From ce090830863f05f06020c76985436e7b3c7e46b4 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Fri, 21 Jun 2024 20:32:18 +0800
Subject: [PATCH 01/22] implement WENO limiter for DG method

---
 include/aspect/parameters.h                   |  42 +-
 .../visualization/kxrcf_indicator.h           |  80 ++
 include/aspect/simulator.h                    |  23 +-
 include/aspect/simulator_access.h             |   8 +
 .../visualization/kxrcf_indicator.cc          | 123 +++
 source/simulator/core.cc                      |  12 +-
 source/simulator/helper_functions.cc          | 243 -----
 source/simulator/limiters.cc                  | 870 ++++++++++++++++++
 source/simulator/parameters.cc                | 121 ++-
 source/simulator/simulator_access.cc          |  13 +
 source/simulator/solver.cc                    |  41 +-
 11 files changed, 1271 insertions(+), 305 deletions(-)
 create mode 100644 include/aspect/postprocess/visualization/kxrcf_indicator.h
 create mode 100644 source/postprocess/visualization/kxrcf_indicator.cc
 create mode 100644 source/simulator/limiters.cc

diff --git a/include/aspect/parameters.h b/include/aspect/parameters.h
index 201fb425efa..f4205dc8d1b 100644
--- a/include/aspect/parameters.h
+++ b/include/aspect/parameters.h
@@ -313,6 +313,41 @@ namespace aspect
       }
     };
 
+    /**
+     * A struct to provide the different choices of limiters for
+     * the discontinuous Galerkin method.
+     */
+    struct DGLimiterType
+    {
+      enum Kind
+      {
+        boundary_preserving,
+        WENO,
+        none
+      };
+
+      static
+      Kind
+      parse(const std::string &input)
+      {
+        if (input == "boundary preserving")
+          return boundary_preserving;
+        else if (input == "WENO")
+          return WENO;
+        else if (input == "none")
+          return none;
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        return Kind();
+      }
+
+      static const std::string pattern()
+      {
+        return "boundary preserving|WENO|none";
+      }
+    };
+
     /**
      * This enum represents the different choices for the linear solver
      * for the Stoke system. See @p stokes_solver_type.
@@ -656,12 +691,15 @@ namespace aspect
     std::vector<double>            stabilization_beta;
     double                         stabilization_gamma;
     double                         discontinuous_penalty;
-    bool                           use_limiter_for_discontinuous_temperature_solution;
-    std::vector<bool>              use_limiter_for_discontinuous_composition_solution;
+    typename DGLimiterType::Kind   limiter_for_discontinuous_temperature_solution;
+    std::vector<typename DGLimiterType::Kind> limiter_for_discontinuous_composition_solution;
     double                         global_temperature_max_preset;
     double                         global_temperature_min_preset;
     std::vector<double>            global_composition_max_preset;
     std::vector<double>            global_composition_min_preset;
+    double                         temperature_KXRCF_indicator_threshold;
+    std::vector<double>            composition_KXRCF_indicator_threshold;
+    double                         WENO_linear_weight;
 
     std::vector<std::string>       compositional_fields_with_disabled_boundary_entropy_viscosity;
     /**
diff --git a/include/aspect/postprocess/visualization/kxrcf_indicator.h b/include/aspect/postprocess/visualization/kxrcf_indicator.h
new file mode 100644
index 00000000000..bcd4022612d
--- /dev/null
+++ b/include/aspect/postprocess/visualization/kxrcf_indicator.h
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_kxrcf_indicator_h
+#define _aspect_postprocess_visualization_kxrcf_indicator_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived that implements a function that provides the
+       * KXRCF indicator for a given advection field on each cell for
+       * graphical output.
+       */
+      template <int dim>
+      class KXRCFIndicator : public CellDataVectorCreator<dim>,
+        public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          KXRCFIndicator();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * A parameter that tells us for which advection field the
+           * KXRCF indicator should be visualized.
+           */
+          unsigned int field_index;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/simulator.h b/include/aspect/simulator.h
index 3df4a6752a9..e21f85c6284 100644
--- a/include/aspect/simulator.h
+++ b/include/aspect/simulator.h
@@ -1373,10 +1373,29 @@ namespace aspect
        * the discontinuous Galerkin solution will stay in the prescribed bounds.
        *
        * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
+       * <code>source/simulator/limiters.cc</code>.
+       */
+      void apply_BP_limiter_to_dg_solutions (const AdvectionField &advection_field);
+
+      /**
+       * Apply the WENO limiter to the discontinuous Galerkin solutions.
+       * The WENO scheme implemented in this function is proposed by Zhong and Shu, 2013.
+       *
+       * This function is implemented in
+       * <code>source/simulator/limiters.cc</code>.
        */
-      void apply_limiter_to_dg_solutions (const AdvectionField &advection_field);
+      void apply_WENO_limiter_to_dg_solutions (const AdvectionField &advection_field);
 
+      /**
+       * Compute the KXRCF indicator that detect shocks in the advection field.
+       * The KXRCF indicator is used by the WENO limiter.
+       *
+       * This function is implemented in
+       * <code>source/simulator/limiters.cc</code>.
+       */
+      template <typename T>
+      void compute_KXRCF_indicators(Vector<T> &KXRCF_indicators,
+                                    const AdvectionField &advection_field) const;
 
       /**
        * Compute the reactions in case of operator splitting:
diff --git a/include/aspect/simulator_access.h b/include/aspect/simulator_access.h
index a65c0cf4879..999a22a6980 100644
--- a/include/aspect/simulator_access.h
+++ b/include/aspect/simulator_access.h
@@ -427,6 +427,14 @@ namespace aspect
       void
       get_artificial_viscosity_composition(Vector<float> &viscosity_per_cell,
                                            const unsigned int compositional_variable) const;
+
+      /**
+       * Compute the KXRCF indicator on each locally owned cell for a specific
+       * advection field.
+       */
+      void
+      compute_KXRCF_indicators(Vector<float> &KXRCF_indicators,
+                               const unsigned int field_index) const;
       /** @} */
 
 
diff --git a/source/postprocess/visualization/kxrcf_indicator.cc b/source/postprocess/visualization/kxrcf_indicator.cc
new file mode 100644
index 00000000000..5403aa477f0
--- /dev/null
+++ b/source/postprocess/visualization/kxrcf_indicator.cc
@@ -0,0 +1,123 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/kxrcf_indicator.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      KXRCFIndicator<dim>::KXRCFIndicator()
+        :
+        CellDataVectorCreator<dim>("")
+      {}
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      KXRCFIndicator<dim>::execute() const
+      {
+        std::pair<std::string, std::unique_ptr<Vector<float>>>
+        return_value ("KXRCF_indicator",
+                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+        this->compute_KXRCF_indicators(*return_value.second, field_index);
+        return return_value;
+      }
+
+
+      template <int dim>
+      void
+      KXRCFIndicator<dim>::declare_parameters(ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("KXRCF indicator");
+            {
+              prm.declare_entry ("Name of advection field", "",
+                                 Patterns::Anything(),
+                                 "The name of the advection field whose output "
+                                 "should be visualized. ");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      KXRCFIndicator<dim>::parse_parameters(ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("KXRCF indicator");
+            {
+              const std::string field_name = prm.get("Name of advection field");
+
+              if (field_name == "temperature")
+                field_index = 0;
+              else
+                {
+                  AssertThrow(this->introspection().compositional_name_exists(field_name),
+                              ExcMessage("No compositional field with name <" +
+                                         field_name +
+                                         "> exists for which you want to visualize the KXRCF indicator."));
+
+                  field_index = this->introspection().compositional_index_for_name(field_name) + 1;
+                }
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(KXRCFIndicator,
+                                                  "kxrcf indicator",
+                                                  "A visualization output object that generates output "
+                                                  "showing the value of the KXRCF indicator on each "
+                                                  "cell."
+                                                  "\n\n"
+                                                  "Physical units: none.")
+    }
+  }
+}
diff --git a/source/simulator/core.cc b/source/simulator/core.cc
index d74c564d1ea..e0226cf8034 100644
--- a/source/simulator/core.cc
+++ b/source/simulator/core.cc
@@ -485,14 +485,16 @@ namespace aspect
     if (MappingQCache<dim> *map = dynamic_cast<MappingQCache<dim>*>(&(*mapping)))
       map->initialize(MappingQGeneric<dim>(4), triangulation);
 
-    bool dg_limiter_enabled = parameters.use_limiter_for_discontinuous_temperature_solution;
+    bool bp_limiter_enabled = (parameters.limiter_for_discontinuous_temperature_solution
+                               == Parameters<dim>::DGLimiterType::boundary_preserving);
     for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-      dg_limiter_enabled = dg_limiter_enabled || parameters.use_limiter_for_discontinuous_composition_solution[c];
+      bp_limiter_enabled = bp_limiter_enabled || (parameters.limiter_for_discontinuous_composition_solution[c]
+                                                  == Parameters<dim>::DGLimiterType::boundary_preserving);
 
-    // Check that DG limiters are only used with cartesian mapping
-    if (dg_limiter_enabled)
+    // Check that BP limiters are only used with cartesian mapping
+    if (bp_limiter_enabled)
       AssertThrow(geometry_model->natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian,
-                  ExcMessage("The limiter for the discontinuous temperature and composition solutions "
+                  ExcMessage("The boundary preserving limiter for the discontinuous temperature and composition solutions "
                              "has not been tested in non-Cartesian geometries and currently requires "
                              "the use of a Cartesian geometry model."));
 
diff --git a/source/simulator/helper_functions.cc b/source/simulator/helper_functions.cc
index 0450a1de14d..bd84cabf160 100644
--- a/source/simulator/helper_functions.cc
+++ b/source/simulator/helper_functions.cc
@@ -1392,248 +1392,6 @@ namespace aspect
 
 
 
-  template <int dim>
-  void Simulator<dim>::apply_limiter_to_dg_solutions (const AdvectionField &advection_field)
-  {
-    // TODO: Modify to more robust method
-    // Skip if this composition field is being set from the volume_of_fluid handler
-    if (!advection_field.is_temperature() &&
-        parameters.volume_of_fluid_tracking_enabled)
-      if (volume_of_fluid_handler->field_index_for_name(introspection.name_for_compositional_index(advection_field.compositional_variable))
-          != volume_of_fluid_handler->get_n_fields())
-        return;
-
-    /*
-     * First setup the quadrature points which are used to find the maximum and minimum solution values at those points.
-     * A quadrature formula that combines all quadrature points constructed as all tensor products of
-     * 1) one dimensional Gauss points; 2) one dimensional Gauss-Lobatto points.
-     * We require that the Gauss-Lobatto points (2) appear in only one direction.
-     * Therefore, possible combination
-     * in 2d: the combinations are 21, 12
-     * in 3d: the combinations are 211, 121, 112
-     */
-    const QGauss<1> quadrature_formula_1 (advection_field.polynomial_degree(introspection)+1);
-    const QGaussLobatto<1> quadrature_formula_2 (advection_field.polynomial_degree(introspection)+1);
-
-    const unsigned int n_q_points_1 = quadrature_formula_1.size();
-    const unsigned int n_q_points_2 = quadrature_formula_2.size();
-    const unsigned int n_q_points   = dim * n_q_points_2 * static_cast<unsigned int>(std::pow(n_q_points_1, dim-1));
-
-    std::vector<Point <dim>> quadrature_points;
-    quadrature_points.reserve(n_q_points);
-
-    switch (dim)
-      {
-        case 2:
-        {
-          // append quadrature points combination 12
-          for (unsigned int i=0; i < n_q_points_1 ; ++i)
-            {
-              const double  x = quadrature_formula_1.point(i)(0);
-              for (unsigned int j=0; j < n_q_points_2 ; ++j)
-                {
-                  const double y = quadrature_formula_2.point(j)(0);
-                  quadrature_points.push_back(Point<dim>(x,y));
-                }
-            }
-          // append quadrature points combination 21
-          for (unsigned int i=0; i < n_q_points_2 ; ++i)
-            {
-              const double  x = quadrature_formula_2.point(i)(0);
-              for (unsigned int j=0; j < n_q_points_1 ; ++j)
-                {
-                  const double y = quadrature_formula_1.point(j)(0);
-                  quadrature_points.push_back(Point<dim>(x,y));
-                }
-            }
-          break;
-        }
-
-        case 3:
-        {
-          // append quadrature points combination 121
-          for ( unsigned int i=0; i < n_q_points_1 ; ++i)
-            {
-              const double x = quadrature_formula_1.point(i)(0);
-              for ( unsigned int j=0; j < n_q_points_2 ; ++j)
-                {
-                  const double y = quadrature_formula_2.point(j)(0);
-                  for ( unsigned int k=0; k < n_q_points_1 ; ++k)
-                    {
-                      const double z = quadrature_formula_1.point(k)(0);
-                      quadrature_points.push_back(Point<dim>(x,y,z));
-                    }
-                }
-            }
-          // append quadrature points combination 112
-          for (unsigned int i=0; i < n_q_points_1 ; ++i)
-            {
-              const double x = quadrature_formula_1.point(i)(0);
-              for (unsigned int j=0; j < n_q_points_1 ; ++j)
-                {
-                  const double y = quadrature_formula_1.point(j)(0);
-                  for (unsigned int k=0; k < n_q_points_2 ; ++k)
-                    {
-                      const double z = quadrature_formula_2.point(k)(0);
-                      quadrature_points.push_back(Point<dim>(x,y,z));
-                    }
-                }
-            }
-          // append quadrature points combination 211
-          for (unsigned int i=0; i < n_q_points_2 ; ++i)
-            {
-              const double x = quadrature_formula_2.point(i)(0);
-              for ( unsigned int j=0; j < n_q_points_1 ; ++j)
-                {
-                  const double y = quadrature_formula_1.point(j)(0);
-                  for ( unsigned int k=0; k < n_q_points_1 ; ++k)
-                    {
-                      const double z = quadrature_formula_1.point(k)(0);
-                      quadrature_points.push_back(Point<dim>(x,y,z));
-                    }
-                }
-            }
-          break;
-        }
-
-        default:
-          Assert (false, ExcNotImplemented());
-      }
-
-    Assert (quadrature_points.size() == n_q_points, ExcInternalError());
-    const Quadrature<dim> quadrature_formula(quadrature_points);
-
-    // Quadrature rules only used for the numerical integration for better accuracy
-    const Quadrature<dim> &quadrature_formula_0
-      = (advection_field.is_temperature() ?
-         introspection.quadratures.temperature :
-         introspection.quadratures.compositional_fields);
-    const unsigned int n_q_points_0 = quadrature_formula_0.size();
-
-    // fe values for points evaluation
-    FEValues<dim> fe_values (*mapping,
-                             finite_element,
-                             quadrature_formula,
-                             update_values   |
-                             update_quadrature_points);
-    std::vector<double> values (n_q_points);
-    // fe values for numerical integration, with a number of quadrature points
-    // that is equal to 1/dim times the number of total points above
-    FEValues<dim> fe_values_0 (*mapping,
-                               finite_element,
-                               quadrature_formula_0,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-    std::vector<double> values_0 (n_q_points_0);
-
-    const FEValuesExtractors::Scalar field
-      = (advection_field.is_temperature()
-         ?
-         introspection.extractors.temperature
-         :
-         introspection.extractors.compositional_fields[advection_field.compositional_variable]
-        );
-
-    const double max_solution_exact_global = (advection_field.is_temperature()
-                                              ?
-                                              parameters.global_temperature_max_preset
-                                              :
-                                              parameters.global_composition_max_preset[advection_field.compositional_variable]
-                                             );
-    const double min_solution_exact_global = (advection_field.is_temperature()
-                                              ?
-                                              parameters.global_temperature_min_preset
-                                              :
-                                              parameters.global_composition_min_preset[advection_field.compositional_variable]
-                                             );
-
-    LinearAlgebra::BlockVector distributed_solution (introspection.index_sets.system_partitioning,
-                                                     mpi_communicator);
-    const unsigned int block_idx = advection_field.block_index(introspection);
-    distributed_solution.block(block_idx) = solution.block(block_idx);
-
-    std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          cell->get_dof_indices (local_dof_indices);
-          // used to find the maximum, minimum
-          fe_values.reinit (cell);
-          fe_values[field].get_function_values(solution, values);
-          // used for the numerical integration
-          fe_values_0.reinit (cell);
-          fe_values_0[field].get_function_values(solution, values_0);
-
-          // Find the local max and local min
-          const double min_solution_local = *std::min_element (values.begin(), values.end());
-          const double max_solution_local = *std::max_element (values.begin(), values.end());
-          // Find the trouble cell
-          if (min_solution_local < min_solution_exact_global
-              || max_solution_local > max_solution_exact_global)
-            {
-              // Compute the cell area and cell solution average
-              double local_area = 0.0;
-              double local_solution_average = 0.0;
-              for (unsigned int q = 0; q < n_q_points_0; ++q)
-                {
-                  local_area += fe_values_0.JxW(q);
-                  local_solution_average += values_0[q]*fe_values_0.JxW(q);
-                }
-              local_solution_average /= local_area;
-
-              /*
-               * Define theta: a scaling constant used to correct the old solution by the formula
-               *   new_value = theta * (old_value-old_solution_cell_average)+old_solution_cell_average
-               * where theta \in [0,1] defined as below.
-               * After the correction, the new solution does not exceed the user-given
-               * exact global maximum/minimum values. Meanwhile, the new solution's cell average
-               * equals to the old solution's cell average.
-               */
-              double theta = 1.0;
-              if (std::abs(max_solution_local-local_solution_average) > std::numeric_limits<double>::min())
-                {
-                  theta = std::min(theta, std::abs((max_solution_exact_global-local_solution_average)
-                                                   / (max_solution_local-local_solution_average)));
-                }
-              if (std::abs(min_solution_local-local_solution_average) > std::numeric_limits<double>::min())
-                {
-                  theta = std::min(theta, std::abs((min_solution_exact_global-local_solution_average)
-                                                   / (min_solution_local-local_solution_average)));
-                }
-
-              /* Modify the advection degrees of freedom of the numerical solution.
-               * Note that we are using DG elements, so every DoF on a locally owned cell is locally owned;
-               * this means that we do not need to check whether the 'distributed_solution' vector actually
-               * stores the element we read from/write to here.
-               */
-              for (unsigned int j = 0;
-                   j < finite_element.base_element(advection_field.base_element(introspection)).dofs_per_cell;
-                   ++j)
-                {
-                  const unsigned int support_point_index = finite_element.component_to_system_index(
-                                                             (advection_field.is_temperature()
-                                                              ?
-                                                              introspection.component_indices.temperature
-                                                              :
-                                                              introspection.component_indices.compositional_fields[advection_field.compositional_variable]
-                                                             ),
-                                                             /*dof index within component=*/ j);
-                  const double solution_value = solution(local_dof_indices[support_point_index]);
-                  const double limited_solution_value = theta * (solution_value-local_solution_average) + local_solution_average;
-                  distributed_solution(local_dof_indices[support_point_index]) = limited_solution_value;
-                }
-            }
-        }
-
-    distributed_solution.compress(VectorOperation::insert);
-    // now get back to the original vector
-    solution.block(block_idx) = distributed_solution.block(block_idx);
-  }
-
-
-
   template <int dim>
   void Simulator<dim>::update_solution_vectors_with_reaction_results (const unsigned int block_index,
                                                                       const LinearAlgebra::BlockVector &distributed_vector,
@@ -2740,7 +2498,6 @@ namespace aspect
   template bool Simulator<dim>::stokes_matrix_depends_on_solution() const; \
   template bool Simulator<dim>::stokes_A_block_is_symmetric() const; \
   template void Simulator<dim>::interpolate_onto_velocity_system(const TensorFunction<1,dim> &func, LinearAlgebra::Vector &vec);\
-  template void Simulator<dim>::apply_limiter_to_dg_solutions(const AdvectionField &advection_field); \
   template void Simulator<dim>::compute_reactions(); \
   template void Simulator<dim>::initialize_current_linearization_point (); \
   template void Simulator<dim>::interpolate_material_output_into_advection_field(const AdvectionField &adv_field); \
diff --git a/source/simulator/limiters.cc b/source/simulator/limiters.cc
new file mode 100644
index 00000000000..eb1ec577785
--- /dev/null
+++ b/source/simulator/limiters.cc
@@ -0,0 +1,870 @@
+#include <aspect/simulator.h>
+
+namespace aspect
+{
+  template <int dim>
+  void
+  Simulator<dim>::apply_BP_limiter_to_dg_solutions(const AdvectionField &advection_field)
+  {
+    // TODO: Modify to more robust method
+    // Skip if this composition field is being set from the volume_of_fluid handler
+    if (!advection_field.is_temperature() &&
+        parameters.volume_of_fluid_tracking_enabled)
+      if (volume_of_fluid_handler->field_index_for_name(introspection.name_for_compositional_index(advection_field.compositional_variable))
+          != volume_of_fluid_handler->get_n_fields())
+        return;
+
+    /*
+     * First setup the quadrature points which are used to find the maximum and minimum solution values at those points.
+     * A quadrature formula that combines all quadrature points constructed as all tensor products of
+     * 1) one dimensional Gauss points; 2) one dimensional Gauss-Lobatto points.
+     * We require that the Gauss-Lobatto points (2) appear in only one direction.
+     * Therefore, possible combination
+     * in 2d: the combinations are 21, 12
+     * in 3d: the combinations are 211, 121, 112
+     */
+    const QGauss<1> quadrature_formula_1 (advection_field.polynomial_degree(introspection)+1);
+    const QGaussLobatto<1> quadrature_formula_2 (advection_field.polynomial_degree(introspection)+1);
+
+    const unsigned int n_q_points_1 = quadrature_formula_1.size();
+    const unsigned int n_q_points_2 = quadrature_formula_2.size();
+    const unsigned int n_q_points   = dim * n_q_points_2 * static_cast<unsigned int>(std::pow(n_q_points_1, dim-1));
+
+    std::vector<Point <dim>> quadrature_points;
+    quadrature_points.reserve(n_q_points);
+
+    switch (dim)
+      {
+        case 2:
+        {
+          // append quadrature points combination 12
+          for (unsigned int i=0; i < n_q_points_1 ; ++i)
+            {
+              const double  x = quadrature_formula_1.point(i)(0);
+              for (unsigned int j=0; j < n_q_points_2 ; ++j)
+                {
+                  const double y = quadrature_formula_2.point(j)(0);
+                  quadrature_points.push_back(Point<dim>(x,y));
+                }
+            }
+          // append quadrature points combination 21
+          for (unsigned int i=0; i < n_q_points_2 ; ++i)
+            {
+              const double  x = quadrature_formula_2.point(i)(0);
+              for (unsigned int j=0; j < n_q_points_1 ; ++j)
+                {
+                  const double y = quadrature_formula_1.point(j)(0);
+                  quadrature_points.push_back(Point<dim>(x,y));
+                }
+            }
+          break;
+        }
+
+        case 3:
+        {
+          // append quadrature points combination 121
+          for ( unsigned int i=0; i < n_q_points_1 ; ++i)
+            {
+              const double x = quadrature_formula_1.point(i)(0);
+              for ( unsigned int j=0; j < n_q_points_2 ; ++j)
+                {
+                  const double y = quadrature_formula_2.point(j)(0);
+                  for ( unsigned int k=0; k < n_q_points_1 ; ++k)
+                    {
+                      const double z = quadrature_formula_1.point(k)(0);
+                      quadrature_points.push_back(Point<dim>(x,y,z));
+                    }
+                }
+            }
+          // append quadrature points combination 112
+          for (unsigned int i=0; i < n_q_points_1 ; ++i)
+            {
+              const double x = quadrature_formula_1.point(i)(0);
+              for (unsigned int j=0; j < n_q_points_1 ; ++j)
+                {
+                  const double y = quadrature_formula_1.point(j)(0);
+                  for (unsigned int k=0; k < n_q_points_2 ; ++k)
+                    {
+                      const double z = quadrature_formula_2.point(k)(0);
+                      quadrature_points.push_back(Point<dim>(x,y,z));
+                    }
+                }
+            }
+          // append quadrature points combination 211
+          for (unsigned int i=0; i < n_q_points_2 ; ++i)
+            {
+              const double x = quadrature_formula_2.point(i)(0);
+              for ( unsigned int j=0; j < n_q_points_1 ; ++j)
+                {
+                  const double y = quadrature_formula_1.point(j)(0);
+                  for ( unsigned int k=0; k < n_q_points_1 ; ++k)
+                    {
+                      const double z = quadrature_formula_1.point(k)(0);
+                      quadrature_points.push_back(Point<dim>(x,y,z));
+                    }
+                }
+            }
+          break;
+        }
+
+        default:
+          Assert (false, ExcNotImplemented());
+      }
+
+    Assert (quadrature_points.size() == n_q_points, ExcInternalError());
+    const Quadrature<dim> quadrature_formula(quadrature_points);
+
+    // Quadrature rules only used for the numerical integration for better accuracy
+    const Quadrature<dim> &quadrature_formula_0
+      = (advection_field.is_temperature() ?
+         introspection.quadratures.temperature :
+         introspection.quadratures.compositional_fields);
+    const unsigned int n_q_points_0 = quadrature_formula_0.size();
+
+    // fe values for points evaluation
+    FEValues<dim> fe_values (*mapping,
+                             finite_element,
+                             quadrature_formula,
+                             update_values   |
+                             update_quadrature_points);
+    std::vector<double> values (n_q_points);
+    // fe values for numerical integration, with a number of quadrature points
+    // that is equal to 1/dim times the number of total points above
+    FEValues<dim> fe_values_0 (*mapping,
+                               finite_element,
+                               quadrature_formula_0,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+    std::vector<double> values_0 (n_q_points_0);
+
+    const FEValuesExtractors::Scalar field
+      = (advection_field.is_temperature()
+         ?
+         introspection.extractors.temperature
+         :
+         introspection.extractors.compositional_fields[advection_field.compositional_variable]
+        );
+
+    const double max_solution_exact_global = (advection_field.is_temperature()
+                                              ?
+                                              parameters.global_temperature_max_preset
+                                              :
+                                              parameters.global_composition_max_preset[advection_field.compositional_variable]
+                                             );
+    const double min_solution_exact_global = (advection_field.is_temperature()
+                                              ?
+                                              parameters.global_temperature_min_preset
+                                              :
+                                              parameters.global_composition_min_preset[advection_field.compositional_variable]
+                                             );
+
+    LinearAlgebra::BlockVector distributed_solution (introspection.index_sets.system_partitioning,
+                                                     mpi_communicator);
+    const unsigned int block_idx = advection_field.block_index(introspection);
+    distributed_solution.block(block_idx) = solution.block(block_idx);
+
+    std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          cell->get_dof_indices (local_dof_indices);
+          // used to find the maximum, minimum
+          fe_values.reinit (cell);
+          fe_values[field].get_function_values(solution, values);
+          // used for the numerical integration
+          fe_values_0.reinit (cell);
+          fe_values_0[field].get_function_values(solution, values_0);
+
+          // Find the local max and local min
+          const double min_solution_local = *std::min_element (values.begin(), values.end());
+          const double max_solution_local = *std::max_element (values.begin(), values.end());
+          // Find the trouble cell
+          if (min_solution_local < min_solution_exact_global
+              || max_solution_local > max_solution_exact_global)
+            {
+              // Compute the cell area and cell solution average
+              double local_area = 0.0;
+              double local_solution_average = 0.0;
+              for (unsigned int q = 0; q < n_q_points_0; ++q)
+                {
+                  local_area += fe_values_0.JxW(q);
+                  local_solution_average += values_0[q]*fe_values_0.JxW(q);
+                }
+              local_solution_average /= local_area;
+
+              /*
+               * Define theta: a scaling constant used to correct the old solution by the formula
+               *   new_value = theta * (old_value-old_solution_cell_average)+old_solution_cell_average
+               * where theta \in [0,1] defined as below.
+               * After the correction, the new solution does not exceed the user-given
+               * exact global maximum/minimum values. Meanwhile, the new solution's cell average
+               * equals to the old solution's cell average.
+               */
+              double theta = 1.0;
+              if (std::abs(max_solution_local-local_solution_average) > std::numeric_limits<double>::min())
+                {
+                  theta = std::min(theta, std::abs((max_solution_exact_global-local_solution_average)
+                                                   / (max_solution_local-local_solution_average)));
+                }
+              if (std::abs(min_solution_local-local_solution_average) > std::numeric_limits<double>::min())
+                {
+                  theta = std::min(theta, std::abs((min_solution_exact_global-local_solution_average)
+                                                   / (min_solution_local-local_solution_average)));
+                }
+
+              /* Modify the advection degrees of freedom of the numerical solution.
+               * Note that we are using DG elements, so every DoF on a locally owned cell is locally owned;
+               * this means that we do not need to check whether the 'distributed_solution' vector actually
+               * stores the element we read from/write to here.
+               */
+              for (unsigned int j = 0;
+                   j < finite_element.base_element(advection_field.base_element(introspection)).dofs_per_cell;
+                   ++j)
+                {
+                  const unsigned int support_point_index = finite_element.component_to_system_index(
+                                                             (advection_field.is_temperature()
+                                                              ?
+                                                              introspection.component_indices.temperature
+                                                              :
+                                                              introspection.component_indices.compositional_fields[advection_field.compositional_variable]
+                                                             ),
+                                                             /*dof index within component=*/ j);
+                  const double solution_value = solution(local_dof_indices[support_point_index]);
+                  const double limited_solution_value = theta * (solution_value-local_solution_average) + local_solution_average;
+                  distributed_solution(local_dof_indices[support_point_index]) = limited_solution_value;
+                }
+            }
+        }
+
+    distributed_solution.compress(VectorOperation::insert);
+    // now get back to the original vector
+    solution.block(block_idx) = distributed_solution.block(block_idx);
+  }
+
+
+
+  namespace internal
+  {
+    struct KXRCFCellData
+    {
+      double cell_norm;
+      double inflow_face_jump;
+      double inflow_face_area;
+
+      KXRCFCellData()
+        : cell_norm(0.0)
+        , inflow_face_jump(0.0)
+        , inflow_face_area(0.0)
+      {}
+    };
+  }
+
+
+  template <int dim>
+  template <typename T>
+  void
+  Simulator<dim>::compute_KXRCF_indicators(Vector<T>            &KXRCF_indicators,
+                                           const AdvectionField &advection_field) const
+  {
+    // stuff for computing the integrals in cells and cell faces
+    QGauss<dim>   quadrature(2);
+    QGauss<dim-1> face_quadrature(2);
+
+    FEValues<dim> fe_values(*mapping,
+                            finite_element,
+                            quadrature,
+                            update_values);
+
+    FEFaceValues<dim> fe_face_values(*mapping,
+                                     finite_element,
+                                     face_quadrature,
+                                     update_values |
+                                     update_normal_vectors |
+                                     update_JxW_values);
+
+    FESubfaceValues<dim> fe_subface_values(*mapping,
+                                           finite_element,
+                                           face_quadrature,
+                                           update_values |
+                                           update_normal_vectors |
+                                           update_JxW_values);
+
+    FEFaceValues<dim> neighbor_fe_face_values(*mapping,
+                                              finite_element,
+                                              face_quadrature,
+                                              update_values |
+                                              update_JxW_values);
+
+    const FEValuesExtractors::Scalar &field_extractor = advection_field.scalar_extractor(introspection);
+
+    const unsigned int n_q_points      = fe_values.n_quadrature_points;
+    const unsigned int n_face_q_points = fe_face_values.n_quadrature_points;
+
+    std::vector<double> field_values(n_q_points);
+    std::vector<double> face_field_values(n_face_q_points);
+    std::vector<double> neighbor_face_field_values(n_face_q_points);
+
+    std::vector<Tensor<1,dim>> face_velocity_values(n_face_q_points);
+    std::vector<Tensor<1,dim>> face_mesh_velocity_values(n_face_q_points);
+
+    // KXRCF indicator requires the computation of (1) cell maximum norm;
+    // (2) integration of the jump over inflow faces of each field. To
+    // avoid doing integration twice on each cell face, we set up a map
+    // to store the cell data and then loop over the cells using the same
+    // strategy as in Assemblers::AdvectionSystemInteriorFace::execute().
+    std::map<unsigned int, internal::KXRCFCellData> data;
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        data.insert(std::make_pair(cell->active_cell_index(),
+                                   internal::KXRCFCellData()));
+
+    // Now loop over locally owned cells and compute the maximum norm
+    // and the jump over inflow faces.
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          auto cell_data = data.find(cell->active_cell_index());
+
+          // Compute the maximum norm of field values in this cell.
+          fe_values.reinit(cell);
+          fe_values[field_extractor].get_function_values(solution, field_values);
+
+          double cell_norm = 0.0;
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            cell_norm = std::max(cell_norm, std::abs(field_values[q]));
+
+          cell_data->second.cell_norm = cell_norm;
+
+          // Compute the jump of field values over inflow faces.
+          for (const unsigned int face_no : cell->face_indices())
+            {
+              if (!cell->at_boundary(face_no) || cell->has_periodic_neighbor(face_no))
+                {
+                  const typename DoFHandler<dim>::cell_iterator
+                  neighbor = cell->neighbor_or_periodic_neighbor(face_no);
+
+                  const bool cell_has_periodic_neighbor = cell->has_periodic_neighbor(face_no);
+
+                  // 'neighbor' defined above is NOT active_cell_iterator, this includes cells
+                  // that are refined
+                  if (!neighbor->has_children())
+                    {
+                      if (neighbor->level() == cell->level() &&
+                          neighbor->is_active() &&
+                          (((neighbor->is_locally_owned()) && (cell->index() < neighbor->index()))
+                           ||
+                           ((!neighbor->is_locally_owned()) && (cell->subdomain_id() < neighbor->subdomain_id()))))
+                        {
+                          // cell and neighbor are equal-sized, and cell has been chosen to
+                          // assemble this face, so calculate from cell
+                          const unsigned int neighbor2 =
+                            (cell_has_periodic_neighbor
+                             ?
+                             cell->periodic_neighbor_of_periodic_neighbor(face_no)
+                             :
+                             cell->neighbor_of_neighbor(face_no));
+
+                          auto neighbor_data = data.find(neighbor->active_cell_index());
+
+                          // Set up face values.
+                          fe_face_values.reinit(cell, face_no);
+                          fe_face_values[field_extractor].get_function_values(solution, face_field_values);
+
+                          fe_face_values[introspection.extractors.velocities].get_function_values(
+                            solution, face_velocity_values);
+                          if (parameters.mesh_deformation_enabled)
+                            fe_face_values[introspection.extractors.velocities].get_function_values(
+                              mesh_deformation->mesh_velocity, face_mesh_velocity_values);
+
+                          // Set up neighbor face values.
+                          neighbor_fe_face_values.reinit(neighbor, neighbor2);
+                          neighbor_fe_face_values[field_extractor].get_function_values(solution, neighbor_face_field_values);
+
+                          const double face_area = cell->face(face_no)->measure();
+
+                          double v_n = 0.0;
+                          double face_jump = 0.0;
+                          for (unsigned int q = 0; q < n_face_q_points; ++q)
+                            {
+                              Tensor<1,dim> current_u = face_velocity_values[q];
+                              if (parameters.mesh_deformation_enabled)
+                                current_u -= face_mesh_velocity_values[q];
+
+                              v_n += (current_u * fe_face_values.normal_vector(q)) * fe_face_values.JxW(q);
+
+                              face_jump += (face_field_values[q] - neighbor_face_field_values[q]) * fe_face_values.JxW(q);
+                            }
+
+                          if (v_n < 0.0) // inflow
+                            {
+                              cell_data->second.inflow_face_jump += face_jump;
+                              cell_data->second.inflow_face_area += face_area;
+                            }
+                          else // outflow
+                            {
+                              if (neighbor_data != data.end())
+                                {
+                                  neighbor_data->second.inflow_face_jump -= face_jump;
+                                  neighbor_data->second.inflow_face_area += face_area;
+                                }
+                            }
+
+                        }
+                      else
+                        {
+                          // Neighbor is taking responsibility for assembly of this face, bacause
+                          // either (1) neighbor is coarser, or
+                          //        (2) neighbor is equally-sized and
+                          //           (a) neighbor is on a different subdomain, with lower subdomain_id(), or
+                          //           (b) nieghbor is on the same subdomain and has lower index().
+                        }
+                    }
+                  else
+                    {
+                      // Neighbor has children, so always assemble from here.
+                      const unsigned int neighbor2 =
+                        (cell_has_periodic_neighbor
+                         ?
+                         cell->periodic_neighbor_face_no(face_no)
+                         :
+                         cell->neighbor_face_no(face_no));
+
+                      // Loop over subfaces. We know that the neighbor is finer, so we could loop over the subfaces of the current
+                      // face. but if we are at a periodic boundary, then the face of the current cell has no children, so instead use
+                      // the children of the periodic neighbor's corresponding face since we know that the letter does indeed have
+                      // children (because we know that the neighbor is refined).
+                      typename DoFHandler<dim>::face_iterator neighbor_face = neighbor->face(neighbor2);
+                      for (unsigned int subface_no = 0; subface_no < neighbor_face->n_children(); ++subface_no)
+                        {
+                          const typename DoFHandler<dim>::active_cell_iterator neighbor_child =
+                            (cell_has_periodic_neighbor
+                             ?
+                             cell->periodic_neighbor_child_on_subface(face_no, subface_no)
+                             :
+                             cell->neighbor_child_on_subface(face_no, subface_no));
+
+                          auto neighbor_data = data.find(neighbor_child->active_cell_index());
+
+                          // Set up subface values.
+                          fe_subface_values.reinit(cell, face_no, subface_no);
+                          fe_subface_values[field_extractor].get_function_values(solution, face_field_values);
+
+                          fe_subface_values[introspection.extractors.velocities].get_function_values(
+                            solution, face_velocity_values);
+                          if (parameters.mesh_deformation_enabled)
+                            fe_subface_values[introspection.extractors.velocities].get_function_values(
+                              mesh_deformation->mesh_velocity, face_mesh_velocity_values);
+
+                          neighbor_fe_face_values.reinit(neighbor_child, neighbor2);
+                          neighbor_fe_face_values[field_extractor].get_function_values(solution, neighbor_face_field_values);
+
+                          const double face_area = neighbor_child->face(neighbor2)->measure();
+
+                          double v_n = 0.0;
+                          double face_jump = 0.0;
+                          for (unsigned int q = 0; q < n_face_q_points; ++q)
+                            {
+                              Tensor<1,dim> current_u = face_velocity_values[q];
+                              if (parameters.mesh_deformation_enabled)
+                                current_u -= face_mesh_velocity_values[q];
+
+                              v_n += (current_u * fe_subface_values.normal_vector(q)) * fe_subface_values.JxW(q);
+
+                              face_jump += (face_field_values[q] - neighbor_face_field_values[q]) * fe_subface_values.JxW(q);
+                            }
+
+                          if (v_n < 0.0) // inflow
+                            {
+                              cell_data->second.inflow_face_jump += face_jump;
+                              cell_data->second.inflow_face_area += face_area;
+                            }
+                          else // outflow
+                            {
+                              if (neighbor_data != data.end())
+                                {
+                                  neighbor_data->second.inflow_face_jump -= face_jump;
+                                  neighbor_data->second.inflow_face_area += face_area;
+                                }
+                            }
+                        }
+                    }
+                }
+              else
+                {
+                  // The current face is a boundary face.
+                }
+            }
+        }
+
+    // Finally, compute the KXRCF indicator and pick the largest one as
+    // troubled cell indicator.
+    const unsigned int degree = advection_field.polynomial_degree(introspection);
+    const double power = (degree + 1.0) / 2.0;
+
+    const unsigned int block_idx = advection_field.block_index(introspection);
+    const double epsilon = std::max(1e-20,
+                                    1e-3 * (solution.block(block_idx).max() - solution.block(block_idx).min()));
+
+    KXRCF_indicators.reinit(triangulation.n_active_cells());
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          const double h_pow = std::pow(cell->diameter(), power);
+          const auto cell_data = data.find(cell->active_cell_index());
+          if (cell_data->second.inflow_face_area == 0.0)
+            KXRCF_indicators[cell->active_cell_index()] = 0.0;
+          else
+            KXRCF_indicators[cell->active_cell_index()] =
+              std::abs(cell_data->second.inflow_face_jump) /
+              (h_pow * cell_data->second.inflow_face_area * (cell_data->second.cell_norm + epsilon));
+        }
+  }
+
+
+  template <int dim>
+  void
+  Simulator<dim>::apply_WENO_limiter_to_dg_solutions(const AdvectionField &advection_field)
+  {
+    // Skip if this composition field is being set from the volume_of_fluid handler
+    if (!advection_field.is_temperature() &&
+        parameters.volume_of_fluid_tracking_enabled)
+      if (volume_of_fluid_handler->field_index_for_name(introspection.name_for_compositional_index(advection_field.compositional_variable))
+          != volume_of_fluid_handler->get_n_fields())
+        return;
+
+    const unsigned int degree = advection_field.polynomial_degree(introspection);
+    AssertThrow(degree < 3,
+                ExcMessage("Currently, WENO limiter has only been implemented for "
+                           "advection fields with polynomial degree 1 or 2."));
+
+    // We need two objects of FEValues in the following computation:
+    // fe_values: computes the cell average and smoothness indicator of the target cell,
+    //   and provides the coordinates and JxWs of the quadrature points of the target
+    //   cell when computing the smoothness indicators of neighbor cells;
+    // neighbor_fe_values: computes the cell averages and field derivatives of
+    //   neighbor cells at quadrature points of the target cell. With the derivatives
+    //   at hand, we can use the JxWs provided by fe_values to compute the smoothness
+    //   indicators of neighbor cells.
+    // The coordinates of quadrature points of neighbor_fe_values change from cell to
+    // cell since the mesh may not be Cartesian, hence neighbor_fe_values has to be
+    // reconstructed in each cell.
+    Quadrature<dim> quadrature(advection_field.is_temperature() ?
+                               introspection.quadratures.temperature :
+                               introspection.quadratures.compositional_fields);
+
+    UpdateFlags update_flags = update_values | update_gradients |
+                               update_quadrature_points | update_JxW_values |
+                               (degree > 1 ? update_hessians : update_default);
+
+    UpdateFlags neighbor_update_flags = update_values | update_gradients |
+                                        (degree > 1 ? update_hessians : update_default);
+
+    FEValues<dim> fe_values(*mapping, finite_element, quadrature, update_flags);
+
+    const unsigned int n_q_points          = fe_values.n_quadrature_points;
+    const unsigned int field_dofs_per_cell = finite_element.base_element(advection_field.base_element(introspection)).dofs_per_cell;
+    const unsigned int field_component     = advection_field.component_index(introspection);
+
+    const FEValuesExtractors::Scalar &field_extractor = advection_field.scalar_extractor(introspection);
+
+    std::vector<double>        field_values(n_q_points);
+    std::vector<Tensor<1,dim>> field_gradients(n_q_points);
+    std::vector<Tensor<2,dim>> field_hessians(n_q_points);
+
+    std::vector<Point<dim>> neighbor_quadrature_points(n_q_points);
+
+    std::vector<double> reconstructed_values(n_q_points);
+
+    std::vector<double> cell_averages;
+    std::vector<double> smoothness_indicators;
+    std::vector<double> linear_weights;
+    std::vector<double> nonlinear_weights;
+    std::vector<std::vector<double>> field_values_in_target_cell;
+
+    // stuff for projecting the reconstructed polynomial onto grid nodes
+    FullMatrix<double> cell_matrix(field_dofs_per_cell, field_dofs_per_cell);
+    Vector<double> cell_rhs(field_dofs_per_cell);
+    Vector<double> cell_solution(field_dofs_per_cell);
+    std::vector<double> phi_field(field_dofs_per_cell);
+    std::vector<types::global_dof_index> cell_dof_indices(finite_element.dofs_per_cell);
+
+    // Detect troubled cells with KXRCF indicator.
+    Vector<double> KXRCF_indicators;
+    compute_KXRCF_indicators(KXRCF_indicators, advection_field);
+
+    TrilinosWrappers::MPI::BlockVector distributed_solution(introspection.index_sets.system_partitioning,
+                                                            mpi_communicator);
+
+    const unsigned int block_idx = advection_field.block_index(introspection);
+    distributed_solution.block(block_idx) = solution.block(block_idx);
+
+    const double KXRCF_indicator_threshold = (advection_field.is_temperature() ?
+                                              parameters.temperature_KXRCF_indicator_threshold :
+                                              parameters.composition_KXRCF_indicator_threshold[advection_field.compositional_variable]);
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          // If the KXRCF indicator of the present cell is lower than the threshold,
+          // then we do not have to do WENO reconstruction for the cell.
+          if (KXRCF_indicators[cell->active_cell_index()] < KXRCF_indicator_threshold)
+            continue;
+
+          cell_averages.clear();
+          smoothness_indicators.clear();
+          field_values_in_target_cell.clear();
+          linear_weights.clear();
+
+          // Compute the field values and derivatives at quadrature points.
+          fe_values.reinit(cell);
+          fe_values[field_extractor].get_function_values(solution, field_values);
+          fe_values[field_extractor].get_function_gradients(solution, field_gradients);
+          if (degree > 1)
+            fe_values[field_extractor].get_function_hessians(solution, field_hessians);
+
+          // Compute the cell average and the smoothness indicator.
+          double cell_measure                   = 0.0;
+          double field_integral                 = 0.0;
+          double field_gradient_square_integral = 0.0;
+          double field_hessian_square_integral  = 0.0;
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            {
+              cell_measure += fe_values.JxW(q);
+              field_integral += field_values[q] * fe_values.JxW(q);
+
+              field_gradient_square_integral += field_gradients[q].norm_square() * fe_values.JxW(q);
+              if (degree > 1)
+                field_hessian_square_integral += field_hessians[q].norm_square() * fe_values.JxW(q);
+            }
+
+          double beta = field_gradient_square_integral;
+          if (degree > 1)
+            beta += field_hessian_square_integral * cell_measure;
+
+          cell_averages.push_back(field_integral / cell_measure);
+          smoothness_indicators.push_back(beta);
+          field_values_in_target_cell.push_back(field_values);
+          // Linear weight of the target cell cannot be determined at present time
+          // (because we don't know how many neighbors the target cell has). Fill in
+          // the position with an invalid value.
+          linear_weights.push_back(numbers::signaling_nan<double>());
+
+          // Loop over the neighbor cells.
+          for (const unsigned int face_no : cell->face_indices())
+            {
+              if (cell->face(face_no)->at_boundary())
+                continue;
+
+              const typename DoFHandler<dim>::cell_iterator
+              neighbor = cell->neighbor_or_periodic_neighbor(face_no);
+
+              // 'neighbor' defined above is NOT active_cell_iterator, this includes cells
+              // that are refined
+              if (!neighbor->has_children())
+                {
+                  // Compute the field values at quadrature points of the neighbor.
+
+                  // Compute the field derivatives at quadrature points of the target cell.
+                  // To do so, we need to transform the quadrature points of the target cell
+                  // to the 'unit cell' defined by the neighbor.
+                  mapping->transform_points_real_to_unit_cell(neighbor,
+                                                              fe_values.get_quadrature_points(),
+                                                              neighbor_quadrature_points);
+
+                  Quadrature<dim> neighbor_quadrature(neighbor_quadrature_points,
+                                                      quadrature.get_weights());
+
+                  FEValues<dim> neighbor_fe_values(*mapping,
+                                                   finite_element,
+                                                   neighbor_quadrature,
+                                                   neighbor_update_flags);
+
+                  neighbor_fe_values.reinit(neighbor);
+                  neighbor_fe_values[field_extractor].get_function_values(solution, field_values);
+                  neighbor_fe_values[field_extractor].get_function_gradients(solution, field_gradients);
+                  if (degree > 1)
+                    neighbor_fe_values[field_extractor].get_function_hessians(solution, field_hessians);
+
+                  // Compute the cell average and the smoothness indicator.
+                  double field_integral                 = 0.0;
+                  double field_gradient_square_integral = 0.0;
+                  double field_hessian_square_integral  = 0.0;
+                  for (unsigned int q = 0; q < n_q_points; ++q)
+                    {
+                      field_integral += field_values[q] * fe_values.JxW(q);
+                      field_gradient_square_integral += field_gradients[q].norm_square() * fe_values.JxW(q);
+                      if (degree > 1)
+                        field_hessian_square_integral += field_hessians[q].norm_square() * fe_values.JxW(q);
+                    }
+
+                  double beta = field_gradient_square_integral;
+                  if (degree > 1)
+                    beta += field_hessian_square_integral * cell_measure;
+
+                  cell_averages.push_back(field_integral / cell_measure);
+                  smoothness_indicators.push_back(beta);
+                  field_values_in_target_cell.push_back(field_values);
+                  linear_weights.push_back(parameters.WENO_linear_weight);
+                }
+              else
+                {
+                  // Neighbor has children. We use a half of the children that are adjacent to
+                  // the target cell (i.e., children that share a face with the target cell) to
+                  // compute the cell average and smoothness indicator.
+                  const unsigned int neighbor_face_no =
+                    (cell->has_periodic_neighbor(face_no)
+                     ?
+                     cell->periodic_neighbor_face_no(face_no)
+                     :
+                     cell->neighbor_face_no(face_no));
+
+                  typename DoFHandler<dim>::face_iterator neighbor_face = neighbor->face(neighbor_face_no);
+                  for (unsigned int subface_no = 0; subface_no < neighbor_face->n_children(); ++subface_no)
+                    {
+                      const unsigned int child_no =
+                        GeometryInfo<dim>::child_cell_on_face(RefinementCase<dim>::isotropic_refinement,
+                                                              neighbor_face_no,
+                                                              subface_no,
+                                                              neighbor->face_orientation(face_no),
+                                                              neighbor->face_flip(face_no),
+                                                              neighbor->face_rotation(face_no));
+
+                      typename DoFHandler<dim>::active_cell_iterator
+                      neighbor_child = neighbor->child(child_no);
+
+                      // Compute the field derivatives at quadrature points of the target cell.
+                      // To do so, we need to transform the quadrature points of the target cell
+                      // to the 'unit cell' defined by the neighbor.
+                      mapping->transform_points_real_to_unit_cell(neighbor_child,
+                                                                  fe_values.get_quadrature_points(),
+                                                                  neighbor_quadrature_points);
+
+                      Quadrature<dim> neighbor_quadrature(neighbor_quadrature_points,
+                                                          quadrature.get_weights());
+
+                      FEValues<dim> neighbor_fe_values(*mapping,
+                                                       finite_element,
+                                                       neighbor_quadrature,
+                                                       neighbor_update_flags);
+
+                      neighbor_fe_values.reinit(neighbor_child);
+                      neighbor_fe_values[field_extractor].get_function_values(solution, field_values);
+                      neighbor_fe_values[field_extractor].get_function_gradients(solution, field_gradients);
+                      if (degree > 1)
+                        neighbor_fe_values[field_extractor].get_function_hessians(solution, field_hessians);
+
+                      // Compute the cell average and the smoothness indicator.
+                      double field_integral                 = 0.0;
+                      double field_gradient_square_integral = 0.0;
+                      double field_hessian_square_integral  = 0.0;
+                      for (unsigned int q = 0; q < n_q_points; ++q)
+                        {
+                          field_integral += field_values[q] * fe_values.JxW(q);
+                          field_gradient_square_integral += field_gradients[q].norm_square() * fe_values.JxW(q);
+                          if (degree > 1)
+                            field_hessian_square_integral += field_hessians[q].norm_square() * fe_values.JxW(q);
+                        }
+
+                      double beta = field_gradient_square_integral;
+                      if (degree > 1)
+                        beta += field_hessian_square_integral * cell_measure;
+
+                      cell_averages.push_back(field_integral / cell_measure);
+                      smoothness_indicators.push_back(beta);
+                      field_values_in_target_cell.push_back(field_values);
+                      linear_weights.push_back(parameters.WENO_linear_weight / neighbor_face->n_children());
+                    }
+                }
+            }
+
+          // Compute the linear weights of the target cell.
+          linear_weights[0] = 1.0;
+          for (unsigned int i = 1; i < linear_weights.size(); ++i)
+            linear_weights[0] -= linear_weights[i];
+
+          // Compute the nonlinear weights.
+          const double epsilon = 1e-6 * std::accumulate(smoothness_indicators.begin(),
+                                                        smoothness_indicators.end(),
+                                                        0.0);
+          nonlinear_weights.clear();
+          for (unsigned int i = 0; i < linear_weights.size(); ++i)
+            nonlinear_weights.push_back(linear_weights[i] /
+                                        Utilities::fixed_power<2,double>(smoothness_indicators[i] + epsilon));
+
+          // Normalize the nonlinear weights.
+          const double sum = std::accumulate(nonlinear_weights.begin(),
+                                             nonlinear_weights.end(),
+                                             0.0);
+
+          for (unsigned int i = 0; i < nonlinear_weights.size(); ++i)
+            nonlinear_weights[i] /= sum;
+
+          // Compute the values of the reconstructed polynomial at quadrature points.
+          std::fill(reconstructed_values.begin(), reconstructed_values.end(), 0.0);
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            for (unsigned int i = 0; i < nonlinear_weights.size(); ++i)
+              reconstructed_values[q] += (field_values_in_target_cell[i][q] - cell_averages[i] + cell_averages[0]) * nonlinear_weights[i];
+
+          // Project the reconstructed polynomial onto grid nodes.
+          cell_matrix = 0;
+          cell_rhs = 0;
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            {
+              for (unsigned int i = 0, i_field = 0; i_field < field_dofs_per_cell; /*increment at end of loop*/)
+                {
+                  if (finite_element.system_to_component_index(i).first == field_component)
+                    {
+                      phi_field[i_field] = fe_values[field_extractor].value(i, q);
+                      ++i_field;
+                    }
+                  ++i;
+                }
+
+              for (unsigned int i = 0; i < field_dofs_per_cell; ++i)
+                {
+                  cell_rhs(i) += phi_field[i] * reconstructed_values[q] * fe_values.JxW(q);
+
+                  for (unsigned int j = 0; j < field_dofs_per_cell; ++j)
+                    cell_matrix(i, j) += phi_field[i] * phi_field[j] * fe_values.JxW(q);
+                }
+            }
+
+          cell_matrix.gauss_jordan();
+          cell_matrix.vmult(cell_solution, cell_rhs);
+
+          // Copy the results to the distributed solution vector.
+          cell->get_dof_indices(cell_dof_indices);
+          for (unsigned int i = 0, i_field = 0; i_field < field_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (finite_element.system_to_component_index(i).first == field_component)
+                {
+                  distributed_solution[cell_dof_indices[i]] = cell_solution(i_field);
+                  ++i_field;
+                }
+              ++i;
+            }
+        }
+
+    // Update the solution vector.
+    distributed_solution.compress(VectorOperation::insert);
+    solution.block(block_idx) = distributed_solution.block(block_idx);
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+
+#define INSTANTIATE(dim) \
+  template void Simulator<dim>::apply_BP_limiter_to_dg_solutions(const AdvectionField &advection_field); \
+  template void Simulator<dim>::compute_KXRCF_indicators(Vector<double> &, \
+                                                         const AdvectionField &) const; \
+  template void Simulator<dim>::compute_KXRCF_indicators(Vector<float> &, \
+                                                         const AdvectionField &) const; \
+  template void Simulator<dim>::apply_WENO_limiter_to_dg_solutions(const AdvectionField &advection_field);
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/parameters.cc b/source/simulator/parameters.cc
index 630301c8fce..465a60ae821 100644
--- a/source/simulator/parameters.cc
+++ b/source/simulator/parameters.cc
@@ -1139,47 +1139,51 @@ namespace aspect
                            "is largely empirically decided -- it must be large enough to ensure "
                            "the bilinear form is coercive, but not so large as to penalize "
                            "discontinuity at all costs.");
-        prm.declare_entry ("Use limiter for discontinuous temperature solution", "false",
-                           Patterns::Bool (),
-                           "Whether to apply the bound preserving limiter as a correction after computing "
-                           "the discontinuous temperature solution. The limiter will only have an "
-                           "effect if the 'Global temperature maximum' and "
-                           "'Global temperature minimum' parameters are defined in the .prm file. "
-                           "This limiter keeps the discontinuous solution in the range given by "
-                           "'Global temperature maximum' and 'Global temperature minimum'. "
-                           "Because this limiter modifies the solution it no longer "
-                           "satisfies the assembled equation. Therefore, "
-                           "the nonlinear residual for this field is meaningless, and in nonlinear "
-                           "solvers we will ignore the residual for this field to evaluate "
+        prm.declare_entry ("Limiter for discontinuous temperature solution", "none",
+                           Patterns::Selection(DGLimiterType::pattern()),
+                           "The type of limiter to apply to the discontinuous temperature solution. "
+                           "Available options are:\n"
+                           "  * `boundary preserving': a limiter that keeps the discontinuous solution "
+                           "in the range given by `Global temperature maximum' and `Global temperature "
+                           "minimum'.\n"
+                           "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
+                           "a polynomial function in places where shocks are detected.\n"
+                           "  * `none`: if chosen, no limiter is applied to the discontinuous solution.\n"
+                           "Note that if this entry is not set to `none', then the limiter will modify "
+                           "the solution, so the nonlinear residual for this field is meaning less, and "
+                           "in nonlinear solvers we will ignore the residual for this field to evaluate "
                            "if the nonlinear solver has converged.");
-        prm.declare_entry ("Use limiter for discontinuous composition solution", "false",
-                           Patterns::List(Patterns::Bool()),
-                           "Whether to apply the bound preserving limiter as a correction after having "
-                           "the discontinuous composition solution. The limiter will only have an "
-                           "effect if the 'Global composition maximum' and "
-                           "'Global composition minimum' parameters are defined in the .prm file. "
-                           "This limiter keeps the discontinuous solution in the range given by "
-                           "Global composition maximum' and 'Global composition minimum'. "
-                           "The number of input values in this parameter separated by ',' has to be "
-                           "one or the number of the compositional fields. When only one value "
-                           "is supplied, this same value is assumed for all compositional fields, otherwise "
-                           "each value represents if the limiter should be applied to the respective "
-                           "compositional field. "
-                           "Because this limiter modifies the solution it no longer "
-                           "satisfies the assembled equation. Therefore, "
-                           "the nonlinear residual for this field is meaningless, and in nonlinear "
-                           "solvers we will ignore the residual for this field to evaluate "
+        prm.declare_entry ("Limiter for discontinuous composition solution", "none",
+                           Patterns::List(Patterns::Selection(DGLimiterType::pattern())),
+                           "The type of limiter to apply to the discontinuous composition solution. The "
+                           "number of the input values separated by ',' has to be one or the same as the "
+                           "number of the compositional fields. When only one value is supplied, this "
+                           "same value is assumed for all compositional fields.\n"
+                           "Available options are:\n"
+                           "  * `boundary preserving': a limiter that keeps the discontinuous solution "
+                           "in the range given by `Global temperature maximum' and `Global temperature "
+                           "minimum'.\n"
+                           "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
+                           "a polynomial function in places where shocks are detected.\n"
+                           "  * `none`: if chosen, no limiter is applied to the discontinuous solution.\n"
+                           "Note that if this entry is not set to `none', then the limiter will modify "
+                           "the solution, so the nonlinear residual for this field is meaning less, and "
+                           "in nonlinear solvers we will ignore the residual for this field to evaluate "
                            "if the nonlinear solver has converged.");
         prm.declare_entry ("Global temperature maximum",
                            boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
                            Patterns::Double (),
                            "The maximum global temperature value that will be used in the bound preserving "
-                           "limiter for the discontinuous solutions from temperature advection fields.");
+                           "limiter for the discontinuous solutions from temperature advection fields. "
+                           "The input value is active only when `Limiter for discontinuous temperature "
+                           "solution' is set to `boundary preserving'.");
         prm.declare_entry ("Global temperature minimum",
                            boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
                            Patterns::Double (),
                            "The minimum global temperature value that will be used in the bound preserving "
-                           "limiter for the discontinuous solutions from temperature advection fields.");
+                           "limiter for the discontinuous solutions from temperature advection fields."
+                           "The input value is active only when `Limiter for discontinuous temperature "
+                           "solution' is set to `boundary preserving'.");
         prm.declare_entry ("Global composition maximum",
                            boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
                            Patterns::List(Patterns::Double ()),
@@ -1187,7 +1191,9 @@ namespace aspect
                            "limiter for the discontinuous solutions from composition advection fields. "
                            "The number of the input 'Global composition maximum' values separated by ',' has to be "
                            "one or the same as the number of the compositional fields. When only one value "
-                           "is supplied, this same value is assumed for all compositional fields.");
+                           "is supplied, this same value is assumed for all compositional fields. "
+                           "The input value is active only when `Limiter for discontinuous composition "
+                           "solution' is set to `boundary preserving'.");
         prm.declare_entry ("Global composition minimum",
                            boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
                            Patterns::List(Patterns::Double ()),
@@ -1195,7 +1201,31 @@ namespace aspect
                            "limiter for the discontinuous solutions from composition advection fields. "
                            "The number of the input 'Global composition minimum' values separated by ',' has to be "
                            "one or the same as the number of the compositional fields. When only one value "
-                           "is supplied, this same value is assumed for all compositional fields.");
+                           "is supplied, this same value is assumed for all compositional fields. "
+                           "The input value is active only when `Limiter for discontinuous composition "
+                           "solution' is set to `boundary preserving'.");
+        prm.declare_entry ("Temperature KXRCF indicator threshold", "1.0",
+                           Patterns::Double(0.0),
+                           "The threshold of KXRCF indicator for the temperature field. If the KXRCF indicator "
+                           "of a cell is greater than the threshold, then the cell is marked as 'troubled' "
+                           "and will be smoothed by the WENO limiter. "
+                           "The input value is active only when `Limiter for discontinuous temperature "
+                           "solution' is set to `WENO'.");
+        prm.declare_entry ("Composition KXRCF indicator threshold", "1.0",
+                           Patterns::Double(0.0),
+                           "The threshold of KXRCF indicator for the temperature field. If the KXRCF indicator "
+                           "of a cell is greater than the threshold, then the cell is marked as 'troubled' "
+                           "and will be smoothed by the WENO limiter. The number of the input values "
+                           "separated by ',' has to be one or the same as the number of the compositional "
+                           "fields. When only one value is supplied, this same value is assumed for all "
+                           "compositional fields. "
+                           "The input value is active only when `Limiter for discontinuous composition "
+                           "solution' is set to `WENO'.");
+        prm.declare_entry ("WENO linear weight of neighbor cells", "0.001",
+                           Patterns::Double(0.0, 1.0),
+                           "The liear weight of neighbor cells in WENO scheme. The larger this value is, "
+                           "the more information of neighbor cells will be involved in the polynomial "
+                           "reconstruction.");
       }
       prm.leave_subsection ();
     }
@@ -1787,13 +1817,16 @@ namespace aspect
 
         stabilization_gamma                 = prm.get_double ("gamma");
         discontinuous_penalty               = prm.get_double ("Discontinuous penalty");
-        use_limiter_for_discontinuous_temperature_solution
-          = prm.get_bool("Use limiter for discontinuous temperature solution");
-        use_limiter_for_discontinuous_composition_solution
-          = Utilities::possibly_extend_from_1_to_N(Utilities::string_to_bool
-                                                   (Utilities::split_string_list(prm.get("Use limiter for discontinuous composition solution"))),
-                                                   n_compositional_fields,
-                                                   "Use limiter for discontinuous composition solution");
+
+        limiter_for_discontinuous_temperature_solution = DGLimiterType::parse(prm.get("Limiter for discontinuous temperature solution"));
+        std::vector<std::string> x_limiter_for_discontinuous_composition_solution =
+          Utilities::possibly_extend_from_1_to_N(Utilities::split_string_list(prm.get("Limiter for discontinuous composition solution")),
+                                                 n_compositional_fields,
+                                                 "Limiter for discontinuous composition solution");
+        limiter_for_discontinuous_composition_solution.resize(n_compositional_fields);
+        for (unsigned int c = 0; c < n_compositional_fields; ++c)
+          limiter_for_discontinuous_composition_solution[c] = DGLimiterType::parse(x_limiter_for_discontinuous_composition_solution[c]);
+
         global_temperature_max_preset       = prm.get_double ("Global temperature maximum");
         global_temperature_min_preset       = prm.get_double ("Global temperature minimum");
         global_composition_max_preset       = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double
@@ -1804,6 +1837,14 @@ namespace aspect
                                                                                       (Utilities::split_string_list(prm.get ("Global composition minimum"))),
                                                                                       n_compositional_fields,
                                                                                       "Global composition minimum");
+
+        temperature_KXRCF_indicator_threshold = prm.get_double ("Temperature KXRCF indicator threshold");
+        composition_KXRCF_indicator_threshold = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double
+                                                                                        (Utilities::split_string_list(prm.get("Composition KXRCF indicator threshold"))),
+                                                                                        n_compositional_fields,
+                                                                                        "Composition KXRCF indicator threshold");
+        WENO_linear_weight = prm.get_double("WENO linear weight of neighbor cells");
+
         compositional_fields_with_disabled_boundary_entropy_viscosity =
           Utilities::split_string_list(prm.get("List of compositional fields with disabled boundary entropy viscosity"));
 
diff --git a/source/simulator/simulator_access.cc b/source/simulator/simulator_access.cc
index 990c55a8564..12b4a3affeb 100644
--- a/source/simulator/simulator_access.cc
+++ b/source/simulator/simulator_access.cc
@@ -321,6 +321,19 @@ namespace aspect
 
 
 
+  template <int dim>
+  void
+  SimulatorAccess<dim>::compute_KXRCF_indicators(Vector<float> &KXRCF_indicators,
+                                                 const unsigned int field_index) const
+  {
+    const typename Simulator<dim>::AdvectionField advection_field =
+      (field_index == 0 ? Simulator<dim>::AdvectionField::temperature()
+       : Simulator<dim>::AdvectionField::composition(field_index-1));
+    simulator->compute_KXRCF_indicators(KXRCF_indicators, advection_field);
+  }
+
+
+
   template <int dim>
   const LinearAlgebra::BlockVector &
   SimulatorAccess<dim>::get_current_linearization_point () const
diff --git a/source/simulator/solver.cc b/source/simulator/solver.cc
index bb9ba0227da..fb737a7ecd7 100644
--- a/source/simulator/solver.cc
+++ b/source/simulator/solver.cc
@@ -736,20 +736,35 @@ namespace aspect
     pcout << solver_control.last_step()
           << " iterations." << std::endl;
 
-    if ((advection_field.is_discontinuous(introspection)
-         &&
-         (
-           (advection_field.is_temperature() && parameters.use_limiter_for_discontinuous_temperature_solution)
-           ||
-           (!advection_field.is_temperature() && parameters.use_limiter_for_discontinuous_composition_solution[advection_field.compositional_variable])
-         )))
+    if (advection_field.is_discontinuous(introspection))
       {
-        apply_limiter_to_dg_solutions(advection_field);
-        // by applying the limiter we have modified the solution to no longer
-        // satisfy the equation. Therefore the residual is meaningless and cannot
-        // converge to zero in nonlinear iterations. Disable residual computation
-        // for this field.
-        return 0.0;
+        const typename Parameters<dim>::DGLimiterType::Kind
+        limiter = (advection_field.is_temperature() ?
+                   parameters.limiter_for_discontinuous_temperature_solution :
+                   parameters.limiter_for_discontinuous_composition_solution[advection_field.compositional_variable]);
+
+        switch (limiter)
+          {
+            case Parameters<dim>::DGLimiterType::boundary_preserving:
+              apply_BP_limiter_to_dg_solutions(advection_field);
+              break;
+            case Parameters<dim>::DGLimiterType::WENO:
+              apply_WENO_limiter_to_dg_solutions(advection_field);
+              break;
+            case Parameters<dim>::DGLimiterType::none:
+              break;
+            default:
+              AssertThrow(false, ExcNotImplemented());
+          }
+
+        if (limiter != Parameters<dim>::DGLimiterType::none)
+          // by applying the limiter we have modified the solution to no longer
+          // satisfy the equation. Therefore the residual is meaningless and cannot
+          // converge to zero in nonlinear iterations. Disable residual computation
+          // for this field.
+          return 0.0;
+        else
+          return initial_residual;
       }
 
     return initial_residual;

From b6aaaca5adb452d8081b0cbe93d0f82a7135b760 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Sat, 22 Jun 2024 15:20:49 +0800
Subject: [PATCH 02/22] correct spelling mistakes

---
 source/simulator/limiters.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/simulator/limiters.cc b/source/simulator/limiters.cc
index eb1ec577785..c8094e91267 100644
--- a/source/simulator/limiters.cc
+++ b/source/simulator/limiters.cc
@@ -414,11 +414,11 @@ namespace aspect
                         }
                       else
                         {
-                          // Neighbor is taking responsibility for assembly of this face, bacause
+                          // Neighbor is taking responsibility for assembly of this face, because
                           // either (1) neighbor is coarser, or
                           //        (2) neighbor is equally-sized and
                           //           (a) neighbor is on a different subdomain, with lower subdomain_id(), or
-                          //           (b) nieghbor is on the same subdomain and has lower index().
+                          //           (b) neighbor is on the same subdomain and has lower index().
                         }
                     }
                   else

From 68e633c2a14c06c1db5c4252796f3b42f2d15a24 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Thu, 4 Jul 2024 11:47:09 +0800
Subject: [PATCH 03/22] add necessary headers for compilation without unity
 build

---
 source/simulator/limiters.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/source/simulator/limiters.cc b/source/simulator/limiters.cc
index c8094e91267..20109ca5f60 100644
--- a/source/simulator/limiters.cc
+++ b/source/simulator/limiters.cc
@@ -1,4 +1,6 @@
 #include <aspect/simulator.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/mesh_deformation/interface.h>
 
 namespace aspect
 {

From 4bfb4a8d20f159e106796e8f1c9670d45c4e84d7 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Thu, 4 Jul 2024 11:54:14 +0800
Subject: [PATCH 04/22] reformat the .prm file for limiter settings

---
 .../prm_files/reformat_limiter_settings.py    | 75 +++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py

diff --git a/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py b/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py
new file mode 100644
index 00000000000..27b26b11627
--- /dev/null
+++ b/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+""" This script changes 'Use limiter for discontinuous temperature/composition solution'
+to 'limiter for discontinuous temperature/composition solution' in order to allow users
+to specify different limiters for different fields
+"""
+
+
+import sys
+import os
+import re
+import argparse
+
+__author__ = 'The authors of the ASPECT code'
+__copyright__ = 'Copyright 2024, ASPECT'
+__license__ = 'GNU GPL 2 or later'
+
+# Add the ASPECT root directory to the path so we can import from the aspect_data module
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+import python.scripts.aspect_input as aspect
+
+
+
+def reformat_limiter_settings(parameters):
+    """change 'Use limiter for discontinuous temperature/composition solution' 
+    to 'limiter for discontinuous temperature/composition solution' in order to allow users
+    to specify different limiters for different fields
+    """
+
+    old_entries = ["Use limiter for discontinuous temperature solution",
+                   "Use limiter for discontinuous composition solution"]
+    new_entries = ["Limiter for discontinuous temperature solution",
+                   "Limiter for discontinuous composition solution"]
+
+    # go to the subsection
+    if "Discretization" in parameters:
+        if "Stabilization parameters" in parameters["Discretization"]["value"]:
+            subsection = parameters["Discretization"]["value"]["Stabilization parameters"]["value"]
+
+            for i in range(0,2):
+                if old_entries[i] in subsection:
+
+                    # Delete the old entry
+                    use_limiter = subsection[old_entries[i]]["value"]
+                    del subsection[old_entries[i]]
+
+                    # If limiter is used, then set the value of the new entry to "boundary preserving"
+                    if use_limiter == "true":
+                        subsection[new_entries[i]] = {"comment"         : "", 
+                                                      "value"           : "boundary preserving",  
+                                                      "type"            : "parameter", 
+                                                      "alignment spaces": 1}
+
+    return parameters
+
+
+        
+def main(input_file, output_file):
+    """Echo the input arguments to standard output"""
+    parameters = aspect.read_parameter_file(input_file)
+    parameters = reformat_limiter_settings(parameters)
+    aspect.write_parameter_file(parameters, output_file)
+
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+                    prog='ASPECT .prm file reformatter',
+                    description='Reformats ASPECT .prm files to follow our general formatting guidelines. See the documentation of this script for details.')
+    parser.add_argument('input_file', type=str, help='The .prm file to reformat')
+    parser.add_argument('output_file', type=str, help='The .prm file to write the reformatted file to')
+    args = parser.parse_args()
+
+    sys.exit(main(args.input_file, args.output_file))

From 13ed3c4f5e57a9b92f0a676fc79b45566b2c1ef8 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinyimin14@mails.ucas.ac.cn>
Date: Thu, 4 Jul 2024 11:57:53 +0800
Subject: [PATCH 05/22] Update source/simulator/parameters.cc

Co-authored-by: Rene Gassmoeller <rene.gassmoeller@mailbox.org>
---
 source/simulator/parameters.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/simulator/parameters.cc b/source/simulator/parameters.cc
index 465a60ae821..26bf5025993 100644
--- a/source/simulator/parameters.cc
+++ b/source/simulator/parameters.cc
@@ -1223,7 +1223,7 @@ namespace aspect
                            "solution' is set to `WENO'.");
         prm.declare_entry ("WENO linear weight of neighbor cells", "0.001",
                            Patterns::Double(0.0, 1.0),
-                           "The liear weight of neighbor cells in WENO scheme. The larger this value is, "
+                           "The linear weight of neighbor cells in WENO scheme. The larger this value is, "
                            "the more information of neighbor cells will be involved in the polynomial "
                            "reconstruction.");
       }

From 95edb8a732f500227946231df74264d998885a34 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Thu, 4 Jul 2024 12:07:01 +0800
Subject: [PATCH 06/22] change boundary_preserving to bound_preserving

---
 include/aspect/parameters.h    |  8 ++++----
 source/simulator/core.cc       |  6 +++---
 source/simulator/parameters.cc | 12 ++++++------
 source/simulator/solver.cc     |  2 +-
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/include/aspect/parameters.h b/include/aspect/parameters.h
index f4205dc8d1b..4890ac4c987 100644
--- a/include/aspect/parameters.h
+++ b/include/aspect/parameters.h
@@ -321,7 +321,7 @@ namespace aspect
     {
       enum Kind
       {
-        boundary_preserving,
+        bound_preserving,
         WENO,
         none
       };
@@ -330,8 +330,8 @@ namespace aspect
       Kind
       parse(const std::string &input)
       {
-        if (input == "boundary preserving")
-          return boundary_preserving;
+        if (input == "bound preserving")
+          return bound_preserving;
         else if (input == "WENO")
           return WENO;
         else if (input == "none")
@@ -344,7 +344,7 @@ namespace aspect
 
       static const std::string pattern()
       {
-        return "boundary preserving|WENO|none";
+        return "bound preserving|WENO|none";
       }
     };
 
diff --git a/source/simulator/core.cc b/source/simulator/core.cc
index e0226cf8034..76cac919a8f 100644
--- a/source/simulator/core.cc
+++ b/source/simulator/core.cc
@@ -486,15 +486,15 @@ namespace aspect
       map->initialize(MappingQGeneric<dim>(4), triangulation);
 
     bool bp_limiter_enabled = (parameters.limiter_for_discontinuous_temperature_solution
-                               == Parameters<dim>::DGLimiterType::boundary_preserving);
+                               == Parameters<dim>::DGLimiterType::bound_preserving);
     for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
       bp_limiter_enabled = bp_limiter_enabled || (parameters.limiter_for_discontinuous_composition_solution[c]
-                                                  == Parameters<dim>::DGLimiterType::boundary_preserving);
+                                                  == Parameters<dim>::DGLimiterType::bound_preserving);
 
     // Check that BP limiters are only used with cartesian mapping
     if (bp_limiter_enabled)
       AssertThrow(geometry_model->natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian,
-                  ExcMessage("The boundary preserving limiter for the discontinuous temperature and composition solutions "
+                  ExcMessage("The bound preserving limiter for the discontinuous temperature and composition solutions "
                              "has not been tested in non-Cartesian geometries and currently requires "
                              "the use of a Cartesian geometry model."));
 
diff --git a/source/simulator/parameters.cc b/source/simulator/parameters.cc
index 26bf5025993..29b7f832f8e 100644
--- a/source/simulator/parameters.cc
+++ b/source/simulator/parameters.cc
@@ -1143,7 +1143,7 @@ namespace aspect
                            Patterns::Selection(DGLimiterType::pattern()),
                            "The type of limiter to apply to the discontinuous temperature solution. "
                            "Available options are:\n"
-                           "  * `boundary preserving': a limiter that keeps the discontinuous solution "
+                           "  * `bound preserving': a limiter that keeps the discontinuous solution "
                            "in the range given by `Global temperature maximum' and `Global temperature "
                            "minimum'.\n"
                            "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
@@ -1160,7 +1160,7 @@ namespace aspect
                            "number of the compositional fields. When only one value is supplied, this "
                            "same value is assumed for all compositional fields.\n"
                            "Available options are:\n"
-                           "  * `boundary preserving': a limiter that keeps the discontinuous solution "
+                           "  * `bound preserving': a limiter that keeps the discontinuous solution "
                            "in the range given by `Global temperature maximum' and `Global temperature "
                            "minimum'.\n"
                            "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
@@ -1176,14 +1176,14 @@ namespace aspect
                            "The maximum global temperature value that will be used in the bound preserving "
                            "limiter for the discontinuous solutions from temperature advection fields. "
                            "The input value is active only when `Limiter for discontinuous temperature "
-                           "solution' is set to `boundary preserving'.");
+                           "solution' is set to `bound preserving'.");
         prm.declare_entry ("Global temperature minimum",
                            boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
                            Patterns::Double (),
                            "The minimum global temperature value that will be used in the bound preserving "
                            "limiter for the discontinuous solutions from temperature advection fields."
                            "The input value is active only when `Limiter for discontinuous temperature "
-                           "solution' is set to `boundary preserving'.");
+                           "solution' is set to `bound preserving'.");
         prm.declare_entry ("Global composition maximum",
                            boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
                            Patterns::List(Patterns::Double ()),
@@ -1193,7 +1193,7 @@ namespace aspect
                            "one or the same as the number of the compositional fields. When only one value "
                            "is supplied, this same value is assumed for all compositional fields. "
                            "The input value is active only when `Limiter for discontinuous composition "
-                           "solution' is set to `boundary preserving'.");
+                           "solution' is set to `bound preserving'.");
         prm.declare_entry ("Global composition minimum",
                            boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
                            Patterns::List(Patterns::Double ()),
@@ -1203,7 +1203,7 @@ namespace aspect
                            "one or the same as the number of the compositional fields. When only one value "
                            "is supplied, this same value is assumed for all compositional fields. "
                            "The input value is active only when `Limiter for discontinuous composition "
-                           "solution' is set to `boundary preserving'.");
+                           "solution' is set to `bound preserving'.");
         prm.declare_entry ("Temperature KXRCF indicator threshold", "1.0",
                            Patterns::Double(0.0),
                            "The threshold of KXRCF indicator for the temperature field. If the KXRCF indicator "
diff --git a/source/simulator/solver.cc b/source/simulator/solver.cc
index fb737a7ecd7..c91409716bb 100644
--- a/source/simulator/solver.cc
+++ b/source/simulator/solver.cc
@@ -745,7 +745,7 @@ namespace aspect
 
         switch (limiter)
           {
-            case Parameters<dim>::DGLimiterType::boundary_preserving:
+            case Parameters<dim>::DGLimiterType::bound_preserving:
               apply_BP_limiter_to_dg_solutions(advection_field);
               break;
             case Parameters<dim>::DGLimiterType::WENO:

From b0c4e8f332fb9cfbd1c668c5f6ad3c5148ba2d35 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Fri, 5 Jul 2024 11:03:38 +0800
Subject: [PATCH 07/22] replace 'boundary preserving' by 'bound preserving'

---
 .../update_scripts/prm_files/reformat_limiter_settings.py     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py b/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py
index 27b26b11627..f9a401d4281 100644
--- a/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py
+++ b/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py
@@ -45,10 +45,10 @@ def reformat_limiter_settings(parameters):
                     use_limiter = subsection[old_entries[i]]["value"]
                     del subsection[old_entries[i]]
 
-                    # If limiter is used, then set the value of the new entry to "boundary preserving"
+                    # If limiter is used, then set the value of the new entry to "bound preserving"
                     if use_limiter == "true":
                         subsection[new_entries[i]] = {"comment"         : "", 
-                                                      "value"           : "boundary preserving",  
+                                                      "value"           : "bound preserving",  
                                                       "type"            : "parameter", 
                                                       "alignment spaces": 1}
 

From a53c298fce094dbd4397585018d8262d3d50c93b Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Mon, 8 Jul 2024 15:48:16 +0800
Subject: [PATCH 08/22] add citations for WENO limiter and KXRCF indicator

---
 doc/manual/citing_aspect.bib   | 28 ++++++++++++++++++++++++++++
 source/simulator/parameters.cc | 29 ++++++++++++++++-------------
 2 files changed, 44 insertions(+), 13 deletions(-)

diff --git a/doc/manual/citing_aspect.bib b/doc/manual/citing_aspect.bib
index 1ef12192db7..f332ea06521 100644
--- a/doc/manual/citing_aspect.bib
+++ b/doc/manual/citing_aspect.bib
@@ -2068,4 +2068,32 @@ @article{SAKI2024107212
 keywords = {Mantle transition zone discontinuities, PP and SS precursors, Caribbean subduction, Plume-slab interaction}
 }
 
+@article{zhong2013,
+title = {A simple weighted essentially nonoscillatory limiter for {Runge}–{Kutta} discontinuous {Galerkin} methods},
+volume = {232},
+issn = {0021-9991},
+doi = {10.1016/j.jcp.2012.08.028},
+language = {en},
+number = {1},
+journal = {Journal of Computational Physics},
+author = {Zhong, Xinghui and Shu, Chi-Wang},
+month = jan,
+year = {2013},
+keywords = {Discontinuous Galerkin method, WENO limiter},
+pages = {397--415}
+}
 
+@article{krivodonova2004,
+series = {Workshop on {Innovative} {Time} {Integrators} for {PDEs}},
+title = {Shock detection and limiting with discontinuous {Galerkin} methods for hyperbolic conservation laws},
+volume = {48},
+issn = {0168-9274},
+doi = {10.1016/j.apnum.2003.11.002},
+language = {en},
+number = {3},
+journal = {Applied Numerical Mathematics},
+author = {Krivodonova, L. and Xin, J. and Remacle, J. -F. and Chevaugeon, N. and Flaherty, J. E.},
+month = mar,
+year = {2004},
+pages = {323--338}
+}
diff --git a/source/simulator/parameters.cc b/source/simulator/parameters.cc
index 29b7f832f8e..ddfc8eae121 100644
--- a/source/simulator/parameters.cc
+++ b/source/simulator/parameters.cc
@@ -1147,7 +1147,8 @@ namespace aspect
                            "in the range given by `Global temperature maximum' and `Global temperature "
                            "minimum'.\n"
                            "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
-                           "a polynomial function in places where shocks are detected.\n"
+                           "a polynomial function in places where shocks are detected, as described in "
+                           "\\cite{zhong:etal:2013}.\n"
                            "  * `none`: if chosen, no limiter is applied to the discontinuous solution.\n"
                            "Note that if this entry is not set to `none', then the limiter will modify "
                            "the solution, so the nonlinear residual for this field is meaning less, and "
@@ -1164,7 +1165,8 @@ namespace aspect
                            "in the range given by `Global temperature maximum' and `Global temperature "
                            "minimum'.\n"
                            "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
-                           "a polynomial function in places where shocks are detected.\n"
+                           "a polynomial function in places where shocks are detected, as described in "
+                           "\\cite{zhong:etal:2013}.\n"
                            "  * `none`: if chosen, no limiter is applied to the discontinuous solution.\n"
                            "Note that if this entry is not set to `none', then the limiter will modify "
                            "the solution, so the nonlinear residual for this field is meaning less, and "
@@ -1201,31 +1203,32 @@ namespace aspect
                            "limiter for the discontinuous solutions from composition advection fields. "
                            "The number of the input 'Global composition minimum' values separated by ',' has to be "
                            "one or the same as the number of the compositional fields. When only one value "
-                           "is supplied, this same value is assumed for all compositional fields. "
+                           "is supplied, this same value is assumed for all compositional fields.\n"
                            "The input value is active only when `Limiter for discontinuous composition "
                            "solution' is set to `bound preserving'.");
         prm.declare_entry ("Temperature KXRCF indicator threshold", "1.0",
                            Patterns::Double(0.0),
-                           "The threshold of KXRCF indicator for the temperature field. If the KXRCF indicator "
-                           "of a cell is greater than the threshold, then the cell is marked as 'troubled' "
-                           "and will be smoothed by the WENO limiter. "
+                           "The threshold of KXRCF indicator for the temperature field, as described in "
+                           "\\cite{Krivodonova:etal:2004}. If the KXRCF indicator of a cell is greater than "
+                           "the threshold, then the cell is marked as 'troubled' and will be smoothed by "
+                           "the WENO limiter.\n"
                            "The input value is active only when `Limiter for discontinuous temperature "
                            "solution' is set to `WENO'.");
         prm.declare_entry ("Composition KXRCF indicator threshold", "1.0",
                            Patterns::Double(0.0),
-                           "The threshold of KXRCF indicator for the temperature field. If the KXRCF indicator "
-                           "of a cell is greater than the threshold, then the cell is marked as 'troubled' "
-                           "and will be smoothed by the WENO limiter. The number of the input values "
-                           "separated by ',' has to be one or the same as the number of the compositional "
-                           "fields. When only one value is supplied, this same value is assumed for all "
-                           "compositional fields. "
+                           "The threshold of KXRCF indicator for the temperature field, as described in "
+                           "\\cite{Krivodonova:etal:2004}. If the KXRCF indicator of a cell is greater than "
+                           "the threshold, then the cell is marked as 'troubled' and will be smoothed by "
+                           "the WENO limiter. The number of the input values separated by ',' has to be one "
+                           "or the same as the number of the compositional fields. When only one value is "
+                           "supplied, this same value is assumed for all compositional fields.\n"
                            "The input value is active only when `Limiter for discontinuous composition "
                            "solution' is set to `WENO'.");
         prm.declare_entry ("WENO linear weight of neighbor cells", "0.001",
                            Patterns::Double(0.0, 1.0),
                            "The linear weight of neighbor cells in WENO scheme. The larger this value is, "
                            "the more information of neighbor cells will be involved in the polynomial "
-                           "reconstruction.");
+                           "reconstruction. See \\cite{zhong:etal:2013} for detail.");
       }
       prm.leave_subsection ();
     }

From 9d46a6266ae0030b447d85eec79fe9bfb412b20d Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Mon, 8 Jul 2024 15:48:56 +0800
Subject: [PATCH 09/22] scale the characteristic mesh spacing by the diameter
 of Omega

---
 source/simulator/limiters.cc | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/source/simulator/limiters.cc b/source/simulator/limiters.cc
index 20109ca5f60..bce8fba5b4a 100644
--- a/source/simulator/limiters.cc
+++ b/source/simulator/limiters.cc
@@ -504,6 +504,7 @@ namespace aspect
     // troubled cell indicator.
     const unsigned int degree = advection_field.polynomial_degree(introspection);
     const double power = (degree + 1.0) / 2.0;
+    const double scaling_factor = 1. / global_Omega_diameter;
 
     const unsigned int block_idx = advection_field.block_index(introspection);
     const double epsilon = std::max(1e-20,
@@ -513,7 +514,10 @@ namespace aspect
     for (const auto &cell : dof_handler.active_cell_iterators())
       if (cell->is_locally_owned())
         {
-          const double h_pow = std::pow(cell->diameter(), power);
+          // The characteristic mesh spacing is calculated by d/D, where
+          // d and D are the diameters of the present cell and the geometry
+          // model, respectively.
+          const double h_pow = std::pow(cell->diameter() * scaling_factor, power);
           const auto cell_data = data.find(cell->active_cell_index());
           if (cell_data->second.inflow_face_area == 0.0)
             KXRCF_indicators[cell->active_cell_index()] = 0.0;

From 06e7cb8134123d4d91da4dd118eeb36f5cc42fac Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Mon, 8 Jul 2024 17:00:09 +0800
Subject: [PATCH 10/22] add viscoelastic_beam_modified benchmark with WENO
 limiter

---
 .../20km_opentopbot_weno.prm                  | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm

diff --git a/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm b/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm
new file mode 100644
index 00000000000..3eab684ad1d
--- /dev/null
+++ b/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm
@@ -0,0 +1,33 @@
+# This parameter file modifies the benchmark 20kmh_05drho.prm to use the WENO limiter
+# for viscoelastic stress components.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/20km_opentopbot.prm
+
+set Output directory = 20kmh_05drho_weno
+
+
+subsection Discretization
+  subsection Stabilization parameters
+    # Use WENO limiter for viscoelastic stress components, while using the
+    # bound-preserving limiter for the chemical field
+    set Limiter for discontinuous composition solution = WENO, WENO, WENO, bound preserving
+    # In this benchmark, the spurious oscillations at the boundaries of the beam
+    # are extremely serious, so we set the linear weight of neighbor cells one
+    # magnitude greater than the default value to make the reconstructed solution
+    # smoother.
+    set WENO linear weight of neighbor cells = 0.01
+    # The global maximum and minimum values are only used by the chemical field.
+    set Global composition maximum = 1.0
+    set Global composition minimum = 0.0
+  end
+end
+
+# Visualize the KXRCF indicator for ve_stress_xy
+subsection Postprocess
+  subsection Visualization
+    set List of output variables = material properties, strain rate, kxrcf indicator
+    subsection KXRCF indicator
+      set Name of advection field = ve_stress_xy
+    end
+  end
+end

From 36ff89126c07e7621380c913d8b0a71bcc0f2386 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Mon, 8 Jul 2024 17:01:45 +0800
Subject: [PATCH 11/22] add viscoelastic_bending_beam benchmark with WENO
 limiter

---
 .../viscoelastic_bending_beam_weno.prm        | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm

diff --git a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm
new file mode 100644
index 00000000000..d6a698d676f
--- /dev/null
+++ b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm
@@ -0,0 +1,32 @@
+# This parameter file modifies the benchmark viscoealastic_bending_beam.prm
+# to use the WENO limiter for viscoelastic stress components.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set Output directory = output_viscoelastic_bending_beam_weno
+
+subsection Discretization
+  subsection Stabilization parameters
+    # Use WENO limiter for viscoelastic stress components, while using the
+    # bound-preserving limiter for the chemical field
+    set Limiter for discontinuous composition solution = WENO, WENO, WENO, bound preserving
+    # In this benchmark, the spurious oscillations at the boundaries of the beam
+    # are extremely serious, so we set the linear weight of neighbor cells one
+    # magnitude greater than the default value to make the reconstructed solution
+    # smoother.
+    set WENO linear weight of neighbor cells = 0.01
+    # The global maximum and minimum values are only used by the chemical field.
+    set Global composition maximum = 1.0
+    set Global composition minimum = 0.0
+  end
+end
+
+# Visualize the KXRCF indicator for ve_stress_xy
+subsection Postprocess
+  subsection Visualization
+    set List of output variables = material properties, strain rate, kxrcf indicator
+    subsection KXRCF indicator
+      set Name of advection field = ve_stress_xy
+    end
+  end
+end

From 0a25a71f8efaf0a625eabc924c1424356b8cb185 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Mon, 8 Jul 2024 17:02:20 +0800
Subject: [PATCH 12/22] add rotate_shape benchmark with WENO limiter

---
 benchmarks/advection/rotate_shape_dg_weno.prm | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 benchmarks/advection/rotate_shape_dg_weno.prm

diff --git a/benchmarks/advection/rotate_shape_dg_weno.prm b/benchmarks/advection/rotate_shape_dg_weno.prm
new file mode 100644
index 00000000000..895cf0ccdb3
--- /dev/null
+++ b/benchmarks/advection/rotate_shape_dg_weno.prm
@@ -0,0 +1,26 @@
+# Like rotate_shape_supg but with discontinuous Galerkin method
+# and WENO limiter
+
+set Dimension                              = 2
+
+include rotate_shape_supg.prm
+
+set Output directory                       = output-rotate-shape-dg-weno
+
+subsection Discretization
+  set Use discontinuous temperature discretization = true
+  set Use discontinuous composition discretization = true
+  subsection Stabilization parameters
+    set Limiter for discontinuous temperature solution = WENO
+    set Limiter for discontinuous composition solution = WENO
+  end
+end
+
+subsection Postprocess
+  subsection Visualization
+    set List of output variables = kxrcf indicator
+    subsection KXRCF indicator
+      set Name of advection field = C_1
+    end
+  end
+end

From 7103a42cb7cb20455281da97e5618dd893794a1c Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Mon, 8 Jul 2024 17:02:31 +0800
Subject: [PATCH 13/22] add rotate_shape benchmark with bound-preserving
 limiter

---
 benchmarks/advection/rotate_shape_dg_bp.prm | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 benchmarks/advection/rotate_shape_dg_bp.prm

diff --git a/benchmarks/advection/rotate_shape_dg_bp.prm b/benchmarks/advection/rotate_shape_dg_bp.prm
new file mode 100644
index 00000000000..bf877a98975
--- /dev/null
+++ b/benchmarks/advection/rotate_shape_dg_bp.prm
@@ -0,0 +1,21 @@
+# Like rotate_shape_supg but with discontinuous Galerkin method
+# and bound-preserving limiter
+
+set Dimension                              = 2
+
+include rotate_shape_supg.prm
+
+set Output directory                       = output-rotate-shape-dg-bp
+
+subsection Discretization
+  set Use discontinuous temperature discretization = true
+  set Use discontinuous composition discretization = true
+  subsection Stabilization parameters
+    set Limiter for discontinuous temperature solution = bound preserving
+    set Limiter for discontinuous composition solution = bound preserving
+    set Global temperature maximum = 1
+    set Global temperature minimum = 0
+    set Global composition maximum = 1
+    set Global composition minimum = 0
+  end
+end

From 59f361bcfbbe9189c92ccd25d0a4a2abd5a5a1f1 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Thu, 11 Jul 2024 23:14:33 +0800
Subject: [PATCH 14/22] replace Patterns::Double() by
 Patterns::List(Patterns::Double()) for Composition KXRCF indicator threshold

---
 source/simulator/parameters.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/simulator/parameters.cc b/source/simulator/parameters.cc
index ddfc8eae121..0388951e6a0 100644
--- a/source/simulator/parameters.cc
+++ b/source/simulator/parameters.cc
@@ -1215,7 +1215,7 @@ namespace aspect
                            "The input value is active only when `Limiter for discontinuous temperature "
                            "solution' is set to `WENO'.");
         prm.declare_entry ("Composition KXRCF indicator threshold", "1.0",
-                           Patterns::Double(0.0),
+                           Patterns::List(Double(0.0)),
                            "The threshold of KXRCF indicator for the temperature field, as described in "
                            "\\cite{Krivodonova:etal:2004}. If the KXRCF indicator of a cell is greater than "
                            "the threshold, then the cell is marked as 'troubled' and will be smoothed by "

From d6a1a0e971102af3c56adb6c7acb096c07a7dae1 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Thu, 11 Jul 2024 23:16:09 +0800
Subject: [PATCH 15/22] supplement comments for KXRCF indicator and WENO
 limiter

---
 include/aspect/simulator.h | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/include/aspect/simulator.h b/include/aspect/simulator.h
index e21f85c6284..0c7fbd1630f 100644
--- a/include/aspect/simulator.h
+++ b/include/aspect/simulator.h
@@ -1379,7 +1379,13 @@ namespace aspect
 
       /**
        * Apply the WENO limiter to the discontinuous Galerkin solutions.
-       * The WENO scheme implemented in this function is proposed by Zhong and Shu, 2013.
+       * WENO is short for Weighted Essentially Non-Oscillatory, which is
+       * a class of high-resolution schemes used in the numerical solution
+       * of hyperbolic conservation laws. The basic idea of WENO limiter is
+       * to replace the solution in troubled cells (cells with oscillation)
+       * by a polynomial reconstruction that takes the neighbor cells into
+       * account. The WENO scheme implemented in the program is a simple
+       * variant proposed by Zhong and Shu, 2013.
        *
        * This function is implemented in
        * <code>source/simulator/limiters.cc</code>.
@@ -1387,8 +1393,10 @@ namespace aspect
       void apply_WENO_limiter_to_dg_solutions (const AdvectionField &advection_field);
 
       /**
-       * Compute the KXRCF indicator that detect shocks in the advection field.
-       * The KXRCF indicator is used by the WENO limiter.
+       * Fills a vector with the KXRCF indicator for a given advection field
+       * on each local cell. The KXRCF indicator is a metric of discontinuity
+       * for hyperbolic conservation laws. Cells with high KXRCF values are
+       * identified as "troubled cells" and will be smoothed by the WENO limiter.
        *
        * This function is implemented in
        * <code>source/simulator/limiters.cc</code>.

From 92b5d90c96838cd7975025469fddfaaa24da175a Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Thu, 11 Jul 2024 23:16:28 +0800
Subject: [PATCH 16/22] supplement the documentation for KXRCF indicator

---
 .../postprocess/visualization/kxrcf_indicator.cc | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/source/postprocess/visualization/kxrcf_indicator.cc b/source/postprocess/visualization/kxrcf_indicator.cc
index 5403aa477f0..b932f96d09f 100644
--- a/source/postprocess/visualization/kxrcf_indicator.cc
+++ b/source/postprocess/visualization/kxrcf_indicator.cc
@@ -114,8 +114,20 @@ namespace aspect
       ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(KXRCFIndicator,
                                                   "kxrcf indicator",
                                                   "A visualization output object that generates output "
-                                                  "showing the value of the KXRCF indicator on each "
-                                                  "cell."
+                                                  "showing the value of the KXRCF indicator for a given "
+                                                  "advection field (either temperature or compositional "
+                                                  "field) on each cell. The KXRCF indicator is a metric "
+                                                  "of discontinuity for hyperbolic conservation laws. "
+                                                  "If the KXRCF value of a cell is higher than the value of "
+                                                  "``Temperature/Composition KXRCF indicator threshold'' "
+                                                  "of the corresponding field in the input parameter file, "
+                                                  "the cell will be identified as a ``troubled-cell'' that "
+                                                  "should be smoothed by the WENO limiter. For details, see "
+                                                  "\\cite{Krivodonova:etal:2004}."
+                                                  "\n\n"
+                                                  "This postprocessor should only be used for discontinuous "
+                                                  "advection fields. Otherwise, the postprocessor will produce "
+                                                  "a meaningless visualization output."
                                                   "\n\n"
                                                   "Physical units: none.")
     }

From e3057763e375413aeb83b86016b2b18d3bfad90e Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinyimin14@mails.ucas.ac.cn>
Date: Thu, 11 Jul 2024 23:18:31 +0800
Subject: [PATCH 17/22] Update source/simulator/parameters.cc

Co-authored-by: Rene Gassmoeller <rene.gassmoeller@mailbox.org>
---
 source/simulator/parameters.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/simulator/parameters.cc b/source/simulator/parameters.cc
index 0388951e6a0..559d3912529 100644
--- a/source/simulator/parameters.cc
+++ b/source/simulator/parameters.cc
@@ -1151,7 +1151,7 @@ namespace aspect
                            "\\cite{zhong:etal:2013}.\n"
                            "  * `none`: if chosen, no limiter is applied to the discontinuous solution.\n"
                            "Note that if this entry is not set to `none', then the limiter will modify "
-                           "the solution, so the nonlinear residual for this field is meaning less, and "
+                           "the solution, so the nonlinear residual for this field is meaningless, and "
                            "in nonlinear solvers we will ignore the residual for this field to evaluate "
                            "if the nonlinear solver has converged.");
         prm.declare_entry ("Limiter for discontinuous composition solution", "none",

From f5cbc1cb05f73165dc1c93a05c82fb43b9deaf67 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinyimin14@mails.ucas.ac.cn>
Date: Thu, 11 Jul 2024 23:19:45 +0800
Subject: [PATCH 18/22] Update source/simulator/parameters.cc

Co-authored-by: Rene Gassmoeller <rene.gassmoeller@mailbox.org>
---
 source/simulator/parameters.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/simulator/parameters.cc b/source/simulator/parameters.cc
index 559d3912529..9738cb515aa 100644
--- a/source/simulator/parameters.cc
+++ b/source/simulator/parameters.cc
@@ -1227,7 +1227,7 @@ namespace aspect
         prm.declare_entry ("WENO linear weight of neighbor cells", "0.001",
                            Patterns::Double(0.0, 1.0),
                            "The linear weight of neighbor cells in WENO scheme. The larger this value is, "
-                           "the more information of neighbor cells will be involved in the polynomial "
+                           "the more weight is given to information from neighbor cells when reconstructing the polynomial "
                            "reconstruction. See \\cite{zhong:etal:2013} for detail.");
       }
       prm.leave_subsection ();

From 4667dbcad9e02dfe8f87b19662c0d29fdb21c728 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Thu, 11 Jul 2024 23:29:43 +0800
Subject: [PATCH 19/22] reformat the .prm file for limiter settings

---
 benchmarks/advection/drop_ev.prm.bak          |   13 +
 benchmarks/advection/drop_supg.prm.bak        |  123 +
 benchmarks/advection/rotate_shape_dg_bp.prm   |    1 +
 .../advection/rotate_shape_dg_bp.prm.bak      |   21 +
 benchmarks/advection/rotate_shape_dg_weno.prm |    2 +
 .../advection/rotate_shape_dg_weno.prm.bak    |   26 +
 benchmarks/advection/rotate_shape_ev.prm.bak  |   13 +
 .../advection/rotate_shape_supg.prm.bak       |  119 +
 .../advection_in_annulus.cc.bak               |  162 +
 .../advection_in_annulus.prm.bak              |  120 +
 .../annulus/instantaneous/annulus.prm.bak     |   90 +
 benchmarks/annulus/plugin/annulus.cc.bak      |  837 ++
 .../transient/transient_annulus.prm.bak       |   89 +
 benchmarks/blankenbach/base_case1a.prm.bak    |  111 +
 benchmarks/blankenbach/base_case1b.prm.bak    |   18 +
 benchmarks/blankenbach/base_case1c.prm.bak    |   18 +
 benchmarks/blankenbach/base_case2a.prm.bak    |  111 +
 benchmarks/blankenbach/base_case2b.prm.bak    |  118 +
 benchmarks/blankenbach/plugin/code.cc.bak     |  167 +
 .../heat_flux_statistics_gradient.cc.bak      |  198 +
 .../heat_flux_statistics_gradient.h.bak       |   53 +
 .../buiter_et_al_2008_jgr/figure_6_1e20.prm   |    1 -
 .../figure_6_1e20.prm.bak                     |  179 +
 .../figure_6_1e22.prm.bak                     |   12 +
 .../doc/convergence.part.prm                  |    2 +-
 .../doc/convergence.part.prm.bak              |   44 +
 .../doc/velocity_bc.part.prm.bak              |   37 +
 benchmarks/buiter_et_al_2016_jsg/exp_1.prm    |    3 +-
 .../buiter_et_al_2016_jsg/exp_1.prm.bak       |  191 +
 .../exp_2_high_resolution.prm                 |    2 +-
 .../exp_2_high_resolution.prm.bak             |  224 +
 .../exp_2_low_resolution.prm.bak              |   32 +
 benchmarks/burstedde/burstedde.cc.bak         |  517 ++
 benchmarks/burstedde/burstedde.prm.bak        |  104 +
 benchmarks/burstedde/doc/burstedde.prm.bak    |   32 +
 .../lateral_pipe/adiabatic.prm.bak            |    8 +
 .../lateral_pipe/ala.prm.bak                  |   14 +
 .../lateral_pipe/hydrostatic.prm.bak          |    4 +
 .../lateral_pipe/isentropic.prm.bak           |    4 +
 .../lateral_pipe/lateral_pipe.prm.bak         |  125 +
 .../lateral_pipe/projected_density.prm.bak    |   10 +
 .../lateral_pipe/sub_adiabatic.prm.bak        |    8 +
 .../lateral_pipe_advect/ala.prm.bak           |   12 +
 .../lateral_pipe_advect/hydrostatic.prm.bak   |    4 +
 .../lateral_pipe_advect/isentropic.prm.bak    |    4 +
 .../lateral_pipe_advect/lateral_pipe.prm.bak  |  135 +
 .../projected_density.prm.bak                 |   10 +
 .../ala.prm.bak                               |   12 +
 .../hydrostatic.prm.bak                       |    4 +
 .../isentropic.prm.bak                        |    4 +
 .../lateral_pipe.prm.bak                      |  147 +
 .../projected_density.prm.bak                 |   10 +
 .../projected_density_full_pressure.prm.bak   |   10 +
 .../lateral_pipe_transient/ala.prm.bak        |   12 +
 .../hydrostatic.prm.bak                       |    4 +
 .../lateral_pipe_transient/isentropic.prm.bak |    4 +
 .../lateral_pipe.prm.bak                      |  138 +
 .../projected_density.prm.bak                 |   10 +
 .../lateral_pipe_transient/timestep.prm.bak   |    1 +
 .../compressibility_formulations.cc.bak       |  265 +
 .../vertical_pipe/adiabatic.prm.bak           |    8 +
 .../vertical_pipe/ala.prm.bak                 |    4 +
 .../vertical_pipe/hydrostatic.prm.bak         |    4 +
 .../vertical_pipe/isentropic.prm.bak          |    4 +
 .../vertical_pipe/projected_density.prm.bak   |   10 +
 .../vertical_pipe/sub_adiabatic.prm.bak       |    8 +
 .../vertical_pipe/vertical_pipe.prm.bak       |  133 +
 .../case_1/crameri_benchmark_1.cc.bak         |  179 +
 .../case_1/crameri_benchmark_1.prm.bak        |  139 +
 .../case_1/crameri_benchmark_1_gmg.prm.bak    |   27 +
 .../case_2/crameri_benchmark_2.prm.bak        |  134 +
 .../doc/crameri_benchmark_1.prm.bak           |   18 +
 .../doc/crameri_benchmark_2.prm.bak           |   22 +
 benchmarks/davies_et_al/case-1.1.prm.bak      |  109 +
 benchmarks/davies_et_al/case-2.1.prm.bak      |  120 +
 benchmarks/davies_et_al/case-2.2.prm.bak      |  119 +
 .../davies_et_al/case-2.3-plugin/VoT.cc.bak   |  202 +
 benchmarks/davies_et_al/case-2.3.prm.bak      |  121 +
 benchmarks/davies_et_al/doc/case-1.1.prm.bak  |   51 +
 benchmarks/davies_et_al/doc/case-2.1.prm.bak  |   11 +
 benchmarks/davies_et_al/doc/case-2.2.prm.bak  |    9 +
 benchmarks/davies_et_al/doc/case-2.3.prm.bak  |   14 +
 .../1_sine_zero_flux.prm.bak                  |  125 +
 .../2_sine_constant_h.prm.bak                 |  124 +
 .../analytical_topography.cc.bak              |  369 +
 .../analytical_topography.h.bak               |  113 +
 benchmarks/doneahuerta/doneahuerta.cc.bak     |  362 +
 benchmarks/doneahuerta/doneahuerta.prm.bak    |   88 +
 .../entropy_adiabat/entropy_adiabat.prm.bak   |  184 +
 .../entropy_adiabat/entropy_combined.prm.bak  |   42 +
 .../entropy_conduction.prm.bak                |  147 +
 .../entropy_half_space.prm.bak                |  155 +
 .../plugins/entropy_advection.cc.bak          |  312 +
 .../plugins/entropy_advection.h.bak           |   58 +
 benchmarks/finite_strain/finite_strain.cc.bak |   20 +
 benchmarks/finite_strain/pure_shear.prm.bak   |  145 +
 benchmarks/finite_strain/simple_shear.prm.bak |  133 +
 ...ree_surface_VE_cylinder_2D_loading.prm.bak |  169 +
 ...linder_2D_loading_fixed_elastic_dt.prm.bak |   21 +
 ...e_VE_cylinder_2D_loading_unloading.prm.bak |   27 +
 ...ree_surface_VE_cylinder_3D_loading.prm.bak |  170 +
 ...linder_3D_loading_fixed_elastic_dt.prm.bak |   21 +
 ...urface_viscous_cylinder_2D_loading.prm.bak |   22 +
 ...urface_viscous_cylinder_3D_loading.prm.bak |   22 +
 .../spectral-comparison.prm.bak               |  124 +
 .../grain_size_plunge.prm.bak                 |  162 +
 .../gravity_mantle/mantle_gravity.prm.bak     |   76 +
 .../doc/thick_shell.prm.bak                   |   11 +
 .../gravity_thick_shell/thick_shell.prm.bak   |   72 +
 .../doc/thinshell_a.prm.bak                   |   11 +
 .../doc/thinshell_b.prm.bak                   |    1 +
 .../doc/thinshell_c.prm.bak                   |   15 +
 .../gravity_thin_shell.prm.bak                |   88 +
 benchmarks/hollow_sphere/hollow_sphere.cc.bak |  682 ++
 .../hollow_sphere/hollow_sphere.prm.bak       |  103 +
 benchmarks/inclusion/adaptive.prm.base.bak    |   72 +
 .../inclusion_compositional_fields.cc.bak     |   51 +
 .../inclusion_compositional_fields.h.bak      |   34 +
 .../inclusion_compositional_fields.prm.bak    |   91 +
 .../inclusion_particles.prm.bak               |  119 +
 benchmarks/inclusion/doc/inclusion.prm.bak    |   62 +
 benchmarks/inclusion/global.prm.base.bak      |   63 +
 benchmarks/inclusion/inclusion.cc.bak         |   50 +
 benchmarks/inclusion/inclusion.h.bak          |  356 +
 benchmarks/infill_density/infill_ascii.prm    |    2 +-
 .../infill_density/infill_ascii.prm.bak       |  217 +
 .../infill_density/infill_ascii_data.cc.bak   |  267 +
 benchmarks/king2dcompressible/ala.prm.bak     |  184 +
 .../king2dcompressible/plugin/code.cc.bak     |  250 +
 benchmarks/layeredflow/layeredflow.cc.bak     |  404 +
 benchmarks/layeredflow/layeredflow.prm.bak    |   94 +
 .../nonlinear_channel_flow/input_t.prm.bak    |  134 +
 .../input_t_gmg.prm.bak                       |   21 +
 .../nonlinear_channel_flow/input_v.prm        |    2 +-
 .../nonlinear_channel_flow/input_v.prm.bak    |  133 +
 .../input_v_gmg.prm.bak                       |   21 +
 .../simple_nonlinear.cc.bak                   |  404 +
 .../drucker_prager_compositions.cc.bak        |  671 ++
 .../spiegelman_et_al_2016/input.prm.bak       |  137 +
 .../tosi_et_al_2015/input.prm                 |    6 +-
 .../tosi_et_al_2015/input.prm.bak             |  168 +
 .../tosi_et_al_2015/input_gmg.prm.bak         |   23 +
 benchmarks/nsinker/nsinker.cc.bak             |  352 +
 benchmarks/nsinker/nsinker.prm                |    4 +-
 benchmarks/nsinker/nsinker.prm.bak            |   84 +
 benchmarks/nsinker/nsinker_2d.prm.bak         |   72 +
 benchmarks/nsinker/nsinker_bfbt.prm           |    6 +-
 benchmarks/nsinker/nsinker_bfbt.prm.bak       |   85 +
 benchmarks/nsinker/nsinker_gmg.prm.bak        |   92 +
 .../nsinker_spherical_shell/amg.prm.bak       |   20 +
 .../nsinker_spherical_shell/gmg.prm.bak       |   86 +
 .../nsinker_spherical_shell/nsinker.cc.bak    |  349 +
 .../convection-box-base.prm.bak               |   94 +
 .../advection_reaction.base.prm.bak           |  149 +
 .../advection_reaction.cc.bak                 |  502 ++
 .../doc/exponential_decay.part.1.prm.bak      |   15 +
 .../doc/exponential_decay.part.2.prm.bak      |   38 +
 .../exponential_decay.base.prm.bak            |  121 +
 .../exponential_decay.cc.bak                  |  402 +
 .../particle_integration_scheme/circle.prm    |    2 +-
 .../circle.prm.bak                            |   78 +
 .../euler.part.prm.bak                        |    6 +
 .../rk2.part.prm.bak                          |    6 +
 .../rk4.part.prm.bak                          |    6 +
 benchmarks/polydiapirs/polydiapirs.prm.bak    |   96 +
 .../rayleigh_taylor_instability/blank.prm.bak |   52 +
 .../rayleigh_taylor_instability.cc.bak        |  199 +
 .../rayleigh_taylor_instability.prm.bak       |   75 +
 .../kaus_rayleigh_taylor_instability.prm      |    2 +-
 .../kaus_rayleigh_taylor_instability.prm.bak  |  158 +
 .../rose_rayleigh_taylor_instability.prm.bak  |   49 +
 .../instantaneous/rigid_shear.prm.bak         |   87 +
 .../rigid_shear/plugin/rigid_shear.cc.bak     |  378 +
 .../steady-state/rigid_shear.prm.bak          |  110 +
 .../rigid_shear/transient/rigid_shear.prm.bak |  134 +
 .../shear_bands/magmatic_shear_bands.prm.bak  |  146 +
 benchmarks/shear_bands/shear_bands.cc.bak     |  846 ++
 benchmarks/shear_bands/shear_bands.prm.bak    |  130 +
 benchmarks/sinking_block/blank.prm.bak        |   58 +
 benchmarks/sinking_block/sinking_block.cc.bak |  232 +
 .../sinking_block/sinking_block.prm.bak       |   71 +
 .../slab_detachment/slab_detachment.prm.bak   |  152 +
 .../solcx_compositional_fields.cc.bak         |   46 +
 .../solcx_compositional_fields.h.bak          |   34 +
 .../solcx_compositional_fields.prm            |    1 -
 .../solcx_compositional_fields.prm.bak        |   95 +
 .../compositional_fields/solcx_particles.prm  |    1 -
 .../solcx_particles.prm.bak                   |  128 +
 benchmarks/solcx/doc/solcx.prm.bak            |   60 +
 benchmarks/solcx/solcx.cc.bak                 |   44 +
 benchmarks/solcx/solcx.h.bak                  | 3189 +++++++
 benchmarks/solcx/solcx.prm.bak                |   66 +
 .../solitary_wave/doc/solitary_wave.prm.bak   |  103 +
 benchmarks/solitary_wave/solitary_wave.cc.bak | 1025 +++
 .../solitary_wave/solitary_wave.prm.bak       |  170 +
 .../solkz_compositional_fields.cc.bak         |   45 +
 .../solkz_compositional_fields.h.bak          |   33 +
 .../solkz_compositional_fields.prm.bak        |   93 +
 .../solkz_particles.prm.bak                   |  117 +
 benchmarks/solkz/doc/solkz.prm.bak            |   60 +
 benchmarks/solkz/solkz.cc.bak                 |   44 +
 benchmarks/solkz/solkz.h.bak                  |  799 ++
 benchmarks/solkz/solkz.prm.bak                |   62 +
 benchmarks/solubility/plugin/solubility.cc    |    4 +-
 .../solubility/plugin/solubility.cc.bak       |  424 +
 benchmarks/solubility/solubility.prm.bak      |  162 +
 benchmarks/tangurnis/ba/tan.prm.bak           |  130 +
 benchmarks/tangurnis/code/tangurnis.cc.bak    |  461 +
 benchmarks/tangurnis/tala/tan.prm.bak         |  140 +
 benchmarks/tangurnis/tala_c/tan.prm.bak       |  139 +
 .../plugin/time_dependent_annulus.cc.bak      |   55 +
 .../plugin/time_dependent_annulus.h.bak       |  377 +
 .../time_dependent_annulus.prm.bak            |  179 +
 .../tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak |   21 +
 .../tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak |   20 +
 .../tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak |   21 +
 .../tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak |   22 +
 .../tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak |   21 +
 .../tosi_et_al_2015_gcubed/Tosi_base.prm.bak  |  175 +
 .../doc/tosi_benchmark_2.prm.bak              |    8 +
 benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak |  722 ++
 .../20km_opentopbot.prm.bak                   |   96 +
 .../20km_opentopbot_weno.prm                  |    4 +-
 .../20km_opentopbot_weno.prm.bak              |   33 +
 .../viscoelastic_bending_beam.prm             |    2 +-
 .../viscoelastic_bending_beam.prm.bak         |  185 +
 ...iscoelastic_bending_beam_particles.prm.bak |   41 +
 .../viscoelastic_bending_beam_weno.prm        |    3 +
 .../viscoelastic_bending_beam_weno.prm.bak    |   32 +
 .../gerya_2019/gerya_2019_vep.prm.bak         |   61 +
 .../gerya_2019/gerya_2019_vp.prm.bak          |  190 +
 .../gerya_2019/gerya_2019_vp_damper.prm.bak   |   20 +
 .../kaus_2010/kaus_2010_extension.prm.bak     |  238 +
 .../viscoelastic_plastic_simple_shear.prm.bak |  146 +
 .../viscoelastic_plate_flexure.prm            |    2 +-
 .../viscoelastic_plate_flexure.prm.bak        |  177 +
 .../viscoelastic_sheared_torsion.prm.bak      |  172 +
 .../viscoelastic_stress_build-up.prm.bak      |  191 +
 ...oelastic_stress_build-up_particles.prm.bak |   43 +
 ...viscoelastic_stress_build-up_yield.prm.bak |   43 +
 ...ic_stress_build-up_yield_particles.prm.bak |   74 +
 .../viscosity_grooves.cc.bak                  |  473 +
 .../viscosity_grooves.prm.bak                 |   82 +
 .../anelasticity_temperature.cc.bak           |  402 +
 .../anelasticity_temperature.h.bak            |  135 +
 .../yamauchi_takei_2016_anelasticity.prm.bak  |   79 +
 benchmarks/zhong_et_al_93/zhong_case1.prm.bak |  105 +
 contrib/opendap/prm_files/aspect_test.prm.bak |   82 +
 .../opendap/prm_files/aspect_url_test.prm.bak |   78 +
 .../perplex_lookup_composition.prm.bak        |   84 +
 .../read_output_files/convection-box.prm.bak  |   10 +
 .../__pycache__/aspect_input.cpython-312.pyc  |  Bin 0 -> 8883 bytes
 contrib/world_builder/include/app/main.h.bak  |   27 +
 contrib/world_builder/include/glm/glm.h.bak   |  248 +
 .../include/rapidjson/allocators.h.bak        |  308 +
 .../rapidjson/cursorstreamwrapper.h.bak       |   89 +
 .../include/rapidjson/encodedstream.h.bak     |  485 +
 .../include/rapidjson/encodings.h.bak         |  855 ++
 .../include/rapidjson/error/en.h.bak          |   95 +
 .../include/rapidjson/error/error.h.bak       |  200 +
 .../include/rapidjson/filereadstream.h.bak    |  130 +
 .../include/rapidjson/filewritestream.h.bak   |  134 +
 .../world_builder/include/rapidjson/fwd.h.bak |  151 +
 .../rapidjson/internal/biginteger.h.bak       |  340 +
 .../include/rapidjson/internal/diyfp.h.bak    |  293 +
 .../include/rapidjson/internal/dtoa.h.bak     |  301 +
 .../include/rapidjson/internal/ieee754.h.bak  |  122 +
 .../include/rapidjson/internal/itoa.h.bak     |  329 +
 .../include/rapidjson/internal/meta.h.bak     |  229 +
 .../include/rapidjson/internal/pow10.h.bak    |   58 +
 .../include/rapidjson/internal/regex.h.bak    |  820 ++
 .../include/rapidjson/internal/stack.h.bak    |  277 +
 .../include/rapidjson/internal/strfunc.h.bak  |   75 +
 .../include/rapidjson/internal/strtod.h.bak   |  317 +
 .../include/rapidjson/internal/swap.h.bak     |   48 +
 .../include/rapidjson/istreamwrapper.h.bak    |  137 +
 .../include/rapidjson/latexwriter.h.bak       |  468 +
 .../include/rapidjson/memorybuffer.h.bak      |   91 +
 .../include/rapidjson/memorystream.h.bak      |   96 +
 .../rapidjson/msinttypes/inttypes.h.bak       |  320 +
 .../include/rapidjson/msinttypes/stdint.h.bak |  300 +
 .../include/rapidjson/mystwriter.h.bak        |  528 ++
 .../include/rapidjson/ostreamwrapper.h.bak    |  104 +
 .../include/rapidjson/pointer.h.bak           | 1532 ++++
 .../include/rapidjson/prettywriter.h.bak      |  340 +
 .../include/rapidjson/rapidjson.h.bak         |  660 ++
 .../include/rapidjson/reader.h.bak            | 2574 ++++++
 .../include/rapidjson/schema.h.bak            | 2927 +++++++
 .../include/rapidjson/stream.h.bak            |  312 +
 .../include/rapidjson/stringbuffer.h.bak      |  155 +
 .../include/rapidjson/writer.h.bak            |  867 ++
 .../include/visualization/main.h.bak          |   39 +
 .../include/world_builder/assert.h.bak        |   63 +
 .../include/world_builder/bounding_box.h.bak  |  513 ++
 .../include/world_builder/consts.h.bak        |   35 +
 .../world_builder/coordinate_system.h.bak     |   68 +
 .../coordinate_systems/cartesian.h.bak        |  114 +
 .../coordinate_systems/interface.h.bak        |  184 +
 .../coordinate_systems/invalid.h.bak          |  110 +
 .../coordinate_systems/spherical.h.bak        |  130 +
 .../include/world_builder/deprecate.h.bak     |   13 +
 .../features/continental_plate.h.bak          |  162 +
 .../composition/interface.h.bak               |  164 +
 .../composition/random.h.bak                  |  100 +
 .../composition/uniform.h.bak                 |   99 +
 .../grains/interface.h.bak                    |  170 +
 .../grains/random_uniform_distribution.h.bak  |  115 +
 ...andom_uniform_distribution_deflected.h.bak |  115 +
 .../grains/uniform.h.bak                      |  113 +
 .../temperature/adiabatic.h.bak               |  113 +
 .../temperature/interface.h.bak               |  169 +
 .../temperature/linear.h.bak                  |   99 +
 .../temperature/uniform.h.bak                 |   98 +
 .../world_builder/features/fault.h.bak        |  229 +
 .../fault_models/composition/interface.h.bak  |  172 +
 .../fault_models/composition/smooth.h.bak     |   97 +
 .../fault_models/composition/uniform.h.bak    |   95 +
 .../fault_models/grains/interface.h.bak       |  173 +
 .../grains/random_uniform_distribution.h.bak  |  113 +
 ...andom_uniform_distribution_deflected.h.bak |  113 +
 .../fault_models/grains/uniform.h.bak         |  112 +
 .../fault_models/temperature/adiabatic.h.bak  |  110 +
 .../fault_models/temperature/interface.h.bak  |  173 +
 .../fault_models/temperature/linear.h.bak     |   95 +
 .../fault_models/temperature/uniform.h.bak    |   95 +
 .../features/feature_utilities.h.bak          |  101 +
 .../world_builder/features/interface.h.bak    |  228 +
 .../world_builder/features/mantle_layer.h.bak |  161 +
 .../composition/interface.h.bak               |  168 +
 .../composition/uniform.h.bak                 |   98 +
 .../grains/interface.h.bak                    |  170 +
 .../grains/random_uniform_distribution.h.bak  |  114 +
 ...andom_uniform_distribution_deflected.h.bak |  114 +
 .../mantle_layer_models/grains/uniform.h.bak  |  114 +
 .../temperature/adiabatic.h.bak               |  113 +
 .../temperature/interface.h.bak               |  169 +
 .../temperature/linear.h.bak                  |   98 +
 .../temperature/uniform.h.bak                 |   97 +
 .../features/oceanic_plate.h.bak              |  158 +
 .../composition/interface.h.bak               |  168 +
 .../composition/uniform.h.bak                 |   98 +
 .../grains/interface.h.bak                    |  166 +
 .../grains/random_uniform_distribution.h.bak  |  114 +
 ...andom_uniform_distribution_deflected.h.bak |  114 +
 .../oceanic_plate_models/grains/uniform.h.bak |  114 +
 .../temperature/adiabatic.h.bak               |  112 +
 .../temperature/half_space_model.h.bak        |  103 +
 .../temperature/interface.h.bak               |  169 +
 .../temperature/linear.h.bak                  |   98 +
 .../temperature/plate_model.h.bak             |  107 +
 .../plate_model_constant_age.h.bak            |  105 +
 .../temperature/uniform.h.bak                 |   97 +
 .../world_builder/features/plume.h.bak        |  164 +
 .../plume_models/composition/interface.h.bak  |  164 +
 .../plume_models/composition/uniform.h.bak    |   97 +
 .../plume_models/grains/interface.h.bak       |  170 +
 .../plume_models/grains/uniform.h.bak         |  111 +
 .../plume_models/temperature/gaussian.h.bak   |   96 +
 .../plume_models/temperature/interface.h.bak  |  173 +
 .../plume_models/temperature/uniform.h.bak    |   98 +
 .../features/subducting_plate.h.bak           |  230 +
 .../composition/interface.h.bak               |  173 +
 .../composition/smooth.h.bak                  |   98 +
 .../composition/uniform.h.bak                 |   95 +
 .../grains/interface.h.bak                    |  173 +
 .../grains/random_uniform_distribution.h.bak  |  112 +
 ...andom_uniform_distribution_deflected.h.bak |  113 +
 .../grains/uniform.h.bak                      |  112 +
 .../temperature/adiabatic.h.bak               |  110 +
 .../temperature/interface.h.bak               |  174 +
 .../temperature/linear.h.bak                  |   96 +
 .../temperature/mass_conserving.h.bak         |  143 +
 .../temperature/plate_model.h.bak             |  102 +
 .../temperature/uniform.h.bak                 |   95 +
 .../include/world_builder/grains.h.bak        |   68 +
 .../gravity_model/interface.h.bak             |  149 +
 .../world_builder/gravity_model/uniform.h.bak |   96 +
 .../include/world_builder/kd_tree.h.bak       |  161 +
 .../include/world_builder/nan.h.bak           |   50 +
 .../world_builder/objects/bezier_curve.h.bak  |   89 +
 .../objects/closest_point_on_curve.h.bak      |   56 +
 .../objects/distance_from_surface.h.bak       |   64 +
 .../objects/natural_coordinate.h.bak          |  125 +
 .../world_builder/objects/segment.h.bak       |   79 +
 .../world_builder/objects/surface.h.bak       |  112 +
 .../include/world_builder/parameters.h.bak    |  332 +
 .../include/world_builder/point.h.bak         |  473 +
 .../include/world_builder/types/array.h.bak   |  119 +
 .../include/world_builder/types/bool.h.bak    |   77 +
 .../include/world_builder/types/double.h.bak  |   76 +
 .../include/world_builder/types/int.h.bak     |   80 +
 .../world_builder/types/interface.h.bak       |   93 +
 .../include/world_builder/types/object.h.bak  |   87 +
 .../include/world_builder/types/one_of.h.bak  |   89 +
 .../world_builder/types/plugin_system.h.bak   |   85 +
 .../include/world_builder/types/point.h.bak   |  132 +
 .../include/world_builder/types/segment.h.bak |  100 +
 .../include/world_builder/types/string.h.bak  |  103 +
 .../world_builder/types/unsigned_int.h.bak    |   80 +
 .../world_builder/types/value_at_points.h.bak |   80 +
 .../include/world_builder/utilities.h.bak     |  494 ++
 .../include/world_builder/world.h.bak         |  316 +
 .../include/world_builder/wrapper_c.h.bak     |   71 +
 .../include/world_builder/wrapper_cpp.h.bak   |   94 +
 .../world_builder/source/gwb-dat/main.cc.bak  |  343 +
 .../world_builder/source/gwb-grid/main.cc.bak | 1672 ++++
 .../coordinate_systems/cartesian.cc.bak       |  103 +
 .../coordinate_systems/interface.cc.bak       |  100 +
 .../coordinate_systems/invalid.cc.bak         |   88 +
 .../coordinate_systems/spherical.cc.bak       |  146 +
 .../features/continental_plate.cc.bak         |  270 +
 .../composition/interface.cc.bak              |   80 +
 .../composition/random.cc.bak                 |  144 +
 .../composition/uniform.cc.bak                |  136 +
 .../grains/interface.cc.bak                   |   81 +
 .../grains/random_uniform_distribution.cc.bak |  225 +
 ...ndom_uniform_distribution_deflected.cc.bak |  231 +
 .../grains/uniform.cc.bak                     |  177 +
 .../temperature/adiabatic.cc.bak              |  171 +
 .../temperature/interface.cc.bak              |   94 +
 .../temperature/linear.cc.bak                 |  157 +
 .../temperature/uniform.cc.bak                |  114 +
 .../world_builder/features/fault.cc.bak       |  730 ++
 .../fault_models/composition/interface.cc.bak |   81 +
 .../fault_models/composition/smooth.cc.bak    |  129 +
 .../fault_models/composition/uniform.cc.bak   |  124 +
 .../fault_models/grains/interface.cc.bak      |  111 +
 .../grains/random_uniform_distribution.cc.bak |  217 +
 ...ndom_uniform_distribution_deflected.cc.bak |  223 +
 .../fault_models/grains/uniform.cc.bak        |  169 +
 .../fault_models/temperature/adiabatic.cc.bak |  164 +
 .../fault_models/temperature/interface.cc.bak |   95 +
 .../fault_models/temperature/linear.cc.bak    |  140 +
 .../fault_models/temperature/uniform.cc.bak   |  107 +
 .../features/feature_utilities.cc.bak         |   56 +
 .../world_builder/features/interface.cc.bak   |  209 +
 .../features/mantle_layer.cc.bak              |  264 +
 .../composition/interface.cc.bak              |   81 +
 .../composition/uniform.cc.bak                |  131 +
 .../grains/interface.cc.bak                   |  111 +
 .../grains/random_uniform_distribution.cc.bak |  224 +
 ...ndom_uniform_distribution_deflected.cc.bak |  231 +
 .../mantle_layer_models/grains/uniform.cc.bak |  176 +
 .../temperature/adiabatic.cc.bak              |  172 +
 .../temperature/interface.cc.bak              |   94 +
 .../temperature/linear.cc.bak                 |  147 +
 .../temperature/uniform.cc.bak                |  117 +
 .../features/oceanic_plate.cc.bak             |  285 +
 .../composition/interface.cc.bak              |   81 +
 .../composition/uniform.cc.bak                |  129 +
 .../grains/interface.cc.bak                   |  111 +
 .../grains/random_uniform_distribution.cc.bak |  224 +
 ...ndom_uniform_distribution_deflected.cc.bak |  230 +
 .../grains/uniform.cc.bak                     |  177 +
 .../temperature/adiabatic.cc.bak              |  173 +
 .../temperature/half_space_model.cc.bak       |  210 +
 .../temperature/interface.cc.bak              |   94 +
 .../temperature/linear.cc.bak                 |  145 +
 .../temperature/plate_model.cc.bak            |  214 +
 .../plate_model_constant_age.cc.bak           |  161 +
 .../temperature/uniform.cc.bak                |  116 +
 .../world_builder/features/plume.cc.bak       |  403 +
 .../plume_models/composition/interface.cc.bak |   80 +
 .../plume_models/composition/uniform.cc.bak   |  129 +
 .../plume_models/grains/interface.cc.bak      |   81 +
 .../plume_models/grains/uniform.cc.bak        |  169 +
 .../plume_models/temperature/gaussian.cc.bak  |  166 +
 .../plume_models/temperature/interface.cc.bak |   94 +
 .../plume_models/temperature/uniform.cc.bak   |  106 +
 .../features/subducting_plate.cc.bak          |  762 ++
 .../composition/interface.cc.bak              |   82 +
 .../composition/smooth.cc.bak                 |  131 +
 .../composition/uniform.cc.bak                |  123 +
 .../grains/interface.cc.bak                   |  111 +
 .../grains/random_uniform_distribution.cc.bak |  217 +
 ...ndom_uniform_distribution_deflected.cc.bak |  223 +
 .../grains/uniform.cc.bak                     |  169 +
 .../temperature/adiabatic.cc.bak              |  166 +
 .../temperature/interface.cc.bak              |   94 +
 .../temperature/linear.cc.bak                 |  138 +
 .../temperature/mass_conserving.cc.bak        |  639 ++
 .../temperature/plate_model.cc.bak            |  214 +
 .../temperature/uniform.cc.bak                |  109 +
 .../source/world_builder/grains.cc.bak        |   80 +
 .../gravity_model/interface.cc.bak            |   99 +
 .../gravity_model/uniform.cc.bak              |   94 +
 .../source/world_builder/kd_tree.cc.bak       |  211 +
 .../world_builder/objects/bezier_curve.cc.bak |  550 ++
 .../objects/distance_from_surface.cc.bak      |   36 +
 .../objects/natural_coordinate.cc.bak         |  121 +
 .../world_builder/objects/segment.cc.bak      |  126 +
 .../world_builder/objects/surface.cc.bak      |  227 +
 .../source/world_builder/parameters.cc.bak    | 2229 +++++
 .../source/world_builder/point.cc.bak         |  108 +
 .../source/world_builder/types/array.cc.bak   |   84 +
 .../source/world_builder/types/bool.cc.bak    |   62 +
 .../source/world_builder/types/double.cc.bak  |   68 +
 .../source/world_builder/types/int.cc.bak     |   64 +
 .../world_builder/types/interface.cc.bak      |   45 +
 .../source/world_builder/types/object.cc.bak  |   91 +
 .../source/world_builder/types/one_of.cc.bak  |   77 +
 .../world_builder/types/plugin_system.cc.bak  |   95 +
 .../source/world_builder/types/point.cc.bak   |  185 +
 .../source/world_builder/types/segment.cc.bak |  170 +
 .../source/world_builder/types/string.cc.bak  |  120 +
 .../world_builder/types/unsigned_int.cc.bak   |   64 +
 .../types/value_at_points.cc.bak              |   96 +
 .../source/world_builder/utilities.cc.bak     | 1510 ++++
 .../source/world_builder/world.cc.bak         |  498 ++
 .../source/world_builder/wrapper_c.cc.bak     |  108 +
 .../source/world_builder/wrapper_cpp.cc.bak   |   77 +
 .../tests/unit_tests/bounding_box.cc.bak      |   87 +
 .../tests/unit_tests/gwb_gravity.cc.bak       |   68 +
 .../tests/unit_tests/kd_tree.cc.bak           |  214 +
 .../tests/unit_tests/main.cc.bak              |   25 +
 .../tests/unit_tests/unit_test_wb_glm.cc.bak  |  253 +
 .../unit_tests/unit_test_world_builder.cc.bak | 7780 +++++++++++++++++
 .../2d_annulus_example.prm.bak                |   89 +
 .../allken.prm                                |    2 +-
 .../allken.prm.bak                            |  155 +
 .../AV_Rayleigh_Taylor.prm.bak                |  100 +
 .../anisotropic_viscosity/av_material.cc.bak  |  831 ++
 .../bunge_et_al.prm.bak                       |  104 +
 cookbooks/burnman/burnman.prm.bak             |  143 +
 .../doc/adiabatic_conditions.part.prm.bak     |    8 +
 .../burnman/doc/formulation.part.prm.bak      |    3 +
 .../burnman/doc/formulation_ica.part.prm.bak  |    3 +
 .../burnman/doc/gravity_model.part.prm.bak    |    3 +
 .../burnman/doc/material_model.part.prm.bak   |   14 +
 cookbooks/burnman/doc/tala.part.prm.bak       |    5 +
 .../christensen_yuen_phase_function.prm.bak   |  172 +
 .../doc/material.part.prm.bak                 |   35 +
 .../composition-reaction.prm.bak              |  113 +
 .../doc/initial.part.prm.bak                  |    8 +
 .../doc/material.part.prm.bak                 |   12 +
 .../composition_active.prm.bak                |  106 +
 .../doc/active.part.prm.bak                   |   12 +
 .../doc/postprocess.part.prm.bak              |    8 +
 .../composition_active_particles.prm.bak      |  127 +
 .../doc/composition.part.prm.bak              |    6 +
 .../doc/particles.part.prm.bak                |   18 +
 .../composition_passive.prm.bak               |   99 +
 .../doc/passive.part.prm.bak                  |   18 +
 .../doc/postprocess.part.prm.bak              |    3 +
 .../composition_passive_particles.prm.bak     |  114 +
 ...ition_passive_particles_properties.prm.bak |  121 +
 .../doc/particle-properties.part.prm.bak      |   17 +
 .../doc/particles.part.prm.bak                |   20 +
 .../continental_extension.prm.bak             |  314 +
 ...ntal_extension_boundary_conditions.prm.bak |   36 +
 .../continental_extension_composition.prm.bak |   16 +
 ...ontinental_extension_geometry_mesh.prm.bak |   23 +
 ...ntinental_extension_material_model.prm.bak |    6 +
 .../convection-box-particles.prm.bak          |  170 +
 .../convection-box/convection-box.prm.bak     |  160 +
 .../convection-box/doc/disc.part.prm.bak      |    4 +
 .../convection-box/doc/gravity.part.prm.bak   |    5 +
 .../convection-box/doc/refine.part.prm.bak    |    5 +
 .../convection-box/doc/refine2.part.prm.bak   |    8 +
 .../model_input/convection-box.prm.bak        |  160 +
 .../model_input/convection-box2.prm.bak       |  161 +
 .../model_input/tutorial.prm                  |   35 +-
 .../model_input/tutorial.prm.bak              |  157 +
 .../convection_box_3d.prm.bak                 |  152 +
 .../convection_box_3d/doc/amr.part.prm.bak    |    6 +
 .../doc/checkpoint.part.prm.bak               |    3 +
 .../doc/gravity.part.prm.bak                  |    7 +
 .../doc/initial.part.prm.bak                  |    9 +
 .../doc/postprocess.part.prm.bak              |    8 +
 .../convection_box_3d/doc/start.part.prm.bak  |   25 +
 .../crustal_model_2D.prm.bak                  |  134 +
 .../crustal_model_3D.prm.bak                  |  128 +
 .../doc/crustal_model_2D_part1.prm.bak        |   15 +
 .../doc/crustal_model_2D_part2.prm.bak        |    7 +
 .../doc/crustal_model_2D_part3.prm.bak        |    3 +
 .../doc/crustal_model_2D_part4.prm.bak        |    9 +
 .../doc/crustal_model_3D_part1.prm.bak        |    7 +
 .../fastscape_eroding_box.prm.bak             |  177 +
 .../doc/finite_strain.part.prm.bak            |   14 +
 cookbooks/finite_strain/finite_strain.cc.bak  |  128 +
 cookbooks/finite_strain/finite_strain.prm.bak |  119 +
 .../doc/free_surface.part.prm.bak             |   41 +
 cookbooks/free_surface/free_surface.prm.bak   |  141 +
 .../doc/free_surface_with_crust.part1.prm.bak |    4 +
 .../doc/free_surface_with_crust.part2.prm.bak |   19 +
 .../free_surface_with_crust.prm.bak           |  112 +
 .../plugin/simpler_with_crust.cc.bak          |  220 +
 cookbooks/future/mantle_setup_restart.prm.bak |   30 +
 cookbooks/future/mantle_setup_start.prm       |    4 +-
 cookbooks/future/mantle_setup_start.prm.bak   |  192 +
 cookbooks/future/net_rotation.prm.bak         |   78 +
 cookbooks/future/periodic_box.prm.bak         |  106 +
 cookbooks/future/radiogenic_heating.prm.bak   |  104 +
 .../radiogenic_heating_function.prm.bak       |  108 +
 cookbooks/future/sphere.prm.bak               |   74 +
 cookbooks/geomio/doc/geomIO.prm.bak           |   40 +
 cookbooks/geomio/geomIO.prm.bak               |   96 +
 cookbooks/global_melt/doc/global_melt.prm.bak |  248 +
 .../global_melt/doc/global_no_melt.prm.bak    |  211 +
 cookbooks/global_melt/global_melt.prm.bak     |  371 +
 cookbooks/global_melt/global_no_melt.prm.bak  |  211 +
 cookbooks/gplates/doc/gplates.part.prm.bak    |   17 +
 cookbooks/gplates/doc/slice1.part.prm.bak     |    2 +
 cookbooks/gplates/doc/slice2.part.prm.bak     |    2 +
 cookbooks/gplates/gplates_2d.prm.bak          |   88 +
 cookbooks/gplates/gplates_3d.prm.bak          |   88 +
 .../grain_size_ridge/doc/fields.part.prm.bak  |   11 +
 .../doc/material_model.part.prm.bak           |   48 +
 .../doc/particles.part.prm.bak                |   30 +
 .../grain_size_ridge/grain_size_ridge.prm.bak |  310 +
 cookbooks/heat_flow/heat-flow-plume.prm.bak   |  154 +
 cookbooks/heat_flow/heat-flow-terms.prm.bak   |   40 +
 cookbooks/heat_flow/heat-flow.prm.bak         |  143 +
 .../inclusions/ellipse_pure_shear.prm.bak     |   13 +
 .../ellipse_pure_shear_nonlinear.prm.bak      |  129 +
 cookbooks/inclusions/ellipse_ref.prm.bak      |   94 +
 .../inclusions/ellipse_simple_shear.prm.bak   |   13 +
 .../inclusions/rectangle_pure_shear.prm.bak   |   13 +
 cookbooks/inclusions/rectangle_ref.prm.bak    |   94 +
 .../inclusions/rectangle_simple_shear.prm.bak |   13 +
 .../initial-condition-S20RTS/S20RTS.prm.bak   |  152 +
 .../doc/S20RTS.part.prm.bak                   |   13 +
 .../doc/inner_core_traction.part.1.prm.bak    |   15 +
 .../doc/inner_core_traction.part.2.prm.bak    |   13 +
 .../doc/inner_core_traction.part.3.prm.bak    |   11 +
 .../inner_core_assembly.cc.bak                |  140 +
 .../inner_core_convection.cc.bak              |  488 ++
 .../inner_core_traction.prm                   |    2 +-
 .../inner_core_traction.prm.bak               |  136 +
 .../composition_trms_statistics.cc.bak        |  227 +
 .../composition_trms_statistics.h.bak         |   75 +
 .../doc/Case1_compositions.prm.bak            |   39 +
 .../doc/Case1_materialmodel.prm.bak           |   15 +
 .../doc/Case1_meshrefinement.prm.bak          |   23 +
 .../doc/Case1_postprocessing.prm              |    2 +-
 .../doc/Case1_postprocessing.prm.bak          |   16 +
 .../doc/Case1_velocity.prm.bak                |   13 +
 .../doc/Case2a_materialmodel.prm.bak          |   13 +
 .../doc/Case2a_postprocessing.prm             |    2 +-
 .../doc/Case2a_postprocessing.prm.bak         |   20 +
 .../doc/Case2a_temperatures.prm.bak           |   21 +
 .../doc/Case2b_materialmodel.prm.bak          |   25 +
 .../isotherm_depth.cc.bak                     |  152 +
 .../isotherm_depth.h.bak                      |   74 +
 ...nematically_driven_subduction_2d_case1.prm |    2 +-
 ...tically_driven_subduction_2d_case1.prm.bak |  202 +
 ...ematically_driven_subduction_2d_case2a.prm |    2 +-
 ...ically_driven_subduction_2d_case2a.prm.bak |  107 +
 ...ically_driven_subduction_2d_case2b.prm.bak |   38 +
 .../subduction_plate_cooling.cc.bak           |  100 +
 .../subduction_plate_cooling.h.bak            |   52 +
 .../trench_location.cc.bak                    |  157 +
 .../trench_location.h.bak                     |   75 +
 .../latent-heat/doc/material.part.prm.bak     |   41 +
 cookbooks/latent-heat/latent-heat.prm.bak     |  145 +
 .../lower_crustal_flow_obstacle.prm.bak       |  116 +
 .../magnetic_stripes/magnetic_stripes.cc      |    2 +-
 .../magnetic_stripes/magnetic_stripes.cc.bak  |  153 +
 .../magnetic_stripes/magnetic_stripes.prm     |    4 +-
 .../magnetic_stripes/magnetic_stripes.prm.bak |  241 +
 .../modelR.prm.bak                            |  210 +
 .../doc/boundary_conditions.part.prm.bak      |   34 +
 .../doc/compaction_length.part.prm.bak        |   23 +
 .../doc/melting_and_freezing.part.prm.bak     |   38 +
 .../doc/mesh_refinement.part.prm.bak          |   28 +
 .../mid_ocean_ridge/mid_ocean_ridge.prm.bak   |  254 +
 .../doc/morency_doin.part.prm.bak             |   59 +
 .../morency_doin_2004/morency_doin.cc.bak     |  302 +
 .../morency_doin_2004/morency_doin.h.bak      |  125 +
 cookbooks/morency_doin_2004/morency_doin.prm  |    2 +-
 .../morency_doin_2004/morency_doin.prm.bak    |  113 +
 .../doc/comp.field.prm.bak                    |    5 +
 .../doc/comp.setup.prm.bak                    |   12 +
 .../doc/conductivity.setup.prm.bak            |    7 +
 .../doc/lookup.part.prm.bak                   |   10 +
 .../doc/temperature.setup.prm.bak             |   26 +
 .../steinberger_thermochemical_plume.prm.bak  |  166 +
 .../doc/check-initial-condition.part.prm.bak  |   18 +
 .../doc/mesh-refinement.part.prm.bak          |   23 +
 .../doc/repetitions.part.prm.bak              |   15 +
 .../doc/temperature.part.prm.bak              |   39 +
 .../muparser-temperature-example.prm.bak      |  159 +
 .../onset_of_convection.prm.bak               |   93 +
 .../doc/boundary.part.prm.bak                 |   10 +
 .../platelike-boundary/doc/platelike.prm.bak  |   91 +
 .../platelike-boundary.prm.bak                |   96 +
 .../opening_angle_45degrees.prm.bak           |   11 +
 .../opening_angle_90degrees.prm.bak           |   11 +
 cookbooks/plume_2D_chunk/plume2D.prm.bak      |  104 +
 .../strongly_temperature_dependent.prm.bak    |   11 +
 .../weakly_temperature_dependent.prm.bak      |   11 +
 cookbooks/prescribed_velocity/circle.prm.bak  |   62 +
 .../prescribed_velocity/corner_flow.prm.bak   |   62 +
 .../prescribed_velocity/doc/minimal.prm.bak   |   24 +
 .../prescribed_velocity.cc.bak                |  301 +
 ...escribed_velocity_ascii_data.prm.0.out.bak |    2 +
 ...escribed_velocity_ascii_data.prm.1.out.bak |   18 +
 ...escribed_velocity_ascii_data.prm.2.out.bak |    8 +
 .../prescribed_velocity_ascii_data.cc.bak     |  311 +
 .../prescribed_velocity_ascii_data.prm.bak    |  152 +
 .../doc/shell_3d_postprocess.part.prm.bak     |    9 +
 .../shell_3d_postprocess.prm.bak              |  108 +
 .../doc/shearheat.part.prm.bak                |    3 +
 cookbooks/shell_simple_2d/doc/shell.prm.bak   |   72 +
 .../shell_simple_2d/shell_simple_2d.prm.bak   |   82 +
 .../shell_simple_2d_smoothing.part.prm.bak    |   20 +
 .../shell_simple_2d_smoothing.prm.bak         |   95 +
 .../shell_simple_3d/doc/amr.part.prm.bak      |    6 +
 .../doc/checkpoint.part.prm.bak               |    3 +
 .../shell_simple_3d/doc/part1.part.prm.bak    |   13 +
 .../shell_simple_3d/doc/part2.part.prm.bak    |   13 +
 .../shell_simple_3d/doc/part3.part.prm.bak    |    9 +
 .../shell_simple_3d/doc/part4.part.prm.bak    |   11 +
 .../doc/postprocess.part.prm.bak              |   16 +
 .../shell_simple_3d/shell_simple_3d.prm.bak   |   79 +
 .../doc/conservative.prm.bak                  |    3 +
 .../sinker-with-averaging/doc/full.prm.bak    |   86 +
 .../doc/harmonic.prm.bak                      |    3 +
 .../sinker-with-averaging.prm.bak             |   86 +
 .../steinberger/doc/geometry.part.prm.bak     |   10 +
 cookbooks/steinberger/doc/lookup.part.prm.bak |   11 +
 .../steinberger/doc/nullspace.part.prm.bak    |    3 +
 .../doc/projected_density.part.prm.bak        |   11 +
 .../steinberger/doc/rheology.part.prm.bak     |   11 +
 .../steinberger/doc/rheology2.part.prm.bak    |    5 +
 cookbooks/steinberger/steinberger.prm.bak     |  215 +
 cookbooks/stokes/doc/stokeslaw.prm.bak        |  118 +
 cookbooks/stokes/stokes.prm.bak               |  121 +
 .../subduction_initiation.prm.base.bak        |   51 +
 ...on_initiation_compositional_fields.prm.bak |   50 +
 ...uction_initiation_particle_in_cell.prm.bak |   66 +
 ...an-parameterization-kinematic-slab.prm.bak |  303 +
 ...an-parameterization-kinematic-slab.prm.bak |   36 +
 .../2D_slice_with_faults_and_cratons.prm.bak  |  246 +
 ...omography_based_plate_motions.part.prm.bak |   53 +
 .../plugins/reference_profile.cc.bak          |  457 +
 .../plugins/reference_profile.h.bak           |  214 +
 .../plugins/tomography_based_plate_motions.cc |   12 +-
 .../tomography_based_plate_motions.cc.bak     | 1726 ++++
 .../tomography_based_plate_motions.h.bak      |  513 ++
 .../doc/material.part.prm.bak                 |   12 +
 .../doc/temperature.part.prm.bak              |   28 +
 .../temperature_dependent.prm.bak             |   24 +
 .../transform_fault_behn_2007.prm.bak         |  203 +
 cookbooks/van-keken-vof/doc/amr.part.prm.bak  |    8 +
 cookbooks/van-keken-vof/doc/main.part.prm.bak |   19 +
 .../doc/postprocess.part.prm.bak              |   13 +
 .../van-keken-vof/doc/variation.part.prm.bak  |   10 +
 cookbooks/van-keken-vof/van-keken-vof.prm.bak |  108 +
 cookbooks/van-keken/doc/main.part.prm.bak     |   19 +
 .../van-keken/doc/postprocess.part.prm.bak    |    3 +
 cookbooks/van-keken/doc/smooth.part.prm.bak   |    9 +
 .../van-keken/van-keken-discontinuous.prm.bak |   93 +
 cookbooks/van-keken/van-keken-smooth.prm.bak  |   94 +
 .../plugin/van_Keken_mesh.cc.bak              |  367 +
 .../vankeken_corner_flow.prm.bak              |  157 +
 .../doc/harzburgite.prm.bak                   |    9 +
 .../doc/material_model.prm.bak                |   15 +
 .../doc/steinberg.prm.bak                     |   17 +
 .../visualizing_phase_diagram.prm.bak         |  131 +
 doc/logo/logo.prm.bak                         |  111 +
 .../doc/boundary-conditions.part.prm.bak      |    7 +
 .../cookbooks/overview/doc/dim.part.prm.bak   |    1 +
 .../overview/doc/geometry.part.prm.bak        |   10 +
 .../overview/doc/gmg-average.part.prm.bak     |    3 +
 .../overview/doc/gmg-enable.part.prm.bak      |    5 +
 .../cookbooks/overview/doc/simple.prm.bak     |   16 +
 .../overview/doc/structure.part.prm.bak       |   20 +
 doc/manual/empty.prm.bak                      |   32 +
 .../adiabatic_conditions/ascii_data.h.bak     |  130 +
 .../compute_entropy_profile.h.bak             |  147 +
 .../compute_profile.h.bak                     |  200 +
 .../adiabatic_conditions/function.h.bak       |  107 +
 .../adiabatic_conditions/interface.h.bak      |  226 +
 .../boundary_composition/ascii_data.h.bak     |   99 +
 include/aspect/boundary_composition/box.h.bak |   84 +
 .../boundary_composition/function.h.bak       |   96 +
 .../initial_composition.h.bak                 |  114 +
 .../boundary_composition/interface.h.bak      |  323 +
 .../spherical_constant.h.bak                  |   95 +
 .../two_merged_boxes.h.bak                    |   84 +
 .../boundary_fluid_pressure/density.h.bak     |   92 +
 .../boundary_fluid_pressure/interface.h.bak   |  166 +
 .../aspect/boundary_heat_flux/function.h.bak  |   99 +
 .../aspect/boundary_heat_flux/interface.h.bak |  158 +
 .../boundary_temperature/ascii_data.h.bak     |  115 +
 include/aspect/boundary_temperature/box.h.bak |   91 +
 .../boundary_temperature/constant.h.bak       |   97 +
 .../boundary_temperature/dynamic_core.h.bak   |  517 ++
 .../boundary_temperature/function.h.bak       |  129 +
 .../initial_temperature.h.bak                 |  115 +
 .../boundary_temperature/interface.h.bak      |  355 +
 .../spherical_constant.h.bak                  |  109 +
 .../two_merged_boxes.h.bak                    |   96 +
 .../aspect/boundary_traction/ascii_data.h.bak |  105 +
 .../aspect/boundary_traction/function.h.bak   |  112 +
 .../initial_lithostatic_pressure.h.bak        |  126 +
 .../aspect/boundary_traction/interface.h.bak  |  286 +
 .../boundary_traction/zero_traction.h.bak     |   61 +
 .../aspect/boundary_velocity/ascii_data.h.bak |  110 +
 .../aspect/boundary_velocity/function.h.bak   |  115 +
 .../aspect/boundary_velocity/gplates.h.bak    |  347 +
 .../aspect/boundary_velocity/interface.h.bak  |  349 +
 .../boundary_velocity/zero_velocity.h.bak     |   59 +
 include/aspect/citation_info.h.bak            |   62 +
 include/aspect/compat.h.bak                   |  216 +
 include/aspect/coordinate_systems.h.bak       |   52 +
 include/aspect/fe_variable_collection.h.bak   |  288 +
 include/aspect/geometry_model/box.h.bak       |  255 +
 include/aspect/geometry_model/chunk.h.bak     |  428 +
 .../geometry_model/ellipsoidal_chunk.h.bak    |  346 +
 .../initial_topography_model/ascii_data.h.bak |  103 +
 .../initial_topography_model/function.h.bak   |   93 +
 .../initial_topography_model/interface.h.bak  |  163 +
 .../prm_polygon.h.bak                         |   87 +
 .../zero_topography.h.bak                     |   60 +
 include/aspect/geometry_model/interface.h.bak |  447 +
 include/aspect/geometry_model/sphere.h.bak    |  164 +
 .../geometry_model/spherical_shell.h.bak      |  454 +
 .../geometry_model/two_merged_boxes.h.bak     |  265 +
 .../geometry_model/two_merged_chunks.h.bak    |  325 +
 include/aspect/global.h.bak                   |  312 +
 include/aspect/gravity_model/ascii_data.h.bak |   99 +
 include/aspect/gravity_model/function.h.bak   |  100 +
 include/aspect/gravity_model/interface.h.bak  |  143 +
 include/aspect/gravity_model/radial.h.bak     |  143 +
 include/aspect/gravity_model/vertical.h.bak   |   72 +
 .../heating_model/adiabatic_heating.h.bak     |  104 +
 .../adiabatic_heating_of_melt.h.bak           |  108 +
 .../heating_model/compositional_heating.h.bak |   94 +
 .../heating_model/constant_heating.h.bak      |   79 +
 include/aspect/heating_model/function.h.bak   |   97 +
 include/aspect/heating_model/interface.h.bak  |  384 +
 .../aspect/heating_model/latent_heat.h.bak    |   74 +
 .../heating_model/latent_heat_melt.h.bak      |   91 +
 .../heating_model/radioactive_decay.h.bak     |  119 +
 .../aspect/heating_model/shear_heating.h.bak  |  119 +
 .../shear_heating_with_melt.h.bak             |   78 +
 .../adiabatic_density.h.bak                   |   58 +
 .../initial_composition/ascii_data.h.bak      |   90 +
 .../ascii_data_layered.h.bak                  |   87 +
 .../entropy_table_lookup.h.bak                |  111 +
 .../aspect/initial_composition/function.h.bak |   89 +
 .../initial_composition/interface.h.bak       |  280 +
 .../aspect/initial_composition/porosity.h.bak |   84 +
 .../initial_composition/slab_model.h.bak      |  109 +
 .../initial_composition/world_builder.h.bak   |  105 +
 .../S40RTS_perturbation.h.bak                 |  233 +
 .../SAVANI_perturbation.h.bak                 |  196 +
 .../initial_temperature/adiabatic.h.bak       |  187 +
 .../adiabatic_boundary.h.bak                  |   89 +
 .../initial_temperature/ascii_data.h.bak      |   85 +
 .../ascii_data_layered.h.bak                  |   85 +
 .../initial_temperature/ascii_profile.h.bak   |   90 +
 include/aspect/initial_temperature/box.h.bak  |  122 +
 .../continental_geotherm.h.bak                |  114 +
 .../aspect/initial_temperature/function.h.bak |   93 +
 .../harmonic_perturbation.h.bak               |  107 +
 .../initial_temperature/interface.h.bak       |  277 +
 .../lithosphere_mask.h.bak                    |  168 +
 .../initial_temperature/patch_on_S40RTS.h.bak |  122 +
 .../prescribed_temperature.h.bak              |   73 +
 .../random_gaussian_perturbation.h.bak        |   99 +
 .../initial_temperature/spherical_shell.h.bak |  147 +
 .../initial_temperature/world_builder.h.bak   |   84 +
 include/aspect/introspection.h.bak            |  676 ++
 include/aspect/lateral_averaging.h.bak        |  326 +
 .../ascii_reference_profile.h.bak             |  167 +
 include/aspect/material_model/averaging.h.bak |  168 +
 .../aspect/material_model/compositing.h.bak   |  136 +
 .../material_model/composition_reaction.h.bak |  125 +
 .../material_model/depth_dependent.h.bak      |  151 +
 .../diffusion_dislocation.h.bak               |  128 +
 .../material_model/drucker_prager.h.bak       |  170 +
 .../aspect/material_model/entropy_model.h.bak |  187 +
 .../equation_of_state/interface.h.bak         |  125 +
 .../linearized_incompressible.h.bak           |  140 +
 .../multicomponent_compressible.h.bak         |  143 +
 .../multicomponent_incompressible.h.bak       |  127 +
 .../thermodynamic_table_lookup.h.bak          |  236 +
 .../aspect/material_model/grain_size.h.bak    |  490 ++
 include/aspect/material_model/interface.h.bak | 1534 ++++
 .../aspect/material_model/latent_heat.h.bak   |  127 +
 .../material_model/latent_heat_melt.h.bak     |  205 +
 .../aspect/material_model/melt_boukare.h.bak  |  355 +
 .../aspect/material_model/melt_global.h.bak   |  149 +
 .../aspect/material_model/melt_simple.h.bak   |  144 +
 .../aspect/material_model/modified_tait.h.bak |  166 +
 .../material_model/multicomponent.h.bak       |  139 +
 .../multicomponent_compressible.h.bak         |  133 +
 .../material_model/nondimensional.h.bak       |  132 +
 .../material_model/perplex_lookup.h.bak       |  113 +
 .../material_model/prescribed_viscosity.h.bak |  110 +
 .../katz2003_mantle_melting.h.bak             |  168 +
 .../reactive_fluid_transport.h.bak            |  262 +
 .../replace_lithosphere_viscosity.h.bak       |  102 +
 .../rheology/ascii_depth_profile.h.bak        |   96 +
 .../rheology/composite_visco_plastic.h.bak    |  147 +
 .../compositional_viscosity_prefactors.h.bak  |  122 +
 .../rheology/constant_viscosity.h.bak         |   73 +
 .../constant_viscosity_prefactors.h.bak       |   85 +
 .../rheology/diffusion_creep.h.bak            |  167 +
 .../rheology/diffusion_dislocation.h.bak      |  139 +
 .../rheology/dislocation_creep.h.bak          |  155 +
 .../rheology/drucker_prager.h.bak             |  161 +
 .../material_model/rheology/elasticity.h.bak  |  197 +
 .../rheology/frank_kamenetskii.h.bak          |   98 +
 .../rheology/friction_models.h.bak            |  135 +
 .../rheology/peierls_creep.h.bak              |  275 +
 .../rheology/strain_dependent.h.bak           |  274 +
 .../rheology/visco_plastic.h.bak              |  339 +
 include/aspect/material_model/simple.h.bak    |  109 +
 .../material_model/simple_compressible.h.bak  |  137 +
 include/aspect/material_model/simpler.h.bak   |   86 +
 .../aspect/material_model/steinberger.h.bak   |  335 +
 include/aspect/material_model/utilities.h.bak |  680 ++
 .../aspect/material_model/visco_plastic.h.bak |  283 +
 .../aspect/material_model/viscoelastic.h.bak  |  220 +
 include/aspect/melt.h.bak                     |  571 ++
 .../aspect/mesh_deformation/ascii_data.h.bak  |   96 +
 .../aspect/mesh_deformation/diffusion.h.bak   |  138 +
 .../aspect/mesh_deformation/fastscape.h.bak   |  597 ++
 .../mesh_deformation/free_surface.h.bak       |  116 +
 .../aspect/mesh_deformation/function.h.bak    |   87 +
 .../aspect/mesh_deformation/interface.h.bak   |  649 ++
 .../artificial_viscosity.h.bak                |   78 +
 include/aspect/mesh_refinement/boundary.h.bak |   81 +
 .../mesh_refinement/compaction_length.h.bak   |   79 +
 .../aspect/mesh_refinement/composition.h.bak  |   78 +
 .../composition_approximate_gradient.h.bak    |   78 +
 .../composition_gradient.h.bak                |   78 +
 .../composition_threshold.h.bak               |   76 +
 include/aspect/mesh_refinement/density.h.bak  |   60 +
 .../aspect/mesh_refinement/interface.h.bak    |  318 +
 .../aspect/mesh_refinement/isosurfaces.h.bak  |  145 +
 .../maximum_refinement_function.h.bak         |   94 +
 .../minimum_refinement_function.h.bak         |   95 +
 .../nonadiabatic_temperature.h.bak            |   58 +
 .../nonadiabatic_temperature_threshold.h.bak  |   90 +
 .../mesh_refinement/particle_density.h.bak    |   69 +
 include/aspect/mesh_refinement/slope.h.bak    |   62 +
 .../aspect/mesh_refinement/strain_rate.h.bak  |   58 +
 .../aspect/mesh_refinement/temperature.h.bak  |   58 +
 .../thermal_energy_density.h.bak              |   59 +
 .../aspect/mesh_refinement/topography.h.bak   |   59 +
 include/aspect/mesh_refinement/velocity.h.bak |   58 +
 .../aspect/mesh_refinement/viscosity.h.bak    |   60 +
 .../volume_of_fluid_interface.h.bak           |   73 +
 include/aspect/newton.h.bak                   |  358 +
 include/aspect/parameters.h                   |    2 +-
 include/aspect/parameters.h.bak               |  802 ++
 .../particle/generator/ascii_file.h.bak       |   80 +
 .../aspect/particle/generator/interface.h.bak |  251 +
 .../probability_density_function.h.bak        |  128 +
 .../generator/quadrature_points.h.bak         |   63 +
 .../particle/generator/random_uniform.h.bak   |   98 +
 .../particle/generator/reference_cell.h.bak   |   94 +
 .../particle/generator/uniform_box.h.bak      |   99 +
 .../particle/generator/uniform_radial.h.bak   |  124 +
 .../aspect/particle/integrator/euler.h.bak    |  101 +
 .../particle/integrator/interface.h.bak       |  242 +
 include/aspect/particle/integrator/rk_2.h.bak |  155 +
 include/aspect/particle/integrator/rk_4.h.bak |  135 +
 include/aspect/particle/interface.h.bak       |   63 +
 .../interpolator/bilinear_least_squares.h.bak |  103 +
 .../particle/interpolator/cell_average.h.bak  |   80 +
 .../interpolator/harmonic_average.h.bak       |   80 +
 .../particle/interpolator/interface.h.bak     |  179 +
 .../interpolator/nearest_neighbor.h.bak       |   81 +
 .../quadratic_least_squares.h.bak             |  117 +
 .../particle/property/composition.h.bak       |   98 +
 .../property/cpo_bingham_average.h.bak        |  224 +
 .../property/cpo_elastic_tensor.h.bak         |  206 +
 .../property/crystal_preferred_orientation.h  |    2 +-
 .../crystal_preferred_orientation.h.bak       |  649 ++
 .../particle/property/elastic_stress.h.bak    |  104 +
 .../elastic_tensor_decomposition.h.bak        |  274 +
 .../aspect/particle/property/function.h.bak   |  101 +
 .../aspect/particle/property/grain_size.h.bak |  123 +
 .../property/initial_composition.h.bak        |   83 +
 .../particle/property/initial_position.h.bak  |   71 +
 .../particle/property/integrated_strain.h.bak |   99 +
 .../integrated_strain_invariant.h.bak         |   98 +
 .../aspect/particle/property/interface.h.bak  |  816 ++
 .../particle/property/melt_particle.h.bak     |  115 +
 .../aspect/particle/property/pT_path.h.bak    |  119 +
 .../aspect/particle/property/position.h.bak   |   87 +
 .../property/reference_position.h.bak         |   87 +
 .../particle/property/strain_rate.h.bak       |   97 +
 .../aspect/particle/property/velocity.h.bak   |   96 +
 .../viscoplastic_strain_invariants.h.bak      |  109 +
 include/aspect/particle/world.h.bak           |  531 ++
 include/aspect/plugins.h.bak                  |  808 ++
 .../aspect/postprocess/ODE_statistics.h.bak   |   82 +
 .../aspect/postprocess/basic_statistics.h.bak |   62 +
 .../postprocess/boundary_densities.h.bak      |   79 +
 .../postprocess/boundary_pressures.h.bak      |   79 +
 ...dary_strain_rate_residual_statistics.h.bak |  106 +
 ...oundary_velocity_residual_statistics.h.bak |  128 +
 include/aspect/postprocess/command.h.bak      |   72 +
 .../postprocess/composition_statistics.h.bak  |   53 +
 .../composition_velocity_statistics.h.bak     |   75 +
 .../aspect/postprocess/core_statistics.h.bak  |  106 +
 .../crystal_preferred_orientation.h.bak       |  279 +
 .../aspect/postprocess/depth_average.h.bak    |  156 +
 .../domain_volume_statistics.h.bak            |   54 +
 .../postprocess/dynamic_topography.h.bak      |  136 +
 .../entropy_viscosity_statistics.h.bak        |   52 +
 include/aspect/postprocess/geoid.h.bak        |  188 +
 .../postprocess/global_statistics.h.bak       |  153 +
 .../postprocess/gravity_point_values.h.bak    |  291 +
 .../postprocess/heat_flux_densities.h.bak     |   54 +
 .../aspect/postprocess/heat_flux_map.h.bak    |  109 +
 .../postprocess/heat_flux_statistics.h.bak    |   53 +
 .../postprocess/heating_statistics.h.bak      |   56 +
 include/aspect/postprocess/interface.h.bak    |  380 +
 .../postprocess/load_balance_statistics.h.bak |   66 +
 .../postprocess/mass_flux_statistics.h.bak    |   54 +
 .../postprocess/material_statistics.h.bak     |   54 +
 .../postprocess/matrix_statistics.h.bak       |   52 +
 .../aspect/postprocess/max_depth_field.h.bak  |   52 +
 .../aspect/postprocess/melt_statistics.h.bak  |   57 +
 .../postprocess/memory_statistics.h.bak       |   68 +
 .../postprocess/mobility_statistics.h.bak     |   52 +
 .../particle_count_statistics.h.bak           |   60 +
 include/aspect/postprocess/particles.h.bak    |  319 +
 include/aspect/postprocess/point_values.h.bak |  128 +
 .../postprocess/pressure_statistics.h.bak     |   52 +
 .../postprocess/rotation_statistics.h.bak     |   85 +
 include/aspect/postprocess/sea_level.h.bak    |  178 +
 .../spherical_velocity_statistics.h.bak       |   54 +
 .../aspect/postprocess/stokes_residual.h.bak  |  108 +
 .../postprocess/temperature_statistics.h.bak  |   52 +
 include/aspect/postprocess/topography.h.bak   |   91 +
 .../velocity_boundary_statistics.h.bak        |   55 +
 .../postprocess/velocity_statistics.h.bak     |   52 +
 .../viscous_dissipation_statistics.h.bak      |   54 +
 .../aspect/postprocess/visualization.h.bak    |  747 ++
 .../ISA_rotation_timescale.h.bak              |   72 +
 .../postprocess/visualization/adiabat.h.bak   |   68 +
 .../visualization/artificial_viscosity.h.bak  |   60 +
 .../artificial_viscosity_composition.h.bak    |   80 +
 .../visualization/boundary_indicator.h.bak    |   65 +
 .../boundary_strain_rate_residual.h.bak       |   87 +
 .../boundary_velocity_residual.h.bak          |   84 +
 .../visualization/compositional_vector.h.bak  |   86 +
 .../postprocess/visualization/depth.h.bak     |   58 +
 .../visualization/dynamic_topography.h.bak    |   75 +
 .../visualization/error_indicator.h.bak       |   59 +
 .../postprocess/visualization/geoid.h.bak     |   84 +
 .../visualization/grain_lag_angle.h.bak       |   79 +
 .../postprocess/visualization/gravity.h.bak   |   58 +
 .../visualization/heat_flux_map.h.bak         |  105 +
 .../postprocess/visualization/heating.h.bak   |   74 +
 .../visualization/kxrcf_indicator.h.bak       |   80 +
 .../visualization/material_properties.h.bak   |   92 +
 ...aximum_horizontal_compressive_stress.h.bak |   92 +
 .../postprocess/visualization/melt.h.bak      |   84 +
 .../visualization/melt_fraction.h.bak         |  116 +
 .../named_additional_outputs.h.bak            |   79 +
 .../visualization/nonadiabatic_pressure.h.bak |   62 +
 .../nonadiabatic_temperature.h.bak            |   62 +
 .../visualization/particle_count.h.bak        |   71 +
 .../postprocess/visualization/partition.h.bak |   62 +
 .../visualization/principal_stress.h.bak      |   82 +
 .../visualization/seismic_anomalies.h.bak     |  156 +
 .../visualization/shear_stress.h.bak          |   72 +
 .../visualization/spd_factor.h.bak            |   71 +
 .../spherical_velocity_components.h.bak       |   76 +
 .../visualization/strain_rate.h.bak           |   67 +
 .../visualization/strain_rate_tensor.h.bak    |   65 +
 .../postprocess/visualization/stress.h.bak    |   71 +
 .../stress_second_invariant.h.bak             |   67 +
 .../surface_dynamic_topography.h.bak          |   72 +
 .../visualization/surface_elevation.h.bak     |   68 +
 .../surface_strain_rate_tensor.h.bak          |   68 +
 .../visualization/surface_stress.h.bak        |   73 +
 .../visualization/temperature_anomaly.h.bak   |   93 +
 .../visualization/vertical_heat_flux.h.bak    |   67 +
 .../volume_of_fluid_values.h.bak              |  116 +
 .../volumetric_strain_rate.h.bak              |   62 +
 .../volume_of_fluid_statistics.h.bak          |   53 +
 .../ascii_data.h.bak                          |   85 +
 .../prescribed_stokes_solution/circle.h.bak   |   51 +
 .../prescribed_stokes_solution/function.h.bak |  105 +
 .../interface.h.bak                           |  159 +
 include/aspect/simulator.h.bak                | 2203 +++++
 .../simulator/assemblers/advection.h.bak      |  136 +
 .../simulator/assemblers/interface.h.bak      |  818 ++
 .../aspect/simulator/assemblers/stokes.h.bak  |  224 +
 include/aspect/simulator_access.h.bak         | 1002 +++
 include/aspect/simulator_signals.h.bak        |  420 +
 include/aspect/stokes_matrix_free.h.bak       |  702 ++
 include/aspect/structured_data.h.bak          |  778 ++
 .../termination_criteria/end_step.h.bak       |   70 +
 .../termination_criteria/end_time.h.bak       |   77 +
 .../termination_criteria/end_walltime.h.bak   |   84 +
 .../termination_criteria/interface.h.bak      |  244 +
 .../steady_heat_flux.h.bak                    |   94 +
 .../steady_rms_velocity.h.bak                 |   79 +
 .../steady_temperature.h.bak                  |   78 +
 .../termination_criteria/user_request.h.bak   |   72 +
 .../time_stepping/conduction_time_step.h.bak  |   61 +
 .../time_stepping/convection_time_step.h.bak  |   62 +
 include/aspect/time_stepping/function.h.bak   |   72 +
 include/aspect/time_stepping/interface.h.bak  |  284 +
 .../time_stepping/repeat_on_cutback.h.bak     |   85 +
 include/aspect/utilities.h.bak                | 1392 +++
 include/aspect/volume_of_fluid/assembly.h     |    4 +-
 include/aspect/volume_of_fluid/assembly.h.bak |  231 +
 include/aspect/volume_of_fluid/field.h.bak    |   96 +
 include/aspect/volume_of_fluid/handler.h      |    2 +-
 include/aspect/volume_of_fluid/handler.h.bak  |  226 +
 .../aspect/volume_of_fluid/utilities.h.bak    |  171 +
 source/adiabatic_conditions/ascii_data.cc.bak |  168 +
 .../compute_entropy_profile.cc.bak            |  315 +
 .../compute_profile.cc.bak                    |  427 +
 source/adiabatic_conditions/function.cc.bak   |  148 +
 source/adiabatic_conditions/interface.cc.bak  |  222 +
 source/boundary_composition/ascii_data.cc.bak |  131 +
 source/boundary_composition/box.cc.bak        |  180 +
 source/boundary_composition/function.cc.bak   |  146 +
 .../initial_composition.cc.bak                |  135 +
 source/boundary_composition/interface.cc.bak  |  376 +
 .../spherical_constant.cc.bak                 |  143 +
 .../two_merged_boxes.cc.bak                   |  207 +
 source/boundary_fluid_pressure/density.cc.bak |  154 +
 .../boundary_fluid_pressure/interface.cc.bak  |  155 +
 source/boundary_heat_flux/function.cc.bak     |  179 +
 source/boundary_heat_flux/interface.cc.bak    |  155 +
 source/boundary_temperature/ascii_data.cc.bak |  144 +
 source/boundary_temperature/box.cc.bak        |  173 +
 source/boundary_temperature/constant.cc.bak   |  189 +
 .../boundary_temperature/dynamic_core.cc.bak  |  986 +++
 source/boundary_temperature/function.cc.bak   |  186 +
 .../initial_temperature.cc.bak                |  134 +
 source/boundary_temperature/interface.cc.bak  |  390 +
 .../spherical_constant.cc.bak                 |  149 +
 .../two_merged_boxes.cc.bak                   |  191 +
 source/boundary_traction/ascii_data.cc.bak    |  140 +
 source/boundary_traction/function.cc.bak      |  158 +
 .../initial_lithostatic_pressure.cc.bak       |  442 +
 source/boundary_traction/interface.cc.bak     |  321 +
 source/boundary_traction/zero_traction.cc.bak |   62 +
 source/boundary_velocity/ascii_data.cc.bak    |  177 +
 source/boundary_velocity/function.cc.bak      |  185 +
 source/boundary_velocity/gplates.cc.bak       |  870 ++
 source/boundary_velocity/interface.cc.bak     |  414 +
 source/boundary_velocity/zero_velocity.cc.bak |   54 +
 source/citation_info.cc.bak                   |   55 +
 source/compat.cc.bak                          |  800 ++
 source/fe_variable_collection.cc.bak          |  268 +
 source/geometry_model/box.cc.bak              |  524 ++
 source/geometry_model/chunk.cc.bak            |  949 ++
 .../geometry_model/ellipsoidal_chunk.cc.bak   |  833 ++
 .../ascii_data.cc.bak                         |  204 +
 .../initial_topography_model/function.cc.bak  |  190 +
 .../initial_topography_model/interface.cc.bak |  176 +
 .../prm_polygon.cc.bak                        |  172 +
 .../zero_topography.cc.bak                    |   58 +
 source/geometry_model/interface.cc.bak        |  368 +
 source/geometry_model/sphere.cc.bak           |  238 +
 source/geometry_model/spherical_shell.cc.bak  | 1074 +++
 source/geometry_model/two_merged_boxes.cc.bak |  570 ++
 .../geometry_model/two_merged_chunks.cc.bak   |  635 ++
 source/global.cc.bak                          |  112 +
 source/gravity_model/ascii_data.cc.bak        |  126 +
 source/gravity_model/function.cc.bak          |  138 +
 source/gravity_model/interface.cc.bak         |  167 +
 source/gravity_model/radial.cc.bak            |  211 +
 source/gravity_model/vertical.cc.bak          |   98 +
 source/heating_model/adiabatic_heating.cc.bak |  112 +
 .../adiabatic_heating_of_melt.cc.bak          |  160 +
 .../compositional_heating.cc.bak              |  141 +
 source/heating_model/constant_heating.cc.bak  |   96 +
 source/heating_model/function.cc.bak          |  157 +
 source/heating_model/interface.cc.bak         |  324 +
 source/heating_model/latent_heat.cc.bak       |   63 +
 source/heating_model/latent_heat_melt.cc.bak  |  187 +
 source/heating_model/radioactive_decay.cc.bak |  206 +
 source/heating_model/shear_heating.cc.bak     |  203 +
 .../shear_heating_with_melt.cc.bak            |  122 +
 .../adiabatic_density.cc.bak                  |   54 +
 source/initial_composition/ascii_data.cc.bak  |  118 +
 .../ascii_data_layered.cc.bak                 |  123 +
 .../entropy_table_lookup.cc.bak               |  138 +
 source/initial_composition/function.cc.bak    |  125 +
 source/initial_composition/interface.cc.bak   |  275 +
 source/initial_composition/porosity.cc.bak    |  116 +
 source/initial_composition/slab_model.cc.bak  |  147 +
 .../initial_composition/world_builder.cc.bak  |  136 +
 .../S40RTS_perturbation.cc.bak                |  530 ++
 .../SAVANI_perturbation.cc.bak                |  537 ++
 source/initial_temperature/adiabatic.cc.bak   |  572 ++
 .../adiabatic_boundary.cc.bak                 |  136 +
 source/initial_temperature/ascii_data.cc.bak  |  112 +
 .../ascii_data_layered.cc.bak                 |  124 +
 .../initial_temperature/ascii_profile.cc.bak  |  112 +
 source/initial_temperature/box.cc.bak         |  276 +
 .../continental_geotherm.cc.bak               |  269 +
 source/initial_temperature/function.cc.bak    |  129 +
 .../harmonic_perturbation.cc.bak              |  234 +
 source/initial_temperature/interface.cc.bak   |  264 +
 .../lithosphere_mask.cc.bak                   |  223 +
 .../patch_on_S40RTS.cc.bak                    |  212 +
 .../prescribed_temperature.cc.bak             |   97 +
 .../random_gaussian_perturbation.cc.bak       |  211 +
 .../spherical_shell.cc.bak                    |  378 +
 .../initial_temperature/world_builder.cc.bak  |   84 +
 source/main.cc.bak                            |  892 ++
 .../ascii_reference_profile.cc.bak            |  280 +
 source/material_model/averaging.cc.bak        |  464 +
 source/material_model/compositing.cc.bak      |  259 +
 .../composition_reaction.cc.bak               |  250 +
 source/material_model/depth_dependent.cc.bak  |  350 +
 .../diffusion_dislocation.cc.bak              |  219 +
 source/material_model/drucker_prager.cc.bak   |  323 +
 source/material_model/entropy_model.cc.bak    |  577 ++
 .../equation_of_state/interface.cc.bak        |   85 +
 .../linearized_incompressible.cc.bak          |  160 +
 .../multicomponent_compressible.cc.bak        |  177 +
 .../multicomponent_incompressible.cc.bak      |  156 +
 .../thermodynamic_table_lookup.cc.bak         |  579 ++
 source/material_model/grain_size.cc.bak       | 1687 ++++
 source/material_model/interface.cc.bak        | 1239 +++
 source/material_model/latent_heat.cc.bak      |  422 +
 source/material_model/latent_heat_melt.cc.bak |  660 ++
 source/material_model/melt_boukare.cc         |    4 +-
 source/material_model/melt_boukare.cc.bak     | 1314 +++
 source/material_model/melt_global.cc.bak      |  556 ++
 source/material_model/melt_simple.cc.bak      |  284 +
 source/material_model/modified_tait.cc.bak    |  271 +
 source/material_model/multicomponent.cc.bak   |  179 +
 .../multicomponent_compressible.cc.bak        |  184 +
 source/material_model/nondimensional.cc.bak   |  216 +
 source/material_model/perplex_lookup.cc.bak   |  230 +
 .../prescribed_viscosity.cc.bak               |  210 +
 .../katz2003_mantle_melting.cc.bak            |  651 ++
 .../reactive_fluid_transport.cc               |    2 +-
 .../reactive_fluid_transport.cc.bak           |  585 ++
 .../replace_lithosphere_viscosity.cc.bak      |  172 +
 .../rheology/ascii_depth_profile.cc.bak       |   99 +
 .../rheology/composite_visco_plastic.cc.bak   |  458 +
 .../compositional_viscosity_prefactors.cc.bak |  178 +
 .../rheology/constant_viscosity.cc.bak        |   67 +
 .../constant_viscosity_prefactors.cc.bak      |  105 +
 .../rheology/diffusion_creep.cc.bak           |  303 +
 .../rheology/diffusion_dislocation.cc.bak     |  386 +
 .../rheology/dislocation_creep.cc.bak         |  285 +
 .../rheology/drucker_prager.cc.bak            |  294 +
 .../material_model/rheology/elasticity.cc.bak |  529 ++
 .../rheology/frank_kamenetskii.cc.bak         |  156 +
 .../rheology/friction_models.cc.bak           |  312 +
 .../rheology/peierls_creep.cc.bak             |  679 ++
 .../rheology/strain_dependent.cc.bak          |  917 ++
 .../rheology/visco_plastic.cc.bak             |  855 ++
 source/material_model/simple.cc.bak           |  265 +
 .../material_model/simple_compressible.cc.bak |  170 +
 source/material_model/simpler.cc.bak          |  131 +
 source/material_model/steinberger.cc.bak      |  631 ++
 source/material_model/utilities.cc.bak        | 1546 ++++
 source/material_model/visco_plastic.cc.bak    |  678 ++
 source/material_model/viscoelastic.cc.bak     |  313 +
 source/mesh_deformation/ascii_data.cc.bak     |  151 +
 source/mesh_deformation/diffusion.cc.bak      |  582 ++
 source/mesh_deformation/fastscape.cc.bak      | 1997 +++++
 source/mesh_deformation/free_surface.cc.bak   |  336 +
 source/mesh_deformation/function.cc.bak       |  149 +
 source/mesh_deformation/interface.cc.bak      | 1605 ++++
 .../artificial_viscosity.cc.bak               |  132 +
 source/mesh_refinement/boundary.cc.bak        |  122 +
 .../mesh_refinement/compaction_length.cc.bak  |  158 +
 source/mesh_refinement/composition.cc.bak     |  152 +
 .../composition_approximate_gradient.cc.bak   |  153 +
 .../composition_gradient.cc.bak               |  185 +
 .../composition_threshold.cc.bak              |  137 +
 source/mesh_refinement/density.cc.bak         |  143 +
 source/mesh_refinement/interface.cc.bak       |  519 ++
 source/mesh_refinement/isosurfaces.cc.bak     |  404 +
 .../maximum_refinement_function.cc.bak        |  193 +
 .../minimum_refinement_function.cc.bak        |  192 +
 .../nonadiabatic_temperature.cc.bak           |  127 +
 .../nonadiabatic_temperature_threshold.cc.bak |  158 +
 .../mesh_refinement/particle_density.cc.bak   |   75 +
 source/mesh_refinement/slope.cc.bak           |  103 +
 source/mesh_refinement/strain_rate.cc.bak     |   75 +
 source/mesh_refinement/temperature.cc.bak     |   83 +
 .../thermal_energy_density.cc.bak             |  144 +
 source/mesh_refinement/topography.cc.bak      |   87 +
 source/mesh_refinement/velocity.cc.bak        |   83 +
 source/mesh_refinement/viscosity.cc.bak       |  148 +
 .../volume_of_fluid_interface.cc.bak          |  345 +
 source/particle/generator/ascii_file.cc.bak   |  133 +
 source/particle/generator/interface.cc.bak    |  306 +
 .../probability_density_function.cc.bak       |  149 +
 .../generator/quadrature_points.cc.bak        |   63 +
 .../particle/generator/random_uniform.cc.bak  |  123 +
 .../particle/generator/reference_cell.cc.bak  |  148 +
 source/particle/generator/uniform_box.cc.bak  |  175 +
 .../particle/generator/uniform_radial.cc.bak  |  254 +
 source/particle/integrator/euler.cc.bak       |  103 +
 source/particle/integrator/interface.cc.bak   |  248 +
 source/particle/integrator/rk_2.cc.bak        |  242 +
 source/particle/integrator/rk_4.cc.bak        |  281 +
 source/particle/interface.cc.bak              |   42 +
 .../bilinear_least_squares.cc.bak             |  364 +
 .../particle/interpolator/cell_average.cc.bak |  161 +
 .../interpolator/harmonic_average.cc.bak      |  169 +
 source/particle/interpolator/interface.cc.bak |  149 +
 .../interpolator/nearest_neighbor.cc.bak      |  161 +
 .../quadratic_least_squares.cc.bak            |  640 ++
 source/particle/property/composition.cc.bak   |  110 +
 .../property/cpo_bingham_average.cc.bak       |  284 +
 .../property/cpo_elastic_tensor.cc.bak        |  261 +
 .../property/crystal_preferred_orientation.cc |    2 +-
 .../crystal_preferred_orientation.cc.bak      | 1275 +++
 .../particle/property/elastic_stress.cc.bak   |  199 +
 .../elastic_tensor_decomposition.cc.bak       |  468 +
 source/particle/property/function.cc.bak      |  113 +
 source/particle/property/grain_size.cc.bak    |  173 +
 .../property/initial_composition.cc.bak       |   91 +
 .../particle/property/initial_position.cc.bak |   72 +
 .../property/integrated_strain.cc.bak         |  124 +
 .../integrated_strain_invariant.cc.bak        |  118 +
 source/particle/property/interface.cc.bak     |  820 ++
 source/particle/property/melt_particle.cc.bak |  126 +
 source/particle/property/pT_path.cc.bak       |  123 +
 source/particle/property/position.cc.bak      |   80 +
 .../property/reference_position.cc.bak        |   80 +
 source/particle/property/strain_rate.cc.bak   |  102 +
 source/particle/property/velocity.cc.bak      |   88 +
 .../viscoplastic_strain_invariants.cc.bak     |  243 +
 source/particle/world.cc.bak                  | 1384 +++
 source/plugins.cc.bak                         |   50 +
 source/postprocess/ODE_statistics.cc.bak      |  108 +
 source/postprocess/basic_statistics.cc.bak    |  165 +
 source/postprocess/boundary_densities.cc.bak  |  177 +
 source/postprocess/boundary_pressures.cc.bak  |  156 +
 ...ary_strain_rate_residual_statistics.cc.bak |  332 +
 ...undary_velocity_residual_statistics.cc.bak |  376 +
 source/postprocess/command.cc.bak             |  131 +
 .../postprocess/composition_statistics.cc.bak |  168 +
 .../composition_velocity_statistics.cc.bak    |  205 +
 source/postprocess/core_statistics.cc.bak     |  236 +
 .../crystal_preferred_orientation.cc.bak      |  870 ++
 source/postprocess/depth_average.cc.bak       |  517 ++
 .../domain_volume_statistics.cc.bak           |   69 +
 source/postprocess/dynamic_topography.cc.bak  |  548 ++
 .../entropy_viscosity_statistics.cc.bak       |  118 +
 source/postprocess/geoid.cc.bak               | 1060 +++
 source/postprocess/global_statistics.cc.bak   |  324 +
 .../postprocess/gravity_point_values.cc.bak   |  850 ++
 source/postprocess/heat_flux_densities.cc.bak |  157 +
 source/postprocess/heat_flux_map.cc.bak       |  565 ++
 .../postprocess/heat_flux_statistics.cc.bak   |  160 +
 source/postprocess/heating_statistics.cc.bak  |  166 +
 source/postprocess/interface.cc.bak           |  414 +
 .../load_balance_statistics.cc.bak            |  111 +
 .../postprocess/mass_flux_statistics.cc.bak   |  188 +
 source/postprocess/material_statistics.cc.bak |  128 +
 source/postprocess/matrix_statistics.cc.bak   |  119 +
 source/postprocess/max_depth_field.cc.bak     |  131 +
 source/postprocess/melt_statistics.cc.bak     |  152 +
 source/postprocess/memory_statistics.cc.bak   |  141 +
 source/postprocess/mobility_statistics.cc.bak |  156 +
 .../particle_count_statistics.cc.bak          |   97 +
 source/postprocess/particles.cc.bak           |  758 ++
 source/postprocess/point_values.cc.bak        |  369 +
 source/postprocess/pressure_statistics.cc.bak |  144 +
 source/postprocess/rotation_statistics.cc.bak |  202 +
 source/postprocess/sea_level.cc.bak           |  618 ++
 .../spherical_velocity_statistics.cc.bak      |  170 +
 source/postprocess/stokes_residual.cc.bak     |  179 +
 .../postprocess/temperature_statistics.cc.bak |  172 +
 source/postprocess/topography.cc.bak          |  250 +
 .../velocity_boundary_statistics.cc.bak       |  217 +
 source/postprocess/velocity_statistics.cc.bak |  118 +
 .../viscous_dissipation_statistics.cc.bak     |  168 +
 source/postprocess/visualization.cc.bak       | 1688 ++++
 .../ISA_rotation_timescale.cc.bak             |  116 +
 .../postprocess/visualization/adiabat.cc.bak  |  120 +
 .../visualization/artificial_viscosity.cc.bak |   84 +
 .../artificial_viscosity_composition.cc.bak   |  135 +
 .../visualization/boundary_indicator.cc.bak   |  112 +
 .../boundary_strain_rate_residual.cc.bak      |  148 +
 .../boundary_velocity_residual.cc.bak         |  126 +
 .../visualization/compositional_vector.cc.bak |  196 +
 source/postprocess/visualization/depth.cc.bak |   93 +
 .../visualization/dynamic_topography.cc.bak   |  142 +
 .../visualization/error_indicator.cc.bak      |   78 +
 source/postprocess/visualization/geoid.cc.bak |  113 +
 .../visualization/grain_lag_angle.cc.bak      |  180 +
 .../postprocess/visualization/gravity.cc.bak  |   80 +
 .../visualization/heat_flux_map.cc.bak        |  208 +
 .../postprocess/visualization/heating.cc.bak  |  188 +
 .../visualization/kxrcf_indicator.cc.bak      |  135 +
 .../visualization/material_properties.cc.bak  |  306 +
 ...ximum_horizontal_compressive_stress.cc.bak |  366 +
 source/postprocess/visualization/melt.cc.bak  |  278 +
 .../visualization/melt_fraction.cc.bak        |  354 +
 .../named_additional_outputs.cc.bak           |  184 +
 .../nonadiabatic_pressure.cc.bak              |   91 +
 .../nonadiabatic_temperature.cc.bak           |   81 +
 .../visualization/particle_count.cc.bak       |   90 +
 .../visualization/partition.cc.bak            |   81 +
 .../visualization/principal_stress.cc.bak     |  242 +
 .../visualization/seismic_anomalies.cc.bak    |  566 ++
 .../visualization/shear_stress.cc.bak         |  148 +
 .../visualization/spd_factor.cc.bak           |  109 +
 .../spherical_velocity_components.cc.bak      |  145 +
 .../visualization/strain_rate.cc.bak          |   97 +
 .../visualization/strain_rate_tensor.cc.bak   |  105 +
 .../postprocess/visualization/stress.cc.bak   |  147 +
 .../stress_second_invariant.cc.bak            |  137 +
 .../surface_dynamic_topography.cc.bak         |  135 +
 .../visualization/surface_elevation.cc.bak    |  110 +
 .../surface_strain_rate_tensor.cc.bak         |  109 +
 .../visualization/surface_stress.cc.bak       |  143 +
 .../visualization/temperature_anomaly.cc.bak  |  190 +
 .../visualization/vertical_heat_flux.cc.bak   |  106 +
 .../volume_of_fluid_values.cc.bak             |  209 +
 .../volumetric_strain_rate.cc.bak             |   95 +
 .../volume_of_fluid_statistics.cc.bak         |  117 +
 .../ascii_data.cc.bak                         |  121 +
 .../prescribed_stokes_solution/circle.cc.bak  |   70 +
 .../function.cc.bak                           |  246 +
 .../interface.cc.bak                          |  156 +
 source/simulator/assemblers/advection.cc.bak  | 1634 ++++
 source/simulator/assemblers/interface.cc.bak  |  656 ++
 .../simulator/assemblers/newton_stokes.cc.bak |  972 ++
 source/simulator/assemblers/stokes.cc.bak     |  994 +++
 source/simulator/assembly.cc.bak              | 1301 +++
 source/simulator/checkpoint_restart.cc.bak    |  650 ++
 source/simulator/core.cc                      |    2 +-
 source/simulator/core.cc.bak                  | 2199 +++++
 source/simulator/entropy_viscosity.cc.bak     |  710 ++
 source/simulator/helper_functions.cc.bak      | 2521 ++++++
 source/simulator/initial_conditions.cc.bak    |  545 ++
 source/simulator/introspection.cc.bak         |  615 ++
 source/simulator/lateral_averaging.cc.bak     |  972 ++
 source/simulator/limiters.cc.bak              |  876 ++
 source/simulator/melt.cc.bak                  | 1960 +++++
 source/simulator/newton.cc.bak                |  318 +
 source/simulator/nullspace.cc.bak             |  522 ++
 source/simulator/parameters.cc                |    6 +-
 source/simulator/parameters.cc.bak            | 2329 +++++
 source/simulator/simulator_access.cc.bak      |  901 ++
 source/simulator/simulator_signals.cc.bak     |  102 +
 source/simulator/solver.cc.bak                | 1270 +++
 source/simulator/solver_schemes.cc.bak        | 1411 +++
 source/simulator/stokes_matrix_free.cc.bak    | 2798 ++++++
 source/structured_data.cc.bak                 | 1952 +++++
 source/termination_criteria/end_step.cc.bak   |   71 +
 source/termination_criteria/end_time.cc.bak   |   95 +
 .../termination_criteria/end_walltime.cc.bak  |   80 +
 source/termination_criteria/interface.cc.bak  |  284 +
 .../steady_heat_flux.cc.bak                   |  233 +
 .../steady_rms_velocity.cc.bak                |  172 +
 .../steady_temperature.cc.bak                 |  199 +
 .../termination_criteria/user_request.cc.bak  |   95 +
 .../time_stepping/conduction_time_step.cc.bak |  131 +
 .../time_stepping/convection_time_step.cc.bak |  109 +
 source/time_stepping/function.cc.bak          |  106 +
 source/time_stepping/interface.cc.bak         |  380 +
 source/time_stepping/repeat_on_cutback.cc.bak |  115 +
 source/utilities.cc.bak                       | 3601 ++++++++
 source/volume_of_fluid/assembler.cc           |    2 +-
 source/volume_of_fluid/assembler.cc.bak       |  650 ++
 source/volume_of_fluid/handler.cc.bak         |  647 ++
 source/volume_of_fluid/reconstruct.cc.bak     |  519 ++
 .../setup_initial_conditions.cc.bak           |  245 +
 source/volume_of_fluid/solver.cc.bak          |  106 +
 source/volume_of_fluid/utilities.cc.bak       |  694 ++
 tests/2d_annulus_pyvista_cookbook.prm.bak     |   90 +
 tests/ISA_rotation_timescale.prm.bak          |  102 +
 tests/Picard_compressible.prm.bak             |  249 +
 tests/additional_outputs_02.cc.bak            |  171 +
 tests/additional_outputs_02.prm.bak           |   77 +
 tests/additional_outputs_03.cc.bak            |  185 +
 tests/additional_outputs_03.prm.bak           |   78 +
 tests/adiabatic_boundary.prm.bak              |   66 +
 tests/adiabatic_conditions.prm.bak            |   75 +
 ...ic_conditions_composition_function.prm.bak |   83 +
 tests/adiabatic_conditions_function.prm.bak   |   83 +
 .../adiabatic_conditions_time_change.prm.bak  |   88 +
 tests/adiabatic_heating.prm.bak               |  124 +
 tests/adiabatic_heating_simplified.prm.bak    |  130 +
 tests/adiabatic_heating_with_melt.prm.bak     |  146 +
 tests/adiabatic_initial_conditions.prm.bak    |   99 +
 ...adiabatic_initial_conditions_chunk.prm.bak |   94 +
 ...abatic_initial_conditions_chunk_3d.prm.bak |   98 +
 ...ic_initial_conditions_compressible.prm.bak |   95 +
 ...abatic_initial_conditions_constant.prm.bak |   89 +
 ...diabatic_initial_conditions_points.prm.bak |  105 +
 ...initial_conditions_subadiabaticity.prm.bak |   93 +
 ...nitial_conditions_without_boundary.prm.bak |   66 +
 tests/adiabatic_plate_cooling.prm.bak         |   81 +
 tests/adiabatic_plate_function.prm.bak        |   86 +
 tests/advect_field_with_melt_velocity.cc.bak  |   21 +
 tests/advect_field_with_melt_velocity.prm.bak |  142 +
 tests/advect_mesh_vertically.prm.bak          |  128 +
 tests/advection_reaction.cc.bak               |   21 +
 tests/advection_reaction.prm.bak              |  152 +
 tests/advection_solver_fail.prm.bak           |   12 +
 tests/airy_isostasy.prm.bak                   |  140 +
 tests/airy_isostasy_initial_topo.cc.bak       |   77 +
 tests/airy_isostasy_initial_topo.prm.bak      |   37 +
 ..._initial_topo_lithostatic_pressure.prm.bak |   41 +
 tests/always_refine.prm.bak                   |  107 +
 tests/analytic_artificial_viscosity_0.prm.bak |   93 +
 tests/anisotropic_viscosity.cc.bak            |  830 ++
 tests/anisotropic_viscosity.prm.bak           |   91 +
 tests/annulus.cc.bak                          |   21 +
 tests/annulus.prm.bak                         |   10 +
 tests/annulus_transient.cc.bak                |   21 +
 tests/annulus_transient.prm.bak               |   96 +
 tests/artificial_postprocess.cc.bak           |   83 +
 tests/artificial_postprocess.prm.bak          |  112 +
 tests/artificial_viscosity.prm.bak            |  124 +
 ...ial_viscosity_dirichlet_boundaries.prm.bak |  110 +
 tests/artificial_viscosity_list.prm.bak       |   93 +
 tests/ascii_boundary_member.cc.bak            |  212 +
 tests/ascii_boundary_member.prm.bak           |   67 +
 tests/ascii_data_adiabatic_conditions.prm.bak |   78 +
 ...a_boundary_composition_2d_box_time.prm.bak |   89 +
 ...i_data_boundary_composition_3d_box.prm.bak |   78 +
 ...a_boundary_temperature_2d_box_time.prm.bak |   71 +
 ...i_data_boundary_temperature_3d_box.prm.bak |   68 +
 ...scii_data_boundary_velocity_2d_box.prm.bak |   67 +
 ...data_boundary_velocity_2d_box_list.prm.bak |   73 +
 ...data_boundary_velocity_2d_box_time.prm.bak |   74 +
 ...dary_velocity_2d_box_time_backward.prm.bak |   77 +
 ...locity_2d_box_time_non_equidistant.prm.bak |   73 +
 ...ii_data_boundary_velocity_2d_chunk.prm.bak |   72 +
 ...ii_data_boundary_velocity_2d_shell.prm.bak |   72 +
 ...undary_velocity_2d_shell_spherical.prm.bak |   73 +
 ...scii_data_boundary_velocity_3d_box.prm.bak |   74 +
 ...ii_data_boundary_velocity_3d_chunk.prm.bak |   75 +
 ...ii_data_boundary_velocity_3d_shell.prm.bak |   72 +
 ...undary_velocity_3d_shell_spherical.prm.bak |   73 +
 ...i_data_boundary_velocity_3d_sphere.prm.bak |   70 +
 ...a_boundary_velocity_residual_shell.prm.bak |   84 +
 tests/ascii_data_fail_1.prm.bak               |   71 +
 tests/ascii_data_fail_2.prm.bak               |   71 +
 tests/ascii_data_fail_3.prm.bak               |   71 +
 tests/ascii_data_fail_4.prm.bak               |   71 +
 tests/ascii_data_gravity.prm.bak              |   79 +
 ...ii_data_initial_composition_2d_box.prm.bak |   77 +
 ...data_initial_composition_2d_box_gz.prm.bak |   79 +
 ..._data_initial_composition_3d_chunk.prm.bak |   85 +
 ..._data_initial_composition_3d_shell.prm.bak |   83 +
 ...ii_data_initial_temperature_2d_box.prm.bak |   59 +
 ..._data_initial_temperature_3d_chunk.prm.bak |   63 +
 ...l_temperature_3d_ellipsoidal_chunk.prm.bak |   62 +
 ..._data_initial_temperature_3d_shell.prm.bak |   60 +
 ..._initial_temperature_3d_two_chunks.prm.bak |   66 +
 ...layered_initial_composition_2d_box.prm.bak |   77 +
 ...layered_initial_temperature_2d_box.prm.bak |   65 +
 ...yered_initial_temperature_2d_chunk.prm.bak |   67 +
 ...layered_initial_temperature_3d_box.prm.bak |   67 +
 ...yered_initial_temperature_3d_chunk.prm.bak |   74 +
 ...perature_piecewise_constant_3d_box.prm.bak |   66 +
 ...uniform_initial_composition_2d_box.prm.bak |   87 +
 ...scii_data_prescribed_stokes_2d_box.prm.bak |   73 +
 tests/ascii_data_slice.prm.bak                |  111 +
 tests/ascii_data_slice_temperature.prm.bak    |   64 +
 tests/average_arithmetic.prm.bak              |   95 +
 ...ge_density_boundary_fluid_pressure.prm.bak |  280 +
 tests/average_geometric.prm.bak               |   95 +
 tests/average_harmonic.prm.bak                |   95 +
 tests/average_log.prm.bak                     |   95 +
 tests/average_none.prm.bak                    |   96 +
 tests/average_nwd_arithmetic.prm.bak          |  100 +
 tests/average_nwd_geometric.prm.bak           |  100 +
 tests/average_nwd_harmonic.prm.bak            |  100 +
 tests/average_pick_largest.prm.bak            |   95 +
 tests/average_project_to_q1.prm.bak           |   96 +
 tests/background_output_writer.prm.bak        |   14 +
 tests/backward_advection.prm.bak              |   84 +
 tests/benchmark_layeredflow.cc.bak            |   21 +
 tests/benchmark_layeredflow.prm.bak           |   13 +
 ...chmark_particle_integration_scheme.prm.bak |    7 +
 tests/blankenbach.prm.bak                     |   80 +
 tests/blankenbach_approximation.prm.bak       |   93 +
 tests/blankenbach_case1a.cc.bak               |   22 +
 tests/blankenbach_case1a.prm.bak              |   20 +
 tests/blankenbach_case1b.cc.bak               |   22 +
 tests/blankenbach_case1b.prm.bak              |   26 +
 tests/blankenbach_case1c.cc.bak               |   22 +
 tests/blankenbach_case1c.prm.bak              |   26 +
 tests/blankenbach_case2a.cc.bak               |   22 +
 tests/blankenbach_case2a.prm.bak              |   20 +
 tests/blankenbach_case2b.cc.bak               |   22 +
 tests/blankenbach_case2b.prm.bak              |   20 +
 tests/boukare_bulk_composition.prm            |    4 +-
 tests/boukare_bulk_composition.prm.bak        |  211 +
 tests/boukare_conserve_mass.prm               |    4 +-
 tests/boukare_conserve_mass.prm.bak           |  159 +
 tests/boukare_latent_heat.prm                 |    2 +-
 tests/boukare_latent_heat.prm.bak             |  166 +
 tests/boukare_melting_diagram.prm.bak         |  162 +
 tests/boundary_composition_list.prm.bak       |  103 +
 ...dary_composition_passive_cartesian.prm.bak |  102 +
 ...boundary_composition_passive_depth.prm.bak |  102 +
 ...oundary_composition_passive_sphere.prm.bak |  102 +
 tests/boundary_heatflux.prm.bak               |  124 +
 tests/boundary_heatflux_update.cc.bak         |  108 +
 tests/boundary_heatflux_update.prm.bak        |  102 +
 tests/boundary_temperature_function.prm.bak   |   70 +
 tests/boundary_temperature_list.prm.bak       |   74 +
 ...on_function_cartesian_free_surface.prm.bak |  143 +
 ...on_function_spherical_free_surface.prm.bak |  144 +
 ...undary_velocity_function_spherical.prm.bak |   74 +
 tests/box_end_time_1e7_terminate.prm.bak      |   67 +
 tests/box_first_time_step.prm.bak             |   58 +
 .../box_first_time_step_alternate_bc.prm.bak  |   64 +
 tests/box_initial_mesh_deformation.cc.bak     |   68 +
 tests/box_initial_mesh_deformation.prm.bak    |   81 +
 ...nitial_mesh_deformation_ascii_data.prm.bak |  102 +
 ...x_initial_mesh_deformation_periodic.cc.bak |   21 +
 ..._initial_mesh_deformation_periodic.prm.bak |   25 +
 .../box_initial_topography_ascii_data.prm.bak |   99 +
 ...topography_ascii_data_moved_origin.prm.bak |  101 +
 tests/box_initial_topography_function.prm.bak |   98 +
 ...box_initial_topography_prm_polygon.prm.bak |   91 +
 tests/box_lithostatic_pressure_2d.prm.bak     |  142 +
 tests/box_lithostatic_pressure_3d.prm.bak     |  140 +
 tests/box_origin.prm.bak                      |   68 +
 tests/box_repetitions.prm.bak                 |   65 +
 ...simple_log_viscosity_depth_average.prm.bak |  104 +
 ...ox_simple_surface_strain_rate_residual.prm |    6 +-
 ...imple_surface_strain_rate_residual.prm.bak |   99 +
 tests/box_steady_state_terminate.prm.bak      |   63 +
 .../box_steady_temperature_terminate.prm.bak  |   73 +
 tests/box_surface_base_variables.prm          |    4 -
 tests/box_surface_base_variables.prm.bak      |  105 +
 tests/bunge_cookbook.prm.bak                  |   17 +
 tests/burnman_seismic_test.prm.bak            |  151 +
 tests/burnman_test.prm.bak                    |  128 +
 tests/burstedde.cc.bak                        |   21 +
 tests/burstedde.prm.bak                       |   94 +
 tests/burstedde_stokes_rhs.cc.bak             |  472 +
 tests/burstedde_stokes_rhs.prm.bak            |   99 +
 tests/cell_reference.cc.bak                   |   61 +
 tests/cell_reference.prm.bak                  |   68 +
 tests/cells_in_circumference.prm.bak          |   91 +
 ...check_compositional_field_functions.cc.bak |   71 +
 ...heck_compositional_field_functions.prm.bak |   13 +
 tests/check_compositional_field_names.cc.bak  |   76 +
 tests/check_compositional_field_names.prm.bak |   14 +
 tests/checkpoint_01.cc.bak                    |  100 +
 tests/checkpoint_01.prm.bak                   |   87 +
 tests/checkpoint_01_check_parameters.cc.bak   |  112 +
 tests/checkpoint_01_check_parameters.prm.bak  |   85 +
 tests/checkpoint_02.cc.bak                    |   97 +
 tests/checkpoint_02.prm.bak                   |   86 +
 tests/checkpoint_02_direct.cc.bak             |   97 +
 tests/checkpoint_02_direct.prm.bak            |   81 +
 tests/checkpoint_03_particles.cc.bak          |   98 +
 tests/checkpoint_03_particles.prm.bak         |   97 +
 .../checkpoint_04_particles_no_output.cc.bak  |   96 +
 .../checkpoint_04_particles_no_output.prm.bak |   97 +
 tests/checkpoint_05_mpi_create.prm.bak        |    5 +
 tests/checkpoint_05_mpi_resume.cc.bak         |   55 +
 tests/checkpoint_05_mpi_resume.prm.bak        |   12 +
 tests/checkpoint_06_spherical_shell.cc.bak    |   98 +
 tests/checkpoint_06_spherical_shell.prm.bak   |   66 +
 ...oint_07_enable_free_surface_create.prm.bak |   74 +
 ...point_07_enable_free_surface_resume.cc.bak |   55 +
 ...oint_07_enable_free_surface_resume.prm.bak |   31 +
 tests/chunk_ascii_initial_temperature.prm.bak |   75 +
 tests/chunk_conditions.prm.bak                |   77 +
 tests/chunk_cross_hemisphere.prm.bak          |   74 +
 tests/chunk_first_time_step_2d.prm.bak        |   74 +
 tests/chunk_first_time_step_3d.prm.bak        |   74 +
 ...hunk_initial_topography_ascii_data.prm.bak |   83 +
 ...k_initial_topography_ascii_data_3d.prm.bak |   88 +
 ...opography_ascii_data_3d_colatitude.prm.bak |   19 +
 tests/chunk_lithostatic_pressure_2d.prm.bak   |  132 +
 ...tic_pressure_2d_initial_topography.prm.bak |   46 +
 tests/chunk_tangential_velocity.prm.bak       |   92 +
 tests/chunk_topography_postprocessor.prm.bak  |  115 +
 tests/command_postprocessor.prm.bak           |   40 +
 tests/compaction_length_refinement.prm.bak    |  128 +
 tests/compaction_length_visualization.prm.bak |  123 +
 tests/composite_viscous_outputs.cc.bak        |  208 +
 tests/composite_viscous_outputs.prm.bak       |   80 +
 tests/compositing_02.prm.bak                  |  119 +
 tests/compositing_named_outputs.prm.bak       |   92 +
 tests/composition_active.prm.bak              |  107 +
 tests/composition_active_nans.prm.bak         |   21 +
 tests/composition_active_with_melt.cc.bak     |  158 +
 tests/composition_active_with_melt.prm.bak    |  106 +
 tests/composition_active_without_melt.cc.bak  |   21 +
 tests/composition_active_without_melt.prm.bak |  100 +
 tests/composition_cg_dg_fem.prm.bak           |   96 +
 tests/composition_names.prm.bak               |  117 +
 tests/composition_names_duplicates.prm.bak    |   95 +
 ...ion_passive_discontinuous_constant.prm.bak |   99 +
 tests/composition_passive_particles.prm.bak   |  111 +
 ...on_passive_quarter_shell_cartesian.prm.bak |  108 +
 ...sition_passive_quarter_shell_depth.prm.bak |  108 +
 ...on_passive_quarter_shell_spherical.prm.bak |  108 +
 tests/composition_passive_static.prm.bak      |   95 +
 tests/composition_reaction.prm.bak            |  110 +
 ...composition_reaction_iterated_IMPES.cc.bak |   91 +
 ...omposition_reaction_iterated_IMPES.prm.bak |  121 +
 tests/composition_stabilization.prm.bak       |  113 +
 tests/compositional_boundary_values.prm.bak   |  101 +
 .../compositional_boundary_values_02.prm.bak  |  102 +
 .../compositional_boundary_values_03.prm.bak  |  100 +
 tests/compositional_heating.prm.bak           |  166 +
 ...itional_heating_exclude_background.prm.bak |  113 +
 tests/compositional_vectors.prm.bak           |   60 +
 tests/compositional_vectors_3d.prm.bak        |   60 +
 tests/compressibility.cc.bak                  |  215 +
 tests/compressibility.prm.bak                 |  110 +
 tests/compressibility_iterated_stokes.cc.bak  |   89 +
 tests/compressibility_iterated_stokes.prm.bak |   99 +
 ...ility_iterated_stokes_direct_solver.cc.bak |   21 +
 ...lity_iterated_stokes_direct_solver.prm.bak |   86 +
 tests/compressibility_lateral_pipe.cc.bak     |   21 +
 tests/compressibility_lateral_pipe.prm.bak    |    5 +
 ...compressibility_lateral_pipe_advect.cc.bak |   21 +
 ...ompressibility_lateral_pipe_advect.prm.bak |    5 +
 ...teral_pipe_advect_projected_density.cc.bak |   21 +
 ...eral_pipe_advect_projected_density.prm.bak |    8 +
 ...lity_lateral_pipe_increase_pressure.cc.bak |   21 +
 ...ity_lateral_pipe_increase_pressure.prm.bak |    5 +
 ...increase_pressure_projected_density.cc.bak |   21 +
 ...ncrease_pressure_projected_density.prm.bak |    8 +
 ...lity_lateral_pipe_projected_density.cc.bak |   21 +
 ...ity_lateral_pipe_projected_density.prm.bak |    8 +
 ...pressibility_lateral_pipe_transient.cc.bak |   21 +
 ...ressibility_lateral_pipe_transient.prm.bak |    5 +
 ...al_pipe_transient_projected_density.cc.bak |   21 +
 ...l_pipe_transient_projected_density.prm.bak |    8 +
 tests/compressibility_vertical_pipe.cc.bak    |   21 +
 tests/compressibility_vertical_pipe.prm.bak   |    5 +
 ...ity_vertical_pipe_projected_density.cc.bak |   21 +
 ...ty_vertical_pipe_projected_density.prm.bak |    8 +
 ...pressibility_volumetric_strain_rate.cc.bak |   21 +
 ...ressibility_volumetric_strain_rate.prm.bak |   87 +
 tests/compressible_forsterite_box.prm.bak     |   87 +
 tests/compression_heating.cc.bak              |   69 +
 tests/compression_heating.prm.bak             |  141 +
 ...compute-no-normal-flux-constraints.prm.bak |  146 +
 tests/conservative_with_mpi.cc.bak            |   21 +
 tests/conservative_with_mpi.prm.bak           |   81 +
 ...t_boundary_flux_adjacent_dirichlet.prm.bak |   90 +
 .../consistent_boundary_flux_neumann.prm.bak  |   84 +
 ...istent_boundary_flux_open_boundary.prm.bak |   88 +
 .../constant_composition_convergence.prm.bak  |   77 +
 ...nt_temperature_boundary_conditions.prm.bak |   70 +
 tests/continental_extension.prm.bak           |   51 +
 tests/convection_box_particles.prm.bak        |    4 +
 tests/convection_box_phase_function.prm.bak   |  143 +
 ...cookbook_mantle_convection_annulus.prm.bak |   36 +
 tests/cookbook_simpler_with_crust.cc.bak      |  208 +
 tests/coordinate_transformation.cc.bak        |   94 +
 tests/coordinate_transformation.prm.bak       |   80 +
 ...an_parameterization_kinematic_slab.prm.bak |   59 +
 tests/cpo_simple_shearbox.prm.bak             |  154 +
 tests/crameri_benchmark_1_gmg.cc.bak          |   21 +
 tests/crameri_benchmark_1_gmg.prm.bak         |   52 +
 tests/crustal_model_3D.prm.bak                |  124 +
 tests/custom_spherical_shell_2d_list.prm.bak  |   82 +
 .../custom_spherical_shell_2d_slices.prm.bak  |   82 +
 tests/custom_spherical_shell_3d_list.prm.bak  |   82 +
 .../custom_spherical_shell_3d_slices.prm.bak  |   82 +
 .../damped_viscoelastic_bending_beam.prm.bak  |   49 +
 tests/darcy_velocity.cc.bak                   |   21 +
 tests/darcy_velocity.prm.bak                  |  145 +
 tests/darcy_velocity_vertical.cc.bak          |   21 +
 tests/darcy_velocity_vertical.prm.bak         |   37 +
 tests/dash_dash.cc.bak                        |   50 +
 tests/dash_dash.prm.bak                       |    8 +
 tests/dc_Picard_compressible.prm              |    4 +-
 tests/dc_Picard_compressible.prm.bak          |  263 +
 tests/density_boundary.prm.bak                |   95 +
 tests/depth_average_01.prm.bak                |   90 +
 tests/depth_average_02.prm.bak                |   88 +
 tests/depth_average_03.prm.bak                |   93 +
 tests/depth_average_04.prm.bak                |   91 +
 tests/depth_average_05.prm.bak                |   91 +
 tests/depth_average_06.prm.bak                |   79 +
 tests/depth_average_rounding_bug.prm.bak      |   85 +
 tests/depth_average_txt_output.prm.bak        |   90 +
 tests/depth_average_underres.prm.bak          |   92 +
 ...pth_dependent_3d_shell_list_simple.prm.bak |   83 +
 ...depth_dependent_additional_outputs.prm.bak |   34 +
 tests/depth_dependent_box_file_simple.prm.bak |  159 +
 ...epth_dependent_box_function_simple.prm.bak |  161 +
 ...endent_box_function_time_dependent.prm.bak |  164 +
 tests/depth_dependent_box_none_simple.prm.bak |  157 +
 ...th_dependent_initialize_base_model.prm.bak |  133 +
 tests/depth_postprocessor_box.prm.bak         |   64 +
 tests/depth_postprocessor_chunk.prm.bak       |   70 +
 ...th_postprocessor_ellipsoidal_chunk.prm.bak |   78 +
 tests/depth_postprocessor_sphere.prm.bak      |   68 +
 ...epth_postprocessor_spherical_shell.prm.bak |   67 +
 ...pth_postprocessor_two_merged_boxes.prm.bak |   68 +
 ...rivative_of_weighted_p_norm_average.cc.bak |   41 +
 ...ivative_of_weighted_p_norm_average.prm.bak |    1 +
 tests/diffusion.prm.bak                       |  304 +
 tests/diffusion_dislocation.prm.bak           |  122 +
 ...sion_dislocation_fixed_strain_rate.prm.bak |   92 +
 ...ion_dislocation_fixed_strain_rate2.prm.bak |   88 +
 ...location_reference_density_profile.prm.bak |  124 +
 tests/diffusion_velocity.prm.bak              |  303 +
 tests/direct_solver_1.prm.bak                 |  152 +
 tests/direct_solver_2.prm.bak                 |  150 +
 tests/discontinuous_composition_1.prm.bak     |   95 +
 ...s_composition_bound_preserving_limiter.prm |    1 -
 ...mposition_bound_preserving_limiter.prm.bak |  100 +
 ...omposition_bound_preserving_limiter_3d.prm |    1 -
 ...sition_bound_preserving_limiter_3d.prm.bak |  101 +
 ...und_preserving_limiter_selected_fields.prm |    2 -
 ...preserving_limiter_selected_fields.prm.bak |   88 +
 ...us_composition_serial_periodic_amr.prm.bak |   80 +
 tests/discontinuous_temperature.prm.bak       |   95 +
 ...scontinuous_temperature_blankenbach.cc.bak |   21 +
 ...continuous_temperature_blankenbach.prm.bak |  119 +
 ...ous_temperature_spherical_shell_3d.prm.bak |   94 +
 tests/doneahuerta_3.cc.bak                    |   21 +
 tests/doneahuerta_3.prm.bak                   |   88 +
 tests/drucker_prager_compression.prm.bak      |  124 +
 tests/drucker_prager_derivatives_2d.cc.bak    |  247 +
 tests/drucker_prager_derivatives_2d.prm.bak   |  108 +
 tests/drucker_prager_derivatives_3d.cc.bak    |  262 +
 tests/drucker_prager_derivatives_3d.prm.bak   |  108 +
 tests/drucker_prager_extension.prm.bak        |  124 +
 tests/dynamic_core.prm.bak                    |  101 +
 tests/dynamic_friction.prm.bak                |  141 +
 tests/dynamic_topography.prm.bak              |  101 +
 tests/dynamic_topography2.prm.bak             |  102 +
 tests/dynamic_topography3.prm.bak             |   79 +
 tests/dynamic_topography_back.prm.bak         |  101 +
 ...aphy_vs_surface_dynamic_topography.prm.bak |  103 +
 tests/edit_parameters.cc.bak                  |   98 +
 tests/edit_parameters.prm.bak                 |   72 +
 ...ic_stabilization_time_scale_factor.prm.bak |   38 +
 ...ipsoidal_chunk_coordinate_parallel.prm.bak |   86 +
 tests/ellipsoidal_chunk_geometry.cc.bak       |  121 +
 tests/ellipsoidal_chunk_geometry.prm.bak      |   78 +
 ...oidal_chunk_noncoordinate_parallel.prm.bak |   87 +
 tests/ellipsoidal_chunk_topography.prm.bak    |   93 +
 tests/entropy_adiabat.cc.bak                  |   21 +
 tests/entropy_adiabat.prm.bak                 |   13 +
 tests/entropy_conduction.cc.bak               |   21 +
 tests/entropy_conduction.prm.bak              |    7 +
 tests/entropy_half_space.cc.bak               |   21 +
 tests/entropy_half_space.prm.bak              |   13 +
 tests/entropy_initial_lookup.cc.bak           |   21 +
 tests/entropy_initial_lookup.prm.bak          |  136 +
 tests/entropy_initial_lookup_wb.cc.bak        |   21 +
 tests/entropy_initial_lookup_wb.prm.bak       |  141 +
 tests/entropy_plasticity.cc.bak               |   21 +
 tests/entropy_plasticity.prm.bak              |  152 +
 tests/entropy_read_multi_table.cc.bak         |   21 +
 tests/entropy_read_multi_table.prm.bak        |  116 +
 tests/entropy_viscosity_statistics.prm.bak    |   11 +
 tests/exponential_decay.cc.bak                |   21 +
 tests/exponential_decay.prm.bak               |  124 +
 tests/fail.prm.bak                            |    5 +
 tests/find_boundary_composition_model.cc.bak  |   88 +
 tests/find_boundary_composition_model.prm.bak |   75 +
 ...d_boundary_composition_model_fail_1.cc.bak |   61 +
 ..._boundary_composition_model_fail_1.prm.bak |   81 +
 tests/find_mesh_refinement.cc.bak             |   88 +
 tests/find_mesh_refinement.prm.bak            |   61 +
 tests/find_mesh_refinement_fail_1.cc.bak      |   60 +
 tests/find_mesh_refinement_fail_1.prm.bak     |   65 +
 tests/find_postprocess.cc.bak                 |   88 +
 tests/find_postprocess.prm.bak                |   58 +
 tests/find_postprocess_fail_1.cc.bak          |   61 +
 tests/find_postprocess_fail_1.prm.bak         |   64 +
 ...er_2D_loading_fixed_elastic_dt_gmg.prm.bak |   33 +
 tests/free_surface_adaptive_blob.prm.bak      |  115 +
 tests/free_surface_blob.prm.bak               |  114 +
 tests/free_surface_blob_gmg.prm.bak           |   17 +
 tests/free_surface_blob_melt.cc.bak           |  326 +
 tests/free_surface_blob_melt.prm.bak          |  135 +
 tests/free_surface_blob_nonzero_melt.cc.bak   |   21 +
 tests/free_surface_blob_nonzero_melt.prm.bak  |  153 +
 tests/free_surface_iterated_IMPES.prm.bak     |  121 +
 tests/free_surface_iterated_stokes.prm.bak    |  120 +
 tests/free_surface_iterated_stokes_gmg.prm    |    2 +-
 .../free_surface_iterated_stokes_gmg.prm.bak  |   21 +
 tests/free_surface_relaxation.cc.bak          |  178 +
 tests/free_surface_relaxation.prm.bak         |  121 +
 ...e_surface_tangential_mesh_velocity.prm.bak |   86 +
 ...surface_tangential_mesh_velocity_2.prm.bak |   83 +
 tests/free_surface_timestep_repeat.prm.bak    |  176 +
 ...formation_tangential_mesh_velocity.prm.bak |   86 +
 tests/gaussian_initial_temperature.prm.bak    |   81 +
 tests/geoid.prm.bak                           |  101 +
 tests/geoid_freesurface.prm.bak               |  116 +
 tests/geoid_no_topo.prm.bak                   |   89 +
 tests/geoid_visualization.prm.bak             |  104 +
 tests/geometric_average_crash.prm.bak         |   59 +
 .../geometric_average_only_viscosity.prm.bak  |   80 +
 tests/global_latent_heat.prm.bak              |  159 +
 tests/global_melt.prm.bak                     |  216 +
 tests/global_melt_parallel.prm.bak            |  214 +
 tests/global_refine_amr.cc.bak                |  105 +
 tests/global_refine_amr.prm.bak               |   59 +
 tests/global_refine_bug.prm.bak               |   74 +
 tests/gmg_mesh_deform.prm.bak                 |   18 +
 tests/gmg_mesh_deform_adaptive.prm.bak        |   21 +
 tests/gmg_mesh_deform_adaptive_bug.prm.bak    |   25 +
 tests/gmg_mesh_deform_adaptive_bug2.prm.bak   |  139 +
 tests/gmg_mesh_deform_function.prm.bak        |   17 +
 tests/gmg_mesh_deform_ghost_entries.prm.bak   |   38 +
 tests/gmg_mesh_deform_prescribed.cc.bak       |   21 +
 tests/gmg_mesh_deform_prescribed.prm.bak      |   17 +
 tests/gmg_mesh_deform_topo.prm.bak            |  109 +
 tests/gmg_no_normal_flux_only.prm.bak         |   87 +
 tests/gmg_test_project_q1.prm.bak             |  102 +
 ...g_velocity_boundary_2d_box_no_flux.prm.bak |  100 +
 ...ity_boundary_2d_box_no_normal_flux.prm.bak |   99 +
 ...velocity_boundary_2d_chunk_no_flux.prm.bak |  103 +
 ...y_boundary_2d_chunk_no_normal_flux.prm.bak |  102 +
 ...g_velocity_boundary_3d_box_no_flux.prm.bak |  103 +
 ...ity_boundary_3d_box_no_normal_flux.prm.bak |  102 +
 ...velocity_boundary_3d_chunk_no_flux.prm.bak |  106 +
 ...y_boundary_3d_chunk_no_normal_flux.prm.bak |  105 +
 tests/gmg_velocity_boundary_component.prm.bak |   20 +
 tests/gplates_1_3.prm.bak                     |   78 +
 tests/gplates_1_4.prm.bak                     |   81 +
 tests/gplates_3d.prm.bak                      |   77 +
 tests/gplates_rotation.prm.bak                |   77 +
 tests/gplates_scale_factor.prm.bak            |   84 +
 tests/grain_lag_angle.prm.bak                 |  102 +
 tests/grain_size_additional_outputs.prm.bak   |   24 +
 tests/grain_size_averaging.prm.bak            |   16 +
 tests/grain_size_crossed_transition.prm.bak   |  172 +
 tests/grain_size_friction_heating.prm.bak     |  131 +
 tests/grain_size_growth.prm.bak               |  159 +
 tests/grain_size_growth_one_cell.prm.bak      |  144 +
 ...ain_size_growth_one_cell_particles.prm.bak |   43 +
 tests/grain_size_growth_particles.prm.bak     |   49 +
 tests/grain_size_growth_pinned.prm.bak        |   34 +
 tests/grain_size_latent_heat.cc.bak           |  237 +
 tests/grain_size_latent_heat.prm.bak          |  131 +
 tests/grain_size_phase_function.prm.bak       |  149 +
 tests/grain_size_plunge.prm.bak               |   10 +
 tests/grain_size_ridge.prm.bak                |   23 +
 tests/grain_size_ridge_traction.prm.bak       |  112 +
 tests/grain_size_strain.prm.bak               |  130 +
 tests/grain_size_strain_pinned.prm.bak        |   77 +
 tests/grain_size_strain_pinned_state.prm.bak  |   58 +
 tests/grain_size_yield.prm.bak                |   55 +
 tests/graphical_output.cc.bak                 |   21 +
 tests/graphical_output.prm.bak                |   74 +
 tests/graphical_output_02.prm.bak             |   76 +
 tests/graphical_output_hdf5.cc.bak            |   21 +
 tests/graphical_output_hdf5.prm.bak           |   78 +
 tests/gravity_function.prm.bak                |   71 +
 tests/gravity_function_time.prm.bak           |   72 +
 tests/gravity_model_cartesian.prm.bak         |   99 +
 tests/gravity_model_depth.prm.bak             |   89 +
 tests/gravity_model_spherical.prm.bak         |   99 +
 tests/gravity_point_values_list.prm.bak       |   69 +
 tests/gravity_point_values_map.prm.bak        |   69 +
 tests/gravity_point_values_spiral.prm.bak     |   68 +
 ...avity_point_values_spiral_parallel.prm.bak |    9 +
 tests/gravity_prem.prm.bak                    |   72 +
 ...gravity_quadrature_degree_increase.prm.bak |   70 +
 tests/gs_drucker_prager.prm.bak               |  131 +
 tests/gs_drucker_prager_extension.prm.bak     |   93 +
 ...drucker_prager_extension_adiabatic.prm.bak |   92 +
 tests/heat_advection_by_melt.cc.bak           |  127 +
 tests/heat_advection_by_melt.prm.bak          |  143 +
 ...dvection_by_melt_operator_splitting.cc.bak |   21 +
 ...vection_by_melt_operator_splitting.prm.bak |  134 +
 tests/heat_flow.prm.bak                       |    4 +
 tests/heat_flow_plume.prm.bak                 |    4 +
 tests/heat_flux_densities.prm.bak             |  110 +
 tests/heat_flux_map.prm.bak                   |   72 +
 tests/heat_flux_map_vis.prm.bak               |   79 +
 tests/heat_flux_map_vis_point_wise.prm.bak    |   20 +
 tests/heating_function.prm.bak                |   67 +
 tests/heating_function_depth.prm.bak          |   16 +
 tests/heating_function_spherical.prm.bak      |   17 +
 tests/hexagonal_initial_temperature.prm.bak   |   84 +
 tests/hill_diffusion.prm.bak                  |  115 +
 tests/hill_diffusion_3D.prm.bak               |  116 +
 ...vine_composite_hydration_prefactor.prm.bak |  144 +
 ...mposite_hydration_prefactor_cutoff.prm.bak |   23 +
 ...vine_diffusion_hydration_prefactor.prm.bak |  131 +
 ...ne_dislocation_hydration_prefactor.prm.bak |  128 +
 tests/hollow_sphere.cc.bak                    |   21 +
 tests/hollow_sphere.prm.bak                   |   99 +
 tests/hollow_sphere_gmg.cc.bak                |   21 +
 tests/hollow_sphere_gmg.prm.bak               |  101 +
 tests/hollow_sphere_gmg_project_q1.cc.bak     |   21 +
 tests/hollow_sphere_gmg_project_q1.prm.bak    |   29 +
 tests/hollow_sphere_gmg_q3.cc.bak             |   21 +
 tests/hollow_sphere_gmg_q3.prm.bak            |  105 +
 tests/hydrostatic_compression.cc.bak          |  313 +
 tests/hydrostatic_compression.prm.bak         |  113 +
 tests/inclusion_2.cc.bak                      |   21 +
 tests/inclusion_2.prm.bak                     |   86 +
 tests/inclusion_4.cc.bak                      |   21 +
 tests/inclusion_4.prm.bak                     |   86 +
 tests/inclusion_adaptive.cc.bak               |   21 +
 tests/inclusion_adaptive.prm.bak              |   89 +
 tests/infill_density_flexure.cc.bak           |   21 +
 tests/infill_density_flexure.prm.bak          |   10 +
 tests/initial_composition_list.prm.bak        |   81 +
 ...ial_composition_list_using_maximum.prm.bak |   82 +
 ...ial_composition_list_using_minimum.prm.bak |   82 +
 ...al_composition_list_using_subtract.prm.bak |   82 +
 tests/initial_condition_S20RTS.prm.bak        |   70 +
 tests/initial_condition_S20RTS_2D.prm.bak     |   10 +
 tests/initial_condition_S20RTS_dgp.prm.bak    |   75 +
 tests/initial_condition_S40RTS.prm.bak        |   71 +
 tests/initial_condition_SAVANI.prm.bak        |   74 +
 ...initial_condition_lithosphere_mask.prm.bak |   62 +
 .../initial_condition_patch_on_S40RTS.prm.bak |   62 +
 tests/initial_condition_vs_to_density.prm.bak |   77 +
 ...ial_condition_vs_to_density_SAVANI.prm.bak |   77 +
 tests/initial_global_refinement.prm.bak       |   88 +
 tests/initial_porosity.prm.bak                |  216 +
 tests/initial_temperature_list.prm.bak        |   63 +
 ...ial_temperature_list_using_maximum.prm.bak |   64 +
 ...ial_temperature_list_using_minimum.prm.bak |   64 +
 ...al_temperature_list_using_subtract.prm.bak |   64 +
 tests/initial_temperature_profile.prm.bak     |   69 +
 tests/inner_core.cc.bak                       |   21 +
 tests/inner_core.prm.bak                      |  142 +
 tests/internal_heating_statistics.prm.bak     |  100 +
 .../interpolor_particles_harmonic_average.prm |    1 -
 ...erpolor_particles_harmonic_average.prm.bak |   21 +
 ...erpolor_particles_nearest_neighbor.prm.bak |    8 +
 ..._particles_quadratic_least_squares.prm.bak |    8 +
 tests/isosurfaces_simple_box_2D.prm.bak       |   96 +
 ...es_simple_box_2D_custom_fieldnames.prm.bak |   21 +
 ...mple_box_2D_custom_fieldnames_fail.prm.bak |   21 +
 ...sosurfaces_simple_box_2D_min_max_1.prm.bak |   14 +
 ...sosurfaces_simple_box_2D_min_max_2.prm.bak |   14 +
 tests/isosurfaces_simple_box_3D.prm.bak       |   56 +
 tests/isosurfaces_slab_2D.prm.bak             |  102 +
 tests/isosurfaces_slab_3D.prm.bak             |   67 +
 ...ction_and_defect_correction_Stokes.prm.bak |  127 +
 tests/iterated_advection_and_stokes.prm.bak   |  127 +
 tests/iterated_advection_and_stokes_DG.prm    |    1 -
 .../iterated_advection_and_stokes_DG.prm.bak  |  128 +
 ...erated_advection_and_stokes_DG_limiter.prm |    3 +-
 ...ed_advection_and_stokes_DG_limiter.prm.bak |  135 +
 ...advection_and_stokes_direct_solver.prm.bak |  130 +
 ...ated_advection_and_stokes_residual.prm.bak |  127 +
 .../kaus_rayleigh_taylor_instability.prm.bak  |   41 +
 ...nematically_driven_subduction_2d_case1.prm |    2 +-
 ...tically_driven_subduction_2d_case1.prm.bak |  177 +
 ...tically_driven_subduction_2d_case2a.cc.bak |    4 +
 ...ematically_driven_subduction_2d_case2a.prm |    2 +-
 ...ically_driven_subduction_2d_case2a.prm.bak |  176 +
 ...tically_driven_subduction_2d_case2b.cc.bak |    4 +
 ...ematically_driven_subduction_2d_case2b.prm |    2 +-
 ...ically_driven_subduction_2d_case2b.prm.bak |  195 +
 tests/king_ala.cc.bak                         |   22 +
 tests/king_ala.prm.bak                        |   11 +
 tests/king_ala_nondim.prm.bak                 |  163 +
 tests/latent_heat.prm.bak                     |  132 +
 tests/latent_heat_composition.prm.bak         |  164 +
 tests/latent_heat_enthalpy.cc.bak             |  188 +
 tests/latent_heat_enthalpy.prm.bak            |  115 +
 tests/latent_heat_melt.prm.bak                |  145 +
 tests/latent_heat_melt_operator_split.prm.bak |  172 +
 tests/latent_heat_melt_statistics.prm.bak     |  127 +
 tests/latent_heat_melt_transport.prm.bak      |  162 +
 tests/latent_heat_pressure.prm.bak            |  126 +
 tests/latent_heat_viscosity.prm.bak           |  113 +
 tests/latent_heat_viscosity_adiabatic.prm.bak |  102 +
 tests/lithosphere_boundary_indicator.prm.bak  |  130 +
 .../lithosphere_boundary_indicator_3d.prm.bak |  133 +
 ...ere_boundary_indicator_3d_one_grid.prm.bak |   13 +
 ...ere_boundary_indicator_3d_periodic.prm.bak |  152 +
 ...sphere_boundary_indicator_one_grid.prm.bak |   13 +
 ...hosphere_boundary_indicator_origin.prm.bak |   15 +
 tests/logo.prm.bak                            |   14 +
 tests/magnetic_stripes.cc.bak                 |   21 +
 tests/magnetic_stripes.prm.bak                |    8 +
 tests/mass_flux_statistics.prm.bak            |   44 +
 tests/mass_reaction_term.prm.bak              |  173 +
 tests/material_model_dependencies.cc.bak      |  132 +
 ...terial_model_dependencies_burstedde.cc.bak |   22 +
 ...erial_model_dependencies_burstedde.prm.bak |   86 +
 ...l_dependencies_composition_reaction.cc.bak |   21 +
 ..._dependencies_composition_reaction.prm.bak |   67 +
 ...es_cookbooks_freesurface_with_crust.cc.bak |   22 +
 ...s_cookbooks_freesurface_with_crust.prm.bak |   67 +
 ..._dependencies_diffusion_dislocation.cc.bak |   21 +
 ...dependencies_diffusion_dislocation.prm.bak |   73 +
 ...rial_model_dependencies_inclusion_2.cc.bak |   22 +
 ...ial_model_dependencies_inclusion_2.prm.bak |   67 +
 ...rial_model_dependencies_latent_heat.cc.bak |   21 +
 ...ial_model_dependencies_latent_heat.prm.bak |  104 +
 ...model_dependencies_latent_heat_melt.cc.bak |   21 +
 ...odel_dependencies_latent_heat_melt.prm.bak |   67 +
 ...ial_model_dependencies_morency_doin.cc.bak |   23 +
 ...al_model_dependencies_morency_doin.prm.bak |   67 +
 ...l_model_dependencies_multicomponent.cc.bak |   21 +
 ..._model_dependencies_multicomponent.prm.bak |   67 +
 ...l_model_dependencies_shear_thinning.cc.bak |   22 +
 ..._model_dependencies_shear_thinning.prm.bak |   76 +
 .../material_model_dependencies_simple.cc.bak |   21 +
 ...material_model_dependencies_simple.prm.bak |   67 +
 ...el_dependencies_simple_compressible.cc.bak |   21 +
 ...l_dependencies_simple_compressible.prm.bak |   67 +
 ...material_model_dependencies_simpler.cc.bak |   21 +
 ...aterial_model_dependencies_simpler.prm.bak |   67 +
 .../material_model_dependencies_solcx.cc.bak  |   22 +
 .../material_model_dependencies_solcx.prm.bak |   67 +
 .../material_model_dependencies_solkz.cc.bak  |   22 +
 .../material_model_dependencies_solkz.prm.bak |   67 +
 ...rial_model_dependencies_steinberger.cc.bak |   21 +
 ...ial_model_dependencies_steinberger.prm.bak |   85 +
 ...terial_model_dependencies_tangurnis.cc.bak |   22 +
 ...erial_model_dependencies_tangurnis.prm.bak |   86 +
 tests/material_statistics.prm.bak             |   80 +
 tests/matrix_nonzeros_1.prm.bak               |   85 +
 tests/matrix_nonzeros_2.prm.bak               |  100 +
 tests/matrix_nonzeros_3.prm.bak               |  106 +
 tests/matrix_nonzeros_4.prm.bak               |  114 +
 tests/matrix_nonzeros_5.prm.bak               |  110 +
 tests/matrix_nonzeros_6.prm.bak               |  111 +
 tests/matrix_nonzeros_7.prm.bak               |  117 +
 tests/max_timesteps_btwn_output.prm.bak       |  168 +
 ...zontal_compressive_stress_case_one.prm.bak |  108 +
 ...zontal_compressive_stress_case_two.prm.bak |  110 +
 tests/maximum_refinement_function.prm.bak     |  154 +
 ...imum_refinement_function_cartesian.prm.bak |  144 +
 ...imum_refinement_function_spherical.prm.bak |  136 +
 tests/maxtimestep.prm.bak                     |   64 +
 tests/melt_and_traction.prm.bak               |  276 +
 tests/melt_boukare_EOS.prm                    |    2 +-
 tests/melt_boukare_EOS.prm.bak                |  157 +
 tests/melt_boukare_averaging.prm              |    2 +-
 tests/melt_boukare_averaging.prm.bak          |  157 +
 tests/melt_boundary_heat_flux.cc.bak          |   21 +
 tests/melt_boundary_heat_flux.prm.bak         |  127 +
 tests/melt_compressible_advection.cc.bak      |  213 +
 tests/melt_compressible_advection.prm.bak     |  132 +
 tests/melt_force_vector.cc.bak                |  338 +
 tests/melt_force_vector.prm.bak               |  160 +
 tests/melt_fraction_postprocessor.prm.bak     |  126 +
 tests/melt_introspection.cc.bak               |  138 +
 tests/melt_introspection.prm.bak              |   95 +
 tests/melt_material_1.cc.bak                  |  102 +
 tests/melt_material_1.prm.bak                 |  109 +
 tests/melt_material_2.cc.bak                  |  129 +
 tests/melt_material_2.prm.bak                 |  132 +
 tests/melt_material_3.cc.bak                  |  129 +
 tests/melt_material_3.prm.bak                 |  132 +
 tests/melt_material_4.cc.bak                  |  240 +
 tests/melt_material_4.prm.bak                 |  143 +
 tests/melt_postprocessor_peridotite.prm.bak   |  121 +
 tests/melt_postprocessor_pyroxenite.prm.bak   |  140 +
 tests/melt_property_visualization.cc.bak      |   21 +
 tests/melt_property_visualization.prm.bak     |  139 +
 tests/melt_restart.cc.bak                     |   96 +
 tests/melt_restart.prm.bak                    |  223 +
 tests/melt_statistics.prm.bak                 |  141 +
 tests/melt_track.cc.bak                       |   21 +
 tests/melt_track.prm.bak                      |  189 +
 tests/melt_transport.prm.bak                  |  151 +
 tests/melt_transport_adaptive.cc.bak          |  518 ++
 tests/melt_transport_adaptive.prm.bak         |  135 +
 tests/melt_transport_compressible.cc.bak      |  370 +
 tests/melt_transport_compressible.prm.bak     |  142 +
 ...lt_transport_compressible_iterative.cc.bak |   21 +
 ...t_transport_compressible_iterative.prm.bak |  135 +
 .../melt_transport_convergence_simple.cc.bak  |  326 +
 .../melt_transport_convergence_simple.prm.bak |  135 +
 tests/melt_transport_convergence_test.cc.bak  |  330 +
 tests/melt_transport_convergence_test.prm.bak |  136 +
 .../melt_velocity_boundary_conditions.cc.bak  |   21 +
 .../melt_velocity_boundary_conditions.prm.bak |  154 +
 tests/melt_visco_plastic.cc.bak               | 1038 +++
 ...isco_plastic_mohr_circle_compaction.cc.bak |   21 +
 ...t_visco_plastic_mohr_circle_compaction.prm |    1 -
 ...sco_plastic_mohr_circle_compaction.prm.bak |  163 +
 ...elt_visco_plastic_mohr_circle_shear.cc.bak |   21 +
 .../melt_visco_plastic_mohr_circle_shear.prm  |    1 -
 ...lt_visco_plastic_mohr_circle_shear.prm.bak |  162 +
 tests/melting_rate.cc.bak                     |  126 +
 tests/melting_rate.prm.bak                    |  138 +
 tests/melting_rate_operator_splitting.prm.bak |  154 +
 .../melting_rate_operator_splitting2.prm.bak  |  144 +
 tests/melting_rate_test.prm.bak               |  156 +
 tests/memory_statistics_1.prm.bak             |   69 +
 tests/merged_chunks_2D.prm.bak                |  132 +
 tests/merged_chunks_2D_one_grid.prm.bak       |   13 +
 tests/merged_chunks_3D.prm.bak                |  140 +
 tests/merged_chunks_3D_one_grid.prm.bak       |   13 +
 ...deformation_gmg_2d_spherical_shell.prm.bak |   96 +
 tests/mesh_deformation_particles.cc.bak       |   71 +
 tests/mesh_deformation_particles.prm.bak      |   85 +
 tests/mesh_velocity_output.prm.bak            |  121 +
 tests/mid_ocean_ridge.prm.bak                 |   26 +
 tests/minimum_refinement_function.prm.bak     |  154 +
 ...imum_refinement_function_cartesian.prm.bak |  144 +
 ...imum_refinement_function_spherical.prm.bak |  136 +
 ...refinement_function_time_dependent.prm.bak |  154 +
 tests/modified_tait_forsterite_box.prm.bak    |  101 +
 tests/morency_doin.cc.bak                     |   22 +
 tests/morency_doin.prm.bak                    |  100 +
 tests/multicomponent_arithmetic.prm.bak       |  128 +
 ...ticomponent_compressible_averaging.prm.bak |  129 +
 tests/multicomponent_geometric.prm.bak        |  128 +
 tests/multicomponent_harmonic.prm.bak         |  128 +
 tests/multicomponent_max_composition.prm.bak  |  128 +
 tests/multicomponent_steinberger.prm.bak      |  121 +
 .../multiple_named_additional_outputs.cc.bak  |  112 +
 .../multiple_named_additional_outputs.prm.bak |   99 +
 tests/muparser-temperature-example.prm.bak    |  149 +
 tests/n_expensive_stokes_solver_steps.prm.bak |  160 +
 tests/natural_coordinates_conversion.cc.bak   |  217 +
 tests/natural_coordinates_conversion.prm.bak  |    1 +
 tests/netcdf_boundary_velocity_2d_box.prm.bak |   71 +
 tests/newton_postprocess_nonlinear.prm.bak    |  175 +
 ..._iterated_defect_correction_Stokes.prm.bak |  127 +
 tests/no_adiabatic_heating.cc.bak             |   57 +
 tests/no_adiabatic_heating.prm.bak            |   82 +
 tests/no_adiabatic_heating_02.cc.bak          |   65 +
 tests/no_adiabatic_heating_02.prm.bak         |   82 +
 tests/no_adiabatic_heating_03.cc.bak          |   57 +
 tests/no_adiabatic_heating_03.prm.bak         |  115 +
 tests/no_cheap_gmg.cc.bak                     |   21 +
 tests/no_cheap_gmg.prm.bak                    |   83 +
 tests/no_conduction_timestep.prm.bak          |   80 +
 tests/no_dirichlet_on_outflow.prm.bak         |  168 +
 tests/no_dirichlet_on_outflow_C.prm.bak       |  172 +
 .../no_dirichlet_on_outflow_adaptive.prm.bak  |  172 +
 tests/no_dirichlet_on_outflow_melt.cc.bak     |   21 +
 tests/no_dirichlet_on_outflow_melt.prm.bak    |  144 +
 ...et_on_outflow_only_new_constraints.prm.bak |  168 +
 tests/no_dirichlet_on_outflow_refine.prm      |    2 +-
 tests/no_dirichlet_on_outflow_refine.prm.bak  |  123 +
 tests/no_flow.prm.bak                         |   85 +
 tests/non_conservative_with_mpi.cc.bak        |   21 +
 tests/non_conservative_with_mpi.prm.bak       |   79 +
 ...hannel_flow_tractions_Newton_Stokes.cc.bak |   21 +
 ...annel_flow_tractions_Newton_Stokes.prm.bak |  131 +
 ...el_flow_tractions_Newton_Stokes_GMG.cc.bak |   21 +
 ...l_flow_tractions_Newton_Stokes_GMG.prm.bak |   17 +
 ...tractions_Newton_Stokes_no_deviator.cc.bak |   21 +
 ...ractions_Newton_Stokes_no_deviator.prm.bak |  132 +
 ...ctions_Newton_Stokes_no_line_search.cc.bak |   21 +
 ...tions_Newton_Stokes_no_line_search.prm.bak |    8 +
 ...w_tractions_Newton_Stokes_particles.cc.bak |   21 +
 ..._tractions_Newton_Stokes_particles.prm.bak |   38 +
 ...flow_tractions_dc_picard_Stokes_GMG.cc.bak |    1 +
 ...low_tractions_dc_picard_Stokes_GMG.prm.bak |   17 +
 ...annel_flow_tractions_iterated_IMPES.cc.bak |   21 +
 ...nnel_flow_tractions_iterated_IMPES.prm.bak |  129 +
 ...annel_flow_velocities_Newton_Stokes.cc.bak |   21 +
 ...nnel_flow_velocities_Newton_Stokes.prm.bak |  134 +
 ...l_flow_velocities_Newton_Stokes_GMG.cc.bak |   21 +
 ..._flow_velocities_Newton_Stokes_GMG.prm.bak |   23 +
 ...ocities_Newton_Stokes_no_derivative.cc.bak |   21 +
 ...cities_Newton_Stokes_no_derivative.prm.bak |   21 +
 ...ties_Newton_Stokes_no_derivative_EW.cc.bak |   21 +
 ...ies_Newton_Stokes_no_derivative_EW.prm.bak |   21 +
 ...elocities_Newton_Stokes_no_deviator.cc.bak |   21 +
 ...locities_Newton_Stokes_no_deviator.prm.bak |   17 +
 ...cities_Newton_Stokes_no_line_search.cc.bak |   21 +
 ...ities_Newton_Stokes_no_line_search.prm.bak |    8 +
 ...nnel_flow_velocities_iterated_IMPES.cc.bak |   21 +
 ...nel_flow_velocities_iterated_IMPES.prm.bak |  128 +
 ...ties_single_advection_Newton_Stokes.cc.bak |   21 +
 ...ies_single_advection_Newton_Stokes.prm.bak |    9 +
 ...r_convergence_for_small_composition.cc.bak |   71 +
 ..._convergence_for_small_composition.prm.bak |  162 +
 tests/nonlinear_solver_history.cc.bak         |   46 +
 tests/nonlinear_solver_history.prm.bak        |   69 +
 tests/normalize_initial_composition.prm.bak   |   62 +
 tests/normalize_pressure_volume.prm.bak       |   70 +
 tests/nsinker.cc.bak                          |   21 +
 tests/nsinker.prm.bak                         |    9 +
 tests/nsinker_2d.cc.bak                       |   21 +
 tests/nsinker_2d.prm.bak                      |    8 +
 tests/nsinker_bfbt.cc.bak                     |   21 +
 tests/nsinker_bfbt.prm.bak                    |    9 +
 tests/nsinker_gmg_idr.cc.bak                  |   21 +
 tests/nsinker_gmg_idr.prm.bak                 |   24 +
 tests/octagonal_initial_temperature.prm.bak   |   90 +
 ...tial_temperature_ellipsoidal_chunk.prm.bak |   94 +
 ...agonal_initial_temperature_rotated.prm.bak |   91 +
 tests/onset_of_convection.prm.bak             |    4 +
 tests/original_prm.prm.bak                    |   10 +
 tests/original_prm/original.prm               |    1 -
 tests/original_prm/original.prm.bak           |   13 +
 tests/output_averaging_arithmetic.cc.bak      |   21 +
 tests/output_averaging_arithmetic.prm.bak     |   82 +
 tests/output_averaging_harmonic.cc.bak        |   21 +
 tests/output_averaging_harmonic.prm.bak       |   82 +
 tests/own_gravity.cc.bak                      |   44 +
 tests/own_gravity.prm.bak                     |   77 +
 tests/parallel_output_group_0.prm.bak         |   76 +
 tests/parallel_output_group_1.prm.bak         |   76 +
 tests/parallel_output_group_2.prm.bak         |   76 +
 tests/parallel_refine_crash.prm.bak           |  112 +
 tests/particle_count_statistics.cc.bak        |   21 +
 tests/particle_count_statistics.prm.bak       |   91 +
 tests/particle_exclude_all_properties.prm.bak |  117 +
 tests/particle_exclude_one_property.prm.bak   |  117 +
 .../particle_exclude_one_property_vtu.prm.bak |  117 +
 ...ticle_exclude_three_properties_vtu.prm.bak |  117 +
 ...article_exclude_two_properties_vtu.prm.bak |  117 +
 ...le_fast_evaluate_many_compositions.prm.bak |  116 +
 ...ast_evaluate_multiple_compositions.prm.bak |  116 +
 tests/particle_free_surface.prm.bak           |  114 +
 tests/particle_generator_ascii.prm.bak        |  108 +
 tests/particle_generator_box.prm.bak          |  113 +
 tests/particle_generator_box_3d.prm.bak       |  118 +
 ...rticle_generator_quadrature_points.prm.bak |  108 +
 tests/particle_generator_radial.prm.bak       |  116 +
 .../particle_generator_random_uniform.prm.bak |  109 +
 ...ator_random_uniform_3mpi_1particle.prm.bak |  109 +
 ...ator_random_uniform_3mpi_2particle.prm.bak |  109 +
 ...ator_random_uniform_3mpi_3particle.prm.bak |  109 +
 ...ator_random_uniform_3mpi_4particle.prm.bak |  109 +
 ..._random_uniform_deterministic_cell.prm.bak |  110 +
 ...enerator_random_uniform_empty_rank.prm.bak |  109 +
 .../particle_generator_reference_cell.prm.bak |  111 +
 tests/particle_handler_copy.cc.bak            |   83 +
 tests/particle_handler_copy.prm.bak           |   96 +
 .../particle_initial_adaptive_output.prm.bak  |  107 +
 ...rticle_initial_adaptive_refinement.prm.bak |  107 +
 tests/particle_integrator_euler.prm.bak       |  109 +
 ...le_integrator_rk2_first_order_time.prm.bak |   26 +
 tests/particle_integrator_rk4.prm.bak         |  109 +
 .../particle_interpolator_bilinear_3d.prm.bak |  118 +
 ...rpolator_bilinear_3d_add_particles.prm.bak |  113 +
 ...interpolator_bilinear_add_particles.cc.bak |   21 +
 ...nterpolator_bilinear_add_particles.prm.bak |  118 +
 ...olator_bilinear_least_squares_solkz.cc.bak |   21 +
 ...lator_bilinear_least_squares_solkz.prm.bak |  115 +
 ...icle_interpolator_bilinear_limiter.prm.bak |  120 +
 ...particle_interpolator_cell_average.prm.bak |  125 +
 ...rticle_interpolator_cell_average_2.prm.bak |  119 +
 .../particle_interpolator_empty_cells.prm.bak |  100 +
 ...icle_interpolator_from_ghost_cells.prm.bak |  102 +
 ...interpolator_harmonic_average_solkz.cc.bak |   21 +
 ...nterpolator_harmonic_average_solkz.prm.bak |  119 +
 ...icle_interpolator_nearest_neighbor.prm.bak |  127 +
 ...atic_least_squares_2d_add_particles.cc.bak |   21 +
 ...tic_least_squares_2d_add_particles.prm.bak |  120 +
 ..._quadratic_least_squares_2d_limiter.cc.bak |   21 +
 ...quadratic_least_squares_2d_limiter.prm.bak |   28 +
 ...uadratic_least_squares_2d_periodic.prm.bak |   41 +
 ...polator_quadratic_least_squares_3d.prm.bak |  119 +
 ...ticle_interpolator_time_dependence.prm.bak |  109 +
 ...rticle_linear_accelerated_flow_rk2.prm.bak |   86 +
 tests/particle_load_balancing_none.prm.bak    |  106 +
 ...particle_load_balancing_refinement.prm.bak |  105 +
 ...ticle_load_balancing_refinement_02.prm.bak |  105 +
 tests/particle_load_balancing_removal.prm.bak |  103 +
 ...le_load_balancing_removal_addition.prm.bak |  106 +
 ...ancing_removal_addition_properties.prm.bak |  107 +
 ...article_load_balancing_repartition.prm.bak |   19 +
 ...le_load_balancing_repartition_1000.prm.bak |   20 +
 tests/particle_melt_advection.cc.bak          |   21 +
 tests/particle_melt_advection.prm.bak         |  166 +
 tests/particle_output_gnuplot.prm.bak         |  107 +
 tests/particle_output_hdf5.prm.bak            |  107 +
 .../particle_output_multiple_formats.prm.bak  |  106 +
 tests/particle_output_none.prm.bak            |  109 +
 tests/particle_output_vtu.prm.bak             |  107 +
 tests/particle_output_vtu_group.prm.bak       |  110 +
 tests/particle_output_vtu_temp.prm.bak        |  109 +
 tests/particle_periodic_boundaries.prm.bak    |  114 +
 tests/particle_periodic_boundaries_dc.prm.bak |   35 +
 .../particle_periodic_boundaries_rk4.prm.bak  |  113 +
 tests/particle_periodic_quarter_shell.prm.bak |  112 +
 .../particle_periodic_quarter_shell_2.prm.bak |  122 +
 tests/particle_property_composition.cc.bak    |   21 +
 tests/particle_property_composition.prm.bak   |  188 +
 tests/particle_property_function.prm.bak      |  113 +
 ...ticle_property_initial_composition.prm.bak |  106 +
 ...perty_initial_composition_boundary.prm.bak |  103 +
 ...operty_integrated_strain_invariant.prm.bak |  112 +
 ...perty_integrated_strain_pure_shear.prm.bak |   92 +
 ...rty_integrated_strain_simple_shear.prm.bak |   91 +
 ...rticle_property_multiple_functions.prm.bak |  115 +
 ...tiple_functions_with_interpolation.prm.bak |  118 +
 ...e_property_post_initialize_function.cc.bak |   86 +
 ..._property_post_initialize_function.prm.bak |  105 +
 tests/particle_timing_information.prm.bak     |  109 +
 ...ticle_visualization_particle_count.prm.bak |  110 +
 tests/particles_with_AMR_on.prm.bak           |  124 +
 tests/passive_comp.prm.bak                    |  280 +
 tests/periodic_box.prm.bak                    |  108 +
 tests/periodic_box2.prm.bak                   |   97 +
 tests/periodic_box_freesurface.prm.bak        |  116 +
 tests/periodic_box_gmg.prm                    |    2 +-
 tests/periodic_box_gmg.prm.bak                |  124 +
 tests/periodic_box_mpi4.prm.bak               |   99 +
 tests/periodic_compressible.prm.bak           |   84 +
 tests/periodic_linear_momentum.prm.bak        |  112 +
 tests/periodic_quarter_shell.prm.bak          |   77 +
 tests/plugin.cc.bak                           |   41 +
 tests/plugin.prm.bak                          |   80 +
 tests/plugin_dependency.cc.bak                |   56 +
 tests/plugin_dependency.prm.bak               |   78 +
 tests/plugin_dependency_redundant.cc.bak      |   23 +
 tests/plugin_dependency_redundant.prm.bak     |   80 +
 tests/plugin_dependency_redundant_02.cc.bak   |   23 +
 tests/plugin_dependency_redundant_02.prm.bak  |   79 +
 tests/point_value_01.prm.bak                  |  102 +
 tests/point_value_02.prm.bak                  |  109 +
 tests/point_value_02_mpi.prm.bak              |  107 +
 tests/point_value_03.prm.bak                  |  103 +
 tests/point_value_natural_coordinates.prm.bak |   86 +
 ...nt_value_natural_coordinates_shell.prm.bak |   86 +
 .../point_value_specific_output_times.prm.bak |  104 +
 tests/poiseuille_2d.prm.bak                   |   72 +
 ...iseuille_2d_horizontal_pressure_bc.prm.bak |  102 +
 tests/poiseuille_2d_pressure_bc.prm.bak       |   94 +
 tests/poiseuille_2d_pressure_bc_gmg.prm.bak   |  105 +
 ...euille_3d_x_horizontal_pressure_bc.prm.bak |  100 +
 tests/postprocess_initial.prm.bak             |  105 +
 .../postprocess_iterations_Stokes_only.cc.bak |   21 +
 ...postprocess_iterations_Stokes_only.prm.bak |   88 +
 ...tprocess_iterations_iterated_Stokes.cc.bak |   21 +
 ...process_iterations_iterated_Stokes.prm.bak |   96 +
 ...ions_iterated_advection_and_stokes.prm.bak |  133 +
 tests/pre_data_out_build_patches.cc.bak       |   45 +
 tests/pre_data_out_build_patches.prm.bak      |   72 +
 tests/prescribed_dilation.cc.bak              |  413 +
 tests/prescribed_dilation.prm.bak             |   71 +
 tests/prescribed_dilation_gmg.cc.bak          |   21 +
 tests/prescribed_dilation_gmg.prm.bak         |   19 +
 tests/prescribed_dilation_newton.cc.bak       |   21 +
 tests/prescribed_dilation_newton.prm.bak      |   18 +
 ...bed_dilation_newton_singleadvection.cc.bak |   21 +
 ...ed_dilation_newton_singleadvection.prm.bak |   18 +
 tests/prescribed_field.cc.bak                 |   92 +
 tests/prescribed_field.prm.bak                |   90 +
 tests/prescribed_field_temperature.cc.bak     |   93 +
 tests/prescribed_field_temperature.prm.bak    |   78 +
 ...bed_field_temperature_max_isotherm.prm.bak |   21 +
 tests/prescribed_field_with_diffusion.cc.bak  |   95 +
 tests/prescribed_field_with_diffusion.prm.bak |  107 +
 tests/prescribed_stokes_solution.prm.bak      |   95 +
 ...cribed_stokes_solution_DG_periodic.prm.bak |   72 +
 tests/prescribed_stokes_solution_melt.prm.bak |  109 +
 tests/prescribed_temperature.cc.bak           |   95 +
 tests/prescribed_temperature.prm.bak          |   85 +
 tests/prescribed_temperature_in_field.cc.bak  |  182 +
 tests/prescribed_temperature_in_field.prm.bak |   67 +
 ...escribed_temperature_with_diffusion.cc.bak |   95 +
 ...scribed_temperature_with_diffusion.prm.bak |   84 +
 tests/prescribed_velocity.cc.bak              |   21 +
 tests/prescribed_velocity.prm.bak             |   58 +
 tests/prescribed_velocity_boundary.cc.bak     |  446 +
 tests/prescribed_velocity_boundary.prm.bak    |   88 +
 tests/prescribed_velocity_dgp.cc.bak          |  264 +
 tests/prescribed_velocity_dgp.prm.bak         |   62 +
 ...ribed_viscosity_additional_outputs.prm.bak |   41 +
 tests/prescribed_viscosity_happy.prm.bak      |   72 +
 tests/pressure_boundary.prm.bak               |   92 +
 tests/pressure_compatibility.prm.bak          |   77 +
 tests/pressure_compatibility_2.prm.bak        |   95 +
 tests/pressure_compatibility_3.prm.bak        |   94 +
 tests/pressure_compatibility_4.prm.bak        |  101 +
 tests/pressure_compatibility_dg.prm.bak       |    9 +
 .../pressure_compatibility_dg_direct.prm.bak  |   15 +
 tests/pressure_compatibility_direct.prm.bak   |   11 +
 tests/pressure_constraint.cc.bak              |   60 +
 tests/pressure_constraint.prm.bak             |   70 +
 tests/pressure_scaling_signal.cc.bak          |   44 +
 tests/pressure_scaling_signal.prm.bak         |   88 +
 tests/principal_deviatoric_stress.cc.bak      |   21 +
 tests/principal_deviatoric_stress.prm.bak     |  117 +
 tests/prm_distance_polygon.cc.bak             |   77 +
 tests/prm_distance_polygon.prm.bak            |    1 +
 tests/prm_polygon_in_out.cc.bak               |   82 +
 tests/prm_polygon_in_out.prm.bak              |    1 +
 tests/prmbackslash.prm                        |    5 -
 tests/prmbackslash.prm.bak                    |   72 +
 tests/prmbackslash_2.cc.bak                   |   21 +
 tests/prmbackslash_2.prm                      |  164 +-
 tests/prmbackslash_2.prm.bak                  |  156 +
 tests/projected_density_vertical_pipe.cc.bak  |   21 +
 tests/projected_density_vertical_pipe.prm     |    2 +-
 tests/projected_density_vertical_pipe.prm.bak |   31 +
 tests/pure_shear.cc.bak                       |   21 +
 tests/pure_shear.prm.bak                      |  145 +
 tests/q1_q1.cc.bak                            |  474 +
 tests/q1_q1.prm.bak                           |   98 +
 tests/q1_q1_6.cc.bak                          |   21 +
 tests/q1_q1_6.prm.bak                         |   95 +
 ...iable_coordinate_systems_cartesian.prm.bak |   86 +
 ..._variable_coordinate_systems_depth.prm.bak |   86 +
 ...iable_coordinate_systems_spherical.prm.bak |   86 +
 tests/quick_mpi.cc.bak                        |   21 +
 tests/quick_mpi.prm.bak                       |   82 +
 tests/radioactive_decay.prm.bak               |   87 +
 tests/radiogenic_heating.prm.bak              |   91 +
 tests/random_perturbation_box.prm.bak         |   70 +
 tests/random_perturbation_chunk.prm.bak       |   72 +
 .../random_perturbation_merged_boxes.prm.bak  |   73 +
 tests/random_perturbation_sphere.prm.bak      |   67 +
 ...andom_perturbation_spherical_shell.prm.bak |   66 +
 ...active_fluid_transport_no_reaction.prm.bak |   25 +
 ...ve_fluid_transport_zero_solubility.prm.bak |  138 +
 tests/refine_vel.prm.bak                      |   92 +
 .../refinement_artificial_viscosity_1.prm.bak |  101 +
 .../refinement_artificial_viscosity_2.prm.bak |   11 +
 .../refinement_artificial_viscosity_3.prm.bak |   11 +
 tests/refinement_boundary.prm.bak             |   71 +
 tests/refinement_composition_gradient.prm.bak |   95 +
 .../refinement_composition_threshold.prm.bak  |   18 +
 ...efinement_nonadiabatic_temperature.prm.bak |   27 +
 tests/refinement_strainrate.prm.bak           |  121 +
 tests/refinement_switch.prm.bak               |  111 +
 tests/refinement_topography.cc.bak            |   21 +
 tests/refinement_topography.prm.bak           |   68 +
 tests/remove_angular_momentum.prm.bak         |   63 +
 tests/remove_angular_momentum_3d.prm.bak      |   66 +
 tests/remove_net_rotation.prm.bak             |   67 +
 tests/remove_net_rotation_3d.prm.bak          |   67 +
 tests/remove_net_surface_rotation.prm.bak     |   15 +
 ...replace_lithosphere_viscosity_file.prm.bak |   65 +
 tests/resume_free_surface.cc.bak              |   95 +
 tests/resume_free_surface.prm.bak             |  130 +
 tests/rheology_scaled_profile.cc.bak          |  296 +
 tests/rheology_scaled_profile.prm.bak         |   82 +
 tests/rigid_shear_instantaneous.cc.bak        |   21 +
 tests/rigid_shear_instantaneous.prm.bak       |    5 +
 tests/rigid_shear_steady_state.cc.bak         |   21 +
 tests/rigid_shear_steady_state.prm.bak        |    5 +
 tests/rigid_shear_transient.cc.bak            |   21 +
 tests/rigid_shear_transient.prm.bak           |    7 +
 tests/rising_melt_blob.cc.bak                 |  103 +
 tests/rising_melt_blob.prm.bak                |  135 +
 tests/rising_melt_blob_freezing.prm.bak       |  123 +
 tests/rotation_statistics.prm.bak             |   76 +
 tests/rotation_statistics_3d.prm.bak          |   76 +
 .../rotation_statistics_3d_asymmetric.prm.bak |   76 +
 tests/rotation_statistics_3d_surface.prm.bak  |   20 +
 tests/sea_level_postprocessor.prm.bak         |   95 +
 tests/segregation_heating.cc.bak              |   71 +
 tests/segregation_heating.prm.bak             |  142 +
 tests/shear_bands.cc.bak                      |   21 +
 tests/shear_bands.prm.bak                     |  128 +
 tests/shear_heating.prm.bak                   |   85 +
 tests/shear_heating_compressible.prm.bak      |  114 +
 tests/shear_heating_compressible_melt.prm.bak |  147 +
 tests/shear_heating_limited.prm.bak           |   30 +
 tests/shear_heating_with_melt.prm.bak         |  210 +
 tests/shear_thinning.cc.bak                   |  194 +
 tests/shear_thinning.prm.bak                  |   88 +
 tests/shearbox_particle_strain_rate.prm       |    2 +-
 tests/shearbox_particle_strain_rate.prm.bak   |  186 +
 tests/shell_2d_gmg.prm.bak                    |   81 +
 tests/shell_3d_gmg.prm.bak                    |   87 +
 ...ary_composition_spherical_constant.prm.bak |   89 +
 tests/shell_quarter_BC.prm.bak                |   17 +
 tests/shell_quarter_gmg.prm.bak               |   81 +
 tests/shell_surface_base_variables.prm        |   12 +-
 tests/shell_surface_base_variables.prm.bak    |   96 +
 ...l_with_variable_coordinate_systems.prm.bak |   92 +
 tests/signal_fem.cc.bak                       |   71 +
 tests/signal_fem.prm.bak                      |   91 +
 tests/signals.cc.bak                          |   60 +
 tests/signals.prm.bak                         |   80 +
 tests/signals_connect.cc.bak                  |   49 +
 tests/signals_connect.prm.bak                 |   78 +
 tests/signals_post_constraints.cc.bak         |   47 +
 tests/signals_post_constraints.prm.bak        |   73 +
 tests/simple_composite.prm.bak                |   96 +
 ...ple_compressibility_iterated_stokes.cc.bak |   21 +
 ...le_compressibility_iterated_stokes.prm.bak |   81 +
 ...compressibility_iterated_stokes_gmg.cc.bak |   21 +
 ...ompressibility_iterated_stokes_gmg.prm.bak |   19 +
 tests/simple_compressible.prm.bak             |   95 +
 tests/simple_incompressible.prm.bak           |   88 +
 tests/simple_nonlinear.cc.bak                 |  253 +
 tests/simple_nonlinear.prm.bak                |    4 +
 tests/simple_shear.cc.bak                     |  124 +
 tests/simple_shear.prm.bak                    |  134 +
 tests/simple_shear_output_the_mobility.cc.bak |  124 +
 .../simple_shear_output_the_mobility.prm.bak  |  139 +
 tests/simpler_box.prm.bak                     |   63 +
 tests/simpler_composition.prm.bak             |   61 +
 ..._iterated_defect_correction_Stokes.prm.bak |  127 +
 tests/sinking_block.cc.bak                    |   21 +
 tests/sinking_block.prm.bak                   |   10 +
 ...itions_setup_on_initial_refinement.prm.bak |   66 +
 tests/skip_refinement.prm.bak                 |  165 +
 ...skip_solvers_on_initial_refinement.prm.bak |   65 +
 ...slab2_initial_composition_3d_shell.prm.bak |   78 +
 tests/slab_tip_depth.prm                      |    4 +-
 tests/slab_tip_depth.prm.bak                  |  157 +
 tests/slope_refinement.prm.bak                |  114 +
 tests/smoothing.prm.bak                       |   98 +
 tests/smoothing_composition_passive.prm.bak   |  108 +
 tests/sol_cx_2.cc.bak                         |   21 +
 tests/sol_cx_2.prm.bak                        |   74 +
 tests/sol_cx_2_conservative.cc.bak            |   21 +
 tests/sol_cx_2_conservative.prm.bak           |   73 +
 tests/sol_cx_2_equal_order.cc.bak             |   21 +
 tests/sol_cx_2_equal_order.prm.bak            |   76 +
 tests/sol_cx_2_gmg.cc.bak                     |   21 +
 tests/sol_cx_2_gmg.prm.bak                    |   86 +
 tests/sol_cx_2_normalized_pressure.cc.bak     |   21 +
 tests/sol_cx_2_normalized_pressure.prm.bak    |   74 +
 tests/sol_cx_2_q3.cc.bak                      |   21 +
 tests/sol_cx_2_q3.prm.bak                     |   73 +
 tests/sol_cx_4.cc.bak                         |   21 +
 tests/sol_cx_4.prm.bak                        |   73 +
 tests/sol_cx_4_conservative.cc.bak            |   21 +
 tests/sol_cx_4_conservative.prm.bak           |   73 +
 tests/sol_cx_4_equal_order.cc.bak             |   21 +
 tests/sol_cx_4_equal_order.prm.bak            |   75 +
 tests/sol_cx_4_gmg.cc.bak                     |   21 +
 tests/sol_cx_4_gmg.prm.bak                    |   84 +
 tests/sol_cx_4_normalized_pressure.cc.bak     |   21 +
 tests/sol_cx_4_normalized_pressure.prm.bak    |   74 +
 ...ized_pressure_large_static_pressure.cc.bak |   21 +
 ...zed_pressure_large_static_pressure.prm.bak |   96 +
 ...lized_pressure_low_solver_tolerance.cc.bak |   21 +
 ...ized_pressure_low_solver_tolerance.prm.bak |   90 +
 tests/sol_cx_mpi_2.cc.bak                     |   21 +
 tests/sol_cx_mpi_2.prm.bak                    |   78 +
 tests/sol_cx_newton_crash.cc.bak              |   21 +
 tests/sol_cx_newton_crash.prm.bak             |   83 +
 tests/sol_cx_particles.cc.bak                 |   21 +
 tests/sol_cx_particles.prm.bak                |    9 +
 tests/sol_kz_2.cc.bak                         |   21 +
 tests/sol_kz_2.prm.bak                        |   73 +
 ...sol_kz_2_cheaper_first_phase_solver.cc.bak |   21 +
 ...ol_kz_2_cheaper_first_phase_solver.prm.bak |   79 +
 tests/sol_kz_2_conservative.cc.bak            |   21 +
 tests/sol_kz_2_conservative.prm.bak           |   73 +
 tests/sol_kz_2_no_first_phase_solver.cc.bak   |   21 +
 tests/sol_kz_2_no_first_phase_solver.prm.bak  |   79 +
 tests/sol_kz_2_project_q1_only_visc.cc.bak    |   21 +
 tests/sol_kz_2_project_q1_only_visc.prm.bak   |   14 +
 tests/sol_kz_2_q3.cc.bak                      |   21 +
 tests/sol_kz_2_q3.prm.bak                     |   73 +
 tests/sol_kz_4.cc.bak                         |   21 +
 tests/sol_kz_4.prm.bak                        |   73 +
 tests/sol_kz_4_conservative.cc.bak            |   21 +
 tests/sol_kz_4_conservative.prm.bak           |   73 +
 tests/solidus_initial_conditions.cc.bak       |  447 +
 tests/solidus_initial_conditions.prm.bak      |   85 +
 tests/solitary_wave.cc.bak                    |   21 +
 tests/solitary_wave.prm.bak                   |  159 +
 tests/solubility.cc.bak                       |   21 +
 tests/solubility.prm.bak                      |   11 +
 tests/solve_no_advection_no_stokes.prm.bak    |   71 +
 tests/solver_history.cc.bak                   |   49 +
 tests/solver_history.prm.bak                  |   69 +
 ...r_scheme_no_advection_single_stokes.cc.bak |   21 +
 ..._scheme_no_advection_single_stokes.prm.bak |   84 +
 tests/spectral_comparison.prm.bak             |   16 +
 ...erical_constant_boundary_3d_sphere.prm.bak |   74 +
 tests/spherical_nsinker.cc.bak                |   21 +
 tests/spherical_nsinker.prm.bak               |   16 +
 ...l_initial_topography_ascii_data_3d.prm.bak |   93 +
 ...ell_initial_topography_function_3d.prm.bak |   88 +
 tests/spherical_velocity_statistics.prm.bak   |   95 +
 tests/spiegelman_fail_test.cc.bak             |  678 ++
 tests/spiegelman_fail_test.prm.bak            |  129 +
 tests/spiegelman_material.cc.bak              |  303 +
 tests/spiegelman_material.prm.bak             |    4 +
 tests/splines.cc.bak                          |   74 +
 tests/splines.prm.bak                         |    1 +
 tests/static_temperature.prm.bak              |   98 +
 tests/statistics_output.prm.bak               |  142 +
 tests/steinberger_averaging.prm.bak           |  123 +
 tests/steinberger_background.prm.bak          |  106 +
 tests/steinberger_compressible.prm.bak        |   95 +
 tests/steinberger_compressible_gmg.prm.bak    |   18 +
 tests/steinberger_conductivity.prm.bak        |   80 +
 tests/steinberger_conductivity_tosi.prm.bak   |   87 +
 .../steinberger_continuous_viscosity.prm.bak  |   18 +
 tests/steinberger_cookbook.prm.bak            |   12 +
 tests/steinberger_latent_heat.prm.bak         |   90 +
 tests/steinberger_latent_heat_2.prm.bak       |  125 +
 tests/steinberger_lateral_fail.prm.bak        |  101 +
 tests/steinberger_phase_fractions.prm.bak     |  112 +
 ...nberger_phase_fractions_background.prm.bak |  129 +
 tests/steinberger_phases.prm.bak              |  110 +
 tests/steinberger_phases_2_lookups.prm.bak    |  108 +
 tests/steinberger_phases_hefesto.prm.bak      |  111 +
 tests/steinberger_projected_density.prm.bak   |  114 +
 ...nberger_projected_density_dcPicard.prm.bak |  118 +
 tests/steinberger_seismic_velocities.prm.bak  |   98 +
 tests/steinberger_several_fields.prm.bak      |  110 +
 tests/steinberger_single_field.prm.bak        |  110 +
 tests/steinberger_viscosity.prm.bak           |   91 +
 tests/steinberger_viscosity_adiabatic.prm.bak |  101 +
 tests/stokes.prm.bak                          |  124 +
 tests/stokes_residual.prm.bak                 |   66 +
 tests/stokes_residual_cheap.prm.bak           |   11 +
 tests/stokes_solver_fail.prm                  |    2 +-
 tests/stokes_solver_fail.prm.bak              |   17 +
 tests/stokes_solver_fail_A.prm.bak            |   15 +
 tests/stokes_solver_fail_S.prm.bak            |   15 +
 tests/stokes_solver_fail_cheap.prm.bak        |   17 +
 tests/stokes_solver_fail_gmg.prm.bak          |   21 +
 tests/stress_vs_surface_stress.cc.bak         |   21 +
 tests/stress_vs_surface_stress.prm.bak        |   92 +
 ...ress_vs_surface_stress_point_values.cc.bak |   21 +
 ...ess_vs_surface_stress_point_values.prm.bak |   17 +
 ...on_initiation_compositional_fields.prm.bak |   51 +
 tests/supg-compositional-passive.prm.bak      |  107 +
 tests/supg.prm.bak                            |   98 +
 .../surface_elevation_box_ascii_data.prm.bak  |   17 +
 ...vation_box_ascii_data_moved_origin.prm.bak |   17 +
 tests/surface_elevation_box_function.prm.bak  |   17 +
 .../surface_elevation_box_prm_polygon.prm.bak |   17 +
 ...surface_elevation_chunk_ascii_data.prm.bak |   17 +
 ...face_elevation_chunk_ascii_data_3d.prm.bak |   17 +
 ...ion_chunk_ascii_data_3d_colatitude.prm.bak |   32 +
 ...evation_chunk_ascii_data_global_3d.prm.bak |  112 +
 ...herical_shell_ascii_data_global_3d.prm.bak |   95 +
 tests/surface_stress_strainrate_3d.cc.bak     |    1 +
 tests/surface_stress_strainrate_3d.prm.bak    |   99 +
 tests/symbolic_boundary_names_box.prm.bak     |   66 +
 ...lic_boundary_names_box_constant_bc.prm.bak |   70 +
 ...mes_spherical_shell_2d_180_degrees.prm.bak |   64 +
 ...ames_spherical_shell_2d_90_degrees.prm.bak |   64 +
 ...dary_names_spherical_shell_2d_full.prm.bak |   60 +
 ...ames_spherical_shell_3d_90_degrees.prm.bak |   64 +
 ...dary_names_spherical_shell_3d_full.prm.bak |   60 +
 tests/tangurnis.cc.bak                        |   21 +
 tests/tangurnis_ba.cc.bak                     |   21 +
 tests/tangurnis_ba.prm.bak                    |  248 +
 tests/tangurnis_ba_custom.cc.bak              |   21 +
 tests/tangurnis_ba_custom.prm.bak             |  247 +
 tests/tangurnis_tala.cc.bak                   |   21 +
 tests/tangurnis_tala.prm.bak                  |  262 +
 tests/tangurnis_tala_c.cc.bak                 |   21 +
 tests/tangurnis_tala_c.prm.bak                |  262 +
 tests/tangurnis_tala_gmg.cc.bak               |   21 +
 tests/tangurnis_tala_gmg.prm.bak              |   19 +
 tests/tangurnis_tala_implicit.cc.bak          |   21 +
 tests/tangurnis_tala_implicit.prm.bak         |  265 +
 ...emperature_dependent_stokes_matrix.prm.bak |   76 +
 tests/terminate_user_request.cc.bak           |   34 +
 tests/terminate_user_request.prm.bak          |   71 +
 tests/thermal_alpha_s40rts.prm.bak            |   66 +
 tests/tian_MORB.prm.bak                       |   27 +
 tests/tian_gabbro.prm.bak                     |   27 +
 tests/tian_peridotite.prm.bak                 |  122 +
 tests/tian_sediment.prm.bak                   |   27 +
 tests/time_dependent_annulus.cc.bak           |   21 +
 tests/time_dependent_annulus.prm.bak          |   10 +
 tests/time_dependent_temperature_bc.cc.bak    |  251 +
 tests/time_dependent_temperature_bc.prm.bak   |  100 +
 tests/time_dependent_temperature_bc_2.cc.bak  |   21 +
 tests/time_dependent_temperature_bc_2.prm.bak |   97 +
 tests/time_stepping_fail.prm.bak              |   65 +
 tests/time_stepping_function.prm.bak          |   63 +
 tests/time_stepping_min.prm.bak               |   66 +
 tests/time_stepping_repeat.prm.bak            |   99 +
 tests/time_stepping_repeat_particles.prm.bak  |  127 +
 ...epeat_particles_iterated_advection.prm.bak |   30 +
 ...graphy_based_plate_motions_cookbook.cc.bak |   22 +
 ...raphy_based_plate_motions_cookbook.prm.bak |   39 +
 tests/topo_box.prm.bak                        |  119 +
 tests/topo_chunk.prm.bak                      |   86 +
 tests/topo_shell.prm.bak                      |   75 +
 tests/tosi_benchmark.cc.bak                   |   21 +
 tests/tosi_benchmark.prm.bak                  |    8 +
 ...tosi_benchmark_gmg_dc_picard_solver.cc.bak |    1 +
 ...osi_benchmark_gmg_dc_picard_solver.prm.bak |   17 +
 tests/tosi_benchmark_gmg_newton_solver.cc.bak |   21 +
 .../tosi_benchmark_gmg_newton_solver.prm.bak  |   18 +
 tests/tosi_benchmark_newton_solver.cc.bak     |   21 +
 tests/tosi_benchmark_newton_solver.prm.bak    |    8 +
 ...tosi_benchmark_newton_solver_full_A.cc.bak |   21 +
 ...osi_benchmark_newton_solver_full_A.prm.bak |   15 +
 tests/traction_ascii_data.prm.bak             |  133 +
 tests/traction_multiple_model.prm.bak         |  135 +
 tests/transform_fault_behn_2007.prm.bak       |   11 +
 tests/two_merged_boxes_free_surface.prm.bak   |   72 +
 ...an_parameterization_kinematic_slab.prm.bak |   50 +
 tests/update_script.cc.bak                    |   65 +
 tests/update_script_2.cc.bak                  |   70 +
 tests/update_script_2/updated2.prm.bak        |  135 +
 tests/upwelling_melting_peridotite.prm.bak    |  135 +
 ...ng_melting_peridotite_compressible.prm.bak |  128 +
 tests/upwelling_melting_pyroxenite.prm.bak    |  161 +
 tests/use_full_A_block_preconditioner.prm.bak |   88 +
 tests/van_keken_smooth_particle.prm.bak       |  108 +
 tests/vankeken_subduction.cc.bak              |    2 +
 tests/vankeken_subduction.prm.bak             |   13 +
 tests/var_declaration_expansion.cc.bak        |   55 +
 tests/var_declaration_expansion.prm.bak       |   80 +
 tests/velocity_boundary_statistics.prm.bak    |   92 +
 tests/velocity_divergence.cc.bak              |   69 +
 tests/velocity_divergence.prm.bak             |  161 +
 tests/velocity_in_years.prm.bak               |   89 +
 tests/vep_chemical_compositions.prm.bak       |   84 +
 tests/vis_velocity_in_years.prm.bak           |   63 +
 tests/visco_elastic_top_beam.prm              |    2 +-
 tests/visco_elastic_top_beam.prm.bak          |  154 +
 tests/visco_plastic.prm.bak                   |   96 +
 ...plastic_additional_plastic_outputs.prm.bak |  132 +
 .../visco_plastic_adiabat_temperature.prm.bak |  118 +
 ..._plastic_adiabatic_heating_density.prm.bak |  115 +
 ...diabatic_pressure_in_viscous_creep.prm.bak |  149 +
 tests/visco_plastic_complex.prm.bak           |  174 +
 tests/visco_plastic_composite.prm.bak         |  108 +
 ...astic_constant_viscosity_prefactor.prm.bak |  104 +
 tests/visco_plastic_derivatives_2d.cc.bak     |  274 +
 tests/visco_plastic_derivatives_2d.prm.bak    |  118 +
 tests/visco_plastic_derivatives_3d.cc.bak     |  289 +
 tests/visco_plastic_derivatives_3d.prm.bak    |  118 +
 tests/visco_plastic_diffusion.prm.bak         |  110 +
 ...ic_diffusion_dislocation_composite.prm.bak |  116 +
 tests/visco_plastic_dislocation.prm.bak       |  109 +
 tests/visco_plastic_frank_kamenetskii.prm.bak |  107 +
 ...plastic_frank_kamenetskii_pressure.prm.bak |  108 +
 tests/visco_plastic_friction_function.prm.bak |  111 +
 tests/visco_plastic_gerya_2019_vp.prm.bak     |   21 +
 ...astic_newton_nonlinear_channelflow.prm.bak |  124 +
 .../visco_plastic_peierls_cutoff_test.prm.bak |  100 +
 ...isco_plastic_peierls_idrissi_exact.prm.bak |  120 +
 tests/visco_plastic_peierls_mei_exact.prm.bak |  120 +
 ...astic_peierls_mei_viscosity_approx.prm.bak |   77 +
 ...plastic_peierls_strict_cutoff_test.prm.bak |  101 +
 tests/visco_plastic_phases.prm.bak            |  106 +
 .../visco_plastic_phases_compositions.prm.bak |  123 +
 ...o_plastic_phases_peierls_mei_exact.prm.bak |   80 +
 tests/visco_plastic_phases_plasticity.prm.bak |  111 +
 ...ic_phases_temperature_limit_basalt.prm.bak |  117 +
 ...ases_temperature_limit_harzburgite.prm.bak |  117 +
 ..._phases_temperature_limit_pyrolite.prm.bak |  117 +
 ...erature_limit_pyrolite_complicated.prm.bak |  117 +
 tests/visco_plastic_phases_viscosity.prm.bak  |  129 +
 ...o_plastic_phases_viscosity_max_min.prm.bak |  133 +
 ..._plastic_reference_density_profile.prm.bak |  103 +
 ...visco_plastic_thermal_conductivity.prm.bak |   21 +
 ...rain_healing_temperature_dependent.prm.bak |  166 +
 ...ic_track_noninitial_plastic_strain.prm.bak |  133 +
 tests/visco_plastic_vep_bending_beam.prm.bak  |   49 +
 .../visco_plastic_vep_brick_extension.prm.bak |   63 +
 tests/visco_plastic_vep_plate_flexure.prm.bak |   51 +
 tests/visco_plastic_vep_simple_shear.prm.bak  |    7 +
 .../visco_plastic_vep_stress_build-up.prm.bak |   58 +
 ...s_build-up_fixed_elastic_time_step.prm.bak |   57 +
 ...p_stress_build-up_stress_averaging.prm.bak |   59 +
 ..._plastic_vep_stress_build-up_yield.prm.bak |   71 +
 ...ep_stress_build-up_yield_particles.prm.bak |   92 +
 ...o_plastic_viscous_strain_weakening.prm.bak |  130 +
 tests/visco_plastic_yield.prm.bak             |   99 +
 tests/visco_plastic_yield_max.prm.bak         |  118 +
 ...oninitial-plastic-strain_particles.prm.bak |   59 +
 ...visco_plastic_yield_plastic_damper.prm.bak |   26 +
 ...tic_yield_plastic_strain_weakening.prm.bak |  132 +
 ...plastic_strain_weakening_particles.prm.bak |   31 +
 ...eld_plastic_viscous_strain_healing.prm.bak |  148 +
 ...d_plastic_viscous_strain_weakening.prm.bak |  135 +
 ...viscous_strain_weakening_particles.prm.bak |   31 +
 ...sco_plastic_yield_strain_weakening.prm.bak |  132 +
 ...ield_strain_weakening_compositions.prm.bak |  127 +
 ...train_weakening_defect_corr_stokes.prm.bak |    4 +
 ...train_weakening_full_strain_tensor.prm.bak |  134 +
 ...in_weakening_full_strain_tensor_3d.prm.bak |  130 +
 ...train_weakening_iterated_advection.prm.bak |   44 +
 ...rain_weakening_no-advect_no_stokes.prm.bak |    7 +
 ...c_yield_strain_weakening_particles.prm.bak |   31 +
 ...activated_viscous_strain_weakening.prm.bak |   46 +
 ...plastic_yield_total_strain_healing.prm.bak |  147 +
 ...tic_yield_viscous_strain_weakening.prm.bak |  131 +
 ...viscous_strain_weakening_particles.prm.bak |   31 +
 tests/viscoelastic_bending_beam.prm.bak       |   51 +
 ...iscoelastic_bending_beam_averaging.prm.bak |   38 +
 tests/viscoelastic_bending_beam_gmg.prm.bak   |   47 +
 ...iscoelastic_bending_beam_particles.prm.bak |   53 +
 ...stic_bending_beam_principal_stress.prm.bak |   34 +
 ...scoelastic_fixed_elastic_time_step.prm.bak |   54 +
 ...lastic_numerical_elastic_time_step.prm.bak |   55 +
 ...erical_elastic_time_step_particles.prm.bak |   75 +
 tests/viscoelastic_plate_flexure.prm.bak      |   32 +
 tests/viscoelastic_sheared_torsion.prm.bak    |    9 +
 tests/viscoelastic_stress_averaging.prm.bak   |   56 +
 tests/viscoelastic_stress_build-up.prm.bak    |   83 +
 .../viscoelastic_stress_build-up_gmg.prm.bak  |   98 +
 ...d_plastic_viscous_strain_weakening.prm.bak |   77 +
 tests/viscoplastic_melt_blob_freezing.prm.bak |   64 +
 tests/viscoplastic_melt_fraction.prm.bak      |  118 +
 tests/viscosity_refinement.prm.bak            |   67 +
 tests/viscous_dissipation_statistics.prm.bak  |  124 +
 tests/viscous_top_beam.prm                    |    2 +-
 tests/viscous_top_beam.prm.bak                |  163 +
 ...visualization_averaged_strain_rate.prm.bak |   84 +
 ...isualization_averaged_strain_rate2.prm.bak |   12 +
 ...alization_conductivity_diffusivity.prm.bak |   80 +
 .../visualization_higher_order_output.prm.bak |   17 +
 tests/visualization_shear_stress.prm.bak      |   87 +
 ...sualization_shear_stress_pointwise.prm.bak |   12 +
 ...lization_shear_stress_viscoelastic.prm.bak |   49 +
 tests/visualization_strain_rate.prm.bak       |   84 +
 ...isualization_strain_rate_pointwise.prm.bak |   12 +
 .../visualization_strain_rate_tensor.prm.bak  |   83 +
 ...ation_strain_rate_tensor_pointwise.prm.bak |   12 +
 tests/visualization_stress.prm.bak            |   90 +
 tests/visualization_stress_pointwise.prm.bak  |   12 +
 .../visualization_stress_viscoelastic.prm.bak |   49 +
 .../visualization_temperature_anomaly.prm.bak |   85 +
 tests/visualization_unique_list.prm.bak       |   83 +
 .../visualization_vertical_heat_flux.prm.bak  |   90 +
 tests/viz_mesh_deform_vector.prm.bak          |  124 +
 tests/viz_plugin_dependency.cc.bak            |   89 +
 tests/viz_plugin_dependency.prm.bak           |   80 +
 .../viz_spherical_velocity_components.prm.bak |   80 +
 tests/vof_circle_1.cc.bak                     |   23 +
 tests/vof_circle_1.prm.bak                    |   94 +
 tests/vof_circle_amr.cc.bak                   |   23 +
 tests/vof_circle_amr.prm.bak                  |   97 +
 tests/vof_circle_mpi.cc.bak                   |   23 +
 tests/vof_circle_mpi.prm.bak                  |   96 +
 tests/vof_circle_mpi_amr.cc.bak               |   23 +
 tests/vof_circle_mpi_amr.prm.bak              |   99 +
 tests/vof_composition_init.prm.bak            |   81 +
 tests/vof_err_calc.h.bak                      |  342 +
 tests/vof_linear.cc.bak                       |   23 +
 tests/vof_linear.prm.bak                      |   93 +
 tests/vof_linear_2f.cc.bak                    |   23 +
 tests/vof_linear_2f.prm.bak                   |   93 +
 tests/vof_linear_amr.cc.bak                   |   23 +
 tests/vof_linear_amr.prm.bak                  |   95 +
 tests/vof_linear_amr_mpi.cc.bak               |   23 +
 tests/vof_linear_amr_mpi.prm.bak              |   97 +
 tests/vof_linear_inflow.prm.bak               |   86 +
 tests/vof_linear_periodic.cc.bak              |   23 +
 tests/vof_linear_periodic.prm.bak             |   94 +
 tests/vof_linear_periodic_amr.cc.bak          |   23 +
 tests/vof_linear_periodic_amr.prm.bak         |   96 +
 tests/vof_mpi_amr_no_dof.prm.bak              |   85 +
 tests/walltime.prm.bak                        |   64 +
 tests/weighted_p_norm_average.cc.bak          |   46 +
 .../world_builder_select_composition.prm.bak  |   69 +
 tests/world_builder_select_grains.prm.bak     |   95 +
 tests/world_builder_simple.prm.bak            |   70 +
 ...der_simple_2d_cartesian_sticky_air.prm.bak |   71 +
 tests/write_plugin_graph.cc.bak               |   98 +
 tests/write_plugin_graph.prm.bak              |   76 +
 tests/zero_RHS.prm.bak                        |  120 +
 tests/zero_matrix.prm.bak                     |  115 +
 tests/zero_temperature.prm.bak                |   94 +
 unit_tests/additional_outputs.cc.bak          |   98 +
 unit_tests/common.h.bak                       |   67 +
 .../crystal_preferred_orientation.cc.bak      | 2309 +++++
 unit_tests/first.cc.bak                       |   89 +
 unit_tests/introspection.cc.bak               |  135 +
 unit_tests/mesh_refinement.cc.bak             |   59 +
 unit_tests/netcdf.cc.bak                      |  101 +
 unit_tests/parse_map_to_double_array.cc.bak   |  460 +
 unit_tests/particles.cc.bak                   |   56 +
 unit_tests/termination_criteria.cc.bak        |   68 +
 unit_tests/utilities.cc.bak                   |  628 ++
 2964 files changed, 427292 insertions(+), 237 deletions(-)
 create mode 100644 benchmarks/advection/drop_ev.prm.bak
 create mode 100644 benchmarks/advection/drop_supg.prm.bak
 create mode 100644 benchmarks/advection/rotate_shape_dg_bp.prm.bak
 create mode 100644 benchmarks/advection/rotate_shape_dg_weno.prm.bak
 create mode 100644 benchmarks/advection/rotate_shape_ev.prm.bak
 create mode 100644 benchmarks/advection/rotate_shape_supg.prm.bak
 create mode 100644 benchmarks/advection_in_annulus/advection_in_annulus.cc.bak
 create mode 100644 benchmarks/advection_in_annulus/advection_in_annulus.prm.bak
 create mode 100644 benchmarks/annulus/instantaneous/annulus.prm.bak
 create mode 100644 benchmarks/annulus/plugin/annulus.cc.bak
 create mode 100644 benchmarks/annulus/transient/transient_annulus.prm.bak
 create mode 100644 benchmarks/blankenbach/base_case1a.prm.bak
 create mode 100644 benchmarks/blankenbach/base_case1b.prm.bak
 create mode 100644 benchmarks/blankenbach/base_case1c.prm.bak
 create mode 100644 benchmarks/blankenbach/base_case2a.prm.bak
 create mode 100644 benchmarks/blankenbach/base_case2b.prm.bak
 create mode 100644 benchmarks/blankenbach/plugin/code.cc.bak
 create mode 100644 benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc.bak
 create mode 100644 benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.h.bak
 create mode 100644 benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm.bak
 create mode 100644 benchmarks/buiter_et_al_2008_jgr/figure_6_1e22.prm.bak
 create mode 100644 benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm.bak
 create mode 100644 benchmarks/buiter_et_al_2016_jsg/doc/velocity_bc.part.prm.bak
 create mode 100644 benchmarks/buiter_et_al_2016_jsg/exp_1.prm.bak
 create mode 100644 benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm.bak
 create mode 100644 benchmarks/buiter_et_al_2016_jsg/exp_2_low_resolution.prm.bak
 create mode 100644 benchmarks/burstedde/burstedde.cc.bak
 create mode 100644 benchmarks/burstedde/burstedde.prm.bak
 create mode 100644 benchmarks/burstedde/doc/burstedde.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe/adiabatic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe/ala.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe/hydrostatic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe/isentropic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe/sub_adiabatic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/ala.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/hydrostatic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/isentropic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/ala.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/hydrostatic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/isentropic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density_full_pressure.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/ala.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/hydrostatic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/isentropic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/timestep.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc.bak
 create mode 100644 benchmarks/compressibility_formulations/vertical_pipe/adiabatic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/vertical_pipe/ala.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/vertical_pipe/hydrostatic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/vertical_pipe/isentropic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/vertical_pipe/sub_adiabatic.prm.bak
 create mode 100644 benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm.bak
 create mode 100644 benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc.bak
 create mode 100644 benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm.bak
 create mode 100644 benchmarks/crameri_et_al/case_1/crameri_benchmark_1_gmg.prm.bak
 create mode 100644 benchmarks/crameri_et_al/case_2/crameri_benchmark_2.prm.bak
 create mode 100644 benchmarks/crameri_et_al/doc/crameri_benchmark_1.prm.bak
 create mode 100644 benchmarks/crameri_et_al/doc/crameri_benchmark_2.prm.bak
 create mode 100644 benchmarks/davies_et_al/case-1.1.prm.bak
 create mode 100644 benchmarks/davies_et_al/case-2.1.prm.bak
 create mode 100644 benchmarks/davies_et_al/case-2.2.prm.bak
 create mode 100644 benchmarks/davies_et_al/case-2.3-plugin/VoT.cc.bak
 create mode 100644 benchmarks/davies_et_al/case-2.3.prm.bak
 create mode 100644 benchmarks/davies_et_al/doc/case-1.1.prm.bak
 create mode 100644 benchmarks/davies_et_al/doc/case-2.1.prm.bak
 create mode 100644 benchmarks/davies_et_al/doc/case-2.2.prm.bak
 create mode 100644 benchmarks/davies_et_al/doc/case-2.3.prm.bak
 create mode 100644 benchmarks/diffusion_of_hill/1_sine_zero_flux.prm.bak
 create mode 100644 benchmarks/diffusion_of_hill/2_sine_constant_h.prm.bak
 create mode 100644 benchmarks/diffusion_of_hill/analytical_topography.cc.bak
 create mode 100644 benchmarks/diffusion_of_hill/analytical_topography.h.bak
 create mode 100644 benchmarks/doneahuerta/doneahuerta.cc.bak
 create mode 100644 benchmarks/doneahuerta/doneahuerta.prm.bak
 create mode 100644 benchmarks/entropy_adiabat/entropy_adiabat.prm.bak
 create mode 100644 benchmarks/entropy_adiabat/entropy_combined.prm.bak
 create mode 100644 benchmarks/entropy_adiabat/entropy_conduction.prm.bak
 create mode 100644 benchmarks/entropy_adiabat/entropy_half_space.prm.bak
 create mode 100644 benchmarks/entropy_adiabat/plugins/entropy_advection.cc.bak
 create mode 100644 benchmarks/entropy_adiabat/plugins/entropy_advection.h.bak
 create mode 100644 benchmarks/finite_strain/finite_strain.cc.bak
 create mode 100644 benchmarks/finite_strain/pure_shear.prm.bak
 create mode 100644 benchmarks/finite_strain/simple_shear.prm.bak
 create mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm.bak
 create mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt.prm.bak
 create mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_unloading.prm.bak
 create mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading.prm.bak
 create mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading_fixed_elastic_dt.prm.bak
 create mode 100644 benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_2D_loading.prm.bak
 create mode 100644 benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_3D_loading.prm.bak
 create mode 100644 benchmarks/geoid-spectral-comparison/spectral-comparison.prm.bak
 create mode 100644 benchmarks/grain_size_pinned_state/grain_size_plunge.prm.bak
 create mode 100644 benchmarks/gravity_mantle/mantle_gravity.prm.bak
 create mode 100644 benchmarks/gravity_thick_shell/doc/thick_shell.prm.bak
 create mode 100644 benchmarks/gravity_thick_shell/thick_shell.prm.bak
 create mode 100644 benchmarks/gravity_thin_shell/doc/thinshell_a.prm.bak
 create mode 100644 benchmarks/gravity_thin_shell/doc/thinshell_b.prm.bak
 create mode 100644 benchmarks/gravity_thin_shell/doc/thinshell_c.prm.bak
 create mode 100644 benchmarks/gravity_thin_shell/gravity_thin_shell.prm.bak
 create mode 100644 benchmarks/hollow_sphere/hollow_sphere.cc.bak
 create mode 100644 benchmarks/hollow_sphere/hollow_sphere.prm.bak
 create mode 100644 benchmarks/inclusion/adaptive.prm.base.bak
 create mode 100644 benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.cc.bak
 create mode 100644 benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.h.bak
 create mode 100644 benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.prm.bak
 create mode 100644 benchmarks/inclusion/compositional_fields/inclusion_particles.prm.bak
 create mode 100644 benchmarks/inclusion/doc/inclusion.prm.bak
 create mode 100644 benchmarks/inclusion/global.prm.base.bak
 create mode 100644 benchmarks/inclusion/inclusion.cc.bak
 create mode 100644 benchmarks/inclusion/inclusion.h.bak
 create mode 100644 benchmarks/infill_density/infill_ascii.prm.bak
 create mode 100644 benchmarks/infill_density/infill_ascii_data.cc.bak
 create mode 100644 benchmarks/king2dcompressible/ala.prm.bak
 create mode 100644 benchmarks/king2dcompressible/plugin/code.cc.bak
 create mode 100644 benchmarks/layeredflow/layeredflow.cc.bak
 create mode 100644 benchmarks/layeredflow/layeredflow.prm.bak
 create mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm.bak
 create mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t_gmg.prm.bak
 create mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm.bak
 create mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v_gmg.prm.bak
 create mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc.bak
 create mode 100644 benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/drucker_prager_compositions.cc.bak
 create mode 100644 benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/input.prm.bak
 create mode 100644 benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm.bak
 create mode 100644 benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm.bak
 create mode 100644 benchmarks/nsinker/nsinker.cc.bak
 create mode 100644 benchmarks/nsinker/nsinker.prm.bak
 create mode 100644 benchmarks/nsinker/nsinker_2d.prm.bak
 create mode 100644 benchmarks/nsinker/nsinker_bfbt.prm.bak
 create mode 100644 benchmarks/nsinker/nsinker_gmg.prm.bak
 create mode 100644 benchmarks/nsinker_spherical_shell/amg.prm.bak
 create mode 100644 benchmarks/nsinker_spherical_shell/gmg.prm.bak
 create mode 100644 benchmarks/nsinker_spherical_shell/nsinker.cc.bak
 create mode 100644 benchmarks/onset-of-convection/convection-box-base.prm.bak
 create mode 100644 benchmarks/operator_splitting/advection_reaction/advection_reaction.base.prm.bak
 create mode 100644 benchmarks/operator_splitting/advection_reaction/advection_reaction.cc.bak
 create mode 100644 benchmarks/operator_splitting/doc/exponential_decay.part.1.prm.bak
 create mode 100644 benchmarks/operator_splitting/doc/exponential_decay.part.2.prm.bak
 create mode 100644 benchmarks/operator_splitting/exponential_decay/exponential_decay.base.prm.bak
 create mode 100644 benchmarks/operator_splitting/exponential_decay/exponential_decay.cc.bak
 create mode 100644 benchmarks/particle_integration_scheme/circle.prm.bak
 create mode 100644 benchmarks/particle_integration_scheme/euler.part.prm.bak
 create mode 100644 benchmarks/particle_integration_scheme/rk2.part.prm.bak
 create mode 100644 benchmarks/particle_integration_scheme/rk4.part.prm.bak
 create mode 100644 benchmarks/polydiapirs/polydiapirs.prm.bak
 create mode 100644 benchmarks/rayleigh_taylor_instability/blank.prm.bak
 create mode 100644 benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.cc.bak
 create mode 100644 benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.prm.bak
 create mode 100644 benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm.bak
 create mode 100644 benchmarks/rayleigh_taylor_instability_free_surface/rose_rayleigh_taylor_instability.prm.bak
 create mode 100644 benchmarks/rigid_shear/instantaneous/rigid_shear.prm.bak
 create mode 100644 benchmarks/rigid_shear/plugin/rigid_shear.cc.bak
 create mode 100644 benchmarks/rigid_shear/steady-state/rigid_shear.prm.bak
 create mode 100644 benchmarks/rigid_shear/transient/rigid_shear.prm.bak
 create mode 100644 benchmarks/shear_bands/magmatic_shear_bands.prm.bak
 create mode 100644 benchmarks/shear_bands/shear_bands.cc.bak
 create mode 100644 benchmarks/shear_bands/shear_bands.prm.bak
 create mode 100644 benchmarks/sinking_block/blank.prm.bak
 create mode 100644 benchmarks/sinking_block/sinking_block.cc.bak
 create mode 100644 benchmarks/sinking_block/sinking_block.prm.bak
 create mode 100644 benchmarks/slab_detachment/slab_detachment.prm.bak
 create mode 100644 benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc.bak
 create mode 100644 benchmarks/solcx/compositional_fields/solcx_compositional_fields.h.bak
 create mode 100644 benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm.bak
 create mode 100644 benchmarks/solcx/compositional_fields/solcx_particles.prm.bak
 create mode 100644 benchmarks/solcx/doc/solcx.prm.bak
 create mode 100644 benchmarks/solcx/solcx.cc.bak
 create mode 100644 benchmarks/solcx/solcx.h.bak
 create mode 100644 benchmarks/solcx/solcx.prm.bak
 create mode 100644 benchmarks/solitary_wave/doc/solitary_wave.prm.bak
 create mode 100644 benchmarks/solitary_wave/solitary_wave.cc.bak
 create mode 100644 benchmarks/solitary_wave/solitary_wave.prm.bak
 create mode 100644 benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc.bak
 create mode 100644 benchmarks/solkz/compositional_fields/solkz_compositional_fields.h.bak
 create mode 100644 benchmarks/solkz/compositional_fields/solkz_compositional_fields.prm.bak
 create mode 100644 benchmarks/solkz/compositional_fields/solkz_particles.prm.bak
 create mode 100644 benchmarks/solkz/doc/solkz.prm.bak
 create mode 100644 benchmarks/solkz/solkz.cc.bak
 create mode 100644 benchmarks/solkz/solkz.h.bak
 create mode 100644 benchmarks/solkz/solkz.prm.bak
 create mode 100644 benchmarks/solubility/plugin/solubility.cc.bak
 create mode 100644 benchmarks/solubility/solubility.prm.bak
 create mode 100644 benchmarks/tangurnis/ba/tan.prm.bak
 create mode 100644 benchmarks/tangurnis/code/tangurnis.cc.bak
 create mode 100644 benchmarks/tangurnis/tala/tan.prm.bak
 create mode 100644 benchmarks/tangurnis/tala_c/tan.prm.bak
 create mode 100644 benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc.bak
 create mode 100644 benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.h.bak
 create mode 100644 benchmarks/time_dependent_annulus/time_dependent_annulus.prm.bak
 create mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak
 create mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak
 create mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak
 create mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak
 create mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak
 create mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm.bak
 create mode 100644 benchmarks/tosi_et_al_2015_gcubed/doc/tosi_benchmark_2.prm.bak
 create mode 100644 benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak
 create mode 100644 benchmarks/viscoelastic_beam_modified/20km_opentopbot.prm.bak
 create mode 100644 benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm.bak
 create mode 100644 benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm.bak
 create mode 100644 benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_particles.prm.bak
 create mode 100644 benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm.bak
 create mode 100644 benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vep.prm.bak
 create mode 100644 benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm.bak
 create mode 100644 benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp_damper.prm.bak
 create mode 100644 benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm.bak
 create mode 100644 benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm.bak
 create mode 100644 benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm.bak
 create mode 100644 benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm.bak
 create mode 100644 benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm.bak
 create mode 100644 benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_particles.prm.bak
 create mode 100644 benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield.prm.bak
 create mode 100644 benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield_particles.prm.bak
 create mode 100644 benchmarks/viscosity_grooves/viscosity_grooves.cc.bak
 create mode 100644 benchmarks/viscosity_grooves/viscosity_grooves.prm.bak
 create mode 100644 benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.cc.bak
 create mode 100644 benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.h.bak
 create mode 100644 benchmarks/yamauchi_takei_2016_anelasticity/yamauchi_takei_2016_anelasticity.prm.bak
 create mode 100644 benchmarks/zhong_et_al_93/zhong_case1.prm.bak
 create mode 100644 contrib/opendap/prm_files/aspect_test.prm.bak
 create mode 100644 contrib/opendap/prm_files/aspect_url_test.prm.bak
 create mode 100644 contrib/perplex/perplex_lookup_composition.prm.bak
 create mode 100644 contrib/python/notebooks/read_output_files/convection-box.prm.bak
 create mode 100644 contrib/python/scripts/__pycache__/aspect_input.cpython-312.pyc
 create mode 100644 contrib/world_builder/include/app/main.h.bak
 create mode 100644 contrib/world_builder/include/glm/glm.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/allocators.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/cursorstreamwrapper.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/encodedstream.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/encodings.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/error/en.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/error/error.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/filereadstream.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/filewritestream.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/fwd.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/biginteger.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/diyfp.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/dtoa.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/ieee754.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/itoa.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/meta.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/pow10.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/regex.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/stack.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/strfunc.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/strtod.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/internal/swap.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/istreamwrapper.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/latexwriter.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/memorybuffer.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/memorystream.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/msinttypes/inttypes.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/msinttypes/stdint.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/mystwriter.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/ostreamwrapper.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/pointer.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/prettywriter.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/rapidjson.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/reader.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/schema.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/stream.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/stringbuffer.h.bak
 create mode 100644 contrib/world_builder/include/rapidjson/writer.h.bak
 create mode 100644 contrib/world_builder/include/visualization/main.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/assert.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/bounding_box.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/consts.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/coordinate_system.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/coordinate_systems/cartesian.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/coordinate_systems/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/coordinate_systems/invalid.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/coordinate_systems/spherical.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/deprecate.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/composition/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/composition/random.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/composition/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/grains/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/grains/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/adiabatic.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/linear.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/composition/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/composition/smooth.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/composition/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/grains/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/grains/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/temperature/adiabatic.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/temperature/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/temperature/linear.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/fault_models/temperature/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/feature_utilities.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/adiabatic.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/linear.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/adiabatic.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/half_space_model.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/linear.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/plume.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/plume_models/composition/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/plume_models/composition/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/plume_models/grains/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/plume_models/grains/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/plume_models/temperature/gaussian.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/plume_models/temperature/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/plume_models/temperature/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/smooth.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/adiabatic.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/linear.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/mass_conserving.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/plate_model.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/grains.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/gravity_model/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/gravity_model/uniform.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/kd_tree.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/nan.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/objects/bezier_curve.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/objects/closest_point_on_curve.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/objects/distance_from_surface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/objects/natural_coordinate.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/objects/segment.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/objects/surface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/parameters.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/point.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/array.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/bool.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/double.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/int.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/interface.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/object.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/one_of.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/plugin_system.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/point.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/segment.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/string.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/unsigned_int.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/types/value_at_points.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/utilities.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/world.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/wrapper_c.h.bak
 create mode 100644 contrib/world_builder/include/world_builder/wrapper_cpp.h.bak
 create mode 100644 contrib/world_builder/source/gwb-dat/main.cc.bak
 create mode 100644 contrib/world_builder/source/gwb-grid/main.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/coordinate_systems/cartesian.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/coordinate_systems/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/coordinate_systems/invalid.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/coordinate_systems/spherical.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/composition/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/composition/random.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/composition/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/grains/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/grains/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/adiabatic.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/linear.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/composition/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/composition/smooth.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/composition/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/grains/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/grains/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/temperature/adiabatic.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/temperature/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/temperature/linear.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/fault_models/temperature/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/feature_utilities.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/adiabatic.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/linear.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/adiabatic.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/half_space_model.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/linear.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/plume.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/plume_models/composition/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/plume_models/composition/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/plume_models/grains/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/plume_models/grains/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/plume_models/temperature/gaussian.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/plume_models/temperature/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/plume_models/temperature/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/smooth.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/adiabatic.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/linear.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/mass_conserving.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/plate_model.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/grains.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/gravity_model/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/gravity_model/uniform.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/kd_tree.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/objects/bezier_curve.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/objects/distance_from_surface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/objects/natural_coordinate.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/objects/segment.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/objects/surface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/parameters.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/point.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/array.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/bool.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/double.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/int.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/interface.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/object.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/one_of.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/plugin_system.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/point.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/segment.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/string.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/unsigned_int.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/types/value_at_points.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/utilities.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/world.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/wrapper_c.cc.bak
 create mode 100644 contrib/world_builder/source/world_builder/wrapper_cpp.cc.bak
 create mode 100644 contrib/world_builder/tests/unit_tests/bounding_box.cc.bak
 create mode 100644 contrib/world_builder/tests/unit_tests/gwb_gravity.cc.bak
 create mode 100644 contrib/world_builder/tests/unit_tests/kd_tree.cc.bak
 create mode 100644 contrib/world_builder/tests/unit_tests/main.cc.bak
 create mode 100644 contrib/world_builder/tests/unit_tests/unit_test_wb_glm.cc.bak
 create mode 100644 contrib/world_builder/tests/unit_tests/unit_test_world_builder.cc.bak
 create mode 100644 cookbooks/2d_annulus_visualization/2d_annulus_example.prm.bak
 create mode 100644 cookbooks/allken_et_al_2012_rift_interaction/allken.prm.bak
 create mode 100644 cookbooks/anisotropic_viscosity/AV_Rayleigh_Taylor.prm.bak
 create mode 100644 cookbooks/anisotropic_viscosity/av_material.cc.bak
 create mode 100644 cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm.bak
 create mode 100644 cookbooks/burnman/burnman.prm.bak
 create mode 100644 cookbooks/burnman/doc/adiabatic_conditions.part.prm.bak
 create mode 100644 cookbooks/burnman/doc/formulation.part.prm.bak
 create mode 100644 cookbooks/burnman/doc/formulation_ica.part.prm.bak
 create mode 100644 cookbooks/burnman/doc/gravity_model.part.prm.bak
 create mode 100644 cookbooks/burnman/doc/material_model.part.prm.bak
 create mode 100644 cookbooks/burnman/doc/tala.part.prm.bak
 create mode 100644 cookbooks/christensen_yuen_phase_function/christensen_yuen_phase_function.prm.bak
 create mode 100644 cookbooks/christensen_yuen_phase_function/doc/material.part.prm.bak
 create mode 100644 cookbooks/composition-reaction/composition-reaction.prm.bak
 create mode 100644 cookbooks/composition-reaction/doc/initial.part.prm.bak
 create mode 100644 cookbooks/composition-reaction/doc/material.part.prm.bak
 create mode 100644 cookbooks/composition_active/composition_active.prm.bak
 create mode 100644 cookbooks/composition_active/doc/active.part.prm.bak
 create mode 100644 cookbooks/composition_active/doc/postprocess.part.prm.bak
 create mode 100644 cookbooks/composition_active_particles/composition_active_particles.prm.bak
 create mode 100644 cookbooks/composition_active_particles/doc/composition.part.prm.bak
 create mode 100644 cookbooks/composition_active_particles/doc/particles.part.prm.bak
 create mode 100644 cookbooks/composition_passive/composition_passive.prm.bak
 create mode 100644 cookbooks/composition_passive/doc/passive.part.prm.bak
 create mode 100644 cookbooks/composition_passive/doc/postprocess.part.prm.bak
 create mode 100644 cookbooks/composition_passive_particles/composition_passive_particles.prm.bak
 create mode 100644 cookbooks/composition_passive_particles/composition_passive_particles_properties.prm.bak
 create mode 100644 cookbooks/composition_passive_particles/doc/particle-properties.part.prm.bak
 create mode 100644 cookbooks/composition_passive_particles/doc/particles.part.prm.bak
 create mode 100644 cookbooks/continental_extension/continental_extension.prm.bak
 create mode 100644 cookbooks/continental_extension/doc/continental_extension_boundary_conditions.prm.bak
 create mode 100644 cookbooks/continental_extension/doc/continental_extension_composition.prm.bak
 create mode 100644 cookbooks/continental_extension/doc/continental_extension_geometry_mesh.prm.bak
 create mode 100644 cookbooks/continental_extension/doc/continental_extension_material_model.prm.bak
 create mode 100644 cookbooks/convection-box-particles/convection-box-particles.prm.bak
 create mode 100644 cookbooks/convection-box/convection-box.prm.bak
 create mode 100644 cookbooks/convection-box/doc/disc.part.prm.bak
 create mode 100644 cookbooks/convection-box/doc/gravity.part.prm.bak
 create mode 100644 cookbooks/convection-box/doc/refine.part.prm.bak
 create mode 100644 cookbooks/convection-box/doc/refine2.part.prm.bak
 create mode 100644 cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box.prm.bak
 create mode 100644 cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box2.prm.bak
 create mode 100644 cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm.bak
 create mode 100644 cookbooks/convection_box_3d/convection_box_3d.prm.bak
 create mode 100644 cookbooks/convection_box_3d/doc/amr.part.prm.bak
 create mode 100644 cookbooks/convection_box_3d/doc/checkpoint.part.prm.bak
 create mode 100644 cookbooks/convection_box_3d/doc/gravity.part.prm.bak
 create mode 100644 cookbooks/convection_box_3d/doc/initial.part.prm.bak
 create mode 100644 cookbooks/convection_box_3d/doc/postprocess.part.prm.bak
 create mode 100644 cookbooks/convection_box_3d/doc/start.part.prm.bak
 create mode 100644 cookbooks/crustal_deformation/crustal_model_2D.prm.bak
 create mode 100644 cookbooks/crustal_deformation/crustal_model_3D.prm.bak
 create mode 100644 cookbooks/crustal_deformation/doc/crustal_model_2D_part1.prm.bak
 create mode 100644 cookbooks/crustal_deformation/doc/crustal_model_2D_part2.prm.bak
 create mode 100644 cookbooks/crustal_deformation/doc/crustal_model_2D_part3.prm.bak
 create mode 100644 cookbooks/crustal_deformation/doc/crustal_model_2D_part4.prm.bak
 create mode 100644 cookbooks/crustal_deformation/doc/crustal_model_3D_part1.prm.bak
 create mode 100644 cookbooks/fastscape_eroding_box/fastscape_eroding_box.prm.bak
 create mode 100644 cookbooks/finite_strain/doc/finite_strain.part.prm.bak
 create mode 100644 cookbooks/finite_strain/finite_strain.cc.bak
 create mode 100644 cookbooks/finite_strain/finite_strain.prm.bak
 create mode 100644 cookbooks/free_surface/doc/free_surface.part.prm.bak
 create mode 100644 cookbooks/free_surface/free_surface.prm.bak
 create mode 100644 cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part1.prm.bak
 create mode 100644 cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part2.prm.bak
 create mode 100644 cookbooks/free_surface_with_crust/free_surface_with_crust.prm.bak
 create mode 100644 cookbooks/free_surface_with_crust/plugin/simpler_with_crust.cc.bak
 create mode 100644 cookbooks/future/mantle_setup_restart.prm.bak
 create mode 100644 cookbooks/future/mantle_setup_start.prm.bak
 create mode 100644 cookbooks/future/net_rotation.prm.bak
 create mode 100644 cookbooks/future/periodic_box.prm.bak
 create mode 100644 cookbooks/future/radiogenic_heating.prm.bak
 create mode 100644 cookbooks/future/radiogenic_heating_function.prm.bak
 create mode 100644 cookbooks/future/sphere.prm.bak
 create mode 100644 cookbooks/geomio/doc/geomIO.prm.bak
 create mode 100644 cookbooks/geomio/geomIO.prm.bak
 create mode 100644 cookbooks/global_melt/doc/global_melt.prm.bak
 create mode 100644 cookbooks/global_melt/doc/global_no_melt.prm.bak
 create mode 100644 cookbooks/global_melt/global_melt.prm.bak
 create mode 100644 cookbooks/global_melt/global_no_melt.prm.bak
 create mode 100644 cookbooks/gplates/doc/gplates.part.prm.bak
 create mode 100644 cookbooks/gplates/doc/slice1.part.prm.bak
 create mode 100644 cookbooks/gplates/doc/slice2.part.prm.bak
 create mode 100644 cookbooks/gplates/gplates_2d.prm.bak
 create mode 100644 cookbooks/gplates/gplates_3d.prm.bak
 create mode 100644 cookbooks/grain_size_ridge/doc/fields.part.prm.bak
 create mode 100644 cookbooks/grain_size_ridge/doc/material_model.part.prm.bak
 create mode 100644 cookbooks/grain_size_ridge/doc/particles.part.prm.bak
 create mode 100644 cookbooks/grain_size_ridge/grain_size_ridge.prm.bak
 create mode 100644 cookbooks/heat_flow/heat-flow-plume.prm.bak
 create mode 100644 cookbooks/heat_flow/heat-flow-terms.prm.bak
 create mode 100644 cookbooks/heat_flow/heat-flow.prm.bak
 create mode 100644 cookbooks/inclusions/ellipse_pure_shear.prm.bak
 create mode 100644 cookbooks/inclusions/ellipse_pure_shear_nonlinear.prm.bak
 create mode 100644 cookbooks/inclusions/ellipse_ref.prm.bak
 create mode 100644 cookbooks/inclusions/ellipse_simple_shear.prm.bak
 create mode 100644 cookbooks/inclusions/rectangle_pure_shear.prm.bak
 create mode 100644 cookbooks/inclusions/rectangle_ref.prm.bak
 create mode 100644 cookbooks/inclusions/rectangle_simple_shear.prm.bak
 create mode 100644 cookbooks/initial-condition-S20RTS/S20RTS.prm.bak
 create mode 100644 cookbooks/initial-condition-S20RTS/doc/S20RTS.part.prm.bak
 create mode 100644 cookbooks/inner_core_convection/doc/inner_core_traction.part.1.prm.bak
 create mode 100644 cookbooks/inner_core_convection/doc/inner_core_traction.part.2.prm.bak
 create mode 100644 cookbooks/inner_core_convection/doc/inner_core_traction.part.3.prm.bak
 create mode 100644 cookbooks/inner_core_convection/inner_core_assembly.cc.bak
 create mode 100644 cookbooks/inner_core_convection/inner_core_convection.cc.bak
 create mode 100644 cookbooks/inner_core_convection/inner_core_traction.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.h.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_compositions.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_materialmodel.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_meshrefinement.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_velocity.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case2a_materialmodel.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case2a_temperatures.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case2b_materialmodel.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/isotherm_depth.h.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2b.prm.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.h.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/trench_location.cc.bak
 create mode 100644 cookbooks/kinematically_driven_subduction_2d/trench_location.h.bak
 create mode 100644 cookbooks/latent-heat/doc/material.part.prm.bak
 create mode 100644 cookbooks/latent-heat/latent-heat.prm.bak
 create mode 100644 cookbooks/lower_crustal_flow/lower_crustal_flow_obstacle.prm.bak
 create mode 100644 cookbooks/magnetic_stripes/magnetic_stripes.cc.bak
 create mode 100644 cookbooks/magnetic_stripes/magnetic_stripes.prm.bak
 create mode 100644 cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm.bak
 create mode 100644 cookbooks/mid_ocean_ridge/doc/boundary_conditions.part.prm.bak
 create mode 100644 cookbooks/mid_ocean_ridge/doc/compaction_length.part.prm.bak
 create mode 100644 cookbooks/mid_ocean_ridge/doc/melting_and_freezing.part.prm.bak
 create mode 100644 cookbooks/mid_ocean_ridge/doc/mesh_refinement.part.prm.bak
 create mode 100644 cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm.bak
 create mode 100644 cookbooks/morency_doin_2004/doc/morency_doin.part.prm.bak
 create mode 100644 cookbooks/morency_doin_2004/morency_doin.cc.bak
 create mode 100644 cookbooks/morency_doin_2004/morency_doin.h.bak
 create mode 100644 cookbooks/morency_doin_2004/morency_doin.prm.bak
 create mode 100644 cookbooks/multicomponent_steinberger/doc/comp.field.prm.bak
 create mode 100644 cookbooks/multicomponent_steinberger/doc/comp.setup.prm.bak
 create mode 100644 cookbooks/multicomponent_steinberger/doc/conductivity.setup.prm.bak
 create mode 100644 cookbooks/multicomponent_steinberger/doc/lookup.part.prm.bak
 create mode 100644 cookbooks/multicomponent_steinberger/doc/temperature.setup.prm.bak
 create mode 100644 cookbooks/multicomponent_steinberger/steinberger_thermochemical_plume.prm.bak
 create mode 100644 cookbooks/muparser_temperature_example/doc/check-initial-condition.part.prm.bak
 create mode 100644 cookbooks/muparser_temperature_example/doc/mesh-refinement.part.prm.bak
 create mode 100644 cookbooks/muparser_temperature_example/doc/repetitions.part.prm.bak
 create mode 100644 cookbooks/muparser_temperature_example/doc/temperature.part.prm.bak
 create mode 100644 cookbooks/muparser_temperature_example/muparser-temperature-example.prm.bak
 create mode 100644 cookbooks/onset_of_convection/onset_of_convection.prm.bak
 create mode 100644 cookbooks/platelike-boundary/doc/boundary.part.prm.bak
 create mode 100644 cookbooks/platelike-boundary/doc/platelike.prm.bak
 create mode 100644 cookbooks/platelike-boundary/platelike-boundary.prm.bak
 create mode 100644 cookbooks/plume_2D_chunk/opening_angle_45degrees.prm.bak
 create mode 100644 cookbooks/plume_2D_chunk/opening_angle_90degrees.prm.bak
 create mode 100644 cookbooks/plume_2D_chunk/plume2D.prm.bak
 create mode 100644 cookbooks/plume_2D_chunk/strongly_temperature_dependent.prm.bak
 create mode 100644 cookbooks/plume_2D_chunk/weakly_temperature_dependent.prm.bak
 create mode 100644 cookbooks/prescribed_velocity/circle.prm.bak
 create mode 100644 cookbooks/prescribed_velocity/corner_flow.prm.bak
 create mode 100644 cookbooks/prescribed_velocity/doc/minimal.prm.bak
 create mode 100644 cookbooks/prescribed_velocity/prescribed_velocity.cc.bak
 create mode 100644 cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.0.out.bak
 create mode 100644 cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.1.out.bak
 create mode 100644 cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.2.out.bak
 create mode 100644 cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.cc.bak
 create mode 100644 cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.prm.bak
 create mode 100644 cookbooks/shell_3d_postprocess/doc/shell_3d_postprocess.part.prm.bak
 create mode 100644 cookbooks/shell_3d_postprocess/shell_3d_postprocess.prm.bak
 create mode 100644 cookbooks/shell_simple_2d/doc/shearheat.part.prm.bak
 create mode 100644 cookbooks/shell_simple_2d/doc/shell.prm.bak
 create mode 100644 cookbooks/shell_simple_2d/shell_simple_2d.prm.bak
 create mode 100644 cookbooks/shell_simple_2d_smoothing/doc/shell_simple_2d_smoothing.part.prm.bak
 create mode 100644 cookbooks/shell_simple_2d_smoothing/shell_simple_2d_smoothing.prm.bak
 create mode 100644 cookbooks/shell_simple_3d/doc/amr.part.prm.bak
 create mode 100644 cookbooks/shell_simple_3d/doc/checkpoint.part.prm.bak
 create mode 100644 cookbooks/shell_simple_3d/doc/part1.part.prm.bak
 create mode 100644 cookbooks/shell_simple_3d/doc/part2.part.prm.bak
 create mode 100644 cookbooks/shell_simple_3d/doc/part3.part.prm.bak
 create mode 100644 cookbooks/shell_simple_3d/doc/part4.part.prm.bak
 create mode 100644 cookbooks/shell_simple_3d/doc/postprocess.part.prm.bak
 create mode 100644 cookbooks/shell_simple_3d/shell_simple_3d.prm.bak
 create mode 100644 cookbooks/sinker-with-averaging/doc/conservative.prm.bak
 create mode 100644 cookbooks/sinker-with-averaging/doc/full.prm.bak
 create mode 100644 cookbooks/sinker-with-averaging/doc/harmonic.prm.bak
 create mode 100644 cookbooks/sinker-with-averaging/sinker-with-averaging.prm.bak
 create mode 100644 cookbooks/steinberger/doc/geometry.part.prm.bak
 create mode 100644 cookbooks/steinberger/doc/lookup.part.prm.bak
 create mode 100644 cookbooks/steinberger/doc/nullspace.part.prm.bak
 create mode 100644 cookbooks/steinberger/doc/projected_density.part.prm.bak
 create mode 100644 cookbooks/steinberger/doc/rheology.part.prm.bak
 create mode 100644 cookbooks/steinberger/doc/rheology2.part.prm.bak
 create mode 100644 cookbooks/steinberger/steinberger.prm.bak
 create mode 100644 cookbooks/stokes/doc/stokeslaw.prm.bak
 create mode 100644 cookbooks/stokes/stokes.prm.bak
 create mode 100644 cookbooks/subduction_initiation/subduction_initiation.prm.base.bak
 create mode 100644 cookbooks/subduction_initiation/subduction_initiation_compositional_fields.prm.bak
 create mode 100644 cookbooks/subduction_initiation/subduction_initiation_particle_in_cell.prm.bak
 create mode 100644 cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
 create mode 100644 cookbooks/tian_parameterization_kinematic_slab/uncoupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
 create mode 100644 cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm.bak
 create mode 100644 cookbooks/tomography_based_plate_motions/doc/tomography_based_plate_motions.part.prm.bak
 create mode 100644 cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc.bak
 create mode 100644 cookbooks/tomography_based_plate_motions/plugins/reference_profile.h.bak
 create mode 100644 cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc.bak
 create mode 100644 cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.h.bak
 create mode 100644 cookbooks/transform_fault_behn_2007/doc/material.part.prm.bak
 create mode 100644 cookbooks/transform_fault_behn_2007/doc/temperature.part.prm.bak
 create mode 100644 cookbooks/transform_fault_behn_2007/temperature_dependent.prm.bak
 create mode 100644 cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm.bak
 create mode 100644 cookbooks/van-keken-vof/doc/amr.part.prm.bak
 create mode 100644 cookbooks/van-keken-vof/doc/main.part.prm.bak
 create mode 100644 cookbooks/van-keken-vof/doc/postprocess.part.prm.bak
 create mode 100644 cookbooks/van-keken-vof/doc/variation.part.prm.bak
 create mode 100644 cookbooks/van-keken-vof/van-keken-vof.prm.bak
 create mode 100644 cookbooks/van-keken/doc/main.part.prm.bak
 create mode 100644 cookbooks/van-keken/doc/postprocess.part.prm.bak
 create mode 100644 cookbooks/van-keken/doc/smooth.part.prm.bak
 create mode 100644 cookbooks/van-keken/van-keken-discontinuous.prm.bak
 create mode 100644 cookbooks/van-keken/van-keken-smooth.prm.bak
 create mode 100644 cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc.bak
 create mode 100644 cookbooks/vankeken_subduction/vankeken_corner_flow.prm.bak
 create mode 100644 cookbooks/visualizing_phase_diagram/doc/harzburgite.prm.bak
 create mode 100644 cookbooks/visualizing_phase_diagram/doc/material_model.prm.bak
 create mode 100644 cookbooks/visualizing_phase_diagram/doc/steinberg.prm.bak
 create mode 100644 cookbooks/visualizing_phase_diagram/visualizing_phase_diagram.prm.bak
 create mode 100644 doc/logo/logo.prm.bak
 create mode 100644 doc/manual/cookbooks/overview/doc/boundary-conditions.part.prm.bak
 create mode 100644 doc/manual/cookbooks/overview/doc/dim.part.prm.bak
 create mode 100644 doc/manual/cookbooks/overview/doc/geometry.part.prm.bak
 create mode 100644 doc/manual/cookbooks/overview/doc/gmg-average.part.prm.bak
 create mode 100644 doc/manual/cookbooks/overview/doc/gmg-enable.part.prm.bak
 create mode 100644 doc/manual/cookbooks/overview/doc/simple.prm.bak
 create mode 100644 doc/manual/cookbooks/overview/doc/structure.part.prm.bak
 create mode 100644 doc/manual/empty.prm.bak
 create mode 100644 include/aspect/adiabatic_conditions/ascii_data.h.bak
 create mode 100644 include/aspect/adiabatic_conditions/compute_entropy_profile.h.bak
 create mode 100644 include/aspect/adiabatic_conditions/compute_profile.h.bak
 create mode 100644 include/aspect/adiabatic_conditions/function.h.bak
 create mode 100644 include/aspect/adiabatic_conditions/interface.h.bak
 create mode 100644 include/aspect/boundary_composition/ascii_data.h.bak
 create mode 100644 include/aspect/boundary_composition/box.h.bak
 create mode 100644 include/aspect/boundary_composition/function.h.bak
 create mode 100644 include/aspect/boundary_composition/initial_composition.h.bak
 create mode 100644 include/aspect/boundary_composition/interface.h.bak
 create mode 100644 include/aspect/boundary_composition/spherical_constant.h.bak
 create mode 100644 include/aspect/boundary_composition/two_merged_boxes.h.bak
 create mode 100644 include/aspect/boundary_fluid_pressure/density.h.bak
 create mode 100644 include/aspect/boundary_fluid_pressure/interface.h.bak
 create mode 100644 include/aspect/boundary_heat_flux/function.h.bak
 create mode 100644 include/aspect/boundary_heat_flux/interface.h.bak
 create mode 100644 include/aspect/boundary_temperature/ascii_data.h.bak
 create mode 100644 include/aspect/boundary_temperature/box.h.bak
 create mode 100644 include/aspect/boundary_temperature/constant.h.bak
 create mode 100644 include/aspect/boundary_temperature/dynamic_core.h.bak
 create mode 100644 include/aspect/boundary_temperature/function.h.bak
 create mode 100644 include/aspect/boundary_temperature/initial_temperature.h.bak
 create mode 100644 include/aspect/boundary_temperature/interface.h.bak
 create mode 100644 include/aspect/boundary_temperature/spherical_constant.h.bak
 create mode 100644 include/aspect/boundary_temperature/two_merged_boxes.h.bak
 create mode 100644 include/aspect/boundary_traction/ascii_data.h.bak
 create mode 100644 include/aspect/boundary_traction/function.h.bak
 create mode 100644 include/aspect/boundary_traction/initial_lithostatic_pressure.h.bak
 create mode 100644 include/aspect/boundary_traction/interface.h.bak
 create mode 100644 include/aspect/boundary_traction/zero_traction.h.bak
 create mode 100644 include/aspect/boundary_velocity/ascii_data.h.bak
 create mode 100644 include/aspect/boundary_velocity/function.h.bak
 create mode 100644 include/aspect/boundary_velocity/gplates.h.bak
 create mode 100644 include/aspect/boundary_velocity/interface.h.bak
 create mode 100644 include/aspect/boundary_velocity/zero_velocity.h.bak
 create mode 100644 include/aspect/citation_info.h.bak
 create mode 100644 include/aspect/compat.h.bak
 create mode 100644 include/aspect/coordinate_systems.h.bak
 create mode 100644 include/aspect/fe_variable_collection.h.bak
 create mode 100644 include/aspect/geometry_model/box.h.bak
 create mode 100644 include/aspect/geometry_model/chunk.h.bak
 create mode 100644 include/aspect/geometry_model/ellipsoidal_chunk.h.bak
 create mode 100644 include/aspect/geometry_model/initial_topography_model/ascii_data.h.bak
 create mode 100644 include/aspect/geometry_model/initial_topography_model/function.h.bak
 create mode 100644 include/aspect/geometry_model/initial_topography_model/interface.h.bak
 create mode 100644 include/aspect/geometry_model/initial_topography_model/prm_polygon.h.bak
 create mode 100644 include/aspect/geometry_model/initial_topography_model/zero_topography.h.bak
 create mode 100644 include/aspect/geometry_model/interface.h.bak
 create mode 100644 include/aspect/geometry_model/sphere.h.bak
 create mode 100644 include/aspect/geometry_model/spherical_shell.h.bak
 create mode 100644 include/aspect/geometry_model/two_merged_boxes.h.bak
 create mode 100644 include/aspect/geometry_model/two_merged_chunks.h.bak
 create mode 100644 include/aspect/global.h.bak
 create mode 100644 include/aspect/gravity_model/ascii_data.h.bak
 create mode 100644 include/aspect/gravity_model/function.h.bak
 create mode 100644 include/aspect/gravity_model/interface.h.bak
 create mode 100644 include/aspect/gravity_model/radial.h.bak
 create mode 100644 include/aspect/gravity_model/vertical.h.bak
 create mode 100644 include/aspect/heating_model/adiabatic_heating.h.bak
 create mode 100644 include/aspect/heating_model/adiabatic_heating_of_melt.h.bak
 create mode 100644 include/aspect/heating_model/compositional_heating.h.bak
 create mode 100644 include/aspect/heating_model/constant_heating.h.bak
 create mode 100644 include/aspect/heating_model/function.h.bak
 create mode 100644 include/aspect/heating_model/interface.h.bak
 create mode 100644 include/aspect/heating_model/latent_heat.h.bak
 create mode 100644 include/aspect/heating_model/latent_heat_melt.h.bak
 create mode 100644 include/aspect/heating_model/radioactive_decay.h.bak
 create mode 100644 include/aspect/heating_model/shear_heating.h.bak
 create mode 100644 include/aspect/heating_model/shear_heating_with_melt.h.bak
 create mode 100644 include/aspect/initial_composition/adiabatic_density.h.bak
 create mode 100644 include/aspect/initial_composition/ascii_data.h.bak
 create mode 100644 include/aspect/initial_composition/ascii_data_layered.h.bak
 create mode 100644 include/aspect/initial_composition/entropy_table_lookup.h.bak
 create mode 100644 include/aspect/initial_composition/function.h.bak
 create mode 100644 include/aspect/initial_composition/interface.h.bak
 create mode 100644 include/aspect/initial_composition/porosity.h.bak
 create mode 100644 include/aspect/initial_composition/slab_model.h.bak
 create mode 100644 include/aspect/initial_composition/world_builder.h.bak
 create mode 100644 include/aspect/initial_temperature/S40RTS_perturbation.h.bak
 create mode 100644 include/aspect/initial_temperature/SAVANI_perturbation.h.bak
 create mode 100644 include/aspect/initial_temperature/adiabatic.h.bak
 create mode 100644 include/aspect/initial_temperature/adiabatic_boundary.h.bak
 create mode 100644 include/aspect/initial_temperature/ascii_data.h.bak
 create mode 100644 include/aspect/initial_temperature/ascii_data_layered.h.bak
 create mode 100644 include/aspect/initial_temperature/ascii_profile.h.bak
 create mode 100644 include/aspect/initial_temperature/box.h.bak
 create mode 100644 include/aspect/initial_temperature/continental_geotherm.h.bak
 create mode 100644 include/aspect/initial_temperature/function.h.bak
 create mode 100644 include/aspect/initial_temperature/harmonic_perturbation.h.bak
 create mode 100644 include/aspect/initial_temperature/interface.h.bak
 create mode 100644 include/aspect/initial_temperature/lithosphere_mask.h.bak
 create mode 100644 include/aspect/initial_temperature/patch_on_S40RTS.h.bak
 create mode 100644 include/aspect/initial_temperature/prescribed_temperature.h.bak
 create mode 100644 include/aspect/initial_temperature/random_gaussian_perturbation.h.bak
 create mode 100644 include/aspect/initial_temperature/spherical_shell.h.bak
 create mode 100644 include/aspect/initial_temperature/world_builder.h.bak
 create mode 100644 include/aspect/introspection.h.bak
 create mode 100644 include/aspect/lateral_averaging.h.bak
 create mode 100644 include/aspect/material_model/ascii_reference_profile.h.bak
 create mode 100644 include/aspect/material_model/averaging.h.bak
 create mode 100644 include/aspect/material_model/compositing.h.bak
 create mode 100644 include/aspect/material_model/composition_reaction.h.bak
 create mode 100644 include/aspect/material_model/depth_dependent.h.bak
 create mode 100644 include/aspect/material_model/diffusion_dislocation.h.bak
 create mode 100644 include/aspect/material_model/drucker_prager.h.bak
 create mode 100644 include/aspect/material_model/entropy_model.h.bak
 create mode 100644 include/aspect/material_model/equation_of_state/interface.h.bak
 create mode 100644 include/aspect/material_model/equation_of_state/linearized_incompressible.h.bak
 create mode 100644 include/aspect/material_model/equation_of_state/multicomponent_compressible.h.bak
 create mode 100644 include/aspect/material_model/equation_of_state/multicomponent_incompressible.h.bak
 create mode 100644 include/aspect/material_model/equation_of_state/thermodynamic_table_lookup.h.bak
 create mode 100644 include/aspect/material_model/grain_size.h.bak
 create mode 100644 include/aspect/material_model/interface.h.bak
 create mode 100644 include/aspect/material_model/latent_heat.h.bak
 create mode 100644 include/aspect/material_model/latent_heat_melt.h.bak
 create mode 100644 include/aspect/material_model/melt_boukare.h.bak
 create mode 100644 include/aspect/material_model/melt_global.h.bak
 create mode 100644 include/aspect/material_model/melt_simple.h.bak
 create mode 100644 include/aspect/material_model/modified_tait.h.bak
 create mode 100644 include/aspect/material_model/multicomponent.h.bak
 create mode 100644 include/aspect/material_model/multicomponent_compressible.h.bak
 create mode 100644 include/aspect/material_model/nondimensional.h.bak
 create mode 100644 include/aspect/material_model/perplex_lookup.h.bak
 create mode 100644 include/aspect/material_model/prescribed_viscosity.h.bak
 create mode 100644 include/aspect/material_model/reaction_model/katz2003_mantle_melting.h.bak
 create mode 100644 include/aspect/material_model/reactive_fluid_transport.h.bak
 create mode 100644 include/aspect/material_model/replace_lithosphere_viscosity.h.bak
 create mode 100644 include/aspect/material_model/rheology/ascii_depth_profile.h.bak
 create mode 100644 include/aspect/material_model/rheology/composite_visco_plastic.h.bak
 create mode 100644 include/aspect/material_model/rheology/compositional_viscosity_prefactors.h.bak
 create mode 100644 include/aspect/material_model/rheology/constant_viscosity.h.bak
 create mode 100644 include/aspect/material_model/rheology/constant_viscosity_prefactors.h.bak
 create mode 100644 include/aspect/material_model/rheology/diffusion_creep.h.bak
 create mode 100644 include/aspect/material_model/rheology/diffusion_dislocation.h.bak
 create mode 100644 include/aspect/material_model/rheology/dislocation_creep.h.bak
 create mode 100644 include/aspect/material_model/rheology/drucker_prager.h.bak
 create mode 100644 include/aspect/material_model/rheology/elasticity.h.bak
 create mode 100644 include/aspect/material_model/rheology/frank_kamenetskii.h.bak
 create mode 100644 include/aspect/material_model/rheology/friction_models.h.bak
 create mode 100644 include/aspect/material_model/rheology/peierls_creep.h.bak
 create mode 100644 include/aspect/material_model/rheology/strain_dependent.h.bak
 create mode 100644 include/aspect/material_model/rheology/visco_plastic.h.bak
 create mode 100644 include/aspect/material_model/simple.h.bak
 create mode 100644 include/aspect/material_model/simple_compressible.h.bak
 create mode 100644 include/aspect/material_model/simpler.h.bak
 create mode 100644 include/aspect/material_model/steinberger.h.bak
 create mode 100644 include/aspect/material_model/utilities.h.bak
 create mode 100644 include/aspect/material_model/visco_plastic.h.bak
 create mode 100644 include/aspect/material_model/viscoelastic.h.bak
 create mode 100644 include/aspect/melt.h.bak
 create mode 100644 include/aspect/mesh_deformation/ascii_data.h.bak
 create mode 100644 include/aspect/mesh_deformation/diffusion.h.bak
 create mode 100644 include/aspect/mesh_deformation/fastscape.h.bak
 create mode 100644 include/aspect/mesh_deformation/free_surface.h.bak
 create mode 100644 include/aspect/mesh_deformation/function.h.bak
 create mode 100644 include/aspect/mesh_deformation/interface.h.bak
 create mode 100644 include/aspect/mesh_refinement/artificial_viscosity.h.bak
 create mode 100644 include/aspect/mesh_refinement/boundary.h.bak
 create mode 100644 include/aspect/mesh_refinement/compaction_length.h.bak
 create mode 100644 include/aspect/mesh_refinement/composition.h.bak
 create mode 100644 include/aspect/mesh_refinement/composition_approximate_gradient.h.bak
 create mode 100644 include/aspect/mesh_refinement/composition_gradient.h.bak
 create mode 100644 include/aspect/mesh_refinement/composition_threshold.h.bak
 create mode 100644 include/aspect/mesh_refinement/density.h.bak
 create mode 100644 include/aspect/mesh_refinement/interface.h.bak
 create mode 100644 include/aspect/mesh_refinement/isosurfaces.h.bak
 create mode 100644 include/aspect/mesh_refinement/maximum_refinement_function.h.bak
 create mode 100644 include/aspect/mesh_refinement/minimum_refinement_function.h.bak
 create mode 100644 include/aspect/mesh_refinement/nonadiabatic_temperature.h.bak
 create mode 100644 include/aspect/mesh_refinement/nonadiabatic_temperature_threshold.h.bak
 create mode 100644 include/aspect/mesh_refinement/particle_density.h.bak
 create mode 100644 include/aspect/mesh_refinement/slope.h.bak
 create mode 100644 include/aspect/mesh_refinement/strain_rate.h.bak
 create mode 100644 include/aspect/mesh_refinement/temperature.h.bak
 create mode 100644 include/aspect/mesh_refinement/thermal_energy_density.h.bak
 create mode 100644 include/aspect/mesh_refinement/topography.h.bak
 create mode 100644 include/aspect/mesh_refinement/velocity.h.bak
 create mode 100644 include/aspect/mesh_refinement/viscosity.h.bak
 create mode 100644 include/aspect/mesh_refinement/volume_of_fluid_interface.h.bak
 create mode 100644 include/aspect/newton.h.bak
 create mode 100644 include/aspect/parameters.h.bak
 create mode 100644 include/aspect/particle/generator/ascii_file.h.bak
 create mode 100644 include/aspect/particle/generator/interface.h.bak
 create mode 100644 include/aspect/particle/generator/probability_density_function.h.bak
 create mode 100644 include/aspect/particle/generator/quadrature_points.h.bak
 create mode 100644 include/aspect/particle/generator/random_uniform.h.bak
 create mode 100644 include/aspect/particle/generator/reference_cell.h.bak
 create mode 100644 include/aspect/particle/generator/uniform_box.h.bak
 create mode 100644 include/aspect/particle/generator/uniform_radial.h.bak
 create mode 100644 include/aspect/particle/integrator/euler.h.bak
 create mode 100644 include/aspect/particle/integrator/interface.h.bak
 create mode 100644 include/aspect/particle/integrator/rk_2.h.bak
 create mode 100644 include/aspect/particle/integrator/rk_4.h.bak
 create mode 100644 include/aspect/particle/interface.h.bak
 create mode 100644 include/aspect/particle/interpolator/bilinear_least_squares.h.bak
 create mode 100644 include/aspect/particle/interpolator/cell_average.h.bak
 create mode 100644 include/aspect/particle/interpolator/harmonic_average.h.bak
 create mode 100644 include/aspect/particle/interpolator/interface.h.bak
 create mode 100644 include/aspect/particle/interpolator/nearest_neighbor.h.bak
 create mode 100644 include/aspect/particle/interpolator/quadratic_least_squares.h.bak
 create mode 100644 include/aspect/particle/property/composition.h.bak
 create mode 100644 include/aspect/particle/property/cpo_bingham_average.h.bak
 create mode 100644 include/aspect/particle/property/cpo_elastic_tensor.h.bak
 create mode 100644 include/aspect/particle/property/crystal_preferred_orientation.h.bak
 create mode 100644 include/aspect/particle/property/elastic_stress.h.bak
 create mode 100644 include/aspect/particle/property/elastic_tensor_decomposition.h.bak
 create mode 100644 include/aspect/particle/property/function.h.bak
 create mode 100644 include/aspect/particle/property/grain_size.h.bak
 create mode 100644 include/aspect/particle/property/initial_composition.h.bak
 create mode 100644 include/aspect/particle/property/initial_position.h.bak
 create mode 100644 include/aspect/particle/property/integrated_strain.h.bak
 create mode 100644 include/aspect/particle/property/integrated_strain_invariant.h.bak
 create mode 100644 include/aspect/particle/property/interface.h.bak
 create mode 100644 include/aspect/particle/property/melt_particle.h.bak
 create mode 100644 include/aspect/particle/property/pT_path.h.bak
 create mode 100644 include/aspect/particle/property/position.h.bak
 create mode 100644 include/aspect/particle/property/reference_position.h.bak
 create mode 100644 include/aspect/particle/property/strain_rate.h.bak
 create mode 100644 include/aspect/particle/property/velocity.h.bak
 create mode 100644 include/aspect/particle/property/viscoplastic_strain_invariants.h.bak
 create mode 100644 include/aspect/particle/world.h.bak
 create mode 100644 include/aspect/plugins.h.bak
 create mode 100644 include/aspect/postprocess/ODE_statistics.h.bak
 create mode 100644 include/aspect/postprocess/basic_statistics.h.bak
 create mode 100644 include/aspect/postprocess/boundary_densities.h.bak
 create mode 100644 include/aspect/postprocess/boundary_pressures.h.bak
 create mode 100644 include/aspect/postprocess/boundary_strain_rate_residual_statistics.h.bak
 create mode 100644 include/aspect/postprocess/boundary_velocity_residual_statistics.h.bak
 create mode 100644 include/aspect/postprocess/command.h.bak
 create mode 100644 include/aspect/postprocess/composition_statistics.h.bak
 create mode 100644 include/aspect/postprocess/composition_velocity_statistics.h.bak
 create mode 100644 include/aspect/postprocess/core_statistics.h.bak
 create mode 100644 include/aspect/postprocess/crystal_preferred_orientation.h.bak
 create mode 100644 include/aspect/postprocess/depth_average.h.bak
 create mode 100644 include/aspect/postprocess/domain_volume_statistics.h.bak
 create mode 100644 include/aspect/postprocess/dynamic_topography.h.bak
 create mode 100644 include/aspect/postprocess/entropy_viscosity_statistics.h.bak
 create mode 100644 include/aspect/postprocess/geoid.h.bak
 create mode 100644 include/aspect/postprocess/global_statistics.h.bak
 create mode 100644 include/aspect/postprocess/gravity_point_values.h.bak
 create mode 100644 include/aspect/postprocess/heat_flux_densities.h.bak
 create mode 100644 include/aspect/postprocess/heat_flux_map.h.bak
 create mode 100644 include/aspect/postprocess/heat_flux_statistics.h.bak
 create mode 100644 include/aspect/postprocess/heating_statistics.h.bak
 create mode 100644 include/aspect/postprocess/interface.h.bak
 create mode 100644 include/aspect/postprocess/load_balance_statistics.h.bak
 create mode 100644 include/aspect/postprocess/mass_flux_statistics.h.bak
 create mode 100644 include/aspect/postprocess/material_statistics.h.bak
 create mode 100644 include/aspect/postprocess/matrix_statistics.h.bak
 create mode 100644 include/aspect/postprocess/max_depth_field.h.bak
 create mode 100644 include/aspect/postprocess/melt_statistics.h.bak
 create mode 100644 include/aspect/postprocess/memory_statistics.h.bak
 create mode 100644 include/aspect/postprocess/mobility_statistics.h.bak
 create mode 100644 include/aspect/postprocess/particle_count_statistics.h.bak
 create mode 100644 include/aspect/postprocess/particles.h.bak
 create mode 100644 include/aspect/postprocess/point_values.h.bak
 create mode 100644 include/aspect/postprocess/pressure_statistics.h.bak
 create mode 100644 include/aspect/postprocess/rotation_statistics.h.bak
 create mode 100644 include/aspect/postprocess/sea_level.h.bak
 create mode 100644 include/aspect/postprocess/spherical_velocity_statistics.h.bak
 create mode 100644 include/aspect/postprocess/stokes_residual.h.bak
 create mode 100644 include/aspect/postprocess/temperature_statistics.h.bak
 create mode 100644 include/aspect/postprocess/topography.h.bak
 create mode 100644 include/aspect/postprocess/velocity_boundary_statistics.h.bak
 create mode 100644 include/aspect/postprocess/velocity_statistics.h.bak
 create mode 100644 include/aspect/postprocess/viscous_dissipation_statistics.h.bak
 create mode 100644 include/aspect/postprocess/visualization.h.bak
 create mode 100644 include/aspect/postprocess/visualization/ISA_rotation_timescale.h.bak
 create mode 100644 include/aspect/postprocess/visualization/adiabat.h.bak
 create mode 100644 include/aspect/postprocess/visualization/artificial_viscosity.h.bak
 create mode 100644 include/aspect/postprocess/visualization/artificial_viscosity_composition.h.bak
 create mode 100644 include/aspect/postprocess/visualization/boundary_indicator.h.bak
 create mode 100644 include/aspect/postprocess/visualization/boundary_strain_rate_residual.h.bak
 create mode 100644 include/aspect/postprocess/visualization/boundary_velocity_residual.h.bak
 create mode 100644 include/aspect/postprocess/visualization/compositional_vector.h.bak
 create mode 100644 include/aspect/postprocess/visualization/depth.h.bak
 create mode 100644 include/aspect/postprocess/visualization/dynamic_topography.h.bak
 create mode 100644 include/aspect/postprocess/visualization/error_indicator.h.bak
 create mode 100644 include/aspect/postprocess/visualization/geoid.h.bak
 create mode 100644 include/aspect/postprocess/visualization/grain_lag_angle.h.bak
 create mode 100644 include/aspect/postprocess/visualization/gravity.h.bak
 create mode 100644 include/aspect/postprocess/visualization/heat_flux_map.h.bak
 create mode 100644 include/aspect/postprocess/visualization/heating.h.bak
 create mode 100644 include/aspect/postprocess/visualization/kxrcf_indicator.h.bak
 create mode 100644 include/aspect/postprocess/visualization/material_properties.h.bak
 create mode 100644 include/aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h.bak
 create mode 100644 include/aspect/postprocess/visualization/melt.h.bak
 create mode 100644 include/aspect/postprocess/visualization/melt_fraction.h.bak
 create mode 100644 include/aspect/postprocess/visualization/named_additional_outputs.h.bak
 create mode 100644 include/aspect/postprocess/visualization/nonadiabatic_pressure.h.bak
 create mode 100644 include/aspect/postprocess/visualization/nonadiabatic_temperature.h.bak
 create mode 100644 include/aspect/postprocess/visualization/particle_count.h.bak
 create mode 100644 include/aspect/postprocess/visualization/partition.h.bak
 create mode 100644 include/aspect/postprocess/visualization/principal_stress.h.bak
 create mode 100644 include/aspect/postprocess/visualization/seismic_anomalies.h.bak
 create mode 100644 include/aspect/postprocess/visualization/shear_stress.h.bak
 create mode 100644 include/aspect/postprocess/visualization/spd_factor.h.bak
 create mode 100644 include/aspect/postprocess/visualization/spherical_velocity_components.h.bak
 create mode 100644 include/aspect/postprocess/visualization/strain_rate.h.bak
 create mode 100644 include/aspect/postprocess/visualization/strain_rate_tensor.h.bak
 create mode 100644 include/aspect/postprocess/visualization/stress.h.bak
 create mode 100644 include/aspect/postprocess/visualization/stress_second_invariant.h.bak
 create mode 100644 include/aspect/postprocess/visualization/surface_dynamic_topography.h.bak
 create mode 100644 include/aspect/postprocess/visualization/surface_elevation.h.bak
 create mode 100644 include/aspect/postprocess/visualization/surface_strain_rate_tensor.h.bak
 create mode 100644 include/aspect/postprocess/visualization/surface_stress.h.bak
 create mode 100644 include/aspect/postprocess/visualization/temperature_anomaly.h.bak
 create mode 100644 include/aspect/postprocess/visualization/vertical_heat_flux.h.bak
 create mode 100644 include/aspect/postprocess/visualization/volume_of_fluid_values.h.bak
 create mode 100644 include/aspect/postprocess/visualization/volumetric_strain_rate.h.bak
 create mode 100644 include/aspect/postprocess/volume_of_fluid_statistics.h.bak
 create mode 100644 include/aspect/prescribed_stokes_solution/ascii_data.h.bak
 create mode 100644 include/aspect/prescribed_stokes_solution/circle.h.bak
 create mode 100644 include/aspect/prescribed_stokes_solution/function.h.bak
 create mode 100644 include/aspect/prescribed_stokes_solution/interface.h.bak
 create mode 100644 include/aspect/simulator.h.bak
 create mode 100644 include/aspect/simulator/assemblers/advection.h.bak
 create mode 100644 include/aspect/simulator/assemblers/interface.h.bak
 create mode 100644 include/aspect/simulator/assemblers/stokes.h.bak
 create mode 100644 include/aspect/simulator_access.h.bak
 create mode 100644 include/aspect/simulator_signals.h.bak
 create mode 100644 include/aspect/stokes_matrix_free.h.bak
 create mode 100644 include/aspect/structured_data.h.bak
 create mode 100644 include/aspect/termination_criteria/end_step.h.bak
 create mode 100644 include/aspect/termination_criteria/end_time.h.bak
 create mode 100644 include/aspect/termination_criteria/end_walltime.h.bak
 create mode 100644 include/aspect/termination_criteria/interface.h.bak
 create mode 100644 include/aspect/termination_criteria/steady_heat_flux.h.bak
 create mode 100644 include/aspect/termination_criteria/steady_rms_velocity.h.bak
 create mode 100644 include/aspect/termination_criteria/steady_temperature.h.bak
 create mode 100644 include/aspect/termination_criteria/user_request.h.bak
 create mode 100644 include/aspect/time_stepping/conduction_time_step.h.bak
 create mode 100644 include/aspect/time_stepping/convection_time_step.h.bak
 create mode 100644 include/aspect/time_stepping/function.h.bak
 create mode 100644 include/aspect/time_stepping/interface.h.bak
 create mode 100644 include/aspect/time_stepping/repeat_on_cutback.h.bak
 create mode 100644 include/aspect/utilities.h.bak
 create mode 100644 include/aspect/volume_of_fluid/assembly.h.bak
 create mode 100644 include/aspect/volume_of_fluid/field.h.bak
 create mode 100644 include/aspect/volume_of_fluid/handler.h.bak
 create mode 100644 include/aspect/volume_of_fluid/utilities.h.bak
 create mode 100644 source/adiabatic_conditions/ascii_data.cc.bak
 create mode 100644 source/adiabatic_conditions/compute_entropy_profile.cc.bak
 create mode 100644 source/adiabatic_conditions/compute_profile.cc.bak
 create mode 100644 source/adiabatic_conditions/function.cc.bak
 create mode 100644 source/adiabatic_conditions/interface.cc.bak
 create mode 100644 source/boundary_composition/ascii_data.cc.bak
 create mode 100644 source/boundary_composition/box.cc.bak
 create mode 100644 source/boundary_composition/function.cc.bak
 create mode 100644 source/boundary_composition/initial_composition.cc.bak
 create mode 100644 source/boundary_composition/interface.cc.bak
 create mode 100644 source/boundary_composition/spherical_constant.cc.bak
 create mode 100644 source/boundary_composition/two_merged_boxes.cc.bak
 create mode 100644 source/boundary_fluid_pressure/density.cc.bak
 create mode 100644 source/boundary_fluid_pressure/interface.cc.bak
 create mode 100644 source/boundary_heat_flux/function.cc.bak
 create mode 100644 source/boundary_heat_flux/interface.cc.bak
 create mode 100644 source/boundary_temperature/ascii_data.cc.bak
 create mode 100644 source/boundary_temperature/box.cc.bak
 create mode 100644 source/boundary_temperature/constant.cc.bak
 create mode 100644 source/boundary_temperature/dynamic_core.cc.bak
 create mode 100644 source/boundary_temperature/function.cc.bak
 create mode 100644 source/boundary_temperature/initial_temperature.cc.bak
 create mode 100644 source/boundary_temperature/interface.cc.bak
 create mode 100644 source/boundary_temperature/spherical_constant.cc.bak
 create mode 100644 source/boundary_temperature/two_merged_boxes.cc.bak
 create mode 100644 source/boundary_traction/ascii_data.cc.bak
 create mode 100644 source/boundary_traction/function.cc.bak
 create mode 100644 source/boundary_traction/initial_lithostatic_pressure.cc.bak
 create mode 100644 source/boundary_traction/interface.cc.bak
 create mode 100644 source/boundary_traction/zero_traction.cc.bak
 create mode 100644 source/boundary_velocity/ascii_data.cc.bak
 create mode 100644 source/boundary_velocity/function.cc.bak
 create mode 100644 source/boundary_velocity/gplates.cc.bak
 create mode 100644 source/boundary_velocity/interface.cc.bak
 create mode 100644 source/boundary_velocity/zero_velocity.cc.bak
 create mode 100644 source/citation_info.cc.bak
 create mode 100644 source/compat.cc.bak
 create mode 100644 source/fe_variable_collection.cc.bak
 create mode 100644 source/geometry_model/box.cc.bak
 create mode 100644 source/geometry_model/chunk.cc.bak
 create mode 100644 source/geometry_model/ellipsoidal_chunk.cc.bak
 create mode 100644 source/geometry_model/initial_topography_model/ascii_data.cc.bak
 create mode 100644 source/geometry_model/initial_topography_model/function.cc.bak
 create mode 100644 source/geometry_model/initial_topography_model/interface.cc.bak
 create mode 100644 source/geometry_model/initial_topography_model/prm_polygon.cc.bak
 create mode 100644 source/geometry_model/initial_topography_model/zero_topography.cc.bak
 create mode 100644 source/geometry_model/interface.cc.bak
 create mode 100644 source/geometry_model/sphere.cc.bak
 create mode 100644 source/geometry_model/spherical_shell.cc.bak
 create mode 100644 source/geometry_model/two_merged_boxes.cc.bak
 create mode 100644 source/geometry_model/two_merged_chunks.cc.bak
 create mode 100644 source/global.cc.bak
 create mode 100644 source/gravity_model/ascii_data.cc.bak
 create mode 100644 source/gravity_model/function.cc.bak
 create mode 100644 source/gravity_model/interface.cc.bak
 create mode 100644 source/gravity_model/radial.cc.bak
 create mode 100644 source/gravity_model/vertical.cc.bak
 create mode 100644 source/heating_model/adiabatic_heating.cc.bak
 create mode 100644 source/heating_model/adiabatic_heating_of_melt.cc.bak
 create mode 100644 source/heating_model/compositional_heating.cc.bak
 create mode 100644 source/heating_model/constant_heating.cc.bak
 create mode 100644 source/heating_model/function.cc.bak
 create mode 100644 source/heating_model/interface.cc.bak
 create mode 100644 source/heating_model/latent_heat.cc.bak
 create mode 100644 source/heating_model/latent_heat_melt.cc.bak
 create mode 100644 source/heating_model/radioactive_decay.cc.bak
 create mode 100644 source/heating_model/shear_heating.cc.bak
 create mode 100644 source/heating_model/shear_heating_with_melt.cc.bak
 create mode 100644 source/initial_composition/adiabatic_density.cc.bak
 create mode 100644 source/initial_composition/ascii_data.cc.bak
 create mode 100644 source/initial_composition/ascii_data_layered.cc.bak
 create mode 100644 source/initial_composition/entropy_table_lookup.cc.bak
 create mode 100644 source/initial_composition/function.cc.bak
 create mode 100644 source/initial_composition/interface.cc.bak
 create mode 100644 source/initial_composition/porosity.cc.bak
 create mode 100644 source/initial_composition/slab_model.cc.bak
 create mode 100644 source/initial_composition/world_builder.cc.bak
 create mode 100644 source/initial_temperature/S40RTS_perturbation.cc.bak
 create mode 100644 source/initial_temperature/SAVANI_perturbation.cc.bak
 create mode 100644 source/initial_temperature/adiabatic.cc.bak
 create mode 100644 source/initial_temperature/adiabatic_boundary.cc.bak
 create mode 100644 source/initial_temperature/ascii_data.cc.bak
 create mode 100644 source/initial_temperature/ascii_data_layered.cc.bak
 create mode 100644 source/initial_temperature/ascii_profile.cc.bak
 create mode 100644 source/initial_temperature/box.cc.bak
 create mode 100644 source/initial_temperature/continental_geotherm.cc.bak
 create mode 100644 source/initial_temperature/function.cc.bak
 create mode 100644 source/initial_temperature/harmonic_perturbation.cc.bak
 create mode 100644 source/initial_temperature/interface.cc.bak
 create mode 100644 source/initial_temperature/lithosphere_mask.cc.bak
 create mode 100644 source/initial_temperature/patch_on_S40RTS.cc.bak
 create mode 100644 source/initial_temperature/prescribed_temperature.cc.bak
 create mode 100644 source/initial_temperature/random_gaussian_perturbation.cc.bak
 create mode 100644 source/initial_temperature/spherical_shell.cc.bak
 create mode 100644 source/initial_temperature/world_builder.cc.bak
 create mode 100644 source/main.cc.bak
 create mode 100644 source/material_model/ascii_reference_profile.cc.bak
 create mode 100644 source/material_model/averaging.cc.bak
 create mode 100644 source/material_model/compositing.cc.bak
 create mode 100644 source/material_model/composition_reaction.cc.bak
 create mode 100644 source/material_model/depth_dependent.cc.bak
 create mode 100644 source/material_model/diffusion_dislocation.cc.bak
 create mode 100644 source/material_model/drucker_prager.cc.bak
 create mode 100644 source/material_model/entropy_model.cc.bak
 create mode 100644 source/material_model/equation_of_state/interface.cc.bak
 create mode 100644 source/material_model/equation_of_state/linearized_incompressible.cc.bak
 create mode 100644 source/material_model/equation_of_state/multicomponent_compressible.cc.bak
 create mode 100644 source/material_model/equation_of_state/multicomponent_incompressible.cc.bak
 create mode 100644 source/material_model/equation_of_state/thermodynamic_table_lookup.cc.bak
 create mode 100644 source/material_model/grain_size.cc.bak
 create mode 100644 source/material_model/interface.cc.bak
 create mode 100644 source/material_model/latent_heat.cc.bak
 create mode 100644 source/material_model/latent_heat_melt.cc.bak
 create mode 100644 source/material_model/melt_boukare.cc.bak
 create mode 100644 source/material_model/melt_global.cc.bak
 create mode 100644 source/material_model/melt_simple.cc.bak
 create mode 100644 source/material_model/modified_tait.cc.bak
 create mode 100644 source/material_model/multicomponent.cc.bak
 create mode 100644 source/material_model/multicomponent_compressible.cc.bak
 create mode 100644 source/material_model/nondimensional.cc.bak
 create mode 100644 source/material_model/perplex_lookup.cc.bak
 create mode 100644 source/material_model/prescribed_viscosity.cc.bak
 create mode 100644 source/material_model/reaction_model/katz2003_mantle_melting.cc.bak
 create mode 100644 source/material_model/reactive_fluid_transport.cc.bak
 create mode 100644 source/material_model/replace_lithosphere_viscosity.cc.bak
 create mode 100644 source/material_model/rheology/ascii_depth_profile.cc.bak
 create mode 100644 source/material_model/rheology/composite_visco_plastic.cc.bak
 create mode 100644 source/material_model/rheology/compositional_viscosity_prefactors.cc.bak
 create mode 100644 source/material_model/rheology/constant_viscosity.cc.bak
 create mode 100644 source/material_model/rheology/constant_viscosity_prefactors.cc.bak
 create mode 100644 source/material_model/rheology/diffusion_creep.cc.bak
 create mode 100644 source/material_model/rheology/diffusion_dislocation.cc.bak
 create mode 100644 source/material_model/rheology/dislocation_creep.cc.bak
 create mode 100644 source/material_model/rheology/drucker_prager.cc.bak
 create mode 100644 source/material_model/rheology/elasticity.cc.bak
 create mode 100644 source/material_model/rheology/frank_kamenetskii.cc.bak
 create mode 100644 source/material_model/rheology/friction_models.cc.bak
 create mode 100644 source/material_model/rheology/peierls_creep.cc.bak
 create mode 100644 source/material_model/rheology/strain_dependent.cc.bak
 create mode 100644 source/material_model/rheology/visco_plastic.cc.bak
 create mode 100644 source/material_model/simple.cc.bak
 create mode 100644 source/material_model/simple_compressible.cc.bak
 create mode 100644 source/material_model/simpler.cc.bak
 create mode 100644 source/material_model/steinberger.cc.bak
 create mode 100644 source/material_model/utilities.cc.bak
 create mode 100644 source/material_model/visco_plastic.cc.bak
 create mode 100644 source/material_model/viscoelastic.cc.bak
 create mode 100644 source/mesh_deformation/ascii_data.cc.bak
 create mode 100644 source/mesh_deformation/diffusion.cc.bak
 create mode 100644 source/mesh_deformation/fastscape.cc.bak
 create mode 100644 source/mesh_deformation/free_surface.cc.bak
 create mode 100644 source/mesh_deformation/function.cc.bak
 create mode 100644 source/mesh_deformation/interface.cc.bak
 create mode 100644 source/mesh_refinement/artificial_viscosity.cc.bak
 create mode 100644 source/mesh_refinement/boundary.cc.bak
 create mode 100644 source/mesh_refinement/compaction_length.cc.bak
 create mode 100644 source/mesh_refinement/composition.cc.bak
 create mode 100644 source/mesh_refinement/composition_approximate_gradient.cc.bak
 create mode 100644 source/mesh_refinement/composition_gradient.cc.bak
 create mode 100644 source/mesh_refinement/composition_threshold.cc.bak
 create mode 100644 source/mesh_refinement/density.cc.bak
 create mode 100644 source/mesh_refinement/interface.cc.bak
 create mode 100644 source/mesh_refinement/isosurfaces.cc.bak
 create mode 100644 source/mesh_refinement/maximum_refinement_function.cc.bak
 create mode 100644 source/mesh_refinement/minimum_refinement_function.cc.bak
 create mode 100644 source/mesh_refinement/nonadiabatic_temperature.cc.bak
 create mode 100644 source/mesh_refinement/nonadiabatic_temperature_threshold.cc.bak
 create mode 100644 source/mesh_refinement/particle_density.cc.bak
 create mode 100644 source/mesh_refinement/slope.cc.bak
 create mode 100644 source/mesh_refinement/strain_rate.cc.bak
 create mode 100644 source/mesh_refinement/temperature.cc.bak
 create mode 100644 source/mesh_refinement/thermal_energy_density.cc.bak
 create mode 100644 source/mesh_refinement/topography.cc.bak
 create mode 100644 source/mesh_refinement/velocity.cc.bak
 create mode 100644 source/mesh_refinement/viscosity.cc.bak
 create mode 100644 source/mesh_refinement/volume_of_fluid_interface.cc.bak
 create mode 100644 source/particle/generator/ascii_file.cc.bak
 create mode 100644 source/particle/generator/interface.cc.bak
 create mode 100644 source/particle/generator/probability_density_function.cc.bak
 create mode 100644 source/particle/generator/quadrature_points.cc.bak
 create mode 100644 source/particle/generator/random_uniform.cc.bak
 create mode 100644 source/particle/generator/reference_cell.cc.bak
 create mode 100644 source/particle/generator/uniform_box.cc.bak
 create mode 100644 source/particle/generator/uniform_radial.cc.bak
 create mode 100644 source/particle/integrator/euler.cc.bak
 create mode 100644 source/particle/integrator/interface.cc.bak
 create mode 100644 source/particle/integrator/rk_2.cc.bak
 create mode 100644 source/particle/integrator/rk_4.cc.bak
 create mode 100644 source/particle/interface.cc.bak
 create mode 100644 source/particle/interpolator/bilinear_least_squares.cc.bak
 create mode 100644 source/particle/interpolator/cell_average.cc.bak
 create mode 100644 source/particle/interpolator/harmonic_average.cc.bak
 create mode 100644 source/particle/interpolator/interface.cc.bak
 create mode 100644 source/particle/interpolator/nearest_neighbor.cc.bak
 create mode 100644 source/particle/interpolator/quadratic_least_squares.cc.bak
 create mode 100644 source/particle/property/composition.cc.bak
 create mode 100644 source/particle/property/cpo_bingham_average.cc.bak
 create mode 100644 source/particle/property/cpo_elastic_tensor.cc.bak
 create mode 100644 source/particle/property/crystal_preferred_orientation.cc.bak
 create mode 100644 source/particle/property/elastic_stress.cc.bak
 create mode 100644 source/particle/property/elastic_tensor_decomposition.cc.bak
 create mode 100644 source/particle/property/function.cc.bak
 create mode 100644 source/particle/property/grain_size.cc.bak
 create mode 100644 source/particle/property/initial_composition.cc.bak
 create mode 100644 source/particle/property/initial_position.cc.bak
 create mode 100644 source/particle/property/integrated_strain.cc.bak
 create mode 100644 source/particle/property/integrated_strain_invariant.cc.bak
 create mode 100644 source/particle/property/interface.cc.bak
 create mode 100644 source/particle/property/melt_particle.cc.bak
 create mode 100644 source/particle/property/pT_path.cc.bak
 create mode 100644 source/particle/property/position.cc.bak
 create mode 100644 source/particle/property/reference_position.cc.bak
 create mode 100644 source/particle/property/strain_rate.cc.bak
 create mode 100644 source/particle/property/velocity.cc.bak
 create mode 100644 source/particle/property/viscoplastic_strain_invariants.cc.bak
 create mode 100644 source/particle/world.cc.bak
 create mode 100644 source/plugins.cc.bak
 create mode 100644 source/postprocess/ODE_statistics.cc.bak
 create mode 100644 source/postprocess/basic_statistics.cc.bak
 create mode 100644 source/postprocess/boundary_densities.cc.bak
 create mode 100644 source/postprocess/boundary_pressures.cc.bak
 create mode 100644 source/postprocess/boundary_strain_rate_residual_statistics.cc.bak
 create mode 100644 source/postprocess/boundary_velocity_residual_statistics.cc.bak
 create mode 100644 source/postprocess/command.cc.bak
 create mode 100644 source/postprocess/composition_statistics.cc.bak
 create mode 100644 source/postprocess/composition_velocity_statistics.cc.bak
 create mode 100644 source/postprocess/core_statistics.cc.bak
 create mode 100644 source/postprocess/crystal_preferred_orientation.cc.bak
 create mode 100644 source/postprocess/depth_average.cc.bak
 create mode 100644 source/postprocess/domain_volume_statistics.cc.bak
 create mode 100644 source/postprocess/dynamic_topography.cc.bak
 create mode 100644 source/postprocess/entropy_viscosity_statistics.cc.bak
 create mode 100644 source/postprocess/geoid.cc.bak
 create mode 100644 source/postprocess/global_statistics.cc.bak
 create mode 100644 source/postprocess/gravity_point_values.cc.bak
 create mode 100644 source/postprocess/heat_flux_densities.cc.bak
 create mode 100644 source/postprocess/heat_flux_map.cc.bak
 create mode 100644 source/postprocess/heat_flux_statistics.cc.bak
 create mode 100644 source/postprocess/heating_statistics.cc.bak
 create mode 100644 source/postprocess/interface.cc.bak
 create mode 100644 source/postprocess/load_balance_statistics.cc.bak
 create mode 100644 source/postprocess/mass_flux_statistics.cc.bak
 create mode 100644 source/postprocess/material_statistics.cc.bak
 create mode 100644 source/postprocess/matrix_statistics.cc.bak
 create mode 100644 source/postprocess/max_depth_field.cc.bak
 create mode 100644 source/postprocess/melt_statistics.cc.bak
 create mode 100644 source/postprocess/memory_statistics.cc.bak
 create mode 100644 source/postprocess/mobility_statistics.cc.bak
 create mode 100644 source/postprocess/particle_count_statistics.cc.bak
 create mode 100644 source/postprocess/particles.cc.bak
 create mode 100644 source/postprocess/point_values.cc.bak
 create mode 100644 source/postprocess/pressure_statistics.cc.bak
 create mode 100644 source/postprocess/rotation_statistics.cc.bak
 create mode 100644 source/postprocess/sea_level.cc.bak
 create mode 100644 source/postprocess/spherical_velocity_statistics.cc.bak
 create mode 100644 source/postprocess/stokes_residual.cc.bak
 create mode 100644 source/postprocess/temperature_statistics.cc.bak
 create mode 100644 source/postprocess/topography.cc.bak
 create mode 100644 source/postprocess/velocity_boundary_statistics.cc.bak
 create mode 100644 source/postprocess/velocity_statistics.cc.bak
 create mode 100644 source/postprocess/viscous_dissipation_statistics.cc.bak
 create mode 100644 source/postprocess/visualization.cc.bak
 create mode 100644 source/postprocess/visualization/ISA_rotation_timescale.cc.bak
 create mode 100644 source/postprocess/visualization/adiabat.cc.bak
 create mode 100644 source/postprocess/visualization/artificial_viscosity.cc.bak
 create mode 100644 source/postprocess/visualization/artificial_viscosity_composition.cc.bak
 create mode 100644 source/postprocess/visualization/boundary_indicator.cc.bak
 create mode 100644 source/postprocess/visualization/boundary_strain_rate_residual.cc.bak
 create mode 100644 source/postprocess/visualization/boundary_velocity_residual.cc.bak
 create mode 100644 source/postprocess/visualization/compositional_vector.cc.bak
 create mode 100644 source/postprocess/visualization/depth.cc.bak
 create mode 100644 source/postprocess/visualization/dynamic_topography.cc.bak
 create mode 100644 source/postprocess/visualization/error_indicator.cc.bak
 create mode 100644 source/postprocess/visualization/geoid.cc.bak
 create mode 100644 source/postprocess/visualization/grain_lag_angle.cc.bak
 create mode 100644 source/postprocess/visualization/gravity.cc.bak
 create mode 100644 source/postprocess/visualization/heat_flux_map.cc.bak
 create mode 100644 source/postprocess/visualization/heating.cc.bak
 create mode 100644 source/postprocess/visualization/kxrcf_indicator.cc.bak
 create mode 100644 source/postprocess/visualization/material_properties.cc.bak
 create mode 100644 source/postprocess/visualization/maximum_horizontal_compressive_stress.cc.bak
 create mode 100644 source/postprocess/visualization/melt.cc.bak
 create mode 100644 source/postprocess/visualization/melt_fraction.cc.bak
 create mode 100644 source/postprocess/visualization/named_additional_outputs.cc.bak
 create mode 100644 source/postprocess/visualization/nonadiabatic_pressure.cc.bak
 create mode 100644 source/postprocess/visualization/nonadiabatic_temperature.cc.bak
 create mode 100644 source/postprocess/visualization/particle_count.cc.bak
 create mode 100644 source/postprocess/visualization/partition.cc.bak
 create mode 100644 source/postprocess/visualization/principal_stress.cc.bak
 create mode 100644 source/postprocess/visualization/seismic_anomalies.cc.bak
 create mode 100644 source/postprocess/visualization/shear_stress.cc.bak
 create mode 100644 source/postprocess/visualization/spd_factor.cc.bak
 create mode 100644 source/postprocess/visualization/spherical_velocity_components.cc.bak
 create mode 100644 source/postprocess/visualization/strain_rate.cc.bak
 create mode 100644 source/postprocess/visualization/strain_rate_tensor.cc.bak
 create mode 100644 source/postprocess/visualization/stress.cc.bak
 create mode 100644 source/postprocess/visualization/stress_second_invariant.cc.bak
 create mode 100644 source/postprocess/visualization/surface_dynamic_topography.cc.bak
 create mode 100644 source/postprocess/visualization/surface_elevation.cc.bak
 create mode 100644 source/postprocess/visualization/surface_strain_rate_tensor.cc.bak
 create mode 100644 source/postprocess/visualization/surface_stress.cc.bak
 create mode 100644 source/postprocess/visualization/temperature_anomaly.cc.bak
 create mode 100644 source/postprocess/visualization/vertical_heat_flux.cc.bak
 create mode 100644 source/postprocess/visualization/volume_of_fluid_values.cc.bak
 create mode 100644 source/postprocess/visualization/volumetric_strain_rate.cc.bak
 create mode 100644 source/postprocess/volume_of_fluid_statistics.cc.bak
 create mode 100644 source/prescribed_stokes_solution/ascii_data.cc.bak
 create mode 100644 source/prescribed_stokes_solution/circle.cc.bak
 create mode 100644 source/prescribed_stokes_solution/function.cc.bak
 create mode 100644 source/prescribed_stokes_solution/interface.cc.bak
 create mode 100644 source/simulator/assemblers/advection.cc.bak
 create mode 100644 source/simulator/assemblers/interface.cc.bak
 create mode 100644 source/simulator/assemblers/newton_stokes.cc.bak
 create mode 100644 source/simulator/assemblers/stokes.cc.bak
 create mode 100644 source/simulator/assembly.cc.bak
 create mode 100644 source/simulator/checkpoint_restart.cc.bak
 create mode 100644 source/simulator/core.cc.bak
 create mode 100644 source/simulator/entropy_viscosity.cc.bak
 create mode 100644 source/simulator/helper_functions.cc.bak
 create mode 100644 source/simulator/initial_conditions.cc.bak
 create mode 100644 source/simulator/introspection.cc.bak
 create mode 100644 source/simulator/lateral_averaging.cc.bak
 create mode 100644 source/simulator/limiters.cc.bak
 create mode 100644 source/simulator/melt.cc.bak
 create mode 100644 source/simulator/newton.cc.bak
 create mode 100644 source/simulator/nullspace.cc.bak
 create mode 100644 source/simulator/parameters.cc.bak
 create mode 100644 source/simulator/simulator_access.cc.bak
 create mode 100644 source/simulator/simulator_signals.cc.bak
 create mode 100644 source/simulator/solver.cc.bak
 create mode 100644 source/simulator/solver_schemes.cc.bak
 create mode 100644 source/simulator/stokes_matrix_free.cc.bak
 create mode 100644 source/structured_data.cc.bak
 create mode 100644 source/termination_criteria/end_step.cc.bak
 create mode 100644 source/termination_criteria/end_time.cc.bak
 create mode 100644 source/termination_criteria/end_walltime.cc.bak
 create mode 100644 source/termination_criteria/interface.cc.bak
 create mode 100644 source/termination_criteria/steady_heat_flux.cc.bak
 create mode 100644 source/termination_criteria/steady_rms_velocity.cc.bak
 create mode 100644 source/termination_criteria/steady_temperature.cc.bak
 create mode 100644 source/termination_criteria/user_request.cc.bak
 create mode 100644 source/time_stepping/conduction_time_step.cc.bak
 create mode 100644 source/time_stepping/convection_time_step.cc.bak
 create mode 100644 source/time_stepping/function.cc.bak
 create mode 100644 source/time_stepping/interface.cc.bak
 create mode 100644 source/time_stepping/repeat_on_cutback.cc.bak
 create mode 100644 source/utilities.cc.bak
 create mode 100644 source/volume_of_fluid/assembler.cc.bak
 create mode 100644 source/volume_of_fluid/handler.cc.bak
 create mode 100644 source/volume_of_fluid/reconstruct.cc.bak
 create mode 100644 source/volume_of_fluid/setup_initial_conditions.cc.bak
 create mode 100644 source/volume_of_fluid/solver.cc.bak
 create mode 100644 source/volume_of_fluid/utilities.cc.bak
 create mode 100644 tests/2d_annulus_pyvista_cookbook.prm.bak
 create mode 100644 tests/ISA_rotation_timescale.prm.bak
 create mode 100644 tests/Picard_compressible.prm.bak
 create mode 100644 tests/additional_outputs_02.cc.bak
 create mode 100644 tests/additional_outputs_02.prm.bak
 create mode 100644 tests/additional_outputs_03.cc.bak
 create mode 100644 tests/additional_outputs_03.prm.bak
 create mode 100644 tests/adiabatic_boundary.prm.bak
 create mode 100644 tests/adiabatic_conditions.prm.bak
 create mode 100644 tests/adiabatic_conditions_composition_function.prm.bak
 create mode 100644 tests/adiabatic_conditions_function.prm.bak
 create mode 100644 tests/adiabatic_conditions_time_change.prm.bak
 create mode 100644 tests/adiabatic_heating.prm.bak
 create mode 100644 tests/adiabatic_heating_simplified.prm.bak
 create mode 100644 tests/adiabatic_heating_with_melt.prm.bak
 create mode 100644 tests/adiabatic_initial_conditions.prm.bak
 create mode 100644 tests/adiabatic_initial_conditions_chunk.prm.bak
 create mode 100644 tests/adiabatic_initial_conditions_chunk_3d.prm.bak
 create mode 100644 tests/adiabatic_initial_conditions_compressible.prm.bak
 create mode 100644 tests/adiabatic_initial_conditions_constant.prm.bak
 create mode 100644 tests/adiabatic_initial_conditions_points.prm.bak
 create mode 100644 tests/adiabatic_initial_conditions_subadiabaticity.prm.bak
 create mode 100644 tests/adiabatic_initial_conditions_without_boundary.prm.bak
 create mode 100644 tests/adiabatic_plate_cooling.prm.bak
 create mode 100644 tests/adiabatic_plate_function.prm.bak
 create mode 100644 tests/advect_field_with_melt_velocity.cc.bak
 create mode 100644 tests/advect_field_with_melt_velocity.prm.bak
 create mode 100644 tests/advect_mesh_vertically.prm.bak
 create mode 100644 tests/advection_reaction.cc.bak
 create mode 100644 tests/advection_reaction.prm.bak
 create mode 100644 tests/advection_solver_fail.prm.bak
 create mode 100644 tests/airy_isostasy.prm.bak
 create mode 100644 tests/airy_isostasy_initial_topo.cc.bak
 create mode 100644 tests/airy_isostasy_initial_topo.prm.bak
 create mode 100644 tests/airy_isostasy_initial_topo_lithostatic_pressure.prm.bak
 create mode 100644 tests/always_refine.prm.bak
 create mode 100644 tests/analytic_artificial_viscosity_0.prm.bak
 create mode 100644 tests/anisotropic_viscosity.cc.bak
 create mode 100644 tests/anisotropic_viscosity.prm.bak
 create mode 100644 tests/annulus.cc.bak
 create mode 100644 tests/annulus.prm.bak
 create mode 100644 tests/annulus_transient.cc.bak
 create mode 100644 tests/annulus_transient.prm.bak
 create mode 100644 tests/artificial_postprocess.cc.bak
 create mode 100644 tests/artificial_postprocess.prm.bak
 create mode 100644 tests/artificial_viscosity.prm.bak
 create mode 100644 tests/artificial_viscosity_dirichlet_boundaries.prm.bak
 create mode 100644 tests/artificial_viscosity_list.prm.bak
 create mode 100644 tests/ascii_boundary_member.cc.bak
 create mode 100644 tests/ascii_boundary_member.prm.bak
 create mode 100644 tests/ascii_data_adiabatic_conditions.prm.bak
 create mode 100644 tests/ascii_data_boundary_composition_2d_box_time.prm.bak
 create mode 100644 tests/ascii_data_boundary_composition_3d_box.prm.bak
 create mode 100644 tests/ascii_data_boundary_temperature_2d_box_time.prm.bak
 create mode 100644 tests/ascii_data_boundary_temperature_3d_box.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_2d_box.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_2d_box_list.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_2d_box_time.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_2d_box_time_backward.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_2d_box_time_non_equidistant.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_2d_chunk.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_2d_shell.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_2d_shell_spherical.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_3d_box.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_3d_chunk.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_3d_shell.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_3d_shell_spherical.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_3d_sphere.prm.bak
 create mode 100644 tests/ascii_data_boundary_velocity_residual_shell.prm.bak
 create mode 100644 tests/ascii_data_fail_1.prm.bak
 create mode 100644 tests/ascii_data_fail_2.prm.bak
 create mode 100644 tests/ascii_data_fail_3.prm.bak
 create mode 100644 tests/ascii_data_fail_4.prm.bak
 create mode 100644 tests/ascii_data_gravity.prm.bak
 create mode 100644 tests/ascii_data_initial_composition_2d_box.prm.bak
 create mode 100644 tests/ascii_data_initial_composition_2d_box_gz.prm.bak
 create mode 100644 tests/ascii_data_initial_composition_3d_chunk.prm.bak
 create mode 100644 tests/ascii_data_initial_composition_3d_shell.prm.bak
 create mode 100644 tests/ascii_data_initial_temperature_2d_box.prm.bak
 create mode 100644 tests/ascii_data_initial_temperature_3d_chunk.prm.bak
 create mode 100644 tests/ascii_data_initial_temperature_3d_ellipsoidal_chunk.prm.bak
 create mode 100644 tests/ascii_data_initial_temperature_3d_shell.prm.bak
 create mode 100644 tests/ascii_data_initial_temperature_3d_two_chunks.prm.bak
 create mode 100644 tests/ascii_data_layered_initial_composition_2d_box.prm.bak
 create mode 100644 tests/ascii_data_layered_initial_temperature_2d_box.prm.bak
 create mode 100644 tests/ascii_data_layered_initial_temperature_2d_chunk.prm.bak
 create mode 100644 tests/ascii_data_layered_initial_temperature_3d_box.prm.bak
 create mode 100644 tests/ascii_data_layered_initial_temperature_3d_chunk.prm.bak
 create mode 100644 tests/ascii_data_layered_initial_temperature_piecewise_constant_3d_box.prm.bak
 create mode 100644 tests/ascii_data_nonuniform_initial_composition_2d_box.prm.bak
 create mode 100644 tests/ascii_data_prescribed_stokes_2d_box.prm.bak
 create mode 100644 tests/ascii_data_slice.prm.bak
 create mode 100644 tests/ascii_data_slice_temperature.prm.bak
 create mode 100644 tests/average_arithmetic.prm.bak
 create mode 100644 tests/average_density_boundary_fluid_pressure.prm.bak
 create mode 100644 tests/average_geometric.prm.bak
 create mode 100644 tests/average_harmonic.prm.bak
 create mode 100644 tests/average_log.prm.bak
 create mode 100644 tests/average_none.prm.bak
 create mode 100644 tests/average_nwd_arithmetic.prm.bak
 create mode 100644 tests/average_nwd_geometric.prm.bak
 create mode 100644 tests/average_nwd_harmonic.prm.bak
 create mode 100644 tests/average_pick_largest.prm.bak
 create mode 100644 tests/average_project_to_q1.prm.bak
 create mode 100644 tests/background_output_writer.prm.bak
 create mode 100644 tests/backward_advection.prm.bak
 create mode 100644 tests/benchmark_layeredflow.cc.bak
 create mode 100644 tests/benchmark_layeredflow.prm.bak
 create mode 100644 tests/benchmark_particle_integration_scheme.prm.bak
 create mode 100644 tests/blankenbach.prm.bak
 create mode 100644 tests/blankenbach_approximation.prm.bak
 create mode 100644 tests/blankenbach_case1a.cc.bak
 create mode 100644 tests/blankenbach_case1a.prm.bak
 create mode 100644 tests/blankenbach_case1b.cc.bak
 create mode 100644 tests/blankenbach_case1b.prm.bak
 create mode 100644 tests/blankenbach_case1c.cc.bak
 create mode 100644 tests/blankenbach_case1c.prm.bak
 create mode 100644 tests/blankenbach_case2a.cc.bak
 create mode 100644 tests/blankenbach_case2a.prm.bak
 create mode 100644 tests/blankenbach_case2b.cc.bak
 create mode 100644 tests/blankenbach_case2b.prm.bak
 create mode 100644 tests/boukare_bulk_composition.prm.bak
 create mode 100644 tests/boukare_conserve_mass.prm.bak
 create mode 100644 tests/boukare_latent_heat.prm.bak
 create mode 100644 tests/boukare_melting_diagram.prm.bak
 create mode 100644 tests/boundary_composition_list.prm.bak
 create mode 100644 tests/boundary_composition_passive_cartesian.prm.bak
 create mode 100644 tests/boundary_composition_passive_depth.prm.bak
 create mode 100644 tests/boundary_composition_passive_sphere.prm.bak
 create mode 100644 tests/boundary_heatflux.prm.bak
 create mode 100644 tests/boundary_heatflux_update.cc.bak
 create mode 100644 tests/boundary_heatflux_update.prm.bak
 create mode 100644 tests/boundary_temperature_function.prm.bak
 create mode 100644 tests/boundary_temperature_list.prm.bak
 create mode 100644 tests/boundary_traction_function_cartesian_free_surface.prm.bak
 create mode 100644 tests/boundary_traction_function_spherical_free_surface.prm.bak
 create mode 100644 tests/boundary_velocity_function_spherical.prm.bak
 create mode 100644 tests/box_end_time_1e7_terminate.prm.bak
 create mode 100644 tests/box_first_time_step.prm.bak
 create mode 100644 tests/box_first_time_step_alternate_bc.prm.bak
 create mode 100644 tests/box_initial_mesh_deformation.cc.bak
 create mode 100644 tests/box_initial_mesh_deformation.prm.bak
 create mode 100644 tests/box_initial_mesh_deformation_ascii_data.prm.bak
 create mode 100644 tests/box_initial_mesh_deformation_periodic.cc.bak
 create mode 100644 tests/box_initial_mesh_deformation_periodic.prm.bak
 create mode 100644 tests/box_initial_topography_ascii_data.prm.bak
 create mode 100644 tests/box_initial_topography_ascii_data_moved_origin.prm.bak
 create mode 100644 tests/box_initial_topography_function.prm.bak
 create mode 100644 tests/box_initial_topography_prm_polygon.prm.bak
 create mode 100644 tests/box_lithostatic_pressure_2d.prm.bak
 create mode 100644 tests/box_lithostatic_pressure_3d.prm.bak
 create mode 100644 tests/box_origin.prm.bak
 create mode 100644 tests/box_repetitions.prm.bak
 create mode 100644 tests/box_simple_log_viscosity_depth_average.prm.bak
 create mode 100644 tests/box_simple_surface_strain_rate_residual.prm.bak
 create mode 100644 tests/box_steady_state_terminate.prm.bak
 create mode 100644 tests/box_steady_temperature_terminate.prm.bak
 create mode 100644 tests/box_surface_base_variables.prm.bak
 create mode 100644 tests/bunge_cookbook.prm.bak
 create mode 100644 tests/burnman_seismic_test.prm.bak
 create mode 100644 tests/burnman_test.prm.bak
 create mode 100644 tests/burstedde.cc.bak
 create mode 100644 tests/burstedde.prm.bak
 create mode 100644 tests/burstedde_stokes_rhs.cc.bak
 create mode 100644 tests/burstedde_stokes_rhs.prm.bak
 create mode 100644 tests/cell_reference.cc.bak
 create mode 100644 tests/cell_reference.prm.bak
 create mode 100644 tests/cells_in_circumference.prm.bak
 create mode 100644 tests/check_compositional_field_functions.cc.bak
 create mode 100644 tests/check_compositional_field_functions.prm.bak
 create mode 100644 tests/check_compositional_field_names.cc.bak
 create mode 100644 tests/check_compositional_field_names.prm.bak
 create mode 100644 tests/checkpoint_01.cc.bak
 create mode 100644 tests/checkpoint_01.prm.bak
 create mode 100644 tests/checkpoint_01_check_parameters.cc.bak
 create mode 100644 tests/checkpoint_01_check_parameters.prm.bak
 create mode 100644 tests/checkpoint_02.cc.bak
 create mode 100644 tests/checkpoint_02.prm.bak
 create mode 100644 tests/checkpoint_02_direct.cc.bak
 create mode 100644 tests/checkpoint_02_direct.prm.bak
 create mode 100644 tests/checkpoint_03_particles.cc.bak
 create mode 100644 tests/checkpoint_03_particles.prm.bak
 create mode 100644 tests/checkpoint_04_particles_no_output.cc.bak
 create mode 100644 tests/checkpoint_04_particles_no_output.prm.bak
 create mode 100644 tests/checkpoint_05_mpi_create.prm.bak
 create mode 100644 tests/checkpoint_05_mpi_resume.cc.bak
 create mode 100644 tests/checkpoint_05_mpi_resume.prm.bak
 create mode 100644 tests/checkpoint_06_spherical_shell.cc.bak
 create mode 100644 tests/checkpoint_06_spherical_shell.prm.bak
 create mode 100644 tests/checkpoint_07_enable_free_surface_create.prm.bak
 create mode 100644 tests/checkpoint_07_enable_free_surface_resume.cc.bak
 create mode 100644 tests/checkpoint_07_enable_free_surface_resume.prm.bak
 create mode 100644 tests/chunk_ascii_initial_temperature.prm.bak
 create mode 100644 tests/chunk_conditions.prm.bak
 create mode 100644 tests/chunk_cross_hemisphere.prm.bak
 create mode 100644 tests/chunk_first_time_step_2d.prm.bak
 create mode 100644 tests/chunk_first_time_step_3d.prm.bak
 create mode 100644 tests/chunk_initial_topography_ascii_data.prm.bak
 create mode 100644 tests/chunk_initial_topography_ascii_data_3d.prm.bak
 create mode 100644 tests/chunk_initial_topography_ascii_data_3d_colatitude.prm.bak
 create mode 100644 tests/chunk_lithostatic_pressure_2d.prm.bak
 create mode 100644 tests/chunk_lithostatic_pressure_2d_initial_topography.prm.bak
 create mode 100644 tests/chunk_tangential_velocity.prm.bak
 create mode 100644 tests/chunk_topography_postprocessor.prm.bak
 create mode 100644 tests/command_postprocessor.prm.bak
 create mode 100644 tests/compaction_length_refinement.prm.bak
 create mode 100644 tests/compaction_length_visualization.prm.bak
 create mode 100644 tests/composite_viscous_outputs.cc.bak
 create mode 100644 tests/composite_viscous_outputs.prm.bak
 create mode 100644 tests/compositing_02.prm.bak
 create mode 100644 tests/compositing_named_outputs.prm.bak
 create mode 100644 tests/composition_active.prm.bak
 create mode 100644 tests/composition_active_nans.prm.bak
 create mode 100644 tests/composition_active_with_melt.cc.bak
 create mode 100644 tests/composition_active_with_melt.prm.bak
 create mode 100644 tests/composition_active_without_melt.cc.bak
 create mode 100644 tests/composition_active_without_melt.prm.bak
 create mode 100644 tests/composition_cg_dg_fem.prm.bak
 create mode 100644 tests/composition_names.prm.bak
 create mode 100644 tests/composition_names_duplicates.prm.bak
 create mode 100644 tests/composition_passive_discontinuous_constant.prm.bak
 create mode 100644 tests/composition_passive_particles.prm.bak
 create mode 100644 tests/composition_passive_quarter_shell_cartesian.prm.bak
 create mode 100644 tests/composition_passive_quarter_shell_depth.prm.bak
 create mode 100644 tests/composition_passive_quarter_shell_spherical.prm.bak
 create mode 100644 tests/composition_passive_static.prm.bak
 create mode 100644 tests/composition_reaction.prm.bak
 create mode 100644 tests/composition_reaction_iterated_IMPES.cc.bak
 create mode 100644 tests/composition_reaction_iterated_IMPES.prm.bak
 create mode 100644 tests/composition_stabilization.prm.bak
 create mode 100644 tests/compositional_boundary_values.prm.bak
 create mode 100644 tests/compositional_boundary_values_02.prm.bak
 create mode 100644 tests/compositional_boundary_values_03.prm.bak
 create mode 100644 tests/compositional_heating.prm.bak
 create mode 100644 tests/compositional_heating_exclude_background.prm.bak
 create mode 100644 tests/compositional_vectors.prm.bak
 create mode 100644 tests/compositional_vectors_3d.prm.bak
 create mode 100644 tests/compressibility.cc.bak
 create mode 100644 tests/compressibility.prm.bak
 create mode 100644 tests/compressibility_iterated_stokes.cc.bak
 create mode 100644 tests/compressibility_iterated_stokes.prm.bak
 create mode 100644 tests/compressibility_iterated_stokes_direct_solver.cc.bak
 create mode 100644 tests/compressibility_iterated_stokes_direct_solver.prm.bak
 create mode 100644 tests/compressibility_lateral_pipe.cc.bak
 create mode 100644 tests/compressibility_lateral_pipe.prm.bak
 create mode 100644 tests/compressibility_lateral_pipe_advect.cc.bak
 create mode 100644 tests/compressibility_lateral_pipe_advect.prm.bak
 create mode 100644 tests/compressibility_lateral_pipe_advect_projected_density.cc.bak
 create mode 100644 tests/compressibility_lateral_pipe_advect_projected_density.prm.bak
 create mode 100644 tests/compressibility_lateral_pipe_increase_pressure.cc.bak
 create mode 100644 tests/compressibility_lateral_pipe_increase_pressure.prm.bak
 create mode 100644 tests/compressibility_lateral_pipe_increase_pressure_projected_density.cc.bak
 create mode 100644 tests/compressibility_lateral_pipe_increase_pressure_projected_density.prm.bak
 create mode 100644 tests/compressibility_lateral_pipe_projected_density.cc.bak
 create mode 100644 tests/compressibility_lateral_pipe_projected_density.prm.bak
 create mode 100644 tests/compressibility_lateral_pipe_transient.cc.bak
 create mode 100644 tests/compressibility_lateral_pipe_transient.prm.bak
 create mode 100644 tests/compressibility_lateral_pipe_transient_projected_density.cc.bak
 create mode 100644 tests/compressibility_lateral_pipe_transient_projected_density.prm.bak
 create mode 100644 tests/compressibility_vertical_pipe.cc.bak
 create mode 100644 tests/compressibility_vertical_pipe.prm.bak
 create mode 100644 tests/compressibility_vertical_pipe_projected_density.cc.bak
 create mode 100644 tests/compressibility_vertical_pipe_projected_density.prm.bak
 create mode 100644 tests/compressibility_volumetric_strain_rate.cc.bak
 create mode 100644 tests/compressibility_volumetric_strain_rate.prm.bak
 create mode 100644 tests/compressible_forsterite_box.prm.bak
 create mode 100644 tests/compression_heating.cc.bak
 create mode 100644 tests/compression_heating.prm.bak
 create mode 100644 tests/compute-no-normal-flux-constraints.prm.bak
 create mode 100644 tests/conservative_with_mpi.cc.bak
 create mode 100644 tests/conservative_with_mpi.prm.bak
 create mode 100644 tests/consistent_boundary_flux_adjacent_dirichlet.prm.bak
 create mode 100644 tests/consistent_boundary_flux_neumann.prm.bak
 create mode 100644 tests/consistent_boundary_flux_open_boundary.prm.bak
 create mode 100644 tests/constant_composition_convergence.prm.bak
 create mode 100644 tests/constant_temperature_boundary_conditions.prm.bak
 create mode 100644 tests/continental_extension.prm.bak
 create mode 100644 tests/convection_box_particles.prm.bak
 create mode 100644 tests/convection_box_phase_function.prm.bak
 create mode 100644 tests/cookbook_mantle_convection_annulus.prm.bak
 create mode 100644 tests/cookbook_simpler_with_crust.cc.bak
 create mode 100644 tests/coordinate_transformation.cc.bak
 create mode 100644 tests/coordinate_transformation.prm.bak
 create mode 100644 tests/coupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
 create mode 100644 tests/cpo_simple_shearbox.prm.bak
 create mode 100644 tests/crameri_benchmark_1_gmg.cc.bak
 create mode 100644 tests/crameri_benchmark_1_gmg.prm.bak
 create mode 100644 tests/crustal_model_3D.prm.bak
 create mode 100644 tests/custom_spherical_shell_2d_list.prm.bak
 create mode 100644 tests/custom_spherical_shell_2d_slices.prm.bak
 create mode 100644 tests/custom_spherical_shell_3d_list.prm.bak
 create mode 100644 tests/custom_spherical_shell_3d_slices.prm.bak
 create mode 100644 tests/damped_viscoelastic_bending_beam.prm.bak
 create mode 100644 tests/darcy_velocity.cc.bak
 create mode 100644 tests/darcy_velocity.prm.bak
 create mode 100644 tests/darcy_velocity_vertical.cc.bak
 create mode 100644 tests/darcy_velocity_vertical.prm.bak
 create mode 100644 tests/dash_dash.cc.bak
 create mode 100644 tests/dash_dash.prm.bak
 create mode 100644 tests/dc_Picard_compressible.prm.bak
 create mode 100644 tests/density_boundary.prm.bak
 create mode 100644 tests/depth_average_01.prm.bak
 create mode 100644 tests/depth_average_02.prm.bak
 create mode 100644 tests/depth_average_03.prm.bak
 create mode 100644 tests/depth_average_04.prm.bak
 create mode 100644 tests/depth_average_05.prm.bak
 create mode 100644 tests/depth_average_06.prm.bak
 create mode 100644 tests/depth_average_rounding_bug.prm.bak
 create mode 100644 tests/depth_average_txt_output.prm.bak
 create mode 100644 tests/depth_average_underres.prm.bak
 create mode 100644 tests/depth_dependent_3d_shell_list_simple.prm.bak
 create mode 100644 tests/depth_dependent_additional_outputs.prm.bak
 create mode 100644 tests/depth_dependent_box_file_simple.prm.bak
 create mode 100644 tests/depth_dependent_box_function_simple.prm.bak
 create mode 100644 tests/depth_dependent_box_function_time_dependent.prm.bak
 create mode 100644 tests/depth_dependent_box_none_simple.prm.bak
 create mode 100644 tests/depth_dependent_initialize_base_model.prm.bak
 create mode 100644 tests/depth_postprocessor_box.prm.bak
 create mode 100644 tests/depth_postprocessor_chunk.prm.bak
 create mode 100644 tests/depth_postprocessor_ellipsoidal_chunk.prm.bak
 create mode 100644 tests/depth_postprocessor_sphere.prm.bak
 create mode 100644 tests/depth_postprocessor_spherical_shell.prm.bak
 create mode 100644 tests/depth_postprocessor_two_merged_boxes.prm.bak
 create mode 100644 tests/derivative_of_weighted_p_norm_average.cc.bak
 create mode 100644 tests/derivative_of_weighted_p_norm_average.prm.bak
 create mode 100644 tests/diffusion.prm.bak
 create mode 100644 tests/diffusion_dislocation.prm.bak
 create mode 100644 tests/diffusion_dislocation_fixed_strain_rate.prm.bak
 create mode 100644 tests/diffusion_dislocation_fixed_strain_rate2.prm.bak
 create mode 100644 tests/diffusion_dislocation_reference_density_profile.prm.bak
 create mode 100644 tests/diffusion_velocity.prm.bak
 create mode 100644 tests/direct_solver_1.prm.bak
 create mode 100644 tests/direct_solver_2.prm.bak
 create mode 100644 tests/discontinuous_composition_1.prm.bak
 create mode 100644 tests/discontinuous_composition_bound_preserving_limiter.prm.bak
 create mode 100644 tests/discontinuous_composition_bound_preserving_limiter_3d.prm.bak
 create mode 100644 tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm.bak
 create mode 100644 tests/discontinuous_composition_serial_periodic_amr.prm.bak
 create mode 100644 tests/discontinuous_temperature.prm.bak
 create mode 100644 tests/discontinuous_temperature_blankenbach.cc.bak
 create mode 100644 tests/discontinuous_temperature_blankenbach.prm.bak
 create mode 100644 tests/discontinuous_temperature_spherical_shell_3d.prm.bak
 create mode 100644 tests/doneahuerta_3.cc.bak
 create mode 100644 tests/doneahuerta_3.prm.bak
 create mode 100644 tests/drucker_prager_compression.prm.bak
 create mode 100644 tests/drucker_prager_derivatives_2d.cc.bak
 create mode 100644 tests/drucker_prager_derivatives_2d.prm.bak
 create mode 100644 tests/drucker_prager_derivatives_3d.cc.bak
 create mode 100644 tests/drucker_prager_derivatives_3d.prm.bak
 create mode 100644 tests/drucker_prager_extension.prm.bak
 create mode 100644 tests/dynamic_core.prm.bak
 create mode 100644 tests/dynamic_friction.prm.bak
 create mode 100644 tests/dynamic_topography.prm.bak
 create mode 100644 tests/dynamic_topography2.prm.bak
 create mode 100644 tests/dynamic_topography3.prm.bak
 create mode 100644 tests/dynamic_topography_back.prm.bak
 create mode 100644 tests/dynamic_topography_vs_surface_dynamic_topography.prm.bak
 create mode 100644 tests/edit_parameters.cc.bak
 create mode 100644 tests/edit_parameters.prm.bak
 create mode 100644 tests/elastic_stabilization_time_scale_factor.prm.bak
 create mode 100644 tests/ellipsoidal_chunk_coordinate_parallel.prm.bak
 create mode 100644 tests/ellipsoidal_chunk_geometry.cc.bak
 create mode 100644 tests/ellipsoidal_chunk_geometry.prm.bak
 create mode 100644 tests/ellipsoidal_chunk_noncoordinate_parallel.prm.bak
 create mode 100644 tests/ellipsoidal_chunk_topography.prm.bak
 create mode 100644 tests/entropy_adiabat.cc.bak
 create mode 100644 tests/entropy_adiabat.prm.bak
 create mode 100644 tests/entropy_conduction.cc.bak
 create mode 100644 tests/entropy_conduction.prm.bak
 create mode 100644 tests/entropy_half_space.cc.bak
 create mode 100644 tests/entropy_half_space.prm.bak
 create mode 100644 tests/entropy_initial_lookup.cc.bak
 create mode 100644 tests/entropy_initial_lookup.prm.bak
 create mode 100644 tests/entropy_initial_lookup_wb.cc.bak
 create mode 100644 tests/entropy_initial_lookup_wb.prm.bak
 create mode 100644 tests/entropy_plasticity.cc.bak
 create mode 100644 tests/entropy_plasticity.prm.bak
 create mode 100644 tests/entropy_read_multi_table.cc.bak
 create mode 100644 tests/entropy_read_multi_table.prm.bak
 create mode 100644 tests/entropy_viscosity_statistics.prm.bak
 create mode 100644 tests/exponential_decay.cc.bak
 create mode 100644 tests/exponential_decay.prm.bak
 create mode 100644 tests/fail.prm.bak
 create mode 100644 tests/find_boundary_composition_model.cc.bak
 create mode 100644 tests/find_boundary_composition_model.prm.bak
 create mode 100644 tests/find_boundary_composition_model_fail_1.cc.bak
 create mode 100644 tests/find_boundary_composition_model_fail_1.prm.bak
 create mode 100644 tests/find_mesh_refinement.cc.bak
 create mode 100644 tests/find_mesh_refinement.prm.bak
 create mode 100644 tests/find_mesh_refinement_fail_1.cc.bak
 create mode 100644 tests/find_mesh_refinement_fail_1.prm.bak
 create mode 100644 tests/find_postprocess.cc.bak
 create mode 100644 tests/find_postprocess.prm.bak
 create mode 100644 tests/find_postprocess_fail_1.cc.bak
 create mode 100644 tests/find_postprocess_fail_1.prm.bak
 create mode 100644 tests/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg.prm.bak
 create mode 100644 tests/free_surface_adaptive_blob.prm.bak
 create mode 100644 tests/free_surface_blob.prm.bak
 create mode 100644 tests/free_surface_blob_gmg.prm.bak
 create mode 100644 tests/free_surface_blob_melt.cc.bak
 create mode 100644 tests/free_surface_blob_melt.prm.bak
 create mode 100644 tests/free_surface_blob_nonzero_melt.cc.bak
 create mode 100644 tests/free_surface_blob_nonzero_melt.prm.bak
 create mode 100644 tests/free_surface_iterated_IMPES.prm.bak
 create mode 100644 tests/free_surface_iterated_stokes.prm.bak
 create mode 100644 tests/free_surface_iterated_stokes_gmg.prm.bak
 create mode 100644 tests/free_surface_relaxation.cc.bak
 create mode 100644 tests/free_surface_relaxation.prm.bak
 create mode 100644 tests/free_surface_tangential_mesh_velocity.prm.bak
 create mode 100644 tests/free_surface_tangential_mesh_velocity_2.prm.bak
 create mode 100644 tests/free_surface_timestep_repeat.prm.bak
 create mode 100644 tests/function_mesh_deformation_tangential_mesh_velocity.prm.bak
 create mode 100644 tests/gaussian_initial_temperature.prm.bak
 create mode 100644 tests/geoid.prm.bak
 create mode 100644 tests/geoid_freesurface.prm.bak
 create mode 100644 tests/geoid_no_topo.prm.bak
 create mode 100644 tests/geoid_visualization.prm.bak
 create mode 100644 tests/geometric_average_crash.prm.bak
 create mode 100644 tests/geometric_average_only_viscosity.prm.bak
 create mode 100644 tests/global_latent_heat.prm.bak
 create mode 100644 tests/global_melt.prm.bak
 create mode 100644 tests/global_melt_parallel.prm.bak
 create mode 100644 tests/global_refine_amr.cc.bak
 create mode 100644 tests/global_refine_amr.prm.bak
 create mode 100644 tests/global_refine_bug.prm.bak
 create mode 100644 tests/gmg_mesh_deform.prm.bak
 create mode 100644 tests/gmg_mesh_deform_adaptive.prm.bak
 create mode 100644 tests/gmg_mesh_deform_adaptive_bug.prm.bak
 create mode 100644 tests/gmg_mesh_deform_adaptive_bug2.prm.bak
 create mode 100644 tests/gmg_mesh_deform_function.prm.bak
 create mode 100644 tests/gmg_mesh_deform_ghost_entries.prm.bak
 create mode 100644 tests/gmg_mesh_deform_prescribed.cc.bak
 create mode 100644 tests/gmg_mesh_deform_prescribed.prm.bak
 create mode 100644 tests/gmg_mesh_deform_topo.prm.bak
 create mode 100644 tests/gmg_no_normal_flux_only.prm.bak
 create mode 100644 tests/gmg_test_project_q1.prm.bak
 create mode 100644 tests/gmg_velocity_boundary_2d_box_no_flux.prm.bak
 create mode 100644 tests/gmg_velocity_boundary_2d_box_no_normal_flux.prm.bak
 create mode 100644 tests/gmg_velocity_boundary_2d_chunk_no_flux.prm.bak
 create mode 100644 tests/gmg_velocity_boundary_2d_chunk_no_normal_flux.prm.bak
 create mode 100644 tests/gmg_velocity_boundary_3d_box_no_flux.prm.bak
 create mode 100644 tests/gmg_velocity_boundary_3d_box_no_normal_flux.prm.bak
 create mode 100644 tests/gmg_velocity_boundary_3d_chunk_no_flux.prm.bak
 create mode 100644 tests/gmg_velocity_boundary_3d_chunk_no_normal_flux.prm.bak
 create mode 100644 tests/gmg_velocity_boundary_component.prm.bak
 create mode 100644 tests/gplates_1_3.prm.bak
 create mode 100644 tests/gplates_1_4.prm.bak
 create mode 100644 tests/gplates_3d.prm.bak
 create mode 100644 tests/gplates_rotation.prm.bak
 create mode 100644 tests/gplates_scale_factor.prm.bak
 create mode 100644 tests/grain_lag_angle.prm.bak
 create mode 100644 tests/grain_size_additional_outputs.prm.bak
 create mode 100644 tests/grain_size_averaging.prm.bak
 create mode 100644 tests/grain_size_crossed_transition.prm.bak
 create mode 100644 tests/grain_size_friction_heating.prm.bak
 create mode 100644 tests/grain_size_growth.prm.bak
 create mode 100644 tests/grain_size_growth_one_cell.prm.bak
 create mode 100644 tests/grain_size_growth_one_cell_particles.prm.bak
 create mode 100644 tests/grain_size_growth_particles.prm.bak
 create mode 100644 tests/grain_size_growth_pinned.prm.bak
 create mode 100644 tests/grain_size_latent_heat.cc.bak
 create mode 100644 tests/grain_size_latent_heat.prm.bak
 create mode 100644 tests/grain_size_phase_function.prm.bak
 create mode 100644 tests/grain_size_plunge.prm.bak
 create mode 100644 tests/grain_size_ridge.prm.bak
 create mode 100644 tests/grain_size_ridge_traction.prm.bak
 create mode 100644 tests/grain_size_strain.prm.bak
 create mode 100644 tests/grain_size_strain_pinned.prm.bak
 create mode 100644 tests/grain_size_strain_pinned_state.prm.bak
 create mode 100644 tests/grain_size_yield.prm.bak
 create mode 100644 tests/graphical_output.cc.bak
 create mode 100644 tests/graphical_output.prm.bak
 create mode 100644 tests/graphical_output_02.prm.bak
 create mode 100644 tests/graphical_output_hdf5.cc.bak
 create mode 100644 tests/graphical_output_hdf5.prm.bak
 create mode 100644 tests/gravity_function.prm.bak
 create mode 100644 tests/gravity_function_time.prm.bak
 create mode 100644 tests/gravity_model_cartesian.prm.bak
 create mode 100644 tests/gravity_model_depth.prm.bak
 create mode 100644 tests/gravity_model_spherical.prm.bak
 create mode 100644 tests/gravity_point_values_list.prm.bak
 create mode 100644 tests/gravity_point_values_map.prm.bak
 create mode 100644 tests/gravity_point_values_spiral.prm.bak
 create mode 100644 tests/gravity_point_values_spiral_parallel.prm.bak
 create mode 100644 tests/gravity_prem.prm.bak
 create mode 100644 tests/gravity_quadrature_degree_increase.prm.bak
 create mode 100644 tests/gs_drucker_prager.prm.bak
 create mode 100644 tests/gs_drucker_prager_extension.prm.bak
 create mode 100644 tests/gs_drucker_prager_extension_adiabatic.prm.bak
 create mode 100644 tests/heat_advection_by_melt.cc.bak
 create mode 100644 tests/heat_advection_by_melt.prm.bak
 create mode 100644 tests/heat_advection_by_melt_operator_splitting.cc.bak
 create mode 100644 tests/heat_advection_by_melt_operator_splitting.prm.bak
 create mode 100644 tests/heat_flow.prm.bak
 create mode 100644 tests/heat_flow_plume.prm.bak
 create mode 100644 tests/heat_flux_densities.prm.bak
 create mode 100644 tests/heat_flux_map.prm.bak
 create mode 100644 tests/heat_flux_map_vis.prm.bak
 create mode 100644 tests/heat_flux_map_vis_point_wise.prm.bak
 create mode 100644 tests/heating_function.prm.bak
 create mode 100644 tests/heating_function_depth.prm.bak
 create mode 100644 tests/heating_function_spherical.prm.bak
 create mode 100644 tests/hexagonal_initial_temperature.prm.bak
 create mode 100644 tests/hill_diffusion.prm.bak
 create mode 100644 tests/hill_diffusion_3D.prm.bak
 create mode 100644 tests/hk04_olivine_composite_hydration_prefactor.prm.bak
 create mode 100644 tests/hk04_olivine_composite_hydration_prefactor_cutoff.prm.bak
 create mode 100644 tests/hk04_olivine_diffusion_hydration_prefactor.prm.bak
 create mode 100644 tests/hk04_olivine_dislocation_hydration_prefactor.prm.bak
 create mode 100644 tests/hollow_sphere.cc.bak
 create mode 100644 tests/hollow_sphere.prm.bak
 create mode 100644 tests/hollow_sphere_gmg.cc.bak
 create mode 100644 tests/hollow_sphere_gmg.prm.bak
 create mode 100644 tests/hollow_sphere_gmg_project_q1.cc.bak
 create mode 100644 tests/hollow_sphere_gmg_project_q1.prm.bak
 create mode 100644 tests/hollow_sphere_gmg_q3.cc.bak
 create mode 100644 tests/hollow_sphere_gmg_q3.prm.bak
 create mode 100644 tests/hydrostatic_compression.cc.bak
 create mode 100644 tests/hydrostatic_compression.prm.bak
 create mode 100644 tests/inclusion_2.cc.bak
 create mode 100644 tests/inclusion_2.prm.bak
 create mode 100644 tests/inclusion_4.cc.bak
 create mode 100644 tests/inclusion_4.prm.bak
 create mode 100644 tests/inclusion_adaptive.cc.bak
 create mode 100644 tests/inclusion_adaptive.prm.bak
 create mode 100644 tests/infill_density_flexure.cc.bak
 create mode 100644 tests/infill_density_flexure.prm.bak
 create mode 100644 tests/initial_composition_list.prm.bak
 create mode 100644 tests/initial_composition_list_using_maximum.prm.bak
 create mode 100644 tests/initial_composition_list_using_minimum.prm.bak
 create mode 100644 tests/initial_composition_list_using_subtract.prm.bak
 create mode 100644 tests/initial_condition_S20RTS.prm.bak
 create mode 100644 tests/initial_condition_S20RTS_2D.prm.bak
 create mode 100644 tests/initial_condition_S20RTS_dgp.prm.bak
 create mode 100644 tests/initial_condition_S40RTS.prm.bak
 create mode 100644 tests/initial_condition_SAVANI.prm.bak
 create mode 100644 tests/initial_condition_lithosphere_mask.prm.bak
 create mode 100644 tests/initial_condition_patch_on_S40RTS.prm.bak
 create mode 100644 tests/initial_condition_vs_to_density.prm.bak
 create mode 100644 tests/initial_condition_vs_to_density_SAVANI.prm.bak
 create mode 100644 tests/initial_global_refinement.prm.bak
 create mode 100644 tests/initial_porosity.prm.bak
 create mode 100644 tests/initial_temperature_list.prm.bak
 create mode 100644 tests/initial_temperature_list_using_maximum.prm.bak
 create mode 100644 tests/initial_temperature_list_using_minimum.prm.bak
 create mode 100644 tests/initial_temperature_list_using_subtract.prm.bak
 create mode 100644 tests/initial_temperature_profile.prm.bak
 create mode 100644 tests/inner_core.cc.bak
 create mode 100644 tests/inner_core.prm.bak
 create mode 100644 tests/internal_heating_statistics.prm.bak
 create mode 100644 tests/interpolor_particles_harmonic_average.prm.bak
 create mode 100644 tests/interpolor_particles_nearest_neighbor.prm.bak
 create mode 100644 tests/interpolor_particles_quadratic_least_squares.prm.bak
 create mode 100644 tests/isosurfaces_simple_box_2D.prm.bak
 create mode 100644 tests/isosurfaces_simple_box_2D_custom_fieldnames.prm.bak
 create mode 100644 tests/isosurfaces_simple_box_2D_custom_fieldnames_fail.prm.bak
 create mode 100644 tests/isosurfaces_simple_box_2D_min_max_1.prm.bak
 create mode 100644 tests/isosurfaces_simple_box_2D_min_max_2.prm.bak
 create mode 100644 tests/isosurfaces_simple_box_3D.prm.bak
 create mode 100644 tests/isosurfaces_slab_2D.prm.bak
 create mode 100644 tests/isosurfaces_slab_3D.prm.bak
 create mode 100644 tests/iterated_advection_and_defect_correction_Stokes.prm.bak
 create mode 100644 tests/iterated_advection_and_stokes.prm.bak
 create mode 100644 tests/iterated_advection_and_stokes_DG.prm.bak
 create mode 100644 tests/iterated_advection_and_stokes_DG_limiter.prm.bak
 create mode 100644 tests/iterated_advection_and_stokes_direct_solver.prm.bak
 create mode 100644 tests/iterated_advection_and_stokes_residual.prm.bak
 create mode 100644 tests/kaus_rayleigh_taylor_instability.prm.bak
 create mode 100644 tests/kinematically_driven_subduction_2d_case1.prm.bak
 create mode 100644 tests/kinematically_driven_subduction_2d_case2a.cc.bak
 create mode 100644 tests/kinematically_driven_subduction_2d_case2a.prm.bak
 create mode 100644 tests/kinematically_driven_subduction_2d_case2b.cc.bak
 create mode 100644 tests/kinematically_driven_subduction_2d_case2b.prm.bak
 create mode 100644 tests/king_ala.cc.bak
 create mode 100644 tests/king_ala.prm.bak
 create mode 100644 tests/king_ala_nondim.prm.bak
 create mode 100644 tests/latent_heat.prm.bak
 create mode 100644 tests/latent_heat_composition.prm.bak
 create mode 100644 tests/latent_heat_enthalpy.cc.bak
 create mode 100644 tests/latent_heat_enthalpy.prm.bak
 create mode 100644 tests/latent_heat_melt.prm.bak
 create mode 100644 tests/latent_heat_melt_operator_split.prm.bak
 create mode 100644 tests/latent_heat_melt_statistics.prm.bak
 create mode 100644 tests/latent_heat_melt_transport.prm.bak
 create mode 100644 tests/latent_heat_pressure.prm.bak
 create mode 100644 tests/latent_heat_viscosity.prm.bak
 create mode 100644 tests/latent_heat_viscosity_adiabatic.prm.bak
 create mode 100644 tests/lithosphere_boundary_indicator.prm.bak
 create mode 100644 tests/lithosphere_boundary_indicator_3d.prm.bak
 create mode 100644 tests/lithosphere_boundary_indicator_3d_one_grid.prm.bak
 create mode 100644 tests/lithosphere_boundary_indicator_3d_periodic.prm.bak
 create mode 100644 tests/lithosphere_boundary_indicator_one_grid.prm.bak
 create mode 100644 tests/lithosphere_boundary_indicator_origin.prm.bak
 create mode 100644 tests/logo.prm.bak
 create mode 100644 tests/magnetic_stripes.cc.bak
 create mode 100644 tests/magnetic_stripes.prm.bak
 create mode 100644 tests/mass_flux_statistics.prm.bak
 create mode 100644 tests/mass_reaction_term.prm.bak
 create mode 100644 tests/material_model_dependencies.cc.bak
 create mode 100644 tests/material_model_dependencies_burstedde.cc.bak
 create mode 100644 tests/material_model_dependencies_burstedde.prm.bak
 create mode 100644 tests/material_model_dependencies_composition_reaction.cc.bak
 create mode 100644 tests/material_model_dependencies_composition_reaction.prm.bak
 create mode 100644 tests/material_model_dependencies_cookbooks_freesurface_with_crust.cc.bak
 create mode 100644 tests/material_model_dependencies_cookbooks_freesurface_with_crust.prm.bak
 create mode 100644 tests/material_model_dependencies_diffusion_dislocation.cc.bak
 create mode 100644 tests/material_model_dependencies_diffusion_dislocation.prm.bak
 create mode 100644 tests/material_model_dependencies_inclusion_2.cc.bak
 create mode 100644 tests/material_model_dependencies_inclusion_2.prm.bak
 create mode 100644 tests/material_model_dependencies_latent_heat.cc.bak
 create mode 100644 tests/material_model_dependencies_latent_heat.prm.bak
 create mode 100644 tests/material_model_dependencies_latent_heat_melt.cc.bak
 create mode 100644 tests/material_model_dependencies_latent_heat_melt.prm.bak
 create mode 100644 tests/material_model_dependencies_morency_doin.cc.bak
 create mode 100644 tests/material_model_dependencies_morency_doin.prm.bak
 create mode 100644 tests/material_model_dependencies_multicomponent.cc.bak
 create mode 100644 tests/material_model_dependencies_multicomponent.prm.bak
 create mode 100644 tests/material_model_dependencies_shear_thinning.cc.bak
 create mode 100644 tests/material_model_dependencies_shear_thinning.prm.bak
 create mode 100644 tests/material_model_dependencies_simple.cc.bak
 create mode 100644 tests/material_model_dependencies_simple.prm.bak
 create mode 100644 tests/material_model_dependencies_simple_compressible.cc.bak
 create mode 100644 tests/material_model_dependencies_simple_compressible.prm.bak
 create mode 100644 tests/material_model_dependencies_simpler.cc.bak
 create mode 100644 tests/material_model_dependencies_simpler.prm.bak
 create mode 100644 tests/material_model_dependencies_solcx.cc.bak
 create mode 100644 tests/material_model_dependencies_solcx.prm.bak
 create mode 100644 tests/material_model_dependencies_solkz.cc.bak
 create mode 100644 tests/material_model_dependencies_solkz.prm.bak
 create mode 100644 tests/material_model_dependencies_steinberger.cc.bak
 create mode 100644 tests/material_model_dependencies_steinberger.prm.bak
 create mode 100644 tests/material_model_dependencies_tangurnis.cc.bak
 create mode 100644 tests/material_model_dependencies_tangurnis.prm.bak
 create mode 100644 tests/material_statistics.prm.bak
 create mode 100644 tests/matrix_nonzeros_1.prm.bak
 create mode 100644 tests/matrix_nonzeros_2.prm.bak
 create mode 100644 tests/matrix_nonzeros_3.prm.bak
 create mode 100644 tests/matrix_nonzeros_4.prm.bak
 create mode 100644 tests/matrix_nonzeros_5.prm.bak
 create mode 100644 tests/matrix_nonzeros_6.prm.bak
 create mode 100644 tests/matrix_nonzeros_7.prm.bak
 create mode 100644 tests/max_timesteps_btwn_output.prm.bak
 create mode 100644 tests/maximum_horizontal_compressive_stress_case_one.prm.bak
 create mode 100644 tests/maximum_horizontal_compressive_stress_case_two.prm.bak
 create mode 100644 tests/maximum_refinement_function.prm.bak
 create mode 100644 tests/maximum_refinement_function_cartesian.prm.bak
 create mode 100644 tests/maximum_refinement_function_spherical.prm.bak
 create mode 100644 tests/maxtimestep.prm.bak
 create mode 100644 tests/melt_and_traction.prm.bak
 create mode 100644 tests/melt_boukare_EOS.prm.bak
 create mode 100644 tests/melt_boukare_averaging.prm.bak
 create mode 100644 tests/melt_boundary_heat_flux.cc.bak
 create mode 100644 tests/melt_boundary_heat_flux.prm.bak
 create mode 100644 tests/melt_compressible_advection.cc.bak
 create mode 100644 tests/melt_compressible_advection.prm.bak
 create mode 100644 tests/melt_force_vector.cc.bak
 create mode 100644 tests/melt_force_vector.prm.bak
 create mode 100644 tests/melt_fraction_postprocessor.prm.bak
 create mode 100644 tests/melt_introspection.cc.bak
 create mode 100644 tests/melt_introspection.prm.bak
 create mode 100644 tests/melt_material_1.cc.bak
 create mode 100644 tests/melt_material_1.prm.bak
 create mode 100644 tests/melt_material_2.cc.bak
 create mode 100644 tests/melt_material_2.prm.bak
 create mode 100644 tests/melt_material_3.cc.bak
 create mode 100644 tests/melt_material_3.prm.bak
 create mode 100644 tests/melt_material_4.cc.bak
 create mode 100644 tests/melt_material_4.prm.bak
 create mode 100644 tests/melt_postprocessor_peridotite.prm.bak
 create mode 100644 tests/melt_postprocessor_pyroxenite.prm.bak
 create mode 100644 tests/melt_property_visualization.cc.bak
 create mode 100644 tests/melt_property_visualization.prm.bak
 create mode 100644 tests/melt_restart.cc.bak
 create mode 100644 tests/melt_restart.prm.bak
 create mode 100644 tests/melt_statistics.prm.bak
 create mode 100644 tests/melt_track.cc.bak
 create mode 100644 tests/melt_track.prm.bak
 create mode 100644 tests/melt_transport.prm.bak
 create mode 100644 tests/melt_transport_adaptive.cc.bak
 create mode 100644 tests/melt_transport_adaptive.prm.bak
 create mode 100644 tests/melt_transport_compressible.cc.bak
 create mode 100644 tests/melt_transport_compressible.prm.bak
 create mode 100644 tests/melt_transport_compressible_iterative.cc.bak
 create mode 100644 tests/melt_transport_compressible_iterative.prm.bak
 create mode 100644 tests/melt_transport_convergence_simple.cc.bak
 create mode 100644 tests/melt_transport_convergence_simple.prm.bak
 create mode 100644 tests/melt_transport_convergence_test.cc.bak
 create mode 100644 tests/melt_transport_convergence_test.prm.bak
 create mode 100644 tests/melt_velocity_boundary_conditions.cc.bak
 create mode 100644 tests/melt_velocity_boundary_conditions.prm.bak
 create mode 100644 tests/melt_visco_plastic.cc.bak
 create mode 100644 tests/melt_visco_plastic_mohr_circle_compaction.cc.bak
 create mode 100644 tests/melt_visco_plastic_mohr_circle_compaction.prm.bak
 create mode 100644 tests/melt_visco_plastic_mohr_circle_shear.cc.bak
 create mode 100644 tests/melt_visco_plastic_mohr_circle_shear.prm.bak
 create mode 100644 tests/melting_rate.cc.bak
 create mode 100644 tests/melting_rate.prm.bak
 create mode 100644 tests/melting_rate_operator_splitting.prm.bak
 create mode 100644 tests/melting_rate_operator_splitting2.prm.bak
 create mode 100644 tests/melting_rate_test.prm.bak
 create mode 100644 tests/memory_statistics_1.prm.bak
 create mode 100644 tests/merged_chunks_2D.prm.bak
 create mode 100644 tests/merged_chunks_2D_one_grid.prm.bak
 create mode 100644 tests/merged_chunks_3D.prm.bak
 create mode 100644 tests/merged_chunks_3D_one_grid.prm.bak
 create mode 100644 tests/mesh_deformation_gmg_2d_spherical_shell.prm.bak
 create mode 100644 tests/mesh_deformation_particles.cc.bak
 create mode 100644 tests/mesh_deformation_particles.prm.bak
 create mode 100644 tests/mesh_velocity_output.prm.bak
 create mode 100644 tests/mid_ocean_ridge.prm.bak
 create mode 100644 tests/minimum_refinement_function.prm.bak
 create mode 100644 tests/minimum_refinement_function_cartesian.prm.bak
 create mode 100644 tests/minimum_refinement_function_spherical.prm.bak
 create mode 100644 tests/minimum_refinement_function_time_dependent.prm.bak
 create mode 100644 tests/modified_tait_forsterite_box.prm.bak
 create mode 100644 tests/morency_doin.cc.bak
 create mode 100644 tests/morency_doin.prm.bak
 create mode 100644 tests/multicomponent_arithmetic.prm.bak
 create mode 100644 tests/multicomponent_compressible_averaging.prm.bak
 create mode 100644 tests/multicomponent_geometric.prm.bak
 create mode 100644 tests/multicomponent_harmonic.prm.bak
 create mode 100644 tests/multicomponent_max_composition.prm.bak
 create mode 100644 tests/multicomponent_steinberger.prm.bak
 create mode 100644 tests/multiple_named_additional_outputs.cc.bak
 create mode 100644 tests/multiple_named_additional_outputs.prm.bak
 create mode 100644 tests/muparser-temperature-example.prm.bak
 create mode 100644 tests/n_expensive_stokes_solver_steps.prm.bak
 create mode 100644 tests/natural_coordinates_conversion.cc.bak
 create mode 100644 tests/natural_coordinates_conversion.prm.bak
 create mode 100644 tests/netcdf_boundary_velocity_2d_box.prm.bak
 create mode 100644 tests/newton_postprocess_nonlinear.prm.bak
 create mode 100644 tests/no_Advection_iterated_defect_correction_Stokes.prm.bak
 create mode 100644 tests/no_adiabatic_heating.cc.bak
 create mode 100644 tests/no_adiabatic_heating.prm.bak
 create mode 100644 tests/no_adiabatic_heating_02.cc.bak
 create mode 100644 tests/no_adiabatic_heating_02.prm.bak
 create mode 100644 tests/no_adiabatic_heating_03.cc.bak
 create mode 100644 tests/no_adiabatic_heating_03.prm.bak
 create mode 100644 tests/no_cheap_gmg.cc.bak
 create mode 100644 tests/no_cheap_gmg.prm.bak
 create mode 100644 tests/no_conduction_timestep.prm.bak
 create mode 100644 tests/no_dirichlet_on_outflow.prm.bak
 create mode 100644 tests/no_dirichlet_on_outflow_C.prm.bak
 create mode 100644 tests/no_dirichlet_on_outflow_adaptive.prm.bak
 create mode 100644 tests/no_dirichlet_on_outflow_melt.cc.bak
 create mode 100644 tests/no_dirichlet_on_outflow_melt.prm.bak
 create mode 100644 tests/no_dirichlet_on_outflow_only_new_constraints.prm.bak
 create mode 100644 tests/no_dirichlet_on_outflow_refine.prm.bak
 create mode 100644 tests/no_flow.prm.bak
 create mode 100644 tests/non_conservative_with_mpi.cc.bak
 create mode 100644 tests/non_conservative_with_mpi.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_iterated_IMPES.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_tractions_iterated_IMPES.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_iterated_IMPES.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_iterated_IMPES.prm.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.cc.bak
 create mode 100644 tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.prm.bak
 create mode 100644 tests/nonlinear_convergence_for_small_composition.cc.bak
 create mode 100644 tests/nonlinear_convergence_for_small_composition.prm.bak
 create mode 100644 tests/nonlinear_solver_history.cc.bak
 create mode 100644 tests/nonlinear_solver_history.prm.bak
 create mode 100644 tests/normalize_initial_composition.prm.bak
 create mode 100644 tests/normalize_pressure_volume.prm.bak
 create mode 100644 tests/nsinker.cc.bak
 create mode 100644 tests/nsinker.prm.bak
 create mode 100644 tests/nsinker_2d.cc.bak
 create mode 100644 tests/nsinker_2d.prm.bak
 create mode 100644 tests/nsinker_bfbt.cc.bak
 create mode 100644 tests/nsinker_bfbt.prm.bak
 create mode 100644 tests/nsinker_gmg_idr.cc.bak
 create mode 100644 tests/nsinker_gmg_idr.prm.bak
 create mode 100644 tests/octagonal_initial_temperature.prm.bak
 create mode 100644 tests/octagonal_initial_temperature_ellipsoidal_chunk.prm.bak
 create mode 100644 tests/octagonal_initial_temperature_rotated.prm.bak
 create mode 100644 tests/onset_of_convection.prm.bak
 create mode 100644 tests/original_prm.prm.bak
 create mode 100644 tests/original_prm/original.prm.bak
 create mode 100644 tests/output_averaging_arithmetic.cc.bak
 create mode 100644 tests/output_averaging_arithmetic.prm.bak
 create mode 100644 tests/output_averaging_harmonic.cc.bak
 create mode 100644 tests/output_averaging_harmonic.prm.bak
 create mode 100644 tests/own_gravity.cc.bak
 create mode 100644 tests/own_gravity.prm.bak
 create mode 100644 tests/parallel_output_group_0.prm.bak
 create mode 100644 tests/parallel_output_group_1.prm.bak
 create mode 100644 tests/parallel_output_group_2.prm.bak
 create mode 100644 tests/parallel_refine_crash.prm.bak
 create mode 100644 tests/particle_count_statistics.cc.bak
 create mode 100644 tests/particle_count_statistics.prm.bak
 create mode 100644 tests/particle_exclude_all_properties.prm.bak
 create mode 100644 tests/particle_exclude_one_property.prm.bak
 create mode 100644 tests/particle_exclude_one_property_vtu.prm.bak
 create mode 100644 tests/particle_exclude_three_properties_vtu.prm.bak
 create mode 100644 tests/particle_exclude_two_properties_vtu.prm.bak
 create mode 100644 tests/particle_fast_evaluate_many_compositions.prm.bak
 create mode 100644 tests/particle_fast_evaluate_multiple_compositions.prm.bak
 create mode 100644 tests/particle_free_surface.prm.bak
 create mode 100644 tests/particle_generator_ascii.prm.bak
 create mode 100644 tests/particle_generator_box.prm.bak
 create mode 100644 tests/particle_generator_box_3d.prm.bak
 create mode 100644 tests/particle_generator_quadrature_points.prm.bak
 create mode 100644 tests/particle_generator_radial.prm.bak
 create mode 100644 tests/particle_generator_random_uniform.prm.bak
 create mode 100644 tests/particle_generator_random_uniform_3mpi_1particle.prm.bak
 create mode 100644 tests/particle_generator_random_uniform_3mpi_2particle.prm.bak
 create mode 100644 tests/particle_generator_random_uniform_3mpi_3particle.prm.bak
 create mode 100644 tests/particle_generator_random_uniform_3mpi_4particle.prm.bak
 create mode 100644 tests/particle_generator_random_uniform_deterministic_cell.prm.bak
 create mode 100644 tests/particle_generator_random_uniform_empty_rank.prm.bak
 create mode 100644 tests/particle_generator_reference_cell.prm.bak
 create mode 100644 tests/particle_handler_copy.cc.bak
 create mode 100644 tests/particle_handler_copy.prm.bak
 create mode 100644 tests/particle_initial_adaptive_output.prm.bak
 create mode 100644 tests/particle_initial_adaptive_refinement.prm.bak
 create mode 100644 tests/particle_integrator_euler.prm.bak
 create mode 100644 tests/particle_integrator_rk2_first_order_time.prm.bak
 create mode 100644 tests/particle_integrator_rk4.prm.bak
 create mode 100644 tests/particle_interpolator_bilinear_3d.prm.bak
 create mode 100644 tests/particle_interpolator_bilinear_3d_add_particles.prm.bak
 create mode 100644 tests/particle_interpolator_bilinear_add_particles.cc.bak
 create mode 100644 tests/particle_interpolator_bilinear_add_particles.prm.bak
 create mode 100644 tests/particle_interpolator_bilinear_least_squares_solkz.cc.bak
 create mode 100644 tests/particle_interpolator_bilinear_least_squares_solkz.prm.bak
 create mode 100644 tests/particle_interpolator_bilinear_limiter.prm.bak
 create mode 100644 tests/particle_interpolator_cell_average.prm.bak
 create mode 100644 tests/particle_interpolator_cell_average_2.prm.bak
 create mode 100644 tests/particle_interpolator_empty_cells.prm.bak
 create mode 100644 tests/particle_interpolator_from_ghost_cells.prm.bak
 create mode 100644 tests/particle_interpolator_harmonic_average_solkz.cc.bak
 create mode 100644 tests/particle_interpolator_harmonic_average_solkz.prm.bak
 create mode 100644 tests/particle_interpolator_nearest_neighbor.prm.bak
 create mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_add_particles.cc.bak
 create mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm.bak
 create mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_limiter.cc.bak
 create mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_limiter.prm.bak
 create mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_periodic.prm.bak
 create mode 100644 tests/particle_interpolator_quadratic_least_squares_3d.prm.bak
 create mode 100644 tests/particle_interpolator_time_dependence.prm.bak
 create mode 100644 tests/particle_linear_accelerated_flow_rk2.prm.bak
 create mode 100644 tests/particle_load_balancing_none.prm.bak
 create mode 100644 tests/particle_load_balancing_refinement.prm.bak
 create mode 100644 tests/particle_load_balancing_refinement_02.prm.bak
 create mode 100644 tests/particle_load_balancing_removal.prm.bak
 create mode 100644 tests/particle_load_balancing_removal_addition.prm.bak
 create mode 100644 tests/particle_load_balancing_removal_addition_properties.prm.bak
 create mode 100644 tests/particle_load_balancing_repartition.prm.bak
 create mode 100644 tests/particle_load_balancing_repartition_1000.prm.bak
 create mode 100644 tests/particle_melt_advection.cc.bak
 create mode 100644 tests/particle_melt_advection.prm.bak
 create mode 100644 tests/particle_output_gnuplot.prm.bak
 create mode 100644 tests/particle_output_hdf5.prm.bak
 create mode 100644 tests/particle_output_multiple_formats.prm.bak
 create mode 100644 tests/particle_output_none.prm.bak
 create mode 100644 tests/particle_output_vtu.prm.bak
 create mode 100644 tests/particle_output_vtu_group.prm.bak
 create mode 100644 tests/particle_output_vtu_temp.prm.bak
 create mode 100644 tests/particle_periodic_boundaries.prm.bak
 create mode 100644 tests/particle_periodic_boundaries_dc.prm.bak
 create mode 100644 tests/particle_periodic_boundaries_rk4.prm.bak
 create mode 100644 tests/particle_periodic_quarter_shell.prm.bak
 create mode 100644 tests/particle_periodic_quarter_shell_2.prm.bak
 create mode 100644 tests/particle_property_composition.cc.bak
 create mode 100644 tests/particle_property_composition.prm.bak
 create mode 100644 tests/particle_property_function.prm.bak
 create mode 100644 tests/particle_property_initial_composition.prm.bak
 create mode 100644 tests/particle_property_initial_composition_boundary.prm.bak
 create mode 100644 tests/particle_property_integrated_strain_invariant.prm.bak
 create mode 100644 tests/particle_property_integrated_strain_pure_shear.prm.bak
 create mode 100644 tests/particle_property_integrated_strain_simple_shear.prm.bak
 create mode 100644 tests/particle_property_multiple_functions.prm.bak
 create mode 100644 tests/particle_property_multiple_functions_with_interpolation.prm.bak
 create mode 100644 tests/particle_property_post_initialize_function.cc.bak
 create mode 100644 tests/particle_property_post_initialize_function.prm.bak
 create mode 100644 tests/particle_timing_information.prm.bak
 create mode 100644 tests/particle_visualization_particle_count.prm.bak
 create mode 100644 tests/particles_with_AMR_on.prm.bak
 create mode 100644 tests/passive_comp.prm.bak
 create mode 100644 tests/periodic_box.prm.bak
 create mode 100644 tests/periodic_box2.prm.bak
 create mode 100644 tests/periodic_box_freesurface.prm.bak
 create mode 100644 tests/periodic_box_gmg.prm.bak
 create mode 100644 tests/periodic_box_mpi4.prm.bak
 create mode 100644 tests/periodic_compressible.prm.bak
 create mode 100644 tests/periodic_linear_momentum.prm.bak
 create mode 100644 tests/periodic_quarter_shell.prm.bak
 create mode 100644 tests/plugin.cc.bak
 create mode 100644 tests/plugin.prm.bak
 create mode 100644 tests/plugin_dependency.cc.bak
 create mode 100644 tests/plugin_dependency.prm.bak
 create mode 100644 tests/plugin_dependency_redundant.cc.bak
 create mode 100644 tests/plugin_dependency_redundant.prm.bak
 create mode 100644 tests/plugin_dependency_redundant_02.cc.bak
 create mode 100644 tests/plugin_dependency_redundant_02.prm.bak
 create mode 100644 tests/point_value_01.prm.bak
 create mode 100644 tests/point_value_02.prm.bak
 create mode 100644 tests/point_value_02_mpi.prm.bak
 create mode 100644 tests/point_value_03.prm.bak
 create mode 100644 tests/point_value_natural_coordinates.prm.bak
 create mode 100644 tests/point_value_natural_coordinates_shell.prm.bak
 create mode 100644 tests/point_value_specific_output_times.prm.bak
 create mode 100644 tests/poiseuille_2d.prm.bak
 create mode 100644 tests/poiseuille_2d_horizontal_pressure_bc.prm.bak
 create mode 100644 tests/poiseuille_2d_pressure_bc.prm.bak
 create mode 100644 tests/poiseuille_2d_pressure_bc_gmg.prm.bak
 create mode 100644 tests/poiseuille_3d_x_horizontal_pressure_bc.prm.bak
 create mode 100644 tests/postprocess_initial.prm.bak
 create mode 100644 tests/postprocess_iterations_Stokes_only.cc.bak
 create mode 100644 tests/postprocess_iterations_Stokes_only.prm.bak
 create mode 100644 tests/postprocess_iterations_iterated_Stokes.cc.bak
 create mode 100644 tests/postprocess_iterations_iterated_Stokes.prm.bak
 create mode 100644 tests/postprocess_iterations_iterated_advection_and_stokes.prm.bak
 create mode 100644 tests/pre_data_out_build_patches.cc.bak
 create mode 100644 tests/pre_data_out_build_patches.prm.bak
 create mode 100644 tests/prescribed_dilation.cc.bak
 create mode 100644 tests/prescribed_dilation.prm.bak
 create mode 100644 tests/prescribed_dilation_gmg.cc.bak
 create mode 100644 tests/prescribed_dilation_gmg.prm.bak
 create mode 100644 tests/prescribed_dilation_newton.cc.bak
 create mode 100644 tests/prescribed_dilation_newton.prm.bak
 create mode 100644 tests/prescribed_dilation_newton_singleadvection.cc.bak
 create mode 100644 tests/prescribed_dilation_newton_singleadvection.prm.bak
 create mode 100644 tests/prescribed_field.cc.bak
 create mode 100644 tests/prescribed_field.prm.bak
 create mode 100644 tests/prescribed_field_temperature.cc.bak
 create mode 100644 tests/prescribed_field_temperature.prm.bak
 create mode 100644 tests/prescribed_field_temperature_max_isotherm.prm.bak
 create mode 100644 tests/prescribed_field_with_diffusion.cc.bak
 create mode 100644 tests/prescribed_field_with_diffusion.prm.bak
 create mode 100644 tests/prescribed_stokes_solution.prm.bak
 create mode 100644 tests/prescribed_stokes_solution_DG_periodic.prm.bak
 create mode 100644 tests/prescribed_stokes_solution_melt.prm.bak
 create mode 100644 tests/prescribed_temperature.cc.bak
 create mode 100644 tests/prescribed_temperature.prm.bak
 create mode 100644 tests/prescribed_temperature_in_field.cc.bak
 create mode 100644 tests/prescribed_temperature_in_field.prm.bak
 create mode 100644 tests/prescribed_temperature_with_diffusion.cc.bak
 create mode 100644 tests/prescribed_temperature_with_diffusion.prm.bak
 create mode 100644 tests/prescribed_velocity.cc.bak
 create mode 100644 tests/prescribed_velocity.prm.bak
 create mode 100644 tests/prescribed_velocity_boundary.cc.bak
 create mode 100644 tests/prescribed_velocity_boundary.prm.bak
 create mode 100644 tests/prescribed_velocity_dgp.cc.bak
 create mode 100644 tests/prescribed_velocity_dgp.prm.bak
 create mode 100644 tests/prescribed_viscosity_additional_outputs.prm.bak
 create mode 100644 tests/prescribed_viscosity_happy.prm.bak
 create mode 100644 tests/pressure_boundary.prm.bak
 create mode 100644 tests/pressure_compatibility.prm.bak
 create mode 100644 tests/pressure_compatibility_2.prm.bak
 create mode 100644 tests/pressure_compatibility_3.prm.bak
 create mode 100644 tests/pressure_compatibility_4.prm.bak
 create mode 100644 tests/pressure_compatibility_dg.prm.bak
 create mode 100644 tests/pressure_compatibility_dg_direct.prm.bak
 create mode 100644 tests/pressure_compatibility_direct.prm.bak
 create mode 100644 tests/pressure_constraint.cc.bak
 create mode 100644 tests/pressure_constraint.prm.bak
 create mode 100644 tests/pressure_scaling_signal.cc.bak
 create mode 100644 tests/pressure_scaling_signal.prm.bak
 create mode 100644 tests/principal_deviatoric_stress.cc.bak
 create mode 100644 tests/principal_deviatoric_stress.prm.bak
 create mode 100644 tests/prm_distance_polygon.cc.bak
 create mode 100644 tests/prm_distance_polygon.prm.bak
 create mode 100644 tests/prm_polygon_in_out.cc.bak
 create mode 100644 tests/prm_polygon_in_out.prm.bak
 create mode 100644 tests/prmbackslash.prm.bak
 create mode 100644 tests/prmbackslash_2.cc.bak
 create mode 100644 tests/prmbackslash_2.prm.bak
 create mode 100644 tests/projected_density_vertical_pipe.cc.bak
 create mode 100644 tests/projected_density_vertical_pipe.prm.bak
 create mode 100644 tests/pure_shear.cc.bak
 create mode 100644 tests/pure_shear.prm.bak
 create mode 100644 tests/q1_q1.cc.bak
 create mode 100644 tests/q1_q1.prm.bak
 create mode 100644 tests/q1_q1_6.cc.bak
 create mode 100644 tests/q1_q1_6.prm.bak
 create mode 100644 tests/quarter_shell_variable_coordinate_systems_cartesian.prm.bak
 create mode 100644 tests/quarter_shell_variable_coordinate_systems_depth.prm.bak
 create mode 100644 tests/quarter_shell_variable_coordinate_systems_spherical.prm.bak
 create mode 100644 tests/quick_mpi.cc.bak
 create mode 100644 tests/quick_mpi.prm.bak
 create mode 100644 tests/radioactive_decay.prm.bak
 create mode 100644 tests/radiogenic_heating.prm.bak
 create mode 100644 tests/random_perturbation_box.prm.bak
 create mode 100644 tests/random_perturbation_chunk.prm.bak
 create mode 100644 tests/random_perturbation_merged_boxes.prm.bak
 create mode 100644 tests/random_perturbation_sphere.prm.bak
 create mode 100644 tests/random_perturbation_spherical_shell.prm.bak
 create mode 100644 tests/reactive_fluid_transport_no_reaction.prm.bak
 create mode 100644 tests/reactive_fluid_transport_zero_solubility.prm.bak
 create mode 100644 tests/refine_vel.prm.bak
 create mode 100644 tests/refinement_artificial_viscosity_1.prm.bak
 create mode 100644 tests/refinement_artificial_viscosity_2.prm.bak
 create mode 100644 tests/refinement_artificial_viscosity_3.prm.bak
 create mode 100644 tests/refinement_boundary.prm.bak
 create mode 100644 tests/refinement_composition_gradient.prm.bak
 create mode 100644 tests/refinement_composition_threshold.prm.bak
 create mode 100644 tests/refinement_nonadiabatic_temperature.prm.bak
 create mode 100644 tests/refinement_strainrate.prm.bak
 create mode 100644 tests/refinement_switch.prm.bak
 create mode 100644 tests/refinement_topography.cc.bak
 create mode 100644 tests/refinement_topography.prm.bak
 create mode 100644 tests/remove_angular_momentum.prm.bak
 create mode 100644 tests/remove_angular_momentum_3d.prm.bak
 create mode 100644 tests/remove_net_rotation.prm.bak
 create mode 100644 tests/remove_net_rotation_3d.prm.bak
 create mode 100644 tests/remove_net_surface_rotation.prm.bak
 create mode 100644 tests/replace_lithosphere_viscosity_file.prm.bak
 create mode 100644 tests/resume_free_surface.cc.bak
 create mode 100644 tests/resume_free_surface.prm.bak
 create mode 100644 tests/rheology_scaled_profile.cc.bak
 create mode 100644 tests/rheology_scaled_profile.prm.bak
 create mode 100644 tests/rigid_shear_instantaneous.cc.bak
 create mode 100644 tests/rigid_shear_instantaneous.prm.bak
 create mode 100644 tests/rigid_shear_steady_state.cc.bak
 create mode 100644 tests/rigid_shear_steady_state.prm.bak
 create mode 100644 tests/rigid_shear_transient.cc.bak
 create mode 100644 tests/rigid_shear_transient.prm.bak
 create mode 100644 tests/rising_melt_blob.cc.bak
 create mode 100644 tests/rising_melt_blob.prm.bak
 create mode 100644 tests/rising_melt_blob_freezing.prm.bak
 create mode 100644 tests/rotation_statistics.prm.bak
 create mode 100644 tests/rotation_statistics_3d.prm.bak
 create mode 100644 tests/rotation_statistics_3d_asymmetric.prm.bak
 create mode 100644 tests/rotation_statistics_3d_surface.prm.bak
 create mode 100644 tests/sea_level_postprocessor.prm.bak
 create mode 100644 tests/segregation_heating.cc.bak
 create mode 100644 tests/segregation_heating.prm.bak
 create mode 100644 tests/shear_bands.cc.bak
 create mode 100644 tests/shear_bands.prm.bak
 create mode 100644 tests/shear_heating.prm.bak
 create mode 100644 tests/shear_heating_compressible.prm.bak
 create mode 100644 tests/shear_heating_compressible_melt.prm.bak
 create mode 100644 tests/shear_heating_limited.prm.bak
 create mode 100644 tests/shear_heating_with_melt.prm.bak
 create mode 100644 tests/shear_thinning.cc.bak
 create mode 100644 tests/shear_thinning.prm.bak
 create mode 100644 tests/shearbox_particle_strain_rate.prm.bak
 create mode 100644 tests/shell_2d_gmg.prm.bak
 create mode 100644 tests/shell_3d_gmg.prm.bak
 create mode 100644 tests/shell_boundary_composition_spherical_constant.prm.bak
 create mode 100644 tests/shell_quarter_BC.prm.bak
 create mode 100644 tests/shell_quarter_gmg.prm.bak
 create mode 100644 tests/shell_surface_base_variables.prm.bak
 create mode 100644 tests/shell_with_variable_coordinate_systems.prm.bak
 create mode 100644 tests/signal_fem.cc.bak
 create mode 100644 tests/signal_fem.prm.bak
 create mode 100644 tests/signals.cc.bak
 create mode 100644 tests/signals.prm.bak
 create mode 100644 tests/signals_connect.cc.bak
 create mode 100644 tests/signals_connect.prm.bak
 create mode 100644 tests/signals_post_constraints.cc.bak
 create mode 100644 tests/signals_post_constraints.prm.bak
 create mode 100644 tests/simple_composite.prm.bak
 create mode 100644 tests/simple_compressibility_iterated_stokes.cc.bak
 create mode 100644 tests/simple_compressibility_iterated_stokes.prm.bak
 create mode 100644 tests/simple_compressibility_iterated_stokes_gmg.cc.bak
 create mode 100644 tests/simple_compressibility_iterated_stokes_gmg.prm.bak
 create mode 100644 tests/simple_compressible.prm.bak
 create mode 100644 tests/simple_incompressible.prm.bak
 create mode 100644 tests/simple_nonlinear.cc.bak
 create mode 100644 tests/simple_nonlinear.prm.bak
 create mode 100644 tests/simple_shear.cc.bak
 create mode 100644 tests/simple_shear.prm.bak
 create mode 100644 tests/simple_shear_output_the_mobility.cc.bak
 create mode 100644 tests/simple_shear_output_the_mobility.prm.bak
 create mode 100644 tests/simpler_box.prm.bak
 create mode 100644 tests/simpler_composition.prm.bak
 create mode 100644 tests/single_Advection_iterated_defect_correction_Stokes.prm.bak
 create mode 100644 tests/sinking_block.cc.bak
 create mode 100644 tests/sinking_block.prm.bak
 create mode 100644 tests/skip_initial_conditions_setup_on_initial_refinement.prm.bak
 create mode 100644 tests/skip_refinement.prm.bak
 create mode 100644 tests/skip_solvers_on_initial_refinement.prm.bak
 create mode 100644 tests/slab2_initial_composition_3d_shell.prm.bak
 create mode 100644 tests/slab_tip_depth.prm.bak
 create mode 100644 tests/slope_refinement.prm.bak
 create mode 100644 tests/smoothing.prm.bak
 create mode 100644 tests/smoothing_composition_passive.prm.bak
 create mode 100644 tests/sol_cx_2.cc.bak
 create mode 100644 tests/sol_cx_2.prm.bak
 create mode 100644 tests/sol_cx_2_conservative.cc.bak
 create mode 100644 tests/sol_cx_2_conservative.prm.bak
 create mode 100644 tests/sol_cx_2_equal_order.cc.bak
 create mode 100644 tests/sol_cx_2_equal_order.prm.bak
 create mode 100644 tests/sol_cx_2_gmg.cc.bak
 create mode 100644 tests/sol_cx_2_gmg.prm.bak
 create mode 100644 tests/sol_cx_2_normalized_pressure.cc.bak
 create mode 100644 tests/sol_cx_2_normalized_pressure.prm.bak
 create mode 100644 tests/sol_cx_2_q3.cc.bak
 create mode 100644 tests/sol_cx_2_q3.prm.bak
 create mode 100644 tests/sol_cx_4.cc.bak
 create mode 100644 tests/sol_cx_4.prm.bak
 create mode 100644 tests/sol_cx_4_conservative.cc.bak
 create mode 100644 tests/sol_cx_4_conservative.prm.bak
 create mode 100644 tests/sol_cx_4_equal_order.cc.bak
 create mode 100644 tests/sol_cx_4_equal_order.prm.bak
 create mode 100644 tests/sol_cx_4_gmg.cc.bak
 create mode 100644 tests/sol_cx_4_gmg.prm.bak
 create mode 100644 tests/sol_cx_4_normalized_pressure.cc.bak
 create mode 100644 tests/sol_cx_4_normalized_pressure.prm.bak
 create mode 100644 tests/sol_cx_4_normalized_pressure_large_static_pressure.cc.bak
 create mode 100644 tests/sol_cx_4_normalized_pressure_large_static_pressure.prm.bak
 create mode 100644 tests/sol_cx_4_normalized_pressure_low_solver_tolerance.cc.bak
 create mode 100644 tests/sol_cx_4_normalized_pressure_low_solver_tolerance.prm.bak
 create mode 100644 tests/sol_cx_mpi_2.cc.bak
 create mode 100644 tests/sol_cx_mpi_2.prm.bak
 create mode 100644 tests/sol_cx_newton_crash.cc.bak
 create mode 100644 tests/sol_cx_newton_crash.prm.bak
 create mode 100644 tests/sol_cx_particles.cc.bak
 create mode 100644 tests/sol_cx_particles.prm.bak
 create mode 100644 tests/sol_kz_2.cc.bak
 create mode 100644 tests/sol_kz_2.prm.bak
 create mode 100644 tests/sol_kz_2_cheaper_first_phase_solver.cc.bak
 create mode 100644 tests/sol_kz_2_cheaper_first_phase_solver.prm.bak
 create mode 100644 tests/sol_kz_2_conservative.cc.bak
 create mode 100644 tests/sol_kz_2_conservative.prm.bak
 create mode 100644 tests/sol_kz_2_no_first_phase_solver.cc.bak
 create mode 100644 tests/sol_kz_2_no_first_phase_solver.prm.bak
 create mode 100644 tests/sol_kz_2_project_q1_only_visc.cc.bak
 create mode 100644 tests/sol_kz_2_project_q1_only_visc.prm.bak
 create mode 100644 tests/sol_kz_2_q3.cc.bak
 create mode 100644 tests/sol_kz_2_q3.prm.bak
 create mode 100644 tests/sol_kz_4.cc.bak
 create mode 100644 tests/sol_kz_4.prm.bak
 create mode 100644 tests/sol_kz_4_conservative.cc.bak
 create mode 100644 tests/sol_kz_4_conservative.prm.bak
 create mode 100644 tests/solidus_initial_conditions.cc.bak
 create mode 100644 tests/solidus_initial_conditions.prm.bak
 create mode 100644 tests/solitary_wave.cc.bak
 create mode 100644 tests/solitary_wave.prm.bak
 create mode 100644 tests/solubility.cc.bak
 create mode 100644 tests/solubility.prm.bak
 create mode 100644 tests/solve_no_advection_no_stokes.prm.bak
 create mode 100644 tests/solver_history.cc.bak
 create mode 100644 tests/solver_history.prm.bak
 create mode 100644 tests/solver_scheme_no_advection_single_stokes.cc.bak
 create mode 100644 tests/solver_scheme_no_advection_single_stokes.prm.bak
 create mode 100644 tests/spectral_comparison.prm.bak
 create mode 100644 tests/spherical_constant_boundary_3d_sphere.prm.bak
 create mode 100644 tests/spherical_nsinker.cc.bak
 create mode 100644 tests/spherical_nsinker.prm.bak
 create mode 100644 tests/spherical_shell_initial_topography_ascii_data_3d.prm.bak
 create mode 100644 tests/spherical_shell_initial_topography_function_3d.prm.bak
 create mode 100644 tests/spherical_velocity_statistics.prm.bak
 create mode 100644 tests/spiegelman_fail_test.cc.bak
 create mode 100644 tests/spiegelman_fail_test.prm.bak
 create mode 100644 tests/spiegelman_material.cc.bak
 create mode 100644 tests/spiegelman_material.prm.bak
 create mode 100644 tests/splines.cc.bak
 create mode 100644 tests/splines.prm.bak
 create mode 100644 tests/static_temperature.prm.bak
 create mode 100644 tests/statistics_output.prm.bak
 create mode 100644 tests/steinberger_averaging.prm.bak
 create mode 100644 tests/steinberger_background.prm.bak
 create mode 100644 tests/steinberger_compressible.prm.bak
 create mode 100644 tests/steinberger_compressible_gmg.prm.bak
 create mode 100644 tests/steinberger_conductivity.prm.bak
 create mode 100644 tests/steinberger_conductivity_tosi.prm.bak
 create mode 100644 tests/steinberger_continuous_viscosity.prm.bak
 create mode 100644 tests/steinberger_cookbook.prm.bak
 create mode 100644 tests/steinberger_latent_heat.prm.bak
 create mode 100644 tests/steinberger_latent_heat_2.prm.bak
 create mode 100644 tests/steinberger_lateral_fail.prm.bak
 create mode 100644 tests/steinberger_phase_fractions.prm.bak
 create mode 100644 tests/steinberger_phase_fractions_background.prm.bak
 create mode 100644 tests/steinberger_phases.prm.bak
 create mode 100644 tests/steinberger_phases_2_lookups.prm.bak
 create mode 100644 tests/steinberger_phases_hefesto.prm.bak
 create mode 100644 tests/steinberger_projected_density.prm.bak
 create mode 100644 tests/steinberger_projected_density_dcPicard.prm.bak
 create mode 100644 tests/steinberger_seismic_velocities.prm.bak
 create mode 100644 tests/steinberger_several_fields.prm.bak
 create mode 100644 tests/steinberger_single_field.prm.bak
 create mode 100644 tests/steinberger_viscosity.prm.bak
 create mode 100644 tests/steinberger_viscosity_adiabatic.prm.bak
 create mode 100644 tests/stokes.prm.bak
 create mode 100644 tests/stokes_residual.prm.bak
 create mode 100644 tests/stokes_residual_cheap.prm.bak
 create mode 100644 tests/stokes_solver_fail.prm.bak
 create mode 100644 tests/stokes_solver_fail_A.prm.bak
 create mode 100644 tests/stokes_solver_fail_S.prm.bak
 create mode 100644 tests/stokes_solver_fail_cheap.prm.bak
 create mode 100644 tests/stokes_solver_fail_gmg.prm.bak
 create mode 100644 tests/stress_vs_surface_stress.cc.bak
 create mode 100644 tests/stress_vs_surface_stress.prm.bak
 create mode 100644 tests/stress_vs_surface_stress_point_values.cc.bak
 create mode 100644 tests/stress_vs_surface_stress_point_values.prm.bak
 create mode 100644 tests/subduction_initiation_compositional_fields.prm.bak
 create mode 100644 tests/supg-compositional-passive.prm.bak
 create mode 100644 tests/supg.prm.bak
 create mode 100644 tests/surface_elevation_box_ascii_data.prm.bak
 create mode 100644 tests/surface_elevation_box_ascii_data_moved_origin.prm.bak
 create mode 100644 tests/surface_elevation_box_function.prm.bak
 create mode 100644 tests/surface_elevation_box_prm_polygon.prm.bak
 create mode 100644 tests/surface_elevation_chunk_ascii_data.prm.bak
 create mode 100644 tests/surface_elevation_chunk_ascii_data_3d.prm.bak
 create mode 100644 tests/surface_elevation_chunk_ascii_data_3d_colatitude.prm.bak
 create mode 100644 tests/surface_elevation_chunk_ascii_data_global_3d.prm.bak
 create mode 100644 tests/surface_elevation_spherical_shell_ascii_data_global_3d.prm.bak
 create mode 100644 tests/surface_stress_strainrate_3d.cc.bak
 create mode 100644 tests/surface_stress_strainrate_3d.prm.bak
 create mode 100644 tests/symbolic_boundary_names_box.prm.bak
 create mode 100644 tests/symbolic_boundary_names_box_constant_bc.prm.bak
 create mode 100644 tests/symbolic_boundary_names_spherical_shell_2d_180_degrees.prm.bak
 create mode 100644 tests/symbolic_boundary_names_spherical_shell_2d_90_degrees.prm.bak
 create mode 100644 tests/symbolic_boundary_names_spherical_shell_2d_full.prm.bak
 create mode 100644 tests/symbolic_boundary_names_spherical_shell_3d_90_degrees.prm.bak
 create mode 100644 tests/symbolic_boundary_names_spherical_shell_3d_full.prm.bak
 create mode 100644 tests/tangurnis.cc.bak
 create mode 100644 tests/tangurnis_ba.cc.bak
 create mode 100644 tests/tangurnis_ba.prm.bak
 create mode 100644 tests/tangurnis_ba_custom.cc.bak
 create mode 100644 tests/tangurnis_ba_custom.prm.bak
 create mode 100644 tests/tangurnis_tala.cc.bak
 create mode 100644 tests/tangurnis_tala.prm.bak
 create mode 100644 tests/tangurnis_tala_c.cc.bak
 create mode 100644 tests/tangurnis_tala_c.prm.bak
 create mode 100644 tests/tangurnis_tala_gmg.cc.bak
 create mode 100644 tests/tangurnis_tala_gmg.prm.bak
 create mode 100644 tests/tangurnis_tala_implicit.cc.bak
 create mode 100644 tests/tangurnis_tala_implicit.prm.bak
 create mode 100644 tests/temperature_dependent_stokes_matrix.prm.bak
 create mode 100644 tests/terminate_user_request.cc.bak
 create mode 100644 tests/terminate_user_request.prm.bak
 create mode 100644 tests/thermal_alpha_s40rts.prm.bak
 create mode 100644 tests/tian_MORB.prm.bak
 create mode 100644 tests/tian_gabbro.prm.bak
 create mode 100644 tests/tian_peridotite.prm.bak
 create mode 100644 tests/tian_sediment.prm.bak
 create mode 100644 tests/time_dependent_annulus.cc.bak
 create mode 100644 tests/time_dependent_annulus.prm.bak
 create mode 100644 tests/time_dependent_temperature_bc.cc.bak
 create mode 100644 tests/time_dependent_temperature_bc.prm.bak
 create mode 100644 tests/time_dependent_temperature_bc_2.cc.bak
 create mode 100644 tests/time_dependent_temperature_bc_2.prm.bak
 create mode 100644 tests/time_stepping_fail.prm.bak
 create mode 100644 tests/time_stepping_function.prm.bak
 create mode 100644 tests/time_stepping_min.prm.bak
 create mode 100644 tests/time_stepping_repeat.prm.bak
 create mode 100644 tests/time_stepping_repeat_particles.prm.bak
 create mode 100644 tests/time_stepping_repeat_particles_iterated_advection.prm.bak
 create mode 100644 tests/tomography_based_plate_motions_cookbook.cc.bak
 create mode 100644 tests/tomography_based_plate_motions_cookbook.prm.bak
 create mode 100644 tests/topo_box.prm.bak
 create mode 100644 tests/topo_chunk.prm.bak
 create mode 100644 tests/topo_shell.prm.bak
 create mode 100644 tests/tosi_benchmark.cc.bak
 create mode 100644 tests/tosi_benchmark.prm.bak
 create mode 100644 tests/tosi_benchmark_gmg_dc_picard_solver.cc.bak
 create mode 100644 tests/tosi_benchmark_gmg_dc_picard_solver.prm.bak
 create mode 100644 tests/tosi_benchmark_gmg_newton_solver.cc.bak
 create mode 100644 tests/tosi_benchmark_gmg_newton_solver.prm.bak
 create mode 100644 tests/tosi_benchmark_newton_solver.cc.bak
 create mode 100644 tests/tosi_benchmark_newton_solver.prm.bak
 create mode 100644 tests/tosi_benchmark_newton_solver_full_A.cc.bak
 create mode 100644 tests/tosi_benchmark_newton_solver_full_A.prm.bak
 create mode 100644 tests/traction_ascii_data.prm.bak
 create mode 100644 tests/traction_multiple_model.prm.bak
 create mode 100644 tests/transform_fault_behn_2007.prm.bak
 create mode 100644 tests/two_merged_boxes_free_surface.prm.bak
 create mode 100644 tests/uncoupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
 create mode 100644 tests/update_script.cc.bak
 create mode 100644 tests/update_script_2.cc.bak
 create mode 100644 tests/update_script_2/updated2.prm.bak
 create mode 100644 tests/upwelling_melting_peridotite.prm.bak
 create mode 100644 tests/upwelling_melting_peridotite_compressible.prm.bak
 create mode 100644 tests/upwelling_melting_pyroxenite.prm.bak
 create mode 100644 tests/use_full_A_block_preconditioner.prm.bak
 create mode 100644 tests/van_keken_smooth_particle.prm.bak
 create mode 100644 tests/vankeken_subduction.cc.bak
 create mode 100644 tests/vankeken_subduction.prm.bak
 create mode 100644 tests/var_declaration_expansion.cc.bak
 create mode 100644 tests/var_declaration_expansion.prm.bak
 create mode 100644 tests/velocity_boundary_statistics.prm.bak
 create mode 100644 tests/velocity_divergence.cc.bak
 create mode 100644 tests/velocity_divergence.prm.bak
 create mode 100644 tests/velocity_in_years.prm.bak
 create mode 100644 tests/vep_chemical_compositions.prm.bak
 create mode 100644 tests/vis_velocity_in_years.prm.bak
 create mode 100644 tests/visco_elastic_top_beam.prm.bak
 create mode 100644 tests/visco_plastic.prm.bak
 create mode 100644 tests/visco_plastic_additional_plastic_outputs.prm.bak
 create mode 100644 tests/visco_plastic_adiabat_temperature.prm.bak
 create mode 100644 tests/visco_plastic_adiabatic_heating_density.prm.bak
 create mode 100644 tests/visco_plastic_adiabatic_pressure_in_viscous_creep.prm.bak
 create mode 100644 tests/visco_plastic_complex.prm.bak
 create mode 100644 tests/visco_plastic_composite.prm.bak
 create mode 100644 tests/visco_plastic_constant_viscosity_prefactor.prm.bak
 create mode 100644 tests/visco_plastic_derivatives_2d.cc.bak
 create mode 100644 tests/visco_plastic_derivatives_2d.prm.bak
 create mode 100644 tests/visco_plastic_derivatives_3d.cc.bak
 create mode 100644 tests/visco_plastic_derivatives_3d.prm.bak
 create mode 100644 tests/visco_plastic_diffusion.prm.bak
 create mode 100644 tests/visco_plastic_diffusion_dislocation_composite.prm.bak
 create mode 100644 tests/visco_plastic_dislocation.prm.bak
 create mode 100644 tests/visco_plastic_frank_kamenetskii.prm.bak
 create mode 100644 tests/visco_plastic_frank_kamenetskii_pressure.prm.bak
 create mode 100644 tests/visco_plastic_friction_function.prm.bak
 create mode 100644 tests/visco_plastic_gerya_2019_vp.prm.bak
 create mode 100644 tests/visco_plastic_newton_nonlinear_channelflow.prm.bak
 create mode 100644 tests/visco_plastic_peierls_cutoff_test.prm.bak
 create mode 100644 tests/visco_plastic_peierls_idrissi_exact.prm.bak
 create mode 100644 tests/visco_plastic_peierls_mei_exact.prm.bak
 create mode 100644 tests/visco_plastic_peierls_mei_viscosity_approx.prm.bak
 create mode 100644 tests/visco_plastic_peierls_strict_cutoff_test.prm.bak
 create mode 100644 tests/visco_plastic_phases.prm.bak
 create mode 100644 tests/visco_plastic_phases_compositions.prm.bak
 create mode 100644 tests/visco_plastic_phases_peierls_mei_exact.prm.bak
 create mode 100644 tests/visco_plastic_phases_plasticity.prm.bak
 create mode 100644 tests/visco_plastic_phases_temperature_limit_basalt.prm.bak
 create mode 100644 tests/visco_plastic_phases_temperature_limit_harzburgite.prm.bak
 create mode 100644 tests/visco_plastic_phases_temperature_limit_pyrolite.prm.bak
 create mode 100644 tests/visco_plastic_phases_temperature_limit_pyrolite_complicated.prm.bak
 create mode 100644 tests/visco_plastic_phases_viscosity.prm.bak
 create mode 100644 tests/visco_plastic_phases_viscosity_max_min.prm.bak
 create mode 100644 tests/visco_plastic_reference_density_profile.prm.bak
 create mode 100644 tests/visco_plastic_thermal_conductivity.prm.bak
 create mode 100644 tests/visco_plastic_total_strain_healing_temperature_dependent.prm.bak
 create mode 100644 tests/visco_plastic_track_noninitial_plastic_strain.prm.bak
 create mode 100644 tests/visco_plastic_vep_bending_beam.prm.bak
 create mode 100644 tests/visco_plastic_vep_brick_extension.prm.bak
 create mode 100644 tests/visco_plastic_vep_plate_flexure.prm.bak
 create mode 100644 tests/visco_plastic_vep_simple_shear.prm.bak
 create mode 100644 tests/visco_plastic_vep_stress_build-up.prm.bak
 create mode 100644 tests/visco_plastic_vep_stress_build-up_fixed_elastic_time_step.prm.bak
 create mode 100644 tests/visco_plastic_vep_stress_build-up_stress_averaging.prm.bak
 create mode 100644 tests/visco_plastic_vep_stress_build-up_yield.prm.bak
 create mode 100644 tests/visco_plastic_vep_stress_build-up_yield_particles.prm.bak
 create mode 100644 tests/visco_plastic_viscous_strain_weakening.prm.bak
 create mode 100644 tests/visco_plastic_yield.prm.bak
 create mode 100644 tests/visco_plastic_yield_max.prm.bak
 create mode 100644 tests/visco_plastic_yield_noninitial-plastic-strain_particles.prm.bak
 create mode 100644 tests/visco_plastic_yield_plastic_damper.prm.bak
 create mode 100644 tests/visco_plastic_yield_plastic_strain_weakening.prm.bak
 create mode 100644 tests/visco_plastic_yield_plastic_strain_weakening_particles.prm.bak
 create mode 100644 tests/visco_plastic_yield_plastic_viscous_strain_healing.prm.bak
 create mode 100644 tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm.bak
 create mode 100644 tests/visco_plastic_yield_plastic_viscous_strain_weakening_particles.prm.bak
 create mode 100644 tests/visco_plastic_yield_strain_weakening.prm.bak
 create mode 100644 tests/visco_plastic_yield_strain_weakening_compositions.prm.bak
 create mode 100644 tests/visco_plastic_yield_strain_weakening_defect_corr_stokes.prm.bak
 create mode 100644 tests/visco_plastic_yield_strain_weakening_full_strain_tensor.prm.bak
 create mode 100644 tests/visco_plastic_yield_strain_weakening_full_strain_tensor_3d.prm.bak
 create mode 100644 tests/visco_plastic_yield_strain_weakening_iterated_advection.prm.bak
 create mode 100644 tests/visco_plastic_yield_strain_weakening_no-advect_no_stokes.prm.bak
 create mode 100644 tests/visco_plastic_yield_strain_weakening_particles.prm.bak
 create mode 100644 tests/visco_plastic_yield_temperature_activated_viscous_strain_weakening.prm.bak
 create mode 100644 tests/visco_plastic_yield_total_strain_healing.prm.bak
 create mode 100644 tests/visco_plastic_yield_viscous_strain_weakening.prm.bak
 create mode 100644 tests/visco_plastic_yield_viscous_strain_weakening_particles.prm.bak
 create mode 100644 tests/viscoelastic_bending_beam.prm.bak
 create mode 100644 tests/viscoelastic_bending_beam_averaging.prm.bak
 create mode 100644 tests/viscoelastic_bending_beam_gmg.prm.bak
 create mode 100644 tests/viscoelastic_bending_beam_particles.prm.bak
 create mode 100644 tests/viscoelastic_bending_beam_principal_stress.prm.bak
 create mode 100644 tests/viscoelastic_fixed_elastic_time_step.prm.bak
 create mode 100644 tests/viscoelastic_numerical_elastic_time_step.prm.bak
 create mode 100644 tests/viscoelastic_numerical_elastic_time_step_particles.prm.bak
 create mode 100644 tests/viscoelastic_plate_flexure.prm.bak
 create mode 100644 tests/viscoelastic_sheared_torsion.prm.bak
 create mode 100644 tests/viscoelastic_stress_averaging.prm.bak
 create mode 100644 tests/viscoelastic_stress_build-up.prm.bak
 create mode 100644 tests/viscoelastic_stress_build-up_gmg.prm.bak
 create mode 100644 tests/viscoelastoplastic_yield_plastic_viscous_strain_weakening.prm.bak
 create mode 100644 tests/viscoplastic_melt_blob_freezing.prm.bak
 create mode 100644 tests/viscoplastic_melt_fraction.prm.bak
 create mode 100644 tests/viscosity_refinement.prm.bak
 create mode 100644 tests/viscous_dissipation_statistics.prm.bak
 create mode 100644 tests/viscous_top_beam.prm.bak
 create mode 100644 tests/visualization_averaged_strain_rate.prm.bak
 create mode 100644 tests/visualization_averaged_strain_rate2.prm.bak
 create mode 100644 tests/visualization_conductivity_diffusivity.prm.bak
 create mode 100644 tests/visualization_higher_order_output.prm.bak
 create mode 100644 tests/visualization_shear_stress.prm.bak
 create mode 100644 tests/visualization_shear_stress_pointwise.prm.bak
 create mode 100644 tests/visualization_shear_stress_viscoelastic.prm.bak
 create mode 100644 tests/visualization_strain_rate.prm.bak
 create mode 100644 tests/visualization_strain_rate_pointwise.prm.bak
 create mode 100644 tests/visualization_strain_rate_tensor.prm.bak
 create mode 100644 tests/visualization_strain_rate_tensor_pointwise.prm.bak
 create mode 100644 tests/visualization_stress.prm.bak
 create mode 100644 tests/visualization_stress_pointwise.prm.bak
 create mode 100644 tests/visualization_stress_viscoelastic.prm.bak
 create mode 100644 tests/visualization_temperature_anomaly.prm.bak
 create mode 100644 tests/visualization_unique_list.prm.bak
 create mode 100644 tests/visualization_vertical_heat_flux.prm.bak
 create mode 100644 tests/viz_mesh_deform_vector.prm.bak
 create mode 100644 tests/viz_plugin_dependency.cc.bak
 create mode 100644 tests/viz_plugin_dependency.prm.bak
 create mode 100644 tests/viz_spherical_velocity_components.prm.bak
 create mode 100644 tests/vof_circle_1.cc.bak
 create mode 100644 tests/vof_circle_1.prm.bak
 create mode 100644 tests/vof_circle_amr.cc.bak
 create mode 100644 tests/vof_circle_amr.prm.bak
 create mode 100644 tests/vof_circle_mpi.cc.bak
 create mode 100644 tests/vof_circle_mpi.prm.bak
 create mode 100644 tests/vof_circle_mpi_amr.cc.bak
 create mode 100644 tests/vof_circle_mpi_amr.prm.bak
 create mode 100644 tests/vof_composition_init.prm.bak
 create mode 100644 tests/vof_err_calc.h.bak
 create mode 100644 tests/vof_linear.cc.bak
 create mode 100644 tests/vof_linear.prm.bak
 create mode 100644 tests/vof_linear_2f.cc.bak
 create mode 100644 tests/vof_linear_2f.prm.bak
 create mode 100644 tests/vof_linear_amr.cc.bak
 create mode 100644 tests/vof_linear_amr.prm.bak
 create mode 100644 tests/vof_linear_amr_mpi.cc.bak
 create mode 100644 tests/vof_linear_amr_mpi.prm.bak
 create mode 100644 tests/vof_linear_inflow.prm.bak
 create mode 100644 tests/vof_linear_periodic.cc.bak
 create mode 100644 tests/vof_linear_periodic.prm.bak
 create mode 100644 tests/vof_linear_periodic_amr.cc.bak
 create mode 100644 tests/vof_linear_periodic_amr.prm.bak
 create mode 100644 tests/vof_mpi_amr_no_dof.prm.bak
 create mode 100644 tests/walltime.prm.bak
 create mode 100644 tests/weighted_p_norm_average.cc.bak
 create mode 100644 tests/world_builder_select_composition.prm.bak
 create mode 100644 tests/world_builder_select_grains.prm.bak
 create mode 100644 tests/world_builder_simple.prm.bak
 create mode 100644 tests/world_builder_simple_2d_cartesian_sticky_air.prm.bak
 create mode 100644 tests/write_plugin_graph.cc.bak
 create mode 100644 tests/write_plugin_graph.prm.bak
 create mode 100644 tests/zero_RHS.prm.bak
 create mode 100644 tests/zero_matrix.prm.bak
 create mode 100644 tests/zero_temperature.prm.bak
 create mode 100644 unit_tests/additional_outputs.cc.bak
 create mode 100644 unit_tests/common.h.bak
 create mode 100644 unit_tests/crystal_preferred_orientation.cc.bak
 create mode 100644 unit_tests/first.cc.bak
 create mode 100644 unit_tests/introspection.cc.bak
 create mode 100644 unit_tests/mesh_refinement.cc.bak
 create mode 100644 unit_tests/netcdf.cc.bak
 create mode 100644 unit_tests/parse_map_to_double_array.cc.bak
 create mode 100644 unit_tests/particles.cc.bak
 create mode 100644 unit_tests/termination_criteria.cc.bak
 create mode 100644 unit_tests/utilities.cc.bak

diff --git a/benchmarks/advection/drop_ev.prm.bak b/benchmarks/advection/drop_ev.prm.bak
new file mode 100644
index 00000000000..d0f3400f9d1
--- /dev/null
+++ b/benchmarks/advection/drop_ev.prm.bak
@@ -0,0 +1,13 @@
+# like drop_supg.prm but with entropy viscosity
+
+set Dimension                              = 2
+
+include drop_supg.prm
+
+set Output directory                       = output-drop-ev
+
+subsection Discretization
+  subsection Stabilization parameters
+    set Stabilization method = entropy viscosity
+  end
+end
diff --git a/benchmarks/advection/drop_supg.prm.bak b/benchmarks/advection/drop_supg.prm.bak
new file mode 100644
index 00000000000..73c1421d522
--- /dev/null
+++ b/benchmarks/advection/drop_supg.prm.bak
@@ -0,0 +1,123 @@
+# Dropping box benchmark on the right half of the domain
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 5.0
+set Output directory                       = output-drop-supg
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Function expression = 0; if (x>0,-0.2,0)
+  end
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 2
+
+  subsection Stabilization parameters
+    set Stabilization method = SUPG
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+    set Box origin X coordinate = -1
+    set Box origin Y coordinate = -1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = if ((abs(x)<0.2)&(abs(y-0.5)<0.2),1,0)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = if ((abs(x)<0.2)&(abs(y-0.5)<0.2),1,0)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top, bottom, left, right
+
+  subsection Box
+    set Bottom temperature = 0
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = box
+  set Fixed composition boundary indicators   = top, bottom, left, right
+
+  subsection Box
+    set Bottom composition = 0
+    set Left composition   = 0
+    set Right composition  = 0
+    set Top composition    = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-5
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Compositional field methods = field
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = .1
+    set List of output variables = artificial viscosity
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/benchmarks/advection/rotate_shape_dg_bp.prm b/benchmarks/advection/rotate_shape_dg_bp.prm
index bf877a98975..b1c2b7309a1 100644
--- a/benchmarks/advection/rotate_shape_dg_bp.prm
+++ b/benchmarks/advection/rotate_shape_dg_bp.prm
@@ -10,6 +10,7 @@ set Output directory                       = output-rotate-shape-dg-bp
 subsection Discretization
   set Use discontinuous temperature discretization = true
   set Use discontinuous composition discretization = true
+
   subsection Stabilization parameters
     set Limiter for discontinuous temperature solution = bound preserving
     set Limiter for discontinuous composition solution = bound preserving
diff --git a/benchmarks/advection/rotate_shape_dg_bp.prm.bak b/benchmarks/advection/rotate_shape_dg_bp.prm.bak
new file mode 100644
index 00000000000..bf877a98975
--- /dev/null
+++ b/benchmarks/advection/rotate_shape_dg_bp.prm.bak
@@ -0,0 +1,21 @@
+# Like rotate_shape_supg but with discontinuous Galerkin method
+# and bound-preserving limiter
+
+set Dimension                              = 2
+
+include rotate_shape_supg.prm
+
+set Output directory                       = output-rotate-shape-dg-bp
+
+subsection Discretization
+  set Use discontinuous temperature discretization = true
+  set Use discontinuous composition discretization = true
+  subsection Stabilization parameters
+    set Limiter for discontinuous temperature solution = bound preserving
+    set Limiter for discontinuous composition solution = bound preserving
+    set Global temperature maximum = 1
+    set Global temperature minimum = 0
+    set Global composition maximum = 1
+    set Global composition minimum = 0
+  end
+end
diff --git a/benchmarks/advection/rotate_shape_dg_weno.prm b/benchmarks/advection/rotate_shape_dg_weno.prm
index 895cf0ccdb3..aae23e8b1e7 100644
--- a/benchmarks/advection/rotate_shape_dg_weno.prm
+++ b/benchmarks/advection/rotate_shape_dg_weno.prm
@@ -10,6 +10,7 @@ set Output directory                       = output-rotate-shape-dg-weno
 subsection Discretization
   set Use discontinuous temperature discretization = true
   set Use discontinuous composition discretization = true
+
   subsection Stabilization parameters
     set Limiter for discontinuous temperature solution = WENO
     set Limiter for discontinuous composition solution = WENO
@@ -19,6 +20,7 @@ end
 subsection Postprocess
   subsection Visualization
     set List of output variables = kxrcf indicator
+
     subsection KXRCF indicator
       set Name of advection field = C_1
     end
diff --git a/benchmarks/advection/rotate_shape_dg_weno.prm.bak b/benchmarks/advection/rotate_shape_dg_weno.prm.bak
new file mode 100644
index 00000000000..895cf0ccdb3
--- /dev/null
+++ b/benchmarks/advection/rotate_shape_dg_weno.prm.bak
@@ -0,0 +1,26 @@
+# Like rotate_shape_supg but with discontinuous Galerkin method
+# and WENO limiter
+
+set Dimension                              = 2
+
+include rotate_shape_supg.prm
+
+set Output directory                       = output-rotate-shape-dg-weno
+
+subsection Discretization
+  set Use discontinuous temperature discretization = true
+  set Use discontinuous composition discretization = true
+  subsection Stabilization parameters
+    set Limiter for discontinuous temperature solution = WENO
+    set Limiter for discontinuous composition solution = WENO
+  end
+end
+
+subsection Postprocess
+  subsection Visualization
+    set List of output variables = kxrcf indicator
+    subsection KXRCF indicator
+      set Name of advection field = C_1
+    end
+  end
+end
diff --git a/benchmarks/advection/rotate_shape_ev.prm.bak b/benchmarks/advection/rotate_shape_ev.prm.bak
new file mode 100644
index 00000000000..72d335d9bb4
--- /dev/null
+++ b/benchmarks/advection/rotate_shape_ev.prm.bak
@@ -0,0 +1,13 @@
+# Like rotate_shape_supg but with entropy viscosity
+
+set Dimension                              = 2
+
+include rotate_shape_supg.prm
+
+set Output directory                       = output-rotate-shape-ev
+
+subsection Discretization
+  subsection Stabilization parameters
+    set Stabilization method = entropy viscosity
+  end
+end
diff --git a/benchmarks/advection/rotate_shape_supg.prm.bak b/benchmarks/advection/rotate_shape_supg.prm.bak
new file mode 100644
index 00000000000..2ec59286181
--- /dev/null
+++ b/benchmarks/advection/rotate_shape_supg.prm.bak
@@ -0,0 +1,119 @@
+# Rotating shapes
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 6.2831
+set Output directory                       = output-rotate-shape-supg
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 2
+
+  subsection Stabilization parameters
+    set Stabilization method = SUPG
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+    set Box origin X coordinate = -1
+    set Box origin Y coordinate = -1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression =  if((sqrt((x-0)^2+(y-0.5)^2)<0.3)&(abs(x)>=0.05|y>=0.7),1,if(sqrt((x-0)^2+(y+0.5)^2)<0.3,1-sqrt((x-0)^2+(y+0.5)^2)/0.3,if(sqrt((x+0.5)^2+(y+0)^2)<0.3,1.0/4.0*(1+cos(pi*min(sqrt((x+0.5)^2+(y+0)^2)/0.3,1))),0)))
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression =  if((sqrt((x-0)^2+(y-0.5)^2)<0.3)&(abs(x)>=0.05|y>=0.7),1,if(sqrt((x-0)^2+(y+0.5)^2)<0.3,1-sqrt((x-0)^2+(y+0.5)^2)/0.3,if(sqrt((x+0.5)^2+(y+0)^2)<0.3,1.0/4.0*(1+cos(pi*min(sqrt((x+0.5)^2+(y+0)^2)/0.3,1))),0)))
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top, bottom, left, right
+
+  subsection Box
+    set Bottom temperature = 0
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = box
+  set Fixed composition boundary indicators   = top, bottom, left, right
+
+  subsection Box
+    set Bottom composition = 0
+    set Left composition   = 0
+    set Right composition  = 0
+    set Top composition    = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0  # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-5
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Compositional field methods = field
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = .12566 # = 2pi/50
+    set List of output variables = artificial viscosity
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/benchmarks/advection_in_annulus/advection_in_annulus.cc.bak b/benchmarks/advection_in_annulus/advection_in_annulus.cc.bak
new file mode 100644
index 00000000000..b0eeeb741e5
--- /dev/null
+++ b/benchmarks/advection_in_annulus/advection_in_annulus.cc.bak
@@ -0,0 +1,162 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/postprocess/dynamic_topography.h>
+
+#include <aspect/prescribed_stokes_solution/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  /**
+   * This is a variation of the "annulus" benchmark in benchmark/annulus
+   * that tests the influence of the stabilization method on the temperature
+   * equation.
+   *
+   */
+  namespace AdvectionInAnnulus
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+      const double A=2.0, B=-3.0/std::log(2.0), C=-1;
+      const double outer_radius = 2.;
+      const double rho_0 = 1000.;
+      const double gravity = 1.;
+
+      Tensor<1,2>
+      Annulus_velocity (const Point<2> &pos,
+                        const double k)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const double r = std::sqrt(x*x+y*y);
+        const double theta = std::atan2(y,x);
+        const double f_r = A*r + B/r;
+        const double g_r = A*r/2 + B*std::log(r)/r + C/r;
+        const double v_r = g_r*k*sin(k*theta);
+        const double v_theta = f_r*cos(k*theta);
+        const double v_x = cos(theta)*v_r - sin(theta)*v_theta;
+        const double v_y = sin(theta)*v_r + cos(theta)*v_theta;
+        return Point<2> (v_x,v_y);
+      }
+
+      double
+      Annulus_pressure (const Point<2> &pos,
+                        const double k)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const double r=std::sqrt(x*x+y*y);
+        const double theta = std::atan2(y,x);
+        const double f_r = 2*r + B/r;
+        const double g_r = A*r/2 + B*std::log(r)/r + C/r;
+        const double h_r=(2*g_r-f_r)/r;
+        return k*h_r*sin(k*theta)+rho_0*gravity*(outer_radius-r);
+      }
+
+      template <int dim>
+      double
+      Annulus_normal_traction (const Point<dim> &pos,
+                               const double k)
+      {
+        Assert (dim == 2, ExcNotImplemented());
+        const double x = pos[0];
+        const double y = pos[1];
+        const double r=std::sqrt(x*x+y*y);
+        const double theta = std::atan2(y,x);
+        const double f_r = 2*r + B/r;
+        const double g_r = A*r/2 + B*std::log(r)/r + C/r;
+        return k * 3.*f_r/r * std::sin(k*theta) - rho_0 * g_r * (outer_radius - r);
+      }
+
+    }
+  }
+}
+
+
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements the flow field of the annulus benchmark.
+     *
+     * @ingroup PrescribedStokesSolution
+     */
+    template <int dim>
+    class AdvectionInAnnulus : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        void stokes_solution (const Point<dim> &p, Vector<double> &value) const override;
+    };
+  }
+}
+
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    template <int dim>
+    void AdvectionInAnnulus<dim>::stokes_solution (const Point<dim> &, Vector<double> &) const
+    {
+      return;
+    }
+
+
+    template <>
+    void AdvectionInAnnulus<2>::stokes_solution (const Point<2> &p, Vector<double> &value) const
+    {
+      Tensor<1,2> velocity = aspect::AdvectionInAnnulus::AnalyticSolutions::Annulus_velocity (p, 4);
+      value(0) = velocity[0];
+      value(1) = velocity[1];
+
+      double pressure = aspect::AdvectionInAnnulus::AnalyticSolutions::Annulus_pressure (p, 4);
+      value(2) = pressure;       // pressure
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(AdvectionInAnnulus,
+                                               "advection in annulus",
+                                               "This plugin prescribes the Stokes solution of "
+                                               "the annulus benchmark.")
+  }
+}
diff --git a/benchmarks/advection_in_annulus/advection_in_annulus.prm.bak b/benchmarks/advection_in_annulus/advection_in_annulus.prm.bak
new file mode 100644
index 00000000000..ba93d9017d5
--- /dev/null
+++ b/benchmarks/advection_in_annulus/advection_in_annulus.prm.bak
@@ -0,0 +1,120 @@
+# The advection benchmark creates a simple, 2d annulus
+# with prescribed Stokes flow creating 4 convection cells.
+# Various parameters can be changed to test their effect
+# on the overall cooling of the model.
+#
+# See run_all_models.sh for running multiple iterations
+# of various parameters in a row.
+#
+# Also see creates_formatted_tables for grabbing specific
+# data points from the log file.
+
+############### Global parameters
+# We use a 2d setup. We are only interested in
+# advection, so we prescribe a Stokes flow and
+# solve only for advection.
+
+set Additional shared libraries            = ./libadvection_in_annulus.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, no Stokes
+set Output directory                       = output_advection_in_annulus
+set Pressure normalization                 = surface
+set Timing output frequency                = 100
+
+subsection Prescribed Stokes solution
+  set Model name = advection in annulus
+end
+
+############### Parameters describing the model
+# We are interested in the flow of heat out of the top
+# boundary and how the advection is stabilized. Interesting
+# values to look at are in subsection Discretization, which
+# control the stabilization directly, as well as thermal
+# conductivity which effectively controls the Rayleigh number.
+# The thermal conductivity and Rayleigh number are inversely
+# proportional.
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  # NOTE: the analytical solutions are hard-coded
+  # to these geometry values: do not change them.
+  subsection Spherical shell
+    set Inner radius = 1
+    set Outer radius = 2
+    set Opening angle = 360
+  end
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 2
+
+  subsection Stabilization parameters
+    set beta = 0.052
+    set cR = 0.11
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density = 1.0
+    set Reference temperature = 1.0
+    set Viscosity = 1.0
+    set Thermal conductivity = 1e-3
+    set Reference specific heat = 1.0
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude =  1
+  end
+end
+
+############### Parameters describing the temperature field
+# Since we are interested in the flow of heat through
+# the top of the model, we set the temperature to 1
+# everywhere within the model except for the top
+# boundary, which is set to 0.
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators = top
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, entropy viscosity statistics, depth average
+
+  subsection Visualization
+    set List of output variables = heat flux map, artificial viscosity
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/benchmarks/annulus/instantaneous/annulus.prm.bak b/benchmarks/annulus/instantaneous/annulus.prm.bak
new file mode 100644
index 00000000000..1417770fa71
--- /dev/null
+++ b/benchmarks/annulus/instantaneous/annulus.prm.bak
@@ -0,0 +1,90 @@
+# The 2D Stokes in an annulus benchmark, for which an
+# analytical solution is available.
+#
+# See the manual for more information.
+
+# We use a 2d setup. Since we are only interested
+# in an instantaneous solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Additional shared libraries            = ../plugin/libannulus.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, single Stokes
+set Output directory                       = output
+set Pressure normalization                 = surface
+
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  # NOTE: the analytical solutions are hard-coded
+  # to these geometry values: do not change them.
+  subsection Spherical shell
+    set Inner radius = 1
+    set Outer radius = 2
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom : AnnulusBoundary, \
+                                                top : AnnulusBoundary
+end
+
+subsection Material model
+  set Model name = AnnulusMaterial
+end
+
+subsection Gravity model
+  set Model name = annulus gravity
+end
+
+# k controls the number of convection cells.
+subsection Annulus benchmark
+  set k = 4
+end
+
+# Temperature does not influence this benchmark
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+# Disable adaptive mesh refinement
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, AnnulusPostprocessor
+
+  subsection Dynamic topography
+    set Density above = 0
+    set Density below = 0
+  end
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, dynamic topography, AnnulusVisualizationPostprocessor
+    set Time between graphical output = 0
+  end
+end
+
+# Increase Stokes solver accuracy to ensure convergence to
+# very low error values
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
diff --git a/benchmarks/annulus/plugin/annulus.cc.bak b/benchmarks/annulus/plugin/annulus.cc.bak
new file mode 100644
index 00000000000..72f77ca337f
--- /dev/null
+++ b/benchmarks/annulus/plugin/annulus.cc.bak
@@ -0,0 +1,837 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+
+#include <aspect/gravity_model/interface.h>
+#include <aspect/postprocess/dynamic_topography.h>
+#include <aspect/postprocess/visualization.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  /**
+   * This is the "annulus" benchmark defined in the following paper:
+   * @code
+   *  @Article{thph17,
+   *    author =       {Rene Gassm\"{o}ller, Juliane Dannberg, Wolfgang Bangerth, Elbridge Gerry Puckett, Cedric Thieulot},
+   *    title =        {Benchmarking the accuracy of higher order particle methods in geodynamic models of transient flow},
+   *    journal =      {xxx},
+   *    year =         2023,
+   *    volume =       xxx,
+   *    number =       {x},
+   *    publisher =    {xxx},
+   *    pages =        {xxx--xxx}}
+   * @endcode
+   *
+   */
+  namespace AnnulusBenchmark
+  {
+    using namespace dealii;
+    using namespace aspect::Utilities::Coordinates;
+
+    /**
+     * The exact solution for the Annulus benchmark.
+     */
+    namespace AnalyticSolutions
+    {
+      // Inner and outer radius are hard-coded to guarantee
+      // tangential flow at the boundaries
+      const double R1 = 1.0;
+      const double R2 = 2.0;
+      const double A = 2.0;
+      const double B = -3.0/std::log(2.0);
+      const double C=-1;
+      const double rho_0 = 1000.;
+      const double gravity = 1.;
+
+      double
+      phase(const double t)
+      {
+        return std::exp(t)-1;
+      }
+
+
+
+      double
+      f(const double r)
+      {
+        return A*r + B/r;
+      }
+
+
+
+      double
+      g(const double r)
+      {
+        return A*r/2 + B*std::log(r)/r + C/r;
+      }
+
+
+
+      double
+      h(const double r)
+      {
+        return (2*g(r)-f(r))/r;
+      }
+
+
+
+      double
+      m(const double r, const double k)
+      {
+        const double f_prime = A - B/(r*r);
+        const double g_prime = A/2 - B*std::log(r)/(r*r) + B/(r*r) - C/(r*r);
+        const double g_prime_prime = -B/(r*r*r)*(3-2*std::log(r)) - 2./(r*r*r);
+        return g_prime_prime - g_prime/r - (g(r)*(k*k - 1))/(r*r) + f(r)/(r*r) + f_prime/r;
+      }
+
+
+
+      template <int dim>
+      Tensor<1,dim>
+      Annulus_velocity (const Point<dim> &pos,
+                        const double k,
+                        const double t,
+                        const bool transient)
+      {
+        Assert (dim == 2, ExcNotImplemented());
+
+        const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
+        const double r = spherical_position[0];
+        const double theta = spherical_position[1];
+
+        Tensor<1,dim> spherical_velocity;
+        spherical_velocity[0] = g(r) * k * std::sin(k*(theta-phase(t)));
+        spherical_velocity[1] = f(r) * std::cos(k*(theta-phase(t)));
+
+        if (transient == true)
+          spherical_velocity[1] += r * std::exp(t);
+
+        return spherical_to_cartesian_vector(spherical_velocity, pos);
+      }
+
+
+
+      template <int dim>
+      double
+      Annulus_pressure (const Point<dim> &pos,
+                        const double k,
+                        const double t)
+      {
+        Assert (dim == 2, ExcNotImplemented());
+        const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
+        const double r = spherical_position[0];
+        const double theta = spherical_position[1];
+
+        return k * h(r) * std::sin(k*(theta-phase(t)))
+               + rho_0 * gravity * (R2-r);
+      }
+
+
+
+      template <int dim>
+      double
+      Annulus_normal_traction (const Point<dim> &pos,
+                               const double k,
+                               const double t)
+      {
+        Assert (dim == 2, ExcNotImplemented());
+        const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
+        const double r = spherical_position[0];
+        const double theta = spherical_position[1];
+
+        return k * 3.*f(r)/r * std::sin(k*(theta-phase(t))) - rho_0 * g(r) * (R2 - r);
+      }
+
+
+
+      template <int dim>
+      double
+      Annulus_density (const Point<dim> &pos,
+                       const double k,
+                       const double t,
+                       const bool transient)
+      {
+        Assert (dim == 2, ExcNotImplemented());
+        const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
+        const double r = spherical_position[0];
+        const double theta = spherical_position[1];
+
+        double density = 0.0;
+        if (transient == true)
+          {
+            const double stream_function = -((A/2)*r*r + B * std::log(r) + C) * std::cos(k*(theta-phase(t)));
+            density = stream_function + rho_0;
+          }
+        else
+          {
+            density = m(r,k) * k * std::sin(k*theta) + rho_0;
+          }
+
+        return density;
+      }
+
+
+
+      template <int dim>
+      Tensor<1,dim>
+      Annulus_gravity (const Point<dim> &pos,
+                       const double k,
+                       const double t,
+                       const bool transient)
+      {
+        Assert (dim == 2, ExcNotImplemented());
+
+        double gravity_magnitude = 1.0;
+
+        // see benchmark description for a justification. we want to change
+        // the density, but keep the forcing term of the Stokes equation constant
+        if (transient == true)
+          {
+            const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
+            const double r = spherical_position[0];
+            const double theta = spherical_position[1];
+
+            const double forcing_term = m(r,k)*k*sin(k*(theta-phase(t))) + rho_0;
+            gravity_magnitude = forcing_term / Annulus_density(pos,k,t, transient);
+          }
+
+        const Tensor<1,dim> gravity_direction = -pos / pos.norm();
+        return gravity_magnitude * gravity_direction;
+      }
+
+
+
+      template <int dim>
+      class FunctionAnnulus : public Function<dim>
+      {
+        public:
+          FunctionAnnulus (const double k,
+                           const unsigned int n_comp,
+                           const bool transient)
+            :
+            Function<dim>(n_comp),
+            k_(k),
+            n_components(n_comp),
+            transient_(transient)
+          {
+            Assert(n_components >= 4, ExcInternalError());
+          }
+
+          void
+          vector_value (const Point<dim>   &pos,
+                        Vector<double>   &values) const override
+          {
+            Assert (dim == 2, ExcNotImplemented());
+            Assert (values.size() >= n_components, ExcInternalError());
+
+            const double t = this->get_time();
+
+            const Tensor<1,dim> v = AnalyticSolutions::Annulus_velocity (pos, k_, t, transient_);
+            values[0] = v[0];
+            values[1] = v[1];
+            values[2] = AnalyticSolutions::Annulus_pressure (pos, k_, t);
+            values[3] = 0.0;
+
+            if (n_components >= 5)
+              values[4] = AnalyticSolutions::Annulus_density (pos, k_, t, transient_);
+          }
+
+        private:
+          const double k_;
+          const unsigned int n_components;
+          const bool transient_;
+      };
+    }
+
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class AnnulusMaterial : public MaterialModel::Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        void
+        evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                 MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          double t = 0.0;
+          if (this->simulator_is_past_initialization() == true)
+            t = this->get_time();
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              out.viscosities[i] = 1;
+              if (use_analytical_density == true)
+                {
+                  out.densities[i] = AnalyticSolutions::Annulus_density(in.position[i], k, t, use_transient_flow_solution);
+                }
+              else
+                {
+                  out.densities[i] = in.composition[i][density_index];
+                }
+
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                out.reaction_terms[i][c] = 0.0;
+            }
+        }
+
+
+
+        bool is_compressible () const override
+        {
+          return false;
+        }
+
+
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm)
+        {
+          // create a global section in the parameter file for parameters
+          // that describe this benchmark. note that we declare them here
+          // in the material model, but other kinds of plugins
+          // may also read these parameters even though they do not
+          // declare them.
+          prm.enter_subsection("Annulus benchmark");
+          {
+            prm.declare_entry("k", "0",
+                              Patterns::Double (0),
+                              "Parameter k in the Annulus benchmark solution. This "
+                              "parameter controls the number of convection cells in "
+                              "the solution (which is 2*k).");
+
+            prm.declare_entry("Use analytical density", "true",
+                              Patterns::Bool(),
+                              "Whether to use the analytical density solution, or to look for a "
+                              "field named <density_field> to use as density.");
+
+            prm.declare_entry("Use transient solution", "false",
+                              Patterns::Bool(),
+                              "Whether to use the transient flow solution, or to use the "
+                              "default instantaneous solution.");
+          }
+          prm.leave_subsection();
+        }
+
+
+
+        void
+        parse_parameters (ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Annulus benchmark");
+          {
+            k = prm.get_double ("k");
+            use_analytical_density = prm.get_bool ("Use analytical density");
+            use_transient_flow_solution = prm.get_bool ("Use transient solution");
+          }
+          prm.leave_subsection();
+
+          density_index = numbers::invalid_unsigned_int;
+          if (use_analytical_density == false)
+            {
+              Assert(this->introspection().compositional_name_exists("density_field"),
+                     ExcInternalError());
+              density_index = this->introspection().compositional_index_for_name("density_field");
+            }
+
+          // Declare dependencies on solution variables
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+
+
+        double get_k() const
+        {
+          return k;
+        }
+
+
+
+        bool use_transient_solution() const
+        {
+          return use_transient_flow_solution;
+        }
+
+
+
+        bool analytical_density() const
+        {
+          return use_analytical_density;
+        }
+
+      private:
+        /**
+         * Whether to use the analytical density.
+         */
+        bool use_analytical_density;
+
+        /**
+         * If not using the analytical density, store the
+         * field index of the density field.
+        */
+        unsigned int density_index;
+
+        /**
+         * Number of positive and negative density anomalies,
+         * resulting in 2*k convection cells.
+         */
+        double k;
+
+        /**
+         * Whether to use the transient flow solution.
+        */
+        bool use_transient_flow_solution;
+    };
+
+
+
+    /**
+     * Velocity boundary condition for the Annulus benchmark
+     */
+    template <int dim>
+    class AnnulusBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id ,
+                           const Point<dim> &position) const override
+        {
+          Assert (dim==2, ExcNotImplemented());
+
+          const AnnulusMaterial<dim> &
+          material_model
+            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
+
+          return AnalyticSolutions::Annulus_velocity (position,
+                                                      material_model.get_k(),
+                                                      this->get_time(),
+                                                      material_model.use_transient_solution());
+        }
+    };
+
+
+
+    /**
+     * Gravity model for the Annulus benchmark
+     */
+    template <int dim>
+    class AnnulusGravity : public aspect::GravityModel::Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        Tensor<1,dim>
+        gravity_vector (const Point<dim> &pos) const override
+        {
+          const AnnulusMaterial<dim> &material_model
+            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
+
+          double t = 0.0;
+          if (this->simulator_is_past_initialization() == true)
+            t = this->get_time();
+
+          return AnalyticSolutions::Annulus_gravity(pos,
+                                                    material_model.get_k(),
+                                                    t,
+                                                    material_model.use_transient_solution());
+        }
+    };
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      */
+    template <int dim>
+    class AnnulusPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void initialize() override
+        {
+          const AnnulusMaterial<dim> &material_model
+            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
+          const unsigned int n_components = this->introspection().n_components;
+
+          compute_density_error = (material_model.analytical_density() == false);
+          reference_solution = std::make_unique<AnalyticSolutions::FunctionAnnulus<dim>>(material_model.get_k(),
+                                                                                          n_components,
+                                                                                          material_model.use_transient_solution());
+        }
+
+
+
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override
+        {
+          const unsigned int n_components = this->introspection().n_components;
+          reference_solution->set_time(this->get_time());
+
+          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+          Vector<double> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+          Vector<double> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                              n_components);
+          ComponentSelectFunction<dim> comp_p(dim, n_components);
+
+          VectorTools::integrate_difference (this->get_mapping(),
+                                             this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *reference_solution,
+                                             cellwise_errors_ul2,
+                                             quadrature_formula,
+                                             VectorTools::L2_norm,
+                                             &comp_u);
+          VectorTools::integrate_difference (this->get_mapping(),
+                                             this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *reference_solution,
+                                             cellwise_errors_pl2,
+                                             quadrature_formula,
+                                             VectorTools::L2_norm,
+                                             &comp_p);
+
+
+          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+          // we output the density error either way, but set it to 0 if we do not compute it.
+          // this simplifies postprocessing the output.
+          double rho_l2 = 0.0;
+          if (compute_density_error == true)
+            {
+              Vector<double> cellwise_errors_rhol2 (this->get_triangulation().n_active_cells());
+              ComponentSelectFunction<dim> comp_rho(dim+2, n_components);
+              VectorTools::integrate_difference (this->get_mapping(),
+                                                 this->get_dof_handler(),
+                                                 this->get_solution(),
+                                                 *reference_solution,
+                                                 cellwise_errors_rhol2,
+                                                 quadrature_formula,
+                                                 VectorTools::L2_norm,
+                                                 &comp_rho);
+              rho_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_rhol2, VectorTools::L2_norm);
+            }
+
+          const double topo_l2 = compute_dynamic_topography_error();
+
+          statistics.add_value ("u_L2",
+                                u_l2);
+          statistics.set_precision ("u_L2", 14);
+          statistics.set_scientific ("u_L2", true);
+
+          statistics.add_value ("p_L2",
+                                p_l2);
+          statistics.set_precision ("p_L2", 14);
+          statistics.set_scientific ("p_L2", true);
+
+          statistics.add_value ("rho_L2",
+                                rho_l2);
+          statistics.set_precision ("rho_L2", 14);
+          statistics.set_scientific ("rho_L2", true);
+
+          statistics.add_value ("topo_L2",
+                                topo_l2);
+          statistics.set_precision ("topo_L2", 14);
+          statistics.set_scientific ("topo_L2", true);
+
+          std::ostringstream os;
+
+          os << std::scientific <<  u_l2
+             << ", " << p_l2
+             << ", " << rho_l2
+             << ", " << topo_l2;
+
+          return std::make_pair("Errors u_L2, p_L2, rho_L2, topo_L2:", os.str());
+        }
+
+
+
+        std::list<std::string>
+        required_other_postprocessors() const override
+        {
+          return std::list<std::string> (1, "dynamic topography");
+        }
+
+      private:
+        /**
+         * Function that defines the reference solution to compare against.
+         */
+        std::unique_ptr<Function<dim>> reference_solution;
+
+        /**
+         * Whether to compute the density error. This only makes sense
+         * if the material model does not use the analytical density solution,
+         * otherwise the error is always 0.
+         */
+        bool compute_density_error;
+
+        /**
+         * Calculate the L2 dynamic topography error.
+         */
+        double
+        compute_dynamic_topography_error() const
+        {
+          const Postprocess::DynamicTopography<dim> &dynamic_topography =
+            this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<dim>>();
+
+          const AnnulusMaterial<dim> &material_model
+            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
+          const double k = material_model.get_k();
+
+          const QGauss<dim-1> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+          FEFaceValues<dim> fe_face_values(this->get_mapping(),
+                                           this->get_fe(),
+                                           quadrature_formula,
+                                           update_values | update_gradients |
+                                           update_quadrature_points | update_JxW_values);
+          LinearAlgebra::BlockVector topo_vector = dynamic_topography.topography_vector();
+          std::vector<double> topo_values(quadrature_formula.size());
+
+          double l2_error = 0.;
+
+          typename DoFHandler<dim>::active_cell_iterator
+          cell = this->get_dof_handler().begin_active(),
+          endc = this->get_dof_handler().end();
+
+          for (; cell!=endc; ++cell)
+            if (cell->is_locally_owned())
+              if (cell->at_boundary())
+                for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+                  if (cell->face(f)->at_boundary())
+                    {
+                      fe_face_values.reinit(cell, f);
+                      MaterialModel::MaterialModelInputs<dim> in_face(fe_face_values, cell, this->introspection(), this->get_solution());
+                      MaterialModel::MaterialModelOutputs<dim> out_face(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+                      fe_face_values[this->introspection().extractors.temperature].get_function_values(topo_vector, topo_values);
+                      in_face.requested_properties = MaterialModel::MaterialProperties::density;
+                      material_model.evaluate(in_face, out_face);
+
+                      for (unsigned int q=0; q < quadrature_formula.size(); ++q)
+                        {
+                          const Point<dim> p = fe_face_values.quadrature_point(q);
+                          const double analytic_normal_stress = AnalyticSolutions::Annulus_normal_traction<dim>(p, k, this->get_time());
+                          const double gravity = this->get_gravity_model().gravity_vector(p).norm();
+                          const double density = out_face.densities[q];
+                          const double diff = - analytic_normal_stress / gravity/ density - topo_values[q];
+                          l2_error += (diff*diff) * fe_face_values.JxW(q);
+                        }
+                    }
+          const double total_l2_error =  Utilities::MPI::sum(l2_error,this->get_mpi_communicator());
+          return std::sqrt(total_l2_error);
+        }
+    };
+
+    /**
+      * A postprocessor that visualizes the analytical solution.
+      */
+    template <int dim>
+    class AnnulusVisualizationPostprocessor : public DataPostprocessor<dim>,
+      public Postprocess::VisualizationPostprocessors::Interface<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        AnnulusVisualizationPostprocessor ()
+          :
+          DataPostprocessor<dim> ()
+        {};
+
+        std::vector<std::string>
+        get_names () const override
+        {
+          std::vector<std::string> solution_names;
+
+          solution_names.push_back ("analytic_pressure");
+          solution_names.push_back ("analytic_density");
+          return solution_names;
+        };
+
+        std::vector<DataComponentInterpretation::DataComponentInterpretation>
+        get_data_component_interpretation () const override
+        {
+          std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretation;
+          interpretation.push_back (DataComponentInterpretation::component_is_scalar);
+          interpretation.push_back (DataComponentInterpretation::component_is_scalar);
+
+          return interpretation;
+        };
+
+        UpdateFlags
+        get_needed_update_flags () const override
+        {
+          return update_quadrature_points;
+        };
+
+        void
+        evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                              std::vector<Vector<double>> &computed_quantities) const override
+        {
+          const unsigned int n_quadrature_points = input_data.solution_values.size();
+          Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+          Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
+
+
+          const AnnulusMaterial<dim> &material_model
+            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
+
+          for (unsigned int q=0; q<n_quadrature_points; ++q)
+            {
+              computed_quantities[q][0] = AnalyticSolutions::Annulus_pressure(input_data.evaluation_points[q],
+                                                                              material_model.get_k(),
+                                                                              this->get_time());
+              computed_quantities[q][1] = AnalyticSolutions::Annulus_density(input_data.evaluation_points[q],
+                                                                             material_model.get_k(),
+                                                                             this->get_time(),
+                                                                             material_model.use_transient_solution());
+            }
+        };
+    };
+
+
+
+    /**
+     * A particle property that represents the density on particles.
+     */
+    template <int dim>
+    class ParticleDensity : public aspect::Particle::Property::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void
+        initialize_one_particle_property (const Point<dim> &position,
+                                          std::vector<double> &particle_properties) const override
+        {
+          const AnnulusMaterial<dim> &material_model
+            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
+
+          const double density = AnalyticSolutions::Annulus_density(position,
+                                                                    material_model.get_k(),
+                                                                    /*time*/ 0.0,
+                                                                    material_model.use_transient_solution());
+
+          particle_properties.push_back(density);
+        }
+
+
+
+        std::vector<std::pair<std::string, unsigned int>>
+        get_property_information() const override
+        {
+          return {{"particle_density",1}};
+        }
+    };
+
+
+
+    /**
+    * A initial condition for compositional fields that represents the initial density.
+    */
+    template <int dim>
+    class AnnulusInitialDensity : public aspect::InitialComposition::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        double initial_composition (const Point<dim> &position,
+                                    const unsigned int n_comp) const override
+        {
+          const double density_index = this->introspection().compositional_index_for_name("density_field");
+
+          if (n_comp == density_index)
+            {
+              const AnnulusMaterial<dim> &material_model
+                = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
+
+              return AnalyticSolutions::Annulus_density(position,
+                                                        material_model.get_k(),
+                                                        /*time*/ 0.0,
+                                                        material_model.use_transient_solution());
+            }
+
+          return 0.0;
+        }
+    };
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace AnnulusBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(AnnulusMaterial,
+                                   "AnnulusMaterial",
+                                   "A material model that corresponds to the `Annulus' benchmark. "
+                                   "See the manual for more information.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(AnnulusBoundary,
+                                            "AnnulusBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "`Annulus' benchmark. See the manual for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(AnnulusPostprocessor,
+                                  "AnnulusPostprocessor",
+                                  "A postprocessor that compares the solution of the `Annulus' benchmark "
+                                  "with the one computed by ASPECT "
+                                  "and reports the error. See the manual for more information.")
+
+    ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(AnnulusVisualizationPostprocessor,
+                                                "AnnulusVisualizationPostprocessor",
+                                                "A visualization output object that visualizes "
+                                                "the analytical solution of the Annulus benchmark.")
+
+    ASPECT_REGISTER_PARTICLE_PROPERTY(ParticleDensity,
+                                      "particle density",
+                                      "A particle property that represents the density.")
+
+    ASPECT_REGISTER_GRAVITY_MODEL(AnnulusGravity,
+                                  "annulus gravity",
+                                  "A gravity model for the `Annulus' benchmark.")
+
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(AnnulusInitialDensity,
+                                              "initial density",
+                                              "An initial condition for composition following the initial density.")
+  }
+}
diff --git a/benchmarks/annulus/transient/transient_annulus.prm.bak b/benchmarks/annulus/transient/transient_annulus.prm.bak
new file mode 100644
index 00000000000..46833d000a9
--- /dev/null
+++ b/benchmarks/annulus/transient/transient_annulus.prm.bak
@@ -0,0 +1,89 @@
+# The 2D Stokes in an annulus benchmark, for which an
+# analytical solution is available. This is the rotating
+# version of the benchmark described in Gassmoeller et al. 2023.
+#
+# See the doc/ directory or manual for more information.
+
+# Most parameters are identical to the instantaneous version
+# of the benchmark. Refer to that parameter file for most settings.
+include $ASPECT_SOURCE_DIR/benchmarks/annulus/instantaneous/annulus.prm
+
+
+# Only list parameters that are specific for the transient benchmark
+set Additional shared libraries            = ../plugin/libannulus.so
+set Dimension                              = 2
+
+# for benchmark: t = log(1 + 4 pi)
+set End time                                = 2.6075939815049280917817614240391581472837221358084918109292273672
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_field
+end
+
+subsection Initial composition model
+  set List of model names = initial density
+end
+
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+end
+
+subsection Annulus benchmark
+  set Use analytical density  = false
+  set Use transient solution  = true
+  set k                       = 4
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, AnnulusPostprocessor, rotation statistics
+
+  subsection Dynamic topography
+    set Density above = 0
+    set Density below = 0
+  end
+
+  subsection Visualization
+    set List of output variables = density, gravity, AnnulusVisualizationPostprocessor
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 2.6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 200
+    set Stokes solver type = block GMG
+    set Krylov method for cheap solver steps = IDR(s)
+    set IDR(s) parameter = 4
+  end
+end
+
+subsection Particles
+  set Integration scheme = rk2
+  set Interpolation scheme = bilinear least squares
+  set List of particle properties = particle density
+  set Update ghost particles = true
+  set Particle generator name = random uniform
+  set Load balancing strategy = add particles
+  set Minimum particles per cell = 12
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 49152
+    end
+  end
+end
diff --git a/benchmarks/blankenbach/base_case1a.prm.bak b/benchmarks/blankenbach/base_case1a.prm.bak
new file mode 100644
index 00000000000..67dfd748504
--- /dev/null
+++ b/benchmarks/blankenbach/base_case1a.prm.bak
@@ -0,0 +1,111 @@
+# This is case 1a from the Blankenbach Benchmark (Blankenbach 1989).
+
+set Additional shared libraries            = ./plugin/libblankenbach.so
+set End time                               = 1.0
+set Use years in output instead of seconds = false
+set CFL number = 5.0
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0; 0; 1
+    set Variable names      = depth
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+
+  subsection Ascii data model
+    set Data directory =
+    set Data file name = initial_temperature_case1a.txt
+  end
+end
+
+subsection Material model
+  set Model name = nondimensional
+
+  subsection Nondimensional model
+    set Di                      = 0.0
+    set Ra                      = 1e4
+    set Reference density       = 1
+    set Reference specific heat = 1
+    set Use TALA                = false
+    set Viscosity temperature prefactor = 0.0
+    set Viscosity depth prefactor = 0.0
+    set gamma                   = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 1.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Formulation
+  set Formulation          = custom # with this selection equivalent to BA
+  set Mass conservation    = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heat flux statistics gradient, heating statistics, heat flux densities, temperature ascii out
+
+  subsection Visualization
+    set Time between graphical output = 0.05
+    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = steady state velocity
+
+  subsection Steady state velocity
+    set Maximum relative deviation = 1e-5
+    set Time in steady state       = 0.1
+  end
+end
diff --git a/benchmarks/blankenbach/base_case1b.prm.bak b/benchmarks/blankenbach/base_case1b.prm.bak
new file mode 100644
index 00000000000..80953a9d798
--- /dev/null
+++ b/benchmarks/blankenbach/base_case1b.prm.bak
@@ -0,0 +1,18 @@
+include base_case1a.prm
+
+set Additional shared libraries            = ./plugin/libblankenbach.so
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory =
+    set Data file name = initial_temperature_case1b.txt
+  end
+end
+
+subsection Material model
+  subsection Nondimensional model
+    set Ra                      = 1e5
+  end
+end
diff --git a/benchmarks/blankenbach/base_case1c.prm.bak b/benchmarks/blankenbach/base_case1c.prm.bak
new file mode 100644
index 00000000000..4f3c92497d9
--- /dev/null
+++ b/benchmarks/blankenbach/base_case1c.prm.bak
@@ -0,0 +1,18 @@
+include base_case1a.prm
+
+set Additional shared libraries            = ./plugin/libblankenbach.so
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory =
+    set Data file name = initial_temperature_case1c.txt
+  end
+end
+
+subsection Material model
+  subsection Nondimensional model
+    set Ra                      = 1e6
+  end
+end
diff --git a/benchmarks/blankenbach/base_case2a.prm.bak b/benchmarks/blankenbach/base_case2a.prm.bak
new file mode 100644
index 00000000000..34442d9d319
--- /dev/null
+++ b/benchmarks/blankenbach/base_case2a.prm.bak
@@ -0,0 +1,111 @@
+# This is case 2a from the Blankenbach Benchmark (Blankenbach 1989).
+
+set Additional shared libraries            = ./plugin/libblankenbach.so
+set End time                               = 1.0
+set Use years in output instead of seconds = false
+set CFL number = 5.0
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0; 0; 1
+    set Variable names      = depth
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+
+  subsection Ascii data model
+    set Data directory =
+    set Data file name = initial_temperature_case2a.txt
+  end
+end
+
+subsection Material model
+  set Model name = nondimensional
+
+  subsection Nondimensional model
+    set Di                      = 0.0
+    set Ra                      = 1e4
+    set Reference density       = 1
+    set Reference specific heat = 1
+    set Use TALA                = false
+    set Viscosity temperature prefactor = 6.907755279
+    set Viscosity depth prefactor = 0.0
+    set gamma                   = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 1.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Formulation
+  set Formulation          = custom # with this selection equivalent to BA
+  set Mass conservation    = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heat flux statistics gradient, heating statistics, heat flux densities, temperature ascii out
+
+  subsection Visualization
+    set Time between graphical output = 0.05
+    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = steady state velocity
+
+  subsection Steady state velocity
+    set Maximum relative deviation = 1e-5
+    set Time in steady state       = 0.1
+  end
+end
diff --git a/benchmarks/blankenbach/base_case2b.prm.bak b/benchmarks/blankenbach/base_case2b.prm.bak
new file mode 100644
index 00000000000..0851fcf0cf5
--- /dev/null
+++ b/benchmarks/blankenbach/base_case2b.prm.bak
@@ -0,0 +1,118 @@
+# This is case 2b from the Blankenbach Benchmark (Blankenbach 1989).
+
+set Additional shared libraries            = ./plugin/libblankenbach.so
+set End time                               = 1.0
+set Use years in output instead of seconds = false
+set CFL number = 5.0
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0; 0; 1
+    set Variable names      = depth
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2.5
+    set Y extent = 1
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1, ratio=2.5
+    set Function expression = 1* ((1.0-z/L) + p*cos(k*pi*x/L/ratio)*sin(pi*z/L))
+  end
+
+  subsection Ascii data model
+    set Data directory =
+    set Data file name = initial_temperature_case2b.txt
+  end
+end
+
+subsection Material model
+  set Model name = nondimensional
+
+  subsection Nondimensional model
+    set Di                      = 0.0
+    set Ra                      = 1e4
+    set Reference density       = 1
+    set Reference specific heat = 1
+    set Use TALA                = false
+    set Viscosity temperature prefactor = 9.70406052783923433184
+    set Viscosity depth prefactor = 4.1588830833596718565
+    set gamma                   = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.0
+  set Refinement fraction                = 1.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Formulation
+  set Formulation          = custom # with this selection equivalent to BA
+  set Mass conservation    = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heat flux statistics gradient, heating statistics, heat flux densities, temperature ascii out
+
+  subsection Visualization
+    set Time between graphical output = 0.002
+    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = steady state velocity
+  set Checkpoint on termination = true
+
+  subsection Steady state velocity
+    set Maximum relative deviation = 1e-5
+    set Time in steady state       = 0.1
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint = 600
+end
diff --git a/benchmarks/blankenbach/plugin/code.cc.bak b/benchmarks/blankenbach/plugin/code.cc.bak
new file mode 100644
index 00000000000..49920460923
--- /dev/null
+++ b/benchmarks/blankenbach/plugin/code.cc.bak
@@ -0,0 +1,167 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <algorithm>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that generates ascii data output of the temperature
+     * field to be used as initial condition.
+     */
+    template <int dim>
+    class TemperatureAsciiOut : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    TemperatureAsciiOut<dim>::execute (TableHandler &)
+    {
+      std::string filename = (this->get_output_directory() + "temperature_ascii_data.txt");
+
+      struct entry
+      {
+        Point<dim> p;
+        double t;
+      };
+      std::vector<entry> entries;
+
+      const QMidpoint<dim> quadrature_formula;
+
+      const unsigned int n_q_points =  quadrature_formula.size();
+      FEValues<dim> fe_values (this->get_mapping(), this->get_fe(),  quadrature_formula,
+                               update_JxW_values | update_values | update_quadrature_points);
+
+      std::vector<double> temperature_values(n_q_points);
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(), temperature_values);
+
+            for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
+              {
+                entry e;
+                e.p = fe_values.quadrature_point(q);
+                e.t = temperature_values[q];
+                entries.push_back(e);
+              }
+          }
+
+      struct sorter
+      {
+        bool operator() (const entry &i, const entry &j)
+        {
+          if (std::abs(i.p[1]-j.p[1])<1e-6)
+            return i.p[0] < j.p[0];
+          else
+            return i.p[1] < j.p[1];
+        }
+      } sorter_instance;
+      std::sort(entries.begin(), entries.end(), sorter_instance);
+
+      unsigned int n_x, n_y;
+      {
+        // find unique number of x and y values by stuffing them into a std::set
+        struct sort_double
+        {
+          bool operator() (const double &i, const double &j)
+          {
+            return i<j;
+          }
+        } sort_double_instance;
+        struct compare_double_eps
+        {
+          bool operator() (const double &i, const double &j)
+          {
+            return (std::abs(i-j)<1e-6);
+          }
+        } compare_double_instance;
+
+        std::vector<double> x_values, y_values;
+        for (unsigned int idx = 0; idx< entries.size(); ++idx)
+          {
+            x_values.push_back(entries[idx].p(0));
+            y_values.push_back(entries[idx].p(1));
+          }
+        std::sort(x_values.begin(), x_values.end(), sort_double_instance);
+        x_values.erase( std::unique( x_values.begin(), x_values.end(), compare_double_instance ), x_values.end() );
+        std::sort(y_values.begin(), y_values.end(), sort_double_instance);
+        y_values.erase( std::unique( y_values.begin(), y_values.end(), compare_double_instance ), y_values.end() );
+
+        n_x = x_values.size();
+        n_y = y_values.size();
+      }
+
+
+      std::stringstream f;
+
+      f << std::scientific << std::setprecision(15);
+
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          // Note: POINTS is only useful if our mesh is a structured grid
+          f << "# POINTS: " << n_x << ' ' << n_y << "\n";
+          f << "# x y T\n";
+        }
+
+      for (unsigned int idx = 0; idx< entries.size(); ++idx)
+        f << entries[idx].p << ' ' << entries[idx].t << '\n';
+
+      aspect::Utilities::collect_and_write_file_content(filename,
+                                                        f.str(),
+                                                        this->get_mpi_communicator());
+
+      return std::make_pair (std::string ("Writing TemperatureAsciiOut:"),
+                             filename);
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(TemperatureAsciiOut,
+                                  "temperature ascii out",
+                                  "A postprocessor that generates ascii data "
+                                  "output of the temperature field that can "
+                                  "be read in in a subsequent computation.")
+  }
+}
diff --git a/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc.bak b/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc.bak
new file mode 100644
index 00000000000..33dd11fe2fa
--- /dev/null
+++ b/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc.bak
@@ -0,0 +1,198 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "heat_flux_statistics_gradient.h"
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    HeatFluxStatisticsGradient<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the temperature element alone.
+      const QGauss<dim-1> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.temperature).degree+1);
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula,
+                                        update_gradients      | update_values |
+                                        update_normal_vectors |
+                                        update_quadrature_points       | update_JxW_values);
+
+      std::vector<Tensor<1,dim>> temperature_gradients (quadrature_formula.size());
+      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+
+      std::map<types::boundary_id, double> local_boundary_fluxes;
+
+      MaterialModel::MaterialModelInputs<dim> in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+
+      // for every surface face on which it makes sense to compute a
+      // heat flux and that is owned by this processor,
+      // integrate the normal heat flux given by the formula
+      //   j =  - k * n . grad T
+      //
+      // for the spherical shell geometry, note that for the inner boundary,
+      // the normal vector points *into* the core, i.e. we compute the flux
+      // *out* of the mantle, not into it. we fix this when we add the local
+      // contribution to the global flux
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+            if (cell->at_boundary(f))
+              {
+                fe_face_values.reinit (cell, f);
+                in.reinit(fe_face_values, cell, this->introspection(), this->get_solution());
+
+                this->get_material_model().evaluate(in, out);
+
+                // Get the temperature gradients from the solution.
+                fe_face_values[this->introspection().extractors.temperature].get_function_gradients (this->get_solution(), temperature_gradients);
+
+                double local_normal_flux = 0;
+                for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                  {
+                    const double thermal_conductivity
+                      = out.thermal_conductivities[q];
+
+                    local_normal_flux
+                    +=
+                      -thermal_conductivity *
+                      (temperature_gradients[q] *
+                       fe_face_values.normal_vector(q)) *
+                      fe_face_values.JxW(q);
+                  }
+
+                const types::boundary_id boundary_indicator
+                  = cell->face(f)->boundary_id();
+                local_boundary_fluxes[boundary_indicator] += local_normal_flux;
+              }
+
+      // now communicate to get the global values
+      std::map<types::boundary_id, double> global_boundary_fluxes;
+      {
+        // first collect local values in the same order in which they are listed
+        // in the set of boundary indicators
+        const std::set<types::boundary_id>
+        boundary_indicators
+          = this->get_geometry_model().get_used_boundary_indicators ();
+        std::vector<double> local_values;
+        for (std::set<types::boundary_id>::const_iterator
+             p = boundary_indicators.begin();
+             p != boundary_indicators.end(); ++p)
+          local_values.push_back (local_boundary_fluxes[*p]);
+
+        // then collect contributions from all processors
+        std::vector<double> global_values (local_values.size());
+        Utilities::MPI::sum (local_values, this->get_mpi_communicator(), global_values);
+
+        // and now take them apart into the global map again
+        unsigned int index = 0;
+        for (std::set<types::boundary_id>::const_iterator
+             p = boundary_indicators.begin();
+             p != boundary_indicators.end(); ++p, ++index)
+          global_boundary_fluxes[*p] = global_values[index];
+      }
+
+      // now add all of the computed heat fluxes to the statistics object
+      // and create a single string that can be output to the screen
+      std::ostringstream screen_text;
+      unsigned int index = 0;
+      for (std::map<types::boundary_id, double>::const_iterator
+           p = global_boundary_fluxes.begin();
+           p != global_boundary_fluxes.end(); ++p, ++index)
+        {
+          const std::string name = "Outward heat flux (gradient) through boundary with indicator "
+                                   + Utilities::int_to_string(p->first)
+                                   + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                 .translate_id_to_symbol_name (p->first))
+                                   + " (W)";
+          statistics.add_value (name, p->second);
+
+          // also make sure that the other columns filled by the this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (name, 8);
+          statistics.set_scientific (name, true);
+
+          // finally have something for the screen
+          screen_text.precision(4);
+          screen_text << p->second << " W"
+                      << (index == global_boundary_fluxes.size()-1 ? "" : ", ");
+        }
+
+      return std::pair<std::string, std::string> ("Heat fluxes (gradient) through boundary parts:",
+                                                  screen_text.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(HeatFluxStatisticsGradient,
+                                  "heat flux statistics gradient",
+                                  "A postprocessor that computes some statistics about "
+                                  "the (conductive) heat flux across boundaries. For each boundary "
+                                  "indicator (see your geometry description for which boundary "
+                                  "indicators are used), the heat flux is computed in outward "
+                                  "direction, i.e., from the domain to the outside, using the "
+                                  "formula $\\int_{\\Gamma_i} -k \\nabla T \\cdot \\mathbf n$ "
+                                  "where $\\Gamma_i$ is the part of the boundary with indicator $i$, "
+                                  "$k$ is the thermal conductivity as reported by the material model, "
+                                  "$T$ is the temperature, and $\\mathbf n$ is the outward normal. "
+                                  "Note that the quantity so computed does not include any energy "
+                                  "transported across the boundary by material transport in cases "
+                                  "where $\\mathbf u \\cdot \\mathbf n \\neq 0$. The point-wise "
+                                  "heat flux can be obtained from the heat flux map postprocessor, "
+                                  "which outputs the heat flux to a file, or the heat flux map "
+                                  "visualization postprocessor, which outputs the heat flux for "
+                                  "visualization. "
+                                  "\n\n"
+                                  "As stated, this postprocessor computes the \\textit{outbound} heat "
+                                  "flux. If you "
+                                  "are interested in the opposite direction, for example from "
+                                  "the core into the mantle when the domain describes the "
+                                  "mantle, then you need to multiply the result by -1."
+                                  "\n\n"
+                                  "\\note{In geodynamics, the term ``heat flux'' is often understood "
+                                  "to be the quantity $- k \\nabla T$, which is really a heat "
+                                  "flux \\textit{density}, i.e., a vector-valued field. In contrast "
+                                  "to this, the current postprocessor only computes the integrated "
+                                  "flux over each part of the boundary. Consequently, the units of "
+                                  "the quantity computed here are $W=\\frac{J}{s}$.}"
+                                  "\n\n"
+                                  "The ``heat flux densities'' postprocessor computes the same "
+                                  "quantity as the one here, but divided by the area of "
+                                  "the surface.")
+  }
+}
diff --git a/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.h.bak b/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.h.bak
new file mode 100644
index 00000000000..be9b019128c
--- /dev/null
+++ b/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.h.bak
@@ -0,0 +1,53 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_heat_flux_statistics_gradient_h
+#define _aspect_postprocess_heat_flux_statistics_gradient_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    /**
+     * A postprocessor that computes some statistics about the heat_flux based
+     * on the gradient of the temperature.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class HeatFluxStatisticsGradient : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm b/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm
index d3006d93625..e72349df709 100644
--- a/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm
+++ b/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm
@@ -100,7 +100,6 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
     set Global composition maximum = 100.0, 1.0, 1.0, 1.0
     set Global composition minimum =   0.0, 0.0, 0.0, 1.0
   end
diff --git a/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm.bak b/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm.bak
new file mode 100644
index 00000000000..d3006d93625
--- /dev/null
+++ b/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm.bak
@@ -0,0 +1,179 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1e6
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-3
+set Max nonlinear iterations               = 100
+set CFL number                             = 0.5
+set Output directory                       = output_figure_6_1e20
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+
+# Model geometry (400x35 km)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 400
+    set Y repetitions = 100
+    set X extent      = 400e3
+    set Y extent      = 35e3
+  end
+end
+
+# No mesh refinement, but the coarse mesh is 400x100
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# The nonlinear solver typically converges more quickly
+# when no cheap Stokes solver steps are used for
+# problems with Drucker-Prager plasticity.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+# Free surface boundary classifications.
+# Advecting the free surface vertically rather than
+# in the surface normal direction can result in a
+# more stable mesh when the deformation is large
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Surface velocity projection = vertical
+  end
+end
+
+# Velocity on boundaries characterized by functions
+# Total extension rate is 1 cm/yr (0.5 cm/yr on each side)
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: function, right x:function
+  set Tangential velocity boundary indicators = bottom
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.005, year=1
+    set Function expression = if (x<200e3 , -1*m/year, 1*m/year); 0.
+  end
+end
+
+# Number and name of compositional fields
+# The field plastic_strain is used for tracking the plastic finite strain invariant
+# upper: brittle upper crust; seed: 'weaker' brittle region
+# lower: viscous lower crust
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = plastic_strain, upper, seed, lower
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0; \
+                              if((y>=17.5e3 && x<=198.0e3) || (y>=17.5e3 && x>=202.0e3) || \
+                                 (y>=18.9e3 && x>=198.0e3 && x<=202.0e3), 1, 0); \
+                              if(y>=17.5e3 && y<18.9e3 && x>198.0e3 && x<202.0e3, 1, 0); \
+                              if(y<17.5e3, 1, 0);
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Use discontinuous composition bound preserving limiter
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 2
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
+    set Global composition maximum = 100.0, 1.0, 1.0, 1.0
+    set Global composition minimum =   0.0, 0.0, 0.0, 1.0
+  end
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Temperature initial conditions (isothermal)
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Minimum strain rate   = 1.e-20
+    set Reference strain rate = 1.e-16
+    set Minimum viscosity     = 1e18
+    set Maximum viscosity     = 1e26
+    set Thermal diffusivities = 1.e-6
+    set Heat capacities       = 750.
+    set Densities             = 2800
+    set Thermal expansivities = 0.
+    set Viscosity averaging scheme = harmonic
+    set Viscous flow law           = dislocation
+    set Prefactors for dislocation creep          = 5.e-25, 5.e-25, 5.e-25, 5.e-25, 5.e-21
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Angles of internal friction =   30.,   30.,   30.,   4.,   30.
+    set Cohesions                   = 20.e6, 20.e6, 20.e6, 2.e6, 1.e11
+    set Strain weakening mechanism = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals  =     0.5,    0.5,    0.5, 0.5, 0.5
+    set End plasticity strain weakening intervals    =     1.5,    1.5,    1.5, 1.5, 1.5
+    set Cohesion strain weakening factors            =     0.1,    0.1,    0.1, 1.0, 1.0
+    set Friction strain weakening factors            = 0.13333, 0.1333, 0.1333, 1.0, 1.0
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, error indicator, partition
+    set Time between graphical output = 1e5
+    set Interpolate output = false
+  end
+end
diff --git a/benchmarks/buiter_et_al_2008_jgr/figure_6_1e22.prm.bak b/benchmarks/buiter_et_al_2008_jgr/figure_6_1e22.prm.bak
new file mode 100644
index 00000000000..1a5a5380b6d
--- /dev/null
+++ b/benchmarks/buiter_et_al_2008_jgr/figure_6_1e22.prm.bak
@@ -0,0 +1,12 @@
+include figure_6_1e20.prm
+
+set Dimension                              = 2
+set Output directory                       = output_figure_6_1e22
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Prefactors for dislocation creep = 5.e-25, 5.e-25, 5.e-25, 5.e-25, 5.e-23
+  end
+end
diff --git a/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm b/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm
index 544ad88b0ac..6e2907fd476 100644
--- a/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm
+++ b/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm
@@ -21,9 +21,9 @@ subsection Discretization
   set Use discontinuous composition discretization   = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
     set Global composition maximum                 = 1, 1, 1, 1, 1, 100
     set Global composition minimum                 = 0, 0, 0, 0, 0, 0
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm.bak b/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm.bak
new file mode 100644
index 00000000000..544ad88b0ac
--- /dev/null
+++ b/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm.bak
@@ -0,0 +1,44 @@
+# Note that the Linear/Nonlinear solver tolerance should be sufficiently strict
+# to avoid numerical instabilities.
+set Nonlinear solver scheme                 = single Advection, iterated Stokes
+set Nonlinear solver tolerance               = 1e-7
+set Max nonlinear iterations                = 100
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance             = 1e-8
+    set Number of cheap Stokes solver steps = 0
+
+    # A higher restart length makes the solver more robust for large viscosity
+    # contrasts.
+    set GMRES solver restart length         = 200
+  end
+end
+
+# The  discontinuous composition bound preserving limiter produces sharp
+# interfaces between compositional layers.
+subsection Discretization
+  set Use discontinuous composition discretization   = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+    set Global composition maximum                 = 1, 1, 1, 1, 1, 100
+    set Global composition minimum                 = 0, 0, 0, 0, 0, 0
+  end
+end
+
+# Material properties
+# Using harmonic material averaging is required to achieve reasonable
+# convergence behavior, particulally when the viscosity contrast is large.
+subsection Material model
+  set Material averaging                             = harmonic average
+  set Model name                                     = visco plastic
+
+  subsection Visco Plastic
+    # The viscosity contrast is 10^7 here and any value higher than this causes
+    # divergence of the solver.
+    set Minimum viscosity                            = 1e5
+    set Maximum viscosity                            = 1e12
+    set Viscosity averaging scheme                   = harmonic
+  end
+end
diff --git a/benchmarks/buiter_et_al_2016_jsg/doc/velocity_bc.part.prm.bak b/benchmarks/buiter_et_al_2016_jsg/doc/velocity_bc.part.prm.bak
new file mode 100644
index 00000000000..3a997ed04db
--- /dev/null
+++ b/benchmarks/buiter_et_al_2016_jsg/doc/velocity_bc.part.prm.bak
@@ -0,0 +1,37 @@
+# Spatial domain of different compositional fields:
+# Quartz sand (qsand) has two layers with 1 cm thickness each.
+# Corundum sand (csand) is in the middle of the 2-layer quatz sand and is
+# 1 cm thick.
+# The boundary 2-mm-thin layers (bound) sit on both the bottom of the domain and
+# between the sand and rigid indenter block. The right boundary has a constant
+# inflow velocity, which pushes a rigid block that approximates a mobile wall.
+# Movement of the rigid block drives deformation in the sand layers.
+# The boundary between the rigid block and boundary layers produces a sharp
+# velocity discontinuity that localizes brittle deformation.
+# The sticky air layer is set on top of the sand layer and approximates a
+# free surface.
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Zero velocity boundary indicators              = bottom    #no slip
+  set Tangential velocity boundary indicators        = left      #free slip
+
+  # right - material inflow with a velocity of 2.5 cm/hour at the height of
+  # the pushing block. The velocity linearly decreases from the base of the
+  # rigid block to 0 cm/hour at the base of the model.
+  set Prescribed velocity boundary indicators        = right:function
+
+  subsection Function
+    set Variable names                             = x,y
+    set Function constants                         = cm=0.01, h=3600, th=0.002
+    set Function expression                        = if(y>th, -2.5*cm/h, -(y/th)*2.5*cm/h); 0
+  end
+end
+
+# The top boundary is open (zero traction), which allows the sticky air to
+# flow freely through it as topography develops along the wedge. Additional
+# testing revealed that using a true free surface leads to significant mesh
+# distortion and associated numerical instabilities.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators        = top: zero traction
+end
diff --git a/benchmarks/buiter_et_al_2016_jsg/exp_1.prm b/benchmarks/buiter_et_al_2016_jsg/exp_1.prm
index 51b2116626e..976b4f505b3 100644
--- a/benchmarks/buiter_et_al_2016_jsg/exp_1.prm
+++ b/benchmarks/buiter_et_al_2016_jsg/exp_1.prm
@@ -106,11 +106,10 @@ subsection Discretization
   set Use discontinuous composition discretization  = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-
     #                                            [sand,  bound, block, sticky_air, total_strain]
     set Global composition maximum                = 1.,     1.,    1.,    1.,         1e5
     set Global composition minimum                = 0.,     0.,    0.,    0.,         0.
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/benchmarks/buiter_et_al_2016_jsg/exp_1.prm.bak b/benchmarks/buiter_et_al_2016_jsg/exp_1.prm.bak
new file mode 100644
index 00000000000..51b2116626e
--- /dev/null
+++ b/benchmarks/buiter_et_al_2016_jsg/exp_1.prm.bak
@@ -0,0 +1,191 @@
+# This is an input file for the setup for the benchmark described in Buiter et al, 2016
+# which simulates a stable wedge undergoing translation.
+# Experiment 2 can be found in $ASPECT_INSTALL/aspect/benchmarks/buiter_et_al_2016_jsg
+# Please refer to the README file for further details on the experimental setup and results.
+#####  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 14400 # Equivalent to 10 cm of horizontal translation
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+
+# Note that the Linear/Nonlinear solver tolerance should be sufficiently
+# strict to avoid numerical instabilities.
+
+set Nonlinear solver tolerance             = 1e-7
+set Max nonlinear iterations               = 100
+set CFL number                             = 0.5
+set Output directory                       = output-stable_wedge
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+set Resume computation         = auto
+
+#### Parameters describing the model
+
+# Model geometry
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 300
+    set Y repetitions = 70
+    set X extent      = 0.15
+    set Y extent      = 0.035
+  end
+end
+
+# Mesh refinement specifications
+# AMR is not used since model X,Y repetitions are defined.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications
+# Temperature boundary conditions
+# Temperature does not affect model
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left
+  set Prescribed velocity boundary indicators = right:function
+  set Zero velocity boundary indicators       = bottom
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = cm=0.01, h=3600., th=0.002                  # h = hr = 3600 s; th = thickness of bounding box
+    set Function expression = if (y>th, -2.5*cm/h, -(y/th)*2.5*cm/h) ; 0. # velocity BC is defined such that the wedge is pushed at 2.5 cm/h to the left above the bound                            -ing box and tapers to zero from the top to the bottom of the bounding box.
+  end
+end
+
+# The zero traction surface allows sticky air to leave the system in response to compression.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = top: zero traction
+end
+
+# Initial temperature field
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 100
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 5
+  set Names of fields  = sand, bound, block, sticky_air, total_strain
+end
+
+# Spatial domain of different compositional fields:
+# Sand wedge with taper angle of 20 degrees,
+# Box bounding simulated sandbox experiment,
+# Rigid indentor used to translate wedge, and
+# Sticky air layer above modelled materials
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = th=0.002
+    set Function expression = if((x<0.1324 && x>=0.05) && (y<=0.36408*x-0.0182039 && y>=th), 1, 0); \
+                              if((x>=0.1324 && x<0.1329) || (x>0 && y<=th),1,0); \
+                              if(x>=0.1329 && y>th,1,0); \
+            if((x<=0.1324 && y>0.36408*x-0.0182039 && y>th) || (x<0.05 && y>th),1,0); \
+            0;
+  end
+end
+
+# Use disccontinous composition bound preserving limiter
+subsection Discretization
+  set Use discontinuous composition discretization  = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+
+    #                                            [sand,  bound, block, sticky_air, total_strain]
+    set Global composition maximum                = 1.,     1.,    1.,    1.,         1e5
+    set Global composition minimum                = 0.,     0.,    0.,    0.,         0.
+  end
+end
+
+# Material model
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    #                                                 [bkd, sand,  bound, block, sticky_air, total_strain]
+    set Densities                                   = 1560, 1560., 3100,  1560 , 0,          1560
+    set Reference temperature                       = 293
+    set Heat capacities                             = 750.
+    set Thermal diffusivities                       = 1e-6
+    set Thermal expansivities                       = 0.
+    set Minimum viscosity                           = 1e4
+    set Maximum viscosity                           = 1e12
+    set Viscosity averaging scheme                  = maximum composition
+    set Viscous flow law                            = dislocation
+    set Prefactors for dislocation creep            = 5e-11,5e-50, 5e-50, 5e-11, 5e-5,       1e5
+    set Stress exponents for dislocation creep      = 1.0
+    set Activation energies for dislocation creep   = 0.
+    set Activation volumes for dislocation creep    = 0.
+
+    #                                                 [bkd, sand,  bound, block, sticky_air, total_strain]
+    set Reference strain rate                       = 1.e-5
+    set Minimum strain rate                         = 1.e-10
+    set Strain weakening mechanism                  = total strain
+    set Start plasticity strain weakening intervals = 0,    0.50,  0.5,   0,     0,          1e5
+    set End plasticity strain weakening intervals   = 0.1,  1.00,  1,     0.1,   0.1,        1e4
+    set Angles of internal friction                 = 36.,  36.,   1.6,   0.,    0.,         1e5
+    set Friction strain weakening factors           = 1,    0.861, 1,     1,     1,          1e5
+    set Cohesions                                   = 30.,  30.,   3.,    1.e18, 1.e18,      1e5
+    set Cohesion strain weakening factors           = 1,    1.00,  1,     1,     1,          1e5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name  = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# Checkpointing for restart files
+subsection Checkpointing
+  set Steps between checkpoint = 10
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, visualization
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, strain rate, named additional outputs
+    set Output format                 = vtu
+    set Time between graphical output = 144
+    set Interpolate output            = false
+  end
+end
+
+# Termination Criteria
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step             = 10000
+end
+
+# Note that the Linear/Nonlinear solver tolerance should be sufficiently
+# strict to avoid numerical instabilities.
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance             = 1e-8
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm b/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm
index b2496ed311c..dba24612726 100644
--- a/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm
+++ b/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm
@@ -48,9 +48,9 @@ subsection Discretization
   set Use discontinuous composition discretization   = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
     set Global composition maximum                 = 1, 1, 1, 1, 1, 100
     set Global composition minimum                 = 0, 0, 0, 0, 0, 0
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm.bak b/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm.bak
new file mode 100644
index 00000000000..b2496ed311c
--- /dev/null
+++ b/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm.bak
@@ -0,0 +1,224 @@
+# This parameter file reproduces the unstable wedge experiment 2 from
+# Buiter et al., 2016, JSG.
+# Experiment 2 tests how an unstable subcritical wedge deforms to reach the
+# critical taper solution. Horizontal layers of sand have 10 cm shortening
+# by inward movement of a mobile wall with a velocity of 2.5 cm/hour. Both
+# the base and the surface are horizontal and the “wedge” is thus in the
+# unstable field. This experiment builds a thrust wedge through a combination
+# of mainly in-sequence forward and backward thrusting. Deformation starts by
+# forming a pop-up structure near the high viscosity rigid indenter.
+
+#  Global parameters
+set Dimension                                        = 2
+set Start time                                       = 0
+set End time                                         = 14400 #Equivalent to ~10 cm of shortening
+set Use years in output instead of seconds           = false
+set CFL number                                       = 0.5
+set Output directory                                 = output-Brittle_thrust_wedge_exp2
+set Pressure normalization                           = no
+set Timing output frequency                          = 20
+
+# Note that the Linear/Nonlinear solver tolerance should be sufficiently
+# strict to avoid numerical instabilities.
+set Nonlinear solver scheme                          = single Advection, iterated Stokes
+set Nonlinear solver tolerance                       = 1e-7
+set Max nonlinear iterations                         = 100
+
+# For restarting the model
+set Resume computation                               = auto
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                      = 1e-8
+    set Number of cheap Stokes solver steps          = 0
+
+    # A higher restart length makes the solver more robust for large viscosity
+    # contrasts.
+    set GMRES solver restart length                  = 200
+  end
+end
+
+# The  discontinuous composition bound preserving limiter produces sharp
+# interfaces between compositional layers.
+subsection Discretization
+  set Composition polynomial degree                  = 2
+  set Temperature polynomial degree                  = 2
+  set Stokes velocity polynomial degree              = 2
+  set Use locally conservative discretization        = false
+  set Use discontinuous composition discretization   = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+    set Global composition maximum                 = 1, 1, 1, 1, 1, 100
+    set Global composition minimum                 = 0, 0, 0, 0, 0, 0
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint                       = 20
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name                                     = vertical
+
+  subsection Vertical
+    set Magnitude                                    = 9.81
+  end
+end
+
+### Parameters describing the model
+
+# Model geometry (36 x 8 cm)
+subsection Geometry model
+  set Model name                                    = box
+
+  subsection Box
+    set X repetitions                               = 180
+    set Y repetitions                               = 40
+    set X extent                                    = 0.36
+    set Y extent                                    = 0.08
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement                    = 0
+
+  #The resolution is 0.5 mm/cell
+  set Initial global refinement                      = 2
+  set Time steps between mesh refinement             = 0
+end
+
+# Boundary conditions & initial conditions
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Fixed composition boundary indicators          = bottom, left, right
+  set List of model names                            = initial composition
+end
+
+# Number and names of compositional fields
+subsection Compositional fields
+  set Number of fields                               = 6
+  set Names of fields                                = qsand,csand,bound,block, \
+                                                       sticky_air,total_strain
+end
+
+# Spatial domain of different compositional fields:
+# Quartz sand (qsand) has two layers with 1 cm thickness each.
+# Corundum sand (csand) is in the middle of the 2-layer quatz sand and is
+# 1 cm thick.
+# The boundary 2-mm-thin layers (bound) sit on both the bottom of the domain and
+# between the sand and rigid indenter block. The right boundary has a constant
+# inflow velocity, which pushes a rigid block that approximates a mobile wall.
+# Movement of the rigid block drives deformation in the sand layers.
+# The boundary between the rigid block and boundary layers produces a sharp
+# velocity discontinuity that localizes brittle deformation.
+# The sticky air layer is set on top of the sand layer and approximates a
+# free surface.
+
+subsection Initial composition model
+  set Model name                                     = function
+
+  subsection Function
+    set Variable names                               = x,y
+    set Function constants                           = w1=0.35, w2=0.352, \
+                                                     h1=0.002, h2=0.012, \
+                                                     h3=0.022, h4=0.032
+    set Function expression = if((x<=w1 & y<=h2 & y>h1) || (x<= w1 & y>h3 & y<=h4), 1,0); \
+                              if((x<=w1 & y>h2 & y<=h3), 1,0); \
+                              if((x>w1 & x<=w2 & y>h1) ||(y<=h1), 1, 0); \
+                              if(x>w2 & y>h1,1,0); \
+                              if(x<=w1 & y>h4,1,0); 0
+  end
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators          = bottom, top
+  set List of model names                            = initial temperature
+end
+
+# Initial temperature field
+subsection Initial temperature model
+  set Model name                                     = function
+
+  subsection Function
+    set Function expression                          = 293
+  end
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Zero velocity boundary indicators              = bottom    #no slip
+  set Tangential velocity boundary indicators        = left      #free slip
+
+  # right - material inflow with a velocity of 2.5 cm/hour at the height of
+  # the pushing block. The velocity linearly decreases from the base of the
+  # rigid block to 0 cm/hour at the base of the model.
+  set Prescribed velocity boundary indicators        = right:function
+
+  subsection Function
+    set Variable names                             = x,y
+    set Function constants                         = cm=0.01, h=3600, th=0.002
+    set Function expression                        = if(y>th, -2.5*cm/h, -(y/th)*2.5*cm/h); 0
+  end
+end
+
+# The top boundary is open (zero traction), which allows the sticky air to
+# flow freely through it as topography develops along the wedge. Additional
+# testing revealed that using a true free surface leads to significant mesh
+# distortion and associated numerical instabilities.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators        = top: zero traction
+end
+
+# Material properties
+# Using harmonic material averaging is required to achieve reasonable
+# convergence behavior, particulally when the viscosity contrast is large.
+subsection Material model
+  set Material averaging                             = harmonic average
+  set Model name                                     = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature                        = 293
+    set Minimum strain rate                          = 1e-20
+    set Reference strain rate                        = 2e-5
+
+    # The viscosity contrast is 10^7 here and any value higher than this causes
+    # divergence of the solver.
+    set Minimum viscosity                            = 1e5
+    set Maximum viscosity                            = 1e12
+    set Thermal diffusivities                        = 1e-6
+    set Heat capacities                              = 750
+    set Densities                                    = 1560, 1560, 1890, 1560, 3000, 0, 1e5
+    set Thermal expansivities                        = 0
+    set Viscosity averaging scheme                   = harmonic
+    set Viscous flow law                             = dislocation
+    set Prefactors for dislocation creep             = 5e-15, 5e-15, 5e-15, 5e-15, 5e-18, 5e-5, 5e-18
+    set Stress exponents for dislocation creep       = 1
+    set Activation energies for dislocation creep    = 0
+    set Activation volumes for dislocation creep     = 0
+    set Angles of internal friction                  = 36, 36, 36, 16, 0, 0, 1e18
+    set Cohesions                                    = 30, 30, 30, 30, 1e18, 1e18, 1e18
+    set Strain weakening mechanism                   = total strain
+    set Start plasticity strain weakening intervals  = 0.5
+    set End plasticity strain weakening intervals    = 1
+    set Cohesion strain weakening factors            = 1
+    set Friction strain weakening factors            = 1, 0.861, 0.861, 0.875, 1, 1, 1
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors                         = velocity statistics, basic statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set List of output variables                     = density, viscosity, strain rate, error indicator
+    set Output format                                = vtu
+    set Time between graphical output                = 144   # Equivalent to ~0.5 cm of shortening
+    set Interpolate output                           = true
+    set Number of grouped files                      = 1
+  end
+end
diff --git a/benchmarks/buiter_et_al_2016_jsg/exp_2_low_resolution.prm.bak b/benchmarks/buiter_et_al_2016_jsg/exp_2_low_resolution.prm.bak
new file mode 100644
index 00000000000..977ff6d9841
--- /dev/null
+++ b/benchmarks/buiter_et_al_2016_jsg/exp_2_low_resolution.prm.bak
@@ -0,0 +1,32 @@
+# This is the unstable wedge experiment 2
+# This prm file is the same as the exp_2_high_resolution.prm file except
+# changes below.
+
+
+
+include $ASPECT_SOURCE_DIR/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm
+
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement                 = 0
+
+  # The resolution is 2 mm/cell.
+  set Initial global refinement                   = 0
+  set Time steps between mesh refinement          = 0
+end
+
+# Material properties
+
+subsection Material model
+  set Model name                                  = visco plastic
+
+  subsection Visco Plastic
+    # Further testing revealed that decreasing the model resolution allows
+    # using a higher contrast between the minimum and maximum viscosity.
+    # The viscosity contrast is 10^8 here and any value higher than this
+    # causes divergence of the solver.
+    set Minimum viscosity                        = 1e4
+    set Maximum viscosity                        = 1e12
+  end
+end
diff --git a/benchmarks/burstedde/burstedde.cc.bak b/benchmarks/burstedde/burstedde.cc.bak
new file mode 100644
index 00000000000..08a0b68dbb1
--- /dev/null
+++ b/benchmarks/burstedde/burstedde.cc.bak
@@ -0,0 +1,517 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/postprocess/interface.h>
+
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  /**
+   * This is the "Burstedde" benchmark defined in the following paper:
+   * @code
+   *  @Article{busa13,
+   *    author =       {Burstedde, Carsten and Stadler, Georg and Alisic, Laura and Wilcox, Lucas C and Tan, Eh and Gurnis, Michael and Ghattas, Omar},
+   *    title =        {Large-scale adaptive mantle convection simulation},
+   *    journal =      {Geophysical Journal International},
+   *    year =         2013,
+   *    volume =       192,
+   *    number =       {3},
+   *    publisher =    {Oxford University Press},
+   *    pages =        {889--906}}
+   * @endcode
+   *
+   */
+  namespace BursteddeBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+      Tensor<1,3>
+      burstedde_velocity (const Point<3> &pos,
+                          const double /*eta*/)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const double z = pos[2];
+
+        // create a Point<3> (because it has a constructor that takes
+        // three doubles) and return it (it automatically converts to
+        // the necessary Tensor<1,3>).
+        return Point<3> (x+x*x+x*y+x*x*x*y,
+                         y+x*y+y*y+x*x*y*y,
+                         -2.*z-3.*x*z-3.*y*z-5.*x*x*y*z);
+      }
+
+      double
+      burstedde_pressure (const Point<3> &pos,
+                          const double /*eta*/)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const double z = pos[2];
+
+        return x*y*z+x*x*x*y*y*y*z-5./32.;
+      }
+
+
+      /**
+       * The exact solution for the Burstedde benchmark.
+       */
+      template <int dim>
+      class FunctionBurstedde : public Function<dim>
+      {
+        public:
+          FunctionBurstedde (const double beta)
+            :
+            Function<dim>(dim+2),
+            beta_(beta)
+          {}
+
+          void vector_value (const Point<dim>   &pos,
+                             Vector<double>   &values) const override
+          {
+            Assert (dim == 3, ExcNotImplemented());
+            Assert (values.size() >= 4, ExcInternalError());
+
+            const Point<3> p (pos[0], pos[1], pos[2]);
+
+            const Tensor<1,3> v = AnalyticSolutions::burstedde_velocity (p, beta_);
+            values[0] = v[0];
+            values[1] = v[1];
+            values[2] = v[2];
+
+            values[3] = AnalyticSolutions::burstedde_pressure (p, beta_);
+          }
+
+        private:
+          const double beta_;
+      };
+    }
+
+
+
+    template <int dim>
+    class BursteddeBoundary : public BoundaryVelocity::Interface<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        BursteddeBoundary();
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position) const override;
+
+      private:
+        const double beta;
+    };
+
+    template <int dim>
+    BursteddeBoundary<dim>::BursteddeBoundary ()
+      :
+      beta (0)
+    {}
+
+
+
+    template <>
+    Tensor<1,2>
+    BursteddeBoundary<2>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<2> &/*p*/) const
+    {
+      Assert (false, ExcNotImplemented());
+      return Tensor<1,2>();
+    }
+
+
+
+    template <>
+    Tensor<1,3>
+    BursteddeBoundary<3>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<3> &p) const
+    {
+      return AnalyticSolutions::burstedde_velocity (p, beta);
+    }
+
+
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class BursteddeMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> &p = in.position[i];
+
+              const double x=p[0];
+              const double y=p[1];
+              const double z=p[2];
+              const double mu=exp(1. - beta * (x*(1.-x)+y*(1.-y) + z*(1.-z)));
+
+              out.viscosities[i] = mu;
+              out.thermal_conductivities[i] = 0.0;
+              out.densities[i] = 1.0;
+
+              out.thermal_expansion_coefficients[i] = 0.0;
+              out.compressibilities[i] = 0.0;
+
+              out.specific_heat[i] = 0.0;
+
+              // Pressure derivative of entropy at the given positions.
+              out.entropy_derivative_pressure[i] = 0.0;
+              // Temperature derivative of entropy at the given positions.
+              out.entropy_derivative_temperature[i] = 0.0;
+              // Change in composition due to chemical reactions at the
+              // given positions. The term reaction_terms[i][c] is the
+              // change in compositional field c at point i.
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                out.reaction_terms[i][c] = 0.0;
+
+            }
+
+        }
+
+
+
+
+
+
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Returns the viscosity value in the inclusion
+         */
+        double get_beta() const;
+
+        /**
+         * viscosity value in the inclusion
+         */
+        double beta;
+    };
+
+
+
+    template <int dim>
+    bool
+    BursteddeMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    BursteddeMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      //create a global section in the parameter file for parameters
+      //that describe this benchmark. note that we declare them here
+      //in the material model, but other kinds of plugins (e.g., the gravity
+      //model below) may also read these parameters even though they do not
+      //declare them
+      prm.enter_subsection("Burstedde benchmark");
+      {
+        prm.declare_entry("Viscosity parameter", "20",
+                          Patterns::Double (0),
+                          "Viscosity in the Burstedde benchmark.");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    BursteddeMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Burstedde benchmark");
+      {
+        beta = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+
+    template <int dim>
+    double
+    BursteddeMaterial<dim>::get_beta() const
+    {
+      return beta;
+    }
+
+    /**
+     * Gravity model for the Burstedde benchmark
+     */
+
+    template <int dim>
+    class BursteddeGravity : public aspect::GravityModel::Interface<dim>
+    {
+      public:
+        Tensor<1,dim> gravity_vector (const Point<dim> &pos) const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+        */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        double beta;
+    };
+
+    template <int dim>
+    Tensor<1,dim>
+    BursteddeGravity<dim>::
+    gravity_vector(const Point<dim> &pos) const
+    {
+
+      const double x=pos[0];
+      const double y=pos[1];
+      const double z=pos[2];
+      const double mu=exp(1. - beta * (x*(1.-x)+y*(1.-y) + z*(1.-z)));
+
+      const double dmudx=-beta*(1.-2.*x)*mu;
+      const double dmudy=-beta*(1.-2.*y)*mu;
+      const double dmudz=-beta*(1.-2.*z)*mu;
+
+      Tensor<1,dim> g;
+
+      g[0]=((y*z+3.*std::pow(x,2)*std::pow(y,3)*z)- mu*(2.+6.*x*y))
+           -dmudx*(2.+4.*x+2.*y+6.*std::pow(x,2)*y)
+           -dmudy*(x+std::pow(x,3)+y+2.*x*std::pow(y,2))
+           -dmudz*(-3.*z-10.*x*y*z);
+
+      g[1]=((x*z+3.*std::pow(x,3)*std::pow(y,2)*z)- mu*(2.+2.*std::pow(x,2)+2.*std::pow(y,2)))
+           -dmudx*(x+std::pow(x,3)+y+2.*x*std::pow(y,2))
+           -dmudy*(2.+2.*x+4.*y+4.*std::pow(x,2)*y)
+           -dmudz*(-3.*z-5.*std::pow(x,2)*z);
+
+      g[2]=((x*y+std::pow(x,3)*std::pow(y,3)) - mu*(-10.*y*z))
+           -dmudx*(-3.*z-10.*x*y*z)
+           -dmudy*(-3.*z-5.*std::pow(x,2)*z)
+           -dmudz*(-4.-6.*x-6.*y-10.*std::pow(x,2)*y);
+
+      return g;
+    }
+
+    template <int dim>
+    void
+    BursteddeGravity<dim>::declare_parameters (ParameterHandler &)
+    {
+      //nothing to declare here. This plugin will however, read parameters
+      //declared by the material model in the "Burstedde benchmark" section
+    }
+
+    template <int dim>
+    void
+    BursteddeGravity<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Burstedde benchmark");
+      {
+        beta = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+    }
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the paper Duretz et al. reference above.
+      */
+    template <int dim>
+    class BursteddePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    BursteddePostprocessor<dim>::execute (TableHandler &)
+    {
+      std::unique_ptr<Function<dim>> ref_func;
+      {
+        const BursteddeMaterial<dim> &
+        material_model
+          = Plugins::get_plugin_as_type<const BursteddeMaterial<dim>>(this->get_material_model());
+
+        ref_func = std::make_unique<AnalyticSolutions::FunctionBurstedde<dim>>(material_model.get_beta());
+      }
+
+      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                          dim+2);
+      ComponentSelectFunction<dim> comp_p(dim, dim+2);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_u,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_p,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_p);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_ul2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_pl2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+      std::ostringstream os;
+
+      os << std::scientific <<  u_l1
+         << ", " << p_l1
+         << ", " << u_l2
+         << ", " << p_l2;
+
+      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
+    }
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BursteddeBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(BursteddeMaterial,
+                                   "BursteddeMaterial",
+                                   "A material model that corresponds to the `Burstedde' benchmark. "
+                                   "See the manual for more information.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(BursteddeBoundary,
+                                            "BursteddeBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "`Burstedde' benchmark. See the manual for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(BursteddePostprocessor,
+                                  "BursteddePostprocessor",
+                                  "A postprocessor that compares the solution of the `Burstedde' benchmark "
+                                  "with the one computed by ASPECT "
+                                  "and reports the error. See the manual for more information.")
+    ASPECT_REGISTER_GRAVITY_MODEL(BursteddeGravity,
+                                  "BursteddeGravity",
+                                  "A gravity model in corresponding to the `Burstedde' benchmark. "
+                                  "See the manual for more information.")
+  }
+}
diff --git a/benchmarks/burstedde/burstedde.prm.bak b/benchmarks/burstedde/burstedde.prm.bak
new file mode 100644
index 00000000000..fc5bcb93414
--- /dev/null
+++ b/benchmarks/burstedde/burstedde.prm.bak
@@ -0,0 +1,104 @@
+# The 3D polynomial Stokes (burstedde) benchmark, for which an
+# analytical solution is available.
+#
+# See the manual for more information.
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+set Additional shared libraries            = ./libburstedde.so
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+############### Parameters describing the model
+# The setup is a 3d unit cube.
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+    set Z extent  = 1
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left  : BursteddeBoundary, \
+                                                right : BursteddeBoundary, \
+                                                front : BursteddeBoundary, \
+                                                back  : BursteddeBoundary, \
+                                                bottom: BursteddeBoundary, \
+                                                top   : BursteddeBoundary
+end
+
+subsection Material model
+  set Model name = BursteddeMaterial
+end
+
+subsection Gravity model
+  set Model name = BursteddeGravity
+end
+
+subsection Burstedde benchmark
+  #Viscosity parameter is beta
+  set Viscosity parameter             = 20
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, BursteddePostprocessor
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate
+  end
+end
diff --git a/benchmarks/burstedde/doc/burstedde.prm.bak b/benchmarks/burstedde/doc/burstedde.prm.bak
new file mode 100644
index 00000000000..830ec42fd67
--- /dev/null
+++ b/benchmarks/burstedde/doc/burstedde.prm.bak
@@ -0,0 +1,32 @@
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                = 1e-12
+  end
+end
+
+# Boundary conditions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left  : BursteddeBoundary, \
+                                                right : BursteddeBoundary, \
+                                                front : BursteddeBoundary, \
+                                                back  : BursteddeBoundary, \
+                                                bottom: BursteddeBoundary, \
+                                                top   : BursteddeBoundary
+end
+
+subsection Material model
+  set Model name = BursteddeMaterial
+end
+
+subsection Gravity model
+  set Model name = BursteddeGravity
+end
+
+subsection Burstedde benchmark
+  # Viscosity parameter is beta
+  set Viscosity parameter             = 20
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, BursteddePostprocessor
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/adiabatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/adiabatic.prm.bak
new file mode 100644
index 00000000000..24921c5158f
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe/adiabatic.prm.bak
@@ -0,0 +1,8 @@
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left
+  set List of model names = box
+
+  subsection Box
+    set Left temperature = 1600
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/ala.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/ala.prm.bak
new file mode 100644
index 00000000000..ea154381bf0
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe/ala.prm.bak
@@ -0,0 +1,14 @@
+subsection Formulation
+  set Mass conservation = reference density profile
+  set Temperature equation = reference density profile
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # A gravity is currently necessary to compute the reference profile.
+    # Set is so low that it does not affect the solution
+    set Magnitude = 0.000000001
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/hydrostatic.prm.bak
new file mode 100644
index 00000000000..503708897df
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe/hydrostatic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = hydrostatic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/isentropic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/isentropic.prm.bak
new file mode 100644
index 00000000000..74b3defb28c
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe/isentropic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = isentropic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm.bak
new file mode 100644
index 00000000000..afca18ae037
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm.bak
@@ -0,0 +1,125 @@
+# This is a benchmark to illustrate the effect of different formulations
+# of compressibility. It starts from a simple lateral pipe flow model,
+# in which material enters a lateral pipe with a prescribed velocity.
+# Due to internal heating the material expands and the velocity
+# changes to conserve mass.
+
+set Additional shared libraries = ../plugins/libcompressibility_formulations.so
+set Dimension = 2
+set End time                               = 5e8
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-12
+set Max nonlinear iterations               = 25
+set Output directory                       = output-lateral_pipe
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Number of points = 100000
+    set Composition reference profile = function
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = true
+  set Use discontinuous composition discretization = true
+  set Use discontinuous temperature discretization = true
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_field
+  set Compositional field methods = prescribed field
+  set Types of fields             = density
+end
+
+subsection Initial composition model
+  set Model name = adiabatic density
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Y extent = 100000
+    set X extent = 1000000
+    set X repetitions = 8
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Heating model
+  set List of model names =  adiabatic heating, shear heating, function
+
+  subsection Function
+    set Function expression = 1e-10 * exp(x/1000000)
+  end
+end
+
+############### Boundary conditions
+# We only fix the temperature at the upper boundary, the other boundaries
+# are isolating.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left
+  set List of model names = initial temperature
+end
+
+# To guarantuee a steady downward flow, we fix the velocity
+# at the top and bottom, and set it to free slip on the sides.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left:function
+  set Tangential velocity boundary indicators = bottom,top
+
+  subsection Function
+    set Function expression = 1e-2;0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Material model
+  set Model name = compressibility formulations
+
+  subsection Simple compressible model
+    set Thermal conductivity = 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics
+
+  subsection Visualization
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 1e7
+    set List of output variables = nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm.bak
new file mode 100644
index 00000000000..71b048352cb
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm.bak
@@ -0,0 +1,10 @@
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Material model
+  subsection Projected density model
+    set Use adiabatic pressure for density = true
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/sub_adiabatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/sub_adiabatic.prm.bak
new file mode 100644
index 00000000000..b1991f6d47d
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe/sub_adiabatic.prm.bak
@@ -0,0 +1,8 @@
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left
+  set List of model names = box
+
+  subsection Box
+    set Left temperature = 1400
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/ala.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/ala.prm.bak
new file mode 100644
index 00000000000..ae46431d4a2
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_advect/ala.prm.bak
@@ -0,0 +1,12 @@
+subsection Formulation
+  set Mass conservation = reference density profile
+  set Temperature equation = reference density profile
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.000000001
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/hydrostatic.prm.bak
new file mode 100644
index 00000000000..503708897df
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_advect/hydrostatic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = hydrostatic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/isentropic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/isentropic.prm.bak
new file mode 100644
index 00000000000..74b3defb28c
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_advect/isentropic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = isentropic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm.bak
new file mode 100644
index 00000000000..c627e9cd948
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm.bak
@@ -0,0 +1,135 @@
+# This is a benchmark to illustrate the effect of different formulations
+# of compressibility. It starts from a simple lateral pipe flow model,
+# in which material enters a vertical pipe with a prescribed velocity.
+# Due to increasing temperature at the boundary a density gradient is
+# advected into the model.
+
+set Additional shared libraries = ../plugins/libcompressibility_formulations.so
+set Dimension = 2
+set End time                               = 6201145.069582775
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-14
+set Max nonlinear iterations               = 25
+set Output directory                       = output-lateral_pipe
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Number of points = 100000
+    set Composition reference profile = function
+  end
+end
+
+subsection Heating model
+  set List of model names =
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+  set Composition polynomial degree = 2
+  set Use locally conservative discretization = true
+  set Use discontinuous composition discretization = true
+  set Use discontinuous temperature discretization = true
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-14
+  set Composition solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-14
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_field
+  set Compositional field methods = prescribed field
+  set Types of fields             = density
+end
+
+subsection Initial composition model
+  set Model name = adiabatic density
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Y extent = 100000
+    set X extent = 1000000
+    set X repetitions = 8
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+############### Boundary conditions
+# We only fix the temperature at the upper boundary, the other boundaries
+# are isolating.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 1600 + 200 * t / 1e7
+  end
+end
+
+# To guarantuee a steady downward flow, we fix the velocity
+# at the top and bottom, and set it to free slip on the sides.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left:function
+  set Tangential velocity boundary indicators = bottom,top
+
+  subsection Function
+    set Function expression = 2*1000000/(1e7*(exp(1)-1)) * exp(t/1e7); 0.0
+    set Variable names      = x,y,t
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600 + 200 * ln(1-x*(exp(1)-1)/(2*1000000))
+  end
+end
+
+subsection Material model
+  set Model name = compressibility formulations
+
+  subsection Simple compressible model
+    set Thermal conductivity = 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, material statistics, mass flux statistics
+
+  subsection Visualization
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 6201145.069582775 #1e7
+    set List of output variables = nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm.bak
new file mode 100644
index 00000000000..71b048352cb
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm.bak
@@ -0,0 +1,10 @@
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Material model
+  subsection Projected density model
+    set Use adiabatic pressure for density = true
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/ala.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/ala.prm.bak
new file mode 100644
index 00000000000..ae46431d4a2
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/ala.prm.bak
@@ -0,0 +1,12 @@
+subsection Formulation
+  set Mass conservation = reference density profile
+  set Temperature equation = reference density profile
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.000000001
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/hydrostatic.prm.bak
new file mode 100644
index 00000000000..503708897df
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/hydrostatic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = hydrostatic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/isentropic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/isentropic.prm.bak
new file mode 100644
index 00000000000..74b3defb28c
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/isentropic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = isentropic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm.bak
new file mode 100644
index 00000000000..ec3f7efd58c
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm.bak
@@ -0,0 +1,147 @@
+# This is a benchmark to illustrate the effect of different formulations
+# of compressibility. It starts from a simple lateral pipe flow model.
+# There is no prescribed velocity and one end of the pipe is left open.
+# Then the pressure at the open end is contiuously increased over time,
+# which should lead to a compression of the material in the pipe.
+# This effect can not be captured by all common compressibility
+# approximations except the projected density approximation if it
+# used the full (instead of the adiabatic) pressure.
+
+set Additional shared libraries = ../plugins/libcompressibility_formulations.so
+set Dimension = 2
+
+# 1e7 years
+set End time                               = 31557600e7
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-12
+set Maximum time step                      = 31557600e5
+set Pressure normalization                 = no
+set Output directory                       = output-lateral-pipe
+set Max nonlinear iterations               = 10
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Number of points = 100000
+    set Composition reference profile = function
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = true
+  set Use discontinuous composition discretization = true
+  set Use discontinuous temperature discretization = true
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
+
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_field
+  set Compositional field methods = prescribed field
+  set Types of fields             = density
+end
+
+subsection Initial composition model
+  set Model name = adiabatic density
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Y extent = 100000
+    set X extent = 1000000
+    set X repetitions = 32
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Heating model
+  set List of model names =
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators =
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right:function
+
+  subsection Function
+    # This generates a pressure of e * 100 MPa at 10 Myr
+    #set Function expression = -10 * t / (3600*24*365.25); 0.0
+    set Function expression = -1e8 * exp (t / (1e7*3600*24*365.25)); 0.0
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left:function
+  set Tangential velocity boundary indicators = bottom,top
+
+  subsection Function
+    set Function expression = 0.0;0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600
+  end
+end
+
+subsection Material model
+  set Model name = compressibility formulations
+
+  subsection Simple compressible model
+    set Thermal conductivity = 0.0
+
+    # We need to change the reference viscosity here
+    # slightly, to improve the accuracy, because
+    # of a more appropriate pressure scaling.
+    # This model is somewhat unusual in that all
+    # velocities are driven by dynamic pressure.
+    set Viscosity = 1e20
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics, pressure statistics
+
+  subsection Visualization
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 1e7
+    set List of output variables = adiabat, nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm.bak
new file mode 100644
index 00000000000..71b048352cb
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm.bak
@@ -0,0 +1,10 @@
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Material model
+  subsection Projected density model
+    set Use adiabatic pressure for density = true
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density_full_pressure.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density_full_pressure.prm.bak
new file mode 100644
index 00000000000..500450965b7
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density_full_pressure.prm.bak
@@ -0,0 +1,10 @@
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Material model
+  subsection Projected density model
+    set Use adiabatic pressure for density = false
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/ala.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/ala.prm.bak
new file mode 100644
index 00000000000..ae46431d4a2
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_transient/ala.prm.bak
@@ -0,0 +1,12 @@
+subsection Formulation
+  set Mass conservation = reference density profile
+  set Temperature equation = reference density profile
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.000000001
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/hydrostatic.prm.bak
new file mode 100644
index 00000000000..503708897df
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_transient/hydrostatic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = hydrostatic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/isentropic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/isentropic.prm.bak
new file mode 100644
index 00000000000..74b3defb28c
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_transient/isentropic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = isentropic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm.bak
new file mode 100644
index 00000000000..ffb9245c2b6
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm.bak
@@ -0,0 +1,138 @@
+# This is a benchmark to illustrate the effect of different formulations
+# of compressibility. It starts from a simple lateral pipe flow model.
+# There is no prescribed velocity, and one end of the pipe is open.
+# Due to internal heating the material in the pipe heats up, expands,
+# and creates a flow out of the open end of the pipe. The parameters
+# for this benchmark were chosen so that an analytical solution for
+# the mass flow out of the pipe exists.
+
+set Additional shared libraries = ../plugins/libcompressibility_formulations.so
+set Dimension = 2
+
+# 1e7 years
+set End time                               = 31557600e7
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-12
+set Maximum time step                      = 31557600e5
+set Output directory                       = output-lateral_pipe
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Number of points = 100000
+    set Composition reference profile = function
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = true
+  set Use discontinuous composition discretization = true
+  set Use discontinuous temperature discretization = true
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
+
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_field
+  set Compositional field methods = prescribed field
+  set Types of fields             = density
+end
+
+subsection Initial composition model
+  set Model name = adiabatic density
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Y extent = 100000
+    set X extent = 1000000
+    set X repetitions = 32
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Heating model
+  set List of model names = function
+
+  subsection Function
+    # dT_dt[K/yr] / yr_in_secs * c_P
+    set Function expression = 1e-4 / 31557600 * 1000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators =
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left:function
+  set Tangential velocity boundary indicators = bottom,top
+
+  subsection Function
+    set Function expression = 0.0;0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600
+  end
+end
+
+subsection Material model
+  set Model name = compressibility formulations
+
+  subsection Simple compressible model
+    set Thermal conductivity = 0.0
+    set Reference specific heat = 1000
+    set Reference compressibility     = 0.0
+    set Reference density             = 3300
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics
+
+  subsection Visualization
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 1e7
+    set List of output variables = adiabat, nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm.bak
new file mode 100644
index 00000000000..71b048352cb
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm.bak
@@ -0,0 +1,10 @@
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Material model
+  subsection Projected density model
+    set Use adiabatic pressure for density = true
+  end
+end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/timestep.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/timestep.prm.bak
new file mode 100644
index 00000000000..f18ce58326e
--- /dev/null
+++ b/benchmarks/compressibility_formulations/lateral_pipe_transient/timestep.prm.bak
@@ -0,0 +1 @@
+set Maximum time step = 24654375e5
diff --git a/benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc.bak b/benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc.bak
new file mode 100644
index 00000000000..29fce8b2b58
--- /dev/null
+++ b/benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc.bak
@@ -0,0 +1,265 @@
+/*
+  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/simulator/assemblers/stokes.h>
+#include <aspect/material_model/simple_compressible.h>
+#include <aspect/simulator_access.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    /**
+     * A material model that is identical to the simple compressible model,
+     * except that the density is tracked in a compositional field of type
+     * 'density' using the prescribed field advection method. It also
+     * allows some modification to the density and thermal expansivity
+     * calculation for the compressibility benchmarks.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class CompressibilityFormulations : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void initialize() override;
+
+        void update() override;
+
+        bool is_compressible () const override;
+
+        void
+        evaluate (const MaterialModelInputs<dim> &in,
+                  MaterialModelOutputs<dim> &out) const override;
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        static void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Pointer to the material model used as the base model
+         */
+        std::shared_ptr<MaterialModel::Interface<dim>> base_model;
+
+        /**
+         * The reference density
+         */
+        double reference_rho;
+
+        /**
+         * The constant thermal expansivity
+         */
+        double thermal_alpha;
+        bool use_exponential_alpha;
+
+        /**
+         * The constant compressibility.
+         */
+        double reference_compressibility;
+
+        /**
+         * Use the adiabatic instead of the full pressure for the
+         * density calculation.
+         */
+        bool use_adiabatic_pressure_for_density;
+    };
+
+
+
+    template <int dim>
+    void
+    CompressibilityFormulations<dim>::initialize()
+    {
+      base_model->initialize();
+    }
+
+
+
+    template <int dim>
+    void
+    CompressibilityFormulations<dim>::update()
+    {
+      base_model->update();
+    }
+
+
+
+    template <int dim>
+    bool
+    CompressibilityFormulations<dim>::
+    is_compressible () const
+    {
+      return this->get_parameters().formulation_mass_conservation != Parameters<dim>::Formulation::MassConservation::incompressible;
+    }
+
+
+
+    template <int dim>
+    void
+    CompressibilityFormulations<dim>::evaluate(const MaterialModelInputs<dim> &in,
+                                               MaterialModelOutputs<dim> &out) const
+    {
+      base_model->evaluate(in,out);
+
+      const unsigned int density_field_index = this->introspection().find_composition_type(Parameters<dim>::CompositionalFieldDescription::density);
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          double pressure_for_density = in.pressure[i];
+
+          // If using the PDA avoid using the real pressure for the density calculation to prevent
+          // pressure waves from forming
+          if (use_adiabatic_pressure_for_density)
+            pressure_for_density = this->get_adiabatic_conditions().pressure(in.position[i]);
+
+          double thermal_expansivity = thermal_alpha;
+          if (use_exponential_alpha)
+            {
+              thermal_expansivity *= std::exp(-1.117979323e-11*pressure_for_density);
+              out.thermal_expansion_coefficients[i] = thermal_expansivity;
+            }
+
+          // Use a thermodynamically consistent thermal expansivity
+          // (if alpha is constant, rho needs to depend exponentially on it, not linearly)
+          out.densities[i] = reference_rho * std::exp(reference_compressibility * (pressure_for_density - this->get_surface_pressure()) -
+                                                      thermal_expansivity * (in.temperature[i] - this->get_adiabatic_surface_temperature()));
+
+          // For the ICA, we have to provide the isentropic rather than isothermal compressibility
+          // for the mass conservation equation.
+          if (this->get_parameters().formulation_mass_conservation ==
+              Parameters<dim>::Formulation::MassConservation::isentropic_compression)
+            {
+              out.compressibilities[i] = reference_compressibility - std::pow(thermal_expansivity, 2) * in.temperature[i]
+                                         / (out.densities[i] * out.specific_heat[i]);
+            }
+        }
+
+      // prescribe the density field to the current value of the density. The actual projection
+      // only happens inside Simulator<dim>::interpolate_material_output_into_compositional_field,
+      // this just sets the correct term the field will be set to.
+      if (PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>())
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          prescribed_field_out->prescribed_field_outputs[i][density_field_index] = out.densities[i];
+    }
+
+
+
+    template <int dim>
+    void
+    CompressibilityFormulations<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::unique_ptr<MaterialModel::AdditionalMaterialOutputs<dim>>
+            (new MaterialModel::PrescribedFieldOutputs<dim> (n_points, this->n_compositional_fields())));
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    CompressibilityFormulations<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Projected density model");
+        {
+          prm.declare_entry ("Use adiabatic pressure for density", "false",
+                             Patterns::Bool(),
+                             "");
+          prm.declare_entry ("Use exponential thermal expansivity", "false",
+                             Patterns::Bool(),
+                             "");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      SimpleCompressible<dim>::declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    CompressibilityFormulations<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Projected density model");
+        {
+          use_adiabatic_pressure_for_density = prm.get_bool("Use adiabatic pressure for density");
+          use_exponential_alpha = prm.get_bool("Use exponential thermal expansivity");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simple compressible model");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+          reference_compressibility  = prm.get_double ("Reference compressibility");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // create the base model and initialize its SimulatorAccess base
+      // class; it will get a chance to read its parameters below after we
+      // leave the current section
+      base_model = create_material_model<dim>("simple compressible");
+      if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
+        sim->initialize_simulator (this->get_simulator());
+      base_model->parse_parameters(prm);
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(CompressibilityFormulations,
+                                   "compressibility formulations",
+                                   "A material model that is identical to the simple compressible model, "
+                                   "except that the density is tracked in a compositional field of type "
+                                   "'density' using the prescribed field advection method. It also "
+                                   "allows some modification to the density and thermal expansivity "
+                                   "calculation for the compressibility benchmarks.")
+  }
+}
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/adiabatic.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/adiabatic.prm.bak
new file mode 100644
index 00000000000..e7004ab4649
--- /dev/null
+++ b/benchmarks/compressibility_formulations/vertical_pipe/adiabatic.prm.bak
@@ -0,0 +1,8 @@
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1600
+  end
+end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/ala.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/ala.prm.bak
new file mode 100644
index 00000000000..2c233e84e40
--- /dev/null
+++ b/benchmarks/compressibility_formulations/vertical_pipe/ala.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = reference density profile
+  set Temperature equation = reference density profile
+end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/hydrostatic.prm.bak
new file mode 100644
index 00000000000..503708897df
--- /dev/null
+++ b/benchmarks/compressibility_formulations/vertical_pipe/hydrostatic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = hydrostatic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/isentropic.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/isentropic.prm.bak
new file mode 100644
index 00000000000..74b3defb28c
--- /dev/null
+++ b/benchmarks/compressibility_formulations/vertical_pipe/isentropic.prm.bak
@@ -0,0 +1,4 @@
+subsection Formulation
+  set Mass conservation = isentropic compression
+  set Temperature equation = real density
+end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm.bak
new file mode 100644
index 00000000000..71b048352cb
--- /dev/null
+++ b/benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm.bak
@@ -0,0 +1,10 @@
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Material model
+  subsection Projected density model
+    set Use adiabatic pressure for density = true
+  end
+end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/sub_adiabatic.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/sub_adiabatic.prm.bak
new file mode 100644
index 00000000000..7665fa17edc
--- /dev/null
+++ b/benchmarks/compressibility_formulations/vertical_pipe/sub_adiabatic.prm.bak
@@ -0,0 +1,8 @@
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1400
+  end
+end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm.bak
new file mode 100644
index 00000000000..04866b04635
--- /dev/null
+++ b/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm.bak
@@ -0,0 +1,133 @@
+# This is a benchmark to illustrate the effect of different formulations
+# of compressibility. It starts from a simple downward pipe flow model,
+# in which material enters a vertical pipe with a prescribed velocity.
+# Due to gravity and pressure the material compresses and the velocity
+# changes to conserve mass.
+
+set Additional shared libraries = ../plugins/libcompressibility_formulations.so
+set Dimension = 2
+set End time                               = 2e8
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-12
+set Max nonlinear iterations               = 25
+set Output directory                       = output-vertical_pipe
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Number of points = 1000000
+    set Composition reference profile = function
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = true
+  set Use discontinuous composition discretization = true
+  set Use discontinuous temperature discretization = true
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
+
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_field
+  set Compositional field methods = prescribed field
+  set Types of fields             = density
+end
+
+subsection Initial composition model
+  set Model name = adiabatic density
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10000
+    set Y extent = 1000000
+    set Y repetitions = 8
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+############### Boundary conditions
+# We only fix the temperature at the upper boundary, the other boundaries
+# are insulating.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1600
+  end
+end
+
+# To guarantuee a steady downward flow, we fix the velocity
+# at the bottom, leave the top open, and set it to free slip on the sides.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Function expression = 0;-1e-2
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Material model
+  set Model name = compressibility formulations
+
+  subsection Simple compressible model
+    set Thermal conductivity = 0.0
+  end
+end
+
+# We use a global refinement of 0 to have a single cell in width. More cells
+# allow for instabilities at the open boundary that would influence the
+# accuracy with increasing resolution.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics
+
+  subsection Visualization
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 1e7
+    set List of output variables = nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
+  end
+end
diff --git a/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc.bak b/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc.bak
new file mode 100644
index 00000000000..51ee940146a
--- /dev/null
+++ b/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc.bak
@@ -0,0 +1,179 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/geometry_model/box.h>
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/grid/tria_accessor.h>
+#include <deal.II/grid/tria.h>
+#include <cmath>
+#include <vector>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    /**
+     * A class deriving from Box<dim>, which changes the upper boundary
+       with a sinusoidal perturbation of a given order and amplitude.
+       The top surface is initialized with smooth sinusoidal topography.
+       Subsequent refinements at the surface would do linear interpolations
+       between the mesh points, potentially affecting the quality of the
+       sinusoidal perturbation. As such, if this class is used for topographic
+       relaxation benchmarks, it makes most sense to do it without mesh
+       refinement.
+     */
+    template <int dim>
+    class ReboundBox : public Box<dim>
+    {
+      public:
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         * Makes perturbs the top boundary of the box with a function
+         * of the form z' = amplitude * cos(order * x )
+         */
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter
+         * file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Give the depth of a point.
+         */
+        double depth( const Point<dim> &position) const override;
+
+        /**
+         * Give the maximal depth of a point.
+         */
+        double maximal_depth() const override;
+
+      private:
+
+        double order;  //Order of the perturbation
+        double amplitude;  //amplitude of the perturbation
+
+    };
+
+    template <int dim>
+    void
+    ReboundBox<dim>::
+    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
+    {
+
+      //Call the normal Box mesh generator
+      Box<dim>::create_coarse_mesh( coarse_grid );
+
+      //move the vertices
+      std::vector<bool> vertex_touched (coarse_grid.n_vertices(), false);
+
+      typename parallel::distributed::Triangulation<dim>::active_cell_iterator cell;
+      for (cell = coarse_grid.begin_active();  cell != coarse_grid.end();  ++cell)
+        for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell;  ++v)
+          if (vertex_touched[cell->vertex_index(v)] == false)
+            {
+              Point<dim> &vertex = cell->vertex(v);
+              vertex[dim-1] = vertex[dim-1] + std::cos(order*2.0*M_PI*vertex[0]/(this->get_extents()[0]))*
+                              amplitude*vertex[dim-1]/(this->get_extents()[dim-1]);
+              vertex_touched[cell->vertex_index(v)] = true;
+            }
+
+    }
+
+    template <int dim>
+    double
+    ReboundBox<dim>::maximal_depth() const
+    {
+      return Box<dim>::maximal_depth()+amplitude;
+    }
+
+    template <int dim>
+    double
+    ReboundBox<dim>::depth(const Point<dim> &position) const
+    {
+      return maximal_depth()-position(dim-1);
+    }
+
+    template <int dim>
+    void
+    ReboundBox<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      Box<dim>::declare_parameters(prm);
+
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Rebound Box");
+        {
+          prm.declare_entry ("Order", "1",
+                             Patterns::Double (0),
+                             "Order of the perturbation");
+          prm.declare_entry ("Amplitude", "0.1",
+                             Patterns::Double (0),
+                             "Scaled amplitude of the perturbation");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ReboundBox<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      Box<dim>::parse_parameters(prm);
+
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Rebound Box");
+        {
+          order = prm.get_double ("Order");
+          amplitude = prm.get_double ("Amplitude");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    ASPECT_REGISTER_GEOMETRY_MODEL(ReboundBox,
+                                   "rebound box",
+                                   "Geometry model for benchmarking relaxation of topography.")
+  }
+}
diff --git a/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm.bak b/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm.bak
new file mode 100644
index 00000000000..86783abb78a
--- /dev/null
+++ b/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm.bak
@@ -0,0 +1,139 @@
+# Can check this benchmark in gnuplot by opening it and running:
+# plot "statistics" using 2:(-$14), "statistics" using 2:(7000.*exp(-$2/14825))
+# This compares relaxation of the topography to an analytical solution
+
+
+set Dimension = 2
+set CFL number                             = 0.01
+set End time                               = 1e5
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+set Additional shared libraries = ./libcrameri_benchmark_1.so
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = bottom:0, top:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = rebound box
+
+  subsection Rebound Box
+    set Order = 1
+    set Amplitude = 7.e3
+  end
+
+  subsection Box
+    set X extent = 28.e5
+    set Y extent = 7.e5
+    set X repetitions = 300
+    set Y repetitions = 75
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  0.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+    set Density differential for compositional field 1 = 0.0
+    set Composition viscosity prefactor = 100.
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.00
+  set Strategy                           = composition
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y>600.e3, 1, 0);
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,topography
+
+  subsection Visualization
+    set List of output variables = viscosity
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+    set Time between graphical output = 1.e4
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/benchmarks/crameri_et_al/case_1/crameri_benchmark_1_gmg.prm.bak b/benchmarks/crameri_et_al/case_1/crameri_benchmark_1_gmg.prm.bak
new file mode 100644
index 00000000000..4ef00bc5874
--- /dev/null
+++ b/benchmarks/crameri_et_al/case_1/crameri_benchmark_1_gmg.prm.bak
@@ -0,0 +1,27 @@
+# Same as crameri_benchmark_1.prm, but using GMG.
+
+include $ASPECT_SOURCE_DIR/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm
+
+set Additional shared libraries = $ASPECT_SOURCE_DIR/benchmarks/crameri_et_al/case_1/libcrameri_benchmark_1.so
+set Dimension = 2
+set Output directory = output-crameri-gmg
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Material model
+  set Material averaging =  harmonic average
+end
+
+subsection Postprocess
+  subsection Visualization
+    set Output mesh velocity = true
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
diff --git a/benchmarks/crameri_et_al/case_2/crameri_benchmark_2.prm.bak b/benchmarks/crameri_et_al/case_2/crameri_benchmark_2.prm.bak
new file mode 100644
index 00000000000..1111ebef04b
--- /dev/null
+++ b/benchmarks/crameri_et_al/case_2/crameri_benchmark_2.prm.bak
@@ -0,0 +1,134 @@
+set Dimension = 2
+set CFL number                             = 0.1
+set End time                               = 2e7
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = no
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 0.0
+    set Bottom temperature = 0.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 28.e5
+    set Y extent = 7.e5
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  0.0
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature = 0.0
+    set Densities = 3300, 3200, 3300
+    set Specific heats = 1250
+    set Thermal conductivities = 4.7
+    set Thermal expansivities = 4e-5
+    set Viscosities = 1.e21, 1.e20, 1.e23
+    set Viscosity averaging scheme = harmonic
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 4
+  set Initial global refinement          = 6
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.0
+  set Strategy                           = density,composition,boundary
+  set Refinement criteria scaling factors =
+  set Refinement criteria merge operation = plus
+  set Time steps between mesh refinement = 5
+
+  subsection Boundary
+    set Boundary refinement indicators = top
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    # Theta from Kaus et al 2010
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( sqrt( (x-14.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( y > 6.e5, 1, 0)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,topography
+
+  subsection Visualization
+    set List of output variables = viscosity,density
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/benchmarks/crameri_et_al/doc/crameri_benchmark_1.prm.bak b/benchmarks/crameri_et_al/doc/crameri_benchmark_1.prm.bak
new file mode 100644
index 00000000000..ad0fa09035b
--- /dev/null
+++ b/benchmarks/crameri_et_al/doc/crameri_benchmark_1.prm.bak
@@ -0,0 +1,18 @@
+set CFL number                             = 0.01
+set Additional shared libraries = ./libcrameri_benchmark_1.so
+
+subsection Geometry model
+  set Model name = rebound box
+
+  subsection Rebound Box
+    set Order = 1
+    set Amplitude = 7.e3
+  end
+
+  subsection Box
+    set X extent = 28.e5
+    set Y extent = 7.e5
+    set X repetitions = 300
+    set Y repetitions = 75
+  end
+end
diff --git a/benchmarks/crameri_et_al/doc/crameri_benchmark_2.prm.bak b/benchmarks/crameri_et_al/doc/crameri_benchmark_2.prm.bak
new file mode 100644
index 00000000000..728009ee14c
--- /dev/null
+++ b/benchmarks/crameri_et_al/doc/crameri_benchmark_2.prm.bak
@@ -0,0 +1,22 @@
+set CFL number                   = 0.1
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities = 3300, 3200, 3300
+    set Viscosities = 1.e21, 1.e20, 1.e23
+    set Viscosity averaging scheme = harmonic
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 4
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.0
+  set Strategy                           = density,composition
+  set Refinement criteria merge operation = plus
+  set Time steps between mesh refinement = 5
+end
diff --git a/benchmarks/davies_et_al/case-1.1.prm.bak b/benchmarks/davies_et_al/case-1.1.prm.bak
new file mode 100644
index 00000000000..7426df13493
--- /dev/null
+++ b/benchmarks/davies_et_al/case-1.1.prm.bak
@@ -0,0 +1,109 @@
+############### Global parameters
+
+set CFL number                             = 10
+set End time                               = 2
+set Output directory                       = output
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1.22
+    set Opening angle = 360
+    set Outer radius  = 2.22
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top, bottom
+end
+
+# Ra is determined by g*alpha
+# Ra = 10^4
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude =  1e10
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1.
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-6
+    set Viscosity                     = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+############### Parameters describing the temperature field
+# Angular mode is set to 4 in order to match the number of
+# convective cells reported by Davies et al.
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+
+  subsection Spherical hexagonal perturbation
+    set Angular mode          = 4
+    set Rotation offset       = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.11
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 1
+  set Coarsening fraction                = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics,temperature statistics,heat flux statistics, depth average, velocity boundary statistics, spherical velocity statistics
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0.025
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/benchmarks/davies_et_al/case-2.1.prm.bak b/benchmarks/davies_et_al/case-2.1.prm.bak
new file mode 100644
index 00000000000..7bd853a1769
--- /dev/null
+++ b/benchmarks/davies_et_al/case-2.1.prm.bak
@@ -0,0 +1,120 @@
+############### Global parameters
+
+set CFL number                             = 10
+set End time                               = 2
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Checkpointing
+  set Steps between checkpoint = 15
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+end
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1.22
+    set Opening angle = 360
+    set Outer radius  = 2.22
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net rotation
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude =  1e10
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1.
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-6
+    set Viscosity                     = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+############### Parameters describing the temperature field
+# Angular mode is set to 4 in order to match the number of
+# convective cells reported by Davies et al.
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+
+  subsection Spherical hexagonal perturbation
+    set Angular mode          = 4
+    set Rotation offset       = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.11
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 1
+  set Coarsening fraction                = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics,temperature statistics,heat flux statistics, depth average, velocity boundary statistics, spherical velocity statistics
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0.025
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/benchmarks/davies_et_al/case-2.2.prm.bak b/benchmarks/davies_et_al/case-2.2.prm.bak
new file mode 100644
index 00000000000..38edd8d3d18
--- /dev/null
+++ b/benchmarks/davies_et_al/case-2.2.prm.bak
@@ -0,0 +1,119 @@
+############### Global parameters
+# Case 2.2 begins with the final steady state solution of Case 2.1
+# Resume computation must be set to true, and Output directory must
+# point to the folder that contains the results of Case 2.1.
+
+set CFL number                             = 10
+set End time                               = 3
+set Output directory                       = output
+set Resume computation                     = true
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Checkpointing
+  set Steps between checkpoint = 15
+end
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1.22
+    set Opening angle = 360
+    set Outer radius  = 2.22
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net rotation
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude =  1e11
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1.
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-6
+    set Viscosity                     = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+############### Parameters describing the temperature field
+# Angular mode is set to 4 in order to match the number of
+# convective cells reported by Davies et al.
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+
+  subsection Spherical hexagonal perturbation
+    set Angular mode          = 4
+    set Rotation offset       = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.11
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 1
+  set Coarsening fraction                = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics,temperature statistics,heat flux statistics, depth average, velocity boundary statistics, spherical velocity statistics
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0.025
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/benchmarks/davies_et_al/case-2.3-plugin/VoT.cc.bak b/benchmarks/davies_et_al/case-2.3-plugin/VoT.cc.bak
new file mode 100644
index 00000000000..e3f82ec394e
--- /dev/null
+++ b/benchmarks/davies_et_al/case-2.3-plugin/VoT.cc.bak
@@ -0,0 +1,202 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/parameter_handler.h>
+
+#include <cmath>
+
+
+using namespace dealii;
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    /**
+     * A material model similar to the "Simpler" model, but with a temperature
+     * dependent viscosity (a "viscosity as a function of temperature", or VoT).
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class VoT : public Interface<dim>
+    {
+      public:
+
+        bool is_compressible () const override;
+
+        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                      typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        double reference_rho;
+        double reference_T;
+        double eta;
+        double thermal_alpha;
+        double reference_specific_heat;
+        double k_value;
+    };
+
+
+    template <int dim>
+    bool
+    VoT<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+
+    template <int dim>
+    void
+    VoT<dim>::
+    evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+             typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          out.viscosities[i] = eta*std::pow(1000,(-in.temperature[i]));
+
+          out.densities[i] = reference_rho * (1.0 - thermal_alpha * (in.temperature[i] - reference_T));
+          out.thermal_expansion_coefficients[i] = thermal_alpha;
+          out.specific_heat[i] = reference_specific_heat;
+          out.thermal_conductivities[i] = k_value;
+          out.compressibilities[i] = 0.0;
+          out.entropy_derivative_pressure[i] = 0.0;
+          out.entropy_derivative_temperature[i] = 0.0;
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+
+    template <int dim>
+    void
+    VoT<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("VoT model");
+        {
+          prm.declare_entry ("Reference density", "3300.",
+                             Patterns::Double (0.),
+                             "Reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. The reference temperature is used "
+                             "in the density formula. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Viscosity", "5e24",
+                             Patterns::Double (0.),
+                             "The value of the viscosity $\\eta$. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250.",
+                             Patterns::Double (0.),
+                             "The value of the specific heat $cp$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\beta$. "
+                             "Units: \\si{\\per\\kelvin}.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    VoT<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("VoT model");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          reference_T                = prm.get_double ("Reference temperature");
+          eta                        = prm.get_double ("Viscosity");
+          k_value                    = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature;
+      this->model_dependence.density = NonlinearDependence::temperature;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(VoT,
+                                   "VoT",
+                                   "A material model that has constant values "
+                                   "except for density, which depends linearly on temperature: "
+                                   "\\begin{align}"
+                                   "  \\rho(p,T) &= \\left(1-\\alpha (T-T_0)\\right)\\rho_0."
+                                   "\\end{align}"
+                                   "\n\n"
+                                   "\\note{This material model fills the role the ``simple'' material "
+                                   "model was originally intended to fill, before the latter acquired "
+                                   "all sorts of complicated temperature and compositional dependencies.}")
+  }
+}
diff --git a/benchmarks/davies_et_al/case-2.3.prm.bak b/benchmarks/davies_et_al/case-2.3.prm.bak
new file mode 100644
index 00000000000..3af059bae65
--- /dev/null
+++ b/benchmarks/davies_et_al/case-2.3.prm.bak
@@ -0,0 +1,121 @@
+set Additional shared libraries            = ./case-2.3-plugin/libVoT.so
+
+############### Global parameters
+# Case 2.3 begins with the final steady state solution of Case 2.1
+# Resume computation must be set to true, and Output directory must
+# point to the folder that contains the results of Case 2.1.
+
+set CFL number                             = 10
+set End time                               = 3
+set Output directory                       = output
+set Resume computation                     = true
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Checkpointing
+  set Steps between checkpoint = 15
+end
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1.22
+    set Opening angle = 360
+    set Outer radius  = 2.22
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net rotation
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude =  1e8
+  end
+end
+
+subsection Material model
+  set Model name = VoT
+
+  subsection VoT model
+    set Reference density             = 1
+    set Reference specific heat       = 1.
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+############### Parameters describing the temperature field
+# Angular mode is set to 4 in order to match the number of
+# convective cells reported by Davies et al.
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+
+  subsection Spherical hexagonal perturbation
+    set Angular mode          = 4
+    set Rotation offset       = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.11
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 1
+  set Coarsening fraction                = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics,temperature statistics,heat flux statistics, depth average, velocity boundary statistics, spherical velocity statistics
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0.25
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/benchmarks/davies_et_al/doc/case-1.1.prm.bak b/benchmarks/davies_et_al/doc/case-1.1.prm.bak
new file mode 100644
index 00000000000..c714e462cce
--- /dev/null
+++ b/benchmarks/davies_et_al/doc/case-1.1.prm.bak
@@ -0,0 +1,51 @@
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1.22
+    set Opening angle = 360
+    set Outer radius  = 2.22
+  end
+end
+
+# [...]
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1.
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-6
+    set Viscosity                     = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Angular mode is set to 4 in order to match the number of
+# convective cells reported by Davies et al.
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+
+  subsection Spherical hexagonal perturbation
+    set Angular mode          = 4
+    set Rotation offset       = 0
+  end
+end
+
+############### Prescribe the Rayleigh number as g*alpha
+# Here, Ra = 10^4 and alpha was chosen as 10^-6 above.
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude =  1e10
+  end
+end
+
+# [...]
diff --git a/benchmarks/davies_et_al/doc/case-2.1.prm.bak b/benchmarks/davies_et_al/doc/case-2.1.prm.bak
new file mode 100644
index 00000000000..9e6273a2e01
--- /dev/null
+++ b/benchmarks/davies_et_al/doc/case-2.1.prm.bak
@@ -0,0 +1,11 @@
+subsection Nullspace removal
+  set Remove nullspace                        = net rotation
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+end
diff --git a/benchmarks/davies_et_al/doc/case-2.2.prm.bak b/benchmarks/davies_et_al/doc/case-2.2.prm.bak
new file mode 100644
index 00000000000..98a936fd85e
--- /dev/null
+++ b/benchmarks/davies_et_al/doc/case-2.2.prm.bak
@@ -0,0 +1,9 @@
+############### Global parameters
+# Case 2.2 begins with the final steady state solution of Case 2.1
+# "Resume computation" must be set to true, and "Output directory" must
+# point to the folder that contains the results of Case 2.1.
+
+set CFL number                             = 10
+set End time                               = 3
+set Output directory                       = output
+set Resume computation                     = true
diff --git a/benchmarks/davies_et_al/doc/case-2.3.prm.bak b/benchmarks/davies_et_al/doc/case-2.3.prm.bak
new file mode 100644
index 00000000000..e50b233ad69
--- /dev/null
+++ b/benchmarks/davies_et_al/doc/case-2.3.prm.bak
@@ -0,0 +1,14 @@
+set Additional shared libraries            = ./case-2.3-plugin/libVoT.so
+
+subsection Material model
+  set Model name = VoT
+
+  subsection VoT model
+    set Reference density             = 1
+    set Reference specific heat       = 1.
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-5
+    set Viscosity                     = 1
+  end
+end
diff --git a/benchmarks/diffusion_of_hill/1_sine_zero_flux.prm.bak b/benchmarks/diffusion_of_hill/1_sine_zero_flux.prm.bak
new file mode 100644
index 00000000000..e674c494033
--- /dev/null
+++ b/benchmarks/diffusion_of_hill/1_sine_zero_flux.prm.bak
@@ -0,0 +1,125 @@
+set Additional shared libraries            = libanalytical_topography.so
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.1
+set Maximum time step                      = 0.0005
+set Output directory                       = output-1_sine_zero_flux/
+set Nonlinear solver scheme = no Advection, no Stokes
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# 1x1 box with an initial hill topography
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function constants = A=0.075, L=1.
+      set Function expression = \
+                                A * sin(x*pi)
+    end
+  end
+end
+
+# Temperature effects are ignored
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = initial temperature
+end
+
+# Free slip on all boundaries
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The mesh will be deformed according to the displacement
+# of the surface nodes due to diffusion of the topography.
+# The mesh is allowed to move vertical along the left and
+# right boundary.
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: diffusion
+  set Additional tangential mesh velocity boundary indicators = left, right
+
+  subsection Diffusion
+    # The diffusivity
+    set Hillslope transport coefficient = 0.25
+  end
+end
+
+# Vertical gravity
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+# One material with unity properties
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 6
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# We output the computed topography and the analytical topography
+# value to file.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, analytical topography
+
+  subsection Topography
+    set Output to file = true
+    set Analytical solution of example = 1
+    set Diffusivity = 0.25
+    set Initial sinusoidal topography amplitude = 0.075
+  end
+
+  subsection Visualization
+    set Time between graphical output = 0.025
+    set Output mesh velocity = true
+    set Interpolate output = false
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                         = 1e-7
+  end
+end
diff --git a/benchmarks/diffusion_of_hill/2_sine_constant_h.prm.bak b/benchmarks/diffusion_of_hill/2_sine_constant_h.prm.bak
new file mode 100644
index 00000000000..537cefb97df
--- /dev/null
+++ b/benchmarks/diffusion_of_hill/2_sine_constant_h.prm.bak
@@ -0,0 +1,124 @@
+set Additional shared libraries            = libanalytical_topography.so
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+
+# You will want to run the model for longer to see
+# significant changes in model height
+set End time                               = 3.15576e9 # 100 yr
+set Maximum time step                      = 3.15576e7 # 1 yr
+set Output directory                       = output-2_sine_constant_h
+set Nonlinear solver scheme = no Advection, no Stokes
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# 1x1 box with or without an initial hill topography
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10000
+    set Y extent = 10000
+  end
+
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function constants = A=100, L=10000.
+      set Function expression = \
+                                A * sin(x*pi/L)
+    end
+  end
+end
+
+# Temperature effects are ignored
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = initial temperature
+end
+
+# Free slip on the top and bottom boundaries,
+# no slip on the left and right boundaries.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+  set Zero velocity boundary indicators = left, right
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top : diffusion
+
+  subsection Diffusion
+    # The diffusivity
+    set Hillslope transport coefficient = 0.0001
+  end
+end
+
+# Vertical gravity
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# One material
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 2.5
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e20
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 6
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# We output the computed topography and the analytical topography
+# value to file.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, analytical topography
+
+  subsection Topography
+    set Output to file = true
+    set Analytical solution of example = 2
+    set Diffusivity = 0.0001
+    set Initial sinusoidal topography amplitude = 100
+  end
+
+  subsection Visualization
+    set Time between graphical output = 3.15576e8
+    set Output mesh velocity = true
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                         = 1e-7
+  end
+end
diff --git a/benchmarks/diffusion_of_hill/analytical_topography.cc.bak b/benchmarks/diffusion_of_hill/analytical_topography.cc.bak
new file mode 100644
index 00000000000..aa4b00cdde1
--- /dev/null
+++ b/benchmarks/diffusion_of_hill/analytical_topography.cc.bak
@@ -0,0 +1,369 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "analytical_topography.h"
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <cmath>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    AnalyticalTopography<dim>::execute (TableHandler &statistics)
+    {
+      // Only allow use of the plugin with the box geometry model
+      AssertThrow(Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
+                  Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
+                  ExcMessage("Topography postprocessor is only implemented for the box geometry model. ") );
+
+      const types::boundary_id relevant_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id ("top");
+
+      // Get a quadrature rule that exists only on the corners
+      const QTrapezoid<dim-1> face_corners;
+
+      FEFaceValues<dim> face_vals (this->get_mapping(), this->get_fe(), face_corners, update_quadrature_points);
+
+      // have a stream into which we write the data. the text stream is then
+      // later sent to processor 0
+      std::ostringstream output_stats;
+      std::ostringstream output_file;
+
+      // on processor 0, write the file header
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          output_file << "# "
+                      << ((dim==2)? "x y" : "x y z")
+                      << " topography" << ((analytical_solution_example != 0)? " analytical topography" : "") << std::endl;
+        }
+
+      // Choose stupidly large values for initialization
+      double local_max_height = -std::numeric_limits<double>::max();
+      double local_min_height = std::numeric_limits<double>::max();
+
+      // Set up some variables for the analytical solution of the
+      // topography
+      const unsigned int n_max = 5000;
+      const double time = this->get_time();
+
+      // loop over all of the surface cells and save the elevation to stored_value
+      for (const auto &cell : this->get_triangulation().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          for (const unsigned int face_no : cell->face_indices())
+            if (cell->face(face_no)->at_boundary())
+              {
+                if ( cell->face(face_no)->boundary_id() != relevant_boundary)
+                  continue;
+
+                face_vals.reinit(cell, face_no);
+
+                for (unsigned int corner = 0; corner < face_corners.size(); ++corner)
+                  {
+                    const Point<dim> vertex = face_vals.quadrature_point(corner);
+                    const double elevation = this->get_geometry_model().height_above_reference_surface(vertex);
+
+                    if (write_to_file)
+                      {
+                        switch (analytical_solution_example)
+                          {
+                            // If there is no analytical solution corresponding to the
+                            // model setup, just output the topography
+                            case 0:
+                            {
+                              output_file << vertex << ' '<< elevation << std::endl;
+                              break;
+                            }
+                            // If the setup corresponds to anaytical solution 1,
+                            // output the topography and the first solution
+                            case 1:
+                            {
+                              double topo = 0;
+
+                              // initial topography
+                              if (time <= 0.)
+                                topo = amplitude * std::sin(numbers::PI*vertex[0]/domain_width);
+                              else
+                                {
+                                  // compute analytical solution
+                                  double sum = 0.;
+                                  for (unsigned int n=1; n<=n_max; ++n)
+                                    {
+                                      sum += std::cos(2.*n*numbers::PI*vertex[0]/domain_width)
+                                             * std::exp(-kappa*4.*n*n*numbers::PI*numbers::PI*time/(domain_width*domain_width))
+                                             / ((4.*n*n)-1.)
+                                             * (-4.*amplitude/numbers::PI);
+                                    }
+                                  // a0=4A/pi --> a0/2=2A/pi
+                                  topo = 2.*amplitude/numbers::PI + sum;
+                                }
+                              // write out predicted and analytical topography
+                              output_file << vertex << ' ' << elevation << ' ' << topo << std::endl;
+                              break;
+                            }
+                            // If the setup corresponds to anaytical solution 2,
+                            // output the topography and the second solution
+                            case 2:
+                            {
+                              const double topo = amplitude * std::sin(vertex[0]*numbers::PI/domain_width)
+                                                  * std::exp(-kappa*numbers::PI*numbers::PI*time/(domain_width*domain_width));
+                              // write out predicted and analytical topography
+                              output_file << vertex << ' ' << elevation << ' ' << topo << std::endl;
+                              break;
+                            }
+                            default:
+                              Assert(false, ExcInternalError());
+                          }
+
+                        if (elevation > local_max_height)
+                          local_max_height = elevation;
+                        if (elevation < local_min_height)
+                          local_min_height = elevation;
+                      }
+                  }
+              }
+
+      // Calculate min/max topography across all processes
+      const double max_topography = Utilities::MPI::max(local_max_height, this->get_mpi_communicator());
+      const double min_topography = Utilities::MPI::min(local_min_height, this->get_mpi_communicator());
+
+      // Calculate min/max analytical topography
+      double max_analytical_topography = 0., min_analytical_topography = 0.;
+      switch (analytical_solution_example)
+        {
+          case 0:
+          {
+            // In this case, there is no analytical solution,
+            // so set the min/max values to something clearly
+            // nonsensical.
+            min_analytical_topography = std::numeric_limits<double>::quiet_NaN();
+            max_analytical_topography = std::numeric_limits<double>::quiet_NaN();
+            break;
+          }
+          case 1:
+          {
+            if (time<=0)
+              max_analytical_topography = amplitude * std::sin(0.5*numbers::PI);
+            else
+              {
+                double sum_min = 0., sum_max = 0.;
+                for (unsigned int n=1; n<=n_max; ++n)
+                  {
+                    sum_min += std::exp(-kappa*4.*n*n*numbers::PI*numbers::PI*time/(domain_width*domain_width))
+                               / ((4.*n*n)-1.) * -4.*amplitude/numbers::PI;
+                    sum_max += std::cos(n*numbers::PI)
+                               * std::exp(-kappa*4.*n*n*numbers::PI*numbers::PI*time/(domain_width*domain_width))
+                               / ((4.*n*n)-1.) * -4.*amplitude/numbers::PI;
+                  }
+                // a0=4A/pi --> a0/2=2A/pi
+                min_analytical_topography = 2.*amplitude/numbers::PI + sum_min;
+                max_analytical_topography = 2.*amplitude/numbers::PI + sum_max;
+              }
+            break;
+          }
+          case 2:
+          {
+            max_analytical_topography = amplitude * std::sin(0.5*numbers::PI)
+                                        * std::exp(-kappa*numbers::PI*numbers::PI*time/(domain_width*domain_width));
+            min_analytical_topography = 0.;
+            break;
+          }
+          default:
+            Assert(false, ExcInternalError());
+        }
+
+      // Write results to statistics file
+      statistics.add_value ("Minimum topography (m)",
+                            min_topography);
+      statistics.add_value ("Maximum topography (m)",
+                            max_topography);
+      statistics.add_value ("Minimum analytical topography (m)",
+                            min_analytical_topography);
+      statistics.add_value ("Maximum analytical topography (m)",
+                            max_analytical_topography);
+      const char *columns[] = { "Minimum topography (m)",
+                                "Maximum topography (m)",
+                                "Minimum analytical topography (m)",
+                                "Maximum analytical topography (m)"
+                              };
+      for (unsigned int i=0; i<sizeof(columns)/sizeof(columns[0]); ++i)
+        {
+          statistics.set_precision (columns[i], 8);
+          statistics.set_scientific (columns[i], true);
+        }
+
+      output_stats.precision(4);
+      output_stats << min_topography << " m, "
+                   << max_topography << " m, "
+                   << min_analytical_topography << " m, "
+                   << max_analytical_topography << " m";
+
+      // Write the solution to file
+
+      // if this is the first time we get here, set the last output time
+      // to the current time - output_interval. this makes sure we
+      // always produce data during the first time step
+      if (std::isnan(last_output_time))
+        {
+          last_output_time = this->get_time() - output_interval;
+        }
+
+      // Just return stats if text output is not required at all or not needed at this time
+      if (!write_to_file || ((this->get_time() < last_output_time + output_interval)
+                             && (this->get_timestep_number() != 0)))
+        return std::pair<std::string, std::string> ("Predicted and analytical topography min/max:",
+                                                    output_stats.str());
+
+      std::string filename = this->get_output_directory() +
+                             "topography." +
+                             Utilities::int_to_string(this->get_timestep_number(), 5);
+      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
+        filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
+
+      Utilities::collect_and_write_file_content(filename, output_file.str(), this->get_mpi_communicator());
+
+      // if output_interval is positive, then update the last supposed output
+      // time
+      if (output_interval > 0)
+        {
+          // We need to find the last time output was supposed to be written.
+          // this is the last_output_time plus the largest positive multiple
+          // of output_intervals that passed since then. We need to handle the
+          // edge case where last_output_time+output_interval==current_time,
+          // we did an output and std::floor sadly rounds to zero. This is done
+          // by forcing std::floor to round 1.0-eps to 1.0.
+          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+          last_output_time = last_output_time + std::floor((this->get_time()-last_output_time)/output_interval*magic) * output_interval/magic;
+        }
+
+      return std::pair<std::string, std::string> ("Predicted and analytical topography min/max:",
+                                                  output_stats.str());
+    }
+
+
+
+    template <int dim>
+    void
+    AnalyticalTopography<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Topography");
+        {
+          prm.declare_entry ("Output to file", "false",
+                             Patterns::Bool(),
+                             "Whether or not to write topography to a text file named named "
+                             "'topography.NNNNN' in the output directory.");
+          prm.declare_entry ("Time between text output", "0.",
+                             Patterns::Double (0),
+                             "The time interval between each generation of "
+                             "text output files. A value of zero indicates "
+                             "that output should be generated in each time step. "
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+          prm.declare_entry ("Analytical solution of example", "1",
+                             Patterns::Integer (0),
+                             "The number of the diffusion example for "
+                             "which we output the analytical solution. "
+                             "For a value of 0, we do not write the "
+                             "analytical solution.");
+          prm.declare_entry ("Diffusivity", "0.5",
+                             Patterns::Double (0),
+                             "The diffusivity in the diffusion equation. "
+                             "Units: \\si{m^2/s}.");
+          prm.declare_entry ("Initial sinusoidal topography amplitude", "0.5",
+                             Patterns::Double (0),
+                             "The maximum amplitude of the initial sinusoidal topography. "
+                             "Units: \\si{m}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AnalyticalTopography<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Topography");
+        {
+          write_to_file        = prm.get_bool ("Output to file");
+          output_interval = prm.get_double ("Time between text output");
+          if (this->convert_output_to_years())
+            {
+              output_interval *= year_in_seconds;
+            }
+          analytical_solution_example = prm.get_integer ("Analytical solution of example");
+          kappa = prm.get_double ("Diffusivity");
+          amplitude = prm.get_double ("Initial sinusoidal topography amplitude");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Box");
+        {
+          domain_width = prm.get_double ("X extent");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(AnalyticalTopography,
+                                  "analytical topography",
+                                  "A postprocessor intended for use with a deforming top surface. After every step "
+                                  "it loops over all the vertices on the top surface and determines the "
+                                  "maximum and minimum topography relative to a reference datum (initial "
+                                  "box height). "
+                                  "If 'Topography.Output to file' is set to true, also outputs topography "
+                                  "into text files named `topography.NNNNN' in the output directory, "
+                                  "where NNNNN is the number of the time step."
+                                  "If 'Analytical solution of example' is set to 1 or 2, the analytical solution of "
+                                  "the topography of a decaying hill is also written to file.\n"
+                                  "The file format then consists of lines with Euclidean coordinates "
+                                  "followed by the corresponding topography value."
+                                  "Topography is printed/written in meters.")
+  }
+}
diff --git a/benchmarks/diffusion_of_hill/analytical_topography.h.bak b/benchmarks/diffusion_of_hill/analytical_topography.h.bak
new file mode 100644
index 00000000000..fc5ab18da29
--- /dev/null
+++ b/benchmarks/diffusion_of_hill/analytical_topography.h.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_analytical_topography_h
+#define _aspect_postprocess_analytical_topography_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that outputs the surface topography to file.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class AnalyticalTopography : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Output predicted and analytical topography [m] to file.
+         */
+        std::pair<std::string,std::string> execute (TableHandler &statistics) override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        /**
+         * Whether or not to produce text files with topography values
+         */
+        bool write_to_file;
+
+        /**
+         * Interval between the generation of text output. This parameter
+         * is read from the input file and consequently is not part of the
+         * state that needs to be saved and restored.
+         */
+        double output_interval;
+
+        /**
+         * A time (in seconds) at which the last text output was supposed
+         * to be produced. Used to check for the next necessary output time.
+         */
+        double last_output_time;
+
+        /**
+         * The amplitude of the sinusoidal initial topography.
+         */
+        double amplitude;
+
+        /**
+         * The diffusivity used in computing the diffusion of the surface
+         * topography.
+         */
+        double kappa;
+
+        /**
+         * The width (X extent) of the 2D rectangular domain.
+         */
+        double domain_width;
+
+        /**
+         * A switch to vary between different analytical solutions.
+         */
+        unsigned int analytical_solution_example;
+
+    };
+  }
+}
+
+
+#endif
diff --git a/benchmarks/doneahuerta/doneahuerta.cc.bak b/benchmarks/doneahuerta/doneahuerta.cc.bak
new file mode 100644
index 00000000000..156c8926bac
--- /dev/null
+++ b/benchmarks/doneahuerta/doneahuerta.cc.bak
@@ -0,0 +1,362 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  namespace DoneaHuertaBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+
+      Tensor<1,2>
+      DoneaHuerta_velocity (const Point<2> &pos)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const double v_x =  x*x*(1.-x)*(1.-x)*(2.*y-6.*y*y+4.*y*y*y) ;
+        const double v_y = -y*y*(1.-y)*(1.-y)*(2.*x-6.*x*x+4.*x*x*x) ;
+        return Point<2> (v_x,v_y);
+      }
+
+      double
+      DoneaHuerta_pressure (const Point<2> &pos)
+      {
+        const double x = pos[0];
+        return x*(1.-x)-1./6.;
+      }
+
+      template <int dim>
+      class FunctionDoneaHuerta : public Function<dim>
+      {
+        public:
+          FunctionDoneaHuerta ()
+            :
+            Function<dim>(dim+2)
+          {}
+
+          void vector_value (const Point<dim>   &pos,
+                             Vector<double>   &values) const override
+          {
+            Assert (dim == 2, ExcNotImplemented());
+            Assert (values.size() >= 4, ExcInternalError());
+
+            const Point<2> p (pos[0], pos[1]);
+
+            const Tensor<1,2> v = AnalyticSolutions::DoneaHuerta_velocity (p);
+            values[0] = v[0];
+            values[1] = v[1];
+            values[2] = AnalyticSolutions::DoneaHuerta_pressure (p);
+          }
+      };
+    }
+
+
+
+    template <int dim>
+    class DoneaHuertaBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        DoneaHuertaBoundary();
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id ,
+                           const Point<dim> &position) const override;
+    };
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class DoneaHuertaMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              out.viscosities[i] = 1.;
+              out.densities[i] = 1;
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+    };
+
+
+    template <int dim>
+    bool
+    DoneaHuertaMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    DoneaHuertaMaterial<dim>::declare_parameters (ParameterHandler &)
+    {
+    }
+
+
+    template <int dim>
+    void
+    DoneaHuertaMaterial<dim>::parse_parameters (ParameterHandler &)
+    {
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+
+    template <int dim>
+    DoneaHuertaBoundary<dim>::DoneaHuertaBoundary ()
+    {}
+
+
+    template <>
+    Tensor<1,2>
+    DoneaHuertaBoundary<2>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<2> &p) const
+    {
+      return AnalyticSolutions::DoneaHuerta_velocity (p);
+    }
+
+
+    template <>
+    Tensor<1,3>
+    DoneaHuertaBoundary<3>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<3> &) const
+    {
+      Assert (false, ExcNotImplemented());
+      return Tensor<1,3>();
+    }
+
+    /**
+     * Gravity model for the DoneaHuerta benchmark
+    */
+
+    template <int dim>
+    class DoneaHuertaGravity : public aspect::GravityModel::Interface<dim>
+    {
+      public:
+        Tensor<1,dim> gravity_vector (const Point<dim> &pos) const override;
+    };
+
+
+    template <int dim>
+    Tensor<1,dim>
+    DoneaHuertaGravity<dim>::
+    gravity_vector(const Point<dim> &pos) const
+    {
+      const double x=pos[0];
+      const double y=pos[1];
+      Tensor<1,dim> g;
+      g[0]= ( (12.-24.*y)*x*x*x*x + (-24.+48.*y)*x*x*x + (-48.*y+72.*y*y-48.*y*y*y+12.)*x*x
+              + (-2.+24.*y-72.*y*y+48.*y*y*y)*x + 1.-4.*y+12.*y*y-8.*y*y*y );
+
+      g[1]= ( (8.-48.*y+48.*y*y)*x*x*x + (-12.+72.*y-72*y*y)*x*x
+              +  (4.-24.*y+48.*y*y-48.*y*y*y+24.*y*y*y*y)*x - 12.*y*y + 24.*y*y*y -12.*y*y*y*y);
+      return g;
+    }
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the Donea and Huerta FEM book (see manual).
+      */
+    template <int dim>
+    class DoneaHuertaPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    DoneaHuertaPostprocessor<dim>::execute (TableHandler &)
+    {
+      std::unique_ptr<Function<dim>> ref_func =
+        std::make_unique<AnalyticSolutions::FunctionDoneaHuerta<dim>>();
+
+      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                          dim+2);
+      ComponentSelectFunction<dim> comp_p(dim, dim+2);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_u,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_p,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_p);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_ul2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_pl2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+      std::ostringstream os;
+
+      os << std::scientific <<  u_l1
+         << ", " << p_l1
+         << ", " << u_l2
+         << ", " << p_l2;
+
+      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace DoneaHuertaBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(DoneaHuertaMaterial,
+                                   "DoneaHuertaMaterial",
+                                   "A material model that corresponds to the `DoneaHuerta' benchmark. "
+                                   "See the manual for more information.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(DoneaHuertaBoundary,
+                                            "DoneaHuertaBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "`DoneaHuerta' benchmark. See the manual for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(DoneaHuertaPostprocessor,
+                                  "DoneaHuertaPostprocessor",
+                                  "A postprocessor that compares the solution of the `DoneaHuerta' benchmark "
+                                  "with the one computed by ASPECT "
+                                  "and reports the error. See the manual for more information.")
+
+    ASPECT_REGISTER_GRAVITY_MODEL(DoneaHuertaGravity,
+                                  "DoneaHuertaGravity",
+                                  "A gravity model in corresponding to the `DoneaHuerta' benchmark. "
+                                  "See the manual for more information.")
+  }
+}
diff --git a/benchmarks/doneahuerta/doneahuerta.prm.bak b/benchmarks/doneahuerta/doneahuerta.prm.bak
new file mode 100644
index 00000000000..84cf6380f7e
--- /dev/null
+++ b/benchmarks/doneahuerta/doneahuerta.prm.bak
@@ -0,0 +1,88 @@
+############### Global parameters
+# This is the manufactured solution of Donea & Huerta,
+# Finite element methods for flow problems,
+# Wiley, 2003. page 306
+
+set Additional shared libraries            = ./libdoneahuerta.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0  : DoneaHuertaBoundary, \
+                                                1  : DoneaHuertaBoundary, \
+                                                2  : DoneaHuertaBoundary, \
+                                                3  : DoneaHuertaBoundary
+end
+
+subsection Material model
+  set Model name = DoneaHuertaMaterial
+end
+
+subsection Gravity model
+  set Model name = DoneaHuertaGravity
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, DoneaHuertaPostprocessor
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, gravity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/benchmarks/entropy_adiabat/entropy_adiabat.prm.bak b/benchmarks/entropy_adiabat/entropy_adiabat.prm.bak
new file mode 100644
index 00000000000..274e78cc5d0
--- /dev/null
+++ b/benchmarks/entropy_adiabat/entropy_adiabat.prm.bak
@@ -0,0 +1,184 @@
+# Adiabatic downwelling along a pipe. Initially all material starts on one
+# adiabat (at constant entropy), with material inflow on another adiabat (a
+# different constant entropy). The adiabatic reference profile is computed for
+# this different inflow adiabat so that the difference between adiabatic
+# profile and actual profile in the model is expected to go to 0 with time. The
+# material data contains a discontinuous phase transition (in
+# pressure-temperature space), which would make convergence of this model hard.
+# Accurate results in particular for the latent heat effects would be nearly
+# impossible if not for the new feature in this benchmark, which is to solve
+# the advection-diffusion equation in terms of entropy instead of temperature.
+# In pressure-entropy space there is no jump in entropy across the phase
+# transition, and the equation can be accurately solved (in fact it is trivial
+# for this example as the steady-state solution is at constant entropy
+# everywhere in the model once the warmer inflowing material has replaced the
+# initial material in the model). The resulting temperature for any given
+# pressure-entropy is looked up in the used material data table.
+
+# As a benchmark this model can only test that ASPECT's results are consistent
+# with the results of the thermodynamic modeling package that produced the
+# entropy-pressure tables for material properties (in this case HeFESTo). This
+# test is done by replacing the 'compute entropy profile' adiabatic conditions
+# plugin with the 'ascii data' plugin, which will load a precomputed adiabat
+# from HeFESTo instead of computing an adiabat inside ASPECT. The disadvantage
+# of this approach is of course that it is only possible for those adiabats
+# that have been precomputed (in this case one for 1600 K), while the 'compute
+# entropy profile' plugin can compute adiabats at arbitrary entropy.
+
+set Additional shared libraries            = ./plugins/libentropy_plugins.so
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 2.5e8
+set Output directory                       = output-entropy-adiabat
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600.1243896484375
+
+subsection Formulation
+  set Mass conservation = projected density field
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 13000
+    set Y extent = 1300000
+    set Y repetitions = 200
+  end
+end
+
+subsection Initial temperature model
+  # The actual initial temperature is irrelevant, because it
+  # is recalculated from the entropy during the first timestep.
+  # The value below corresponds to the entropy of 2534 J/kg/K
+  # used as the top boundary condition.
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600.1243896484375
+  end
+end
+
+subsection Adiabatic conditions model
+  # The 'ascii data' option does not need the additional
+  # plugin, but is limited to the available adiabat data files.
+  # 'compute entropy profile' computes arbitrary adiabats
+  # internally, based on the data table.
+  # Use 'ascii data' to compare against HeFESTo adiabat.
+  set Model name = compute entropy profile
+
+  subsection Compute entropy profile
+    # Entropy equivalent to T=1600 K according to the used table
+    set Surface entropy = 2534
+  end
+
+  subsection Ascii data model
+    set Data directory  = $ASPECT_SOURCE_DIR/data/material-model/
+    set Data file name  = entropy-table/opxtable/1600K_adiabat.txt
+  end
+end
+
+# We prescribe temperatures according to the data table.
+# This output is computed in the material model.
+subsection Temperature field
+  set Temperature method = prescribed field with diffusion
+end
+
+# We solve the entropy equation for the compositional field with name
+# 'entropy'. Temperature and density are then computed based on entropy and
+# pressure.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = entropy, density_field
+  set Types of fields = entropy, density
+  set Compositional field methods = field, prescribed field
+end
+
+subsection Boundary temperature model
+  # No temperature boundary conditions,
+  # as the temperature equation is not solved
+  set Fixed temperature boundary indicators = top
+  set List of model names = initial temperature
+end
+
+# We prescribe the entropy of the inflowing material to
+# be different from the initial entropy in the model.
+subsection Boundary composition model
+  set Fixed composition boundary indicators = top
+  set List of model names = function
+
+  subsection Function
+    # Only the first component (entropy) matters, the other equations
+    # are not solved but computed from entropy.
+    set Function expression = 2534; 3300
+  end
+end
+
+# Prescribing downward flow through a vertical pipe with
+# tangential side boundaries.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Function expression = 0; -0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We start at a lower entropy than the one used for the
+# adiabatic profile.
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    # Entropy equivalent to T=1405 K according to table
+    set Function expression = 2360; 0.0
+  end
+end
+
+# We use a data table for orthopyroxene computed using the thermodynamic
+# modeling software HeFESTo.
+subsection Material model
+  set Model name = entropy model
+
+  subsection Entropy model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
+    set Material file name               = material_table.txt
+    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
+    set Thermal conductivity formulation = constant
+    set Thermal conductivity             = 0.1
+  end
+
+  subsection Depth dependent viscosity
+    set Data directory                   = $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/data/
+    set Data file name                   = constant_viscosity.txt
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e7
+    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
+    end
+  end
+end
diff --git a/benchmarks/entropy_adiabat/entropy_combined.prm.bak b/benchmarks/entropy_adiabat/entropy_combined.prm.bak
new file mode 100644
index 00000000000..c06bcf6ae60
--- /dev/null
+++ b/benchmarks/entropy_adiabat/entropy_combined.prm.bak
@@ -0,0 +1,42 @@
+# Downwelling along a pipe.
+# This is a modification of the entropy adiabat example with added diffusion.
+# According to Schubert, Turcotte and Olson (part 1, p. 194), the added
+# diffusion should only affect the temperature profile above the phase transition.
+# Schubert, Turcotte and Olson also give an analytical solution for the
+# temperature profile. However, since they do not include adiabatic heating, this
+# model does not yield the exact solution from Schubert, Turcotte and Olson.
+# Instead, the temperature is slightly cooler below the phase transition due to
+# the additional heat conduction along the adiabat.
+
+include ./entropy_adiabat.prm
+
+set Additional shared libraries            = ./plugins/libentropy_plugins.so
+set Dimension                              = 2
+set End time                               = 2.5e8
+set Output directory                       = output-entropy-combined
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600.1243896484375
+
+# We start at the same entropy as the one used for the
+# adiabatic profile.
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    # Entropy equivalent to T=1600 K according to table
+    set Function expression = 2534; 0.0
+  end
+end
+
+# We increase the thermal conductivity compared to the
+# entropy adiabat example. We choose a very large value
+# here because the thermal diffusion effects only become
+# visible for large conductivities (or slow flow).
+subsection Material model
+  set Model name = entropy model
+
+  subsection Entropy model
+    set Thermal conductivity formulation = constant
+    set Thermal conductivity             = 50
+  end
+end
diff --git a/benchmarks/entropy_adiabat/entropy_conduction.prm.bak b/benchmarks/entropy_adiabat/entropy_conduction.prm.bak
new file mode 100644
index 00000000000..3a1c77c6b4b
--- /dev/null
+++ b/benchmarks/entropy_adiabat/entropy_conduction.prm.bak
@@ -0,0 +1,147 @@
+# Conduction along an adiabat. Initially all material starts on one adiabat
+# (at constant entropy), with no material inflow. The adiabatic reference
+# profile is computed based on this initial entropy, using a look-up table
+# for orthopyroxene, which has one narrow phase transition in the center of
+# the model. The temperature is fixed at the top, and the bottom is set as
+# an insulating boundary. Consequently, the model should cool down over
+# time as heat flows out conductively through the top boundary, eventually
+# reaching a constant temperature.
+
+
+set Additional shared libraries            = ./plugins/libentropy_plugins.so
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 2.5e11
+set Maximum time step                      = 1e7
+set Output directory                       = output-entropy-conduction
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600.1243896484375
+
+subsection Formulation
+  set Mass conservation = projected density field
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 13000
+    set Y extent = 1300000
+    set Y repetitions = 200
+  end
+end
+
+subsection Initial temperature model
+  # We convert the initial temperature from the
+  # initial entropy.
+  # The value below corresponds to the entropy of 2534 J/kg/K
+  # used as the top boundary condition and the initial condition.
+  set Model name = prescribed temperature
+end
+
+subsection Adiabatic conditions model
+  # 'compute entropy profile' computes arbitrary adiabats
+  # internally, based on the data table.
+  set Model name = compute entropy profile
+
+  subsection Compute entropy profile
+    # Entropy equivalent to T=1600 K according to the used table
+    set Surface entropy = 2534
+  end
+end
+
+# We prescribe temperatures according to the data table.
+# This output is computed in the material model.
+subsection Temperature field
+  set Temperature method = prescribed field with diffusion
+end
+
+# We solve the entropy equation for the compositional field with name
+# 'entropy'. Temperature and density are then computed based on entropy and
+# pressure.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = entropy, density_field
+  set Types of fields = entropy, density
+  set Compositional field methods = field, prescribed field
+end
+
+subsection Boundary temperature model
+  # No temperature boundary conditions,
+  # as the temperature equation is not solved
+  set Fixed temperature boundary indicators = top
+  set List of model names = initial temperature
+end
+
+# We prescribe the entropy at the top.
+subsection Boundary composition model
+  set Fixed composition boundary indicators = top
+  set List of model names = function
+
+  subsection Function
+    # Only the first component (entropy) matters, the other equations
+    # are not solved but computed from entropy.
+    set Function expression = 2534; 3300
+  end
+end
+
+# Prescribing closed boundaries.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, left, right, bottom
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We start at the same entropy as the one used for the
+# adiabatic profile.
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    # Entropy equivalent to T=1600 K according to table
+    set Function expression = 2534; 0.0
+  end
+end
+
+# We use a data table for orthopyroxene computed using the thermodynamic
+# modeling software HeFESTo.
+# We use a very large viscosity to make sure the material does not move.
+subsection Material model
+  set Model name = entropy model
+
+  subsection Entropy model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
+    set Material file name               = material_table.txt
+    set Maximum viscosity                = 1e30
+    set Minimum viscosity                = 1e30
+    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
+    set Thermal conductivity formulation = constant
+    set Thermal conductivity             = 4.7
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e8
+    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
+    end
+  end
+end
diff --git a/benchmarks/entropy_adiabat/entropy_half_space.prm.bak b/benchmarks/entropy_adiabat/entropy_half_space.prm.bak
new file mode 100644
index 00000000000..ac06b3691c9
--- /dev/null
+++ b/benchmarks/entropy_adiabat/entropy_half_space.prm.bak
@@ -0,0 +1,155 @@
+# Conduction in a boundary layer, without adiabatic effects. Initially all
+# material starts at a constant temperature. Adiabatic effects are switched
+# off by setting the gravity to zero. The temperature is fixed at the top,
+# and the bottom is set as an insulating boundary. Consequently, the model
+# should cool down over time according to the half-space cooling model.
+# The temperature at the end of the model run can be compared to the
+# solution of the half-space cooling model given in the compositional
+# field "half_space".
+# Note that density and specific heat are temperature- and, consequently,
+# time-dependent, so the solution might slightly deviate from this
+# reference profile.
+
+set Additional shared libraries            = ./plugins/libentropy_plugins.so
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e9
+set Maximum time step                      = 1e6
+set Output directory                       = output-entropy-half-space
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 50
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600.1243896484375
+
+subsection Formulation
+  set Mass conservation = projected density field
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 13000
+    set Y extent = 1300000
+    set Y repetitions = 200
+  end
+end
+
+subsection Initial temperature model
+  # The actual initial temperature is irrelevant, because it
+  # is recalculated from the entropy during the first timestep.
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1500
+  end
+end
+
+subsection Adiabatic conditions model
+  # 'compute entropy profile' computes arbitrary adiabats
+  # internally, based on the data table.
+  set Model name = compute entropy profile
+
+  subsection Compute entropy profile
+    # Entropy equivalent to T=1600 K according to the used table
+    set Surface entropy = 2534
+  end
+end
+
+# We prescribe temperatures according to the data table.
+# This output is computed in the material model.
+subsection Temperature field
+  set Temperature method = prescribed field with diffusion
+end
+
+# We solve the entropy equation for the compositional field with name
+# 'entropy'. Temperature and density are then computed based on entropy and
+# pressure.
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = entropy, density_field, half_space
+  set Types of fields = entropy, density, generic
+  set Compositional field methods = field, prescribed field, static
+end
+
+subsection Boundary temperature model
+  # No temperature boundary conditions,
+  # as the temperature equation is not solved
+  set Fixed temperature boundary indicators = top
+  set List of model names = initial temperature
+end
+
+# We prescribe the entropy at the top.
+subsection Boundary composition model
+  set Fixed composition boundary indicators = top
+  set List of model names = function
+
+  subsection Function
+    # Only the first component (entropy) matters, the other equations
+    # are not solved but computed from entropy.
+    set Function expression = 2450; 3300; 1500
+  end
+end
+
+# Prescribing closed boundaries.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, left, right, bottom
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+# We start at the same entropy as the one used for the
+# adiabatic profile. The last compositional field gives
+# the analytical solution for the temperature at the
+# end of the model run based on the half-space cooling
+# model.
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    # Entropy equivalent to T=1600 K according to table
+    set Function expression = 2534; 0.0; 1600 - 100 * erfc((1300000 - y)/(2 * sqrt(4.7/(1342*3380)*3600*24*365.25*1e9)))
+  end
+end
+
+# We use a data table for orthopyroxene computed using the thermodynamic
+# modeling software HeFESTo.
+# We use a very large viscosity to make sure the material does not move.
+subsection Material model
+  set Model name = entropy model
+
+  subsection Entropy model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
+    set Material file name               = material_table.txt
+    set Maximum viscosity                = 1e30
+    set Minimum viscosity                = 1e30
+    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
+    set Thermal conductivity formulation = constant
+    set Thermal conductivity             = 4.7
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e8
+    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
+    end
+  end
+end
diff --git a/benchmarks/entropy_adiabat/plugins/entropy_advection.cc.bak b/benchmarks/entropy_adiabat/plugins/entropy_advection.cc.bak
new file mode 100644
index 00000000000..61c005ec1f5
--- /dev/null
+++ b/benchmarks/entropy_adiabat/plugins/entropy_advection.cc.bak
@@ -0,0 +1,312 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "entropy_advection.h"
+#include <aspect/material_model/entropy_model.h>
+
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+#include <aspect/plugins.h>
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    template <int dim>
+    void
+    EntropyAdvectionSystem<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                                          internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+      const std::vector<CompositionalFieldDescription> &composition_descriptions = this->introspection().get_composition_descriptions();
+      if (!advection_field.is_temperature()
+          && composition_descriptions[advection_field.compositional_variable].type != CompositionalFieldDescription::entropy)
+        return;
+
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
+
+      const bool   use_bdf2_scheme = (this->get_timestep_number() > 1);
+      const double time_step = this->get_timestep();
+      const double old_time_step = this->get_old_timestep();
+
+      const double bdf2_factor = (use_bdf2_scheme)? ((2*time_step + old_time_step) /
+                                                     (time_step + old_time_step)) : 1.0;
+
+      const unsigned int solution_component = advection_field.component_index(introspection);
+      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
+
+      scratch.finite_element_values[introspection.extractors.temperature].get_function_values (this->get_old_solution(),
+          scratch.old_temperature_values);
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          // precompute the values of shape functions and their gradients.
+          // We only need to look up values of shape functions if they
+          // belong to 'our' component. They are zero otherwise anyway.
+          // Note that we later only look at the values that we do set here.
+          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
+            {
+              if (fe.system_to_component_index(i).first == solution_component)
+                {
+                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
+                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
+                  ++i_advection;
+                }
+              ++i;
+            }
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          // solve the diffusion equation for the temperature
+          if (advection_field.is_temperature())
+            {
+              const double density_c_P = scratch.material_model_outputs.densities[q] *
+                                         scratch.material_model_outputs.specific_heat[q];
+
+              const double field_term_for_rhs = scratch.old_field_values[q] * density_c_P;
+
+              // do the actual assembly. note that we only need to loop over the advection
+              // shape functions because these are the only contributions we compute here
+              for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+                {
+                  data.local_rhs(i)
+                  += field_term_for_rhs * scratch.phi_field[i] * JxW;
+
+                  for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                    {
+                      data.local_matrix(i,j)
+                      += (
+                           (time_step * scratch.material_model_outputs.thermal_conductivities[q]
+                            * (scratch.grad_phi_field[i] * scratch.grad_phi_field[j]))
+                           + (scratch.phi_field[i] * scratch.phi_field[j]) * density_c_P
+                         )
+                         * JxW;
+                    }
+                }
+            }
+          else
+            // solve the entropy equation
+            {
+              const double rho_T              =
+                scratch.material_model_outputs.densities[q] *
+                scratch.material_model_inputs.temperature[q];
+
+              Assert (rho_T >= 0,
+                      ExcMessage ("The product of density and temperature needs to be a "
+                                  "non-negative quantity."));
+
+              const double gamma =
+                scratch.heating_model_outputs.heating_source_terms[q];
+
+              const double field_term_for_rhs
+                = (use_bdf2_scheme ?
+                   (scratch.old_field_values[q] *
+                    (1 + time_step/old_time_step)
+                    -
+                    scratch.old_old_field_values[q] *
+                    (time_step * time_step) /
+                    (old_time_step * (time_step + old_time_step)))
+                   :
+                   scratch.old_field_values[q])
+                  *
+                  (rho_T);
+
+              Tensor<1,dim> current_u = scratch.current_velocity_values[q];
+              // Subtract off the mesh velocity for ALE corrections if necessary
+              if (this->get_parameters().mesh_deformation_enabled)
+                current_u -= scratch.mesh_velocity_values[q];
+
+              // We compute the amount of diffusion based on the solution of the temperature equation.
+              const double diffusion_term = (scratch.material_model_inputs.temperature[q] - scratch.old_temperature_values[q])
+                                            * scratch.material_model_outputs.densities[q] * scratch.material_model_outputs.specific_heat[q];
+
+              // do the actual assembly. note that we only need to loop over the advection
+              // shape functions because these are the only contributions we compute here
+              for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+                {
+                  data.local_rhs(i)
+                  += (field_term_for_rhs * scratch.phi_field[i]
+                      + diffusion_term * scratch.phi_field[i]
+                      + time_step * scratch.phi_field[i] * gamma)
+                     *
+                     JxW;
+
+                  for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                    {
+                      data.local_matrix(i,j)
+                      += (
+                           (time_step * scratch.artificial_viscosity
+                            * scratch.grad_phi_field[i] * scratch.grad_phi_field[j])
+                           + ((time_step * (scratch.phi_field[i] * (current_u * scratch.grad_phi_field[j])))
+                              + (bdf2_factor * scratch.phi_field[i] * scratch.phi_field[j])) *
+                           (rho_T)
+                         )
+                         * JxW;
+                    }
+                }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    EntropyAdvectionSystem<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      std::vector<double> residuals(n_q_points,0.0);
+
+      const std::vector<CompositionalFieldDescription> &composition_descriptions = this->introspection().get_composition_descriptions();
+      if (!advection_field.is_temperature()
+          && composition_descriptions[advection_field.compositional_variable].type != CompositionalFieldDescription::entropy)
+        return residuals;
+
+      this->get_heating_model_manager().evaluate(scratch.material_model_inputs,
+                                                 scratch.material_model_outputs,
+                                                 scratch.heating_model_outputs);
+
+      for (unsigned int q=0; q < n_q_points; ++q)
+        {
+          const Tensor<1,dim> u = (scratch.old_velocity_values[q] +
+                                   scratch.old_old_velocity_values[q]) / 2;
+
+          const double dField_dt = (this->get_old_timestep() == 0.0) ? 0.0 :
+                                   (
+                                     ((scratch.old_field_values)[q] - (scratch.old_old_field_values)[q])
+                                     / this->get_old_timestep());
+          const double u_grad_field = u * (scratch.old_field_grads[q] +
+                                           scratch.old_old_field_grads[q]) / 2;
+
+          const double density      = scratch.material_model_outputs.densities[q];
+          const double gamma        = scratch.heating_model_outputs.heating_source_terms[q];
+
+          // Because we solve the diffusion equation for the temperature before the advection equation, we can use
+          // the current and old temperature here, together with the current time step.
+          const double diffusion_term = (this->get_timestep() == 0.0) ? 0.0
+                                        :
+                                        (scratch.material_model_inputs.temperature[q] - scratch.old_temperature_values[q]) / this->get_timestep()
+                                        * scratch.material_model_outputs.densities[q] * scratch.material_model_outputs.specific_heat[q];
+
+
+          residuals[q]
+            = std::abs((density * scratch.material_model_inputs.temperature[q]) * (dField_dt + u_grad_field) - gamma - diffusion_term);
+        }
+      return residuals;
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    EntropyAdvectionSystem<dim>::advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+
+      std::vector<double> prefactors(scratch.material_model_inputs.n_evaluation_points(), 0.0);
+
+      for (unsigned int i=0; i<prefactors.size(); ++i)
+        prefactors[i] = scratch.material_model_outputs.densities[i] * scratch.material_model_inputs.temperature[i];
+
+      return prefactors;
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    EntropyAdvectionSystem<dim>::diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+
+      std::vector<double> prefactors(scratch.material_model_inputs.n_evaluation_points(), 0.0);
+
+      for (unsigned int i=0; i<prefactors.size(); ++i)
+        prefactors[i] = scratch.material_model_outputs.thermal_conductivities[i] *
+                        scratch.material_model_inputs.temperature[i] /
+                        scratch.material_model_outputs.specific_heat[i];
+
+      return prefactors;
+    }
+  }
+
+// The function below replaces the normal temperature advection assembler with the entropy advection assembler of this file
+  template <int dim>
+  void set_assemblers_entropy_advection(const SimulatorAccess<dim> &simulator_access,
+                                        Assemblers::Manager<dim> &assemblers)
+  {
+    AssertThrow (Plugins::plugin_type_matches<MaterialModel::EntropyModel<dim>>
+                 (simulator_access.get_material_model()),
+                 ExcMessage ("The entropy advection assembler can only be used with the "
+                             "material model 'entropy model'!"));
+
+    AssertThrow (simulator_access.get_heating_model_manager().adiabatic_heating_enabled() == false,
+                 ExcMessage("The entropy advection assembler requires "
+                            "that adiabatic heating is disabled."));
+
+    // Replace all existing assemblers for the temperature and entropy fields by the one for the entropy equation.
+    const unsigned int temperature_index = 0;
+    assemblers.advection_system[temperature_index].clear();
+    assemblers.advection_system[temperature_index].emplace_back (std::make_unique<Assemblers::EntropyAdvectionSystem<dim>>());
+    assemblers.advection_system_assembler_properties[temperature_index].needed_update_flags = update_hessians;
+
+    if (simulator_access.introspection().composition_type_exists(CompositionalFieldDescription::entropy))
+      {
+        // Find the index of the entropy field and replace the assembler for it.
+        // The index of the entropy field is its index in the compositional fields plus one (for the temperature field).
+        const unsigned int entropy_index = simulator_access.introspection().get_indices_for_fields_of_type(CompositionalFieldDescription::entropy)[0]
+                                           + 1;
+        assemblers.advection_system[entropy_index].clear();
+        assemblers.advection_system[entropy_index].emplace_back (std::make_unique<Assemblers::EntropyAdvectionSystem<dim>>());
+        assemblers.advection_system_assembler_properties[entropy_index].needed_update_flags = update_hessians;
+      }
+  }
+} // namespace aspect
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  signals.set_assemblers.connect (&aspect::set_assemblers_entropy_advection<dim>);
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace Assemblers
+  {
+#define INSTANTIATE(dim) \
+  template class EntropyAdvectionSystem<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+  }
+}
diff --git a/benchmarks/entropy_adiabat/plugins/entropy_advection.h.bak b/benchmarks/entropy_adiabat/plugins/entropy_advection.h.bak
new file mode 100644
index 00000000000..1d0c41a1b67
--- /dev/null
+++ b/benchmarks/entropy_adiabat/plugins/entropy_advection.h.bak
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_simulator_assemblers_entropy_advection_h
+#define _aspect_simulator_assemblers_entropy_advection_h
+
+
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    /**
+     * This class assembles the terms for the matrix and right-hand-side of the entropy
+     * advection equation for the current cell.
+     */
+    template <int dim>
+    class EntropyAdvectionSystem : public Assemblers::Interface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
+
+        std::vector<double>
+        compute_residual(internal::Assembly::Scratch::ScratchBase<dim>  &scratch) const override;
+
+        std::vector<double>
+        advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
+
+        std::vector<double>
+        diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/benchmarks/finite_strain/finite_strain.cc.bak b/benchmarks/finite_strain/finite_strain.cc.bak
new file mode 100644
index 00000000000..7084bcac0ef
--- /dev/null
+++ b/benchmarks/finite_strain/finite_strain.cc.bak
@@ -0,0 +1,20 @@
+/*
+  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include "../../cookbooks/finite_strain/finite_strain.cc"
diff --git a/benchmarks/finite_strain/pure_shear.prm.bak b/benchmarks/finite_strain/pure_shear.prm.bak
new file mode 100644
index 00000000000..fcfe9eb7802
--- /dev/null
+++ b/benchmarks/finite_strain/pure_shear.prm.bak
@@ -0,0 +1,145 @@
+# This parameter file reproduces an analytical benchmark for the evolution
+# of finite strain in a model of pure shear as described (for a specific
+# application) in McKenzie & Jackson (1983): "The relationship between
+# strain rates, crustal thickening, paleomagnetism, finite strain and
+# fault movements within a deforming zone." They show that the analytical
+# solution for the deformation gradient tensor F in pure shear deformation is:
+#
+# F_xx = e^(u_x,x * t)
+# F_xy = 0
+# F_yx = 0
+# F_yy = e^(-u_x,x * t),
+#
+# where u is the velocity, t is time, and a comma represents a derivative
+# in that particular direction. u_x,x in this example is equivalent to
+# -u_y,y so that also: F_yy = e^(u_y,y * t) which is intuitive.
+# For this benchmark it is important to recognize that the deformation in
+# this model is actually only "pure" pure shear at the origin, since the
+# deformation field around is a mixture of pure shear and a rotational
+# component. Also the value of u_x,x at the origin is not prescribed
+# directly, but is a model output, because we only know velocity profiles
+# for the top and right boundaries. Using the computed velocity field we
+# can calculate u_x,x approximately at the origin to be 1.253, and therefore
+# expect:
+# F_xx (t=1.0) = 3.501
+# F_yy (t=1.0) = 0.2856
+# This parameter file tracks the finite strain in two ways, once by using
+# compositional fields as illustrated in the finite strain cookbook, and
+# once by using a particle particle that sits and remains at the origin.
+# The results should of course be the same.
+#
+# Numerical results for particle tracking show excellent agreement:
+# F_xx (t=1.0) = 3.50088
+# F_yy (t=1.0) = 0.285643
+#
+# Numerical results for compositional fields also show good results.
+# F_xx (t=1.0) = 3.49776
+# F_yy (t=1.0) = 0.286723
+# The compositional field results are slightly less accurate, probably due to
+# numerical diffusion, but were found to converge against the analytical
+# values with increasing resolution.
+
+set Additional shared libraries            = ./libfinite_strain.so
+set Dimension                              = 2
+set End time                               = 1.0
+set Use years in output instead of seconds = false
+set Output directory                       = output-pure_shear
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom
+  set Prescribed velocity boundary indicators = top:function, right:function
+
+  subsection Function
+    set Function expression = 1-y; x-1
+  end
+end
+
+subsection Material model
+  set Model name = finite strain
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0;0.0;0.0;1.0
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, visualization
+
+  subsection Visualization
+    set List of output variables = strain rate, shear stress
+    set Time between graphical output = 0.05
+  end
+
+  subsection Particles
+    set Time between data output = 0.05
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain
+  set Particle generator name = ascii file
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = ./
+      set Data file name = pure_shear_particle.dat
+    end
+  end
+end
diff --git a/benchmarks/finite_strain/simple_shear.prm.bak b/benchmarks/finite_strain/simple_shear.prm.bak
new file mode 100644
index 00000000000..866ca5d7822
--- /dev/null
+++ b/benchmarks/finite_strain/simple_shear.prm.bak
@@ -0,0 +1,133 @@
+# This parameter file reproduces an analytical benchmark for the evolution
+# of finite strain in a model of simple shear as described (for a specific
+# application) in McKenzie & Jackson (1983): "The relationship between
+# strain rates, crustal thickening, paleomagnetism, finite strain and
+# fault movements within a deforming zone." They show that the analytical
+# solution for the deformation gradient tensor F in simple shear deformation is:
+#
+# F_xx = 1.0
+# F_xy = u_x,y * t
+# F_yx = 0
+# F_yy = 1.0,
+#
+# where u is the velocity, t is time, and a comma represents a derivative
+# in that particular direction.
+# Because u_x,y = 2.0 / 1.0 is constant in the whole domain (and over time) we expect
+# a constant F at any given time, and in particular:
+# F_xy (t=1.0) = 2.0
+#
+# This parameter file tracks the finite strain in two ways, once by using
+# compositional fields as illustrated in the finite strain cookbook, and
+# once by using a particle particle that sits and remains in the center of the domain.
+# The results should of course be the same.
+#
+# Numerical results for particle tracking and compositional fields
+# show equally excellent agreement:
+# F_xy (t=1.0) = 2.0
+
+set Additional shared libraries            = ./libfinite_strain.so
+set Dimension                              = 2
+set End time                               = 1.0
+set Use years in output instead of seconds = false
+set Output directory = output-simple_shear
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set X periodic = true
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+
+  subsection Function
+    set Function expression = if (y < 0.5, -1, 1); 0
+  end
+end
+
+subsection Material model
+  set Model name = finite strain
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0;0.0;0.0;1.0
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, visualization
+
+  subsection Visualization
+    set List of output variables = strain rate
+    set Time between graphical output = 0.05
+  end
+
+  subsection Particles
+    set Time between data output = 0.05
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain
+  set Particle generator name = ascii file
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = ./
+      set Data file name = simple_shear_particle.dat
+    end
+  end
+end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm.bak
new file mode 100644
index 00000000000..6bba7d2ad73
--- /dev/null
+++ b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm.bak
@@ -0,0 +1,169 @@
+# This model applies a surface load (using the traction
+# boundary condition) on a free surface overlying
+# a viscoelastic box. It approximates the analytical solution
+# of Nakiboglu and Lambeck (1982) for an applied/removed
+# axisymmetric cylindrical load over a viscoelastic half-space.
+
+#  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1500
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set CFL number                             = 0.5
+set Maximum time step                      = 10
+set Output directory                       = output_free_surface_VE_cylinder_2D_loading
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+
+# Model geometry (500x500 km, 50 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 500e3
+    set Y extent      = 500e3
+  end
+end
+
+# Mesh refinement specifications
+# Mesh refinement does not seem to affect
+# deformation of free surface (at least in 2-D).
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Time steps between mesh refinement = 1
+  set Strategy         = strain rate
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Mesh deformation
+  set Additional tangential mesh velocity boundary indicators = left,right
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Surface velocity projection      = normal
+  end
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+end
+
+# Prescribe a fixed vertical traction on the top boundary
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = top y: function
+
+  subsection Function
+    set Variable names = x,y,t
+
+    #set Function expression = 0; 1.e9 + -20.e3*x
+    set Function constants  = r0=100.e3, H0=1.e3, t1=1.e3, rhoi=900, g=9.8, t0=1.e3
+
+    # r0 is load radius, H0 is load height, t1 is time load is fully removed,
+    # rhoi is density of ice/load
+    # option to linearly thin load beginning at time t0.
+    set Function expression = 0; if (x<r0 ,if(t<t0,-g*H0*rhoi,if(t<t1,-g*H0*rhoi*(1-(t-t0)/t1),0)), 0)
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0;
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = true
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# Temperature initial conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 3300
+    set Viscosities                 = 3.e20
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e2
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.8
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate
+    set Time between graphical output = 1e2
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+
+  subsection Topography
+    set Output to file = true
+    set Time between text output = 100
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt.prm.bak
new file mode 100644
index 00000000000..4ffb854ca76
--- /dev/null
+++ b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt.prm.bak
@@ -0,0 +1,21 @@
+# Same as free_surface_VE_cylinder_2D_loading.prm, but uses
+# a fixed elastic timestep in combination with stress averaging
+# to smooth out the elastic response to instantaneous stress changes.
+
+include free_surface_VE_cylinder_2D_loading.prm
+
+
+#  Global parameters
+set Dimension                              = 2
+set Output directory                       = output_free_surface_VE_cylinder_2D_loading_fixed_elastic_dt
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Use fixed elastic time step = true
+    set Fixed elastic time step     = 1e2
+    set Viscosity averaging scheme  = harmonic
+  end
+end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_unloading.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_unloading.prm.bak
new file mode 100644
index 00000000000..cef117fb836
--- /dev/null
+++ b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_unloading.prm.bak
@@ -0,0 +1,27 @@
+# This model applies a surface load (using the traction
+# boundary condition) on a free surface overlying
+# a viscoelastic box. It approximates the analytical solution
+# of Nakiboglu and Lambeck (1982) for an applied/removed
+# axisymmetric cylindrical load over a viscoelastic half-space.
+
+# Modified such that linear unloading occurs at intermediate
+# time steps. Compare to soln_reload files.
+
+include free_surface_VE_cylinder_2D_loading.prm
+
+
+#  Global parameters
+set Dimension                              = 2
+set Output directory                       = output_free_surface_VE_cylinder_2D_loading_unloading
+
+subsection Boundary traction model
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants  = r0=100.e3, H0=1.e3, t1=1.e3, rhoi=900, g=9.8, t0=5.e2
+
+    # r0 is load radius, H0 is load height, t1 is time load is fully removed,
+    # rhoi is density of ice/load
+    # option to linearly thin load beginning at time t0.
+    set Function expression = 0; if (x<r0 ,if(t<t0,-g*H0*rhoi,if(t<t1,-g*H0*rhoi*(1-(t-t0)/t1),0)), 0)
+  end
+end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading.prm.bak
new file mode 100644
index 00000000000..fca02c2d27c
--- /dev/null
+++ b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading.prm.bak
@@ -0,0 +1,170 @@
+# This model applies a surface load (using the traction
+# boundary condition) on a free surface overlying
+# a viscoelastic box. It approximates the analytical solution
+# of Nakiboglu and Lambeck (1982) for an applied/removed
+# axisymmetric cylindrical load over a viscoelastic half-space.
+
+
+#  Global parameters
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 1500
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set CFL number                             = 0.5
+set Maximum time step                      = 10
+set Output directory                       = output_free_surface_VE_cylinder_3D_loading
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+
+# Model geometry (500x500x500 km, 50 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set Z repetitions = 10
+    set X extent      = 500e3
+    set Y extent      = 500e3
+    set Z extent      = 500e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Time steps between mesh refinement = 1
+  set Strategy         = strain rate
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Mesh deformation
+  set Additional tangential mesh velocity boundary indicators = left, right, front, back
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Surface velocity projection      = normal
+  end
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right, front, back
+end
+
+# Prescribe a fixed vertical traction on the top boundary
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = top z: function
+
+  subsection Function
+    set Variable names = x,y,z,t
+
+    #set Function expression = 0; 1.e9 + -20.e3*x
+    set Function constants  = r0=100.e3, H0=1.e3, t1=1.e3, rhoi=900, g=9.8, t0=1.e3
+
+    # r0 is load radius, H0 is load height, t1 is time load is fully removed,
+    # rhoi is density of ice/load
+    # option to linearly thin load beginning at time t0.
+    set Function expression = 0; 0; if ((x^2+y^2)<r0^2 ,if(t<t0,-g*H0*rhoi,if(t<t1,-g*H0*rhoi*(1-(t-t0)/t1),0)), 0)
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_zz, ve_stress_xy, ve_stress_xz, ve_stress_yz
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  =
+    set Function expression = 0; 0; 0; 0; 0; 0;
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = true
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right, front, back
+  set List of model names = initial temperature
+end
+
+# Temperature initial conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 3300
+    set Viscosities                 = 3.e20
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e2
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.8
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate
+    set Time between graphical output = 1e2
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+
+  subsection Topography
+    set Output to file = true
+    set Time between text output = 100
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading_fixed_elastic_dt.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading_fixed_elastic_dt.prm.bak
new file mode 100644
index 00000000000..db965ee7966
--- /dev/null
+++ b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading_fixed_elastic_dt.prm.bak
@@ -0,0 +1,21 @@
+# Same as free_surface_VE_cylinder_3D_loading.prm, instead
+# setting fixed elastic timestep and allowing stress averaging,
+# to smooth out elastic response to instantaneous stress changes.
+
+include free_surface_VE_cylinder_3D_loading.prm
+
+
+#  Global parameters
+set Dimension                              = 3
+set Output directory                       = output_free_surface_VE_cylinder_3D_loading_fixed_elastic_dt
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Use fixed elastic time step = true
+    set Fixed elastic time step     = 1e2
+    set Viscosity averaging scheme  = harmonic
+  end
+end
diff --git a/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_2D_loading.prm.bak b/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_2D_loading.prm.bak
new file mode 100644
index 00000000000..5cb6d26b333
--- /dev/null
+++ b/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_2D_loading.prm.bak
@@ -0,0 +1,22 @@
+# This model applies a surface load (using the traction
+# boundary condition) on a free surface overlying
+# a viscous box. It approximates the analytical solution
+# of Haskell (1935a) for an instantaneously applied
+# axisymmetric cylindrical load over a viscous half-space.
+
+# This is done by using the viscoelastic model and
+# setting a high shear modulus, which produces viscous behavior.
+
+include ../viscoelastic/free_surface_VE_cylinder_2D_loading.prm
+
+set Dimension                              = 2
+set Output directory                       = output_free_surface_viscous_cylinder_2D_loading
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Elastic shear moduli        = 1.e50
+  end
+end
diff --git a/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_3D_loading.prm.bak b/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_3D_loading.prm.bak
new file mode 100644
index 00000000000..1bae0228576
--- /dev/null
+++ b/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_3D_loading.prm.bak
@@ -0,0 +1,22 @@
+# This model applies a surface load (using the traction
+# boundary condition) on a free surface overlying
+# a viscous box. It approximates the analytical solution
+# of Haskell (1935a) for an instantaneously applied
+# axisymmetric cylindrical load over a viscous half-space.
+
+# This is done by using the viscoelastic model and
+# setting a high shear modulus.
+
+include ../viscoelastic/free_surface_VE_cylinder_3D_loading.prm
+
+set Dimension                              = 3
+set Output directory                       = output_free_surface_viscous_cylinder_3D_loading
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Elastic shear moduli        = 1.e50
+  end
+end
diff --git a/benchmarks/geoid-spectral-comparison/spectral-comparison.prm.bak b/benchmarks/geoid-spectral-comparison/spectral-comparison.prm.bak
new file mode 100644
index 00000000000..132e9d825ac
--- /dev/null
+++ b/benchmarks/geoid-spectral-comparison/spectral-comparison.prm.bak
@@ -0,0 +1,124 @@
+# Spectral Comparison of the Geoid
+
+# Define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 3
+
+# Specify the time you want to let the model run for in
+# years and the output directory. Here we only calculate
+# the instantaneous solution.
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Output directory                       = output
+
+# The following variables describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Here we specify the residual tolerance for the linear solver.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-5
+    set Number of cheap Stokes solver steps             = 0
+  end
+end
+
+# Here we specify the geometry of the domain, which is
+# a spherical shell with inner radius of 3481km and
+# outer radius of 6371km
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6371000
+  end
+end
+
+# This section describes the gravity field, which is pointing
+# towards the Earth's center with the same magnitude of 10 m/s^2
+# everywhere
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+# This section prescribes the initial condition in the temperature
+# field, which is chosen as a scaled version of the S20RTS shear
+# wave velocity model (Ritsema et al., 2000). S20RTS is defined
+# by spherical harmonics up to degree 20 that are radially interpolated
+# with a cubic spline.
+subsection Initial temperature model
+  set Model name = S40RTS perturbation
+
+  subsection S40RTS perturbation
+    # The two input options here are S20RTS or the higher resolution
+    # S40RTS (Ritsema et al., 2011). One can choose to remove the
+    # degree 0 from these files so that the depth average value
+    # is zero.
+    set Initial condition file name       = S20RTS.sph
+    set Remove degree 0 from perturbation = false
+
+    # The following parameters determine the scaling from shear wave
+    # velocity perturbation to temperature differences. We chose the
+    # scaling to density perturbation as 0.15
+    set Vs to density scaling             = 0.15
+    set Thermal expansion coefficient in initial temperature scaling = 3e-5
+
+    # This specifies the background temperature to which we add the
+    # temperature difference.
+    set Reference temperature             = 1600
+
+    #    set Remove temperature heterogeneity down to specified depth = 660000
+  end
+end
+
+# The material model is based on the simple material model, which assumes
+# a constant density, and other parameters as stated below.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                 = 3300
+    set Viscosity                         = 1e21
+    set Thermal expansion coefficient     = 3e-5
+    set Reference temperature             = 1600
+    set Thermal conductivity              = 4.125
+    set Reference specific heat           = 1250
+  end
+end
+
+# For this calculation we only do 3 global refinement steps. This resolution
+# is too low to fully resolve the mantle flow, however it does capture
+# the main features.
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 0
+end
+
+# We assume free slip at the inner and outer boundary
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom
+end
+
+# We output the density, velocity, dynamic topography, geoid and heat flux density
+# for plotting.
+subsection Postprocess
+  set List of postprocessors = geoid, dynamic topography, visualization, basic statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set List of output variables      = geoid, dynamic topography,  density, viscosity, gravity
+    set Time between graphical output = 0
+    set Number of grouped files       = 1
+  end
+
+  subsection Geoid
+    set Also output the gravity anomaly  = true
+  end
+end
diff --git a/benchmarks/grain_size_pinned_state/grain_size_plunge.prm.bak b/benchmarks/grain_size_pinned_state/grain_size_plunge.prm.bak
new file mode 100644
index 00000000000..c4d11dfca7c
--- /dev/null
+++ b/benchmarks/grain_size_pinned_state/grain_size_plunge.prm.bak
@@ -0,0 +1,162 @@
+# A test for the grain size material model using pinned state damage formulation.
+# This test is like tests/grain_size_strain_pinned_state.prm, but uses the parameters
+# from Mulyukova and Bercovici (2018) at constant
+# temperature and stress in their Figure 4.
+
+# The output can be compared to the analytical solution computed in the
+# grain_size_plunge.ipynb notebook located in the same folder as this input file.
+
+set Dimension                              = 2
+set End time                               = 1e7
+set Output directory                       = output-grain_size_plunge
+set Use years in output instead of seconds = true
+set Maximum first time step                = 10
+set Maximum relative increase in time step = 1
+set Nonlinear solver scheme                = iterated Advection and defect correction Stokes
+set Max nonlinear iterations               = 50
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1100
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+    set X periodic = true
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top,bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 1100
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = top x: function, bottom x: function
+
+  subsection Function
+    set Variable names = x,y
+
+    # We want to prescribe a tangential traction of 50 MPa
+    # at the top boundary and -50 at the bottom boundary.
+    set Function constants = traction = 50e6, y_extent = 1e5
+    set Function expression = if (y>y_extent/2, traction, -traction)  ;  0
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top y: function, bottom y: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 0
+
+    subsection Function
+      set Function expression       = 0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+
+    # This is the test case from Mulyukova and Bercovici (2018) using
+    # the parameters from their figure 4 and a grain size of 1e-2 m.
+    set Function expression = 1e-2
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+end
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                = 3400
+    set Thermal conductivity             = 0
+    set Thermal expansion coefficient    = 0
+    set Reference compressibility        = 0
+    set Viscosity                        = 1e18
+    set Minimum viscosity                = 1e16
+    set Reference temperature            = 1100
+    set Recrystallized grain size        =
+    set Grain growth activation energy       = 3e5
+    set Grain growth activation volume       = 0.0
+    set Grain growth rate constant           = 1.6E-022
+    set Grain growth exponent                = 4
+    set Average specific grain boundary energy = 1.0
+    set Geometric constant                   = 3
+    set Grain size evolution formulation     = pinned grain damage
+
+    # Mulyukova and Bercovici (2018)
+    # Diffusion creep
+    set Diffusion creep prefactor            = 27.2e-24 # s^-1 Pa^-1 m^p
+    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 3e5 #J/mol
+    set Diffusion activation volume          = 0 # m^3/mol
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # Dislocation creep
+    set Dislocation creep prefactor          = 8.8e-13 # s^-1 Pa^-n
+    set Dislocation creep exponent           = 3
+    set Dislocation activation energy        = 530000 # J/mol
+    set Dislocation activation volume        = 0 # m^3/mol
+    set Minimum grain size                   = 1e-8
+
+    subsection Grain damage partitioning
+      set Minimum grain size reduction work fraction = 5e-3
+      set Maximum grain size reduction work fraction = 5e-3
+    end
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, visualization, material statistics, ODE statistics
+
+  subsection Visualization
+    set List of output variables = viscosity, shear stress, stress, stress second invariant
+    set Time between graphical output = 5e3
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net x translation
+end
diff --git a/benchmarks/gravity_mantle/mantle_gravity.prm.bak b/benchmarks/gravity_mantle/mantle_gravity.prm.bak
new file mode 100644
index 00000000000..82754a08720
--- /dev/null
+++ b/benchmarks/gravity_mantle/mantle_gravity.prm.bak
@@ -0,0 +1,76 @@
+# A simple setup for testing the gravity postprocessor using the
+# sample scheme 'map'.
+# See the corresponding section in the manual for more information.
+
+# General parameters
+set Dimension                              = 3
+set End time                               = 0
+set Output directory                       = output-gravity-mantle
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3480e3
+    set Outer radius  = 6251e3
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Thermal expansion coefficient = 3e-5
+  end
+end
+
+# Model initial temperature
+subsection Initial temperature model
+  set Model name = S40RTS perturbation
+
+  subsection S40RTS perturbation
+    set Initial condition file name       = S40RTS.sph
+    set Spline knots depth file name      = Spline_knots.txt
+    set Remove degree 0 from perturbation = false
+    set Vs to density scaling             = 0.15
+    set Thermal expansion coefficient in initial temperature scaling = 3e-5
+    set Reference temperature             = 0
+  end
+end
+
+# Model gravity
+subsection Gravity model
+  set Model name = radial constant
+end
+
+# Mesh refinement
+subsection Mesh refinement
+  set Initial global refinement = 3
+end
+
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = gravity calculation,visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity
+    set Time between graphical output = 0
+    set Interpolate output = false
+  end
+
+  subsection Gravity calculation
+    set Sampling scheme = map
+    set Minimum radius = 6621e3
+    set Minimum longitude = -180
+    set Maximum longitude = 179
+    set Number points longitude = 180
+    set Minimum latitude = -90
+    set Maximum latitude = +90
+    set Number points latitude  = 90
+    set Quadrature degree increase = 01
+  end
+end
diff --git a/benchmarks/gravity_thick_shell/doc/thick_shell.prm.bak b/benchmarks/gravity_thick_shell/doc/thick_shell.prm.bak
new file mode 100644
index 00000000000..d21edf6563d
--- /dev/null
+++ b/benchmarks/gravity_thick_shell/doc/thick_shell.prm.bak
@@ -0,0 +1,11 @@
+subsection Postprocess
+  set List of postprocessors = gravity calculation,visualization
+
+  subsection Gravity calculation
+    set Sampling scheme = list of points
+    set List of radius    = 0,1e6,2e6,3e6,3.5e6,4e6,4.5e6,5e6,5.5e6,6e6,6.371e6,6.5e6,7e6,8e6,9e6,10e6
+    set List of longitude = 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
+    set List of latitude  = 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
+    set Quadrature degree increase = 1
+  end
+end
diff --git a/benchmarks/gravity_thick_shell/thick_shell.prm.bak b/benchmarks/gravity_thick_shell/thick_shell.prm.bak
new file mode 100644
index 00000000000..911dd9853f8
--- /dev/null
+++ b/benchmarks/gravity_thick_shell/thick_shell.prm.bak
@@ -0,0 +1,72 @@
+# A simple setup for testing the gravity postprocessor using the
+# sample scheme 'list of points'. The domain is a 2891 km thick
+# shell of constant density, i.e. the Earth mantle.
+# An analytical solution exists for the gravitational acceleration
+# and potential so that values returned by the gravity postprocessor
+# can be benchmarked on a line from the center of the planet to
+# 10,000 km outside.
+# See the corresponding section in the manual for more information.
+
+# General parameters
+set Dimension                              = 3
+set End time                               = 0
+set Output directory                       = output_shellgravity
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3480e3
+    set Outer radius = 6371e3
+  end
+end
+
+# Model boundary velocity
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top, bottom
+end
+
+# Material model
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3300
+    set Thermal expansion coefficient = 0
+  end
+end
+
+# Model gravity
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+# Mesh refinement
+subsection Mesh refinement
+  set Initial global refinement = 4
+end
+
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = gravity calculation,visualization
+
+  subsection Visualization
+    set List of output variables = density
+    set Time between graphical output = 0
+    set Interpolate output = false
+  end
+
+  subsection Gravity calculation
+    set Sampling scheme = list of points
+    set List of radius    = 0,1e6,2e6,3e6,3.5e6,4e6,4.5e6,5e6,5.5e6,6e6,6.371e6,6.5e6,7e6,8e6,9e6,10e6
+    set List of longitude = 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
+    set List of latitude  = 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
+    set Quadrature degree increase = 1
+  end
+end
diff --git a/benchmarks/gravity_thin_shell/doc/thinshell_a.prm.bak b/benchmarks/gravity_thin_shell/doc/thinshell_a.prm.bak
new file mode 100644
index 00000000000..aec41ce6b98
--- /dev/null
+++ b/benchmarks/gravity_thin_shell/doc/thinshell_a.prm.bak
@@ -0,0 +1,11 @@
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 6266e3
+    set Outer radius = 6276e3
+    set Custom mesh subdivision = number of slices
+    set Number of slices = 1
+    set Initial lateral refinement = 5
+  end
+end
diff --git a/benchmarks/gravity_thin_shell/doc/thinshell_b.prm.bak b/benchmarks/gravity_thin_shell/doc/thinshell_b.prm.bak
new file mode 100644
index 00000000000..3bf6a339c65
--- /dev/null
+++ b/benchmarks/gravity_thin_shell/doc/thinshell_b.prm.bak
@@ -0,0 +1 @@
+set Nonlinear solver scheme = no Advection, no Stokes
diff --git a/benchmarks/gravity_thin_shell/doc/thinshell_c.prm.bak b/benchmarks/gravity_thin_shell/doc/thinshell_c.prm.bak
new file mode 100644
index 00000000000..7185128e5de
--- /dev/null
+++ b/benchmarks/gravity_thin_shell/doc/thinshell_c.prm.bak
@@ -0,0 +1,15 @@
+subsection Postprocess
+  set List of postprocessors = gravity calculation,visualization
+
+  subsection Gravity calculation
+    set Sampling scheme = map
+    set Minimum radius = 6621e3
+    set Minimum longitude = -180
+    set Maximum longitude = 179
+    set Number points longitude = 180
+    set Minimum latitude = -90
+    set Maximum latitude = +90
+    set Number points latitude  = 90
+    set Quadrature degree increase = 1
+  end
+end
diff --git a/benchmarks/gravity_thin_shell/gravity_thin_shell.prm.bak b/benchmarks/gravity_thin_shell/gravity_thin_shell.prm.bak
new file mode 100644
index 00000000000..4b778bd997f
--- /dev/null
+++ b/benchmarks/gravity_thin_shell/gravity_thin_shell.prm.bak
@@ -0,0 +1,88 @@
+# A simple setup for testing the gravity postprocessor using the
+# sample scheme 'map'. The domain is a 5 km thick thin shell of constant density.
+# An analytical solution exists for the gravitational acceleration
+# and potential so that values returned by the gravity postprocessor
+# can be benchmarked on a longitude-latitude grid at satellite orbit height.
+
+set Dimension                              = 3
+set End time                               = 0
+set Output directory                       = output_thin_shell_gravity
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry
+# The thin shell (5 km thickness) can be centered around 5 different depths,
+# 0, 100, 500, 1500 and 3000 km, i.e. radii 6371, 6271, 5871, 4871 and 3371 km.
+# The default depth is here 100 km while other corresponding inner and outer
+# radii are commented.
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    # layer 0 km depth
+    #set Inner radius = 6366e3
+    #set Outer radius = 6376e3
+    # layer 100 km depth
+    set Inner radius = 6266e3
+    set Outer radius = 6276e3
+
+    # layer 500 km depth
+    #set Inner radius = 5866e3
+    #set Outer radius = 5876e3
+    # layer 1500 km depth
+    #set Inner radius = 4866e3
+    #set Outer radius = 4876e3
+    # layer 3000 km depth
+    #set Inner radius = 3366e3
+    #set Outer radius = 3376e3
+    set Custom mesh subdivision = number of slices
+    set Number of slices = 1
+    set Initial lateral refinement = 5
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top, bottom
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3300
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = gravity calculation,visualization
+
+  subsection Visualization
+    set List of output variables = density, viscosity, partition
+    set Time between graphical output = 0
+    set Interpolate output = false
+  end
+
+  subsection Gravity calculation
+    set Sampling scheme = map
+    set Minimum radius = 6621e3
+    set Minimum longitude = -180
+    set Maximum longitude = 179
+    set Number points longitude = 180
+    set Minimum latitude = -90
+    set Maximum latitude = +90
+    set Number points latitude  = 90
+    set Quadrature degree increase = 1
+  end
+end
diff --git a/benchmarks/hollow_sphere/hollow_sphere.cc.bak b/benchmarks/hollow_sphere/hollow_sphere.cc.bak
new file mode 100644
index 00000000000..12ebe62fc77
--- /dev/null
+++ b/benchmarks/hollow_sphere/hollow_sphere.cc.bak
@@ -0,0 +1,682 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/postprocess/dynamic_topography.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+
+namespace aspect
+{
+  /**
+   * This is the "HollowSphere" benchmark defined in the following paper:
+   * Analytical solution for viscous incompressible Stokes flow in a spherical shell
+   * C. Thieulot, in prep.
+   */
+  namespace HollowSphereBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+      const double gammma = 1.0;
+
+      const double R1 = 0.5;
+      const double R2 = 1.0;
+
+      const double gravity = 1.0;
+      const double mu0=1;
+      const double rho_0 = 1000;
+
+      Tensor<1,3>
+      hollow_sphere_velocity (const Point<3> &pos,
+                              const double mmm)
+      {
+
+        const std::array<double,3> spos =
+          aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(pos);
+
+        const double r=spos[0];
+        const double phi=spos[1];
+        const double theta=spos[2];
+
+
+        double alpha,beta,fr,gr;
+
+        if (mmm == -1)
+          {
+            alpha=-gammma*(pow(R2,3)-pow(R1,3))/(pow(R2,3)*log(R1)-pow(R1,3)*log(R2));
+            beta=-3*gammma*(log(R2)-log(R1))/(pow(R1,3)*log(R2)-pow(R2,3)*log(R1)) ;
+            fr=alpha/(r*r)+beta*r;
+            gr=-2/(r*r)*(alpha*log(r)+beta/3*pow(r,3)+gammma);
+          }
+        else
+          {
+            alpha=gammma*(mmm+1)*(pow(R1,-3)-pow(R2,-3))/(pow(R1,-mmm-4)-pow(R2,-mmm-4));
+            beta=-3*gammma*(pow(R1,mmm+1)-pow(R2,mmm+1))/(pow(R1,mmm+4)-pow(R2,mmm+4));
+            fr=alpha/pow(r,mmm+3)+beta*r;
+            gr=-2/(r*r)*(-alpha/(mmm+1)*pow(r,-mmm-1)+beta/3*pow(r,3)+gammma);
+          }
+
+        const double v_r    =gr*cos(theta);
+        const double v_theta=fr*sin(theta);
+        const double v_phi  =fr*sin(theta);
+        const double v_x=sin(theta)*cos(phi)*v_r + cos(theta)*cos(phi)*v_theta-sin(phi)*v_phi;
+        const double v_y=sin(theta)*sin(phi)*v_r + cos(theta)*sin(phi)*v_theta+cos(phi)*v_phi;
+        const double v_z=cos(theta)*v_r - sin(theta)*v_theta;
+
+        // create a Point<3> (because it has a constructor that takes
+        // three doubles) and return it (it automatically converts to
+        // the necessary Tensor<1,3>).
+        return Point<3> (v_x,v_y,v_z);
+      }
+
+      double
+      hollow_sphere_pressure (const Point<3> &pos,
+                              const double mmm)
+      {
+        const std::array<double,3> spos =
+          aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(pos);
+
+        const double r=spos[0];
+        const double theta=spos[2];
+
+        double alpha,beta,gr,hr,mur;
+
+
+        if (mmm == -1)
+          {
+            mur=mu0;
+            alpha=-gammma*(pow(R2,3)-pow(R1,3))/(pow(R2,3)*log(R1)-pow(R1,3)*log(R2));
+            beta=-3*gammma*(log(R2)-log(R1))/(pow(R1,3)*log(R2)-pow(R2,3)*log(R1)) ;
+            gr=-2/(r*r)*(alpha*log(r)+beta/3*pow(r,3)+gammma);
+            hr=2/r*gr*mur;
+          }
+        else
+          {
+            mur=mu0*pow(r,mmm+1);
+            alpha=gammma*(mmm+1)*(pow(R1,-3)-pow(R2,-3))/(pow(R1,-mmm-4)-pow(R2,-mmm-4));
+            beta=-3*gammma*(pow(R1,mmm+1)-pow(R2,mmm+1))/(pow(R1,mmm+4)-pow(R2,mmm+4));
+            gr=-2/(r*r)*(-alpha/(mmm+1)*pow(r,-mmm-1)+beta/3*pow(r,3)+gammma);
+            hr=(mmm+3)/r*gr*mur;
+          }
+
+        return hr*cos(theta) + rho_0 * gravity * (R2 - r);
+      }
+
+      template <int dim>
+      double
+      hollow_sphere_normal_traction(const Point<dim> &pos,
+                                    const double mmm)
+      {
+        Assert (dim == 3, ExcNotImplemented());
+
+        const double r=std::sqrt(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2]);
+        const double theta=std::acos(pos[2]/r);
+
+        double alpha,beta,fr,gr;
+
+
+        if (mmm == -1)
+          {
+            alpha=-gammma*(pow(R2,3)-pow(R1,3))/(pow(R2,3)*log(R1)-pow(R1,3)*log(R2));
+            beta=-3*gammma*(log(R2)-log(R1))/(pow(R1,3)*log(R2)-pow(R2,3)*log(R1)) ;
+            fr=alpha/(r*r)+beta*r;
+            gr=-2/(r*r)*(alpha*log(r)+beta/3*pow(r,3)+gammma);
+          }
+        else
+          {
+            alpha=gammma*(mmm+1)*(pow(R1,-3)-pow(R2,-3))/(pow(R1,-mmm-4)-pow(R2,-mmm-4));
+            beta=-3*gammma*(pow(R1,mmm+1)-pow(R2,mmm+1))/(pow(R1,mmm+4)-pow(R2,mmm+4));
+            fr=alpha/pow(r,mmm+3)+beta*r;
+            gr=-2/(r*r)*(-alpha/(mmm+1)*pow(r,-mmm-1)+beta/3*pow(r,3)+gammma);
+          }
+
+        return -(6.*gr + 4.*fr) * cos(theta) * mu0 / r;
+      }
+
+
+      /**
+       * The exact solution for the HollowSphere benchmark.
+       */
+      template <int dim>
+      class FunctionHollowSphere : public Function<dim>
+      {
+        public:
+          FunctionHollowSphere (const double mmm)
+            :
+            Function<dim>(dim+2),
+            mmm_(mmm)
+          {}
+
+          void vector_value (const Point<dim>   &pos,
+                             Vector<double>   &values) const override
+          {
+            Assert (dim == 3, ExcNotImplemented());
+            Assert (values.size() >= 4, ExcInternalError());
+
+            const Point<3> p (pos[0], pos[1], pos[2]);
+
+            const Tensor<1,3> v = AnalyticSolutions::hollow_sphere_velocity (p, mmm_);
+            values[0] = v[0];
+            values[1] = v[1];
+            values[2] = v[2];
+
+            values[3] = AnalyticSolutions::hollow_sphere_pressure (p, mmm_);
+          }
+
+        private:
+          const double mmm_;
+      };
+    }
+
+
+
+    template <int dim>
+    class HollowSphereBoundary : public BoundaryVelocity::Interface<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        HollowSphereBoundary();
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id ,
+                           const Point<dim> &position) const override;
+
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+        */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+
+      private:
+        double mmm;
+    };
+
+    template <int dim>
+    HollowSphereBoundary<dim>::HollowSphereBoundary ()
+      :
+      mmm (0)
+    {}
+
+
+
+    template <>
+    Tensor<1,2>
+    HollowSphereBoundary<2>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<2> &) const
+    {
+      Assert (false, ExcNotImplemented());
+      return Tensor<1,2>();
+    }
+
+
+
+    template <>
+    Tensor<1,3>
+    HollowSphereBoundary<3>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<3> &p) const
+    {
+      return AnalyticSolutions::hollow_sphere_velocity (p, mmm);
+    }
+
+
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class HollowSphereMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+
+        /**
+         * Returns the viscosity value in the inclusion
+         */
+        double get_mmm() const;
+
+        /**
+         * viscosity value in the inclusion
+         */
+        double mmm;
+    };
+
+
+
+    template <int dim>
+    bool
+    HollowSphereMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+
+    template <>
+    void
+    HollowSphereMaterial<2>::
+    evaluate (const MaterialModel::MaterialModelInputs<2> &/*in*/,
+              MaterialModel::MaterialModelOutputs<2> &/*out*/) const
+    {
+      Assert (false, ExcNotImplemented());
+    }
+
+
+
+    template <>
+    void
+    HollowSphereMaterial<3>::
+    evaluate (const MaterialModel::MaterialModelInputs<3> &in,
+              MaterialModel::MaterialModelOutputs<3> &out) const
+    {
+      const unsigned int dim = 3;
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const Point<dim> &pos = in.position[i];
+          const std::array<double,dim> spos = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(pos);
+          const double r = spos[0];
+          const double mu = pow(r,mmm+1);
+          out.viscosities[i] = mu;
+
+          const double theta=spos[2];
+
+          const double gammma = 1.0;
+          const double R1 = 0.5;
+          const double R2 = 1.0;
+
+          double alpha,beta,rho;
+          const double rho_0 = 1000.;
+
+          if (mmm == -1)
+            {
+              alpha = -gammma*(pow(R2,3)-pow(R1,3))/(pow(R2,3)*log(R1)-pow(R1,3)*log(R2));
+              beta  = -3*gammma*(log(R2)-log(R1))/(pow(R1,3)*log(R2)-pow(R2,3)*log(R1)) ;
+              rho = -(alpha/pow(r,4)*(8*log(r)-6) + 8./3.*beta/r+8*gammma/pow(r,4))*cos(theta) + rho_0;
+            }
+          else
+            {
+              alpha=gammma*(mmm+1)*(pow(R1,-3)-pow(R2,-3))/(pow(R1,-mmm-4)-pow(R2,-mmm-4));
+              beta=-3*gammma*(pow(R1,mmm+1)-pow(R2,mmm+1))/(pow(R1,mmm+4)-pow(R2,mmm+4));
+              rho= -(2*alpha*pow(r,-4)*(mmm+3)/(mmm+1)*(mmm-1)-2*beta/3*(mmm-1)*(mmm+3)*pow(r,mmm)-mmm*(mmm+5)*2*gammma*pow(r,mmm-3) )*cos(theta) + rho_0;
+            }
+
+          out.densities[i] = rho;
+
+          out.specific_heat[i] = 0;
+          out.thermal_conductivities[i] = 0.0;
+          out.compressibilities[i] = 0;
+          out.thermal_expansion_coefficients[i] = 0;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    HollowSphereMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      //create a global section in the parameter file for parameters
+      //that describe this benchmark. note that we declare them here
+      //in the material model, but other kinds of plugins (e.g., the gravity
+      //model below) may also read these parameters even though they do not
+      //declare them
+      prm.enter_subsection("HollowSphere benchmark");
+      {
+        prm.declare_entry("Viscosity parameter", "-1",
+                          Patterns::Double (),
+                          "Viscosity in the HollowSphere benchmark.");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    HollowSphereMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("HollowSphere benchmark");
+      {
+        mmm = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+    template <int dim>
+    void
+    HollowSphereBoundary<dim>::declare_parameters (ParameterHandler &)
+    {
+      //nothing to declare here. This plugin will however, read parameters
+      //declared by the material model in the "HollowSphere benchmark" section
+    }
+
+
+    template <int dim>
+    void
+    HollowSphereBoundary<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("HollowSphere benchmark");
+      {
+        mmm = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    double
+    HollowSphereMaterial<dim>::get_mmm() const
+    {
+      return mmm;
+    }
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the paper Duretz et al. reference above.
+      */
+    template <int dim>
+    class HollowSpherePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * List the other postprocessors required by this plugin.
+         */
+        std::list<std::string>
+        required_other_postprocessors() const override;
+
+      private:
+        /**
+         * Calculate the L2 dynamic topography error.
+         */
+        double
+        compute_dynamic_topography_error() const;
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    HollowSpherePostprocessor<dim>::execute (TableHandler &)
+    {
+      std::unique_ptr<Function<dim>> ref_func;
+      {
+        const HollowSphereMaterial<dim> &
+        material_model
+          = Plugins::get_plugin_as_type<const HollowSphereMaterial<dim>>(this->get_material_model());
+
+        ref_func = std::make_unique<AnalyticSolutions::FunctionHollowSphere<dim>>(material_model.get_mmm());
+      }
+
+      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                          dim+2);
+      ComponentSelectFunction<dim> comp_p(dim, dim+2);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_u,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_p,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_p);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_ul2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_pl2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+      const double topo_l2 = compute_dynamic_topography_error();
+
+      std::ostringstream os;
+
+      os << std::scientific <<  u_l1
+         << ", " << p_l1
+         << ", " << u_l2
+         << ", " << p_l2
+         << ", " << topo_l2;
+
+      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2 topo_L2:", os.str());
+    }
+
+    /**
+     * Register the other postprocessor that we need: DynamicTopography
+     */
+    template <int dim>
+    std::list<std::string>
+    HollowSpherePostprocessor<dim>::required_other_postprocessors() const
+    {
+      return std::list<std::string> (1, "dynamic topography");
+    }
+
+
+    template <>
+    double
+    HollowSpherePostprocessor<2>::compute_dynamic_topography_error () const
+    {
+      Assert (false, ExcNotImplemented());
+      return 0.0;
+    }
+
+
+
+    /**
+     * Integrate the difference between the analytical and numerical
+     * solutions for dynamic topography.
+     */
+    template <>
+    double
+    HollowSpherePostprocessor<3>::compute_dynamic_topography_error() const
+    {
+      const unsigned int dim = 3;
+      const Postprocess::DynamicTopography<dim> &dynamic_topography =
+        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<dim>>();
+
+      const HollowSphereMaterial<dim> &material_model
+        = Plugins::get_plugin_as_type<const HollowSphereMaterial<dim>>(this->get_material_model());
+      const double beta = material_model.get_mmm();
+
+      const QGauss<dim-1> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+      FEFaceValues<dim> fe_face_values(this->get_mapping(),
+                                       this->get_fe(),
+                                       quadrature_formula,
+                                       update_values | update_gradients |
+                                       update_quadrature_points | update_JxW_values);
+      LinearAlgebra::BlockVector topo_vector = dynamic_topography.topography_vector();
+      std::vector<double> topo_values(quadrature_formula.size());
+
+      double l2_error = 0.;
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell = this->get_dof_handler().begin_active(),
+      endc = this->get_dof_handler().end();
+
+      Point<dim> test;
+      test[2] = 1.0;
+      test[0] = 0.;
+      test[1] = 0.;
+      for (; cell!=endc; ++cell)
+        if (cell->is_locally_owned())
+          if (cell->at_boundary())
+            for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+              if (cell->face(f)->at_boundary() && cell->face(f)->boundary_id() == 1 /*outer surface*/)
+                {
+                  fe_face_values.reinit(cell, f);
+                  MaterialModel::MaterialModelInputs<dim> in_face(fe_face_values, cell, this->introspection(), this->get_solution());
+                  MaterialModel::MaterialModelOutputs<dim> out_face(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+                  in_face.requested_properties = MaterialModel::MaterialProperties::density;
+                  fe_face_values[this->introspection().extractors.temperature].get_function_values(topo_vector, topo_values);
+                  this->get_material_model().evaluate(in_face, out_face);
+
+                  for (unsigned int q=0; q < quadrature_formula.size(); ++q)
+                    {
+                      const Point<dim> p = fe_face_values.quadrature_point(q);
+                      const double analytic_normal_stress = AnalyticSolutions::hollow_sphere_normal_traction<dim>(p, beta);
+                      const double gravity = this->get_gravity_model().gravity_vector(p).norm();
+                      const double density = out_face.densities[q];
+                      const double diff = -analytic_normal_stress / gravity / density - topo_values[q];
+                      l2_error += (diff*diff) * fe_face_values.JxW(q);
+                    }
+                }
+      const double total_l2_error =  Utilities::MPI::sum(l2_error,this->get_mpi_communicator());
+      return std::sqrt(total_l2_error);
+    }
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HollowSphereBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(HollowSphereMaterial,
+                                   "HollowSphereMaterial",
+                                   "A material model that corresponds to the `HollowSphere' benchmark. "
+                                   "See the manual for more information.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(HollowSphereBoundary,
+                                            "HollowSphereBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "`HollowSphere' benchmark. See the manual for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(HollowSpherePostprocessor,
+                                  "HollowSpherePostprocessor",
+                                  "A postprocessor that compares the solution of the `HollowSphere' benchmark "
+                                  "with the one computed by ASPECT "
+                                  "and reports the error. See the manual for more information.")
+  }
+}
diff --git a/benchmarks/hollow_sphere/hollow_sphere.prm.bak b/benchmarks/hollow_sphere/hollow_sphere.prm.bak
new file mode 100644
index 00000000000..b7678faba23
--- /dev/null
+++ b/benchmarks/hollow_sphere/hollow_sphere.prm.bak
@@ -0,0 +1,103 @@
+# The 3D HollowSphere benchmark, for which an
+# analytical solution is available (Thieulot, in prep).
+
+
+############### Global parameters
+
+set Additional shared libraries            = ./libhollow_sphere.so
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Output directory                       = output
+set Pressure normalization                 = surface
+
+############### Parameters describing the model
+# The setup is a 3D shell
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 0.5
+    set Outer radius = 1.0
+    set Cells along circumference = 12
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom : HollowSphereBoundary, \
+                                                top : HollowSphereBoundary
+end
+
+subsection Material model
+  set Model name = HollowSphereMaterial
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 1.0
+  end
+end
+
+subsection HollowSphere benchmark
+  #Viscosity parameter is m
+  set Viscosity parameter             = 3
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+#subsection Discretization
+#set Stokes velocity polynomial degree = 1
+#set Use locally conservative discretization = true
+#end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, HollowSpherePostprocessor, memory statistics, dynamic topography
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, dynamic topography, gravity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/benchmarks/inclusion/adaptive.prm.base.bak b/benchmarks/inclusion/adaptive.prm.base.bak
new file mode 100644
index 00000000000..c539065b2ad
--- /dev/null
+++ b/benchmarks/inclusion/adaptive.prm.base.bak
@@ -0,0 +1,72 @@
+############### Global parameters
+
+set Additional shared libraries            = ./libinclusion.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
+                                                right : InclusionBoundary, \
+                                                bottom: InclusionBoundary, \
+                                                top   : InclusionBoundary
+end
+
+subsection Material model
+  set Model name = InclusionMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 13
+  set Initial global refinement                = 4
+  set Strategy = velocity#viscosity
+  set Run postprocessors on initial refinement = true
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.5
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = InclusionPostprocessor, visualization
+
+  subsection Visualization
+    set List of output variables = viscosity
+    set Time between graphical output = 0
+  end
+end
diff --git a/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.cc.bak b/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.cc.bak
new file mode 100644
index 00000000000..0ba0f0693a5
--- /dev/null
+++ b/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.cc.bak
@@ -0,0 +1,51 @@
+/*
+  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include "inclusion_compositional_fields.h"
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(InclusionCompositionalMaterial,
+                                   "InclusionCompositionalMaterial",
+                                   "A material model that corresponds to the 'Inclusion' benchmark "
+                                   "defined in Duretz et al., G-Cubed, 2011. using "
+                                   "compositional fields.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(InclusionBoundary,
+                                            "InclusionBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "``inclusion'' benchmark. See the manual and the Kronbichler, Heister "
+                                            "and Bangerth paper on ASPECT for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(InclusionPostprocessor,
+                                  "InclusionPostprocessor",
+                                  "A postprocessor that compares the solution of the benchmarks from "
+                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
+                                  "and reports the error. Specifically, it can compute the errors for "
+                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
+                                  "which material model is currently being used and adjusts "
+                                  "which exact solution to use accordingly.")
+  }
+}
diff --git a/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.h.bak b/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.h.bak
new file mode 100644
index 00000000000..b8d29972826
--- /dev/null
+++ b/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.h.bak
@@ -0,0 +1,34 @@
+#ifndef ASPECT_INCLUSION_COMPOSITIONAL_FIELDS_H
+#define ASPECT_INCLUSION_COMPOSITIONAL_FIELDS_H
+
+#include "../inclusion.h"
+
+
+
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class InclusionCompositionalMaterial : public InclusionMaterial<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              out.viscosities[i] = in.composition[i][0];
+              out.densities[i] = 0;
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+    };
+  }
+}
+#endif
diff --git a/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.prm.bak b/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.prm.bak
new file mode 100644
index 00000000000..0a368f998f3
--- /dev/null
+++ b/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.prm.bak
@@ -0,0 +1,91 @@
+# A description of the SolVI or Inclusion benchmark using
+# compositional fields for which a known solution is available.
+# See the manual for more information.
+
+############### Global parameters
+
+set Additional shared libraries            = ./libinclusion_compositional_fields.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
+                                                right : InclusionBoundary, \
+                                                bottom: InclusionBoundary, \
+                                                top   : InclusionBoundary
+end
+
+subsection Material model
+  set Model name = InclusionCompositionalMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Composition polynomial degree                = 1
+  set Stokes velocity polynomial degree            = 2
+  set Use discontinuous composition discretization = true
+  set Use locally conservative discretization      = false
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+subsection Compositional fields
+  set Number of fields            = 1
+  set Names of fields             = viscosity_comp
+  set Compositional field methods = field
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = eta_b=1e3, rmax=0.2
+    set Function expression = if((x-1.0)*(x-1.0)+(z-1.0)*(z-1.0)<=0.04,eta_b,1.0)
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, InclusionPostprocessor
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Number of grouped files       = 1
+    set Time between graphical output = 0
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/benchmarks/inclusion/compositional_fields/inclusion_particles.prm.bak b/benchmarks/inclusion/compositional_fields/inclusion_particles.prm.bak
new file mode 100644
index 00000000000..41aa2dc74df
--- /dev/null
+++ b/benchmarks/inclusion/compositional_fields/inclusion_particles.prm.bak
@@ -0,0 +1,119 @@
+# A description of the SolVI or Inclusion benchmark using
+# active particles for which a known solution is available.
+# See the manual for more information.
+
+############### Global parameters
+
+set Additional shared libraries            = ./libinclusion_compositional_fields.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
+                                                right : InclusionBoundary, \
+                                                bottom: InclusionBoundary, \
+                                                top   : InclusionBoundary
+end
+
+subsection Material model
+  set Model name = InclusionCompositionalMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Composition polynomial degree                = 2
+  set Stokes velocity polynomial degree            = 2
+  set Use discontinuous composition discretization = true
+  set Use locally conservative discretization      = false
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = viscosity_comp
+  set Compositional field methods = particles
+  set Mapped particle properties = viscosity_comp:function
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = eta_b=1e3, rmax=0.2
+    set Function expression = if((x-1.0)*(x-1.0)+(z-1.0)*(z-1.0)<=0.04,eta_b,1.0)
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, visualization, InclusionPostprocessor
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Number of grouped files       = 1
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = cell average
+  set Maximum particles per cell = 16384
+  set Update ghost particles = true
+  set Particle generator name = reference cell
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = eta_b=1e3, rmax=0.2
+    set Function expression = if((x-1.0)*(x-1.0)+(z-1.0)*(z-1.0)<=0.04,eta_b,1.0)
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 4
+    end
+  end
+end
diff --git a/benchmarks/inclusion/doc/inclusion.prm.bak b/benchmarks/inclusion/doc/inclusion.prm.bak
new file mode 100644
index 00000000000..d9a6f297152
--- /dev/null
+++ b/benchmarks/inclusion/doc/inclusion.prm.bak
@@ -0,0 +1,62 @@
+############### Global parameters
+
+set Additional shared libraries            = ./libinclusion.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
+                                                right : InclusionBoundary, \
+                                                bottom: InclusionBoundary, \
+                                                top   : InclusionBoundary
+end
+
+subsection Material model
+  set Model name = InclusionMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 6
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = InclusionPostprocessor, visualization
+end
diff --git a/benchmarks/inclusion/global.prm.base.bak b/benchmarks/inclusion/global.prm.base.bak
new file mode 100644
index 00000000000..176659deda1
--- /dev/null
+++ b/benchmarks/inclusion/global.prm.base.bak
@@ -0,0 +1,63 @@
+############### Global parameters
+
+set Additional shared libraries            = ./libinclusion.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
+                                                right : InclusionBoundary, \
+                                                bottom: InclusionBoundary, \
+                                                top   : InclusionBoundary
+end
+
+subsection Material model
+  set Model name = InclusionMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = InclusionPostprocessor, visualization
+end
diff --git a/benchmarks/inclusion/inclusion.cc.bak b/benchmarks/inclusion/inclusion.cc.bak
new file mode 100644
index 00000000000..d8ac9d6b466
--- /dev/null
+++ b/benchmarks/inclusion/inclusion.cc.bak
@@ -0,0 +1,50 @@
+/*
+  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include "inclusion.h"
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(InclusionMaterial,
+                                   "InclusionMaterial",
+                                   "A material model that corresponds to the 'Inclusion' benchmark "
+                                   "defined in Duretz et al., G-Cubed, 2011.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(InclusionBoundary,
+                                            "InclusionBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "``inclusion'' benchmark. See the manual and the Kronbichler, Heister "
+                                            "and Bangerth paper on ASPECT for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(InclusionPostprocessor,
+                                  "InclusionPostprocessor",
+                                  "A postprocessor that compares the solution of the benchmarks from "
+                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
+                                  "and reports the error. Specifically, it can compute the errors for "
+                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
+                                  "which material model is currently being used and adjusts "
+                                  "which exact solution to use accordingly.")
+  }
+}
diff --git a/benchmarks/inclusion/inclusion.h.bak b/benchmarks/inclusion/inclusion.h.bak
new file mode 100644
index 00000000000..9c9a0bb8ed9
--- /dev/null
+++ b/benchmarks/inclusion/inclusion.h.bak
@@ -0,0 +1,356 @@
+#ifndef ASPECT_INCLUSION_H
+#define ASPECT_INCLUSION_H
+
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+
+namespace aspect
+{
+  /**
+   * This is the "Pure shear/Inclusion" benchmark defined in the following paper:
+   * @code
+   *  @Article{DMGT11,
+   *    author =       {T. Duretz and D. A. May and T. V. Gerya and P. J. Tackley},
+   *    title =        {Discretization errors and free surface stabilization in the
+   *                  finite difference and marker-in-cell method for applied
+   *                  geodynamics: {A} numerical study},
+   *    journal =      {Geochemistry Geophysics Geosystems},
+   *    year =         2011,
+   *    volume =       12,
+   *    pages =        {Q07004/1--26}}
+   * @endcode
+   *
+   * The results are published in Kronbichler, Heister and Bangerth paper.
+   */
+  namespace InclusionBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+      // based on http://geodynamics.org/hg/cs/AMR/Discontinuous_Stokes with permission
+      void _Inclusion(double pos[2], double r_inclusion, double eta, double *vx, double *vy, double *p)
+      {
+        const double min_eta = 1.0;
+        const double max_eta = eta;
+        const double epsilon = 1; //strain rate
+        const double A(min_eta*(max_eta-min_eta)/(max_eta+min_eta));
+        std::complex<double> phi, psi, dphi;
+        const double offset[2]= {1.0, 1.0};
+        double r2_inclusion = r_inclusion * r_inclusion;
+
+        double x = pos[0]-offset[0];
+        double y = pos[1]-offset[1];
+        double r2 = x*x+y*y;
+
+        std::complex<double> z(x,y);
+        if (r2<r2_inclusion)
+          {
+            //inside the inclusion
+            phi=0;
+            dphi=0;
+            psi=-4*epsilon*(max_eta*min_eta/(min_eta+max_eta))*z;
+          }
+        else
+          {
+            //outside the inclusion
+            phi=-2*epsilon*A*r2_inclusion/z;
+            dphi=-phi/z;
+            psi=-2*epsilon*(min_eta*z+A*r2_inclusion*r2_inclusion/(z*z*z));
+          }
+        double visc = (r2<r2_inclusion)? max_eta : 1.0;
+        std::complex<double> v = (phi - z*conj(dphi) - conj(psi))/(2.0*visc);
+        *vx=v.real();
+        *vy=v.imag();
+        *p=-2*epsilon*dphi.real();
+      }
+
+
+
+      /**
+       * The exact solution for the Inclusion benchmark.
+       */
+      template <int dim>
+      class FunctionInclusion : public Function<dim>
+      {
+        public:
+          FunctionInclusion (double eta_B,
+                             const unsigned int n_compositional_fields)
+            : Function<dim>(dim+2+n_compositional_fields), eta_B_(eta_B) {}
+
+          void vector_value (const Point<dim>   &p,
+                             Vector<double>   &values) const override
+          {
+            double pos[2]= {p(0),p(1)};
+            AnalyticSolutions::_Inclusion
+            (pos,0.2,eta_B_, &values[0], &values[1], &values[2]);
+          }
+
+        private:
+          double eta_B_;
+      };
+    }
+
+
+
+    template <int dim>
+    class InclusionBoundary : public BoundaryVelocity::Interface<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        InclusionBoundary() : eta_B(1e3) {}
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id ,
+                           const Point<dim> &position) const override
+        {
+          Assert (dim == 2, ExcNotImplemented());
+
+          double pos[2]= {position(0),position(1)};
+
+          Tensor<1,dim> velocity;
+          double pressure;
+          AnalyticSolutions::_Inclusion
+          (pos,0.2,eta_B, &velocity[0], &velocity[1], &pressure);
+
+          return velocity;
+        };
+
+      private:
+        double eta_B;
+    };
+
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class InclusionMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> &pos = in.position[i];
+              double r2 = (pos[0]-1.0)*(pos[0]-1.0) + (pos[1]-1.0)*(pos[1]-1.0);
+
+              out.viscosities[i] = (r2<0.2*0.2)? eta_B : 1.0;
+
+              out.densities[i] = 0;
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+              out.entropy_derivative_pressure[i] = 0.0;
+              out.entropy_derivative_temperature[i] = 0.0;
+            }
+        }
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override
+        {
+          return false;
+        }
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm)
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("Inclusion");
+            {
+              prm.declare_entry ("Viscosity jump", "1e3",
+                                 Patterns::Double (0.),
+                                 "Viscosity in the Inclusion.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("Inclusion");
+            {
+              eta_B = prm.get_double ("Viscosity jump");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          // Declare dependencies on solution variables
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+
+
+        /**
+         * Returns the viscosity value in the inclusion
+         */
+        double get_eta_B() const
+        {
+          return eta_B;
+        }
+
+      private:
+        /**
+         * viscosity value in the inclusion
+         */
+        double eta_B;
+    };
+
+
+
+    /**
+     * A postprocessor that evaluates the accuracy of the solution.
+     *
+     * The implementation of error evaluators that correspond to the
+     * benchmarks defined in the paper Duretz et al. reference above.
+     */
+    template <int dim>
+    class InclusionPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &/*statistics*/) override
+        {
+          AssertThrow(Plugins::plugin_type_matches<const InclusionMaterial<dim>>(this->get_material_model()),
+                      ExcMessage("Postprocessor only works with the inclusion material model."));
+
+          const InclusionMaterial<dim> &
+          material_model
+            = Plugins::get_plugin_as_type<const InclusionMaterial<dim>>(this->get_material_model());
+
+          std::unique_ptr<Function<dim>> ref_func
+            = std::make_unique<AnalyticSolutions::FunctionInclusion<dim>>(
+                material_model.get_eta_B(),
+                this->n_compositional_fields());
+
+          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+          Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                              this->get_fe().n_components());
+          ComponentSelectFunction<dim> comp_p(dim,
+                                              this->get_fe().n_components());
+
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_u,
+                                             quadrature_formula,
+                                             VectorTools::L1_norm,
+                                             &comp_u);
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_p,
+                                             quadrature_formula,
+                                             VectorTools::L1_norm,
+                                             &comp_p);
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_ul2,
+                                             quadrature_formula,
+                                             VectorTools::L2_norm,
+                                             &comp_u);
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_pl2,
+                                             quadrature_formula,
+                                             VectorTools::L2_norm,
+                                             &comp_p);
+
+          const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+          const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+          // Compute stokes unknowns, do not include temperature
+          types::global_dof_index n_stokes_dofs = this->introspection().system_dofs_per_block[this->introspection().block_indices.velocities];
+          if (this->introspection().block_indices.velocities != this->introspection().block_indices.pressure)
+            n_stokes_dofs  += this->introspection().system_dofs_per_block[this->introspection().block_indices.pressure];
+
+          std::ostringstream os;
+          os << n_stokes_dofs << "; "
+             << std::scientific << u_l1
+             << ", " << p_l1
+             << ", " << u_l2
+             << ", " << p_l2;
+
+          return std::make_pair("DoFs; Errors u_L1, p_L1, u_L2, p_L2:", os.str());
+        }
+    };
+  }
+}
+#endif
diff --git a/benchmarks/infill_density/infill_ascii.prm b/benchmarks/infill_density/infill_ascii.prm
index dbed3116c5c..aad1f865492 100644
--- a/benchmarks/infill_density/infill_ascii.prm
+++ b/benchmarks/infill_density/infill_ascii.prm
@@ -72,9 +72,9 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
     set Global composition maximum =  1.e13,  1.e13,  1.e13, 1.0
     set Global composition minimum = -1.e13, -1.e13, -1.e13, 0.0
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/benchmarks/infill_density/infill_ascii.prm.bak b/benchmarks/infill_density/infill_ascii.prm.bak
new file mode 100644
index 00000000000..dbed3116c5c
--- /dev/null
+++ b/benchmarks/infill_density/infill_ascii.prm.bak
@@ -0,0 +1,217 @@
+# This model demonstrates ASPECT's ability to be used to
+# model load induced flexure from a topographic feature
+# on top of the lithosphere. The model uses the viscoelastic
+# material model and is composed of an 'elastic' high viscosity
+# lithosphere and a low viscosity mantle beneath the elastic
+# lithosphere. A time dependent axisymmetric box load is applied
+# to the top boundary using ASCII files, with the center of the load
+# at the left boundary of the 2D cartesian model domain. The model
+# is run for 120'000 years, which is equivalent to 40*tm:
+# tm = eta_m / mu
+# eta_m = mantle viscosity
+# mu = elastic shear modulus
+# tm is the time scale of viscous stress relaxation for the mantle.
+# This allows for virtually all stresses in the mantle to be relaxed
+# and for the elastic lithosphere to be fully compensating the load.
+# The analytic solution for this setup is outlined in the Generic
+# Mapping Tools function grdflexure:
+# <https://docs.generic-mapping-tools.org/6.1/supplements/potential/grdflexure.html>
+
+#  Global parameters
+set Additional shared libraries            = ./libinfill_density.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 120e3
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set CFL number                             = 0.1
+set Maximum time step                      = 750
+set Output directory                       = output
+set Pressure normalization                 = no
+
+# Model geometry (1200x1200 km, 80 km spacing in x direction, 40km spacing in y direction)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 30
+    set X extent      = 1200e3
+    set Y extent      = 1200e3
+  end
+end
+
+# Mesh refinement specifications
+# Refine the mesh in the uppermost part of the model
+# to better capture lithospheric response to the load.
+# (10x5km mesh in the lithosphere)
+subsection Mesh refinement
+  set Initial adaptive refinement              = 2
+  set Initial global refinement                = 1
+  set Time steps between mesh refinement       = 1
+  set Minimum refinement level                 = 0
+  set Strategy                                 = minimum refinement function, strain rate
+
+  subsection Minimum refinement function
+    set Coordinate system                      = cartesian
+    set Variable names                         = x,y,t
+    set Function expression                    = if(y>=1050e3, 3, 0)
+  end
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree           = 2
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 1
+  set Use locally conservative discretization = true
+  set Use discontinuous temperature discretization = false
+
+  # Discontinuous (DG) elements are used for compositional fields to more accurately track
+  # the lithosphere-asthenosphere boundary.
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+    set Global composition maximum =  1.e13,  1.e13,  1.e13, 1.0
+    set Global composition minimum = -1.e13, -1.e13, -1.e13, 0.0
+  end
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+  set Additional tangential mesh velocity boundary indicators = left, right
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+end
+
+# Velocity boundary conditions
+# The left boundary is set to free slip to allow the lithosphere
+# to vertically deform along this boundary and act as mirror plane
+# for the other 'half' of the load.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left
+end
+
+# Prescribe a fixed vertical traction on the top boundary
+# The right boundary is open in order to allow outflow of the
+# mantle as lithospheric flexure pushes the mantle to the right.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = top y: infill ascii data, right: initial lithostatic pressure
+
+  subsection Infill ascii data
+    set Rock density = 2000
+    set Sediment density = 2000
+    set Height for specifying rock infill = 0
+
+    subsection Ascii data model
+      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/infill_density/data/
+      set First data file model time = 0
+      set Data file name = box_2d_%s.%d.txt
+      set Data file time step = 750
+    end
+  end
+
+  subsection Initial lithostatic pressure
+    set Representative point = 1200e3, 0
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, lithosphere
+end
+
+#Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; if(y>=1125e3, 1, 0)
+  end
+end
+
+#Composition boundary conditions
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# Temperature initial conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 3300
+
+    # The first valueis assigned to the mantle and the next three are assigned to the compositional
+    # fields representing viscoelastic stresses, but significantly these values are not used in the
+    # viscosity calculation (i.e., only values representing lithologies are used). Respectively, the
+    # fourth and fifth values are assigned to the compositional fields representing the lithosphere.
+    set Viscosities                 = 1.e21, 1.e21, 1.e21, 1.e21, 1.e26
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = true
+    set Fixed elastic time step     = 7500
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, temperature statistics, topography, velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate, shear stress, boundary indicators
+    set Number of grouped files = 1
+    set Time between graphical output = 7500
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = viscosity
+    end
+  end
+
+  subsection Topography
+    set Output to file = true
+    set Time between text output = 7500
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/benchmarks/infill_density/infill_ascii_data.cc.bak b/benchmarks/infill_density/infill_ascii_data.cc.bak
new file mode 100644
index 00000000000..92c66e10a1d
--- /dev/null
+++ b/benchmarks/infill_density/infill_ascii_data.cc.bak
@@ -0,0 +1,267 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_traction/ascii_data.h>
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements prescribed traction boundary conditions determined
+     * from pressures given in an AsciiData input file.
+     *
+     * @ingroup BoundaryTractions
+     */
+    template <int dim>
+    class InfillAsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        InfillAsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataBoundary<dim>::initialize;
+
+        /**
+         * Return the boundary traction as a function of position. The
+         * (outward) normal vector to the domain is also provided as
+         * a second argument.
+         */
+        Tensor<1,dim>
+        boundary_traction (const types::boundary_id surface_boundary_id,
+                           const Point<dim> &position,
+                           const Tensor<1,dim> &normal_vector) const override;
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the boundary values will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        types::boundary_id surface_boundary_id;
+        double rock_density;
+        double sediment_density;
+        double crustal_density;
+        double rock_infill_height;
+    };
+
+    template <int dim>
+    InfillAsciiData<dim>::InfillAsciiData ()
+      :
+      surface_boundary_id(numbers::invalid_unsigned_int)
+    {}
+
+
+    template <int dim>
+    void
+    InfillAsciiData<dim>::initialize ()
+    {
+      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+      std::set<types::boundary_id> surface_boundary_set;
+      surface_boundary_set.insert(surface_boundary_id);
+
+      // The input ascii table contains one data column (Traction [Pa]) due to
+      // the load in addition to the coordinate columns.
+      Utilities::AsciiDataBoundary<dim>::initialize(surface_boundary_set,
+                                                    1);
+    }
+
+
+    template <int dim>
+    Tensor<1,dim>
+    InfillAsciiData<dim>::
+    boundary_traction (const types::boundary_id surface_boundary_id,
+                       const Point<dim> &position,
+                       const Tensor<1,dim> &normal_vector) const
+    {
+      const double load = Utilities::AsciiDataBoundary<dim>::get_data_component(surface_boundary_id,
+                                                                                position,
+                                                                                0);
+      Tensor<1, dim> traction = normal_vector;
+      const double gravity_norm = this->get_gravity_model().gravity_vector(position).norm();
+      const double elevation = this->get_geometry_model().height_above_reference_surface(position);
+
+      // Check if the load at the current point has a height which exceeds the
+      // 'rock_infill height'. The assumption is that the values taken from the
+      // ASCII file are specifying the part of the load that is above the undeformed
+      // reference surface. If we consider a seamount as the load, the ASCII
+      // file takes the bathymetry of the seamount and provides it as a traction.
+      // However, the volcanic rock comprising the seamount also fills in the
+      // flexural moat, providing an additional traction. Since it is much harder to
+      // specify this traction, 'rock_infill_height' determines where the rock_density
+      // that the seamount is made of will infill the flexural moat, and where
+      // sediment_density will infill the flexural moat. For this test, this
+      // variable is not that important given the idealized load, but this is useful
+      // when using more complicated bathymetry maps where small scale seafloor
+      // features makes it unrealistic to set rock_infill_height=0.
+      if (load >= rock_infill_height*gravity_norm*rock_density)
+        {
+          traction = (-load + elevation*gravity_norm*rock_density) * normal_vector;
+        }
+      else
+        {
+          traction = (-load + elevation*gravity_norm*sediment_density) * normal_vector;
+        }
+      return traction;
+    }
+
+
+    template <int dim>
+    void
+    InfillAsciiData<dim>::update()
+    {
+      Interface<dim>::update ();
+      Utilities::AsciiDataBoundary<dim>::update();
+    }
+
+
+    template <int dim>
+    void
+    InfillAsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary traction model");
+      {
+        // Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
+        //                                                       "$ASPECT_SOURCE_DIR/tests/infill_density/",
+        //                                                       "box_2d_%s.%d.txt");
+        prm.enter_subsection("Infill ascii data");
+        {
+          Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
+                                                                "$ASPECT_SOURCE_DIR/tests/infill_density/",
+                                                                "box_2d_%s.%d.txt");
+          prm.declare_entry ("Rock density", "2800",
+                             Patterns::Double(0.),
+                             "Density of the volcanic edifice that infills the flexural moat.");
+          prm.declare_entry ("Sediment density", "2300",
+                             Patterns::Double(0.),
+                             "Density of the sediment that infills the flexural moat.");
+          prm.declare_entry ("Height for specifying rock infill", "500",
+                             Patterns::Double(0.),
+                             "If the load defined in the ASCII file has a height equal to or greater than "
+                             "the Height for specifying rock infill, then the infill material will be rock, "
+                             "otherwise it will be sediment");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    InfillAsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary traction model");
+      {
+        // Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
+        prm.enter_subsection("Infill ascii data");
+        {
+          Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
+          rock_density = prm.get_double("Rock density");
+          sediment_density = prm.get_double("Sediment density");
+          rock_infill_height = prm.get_double("Height for specifying rock infill");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(InfillAsciiData,
+                                            "infill ascii data",
+                                            "Implementation of a model in which the boundary "
+                                            "traction is derived from files containing pressure data "
+                                            "in ascii format. This model differs from the normal ascii data "
+                                            "model as the pressure given in the data file is summed with another "
+                                            "traction that depends on the current state of flexure in the model. "
+                                            "The traction sum is applied normal to the surface of a given boundary, "
+                                            "pointing inwards. Note the required format of the "
+                                            "input data: The first lines may contain any number of comments "
+                                            "if they begin with `#', but one of these lines needs to "
+                                            "contain the number of grid points in each dimension as "
+                                            "for example `# POINTS: 3 3'. "
+                                            "The order of the data columns "
+                                            "has to be `x', `Pressure [Pa]' in a 2d model and "
+                                            " `x', `y', `Pressure [Pa]' in a 3d model, which means that "
+                                            "there has to be a single column "
+                                            "containing the pressure. "
+                                            "Note that the data in the input "
+                                            "files need to be sorted in a specific order: "
+                                            "the first coordinate needs to ascend first, "
+                                            "followed by the second in order to "
+                                            "assign the correct data to the prescribed coordinates. "
+                                            "If you use a spherical model, "
+                                            "then the data will still be handled as Cartesian, "
+                                            "however the assumed grid changes. `x' will be replaced by "
+                                            "the radial distance of the point to the bottom of the model, "
+                                            "`y' by the azimuth angle and `z' by the polar angle measured "
+                                            "positive from the north pole. The grid will be assumed to be "
+                                            "a latitude-longitude grid. Note that the order "
+                                            "of spherical coordinates is `r', `phi', `theta' "
+                                            "and not `r', `theta', `phi', since this allows "
+                                            "for dimension independent expressions.")
+  }
+}
diff --git a/benchmarks/king2dcompressible/ala.prm.bak b/benchmarks/king2dcompressible/ala.prm.bak
new file mode 100644
index 00000000000..0bb0a4f018a
--- /dev/null
+++ b/benchmarks/king2dcompressible/ala.prm.bak
@@ -0,0 +1,184 @@
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# We can use a large CFL number because we are only interested in the
+# steady state solution.
+set CFL number = 5.0
+set Additional shared libraries            = ./plugin/libking.so
+
+# This is the non-dimensionalized surface temperature, which is the
+# ratio of the dimensional surface temperature T_surf = 273 K and
+# the temperature change across the domain DeltaT = 3000 K.
+set Adiabatic surface temperature          = 0.091
+set Use years in output instead of seconds = false
+set End time                               = 10
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Discretization
+  subsection Stabilization parameters
+    set alpha                                              = 2
+    set beta                                               = 0.005
+    set cR                                                 = 0.033
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria = end time, steady state velocity
+
+  subsection Steady state velocity
+    set Maximum relative deviation = 1e-7
+    set Time in steady state       = 1
+  end
+end
+
+# In this section we define the adiabatic profiles of temperature,
+# pressure and density. The temperature and density profiles are
+# equivalent to the reference profiles bar(T) and bar(rho) defined
+# in the King 2010 benchmark.
+# gamma is the grueneisen parameter, which defines the compressibility
+# of the material, and we have to choose the same value for gamma as
+# in the material model below.
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=1.0, gamma=1.0
+    set Function expression = 0.091*exp(depth*Di); gamma/Di*(exp(depth*Di/gamma)-1); exp(depth*Di/gamma)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+# The King benchmark uses the anelastic liquid approximation.
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
+
+# The benchmark is defined in terms of the nondimensional numbers
+# Di (dissipation number) and Ra (Rayleigh number).
+# As ASPECT uses physical properties instead of these dimensionless
+# numbers in its equations, we replicate the benchmark formulation
+# by using a new material model that fixes all of the material
+# constants to 1, except for the thermal expansivity, which is set
+# to Di, and the viscosity, which is set to Di/Ra.
+subsection Material model
+  set Model name = king material
+
+  subsection King model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+
+    # The value of the Rayleigh number Ra.
+    set Ra                            = 1e4
+
+    # The dissipation number Di determines the slope of the
+    # adiabatic/reference temperature profile.
+    # For the Boussinesq approximation, Di would be zero.
+    set Di                            = 1.0
+    set b                             = 0
+    set c                             = 0
+    set gamma                         = 1.0
+  end
+end
+
+# The model domain is the unit square.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# We choose a linear initial temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression =  1* ((1.0-z/L) + p*cos(k*pi*x/L/1.0)*sin(pi*z/L)) +0.091
+  end
+end
+
+# We prescibe the adiabatic surface temperature as top temperature
+# and the (nondimensional) temperature change across the boundary
+# is set to 1 (with no flux conditions at the sides).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Top temperature    = 0.091
+    set Bottom temperature = 1.091
+    set Left temperature   = 0
+    set Right temperature  = 0
+  end
+end
+
+# The velocity boundary conditions are free slip on all boundaries.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+# This subsection describes which heating models we want to use.
+# This benchmark includes adiabatic heating and shear heating.
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    # A flag indicating whether the adiabatic heating should be simplified
+    # from $\alpha T (\mathbf u \cdot \nabla p)$
+    # to $ \alpha \rho T (\mathbf u \cdot \mathbf g) $.
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+# As we are only interested in the steady state, we start on a
+# coarse mesh and refine once the solution is close to steady state.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 1.0
+end
+
+# In addition to some general postprocessing, we output
+# velocity statistics (needed for the root mean square velocity),
+# temperature statistics (needed for the average temperature),
+# heat flux statistics using the CBF method (needed for the Nusselt number) and
+# heating statistics (needed for shear and adiabatic heating).
+# We also include a simpler heat flux statistics postprocessor
+# that illustrates the superiority of the CBF method in the default
+# heat flux statistics postprocessor.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heat flux statistics gradient, visualization, depth average, heating statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e-2
+    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
+  end
+end
+
+# We would like the benchmark to converge to very high accuracy,
+# so we tighten the linear solver tolerance compared to default of 1e-7.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-9
+  end
+end
diff --git a/benchmarks/king2dcompressible/plugin/code.cc.bak b/benchmarks/king2dcompressible/plugin/code.cc.bak
new file mode 100644
index 00000000000..f0099ccc8ad
--- /dev/null
+++ b/benchmarks/king2dcompressible/plugin/code.cc.bak
@@ -0,0 +1,250 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/global.h>
+
+#include <aspect/material_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  /**
+   * This benchmark is from the article
+   * @code
+   * @article{KLKLZTTK10,
+   *   title={A community benchmark for 2-{D} {C}artesian compressible
+   *          convection in the {E}arth's mantle},
+   *   author={King, Scott D and Lee, Changyeol and Van Keken, Peter E
+   *           and Leng, Wei and Zhong, Shijie and Tan, Eh and Tosi, Nicola
+   *           and Kameyama, Masanori C},
+   *   journal={Geophysical Journal International},
+   *   volume={180},
+   *   number={1},
+   *   pages={73--87},
+   *   year={2010},
+   *   publisher={Oxford University Press}
+   * }
+   * @endcode
+   */
+
+
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    class Material : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+        * Evaluate material properties.
+        */
+        void evaluate(const MaterialModelInputs<dim> &in,
+                      MaterialModelOutputs<dim> &out) const override
+        {
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> position = in.position[i];
+              const double temperature = in.temperature[i];
+              const double pressure = in.pressure[i];
+
+              const double depth = 1.0-position(dim-1);
+
+              out.viscosities[i] = ((Di==0.0)?1.0:Di)/Ra*exp(-b*(temperature- this->get_adiabatic_conditions().temperature(position))+c*depth);
+
+              out.specific_heat[i] = reference_specific_heat;
+              out.thermal_conductivities[i] = 1.0;
+              out.thermal_expansion_coefficients[i] = (Di==0.0)?1.0:Di;
+
+              double rho = reference_rho * exp(depth * Di/gamma);
+              rho *= 1.0 - out.thermal_expansion_coefficients[i] * (temperature - this->get_adiabatic_conditions().temperature(position))
+                     + (tala?0.0:1.0)*Di*gamma
+                     *  (pressure - this->get_adiabatic_conditions().pressure(position));
+
+              out.densities[i] = rho;
+
+              out.compressibilities[i] = 0.0;
+              out.entropy_derivative_pressure[i] = 0.0;
+              out.entropy_derivative_temperature[i] = 0.0;
+              // Change in composition due to chemical reactions at the
+              // given positions. The term reaction_terms[i][c] is the
+              // change in compositional field c at point i.
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                out.reaction_terms[i][c] = 0.0;
+            }
+        }
+
+        bool is_compressible () const override
+        {
+          return true;
+        }
+
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+
+        /**
+         * @}
+         */
+
+      private:
+
+        bool tala;
+
+        /**
+         * Parameters describing temperature and depth-dependence
+         * of viscosity.
+         */
+        double b, c;
+
+        /**
+         * The surface density.
+         */
+        double reference_rho;
+
+        /**
+         * The nondimensional numbers (Dissipation number,
+         * Rayleigh number, grueneisen parameter).
+         */
+        double Di, Ra, gamma;
+
+        /**
+         * The constant specific heat
+         */
+        double reference_specific_heat;
+    };
+
+
+
+    template <int dim>
+    void
+    Material<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("King model");
+        {
+          prm.declare_entry ("Reference density", "3300",
+                             Patterns::Double (0),
+                             "Reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Ra", "1e4",
+                             Patterns::Double (0),
+                             "");
+          prm.declare_entry ("Di", "0.0",
+                             Patterns::Double (0),
+                             "");
+          prm.declare_entry ("gamma", "1.0",
+                             Patterns::Double (0),
+                             "");
+          prm.declare_entry ("Reference specific heat", "1250",
+                             Patterns::Double (0),
+                             "The value of the specific heat $cp$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("b", "6.907755279",
+                             Patterns::Double (0),
+                             "");
+          prm.declare_entry ("c", "0",
+                             Patterns::Double (0),
+                             "");
+          prm.declare_entry ("Use TALA", "false",
+                             Patterns::Bool (),
+                             "Whether to use the TALA instead of the ALA "
+                             "approximation.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Material<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("King model");
+        {
+          reference_rho   = prm.get_double ("Reference density");
+          b               = prm.get_double ("b");
+          c               = prm.get_double ("c");
+          Di              = prm.get_double ("Di");
+          Ra              = prm.get_double ("Ra");
+          gamma           = prm.get_double ("gamma");
+
+          tala            = prm.get_bool ("Use TALA");
+
+          reference_specific_heat = prm.get_double ("Reference specific heat");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature;
+      this->model_dependence.density = NonlinearDependence::none;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+    }
+  }
+
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Material,
+                                   "king material",
+                                   "A simple compressible material model based on a benchmark "
+                                   "from the paper of King et al. (2010). It uses the "
+                                   "nondimensional numbers Di, Ra and gamma to define material "
+                                   "properties.")
+  }
+
+}
diff --git a/benchmarks/layeredflow/layeredflow.cc.bak b/benchmarks/layeredflow/layeredflow.cc.bak
new file mode 100644
index 00000000000..2f1c3bc6fac
--- /dev/null
+++ b/benchmarks/layeredflow/layeredflow.cc.bak
@@ -0,0 +1,404 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  namespace LayeredFlowBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+
+      Tensor<1,2>
+      LayeredFlow_velocity (const Point<2> &pos,
+                            const double beta,
+                            const double epsilon)
+      {
+        const double y0 = 1./3.;
+        const double yplus=(1.+y0)/beta;
+        const double yminus=(1.-y0)/beta;
+        const double C1 = 2.*numbers::PI /
+                          ( beta*std::log(beta*beta+pow(1.+y0,2.0))-2.*(1.+y0)*std::atan(yplus)
+                            - beta*std::log(beta*beta+pow(1.-y0,2.0))+2.*(1.-y0)*std::atan(yminus)
+                            + 2.*numbers::PI*(1.+2.*epsilon) );
+
+        const double C2 = ( beta*std::log( beta*beta+std::pow(1+y0,2.) )- 2.*(1.+y0)*std::atan(yplus)
+                            + numbers::PI*(1.+2.*epsilon) )*C1 ;
+        const double y = pos[1]-1.0;
+        const double v_x = (-beta*C1*std::log(beta*beta+std::pow(y-y0,2.0))+2.*(y-y0)*C1*std::atan((y-y0)/beta)
+                            + numbers::PI*(1.+2.*epsilon)*y*C1+C2)/(2.*numbers::PI);
+        const double v_y = 0;
+        return Point<2> (v_x,v_y);
+      }
+
+      double
+      LayeredFlow_pressure (const Point<2> &,
+                            const double &,
+                            const double)
+      {
+        return 0;
+      }
+
+
+      template <int dim>
+      class FunctionLayeredFlow : public Function<dim>
+      {
+        public:
+          FunctionLayeredFlow (const double beta, const double epsilon)
+            :
+            Function<dim>(dim+2),
+            beta_(beta),
+            epsilon_(epsilon)
+          {}
+
+          void vector_value (const Point<dim>   &pos,
+                             Vector<double>   &values) const override
+          {
+            Assert (dim == 2, ExcNotImplemented());
+            Assert (values.size() >= 4, ExcInternalError());
+
+            const Point<2> p (pos[0], pos[1]);
+
+            const Tensor<1,2> v = AnalyticSolutions::LayeredFlow_velocity (p, beta_, epsilon_);
+            values[0] = v[0];
+            values[1] = v[1];
+            values[2] = AnalyticSolutions::LayeredFlow_pressure (p, beta_, epsilon_);
+          }
+
+        private:
+          const double beta_;
+          const double epsilon_;
+      };
+    }
+
+
+    template <int dim>
+    class LayeredFlowBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        LayeredFlowBoundary();
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id ,
+                           const Point<dim> &position) const override;
+
+      private:
+        const double beta;
+        const double epsilon;
+    };
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class LayeredFlowMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> &pos = in.position[i];
+
+              const double y = pos[1]-1.0;
+              const double y0 = 1./3.;
+              out.viscosities[i] = 1.0/(std::atan((y-y0)/beta)/numbers::PI + 0.5 + epsilon);
+              out.densities[i] = 1;
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+
+        /**
+         * Returns the viscosity value in the inclusion
+         */
+        double get_beta() const;
+        double get_epsilon() const;
+
+        /**
+         * viscosity value in the inclusion
+         */
+        double beta;
+        double epsilon;
+    };
+
+
+    template <int dim>
+    bool
+    LayeredFlowMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    LayeredFlowMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      //create a global section in the parameter file for parameters
+      //that describe this benchmark. note that we declare them here
+      //in the material model, but other kinds of plugins (e.g., the gravity
+      //model below) may also read these parameters even though they do not
+      //declare them
+      prm.enter_subsection("LayeredFlow benchmark");
+      {
+        prm.declare_entry("Viscosity parameter beta", "1",
+                          Patterns::Double (),
+                          "Viscosity parameter beta in the LayeredFlow benchmark.");
+        prm.declare_entry("Viscosity parameter epsilon", "0.1",
+                          Patterns::Double (),
+                          "Viscosity parameter epsilon in the LayeredFlow benchmark.");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    LayeredFlowMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("LayeredFlow benchmark");
+      {
+        beta = prm.get_double ("Viscosity parameter beta");
+        epsilon = prm.get_double ("Viscosity parameter epsilon");
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+
+    template <int dim>
+    double
+    LayeredFlowMaterial<dim>::get_beta() const
+    {
+      return beta;
+    }
+
+    template <int dim>
+    double
+    LayeredFlowMaterial<dim>::get_epsilon() const
+    {
+      return epsilon;
+    }
+
+    template <int dim>
+    LayeredFlowBoundary<dim>::LayeredFlowBoundary ()
+      :
+      beta (0),
+      epsilon (0)
+    {}
+
+
+
+    template <>
+    Tensor<1,2>
+    LayeredFlowBoundary<2>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<2> &p) const
+    {
+      const LayeredFlowMaterial<2> &
+      material_model
+        = Plugins::get_plugin_as_type<const LayeredFlowMaterial<2>>(this->get_material_model());
+
+      return AnalyticSolutions::LayeredFlow_velocity (p, material_model.get_beta(),
+                                                      material_model.get_epsilon());
+    }
+
+
+
+    template <>
+    Tensor<1,3>
+    LayeredFlowBoundary<3>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<3> &) const
+    {
+      Assert (false, ExcNotImplemented());
+      return Tensor<1,3>();
+    }
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the manual.
+      */
+    template <int dim>
+    class LayeredFlowPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    LayeredFlowPostprocessor<dim>::execute (TableHandler &)
+    {
+      std::unique_ptr<Function<dim>> ref_func;
+      {
+        const LayeredFlowMaterial<dim> &
+        material_model
+          = Plugins::get_plugin_as_type<const LayeredFlowMaterial<dim>>(this->get_material_model());
+
+        ref_func = std::make_unique<AnalyticSolutions::FunctionLayeredFlow<dim>>(material_model.get_beta(),
+                                                                                  material_model.get_epsilon());
+      }
+
+      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                          dim+2);
+      ComponentSelectFunction<dim> comp_p(dim, dim+2);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_ul2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_pl2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+      std::ostringstream os;
+      os << std::scientific <<  u_l2
+         << ", " << p_l2;
+
+      return std::make_pair("Errors u_L2, p_L2:", os.str());
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace LayeredFlowBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(LayeredFlowMaterial,
+                                   "LayeredFlowMaterial",
+                                   "A material model that corresponds to the `LayeredFlow' benchmark. "
+                                   "See the manual for more information.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(LayeredFlowBoundary,
+                                            "LayeredFlowBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "`LayeredFlow' benchmark. See the manual for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(LayeredFlowPostprocessor,
+                                  "LayeredFlowPostprocessor",
+                                  "A postprocessor that compares the solution of the `LayeredFlow' benchmark "
+                                  "with the one computed by ASPECT "
+                                  "and reports the error. See the manual for more information.")
+  }
+}
diff --git a/benchmarks/layeredflow/layeredflow.prm.bak b/benchmarks/layeredflow/layeredflow.prm.bak
new file mode 100644
index 00000000000..b0152284960
--- /dev/null
+++ b/benchmarks/layeredflow/layeredflow.prm.bak
@@ -0,0 +1,94 @@
+############### Global parameters
+
+set Additional shared libraries            = ./liblayeredflow.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0  : LayeredFlowBoundary, \
+                                                1  : LayeredFlowBoundary, \
+                                                2  : LayeredFlowBoundary, \
+                                                3  : LayeredFlowBoundary
+end
+
+subsection Material model
+  set Model name = LayeredFlowMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection LayeredFlow benchmark
+  set Viscosity parameter beta = 0.001
+  set Viscosity parameter epsilon = 0.05
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, LayeredFlowPostprocessor
+
+  subsection Visualization
+    set List of output variables = viscosity, strain rate
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm.bak
new file mode 100644
index 00000000000..ca7b64af468
--- /dev/null
+++ b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm.bak
@@ -0,0 +1,134 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Output directory = results/b1SNL_BTt_NS_ST1e-20_UFSfalse_NSP-SPD_NSA-SPD_C0_g6_ag0_AEWfalse_UDStrue_SF9e-1_NLT1e-14_ABT1e-2_LT1e-5_mLT9e-1_I150_P5_EW1_theta1_LS0_RSMtrue_AV-1_phi0_vel0_BV1e19_n5
+set Dimension = 2
+set CFL number                             = 1.0
+set Maximum time step                      = 1
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = iterated Advection and Newton Stokes
+set Max nonlinear iterations = 150
+set Nonlinear solver tolerance = 1e-14
+set Additional shared libraries = libsimple_nonlinear.so
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-5
+  end
+
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 5
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 0
+    set Maximum linear Stokes solver tolerance = 9e-1
+    set Use Newton residual scaling method = true
+    set Use Newton failsafe = false
+    set Stabilization preconditioner = SPD
+    set Stabilization velocity block = SPD
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10e3
+    set Y extent = 8e3
+    set Y repetitions = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple nonlinear
+
+  subsection Simple nonlinear
+    set Minimum viscosity = 1e19
+    set Maximum viscosity = 1e25
+    set Stress exponent = 5
+    set Viscosity averaging p = 10000
+    set Viscosity prefactor = 1e-37
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 2 y: function, 3 y: function # pressure bc: Prescribe a horizontal traction on the vertical boundaries
+
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 0;if(z>0,0,1e9)
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1
+  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
+
+  subsection Function
+    set Function constants = n = 5
+    set Variable names = x,z
+
+    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
+    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
+
+  subsection Depth average
+    set List of output variables = viscosity
+  end
+
+  subsection Visualization
+    set List of output variables = material properties,strain rate, spd factor
+
+    #    set Output format = gnuplot
+    set Time between graphical output = 2
+  end
+end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t_gmg.prm.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t_gmg.prm.bak
new file mode 100644
index 00000000000..9350829516d
--- /dev/null
+++ b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t_gmg.prm.bak
@@ -0,0 +1,21 @@
+# Like the newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
+# benchmark, but use GMG instead.
+
+include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
+
+set Additional shared libraries = libsimple_nonlinear.so
+set Output directory = results/output-t-gmg
+
+subsection Material model
+  set Material averaging = harmonic average
+end
+
+subsection Solver parameters
+  subsection Matrix Free
+    set Output details = true
+  end
+
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm
index 37534cc3107..7b80ff14209 100644
--- a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm
+++ b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm
@@ -2,7 +2,7 @@
 # flow benchmark. This is used to test the velocity boundary conditions
 # of the Newton Stokes solver.
 
-set Output directory = a2_itIMPES_ST1e-20_UFSfalse_NSP-SPD_NSA-none_C0_g6_ag0_AEWfalse_SF9e-1_NLT1e-14_ABT1e-2_LT1e-5_mLT9e-1_I150_P3_EW1_theta1_LS5_RSMfalse_AV-1_n5
+set Output directory = a2_itsingle Advection, single Stokes_ST1e-20_UFSfalse_NSP-SPD_NSA-none_C0_g6_ag0_AEWfalse_SF9e-1_NLT1e-14_ABT1e-2_LT1e-5_mLT9e-1_I150_P3_EW1_theta1_LS5_RSMfalse_AV-1_n5
 set Dimension = 2
 set CFL number                             = 1.0
 set Maximum time step                      = 1
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm.bak
new file mode 100644
index 00000000000..37534cc3107
--- /dev/null
+++ b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm.bak
@@ -0,0 +1,133 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Output directory = a2_itIMPES_ST1e-20_UFSfalse_NSP-SPD_NSA-none_C0_g6_ag0_AEWfalse_SF9e-1_NLT1e-14_ABT1e-2_LT1e-5_mLT9e-1_I150_P3_EW1_theta1_LS5_RSMfalse_AV-1_n5
+set Dimension = 2
+set CFL number                             = 1.0
+set Maximum time step                      = 1
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = iterated Advection and Stokes #Newton Stokes
+set Max nonlinear iterations = 150
+set Nonlinear solver tolerance = 1e-14
+set Additional shared libraries = libsimple_nonlinear.so
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-15
+  end
+
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 3
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 5
+    set Maximum linear Stokes solver tolerance = 9e-1
+    set Use Newton residual scaling method = false
+    set Use Newton failsafe = false
+    set Stabilization preconditioner = SPD
+    set Stabilization velocity block = none
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10e3
+    set Y extent = 8e3
+    set Y repetitions = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple nonlinear
+
+  subsection Simple nonlinear
+    set Minimum viscosity = 1e19
+    set Maximum viscosity = 1e24
+    set Stress exponent = 5
+    set Viscosity averaging p = 10000
+    set Viscosity prefactor = 1e-37
+    set Use deviator of strain-rate = false
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1
+  set Prescribed velocity boundary indicators = 2: function, 3: function # velocity bc
+
+  subsection Function
+    set Function constants = n = 5
+    set Variable names = x,z
+
+    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
+    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-(abs(x-(5e3))^(n+1)));
+  end
+end
+
+subsection Boundary traction model
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 0;if(z>0,0,1e9)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
+
+  subsection Depth average
+    set List of output variables = viscosity
+  end
+
+  subsection Visualization
+    set List of output variables = material properties,strain rate#, spd factor
+
+    #    set Output format = gnuplot
+    set Time between graphical output = 2
+  end
+end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v_gmg.prm.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v_gmg.prm.bak
new file mode 100644
index 00000000000..de4a4b69a82
--- /dev/null
+++ b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v_gmg.prm.bak
@@ -0,0 +1,21 @@
+# Like the newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm
+# benchmark, but use GMG instead.
+
+include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm
+
+set Additional shared libraries = libsimple_nonlinear.so
+set Output directory = results/output-v-gmg
+
+subsection Material model
+  set Material averaging = harmonic average
+end
+
+subsection Solver parameters
+  subsection Matrix Free
+    set Output details = true
+  end
+
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc.bak
new file mode 100644
index 00000000000..8f72dd39357
--- /dev/null
+++ b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc.bak
@@ -0,0 +1,404 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/newton.h>
+
+#include <iostream>
+
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model based on a simple power law rheology and
+     * implementing the derivatives needed for the Newton method.
+     *
+     * Power law equation to compute the viscosity $\eta$ per composition:
+     * $\eta = A^{\frac{-1}{n}} * \left(2.0 * \dot\varepsilon_{II}\right)
+     * ^{\frac{1}{n}-1}$ where $A$ is the prefactor, $\dot\varepsion$ is
+     * the strain-rate, II indicates the square root of the second invariant
+     * defined as $\frac{1}{2} \dot\varepsilon_{ij} \dot\varepsilon_{ij}$,
+     * and $n$ is the stress exponent.
+     *
+     * The viscosities per composition are averaged using the
+     * utilities weighted p-norm function. The volume fractions are used
+     * as weights for the averaging.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class SimpleNonlinear : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * This material model is incompressible.
+         */
+        bool is_compressible () const override;
+
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * For calculating density by thermal expansivity. Units: $\\si{\\kelvin}$
+         */
+        double reference_temperature;
+
+        /**
+         * Defining a minimum strain rate stabilizes the viscosity calculation,
+         * which involves a division by the strain rate. Units: $\\si{\\per\\second}$.
+         */
+        std::vector<double> min_strain_rate;
+        std::vector<double> min_viscosity;
+        std::vector<double> max_viscosity;
+
+        std::vector<double> thermal_diffusivity;
+        std::vector<double> heat_capacity;
+
+
+        std::vector<double> densities;
+        std::vector<double> thermal_expansivities;
+
+
+        std::vector<double> viscosity_prefactor;
+        std::vector<double> stress_exponent;
+
+        unsigned int n_fields;
+        /**
+         * averaging parameters used for the power exponent
+         * in the Utilities::weighted_p_norm_average and
+         * Utilities::derivative_of_weighted_p_norm_average.
+         */
+        double viscosity_averaging_p;
+
+        bool use_deviator_of_strain_rate;
+    };
+  }
+}
+
+
+
+using namespace dealii;
+
+namespace aspect
+{
+
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    SimpleNonlinear<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      //set up additional output for the derivatives
+      MaterialModelDerivatives<dim> *derivatives = out.template get_additional_output<MaterialModelDerivatives<dim>>();
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double temperature = in.temperature[i];
+
+          // Averaging composition-field dependent properties
+          // Compositions
+          //This assert may be help when designing tests for this material model
+          AssertThrow(in.composition[i].size()+1 == n_fields,
+                      ExcMessage("Number of compositional fields + 1 not equal to number of fields given in input file."));
+
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
+          double density = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            {
+              //not strictly correct if thermal expansivities are different, since we are interpreting
+              //these compositions as volume fractions, but the error introduced should not be too bad.
+              const double temperature_factor = (1.0 - thermal_expansivities[c] * (temperature - reference_temperature));
+              density += volume_fractions[c] * densities[c] * temperature_factor;
+            }
+
+          // thermal expansivities
+          double thermal_expansivity = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            thermal_expansivity += volume_fractions[c] * thermal_expansivities[c];
+
+          // Specific heat at the given positions.
+          double specific_heat = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            specific_heat += volume_fractions[c] * heat_capacity[c];
+
+          // Thermal conductivity at the given positions.
+          double thermal_conductivities = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            thermal_conductivities += volume_fractions[c] * thermal_diffusivity[c] * heat_capacity[c] * densities[c];
+
+          // calculate effective viscosity
+          if (in.requests_property(MaterialProperties::viscosity))
+            {
+              // This function calculates viscosities assuming that all the compositional fields
+              // experience the same strain rate (isostrain). Since there is only one process in
+              // this material model (a general powerlaw) we do not need to worry about how to
+              // distribute the strain-rate and stress over the processes.
+              std::vector<double> composition_viscosities(volume_fractions.size());
+
+              std::vector<SymmetricTensor<2,dim>> composition_viscosities_derivatives(volume_fractions.size());
+
+              for (unsigned int c=0; c < volume_fractions.size(); ++c)
+                {
+                  // If strain rate is zero (like during the first time step) set it to some very small number
+                  // to prevent a division-by-zero, and a floating point exception.
+                  // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
+                  // strain rate (often simplified as epsilondot_ii)
+                  const SymmetricTensor<2,dim> edot = use_deviator_of_strain_rate ? deviator(in.strain_rate[i]) : in.strain_rate[i];
+                  const double edot_ii_strict = std::sqrt(0.5*edot*edot);
+                  const double edot_ii = 2.0 * std::max(edot_ii_strict, min_strain_rate[c]);
+
+                  const double stress_exponent_inv = 1/stress_exponent[c];
+                  composition_viscosities[c] = std::max(std::min(std::pow(viscosity_prefactor[c],-stress_exponent_inv) * std::pow(edot_ii,stress_exponent_inv-1), max_viscosity[c]), min_viscosity[c]);
+                  Assert(dealii::numbers::is_finite(composition_viscosities[c]), ExcMessage ("Error: Viscosity is not finite."));
+                  if (derivatives != nullptr)
+                    {
+                      if (edot_ii_strict > min_strain_rate[c] && composition_viscosities[c] < max_viscosity[c] && composition_viscosities[c] > min_viscosity[c])
+                        {
+                          composition_viscosities_derivatives[c] = (stress_exponent_inv-1) * composition_viscosities[c] * (1.0/(edot*edot)) * edot;
+
+                          if (use_deviator_of_strain_rate == true)
+                            composition_viscosities_derivatives[c] = composition_viscosities_derivatives[c] * deviator_tensor<dim>();
+                        }
+                      else
+                        {
+                          composition_viscosities_derivatives[c] = 0;
+                        }
+                    }
+                }
+
+              out.viscosities[i] = Utilities::weighted_p_norm_average(volume_fractions, composition_viscosities, viscosity_averaging_p);
+              Assert(dealii::numbers::is_finite(out.viscosities[i]), ExcMessage ("Error: Averaged viscosity is not finite."));
+
+              if (derivatives != nullptr)
+                {
+                  derivatives->viscosity_derivative_wrt_strain_rate[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_viscosities_derivatives, viscosity_averaging_p);
+
+                  for (unsigned int x = 0; x < dim; x++)
+                    for (unsigned int y = 0; y < dim; y++)
+                      Assert (dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]),
+                              ExcMessage ("Averaged viscosity to strain-rate devrivative is not finite."));
+
+                  derivatives->viscosity_derivative_wrt_pressure[i]  = 0;
+
+                }
+            }
+          out.densities[i] = density;
+          out.thermal_expansion_coefficients[i] = thermal_expansivity;
+          // Specific heat at the given positions.
+          out.specific_heat[i] = specific_heat;
+          // Thermal conductivity at the given positions.
+          out.thermal_conductivities[i] = thermal_conductivities;
+          // Compressibility at the given positions.
+          // The compressibility is given as
+          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
+          out.compressibilities[i] = 0.0;
+          // Pressure derivative of entropy at the given positions.
+          out.entropy_derivative_pressure[i] = 0.0;
+          // Temperature derivative of entropy at the given positions.
+          out.entropy_derivative_temperature[i] = 0.0;
+          // Change in composition due to chemical reactions at the
+          // given positions. The term reaction_terms[i][c] is the
+          // change in compositional field c at point i.
+          for (unsigned int c=0; c < in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+    template <int dim>
+    bool
+    SimpleNonlinear<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    SimpleNonlinear<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Compositional fields");
+      {
+        prm.declare_entry ("Number of fields", "0",
+                           Patterns::Integer (0),
+                           "The number of fields that will be advected along with the flow field, excluding "
+                           "velocity, pressure and temperature.");
+      }
+      prm.leave_subsection();
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Simple nonlinear");
+        {
+          // Reference and minimum/maximum values
+          prm.declare_entry ("Reference temperature", "293.", Patterns::Double(0.),
+                             "For calculating density by thermal expansivity. Units: \\si{\\kelvin}");
+          prm.declare_entry ("Minimum strain rate", "1.96e-40", Patterns::List(Patterns::Double(0.)),
+                             "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}");
+          prm.declare_entry ("Minimum viscosity", "1e10", Patterns::List(Patterns::Double(0.)),
+                             "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Maximum viscosity", "1e28", Patterns::List(Patterns::Double(0.)),
+                             "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Effective viscosity coefficient", "1.0", Patterns::List(Patterns::Double(0.)),
+                             "Scaling coefficient for effective viscosity.");
+
+          // Equation of state parameters
+          prm.declare_entry ("Thermal diffusivity", "0.8e-6", Patterns::List(Patterns::Double(0.)),
+                             "Units: \\si{\\meter\\squared\\per\\second}");
+          prm.declare_entry ("Heat capacity", "1.25e3", Patterns::List(Patterns::Double(0.)),
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}");
+          prm.declare_entry ("Densities", "3300.",
+                             Patterns::List(Patterns::Double(0.)),
+                             "List of densities, $\\rho$, for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "If only one value is given, then all use the same value. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}");
+          prm.declare_entry ("Thermal expansivities", "3.5e-5",
+                             Patterns::List(Patterns::Double(0.)),
+                             "List of thermal expansivities for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}");
+
+
+          // SimpleNonlinear creep parameters
+          prm.declare_entry ("Viscosity prefactor", "1e-37",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of viscosity prefactors, $A$, for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "If only one value is given, then all use the same value. "
+                             "Units: \\si{\\pascal}$^{-n_{\\text{dislocation}}}$ \\si{\\meter}$^{n_{\\text{dislocation}}/m_{\\text{dislocation}}}$ \\si{\\per\\second}");
+          prm.declare_entry ("Stress exponent", "3.",
+                             Patterns::List(Patterns::Double(0.)),
+                             "List of stress exponents, $n_dislocation$, for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "If only one value is given, then all use the same value.  Units: None");
+
+          // averaging parameters
+          prm.declare_entry ("Viscosity averaging p", "-1.",
+                             Patterns::Double(),
+                             "This is the p value in the generalized weighed average equation: "
+                             " $\\text{mean} = \\frac{1}{k}(\\sum_{i=1}^k \\big(c_i \\eta_{\\text{eff}_i}^p)\\big)^{\\frac{1}{p}}$. "
+                             " Units: \\si{\\pascal\\second}");
+
+          // strain-rate deviator parameter
+          prm.declare_entry ("Use deviator of strain-rate", "true",
+                             Patterns::Bool(),
+                             "This value determines whether to use the deviator of the strain-rate in computing the viscosity, "
+                             "or simply the strain rate $\\varepsilon(\\mathbf u)$.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    SimpleNonlinear<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // Can't use this->n_compositional_fields(), because some
+      // tests never initialize the simulator, but uses the material
+      // model directly.
+      prm.enter_subsection ("Compositional fields");
+      {
+        n_fields = prm.get_integer ("Number of fields")+1;
+      }
+      prm.leave_subsection();
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Simple nonlinear");
+        {
+
+          // Reference and minimum/maximum values
+          reference_temperature = prm.get_double("Reference temperature");
+          min_strain_rate =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Minimum strain rate"))),n_fields,"Minimum strain rate");
+          min_viscosity =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get ("Minimum viscosity"))),n_fields,"Minimum viscosity");
+          max_viscosity =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get ("Maximum viscosity"))),n_fields,"Maximum viscosity");
+
+          // Equation of state parameters
+          thermal_diffusivity =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal diffusivity"))),n_fields,"Thermal diffusivity");
+          heat_capacity =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Heat capacity"))),n_fields,"Heat capacity");
+
+          // Compositional parameters
+          densities =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Densities"))),n_fields,"Densities");
+          thermal_expansivities =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal expansivities"))),n_fields,"Thermal expansivities");
+
+          // Rheological parameters
+          viscosity_prefactor =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Viscosity prefactor"))),n_fields,"Viscosity prefactor");
+          stress_exponent =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Stress exponent"))),n_fields,"Stress exponent");
+
+          // averaging parameters
+          viscosity_averaging_p = prm.get_double("Viscosity averaging p");
+
+          use_deviator_of_strain_rate = prm.get_bool ("Use deviator of strain-rate");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SimpleNonlinear,
+                                   "simple nonlinear",
+                                   "A material model based on a simple power law rheology and implementing the derivatives "
+                                   "needed for the Newton method. "
+                                   "Power law equation to compute the viscosity $\\eta$ per composition comes from the book Introduction "
+                                   "to Geodynamic Modelling by Taras Gerya (2010): "
+                                   "$\\eta = A^{\\frac{-1}{n}} * \\left(2.0 * \\dot\\varepsilon_{II}\\right)^{\\frac{1}{n}-1}$ "
+                                   "where $A$ is the prefactor, $\\dot\\varepsion$ is the strain-rate, II indicates the square "
+                                   "root of the second invariant defined as $\\frac{1}{2} \\dot\\varepsilon_{ij} \\dot\\varepsilon_{ij}$, "
+                                   "and $n$ is the stress exponent. "
+                                   "The viscosities per composition are averaged using the utilities weighted "
+                                   "p-norm function. The volume fractions are used as weights for the averaging. ")
+  }
+}
diff --git a/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/drucker_prager_compositions.cc.bak b/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/drucker_prager_compositions.cc.bak
new file mode 100644
index 00000000000..e1a213fc455
--- /dev/null
+++ b/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/drucker_prager_compositions.cc.bak
@@ -0,0 +1,671 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+/**
+ * This material model is specifically designed for the
+ * Spiegelman benchmark as reproduced in the Fraters (2019)
+ * paper on Newton solvers. It is not meant to be used for
+ * general purpose models. For more details see that paper.
+ */
+
+#ifndef __aspect__model_drucker_prager_compositions_h
+#define __aspect__model_drucker_prager_compositions_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/newton.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * The same material model as Drucker Prager, but this one supports multiple
+     * compositions. Designed to run the Spiegelman et al. 2016 benchmark.
+     *
+     * The model is considered incompressible, following the definition
+     * described in Interface::is_compressible.
+     *
+     * The viscosity is computed according to the Drucker Prager frictional
+     * plasticity criterion based on a user-defined internal angle of friction $\phi$
+     * and cohesion $C$. In 3D:
+     * $\sigma_y = \frac{6 C \cos(\phi)}{\sqrt(3) (3+\sin(\phi))} +
+     * \frac{6 P \sin(\phi)}{\sqrt(3) (3+\sin(\phi))}$,
+     * where $P$ is the pressure.
+     * See for example Zienkiewicz, O. C., Humpheson, C. and Lewis, R. W. (1975),
+     * Géotechnique 25, No. 4, 671-689.
+     * With this formulation we circumscribe instead of inscribe the Mohr Coulomb
+     * yield surface.
+     * In 2D the Drucker Prager yield surface is the same
+     * as the Mohr Coulomb surface:
+     * $\sigma_y = P \sin(\phi) + C \cos(\phi)$.
+     * Note that in 2D for $\phi=0$, these criteria
+     * revert to the von Mises criterion (no pressure dependence).
+     * See for example Thieulot, C. (2011), PEPI 188, 47-68.
+     *
+     * Note that we enforce the pressure to be positive in the computation of
+     * the yield strength by replacing it with
+     * a zero value whenever it is negative to prevent negative
+     * yield strengths and viscosities.
+     * We then use the computed yield strength to scale back the viscosity on
+     * to the yield surface using the Viscosity Rescaling Method described in
+     * Kachanov, L. M. (2004), Fundamentals of the Theory of Plasticity,
+     * Dover Publications, Inc.
+     *
+     * To avoid numerically unfavourably large (or even negative) viscosity ranges,
+     * we cut off the viscosity with a user-defined minimum and maximum viscosity:
+     * $\eta_eff = \max(\min(eta,max_visc),min_visc)$.
+     *
+     * Note that this model uses the formulation that assumes an incompressible
+     * medium despite the fact that the density follows the law
+     * $\rho(T)=\rho_0(1-\beta(T-T_{\text{ref}}))$.
+     *
+     *
+     * @ingroup MaterialModels
+     */
+
+    template <int dim>
+    class DruckerPragerCompositions : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        double compute_second_invariant(const SymmetricTensor<2,dim> strain_rate, const double min_strain_rate) const;
+
+        double compute_viscosity(const double edot_ii,const double pressure,const int comp, const double prefactor,const bool regularize, const double min_visc, const double max_visc) const;
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+        *
+        * This material model is incompressible.
+         */
+        bool is_compressible () const override;
+
+        double reference_density () const;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        double reference_T;
+        std::vector<double> reference_T_list;
+
+        /**
+         * Defining a minimum strain rate stabilizes the viscosity calculation,
+         * which involves a division by the strain rate. Units: $\\si{\\per\\second}$.
+         */
+        bool use_deviator_of_strain_rate;
+        std::vector<double> min_strain_rate;
+        std::vector<double> min_visc;
+        std::vector<double> max_visc;
+        std::vector<double> veff_coefficient;
+        double ref_visc;
+        double reference_compressibility;
+        std::vector<double> ref_visc_list;
+
+        std::vector<double> thermal_diffusivity;
+        std::vector<double> heat_capacity;
+
+
+        std::vector<double> densities;
+        std::vector<double> thermal_expansivities;
+
+        std::vector<double> cohesion;
+        std::vector<double> phi;
+
+        std::vector<double> prefactor;
+        std::vector<double> stress_exponent;
+
+        unsigned int n_fields;
+        // averaging parameters
+        double viscosity_averaging_p;
+
+        bool use_analytical_derivative;
+
+        //optimize variables
+        const double sqrt_3 = std::sqrt(3);
+        const double sqrt_half = std::sqrt(0.5);
+        std::vector<double> sin_phi;
+        std::vector<double> cos_phi;
+
+
+
+    };
+
+  }
+}
+
+#endif
+
+#include <aspect/utilities.h>
+#include <aspect/parameters.h>
+
+using namespace dealii;
+
+namespace aspect
+{
+  namespace
+  {
+    std::vector<double>
+    get_vector_double (const std::string &parameter, const unsigned int n_fields, ParameterHandler &prm)
+    {
+      std::vector<double> parameter_list;
+      parameter_list = Utilities::string_to_double(Utilities::split_string_list(prm.get (parameter)));
+      if (parameter_list.size() == 1)
+        parameter_list.resize(n_fields, parameter_list[0]);
+
+      AssertThrow(parameter_list.size() == n_fields,
+                  ExcMessage("Length of " + parameter + " list (size "+ std::to_string(parameter_list.size()) +") must be either one,"
+                             " or n_compositional_fields+1 (= " + std::to_string(n_fields) + ")."));
+
+      return parameter_list;
+    }
+  }
+
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    double
+    DruckerPragerCompositions<dim>::
+    compute_second_invariant(const SymmetricTensor<2,dim> strain_rate, const double min_strain_rate) const
+    {
+      const double edot_ii_strict = std::sqrt(strain_rate*strain_rate);
+      const double edot_ii = std::max(edot_ii_strict, min_strain_rate*min_strain_rate);
+      return edot_ii;
+    }
+
+    template <int dim>
+    double
+    DruckerPragerCompositions<dim>::
+    compute_viscosity(const double edot_ii,const double pressure,const int comp,const double prefactor,const bool regularize, const double min_visc, const double max_visc) const
+    {
+      double viscosity;
+      if (comp == 0)
+        {
+          const double strength = ( (dim==3)
+                                    ?
+                                    ( 6.0 * cohesion[comp] * cos_phi[comp] + 6.0 * std::max(pressure,0.0) * sin_phi[comp] )
+                                    / ( sqrt_3 * ( 3.0 + sin_phi[comp] ) )
+                                    :
+                                    cohesion[comp] * cos_phi[comp] + std::max(pressure,0.0) * sin_phi[comp] );
+
+          // Rescale the viscosity back onto the yield surface
+          if (strength != 0 && edot_ii != 0)
+            viscosity = strength / ( 2.0 * sqrt_half * edot_ii );
+          else
+            viscosity = ref_visc;
+          if (regularize == true)
+            viscosity = ref_visc*viscosity / (ref_visc + viscosity);
+        }
+      else
+        {
+          viscosity = prefactor;
+        }
+
+      return std::max(std::min(viscosity,max_visc),min_visc);
+    }
+
+    template <int dim>
+    void
+    DruckerPragerCompositions<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      //set up additional output for the derivatives
+      MaterialModelDerivatives<dim> *derivatives;
+      derivatives = out.template get_additional_output<MaterialModelDerivatives<dim>>();
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double temperature = in.temperature[i];
+          const double pressure = in.pressure[i];
+
+          // Averaging composition-field dependent properties
+          // Compositions
+          //This assert may be help when designing tests for this material model
+          AssertThrow(in.composition[i].size()+1 == n_fields,
+                      ExcMessage("Number of compositional fields + 1 not equal to number of fields given in input file."));
+
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
+          double density = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            {
+              const double temperature_factor = (1 - thermal_expansivities[c] * (temperature - reference_T));
+              density += volume_fractions[c] * densities[c] * std::exp(reference_compressibility * pressure) * temperature_factor;
+            }
+
+          // thermal expansivities
+          double thermal_expansivity = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            thermal_expansivity += volume_fractions[c] * thermal_expansivities[c];
+
+          // Specific heat at the given positions.
+          double specific_heat = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            specific_heat += volume_fractions[c] * heat_capacity[c];
+
+          // Thermal conductivity at the given positions.
+          double thermal_conductivities = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            thermal_conductivities += volume_fractions[c] * thermal_diffusivity[c] * heat_capacity[c] * densities[c];
+
+          // calculate effective viscosity
+          if (in.requests_property(MaterialProperties::viscosity))
+            {
+              // This function calculates viscosities assuming that all the compositional fields
+              // experience the same strain rate (isostrain). Since there is only one process in
+              // this material model (a general powerlaw) we do not need to worry about how to
+              // distribute the strain-rate and stress over the processes.
+              std::vector<double> composition_viscosities(volume_fractions.size());
+              std::vector<SymmetricTensor<2,dim>> composition_viscosities_derivatives(volume_fractions.size());
+              std::vector<double> composition_dviscosities_dpressure(volume_fractions.size());
+
+              const SymmetricTensor<2,dim> deviator_strain_rate = use_deviator_of_strain_rate ? deviator(in.strain_rate[i]) : in.strain_rate[i];
+
+              for (unsigned int c=0; c < volume_fractions.size(); ++c)
+                {
+                  // If strain rate is zero (like during the first time step) set it to some very small number
+                  // to prevent a division-by-zero, and a floating point exception.
+                  // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
+                  // strain rate (often simplified as epsilondot_ii)
+
+                  const double edot_ii = compute_second_invariant(deviator_strain_rate, min_strain_rate[c]);
+
+                  // Find effective viscosities for each of the individual phases
+                  // Viscosities should have same number of entries as compositional fields
+
+                  // Regularized Drucker Prager viscosity (see Spiegelman et al, 2016)
+                  composition_viscosities[c] = compute_viscosity(edot_ii,pressure,c,prefactor[c],true,min_visc[c],max_visc[c]);
+
+                  Assert(dealii::numbers::is_finite(composition_viscosities[c]),ExcMessage ("Error: Viscosity is not finite."));
+
+                  if (derivatives != nullptr)
+                    {
+                      if (use_analytical_derivative)
+                        {
+                          //analytic
+                          if (c == 0  && composition_viscosities[c] <= max_visc[c] && composition_viscosities[c] >= min_visc[c])
+                            {
+                              const double drucker_prager_viscosity = compute_viscosity(edot_ii,pressure,c,prefactor[c],false,min_visc[c],max_visc[c]);
+                              const double regulaization_adjustment = (ref_visc * ref_visc)
+                                                                      / (ref_visc * ref_visc + 2.0 * ref_visc * drucker_prager_viscosity
+                                                                         + drucker_prager_viscosity * drucker_prager_viscosity);
+
+                              composition_viscosities_derivatives[c] = -regulaization_adjustment *
+                                                                       (drucker_prager_viscosity / (edot_ii * edot_ii)) * deviator_strain_rate;
+
+                              if (use_deviator_of_strain_rate == true)
+                                composition_viscosities_derivatives[c]*deviator_tensor<dim>();
+
+                              composition_dviscosities_dpressure[c] = regulaization_adjustment *
+                                                                      ((dim == 3)
+                                                                       ?
+                                                                       6 * sin_phi[c] / (sqrt_3 * (3.0 + sin_phi[c]) * 2.0 * sqrt_half * edot_ii)
+                                                                       :
+                                                                       sin_phi[c] / (2.0 * sqrt_half * edot_ii));
+                            }
+                          else
+                            {
+                              composition_viscosities_derivatives[c] = 0;
+                              composition_dviscosities_dpressure[c] = 0;
+                            }
+                        }
+                      else
+                        {
+                          // finite difference
+                          const double finite_difference_accuracy = 1e-7;
+                          // For each independent component, compute the derivative.
+                          for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
+                            {
+                              // compute which of the independent index of the strain-rate tensor we are now looking at.
+                              const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
+
+                              // add a small difference to one independent component of the strain-rate tensor
+                              const SymmetricTensor<2,dim> strain_rate_difference_plus = deviator_strain_rate + std::max(edot_ii, min_strain_rate[c]*min_strain_rate[c]) * finite_difference_accuracy
+                                                                                         * Utilities::nth_basis_for_symmetric_tensors<dim>(component);
+                              const double second_invariant_strain_rate_difference_plus = compute_second_invariant(strain_rate_difference_plus, min_strain_rate[c]);
+                              const double eta_component_plus = compute_viscosity(second_invariant_strain_rate_difference_plus,pressure,c,prefactor[c],true,min_visc[c],max_visc[c]);
+
+                              // compute the difference between the viscosity with and without the strain-rate difference.
+                              double viscosity_derivative = eta_component_plus - composition_viscosities[c];
+                              if (viscosity_derivative != 0)
+                                {
+                                  // when the difference is non-zero, divide by the difference.
+                                  viscosity_derivative /= std::max(edot_ii, min_strain_rate[c]*min_strain_rate[c]) * finite_difference_accuracy;
+                                }
+
+                              composition_viscosities_derivatives[c][strain_rate_indices] = viscosity_derivative;
+                            }
+
+                          /**
+                           * Now compute the finite difference derivative of the viscoisty to the pressure
+                           */
+                          double pressure_difference = in.pressure[i] + (std::fabs(in.pressure[i]) * finite_difference_accuracy);
+
+                          double pressure_difference_eta = compute_viscosity(edot_ii, pressure_difference,c,prefactor[c],true,min_visc[c],max_visc[c]);
+                          double deriv_pressure = pressure_difference_eta - composition_viscosities[c];
+
+
+                          if (pressure_difference_eta != 0)
+                            {
+                              if (in.pressure[i] != 0)
+                                {
+                                  deriv_pressure /= std::fabs(in.pressure[i]) * finite_difference_accuracy;
+                                }
+                              else
+                                {
+                                  deriv_pressure = 0;
+                                }
+                            }
+
+                          composition_dviscosities_dpressure[c] = deriv_pressure;
+                        }
+                    }
+                }
+              out.viscosities[i] = Utilities::weighted_p_norm_average(volume_fractions, composition_viscosities, viscosity_averaging_p);
+              Assert(dealii::numbers::is_finite(out.viscosities[i]),ExcMessage ("Error: Averaged viscosity is not finite."));
+
+              if (derivatives != nullptr)
+                {
+                  derivatives->viscosity_derivative_wrt_strain_rate[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_viscosities_derivatives, viscosity_averaging_p);
+                  derivatives->viscosity_derivative_wrt_pressure[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_dviscosities_dpressure, viscosity_averaging_p);
+
+
+#ifdef DEBUG
+                  for (int x = 0; x < dim; x++)
+                    for (int y = 0; y < dim; y++)
+                      if (!dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]))
+                        std::cout << "Error: Averaged viscosity to strain-rate devrivative is not finite." << std::endl;
+
+                  if (!dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_pressure[i]))
+                    {
+                      std::cout << "Error: Averaged viscosity to pressure devrivative is not finite. " << std::endl;
+                      for (unsigned int c=0; c < volume_fractions.size(); ++c)
+                        std::cout << composition_dviscosities_dpressure[c] << ',';
+                      std::cout << std::endl;
+                    }
+                  Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_pressure[i]),ExcMessage ("Error: Averaged dviscosities_dpressure is not finite."));
+                  for (int x = 0; x < dim; x++)
+                    for (int y = 0; y < dim; y++)
+                      Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]),ExcMessage ("Error: Averaged dviscosities_dstrain_rate is not finite."));
+#endif
+                }
+            }
+          out.densities[i] = density;
+          out.thermal_expansion_coefficients[i] = thermal_expansivity;
+          // Specific heat at the given positions.
+          out.specific_heat[i] = specific_heat;
+          // Thermal conductivity at the given positions.
+          out.thermal_conductivities[i] = thermal_conductivities;
+          // Compressibility at the given positions.
+          // The compressibility is given as
+          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
+          out.compressibilities[i] = reference_compressibility;
+          // Pressure derivative of entropy at the given positions.
+          out.entropy_derivative_pressure[i] = 0.0;
+          // Temperature derivative of entropy at the given positions.
+          out.entropy_derivative_temperature[i] = 0.0;
+          // Change in composition due to chemical reactions at the
+          // given positions. The term reaction_terms[i][c] is the
+          // change in compositional field c at point i.
+          for (unsigned int c=0; c < in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+    template <int dim>
+    double
+    DruckerPragerCompositions<dim>::
+    reference_density () const
+    {
+      return densities[0];
+    }
+
+    template <int dim>
+    bool
+    DruckerPragerCompositions<dim>::
+    is_compressible () const
+    {
+      return (reference_compressibility != 0);
+    }
+
+    template <int dim>
+    void
+    DruckerPragerCompositions<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Compositional fields");
+      {
+        prm.declare_entry ("Number of fields", "0",
+                           Patterns::Integer(0),
+                           "The number of fields that will be advected along with the flow field, excluding "
+                           "velocity, pressure and temperature.");
+        prm.declare_entry ("Conductivities", "2.25",
+                           Patterns::List (Patterns::Double(0.)),
+                           "A list of thermal conductivities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("Heat capacities", "1250.",
+                           Patterns::List (Patterns::Double(0.)),
+                           "A list of heat capacities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("Reference temperatures", "0.",
+                           Patterns::List (Patterns::Double(0.)),
+                           "A list of reference temperatures equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("Reference densities", "2700.",
+                           Patterns::List (Patterns::Double(0.)),
+                           "A list of reference densities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("Thermal expansivities", "3.5e-5",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of thermal expansivities for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of compositional fields. "
+                           "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}");
+        prm.declare_entry ("Stress exponents", "1.",
+                           Patterns::List (Patterns::Double(0.)),
+                           "A list of stress exponents equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("Cohesions", "1e20",
+                           Patterns::List (Patterns::Double(0.)),
+                           "A list of initial viscosities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("Angles of internal friction", "30.",
+                           Patterns::List (Patterns::Double(0.)),
+                           "A list of initial viscosities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("Initial viscosities", "1e21",
+                           Patterns::List (Patterns::Double(0.)),
+                           "A list of initial viscosities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("Viscous prefactors", "1e21",
+                           Patterns::List (Patterns::Double(0.)),
+                           "A list of viscous viscosities equal to the number of "
+                           "compositional fields.");
+
+      }
+      prm.leave_subsection();
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Drucker prager compositions");
+        {
+          // Reference and minimum/maximum values
+          prm.declare_entry ("Reference temperature", "293.", Patterns::Double(0.),
+                             "For calculating density by thermal expansivity. Units: \\si{\\kelvin}");
+          prm.declare_entry ("Minimum strain rate", "1.4e-20", Patterns::List(Patterns::Double(0.)),
+                             "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}");
+          prm.declare_entry ("Minimum viscosity", "1e10", Patterns::List(Patterns::Double(0.)),
+                             "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Maximum viscosity", "1e28", Patterns::List(Patterns::Double(0.)),
+                             "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Effective viscosity coefficient", "1.0", Patterns::List(Patterns::Double(0.)),
+                             "Scaling coefficient for effective viscosity.");
+          prm.declare_entry ("Reference viscosity", "1e22", Patterns::List(Patterns::Double(0.)),
+                             "Reference viscosity for nondimensionalization. Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Reference compressibility", "4e-12", Patterns::Double(0.),
+                             "The value of the reference compressibility. Units: \\si{\\per\\pascal}.");
+
+          // averaging parameters
+          prm.declare_entry ("Viscosity averaging p", "-1",
+                             Patterns::Double(),
+                             "This is the p value in the generalized weighed average eqation: "
+                             " mean = \\frac{1}{k}(\\sum_{i=1}^k \\big(c_i \\eta_{\\text{eff}_i}^p)\\big)^{\\frac{1}{p}}. "
+                             " Units: \\si{\\pascal\\second}");
+
+          // finite difference versus analytical
+          prm.declare_entry ("Use analytical derivative", "false",
+                             Patterns::Bool(),
+                             "A bool indicating whether to use finite differences to compute the derivative or to use "
+                             "the analytical derivative.");
+
+          prm.declare_entry ("Use deviator of strain-rate", "true",
+                             Patterns::Bool(),
+                             "Todo.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    DruckerPragerCompositions<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // can't use this->n_compositional_fields(), because some
+      // tests never initiate the simulator, but uses the material
+      // model directly.
+      prm.enter_subsection ("Compositional fields");
+      {
+        n_fields = prm.get_integer ("Number of fields")+1;
+        //AssertThrow(n_fields > 0, ExcMessage("This material model needs at least one compositional field."))
+        reference_T_list = get_vector_double("Reference temperatures",n_fields,prm);
+        ref_visc_list = get_vector_double ("Initial viscosities",n_fields,prm);
+        thermal_diffusivity = get_vector_double("Conductivities",n_fields,prm);
+        heat_capacity = get_vector_double("Heat capacities",n_fields,prm);
+
+        // ---- Compositional parameters
+        densities = get_vector_double("Reference densities",n_fields,prm);
+        thermal_expansivities = get_vector_double("Thermal expansivities",n_fields,prm);
+
+        // Rheological parameters
+        cohesion = get_vector_double("Cohesions",n_fields,prm);
+        phi = get_vector_double("Angles of internal friction",n_fields,prm);
+
+        sin_phi.resize(n_fields);
+        cos_phi.resize(n_fields);
+        for (unsigned int c = 0; c < n_fields; ++c)
+          {
+            sin_phi[c] = std::sin(phi[c] * constants::degree_to_radians);
+            cos_phi[c] = std::cos(phi[c] * constants::degree_to_radians);
+          }
+
+        prefactor = get_vector_double("Viscous prefactors",n_fields,prm);
+        stress_exponent = get_vector_double("Stress exponents",n_fields,prm);
+      }
+      prm.leave_subsection();
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Drucker prager compositions");
+        {
+
+          // Reference and minimum/maximum values
+          reference_T = prm.get_double("Reference temperature");
+          ref_visc = prm.get_double ("Reference viscosity");
+          min_strain_rate = get_vector_double("Minimum strain rate",n_fields,prm);
+          min_visc = get_vector_double ("Minimum viscosity",n_fields,prm);
+          max_visc = get_vector_double ("Maximum viscosity",n_fields,prm);
+          veff_coefficient = get_vector_double ("Effective viscosity coefficient",n_fields,prm);
+          reference_compressibility  = prm.get_double ("Reference compressibility");
+          use_deviator_of_strain_rate = prm.get_bool ("Use deviator of strain-rate");
+
+
+          // averaging parameters
+          viscosity_averaging_p = prm.get_double("Viscosity averaging p");
+
+          use_analytical_derivative = prm.get_bool("Use analytical derivative");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(DruckerPragerCompositions,
+                                   "drucker prager compositions",
+                                   " An implementation of a viscous rheology including diffusion"
+                                   " and dislocation creep allowing for different compositions."
+                                   " Designed for testing the Spiegelman et al. (2016) benchmark."
+                                   " Compositional fields can each be assigned individual"
+                                   " activation energies, reference densities, thermal expansivities,"
+                                   " and stress exponents. The effective viscosity is defined as"
+                                   " \n\n"
+                                   " \\[v_\\text{eff} = \\left(\\frac{1}{v_\\text{eff}^\\text{diff}}+"
+                                   " \\frac{1}{v_\\text{eff}^\\text{dis}}\\right)^{-1}\\]"
+                                   " where"
+                                   " \\[v_\\text{i} = 0.5 * A^{-\\frac{1}{n_i}} d^\\frac{m_i}{n_i}"
+                                   " \\dot{\\varepsilon_i}^{\\frac{1-n_i}{n_i}}"
+                                   " \\exp\\left(\\frac{E_i^* + PV_i^*}{n_iRT}\\right)\\]"
+                                   " \n\n"
+                                   " where $d$ is grain size, $i$ corresponds to diffusion or dislocation creep,"
+                                   " $\\dot{\\varepsilon}$ is the square root of the second invariant of the"
+                                   " strain rate tensor, $R$ is the gas constant, $T$ is temperature, "
+                                   " and $P$ is pressure."
+                                   " $A_i$ are prefactors, $n_i$ and $m_i$ are stress and grain size exponents"
+                                   " $E_i$ are the activation energies and $V_i$ are the activation volumes."
+                                   " \n\n"
+                                   " The ratio of diffusion to dislocation strain rate is found by Newton's"
+                                   " method, iterating to find the stress which satisfies the above equations."
+                                   " The value for the components of this formula and additional"
+                                   " parameters are read from the parameter file in subsection"
+                                   " 'Material model/SimpleNonlinear'.")
+  }
+}
diff --git a/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/input.prm.bak b/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/input.prm.bak
new file mode 100644
index 00000000000..a35e871b3ca
--- /dev/null
+++ b/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/input.prm.bak
@@ -0,0 +1,137 @@
+set Additional shared libraries            = ./libdrucker_prager_compositions.so
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = iterated Advection and Newton Stokes
+set Max nonlinear iterations               = 150
+set Nonlinear solver tolerance             = 1e-14
+set Pressure normalization                 = no
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+    set Linear solver tolerance             = 1e-5
+  end
+
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations      = 5
+    set SPD safety factor                        = 0.9
+    set Nonlinear Newton solver switch tolerance = 1e-20 #
+    set Max Newton line search iterations        = 0
+    set Maximum linear Stokes solver tolerance   = 9e-1
+    set Use Newton residual scaling method       = false
+    set Use Newton failsafe                      = false
+    set Stabilization preconditioner             = SPD
+    set Stabilization velocity block             = SPD
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = H = 30e3
+
+    # The function below lays out the composition structure as described in the Spiegelman paper.
+    # It generates a composition at the bottom which has a square with round eges sticking out in
+    # the center.
+    set Function expression = if(z < 0.25 * H,1, \
+if(z < (0.25+(1/12)-0.02)*H & x > (2-(1/12))*H & x < (2+(1/12))*H,1, \
+if(z < (0.25+(1/12))*H & (x > (2-(1/12)+0.02)*H & x < (2+(1/12)-0.02)*H | (x-(2-(1/12)+0.02)*H)^2 + (z-(0.25+(1/12)-0.02)*H)^2 < (0.02*H)^2 | (x-(2+(1/12)-0.02)*H)^2 + (z-(0.25+(1/12)-0.02)*H)^2 < (0.02*H)^2),1, \
+if(z < (0.25+0.02)*H && x > (2-(1/12)-0.02)*H && x < (2+(1/12)+0.02)*H && ((x-(2-(1/12)-0.02)*H)^2 + (z-(0.25+0.02)*H)^2 > (0.02*H)^2 && (x-(2+(1/12)+0.02)*H)^2 + (z-(0.25+0.02)*H)^2 > (0.02*H)^2),1,0))))
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent      = 120e3
+    set Y extent      = 30e3
+    set X repetitions = 4
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+
+  #parameters for all rheologies
+  set Conductivities                         = 2.25,          2.25
+  set Heat capacities                        = 1250,          1250
+  set Reference temperatures                 = 0,             0
+  set Reference densities                    = 2700.0,        2700.0
+
+  #plastic parameters
+  set Cohesions                              = 1e8,0
+  set Angles of internal friction            = 30,0
+
+  #Dislocation parameters
+  set Stress exponents                       = 50,            1
+  set Initial viscosities                    = 1e20, 1e21
+
+  # the first value is ignored by the specific drucker prager compositions material model
+  # in this benchmark folder, so set it to a nonsensical value: 0.
+  set Viscous prefactors                     = 0, 1e21
+end
+
+subsection Material model
+  set Model name = drucker prager compositions
+
+  subsection Drucker prager compositions
+    set Maximum viscosity           = 1e24
+    set Minimum viscosity           = 1e21
+    set Viscosity averaging p       = -1
+    set Use deviator of strain-rate = true
+    set Use analytical derivative   = false
+    set Reference viscosity         = 5e24
+    set Reference compressibility   = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement   = 5
+  set Strategy                    = strain rate
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   =
+end
+
+subsection Boundary velocity model
+  # Prescribe a horizontal traction on the vertical boundaries
+  set Tangential velocity boundary indicators = 2
+  set Zero velocity boundary indicators       =
+
+  # Prescribe a zero vertical velocity component on the vertical boundaries
+  set Prescribed velocity boundary indicators = 0 x:function,1 x:function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = if(x<60e3,7.92219116e-11,-7.92219116e-11);0
+  end
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators =
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties,strain rate, spd factor
+    set Interpolate output       = false
+  end
+end
diff --git a/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm b/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
index b6cca66b629..86379ea1226 100644
--- a/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
+++ b/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
@@ -146,9 +146,9 @@ end
 # - Vrms over the whole domain (velocity statistics)
 # - Vrms along the surface (velocity boundary statistics)
 # - Vmax along the surface (velocity boundary statistics)
-# - average rate of viscous dissipation (tosi viscous dissipation statistics)
-# - average rate of work against gravity (tosi viscous dissipation statistics)
-# - percentage error difference work and dissipation (tosi viscous dissipation statistics)
+# - average rate of viscous dissipation (tosi heating statistics)
+# - average rate of work against gravity (tosi heating statistics)
+# - percentage error difference work and dissipation (tosi heating statistics)
 #
 # Tosi et al. (2015) also report depth averages; averages for viscosity
 # and temperature are produced every 0.05 units of time.
diff --git a/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm.bak b/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm.bak
new file mode 100644
index 00000000000..b6cca66b629
--- /dev/null
+++ b/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm.bak
@@ -0,0 +1,168 @@
+# A description of viscoplastic convection in a 2d box as
+# described in Tosi et al. (2015).
+
+# We add the necessary plugins through a shared library
+set Additional shared libraries            = $ASPECT_SOURCE_DIR/benchmarks/tosi_et_al_2015_gcubed/libtosi_benchmark.so
+
+# This is a 2D benchmark.
+set Dimension                              = 2
+
+# We run the model from time = 0 to time = 1 and to handle
+# the nonlinearity of the viscosity correctly, we use
+# the iterated Advection and Stokes nonlinear solver and skip the cheap
+# Stokes solves.
+set Use years in output instead of seconds = false
+set End time                               = 0.01
+set Output directory                       = Case4_3_T15_NS_analytical_9e-1_release
+set Nonlinear solver scheme                = iterated Advection and Newton Stokes
+set Max nonlinear iterations               = 30
+set Nonlinear solver tolerance             = 1e-7
+
+# We choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 200
+    set Linear solver tolerance = 1e-6
+  end
+
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 5
+    set SPD safety factor = 0.9
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 0
+    set Maximum linear Stokes solver tolerance = 9e-1
+    set Use Newton residual scaling method = false
+    set Use Newton failsafe = false
+    set Stabilization preconditioner = SPD
+    set Stabilization velocity block = SPD
+  end
+end
+
+# Our model domain is the unit square.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# We prescribe a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation with amplitude A.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = A=0.01, pi=3.1415926536
+    set Function expression = (1.0-z) + A*cos(pi*x)*sin(pi*z)
+  end
+end
+
+# The top and bottom boundary carry a prescribed boundary temperature, whereas
+# all other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  # The temperature at the bottom is set to 1; at the top to 0.
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  # Here, all four sides of the box allow tangential
+  # unrestricted flow but with a zero normal component:
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# Gravity is vertical and of magnitude 1e8.
+# //TODO elaborate on scaling/rayleigh
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e8
+  end
+end
+
+subsection Material model
+  set Model name = TosiMaterial
+
+  subsection Tosi benchmark
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-06
+    set Thermal viscosity parameter   = 1e5
+    set Pressure viscosity parameter  = 10
+    set Yield stress          = 1
+    set Nonlinear viscosity constant  = 1e-3
+    set Initial viscosity        = 1e-1
+    set Minimum viscosity        = 1e-6
+    set Maximum viscosity        = 10
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.05. Given
+# our start time (0.0) and final time (1.0) this means that
+# we will obtain 20 output files.
+#
+# The statistics file includes the data reported in Tosi et al. (2015):
+# - average temperature (temperature statistics)
+# - top and bottom Nusselt numbers (heat flux statistics)
+# - Vrms over the whole domain (velocity statistics)
+# - Vrms along the surface (velocity boundary statistics)
+# - Vmax along the surface (velocity boundary statistics)
+# - average rate of viscous dissipation (tosi viscous dissipation statistics)
+# - average rate of work against gravity (tosi viscous dissipation statistics)
+# - percentage error difference work and dissipation (tosi viscous dissipation statistics)
+#
+# Tosi et al. (2015) also report depth averages; averages for viscosity
+# and temperature are produced every 0.05 units of time.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization , depth average, velocity boundary statistics #, tosi dissipation and work statistics, depth average, velocity boundary statistics
+
+  subsection Depth average
+    set List of output variables = temperature, viscosity
+    set Time between graphical output = 0.05
+    set Number of zones = 10
+  end
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate, gravity
+    set Time between graphical output = 0.05
+  end
+end
diff --git a/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm.bak b/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm.bak
new file mode 100644
index 00000000000..d76f0ae4e05
--- /dev/null
+++ b/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm.bak
@@ -0,0 +1,23 @@
+# Same as the newton_solver_benchmark_set/tosi_et_al_2015/input.prm
+# benchmark but using GMG instead.
+
+# We add the necessary plugins through a shared library
+set Additional shared libraries            = $ASPECT_SOURCE_DIR/benchmarks/tosi_et_al_2015_gcubed/libtosi_benchmark.so
+
+include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
+
+set Output directory                       = output-gmg
+
+subsection Solver parameters
+  subsection Matrix Free
+    set Output details = true
+  end
+
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/benchmarks/nsinker/nsinker.cc.bak b/benchmarks/nsinker/nsinker.cc.bak
new file mode 100644
index 00000000000..c031bdea433
--- /dev/null
+++ b/benchmarks/nsinker/nsinker.cc.bak
@@ -0,0 +1,352 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/global.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_signals.h>
+
+#include <deal.II/base/point.h>
+#include <deal.II/base/exceptions.h>
+
+
+namespace aspect
+{
+  /**
+   * This is the "NSinker" benchmark as defined in Rudi et al. (2017),
+   * which is based on May et al. (2014). It creates a number of
+   * spherical high-viscosity, high-density sinking spheres in a box
+   * geometry that provide a challenge for the Stokes preconditioner.
+   * The difficulty of the problem is determined by the number of
+   * sinkers and the viscosity contrast between sinkers and
+   * background.
+   */
+  namespace NSinkerBenchmark
+  {
+    using namespace dealii;
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class NSinkerMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * Constructor
+         */
+        NSinkerMaterial ();
+
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          const double sqrt_dynamic_viscosity_ratio = std::sqrt(dynamic_viscosity_ratio);
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const double chi = inside_outside_factor(in.position[i]);
+              out.viscosities[i] = (sqrt_dynamic_viscosity_ratio - 1./sqrt_dynamic_viscosity_ratio)*(1-chi) + 1./sqrt_dynamic_viscosity_ratio;
+              out.densities[i] = sinker_density * (1.0 - chi);
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override
+        {
+          return false;
+        }
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm)
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("NSinker");
+            {
+              prm.declare_entry ("Dynamic viscosity ratio", "1e3",
+                                 Patterns::Double (0),
+                                 "Viscosity in the sinkers.");
+              prm.declare_entry ("Sinker density", "10",
+                                 Patterns::Double (0),
+                                 "Density in the sinkers.");
+              prm.declare_entry ("Number of sinkers", "4",
+                                 Patterns::Integer (0,75),
+                                 "Number of sinking spheres.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("NSinker");
+            {
+              dynamic_viscosity_ratio = prm.get_double ("Dynamic viscosity ratio");
+              sinker_density = prm.get_double ("Sinker density");
+              n_sinkers = prm.get_integer ("Number of sinkers");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          // Declare dependencies on solution variables
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+
+
+      private:
+        /**
+         * Ratio of viscosities between sinkers and background material.
+         */
+        double dynamic_viscosity_ratio;
+
+        /**
+         * Sinker density. For a gravity of 1 this corresponds to
+         * the size of the right-hand-side forcing term.
+         */
+        double sinker_density;
+
+        /**
+         * Number of sinking spheres.
+         */
+        unsigned int n_sinkers;
+
+        /**
+         * Centers for the sinkers provided by Cedric Thielot (pers. comm. from Dave May)
+         */
+        std::vector<Point<3>> centers;
+
+        /**
+         * Parameters for evaluating viscosity
+         */
+        double delta;
+        double omega;
+
+        /**
+         * Return a factor that indicates whether a point is inside or
+         * outside the sinker spheres. The function can be thought of
+         * as a 1 (outside) vs 0 (inside) factor, but is in reality a
+         * smoothed version of this that takes into account the
+         * distance from the centers of the sinkers.
+         */
+        double inside_outside_factor (const Point<dim> &p) const;
+    };
+
+
+    template <int dim>
+    NSinkerMaterial<dim>::NSinkerMaterial ()
+    {
+      delta = 200.0;
+      omega = 0.1;
+
+      centers.resize(75);
+      centers[0] = Point<3>(2.4257829890e-01, 1.3469574514e-02, 3.8313885004e-01);
+      centers[1] = Point<3>(4.1465269048e-01, 6.7768972864e-02, 9.9312692973e-01);
+      centers[2] = Point<3>(4.8430804651e-01, 7.6533776604e-01, 3.1833815403e-02);
+      centers[3] = Point<3>(3.0935481671e-02, 9.3264044027e-01, 8.8787953411e-01);
+      centers[4] = Point<3>(5.9132973039e-01, 4.7877868473e-01, 8.3335433660e-01);
+      centers[5] = Point<3>(1.8633519681e-01, 7.3565270739e-01, 1.1505317181e-01);
+      centers[6] = Point<3>(6.9865863058e-01, 3.5560411138e-01, 6.3830000658e-01);
+      centers[7] = Point<3>(9.0821050755e-01, 2.9400041480e-01, 2.6497158886e-01);
+      centers[8] = Point<3>(3.7749399775e-01, 5.4162011554e-01, 9.2818150340e-03);
+      centers[9] = Point<3>(8.5247022139e-01, 4.6701098395e-01, 5.3607231962e-02);
+      centers[10] = Point<3>(9.7674759057e-01, 1.9675474344e-01, 8.5697294067e-01);
+      centers[11] = Point<3>(1.4421375987e-01, 8.0066218823e-01, 7.2939761948e-01);
+      centers[12] = Point<3>(9.8579064709e-01, 1.8340570954e-01, 4.9976021075e-01);
+      centers[13] = Point<3>(4.6986202126e-01, 9.7099129947e-01, 4.5077026191e-01);
+      centers[14] = Point<3>(9.5791877292e-02, 9.7408164664e-01, 3.9023506101e-01);
+      centers[15] = Point<3>(6.8067035576e-01, 2.6669318800e-02, 2.3124107450e-01);
+      centers[16] = Point<3>(4.6873909443e-01, 9.7960100555e-02, 4.1541002524e-01);
+      centers[17] = Point<3>(7.9629418710e-01, 3.1640260216e-01, 7.7853444953e-01);
+      centers[18] = Point<3>(8.2849331472e-01, 4.8714042059e-01, 3.6904878000e-01);
+      centers[19] = Point<3>(6.0284549678e-01, 2.4264360789e-02, 8.1111178631e-01);
+      centers[20] = Point<3>(3.5579259291e-01, 8.0610905439e-01, 2.7487712366e-01);
+      centers[21] = Point<3>(8.5981739865e-01, 9.5101905612e-01, 7.7727618477e-01);
+      centers[22] = Point<3>(6.8083745971e-01, 8.3518540665e-01, 9.6112961413e-01);
+      centers[23] = Point<3>(7.0542474869e-01, 7.3751226102e-02, 5.3685709440e-01);
+      centers[24] = Point<3>(9.5718558131e-01, 4.1806501915e-01, 4.1877679639e-01);
+      centers[25] = Point<3>(3.8161700050e-01, 8.3692747440e-01, 2.4006224854e-01);
+      centers[26] = Point<3>(7.2621119848e-01, 4.3161282150e-01, 1.1669089744e-01);
+      centers[27] = Point<3>(2.2391322592e-01, 3.0958795748e-01, 2.4480139429e-01);
+      centers[28] = Point<3>(3.7703382754e-01, 8.0753940242e-01, 3.1473643301e-01);
+      centers[29] = Point<3>(7.7522956709e-01, 2.8333410774e-01, 9.9634871585e-01);
+      centers[30] = Point<3>(6.3286731189e-01, 6.0091089904e-01, 5.0948022423e-01);
+      centers[31] = Point<3>(8.3412860373e-01, 1.9944285005e-01, 3.5980841627e-02);
+      centers[32] = Point<3>(7.3000523063e-01, 1.9791117972e-01, 2.9319749786e-01);
+      centers[33] = Point<3>(7.7034656693e-01, 2.1475035521e-01, 3.0922000730e-01);
+      centers[34] = Point<3>(6.0662675677e-02, 5.5759010630e-01, 4.1691651960e-01);
+      centers[35] = Point<3>(1.1594487686e-01, 6.8554530558e-01, 9.5995079957e-01);
+      centers[36] = Point<3>(2.7973348288e-02, 1.4806467395e-01, 5.2297503060e-01);
+      centers[37] = Point<3>(6.4133927209e-01, 9.8914607800e-01, 5.7813295237e-01);
+      centers[38] = Point<3>(6.8053043246e-01, 6.7497840462e-01, 3.6204645148e-01);
+      centers[39] = Point<3>(9.1470996426e-01, 5.3036934674e-01, 9.1761070439e-01);
+      centers[40] = Point<3>(2.8310876353e-01, 2.0898862472e-01, 4.7181570645e-01);
+      centers[41] = Point<3>(8.0657831198e-01, 1.6168943288e-01, 5.1429839456e-01);
+      centers[42] = Point<3>(8.1311740159e-01, 6.4168478858e-02, 4.7962416312e-01);
+      centers[43] = Point<3>(4.3309508843e-02, 9.0291512474e-01, 2.9450144167e-01);
+      centers[44] = Point<3>(6.8573011443e-01, 6.6033273035e-02, 8.2121989495e-01);
+      centers[45] = Point<3>(2.4277445452e-01, 3.1025718772e-01, 4.9255406554e-01);
+      centers[46] = Point<3>(3.5617944848e-01, 3.0799053857e-01, 3.9698166931e-01);
+      centers[47] = Point<3>(7.0916077621e-02, 8.8651657239e-01, 6.8403214295e-01);
+      centers[48] = Point<3>(5.2822650202e-01, 9.0281945043e-01, 6.8650344000e-01);
+      centers[49] = Point<3>(6.3316007640e-02, 1.5214040370e-01, 2.3765034985e-02);
+      centers[50] = Point<3>(4.1894298765e-01, 1.7479340461e-01, 7.5275125343e-01);
+      centers[51] = Point<3>(4.9031640053e-01, 7.4774375406e-01, 3.2927456281e-01);
+      centers[52] = Point<3>(1.1757708859e-01, 1.1812786251e-01, 3.7498524244e-01);
+      centers[53] = Point<3>(3.7696964032e-01, 7.2874483733e-01, 1.4480990830e-02);
+      centers[54] = Point<3>(3.8201288152e-01, 4.9049964756e-01, 8.2757658503e-01);
+      centers[55] = Point<3>(7.9664661586e-02, 9.2396727806e-01, 1.1804237828e-01);
+      centers[56] = Point<3>(9.3825167927e-01, 1.9597347043e-01, 7.2611756191e-01);
+      centers[57] = Point<3>(8.5786301170e-01, 1.0363770514e-01, 8.3891028205e-01);
+      centers[58] = Point<3>(5.6511039453e-01, 8.1040084307e-01, 4.0696941614e-01);
+      centers[59] = Point<3>(9.3497714490e-01, 1.6087440083e-01, 8.1605472361e-01);
+      centers[60] = Point<3>(4.3173963829e-01, 2.4810082244e-01, 8.3052277138e-01);
+      centers[61] = Point<3>(5.9621858625e-01, 6.4577903070e-01, 6.0816894547e-01);
+      centers[62] = Point<3>(4.9546643556e-01, 3.0438243752e-01, 7.5562733447e-01);
+      centers[63] = Point<3>(8.2861043319e-01, 4.5555055302e-01, 4.3814466774e-01);
+      centers[64] = Point<3>(8.9743076959e-01, 1.1894442752e-01, 9.8993320995e-02);
+      centers[65] = Point<3>(6.9884936497e-01, 5.6127713367e-01, 3.8478565932e-01);
+      centers[66] = Point<3>(9.2576270966e-02, 9.2938612771e-01, 1.9264837596e-01);
+      centers[67] = Point<3>(8.4125479722e-01, 9.6937695284e-01, 3.1844636161e-01);
+      centers[68] = Point<3>(1.2799954700e-01, 2.8838638276e-01, 9.0993508972e-01);
+      centers[69] = Point<3>(2.7905288352e-01, 4.1813262758e-02, 7.5550716964e-01);
+      centers[70] = Point<3>(8.0900019305e-01, 8.6624463269e-01, 9.7354159503e-01);
+      centers[71] = Point<3>(3.1358765965e-01, 4.6779574243e-01, 2.4304298462e-01);
+      centers[72] = Point<3>(8.2344259034e-01, 5.9961585635e-01, 7.4369772512e-01);
+      centers[73] = Point<3>(3.2766604253e-01, 8.3176720460e-02, 9.5114077951e-01);
+      centers[74] = Point<3>(8.2308128282e-01, 5.2712029523e-01, 3.1080186614e-01);
+    }
+
+
+
+    template <>
+    double
+    NSinkerMaterial<2>::inside_outside_factor (const Point<2> &p) const
+    {
+      double chi = 1.0;
+
+      for (unsigned int s=0; s<n_sinkers; ++s)
+        {
+          double dist = p.distance(Point<2>(centers[s](0), centers[s](1)));
+          double temp = 1-std::exp(-delta*
+                                   std::pow(std::max(0.0,dist-omega/2.0),2));
+          chi *= temp;
+        }
+      return chi;
+    }
+
+
+
+    template <>
+    double
+    NSinkerMaterial<3>::inside_outside_factor (const Point<3> &p) const
+    {
+      double chi = 1.0;
+
+      for (unsigned int s=0; s<n_sinkers; ++s)
+        {
+          double dist = p.distance(centers[s]);
+          double temp = 1-std::exp(-delta*
+                                   std::pow(std::max(0.0,dist-omega/2.0),2));
+          chi *= temp;
+        }
+      return chi;
+    }
+  }
+}
+
+
+// Change pressure scaling to 1.0:
+double pressure_scaling_signal(const double /*pressure_scaling*/,
+                               const double /*reference_viscosity*/,
+                               const double /*length_scale*/)
+{
+  return 1.0;
+}
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  signals.modify_pressure_scaling.connect(&pressure_scaling_signal);
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
+
+
+namespace aspect
+{
+  namespace NSinkerBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(NSinkerMaterial,
+                                   "nsinker",
+                                   "A material model that corresponds to the 'NSinker' benchmark "
+                                   "defined in May et al., G-Cubed, 2015. We here implement the "
+                                   "version defined in Rudi et al., SIAM Journal on Scientific "
+                                   "Computing, 2017. Number of sinkers and viscosity ratio can be chosen "
+                                   "as input parameters.")
+  }
+}
diff --git a/benchmarks/nsinker/nsinker.prm b/benchmarks/nsinker/nsinker.prm
index 3e7adb91f88..0716eaac90a 100644
--- a/benchmarks/nsinker/nsinker.prm
+++ b/benchmarks/nsinker/nsinker.prm
@@ -13,7 +13,6 @@ set Nonlinear solver scheme                = no Advection, single Stokes
 set Max nonlinear iterations               = 1
 set Use years in output instead of seconds = false
 
-
 # Follow as closely as possible the parameters from Rudi et al. (2017)
 subsection Solver parameters
   subsection Stokes solver parameters
@@ -25,8 +24,9 @@ subsection Solver parameters
     set Use weighted BFBT for Schur complement          = false
     set Krylov method for cheap solver steps            = GMRES
   end
+
   subsection AMG parameters
-   set AMG aggregation threshold = 0.02
+    set AMG aggregation threshold = 0.02
   end
 end
 
diff --git a/benchmarks/nsinker/nsinker.prm.bak b/benchmarks/nsinker/nsinker.prm.bak
new file mode 100644
index 00000000000..3e7adb91f88
--- /dev/null
+++ b/benchmarks/nsinker/nsinker.prm.bak
@@ -0,0 +1,84 @@
+# This is the "NSinker" benchmark defined in May et al. (2015,G3) in the
+# implementation of Rudi et al., (2017, SIAM J.Sci.Comp.). It creates a number
+# of spherical high-viscosity, high-density sinking spheres in a box geometry
+# that provide a challenge for the Stokes preconditioner. The difficulty of the
+# problem is determined by the number of sinkers and the viscosity contrast
+# between sinkers and background.
+
+set Additional shared libraries            = ./libnsinker.so
+set Dimension                              = 3
+set End time                               = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, single Stokes
+set Max nonlinear iterations               = 1
+set Use years in output instead of seconds = false
+
+
+# Follow as closely as possible the parameters from Rudi et al. (2017)
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use full A block as preconditioner              = true
+    set Number of cheap Stokes solver steps             = 500
+    set Maximum number of expensive Stokes solver steps = 1000
+    set Linear solver tolerance                         = 1e-6
+    set GMRES solver restart length                     = 100
+    set Use weighted BFBT for Schur complement          = false
+    set Krylov method for cheap solver steps            = GMRES
+  end
+  subsection AMG parameters
+   set AMG aggregation threshold = 0.02
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = false
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = left,right,bottom,top,front,back
+end
+
+subsection Material model
+  set Model name = nsinker
+  set Material averaging = none
+
+  subsection NSinker
+    set Number of sinkers = 8
+    set Dynamic viscosity ratio = 1e4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables = material properties
+  end
+end
diff --git a/benchmarks/nsinker/nsinker_2d.prm.bak b/benchmarks/nsinker/nsinker_2d.prm.bak
new file mode 100644
index 00000000000..070b9bdef40
--- /dev/null
+++ b/benchmarks/nsinker/nsinker_2d.prm.bak
@@ -0,0 +1,72 @@
+# This is a 2D version of the original 3D "NSinker" problem.
+
+set Additional shared libraries            = ./libnsinker.so
+set Dimension                              = 2
+set End time                               = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, single Stokes
+set Max nonlinear iterations               = 1
+set Use years in output instead of seconds = false
+
+# Follow as closely as possible the parameters from Rudi et al. (2017)
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use full A block as preconditioner              = true
+    set Number of cheap Stokes solver steps             = 0
+    set Maximum number of expensive Stokes solver steps = 1000
+    set Linear solver tolerance                         = 1e-6
+    set GMRES solver restart length                     = 100
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = true
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left,right,bottom
+end
+
+subsection Material model
+  set Model name = nsinker
+  set Material averaging = none
+
+  subsection NSinker
+    set Number of sinkers = 1
+    set Dynamic viscosity ratio = 1e4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables = material properties
+  end
+end
diff --git a/benchmarks/nsinker/nsinker_bfbt.prm b/benchmarks/nsinker/nsinker_bfbt.prm
index ed104447980..7de5ffda08f 100644
--- a/benchmarks/nsinker/nsinker_bfbt.prm
+++ b/benchmarks/nsinker/nsinker_bfbt.prm
@@ -14,10 +14,9 @@ set Nonlinear solver scheme                = no Advection, single Stokes
 set Max nonlinear iterations               = 1
 set Use years in output instead of seconds = false
 
-
 # Follow as closely as possible the parameters from Rudi et al. (2017)
 subsection Solver parameters
-   subsection Stokes solver parameters
+  subsection Stokes solver parameters
     set Use full A block as preconditioner              = true
     set Number of cheap Stokes solver steps             = 500
     set Maximum number of expensive Stokes solver steps = 1000
@@ -26,8 +25,9 @@ subsection Solver parameters
     set Use weighted BFBT for Schur complement          = true
     set Krylov method for cheap solver steps            = GMRES
   end
+
   subsection AMG parameters
-   set AMG aggregation threshold = 0.02
+    set AMG aggregation threshold = 0.02
   end
 end
 
diff --git a/benchmarks/nsinker/nsinker_bfbt.prm.bak b/benchmarks/nsinker/nsinker_bfbt.prm.bak
new file mode 100644
index 00000000000..ed104447980
--- /dev/null
+++ b/benchmarks/nsinker/nsinker_bfbt.prm.bak
@@ -0,0 +1,85 @@
+# This is the "NSinker" benchmark defined in May et al. (2015,G3) in the
+# implementation of Rudi et al., (2017, SIAM J.Sci.Comp.). It creates a number
+# of spherical high-viscosity, high-density sinking spheres in a box geometry
+# that provide a challenge for the Stokes preconditioner. The difficulty of the
+# problem is determined by the number of sinkers and the viscosity contrast
+# between sinkers and background. In this benchmark, we use the
+# weighted BFBT preconditioner introduced by Rudi et al., (2017).
+
+set Additional shared libraries            = ./libnsinker.so
+set Dimension                              = 3
+set End time                               = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, single Stokes
+set Max nonlinear iterations               = 1
+set Use years in output instead of seconds = false
+
+
+# Follow as closely as possible the parameters from Rudi et al. (2017)
+subsection Solver parameters
+   subsection Stokes solver parameters
+    set Use full A block as preconditioner              = true
+    set Number of cheap Stokes solver steps             = 500
+    set Maximum number of expensive Stokes solver steps = 1000
+    set Linear solver tolerance                         = 1e-6
+    set GMRES solver restart length                     = 100
+    set Use weighted BFBT for Schur complement          = true
+    set Krylov method for cheap solver steps            = GMRES
+  end
+  subsection AMG parameters
+   set AMG aggregation threshold = 0.02
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = false
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = left,right,bottom,top,front,back
+end
+
+subsection Material model
+  set Model name = nsinker
+  set Material averaging = none
+
+  subsection NSinker
+    set Number of sinkers = 8
+    set Dynamic viscosity ratio = 1e4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables = material properties
+  end
+end
diff --git a/benchmarks/nsinker/nsinker_gmg.prm.bak b/benchmarks/nsinker/nsinker_gmg.prm.bak
new file mode 100644
index 00000000000..aa4817332bf
--- /dev/null
+++ b/benchmarks/nsinker/nsinker_gmg.prm.bak
@@ -0,0 +1,92 @@
+# This is the "NSinker" benchmark defined in May et al. (2015,G3) in the
+# implementation of Rudi et al., (2017, SIAM J.Sci.Comp.). It creates a number
+# of spherical high-viscosity, high-density sinking spheres in a box geometry
+# that provide a challenge for the Stokes preconditioner. The difficulty of the
+# problem is determined by the number of sinkers and the viscosity contrast
+# between sinkers and background.
+
+set Additional shared libraries            = ./libnsinker.so
+set Dimension                              = 3
+set End time                               = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, single Stokes
+set Max nonlinear iterations               = 1
+set Use years in output instead of seconds = false
+set Output directory = output-gmg
+
+# Follow as closely as possible the parameters from Rudi et al. (2017)
+subsection Solver parameters
+  subsection Matrix Free
+    set Output details = true
+  end
+
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps             = 200
+    set Maximum number of expensive Stokes solver steps = 0
+    set Linear solver tolerance                         = 1e-6
+    set GMRES solver restart length                     = 100
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = false
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = left,right,bottom,top,front,back
+end
+
+subsection Material model
+  set Model name = nsinker
+  set Material averaging = harmonic average
+
+  subsection NSinker
+    set Number of sinkers = 4
+    set Dynamic viscosity ratio = 1e4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 4
+  set Initial adaptive refinement = 5
+  set Adapt by fraction of cells = true
+  set Strategy = velocity
+  set Run postprocessors on initial refinement = true
+  set Coarsening fraction       = 0.0
+  set Refinement fraction       = 0.147 #0.14285714285
+end
+
+subsection Postprocess
+  set List of postprocessors = memory statistics, visualization
+
+  subsection Memory statistics
+    set Output peak virtual memory (VmPeak) = true
+  end
+
+  subsection Visualization
+    set List of output variables = viscosity
+  end
+end
diff --git a/benchmarks/nsinker_spherical_shell/amg.prm.bak b/benchmarks/nsinker_spherical_shell/amg.prm.bak
new file mode 100644
index 00000000000..64b627b59c4
--- /dev/null
+++ b/benchmarks/nsinker_spherical_shell/amg.prm.bak
@@ -0,0 +1,20 @@
+# This is the "Spherical Shell NSinker" benchmark
+#
+# This file uses the AMG instead of GMG solver
+
+set Additional shared libraries            = ./libnsinker_spherical_shell.so
+
+include gmg.prm
+
+set Dimension                              = 3
+set Output directory = output-amg
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block AMG
+    set Number of cheap Stokes solver steps             = 2000
+    set Maximum number of expensive Stokes solver steps = 0
+    set Linear solver tolerance                         = 1e-6
+    set GMRES solver restart length                     = 100
+  end
+end
diff --git a/benchmarks/nsinker_spherical_shell/gmg.prm.bak b/benchmarks/nsinker_spherical_shell/gmg.prm.bak
new file mode 100644
index 00000000000..58a4eab153b
--- /dev/null
+++ b/benchmarks/nsinker_spherical_shell/gmg.prm.bak
@@ -0,0 +1,86 @@
+# This is the "Spherical Shell NSinker" benchmark
+
+set Additional shared libraries            = ./libnsinker_spherical_shell.so
+set Dimension                              = 3
+set End time                               = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, single Stokes
+set Use years in output instead of seconds = false
+set Output directory = output-gmg
+
+subsection Solver parameters
+  subsection Matrix Free
+    set Output details = true
+  end
+
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps             = 2000
+    set Maximum number of expensive Stokes solver steps = 0
+    set Linear solver tolerance                         = 1e-6
+    set GMRES solver restart length                     = 200
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = false
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 0.54
+    set Outer radius  = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top,bottom
+end
+
+subsection Material model
+  set Model name = nsinker
+  set Material averaging = harmonic average
+
+  subsection NSinker
+    set Number of sinkers = 5
+    set Dynamic viscosity ratio = 1e2
+    set Sinker density = 10
+    set Transition zone viscosity jump = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 2
+  set Initial adaptive refinement = 5
+  set Adapt by fraction of cells = true
+  set Strategy = velocity
+  set Run postprocessors on initial refinement = true
+  set Coarsening fraction       = 0.0
+  set Refinement fraction       = 0.147
+end
+
+subsection Postprocess
+  set List of postprocessors = memory statistics, visualization
+
+  subsection Memory statistics
+    set Output peak virtual memory (VmPeak) = true
+  end
+
+  subsection Visualization
+    set List of output variables = viscosity
+  end
+end
diff --git a/benchmarks/nsinker_spherical_shell/nsinker.cc.bak b/benchmarks/nsinker_spherical_shell/nsinker.cc.bak
new file mode 100644
index 00000000000..9ae67327596
--- /dev/null
+++ b/benchmarks/nsinker_spherical_shell/nsinker.cc.bak
@@ -0,0 +1,349 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+
+#include <deal.II/base/point.h>
+#include <deal.II/base/exceptions.h>
+
+
+namespace aspect
+{
+  /**
+   * This is the "Spherical Shell NSinker" benchmark.
+   */
+  namespace NSinkerBenchmark
+  {
+    using namespace dealii;
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class NSinkerMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * Constructor
+         */
+        NSinkerMaterial ();
+
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          const double sqrt_dynamic_viscosity_ratio = std::sqrt(dynamic_viscosity_ratio);
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const double chi = inside_outside_factor(in.position[i]);
+              out.viscosities[i] = (sqrt_dynamic_viscosity_ratio - 1./sqrt_dynamic_viscosity_ratio)*(1-chi) + 1./sqrt_dynamic_viscosity_ratio;
+              if (in.position[i].norm()<0.89583) // below "660km"?
+                out.viscosities[i] *= transition_zone_jump;
+              out.densities[i] = sinker_density * (1.0 - chi);
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override
+        {
+          return false;
+        }
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm)
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("NSinker");
+            {
+              prm.declare_entry ("Dynamic viscosity ratio", "1e3",
+                                 Patterns::Double (0),
+                                 "Viscosity in the sinkers.");
+              prm.declare_entry ("Sinker density", "10",
+                                 Patterns::Double (0),
+                                 "Density in the sinkers.");
+              prm.declare_entry ("Number of sinkers", "4",
+                                 Patterns::Integer (0,31),
+                                 "Number of sinking spheres.");
+              prm.declare_entry ("Transition zone viscosity jump", "1.0",
+                                 Patterns::Double (0),
+                                 "The factor by which the viscosity increases below the base of the "
+                                 "transition zone at a depth of 660km.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("NSinker");
+            {
+              dynamic_viscosity_ratio = prm.get_double ("Dynamic viscosity ratio");
+              sinker_density = prm.get_double ("Sinker density");
+              n_sinkers = prm.get_integer ("Number of sinkers");
+              transition_zone_jump = prm.get_double("Transition zone viscosity jump");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          // Declare dependencies on solution variables
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+
+
+      private:
+        /**
+         * Ratio of viscosities between sinkers and background material.
+         */
+        double dynamic_viscosity_ratio;
+
+        /**
+         * Sinker density. For a gravity of 1 this corresponds to
+         * the size of the right-hand-side forcing term.
+         */
+        double sinker_density;
+
+        /**
+         * Magnitude of the jump of viscosity when going below the transition zone.
+         */
+        double transition_zone_jump;
+
+        /**
+         * Number of sinking spheres.
+         */
+        unsigned int n_sinkers;
+
+        /**
+         * Centers for the sinkers provided by Cedric Thielot (pers. comm. from Dave May)
+         */
+        std::vector<Point<3>> centers;
+
+        /**
+         * Parameters for evaluating viscosity
+         */
+        double delta;
+        double omega;
+
+        /**
+         * Return a factor that indicates whether a point is inside or
+         * outside the sinker spheres. The function can be thought of
+         * as a 1 (outside) vs 0 (inside) factor, but is in reality a
+         * smoothed version of this that takes into account the
+         * distance from the centers of the sinkers.
+         */
+        double inside_outside_factor (const Point<dim> &p) const;
+    };
+
+
+    template <int dim>
+    NSinkerMaterial<dim>::NSinkerMaterial ()
+    {
+      delta = 2*200.0;
+      omega = 2*0.1;
+
+      // The original 75 randomly placed sinkers from the nsinker benchmark:
+      centers.resize(75);
+      centers[0] = Point<3>(2.4257829890e-01, 1.3469574514e-02, 3.8313885004e-01);
+      centers[1] = Point<3>(4.1465269048e-01, 6.7768972864e-02, 9.9312692973e-01);
+      centers[2] = Point<3>(4.8430804651e-01, 7.6533776604e-01, 3.1833815403e-02);
+      centers[3] = Point<3>(3.0935481671e-02, 9.3264044027e-01, 8.8787953411e-01);
+      centers[4] = Point<3>(5.9132973039e-01, 4.7877868473e-01, 8.3335433660e-01);
+      centers[5] = Point<3>(1.8633519681e-01, 7.3565270739e-01, 1.1505317181e-01);
+      centers[6] = Point<3>(6.9865863058e-01, 3.5560411138e-01, 6.3830000658e-01);
+      centers[7] = Point<3>(9.0821050755e-01, 2.9400041480e-01, 2.6497158886e-01);
+      centers[8] = Point<3>(3.7749399775e-01, 5.4162011554e-01, 9.2818150340e-03);
+      centers[9] = Point<3>(8.5247022139e-01, 4.6701098395e-01, 5.3607231962e-02);
+      centers[10] = Point<3>(9.7674759057e-01, 1.9675474344e-01, 8.5697294067e-01);
+      centers[11] = Point<3>(1.4421375987e-01, 8.0066218823e-01, 7.2939761948e-01);
+      centers[12] = Point<3>(9.8579064709e-01, 1.8340570954e-01, 4.9976021075e-01);
+      centers[13] = Point<3>(4.6986202126e-01, 9.7099129947e-01, 4.5077026191e-01);
+      centers[14] = Point<3>(9.5791877292e-02, 9.7408164664e-01, 3.9023506101e-01);
+      centers[15] = Point<3>(6.8067035576e-01, 2.6669318800e-02, 2.3124107450e-01);
+      centers[16] = Point<3>(4.6873909443e-01, 9.7960100555e-02, 4.1541002524e-01);
+      centers[17] = Point<3>(7.9629418710e-01, 3.1640260216e-01, 7.7853444953e-01);
+      centers[18] = Point<3>(8.2849331472e-01, 4.8714042059e-01, 3.6904878000e-01);
+      centers[19] = Point<3>(6.0284549678e-01, 2.4264360789e-02, 8.1111178631e-01);
+      centers[20] = Point<3>(3.5579259291e-01, 8.0610905439e-01, 2.7487712366e-01);
+      centers[21] = Point<3>(8.5981739865e-01, 9.5101905612e-01, 7.7727618477e-01);
+      centers[22] = Point<3>(6.8083745971e-01, 8.3518540665e-01, 9.6112961413e-01);
+      centers[23] = Point<3>(7.0542474869e-01, 7.3751226102e-02, 5.3685709440e-01);
+      centers[24] = Point<3>(9.5718558131e-01, 4.1806501915e-01, 4.1877679639e-01);
+      centers[25] = Point<3>(3.8161700050e-01, 8.3692747440e-01, 2.4006224854e-01);
+      centers[26] = Point<3>(7.2621119848e-01, 4.3161282150e-01, 1.1669089744e-01);
+      centers[27] = Point<3>(2.2391322592e-01, 3.0958795748e-01, 2.4480139429e-01);
+      centers[28] = Point<3>(3.7703382754e-01, 8.0753940242e-01, 3.1473643301e-01);
+      centers[29] = Point<3>(7.7522956709e-01, 2.8333410774e-01, 9.9634871585e-01);
+      centers[30] = Point<3>(6.3286731189e-01, 6.0091089904e-01, 5.0948022423e-01);
+      centers[31] = Point<3>(8.3412860373e-01, 1.9944285005e-01, 3.5980841627e-02);
+      centers[32] = Point<3>(7.3000523063e-01, 1.9791117972e-01, 2.9319749786e-01);
+      centers[33] = Point<3>(7.7034656693e-01, 2.1475035521e-01, 3.0922000730e-01);
+      centers[34] = Point<3>(6.0662675677e-02, 5.5759010630e-01, 4.1691651960e-01);
+      centers[35] = Point<3>(1.1594487686e-01, 6.8554530558e-01, 9.5995079957e-01);
+      centers[36] = Point<3>(2.7973348288e-02, 1.4806467395e-01, 5.2297503060e-01);
+      centers[37] = Point<3>(6.4133927209e-01, 9.8914607800e-01, 5.7813295237e-01);
+      centers[38] = Point<3>(6.8053043246e-01, 6.7497840462e-01, 3.6204645148e-01);
+      centers[39] = Point<3>(9.1470996426e-01, 5.3036934674e-01, 9.1761070439e-01);
+      centers[40] = Point<3>(2.8310876353e-01, 2.0898862472e-01, 4.7181570645e-01);
+      centers[41] = Point<3>(8.0657831198e-01, 1.6168943288e-01, 5.1429839456e-01);
+      centers[42] = Point<3>(8.1311740159e-01, 6.4168478858e-02, 4.7962416312e-01);
+      centers[43] = Point<3>(4.3309508843e-02, 9.0291512474e-01, 2.9450144167e-01);
+      centers[44] = Point<3>(6.8573011443e-01, 6.6033273035e-02, 8.2121989495e-01);
+      centers[45] = Point<3>(2.4277445452e-01, 3.1025718772e-01, 4.9255406554e-01);
+      centers[46] = Point<3>(3.5617944848e-01, 3.0799053857e-01, 3.9698166931e-01);
+      centers[47] = Point<3>(7.0916077621e-02, 8.8651657239e-01, 6.8403214295e-01);
+      centers[48] = Point<3>(5.2822650202e-01, 9.0281945043e-01, 6.8650344000e-01);
+      centers[49] = Point<3>(6.3316007640e-02, 1.5214040370e-01, 2.3765034985e-02);
+      centers[50] = Point<3>(4.1894298765e-01, 1.7479340461e-01, 7.5275125343e-01);
+      centers[51] = Point<3>(4.9031640053e-01, 7.4774375406e-01, 3.2927456281e-01);
+      centers[52] = Point<3>(1.1757708859e-01, 1.1812786251e-01, 3.7498524244e-01);
+      centers[53] = Point<3>(3.7696964032e-01, 7.2874483733e-01, 1.4480990830e-02);
+      centers[54] = Point<3>(3.8201288152e-01, 4.9049964756e-01, 8.2757658503e-01);
+      centers[55] = Point<3>(7.9664661586e-02, 9.2396727806e-01, 1.1804237828e-01);
+      centers[56] = Point<3>(9.3825167927e-01, 1.9597347043e-01, 7.2611756191e-01);
+      centers[57] = Point<3>(8.5786301170e-01, 1.0363770514e-01, 8.3891028205e-01);
+      centers[58] = Point<3>(5.6511039453e-01, 8.1040084307e-01, 4.0696941614e-01);
+      centers[59] = Point<3>(9.3497714490e-01, 1.6087440083e-01, 8.1605472361e-01);
+      centers[60] = Point<3>(4.3173963829e-01, 2.4810082244e-01, 8.3052277138e-01);
+      centers[61] = Point<3>(5.9621858625e-01, 6.4577903070e-01, 6.0816894547e-01);
+      centers[62] = Point<3>(4.9546643556e-01, 3.0438243752e-01, 7.5562733447e-01);
+      centers[63] = Point<3>(8.2861043319e-01, 4.5555055302e-01, 4.3814466774e-01);
+      centers[64] = Point<3>(8.9743076959e-01, 1.1894442752e-01, 9.8993320995e-02);
+      centers[65] = Point<3>(6.9884936497e-01, 5.6127713367e-01, 3.8478565932e-01);
+      centers[66] = Point<3>(9.2576270966e-02, 9.2938612771e-01, 1.9264837596e-01);
+      centers[67] = Point<3>(8.4125479722e-01, 9.6937695284e-01, 3.1844636161e-01);
+      centers[68] = Point<3>(1.2799954700e-01, 2.8838638276e-01, 9.0993508972e-01);
+      centers[69] = Point<3>(2.7905288352e-01, 4.1813262758e-02, 7.5550716964e-01);
+      centers[70] = Point<3>(8.0900019305e-01, 8.6624463269e-01, 9.7354159503e-01);
+      centers[71] = Point<3>(3.1358765965e-01, 4.6779574243e-01, 2.4304298462e-01);
+      centers[72] = Point<3>(8.2344259034e-01, 5.9961585635e-01, 7.4369772512e-01);
+      centers[73] = Point<3>(3.2766604253e-01, 8.3176720460e-02, 9.5114077951e-01);
+      centers[74] = Point<3>(8.2308128282e-01, 5.2712029523e-01, 3.1080186614e-01);
+
+      // First rescale their location from [0,1] to [-1,1]:
+      for (auto &p: centers)
+        for (int d=0; d<3; ++d)
+          p[d] = p[d]*2.0-1.0;
+
+      // Now erase all points with center outside our shell. This
+      // means some of them are not fully inside the domain, but this is ok.
+      auto e = std::remove_if(centers.begin(), centers.end(), [](const Point<3> &p)
+      {
+        return (p.norm()<0.54) || (p.norm()>1.0);
+      });
+      centers.erase(e, centers.end());
+    }
+
+
+
+    template <>
+    double
+    NSinkerMaterial<2>::inside_outside_factor (const Point<2> &p) const
+    {
+      double chi = 1.0;
+
+      for (unsigned int s=0; s<n_sinkers; ++s)
+        {
+          double dist = p.distance(Point<2>(centers[s](0), centers[s](1)));
+          double temp = 1-std::exp(-delta*
+                                   std::pow(std::max(0.0,dist-omega/2.0),2));
+          chi *= temp;
+        }
+      return chi;
+    }
+
+
+
+    template <>
+    double
+    NSinkerMaterial<3>::inside_outside_factor (const Point<3> &p) const
+    {
+      double chi = 1.0;
+
+      for (unsigned int s=0; s<n_sinkers; ++s)
+        {
+          double dist = p.distance(centers[s]);
+          double temp = 1-std::exp(-delta*
+                                   std::pow(std::max(0.0,dist-omega/2.0),2));
+          chi *= temp;
+        }
+      return chi;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace NSinkerBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(NSinkerMaterial,
+                                   "nsinker",
+                                   "A material model that corresponds to the 'Spherical Shell NSinker' benchmark.")
+  }
+}
diff --git a/benchmarks/onset-of-convection/convection-box-base.prm.bak b/benchmarks/onset-of-convection/convection-box-base.prm.bak
new file mode 100644
index 00000000000..b8a879461ee
--- /dev/null
+++ b/benchmarks/onset-of-convection/convection-box-base.prm.bak
@@ -0,0 +1,94 @@
+# This is the 'base' input file from which additional input files are generated
+# for the onset of convection example in:
+# benchmarks/onset-of-convection/onset-of-convection.ipynb.
+# UPPERCASE strings are replaced automatically by the python script
+# with appropriate values for each model run. This .prm file will fail if run
+# without substituting appropriate values for each UPPERCASE string.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use conduction timestep                = true
+
+subsection Termination criteria
+  set Termination criteria                 = end step
+  set End step                 = 1
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = WIDTH
+    set Y extent = HEIGHT
+    set X repetitions = NX
+    set Y repetitions = NY
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=PMAG, L=WIDTH,H=HEIGHT, pi=3.1415926536, k=2
+    set Function expression = DELTA_T*(1.0-z/H) - p*cos(k*pi*x/L)*sin(pi*z/H)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = DELTA_T
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = GRAVITY
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = DENSITY
+    set Reference specific heat       = SPECIFIC_HEAT
+    set Reference temperature         = 0
+    set Thermal conductivity          = KTHERMAL
+    set Thermal expansion coefficient = ALPHA
+    set Viscosity                     = VISCOSITY
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = IREF
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, point values
+
+  subsection Point values
+    set Evaluation points = EVALUATION_POINTS
+  end
+end
diff --git a/benchmarks/operator_splitting/advection_reaction/advection_reaction.base.prm.bak b/benchmarks/operator_splitting/advection_reaction/advection_reaction.base.prm.bak
new file mode 100644
index 00000000000..2dc0f08dadb
--- /dev/null
+++ b/benchmarks/operator_splitting/advection_reaction/advection_reaction.base.prm.bak
@@ -0,0 +1,149 @@
+#########################################################
+# This is a benchmark case that tests the operator split
+# solver scheme, which can use a different time step to
+# compute reactions between compositional fields than
+# the time step used for advection.
+# In comparison to the example 'exponential_decay', the
+# initial comosition depends on x, and there is a constant
+# horizontal velocity. The composition decays over time,
+# following the equations for exponential decay with a decay
+# rate that depends on y.
+
+set Additional shared libraries = ./libadvection_reaction.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+# We use a new solver scheme option that enables the operator split.
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Use operator splitting                 = true
+set Maximum time step                      = 1
+
+# As we split the time-stepping of advection and reactions,
+# there are now two different time steps in the model:
+# We control the advection time step using the 'Maximum time step'
+# parameter (for easy comparison with the exponential decay test
+# case), and the reaction time step using the 'Reaction time step'
+# parameter. We will vary both parameters in different model runs.
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction time step                 = 0.0005
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.0
+    set cR = 0.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+# The velocity on all boundaries is prescribed to a constant
+# value, leading to horizontal flow from left to right.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  =
+    set Function expression = 0.01;0.0
+  end
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+# For this model, we choose a sinusoidal initial temperature
+# and composition, so that we can see how the field changes
+# over time as it is advected and decays over time.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = sin(2*pi*x)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = sin(2*pi*x)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0
+  set List of model names = ExponentialDecayBoundary
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = 0
+  set List of model names = ExponentialDecayBoundary
+end
+
+# We choose material and heating models that let temperature
+# and composition decay over time, and that is implemented in
+# a plugin.
+subsection Heating model
+  set List of model names = exponential decay heating
+
+  subsection Exponential decay heating
+    set Half life = 10
+  end
+end
+
+subsection Material model
+  set Model name = exponential decay
+
+  subsection Exponential decay
+    set Half life = 10
+  end
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1e5
+    set Density differential for compositional field 1 = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization, ExponentialDecayPostprocessor
+
+  subsection Visualization
+    set Time between graphical output = 0
+  end
+end
diff --git a/benchmarks/operator_splitting/advection_reaction/advection_reaction.cc.bak b/benchmarks/operator_splitting/advection_reaction/advection_reaction.cc.bak
new file mode 100644
index 00000000000..3fb6fcdf568
--- /dev/null
+++ b/benchmarks/operator_splitting/advection_reaction/advection_reaction.cc.bak
@@ -0,0 +1,502 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <deal.II/base/function_lib.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_composition/interface.h>
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/melt.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/numerics/vector_tools.h>
+
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class ExponentialDecay : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+        static void declare_parameters (ParameterHandler &prm);
+        void parse_parameters(ParameterHandler &prm) override;
+
+        bool is_compressible () const override;
+
+        void create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+      private:
+
+        /**
+         * Pointer to the material model used as the base model
+         */
+        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
+
+        /**
+         * Parameters determining the initial decay rate.
+         */
+        double half_life;
+    };
+  }
+
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class ExponentialDecayHeating : public HeatingModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        static void declare_parameters (ParameterHandler &prm);
+
+        void parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Parameter determining the decay rate.
+         */
+        double half_life;
+    };
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    bool
+    ExponentialDecay<dim>::
+    is_compressible () const
+    {
+      return base_model->is_compressible();
+    }
+
+
+    template <int dim>
+    void
+    ExponentialDecay<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      AssertThrow(this->introspection().n_compositional_fields == 1,
+                  ExcMessage("Exponential decay model needs exactly one compositional field."));
+
+      // Fill material model outputs using the base model.
+      base_model->evaluate(in,out);
+      const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+      for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
+        for (unsigned int c=0; c < this->introspection().n_compositional_fields; ++c)
+          out.reaction_terms[q][c] = 0.0;
+
+      // fill melt reaction rates if they exist
+      ReactionRateOutputs<dim> *reaction_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
+
+      if (reaction_out != nullptr)
+        {
+          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
+            {
+              // dC/dt = - z * lambda * C
+              const double decay_constant = half_life > 0.0 ? log(2.0) / half_life : 0.0;
+              const double z = in.position[q](1);
+              reaction_out->reaction_rates[q][0] = - decay_constant * z / time_scale * in.composition[q][0];
+            }
+        }
+    }
+
+
+    template <int dim>
+    void
+    ExponentialDecay<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Exponential decay");
+        {
+          prm.declare_entry("Base model","composition reaction",
+                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
+                            "The name of a material model that will be modified by a position "
+                            "dependent melting rate. Valid values for this parameter "
+                            "are the names of models that are also valid for the "
+                            "``Material models/Model name'' parameter. See the documentation for "
+                            "that for more information.");
+          prm.declare_entry ("Half life", "0",
+                             Patterns::Double (0),
+                             "Time required for a compositional field to reduce to half its "
+                             "initial value. Units: Years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    ExponentialDecay<dim>::
+    parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Exponential decay");
+        {
+          AssertThrow( prm.get("Base model") != "reaction rate function",
+                       ExcMessage("You may not use ``reaction rate function'' as the base model for "
+                                  "a reaction rate function model.") );
+
+          // create the base model and initialize its SimulatorAccess base
+          // class; it will get a chance to read its parameters below after we
+          // leave the current section
+          base_model = create_material_model<dim>(prm.get("Base model"));
+          if (auto s = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
+            s->initialize_simulator (this->get_simulator());
+
+          half_life              = prm.get_double ("Half life");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // After parsing the parameters for the exponential decay material model,
+      // also parse the parameters related to the base model.
+      base_model->parse_parameters(prm);
+      this->model_dependence = base_model->get_model_dependence();
+    }
+
+
+    template <int dim>
+    void
+    ExponentialDecay<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
+        }
+    }
+  }
+
+
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    ExponentialDecayHeating<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
+              const MaterialModel::MaterialModelOutputs<dim> & /*out*/,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == in.n_evaluation_points(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          // dC/dt = - z * lambda * C
+          const double decay_constant = half_life > 0.0 ? log(2.0) / half_life : 0.0;
+          const double z = in.position[q](1);
+          heating_model_outputs.rates_of_temperature_change[q] = - decay_constant * z / time_scale * in.composition[q][0];
+
+          heating_model_outputs.heating_source_terms[q] = 0.0;
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+    template <int dim>
+    void
+    ExponentialDecayHeating<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Exponential decay heating");
+        {
+          prm.declare_entry ("Half life", "0",
+                             Patterns::Double (0),
+                             "Time required for the temperature to reduce to half of its "
+                             "initial value. Units: Years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ExponentialDecayHeating<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Exponential decay heating");
+        {
+          half_life              = prm.get_double ("Half life");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(dim+3) {}
+
+      void vector_value (const Point<dim>   &p,
+                         Vector<double>   &values) const override
+      {
+        double x = p(0);
+        double z = p(1);
+        double t = this->get_time();
+
+        values[0] = 0.0; // velocity x
+        values[1] = 0.0; // velocity z
+        values[2] = 0.0; // pressure
+        values[3] = sin(2*numbers::PI*(x-t*0.01))*exp(-log(2.0)/10.0*z*t); // temperature
+        values[4] = sin(2*numbers::PI*(x-t*0.01))*exp(-log(2.0)/10.0*z*t); // composition
+      }
+  };
+
+
+
+  template <int dim>
+  class ExponentialDecayBoundary : public BoundaryComposition::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Return the boundary composition as a function of position.
+       */
+      double
+      boundary_composition (const types::boundary_id boundary_indicator,
+                            const Point<dim> &position,
+                            const unsigned int compositional_field) const override;
+  };
+
+
+  template <int dim>
+  double
+  ExponentialDecayBoundary<dim>::
+  boundary_composition (const types::boundary_id /*boundary_indicator*/,
+                        const Point<dim> &p,
+                        const unsigned int /*compositional_field*/) const
+  {
+    double x = p(0);
+    double z = p(1);
+    const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+    double t = this->get_time() / time_scale;
+
+    return sin(2*numbers::PI*(x-t*0.01))*exp(-log(2.0)/10.0*z*t);
+  }
+
+
+
+  template <int dim>
+  class ExponentialDecayBoundaryTemperature : public BoundaryTemperature::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Return the boundary composition as a function of position.
+       */
+      double
+      boundary_temperature (const types::boundary_id boundary_indicator,
+                            const Point<dim> &position) const override;
+
+      double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+      double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+  };
+
+
+  template <int dim>
+  double
+  ExponentialDecayBoundaryTemperature<dim>::
+  boundary_temperature (const types::boundary_id /*boundary_indicator*/,
+                        const Point<dim> &p) const
+  {
+    double x = p(0);
+    double z = p(1);
+    const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+    double t = this->get_time() / time_scale;
+
+    return sin(2*numbers::PI*(x-t*0.01))*exp(-log(2.0)/10.0*z*t);
+  }
+
+  template <int dim>
+  double
+  ExponentialDecayBoundaryTemperature<dim>::
+  minimal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
+  {
+    return 0.0;
+  }
+
+
+
+  template <int dim>
+  double
+  ExponentialDecayBoundaryTemperature<dim>::
+  maximal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
+  {
+    return 1.0;
+  }
+
+
+
+  /**
+     * A postprocessor that evaluates the accuracy of the solution
+     * by using the L2 norm.
+     */
+  template <int dim>
+  class ExponentialDecayPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      ExponentialDecayPostprocessor();
+
+      /**
+       * Generate graphical output from the current solution.
+       */
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics) override;
+
+      double max_error;
+      double max_error_T;
+  };
+
+  template <int dim>
+  ExponentialDecayPostprocessor<dim>::ExponentialDecayPostprocessor ()
+  {
+    max_error = 0.0;
+    max_error_T = 0.0;
+  }
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  ExponentialDecayPostprocessor<dim>::execute (TableHandler & /*statistics*/)
+  {
+    AssertThrow (this->n_compositional_fields() == 1, ExcInternalError());
+
+    RefFunction<dim> ref_func;
+    ref_func.set_time(this->get_time());
+
+    const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.velocities).degree+2);
+
+    const unsigned int n_total_comp = this->introspection().n_components;
+
+    Vector<float> cellwise_errors_composition (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_temperature (this->get_triangulation().n_active_cells());
+
+    ComponentSelectFunction<dim> comp_C(this->introspection().component_indices.compositional_fields[0], n_total_comp);
+    ComponentSelectFunction<dim> comp_T(this->introspection().component_indices.temperature, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_composition,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_C);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_temperature,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_T);
+
+    const double current_error = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_composition, VectorTools::L2_norm);
+    max_error = std::max(max_error, current_error);
+
+    const double current_error_T = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_temperature, VectorTools::L2_norm);
+    max_error_T = std::max(max_error_T, current_error_T);
+
+    std::ostringstream os;
+    os << std::scientific
+       << "time=" << this->get_time()
+       << " ndofs= " << this->get_solution().size()
+       << " C_L2_current= " << current_error
+       << " C_L2_max= " << max_error
+       << " T_L2_current= " << current_error_T
+       << " T_L2_max= " << max_error_T
+       ;
+
+    return std::make_pair("Errors", os.str());
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ExponentialDecay,
+                                   "exponential decay",
+                                   "A material model that can be derived from any of the other "
+                                   "material model and that will replace the reaction rate by a "
+                                   "function that models exponential decay. The half life can be "
+                                   "chosen as an input parameter.")
+  }
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(ExponentialDecayHeating,
+                                  "exponential decay heating",
+                                  "A heating model that will use a model for exponential decay as "
+                                  "the heating reaction rate. The half life can be chosen as an "
+                                  "input parameter.")
+
+  }
+  ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(ExponentialDecayBoundary,
+                                             "ExponentialDecayBoundary",
+                                             "A boundary composition model that prescribes the analytical "
+                                             "solution for an initially sinusoidal field that is advected "
+                                             "and decays over time.")
+
+  ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(ExponentialDecayBoundaryTemperature,
+                                             "ExponentialDecayBoundary",
+                                             "A boundary composition model that prescribes the analytical "
+                                             "solution for an initially sinusoidal field that is advected "
+                                             "and decays over time.")
+
+  ASPECT_REGISTER_POSTPROCESSOR(ExponentialDecayPostprocessor,
+                                "ExponentialDecayPostprocessor",
+                                "A postprocessor that compares the solution "
+                                "to the analytical solution for exponential decay.")
+}
diff --git a/benchmarks/operator_splitting/doc/exponential_decay.part.1.prm.bak b/benchmarks/operator_splitting/doc/exponential_decay.part.1.prm.bak
new file mode 100644
index 00000000000..767dd3beb7d
--- /dev/null
+++ b/benchmarks/operator_splitting/doc/exponential_decay.part.1.prm.bak
@@ -0,0 +1,15 @@
+set Additional shared libraries = ./libexponential_decay.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 100
+
+# We use a new solver scheme option that enables the operator split.
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Use operator splitting                 = true
+set Maximum time step                      = 10
+
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction time step                 = 0.0005
+  end
+end
diff --git a/benchmarks/operator_splitting/doc/exponential_decay.part.2.prm.bak b/benchmarks/operator_splitting/doc/exponential_decay.part.2.prm.bak
new file mode 100644
index 00000000000..7a74c690dce
--- /dev/null
+++ b/benchmarks/operator_splitting/doc/exponential_decay.part.2.prm.bak
@@ -0,0 +1,38 @@
+# Both initial temperature and composition are set to 1,
+# and will decay starting from this value.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1.0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1.0
+  end
+end
+
+# We choose material and heating models that let temperature
+# and composition decay over time, and that is implemented in
+# a plugin.
+subsection Heating model
+  set List of model names = exponential decay heating
+
+  subsection Exponential decay heating
+    set Half life = 10
+  end
+end
+
+subsection Material model
+  set Model name = exponential decay
+
+  subsection Exponential decay
+    set Half life = 10
+  end
+end
diff --git a/benchmarks/operator_splitting/exponential_decay/exponential_decay.base.prm.bak b/benchmarks/operator_splitting/exponential_decay/exponential_decay.base.prm.bak
new file mode 100644
index 00000000000..f2b055294b7
--- /dev/null
+++ b/benchmarks/operator_splitting/exponential_decay/exponential_decay.base.prm.bak
@@ -0,0 +1,121 @@
+#########################################################
+# This is a benchmark case that tests the operator split
+# solver scheme, which can use a different time step to
+# compute reactions between compositional fields than
+# the time step used for advection.
+# In this test case, there is no advection, and we start
+# from a composition (and temperature) that is 1 everywhere
+# in the domain and then decays over time, following the
+# equations for exponential decay.
+
+# We use a plugin that implements the reactions for exponential
+# decay.
+set Additional shared libraries = ./libexponential_decay.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 100
+set Use years in output instead of seconds = false
+
+# We use a new solver scheme option that enables the operator split.
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Use operator splitting                 = true
+set Maximum time step                      = 10
+
+# As we split the time-stepping of advection and reactions,
+# there are now two different time steps in the model:
+# We control the advection time step using the 'Maximum time step'
+# parameter (as this benchmark has no driving force, and hence very
+# low velocities, we can not use the CFL number), and the reaction
+# time step using the 'Reaction time step' parameter.
+# We will vary both parameters in different model runs.
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction time step                 = 0.0005
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+# Both initial temperature and composition are set to 1,
+# and will decay starting from this value.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1.0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1.0
+  end
+end
+
+# We choose material and heating models that let temperature
+# and composition decay over time, and that is implemented in
+# a plugin.
+subsection Heating model
+  set List of model names = exponential decay heating
+
+  subsection Exponential decay heating
+    set Half life = 10
+  end
+end
+
+subsection Material model
+  set Model name = exponential decay
+
+  subsection Exponential decay
+    set Half life = 10
+  end
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1e5
+    set Density differential for compositional field 1 = 0
+  end
+end
+
+# As composition and temperature do not depend on x or y,
+# we can use a coarse resolution.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+# We output some statistics about the composition, and make
+# use of a postprocessor that computes errors compared to the
+# analytical solution for exponential decay.
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization, ExponentialDecayPostprocessor
+
+  subsection Visualization
+    set Time between graphical output = 0
+  end
+end
diff --git a/benchmarks/operator_splitting/exponential_decay/exponential_decay.cc.bak b/benchmarks/operator_splitting/exponential_decay/exponential_decay.cc.bak
new file mode 100644
index 00000000000..d856eec21fb
--- /dev/null
+++ b/benchmarks/operator_splitting/exponential_decay/exponential_decay.cc.bak
@@ -0,0 +1,402 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <deal.II/base/function_lib.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/melt.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/numerics/vector_tools.h>
+
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class ExponentialDecay : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        static void declare_parameters (ParameterHandler &prm);
+
+        void parse_parameters(ParameterHandler &prm) override;
+
+        bool is_compressible () const override;
+
+        void create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+      private:
+
+        /**
+         * Pointer to the material model used as the base model
+         */
+        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
+
+        /**
+         * Parameter determining the decay rate.
+         */
+        double half_life;
+    };
+  }
+
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class ExponentialDecayHeating : public HeatingModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        static void declare_parameters (ParameterHandler &prm);
+
+        void parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Parameter determining the decay rate.
+         */
+        double half_life;
+    };
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    bool
+    ExponentialDecay<dim>::
+    is_compressible () const
+    {
+      return base_model->is_compressible();
+    }
+
+
+    template <int dim>
+    void
+    ExponentialDecay<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      AssertThrow(this->introspection().n_compositional_fields == 1,
+                  ExcMessage("Exponential decay model needs exactly one compositional field."));
+
+      // Fill material model outputs using the base model.
+      base_model->evaluate(in,out);
+      const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+      for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
+        for (unsigned int c=0; c < this->introspection().n_compositional_fields; ++c)
+          out.reaction_terms[q][c] = 0.0;
+
+      // fill melt reaction rates if they exist
+      ReactionRateOutputs<dim> *reaction_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
+
+      if (reaction_out != nullptr)
+        {
+          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
+            {
+              // dC/dt = - lambda * C
+              const double decay_constant = half_life > 0.0 ? log(2.0) / half_life : 0.0;
+              reaction_out->reaction_rates[q][0] = - decay_constant / time_scale * in.composition[q][0];
+            }
+        }
+    }
+
+
+    template <int dim>
+    void
+    ExponentialDecay<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Exponential decay");
+        {
+          prm.declare_entry("Base model","composition reaction",
+                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
+                            "The name of a material model that will be modified by a position "
+                            "dependent melting rate. Valid values for this parameter "
+                            "are the names of models that are also valid for the "
+                            "``Material models/Model name'' parameter. See the documentation for "
+                            "that for more information.");
+          prm.declare_entry ("Half life", "0",
+                             Patterns::Double (0),
+                             "Time required for a compositional field to reduce to half its "
+                             "initial value. Units: Years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    ExponentialDecay<dim>::
+    parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Exponential decay");
+        {
+          AssertThrow( prm.get("Base model") != "reaction rate function",
+                       ExcMessage("You may not use ``reaction rate function'' as the base model for "
+                                  "a reaction rate function model.") );
+
+          // create the base model and initialize its SimulatorAccess base
+          // class; it will get a chance to read its parameters below after we
+          // leave the current section
+          base_model = create_material_model<dim>(prm.get("Base model"));
+          if (auto s = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
+            s->initialize_simulator (this->get_simulator());
+
+          half_life              = prm.get_double ("Half life");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // After parsing the parameters for the exponential decay material model,
+      // also parse the parameters related to the base model.
+      base_model->parse_parameters(prm);
+      this->model_dependence = base_model->get_model_dependence();
+    }
+
+
+    template <int dim>
+    void
+    ExponentialDecay<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
+        }
+    }
+  }
+
+
+
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    ExponentialDecayHeating<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
+              const MaterialModel::MaterialModelOutputs<dim> & /*out*/,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == in.n_evaluation_points(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          // dC/dt = - lambda * C
+          const double decay_constant = half_life > 0.0 ? log(2.0) / half_life : 0.0;
+          heating_model_outputs.rates_of_temperature_change[q] = - decay_constant / time_scale * in.composition[q][0];
+
+          heating_model_outputs.heating_source_terms[q] = 0.0;
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+    template <int dim>
+    void
+    ExponentialDecayHeating<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Exponential decay heating");
+        {
+          prm.declare_entry ("Half life", "0",
+                             Patterns::Double (0),
+                             "Time required for the temperature to reduce to half of its "
+                             "initial value. Units: Years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ExponentialDecayHeating<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Exponential decay heating");
+        {
+          half_life              = prm.get_double ("Half life");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(dim+3) {}
+      void vector_value (const Point<dim> &/*position*/,
+                         Vector<double>   &values) const override
+      {
+        values[0] = 0.0; // velocity x
+        values[1] = 0.0; // velocity z
+        values[2] = 0.0; // pressure
+        values[3] = exp(-log(2.0)/10.0*this->get_time()); // temperature
+        values[4] = exp(-log(2.0)/10.0*this->get_time()); // composition
+      }
+  };
+
+
+
+  /**
+     * A postprocessor that evaluates the accuracy of the solution
+     * by using the L2 norm.
+     */
+  template <int dim>
+  class ExponentialDecayPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      ExponentialDecayPostprocessor();
+
+      /**
+       * Generate graphical output from the current solution.
+       */
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics) override;
+
+      double max_error;
+      double max_error_T;
+  };
+
+  template <int dim>
+  ExponentialDecayPostprocessor<dim>::ExponentialDecayPostprocessor ()
+  {
+    max_error = 0.0;
+    max_error_T = 0.0;
+  }
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  ExponentialDecayPostprocessor<dim>::execute (TableHandler & /*statistics*/)
+  {
+    AssertThrow (this->n_compositional_fields() == 1, ExcInternalError());
+
+    RefFunction<dim> ref_func;
+    ref_func.set_time(this->get_time());
+
+    const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.velocities).degree+2);
+
+    const unsigned int n_total_comp = this->introspection().n_components;
+
+    Vector<float> cellwise_errors_composition (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_temperature (this->get_triangulation().n_active_cells());
+
+    ComponentSelectFunction<dim> comp_C(this->introspection().component_indices.compositional_fields[0], n_total_comp);
+    ComponentSelectFunction<dim> comp_T(this->introspection().component_indices.temperature, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_composition,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_C);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_temperature,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_T);
+
+    const double current_error = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_composition, VectorTools::L2_norm);
+    max_error = std::max(max_error, current_error);
+
+    const double current_error_T = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_temperature, VectorTools::L2_norm);
+    max_error_T = std::max(max_error_T, current_error_T);
+
+    std::ostringstream os;
+    os << std::scientific
+       << "time=" << this->get_time()
+       << " ndofs= " << this->get_solution().size()
+       << " C_L2_current= " << current_error
+       << " C_L2_max= " << max_error
+       << " T_L2_current= " << current_error_T
+       << " T_L2_max= " << max_error_T
+       ;
+
+    return std::make_pair("Errors", os.str());
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ExponentialDecay,
+                                   "exponential decay",
+                                   "A material model that can be derived from any of the other "
+                                   "material model and that will replace the reaction rate by a "
+                                   "function that models exponential decay. The half life can be "
+                                   "chosen as an input parameter.")
+
+  }
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(ExponentialDecayHeating,
+                                  "exponential decay heating",
+                                  "A heating model that will use a model for exponential decay as "
+                                  "the heating reaction rate. The half life can be chosen as an "
+                                  "input parameter.")
+
+  }
+  ASPECT_REGISTER_POSTPROCESSOR(ExponentialDecayPostprocessor,
+                                "ExponentialDecayPostprocessor",
+                                "A postprocessor that compares the solution "
+                                "to the analytical solution for exponential decay.")
+}
diff --git a/benchmarks/particle_integration_scheme/circle.prm b/benchmarks/particle_integration_scheme/circle.prm
index 83ac384ab47..3b7a17da328 100644
--- a/benchmarks/particle_integration_scheme/circle.prm
+++ b/benchmarks/particle_integration_scheme/circle.prm
@@ -5,7 +5,7 @@ set Use years in output instead of seconds = false
 set CFL number                             = 1.0
 set Output directory                       = circle_euler_1.0
 set Timing output frequency                = 100
-set Nonlinear solver scheme                = Advection only
+set Nonlinear solver scheme                = single Advection, no Stokes
 
 subsection Geometry model
   set Model name = box
diff --git a/benchmarks/particle_integration_scheme/circle.prm.bak b/benchmarks/particle_integration_scheme/circle.prm.bak
new file mode 100644
index 00000000000..83ac384ab47
--- /dev/null
+++ b/benchmarks/particle_integration_scheme/circle.prm.bak
@@ -0,0 +1,78 @@
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1.0
+set Use years in output instead of seconds = false
+set CFL number                             = 1.0
+set Output directory                       = circle_euler_1.0
+set Timing output frequency                = 100
+set Nonlinear solver scheme                = Advection only
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 4
+    set Y extent = 4
+    set Box origin X coordinate = -2
+    set Box origin Y coordinate = -2
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function expression = 2 * pi * (1+0.0*sin(t))*-y; 2 * pi * (1+0.0*sin(t))*x
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Particle generator name = ascii file
+  set Integration scheme = rk2
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/particle_integration_scheme/
+      set Data file name = particle.dat
+    end
+  end
+end
diff --git a/benchmarks/particle_integration_scheme/euler.part.prm.bak b/benchmarks/particle_integration_scheme/euler.part.prm.bak
new file mode 100644
index 00000000000..bc430c393c8
--- /dev/null
+++ b/benchmarks/particle_integration_scheme/euler.part.prm.bak
@@ -0,0 +1,6 @@
+subsection Postprocess
+end
+
+subsection Particles
+  set Integration scheme = euler
+end
diff --git a/benchmarks/particle_integration_scheme/rk2.part.prm.bak b/benchmarks/particle_integration_scheme/rk2.part.prm.bak
new file mode 100644
index 00000000000..f68ef89b515
--- /dev/null
+++ b/benchmarks/particle_integration_scheme/rk2.part.prm.bak
@@ -0,0 +1,6 @@
+subsection Postprocess
+end
+
+subsection Particles
+  set Integration scheme = rk2
+end
diff --git a/benchmarks/particle_integration_scheme/rk4.part.prm.bak b/benchmarks/particle_integration_scheme/rk4.part.prm.bak
new file mode 100644
index 00000000000..1158abaf34f
--- /dev/null
+++ b/benchmarks/particle_integration_scheme/rk4.part.prm.bak
@@ -0,0 +1,6 @@
+subsection Postprocess
+end
+
+subsection Particles
+  set Integration scheme = rk4
+end
diff --git a/benchmarks/polydiapirs/polydiapirs.prm.bak b/benchmarks/polydiapirs/polydiapirs.prm.bak
new file mode 100644
index 00000000000..b473530e640
--- /dev/null
+++ b/benchmarks/polydiapirs/polydiapirs.prm.bak
@@ -0,0 +1,96 @@
+# This is the setup of a polydiapirs experiment, i.e.
+# multiwavelength gravity structures.
+# It consists of three layers of Newtonian fluids
+# set in motion by gravitational instability, as in
+# case II of Weinberg and Schmeling 1992.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 250
+set Use years in output instead of seconds = false
+set CFL number                             = 1.
+set Maximum time step                      = 0.1
+set Output directory                       = output_polydiapirs
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2.24
+    set Y extent  = 1.0000
+    set X repetitions = 2
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right,top
+  set Zero velocity boundary indicators       = bottom
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities = 100, 90, 89
+    set Viscosities = 100, 1, 1
+    set Viscosity averaging scheme = harmonic
+    set Thermal expansivities = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z< 0.25 + (rand()-0.5)/5000. && z>=0.125+(rand()-0.5)/5000.) ,1 , 0 ) ; if (z<0.125+(rand    ()-0.5)/5000., 1 , 0)
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 7
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics, material statistics, global statistics, Stokes residual
+
+  subsection Visualization
+    set List of output variables = viscosity,density, strain rate
+    set Output format                 = vtu
+    set Time between graphical output = 5
+  end
+end
diff --git a/benchmarks/rayleigh_taylor_instability/blank.prm.bak b/benchmarks/rayleigh_taylor_instability/blank.prm.bak
new file mode 100644
index 00000000000..51699401b79
--- /dev/null
+++ b/benchmarks/rayleigh_taylor_instability/blank.prm.bak
@@ -0,0 +1,52 @@
+set Additional shared libraries  = ./librayleigh_taylor_instability.so
+set Dimension                    = 2
+set Start time                   = 0
+set End time                     = 0
+set Output directory             = output
+set Pressure normalization       = volume
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 512e3
+    set Y extent  = 512e3
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators =  bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity, strain rate
+  end
+end
diff --git a/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.cc.bak b/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.cc.bak
new file mode 100644
index 00000000000..879c094ac89
--- /dev/null
+++ b/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.cc.bak
@@ -0,0 +1,199 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  namespace RTinstabilityBenchmark
+  {
+    using namespace dealii;
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class RTinstabilityMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> &pos = in.position[i];
+
+              if ( pos[1]< 256e3 + amplitude*std::cos(pos[0]/lambda*2.0*numbers::PI))
+                {
+                  out.viscosities[i] = eta2;
+                  out.densities[i] = rho2;
+                }
+              else
+                {
+                  out.viscosities[i] = eta1;
+                  out.densities[i] = rho1;
+                }
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm)
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("RTinstability");
+            {
+              prm.declare_entry ("eta1", "1e21",
+                                 Patterns::Double (0),
+                                 "Viscosity of the mantle.");
+              prm.declare_entry ("eta2", "1e23",
+                                 Patterns::Double (0),
+                                 "Viscosity in the inclusion.");
+              prm.declare_entry ("rho1", "3200",
+                                 Patterns::Double (0),
+                                 "density of the mantle.");
+              prm.declare_entry ("rho2", "3232",
+                                 Patterns::Double (0),
+                                 "density in the inclusion.");
+              prm.declare_entry ("amplitude", "1000",
+                                 Patterns::Double (0),
+                                 "perturbation amplitude.");
+              prm.declare_entry ("lambda", "256e3",
+                                 Patterns::Double (0),
+                                 "perturbation wavelength.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("RTinstability");
+            {
+              eta1 = prm.get_double ("eta1");
+              eta2 = prm.get_double ("eta2");
+              rho1 = prm.get_double ("rho1");
+              rho2 = prm.get_double ("rho2");
+              amplitude = prm.get_double ("amplitude");
+              lambda = prm.get_double ("lambda");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          // Declare dependencies on solution variables
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+      private:
+        double eta1;
+        double eta2;
+        double rho1;
+        double rho2;
+        double amplitude;
+        double lambda;
+
+    };
+
+
+    template <int dim>
+    bool
+    RTinstabilityMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace RTinstabilityBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(RTinstabilityMaterial,
+                                   "RTinstabilityMaterial",
+                                   "A material model that corresponds to the `RTinstability' benchmark. "
+                                   "See the manual for more information.")
+  }
+}
diff --git a/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.prm.bak b/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.prm.bak
new file mode 100644
index 00000000000..7a0a18a736a
--- /dev/null
+++ b/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.prm.bak
@@ -0,0 +1,75 @@
+set Additional shared libraries  = ./librayleigh_taylor_instability.so
+set Dimension                    = 2
+set Start time                   = 0
+set End time                     = 0
+set Output directory             = output
+set Pressure normalization       = volume
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 512e3
+    set Y extent  = 512e3
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators =  bottom, top
+end
+
+subsection Material model
+  set Model name  = RTinstabilityMaterial
+
+  subsection RTinstability
+    set eta1 = 1e21
+    set eta2 = 1e21
+    set rho1 = 3300
+    set rho2 = 3000
+    set amplitude = 4000
+    set lambda = 256e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement     = 4
+  set Initial adaptive refinement   = 6
+  set Strategy                      = density
+  set Refinement fraction           = 0.5
+  set Run postprocessors on initial refinement = true
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity, strain rate
+  end
+end
diff --git a/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm b/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm
index 08f66c0330c..96cbf4deadc 100644
--- a/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm
+++ b/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm
@@ -27,9 +27,9 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
     set Global composition maximum = 1
     set Global composition minimum = 0
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm.bak b/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm.bak
new file mode 100644
index 00000000000..08f66c0330c
--- /dev/null
+++ b/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm.bak
@@ -0,0 +1,158 @@
+# Input file for the 2D Rayleigh Taylor benchmark described
+# in Kaus et al. (2010, 10.1016/j.pepi.2010.04.007).
+# The benchmark considers a denser, more viscous layer
+# overlying lighter, less viscous mantle. The interface
+# between the layers is perturbed, leading to drips along
+# the vertical domain boundaries. A free surface allows
+# for the development of surface topography.
+
+############### Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 6e6
+
+# For a timestep of 2500 yr and no stabilization,
+# the model is stable. For a timestep of 10000 yr,
+# it is not ("drunken sailor").
+set Maximum time step                      = 100e2
+set Use years in output instead of seconds = true
+set CFL number                             = 0.5
+set Output directory                       = output_nostab_10000
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Pressure normalization                 = no
+
+############## Element types
+# Use dicontinuous composition elements for a sharp interface
+subsection Discretization
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+    set Global composition maximum = 1
+    set Global composition minimum = 0
+  end
+end
+
+############### Geometry
+# We consider a 2D box of 500x500 km
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500e3
+    set Y extent  = 500e3
+  end
+end
+
+############### Boundary conditions
+# Vertical boundaries are free slip,
+# the bottom boundary is no slip,
+# and the top boundary is a free surface.
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators                    = top: free surface
+  set Additional tangential mesh velocity boundary indicators = left, right
+
+  subsection Free surface
+    # We test the stability of the free surface
+    # for a timestep of 2500 and 10000 yr with
+    # (0.5) and without (0.0) stabilization.
+    set Free surface stabilization theta = 0.0
+
+    # We compare the vertical and normal projection of
+    # the free surface.
+    #set Surface velocity projection      = normal
+    set Surface velocity projection      = vertical
+  end
+end
+
+############### Material properties
+# No temperature effects.
+# The top layer is denser and more viscous.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                                      = 1.0e20
+    set Composition viscosity prefactor                = 10
+    set Reference temperature                          = 1.0
+    set Reference density                              = 3200.0
+    set Density differential for compositional field 1 = 100
+    set Thermal expansion coefficient                  = 0.0
+    set Thermal conductivity                           = 2.7
+    set Reference specific heat                        = 1250
+  end
+end
+
+############## Gravity
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# We ignore any temperature effects.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom, left, right
+  set List of model names = initial temperature
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional fields
+# We include one compositional field plus the background material.
+# The material interface is sinusoidally perturbed with an amplitude
+# A of 5 km.
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = A=5000, W=250e3, C=250e3
+    set Function expression = if(y>400e3+A*cos(pi*(x-C)/W),1,0)
+  end
+end
+
+############### Mesh refinement
+# The Kaus paper considers a resolution of 50x50 elements.
+# We use 64x64.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+# We monitor the topography over time.
+subsection Postprocess
+  set List of postprocessors = visualization, topography, composition statistics, maximum depth of field, velocity statistics
+
+  subsection Visualization
+    set Time between graphical output = 1.0e5
+    set List of output variables      = viscosity, density
+    set Output mesh velocity          = true
+  end
+
+  subsection Topography
+    set Output to file           = true
+    set Time between text output = 2.e5
+  end
+end
diff --git a/benchmarks/rayleigh_taylor_instability_free_surface/rose_rayleigh_taylor_instability.prm.bak b/benchmarks/rayleigh_taylor_instability_free_surface/rose_rayleigh_taylor_instability.prm.bak
new file mode 100644
index 00000000000..fad2de9f2ff
--- /dev/null
+++ b/benchmarks/rayleigh_taylor_instability_free_surface/rose_rayleigh_taylor_instability.prm.bak
@@ -0,0 +1,49 @@
+# Input file for the 2D Rayleigh Taylor benchmark described
+# in Rose et al. (2017, 10.1016/j.pepi.2016.11.007).
+# The benchmark considers a denser, more viscous layer
+# overlying lighter, less viscous mantle. The interface
+# between the layers is perturbed, leading to drips along
+# the vertical domain boundaries. A free surface allows
+# for the development of surface topography.
+# Compared to the setup in Kaus et al. (2010), the resolution
+# of the layer interface is higher and therefore a timestep
+# of 5000 yr is still stable without free surface stabilization,
+# while a timestep of 10,000 yr is not.
+
+############### Global parameters
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm
+
+set Start time                             = 0
+set Maximum time step                      = 1e5
+set End time                               = 6e6
+set CFL number                             = 0.2
+set Output directory                       = output_Rose_stab_CFL02
+
+############### Boundary conditions
+subsection Mesh deformation
+  set Mesh deformation boundary indicators                    = top: free surface
+  set Additional tangential mesh velocity boundary indicators = left, right
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+    set Surface velocity projection      = vertical
+  end
+end
+
+############### Mesh refinement
+# The Rose et al. (2017) paper considers a maximum local resolution
+# of ~1 km by using global and adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 4
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.95
+  set Coarsening fraction                = 0.05
+  set Strategy                           = composition, boundary
+  set Time steps between mesh refinement = 5
+
+  subsection Boundary
+    set Boundary refinement indicators = top
+  end
+end
diff --git a/benchmarks/rigid_shear/instantaneous/rigid_shear.prm.bak b/benchmarks/rigid_shear/instantaneous/rigid_shear.prm.bak
new file mode 100644
index 00000000000..a60074dacad
--- /dev/null
+++ b/benchmarks/rigid_shear/instantaneous/rigid_shear.prm.bak
@@ -0,0 +1,87 @@
+# A description of the "Rigid shear" benchmark for which a known solution
+# is available. See Gassmoeller et al. "Evaluating
+# the Accuracy of Hybrid Finite Element/Particle-In-Cell Methods for
+# Modeling Incompressible Stokes Flow" for a discussion.
+
+set Additional shared libraries            = ../plugin/librigid_shear.so
+set Dimension                              = 2
+set End time                               = 0.0
+set Output directory                       = output
+set Pressure normalization                 = no
+set Nonlinear solver scheme                = no Advection, single Stokes
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Compositional fields
+  set Names of fields = density_comp
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*x)*sin(pi*y) + 2.0
+  end
+end
+
+subsection Material model
+  set Model name = rigid shear
+end
+
+subsection Rigid shear benchmark
+  set Use analytical density = true
+  set Use transient solution = false
+end
+
+subsection Gravity model
+  set Model name = rigid shear
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators =
+  set List of model names =
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (x<0.5) ? 0.4 : 0.6
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, rigid shear
+
+  subsection Visualization
+    set Time between graphical output = 0.0
+    set List of output variables = material properties
+  end
+end
+
+# Increase Stokes solver accuracy to ensure convergence to
+# very low error values
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
diff --git a/benchmarks/rigid_shear/plugin/rigid_shear.cc.bak b/benchmarks/rigid_shear/plugin/rigid_shear.cc.bak
new file mode 100644
index 00000000000..903b0ce97ee
--- /dev/null
+++ b/benchmarks/rigid_shear/plugin/rigid_shear.cc.bak
@@ -0,0 +1,378 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/gravity_model/interface.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/postprocess/particles.h>
+#include <aspect/particle/property/interface.h>
+#include <aspect/particle/world.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace RigidShearBenchmark
+  {
+    /**
+     * This is the "Rigid shear" benchmark based on a suggestion in the following paper:
+     * @code
+     *  @Article{KKSCND97,
+     *  author =       {P. E. van Keken and S. D. King and H. Schmeling and U. R. Christensen and D. Neumeister and M.-P. Doin},
+     *  title =        {A comparison of methods for the modeling of thermochemical convection},
+     *  journal =      {J. Geoph. Res.},
+     *  year =         1997,
+     *  volume =       102,
+     *  pages =        {22477--22495}}
+     * @endcode
+     *
+     * The results of the modification are published in Gassmoeller,
+     * Lokavarapu, Bangerth, Puckett, 2019, "Evaluating the Accuracy of Hybrid
+     * Finite Element/Particle-In-Cell Methods for Modeling Incompressible
+     * Stokes Flow".
+     */
+    namespace AnalyticSolutions
+    {
+      double
+      phase_function(const double t)
+      {
+        return std::exp(t)-1.;
+      }
+
+      template <int dim>
+      double
+      density(const Point<dim> &p,
+              const double t,
+              const bool transient)
+      {
+        const double pi = numbers::PI;
+        const double phase = (transient == true) ? phase_function(t) : 0.0;
+
+        return std::sin(pi*(p[0]-phase)) * std::sin(pi*p[1]) + 2.0;
+      }
+
+      /**
+       * The exact solution for the Rigid Shear benchmark.
+       */
+      template <int dim>
+      class FunctionRigidShear : public Function<dim>
+      {
+        public:
+          FunctionRigidShear(const unsigned int n_components,
+                             const bool transient)
+            : Function<dim>(n_components),
+              transient(transient) {}
+
+          void vector_value(const Point<dim> &p,
+                            Vector<double> &values) const override
+          {
+            const double pi = numbers::PI;
+            const double t = this->get_time();
+            const double phase = (transient == true) ? phase_function(t) : 0.0;
+
+            values[0] = std::sin(pi*(p[0]-phase)) * std::cos(pi*p[1]);
+
+            if (transient == true)
+              values[0] += std::exp(t);
+
+            values[1] = -std::cos(pi*(p[0]-phase)) * std::sin(pi*p[1]);
+            values[2] = 2.0 * pi * std::cos(pi*(p[0]-phase)) * std::cos(pi*p[1]);
+            values[4] = density(p,t,transient);
+            return;
+          }
+
+        private:
+          bool transient;
+      };
+    }
+
+
+
+    /**
+     * A material model for the stationary form of the rigid shear benchmark. All properties
+     * are defined in dependence of position.
+     */
+    template <int dim>
+    class RigidShearMaterial : public MaterialModel::Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          const double t = (this->simulator_is_past_initialization()) ? this->get_time() : 0.0;
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              if (use_analytical_density == true)
+                out.densities[i] = AnalyticSolutions::density(in.position[i],t,use_transient_flow_solution);
+              else
+                out.densities[i] = in.composition[i][0];
+
+              out.viscosities[i] = 1.0;
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0.0;
+              out.thermal_conductivities[i] = 0.0;
+
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                out.reaction_terms[i][c] = 0.0;
+            }
+        }
+
+
+
+        bool is_compressible() const override
+        {
+          return false;
+        }
+
+
+
+        bool use_transient_solution() const
+        {
+          return use_transient_flow_solution;
+        }
+
+
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm)
+        {
+          //create a global section in the parameter file for parameters
+          //that describe this benchmark. note that we declare them here
+          //in the material model, but other kinds of plugins (e.g., the gravity
+          //model below) may also read these parameters even though they do not
+          //declare them
+          prm.enter_subsection("Rigid shear benchmark");
+          {
+            prm.declare_entry("Use analytical density", "true",
+                              Patterns::Bool(),
+                              "Whether to use the analytical density solution, or to look for a "
+                              "compositional field named <density_field> to use as density.");
+
+            prm.declare_entry("Use transient solution", "false",
+                              Patterns::Bool(),
+                              "Whether to use the transient flow solution, or to use the "
+                              "default steady-state solution.");
+          }
+          prm.leave_subsection();
+        }
+
+        void
+        parse_parameters(ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Rigid shear benchmark");
+          {
+            use_analytical_density = prm.get_bool ("Use analytical density");
+            use_transient_flow_solution = prm.get_bool ("Use transient solution");
+          }
+          prm.leave_subsection();
+
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+        bool use_analytical_density;
+        bool use_transient_flow_solution;
+    };
+
+
+
+
+    /**
+     * Gravity model for the Rigid shear benchmark
+     */
+    template <int dim>
+    class RigidShearGravity : public aspect::GravityModel::Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        Tensor<1,dim> gravity_vector (const Point<dim> &pos) const override
+        {
+          const double pi = numbers::PI;
+          const double t = (this->simulator_is_past_initialization()) ? this->get_time() : 0.0;
+
+          const RigidShearMaterial<dim> &
+          material_model
+            = Plugins::get_plugin_as_type<const RigidShearMaterial<dim>>(this->get_material_model());
+          const bool transient = material_model.use_transient_solution();
+          const double phase = (transient == true) ? AnalyticSolutions::phase_function(t) : 0.0;
+
+          const double forcing_term = - 4.0 * pi * pi * std::cos(pi*(pos[0] - phase)) * std::sin(pi*pos[1]);
+
+          Tensor<1,dim> gravity;
+          gravity[0] =  0.0;
+          gravity[1] =  forcing_term / AnalyticSolutions::density(pos,t,transient);
+
+          return gravity;
+        }
+    };
+
+    /**
+     * A postprocessor that evaluates the accuracy of the solution.
+     *
+     * The implementation of error evaluators that correspond to the
+     * benchmarks defined in the paper Gassmoeller et al. referenced above.
+     */
+    template <int dim>
+    class RigidShearPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate error output for velocity, pressure, and density.
+         */
+        std::pair<std::string, std::string>
+        execute(TableHandler &statistics) override
+        {
+          const RigidShearMaterial<dim> &
+          material_model
+            = Plugins::get_plugin_as_type<const RigidShearMaterial<dim>>(this->get_material_model());
+
+          AnalyticSolutions::FunctionRigidShear<dim> ref_func(this->introspection().n_components,
+                                                              material_model.use_transient_solution());
+          ref_func.set_time(this->get_time());
+
+          AssertThrow(Plugins::plugin_type_matches<const RigidShearMaterial<dim>>(this->get_material_model()),
+                      ExcMessage(
+                        "Postprocessor RigidShearPostprocessor only works with the material model RigidShearMaterial."));
+
+          const QGauss<dim> quadrature_formula(this->introspection().polynomial_degree.velocities + 2);
+
+          Vector<double> cellwise_errors_u(this->get_triangulation().n_active_cells());
+          Vector<double> cellwise_errors_p(this->get_triangulation().n_active_cells());
+          Vector<double> cellwise_errors_ul2(this->get_triangulation().n_active_cells());
+          Vector<double> cellwise_errors_pl2(this->get_triangulation().n_active_cells());
+          Vector<double> cellwise_errors_rhol2(this->get_triangulation().n_active_cells());
+
+          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0, dim),
+                                              this->get_fe().n_components());
+          ComponentSelectFunction<dim> comp_p(dim,
+                                              this->get_fe().n_components());
+          ComponentSelectFunction<dim> comp_rho(dim+2,
+                                                this->get_fe().n_components());
+
+          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
+                                            this->get_solution(),
+                                            ref_func,
+                                            cellwise_errors_u,
+                                            quadrature_formula,
+                                            VectorTools::L1_norm,
+                                            &comp_u);
+          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
+                                            this->get_solution(),
+                                            ref_func,
+                                            cellwise_errors_p,
+                                            quadrature_formula,
+                                            VectorTools::L1_norm,
+                                            &comp_p);
+          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
+                                            this->get_solution(),
+                                            ref_func,
+                                            cellwise_errors_ul2,
+                                            quadrature_formula,
+                                            VectorTools::L2_norm,
+                                            &comp_u);
+          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
+                                            this->get_solution(),
+                                            ref_func,
+                                            cellwise_errors_pl2,
+                                            quadrature_formula,
+                                            VectorTools::L2_norm,
+                                            &comp_p);
+          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
+                                            this->get_solution(),
+                                            ref_func,
+                                            cellwise_errors_rhol2,
+                                            quadrature_formula,
+                                            VectorTools::L2_norm,
+                                            &comp_rho);
+
+          const double u_l1 = Utilities::MPI::sum(cellwise_errors_u.l1_norm(), this->get_mpi_communicator());
+          const double p_l1 = Utilities::MPI::sum(cellwise_errors_p.l1_norm(), this->get_mpi_communicator());
+          const double u_l2 = std::sqrt(
+                                Utilities::MPI::sum(cellwise_errors_ul2.norm_sqr(), this->get_mpi_communicator()));
+          const double p_l2 = std::sqrt(
+                                Utilities::MPI::sum(cellwise_errors_pl2.norm_sqr(), this->get_mpi_communicator()));
+          const double rho_l2 = std::sqrt(
+                                  Utilities::MPI::sum(cellwise_errors_rhol2.norm_sqr(), this->get_mpi_communicator()));
+
+          statistics.add_value ("u_L2",
+                                u_l2);
+          statistics.set_precision ("u_L2", 14);
+          statistics.set_scientific ("u_L2", true);
+
+          statistics.add_value ("p_L2",
+                                p_l2);
+          statistics.set_precision ("p_L2", 14);
+          statistics.set_scientific ("p_L2", true);
+
+          statistics.add_value ("rho_L2",
+                                rho_l2);
+          statistics.set_precision ("rho_L2", 14);
+          statistics.set_scientific ("rho_L2", true);
+
+          std::ostringstream os;
+          os << std::scientific << u_l1
+             << ", " << p_l1
+             << ", " << u_l2
+             << ", " << p_l2
+             << ", " << rho_l2;
+
+          return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2, rho_L2:", os.str());
+        }
+    };
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace RigidShearBenchmark
+  {
+    ASPECT_REGISTER_GRAVITY_MODEL(RigidShearGravity,
+                                  "rigid shear",
+                                  "A gravity model.")
+
+    ASPECT_REGISTER_MATERIAL_MODEL(RigidShearMaterial,
+                                   "rigid shear",
+                                   "A material model for the stationary form of the rigid shear benchmark. All properties "
+                                   "are defined in dependence of position.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(RigidShearPostprocessor,
+                                  "rigid shear",
+                                  "The implementation of error evaluators that correspond to the "
+                                  "benchmarks defined in the paper Gassmoeller et al. referenced above.")
+  }
+}
diff --git a/benchmarks/rigid_shear/steady-state/rigid_shear.prm.bak b/benchmarks/rigid_shear/steady-state/rigid_shear.prm.bak
new file mode 100644
index 00000000000..ec607b5004c
--- /dev/null
+++ b/benchmarks/rigid_shear/steady-state/rigid_shear.prm.bak
@@ -0,0 +1,110 @@
+# A description of the time-dependent "Rigid shear" benchmark for which a known
+# solution is available. See Gassmoeller et al. "Evaluating the Accuracy of
+# Hybrid Finite Element/Particle-In-Cell Methods for Modeling Incompressible
+# Stokes Flow" for a discussion.
+
+set Additional shared libraries            = ../plugin/librigid_shear.so
+set Dimension                              = 2
+set End time                               = 0.1
+set Output directory                       = output
+set Pressure normalization                 = no
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_comp
+  set Compositional field methods = particles
+  set Mapped particle properties = density_comp:function
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*x)*sin(pi*y) + 2.0
+  end
+end
+
+subsection Material model
+  set Model name = rigid shear
+end
+
+subsection Rigid shear benchmark
+  set Use analytical density = false
+  set Use transient solution = false
+end
+
+subsection Gravity model
+  set Model name = rigid shear
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators =
+  set List of model names =
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (x<0.5) ? 0.4 : 0.6
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 3
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles, rigid shear
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+    set List of output variables = material properties, gravity
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = bilinear least squares
+  set Update ghost particles = true
+  set Minimum particles per cell = 9
+  set Maximum particles per cell = 16384
+  set Particle generator name = reference cell
+
+  subsection Function
+    set Function expression = sin(pi*x)*sin(pi*y) + 2.0
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 9
+    end
+  end
+end
diff --git a/benchmarks/rigid_shear/transient/rigid_shear.prm.bak b/benchmarks/rigid_shear/transient/rigid_shear.prm.bak
new file mode 100644
index 00000000000..6ce240c74c3
--- /dev/null
+++ b/benchmarks/rigid_shear/transient/rigid_shear.prm.bak
@@ -0,0 +1,134 @@
+# A description of the time-dependent "Rigid shear" benchmark for which a known
+# solution is available. See Gassmoeller et al. "Benchmarking the accuracy of
+# higher order particle methods in geodynamic models of transient flow" for a
+# discussion.
+
+set Additional shared libraries            = ../plugin/librigid_shear.so
+set Dimension                              = 2
+set End time                               = 1.098612289
+set Output directory                       = output
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set X repetitions = 2
+    set Y extent = 1
+    set X periodic = true
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+
+    #set Stokes solver type = block GMG
+    set Krylov method for cheap solver steps = IDR(s)
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom: function, top: function
+
+  subsection Function
+    set Function expression = sin(pi*(x-exp(t)+1))*cos(pi*y) + exp(t); 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_comp
+
+  #set Compositional field methods = particles
+  #set Mapped particle properties = density_comp:function
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*x)*sin(pi*y) + 2
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+  set Model name = rigid shear
+end
+
+subsection Rigid shear benchmark
+  set Use analytical density = false
+  set Use transient solution = true
+end
+
+subsection Gravity model
+  set Model name = rigid shear
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators =
+  set List of model names =
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (x<0.5) ? 0.4 : 0.6
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 3
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, rigid shear
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+    set List of output variables = material properties, gravity
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = bilinear least squares
+  set Update ghost particles = true
+  set Minimum particles per cell = 12
+  set Maximum particles per cell = 16384
+  set Particle generator name = random uniform
+  set Load balancing strategy = add particles
+
+  subsection Function
+    set Function expression = sin(pi*x)*sin(pi*y) + 2
+  end
+
+  subsection Interpolator
+    subsection Quadratic least squares
+      set Use boundary extrapolation = true
+    end
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 8192
+    end
+  end
+end
diff --git a/benchmarks/shear_bands/magmatic_shear_bands.prm.bak b/benchmarks/shear_bands/magmatic_shear_bands.prm.bak
new file mode 100644
index 00000000000..0696dfdb4f9
--- /dev/null
+++ b/benchmarks/shear_bands/magmatic_shear_bands.prm.bak
@@ -0,0 +1,146 @@
+# Listing of Parameters
+# ---------------------
+# Set up the magmatic shear bands testcase
+# for Newtonian rheology and analyze it using
+# the relations given in Spiegelman (2003):
+# Linear analysis of melt band formation by
+# simple shear, Geochemistry, Geophysics,
+# Geosystems, 4(9), 8615.
+
+set Additional shared libraries            = ./libshear_bands.so
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = output
+set Max nonlinear iterations               = 5
+set Nonlinear solver tolerance             = 1e-5
+set Dimension                              = 2
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.0005
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# we apply simple shear here, so that the top and bottom boundaries
+# move with the same speed u0, but in opposite directions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+
+  subsection Function
+    set Function constants = u0=5e2,ymid=0.0005
+    set Function expression = u0*(y/ymid-1.0);0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.004
+    set Y extent  = 0.001
+    set X periodic = true
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=64000
+    set Function expression = 0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = plane wave melt bands initial condition
+
+  subsection Plane wave melt bands initial condition
+    set Wave amplitude = 1e-4
+    set Initial band angle = 30
+    set Wave number = 4000
+  end
+end
+
+subsection Material model
+  set Model name = shear bands material
+
+  subsection Shear bands material
+    set Dislocation creep exponent = 1.0
+    set Porosity exponent          = -1.0
+    set Compaction viscosity exponent = 1.0
+    set Permeability exponent = 2
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 8
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, shear bands growth rate
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, thermal expansivity, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-24
+  set Temperature solver tolerance = 1e-20
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
diff --git a/benchmarks/shear_bands/shear_bands.cc.bak b/benchmarks/shear_bands/shear_bands.cc.bak
new file mode 100644
index 00000000000..370bc5a9afb
--- /dev/null
+++ b/benchmarks/shear_bands/shear_bands.cc.bak
@@ -0,0 +1,846 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/initial_composition/interface.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+#include <deal.II/base/table.h>
+#include <deal.II/base/table_indices.h>
+#include <array>
+
+
+namespace aspect
+{
+  /**
+   * This is the "Shear bands" benchmark defined in the following paper:
+   * @code
+   *  @Article{DMGT11,
+   *    author =       {R. F. Katz and M. Spiegelman and B. Holtzman},
+   *    title =        {The dynamics of melt and shear localization in
+   *                    partially molten aggregates},
+   *    journal =      {Nature},
+   *    year =         2006,
+   *    volume =       442,
+   *    pages =        {676-679}
+   * @endcode
+   *
+   * Magmatic shear bands are generated by a combination of porosity- and
+   * strain-rate dependent viscosity in a simple shear regime; and the
+   * angle of the shear bands is measured.
+   *
+   */
+  namespace ShearBands
+  {
+    using namespace dealii;
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class ShearBandsMaterial : public MaterialModel::MeltInterface<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        bool is_compressible () const override
+        {
+          return false;
+        }
+
+        double reference_viscosity () const
+        {
+          return eta_0;
+        }
+
+        double reference_darcy_coefficient () const override
+        {
+          return reference_permeability * pow(0.01, permeability_exponent) / eta_f;
+        }
+
+
+        double
+        get_background_porosity () const;
+
+        double
+        get_reference_compaction_viscosity () const;
+
+        double
+        get_porosity_exponent () const;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                      typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const override
+        {
+          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+          const double strain_rate_dependence = (1.0 - dislocation_creep_exponent) / dislocation_creep_exponent;
+
+          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+            {
+              double porosity = std::max(in.composition[i][porosity_idx],1e-4);
+              out.viscosities[i] = eta_0 * std::exp(alpha*(porosity - background_porosity));
+              if (in.requests_property(MaterialModel::MaterialProperties::viscosity))
+                {
+                  const SymmetricTensor<2,dim> shear_strain_rate = in.strain_rate[i]
+                                                                   - 1./dim * trace(in.strain_rate[i]) * unit_symmetric_tensor<dim>();
+                  const double second_strain_rate_invariant = std::sqrt(std::abs(second_invariant(shear_strain_rate)));
+
+                  if (std::abs(second_strain_rate_invariant) > 1e-30)
+                    out.viscosities[i] *= std::pow(second_strain_rate_invariant,strain_rate_dependence);
+                }
+
+
+              out.densities[i] = reference_rho_s;
+              out.thermal_expansion_coefficients[i] = 0.0;
+              out.specific_heat[i] = 1.0;
+              out.thermal_conductivities[i] = 0.0;
+              out.compressibilities[i] = 0.0;
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                out.reaction_terms[i][c] = 0.0;
+            }
+
+          // fill melt outputs if they exist
+          aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+          if (melt_out != nullptr)
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                double porosity = std::max(in.composition[i][porosity_idx],1e-4);
+
+                melt_out->compaction_viscosities[i] = xi_0 * pow(porosity/background_porosity,-compaction_viscosity_exponent);
+                melt_out->fluid_viscosities[i]= eta_f;
+                melt_out->permeabilities[i]= reference_permeability * std::pow(porosity,permeability_exponent);
+                melt_out->fluid_densities[i]= reference_rho_f;
+                melt_out->fluid_density_gradients[i] = 0.0;
+              }
+        }
+
+      private:
+        double reference_rho_s;
+        double reference_rho_f;
+        double eta_0;
+        double xi_0;
+        double eta_f;
+        double reference_permeability;
+        double dislocation_creep_exponent;
+        double alpha;
+        double background_porosity;
+        double compaction_viscosity_exponent;
+        double permeability_exponent;
+    };
+
+    template <int dim>
+    double
+    ShearBandsMaterial<dim>::get_background_porosity () const
+    {
+      return background_porosity;
+    }
+
+    template <int dim>
+    double
+    ShearBandsMaterial<dim>::get_reference_compaction_viscosity () const
+    {
+      return xi_0;
+    }
+
+    template <int dim>
+    double
+    ShearBandsMaterial<dim>::get_porosity_exponent () const
+    {
+      return alpha;
+    }
+
+
+    template <int dim>
+    void
+    ShearBandsMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Shear bands material");
+        {
+          prm.declare_entry ("Reference solid density", "3000",
+                             Patterns::Double (0),
+                             "Reference density of the solid $\\rho_{s,0}$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference melt density", "3000",
+                             Patterns::Double (0),
+                             "Reference density of the melt/fluid$\\rho_{f,0}$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference shear viscosity", "1.41176e7",
+                             Patterns::Double (0),
+                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Reference compaction viscosity", "1.41176e8",
+                             Patterns::Double (0),
+                             "The value of the constant volumetric viscosity $\\xi_0$ of the solid matrix. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Reference melt viscosity", "100.0",
+                             Patterns::Double (0),
+                             "The value of the constant melt viscosity $\\eta_f$. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Reference permeability", "5e-9",
+                             Patterns::Double(),
+                             "Reference permeability of the solid host rock."
+                             "Units: \\si{\\meter\\squared}.");
+          prm.declare_entry ("Dislocation creep exponent", "6.0",
+                             Patterns::Double(0),
+                             "Power-law exponent $n_{dis}$ for dislocation creep. "
+                             "Units: none.");
+          prm.declare_entry ("Porosity exponent", "-27.0",
+                             Patterns::Double(),
+                             "Exponent $\alpha$ for the exponential porosity-dependence "
+                             "of the viscosity. "
+                             "Units: none.");
+          prm.declare_entry ("Background porosity", "0.05",
+                             Patterns::Double (0),
+                             "Background porosity used in the viscosity law. Units: none.");
+          prm.declare_entry ("Compaction viscosity exponent", "0.0",
+                             Patterns::Double(0),
+                             "Power-law exponent $m$ for the compaction viscosity. "
+                             "Units: none.");
+          prm.declare_entry ("Permeability exponent", "3.0",
+                             Patterns::Double(0),
+                             "Power-law exponent $n$ for the porosity-dependence of permeability. "
+                             "Units: none.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ShearBandsMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Shear bands material");
+        {
+          reference_rho_s            = prm.get_double ("Reference solid density");
+          reference_rho_f            = prm.get_double ("Reference melt density");
+          eta_0                      = prm.get_double ("Reference shear viscosity");
+          xi_0                       = prm.get_double ("Reference compaction viscosity");
+          eta_f                      = prm.get_double ("Reference melt viscosity");
+          reference_permeability     = prm.get_double ("Reference permeability");
+          dislocation_creep_exponent = prm.get_double ("Dislocation creep exponent");
+          alpha                      = prm.get_double ("Porosity exponent");
+          background_porosity        = prm.get_double ("Background porosity");
+          compaction_viscosity_exponent = prm.get_double ("Compaction viscosity exponent");
+          permeability_exponent      = prm.get_double ("Permeability exponent");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    /**
+     * An initial conditions model for the shear bands benchmark
+     * that implements a background porosity plus white noise with
+     * a certain amplitude.
+     */
+    template <int dim>
+    class ShearBandsInitialCondition : public InitialComposition::Interface<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Return the initial porosity as a function of position.
+         */
+        double
+        initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Initialization function.
+         */
+        void
+        initialize () override;
+
+      private:
+        double noise_amplitude;
+        double background_porosity;
+        std::array<unsigned int,dim> grid_intervals;
+        std::unique_ptr<Functions::InterpolatedUniformGridData<dim>> interpolate_noise;
+    };
+
+
+
+    template <int dim>
+    void
+    ShearBandsInitialCondition<dim>::initialize ()
+    {
+      AssertThrow(Plugins::plugin_type_matches<const ShearBandsMaterial<dim>>(this->get_material_model()),
+                  ExcMessage("Initial condition shear bands only works with the material model shear bands."));
+
+      const ShearBandsMaterial<dim> &
+      material_model
+        = Plugins::get_plugin_as_type<const ShearBandsMaterial<dim>>(this->get_material_model());
+
+      background_porosity = material_model.get_background_porosity();
+
+      AssertThrow(noise_amplitude < background_porosity,
+                  ExcMessage("Amplitude of the white noise must be smaller "
+                             "than the background porosity."));
+
+      Point<dim> extents;
+      TableIndices<dim> size_idx;
+      for (unsigned int d=0; d<dim; ++d)
+        size_idx[d] = grid_intervals[d]+1;
+
+      Table<dim,double> white_noise;
+      white_noise.TableBase<dim,double>::reinit(size_idx);
+      std::array<std::pair<double,double>,dim> grid_extents;
+
+      AssertThrow(Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
+                  ExcMessage("Initial condition shear bands only works with the box geometry model."));
+
+      const GeometryModel::Box<dim> &
+      geometry_model
+        = Plugins::get_plugin_as_type<const GeometryModel::Box<dim>>(this->get_geometry_model());
+
+      extents = geometry_model.get_extents();
+
+      for (unsigned int d=0; d<dim; ++d)
+        {
+          grid_extents[d].first=0;
+          grid_extents[d].second=extents[d];
+        }
+
+      // use a fixed number as seed for random generator
+      // this is important if we run the code on more than 1 processor
+      std::srand(0);
+
+      TableIndices<dim> idx;
+
+      for (unsigned int i=0; i<white_noise.size()[0]; ++i)
+        {
+          idx[0] = i;
+          for (unsigned int j=0; j<white_noise.size()[1]; ++j)
+            {
+              idx[1] = j;
+              white_noise(idx) = noise_amplitude * ((std::rand() % 10000) / 5000.0 - 1.0);
+            }
+        }
+
+      interpolate_noise
+        = std::make_unique<Functions::InterpolatedUniformGridData<dim>> (grid_extents,
+                                                                          grid_intervals,
+                                                                          white_noise);
+    }
+
+
+    template <int dim>
+    double
+    ShearBandsInitialCondition<dim>::
+    initial_composition (const Point<dim> &position, const unsigned int /*n_comp*/) const
+    {
+      return background_porosity + interpolate_noise->value(position);
+    }
+
+
+    template <int dim>
+    void
+    ShearBandsInitialCondition<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Shear bands initial condition");
+        {
+          prm.declare_entry ("Noise amplitude", "0.0005",
+                             Patterns::Double (0),
+                             "Amplitude of the white noise added to the initial "
+                             "porosity. Units: none.");
+          prm.declare_entry ("Grid intervals for noise X", "100",
+                             Patterns::Integer (0),
+                             "Grid intervals in X directions for the white noise added to "
+                             "the initial background porosity that will then be interpolated "
+                             "to the model grid. "
+                             "Units: none.");
+          prm.declare_entry ("Grid intervals for noise Y", "25",
+                             Patterns::Integer (0),
+                             "Grid intervals in Y directions for the white noise added to "
+                             "the initial background porosity that will then be interpolated "
+                             "to the model grid. "
+                             "Units: none.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ShearBandsInitialCondition<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Shear bands initial condition");
+        {
+          noise_amplitude      = prm.get_double ("Noise amplitude");
+          grid_intervals[0]    = prm.get_integer ("Grid intervals for noise X");
+          grid_intervals[1]    = prm.get_integer ("Grid intervals for noise Y");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    /**
+     * An initial conditions model for the plane wave melt bands benchmark
+     * that implements a background porosity plus a plave wave in the porosity
+     * field with a certain amplitude.
+     */
+    template <int dim>
+    class PlaneWaveMeltBandsInitialCondition : public InitialComposition::Interface<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Return the initial porosity as a function of position.
+         */
+        double
+        initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Initialization function.
+         */
+        void
+        initialize () override;
+
+        double
+        get_wave_amplitude () const;
+
+        double
+        get_wave_number () const;
+
+        double
+        get_initial_band_angle () const;
+
+      private:
+        double amplitude;
+        double background_porosity;
+        double wave_number;
+        double initial_band_angle;
+    };
+
+
+
+    template <int dim>
+    void
+    PlaneWaveMeltBandsInitialCondition<dim>::initialize ()
+    {
+      AssertThrow(Plugins::plugin_type_matches<ShearBandsMaterial<dim>>(this->get_material_model()),
+                  ExcMessage("Initial condition shear bands only works with the material model shear bands."));
+
+      const ShearBandsMaterial<dim> &
+      material_model
+        = Plugins::get_plugin_as_type<const ShearBandsMaterial<dim>>(this->get_material_model());
+
+      background_porosity = material_model.get_background_porosity();
+
+      AssertThrow(amplitude < 1.0,
+                  ExcMessage("Amplitude of the melt bands must be smaller "
+                             "than the background porosity."));
+    }
+
+
+    template <int dim>
+    double
+    PlaneWaveMeltBandsInitialCondition<dim>::get_wave_amplitude () const
+    {
+      return amplitude;
+    }
+
+    template <int dim>
+    double
+    PlaneWaveMeltBandsInitialCondition<dim>::get_wave_number () const
+    {
+      return wave_number;
+    }
+
+    template <int dim>
+    double
+    PlaneWaveMeltBandsInitialCondition<dim>::get_initial_band_angle () const
+    {
+      return initial_band_angle;
+    }
+
+
+    template <int dim>
+    double
+    PlaneWaveMeltBandsInitialCondition<dim>::
+    initial_composition (const Point<dim> &position, const unsigned int /*n_comp*/) const
+    {
+      return background_porosity * (1.0 + amplitude * cos(wave_number*position[0]*sin(initial_band_angle)
+                                                          + wave_number*position[1]*cos(initial_band_angle)));
+    }
+
+
+    template <int dim>
+    void
+    PlaneWaveMeltBandsInitialCondition<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Plane wave melt bands initial condition");
+        {
+          prm.declare_entry ("Wave amplitude", "1e-4",
+                             Patterns::Double (0),
+                             "Amplitude of the plane wave added to the initial "
+                             "porosity. Units: none.");
+          prm.declare_entry ("Wave number", "2000",
+                             Patterns::Double (0),
+                             "Wave number of the plane wave added to the initial "
+                             "porosity. Is multiplied by 2 pi internally. "
+                             "Units: 1/m.");
+          prm.declare_entry ("Initial band angle", "30",
+                             Patterns::Double (0),
+                             "Initial angle of the plane wave added to the initial "
+                             "porosity. Units: degrees.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    PlaneWaveMeltBandsInitialCondition<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Plane wave melt bands initial condition");
+        {
+          amplitude          = prm.get_double ("Wave amplitude");
+          wave_number        = 2.0 * numbers::PI * prm.get_double ("Wave number");
+          initial_band_angle = 2.0 * numbers::PI / 360.0 * prm.get_double ("Initial band angle");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+
+    /**
+      * A postprocessor that evaluates the angle of the shear bands.
+      */
+    template <int dim>
+    class ShearBandsPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    ShearBandsPostprocessor<dim>::execute (TableHandler &/*statistics*/)
+    {
+      // write output that can be used to calculate the angle of the shear bands
+      const unsigned int max_lvl = this->get_triangulation().n_global_levels();
+
+      std::stringstream output;
+      output.precision (16);
+      output << std::scientific;
+
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          // write header
+          output << "x                      y                      porosity" << std::endl;
+        }
+
+      // we want to have equidistant points in the output
+      const QMidpoint<1> mp_rule;
+      const QIterated<dim> quadrature_formula (mp_rule, 2);
+      const unsigned int n_q_points =  quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(), this->get_fe(),  quadrature_formula,
+                               update_JxW_values | update_values | update_quadrature_points);
+
+      std::vector<double>         porosity_values (quadrature_formula.size());
+      const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.compositional_fields[porosity_idx]].get_function_values (this->get_solution(), porosity_values);
+
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                output << fe_values.quadrature_point (q) (0) << " "
+                       << fe_values.quadrature_point (q) (1) << " "
+                       << porosity_values[q] << std::endl;
+              }
+          }
+
+      std::string filename = this->get_output_directory() + "shear_bands_" +
+                             Utilities::int_to_string(max_lvl) +
+                             ".csv";
+
+      Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
+
+      return std::make_pair("writing:", filename);
+    }
+
+
+
+    /**
+      * A postprocessor that evaluates the groeth rate of the shear bands.
+      *
+      * The implementation of error evaluators correspond to the
+      * benchmarks defined in the paper:
+      * Laura Alisic, John F. Rudge, Richard F. Katz, Garth N. Wells, Sander Rhebergen:
+      * "Compaction around a rigid, circular inclusion in partially molten rock."
+      * Journal of Geophysical Research: Solid Earth 119.7 (2014): 5903-5920.
+      */
+    template <int dim>
+    class ShearBandsGrowthRate : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Initialization function. Take references to the material model and
+         * initial conditions model to get the parameters necessary for computing
+         * the analytical solution for the growth rate and store them.
+         */
+        void
+        initialize () override;
+
+      private:
+        double amplitude;
+        double background_porosity;
+        double initial_band_angle;
+        double eta_0;
+        double xi_0;
+        double alpha;
+    };
+
+
+    template <int dim>
+    void
+    ShearBandsGrowthRate<dim>::initialize ()
+    {
+      AssertThrow(Plugins::plugin_type_matches<const ShearBandsMaterial<dim>>(this->get_material_model()),
+                  ExcMessage("Postprocessor shear bands growth rate only works with the material model shear bands."));
+
+      const ShearBandsMaterial<dim> &
+      material_model
+        = Plugins::get_plugin_as_type<const ShearBandsMaterial<dim>>(this->get_material_model());
+
+      background_porosity = material_model.get_background_porosity();
+      eta_0               = material_model.reference_viscosity();
+      xi_0                = material_model.get_reference_compaction_viscosity();
+      alpha               = material_model.get_porosity_exponent();
+
+      const PlaneWaveMeltBandsInitialCondition<dim> &initial_composition
+        = this->get_initial_composition_manager().template
+          get_matching_initial_composition_model<PlaneWaveMeltBandsInitialCondition<dim>> ();
+
+      amplitude           = initial_composition.get_wave_amplitude();
+      initial_band_angle  = initial_composition.get_initial_band_angle();
+    }
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    ShearBandsGrowthRate<dim>::execute (TableHandler &/*statistics*/)
+    {
+      // compute analytical melt band growth rate
+      const double time = this->get_time();
+      const Point<dim> upper_boundary_point = this->get_geometry_model().representative_point(0.0);
+      const Point<dim> lower_boundary_point = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
+
+      types::boundary_id upper_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+      types::boundary_id lower_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
+
+      const BoundaryVelocity::Manager<dim> &bm = this->get_boundary_velocity_manager();
+      const double max_velocity = bm.boundary_velocity(upper_boundary, upper_boundary_point).norm();
+      const double min_velocity = bm.boundary_velocity(lower_boundary, lower_boundary_point).norm();
+
+      const double strain_rate = 0.5 * (max_velocity + min_velocity) / this->get_geometry_model().maximal_depth();
+      const double theta = std::atan(std::sin(initial_band_angle) / (std::cos(initial_band_angle) - time * strain_rate/sqrt(2.0) * std::sin(initial_band_angle)));
+      const double analytical_growth_rate = - eta_0 / (xi_0 + 4.0/3.0 * eta_0) * alpha * (1.0 - background_porosity)
+                                            * 2.0 * strain_rate * std::sin(2.0 * theta);
+
+      // integrate velocity divergence
+      const QGauss<dim> quadrature_formula (this->get_fe()
+                                            .base_element(this->introspection().base_elements.velocities).degree+1);
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_gradients   |
+                               update_quadrature_points |
+                               update_JxW_values);
+      std::vector<double> velocity_divergences(n_q_points);
+      std::vector<Point<dim>> position(n_q_points);
+
+      double local_velocity_divergence_max = 0.0;
+      double local_velocity_divergence_min = 0.0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.velocities].get_function_divergences (this->get_solution(),
+                velocity_divergences);
+            position = fe_values.get_quadrature_points();
+
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                const double relative_depth = this->get_geometry_model().depth(position[q]) / this->get_geometry_model().maximal_depth();
+                const double relative_x = 0.25 * position[q](0) / this->get_geometry_model().maximal_depth();
+                if (relative_depth < 0.55 && relative_depth > 0.45 && relative_x < 0.75 && relative_x > 0.25)
+                  {
+                    local_velocity_divergence_max = std::max (velocity_divergences[q], local_velocity_divergence_max);
+                    local_velocity_divergence_min = std::min (velocity_divergences[q], local_velocity_divergence_min);
+                  }
+              }
+          }
+
+      const double global_velocity_divergence_max
+        = Utilities::MPI::max (local_velocity_divergence_max, this->get_mpi_communicator());
+      const double global_velocity_divergence_min
+        = Utilities::MPI::min (local_velocity_divergence_min, this->get_mpi_communicator());
+
+      // compute modelled melt band growth rate
+      const double numerical_growth_rate = (0 <= initial_band_angle && initial_band_angle < numbers::PI /2.
+                                            ?
+                                            (1.0 - background_porosity) / (amplitude * background_porosity) * global_velocity_divergence_max
+                                            :
+                                            (1.0 - background_porosity) / (amplitude * background_porosity) * global_velocity_divergence_min);
+
+      const double relative_error = (analytical_growth_rate != 0.0) ?
+                                    std::abs(numerical_growth_rate - analytical_growth_rate)/analytical_growth_rate
+                                    :
+                                    1.0;
+
+      // compute and output error
+      std::ostringstream os;
+      os << std::scientific << initial_band_angle
+         << ", " << analytical_growth_rate
+         << ", " << numerical_growth_rate
+         << ", " << relative_error;
+
+      return std::make_pair("Initial angle, Analytical growth rate, Modelled growth rate, Error:", os.str());
+    }
+
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace ShearBands
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ShearBandsMaterial,
+                                   "shear bands material",
+                                   "A material model that corresponds to the setup to"
+                                   "generate magmatic shear bands described in Katz et al., "
+                                   "Nature, 2006.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(ShearBandsPostprocessor,
+                                  "shear bands statistics",
+                                  "A postprocessor that writes output for the porosity field, "
+                                  "which can be used to calculate the angle of the shear "
+                                  "bands in the model.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(ShearBandsGrowthRate,
+                                  "shear bands growth rate",
+                                  "A postprocessor computes the growth rate of melt bands as "
+                                  "presicted from linear stability analysis (Spiegelman, 2003), "
+                                  "and compares modelled and analytical solution.")
+
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(ShearBandsInitialCondition,
+                                              "shear bands initial condition",
+                                              "Composition is set to background porosity plus "
+                                              "white noise.")
+
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(PlaneWaveMeltBandsInitialCondition,
+                                              "plane wave melt bands initial condition",
+                                              "Composition is set to background porosity plus "
+                                              "plane wave.")
+  }
+}
diff --git a/benchmarks/shear_bands/shear_bands.prm.bak b/benchmarks/shear_bands/shear_bands.prm.bak
new file mode 100644
index 00000000000..7ded4bef6be
--- /dev/null
+++ b/benchmarks/shear_bands/shear_bands.prm.bak
@@ -0,0 +1,130 @@
+# Listing of Parameters
+# ---------------------
+# Set up the magmatic shear bands testcase
+# with non-linear rheology after Katz et al.,
+# 2006: The dynamics of melt and shear
+# localization in partially molten aggregates.
+
+set Additional shared libraries            = ./libshear_bands.so
+set Adiabatic surface temperature          = 1623
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = output
+set Max nonlinear iterations               = 50
+set Nonlinear solver tolerance             = 1e-5
+set Dimension                              = 2
+set End time                               = 3.125e-8
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+# we want to have a similar contribution of velocity and strain rate
+# in the stabilization. Velocities are on the order of 1e-3 and cell
+# size * strain rate (which is used in the stabilization and scaled
+# by the parameter gamma) is on the order of 1e-5, so we set gamma to
+# 100.
+subsection Discretization
+  set Composition polynomial degree = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.05
+    set gamma = 100
+    set Use artificial viscosity smoothing = true
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# we apply simple shear here, so that the top and bottom boundaries
+# move with the same speed u0, but in opposite directions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+
+  subsection Function
+    set Function constants = u0=3.2e4,ymid=0.0005
+    set Function expression = u0*(y/ymid-1.0);0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.004
+    set Y extent  = 0.001
+    set X periodic = true
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=64000
+    set Function expression = 0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = shear bands initial condition
+end
+
+subsection Material model
+  set Model name = shear bands material
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics,shear bands statistics
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, thermal expansivity, strain rate, melt material properties, artificial viscosity composition
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Artificial viscosity composition
+      set Name of compositional field = porosity
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
diff --git a/benchmarks/sinking_block/blank.prm.bak b/benchmarks/sinking_block/blank.prm.bak
new file mode 100644
index 00000000000..30107e52825
--- /dev/null
+++ b/benchmarks/sinking_block/blank.prm.bak
@@ -0,0 +1,58 @@
+# This is the common core prm file for the sinking block benchmark.
+# It is used by the run_benchmark script which runs the benchmark
+# for various viscosity ratios and density differences.
+# This file cannot be used by aspect - see instead sinking_block.prm
+
+set Additional shared libraries  = ./libsinking_block.so
+set Dimension                    = 2
+set Start time                   = 0
+set End time                     = 0
+set Pressure normalization       = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 512e3
+    set Y extent  = 512e3
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, point values, matrix statistics
+
+  subsection Point values
+    set Evaluation points = 256e3,384e3
+  end
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
diff --git a/benchmarks/sinking_block/sinking_block.cc.bak b/benchmarks/sinking_block/sinking_block.cc.bak
new file mode 100644
index 00000000000..16d038841ee
--- /dev/null
+++ b/benchmarks/sinking_block/sinking_block.cc.bak
@@ -0,0 +1,232 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  namespace SinkingBlockBenchmark
+  {
+    using namespace dealii;
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class SinkingBlockMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> &pos = in.position[i];
+              if (method==0)
+                {
+                  if ( std::abs(pos[0]-256e3)<64e3 && std::abs(pos[1]-384e3)<64e3)
+                    {
+                      out.viscosities[i] = eta2;
+                      out.densities[i] = rho2;
+                    }
+                  else
+                    {
+                      out.viscosities[i] = eta1;
+                      out.densities[i] = rho1;
+                    }
+                }
+              else if (method==1)
+                {
+                  if ( std::abs(pos[0]-256e3)<64e3 && std::abs(pos[1]-384e3)<64e3)
+                    {
+                      out.viscosities[i] = eta2;
+                      out.densities[i] = rho2-rho1;
+                    }
+                  else
+                    {
+                      out.viscosities[i] = eta1;
+                      out.densities[i] = 0;
+                    }
+                }
+              else if (method==2)
+                {
+                  if ( std::abs(pos[1]-384e3)<64e3)
+                    {
+                      if ( std::abs(pos[0]-256e3)<64e3) // in block
+                        {
+                          out.viscosities[i] = eta2;
+                          out.densities[i] = 0.75*(rho2-rho1);
+                        }
+                      else // left and right of block
+                        {
+                          out.viscosities[i] = eta1;
+                          out.densities[i] = -0.25*(rho2-rho1);
+                        }
+                    }
+                  else
+                    {
+                      out.viscosities[i] = eta1;
+                      out.densities[i] = 0;
+                    }
+                }
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm)
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("SinkingBlock");
+            {
+              prm.declare_entry ("eta1", "1e21",
+                                 Patterns::Double (0),
+                                 "Viscosity of the mantle.");
+              prm.declare_entry ("eta2", "1e23",
+                                 Patterns::Double (0),
+                                 "Viscosity in the Inclusion.");
+              prm.declare_entry ("rho1", "3200",
+                                 Patterns::Double (0),
+                                 "density of the mantle.");
+              prm.declare_entry ("rho2", "3232",
+                                 Patterns::Double (0),
+                                 "density in the Inclusion.");
+              prm.declare_entry ("method", "0",
+                                 Patterns::Integer (0,2),
+                                 "density field treatment. Acceptable values are "
+                                 "0 (full densities), 1 (reduced densities), and "
+                                 "2 (vertically averaged density profile is removed"
+                                 " --see Thieulot and Bangerth, In prep.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("SinkingBlock");
+            {
+              eta1 = prm.get_double ("eta1");
+              eta2 = prm.get_double ("eta2");
+              rho1 = prm.get_double ("rho1");
+              rho2 = prm.get_double ("rho2");
+              method = prm.get_integer ("method");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          // Declare dependencies on solution variables
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+      private:
+        double eta1;
+        double eta2;
+        double rho1;
+        double rho2;
+        int method;
+
+    };
+
+
+    template <int dim>
+    bool
+    SinkingBlockMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace SinkingBlockBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SinkingBlockMaterial,
+                                   "SinkingBlockMaterial",
+                                   "A material model that corresponds to the `SinkingBlock' benchmark. "
+                                   "See the manual for more information.")
+  }
+}
diff --git a/benchmarks/sinking_block/sinking_block.prm.bak b/benchmarks/sinking_block/sinking_block.prm.bak
new file mode 100644
index 00000000000..3d1e1348fd5
--- /dev/null
+++ b/benchmarks/sinking_block/sinking_block.prm.bak
@@ -0,0 +1,71 @@
+# This is the standalone prm file for the sinking block benchmark.
+
+set Additional shared libraries  = ./libsinking_block.so
+set Dimension                    = 2
+set Start time                   = 0
+set End time                     = 0
+set Output directory             = output-block
+set Pressure normalization       = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 512e3
+    set Y extent  = 512e3
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name  = SinkingBlockMaterial
+
+  subsection SinkingBlock
+    set eta1 = 1e21
+    set eta2 = 1e22
+    set rho1 = 3200
+    set rho2 = 3208
+    set method = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 5
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
diff --git a/benchmarks/slab_detachment/slab_detachment.prm.bak b/benchmarks/slab_detachment/slab_detachment.prm.bak
new file mode 100644
index 00000000000..eacb778f226
--- /dev/null
+++ b/benchmarks/slab_detachment/slab_detachment.prm.bak
@@ -0,0 +1,152 @@
+# Input file for the Detachment benchmark of
+# Schmalholz 2011 as performed in the paper of Glerum et al. 2017.
+# It considers a 2D box with a lithosphere of nonlinear rheology
+# and a vertically hanging slab that necks over time.
+
+set Dimension                              = 2
+set End time                               = 7.8894e14 #seconds = 25My
+set Use years in output instead of seconds = true
+set Output directory                       = output_slab_detachment
+
+#set Nonlinear solver scheme                = iterated Advection and Newton Stokes
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-6
+set Max nonlinear iterations               = 50
+set CFL number                             = 1
+
+# A 2D rectangle of 1000x660 km.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000.0
+    set Y extent = 660000.0
+    set X repetitions = 100
+    set Y repetitions = 66
+  end
+end
+
+# Vertical gravity.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# setting up DG for composition(s)
+#subsection Discretization
+#   set Use discontinuous composition discretization = true
+#   subsection Stabilization parameters
+#      set Use limiter for discontinuous composition solution = true
+#      set Global composition maximum = 1.
+#      set Global composition minimum = 0.
+#   end
+#end
+
+# there are two compositions, one background (mantle) and one additional (slab)
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = slab
+end
+
+# Dislocation rheology set to linear viscosity in the mantle.
+# Temperature effects are not considered.
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature  = 273
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0,      0
+    set Heat capacities       = 750.,   750.
+    set Densities             = 3150,   3300
+    set Thermal expansivities = 0,      0
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep          =  1e-21, 1.22773766e-48
+    set Stress exponents for dislocation creep    =   1, 4
+    set Activation energies for dislocation creep =   0, 0
+    set Activation volumes for dislocation creep  =   0, 0
+
+    # cohesion set really high to generate very large plastic
+    # viscosities which will not be taken into account
+    # by the material model.
+    set Angles of internal friction = 0 , 0
+    set Cohesions                   = 1e15, 1e15
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+#free slip boundary conditions on the top and bottom,
+# no slip on left and right boundaries
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+  set Zero velocity boundary indicators       = left, right
+end
+
+# Temperature effects are not considered,
+# so we set everything to zero.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273 # cannot be zero!!!
+  end
+end
+
+# Description of the initial compositional fields mantle and slab
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = if((x<460000.0&z<580000.0)|(z<330000.0&x>=460000.0&x<540000.0)|(z<580000.0&x>=540000.0),0,1)
+  end
+end
+
+# We output the solution every 1 My and monitor the velocity
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, particles
+
+  subsection Visualization
+    set Time between graphical output = 1e6
+    set List of output variables      = strain rate, viscosity, density
+  end
+
+  subsection Particles
+    set Time between data output  = 1e6
+    set Data output format        = ascii
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+# We read a file with 22 initial particle locations and
+# output the new particle locations over time to an ascii file.
+subsection Particles
+  set Particle generator name   = ascii file
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/slab_detachment/
+      set Data file name = initial_particle_location.dat
+    end
+  end
+end
diff --git a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc.bak b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc.bak
new file mode 100644
index 00000000000..4c98e51cf63
--- /dev/null
+++ b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc.bak
@@ -0,0 +1,46 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "solcx_compositional_fields.h"
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SolCxCompositionalMaterial,
+                                   "SolCxCompositionalMaterial",
+                                   "A material model that corresponds to the 'SolCx' benchmark "
+                                   "as defined in Duretz et al., G-Cubed, 2011 using "
+                                   "compositional fields. ")
+
+
+    ASPECT_REGISTER_POSTPROCESSOR(SolCxPostprocessor,
+                                  "SolCxPostprocessor",
+                                  "A postprocessor that compares the solution of the benchmarks from "
+                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
+                                  "and reports the error. Specifically, it can compute the errors for "
+                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
+                                  "which material model is currently being used and adjusts "
+                                  "which exact solution to use accordingly.")
+  }
+}
diff --git a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.h.bak b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.h.bak
new file mode 100644
index 00000000000..40eafb19602
--- /dev/null
+++ b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.h.bak
@@ -0,0 +1,34 @@
+#ifndef ASPECT_SOLCX_COMPOSITIONAL_FIELDS_H
+#define ASPECT_SOLCX_COMPOSITIONAL_FIELDS_H
+
+#include "../solcx.h"
+
+
+
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class SolCxCompositionalMaterial : public SolCxMaterial<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              out.densities[i] = in.composition[i][0];
+              out.viscosities[i] = in.composition[i][1];
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+    };
+  }
+}
+#endif
diff --git a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm
index 724762bcdfb..959a224769a 100644
--- a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm
+++ b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm
@@ -70,7 +70,6 @@ subsection Discretization
   set Use locally conservative discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
     set Global composition maximum = 1, 1e6
     set Global composition minimum = -1, 1
   end
diff --git a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm.bak b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm.bak
new file mode 100644
index 00000000000..724762bcdfb
--- /dev/null
+++ b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm.bak
@@ -0,0 +1,95 @@
+# A description of the SolCX benchmark for which a known solution
+# is available. See the manual for more information.
+
+set Additional shared libraries            = ./libsolcx_compositional_fields.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolCxCompositionalMaterial
+
+  subsection SolCx
+    set Viscosity jump = 1e6
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = density_comp, viscosity_comp
+  set Compositional field methods = field, field
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x, z
+    set Function constants  = pi=3.1415926536, eta_b=1e6, background_density=0.0
+    set Function expression = background_density - sin(pi*z) * cos(pi*x); if(x<=0.5, 1, eta_b)
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Composition polynomial degree           = 2
+  set Stokes velocity polynomial degree       = 2
+  set Use discontinuous composition discretization = true
+  set Use locally conservative discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
+    set Global composition maximum = 1, 1e6
+    set Global composition minimum = -1, 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, SolCxPostprocessor
+
+  subsection Visualization
+    set Output format = vtu
+    set Number of grouped files = 1
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
diff --git a/benchmarks/solcx/compositional_fields/solcx_particles.prm b/benchmarks/solcx/compositional_fields/solcx_particles.prm
index 624d2616aaa..d12d68df74c 100644
--- a/benchmarks/solcx/compositional_fields/solcx_particles.prm
+++ b/benchmarks/solcx/compositional_fields/solcx_particles.prm
@@ -55,7 +55,6 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = false # apply the limiter to the DG solutions
   end
 end
 
diff --git a/benchmarks/solcx/compositional_fields/solcx_particles.prm.bak b/benchmarks/solcx/compositional_fields/solcx_particles.prm.bak
new file mode 100644
index 00000000000..624d2616aaa
--- /dev/null
+++ b/benchmarks/solcx/compositional_fields/solcx_particles.prm.bak
@@ -0,0 +1,128 @@
+# A description of the SolCX benchmark using active particles
+# to interpolate both density and viscosity onto the compositional
+# field for which a known solution is available. See the manual
+# for more information.
+
+set Additional shared libraries            = ./libsolcx_compositional_fields.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolCxCompositionalMaterial
+
+  subsection SolCx
+    set Viscosity jump = 1e6
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = true
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = false # apply the limiter to the DG solutions
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = density_comp, viscosity_comp
+  set Compositional field methods = particles, particles
+
+  # In the source code, we assumed that density is being carried
+  # on compositional field 1 (at index 0) and viscosity is being
+  # carried on compositional field 2 (at index 1).  If this order
+  # is changed, then the evaluate() function in solcx_compositional_fields.h
+  # must also be changed.
+  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926, eta_b=1e6, background_density=0.0
+    set Function expression = background_density - sin(pi*y) * cos(pi*x); if(x<0.5, 1, eta_b)
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, visualization, SolCxPostprocessor
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Number of grouped files       = 1
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = cell average
+  set Maximum particles per cell = 16384
+  set Update ghost particles = true
+  set Particle generator name = reference cell
+
+  subsection Function
+    set Number of components = 2
+    set Variable names      = x, y
+    set Function constants  = pi=3.1415926, eta_b=1e6, background_density=0.0
+    set Function expression =  background_density - sin(pi*y) * cos(pi*x); if(x<0.5, 1, eta_b)
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 4
+    end
+  end
+end
diff --git a/benchmarks/solcx/doc/solcx.prm.bak b/benchmarks/solcx/doc/solcx.prm.bak
new file mode 100644
index 00000000000..fa9a9331c43
--- /dev/null
+++ b/benchmarks/solcx/doc/solcx.prm.bak
@@ -0,0 +1,60 @@
+set Additional shared libraries            = ./libsolcx.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+
+  subsection SolCx
+    set Viscosity jump = 1e6
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor, visualization
+end
diff --git a/benchmarks/solcx/solcx.cc.bak b/benchmarks/solcx/solcx.cc.bak
new file mode 100644
index 00000000000..96081618aad
--- /dev/null
+++ b/benchmarks/solcx/solcx.cc.bak
@@ -0,0 +1,44 @@
+/*
+  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include "solcx.h"
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SolCxMaterial,
+                                   "SolCxMaterial",
+                                   "A material model that corresponds to the 'SolCx' benchmark "
+                                   "defined in Duretz et al., G-Cubed, 2011.")
+
+
+    ASPECT_REGISTER_POSTPROCESSOR(SolCxPostprocessor,
+                                  "SolCxPostprocessor",
+                                  "A postprocessor that compares the solution of the benchmarks from "
+                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
+                                  "and reports the error. Specifically, it can compute the errors for "
+                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
+                                  "which material model is currently being used and adjusts "
+                                  "which exact solution to use accordingly.")
+  }
+}
diff --git a/benchmarks/solcx/solcx.h.bak b/benchmarks/solcx/solcx.h.bak
new file mode 100644
index 00000000000..0e7c8100a48
--- /dev/null
+++ b/benchmarks/solcx/solcx.h.bak
@@ -0,0 +1,3189 @@
+#ifndef ASPECT_SOLCX_H
+#define ASPECT_SOLCX_H
+
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+
+namespace aspect
+{
+  /**
+   * This is the "Sol Cx" benchmark defined in the following paper:
+   * @code
+   *  @Article{DMGT11,
+   *    author =       {T. Duretz and D. A. May and T. V. Gerya and P. J. Tackley},
+   *    title =        {Discretization errors and free surface stabilization in the
+   *                  finite difference and marker-in-cell method for applied
+   *                  geodynamics: {A} numerical study},
+   *    journal =      {Geochemistry Geophysics Geosystems},
+   *    year =         2011,
+   *    volume =       12,
+   *    pages =        {Q07004/1--26}}
+   * @endcode
+   *
+   * The results are published in Kronbichler, Heister and Bangerth paper.
+   */
+  namespace InclusionBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+      // based on http://geodynamics.org/hg/cs/AMR/Discontinuous_Stokes with permission
+      // The following code has been taken from http://www.underworldproject.org/,
+      // release 1.7.0. As mentioned in the Underworld Manual, this code has been
+      // released under the GNU General Public License (GPL).
+
+      void _Velic_solCx(
+        double pos[],
+        double _eta_A, double _eta_B,   /* Input parameters: density, viscosity A, viscosity B */
+        double _x_c, int _n,      /* Input parameters: viscosity jump location, wavenumber in x */
+        double vel[], double *presssure,
+        double total_stress[], double strain_rate[])
+      {
+        const double PI = numbers::PI;
+        double Z, u1, u2, u3, u4, u5, u6, ZA, ZB;
+        double sum1, sum2, sum3, sum4, sum5, sum6, x, z, xc;
+        double _C1A, _C2A, _C3A, _C4A, _C1B, _C2B, _C3B, _C4B, _C1, _C2, _C3, _C4;
+        int n, nx;
+
+        double t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40;
+        double t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57, t58, t59, t60, t61, t62, t63, t64, t65, t66, t67, t68, t69, t70, t71, t72, t73, t74, t75, t76, t77, t78, t79, t80;
+        double t81, t82, t83, t84, t85, t86, t87, t88, t89, t90, t91, t92, t93, t94, t95, t96, t97, t98, t99, t100, t101, t102, t103, t104, t105, t106, t107, t108, t109, t110, t111, t112, t113, t115, t116, t117, t118, t119, t120;
+        double t121, t122, t123, t124, t125, t126, t127, t128, t129, t130, t131, t132, t133, t134, t135, t136, t137, t138, t139, t140, t141, t142, t143, t144, t145, t146, t147, t148, t149, t150, t151, t152, t153, t154, t155, t156, t157, t158, t159, t160;
+        double t161, t162, t163, t164, t165, t166, t167, t168, t169, t170, t171, t172, t173, t174, t175, t176, t177, t178, t179, t180, t181, t182, t183, t184, t186, t187, t188, t189, t190, t191, t192, t193, t194, t195, t196, t197, t198, t199;
+        double t201, t202, t203, t204, t206, t207, t208, t209, t210, t211, t212, t213, t215, t216, t217, t218, t219, t220, t221, t222, t223, t224, t225, t226, t227, t228, t229, t230, t231, t232, t233, t234, t235, t236, t237, t238, t239, t240;
+        double t241, t242, t243, t244, t245, t246, t247, t248, t249, t250, t251, t252, t253, t254, t255, t256, t257, t258, t259, t260, t261, t262, t263, t264, t265, t267, t268, t269, t270, t272, t273, t274, t275, t276, t277, t278, t279, t280;
+        double t281, t282, t283, t284, t285, t286, t288, t289, t290, t291, t292, t295, t296, t297, t298, t299, t300, t301, t303, t304, t305, t307, t308, t310, t311, t312, t313, t314, t315, t316, t317, t318, t319, t320;
+        double t321, t322, t323, t324, t325, t326, t327, t328, t329, t330, t331, t332, t334, t335, t336, t337, t338, t339, t340, t341, t342, t344, t345, t346, t347, t348, t349, t350, t351, t352, t353, t354, t355, t356, t358, t359, t360;
+        double t361, t362, t363, t364, t365, t366, t367, t368, t369, t370, t371, t372, t373, t374, t375, t376, t377, t378, t379, t380, t381, t382, t383, t384, t385, t386, t387, t389, t390, t391, t393, t394, t395, t396, t397, t398;
+        double t401, t402, t403, t404, t405, t406, t407, t408, t409, t410, t411, t412, t413, t414, t415, t416, t417, t418, t419, t421, t422, t423, t424, t425, t426, t427, t428, t429, t430, t431, t432, t433, t434, t436, t437, t438, t439, t440;
+        double t441, t442, t443, t444, t445, t446, t447, t448, t450, t451, t453, t454, t455, t456, t457, t458, t459, t461, t462, t463, t464, t465, t466, t468, t469, t470, t471, t474, t475, t478, t480;
+        double t482, t483, t484, t485, t488, t489, t490, t492, t493, t495, t497, t498, t499, t501, t502, t503, t504, t505, t507, t508, t509, t510, t511, t512, t513, t515, t518, t520;
+        double t522, t525, t527, t528, t529, t530, t532, t533, t534, t535, t536, t538, t539, t541, t542, t544, t545, t546, t547, t548, t549, t550, t551, t552, t553, t554, t555, t556, t557, t560;
+        double t561, t562, t563, t564, t567, t568, t571, t573, t575, t576, t578, t579, t583, t590, t591, t594, t595, t596, t597, t598, t600;
+        double t601, t602, t604, t606, t607, t608, t611, t613, t615, t616, t617, t619, t621, t623, t624, t625, t626, t627, t629, t630, t632, t633, t634, t638, t639, t640;
+        double t641, t642, t643, t644, t645, t647, t648, t649, t650, t651, t652, t653, t654, t655, t656, t657, t658, t659, t660, t662, t663, t665, t666, t667, t668, t670, t671, t672, t673, t674, t675, t676, t679, t680;
+        double t682, t683, t684, t685, t686, t688, t689, t690, t691, t693, t694, t695, t696, t697, t698, t699, t700, t701, t702, t704, t705, t708, t709, t711, t712, t713, t714, t717, t718, t719;
+        double t721, t722, t723, t726, t727, t728, t730, t733, t734, t735, t736, t737, t738, t739, t740, t741, t744, t745, t746, t749, t750, t752, t753, t754, t755, t757, t758, t759, t760;
+        double t761, t762, t763, t764, t766, t767, t768, t770, t771, t772, t773, t774, t775, t776, t777, t778, t780, t781, t782, t785, t786, t789, t790, t791, t792, t793, t794, t795, t796, t797, t798, t800;
+        double t801, t806, t807, t808, t809, t811, t812, t817, t818, t819, t821, t822, t824, t827, t828, t830, t834, t835, t837, t840;
+        double t842, t843, t844, t845, t846, t849, t850, t853, t854, t855, t857, t858, t859, t860, t863, t864, t867, t868, t869, t873, t874, t877, t878, t879, t880;
+        double t884, t888, t891, t894, t900, t901, t903, t904, t907, t908, t909, t911, t914, t915, t916, t919, t920;
+        double t923, t924, t925, t926, t927, t929, t932, t935, t937, t939, t942, t943, t944, t945, t947, t948, t949, t950, t952, t953, t954, t955, t956, t957;
+        double t961, t964, t965, t966, t967, t968, t969, t971, t972, t974, t977, t978, t981, t983, t987, t988, t992, t993, t994, t997, t998;
+        double t1001, t1003, t1005, t1006, t1009, t1010, t1012, t1013, t1015, t1016, t1017, t1018, t1020, t1021, t1029, t1031, t1032, t1033, t1040;
+        double t1041, t1042, t1044, t1047, t1050, t1054, t1055, t1057, t1058, t1063, t1068, t1069, t1070, t1079, t1080;
+        double t1088, t1089, t1091, t1092, t1094, t1096, t1101, t1102, t1103, t1104, t1105, t1108, t1112, t1113, t1118, t1119, t1120;
+        double t1121, t1122, t1123, t1124, t1125, t1126, t1127, t1128, t1129, t1130, t1132, t1133, t1134, t1135, t1138, t1139, t1140, t1141, t1142, t1145, t1146, t1148, t1149, t1150, t1153, t1154, t1156, t1157, t1158, t1159;
+        double t1161, t1162, t1165, t1166, t1170, t1171, t1172, t1173, t1175, t1176, t1178, t1180, t1181, t1182, t1185, t1189, t1192, t1193, t1195, t1196, t1199;
+        double t1201, t1203, t1209, t1210, t1211, t1213, t1214, t1218, t1221, t1224, t1225, t1226, t1228, t1233, t1234, t1235, t1236, t1237, t1240;
+        double t1241, t1242, t1243, t1244, t1245, t1248, t1251, t1252, t1257, t1258, t1259, t1260, t1263, t1268, t1269, t1272, t1280;
+        double t1282, t1283, t1284, t1285, t1287, t1288, t1289, t1292, t1293, t1296, t1297, t1300, t1304, t1307, t1310, t1311, t1312, t1316, t1317, t1320;
+        double t1321, t1323, t1328, t1330, t1331, t1332, t1333, t1336, t1338, t1343, t1344, t1346, t1349, t1350, t1354;
+        double t1366, t1369, t1370, t1371, t1376, t1378, t1380, t1383, t1386, t1387, t1388, t1391, t1393, t1399;
+        double t1411, t1412, t1420, t1427;
+        double t1450, t1456, t1468, t1472, t1474, t1478;
+        double t1504, t1511;
+        double t1545;
+        double t1564, t1583;
+
+
+        /* del_rho = sin(n*Pi*z)*cos(nx*Pi*x)  n=nx gives only non-zero terms*/
+        n = _n; /* only one n in Fourier series because  del_rho has cos term */
+        nx = 1; /* can set these two to whatever we like */
+
+        ZA = _eta_A; /* left column viscosity */
+        ZB = _eta_B; /* right column viscosity */
+        xc = _x_c;
+
+        x = pos[0];
+        z = pos[1];
+
+        sum1 = 0.0;
+        sum2 = 0.0;
+        sum3 = 0.0;
+        sum4 = 0.0;
+        sum5 = 0.0;
+        sum6 = 0.0;
+
+        // Note that there is no Fourier sum here.
+        /****************************************************************************************/
+        _C1A = 0;
+        /****************************************************************************************/
+        t1 = nx * 0.3141592654e1;
+        t2 = sin(t1);
+        t3 = nx * t2;
+        t4 = n * n;
+        t5 = t4 * t4;
+        t6 = 0.3141592654e1 * 0.3141592654e1;
+        t8 = t3 * t5 * t6;
+        t9 = ZA * xc;
+        t12 = exp(xc * n * 0.3141592654e1);
+        t13 = t12 * t12;
+        t15 = n * 0.3141592654e1;
+        t16 = exp(t15);
+        t17 = t16 * t16;
+        t18 = t17 * t16;
+        t19 = ZB * t13 * t18;
+        t20 = t9 * t19;
+        t23 = ZA * ZA;
+        t24 = nx * nx;
+        t25 = t24 * nx;
+        t26 = t23 * t25;
+        t28 = t13 * t13;
+        t29 = t28 * t13;
+        t33 = nx * ZB;
+        t34 = t1 * xc;
+        t35 = sin(t34);
+        t36 = t4 * n;
+        t37 = t35 * t36;
+        t38 = t33 * t37;
+        t39 = 0.3141592654e1 * ZA;
+        t40 = t13 * t12;
+        t41 = t17 * t40;
+        t45 = ZB * ZB;
+        t46 = t45 * t24;
+        t47 = t46 * t4;
+        t48 = 0.3141592654e1 * xc;
+        t49 = t13 * t17;
+        t53 = xc * xc;
+        t54 = t36 * t53;
+        t56 = t54 * t6 * t45;
+        t57 = cos(t34);
+        t58 = t57 * t24;
+        t59 = t28 * t12;
+        t60 = t17 * t59;
+        t61 = t58 * t60;
+        t64 = t25 * t2;
+        t65 = t64 * t15;
+        t72 = nx * t23;
+        t74 = t72 * t2 * t5;
+        t75 = t6 * t53;
+        t76 = t16 * t29;
+        t80 = t23 * n;
+        t81 = t80 * 0.3141592654e1;
+        t82 = t18 * t28;
+        t86 = nx * t5;
+        t87 = t23 * t6;
+        t89 = xc * t2;
+        t90 = t13 * t18;
+        t91 = t89 * t90;
+        t94 = t28 * t28;
+        t96 = t24 * n;
+        t98 = t4 * t45;
+        t99 = t98 * 0.3141592654e1;
+        t100 = t58 * t41;
+        t104 = 0.3141592654e1 * t25;
+        t105 = ZA * n * t104;
+        t106 = t2 * ZB;
+        t110 = t17 * t17;
+        t111 = ZA * t110;
+        t116 = n * t28;
+        t122 = t64 * t4 * t6;
+        t126 = t23 * t29 * t4;
+        t128 = t24 * xc;
+        t132 = t36 * t23;
+        t133 = t6 * t57;
+        t135 = t128 * t41;
+        t138 = t6 * xc;
+        t142 = t72 * t2;
+        t147 = 0.4e1 * t8 * t20 - 0.2e1 * t26 * t2 * t16 * t29 - 0.8e1 * t38 * t39 * t41 + 0.4e1 * t47 * t48 * t49 -
+               0.8e1 * t56 * t61 - 0.4e1 * t65 * t20 + 0.2e1 * t26 * t2 * t18 * t28 - 0.4e1 * t74 * t75 * t76 -
+               0.2e1 * t81 * t64 * t82 - 0.4e1 * t86 * t87 * t91 - t23 * t94 * t96 + 0.8e1 * t99 * t100 -
+               0.2e1 * t105 * t106 * t82 - 0.4e1 * t38 * t48 * t111 * t12 + 0.2e1 * t116 * ZB * t111 * t24 +
+               0.4e1 * t122 * t20 + 0.4e1 * t126 * 0.3141592654e1 * t17 * t128 + 0.8e1 * t132 * t133 * t135 +
+               0.4e1 * t74 * t138 * t76 - 0.2e1 * t142 * t4 * t18 * t28;
+        t149 = ZA * t25 * t2;
+        t150 = ZB * t28;
+        t154 = t35 * t5;
+        t155 = t72 * t154;
+        t156 = t75 * t41;
+        t159 = nx * ZA;
+        t160 = t2 * t36;
+        t161 = t159 * t160;
+        t162 = 0.3141592654e1 * ZB;
+        t163 = t28 * t16;
+        t167 = t23 * t57;
+        t168 = t167 * t24;
+        t169 = n * t110;
+        t170 = t169 * t40;
+        t173 = ZA * ZB;
+        t174 = t173 * t90;
+        t177 = t36 * 0.3141592654e1;
+        t181 = t80 * t104;
+        t184 = n * t17;
+        t188 = t17 * t29;
+        t190 = t4 * 0.3141592654e1;
+        t191 = t190 * t24;
+        t206 = t138 * t60;
+        t209 = t23 * t4;
+        t211 = t209 * t6 * t25;
+        t212 = t89 * t76;
+        t216 = ZB * t16 * t29;
+        t217 = t9 * t216;
+        t220 = ZB * t110;
+        t221 = ZA * t24;
+        t222 = t221 * n;
+        t225 = t132 * t75;
+        t232 = t45 * t28;
+        t233 = t110 * t24;
+        t234 = t233 * n;
+        t236 = t209 * 0.3141592654e1;
+        t237 = t17 * xc;
+        t239 = t237 * t13 * t24;
+        t242 = -0.2e1 * t149 * t150 * t16 - 0.8e1 * t155 * t156 - 0.2e1 * t161 * t162 * t163 + 0.2e1 * t168 * t170 +
+               0.2e1 * t65 * t174 - 0.2e1 * t142 * t177 * t76 + 0.4e1 * t181 * t91 - 0.4e1 * t168 * t184 * t59 -
+               0.4e1 * t188 * t23 * t191 + 0.4e1 * t38 * t48 * ZA * t17 * t40 + 0.4e1 * t49 * t23 * t191 +
+               0.2e1 * t26 * t2 * t13 * t18 - 0.8e1 * t155 * t206 + 0.4e1 * t211 * t212 - 0.4e1 * t8 * t217 +
+               0.2e1 * t220 * t222 - 0.8e1 * t225 * t100 + 0.2e1 * t142 * t4 * t16 * t29 + t232 * t234 -
+               0.4e1 * t236 * t239;
+        t244 = nx * t45;
+        t245 = t244 * t37;
+        t246 = t110 * t40;
+        t251 = t237 * t59;
+        t256 = t64 * t90;
+        t260 = t36 * t45 * t133;
+        t263 = t45 * t57;
+        t264 = t263 * t24;
+        t265 = t169 * t12;
+        t269 = t6 * t36;
+        t270 = t17 * t24;
+        t274 = t110 * t13;
+        t276 = t190 * t128;
+        t279 = nx * t36;
+        t281 = t28 * t40;
+        t282 = t281 * t35;
+        t286 = t138 * t41;
+        t289 = t75 * t60;
+        t296 = t190 * t173;
+        t305 = t86 * t45 * t35;
+        t312 = t33 * t154;
+        t313 = t6 * ZA;
+        t324 = t232 * t270;
+        t327 = -0.2e1 * t245 * t48 * t246 + 0.4e1 * t159 * t37 * t162 * t251 + 0.4e1 * t209 * t75 * t256 +
+               0.8e1 * t260 * t135 + 0.2e1 * t264 * t265 + 0.32e2 * t9 * t150 * t269 * t270 +
+               0.4e1 * t274 * t23 * t276 + 0.2e1 * t279 * t45 * t282 * t48 + 0.8e1 * t155 * t286 +
+               0.8e1 * t155 * t289 - 0.8e1 * t150 * ZA * t96 * t17 + 0.8e1 * t296 * t61 -
+               0.2e1 * t105 * t106 * t163 - 0.2e1 * t81 * t256 - 0.8e1 * t305 * t156 -
+               0.4e1 * t33 * t282 * t177 * t9 - 0.16e2 * t312 * t313 * t237 * t40 - 0.4e1 * t168 * t184 * t40 +
+               0.2e1 * t168 * t265 + 0.16e2 * t269 * t53 * t324;
+        t328 = t3 * t4;
+        t331 = t72 * t37;
+        t332 = t48 * t60;
+        t335 = n * t94;
+        t345 = t72 * t35;
+        t349 = t173 * t57;
+        t355 = t53 * t17;
+        t364 = t54 * t6 * ZB;
+        t365 = t28 * t17;
+        t369 = xc * ZB;
+        t370 = t269 * t369;
+        t371 = ZA * t57;
+        t373 = t371 * t270 * t40;
+        t385 = nx * t35;
+        t396 = t4 * xc;
+        t397 = t396 * t162;
+        t415 = t37 * t48;
+        t418 = -0.32e2 * t364 * t365 * t221 - 0.16e2 * t370 * t373 - 0.4e1 * t331 * t48 * t41 +
+               0.4e1 * t86 * t23 * t53 * t6 * t2 * t90 + 0.2e1 * t385 * t177 * t23 * xc * t246 +
+               0.16e2 * t132 * t53 * t6 * t28 * t270 - 0.4e1 * t397 * t371 * t233 * t12 -
+               0.12e2 * t173 * t58 * t190 * t251 + 0.2e1 * t385 * t36 * 0.3141592654e1 * t23 * xc * t59 -
+               0.8e1 * t99 * t61 - 0.2e1 * t244 * t59 * t415;
+        t427 = t371 * t270 * t59;
+        t439 = t209 * t48;
+        t440 = t110 * t12;
+        t441 = t58 * t440;
+        t447 = t36 * xc;
+        t455 = t48 * t440;
+        t471 = ZB * t17;
+        t492 = 0.12e2 * t397 * t373 - 0.4e1 * t122 * t217 + 0.16e2 * t364 * t427 +
+               0.16e2 * t312 * t313 * t355 * t40 - 0.8e1 * t279 * t39 * t35 * ZB * t60 + 0.2e1 * t439 * t441 -
+               0.2e1 * t81 * t64 * t163 + 0.8e1 * t447 * t87 * t61 + 0.2e1 * t23 * t59 * t57 * t276 +
+               0.2e1 * t245 * t455 - 0.4e1 * t349 * t96 * t440 - 0.16e2 * t370 * t427 + 0.4e1 * t181 * t212 -
+               0.16e2 * t365 * t23 * t269 * t128 + 0.16e2 * t86 * t138 * ZA * t35 * t471 * t59 +
+               0.8e1 * t305 * t289 - 0.4e1 * t439 * t100 + 0.2e1 * ZB * t25 * t2 * ZA * t18 * t28 +
+               0.2e1 * t142 * t4 * t28 * t16 - 0.8e1 * t56 * t100;
+        t499 = ZA * t53 * t19;
+        t505 = t396 * 0.3141592654e1;
+        t518 = t173 * t53 * t16 * t29;
+        t533 = t23 * t28;
+        t535 = t188 * t45;
+        t538 = t24 * t4;
+        t545 = t3 * t177;
+        t546 = t173 * t76;
+        t555 = t45 * t110;
+        t557 = t72 * t160;
+        t561 = -0.8e1 * t225 * t61 - 0.2e1 * t161 * t162 * t82 + t533 * t234 + 0.4e1 * t535 * t191 +
+               0.4e1 * t167 * t538 * t332 + 0.4e1 * t349 * t96 * t60 + 0.2e1 * t545 * t546 - 0.2e1 * t264 * t170 +
+               0.4e1 * t397 * t281 * ZA * t58 - t555 * t96 - 0.4e1 * t557 * t48 * t76;
+        t567 = t396 * 0.3141592654e1 * t45;
+        t568 = t58 * t246;
+        t597 = t58 * n;
+        t615 = t13 * t45;
+        t616 = t615 * t233;
+        t619 = t94 * t45;
+        t621 = t45 * t59;
+        t625 = 0.2e1 * t149 * t216 + 0.2e1 * t567 * t568 - 0.16e2 * t269 * xc * t324 -
+               0.2e1 * t236 * xc * t281 * t58 - 0.2e1 * t142 * t177 * t90 - 0.8e1 * t567 * t100 +
+               0.2e1 * t65 * t546 - 0.8e1 * t305 * t206 + 0.2e1 * n * t45 * t281 * t57 * t24 - t23 * t110 * t96 -
+               0.8e1 * t296 * t100 + 0.2e1 * t23 * t281 * t597 + 0.4e1 * t545 * t20 +
+               0.2e1 * t159 * t2 * t4 * ZB * t163 - 0.4e1 * t557 * t48 * t90 + 0.4e1 * t122 * t518 +
+               0.8e1 * t263 * t538 * t332 - 0.4e1 * t505 * t616 - t619 * t96 - 0.2e1 * t621 * t57 * t276;
+        t626 = t49 * t45;
+        t660 = t29 * t45;
+        t685 = 0.2e1 * t545 * t174 - 0.4e1 * t126 * 0.3141592654e1 * t24 * xc - 0.4e1 * t47 * t48 * t188 +
+               0.4e1 * t505 * t660 * t24 - 0.2e1 * t142 * t177 * t163 - 0.2e1 * t142 * t4 * t13 * t18 +
+               0.8e1 * t260 * t128 * t60 - 0.2e1 * t328 * t546 - 0.2e1 * t26 * t2 * t28 * t16 +
+               0.4e1 * t545 * t217 - 0.4e1 * t209 * t138 * t256;
+        t690 = t6 * 0.3141592654e1;
+        t691 = ZA * t690;
+        t693 = t24 * t24;
+        t694 = t693 * xc;
+        t695 = t188 * t694;
+        t698 = t23 * ZA;
+        t699 = t698 * t690;
+        t700 = t699 * t5;
+        t704 = t5 * t4;
+        t705 = t691 * t704;
+        t709 = t691 * t5;
+        t713 = t5 * n;
+        t714 = t713 * ZB;
+        t718 = t698 * t6;
+        t719 = t713 * t28;
+        t722 = t699 * t704;
+        t726 = t713 * t94;
+        t733 = t713 * t45;
+        t736 = t87 * t36;
+        t740 = -0.4e1 * t691 * t98 * t695 + 0.8e1 * t700 * t270 * t13 + 0.4e1 * t705 * t660 * xc +
+               0.8e1 * t709 * t660 * t128 + 0.2e1 * t87 * t714 * t110 + t718 * t719 * t110 -
+               0.4e1 * t722 * t237 * t13 - t313 * t726 * t45 - 0.4e1 * t699 * t704 * xc * t29 + t313 * t733 * t28 +
+               0.4e1 * t736 * t150 * t233;
+        t746 = t313 * t36;
+        t752 = t6 * t6;
+        t753 = t23 * t752;
+        t759 = t698 * t752;
+        t760 = t759 * t36;
+        t761 = t17 * t693;
+        t762 = xc * t28;
+        t763 = t761 * t762;
+        t766 = t87 * t713;
+        t773 = t699 * t4;
+        t774 = t110 * t693;
+        t775 = xc * t13;
+        t785 = t704 * t17;
+        t789 = -0.16e2 * t736 * t150 * t270 + t718 * t116 * t693 - 0.2e1 * t746 * t555 * t24 + 0.4e1 * t705 * t535 +
+               0.64e2 * t753 * t713 * t17 * t150 * t128 - 0.16e2 * t760 * t763 + 0.2e1 * t766 * t150 * t110 +
+               0.4e1 * t722 * t274 * xc + 0.4e1 * t773 * t774 * t775 - 0.8e1 * t766 * t150 * t17 +
+               0.8e1 * t700 * t233 * t775 + 0.4e1 * t699 * t785 * t13;
+        t791 = t691 * t4;
+        t792 = t45 * t693;
+        t793 = t49 * t792;
+        t796 = t759 * t713;
+        t797 = t53 * t28;
+        t798 = t270 * t797;
+        t801 = t87 * n;
+        t818 = t5 * t36;
+        t819 = t753 * t818;
+        t827 = t753 * t36 * ZB;
+        t830 = xc * t45;
+        t834 = -0.4e1 * t791 * t793 + 0.32e2 * t796 * t798 + 0.2e1 * t801 * ZB * t693 * t110 +
+               0.2e1 * t718 * t36 * t28 * t24 - 0.8e1 * t700 * t128 * t29 - 0.8e1 * t700 * t239 -
+               0.8e1 * t801 * t150 * t761 + 0.32e2 * t819 * t365 * t369 - 0.64e2 * t753 * t714 * t798 +
+               0.32e2 * t827 * t763 + 0.4e1 * t705 * t830 * t49;
+        t842 = xc * t29;
+        t843 = t270 * t842;
+        t849 = t759 * t818;
+        t853 = t691 * t396;
+        t857 = t691 * t5 * t45;
+        t869 = t313 * n;
+        t874 = -0.2e1 * t718 * t36 * t94 * t24 - 0.4e1 * t773 * t761 * t29 + 0.8e1 * t700 * t843 +
+               0.2e1 * t87 * t726 * ZB + 0.16e2 * t849 * t797 * t17 + 0.4e1 * t853 * t793 + 0.8e1 * t857 * t239 +
+               0.2e1 * t801 * t150 * t693 - 0.8e1 * t700 * t270 * t29 - 0.8e1 * t709 * t49 * t46 -
+               t869 * t619 * t693 + t869 * t232 * t693;
+        t877 = ZA * t752;
+        t878 = t877 * t818;
+        t911 = 0.16e2 * t878 * t53 * t45 * t365 - 0.4e1 * t699 * t785 * t29 - 0.4e1 * t705 * t188 * t830 +
+               0.2e1 * t801 * t94 * t693 * ZB - 0.8e1 * t857 * t843 - t718 * t726 + 0.4e1 * t773 * t761 * t13 -
+               0.4e1 * t705 * t775 * t555 + 0.2e1 * t746 * t232 * t233 - 0.16e2 * t878 * t830 * t365 -
+               0.2e1 * t746 * t619 * t24;
+        t916 = t110 * t28;
+        t945 = t28 * t693 * t45 * t17;
+        t948 = 0.32e2 * t877 * t733 * t798 + 0.2e1 * t718 * t36 * t916 * t24 - 0.4e1 * t705 * t626 +
+               t718 * n * t916 * t693 - t869 * t792 * t110 - 0.4e1 * t773 * t761 * t775 + t718 * t719 +
+               0.2e1 * t746 * t232 * t24 - 0.16e2 * t849 * t365 * xc - t718 * t713 * t110 -
+               0.4e1 * t773 * t694 * t29 + 0.16e2 * t877 * t54 * t945;
+        t974 = t761 * t797;
+        t987 = 0.4e1 * t773 * t695 + 0.4e1 * t736 * t150 * t24 + 0.4e1 * t722 * t842 * t17 -
+               0.16e2 * t877 * t447 * t945 + 0.2e1 * t87 * t714 * t28 + t313 * t713 * t916 * t45 -
+               0.4e1 * t853 * t615 * t774 - 0.32e2 * t877 * t713 * xc * t324 + 0.16e2 * t760 * t974 +
+               0.4e1 * t736 * t94 * t24 * ZB + t869 * t792 * t916 - 0.8e1 * t691 * t5 * xc * t616;
+        t1021 = -t718 * t169 * t693 - 0.32e2 * t827 * t974 + 0.2e1 * t801 * t150 * t774 +
+                0.4e1 * t791 * t188 * t792 + 0.4e1 * t736 * t220 * t24 + 0.4e1 * t791 * t842 * t792 +
+                0.8e1 * t709 * t660 * t270 - t718 * t335 * t693 - 0.2e1 * t718 * t36 * t110 * t24 -
+                0.32e2 * t819 * t797 * t471 - t313 * t733 * t110 - 0.32e2 * t796 * t270 * t762;
+
+        _C2A = (t147 - 0.4e1 * t65 * t217 + t418 + 0.2e1 * t150 * t222 + t327 - 0.2e1 * t149 * t19 +
+                0.2e1 * t335 * ZB * t24 * ZA - 0.16e2 * t312 * t313 * t355 * t59 - 0.4e1 * t281 * ZB * ZA * t597 -
+                0.2e1 * t505 * t45 * t281 * t58 - 0.4e1 * t211 * t2 * t53 * t76 + 0.8e1 * t305 * t286 -
+                0.4e1 * t122 * t499 - 0.4e1 * t331 * t332 + 0.8e1 * t345 * t177 * t60 - 0.2e1 * t142 * t177 * t82 +
+                0.2e1 * t72 * t281 * t415 + 0.4e1 * t349 * t96 * t41 - 0.2e1 * t81 * t64 * t76 +
+                0.2e1 * t58 * t80 * t59 + 0.8e1 * t345 * t177 * t41 - 0.4e1 * t8 * t499 + t242 + 0.4e1 * t8 * t518 +
+                t625 + t685 + 0.2e1 * t328 * t174 + 0.2e1 * t331 * t455 - 0.2e1 * t33 * t2 * t4 * ZA * t82 -
+                0.4e1 * t626 * t191 + 0.16e2 * t364 * t373 - 0.2e1 * t621 * t597 - 0.2e1 * t439 * t568 + t492 +
+                t533 * t96 + t232 * t96 + 0.2e1 * t567 * t441 + t561) /
+               (t740 + t789 + t834 + t874 + t911 + t948 + t987 + t1021);
+        /****************************************************************************************/
+        t1 = n * n;
+        t2 = t1 * n;
+        t3 = t2 * 0.3141592654e1;
+        t4 = t3 * xc;
+        t5 = ZB * ZB;
+        t7 = exp(n * 0.3141592654e1);
+        t8 = t7 * t7;
+        t9 = t5 * t8;
+        t12 = exp(xc * n * 0.3141592654e1);
+        t13 = t12 * t12;
+        t14 = t13 * t13;
+        t15 = t14 * t13;
+        t19 = nx * nx;
+        t21 = nx * 0.3141592654e1;
+        t22 = sin(t21);
+        t23 = t19 * nx * t22;
+        t24 = t23 * 0.3141592654e1;
+        t25 = ZA * ZB;
+        t26 = t7 * t15;
+        t27 = t25 * t26;
+        t30 = t21 * xc;
+        t31 = sin(t30);
+        t32 = t31 * nx;
+        t33 = t32 * n;
+        t34 = ZA * ZA;
+        t35 = t8 * t8;
+        t36 = t34 * t35;
+        t40 = t2 * t34;
+        t41 = 0.3141592654e1 * t8;
+        t42 = t41 * t15;
+        t45 = t1 * t5;
+        t46 = t14 * t14;
+        t49 = t19 * t5;
+        t51 = t19 * t46;
+        t53 = t19 * t34;
+        t55 = t8 * t7;
+        t56 = t13 * t55;
+        t57 = t25 * t56;
+        t60 = t2 * nx;
+        t61 = 0.3141592654e1 * 0.3141592654e1;
+        t63 = t60 * t31 * t61;
+        t64 = xc * xc;
+        t65 = ZA * t64;
+        t66 = ZB * t8;
+        t67 = t14 * t12;
+        t68 = t66 * t67;
+        t69 = t65 * t68;
+        t72 = -0.4e1 * t4 * t9 * t15 + 0.4e1 * t24 * t27 + 0.4e1 * t33 * t36 * t12 - 0.4e1 * t40 * t42 - t45 * t46 +
+              t45 * t14 - t49 * t14 + t51 * t5 - t53 * t14 + 0.4e1 * t24 * t57 + 0.32e2 * t63 * t69;
+        t73 = t1 * nx;
+        t75 = t73 * t31 * 0.3141592654e1;
+        t76 = t8 * t67;
+        t77 = t25 * t76;
+        t80 = t1 * t1;
+        t81 = t80 * t34;
+        t83 = t61 * t14;
+        t87 = t1 * t19;
+        t88 = cos(t30);
+        t90 = t87 * t88 * t61;
+        t91 = t5 * t64;
+        t92 = t13 * t12;
+        t93 = t8 * t92;
+        t94 = t91 * t93;
+        t100 = ZB * t64 * ZA * t8 * t92;
+        t103 = n * t19;
+        t105 = t103 * t88 * 0.3141592654e1;
+        t106 = ZA * xc;
+        t107 = ZB * t35;
+        t109 = t106 * t107 * t12;
+        t112 = t34 * xc;
+        t113 = t112 * t93;
+        t116 = t35 * t14;
+        t118 = t1 * ZA;
+        t119 = ZB * t14;
+        t122 = t1 * t46;
+        t125 = t19 * ZB;
+        t126 = t35 * ZA;
+        t127 = t125 * t126;
+        t129 = t1 * ZB;
+        t132 = -0.16e2 * t75 * t77 + 0.16e2 * t81 * t64 * t83 * t8 + 0.16e2 * t90 * t94 - 0.32e2 * t90 * t100 +
+               0.8e1 * t105 * t109 - 0.8e1 * t75 * t113 + t45 * t116 + 0.2e1 * t118 * t119 + 0.2e1 * t122 * t25 -
+               0.2e1 * t127 + 0.2e1 * t129 * t126;
+        t134 = t1 * t34;
+        t136 = t34 * t64;
+        t137 = t136 * t76;
+        t141 = t91 * t76;
+        t145 = t103 * t34;
+        t146 = 0.3141592654e1 * xc;
+        t147 = t8 * t13;
+        t153 = t14 * ZA;
+        t156 = xc * t5;
+        t157 = t156 * t93;
+        t160 = t103 * t5;
+        t162 = t146 * t8 * t15;
+        t166 = t34 * t7 * t15;
+        t169 = t134 * t116 - 0.16e2 * t63 * t137 - t49 * t116 - 0.16e2 * t63 * t141 - t53 * t116 +
+               0.4e1 * t145 * t146 * t147 - 0.2e1 * t51 * t25 - 0.2e1 * t125 * t153 - 0.16e2 * t75 * t157 +
+               0.4e1 * t160 * t162 - 0.4e1 * t24 * t166;
+        t170 = t106 * t68;
+        t177 = t35 * t92;
+        t178 = t112 * t177;
+        t181 = t156 * t76;
+        t186 = t35 * t12;
+        t187 = t112 * t186;
+        t193 = t5 * 0.3141592654e1;
+        t206 = t34 * t14;
+        t207 = t206 * t7;
+        t210 = -0.32e2 * t63 * t170 + 0.32e2 * t90 * t170 + 0.8e1 * t75 * t109 + 0.4e1 * t105 * t178 -
+               0.16e2 * t75 * t181 - 0.16e2 * t90 * t113 - 0.4e1 * t75 * t187 + 0.16e2 * t90 * t141 -
+               0.4e1 * t103 * t15 * t193 * xc + 0.16e2 * t73 * t22 * t34 * t146 * t26 +
+               0.4e1 * t32 * n * t34 * t67 + 0.4e1 * t24 * t207;
+        t217 = t106 * t66 * t92;
+        t226 = t88 * t19 * n;
+        t227 = 0.3141592654e1 * t34;
+        t229 = t227 * xc * t67;
+        t232 = t73 * t31;
+        t234 = t146 * t5 * t67;
+        t238 = t61 * ZB;
+        t239 = t14 * t8;
+        t240 = t238 * t239;
+        t243 = t136 * t93;
+        t246 = -0.8e1 * t33 * t25 * t186 + 0.32e2 * t90 * t217 - t45 * t35 + t53 * t35 - t134 * t35 - t134 * t46 +
+               t134 * t14 - 0.4e1 * t226 * t229 + 0.4e1 * t232 * t234 + 0.32e2 * t87 * t65 * t240 +
+               0.16e2 * t63 * t243;
+        t247 = t14 * t92;
+        t249 = t227 * t247 * xc;
+        t254 = t73 * t22;
+        t259 = t60 * t22 * t61;
+        t260 = t112 * t26;
+        t264 = t146 * t247 * t5;
+        t268 = xc * t14;
+        t274 = t5 * t14;
+        t275 = t274 * t8;
+        t280 = n * nx;
+        t281 = t280 * t22;
+        t282 = t55 * t14;
+        t283 = t25 * t282;
+        t290 = ZA * t247 * xc * ZB;
+        t295 = t22 * nx * t1 * 0.3141592654e1;
+        t298 = -0.4e1 * t232 * t249 + 0.8e1 * t105 * t217 - 0.4e1 * t254 * t227 * t26 - 0.8e1 * t259 * t260 -
+               0.4e1 * t232 * t264 - 0.16e2 * t81 * t61 * t268 * t8 + 0.16e2 * t80 * t64 * t61 * t275 -
+               0.4e1 * t232 * t229 + 0.8e1 * t281 * t283 - 0.4e1 * t105 * t187 + 0.8e1 * t75 * t290 +
+               0.4e1 * t295 * t27;
+        t301 = t61 * t5;
+        t307 = t87 * t34;
+        t312 = t61 * xc;
+        t313 = t312 * t239;
+        t317 = t34 * t55 * t14;
+        t329 = ZB * t13 * t55;
+        t330 = t65 * t329;
+        t337 = -0.16e2 * t87 * t64 * t301 * t239 - 0.32e2 * t90 * t69 - 0.16e2 * t307 * t64 * t61 * t239 +
+               0.16e2 * t307 * t313 + 0.4e1 * t24 * t317 + t53 * t46 + t49 * t35 - 0.32e2 * t63 * t100 -
+               0.4e1 * t280 * t31 * t34 * t247 + 0.8e1 * t259 * t330 - 0.4e1 * t280 * t31 * t247 * t5;
+        t340 = t5 * t35;
+        t344 = t25 * t93;
+        t356 = t41 * t13;
+        t360 = t23 * n * t61;
+        t363 = t25 * t64 * t7 * t15;
+        t366 = t156 * t177;
+        t369 = t14 * t7;
+        t370 = t25 * t369;
+        t373 = t156 * t186;
+        t378 = 0.4e1 * t24 * t283 + 0.4e1 * t33 * t340 * t12 - 0.16e2 * t75 * t344 - 0.4e1 * t280 * t31 * t5 * t67 +
+               0.8e1 * t33 * t25 * t247 + 0.32e2 * t63 * t217 + 0.4e1 * t40 * t356 - 0.8e1 * t360 * t363 +
+               0.4e1 * t75 * t366 + 0.4e1 * t295 * t370 - 0.4e1 * t75 * t373 - 0.4e1 * t105 * t366;
+        t382 = t112 * t76;
+        t387 = t80 * t61;
+        t391 = t136 * t26;
+        t409 = 0.16e2 * t63 * t382 + 0.4e1 * t226 * t234 - 0.16e2 * t387 * xc * t275 + 0.8e1 * t259 * t391 -
+               0.16e2 * t105 * t344 + 0.4e1 * t226 * t264 - 0.8e1 * t105 * t170 + 0.16e2 * t232 * t193 * t76 +
+               0.8e1 * t360 * t330 - 0.8e1 * t105 * t290 + 0.16e2 * t90 * t243;
+        t423 = t153 * t8;
+        t426 = t34 * t13;
+        t427 = t426 * t55;
+        t430 = t34 * t8;
+        t437 = t80 * ZA;
+        t441 = 0.4e1 * t145 * t42 - 0.16e2 * t90 * t157 + 0.24e2 * t75 * t217 + 0.4e1 * t226 * t249 +
+               0.4e1 * t254 * t227 * t282 + 0.4e1 * t160 * t356 - 0.8e1 * t129 * t423 - 0.8e1 * t281 * t427 -
+               0.8e1 * t33 * t430 * t67 + 0.8e1 * t33 * t430 * t92 + 0.32e2 * t437 * ZB * t313;
+        t453 = t106 * ZB * t7 * t15;
+        t456 = t2 * t5;
+        t459 = t112 * t56;
+        t462 = t126 * t14;
+        t474 = t40 * 0.3141592654e1;
+        t475 = xc * t8;
+        t480 = t146 * t13 * t35;
+        t483 = -0.4e1 * t103 * xc * t193 * t147 + 0.16e2 * t87 * t61 * t156 * t239 + 0.8e1 * t259 * t453 -
+               0.4e1 * t456 * t356 + 0.8e1 * t259 * t459 - 0.2e1 * t125 * t462 - 0.8e1 * t281 * t207 +
+               0.16e2 * t295 * t459 - 0.8e1 * t60 * t22 * ZA * t312 * t329 + 0.4e1 * t474 * t475 * t15 +
+               0.4e1 * t160 * t480;
+        t497 = t136 * t56;
+        t504 = t9 * t13;
+        t509 = t475 * t13;
+        t512 = -0.8e1 * t105 * t113 - 0.4e1 * t254 * t227 * t56 + 0.8e1 * t281 * t57 + 0.4e1 * t295 * t283 +
+               0.2e1 * t129 * t462 + 0.4e1 * t24 * t370 - 0.8e1 * t360 * t497 - 0.4e1 * t24 * t427 -
+               0.4e1 * t145 * t162 + 0.4e1 * t4 * t504 - 0.8e1 * t281 * t370 - 0.4e1 * t474 * t509;
+        t528 = t5 * t13;
+        t529 = t528 * t35;
+        t532 = t106 * t329;
+        t542 = -0.16e2 * t295 * t453 - 0.32e2 * t437 * t64 * t240 + 0.8e1 * t281 * t317 + 0.24e2 * t75 * t170 -
+               0.4e1 * t75 * t178 + 0.8e1 * t360 * t453 - 0.4e1 * t4 * t529 - 0.16e2 * t295 * t532 -
+               0.8e1 * t33 * t344 - 0.16e2 * t90 * t181 + 0.4e1 * t33 * t340 * t92;
+        t557 = t146 * t15;
+        t562 = xc * t15;
+        t563 = t562 * t5;
+        t573 = 0.16e2 * t232 * t193 * t93 - 0.8e1 * t259 * t363 - 0.8e1 * t259 * t497 + 0.8e1 * t33 * t77 +
+               0.8e1 * t360 * t391 + 0.4e1 * t254 * t227 * t369 + 0.4e1 * t145 * t557 + 0.8e1 * t281 * t166 +
+               0.4e1 * t3 * t563 + 0.8e1 * t105 * t382 - 0.4e1 * t145 * t480 - 0.4e1 * t33 * t36 * t92;
+        t600 = 0.4e1 * t456 * t42 - 0.8e1 * t360 * t260 - 0.4e1 * t40 * t557 - 0.4e1 * t105 * t373 +
+               0.16e2 * t226 * t227 * t93 - 0.16e2 * t90 * t382 - 0.4e1 * t145 * t356 - 0.16e2 * t63 * t157 -
+               0.32e2 * t87 * t25 * t313 - 0.16e2 * t226 * t227 * t76 - 0.16e2 * t63 * t113;
+        t623 = xc * t13;
+        t627 = 0.8e1 * t125 * t423 - 0.8e1 * t360 * t532 + 0.16e2 * t90 * t137 - 0.4e1 * t160 * t42 +
+               0.16e2 * t63 * t94 + 0.16e2 * t63 * t181 - 0.8e1 * t281 * t27 - 0.8e1 * t75 * t382 +
+               0.8e1 * t360 * t459 + 0.4e1 * t295 * t57 + 0.16e2 * t105 * t77 + 0.4e1 * t474 * t623 * t35;
+        t632 = t61 * 0.3141592654e1;
+        t633 = t632 * t8;
+        t634 = t80 * n;
+        t638 = t632 * t634;
+        t639 = t638 * xc;
+        t642 = t61 * t34;
+        t643 = t122 * t19;
+        t649 = t61 * t61;
+        t650 = t649 * t1;
+        t652 = t19 * t19;
+        t653 = t14 * t652;
+        t654 = t653 * t9;
+        t657 = t14 * t1;
+        t658 = t657 * t19;
+        t665 = t632 * t34;
+        t666 = t665 * t2;
+        t667 = t8 * t19;
+        t668 = t667 * t623;
+        t674 = t665 * n;
+        t675 = t652 * xc;
+        t682 = 0.8e1 * t633 * t426 * t634 - 0.8e1 * t639 * t529 - 0.4e1 * t642 * t643 + 0.2e1 * t642 * t116 * t80 +
+               0.32e2 * t650 * t64 * t654 + 0.4e1 * t301 * t658 + 0.4e1 * t387 * t46 * ZA * ZB -
+               0.16e2 * t666 * t668 - 0.16e2 * t666 * t667 * t15 - 0.8e1 * t674 * t675 * t15 +
+               0.4e1 * t238 * t153 * t80;
+        t683 = t46 * t652;
+        t686 = t633 * t15;
+        t691 = t35 * t80;
+        t698 = t35 * t652;
+        t705 = t14 * t80;
+        t708 = t61 * t35;
+        t717 = -0.2e1 * t642 * t683 - 0.8e1 * t686 * t5 * t634 * xc - 0.2e1 * t301 * t691 + 0.8e1 * t638 * t563 -
+               0.2e1 * t642 * t691 - 0.2e1 * t642 * t698 - 0.2e1 * t301 * t698 - 0.2e1 * t301 * t683 +
+               0.2e1 * t642 * t705 + 0.2e1 * t708 * t274 * t80 + 0.2e1 * t301 * t653 - 0.2e1 * t642 * t80 * t46;
+        t727 = t61 * t46;
+        t737 = t649 * t34;
+        t738 = t737 * t1;
+        t739 = t8 * t652;
+        t740 = t739 * t268;
+        t746 = t61 * ZA;
+        t754 = t632 * n * xc;
+        t758 = 0.2e1 * t301 * t705 + 0.2e1 * t642 * t653 - 0.8e1 * t665 * xc * t634 * t15 -
+               0.2e1 * t727 * t5 * t80 - 0.32e2 * t650 * xc * t654 + 0.2e1 * t301 * t698 * t14 -
+               0.32e2 * t738 * t740 + 0.8e1 * t674 * t739 * t562 + 0.4e1 * t746 * t119 * t652 +
+               0.8e1 * t674 * t698 * t623 - 0.8e1 * t754 * t528 * t698;
+        t762 = t633 * t13;
+        t764 = t5 * n * t652;
+        t767 = t80 * t1;
+        t768 = t649 * t767;
+        t772 = t649 * ZA;
+        t773 = t772 * t129;
+        t777 = t35 * t1 * t19;
+        t780 = t632 * t5;
+        t781 = t780 * t15;
+        t786 = t698 * ZA;
+        t790 = t64 * t14;
+        t800 = t649 * t8;
+        t809 = 0.4e1 * t238 * t126 * t80 - 0.8e1 * t762 * t764 - 0.32e2 * t768 * xc * t275 + 0.64e2 * t773 * t740 -
+               0.4e1 * t301 * t777 - 0.8e1 * t781 * n * t8 * t675 + 0.4e1 * t238 * t786 +
+               0.32e2 * t768 * t34 * t790 * t8 - 0.8e1 * t633 * t528 * t634 + 0.8e1 * t754 * t528 * t739 +
+               0.128e3 * t800 * t119 * t80 * t19 * t106 + 0.8e1 * t674 * t739 * t13;
+        t812 = t649 * t80;
+        t817 = t83 * ZB;
+        t824 = t746 * ZB;
+        t828 = t800 * t14;
+        t855 = -0.64e2 * t812 * xc * t274 * t667 + 0.4e1 * t817 * t786 + 0.4e1 * t727 * ZA * t652 * ZB -
+               0.32e2 * t824 * t657 * t667 - 0.32e2 * t828 * t34 * t767 * xc - 0.8e1 * t633 * t15 * t34 * t634 -
+               0.8e1 * t674 * t739 * t15 + 0.32e2 * t768 * t64 * t275 + 0.4e1 * t708 * t14 * t307 +
+               0.2e1 * t708 * t206 * t652 + 0.8e1 * t632 * t35 * t13 * t34 * t634 * xc;
+        t858 = t35 * t19;
+        t873 = t2 * t8;
+        t878 = t61 * t1;
+        t901 = -0.16e2 * t632 * t2 * xc * t528 * t858 + 0.8e1 * t824 * t658 + 0.4e1 * t301 * t14 * t777 -
+               0.8e1 * t665 * t634 * t509 - 0.8e1 * t674 * t739 * t623 - 0.16e2 * t781 * t873 * t19 * xc +
+               0.8e1 * t878 * t14 * t127 + 0.8e1 * t878 * ZA * t51 * ZB + 0.8e1 * t686 * t764 +
+               0.8e1 * t665 * xc * t634 * t15 * t8 + 0.8e1 * t633 * t15 * t5 * t634 +
+               0.4e1 * t387 * t14 * t107 * ZA;
+        t903 = t739 * t790;
+        t923 = t737 * t80;
+        t924 = t667 * t790;
+        t927 = t780 * t2;
+        t937 = t15 * t19 * xc;
+        t943 = 0.32e2 * t738 * t903 + 0.16e2 * t781 * t873 * t19 + 0.8e1 * t754 * t15 * t652 * t5 +
+               0.16e2 * t666 * t858 * t623 + 0.64e2 * t828 * t25 * t767 * xc - 0.16e2 * t762 * t456 * t19 +
+               0.64e2 * t923 * t924 + 0.16e2 * t927 * t668 - 0.64e2 * t768 * ZA * t790 * t66 -
+               0.64e2 * t773 * t903 + 0.16e2 * t927 * t937 + 0.16e2 * t666 * t667 * t562;
+        t977 = 0.64e2 * t812 * t5 * t924 + 0.8e1 * t639 * t504 + 0.8e1 * t238 * t35 * t118 * t19 +
+               0.4e1 * t642 * t658 - 0.16e2 * t817 * t437 * t8 - 0.128e3 * t772 * ZB * t80 * t924 +
+               0.16e2 * t666 * t667 * t13 - 0.4e1 * t301 * t643 - 0.16e2 * t824 * t653 * t8 - 0.4e1 * t642 * t777 -
+               0.64e2 * t923 * t667 * t268 - 0.16e2 * t666 * t937;
+
+        _C3A = (t72 + t132 + t169 + t210 + t246 + t298 + t337 + t378 + t409 + t441 + t483 + t512 + t542 + t573 +
+                t600 + t627) / (t682 + t717 + t758 + t809 + t855 + t901 + t943 + t977);
+        /****************************************************************************************/
+        _C4A = 0;
+        /****************************************************************************************/
+        t1 = nx * 0.3141592654e1;
+        t2 = t1 * xc;
+        t3 = cos(t2);
+        t4 = nx * nx;
+        t6 = n * 0.3141592654e1;
+        t7 = t3 * t4 * t6;
+        t8 = ZA * ZB;
+        t9 = exp(t6);
+        t10 = t9 * t9;
+        t11 = xc * n;
+        t13 = exp(t11 * 0.3141592654e1);
+        t14 = t13 * t13;
+        t15 = t14 * t13;
+        t16 = t14 * t14;
+        t17 = t16 * t15;
+        t18 = t10 * t17;
+        t19 = t8 * t18;
+        t22 = sin(t2);
+        t23 = nx * t22;
+        t24 = t23 * n;
+        t25 = ZB * ZB;
+        t30 = n * n;
+        t31 = t30 * n;
+        t32 = t31 * nx;
+        t33 = 0.3141592654e1 * 0.3141592654e1;
+        t35 = t32 * t22 * t33;
+        t36 = ZA * ZA;
+        t37 = t36 * xc;
+        t38 = t16 * t13;
+        t39 = t10 * t38;
+        t40 = t37 * t39;
+        t43 = sin(t1);
+        t44 = nx * t43;
+        t45 = t30 * 0.3141592654e1;
+        t46 = t44 * t45;
+        t47 = ZA * xc;
+        t49 = ZB * t16 * t9;
+        t54 = t4 * nx * t43;
+        t55 = xc * xc;
+        t57 = t54 * t30 * t55;
+        t58 = t33 * 0.3141592654e1;
+        t59 = t58 * t25;
+        t60 = t16 * t9;
+        t61 = t59 * t60;
+        t64 = xc * t25;
+        t65 = t14 * t9;
+        t66 = t64 * t65;
+        t70 = t44 * t31 * t33;
+        t71 = t37 * t65;
+        t74 = t10 * t15;
+        t75 = t64 * t74;
+        t78 = t25 * t10;
+        t83 = t54 * n * t33;
+        t84 = t55 * t25;
+        t85 = t10 * t9;
+        t86 = t14 * t85;
+        t87 = t84 * t86;
+        t90 = t30 * t30;
+        t92 = t44 * t90 * t58;
+        t93 = t55 * xc;
+        t94 = t93 * t25;
+        t95 = t85 * t16;
+        t96 = t94 * t95;
+        t102 = t23 * t45;
+        t103 = t10 * t10;
+        t104 = ZB * t103;
+        t106 = t47 * t104 * t15;
+        t111 = t54 * 0.3141592654e1;
+        t112 = t25 * t85;
+        t113 = t112 * t16;
+        t115 = t8 * t39;
+        t118 = t16 * t14;
+        t119 = t85 * t118;
+        t120 = t37 * t119;
+        t123 = t16 * t16;
+        t124 = t36 * t123;
+        t125 = t124 * t9;
+        t127 = -0.8e1 * t7 * t19 + 0.2e1 * t24 * t25 * t13 * t10 - 0.16e2 * t35 * t40 - 0.16e2 * t46 * t47 * t49 -
+               0.8e1 * t57 * t61 + 0.4e1 * t46 * t66 + 0.2e1 * t70 * t71 - 0.16e2 * t35 * t75 +
+               0.6e1 * t24 * t78 * t38 - 0.2e1 * t83 * t87 - 0.8e1 * t92 * t96 - 0.8e1 * t46 * t37 * t95 -
+               0.12e2 * t102 * t106 + 0.2e1 * t83 * t71 + t111 * t113 + 0.8e1 * t7 * t115 + 0.2e1 * t83 * t120 +
+               t111 * t125;
+        t128 = t37 * t74;
+        t131 = t44 * n;
+        t133 = t25 * t9 * t118;
+        t136 = t36 * t14;
+        t137 = t136 * t9;
+        t140 = t30 * t4;
+        t142 = t140 * t3 * t33;
+        t143 = t64 * t39;
+        t147 = t30 * nx * t43;
+        t148 = 0.3141592654e1 * t36;
+        t149 = t9 * t118;
+        t153 = t44 * t31 * ZA;
+        t154 = t33 * xc;
+        t155 = t154 * t49;
+        t160 = ZA * t17 * xc * ZB;
+        t163 = t103 * t13;
+        t164 = t64 * t163;
+        t170 = t44 * t90 * t55;
+        t171 = t58 * ZB;
+        t172 = ZA * t16;
+        t174 = t171 * t172 * t9;
+        t177 = t36 * t55;
+        t178 = t177 * t149;
+        t181 = t54 * t11;
+        t182 = t33 * t25;
+        t186 = t25 * t14;
+        t187 = t186 * t9;
+        t193 = t186 * t85;
+        t198 = ZB * t55;
+        t199 = ZA * t103;
+        t201 = t198 * t199 * t15;
+        t204 = 0.2e1 * t7 * t128 - 0.2e1 * t131 * t133 - 0.2e1 * t131 * t137 + 0.16e2 * t142 * t143 -
+               t147 * t148 * t149 + 0.8e1 * t153 * t155 - 0.4e1 * t7 * t160 + 0.2e1 * t7 * t164 +
+               0.10e2 * t102 * t40 + 0.16e2 * t170 * t174 + 0.2e1 * t83 * t178 - 0.2e1 * t181 * t182 * t65 -
+               t111 * t187 - 0.2e1 * t70 * t87 + 0.4e1 * t102 * t160 - 0.2e1 * t131 * t193 - 0.16e2 * t142 * t75 +
+               0.16e2 * t35 * t201;
+        t210 = t32 * t22;
+        t211 = t33 * t55;
+        t212 = t25 * t38;
+        t213 = t211 * t212;
+        t216 = n * nx;
+        t217 = t22 * t25;
+        t222 = ZB * t85 * t16;
+        t226 = t23 * t30;
+        t227 = t13 * t10;
+        t228 = t148 * t227;
+        t233 = t37 * t163;
+        t237 = n * t4 * t3;
+        t238 = t148 * t74;
+        t241 = t64 * t86;
+        t245 = t148 * xc * t15;
+        t248 = t112 * t118;
+        t250 = t22 * t36;
+        t256 = 0.3141592654e1 * t25;
+        t257 = t256 * t39;
+        t262 = t38 * t103;
+        t263 = t37 * t262;
+        t267 = t148 * t17 * xc;
+        t270 = -0.6e1 * t7 * t143 - 0.4e1 * t24 * t19 - 0.8e1 * t210 * t213 - 0.2e1 * t216 * t217 * t15 -
+               0.32e2 * t153 * t211 * t222 + 0.4e1 * t226 * t228 + 0.16e2 * t142 * t201 + 0.2e1 * t7 * t233 -
+               0.4e1 * t237 * t238 - 0.2e1 * t83 * t241 - 0.2e1 * t237 * t245 + t111 * t248 +
+               0.2e1 * t216 * t250 * t15 - 0.2e1 * t131 * t125 - 0.4e1 * t226 * t257 + t147 * t148 * t95 -
+               0.2e1 * t102 * t263 + 0.2e1 * t237 * t267;
+        t273 = t37 * t149;
+        t277 = t47 * t104 * t13;
+        t285 = t31 * t36;
+        t286 = t44 * t285;
+        t291 = t25 * t123 * t9;
+        t304 = 0.3141592654e1 * xc;
+        t305 = t304 * t212;
+        t312 = t256 * t18;
+        t315 = t8 * t60;
+        t319 = t54 * t30 * t58;
+        t323 = t90 * t36;
+        t324 = t44 * t323;
+        t325 = t55 * t58;
+        t326 = t325 * t60;
+        t329 = 0.2e1 * t102 * t164 + 0.2e1 * t83 * t273 - 0.4e1 * t102 * t277 - 0.2e1 * t7 * t263 +
+               0.4e1 * t24 * t8 * t17 - 0.4e1 * t286 * t154 * t60 - 0.2e1 * t131 * t291 - t147 * t148 * t119 +
+               0.2e1 * t24 * t78 * t17 + 0.2e1 * t54 * t85 * 0.3141592654e1 * ZA * ZB - 0.4e1 * t226 * t305 -
+               0.2e1 * t70 * t66 + t147 * t256 * t95 + 0.4e1 * t237 * t312 + 0.2e1 * t111 * t315 -
+               0.8e1 * t319 * t96 - t111 * t193 - 0.8e1 * t324 * t326;
+        t332 = t8 * t95;
+        t335 = t136 * t85;
+        t337 = t256 * t227;
+        t340 = t177 * t119;
+        t346 = t37 * t86;
+        t351 = t103 * t15;
+        t352 = t177 * t351;
+        t355 = t64 * t119;
+        t358 = t8 * t227;
+        t361 = t85 * 0.3141592654e1;
+        t365 = t84 * t39;
+        t372 = ZB * t10;
+        t373 = t372 * t38;
+        t374 = t47 * t373;
+        t379 = t177 * t39;
+        t384 = -0.2e1 * t46 * t332 + t111 * t335 + 0.4e1 * t237 * t337 - 0.2e1 * t83 * t340 +
+               0.16e2 * t286 * t211 * t95 + 0.2e1 * t70 * t346 - 0.8e1 * t170 * t61 - 0.8e1 * t142 * t352 -
+               0.2e1 * t83 * t355 - 0.4e1 * t24 * t358 + 0.2e1 * t147 * t361 * t8 + 0.8e1 * t35 * t365 -
+               0.2e1 * t226 * t267 + 0.8e1 * t102 * t115 - 0.12e2 * t102 * t374 + 0.16e2 * t142 * t40 -
+               0.8e1 * t142 * t379 + 0.4e1 * t237 * t228;
+        t386 = t54 * t30 * t93;
+        t387 = ZA * t85;
+        t389 = t171 * t387 * t16;
+        t394 = t64 * t60;
+        t398 = t304 * t25 * t15;
+        t401 = t361 * t25;
+        t405 = t84 * t65;
+        t410 = t148 * t18;
+        t414 = t25 * t16 * t9;
+        t417 = t84 * t74;
+        t422 = t177 * t86;
+        t428 = ZB * t38;
+        t429 = t47 * t428;
+        t432 = t148 * t39;
+        t439 = 0.16e2 * t386 * t389 - 0.16e2 * t386 * t174 + 0.8e1 * t46 * t394 + 0.2e1 * t237 * t398 -
+               t147 * t401 + 0.4e1 * t7 * t374 + 0.2e1 * t83 * t405 - 0.4e1 * t46 * t241 - 0.4e1 * t226 * t410 +
+               0.2e1 * t131 * t414 + 0.8e1 * t35 * t417 - 0.8e1 * t142 * t365 + 0.2e1 * t70 * t422 -
+               0.4e1 * t181 * t182 * t60 + 0.12e2 * t102 * t429 - 0.4e1 * t226 * t432 + 0.32e2 * t35 * t374 -
+               0.4e1 * t7 * t106;
+        t442 = t36 * t9 * t118;
+        t444 = t123 * t9;
+        t445 = t8 * t444;
+        t448 = t361 * t36;
+        t451 = t47 * t372 * t17;
+        t454 = t94 * t60;
+        t457 = t25 * t103;
+        t465 = t47 * t372 * t15;
+        t468 = t36 * t85;
+        t469 = t468 * t16;
+        t474 = t43 * t85;
+        t478 = t8 * t74;
+        t484 = t256 * t74;
+        t489 = t198 * ZA * t10 * t15;
+        t501 = -t111 * t442 + 0.4e1 * t131 * t445 - t147 * t448 + 0.4e1 * t7 * t451 + 0.8e1 * t92 * t454 -
+               0.2e1 * t24 * t457 * t13 - 0.2e1 * t286 * t211 * t65 + 0.4e1 * t7 * t465 + t111 * t469 -
+               0.2e1 * t216 * t250 * t17 - 0.2e1 * t216 * t474 * t25 - 0.4e1 * t24 * t478 + 0.4e1 * t24 * t8 * t38 +
+               0.4e1 * t226 * t484 - 0.16e2 * t142 * t489 - 0.2e1 * t24 * t212 * t103 -
+               0.2e1 * t216 * t22 * t17 * t25 + 0.2e1 * t70 * t120;
+        t504 = t33 * t36 * t55 * t38;
+        t507 = t37 * t18;
+        t512 = t47 * ZB * t13 * t10;
+        t518 = t59 * t95;
+        t530 = t84 * t351;
+        t534 = t37 * t227;
+        t549 = -0.8e1 * t210 * t504 + 0.2e1 * t102 * t507 + 0.4e1 * t7 * t512 + t111 * t133 - 0.16e2 * t35 * t489 +
+               0.8e1 * t170 * t518 + 0.2e1 * t24 * t36 * t13 * t10 + 0.4e1 * t131 * t387 * ZB +
+               0.12e2 * t102 * t465 - 0.8e1 * t142 * t530 + t111 * t291 - 0.2e1 * t102 * t534 - 0.4e1 * t70 * t394 -
+               0.10e2 * t102 * t128 + 0.4e1 * t237 * t305 + 0.8e1 * t102 * t19 + 0.2e1 * t83 * t346 -
+               0.16e2 * t35 * t128;
+        t557 = t468 * t118;
+        t562 = t93 * t58;
+        t563 = t562 * t60;
+        t567 = t44 * t90 * t93;
+        t575 = ZA * t55;
+        t576 = t575 * t428;
+        t583 = t37 * t60;
+        t590 = t140 * t3;
+        t601 = -0.2e1 * t226 * t398 - 0.2e1 * t70 * t340 - 0.2e1 * t131 * t557 - 0.4e1 * t24 * t115 +
+               0.8e1 * t324 * t563 + 0.16e2 * t567 * t389 + 0.16e2 * t70 * t84 * t95 + 0.2e1 * t70 * t178 -
+               0.16e2 * t142 * t576 - 0.4e1 * t237 * t257 - 0.4e1 * t226 * t312 + 0.8e1 * t46 * t583 +
+               0.2e1 * t24 * t36 * t38 * t103 + 0.8e1 * t590 * t213 + 0.2e1 * t102 * t143 - 0.16e2 * t35 * t143 +
+               0.2e1 * t131 * t248 + 0.4e1 * t46 * t346;
+        t604 = n * t36;
+        t606 = t154 * t95;
+        t625 = t36 * t103;
+        t640 = t30 * t36;
+        t641 = t54 * t640;
+        t642 = t325 * t95;
+        t647 = -0.4e1 * t131 * t315 - 0.4e1 * t54 * t604 * t606 - t147 * t148 * t60 + 0.16e2 * t35 * t576 -
+               0.8e1 * t102 * t478 + 0.32e2 * t142 * t465 - 0.4e1 * t237 * t484 - 0.2e1 * t70 * t355 +
+               0.2e1 * t70 * t273 + 0.2e1 * t102 * t233 - 0.2e1 * t24 * t625 * t13 - 0.8e1 * t7 * t358 -
+               0.2e1 * t111 * t445 - 0.4e1 * t7 * t429 + 0.16e2 * t46 * t47 * t222 + 0.2e1 * t131 * t113 +
+               0.8e1 * t641 * t642 - 0.2e1 * t7 * t534;
+        t652 = t36 * t16;
+        t653 = t652 * t9;
+        t655 = t64 * t227;
+        t658 = t182 * t95;
+        t663 = t562 * t95;
+        t684 = t64 * t351;
+        t689 = t36 * t10;
+        t695 = t154 * t222;
+        t698 = -0.4e1 * t216 * t217 * t38 - t111 * t653 - 0.2e1 * t7 * t655 - 0.4e1 * t181 * t658 +
+               0.2e1 * t131 * t469 - 0.8e1 * t641 * t663 - 0.4e1 * t83 * t583 - 0.2e1 * t83 * t177 * t65 -
+               0.4e1 * t24 * t457 * t15 + 0.16e2 * t70 * t84 * t60 + 0.8e1 * t57 * t518 - 0.32e2 * t142 * t374 +
+               0.4e1 * t24 * t8 * t351 + 0.4e1 * t102 * t684 - t147 * t256 * t86 - 0.2e1 * t24 * t689 * t15 -
+               0.2e1 * t70 * t241 + 0.8e1 * t153 * t695;
+        t711 = t575 * t373;
+        t717 = t304 * t17 * t25;
+        t736 = t177 * t74;
+        t739 = 0.2e1 * t226 * t245 - 0.8e1 * t102 * t358 - 0.16e2 * t57 * t389 - 0.2e1 * t102 * t655 +
+               0.8e1 * t590 * t504 - 0.8e1 * t641 * t326 - 0.16e2 * t35 * t711 - t111 * t557 + t111 * t137 -
+               0.2e1 * t226 * t717 + 0.8e1 * t102 * t37 * t351 + 0.2e1 * t131 * t335 - 0.4e1 * t131 * t332 -
+               0.2e1 * t216 * t474 * t36 - 0.2e1 * t111 * t332 + 0.16e2 * t142 * t711 - t147 * t256 * t60 +
+               0.8e1 * t142 * t736;
+        t750 = t64 * t262;
+        t763 = t44 * t640;
+        t770 = t84 * t119;
+        t782 = 0.4e1 * t102 * t512 + 0.8e1 * t142 * t417 + 0.8e1 * t641 * t563 - 0.2e1 * t7 * t507 +
+               0.2e1 * t7 * t750 - 0.8e1 * t35 * t352 + 0.4e1 * t237 * t410 + 0.4e1 * t7 * t684 -
+               0.2e1 * t46 * t445 + t147 * t148 * t65 + 0.4e1 * t763 * t304 * t119 + 0.16e2 * t70 * t177 * t60 +
+               0.2e1 * t70 * t770 - t111 * t414 - 0.16e2 * t567 * t174 - 0.4e1 * t46 * t71 - 0.4e1 * t46 * t355 -
+               0.4e1 * t7 * t277;
+        t797 = t64 * t149;
+        t821 = -t54 * t448 + 0.2e1 * t131 * t442 + 0.8e1 * t7 * t478 + 0.8e1 * t35 * t379 -
+               0.2e1 * t181 * t182 * t149 + 0.2e1 * t70 * t405 + 0.2e1 * t83 * t770 - 0.2e1 * t70 * t797 -
+               0.6e1 * t7 * t75 - 0.4e1 * t286 * t606 - 0.4e1 * t237 * t432 + t147 * t256 * t149 -
+               0.4e1 * t763 * t304 * t149 - 0.2e1 * t102 * t75 + 0.2e1 * t237 * t717 + 0.8e1 * t324 * t642 -
+               0.16e2 * t170 * t389 + 0.2e1 * t83 * t422;
+        t827 = t84 * t149;
+        t846 = t54 * n * ZA;
+        t854 = t64 * t18;
+        t867 = -0.16e2 * t142 * t128 + 0.32e2 * t35 * t465 - 0.2e1 * t83 * t827 + 0.2e1 * t46 * t315 +
+               t147 * t148 * t86 - 0.4e1 * t102 * t451 - 0.8e1 * t226 * t148 * xc * t38 - 0.2e1 * t24 * t689 * t38 +
+               0.2e1 * t131 * t187 + 0.8e1 * t846 * t155 + 0.8e1 * t35 * t736 + 0.2e1 * t24 * t689 * t17 -
+               0.2e1 * t7 * t854 + t147 * t256 * t119 + 0.2e1 * t102 * t854 - 0.8e1 * t35 * t530 +
+               0.4e1 * t46 * t797 + 0.2e1 * t102 * t750;
+        t909 = -0.8e1 * t324 * t663 + t147 * t256 * t444 - t147 * t256 * t65 + 0.4e1 * t226 * t238 +
+               0.2e1 * t7 * t40 - t54 * t401 + 0.16e2 * t57 * t174 + 0.4e1 * t226 * t337 + 0.4e1 * t24 * t8 * t163 +
+               0.8e1 * t846 * t695 + 0.8e1 * t319 * t454 + 0.2e1 * t131 * t653 - 0.8e1 * t46 * t64 * t95 +
+               0.6e1 * t24 * t78 * t15 - 0.4e1 * t44 * t31 * xc * t658 - 0.32e2 * t153 * t211 * t49 -
+               0.2e1 * t70 * t827 + t147 * t148 * t444;
+        t914 = t25 * ZB;
+        t915 = t33 * t914;
+        t919 = t4 * t4;
+        t920 = t16 * t919;
+        t929 = t123 * t90;
+        t932 = t919 * t103;
+        t935 = t33 * ZB;
+        t939 = t652 * t919;
+        t942 = t16 * t30;
+        t943 = t942 * t4;
+        t949 = t103 * t16;
+        t950 = t949 * t90;
+        t953 = -0.2e1 * t915 * t103 * t90 + 0.2e1 * t915 * t920 - 0.2e1 * t915 * t123 * t919 +
+               0.2e1 * t915 * t16 * t90 - 0.2e1 * t915 * t929 - 0.2e1 * t915 * t932 - 0.2e1 * t935 * t323 * t123 +
+               0.2e1 * t935 * t939 + 0.4e1 * t915 * t943 + 0.4e1 * t182 * t172 * t90 + 0.2e1 * t915 * t950;
+        t954 = t171 * t36;
+        t955 = t90 * n;
+        t956 = xc * t955;
+        t957 = t118 * t10;
+        t964 = t33 * t33;
+        t965 = t964 * ZB;
+        t966 = t965 * t640;
+        t967 = t10 * t919;
+        t968 = t55 * t16;
+        t969 = t967 * t968;
+        t972 = t935 * t36;
+        t974 = t103 * t30 * t4;
+        t977 = xc * t16;
+        t978 = t967 * t977;
+        t981 = t90 * t30;
+        t983 = t16 * t10;
+        t987 = t182 * ZA;
+        t988 = t4 * t10;
+        t992 = t171 * t604;
+        t993 = xc * t14;
+        t994 = t932 * t993;
+        t997 = t182 * t30;
+        t1005 = t171 * t285;
+        t1006 = t988 * t993;
+        t1009 = t58 * t914;
+        t1010 = t1009 * t31;
+        t1013 = 0.8e1 * t954 * t956 * t957 + 0.2e1 * t915 * t932 * t16 + 0.32e2 * t966 * t969 -
+                0.4e1 * t972 * t974 - 0.32e2 * t966 * t978 + 0.32e2 * t965 * t981 * t177 * t983 -
+                0.32e2 * t987 * t942 * t988 + 0.8e1 * t992 * t994 + 0.8e1 * t997 * t949 * ZA * t4 -
+                0.2e1 * t935 * t124 * t919 - 0.16e2 * t1005 * t1006 + 0.16e2 * t1010 * t1006;
+        t1015 = t964 * t25;
+        t1016 = ZA * t30;
+        t1017 = t1015 * t1016;
+        t1020 = t967 * t993;
+        t1031 = t1009 * t118;
+        t1032 = t31 * t10;
+        t1040 = t964 * t914;
+        t1041 = t1040 * t90;
+        t1044 = t55 * t10 * t4 * t16;
+        t1047 = t1040 * t30;
+        t1050 = t123 * ZA;
+        t1054 = t977 * t988;
+        t1057 = 0.64e2 * t1017 * t978 - 0.8e1 * t992 * t1020 + 0.2e1 * t972 * t950 + 0.4e1 * t182 * t929 * ZA +
+                0.4e1 * t182 * t199 * t90 - 0.16e2 * t1031 * t1032 * t4 * xc + 0.4e1 * t182 * t172 * t919 +
+                0.64e2 * t1041 * t1044 + 0.32e2 * t1047 * t969 + 0.4e1 * t182 * t1050 * t919 -
+                0.64e2 * t1041 * t1054;
+        t1058 = t1009 * n;
+        t1063 = t932 * ZA;
+        t1069 = t123 * t30 * t4;
+        t1080 = t993 * t103 * t4;
+        t1088 = t935 * t103;
+        t1094 = -0.8e1 * t1058 * t994 - 0.32e2 * t1047 * t978 + 0.4e1 * t182 * t1063 - 0.4e1 * t915 * t974 -
+                0.4e1 * t915 * t1069 - 0.2e1 * t935 * t625 * t90 - 0.8e1 * t1009 * t10 * t14 * t955 -
+                0.16e2 * t1010 * t1080 - 0.2e1 * t935 * t625 * t919 - 0.64e2 * t1017 * t969 + 0.2e1 * t1088 * t939 +
+                0.8e1 * t1009 * t957 * t955;
+        t1113 = t955 * t118 * xc;
+        t1120 = t4 * t118;
+        t1125 = t981 * xc;
+        t1133 = n * t10;
+        t1140 = -0.8e1 * t954 * t955 * t10 * t993 + 0.2e1 * t935 * t652 * t90 -
+                0.64e2 * t1015 * t981 * t575 * t983 + 0.8e1 * t182 * t103 * t1016 * t4 + 0.8e1 * t1009 * t1113 +
+                0.16e2 * t954 * t1032 * t4 * t14 - 0.16e2 * t954 * t1032 * t1120 +
+                0.64e2 * t1015 * t10 * t172 * t1125 + 0.8e1 * t171 * t103 * t136 * t956 -
+                0.8e1 * t1031 * t1133 * t919 * xc + 0.8e1 * t1058 * t1020;
+        t1153 = xc * t118;
+        t1165 = t182 * t16;
+        t1170 = t171 * t10;
+        t1178 = ZA * t90;
+        t1182 = 0.4e1 * t1088 * t652 * t140 + 0.8e1 * t954 * t1133 * t919 * t14 + 0.4e1 * t972 * t943 -
+                0.4e1 * t972 * t1069 - 0.16e2 * t954 * t31 * t4 * t1153 - 0.8e1 * t954 * n * t919 * t1153 -
+                0.8e1 * t954 * t1133 * t919 * t118 + 0.4e1 * t1165 * t1063 + 0.16e2 * t1005 * t1080 -
+                0.8e1 * t1170 * t118 * t36 * t955 - 0.16e2 * t987 * t920 * t10 - 0.16e2 * t1165 * t1178 * t10;
+        t1195 = t1040 * t981;
+        t1199 = t1009 * t955;
+        t1203 = t1009 * t10;
+        t1211 = t965 * t323;
+        t1225 = -0.32e2 * t965 * t10 * t652 * t1125 + 0.4e1 * t915 * t16 * t974 + 0.4e1 * t182 * t90 * t949 * ZA +
+                0.32e2 * t1195 * t968 * t10 - 0.8e1 * t1199 * t993 * t103 + 0.8e1 * t1203 * t118 * n * t919 +
+                0.8e1 * t1170 * t136 * t955 + 0.64e2 * t1211 * t1044 + 0.16e2 * t1031 * t1032 * t4 +
+                0.8e1 * t987 * t943 + 0.8e1 * t1199 * t993 * t10 + 0.8e1 * t997 * t1050 * t4;
+        t1263 = -0.128e3 * t1015 * t1178 * t1044 + 0.16e2 * t1005 * t988 * t1153 + 0.8e1 * t1058 * t1153 * t919 +
+                0.16e2 * t1010 * t1120 * xc - 0.8e1 * t954 * t1113 - 0.8e1 * t1203 * t14 * n * t919 -
+                0.16e2 * t1203 * t14 * t31 * t4 - 0.8e1 * t1203 * t1113 - 0.32e2 * t1195 * t977 * t10 -
+                0.64e2 * t1211 * t1054 + 0.8e1 * t992 * t967 * t1153 + 0.128e3 * t1015 * t983 * t90 * t4 * t47;
+
+        _C1B = (t127 + t204 + t270 + t329 + t384 + t439 + t501 + t549 + t601 + t647 + t698 + t739 + t782 + t821 +
+                t867 + t909) / (t953 + t1013 + t1057 + t1094 + t1140 + t1182 + t1225 + t1263);
+        /****************************************************************************************/
+        t1 = n * n;
+        t2 = t1 * n;
+        t3 = nx * t2;
+        t4 = 0.3141592654e1 * ZA;
+        t5 = t3 * t4;
+        t6 = nx * 0.3141592654e1;
+        t7 = t6 * xc;
+        t8 = sin(t7);
+        t9 = t8 * ZB;
+        t10 = n * 0.3141592654e1;
+        t11 = exp(t10);
+        t12 = t11 * t11;
+        t15 = exp(xc * n * 0.3141592654e1);
+        t16 = t15 * t15;
+        t17 = t16 * t16;
+        t18 = t17 * t15;
+        t19 = t12 * t18;
+        t23 = t1 * t1;
+        t24 = nx * t23;
+        t25 = ZB * ZB;
+        t27 = t18 * t8;
+        t28 = 0.3141592654e1 * 0.3141592654e1;
+        t29 = xc * xc;
+        t30 = t28 * t29;
+        t34 = t1 * xc;
+        t35 = 0.3141592654e1 * ZB;
+        t36 = t34 * t35;
+        t37 = cos(t7);
+        t38 = ZA * t37;
+        t39 = nx * nx;
+        t40 = t39 * t12;
+        t41 = t16 * t15;
+        t43 = t38 * t40 * t41;
+        t46 = t25 * n;
+        t47 = t46 * 0.3141592654e1;
+        t48 = t39 * nx;
+        t49 = sin(t6);
+        t50 = t48 * t49;
+        t51 = t12 * t11;
+        t52 = t51 * t17;
+        t53 = t50 * t52;
+        t56 = t34 * 0.3141592654e1 * t25;
+        t57 = t37 * t39;
+        t58 = t17 * t41;
+        t59 = t12 * t58;
+        t60 = t57 * t59;
+        t63 = t25 * t18;
+        t64 = t57 * n;
+        t67 = ZA * ZA;
+        t68 = t67 * n;
+        t69 = 0.3141592654e1 * t48;
+        t70 = t68 * t69;
+        t71 = t49 * xc;
+        t72 = t17 * t16;
+        t73 = t11 * t72;
+        t74 = t71 * t73;
+        t77 = t1 * t67;
+        t78 = t77 * 0.3141592654e1;
+        t81 = nx * t25;
+        t82 = t81 * t49;
+        t83 = t17 * t17;
+        t85 = t1 * t83 * t11;
+        t87 = nx * ZB;
+        t88 = t8 * t2;
+        t89 = t87 * t88;
+        t90 = 0.3141592654e1 * xc;
+        t91 = t12 * t12;
+        t92 = ZA * t91;
+        t97 = ZB * ZA;
+        t98 = t97 * t37;
+        t99 = t39 * n;
+        t100 = t12 * t41;
+        t104 = 0.8e1 * t5 * t9 * t19 + 0.8e1 * t24 * t25 * t27 * t30 + 0.12e2 * t36 * t43 - t47 * t53 -
+               0.2e1 * t56 * t60 - 0.4e1 * t63 * t64 + 0.6e1 * t70 * t74 + 0.4e1 * t78 * t60 - t82 * t85 +
+               0.4e1 * t89 * t90 * t92 * t41 + 0.4e1 * t98 * t99 * t100;
+        t105 = t67 * t48;
+        t106 = t49 * t51;
+        t107 = t106 * t72;
+        t109 = t1 * 0.3141592654e1;
+        t110 = t109 * xc;
+        t115 = nx * t67;
+        t116 = t115 * t49;
+        t117 = t1 * t16;
+        t118 = t117 * t11;
+        t120 = t2 * t25;
+        t121 = t28 * 0.3141592654e1;
+        t122 = t121 * t29;
+        t123 = t120 * t122;
+        t129 = t1 * ZB;
+        t130 = t129 * t4;
+        t131 = t57 * t100;
+        t134 = t12 * t16;
+        t136 = t109 * t39;
+        t139 = ZB * t18;
+        t141 = t39 * t1;
+        t142 = t141 * t90;
+        t145 = t77 * t90;
+        t146 = t91 * t41;
+        t147 = t57 * t146;
+        t151 = t25 * t39 * t1;
+        t152 = t72 * t12;
+        t156 = t49 * t2;
+        t158 = t83 * t11;
+        t162 = -t105 * t107 + 0.8e1 * t110 * t72 * t25 * t39 - t116 * t118 + 0.8e1 * t123 * t53 +
+               0.8e1 * t5 * t9 * t59 - 0.8e1 * t130 * t131 - 0.8e1 * t134 * t25 * t136 -
+               0.12e2 * t139 * t38 * t142 - 0.8e1 * t145 * t147 - 0.8e1 * t151 * t90 * t152 -
+               0.2e1 * t87 * t156 * t4 * t158;
+        t164 = t115 * t88;
+        t165 = t90 * t19;
+        t168 = t25 * t48;
+        t169 = t49 * t16;
+        t170 = t169 * t11;
+        t174 = ZA * n * t69;
+        t175 = ZB * t51;
+        t176 = t175 * t17;
+        t177 = t71 * t176;
+        t180 = t1 * t29;
+        t181 = t28 * t25;
+        t182 = t180 * t181;
+        t183 = t50 * t73;
+        t186 = ZA * t1;
+        t187 = t28 * t48;
+        t188 = t186 * t187;
+        t189 = ZB * t17;
+        t190 = t189 * t11;
+        t191 = t71 * t190;
+        t194 = t50 * t158;
+        t196 = t115 * t156;
+        t197 = t90 * t73;
+        t201 = t49 * t17 * t11;
+        t204 = t88 * t90;
+        t207 = t68 * 0.3141592654e1;
+        t208 = t17 * t11;
+        t209 = t50 * t208;
+        t211 = -0.2e1 * t164 * t165 - t168 * t170 + t168 * t107 + 0.8e1 * t174 * t177 + 0.2e1 * t182 * t183 +
+               0.8e1 * t188 * t191 + t47 * t194 - 0.6e1 * t196 * t197 - t168 * t201 - 0.4e1 * t81 * t18 * t204 -
+               t207 * t209;
+        t212 = t2 * 0.3141592654e1;
+        t213 = t212 * t52;
+        t215 = t81 * t8;
+        t216 = t212 * t59;
+        t219 = t3 * t90;
+        t220 = t25 * t8;
+        t221 = t18 * t91;
+        t225 = t71 * t52;
+        t231 = t16 * t51;
+        t232 = t50 * t231;
+        t237 = ZA * t12;
+        t243 = t67 * t28;
+        t244 = t24 * t243;
+        t245 = t71 * t231;
+        t249 = -t116 * t213 - 0.4e1 * t215 * t216 + 0.2e1 * t219 * t220 * t221 - 0.4e1 * t70 * t225 +
+               0.4e1 * t98 * t99 * t146 + t47 * t232 - 0.2e1 * t145 * t57 * t221 + 0.4e1 * t89 * t90 * t237 * t41 -
+               t105 * t201 - 0.6e1 * t244 * t245 + t105 * t170;
+        t252 = t25 * t37;
+        t253 = t252 * t39;
+        t255 = n * t15 * t12;
+        t258 = t2 * t29;
+        t259 = ZB * t28;
+        t260 = t258 * t259;
+        t263 = t106 * t17;
+        t265 = xc * t25;
+        t269 = t25 * t49;
+        t270 = t269 * t52;
+        t273 = t1 * t25;
+        t274 = t273 * 0.3141592654e1;
+        t275 = t57 * t19;
+        t278 = t24 * t30;
+        t288 = t1 * t11 * t72;
+        t290 = t212 * t208;
+        t292 = t2 * xc;
+        t296 = 0.2e1 * t253 * t255 + 0.16e2 * t260 * t43 + t105 * t263 - 0.4e1 * t10 * t265 * t53 +
+               0.4e1 * t219 * t270 - 0.12e2 * t274 * t275 + 0.8e1 * t278 * t270 -
+               0.2e1 * ZB * n * t69 * t49 * ZA * t158 - t82 * t288 - t116 * t290 + 0.16e2 * t292 * t243 * t275;
+        t301 = t50 * t176;
+        t304 = t51 * t72;
+        t305 = t71 * t304;
+        t308 = t25 * t41;
+        t311 = ZA * t48;
+        t312 = t311 * t49;
+        t317 = t91 * t15;
+        t318 = t57 * t317;
+        t321 = t81 * t88;
+        t322 = t90 * t59;
+        t325 = t212 * t231;
+        t327 = t15 * t12;
+        t328 = t57 * t327;
+        t331 = t77 * t187;
+        t334 = t2 * ZA;
+        t335 = t334 * t122;
+        t336 = t50 * t190;
+        t339 = 0.8e1 * t151 * t90 * t134 + 0.16e2 * t186 * t30 * t301 - 0.2e1 * t70 * t305 + 0.2e1 * t308 * t64 -
+               0.2e1 * t312 * ZB * t83 * t11 + 0.2e1 * t56 * t318 + 0.2e1 * t321 * t322 - t116 * t325 -
+               0.4e1 * t274 * t328 + 0.2e1 * t331 * t305 - 0.16e2 * t335 * t336;
+        t341 = t169 * t51;
+        t344 = t49 * t11 * t72;
+        t346 = t77 * t30;
+        t347 = t50 * t304;
+        t350 = t25 * t51;
+        t352 = nx * ZA;
+        t353 = t49 * t23;
+        t354 = t352 * t353;
+        t355 = t28 * xc;
+        t362 = t25 * t91;
+        t365 = t23 * n;
+        t366 = nx * t365;
+        t367 = t366 * t122;
+        t368 = ZB * t49;
+        t369 = ZA * t51;
+        t370 = t369 * t17;
+        t371 = t368 * t370;
+        t374 = t115 * t353;
+        t375 = t355 * t73;
+        t381 = t105 * t341 - t105 * t344 - 0.2e1 * t346 * t347 - t350 * t50 - 0.8e1 * t354 * t355 * t176 -
+               0.4e1 * t98 * t99 * t317 - 0.2e1 * t362 * t99 - 0.16e2 * t367 * t371 + 0.6e1 * t374 * t375 -
+               0.8e1 * t182 * t53 - t82 * t290;
+        t382 = t71 * t208;
+        t394 = t2 * t67;
+        t395 = t394 * t122;
+        t398 = t352 * t156;
+        t402 = t17 * t12;
+        t403 = t39 * ZA;
+        t404 = t402 * t403;
+        t407 = t269 * t208;
+        t411 = t49 * t83 * t11;
+        t413 = t46 * t69;
+        t419 = -0.4e1 * t331 * t382 + 0.2e1 * t115 * t58 * t204 - 0.2e1 * t145 * t60 + 0.12e2 * t274 * t131 +
+               0.2e1 * t346 * t232 + 0.8e1 * t395 * t53 - 0.8e1 * t398 * t90 * t176 - 0.64e2 * t260 * t404 +
+               0.4e1 * t219 * t407 + t168 * t411 - 0.6e1 * t413 * t74 - 0.2e1 * t110 * t308 * t57;
+        t424 = t16 * t11;
+        t425 = t212 * t424;
+        t427 = t258 * t181;
+        t430 = t67 * t29;
+        t431 = t366 * t430;
+        t432 = t121 * t49;
+        t433 = t432 * t52;
+        t436 = n * t12;
+        t437 = t436 * t18;
+        t440 = t29 * xc;
+        t441 = t440 * t121;
+        t442 = t394 * t441;
+        t445 = t67 * t37;
+        t446 = t445 * t39;
+        t448 = n * t18 * t91;
+        t453 = t352 * t49;
+        t458 = t8 * t23;
+        t462 = t81 * t458;
+        t463 = t30 * t19;
+        t466 = -t47 * t209 + t116 * t425 - 0.8e1 * t427 * t275 + 0.8e1 * t431 * t433 - 0.2e1 * t253 * t437 -
+               0.8e1 * t442 * t53 - 0.2e1 * t446 * t448 + 0.2e1 * t175 * t312 + 0.6e1 * t453 * t129 * t208 +
+               0.8e1 * t115 * t18 * t458 * t30 + 0.8e1 * t462 * t463;
+        t470 = t436 * t58;
+        t475 = t2 * t121 * t440 * t25;
+        t485 = t212 * t73;
+        t488 = t67 * t72 * t1;
+        t490 = t39 * xc;
+        t501 = 0.4e1 * t374 * t355 * t52 + 0.2e1 * t446 * t470 - 0.8e1 * t475 * t53 - 0.2e1 * t446 * t437 -
+               0.4e1 * t36 * t38 * t39 * t15 * t12 - t116 * t485 + 0.8e1 * t488 * 0.3141592654e1 * t12 * t490 -
+               t207 * t183 - 0.2e1 * t182 * t232 - 0.6e1 * t413 * t245 - 0.4e1 * t413 * t382;
+        t503 = t115 * t8;
+        t510 = t355 * t19;
+        t513 = t432 * t208;
+        t525 = t38 * t40 * t18;
+        t533 = -0.4e1 * t503 * t216 - 0.4e1 * t89 * t90 * t92 * t15 - 0.16e2 * t462 * t510 + 0.8e1 * t431 * t513 -
+               0.4e1 * t78 * t131 + t47 * t183 - 0.2e1 * t67 * t83 * t99 + 0.4e1 * t331 * t225 +
+               0.16e2 * t260 * t525 - 0.4e1 * t89 * t90 * t237 * t58 - t207 * t53;
+        t536 = t28 * t37;
+        t538 = t490 * t100;
+        t541 = t334 * t441;
+        t547 = t394 * t30;
+        t550 = t212 * t19;
+        t553 = t366 * t441;
+        t556 = n * t17;
+        t571 = -0.8e1 * t427 * t131 + 0.16e2 * t394 * t536 * t538 + 0.16e2 * t541 * t336 +
+               0.2e1 * t453 * t129 * t158 - 0.8e1 * t547 * t147 + 0.4e1 * t503 * t550 - 0.8e1 * t553 * t270 +
+               0.4e1 * t556 * ZB * t92 * t39 - 0.2e1 * t67 * t91 * t99 - t82 * t425 + 0.4e1 * t78 * t275 +
+               0.2e1 * t78 * xc * t41 * t57;
+        t583 = t90 * t317;
+        t594 = t212 * t158;
+        t596 = t152 * t67;
+        t602 = t67 * t17;
+        t607 = 0.8e1 * t367 * t407 - 0.4e1 * t98 * t99 * t59 + 0.16e2 * t260 * t18 * ZA * t57 +
+               0.2e1 * t321 * t583 - 0.6e1 * t174 * t368 * t52 - 0.4e1 * t89 * t90 * ZA * t15 * t12 + t116 * t594 -
+               0.8e1 * t596 * t136 - 0.4e1 * t98 * t99 * t327 + 0.2e1 * t602 * t99 + 0.2e1 * t164 * t583;
+        t613 = t83 * t25;
+        t616 = t81 * t156;
+        t627 = t90 * t231;
+        t630 = t91 * t16;
+        t638 = 0.4e1 * t196 * t90 * t208 - 0.8e1 * t130 * t60 - 0.2e1 * t613 * t99 + 0.6e1 * t616 * t197 -
+               0.8e1 * t547 * t131 + 0.8e1 * t67 * t18 * t37 * t142 + 0.2e1 * t145 * t328 - 0.6e1 * t196 * t627 +
+               0.8e1 * t630 * t67 * t142 - 0.8e1 * t547 * t275 + 0.8e1 * t395 * t209;
+        t643 = t77 * t355;
+        t648 = t115 * t458;
+        t651 = t134 * t67;
+        t657 = t30 * t304;
+        t660 = t30 * t146;
+        t665 = t25 * t17;
+        t668 = t50 * t424;
+        t671 = -0.4e1 * t321 * t90 * t146 - 0.6e1 * t643 * t232 + 0.8e1 * t182 * t209 - 0.16e2 * t648 * t510 +
+               0.8e1 * t651 * t136 + 0.8e1 * t89 * t4 * t100 - 0.2e1 * t374 * t657 - 0.8e1 * t648 * t660 +
+               0.8e1 * t130 * t328 + 0.2e1 * t665 * t99 + 0.2e1 * t346 * t668;
+        t672 = t90 * t424;
+        t676 = t120 * t536;
+        t680 = t436 * t41;
+        t688 = t366 * t67 * t440;
+        t696 = xc * t12;
+        t697 = t696 * t18;
+        t701 = t252 * t141;
+        t702 = t90 * t221;
+        t705 = 0.2e1 * t196 * t672 - t47 * t347 + 0.16e2 * t676 * t538 - t116 * t85 - 0.2e1 * t253 * t680 +
+               t207 * t194 + 0.4e1 * t98 * t99 * t19 - 0.8e1 * t688 * t433 + 0.16e2 * t541 * t301 -
+               0.6e1 * t312 * t190 + 0.4e1 * t352 * t88 * t35 * t697 + 0.2e1 * t701 * t702;
+        t712 = t24 * t430;
+        t713 = t28 * t49;
+        t721 = t1 * t17 * t11;
+        t726 = ZB * xc;
+        t737 = n * t91;
+        t741 = 0.8e1 * t346 * t209 + 0.2e1 * t712 * t713 * t424 + 0.8e1 * t130 * t275 - t47 * t668 + t116 * t721 -
+               0.8e1 * t688 * t513 + 0.4e1 * t352 * t27 * t212 * t726 + 0.8e1 * t648 * t463 + 0.4e1 * t274 * t60 -
+               0.4e1 * t374 * t355 * t208 - 0.4e1 * t253 * t737 * t41;
+        t745 = t269 * t231;
+        t749 = t1 * t28 * t265;
+        t757 = t16 * t39;
+        t758 = t696 * t757;
+        t762 = t69 * t49;
+        t772 = t355 * t100;
+        t775 = t81 * t353;
+        t778 = -0.8e1 * t398 * t90 * t190 - 0.2e1 * t278 * t745 + 0.4e1 * t749 * t53 +
+               0.32e2 * t394 * t29 * t28 * t17 * t40 - 0.8e1 * t78 * t758 + t350 * n * t762 -
+               0.6e1 * t87 * t49 * t186 * t52 - 0.8e1 * t553 * t407 - 0.4e1 * t749 * t209 + 0.16e2 * t648 * t772 -
+               0.6e1 * t775 * t375;
+        t790 = t212 * t304;
+        t793 = t156 * 0.3141592654e1;
+        t795 = t355 * t304;
+        t800 = t91 * t39;
+        t801 = t800 * n;
+        t807 = t2 * t28;
+        t808 = t807 * t726;
+        t811 = -0.2e1 * t616 * t672 - 0.2e1 * t446 * t680 - 0.2e1 * t78 * xc * t58 * t57 + 0.8e1 * t367 * t270 -
+               t82 * t790 + t115 * t51 * t793 - 0.2e1 * t775 * t795 + 0.8e1 * t123 * t209 + 0.2e1 * t665 * t801 -
+               0.2e1 * t67 * t41 * t64 - 0.32e2 * t808 * t43;
+        t812 = t117 * t51;
+        t821 = t24 * t355;
+        t827 = t90 * t304;
+        t840 = t800 * t41;
+        t844 = -t116 * t812 - 0.2e1 * t110 * t25 * t58 * t57 - 0.4e1 * t78 * t328 + t82 * t485 -
+               0.4e1 * t821 * t407 + 0.4e1 * t196 * t90 * t52 + 0.2e1 * t196 * t827 + t82 * t325 +
+               0.2e1 * t253 * t448 - 0.32e2 * t402 * t67 * t807 * t490 - t207 * t232 +
+               0.12e2 * t186 * t90 * ZB * t37 * t840;
+        t849 = t1 * t51;
+        t850 = t849 * t17;
+        t860 = t269 * t424;
+        t863 = t273 * t187;
+        t874 = 0.16e2 * t462 * t772 - t116 * t850 + 0.16e2 * t553 * t371 + t116 * t288 -
+               0.12e2 * t97 * t57 * t109 * t697 + t82 * t594 - 0.2e1 * t278 * t860 - 0.2e1 * t863 * t305 -
+               0.16e2 * t180 * t259 * t311 * t201 - 0.6e1 * t863 * t74 + 0.8e1 * t174 * t191;
+        t879 = xc * ZA;
+        t888 = t67 * t51;
+        t901 = ZA * t17;
+        t903 = t368 * t901 * t11;
+        t908 = -0.2e1 * t352 * t51 * t156 * t35 + 0.64e2 * t879 * t189 * t807 * t40 +
+               0.2e1 * t46 * t58 * t37 * t39 - t888 * t50 + t105 * t411 - 0.16e2 * t335 * t301 +
+               0.8e1 * t152 * t25 * t136 - 0.8e1 * t278 * t407 + 0.2e1 * t712 * t713 * t231 - 0.16e2 * t367 * t903 +
+               0.2e1 * t145 * t318;
+        t923 = t71 * t424;
+        t926 = t87 * t458;
+        t927 = t28 * ZA;
+        t944 = 0.8e1 * t354 * t355 * t190 - 0.8e1 * t110 * t16 * t25 * t800 - 0.2e1 * t374 * t30 * t73 -
+               0.16e2 * t354 * t30 * t176 - 0.2e1 * t244 * t923 - 0.32e2 * t926 * t927 * t696 * t41 -
+               0.32e2 * t808 * t525 + 0.6e1 * t749 * t232 - 0.8e1 * t188 * t177 + 0.4e1 * t36 * t58 * ZA * t57 +
+               0.4e1 * t821 * t270;
+        t948 = t90 * t327;
+        t961 = t30 * t100;
+        t964 = t29 * t49;
+        t981 = t106 * t1;
+        t983 = -0.2e1 * t219 * t220 * t100 + 0.2e1 * t321 * t948 - 0.16e2 * t189 * ZA * t99 * t12 -
+               0.2e1 * t369 * n * t69 * t368 + 0.2e1 * t374 * t795 - 0.8e1 * t462 * t961 -
+               0.8e1 * t244 * t964 * t208 + 0.2e1 * t413 * t923 + 0.4e1 * t36 * t38 * t40 * t58 -
+               0.2e1 * t87 * t51 * t49 * t1 * ZA + t888 * n * t762 + t115 * t981;
+        t1012 = 0.6e1 * t616 * t627 - t82 * t213 + 0.2e1 * t775 * t657 - 0.12e2 * t215 * t550 -
+                0.6e1 * t145 * t131 + 0.2e1 * t81 * t41 * t204 + 0.6e1 * ZB * t48 * t49 * t370 -
+                0.4e1 * t70 * t382 + 0.2e1 * t446 * t255 + 0.8e1 * t89 * t4 * t327 - 0.4e1 * t56 * t147;
+        t1018 = t212 * t100;
+        t1029 = t212 * t327;
+        t1040 = 0.6e1 * t70 * t245 + 0.2e1 * t56 * t328 + t207 * t668 + 0.4e1 * t503 * t1018 + 0.2e1 * t253 * t470 -
+                0.6e1 * t398 * t35 * t208 - 0.8e1 * t331 * t964 * t52 - 0.4e1 * t503 * t1029 + 0.6e1 * t821 * t745 +
+                0.4e1 * t63 * t37 * t142 + 0.16e2 * t260 * t38 * t840;
+        t1068 = t207 * t347 - 0.2e1 * t164 * t702 - 0.2e1 * t331 * t964 * t73 + 0.8e1 * t374 * t30 * t52 +
+                0.16e2 * t278 * t903 + 0.2e1 * t863 * t923 + 0.6e1 * t445 * t141 * t165 -
+                0.2e1 * t164 * t90 * t100 + 0.6e1 * t331 * t74 - 0.2e1 * t182 * t668 - 0.2e1 * t115 * t41 * t204;
+        t1079 = t58 * t8;
+        t1091 = t807 * t29;
+        t1092 = t665 * t40;
+        t1101 = ZB * t91;
+        t1102 = t403 * n;
+        t1105 = -0.4e1 * t58 * ZB * ZA * t64 - t82 * t850 + 0.2e1 * t821 * t860 + t81 * t51 * t793 +
+                0.2e1 * t3 * t25 * t1079 * t90 + t82 * t721 - 0.2e1 * t643 * t668 +
+                0.16e2 * t926 * t927 * t29 * t91 * t41 + 0.32e2 * t1091 * t1092 - 0.2e1 * t219 * t220 * t19 +
+                0.4e1 * t139 * ZA * t64 + 0.4e1 * t1101 * t1102;
+        t1108 = t849 * t72;
+        t1121 = t737 * t15;
+        t1124 = t29 * t12;
+        t1133 = t116 * t1108 - 0.8e1 * t475 * t209 - 0.32e2 * t807 * xc * t1092 + 0.2e1 * t278 * t269 * t73 +
+                t82 * t812 - 0.6e1 * t56 * t131 + 0.2e1 * t253 * t1121 + 0.16e2 * t926 * t927 * t1124 * t41 +
+                t168 * t263 - 0.2e1 * t616 * t827 + t81 * t981;
+        t1134 = t394 * t28;
+        t1159 = -0.8e1 * t1134 * t29 * t18 * t57 + t82 * t118 - 0.12e2 * t215 * t1018 + 0.2e1 * t602 * t801 -
+                t168 * t341 + 0.2e1 * t67 * t58 * t64 + t168 * t344 - 0.6e1 * t174 * t368 * t208 +
+                0.16e2 * t553 * t903 + t116 * t790 - 0.4e1 * t36 * t38 * t800 * t15;
+        t1161 = n * t83;
+        t1173 = ZB * t12;
+        t1196 = 0.4e1 * t1161 * ZB * t39 * ZA - 0.4e1 * t215 * t1029 - 0.8e1 * t488 * 0.3141592654e1 * t39 * xc +
+                0.32e2 * t821 * ZA * t8 * t1173 * t18 - 0.8e1 * t427 * t147 + 0.6e1 * t701 * t165 -
+                0.16e2 * t926 * t927 * t1124 * t18 - 0.8e1 * t1091 * t63 * t57 - 0.8e1 * t442 * t209 -
+                0.8e1 * t462 * t660 - 0.6e1 * t398 * t35 * t52;
+        t1228 = 0.2e1 * t413 * t305 - 0.8e1 * t648 * t961 - 0.16e2 * t87 * t27 * t23 * t28 * ZA * t29 +
+                0.4e1 * t189 * t1102 - 0.4e1 * t87 * t1079 * t212 * t879 + 0.2e1 * t164 * t948 -
+                0.2e1 * t70 * t923 + 0.2e1 * t164 * t322 + 0.2e1 * t446 * t1121 + 0.2e1 * t863 * t964 * t304 -
+                t82 * t1108 + 0.16e2 * t676 * t490 * t19;
+        t1234 = t25 * ZB;
+        t1235 = t1234 * t28;
+        t1236 = t365 * t91;
+        t1240 = ZB * t121;
+        t1241 = t1240 * t77;
+        t1242 = t39 * t39;
+        t1243 = t12 * t1242;
+        t1244 = xc * t72;
+        t1245 = t1243 * t1244;
+        t1248 = t365 * t25;
+        t1252 = t243 * n;
+        t1257 = t23 * t1;
+        t1258 = t1240 * t1257;
+        t1259 = t67 * t12;
+        t1260 = xc * t16;
+        t1268 = t1234 * t121;
+        t1269 = t1268 * t23;
+        t1272 = t1242 * t91;
+        t1280 = t67 * xc;
+        t1284 = t28 * t28;
+        t1285 = t67 * t1284;
+        t1287 = t1285 * t2 * ZB;
+        t1288 = t17 * xc;
+        t1289 = t1243 * t1288;
+        t1292 = 0.2e1 * t1235 * t1236 * t17 + 0.8e1 * t1241 * t1245 + 0.4e1 * t927 * t1248 * t91 -
+                0.2e1 * t1252 * ZB * t1242 * t91 - 0.8e1 * t1258 * t1259 * t1260 - 0.4e1 * t1235 * t2 * t83 * t39 +
+                0.16e2 * t1269 * t758 + 0.2e1 * t1252 * t189 * t1272 - 0.2e1 * t1252 * t83 * t1242 * ZB +
+                0.8e1 * t1258 * t630 * t1280 - 0.32e2 * t1287 * t1289;
+        t1293 = t365 * t83;
+        t1300 = ZA * t1284;
+        t1304 = t17 * t1242 * t25 * t12;
+        t1307 = t927 * t2;
+        t1311 = t23 * t2;
+        t1312 = t1300 * t1311;
+        t1316 = t1234 * t1284;
+        t1317 = t1316 * t1311;
+        t1321 = t1240 * t23;
+        t1331 = t1240 * t23 * t67;
+        t1332 = t40 * t1244;
+        t1338 = t1243 * t1260;
+        t1344 = -0.2e1 * t1235 * t1293 - 0.16e2 * t181 * t365 * t901 * t12 - 0.64e2 * t1300 * t258 * t1304 +
+                0.8e1 * t1307 * t613 * t39 + 0.64e2 * t1312 * t265 * t402 - 0.32e2 * t1317 * t1288 * t12 -
+                0.16e2 * t1321 * t67 * t39 * t1244 + 0.2e1 * t1235 * n * t1272 * t17 + 0.16e2 * t1331 * t1332 +
+                0.64e2 * t1300 * t292 * t1304 - 0.8e1 * t1241 * t1338 - 0.2e1 * t243 * t1293 * ZB;
+        t1346 = t1316 * t2;
+        t1349 = t927 * n;
+        t1350 = t25 * t1242;
+        t1354 = t1268 * t1257;
+        t1366 = t1268 * t1;
+        t1370 = t29 * t17;
+        t1371 = t1243 * t1370;
+        t1386 = -0.32e2 * t1346 * t1289 + 0.4e1 * t1349 * t1350 * t91 + 0.8e1 * t1354 * t1260 * t12 -
+                0.16e2 * t181 * n * t901 * t1243 - 0.4e1 * t1235 * t2 * t91 * t39 + 0.8e1 * t1366 * t152 * t1242 +
+                0.32e2 * t1287 * t1371 + 0.8e1 * t1258 * t1280 * t152 - 0.8e1 * t1354 * t1260 * t91 +
+                0.128e3 * t1300 * t365 * xc * t1092 + 0.8e1 * t1366 * t1338;
+        t1387 = t1257 * t12;
+        t1391 = t1240 * t1;
+        t1399 = t1272 * t1260;
+        t1412 = t1285 * t1311;
+        t1427 = -0.8e1 * t1268 * t1387 * t16 - 0.8e1 * t1391 * t67 * t1242 * t1244 - 0.4e1 * t1134 * t1101 * t39 +
+                0.8e1 * t1241 * t1399 - 0.8e1 * t1258 * t596 + 0.4e1 * t927 * t1293 * t25 - 0.16e2 * t1331 * t758 +
+                0.8e1 * t1307 * t665 * t39 + 0.32e2 * t1412 * t1370 * t1173 + 0.8e1 * t1307 * t665 * t800 +
+                0.8e1 * t1391 * t1259 * t1242 * t16 - 0.8e1 * t1391 * t1259 * t1242 * t72;
+        t1456 = t365 * ZB;
+        t1468 = 0.4e1 * t927 * t1248 * t17 - 0.2e1 * t1235 * n * t1242 * t91 + 0.8e1 * t1366 * t1244 * t1242 -
+                0.16e2 * t1269 * t134 * t39 + 0.8e1 * t1268 * t1257 * t72 * xc + 0.16e2 * t1321 * t1259 * t757 +
+                0.32e2 * t1317 * t1370 * t12 + 0.4e1 * t1349 * t613 * t1242 + 0.2e1 * t243 * t1456 * t17 -
+                0.64e2 * t1285 * t365 * t12 * t189 * t490 - 0.8e1 * t1354 * t152 * xc;
+        t1472 = t1316 * t365;
+        t1474 = t1124 * t39 * t17;
+        t1478 = t17 * t91;
+        t1504 = t72 * t39;
+        t1511 = 0.4e1 * t1134 * t189 * t800 + 0.64e2 * t1472 * t1474 + 0.4e1 * t1235 * t2 * t1478 * t39 +
+                0.4e1 * t1349 * t665 * t1242 - 0.8e1 * t1258 * t1280 * t72 + 0.2e1 * t1252 * t189 * t1242 +
+                0.2e1 * t243 * t365 * t189 * t91 + 0.4e1 * t927 * t365 * t1478 * t25 -
+                0.128e3 * t1300 * t1248 * t1474 - 0.2e1 * t1235 * t1236 + 0.16e2 * t1269 * t1504 * xc +
+                0.2e1 * t1235 * t365 * t17;
+        t1545 = -0.2e1 * t1235 * t1161 * t1242 + 0.4e1 * t1349 * t1350 * t1478 - 0.8e1 * t1366 * t1245 +
+                0.2e1 * t1235 * t556 * t1242 - 0.32e2 * t1412 * t402 * t726 - 0.8e1 * t1366 * t1399 +
+                0.8e1 * t1258 * t651 - 0.2e1 * t243 * t1456 * t91 + 0.8e1 * t1268 * t1387 * t72 -
+                0.16e2 * t1269 * t1332 + 0.4e1 * t1134 * t189 * t39 + 0.16e2 * t1269 * t152 * t39;
+        t1564 = t1260 * t800;
+        t1583 = 0.64e2 * t1285 * t1456 * t1474 - 0.64e2 * t1472 * t1288 * t40 - 0.8e1 * t1366 * t134 * t1242 +
+                0.8e1 * t1307 * t362 * t39 + 0.4e1 * t1235 * t2 * t17 * t39 + 0.32e2 * t1346 * t1371 -
+                0.16e2 * t1269 * t1564 - 0.16e2 * t1321 * t1259 * t1504 + 0.16e2 * t1331 * t1564 -
+                0.64e2 * t1312 * t29 * t25 * t402 - 0.4e1 * t1134 * t83 * t39 * ZB - 0.32e2 * t181 * t2 * t404;
+
+        _C2B = (t1133 + t1196 + t1068 + t811 + t466 + t1012 + t381 + t162 + t249 + t533 + t844 + t104 + t1159 +
+                t571 + t211 + t874 + t607 + t339 + t296 + t638 + t908 + t671 + t419 + t983 + t705 + t1105 + t501 +
+                t778 + t1040 + t1228 + t741 + t944) /
+               (t1292 + t1344 + t1386 + t1427 + t1468 + t1511 + t1545 + t1583);
+        /****************************************************************************************/
+        t1 = n * n;
+        t2 = t1 * n;
+        t3 = t2 * nx;
+        t4 = nx * 0.3141592654e1;
+        t5 = t4 * xc;
+        t6 = sin(t5);
+        t7 = 0.3141592654e1 * 0.3141592654e1;
+        t9 = t3 * t6 * t7;
+        t10 = xc * xc;
+        t11 = ZA * ZA;
+        t12 = t10 * t11;
+        t13 = n * 0.3141592654e1;
+        t14 = exp(t13);
+        t15 = t14 * t14;
+        t16 = xc * n;
+        t18 = exp(t16 * 0.3141592654e1);
+        t19 = t18 * t18;
+        t20 = t19 * t18;
+        t21 = t15 * t20;
+        t22 = t12 * t21;
+        t25 = nx * t6;
+        t26 = t1 * 0.3141592654e1;
+        t27 = t25 * t26;
+        t28 = ZA * ZB;
+        t29 = t18 * t15;
+        t30 = t28 * t29;
+        t33 = t25 * n;
+        t34 = t11 * t15;
+        t35 = t19 * t19;
+        t36 = t35 * t18;
+        t40 = t25 * t1;
+        t41 = 0.3141592654e1 * t11;
+        t42 = t15 * t36;
+        t43 = t41 * t42;
+        t46 = nx * nx;
+        t47 = t1 * t46;
+        t48 = t47 * t11;
+        t49 = t7 * xc;
+        t50 = t35 * t15;
+        t51 = t49 * t50;
+        t55 = sin(t4);
+        t56 = t46 * nx * t55;
+        t58 = t56 * n * t7;
+        t59 = ZB * ZB;
+        t60 = t10 * t59;
+        t61 = t15 * t14;
+        t62 = t19 * t61;
+        t63 = t60 * t62;
+        t66 = t19 * t14;
+        t67 = t60 * t66;
+        t70 = t28 * t42;
+        t73 = cos(t5);
+        t74 = t47 * t73;
+        t75 = t7 * t11;
+        t77 = t75 * t10 * t36;
+        t80 = t73 * t46;
+        t81 = t80 * n;
+        t82 = 0.3141592654e1 * t59;
+        t83 = t82 * t42;
+        t87 = xc * t11;
+        t88 = t87 * t62;
+        t91 = n * nx;
+        t92 = t55 * t61;
+        t96 = nx * t55;
+        t98 = t96 * t2 * t7;
+        t101 = xc * t59;
+        t102 = t101 * t62;
+        t108 = t1 * t1;
+        t109 = t108 * t7;
+        t111 = t59 * t35;
+        t112 = t111 * t15;
+        t115 = t35 * t20;
+        t123 = t1 * nx * t55;
+        t124 = t61 * t35;
+        t127 = t35 * t19;
+        t128 = t61 * t127;
+        t129 = t60 * t128;
+        t132 = t56 * t16;
+        t133 = t7 * t59;
+        t134 = t133 * t124;
+        t137 = 0.6e1 * t58 * t88 - 0.2e1 * t91 * t92 * t11 + 0.2e1 * t98 * t63 - 0.6e1 * t58 * t102 -
+               0.2e1 * t91 * t92 * t59 - 0.16e2 * t109 * xc * t112 - 0.2e1 * t91 * t6 * t115 * t59 +
+               0.12e2 * t40 * t83 + t123 * t41 * t124 - 0.2e1 * t58 * t129 + 0.4e1 * t132 * t134;
+        t139 = t56 * 0.3141592654e1;
+        t140 = t111 * t14;
+        t144 = t49 * t124;
+        t147 = t91 * t55;
+        t148 = t61 * ZA;
+        t154 = ZA * t115 * xc * ZB;
+        t157 = t7 * 0.3141592654e1;
+        t159 = t96 * t108 * t157;
+        t160 = t10 * xc;
+        t161 = t160 * t59;
+        t162 = t35 * t14;
+        t163 = t161 * t162;
+        t166 = t28 * t162;
+        t169 = t80 * t13;
+        t170 = t101 * t42;
+        t173 = t2 * t11;
+        t174 = t96 * t173;
+        t175 = t7 * t10;
+        t179 = t59 * t15;
+        t184 = t15 * t15;
+        t193 = t139 * t140 + 0.4e1 * t56 * n * t11 * t144 + 0.4e1 * t147 * t148 * ZB + 0.4e1 * t27 * t154 +
+               0.8e1 * t159 * t163 - 0.12e2 * t147 * t166 + 0.2e1 * t169 * t170 - 0.16e2 * t174 * t175 * t124 +
+               0.2e1 * t33 * t179 * t20 - 0.2e1 * t33 * t11 * t36 * t184 +
+               0.2e1 * t56 * t61 * 0.3141592654e1 * ZA * ZB;
+        t194 = t173 * 0.3141592654e1;
+        t195 = xc * t15;
+        t196 = t195 * t19;
+        t202 = t15 * t115;
+        t203 = t28 * t202;
+        t206 = t96 * t26;
+        t207 = t14 * t127;
+        t208 = t101 * t207;
+        t211 = t12 * t128;
+        t218 = t11 * t61;
+        t219 = t218 * t35;
+        t221 = t108 * ZA;
+        t223 = t7 * ZB;
+        t224 = t223 * t50;
+        t227 = ZA * xc;
+        t228 = ZB * t15;
+        t229 = t228 * t36;
+        t230 = t227 * t229;
+        t233 = t87 * t207;
+        t236 = t6 * t11;
+        t240 = -0.4e1 * t194 * t196 + 0.4e1 * t194 * t195 * t127 + 0.4e1 * t33 * t203 - 0.12e2 * t206 * t208 +
+               0.2e1 * t58 * t211 - 0.16e2 * t47 * t10 * t133 * t50 + t139 * t219 - 0.32e2 * t221 * t10 * t224 -
+               0.4e1 * t169 * t230 - 0.6e1 * t98 * t233 + 0.2e1 * t91 * t236 * t20;
+        t244 = t227 * t228 * t20;
+        t252 = t184 * t18;
+        t253 = t101 * t252;
+        t256 = t35 * t35;
+        t257 = t256 * t14;
+        t258 = t28 * t257;
+        t261 = t108 * t11;
+        t263 = t7 * t35;
+        t268 = ZB * t61 * t35;
+        t273 = t96 * t108 * t160;
+        t274 = t157 * ZB;
+        t276 = t274 * t148 * t35;
+        t279 = t101 * t21;
+        t282 = 0.3141592654e1 * xc;
+        t283 = t59 * t36;
+        t284 = t282 * t283;
+        t289 = 0.4e1 * t169 * t244 - 0.4e1 * t132 * t133 * t162 - 0.2e1 * t147 * t140 - 0.2e1 * t27 * t253 +
+               0.2e1 * t139 * t258 + 0.16e2 * t261 * t10 * t263 * t15 - 0.16e2 * t206 * t227 * t268 -
+               0.16e2 * t273 * t276 - 0.6e1 * t27 * t279 - 0.4e1 * t40 * t284 - 0.32e2 * t9 * t230;
+        t290 = t1 * t11;
+        t291 = t96 * t290;
+        t297 = t59 * t61;
+        t298 = t297 * t127;
+        t300 = ZB * t36;
+        t301 = t227 * t300;
+        t304 = t1 * t59;
+        t305 = t184 * t35;
+        t310 = t46 * ZB;
+        t311 = t184 * ZA;
+        t312 = t310 * t311;
+        t314 = t60 * t21;
+        t317 = t1 * ZA;
+        t318 = ZB * t35;
+        t321 = t1 * t256;
+        t324 = t96 * t261;
+        t325 = t10 * t157;
+        t326 = t325 * t124;
+        t329 = -0.4e1 * t291 * t282 * t128 + t123 * t82 * t62 - t139 * t298 + 0.12e2 * t27 * t301 + t304 * t305 -
+               0.2e1 * t58 * t12 * t66 - 0.2e1 * t312 + 0.8e1 * t9 * t314 + 0.2e1 * t317 * t318 +
+               0.2e1 * t321 * t28 - 0.8e1 * t324 * t326;
+        t331 = t28 * t124;
+        t334 = 0.3141592654e1 * t15;
+        t335 = t334 * t127;
+        t338 = t35 * ZA;
+        t341 = t46 * t256;
+        t344 = t46 * t11;
+        t346 = t46 * t59;
+        t348 = t297 * t35;
+        t351 = ZA * t10;
+        t352 = t351 * t300;
+        t355 = t1 * ZB;
+        t362 = 0.12e2 * t147 * t331 - 0.4e1 * t173 * t335 - 0.2e1 * t310 * t338 - 0.2e1 * t341 * t28 - t344 * t305 -
+               t346 * t305 + 0.2e1 * t147 * t348 + 0.16e2 * t9 * t352 + 0.2e1 * t355 * t311 + t290 * t305 +
+               0.2e1 * t33 * t34 * t20;
+        t363 = t36 * t184;
+        t364 = t87 * t363;
+        t368 = t47 * t73 * t7;
+        t373 = t160 * t157;
+        t374 = t373 * t124;
+        t377 = t311 * t35;
+        t380 = t12 * t62;
+        t386 = ZB * t10 * ZA * t15 * t20;
+        t389 = t87 * t66;
+        t393 = t56 * t1 * t10;
+        t401 = 0.2e1 * t27 * t364 - 0.16e2 * t368 * t279 - t123 * t41 * t257 + 0.8e1 * t324 * t374 +
+               0.2e1 * t355 * t377 - 0.2e1 * t98 * t380 - 0.16e2 * t9 * t386 + 0.2e1 * t58 * t389 +
+               0.16e2 * t393 * t276 + t123 * t82 * t162 - 0.2e1 * t33 * t179 * t36;
+        t412 = t11 * t14 * t127;
+        t416 = t11 * t19;
+        t417 = t416 * t61;
+        t421 = t96 * t2 * ZA;
+        t426 = t56 * n * ZA;
+        t427 = t318 * t14;
+        t428 = t49 * t427;
+        t431 = t82 * t29;
+        t434 = t87 * t21;
+        t442 = 0.2e1 * t33 * t11 * t184 * t18 + 0.4e1 * t81 * t284 - t139 * t412 + 0.2e1 * t147 * t219 -
+               0.2e1 * t147 * t417 + 0.32e2 * t421 * t175 * t268 + 0.8e1 * t426 * t428 + 0.4e1 * t81 * t431 -
+               0.2e1 * t169 * t434 - 0.2e1 * t98 * t129 - 0.32e2 * t47 * t28 * t51;
+        t443 = t184 * t20;
+        t447 = t61 * 0.3141592654e1;
+        t448 = t447 * t11;
+        t450 = t49 * t268;
+        t453 = t60 * t42;
+        t456 = t41 * t202;
+        t463 = t101 * t443;
+        t469 = t41 * xc * t20;
+        t474 = -0.8e1 * t27 * t87 * t443 - t56 * t448 - 0.8e1 * t426 * t450 + 0.8e1 * t368 * t453 +
+               0.4e1 * t40 * t456 + 0.4e1 * t40 * t431 - 0.4e1 * t81 * t456 - 0.4e1 * t27 * t463 +
+               0.6e1 * t139 * t331 + 0.2e1 * t40 * t469 - 0.16e2 * t9 * t434;
+        t482 = t108 * t10;
+        t492 = n * t46;
+        t493 = t492 * t11;
+        t495 = t282 * t19 * t184;
+        t498 = t56 * t290;
+        t499 = t325 * t162;
+        t502 = t416 * t14;
+        t504 = t60 * t207;
+        t507 = -t123 * t82 * t257 - 0.4e1 * t169 * t301 + t123 * t41 * t162 + 0.16e2 * t482 * t7 * t112 -
+               0.12e2 * t206 * t102 - t123 * t82 * t66 - 0.4e1 * t147 * t258 - 0.4e1 * t493 * t495 -
+               0.8e1 * t498 * t499 + t139 * t502 - 0.2e1 * t98 * t504;
+        t508 = t101 * t162;
+        t512 = t41 * t115 * xc;
+        t515 = t87 * t42;
+        t520 = ZB * t184;
+        t522 = t227 * t520 * t18;
+        t525 = t492 * t59;
+        t528 = t6 * t59;
+        t532 = t520 * t20;
+        t533 = t351 * t532;
+        t539 = t447 * t59;
+        t544 = 0.8e1 * t206 * t508 - 0.2e1 * t40 * t512 - 0.16e2 * t368 * t515 + 0.12e2 * t206 * t88 +
+               0.4e1 * t27 * t522 + 0.4e1 * t525 * t495 - 0.4e1 * t91 * t528 * t36 - 0.16e2 * t368 * t533 -
+               0.16e2 * t206 * t227 * t427 - t56 * t539 - 0.2e1 * t132 * t133 * t66;
+        t551 = t87 * t162;
+        t554 = t351 * t229;
+        t560 = t59 * t19;
+        t561 = t560 * t14;
+        t564 = t101 * t202;
+        t567 = t87 * t252;
+        t573 = t227 * t228 * t115;
+        t578 = 0.4e1 * t33 * t70 + 0.4e1 * t493 * t335 - 0.4e1 * t58 * t551 + 0.16e2 * t9 * t554 -
+               0.4e1 * t33 * t28 * t252 + 0.2e1 * t147 * t561 + 0.2e1 * t169 * t564 - 0.2e1 * t27 * t567 -
+               0.8e1 * t324 * t499 - 0.4e1 * t169 * t573 + 0.12e2 * t27 * t244;
+        t579 = t82 * t202;
+        t591 = t282 * t115 * t59;
+        t598 = t101 * t66;
+        t606 = -0.4e1 * t81 * t579 - 0.2e1 * t169 * t567 - 0.6e1 * t27 * t170 + 0.8e1 * t169 * t203 +
+               0.2e1 * t98 * t67 + 0.2e1 * t81 * t591 + 0.32e2 * t368 * t244 - 0.2e1 * t27 * t564 +
+               0.4e1 * t206 * t598 + 0.16e2 * t9 * t170 + 0.2e1 * t33 * t283 * t184;
+        t608 = t373 * t162;
+        t611 = t59 * t184;
+        t617 = t101 * t29;
+        t624 = t227 * ZB * t18 * t15;
+        t629 = t157 * t59;
+        t630 = t629 * t124;
+        t633 = t3 * t6;
+        t634 = t175 * t283;
+        t644 = 0.8e1 * t498 * t608 + 0.2e1 * t33 * t611 * t18 - 0.4e1 * t206 * t389 - 0.2e1 * t27 * t617 -
+               0.4e1 * t169 * t154 + 0.4e1 * t27 * t624 + 0.12e2 * t27 * t230 - 0.8e1 * t393 * t630 -
+               0.8e1 * t633 * t634 + 0.16e2 * t47 * t7 * t101 * t50 + 0.2e1 * t123 * t447 * t28;
+        t645 = t41 * t29;
+        t648 = t2 * 0.3141592654e1;
+        t649 = t648 * xc;
+        t650 = t560 * t184;
+        t656 = t56 * t1 * t157;
+        t659 = t87 * t128;
+        t662 = t96 * t482;
+        t663 = t629 * t162;
+        t671 = t161 * t124;
+        t674 = t218 * t127;
+        t679 = 0.4e1 * t81 * t645 - 0.4e1 * t649 * t650 - 0.8e1 * t169 * t70 + 0.8e1 * t656 * t163 -
+               0.2e1 * t98 * t659 - 0.8e1 * t662 * t663 - 0.32e2 * t421 * t175 * t427 - 0.2e1 * t147 * t502 +
+               0.8e1 * t656 * t671 + 0.2e1 * t147 * t674 - 0.16e2 * t368 * t386;
+        t714 = t334 * t19;
+        t719 = t12 * t42;
+        t722 = t304 * t35 - t346 * t35 + t341 * t59 - t344 * t35 + t344 * t256 + t346 * t184 -
+               0.16e2 * t368 * t554 - 0.16e2 * t48 * t175 * t50 + 0.4e1 * t525 * t714 - 0.2e1 * t58 * t659 +
+               0.8e1 * t368 * t719;
+        t730 = xc * t19;
+        t735 = t59 * t256 * t14;
+        t752 = 0.4e1 * t173 * t714 - 0.6e1 * t27 * t515 - 0.16e2 * t9 * t279 + 0.4e1 * t194 * t730 * t184 -
+               t139 * t735 - 0.4e1 * t492 * t127 * t82 * xc - 0.4e1 * t98 * t508 - t123 * t41 * t207 -
+               0.2e1 * t147 * t298 + 0.8e1 * t368 * t314 + 0.6e1 * t132 * t133 * t207;
+        t755 = t28 * t21;
+        t759 = t274 * t338 * t14;
+        t767 = t11 * t35;
+        t768 = t767 * t14;
+        t778 = t560 * t61;
+        t781 = -0.2e1 * t58 * t504 - 0.8e1 * t27 * t755 + 0.16e2 * t662 * t759 + 0.12e2 * t291 * t282 * t207 -
+               0.6e1 * t27 * t434 + t139 * t768 - 0.8e1 * t498 * t326 + 0.4e1 * t33 * t611 * t20 +
+               0.2e1 * t81 * t512 - t139 * t561 + 0.2e1 * t147 * t778;
+        t786 = t12 * t443;
+        t790 = t282 * t59 * t20;
+        t796 = t59 * t14 * t127;
+        t806 = t41 * t21;
+        t811 = -0.8e1 * t393 * t663 + 0.8e1 * t368 * t786 + 0.2e1 * t81 * t790 + 0.4e1 * t169 * t624 + t139 * t796 +
+               0.2e1 * t206 * t258 - 0.2e1 * t40 * t591 - 0.8e1 * t662 * t630 - 0.4e1 * t33 * t30 -
+               0.4e1 * t40 * t806 + 0.8e1 * t9 * t786;
+        t819 = t282 * t15 * t127;
+        t822 = t101 * t363;
+        t830 = t11 * t256 * t14;
+        t835 = t227 * t532;
+        t842 = 0.2e1 * t33 * t11 * t18 * t15 + t123 * t41 * t66 - 0.4e1 * t493 * t819 - 0.2e1 * t27 * t822 -
+               0.16e2 * t368 * t170 - 0.4e1 * t169 * t463 - t139 * t830 - 0.4e1 * t649 * t179 * t127 +
+               0.12e2 * t27 * t835 - 0.16e2 * t368 * t434 - 0.2e1 * t40 * t790;
+        t845 = t87 * t202;
+        t854 = t338 * t15;
+        t859 = t12 * t207;
+        t868 = t139 * t348 - 0.2e1 * t27 * t845 + 0.8e1 * t169 * t755 - 0.2e1 * t58 * t380 + 0.6e1 * t206 * t331 +
+               0.8e1 * t310 * t854 - 0.2e1 * t169 * t822 + 0.2e1 * t98 * t859 + 0.8e1 * t159 * t671 +
+               0.8e1 * t74 * t634 - 0.2e1 * t169 * t253;
+        t880 = t60 * t443;
+        t891 = t101 * t128;
+        t894 = -t123 * t539 - 0.2e1 * t147 * t796 + 0.32e2 * t368 * t230 + t139 * t674 - 0.16e2 * t98 * t60 * t124 +
+               0.32e2 * t9 * t244 + 0.8e1 * t368 * t880 - 0.8e1 * t40 * t41 * xc * t36 - t123 * t82 * t128 -
+               0.6e1 * t58 * t233 + 0.2e1 * t58 * t891;
+        t903 = t179 * t19;
+        t920 = t56 * t1 * t160;
+        t925 = -0.2e1 * t174 * t175 * t66 - 0.4e1 * t493 * t714 + 0.4e1 * t649 * t903 - 0.4e1 * t81 * t43 +
+               t123 * t82 * t207 + 0.4e1 * t206 * t891 - 0.16e2 * t273 * t759 - 0.8e1 * t27 * t203 +
+               0.32e2 * t221 * ZB * t51 - 0.16e2 * t920 * t759 - 0.8e1 * t9 * t453;
+        t932 = t87 * t29;
+        t945 = t82 * t21;
+        t953 = -0.16e2 * t920 * t276 - 0.8e1 * t169 * t30 - 0.8e1 * t633 * t77 - 0.2e1 * t27 * t932 -
+               0.4e1 * t174 * t49 * t162 + 0.8e1 * t206 * t87 * t124 - 0.2e1 * t147 * t768 + 0.4e1 * t169 * t522 -
+               0.12e2 * t81 * t945 + 0.4e1 * t33 * t28 * t115 + 0.4e1 * t525 * t819;
+        t971 = t282 * t127;
+        t978 = -0.6e1 * t98 * t102 + 0.2e1 * t169 * t515 - 0.2e1 * t310 * t377 + 0.2e1 * t147 * t830 +
+               0.8e1 * t368 * t22 - 0.2e1 * t169 * t617 + 0.16e2 * t662 * t276 - 0.8e1 * t355 * t854 +
+               0.4e1 * t493 * t971 - 0.16e2 * t9 * t533 - 0.2e1 * t169 * t279;
+        t997 = xc * t127;
+        t998 = t997 * t59;
+        t1003 = 0.4e1 * t40 * t579 + 0.2e1 * t169 * t845 + 0.16e2 * t9 * t515 + 0.8e1 * t206 * t551 +
+                t123 * t41 * t128 + 0.16e2 * t98 * t60 * t162 + 0.2e1 * t169 * t364 - 0.2e1 * t169 * t932 +
+                t139 * t778 + 0.4e1 * t648 * t998 + 0.2e1 * t147 * t412;
+        t1006 = t2 * t59;
+        t1017 = xc * t35;
+        t1033 = 0.4e1 * t1006 * t335 + 0.4e1 * t81 * t806 - 0.2e1 * t33 * t34 * t115 + 0.8e1 * t498 * t374 -
+                0.16e2 * t261 * t7 * t1017 * t15 + 0.8e1 * t206 * t101 * t124 - t123 * t448 + 0.2e1 * t147 * t735 +
+                0.6e1 * t98 * t208 + 0.6e1 * t98 * t88 - 0.4e1 * t33 * t755;
+        t1055 = -0.4e1 * t173 * t971 + 0.2e1 * t98 * t891 + 0.8e1 * t9 * t880 + 0.4e1 * t169 * t835 - t304 * t184 +
+                t344 * t184 - t123 * t41 * t62 - 0.2e1 * t98 * t598 + 0.2e1 * t58 * t859 +
+                0.32e2 * t47 * t351 * t224 + 0.2e1 * t98 * t389;
+        t1070 = t15 * t19;
+        t1089 = -0.16e2 * t368 * t352 - 0.8e1 * t9 * t719 + 0.4e1 * t96 * t2 * xc * t134 -
+                0.2e1 * t91 * t236 * t115 + 0.4e1 * t27 * t573 + 0.4e1 * t493 * t282 * t1070 +
+                0.2e1 * t33 * t59 * t18 * t15 + 0.12e2 * t40 * t945 - 0.4e1 * t492 * xc * t82 * t1070 -
+                0.2e1 * t91 * t528 * t20 + 0.8e1 * t324 * t608;
+        t1113 = t123 * t82 * t124 + 0.8e1 * t421 * t428 - t139 * t417 + 0.4e1 * t40 * t645 + 0.16e2 * t393 * t759 -
+                0.2e1 * t33 * t179 * t115 - 0.4e1 * t525 * t335 + 0.4e1 * t33 * t28 * t36 - 0.4e1 * t1006 * t714 +
+                0.6e1 * t206 * t166 - 0.8e1 * t421 * t450;
+        t1119 = t321 * t46;
+        t1122 = t157 * t11;
+        t1123 = t1122 * t2;
+        t1124 = t184 * t46;
+        t1128 = t108 * n;
+        t1132 = t7 * t7;
+        t1133 = t1132 * t11;
+        t1134 = t1133 * t108;
+        t1135 = t15 * t46;
+        t1139 = t7 * ZA;
+        t1140 = t1139 * ZB;
+        t1141 = t1 * t35;
+        t1145 = t629 * t2;
+        t1146 = t1135 * t730;
+        t1149 = t157 * t1128;
+        t1150 = t1149 * xc;
+        t1153 = t46 * xc;
+        t1154 = t1153 * t127;
+        t1158 = t184 * t1 * t46;
+        t1161 = t46 * t46;
+        t1162 = t35 * t1161;
+        t1166 = t7 * t1;
+        t1170 = -0.4e1 * t133 * t1119 + 0.16e2 * t1123 * t1124 * t730 - 0.8e1 * t1122 * t1128 * t196 -
+                0.64e2 * t1134 * t1135 * t1017 - 0.32e2 * t1140 * t1141 * t1135 + 0.16e2 * t1145 * t1146 -
+                0.8e1 * t1150 * t650 - 0.16e2 * t1123 * t1154 - 0.4e1 * t133 * t1158 -
+                0.16e2 * t1140 * t1162 * t15 + 0.8e1 * t1166 * t35 * t312;
+        t1171 = t1161 * t184;
+        t1175 = t1122 * n;
+        t1176 = t15 * t1161;
+        t1180 = t1132 * ZA;
+        t1181 = t1180 * t355;
+        t1182 = t1176 * t1017;
+        t1185 = t1161 * xc;
+        t1189 = t1133 * t1;
+        t1192 = t108 * t1;
+        t1193 = t1132 * t1192;
+        t1195 = t10 * t35;
+        t1199 = t157 * t15;
+        t1203 = t1141 * t46;
+        t1211 = t184 * t108;
+        t1218 = 0.2e1 * t133 * t1171 * t35 + 0.8e1 * t1175 * t1176 * t997 + 0.64e2 * t1181 * t1182 -
+                0.8e1 * t1175 * t1185 * t127 - 0.32e2 * t1189 * t1182 - 0.64e2 * t1193 * ZA * t1195 * t228 +
+                0.8e1 * t1199 * t416 * t1128 + 0.8e1 * t1140 * t1203 - 0.4e1 * t75 * t1158 -
+                0.8e1 * t1199 * t560 * t1128 - 0.2e1 * t133 * t1211 - 0.8e1 * t1199 * t127 * t11 * t1128;
+        t1221 = t256 * t1161;
+        t1224 = t35 * t108;
+        t1233 = t7 * t256;
+        t1236 = -t75 * t1211 - t75 * t1221 - t133 * t1221 + t75 * t1224 - t75 * t1171 - t133 * t1171 +
+                t133 * t1224 + t75 * t1162 - t75 * t108 * t256 + t133 * t1162 - t1233 * t59 * t108;
+        t1240 = t1135 * t1195;
+        t1252 = t629 * t127;
+        t1263 = t1171 * ZA;
+        t1280 = -0.128e3 * t1180 * ZB * t108 * t1240 + 0.32e2 * t1193 * t10 * t112 + 0.4e1 * t133 * t1203 +
+                0.4e1 * t109 * t256 * ZA * ZB - 0.8e1 * t1252 * n * t15 * t1185 + 0.8e1 * t1175 * t1171 * t730 -
+                0.8e1 * t1175 * t1176 * t127 + 0.4e1 * t223 * t1263 - 0.8e1 * t1175 * t1176 * t730 +
+                0.8e1 * t1166 * ZA * t341 * ZB + 0.64e2 * t1134 * t1240 + 0.8e1 * t1122 * xc * t1128 * t127 * t15;
+        t1283 = t1199 * t19;
+        t1287 = t1199 * t127;
+        t1289 = t59 * n * t1161;
+        t1293 = t157 * n * xc;
+        t1304 = t1132 * t108;
+        t1310 = t263 * ZB;
+        t1316 = t2 * t15;
+        t1323 = -0.16e2 * t1283 * t1006 * t46 + 0.8e1 * t1287 * t1289 + 0.8e1 * t1293 * t127 * t1161 * t59 +
+                0.16e2 * t1123 * t1135 * t19 + 0.8e1 * t1293 * t560 * t1176 + 0.64e2 * t1304 * t59 * t1240 +
+                0.4e1 * t75 * t1203 + 0.4e1 * t1310 * t1263 + 0.4e1 * t223 * t338 * t108 -
+                0.16e2 * t1252 * t1316 * t1153 - 0.16e2 * t1310 * t221 * t15;
+        t1330 = t1132 * t15;
+        t1336 = t1132 * t1;
+        t1338 = t1162 * t179;
+        t1370 = 0.8e1 * t1175 * t1176 * t19 + 0.4e1 * t1139 * t318 * t1161 +
+                0.128e3 * t1330 * t318 * t108 * t46 * t227 - 0.32e2 * t1336 * xc * t1338 +
+                0.4e1 * t1233 * ZA * t1161 * ZB - 0.8e1 * t1287 * t59 * t1128 * xc + 0.2e1 * t75 * t305 * t108 +
+                0.8e1 * t1199 * t127 * t59 * t1128 - 0.8e1 * t1283 * t1289 - 0.8e1 * t1293 * t560 * t1171 +
+                0.4e1 * t133 * t35 * t1158 + 0.8e1 * t157 * t184 * t19 * t11 * t1128 * xc;
+        t1376 = t7 * t184;
+        t1380 = t1176 * t1195;
+        t1393 = t1330 * t35;
+        t1411 = 0.16e2 * t1145 * t1154 + 0.8e1 * t1149 * t998 + 0.4e1 * t1376 * t35 * t48 + 0.32e2 * t1189 * t1380 +
+                0.32e2 * t1193 * t11 * t1195 * t15 - 0.64e2 * t1304 * xc * t111 * t1135 - 0.16e2 * t1123 * t1146 +
+                0.64e2 * t1393 * t28 * t1192 * xc - 0.16e2 * t1123 * t1135 * t127 -
+                0.8e1 * t1122 * xc * t1128 * t127 - 0.32e2 * t1193 * xc * t112 + 0.16e2 * t1252 * t1316 * t46;
+        t1450 = 0.2e1 * t1376 * t767 * t1161 + 0.2e1 * t1376 * t111 * t108 + 0.4e1 * t223 * t311 * t108 +
+                0.4e1 * t109 * t35 * t520 * ZA + 0.16e2 * t1123 * t1135 * t997 - 0.64e2 * t1181 * t1380 +
+                0.8e1 * t1150 * t903 - 0.32e2 * t1393 * t11 * t1192 * xc - 0.16e2 * t157 * t2 * xc * t560 * t1124 +
+                0.8e1 * t223 * t184 * t317 * t46 + 0.32e2 * t1336 * t10 * t1338 - 0.4e1 * t75 * t1119;
+        _C3B = (t606 + t722 + t1089 + t781 + 0.16e2 * t48 * t51 + t978 + t868 + t507 - t304 * t256 +
+                0.8e1 * t9 * t22 + t752 + 0.4e1 * t174 * t144 - 0.2e1 * t81 * t469 + 0.6e1 * t139 * t166 + t362 +
+                0.2e1 * t98 * t211 + t925 + t137 - t290 * t184 + 0.12e2 * t81 * t83 + t842 + 0.8e1 * t74 * t77 +
+                0.16e2 * t98 * t12 * t162 - 0.4e1 * t33 * t28 * t443 - 0.8e1 * t27 * t70 - 0.2e1 * t33 * t34 * t36 -
+                0.8e1 * t27 * t30 + 0.2e1 * t58 * t67 - 0.4e1 * t40 * t43 + 0.2e1 * t58 * t63 + t1033 -
+                t290 * t256 + t290 * t35 + t193 + t1113 + t578 + t442 + t474 + t544 + t329 + t679 + t401 + t953 +
+                t811 + t644 + t894 + t289 + t240 + t1055 + t1003) /
+               (t1170 + t1218 + 0.2e1 * t1236 + t1280 + t1323 + t1370 + t1411 + t1450);
+        /****************************************************************************************/
+        t1 = n * n;
+        t2 = t1 * xc;
+        t3 = ZB * ZB;
+        t5 = t2 * 0.3141592654e1 * t3;
+        t6 = nx * 0.3141592654e1;
+        t7 = t6 * xc;
+        t8 = cos(t7);
+        t9 = nx * nx;
+        t10 = t8 * t9;
+        t11 = n * 0.3141592654e1;
+        t12 = exp(t11);
+        t13 = t12 * t12;
+        t16 = exp(xc * n * 0.3141592654e1);
+        t17 = t16 * t16;
+        t18 = t17 * t16;
+        t19 = t17 * t17;
+        t20 = t19 * t18;
+        t21 = t13 * t20;
+        t22 = t10 * t21;
+        t25 = ZA * ZA;
+        t26 = t1 * t25;
+        t27 = xc * 0.3141592654e1;
+        t28 = t26 * t27;
+        t29 = t19 * t16;
+        t30 = t13 * t13;
+        t31 = t29 * t30;
+        t35 = t9 * nx;
+        t36 = t3 * t35;
+        t37 = sin(t6);
+        t38 = t13 * t12;
+        t39 = t37 * t38;
+        t40 = t39 * t19;
+        t42 = t1 * t1;
+        t43 = nx * t42;
+        t44 = xc * xc;
+        t45 = t25 * t44;
+        t46 = t43 * t45;
+        t47 = 0.3141592654e1 * 0.3141592654e1;
+        t48 = t47 * t37;
+        t49 = t17 * t38;
+        t54 = 0.3141592654e1 * t35;
+        t55 = ZA * n * t54;
+        t56 = t37 * ZB;
+        t57 = t19 * t12;
+        t61 = t25 * t8;
+        t62 = t61 * t9;
+        t63 = n * t30;
+        t64 = t63 * t16;
+        t67 = t1 * n;
+        t69 = t47 * ZB;
+        t70 = t67 * t44 * t69;
+        t75 = nx * t3;
+        t76 = t75 * t37;
+        t77 = t67 * 0.3141592654e1;
+        t78 = t19 * t19;
+        t79 = t78 * t12;
+        t80 = t77 * t79;
+        t82 = t3 * t38;
+        t84 = t54 * t37;
+        t87 = sin(t7);
+        t88 = t29 * t87;
+        t89 = t47 * t44;
+        t93 = nx * t25;
+        t94 = t87 * t42;
+        t95 = t93 * t94;
+        t96 = t47 * xc;
+        t97 = t13 * t29;
+        t98 = t96 * t97;
+        t101 = t87 * t67;
+        t102 = t93 * t101;
+        t103 = t13 * t18;
+        t107 = t47 * t35;
+        t108 = t26 * t107;
+        t109 = t37 * t44;
+        t110 = t19 * t17;
+        t111 = t12 * t110;
+        t116 = t37 * t19 * t12;
+        t118 = t37 * xc;
+        t119 = ZB * t19;
+        t120 = t119 * t12;
+        t121 = t118 * t120;
+        t125 = xc * t3;
+        t126 = t1 * t47 * t125;
+        t127 = t35 * t37;
+        t128 = t38 * t19;
+        t129 = t127 * t128;
+        t132 = t26 * 0.3141592654e1;
+        t133 = t16 * t13;
+        t134 = t10 * t133;
+        t137 = 0.3141592654e1 * ZB;
+        t138 = t2 * t137;
+        t139 = ZA * t8;
+        t140 = t9 * t13;
+        t145 = t30 * t18;
+        t146 = t10 * t145;
+        t149 = t3 * t8;
+        t150 = t149 * t9;
+        t153 = 0.2e1 * t5 * t22 + 0.2e1 * t28 * t10 * t31 + t36 * t40 - 0.2e1 * t46 * t48 * t49 -
+               0.2e1 * t55 * t56 * t57 - 0.2e1 * t62 * t64 + 0.16e2 * t70 * t29 * ZA * t10 - t76 * t80 +
+               t82 * n * t84 + 0.8e1 * t43 * t3 * t88 * t89 + 0.16e2 * t95 * t98 + 0.2e1 * t102 * t27 * t103 -
+               0.2e1 * t108 * t109 * t111 + t36 * t116 + 0.8e1 * t55 * t121 - 0.4e1 * t126 * t129 -
+               0.4e1 * t132 * t134 - 0.4e1 * t138 * t139 * t140 * t20 + 0.8e1 * t28 * t146 - 0.2e1 * t150 * t64;
+        t154 = t42 * n;
+        t155 = nx * t154;
+        t156 = t44 * xc;
+        t157 = t47 * 0.3141592654e1;
+        t158 = t156 * t157;
+        t159 = t155 * t158;
+        t162 = t56 * ZA * t19 * t12;
+        t165 = t77 * t49;
+        t167 = t1 * t3;
+        t168 = t167 * t89;
+        t169 = t127 * t49;
+        t172 = t37 * t67;
+        t173 = t75 * t172;
+        t174 = t38 * t110;
+        t175 = t27 * t174;
+        t179 = t47 * t25;
+        t181 = t10 * t97;
+        t184 = t27 * t31;
+        t187 = t67 * t47;
+        t188 = t44 * t3;
+        t189 = t187 * t188;
+        t192 = t25 * t35;
+        t193 = t37 * t17;
+        t194 = t193 * t12;
+        t196 = nx * ZA;
+        t197 = t196 * t172;
+        t198 = ZB * t38;
+        t199 = t198 * t19;
+        t204 = t1 * t12 * t110;
+        t207 = nx * ZB;
+        t209 = t1 * ZA;
+        t215 = t67 * t3;
+        t216 = t47 * t8;
+        t217 = t215 * t216;
+        t218 = t9 * xc;
+        t222 = nx * t67;
+        t223 = t222 * t27;
+        t224 = t3 * t87;
+        t228 = t167 * t107;
+        t232 = t26 * t96;
+        t235 = t207 * t94;
+        t236 = t47 * ZA;
+        t243 = xc * t13;
+        t244 = t243 * t29;
+        t248 = t25 * n;
+        t249 = t248 * 0.3141592654e1;
+        t253 = ZB * ZA;
+        t254 = t253 * t8;
+        t255 = t9 * n;
+        t256 = t30 * t16;
+        t260 = 0.2e1 * t207 * t37 * t209 * t128 + 0.2e1 * t5 * t134 - 0.16e2 * t217 * t218 * t97 -
+               0.2e1 * t223 * t224 * t31 - 0.2e1 * t228 * t109 * t174 - 0.2e1 * t232 * t169 -
+               0.16e2 * t235 * t236 * t44 * t30 * t18 - 0.4e1 * t196 * t101 * t137 * t244 + t249 * t169 +
+               0.8e1 * t168 * t129 + 0.4e1 * t254 * t255 * t256;
+        t263 = t43 * t179;
+        t267 = t3 * n;
+        t268 = t267 * t54;
+        t269 = t118 * t57;
+        t272 = t39 * t1;
+        t274 = t67 * t25;
+        t275 = t274 * t158;
+        t278 = t75 * t87;
+        t279 = t77 * t103;
+        t282 = t25 * t38;
+        t285 = ZA * t38;
+        t290 = t267 * 0.3141592654e1;
+        t296 = t77 * t111;
+        t298 = t196 * t37;
+        t299 = t1 * ZB;
+        t303 = t37 * t42;
+        t304 = t196 * t303;
+        t308 = t77 * t57;
+        t310 = t26 * t89;
+        t313 = t77 * t128;
+        t316 = t101 * t27;
+        t319 = t93 * t87;
+        t320 = t77 * t97;
+        t323 = t127 * t57;
+        t326 = t10 * n;
+        t329 = t118 * t174;
+        t332 = -0.8e1 * t263 * t109 * t57 - 0.4e1 * t268 * t269 + t93 * t272 + 0.8e1 * t275 * t129 -
+               0.4e1 * t278 * t279 + t282 * n * t84 - 0.2e1 * t285 * n * t54 * t56 - t290 * t169 -
+               0.2e1 * t196 * t38 * t172 * t137 + t76 * t296 - 0.2e1 * t298 * t299 * t79 +
+               0.8e1 * t304 * t96 * t120 + t76 * t308 - 0.2e1 * t310 * t169 - t76 * t313 +
+               0.2e1 * t75 * t18 * t316 + 0.4e1 * t319 * t320 + t249 * t323 - 0.2e1 * t25 * t18 * t326 +
+               0.2e1 * t228 * t329;
+        t335 = t75 * t101;
+        t336 = t27 * t21;
+        t342 = t77 * t133;
+        t347 = t209 * t137;
+        t350 = t9 * t1;
+        t351 = t149 * t350;
+        t355 = t37 * t78 * t12;
+        t359 = t93 * t303;
+        t367 = t172 * 0.3141592654e1;
+        t369 = t96 * t103;
+        t376 = t209 * t107;
+        t379 = t10 * t103;
+        t383 = t207 * t101;
+        t389 = 0.3141592654e1 * ZA;
+        t390 = t222 * t389;
+        t391 = t87 * ZB;
+        t398 = -0.2e1 * t102 * t336 + t93 * t38 * t367 + 0.16e2 * t95 * t369 - t82 * t127 -
+               0.8e1 * t197 * t27 * t120 + 0.8e1 * t376 * t121 - 0.8e1 * t189 * t379 - t249 * t129 -
+               0.4e1 * t383 * t27 * ZA * t16 * t13 - 0.8e1 * t390 * t391 * t21 - 0.2e1 * t197 * t137 * t57;
+        t402 = t39 * t110;
+        t404 = t193 * t38;
+        t406 = t127 * t174;
+        t408 = t167 * 0.3141592654e1;
+        t411 = t44 * t157;
+        t412 = t155 * t411;
+        t413 = t285 * t19;
+        t414 = t56 * t413;
+        t417 = ZA * t30;
+        t424 = t93 * t37;
+        t426 = t248 * t54;
+        t427 = t17 * t12;
+        t428 = t118 * t427;
+        t431 = t77 * t21;
+        t438 = ZA * t13;
+        t443 = t93 * t172;
+        t444 = t27 * t427;
+        t448 = t1 * t78 * t12;
+        t455 = t274 * t89;
+        t461 = t118 * t111;
+        t464 = -t36 * t402 + t36 * t404 - t249 * t406 - 0.4e1 * t408 * t134 + 0.16e2 * t412 * t414 -
+               0.4e1 * t383 * t27 * t417 * t18 + 0.2e1 * t28 * t22 - t424 * t80 - 0.2e1 * t426 * t428 +
+               0.4e1 * t278 * t431 + 0.4e1 * t254 * t255 * t103 + t290 * t323 + 0.4e1 * t383 * t27 * t438 * t20 +
+               0.2e1 * t443 * t444 + t424 * t448 - t36 * t194 - 0.32e2 * t235 * t236 * t243 * t18 +
+               0.8e1 * t455 * t181 - 0.4e1 * t359 * t96 * t128 - 0.2e1 * t426 * t461;
+        t469 = n * t16 * t13;
+        t474 = t1 * t38;
+        t475 = t474 * t19;
+        t480 = t89 * t103;
+        t483 = t67 * ZA;
+        t484 = t483 * t411;
+        t485 = t127 * t120;
+        t488 = t127 * t111;
+        t497 = t77 * t427;
+        t502 = t27 * t97;
+        t508 = t1 * t19 * t12;
+        t511 = t155 * t25 * t156;
+        t512 = t157 * t37;
+        t513 = t512 * t128;
+        t527 = t1 * t17;
+        t528 = t527 * t38;
+        t530 = -t76 * t497 - 0.4e1 * t254 * t255 * t97 - 0.2e1 * t102 * t502 - 0.4e1 * t108 * t269 - t76 * t508 +
+               0.8e1 * t511 * t513 + 0.4e1 * t150 * t63 * t18 + 0.4e1 * t383 * t27 * t438 * t18 +
+               0.4e1 * t132 * t379 + 0.2e1 * t168 * t488 - t76 * t528;
+        t535 = t44 * t13;
+        t542 = t527 * t12;
+        t544 = n * t13;
+        t545 = t544 * t20;
+        t548 = t75 * t303;
+        t549 = t96 * t111;
+        t552 = ZA * t35;
+        t553 = t552 * t37;
+        t562 = t43 * t96;
+        t563 = t3 * t37;
+        t564 = t563 * t128;
+        t579 = t474 * t110;
+        t590 = t9 * t30;
+        t591 = t590 * t18;
+        t595 = t127 * t427;
+        t598 = t77 * t174;
+        t600 = 0.4e1 * t5 * t146 + 0.16e2 * t235 * t236 * t535 * t18 + 0.8e1 * t455 * t146 + t76 * t542 -
+               0.2e1 * t150 * t545 + 0.2e1 * t548 * t549 - 0.2e1 * t553 * t120 + t290 * t488 -
+               0.8e1 * t274 * t47 * t44 * t29 * t10 - 0.4e1 * t562 * t564 - 0.2e1 * t132 * xc * t20 * t10 -
+               0.32e2 * t562 * ZA * t87 * ZB * t13 * t29 - 0.8e1 * t347 * t379 + t76 * t579 -
+               0.4e1 * t359 * t96 * t57 + 0.4e1 * t408 * t181 - 0.4e1 * t223 * t564 -
+               0.12e2 * t209 * t27 * ZB * t8 * t591 + 0.2e1 * t310 * t595 + t76 * t598;
+        t601 = t27 * t49;
+        t604 = t127 * t79;
+        t606 = ZB * t29;
+        t616 = t139 * t140 * t18;
+        t638 = t10 * t256;
+        t643 = t118 * t199;
+        t653 = t544 * t29;
+        t658 = t3 * t29;
+        t660 = t350 * t27;
+        t663 = -0.4e1 * t254 * t255 * t145 + 0.2e1 * t267 * t20 * t8 * t9 - 0.4e1 * t138 * t139 * t9 * t16 * t13 -
+               0.2e1 * t5 * t638 + 0.2e1 * t126 * t169 + 0.8e1 * t376 * t643 + 0.4e1 * t335 * t27 * t145 +
+               0.16e2 * t235 * t236 * t535 * t29 + 0.6e1 * t150 * t653 - 0.4e1 * t426 * t269 +
+               0.4e1 * t658 * t8 * t660;
+        t670 = t274 * t411;
+        t673 = t118 * t49;
+        t694 = t155 * t45;
+        t713 = n * t29 * t30;
+        t717 = t20 * t87;
+        t723 = t512 * t57;
+        t728 = -0.2e1 * t443 * t175 - 0.8e1 * t670 * t129 + 0.2e1 * t426 * t673 -
+               0.16e2 * t207 * t88 * t42 * t47 * ZA * t44 + 0.4e1 * t254 * t255 * t21 + t249 * t595 +
+               0.8e1 * t25 * t29 * t8 * t660 + 0.2e1 * t268 * t461 + 0.8e1 * t189 * t181 - 0.8e1 * t694 * t513 +
+               0.2e1 * t198 * t553 - 0.12e2 * t606 * t139 * t660 - 0.2e1 * t359 * t549 +
+               0.4e1 * t138 * t139 * t590 * t16 + 0.8e1 * t93 * t29 * t94 * t89 - 0.2e1 * t150 * t713 +
+               0.2e1 * t222 * t3 * t717 * t27 + 0.8e1 * t670 * t323 + 0.8e1 * t694 * t723 - 0.2e1 * t62 * t653;
+        t734 = t43 * t89;
+        t735 = t563 * t427;
+        t740 = t75 * t94;
+        t744 = ZB * xc;
+        t750 = t563 * t57;
+        t754 = t218 * t103;
+        t771 = t127 * t199;
+        t776 = t89 * t174;
+        t791 = -0.4e1 * t207 * t717 * t77 * xc * ZA + 0.4e1 * t443 * t27 * t57 + t192 * t40 - 0.8e1 * t55 * t643 -
+               0.16e2 * t209 * t89 * t771 - 0.8e1 * t275 * t323 + 0.2e1 * t359 * t776 + 0.16e2 * t304 * t89 * t199 +
+               0.4e1 * t278 * t320 + 0.2e1 * t207 * t172 * t389 * t79 - 0.8e1 * t390 * t391 * t97;
+        t794 = t483 * t158;
+        t801 = t2 * 0.3141592654e1;
+        t818 = t215 * t411;
+        t827 = t96 * t174;
+        t837 = t37 * t12 * t110;
+        t845 = 0.16e2 * t794 * t485 + 0.8e1 * t159 * t564 - 0.8e1 * t455 * t379 - 0.2e1 * t801 * t3 * t20 * t10 -
+               0.4e1 * t132 * t22 - 0.8e1 * t734 * t564 - 0.8e1 * t187 * t44 * t658 * t10 - 0.8e1 * t412 * t564 +
+               0.4e1 * t132 * t181 - 0.8e1 * t818 * t129 + 0.2e1 * t46 * t48 * t427 - 0.4e1 * t75 * t29 * t316 -
+               0.2e1 * t359 * t827 - t290 * t595 + 0.16e2 * t217 * t754 - t424 * t542 - 0.8e1 * t734 * t750 -
+               t192 * t837 - 0.4e1 * t254 * t255 * t133 + 0.8e1 * t304 * t96 * t199;
+        t864 = t544 * t18;
+        t867 = t3 * t18;
+        t884 = t27 * t256;
+        t891 = t187 * t744;
+        t894 = t563 * t49;
+        t900 = -0.2e1 * t263 * t428 + 0.2e1 * t228 * t428 - 0.6e1 * t223 * t224 * t103 - t192 * t404 +
+               0.2e1 * t268 * t428 - 0.2e1 * t335 * t884 - t424 * t296 + 0.2e1 * t93 * t20 * t316 -
+               0.32e2 * t891 * t616 + 0.2e1 * t562 * t894 - 0.2e1 * t801 * t867 * t10;
+        t904 = t27 * t111;
+        t907 = t118 * t128;
+        t915 = t89 * t145;
+        t947 = t139 * t140 * t29;
+        t952 = -0.2e1 * t173 * t904 + 0.4e1 * t426 * t907 + 0.12e2 * t253 * t10 * t1 * 0.3141592654e1 * t244 +
+               0.8e1 * t95 * t915 - t36 * t355 - 0.16e2 * t794 * t771 - 0.8e1 * t511 * t723 + 0.16e2 * t734 * t162 +
+               t36 * t837 + 0.2e1 * t298 * t299 * t57 - 0.2e1 * t28 * t638 - 0.2e1 * t62 * t545 +
+               0.2e1 * t310 * t406 + 0.12e2 * t138 * t616 + 0.4e1 * t223 * t750 + t424 * t497 +
+               0.2e1 * t734 * t894 + 0.2e1 * t132 * xc * t18 * t10 - 0.16e2 * t70 * t947 + 0.32e2 * t891 * t947;
+        t969 = t67 * t157 * t156 * t3;
+        t974 = t27 * t133;
+        t1001 = -0.8e1 * t159 * t750 - 0.16e2 * t412 * t162 - t290 * t129 + 0.8e1 * t310 * t323 -
+                0.4e1 * t319 * t342 + t75 * t272 + t192 * t402 - 0.8e1 * t359 * t89 * t128 -
+                0.10e2 * t61 * t350 * t502 + 0.8e1 * t818 * t323 - 0.4e1 * t108 * t907;
+        t1042 = t89 * t97;
+        t1055 = -0.2e1 * t168 * t595 + 0.16e2 * t484 * t771 + 0.4e1 * t11 * t125 * t129 - 0.2e1 * t173 * t444 +
+                0.2e1 * ZB * n * t54 * t37 * ZA * t79 - t424 * t475 + 0.2e1 * t562 * t735 - 0.2e1 * t548 * t776 +
+                t424 * t204 + 0.2e1 * t25 * t20 * t326 + 0.8e1 * t383 * t389 * t133 + t75 * t38 * t367 +
+                0.2e1 * t62 * t469 + 0.2e1 * t197 * t137 * t128 - 0.2e1 * t102 * t884 - 0.2e1 * t5 * t379 -
+                0.8e1 * t740 * t1042 - 0.16e2 * t159 * t414 - 0.2e1 * ZB * t35 * t37 * t413 +
+                0.2e1 * t553 * ZB * t78 * t12;
+        t1096 = 0.2e1 * t443 * t904 - 0.2e1 * t268 * t329 - 0.2e1 * t443 * t601 + 0.2e1 * t102 * t974 -
+                0.2e1 * t263 * t673 + t424 * t165 + 0.2e1 * t62 * t713 + t424 * t308 - t424 * t313 +
+                0.8e1 * t347 * t22 - t424 * t598;
+        t1103 = t42 * t1 * t157;
+        t1104 = t1103 * t25;
+        t1108 = t3 * t19;
+        t1112 = n * t47;
+        t1113 = t9 * t9;
+        t1118 = t42 * t157;
+        t1119 = t1118 * t9;
+        t1120 = t25 * xc;
+        t1121 = t13 * t110;
+        t1122 = t1120 * t1121;
+        t1125 = t47 * t47;
+        t1126 = t67 * t1125;
+        t1127 = t1113 * ZA;
+        t1128 = t1126 * t1127;
+        t1129 = t19 * t13;
+        t1130 = t744 * t1129;
+        t1133 = t154 * t1125;
+        t1134 = t1133 * t9;
+        t1135 = t45 * t1129;
+        t1138 = t154 * t47;
+        t1139 = t25 * t30;
+        t1142 = t1126 * t1113;
+        t1145 = t125 * t1129;
+        t1148 = t1103 * xc;
+        t1149 = t3 * t13;
+        t1150 = t1149 * t17;
+        t1153 = t25 * t78;
+        t1156 = -0.8e1 * t1104 * t243 * t17 + 0.4e1 * t187 * t1108 * t9 - 0.2e1 * t1112 * t3 * t1113 * t30 +
+                0.16e2 * t1119 * t1122 + 0.64e2 * t1128 * t1130 + 0.64e2 * t1134 * t1135 - 0.2e1 * t1138 * t1139 +
+                0.32e2 * t1142 * t1135 - 0.32e2 * t1142 * t1145 + 0.8e1 * t1148 * t1150 - 0.2e1 * t1138 * t1153;
+        t1157 = t25 * t13;
+        t1158 = t1157 * t17;
+        t1161 = t13 * t17;
+        t1162 = t1120 * t1161;
+        t1165 = t3 * t78;
+        t1170 = t42 * t67 * t1125;
+        t1172 = t1108 * t13;
+        t1175 = t1 * t157;
+        t1176 = t1175 * t1113;
+        t1182 = t1120 * t1129;
+        t1189 = t110 * t9 * xc;
+        t1192 = t1149 * t110;
+        t1201 = 0.8e1 * t1103 * t1158 - 0.16e2 * t1119 * t1162 - 0.2e1 * t1112 * t1165 * t1113 +
+                0.32e2 * t1170 * t44 * t1172 - 0.8e1 * t1176 * t1162 + 0.8e1 * t1104 * t243 * t110 -
+                0.64e2 * t1134 * t1182 - 0.64e2 * t1134 * t1145 + 0.16e2 * t1118 * t3 * t1189 +
+                0.16e2 * t1119 * t1192 - 0.4e1 * t187 * t1165 * t9 - 0.4e1 * t187 * t1139 * t9;
+        t1209 = t17 * t30;
+        t1210 = t125 * t1209;
+        t1213 = t1138 * ZA;
+        t1214 = ZB * t30;
+        t1218 = t1157 * t110;
+        t1226 = t3 * t30;
+        t1237 = t1170 * t25;
+        t1242 = 0.4e1 * t1112 * ZA * t119 * t1113 - 0.16e2 * t1119 * t1150 - 0.8e1 * t1176 * t1210 +
+                0.4e1 * t1213 * t1214 * t19 - 0.16e2 * t1119 * t1218 - 0.32e2 * t1142 * t1182 -
+                0.8e1 * t1103 * t1120 * t110 - 0.4e1 * t187 * t1226 * t9 + 0.8e1 * t1103 * t1192 +
+                0.4e1 * t1112 * ZB * t1113 * t30 * ZA - 0.32e2 * t1237 * xc * t19 * t13;
+        t1251 = t125 * t1121;
+        t1260 = t1120 * t1209;
+        t1263 = t1139 * t19;
+        t1282 = 0.8e1 * t1103 * t110 * t3 * xc + 0.8e1 * t1104 * xc * t17 * t30 - 0.8e1 * t1176 * t1251 +
+                0.16e2 * t1119 * t1158 + 0.4e1 * t1112 * t78 * t1127 * ZB + 0.16e2 * t1119 * t1260 +
+                0.2e1 * t1138 * t1263 - 0.32e2 * t1170 * xc * t1172 - 0.16e2 * t1213 * t119 * t13 +
+                0.4e1 * t1138 * t1214 * ZA + 0.32e2 * t1237 * t44 * t19 * t13 - 0.16e2 * t1118 * t25 * t1189;
+        t1287 = t188 * t1129;
+        t1292 = t25 * t19;
+        t1296 = t187 * t9;
+        t1297 = t1226 * t19;
+        t1311 = t1112 * t1113;
+        t1317 = -0.8e1 * t1176 * t1150 + 0.32e2 * t1142 * t1287 - 0.8e1 * t1103 * t1150 +
+                0.2e1 * t1112 * t1292 * t1113 + 0.4e1 * t1296 * t1297 + 0.8e1 * t1176 * t1192 +
+                0.4e1 * t1296 * t1263 + 0.8e1 * t1176 * t1158 - 0.8e1 * t1175 * t25 * t1113 * xc * t110 +
+                0.2e1 * t1311 * t1297 + 0.2e1 * t1112 * t1108 * t1113;
+        t1320 = t253 * t1129;
+        t1328 = t253 * t30 * t19;
+        t1333 = t125 * t1161;
+        t1343 = ZB * t44 * t1129;
+        t1350 = -0.8e1 * t1176 * t1218 - 0.16e2 * t1311 * t1320 + 0.8e1 * t1176 * t1260 - 0.16e2 * t1119 * t1210 +
+                0.4e1 * t1311 * t1328 + 0.2e1 * t1311 * t1263 + 0.8e1 * t1176 * t1333 +
+                0.8e1 * t187 * ZB * t417 * t9 - 0.2e1 * t1138 * t1165 - 0.64e2 * t1128 * t1343 +
+                0.64e2 * t1134 * t1287 + 0.2e1 * t1138 * t1108;
+        t1369 = t1133 * t9 * ZA;
+        t1378 = t187 * ZA;
+        t1383 = t1170 * ZA;
+        t1388 = 0.2e1 * t1138 * t1297 - 0.8e1 * t1148 * t1192 + 0.2e1 * t1138 * t1292 - 0.16e2 * t1119 * t1251 +
+                0.8e1 * t1175 * xc * t110 * t1113 * t3 - 0.2e1 * t1112 * t1153 * t1113 + 0.128e3 * t1369 * t1130 +
+                0.16e2 * t1119 * t1333 + 0.4e1 * t1138 * t78 * ZA * ZB + 0.8e1 * t1378 * t78 * t9 * ZB -
+                0.64e2 * t1383 * t1343 + 0.64e2 * t1383 * t1130;
+        t1420 = 0.4e1 * t1138 * t119 * ZA - 0.128e3 * t1369 * t1343 - 0.4e1 * t187 * t1153 * t9 -
+                0.2e1 * t1138 * t1226 + 0.8e1 * t1296 * t1328 - 0.2e1 * t1112 * t1139 * t1113 -
+                0.8e1 * t1148 * t3 * t17 * t30 - 0.32e2 * t1296 * t1320 + 0.8e1 * t1176 * t1122 +
+                0.4e1 * t187 * t1292 * t9 + 0.8e1 * t1378 * t119 * t9 - 0.8e1 * t1103 * t1218;
+
+        _C4B = (-t424 * t508 + 0.8e1 * t412 * t750 - 0.2e1 * t232 * t595 - 0.4e1 * t126 * t323 + t1096 -
+                t76 * t204 + t728 + 0.2e1 * t548 * t827 + 0.2e1 * t150 * t469 + t398 + 0.8e1 * t189 * t146 + t260 -
+                0.2e1 * t351 * t184 - 0.2e1 * t268 * t673 - 0.4e1 * t319 * t279 + t464 - 0.2e1 * t108 * t461 +
+                0.16e2 * t740 * t369 + 0.16e2 * t274 * t216 * t754 - 0.16e2 * t70 * t139 * t591 +
+                0.2e1 * t55 * t56 * t128 - 0.2e1 * t359 * t89 * t111 + 0.2e1 * t734 * t563 * t111 +
+                0.6e1 * t223 * t224 * t97 + 0.8e1 * t383 * t389 * t103 + 0.4e1 * t606 * ZA * t326 -
+                0.2e1 * t93 * t18 * t316 - 0.4e1 * t443 * t27 * t128 + 0.8e1 * t197 * t27 * t199 +
+                0.8e1 * t108 * t109 * t128 - t249 * t604 + 0.16e2 * t70 * t616 - 0.8e1 * t969 * t323 + t845 -
+                t424 * t579 + 0.16e2 * t159 * t162 + t290 * t406 - 0.6e1 * t150 * t864 + t192 * t116 +
+                0.2e1 * t867 * t326 - 0.4e1 * t658 * t326 - 0.2e1 * t351 * t502 - t76 * t165 + t900 +
+                0.8e1 * t168 * t323 + t791 + 0.8e1 * t740 * t915 - 0.4e1 * t562 * t750 - 0.4e1 * t278 * t342 +
+                0.4e1 * t319 * t431 + 0.2e1 * t173 * t175 + t424 * t528 + 0.8e1 * t969 * t129 -
+                0.8e1 * t347 * t181 + t332 + t530 - 0.2e1 * t108 * t329 - 0.2e1 * t207 * t38 * t37 * t1 * ZA +
+                t1001 + 0.4e1 * t408 * t379 + t76 * t448 + 0.2e1 * t102 * t184 + 0.2e1 * t426 * t329 +
+                0.16e2 * t740 * t98 - t282 * t127 - 0.16e2 * t1 * t44 * t69 * t552 * t116 + 0.2e1 * t168 * t169 +
+                0.2e1 * t28 * t134 - t290 * t604 - 0.16e2 * t484 * t485 - 0.8e1 * t740 * t480 +
+                0.2e1 * t173 * t601 - 0.2e1 * t335 * t336 + t600 + 0.2e1 * t62 * t864 + t952 + 0.8e1 * t347 * t134 -
+                t192 * t355 + t192 * t194 + 0.2e1 * t228 * t461 + t663 + 0.4e1 * t383 * t27 * t417 * t16 +
+                0.4e1 * t138 * t20 * ZA * t10 - 0.4e1 * t20 * ZB * ZA * t326 + 0.4e1 * t196 * t88 * t77 * t744 -
+                0.16e2 * t67 * xc * t179 * t181 - 0.8e1 * t95 * t480 - t249 * t488 - t76 * t475 + t1055 -
+                0.4e1 * t408 * t22 - 0.10e2 * t28 * t379 + 0.2e1 * t335 * t974 + t153 - 0.8e1 * t95 * t1042 -
+                0.2e1 * t734 * t735) / (t1156 + t1201 + t1242 + t1282 + t1317 + t1350 + t1388 + t1420);
+        /****************************************************************************************/
+        /****************************************************************************************/
+
+        if (x > xc)
+          {
+            _C1 = _C1B;
+            _C2 = _C2B;
+            _C3 = _C3B;
+            _C4 = _C4B;
+            Z = ZB;
+          }
+        else
+          {
+            _C1 = _C1A;
+            _C2 = _C2A;
+            _C3 = _C3A;
+            _C4 = _C4A;
+            Z = ZA;
+          }
+        /****************************************************************************************/
+        /****************************************************************************************/
+        t1 = n * n;
+        t2 = t1 * t1;
+        t3 = t2 * n;
+        t4 = x * t3;
+        t5 = 0.3141592654e1 * 0.3141592654e1;
+        t6 = t5 * 0.3141592654e1;
+        t11 = _C3 * t6;
+        t12 = x * n;
+        t13 = nx * nx;
+        t14 = t13 * t13;
+        t15 = t12 * t14;
+        t19 = exp(t12 * 0.3141592654e1);
+        t20 = t19 * t19;
+        t21 = t4 * t20;
+        t24 = _C1 * t5;
+        t25 = Z * t20;
+        t29 = _C1 * t6;
+        t30 = t29 * Z;
+        t31 = t1 * n;
+        t32 = x * t31;
+        t33 = t32 * t13;
+        t36 = t11 * x;
+        t41 = n * t20;
+        t45 = t6 * _C4;
+        t49 = t20 * t1;
+        t51 = _C2 * Z;
+        t55 = -0.2e1 * t4 * t6 * _C2 * Z - 0.2e1 * t11 * t15 - 0.2e1 * t11 * t21 + 0.2e1 * t24 * t25 * t14 - t13 +
+              0.4e1 * t30 * t33 - 0.4e1 * t36 * t31 * t20 * t13 - 0.2e1 * t36 * t41 * t14 - 0.2e1 * t4 * t45 * t20 -
+              t49 - 0.2e1 * t4 * t6 * t51 * t20;
+        t58 = t32 * t6;
+        t59 = _C4 * t20;
+        t63 = t20 * t13;
+        t67 = t12 * t6;
+        t68 = t20 * t14;
+        t87 = t49 * t13;
+        t90 = -0.4e1 * t11 * t33 - 0.4e1 * t58 * t59 * t13 - 0.4e1 * t58 * t51 * t63 - 0.2e1 * t67 * t51 * t68 +
+              0.4e1 * t32 * t45 * t13 - 0.2e1 * t67 * t59 * t14 - 0.2e1 * t30 * t21 + t1 + 0.2e1 * t24 * t25 * t2 +
+              0.2e1 * t12 * t45 * t14 + 0.4e1 * t24 * Z * t87;
+        t106 = _C3 * t5;
+        t120 = -0.4e1 * t30 * t32 * t63 + t63 + 0.4e1 * t24 * Z * t1 * t13 + 0.2e1 * t29 * Z * x * t3 -
+               0.4e1 * t58 * t51 * t13 - 0.2e1 * t106 * t2 + t32 * 0.3141592654e1 - 0.2e1 * t106 * t14 -
+               0.2e1 * t30 * t12 * t68 - 0.2e1 * t67 * t51 * t14 + 0.4e1 * t106 * t87;
+        t129 = sin(nx * 0.3141592654e1 * x);
+        t155 = 0.2e1 * t30 * t15 + x * 0.3141592654e1 * t41 * t13 - 0.4e1 * t19 * nx * t129 * n +
+               t32 * 0.3141592654e1 * t20 + 0.2e1 * t106 * t68 + 0.2e1 * t106 * t20 * t2 - 0.4e1 * t106 * t1 * t13 -
+               0.2e1 * t11 * t4 + 0.2e1 * t4 * t45 + 0.2e1 * t24 * Z * t2 + 0.2e1 * t24 * Z * t14 +
+               t12 * 0.3141592654e1 * t13;
+        t158 = t5 * Z;
+
+        u1 = (t55 + t90 + t120 + t155) /
+             (0.4e1 * t158 * t19 * t2 + 0.8e1 * t158 * t19 * t1 * t13 + 0.4e1 * t158 * t19 * t14);
+        /****************************************************************************************/
+        /****************************************************************************************/
+        t1 = n * n;
+        t2 = t1 * n;
+        t3 = x * t2;
+        t4 = 0.3141592654e1 * 0.3141592654e1;
+        t5 = t4 * 0.3141592654e1;
+        t6 = t3 * t5;
+        t7 = _C2 * Z;
+        t8 = nx * nx;
+        t12 = t1 * t1;
+        t13 = t12 * n;
+        t14 = x * t13;
+        t15 = t5 * _C4;
+        t16 = x * n;
+        t18 = exp(t16 * 0.3141592654e1);
+        t19 = t18 * t18;
+        t23 = t16 * t5;
+        t24 = t8 * t8;
+        t28 = _C3 * t5;
+        t29 = t14 * t19;
+        t32 = _C1 * t5;
+        t33 = t32 * Z;
+        t34 = t16 * t24;
+        t37 = _C4 * t19;
+        t45 = _C2 * t4;
+        t53 = t19 * t8;
+        t58 = _C4 * t4;
+        t60 = t1 * t19 * t8;
+        t63 = t19 * t24;
+        t67 = t3 * t8;
+        t73 = n * t19;
+        t86 = t28 * x;
+        t91 = 0.4e1 * t58 * t60 + 0.2e1 * t33 * t16 * t63 + 0.4e1 * t33 * t67 + 0.2e1 * t33 * t29 -
+              x * 0.3141592654e1 * t73 * t8 - 0.2e1 * t53 + 0.2e1 * t32 * Z * x * t13 - 0.2e1 * t58 * t12 -
+              0.2e1 * t58 * t24 + t3 * 0.3141592654e1 + 0.4e1 * t86 * t2 * t19 * t8;
+        t94 = Z * t12;
+        t121 = -0.2e1 * t8 + 0.2e1 * t45 * t94 * t19 + 0.2e1 * t14 * t5 * t7 * t19 + 0.4e1 * t6 * t7 * t53 +
+               0.2e1 * t23 * t7 * t63 - 0.4e1 * t28 * t67 + 0.2e1 * t45 * t94 + 0.2e1 * t58 * t12 * t19 +
+               t16 * 0.3141592654e1 * t8 + 0.2e1 * t14 * t15 - 0.2e1 * t28 * t14;
+        t146 = cos(nx * 0.3141592654e1 * x);
+        t156 = -t3 * 0.3141592654e1 * t19 + 0.2e1 * t58 * t63 - 0.4e1 * t58 * t1 * t8 + 0.4e1 * t45 * Z * t1 * t8 -
+               0.2e1 * t28 * t34 + 0.2e1 * t86 * t73 * t24 + 0.4e1 * t3 * t15 * t8 + 0.4e1 * t45 * Z * t60 +
+               0.4e1 * t18 * t146 * t8 + 0.2e1 * t45 * Z * t24 + 0.2e1 * t16 * t15 * t24;
+        t159 = t4 * Z;
+
+        u2 = (-0.4e1 * t6 * t7 * t8 + 0.2e1 * t14 * t15 * t19 - 0.2e1 * t23 * t7 * t24 + 0.2e1 * t28 * t29 +
+              0.2e1 * t33 * t34 + 0.4e1 * t6 * t37 * t8 - 0.2e1 * t14 * t5 * _C2 * Z + 0.2e1 * t45 * Z * t19 * t24 +
+              0.2e1 * t23 * t37 * t24 + 0.4e1 * t33 * t3 * t53 + t91 + t121 + t156) /
+             (0.4e1 * t159 * t18 * t12 + 0.8e1 * t159 * t18 * t1 * t8 + 0.4e1 * t159 * t18 * t24);
+        /****************************************************************************************/
+        /****************************************************************************************/
+        t1 = 0.3141592654e1 * 0.3141592654e1;
+        t2 = t1 * 0.3141592654e1;
+        t3 = _C1 * t2;
+        t4 = t3 * Z;
+        t5 = n * n;
+        t6 = t5 * t5;
+        t7 = t6 * n;
+        t8 = x * t7;
+        t9 = x * n;
+        t11 = exp(t9 * 0.3141592654e1);
+        t12 = t11 * t11;
+        t13 = t8 * t12;
+        t16 = t5 * n;
+        t17 = x * t16;
+        t18 = t17 * t2;
+        t19 = _C4 * t12;
+        t20 = nx * nx;
+        t24 = t2 * _C4;
+        t28 = _C3 * t2;
+        t29 = t28 * x;
+        t30 = t12 * n;
+        t31 = t20 * t20;
+        t40 = _C2 * Z;
+        t44 = t9 * t2;
+        t48 = t12 * t20;
+        t52 = t17 * t20;
+        t57 = -0.2e1 * t4 * t13 - 0.4e1 * t18 * t19 * t20 - 0.2e1 * t8 * t24 * t12 - 0.2e1 * t29 * t30 * t31 +
+              0.2e1 * t8 * t2 * _C2 * Z - 0.2e1 * t8 * t2 * t40 * t12 - 0.2e1 * t44 * t19 * t31 -
+              0.4e1 * t18 * t40 * t48 + t20 + 0.4e1 * t28 * t52 + t17 * 0.3141592654e1 * t12;
+        t58 = t9 * t31;
+        t61 = _C3 * t1;
+        t62 = t12 * t31;
+        t73 = t5 * t20;
+        t78 = _C1 * t1;
+        t90 = Z * t12;
+        t94 = 0.2e1 * t28 * t58 + 0.2e1 * t61 * t62 + 0.2e1 * t61 * t12 * t6 - 0.4e1 * t4 * t17 * t48 +
+              0.2e1 * t28 * t8 + 0.4e1 * t61 * t73 - 0.2e1 * t8 * t24 - 0.2e1 * t78 * Z * t6 -
+              0.2e1 * t44 * t40 * t62 - 0.2e1 * t78 * Z * t31 - t9 * 0.3141592654e1 * t20 + 0.2e1 * t78 * t90 * t6;
+        t101 = cos(nx * 0.3141592654e1 * x);
+        t102 = t11 * t101;
+        t109 = t12 * t5;
+        t110 = t109 * t20;
+        t128 = 0.2e1 * t61 * t6 - t17 * 0.3141592654e1 + 0.2e1 * t102 * t5 - 0.4e1 * t17 * t24 * t20 +
+               0.4e1 * t78 * Z * t110 - 0.2e1 * t9 * t24 * t31 - 0.4e1 * t4 * t52 - 0.2e1 * t4 * t9 * t62 +
+               x * 0.3141592654e1 * t30 * t20 - t5 - 0.4e1 * t78 * Z * t5 * t20;
+        t156 = 0.2e1 * t78 * t90 * t31 - 0.2e1 * t3 * Z * x * t7 + t48 + 0.4e1 * t61 * t110 +
+               0.4e1 * t18 * t40 * t20 - 0.2e1 * t102 * t20 + 0.2e1 * t61 * t31 + 0.2e1 * t44 * t40 * t31 - t109 -
+               0.2e1 * t4 * t58 - 0.2e1 * t28 * t13 - 0.4e1 * t29 * t16 * t12 * t20;
+        t159 = t1 * t11;
+
+        u3 = (t57 + t94 + t128 + t156) / (0.4e1 * t159 * t6 + 0.8e1 * t159 * t73 + 0.4e1 * t159 * t31);
+        /****************************************************************************************/
+        /****************************************************************************************/
+        t1 = _C2 * Z;
+        t2 = 0.3141592654e1 * 0.3141592654e1;
+        t3 = t2 * 0.3141592654e1;
+        t4 = n * n;
+        t5 = t4 * t4;
+        t6 = t5 * t4;
+        t8 = t3 * t6 * x;
+        t11 = x * t4;
+        t12 = t11 * t3;
+        t15 = exp(x * n * 0.3141592654e1);
+        t16 = t15 * t15;
+        t17 = _C3 * t16;
+        t18 = nx * nx;
+        t19 = t18 * t18;
+        t23 = t5 * n;
+        t24 = t2 * t23;
+        t28 = t1 * t3;
+        t29 = t6 * x;
+        t30 = t29 * t16;
+        t33 = _C4 * t3;
+        t34 = t5 * x;
+        t35 = t34 * t18;
+        t41 = sin(nx * 0.3141592654e1 * x);
+        t47 = t11 * t19;
+        t54 = t3 * _C3;
+        t57 = 0.2e1 * t1 * t8 + 0.2e1 * t12 * t17 * t19 + 0.2e1 * t1 * t24 * t16 + 0.2e1 * t28 * t30 -
+              0.4e1 * t33 * t35 + 0.2e1 * t15 * nx * t41 * t4 + 0.4e1 * t28 * t35 - 0.2e1 * t33 * t47 -
+              0.2e1 * t1 * t24 - 0.2e1 * t33 * t29 + 0.2e1 * t29 * t54;
+        t58 = 0.3141592654e1 * t16;
+        t60 = t2 * _C4;
+        t69 = t4 * n;
+        t73 = t1 * t2;
+        t75 = t69 * t16 * t18;
+        t79 = x * t16;
+        t83 = n * t16;
+        t84 = t83 * t19;
+        t95 = -t34 * t58 + 0.2e1 * t60 * t23 * t16 + 0.2e1 * t60 * n * t19 - t11 * 0.3141592654e1 * t18 +
+              0.4e1 * t60 * t69 * t18 + 0.4e1 * t73 * t75 + 0.4e1 * t33 * t5 * t79 * t18 + 0.2e1 * t73 * t84 +
+              0.2e1 * t60 * t84 + 0.2e1 * t33 * t4 * t79 * t19 + 0.4e1 * t60 * t75;
+        t97 = t34 * t3;
+        t101 = Z * _C1;
+        t102 = t16 * t19;
+        t106 = t16 * t18;
+        t127 = t2 * t69;
+        t131 = t2 * n;
+        t135 = 0.4e1 * t97 * t17 * t18 + 0.2e1 * t12 * t101 * t102 + 0.4e1 * t28 * t34 * t106 +
+               0.2e1 * t28 * t11 * t102 - 0.2e1 * t29 * t3 * Z * _C1 - 0.4e1 * t97 * t101 * t18 -
+               0.2e1 * t12 * t101 * t19 + 0.2e1 * t60 * t23 - 0.2e1 * t83 * t18 - 0.4e1 * t1 * t127 * t18 -
+               0.2e1 * t1 * t131 * t19;
+        t164 = 0.2e1 * t28 * t47 + 0.2e1 * t11 * t54 * t19 + 0.2e1 * t8 * t101 * t16 + 0.2e1 * t33 * t30 -
+               t11 * t58 * t18 + 0.2e1 * t29 * t54 * t16 + 0.4e1 * t34 * t54 * t18 + 0.4e1 * t97 * t101 * t106 -
+               0.2e1 * t15 * t18 * nx * t41 - t34 * 0.3141592654e1 + 0.2e1 * n * t18;
+
+        u4 = (t57 + t95 + t135 + t164) / (0.4e1 * t24 * t15 + 0.8e1 * t127 * t15 * t18 + 0.4e1 * t131 * t15 * t19);
+
+
+        /****************************************************************************************/
+        /****************************************************************************************/
+
+
+        u5 = (double) (-2 * Z * n * PI * u2 - u3 * 2 * n * PI) * cos(n * PI * z); /* pressure */
+
+        u6 = (double) (u3 * 2 * n * PI + 4 * Z * n * PI * u2) * cos(n * PI * z); /* zz stress */
+        sum5 += u5;
+        sum6 += u6;
+
+        u1 *= cos(n * PI * z); /* x velocity */
+        sum1 += u1;
+        u2 *= sin(n * PI * z); /* z velocity */
+        sum2 += u2;
+        u3 *= 2 * n * PI * cos(n * PI * z); /* xx stress */
+        sum3 += u3;
+        u4 *= 2 * n * PI * sin(n * PI * z); /* zx stress */
+        sum4 += u4;
+
+        /*printf("%0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f\n",x,z,sum1,sum2,sum3,sum4,sum5,sum6);*/
+
+        /* Output */
+        if (vel != nullptr)
+          {
+            vel[0] = sum1;
+            vel[1] = sum2;
+          }
+        if (presssure != nullptr)
+          {
+            (*presssure) = sum5;
+          }
+        if (total_stress != nullptr)
+          {
+            total_stress[0] = sum3;
+            total_stress[1] = sum6;
+            total_stress[2] = sum4;
+          }
+        if (strain_rate != nullptr)
+          {
+            if (x > xc)
+              {
+                Z = ZB;
+              }
+            else
+              {
+                Z = ZA;
+              }
+            strain_rate[0] = (sum3 + sum5) / (2.0 * Z);
+            strain_rate[1] = (sum6 + sum5) / (2.0 * Z);
+            strain_rate[2] = (sum4) / (2.0 * Z);
+          }
+        /* Value checks, could be cleaned up if needed. Julian Giordani 2-Oct-2006*/
+        if (fabs(sum5 - (-0.5 * (sum6 + sum3))) > 1e-5)
+          {
+            assert(0);
+          }
+      }
+
+
+
+      /**
+       * The exact solution for the SolCx benchmark, given the value of the
+       * jump in viscosity $\eta_B$.
+       */
+      template <int dim>
+      class FunctionSolCx : public Function<dim>
+      {
+        public:
+          FunctionSolCx(const double eta_B,
+                        const double background_density,
+                        const unsigned int n_compositional_fields)
+            :
+            Function<dim>(dim+2+n_compositional_fields),
+            eta_B_(eta_B),
+            background_density(background_density),
+            n_compositional_fields(n_compositional_fields) {}
+
+
+          void vector_value(const Point<dim> &p,
+                            Vector<double> &values) const override
+          {
+            AssertDimension(values.size(), 4 + n_compositional_fields);
+
+            double pos[2] = {p(0), p(1)};
+            double total_stress[3], strain_rate[3];
+            double eta_A = 1.0;
+            double eta_B = eta_B_;
+
+            // call the analytic function for the solution with a zero
+            // background density
+            AnalyticSolutions::_Velic_solCx
+            (pos,
+             eta_A, eta_B,
+             0.5, 1,
+             &values[0], &values[2], total_stress, strain_rate);
+
+            // then add the background pressure to the value we just got
+            values[2] += (0.5 - p[1]) * background_density;
+          }
+
+        private:
+          double eta_B_, background_density;
+          unsigned int n_compositional_fields;
+      };
+    }
+
+
+
+    /**
+     * A material model that describes the <i>SolCx</i> benchmark of the paper
+     * cited in the documentation of the DuretzEtAl namespace.
+     *
+     * @note The SolCx benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @note The analytic solution of this benchmark is implemented in the
+     * "SolCx error" postprocessor in aspect::Postprocessor::DuretzEtAl::SolCx
+     * class and can be used to assess the accuracy of the computed solution.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class SolCxMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+
+              const Point<dim> &pos = in.position[i];
+              out.viscosities[i] = (pos[0] < 0.5 ? 1 : eta_B);
+              out.densities[i] =  background_density-std::sin(numbers::PI*pos[1])*std::cos(numbers::PI*pos[0]);
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+
+            }
+        }
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override
+        {
+          return false;
+        }
+        /**
+         * @}
+         */
+
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm)
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("SolCx");
+            {
+              prm.declare_entry ("Viscosity jump", "1e6",
+                                 Patterns::Double (0.),
+                                 "Viscosity in the right half of the domain.");
+              prm.declare_entry ("Background density", "0.",
+                                 Patterns::Double (0.),
+                                 "Density value upon which the variation of this testcase "
+                                 "is overlaid. Since this background density is constant "
+                                 "it does not affect the flow pattern but it adds to the "
+                                 "total pressure since it produces a nonzero adiabatic "
+                                 "pressure if set to a nonzero value.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("SolCx");
+            {
+              eta_B = prm.get_double ("Viscosity jump");
+              background_density = prm.get_double("Background density");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          // Declare dependencies on solution variables
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+
+        /**
+         * Returns the viscosity value on the right half of the domain,
+         * typically 1 or 1e6
+         */
+        double get_eta_B() const
+        {
+          return  eta_B;
+        }
+
+        /**
+         * Returns the background density of this model. See the
+         * corresponding member variable of this class for more information.
+         */
+        double get_background_density() const
+        {
+          return background_density;
+        }
+
+      private:
+        /**
+         * Viscosity value on the right half of the domain, typically 1 or
+         * 1e6
+         */
+        double eta_B;
+
+        /**
+         * A constant background density over which the density variations
+         * are overlaid. This constant density has no effect on the dynamic
+         * pressure and consequently on the flow field, but it contributes
+         * to the total pressure via the adiabatic pressure. We use this
+         * field to support our claim in the first ASPECT paper that the
+         * accuracy of the solutions is guaranteed even if we don't subtract
+         * the adiabatic pressure in our computations.
+         */
+        double background_density;
+    };
+
+
+
+
+    /**
+     * A postprocessor that evaluates the accuracy of the solution.
+     *
+     * The implementation of error evaluators that correspond to the
+     * benchmarks defined in the paper Duretz et al. reference above.
+     */
+    template <int dim>
+    class SolCxPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &/*statistics*/) override
+        {
+
+          AssertThrow(Plugins::plugin_type_matches<const SolCxMaterial<dim>>(this->get_material_model()),
+                      ExcMessage("Postprocessor DuretzEtAl only works with the material model SolCx, SolKz, and Inclusion."));
+
+          const SolCxMaterial<dim> &
+          material_model
+            = Plugins::get_plugin_as_type<const SolCxMaterial<dim>>(this->get_material_model());
+
+          std::unique_ptr<Function<dim>> ref_func
+            = std::make_unique<AnalyticSolutions::FunctionSolCx<dim>>(material_model.get_eta_B(),
+                                                                       material_model.get_background_density(),
+                                                                       this->n_compositional_fields());
+
+          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities + 2);
+
+          Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                              this->get_fe().n_components());
+          ComponentSelectFunction<dim> comp_p(dim,
+                                              this->get_fe().n_components());
+
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_u,
+                                             quadrature_formula,
+                                             VectorTools::L1_norm,
+                                             &comp_u);
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_p,
+                                             quadrature_formula,
+                                             VectorTools::L1_norm,
+                                             &comp_p);
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_ul2,
+                                             quadrature_formula,
+                                             VectorTools::L2_norm,
+                                             &comp_u);
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_pl2,
+                                             quadrature_formula,
+                                             VectorTools::L2_norm,
+                                             &comp_p);
+
+          const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+          const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+          std::ostringstream os;
+          os << std::scientific << u_l1
+             << ", " << p_l1
+             << ", " << u_l2
+             << ", " << p_l2;
+
+          return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
+        }
+    };
+
+  }
+}
+#endif
diff --git a/benchmarks/solcx/solcx.prm.bak b/benchmarks/solcx/solcx.prm.bak
new file mode 100644
index 00000000000..b21e251c484
--- /dev/null
+++ b/benchmarks/solcx/solcx.prm.bak
@@ -0,0 +1,66 @@
+# A description of the SolCX benchmark for which a known solution
+# is available. See the manual for more information.
+
+set Additional shared libraries            = ./libsolcx.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+
+  subsection SolCx
+    set Viscosity jump = 1e6
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor, visualization
+end
diff --git a/benchmarks/solitary_wave/doc/solitary_wave.prm.bak b/benchmarks/solitary_wave/doc/solitary_wave.prm.bak
new file mode 100644
index 00000000000..faf3e731475
--- /dev/null
+++ b/benchmarks/solitary_wave/doc/solitary_wave.prm.bak
@@ -0,0 +1,103 @@
+# Listing of Parameters
+# ---------------------
+# Set up the solitary wave benchmark
+# (Barcilon & Richter, 1986; Simpson & Spiegelman, 2011;
+# Keller et al., 2013; Schmeling, 200
+
+set Additional shared libraries            = ./libsolitary_wave.so
+
+# A non-linear solver has to be used for models with melt migration
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+set Nonlinear solver tolerance             = 1e-5
+
+# The end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 6e6
+
+# To model melt migration, there has to be a compositional field with
+# the name 'porosity'.
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+# Enable modeling of melt migration in addition to the advection of
+# solid material.
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+######### Parameters for the porosity field ########################
+
+# We use the initial conditions and material model from the
+# solitary wave plugin and choose a wave with an amplitude of
+# 0.01 and a background porosity of 0.001.
+subsection Initial composition model
+  set Model name = Solitary wave initial condition
+
+  subsection Solitary wave initial condition
+    set Offset = 200
+    set Read solution from file = true
+    set Amplitude = 0.01
+    set Background porosity = 0.001
+  end
+end
+
+subsection Material model
+  set Model name = Solitary Wave
+end
+
+# As material is flowing in, we prescribe the porosity at the
+# upper and lower boundary.
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+# As we know that our solution does not have any steep gradients
+# we can use a low stabilization to avoid too much diffusion.
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.001
+  end
+end
+
+######### Model geometry ##############################################
+
+# Our domain is a pseudo-1D-profile 400 m in height, but only a few elements wide
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 10
+    set Y extent  = 400
+    set Y repetitions = 40
+  end
+end
+
+######### Velocity boundary conditions ################################
+
+# We apply the phase speed of the wave here, so that it always stays in the
+# same place in our model. The phase speed is c = 5.25e-11 m/s, but we have
+# to convert it to m/years using the same conversion that is used internally
+# in ASPECT: year_in_seconds = 60*60*24*365.2425.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+
+  subsection Function
+    set Function expression = 0;-1.65673998e-4
+  end
+end
+
+# Postprocessor for the error calculation
+subsection Postprocess
+  set List of postprocessors = solitary wave statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-10
+  end
+end
diff --git a/benchmarks/solitary_wave/solitary_wave.cc.bak b/benchmarks/solitary_wave/solitary_wave.cc.bak
new file mode 100644
index 00000000000..715f6dd3301
--- /dev/null
+++ b/benchmarks/solitary_wave/solitary_wave.cc.bak
@@ -0,0 +1,1025 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/melt.h>
+#include <aspect/initial_composition/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+/**
+ * MPI operator used by MPI_max_and_data
+ */
+void myop_func(void *invec,
+               void *inoutvec,
+               int *len,
+               MPI_Datatype *datatype)
+{
+  AssertThrow(*len > 1, dealii::ExcNotImplemented());
+  AssertThrow(*datatype == MPI_DOUBLE, dealii::ExcNotImplemented());
+
+  double *indata = static_cast<double *>(invec);
+  double *inoutdata = static_cast<double *>(inoutvec);
+
+  if (indata[0]>inoutdata[0])
+    {
+      for (int i=0; i<*len; ++i)
+        inoutdata[i] = indata[i];
+    }
+}
+
+
+/**
+ * Computes MPI_MAX of @p local_max like Allreduce, but also transmits the
+ * @p local_data from the rank with the largest @local_max to every rank
+ * (returned in @p global_data).
+ */
+void MPI_max_and_data(const double &local_max,
+                      const double &local_data,
+                      double &global_max,
+                      double &global_data)
+{
+  MPI_Op myop;
+  MPI_Op_create(&myop_func, /* commutes? */ 1 ,&myop);
+
+  double local[] = {local_max, local_data};
+  double global[2];
+
+  MPI_Allreduce(local, global, 2, MPI_DOUBLE, myop, MPI_COMM_WORLD);
+  global_max = global[0];
+  global_data = global[1];
+  MPI_Op_free(&myop);
+}
+
+
+namespace aspect
+{
+  /**
+   * This is the "Solitary wave" benchmark defined in the following paper:
+   * @code
+   *  @Article{DMGT11,
+   *    author =       {T. Keller and D. A. May and B. J. P. Kaus},
+   *    title =        {Numerical modelling of magma dynamics coupled
+   *                    to tectonic deformation of lithosphere and crust},
+   *    journal =      {Geophysical Journal International},
+   *    year =         2013,
+   *    volume =       195(3),
+   *    pages =        {1406-1442}
+   * @endcode
+   *
+   * To calculate the initial condition, which is a solitary wave solution of
+   * the magma dynamics equations, we use the equation for the one-dinemsional
+   * case and the non-dimensionalization as it is described in
+   * @code
+   *  @Article{SS11,
+   *    author =       {G. Simpson and M. Spiegelman},
+   *    title =        {Solitary Wave Benchmarks in Magma Dynamics},
+   *    journal =      {Journal of Scientific Computing},
+   *    year =         2011,
+   *    volume =       49(3),
+   *    pages =        {268-290}
+   * @endcode
+   *
+   * Specifically, this means that we scale the porosity with the background
+   * porosity, and the coordinates with the compaction length $\delta_0$, which is
+   * defined as $\sqrt \frac{k(\phi_0) \xi^{*}+4/3 \eta^{*}}{\eta_f}$.  $k(\phi_0)$ is the
+   * permeability at background porosity, $\xi^{*}$ is the compaction viscosity,
+   * $\eta^{*}$ is the shear viscosity of the fluid and $\eta_f$ is the shear viscosity
+   * of the melt.
+   */
+  namespace SolitaryWaveBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+      // vectors to store the porosity field and the corresponding coordinate in
+      const unsigned int max_points = 2e8;
+      std::vector<double> porosity, coordinate;
+
+      /**
+       * @note The solitary wave solution only exists as a function x = func(phi)
+       * and not phi = func(x), which is what we would like to have for describing
+       * the shape of the wave. Thus, we calculate x = func(phi) for a range of phis
+       * between the background porosity and the amplitude of the wave. In a next
+       * step, we interpolate these values to the grid.
+       *
+       * @param phi The characteristic shape of the wave, with phi --> 1
+       * for x --> +- infinity
+       *
+       * @param amplitude The amplitude of the solitary wave, which is always
+       * greater than 1.
+       */
+      double solitary_wave_solution (const double phi, const double amplitude)
+      {
+        AssertThrow(phi > 1.0 && phi <= amplitude,
+                    ExcMessage("The solitary wave solution can only be computed "
+                               "for porosities larger than the background porosity of 1 "
+                               "and smaller than or equal to the amplitude of the wave."));
+        AssertThrow(amplitude > 1,
+                    ExcMessage("Amplitude of the solitary wave must be larger than 1!"));
+        const double A_1   = std::sqrt(amplitude - 1.0);
+        const double A_phi = std::sqrt(amplitude - phi);
+        return std::sqrt(amplitude + 0.5)
+               * (2 * A_phi - 1.0/A_1 * std::log((A_1 - A_phi)/(A_1 + A_phi)));
+      }
+
+
+      /**
+       * This function reads the coordinate and the porosity of the solitary wave
+       * from an input file.
+       *
+       * @param filename Name of the input file.
+       */
+      void read_solitary_wave_solution (const std::string &filename,
+                                        const MPI_Comm comm)
+      {
+        std::string temp;
+        std::stringstream in(Utilities::read_and_distribute_file_content(filename, comm));
+
+        while (!in.eof())
+          {
+            double x, f;
+            in >> x >> f;
+            if (in.eof())
+              break;
+            getline(in, temp);
+
+            coordinate.insert(coordinate.begin(),x);
+            porosity.insert(porosity.begin(),f);
+          }
+      }
+
+
+      /**
+       * This function gets the coordinate as an input parameters and gives
+       * back the porosity of the solitary wave. As this function is only defined
+       * implicitly, we have to interpolate from the coordinates where we have the
+       * porosity to our mesh.
+       *
+       * @param amplitude The amplitude of the solitary wave, which is always
+       * greater than 1.
+       * @param offset The offset of the center of the solitary wave from the
+       * boundary of the domain.
+       */
+      void compute_porosity (const double amplitude,
+                             const double background_porosity,
+                             const double /*offset*/,
+                             const double compaction_length,
+                             const bool read_solution,
+                             const std::string file_name,
+                             const MPI_Comm comm)
+      {
+        // non-dimensionalize the amplitude
+        const double non_dim_amplitude = amplitude / background_porosity;
+
+        if (read_solution)
+          read_solitary_wave_solution(file_name, comm);
+        else
+          {
+            porosity.resize(max_points);
+            coordinate.resize(max_points);
+
+            // get the coordinates where we have the solution
+            for (unsigned int i=0; i<max_points; ++i)
+              {
+                porosity[i] = 1.0 + 1e-10*non_dim_amplitude
+                              + double(i)/double(max_points-1) * (non_dim_amplitude * (1.0 - 1e-10) - 1.0);
+                coordinate[i] = solitary_wave_solution(porosity[i], non_dim_amplitude);
+              }
+          }
+
+        for (unsigned int i=0; i<coordinate.size(); ++i)
+          {
+            // re-scale porosity and position
+            porosity[i] *= background_porosity;
+            coordinate[i] *= compaction_length;
+          }
+      }
+
+
+      double interpolate (const double position,
+                          const double offset)
+      {
+        // interpolate from the solution grid to the mesh used in the simulation
+        // solitary wave is a monotonically decreasing function, so the coordinates
+        // should be in descending order
+
+        // we only have the solution of the solitary wave for
+        // coordinates larger than 0 (one half of the wave)
+        const double x = (position > offset
+                          ?
+                          position - offset
+                          :
+                          offset - position);
+
+        if (x > coordinate[0])
+          return porosity[0];
+
+        unsigned int j= coordinate.size()-2;
+        unsigned int i = j/2;
+        while (!(x < coordinate[j] && x >= coordinate[j+1]))
+          {
+            if (x < coordinate[j])
+              j += i;
+            else
+              j -= i;
+            if (i>1)
+              i /= 2;
+          }
+
+        const double distance = (x - coordinate[j+1])
+                                /(coordinate[j] - coordinate[j+1]);
+        return porosity[j+1] + distance * (porosity[j] - porosity[j+1]);
+      }
+
+      /**
+       * The exact solution for the Solitary wave benchmark.
+       */
+      template <int dim>
+      class FunctionSolitaryWave : public Function<dim>
+      {
+        public:
+          FunctionSolitaryWave (const double offset, const double delta, const std::vector<double> &initial_pressure, const double max_z, const unsigned int n_components)
+            :
+            Function<dim>(n_components),
+            offset_(offset),
+            delta_(delta),
+            initial_pressure_(initial_pressure),
+            max_z_(max_z)
+          {}
+
+          void set_delta(const double delta)
+          {
+            delta_ = delta;
+          }
+
+          void vector_value (const Point<dim> &p,
+                             Vector<double>   &values) const override
+          {
+            unsigned int index = static_cast<int>((p[dim-1]-delta_)/max_z_ * (initial_pressure_.size()-1));
+            if (p[dim-1]-delta_ < 0)
+              index = 0;
+            else if (p[dim-1]-delta_ > max_z_)
+              index = initial_pressure_.size()-1;
+            AssertThrow(index < initial_pressure_.size(), ExcMessage("not in range"));
+            const double z_coordinate1 = static_cast<double>(index)/static_cast<double>(initial_pressure_.size()-1) * max_z_;
+            const double z_coordinate2 = static_cast<double>(index+1)/static_cast<double>(initial_pressure_.size()-1) * max_z_;
+            const double interpolated_pressure = (index == initial_pressure_.size()-1)
+                                                 ?
+                                                 initial_pressure_[index]
+                                                 :
+                                                 initial_pressure_[index] + (initial_pressure_[index+1] - initial_pressure_[index])
+                                                 * (p[dim-1]-delta_ - z_coordinate1) / (z_coordinate2 - z_coordinate1);
+
+            values[dim+2+dim+2] = AnalyticSolutions::interpolate(p[dim-1]-delta_,offset_); //porosity
+            values[dim+1] = interpolated_pressure;                                   //compaction pressure
+          }
+
+        private:
+          const double offset_;
+          double delta_;
+          const std::vector<double> initial_pressure_;
+          const double max_z_;
+      };
+    }
+
+
+    /**
+     * An initial conditions model for the solitary waves benchmark.
+     */
+    template <int dim>
+    class SolitaryWaveInitialCondition : public InitialComposition::Interface<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Initialization function. Take references to the material model and
+         * get the compaction length, so that it can be used subsequently to
+         * compute the analytical solution for the shape of the solitary wave.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        double
+        initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        double
+        get_amplitude () const;
+
+        double
+        get_background_porosity () const;
+
+        double
+        get_offset () const;
+
+      private:
+        double amplitude;
+        double background_porosity;
+        double offset;
+        double compaction_length;
+        bool read_solution;
+        std::string file_name;
+    };
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class SolitaryWaveMaterial : public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        bool is_compressible () const override
+        {
+          return false;
+        }
+
+        double reference_darcy_coefficient () const override
+        {
+          // Make sure we keep track of the initial composition manager and
+          // that it continues to live beyond the time when the simulator
+          // class releases its pointer to it.
+          if (initial_composition_manager == nullptr)
+            const_cast<std::shared_ptr<const aspect::InitialComposition::Manager<dim>>&>(initial_composition_manager)
+              = this->get_initial_composition_manager_pointer();
+
+          // Note that this number is based on the background porosity in the
+          // solitary wave initial condition.
+          const SolitaryWaveInitialCondition<dim> &initial_composition =
+            initial_composition_manager->template
+            get_matching_initial_composition_model<SolitaryWaveInitialCondition<dim>>();
+
+          return reference_permeability * pow(initial_composition.get_background_porosity(), 3.0) / eta_f;
+
+        }
+
+        double length_scaling (const double porosity) const
+        {
+          return std::sqrt(reference_permeability * std::pow(porosity,3) * (xi_0 + 4.0/3.0 * eta_0) / eta_f);
+        }
+
+        double velocity_scaling (const double porosity) const
+        {
+          const Point<dim> surface_point = this->get_geometry_model().representative_point(0.0);
+          return reference_permeability * std::pow(porosity,2) * (reference_rho_s - reference_rho_f)
+                 * this->get_gravity_model().gravity_vector(surface_point).norm() / eta_f;
+        }
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                      typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const override
+        {
+          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+            {
+              double porosity = in.composition[i][porosity_idx];
+
+              out.viscosities[i] = eta_0 * (1.0 - porosity);
+              out.densities[i] = reference_rho_s;
+              out.thermal_expansion_coefficients[i] = 0.0;
+              out.specific_heat[i] = 1.0;
+              out.thermal_conductivities[i] = 0.0;
+              out.compressibilities[i] = 0.0;
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                out.reaction_terms[i][c] = 0.0;
+            }
+
+          // fill melt outputs if they exist
+          aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+          if (melt_out != nullptr)
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                double porosity = in.composition[i][porosity_idx];
+
+                melt_out->compaction_viscosities[i] = xi_0 * (1.0 - porosity);
+                melt_out->fluid_viscosities[i]= eta_f;
+                melt_out->permeabilities[i]= reference_permeability * std::pow(porosity,3);
+                melt_out->fluid_densities[i]= reference_rho_f;
+                melt_out->fluid_density_gradients[i] = 0.0;
+              }
+
+        }
+
+      private:
+        double reference_rho_s;
+        double reference_rho_f;
+        double eta_0;
+        double xi_0;
+        double eta_f;
+        double reference_permeability;
+
+        /**
+         * A shared pointer to the initial composition object
+         * that ensures that the current object can continue
+         * to access the initial composition object beyond the
+         * first time step.
+         */
+        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition_manager;
+    };
+
+    template <int dim>
+    void
+    SolitaryWaveMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Solitary wave");
+        {
+          prm.declare_entry ("Reference solid density", "3000",
+                             Patterns::Double (0),
+                             "Reference density of the solid $\\rho_{s,0}$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference melt density", "2500",
+                             Patterns::Double (0),
+                             "Reference density of the melt/fluid$\\rho_{f,0}$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference shear viscosity", "1e20",
+                             Patterns::Double (0),
+                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Reference compaction viscosity", "1e20",
+                             Patterns::Double (0),
+                             "The value of the constant volumetric viscosity $\\xi_0$ of the solid matrix. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Reference melt viscosity", "100.0",
+                             Patterns::Double (0),
+                             "The value of the constant melt viscosity $\\eta_f$. "
+                             "Units: \\si{\\pascal\\second}.");
+
+          prm.declare_entry ("Reference permeability", "5e-9",
+                             Patterns::Double(),
+                             "Reference permeability of the solid host rock."
+                             "Units: \\si{\\meter\\squared}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    SolitaryWaveMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Solitary wave");
+        {
+          reference_rho_s            = prm.get_double ("Reference solid density");
+          reference_rho_f            = prm.get_double ("Reference melt density");
+          eta_0                      = prm.get_double ("Reference shear viscosity");
+          xi_0                       = prm.get_double ("Reference compaction viscosity");
+          eta_f                      = prm.get_double ("Reference melt viscosity");
+          reference_permeability     = prm.get_double ("Reference permeability");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    double
+    SolitaryWaveInitialCondition<dim>::get_amplitude () const
+    {
+      return amplitude;
+    }
+
+    template <int dim>
+    double
+    SolitaryWaveInitialCondition<dim>::get_background_porosity () const
+    {
+      return background_porosity;
+    }
+
+    template <int dim>
+    double
+    SolitaryWaveInitialCondition<dim>::get_offset () const
+    {
+      return offset;
+    }
+
+    template <int dim>
+    void
+    SolitaryWaveInitialCondition<dim>::initialize ()
+    {
+      std::cout << "Initialize solitary wave solution"
+                << std::endl;
+
+      AssertThrow(Plugins::plugin_type_matches<const SolitaryWaveMaterial<dim>>(this->get_material_model()),
+                  ExcMessage("Initial condition Solitary Wave only works with the material model Solitary wave."));
+
+      const SolitaryWaveMaterial<dim> &
+      material_model
+        = Plugins::get_plugin_as_type<const SolitaryWaveMaterial<dim>>(this->get_material_model());
+
+      compaction_length = material_model.length_scaling(background_porosity);
+
+      AnalyticSolutions::compute_porosity(amplitude,
+                                          background_porosity,
+                                          offset,
+                                          compaction_length,
+                                          read_solution,
+                                          file_name,
+                                          this->get_mpi_communicator());
+    }
+
+
+    template <int dim>
+    double
+    SolitaryWaveInitialCondition<dim>::
+    initial_composition (const Point<dim> &position, const unsigned int /*n_comp*/) const
+    {
+      return AnalyticSolutions::interpolate(position[dim-1],
+                                            offset);
+    }
+
+
+    template <int dim>
+    void
+    SolitaryWaveInitialCondition<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Solitary wave initial condition");
+        {
+          prm.declare_entry ("Amplitude", "0.01",
+                             Patterns::Double (0),
+                             "Amplitude of the solitary wave. Units: none.");
+          prm.declare_entry ("Background porosity", "0.001",
+                             Patterns::Double (0),
+                             "Background porosity of the solitary wave. Units: none.");
+          prm.declare_entry ("Offset", "150",
+                             Patterns::Double (0),
+                             "Offset of the center of the solitary wave from the boundary"
+                             "of the domain. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Read solution from file", "false",
+                             Patterns::Bool (),
+                             "Whether to read the porosity initial condition from "
+                             "a file or to compute it.");
+          prm.declare_entry ("File name", "solitary_wave.txt",
+                             Patterns::Anything (),
+                             "The file name of the porosity initial condition data. ");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    SolitaryWaveInitialCondition<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Solitary wave initial condition");
+        {
+          amplitude            = prm.get_double ("Amplitude");
+          background_porosity  = prm.get_double ("Background porosity");
+          offset               = prm.get_double ("Offset");
+          read_solution        = prm.get_bool ("Read solution from file");
+          file_name            = prm.get ("File name");
+
+          AssertThrow(amplitude > background_porosity,
+                      ExcMessage("Amplitude of the solitary wave must be larger "
+                                 "than the background porosity."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the paper Keller et al. reference above.
+      */
+    template <int dim>
+    class SolitaryWavePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Initialization function. Take references to the material model and
+         * initial conditions model to get the parameters necessary for computing
+         * the analytical solution for the shape of the solitary wave and store them.
+         */
+        void
+        initialize () override;
+
+        void
+        store_initial_pressure ();
+
+        double
+        compute_phase_shift ();
+
+      private:
+        double amplitude;
+        double background_porosity;
+        double offset;
+        double compaction_length;
+        double velocity_scaling;
+        double boundary_velocity;
+        unsigned int max_points;
+        std::vector<double> initial_pressure;
+        double maximum_pressure;
+        std::shared_ptr<AnalyticSolutions::FunctionSolitaryWave<dim>> ref_func;
+
+    };
+
+    template <int dim>
+    void
+    SolitaryWavePostprocessor<dim>::initialize ()
+    {
+      // verify that we are using the "Solitary wave" initial conditions and material model,
+      // then get the parameters we need
+
+      const SolitaryWaveInitialCondition<dim> &initial_composition
+        = this->get_initial_composition_manager().template get_matching_initial_composition_model<SolitaryWaveInitialCondition<dim>> ();
+
+      amplitude           = initial_composition.get_amplitude();
+      background_porosity = initial_composition.get_background_porosity();
+      offset              = initial_composition.get_offset();
+
+      AssertThrow(Plugins::plugin_type_matches<const SolitaryWaveMaterial<dim>>(this->get_material_model()),
+                  ExcMessage("Postprocessor Solitary Wave only works with the material model Solitary wave."));
+
+      const SolitaryWaveMaterial<dim> &material_model
+        = Plugins::get_plugin_as_type<const SolitaryWaveMaterial<dim>>(this->get_material_model());
+
+      compaction_length = material_model.length_scaling(background_porosity);
+      velocity_scaling = material_model.velocity_scaling(background_porosity);
+
+
+      // we also need the boundary velocity, but we can not get it from simulator access
+      // TODO: write solitary wave boundary condition where the phase speed is calculated!
+
+      max_points = 1e6;
+      initial_pressure.resize(max_points);
+      maximum_pressure = 0.0;
+    }
+
+    template <int dim>
+    void
+    SolitaryWavePostprocessor<dim>::store_initial_pressure ()
+    {
+      const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.pressure).degree);
+      const unsigned int n_q_points = quadrature_formula.size();
+      const double max_depth = this->get_geometry_model().maximal_depth();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      // do the same stuff we do in depth average
+      std::vector<double> volume(max_points,0.0);
+      std::vector<double> pressure(max_points,0.0);
+      std::vector<double> p_c(n_q_points);
+      double local_max_pressure = 0.0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().variable("compaction pressure").extractor_scalar()]
+            .get_function_values (this->get_solution(),
+                                  p_c);
+
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                double z = fe_values.quadrature_point(q)[dim-1];
+                const unsigned int idx = static_cast<unsigned int>((z*(max_points-1))/max_depth);
+                AssertThrow(idx < max_points, ExcInternalError());
+
+                pressure[idx] += p_c[q] * fe_values.JxW(q);
+                volume[idx] += fe_values.JxW(q);
+
+                local_max_pressure = std::max (local_max_pressure, std::abs(p_c[q]));
+              }
+          }
+
+      std::vector<double> volume_all(max_points, 0.0);
+      Utilities::MPI::sum(volume, this->get_mpi_communicator(), volume_all);
+      Utilities::MPI::sum(pressure, this->get_mpi_communicator(), initial_pressure);
+      maximum_pressure = Utilities::MPI::max (local_max_pressure, this->get_mpi_communicator());
+
+      for (unsigned int i=0; i<initial_pressure.size(); ++i)
+        {
+          initial_pressure[i] = initial_pressure[i] / (static_cast<double>(volume_all[i])+1e-20);
+        }
+
+      // fill the first and last element of the initial_pressure vector if they are empty
+      // this makes sure they can be used for the interpolation later on
+      if (initial_pressure[0] == 0.0)
+        {
+          unsigned int j = 1;
+          while (initial_pressure[j] == 0.0)
+            j++;
+          initial_pressure[0] = initial_pressure[j];
+        }
+
+      if (initial_pressure[max_points-1] == 0.0)
+        {
+          unsigned int k = max_points-2;
+          while (initial_pressure[k] == 0.0)
+            k--;
+          initial_pressure[max_points-1] = initial_pressure[k];
+        }
+
+      // interpolate between the non-zero elements to fill the elements that are 0
+      for (unsigned int i=1; i<max_points-1; ++i)
+        {
+          if (initial_pressure[i] == 0.0)
+            {
+              // interpolate between the values we have
+              unsigned int k = i-1;
+              while (initial_pressure[k] == 0.0)
+                {
+                  Assert(k > 0, ExcInternalError());
+                  k--;
+                }
+
+              unsigned int j = i+1;
+              while (initial_pressure[j] == 0.0)
+                j++;
+              Assert(j < max_points, ExcInternalError());
+              initial_pressure[i] = initial_pressure[k] + (initial_pressure[j]-initial_pressure[k]) * static_cast<double>(i-k)/static_cast<double>(j-k);
+            }
+        }
+    }
+
+    template <int dim>
+    double
+    SolitaryWavePostprocessor<dim>::compute_phase_shift ()
+    {
+      AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                  ExcMessage("Postprocessor Solitary Wave only works if there is a compositional field called porosity."));
+      const unsigned int porosity_index = this->introspection().compositional_index_for_name("porosity");
+      const typename Simulator<dim>::AdvectionField porosity = Simulator<dim>::AdvectionField::composition(porosity_index);
+
+      // create a quadrature formula based on the compositional element alone.
+      AssertThrow (this->introspection().n_compositional_fields > 0,
+                   ExcMessage("This postprocessor cannot be used without compositional fields."));
+
+      const QGauss<dim> quadrature_formula (this->get_fe().base_element(porosity.base_element(this->introspection())).degree+1);
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      std::vector<double> compositional_values(n_q_points);
+
+      // The idea here is to first find the maximum, and then use the analytical solution of the
+      // solitary wave to calculate a phase shift for every point.
+      // This has to be done separately for points left and right of the maximum, as the analytical
+      // solution is only defined for coordinates > 0.
+      // In the end, these values for the phase shift are averaged.
+
+      // compute the maximum composition by quadrature (because we also need the coordinate)
+      double z_max_porosity = std::numeric_limits<double>::quiet_NaN();
+      {
+        double local_max_porosity = -std::numeric_limits<double>::max();
+        double local_max_z_location = std::numeric_limits<double>::quiet_NaN();
+
+        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              fe_values.reinit (cell);
+              fe_values[this->introspection().extractors.compositional_fields[porosity_index]].get_function_values (this->get_solution(),
+                  compositional_values);
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  const double composition = compositional_values[q];
+
+                  if (composition > local_max_porosity)
+                    {
+                      local_max_porosity = composition;
+                      local_max_z_location = fe_values.quadrature_point(q)[dim-1];
+                    }
+                }
+            }
+
+        double max_porosity = 0.0;
+        MPI_max_and_data(local_max_porosity, local_max_z_location, max_porosity, z_max_porosity);
+      }
+
+
+      // iterate over all points and calculate the phase shift
+      double phase_shift_integral = 0.0;
+      unsigned int number_of_points = 0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.compositional_fields[porosity_index]].get_function_values (this->get_solution(),
+                compositional_values);
+
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                const double composition = compositional_values[q];
+
+                // we do not want to include the constant-porosity background in the calculation
+                // nor the peak of the wave where we maximum of the composition is not a good indicator
+                // if we are left or right of the maximum of the analytical solution
+                if (composition > background_porosity + (amplitude - background_porosity)*0.05  && composition <= amplitude*0.9)
+                  {
+                    double z_analytical = compaction_length
+                                          * AnalyticSolutions::solitary_wave_solution(composition/background_porosity,
+                                                                                      amplitude/background_porosity);
+                    double z = fe_values.quadrature_point(q)[dim-1];
+
+                    if (z > z_max_porosity)
+                      {
+                        z -= offset;
+                        phase_shift_integral += (z - z_analytical);
+                      }
+                    else
+                      {
+                        z = offset - z;
+                        phase_shift_integral -= (z - z_analytical);
+                      }
+
+                    number_of_points += 1;
+                  }
+              }
+          }
+
+      double integral = Utilities::MPI::sum (phase_shift_integral, this->get_mpi_communicator())
+                        / Utilities::MPI::sum (static_cast<double>(number_of_points), this->get_mpi_communicator());
+
+      // TODO: different case for moving wave (with zero boundary velocity)
+      // const double phase_speed = velocity_scaling * (2.0 * amplitude / background_porosity + 1);
+      return integral; // + phase_speed * this->get_time();
+    }
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    SolitaryWavePostprocessor<dim>::execute (TableHandler & /*statistics*/)
+    {
+      // as we do not have an analytical solution for the pressure, we store the initial solution
+      if (this->get_timestep_number()==0)
+        {
+          store_initial_pressure();
+          ref_func = std::make_unique<AnalyticSolutions::FunctionSolitaryWave<dim>>(offset,0.0,initial_pressure,
+                                                                                     this->get_geometry_model().maximal_depth(), this->introspection().n_components);
+        }
+
+      double delta=0;
+
+      delta = compute_phase_shift();
+      // reset the phase shift of the analytical solution so we can compare the shape of the wave
+      ref_func->set_delta(delta);
+
+      // what we want to compare:
+      // (1) error of the numerical phase speed c:
+      // c_numerical = c_analytical - Delta / time;
+      const double c_analytical = velocity_scaling * (2.0 * amplitude / background_porosity + 1);
+      const double c_numerical = c_analytical + (this->get_time() > 0 ? delta / this->get_time() : 0.0);
+      const double error_c = std::abs (c_numerical / c_analytical - 1);
+
+      // (3) preservation of shape of melt fraction
+      // (4) preservation of the shape of compaction pressure
+
+      Vector<float> cellwise_errors_f (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+
+      // get correct components for porosity and compaction pressure
+      const unsigned int n_total_comp = this->introspection().n_components;
+      ComponentSelectFunction<dim> comp_f(dim+2+dim+2, n_total_comp);
+      ComponentSelectFunction<dim> comp_p(dim+1, n_total_comp);
+
+      const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.pressure).degree+1);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_f,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_f);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_p,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double e_f = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_f, VectorTools::L2_norm);
+      const double e_p = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
+
+      std::ostringstream os;
+      os << std::scientific << e_f / amplitude
+         << ", " << e_p / maximum_pressure
+         << ", " << error_c
+         << ", " << std::abs(delta);
+
+
+      return std::make_pair("Errors e_f, e_p_c_bar, e_c, delta:", os.str());
+    }
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace SolitaryWaveBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SolitaryWaveMaterial,
+                                   "Solitary Wave",
+                                   "A material model that corresponds to the 'SolitaryWave' benchmark "
+                                   "defined in Keller et al., JGI, 2013.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(SolitaryWavePostprocessor,
+                                  "solitary wave statistics",
+                                  "A postprocessor that compares the solution of the benchmarks from "
+                                  "the Keller et al., JGI, 2013, paper with the one computed by ASPECT "
+                                  "and reports the error.")
+
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(SolitaryWaveInitialCondition,
+                                              "Solitary wave initial condition",
+                                              "Composition is set to a solitary wave function.")
+  }
+}
diff --git a/benchmarks/solitary_wave/solitary_wave.prm.bak b/benchmarks/solitary_wave/solitary_wave.prm.bak
new file mode 100644
index 00000000000..6d3059ca04f
--- /dev/null
+++ b/benchmarks/solitary_wave/solitary_wave.prm.bak
@@ -0,0 +1,170 @@
+# Listing of Parameters
+# ---------------------
+# Set up the solitary wave benchmark
+# (Barcilon & Richter, 1986; Simpson & Spiegelman, 2011;
+# Keller et al., 2013; Schmeling, 200
+
+set Additional shared libraries            = ./libsolitary_wave.so
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = output
+set Max nonlinear iterations               = 10
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 6e6
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.001
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = top, bottom
+  set List of model names = initial composition
+end
+
+# we apply the phase speed of the wave here, so that it always stays in the same place in our model
+# the phase speed is c = 5.25e-11 m/s, but we have to convert it to m/years using the same conversion
+# that is used internally in ASPECT: year_in_seconds = 60*60*24*365.2425
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Prescribed velocity boundary indicators = top:function, bottom:function
+
+  subsection Function
+    #    set Function expression = 0;-8.2836999e-5
+    set Function expression = 0;-1.65673998e-4
+
+    #    set Function expression = 0;-3.31347996e-4
+    #    set Function expression = 0;-6.62695992e-4
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 10
+    set Y extent  = 400
+    set Y repetitions = 40
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Initial composition model
+  set Model name = Solitary wave initial condition
+
+  subsection Solitary wave initial condition
+    set Offset = 200
+    set Read solution from file = true
+    set Amplitude = 0.01
+    set Background porosity = 0.001
+  end
+end
+
+subsection Material model
+  set Model name = Solitary Wave
+
+  subsection Solitary wave
+    set Reference permeability = 5e-9
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics,solitary wave statistics
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 5e5
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-14
+  set Temperature solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-10
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc.bak b/benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc.bak
new file mode 100644
index 00000000000..b9fab75725b
--- /dev/null
+++ b/benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc.bak
@@ -0,0 +1,45 @@
+/*
+  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include "solkz_compositional_fields.h"
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SolKzCompositionalMaterial,
+                                   "SolKzCompositionalMaterial",
+                                   "A material model that corresponds to the 'SolKz' benchmark "
+                                   "defined in Duretz et al., G-Cubed, 2011. using "
+                                   "compositional fields. ")
+
+
+    ASPECT_REGISTER_POSTPROCESSOR(SolKzPostprocessor,
+                                  "SolKzPostprocessor",
+                                  "A postprocessor that compares the solution of the benchmarks from "
+                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
+                                  "and reports the error. Specifically, it can compute the errors for "
+                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
+                                  "which material model is currently being used and adjusts "
+                                  "which exact solution to use accordingly.")
+  }
+}
diff --git a/benchmarks/solkz/compositional_fields/solkz_compositional_fields.h.bak b/benchmarks/solkz/compositional_fields/solkz_compositional_fields.h.bak
new file mode 100644
index 00000000000..8e2e4e7232e
--- /dev/null
+++ b/benchmarks/solkz/compositional_fields/solkz_compositional_fields.h.bak
@@ -0,0 +1,33 @@
+#ifndef ASPECT_SOLKZ_COMPOSITIONAL_FIELDS_H
+#define ASPECT_SOLKZ_COMPOSITIONAL_FIELDS_H
+
+
+#include "../solkz.h"
+
+
+
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class SolKzCompositionalMaterial : public SolKzMaterial<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          SolKzMaterial<dim>::evaluate(in, out);
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              out.densities[i] = in.composition[i][0];
+              out.viscosities[i] = in.composition[i][1];
+            }
+        }
+    };
+  }
+}
+#endif
diff --git a/benchmarks/solkz/compositional_fields/solkz_compositional_fields.prm.bak b/benchmarks/solkz/compositional_fields/solkz_compositional_fields.prm.bak
new file mode 100644
index 00000000000..67f3ebe888c
--- /dev/null
+++ b/benchmarks/solkz/compositional_fields/solkz_compositional_fields.prm.bak
@@ -0,0 +1,93 @@
+# A description of the SolKZ benchmark using compositional fields
+# for which a known solution is available. See the manual for
+# more information.
+
+set Additional shared libraries            = ./libsolkz_compositional_fields.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolKzCompositionalMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+
+  # Whether to use a composition discretization that is discontinuous as
+  # opposed to continuous. This then requires the assembly of face terms
+  # between cells, and weak imposition of boundary terms for the composition
+  # field via the discontinuous Galerkin method.
+
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+############### Parameters describing the compositional field
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = density_comp, viscosity_comp
+  set Compositional field methods = field, field
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi = 3.1415926536
+    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(1e6)*z)
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, SolKzPostprocessor
+
+  subsection Visualization
+    set Output format = vtu
+    set Number of grouped files = 1
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
diff --git a/benchmarks/solkz/compositional_fields/solkz_particles.prm.bak b/benchmarks/solkz/compositional_fields/solkz_particles.prm.bak
new file mode 100644
index 00000000000..44f32cc289b
--- /dev/null
+++ b/benchmarks/solkz/compositional_fields/solkz_particles.prm.bak
@@ -0,0 +1,117 @@
+# A description of the SolKZ benchmark using active particles
+# to interpolate both density and viscosity onto the compositional
+# fields for which a known solution is available. See the manual
+# for more information.
+
+set Additional shared libraries            = ./libsolkz_compositional_fields.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolKzCompositionalMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = density_comp, viscosity_comp
+  set Compositional field methods = particles, particles
+  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, visualization, SolKzPostprocessor
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Number of grouped files       = 1
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = cell average
+  set Maximum particles per cell = 16384
+  set Update ghost particles = true
+  set Particle generator name = reference cell
+
+  subsection Function
+    set Number of components = 2
+    set Variable names      = x, z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression =  -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 4
+    end
+  end
+end
diff --git a/benchmarks/solkz/doc/solkz.prm.bak b/benchmarks/solkz/doc/solkz.prm.bak
new file mode 100644
index 00000000000..99e6a93d934
--- /dev/null
+++ b/benchmarks/solkz/doc/solkz.prm.bak
@@ -0,0 +1,60 @@
+# A description of the SolKZ benchmark for which a known solution
+# is available. See the manual for more information.
+
+set Additional shared libraries            = ./libsolkz.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = SolKzPostprocessor, visualization
+end
diff --git a/benchmarks/solkz/solkz.cc.bak b/benchmarks/solkz/solkz.cc.bak
new file mode 100644
index 00000000000..cc972af1460
--- /dev/null
+++ b/benchmarks/solkz/solkz.cc.bak
@@ -0,0 +1,44 @@
+/*
+  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include "solkz.h"
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SolKzMaterial,
+                                   "SolKzMaterial",
+                                   "A material model that corresponds to the 'SolKz' benchmark "
+                                   "defined in Duretz et al., G-Cubed, 2011.")
+
+
+    ASPECT_REGISTER_POSTPROCESSOR(SolKzPostprocessor,
+                                  "SolKzPostprocessor",
+                                  "A postprocessor that compares the solution of the benchmarks from "
+                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
+                                  "and reports the error. Specifically, it can compute the errors for "
+                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
+                                  "which material model is currently being used and adjusts "
+                                  "which exact solution to use accordingly.")
+  }
+}
diff --git a/benchmarks/solkz/solkz.h.bak b/benchmarks/solkz/solkz.h.bak
new file mode 100644
index 00000000000..50d8e0765e2
--- /dev/null
+++ b/benchmarks/solkz/solkz.h.bak
@@ -0,0 +1,799 @@
+#ifndef ASPECT_SOLKZ_H
+#define ASPECT_SOLKZ_H
+
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+
+namespace aspect
+{
+  /**
+   * This is the "Sol Kz" benchmark defined in the following paper:
+   * @code
+   *  @Article{DMGT11,
+   *    author =       {T. Duretz and D. A. May and T. V. Gerya and P. J. Tackley},
+   *    title =        {Discretization errors and free surface stabilization in the
+   *                  finite difference and marker-in-cell method for applied
+   *                  geodynamics: {A} numerical study},
+   *    journal =      {Geochemistry Geophysics Geosystems},
+   *    year =         2011,
+   *    volume =       12,
+   *    pages =        {Q07004/1--26}}
+   * @endcode
+   *
+   * The results are published in Kronbichler, Heister and Bangerth paper.
+   */
+  namespace InclusionBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+      // based on http://geodynamics.org/hg/cs/AMR/Discontinuous_Stokes with permission
+      // The following code has been taken from http://www.underworldproject.org/,
+      // release 1.7.0. As mentioned in the Underworld Manual, this code has been
+      // released under the GNU General Public License (GPL).
+
+      void _Velic_solKz(
+        double pos[],
+        double _sigma, /* density */
+        double _km, int _n, /* wavelength in z, wavenumber in x */
+        double _B, /* viscosity parameter */
+        double vel[], double *presssure,
+        double total_stress[], double strain_rate[])
+      {
+        double Z;
+        double u1, u2, u3, u4, u5, u6, SS;
+        double sum1, sum2, sum3, sum4, sum5, sum6, sum7, x, z;
+        double sigma;
+        int n;
+        double kn;
+        double _C1, _C2, _C3, _C4;
+        double B, Rp, UU, VV;
+        double rho, a, b, r, _aa, _bb, AA, BB, Rm, km;
+
+
+        double t1, t2, t3, t4, t5, t6, t7, t8, t9, t10;
+        double t11, t12, t13, t14, t15, t16, t17, t18, t19, t20;
+        double t21, t22, t23, t24, t25, t26, t27, t28, t29, t31;
+        double t33, t34, t35, t37, t38, t40, t41, t42, t43, t45;
+        double t47, t51, t52, t53, t54, t55, t56, t57, t58, t59;
+        double t60, t61, t62, t64, t65, t66, t67, t68, t69, t70;
+        double t71, t72, t73, t74, t75, t76, t77, t78, t79, t80;
+        double t81, t82, t83, t84, t85, t86, t89, t90, t92, t94;
+        double t96, t97, t98, t99, t100, t101, t103, t104, t105, t106;
+        double t107, t108, t109, t110, t111, t112, t113, t114, t115, t116;
+        double t117, t118, t119, t120, t121, t122, t123, t124, t125, t126;
+        double t127, t130, t131, t132, t134, t135, t141, t144, t147, t148;
+        double t150, t151, t152, t161, t171;
+
+
+
+        /*************************************************************************/
+        /*************************************************************************/
+        /* rho = -sigma*sin(km*z)*cos(kn*x) */
+        /* viscosity  Z= exp(2*B*z)  */
+        B = _B; /* viscosity parameter must be non-zero*/
+        km = _km; /* solution valid for km not zero -- should get trivial solution if km=0 */
+        n = _n; /* solution valid for n not zero */
+        sigma = _sigma;
+        /*************************************************************************/
+        /*************************************************************************/
+        kn = (double) _n * M_PI;
+        a = B * B + kn * kn;
+        b = 2.0 * kn * B;
+        r = sqrt(a * a + b * b);
+        Rp = sqrt((r + a) / 2.0);
+        Rm = sqrt((r - a) / 2.0);
+        UU = Rp - B;
+        VV = Rp + B;
+
+
+        x = pos[0];
+        z = pos[1];
+
+        sum1 = 0.0;
+        sum2 = 0.0;
+        sum3 = 0.0;
+        sum4 = 0.0;
+        sum5 = 0.0;
+        sum6 = 0.0;
+        sum7 = 0.0;
+
+
+
+
+        /*******************************************/
+        /*         calculate the constants         */
+        /*******************************************/
+
+        t3 = kn * kn;
+        t4 = km * km;
+        t6 = B * B;
+        t8 = 0.4e1 * t3 * t6;
+        t10 = 0.4e1 * t4 * t6;
+        t13 = 0.8e1 * kn * t6 * km;
+        t14 = t4 * t4;
+        t16 = 0.2e1 * t3 * t4;
+        t17 = t3 * t3;
+        _aa = -0.4e1 * B * km * kn * (t3 + t4) / (t8 + t10 + t13 + t14 + t16 + t17) /
+              (-t13 + t8 + t10 + t14 + t16 + t17);
+
+        t1 = kn * kn;
+        t2 = t1 * t1;
+        t3 = B * B;
+        t5 = 0.4e1 * t1 * t3;
+        t6 = km * km;
+        t7 = t6 * t6;
+        t9 = 0.2e1 * t1 * t6;
+        t11 = 0.4e1 * t3 * t6;
+        t16 = 0.8e1 * kn * t3 * km;
+        _bb = kn * (t2 + t5 + t7 + t9 - t11) / (t5 + t11 + t16 + t7 + t9 + t2) /
+              (-t16 + t5 + t11 + t7 + t9 + t2);
+
+        AA = _aa;
+        BB = _bb;
+
+        t1 = B * B;
+        t2 = t1 * Rp;
+        t4 = Rm * Rm;
+        t5 = t4 * Rp;
+        t7 = t4 * B;
+        t8 = km * km;
+        t12 = Rp * Rp;
+        t13 = B * t12;
+        t21 = 0.8e1 * t1 * km * BB * Rp;
+        t23 = 0.2e1 * Rm;
+        t24 = cos(t23);
+        t26 = Rm * Rp;
+        t38 = sin(t23);
+        t51 = exp(-0.2e1 * Rp);
+        t53 = B + Rp;
+        t54 = Rm * t53;
+        t55 = Rm * B;
+        t57 = 0.2e1 * B * km;
+        t58 = t55 + t57 - t26;
+        t62 = 0.3e1 * t1;
+        t64 = 0.2e1 * Rp * B;
+        t65 = t62 + t64 + t4 - t8 - t12;
+        t67 = t54 * t65 * BB;
+        t69 = Rm - km;
+        t70 = cos(t69);
+        t72 = -t57 + t55 - t26;
+        t77 = Rm + km;
+        t78 = cos(t77);
+        t81 = t54 * t65 * AA;
+        t86 = sin(t77);
+        t92 = sin(t69);
+        t96 = exp(-t53);
+        t98 = B - Rp;
+        t99 = Rm * t98;
+        t100 = t55 + t57 + t26;
+        t104 = t62 - t64 + t4 - t8 - t12;
+        t106 = t99 * t104 * BB;
+        t109 = -t57 + t55 + t26;
+        t116 = t99 * t104 * AA;
+        t130 = exp(-0.3e1 * Rp - B);
+        t135 = exp(-0.4e1 * Rp);
+        t144 = t4 * t1;
+        t150 = t4 * t12;
+        _C1 = (((0.2e1 * Rp * (0.2e1 * t2 + 0.2e1 * t5 + t7 + B * t8 - 0.3e1 * t1 * B + t13) * AA + t21) * t24 +
+                (-0.2e1 * t26 * (t4 - t8 - t12 + 0.5e1 * t1) * AA + 0.8e1 * B * BB * km * Rm * Rp) * t38 -
+                0.2e1 * B * (0.2e1 * t13 + t12 * Rp - 0.3e1 * t2 + t5 + 0.2e1 * t7 + t8 * Rp) * AA - t21) *
+               t51 + ((0.2e1 * t54 * t58 * AA + t67) * t70 + (0.2e1 * t54 * t72 * AA - t67) * t78 +
+                      (t81 + 0.2e1 * t54 * t72 * BB) * t86 + (t81 - 0.2e1 * t54 * t58 * BB) * t92) * t96 +
+               ((-0.2e1 * t99 * t100 * AA - t106) * t70 + (-0.2e1 * t99 * t109 * AA + t106) * t78 +
+                (-t116 - 0.2e1 * t99 * t109 * BB) * t86 + (-t116 + 0.2e1 * t99 * t100 * BB) * t92) * t130 +
+               0.4e1 * t4 * t98 * t53 * AA * t135) /
+              (((-0.8e1 * t4 - 0.8e1 * t1) * t12 * t24 + 0.8e1 * t144 + 0.8e1 * t12 * t1) * t51 +
+               (0.4e1 * t150 - 0.4e1 * t144) * t135 + 0.4e1 * t150 - 0.4e1 * t144);
+
+        t1 = Rm * Rp;
+        t2 = Rm * Rm;
+        t3 = km * km;
+        t4 = Rp * Rp;
+        t5 = B * B;
+        t12 = km * Rm;
+        t17 = 0.2e1 * Rm;
+        t18 = cos(t17);
+        t22 = t2 * Rp;
+        t25 = B * t3;
+        t26 = t5 * B;
+        t33 = t5 * km;
+        t38 = sin(t17);
+        t40 = Rm * B;
+        t41 = 0.3e1 * t5;
+        t51 = exp(-0.2e1 * Rp);
+        t53 = B + Rp;
+        t54 = Rm * t53;
+        t57 = t41 + 0.2e1 * Rp * B + t2 - t3 - t4;
+        t59 = t54 * t57 * AA;
+        t60 = B * km;
+        t61 = 0.2e1 * t60;
+        t62 = t40 + t61 - t1;
+        t67 = Rm - km;
+        t68 = cos(t67);
+        t70 = -t61 + t40 - t1;
+        t75 = Rm + km;
+        t76 = cos(t75);
+        t82 = t54 * t57 * BB;
+        t84 = sin(t75);
+        t90 = sin(t67);
+        t94 = exp(-t53);
+        t97 = 0.3e1 * Rm * t26;
+        t98 = t2 * Rm;
+        t99 = t98 * B;
+        t100 = t3 * Rm;
+        t101 = t100 * Rp;
+        t103 = Rm * t4 * B;
+        t104 = t4 * Rp;
+        t105 = Rm * t104;
+        t107 = 0.8e1 * t33 * Rp;
+        t109 = 0.5e1 * t1 * t5;
+        t110 = t98 * Rp;
+        t111 = t100 * B;
+        t112 = t97 + t99 - t101 + t103 - t105 + t107 + t109 + t110 - t111;
+        t114 = t2 * t4;
+        t116 = 0.2e1 * t60 * t1;
+        t117 = t2 * t5;
+        t119 = 0.3e1 * t26 * Rp;
+        t120 = t104 * B;
+        t121 = t4 * t5;
+        t122 = 0.2e1 * t121;
+        t123 = t22 * B;
+        t125 = 0.2e1 * t33 * Rm;
+        t126 = t25 * Rp;
+        t127 = t114 + t116 + t117 - t119 + t120 + t122 + t123 + t125 + t126;
+        t132 = -t107 + t103 - t105 - t101 + t97 - t111 + t110 + t109 + t99;
+        t134 = t120 - t125 + t123 - t116 + t122 + t117 + t114 + t126 - t119;
+        t152 = exp(-0.3e1 * Rp - B);
+        t161 = exp(-0.4e1 * Rp);
+        _C2 = (((0.2e1 * t1 * (t2 - t3 - t4 + 0.5e1 * t5) * AA - 0.8e1 * B * BB * t12 * Rp) * t18 +
+                (0.2e1 * Rp * (0.2e1 * t5 * Rp + 0.2e1 * t22 + t2 * B + t25 - 0.3e1 * t26 + B * t4) * AA +
+                 0.8e1 * t33 * BB * Rp) * t38 + 0.2e1 * t40 * (t41 + t4 + t2 - t3) * AA -
+                0.8e1 * t5 * BB * t12) * t51 +
+               ((-t59 + 0.2e1 * t54 * t62 * BB) * t68 + (-t59 - 0.2e1 * t54 * t70 * BB) * t76 +
+                (0.2e1 * t54 * t70 * AA - t82) * t84 + (0.2e1 * t54 * t62 * AA + t82) * t90) * t94 +
+               ((t112 * AA - 0.2e1 * t127 * BB) * t68 + (t132 * AA + 0.2e1 * t134 * BB) * t76 +
+                (-0.2e1 * t134 * AA + t132 * BB) * t84 + (-0.2e1 * t127 * AA - t112 * BB) * t90) * t152 +
+               (-0.2e1 * t59 + 0.8e1 * t40 * km * t53 * BB) * t161) /
+              (((-0.8e1 * t2 - 0.8e1 * t5) * t4 * t18 + 0.8e1 * t117 + 0.8e1 * t121) * t51 +
+               (0.4e1 * t114 - 0.4e1 * t117) * t161 + 0.4e1 * t114 - 0.4e1 * t117);
+
+        t1 = B * B;
+        t2 = t1 * Rp;
+        t4 = Rm * Rm;
+        t5 = t4 * Rp;
+        t7 = Rp * Rp;
+        t8 = B * t7;
+        t11 = km * km;
+        t13 = t4 * B;
+        t21 = 0.8e1 * t1 * km * BB * Rp;
+        t23 = 0.2e1 * Rm;
+        t24 = cos(t23);
+        t26 = Rm * Rp;
+        t38 = sin(t23);
+        t51 = exp(-0.2e1 * Rp);
+        t53 = B + Rp;
+        t54 = Rm * t53;
+        t55 = Rm * B;
+        t57 = 0.2e1 * B * km;
+        t58 = t55 + t57 - t26;
+        t62 = 0.3e1 * t1;
+        t64 = 0.2e1 * Rp * B;
+        t65 = t62 + t64 + t4 - t11 - t7;
+        t67 = t54 * t65 * BB;
+        t69 = Rm - km;
+        t70 = cos(t69);
+        t72 = -t57 + t55 - t26;
+        t77 = Rm + km;
+        t78 = cos(t77);
+        t81 = t54 * t65 * AA;
+        t86 = sin(t77);
+        t92 = sin(t69);
+        t96 = exp(-t53);
+        t98 = B - Rp;
+        t99 = Rm * t98;
+        t100 = t55 + t57 + t26;
+        t104 = t62 - t64 + t4 - t11 - t7;
+        t106 = t99 * t104 * BB;
+        t109 = -t57 + t55 + t26;
+        t116 = t99 * t104 * AA;
+        t130 = exp(-0.3e1 * Rp - B);
+        t141 = t4 * t1;
+        t147 = t4 * t7;
+        t151 = exp(-0.4e1 * Rp);
+        _C3 = (((-0.2e1 * Rp * (-0.2e1 * t2 - 0.2e1 * t5 + t8 - 0.3e1 * t1 * B + B * t11 + t13) * AA - t21) *
+                t24 + (0.2e1 * t26 * (t4 - t11 - t7 + 0.5e1 * t1) * AA - 0.8e1 * B * BB * km * Rm * Rp) * t38 -
+                0.2e1 * B * (0.2e1 * t8 + 0.2e1 * t13 + 0.3e1 * t2 - t7 * Rp - t5 - t11 * Rp) * AA + t21) *
+               t51 + ((-0.2e1 * t54 * t58 * AA - t67) * t70 + (-0.2e1 * t54 * t72 * AA + t67) * t78 +
+                      (-t81 - 0.2e1 * t54 * t72 * BB) * t86 + (-t81 + 0.2e1 * t54 * t58 * BB) * t92) * t96 +
+               ((0.2e1 * t99 * t100 * AA + t106) * t70 + (0.2e1 * t99 * t109 * AA - t106) * t78 +
+                (t116 + 0.2e1 * t99 * t109 * BB) * t86 + (t116 - 0.2e1 * t99 * t100 * BB) * t92) * t130 +
+               0.4e1 * t4 * t98 * t53 * AA) /
+              (((-0.8e1 * t4 - 0.8e1 * t1) * t7 * t24 + 0.8e1 * t141 + 0.8e1 * t7 * t1) * t51 +
+               (0.4e1 * t147 - 0.4e1 * t141) * t151 + 0.4e1 * t147 - 0.4e1 * t141);
+
+        t1 = Rm * Rp;
+        t2 = Rm * Rm;
+        t3 = km * km;
+        t4 = Rp * Rp;
+        t5 = B * B;
+        t12 = km * Rm;
+        t17 = 0.2e1 * Rm;
+        t18 = cos(t17);
+        t22 = t2 * Rp;
+        t25 = t5 * B;
+        t27 = B * t3;
+        t33 = t5 * km;
+        t38 = sin(t17);
+        t40 = Rm * B;
+        t41 = 0.3e1 * t5;
+        t51 = exp(-0.2e1 * Rp);
+        t53 = t2 * Rm;
+        t54 = t53 * B;
+        t56 = 0.5e1 * t1 * t5;
+        t58 = Rm * t4 * B;
+        t59 = t3 * Rm;
+        t60 = t59 * Rp;
+        t62 = 0.8e1 * t33 * Rp;
+        t64 = 0.3e1 * Rm * t25;
+        t65 = t53 * Rp;
+        t66 = t59 * B;
+        t67 = t4 * Rp;
+        t68 = Rm * t67;
+        t69 = t54 - t56 + t58 + t60 - t62 + t64 - t65 - t66 + t68;
+        t71 = t2 * t4;
+        t73 = 0.3e1 * t25 * Rp;
+        t74 = t2 * t5;
+        t75 = t27 * Rp;
+        t76 = B * km;
+        t78 = 0.2e1 * t76 * t1;
+        t80 = 0.2e1 * t33 * Rm;
+        t81 = t22 * B;
+        t82 = t4 * t5;
+        t83 = 0.2e1 * t82;
+        t84 = t67 * B;
+        t85 = t71 + t73 + t74 - t75 - t78 + t80 - t81 + t83 - t84;
+        t89 = Rm - km;
+        t90 = cos(t89);
+        t92 = t60 - t66 - t65 + t58 + t54 - t56 + t62 + t68 + t64;
+        t94 = t73 + t78 - t81 + t74 - t80 - t84 - t75 + t83 + t71;
+        t98 = Rm + km;
+        t99 = cos(t98);
+        t105 = sin(t98);
+        t111 = sin(t89);
+        t115 = exp(-Rp - B);
+        t117 = B - Rp;
+        t118 = Rm * t117;
+        t121 = t41 - 0.2e1 * Rp * B + t2 - t3 - t4;
+        t123 = t118 * t121 * AA;
+        t124 = 0.2e1 * t76;
+        t125 = t40 + t124 + t1;
+        t131 = -t124 + t40 + t1;
+        t141 = t118 * t121 * BB;
+        t152 = exp(-0.3e1 * Rp - B);
+        t171 = exp(-0.4e1 * Rp);
+        _C4 = (((-0.2e1 * t1 * (t2 - t3 - t4 + 0.5e1 * t5) * AA + 0.8e1 * B * BB * t12 * Rp) * t18 +
+                (-0.2e1 * Rp * (-0.2e1 * t5 * Rp - 0.2e1 * t22 + t4 * B - 0.3e1 * t25 + t27 + t2 * B) * AA -
+                 0.8e1 * t33 * BB * Rp) * t38 + 0.2e1 * t40 * (t41 + t4 + t2 - t3) * AA -
+                0.8e1 * t5 * BB * t12) * t51 +
+               ((t69 * AA - 0.2e1 * t85 * BB) * t90 + (t92 * AA + 0.2e1 * t94 * BB) * t99 +
+                (-0.2e1 * t94 * AA + t92 * BB) * t105 + (-0.2e1 * t85 * AA - t69 * BB) * t111) * t115 +
+               ((-t123 + 0.2e1 * t118 * t125 * BB) * t90 + (-t123 - 0.2e1 * t118 * t131 * BB) * t99 +
+                (0.2e1 * t118 * t131 * AA - t141) * t105 + (0.2e1 * t118 * t125 * AA + t141) * t111) * t152 -
+               0.2e1 * t123 + 0.8e1 * t40 * km * t117 * BB) /
+              (((-0.8e1 * t2 - 0.8e1 * t5) * t4 * t18 + 0.8e1 * t74 + 0.8e1 * t82) * t51 +
+               (0.4e1 * t71 - 0.4e1 * t74) * t171 + 0.4e1 * t71 - 0.4e1 * t74);
+
+        /******************************************************************/
+        /******************************************************************/
+
+        /*******************************************/
+        /*       calculate the velocities etc      */
+        /*******************************************/
+
+        t2 = exp(UU * z);
+        t3 = Rm * z;
+        t4 = cos(t3);
+        t6 = sin(t3);
+        t11 = exp(-VV * z);
+        t18 = exp(-0.2e1 * z * B);
+        t19 = km * z;
+        t20 = cos(t19);
+        t22 = sin(t19);
+        u1 = kn * (t2 * (_C1 * t4 + _C2 * t6) + t11 * (_C3 * t4 + _C4 * t6) + t18 * (AA * t20 + BB * t22));
+
+        t1 = Rm * z;
+        t2 = cos(t1);
+        t4 = sin(t1);
+        t14 = exp(UU * z);
+        t26 = exp(-VV * z);
+        t28 = km * z;
+        t29 = cos(t28);
+        t31 = sin(t28);
+        t43 = exp(-0.2e1 * z * B);
+        u2 = (-UU * (_C1 * t2 + _C2 * t4) + _C1 * t4 * Rm - _C2 * t2 * Rm) * t14 +
+             (VV * (_C3 * t2 + _C4 * t4) + _C3 * t4 * Rm - _C4 * t2 * Rm) * t26 +
+             (0.2e1 * B * (AA * t29 + BB * t31) + AA * t31 * km - BB * t29 * km) * t43;
+
+        t2 = 0.2e1 * z * B;
+        t3 = exp(t2);
+        t4 = t3 * kn;
+        t5 = Rm * z;
+        t6 = cos(t5);
+        t8 = sin(t5);
+        t18 = exp(UU * z);
+        t31 = exp(-VV * z);
+        t34 = km * z;
+        t35 = cos(t34);
+        t37 = sin(t34);
+        t47 = exp(-t2);
+        u3 = 0.2e1 * t4 * (UU * (_C1 * t6 + _C2 * t8) - _C1 * t8 * Rm + _C2 * t6 * Rm) * t18 +
+             0.2e1 * t4 * (-VV * (_C3 * t6 + _C4 * t8) - _C3 * t8 * Rm + _C4 * t6 * Rm) * t31 +
+             0.2e1 * t4 * (-0.2e1 * B * (AA * t35 + BB * t37) - AA * t37 * km + BB * t35 * km) * t47;
+
+        t1 = Rm * Rm;
+        t3 = UU * UU;
+        t8 = kn * kn;
+        t11 = Rm * z;
+        t12 = sin(t11);
+        t14 = cos(t11);
+        t20 = t14 * Rm;
+        t27 = 0.2e1 * z * B;
+        t28 = exp(t27);
+        t31 = exp(UU * z);
+        t38 = VV * VV;
+        t54 = exp(-VV * z);
+        t56 = km * km;
+        t59 = B * B;
+        t66 = km * z;
+        t67 = sin(t66);
+        t69 = cos(t66);
+        t83 = exp(-t27);
+        u4 = ((_C2 * t1 - t3 * _C2 + 0.2e1 * UU * _C1 * Rm - _C2 * t8) * t12 + _C1 * t14 * t1 - t3 * _C1 * t14 -
+              0.2e1 * UU * _C2 * t20 - t8 * _C1 * t14) * t28 * t31 +
+             ((-0.2e1 * VV * _C3 * Rm + _C4 * t1 - _C4 * t8 - t38 * _C4) * t12 + 0.2e1 * VV * _C4 * t20 +
+              _C3 * t14 * t1 - t8 * _C3 * t14 - t38 * _C3 * t14) * t28 * t54 +
+             ((BB * t56 - t8 * BB - 0.4e1 * t59 * BB - 0.4e1 * B * AA * km) * t67 + AA * t69 * t56 -
+              t8 * AA * t69 - 0.4e1 * t59 * AA * t69 + 0.4e1 * B * BB * t69 * km) * t28 * t83;
+
+
+        t1 = Rm * z;
+        t2 = sin(t1);
+        t3 = Rm * Rm;
+        t4 = t3 * Rm;
+        t5 = t2 * t4;
+        t6 = UU * UU;
+        t7 = t6 * UU;
+        t8 = cos(t1);
+        t15 = 0.2e1 * B * t8 * t3;
+        t19 = B * UU;
+        t20 = t2 * Rm;
+        t23 = kn * kn;
+        t24 = B * t23;
+        t26 = 0.2e1 * t24 * t8;
+        t27 = t23 * UU;
+        t29 = B * t6;
+        t33 = t23 * t2 * Rm;
+        t35 = 0.1e1 / kn;
+        t42 = 0.2e1 * B * t2 * t3;
+        t43 = t8 * t4;
+        t45 = 0.2e1 * t24 * t2;
+        t52 = t23 * t8 * Rm;
+        t53 = t8 * Rm;
+        t64 = 0.2e1 * z * B;
+        t65 = exp(t64);
+        t68 = exp(UU * z);
+        t70 = B * VV;
+        t76 = t23 * VV;
+        t78 = VV * VV;
+        t79 = t78 * VV;
+        t84 = B * t78;
+        t108 = exp(-VV * z);
+        t111 = km * z;
+        t112 = sin(t111);
+        t113 = km * km;
+        t118 = cos(t111);
+        t119 = t118 * km;
+        t121 = B * B;
+        t123 = t112 * km;
+        t130 = t113 * km;
+        t148 = exp(-t64);
+        u5 = (-(-t5 - t7 * t8 + 0.3e1 * UU * t8 * t3 + t15 + 0.3e1 * t6 * t2 * Rm + 0.4e1 * t19 * t20 - t26 +
+                t27 * t8 - 0.2e1 * t29 * t8 - t33) * t35 * _C1 -
+              (-t7 * t2 + t27 * t2 + t42 + t43 - t45 + 0.3e1 * UU * t2 * t3 - 0.2e1 * t29 * t2 + t52 -
+               0.4e1 * t19 * t53 - 0.3e1 * t6 * t8 * Rm) * t35 * _C2) * t65 * t68 +
+             (-(t15 - 0.4e1 * t70 * t20 - t33 - 0.3e1 * VV * t8 * t3 - t76 * t8 + t79 * t8 +
+                0.3e1 * t78 * t2 * Rm - 0.2e1 * t84 * t8 - t26 - t5) * t35 * _C3 -
+              (t52 - 0.3e1 * VV * t2 * t3 + t79 * t2 + 0.4e1 * t70 * t53 - 0.3e1 * t78 * t8 * Rm -
+               0.2e1 * t84 * t2 + t43 - t76 * t2 + t42 - t45) * t35 * _C4) * t65 * t108 - t65 *
+             (-0.4e1 * B * BB *
+              t112 * t113 +
+              t23 * BB * t119 +
+              0.4e1 * t121 * AA *
+              t123 -
+              0.4e1 * t121 * BB *
+              t119 +
+              BB * t118 * t130 -
+              AA * t112 * t130 -
+              0.4e1 * B * AA *
+              t118 * t113 -
+              t23 * AA * t123 -
+              0.4e1 * t24 * AA *
+              t118 -
+              0.4e1 * t24 * BB *
+              t112) * t35 * t148;
+
+
+        t2 = 0.2e1 * z * B;
+        t3 = exp(t2);
+        t4 = t3 * kn;
+        t5 = Rm * z;
+        t6 = cos(t5);
+        t8 = sin(t5);
+        t18 = exp(UU * z);
+        t31 = exp(-VV * z);
+        t34 = km * z;
+        t35 = cos(t34);
+        t37 = sin(t34);
+        t47 = exp(-t2);
+        u6 = -0.2e1 * t4 * (UU * (_C1 * t6 + _C2 * t8) - _C1 * t8 * Rm + _C2 * t6 * Rm) * t18 -
+             0.2e1 * t4 * (-VV * (_C3 * t6 + _C4 * t8) - _C3 * t8 * Rm + _C4 * t6 * Rm) * t31 -
+             0.2e1 * t4 * (-0.2e1 * B * (AA * t35 + BB * t37) - AA * t37 * km + BB * t35 * km) * t47;
+
+
+
+
+        /******************************************************************/
+        /******************************************************************/
+
+
+
+        sum5 += u5 * cos(n * M_PI * x);  /* pressure */
+        u6 -= u5; /* get total stress */
+        sum6 += u6 * cos(n * M_PI * x);  /* xx stress */
+
+        u1 *= cos(n * M_PI * x); /* z velocity */
+        sum1 += u1;
+        u2 *= sin(n * M_PI * x); /* x velocity */
+        sum2 += u2;
+        u3 -= u5; /* get total stress */
+        u3 *= cos(n * M_PI * x); /* zz stress */
+        sum3 += u3;
+        u4 *= sin(n * M_PI * x); /* zx stress */
+        sum4 += u4;
+
+        rho = -sigma * sin(km * z) * cos(kn * x); /* density */
+        sum7 += rho;
+
+        SS = exp(UU * z) * (_C1 * cos(Rm * z) + _C2 * sin(Rm * z)) +
+             exp(-VV * z) * (_C3 * cos(Rm * z) + _C4 * sin(Rm * z)) +
+             exp(-2 * z * B) * (AA * cos(km * z) + BB * sin(km * z));
+        SS *= sin(kn * x); /* stream function */
+
+        //mag = sqrt(u1 * u1 + u2 * u2);
+        /*printf("%0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f\n",x,z,sum1,sum2,sum3,sum4,sum5,sum6,mag,sum7,SS);*/
+
+
+        /* Output */
+        if (vel != nullptr)
+          {
+            vel[0] = sum2;
+            vel[1] = sum1;
+          }
+        if (presssure != nullptr)
+          {
+            (*presssure) = sum5;
+          }
+        if (total_stress != nullptr)
+          {
+            total_stress[0] = sum6;
+            total_stress[1] = sum3;
+            total_stress[2] = sum4;
+          }
+        if (strain_rate != nullptr)
+          {
+            /* sigma = tau - p, tau = sigma + p, tau[] = 2*eta*strain_rate[] */
+            Z = exp(2.0 * B * z);
+            strain_rate[0] = (sum6 + sum5) / (2.0 * Z);
+            strain_rate[1] = (sum3 + sum5) / (2.0 * Z);
+            strain_rate[2] = (sum4) / (2.0 * Z);
+          }
+        /* Value checks, could be cleaned up if needed. Julian Giordani 9-Oct-2006*/
+        if (fabs(sum5 - (-0.5 * (sum6 + sum3))) > 1e-5)
+          {
+            assert(0);
+          }
+      }
+
+
+
+      /**
+       * The exact solution for the SolKz benchmark.
+       */
+      template <int dim>
+      class FunctionSolKz : public Function<dim>
+      {
+        public:
+          FunctionSolKz(unsigned int n_components) : Function<dim>(n_components) {}
+
+          void vector_value(const Point<dim> &p,
+                            Vector<double> &values) const override
+          {
+            double pos[2] = {p(0), p(1)};
+            double total_stress[3], strain_rate[3];
+            static const double B = 0.5 * std::log(1e6);
+            AnalyticSolutions::_Velic_solKz
+            (pos,
+             1.0, 2, 3,
+             B,
+             &values[0], &values[2], total_stress, strain_rate);
+          }
+      };
+
+
+    }
+
+
+
+    template <int dim>
+    class SolKzMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+
+              const Point<dim> &pos = in.position[i];
+
+              static const double B = 0.5 * std::log(1e6);
+              out.viscosities[i] = std::exp(2 * B * pos[1]);
+
+              out.densities[i] = -std::sin(2 * pos[1]) * std::cos(3 * numbers::PI * pos[0]);
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible() const override
+        {
+          return false;
+        }
+        /**
+         * @}
+         */
+
+        void
+        parse_parameters(ParameterHandler &/*prm*/) override
+        {
+          // Declare dependencies on solution variables
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+    };
+
+
+
+    /**
+     * A postprocessor that evaluates the accuracy of the solution.
+     *
+     * The implementation of error evaluators that correspond to the
+     * benchmarks defined in the paper Duretz et al. reference above.
+     */
+    template <int dim>
+    class SolKzPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string, std::string>
+        execute(TableHandler &/*statistics*/) override
+        {
+          AnalyticSolutions::FunctionSolKz<dim> ref_func(this->introspection().n_components);
+
+          AssertThrow(Plugins::plugin_type_matches<const SolKzMaterial<dim>>(this->get_material_model()),
+                      ExcMessage(
+                        "Postprocessor SolKzPostprocessor only works with the material model SolKzn."));
+
+          const QGauss<dim> quadrature_formula(this->introspection().polynomial_degree.velocities + 2);
+
+          Vector<float> cellwise_errors_u(this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_p(this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_ul2(this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_pl2(this->get_triangulation().n_active_cells());
+
+          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0, dim),
+                                              this->get_fe().n_components());
+          ComponentSelectFunction<dim> comp_p(dim,
+                                              this->get_fe().n_components());
+
+          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
+                                            this->get_solution(),
+                                            ref_func,
+                                            cellwise_errors_u,
+                                            quadrature_formula,
+                                            VectorTools::L1_norm,
+                                            &comp_u);
+          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
+                                            this->get_solution(),
+                                            ref_func,
+                                            cellwise_errors_p,
+                                            quadrature_formula,
+                                            VectorTools::L1_norm,
+                                            &comp_p);
+          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
+                                            this->get_solution(),
+                                            ref_func,
+                                            cellwise_errors_ul2,
+                                            quadrature_formula,
+                                            VectorTools::L2_norm,
+                                            &comp_u);
+          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
+                                            this->get_solution(),
+                                            ref_func,
+                                            cellwise_errors_pl2,
+                                            quadrature_formula,
+                                            VectorTools::L2_norm,
+                                            &comp_p);
+
+          const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+          const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+          std::ostringstream os;
+          os << std::scientific << u_l1
+             << ", " << p_l1
+             << ", " << u_l2
+             << ", " << p_l2;
+
+          return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
+        }
+    };
+
+  }
+}
+
+#endif
diff --git a/benchmarks/solkz/solkz.prm.bak b/benchmarks/solkz/solkz.prm.bak
new file mode 100644
index 00000000000..399ef6b1f1c
--- /dev/null
+++ b/benchmarks/solkz/solkz.prm.bak
@@ -0,0 +1,62 @@
+# A description of the SolKZ benchmark for which a known solution
+# is available. See the manual for more information.
+
+set Additional shared libraries            = ./libsolkz.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = SolKzPostprocessor, visualization
+end
diff --git a/benchmarks/solubility/plugin/solubility.cc b/benchmarks/solubility/plugin/solubility.cc
index c899cb5ed8c..896ed59ffa9 100644
--- a/benchmarks/solubility/plugin/solubility.cc
+++ b/benchmarks/solubility/plugin/solubility.cc
@@ -359,7 +359,7 @@ namespace aspect
     melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
                     std::vector<double> &melt_fractions) const
     {
-      for (unsigned int q=0; q<in.temperature.size(); ++q)
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
         {
           const unsigned int water_idx = this->introspection().compositional_index_for_name("water_content");
           const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
@@ -399,7 +399,7 @@ namespace aspect
       if (this->get_parameters().use_operator_splitting
           && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
         {
-          const unsigned int n_points = out.viscosities.size();
+          const unsigned int n_points = out.n_evaluation_points();
           out.additional_outputs.push_back(
             std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
         }
diff --git a/benchmarks/solubility/plugin/solubility.cc.bak b/benchmarks/solubility/plugin/solubility.cc.bak
new file mode 100644
index 00000000000..c899cb5ed8c
--- /dev/null
+++ b/benchmarks/solubility/plugin/solubility.cc.bak
@@ -0,0 +1,424 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/melt.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <array>
+#include <utility>
+#include <limits>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * Volatiles material model.
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class Volatiles : public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>, public MaterialModel::MeltFractionModel<dim>
+    {
+      public:
+        /**
+         * Initialize the base model at the beginning of the run.
+         */
+        void initialize() override;
+
+        /**
+         * Update the base model at the beginning of each timestep.
+         */
+        void update() override;
+
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void
+        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
+                  typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * Method that indicates whether material is compressible. The model is compressible
+         * if and only if base model is compressible.
+         */
+        bool is_compressible () const override;
+
+        /**
+         * Compute the free fluid fraction that can be present in the material based on the
+         * fluid content of the material and the fluid solubility for the given input conditions.
+         * @p in and @p melt_fractions need to have the same size.
+         *
+         * @param in Object that contains the current conditions.
+         * @param melt_fractions Vector of doubles that is filled with the
+         * allowable free fluid fraction for each given input conditions.
+         */
+        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                             std::vector<double> &melt_fractions) const override;
+
+        double reference_darcy_coefficient () const override;
+
+        /**
+         * Method to declare parameters related to volatile model
+         */
+        static void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Method to parse parameters related to volatile model
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+      private:
+        /**
+         * Pointer to the material model used as the base model
+         */
+        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
+
+        // Variables that describe the properties of the fluid, i.e. its density,
+        // viscosity, and compressibility.
+        // Properties of the solid are defined in the base model.
+        double reference_rho_f;
+        double eta_f;
+        double fluid_compressibility;
+
+        // Material properties governing the transport of the fluid with respect
+        // to the solid, i.e., the bulk viscosity (relative to the shear viscosity),
+        // the permeability, and how much the solid viscosity changes in the presence
+        // of fluids.
+        double shear_to_bulk_viscosity_ratio;
+        double reference_permeability;
+        double alpha_phi;
+
+        // Time scale for fluid release and absorption.
+        double fluid_reaction_time_scale;
+    };
+
+
+
+    template <int dim>
+    void
+    Volatiles<dim>::initialize()
+    {
+      base_model->initialize();
+    }
+
+
+
+    template <int dim>
+    void
+    Volatiles<dim>::update()
+    {
+      base_model->update();
+    }
+
+
+
+    template <int dim>
+    void
+    Volatiles<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                             typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      base_model->evaluate(in,out);
+
+      // Modify the viscosity from the base model based on the presence of fluid.
+      const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+      if (in.requests_property(MaterialProperties::viscosity))
+        {
+          // Scale the base model viscosity value based on the porosity.
+          for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
+            {
+              const double porosity = std::max(in.composition[q][porosity_idx],0.0);
+              out.viscosities[q] *= (1.0 - porosity) * exp(- alpha_phi * porosity);
+            }
+        }
+
+      // Fill the melt outputs if they exist. Note that the MeltOutputs class was originally
+      // designed for two-phase flow material models in ASPECT that model the flow of melt,
+      // but can be reused for a geofluid of arbitrary composition.
+      MeltOutputs<dim> *fluid_out = out.template get_additional_output<MeltOutputs<dim>>();
+
+      if (fluid_out != nullptr)
+        {
+          for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
+            {
+              double porosity = std::max(in.composition[q][porosity_idx],0.0);
+
+              fluid_out->fluid_viscosities[q] = eta_f;
+              fluid_out->permeabilities[q] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+
+              fluid_out->fluid_densities[q] = reference_rho_f * std::exp(fluid_compressibility * (in.pressure[q] - this->get_surface_pressure()));
+
+              if (in.requests_property(MaterialProperties::viscosity))
+                {
+                  const double phi_0 = 0.05;
+                  porosity = std::max(porosity,1e-8);
+                  fluid_out->compaction_viscosities[q] = out.viscosities[q] * shear_to_bulk_viscosity_ratio * phi_0/porosity;
+                }
+            }
+        }
+
+      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
+      const unsigned int water_idx = this->introspection().compositional_index_for_name("water_content");
+
+      // Fill reaction rate outputs if the model uses operator splitting.
+      // Specifically, change the porosity (representing the amount of free water)
+      // based on the water solubility and the water content.
+      if (this->get_parameters().use_operator_splitting && reaction_rate_out != nullptr)
+        {
+          std::vector<double> eq_free_fluid_fractions(out.n_evaluation_points());
+          melt_fractions(in, eq_free_fluid_fractions);
+
+          for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
+            for (unsigned int c=0; c<in.composition[q].size(); ++c)
+              {
+                double porosity_change = eq_free_fluid_fractions[q] - in.composition[q][porosity_idx];
+                // do not allow negative porosity
+                if (in.composition[q][porosity_idx] + porosity_change < 0)
+                  porosity_change = -in.composition[q][porosity_idx];
+
+                if (c == water_idx && this->get_timestep_number() > 0)
+                  reaction_rate_out->reaction_rates[q][c] = - porosity_change / fluid_reaction_time_scale
+                                                            + in.composition[q][water_idx] * trace(in.strain_rate[q]);
+                else if (c == porosity_idx && this->get_timestep_number() > 0)
+                  reaction_rate_out->reaction_rates[q][c] = porosity_change / fluid_reaction_time_scale;
+                else
+                  reaction_rate_out->reaction_rates[q][c] = 0.0;
+              }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Volatiles<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Volatile model");
+        {
+          prm.declare_entry("Base model","visco plastic",
+                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
+                            "The name of a material model that will be modified by the "
+                            "addition of fluids. Valid values for this parameter "
+                            "are the names of models that are also valid for the "
+                            "``Material models/Model name'' parameter. See the documentation for "
+                            "that for more information.");
+          prm.declare_entry ("Reference fluid density", "2500",
+                             Patterns::Double (0),
+                             "Reference density of the melt/fluid$\\rho_{f,0}$. Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Shear to bulk viscosity ratio", "0.1",
+                             Patterns::Double (0),
+                             "Ratio between shear and bulk viscosity at the reference "
+                             "permeability $\\phi_0=0.05$. The bulk viscosity additionally "
+                             "scales with $\\phi_0/\\phi$. The shear viscosity is read in "
+                             "from the base model. Units: dimensionless.");
+          prm.declare_entry ("Reference fluid viscosity", "10",
+                             Patterns::Double (0),
+                             "The value of the constant melt/fluid viscosity $\\eta_f$. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Exponential fluid weakening factor", "27",
+                             Patterns::Double (0),
+                             "The porosity dependence of the viscosity. Units: dimensionless.");
+          prm.declare_entry ("Reference permeability", "1e-8",
+                             Patterns::Double(),
+                             "Reference permeability of the solid host rock."
+                             "Units: \\si{\\meter\\squared}.");
+          prm.declare_entry ("Fluid compressibility", "0.0",
+                             Patterns::Double (0),
+                             "The value of the compressibility of the fluid. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("Fluid reaction time scale for operator splitting", "1e3",
+                             Patterns::Double (0),
+                             "In case the operator splitting scheme is used, the porosity field can not "
+                             "be set to a new equilibrium fluid fraction instantly, but the model has to "
+                             "provide a reaction time scale instead. This time scale defines how fast fluid "
+                             "release and absorption happen, or more specifically, the parameter defines the "
+                             "time after which the deviation of the porosity from the free fluid fraction "
+                             "that would be in equilibrium with the solid will be reduced to a fraction of "
+                             "$1/e$. So if the fluid reaction time scale is small compared "
+                             "to the time step size, the reaction will be so fast that the porosity is very "
+                             "close to this equilibrium value after reactions are computed. Conversely, "
+                             "if the fluid reaction time scale is large compared to the time step size, almost no "
+                             "fluid release and absorption will occur."
+                             "\n\n"
+                             "Also note that the fluid reaction time scale has to be larger than or equal to the reaction "
+                             "time step used in the operator splitting scheme, otherwise reactions can not be "
+                             "computed. If the model does not use operator splitting, this parameter is not used. "
+                             "Units: yr or s, depending on the ``Use years "
+                             "in output instead of seconds'' parameter.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Volatiles<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Volatile model");
+        {
+          AssertThrow( prm.get("Base model") != "volatiles",
+                       ExcMessage("You may not use ``volatiles'' as the base model for "
+                                  "a the volatile model itself.") );
+
+          reference_rho_f                   = prm.get_double ("Reference fluid density");
+          shear_to_bulk_viscosity_ratio     = prm.get_double ("Shear to bulk viscosity ratio");
+          eta_f                             = prm.get_double ("Reference fluid viscosity");
+          reference_permeability            = prm.get_double ("Reference permeability");
+          alpha_phi                         = prm.get_double ("Exponential fluid weakening factor");
+          fluid_compressibility             = prm.get_double ("Fluid compressibility");
+          fluid_reaction_time_scale         = prm.get_double ("Fluid reaction time scale for operator splitting");
+
+          // Create the base model and initialize its SimulatorAccess base
+          // class; it will get a chance to read its parameters below after we
+          // leave the current section.
+          base_model = create_material_model<dim>(prm.get("Base model"));
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
+            sim->initialize_simulator (this->get_simulator());
+
+          if (this->convert_output_to_years() == true)
+            fluid_reaction_time_scale *= year_in_seconds;
+
+          if (this->get_parameters().use_operator_splitting)
+            {
+              AssertThrow(fluid_reaction_time_scale >= this->get_parameters().reaction_time_step,
+                          ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
+                                     + " in the operator splitting scheme is too large to compute melting rates! "
+                                     "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
+                                     "operator splitting' chosen in the material model, which is currently "
+                                     + Utilities::to_string(fluid_reaction_time_scale) + "."));
+              AssertThrow(fluid_reaction_time_scale > 0,
+                          ExcMessage("The Fluid reaction time scale for operator splitting must be larger than 0!"));
+            }
+
+          AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                      ExcMessage("Material model Volatiles only "
+                                 "works if there is a compositional field called porosity."));
+
+          AssertThrow(this->introspection().compositional_name_exists("water_content"),
+                      ExcMessage("Material model Volatiles only "
+                                 "works if there is a compositional field called water_content."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // After parsing the parameters for this model, parse parameters related to the base model.
+      base_model->parse_parameters(prm);
+      this->model_dependence = base_model->get_model_dependence();
+    }
+
+
+
+    template <int dim>
+    bool
+    Volatiles<dim>::
+    is_compressible () const
+    {
+      return base_model->is_compressible();
+    }
+
+
+
+    template <int dim>
+    void
+    Volatiles<dim>::
+    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                    std::vector<double> &melt_fractions) const
+    {
+      for (unsigned int q=0; q<in.temperature.size(); ++q)
+        {
+          const unsigned int water_idx = this->introspection().compositional_index_for_name("water_content");
+          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+          // A very simple model for water solubility:
+          // There are three layers, the top layer (<30 km depth) and the bottom layer (>60 km depth)
+          // can accommodate an unlimited amount of bound water (equivalent to a zero porosity).
+          // The middle layer between the two can not accommodate any water, therefore, any water
+          // present will be in the form of free water (and the porosity equals the total water available,
+          // which is the sum free and bound water, i.e. porosity + water_content.
+          if (this->get_geometry_model().depth(in.position[q]) < 3e4
+              || this->get_geometry_model().depth(in.position[q]) > 6e4)
+
+            melt_fractions[q] = 0.0;
+          else
+            melt_fractions[q] = in.composition[q][water_idx] + in.composition[q][porosity_idx];
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    Volatiles<dim>::
+    reference_darcy_coefficient () const
+    {
+      // 0.01 = 1% melt
+      return reference_permeability * std::pow(0.01,3.0) / eta_f;
+    }
+
+
+
+    template <int dim>
+    void
+    Volatiles<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (this->get_parameters().use_operator_splitting
+          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.viscosities.size();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Volatiles,
+                                   "volatiles",
+                                   "Material model that is designed to advect fluids and compute "
+                                   "fluid release and absorption based on a very simple model for "
+                                   "water solubility consisting of three layers with water only being "
+                                   "present as a free phase in the middle layer. "
+                                   "The properties of the solid can be taken from another material "
+                                   "model that is used as a base model.")
+  }
+}
diff --git a/benchmarks/solubility/solubility.prm.bak b/benchmarks/solubility/solubility.prm.bak
new file mode 100644
index 00000000000..aa8fa56c0be
--- /dev/null
+++ b/benchmarks/solubility/solubility.prm.bak
@@ -0,0 +1,162 @@
+# This is a 1D test case for the solubility of fluids in interaction
+# with porous flow. Material with a given water content flows into the
+# model from the bottom. The model has three layers with different
+# water solubility, specifically, an infinite solubility above 30 km
+# depth and below 60 km depth, and a zero solubility in between. When
+# the upwelling material reaches the boundary at 60 km depth, water is
+# being released and can move relative to the solid as a free fluid
+# phase. Due to its lower density, it moves upwards twice as fast as the
+# solid, until it reaches 30 km depth where it is reabsorbed into the
+# solid. In steady state, the water content should be the same in the
+# top and bottom layer, and in the middle layer it should be zero (at
+# least the water_content field, representing the bound water in the
+# solid). The porosity (free water) should be 0.1, which is half of the
+# bound water content in the upper and lower layer (which follows from
+# mass conservation, since the free fluid moves twice as fast).
+
+set Additional shared libraries            = ./plugin/libsolubility.so
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = output
+set Max nonlinear iterations               = 10
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+set End time                               = 6e6
+
+# Because the model includes reactions that might be on a faster time scale
+# than the time step of the model (melting and the freezing of melt), we use
+# the operator splitting scheme.
+set Use operator splitting                     = true
+
+# There are two compositional fields, one that tracks the amount of free water
+# (the porosity) and one that tracks the amount of bound water (the water_content).
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, water_content
+end
+
+# Initially, there is no free water (the porosity is zero) and the water content
+# of the material is 1%.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0; 0.01
+  end
+end
+
+# The material flowing in from the bottom has the same water content as prescribed
+# in the initial condition.
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = bottom
+  set List of model names = initial composition
+end
+
+# We prescribe an upwelling velocity of 1 cm/yr at the bottom,
+# the left and right boundaries are closed and the top is open.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Prescribed velocity boundary indicators = bottom:function
+
+  subsection Function
+    set Function expression = 0; 1e-2
+  end
+end
+
+# The model is 1 km wide and extends 100 km in vertical direction.
+# This is because for this specific test material model, the transitions
+# between the three layers with different water solubilities are at
+# 30 km and 60 km depth.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2e2
+    set Y extent  = 1e5
+    set Y repetitions = 500
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# The temperature is not important for this model, so we simply
+# set it to 1600 K everywhere (including the boundary).
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Maximal temperature = 1600
+    set Minimal temperature = 1600
+  end
+end
+
+# We use a custom material model that implements the layers with
+# different solubility.
+subsection Material model
+  set Model name = volatiles
+
+  subsection Volatile model
+    set Base model = visco plastic
+    set Reference fluid density = 2995
+    set Shear to bulk viscosity ratio = 0.1
+    set Reference fluid viscosity = 10
+    set Reference permeability = 2.5e-6
+    set Exponential fluid weakening factor = 27
+    set Fluid reaction time scale for operator splitting = 5e4
+  end
+
+  subsection Visco Plastic
+    set Reference temperature                   = 1600
+    set Prefactors for diffusion creep          = 5e-21
+    set Viscous flow law = diffusion
+    set Densities                   = 3000
+    set Viscosity averaging scheme  = harmonic
+    set Minimum viscosity           = 1e19
+    set Maximum viscosity           = 1e19
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 0
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties, melt fraction
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Interpolate output            = false
+
+    subsection Melt material properties
+      set List of properties          = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
diff --git a/benchmarks/tangurnis/ba/tan.prm.bak b/benchmarks/tangurnis/ba/tan.prm.bak
new file mode 100644
index 00000000000..73442056e32
--- /dev/null
+++ b/benchmarks/tangurnis/ba/tan.prm.bak
@@ -0,0 +1,130 @@
+# Listing of Parameters
+# ---------------------
+
+set Additional shared libraries            = ./code/libtangurnis.so
+set Dimension                              = 2
+set CFL number                             = 1.0
+
+# We only need a single time step.
+set Start time                             = 0
+set End time                               = 0.0001
+
+# The temperature is prescibed, so we only need to
+# solve the Stokes system
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+
+# In this section we define the adiabatic profiles of temperature,
+# pressure and density. The temperature and pressure profiles are
+# not used for this benchmark (and set to zero).
+# gamma is the grueneisen parameter, which defines the compressibility
+# of the material, and we have to choose the same value for gamma as
+# in the material model below.
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=0.0, gamma=1.0
+    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+# This case of the benchmark uses the Boussinesq approximation.
+subsection Formulation
+  set Formulation              = custom # equivalent to Boussinesq approximation
+  set Mass conservation        = incompressible
+  set Temperature equation     = reference density profile
+end
+
+# We define our own boundary condition that implements a boundary
+# temperature according to the prescibed temperature of the Tan & Gurnis
+# benchmark.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left, right, bottom, top
+  set List of model names = Tan Gurnis
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+# The model domain is the unit square.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*y)*cos(pi*1*x)
+  end
+end
+
+# The benchmark is defined in terms of the nondimensional numbers
+# Di (dissipation number) and gamma (grueneisen parameter).
+# As ASPECT uses physical properties instead of these dimensionless
+# numbers in its equations, we replicate the benchmark formulation
+# by using a new material model that fixes all of the material
+# constants to 1, except for the thermal expansivity and the viscosity,
+# which is set to Di, and the density profile, which depends on Di and
+# gamma.
+# For the Boussinesq case, Di=0 and gamma=infinity, and all parameters
+# are constant, except for the density, which depends on the temperature.
+subsection Material model
+  set Model name = Tan Gurnis
+
+  subsection Tan Gurnis model
+    set Di                            = 0
+    set gamma                         = 1 # infinity really, but is not used if Di=0
+    set a                             = 0   # constant viscosity
+    set wavenumber                    = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  set List of postprocessors = Tan Gurnis error, visualization
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/benchmarks/tangurnis/code/tangurnis.cc.bak b/benchmarks/tangurnis/code/tangurnis.cc.bak
new file mode 100644
index 00000000000..d4c6c372457
--- /dev/null
+++ b/benchmarks/tangurnis/code/tangurnis.cc.bak
@@ -0,0 +1,461 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/geometry_model/box.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+#include <deal.II/base/signaling_nan.h>
+
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+
+
+  /**
+   * This benchmark is from the article
+   * @code
+   *  @article{tan2007compressible,
+   *    title={Compressible thermochemical convection and application to lower mantle structures},
+   *    author={Tan, E. and Gurnis, M.},
+   *    journal={JOURNAL OF GEOPHYSICAL RESEARCH-ALL SERIES-},
+   *    volume={112},
+   *    number={B6},
+   *    pages={6304},
+   *    year={2007},
+   *    publisher={AGU AMERICAN GEOPHYSICAL UNION}
+   *    }
+   * @endcode
+   *
+   * @ingroup Postprocessing
+   */
+
+
+
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    class TanGurnis : public MaterialModel::Interface<dim>
+    {
+      public:
+
+        TanGurnis();
+
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              /**
+               * @name Physical parameters used in the basic equations
+               * @{
+               */
+
+              const Point<dim> &pos = in.position[i];
+              const double depth = 1.0 - pos[dim-1];
+              const double temperature = sin(numbers::PI*pos(dim-1))*cos(numbers::PI*wavenumber*pos(0));
+
+              out.viscosities[i] = ( Di==0.0 ? 1.0 : Di ) * exp( a * depth );
+              out.densities[i] = ( Di==0.0 ? 1.0 : Di ) * (-1.0 * temperature ) * exp( Di/gamma * (depth) );
+              out.specific_heat[i] = 1.0;
+              out.thermal_conductivities[i] = 1.0;
+              out.thermal_expansion_coefficients[i] = ( Di==0.0 ) ? 1.0 : Di;
+              out.compressibilities[i] = numbers::signaling_nan<double>();;
+            }
+        }
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+
+        double parameter_a() const;
+        double parameter_wavenumber() const;
+        double parameter_Di() const;
+        double parameter_gamma() const;
+
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+
+        double a;
+        double wavenumber;
+        double Di;
+        double gamma;
+
+    };
+
+    template <int dim>
+    TanGurnis<dim>::TanGurnis()
+    {
+      // a=0 for a constant viscosity or
+      // a=2 for a depth-dependent viscosity (case tala_c)
+      a=0;
+
+      // for BA: Di=0; gamma=inf
+      // however, we do not use gamma if Di=0, so the actual value does not matter
+
+      //TALA:
+      Di=0.5;
+      gamma=1.0;
+
+      wavenumber=1;
+    }
+
+
+    template <int dim>
+    bool
+    TanGurnis<dim>::
+    is_compressible () const
+    {
+      return Di != 0.0;
+    }
+
+
+
+    template <int dim>
+    double
+    TanGurnis<dim>::
+    parameter_a() const
+    {
+      return a;
+    }
+
+
+
+    template <int dim>
+    double
+    TanGurnis<dim>::
+    parameter_wavenumber() const
+    {
+      return wavenumber;
+    }
+
+
+
+    template <int dim>
+    double
+    TanGurnis<dim>::
+    parameter_Di() const
+    {
+      return Di;
+    }
+
+
+
+    template <int dim>
+    double
+    TanGurnis<dim>::
+    parameter_gamma() const
+    {
+      return gamma;
+    }
+
+
+
+    template <int dim>
+    void
+    TanGurnis<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Tan Gurnis model");
+        {
+          prm.declare_entry ("a", "0",
+                             Patterns::Double (0),
+                             "");
+          prm.declare_entry ("Di", "0.5",
+                             Patterns::Double (0),
+                             "");
+          prm.declare_entry ("gamma", "1",
+                             Patterns::Double (0),
+                             "");
+          prm.declare_entry ("wavenumber", "1",
+                             Patterns::Double (0),
+                             "");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    TanGurnis<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Tan Gurnis model");
+        {
+          a                       = prm.get_double("a");
+          Di                      = prm.get_double("Di");
+          gamma                   = prm.get_double("gamma");
+          wavenumber              = prm.get_double("wavenumber");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.density = NonlinearDependence::none;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+    }
+  }
+
+
+  /**
+   * A class that implements a temperature boundary condition for the
+   * tan/gurnis benchmark in a box geometry.
+   *
+   * @ingroup BoundaryTemperatures
+   */
+  template <int dim>
+  class TanGurnisBoundary : public BoundaryTemperature::Interface<dim>
+  {
+    public:
+      double boundary_temperature (const types::boundary_id /*boundary_indicator*/,
+                                   const Point<dim> &position) const override
+      {
+        double wavenumber=1;
+        return sin(numbers::PI*position(dim-1))*cos(numbers::PI*wavenumber*position(0));
+      }
+
+      double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+      double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+  };
+
+  template <int dim>
+  double
+  TanGurnisBoundary<dim>::
+  minimal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
+  {
+    return 0;
+  }
+
+
+
+  template <int dim>
+  double
+  TanGurnisBoundary<dim>::
+  maximal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
+  {
+    return 1;
+  }
+
+
+
+  /*
+   * A postprocessor that evaluates the accuracy of the solution of the
+   * aspect::MaterialModel::TanGurnis material model.
+   *
+   * The implementation writes out the solution to be read in by a matlab
+   * script.
+   */
+  template <int dim>
+  class TanGurnisPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics) override;
+  };
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  TanGurnisPostprocessor<dim>::execute (TableHandler &/*statistics*/)
+  {
+    AssertThrow(Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()) == 1,
+                ExcNotImplemented());
+
+    AssertThrow(Plugins::plugin_type_matches<const MaterialModel::TanGurnis<dim>>(this->get_material_model()),
+                ExcMessage("tan gurnis postprocessor only works with tan gurnis material model"));
+
+    const MaterialModel::TanGurnis<dim> &
+    material_model = Plugins::get_plugin_as_type<const MaterialModel::TanGurnis<dim>>(this->get_material_model());
+
+    double ref=1.0/this->get_triangulation().begin_active()->minimum_vertex_distance();
+
+    std::stringstream output;
+    output.precision (16);
+    output << material_model.parameter_Di() << ' '
+           << material_model.parameter_gamma() << ' '
+           << material_model.parameter_wavenumber() << ' '
+           << material_model.parameter_a();
+
+    // pad the first line to the same number ooutputcolumns as the data below to make MATLAB happy
+    for (unsigned int i=4; i<7+this->get_heating_model_manager().get_active_heating_models().size(); ++i)
+      output<< " -1";
+
+    output<< std::endl;
+    output<< std::scientific;
+
+
+    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+    const unsigned int n_q_points =  quadrature_formula.size();
+    FEValues<dim> fe_values (this->get_mapping(), this->get_fe(),  quadrature_formula,
+                             update_JxW_values | update_values    |
+                             update_gradients  | update_quadrature_points);
+
+    MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
+    MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, this->n_compositional_fields());
+
+    const std::list<std::unique_ptr<HeatingModel::Interface<dim>>> &heating_model_objects = this->get_heating_model_manager().get_active_heating_models();
+
+    std::vector<HeatingModel::HeatingModelOutputs> heating_model_outputs (heating_model_objects.size(),
+                                                                          HeatingModel::HeatingModelOutputs (n_q_points, this->n_compositional_fields()));
+
+    for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          in.reinit(fe_values,cell,this->introspection(),this->get_solution());
+
+          this->get_material_model().evaluate(in, out);
+
+          if (this->get_parameters().formulation_temperature_equation ==
+              Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+            {
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  out.densities[q] = this->get_adiabatic_conditions().density(in.position[q]);
+                }
+            }
+
+          unsigned int index = 0;
+          for (typename std::list<std::unique_ptr<HeatingModel::Interface<dim>>>::const_iterator
+               heating_model = heating_model_objects.begin();
+               heating_model != heating_model_objects.end(); ++heating_model, ++index)
+            {
+              (*heating_model)->evaluate(in, out, heating_model_outputs[index]);
+            }
+
+
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            {
+              output
+                  <<  fe_values.quadrature_point (q) (0)
+                  << ' ' << fe_values.quadrature_point (q) (1)
+                  << ' ' << in.velocity[q][0]
+                  << ' ' << in.velocity[q][1]
+                  << ' ' << fe_values.JxW (q)
+                  << ' ' << in.pressure[q]
+                  << ' ' << in.temperature[q];
+
+              for (unsigned int i = 0; i < heating_model_objects.size(); ++i)
+                output << ' ' << heating_model_outputs[i].heating_source_terms[q];
+
+              output << std::endl;
+            }
+        }
+
+    const std::string filename = this->get_output_directory() + "vel_" +
+                                 Utilities::int_to_string(static_cast<unsigned int>(ref)) +
+                                 ".csv";
+    Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
+
+    return std::make_pair("writing:", "output.csv");
+  }
+
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_POSTPROCESSOR(TanGurnisPostprocessor,
+                                "Tan Gurnis error",
+                                "A postprocessor that compares the solution of the benchmarks from "
+                                "the Tan/Gurnis (2007) paper with the one computed by ASPECT "
+                                "by outputting data that is compared using a matlab script.")
+
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(TanGurnis,
+                                   "Tan Gurnis",
+                                   "A simple compressible material model based on a benchmark"
+                                   " from the paper of Tan/Gurnis (2007). This does not use the"
+                                   " temperature equation, but has a hardcoded temperature.")
+  }
+
+  ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(TanGurnisBoundary,
+                                             "Tan Gurnis",
+                                             "A model for the Tan/Gurnis benchmark.")
+}
diff --git a/benchmarks/tangurnis/tala/tan.prm.bak b/benchmarks/tangurnis/tala/tan.prm.bak
new file mode 100644
index 00000000000..737d7863d79
--- /dev/null
+++ b/benchmarks/tangurnis/tala/tan.prm.bak
@@ -0,0 +1,140 @@
+# Listing of Parameters
+# ---------------------
+
+set Additional shared libraries            = ./code/libtangurnis.so
+set Dimension                              = 2
+set CFL number                             = 1.0
+
+# We only need a single time step.
+set Start time                             = 0
+set End time                               = 0.0001
+set Output directory                       = output_tala
+
+# The temperature is prescibed, so we only need to
+# solve the Stokes system
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+
+# In this section we define the adiabatic profiles of temperature,
+# pressure and density. The temperature and pressure profiles are
+# not used for this benchmark (and set to zero).
+# gamma is the grueneisen parameter, which defines the compressibility
+# of the material, and we have to choose the same value for gamma as
+# in the material model below.
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=0.5, gamma=1.0
+    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+# This case of the benchmark uses the truncated anelastic liquid approximation.
+subsection Formulation
+  set Formulation = custom # equivalent to TALA or ALA depending on material model
+  set Mass conservation        = reference density profile
+  set Temperature equation     = reference density profile
+end
+
+# We define our own boundary condition that implements a boundary
+# temperature according to the prescibed temperature of the Tan & Gurnis
+# benchmark.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left, right, bottom, top
+  set List of model names = Tan Gurnis
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+# The model domain is the unit square.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*y)*cos(pi*1*x)
+  end
+end
+
+# The benchmark is defined in terms of the nondimensional numbers
+# Di (dissipation number) and gamma (grueneisen parameter).
+# As ASPECT uses physical properties instead of these dimensionless
+# numbers in its equations, we replicate the benchmark formulation
+# by using a new material model that fixes all of the material
+# constants to 1, except for the thermal expansivity and the viscosity,
+# which is set to Di, and the density profile, which depends on Di and
+# gamma.
+subsection Material model
+  set Model name = Tan Gurnis
+
+  subsection Tan Gurnis model
+    set Di                            = 0.5
+    set gamma                         = 1
+    set a                             = 0   # constant viscosity
+    set wavenumber                    = 1
+  end
+end
+
+# This subsection describes which heating models we want to use.
+# This case includes adiabatic heating and shear heating.
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set List of output variables      = density, adiabat
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/benchmarks/tangurnis/tala_c/tan.prm.bak b/benchmarks/tangurnis/tala_c/tan.prm.bak
new file mode 100644
index 00000000000..d5d7f6b1c26
--- /dev/null
+++ b/benchmarks/tangurnis/tala_c/tan.prm.bak
@@ -0,0 +1,139 @@
+# Listing of Parameters
+# ---------------------
+
+set Additional shared libraries            = ./code/libtangurnis.so
+set Dimension                              = 2
+set CFL number                             = 1.0
+
+# We only need a single time step.
+set Start time                             = 0
+set End time                               = 0.0001
+
+# The temperature is prescibed, so we only need to
+# solve the Stokes system
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+
+# In this section we define the adiabatic profiles of temperature,
+# pressure and density. The temperature and pressure profiles are
+# not used for this benchmark (and set to zero).
+# gamma is the grueneisen parameter, which defines the compressibility
+# of the material, and we have to choose the same value for gamma as
+# in the material model below.
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=0.5, gamma=1.0
+    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+# This case of the benchmark uses the truncated anelastic liquid approximation.
+subsection Formulation
+  set Formulation = custom # equivalent to TALA or ALA depending on material model
+  set Mass conservation        = reference density profile
+  set Temperature equation     = reference density profile
+end
+
+# We define our own boundary condition that implements a boundary
+# temperature according to the prescibed temperature of the Tan & Gurnis
+# benchmark.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left, right, bottom, top
+  set List of model names = Tan Gurnis
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+# The model domain is the unit square.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*y)*cos(pi*1*x)
+  end
+end
+
+# The benchmark is defined in terms of the nondimensional numbers
+# Di (dissipation number) and gamma (grueneisen parameter).
+# As ASPECT uses physical properties instead of these dimensionless
+# numbers in its equations, we replicate the benchmark formulation
+# by using a new material model that fixes all of the material
+# constants to 1, except for the thermal expansivity and the viscosity,
+# which is set to Di, and the density profile, which depends on Di and
+# gamma.
+subsection Material model
+  set Model name = Tan Gurnis
+
+  subsection Tan Gurnis model
+    set Di                            = 0.5
+    set gamma                         = 1
+    set a                             = 2   # depth-dependent viscosity
+    set wavenumber                    = 1
+  end
+end
+
+# This subsection describes which heating models we want to use.
+# This case includes adiabatic heating and shear heating.
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set List of output variables      = density, adiabat
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc.bak b/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc.bak
new file mode 100644
index 00000000000..7f85d60857b
--- /dev/null
+++ b/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc.bak
@@ -0,0 +1,55 @@
+/*
+  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "time_dependent_annulus.h"
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(TimeDependentAnnulus,
+                                   "time dependent annulus",
+                                   "This is the material model setup "
+                                   "for the time dependent annular flow benchmark from Section 5 of "
+                                   "``Gassmoeller, Lokavarapu, Bangerth, Puckett (2019): "
+                                   "Evaluating the Accuracy of Hybrid Finite Element/Particle-In-Cell "
+                                   "Methods for Modeling Incompressible Stokes Flow. Geophys. J. Int. "
+                                   "submitted.'' "
+                                   "The model "
+                                   "can either use the analytic density, or whatever is stored in the "
+                                   "first compositional field as the density that enters the Stokes equations. "
+                                   "This allows testing different advection schemes for the density.")
+  }
+
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(TimeDependentAnnulus,
+                                  "time dependent annulus",
+                                  "This is the error postprocessor "
+                                  "for the time dependent annular flow benchmark from Section 5 of "
+                                  "``Gassmoeller, Lokavarapu, Bangerth, Puckett (2019): "
+                                  "Evaluating the Accuracy of Hybrid Finite Element/Particle-In-Cell "
+                                  "Methods for Modeling Incompressible Stokes Flow. Geophys. J. Int. "
+                                  "submitted.'' "
+                                  "Specifically, it can compute the errors for "
+                                  "the velocity, pressure, and density variables.")
+  }
+}
diff --git a/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.h.bak b/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.h.bak
new file mode 100644
index 00000000000..624ad9158bd
--- /dev/null
+++ b/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.h.bak
@@ -0,0 +1,377 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+#include <aspect/initial_composition/function.h>
+#include <deal.II/base/parsed_function.h>
+
+
+namespace aspect
+{
+  /**
+   * This is the analytic solution, postprocessor, and material model setup
+   * for the time dependent annular flow benchmark from Section 5 of
+   *
+   * Gassmoeller, Lokavarapu, Bangerth, Puckett (2019):
+   * Evaluating the Accuracy of Hybrid Finite Element/Particle-In-Cell
+   * Methods for Modeling Incompressible Stokes Flow. Geophys. J. Int.
+   * submitted.
+   *
+   * It features a spherical annulus with a circular flow and a
+   * time-independent analytical, but a time-dependent numerical solution,
+   * which allows to quantify how errors in the advection equation
+   * influence the accuracy of the Stokes equation. In this example
+   * the benchmark uses particles to carry density, but it can be
+   * used for other advection methods as well.
+   */
+  namespace AnalyticSolutions
+  {
+    template <int dim>
+    void analytic_solution(
+      double pos[],
+      double vel[],
+      double *pressure,
+      double *density,
+      std::shared_ptr<Functions::ParsedFunction<dim>> pressure_function,
+      std::shared_ptr<Functions::ParsedFunction<dim>> velocity_function,
+      std::shared_ptr<Functions::ParsedFunction<dim>> density_function)
+    {
+      /****************************************************************************************/
+      /****************************************************************************************/
+      /* Output */
+      for (unsigned int i=0; i < dim; i++)
+        vel[i] = velocity_function->value(Point<dim>(pos[0],pos[1]), i);
+
+      (*pressure) = pressure_function->value(Point<dim>(pos[0], pos[1]));
+
+      (*density) = density_function->value(Point<dim>(pos[0], pos[1]));
+    }
+
+    /**
+     * The exact solution for the benchmark.
+     */
+    template <int dim>
+    class FunctionStreamline : public Function<dim>
+    {
+      public:
+        FunctionStreamline (std::shared_ptr<Functions::ParsedFunction<dim>> pressure,
+                            std::shared_ptr<Functions::ParsedFunction<dim>> velocity,
+                            std::shared_ptr<Functions::ParsedFunction<dim>> density,
+                            const unsigned int n_components)
+          :
+          Function<dim>(n_components),
+          pressure_function (pressure),
+          velocity_function (velocity),
+          density_function (density)
+        {}
+
+        void vector_value (const Point<dim> &p,
+                           Vector<double>   &values) const override
+        {
+          double pos[2]= {p(0),p(1)};
+
+          AnalyticSolutions::analytic_solution<dim>
+          (pos,
+           &values[0], &values[2], &values[4], pressure_function, velocity_function, density_function);
+        }
+      private:
+        std::shared_ptr<Functions::ParsedFunction<dim>> pressure_function;
+        std::shared_ptr<Functions::ParsedFunction<dim>> velocity_function;
+        std::shared_ptr<Functions::ParsedFunction<dim>> density_function;
+    };
+  }
+
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class TimeDependentAnnulus : public MaterialModel::Interface<dim>
+    {
+      private:
+        std::shared_ptr<Functions::ParsedFunction<dim>> density_function, pressure_function, velocity_function;
+
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              if (use_analytic_density)
+                out.densities[i] = density_function->value(in.position[i]);
+              else
+                out.densities[i] = in.composition[i][0];
+
+              out.viscosities[i] = 1;
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+
+        bool is_compressible () const override
+        {
+          return false;
+        }
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm)
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("Time dependent annulus");
+            {
+              prm.declare_entry ("Use analytic density", "false",
+                                 Patterns::Bool(),
+                                 "Whether to use the analytic density for the computations, or whatever"
+                                 "density is stored in the first compositional field.");
+
+              prm.enter_subsection("Analytical density");
+              {
+                prm.enter_subsection("Function");
+                {
+                  Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+                }
+                prm.leave_subsection();
+              }
+              prm.leave_subsection();
+
+              prm.enter_subsection("Analytical pressure");
+              {
+                prm.enter_subsection("Function");
+                {
+                  Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+                }
+                prm.leave_subsection();
+              }
+              prm.leave_subsection();
+
+              prm.enter_subsection("Analytical velocity");
+              {
+                prm.enter_subsection("Function");
+                {
+                  Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+                }
+                prm.leave_subsection();
+              }
+              prm.leave_subsection();
+
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Material model");
+          {
+            prm.enter_subsection("Time dependent annulus");
+            {
+              use_analytic_density = prm.get_bool ("Use analytic density");
+
+              prm.enter_subsection("Analytical density");
+              {
+                prm.enter_subsection("Function");
+                {
+                  density_function = std::make_unique<Functions::ParsedFunction<dim>>(1);
+                  density_function->parse_parameters(prm);
+                }
+                prm.leave_subsection();
+              }
+              prm.leave_subsection();
+
+              prm.enter_subsection("Analytical pressure");
+              {
+                prm.enter_subsection("Function");
+                {
+                  pressure_function = std::make_unique<Functions::ParsedFunction<dim>>(1);
+                  pressure_function->parse_parameters(prm);
+                }
+                prm.leave_subsection();
+              }
+              prm.leave_subsection();
+
+              prm.enter_subsection("Analytical velocity");
+              {
+                prm.enter_subsection("Function");
+                {
+                  try
+                    {
+                      velocity_function = std::make_unique<Functions::ParsedFunction<dim>>(dim);
+                      velocity_function->parse_parameters (prm);
+                    }
+                  catch (...)
+                    {
+                      std::cerr << "ERROR: FunctionParser failed to parse\n"
+                                << "\t'Analytical velocity.Function'\n"
+                                << "with expression\n"
+                                << "\t'" << prm.get("Function expression") << "'\n"
+                                << "More information about the cause of the parse error \n"
+                                << "is shown below.\n";
+                      throw;
+                    }
+                }
+                prm.leave_subsection();
+              }
+              prm.leave_subsection();
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          // Declare dependencies on solution variables
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+        /**
+         * Returns the analytic solutions of this model. See the
+         * corresponding member variable of this class for more information.
+         */
+        std::shared_ptr<Functions::ParsedFunction<dim>>  get_pressure() const
+        {
+          return pressure_function;
+        }
+
+        std::shared_ptr<Functions::ParsedFunction<dim>>  get_velocity() const
+        {
+          return velocity_function;
+        }
+
+        std::shared_ptr<Functions::ParsedFunction<dim>>  get_density() const
+        {
+          return density_function;
+        }
+
+      private:
+        /**
+         * Whether to use the analytic density for the benchmark or whatever density is
+         * stored in the first compositional field.
+         */
+        bool use_analytic_density;
+    };
+  }
+
+  namespace Postprocess
+  {
+    /**
+     * A postprocessor that evaluates the accuracy of the solution.
+     *
+     */
+    template <int dim>
+    class TimeDependentAnnulus : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      private:
+        std::shared_ptr<Function<dim>> ref_func;
+
+      public:
+        void
+        initialize () override
+        {
+          const MaterialModel::TimeDependentAnnulus<dim> &material_model =
+            Plugins::get_plugin_as_type<const MaterialModel::TimeDependentAnnulus<dim>>(this->get_material_model());
+
+          ref_func = std::make_unique<AnalyticSolutions::FunctionStreamline<dim>>(material_model.get_pressure(),
+                                                                                   material_model.get_velocity(),
+                                                                                   material_model.get_density(),
+                                                                                   1 + dim + 1 + this->n_compositional_fields());
+        }
+
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override
+        {
+          const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.velocities).degree+2);
+
+          Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+          Vector<float> cellwise_errors_rhol2 (this->get_triangulation().n_active_cells());
+
+          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                              this->get_fe().n_components());
+          ComponentSelectFunction<dim> comp_p(dim, this->get_fe().n_components());
+          ComponentSelectFunction<dim> comp_rho(dim+2, this->get_fe().n_components());
+
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_ul2,
+                                             quadrature_formula,
+                                             VectorTools::L2_norm,
+                                             &comp_u);
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_pl2,
+                                             quadrature_formula,
+                                             VectorTools::L2_norm,
+                                             &comp_p);
+          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                             this->get_solution(),
+                                             *ref_func,
+                                             cellwise_errors_rhol2,
+                                             quadrature_formula,
+                                             VectorTools::L2_norm,
+                                             &comp_rho);
+
+          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+          const double rho_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_rhol2, VectorTools::L2_norm);
+
+          statistics.add_value ("Error_u_l2", u_l2);
+          statistics.add_value ("Error_p_l2", p_l2);
+          statistics.add_value ("Error_rho_l2", rho_l2);
+
+          statistics.set_scientific ("Error_u_l2", true);
+          statistics.set_scientific ("Error_p_l2", true);
+          statistics.set_scientific ("Error_rho_l2", true);
+
+          std::ostringstream os;
+          os << std::scientific
+             << u_l2
+             << ", " << p_l2
+             << ", " << rho_l2;
+
+          return std::make_pair("Errors u_L2, p_L2, rho_L2", os.str());
+        }
+    };
+  }
+}
diff --git a/benchmarks/time_dependent_annulus/time_dependent_annulus.prm.bak b/benchmarks/time_dependent_annulus/time_dependent_annulus.prm.bak
new file mode 100644
index 00000000000..7e9b37ee662
--- /dev/null
+++ b/benchmarks/time_dependent_annulus/time_dependent_annulus.prm.bak
@@ -0,0 +1,179 @@
+# This is the setup of the time dependent annular flow benchmark
+# from Section 5 of
+#
+# Gassmoeller, Lokavarapu, Bangerth, Puckett (2019):
+# Evaluating the Accuracy of Hybrid Finite Element/Particle-In-Cell
+# Methods for Modeling Incompressible Stokes Flow. Geophys. J. Int.
+# submitted.
+#
+# It features a spherical annulus with a circular flow and a
+# time-independent analytical, but a time-dependent numerical solution,
+# which allows to quantify how errors in the advection equation
+# influence the accuracy of the Stokes equation. In this example
+# the benchmark uses particles to carry density, but it can be
+# used for other advection methods as well.
+
+
+set Additional shared libraries = ./plugin/libtime_dependent_annulus.so
+set Dimension                              = 2
+set End time                               = 0.09817477042468103
+set Output directory                       = output-time_dependent_annulus
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 1
+    set Outer radius = 2
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function
+
+  subsection Function
+    set Function constants  = pi=3.1415926
+    set Variable names      = x,y
+    set Function expression = y*sqrt(x^2 + y^2)^6;-x*sqrt(x^2 + y^2)^6
+  end
+end
+
+subsection Material model
+  set Model name = time dependent annulus
+  set Material averaging = none
+
+  subsection Time dependent annulus
+    set Use analytic density = false
+
+    subsection Analytical density
+      subsection Function
+        set Variable names = x, y
+        set Function expression = 48*sqrt(x^2 + y^2)^5
+      end
+    end
+
+    subsection Analytical pressure
+      subsection Function
+        # The term 512/72 causes the pressure to be zero at the outer boundary R = 2
+        set Function expression = (sqrt(x^2 + y^2)^9)/72 - 512/72
+      end
+    end
+
+    subsection Analytical velocity
+      subsection Function
+        set Variable names = x, y
+        set Function expression = y*sqrt(x^2 + y^2)^6;-x*sqrt(x^2 + y^2)^6
+      end
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = (x*(x^2 + y^2)/384) + (-y/sqrt(x^2 + y^2)); \
+                              (y*(x^2 + y^2)/384) + (x/sqrt(x^2 + y^2))
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_comp
+  set Compositional field methods = particles
+  set Mapped particle properties = density_comp:function[0]
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 48*sqrt(x^2 + y^2)^5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0; 0; 0
+    set Variable names      = depth
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+  set Use locally conservative discretization = false
+  set Use discontinuous composition discretization = true
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement   = 3
+  set Initial adaptive refinement = 0
+  set Time steps between mesh refinement = 0
+  set Refinement fraction         = 0
+  set Coarsening fraction         = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = time dependent annulus, particles, visualization
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Number of grouped files       = 1
+    set Time between graphical output = 0.0009817477042468104
+    set List of output variables      = density, gravity
+  end
+
+  subsection Particles
+    set Time between data output = 0.0009817477042468104
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+end
+
+subsection Checkpointing
+  set Time between checkpoint  = 7200
+end
+
+subsection Particles
+  set Integration scheme = rk2 # or rk4
+  set Interpolation scheme = bilinear least squares # or cell average
+  set List of particle properties = function
+  set Update ghost particles = true
+  set Particle generator name = reference cell
+  set Load balancing strategy = none # not necessary for uniform mesh
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 4 # or 5, 6, 7, 10, 15, 20, 32, 45, 64, 80
+    end
+  end
+
+  subsection Function
+    set Number of components = 2
+    set Variable names      = x,y
+    set Function expression = 48*sqrt(x^2 + y^2)^5;if(0<y,if(y<1/4,1,0),0)
+  end
+end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak
new file mode 100644
index 00000000000..07bece2410e
--- /dev/null
+++ b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak
@@ -0,0 +1,21 @@
+include Tosi_base.prm
+
+set Additional shared libraries            = ./libtosi_benchmark.so
+set Output directory                       = Case1_5
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+end
+
+# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
+# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity constant" ($\eta^*$)
+# are varied, see Eq. (6-8) and Table 1 of the paper.
+subsection Material model
+  set Model name = TosiMaterial
+
+  subsection Tosi benchmark
+    set Pressure viscosity parameter  = 1
+    set Yield stress          = 0
+    set Nonlinear viscosity constant  = 0
+  end
+end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak
new file mode 100644
index 00000000000..bd4670b4c7c
--- /dev/null
+++ b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak
@@ -0,0 +1,20 @@
+include Tosi_base.prm
+
+set Additional shared libraries            = ./libtosi_benchmark.so
+set Output directory                       = Case2_4
+
+# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
+# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity constant" ($\eta^*$)
+# are varied, see Eq. (6-8) and Table 1 of the paper.
+subsection Material model
+  subsection Tosi benchmark
+    set Pressure viscosity parameter  = 1
+    set Yield stress          = 1
+    set Nonlinear viscosity constant  = 1e-3
+    set Initial viscosity        = 0.115
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak
new file mode 100644
index 00000000000..361b9d8924e
--- /dev/null
+++ b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak
@@ -0,0 +1,21 @@
+include Tosi_base.prm
+
+set Additional shared libraries            = ./libtosi_benchmark.so
+set Output directory                       = Case3_6
+
+# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
+# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity parameter" ($\eta^*$)
+# are varied, see Eq. (6-8) and Table 1 of the paper.
+subsection Material model
+  set Model name = TosiMaterial
+
+  subsection Tosi benchmark
+    set Pressure viscosity parameter  = 10
+    set Yield stress          = 0
+    set Nonlinear viscosity constant  = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 6
+end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak
new file mode 100644
index 00000000000..e509c3e0a09
--- /dev/null
+++ b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak
@@ -0,0 +1,22 @@
+include Tosi_base.prm
+
+set Additional shared libraries            = ./libtosi_benchmark.so
+set Output directory                       = Case4_6
+
+# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
+# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity parameter" ($\eta^*$)
+# are varied, see Eq. (6-8) and Table 1 of the paper.
+subsection Material model
+  set Model name = TosiMaterial
+
+  subsection Tosi benchmark
+    set Pressure viscosity parameter  = 10
+    set Yield stress          = 1
+    set Nonlinear viscosity constant  = 1e-3
+    set Initial viscosity        = 1e-1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 6
+end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak
new file mode 100644
index 00000000000..4b06c0c01b1
--- /dev/null
+++ b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak
@@ -0,0 +1,21 @@
+include Tosi_base.prm
+
+set Additional shared libraries            = ./libtosi_benchmark.so
+set Output directory                       = Case5_6
+
+# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
+# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity parameter" ($\eta^*$)
+# are varied, see Eq. (6-8) and Table 1 of the paper.
+subsection Material model
+  set Model name = TosiMaterial
+
+  subsection Tosi benchmark
+    set Pressure viscosity parameter  = 10
+    set Yield stress          = 4
+    set Nonlinear viscosity constant  = 1e-3
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 6
+end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm.bak
new file mode 100644
index 00000000000..6c0bb5b85bd
--- /dev/null
+++ b/benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm.bak
@@ -0,0 +1,175 @@
+# A description of viscoplastic convection in a 2d box as
+# described in Tosi et al. (2015).
+# Tosi, N., et al. (2015),
+# A community benchmark for viscoplastic thermal
+# convection in a 2-D square box,
+# Geochem. Geophys. Geosyst., 16, 2175–2196,
+# doi:10.1002/2015GC005807.
+
+# We add the necessary plugins through a shared library
+set Additional shared libraries            = ./libtosi_benchmark.so
+
+# This is a 2D benchmark.
+set Dimension                              = 2
+
+# We run the model from time = 0 to time = 1 and to handle
+# the nonlinearity of the viscosity correctly, we use
+# the iterated Advection and Stokes nonlinear solver with 200 cheap
+# Stokes solves.
+set Use years in output instead of seconds = false
+set End time                               = 1
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 30
+set Nonlinear solver tolerance             = 1e-5
+
+# We choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps    = 200
+    set Linear solver tolerance                = 1e-6
+  end
+end
+
+# Our model domain is the unit square.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# We prescribe a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation with amplitude A.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = A=0.01, pi=3.1415926536
+    set Function expression = (1.0-z) + A*cos(pi*x)*sin(pi*z)
+  end
+end
+
+# The top and bottom boundary carry a prescribed boundary temperature, whereas
+# all other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+# The temperature at the bottom is set to 1; at the top to 0.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  # Here, all four sides of the box allow tangential
+  # unrestricted flow but with a zero normal component:
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# Gravity is vertical and of magnitude 1e8.
+# The Rayleigh number is defined as
+# $Ra = \frac{\rho g \alpha \Delta_T D^3}{\kappa \eta_0}$,
+# with $\rho$ the density, g the gravity magnitude, $\alpha$ thermal
+# expansivity, $\Delta_T$ the temperature contrast across the mantle and D the domain height.
+# $\eta_0$ is the reference viscosity and $\kappa$ the thermal diffusivity.
+# With the parameter values in this and the next section, this leads to
+# $Ra = \frac{1 * 1e8 * 1e-6 * 1 * 1^3}{\frac{1}{1*1} * 1e-1} = 100$.
+# Note that $\eta_0$ is not the same as the Tosi material model "Reference viscosity".
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e8
+  end
+end
+
+# Each case has a surface Rayleigh number of 100
+# and the parameter controlling the temperature
+# dependence of viscosity "Thermal viscosity parameter"
+# is always 1e5.
+# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
+# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity constant" ($\eta^*$)
+# are varied, see Eq. (6-8) and Table 1 of the paper.
+subsection Material model
+  set Model name = TosiMaterial
+
+  subsection Tosi benchmark
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-06
+    set Thermal viscosity parameter   = 1e5
+    set Initial viscosity        = 1e-1
+    set Minimum viscosity        = 1e-6
+    set Maximum viscosity        = 10
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.05. Given
+# our start time (0.0) and final time (1.0) this means that
+# we will obtain 20 output files.
+#
+# The statistics file includes the data reported in Tosi et al. (2015):
+# - average temperature (temperature statistics)
+# - top and bottom Nusselt numbers (heat flux statistics)
+# - Vrms over the whole domain (velocity statistics)
+# - Vrms along the surface (velocity boundary statistics)
+# - Vmax along the surface (velocity boundary statistics)
+# - average rate of viscous dissipation (TosiPostprocessor)
+# - average rate of work against gravity (TosiPostprocessor)
+# - percentage error difference work and dissipation (TosiPostprocessor)
+#
+# Tosi et al. (2015) also report depth averages; averages for viscosity
+# and temperature are produced every 0.05 units of time.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, \
+                               visualization, TosiPostprocessor, depth average, velocity boundary statistics
+
+  subsection Depth average
+    set List of output variables = temperature, viscosity
+    set Time between graphical output = 0.05
+    set Number of zones = 10
+  end
+
+  subsection Visualization
+    set List of output variables = viscosity, strain rate, density, specific heat, thermal expansivity, gravity, heating
+    set Time between graphical output = 0.05
+  end
+end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/doc/tosi_benchmark_2.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/doc/tosi_benchmark_2.prm.bak
new file mode 100644
index 00000000000..6a257bb5dc1
--- /dev/null
+++ b/benchmarks/tosi_et_al_2015_gcubed/doc/tosi_benchmark_2.prm.bak
@@ -0,0 +1,8 @@
+subsection Material model
+  subsection Tosi benchmark
+    set Pressure viscosity parameter  = 1
+    set Yield stress          = 1
+    set Nonlinear viscosity constant  = 1e-3
+    set Initial viscosity        = 0.115
+  end
+end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak b/benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak
new file mode 100644
index 00000000000..75202bb88e8
--- /dev/null
+++ b/benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak
@@ -0,0 +1,722 @@
+/*
+  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/global.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/newton.h>
+
+#include <aspect/simulator_access.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+
+namespace aspect
+{
+  /**
+   * This is the material model used for the viscoplastic convection
+   * benchmark models that were presented in the open access Tosi et al. (2015) paper:
+   * @code
+   *  @Article{T15,
+   *    Author = {Tosi, N. and Stein, C. and Noack, L. and H\"uttig, C. and Maierova, P. and Samuel, H. and Davies, D. R. and Wilson, C. R. and Kramer, S. C. and Thieulot, C. and Glerum, A. and Fraters, M. and Spakman, W. and Rozel, A. and Tackley, P. J.},
+   *    Title = {A community benchmark for viscoplastic thermal convection in a 2-D square box},
+   *    Journal = {Geochemistry, Geophysics, Geosystems},
+   *    Year = {2015}
+   *    Pages = {2175-2196},
+   *    Volume = {16},
+   *    Doi = {10.1002/2015GC005807}}
+   * @endcode
+   *
+   * It is a material model that consists of globally constant values for all
+   * material parameters except density and viscosity. Density is temperature dependent,
+   * but practically constant through a small value of the thermal expansivity,
+   * and viscosity depends on temperature, depth and strain rate.
+   *
+   * The model is considered incompressible, following the definition
+   * described in Interface::is_compressible.
+   *
+   * @ingroup MaterialModels
+   */
+  namespace TosiBenchmark
+  {
+    using namespace dealii;
+
+
+    /**
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class TosiMaterial : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          /**
+           * As described in Tosi et al (2015), the viscosity \eta is computed as the
+           * harmonic average of a linear and nonlinear part.
+           *
+           * The linear part is calculated as follows
+           * (see below for the meaning of the used parameter names):
+           * $\eta_{lin}(T,z) = \exp(-\ln(\text{eta\_T} * T + \ln(\text{eta\_Z}) * z)$
+           * while the strain rate dependent nonlinear part is computed as:
+           * $\eta_{plast}(\dot\epsilon) = \text{eta\_asterisk} + \frac{\text{sigma\_yield}}{\sqrt(\dot\epsilon:\dot\epsilon)}$
+           */
+
+          //set up additional output for the derivatives
+          MaterialModel::MaterialModelDerivatives<dim> *derivatives;
+          derivatives = out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              if (in.requests_property(MaterialModel::MaterialProperties::viscosity))
+                {
+                  out.viscosities[i] = viscosity (in.temperature[i],
+                                                  in.pressure[i],
+                                                  in.composition[i],
+                                                  in.strain_rate[i],
+                                                  in.position[i]);
+                }
+
+              out.densities[i] = reference_rho * (1.0 - thermal_alpha * (in.temperature[i] - reference_T));
+              out.thermal_expansion_coefficients[i] = thermal_alpha;
+              out.specific_heat[i] = reference_specific_heat;
+              out.thermal_conductivities[i] = thermal_k;
+              out.compressibilities[i] = 0.0;
+              // Pressure derivative of entropy at the given positions.
+              out.entropy_derivative_pressure[i] = 0.0;
+              // Temperature derivative of entropy at the given positions.
+              out.entropy_derivative_temperature[i] = 0.0;
+              // Change in composition due to chemical reactions at the
+              // given positions. The term reaction_terms[i][c] is the
+              // change in compositional field c at point i.
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                out.reaction_terms[i][c] = 0.0;
+
+              // If requested compute viscosity derivatives. This is only important
+              // if using the Newton solver.
+              if (derivatives != nullptr && in.requests_property(MaterialModel::MaterialProperties::viscosity))
+                {
+                  if (use_analytical_derivative)
+                    {
+                      if (in.strain_rate[i].norm() == 0)
+                        {
+                          derivatives->viscosity_derivative_wrt_strain_rate[i] = 0;
+                          derivatives->viscosity_derivative_wrt_pressure[i] = 0;
+                        }
+                      else
+                        {
+                          const double deviator_strain_rate_norm = in.strain_rate[i].norm();
+                          const double part1 = (eta_asterisk * deviator_strain_rate_norm + sigma_yield);
+
+                          derivatives->viscosity_derivative_wrt_strain_rate[i] = -(0.5*out.viscosities[i]*out.viscosities[i])
+                                                                                 * (sigma_yield/(part1 * part1 * deviator_strain_rate_norm)) * in.strain_rate[i];
+                          derivatives->viscosity_derivative_wrt_pressure[i] = 0;
+                        }
+                    }
+                  else
+                    {
+                      // finite difference derivative
+                      const double finite_difference_accuracy = 1e-7;
+
+                      SymmetricTensor<2,dim> &deta = derivatives->viscosity_derivative_wrt_strain_rate[i];
+
+                      // derivative in xx direction
+                      SymmetricTensor<2,dim> dstrain_rate = in.strain_rate[i];
+                      dstrain_rate[0][0] += std::fabs(in.strain_rate[i][0][0]) * finite_difference_accuracy;
+                      const double eta_zero_zero = viscosity(in.temperature[i], in.pressure[i], in.composition[i], dstrain_rate, in.position[i]);
+                      deta[0][0] = eta_zero_zero - out.viscosities[i];
+
+                      if (dstrain_rate[0][0] != 0)
+                        deta[0][0] /= std::fabs(in.strain_rate[i][0][0]) * finite_difference_accuracy;
+                      else
+                        deta[0][0] = 0;
+
+                      // derivative in xy direction
+                      dstrain_rate = in.strain_rate[i];
+                      // dstrain_rate in yx direction is multiplied by 0.5, because the symmetric tensor
+                      // is modified by 0.5 in xy and yx direction simultaneously and we compute the combined
+                      // derivative
+                      dstrain_rate[1][0] += 0.5 * std::fabs(in.strain_rate[i][1][0]) * finite_difference_accuracy;
+                      const double eta_one_zero = viscosity(in.temperature[i], in.pressure[i], in.composition[i], dstrain_rate, in.position[i]);
+                      deta[1][0] = eta_one_zero - out.viscosities[i];
+
+                      if (dstrain_rate[1][0] != 0)
+                        deta[1][0] /= std::fabs(in.strain_rate[i][1][0]) * finite_difference_accuracy;
+                      else
+                        deta[1][0] = 0;
+
+                      // derivative in yy direction
+                      dstrain_rate = in.strain_rate[i];
+                      dstrain_rate[1][1] += std::fabs(in.strain_rate[i][1][1]) * finite_difference_accuracy;
+                      const double eta_one_one = viscosity(in.temperature[i], in.pressure[i], in.composition[i], dstrain_rate, in.position[i]);
+                      deta[1][1] = eta_one_one - out.viscosities[i];
+
+                      if (dstrain_rate[1][1] != 0)
+                        deta[1][1] /= std::fabs(in.strain_rate[i][1][1]) * finite_difference_accuracy;
+                      else
+                        deta[1][1] = 0;
+
+                      derivatives->viscosity_derivative_wrt_pressure[i] = 0;
+                    }
+                }
+
+            }
+
+        }
+
+
+
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        double viscosity (const double                  temperature,
+                          const double                  pressure,
+                          const std::vector<double>    &compositional_fields,
+                          const SymmetricTensor<2,dim> &strain_rate,
+                          const Point<dim>             &position) const;
+
+        /*
+         * Function to compute the linear viscosity
+         * according to equation (7) of Tosi et al. 2015.
+         */
+        double viscolin(const double etaT,
+                        const double etaZ,
+                        const double T,
+                        const double depth) const;
+
+        /*
+         * Function to compute the plastic viscosity
+         * according to equation (8) of the paper.
+         */
+        double viscoplast(const double eta_asterisk,
+                          const double stress_y,
+                          const double strain_rate_norm) const;
+
+        /**
+         * The density at reference temperature
+         */
+        double reference_rho;
+
+        /*
+         * The reference temperature
+         */
+        double reference_T;
+
+        /*
+         * The thermal expansivity
+         */
+        double thermal_alpha;
+
+        /*
+         * The reference specific heat
+         */
+        double reference_specific_heat;
+
+        /**
+         * The thermal conductivity.
+         */
+        double thermal_k;
+
+        /*
+         * The linear viscosity parameter pertaining to
+         * the viscosity contrast due to temperature
+         */
+        double eta_T;
+
+        /*
+         * The linear viscosity parameter pertaining to
+         * the viscosity contrast due to pressure (depth)
+         */
+        double eta_Z;
+
+        /*
+         * The effective viscosity at high stresses that is
+         * part of the plastic viscosity
+         */
+        double eta_asterisk;
+
+        /*
+         * The constant yield stress that is used in the
+         * plastic viscosity formula
+         */
+        double sigma_yield;
+
+        /*
+         * The lower viscosity cut-off value
+         */
+        double eta_minimum;
+
+        /*
+         * The upper viscosity cut-off value
+         */
+        double eta_maximum;
+
+        /*
+         * The initial guess of the viscosity
+         */
+        double eta_initial;
+
+        /**
+         * Whether to use analytical or finite-difference viscosity derivatives
+         * if the Newton solver is used.
+         */
+        bool use_analytical_derivative;
+
+    };
+
+    /*
+     * Function to calculate the viscosity according
+     * to equation (6) of the paper.
+     */
+    template <int dim>
+    double
+    TosiMaterial<dim>::
+    viscosity (const double temperature,
+               const double,
+               const std::vector<double> &,
+               const SymmetricTensor<2,dim> &strain_rate,
+               const Point<dim> &) const
+    {
+
+      // In the first nonlinear iteration of the (pre-refinement steps of the) first time step,
+      // strain rate is zero, so we set viscosity to eta_initial, a user-defined guess of the viscosity.
+      if (strain_rate.norm() == 0)
+        {
+          return eta_initial;
+        }
+
+      // Otherwise we compute the linear viscosity and, if needed, the plastic viscosity.
+      double viscosity = 0.0;
+      const double visc_linear = viscolin(eta_T,eta_Z,temperature,0);
+
+      if (eta_asterisk == 0.0 && sigma_yield == 0.0)
+        {
+          viscosity = visc_linear;
+        }
+      else
+        {
+          const double visc_plastic = viscoplast(eta_asterisk,sigma_yield,strain_rate.norm());
+
+          // Compute the harmonic average (equation (6) of the paper)
+          viscosity = 2.0 / ((1.0 / visc_linear) + (1.0 / visc_plastic));
+        }
+
+      // Cut-off the viscosity by user-defined values to avoid possible very large viscosity ratios
+      viscosity = std::max(std::min(viscosity,eta_maximum),eta_minimum);
+
+      return viscosity;
+    }
+
+    /*
+     * Function to compute the linear viscosity
+     * according to equation (7) of Tosi et al. 2015.
+     */
+    template <int dim>
+    double
+    TosiMaterial<dim>::
+    viscolin(const double etaT,
+             const double etaZ,
+             const double T,
+             const double z) const
+    {
+
+      return std::exp((-1.0 * std::log(etaT) * T ) + (std::log(etaZ) * z));
+    }
+
+    /*
+     * Function to compute the plastic viscosity
+     * according to equation (8) of the paper.
+     */
+    template <int dim>
+    double
+    TosiMaterial<dim>::
+    viscoplast(const double etaasterisk,
+               const double stressy,
+               const double strainratenorm) const
+    {
+      return etaasterisk + (stressy/strainratenorm);
+    }
+
+
+
+    template <int dim>
+    bool
+    TosiMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    TosiMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // Default values are for Case 1 of Tosi et al. (2015).
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Tosi benchmark");
+        {
+          prm.declare_entry ("Reference density", "1",
+                             Patterns::Double (0),
+                             "The value of the reference density $\\rho_0$.");
+          prm.declare_entry ("Reference temperature", "0",
+                             Patterns::Double (0),
+                             "The value of the reference temperature $T_0$. The reference temperature is used "
+                             "in the density calculation.");
+          prm.declare_entry ("Minimum viscosity", "1e-6",
+                             Patterns::Double (0),
+                             "The value of the minimum cut-off viscosity $\\eta_min$.");
+          prm.declare_entry ("Maximum viscosity", "1e1",
+                             Patterns::Double (0),
+                             "The value of the maximum cut-off viscosity $\\eta_max$.");
+          prm.declare_entry ("Initial viscosity", "1e-1",
+                             Patterns::Double (0),
+                             "The value of the initial viscosity guess $\\eta_init$.");
+          prm.declare_entry ("Thermal conductivity", "1",
+                             Patterns::Double (0),
+                             "The value of the thermal conductivity $k$.");
+          prm.declare_entry ("Reference specific heat", "1",
+                             Patterns::Double (0),
+                             "The value of the specific heat $cp$.");
+          prm.declare_entry ("Thermal expansion coefficient", "1e-6",
+                             Patterns::Double (0),
+                             "The value of the thermal expansion coefficient $\\alpha$.");
+          prm.declare_entry ("Thermal viscosity parameter", "1e5",
+                             Patterns::Double (0),
+                             "The value of the thermal viscosity parameter $\\eta_T$, "
+                             "as used in equation (7) of the paper.");
+          prm.declare_entry ("Pressure viscosity parameter", "1e0",
+                             Patterns::Double (0),
+                             "The value of the pressure viscosity parameter $\\eta_Z$, "
+                             "as used in equation (7) of the paper.");
+          prm.declare_entry ("Yield stress", "0",
+                             Patterns::Double (0),
+                             "The value of the plastic viscosity yield stress $\\sigma_yield$, "
+                             "as used in equation (8) of the paper.");
+          prm.declare_entry ("Nonlinear viscosity constant", "0",
+                             Patterns::Double (0),
+                             "The value of the plastic viscosity constant $\\eta_asterisk$, "
+                             "as used in equation (8) of the paper.");
+          prm.declare_entry ("Use analytical derivative", "false",
+                             Patterns::Bool (),
+                             "Whether to use the analytical or the finite difference derivative for the Newton method.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    TosiMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Tosi benchmark");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          reference_T                = prm.get_double ("Reference temperature");
+          thermal_k                  = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+          eta_T                      = prm.get_double ("Thermal viscosity parameter");
+          eta_Z                      = prm.get_double ("Pressure viscosity parameter");
+          sigma_yield                = prm.get_double ("Yield stress");
+          eta_asterisk               = prm.get_double ("Nonlinear viscosity constant");
+          eta_minimum                = prm.get_double ("Minimum viscosity");
+          eta_maximum                = prm.get_double ("Maximum viscosity");
+          eta_initial                = prm.get_double ("Initial viscosity");
+          use_analytical_derivative  = prm.get_bool ("Use analytical derivative");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = (sigma_yield != 0.0) ? MaterialModel::NonlinearDependence::strain_rate | MaterialModel::NonlinearDependence::temperature | MaterialModel::NonlinearDependence::pressure : MaterialModel::NonlinearDependence::temperature | MaterialModel::NonlinearDependence::pressure;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::temperature;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+
+    /**
+     * A postprocessor that computes some statistics about the
+     * rate of viscous dissipation, the rate of work done against gravity
+     * and the error between the two. These diagnostic quantities
+     * are reported in the Tosi et al. (2015) paper for a visco-plastic
+     * 2D thermal convection model.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class TosiPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for statistics on the rate of viscous dissipation,
+         * rate of work and the error between the two.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    TosiPostprocessor<dim>::execute (TableHandler &statistics)
+    {
+      AssertThrow(this->get_geometry_model().natural_coordinate_system() == aspect::Utilities::Coordinates::CoordinateSystem::cartesian,
+                  ExcMessage("The current calculation of rate of work only makes sense in a Cartesian geometry."));
+
+      AssertThrow(Plugins::plugin_type_matches<const TosiMaterial<dim>>(this->get_material_model()),
+                  ExcMessage("The current calculation of viscous dissipation is only for incompressible models "
+                             "and specifically computes the difference between work and dissipation as requested "
+                             "in the paper of Tosi et al. 2015."));
+
+      const QGauss<dim> quadrature_formula (this->get_fe()
+                                            .base_element(this->introspection().base_elements.velocities)
+                                            .degree+1);
+
+      const unsigned int n_q_points = quadrature_formula.size();
+      std::vector<Tensor<1,dim>> velocities(n_q_points);
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_gradients |
+                               update_JxW_values);
+
+      // the local integral values of rate of viscous dissipation and work against gravity
+      double local_dissipation_integral = 0.0;
+      double local_work = 0.0;
+
+      // the values of the compositional fields are stored as blockvectors for each field
+      // we have to extract them in this structure
+      std::vector<std::vector<double>> prelim_composition_values (this->n_compositional_fields(),
+                                                                   std::vector<double> (n_q_points));
+
+      typename MaterialModel::Interface<dim>::MaterialModelInputs in(n_q_points,
+                                                                     this->n_compositional_fields());
+      typename MaterialModel::Interface<dim>::MaterialModelOutputs out(n_q_points,
+                                                                       this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+      // loop over active, locally owned cells and
+      // extract material model input and compute integrals
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+
+            // retrieve velocities
+            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                                                                                        velocities);
+
+            // retrieve the input for the material model
+            in.position = fe_values.get_quadrature_points();
+
+            fe_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
+                                                                                      in.pressure);
+
+            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
+                                                                                         in.temperature);
+
+            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+              fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values
+              (this->get_solution(),prelim_composition_values[c]);
+
+            for (unsigned int i=0; i<n_q_points; ++i)
+              {
+                for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                  in.composition[i][c] = prelim_composition_values[c][i];
+              }
+
+            fe_values[this->introspection().extractors.velocities].get_function_symmetric_gradients (this->get_solution(),
+                in.strain_rate);
+
+            // get the output from the material model
+            this->get_material_model().evaluate(in, out);
+
+            // calculate the local viscous dissipation integral and local rate of work against gravity
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                const SymmetricTensor<2,dim> strain_rate_dev = deviator(in.strain_rate[q]);
+                local_dissipation_integral += 2.0 * out.viscosities[q] * strain_rate_dev * strain_rate_dev * fe_values.JxW(q);
+                local_work += in.temperature[q] * velocities[q][dim-1] * fe_values.JxW(q);
+              }
+          }
+
+      // compute the integrals on the whole domain
+      const double viscous_dissipation
+        = Utilities::MPI::sum (local_dissipation_integral, this->get_mpi_communicator());
+
+      const double work
+        = Utilities::MPI::sum(local_work, this->get_mpi_communicator());
+
+      // compute the percentage error between rate of dissipation (divided by the surface rayleigh number of the Tosi et al. (2015)
+      // benchmark (Ra=100)) and rate of work (see equation (21) of the paper)
+      const double error = 100.0 * (std::abs(work - (viscous_dissipation / 100.0)) / std::max(work, viscous_dissipation / 100.0));
+
+      if (this->convert_output_to_years() == true)
+        {
+          // fill statistics file
+          // make sure that the columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.add_value ("Viscous dissipation (J/yr)", viscous_dissipation * year_in_seconds);
+          statistics.set_precision ("Viscous dissipation (J/yr)", 8);
+          statistics.set_scientific ("Viscous dissipation (J/yr)", true);
+          statistics.add_value ("Rate of work (Km/yr)", work * year_in_seconds);
+          statistics.set_precision ("Rate of work (Km/yr)", 8);
+          statistics.set_scientific ("Rate of work (Km/yr)", true);
+          statistics.add_value ("Error", error);
+          statistics.set_precision ("Error", 8);
+          statistics.set_scientific ("Error", true);
+        }
+      else
+        {
+          // fill statistics file
+          // make sure that the columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.add_value ("Viscous dissipation (W)", viscous_dissipation);
+          statistics.set_precision ("Viscous dissipation (W)", 8);
+          statistics.set_scientific ("Viscous dissipation (W)", true);
+          statistics.add_value ("Rate of work (W)", work);
+          statistics.set_precision ("Rate of work (W)", 8);
+          statistics.set_scientific ("Rate of work (W)", true);
+          statistics.add_value ("Error", error);
+          statistics.set_precision ("Error", 8);
+          statistics.set_scientific ("Error", true);
+        }
+
+      std::ostringstream output;
+      output.precision(3);
+      if (this->convert_output_to_years() == true)
+        output << viscous_dissipation *year_in_seconds
+               << " J/yr "
+               << work *year_in_seconds
+               << " J/yr "
+               << error
+               << " error";
+      else
+        output << viscous_dissipation
+               << " W "
+               << work
+               << " W "
+               << error
+               << " error";
+
+      return std::pair<std::string, std::string> ("Viscous dissipation, rate of work, error:",
+                                                  output.str());
+    }
+
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TosiBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(TosiMaterial,
+                                   "TosiMaterial",
+                                   "A material model that has constant values "
+                                   "for all coefficients except the density and viscosity as described in the "
+                                   "open access paper of Tosi et al. 2015. "
+                                   "The default parameter values are chosen according to Case 1 of the paper. "
+                                   "All of the values that define this model are read "
+                                   "from a section ``Material model/Tosi model'' in the input file, see "
+                                   "Section~\\ref{parameters:Material_model/Tosi_model}."
+                                   "\n\n"
+                                   "This model uses the following set of equations for the two coefficients that "
+                                   "are non-constant (see equation (6) - (10) of the paper): "
+                                   "\\begin{align}"
+                                   "  \\eta(T,z,\\dot \\epsilon) &= 2\\frac{1}{\\frac{1}{\\eta_{lin}(T,z)}\\frac{1}{\\eta_{plast}(\\dot\\epsilon}}, \\\\"
+                                   "  \\rho(T) &= \\left(1-\\alpha (T-T_0)\\right)\\rho_0,"
+                                   "\\end{align}"
+                                   "where $z$ represents depth."
+                                   "\n\n"
+                                   "The linear and plastic viscosity parts are defined as follows:"
+                                   "\\begin{align}"
+                                   "  \\eta_{lin}(T,z) &= \\exp(-\\ln(\\eta_T)T+\\ln(\\eta_z)z), \\\\"
+                                   "  \\eta_{plast}(\\dot\\epsilon) &= \\eta^{*}+\\frac{\\sigma_y}{\\sqrt(\\dot\\epsilon : \\dot\\epsilon)} "
+                                   "\\end{align} "
+                                   "\n\n"
+                                   "Note that this model uses the formulation that assumes an incompressible "
+                                   "medium despite the fact that the density follows the law "
+                                   "$\\rho(T)=\\rho_0(1-\\alpha(T-T_0))$. ")
+    ASPECT_REGISTER_POSTPROCESSOR(TosiPostprocessor,
+                                  "TosiPostprocessor",
+                                  "A postprocessor that computes the viscous dissipation"
+                                  "for the whole domain as: "
+                                  "$\\left<\\Phi\\right>=\\int_{V} \\tau : \\dot{\\epsilon}dV$ "
+                                  "= $\\int_{V} 2\\mu\\dot{\\epsilon}:\\dot{\\epsilon} dV$. "
+                                  "Besides the dissipation, for the Tosi et al. (2015) benchmark "
+                                  "the rate of work against gravity is "
+                                  "calculated, as well as the percentage error between the two: "
+                                  "$W$ = $\\int_{V} T u_{y} dV$ and "
+                                  "$\\delta$ = $ \\frac{|W - \\frac{\\left<\\Phi\\right>}{Ra}|}{\\max\\left(\\left<W\\right>,\\frac{\\left<\\Phi\\right>}{Ra}\\right)}$. "
+                                  "This error W should tend to zero if in steady state the thermal energy is accurately preserved."
+                                  "Note that this postprocessor only makes sense for box geometries.")
+  }
+}
diff --git a/benchmarks/viscoelastic_beam_modified/20km_opentopbot.prm.bak b/benchmarks/viscoelastic_beam_modified/20km_opentopbot.prm.bak
new file mode 100644
index 00000000000..b27baca2f91
--- /dev/null
+++ b/benchmarks/viscoelastic_beam_modified/20km_opentopbot.prm.bak
@@ -0,0 +1,96 @@
+# This parameter file modifies the 2D benchmark 'viscoelastic_bending_beam'.
+# It has been modified to model a much larger beam, and to have an open top
+# and bottom boundary to allow the inelastic, low viscosity fluid surrounding the beam to
+# be more easily displaced while the beam flexes.
+#
+# The benchmark examines bending of a viscoelastic beam surrounded by a less dense
+# and viscous (inelastic) fluid. Gravitational forces drive initial bending
+# (elastic strain) of the beam. The analytic solution is from Geodynamics 3rd Edition by
+# Turcotte and Schubert, Chapter 3.10 (eq. 3.85 for flexure and 3.86 for stress).
+# Models have been tested for deflections that are no greater than half the thickness of
+# the beam. More flexure could potentially lead to a breakdown of the fit since the analytic
+# solution assumes small deflection relative to the thickness.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+
+# Global parameters
+set Start time                             = 0
+set End time                               = 200e3
+set Use years in output instead of seconds = true
+set Maximum time step                      = 1e3
+set Output directory                       = 20kmh_05drho
+
+# Model geometry (240x160 km, 1 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 160
+    set Y repetitions = 80
+    set X extent      = 320e3
+    set Y extent      = 160e3
+  end
+end
+
+# Mesh refinement
+subsection Mesh refinement
+  set Initial adaptive refinement        = 3
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 1
+  set Strategy                           = viscosity
+end
+
+# override boundary conditions:
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left
+  set Tangential velocity boundary indicators = right
+end
+
+# Traction Boundary Conditions
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = top: initial lithostatic pressure, bottom: initial lithostatic pressure
+
+  # Set the point for the open top and bottom boundaries
+
+  subsection Initial lithostatic pressure
+    set Representative point = 320e3, 0
+    set Number of integration points = 10000
+  end
+end
+
+# Spatial domain of different compositional fields
+# Make the beam 9x longer than it is wide to ensure the 'thin' approximation is valid
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; if ( 180e3>=x && y>=100e3 && y<=120e3, 1, 0)
+  end
+end
+
+# Material model
+# The density contrast has to be small with such a large beam to preserve the small deflection approximation
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities            =  2800,  2800,  2800,  2800,  2805
+    set Viscosities          = 1.e18, 1.e18, 1.e18, 1.e18, 1.e24
+    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
+  end
+end
+
+# Post processing
+subsection Postprocess
+  subsection Visualization
+    set Number of grouped files = 1
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm b/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm
index 3eab684ad1d..5f10ad30d36 100644
--- a/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm
+++ b/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm
@@ -5,17 +5,18 @@ include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/20km_opentopbot.
 
 set Output directory = 20kmh_05drho_weno
 
-
 subsection Discretization
   subsection Stabilization parameters
     # Use WENO limiter for viscoelastic stress components, while using the
     # bound-preserving limiter for the chemical field
     set Limiter for discontinuous composition solution = WENO, WENO, WENO, bound preserving
+
     # In this benchmark, the spurious oscillations at the boundaries of the beam
     # are extremely serious, so we set the linear weight of neighbor cells one
     # magnitude greater than the default value to make the reconstructed solution
     # smoother.
     set WENO linear weight of neighbor cells = 0.01
+
     # The global maximum and minimum values are only used by the chemical field.
     set Global composition maximum = 1.0
     set Global composition minimum = 0.0
@@ -26,6 +27,7 @@ end
 subsection Postprocess
   subsection Visualization
     set List of output variables = material properties, strain rate, kxrcf indicator
+
     subsection KXRCF indicator
       set Name of advection field = ve_stress_xy
     end
diff --git a/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm.bak b/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm.bak
new file mode 100644
index 00000000000..3eab684ad1d
--- /dev/null
+++ b/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm.bak
@@ -0,0 +1,33 @@
+# This parameter file modifies the benchmark 20kmh_05drho.prm to use the WENO limiter
+# for viscoelastic stress components.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/20km_opentopbot.prm
+
+set Output directory = 20kmh_05drho_weno
+
+
+subsection Discretization
+  subsection Stabilization parameters
+    # Use WENO limiter for viscoelastic stress components, while using the
+    # bound-preserving limiter for the chemical field
+    set Limiter for discontinuous composition solution = WENO, WENO, WENO, bound preserving
+    # In this benchmark, the spurious oscillations at the boundaries of the beam
+    # are extremely serious, so we set the linear weight of neighbor cells one
+    # magnitude greater than the default value to make the reconstructed solution
+    # smoother.
+    set WENO linear weight of neighbor cells = 0.01
+    # The global maximum and minimum values are only used by the chemical field.
+    set Global composition maximum = 1.0
+    set Global composition minimum = 0.0
+  end
+end
+
+# Visualize the KXRCF indicator for ve_stress_xy
+subsection Postprocess
+  subsection Visualization
+    set List of output variables = material properties, strain rate, kxrcf indicator
+    subsection KXRCF indicator
+      set Name of advection field = ve_stress_xy
+    end
+  end
+end
diff --git a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
index 3d14a096e72..ca656ef8389 100644
--- a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+++ b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
@@ -74,9 +74,9 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
     set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0
     set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm.bak b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm.bak
new file mode 100644
index 00000000000..3d14a096e72
--- /dev/null
+++ b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm.bak
@@ -0,0 +1,185 @@
+# This parameter file reproduces a 2D benchmark for viscoelastic deformation
+# published in "Numerical modelling of magma dynamics coupled to tectonic
+# deformation of lithosphere and crust" by Keller, May and Kaus, 2013,
+# Geophys. J. Int., v. 195,  p. 1406-1422. The model setup and results are
+# described in detail in section B.2.3 and figure B5.
+#
+# The benchmark examines bending and unbending (e.g., recovery) of a
+# viscoelastic beam surrounded by a less dense and viscous (inelastic) fluid.
+# Gravitational forces drive initial bending (elastic strain) of the beam for
+# 50 Kyr, which then recovers its shape over ~ 500 Kyr if gravity is turned
+# off. The recovery is driven by the accumulated elastic stresses and thus
+# provides a basic test for the viscoelasticity implementation.
+#
+# Compositional fields are used to track the viscoelastic stresses and material
+# representing the beam. To improve the accuracy of tracking the beam interface,
+# a discontinuous discretization and bound preserving limiter is used for the
+# compositional fields. Significantly, the time step is limited to 1 Kyr through
+# the "Maximum time step" parameter and a relatively high (0.5) CFL value. Using
+# a constant time step ensures the effective (viscoelastic) viscosity of the
+# viscoelastic beam and viscous fluid remains constants throughout the model run.
+#
+# As currently constructed, the model will run for 50 Kyr with a gravitational
+# acceleration of 10 m/s^2. To produce unbending of the beam after the model
+# has finished, change the parameter "End time" to 500 Kyr and set the
+# gravitational acceleration to 0 m/s^2. A restart file is written every 10 Kyr
+# and the parameter "Resume computation = auto" specifies that a model should
+# restart from a checkpoint file if one is present.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 50e3
+set Use years in output instead of seconds = true
+set Resume computation                     = auto
+set CFL number                             = 0.5
+set Maximum time step                      = 1e3
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0.
+
+# Solver settings
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 2000
+  end
+end
+
+# Model geometry (7.5x5 km, 0.1 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 75
+    set Y repetitions = 50
+    set X extent      = 7.5e3
+    set Y extent      = 5e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree           = 2
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 1
+  set Use locally conservative discretization = false
+  set Use discontinuous temperature discretization = false
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+    set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0
+    set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0
+  end
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left
+  set Tangential velocity boundary indicators = bottom, top, right
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, beam
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; if (x<=4.5e3 && y>=2.5e3 && y<=3.0e3, 1, 0)
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Fixed composition boundary indicators  = bottom, top, right
+  set List of model names                   = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 293
+    set Left temperature   = 293
+    set Right temperature  = 293
+    set Top temperature    = 293
+  end
+end
+
+# Temperature initial conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities            =  2800,  2800,  2800,  2800,  3300
+    set Viscosities          = 1.e18, 1.e18, 1.e18, 1.e18, 1.e24
+    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
+    set Fixed elastic time step     = 1e3
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = maximum composition
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate
+    set Time between graphical output = 0
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 500
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 10
+end
diff --git a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_particles.prm.bak b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_particles.prm.bak
new file mode 100644
index 00000000000..f48b09ce194
--- /dev/null
+++ b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_particles.prm.bak
@@ -0,0 +1,41 @@
+# This parameter file modifies the benchmark viscoealastic_bending_beam.prm
+# to use particles, rather than compositional fields, to track viscoleastic
+# stresses and location of the beam.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set Output directory = output_viscoelastic_bending_beam_particles
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 4
+  set Compositional field methods =           particles,           particles,           particles,         particles
+  set Names of fields             =           ve_stress_xx,        ve_stress_yy,        ve_stress_xy,      beam
+  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy, beam:initial beam
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, particles, temperature statistics, visualization
+
+  subsection Particles
+    set Time between data output    = 0
+    set Data output format          = vtu
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell  = 95
+  set Maximum particles per cell  = 105
+  set Load balancing strategy     = remove and add particles
+  set List of particle properties = initial composition, elastic stress
+  set Interpolation scheme        = nearest neighbor
+  set Update ghost particles      = true
+  set Particle generator name     = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 4e5
+    end
+  end
+end
diff --git a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm
index d6a698d676f..34f163cfdd1 100644
--- a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm
+++ b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm
@@ -10,11 +10,13 @@ subsection Discretization
     # Use WENO limiter for viscoelastic stress components, while using the
     # bound-preserving limiter for the chemical field
     set Limiter for discontinuous composition solution = WENO, WENO, WENO, bound preserving
+
     # In this benchmark, the spurious oscillations at the boundaries of the beam
     # are extremely serious, so we set the linear weight of neighbor cells one
     # magnitude greater than the default value to make the reconstructed solution
     # smoother.
     set WENO linear weight of neighbor cells = 0.01
+
     # The global maximum and minimum values are only used by the chemical field.
     set Global composition maximum = 1.0
     set Global composition minimum = 0.0
@@ -25,6 +27,7 @@ end
 subsection Postprocess
   subsection Visualization
     set List of output variables = material properties, strain rate, kxrcf indicator
+
     subsection KXRCF indicator
       set Name of advection field = ve_stress_xy
     end
diff --git a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm.bak b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm.bak
new file mode 100644
index 00000000000..d6a698d676f
--- /dev/null
+++ b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm.bak
@@ -0,0 +1,32 @@
+# This parameter file modifies the benchmark viscoealastic_bending_beam.prm
+# to use the WENO limiter for viscoelastic stress components.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set Output directory = output_viscoelastic_bending_beam_weno
+
+subsection Discretization
+  subsection Stabilization parameters
+    # Use WENO limiter for viscoelastic stress components, while using the
+    # bound-preserving limiter for the chemical field
+    set Limiter for discontinuous composition solution = WENO, WENO, WENO, bound preserving
+    # In this benchmark, the spurious oscillations at the boundaries of the beam
+    # are extremely serious, so we set the linear weight of neighbor cells one
+    # magnitude greater than the default value to make the reconstructed solution
+    # smoother.
+    set WENO linear weight of neighbor cells = 0.01
+    # The global maximum and minimum values are only used by the chemical field.
+    set Global composition maximum = 1.0
+    set Global composition minimum = 0.0
+  end
+end
+
+# Visualize the KXRCF indicator for ve_stress_xy
+subsection Postprocess
+  subsection Visualization
+    set List of output variables = material properties, strain rate, kxrcf indicator
+    subsection KXRCF indicator
+      set Name of advection field = ve_stress_xy
+    end
+  end
+end
diff --git a/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vep.prm.bak b/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vep.prm.bak
new file mode 100644
index 00000000000..ac107463d2e
--- /dev/null
+++ b/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vep.prm.bak
@@ -0,0 +1,61 @@
+# This parameter file modifies the benchmark gerya_2019_vp.prm
+# to include viscoelasticity.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm
+
+
+#  Global parameters
+set End time                               = 500
+set Output directory                       = output_gerya_2019_vep
+
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, block, air, inclusion
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; \
+                              if ( ( x<43.75e3 && y>25.e3 && y<75.e3) || (x>56.25e3 && y>25.e3 && y<75.e3) || (y>56.25e3 && y<75.e3 && x>=43.75e3 && x<=56.25e3) || (y<43.75e3 && y>25.e3 && x>=43.75e3 && x<=56.25e3), 1, 0); \
+                              if (y<=25.e3 || y>=75.e3, 1, 0); \
+                              if (y<=56.25e3 && y>=43.75e3 && x>=43.75e3 && x<=56.25e3, 1, 0);
+  end
+end
+
+# Material model
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # For identification purposes, nonsensical Prefactor values (1e-50) are assigned to the compositional
+    # fields tracking elastic stresses, which are not included in the volume fractions computation.
+    set Prefactors for dislocation creep          = 5e-24, 1e-50, 1e-50, 1e-50, 5e-24, 5.e-18, 5e-18
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 1e11
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 20
+    set Viscosity averaging scheme  = harmonic
+
+    # Nonsensical cohesion values (1e50) are assigned to the compositional fields tracking elastic stresses
+    set Angles of internal friction = 37.,       0.,    0.,    0.,    37.,    0.,    0.
+    set Cohesions                   = 100.e6, 1.e50, 1.e50, 1.e50, 100.e6, 10.e6, 10.e6
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set Run postprocessors on nonlinear iterations = false
+end
diff --git a/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm.bak b/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm.bak
new file mode 100644
index 00000000000..2768acc033c
--- /dev/null
+++ b/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm.bak
@@ -0,0 +1,190 @@
+# Shortening of a visco-plastic block in the absence of gravity
+# modified from Exercise 13.2 in Gerya 2019 (Introduction to
+# Numerical Geodynamic Modeling). The benchmark has been modified
+# to remove viscoelasticity and use slightly different geometries
+# for different materials, which allows the edges of features to
+# always align with the edges of the mesh with additional global
+# refinements. The viscoelastic-plastic version of this setup is
+# provided by gerya_2019_vep.prm within this folder.
+#
+# In detail, the benchmark examines shortening of a viscoelastic
+# plastic (here, visco-plastic) block, which contains a weak
+# inclusion in the center and a weak medium layer (i.e., sticky
+# air) on the top and bottom. The thickness of the weak layers
+# and dimensions of the square inclusion have also been modified
+# so that element edges always align with these material interfaces
+# for uniformly refined meshes of level 3 and up. The velocity on
+# the boundaries is 5e-9 m/s, giving a background strain rate of
+# 1e-13 1/s. The weak medium and weak inclusion have the following
+# material properties: viscosity = 1e17 Pa s, cohesion = 1e7 Pa,
+# and internal friction angle = 0. The visco-plastic block has
+# the following material properties: viscosity = 1e23 Pa s,
+# cohesion = 1e8 Pa, and internal friction angle = 37 degrees.
+# Gravity is set to zero and the average pressure is required
+# to be equal to zero.
+
+#  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 500
+set CFL number                             = 0.5
+set Maximum time step                      = 20
+set Output directory                       = output_gerya_2019_vp
+set Timing output frequency                = 1
+set Pressure normalization                 = volume
+
+# Solver parameters
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block AMG
+    set Linear solver tolerance = 1e-7
+    set Number of cheap Stokes solver steps = 200
+  end
+
+  subsection Newton solver parameters
+    set Max Newton line search iterations        = 0
+    set Max pre-Newton nonlinear iterations      = 500 # Ensures only defect-correction Picard method is used
+    set Maximum linear Stokes solver tolerance   = 1e-2
+    set Nonlinear Newton solver switch tolerance = 1e-5
+    set SPD safety factor                        = 0.9
+    set Stabilization preconditioner             = SPD
+    set Stabilization velocity block             = SPD
+    set Use Newton failsafe                      = false
+    set Use Newton residual scaling method       = false
+    set Use Eisenstat Walker method for Picard iterations = true
+  end
+end
+
+# Model geometry (100x100 km, initial 50 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 2
+    set Y repetitions = 2
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Globally refine the mesh. A minimum of 3 global refinements
+# is needed to resolve the edges of the weak viscous inclusion.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+# Velocity boundary conditions (5e-9 m/s on each boundary)
+# The imposed velocity produces a background strain-rate
+# of 10e-13 1/s.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: function, right x:function, top y: function, bottom y: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = vel=0.15778463
+    set Function expression = if (x<50e3, vel, -vel); if (y<50e3, -vel, vel);
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = block, air, inclusion
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = if ( ( x<43.75e3 && y>25.e3 && y<75.e3) || (x>56.25e3 && y>25.e3 && y<75.e3) || (y>56.25e3 && y<75.e3 && x>=43.75e3 && x<=56.25e3) || (y<43.75e3 && y>25.e3 && x>=43.75e3 && x<=56.25e3), 1, 0); \
+                              if (y<=25.e3 || y>=75.e3, 1, 0); \
+                              if (y<=56.25e3 && y>=43.75e3 && x>=43.75e3 && x<=56.25e3, 1, 0);
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Fixed composition boundary indicators  =
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# Temperature initial conditions (isothermal)
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.
+  end
+end
+
+# Material model
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Densities                   = 2700
+    set Reference strain rate       = 1.e-13
+    set Maximum viscosity           = 1.e23
+    set Minimum viscosity           = 1.e17
+    set Prefactors for dislocation creep          = 5e-24, 5e-24, 5.e-18, 5e-18
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Angles of internal friction = 37.,       37.,    0.,    0.
+    set Cohesions                   = 100.e6, 100.e6, 10.e6, 10.e6
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, velocity statistics, visualization
+  set Run postprocessors on nonlinear iterations = true
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate, named additional outputs
+    set Time between graphical output = 0e3
+    set Interpolate output            = true
+    set Write higher order output     = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp_damper.prm.bak b/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp_damper.prm.bak
new file mode 100644
index 00000000000..86000583382
--- /dev/null
+++ b/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp_damper.prm.bak
@@ -0,0 +1,20 @@
+# This parameter file modifies the benchmark gerya_2019_vp.prm
+# to include a viscous damper in the plastic viscosity calculation.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm
+
+set Output directory = output_gerya_2019_damper
+
+subsection Mesh refinement
+  set Initial global refinement = 5
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Allow negative pressures in plasticity = true
+    set Use plastic damper = true
+    set Plastic damper viscosity = 1e19
+  end
+end
diff --git a/benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm.bak b/benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm.bak
new file mode 100644
index 00000000000..f60c43f46c0
--- /dev/null
+++ b/benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm.bak
@@ -0,0 +1,238 @@
+# This parameter file examines shear band development in a viscoelastic-plastic
+# medium that contains a weak viscous inclusion. The experiment is based
+# directly on the setup used in Kaus, 2010, Tectonophysics, v. 484, p. 36-47.
+# This paper examines both compressional and extensional test cases, and this
+# parameter file examines the extensional case. One notable exception to the
+# Kaus et al. models and this setup is the lack of cohesion strain-softerning,
+# which helps localize deformation along the shear bands.
+#
+# The key feature of the model is the inclusion of viscoelasticity,
+# which leads to a gradual (as opposed to instantaneous for visco-plasticity)
+# development of the plastic shear bands above the weak viscous inclusion.
+# Kaus (2010) and many other studies (e.g., Glerum et al. 2018, Solid Earth)
+# have shown that the shear band angle is directly dependent on the mesh
+# resolution. Here, the model contains a very coarse resolution of 100x25
+# grid points (0.4 km grid spacing. Increasing the "Initial global refinement"
+# parameter from 0 to 1 or 2 (resolution increases by 2x or 4x) should lead
+# to an increase in the shear band angle from 45 degrees to close to 60
+# degrees. Additional key features of the model include the use of the
+# Newton solver for improved nonlinear solver convergence and a plastic
+# damper term (Duretz et al., 2019) to provide a quasi length-scale
+# and smoother viscosity for plastic shear bands.
+
+#  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20e3
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
+set Nonlinear solver tolerance             = 1e-4
+set Max nonlinear iterations               = 100
+set CFL number                             = 0.5
+set Maximum time step                      = 1000
+set Output directory                       = output_kaus_2010_extension
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+
+# Solver settings
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type                  = block AMG
+    set Number of cheap Stokes solver steps = 2000
+    set Linear solver tolerance             = 1e-7
+    set GMRES solver restart length         = 50
+    set Use full A block as preconditioner  = true
+  end
+
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations      = 5
+    set SPD safety factor                        = 0.9
+    set Nonlinear Newton solver switch tolerance = 1e-4
+    set Max Newton line search iterations        = 5
+    set Maximum linear Stokes solver tolerance   = 1e-7
+    set Use Newton residual scaling method       = false
+    set Use Newton failsafe                      = true
+    set Stabilization preconditioner             = SPD
+    set Stabilization velocity block             = SPD
+    set Use Eisenstat Walker method for Picard iterations = false
+  end
+end
+
+# Model geometry (40x10 km, 0.4 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 100
+    set Y repetitions = 25
+    set X extent      = 40e3
+    set Y extent      = 10e3
+  end
+end
+
+# Mesh refinement specifications.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+  set Additional tangential mesh velocity boundary indicators = left, right
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+end
+
+# Velocity boundary conditions
+# The imposed velocity produces a background strain-rate of 2e-15.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom
+  set Prescribed velocity boundary indicators = left x: function, right x:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = cm=0.01, year=1, vel=0.12616
+    set Function expression = if (x<20e3 , -vel*cm/year, vel*cm/year); 0;
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 5
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, plastic_strain, inclusion
+  set Types of fields  = stress, stress, stress, strain, chemical composition
+  set Compositional field methods = particles
+  set Mapped particle properties  = ve_stress_xx: ve_stress_xx, \
+                                    ve_stress_yy: ve_stress_yy, \
+                                    ve_stress_xy: ve_stress_xy, \
+                                    plastic_strain: plastic_strain, \
+                                    inclusion: initial inclusion
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; 0; \
+                              if (y<=0.4e3 && x>=19.6e3 && x<=20.4e3, 1, 0);
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Fixed composition boundary indicators  =
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# Temperature initial conditions (isothermal)
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+  set Material averaging = harmonic average only viscosity
+
+  subsection Visco Plastic
+    set Densities                   = 2700
+    set Reference strain rate       = 1.e-15
+    set Maximum viscosity           = 1.e25
+    set Minimum viscosity           = 1.e20
+    set Prefactors for dislocation creep          = 5e-26, 5e-26, 5e-26, 5e-26, 5e-26, 5e-21
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 5.e10, 5.e10, 5.e10, 5.e10, 5.e10, 1.e50
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+    set Viscosity averaging scheme  = harmonic
+    set Angles of internal friction = 30.
+    set Cohesions                   = 40.e6, 40.e6, 40.e6, 40.e6, 40.e6, 1.e20
+    set Strain weakening mechanism                   = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals  = 0.0
+    set End plasticity strain weakening intervals    = 0.1
+    set Cohesion strain weakening factors            = 0.1
+    set Friction strain weakening factors            = 1.0
+    set Use plastic damper       = true
+    set Plastic damper viscosity = 1e20
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, particles, temperature statistics, velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate
+    set Time between graphical output = 0e3
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+
+  subsection Particles
+    set Time between data output    = 0.e3
+    set Data output format          = vtu
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
+
+subsection Particles
+  set Minimum particles per cell  = 40
+  set Maximum particles per cell  = 60
+  set Load balancing strategy     = remove and add particles
+  set List of particle properties = initial composition, viscoplastic strain invariants, elastic stress
+  set Interpolation scheme        = cell average
+  set Update ghost particles      = true
+  set Particle generator name     = reference cell
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 7
+    end
+  end
+end
diff --git a/benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm.bak b/benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm.bak
new file mode 100644
index 00000000000..33285ea8f23
--- /dev/null
+++ b/benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm.bak
@@ -0,0 +1,146 @@
+# This parameter file constructs a simple shear benchmark, which is adapted from Farrington et al. 2014,
+# (Geophysics, Geochemistry, Geosystems). A uniform material undergoes simple shear at a constant rate
+# up until time=1.  At this point the shearing velocity is reduced to zero, and elastic stresses relax.
+# The rheology is viscoelastic plastic, with a cohesion value of 3.5. This value is slightly
+# higher than the visco-elastic stress at time=1, meaning that yielding does not occur, and the
+# analytic (visco-elastic) solution should be reasonably well approximated. If the cohesion value is reduced
+# to below the shear stress value at time t=1 (~3.1411), the shear stress will reach and remain
+# at this value until after time t=1 when stresses begin to relax.
+# This setup demonstrates an important difference between viscoelastic plastic, and visco-plastic rheology.
+# In a comparable setup, the visco-plastic rheology will exhibit yielding in the first velocity iteration,
+# as the value pre-yield stress magnitude is 3.5.
+# The analytic solution follows the expression in Farrington et al., and describes the
+# non-viscous portion of the total stress. This is equivalent to the magnitude of the stored stress
+# history tensor. The three independent components of this tensor are tracked with compositional fields
+# (ve_stress_xx, ve_stress_yy, ve_stress_xy). The choice of elastic time step (Fixed elastic time step) and
+# numerical timestep (Maximum time step) determine the degree of convergence with the analytic
+# solution. The values set in the parameter file (0.01) produce a close fit to the analytical solution.
+# The stress values are tracked through time in the log file using the composition statistics postprocessor,
+# which reports the min, max, and average value of each compositional field after each time step. Given
+# that there is no discrepancy between the numerical and elastic time steps and stress averaging is not invoked,
+# the min, max, and average stress values remain equal over time.
+
+# Global parameters
+set Dimension                                  = 2
+set Start time                                 = 0
+set End time                                   = 8
+set Use years in output instead of seconds     = false
+set Maximum time step                          = 0.01
+set Output directory                           = output-viscoelastic_plastic_simple_shear
+set Pressure normalization                     = surface
+set Surface pressure                           = 0.
+set Nonlinear solver scheme                    = single Advection, iterated Stokes
+set Max nonlinear iterations                   = 30
+set Nonlinear solver tolerance                 = 1e-5
+set Max nonlinear iterations in pre-refinement = 0
+
+# Solver settings
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance             = 1e-9
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set X repetitions = 2
+    set Y repetitions = 2
+    set X periodic = true
+  end
+end
+
+# Velocity boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+
+  subsection Function
+    set Function expression = if(t<1, if (y > 0.5, 0.05, 0), 0); \
+                              0
+  end
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Spatial domain of different compositional fields.
+# The elastic stress tensor components are set to 0 initially.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0;0.0;0.0
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Because we set the stress exponent n=1, the strain rate term of the dislocation creep
+    # equation becomes 1 as it is set to the power of 0. Furthermore E=0 and P=0 so the exponential
+    # term equals 1 as well. This leads to a simplification of the dislocation creep equation to:
+    # eta = 1/2*prefactor^(-1/stress_exponent)
+    # So this parameter file gives a viscosity eta = 1/2*0.005(⁻1/1) = 100
+    set Prefactors for dislocation creep          = 0.005
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Viscous flow law = dislocation
+    set Densities                   =  1
+    set Elastic shear moduli        = 1.e2
+
+    # Even though we do not use a fixed elastic time step,
+    # this parameters needs to be set equal to the "maximum time step"
+    # as it is used to compute time step 0.
+    set Fixed elastic time step     = 0.01
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = maximum composition
+    set Cohesions                   = 3.5
+    set Angles of internal friction = 0.
+    set Minimum viscosity           = 1e-3
+    set Maximum viscosity           = 1e3
+  end
+end
+
+# The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
diff --git a/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm b/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm
index 8b4f09583d9..ae3a3bc71a8 100644
--- a/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm
+++ b/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm
@@ -61,9 +61,9 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
     set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0, 1.0
     set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0, 0.0
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm.bak b/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm.bak
new file mode 100644
index 00000000000..8b4f09583d9
--- /dev/null
+++ b/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm.bak
@@ -0,0 +1,177 @@
+# This benchmark examines flexure of a finite-length elastic plate based
+# on the setup described in Choi et al., 2013, JGR, v.118, p.2429-2444,
+# doi:10.1002/jgrb.50148. The model setup has a 50 km long and 5 km thick
+# elastic plate (shear modulus: 30 GPa, viscosity: 1e35 Pa s) overlaying a
+# viscous layer (viscosity: 1e17 Pa s, 12.5 km thick), which both have a density
+# of 2700 kg/m^3. The top of the model is a free surface, while the bottom
+# boundary is zero-slip and the sides are free-slip. The upper right corner
+# of the viscous layer is replaced with a low density (1890 kg/m^3) elastic
+# block, which drives flexure of the elastic plate (right side goes up, left
+# side goes down). The total topography obtained after the model has reached
+# equilibrium is 330 m, with -146.5 m and 183.5 m of topography, respectively,
+# on the left and right sides. The summed value and profiles differ slightly
+# from those reported in Choi et al. (see viscoelastic_plate_flexure.png within
+# the doc/ subdirectory of this folder), but closely match more recent experiments
+# performed by Cedric Thieulot. The curves from the experiments performed by
+# Cedric Thieulot are labeled 'ELEFANT, nelx=150', 'ELEFANT, nelx=250', and
+# '100x35'. For further details on these additional experiments, visit:
+# https://github.com/naliboff/fieldstone/blob/master/python_codes/fieldstone_64/results/flexureplate
+# The figure in this folder (viscoelastic_plate_flexure.png) was made and
+# provided by Cedric Thieulot.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1e3
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set CFL number                             = 0.1
+set Maximum time step                      = 5
+set Output directory                       = output-viscoelastic_plate_flexure
+set Pressure normalization                 = no
+
+# Model geometry (500 m initial resolution)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 100
+    set Y repetitions = 35
+    set X extent      = 50.0e3
+    set Y extent      = 17.5e3
+  end
+end
+
+# Mesh refinement specifications (refine to 250 m)
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Time steps between mesh refinement = 0
+end
+
+# Element types. The temperature polynomial degree is reduced
+# from the default value of 2 to 1, as temperature is not
+# relevant in this problem.
+subsection Discretization
+  set Composition polynomial degree           = 2
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 1
+  set Use locally conservative discretization = true
+  set Use discontinuous temperature discretization = false
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+    set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0, 1.0
+    set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0, 0.0
+  end
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom
+  set Tangential velocity boundary indicators = left, right
+end
+
+# Free surface advection (vertical or normal)
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+  set Additional tangential mesh velocity boundary indicators = left, right
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 5
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, plate, inclusion
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; \
+                              if (y>12.5e3, 1, 0); \
+                              if (x>=45e3 && y>=7.5e3 && y<=12.5e3, 1, 0);
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Fixed composition boundary indicators  =
+  set List of model names = initial composition
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# Initial temperature is constant
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   =  2700,  2700,  2700,  2700,  2700,  1890
+    set Viscosities                 = 1.e17, 1.e17, 1.e17, 1.e17, 1.e35, 1.e35
+    set Elastic shear moduli        = 1.e50, 1.e50, 1.e50, 1.e50, 3.e10, 3.e10
+    set Fixed elastic time step     = 5
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = maximum composition
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, material statistics, velocity statistics, topography, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate, named additional outputs
+    set Time between graphical output = 100
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+
+  subsection Topography
+    set Output to file           = true
+    set Time between text output = 100
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm.bak b/benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm.bak
new file mode 100644
index 00000000000..f5c6bf5106f
--- /dev/null
+++ b/benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm.bak
@@ -0,0 +1,172 @@
+# This parameter file constructs a 3D cube which is rotated around its vertical axis and sheared in the
+# xz-plane. It is adapted from Farrington et al. 2014 (Geophysics, Geochemistry, Geosystems), section "3.4.
+# Torsion Test in 3-D". According to the authors this is essentially an extension of the simple shear test
+# (see the viscoelastic_plastic_simple_shear benchmark prm file) into the third dimension.
+# While the model always rotates with a constant rate of 42/360 per unit time, shearing is only applied until
+# t = 0.5. At this point the shearing velocity is reduced to zero, and elastic stresses relax.
+# For t < 0.5 the analytical expression of the stress is given by:
+#   tau = exp(-mu/eta*t)*(C2*cos(V*t/h)-C1*sin(V*t/h))-C2
+# and for t >= 0.5:
+#   tau = exp(-mu/eta*tmax)*(C2*cos(V*tmax/h)-C1*sin(V*tmax/h))-C2)*exp(-mu/eta*(t-tmax))
+# with:
+#   tmax = 0.5 [s]     # time at which shearing stops
+#   eta = 100  [Pa s]  # the shear viscosity
+#   mu  = 100  [Pa]    # the shear modulus
+#   V = 0.3    [m/s]   # the shearing velocity
+#   h = 1      [m]     # the height of the box
+#   omega = 42 [deg/s] # the rotation rate
+#   C1 = -(V^2*eta^2*mu)/(mu^2*h^2+V^2*eta^2)
+#   C2 = -(V*h*eta*mu^2)/(mu^2*h^2+V^2*eta^2)
+#
+# These analytical stresses can be directly compared to the xz-component of the stress output (in the composition
+# statistics) from this parameter file.
+# Farrington et al., however, look at the stresses in an unrotated frame (their Fig. 1b), in which case both
+# the analytical stress and the ASPECT stress component need to be multiplied with cos(omega*t). Note that in the
+# Farrington paper the vertical axis is the y-axis, such that their stress component xy is ASPECT's stress
+# component xz.
+# With the time step size given in this parameter file, stresses are underestimated compared to the analytical
+# solution by about 0.9% for t < 0.5 and about 2% for t > 0.5. The fit of the numerical stress to the analytical
+# solution can be enhanced by choosing a smaller time step size.
+
+
+# Global parameters
+set Dimension                                  = 3
+set Start time                                 = 0
+set End time                                   = 2
+set Use years in output instead of seconds     = false
+
+# This will limit all time steps sizes to equal the "maximum time step" size
+set Maximum time step                          = 0.01
+set Output directory                           = output-viscoelastic_sheared_torsion
+set Pressure normalization                     = surface
+set Surface pressure                           = 0.
+set Nonlinear solver scheme                    = single Advection, iterated Stokes
+set Max nonlinear iterations                   = 30
+set Nonlinear solver tolerance                 = 1e-5
+set Max nonlinear iterations in pre-refinement = 0
+
+# Solver settings
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                = 1e-6
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set Z extent  = 1.0
+    set X repetitions = 5
+    set Y repetitions = 5
+    set Z repetitions = 5
+
+    # The axes' origins are offset such that the vertical axis runs through the middle of
+    # the box. This facilitates the velocity boundary condition of the rotational movement.
+    set Box origin X coordinate = -0.5
+    set Box origin Y coordinate = -0.5
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function, 4:function, 5:function
+
+  subsection Function
+    # circular rotation plus shearing until t=0.5
+    set Function expression = if(t<0.5, -sin(atan2(y,x))*sqrt(y*y+x*x)*42/360 + 0.3*z, -sin(atan2(y,x))*sqrt(y*y+x*x)*42/360) ;\
+                            cos(atan2(y,x))*sqrt(y*y+x*x)*42/360 ;\
+                            0
+  end
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name  = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_zz, ve_stress_xy, ve_stress_xz, ve_stress_yz
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Spatial domain of different compositional fields.
+# The elastic stress tensor components are set to 0 initially.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0;0.0;0.0;0.0;0.0;0.0
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # We use the dislocation creep law to prescribe a constant viscous viscosity.
+    # Because we set the stress exponent n=1, the strain rate term of the dislocation creep
+    # equation becomes 1 as it is set to the power of 0. Furthermore E=0 and P=0 so the exponential
+    # term equals 1 as well. This leads to a simplification of the dislocation creep equation to:
+    # eta = 1/2*prefactor^(-1/stress_exponent)
+    # So this parameter file gives a viscosity eta = 1/2*0.005(-1/1) = 100
+    set Prefactors for dislocation creep          = 0.005
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Viscous flow law = dislocation
+    set Densities                   =  1
+    set Elastic shear moduli        = 1.e2
+
+    # Even though we do not use a fixed elastic time step,
+    # this parameters needs to be set equal to the "maximum time step"
+    # as it is used to compute the elastic time step during time step 0.
+    set Fixed elastic time step     = 0.01
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = maximum composition
+
+    # Cohesion is set higher than the maximum stress expected in this benchmark,
+    # such that yielding does not occur
+    set Cohesions                   = 15
+    set Angles of internal friction = 0.
+    set Minimum viscosity           = 1e-3
+    set Maximum viscosity           = 1e3
+  end
+end
+
+# The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
diff --git a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm.bak b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm.bak
new file mode 100644
index 00000000000..aa4b2f544da
--- /dev/null
+++ b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm.bak
@@ -0,0 +1,191 @@
+# This parameter file reproduces a 2D analytical benchmark for the build-up
+# of stress in an initially unstressed viscoelastic medium subject to a
+# constant strain-rate. This benchmark is described in "Robust
+# characteristics method for modelling multiphase visco-elasto-plastic
+# thermo-mechanical problems" by Gerya and Yuen, 2007, Phys. Earth. Planet.
+# Inter., v. 163, p. 83-105. Full details of the benchmark are located in
+# section 3.1 and figure 3 of this manuscript.
+#
+# The analytical solution for viscoelastic stress build-up in
+# an incompressible medium with a constant strain-rate is:
+#   sigma_ij = 2 * edot_ii * eta * (1 - e^(-mu*t/eta)),
+# where sigma_ij is the elastic deviatoric stress tensor, edot_ij is
+# the deviatoric strain-rate, eta is the background viscosity, mu is the
+# shear modulus and t is time.
+#
+# Following the conditions described in section 3.1 and figure 3 from
+# Gerya and Yuen (2007), a 100x100 km body is subject to a constant
+# strain-rate of 1.e-14 s^-1 in both the horizontal and vertical directions.
+# Constant deformation is driven by inflow and outflow, respectively,
+# on the right and bottom walls. The top and left walls are free-slip.
+# The material has a viscosity of 1e22 Pa s and a shear modulus of 1e10 Pa.
+# With these values, the analytical solution predicts a horizontal
+# or vertical viscoelastic stress magnitude of ~ 200 MPa after 250 Kyr
+# of deformation. Significantly, the effective "viscoelastic" viscosity
+# is enforced to be constant through time by using a constant time step.
+# This is achieved by setting a maximum time step (1000 years) much lower
+# than the time step size given by the CFL number of 0.5.
+#
+# This result can be observed by viewing the compositional field values
+# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
+# of the viscoelastic stress tensor. Significantly, the composition is not
+# fixed on any boundary in order to prevent the formation of boundary artifacts
+# in the compositional fields tracking viscoelastic stresses.
+
+#  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 250e3
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 1
+set CFL number                             = 0.5
+set Maximum time step                      = 1000
+set Output directory                       = output
+set Timing output frequency                = 1
+set Pressure normalization                 = surface
+set Surface pressure                       = 0.
+
+# Solver settings
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+    set Linear solver tolerance = 1e-7
+    set Number of cheap Stokes solver steps = 2000
+  end
+end
+
+# Model geometry (100x100 km, 2 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 50
+    set Y repetitions = 50
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, left
+  set Prescribed velocity boundary indicators = bottom y:function, right x:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = cm=0.01, year=1, vel=3.154
+    set Function expression = if (x>50e3 , vel*cm/year, 0.); if (y<50e3 , vel*cm/year, 0.);
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0;
+  end
+end
+
+# Composition boundary conditions
+# We specify that no boundaries have a fixed composition
+# in order to prevent boundary effects from developing
+# in the compositional fields tracking viscoelastic stresses.
+subsection Boundary composition model
+  set Fixed composition boundary indicators =
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 293
+    set Left temperature   = 293
+    set Right temperature  = 293
+    set Top temperature    = 293
+  end
+end
+
+# Temperature initial conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 2800
+    set Viscosities                 = 1.e22
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, temperature statistics, velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate
+    set Time between graphical output = 10e3
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_particles.prm.bak b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_particles.prm.bak
new file mode 100644
index 00000000000..220b661bdd5
--- /dev/null
+++ b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_particles.prm.bak
@@ -0,0 +1,43 @@
+# This parameter file modifies the benchmark viscoelastic_stress_build_up.prm
+# to use particles, rather than compositional fields, to track viscoleastic
+# stresses.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+set Output directory = output_viscoelastic_stress_build-up_particles
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Compositional field methods = particles, particles, particles
+  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, particles, temperature statistics, velocity statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0e3
+  end
+
+  subsection Particles
+    set Time between data output    = 0
+    set Data output format          = vtu
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell  = 25
+  set Maximum particles per cell  = 35
+  set Load balancing strategy     = remove and add particles
+  set List of particle properties = initial composition, elastic stress
+  set Interpolation scheme        = bilinear least squares
+  set Update ghost particles      = true
+  set Particle generator name     = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1e5
+    end
+  end
+end
diff --git a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield.prm.bak b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield.prm.bak
new file mode 100644
index 00000000000..a0d946e36fc
--- /dev/null
+++ b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield.prm.bak
@@ -0,0 +1,43 @@
+# This parameter file modifies the benchmark viscoelastic_stress_build-up.prm
+# to use the Visco Plastic material model and include a constant
+# yield stress of 100 MPa. Without the imposed yield stress, the viscoelastic
+# stress will build up to ~ 200 MPa. However, the imposed yield stress will
+# truncate the viscoelastic stresses at the yield stress magnitude.
+# For additional information on the model setup and analytical solution,
+# see viscoelastic_stress_build-up.prm, which is located in this folder.
+#
+# The results can be observed by viewing the compositional field values
+# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
+# of the viscoelastic stress tensor. Significantly, the stress near the
+# model boundaries is incorrect due to the compositional field boundary
+# conditions, which are based on the initial compositional values (e.g., zero).
+# This leads to oscillations in the stress field near the boundaries, which
+# decay towards a constant value in the model interior as the stresses build up to
+# 100 MPa.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 100
+set End time  = 100e3
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5e-23
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+    set Viscosity averaging scheme  = harmonic
+    set Angles of internal friction = 0.
+    set Cohesions                   = 100.e6
+    set Densities                   = 2800
+  end
+end
diff --git a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield_particles.prm.bak b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield_particles.prm.bak
new file mode 100644
index 00000000000..fb937f42ef6
--- /dev/null
+++ b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield_particles.prm.bak
@@ -0,0 +1,74 @@
+# This parameter file modifies the benchmark viscoelastic_stress_build-up.prm
+# to use the Visco Plastic material model and include a constant
+# yield stress of 100 MPa. Without the imposed yield stress, the viscoelastic
+# stress will build up to ~ 200 MPa. However, the imposed yield stress will
+# truncate the viscoelastic stresses at the yield stress magnitude.
+# For additional information on the model setup and analytical solution,
+# see viscoelastic_stress_build-up.prm, which is located in this folder.
+#
+# The results can be observed by viewing the compositional field values
+# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
+# of the viscoelastic stress tensor or the equivalent values on particles,
+# which are used to store and track the viscoelastic stresses. This parameter
+# file differs from viscoelastic_stress_build-up_yield.prm only in the use
+# of active particles to track the elastic stresses.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 100
+set End time                               = 100e3
+set Output directory                       = output_viscoelastic_stress_build-up_yield_particles
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Compositional field methods = particles, particles, particles
+  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5e-23
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+    set Viscosity averaging scheme  = harmonic
+    set Angles of internal friction = 0.
+    set Cohesions                   = 100.e6
+    set Densities                   = 2800
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, particles, temperature statistics, velocity statistics, visualization
+
+  subsection Particles
+    set Time between data output    = 0
+    set Data output format          = vtu
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell  = 25
+  set Maximum particles per cell  = 35
+  set Load balancing strategy     = remove and add particles
+  set List of particle properties = initial composition, elastic stress
+  set Interpolation scheme        = bilinear least squares
+  set Update ghost particles      = true
+  set Particle generator name     = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1e5
+    end
+  end
+end
diff --git a/benchmarks/viscosity_grooves/viscosity_grooves.cc.bak b/benchmarks/viscosity_grooves/viscosity_grooves.cc.bak
new file mode 100644
index 00000000000..9b0eddf9ac3
--- /dev/null
+++ b/benchmarks/viscosity_grooves/viscosity_grooves.cc.bak
@@ -0,0 +1,473 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/box.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  namespace ViscosityGroovesBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+
+
+      Tensor<1,2>
+      ViscosityGrooves_velocity (const Point<2> &pos)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const double v_x = x*x*x*y+x*x+x*y+x;
+        const double v_y = -1.5*x*x*y*y-2*x*y-0.5*y*y-y;
+        return Point<2> (v_x,v_y);
+      }
+
+      double
+      ViscosityGrooves_pressure (const Point<2> &pos,
+                                 const GeometryModel::Interface<2> &geometry_model)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const GeometryModel::Box<2> *geometry
+          = dynamic_cast<const GeometryModel::Box<2>*> (&geometry_model);
+        const double L=geometry->get_extents()[0];
+        return x*x*y*y+x*y+5. - pow(L,4.)/9.-pow(L,2.)/4.-5.;
+      }
+
+      double
+      ViscosityGrooves_pressure (const Point<2> &, const GeometryModel::Interface<3> &)
+      {
+        Assert (false, ExcNotImplemented());
+        return 0.;
+      }
+
+      template <int dim>
+      class FunctionViscosityGrooves : public Function<dim>
+      {
+        public:
+          FunctionViscosityGrooves (const GeometryModel::Interface<dim> &geometry_model)
+            :
+            Function<dim>(dim+2),
+            geometry_model (geometry_model)
+          {}
+
+          void vector_value (const Point<dim>   &pos,
+                             Vector<double>   &values) const override
+          {
+            Assert (dim == 2, ExcNotImplemented());
+            Assert (values.size() >= 4, ExcInternalError());
+
+            const Point<2> p (pos[0], pos[1]);
+
+            const Tensor<1,2> v = AnalyticSolutions::ViscosityGrooves_velocity (p);
+            values[0] = v[0];
+            values[1] = v[1];
+            values[2] = AnalyticSolutions::ViscosityGrooves_pressure (p, geometry_model);
+          }
+
+        private:
+          const GeometryModel::Interface<dim> &geometry_model;
+      };
+    }
+
+
+    template <int dim>
+    class ViscosityGroovesBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        ViscosityGroovesBoundary();
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id ,
+                           const Point<dim> &position) const override;
+
+      private:
+        const double epsilon;
+
+    };
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class ViscosityGroovesMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> &pos = in.position[i];
+              const double x = pos[0];
+              const double y = pos[1];
+              out.viscosities[i] = -std::sin(x*x*y*y+x*y+5.)+1.+epsilon;
+              out.densities[i] = 1.;
+              out.compressibilities[i] = 0.;
+              out.specific_heat[i] = 0.;
+              out.thermal_expansion_coefficients[i] = 0.;
+              out.thermal_conductivities[i] = 0.;
+            }
+        }
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        double get_epsilon() const;
+
+        double epsilon;
+
+    };
+
+
+    template <int dim>
+    bool
+    ViscosityGroovesMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    ViscosityGroovesMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      //create a global section in the parameter file for parameters
+      //that describe this benchmark. note that we declare them here
+      //in the material model, but other kinds of plugins (e.g., the gravity
+      //model below) may also read these parameters even though they do not
+      //declare them
+      prm.enter_subsection("ViscosityGrooves benchmark");
+      {
+        prm.declare_entry("Viscosity parameter", "0.1",
+                          Patterns::Double (0.),
+                          "Viscosity parameter epsilon in the ViscosityGrooves benchmark.");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    ViscosityGroovesMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("ViscosityGrooves benchmark");
+      {
+        epsilon = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+    template <int dim>
+    double
+    ViscosityGroovesMaterial<dim>::get_epsilon() const
+    {
+      return epsilon;
+    }
+
+    template <int dim>
+    ViscosityGroovesBoundary<dim>::ViscosityGroovesBoundary ()
+      :
+      epsilon (0.)
+    {}
+
+    template <>
+    Tensor<1,2>
+    ViscosityGroovesBoundary<2>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<2> &p) const
+    {
+      return AnalyticSolutions::ViscosityGrooves_velocity (p);
+    }
+
+
+    template <>
+    Tensor<1,3>
+    ViscosityGroovesBoundary<3>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<3> &) const
+    {
+      Assert (false, ExcNotImplemented());
+      return Tensor<1,3>();
+    }
+
+    /**
+     * Gravity model for the ViscosityGrooves benchmark
+    */
+
+    template <int dim>
+    class ViscosityGroovesGravity : public aspect::GravityModel::Interface<dim>
+    {
+      public:
+        Tensor<1,dim> gravity_vector (const Point<dim> &pos) const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+        */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        double epsilon;
+
+    };
+
+    template <int dim>
+    Tensor<1,dim>
+    ViscosityGroovesGravity<dim>::
+    gravity_vector(const Point<dim> &pos) const
+    {
+      const double x=pos[0];
+      const double y=pos[1];
+      Tensor<1,dim> g;
+
+      const double eta=-std::sin(x*x*y*y+x*y+5.)+1.+epsilon;
+
+      const double costerm=std::cos(x*x*y*y+x*y+5.);
+
+      const double deta_dx=-y*(2.*x*y+1.)*costerm;
+      const double deta_dy=-x*(2.*x*y+1.)*costerm;
+
+      const double dpdx=2. * x  *y*y +y ;
+      const double dpdy=2. * x*x*y   +x ;
+
+      const double exx= 3.*x*x * y +2.*x +y +1.;
+      const double eyy=-3.*x*x * y -2.*x -y -1.;
+
+      const double exy=0.5*(x*x*x + x -3.*x*y*y -2.*y);
+      const double eyx=0.5*(x*x*x + x -3.*x*y*y -2.*y);
+
+      const double dexxdx= 6.*x*y+2.;
+      const double deyxdy=-3.*x*y-1.;
+
+      const double dexydx= 0.5*(3.*x*x +1. -3.*y*y);
+      const double deyydy= -3.*x*x -1.;
+
+      const double gx =-dpdx + 2.*eta*dexxdx + 2.*deta_dx*exx + 2.*eta*deyxdy + 2.*deta_dy*eyx;
+      const double gy =-dpdy + 2.*eta*dexydx + 2.*deta_dx*exy + 2.*eta*deyydy + 2.*deta_dy*eyy;
+
+      g[0]=-gx;
+      g[1]=-gy;
+
+      return g;
+    }
+
+    template <int dim>
+    void
+    ViscosityGroovesGravity<dim>::declare_parameters (ParameterHandler &)
+    {
+      //nothing to declare here. This plugin will however, read parameters
+      //declared by the material model in the "ViscosityGrooves benchmark" section
+    }
+
+    template <int dim>
+    void
+    ViscosityGroovesGravity<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("ViscosityGrooves benchmark");
+      {
+        epsilon = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+    }
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the Donea and Huerta FEM book (see manual).
+      */
+    template <int dim>
+    class ViscosityGroovesPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    ViscosityGroovesPostprocessor<dim>::execute (TableHandler &)
+    {
+      std::shared_ptr<Function<dim>> ref_func;
+      {
+
+        ref_func = std::make_unique<AnalyticSolutions::FunctionViscosityGrooves<dim>>(this->get_geometry_model());
+      }
+
+      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                          dim+2);
+      ComponentSelectFunction<dim> comp_p(dim, dim+2);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_u,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_p,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_p);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_ul2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_pl2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double u_l1 =  VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+      const double p_l1 =  VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+      const double u_l2 =  VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+      const double p_l2 =  VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+      std::ostringstream os;
+
+      os << std::scientific <<  u_l1
+         << ", " << p_l1
+         << ", " << u_l2
+         << ", " << p_l2;
+
+      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace ViscosityGroovesBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ViscosityGroovesMaterial,
+                                   "ViscosityGroovesMaterial",
+                                   "A material model that corresponds to the `ViscosityGrooves' benchmark. "
+                                   "See the manual for more information.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(ViscosityGroovesBoundary,
+                                            "ViscosityGroovesBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "`ViscosityGrooves' benchmark. See the manual for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(ViscosityGroovesPostprocessor,
+                                  "ViscosityGroovesPostprocessor",
+                                  "A postprocessor that compares the solution of the `ViscosityGrooves' benchmark "
+                                  "with the one computed by ASPECT "
+                                  "and reports the error. See the manual for more information.")
+
+    ASPECT_REGISTER_GRAVITY_MODEL(ViscosityGroovesGravity,
+                                  "ViscosityGroovesGravity",
+                                  "A gravity model in corresponding to the `ViscosityGrooves' benchmark. "
+                                  "See the manual for more information.")
+  }
+}
diff --git a/benchmarks/viscosity_grooves/viscosity_grooves.prm.bak b/benchmarks/viscosity_grooves/viscosity_grooves.prm.bak
new file mode 100644
index 00000000000..d7c2da3015f
--- /dev/null
+++ b/benchmarks/viscosity_grooves/viscosity_grooves.prm.bak
@@ -0,0 +1,82 @@
+############### Global parameters
+# This is a manufactured solution by Dave May (unpublished).
+
+set Additional shared libraries            = ./libviscosity_grooves.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = output_viscosity_grooves
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0  : ViscosityGroovesBoundary, \
+                                                1  : ViscosityGroovesBoundary, \
+                                                2  : ViscosityGroovesBoundary, \
+                                                3  : ViscosityGroovesBoundary
+end
+
+subsection Material model
+  set Model name = ViscosityGroovesMaterial
+end
+
+subsection Gravity model
+  set Model name = ViscosityGroovesGravity
+end
+
+# This is the epsilon parameter
+
+subsection ViscosityGrooves benchmark
+  set Viscosity parameter = 0.01
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, ViscosityGroovesPostprocessor
+
+  subsection Visualization
+    set Output format = vtu
+    set List of output variables = density, viscosity, strain rate, gravity
+  end
+end
+
+# Because it is a benchmark lower solver tolerance is set.
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.cc.bak b/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.cc.bak
new file mode 100644
index 00000000000..e4b7e8fe57a
--- /dev/null
+++ b/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.cc.bak
@@ -0,0 +1,402 @@
+/*
+  Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include "anelasticity_temperature.h"
+#include <aspect/material_model/interface.h>
+#include <aspect/initial_composition/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/simulator_access.h>
+#include <cmath>
+#include <algorithm>
+#include <functional>
+
+#include <boost/lexical_cast.hpp>
+#include <boost/math/tools/minima.hpp>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    AnelasticVs2T<dim>::AnelasticVs2T ()
+    {}
+
+    template <int dim>
+    void
+    AnelasticVs2T<dim>::initialize ()
+    {
+      Utilities::AsciiDataInitial<dim>::initialize(1);
+    }
+
+// set up Vs function that Brent minimization operates on
+    template <int dim>
+    double
+    AnelasticVs2T<dim>::
+    fVs (double x,
+         const double      depth,
+         const double      absolute_Vs,
+         const double      mu0,
+         const double      dmudT,
+         const double      dmudP,
+         const double      viscosity_prefactor,
+         const double      activation_energy,
+         const double      activation_volume,
+         const double      solidus_gradient,
+         const bool      use_original_model) const
+    {
+      return std::abs(yamauchi_takei_Vs(x,depth,mu0,dmudT,dmudP,viscosity_prefactor,activation_energy,activation_volume
+                                        ,solidus_gradient,use_original_model)-absolute_Vs);
+    }
+
+// set up volume change function that Brent minimization operates on
+    template <int dim>
+    double
+    AnelasticVs2T<dim>::
+    fdV (double x, const double bulk_modulus, const double bulk_modulus_pressure_derivative, const double pressure ) const
+    {
+      return std::abs((bulk_modulus*(3./2.)*(std::pow(x,7./3.)-std::pow(x,5./3.))*(1+(((3./4.)*
+                                                                                      (bulk_modulus_pressure_derivative-4))*(std::pow(x,2./3.)-1))))-pressure);
+    }
+
+// set up initial temperature
+    template <int dim>
+    double
+    AnelasticVs2T<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // determine depth
+      double depth;
+      depth = this->get_geometry_model().depth(position);
+
+      // declare temperature
+      double temperature;
+
+      // read absolute Vs in from ascii file
+      const double absolute_Vs = Utilities::AsciiDataInitial<dim>::get_data_component(position,0);
+
+      if (depth >= no_perturbation_depth)
+        {
+          // convert absolute Vs into temperature
+          // check if using Yamauchi & Takei 2016 parameterization
+          if (use_yamauchi_takei == true)
+            {
+              // specify anelasticity parameters
+              const double mu0=72.45;
+              const double dmudT=-0.01094;
+              const double dmudP=1.987;
+              const double viscosity_prefactor=6.22e21;
+              const double activation_energy=462.5e3;
+              const double activation_volume=7.913e-6;
+              const double solidus_gradient=1.018;
+              // specify Brent algorithm parameters
+              const double a=273;
+              const double b=3273;
+              using Result = std::pair<double, double>;
+              // create fVs function to use in Brent minimization and calculate temperature
+              auto bfunc = [ &,this] (double x)
+              {
+                return fVs(x, depth, absolute_Vs, mu0, dmudT,dmudP,
+                           viscosity_prefactor,activation_energy,activation_volume,solidus_gradient,use_original_model);
+              };
+              // determine maximum Vs
+              double maximum_Vs;
+              int fail;
+              maximum_Vs=yamauchi_takei_Vs(273.,depth,mu0,dmudT,dmudP,viscosity_prefactor,activation_energy,activation_volume
+                                           ,solidus_gradient,use_original_model);
+
+              // set number of fails to zero
+              fail=0;
+              // where absolute Vs exceeds maximum Vs, set temperature to 273 K
+              if (absolute_Vs>maximum_Vs)
+                {
+                  temperature=273.;
+                  fail=fail+1;
+                  std::cout << "Vs too fast for sensible temperature for " << fail << " points!" << std::endl;
+                }
+              else
+                {
+                  Result r1 = boost::math::tools::brent_find_minima(bfunc,a,b,16);
+                  temperature=r1.first;
+                }
+            }
+          else
+            {
+              Assert (false, ExcNotImplemented());
+              return 273.;
+            }
+        }
+      else
+        {
+          // set temperature to constant above specified depth
+          temperature = reference_temperature;
+        }
+      // return the absolute temperature in Kelvin
+      return temperature;
+    }
+
+    template <int dim>
+    double
+    AnelasticVs2T<dim>::
+    yamauchi_takei_Vs (double temperature,
+                       double depth,
+                       const double mu0,
+                       const double dmudT,
+                       const double dmudP,
+                       const double viscosity_prefactor,
+                       const double activation_energy,
+                       const double activation_volume,
+                       const double solidus_gradient,
+                       const bool use_original_model) const
+    {
+      // specify anelasticity parameters
+      const double critical_homologous_temperature = 0.94;
+      const double reduction_factor = 5;
+      const double background_amplitude = 0.664;
+      const double background_slope = 0.38;
+      const double peak_period = 6e-5;
+      const double melt_viscosity_factor = 0;
+      const double melt_peak_factor = 0;
+      const double reference_temperature = 1473;
+      const double reference_pressure = 1.5e9;
+      const double grain_size = 1e-3;
+      const double reference_grain_size = 1e-3;
+      const double grain_size_exponent = 3;
+      const double pressure_gradient = 3e-5;
+      const double gas_constant=8.3145;
+      // specify Grose & Afonso (2013) density parameters
+      const double a=1;
+      const double b=3;
+      const double bulk_modulus=130e9;
+      const double bulk_modulus_pressure_derivative=4.8;
+      const double gruneisen_parameter=6;
+      const double reference_density=3330;
+      // specify original density parameters
+      const double original_density=3291;
+      const double original_thermal_expansivity=3.59e-5;
+      const double original_bulk_modulus=115.2;
+      // initialize solidus
+      const double T_solidus = 1326.0 + 273 + (((depth-50000)/1e3)*solidus_gradient);
+      // initialize homologous_temperature
+      double homologous_temperature = temperature/T_solidus;
+      // initialize pressures
+      double pressure = depth/pressure_gradient;
+      // declare other parameters
+      double viscosity,viscosity_reduction_factor,peak_amplitude,peak_width,isothermal_volume_change;
+      double compressibility,pressure_dependent_density,integrated_thermal_expansivity,density;
+      double unrelaxed_compliance,storage_compliance,period,anelastic_Vs;
+      // begin calculation of Vs
+      if (homologous_temperature<critical_homologous_temperature)
+        {
+          viscosity_reduction_factor=1;
+        }
+      else if ((homologous_temperature>=critical_homologous_temperature) && (homologous_temperature<1))
+        {
+          viscosity_reduction_factor=std::exp((-1*((homologous_temperature-critical_homologous_temperature)/(homologous_temperature-
+                                                   (homologous_temperature*critical_homologous_temperature))))*std::log(reduction_factor));
+        }
+      else
+        {
+          viscosity_reduction_factor=(1/reduction_factor)*std::exp(-melt_viscosity_factor);
+        }
+      viscosity = std::pow(grain_size/reference_grain_size,grain_size_exponent)*viscosity_prefactor*std::exp((activation_energy/gas_constant)
+                  *(1/temperature-1/reference_temperature))*std::exp((activation_volume/gas_constant)*(pressure/temperature-reference_pressure/
+                                                                     reference_temperature))*viscosity_reduction_factor;
+      unrelaxed_compliance=1./(1e9*(mu0+(dmudP*pressure*1e-9)+(dmudT*(temperature-273))));
+      if (temperature<273)
+        {
+          // Vs is too high to give realistic temperature so viscosity, attenuation and unrelaxed compliance are reset
+          viscosity=1e40;
+          unrelaxed_compliance=1./(1e9*(mu0+(dmudP*pressure*1e-9)));
+          // attenuation=1e-9;
+        }
+      // evaluate Maxwell normalized shear wave period
+      double maxwell_relaxation_time=viscosity*unrelaxed_compliance;
+      if (use_original_model == true)
+        {
+          // set shear wave period as constant
+          period=100;
+        }
+      else
+        {
+          // calculate shear wave period incorporating depth dependence of Forsyth 1992
+          period=(3*depth)/4200;
+        }
+      double normalized_period=period/(2*M_PI*maxwell_relaxation_time);
+      // determine peak amplitudes
+      if (homologous_temperature < 0.91)
+        {
+          peak_amplitude=0.01;
+        }
+      else if ((homologous_temperature >= 0.91) && (homologous_temperature < 0.96))
+        {
+          peak_amplitude=0.01+(0.4*(homologous_temperature-0.91));
+        }
+      else if ((homologous_temperature >= 0.96) && (homologous_temperature < 1))
+        {
+          peak_amplitude=0.03;
+        }
+      else
+        {
+          peak_amplitude=0.03+melt_peak_factor;
+        }
+      // determine peak widths
+      if (homologous_temperature < 0.92)
+        {
+          peak_width=4;
+        }
+      else if ((homologous_temperature >= 0.92) && (homologous_temperature < 1))
+        {
+          peak_width=4+(37.5*(homologous_temperature-0.92));
+        }
+      else
+        {
+          peak_width=7;
+        }
+      // determine density
+      if (use_original_model == true)
+        {
+          // calculate density using original parameters from Yamauchi & Takei (2016)
+          density=original_density*(1-(original_thermal_expansivity*((temperature-273)-600))+((pressure*1e-9)/original_bulk_modulus));
+        }
+      else
+        {
+          // create fdV function to use in Brent minimization and calculate isothermal_volume_change and density using
+          // expressions in Grose & Afonso 2013
+          using Result2 = std::pair<double, double>;
+          auto vfunc = [ &,this] (double x)
+          {
+            return fdV(x, bulk_modulus, bulk_modulus_pressure_derivative, pressure);
+          };
+          Result2 r2 = boost::math::tools::brent_find_minima(vfunc,a,b,16);
+          isothermal_volume_change=r2.first;
+          compressibility=isothermal_volume_change*std::exp((gruneisen_parameter+1)*(std::pow(isothermal_volume_change,-1)-1));
+          pressure_dependent_density=reference_density*isothermal_volume_change;
+          integrated_thermal_expansivity=(2.832e-5*(temperature-273))+((0.758e-8/2)*(std::pow(temperature,2)-std::pow(273,2)));
+          density=pressure_dependent_density*(1-(compressibility*integrated_thermal_expansivity));
+        }
+      // determine J1 term (real part of complex compliance)
+      storage_compliance=unrelaxed_compliance*(1+((background_amplitude*std::pow(normalized_period,background_slope))
+                                                  /background_slope)+((std::sqrt(2*M_PI)/2)*peak_amplitude*peak_width*(1-
+                                                                      std::erf((std::log(peak_period/normalized_period))/(std::sqrt(2)*peak_width)))));
+      // determine J2 term (imaginary part of complex compliance)
+      //double loss_compliance=unrelaxed_compliance*(M_PI/2)*(background_amplitude*(std::pow(normalized_period,background_slope))+
+      // (peak_amplitude*std::exp(-1*(std::pow(std::log(peak_period/normalized_period),2)/
+      // (2*std::pow(peak_width,2))))))+(unrelaxed_compliance*normalized_period);
+      // calculate anharmonic Vs
+      // anharmonic_Vs=1/(std::sqrt(density*unrelaxed_compliance)*1e3);
+      // calculate Vs
+      anelastic_Vs=1/(std::sqrt(density*storage_compliance)*1e3);
+      // calculate attenuation
+      // attenuation=loss_compliance/storage_compliance;
+      return anelastic_Vs;
+    }
+
+    template <int dim>
+    void
+    AnelasticVs2T<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.declare_entry ("Remove temperature heterogeneity down to specified depth",
+                           boost::lexical_cast<std::string>(-std::numeric_limits<double>::max()),
+                           Patterns::Double (),
+                           "This will remove temperature variations prescribed by the input model "
+                           "down to the specified depth (in meters). Note that your resolution has "
+                           "to be adequate to capture this cutoff. For example if you specify a depth "
+                           "of 660km, but your closest spherical depth layers are only at 500km and "
+                           "750km (due to a coarse resolution) it will only remove heterogeneities "
+                           "down to 500km. Similar caution has to be taken when using adaptive meshing.");
+        prm.declare_entry ("Set reference temperature down to specified depth", "1600",
+                           Patterns::Double (),
+                           "This parameter sets the a constant value of temperature down to the specified depth.");
+        prm.declare_entry ("Use Yamauchi and Takei parameterization", "true",
+                           Patterns::Bool(),
+                           "This parameter determines whether to use the anelasticity model of "
+                           "Yamauchi & Takei (2016) to convert absolute Vs into temperature");
+        prm.declare_entry ("Use original density and frequency model of Yamauchi and Takei", "true",
+                           Patterns::Bool(),
+                           "Use original density and frequency model of Yamauchi & Takei (2016) where density"
+                           "has simple pressure-dependence and shear wave is period set at 100s");
+
+        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                          "$ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/",
+                                                          "box_2d_Vs_YT16.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AnelasticVs2T<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        no_perturbation_depth   = prm.get_double ("Remove temperature heterogeneity down to specified depth");
+        reference_temperature   = prm.get_double ("Set reference temperature down to specified depth");
+        use_yamauchi_takei = prm.get_bool ("Use Yamauchi and Takei parameterization");
+        use_original_model = prm.get_bool ("Use original density and frequency model of Yamauchi and Takei");
+
+        Utilities::AsciiDataBase<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AnelasticVs2T,
+                                              "anelastic Vs to temperature",
+                                              "Implementation of a model in which the initial temperature is calculated "
+                                              "from files containing absolute shear wave velocity (Vs) data in ascii format. "
+                                              "This plug-in allows you to select from a number of different models that"
+                                              "convert Vs into temperature, accounting for the anelastic behavior of mantle material."
+                                              "Note the required format of the "
+                                              "input data: The first lines may contain any number of comments "
+                                              "if they begin with `#', but one of these lines needs to "
+                                              "contain the number of grid points in each dimension as "
+                                              "for example `# POINTS: 3 3'. "
+                                              "The order of the data columns "
+                                              "has to be `x', `y', `Temperature [K]' in a 2d model and "
+                                              " `x', `y', `z', `Temperature [K]' in a 3d model, which means that "
+                                              "there has to be a single column "
+                                              "containing the temperature. "
+                                              "Note that the data in the input "
+                                              "files need to be sorted in a specific order: "
+                                              "the first coordinate needs to ascend first, "
+                                              "followed by the second and the third at last in order to "
+                                              "assign the correct data to the prescribed coordinates. "
+                                              "If you use a spherical model, "
+                                              "then the assumed grid changes. `x' will be replaced by "
+                                              "the radial distance of the point to the bottom of the model, "
+                                              "`y' by the azimuth angle and `z' by the polar angle measured "
+                                              "positive from the north pole. The grid will be assumed to be "
+                                              "a latitude-longitude grid. Note that the order "
+                                              "of spherical coordinates is `r', `phi', `theta' "
+                                              "and not `r', `theta', `phi', since this allows "
+                                              "for dimension independent expressions.")
+  }
+}
diff --git a/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.h.bak b/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.h.bak
new file mode 100644
index 00000000000..b6744f31e42
--- /dev/null
+++ b/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.h.bak
@@ -0,0 +1,135 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_anelasticity_temperature_h
+#define _aspect_initial_temperature_anelasticity_temperature_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+#include <cmath>
+#include <algorithm>
+#include <functional>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes an initial temperature field for a 2D or 3D shear wave velocity (Vs) model.
+     * Vs values are converted to temperature using the anelasticity parameterization of Yamauchi & Takei (2016).
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class AnelasticVs2T : public Utilities::AsciiDataInitial<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        AnelasticVs2T ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // Avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataInitial<dim>::initialize;
+
+        /**
+         * Return the boundary temperature as a function of position. For the
+         * current class, this function returns value from the text files.
+         */
+        double
+        initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters for the input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler  &prm);
+
+        /**
+         * Read the parameters from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * Function that assesses difference between input and calculated Vs for Brent minimization
+         */
+        double
+        fVs(double x, double depth, double absolute_Vs, double mu0, double dmudT,
+            double dmudP, double viscosity_prefactor, double activation_energy, double activation_volume,
+            double solidus_gradient, bool density_model_flag) const;
+
+        /**
+         * Function that assesses difference between input and calculated pressure for Brent minimization
+         */
+        double
+        fdV(double x, double bulk_modulus, double bulk_modulus_pressure_derivative, double pressure) const;
+
+        /**
+         * Function to calculate Vs using Yamauchi & Takei 2016 anelasticity parameterization
+         */
+        double
+        yamauchi_takei_Vs(double temperature, double depth, double mu0, double dmudT,
+                          double dmudP, double viscosity_prefactor, double activation_energy,
+                          double activation_volume, double solidus_gradient, bool density_model_flag) const;
+
+        /**
+         * Whether to remove temperature heterogeneity upper parts of model
+         */
+        double no_perturbation_depth;
+
+        /**
+         * Constant temperature to set where variations have been removed
+         */
+        double reference_temperature;
+
+        /**
+         * Whether to use Yamauchi & Takei (2016) anelasticity
+         * parameterization
+         */
+        bool use_yamauchi_takei;
+
+        /**
+         * Whether to use original parameters published in Yamauchi & Takei
+         * (2016) or an updated version that accounts for non-linear pressure
+         * dependence of thermal expansivity and depth dependence of shear
+         * wave period
+         */
+        bool use_original_model;
+
+    };
+  }
+}
+
+#endif
diff --git a/benchmarks/yamauchi_takei_2016_anelasticity/yamauchi_takei_2016_anelasticity.prm.bak b/benchmarks/yamauchi_takei_2016_anelasticity/yamauchi_takei_2016_anelasticity.prm.bak
new file mode 100644
index 00000000000..f704bf05f74
--- /dev/null
+++ b/benchmarks/yamauchi_takei_2016_anelasticity/yamauchi_takei_2016_anelasticity.prm.bak
@@ -0,0 +1,79 @@
+# This benchmark tests the ASPECT implementation of an initial temperature model
+# that converts absolute shear wave velocity to temperature using the anelasticity model of
+# Yamauchi & Takei 2016 (JGR). This .prm aims to recreate Figure 20 in the paper.
+# Output can be plotted and compared to results in Figure 20 by running plot_output.gmt
+# in the plot_output folder.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+set Additional shared libraries = ./libanelasticity_temperature.so
+set Output directory                       = output_yamauchi_takei_2016_anelasticity
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 52000
+    set Y extent = 100000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = anelastic Vs to temperature
+  set Remove temperature heterogeneity down to specified depth = 25000
+  set Set reference temperature down to specified depth = 600
+  set Use Yamauchi and Takei parameterization = true
+  set Use original density and frequency model of Yamauchi and Takei = true
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = box_2d_Vs_YT16.txt
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 6
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, point values
+
+  subsection Point values
+    set Evaluation points = 0,25000;2000,25000;4000,25000;\
+  6000,25000;8000,25000;10000,25000;12000,25000;14000,25000;16000,25000;18000,25000;20000,25000;22000,25000;24000,25000;26000,25000;\
+  28000,25000;30000,25000;32000,25000;34000,25000;36000,25000;38000,25000;40000,25000;42000,25000;44000,25000;46000,25000;\
+  48000,25000;50000,25000;52000,25000;0,50000;2000,50000;4000,50000;6000,50000;8000,50000;10000,50000;12000,50000;14000,50000;16000,50000;\
+  18000,50000;20000,50000;22000,50000;24000,50000;26000,50000;28000,50000;30000,50000;32000,50000;34000,50000;36000,50000;\
+  38000,50000;40000,50000;42000,50000;44000,50000;46000,50000;48000,50000;50000,50000;52000,50000
+  end
+end
diff --git a/benchmarks/zhong_et_al_93/zhong_case1.prm.bak b/benchmarks/zhong_et_al_93/zhong_case1.prm.bak
new file mode 100644
index 00000000000..0f3500e7267
--- /dev/null
+++ b/benchmarks/zhong_et_al_93/zhong_case1.prm.bak
@@ -0,0 +1,105 @@
+set Dimension                              = 2
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Use a one by one box
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# Approximate a delta function
+# perturbation at depth
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x1,x2
+    set Function constants  = lambda=1, pi=3.1415926536, L=1, depth=62, sigma = 0.5, N=64
+    set Function expression = 1/(sigma/N*L * sqrt( 2 * pi) ) * exp( -0.5*(x2-depth/N)*(x2-depth/N)/sigma/sigma/L/L*N*N ) * cos(2*pi/lambda*x1/L)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 0
+    set Top temperature    = 0
+  end
+end
+
+# Boussinesq approximation
+subsection Formulation
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Material model
+  set Model name = nondimensional
+
+  subsection Nondimensional model
+    set Di = 0.0
+    set Ra = 1.0
+    set Reference density = 1
+    set Reference specific heat = 1
+    set Use TALA = false
+  end
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = dynamic topography, visualization
+
+  subsection Visualization
+    set Output format                 = vtu
+    set List of output variables      = dynamic topography
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Dynamic topography
+    set Density above          = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/contrib/opendap/prm_files/aspect_test.prm.bak b/contrib/opendap/prm_files/aspect_test.prm.bak
new file mode 100644
index 00000000000..23b8dda81c2
--- /dev/null
+++ b/contrib/opendap/prm_files/aspect_test.prm.bak
@@ -0,0 +1,82 @@
+# Test the aspect simulator using local data match the file used
+# with the opendap client. See aspect_url_test.prm for an example
+# of that version.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output-adiabatic_boundary-no-url-test
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 50
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 35
+    set Chunk maximum longitude = 55
+    set Chunk minimum latitude = -28
+    set Chunk maximum latitude = -8
+    set Chunk inner radius = 5878137
+    set Chunk outer radius = 6378137
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic boundary
+
+  subsection Adiabatic boundary
+    set Data directory    = $ASPECT_SOURCE_DIR/contrib/opendap/input_files/
+    set Data file name    = lithospheric_thickness.txt
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Initial temperature
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, outer, west, east, south, north
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Material model
+  set Model name = simpler
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics
+
+  subsection Visualization
+    set List of output variables      = viscosity, density, strain rate
+    set Time between graphical output = 1.0
+    set Output format = vtu
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+    set Number of cheap Stokes solver steps = 50
+  end
+end
diff --git a/contrib/opendap/prm_files/aspect_url_test.prm.bak b/contrib/opendap/prm_files/aspect_url_test.prm.bak
new file mode 100644
index 00000000000..b5532978ba4
--- /dev/null
+++ b/contrib/opendap/prm_files/aspect_url_test.prm.bak
@@ -0,0 +1,78 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output-adiabatic_boundary-url-test
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 50
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 35
+    set Chunk maximum longitude = 55
+    set Chunk minimum latitude = -28
+    set Chunk maximum latitude = -8
+    set Chunk inner radius = 5878137
+    set Chunk outer radius = 6378137
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic boundary
+
+  subsection Adiabatic boundary
+    set Data directory    =
+    set Data file name       = http://balto.opendap.org/opendap/lithosphere_thickness/lithospheric_thickness.csv
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Initial temperature
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, outer, west, east, south, north
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Material model
+  set Model name = simpler
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics
+
+  subsection Visualization
+    set List of output variables      = viscosity, density, strain rate
+    set Time between graphical output = 1.0
+    set Output format = vtu
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+    set Number of cheap Stokes solver steps = 50
+  end
+end
diff --git a/contrib/perplex/perplex_lookup_composition.prm.bak b/contrib/perplex/perplex_lookup_composition.prm.bak
new file mode 100644
index 00000000000..8b519f72792
--- /dev/null
+++ b/contrib/perplex/perplex_lookup_composition.prm.bak
@@ -0,0 +1,84 @@
+# This test ensures that the PerpleX lookup material model works
+# with compositional fields enabled
+
+# WARNING: Please understand that the PerpleX Lookup material model is only a
+# proof-of-concept; the number of P-T-X evaluations is extremely large, which
+# means that ASPECT will be interminably slow for any real problems.
+
+set Dimension                              = 2
+set End time                               = 0
+set Adiabatic surface temperature          = 1300
+
+# KLB composition in the CFMAS system
+# The bulk composition is given by five compositional fields
+# which correspond to the components in the PerpleX input
+# file (in this case, SiO2, Al2O3, FeO and MgO).
+# As defined in the PerpleX input file, the composition is
+# given in weight amount. The total amount is normalized
+# by the PerpleX routines, so it doesn't need to equal 1 or 100.
+
+subsection Compositional fields
+  set Number of fields          = 4
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 0.44; 0.04; 0.08; 0.44
+  end
+end
+
+subsection Material model
+  set Model name                   = perplex lookup
+
+  subsection PerpleX lookup model
+    set PerpleX input file name    = pyrolite
+    set Viscosity                  = 1e21
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent                = 200e3
+    set X repetitions           = 1
+    set Y extent                = 800e3
+    set Y repetitions           = 16
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1300
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Output format = gnuplot
+    set Number of zones = 200
+  end
+end
diff --git a/contrib/python/notebooks/read_output_files/convection-box.prm.bak b/contrib/python/notebooks/read_output_files/convection-box.prm.bak
new file mode 100644
index 00000000000..055f18b7567
--- /dev/null
+++ b/contrib/python/notebooks/read_output_files/convection-box.prm.bak
@@ -0,0 +1,10 @@
+include $ASPECT_SOURCE_DIR/cookbooks/convection-box.prm
+
+set End time                               = 0.1
+set Output directory                       = output
+
+subsection Postprocess
+  subsection Visualization
+    set Output format = gnuplot
+  end
+end
diff --git a/contrib/python/scripts/__pycache__/aspect_input.cpython-312.pyc b/contrib/python/scripts/__pycache__/aspect_input.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f20772791edaa5583f3825072f4f8ffb89c04f7a
GIT binary patch
literal 8883
zcmcgyT}&HUmaekPKiFk#Y`}yhxIzfv4#6RTg#2~qhy0O*PUp8f(`n1N3NSIYyQ&<5
zV|q|)9!MvvCfm}+y%WuNrPVI0JS-2p61xwpNb?eDMk5zy6|a>Cq#0?|Z!~FbOT6r!
zbL+<r&174n-7dnVs_s4Ko_p@O-}$Nh*5z_gaQ))k!;$~&pr}9KgMOK`o7WfN<_X19
zw<w<GO>z1b&6{tTc;=Rwx7=cQ>o2HV7TyM}mA6A{<7=R`^A2chcqg<Do`u%QyP##K
zOu^dBd)$>|T8<?IiIbC@C`5QJlHj>XF(wOKERjmf+(;}Ay`9}DaYDTha>)_y#MR5E
zPhI1_LD_~fE!V~bE|QkVlA?sYGCXP{qDfxJG@eSPro`Cjn9S|lyKjG&)|v619lFk)
zy?l||$0bEB9+3qxsxKEgTj19Wzpw8>^MuOMS?Vq&+Ou%C1>W$ay-H=N0qS;;qNYvI
zV<J6jYrfM-Q4;;gEz>ZZT*e4Oo28#=^G%zxW}dlokc{uhnxiI~x=JzB6ce;$irm@Q
zT_M3mI6fAYW64BBoWgacB4T7h0I4NzGA55fza)$4sGJr-9g>5C3ssR!2wW7DD+@d~
zJVn$THb}#$;Lczdyau`iA-Effrv*Z;DbpCO&Vx)xi9`vQzni;4NF{CvXNnR16Y2_C
zOyUwr*vw=)!FQ9svW3i2X5^`qP<BY^VM!os8w%28->4v0iAY8UnX<!RD3uwUx@-{=
zvN$C&pj!zWT=M#4Xe>D)gvMiusfkcZOpXI%DKrWiN)Lx3QVJeJ-Jxg_NMpkxu)lar
zjtNpIo#H`9VJRxcQa}I}N0cLly1TW1sVT6rL`WZ@@(L3}?FI|8fdr&+p*%b^Gt_D=
zWoKtIifv2Dy(QPCxC42c;_fWiJ69S4YZOznWA-%m>{8rZz7cxnFBaYXubOtx4=$vY
zu49X%O4peeOtI<GoTcPz$_;#VthAN;%ZsZuK)T9Otmie%Lq*X}^~(x3#BOD{G3>S`
zi}tBm?osHOf@iSYcCcJC^q7g|sx7mr<*I#}<z`LKv^jZ`HoBb#o?x?<pf$7hQ`oE|
z$bW{xBGyz)m>8F8le!)6)r`1uz_`hXq*^ZlD44g4>*12XMVyRDf=W)zP{ac*B65hh
z4d39&M~eoMA6m3%$8j~-p!JG~!iF7-PJHFon;qB}h2{;LY75Rf=6V%-Q_ip0ca+>7
zVpZmv?VDPauRWhx*rjyzFZz{^6VH2JG!%XB7p`6_`mX)Q)@`dcpj&lNtV?8Jo~Qv@
z@L-tKIJ^auqVVs=i>IGyZ>MS5Fvu*$o3eB>rT6`?XB^eF;d-V$>r@%g4FasnYaEZ-
zhKmOP)!}p;b-LlwITEO~@TO*J8obsxYI(zzW%OC689Xw)B?BXn;%$;nTe6mMJoy_g
z-l}sGeN}6>=x=$;odMWrpypMnELkRN$(lyYSE-;aa|YlQ{UX<a)@~qR2NwswNvu)0
zCySA&dJ+&7yEtOgU8Hj)DNaP>Zf>1EHneW~*ioj$S`cuZ=7P2|GZIViWpi9el&vE8
zj##Q}6NOYf5(Q|LQh<wPW;_{706xnRQI^ol1g&KTr!G5%Pt%b&pdT;XD|;gG*l1z`
z;5aO$fLtm!O(sQN3de;JIh-5`tAiyNq``QY0JxJZC`<&F(8v(MIgZ$Vxt@qnb!>26
zu@y%3!mspuXy7ndDWCsI@NqDA>Z|UV3*R}YrmeZ&Je%KI*t)0a@BSy>!nMV&#Uq8j
zvoHIGl)j;2-{oS@2a5lL0#gsfTwDHP{%3_i&&$9eC2(l5{kgXo7<d^NR04y=z{LWy
ztyCAB-!b1>sM|9$SgNak()73~_fD~H*UTW9d+vU|=kfI1X9aKjOYa`VyQk<4&0JWu
zQ+D4=+jhmaJr`ZJwf?O%f27!PaB;^{$B|Owj{J^%>s)fyx#Db?yI*MQEjW7%Os{(G
zszVS22s}xz{|#D*zGyrH1JoRS`!@u(&6}OWH!PjTphDaW;YC$YB6ec9QDu$B>3o}o
z<0;61g_9Fh&5eEp{5Cz47Qh5;J#Rge49G(hH&QDbC$e%5c`NpbY}N#$)FA0|xMzqo
zrbn|tZ6)r@M#gdaI5<_tC~$xOtBe}Ig)ATg;b$lO=J=Y;PBx5k@XiXdZK?rSm#zUs
zh%9}V7QH+zBe0VzX6T-`^XyYIgqap}&-j<f;3BQMkDkigd!~Ep9uO@=A!K}$O7G8_
za8-Igu^^puEpi^OQ{|{`WuN|p_@~K1M(b<Q(TfIKe00vxmz(HoyWC*VoAr?&g9T4p
zr)|@A*a=(K&U^T}rwnknqTDDKaGEeUc?qZXAE)_gE703`tHIm53GZJTynTdsgJC7a
zu6Qf&QmOcQU7{?l2I8_`Uk~4qHRCzZSM@o~K+vyRrD~s>^8qYx%v{&8oZuZM9TBb)
z`Eny-asu8M7*7%&$b%qWseW5Y0<^dTH|v}KhHIVvc%62LUU(*P$U41~L?L25zCqj{
z3YyEdXmSFPT8%kKr~-#e4MECg@G|8ZLxdnB8hz^(kmpp8Cvi^M7E46qX<jIs1@I=$
zR8o?)88U6x6QU4JjwWImNIphl;AFTv!W6m&SQl|&hq)jN&W1Q2CV{>TbuBhwgXSqV
zV$%#wnZcEpt!kWJZo+&~^&H`(7_R7%c!)B4C7qCC6T)dxOp3vpvV(-_B%&u_SJ@Yd
zM$;2%O#Aq-u99sykA=9dvb(~PIIF5atp$cj7-OKbB9|Ji?T1$)Ht*wre+J|O2gOob
zw-*@yil_NCb<{FM&oU*q@5{`C%){&~11^O1%<cQ)aLL;^CqC}X@k`#;lBYh$JeBj{
zfI=?=2b92pVxV7X>Q_AdbIht49G*I~=xqi1x`rq0V>Wjqf3oQ5c<I@rc=i-Mp;?Q;
z`l&B>{g=)8Pyaela<}G(i|)>nXJ=kkJi8UoP8e0|o!jx?X3qS@C!~L=(qHiGEU|%n
z@82K&o1+WX1+lpEu)@N>0JyhW-(1gw4|Cg=T)RpwJAOU(^;kYV|H1r~{8X`}=Vi+w
zrRC6K+oD)(IXV0Oin}F0uDJJ>4j=s;^Ww^H?S)$-O84lTBljLiu>$!|NO8Y2e@Jon
zEqa&SM@pV%(ldX)=sB?1rg+|kzbkCx+|L!ZW4@-y?kgNPudwIgrqtS2U;{><O=0)G
zWDhFr!R7wTg%5sKxIJ1Jn^bP!TLs@mpD=w(QJ>H!O|L2H&?(b@QIu=Igc?xS(y-)e
zdDV6Nd3~|#jKT(I2j+Gawggvpzx$%0z{|kl=ky?Q;4YYE2j^sk-3GHS!R#(C(Z!Y}
zS8K`F_@w`Ff9^E8_}uxTuYGo)RNn~kcz`PaK{c~;gxUGcnV~Q%xL>#*{TB*1J}e}X
zWEH27Y|nrR)OSqr1WWCmuum(#?Mv+T?;siq6auGTFiPNJ(R-=DURs@^(dt$|qbd8=
z-0+f(EA2h?Vz@9eTKF`hwB3gU;uz)*EnLCA72=Ts)9{w~UoC}H3K|vfwISv=yj~x~
z?XnT!1NIv|G{n^Sqx%#Ze9cvAC)Gnq^duBOKB8#&!FTt}A5oKZ&>Xo9PDBM!1EL5@
zs==;S!+4`kqE<%YaWyEGx;Y1)SJGUAI)+LD;8a0X4od@(SVDp#3ZfMhr(ht4t9o&%
z0t{V*5nvfXK&Za}njp3!wi^<v!T~cC_J1Ir$^$1ENyg*J$yj2P%zK!0?BO~zbm}-v
zB+;G-dP>}|03p6WI*bW%_KJ);7c#rXLvuiCt*k-^GJ;0}EKZDesqU$w7FEhh1xP}L
zR2Q6x3|Im(bPClbc?@blBk2UG?Px4OV4TJ%`E+xqCsOhhtRCJcHc@6L>IQcOG^_D|
z%G9PqVYZkI)g}-wsJchcpOKtseoIqAB0VuIh`6b$I|E(HlL8dl$X;V5l4LC$W-Z#Z
z;Iyh;F(xG4+%;Sy{7Xw<N8qgQ2ttY|LruP*z&Tox8kbU0I9A`d$uXD{i=MdgF_{~V
zMDG}~V|@(d6(IEjSvw5UjxMf4GdsMkXcL}5kA}@?GxI_UyfaRaREvDbSGQ*j2By>*
z%d`kFg4hH8tIQ;UhPX3`8X#AU3##X&M<h6g6dWTpPxBE^Y)Gd1*mq&Xuh0vggl2~N
zu8jf*H~dx8%-|nuT(kV#sfU48ini>{op@#E@^$&aWqas*GrT~z)d(Q;y{+nDUBXN#
z=L(ts(Q?T4Mzsr}1;u&&SI}T-LJP(Q{zQ?&^h_&K3{ba2S~8;s*Y#P`IC9!>@eq<{
zU>2PYAZgQam||6jhBWo42P?RwhI^j745vy>(%(41U7Q@b1J)hEL!3k#BBm2fiV!);
za2R;lod{NaHRuvC+!LW{N0G2@C}<*a5=1RnHrE2Sa%~C{dDw9+9Tzd86*0Pbv%XZ`
zLa6lkCme%J{a#GMgC^p}{R>iDhK3~CcK2NC=hLP7txqmJzLak()_1H?=9)HeaBkn6
z_(cZdmM4zKj@<ryi?TJe?AcplJzow!09TpgAK(9XcIUTHVrqi`#;&=TYHedlhwS6O
zLQ7Izs7jJl7s4n~h+#+~RGoN!hG{Gb=C?tjqV}svla-{sb+A*L6{>8Ny{t}xt2sbo
zVpKR`$93*@B7@4^#MdNfNID?N+;o;2)oyqPT1A$@maj25Igu0E6?xB+F{IFBj39H7
zUK_R*nR#Z~{OB)?ajHgKs0aAk@U@|n|GU+{eSNh=c6EIlB+W8auHRSz@5Z(N*d4;v
zLTYG%L<{THzuUwbJj4d3fAW>ry=CPz?<M5~S~iN6#*UGl-C$uj9#Wrau)DWflW!AS
zcxZ4|ZNZ}1!V^Oy|Ig=xSmf^k?dpRKnfu&L@&&KTQ%cqG6#!dWl;8tWd<yW5WVh<)
zBy=&V8+sGHI4p49QR6Tm6#<>9fsu;~z)K~(rq<ry0sA_mrmhvZWZ)&i%nXCIRB<;x
z*J0BIO~$TAabg?3!)j#4S@EmfH-JM_h5=A@kn9?u_BakioWz=_B<pBOqN_KP(x6o>
z_Mbos1mm)kq{Ct2dr9TLTuZ_b#9+c;V?9(ngS6QE27V<8#3A1Te10f5S}E_g*VGmZ
zH)|<DO;J#s+j2J)XWP7U$+>^U-JBDa+&kwT3w=uGp~axmIq<@?)H$dFcJH!>d&Ta`
zk1sSR?FScYl=hR)hYHs|TxLH4&bvbMX{D`iVN_{*_j&75+rZaXU$o8+>EJHqK2iL;
z=SLKOFMP7{A6=B5-zr?buAIJ6xEWJUk1OwuEB^7qL`w0eO3j_$n(3xsX?Nd(pzJ=n
zcvIPZ8sD6uOXn`)%_aIfigpdrE6sri7gk*UoJDc9<nAi2_W5AZWh~{#N$#p6?njdl
z#OPn_Q~bxD_bUFg%j~%ocl}c)cdOXcIqy}Px|ZBs)oek6FD|U^2c53=gLc;_?+>-h
zE;)Nkns%#c|AaDEG=HcGG@<y9EDDPM)N@|(4=%G8N^Em30_pYa&>t(iVN=?VKkqJF
zxv|XNtPI$o{ZYl=x6B?WZLT$4#6QOX2+P%7u=v$ZO8+*5M?t^vpb*E+!;M;_uH=XC
z^~A{UAQLpd;clTKtA9j<T+oa^m0WO&-k1qa(OMqJWFGw#pBG7JM53_`SrCD&3Rn>|
zDASV|iX8zRkTVMCfFY|Ic#%_o3?4T`U-fGAwIOuA00U_VTcks9LkdWZ{+XdyBy8UQ
zum!{B6LhZUm3>G4o%zIKWZ8ZkBj*$Jij)1`qTQ$w^Ov>l=D)LqY(ZDq77p{tXgFLp
zC8e?>99I9s1U$RK5dLZZK>{9~;cz?_6%vvV4y&KE$v4PWTnv`BM2zeS=#h1bDD6K$
zZ64oZ>3-dQbRx;8<HEb*6?nw(OF9S5s+p$gZ|xL)hW-Opv*Ow_<0yGLXI!P))*0uT
s)kAyMIz6;&t=&)etsS^P(~WDNnEcQlu+eR6^@nNK>nvSEs~;!-2k+U>p8x;=

literal 0
HcmV?d00001

diff --git a/contrib/world_builder/include/app/main.h.bak b/contrib/world_builder/include/app/main.h.bak
new file mode 100644
index 00000000000..097d0caf137
--- /dev/null
+++ b/contrib/world_builder/include/app/main.h.bak
@@ -0,0 +1,27 @@
+/*
+  Copyright (C) 2020 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_APP_MAIN_H_
+#define WORLD_BUILDER_APP_MAIN_H_
+
+#include <string>
+
+bool find_command_line_option(char **begin, char **end, const std::string &option);
+
+#endif
diff --git a/contrib/world_builder/include/glm/glm.h.bak b/contrib/world_builder/include/glm/glm.h.bak
new file mode 100644
index 00000000000..3089ebc6876
--- /dev/null
+++ b/contrib/world_builder/include/glm/glm.h.bak
@@ -0,0 +1,248 @@
+#ifndef _glm_h
+#define _glm_h
+#include <array>
+#include <math.h>
+#include <limits>
+
+namespace WorldBuilder
+{
+  /**
+   * The code in this file is derived from the OpenGL Mathematics (GLM) library, which
+   * is available under two version of MIT Lincense (see below). The derived work in
+   * this file is avaible under the same licenses.
+   *
+   * The changes are mainly specializing and isolation functions which are needed in
+   * the World Builder.
+   *
+   * ================================================================================
+   * OpenGL Mathematics (GLM)
+   * --------------------------------------------------------------------------------
+   * GLM is licensed under The Happy Bunny License and MIT License
+   *
+   * ================================================================================
+   * The Happy Bunny License (Modified MIT License)
+   * --------------------------------------------------------------------------------
+   * Copyright (c) 2005 - 2014 G-Truc Creation
+   *
+   * Permission is hereby granted, free of charge, to any person obtaining a copy
+   * of this software and associated documentation files (the "Software"), to deal
+   * in the Software without restriction, including without limitation the rights
+   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   * copies of the Software, and to permit persons to whom the Software is
+   * furnished to do so, subject to the following conditions:
+   *
+   * The above copyright notice and this permission notice shall be included in
+   * all copies or substantial portions of the Software.
+   *
+   * Restrictions:
+   *  By making use of the Software for military purposes, you choose to make a
+   *  Bunny unhappy.
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+   * THE SOFTWARE.
+   *
+   * ================================================================================
+   * The MIT License
+   * --------------------------------------------------------------------------------
+   * Copyright (c) 2005 - 2014 G-Truc Creation
+   *
+   * Permission is hereby granted, free of charge, to any person obtaining a copy
+   * of this software and associated documentation files (the "Software"), to deal
+   * in the Software without restriction, including without limitation the rights
+   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   * copies of the Software, and to permit persons to whom the Software is
+   * furnished to do so, subject to the following conditions:
+   *
+   * The above copyright notice and this permission notice shall be included in
+   * all copies or substantial portions of the Software.
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+   * THE SOFTWARE.
+   */
+  namespace glm
+  {
+    namespace quaternion
+    {
+      struct quat
+      {
+        quat(double w_, double x_, double y_, double z_)
+          :
+          w(w_),
+          x(x_),
+          y(y_),
+          z(z_)
+        {}
+
+
+        const quat operator-() const
+        {
+          return quat(-w, -x, -y, -z);
+        }
+
+        const quat operator-(quat &p) const
+        {
+          return quat(p.w-w, p.x-x, p.y-y, p.z-z);
+        }
+
+        quat operator*(double const &s) const
+        {
+          return quat(
+                   w * s, x * s, y * s, z * s);
+        }
+
+
+        quat operator/( double const &s)
+        {
+          return quat(
+                   w / s, x / s, y / s, z / s);
+        }
+
+        quat operator+(quat const &p)
+        {
+          return quat(w + p.w, x + p.x, y + p.y, z + p.z);
+        }
+
+        double w, x, y, z;
+      };
+
+      inline quat operator*(double const &s,quat const &q)
+      {
+        return quat(
+                 q.w * s, q.x * s, q.y * s, q.z * s);
+      }
+
+
+
+      inline double dot(quat u, quat v)
+      {
+        return u.w * v.w + u.x * v.x + u.y * v.y + u.z * v.z;
+      }
+
+      inline double mix(double const     &x,
+                        double const     &y,
+                        double const     &a )
+      {
+        return x * (1.0 - a) + y * a;
+      }
+
+      inline quat quat_cast(std::array<std::array<double,3>,3> const &m)
+      {
+        double fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
+        double fourYSquaredMinus1 = m[1][1] - m[0][0] - m[2][2];
+        double fourZSquaredMinus1 = m[2][2] - m[0][0] - m[1][1];
+        double fourWSquaredMinus1 = m[0][0] + m[1][1] + m[2][2];
+
+        int biggestIndex = 0;
+        double fourBiggestSquaredMinus1 = fourWSquaredMinus1;
+        if (fourXSquaredMinus1 > fourBiggestSquaredMinus1)
+          {
+            fourBiggestSquaredMinus1 = fourXSquaredMinus1;
+            biggestIndex = 1;
+          }
+        if (fourYSquaredMinus1 > fourBiggestSquaredMinus1)
+          {
+            fourBiggestSquaredMinus1 = fourYSquaredMinus1;
+            biggestIndex = 2;
+          }
+        if (fourZSquaredMinus1 > fourBiggestSquaredMinus1)
+          {
+            fourBiggestSquaredMinus1 = fourZSquaredMinus1;
+            biggestIndex = 3;
+          }
+
+        double biggestVal = sqrt(fourBiggestSquaredMinus1 + static_cast<double>(1)) * static_cast<double>(0.5);
+        double mult = static_cast<double>(0.25) / biggestVal;
+
+        switch (biggestIndex)
+          {
+            case 0:
+              return quat {biggestVal, (m[1][2] - m[2][1]) *mult, (m[2][0] - m[0][2]) *mult, (m[0][1] - m[1][0]) *mult};
+            case 1:
+              return quat {(m[1][2] - m[2][1]) *mult, biggestVal, (m[0][1] + m[1][0]) *mult, (m[2][0] + m[0][2]) *mult};
+            case 2:
+              return quat {(m[2][0] - m[0][2]) *mult, (m[0][1] + m[1][0]) *mult, biggestVal, (m[1][2] + m[2][1]) *mult};
+            case 3:
+              return quat {(m[0][1] - m[1][0]) *mult, (m[2][0] + m[0][2]) *mult, (m[1][2] + m[2][1]) *mult, biggestVal};
+            default: // Silence a -Wswitch-default warning in GCC. Should never actually get here. Assert is just for sanity.
+              throw (false);
+              return quat {1, 0, 0, 0};
+          }
+      }
+
+
+
+      inline std::array<std::array<double,3>,3> mat3_cast(quat const &q)
+      {
+        std::array<std::array<double,3>,3> Result;
+        double qxx(q.x * q.x);
+        double qyy(q.y * q.y);
+        double qzz(q.z * q.z);
+        double qxz(q.x * q.z);
+        double qxy(q.x * q.y);
+        double qyz(q.y * q.z);
+        double qwx(q.w * q.x);
+        double qwy(q.w * q.y);
+        double qwz(q.w * q.z);
+
+        Result[0][0] = double(1) - double(2) * (qyy +  qzz);
+        Result[0][1] = double(2) * (qxy + qwz);
+        Result[0][2] = double(2) * (qxz - qwy);
+
+        Result[1][0] = double(2) * (qxy - qwz);
+        Result[1][1] = double(1) - double(2) * (qxx +  qzz);
+        Result[1][2] = double(2) * (qyz + qwx);
+
+        Result[2][0] = double(2) * (qxz + qwy);
+        Result[2][1] = double(2) * (qyz - qwx);
+        Result[2][2] = double(1) - double(2) * (qxx +  qyy);
+        return Result;
+      }
+
+      inline quat slerp(quat const &x, quat const &y, double a)
+      {
+        static_assert(std::numeric_limits<double>::is_iec559, "'slerp' only accept floating-point inputs");
+
+        quat z = y;
+
+        double cosTheta = dot(x, y);
+
+        // If cosTheta < 0, the interpolation will take the long way around the sphere.
+        // To fix this, one quat must be negated.
+        if (cosTheta < static_cast<double>(0))
+          {
+            z = -y;
+
+            cosTheta = -cosTheta;
+          }
+
+        // Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator
+        if (cosTheta > 1.0 - std::numeric_limits<double>::epsilon())
+          {
+            // Linear interpolation
+            return quat(
+                     mix(x.w, z.w, a),
+                     mix(x.x, z.x, a),
+                     mix(x.y, z.y, a),
+                     mix(x.z, z.z, a));
+          }
+        else
+          {
+            // Essential Mathematics, page 467
+            double angle = acos(cosTheta);
+            return (sin((1.0 - a) * angle) * x + sin(a * angle) * z) / sin(angle);
+          }
+      }
+    }
+  }
+}
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/rapidjson/allocators.h.bak b/contrib/world_builder/include/rapidjson/allocators.h.bak
new file mode 100644
index 00000000000..9e2aa49f7a3
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/allocators.h.bak
@@ -0,0 +1,308 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ALLOCATORS_H_
+#define RAPIDJSON_ALLOCATORS_H_
+
+#include "rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Allocator
+
+/*! \class rapidjson::Allocator
+    \brief Concept for allocating, resizing and freeing memory block.
+
+    Note that Malloc() and Realloc() are non-static but Free() is static.
+
+    So if an allocator need to support Free(), it needs to put its pointer in
+    the header of memory block.
+
+\code
+concept Allocator {
+    static const bool kNeedFree;    //!< Whether this allocator needs to call Free().
+
+    // Allocate a memory block.
+    // \param size of the memory block in bytes.
+    // \returns pointer to the memory block.
+    void* Malloc(size_t size);
+
+    // Resize a memory block.
+    // \param originalPtr The pointer to current memory block. Null pointer is permitted.
+    // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.)
+    // \param newSize the new size in bytes.
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize);
+
+    // Free a memory block.
+    // \param pointer to the memory block. Null pointer is permitted.
+    static void Free(void *ptr);
+};
+\endcode
+*/
+
+
+/*! \def RAPIDJSON_ALLOCATOR_DEFUALT_CHUNK_CAPACITY
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-defined kDefaultChunkCapacity definition.
+
+    User can define this as any \c size that is a power of 2.
+*/
+
+#ifndef RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
+#define RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024)
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CrtAllocator
+
+//! C-runtime library allocator.
+/*! This class is just wrapper for standard C library memory routines.
+    \note implements Allocator concept
+*/
+class CrtAllocator
+{
+  public:
+    static const bool kNeedFree = true;
+    void *Malloc(size_t size)
+    {
+      if (size) //  behavior of malloc(0) is implementation defined.
+        return std::malloc(size);
+      else
+        return NULL; // standardize to returning NULL.
+    }
+    void *Realloc(void *originalPtr, size_t originalSize, size_t newSize)
+    {
+      (void)originalSize;
+      if (newSize == 0)
+        {
+          std::free(originalPtr);
+          return NULL;
+        }
+      return std::realloc(originalPtr, newSize);
+    }
+    static void Free(void *ptr)
+    {
+      std::free(ptr);
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// MemoryPoolAllocator
+
+//! Default memory allocator used by the parser and DOM.
+/*! This allocator allocate memory blocks from pre-allocated memory chunks.
+
+    It does not free memory blocks. And Realloc() only allocate new memory.
+
+    The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.
+
+    User may also supply a buffer as the first chunk.
+
+    If the user-buffer is full then additional chunks are allocated by BaseAllocator.
+
+    The user-buffer is not deallocated by this allocator.
+
+    \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator.
+    \note implements Allocator concept
+*/
+template <typename BaseAllocator = CrtAllocator>
+class MemoryPoolAllocator
+{
+  public:
+    static const bool kNeedFree = false;    //!< Tell users that no need to call Free() with this allocator. (concept Allocator)
+
+    //! Constructor with chunkSize.
+    /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
+        \param baseAllocator The allocator for allocating memory chunks.
+    */
+    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator *baseAllocator = 0) :
+      chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
+    {
+    }
+
+    //! Constructor with user-supplied buffer.
+    /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.
+
+        The user buffer will not be deallocated when this allocator is destructed.
+
+        \param buffer User supplied buffer.
+        \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
+        \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
+        \param baseAllocator The allocator for allocating memory chunks.
+    */
+    MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator *baseAllocator = 0) :
+      chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
+    {
+      RAPIDJSON_ASSERT(buffer != 0);
+      RAPIDJSON_ASSERT(size > sizeof(ChunkHeader));
+      chunkHead_ = reinterpret_cast<ChunkHeader *>(buffer);
+      chunkHead_->capacity = size - sizeof(ChunkHeader);
+      chunkHead_->size = 0;
+      chunkHead_->next = 0;
+    }
+
+    //! Destructor.
+    /*! This deallocates all memory chunks, excluding the user-supplied buffer.
+    */
+    ~MemoryPoolAllocator()
+    {
+      Clear();
+      RAPIDJSON_DELETE(ownBaseAllocator_);
+    }
+
+    //! Deallocates all memory chunks, excluding the user-supplied buffer.
+    void Clear()
+    {
+      while (chunkHead_ && chunkHead_ != userBuffer_)
+        {
+          ChunkHeader *next = chunkHead_->next;
+          baseAllocator_->Free(chunkHead_);
+          chunkHead_ = next;
+        }
+      if (chunkHead_ && chunkHead_ == userBuffer_)
+        chunkHead_->size = 0; // Clear user buffer
+    }
+
+    //! Computes the total capacity of allocated memory chunks.
+    /*! \return total capacity in bytes.
+    */
+    size_t Capacity() const
+    {
+      size_t capacity = 0;
+      for (ChunkHeader *c = chunkHead_; c != 0; c = c->next)
+        capacity += c->capacity;
+      return capacity;
+    }
+
+    //! Computes the memory blocks allocated.
+    /*! \return total used bytes.
+    */
+    size_t Size() const
+    {
+      size_t size = 0;
+      for (ChunkHeader *c = chunkHead_; c != 0; c = c->next)
+        size += c->size;
+      return size;
+    }
+
+    //! Allocates a memory block. (concept Allocator)
+    void *Malloc(size_t size)
+    {
+      if (!size)
+        return NULL;
+
+      size = RAPIDJSON_ALIGN(size);
+      if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
+        if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
+          return NULL;
+
+      void *buffer = reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;
+      chunkHead_->size += size;
+      return buffer;
+    }
+
+    //! Resizes a memory block (concept Allocator)
+    void *Realloc(void *originalPtr, size_t originalSize, size_t newSize)
+    {
+      if (originalPtr == 0)
+        return Malloc(newSize);
+
+      if (newSize == 0)
+        return NULL;
+
+      originalSize = RAPIDJSON_ALIGN(originalSize);
+      newSize = RAPIDJSON_ALIGN(newSize);
+
+      // Do not shrink if new size is smaller than original
+      if (originalSize >= newSize)
+        return originalPtr;
+
+      // Simply expand it if it is the last allocation and there is sufficient space
+      if (originalPtr == reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize)
+        {
+          size_t increment = static_cast<size_t>(newSize - originalSize);
+          if (chunkHead_->size + increment <= chunkHead_->capacity)
+            {
+              chunkHead_->size += increment;
+              return originalPtr;
+            }
+        }
+
+      // Realloc process: allocate and copy memory, do not free original buffer.
+      if (void *newBuffer = Malloc(newSize))
+        {
+          if (originalSize)
+            std::memcpy(newBuffer, originalPtr, originalSize);
+          return newBuffer;
+        }
+      else
+        return NULL;
+    }
+
+    //! Frees a memory block (concept Allocator)
+    static void Free(void *ptr)
+    {
+      (void)ptr;  // Do nothing
+    }
+
+  private:
+    //! Copy constructor is not permitted.
+    MemoryPoolAllocator(const MemoryPoolAllocator &rhs) /* = delete */;
+    //! Copy assignment operator is not permitted.
+    MemoryPoolAllocator &operator=(const MemoryPoolAllocator &rhs) /* = delete */;
+
+    //! Creates a new chunk.
+    /*! \param capacity Capacity of the chunk in bytes.
+        \return true if success.
+    */
+    bool AddChunk(size_t capacity)
+    {
+      if (!baseAllocator_)
+        ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator)();
+      if (ChunkHeader *chunk = reinterpret_cast<ChunkHeader *>(baseAllocator_->Malloc(RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity)))
+        {
+          chunk->capacity = capacity;
+          chunk->size = 0;
+          chunk->next = chunkHead_;
+          chunkHead_ =  chunk;
+          return true;
+        }
+      else
+        return false;
+    }
+
+    static const int kDefaultChunkCapacity = RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< Default chunk capacity.
+
+    //! Chunk header for perpending to each chunk.
+    /*! Chunks are stored as a singly linked list.
+    */
+    struct ChunkHeader
+    {
+      size_t capacity;    //!< Capacity of the chunk in bytes (excluding the header itself).
+      size_t size;        //!< Current size of allocated memory in bytes.
+      ChunkHeader *next;  //!< Next chunk in the linked list.
+    };
+
+    ChunkHeader *chunkHead_;    //!< Head of the chunk linked-list. Only the head chunk serves allocation.
+    size_t chunk_capacity_;     //!< The minimum capacity of chunk when they are allocated.
+    void *userBuffer_;          //!< User supplied buffer.
+    BaseAllocator *baseAllocator_;  //!< base allocator for allocating memory chunks.
+    BaseAllocator *ownBaseAllocator_;   //!< base allocator created by this object.
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/contrib/world_builder/include/rapidjson/cursorstreamwrapper.h.bak b/contrib/world_builder/include/rapidjson/cursorstreamwrapper.h.bak
new file mode 100644
index 00000000000..fdaffb4e386
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/cursorstreamwrapper.h.bak
@@ -0,0 +1,89 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_CURSORSTREAMWRAPPER_H_
+#define RAPIDJSON_CURSORSTREAMWRAPPER_H_
+
+#include "stream.h"
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
+RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+
+//! Cursor stream wrapper for counting line and column number if error exists.
+/*!
+    \tparam InputStream     Any stream that implements Stream Concept
+*/
+template <typename InputStream, typename Encoding = UTF8<> >
+class CursorStreamWrapper : public GenericStreamWrapper<InputStream, Encoding>
+{
+  public:
+    typedef typename Encoding::Ch Ch;
+
+    CursorStreamWrapper(InputStream &is):
+      GenericStreamWrapper<InputStream, Encoding>(is), line_(1), col_(0) {}
+
+    // counting line and column number
+    Ch Take()
+    {
+      Ch ch = this->is_.Take();
+      if (ch == '\n')
+        {
+          line_ ++;
+          col_ = 0;
+        }
+      else
+        {
+          col_ ++;
+        }
+      return ch;
+    }
+
+    //! Get the error line number, if error exists.
+    size_t GetLine() const
+    {
+      return line_;
+    }
+    //! Get the error column number, if error exists.
+    size_t GetColumn() const
+    {
+      return col_;
+    }
+
+  private:
+    size_t line_;   //!< Current Line
+    size_t col_;    //!< Current Column
+};
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_POP
+#endif
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_POP
+#endif
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_CURSORSTREAMWRAPPER_H_
diff --git a/contrib/world_builder/include/rapidjson/encodedstream.h.bak b/contrib/world_builder/include/rapidjson/encodedstream.h.bak
new file mode 100644
index 00000000000..38b259332db
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/encodedstream.h.bak
@@ -0,0 +1,485 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ENCODEDSTREAM_H_
+#define RAPIDJSON_ENCODEDSTREAM_H_
+
+#include "stream.h"
+#include "memorystream.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Input byte stream wrapper with a statically bound encoding.
+/*!
+    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
+    \tparam InputByteStream Type of input byte stream. For example, FileReadStream.
+*/
+template <typename Encoding, typename InputByteStream>
+class EncodedInputStream
+{
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+  public:
+    typedef typename Encoding::Ch Ch;
+
+    EncodedInputStream(InputByteStream &is) : is_(is)
+    {
+      current_ = Encoding::TakeBOM(is_);
+    }
+
+    Ch Peek() const
+    {
+      return current_;
+    }
+    Ch Take()
+    {
+      Ch c = current_;
+      current_ = Encoding::Take(is_);
+      return c;
+    }
+    size_t Tell() const
+    {
+      return is_.Tell();
+    }
+
+    // Not implemented
+    void Put(Ch)
+    {
+      RAPIDJSON_ASSERT(false);
+    }
+    void Flush()
+    {
+      RAPIDJSON_ASSERT(false);
+    }
+    Ch *PutBegin()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t PutEnd(Ch *)
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+
+  private:
+    EncodedInputStream(const EncodedInputStream &);
+    EncodedInputStream &operator=(const EncodedInputStream &);
+
+    InputByteStream &is_;
+    Ch current_;
+};
+
+//! Specialized for UTF8 MemoryStream.
+template <>
+class EncodedInputStream<UTF8<>, MemoryStream>
+{
+  public:
+    typedef UTF8<>::Ch Ch;
+
+    EncodedInputStream(MemoryStream &is) : is_(is)
+    {
+      if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
+      if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
+      if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
+    }
+    Ch Peek() const
+    {
+      return is_.Peek();
+    }
+    Ch Take()
+    {
+      return is_.Take();
+    }
+    size_t Tell() const
+    {
+      return is_.Tell();
+    }
+
+    // Not implemented
+    void Put(Ch) {}
+    void Flush() {}
+    Ch *PutBegin()
+    {
+      return 0;
+    }
+    size_t PutEnd(Ch *)
+    {
+      return 0;
+    }
+
+    MemoryStream &is_;
+
+  private:
+    EncodedInputStream(const EncodedInputStream &);
+    EncodedInputStream &operator=(const EncodedInputStream &);
+};
+
+//! Output byte stream wrapper with statically bound encoding.
+/*!
+    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
+    \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
+*/
+template <typename Encoding, typename OutputByteStream>
+class EncodedOutputStream
+{
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+  public:
+    typedef typename Encoding::Ch Ch;
+
+    EncodedOutputStream(OutputByteStream &os, bool putBOM = true) : os_(os)
+    {
+      if (putBOM)
+        Encoding::PutBOM(os_);
+    }
+
+    void Put(Ch c)
+    {
+      Encoding::Put(os_, c);
+    }
+    void Flush()
+    {
+      os_.Flush();
+    }
+
+    // Not implemented
+    Ch Peek() const
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    Ch Take()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t Tell() const
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    Ch *PutBegin()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t PutEnd(Ch *)
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+
+  private:
+    EncodedOutputStream(const EncodedOutputStream &);
+    EncodedOutputStream &operator=(const EncodedOutputStream &);
+
+    OutputByteStream &os_;
+};
+
+#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
+
+//! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
+/*!
+    \tparam CharType Type of character for reading.
+    \tparam InputByteStream type of input byte stream to be wrapped.
+*/
+template <typename CharType, typename InputByteStream>
+class AutoUTFInputStream
+{
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+  public:
+    typedef CharType Ch;
+
+    //! Constructor.
+    /*!
+        \param is input stream to be wrapped.
+        \param type UTF encoding type if it is not detected from the stream.
+    */
+    AutoUTFInputStream(InputByteStream &is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false)
+    {
+      RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
+      DetectType();
+      static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
+      takeFunc_ = f[type_];
+      current_ = takeFunc_(*is_);
+    }
+
+    UTFType GetType() const
+    {
+      return type_;
+    }
+    bool HasBOM() const
+    {
+      return hasBOM_;
+    }
+
+    Ch Peek() const
+    {
+      return current_;
+    }
+    Ch Take()
+    {
+      Ch c = current_;
+      current_ = takeFunc_(*is_);
+      return c;
+    }
+    size_t Tell() const
+    {
+      return is_->Tell();
+    }
+
+    // Not implemented
+    void Put(Ch)
+    {
+      RAPIDJSON_ASSERT(false);
+    }
+    void Flush()
+    {
+      RAPIDJSON_ASSERT(false);
+    }
+    Ch *PutBegin()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t PutEnd(Ch *)
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+
+  private:
+    AutoUTFInputStream(const AutoUTFInputStream &);
+    AutoUTFInputStream &operator=(const AutoUTFInputStream &);
+
+    // Detect encoding type with BOM or RFC 4627
+    void DetectType()
+    {
+      // BOM (Byte Order Mark):
+      // 00 00 FE FF  UTF-32BE
+      // FF FE 00 00  UTF-32LE
+      // FE FF        UTF-16BE
+      // FF FE        UTF-16LE
+      // EF BB BF     UTF-8
+
+      const unsigned char *c = reinterpret_cast<const unsigned char *>(is_->Peek4());
+      if (!c)
+        return;
+
+      unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
+      hasBOM_ = false;
+      if (bom == 0xFFFE0000)
+        {
+          type_ = kUTF32BE;
+          hasBOM_ = true;
+          is_->Take();
+          is_->Take();
+          is_->Take();
+          is_->Take();
+        }
+      else if (bom == 0x0000FEFF)
+        {
+          type_ = kUTF32LE;
+          hasBOM_ = true;
+          is_->Take();
+          is_->Take();
+          is_->Take();
+          is_->Take();
+        }
+      else if ((bom & 0xFFFF) == 0xFFFE)
+        {
+          type_ = kUTF16BE;
+          hasBOM_ = true;
+          is_->Take();
+          is_->Take();
+        }
+      else if ((bom & 0xFFFF) == 0xFEFF)
+        {
+          type_ = kUTF16LE;
+          hasBOM_ = true;
+          is_->Take();
+          is_->Take();
+        }
+      else if ((bom & 0xFFFFFF) == 0xBFBBEF)
+        {
+          type_ = kUTF8;
+          hasBOM_ = true;
+          is_->Take();
+          is_->Take();
+          is_->Take();
+        }
+
+      // RFC 4627: Section 3
+      // "Since the first two characters of a JSON text will always be ASCII
+      // characters [RFC0020], it is possible to determine whether an octet
+      // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
+      // at the pattern of nulls in the first four octets."
+      // 00 00 00 xx  UTF-32BE
+      // 00 xx 00 xx  UTF-16BE
+      // xx 00 00 00  UTF-32LE
+      // xx 00 xx 00  UTF-16LE
+      // xx xx xx xx  UTF-8
+
+      if (!hasBOM_)
+        {
+          int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
+          switch (pattern)
+            {
+              case 0x08:
+                type_ = kUTF32BE;
+                break;
+              case 0x0A:
+                type_ = kUTF16BE;
+                break;
+              case 0x01:
+                type_ = kUTF32LE;
+                break;
+              case 0x05:
+                type_ = kUTF16LE;
+                break;
+              case 0x0F:
+                type_ = kUTF8;
+                break;
+              default:
+                break; // Use type defined by user.
+            }
+        }
+
+      // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
+      if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
+      if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
+    }
+
+    typedef Ch (*TakeFunc)(InputByteStream &is);
+    InputByteStream *is_;
+    UTFType type_;
+    Ch current_;
+    TakeFunc takeFunc_;
+    bool hasBOM_;
+};
+
+//! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
+/*!
+    \tparam CharType Type of character for writing.
+    \tparam OutputByteStream type of output byte stream to be wrapped.
+*/
+template <typename CharType, typename OutputByteStream>
+class AutoUTFOutputStream
+{
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+  public:
+    typedef CharType Ch;
+
+    //! Constructor.
+    /*!
+        \param os output stream to be wrapped.
+        \param type UTF encoding type.
+        \param putBOM Whether to write BOM at the beginning of the stream.
+    */
+    AutoUTFOutputStream(OutputByteStream &os, UTFType type, bool putBOM) : os_(&os), type_(type)
+    {
+      RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
+
+      // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
+      if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
+      if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
+
+      static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
+      putFunc_ = f[type_];
+
+      if (putBOM)
+        PutBOM();
+    }
+
+    UTFType GetType() const
+    {
+      return type_;
+    }
+
+    void Put(Ch c)
+    {
+      putFunc_(*os_, c);
+    }
+    void Flush()
+    {
+      os_->Flush();
+    }
+
+    // Not implemented
+    Ch Peek() const
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    Ch Take()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t Tell() const
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    Ch *PutBegin()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t PutEnd(Ch *)
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+
+  private:
+    AutoUTFOutputStream(const AutoUTFOutputStream &);
+    AutoUTFOutputStream &operator=(const AutoUTFOutputStream &);
+
+    void PutBOM()
+    {
+      typedef void (*PutBOMFunc)(OutputByteStream &);
+      static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
+      f[type_](*os_);
+    }
+
+    typedef void (*PutFunc)(OutputByteStream &, Ch);
+
+    OutputByteStream *os_;
+    UTFType type_;
+    PutFunc putFunc_;
+};
+
+#undef RAPIDJSON_ENCODINGS_FUNC
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/contrib/world_builder/include/rapidjson/encodings.h.bak b/contrib/world_builder/include/rapidjson/encodings.h.bak
new file mode 100644
index 00000000000..8d966002514
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/encodings.h.bak
@@ -0,0 +1,855 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ENCODINGS_H_
+#define RAPIDJSON_ENCODINGS_H_
+
+#include "rapidjson.h"
+
+#if defined(_MSC_VER) && !defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
+#elif defined(__GNUC__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+RAPIDJSON_DIAG_OFF(overflow)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Encoding
+
+/*! \class rapidjson::Encoding
+    \brief Concept for encoding of Unicode characters.
+
+\code
+concept Encoding {
+    typename Ch;    //! Type of character. A "character" is actually a code unit in unicode's definition.
+
+    enum { supportUnicode = 1 }; // or 0 if not supporting unicode
+
+    //! \brief Encode a Unicode codepoint to an output stream.
+    //! \param os Output stream.
+    //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively.
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint);
+
+    //! \brief Decode a Unicode codepoint from an input stream.
+    //! \param is Input stream.
+    //! \param codepoint Output of the unicode codepoint.
+    //! \return true if a valid codepoint can be decoded from the stream.
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint);
+
+    //! \brief Validate one Unicode codepoint from an encoded stream.
+    //! \param is Input stream to obtain codepoint.
+    //! \param os Output for copying one codepoint.
+    //! \return true if it is valid.
+    //! \note This function just validating and copying the codepoint without actually decode it.
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os);
+
+    // The following functions are deal with byte streams.
+
+    //! Take a character from input byte stream, skip BOM if exist.
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is);
+
+    //! Take a character from input byte stream.
+    template <typename InputByteStream>
+    static Ch Take(InputByteStream& is);
+
+    //! Put BOM to output byte stream.
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os);
+
+    //! Put a character to output byte stream.
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, Ch c);
+};
+\endcode
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+// UTF8
+
+//! UTF-8 encoding.
+/*! http://en.wikipedia.org/wiki/UTF-8
+    http://tools.ietf.org/html/rfc3629
+    \tparam CharType Code unit for storing 8-bit UTF-8 data. Default is char.
+    \note implements Encoding concept
+*/
+template<typename CharType = char>
+struct UTF8
+{
+  typedef CharType Ch;
+
+  enum { supportUnicode = 1 };
+
+  template<typename OutputStream>
+  static void Encode(OutputStream &os, unsigned codepoint)
+  {
+    if (codepoint <= 0x7F)
+      os.Put(static_cast<Ch>(codepoint & 0xFF));
+    else if (codepoint <= 0x7FF)
+      {
+        os.Put(static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
+        os.Put(static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
+      }
+    else if (codepoint <= 0xFFFF)
+      {
+        os.Put(static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
+        os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+        os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+      }
+    else
+      {
+        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+        os.Put(static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
+        os.Put(static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
+        os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+        os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+      }
+  }
+
+  template<typename OutputStream>
+  static void EncodeUnsafe(OutputStream &os, unsigned codepoint)
+  {
+    if (codepoint <= 0x7F)
+      PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
+    else if (codepoint <= 0x7FF)
+      {
+        PutUnsafe(os, static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
+        PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
+      }
+    else if (codepoint <= 0xFFFF)
+      {
+        PutUnsafe(os, static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
+        PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+        PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+      }
+    else
+      {
+        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+        PutUnsafe(os, static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
+        PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
+        PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+        PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+      }
+  }
+
+  template <typename InputStream>
+  static bool Decode(InputStream &is, unsigned *codepoint)
+  {
+#define RAPIDJSON_COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
+#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
+    typename InputStream::Ch c = is.Take();
+    if (!(c & 0x80))
+      {
+        *codepoint = static_cast<unsigned char>(c);
+        return true;
+      }
+
+    unsigned char type = GetRange(static_cast<unsigned char>(c));
+    if (type >= 32)
+      {
+        *codepoint = 0;
+      }
+    else
+      {
+        *codepoint = (0xFFu >> type) & static_cast<unsigned char>(c);
+      }
+    bool result = true;
+    switch (type)
+      {
+        case 2:
+          RAPIDJSON_TAIL();
+          return result;
+        case 3:
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          return result;
+        case 4:
+          RAPIDJSON_COPY();
+          RAPIDJSON_TRANS(0x50);
+          RAPIDJSON_TAIL();
+          return result;
+        case 5:
+          RAPIDJSON_COPY();
+          RAPIDJSON_TRANS(0x10);
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          return result;
+        case 6:
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          return result;
+        case 10:
+          RAPIDJSON_COPY();
+          RAPIDJSON_TRANS(0x20);
+          RAPIDJSON_TAIL();
+          return result;
+        case 11:
+          RAPIDJSON_COPY();
+          RAPIDJSON_TRANS(0x60);
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          return result;
+        default:
+          return false;
+      }
+#undef RAPIDJSON_COPY
+#undef RAPIDJSON_TRANS
+#undef RAPIDJSON_TAIL
+  }
+
+  template <typename InputStream, typename OutputStream>
+  static bool Validate(InputStream &is, OutputStream &os)
+  {
+#define RAPIDJSON_COPY() os.Put(c = is.Take())
+#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
+    Ch c;
+    RAPIDJSON_COPY();
+    if (!(c & 0x80))
+      return true;
+
+    bool result = true;
+    switch (GetRange(static_cast<unsigned char>(c)))
+      {
+        case 2:
+          RAPIDJSON_TAIL();
+          return result;
+        case 3:
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          return result;
+        case 4:
+          RAPIDJSON_COPY();
+          RAPIDJSON_TRANS(0x50);
+          RAPIDJSON_TAIL();
+          return result;
+        case 5:
+          RAPIDJSON_COPY();
+          RAPIDJSON_TRANS(0x10);
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          return result;
+        case 6:
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          return result;
+        case 10:
+          RAPIDJSON_COPY();
+          RAPIDJSON_TRANS(0x20);
+          RAPIDJSON_TAIL();
+          return result;
+        case 11:
+          RAPIDJSON_COPY();
+          RAPIDJSON_TRANS(0x60);
+          RAPIDJSON_TAIL();
+          RAPIDJSON_TAIL();
+          return result;
+        default:
+          return false;
+      }
+#undef RAPIDJSON_COPY
+#undef RAPIDJSON_TRANS
+#undef RAPIDJSON_TAIL
+  }
+
+  static unsigned char GetRange(unsigned char c)
+  {
+    // Referring to DFA of http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    // With new mapping 1 -> 0x10, 7 -> 0x20, 9 -> 0x40, such that AND operation can test multiple types.
+    static const unsigned char type[] =
+    {
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+      0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
+      0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
+      0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+      0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+      8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+      10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
+    };
+    return type[c];
+  }
+
+  template <typename InputByteStream>
+  static CharType TakeBOM(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    typename InputByteStream::Ch c = Take(is);
+    if (static_cast<unsigned char>(c) != 0xEFu) return c;
+    c = is.Take();
+    if (static_cast<unsigned char>(c) != 0xBBu) return c;
+    c = is.Take();
+    if (static_cast<unsigned char>(c) != 0xBFu) return c;
+    c = is.Take();
+    return c;
+  }
+
+  template <typename InputByteStream>
+  static Ch Take(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    return static_cast<Ch>(is.Take());
+  }
+
+  template <typename OutputByteStream>
+  static void PutBOM(OutputByteStream &os)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xEFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xBBu));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xBFu));
+  }
+
+  template <typename OutputByteStream>
+  static void Put(OutputByteStream &os, Ch c)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>(c));
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// UTF16
+
+//! UTF-16 encoding.
+/*! http://en.wikipedia.org/wiki/UTF-16
+    http://tools.ietf.org/html/rfc2781
+    \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead.
+    \note implements Encoding concept
+
+    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
+    For streaming, use UTF16LE and UTF16BE, which handle endianness.
+*/
+template<typename CharType = wchar_t>
+struct UTF16
+{
+  typedef CharType Ch;
+  RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 2);
+
+  enum { supportUnicode = 1 };
+
+  template<typename OutputStream>
+  static void Encode(OutputStream &os, unsigned codepoint)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
+    if (codepoint <= 0xFFFF)
+      {
+        RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair
+        os.Put(static_cast<typename OutputStream::Ch>(codepoint));
+      }
+    else
+      {
+        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+        unsigned v = codepoint - 0x10000;
+        os.Put(static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
+        os.Put(static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
+      }
+  }
+
+
+  template<typename OutputStream>
+  static void EncodeUnsafe(OutputStream &os, unsigned codepoint)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
+    if (codepoint <= 0xFFFF)
+      {
+        RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair
+        PutUnsafe(os, static_cast<typename OutputStream::Ch>(codepoint));
+      }
+    else
+      {
+        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+        unsigned v = codepoint - 0x10000;
+        PutUnsafe(os, static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
+        PutUnsafe(os, static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
+      }
+  }
+
+  template <typename InputStream>
+  static bool Decode(InputStream &is, unsigned *codepoint)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
+    typename InputStream::Ch c = is.Take();
+    if (c < 0xD800 || c > 0xDFFF)
+      {
+        *codepoint = static_cast<unsigned>(c);
+        return true;
+      }
+    else if (c <= 0xDBFF)
+      {
+        *codepoint = (static_cast<unsigned>(c) & 0x3FF) << 10;
+        c = is.Take();
+        *codepoint |= (static_cast<unsigned>(c) & 0x3FF);
+        *codepoint += 0x10000;
+        return c >= 0xDC00 && c <= 0xDFFF;
+      }
+    return false;
+  }
+
+  template <typename InputStream, typename OutputStream>
+  static bool Validate(InputStream &is, OutputStream &os)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
+    typename InputStream::Ch c;
+    os.Put(static_cast<typename OutputStream::Ch>(c = is.Take()));
+    if (c < 0xD800 || c > 0xDFFF)
+      return true;
+    else if (c <= 0xDBFF)
+      {
+        os.Put(c = is.Take());
+        return c >= 0xDC00 && c <= 0xDFFF;
+      }
+    return false;
+  }
+};
+
+//! UTF-16 little endian encoding.
+template<typename CharType = wchar_t>
+struct UTF16LE : UTF16<CharType>
+{
+  template <typename InputByteStream>
+  static CharType TakeBOM(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    CharType c = Take(is);
+    return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
+  }
+
+  template <typename InputByteStream>
+  static CharType Take(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    unsigned c = static_cast<uint8_t>(is.Take());
+    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+    return static_cast<CharType>(c);
+  }
+
+  template <typename OutputByteStream>
+  static void PutBOM(OutputByteStream &os)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+  }
+
+  template <typename OutputByteStream>
+  static void Put(OutputByteStream &os, CharType c)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
+  }
+};
+
+//! UTF-16 big endian encoding.
+template<typename CharType = wchar_t>
+struct UTF16BE : UTF16<CharType>
+{
+  template <typename InputByteStream>
+  static CharType TakeBOM(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    CharType c = Take(is);
+    return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
+  }
+
+  template <typename InputByteStream>
+  static CharType Take(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
+    return static_cast<CharType>(c);
+  }
+
+  template <typename OutputByteStream>
+  static void PutBOM(OutputByteStream &os)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+  }
+
+  template <typename OutputByteStream>
+  static void Put(OutputByteStream &os, CharType c)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// UTF32
+
+//! UTF-32 encoding.
+/*! http://en.wikipedia.org/wiki/UTF-32
+    \tparam CharType Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead.
+    \note implements Encoding concept
+
+    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
+    For streaming, use UTF32LE and UTF32BE, which handle endianness.
+*/
+template<typename CharType = unsigned>
+struct UTF32
+{
+  typedef CharType Ch;
+  RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 4);
+
+  enum { supportUnicode = 1 };
+
+  template<typename OutputStream>
+  static void Encode(OutputStream &os, unsigned codepoint)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
+    RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+    os.Put(codepoint);
+  }
+
+  template<typename OutputStream>
+  static void EncodeUnsafe(OutputStream &os, unsigned codepoint)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
+    RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+    PutUnsafe(os, codepoint);
+  }
+
+  template <typename InputStream>
+  static bool Decode(InputStream &is, unsigned *codepoint)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
+    Ch c = is.Take();
+    *codepoint = c;
+    return c <= 0x10FFFF;
+  }
+
+  template <typename InputStream, typename OutputStream>
+  static bool Validate(InputStream &is, OutputStream &os)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
+    Ch c;
+    os.Put(c = is.Take());
+    return c <= 0x10FFFF;
+  }
+};
+
+//! UTF-32 little endian enocoding.
+template<typename CharType = unsigned>
+struct UTF32LE : UTF32<CharType>
+{
+  template <typename InputByteStream>
+  static CharType TakeBOM(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    CharType c = Take(is);
+    return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c;
+  }
+
+  template <typename InputByteStream>
+  static CharType Take(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    unsigned c = static_cast<uint8_t>(is.Take());
+    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
+    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
+    return static_cast<CharType>(c);
+  }
+
+  template <typename OutputByteStream>
+  static void PutBOM(OutputByteStream &os)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+  }
+
+  template <typename OutputByteStream>
+  static void Put(OutputByteStream &os, CharType c)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
+  }
+};
+
+//! UTF-32 big endian encoding.
+template<typename CharType = unsigned>
+struct UTF32BE : UTF32<CharType>
+{
+  template <typename InputByteStream>
+  static CharType TakeBOM(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    CharType c = Take(is);
+    return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c;
+  }
+
+  template <typename InputByteStream>
+  static CharType Take(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
+    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
+    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
+    return static_cast<CharType>(c);
+  }
+
+  template <typename OutputByteStream>
+  static void PutBOM(OutputByteStream &os)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+    os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+  }
+
+  template <typename OutputByteStream>
+  static void Put(OutputByteStream &os, CharType c)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
+    os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// ASCII
+
+//! ASCII encoding.
+/*! http://en.wikipedia.org/wiki/ASCII
+    \tparam CharType Code unit for storing 7-bit ASCII data. Default is char.
+    \note implements Encoding concept
+*/
+template<typename CharType = char>
+struct ASCII
+{
+  typedef CharType Ch;
+
+  enum { supportUnicode = 0 };
+
+  template<typename OutputStream>
+  static void Encode(OutputStream &os, unsigned codepoint)
+  {
+    RAPIDJSON_ASSERT(codepoint <= 0x7F);
+    os.Put(static_cast<Ch>(codepoint & 0xFF));
+  }
+
+  template<typename OutputStream>
+  static void EncodeUnsafe(OutputStream &os, unsigned codepoint)
+  {
+    RAPIDJSON_ASSERT(codepoint <= 0x7F);
+    PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
+  }
+
+  template <typename InputStream>
+  static bool Decode(InputStream &is, unsigned *codepoint)
+  {
+    uint8_t c = static_cast<uint8_t>(is.Take());
+    *codepoint = c;
+    return c <= 0X7F;
+  }
+
+  template <typename InputStream, typename OutputStream>
+  static bool Validate(InputStream &is, OutputStream &os)
+  {
+    uint8_t c = static_cast<uint8_t>(is.Take());
+    os.Put(static_cast<typename OutputStream::Ch>(c));
+    return c <= 0x7F;
+  }
+
+  template <typename InputByteStream>
+  static CharType TakeBOM(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    uint8_t c = static_cast<uint8_t>(Take(is));
+    return static_cast<Ch>(c);
+  }
+
+  template <typename InputByteStream>
+  static Ch Take(InputByteStream &is)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+    return static_cast<Ch>(is.Take());
+  }
+
+  template <typename OutputByteStream>
+  static void PutBOM(OutputByteStream &os)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    (void)os;
+  }
+
+  template <typename OutputByteStream>
+  static void Put(OutputByteStream &os, Ch c)
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+    os.Put(static_cast<typename OutputByteStream::Ch>(c));
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// AutoUTF
+
+//! Runtime-specified UTF encoding type of a stream.
+enum UTFType
+{
+  kUTF8 = 0,      //!< UTF-8.
+  kUTF16LE = 1,   //!< UTF-16 little endian.
+  kUTF16BE = 2,   //!< UTF-16 big endian.
+  kUTF32LE = 3,   //!< UTF-32 little endian.
+  kUTF32BE = 4    //!< UTF-32 big endian.
+};
+
+//! Dynamically select encoding according to stream's runtime-specified UTF encoding type.
+/*! \note This class can be used with AutoUTFInputtStream and AutoUTFOutputStream, which provides GetType().
+*/
+template<typename CharType>
+struct AutoUTF
+{
+  typedef CharType Ch;
+
+  enum { supportUnicode = 1 };
+
+#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
+
+  template<typename OutputStream>
+  static RAPIDJSON_FORCEINLINE void Encode(OutputStream &os, unsigned codepoint)
+  {
+    typedef void (*EncodeFunc)(OutputStream &, unsigned);
+    static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Encode) };
+    (*f[os.GetType()])(os, codepoint);
+  }
+
+  template<typename OutputStream>
+  static RAPIDJSON_FORCEINLINE void EncodeUnsafe(OutputStream &os, unsigned codepoint)
+  {
+    typedef void (*EncodeFunc)(OutputStream &, unsigned);
+    static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(EncodeUnsafe) };
+    (*f[os.GetType()])(os, codepoint);
+  }
+
+  template <typename InputStream>
+  static RAPIDJSON_FORCEINLINE bool Decode(InputStream &is, unsigned *codepoint)
+  {
+    typedef bool (*DecodeFunc)(InputStream &, unsigned *);
+    static const DecodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Decode) };
+    return (*f[is.GetType()])(is, codepoint);
+  }
+
+  template <typename InputStream, typename OutputStream>
+  static RAPIDJSON_FORCEINLINE bool Validate(InputStream &is, OutputStream &os)
+  {
+    typedef bool (*ValidateFunc)(InputStream &, OutputStream &);
+    static const ValidateFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Validate) };
+    return (*f[is.GetType()])(is, os);
+  }
+
+#undef RAPIDJSON_ENCODINGS_FUNC
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Transcoder
+
+//! Encoding conversion.
+template<typename SourceEncoding, typename TargetEncoding>
+struct Transcoder
+{
+  //! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream.
+  template<typename InputStream, typename OutputStream>
+  static RAPIDJSON_FORCEINLINE bool Transcode(InputStream &is, OutputStream &os)
+  {
+    unsigned codepoint;
+    if (!SourceEncoding::Decode(is, &codepoint))
+      return false;
+    TargetEncoding::Encode(os, codepoint);
+    return true;
+  }
+
+  template<typename InputStream, typename OutputStream>
+  static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream &is, OutputStream &os)
+  {
+    unsigned codepoint;
+    if (!SourceEncoding::Decode(is, &codepoint))
+      return false;
+    TargetEncoding::EncodeUnsafe(os, codepoint);
+    return true;
+  }
+
+  //! Validate one Unicode codepoint from an encoded stream.
+  template<typename InputStream, typename OutputStream>
+  static RAPIDJSON_FORCEINLINE bool Validate(InputStream &is, OutputStream &os)
+  {
+    return Transcode(is, os);   // Since source/target encoding is different, must transcode.
+  }
+};
+
+// Forward declaration.
+template<typename Stream>
+inline void PutUnsafe(Stream &stream, typename Stream::Ch c);
+
+//! Specialization of Transcoder with same source and target encoding.
+template<typename Encoding>
+struct Transcoder<Encoding, Encoding>
+{
+  template<typename InputStream, typename OutputStream>
+  static RAPIDJSON_FORCEINLINE bool Transcode(InputStream &is, OutputStream &os)
+  {
+    os.Put(is.Take());  // Just copy one code unit. This semantic is different from primary template class.
+    return true;
+  }
+
+  template<typename InputStream, typename OutputStream>
+  static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream &is, OutputStream &os)
+  {
+    PutUnsafe(os, is.Take());  // Just copy one code unit. This semantic is different from primary template class.
+    return true;
+  }
+
+  template<typename InputStream, typename OutputStream>
+  static RAPIDJSON_FORCEINLINE bool Validate(InputStream &is, OutputStream &os)
+  {
+    return Encoding::Validate(is, os);  // source/target encoding are the same
+  }
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__GNUC__) || (defined(_MSC_VER) && !defined(__clang__))
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/contrib/world_builder/include/rapidjson/error/en.h.bak b/contrib/world_builder/include/rapidjson/error/en.h.bak
new file mode 100644
index 00000000000..d817e0c5825
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/error/en.h.bak
@@ -0,0 +1,95 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ERROR_EN_H_
+#define RAPIDJSON_ERROR_EN_H_
+
+#include "error.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+//RAPIDJSON_DIAG_OFF(switch -enum)
+//  RAPIDJSON_DIAG_OFF(covered-switch -default)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Maps error code of parsing into error message.
+/*!
+    \ingroup RAPIDJSON_ERRORS
+    \param parseErrorCode Error code obtained in parsing.
+    \return the error message.
+    \note User can make a copy of this function for localization.
+        Using switch-case is safer for future modification of error codes.
+*/
+inline const RAPIDJSON_ERROR_CHARTYPE *GetParseError_En(ParseErrorCode parseErrorCode)
+{
+  switch (parseErrorCode)
+    {
+      case kParseErrorNone:
+        return RAPIDJSON_ERROR_STRING("No error.");
+
+      case kParseErrorDocumentEmpty:
+        return RAPIDJSON_ERROR_STRING("The document is empty.");
+      case kParseErrorDocumentRootNotSingular:
+        return RAPIDJSON_ERROR_STRING("The document root must not be followed by other values.");
+
+      case kParseErrorValueInvalid:
+        return RAPIDJSON_ERROR_STRING("Invalid value.");
+
+      case kParseErrorObjectMissName:
+        return RAPIDJSON_ERROR_STRING("Missing a name for object member.");
+      case kParseErrorObjectMissColon:
+        return RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member.");
+      case kParseErrorObjectMissCommaOrCurlyBracket:
+        return RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member.");
+
+      case kParseErrorArrayMissCommaOrSquareBracket:
+        return RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element.");
+
+      case kParseErrorStringUnicodeEscapeInvalidHex:
+        return RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string.");
+      case kParseErrorStringUnicodeSurrogateInvalid:
+        return RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid.");
+      case kParseErrorStringEscapeInvalid:
+        return RAPIDJSON_ERROR_STRING("Invalid escape character in string.");
+      case kParseErrorStringMissQuotationMark:
+        return RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string.");
+      case kParseErrorStringInvalidEncoding:
+        return RAPIDJSON_ERROR_STRING("Invalid encoding in string.");
+
+      case kParseErrorNumberTooBig:
+        return RAPIDJSON_ERROR_STRING("Number too big to be stored in double.");
+      case kParseErrorNumberMissFraction:
+        return RAPIDJSON_ERROR_STRING("Miss fraction part in number.");
+      case kParseErrorNumberMissExponent:
+        return RAPIDJSON_ERROR_STRING("Miss exponent in number.");
+
+      case kParseErrorTermination:
+        return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
+      case kParseErrorUnspecificSyntaxError:
+        return RAPIDJSON_ERROR_STRING("Unspecific syntax error.");
+
+      default:
+        return RAPIDJSON_ERROR_STRING("Unknown error.");
+    }
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_ERROR_EN_H_
diff --git a/contrib/world_builder/include/rapidjson/error/error.h.bak b/contrib/world_builder/include/rapidjson/error/error.h.bak
new file mode 100644
index 00000000000..3e4058097da
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/error/error.h.bak
@@ -0,0 +1,200 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ERROR_ERROR_H_
+#define RAPIDJSON_ERROR_ERROR_H_
+
+#include "../rapidjson.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+/*! \file error.h */
+
+/*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ERROR_CHARTYPE
+
+//! Character type of error messages.
+/*! \ingroup RAPIDJSON_ERRORS
+    The default character type is \c char.
+    On Windows, user can define this macro as \c TCHAR for supporting both
+    unicode/non-unicode settings.
+*/
+#ifndef RAPIDJSON_ERROR_CHARTYPE
+#define RAPIDJSON_ERROR_CHARTYPE char
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ERROR_STRING
+
+//! Macro for converting string literial to \ref RAPIDJSON_ERROR_CHARTYPE[].
+/*! \ingroup RAPIDJSON_ERRORS
+    By default this conversion macro does nothing.
+    On Windows, user can define this macro as \c _T(x) for supporting both
+    unicode/non-unicode settings.
+*/
+#ifndef RAPIDJSON_ERROR_STRING
+#define RAPIDJSON_ERROR_STRING(x) x
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// ParseErrorCode
+
+//! Error code of parsing.
+/*! \ingroup RAPIDJSON_ERRORS
+    \see GenericReader::Parse, GenericReader::GetParseErrorCode
+*/
+enum ParseErrorCode
+{
+  kParseErrorNone = 0,                        //!< No error.
+
+  kParseErrorDocumentEmpty,                   //!< The document is empty.
+  kParseErrorDocumentRootNotSingular,         //!< The document root must not follow by other values.
+
+  kParseErrorValueInvalid,                    //!< Invalid value.
+
+  kParseErrorObjectMissName,                  //!< Missing a name for object member.
+  kParseErrorObjectMissColon,                 //!< Missing a colon after a name of object member.
+  kParseErrorObjectMissCommaOrCurlyBracket,   //!< Missing a comma or '}' after an object member.
+
+  kParseErrorArrayMissCommaOrSquareBracket,   //!< Missing a comma or ']' after an array element.
+
+  kParseErrorStringUnicodeEscapeInvalidHex,   //!< Incorrect hex digit after \\u escape in string.
+  kParseErrorStringUnicodeSurrogateInvalid,   //!< The surrogate pair in string is invalid.
+  kParseErrorStringEscapeInvalid,             //!< Invalid escape character in string.
+  kParseErrorStringMissQuotationMark,         //!< Missing a closing quotation mark in string.
+  kParseErrorStringInvalidEncoding,           //!< Invalid encoding in string.
+
+  kParseErrorNumberTooBig,                    //!< Number too big to be stored in double.
+  kParseErrorNumberMissFraction,              //!< Miss fraction part in number.
+  kParseErrorNumberMissExponent,              //!< Miss exponent in number.
+
+  kParseErrorTermination,                     //!< Parsing was terminated.
+  kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
+};
+
+//! Result of parsing (wraps ParseErrorCode)
+/*!
+    \ingroup RAPIDJSON_ERRORS
+    \code
+        Document doc;
+        ParseResult ok = doc.Parse("[42]");
+        if (!ok) {
+            fprintf(stderr, "JSON parse error: %s (%u)",
+                    GetParseError_En(ok.Code()), ok.Offset());
+            exit(EXIT_FAILURE);
+        }
+    \endcode
+    \see GenericReader::Parse, GenericDocument::Parse
+*/
+struct ParseResult
+{
+    //!! Unspecified boolean type
+    typedef bool (ParseResult::*BooleanType)() const;
+  public:
+    //! Default constructor, no error.
+    ParseResult() : code_(kParseErrorNone), offset_(0) {}
+    //! Constructor to set an error.
+    ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}
+
+    //! Get the error code.
+    ParseErrorCode Code() const
+    {
+      return code_;
+    }
+    //! Get the error offset, if \ref IsError(), 0 otherwise.
+    size_t Offset() const
+    {
+      return offset_;
+    }
+
+    //! Explicit conversion to \c bool, returns \c true, iff !\ref IsError().
+    operator BooleanType() const
+    {
+      return !IsError() ? &ParseResult::IsError : NULL;
+    }
+    //! Whether the result is an error.
+    bool IsError() const
+    {
+      return code_ != kParseErrorNone;
+    }
+
+    bool operator==(const ParseResult &that) const
+    {
+      return code_ == that.code_;
+    }
+    bool operator==(ParseErrorCode code) const
+    {
+      return code_ == code;
+    }
+    friend bool operator==(ParseErrorCode code, const ParseResult &err)
+    {
+      return code == err.code_;
+    }
+
+    bool operator!=(const ParseResult &that) const
+    {
+      return !(*this == that);
+    }
+    bool operator!=(ParseErrorCode code) const
+    {
+      return !(*this == code);
+    }
+    friend bool operator!=(ParseErrorCode code, const ParseResult &err)
+    {
+      return err != code;
+    }
+
+    //! Reset error code.
+    void Clear()
+    {
+      Set(kParseErrorNone);
+    }
+    //! Update error code and offset.
+    void Set(ParseErrorCode code, size_t offset = 0)
+    {
+      code_ = code;
+      offset_ = offset;
+    }
+
+  private:
+    ParseErrorCode code_;
+    size_t offset_;
+};
+
+//! Function pointer type of GetParseError().
+/*! \ingroup RAPIDJSON_ERRORS
+
+    This is the prototype for \c GetParseError_X(), where \c X is a locale.
+    User can dynamically change locale in runtime, e.g.:
+\code
+    GetParseErrorFunc GetParseError = GetParseError_En; // or whatever
+    const RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode());
+\endcode
+*/
+typedef const RAPIDJSON_ERROR_CHARTYPE *(*GetParseErrorFunc)(ParseErrorCode);
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_ERROR_ERROR_H_
diff --git a/contrib/world_builder/include/rapidjson/filereadstream.h.bak b/contrib/world_builder/include/rapidjson/filereadstream.h.bak
new file mode 100644
index 00000000000..076e0e48f0f
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/filereadstream.h.bak
@@ -0,0 +1,130 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_FILEREADSTREAM_H_
+#define RAPIDJSON_FILEREADSTREAM_H_
+
+#include "stream.h"
+#include <cstdio>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(unreachable-code)
+RAPIDJSON_DIAG_OFF(missing-noreturn)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! File byte stream for input using fread().
+/*!
+    \note implements Stream concept
+*/
+class FileReadStream
+{
+  public:
+    typedef char Ch;    //!< Character type (byte).
+
+    //! Constructor.
+    /*!
+        \param fp File pointer opened for read.
+        \param buffer user-supplied buffer.
+        \param bufferSize size of buffer in bytes. Must >=4 bytes.
+    */
+    FileReadStream(std::FILE *fp, char *buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false)
+    {
+      RAPIDJSON_ASSERT(fp_ != 0);
+      RAPIDJSON_ASSERT(bufferSize >= 4);
+      Read();
+    }
+
+    Ch Peek() const
+    {
+      return *current_;
+    }
+    Ch Take()
+    {
+      Ch c = *current_;
+      Read();
+      return c;
+    }
+    size_t Tell() const
+    {
+      return count_ + static_cast<size_t>(current_ - buffer_);
+    }
+
+    // Not implemented
+    void Put(Ch)
+    {
+      RAPIDJSON_ASSERT(false);
+    }
+    void Flush()
+    {
+      RAPIDJSON_ASSERT(false);
+    }
+    Ch *PutBegin()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t PutEnd(Ch *)
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+
+    // For encoding detection only.
+    const Ch *Peek4() const
+    {
+      return (current_ + 4 <= bufferLast_) ? current_ : 0;
+    }
+
+  private:
+    void Read()
+    {
+      if (current_ < bufferLast_)
+        ++current_;
+      else if (!eof_)
+        {
+          count_ += readCount_;
+          readCount_ = std::fread(buffer_, 1, bufferSize_, fp_);
+          bufferLast_ = buffer_ + readCount_ - 1;
+          current_ = buffer_;
+
+          if (readCount_ < bufferSize_)
+            {
+              buffer_[readCount_] = '\0';
+              ++bufferLast_;
+              eof_ = true;
+            }
+        }
+    }
+
+    std::FILE *fp_;
+    Ch *buffer_;
+    size_t bufferSize_;
+    Ch *bufferLast_;
+    Ch *current_;
+    size_t readCount_;
+    size_t count_;  //!< Number of characters read
+    bool eof_;
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/contrib/world_builder/include/rapidjson/filewritestream.h.bak b/contrib/world_builder/include/rapidjson/filewritestream.h.bak
new file mode 100644
index 00000000000..291e6991c87
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/filewritestream.h.bak
@@ -0,0 +1,134 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_FILEWRITESTREAM_H_
+#define RAPIDJSON_FILEWRITESTREAM_H_
+
+#include "stream.h"
+#include <cstdio>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(unreachable-code)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Wrapper of C file stream for output using fwrite().
+/*!
+    \note implements Stream concept
+*/
+class FileWriteStream
+{
+  public:
+    typedef char Ch;    //!< Character type. Only support char.
+
+    FileWriteStream(std::FILE *fp, char *buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_)
+    {
+      RAPIDJSON_ASSERT(fp_ != 0);
+    }
+
+    void Put(char c)
+    {
+      if (current_ >= bufferEnd_)
+        Flush();
+
+      *current_++ = c;
+    }
+
+    void PutN(char c, size_t n)
+    {
+      size_t avail = static_cast<size_t>(bufferEnd_ - current_);
+      while (n > avail)
+        {
+          std::memset(current_, c, avail);
+          current_ += avail;
+          Flush();
+          n -= avail;
+          avail = static_cast<size_t>(bufferEnd_ - current_);
+        }
+
+      if (n > 0)
+        {
+          std::memset(current_, c, n);
+          current_ += n;
+        }
+    }
+
+    void Flush()
+    {
+      if (current_ != buffer_)
+        {
+          size_t result = std::fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
+          if (result < static_cast<size_t>(current_ - buffer_))
+            {
+              // failure deliberately ignored at this time
+              // added to avoid warn_unused_result build errors
+            }
+          current_ = buffer_;
+        }
+    }
+
+    // Not implemented
+    char Peek() const
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    char Take()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t Tell() const
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    char *PutBegin()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t PutEnd(char *)
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+
+  private:
+    // Prohibit copy constructor & assignment operator.
+    FileWriteStream(const FileWriteStream &);
+    FileWriteStream &operator=(const FileWriteStream &);
+
+    std::FILE *fp_;
+    char *buffer_;
+    char *bufferEnd_;
+    char *current_;
+};
+
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(FileWriteStream &stream, char c, size_t n)
+{
+  stream.PutN(c, n);
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/contrib/world_builder/include/rapidjson/fwd.h.bak b/contrib/world_builder/include/rapidjson/fwd.h.bak
new file mode 100644
index 00000000000..f280a4ea30b
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/fwd.h.bak
@@ -0,0 +1,151 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_FWD_H_
+#define RAPIDJSON_FWD_H_
+
+#include "rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+// encodings.h
+
+template<typename CharType> struct UTF8;
+template<typename CharType> struct UTF16;
+template<typename CharType> struct UTF16BE;
+template<typename CharType> struct UTF16LE;
+template<typename CharType> struct UTF32;
+template<typename CharType> struct UTF32BE;
+template<typename CharType> struct UTF32LE;
+template<typename CharType> struct ASCII;
+template<typename CharType> struct AutoUTF;
+
+template<typename SourceEncoding, typename TargetEncoding>
+struct Transcoder;
+
+// allocators.h
+
+class CrtAllocator;
+
+template <typename BaseAllocator>
+class MemoryPoolAllocator;
+
+// stream.h
+
+template <typename Encoding>
+struct GenericStringStream;
+
+typedef GenericStringStream<UTF8<char> > StringStream;
+
+template <typename Encoding>
+struct GenericInsituStringStream;
+
+typedef GenericInsituStringStream<UTF8<char> > InsituStringStream;
+
+// stringbuffer.h
+
+template <typename Encoding, typename Allocator>
+class GenericStringBuffer;
+
+typedef GenericStringBuffer<UTF8<char>, CrtAllocator> StringBuffer;
+
+// filereadstream.h
+
+class FileReadStream;
+
+// filewritestream.h
+
+class FileWriteStream;
+
+// memorybuffer.h
+
+template <typename Allocator>
+struct GenericMemoryBuffer;
+
+typedef GenericMemoryBuffer<CrtAllocator> MemoryBuffer;
+
+// memorystream.h
+
+struct MemoryStream;
+
+// reader.h
+
+template<typename Encoding, typename Derived>
+struct BaseReaderHandler;
+
+template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator>
+class GenericReader;
+
+typedef GenericReader<UTF8<char>, UTF8<char>, CrtAllocator> Reader;
+
+// writer.h
+
+template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
+class Writer;
+
+// prettywriter.h
+
+template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
+class PrettyWriter;
+
+// document.h
+
+template <typename Encoding, typename Allocator>
+struct GenericMember;
+
+template <bool Const, typename Encoding, typename Allocator>
+class GenericMemberIterator;
+
+template<typename CharType>
+struct GenericStringRef;
+
+template <typename Encoding, typename Allocator>
+class GenericValue;
+
+typedef GenericValue<UTF8<char>, MemoryPoolAllocator<CrtAllocator> > Value;
+
+template <typename Encoding, typename Allocator, typename StackAllocator>
+class GenericDocument;
+
+typedef GenericDocument<UTF8<char>, MemoryPoolAllocator<CrtAllocator>, CrtAllocator> Document;
+
+// pointer.h
+
+template <typename ValueType, typename Allocator>
+class GenericPointer;
+
+typedef GenericPointer<Value, CrtAllocator> Pointer;
+
+// schema.h
+
+template <typename SchemaDocumentType>
+class IGenericRemoteSchemaDocumentProvider;
+
+template <typename ValueT, typename Allocator>
+class GenericSchemaDocument;
+
+typedef GenericSchemaDocument<Value, CrtAllocator> SchemaDocument;
+typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
+
+template <
+  typename SchemaDocumentType,
+  typename OutputHandler,
+  typename StateAllocator>
+class GenericSchemaValidator;
+
+typedef GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<char>, void>, CrtAllocator> SchemaValidator;
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_RAPIDJSONFWD_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/biginteger.h.bak b/contrib/world_builder/include/rapidjson/internal/biginteger.h.bak
new file mode 100644
index 00000000000..04a30c670a7
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/biginteger.h.bak
@@ -0,0 +1,340 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_BIGINTEGER_H_
+#define RAPIDJSON_BIGINTEGER_H_
+
+#include "../rapidjson.h"
+
+#if defined(_MSC_VER) && !__INTEL_COMPILER && defined(_M_AMD64)
+#include <intrin.h> // for _umul128
+#pragma intrinsic(_umul128)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+  class BigInteger
+  {
+    public:
+      typedef uint64_t Type;
+
+      BigInteger(const BigInteger &rhs) : count_(rhs.count_)
+      {
+        std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
+      }
+
+      explicit BigInteger(uint64_t u) : count_(1)
+      {
+        digits_[0] = u;
+      }
+
+      BigInteger(const char *decimals, size_t length) : count_(1)
+      {
+        RAPIDJSON_ASSERT(length > 0);
+        digits_[0] = 0;
+        size_t i = 0;
+        const size_t kMaxDigitPerIteration = 19;  // 2^64 = 18446744073709551616 > 10^19
+        while (length >= kMaxDigitPerIteration)
+          {
+            AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration);
+            length -= kMaxDigitPerIteration;
+            i += kMaxDigitPerIteration;
+          }
+
+        if (length > 0)
+          AppendDecimal64(decimals + i, decimals + i + length);
+      }
+
+      BigInteger &operator=(const BigInteger &rhs)
+      {
+        if (this != &rhs)
+          {
+            count_ = rhs.count_;
+            std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
+          }
+        return *this;
+      }
+
+      BigInteger &operator=(uint64_t u)
+      {
+        digits_[0] = u;
+        count_ = 1;
+        return *this;
+      }
+
+      BigInteger &operator+=(uint64_t u)
+      {
+        Type backup = digits_[0];
+        digits_[0] += u;
+        for (size_t i = 0; i < count_ - 1; i++)
+          {
+            if (digits_[i] >= backup)
+              return *this; // no carry
+            backup = digits_[i + 1];
+            digits_[i + 1] += 1;
+          }
+
+        // Last carry
+        if (digits_[count_ - 1] < backup)
+          PushBack(1);
+
+        return *this;
+      }
+
+      BigInteger &operator*=(uint64_t u)
+      {
+        if (u == 0) return *this = 0;
+        if (u == 1) return *this;
+        if (*this == 1) return *this = u;
+
+        uint64_t k = 0;
+        for (size_t i = 0; i < count_; i++)
+          {
+            uint64_t hi;
+            digits_[i] = MulAdd64(digits_[i], u, k, &hi);
+            k = hi;
+          }
+
+        if (k > 0)
+          PushBack(k);
+
+        return *this;
+      }
+
+      BigInteger &operator*=(uint32_t u)
+      {
+        if (u == 0) return *this = 0;
+        if (u == 1) return *this;
+        if (*this == 1) return *this = u;
+
+        uint64_t k = 0;
+        for (size_t i = 0; i < count_; i++)
+          {
+            const uint64_t c = digits_[i] >> 32;
+            const uint64_t d = digits_[i] & 0xFFFFFFFF;
+            const uint64_t uc = u * c;
+            const uint64_t ud = u * d;
+            const uint64_t p0 = ud + k;
+            const uint64_t p1 = uc + (p0 >> 32);
+            digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32);
+            k = p1 >> 32;
+          }
+
+        if (k > 0)
+          PushBack(k);
+
+        return *this;
+      }
+
+      BigInteger &operator<<=(size_t shift)
+      {
+        if (IsZero() || shift == 0) return *this;
+
+        size_t offset = shift / kTypeBit;
+        size_t interShift = shift % kTypeBit;
+        RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
+
+        if (interShift == 0)
+          {
+            std::memmove(digits_ + offset, digits_, count_ * sizeof(Type));
+            count_ += offset;
+          }
+        else
+          {
+            digits_[count_] = 0;
+            for (size_t i = count_; i > 0; i--)
+              digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift));
+            digits_[offset] = digits_[0] << interShift;
+            count_ += offset;
+            if (digits_[count_])
+              count_++;
+          }
+
+        std::memset(digits_, 0, offset * sizeof(Type));
+
+        return *this;
+      }
+
+      bool operator==(const BigInteger &rhs) const
+      {
+        return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
+      }
+
+      bool operator==(const Type rhs) const
+      {
+        return count_ == 1 && digits_[0] == rhs;
+      }
+
+      BigInteger &MultiplyPow5(unsigned exp)
+      {
+        static const uint32_t kPow5[12] =
+        {
+          5,
+          5 * 5,
+          5 * 5 * 5,
+          5 * 5 * 5 * 5,
+          5 * 5 * 5 * 5 * 5,
+          5 * 5 * 5 * 5 * 5 * 5,
+          5 * 5 * 5 * 5 * 5 * 5 * 5,
+          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
+        };
+        if (exp == 0) return *this;
+        for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
+        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
+        if (exp > 0)                 *this *= kPow5[exp - 1];
+        return *this;
+      }
+
+      // Compute absolute difference of this and rhs.
+      // Assume this != rhs
+      bool Difference(const BigInteger &rhs, BigInteger *out) const
+      {
+        int cmp = Compare(rhs);
+        RAPIDJSON_ASSERT(cmp != 0);
+        const BigInteger *a, *b;  // Makes a > b
+        bool ret;
+        if (cmp < 0)
+          {
+            a = &rhs;
+            b = this;
+            ret = true;
+          }
+        else
+          {
+            a = this;
+            b = &rhs;
+            ret = false;
+          }
+
+        Type borrow = 0;
+        for (size_t i = 0; i < a->count_; i++)
+          {
+            Type d = a->digits_[i] - borrow;
+            if (i < b->count_)
+              d -= b->digits_[i];
+            borrow = (d > a->digits_[i]) ? 1 : 0;
+            out->digits_[i] = d;
+            if (d != 0)
+              out->count_ = i + 1;
+          }
+
+        return ret;
+      }
+
+      int Compare(const BigInteger &rhs) const
+      {
+        if (count_ != rhs.count_)
+          return count_ < rhs.count_ ? -1 : 1;
+
+        for (size_t i = count_; i-- > 0;)
+          if (digits_[i] != rhs.digits_[i])
+            return digits_[i] < rhs.digits_[i] ? -1 : 1;
+
+        return 0;
+      }
+
+      size_t GetCount() const
+      {
+        return count_;
+      }
+      Type GetDigit(size_t index) const
+      {
+        RAPIDJSON_ASSERT(index < count_);
+        return digits_[index];
+      }
+      bool IsZero() const
+      {
+        return count_ == 1 && digits_[0] == 0;
+      }
+
+    private:
+      void AppendDecimal64(const char *begin, const char *end)
+      {
+        uint64_t u = ParseUint64(begin, end);
+        if (IsZero())
+          *this = u;
+        else
+          {
+            unsigned exp = static_cast<unsigned>(end - begin);
+            (MultiplyPow5(exp) <<= exp) += u;   // *this = *this * 10^exp + u
+          }
+      }
+
+      void PushBack(Type digit)
+      {
+        RAPIDJSON_ASSERT(count_ < kCapacity);
+        digits_[count_++] = digit;
+      }
+
+      static uint64_t ParseUint64(const char *begin, const char *end)
+      {
+        uint64_t r = 0;
+        for (const char *p = begin; p != end; ++p)
+          {
+            RAPIDJSON_ASSERT(*p >= '0' && *p <= '9');
+            r = r * 10u + static_cast<unsigned>(*p - '0');
+          }
+        return r;
+      }
+
+      // Assume a * b + k < 2^128
+      static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t *outHigh)
+      {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        uint64_t low = _umul128(a, b, outHigh) + k;
+        if (low < k)
+          (*outHigh)++;
+        return low;
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
+        __extension__ typedef unsigned __int128 uint128;
+        uint128 p = static_cast<uint128>(a) * static_cast<uint128>(b);
+        p += k;
+        *outHigh = static_cast<uint64_t>(p >> 64);
+        return static_cast<uint64_t>(p);
+#else
+        const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32;
+        uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1;
+        x1 += (x0 >> 32); // can't give carry
+        x1 += x2;
+        if (x1 < x2)
+          x3 += (static_cast<uint64_t>(1) << 32);
+        uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF);
+        uint64_t hi = x3 + (x1 >> 32);
+
+        lo += k;
+        if (lo < k)
+          hi++;
+        *outHigh = hi;
+        return lo;
+#endif
+      }
+
+      static const size_t kBitCount = 3328;  // 64bit * 54 > 10^1000
+      static const size_t kCapacity = kBitCount / sizeof(Type);
+      static const size_t kTypeBit = sizeof(Type) * 8;
+
+      Type digits_[kCapacity];
+      size_t count_;
+  };
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_BIGINTEGER_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/diyfp.h.bak b/contrib/world_builder/include/rapidjson/internal/diyfp.h.bak
new file mode 100644
index 00000000000..09de0161156
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/diyfp.h.bak
@@ -0,0 +1,293 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
+// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
+// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
+
+#ifndef RAPIDJSON_DIYFP_H_
+#define RAPIDJSON_DIYFP_H_
+
+#include "../rapidjson.h"
+#include <limits>
+
+#if defined(_MSC_VER) && defined(_M_AMD64) && !defined(__INTEL_COMPILER)
+#include <intrin.h>
+#pragma intrinsic(_BitScanReverse64)
+#pragma intrinsic(_umul128)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+#ifdef __GNUC__
+  RAPIDJSON_DIAG_PUSH
+  RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+  RAPIDJSON_DIAG_PUSH
+  RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+  struct DiyFp
+  {
+    DiyFp() : f(), e() {}
+
+    DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {}
+
+    explicit DiyFp(double d)
+    {
+      union
+      {
+        double d;
+        uint64_t u64;
+      } u = { d };
+
+      int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
+      uint64_t significand = (u.u64 & kDpSignificandMask);
+      if (biased_e != 0)
+        {
+          f = significand + kDpHiddenBit;
+          e = biased_e - kDpExponentBias;
+        }
+      else
+        {
+          f = significand;
+          e = kDpMinExponent + 1;
+        }
+    }
+
+    DiyFp operator-(const DiyFp &rhs) const
+    {
+      return DiyFp(f - rhs.f, e);
+    }
+
+    DiyFp operator*(const DiyFp &rhs) const
+    {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+      uint64_t h;
+      uint64_t l = _umul128(f, rhs.f, &h);
+      if (l & (uint64_t(1) << 63)) // rounding
+        h++;
+      return DiyFp(h, e + rhs.e + 64);
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
+      __extension__ typedef unsigned __int128 uint128;
+      uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
+      uint64_t h = static_cast<uint64_t>(p >> 64);
+      uint64_t l = static_cast<uint64_t>(p);
+      if (l & (uint64_t(1) << 63)) // rounding
+        h++;
+      return DiyFp(h, e + rhs.e + 64);
+#else
+      const uint64_t M32 = 0xFFFFFFFF;
+      const uint64_t a = f >> 32;
+      const uint64_t b = f & M32;
+      const uint64_t c = rhs.f >> 32;
+      const uint64_t d = rhs.f & M32;
+      const uint64_t ac = a * c;
+      const uint64_t bc = b * c;
+      const uint64_t ad = a * d;
+      const uint64_t bd = b * d;
+      uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
+      tmp += 1U << 31;  /// mult_round
+      return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
+#endif
+    }
+
+    DiyFp Normalize() const
+    {
+      RAPIDJSON_ASSERT(f != 0); // https://stackoverflow.com/a/26809183/291737
+#if defined(_MSC_VER) && defined(_M_AMD64)
+      unsigned long index;
+      _BitScanReverse64(&index, f);
+      return DiyFp(f << (63 - index), e - (63 - index));
+#elif defined(__GNUC__) && __GNUC__ >= 4
+      int s = __builtin_clzll(f);
+      return DiyFp(f << s, e - s);
+#else
+      DiyFp res = *this;
+      while (!(res.f & (static_cast<uint64_t>(1) << 63)))
+        {
+          res.f <<= 1;
+          res.e--;
+        }
+      return res;
+#endif
+    }
+
+    DiyFp NormalizeBoundary() const
+    {
+      DiyFp res = *this;
+      while (!(res.f & (kDpHiddenBit << 1)))
+        {
+          res.f <<= 1;
+          res.e--;
+        }
+      res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
+      res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
+      return res;
+    }
+
+    void NormalizedBoundaries(DiyFp *minus, DiyFp *plus) const
+    {
+      DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
+      DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
+      mi.f <<= mi.e - pl.e;
+      mi.e = pl.e;
+      *plus = pl;
+      *minus = mi;
+    }
+
+    double ToDouble() const
+    {
+      union
+      {
+        double d;
+        uint64_t u64;
+      } u;
+      RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask);
+      if (e < kDpDenormalExponent)
+        {
+          // Underflow.
+          return 0.0;
+        }
+      if (e >= kDpMaxExponent)
+        {
+          // Overflow.
+          return std::numeric_limits<double>::infinity();
+        }
+      const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
+                          static_cast<uint64_t>(e + kDpExponentBias);
+      u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
+      return u.d;
+    }
+
+    static const int kDiySignificandSize = 64;
+    static const int kDpSignificandSize = 52;
+    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
+    static const int kDpMaxExponent = 0x7FF - kDpExponentBias;
+    static const int kDpMinExponent = -kDpExponentBias;
+    static const int kDpDenormalExponent = -kDpExponentBias + 1;
+    static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
+    static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+    static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
+
+    uint64_t f;
+    int e;
+  };
+
+  inline DiyFp GetCachedPowerByIndex(size_t index)
+  {
+    // 10^-348, 10^-340, ..., 10^340
+    static const uint64_t kCachedPowers_F[] =
+    {
+      RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
+      RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
+      RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
+      RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
+      RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
+      RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
+      RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
+      RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
+      RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
+      RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
+      RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
+      RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
+      RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
+      RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
+      RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
+      RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
+      RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
+      RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
+      RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
+      RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
+      RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
+      RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
+      RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
+      RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
+      RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
+      RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
+      RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
+      RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
+      RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
+      RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
+      RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
+      RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
+      RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
+      RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
+      RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
+      RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
+      RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
+      RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
+      RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
+      RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
+      RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
+      RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
+      RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
+      RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
+    };
+    static const int16_t kCachedPowers_E[] =
+    {
+      -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
+      -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
+      -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
+      -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
+      -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
+      109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
+      375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
+      641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
+      907,   933,   960,   986,  1013,  1039,  1066
+    };
+    RAPIDJSON_ASSERT(index < 87);
+    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
+  }
+
+  inline DiyFp GetCachedPower(int e, int *K)
+  {
+
+    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
+    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
+    int k = static_cast<int>(dk);
+    if (dk - k > 0.0)
+      k++;
+
+    unsigned index = static_cast<unsigned>((k >> 3) + 1);
+    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table
+
+    return GetCachedPowerByIndex(index);
+  }
+
+  inline DiyFp GetCachedPower10(int exp, int *outExp)
+  {
+    RAPIDJSON_ASSERT(exp >= -348);
+    unsigned index = static_cast<unsigned>(exp + 348) / 8u;
+    *outExp = -348 + static_cast<int>(index) * 8;
+    return GetCachedPowerByIndex(index);
+  }
+
+#ifdef __GNUC__
+  RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __clang__
+  RAPIDJSON_DIAG_POP
+  RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_DIYFP_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/dtoa.h.bak b/contrib/world_builder/include/rapidjson/internal/dtoa.h.bak
new file mode 100644
index 00000000000..2655748aac6
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/dtoa.h.bak
@@ -0,0 +1,301 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
+// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
+// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
+
+#ifndef RAPIDJSON_DTOA_
+#define RAPIDJSON_DTOA_
+
+#include "itoa.h" // GetDigitsLut()
+#include "diyfp.h"
+#include "ieee754.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+#ifdef __GNUC__
+  RAPIDJSON_DIAG_PUSH
+  RAPIDJSON_DIAG_OFF(effc++)
+  RAPIDJSON_DIAG_OFF(array-bounds) // some gcc versions generate wrong warnings https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124
+#endif
+
+  inline void GrisuRound(char *buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w)
+  {
+    while (rest < wp_w && delta - rest >= ten_kappa &&
+           (rest + ten_kappa < wp_w ||  /// closer
+            wp_w - rest > rest + ten_kappa - wp_w))
+      {
+        buffer[len - 1]--;
+        rest += ten_kappa;
+      }
+  }
+
+  inline int CountDecimalDigit32(uint32_t n)
+  {
+    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
+    if (n < 10) return 1;
+    if (n < 100) return 2;
+    if (n < 1000) return 3;
+    if (n < 10000) return 4;
+    if (n < 100000) return 5;
+    if (n < 1000000) return 6;
+    if (n < 10000000) return 7;
+    if (n < 100000000) return 8;
+    // Will not reach 10 digits in DigitGen()
+    //if (n < 1000000000) return 9;
+    //return 10;
+    return 9;
+  }
+
+  inline void DigitGen(const DiyFp &W, const DiyFp &Mp, uint64_t delta, char *buffer, int *len, int *K)
+  {
+    static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
+    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
+    const DiyFp wp_w = Mp - W;
+    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
+    uint64_t p2 = Mp.f & (one.f - 1);
+    int kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
+    *len = 0;
+
+    while (kappa > 0)
+      {
+        uint32_t d = 0;
+        switch (kappa)
+          {
+            case  9:
+              d = p1 /  100000000;
+              p1 %=  100000000;
+              break;
+            case  8:
+              d = p1 /   10000000;
+              p1 %=   10000000;
+              break;
+            case  7:
+              d = p1 /    1000000;
+              p1 %=    1000000;
+              break;
+            case  6:
+              d = p1 /     100000;
+              p1 %=     100000;
+              break;
+            case  5:
+              d = p1 /      10000;
+              p1 %=      10000;
+              break;
+            case  4:
+              d = p1 /       1000;
+              p1 %=       1000;
+              break;
+            case  3:
+              d = p1 /        100;
+              p1 %=        100;
+              break;
+            case  2:
+              d = p1 /         10;
+              p1 %=         10;
+              break;
+            case  1:
+              d = p1;
+              p1 =           0;
+              break;
+            default:
+              ;
+          }
+        if (d || *len)
+          buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
+        kappa--;
+        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
+        if (tmp <= delta)
+          {
+            *K += kappa;
+            GrisuRound(buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
+            return;
+          }
+      }
+
+    // kappa = 0
+    for (;;)
+      {
+        p2 *= 10;
+        delta *= 10;
+        char d = static_cast<char>(p2 >> -one.e);
+        if (d || *len)
+          buffer[(*len)++] = static_cast<char>('0' + d);
+        p2 &= one.f - 1;
+        kappa--;
+        if (p2 < delta)
+          {
+            *K += kappa;
+            int index = -kappa;
+            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[index] : 0));
+            return;
+          }
+      }
+  }
+
+  inline void Grisu2(double value, char *buffer, int *length, int *K)
+  {
+    const DiyFp v(value);
+    DiyFp w_m, w_p;
+    v.NormalizedBoundaries(&w_m, &w_p);
+
+    const DiyFp c_mk = GetCachedPower(w_p.e, K);
+    const DiyFp W = v.Normalize() * c_mk;
+    DiyFp Wp = w_p * c_mk;
+    DiyFp Wm = w_m * c_mk;
+    Wm.f++;
+    Wp.f--;
+    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
+  }
+
+  inline char *WriteExponent(int K, char *buffer)
+  {
+    if (K < 0)
+      {
+        *buffer++ = '-';
+        K = -K;
+      }
+
+    if (K >= 100)
+      {
+        *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
+        K %= 100;
+        const char *d = GetDigitsLut() + K * 2;
+        *buffer++ = d[0];
+        *buffer++ = d[1];
+      }
+    else if (K >= 10)
+      {
+        const char *d = GetDigitsLut() + K * 2;
+        *buffer++ = d[0];
+        *buffer++ = d[1];
+      }
+    else
+      *buffer++ = static_cast<char>('0' + static_cast<char>(K));
+
+    return buffer;
+  }
+
+  inline char *Prettify(char *buffer, int length, int k, int maxDecimalPlaces)
+  {
+    const int kk = length + k;  // 10^(kk-1) <= v < 10^kk
+
+    if (0 <= k && kk <= 21)
+      {
+        // 1234e7 -> 12340000000
+        for (int i = length; i < kk; i++)
+          buffer[i] = '0';
+        buffer[kk] = '.';
+        buffer[kk + 1] = '0';
+        return &buffer[kk + 2];
+      }
+    else if (0 < kk && kk <= 21)
+      {
+        // 1234e-2 -> 12.34
+        std::memmove(&buffer[kk + 1], &buffer[kk], static_cast<size_t>(length - kk));
+        buffer[kk] = '.';
+        if (0 > k + maxDecimalPlaces)
+          {
+            // When maxDecimalPlaces = 2, 1.2345 -> 1.23, 1.102 -> 1.1
+            // Remove extra trailing zeros (at least one) after truncation.
+            for (int i = kk + maxDecimalPlaces; i > kk + 1; i--)
+              if (buffer[i] != '0')
+                return &buffer[i + 1];
+            return &buffer[kk + 2]; // Reserve one zero
+          }
+        else
+          return &buffer[length + 1];
+      }
+    else if (-6 < kk && kk <= 0)
+      {
+        // 1234e-6 -> 0.001234
+        const int offset = 2 - kk;
+        std::memmove(&buffer[offset], &buffer[0], static_cast<size_t>(length));
+        buffer[0] = '0';
+        buffer[1] = '.';
+        for (int i = 2; i < offset; i++)
+          buffer[i] = '0';
+        if (length - kk > maxDecimalPlaces)
+          {
+            // When maxDecimalPlaces = 2, 0.123 -> 0.12, 0.102 -> 0.1
+            // Remove extra trailing zeros (at least one) after truncation.
+            for (int i = maxDecimalPlaces + 1; i > 2; i--)
+              if (buffer[i] != '0')
+                return &buffer[i + 1];
+            return &buffer[3]; // Reserve one zero
+          }
+        else
+          return &buffer[length + offset];
+      }
+    else if (kk < -maxDecimalPlaces)
+      {
+        // Truncate to zero
+        buffer[0] = '0';
+        buffer[1] = '.';
+        buffer[2] = '0';
+        return &buffer[3];
+      }
+    else if (length == 1)
+      {
+        // 1e30
+        buffer[1] = 'e';
+        return WriteExponent(kk - 1, &buffer[2]);
+      }
+    else
+      {
+        // 1234e30 -> 1.234e33
+        std::memmove(&buffer[2], &buffer[1], static_cast<size_t>(length - 1));
+        buffer[1] = '.';
+        buffer[length + 1] = 'e';
+        return WriteExponent(kk - 1, &buffer[0 + length + 2]);
+      }
+  }
+
+  inline char *dtoa(double value, char *buffer, int maxDecimalPlaces = 324)
+  {
+    RAPIDJSON_ASSERT(maxDecimalPlaces >= 1);
+    Double d(value);
+    if (d.IsZero())
+      {
+        if (d.Sign())
+          *buffer++ = '-';     // -0.0, Issue #289
+        buffer[0] = '0';
+        buffer[1] = '.';
+        buffer[2] = '0';
+        return &buffer[3];
+      }
+    else
+      {
+        if (value < 0)
+          {
+            *buffer++ = '-';
+            value = -value;
+          }
+        int length, K;
+        Grisu2(value, buffer, &length, &K);
+        return Prettify(buffer, length, K, maxDecimalPlaces);
+      }
+  }
+
+#ifdef __GNUC__
+  RAPIDJSON_DIAG_POP
+#endif
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_DTOA_
diff --git a/contrib/world_builder/include/rapidjson/internal/ieee754.h.bak b/contrib/world_builder/include/rapidjson/internal/ieee754.h.bak
new file mode 100644
index 00000000000..44db4b48955
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/ieee754.h.bak
@@ -0,0 +1,122 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_IEEE754_
+#define RAPIDJSON_IEEE754_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+  class Double
+  {
+    public:
+      Double() {}
+      Double(double d) : d_(d) {}
+      Double(uint64_t u) : u_(u) {}
+
+      double Value() const
+      {
+        return d_;
+      }
+      uint64_t Uint64Value() const
+      {
+        return u_;
+      }
+
+      double NextPositiveDouble() const
+      {
+        RAPIDJSON_ASSERT(!Sign());
+        return Double(u_ + 1).Value();
+      }
+
+      bool Sign() const
+      {
+        return (u_ & kSignMask) != 0;
+      }
+      uint64_t Significand() const
+      {
+        return u_ & kSignificandMask;
+      }
+      int Exponent() const
+      {
+        return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias);
+      }
+
+      bool IsNan() const
+      {
+        return (u_ & kExponentMask) == kExponentMask && Significand() != 0;
+      }
+      bool IsInf() const
+      {
+        return (u_ & kExponentMask) == kExponentMask && Significand() == 0;
+      }
+      bool IsNanOrInf() const
+      {
+        return (u_ & kExponentMask) == kExponentMask;
+      }
+      bool IsNormal() const
+      {
+        return (u_ & kExponentMask) != 0 || Significand() == 0;
+      }
+      bool IsZero() const
+      {
+        return (u_ & (kExponentMask | kSignificandMask)) == 0;
+      }
+
+      uint64_t IntegerSignificand() const
+      {
+        return IsNormal() ? Significand() | kHiddenBit : Significand();
+      }
+      int IntegerExponent() const
+      {
+        return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize;
+      }
+      uint64_t ToBias() const
+      {
+        return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask;
+      }
+
+      static int EffectiveSignificandSize(int order)
+      {
+        if (order >= -1021)
+          return 53;
+        else if (order <= -1074)
+          return 0;
+        else
+          return order + 1074;
+      }
+
+    private:
+      static const int kSignificandSize = 52;
+      static const int kExponentBias = 0x3FF;
+      static const int kDenormalExponent = 1 - kExponentBias;
+      static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
+      static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
+      static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+      static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
+
+      union
+      {
+        double d_;
+        uint64_t u_;
+      };
+  };
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_IEEE754_
diff --git a/contrib/world_builder/include/rapidjson/internal/itoa.h.bak b/contrib/world_builder/include/rapidjson/internal/itoa.h.bak
new file mode 100644
index 00000000000..23016b08a4d
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/itoa.h.bak
@@ -0,0 +1,329 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ITOA_
+#define RAPIDJSON_ITOA_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+  inline const char *GetDigitsLut()
+  {
+    static const char cDigitsLut[200] =
+    {
+      '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
+      '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
+      '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
+      '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
+      '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
+      '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
+      '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
+      '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
+      '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
+      '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
+    };
+    return cDigitsLut;
+  }
+
+  inline char *u32toa(uint32_t value, char *buffer)
+  {
+    RAPIDJSON_ASSERT(buffer != 0);
+
+    const char *cDigitsLut = GetDigitsLut();
+
+    if (value < 10000)
+      {
+        const uint32_t d1 = (value / 100) << 1;
+        const uint32_t d2 = (value % 100) << 1;
+
+        if (value >= 1000)
+          *buffer++ = cDigitsLut[d1];
+        if (value >= 100)
+          *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= 10)
+          *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+      }
+    else if (value < 100000000)
+      {
+        // value = bbbbcccc
+        const uint32_t b = value / 10000;
+        const uint32_t c = value % 10000;
+
+        const uint32_t d1 = (b / 100) << 1;
+        const uint32_t d2 = (b % 100) << 1;
+
+        const uint32_t d3 = (c / 100) << 1;
+        const uint32_t d4 = (c % 100) << 1;
+
+        if (value >= 10000000)
+          *buffer++ = cDigitsLut[d1];
+        if (value >= 1000000)
+          *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= 100000)
+          *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+      }
+    else
+      {
+        // value = aabbbbcccc in decimal
+
+        const uint32_t a = value / 100000000; // 1 to 42
+        value %= 100000000;
+
+        if (a >= 10)
+          {
+            const unsigned i = a << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+          }
+        else
+          *buffer++ = static_cast<char>('0' + static_cast<char>(a));
+
+        const uint32_t b = value / 10000; // 0 to 9999
+        const uint32_t c = value % 10000; // 0 to 9999
+
+        const uint32_t d1 = (b / 100) << 1;
+        const uint32_t d2 = (b % 100) << 1;
+
+        const uint32_t d3 = (c / 100) << 1;
+        const uint32_t d4 = (c % 100) << 1;
+
+        *buffer++ = cDigitsLut[d1];
+        *buffer++ = cDigitsLut[d1 + 1];
+        *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+      }
+    return buffer;
+  }
+
+  inline char *i32toa(int32_t value, char *buffer)
+  {
+    RAPIDJSON_ASSERT(buffer != 0);
+    uint32_t u = static_cast<uint32_t>(value);
+    if (value < 0)
+      {
+        *buffer++ = '-';
+        u = ~u + 1;
+      }
+
+    return u32toa(u, buffer);
+  }
+
+  inline char *u64toa(uint64_t value, char *buffer)
+  {
+    RAPIDJSON_ASSERT(buffer != 0);
+    const char *cDigitsLut = GetDigitsLut();
+    const uint64_t  kTen8 = 100000000;
+    const uint64_t  kTen9 = kTen8 * 10;
+    const uint64_t kTen10 = kTen8 * 100;
+    const uint64_t kTen11 = kTen8 * 1000;
+    const uint64_t kTen12 = kTen8 * 10000;
+    const uint64_t kTen13 = kTen8 * 100000;
+    const uint64_t kTen14 = kTen8 * 1000000;
+    const uint64_t kTen15 = kTen8 * 10000000;
+    const uint64_t kTen16 = kTen8 * kTen8;
+
+    if (value < kTen8)
+      {
+        uint32_t v = static_cast<uint32_t>(value);
+        if (v < 10000)
+          {
+            const uint32_t d1 = (v / 100) << 1;
+            const uint32_t d2 = (v % 100) << 1;
+
+            if (v >= 1000)
+              *buffer++ = cDigitsLut[d1];
+            if (v >= 100)
+              *buffer++ = cDigitsLut[d1 + 1];
+            if (v >= 10)
+              *buffer++ = cDigitsLut[d2];
+            *buffer++ = cDigitsLut[d2 + 1];
+          }
+        else
+          {
+            // value = bbbbcccc
+            const uint32_t b = v / 10000;
+            const uint32_t c = v % 10000;
+
+            const uint32_t d1 = (b / 100) << 1;
+            const uint32_t d2 = (b % 100) << 1;
+
+            const uint32_t d3 = (c / 100) << 1;
+            const uint32_t d4 = (c % 100) << 1;
+
+            if (value >= 10000000)
+              *buffer++ = cDigitsLut[d1];
+            if (value >= 1000000)
+              *buffer++ = cDigitsLut[d1 + 1];
+            if (value >= 100000)
+              *buffer++ = cDigitsLut[d2];
+            *buffer++ = cDigitsLut[d2 + 1];
+
+            *buffer++ = cDigitsLut[d3];
+            *buffer++ = cDigitsLut[d3 + 1];
+            *buffer++ = cDigitsLut[d4];
+            *buffer++ = cDigitsLut[d4 + 1];
+          }
+      }
+    else if (value < kTen16)
+      {
+        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
+        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
+
+        const uint32_t b0 = v0 / 10000;
+        const uint32_t c0 = v0 % 10000;
+
+        const uint32_t d1 = (b0 / 100) << 1;
+        const uint32_t d2 = (b0 % 100) << 1;
+
+        const uint32_t d3 = (c0 / 100) << 1;
+        const uint32_t d4 = (c0 % 100) << 1;
+
+        const uint32_t b1 = v1 / 10000;
+        const uint32_t c1 = v1 % 10000;
+
+        const uint32_t d5 = (b1 / 100) << 1;
+        const uint32_t d6 = (b1 % 100) << 1;
+
+        const uint32_t d7 = (c1 / 100) << 1;
+        const uint32_t d8 = (c1 % 100) << 1;
+
+        if (value >= kTen15)
+          *buffer++ = cDigitsLut[d1];
+        if (value >= kTen14)
+          *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= kTen13)
+          *buffer++ = cDigitsLut[d2];
+        if (value >= kTen12)
+          *buffer++ = cDigitsLut[d2 + 1];
+        if (value >= kTen11)
+          *buffer++ = cDigitsLut[d3];
+        if (value >= kTen10)
+          *buffer++ = cDigitsLut[d3 + 1];
+        if (value >= kTen9)
+          *buffer++ = cDigitsLut[d4];
+
+        *buffer++ = cDigitsLut[d4 + 1];
+        *buffer++ = cDigitsLut[d5];
+        *buffer++ = cDigitsLut[d5 + 1];
+        *buffer++ = cDigitsLut[d6];
+        *buffer++ = cDigitsLut[d6 + 1];
+        *buffer++ = cDigitsLut[d7];
+        *buffer++ = cDigitsLut[d7 + 1];
+        *buffer++ = cDigitsLut[d8];
+        *buffer++ = cDigitsLut[d8 + 1];
+      }
+    else
+      {
+        const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
+        value %= kTen16;
+
+        if (a < 10)
+          *buffer++ = static_cast<char>('0' + static_cast<char>(a));
+        else if (a < 100)
+          {
+            const uint32_t i = a << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+          }
+        else if (a < 1000)
+          {
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
+
+            const uint32_t i = (a % 100) << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+          }
+        else
+          {
+            const uint32_t i = (a / 100) << 1;
+            const uint32_t j = (a % 100) << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+            *buffer++ = cDigitsLut[j];
+            *buffer++ = cDigitsLut[j + 1];
+          }
+
+        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
+        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
+
+        const uint32_t b0 = v0 / 10000;
+        const uint32_t c0 = v0 % 10000;
+
+        const uint32_t d1 = (b0 / 100) << 1;
+        const uint32_t d2 = (b0 % 100) << 1;
+
+        const uint32_t d3 = (c0 / 100) << 1;
+        const uint32_t d4 = (c0 % 100) << 1;
+
+        const uint32_t b1 = v1 / 10000;
+        const uint32_t c1 = v1 % 10000;
+
+        const uint32_t d5 = (b1 / 100) << 1;
+        const uint32_t d6 = (b1 % 100) << 1;
+
+        const uint32_t d7 = (c1 / 100) << 1;
+        const uint32_t d8 = (c1 % 100) << 1;
+
+        *buffer++ = cDigitsLut[d1];
+        *buffer++ = cDigitsLut[d1 + 1];
+        *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+        *buffer++ = cDigitsLut[d5];
+        *buffer++ = cDigitsLut[d5 + 1];
+        *buffer++ = cDigitsLut[d6];
+        *buffer++ = cDigitsLut[d6 + 1];
+        *buffer++ = cDigitsLut[d7];
+        *buffer++ = cDigitsLut[d7 + 1];
+        *buffer++ = cDigitsLut[d8];
+        *buffer++ = cDigitsLut[d8 + 1];
+      }
+
+    return buffer;
+  }
+
+  inline char *i64toa(int64_t value, char *buffer)
+  {
+    RAPIDJSON_ASSERT(buffer != 0);
+    uint64_t u = static_cast<uint64_t>(value);
+    if (value < 0)
+      {
+        *buffer++ = '-';
+        u = ~u + 1;
+      }
+
+    return u64toa(u, buffer);
+  }
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ITOA_
diff --git a/contrib/world_builder/include/rapidjson/internal/meta.h.bak b/contrib/world_builder/include/rapidjson/internal/meta.h.bak
new file mode 100644
index 00000000000..3b61258b9a0
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/meta.h.bak
@@ -0,0 +1,229 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_META_H_
+#define RAPIDJSON_INTERNAL_META_H_
+
+#include "../rapidjson.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(6334)
+#endif
+
+#if RAPIDJSON_HAS_CXX11_TYPETRAITS
+#include <type_traits>
+#endif
+
+//@cond RAPIDJSON_INTERNAL
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
+  template <typename T> struct Void
+  {
+    typedef void Type;
+  };
+
+///////////////////////////////////////////////////////////////////////////////
+// BoolType, TrueType, FalseType
+//
+  template <bool Cond> struct BoolType
+  {
+    static const bool Value = Cond;
+    typedef BoolType Type;
+  };
+  typedef BoolType<true> TrueType;
+  typedef BoolType<false> FalseType;
+
+
+///////////////////////////////////////////////////////////////////////////////
+// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
+//
+
+  template <bool C> struct SelectIfImpl
+  {
+    template <typename T1, typename T2> struct Apply
+    {
+      typedef T1 Type;
+    };
+  };
+  template <> struct SelectIfImpl<false>
+  {
+    template <typename T1, typename T2> struct Apply
+    {
+      typedef T2 Type;
+    };
+  };
+  template <bool C, typename T1, typename T2> struct SelectIfCond : SelectIfImpl<C>::template Apply<T1,T2> {};
+  template <typename C, typename T1, typename T2> struct SelectIf : SelectIfCond<C::Value, T1, T2> {};
+
+  template <bool Cond1, bool Cond2> struct AndExprCond : FalseType {};
+  template <> struct AndExprCond<true, true> : TrueType {};
+  template <bool Cond1, bool Cond2> struct OrExprCond : TrueType {};
+  template <> struct OrExprCond<false, false> : FalseType {};
+
+  template <typename C> struct BoolExpr : SelectIf<C,TrueType,FalseType>::Type {};
+  template <typename C> struct NotExpr  : SelectIf<C,FalseType,TrueType>::Type {};
+  template <typename C1, typename C2> struct AndExpr : AndExprCond<C1::Value, C2::Value>::Type {};
+  template <typename C1, typename C2> struct OrExpr  : OrExprCond<C1::Value, C2::Value>::Type {};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// AddConst, MaybeAddConst, RemoveConst
+  template <typename T> struct AddConst
+  {
+    typedef const T Type;
+  };
+  template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
+  template <typename T> struct RemoveConst
+  {
+    typedef T Type;
+  };
+  template <typename T> struct RemoveConst<const T>
+  {
+    typedef T Type;
+  };
+
+
+///////////////////////////////////////////////////////////////////////////////
+// IsSame, IsConst, IsMoreConst, IsPointer
+//
+  template <typename T, typename U> struct IsSame : FalseType {};
+  template <typename T> struct IsSame<T, T> : TrueType {};
+
+  template <typename T> struct IsConst : FalseType {};
+  template <typename T> struct IsConst<const T> : TrueType {};
+
+  template <typename CT, typename T>
+  struct IsMoreConst
+    : AndExpr<IsSame<typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>,
+      BoolType<IsConst<CT>::Value >= IsConst<T>::Value> >::Type {};
+
+  template <typename T> struct IsPointer : FalseType {};
+  template <typename T> struct IsPointer<T *> : TrueType {};
+
+///////////////////////////////////////////////////////////////////////////////
+// IsBaseOf
+//
+#if RAPIDJSON_HAS_CXX11_TYPETRAITS
+
+  template <typename B, typename D> struct IsBaseOf
+    : BoolType< ::std::is_base_of<B,D>::value> {};
+
+#else // simplified version adopted from Boost
+
+  template<typename B, typename D> struct IsBaseOfImpl
+  {
+    RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0);
+    RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0);
+
+    typedef char (&Yes)[1];
+    typedef char (&No) [2];
+
+    template <typename T>
+    static Yes Check(const D *, T);
+    static No  Check(const B *, int);
+
+    struct Host
+    {
+      operator const B *() const;
+      operator const D *();
+    };
+
+    enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) };
+  };
+
+  template <typename B, typename D> struct IsBaseOf
+    : OrExpr<IsSame<B, D>, BoolExpr<IsBaseOfImpl<B, D> > >::Type {};
+
+#endif // RAPIDJSON_HAS_CXX11_TYPETRAITS
+
+
+//////////////////////////////////////////////////////////////////////////
+// EnableIf / DisableIf
+//
+  template <bool Condition, typename T = void> struct EnableIfCond
+  {
+    typedef T Type;
+  };
+  template <typename T> struct EnableIfCond<false, T>
+  {
+    /* empty */
+  };
+
+  template <bool Condition, typename T = void> struct DisableIfCond
+  {
+    typedef T Type;
+  };
+  template <typename T> struct DisableIfCond<true, T>
+  {
+    /* empty */
+  };
+
+  template <typename Condition, typename T = void>
+  struct EnableIf : EnableIfCond<Condition::Value, T> {};
+
+  template <typename Condition, typename T = void>
+  struct DisableIf : DisableIfCond<Condition::Value, T> {};
+
+// SFINAE helpers
+  struct SfinaeTag {};
+  template <typename T> struct RemoveSfinaeTag;
+  template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)>
+  {
+    typedef T Type;
+  };
+
+#define RAPIDJSON_REMOVEFPTR_(type) \
+  typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \
+  < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type
+
+#define RAPIDJSON_ENABLEIF(cond) \
+  typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
+  <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
+
+#define RAPIDJSON_DISABLEIF(cond) \
+  typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
+  <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
+
+#define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \
+  typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
+  <RAPIDJSON_REMOVEFPTR_(cond), \
+  RAPIDJSON_REMOVEFPTR_(returntype)>::Type
+
+#define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \
+  typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
+  <RAPIDJSON_REMOVEFPTR_(cond), \
+  RAPIDJSON_REMOVEFPTR_(returntype)>::Type
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+//@endcond
+
+#if defined(_MSC_VER) && !defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_INTERNAL_META_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/pow10.h.bak b/contrib/world_builder/include/rapidjson/internal/pow10.h.bak
new file mode 100644
index 00000000000..579502aa633
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/pow10.h.bak
@@ -0,0 +1,58 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_POW10_
+#define RAPIDJSON_POW10_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+//! Computes integer powers of 10 in double (10.0^n).
+  /*! This function uses lookup table for fast and accurate results.
+      \param n non-negative exponent. Must <= 308.
+      \return 10.0^n
+  */
+  inline double Pow10(int n)
+  {
+    static const double e[] =   // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
+    {
+      1e+0,
+      1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20,
+      1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
+      1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
+      1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
+      1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
+      1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
+      1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
+      1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
+      1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
+      1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
+      1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
+      1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
+      1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
+      1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
+      1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
+      1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
+    };
+    RAPIDJSON_ASSERT(n >= 0 && n <= 308);
+    return e[n];
+  }
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_POW10_
diff --git a/contrib/world_builder/include/rapidjson/internal/regex.h.bak b/contrib/world_builder/include/rapidjson/internal/regex.h.bak
new file mode 100644
index 00000000000..88274ba2a59
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/regex.h.bak
@@ -0,0 +1,820 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_REGEX_H_
+#define RAPIDJSON_INTERNAL_REGEX_H_
+
+#include "../allocators.h"
+#include "../stream.h"
+#include "stack.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+//RAPIDJSON_DIAG_OFF(switch -enum)
+RAPIDJSON_DIAG_OFF(implicit-fallthrough)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#if __GNUC__ >= 7
+RAPIDJSON_DIAG_OFF(implicit-fallthrough)
+#endif
+#endif
+
+#ifndef RAPIDJSON_REGEX_VERBOSE
+#define RAPIDJSON_REGEX_VERBOSE 0
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// DecodedStream
+
+  template <typename SourceStream, typename Encoding>
+  class DecodedStream
+  {
+    public:
+      DecodedStream(SourceStream &ss) : ss_(ss), codepoint_()
+      {
+        Decode();
+      }
+      unsigned Peek()
+      {
+        return codepoint_;
+      }
+      unsigned Take()
+      {
+        unsigned c = codepoint_;
+        if (c) // No further decoding when '\0'
+          Decode();
+        return c;
+      }
+
+    private:
+      void Decode()
+      {
+        if (!Encoding::Decode(ss_, &codepoint_))
+          codepoint_ = 0;
+      }
+
+      SourceStream &ss_;
+      unsigned codepoint_;
+  };
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericRegex
+
+  static const SizeType kRegexInvalidState = ~SizeType(0);  //!< Represents an invalid index in GenericRegex::State::out, out1
+  static const SizeType kRegexInvalidRange = ~SizeType(0);
+
+  template <typename Encoding, typename Allocator>
+  class GenericRegexSearch;
+
+//! Regular expression engine with subset of ECMAscript grammar.
+  /*!
+      Supported regular expression syntax:
+      - \c ab     Concatenation
+      - \c a|b    Alternation
+      - \c a?     Zero or one
+      - \c a*     Zero or more
+      - \c a+     One or more
+      - \c a{3}   Exactly 3 times
+      - \c a{3,}  At least 3 times
+      - \c a{3,5} 3 to 5 times
+      - \c (ab)   Grouping
+      - \c ^a     At the beginning
+      - \c a$     At the end
+      - \c .      Any character
+      - \c [abc]  Character classes
+      - \c [a-c]  Character class range
+      - \c [a-z0-9_] Character class combination
+      - \c [^abc] Negated character classes
+      - \c [^a-c] Negated character class range
+      - \c [\b]   Backspace (U+0008)
+      - \c \\| \\\\ ...  Escape characters
+      - \c \\f Form feed (U+000C)
+      - \c \\n Line feed (U+000A)
+      - \c \\r Carriage return (U+000D)
+      - \c \\t Tab (U+0009)
+      - \c \\v Vertical tab (U+000B)
+
+      \note This is a Thompson NFA engine, implemented with reference to
+          Cox, Russ. "Regular Expression Matching Can Be Simple And Fast (but is slow in Java, Perl, PHP, Python, Ruby,...).",
+          https://swtch.com/~rsc/regexp/regexp1.html
+  */
+  template <typename Encoding, typename Allocator = CrtAllocator>
+  class GenericRegex
+  {
+    public:
+      typedef Encoding EncodingType;
+      typedef typename Encoding::Ch Ch;
+      template <typename, typename> friend class GenericRegexSearch;
+
+      GenericRegex(const Ch *source, Allocator *allocator = 0) :
+        states_(allocator, 256), ranges_(allocator, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(),
+        anchorBegin_(), anchorEnd_()
+      {
+        GenericStringStream<Encoding> ss(source);
+        DecodedStream<GenericStringStream<Encoding>, Encoding> ds(ss);
+        Parse(ds);
+      }
+
+      ~GenericRegex() {}
+
+      bool IsValid() const
+      {
+        return root_ != kRegexInvalidState;
+      }
+
+    private:
+      enum Operator
+      {
+        kZeroOrOne,
+        kZeroOrMore,
+        kOneOrMore,
+        kConcatenation,
+        kAlternation,
+        kLeftParenthesis
+      };
+
+      static const unsigned kAnyCharacterClass = 0xFFFFFFFF;   //!< For '.'
+      static const unsigned kRangeCharacterClass = 0xFFFFFFFE;
+      static const unsigned kRangeNegationFlag = 0x80000000;
+
+      struct Range
+      {
+        unsigned start; //
+        unsigned end;
+        SizeType next;
+      };
+
+      struct State
+      {
+        SizeType out;     //!< Equals to kInvalid for matching state
+        SizeType out1;    //!< Equals to non-kInvalid for split
+        SizeType rangeStart;
+        unsigned codepoint;
+      };
+
+      struct Frag
+      {
+        Frag(SizeType s, SizeType o, SizeType m) : start(s), out(o), minIndex(m) {}
+        SizeType start;
+        SizeType out; //!< link-list of all output states
+        SizeType minIndex;
+      };
+
+      State &GetState(SizeType index)
+      {
+        RAPIDJSON_ASSERT(index < stateCount_);
+        return states_.template Bottom<State>()[index];
+      }
+
+      const State &GetState(SizeType index) const
+      {
+        RAPIDJSON_ASSERT(index < stateCount_);
+        return states_.template Bottom<State>()[index];
+      }
+
+      Range &GetRange(SizeType index)
+      {
+        RAPIDJSON_ASSERT(index < rangeCount_);
+        return ranges_.template Bottom<Range>()[index];
+      }
+
+      const Range &GetRange(SizeType index) const
+      {
+        RAPIDJSON_ASSERT(index < rangeCount_);
+        return ranges_.template Bottom<Range>()[index];
+      }
+
+      template <typename InputStream>
+      void Parse(DecodedStream<InputStream, Encoding> &ds)
+      {
+        Allocator allocator;
+        Stack<Allocator> operandStack(&allocator, 256);     // Frag
+        Stack<Allocator> operatorStack(&allocator, 256);    // Operator
+        Stack<Allocator> atomCountStack(&allocator, 256);   // unsigned (Atom per parenthesis)
+
+        *atomCountStack.template Push<unsigned>() = 0;
+
+        unsigned codepoint;
+        while (ds.Peek() != 0)
+          {
+            switch (codepoint = ds.Take())
+              {
+                case '^':
+                  anchorBegin_ = true;
+                  break;
+
+                case '$':
+                  anchorEnd_ = true;
+                  break;
+
+                case '|':
+                  while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() < kAlternation)
+                    if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
+                      return;
+                  *operatorStack.template Push<Operator>() = kAlternation;
+                  *atomCountStack.template Top<unsigned>() = 0;
+                  break;
+
+                case '(':
+                  *operatorStack.template Push<Operator>() = kLeftParenthesis;
+                  *atomCountStack.template Push<unsigned>() = 0;
+                  break;
+
+                case ')':
+                  while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() != kLeftParenthesis)
+                    if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
+                      return;
+                  if (operatorStack.Empty())
+                    return;
+                  operatorStack.template Pop<Operator>(1);
+                  atomCountStack.template Pop<unsigned>(1);
+                  ImplicitConcatenation(atomCountStack, operatorStack);
+                  break;
+
+                case '?':
+                  if (!Eval(operandStack, kZeroOrOne))
+                    return;
+                  break;
+
+                case '*':
+                  if (!Eval(operandStack, kZeroOrMore))
+                    return;
+                  break;
+
+                case '+':
+                  if (!Eval(operandStack, kOneOrMore))
+                    return;
+                  break;
+
+                case '{':
+                {
+                  unsigned n = 0;
+                  unsigned m = 0;
+                  if (!ParseUnsigned(ds, &n))
+                    return;
+
+                  if (ds.Peek() == ',')
+                    {
+                      ds.Take();
+                      if (ds.Peek() == '}')
+                        m = kInfinityQuantifier;
+                      else if (!ParseUnsigned(ds, &m) || m < n)
+                        return;
+                    }
+                  else
+                    m = n;
+
+                  if (!EvalQuantifier(operandStack, n, m) || ds.Peek() != '}')
+                    return;
+                  ds.Take();
+                }
+                break;
+
+                case '.':
+                  PushOperand(operandStack, kAnyCharacterClass);
+                  ImplicitConcatenation(atomCountStack, operatorStack);
+                  break;
+
+                case '[':
+                {
+                  SizeType range;
+                  if (!ParseRange(ds, &range))
+                    return;
+                  SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, kRangeCharacterClass);
+                  GetState(s).rangeStart = range;
+                  *operandStack.template Push<Frag>() = Frag(s, s, s);
+                }
+                ImplicitConcatenation(atomCountStack, operatorStack);
+                break;
+
+                case '\\': // Escape character
+                  if (!CharacterEscape(ds, &codepoint))
+                    return; // Unsupported escape character
+                // fall through to default
+
+                default: // Pattern character
+                  PushOperand(operandStack, codepoint);
+                  ImplicitConcatenation(atomCountStack, operatorStack);
+              }
+          }
+
+        while (!operatorStack.Empty())
+          if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
+            return;
+
+        // Link the operand to matching state.
+        if (operandStack.GetSize() == sizeof(Frag))
+          {
+            Frag *e = operandStack.template Pop<Frag>(1);
+            Patch(e->out, NewState(kRegexInvalidState, kRegexInvalidState, 0));
+            root_ = e->start;
+
+#if RAPIDJSON_REGEX_VERBOSE
+            printf("root: %d\n", root_);
+            for (SizeType i = 0; i < stateCount_ ; i++)
+              {
+                State &s = GetState(i);
+                printf("[%2d] out: %2d out1: %2d c: '%c'\n", i, s.out, s.out1, (char)s.codepoint);
+              }
+            printf("\n");
+#endif
+          }
+      }
+
+      SizeType NewState(SizeType out, SizeType out1, unsigned codepoint)
+      {
+        State *s = states_.template Push<State>();
+        s->out = out;
+        s->out1 = out1;
+        s->codepoint = codepoint;
+        s->rangeStart = kRegexInvalidRange;
+        return stateCount_++;
+      }
+
+      void PushOperand(Stack<Allocator> &operandStack, unsigned codepoint)
+      {
+        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, codepoint);
+        *operandStack.template Push<Frag>() = Frag(s, s, s);
+      }
+
+      void ImplicitConcatenation(Stack<Allocator> &atomCountStack, Stack<Allocator> &operatorStack)
+      {
+        if (*atomCountStack.template Top<unsigned>())
+          *operatorStack.template Push<Operator>() = kConcatenation;
+        (*atomCountStack.template Top<unsigned>())++;
+      }
+
+      SizeType Append(SizeType l1, SizeType l2)
+      {
+        SizeType old = l1;
+        while (GetState(l1).out != kRegexInvalidState)
+          l1 = GetState(l1).out;
+        GetState(l1).out = l2;
+        return old;
+      }
+
+      void Patch(SizeType l, SizeType s)
+      {
+        for (SizeType next; l != kRegexInvalidState; l = next)
+          {
+            next = GetState(l).out;
+            GetState(l).out = s;
+          }
+      }
+
+      bool Eval(Stack<Allocator> &operandStack, Operator op)
+      {
+        switch (op)
+          {
+            case kConcatenation:
+              RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag) * 2);
+              {
+                Frag e2 = *operandStack.template Pop<Frag>(1);
+                Frag e1 = *operandStack.template Pop<Frag>(1);
+                Patch(e1.out, e2.start);
+                *operandStack.template Push<Frag>() = Frag(e1.start, e2.out, Min(e1.minIndex, e2.minIndex));
+              }
+              return true;
+
+            case kAlternation:
+              if (operandStack.GetSize() >= sizeof(Frag) * 2)
+                {
+                  Frag e2 = *operandStack.template Pop<Frag>(1);
+                  Frag e1 = *operandStack.template Pop<Frag>(1);
+                  SizeType s = NewState(e1.start, e2.start, 0);
+                  *operandStack.template Push<Frag>() = Frag(s, Append(e1.out, e2.out), Min(e1.minIndex, e2.minIndex));
+                  return true;
+                }
+              return false;
+
+            case kZeroOrOne:
+              if (operandStack.GetSize() >= sizeof(Frag))
+                {
+                  Frag e = *operandStack.template Pop<Frag>(1);
+                  SizeType s = NewState(kRegexInvalidState, e.start, 0);
+                  *operandStack.template Push<Frag>() = Frag(s, Append(e.out, s), e.minIndex);
+                  return true;
+                }
+              return false;
+
+            case kZeroOrMore:
+              if (operandStack.GetSize() >= sizeof(Frag))
+                {
+                  Frag e = *operandStack.template Pop<Frag>(1);
+                  SizeType s = NewState(kRegexInvalidState, e.start, 0);
+                  Patch(e.out, s);
+                  *operandStack.template Push<Frag>() = Frag(s, s, e.minIndex);
+                  return true;
+                }
+              return false;
+
+            default:
+              RAPIDJSON_ASSERT(op == kOneOrMore);
+              if (operandStack.GetSize() >= sizeof(Frag))
+                {
+                  Frag e = *operandStack.template Pop<Frag>(1);
+                  SizeType s = NewState(kRegexInvalidState, e.start, 0);
+                  Patch(e.out, s);
+                  *operandStack.template Push<Frag>() = Frag(e.start, s, e.minIndex);
+                  return true;
+                }
+              return false;
+          }
+      }
+
+      bool EvalQuantifier(Stack<Allocator> &operandStack, unsigned n, unsigned m)
+      {
+        RAPIDJSON_ASSERT(n <= m);
+        RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag));
+
+        if (n == 0)
+          {
+            if (m == 0)                             // a{0} not support
+              return false;
+            else if (m == kInfinityQuantifier)
+              Eval(operandStack, kZeroOrMore);    // a{0,} -> a*
+            else
+              {
+                Eval(operandStack, kZeroOrOne);         // a{0,5} -> a?
+                for (unsigned i = 0; i < m - 1; i++)
+                  CloneTopOperand(operandStack);      // a{0,5} -> a? a? a? a? a?
+                for (unsigned i = 0; i < m - 1; i++)
+                  Eval(operandStack, kConcatenation); // a{0,5} -> a?a?a?a?a?
+              }
+            return true;
+          }
+
+        for (unsigned i = 0; i < n - 1; i++)        // a{3} -> a a a
+          CloneTopOperand(operandStack);
+
+        if (m == kInfinityQuantifier)
+          Eval(operandStack, kOneOrMore);         // a{3,} -> a a a+
+        else if (m > n)
+          {
+            CloneTopOperand(operandStack);          // a{3,5} -> a a a a
+            Eval(operandStack, kZeroOrOne);         // a{3,5} -> a a a a?
+            for (unsigned i = n; i < m - 1; i++)
+              CloneTopOperand(operandStack);      // a{3,5} -> a a a a? a?
+            for (unsigned i = n; i < m; i++)
+              Eval(operandStack, kConcatenation); // a{3,5} -> a a aa?a?
+          }
+
+        for (unsigned i = 0; i < n - 1; i++)
+          Eval(operandStack, kConcatenation);     // a{3} -> aaa, a{3,} -> aaa+, a{3.5} -> aaaa?a?
+
+        return true;
+      }
+
+      static SizeType Min(SizeType a, SizeType b)
+      {
+        return a < b ? a : b;
+      }
+
+      void CloneTopOperand(Stack<Allocator> &operandStack)
+      {
+        const Frag src = *operandStack.template Top<Frag>(); // Copy constructor to prevent invalidation
+        SizeType count = stateCount_ - src.minIndex; // Assumes top operand contains states in [src->minIndex, stateCount_)
+        State *s = states_.template Push<State>(count);
+        memcpy(s, &GetState(src.minIndex), count * sizeof(State));
+        for (SizeType j = 0; j < count; j++)
+          {
+            if (s[j].out != kRegexInvalidState)
+              s[j].out += count;
+            if (s[j].out1 != kRegexInvalidState)
+              s[j].out1 += count;
+          }
+        *operandStack.template Push<Frag>() = Frag(src.start + count, src.out + count, src.minIndex + count);
+        stateCount_ += count;
+      }
+
+      template <typename InputStream>
+      bool ParseUnsigned(DecodedStream<InputStream, Encoding> &ds, unsigned *u)
+      {
+        unsigned r = 0;
+        if (ds.Peek() < '0' || ds.Peek() > '9')
+          return false;
+        while (ds.Peek() >= '0' && ds.Peek() <= '9')
+          {
+            if (r >= 429496729 && ds.Peek() > '5') // 2^32 - 1 = 4294967295
+              return false; // overflow
+            r = r * 10 + (ds.Take() - '0');
+          }
+        *u = r;
+        return true;
+      }
+
+      template <typename InputStream>
+      bool ParseRange(DecodedStream<InputStream, Encoding> &ds, SizeType *range)
+      {
+        bool isBegin = true;
+        bool negate = false;
+        int step = 0;
+        SizeType start = kRegexInvalidRange;
+        SizeType current = kRegexInvalidRange;
+        unsigned codepoint;
+        while ((codepoint = ds.Take()) != 0)
+          {
+            if (isBegin)
+              {
+                isBegin = false;
+                if (codepoint == '^')
+                  {
+                    negate = true;
+                    continue;
+                  }
+              }
+
+            switch (codepoint)
+              {
+                case ']':
+                  if (start == kRegexInvalidRange)
+                    return false;   // Error: nothing inside []
+                  if (step == 2)   // Add trailing '-'
+                    {
+                      SizeType r = NewRange('-');
+                      RAPIDJSON_ASSERT(current != kRegexInvalidRange);
+                      GetRange(current).next = r;
+                    }
+                  if (negate)
+                    GetRange(start).start |= kRangeNegationFlag;
+                  *range = start;
+                  return true;
+
+                case '\\':
+                  if (ds.Peek() == 'b')
+                    {
+                      ds.Take();
+                      codepoint = 0x0008; // Escape backspace character
+                    }
+                  else if (!CharacterEscape(ds, &codepoint))
+                    return false;
+                // fall through to default
+
+                default:
+                  switch (step)
+                    {
+                      case 1:
+                        if (codepoint == '-')
+                          {
+                            step++;
+                            break;
+                          }
+                      // fall through to step 0 for other characters
+
+                      case 0:
+                      {
+                        SizeType r = NewRange(codepoint);
+                        if (current != kRegexInvalidRange)
+                          GetRange(current).next = r;
+                        if (start == kRegexInvalidRange)
+                          start = r;
+                        current = r;
+                      }
+                      step = 1;
+                      break;
+
+                      default:
+                        RAPIDJSON_ASSERT(step == 2);
+                        GetRange(current).end = codepoint;
+                        step = 0;
+                    }
+              }
+          }
+        return false;
+      }
+
+      SizeType NewRange(unsigned codepoint)
+      {
+        Range *r = ranges_.template Push<Range>();
+        r->start = r->end = codepoint;
+        r->next = kRegexInvalidRange;
+        return rangeCount_++;
+      }
+
+      template <typename InputStream>
+      bool CharacterEscape(DecodedStream<InputStream, Encoding> &ds, unsigned *escapedCodepoint)
+      {
+        unsigned codepoint;
+        switch (codepoint = ds.Take())
+          {
+            case '^':
+            case '$':
+            case '|':
+            case '(':
+            case ')':
+            case '?':
+            case '*':
+            case '+':
+            case '.':
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case '\\':
+              *escapedCodepoint = codepoint;
+              return true;
+            case 'f':
+              *escapedCodepoint = 0x000C;
+              return true;
+            case 'n':
+              *escapedCodepoint = 0x000A;
+              return true;
+            case 'r':
+              *escapedCodepoint = 0x000D;
+              return true;
+            case 't':
+              *escapedCodepoint = 0x0009;
+              return true;
+            case 'v':
+              *escapedCodepoint = 0x000B;
+              return true;
+            default:
+              return false; // Unsupported escape character
+          }
+      }
+
+      Stack<Allocator> states_;
+      Stack<Allocator> ranges_;
+      SizeType root_;
+      SizeType stateCount_;
+      SizeType rangeCount_;
+
+      static const unsigned kInfinityQuantifier = ~0u;
+
+      // For SearchWithAnchoring()
+      bool anchorBegin_;
+      bool anchorEnd_;
+  };
+
+  template <typename RegexType, typename Allocator = CrtAllocator>
+  class GenericRegexSearch
+  {
+    public:
+      typedef typename RegexType::EncodingType Encoding;
+      typedef typename Encoding::Ch Ch;
+
+      GenericRegexSearch(const RegexType &regex, Allocator *allocator = 0) :
+        regex_(regex), allocator_(allocator), ownAllocator_(0),
+        state0_(allocator, 0), state1_(allocator, 0), stateSet_()
+      {
+        RAPIDJSON_ASSERT(regex_.IsValid());
+        if (!allocator_)
+          ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
+        stateSet_ = static_cast<unsigned *>(allocator_->Malloc(GetStateSetSize()));
+        state0_.template Reserve<SizeType>(regex_.stateCount_);
+        state1_.template Reserve<SizeType>(regex_.stateCount_);
+      }
+
+      ~GenericRegexSearch()
+      {
+        Allocator::Free(stateSet_);
+        RAPIDJSON_DELETE(ownAllocator_);
+      }
+
+      template <typename InputStream>
+      bool Match(InputStream &is)
+      {
+        return SearchWithAnchoring(is, true, true);
+      }
+
+      bool Match(const Ch *s)
+      {
+        GenericStringStream<Encoding> is(s);
+        return Match(is);
+      }
+
+      template <typename InputStream>
+      bool Search(InputStream &is)
+      {
+        return SearchWithAnchoring(is, regex_.anchorBegin_, regex_.anchorEnd_);
+      }
+
+      bool Search(const Ch *s)
+      {
+        GenericStringStream<Encoding> is(s);
+        return Search(is);
+      }
+
+    private:
+      typedef typename RegexType::State State;
+      typedef typename RegexType::Range Range;
+
+      template <typename InputStream>
+      bool SearchWithAnchoring(InputStream &is, bool anchorBegin, bool anchorEnd)
+      {
+        DecodedStream<InputStream, Encoding> ds(is);
+
+        state0_.Clear();
+        Stack<Allocator> *current = &state0_, *next = &state1_;
+        const size_t stateSetSize = GetStateSetSize();
+        std::memset(stateSet_, 0, stateSetSize);
+
+        bool matched = AddState(*current, regex_.root_);
+        unsigned codepoint = 0;
+        while (!current->Empty() && (codepoint = ds.Take()) != 0)
+          {
+            std::memset(stateSet_, 0, stateSetSize);
+            next->Clear();
+            matched = false;
+            for (const SizeType *s = current->template Bottom<SizeType>(); s != current->template End<SizeType>(); ++s)
+              {
+                const State &sr = regex_.GetState(*s);
+                if (sr.codepoint == codepoint ||
+                    sr.codepoint == RegexType::kAnyCharacterClass ||
+                    (sr.codepoint == RegexType::kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))
+                  {
+                    matched = AddState(*next, sr.out) || matched;
+                    if (!anchorEnd && matched)
+                      return true;
+                  }
+                if (!anchorBegin)
+                  AddState(*next, regex_.root_);
+              }
+            internal::Swap(current, next);
+          }
+
+        return matched;
+      }
+
+      size_t GetStateSetSize() const
+      {
+        return (regex_.stateCount_ + 31) / 32 * 4;
+      }
+
+      // Return whether the added states is a match state
+      bool AddState(Stack<Allocator> &l, SizeType index)
+      {
+        RAPIDJSON_ASSERT(index != kRegexInvalidState);
+
+        const State &s = regex_.GetState(index);
+        if (s.out1 != kRegexInvalidState)   // Split
+          {
+            bool matched = AddState(l, s.out);
+            return AddState(l, s.out1) || matched;
+          }
+        else if (!(stateSet_[index >> 5] & (1u << (index & 31))))
+          {
+            stateSet_[index >> 5] |= (1u << (index & 31));
+            *l.template PushUnsafe<SizeType>() = index;
+          }
+        return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation.
+      }
+
+      bool MatchRange(SizeType rangeIndex, unsigned codepoint) const
+      {
+        bool yes = (regex_.GetRange(rangeIndex).start & RegexType::kRangeNegationFlag) == 0;
+        while (rangeIndex != kRegexInvalidRange)
+          {
+            const Range &r = regex_.GetRange(rangeIndex);
+            if (codepoint >= (r.start & ~RegexType::kRangeNegationFlag) && codepoint <= r.end)
+              return yes;
+            rangeIndex = r.next;
+          }
+        return !yes;
+      }
+
+      const RegexType &regex_;
+      Allocator *allocator_;
+      Allocator *ownAllocator_;
+      Stack<Allocator> state0_;
+      Stack<Allocator> state1_;
+      uint32_t *stateSet_;
+  };
+
+  typedef GenericRegex<UTF8<> > Regex;
+  typedef GenericRegexSearch<Regex> RegexSearch;
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#if defined(__clang__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_INTERNAL_REGEX_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/stack.h.bak b/contrib/world_builder/include/rapidjson/internal/stack.h.bak
new file mode 100644
index 00000000000..8d64a7a451c
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/stack.h.bak
@@ -0,0 +1,277 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_STACK_H_
+#define RAPIDJSON_INTERNAL_STACK_H_
+
+#include "../allocators.h"
+#include "swap.h"
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// Stack
+
+//! A type-unsafe stack for storing different types of data.
+  /*! \tparam Allocator Allocator for allocating stack memory.
+  */
+  template <typename Allocator>
+  class Stack
+  {
+    public:
+      // Optimization note: Do not allocate memory for stack_ in constructor.
+      // Do it lazily when first Push() -> Expand() -> Resize().
+      Stack(Allocator *allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity)
+      {
+      }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+      Stack(Stack &&rhs)
+        : allocator_(rhs.allocator_),
+          ownAllocator_(rhs.ownAllocator_),
+          stack_(rhs.stack_),
+          stackTop_(rhs.stackTop_),
+          stackEnd_(rhs.stackEnd_),
+          initialCapacity_(rhs.initialCapacity_)
+      {
+        rhs.allocator_ = 0;
+        rhs.ownAllocator_ = 0;
+        rhs.stack_ = 0;
+        rhs.stackTop_ = 0;
+        rhs.stackEnd_ = 0;
+        rhs.initialCapacity_ = 0;
+      }
+#endif
+
+      ~Stack()
+      {
+        Destroy();
+      }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+      Stack &operator=(Stack&& rhs)
+      {
+        if (&rhs != this)
+          {
+            Destroy();
+
+            allocator_ = rhs.allocator_;
+            ownAllocator_ = rhs.ownAllocator_;
+            stack_ = rhs.stack_;
+            stackTop_ = rhs.stackTop_;
+            stackEnd_ = rhs.stackEnd_;
+            initialCapacity_ = rhs.initialCapacity_;
+
+            rhs.allocator_ = 0;
+            rhs.ownAllocator_ = 0;
+            rhs.stack_ = 0;
+            rhs.stackTop_ = 0;
+            rhs.stackEnd_ = 0;
+            rhs.initialCapacity_ = 0;
+          }
+        return *this;
+      }
+#endif
+
+      void Swap(Stack &rhs) RAPIDJSON_NOEXCEPT
+      {
+        internal::Swap(allocator_, rhs.allocator_);
+        internal::Swap(ownAllocator_, rhs.ownAllocator_);
+        internal::Swap(stack_, rhs.stack_);
+        internal::Swap(stackTop_, rhs.stackTop_);
+        internal::Swap(stackEnd_, rhs.stackEnd_);
+        internal::Swap(initialCapacity_, rhs.initialCapacity_);
+      }
+
+      void Clear()
+      {
+        stackTop_ = stack_;
+      }
+
+      void ShrinkToFit()
+      {
+        if (Empty())
+          {
+            // If the stack is empty, completely deallocate the memory.
+            Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
+            stack_ = 0;
+            stackTop_ = 0;
+            stackEnd_ = 0;
+          }
+        else
+          Resize(GetSize());
+      }
+
+      // Optimization note: try to minimize the size of this function for force inline.
+      // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
+      template<typename T>
+      RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1)
+      {
+        // Expand the stack if needed
+        if (RAPIDJSON_UNLIKELY(stackTop_ + sizeof(T) * count > stackEnd_))
+          Expand<T>(count);
+      }
+
+      template<typename T>
+      RAPIDJSON_FORCEINLINE T *Push(size_t count = 1)
+      {
+        Reserve<T>(count);
+        return PushUnsafe<T>(count);
+      }
+
+      template<typename T>
+      RAPIDJSON_FORCEINLINE T *PushUnsafe(size_t count = 1)
+      {
+        RAPIDJSON_ASSERT(stackTop_);
+        RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_);
+        T *ret = reinterpret_cast<T *>(stackTop_);
+        stackTop_ += sizeof(T) * count;
+        return ret;
+      }
+
+      template<typename T>
+      T *Pop(size_t count)
+      {
+        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
+        stackTop_ -= count * sizeof(T);
+        return reinterpret_cast<T *>(stackTop_);
+      }
+
+      template<typename T>
+      T *Top()
+      {
+        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
+        return reinterpret_cast<T *>(stackTop_ - sizeof(T));
+      }
+
+      template<typename T>
+      const T *Top() const
+      {
+        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
+        return reinterpret_cast<T *>(stackTop_ - sizeof(T));
+      }
+
+      template<typename T>
+      T *End()
+      {
+        return reinterpret_cast<T *>(stackTop_);
+      }
+
+      template<typename T>
+      const T *End() const
+      {
+        return reinterpret_cast<T *>(stackTop_);
+      }
+
+      template<typename T>
+      T *Bottom()
+      {
+        return reinterpret_cast<T *>(stack_);
+      }
+
+      template<typename T>
+      const T *Bottom() const
+      {
+        return reinterpret_cast<T *>(stack_);
+      }
+
+      bool HasAllocator() const
+      {
+        return allocator_ != 0;
+      }
+
+      Allocator &GetAllocator()
+      {
+        RAPIDJSON_ASSERT(allocator_);
+        return *allocator_;
+      }
+
+      bool Empty() const
+      {
+        return stackTop_ == stack_;
+      }
+      size_t GetSize() const
+      {
+        return static_cast<size_t>(stackTop_ - stack_);
+      }
+      size_t GetCapacity() const
+      {
+        return static_cast<size_t>(stackEnd_ - stack_);
+      }
+
+    private:
+      template<typename T>
+      void Expand(size_t count)
+      {
+        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
+        size_t newCapacity;
+        if (stack_ == 0)
+          {
+            if (!allocator_)
+              ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
+            newCapacity = initialCapacity_;
+          }
+        else
+          {
+            newCapacity = GetCapacity();
+            newCapacity += (newCapacity + 1) / 2;
+          }
+        size_t newSize = GetSize() + sizeof(T) * count;
+        if (newCapacity < newSize)
+          newCapacity = newSize;
+
+        Resize(newCapacity);
+      }
+
+      void Resize(size_t newCapacity)
+      {
+        const size_t size = GetSize();  // Backup the current size
+        stack_ = static_cast<char *>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
+        stackTop_ = stack_ + size;
+        stackEnd_ = stack_ + newCapacity;
+      }
+
+      void Destroy()
+      {
+        Allocator::Free(stack_);
+        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
+      }
+
+      // Prohibit copy constructor & assignment operator.
+      Stack(const Stack &);
+      Stack &operator=(const Stack &);
+
+      Allocator *allocator_;
+      Allocator *ownAllocator_;
+      char *stack_;
+      char *stackTop_;
+      char *stackEnd_;
+      size_t initialCapacity_;
+  };
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_STACK_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/strfunc.h.bak b/contrib/world_builder/include/rapidjson/internal/strfunc.h.bak
new file mode 100644
index 00000000000..c6a36d50f69
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/strfunc.h.bak
@@ -0,0 +1,75 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_STRFUNC_H_
+#define RAPIDJSON_INTERNAL_STRFUNC_H_
+
+#include "../stream.h"
+#include <cwchar>
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+//! Custom strlen() which works on different character types.
+  /*! \tparam Ch Character type (e.g. char, wchar_t, short)
+      \param s Null-terminated input string.
+      \return Number of characters in the string.
+      \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
+  */
+  template <typename Ch>
+  inline SizeType StrLen(const Ch *s)
+  {
+    RAPIDJSON_ASSERT(s != 0);
+    const Ch *p = s;
+    while (*p) ++p;
+    return SizeType(p - s);
+  }
+
+  template <>
+  inline SizeType StrLen(const char *s)
+  {
+    return SizeType(std::strlen(s));
+  }
+
+  template <>
+  inline SizeType StrLen(const wchar_t *s)
+  {
+    return SizeType(std::wcslen(s));
+  }
+
+//! Returns number of code points in a encoded string.
+  template<typename Encoding>
+  bool CountStringCodePoint(const typename Encoding::Ch *s, SizeType length, SizeType *outCount)
+  {
+    RAPIDJSON_ASSERT(s != 0);
+    RAPIDJSON_ASSERT(outCount != 0);
+    GenericStringStream<Encoding> is(s);
+    const typename Encoding::Ch *end = s + length;
+    SizeType count = 0;
+    while (is.src_ < end)
+      {
+        unsigned codepoint;
+        if (!Encoding::Decode(is, &codepoint))
+          return false;
+        count++;
+      }
+    *outCount = count;
+    return true;
+  }
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_INTERNAL_STRFUNC_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/strtod.h.bak b/contrib/world_builder/include/rapidjson/internal/strtod.h.bak
new file mode 100644
index 00000000000..b98760f7345
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/strtod.h.bak
@@ -0,0 +1,317 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_STRTOD_
+#define RAPIDJSON_STRTOD_
+
+#include "ieee754.h"
+#include "biginteger.h"
+#include "diyfp.h"
+#include "pow10.h"
+#include <climits>
+#include <limits>
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+  inline double FastPath(double significand, int exp)
+  {
+    if (exp < -308)
+      return 0.0;
+    else if (exp >= 0)
+      return significand * internal::Pow10(exp);
+    else
+      return significand / internal::Pow10(-exp);
+  }
+
+  inline double StrtodNormalPrecision(double d, int p)
+  {
+    if (p < -308)
+      {
+        // Prevent expSum < -308, making Pow10(p) = 0
+        d = FastPath(d, -308);
+        d = FastPath(d, p + 308);
+      }
+    else
+      d = FastPath(d, p);
+    return d;
+  }
+
+  template <typename T>
+  inline T Min3(T a, T b, T c)
+  {
+    T m = a;
+    if (m > b) m = b;
+    if (m > c) m = c;
+    return m;
+  }
+
+  inline int CheckWithinHalfULP(double b, const BigInteger &d, int dExp)
+  {
+    const Double db(b);
+    const uint64_t bInt = db.IntegerSignificand();
+    const int bExp = db.IntegerExponent();
+    const int hExp = bExp - 1;
+
+    int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
+
+    // Adjust for decimal exponent
+    if (dExp >= 0)
+      {
+        dS_Exp2 += dExp;
+        dS_Exp5 += dExp;
+      }
+    else
+      {
+        bS_Exp2 -= dExp;
+        bS_Exp5 -= dExp;
+        hS_Exp2 -= dExp;
+        hS_Exp5 -= dExp;
+      }
+
+    // Adjust for binary exponent
+    if (bExp >= 0)
+      bS_Exp2 += bExp;
+    else
+      {
+        dS_Exp2 -= bExp;
+        hS_Exp2 -= bExp;
+      }
+
+    // Adjust for half ulp exponent
+    if (hExp >= 0)
+      hS_Exp2 += hExp;
+    else
+      {
+        dS_Exp2 -= hExp;
+        bS_Exp2 -= hExp;
+      }
+
+    // Remove common power of two factor from all three scaled values
+    int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
+    dS_Exp2 -= common_Exp2;
+    bS_Exp2 -= common_Exp2;
+    hS_Exp2 -= common_Exp2;
+
+    BigInteger dS = d;
+    dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);
+
+    BigInteger bS(bInt);
+    bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);
+
+    BigInteger hS(1);
+    hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);
+
+    BigInteger delta(0);
+    dS.Difference(bS, &delta);
+
+    return delta.Compare(hS);
+  }
+
+  inline bool StrtodFast(double d, int p, double *result)
+  {
+    // Use fast path for string-to-double conversion if possible
+    // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
+    if (p > 22  && p < 22 + 16)
+      {
+        // Fast Path Cases In Disguise
+        d *= internal::Pow10(p - 22);
+        p = 22;
+      }
+
+    if (p >= -22 && p <= 22 && d <= 9007199254740991.0)   // 2^53 - 1
+      {
+        *result = FastPath(d, p);
+        return true;
+      }
+    else
+      return false;
+  }
+
+// Compute an approximation and see if it is within 1/2 ULP
+  inline bool StrtodDiyFp(const char *decimals, int dLen, int dExp, double *result)
+  {
+    uint64_t significand = 0;
+    int i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999
+    for (; i < dLen; i++)
+      {
+        if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
+            (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
+          break;
+        significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
+      }
+
+    if (i < dLen && decimals[i] >= '5') // Rounding
+      significand++;
+
+    int remaining = dLen - i;
+    const int kUlpShift = 3;
+    const int kUlp = 1 << kUlpShift;
+    int64_t error = (remaining == 0) ? 0 : kUlp / 2;
+
+    DiyFp v(significand, 0);
+    v = v.Normalize();
+    error <<= -v.e;
+
+    dExp += remaining;
+
+    int actualExp;
+    DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
+    if (actualExp != dExp)
+      {
+        static const DiyFp kPow10[] =
+        {
+          DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60),  // 10^1
+          DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57),  // 10^2
+          DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54),  // 10^3
+          DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50),  // 10^4
+          DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47),  // 10^5
+          DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44),  // 10^6
+          DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40)   // 10^7
+        };
+        int adjustment = dExp - actualExp;
+        RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8);
+        v = v * kPow10[adjustment - 1];
+        if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit
+          error += kUlp / 2;
+      }
+
+    v = v * cachedPower;
+
+    error += kUlp + (error == 0 ? 0 : 1);
+
+    const int oldExp = v.e;
+    v = v.Normalize();
+    error <<= oldExp - v.e;
+
+    const int effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
+    int precisionSize = 64 - effectiveSignificandSize;
+    if (precisionSize + kUlpShift >= 64)
+      {
+        int scaleExp = (precisionSize + kUlpShift) - 63;
+        v.f >>= scaleExp;
+        v.e += scaleExp;
+        error = (error >> scaleExp) + 1 + kUlp;
+        precisionSize -= scaleExp;
+      }
+
+    DiyFp rounded(v.f >> precisionSize, v.e + precisionSize);
+    const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
+    const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
+    if (precisionBits >= halfWay + static_cast<unsigned>(error))
+      {
+        rounded.f++;
+        if (rounded.f & (DiyFp::kDpHiddenBit << 1))   // rounding overflows mantissa (issue #340)
+          {
+            rounded.f >>= 1;
+            rounded.e++;
+          }
+      }
+
+    *result = rounded.ToDouble();
+
+    return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
+  }
+
+  inline double StrtodBigInteger(double approx, const char *decimals, int dLen, int dExp)
+  {
+    RAPIDJSON_ASSERT(dLen >= 0);
+    const BigInteger dInt(decimals, static_cast<unsigned>(dLen));
+    Double a(approx);
+    int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
+    if (cmp < 0)
+      return a.Value();  // within half ULP
+    else if (cmp == 0)
+      {
+        // Round towards even
+        if (a.Significand() & 1)
+          return a.NextPositiveDouble();
+        else
+          return a.Value();
+      }
+    else // adjustment
+      return a.NextPositiveDouble();
+  }
+
+  inline double StrtodFullPrecision(double d, int p, const char *decimals, size_t length, size_t decimalPosition, int exp)
+  {
+    RAPIDJSON_ASSERT(d >= 0.0);
+    RAPIDJSON_ASSERT(length >= 1);
+
+    double result = 0.0;
+    if (StrtodFast(d, p, &result))
+      return result;
+
+    RAPIDJSON_ASSERT(length <= INT_MAX);
+    int dLen = static_cast<int>(length);
+
+    RAPIDJSON_ASSERT(length >= decimalPosition);
+    RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX);
+    int dExpAdjust = static_cast<int>(length - decimalPosition);
+
+    RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust);
+    int dExp = exp - dExpAdjust;
+
+    // Make sure length+dExp does not overflow
+    RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen);
+
+    // Trim leading zeros
+    while (dLen > 0 && *decimals == '0')
+      {
+        dLen--;
+        decimals++;
+      }
+
+    // Trim trailing zeros
+    while (dLen > 0 && decimals[dLen - 1] == '0')
+      {
+        dLen--;
+        dExp++;
+      }
+
+    if (dLen == 0)   // Buffer only contains zeros.
+      {
+        return 0.0;
+      }
+
+    // Trim right-most digits
+    const int kMaxDecimalDigit = 767 + 1;
+    if (dLen > kMaxDecimalDigit)
+      {
+        dExp += dLen - kMaxDecimalDigit;
+        dLen = kMaxDecimalDigit;
+      }
+
+    // If too small, underflow to zero.
+    // Any x <= 10^-324 is interpreted as zero.
+    if (dLen + dExp <= -324)
+      return 0.0;
+
+    // If too large, overflow to infinity.
+    // Any x >= 10^309 is interpreted as +infinity.
+    if (dLen + dExp > 309)
+      return std::numeric_limits<double>::infinity();
+
+    if (StrtodDiyFp(decimals, dLen, dExp, &result))
+      return result;
+
+    // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
+    return StrtodBigInteger(result, decimals, dLen, dExp);
+  }
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_STRTOD_
diff --git a/contrib/world_builder/include/rapidjson/internal/swap.h.bak b/contrib/world_builder/include/rapidjson/internal/swap.h.bak
new file mode 100644
index 00000000000..dfb1f19e77e
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/internal/swap.h.bak
@@ -0,0 +1,48 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_SWAP_H_
+#define RAPIDJSON_INTERNAL_SWAP_H_
+
+#include "../rapidjson.h"
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal
+{
+
+//! Custom swap() to avoid dependency on C++ <algorithm> header
+  /*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.
+      \note This has the same semantics as std::swap().
+  */
+  template <typename T>
+  inline void Swap(T &a, T &b) RAPIDJSON_NOEXCEPT
+  {
+    T tmp = a;
+    a = b;
+    b = tmp;
+  }
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_INTERNAL_SWAP_H_
diff --git a/contrib/world_builder/include/rapidjson/istreamwrapper.h.bak b/contrib/world_builder/include/rapidjson/istreamwrapper.h.bak
new file mode 100644
index 00000000000..f3b83b6858f
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/istreamwrapper.h.bak
@@ -0,0 +1,137 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ISTREAMWRAPPER_H_
+#define RAPIDJSON_ISTREAMWRAPPER_H_
+
+#include "stream.h"
+#include <iosfwd>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Wrapper of \c std::basic_istream into RapidJSON's Stream concept.
+/*!
+    The classes can be wrapped including but not limited to:
+
+    - \c std::istringstream
+    - \c std::stringstream
+    - \c std::wistringstream
+    - \c std::wstringstream
+    - \c std::ifstream
+    - \c std::fstream
+    - \c std::wifstream
+    - \c std::wfstream
+
+    \tparam StreamType Class derived from \c std::basic_istream.
+*/
+
+template <typename StreamType>
+class BasicIStreamWrapper
+{
+  public:
+    typedef typename StreamType::char_type Ch;
+    BasicIStreamWrapper(StreamType &stream) : stream_(stream), count_(), peekBuffer_() {}
+
+    Ch Peek() const
+    {
+      typename StreamType::int_type c = stream_.peek();
+      return RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()) ? static_cast<Ch>(c) : static_cast<Ch>('\0');
+    }
+
+    Ch Take()
+    {
+      typename StreamType::int_type c = stream_.get();
+      if (RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()))
+        {
+          count_++;
+          return static_cast<Ch>(c);
+        }
+      else
+        return '\0';
+    }
+
+    // tellg() may return -1 when failed. So we count by ourself.
+    size_t Tell() const
+    {
+      return count_;
+    }
+
+    Ch *PutBegin()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    void Put(Ch)
+    {
+      RAPIDJSON_ASSERT(false);
+    }
+    void Flush()
+    {
+      RAPIDJSON_ASSERT(false);
+    }
+    size_t PutEnd(Ch *)
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+
+    // For encoding detection only.
+    const Ch *Peek4() const
+    {
+      RAPIDJSON_ASSERT(sizeof(Ch) == 1); // Only usable for byte stream.
+      int i;
+      bool hasError = false;
+      for (i = 0; i < 4; ++i)
+        {
+          typename StreamType::int_type c = stream_.get();
+          if (c == StreamType::traits_type::eof())
+            {
+              hasError = true;
+              stream_.clear();
+              break;
+            }
+          peekBuffer_[i] = static_cast<Ch>(c);
+        }
+      for (--i; i >= 0; --i)
+        stream_.putback(peekBuffer_[i]);
+      return !hasError ? peekBuffer_ : 0;
+    }
+
+  private:
+    BasicIStreamWrapper(const BasicIStreamWrapper &);
+    BasicIStreamWrapper &operator=(const BasicIStreamWrapper &);
+
+    StreamType &stream_;
+    size_t count_;  //!< Number of characters read. Note:
+    mutable Ch peekBuffer_[4];
+};
+
+typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
+typedef BasicIStreamWrapper<std::wistream> WIStreamWrapper;
+
+#if defined(__clang__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ISTREAMWRAPPER_H_
diff --git a/contrib/world_builder/include/rapidjson/latexwriter.h.bak b/contrib/world_builder/include/rapidjson/latexwriter.h.bak
new file mode 100644
index 00000000000..85c07e958ad
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/latexwriter.h.bak
@@ -0,0 +1,468 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_LATEXWRITER_H_
+#define RAPIDJSON_LATEXWRITER_H_
+
+#include "writer.h"
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+
+//! Writer with indentation and spacing.
+/*!
+    \tparam OutputStream Type of output os.
+    \tparam SourceEncoding Encoding of source string.
+    \tparam TargetEncoding Encoding of output stream.
+    \tparam StackAllocator Type of allocator for allocating memory of stack.
+*/
+template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
+class LatexWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags>
+{
+  public:
+    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base;
+    typedef typename Base::Ch Ch;
+
+    //! Constructor
+    /*! \param os Output stream.
+        \param allocator User supplied allocator. If it is null, it will create a private one.
+        \param levelDepth Initial capacity of stack.
+    */
+    explicit LatexWriter(OutputStream &os, StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
+      Base(os, allocator, levelDepth)
+    {
+      level_type.resize(0);
+      array_number.resize(0);
+      path.resize(0);
+    }
+
+
+    explicit LatexWriter(StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
+      Base(allocator, levelDepth)
+    {
+      level_type.resize(0);
+      array_number.resize(0);
+      path.resize(0);
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    LatexWriter(LatexWriter &&rhs) :
+      Base(std::forward<LatexWriter>(rhs))
+    {
+      level_type.resize(0);
+      array_number.resize(0);
+      path.resize(0);
+    }
+#endif
+
+    /*! @name Implementation of Handler
+        \see Handler
+    */
+    //@{
+
+    bool Null()
+    {
+      return Base::EndValue(Base::WriteNull());
+    }
+    bool Bool(bool b)
+    {
+      Base::EndValue(Base::WriteBool(b));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Int(int i)
+    {
+      Base::EndValue(Base::WriteInt(i));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Uint(unsigned u)
+    {
+      Base::EndValue(Base::WriteUint(u));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Int64(int64_t i64)
+    {
+      Base::EndValue(Base::WriteInt64(i64));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Uint64(uint64_t u64)
+    {
+      Base::EndValue(Base::WriteUint64(u64));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Double(double d)
+    {
+      Base::EndValue(Base::WriteDouble(d));
+      Base::os_->Put('\n');
+      return true;
+    }
+
+    bool RawNumber(const Ch *str, SizeType length, bool /*copy = false*/)
+    {
+      RAPIDJSON_ASSERT(str != 0);
+      Base::EndValue(Base::WriteString(str, length, false));
+      Base::os_->Put('\n');
+      return true;
+    }
+
+    bool String(const Ch *str, SizeType length, bool /*copy = false*/)
+    {
+      RAPIDJSON_ASSERT(str != 0);
+      if (small_array == true)
+        {
+          if (first_small_array == true)
+            first_small_array = false;
+          else
+            {
+              Base::os_->Put(',');
+              Base::os_->Put(' ');
+            }
+        }
+      Base::EndValue(Base::WriteString(str, length, false));
+
+      if (small_array == false)
+        Base::os_->Put('\n');
+      return true;
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool String(const std::basic_string<Ch> &str)
+    {
+      return String(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool StartObject()
+    {
+      std::string begin = "";
+      if (level_type.size() != 0 && level_type.back() == 1)
+        {
+          // this is a properties starting, so first clear all the itemize
+          // the lvel_type.push_back(1) has already been done by the key: properties
+          for (unsigned int i = 0; i < itemize_open; ++i)
+            {
+              begin += "\\end{itemize}";
+            }
+          itemize_open = 0;
+          if (skip_next_push_back == false)
+            {
+              if (section_level <= 2)
+                begin += "\\section{(" + std::to_string(section_level) + ") " + get_path() + "}";
+              else if (section_level <= 5)
+                begin += "\\subsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
+              else if (section_level <= 8)
+                begin += "\\subsubsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
+              else
+                begin += "\\paragraph{(" + std::to_string(section_level) + ") " + get_path() + "}";
+
+              open_new_itemize = true;
+              level_type.push_back(0);
+            }
+          else
+            {
+              skip_next_push_back = false;
+            }
+        }
+      else if (level_type.size() != 0 && level_type.back() == 2)
+        {
+          // this is a array starting, so first clear all the itemize
+          // the lvel_type.push_back(1) has already been done by the key: properties
+          for (unsigned int i = 0; i < itemize_open; ++i)
+            {
+              begin += "\\end{itemize}";
+            }
+          itemize_open = 0;
+          unsigned int number = array_number.back() + 1;
+          array_number.back() = number;
+          path.push_back(std::to_string(array_number.back()));
+          level_type.push_back(0);
+          // have arrrays (/oneOf/1) as new section level
+          section_level++;
+
+          if (section_level <= 2)
+            begin += "\\section{(" + std::to_string(section_level) + ") " + get_path() + "}";
+          else if (section_level <= 5)
+            begin += "\\subsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
+          else if (section_level <= 8)
+            begin += "\\subsubsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
+          else
+            begin += "\\paragraph{(" + std::to_string(section_level) + ") " + get_path() + "}";
+
+          open_new_itemize = true;
+        }
+      else
+        {
+          for (unsigned int i = 0; i < itemize_open; ++i)
+            {
+              begin += "\\end{itemize}";
+            }
+          itemize_open = 0;
+
+          //begin += "C";
+          if (section_level <= 2)
+            begin += "\\section{(" + std::to_string(section_level) + ") " + get_path() + "}";
+          else if (section_level <= 5)
+            begin += "\\subsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
+          else if (section_level <= 8)
+            begin += "\\subsubsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
+          else
+            begin += "\\paragraph{(" + std::to_string(section_level) + ") " + get_path() + "}";
+
+          open_new_itemize = true;
+          if (level_type.size() > 0 && (level_type.back() != 3 || level_type.size() == 0))
+            level_type.push_back(0);
+        }
+
+      Base::WriteString(begin.c_str(), static_cast<rapidjson::SizeType>(begin.size()), false);
+      Base::os_->Put('\n');
+
+      return true;
+    }
+
+    bool Key(const Ch *str, SizeType /*length*/, bool /*copy = false*/)
+    {
+      std::string item = "";
+
+
+      std::string key(str);
+      if (key == "properties")
+        {
+          if (open_new_itemize == true)
+            {
+              item += "\\begin{itemize}[leftmargin=" + std::to_string(section_level) + "em]";
+              itemize_open++;
+            }
+          level_type.push_back(1);
+          skip_next_push_back = true;
+        }
+      else if (key == "oneOf")
+        {
+          level_type.push_back(2);
+          path.push_back(key);
+        }
+      else if (key == "items")
+        {
+          if (open_new_itemize == true)
+            {
+              item += "\\begin{itemize}[leftmargin=" + std::to_string(section_level) + "em]";
+              itemize_open++;
+            }
+          section_level++;
+          level_type.push_back(3);
+          path.push_back(key);
+        }
+      else if (level_type.size() > 0 && level_type.back() == 1)
+        {
+          // the level just below properties, these are the sections
+          // add to the path
+
+          section_level++;
+          path.push_back(key);
+        }
+      else
+        {
+          if (open_new_itemize == true)
+            {
+              item += "\\begin{itemize}[leftmargin=" + std::to_string(section_level) + "em]";
+              itemize_open++;
+
+            }
+          item += "\\item {\\bf " + std::string(str) + "}: ";
+        }
+
+      open_new_itemize = false;
+      Base::WriteString(item.c_str(), static_cast<rapidjson::SizeType>(item.length()), false);
+
+      return true;
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool Key(const std::basic_string<Ch> &str)
+    {
+      return Key(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool EndObject(SizeType /*memberCount = 0*/)
+    {
+      std::string end = "";
+      if (itemize_open > 0)
+        {
+          end = "\\end{itemize}";
+          itemize_open--;
+        }
+      itemize_open = 0;
+      // If this assert fails it could be an indicator that
+      // the world builder library is not fuly linked to the
+      // appllication.
+      if (level_type.size() > 0 && (level_type.back() == 0 || level_type.back() == 3))
+        section_level = section_level > 0 ? section_level-1 : 0;
+
+
+      if (level_type.size() > 0 && path.size() > 0 &&
+          ( level_type.back() == 3 || level_type.back() == 0))
+        {
+          path.pop_back();
+        }
+
+      if (level_type.size() > 0)
+        level_type.pop_back();
+
+      Base::WriteString(end.c_str(), static_cast<rapidjson::SizeType>(end.length()), false);
+
+      return true;
+    }
+
+    bool StartArray()
+    {
+      std::string begin = "";
+      if (level_type.size() != 0 && level_type.back() == 2)
+        {
+          // this is a properties starting, so first clear all the itemize
+          // the lvel_type.push_back(1) has already been done by the key: properties
+          for (unsigned int i = 0; i < itemize_open; ++i)
+            {
+              begin += "\\end{itemize}";
+            }
+          itemize_open = 0;
+
+          open_new_itemize = true;
+          array_number.push_back(0);
+        }
+      else
+        {
+          begin = "[";
+          small_array = true;
+          first_small_array = true;
+        }
+
+      Base::WriteString(begin.c_str(), static_cast<rapidjson::SizeType>(begin.size()), false);
+
+      if (small_array == false)
+        Base::os_->Put('\n');
+
+      return true;
+    }
+
+    bool EndArray(SizeType /*memberCount = 0*/)
+    {
+      std::string end = "";
+      if (level_type.size() != 0 && level_type.back() == 2)
+        {
+          array_number.pop_back();
+          level_type.pop_back();
+
+          if (path.size() > 0)
+            path.pop_back();
+        }
+      else
+        {
+          end = "]";
+          small_array = false;
+        }
+
+      Base::WriteString(end.c_str(), static_cast<rapidjson::SizeType>(end.size()), false);
+
+      return true;
+    }
+
+    //@}
+
+    /*! @name Convenience extensions */
+    //@{
+
+    //! Simpler but slower overload.
+    bool String(const Ch *str)
+    {
+      return String(str, internal::StrLen(str));
+    }
+    bool Key(const Ch *str)
+    {
+      return Key(str, internal::StrLen(str));
+    }
+
+    //@}
+
+    //! Write a raw JSON value.
+    /*!
+        For user to write a stringified JSON as a value.
+
+        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
+        \param length Length of the json.
+        \param type Type of the root of json.
+        \note When using LatexWriter::RawValue(), the result json may not be indented correctly.
+    */
+    bool RawValue(const Ch *json, size_t length, Type /*type*/)
+    {
+      RAPIDJSON_ASSERT(json != 0);
+      return Base::EndValue(Base::WriteRawValue(json, length));
+    }
+
+  protected:
+
+    std::string get_path()
+    {
+      std::string return_path;
+      for (auto string : path)
+        {
+          return_path += "/" + string;
+        }
+      return return_path == "" ? "/" : return_path;
+    }
+
+    unsigned int itemize_open = 0;
+    std::vector<unsigned int> level_type;
+    std::vector<unsigned int> array_number;
+    bool skip_next_push_back = false;
+    bool small_array = false;
+    bool first_small_array = false;
+    bool open_new_itemize = false;
+    unsigned int section_level = 0;
+
+  private:
+    std::vector<std::string> path;
+    // Prohibit copy constructor & assignment operator.
+    LatexWriter(const LatexWriter &);
+    LatexWriter &operator=(const LatexWriter &);
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/rapidjson/memorybuffer.h.bak b/contrib/world_builder/include/rapidjson/memorybuffer.h.bak
new file mode 100644
index 00000000000..f77b612f24e
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/memorybuffer.h.bak
@@ -0,0 +1,91 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_MEMORYBUFFER_H_
+#define RAPIDJSON_MEMORYBUFFER_H_
+
+#include "stream.h"
+#include "internal/stack.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Represents an in-memory output byte stream.
+/*!
+    This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream.
+
+    It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file.
+
+    Differences between MemoryBuffer and StringBuffer:
+    1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer.
+    2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator.
+
+    \tparam Allocator type for allocating memory buffer.
+    \note implements Stream concept
+*/
+template <typename Allocator = CrtAllocator>
+struct GenericMemoryBuffer
+{
+  typedef char Ch; // byte
+
+  GenericMemoryBuffer(Allocator *allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
+
+  void Put(Ch c)
+  {
+    *stack_.template Push<Ch>() = c;
+  }
+  void Flush() {}
+
+  void Clear()
+  {
+    stack_.Clear();
+  }
+  void ShrinkToFit()
+  {
+    stack_.ShrinkToFit();
+  }
+  Ch *Push(size_t count)
+  {
+    return stack_.template Push<Ch>(count);
+  }
+  void Pop(size_t count)
+  {
+    stack_.template Pop<Ch>(count);
+  }
+
+  const Ch *GetBuffer() const
+  {
+    return stack_.template Bottom<Ch>();
+  }
+
+  size_t GetSize() const
+  {
+    return stack_.GetSize();
+  }
+
+  static const size_t kDefaultCapacity = 256;
+  mutable internal::Stack<Allocator> stack_;
+};
+
+typedef GenericMemoryBuffer<> MemoryBuffer;
+
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(MemoryBuffer &memoryBuffer, char c, size_t n)
+{
+  std::memset(memoryBuffer.stack_.Push<char>(n), c, n * sizeof(c));
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/contrib/world_builder/include/rapidjson/memorystream.h.bak b/contrib/world_builder/include/rapidjson/memorystream.h.bak
new file mode 100644
index 00000000000..68000d9938a
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/memorystream.h.bak
@@ -0,0 +1,96 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_MEMORYSTREAM_H_
+#define RAPIDJSON_MEMORYSTREAM_H_
+
+#include "stream.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(unreachable-code)
+RAPIDJSON_DIAG_OFF(missing-noreturn)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Represents an in-memory input byte stream.
+/*!
+    This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream.
+
+    It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file.
+
+    Differences between MemoryStream and StringStream:
+    1. StringStream has encoding but MemoryStream is a byte stream.
+    2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source.
+    3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4().
+    \note implements Stream concept
+*/
+struct MemoryStream
+{
+  typedef char Ch; // byte
+
+  MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}
+
+  Ch Peek() const
+  {
+    return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_;
+  }
+  Ch Take()
+  {
+    return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_++;
+  }
+  size_t Tell() const
+  {
+    return static_cast<size_t>(src_ - begin_);
+  }
+
+  Ch *PutBegin()
+  {
+    RAPIDJSON_ASSERT(false);
+    return 0;
+  }
+  void Put(Ch)
+  {
+    RAPIDJSON_ASSERT(false);
+  }
+  void Flush()
+  {
+    RAPIDJSON_ASSERT(false);
+  }
+  size_t PutEnd(Ch *)
+  {
+    RAPIDJSON_ASSERT(false);
+    return 0;
+  }
+
+  // For encoding detection only.
+  const Ch *Peek4() const
+  {
+    return Tell() + 4 <= size_ ? src_ : 0;
+  }
+
+  const Ch *src_;     //!< Current read position.
+  const Ch *begin_;   //!< Original head of the string.
+  const Ch *end_;     //!< End of stream.
+  size_t size_;       //!< Size of the stream.
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/contrib/world_builder/include/rapidjson/msinttypes/inttypes.h.bak b/contrib/world_builder/include/rapidjson/msinttypes/inttypes.h.bak
new file mode 100644
index 00000000000..502d4bfe1e0
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/msinttypes/inttypes.h.bak
@@ -0,0 +1,320 @@
+// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
+//  Copyright (c) 2006-2013 Alexander Chemeris
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+//
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+//
+//   3. Neither the name of the product nor the names of its contributors may
+//      be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// The above software in this distribution may have been modified by
+// THL A29 Limited ("Tencent Modifications").
+// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
+namespace rapidjson
+{
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_INTTYPES_H_ // [
+#define _MSC_INTTYPES_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include "stdint.h"
+
+// miloyip: VC supports inttypes.h since VC2013
+#if _MSC_VER >= 1800
+#include <inttypes.h>
+#else
+
+// 7.8 Format conversion of integer types
+
+  typedef struct
+  {
+    intmax_t quot;
+    intmax_t rem;
+  } imaxdiv_t;
+
+// 7.8.1 Macros for format specifiers
+
+#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
+
+// The fprintf macros for signed integers are:
+#define PRId8       "d"
+#define PRIi8       "i"
+#define PRIdLEAST8  "d"
+#define PRIiLEAST8  "i"
+#define PRIdFAST8   "d"
+#define PRIiFAST8   "i"
+
+#define PRId16       "hd"
+#define PRIi16       "hi"
+#define PRIdLEAST16  "hd"
+#define PRIiLEAST16  "hi"
+#define PRIdFAST16   "hd"
+#define PRIiFAST16   "hi"
+
+#define PRId32       "I32d"
+#define PRIi32       "I32i"
+#define PRIdLEAST32  "I32d"
+#define PRIiLEAST32  "I32i"
+#define PRIdFAST32   "I32d"
+#define PRIiFAST32   "I32i"
+
+#define PRId64       "I64d"
+#define PRIi64       "I64i"
+#define PRIdLEAST64  "I64d"
+#define PRIiLEAST64  "I64i"
+#define PRIdFAST64   "I64d"
+#define PRIiFAST64   "I64i"
+
+#define PRIdMAX     "I64d"
+#define PRIiMAX     "I64i"
+
+#define PRIdPTR     "Id"
+#define PRIiPTR     "Ii"
+
+// The fprintf macros for unsigned integers are:
+#define PRIo8       "o"
+#define PRIu8       "u"
+#define PRIx8       "x"
+#define PRIX8       "X"
+#define PRIoLEAST8  "o"
+#define PRIuLEAST8  "u"
+#define PRIxLEAST8  "x"
+#define PRIXLEAST8  "X"
+#define PRIoFAST8   "o"
+#define PRIuFAST8   "u"
+#define PRIxFAST8   "x"
+#define PRIXFAST8   "X"
+
+#define PRIo16       "ho"
+#define PRIu16       "hu"
+#define PRIx16       "hx"
+#define PRIX16       "hX"
+#define PRIoLEAST16  "ho"
+#define PRIuLEAST16  "hu"
+#define PRIxLEAST16  "hx"
+#define PRIXLEAST16  "hX"
+#define PRIoFAST16   "ho"
+#define PRIuFAST16   "hu"
+#define PRIxFAST16   "hx"
+#define PRIXFAST16   "hX"
+
+#define PRIo32       "I32o"
+#define PRIu32       "I32u"
+#define PRIx32       "I32x"
+#define PRIX32       "I32X"
+#define PRIoLEAST32  "I32o"
+#define PRIuLEAST32  "I32u"
+#define PRIxLEAST32  "I32x"
+#define PRIXLEAST32  "I32X"
+#define PRIoFAST32   "I32o"
+#define PRIuFAST32   "I32u"
+#define PRIxFAST32   "I32x"
+#define PRIXFAST32   "I32X"
+
+#define PRIo64       "I64o"
+#define PRIu64       "I64u"
+#define PRIx64       "I64x"
+#define PRIX64       "I64X"
+#define PRIoLEAST64  "I64o"
+#define PRIuLEAST64  "I64u"
+#define PRIxLEAST64  "I64x"
+#define PRIXLEAST64  "I64X"
+#define PRIoFAST64   "I64o"
+#define PRIuFAST64   "I64u"
+#define PRIxFAST64   "I64x"
+#define PRIXFAST64   "I64X"
+
+#define PRIoMAX     "I64o"
+#define PRIuMAX     "I64u"
+#define PRIxMAX     "I64x"
+#define PRIXMAX     "I64X"
+
+#define PRIoPTR     "Io"
+#define PRIuPTR     "Iu"
+#define PRIxPTR     "Ix"
+#define PRIXPTR     "IX"
+
+// The fscanf macros for signed integers are:
+#define SCNd8       "d"
+#define SCNi8       "i"
+#define SCNdLEAST8  "d"
+#define SCNiLEAST8  "i"
+#define SCNdFAST8   "d"
+#define SCNiFAST8   "i"
+
+#define SCNd16       "hd"
+#define SCNi16       "hi"
+#define SCNdLEAST16  "hd"
+#define SCNiLEAST16  "hi"
+#define SCNdFAST16   "hd"
+#define SCNiFAST16   "hi"
+
+#define SCNd32       "ld"
+#define SCNi32       "li"
+#define SCNdLEAST32  "ld"
+#define SCNiLEAST32  "li"
+#define SCNdFAST32   "ld"
+#define SCNiFAST32   "li"
+
+#define SCNd64       "I64d"
+#define SCNi64       "I64i"
+#define SCNdLEAST64  "I64d"
+#define SCNiLEAST64  "I64i"
+#define SCNdFAST64   "I64d"
+#define SCNiFAST64   "I64i"
+
+#define SCNdMAX     "I64d"
+#define SCNiMAX     "I64i"
+
+#ifdef _WIN64 // [
+#  define SCNdPTR     "I64d"
+#  define SCNiPTR     "I64i"
+#else  // _WIN64 ][
+#  define SCNdPTR     "ld"
+#  define SCNiPTR     "li"
+#endif  // _WIN64 ]
+
+// The fscanf macros for unsigned integers are:
+#define SCNo8       "o"
+#define SCNu8       "u"
+#define SCNx8       "x"
+#define SCNX8       "X"
+#define SCNoLEAST8  "o"
+#define SCNuLEAST8  "u"
+#define SCNxLEAST8  "x"
+#define SCNXLEAST8  "X"
+#define SCNoFAST8   "o"
+#define SCNuFAST8   "u"
+#define SCNxFAST8   "x"
+#define SCNXFAST8   "X"
+
+#define SCNo16       "ho"
+#define SCNu16       "hu"
+#define SCNx16       "hx"
+#define SCNX16       "hX"
+#define SCNoLEAST16  "ho"
+#define SCNuLEAST16  "hu"
+#define SCNxLEAST16  "hx"
+#define SCNXLEAST16  "hX"
+#define SCNoFAST16   "ho"
+#define SCNuFAST16   "hu"
+#define SCNxFAST16   "hx"
+#define SCNXFAST16   "hX"
+
+#define SCNo32       "lo"
+#define SCNu32       "lu"
+#define SCNx32       "lx"
+#define SCNX32       "lX"
+#define SCNoLEAST32  "lo"
+#define SCNuLEAST32  "lu"
+#define SCNxLEAST32  "lx"
+#define SCNXLEAST32  "lX"
+#define SCNoFAST32   "lo"
+#define SCNuFAST32   "lu"
+#define SCNxFAST32   "lx"
+#define SCNXFAST32   "lX"
+
+#define SCNo64       "I64o"
+#define SCNu64       "I64u"
+#define SCNx64       "I64x"
+#define SCNX64       "I64X"
+#define SCNoLEAST64  "I64o"
+#define SCNuLEAST64  "I64u"
+#define SCNxLEAST64  "I64x"
+#define SCNXLEAST64  "I64X"
+#define SCNoFAST64   "I64o"
+#define SCNuFAST64   "I64u"
+#define SCNxFAST64   "I64x"
+#define SCNXFAST64   "I64X"
+
+#define SCNoMAX     "I64o"
+#define SCNuMAX     "I64u"
+#define SCNxMAX     "I64x"
+#define SCNXMAX     "I64X"
+
+#ifdef _WIN64 // [
+#  define SCNoPTR     "I64o"
+#  define SCNuPTR     "I64u"
+#  define SCNxPTR     "I64x"
+#  define SCNXPTR     "I64X"
+#else  // _WIN64 ][
+#  define SCNoPTR     "lo"
+#  define SCNuPTR     "lu"
+#  define SCNxPTR     "lx"
+#  define SCNXPTR     "lX"
+#endif  // _WIN64 ]
+
+#endif // __STDC_FORMAT_MACROS ]
+
+// 7.8.2 Functions for greatest-width integer types
+
+// 7.8.2.1 The imaxabs function
+#define imaxabs _abs64
+
+// 7.8.2.2 The imaxdiv function
+
+// This is modified version of div() function from Microsoft's div.c found
+// in %MSVC.NET%\crt\src\div.c
+#ifdef STATIC_IMAXDIV // [
+  static
+#else // STATIC_IMAXDIV ][
+  _inline
+#endif // STATIC_IMAXDIV ]
+  imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
+  {
+    imaxdiv_t result;
+
+    result.quot = numer / denom;
+    result.rem = numer % denom;
+
+    if (numer < 0 && result.rem > 0)
+      {
+        // did division wrong; must fix up
+        ++result.quot;
+        result.rem -= denom;
+      }
+
+    return result;
+  }
+
+// 7.8.2.3 The strtoimax and strtoumax functions
+#define strtoimax _strtoi64
+#define strtoumax _strtoui64
+
+// 7.8.2.4 The wcstoimax and wcstoumax functions
+#define wcstoimax _wcstoi64
+#define wcstoumax _wcstoui64
+
+#endif // _MSC_VER >= 1800
+
+#endif // _MSC_INTTYPES_H_ ]
+}
\ No newline at end of file
diff --git a/contrib/world_builder/include/rapidjson/msinttypes/stdint.h.bak b/contrib/world_builder/include/rapidjson/msinttypes/stdint.h.bak
new file mode 100644
index 00000000000..421edf64459
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/msinttypes/stdint.h.bak
@@ -0,0 +1,300 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
+//  Copyright (c) 2006-2013 Alexander Chemeris
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+//
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+//
+//   3. Neither the name of the product nor the names of its contributors may
+//      be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// The above software in this distribution may have been modified by
+// THL A29 Limited ("Tencent Modifications").
+// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+// miloyip: Originally Visual Studio 2010 uses its own stdint.h. However it generates warning with INT64_C(), so change to use this file for vs2010.
+#if _MSC_VER >= 1600 // [
+#include <stdint.h>
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+#undef INT8_C
+#undef INT16_C
+#undef INT32_C
+#undef INT64_C
+#undef UINT8_C
+#undef UINT16_C
+#undef UINT32_C
+#undef UINT64_C
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
+// Check out Issue 9 for the details.
+#ifndef INTMAX_C //   [
+#  define INTMAX_C   INT64_C
+#endif // INTMAX_C    ]
+#ifndef UINTMAX_C //  [
+#  define UINTMAX_C  UINT64_C
+#endif // UINTMAX_C   ]
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+#else // ] _MSC_VER >= 1700 [
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we have to wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler would give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#if defined(__cplusplus) && !defined(_M_ARM)
+extern "C" {
+#endif
+#  include <wchar.h>
+#if defined(__cplusplus) && !defined(_M_ARM)
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#     define _W64 __w64
+#  else
+#     define _W64
+#  endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+typedef signed char       int8_t;
+typedef signed short      int16_t;
+typedef signed int        int32_t;
+typedef unsigned char     uint8_t;
+typedef unsigned short    uint16_t;
+typedef unsigned int      uint32_t;
+#else
+typedef signed __int8     int8_t;
+typedef signed __int16    int16_t;
+typedef signed __int32    int32_t;
+typedef unsigned __int8   uint8_t;
+typedef unsigned __int16  uint16_t;
+typedef unsigned __int32  uint32_t;
+#endif
+typedef signed __int64       int64_t;
+typedef unsigned __int64     uint64_t;
+
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint64_t  uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+typedef signed __int64    intptr_t;
+typedef unsigned __int64  uintptr_t;
+#else // _WIN64 ][
+typedef _W64 signed int   intptr_t;
+typedef _W64 unsigned int uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else // _WIN64 ][
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  // _WIN64 ][
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  // _WIN64 ]
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX // [
+#  ifdef _WIN64 // [
+#     define SIZE_MAX  _UI64_MAX
+#  else // _WIN64 ][
+#     define SIZE_MAX  _UI32_MAX
+#  endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#  define WCHAR_MIN  0
+#endif  // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  // WCHAR_MAX ]
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
+// Check out Issue 9 for the details.
+#ifndef INTMAX_C //   [
+#  define INTMAX_C   INT64_C
+#endif // INTMAX_C    ]
+#ifndef UINTMAX_C //  [
+#  define UINTMAX_C  UINT64_C
+#endif // UINTMAX_C   ]
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+#endif // _MSC_VER >= 1600 ]
+
+#endif // _MSC_STDINT_H_ ]
diff --git a/contrib/world_builder/include/rapidjson/mystwriter.h.bak b/contrib/world_builder/include/rapidjson/mystwriter.h.bak
new file mode 100644
index 00000000000..b684ddaf12b
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/mystwriter.h.bak
@@ -0,0 +1,528 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_MYSTWRITER_H_
+#define RAPIDJSON_MYSTWRITER_H_
+
+#include "writer.h"
+
+#include "assert.h"
+
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+#define MAX_PATH_LEVEL 25
+
+//! Writer with indentation and spacing.
+/*!
+    \tparam OutputStream Type of output os.
+    \tparam SourceEncoding Encoding of source string.
+    \tparam TargetEncoding Encoding of output stream.
+    \tparam StackAllocator Type of allocator for allocating memory of stack.
+*/
+template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
+class MySTWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags>
+{
+  public:
+    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base;
+    typedef typename Base::Ch Ch;
+
+    //! Constructor
+    /*! \param os Output stream.
+        \param allocator User supplied allocator. If it is null, it will create a private one.
+        \param levelDepth Initial capacity of stack.
+    */
+    explicit MySTWriter(OutputStream &os, bool _make_open = false, StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
+      Base(os, allocator, levelDepth)
+    {
+      make_open = _make_open;
+      level_type.resize(0);
+      array_number.resize(0);
+      path.resize(0);
+    }
+
+
+    explicit MySTWriter(StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
+      Base(allocator, levelDepth)
+    {
+      level_type.resize(0);
+      array_number.resize(0);
+      path.resize(0);
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    MySTWriter(MySTWriter &&rhs) :
+      Base(std::forward<MySTWriter>(rhs))
+    {
+      level_type.resize(0);
+      array_number.resize(0);
+      path.resize(0);
+    }
+#endif
+
+    /*! @name Implementation of Handler
+        \see Handler
+    */
+    //@{
+
+    bool Null()
+    {
+      return Base::EndValue(Base::WriteNull());
+    }
+    bool Bool(bool b)
+    {
+      Base::EndValue(Base::WriteBool(b));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Int(int i)
+    {
+      Base::EndValue(Base::WriteInt(i));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Uint(unsigned u)
+    {
+      Base::EndValue(Base::WriteUint(u));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Int64(int64_t i64)
+    {
+      Base::EndValue(Base::WriteInt64(i64));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Uint64(uint64_t u64)
+    {
+      Base::EndValue(Base::WriteUint64(u64));
+      Base::os_->Put('\n');
+      return true;
+    }
+    bool Double(double d)
+    {
+      Base::EndValue(Base::WriteDouble(d));
+      Base::os_->Put('\n');
+      return true;
+    }
+
+    bool RawNumber(const Ch *str, SizeType length, bool /*copy = false*/)
+    {
+      RAPIDJSON_ASSERT(str != 0);
+      Base::EndValue(Base::WriteString(str, length, false));
+      Base::os_->Put('\n');
+      return true;
+    }
+
+    bool String(const Ch *str, SizeType length, bool /*copy = false*/)
+    {
+      RAPIDJSON_ASSERT(str != 0);
+      if (small_array == true)
+        {
+          if (first_small_array == true)
+            first_small_array = false;
+          else
+            {
+              Base::os_->Put(',');
+              Base::os_->Put(' ');
+            }
+        }
+      Base::EndValue(Base::WriteString(str, length, false));
+
+      if (small_array == false)
+        Base::os_->Put('\n');
+      return true;
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool String(const std::basic_string<Ch> &str)
+    {
+      return String(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool StartObject()
+    {
+      bool wrote_dropdown = false;
+      std::string begin = "";
+      if (level_type.size() != 0 && level_type.back() == 1)
+        {
+          // this is a properties starting, so first clear all the itemize
+          // the lvel_type.push_back(1) has already been done by the key: properties
+
+          if (skip_next_push_back == false)
+            {
+              for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
+                {
+                  begin += ":";
+                }
+              begin += "{dropdown} " + get_path();
+
+              wrote_dropdown =  true;
+              level_type.push_back(0);
+            }
+          else
+            {
+              skip_next_push_back = false;
+            }
+        }
+      else if (level_type.size() != 0 && level_type.back() == 2)
+        {
+          unsigned int number = array_number.back() + 1;
+          array_number.back() = number;
+          path.push_back(std::to_string(array_number.back()));
+          level_type.push_back(0);
+
+          for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
+            {
+              begin += ":";
+            }
+          begin += "{dropdown} " + get_path();
+
+
+          wrote_dropdown =  true;
+        }
+      else if (level_type.size() != 0 && level_type.back() == 5)
+        {
+          unsigned int number = array_number.back() + 1;
+          array_number.back() = number;
+          path.push_back(std::to_string(array_number.back()));
+          level_type.push_back(0);
+
+          for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
+            {
+              begin += ":";
+            }
+          begin += "{dropdown} " + get_path();
+
+
+          wrote_dropdown =  true;
+        }
+      else
+        {
+          for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
+            {
+              begin += ":";
+            }
+          begin += "{dropdown} " + get_path();
+
+
+          wrote_dropdown =  true;
+          if (level_type.size() > 0 && (level_type.back() != 3 || level_type.size() == 0))
+            level_type.push_back(0);
+        }
+
+      Base::WriteString(begin.c_str(), static_cast<rapidjson::SizeType>(begin.size()), false);
+
+      Base::os_->Put('\n');
+      if (level_type.size() == 0 && !make_open)
+        {
+          std::string string_open = ":open:";
+          Base::WriteString(string_open.c_str(), static_cast<rapidjson::SizeType>(string_open.size()), false);
+          Base::os_->Put('\n');
+        }
+
+      if (wrote_dropdown)
+        {
+          if (make_open)
+            {
+              std::string open = ":open:";
+              Base::WriteString(open.c_str(), static_cast<rapidjson::SizeType>(open.size()), false);
+              Base::os_->Put('\n');
+              std::string name = ":name: open" + get_path_underscore() + "";
+              Base::WriteString(name.c_str(), static_cast<rapidjson::SizeType>(name.size()), false);
+              Base::os_->Put('\n');
+              Base::os_->Put('\n');
+            }
+          else
+            {
+              std::string name = ":name: closed" + get_path_underscore() + "";
+              Base::WriteString(name.c_str(), static_cast<rapidjson::SizeType>(name.size()), false);
+              Base::os_->Put('\n');
+              Base::os_->Put('\n');
+            }
+        }
+
+      return true;
+    }
+
+    bool Key(const Ch *str, SizeType /*length*/, bool /*copy = false*/)
+    {
+      std::string item = "";
+
+
+      std::string key(str);
+      if (key == "properties")
+        {
+          level_type.push_back(1);
+          skip_next_push_back = true;
+        }
+      else if (key == "oneOf")
+        {
+          level_type.push_back(2);
+          path.push_back(key);
+        }
+      else if (key == "items")
+        {
+          level_type.push_back(3);
+          path.push_back(key);
+        }
+      else if (key == "enum" || key == "required" )
+        {
+          level_type.push_back(4);
+          item += "- **" + std::string(str) + "**:";
+        }
+      else if (key == "anyOf")
+        {
+          level_type.push_back(5);
+          path.push_back(key);
+        }
+      else if (level_type.size() > 0 && (level_type.back() == 1 || level_type.back() == 2 || level_type.back() == 5))
+        {
+          // the level just below properties, these are the sections
+          // add to the path
+          path.push_back(key);
+        }
+      else
+        {
+          item += "- **" + std::string(str) + "**:";
+        }
+
+      Base::WriteString(item.c_str(), static_cast<rapidjson::SizeType>(item.length()), false);
+
+      return true;
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool Key(const std::basic_string<Ch> &str)
+    {
+      return Key(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool EndObject(SizeType /*memberCount = 0*/)
+    {
+      std::string end = "";
+
+      // If this assert fails it could be an indicator that
+      // the world builder library is not fuly linked to the
+      // appllication.
+
+      if (level_type.size() > 0 && path.size() > 0 &&
+          ( level_type.back() == 3 || level_type.back() == 0))
+        {
+
+          for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
+            {
+              WBAssert(path.size() < MAX_PATH_LEVEL, "EA: path size is larger than 90: " << path.size() << ", level = " << level);
+              end += ':';
+            }
+
+          path.pop_back();
+        }
+
+      if (level_type.size() > 0)
+        {
+          level_type.pop_back();
+        }
+
+      Base::WriteString(end.c_str(), static_cast<rapidjson::SizeType>(end.length()), false);
+
+      Base::os_->Put('\n');
+      Base::os_->Put('\n');
+      return true;
+    }
+
+    bool StartArray()
+    {
+      bool wrote_dropdown = false;
+      std::string begin = "";
+      if (level_type.size() != 0 && (level_type.back() == 2|| level_type.back() == 3|| level_type.back() == 5 ))
+        {
+          //begin += "level type" + std::to_string(level_type.back());
+          // this is a properties starting, so first clear all the itemize
+          // the lvel_type.push_back(1) has already been done by the key: properties
+
+          for (size_t level = MAX_PATH_LEVEL-path.size(); level != 0; level--)
+            {
+              WBAssert(path.size() < MAX_PATH_LEVEL, "SA: path size is larger than 90: " << path.size() << ", level = " << level);
+              begin += ":";
+            }
+          begin += "{dropdown} " + get_path();
+
+          wrote_dropdown = true;
+          array_number.push_back(0);
+        }
+      else
+        {
+          begin += "[";
+          small_array = true;
+          first_small_array = true;
+        }
+
+      Base::WriteString(begin.c_str(), static_cast<rapidjson::SizeType>(begin.size()), false);
+
+      if (small_array == false)
+        Base::os_->Put('\n');
+
+
+      if (wrote_dropdown)
+        {
+          if (make_open)
+            {
+              std::string open = ":open:";
+              Base::WriteString(open.c_str(), static_cast<rapidjson::SizeType>(open.size()), false);
+              Base::os_->Put('\n');
+              std::string name = ":name: open" + get_path_underscore() + "";
+              Base::WriteString(name.c_str(), static_cast<rapidjson::SizeType>(name.size()), false);
+              Base::os_->Put('\n');
+              Base::os_->Put('\n');
+            }
+          else
+            {
+              std::string name = ":name: closed" + get_path_underscore() + "";
+              Base::WriteString(name.c_str(), static_cast<rapidjson::SizeType>(name.size()), false);
+              Base::os_->Put('\n');
+              Base::os_->Put('\n');
+            }
+        }
+      return true;
+    }
+
+    bool EndArray(SizeType /*memberCount = 0*/)
+    {
+      std::string end = "";
+      if (level_type.size() != 0 && (level_type.back() == 1 || level_type.back() == 2 || level_type.back() == 3 || level_type.back() == 5))
+        {
+          array_number.pop_back();
+          level_type.pop_back();
+
+          if (path.size() > 0)
+            path.pop_back();
+        }
+      else
+        {
+
+          end = "]";
+
+          small_array = false;
+
+          if (level_type.size() > 0 && (level_type.back() == 4))// || level_type.back() == 0))
+            {
+              level_type.pop_back();
+            }
+        }
+
+      Base::WriteString(end.c_str(), static_cast<rapidjson::SizeType>(end.size()), false);
+
+      Base::os_->Put('\n');
+      return true;
+    }
+
+    //@}
+
+    /*! @name Convenience extensions */
+    //@{
+
+    //! Simpler but slower overload.
+    bool String(const Ch *str)
+    {
+      return String(str, internal::StrLen(str));
+    }
+    bool Key(const Ch *str)
+    {
+      return Key(str, internal::StrLen(str));
+    }
+
+    //@}
+
+    //! Write a raw JSON value.
+    /*!
+        For user to write a stringified JSON as a value.
+
+        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
+        \param length Length of the json.
+        \param type Type of the root of json.
+        \note When using MySTWriter::RawValue(), the result json may not be indented correctly.
+    */
+    bool RawValue(const Ch *json, size_t length, Type /*type*/)
+    {
+      RAPIDJSON_ASSERT(json != 0);
+      return Base::EndValue(Base::WriteRawValue(json, length));
+    }
+
+  protected:
+
+    std::string get_path()
+    {
+      std::string return_path;
+      for (auto string : path)
+        {
+          return_path += "/" + string;
+        }
+      return return_path == "" ? "/" : return_path;
+    }
+
+    std::string get_path_underscore()
+    {
+      std::string return_path;
+      for (auto string : path)
+        {
+          return_path += "_" + string;
+        }
+      const char space  = ' ';
+      const char dash = '-';
+      std::replace(return_path.begin(), return_path.end(), space, dash);
+      return return_path == "" ? "_" : return_path;
+    }
+
+    std::vector<unsigned int> level_type;
+    std::vector<unsigned int> array_number;
+    bool make_open = false;
+    bool skip_next_push_back = false;
+    bool small_array = false;
+    bool first_small_array = false;
+
+  private:
+    std::vector<std::string> path;
+    // Prohibit copy constructor & assignment operator.
+    MySTWriter(const MySTWriter &);
+    MySTWriter &operator=(const MySTWriter &);
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/rapidjson/ostreamwrapper.h.bak b/contrib/world_builder/include/rapidjson/ostreamwrapper.h.bak
new file mode 100644
index 00000000000..70cb06ba940
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/ostreamwrapper.h.bak
@@ -0,0 +1,104 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_OSTREAMWRAPPER_H_
+#define RAPIDJSON_OSTREAMWRAPPER_H_
+
+#include "stream.h"
+#include <iosfwd>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Wrapper of \c std::basic_ostream into RapidJSON's Stream concept.
+/*!
+    The classes can be wrapped including but not limited to:
+
+    - \c std::ostringstream
+    - \c std::stringstream
+    - \c std::wpstringstream
+    - \c std::wstringstream
+    - \c std::ifstream
+    - \c std::fstream
+    - \c std::wofstream
+    - \c std::wfstream
+
+    \tparam StreamType Class derived from \c std::basic_ostream.
+*/
+
+template <typename StreamType>
+class BasicOStreamWrapper
+{
+  public:
+    typedef typename StreamType::char_type Ch;
+    BasicOStreamWrapper(StreamType &stream) : stream_(stream) {}
+
+    void Put(Ch c)
+    {
+      stream_.put(c);
+    }
+
+    void Flush()
+    {
+      stream_.flush();
+    }
+
+    // Not implemented
+    char Peek() const
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    char Take()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t Tell() const
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    char *PutBegin()
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+    size_t PutEnd(char *)
+    {
+      RAPIDJSON_ASSERT(false);
+      return 0;
+    }
+
+  private:
+    BasicOStreamWrapper(const BasicOStreamWrapper &);
+    BasicOStreamWrapper &operator=(const BasicOStreamWrapper &);
+
+    StreamType &stream_;
+};
+
+typedef BasicOStreamWrapper<std::ostream> OStreamWrapper;
+typedef BasicOStreamWrapper<std::wostream> WOStreamWrapper;
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_OSTREAMWRAPPER_H_
diff --git a/contrib/world_builder/include/rapidjson/pointer.h.bak b/contrib/world_builder/include/rapidjson/pointer.h.bak
new file mode 100644
index 00000000000..f2dee09185e
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/pointer.h.bak
@@ -0,0 +1,1532 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_POINTER_H_
+#define RAPIDJSON_POINTER_H_
+
+#include "document.h"
+#include "internal/itoa.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+//RAPIDJSON_DIAG_OFF(switch -enum)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+static const SizeType kPointerInvalidIndex = ~SizeType(0);  //!< Represents an invalid index in GenericPointer::Token
+
+//! Error code of parsing.
+/*! \ingroup RAPIDJSON_ERRORS
+    \see GenericPointer::GenericPointer, GenericPointer::GetParseErrorCode
+*/
+enum PointerParseErrorCode
+{
+  kPointerParseErrorNone = 0,                     //!< The parse is successful
+
+  kPointerParseErrorTokenMustBeginWithSolidus,    //!< A token must begin with a '/'
+  kPointerParseErrorInvalidEscape,                //!< Invalid escape
+  kPointerParseErrorInvalidPercentEncoding,       //!< Invalid percent encoding in URI fragment
+  kPointerParseErrorCharacterMustPercentEncode    //!< A character must percent encoded in URI fragment
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericPointer
+
+//! Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
+/*!
+    This class implements RFC 6901 "JavaScript Object Notation (JSON) Pointer"
+    (https://tools.ietf.org/html/rfc6901).
+
+    A JSON pointer is for identifying a specific value in a JSON document
+    (GenericDocument). It can simplify coding of DOM tree manipulation, because it
+    can access multiple-level depth of DOM tree with single API call.
+
+    After it parses a string representation (e.g. "/foo/0" or URI fragment
+    representation (e.g. "#/foo/0") into its internal representation (tokens),
+    it can be used to resolve a specific value in multiple documents, or sub-tree
+    of documents.
+
+    Contrary to GenericValue, Pointer can be copy constructed and copy assigned.
+    Apart from assignment, a Pointer cannot be modified after construction.
+
+    Although Pointer is very convenient, please aware that constructing Pointer
+    involves parsing and dynamic memory allocation. A special constructor with user-
+    supplied tokens eliminates these.
+
+    GenericPointer depends on GenericDocument and GenericValue.
+
+    \tparam ValueType The value type of the DOM tree. E.g. GenericValue<UTF8<> >
+    \tparam Allocator The allocator type for allocating memory for internal representation.
+
+    \note GenericPointer uses same encoding of ValueType.
+    However, Allocator of GenericPointer is independent of Allocator of Value.
+*/
+template <typename ValueType, typename Allocator = CrtAllocator>
+class GenericPointer
+{
+  public:
+    typedef typename ValueType::EncodingType EncodingType;  //!< Encoding type from Value
+    typedef typename ValueType::Ch Ch;                      //!< Character type from Value
+
+    //! A token is the basic units of internal representation.
+    /*!
+        A JSON pointer string representation "/foo/123" is parsed to two tokens:
+        "foo" and 123. 123 will be represented in both numeric form and string form.
+        They are resolved according to the actual value type (object or array).
+
+        For token that are not numbers, or the numeric value is out of bound
+        (greater than limits of SizeType), they are only treated as string form
+        (i.e. the token's index will be equal to kPointerInvalidIndex).
+
+        This struct is public so that user can create a Pointer without parsing and
+        allocation, using a special constructor.
+    */
+    struct Token
+    {
+      const Ch *name;             //!< Name of the token. It has null character at the end but it can contain null character.
+      SizeType length;            //!< Length of the name.
+      SizeType index;             //!< A valid array index, if it is not equal to kPointerInvalidIndex.
+    };
+
+    //!@name Constructors and destructor.
+    //@{
+
+    //! Default constructor.
+    GenericPointer(Allocator *allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
+
+    //! Constructor that parses a string or URI fragment representation.
+    /*!
+        \param source A null-terminated, string or URI fragment representation of JSON pointer.
+        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
+    */
+    explicit GenericPointer(const Ch *source, Allocator *allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
+    {
+      Parse(source, internal::StrLen(source));
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Constructor that parses a string or URI fragment representation.
+    /*!
+        \param source A string or URI fragment representation of JSON pointer.
+        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
+        \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
+    */
+    explicit GenericPointer(const std::basic_string<Ch> &source, Allocator *allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
+    {
+      Parse(source.c_str(), source.size());
+    }
+#endif
+
+    //! Constructor that parses a string or URI fragment representation, with length of the source string.
+    /*!
+        \param source A string or URI fragment representation of JSON pointer.
+        \param length Length of source.
+        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
+        \note Slightly faster than the overload without length.
+    */
+    GenericPointer(const Ch *source, size_t length, Allocator *allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
+    {
+      Parse(source, length);
+    }
+
+    //! Constructor with user-supplied tokens.
+    /*!
+        This constructor let user supplies const array of tokens.
+        This prevents the parsing process and eliminates allocation.
+        This is preferred for memory constrained environments.
+
+        \param tokens An constant array of tokens representing the JSON pointer.
+        \param tokenCount Number of tokens.
+
+        \b Example
+        \code
+        #define NAME(s) { s, sizeof(s) / sizeof(s[0]) - 1, kPointerInvalidIndex }
+        #define INDEX(i) { #i, sizeof(#i) - 1, i }
+
+        static const Pointer::Token kTokens[] = { NAME("foo"), INDEX(123) };
+        static const Pointer p(kTokens, sizeof(kTokens) / sizeof(kTokens[0]));
+        // Equivalent to static const Pointer p("/foo/123");
+
+        #undef NAME
+        #undef INDEX
+        \endcode
+    */
+    GenericPointer(const Token *tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token *>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
+
+    //! Copy constructor.
+    GenericPointer(const GenericPointer &rhs) : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
+    {
+      *this = rhs;
+    }
+
+    //! Copy constructor.
+    GenericPointer(const GenericPointer &rhs, Allocator *allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
+    {
+      *this = rhs;
+    }
+
+    //! Destructor.
+    ~GenericPointer()
+    {
+      if (nameBuffer_)    // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated.
+        Allocator::Free(tokens_);
+      RAPIDJSON_DELETE(ownAllocator_);
+    }
+
+    //! Assignment operator.
+    GenericPointer &operator=(const GenericPointer &rhs)
+    {
+      if (this != &rhs)
+        {
+          // Do not delete ownAllcator
+          if (nameBuffer_)
+            Allocator::Free(tokens_);
+
+          tokenCount_ = rhs.tokenCount_;
+          parseErrorOffset_ = rhs.parseErrorOffset_;
+          parseErrorCode_ = rhs.parseErrorCode_;
+
+          if (rhs.nameBuffer_)
+            CopyFromRaw(rhs); // Normally parsed tokens.
+          else
+            {
+              tokens_ = rhs.tokens_; // User supplied const tokens.
+              nameBuffer_ = 0;
+            }
+        }
+      return *this;
+    }
+
+    //@}
+
+    //!@name Append token
+    //@{
+
+    //! Append a token and return a new Pointer
+    /*!
+        \param token Token to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const Token &token, Allocator *allocator = 0) const
+    {
+      GenericPointer r;
+      r.allocator_ = allocator;
+      Ch *p = r.CopyFromRaw(*this, 1, token.length + 1);
+      std::memcpy(p, token.name, (token.length + 1) * sizeof(Ch));
+      r.tokens_[tokenCount_].name = p;
+      r.tokens_[tokenCount_].length = token.length;
+      r.tokens_[tokenCount_].index = token.index;
+      return r;
+    }
+
+    //! Append a name token with length, and return a new Pointer
+    /*!
+        \param name Name to be appended.
+        \param length Length of name.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const Ch *name, SizeType length, Allocator *allocator = 0) const
+    {
+      Token token = { name, length, kPointerInvalidIndex };
+      return Append(token, allocator);
+    }
+
+    //! Append a name token without length, and return a new Pointer
+    /*!
+        \param name Name (const Ch*) to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >), (GenericPointer))
+    Append(T *name, Allocator *allocator = 0) const
+    {
+      return Append(name, internal::StrLen(name), allocator);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Append a name token, and return a new Pointer
+    /*!
+        \param name Name to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const std::basic_string<Ch> &name, Allocator *allocator = 0) const
+    {
+      return Append(name.c_str(), static_cast<SizeType>(name.size()), allocator);
+    }
+#endif
+
+    //! Append a index token, and return a new Pointer
+    /*!
+        \param index Index to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(SizeType index, Allocator *allocator = 0) const
+    {
+      char buffer[21];
+      char *end = sizeof(SizeType) == 4 ? internal::u32toa(index, buffer) : internal::u64toa(index, buffer);
+      SizeType length = static_cast<SizeType>(end - buffer);
+      buffer[length] = '\0';
+
+      if (sizeof(Ch) == 1)
+        {
+          Token token = { reinterpret_cast<Ch *>(buffer), length, index };
+          return Append(token, allocator);
+        }
+      else
+        {
+          Ch name[21];
+          for (size_t i = 0; i <= length; i++)
+            name[i] = static_cast<Ch>(buffer[i]);
+          Token token = { name, length, index };
+          return Append(token, allocator);
+        }
+    }
+
+    //! Append a token by value, and return a new Pointer
+    /*!
+        \param token token to be appended.
+        \param allocator Allocator for the newly return Pointer.
+        \return A new Pointer with appended token.
+    */
+    GenericPointer Append(const ValueType &token, Allocator *allocator = 0) const
+    {
+      if (token.IsString())
+        return Append(token.GetString(), token.GetStringLength(), allocator);
+      else
+        {
+          RAPIDJSON_ASSERT(token.IsUint64());
+          RAPIDJSON_ASSERT(token.GetUint64() <= SizeType(~0));
+          return Append(static_cast<SizeType>(token.GetUint64()), allocator);
+        }
+    }
+
+    //!@name Handling Parse Error
+    //@{
+
+    //! Check whether this is a valid pointer.
+    bool IsValid() const
+    {
+      return parseErrorCode_ == kPointerParseErrorNone;
+    }
+
+    //! Get the parsing error offset in code unit.
+    size_t GetParseErrorOffset() const
+    {
+      return parseErrorOffset_;
+    }
+
+    //! Get the parsing error code.
+    PointerParseErrorCode GetParseErrorCode() const
+    {
+      return parseErrorCode_;
+    }
+
+    //@}
+
+    //! Get the allocator of this pointer.
+    Allocator &GetAllocator()
+    {
+      return *allocator_;
+    }
+
+    //!@name Tokens
+    //@{
+
+    //! Get the token array (const version only).
+    const Token *GetTokens() const
+    {
+      return tokens_;
+    }
+
+    //! Get the number of tokens.
+    size_t GetTokenCount() const
+    {
+      return tokenCount_;
+    }
+
+    //@}
+
+    //!@name Equality/inequality operators
+    //@{
+
+    //! Equality operator.
+    /*!
+        \note When any pointers are invalid, always returns false.
+    */
+    bool operator==(const GenericPointer &rhs) const
+    {
+      if (!IsValid() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_)
+        return false;
+
+      for (size_t i = 0; i < tokenCount_; i++)
+        {
+          if (tokens_[i].index != rhs.tokens_[i].index ||
+              tokens_[i].length != rhs.tokens_[i].length ||
+              (tokens_[i].length != 0 && std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch)* tokens_[i].length) != 0))
+            {
+              return false;
+            }
+        }
+
+      return true;
+    }
+
+    //! Inequality operator.
+    /*!
+        \note When any pointers are invalid, always returns true.
+    */
+    bool operator!=(const GenericPointer &rhs) const
+    {
+      return !(*this == rhs);
+    }
+
+    //@}
+
+    //!@name Stringify
+    //@{
+
+    //! Stringify the pointer into string representation.
+    /*!
+        \tparam OutputStream Type of output stream.
+        \param os The output stream.
+    */
+    template<typename OutputStream>
+    bool Stringify(OutputStream &os) const
+    {
+      return Stringify<false, OutputStream>(os);
+    }
+
+    //! Stringify the pointer into URI fragment representation.
+    /*!
+        \tparam OutputStream Type of output stream.
+        \param os The output stream.
+    */
+    template<typename OutputStream>
+    bool StringifyUriFragment(OutputStream &os) const
+    {
+      return Stringify<true, OutputStream>(os);
+    }
+
+    //@}
+
+    //!@name Create value
+    //@{
+
+    //! Create a value in a subtree.
+    /*!
+        If the value is not exist, it creates all parent values and a JSON Null value.
+        So it always succeed and return the newly created or existing value.
+
+        Remind that it may change types of parents according to tokens, so it
+        potentially removes previously stored values. For example, if a document
+        was an array, and "/foo" is used to create a value, then the document
+        will be changed to an object, and all existing array elements are lost.
+
+        \param root Root value of a DOM subtree to be resolved. It can be any value other than document root.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
+        \return The resolved newly created (a JSON Null value), or already exists value.
+    */
+    ValueType &Create(ValueType &root, typename ValueType::AllocatorType &allocator, bool *alreadyExist = 0) const
+    {
+      RAPIDJSON_ASSERT(IsValid());
+      ValueType *v = &root;
+      bool exist = true;
+      for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t)
+        {
+          if (v->IsArray() && t->name[0] == '-' && t->length == 1)
+            {
+              v->PushBack(ValueType().Move(), allocator);
+              v = &((*v)[v->Size() - 1]);
+              exist = false;
+            }
+          else
+            {
+              if (t->index == kPointerInvalidIndex)   // must be object name
+                {
+                  if (!v->IsObject())
+                    v->SetObject(); // Change to Object
+                }
+              else   // object name or array index
+                {
+                  if (!v->IsArray() && !v->IsObject())
+                    v->SetArray(); // Change to Array
+                }
+
+              if (v->IsArray())
+                {
+                  if (t->index >= v->Size())
+                    {
+                      v->Reserve(t->index + 1, allocator);
+                      while (t->index >= v->Size())
+                        v->PushBack(ValueType().Move(), allocator);
+                      exist = false;
+                    }
+                  v = &((*v)[t->index]);
+                }
+              else
+                {
+                  typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                  if (m == v->MemberEnd())
+                    {
+                      v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator);
+                      v = &(--v->MemberEnd())->value; // Assumes AddMember() appends at the end
+                      exist = false;
+                    }
+                  else
+                    v = &m->value;
+                }
+            }
+        }
+
+      if (alreadyExist)
+        *alreadyExist = exist;
+
+      return *v;
+    }
+
+    //! Creates a value in a document.
+    /*!
+        \param document A document to be resolved.
+        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
+        \return The resolved newly created, or already exists value.
+    */
+    template <typename stackAllocator>
+    ValueType &Create(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, bool *alreadyExist = 0) const
+    {
+      return Create(document, document.GetAllocator(), alreadyExist);
+    }
+
+    //@}
+
+    //!@name Query value
+    //@{
+
+    //! Query a value in a subtree.
+    /*!
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param unresolvedTokenIndex If the pointer cannot resolve a token in the pointer, this parameter can obtain the index of unresolved token.
+        \return Pointer to the value if it can be resolved. Otherwise null.
+
+        \note
+        There are only 3 situations when a value cannot be resolved:
+        1. A value in the path is not an array nor object.
+        2. An object value does not contain the token.
+        3. A token is out of range of an array value.
+
+        Use unresolvedTokenIndex to retrieve the token index.
+    */
+    ValueType *Get(ValueType &root, size_t *unresolvedTokenIndex = 0) const
+    {
+      RAPIDJSON_ASSERT(IsValid());
+      ValueType *v = &root;
+      for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t)
+        {
+          switch (v->GetType())
+            {
+              case kObjectType:
+              {
+                typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                if (m == v->MemberEnd())
+                  break;
+                v = &m->value;
+              }
+              continue;
+              case kArrayType:
+                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
+                  break;
+                v = &((*v)[t->index]);
+                continue;
+              default:
+                break;
+            }
+
+          // Error: unresolved token
+          if (unresolvedTokenIndex)
+            *unresolvedTokenIndex = static_cast<size_t>(t - tokens_);
+          return 0;
+        }
+      return v;
+    }
+
+    //! Query a const value in a const subtree.
+    /*!
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \return Pointer to the value if it can be resolved. Otherwise null.
+    */
+    const ValueType *Get(const ValueType &root, size_t *unresolvedTokenIndex = 0) const
+    {
+      return Get(const_cast<ValueType &>(root), unresolvedTokenIndex);
+    }
+
+    //@}
+
+    //!@name Query a value with default
+    //@{
+
+    //! Query a value in a subtree with default value.
+    /*!
+        Similar to Get(), but if the specified value do not exists, it creates all parents and clone the default value.
+        So that this function always succeed.
+
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param defaultValue Default value to be cloned if the value was not exists.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \see Create()
+    */
+    ValueType &GetWithDefault(ValueType &root, const ValueType &defaultValue, typename ValueType::AllocatorType &allocator) const
+    {
+      bool alreadyExist;
+      ValueType &v = Create(root, allocator, &alreadyExist);
+      return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
+    }
+
+    //! Query a value in a subtree with default null-terminated string.
+    ValueType &GetWithDefault(ValueType &root, const Ch *defaultValue, typename ValueType::AllocatorType &allocator) const
+    {
+      bool alreadyExist;
+      ValueType &v = Create(root, allocator, &alreadyExist);
+      return alreadyExist ? v : v.SetString(defaultValue, allocator);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Query a value in a subtree with default std::basic_string.
+    ValueType &GetWithDefault(ValueType &root, const std::basic_string<Ch> &defaultValue, typename ValueType::AllocatorType &allocator) const
+    {
+      bool alreadyExist;
+      ValueType &v = Create(root, allocator, &alreadyExist);
+      return alreadyExist ? v : v.SetString(defaultValue, allocator);
+    }
+#endif
+
+    //! Query a value in a subtree with default primitive value.
+    /*!
+        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType &))
+    GetWithDefault(ValueType &root, T defaultValue, typename ValueType::AllocatorType &allocator) const
+    {
+      return GetWithDefault(root, ValueType(defaultValue).Move(), allocator);
+    }
+
+    //! Query a value in a document with default value.
+    template <typename stackAllocator>
+    ValueType &GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const ValueType &defaultValue) const
+    {
+      return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+
+    //! Query a value in a document with default null-terminated string.
+    template <typename stackAllocator>
+    ValueType &GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const Ch *defaultValue) const
+    {
+      return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Query a value in a document with default std::basic_string.
+    template <typename stackAllocator>
+    ValueType &GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const std::basic_string<Ch> &defaultValue) const
+    {
+      return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+#endif
+
+    //! Query a value in a document with default primitive value.
+    /*!
+        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T, typename stackAllocator>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType &))
+    GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, T defaultValue) const
+    {
+      return GetWithDefault(document, defaultValue, document.GetAllocator());
+    }
+
+    //@}
+
+    //!@name Set a value
+    //@{
+
+    //! Set a value in a subtree, with move semantics.
+    /*!
+        It creates all parents if they are not exist or types are different to the tokens.
+        So this function always succeeds but potentially remove existing values.
+
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param value Value to be set.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \see Create()
+    */
+    ValueType &Set(ValueType &root, ValueType &value, typename ValueType::AllocatorType &allocator) const
+    {
+      return Create(root, allocator) = value;
+    }
+
+    //! Set a value in a subtree, with copy semantics.
+    ValueType &Set(ValueType &root, const ValueType &value, typename ValueType::AllocatorType &allocator) const
+    {
+      return Create(root, allocator).CopyFrom(value, allocator);
+    }
+
+    //! Set a null-terminated string in a subtree.
+    ValueType &Set(ValueType &root, const Ch *value, typename ValueType::AllocatorType &allocator) const
+    {
+      return Create(root, allocator) = ValueType(value, allocator).Move();
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Set a std::basic_string in a subtree.
+    ValueType &Set(ValueType &root, const std::basic_string<Ch> &value, typename ValueType::AllocatorType &allocator) const
+    {
+      return Create(root, allocator) = ValueType(value, allocator).Move();
+    }
+#endif
+
+    //! Set a primitive value in a subtree.
+    /*!
+        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType &))
+    Set(ValueType &root, T value, typename ValueType::AllocatorType &allocator) const
+    {
+      return Create(root, allocator) = ValueType(value).Move();
+    }
+
+    //! Set a value in a document, with move semantics.
+    template <typename stackAllocator>
+    ValueType &Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, ValueType &value) const
+    {
+      return Create(document) = value;
+    }
+
+    //! Set a value in a document, with copy semantics.
+    template <typename stackAllocator>
+    ValueType &Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const ValueType &value) const
+    {
+      return Create(document).CopyFrom(value, document.GetAllocator());
+    }
+
+    //! Set a null-terminated string in a document.
+    template <typename stackAllocator>
+    ValueType &Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const Ch *value) const
+    {
+      return Create(document) = ValueType(value, document.GetAllocator()).Move();
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    //! Sets a std::basic_string in a document.
+    template <typename stackAllocator>
+    ValueType &Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const std::basic_string<Ch> &value) const
+    {
+      return Create(document) = ValueType(value, document.GetAllocator()).Move();
+    }
+#endif
+
+    //! Set a primitive value in a document.
+    /*!
+    \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
+    */
+    template <typename T, typename stackAllocator>
+    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType &))
+    Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, T value) const
+    {
+      return Create(document) = value;
+    }
+
+    //@}
+
+    //!@name Swap a value
+    //@{
+
+    //! Swap a value with a value in a subtree.
+    /*!
+        It creates all parents if they are not exist or types are different to the tokens.
+        So this function always succeeds but potentially remove existing values.
+
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \param value Value to be swapped.
+        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
+        \see Create()
+    */
+    ValueType &Swap(ValueType &root, ValueType &value, typename ValueType::AllocatorType &allocator) const
+    {
+      return Create(root, allocator).Swap(value);
+    }
+
+    //! Swap a value with a value in a document.
+    template <typename stackAllocator>
+    ValueType &Swap(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, ValueType &value) const
+    {
+      return Create(document).Swap(value);
+    }
+
+    //@}
+
+    //! Erase a value in a subtree.
+    /*!
+        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
+        \return Whether the resolved value is found and erased.
+
+        \note Erasing with an empty pointer \c Pointer(""), i.e. the root, always fail and return false.
+    */
+    bool Erase(ValueType &root) const
+    {
+      RAPIDJSON_ASSERT(IsValid());
+      if (tokenCount_ == 0) // Cannot erase the root
+        return false;
+
+      ValueType *v = &root;
+      const Token *last = tokens_ + (tokenCount_ - 1);
+      for (const Token *t = tokens_; t != last; ++t)
+        {
+          switch (v->GetType())
+            {
+              case kObjectType:
+              {
+                typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
+                if (m == v->MemberEnd())
+                  return false;
+                v = &m->value;
+              }
+              break;
+              case kArrayType:
+                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
+                  return false;
+                v = &((*v)[t->index]);
+                break;
+              default:
+                return false;
+            }
+        }
+
+      switch (v->GetType())
+        {
+          case kObjectType:
+            return v->EraseMember(GenericStringRef<Ch>(last->name, last->length));
+          case kArrayType:
+            if (last->index == kPointerInvalidIndex || last->index >= v->Size())
+              return false;
+            v->Erase(v->Begin() + last->index);
+            return true;
+          default:
+            return false;
+        }
+    }
+
+  private:
+    //! Clone the content from rhs to this.
+    /*!
+        \param rhs Source pointer.
+        \param extraToken Extra tokens to be allocated.
+        \param extraNameBufferSize Extra name buffer size (in number of Ch) to be allocated.
+        \return Start of non-occupied name buffer, for storing extra names.
+    */
+    Ch *CopyFromRaw(const GenericPointer &rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0)
+    {
+      if (!allocator_) // allocator is independently owned.
+        ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
+
+      size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens
+      for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t)
+        nameBufferSize += t->length;
+
+      tokenCount_ = rhs.tokenCount_ + extraToken;
+      tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + (nameBufferSize + extraNameBufferSize) * sizeof(Ch)));
+      nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
+      if (rhs.tokenCount_ > 0)
+        {
+          std::memcpy(tokens_, rhs.tokens_, rhs.tokenCount_ * sizeof(Token));
+        }
+      if (nameBufferSize > 0)
+        {
+          std::memcpy(nameBuffer_, rhs.nameBuffer_, nameBufferSize * sizeof(Ch));
+        }
+
+      // Adjust pointers to name buffer
+      std::ptrdiff_t diff = nameBuffer_ - rhs.nameBuffer_;
+      for (Token *t = tokens_; t != tokens_ + rhs.tokenCount_; ++t)
+        t->name += diff;
+
+      return nameBuffer_ + nameBufferSize;
+    }
+
+    //! Check whether a character should be percent-encoded.
+    /*!
+        According to RFC 3986 2.3 Unreserved Characters.
+        \param c The character (code unit) to be tested.
+    */
+    bool NeedPercentEncode(Ch c) const
+    {
+      return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~');
+    }
+
+    //! Parse a JSON String or its URI fragment representation into tokens.
+#ifndef __clang__ // -Wdocumentation
+    /*!
+        \param source Either a JSON Pointer string, or its URI fragment representation. Not need to be null terminated.
+        \param length Length of the source string.
+        \note Source cannot be JSON String Representation of JSON Pointer, e.g. In "/\u0000", \u0000 will not be unescaped.
+    */
+#endif
+    void Parse(const Ch *source, size_t length)
+    {
+      RAPIDJSON_ASSERT(source != NULL);
+      RAPIDJSON_ASSERT(nameBuffer_ == 0);
+      RAPIDJSON_ASSERT(tokens_ == 0);
+
+      // Create own allocator if user did not supply.
+      if (!allocator_)
+        ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
+
+      // Count number of '/' as tokenCount
+      tokenCount_ = 0;
+      for (const Ch *s = source; s != source + length; s++)
+        if (*s == '/')
+          tokenCount_++;
+
+      Token *token = tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + length * sizeof(Ch)));
+      Ch *name = nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
+      size_t i = 0;
+
+      // Detect if it is a URI fragment
+      bool uriFragment = false;
+      if (source[i] == '#')
+        {
+          uriFragment = true;
+          i++;
+        }
+
+      if (i != length && source[i] != '/')
+        {
+          parseErrorCode_ = kPointerParseErrorTokenMustBeginWithSolidus;
+          goto error;
+        }
+
+      while (i < length)
+        {
+          RAPIDJSON_ASSERT(source[i] == '/');
+          i++; // consumes '/'
+
+          token->name = name;
+          bool isNumber = true;
+
+          while (i < length && source[i] != '/')
+            {
+              Ch c = source[i];
+              if (uriFragment)
+                {
+                  // Decoding percent-encoding for URI fragment
+                  if (c == '%')
+                    {
+                      PercentDecodeStream is(&source[i], source + length);
+                      GenericInsituStringStream<EncodingType> os(name);
+                      Ch *begin = os.PutBegin();
+                      if (!Transcoder<UTF8<>, EncodingType>().Validate(is, os) || !is.IsValid())
+                        {
+                          parseErrorCode_ = kPointerParseErrorInvalidPercentEncoding;
+                          goto error;
+                        }
+                      size_t len = os.PutEnd(begin);
+                      i += is.Tell() - 1;
+                      if (len == 1)
+                        c = *name;
+                      else
+                        {
+                          name += len;
+                          isNumber = false;
+                          i++;
+                          continue;
+                        }
+                    }
+                  else if (NeedPercentEncode(c))
+                    {
+                      parseErrorCode_ = kPointerParseErrorCharacterMustPercentEncode;
+                      goto error;
+                    }
+                }
+
+              i++;
+
+              // Escaping "~0" -> '~', "~1" -> '/'
+              if (c == '~')
+                {
+                  if (i < length)
+                    {
+                      c = source[i];
+                      if (c == '0')       c = '~';
+                      else if (c == '1')  c = '/';
+                      else
+                        {
+                          parseErrorCode_ = kPointerParseErrorInvalidEscape;
+                          goto error;
+                        }
+                      i++;
+                    }
+                  else
+                    {
+                      parseErrorCode_ = kPointerParseErrorInvalidEscape;
+                      goto error;
+                    }
+                }
+
+              // First check for index: all of characters are digit
+              if (c < '0' || c > '9')
+                isNumber = false;
+
+              *name++ = c;
+            }
+          token->length = static_cast<SizeType>(name - token->name);
+          if (token->length == 0)
+            isNumber = false;
+          *name++ = '\0'; // Null terminator
+
+          // Second check for index: more than one digit cannot have leading zero
+          if (isNumber && token->length > 1 && token->name[0] == '0')
+            isNumber = false;
+
+          // String to SizeType conversion
+          SizeType n = 0;
+          if (isNumber)
+            {
+              for (size_t j = 0; j < token->length; j++)
+                {
+                  SizeType m = n * 10 + static_cast<SizeType>(token->name[j] - '0');
+                  if (m < n)     // overflow detection
+                    {
+                      isNumber = false;
+                      break;
+                    }
+                  n = m;
+                }
+            }
+
+          token->index = isNumber ? n : kPointerInvalidIndex;
+          token++;
+        }
+
+      RAPIDJSON_ASSERT(name <= nameBuffer_ + length); // Should not overflow buffer
+      parseErrorCode_ = kPointerParseErrorNone;
+      return;
+
+    error:
+      Allocator::Free(tokens_);
+      nameBuffer_ = 0;
+      tokens_ = 0;
+      tokenCount_ = 0;
+      parseErrorOffset_ = i;
+      return;
+    }
+
+    //! Stringify to string or URI fragment representation.
+    /*!
+        \tparam uriFragment True for stringifying to URI fragment representation. False for string representation.
+        \tparam OutputStream type of output stream.
+        \param os The output stream.
+    */
+    template<bool uriFragment, typename OutputStream>
+    bool Stringify(OutputStream &os) const
+    {
+      RAPIDJSON_ASSERT(IsValid());
+
+      if (uriFragment)
+        os.Put('#');
+
+      for (Token *t = tokens_; t != tokens_ + tokenCount_; ++t)
+        {
+          os.Put('/');
+          for (size_t j = 0; j < t->length; j++)
+            {
+              Ch c = t->name[j];
+              if (c == '~')
+                {
+                  os.Put('~');
+                  os.Put('0');
+                }
+              else if (c == '/')
+                {
+                  os.Put('~');
+                  os.Put('1');
+                }
+              else if (uriFragment && NeedPercentEncode(c))
+                {
+                  // Transcode to UTF8 sequence
+                  GenericStringStream<typename ValueType::EncodingType> source(&t->name[j]);
+                  PercentEncodeStream<OutputStream> target(os);
+                  if (!Transcoder<EncodingType, UTF8<> >().Validate(source, target))
+                    return false;
+                  j += source.Tell() - 1;
+                }
+              else
+                os.Put(c);
+            }
+        }
+      return true;
+    }
+
+    //! A helper stream for decoding a percent-encoded sequence into code unit.
+    /*!
+        This stream decodes %XY triplet into code unit (0-255).
+        If it encounters invalid characters, it sets output code unit as 0 and
+        mark invalid, and to be checked by IsValid().
+    */
+    class PercentDecodeStream
+    {
+      public:
+        typedef typename ValueType::Ch Ch;
+
+        //! Constructor
+        /*!
+            \param source Start of the stream
+            \param end Past-the-end of the stream.
+        */
+        PercentDecodeStream(const Ch *source, const Ch *end) : src_(source), head_(source), end_(end), valid_(true) {}
+
+        Ch Take()
+        {
+          if (*src_ != '%' || src_ + 3 > end_)   // %XY triplet
+            {
+              valid_ = false;
+              return 0;
+            }
+          src_++;
+          Ch c = 0;
+          for (int j = 0; j < 2; j++)
+            {
+              c = static_cast<Ch>(c << 4);
+              Ch h = *src_;
+              if      (h >= '0' && h <= '9') c = static_cast<Ch>(c + h - '0');
+              else if (h >= 'A' && h <= 'F') c = static_cast<Ch>(c + h - 'A' + 10);
+              else if (h >= 'a' && h <= 'f') c = static_cast<Ch>(c + h - 'a' + 10);
+              else
+                {
+                  valid_ = false;
+                  return 0;
+                }
+              src_++;
+            }
+          return c;
+        }
+
+        size_t Tell() const
+        {
+          return static_cast<size_t>(src_ - head_);
+        }
+        bool IsValid() const
+        {
+          return valid_;
+        }
+
+      private:
+        const Ch *src_;     //!< Current read position.
+        const Ch *head_;    //!< Original head of the string.
+        const Ch *end_;     //!< Past-the-end position.
+        bool valid_;        //!< Whether the parsing is valid.
+    };
+
+    //! A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence.
+    template <typename OutputStream>
+    class PercentEncodeStream
+    {
+      public:
+        PercentEncodeStream(OutputStream &os) : os_(os) {}
+        void Put(char c)   // UTF-8 must be byte
+        {
+          unsigned char u = static_cast<unsigned char>(c);
+          static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+          os_.Put('%');
+          os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u >> 4]));
+          os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u & 15]));
+        }
+      private:
+        OutputStream &os_;
+    };
+
+    Allocator *allocator_;                  //!< The current allocator. It is either user-supplied or equal to ownAllocator_.
+    Allocator *ownAllocator_;               //!< Allocator owned by this Pointer.
+    Ch *nameBuffer_;                        //!< A buffer containing all names in tokens.
+    Token *tokens_;                         //!< A list of tokens.
+    size_t tokenCount_;                     //!< Number of tokens in tokens_.
+    size_t parseErrorOffset_;               //!< Offset in code unit when parsing fail.
+    PointerParseErrorCode parseErrorCode_;  //!< Parsing error code.
+};
+
+//! GenericPointer for Value (UTF-8, default allocator).
+typedef GenericPointer<Value> Pointer;
+
+//!@name Helper functions for GenericPointer
+//@{
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType &CreateValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, typename T::AllocatorType &a)
+{
+  return pointer.Create(root, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType &CreateValueByPointer(T &root, const CharType(&source)[N], typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Create(root, a);
+}
+
+// No allocator parameter
+
+template <typename DocumentType>
+typename DocumentType::ValueType &CreateValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer)
+{
+  return pointer.Create(document);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType &CreateValueByPointer(DocumentType &document, const CharType(&source)[N])
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Create(document);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType *GetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, size_t *unresolvedTokenIndex = 0)
+{
+  return pointer.Get(root, unresolvedTokenIndex);
+}
+
+template <typename T>
+const typename T::ValueType *GetValueByPointer(const T &root, const GenericPointer<typename T::ValueType> &pointer, size_t *unresolvedTokenIndex = 0)
+{
+  return pointer.Get(root, unresolvedTokenIndex);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType *GetValueByPointer(T &root, const CharType (&source)[N], size_t *unresolvedTokenIndex = 0)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
+}
+
+template <typename T, typename CharType, size_t N>
+const typename T::ValueType *GetValueByPointer(const T &root, const CharType(&source)[N], size_t *unresolvedTokenIndex = 0)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType &GetValueByPointerWithDefault(T &root, const GenericPointer<typename T::ValueType> &pointer, const typename T::ValueType &defaultValue, typename T::AllocatorType &a)
+{
+  return pointer.GetWithDefault(root, defaultValue, a);
+}
+
+template <typename T>
+typename T::ValueType &GetValueByPointerWithDefault(T &root, const GenericPointer<typename T::ValueType> &pointer, const typename T::Ch *defaultValue, typename T::AllocatorType &a)
+{
+  return pointer.GetWithDefault(root, defaultValue, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T>
+typename T::ValueType &GetValueByPointerWithDefault(T &root, const GenericPointer<typename T::ValueType> &pointer, const std::basic_string<typename T::Ch> &defaultValue, typename T::AllocatorType &a)
+{
+  return pointer.GetWithDefault(root, defaultValue, a);
+}
+#endif
+
+template <typename T, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType &))
+GetValueByPointerWithDefault(T &root, const GenericPointer<typename T::ValueType> &pointer, T2 defaultValue, typename T::AllocatorType &a)
+{
+  return pointer.GetWithDefault(root, defaultValue, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType &GetValueByPointerWithDefault(T &root, const CharType(&source)[N], const typename T::ValueType &defaultValue, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType &GetValueByPointerWithDefault(T &root, const CharType(&source)[N], const typename T::Ch *defaultValue, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T, typename CharType, size_t N>
+typename T::ValueType &GetValueByPointerWithDefault(T &root, const CharType(&source)[N], const std::basic_string<typename T::Ch> &defaultValue, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+#endif
+
+template <typename T, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType &))
+GetValueByPointerWithDefault(T &root, const CharType(&source)[N], T2 defaultValue, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
+}
+
+// No allocator parameter
+
+template <typename DocumentType>
+typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const typename DocumentType::ValueType &defaultValue)
+{
+  return pointer.GetWithDefault(document, defaultValue);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const typename DocumentType::Ch *defaultValue)
+{
+  return pointer.GetWithDefault(document, defaultValue);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType>
+typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const std::basic_string<typename DocumentType::Ch> &defaultValue)
+{
+  return pointer.GetWithDefault(document, defaultValue);
+}
+#endif
+
+template <typename DocumentType, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType &))
+GetValueByPointerWithDefault(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, T2 defaultValue)
+{
+  return pointer.GetWithDefault(document, defaultValue);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const CharType(&source)[N], const typename DocumentType::ValueType &defaultValue)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const CharType(&source)[N], const typename DocumentType::Ch *defaultValue)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch> &defaultValue)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+#endif
+
+template <typename DocumentType, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType &))
+GetValueByPointerWithDefault(DocumentType &document, const CharType(&source)[N], T2 defaultValue)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType &SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, typename T::ValueType &value, typename T::AllocatorType &a)
+{
+  return pointer.Set(root, value, a);
+}
+
+template <typename T>
+typename T::ValueType &SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, const typename T::ValueType &value, typename T::AllocatorType &a)
+{
+  return pointer.Set(root, value, a);
+}
+
+template <typename T>
+typename T::ValueType &SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, const typename T::Ch *value, typename T::AllocatorType &a)
+{
+  return pointer.Set(root, value, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T>
+typename T::ValueType &SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, const std::basic_string<typename T::Ch> &value, typename T::AllocatorType &a)
+{
+  return pointer.Set(root, value, a);
+}
+#endif
+
+template <typename T, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType &))
+SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, T2 value, typename T::AllocatorType &a)
+{
+  return pointer.Set(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType &SetValueByPointer(T &root, const CharType(&source)[N], typename T::ValueType &value, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType &SetValueByPointer(T &root, const CharType(&source)[N], const typename T::ValueType &value, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType &SetValueByPointer(T &root, const CharType(&source)[N], const typename T::Ch *value, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename T, typename CharType, size_t N>
+typename T::ValueType &SetValueByPointer(T &root, const CharType(&source)[N], const std::basic_string<typename T::Ch> &value, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+#endif
+
+template <typename T, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType &))
+SetValueByPointer(T &root, const CharType(&source)[N], T2 value, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
+}
+
+// No allocator parameter
+
+template <typename DocumentType>
+typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, typename DocumentType::ValueType &value)
+{
+  return pointer.Set(document, value);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const typename DocumentType::ValueType &value)
+{
+  return pointer.Set(document, value);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const typename DocumentType::Ch *value)
+{
+  return pointer.Set(document, value);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType>
+typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const std::basic_string<typename DocumentType::Ch> &value)
+{
+  return pointer.Set(document, value);
+}
+#endif
+
+template <typename DocumentType, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType &))
+SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, T2 value)
+{
+  return pointer.Set(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const CharType(&source)[N], typename DocumentType::ValueType &value)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const CharType(&source)[N], const typename DocumentType::ValueType &value)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const CharType(&source)[N], const typename DocumentType::Ch *value)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+#if RAPIDJSON_HAS_STDSTRING
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch> &value)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+#endif
+
+template <typename DocumentType, typename CharType, size_t N, typename T2>
+RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType &))
+SetValueByPointer(DocumentType &document, const CharType(&source)[N], T2 value)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+typename T::ValueType &SwapValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, typename T::ValueType &value, typename T::AllocatorType &a)
+{
+  return pointer.Swap(root, value, a);
+}
+
+template <typename T, typename CharType, size_t N>
+typename T::ValueType &SwapValueByPointer(T &root, const CharType(&source)[N], typename T::ValueType &value, typename T::AllocatorType &a)
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Swap(root, value, a);
+}
+
+template <typename DocumentType>
+typename DocumentType::ValueType &SwapValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, typename DocumentType::ValueType &value)
+{
+  return pointer.Swap(document, value);
+}
+
+template <typename DocumentType, typename CharType, size_t N>
+typename DocumentType::ValueType &SwapValueByPointer(DocumentType &document, const CharType(&source)[N], typename DocumentType::ValueType &value)
+{
+  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Swap(document, value);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+bool EraseValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer)
+{
+  return pointer.Erase(root);
+}
+
+template <typename T, typename CharType, size_t N>
+bool EraseValueByPointer(T &root, const CharType(&source)[N])
+{
+  return GenericPointer<typename T::ValueType>(source, N - 1).Erase(root);
+}
+
+//@}
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_POINTER_H_
diff --git a/contrib/world_builder/include/rapidjson/prettywriter.h.bak b/contrib/world_builder/include/rapidjson/prettywriter.h.bak
new file mode 100644
index 00000000000..ea658987976
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/prettywriter.h.bak
@@ -0,0 +1,340 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_PRETTYWRITER_H_
+#define RAPIDJSON_PRETTYWRITER_H_
+
+#include "writer.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Combination of PrettyWriter format flags.
+/*! \see PrettyWriter::SetFormatOptions
+ */
+enum PrettyFormatOptions
+{
+  kFormatDefault = 0,         //!< Default pretty formatting.
+  kFormatSingleLineArray = 1  //!< Format arrays on a single line.
+};
+
+//! Writer with indentation and spacing.
+/*!
+    \tparam OutputStream Type of output os.
+    \tparam SourceEncoding Encoding of source string.
+    \tparam TargetEncoding Encoding of output stream.
+    \tparam StackAllocator Type of allocator for allocating memory of stack.
+*/
+template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
+class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags>
+{
+  public:
+    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base;
+    typedef typename Base::Ch Ch;
+
+    //! Constructor
+    /*! \param os Output stream.
+        \param allocator User supplied allocator. If it is null, it will create a private one.
+        \param levelDepth Initial capacity of stack.
+    */
+    explicit PrettyWriter(OutputStream &os, StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
+      Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
+
+
+    explicit PrettyWriter(StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
+      Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    PrettyWriter(PrettyWriter &&rhs) :
+      Base(std::forward<PrettyWriter>(rhs)), indentChar_(rhs.indentChar_), indentCharCount_(rhs.indentCharCount_), formatOptions_(rhs.formatOptions_) {}
+#endif
+
+    //! Set custom indentation.
+    /*! \param indentChar       Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
+        \param indentCharCount  Number of indent characters for each indentation level.
+        \note The default indentation is 4 spaces.
+    */
+    PrettyWriter &SetIndent(Ch indentChar, unsigned indentCharCount)
+    {
+      RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
+      indentChar_ = indentChar;
+      indentCharCount_ = indentCharCount;
+      return *this;
+    }
+
+    //! Set pretty writer formatting options.
+    /*! \param options Formatting options.
+    */
+    PrettyWriter &SetFormatOptions(PrettyFormatOptions options)
+    {
+      formatOptions_ = options;
+      return *this;
+    }
+
+    /*! @name Implementation of Handler
+        \see Handler
+    */
+    //@{
+
+    bool Null()
+    {
+      PrettyPrefix(kNullType);
+      return Base::EndValue(Base::WriteNull());
+    }
+    bool Bool(bool b)
+    {
+      PrettyPrefix(b ? kTrueType : kFalseType);
+      return Base::EndValue(Base::WriteBool(b));
+    }
+    bool Int(int i)
+    {
+      PrettyPrefix(kNumberType);
+      return Base::EndValue(Base::WriteInt(i));
+    }
+    bool Uint(unsigned u)
+    {
+      PrettyPrefix(kNumberType);
+      return Base::EndValue(Base::WriteUint(u));
+    }
+    bool Int64(int64_t i64)
+    {
+      PrettyPrefix(kNumberType);
+      return Base::EndValue(Base::WriteInt64(i64));
+    }
+    bool Uint64(uint64_t u64)
+    {
+      PrettyPrefix(kNumberType);
+      return Base::EndValue(Base::WriteUint64(u64));
+    }
+    bool Double(double d)
+    {
+      PrettyPrefix(kNumberType);
+      return Base::EndValue(Base::WriteDouble(d));
+    }
+
+    bool RawNumber(const Ch *str, SizeType length, bool copy = false)
+    {
+      RAPIDJSON_ASSERT(str != 0);
+      (void)copy;
+      PrettyPrefix(kNumberType);
+      return Base::EndValue(Base::WriteString(str, length));
+    }
+
+    bool String(const Ch *str, SizeType length, bool copy = false)
+    {
+      RAPIDJSON_ASSERT(str != 0);
+      (void)copy;
+      PrettyPrefix(kStringType);
+      return Base::EndValue(Base::WriteString(str, length));
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool String(const std::basic_string<Ch> &str)
+    {
+      return String(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool StartObject()
+    {
+      PrettyPrefix(kObjectType);
+      new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
+      return Base::WriteStartObject();
+    }
+
+    bool Key(const Ch *str, SizeType length, bool copy = false)
+    {
+      return String(str, length, copy);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool Key(const std::basic_string<Ch> &str)
+    {
+      return Key(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool EndObject(SizeType memberCount = 0)
+    {
+      (void)memberCount;
+      RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object
+      RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray); // currently inside an Array, not Object
+      RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top<typename Base::Level>()->valueCount % 2); // Object has a Key without a Value
+
+      bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
+
+      if (!empty)
+        {
+          Base::os_->Put('\n');
+          WriteIndent();
+        }
+      bool ret = Base::EndValue(Base::WriteEndObject());
+      (void)ret;
+      RAPIDJSON_ASSERT(ret == true);
+      if (Base::level_stack_.Empty()) // end of json text
+        Base::Flush();
+      return true;
+    }
+
+    bool StartArray()
+    {
+      PrettyPrefix(kArrayType);
+      new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
+      return Base::WriteStartArray();
+    }
+
+    bool EndArray(SizeType memberCount = 0)
+    {
+      (void)memberCount;
+      RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
+      RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
+      bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
+
+      if (!empty && !(formatOptions_ & kFormatSingleLineArray))
+        {
+          Base::os_->Put('\n');
+          WriteIndent();
+        }
+      bool ret = Base::EndValue(Base::WriteEndArray());
+      (void)ret;
+      RAPIDJSON_ASSERT(ret == true);
+      if (Base::level_stack_.Empty()) // end of json text
+        Base::Flush();
+      return true;
+    }
+
+    //@}
+
+    /*! @name Convenience extensions */
+    //@{
+
+    //! Simpler but slower overload.
+    bool String(const Ch *str)
+    {
+      return String(str, internal::StrLen(str));
+    }
+    bool Key(const Ch *str)
+    {
+      return Key(str, internal::StrLen(str));
+    }
+
+    //@}
+
+    //! Write a raw JSON value.
+    /*!
+        For user to write a stringified JSON as a value.
+
+        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
+        \param length Length of the json.
+        \param type Type of the root of json.
+        \note When using PrettyWriter::RawValue(), the result json may not be indented correctly.
+    */
+    bool RawValue(const Ch *json, size_t length, Type type)
+    {
+      RAPIDJSON_ASSERT(json != 0);
+      PrettyPrefix(type);
+      return Base::EndValue(Base::WriteRawValue(json, length));
+    }
+
+  protected:
+    void PrettyPrefix(Type type)
+    {
+      (void)type;
+      if (Base::level_stack_.GetSize() != 0)   // this value is not at root
+        {
+          typename Base::Level *level = Base::level_stack_.template Top<typename Base::Level>();
+
+          if (level->inArray)
+            {
+              if (level->valueCount > 0)
+                {
+                  Base::os_->Put(','); // add comma if it is not the first element in array
+                  if (formatOptions_ & kFormatSingleLineArray)
+                    Base::os_->Put(' ');
+                }
+
+              if (!(formatOptions_ & kFormatSingleLineArray))
+                {
+                  Base::os_->Put('\n');
+                  WriteIndent();
+                }
+            }
+          else    // in object
+            {
+              if (level->valueCount > 0)
+                {
+                  if (level->valueCount % 2 == 0)
+                    {
+                      Base::os_->Put(',');
+                      Base::os_->Put('\n');
+                    }
+                  else
+                    {
+                      Base::os_->Put(':');
+                      Base::os_->Put(' ');
+                    }
+                }
+              else
+                Base::os_->Put('\n');
+
+              if (level->valueCount % 2 == 0)
+                WriteIndent();
+            }
+          if (!level->inArray && level->valueCount % 2 == 0)
+            RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
+          level->valueCount++;
+        }
+      else
+        {
+          RAPIDJSON_ASSERT(!Base::hasRoot_);  // Should only has one and only one root.
+          Base::hasRoot_ = true;
+        }
+    }
+
+    void WriteIndent()
+    {
+      size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
+      PutN(*Base::os_, static_cast<typename OutputStream::Ch>(indentChar_), count);
+    }
+
+    Ch indentChar_;
+    unsigned indentCharCount_;
+    PrettyFormatOptions formatOptions_;
+
+  private:
+    // Prohibit copy constructor & assignment operator.
+    PrettyWriter(const PrettyWriter &);
+    PrettyWriter &operator=(const PrettyWriter &);
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/rapidjson/rapidjson.h.bak b/contrib/world_builder/include/rapidjson/rapidjson.h.bak
new file mode 100644
index 00000000000..d857baeea34
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/rapidjson.h.bak
@@ -0,0 +1,660 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_RAPIDJSON_H_
+#define RAPIDJSON_RAPIDJSON_H_
+
+/*!\file rapidjson.h
+    \brief common definitions and configuration
+
+    \see RAPIDJSON_CONFIG
+ */
+
+/*! \defgroup RAPIDJSON_CONFIG RapidJSON configuration
+    \brief Configuration macros for library features
+
+    Some RapidJSON features are configurable to adapt the library to a wide
+    variety of platforms, environments and usage scenarios.  Most of the
+    features can be configured in terms of overridden or predefined
+    preprocessor macros at compile-time.
+
+    Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs.
+
+    \note These macros should be given on the compiler command-line
+          (where applicable)  to avoid inconsistent values when compiling
+          different translation units of a single application.
+ */
+
+#include <cstdlib>  // malloc(), realloc(), free(), size_t
+#include <cstring>  // memset(), memcpy(), memmove(), memcmp()
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_VERSION_STRING
+//
+// ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt.
+//
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+// token stringification
+#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x)
+#define RAPIDJSON_DO_STRINGIFY(x) #x
+
+// token concatenation
+#define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y)
+#define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y)
+#define RAPIDJSON_DO_JOIN2(X, Y) X##Y
+//!@endcond
+
+/*! \def RAPIDJSON_MAJOR_VERSION
+    \ingroup RAPIDJSON_CONFIG
+    \brief Major version of RapidJSON in integer.
+*/
+/*! \def RAPIDJSON_MINOR_VERSION
+    \ingroup RAPIDJSON_CONFIG
+    \brief Minor version of RapidJSON in integer.
+*/
+/*! \def RAPIDJSON_PATCH_VERSION
+    \ingroup RAPIDJSON_CONFIG
+    \brief Patch version of RapidJSON in integer.
+*/
+/*! \def RAPIDJSON_VERSION_STRING
+    \ingroup RAPIDJSON_CONFIG
+    \brief Version of RapidJSON in "<major>.<minor>.<patch>" string format.
+*/
+#define RAPIDJSON_MAJOR_VERSION 1
+#define RAPIDJSON_MINOR_VERSION 1
+#define RAPIDJSON_PATCH_VERSION 0
+#define RAPIDJSON_VERSION_STRING \
+  RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION)
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NAMESPACE_(BEGIN|END)
+/*! \def RAPIDJSON_NAMESPACE
+    \ingroup RAPIDJSON_CONFIG
+    \brief   provide custom rapidjson namespace
+
+    In order to avoid symbol clashes and/or "One Definition Rule" errors
+    between multiple inclusions of (different versions of) RapidJSON in
+    a single binary, users can customize the name of the main RapidJSON
+    namespace.
+
+    In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE
+    to a custom name (e.g. \c MyRapidJSON) is sufficient.  If multiple
+    levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref
+    RAPIDJSON_NAMESPACE_END need to be defined as well:
+
+    \code
+    // in some .cpp file
+    #define RAPIDJSON_NAMESPACE my::rapidjson
+    #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {
+    #define RAPIDJSON_NAMESPACE_END   } }
+    #include "rapidjson/..."
+    \endcode
+
+    \see rapidjson
+ */
+/*! \def RAPIDJSON_NAMESPACE_BEGIN
+    \ingroup RAPIDJSON_CONFIG
+    \brief   provide custom rapidjson namespace (opening expression)
+    \see RAPIDJSON_NAMESPACE
+*/
+/*! \def RAPIDJSON_NAMESPACE_END
+    \ingroup RAPIDJSON_CONFIG
+    \brief   provide custom rapidjson namespace (closing expression)
+    \see RAPIDJSON_NAMESPACE
+*/
+#ifndef RAPIDJSON_NAMESPACE
+#define RAPIDJSON_NAMESPACE rapidjson
+#endif
+#ifndef RAPIDJSON_NAMESPACE_BEGIN
+#define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE {
+#endif
+#ifndef RAPIDJSON_NAMESPACE_END
+#define RAPIDJSON_NAMESPACE_END }
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_HAS_STDSTRING
+
+#ifndef RAPIDJSON_HAS_STDSTRING
+#ifdef RAPIDJSON_DOXYGEN_RUNNING
+#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation
+#else
+#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default
+#endif
+/*! \def RAPIDJSON_HAS_STDSTRING
+    \ingroup RAPIDJSON_CONFIG
+    \brief Enable RapidJSON support for \c std::string
+
+    By defining this preprocessor symbol to \c 1, several convenience functions for using
+    \ref rapidjson::GenericValue with \c std::string are enabled, especially
+    for construction and comparison.
+
+    \hideinitializer
+*/
+#endif // !defined(RAPIDJSON_HAS_STDSTRING)
+
+#if RAPIDJSON_HAS_STDSTRING
+#include <string>
+#endif // RAPIDJSON_HAS_STDSTRING
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NO_INT64DEFINE
+
+/*! \def RAPIDJSON_NO_INT64DEFINE
+    \ingroup RAPIDJSON_CONFIG
+    \brief Use external 64-bit integer types.
+
+    RapidJSON requires the 64-bit integer types \c int64_t and  \c uint64_t types
+    to be available at global scope.
+
+    If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to
+    prevent RapidJSON from defining its own types.
+*/
+#ifndef RAPIDJSON_NO_INT64DEFINE
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#if defined(_MSC_VER) && (_MSC_VER < 1800)  // Visual Studio 2013
+#include "msinttypes/stdint.h"
+#include "msinttypes/inttypes.h"
+#else
+// Other compilers should have this.
+#include <stdint.h>
+#include <inttypes.h>
+#endif
+//!@endcond
+#ifdef RAPIDJSON_DOXYGEN_RUNNING
+#define RAPIDJSON_NO_INT64DEFINE
+#endif
+#endif // RAPIDJSON_NO_INT64TYPEDEF
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_FORCEINLINE
+
+#ifndef RAPIDJSON_FORCEINLINE
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#if defined(_MSC_VER) && defined(NDEBUG)
+#define RAPIDJSON_FORCEINLINE __forceinline
+#elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG)
+#define RAPIDJSON_FORCEINLINE __attribute__((always_inline))
+#else
+#define RAPIDJSON_FORCEINLINE
+#endif
+//!@endcond
+#endif // RAPIDJSON_FORCEINLINE
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ENDIAN
+#define RAPIDJSON_LITTLEENDIAN  0   //!< Little endian machine
+#define RAPIDJSON_BIGENDIAN     1   //!< Big endian machine
+
+//! Endianness of the machine.
+/*!
+    \def RAPIDJSON_ENDIAN
+    \ingroup RAPIDJSON_CONFIG
+
+    GCC 4.6 provided macro for detecting endianness of the target machine. But other
+    compilers may not have this. User can define RAPIDJSON_ENDIAN to either
+    \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN.
+
+    Default detection implemented with reference to
+    \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html
+    \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp
+*/
+#ifndef RAPIDJSON_ENDIAN
+// Detect with GCC 4.6's macro
+#  ifdef __BYTE_ORDER__
+#    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+#    else
+#      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
+#    endif // __BYTE_ORDER__
+// Detect with GLIBC's endian.h
+#  elif defined(__GLIBC__)
+#    include <endian.h>
+#    if (__BYTE_ORDER == __LITTLE_ENDIAN)
+#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#    elif (__BYTE_ORDER == __BIG_ENDIAN)
+#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+#    else
+#      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
+#   endif // __GLIBC__
+// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
+#  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#  elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+// Detect with architecture macros
+#  elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+#  elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#  elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#  elif defined(RAPIDJSON_DOXYGEN_RUNNING)
+#    define RAPIDJSON_ENDIAN
+#  else
+#    error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
+#  endif
+#endif // RAPIDJSON_ENDIAN
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_64BIT
+
+//! Whether using 64-bit architecture
+#ifndef RAPIDJSON_64BIT
+#if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__)
+#define RAPIDJSON_64BIT 1
+#else
+#define RAPIDJSON_64BIT 0
+#endif
+#endif // RAPIDJSON_64BIT
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ALIGN
+
+//! Data alignment of the machine.
+/*! \ingroup RAPIDJSON_CONFIG
+    \param x pointer to align
+
+    Some machines require strict data alignment. The default is 8 bytes.
+    User can customize by defining the RAPIDJSON_ALIGN function macro.
+*/
+#ifndef RAPIDJSON_ALIGN
+#define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_UINT64_C2
+
+//! Construct a 64-bit literal by a pair of 32-bit integer.
+/*!
+    64-bit literal with or without ULL suffix is prone to compiler warnings.
+    UINT64_C() is C macro which cause compilation problems.
+    Use this macro to define 64-bit constants by a pair of 32-bit integer.
+*/
+#ifndef RAPIDJSON_UINT64_C2
+#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_48BITPOINTER_OPTIMIZATION
+
+//! Use only lower 48-bit address for some pointers.
+/*!
+    \ingroup RAPIDJSON_CONFIG
+
+    This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address.
+    The higher 16-bit can be used for storing other data.
+    \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture.
+*/
+#ifndef RAPIDJSON_48BITPOINTER_OPTIMIZATION
+#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
+#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 1
+#else
+#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 0
+#endif
+#endif // RAPIDJSON_48BITPOINTER_OPTIMIZATION
+
+#if RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1
+#if RAPIDJSON_64BIT != 1
+#error RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when RAPIDJSON_64BIT=1
+#endif
+#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x))))
+#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
+#else
+#define RAPIDJSON_SETPOINTER(type, p, x) (p = (x))
+#define RAPIDJSON_GETPOINTER(type, p) (p)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_NEON/RAPIDJSON_SIMD
+
+/*! \def RAPIDJSON_SIMD
+    \ingroup RAPIDJSON_CONFIG
+    \brief Enable SSE2/SSE4.2/Neon optimization.
+
+    RapidJSON supports optimized implementations for some parsing operations
+    based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel
+    or ARM compatible processors.
+
+    To enable these optimizations, three different symbols can be defined;
+    \code
+    // Enable SSE2 optimization.
+    #define RAPIDJSON_SSE2
+
+    // Enable SSE4.2 optimization.
+    #define RAPIDJSON_SSE42
+    \endcode
+
+    // Enable ARM Neon optimization.
+    #define RAPIDJSON_NEON
+    \endcode
+
+    \c RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined.
+
+    If any of these symbols is defined, RapidJSON defines the macro
+    \c RAPIDJSON_SIMD to indicate the availability of the optimized code.
+*/
+#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \
+    || defined(RAPIDJSON_NEON) || defined(RAPIDJSON_DOXYGEN_RUNNING)
+#define RAPIDJSON_SIMD
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NO_SIZETYPEDEFINE
+
+#ifndef RAPIDJSON_NO_SIZETYPEDEFINE
+/*! \def RAPIDJSON_NO_SIZETYPEDEFINE
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-provided \c SizeType definition.
+
+    In order to avoid using 32-bit size types for indexing strings and arrays,
+    define this preprocessor symbol and provide the type rapidjson::SizeType
+    before including RapidJSON:
+    \code
+    #define RAPIDJSON_NO_SIZETYPEDEFINE
+    namespace rapidjson { typedef ::std::size_t SizeType; }
+    #include "rapidjson/..."
+    \endcode
+
+    \see rapidjson::SizeType
+*/
+#ifdef RAPIDJSON_DOXYGEN_RUNNING
+#define RAPIDJSON_NO_SIZETYPEDEFINE
+#endif
+RAPIDJSON_NAMESPACE_BEGIN
+//! Size type (for string lengths, array sizes, etc.)
+/*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,
+    instead of using \c size_t. Users may override the SizeType by defining
+    \ref RAPIDJSON_NO_SIZETYPEDEFINE.
+*/
+typedef unsigned SizeType;
+RAPIDJSON_NAMESPACE_END
+#endif
+
+// always import std::size_t to rapidjson namespace
+RAPIDJSON_NAMESPACE_BEGIN
+using std::size_t;
+RAPIDJSON_NAMESPACE_END
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ASSERT
+
+//! Assertion.
+/*! \ingroup RAPIDJSON_CONFIG
+    By default, rapidjson uses C \c assert() for internal assertions.
+    User can override it by defining RAPIDJSON_ASSERT(x) macro.
+
+    \note Parsing errors are handled and can be customized by the
+          \ref RAPIDJSON_ERRORS APIs.
+*/
+#ifndef RAPIDJSON_ASSERT
+#include "world_builder/assert.h"
+#define RAPIDJSON_ASSERT(x) WBAssertThrow(x, "RapidJSON error.")
+#endif // RAPIDJSON_ASSERT
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_STATIC_ASSERT
+
+// Prefer C++11 static_assert, if available
+#ifndef RAPIDJSON_STATIC_ASSERT
+#if __cplusplus >= 201103L || ( defined(_MSC_VER) && _MSC_VER >= 1800 )
+#define RAPIDJSON_STATIC_ASSERT(x) \
+  static_assert(x, RAPIDJSON_STRINGIFY(x))
+#endif // C++11
+#endif // RAPIDJSON_STATIC_ASSERT
+
+// Adopt C++03 implementation from boost
+#ifndef RAPIDJSON_STATIC_ASSERT
+#ifndef __clang__
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#endif
+RAPIDJSON_NAMESPACE_BEGIN
+template <bool x> struct STATIC_ASSERTION_FAILURE;
+template <> struct STATIC_ASSERTION_FAILURE<true>
+{
+  enum { value = 1 };
+};
+template <size_t x> struct StaticAssertTest {};
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__GNUC__) || defined(__clang__)
+#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
+#else
+#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
+#endif
+#ifndef __clang__
+//!@endcond
+#endif
+
+/*! \def RAPIDJSON_STATIC_ASSERT
+    \brief (Internal) macro to check for conditions at compile-time
+    \param x compile-time condition
+    \hideinitializer
+ */
+#define RAPIDJSON_STATIC_ASSERT(x) \
+  typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \
+  sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
+  RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
+#endif // RAPIDJSON_STATIC_ASSERT
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY
+
+//! Compiler branching hint for expression with high probability to be true.
+/*!
+    \ingroup RAPIDJSON_CONFIG
+    \param x Boolean expression likely to be true.
+*/
+#ifndef RAPIDJSON_LIKELY
+#if defined(__GNUC__) || defined(__clang__)
+#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
+#else
+#define RAPIDJSON_LIKELY(x) (x)
+#endif
+#endif
+
+//! Compiler branching hint for expression with low probability to be true.
+/*!
+    \ingroup RAPIDJSON_CONFIG
+    \param x Boolean expression unlikely to be true.
+*/
+#ifndef RAPIDJSON_UNLIKELY
+#if defined(__GNUC__) || defined(__clang__)
+#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define RAPIDJSON_UNLIKELY(x) (x)
+#endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Helpers
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+
+#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
+#define RAPIDJSON_MULTILINEMACRO_END \
+  } while((void)0, 0)
+
+// adopted from Boost
+#define RAPIDJSON_VERSION_CODE(x,y,z) \
+  (((x)*100000) + ((y)*100) + (z))
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF
+
+#if defined(__GNUC__)
+#define RAPIDJSON_GNUC \
+  RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
+#endif
+
+#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0))
+
+#define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x))
+#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x)
+#define RAPIDJSON_DIAG_OFF(x) \
+  RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x)))
+
+// push/pop support in Clang and GCC>=4.6
+#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0))
+#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
+#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
+#else // GCC >= 4.2, < 4.6
+#define RAPIDJSON_DIAG_PUSH /* ignored */
+#define RAPIDJSON_DIAG_POP /* ignored */
+#endif
+
+#elif defined(_MSC_VER)
+
+// pragma (MSVC specific)
+#define RAPIDJSON_PRAGMA(x) __pragma(x)
+#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x))
+
+#define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x)
+#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
+#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
+
+#else
+
+#define RAPIDJSON_DIAG_OFF(x) /* ignored */
+#define RAPIDJSON_DIAG_PUSH   /* ignored */
+#define RAPIDJSON_DIAG_POP    /* ignored */
+
+#endif // RAPIDJSON_DIAG_*
+
+///////////////////////////////////////////////////////////////////////////////
+// C++11 features
+
+#ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
+#if defined(__clang__)
+#if __has_feature(cxx_rvalue_references) && \
+    (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
+#else
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
+#endif
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+      (defined(_MSC_VER) && _MSC_VER >= 1600) || \
+      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
+
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
+#else
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
+#endif
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+
+#ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
+#if defined(__clang__)
+#define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+    (defined(_MSC_VER) && _MSC_VER >= 1900) || \
+    (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
+#else
+#define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
+#endif
+#endif
+#if RAPIDJSON_HAS_CXX11_NOEXCEPT
+#define RAPIDJSON_NOEXCEPT noexcept
+#else
+#define RAPIDJSON_NOEXCEPT /* noexcept */
+#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
+
+// no automatic detection, yet
+#ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
+#if (defined(_MSC_VER) && _MSC_VER >= 1700)
+#define RAPIDJSON_HAS_CXX11_TYPETRAITS 1
+#else
+#define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
+#endif
+#endif
+
+#ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR
+#if defined(__clang__)
+#define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+      (defined(_MSC_VER) && _MSC_VER >= 1700) || \
+      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#define RAPIDJSON_HAS_CXX11_RANGE_FOR 1
+#else
+#define RAPIDJSON_HAS_CXX11_RANGE_FOR 0
+#endif
+#endif // RAPIDJSON_HAS_CXX11_RANGE_FOR
+
+//!@endcond
+
+//! Assertion (in non-throwing contexts).
+/*! \ingroup RAPIDJSON_CONFIG
+   Some functions provide a \c noexcept guarantee, if the compiler supports it.
+   In these cases, the \ref RAPIDJSON_ASSERT macro cannot be overridden to
+   throw an exception.  This macro adds a separate customization point for
+   such cases.
+
+   Defaults to C \c assert() (as \ref RAPIDJSON_ASSERT), if \c noexcept is
+   supported, and to \ref RAPIDJSON_ASSERT otherwise.
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NOEXCEPT_ASSERT
+
+#ifdef RAPIDJSON_ASSERT_THROWS
+#if RAPIDJSON_HAS_CXX11_NOEXCEPT
+#define RAPIDJSON_NOEXCEPT_ASSERT(x)
+#else
+#include<cassert>
+#define RAPIDJSON_NOEXCEPT_ASSERT(x) assert(x)
+#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
+#else
+#include<cassert>
+#define RAPIDJSON_NOEXCEPT_ASSERT(x) assert(x)
+#endif // RAPIDJSON_ASSERT_THROWS
+
+///////////////////////////////////////////////////////////////////////////////
+// new/delete
+
+#ifndef RAPIDJSON_NEW
+///! customization point for global \c new
+#define RAPIDJSON_NEW(TypeName) new TypeName
+#endif
+#ifndef RAPIDJSON_DELETE
+///! customization point for global \c delete
+#define RAPIDJSON_DELETE(x) delete x
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Type
+
+/*! \namespace rapidjson
+    \brief main RapidJSON namespace
+    \see RAPIDJSON_NAMESPACE
+*/
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Type of JSON value
+enum Type
+{
+  kNullType = 0,      //!< null
+  kFalseType = 1,     //!< false
+  kTrueType = 2,      //!< true
+  kObjectType = 3,    //!< object
+  kArrayType = 4,     //!< array
+  kStringType = 5,    //!< string
+  kNumberType = 6     //!< number
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/rapidjson/reader.h.bak b/contrib/world_builder/include/rapidjson/reader.h.bak
new file mode 100644
index 00000000000..064a3e56ba8
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/reader.h.bak
@@ -0,0 +1,2574 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_READER_H_
+#define RAPIDJSON_READER_H_
+
+/*! \file reader.h */
+
+#include "allocators.h"
+#include "stream.h"
+#include "encodedstream.h"
+#include "internal/meta.h"
+#include "internal/stack.h"
+#include "internal/strtod.h"
+#include <limits>
+
+#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
+#include <intrin.h>
+#pragma intrinsic(_BitScanForward)
+#endif
+#ifdef RAPIDJSON_SSE42
+#include <nmmintrin.h>
+#elif defined(RAPIDJSON_SSE2)
+#include <emmintrin.h>
+#elif defined(RAPIDJSON_NEON)
+#include <arm_neon.h>
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(old-style-cast)
+RAPIDJSON_DIAG_OFF(padded)
+//RAPIDJSON_DIAG_OFF(switch -enum)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4127)  // conditional expression is constant
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#define RAPIDJSON_NOTHING /* deliberately empty */
+#ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN
+#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \
+  RAPIDJSON_MULTILINEMACRO_BEGIN \
+  if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
+  RAPIDJSON_MULTILINEMACRO_END
+#endif
+#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \
+  RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
+//!@endcond
+
+/*! \def RAPIDJSON_PARSE_ERROR_NORETURN
+    \ingroup RAPIDJSON_ERRORS
+    \brief Macro to indicate a parse error.
+    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
+    \param offset  position of the error in JSON input (\c size_t)
+
+    This macros can be used as a customization point for the internal
+    error handling mechanism of RapidJSON.
+
+    A common usage model is to throw an exception instead of requiring the
+    caller to explicitly check the \ref rapidjson::GenericReader::Parse's
+    return value:
+
+    \code
+    #define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \
+       throw ParseException(parseErrorCode, #parseErrorCode, offset)
+
+    #include <stdexcept>               // std::runtime_error
+    #include "rapidjson/error/error.h" // rapidjson::ParseResult
+
+    struct ParseException : std::runtime_error, rapidjson::ParseResult {
+      ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset)
+        : std::runtime_error(msg), ParseResult(code, offset) {}
+    };
+
+    #include "rapidjson/reader.h"
+    \endcode
+
+    \see RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse
+ */
+#ifndef RAPIDJSON_PARSE_ERROR_NORETURN
+#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \
+  RAPIDJSON_MULTILINEMACRO_BEGIN \
+  RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
+  SetParseError(parseErrorCode, offset); \
+  RAPIDJSON_MULTILINEMACRO_END
+#endif
+
+/*! \def RAPIDJSON_PARSE_ERROR
+    \ingroup RAPIDJSON_ERRORS
+    \brief (Internal) macro to indicate and handle a parse error.
+    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
+    \param offset  position of the error in JSON input (\c size_t)
+
+    Invokes RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing.
+
+    \see RAPIDJSON_PARSE_ERROR_NORETURN
+    \hideinitializer
+ */
+#ifndef RAPIDJSON_PARSE_ERROR
+#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \
+  RAPIDJSON_MULTILINEMACRO_BEGIN \
+  RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
+  RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
+  RAPIDJSON_MULTILINEMACRO_END
+#endif
+
+#include "error/error.h" // ParseErrorCode, ParseResult
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// ParseFlag
+
+/*! \def RAPIDJSON_PARSE_DEFAULT_FLAGS
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-defined kParseDefaultFlags definition.
+
+    User can define this as any \c ParseFlag combinations.
+*/
+#ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS
+#define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags
+#endif
+
+//! Combination of parseFlags
+/*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream
+ */
+enum ParseFlag
+{
+  kParseNoFlags = 0,              //!< No flags are set.
+  kParseInsituFlag = 1,           //!< In-situ(destructive) parsing.
+  kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings.
+  kParseIterativeFlag = 4,        //!< Iterative(constant complexity in terms of function call stack size) parsing.
+  kParseStopWhenDoneFlag = 8,     //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error.
+  kParseFullPrecisionFlag = 16,   //!< Parse number in full precision (but slower).
+  kParseCommentsFlag = 32,        //!< Allow one-line (//) and multi-line (/**/) comments.
+  kParseNumbersAsStringsFlag = 64,    //!< Parse all numbers (ints/doubles) as strings.
+  kParseTrailingCommasFlag = 128, //!< Allow trailing commas at the end of objects and arrays.
+  kParseNanAndInfFlag = 256,      //!< Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
+  kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS  //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Handler
+
+/*! \class rapidjson::Handler
+    \brief Concept for receiving events from GenericReader upon parsing.
+    The functions return true if no error occurs. If they return false,
+    the event publisher should terminate the process.
+\code
+concept Handler {
+    typename Ch;
+
+    bool Null();
+    bool Bool(bool b);
+    bool Int(int i);
+    bool Uint(unsigned i);
+    bool Int64(int64_t i);
+    bool Uint64(uint64_t i);
+    bool Double(double d);
+    /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
+    bool RawNumber(const Ch* str, SizeType length, bool copy);
+    bool String(const Ch* str, SizeType length, bool copy);
+    bool StartObject();
+    bool Key(const Ch* str, SizeType length, bool copy);
+    bool EndObject(SizeType memberCount);
+    bool StartArray();
+    bool EndArray(SizeType elementCount);
+};
+\endcode
+*/
+///////////////////////////////////////////////////////////////////////////////
+// BaseReaderHandler
+
+//! Default implementation of Handler.
+/*! This can be used as base class of any reader handler.
+    \note implements Handler concept
+*/
+template<typename Encoding = UTF8<>, typename Derived = void>
+struct BaseReaderHandler
+{
+  typedef typename Encoding::Ch Ch;
+
+  typedef typename internal::SelectIf<internal::IsSame<Derived, void>, BaseReaderHandler, Derived>::Type Override;
+
+  bool Default()
+  {
+    return true;
+  }
+  bool Null()
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool Bool(bool)
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool Int(int)
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool Uint(unsigned)
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool Int64(int64_t)
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool Uint64(uint64_t)
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool Double(double)
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
+  bool RawNumber(const Ch *str, SizeType len, bool copy)
+  {
+    return static_cast<Override &>(*this).String(str, len, copy);
+  }
+  bool String(const Ch *, SizeType, bool)
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool StartObject()
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool Key(const Ch *str, SizeType len, bool copy)
+  {
+    return static_cast<Override &>(*this).String(str, len, copy);
+  }
+  bool EndObject(SizeType)
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool StartArray()
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+  bool EndArray(SizeType)
+  {
+    return static_cast<Override &>(*this).Default();
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// StreamLocalCopy
+
+namespace internal
+{
+
+  template<typename Stream, int = StreamTraits<Stream>::copyOptimization>
+  class StreamLocalCopy;
+
+//! Do copy optimization.
+  template<typename Stream>
+  class StreamLocalCopy<Stream, 1>
+  {
+    public:
+      StreamLocalCopy(Stream &original) : s(original), original_(original) {}
+      ~StreamLocalCopy()
+      {
+        original_ = s;
+      }
+
+      Stream s;
+
+    private:
+      StreamLocalCopy &operator=(const StreamLocalCopy &) /* = delete */;
+
+      Stream &original_;
+  };
+
+//! Keep reference.
+  template<typename Stream>
+  class StreamLocalCopy<Stream, 0>
+  {
+    public:
+      StreamLocalCopy(Stream &original) : s(original) {}
+
+      Stream &s;
+
+    private:
+      StreamLocalCopy &operator=(const StreamLocalCopy &) /* = delete */;
+  };
+
+} // namespace internal
+
+///////////////////////////////////////////////////////////////////////////////
+// SkipWhitespace
+
+//! Skip the JSON white spaces in a stream.
+/*! \param is A input stream for skipping white spaces.
+    \note This function has SSE2/SSE4.2 specialization.
+*/
+template<typename InputStream>
+void SkipWhitespace(InputStream &is)
+{
+  internal::StreamLocalCopy<InputStream> copy(is);
+  InputStream &s(copy.s);
+
+  typename InputStream::Ch c;
+  while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t')
+    s.Take();
+}
+
+inline const char *SkipWhitespace(const char *p, const char *end)
+{
+  while (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
+    ++p;
+  return p;
+}
+
+#ifdef RAPIDJSON_SSE42
+//! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once.
+inline const char *SkipWhitespace_SIMD(const char *p)
+{
+  // Fast return for single non-whitespace
+  if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+    ++p;
+  else
+    return p;
+
+  // 16-byte align to the next boundary
+  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+  while (p != nextAligned)
+    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+      ++p;
+    else
+      return p;
+
+  // The rest of string using SIMD
+  static const char whitespace[16] = " \n\r\t";
+  const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
+
+  for (;; p += 16)
+    {
+      const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+      const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
+      if (r != 16)    // some of characters is non-whitespace
+        return p + r;
+    }
+}
+
+inline const char *SkipWhitespace_SIMD(const char *p, const char *end)
+{
+  // Fast return for single non-whitespace
+  if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
+    ++p;
+  else
+    return p;
+
+  // The middle of string using SIMD
+  static const char whitespace[16] = " \n\r\t";
+  const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
+
+  for (; p <= end - 16; p += 16)
+    {
+      const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
+      const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
+      if (r != 16)    // some of characters is non-whitespace
+        return p + r;
+    }
+
+  return SkipWhitespace(p, end);
+}
+
+#elif defined(RAPIDJSON_SSE2)
+
+//! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once.
+inline const char *SkipWhitespace_SIMD(const char *p)
+{
+  // Fast return for single non-whitespace
+  if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+    ++p;
+  else
+    return p;
+
+  // 16-byte align to the next boundary
+  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+  while (p != nextAligned)
+    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+      ++p;
+    else
+      return p;
+
+  // The rest of string
+#define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
+  static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
+#undef C16
+
+  const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
+  const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
+  const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
+  const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
+
+  for (;; p += 16)
+    {
+      const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+      __m128i x = _mm_cmpeq_epi8(s, w0);
+      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
+      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
+      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
+      unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
+      if (r != 0)     // some of characters may be non-whitespace
+        {
+#ifdef _MSC_VER         // Find the index of first non-whitespace
+          unsigned long offset;
+          _BitScanForward(&offset, r);
+          return p + offset;
+#else
+          return p + __builtin_ffs(r) - 1;
+#endif
+        }
+    }
+}
+
+inline const char *SkipWhitespace_SIMD(const char *p, const char *end)
+{
+  // Fast return for single non-whitespace
+  if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
+    ++p;
+  else
+    return p;
+
+  // The rest of string
+#define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
+  static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
+#undef C16
+
+  const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
+  const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
+  const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
+  const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
+
+  for (; p <= end - 16; p += 16)
+    {
+      const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
+      __m128i x = _mm_cmpeq_epi8(s, w0);
+      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
+      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
+      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
+      unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
+      if (r != 0)     // some of characters may be non-whitespace
+        {
+#ifdef _MSC_VER         // Find the index of first non-whitespace
+          unsigned long offset;
+          _BitScanForward(&offset, r);
+          return p + offset;
+#else
+          return p + __builtin_ffs(r) - 1;
+#endif
+        }
+    }
+
+  return SkipWhitespace(p, end);
+}
+
+#elif defined(RAPIDJSON_NEON)
+
+//! Skip whitespace with ARM Neon instructions, testing 16 8-byte characters at once.
+inline const char *SkipWhitespace_SIMD(const char *p)
+{
+  // Fast return for single non-whitespace
+  if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+    ++p;
+  else
+    return p;
+
+  // 16-byte align to the next boundary
+  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+  while (p != nextAligned)
+    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
+      ++p;
+    else
+      return p;
+
+  const uint8x16_t w0 = vmovq_n_u8(' ');
+  const uint8x16_t w1 = vmovq_n_u8('\n');
+  const uint8x16_t w2 = vmovq_n_u8('\r');
+  const uint8x16_t w3 = vmovq_n_u8('\t');
+
+  for (;; p += 16)
+    {
+      const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
+      uint8x16_t x = vceqq_u8(s, w0);
+      x = vorrq_u8(x, vceqq_u8(s, w1));
+      x = vorrq_u8(x, vceqq_u8(s, w2));
+      x = vorrq_u8(x, vceqq_u8(s, w3));
+
+      x = vmvnq_u8(x);                       // Negate
+      x = vrev64q_u8(x);                     // Rev in 64
+      uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
+      uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+
+      if (low == 0)
+        {
+          if (high != 0)
+            {
+              int lz =__builtin_clzll(high);;
+              return p + 8 + (lz >> 3);
+            }
+        }
+      else
+        {
+          int lz = __builtin_clzll(low);;
+          return p + (lz >> 3);
+        }
+    }
+}
+
+inline const char *SkipWhitespace_SIMD(const char *p, const char *end)
+{
+  // Fast return for single non-whitespace
+  if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
+    ++p;
+  else
+    return p;
+
+  const uint8x16_t w0 = vmovq_n_u8(' ');
+  const uint8x16_t w1 = vmovq_n_u8('\n');
+  const uint8x16_t w2 = vmovq_n_u8('\r');
+  const uint8x16_t w3 = vmovq_n_u8('\t');
+
+  for (; p <= end - 16; p += 16)
+    {
+      const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
+      uint8x16_t x = vceqq_u8(s, w0);
+      x = vorrq_u8(x, vceqq_u8(s, w1));
+      x = vorrq_u8(x, vceqq_u8(s, w2));
+      x = vorrq_u8(x, vceqq_u8(s, w3));
+
+      x = vmvnq_u8(x);                       // Negate
+      x = vrev64q_u8(x);                     // Rev in 64
+      uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
+      uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+
+      if (low == 0)
+        {
+          if (high != 0)
+            {
+              int lz = __builtin_clzll(high);
+              return p + 8 + (lz >> 3);
+            }
+        }
+      else
+        {
+          int lz = __builtin_clzll(low);
+          return p + (lz >> 3);
+        }
+    }
+
+  return SkipWhitespace(p, end);
+}
+
+#endif // RAPIDJSON_NEON
+
+#ifdef RAPIDJSON_SIMD
+//! Template function specialization for InsituStringStream
+template<> inline void SkipWhitespace(InsituStringStream &is)
+{
+  is.src_ = const_cast<char *>(SkipWhitespace_SIMD(is.src_));
+}
+
+//! Template function specialization for StringStream
+template<> inline void SkipWhitespace(StringStream &is)
+{
+  is.src_ = SkipWhitespace_SIMD(is.src_);
+}
+
+template<> inline void SkipWhitespace(EncodedInputStream<UTF8<>, MemoryStream> &is)
+{
+  is.is_.src_ = SkipWhitespace_SIMD(is.is_.src_, is.is_.end_);
+}
+#endif // RAPIDJSON_SIMD
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericReader
+
+//! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator.
+/*! GenericReader parses JSON text from a stream, and send events synchronously to an
+    object implementing Handler concept.
+
+    It needs to allocate a stack for storing a single decoded string during
+    non-destructive parsing.
+
+    For in-situ parsing, the decoded string is directly written to the source
+    text string, no temporary buffer is required.
+
+    A GenericReader object can be reused for parsing multiple JSON text.
+
+    \tparam SourceEncoding Encoding of the input stream.
+    \tparam TargetEncoding Encoding of the parse output.
+    \tparam StackAllocator Allocator type for stack.
+*/
+template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>
+class GenericReader
+{
+  public:
+    typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type
+
+    //! Constructor.
+    /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
+        \param stackCapacity stack capacity in bytes for storing a single decoded string.  (Only use for non-destructive parsing)
+    */
+    GenericReader(StackAllocator *stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) :
+      stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
+
+    //! Parse JSON text.
+    /*! \tparam parseFlags Combination of \ref ParseFlag.
+        \tparam InputStream Type of input stream, implementing Stream concept.
+        \tparam Handler Type of handler, implementing Handler concept.
+        \param is Input stream to be parsed.
+        \param handler The handler to receive events.
+        \return Whether the parsing is successful.
+    */
+    template <unsigned parseFlags, typename InputStream, typename Handler>
+    ParseResult Parse(InputStream &is, Handler &handler)
+    {
+      if (parseFlags & kParseIterativeFlag)
+        return IterativeParse<parseFlags>(is, handler);
+
+      parseResult_.Clear();
+
+      ClearStackOnExit scope(*this);
+
+      SkipWhitespaceAndComments<parseFlags>(is);
+      RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+
+      if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
+        {
+          RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+        }
+      else
+        {
+          ParseValue<parseFlags>(is, handler);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+
+          if (!(parseFlags & kParseStopWhenDoneFlag))
+            {
+              SkipWhitespaceAndComments<parseFlags>(is);
+              RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+
+              if (RAPIDJSON_UNLIKELY(is.Peek() != '\0'))
+                {
+                  RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
+                  RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+                }
+            }
+        }
+
+      return parseResult_;
+    }
+
+    //! Parse JSON text (with \ref kParseDefaultFlags)
+    /*! \tparam InputStream Type of input stream, implementing Stream concept
+        \tparam Handler Type of handler, implementing Handler concept.
+        \param is Input stream to be parsed.
+        \param handler The handler to receive events.
+        \return Whether the parsing is successful.
+    */
+    template <typename InputStream, typename Handler>
+    ParseResult Parse(InputStream &is, Handler &handler)
+    {
+      return Parse<kParseDefaultFlags>(is, handler);
+    }
+
+    //! Initialize JSON text token-by-token parsing
+    /*!
+     */
+    void IterativeParseInit()
+    {
+      parseResult_.Clear();
+      state_ = IterativeParsingStartState;
+    }
+
+    //! Parse one token from JSON text
+    /*! \tparam InputStream Type of input stream, implementing Stream concept
+        \tparam Handler Type of handler, implementing Handler concept.
+        \param is Input stream to be parsed.
+        \param handler The handler to receive events.
+        \return Whether the parsing is successful.
+     */
+    template <unsigned parseFlags, typename InputStream, typename Handler>
+    bool IterativeParseNext(InputStream &is, Handler &handler)
+    {
+      while (RAPIDJSON_LIKELY(is.Peek() != '\0'))
+        {
+          SkipWhitespaceAndComments<parseFlags>(is);
+
+          Token t = Tokenize(is.Peek());
+          IterativeParsingState n = Predict(state_, t);
+          IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
+
+          // If we've finished or hit an error...
+          if (RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d)))
+            {
+              // Report errors.
+              if (d == IterativeParsingErrorState)
+                {
+                  HandleError(state_, is);
+                  return false;
+                }
+
+              // Transition to the finish state.
+              RAPIDJSON_ASSERT(d == IterativeParsingFinishState);
+              state_ = d;
+
+              // If StopWhenDone is not set...
+              if (!(parseFlags & kParseStopWhenDoneFlag))
+                {
+                  // ... and extra non-whitespace data is found...
+                  SkipWhitespaceAndComments<parseFlags>(is);
+                  if (is.Peek() != '\0')
+                    {
+                      // ... this is considered an error.
+                      HandleError(state_, is);
+                      return false;
+                    }
+                }
+
+              // Success! We are done!
+              return true;
+            }
+
+          // Transition to the new state.
+          state_ = d;
+
+          // If we parsed anything other than a delimiter, we invoked the handler, so we can return true now.
+          if (!IsIterativeParsingDelimiterState(n))
+            return true;
+        }
+
+      // We reached the end of file.
+      stack_.Clear();
+
+      if (state_ != IterativeParsingFinishState)
+        {
+          HandleError(state_, is);
+          return false;
+        }
+
+      return true;
+    }
+
+    //! Check if token-by-token parsing JSON text is complete
+    /*! \return Whether the JSON has been fully decoded.
+     */
+    RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const
+    {
+      return IsIterativeParsingCompleteState(state_);
+    }
+
+    //! Whether a parse error has occurred in the last parsing.
+    bool HasParseError() const
+    {
+      return parseResult_.IsError();
+    }
+
+    //! Get the \ref ParseErrorCode of last parsing.
+    ParseErrorCode GetParseErrorCode() const
+    {
+      return parseResult_.Code();
+    }
+
+    //! Get the position of last parsing error in input, 0 otherwise.
+    size_t GetErrorOffset() const
+    {
+      return parseResult_.Offset();
+    }
+
+  protected:
+    void SetParseError(ParseErrorCode code, size_t offset)
+    {
+      parseResult_.Set(code, offset);
+    }
+
+  private:
+    // Prohibit copy constructor & assignment operator.
+    GenericReader(const GenericReader &);
+    GenericReader &operator=(const GenericReader &);
+
+    void ClearStack()
+    {
+      stack_.Clear();
+    }
+
+    // clear stack on any exit from ParseStream, e.g. due to exception
+    struct ClearStackOnExit
+    {
+        explicit ClearStackOnExit(GenericReader &r) : r_(r) {}
+        ~ClearStackOnExit()
+        {
+          r_.ClearStack();
+        }
+      private:
+        GenericReader &r_;
+        ClearStackOnExit(const ClearStackOnExit &);
+        ClearStackOnExit &operator=(const ClearStackOnExit &);
+    };
+
+    template<unsigned parseFlags, typename InputStream>
+    void SkipWhitespaceAndComments(InputStream &is)
+    {
+      SkipWhitespace(is);
+
+      if (parseFlags & kParseCommentsFlag)
+        {
+          while (RAPIDJSON_UNLIKELY(Consume(is, '/')))
+            {
+              if (Consume(is, '*'))
+                {
+                  while (true)
+                    {
+                      if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
+                        RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
+                      else if (Consume(is, '*'))
+                        {
+                          if (Consume(is, '/'))
+                            break;
+                        }
+                      else
+                        is.Take();
+                    }
+                }
+              else if (RAPIDJSON_LIKELY(Consume(is, '/')))
+                while (is.Peek() != '\0' && is.Take() != '\n') {}
+              else
+                RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
+
+              SkipWhitespace(is);
+            }
+        }
+    }
+
+    // Parse object: { string : value, ... }
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseObject(InputStream &is, Handler &handler)
+    {
+      RAPIDJSON_ASSERT(is.Peek() == '{');
+      is.Take();  // Skip '{'
+
+      if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
+        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+
+      SkipWhitespaceAndComments<parseFlags>(is);
+      RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+      if (Consume(is, '}'))
+        {
+          if (RAPIDJSON_UNLIKELY(!handler.EndObject(0)))  // empty object
+            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+          return;
+        }
+
+      for (SizeType memberCount = 0;;)
+        {
+          if (RAPIDJSON_UNLIKELY(is.Peek() != '"'))
+            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
+
+          ParseString<parseFlags>(is, handler, true);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+          SkipWhitespaceAndComments<parseFlags>(is);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+          if (RAPIDJSON_UNLIKELY(!Consume(is, ':')))
+            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
+
+          SkipWhitespaceAndComments<parseFlags>(is);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+          ParseValue<parseFlags>(is, handler);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+          SkipWhitespaceAndComments<parseFlags>(is);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+          ++memberCount;
+
+          switch (is.Peek())
+            {
+              case ',':
+                is.Take();
+                SkipWhitespaceAndComments<parseFlags>(is);
+                RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+                break;
+              case '}':
+                is.Take();
+                if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
+                  RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+                return;
+              default:
+                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());
+                break; // This useless break is only for making warning and coverage happy
+            }
+
+          if (parseFlags & kParseTrailingCommasFlag)
+            {
+              if (is.Peek() == '}')
+                {
+                  if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
+                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+                  is.Take();
+                  return;
+                }
+            }
+        }
+    }
+
+    // Parse array: [ value, ... ]
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseArray(InputStream &is, Handler &handler)
+    {
+      RAPIDJSON_ASSERT(is.Peek() == '[');
+      is.Take();  // Skip '['
+
+      if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
+        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+
+      SkipWhitespaceAndComments<parseFlags>(is);
+      RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+      if (Consume(is, ']'))
+        {
+          if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
+            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+          return;
+        }
+
+      for (SizeType elementCount = 0;;)
+        {
+          ParseValue<parseFlags>(is, handler);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+          ++elementCount;
+          SkipWhitespaceAndComments<parseFlags>(is);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+
+          if (Consume(is, ','))
+            {
+              SkipWhitespaceAndComments<parseFlags>(is);
+              RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+            }
+          else if (Consume(is, ']'))
+            {
+              if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
+                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+              return;
+            }
+          else
+            RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
+
+          if (parseFlags & kParseTrailingCommasFlag)
+            {
+              if (is.Peek() == ']')
+                {
+                  if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
+                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+                  is.Take();
+                  return;
+                }
+            }
+        }
+    }
+
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseNull(InputStream &is, Handler &handler)
+    {
+      RAPIDJSON_ASSERT(is.Peek() == 'n');
+      is.Take();
+
+      if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l')))
+        {
+          if (RAPIDJSON_UNLIKELY(!handler.Null()))
+            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+        }
+      else
+        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
+    }
+
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseTrue(InputStream &is, Handler &handler)
+    {
+      RAPIDJSON_ASSERT(is.Peek() == 't');
+      is.Take();
+
+      if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e')))
+        {
+          if (RAPIDJSON_UNLIKELY(!handler.Bool(true)))
+            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+        }
+      else
+        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
+    }
+
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseFalse(InputStream &is, Handler &handler)
+    {
+      RAPIDJSON_ASSERT(is.Peek() == 'f');
+      is.Take();
+
+      if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e')))
+        {
+          if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
+            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
+        }
+      else
+        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
+    }
+
+    template<typename InputStream>
+    RAPIDJSON_FORCEINLINE static bool Consume(InputStream &is, typename InputStream::Ch expect)
+    {
+      if (RAPIDJSON_LIKELY(is.Peek() == expect))
+        {
+          is.Take();
+          return true;
+        }
+      else
+        return false;
+    }
+
+    // Helper function to parse four hexadecimal digits in \uXXXX in ParseString().
+    template<typename InputStream>
+    unsigned ParseHex4(InputStream &is, size_t escapeOffset)
+    {
+      unsigned codepoint = 0;
+      for (int i = 0; i < 4; i++)
+        {
+          Ch c = is.Peek();
+          codepoint <<= 4;
+          codepoint += static_cast<unsigned>(c);
+          if (c >= '0' && c <= '9')
+            codepoint -= '0';
+          else if (c >= 'A' && c <= 'F')
+            codepoint -= 'A' - 10;
+          else if (c >= 'a' && c <= 'f')
+            codepoint -= 'a' - 10;
+          else
+            {
+              RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
+              RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
+            }
+          is.Take();
+        }
+      return codepoint;
+    }
+
+    template <typename CharType>
+    class StackStream
+    {
+      public:
+        typedef CharType Ch;
+
+        StackStream(internal::Stack<StackAllocator> &stack) : stack_(stack), length_(0) {}
+        RAPIDJSON_FORCEINLINE void Put(Ch c)
+        {
+          *stack_.template Push<Ch>() = c;
+          ++length_;
+        }
+
+        RAPIDJSON_FORCEINLINE void *Push(SizeType count)
+        {
+          length_ += count;
+          return stack_.template Push<Ch>(count);
+        }
+
+        size_t Length() const
+        {
+          return length_;
+        }
+
+        Ch *Pop()
+        {
+          return stack_.template Pop<Ch>(length_);
+        }
+
+      private:
+        StackStream(const StackStream &);
+        StackStream &operator=(const StackStream &);
+
+        internal::Stack<StackAllocator> &stack_;
+        SizeType length_;
+    };
+
+    // Parse string and generate String event. Different code paths for kParseInsituFlag.
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseString(InputStream &is, Handler &handler, bool isKey = false)
+    {
+      internal::StreamLocalCopy<InputStream> copy(is);
+      InputStream &s(copy.s);
+
+      RAPIDJSON_ASSERT(s.Peek() == '\"');
+      s.Take();  // Skip '\"'
+
+      bool success = false;
+      if (parseFlags & kParseInsituFlag)
+        {
+          typename InputStream::Ch *head = s.PutBegin();
+          ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+          size_t length = s.PutEnd(head) - 1;
+          RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
+          const typename TargetEncoding::Ch *const str = reinterpret_cast<typename TargetEncoding::Ch *>(head);
+          success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
+        }
+      else
+        {
+          StackStream<typename TargetEncoding::Ch> stackStream(stack_);
+          ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+          SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
+          const typename TargetEncoding::Ch *const str = stackStream.Pop();
+          success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
+        }
+      if (RAPIDJSON_UNLIKELY(!success))
+        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
+    }
+
+    // Parse string to an output is
+    // This function handles the prefix/suffix double quotes, escaping, and optional encoding validation.
+    template<unsigned parseFlags, typename SEncoding, typename TEncoding, typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream &is, OutputStream &os)
+    {
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+      static const char escape[256] =
+      {
+        Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/',
+        Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
+        0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
+        0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
+      };
+#undef Z16
+//!@endcond
+
+      for (;;)
+        {
+          // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
+          if (!(parseFlags & kParseValidateEncodingFlag))
+            ScanCopyUnescapedString(is, os);
+
+          Ch c = is.Peek();
+          if (RAPIDJSON_UNLIKELY(c == '\\'))      // Escape
+            {
+              size_t escapeOffset = is.Tell();    // For invalid escaping, report the initial '\\' as error offset
+              is.Take();
+              Ch e = is.Peek();
+              if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)]))
+                {
+                  is.Take();
+                  os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
+                }
+              else if (RAPIDJSON_LIKELY(e == 'u'))      // Unicode
+                {
+                  is.Take();
+                  unsigned codepoint = ParseHex4(is, escapeOffset);
+                  RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+                  if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDBFF))
+                    {
+                      // Handle UTF-16 surrogate pair
+                      if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
+                        RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
+                      unsigned codepoint2 = ParseHex4(is, escapeOffset);
+                      RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
+                      if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
+                        RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
+                      codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
+                    }
+                  TEncoding::Encode(os, codepoint);
+                }
+              else
+                RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
+            }
+          else if (RAPIDJSON_UNLIKELY(c == '"'))      // Closing double quote
+            {
+              is.Take();
+              os.Put('\0');   // null-terminate the string
+              return;
+            }
+          else if (RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20))   // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
+            {
+              if (c == '\0')
+                RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
+              else
+                RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
+            }
+          else
+            {
+              size_t offset = is.Tell();
+              if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
+                                      !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
+                                      !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
+                RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
+            }
+        }
+    }
+
+    template<typename InputStream, typename OutputStream>
+    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InputStream &, OutputStream &)
+    {
+      // Do nothing for generic version
+    }
+
+#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
+    // StringStream -> StackStream<char>
+    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream &is, StackStream<char> &os)
+    {
+      const char *p = is.src_;
+
+      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+      while (p != nextAligned)
+        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
+          {
+            is.src_ = p;
+            return;
+          }
+        else
+          os.Put(*p++);
+
+      // The rest of string using SIMD
+      static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
+      static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
+      static const char space[16]  = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
+      const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
+      const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
+      const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
+
+      for (;; p += 16)
+        {
+          const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+          const __m128i t1 = _mm_cmpeq_epi8(s, dq);
+          const __m128i t2 = _mm_cmpeq_epi8(s, bs);
+          const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
+          const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
+          unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
+          if (RAPIDJSON_UNLIKELY(r != 0))     // some of characters is escaped
+            {
+              SizeType length;
+#ifdef _MSC_VER         // Find the index of first escaped
+              unsigned long offset;
+              _BitScanForward(&offset, r);
+              length = offset;
+#else
+              length = static_cast<SizeType>(__builtin_ffs(r) - 1);
+#endif
+              if (length != 0)
+                {
+                  char *q = reinterpret_cast<char *>(os.Push(length));
+                  for (size_t i = 0; i < length; i++)
+                    q[i] = p[i];
+
+                  p += length;
+                }
+              break;
+            }
+          _mm_storeu_si128(reinterpret_cast<__m128i *>(os.Push(16)), s);
+        }
+
+      is.src_ = p;
+    }
+
+    // InsituStringStream -> InsituStringStream
+    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream &is, InsituStringStream &os)
+    {
+      RAPIDJSON_ASSERT(&is == &os);
+      (void)os;
+
+      if (is.src_ == is.dst_)
+        {
+          SkipUnescapedString(is);
+          return;
+        }
+
+      char *p = is.src_;
+      char *q = is.dst_;
+
+      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+      while (p != nextAligned)
+        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
+          {
+            is.src_ = p;
+            is.dst_ = q;
+            return;
+          }
+        else
+          *q++ = *p++;
+
+      // The rest of string using SIMD
+      static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
+      static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
+      static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
+      const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
+      const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
+      const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
+
+      for (;; p += 16, q += 16)
+        {
+          const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+          const __m128i t1 = _mm_cmpeq_epi8(s, dq);
+          const __m128i t2 = _mm_cmpeq_epi8(s, bs);
+          const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
+          const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
+          unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
+          if (RAPIDJSON_UNLIKELY(r != 0))     // some of characters is escaped
+            {
+              size_t length;
+#ifdef _MSC_VER         // Find the index of first escaped
+              unsigned long offset;
+              _BitScanForward(&offset, r);
+              length = offset;
+#else
+              length = static_cast<size_t>(__builtin_ffs(r) - 1);
+#endif
+              for (const char *pend = p + length; p != pend; )
+                *q++ = *p++;
+              break;
+            }
+          _mm_storeu_si128(reinterpret_cast<__m128i *>(q), s);
+        }
+
+      is.src_ = p;
+      is.dst_ = q;
+    }
+
+    // When read/write pointers are the same for insitu stream, just skip unescaped characters
+    static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream &is)
+    {
+      RAPIDJSON_ASSERT(is.src_ == is.dst_);
+      char *p = is.src_;
+
+      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+      for (; p != nextAligned; p++)
+        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
+          {
+            is.src_ = is.dst_ = p;
+            return;
+          }
+
+      // The rest of string using SIMD
+      static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
+      static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
+      static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
+      const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
+      const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
+      const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
+
+      for (;; p += 16)
+        {
+          const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+          const __m128i t1 = _mm_cmpeq_epi8(s, dq);
+          const __m128i t2 = _mm_cmpeq_epi8(s, bs);
+          const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
+          const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
+          unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
+          if (RAPIDJSON_UNLIKELY(r != 0))     // some of characters is escaped
+            {
+              size_t length;
+#ifdef _MSC_VER         // Find the index of first escaped
+              unsigned long offset;
+              _BitScanForward(&offset, r);
+              length = offset;
+#else
+              length = static_cast<size_t>(__builtin_ffs(r) - 1);
+#endif
+              p += length;
+              break;
+            }
+        }
+
+      is.src_ = is.dst_ = p;
+    }
+#elif defined(RAPIDJSON_NEON)
+    // StringStream -> StackStream<char>
+    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream &is, StackStream<char> &os)
+    {
+      const char *p = is.src_;
+
+      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+      while (p != nextAligned)
+        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
+          {
+            is.src_ = p;
+            return;
+          }
+        else
+          os.Put(*p++);
+
+      // The rest of string using SIMD
+      const uint8x16_t s0 = vmovq_n_u8('"');
+      const uint8x16_t s1 = vmovq_n_u8('\\');
+      const uint8x16_t s2 = vmovq_n_u8('\b');
+      const uint8x16_t s3 = vmovq_n_u8(32);
+
+      for (;; p += 16)
+        {
+          const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
+          uint8x16_t x = vceqq_u8(s, s0);
+          x = vorrq_u8(x, vceqq_u8(s, s1));
+          x = vorrq_u8(x, vceqq_u8(s, s2));
+          x = vorrq_u8(x, vcltq_u8(s, s3));
+
+          x = vrev64q_u8(x);                     // Rev in 64
+          uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
+          uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+
+          SizeType length = 0;
+          bool escaped = false;
+          if (low == 0)
+            {
+              if (high != 0)
+                {
+                  unsigned lz = (unsigned)__builtin_clzll(high);;
+                  length = 8 + (lz >> 3);
+                  escaped = true;
+                }
+            }
+          else
+            {
+              unsigned lz = (unsigned)__builtin_clzll(low);;
+              length = lz >> 3;
+              escaped = true;
+            }
+          if (RAPIDJSON_UNLIKELY(escaped))     // some of characters is escaped
+            {
+              if (length != 0)
+                {
+                  char *q = reinterpret_cast<char *>(os.Push(length));
+                  for (size_t i = 0; i < length; i++)
+                    q[i] = p[i];
+
+                  p += length;
+                }
+              break;
+            }
+          vst1q_u8(reinterpret_cast<uint8_t *>(os.Push(16)), s);
+        }
+
+      is.src_ = p;
+    }
+
+    // InsituStringStream -> InsituStringStream
+    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream &is, InsituStringStream &os)
+    {
+      RAPIDJSON_ASSERT(&is == &os);
+      (void)os;
+
+      if (is.src_ == is.dst_)
+        {
+          SkipUnescapedString(is);
+          return;
+        }
+
+      char *p = is.src_;
+      char *q = is.dst_;
+
+      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+      while (p != nextAligned)
+        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
+          {
+            is.src_ = p;
+            is.dst_ = q;
+            return;
+          }
+        else
+          *q++ = *p++;
+
+      // The rest of string using SIMD
+      const uint8x16_t s0 = vmovq_n_u8('"');
+      const uint8x16_t s1 = vmovq_n_u8('\\');
+      const uint8x16_t s2 = vmovq_n_u8('\b');
+      const uint8x16_t s3 = vmovq_n_u8(32);
+
+      for (;; p += 16, q += 16)
+        {
+          const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
+          uint8x16_t x = vceqq_u8(s, s0);
+          x = vorrq_u8(x, vceqq_u8(s, s1));
+          x = vorrq_u8(x, vceqq_u8(s, s2));
+          x = vorrq_u8(x, vcltq_u8(s, s3));
+
+          x = vrev64q_u8(x);                     // Rev in 64
+          uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
+          uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+
+          SizeType length = 0;
+          bool escaped = false;
+          if (low == 0)
+            {
+              if (high != 0)
+                {
+                  unsigned lz = (unsigned)__builtin_clzll(high);
+                  length = 8 + (lz >> 3);
+                  escaped = true;
+                }
+            }
+          else
+            {
+              unsigned lz = (unsigned)__builtin_clzll(low);
+              length = lz >> 3;
+              escaped = true;
+            }
+          if (RAPIDJSON_UNLIKELY(escaped))     // some of characters is escaped
+            {
+              for (const char *pend = p + length; p != pend; )
+                {
+                  *q++ = *p++;
+                }
+              break;
+            }
+          vst1q_u8(reinterpret_cast<uint8_t *>(q), s);
+        }
+
+      is.src_ = p;
+      is.dst_ = q;
+    }
+
+    // When read/write pointers are the same for insitu stream, just skip unescaped characters
+    static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream &is)
+    {
+      RAPIDJSON_ASSERT(is.src_ == is.dst_);
+      char *p = is.src_;
+
+      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
+      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+      for (; p != nextAligned; p++)
+        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
+          {
+            is.src_ = is.dst_ = p;
+            return;
+          }
+
+      // The rest of string using SIMD
+      const uint8x16_t s0 = vmovq_n_u8('"');
+      const uint8x16_t s1 = vmovq_n_u8('\\');
+      const uint8x16_t s2 = vmovq_n_u8('\b');
+      const uint8x16_t s3 = vmovq_n_u8(32);
+
+      for (;; p += 16)
+        {
+          const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
+          uint8x16_t x = vceqq_u8(s, s0);
+          x = vorrq_u8(x, vceqq_u8(s, s1));
+          x = vorrq_u8(x, vceqq_u8(s, s2));
+          x = vorrq_u8(x, vcltq_u8(s, s3));
+
+          x = vrev64q_u8(x);                     // Rev in 64
+          uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
+          uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+
+          if (low == 0)
+            {
+              if (high != 0)
+                {
+                  int lz = __builtin_clzll(high);
+                  p += 8 + (lz >> 3);
+                  break;
+                }
+            }
+          else
+            {
+              int lz = __builtin_clzll(low);
+              p += lz >> 3;
+              break;
+            }
+        }
+
+      is.src_ = is.dst_ = p;
+    }
+#endif // RAPIDJSON_NEON
+
+    template<typename InputStream, bool backup, bool pushOnTake>
+    class NumberStream;
+
+    template<typename InputStream>
+    class NumberStream<InputStream, false, false>
+    {
+      public:
+        typedef typename InputStream::Ch Ch;
+
+        NumberStream(GenericReader &reader, InputStream &s) : is(s)
+        {
+          (void)reader;
+        }
+
+        RAPIDJSON_FORCEINLINE Ch Peek() const
+        {
+          return is.Peek();
+        }
+        RAPIDJSON_FORCEINLINE Ch TakePush()
+        {
+          return is.Take();
+        }
+        RAPIDJSON_FORCEINLINE Ch Take()
+        {
+          return is.Take();
+        }
+        RAPIDJSON_FORCEINLINE void Push(char) {}
+
+        size_t Tell()
+        {
+          return is.Tell();
+        }
+        size_t Length()
+        {
+          return 0;
+        }
+        const char *Pop()
+        {
+          return 0;
+        }
+
+      protected:
+        NumberStream &operator=(const NumberStream &);
+
+        InputStream &is;
+    };
+
+    template<typename InputStream>
+    class NumberStream<InputStream, true, false> : public NumberStream<InputStream, false, false>
+    {
+        typedef NumberStream<InputStream, false, false> Base;
+      public:
+        NumberStream(GenericReader &reader, InputStream &is) : Base(reader, is), stackStream(reader.stack_) {}
+
+        RAPIDJSON_FORCEINLINE Ch TakePush()
+        {
+          stackStream.Put(static_cast<char>(Base::is.Peek()));
+          return Base::is.Take();
+        }
+
+        RAPIDJSON_FORCEINLINE void Push(char c)
+        {
+          stackStream.Put(c);
+        }
+
+        size_t Length()
+        {
+          return stackStream.Length();
+        }
+
+        const char *Pop()
+        {
+          stackStream.Put('\0');
+          return stackStream.Pop();
+        }
+
+      private:
+        StackStream<char> stackStream;
+    };
+
+    template<typename InputStream>
+    class NumberStream<InputStream, true, true> : public NumberStream<InputStream, true, false>
+    {
+        typedef NumberStream<InputStream, true, false> Base;
+      public:
+        NumberStream(GenericReader &reader, InputStream &is) : Base(reader, is) {}
+
+        RAPIDJSON_FORCEINLINE Ch Take()
+        {
+          return Base::TakePush();
+        }
+    };
+
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseNumber(InputStream &is, Handler &handler)
+    {
+      internal::StreamLocalCopy<InputStream> copy(is);
+      NumberStream<InputStream,
+                   ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
+                   ((parseFlags & kParseInsituFlag) == 0) :
+                   ((parseFlags & kParseFullPrecisionFlag) != 0),
+                   (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
+                   (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);
+
+      size_t startOffset = s.Tell();
+      double d = 0.0;
+      bool useNanOrInf = false;
+
+      // Parse minus
+      bool minus = Consume(s, '-');
+
+      // Parse int: zero / ( digit1-9 *DIGIT )
+      unsigned i = 0;
+      uint64_t i64 = 0;
+      bool use64bit = false;
+      int significandDigit = 0;
+      if (RAPIDJSON_UNLIKELY(s.Peek() == '0'))
+        {
+          i = 0;
+          s.TakePush();
+        }
+      else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9'))
+        {
+          i = static_cast<unsigned>(s.TakePush() - '0');
+
+          if (minus)
+            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+              {
+                if (RAPIDJSON_UNLIKELY(i >= 214748364))   // 2^31 = 2147483648
+                  {
+                    if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8'))
+                      {
+                        i64 = i;
+                        use64bit = true;
+                        break;
+                      }
+                  }
+                i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                significandDigit++;
+              }
+          else
+            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+              {
+                if (RAPIDJSON_UNLIKELY(i >= 429496729))   // 2^32 - 1 = 4294967295
+                  {
+                    if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5'))
+                      {
+                        i64 = i;
+                        use64bit = true;
+                        break;
+                      }
+                  }
+                i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                significandDigit++;
+              }
+        }
+      // Parse NaN or Infinity here
+      else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N')))
+        {
+          if (Consume(s, 'N'))
+            {
+              if (Consume(s, 'a') && Consume(s, 'N'))
+                {
+                  d = std::numeric_limits<double>::quiet_NaN();
+                  useNanOrInf = true;
+                }
+            }
+          else if (RAPIDJSON_LIKELY(Consume(s, 'I')))
+            {
+              if (Consume(s, 'n') && Consume(s, 'f'))
+                {
+                  d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
+                  useNanOrInf = true;
+
+                  if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
+                                                              && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y'))))
+                    {
+                      RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
+                    }
+                }
+            }
+
+          if (RAPIDJSON_UNLIKELY(!useNanOrInf))
+            {
+              RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
+            }
+        }
+      else
+        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
+
+      // Parse 64bit int
+      bool useDouble = false;
+      if (use64bit)
+        {
+          if (minus)
+            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+              {
+                if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
+                  if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8'))
+                    {
+                      d = static_cast<double>(i64);
+                      useDouble = true;
+                      break;
+                    }
+                i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                significandDigit++;
+              }
+          else
+            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+              {
+                if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
+                  if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5'))
+                    {
+                      d = static_cast<double>(i64);
+                      useDouble = true;
+                      break;
+                    }
+                i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                significandDigit++;
+              }
+        }
+
+      // Force double for big integer
+      if (useDouble)
+        {
+          while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+            {
+              d = d * 10 + (s.TakePush() - '0');
+            }
+        }
+
+      // Parse frac = decimal-point 1*DIGIT
+      int expFrac = 0;
+      size_t decimalPosition;
+      if (Consume(s, '.'))
+        {
+          decimalPosition = s.Length();
+
+          if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
+            RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
+
+          if (!useDouble)
+            {
+#if RAPIDJSON_64BIT
+              // Use i64 to store significand in 64-bit architecture
+              if (!use64bit)
+                i64 = i;
+
+              while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+                {
+                  if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
+                    break;
+                  else
+                    {
+                      i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
+                      --expFrac;
+                      if (i64 != 0)
+                        significandDigit++;
+                    }
+                }
+
+              d = static_cast<double>(i64);
+#else
+              // Use double to store significand in 32-bit architecture
+              d = static_cast<double>(use64bit ? i64 : i);
+#endif
+              useDouble = true;
+            }
+
+          while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+            {
+              if (significandDigit < 17)
+                {
+                  d = d * 10.0 + (s.TakePush() - '0');
+                  --expFrac;
+                  if (RAPIDJSON_LIKELY(d > 0.0))
+                    significandDigit++;
+                }
+              else
+                s.TakePush();
+            }
+        }
+      else
+        decimalPosition = s.Length(); // decimal position at the end of integer.
+
+      // Parse exp = e [ minus / plus ] 1*DIGIT
+      int exp = 0;
+      if (Consume(s, 'e') || Consume(s, 'E'))
+        {
+          if (!useDouble)
+            {
+              d = static_cast<double>(use64bit ? i64 : i);
+              useDouble = true;
+            }
+
+          bool expMinus = false;
+          if (Consume(s, '+'))
+            ;
+          else if (Consume(s, '-'))
+            expMinus = true;
+
+          if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+            {
+              exp = static_cast<int>(s.Take() - '0');
+              if (expMinus)
+                {
+                  // (exp + expFrac) must not underflow int => we're detecting when -exp gets
+                  // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
+                  // underflow territory):
+                  //
+                  //        -(exp * 10 + 9) + expFrac >= INT_MIN
+                  //   <=>  exp <= (expFrac - INT_MIN - 9) / 10
+                  RAPIDJSON_ASSERT(expFrac <= 0);
+                  int maxExp = (expFrac + 2147483639) / 10;
+
+                  while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+                    {
+                      exp = exp * 10 + static_cast<int>(s.Take() - '0');
+                      if (RAPIDJSON_UNLIKELY(exp > maxExp))
+                        {
+                          while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
+                            s.Take();
+                        }
+                    }
+                }
+              else    // positive exp
+                {
+                  int maxExp = 308 - expFrac;
+                  while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
+                    {
+                      exp = exp * 10 + static_cast<int>(s.Take() - '0');
+                      if (RAPIDJSON_UNLIKELY(exp > maxExp))
+                        RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
+                    }
+                }
+            }
+          else
+            RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
+
+          if (expMinus)
+            exp = -exp;
+        }
+
+      // Finish parsing, call event according to the type of number.
+      bool cont = true;
+
+      if (parseFlags & kParseNumbersAsStringsFlag)
+        {
+          if (parseFlags & kParseInsituFlag)
+            {
+              s.Pop();  // Pop stack no matter if it will be used or not.
+              typename InputStream::Ch *head = is.PutBegin();
+              const size_t length = s.Tell() - startOffset;
+              RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
+              // unable to insert the \0 character here, it will erase the comma after this number
+              const typename TargetEncoding::Ch *const str = reinterpret_cast<typename TargetEncoding::Ch *>(head);
+              cont = handler.RawNumber(str, SizeType(length), false);
+            }
+          else
+            {
+              SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
+              StringStream srcStream(s.Pop());
+              StackStream<typename TargetEncoding::Ch> dstStream(stack_);
+              while (numCharsToCopy--)
+                {
+                  Transcoder<UTF8<>, TargetEncoding>::Transcode(srcStream, dstStream);
+                }
+              dstStream.Put('\0');
+              const typename TargetEncoding::Ch *str = dstStream.Pop();
+              const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
+              cont = handler.RawNumber(str, SizeType(length), true);
+            }
+        }
+      else
+        {
+          size_t length = s.Length();
+          const char *decimal = s.Pop();  // Pop stack no matter if it will be used or not.
+
+          if (useDouble)
+            {
+              int p = exp + expFrac;
+              if (parseFlags & kParseFullPrecisionFlag)
+                d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
+              else
+                d = internal::StrtodNormalPrecision(d, p);
+
+              // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
+              if (d > (std::numeric_limits<double>::max)())
+                {
+                  // Overflow
+                  // TODO: internal::StrtodX should report overflow (or underflow)
+                  RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
+                }
+
+              cont = handler.Double(minus ? -d : d);
+            }
+          else if (useNanOrInf)
+            {
+              cont = handler.Double(d);
+            }
+          else
+            {
+              if (use64bit)
+                {
+                  if (minus)
+                    cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
+                  else
+                    cont = handler.Uint64(i64);
+                }
+              else
+                {
+                  if (minus)
+                    cont = handler.Int(static_cast<int32_t>(~i + 1));
+                  else
+                    cont = handler.Uint(i);
+                }
+            }
+        }
+      if (RAPIDJSON_UNLIKELY(!cont))
+        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
+    }
+
+    // Parse any JSON value
+    template<unsigned parseFlags, typename InputStream, typename Handler>
+    void ParseValue(InputStream &is, Handler &handler)
+    {
+      switch (is.Peek())
+        {
+          case 'n':
+            ParseNull  <parseFlags>(is, handler);
+            break;
+          case 't':
+            ParseTrue  <parseFlags>(is, handler);
+            break;
+          case 'f':
+            ParseFalse <parseFlags>(is, handler);
+            break;
+          case '"':
+            ParseString<parseFlags>(is, handler);
+            break;
+          case '{':
+            ParseObject<parseFlags>(is, handler);
+            break;
+          case '[':
+            ParseArray <parseFlags>(is, handler);
+            break;
+          default :
+            ParseNumber<parseFlags>(is, handler);
+            break;
+
+        }
+    }
+
+    // Iterative Parsing
+
+    // States
+    enum IterativeParsingState
+    {
+      IterativeParsingFinishState = 0, // sink states at top
+      IterativeParsingErrorState,      // sink states at top
+      IterativeParsingStartState,
+
+      // Object states
+      IterativeParsingObjectInitialState,
+      IterativeParsingMemberKeyState,
+      IterativeParsingMemberValueState,
+      IterativeParsingObjectFinishState,
+
+      // Array states
+      IterativeParsingArrayInitialState,
+      IterativeParsingElementState,
+      IterativeParsingArrayFinishState,
+
+      // Single value state
+      IterativeParsingValueState,
+
+      // Delimiter states (at bottom)
+      IterativeParsingElementDelimiterState,
+      IterativeParsingMemberDelimiterState,
+      IterativeParsingKeyValueDelimiterState,
+
+      cIterativeParsingStateCount
+    };
+
+    // Tokens
+    enum Token
+    {
+      LeftBracketToken = 0,
+      RightBracketToken,
+
+      LeftCurlyBracketToken,
+      RightCurlyBracketToken,
+
+      CommaToken,
+      ColonToken,
+
+      StringToken,
+      FalseToken,
+      TrueToken,
+      NullToken,
+      NumberToken,
+
+      kTokenCount
+    };
+
+    RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const
+    {
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#define N NumberToken
+#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
+      // Maps from ASCII to Token
+      static const unsigned char tokenMap[256] =
+      {
+        N16, // 00~0F
+        N16, // 10~1F
+        N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F
+        N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F
+        N16, // 40~4F
+        N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F
+        N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F
+        N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F
+        N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF
+      };
+#undef N
+#undef N16
+//!@endcond
+
+      if (sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256)
+        return static_cast<Token>(tokenMap[static_cast<unsigned char>(c)]);
+      else
+        return NumberToken;
+    }
+
+    RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const
+    {
+      // current state x one lookahead token -> new state
+      static const char G[cIterativeParsingStateCount][kTokenCount] =
+      {
+        // Finish(sink state)
+        {
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState
+        },
+        // Error(sink state)
+        {
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState
+        },
+        // Start
+        {
+          IterativeParsingArrayInitialState,  // Left bracket
+          IterativeParsingErrorState,         // Right bracket
+          IterativeParsingObjectInitialState, // Left curly bracket
+          IterativeParsingErrorState,         // Right curly bracket
+          IterativeParsingErrorState,         // Comma
+          IterativeParsingErrorState,         // Colon
+          IterativeParsingValueState,         // String
+          IterativeParsingValueState,         // False
+          IterativeParsingValueState,         // True
+          IterativeParsingValueState,         // Null
+          IterativeParsingValueState          // Number
+        },
+        // ObjectInitial
+        {
+          IterativeParsingErrorState,         // Left bracket
+          IterativeParsingErrorState,         // Right bracket
+          IterativeParsingErrorState,         // Left curly bracket
+          IterativeParsingObjectFinishState,  // Right curly bracket
+          IterativeParsingErrorState,         // Comma
+          IterativeParsingErrorState,         // Colon
+          IterativeParsingMemberKeyState,     // String
+          IterativeParsingErrorState,         // False
+          IterativeParsingErrorState,         // True
+          IterativeParsingErrorState,         // Null
+          IterativeParsingErrorState          // Number
+        },
+        // MemberKey
+        {
+          IterativeParsingErrorState,             // Left bracket
+          IterativeParsingErrorState,             // Right bracket
+          IterativeParsingErrorState,             // Left curly bracket
+          IterativeParsingErrorState,             // Right curly bracket
+          IterativeParsingErrorState,             // Comma
+          IterativeParsingKeyValueDelimiterState, // Colon
+          IterativeParsingErrorState,             // String
+          IterativeParsingErrorState,             // False
+          IterativeParsingErrorState,             // True
+          IterativeParsingErrorState,             // Null
+          IterativeParsingErrorState              // Number
+        },
+        // MemberValue
+        {
+          IterativeParsingErrorState,             // Left bracket
+          IterativeParsingErrorState,             // Right bracket
+          IterativeParsingErrorState,             // Left curly bracket
+          IterativeParsingObjectFinishState,      // Right curly bracket
+          IterativeParsingMemberDelimiterState,   // Comma
+          IterativeParsingErrorState,             // Colon
+          IterativeParsingErrorState,             // String
+          IterativeParsingErrorState,             // False
+          IterativeParsingErrorState,             // True
+          IterativeParsingErrorState,             // Null
+          IterativeParsingErrorState              // Number
+        },
+        // ObjectFinish(sink state)
+        {
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState
+        },
+        // ArrayInitial
+        {
+          IterativeParsingArrayInitialState,      // Left bracket(push Element state)
+          IterativeParsingArrayFinishState,       // Right bracket
+          IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
+          IterativeParsingErrorState,             // Right curly bracket
+          IterativeParsingErrorState,             // Comma
+          IterativeParsingErrorState,             // Colon
+          IterativeParsingElementState,           // String
+          IterativeParsingElementState,           // False
+          IterativeParsingElementState,           // True
+          IterativeParsingElementState,           // Null
+          IterativeParsingElementState            // Number
+        },
+        // Element
+        {
+          IterativeParsingErrorState,             // Left bracket
+          IterativeParsingArrayFinishState,       // Right bracket
+          IterativeParsingErrorState,             // Left curly bracket
+          IterativeParsingErrorState,             // Right curly bracket
+          IterativeParsingElementDelimiterState,  // Comma
+          IterativeParsingErrorState,             // Colon
+          IterativeParsingErrorState,             // String
+          IterativeParsingErrorState,             // False
+          IterativeParsingErrorState,             // True
+          IterativeParsingErrorState,             // Null
+          IterativeParsingErrorState              // Number
+        },
+        // ArrayFinish(sink state)
+        {
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState
+        },
+        // Single Value (sink state)
+        {
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
+          IterativeParsingErrorState
+        },
+        // ElementDelimiter
+        {
+          IterativeParsingArrayInitialState,      // Left bracket(push Element state)
+          IterativeParsingArrayFinishState,       // Right bracket
+          IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
+          IterativeParsingErrorState,             // Right curly bracket
+          IterativeParsingErrorState,             // Comma
+          IterativeParsingErrorState,             // Colon
+          IterativeParsingElementState,           // String
+          IterativeParsingElementState,           // False
+          IterativeParsingElementState,           // True
+          IterativeParsingElementState,           // Null
+          IterativeParsingElementState            // Number
+        },
+        // MemberDelimiter
+        {
+          IterativeParsingErrorState,         // Left bracket
+          IterativeParsingErrorState,         // Right bracket
+          IterativeParsingErrorState,         // Left curly bracket
+          IterativeParsingObjectFinishState,  // Right curly bracket
+          IterativeParsingErrorState,         // Comma
+          IterativeParsingErrorState,         // Colon
+          IterativeParsingMemberKeyState,     // String
+          IterativeParsingErrorState,         // False
+          IterativeParsingErrorState,         // True
+          IterativeParsingErrorState,         // Null
+          IterativeParsingErrorState          // Number
+        },
+        // KeyValueDelimiter
+        {
+          IterativeParsingArrayInitialState,      // Left bracket(push MemberValue state)
+          IterativeParsingErrorState,             // Right bracket
+          IterativeParsingObjectInitialState,     // Left curly bracket(push MemberValue state)
+          IterativeParsingErrorState,             // Right curly bracket
+          IterativeParsingErrorState,             // Comma
+          IterativeParsingErrorState,             // Colon
+          IterativeParsingMemberValueState,       // String
+          IterativeParsingMemberValueState,       // False
+          IterativeParsingMemberValueState,       // True
+          IterativeParsingMemberValueState,       // Null
+          IterativeParsingMemberValueState        // Number
+        },
+      }; // End of G
+
+      return static_cast<IterativeParsingState>(G[state][token]);
+    }
+
+    // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit().
+    // May return a new state on state pop.
+    template <unsigned parseFlags, typename InputStream, typename Handler>
+    RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream &is, Handler &handler)
+    {
+      (void)token;
+
+      switch (dst)
+        {
+          case IterativeParsingErrorState:
+            return dst;
+
+          case IterativeParsingObjectInitialState:
+          case IterativeParsingArrayInitialState:
+          {
+            // Push the state(Element or MemeberValue) if we are nested in another array or value of member.
+            // In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop.
+            IterativeParsingState n = src;
+            if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
+              n = IterativeParsingElementState;
+            else if (src == IterativeParsingKeyValueDelimiterState)
+              n = IterativeParsingMemberValueState;
+            // Push current state.
+            *stack_.template Push<SizeType>(1) = n;
+            // Initialize and push the member/element count.
+            *stack_.template Push<SizeType>(1) = 0;
+            // Call handler
+            bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
+            // On handler short circuits the parsing.
+            if (!hr)
+              {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
+                return IterativeParsingErrorState;
+              }
+            else
+              {
+                is.Take();
+                return dst;
+              }
+          }
+
+          case IterativeParsingMemberKeyState:
+            ParseString<parseFlags>(is, handler, true);
+            if (HasParseError())
+              return IterativeParsingErrorState;
+            else
+              return dst;
+
+          case IterativeParsingKeyValueDelimiterState:
+            RAPIDJSON_ASSERT(token == ColonToken);
+            is.Take();
+            return dst;
+
+          case IterativeParsingMemberValueState:
+            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
+            ParseValue<parseFlags>(is, handler);
+            if (HasParseError())
+              {
+                return IterativeParsingErrorState;
+              }
+            return dst;
+
+          case IterativeParsingElementState:
+            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
+            ParseValue<parseFlags>(is, handler);
+            if (HasParseError())
+              {
+                return IterativeParsingErrorState;
+              }
+            return dst;
+
+          case IterativeParsingMemberDelimiterState:
+          case IterativeParsingElementDelimiterState:
+            is.Take();
+            // Update member/element count.
+            *stack_.template Top<SizeType>() = *stack_.template Top<SizeType>() + 1;
+            return dst;
+
+          case IterativeParsingObjectFinishState:
+          {
+            // Transit from delimiter is only allowed when trailing commas are enabled
+            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingMemberDelimiterState)
+              {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorObjectMissName, is.Tell());
+                return IterativeParsingErrorState;
+              }
+            // Get member count.
+            SizeType c = *stack_.template Pop<SizeType>(1);
+            // If the object is not empty, count the last member.
+            if (src == IterativeParsingMemberValueState)
+              ++c;
+            // Restore the state.
+            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
+            // Transit to Finish state if this is the topmost scope.
+            if (n == IterativeParsingStartState)
+              n = IterativeParsingFinishState;
+            // Call handler
+            bool hr = handler.EndObject(c);
+            // On handler short circuits the parsing.
+            if (!hr)
+              {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
+                return IterativeParsingErrorState;
+              }
+            else
+              {
+                is.Take();
+                return n;
+              }
+          }
+
+          case IterativeParsingArrayFinishState:
+          {
+            // Transit from delimiter is only allowed when trailing commas are enabled
+            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingElementDelimiterState)
+              {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorValueInvalid, is.Tell());
+                return IterativeParsingErrorState;
+              }
+            // Get element count.
+            SizeType c = *stack_.template Pop<SizeType>(1);
+            // If the array is not empty, count the last element.
+            if (src == IterativeParsingElementState)
+              ++c;
+            // Restore the state.
+            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
+            // Transit to Finish state if this is the topmost scope.
+            if (n == IterativeParsingStartState)
+              n = IterativeParsingFinishState;
+            // Call handler
+            bool hr = handler.EndArray(c);
+            // On handler short circuits the parsing.
+            if (!hr)
+              {
+                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
+                return IterativeParsingErrorState;
+              }
+            else
+              {
+                is.Take();
+                return n;
+              }
+          }
+
+          default:
+            // This branch is for IterativeParsingValueState actually.
+            // Use `default:` rather than
+            // `case IterativeParsingValueState:` is for code coverage.
+
+            // The IterativeParsingStartState is not enumerated in this switch-case.
+            // It is impossible for that case. And it can be caught by following assertion.
+
+            // The IterativeParsingFinishState is not enumerated in this switch-case either.
+            // It is a "derivative" state which cannot triggered from Predict() directly.
+            // Therefore it cannot happen here. And it can be caught by following assertion.
+            RAPIDJSON_ASSERT(dst == IterativeParsingValueState);
+
+            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
+            ParseValue<parseFlags>(is, handler);
+            if (HasParseError())
+              {
+                return IterativeParsingErrorState;
+              }
+            return IterativeParsingFinishState;
+        }
+    }
+
+    template <typename InputStream>
+    void HandleError(IterativeParsingState src, InputStream &is)
+    {
+      if (HasParseError())
+        {
+          // Error flag has been set.
+          return;
+        }
+
+      switch (src)
+        {
+          case IterativeParsingStartState:
+            RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell());
+            return;
+          case IterativeParsingFinishState:
+            RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell());
+            return;
+          case IterativeParsingObjectInitialState:
+          case IterativeParsingMemberDelimiterState:
+            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
+            return;
+          case IterativeParsingMemberKeyState:
+            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
+            return;
+          case IterativeParsingMemberValueState:
+            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());
+            return;
+          case IterativeParsingKeyValueDelimiterState:
+          case IterativeParsingArrayInitialState:
+          case IterativeParsingElementDelimiterState:
+            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
+            return;
+          default:
+            RAPIDJSON_ASSERT(src == IterativeParsingElementState);
+            RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
+            return;
+        }
+    }
+
+    RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const
+    {
+      return s >= IterativeParsingElementDelimiterState;
+    }
+
+    RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const
+    {
+      return s <= IterativeParsingErrorState;
+    }
+
+    template <unsigned parseFlags, typename InputStream, typename Handler>
+    ParseResult IterativeParse(InputStream &is, Handler &handler)
+    {
+      parseResult_.Clear();
+      ClearStackOnExit scope(*this);
+      IterativeParsingState state = IterativeParsingStartState;
+
+      SkipWhitespaceAndComments<parseFlags>(is);
+      RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+      while (is.Peek() != '\0')
+        {
+          Token t = Tokenize(is.Peek());
+          IterativeParsingState n = Predict(state, t);
+          IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
+
+          if (d == IterativeParsingErrorState)
+            {
+              HandleError(state, is);
+              break;
+            }
+
+          state = d;
+
+          // Do not further consume streams if a root JSON has been parsed.
+          if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
+            break;
+
+          SkipWhitespaceAndComments<parseFlags>(is);
+          RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
+        }
+
+      // Handle the end of file.
+      if (state != IterativeParsingFinishState)
+        HandleError(state, is);
+
+      return parseResult_;
+    }
+
+    static const size_t kDefaultStackCapacity = 256;    //!< Default stack capacity in bytes for storing a single decoded string.
+    internal::Stack<StackAllocator> stack_;  //!< A stack for storing decoded string temporarily during non-destructive parsing.
+    ParseResult parseResult_;
+    IterativeParsingState state_;
+}; // class GenericReader
+
+//! Reader with UTF8 encoding and default allocator.
+typedef GenericReader<UTF8<>, UTF8<> > Reader;
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_READER_H_
diff --git a/contrib/world_builder/include/rapidjson/schema.h.bak b/contrib/world_builder/include/rapidjson/schema.h.bak
new file mode 100644
index 00000000000..66a90b3a44e
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/schema.h.bak
@@ -0,0 +1,2927 @@
+// Tencent is pleased to support the open source community by making RapidJSON available->
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip-> All rights reserved->
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License-> You may obtain a copy of the License at
+//
+// http://opensource->org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied-> See the License for the
+// specific language governing permissions and limitations under the License->
+
+#ifndef RAPIDJSON_SCHEMA_H_
+#define RAPIDJSON_SCHEMA_H_
+
+#include "document.h"
+#include "pointer.h"
+#include "stringbuffer.h"
+#include <cmath> // abs, floor
+
+#if !defined(RAPIDJSON_SCHEMA_USE_INTERNALREGEX)
+#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 1
+#else
+#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0
+#endif
+
+#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
+#define RAPIDJSON_SCHEMA_USE_STDREGEX 1
+#else
+#define RAPIDJSON_SCHEMA_USE_STDREGEX 0
+#endif
+
+#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
+#include "internal/regex.h"
+#elif RAPIDJSON_SCHEMA_USE_STDREGEX
+#include <regex>
+#endif
+
+#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX || RAPIDJSON_SCHEMA_USE_STDREGEX
+#define RAPIDJSON_SCHEMA_HAS_REGEX 1
+#else
+#define RAPIDJSON_SCHEMA_HAS_REGEX 0
+#endif
+
+#ifndef RAPIDJSON_SCHEMA_VERBOSE
+#define RAPIDJSON_SCHEMA_VERBOSE 0
+#endif
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+#include "stringbuffer.h"
+#endif
+
+RAPIDJSON_DIAG_PUSH
+
+#if defined(__GNUC__)
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_OFF(weak-vtables)
+RAPIDJSON_DIAG_OFF(exit-time-destructors)
+RAPIDJSON_DIAG_OFF(c++98-compat-pedantic)
+RAPIDJSON_DIAG_OFF(variadic-macros)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Verbose Utilities
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+
+namespace internal
+{
+
+  inline void PrintInvalidKeyword(const char *keyword)
+  {
+    printf("Fail keyword: %s\n", keyword);
+  }
+
+  inline void PrintInvalidKeyword(const wchar_t *keyword)
+  {
+    wprintf(L"Fail keyword: %ls\n", keyword);
+  }
+
+  inline void PrintInvalidDocument(const char *document)
+  {
+    printf("Fail document: %s\n\n", document);
+  }
+
+  inline void PrintInvalidDocument(const wchar_t *document)
+  {
+    wprintf(L"Fail document: %ls\n\n", document);
+  }
+
+  inline void PrintValidatorPointers(unsigned depth, const char *s, const char *d)
+  {
+    printf("S: %*s%s\nD: %*s%s\n\n", depth * 4, " ", s, depth * 4, " ", d);
+  }
+
+  inline void PrintValidatorPointers(unsigned depth, const wchar_t *s, const wchar_t *d)
+  {
+    wprintf(L"S: %*ls%ls\nD: %*ls%ls\n\n", depth * 4, L" ", s, depth * 4, L" ", d);
+  }
+
+} // namespace internal
+
+#endif // RAPIDJSON_SCHEMA_VERBOSE
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_INVALID_KEYWORD_RETURN
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) internal::PrintInvalidKeyword(keyword)
+#else
+#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword)
+#endif
+
+#define RAPIDJSON_INVALID_KEYWORD_RETURN(keyword)\
+  RAPIDJSON_MULTILINEMACRO_BEGIN\
+  context.invalidKeyword = keyword.GetString();\
+  RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword.GetString());\
+  return false;\
+  RAPIDJSON_MULTILINEMACRO_END
+
+///////////////////////////////////////////////////////////////////////////////
+// Forward declarations
+
+template <typename ValueType, typename Allocator>
+class GenericSchemaDocument;
+
+namespace internal
+{
+
+  template <typename SchemaDocumentType>
+  class Schema;
+
+///////////////////////////////////////////////////////////////////////////////
+// ISchemaValidator
+
+  class ISchemaValidator
+  {
+    public:
+      virtual ~ISchemaValidator() {}
+      virtual bool IsValid() const = 0;
+  };
+
+///////////////////////////////////////////////////////////////////////////////
+// ISchemaStateFactory
+
+  template <typename SchemaType>
+  class ISchemaStateFactory
+  {
+    public:
+      virtual ~ISchemaStateFactory() {}
+      virtual ISchemaValidator *CreateSchemaValidator(const SchemaType &) = 0;
+      virtual void DestroySchemaValidator(ISchemaValidator *validator) = 0;
+      virtual void *CreateHasher() = 0;
+      virtual uint64_t GetHashCode(void *hasher) = 0;
+      virtual void DestroryHasher(void *hasher) = 0;
+      virtual void *MallocState(size_t size) = 0;
+      virtual void FreeState(void *p) = 0;
+  };
+
+///////////////////////////////////////////////////////////////////////////////
+// IValidationErrorHandler
+
+  template <typename SchemaType>
+  class IValidationErrorHandler
+  {
+    public:
+      typedef typename SchemaType::Ch Ch;
+      typedef typename SchemaType::SValue SValue;
+
+      virtual ~IValidationErrorHandler() {}
+
+      virtual void NotMultipleOf(int64_t actual, const SValue &expected) = 0;
+      virtual void NotMultipleOf(uint64_t actual, const SValue &expected) = 0;
+      virtual void NotMultipleOf(double actual, const SValue &expected) = 0;
+      virtual void AboveMaximum(int64_t actual, const SValue &expected, bool exclusive) = 0;
+      virtual void AboveMaximum(uint64_t actual, const SValue &expected, bool exclusive) = 0;
+      virtual void AboveMaximum(double actual, const SValue &expected, bool exclusive) = 0;
+      virtual void BelowMinimum(int64_t actual, const SValue &expected, bool exclusive) = 0;
+      virtual void BelowMinimum(uint64_t actual, const SValue &expected, bool exclusive) = 0;
+      virtual void BelowMinimum(double actual, const SValue &expected, bool exclusive) = 0;
+
+      virtual void TooLong(const Ch *str, SizeType length, SizeType expected) = 0;
+      virtual void TooShort(const Ch *str, SizeType length, SizeType expected) = 0;
+      virtual void DoesNotMatch(const Ch *str, SizeType length) = 0;
+
+      virtual void DisallowedItem(SizeType index) = 0;
+      virtual void TooFewItems(SizeType actualCount, SizeType expectedCount) = 0;
+      virtual void TooManyItems(SizeType actualCount, SizeType expectedCount) = 0;
+      virtual void DuplicateItems(SizeType index1, SizeType index2) = 0;
+
+      virtual void TooManyProperties(SizeType actualCount, SizeType expectedCount) = 0;
+      virtual void TooFewProperties(SizeType actualCount, SizeType expectedCount) = 0;
+      virtual void StartMissingProperties() = 0;
+      virtual void AddMissingProperty(const SValue &name) = 0;
+      virtual bool EndMissingProperties() = 0;
+      virtual void PropertyViolations(ISchemaValidator **subvalidators, SizeType count) = 0;
+      virtual void DisallowedProperty(const Ch *name, SizeType length) = 0;
+
+      virtual void StartDependencyErrors() = 0;
+      virtual void StartMissingDependentProperties() = 0;
+      virtual void AddMissingDependentProperty(const SValue &targetName) = 0;
+      virtual void EndMissingDependentProperties(const SValue &sourceName) = 0;
+      virtual void AddDependencySchemaError(const SValue &souceName, ISchemaValidator *subvalidator) = 0;
+      virtual bool EndDependencyErrors() = 0;
+
+      virtual void DisallowedValue() = 0;
+      virtual void StartDisallowedType() = 0;
+      virtual void AddExpectedType(const typename SchemaType::ValueType &expectedType) = 0;
+      virtual void EndDisallowedType(const typename SchemaType::ValueType &actualType) = 0;
+      virtual void NotAllOf(ISchemaValidator **subvalidators, SizeType count) = 0;
+      virtual void NoneOf(ISchemaValidator **subvalidators, SizeType count) = 0;
+      virtual void NotOneOf(ISchemaValidator **subvalidators, SizeType count) = 0;
+      virtual void Disallowed() = 0;
+  };
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Hasher
+
+// For comparison of compound value
+  template<typename Encoding, typename Allocator>
+  class Hasher
+  {
+    public:
+      typedef typename Encoding::Ch Ch;
+
+      Hasher(Allocator *allocator = 0, size_t stackCapacity = kDefaultSize) : stack_(allocator, stackCapacity) {}
+
+      bool Null()
+      {
+        return WriteType(kNullType);
+      }
+      bool Bool(bool b)
+      {
+        return WriteType(b ? kTrueType : kFalseType);
+      }
+      bool Int(int i)
+      {
+        Number n;
+        n.u.i = i;
+        n.d = static_cast<double>(i);
+        return WriteNumber(n);
+      }
+      bool Uint(unsigned u)
+      {
+        Number n;
+        n.u.u = u;
+        n.d = static_cast<double>(u);
+        return WriteNumber(n);
+      }
+      bool Int64(int64_t i)
+      {
+        Number n;
+        n.u.i = i;
+        n.d = static_cast<double>(i);
+        return WriteNumber(n);
+      }
+      bool Uint64(uint64_t u)
+      {
+        Number n;
+        n.u.u = u;
+        n.d = static_cast<double>(u);
+        return WriteNumber(n);
+      }
+      bool Double(double d)
+      {
+        Number n;
+        if (d < 0) n.u.i = static_cast<int64_t>(d);
+        else       n.u.u = static_cast<uint64_t>(d);
+        n.d = d;
+        return WriteNumber(n);
+      }
+
+      bool RawNumber(const Ch *str, SizeType len, bool)
+      {
+        WriteBuffer(kNumberType, str, len * sizeof(Ch));
+        return true;
+      }
+
+      bool String(const Ch *str, SizeType len, bool)
+      {
+        WriteBuffer(kStringType, str, len * sizeof(Ch));
+        return true;
+      }
+
+      bool StartObject()
+      {
+        return true;
+      }
+      bool Key(const Ch *str, SizeType len, bool copy)
+      {
+        return String(str, len, copy);
+      }
+      bool EndObject(SizeType memberCount)
+      {
+        uint64_t h = Hash(0, kObjectType);
+        uint64_t *kv = stack_.template Pop<uint64_t>(memberCount * 2);
+        for (SizeType i = 0; i < memberCount; i++)
+          h ^= Hash(kv[i * 2], kv[i * 2 + 1]);  // Use xor to achieve member order insensitive
+        *stack_.template Push<uint64_t>() = h;
+        return true;
+      }
+
+      bool StartArray()
+      {
+        return true;
+      }
+      bool EndArray(SizeType elementCount)
+      {
+        uint64_t h = Hash(0, kArrayType);
+        uint64_t *e = stack_.template Pop<uint64_t>(elementCount);
+        for (SizeType i = 0; i < elementCount; i++)
+          h = Hash(h, e[i]); // Use hash to achieve element order sensitive
+        *stack_.template Push<uint64_t>() = h;
+        return true;
+      }
+
+      bool IsValid() const
+      {
+        return stack_.GetSize() == sizeof(uint64_t);
+      }
+
+      uint64_t GetHashCode() const
+      {
+        RAPIDJSON_ASSERT(IsValid());
+        return *stack_.template Top<uint64_t>();
+      }
+
+    private:
+      static const size_t kDefaultSize = 256;
+      struct Number
+      {
+        union U
+        {
+          uint64_t u;
+          int64_t i;
+        } u;
+        double d;
+      };
+
+      bool WriteType(Type type)
+      {
+        return WriteBuffer(type, 0, 0);
+      }
+
+      bool WriteNumber(const Number &n)
+      {
+        return WriteBuffer(kNumberType, &n, sizeof(n));
+      }
+
+      bool WriteBuffer(Type type, const void *data, size_t len)
+      {
+        // FNV-1a from http://isthe.com/chongo/tech/comp/fnv/
+        uint64_t h = Hash(RAPIDJSON_UINT64_C2(0x84222325, 0xcbf29ce4), type);
+        const unsigned char *d = static_cast<const unsigned char *>(data);
+        for (size_t i = 0; i < len; i++)
+          h = Hash(h, d[i]);
+        *stack_.template Push<uint64_t>() = h;
+        return true;
+      }
+
+      static uint64_t Hash(uint64_t h, uint64_t d)
+      {
+        static const uint64_t kPrime = RAPIDJSON_UINT64_C2(0x00000100, 0x000001b3);
+        h ^= d;
+        h *= kPrime;
+        return h;
+      }
+
+      Stack<Allocator> stack_;
+  };
+
+///////////////////////////////////////////////////////////////////////////////
+// SchemaValidationContext
+
+  template <typename SchemaDocumentType>
+  struct SchemaValidationContext
+  {
+    typedef Schema<SchemaDocumentType> SchemaType;
+    typedef ISchemaStateFactory<SchemaType> SchemaValidatorFactoryType;
+    typedef IValidationErrorHandler<SchemaType> ErrorHandlerType;
+    typedef typename SchemaType::ValueType ValueType;
+    typedef typename ValueType::Ch Ch;
+
+    enum PatternValidatorType
+    {
+      kPatternValidatorOnly,
+      kPatternValidatorWithProperty,
+      kPatternValidatorWithAdditionalProperty
+    };
+
+    SchemaValidationContext(SchemaValidatorFactoryType &f, ErrorHandlerType &eh, const SchemaType *s) :
+      factory(f),
+      error_handler(eh),
+      schema(s),
+      valueSchema(),
+      invalidKeyword(),
+      hasher(),
+      arrayElementHashCodes(),
+      validators(),
+      validatorCount(),
+      patternPropertiesValidators(),
+      patternPropertiesValidatorCount(),
+      patternPropertiesSchemas(),
+      patternPropertiesSchemaCount(),
+      valuePatternValidatorType(kPatternValidatorOnly),
+      propertyExist(),
+      inArray(false),
+      valueUniqueness(false),
+      arrayUniqueness(false)
+    {
+    }
+
+    ~SchemaValidationContext()
+    {
+      if (hasher)
+        factory.DestroryHasher(hasher);
+      if (validators)
+        {
+          for (SizeType i = 0; i < validatorCount; i++)
+            factory.DestroySchemaValidator(validators[i]);
+          factory.FreeState(validators);
+        }
+      if (patternPropertiesValidators)
+        {
+          for (SizeType i = 0; i < patternPropertiesValidatorCount; i++)
+            factory.DestroySchemaValidator(patternPropertiesValidators[i]);
+          factory.FreeState(patternPropertiesValidators);
+        }
+      if (patternPropertiesSchemas)
+        factory.FreeState(patternPropertiesSchemas);
+      if (propertyExist)
+        factory.FreeState(propertyExist);
+    }
+
+    SchemaValidatorFactoryType &factory;
+    ErrorHandlerType &error_handler;
+    const SchemaType *schema;
+    const SchemaType *valueSchema;
+    const Ch *invalidKeyword;
+    void *hasher; // Only validator access
+    void *arrayElementHashCodes; // Only validator access this
+    ISchemaValidator **validators;
+    SizeType validatorCount;
+    ISchemaValidator **patternPropertiesValidators;
+    SizeType patternPropertiesValidatorCount;
+    const SchemaType **patternPropertiesSchemas;
+    SizeType patternPropertiesSchemaCount;
+    PatternValidatorType valuePatternValidatorType;
+    PatternValidatorType objectPatternValidatorType;
+    SizeType arrayElementIndex;
+    bool *propertyExist;
+    bool inArray;
+    bool valueUniqueness;
+    bool arrayUniqueness;
+  };
+
+///////////////////////////////////////////////////////////////////////////////
+// Schema
+
+  template <typename SchemaDocumentType>
+  class Schema
+  {
+    public:
+      typedef typename SchemaDocumentType::ValueType ValueType;
+      typedef typename SchemaDocumentType::AllocatorType AllocatorType;
+      typedef typename SchemaDocumentType::PointerType PointerType;
+      typedef typename ValueType::EncodingType EncodingType;
+      typedef typename EncodingType::Ch Ch;
+      typedef SchemaValidationContext<SchemaDocumentType> Context;
+      typedef Schema<SchemaDocumentType> SchemaType;
+      typedef GenericValue<EncodingType, AllocatorType> SValue;
+      typedef IValidationErrorHandler<Schema> ErrorHandler;
+      friend class GenericSchemaDocument<ValueType, AllocatorType>;
+
+      Schema(SchemaDocumentType *schemaDocument, const PointerType &p, const ValueType &value, const ValueType &document, AllocatorType *allocator) :
+        allocator_(allocator),
+        uri_(schemaDocument->GetURI(), *allocator),
+        pointer_(p),
+        typeless_(schemaDocument->GetTypeless()),
+        enum_(),
+        enumCount_(),
+        not_(),
+        type_((1 << kTotalSchemaType) - 1), // typeless
+        validatorCount_(),
+        notValidatorIndex_(),
+        properties_(),
+        additionalPropertiesSchema_(),
+        patternProperties_(),
+        patternPropertyCount_(),
+        propertyCount_(),
+        minProperties_(),
+        maxProperties_(SizeType(~0)),
+        additionalProperties_(true),
+        hasDependencies_(),
+        hasRequired_(),
+        hasSchemaDependencies_(),
+        additionalItemsSchema_(),
+        itemsList_(),
+        itemsTuple_(),
+        itemsTupleCount_(),
+        minItems_(),
+        maxItems_(SizeType(~0)),
+        additionalItems_(true),
+        uniqueItems_(false),
+        pattern_(),
+        minLength_(0),
+        maxLength_(~SizeType(0)),
+        exclusiveMinimum_(false),
+        exclusiveMaximum_(false),
+        defaultValueLength_(0)
+      {
+        typedef typename ValueType::ConstValueIterator ConstValueIterator;
+        typedef typename ValueType::ConstMemberIterator ConstMemberIterator;
+
+        if (!value.IsObject())
+          return;
+
+        if (const ValueType *v = GetMember(value, GetTypeString()))
+          {
+            type_ = 0;
+            if (v->IsString())
+              AddType(*v);
+            else if (v->IsArray())
+              for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr)
+                AddType(*itr);
+          }
+
+        if (const ValueType *v = GetMember(value, GetEnumString()))
+          if (v->IsArray() && v->Size() > 0)
+            {
+              enum_ = static_cast<uint64_t *>(allocator_->Malloc(sizeof(uint64_t) * v->Size()));
+              for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr)
+                {
+                  typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
+                  char buffer[256u + 24];
+                  MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer));
+                  EnumHasherType h(&hasherAllocator, 256);
+                  itr->Accept(h);
+                  enum_[enumCount_++] = h.GetHashCode();
+                }
+            }
+
+        if (schemaDocument)
+          {
+            AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document);
+            AssignIfExist(anyOf_, *schemaDocument, p, value, GetAnyOfString(), document);
+            AssignIfExist(oneOf_, *schemaDocument, p, value, GetOneOfString(), document);
+          }
+
+        if (const ValueType *v = GetMember(value, GetNotString()))
+          {
+            schemaDocument->CreateSchema(&not_, p.Append(GetNotString(), allocator_), *v, document);
+            notValidatorIndex_ = validatorCount_;
+            validatorCount_++;
+          }
+
+        // Object
+
+        const ValueType *properties = GetMember(value, GetPropertiesString());
+        const ValueType *required = GetMember(value, GetRequiredString());
+        const ValueType *dependencies = GetMember(value, GetDependenciesString());
+        {
+          // Gather properties from properties/required/dependencies
+          SValue allProperties(kArrayType);
+
+          if (properties && properties->IsObject())
+            for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr)
+              AddUniqueElement(allProperties, itr->name);
+
+          if (required && required->IsArray())
+            for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
+              if (itr->IsString())
+                AddUniqueElement(allProperties, *itr);
+
+          if (dependencies && dependencies->IsObject())
+            for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr)
+              {
+                AddUniqueElement(allProperties, itr->name);
+                if (itr->value.IsArray())
+                  for (ConstValueIterator i = itr->value.Begin(); i != itr->value.End(); ++i)
+                    if (i->IsString())
+                      AddUniqueElement(allProperties, *i);
+              }
+
+          if (allProperties.Size() > 0)
+            {
+              propertyCount_ = allProperties.Size();
+              properties_ = static_cast<Property *>(allocator_->Malloc(sizeof(Property) * propertyCount_));
+              for (SizeType i = 0; i < propertyCount_; i++)
+                {
+                  new (&properties_[i]) Property();
+                  properties_[i].name = allProperties[i];
+                  properties_[i].schema = typeless_;
+                }
+            }
+        }
+
+        if (properties && properties->IsObject())
+          {
+            PointerType q = p.Append(GetPropertiesString(), allocator_);
+            for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr)
+              {
+                SizeType index;
+                if (FindPropertyIndex(itr->name, &index))
+                  schemaDocument->CreateSchema(&properties_[index].schema, q.Append(itr->name, allocator_), itr->value, document);
+              }
+          }
+
+        if (const ValueType *v = GetMember(value, GetPatternPropertiesString()))
+          {
+            PointerType q = p.Append(GetPatternPropertiesString(), allocator_);
+            patternProperties_ = static_cast<PatternProperty *>(allocator_->Malloc(sizeof(PatternProperty) * v->MemberCount()));
+            patternPropertyCount_ = 0;
+
+            for (ConstMemberIterator itr = v->MemberBegin(); itr != v->MemberEnd(); ++itr)
+              {
+                new (&patternProperties_[patternPropertyCount_]) PatternProperty();
+                patternProperties_[patternPropertyCount_].pattern = CreatePattern(itr->name);
+                schemaDocument->CreateSchema(&patternProperties_[patternPropertyCount_].schema, q.Append(itr->name, allocator_), itr->value, document);
+                patternPropertyCount_++;
+              }
+          }
+
+        if (required && required->IsArray())
+          for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
+            if (itr->IsString())
+              {
+                SizeType index;
+                if (FindPropertyIndex(*itr, &index))
+                  {
+                    properties_[index].required = true;
+                    hasRequired_ = true;
+                  }
+              }
+
+        if (dependencies && dependencies->IsObject())
+          {
+            PointerType q = p.Append(GetDependenciesString(), allocator_);
+            hasDependencies_ = true;
+            for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr)
+              {
+                SizeType sourceIndex = 0;
+                if (FindPropertyIndex(itr->name, &sourceIndex))
+                  {
+                    if (itr->value.IsArray())
+                      {
+                        properties_[sourceIndex].dependencies = static_cast<bool *>(allocator_->Malloc(sizeof(bool) * propertyCount_));
+                        std::memset(properties_[sourceIndex].dependencies, 0, sizeof(bool)* propertyCount_);
+                        for (ConstValueIterator targetItr = itr->value.Begin(); targetItr != itr->value.End(); ++targetItr)
+                          {
+                            SizeType targetIndex = 0;
+                            if (FindPropertyIndex(*targetItr, &targetIndex))
+                              properties_[sourceIndex].dependencies[targetIndex] = true;
+                          }
+                      }
+                    else if (itr->value.IsObject())
+                      {
+                        hasSchemaDependencies_ = true;
+                        schemaDocument->CreateSchema(&properties_[sourceIndex].dependenciesSchema, q.Append(itr->name, allocator_), itr->value, document);
+                        properties_[sourceIndex].dependenciesValidatorIndex = validatorCount_;
+                        validatorCount_++;
+                      }
+                  }
+              }
+          }
+
+        if (const ValueType *v = GetMember(value, GetAdditionalPropertiesString()))
+          {
+            if (v->IsBool())
+              additionalProperties_ = v->GetBool();
+            else if (v->IsObject())
+              schemaDocument->CreateSchema(&additionalPropertiesSchema_, p.Append(GetAdditionalPropertiesString(), allocator_), *v, document);
+          }
+
+        AssignIfExist(minProperties_, value, GetMinPropertiesString());
+        AssignIfExist(maxProperties_, value, GetMaxPropertiesString());
+
+        // Array
+        if (const ValueType *v = GetMember(value, GetItemsString()))
+          {
+            PointerType q = p.Append(GetItemsString(), allocator_);
+            if (v->IsObject()) // List validation
+              schemaDocument->CreateSchema(&itemsList_, q, *v, document);
+            else if (v->IsArray())   // Tuple validation
+              {
+                itemsTuple_ = static_cast<const Schema **>(allocator_->Malloc(sizeof(const Schema *) * v->Size()));
+                SizeType index = 0;
+                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr, index++)
+                  schemaDocument->CreateSchema(&itemsTuple_[itemsTupleCount_++], q.Append(index, allocator_), *itr, document);
+              }
+          }
+
+        AssignIfExist(minItems_, value, GetMinItemsString());
+        AssignIfExist(maxItems_, value, GetMaxItemsString());
+
+        if (const ValueType *v = GetMember(value, GetAdditionalItemsString()))
+          {
+            if (v->IsBool())
+              additionalItems_ = v->GetBool();
+            else if (v->IsObject())
+              schemaDocument->CreateSchema(&additionalItemsSchema_, p.Append(GetAdditionalItemsString(), allocator_), *v, document);
+          }
+
+        AssignIfExist(uniqueItems_, value, GetUniqueItemsString());
+
+        // String
+        AssignIfExist(minLength_, value, GetMinLengthString());
+        AssignIfExist(maxLength_, value, GetMaxLengthString());
+
+        if (const ValueType *v = GetMember(value, GetPatternString()))
+          pattern_ = CreatePattern(*v);
+
+        // Number
+        if (const ValueType *v = GetMember(value, GetMinimumString()))
+          if (v->IsNumber())
+            minimum_.CopyFrom(*v, *allocator_);
+
+        if (const ValueType *v = GetMember(value, GetMaximumString()))
+          if (v->IsNumber())
+            maximum_.CopyFrom(*v, *allocator_);
+
+        AssignIfExist(exclusiveMinimum_, value, GetExclusiveMinimumString());
+        AssignIfExist(exclusiveMaximum_, value, GetExclusiveMaximumString());
+
+        if (const ValueType *v = GetMember(value, GetMultipleOfString()))
+          if (v->IsNumber() && v->GetDouble() > 0.0)
+            multipleOf_.CopyFrom(*v, *allocator_);
+
+        // Default
+        if (const ValueType *v = GetMember(value, GetDefaultValueString()))
+          if (v->IsString())
+            defaultValueLength_ = v->GetStringLength();
+
+      }
+
+      ~Schema()
+      {
+        AllocatorType::Free(enum_);
+        if (properties_)
+          {
+            for (SizeType i = 0; i < propertyCount_; i++)
+              properties_[i].~Property();
+            AllocatorType::Free(properties_);
+          }
+        if (patternProperties_)
+          {
+            for (SizeType i = 0; i < patternPropertyCount_; i++)
+              patternProperties_[i].~PatternProperty();
+            AllocatorType::Free(patternProperties_);
+          }
+        AllocatorType::Free(itemsTuple_);
+#if RAPIDJSON_SCHEMA_HAS_REGEX
+        if (pattern_)
+          {
+            pattern_->~RegexType();
+            AllocatorType::Free(pattern_);
+          }
+#endif
+      }
+
+      const SValue &GetURI() const
+      {
+        return uri_;
+      }
+
+      const PointerType &GetPointer() const
+      {
+        return pointer_;
+      }
+
+      bool BeginValue(Context &context) const
+      {
+        if (context.inArray)
+          {
+            if (uniqueItems_)
+              context.valueUniqueness = true;
+
+            if (itemsList_)
+              context.valueSchema = itemsList_;
+            else if (itemsTuple_)
+              {
+                if (context.arrayElementIndex < itemsTupleCount_)
+                  context.valueSchema = itemsTuple_[context.arrayElementIndex];
+                else if (additionalItemsSchema_)
+                  context.valueSchema = additionalItemsSchema_;
+                else if (additionalItems_)
+                  context.valueSchema = typeless_;
+                else
+                  {
+                    context.error_handler.DisallowedItem(context.arrayElementIndex);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString());
+                  }
+              }
+            else
+              context.valueSchema = typeless_;
+
+            context.arrayElementIndex++;
+          }
+        return true;
+      }
+
+      RAPIDJSON_FORCEINLINE bool EndValue(Context &context) const
+      {
+        if (context.patternPropertiesValidatorCount > 0)
+          {
+            bool otherValid = false;
+            SizeType count = context.patternPropertiesValidatorCount;
+            if (context.objectPatternValidatorType != Context::kPatternValidatorOnly)
+              otherValid = context.patternPropertiesValidators[--count]->IsValid();
+
+            bool patternValid = true;
+            for (SizeType i = 0; i < count; i++)
+              if (!context.patternPropertiesValidators[i]->IsValid())
+                {
+                  patternValid = false;
+                  break;
+                }
+
+            if (context.objectPatternValidatorType == Context::kPatternValidatorOnly)
+              {
+                if (!patternValid)
+                  {
+                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+                  }
+              }
+            else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty)
+              {
+                if (!patternValid || !otherValid)
+                  {
+                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+                  }
+              }
+            else if (!patternValid && !otherValid)   // kPatternValidatorWithAdditionalProperty)
+              {
+                context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
+                RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
+              }
+          }
+
+        if (enum_)
+          {
+            const uint64_t h = context.factory.GetHashCode(context.hasher);
+            for (SizeType i = 0; i < enumCount_; i++)
+              if (enum_[i] == h)
+                goto foundEnum;
+            context.error_handler.DisallowedValue();
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetEnumString());
+          foundEnum:
+            ;
+          }
+
+        if (allOf_.schemas)
+          for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++)
+            if (!context.validators[i]->IsValid())
+              {
+                context.error_handler.NotAllOf(&context.validators[allOf_.begin], allOf_.count);
+                RAPIDJSON_INVALID_KEYWORD_RETURN(GetAllOfString());
+              }
+
+        if (anyOf_.schemas)
+          {
+            for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++)
+              if (context.validators[i]->IsValid())
+                goto foundAny;
+            context.error_handler.NoneOf(&context.validators[anyOf_.begin], anyOf_.count);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetAnyOfString());
+          foundAny:
+            ;
+          }
+
+        if (oneOf_.schemas)
+          {
+            bool oneValid = false;
+            for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
+              if (context.validators[i]->IsValid())
+                {
+                  if (oneValid)
+                    {
+                      context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
+                      RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
+                    }
+                  else
+                    oneValid = true;
+                }
+            if (!oneValid)
+              {
+                context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
+                RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
+              }
+          }
+
+        if (not_ && context.validators[notValidatorIndex_]->IsValid())
+          {
+            context.error_handler.Disallowed();
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString());
+          }
+
+        return true;
+      }
+
+      bool Null(Context &context) const
+      {
+        if (!(type_ & (1 << kNullSchemaType)))
+          {
+            DisallowedType(context, GetNullString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+          }
+        return CreateParallelValidator(context);
+      }
+
+      bool Bool(Context &context, bool) const
+      {
+        if (!(type_ & (1 << kBooleanSchemaType)))
+          {
+            DisallowedType(context, GetBooleanString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+          }
+        return CreateParallelValidator(context);
+      }
+
+      bool Int(Context &context, int i) const
+      {
+        if (!CheckInt(context, i))
+          return false;
+        return CreateParallelValidator(context);
+      }
+
+      bool Uint(Context &context, unsigned u) const
+      {
+        if (!CheckUint(context, u))
+          return false;
+        return CreateParallelValidator(context);
+      }
+
+      bool Int64(Context &context, int64_t i) const
+      {
+        if (!CheckInt(context, i))
+          return false;
+        return CreateParallelValidator(context);
+      }
+
+      bool Uint64(Context &context, uint64_t u) const
+      {
+        if (!CheckUint(context, u))
+          return false;
+        return CreateParallelValidator(context);
+      }
+
+      bool Double(Context &context, double d) const
+      {
+        if (!(type_ & (1 << kNumberSchemaType)))
+          {
+            DisallowedType(context, GetNumberString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+          }
+
+        if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
+          return false;
+
+        if (!maximum_.IsNull() && !CheckDoubleMaximum(context, d))
+          return false;
+
+        if (!multipleOf_.IsNull() && !CheckDoubleMultipleOf(context, d))
+          return false;
+
+        return CreateParallelValidator(context);
+      }
+
+      bool String(Context &context, const Ch *str, SizeType length, bool) const
+      {
+        if (!(type_ & (1 << kStringSchemaType)))
+          {
+            DisallowedType(context, GetStringString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+          }
+
+        if (minLength_ != 0 || maxLength_ != SizeType(~0))
+          {
+            SizeType count;
+            if (internal::CountStringCodePoint<EncodingType>(str, length, &count))
+              {
+                if (count < minLength_)
+                  {
+                    context.error_handler.TooShort(str, length, minLength_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString());
+                  }
+                if (count > maxLength_)
+                  {
+                    context.error_handler.TooLong(str, length, maxLength_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString());
+                  }
+              }
+          }
+
+        if (pattern_ && !IsPatternMatch(pattern_, str, length))
+          {
+            context.error_handler.DoesNotMatch(str, length);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString());
+          }
+
+        return CreateParallelValidator(context);
+      }
+
+      bool StartObject(Context &context) const
+      {
+        if (!(type_ & (1 << kObjectSchemaType)))
+          {
+            DisallowedType(context, GetObjectString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+          }
+
+        if (hasDependencies_ || hasRequired_)
+          {
+            context.propertyExist = static_cast<bool *>(context.factory.MallocState(sizeof(bool) * propertyCount_));
+            std::memset(context.propertyExist, 0, sizeof(bool) * propertyCount_);
+          }
+
+        if (patternProperties_)   // pre-allocate schema array
+          {
+            SizeType count = patternPropertyCount_ + 1; // extra for valuePatternValidatorType
+            context.patternPropertiesSchemas = static_cast<const SchemaType **>(context.factory.MallocState(sizeof(const SchemaType *) * count));
+            context.patternPropertiesSchemaCount = 0;
+            std::memset(context.patternPropertiesSchemas, 0, sizeof(SchemaType *) * count);
+          }
+
+        return CreateParallelValidator(context);
+      }
+
+      bool Key(Context &context, const Ch *str, SizeType len, bool) const
+      {
+        if (patternProperties_)
+          {
+            context.patternPropertiesSchemaCount = 0;
+            for (SizeType i = 0; i < patternPropertyCount_; i++)
+              if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len))
+                {
+                  context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema;
+                  context.valueSchema = typeless_;
+                }
+          }
+
+        SizeType index;
+        if (FindPropertyIndex(ValueType(str, len).Move(), &index))
+          {
+            if (context.patternPropertiesSchemaCount > 0)
+              {
+                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema;
+                context.valueSchema = typeless_;
+                context.valuePatternValidatorType = Context::kPatternValidatorWithProperty;
+              }
+            else
+              context.valueSchema = properties_[index].schema;
+
+            if (context.propertyExist)
+              context.propertyExist[index] = true;
+
+            return true;
+          }
+
+        if (additionalPropertiesSchema_)
+          {
+            if (additionalPropertiesSchema_ && context.patternPropertiesSchemaCount > 0)
+              {
+                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_;
+                context.valueSchema = typeless_;
+                context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty;
+              }
+            else
+              context.valueSchema = additionalPropertiesSchema_;
+            return true;
+          }
+        else if (additionalProperties_)
+          {
+            context.valueSchema = typeless_;
+            return true;
+          }
+
+        if (context.patternPropertiesSchemaCount == 0)   // patternProperties are not additional properties
+          {
+            context.error_handler.DisallowedProperty(str, len);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString());
+          }
+
+        return true;
+      }
+
+      bool EndObject(Context &context, SizeType memberCount) const
+      {
+        if (hasRequired_)
+          {
+            context.error_handler.StartMissingProperties();
+            for (SizeType index = 0; index < propertyCount_; index++)
+              if (properties_[index].required && !context.propertyExist[index])
+                if (properties_[index].schema->defaultValueLength_ == 0 )
+                  context.error_handler.AddMissingProperty(properties_[index].name);
+            if (context.error_handler.EndMissingProperties())
+              RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
+          }
+
+        if (memberCount < minProperties_)
+          {
+            context.error_handler.TooFewProperties(memberCount, minProperties_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString());
+          }
+
+        if (memberCount > maxProperties_)
+          {
+            context.error_handler.TooManyProperties(memberCount, maxProperties_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString());
+          }
+
+        if (hasDependencies_)
+          {
+            context.error_handler.StartDependencyErrors();
+            for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++)
+              {
+                const Property &source = properties_[sourceIndex];
+                if (context.propertyExist[sourceIndex])
+                  {
+                    if (source.dependencies)
+                      {
+                        context.error_handler.StartMissingDependentProperties();
+                        for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
+                          if (source.dependencies[targetIndex] && !context.propertyExist[targetIndex])
+                            context.error_handler.AddMissingDependentProperty(properties_[targetIndex].name);
+                        context.error_handler.EndMissingDependentProperties(source.name);
+                      }
+                    else if (source.dependenciesSchema)
+                      {
+                        ISchemaValidator *dependenciesValidator = context.validators[source.dependenciesValidatorIndex];
+                        if (!dependenciesValidator->IsValid())
+                          context.error_handler.AddDependencySchemaError(source.name, dependenciesValidator);
+                      }
+                  }
+              }
+            if (context.error_handler.EndDependencyErrors())
+              RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
+          }
+
+        return true;
+      }
+
+      bool StartArray(Context &context) const
+      {
+        if (!(type_ & (1 << kArraySchemaType)))
+          {
+            DisallowedType(context, GetArrayString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+          }
+
+        context.arrayElementIndex = 0;
+        context.inArray = true;
+
+        return CreateParallelValidator(context);
+      }
+
+      bool EndArray(Context &context, SizeType elementCount) const
+      {
+        context.inArray = false;
+
+        if (elementCount < minItems_)
+          {
+            context.error_handler.TooFewItems(elementCount, minItems_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString());
+          }
+
+        if (elementCount > maxItems_)
+          {
+            context.error_handler.TooManyItems(elementCount, maxItems_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString());
+          }
+
+        return true;
+      }
+
+      // Generate functions for string literal according to Ch
+#define RAPIDJSON_STRING_(name, ...) \
+  static const ValueType& Get##name##String() {\
+    static const Ch s[] = { __VA_ARGS__, '\0' };\
+    static const ValueType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1));\
+    return v;\
+  }
+
+      RAPIDJSON_STRING_(Null, 'n', 'u', 'l', 'l')
+      RAPIDJSON_STRING_(Boolean, 'b', 'o', 'o', 'l', 'e', 'a', 'n')
+      RAPIDJSON_STRING_(Object, 'o', 'b', 'j', 'e', 'c', 't')
+      RAPIDJSON_STRING_(Array, 'a', 'r', 'r', 'a', 'y')
+      RAPIDJSON_STRING_(String, 's', 't', 'r', 'i', 'n', 'g')
+      RAPIDJSON_STRING_(Number, 'n', 'u', 'm', 'b', 'e', 'r')
+      RAPIDJSON_STRING_(Integer, 'i', 'n', 't', 'e', 'g', 'e', 'r')
+      RAPIDJSON_STRING_(Type, 't', 'y', 'p', 'e')
+      RAPIDJSON_STRING_(Enum, 'e', 'n', 'u', 'm')
+      RAPIDJSON_STRING_(AllOf, 'a', 'l', 'l', 'O', 'f')
+      RAPIDJSON_STRING_(AnyOf, 'a', 'n', 'y', 'O', 'f')
+      RAPIDJSON_STRING_(OneOf, 'o', 'n', 'e', 'O', 'f')
+      RAPIDJSON_STRING_(Not, 'n', 'o', 't')
+      RAPIDJSON_STRING_(Properties, 'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+      RAPIDJSON_STRING_(Required, 'r', 'e', 'q', 'u', 'i', 'r', 'e', 'd')
+      RAPIDJSON_STRING_(Dependencies, 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 'c', 'i', 'e', 's')
+      RAPIDJSON_STRING_(PatternProperties, 'p', 'a', 't', 't', 'e', 'r', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+      RAPIDJSON_STRING_(AdditionalProperties, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+      RAPIDJSON_STRING_(MinProperties, 'm', 'i', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+      RAPIDJSON_STRING_(MaxProperties, 'm', 'a', 'x', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
+      RAPIDJSON_STRING_(Items, 'i', 't', 'e', 'm', 's')
+      RAPIDJSON_STRING_(MinItems, 'm', 'i', 'n', 'I', 't', 'e', 'm', 's')
+      RAPIDJSON_STRING_(MaxItems, 'm', 'a', 'x', 'I', 't', 'e', 'm', 's')
+      RAPIDJSON_STRING_(AdditionalItems, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'I', 't', 'e', 'm', 's')
+      RAPIDJSON_STRING_(UniqueItems, 'u', 'n', 'i', 'q', 'u', 'e', 'I', 't', 'e', 'm', 's')
+      RAPIDJSON_STRING_(MinLength, 'm', 'i', 'n', 'L', 'e', 'n', 'g', 't', 'h')
+      RAPIDJSON_STRING_(MaxLength, 'm', 'a', 'x', 'L', 'e', 'n', 'g', 't', 'h')
+      RAPIDJSON_STRING_(Pattern, 'p', 'a', 't', 't', 'e', 'r', 'n')
+      RAPIDJSON_STRING_(Minimum, 'm', 'i', 'n', 'i', 'm', 'u', 'm')
+      RAPIDJSON_STRING_(Maximum, 'm', 'a', 'x', 'i', 'm', 'u', 'm')
+      RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm')
+      RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm')
+      RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f')
+      RAPIDJSON_STRING_(DefaultValue, 'd', 'e', 'f', 'a', 'u', 'l', 't')
+
+#undef RAPIDJSON_STRING_
+
+    private:
+      enum SchemaValueType
+      {
+        kNullSchemaType,
+        kBooleanSchemaType,
+        kObjectSchemaType,
+        kArraySchemaType,
+        kStringSchemaType,
+        kNumberSchemaType,
+        kIntegerSchemaType,
+        kTotalSchemaType
+      };
+
+#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
+      typedef internal::GenericRegex<EncodingType, AllocatorType> RegexType;
+#elif RAPIDJSON_SCHEMA_USE_STDREGEX
+      typedef std::basic_regex<Ch> RegexType;
+#else
+      typedef char RegexType;
+#endif
+
+      struct SchemaArray
+      {
+        SchemaArray() : schemas(), count() {}
+        ~SchemaArray()
+        {
+          AllocatorType::Free(schemas);
+        }
+        const SchemaType **schemas;
+        SizeType begin; // begin index of context.validators
+        SizeType count;
+      };
+
+      template <typename V1, typename V2>
+      void AddUniqueElement(V1 &a, const V2 &v)
+      {
+        for (typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
+          if (*itr == v)
+            return;
+        V1 c(v, *allocator_);
+        a.PushBack(c, *allocator_);
+      }
+
+      static const ValueType *GetMember(const ValueType &value, const ValueType &name)
+      {
+        typename ValueType::ConstMemberIterator itr = value.FindMember(name);
+        return itr != value.MemberEnd() ? &(itr->value) : 0;
+      }
+
+      static void AssignIfExist(bool &out, const ValueType &value, const ValueType &name)
+      {
+        if (const ValueType *v = GetMember(value, name))
+          if (v->IsBool())
+            out = v->GetBool();
+      }
+
+      static void AssignIfExist(SizeType &out, const ValueType &value, const ValueType &name)
+      {
+        if (const ValueType *v = GetMember(value, name))
+          if (v->IsUint64() && v->GetUint64() <= SizeType(~0))
+            out = static_cast<SizeType>(v->GetUint64());
+      }
+
+      void AssignIfExist(SchemaArray &out, SchemaDocumentType &schemaDocument, const PointerType &p, const ValueType &value, const ValueType &name, const ValueType &document)
+      {
+        if (const ValueType *v = GetMember(value, name))
+          {
+            if (v->IsArray() && v->Size() > 0)
+              {
+                PointerType q = p.Append(name, allocator_);
+                out.count = v->Size();
+                out.schemas = static_cast<const Schema **>(allocator_->Malloc(out.count * sizeof(const Schema *)));
+                memset(out.schemas, 0, sizeof(Schema *)* out.count);
+                for (SizeType i = 0; i < out.count; i++)
+                  schemaDocument.CreateSchema(&out.schemas[i], q.Append(i, allocator_), (*v)[i], document);
+                out.begin = validatorCount_;
+                validatorCount_ += out.count;
+              }
+          }
+      }
+
+#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
+      template <typename ValueType>
+      RegexType *CreatePattern(const ValueType &value)
+      {
+        if (value.IsString())
+          {
+            RegexType *r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), allocator_);
+            if (!r->IsValid())
+              {
+                r->~RegexType();
+                AllocatorType::Free(r);
+                r = 0;
+              }
+            return r;
+          }
+        return 0;
+      }
+
+      static bool IsPatternMatch(const RegexType *pattern, const Ch *str, SizeType)
+      {
+        GenericRegexSearch<RegexType> rs(*pattern);
+        return rs.Search(str);
+      }
+#elif RAPIDJSON_SCHEMA_USE_STDREGEX
+      template <typename ValueType>
+      RegexType *CreatePattern(const ValueType &value)
+      {
+        if (value.IsString())
+          try
+            {
+              return new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
+            }
+          catch (const std::regex_error &)
+            {
+            }
+        return 0;
+      }
+
+      static bool IsPatternMatch(const RegexType *pattern, const Ch *str, SizeType length)
+      {
+        std::match_results<const Ch *> r;
+        return std::regex_search(str, str + length, r, *pattern);
+      }
+#else
+      template <typename ValueType>
+      RegexType *CreatePattern(const ValueType &)
+      {
+        return 0;
+      }
+
+      static bool IsPatternMatch(const RegexType *, const Ch *, SizeType)
+      {
+        return true;
+      }
+#endif // RAPIDJSON_SCHEMA_USE_STDREGEX
+
+      void AddType(const ValueType &type)
+      {
+        if      (type == GetNullString()   ) type_ |= 1 << kNullSchemaType;
+        else if (type == GetBooleanString()) type_ |= 1 << kBooleanSchemaType;
+        else if (type == GetObjectString() ) type_ |= 1 << kObjectSchemaType;
+        else if (type == GetArrayString()  ) type_ |= 1 << kArraySchemaType;
+        else if (type == GetStringString() ) type_ |= 1 << kStringSchemaType;
+        else if (type == GetIntegerString()) type_ |= 1 << kIntegerSchemaType;
+        else if (type == GetNumberString() ) type_ |= (1 << kNumberSchemaType) | (1 << kIntegerSchemaType);
+      }
+
+      bool CreateParallelValidator(Context &context) const
+      {
+        if (enum_ || context.arrayUniqueness)
+          context.hasher = context.factory.CreateHasher();
+
+        if (validatorCount_)
+          {
+            RAPIDJSON_ASSERT(context.validators == 0);
+            context.validators = static_cast<ISchemaValidator **>(context.factory.MallocState(sizeof(ISchemaValidator *) * validatorCount_));
+            context.validatorCount = validatorCount_;
+
+            if (allOf_.schemas)
+              CreateSchemaValidators(context, allOf_);
+
+            if (anyOf_.schemas)
+              CreateSchemaValidators(context, anyOf_);
+
+            if (oneOf_.schemas)
+              CreateSchemaValidators(context, oneOf_);
+
+            if (not_)
+              context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_);
+
+            if (hasSchemaDependencies_)
+              {
+                for (SizeType i = 0; i < propertyCount_; i++)
+                  if (properties_[i].dependenciesSchema)
+                    context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema);
+              }
+          }
+
+        return true;
+      }
+
+      void CreateSchemaValidators(Context &context, const SchemaArray &schemas) const
+      {
+        for (SizeType i = 0; i < schemas.count; i++)
+          context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i]);
+      }
+
+      // O(n)
+      bool FindPropertyIndex(const ValueType &name, SizeType *outIndex) const
+      {
+        SizeType len = name.GetStringLength();
+        const Ch *str = name.GetString();
+        for (SizeType index = 0; index < propertyCount_; index++)
+          if (properties_[index].name.GetStringLength() == len &&
+              (std::memcmp(properties_[index].name.GetString(), str, sizeof(Ch) * len) == 0))
+            {
+              *outIndex = index;
+              return true;
+            }
+        return false;
+      }
+
+      bool CheckInt(Context &context, int64_t i) const
+      {
+        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
+          {
+            DisallowedType(context, GetIntegerString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+          }
+
+        if (!minimum_.IsNull())
+          {
+            if (minimum_.IsInt64())
+              {
+                if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64())
+                  {
+                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+                  }
+              }
+            else if (minimum_.IsUint64())
+              {
+                context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
+                RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); // i <= max(int64_t) < minimum.GetUint64()
+              }
+            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
+              return false;
+          }
+
+        if (!maximum_.IsNull())
+          {
+            if (maximum_.IsInt64())
+              {
+                if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64())
+                  {
+                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+                  }
+              }
+            else if (maximum_.IsUint64()) { }
+            /* do nothing */ // i <= max(int64_t) < maximum_.GetUint64()
+            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
+              return false;
+          }
+
+        if (!multipleOf_.IsNull())
+          {
+            if (multipleOf_.IsUint64())
+              {
+                if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0)
+                  {
+                    context.error_handler.NotMultipleOf(i, multipleOf_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+                  }
+              }
+            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
+              return false;
+          }
+
+        return true;
+      }
+
+      bool CheckUint(Context &context, uint64_t i) const
+      {
+        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
+          {
+            DisallowedType(context, GetIntegerString());
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
+          }
+
+        if (!minimum_.IsNull())
+          {
+            if (minimum_.IsUint64())
+              {
+                if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64())
+                  {
+                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+                  }
+              }
+            else if (minimum_.IsInt64())
+              /* do nothing */; // i >= 0 > minimum.Getint64()
+            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
+              return false;
+          }
+
+        if (!maximum_.IsNull())
+          {
+            if (maximum_.IsUint64())
+              {
+                if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64())
+                  {
+                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+                  }
+              }
+            else if (maximum_.IsInt64())
+              {
+                context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
+                RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); // i >= 0 > maximum_
+              }
+            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
+              return false;
+          }
+
+        if (!multipleOf_.IsNull())
+          {
+            if (multipleOf_.IsUint64())
+              {
+                if (i % multipleOf_.GetUint64() != 0)
+                  {
+                    context.error_handler.NotMultipleOf(i, multipleOf_);
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+                  }
+              }
+            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
+              return false;
+          }
+
+        return true;
+      }
+
+      bool CheckDoubleMinimum(Context &context, double d) const
+      {
+        if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble())
+          {
+            context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
+          }
+        return true;
+      }
+
+      bool CheckDoubleMaximum(Context &context, double d) const
+      {
+        if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble())
+          {
+            context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
+          }
+        return true;
+      }
+
+      bool CheckDoubleMultipleOf(Context &context, double d) const
+      {
+        double a = std::abs(d), b = std::abs(multipleOf_.GetDouble());
+        double q = std::floor(a / b);
+        double r = a - q * b;
+        if (r > 0.0)
+          {
+            context.error_handler.NotMultipleOf(d, multipleOf_);
+            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
+          }
+        return true;
+      }
+
+      void DisallowedType(Context &context, const ValueType &actualType) const
+      {
+        ErrorHandler &eh = context.error_handler;
+        eh.StartDisallowedType();
+
+        if (type_ & (1 << kNullSchemaType)) eh.AddExpectedType(GetNullString());
+        if (type_ & (1 << kBooleanSchemaType)) eh.AddExpectedType(GetBooleanString());
+        if (type_ & (1 << kObjectSchemaType)) eh.AddExpectedType(GetObjectString());
+        if (type_ & (1 << kArraySchemaType)) eh.AddExpectedType(GetArrayString());
+        if (type_ & (1 << kStringSchemaType)) eh.AddExpectedType(GetStringString());
+
+        if (type_ & (1 << kNumberSchemaType)) eh.AddExpectedType(GetNumberString());
+        else if (type_ & (1 << kIntegerSchemaType)) eh.AddExpectedType(GetIntegerString());
+
+        eh.EndDisallowedType(actualType);
+      }
+
+      struct Property
+      {
+        Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {}
+        ~Property()
+        {
+          AllocatorType::Free(dependencies);
+        }
+        SValue name;
+        const SchemaType *schema;
+        const SchemaType *dependenciesSchema;
+        SizeType dependenciesValidatorIndex;
+        bool *dependencies;
+        bool required;
+      };
+
+      struct PatternProperty
+      {
+        PatternProperty() : schema(), pattern() {}
+        ~PatternProperty()
+        {
+          if (pattern)
+            {
+              pattern->~RegexType();
+              AllocatorType::Free(pattern);
+            }
+        }
+        const SchemaType *schema;
+        RegexType *pattern;
+      };
+
+      AllocatorType *allocator_;
+      SValue uri_;
+      PointerType pointer_;
+      const SchemaType *typeless_;
+      uint64_t *enum_;
+      SizeType enumCount_;
+      SchemaArray allOf_;
+      SchemaArray anyOf_;
+      SchemaArray oneOf_;
+      const SchemaType *not_;
+      unsigned type_; // bitmask of kSchemaType
+      SizeType validatorCount_;
+      SizeType notValidatorIndex_;
+
+      Property *properties_;
+      const SchemaType *additionalPropertiesSchema_;
+      PatternProperty *patternProperties_;
+      SizeType patternPropertyCount_;
+      SizeType propertyCount_;
+      SizeType minProperties_;
+      SizeType maxProperties_;
+      bool additionalProperties_;
+      bool hasDependencies_;
+      bool hasRequired_;
+      bool hasSchemaDependencies_;
+
+      const SchemaType *additionalItemsSchema_;
+      const SchemaType *itemsList_;
+      const SchemaType **itemsTuple_;
+      SizeType itemsTupleCount_;
+      SizeType minItems_;
+      SizeType maxItems_;
+      bool additionalItems_;
+      bool uniqueItems_;
+
+      RegexType *pattern_;
+      SizeType minLength_;
+      SizeType maxLength_;
+
+      SValue minimum_;
+      SValue maximum_;
+      SValue multipleOf_;
+      bool exclusiveMinimum_;
+      bool exclusiveMaximum_;
+
+      SizeType defaultValueLength_;
+  };
+
+  template<typename Stack, typename Ch>
+  struct TokenHelper
+  {
+    RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack &documentStack, SizeType index)
+    {
+      *documentStack.template Push<Ch>() = '/';
+      char buffer[21];
+      size_t length = static_cast<size_t>((sizeof(SizeType) == 4 ? u32toa(index, buffer) : u64toa(index, buffer)) - buffer);
+      for (size_t i = 0; i < length; i++)
+        *documentStack.template Push<Ch>() = static_cast<Ch>(buffer[i]);
+    }
+  };
+
+// Partial specialized version for char to prevent buffer copying.
+  template <typename Stack>
+  struct TokenHelper<Stack, char>
+  {
+    RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack &documentStack, SizeType index)
+    {
+      if (sizeof(SizeType) == 4)
+        {
+          char *buffer = documentStack.template Push<char>(1 + 10); // '/' + uint
+          *buffer++ = '/';
+          const char *end = internal::u32toa(index, buffer);
+          documentStack.template Pop<char>(static_cast<size_t>(10 - (end - buffer)));
+        }
+      else
+        {
+          char *buffer = documentStack.template Push<char>(1 + 20); // '/' + uint64
+          *buffer++ = '/';
+          const char *end = internal::u64toa(index, buffer);
+          documentStack.template Pop<char>(static_cast<size_t>(20 - (end - buffer)));
+        }
+    }
+  };
+
+} // namespace internal
+
+///////////////////////////////////////////////////////////////////////////////
+// IGenericRemoteSchemaDocumentProvider
+
+template <typename SchemaDocumentType>
+class IGenericRemoteSchemaDocumentProvider
+{
+  public:
+    typedef typename SchemaDocumentType::Ch Ch;
+
+    virtual ~IGenericRemoteSchemaDocumentProvider() {}
+    virtual const SchemaDocumentType *GetRemoteDocument(const Ch *uri, SizeType length) = 0;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericSchemaDocument
+
+//! JSON schema document.
+/*!
+    A JSON schema document is a compiled version of a JSON schema.
+    It is basically a tree of internal::Schema.
+
+    \note This is an immutable class (i.e. its instance cannot be modified after construction).
+    \tparam ValueT Type of JSON value (e.g. \c Value ), which also determine the encoding.
+    \tparam Allocator Allocator type for allocating memory of this document.
+*/
+template <typename ValueT, typename Allocator = CrtAllocator>
+class GenericSchemaDocument
+{
+  public:
+    typedef ValueT ValueType;
+    typedef IGenericRemoteSchemaDocumentProvider<GenericSchemaDocument> IRemoteSchemaDocumentProviderType;
+    typedef Allocator AllocatorType;
+    typedef typename ValueType::EncodingType EncodingType;
+    typedef typename EncodingType::Ch Ch;
+    typedef internal::Schema<GenericSchemaDocument> SchemaType;
+    typedef GenericPointer<ValueType, Allocator> PointerType;
+    typedef GenericValue<EncodingType, Allocator> URIType;
+    friend class internal::Schema<GenericSchemaDocument>;
+    template <typename, typename, typename>
+    friend class GenericSchemaValidator;
+
+    //! Constructor.
+    /*!
+        Compile a JSON document into schema document.
+
+        \param document A JSON document as source.
+        \param uri The base URI of this schema document for purposes of violation reporting.
+        \param uriLength Length of \c name, in code points.
+        \param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null.
+        \param allocator An optional allocator instance for allocating memory. Can be null.
+    */
+    explicit GenericSchemaDocument(const ValueType &document, const Ch *uri = 0, SizeType uriLength = 0,
+                                   IRemoteSchemaDocumentProviderType *remoteProvider = 0, Allocator *allocator = 0) :
+      remoteProvider_(remoteProvider),
+      allocator_(allocator),
+      ownAllocator_(),
+      root_(),
+      typeless_(),
+      schemaMap_(allocator, kInitialSchemaMapSize),
+      schemaRef_(allocator, kInitialSchemaRefSize)
+    {
+      if (!allocator_)
+        ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
+
+      Ch noUri[1] = {0};
+      uri_.SetString(uri ? uri : noUri, uriLength, *allocator_);
+
+      typeless_ = static_cast<SchemaType *>(allocator_->Malloc(sizeof(SchemaType)));
+      new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_);
+
+      // Generate root schema, it will call CreateSchema() to create sub-schemas,
+      // And call AddRefSchema() if there are $ref.
+      CreateSchemaRecursive(&root_, PointerType(), document, document);
+
+      // Resolve $ref
+      while (!schemaRef_.Empty())
+        {
+          SchemaRefEntry *refEntry = schemaRef_.template Pop<SchemaRefEntry>(1);
+          if (const SchemaType *s = GetSchema(refEntry->target))
+            {
+              if (refEntry->schema)
+                *refEntry->schema = s;
+
+              // Create entry in map if not exist
+              if (!GetSchema(refEntry->source))
+                {
+                  new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(refEntry->source, const_cast<SchemaType *>(s), false, allocator_);
+                }
+            }
+          else if (refEntry->schema)
+            *refEntry->schema = typeless_;
+
+          refEntry->~SchemaRefEntry();
+        }
+
+      RAPIDJSON_ASSERT(root_ != 0);
+
+      schemaRef_.ShrinkToFit(); // Deallocate all memory for ref
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    //! Move constructor in C++11
+  GenericSchemaDocument(GenericSchemaDocument &&rhs) RAPIDJSON_NOEXCEPT :
+    remoteProvider_(rhs.remoteProvider_),
+                    allocator_(rhs.allocator_),
+                    ownAllocator_(rhs.ownAllocator_),
+                    root_(rhs.root_),
+                    typeless_(rhs.typeless_),
+                    schemaMap_(std::move(rhs.schemaMap_)),
+                    schemaRef_(std::move(rhs.schemaRef_)),
+                    uri_(std::move(rhs.uri_))
+    {
+      rhs.remoteProvider_ = 0;
+      rhs.allocator_ = 0;
+      rhs.ownAllocator_ = 0;
+      rhs.typeless_ = 0;
+    }
+#endif
+
+    //! Destructor
+    ~GenericSchemaDocument()
+    {
+      while (!schemaMap_.Empty())
+        schemaMap_.template Pop<SchemaEntry>(1)->~SchemaEntry();
+
+      if (typeless_)
+        {
+          typeless_->~SchemaType();
+          Allocator::Free(typeless_);
+        }
+
+      RAPIDJSON_DELETE(ownAllocator_);
+    }
+
+    const URIType &GetURI() const
+    {
+      return uri_;
+    }
+
+    //! Get the root schema.
+    const SchemaType &GetRoot() const
+    {
+      return *root_;
+    }
+
+  private:
+    //! Prohibit copying
+    GenericSchemaDocument(const GenericSchemaDocument &);
+    //! Prohibit assignment
+    GenericSchemaDocument &operator=(const GenericSchemaDocument &);
+
+    struct SchemaRefEntry
+    {
+      SchemaRefEntry(const PointerType &s, const PointerType &t, const SchemaType **outSchema, Allocator *allocator) : source(s, allocator), target(t, allocator), schema(outSchema) {}
+      PointerType source;
+      PointerType target;
+      const SchemaType **schema;
+    };
+
+    struct SchemaEntry
+    {
+      SchemaEntry(const PointerType &p, SchemaType *s, bool o, Allocator *allocator) : pointer(p, allocator), schema(s), owned(o) {}
+      ~SchemaEntry()
+      {
+        if (owned)
+          {
+            schema->~SchemaType();
+            Allocator::Free(schema);
+          }
+      }
+      PointerType pointer;
+      SchemaType *schema;
+      bool owned;
+    };
+
+    void CreateSchemaRecursive(const SchemaType **schema, const PointerType &pointer, const ValueType &v, const ValueType &document)
+    {
+      if (schema)
+        *schema = typeless_;
+
+      if (v.GetType() == kObjectType)
+        {
+          const SchemaType *s = GetSchema(pointer);
+          if (!s)
+            CreateSchema(schema, pointer, v, document);
+
+          for (typename ValueType::ConstMemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr)
+            CreateSchemaRecursive(0, pointer.Append(itr->name, allocator_), itr->value, document);
+        }
+      else if (v.GetType() == kArrayType)
+        for (SizeType i = 0; i < v.Size(); i++)
+          CreateSchemaRecursive(0, pointer.Append(i, allocator_), v[i], document);
+    }
+
+    void CreateSchema(const SchemaType **schema, const PointerType &pointer, const ValueType &v, const ValueType &document)
+    {
+      RAPIDJSON_ASSERT(pointer.IsValid());
+      if (v.IsObject())
+        {
+          if (!HandleRefSchema(pointer, schema, v, document))
+            {
+              SchemaType *s = new (allocator_->Malloc(sizeof(SchemaType))) SchemaType(this, pointer, v, document, allocator_);
+              new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(pointer, s, true, allocator_);
+              if (schema)
+                *schema = s;
+            }
+        }
+    }
+
+    bool HandleRefSchema(const PointerType &source, const SchemaType **schema, const ValueType &v, const ValueType &document)
+    {
+      static const Ch kRefString[] = { '$', 'r', 'e', 'f', '\0' };
+      static const ValueType kRefValue(kRefString, 4);
+
+      typename ValueType::ConstMemberIterator itr = v.FindMember(kRefValue);
+      if (itr == v.MemberEnd())
+        return false;
+
+      if (itr->value.IsString())
+        {
+          SizeType len = itr->value.GetStringLength();
+          if (len > 0)
+            {
+              const Ch *s = itr->value.GetString();
+              SizeType i = 0;
+              while (i < len && s[i] != '#') // Find the first #
+                i++;
+
+              if (i > 0)   // Remote reference, resolve immediately
+                {
+                  if (remoteProvider_)
+                    {
+                      if (const GenericSchemaDocument *remoteDocument = remoteProvider_->GetRemoteDocument(s, i))
+                        {
+                          PointerType pointer(&s[i], len - i, allocator_);
+                          if (pointer.IsValid())
+                            {
+                              if (const SchemaType *sc = remoteDocument->GetSchema(pointer))
+                                {
+                                  if (schema)
+                                    *schema = sc;
+                                  new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(source, const_cast<SchemaType *>(sc), false, allocator_);
+                                  return true;
+                                }
+                            }
+                        }
+                    }
+                }
+              else if (s[i] == '#')   // Local reference, defer resolution
+                {
+                  PointerType pointer(&s[i], len - i, allocator_);
+                  if (pointer.IsValid())
+                    {
+                      if (const ValueType *nv = pointer.Get(document))
+                        if (HandleRefSchema(source, schema, *nv, document))
+                          return true;
+
+                      new (schemaRef_.template Push<SchemaRefEntry>()) SchemaRefEntry(source, pointer, schema, allocator_);
+                      return true;
+                    }
+                }
+            }
+        }
+      return false;
+    }
+
+    const SchemaType *GetSchema(const PointerType &pointer) const
+    {
+      for (const SchemaEntry *target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
+        if (pointer == target->pointer)
+          return target->schema;
+      return 0;
+    }
+
+    PointerType GetPointer(const SchemaType *schema) const
+    {
+      for (const SchemaEntry *target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
+        if (schema == target->schema)
+          return target->pointer;
+      return PointerType();
+    }
+
+    const SchemaType *GetTypeless() const
+    {
+      return typeless_;
+    }
+
+    static const size_t kInitialSchemaMapSize = 64;
+    static const size_t kInitialSchemaRefSize = 64;
+
+    IRemoteSchemaDocumentProviderType *remoteProvider_;
+    Allocator *allocator_;
+    Allocator *ownAllocator_;
+    const SchemaType *root_;                //!< Root schema.
+    SchemaType *typeless_;
+    internal::Stack<Allocator> schemaMap_;  // Stores created Pointer -> Schemas
+    internal::Stack<Allocator> schemaRef_;  // Stores Pointer from $ref and schema which holds the $ref
+    URIType uri_;
+};
+
+//! GenericSchemaDocument using Value type.
+typedef GenericSchemaDocument<Value> SchemaDocument;
+//! IGenericRemoteSchemaDocumentProvider using SchemaDocument.
+typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericSchemaValidator
+
+//! JSON Schema Validator.
+/*!
+    A SAX style JSON schema validator.
+    It uses a \c GenericSchemaDocument to validate SAX events.
+    It delegates the incoming SAX events to an output handler.
+    The default output handler does nothing.
+    It can be reused multiple times by calling \c Reset().
+
+    \tparam SchemaDocumentType Type of schema document.
+    \tparam OutputHandler Type of output handler. Default handler does nothing.
+    \tparam StateAllocator Allocator for storing the internal validation states.
+*/
+template <
+  typename SchemaDocumentType,
+  typename OutputHandler = BaseReaderHandler<typename SchemaDocumentType::SchemaType::EncodingType>,
+  typename StateAllocator = CrtAllocator>
+class GenericSchemaValidator :
+  public internal::ISchemaStateFactory<typename SchemaDocumentType::SchemaType>,
+  public internal::ISchemaValidator,
+  public internal::IValidationErrorHandler<typename SchemaDocumentType::SchemaType>
+{
+  public:
+    typedef typename SchemaDocumentType::SchemaType SchemaType;
+    typedef typename SchemaDocumentType::PointerType PointerType;
+    typedef typename SchemaType::EncodingType EncodingType;
+    typedef typename SchemaType::SValue SValue;
+    typedef typename EncodingType::Ch Ch;
+    typedef GenericStringRef<Ch> StringRefType;
+    typedef GenericValue<EncodingType, StateAllocator> ValueType;
+
+    //! Constructor without output handler.
+    /*!
+        \param schemaDocument The schema document to conform to.
+        \param allocator Optional allocator for storing internal validation states.
+        \param schemaStackCapacity Optional initial capacity of schema path stack.
+        \param documentStackCapacity Optional initial capacity of document path stack.
+    */
+    GenericSchemaValidator(
+      const SchemaDocumentType &schemaDocument,
+      StateAllocator *allocator = 0,
+      size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
+      size_t documentStackCapacity = kDefaultDocumentStackCapacity)
+      :
+      schemaDocument_(&schemaDocument),
+      root_(schemaDocument.GetRoot()),
+      stateAllocator_(allocator),
+      ownStateAllocator_(0),
+      schemaStack_(allocator, schemaStackCapacity),
+      documentStack_(allocator, documentStackCapacity),
+      outputHandler_(0),
+      error_(kObjectType),
+      currentError_(),
+      missingDependents_(),
+      valid_(true)
+#if RAPIDJSON_SCHEMA_VERBOSE
+      , depth_(0)
+#endif
+    {
+    }
+
+    //! Constructor with output handler.
+    /*!
+        \param schemaDocument The schema document to conform to.
+        \param allocator Optional allocator for storing internal validation states.
+        \param schemaStackCapacity Optional initial capacity of schema path stack.
+        \param documentStackCapacity Optional initial capacity of document path stack.
+    */
+    GenericSchemaValidator(
+      const SchemaDocumentType &schemaDocument,
+      OutputHandler &outputHandler,
+      StateAllocator *allocator = 0,
+      size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
+      size_t documentStackCapacity = kDefaultDocumentStackCapacity)
+      :
+      schemaDocument_(&schemaDocument),
+      root_(schemaDocument.GetRoot()),
+      stateAllocator_(allocator),
+      ownStateAllocator_(0),
+      schemaStack_(allocator, schemaStackCapacity),
+      documentStack_(allocator, documentStackCapacity),
+      outputHandler_(&outputHandler),
+      error_(kObjectType),
+      currentError_(),
+      missingDependents_(),
+      valid_(true)
+#if RAPIDJSON_SCHEMA_VERBOSE
+      , depth_(0)
+#endif
+    {
+    }
+
+    //! Destructor.
+    ~GenericSchemaValidator()
+    {
+      Reset();
+      RAPIDJSON_DELETE(ownStateAllocator_);
+    }
+
+    //! Reset the internal states.
+    void Reset()
+    {
+      while (!schemaStack_.Empty())
+        PopSchema();
+      documentStack_.Clear();
+      error_.SetObject();
+      currentError_.SetNull();
+      missingDependents_.SetNull();
+      valid_ = true;
+    }
+
+    //! Checks whether the current state is valid.
+    // Implementation of ISchemaValidator
+    bool IsValid() const override final
+    {
+      return valid_;
+    }
+
+    //! Gets the error object.
+    ValueType &GetError()
+    {
+      return error_;
+    }
+    const ValueType &GetError() const
+    {
+      return error_;
+    }
+
+    //! Gets the JSON pointer pointed to the invalid schema.
+    PointerType GetInvalidSchemaPointer() const
+    {
+      return schemaStack_.Empty() ? PointerType() : CurrentSchema().GetPointer();
+    }
+
+    //! Gets the keyword of invalid schema.
+    const Ch *GetInvalidSchemaKeyword() const
+    {
+      return schemaStack_.Empty() ? 0 : CurrentContext().invalidKeyword;
+    }
+
+    //! Gets the JSON pointer pointed to the invalid value.
+    PointerType GetInvalidDocumentPointer() const
+    {
+      if (documentStack_.Empty())
+        {
+          return PointerType();
+        }
+      else
+        {
+          return PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
+        }
+    }
+
+    void NotMultipleOf(int64_t actual, const SValue &expected) override final
+    {
+      AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
+    }
+    void NotMultipleOf(uint64_t actual, const SValue &expected) override final
+    {
+      AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
+    }
+    void NotMultipleOf(double actual, const SValue &expected) override final
+    {
+      AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
+    }
+    void AboveMaximum(int64_t actual, const SValue &expected, bool exclusive) override final
+    {
+      AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
+                     exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+    }
+    void AboveMaximum(uint64_t actual, const SValue &expected, bool exclusive) override final
+    {
+      AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
+                     exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+    }
+    void AboveMaximum(double actual, const SValue &expected, bool exclusive) override final
+    {
+      AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
+                     exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
+    }
+    void BelowMinimum(int64_t actual, const SValue &expected, bool exclusive) override final
+    {
+      AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
+                     exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+    }
+    void BelowMinimum(uint64_t actual, const SValue &expected, bool exclusive) override final
+    {
+      AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
+                     exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+    }
+    void BelowMinimum(double actual, const SValue &expected, bool exclusive) override final
+    {
+      AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
+                     exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
+    }
+
+    void TooLong(const Ch *str, SizeType length, SizeType expected) override final
+    {
+      AddNumberError(SchemaType::GetMaxLengthString(),
+                     ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
+    }
+    void TooShort(const Ch *str, SizeType length, SizeType expected) override final
+    {
+      AddNumberError(SchemaType::GetMinLengthString(),
+                     ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
+    }
+    void DoesNotMatch(const Ch *str, SizeType length) override final
+    {
+      currentError_.SetObject();
+      currentError_.AddMember(GetActualString(), ValueType(str, length, GetStateAllocator()).Move(), GetStateAllocator());
+      AddCurrentError(SchemaType::GetPatternString());
+    }
+
+    void DisallowedItem(SizeType index) override final
+    {
+      currentError_.SetObject();
+      currentError_.AddMember(GetDisallowedString(), ValueType(index).Move(), GetStateAllocator());
+      AddCurrentError(SchemaType::GetAdditionalItemsString(), true);
+    }
+    void TooFewItems(SizeType actualCount, SizeType expectedCount) override final
+    {
+      AddNumberError(SchemaType::GetMinItemsString(),
+                     ValueType(actualCount).Move(), SValue(expectedCount).Move());
+    }
+    void TooManyItems(SizeType actualCount, SizeType expectedCount) override final
+    {
+      AddNumberError(SchemaType::GetMaxItemsString(),
+                     ValueType(actualCount).Move(), SValue(expectedCount).Move());
+    }
+    void DuplicateItems(SizeType index1, SizeType index2) override final
+    {
+      ValueType duplicates(kArrayType);
+      duplicates.PushBack(index1, GetStateAllocator());
+      duplicates.PushBack(index2, GetStateAllocator());
+      currentError_.SetObject();
+      currentError_.AddMember(GetDuplicatesString(), duplicates, GetStateAllocator());
+      AddCurrentError(SchemaType::GetUniqueItemsString(), true);
+    }
+
+    void TooManyProperties(SizeType actualCount, SizeType expectedCount) override final
+    {
+      AddNumberError(SchemaType::GetMaxPropertiesString(),
+                     ValueType(actualCount).Move(), SValue(expectedCount).Move());
+    }
+    void TooFewProperties(SizeType actualCount, SizeType expectedCount) override final
+    {
+      AddNumberError(SchemaType::GetMinPropertiesString(),
+                     ValueType(actualCount).Move(), SValue(expectedCount).Move());
+    }
+    void StartMissingProperties() override final
+    {
+      currentError_.SetArray();
+    }
+    void AddMissingProperty(const SValue &name) override final
+    {
+      currentError_.PushBack(ValueType(name, GetStateAllocator()).Move(), GetStateAllocator());
+    }
+    bool EndMissingProperties() override final
+    {
+      if (currentError_.Empty())
+        return false;
+      ValueType error(kObjectType);
+      error.AddMember(GetMissingString(), currentError_, GetStateAllocator());
+      currentError_ = error;
+      AddCurrentError(SchemaType::GetRequiredString());
+      return true;
+    }
+    void PropertyViolations(ISchemaValidator **subvalidators, SizeType count) override final
+    {
+      for (SizeType i = 0; i < count; ++i)
+        MergeError(static_cast<GenericSchemaValidator *>(subvalidators[i])->GetError());
+    }
+    void DisallowedProperty(const Ch *name, SizeType length) override final
+    {
+      currentError_.SetObject();
+      currentError_.AddMember(GetDisallowedString(), ValueType(name, length, GetStateAllocator()).Move(), GetStateAllocator());
+      AddCurrentError(SchemaType::GetAdditionalPropertiesString(), true);
+    }
+
+    void StartDependencyErrors() override final
+    {
+      currentError_.SetObject();
+    }
+    void StartMissingDependentProperties() override final
+    {
+      missingDependents_.SetArray();
+    }
+    void AddMissingDependentProperty(const SValue &targetName) override final
+    {
+      missingDependents_.PushBack(ValueType(targetName, GetStateAllocator()).Move(), GetStateAllocator());
+    }
+    void EndMissingDependentProperties(const SValue &sourceName) override final
+    {
+      if (!missingDependents_.Empty())
+        currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
+                                missingDependents_, GetStateAllocator());
+    }
+    void AddDependencySchemaError(const SValue &sourceName, ISchemaValidator *subvalidator) override final
+    {
+      currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
+                              static_cast<GenericSchemaValidator *>(subvalidator)->GetError(), GetStateAllocator());
+    }
+    bool EndDependencyErrors() override final
+    {
+      if (currentError_.ObjectEmpty())
+        return false;
+      ValueType error(kObjectType);
+      error.AddMember(GetErrorsString(), currentError_, GetStateAllocator());
+      currentError_ = error;
+      AddCurrentError(SchemaType::GetDependenciesString());
+      return true;
+    }
+
+    void DisallowedValue() override final
+    {
+      currentError_.SetObject();
+      AddCurrentError(SchemaType::GetEnumString());
+    }
+    void StartDisallowedType() override final
+    {
+      currentError_.SetArray();
+    }
+    void AddExpectedType(const typename SchemaType::ValueType &expectedType) override final
+    {
+      currentError_.PushBack(ValueType(expectedType, GetStateAllocator()).Move(), GetStateAllocator());
+    }
+    void EndDisallowedType(const typename SchemaType::ValueType &actualType) override final
+    {
+      ValueType error(kObjectType);
+      error.AddMember(GetExpectedString(), currentError_, GetStateAllocator());
+      error.AddMember(GetActualString(), ValueType(actualType, GetStateAllocator()).Move(), GetStateAllocator());
+      currentError_ = error;
+      AddCurrentError(SchemaType::GetTypeString());
+    }
+    void NotAllOf(ISchemaValidator **subvalidators, SizeType count) override final
+    {
+      for (SizeType i = 0; i < count; ++i)
+        {
+          MergeError(static_cast<GenericSchemaValidator *>(subvalidators[i])->GetError());
+        }
+    }
+    void NoneOf(ISchemaValidator **subvalidators, SizeType count) override final
+    {
+      AddErrorArray(SchemaType::GetAnyOfString(), subvalidators, count);
+    }
+    void NotOneOf(ISchemaValidator **subvalidators, SizeType count) override final
+    {
+      AddErrorArray(SchemaType::GetOneOfString(), subvalidators, count);
+    }
+    void Disallowed() override final
+    {
+      currentError_.SetObject();
+      AddCurrentError(SchemaType::GetNotString());
+    }
+
+#define RAPIDJSON_STRING_(name, ...) \
+  static const StringRefType& Get##name##String() {\
+    static const Ch s[] = { __VA_ARGS__, '\0' };\
+    static const StringRefType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1)); \
+    return v;\
+  }
+
+    RAPIDJSON_STRING_(InstanceRef, 'i', 'n', 's', 't', 'a', 'n', 'c', 'e', 'R', 'e', 'f')
+    RAPIDJSON_STRING_(SchemaRef, 's', 'c', 'h', 'e', 'm', 'a', 'R', 'e', 'f')
+    RAPIDJSON_STRING_(Expected, 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd')
+    RAPIDJSON_STRING_(Actual, 'a', 'c', 't', 'u', 'a', 'l')
+    RAPIDJSON_STRING_(Disallowed, 'd', 'i', 's', 'a', 'l', 'l', 'o', 'w', 'e', 'd')
+    RAPIDJSON_STRING_(Missing, 'm', 'i', 's', 's', 'i', 'n', 'g')
+    RAPIDJSON_STRING_(Errors, 'e', 'r', 'r', 'o', 'r', 's')
+    RAPIDJSON_STRING_(Duplicates, 'd', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e', 's')
+
+#undef RAPIDJSON_STRING_
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \
+  RAPIDJSON_MULTILINEMACRO_BEGIN\
+  *documentStack_.template Push<Ch>() = '\0';\
+  documentStack_.template Pop<Ch>(1);\
+  internal::PrintInvalidDocument(documentStack_.template Bottom<Ch>());\
+  RAPIDJSON_MULTILINEMACRO_END
+#else
+#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_()
+#endif
+
+#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_(method, arg1)\
+  if (!valid_) return false; \
+  if (!BeginValue() || !CurrentSchema().method arg1) {\
+      RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_();\
+      return valid_ = false;\
+    }
+
+#define RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2)\
+  for (Context* context = schemaStack_.template Bottom<Context>(); context != schemaStack_.template End<Context>(); context++) {\
+      if (context->hasher)\
+        static_cast<HasherType*>(context->hasher)->method arg2;\
+      if (context->validators)\
+        for (SizeType i_ = 0; i_ < context->validatorCount; i_++)\
+          static_cast<GenericSchemaValidator*>(context->validators[i_])->method arg2;\
+      if (context->patternPropertiesValidators)\
+        for (SizeType i_ = 0; i_ < context->patternPropertiesValidatorCount; i_++)\
+          static_cast<GenericSchemaValidator*>(context->patternPropertiesValidators[i_])->method arg2;\
+    }
+
+#define RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\
+  return valid_ = EndValue() && (!outputHandler_ || outputHandler_->method arg2)
+
+#define RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \
+  RAPIDJSON_SCHEMA_HANDLE_BEGIN_   (method, arg1);\
+  RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\
+  RAPIDJSON_SCHEMA_HANDLE_END_     (method, arg2)
+
+    bool Null()
+    {
+      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null,   (CurrentContext()), ( ));
+    }
+    bool Bool(bool b)
+    {
+      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool,   (CurrentContext(), b), (b));
+    }
+    bool Int(int i)
+    {
+      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int,    (CurrentContext(), i), (i));
+    }
+    bool Uint(unsigned u)
+    {
+      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint,   (CurrentContext(), u), (u));
+    }
+    bool Int64(int64_t i)
+    {
+      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int64,  (CurrentContext(), i), (i));
+    }
+    bool Uint64(uint64_t u)
+    {
+      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint64, (CurrentContext(), u), (u));
+    }
+    bool Double(double d)
+    {
+      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Double, (CurrentContext(), d), (d));
+    }
+    bool RawNumber(const Ch *str, SizeType length, bool copy)
+    {
+      RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy));
+    }
+    bool String(const Ch *str, SizeType length, bool copy)
+    {
+      RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy));
+    }
+
+    bool StartObject()
+    {
+      RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartObject, (CurrentContext()));
+      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartObject, ());
+      return valid_ = !outputHandler_ || outputHandler_->StartObject();
+    }
+
+    bool Key(const Ch *str, SizeType len, bool copy)
+    {
+      if (!valid_) return false;
+      AppendToken(str, len);
+      if (!CurrentSchema().Key(CurrentContext(), str, len, copy)) return valid_ = false;
+      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy));
+      return valid_ = !outputHandler_ || outputHandler_->Key(str, len, copy);
+    }
+
+    bool EndObject(SizeType memberCount)
+    {
+      if (!valid_) return false;
+      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndObject, (memberCount));
+      if (!CurrentSchema().EndObject(CurrentContext(), memberCount)) return valid_ = false;
+      RAPIDJSON_SCHEMA_HANDLE_END_(EndObject, (memberCount));
+    }
+
+    bool StartArray()
+    {
+      RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartArray, (CurrentContext()));
+      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartArray, ());
+      return valid_ = !outputHandler_ || outputHandler_->StartArray();
+    }
+
+    bool EndArray(SizeType elementCount)
+    {
+      if (!valid_) return false;
+      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndArray, (elementCount));
+      if (!CurrentSchema().EndArray(CurrentContext(), elementCount)) return valid_ = false;
+      RAPIDJSON_SCHEMA_HANDLE_END_(EndArray, (elementCount));
+    }
+
+#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_
+#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_
+#undef RAPIDJSON_SCHEMA_HANDLE_PARALLEL_
+#undef RAPIDJSON_SCHEMA_HANDLE_VALUE_
+
+    // Implementation of ISchemaStateFactory<SchemaType>
+    ISchemaValidator *CreateSchemaValidator(const SchemaType &root) override final
+    {
+      return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root, documentStack_.template Bottom<char>(), documentStack_.GetSize(),
+#if RAPIDJSON_SCHEMA_VERBOSE
+             depth_ + 1,
+#endif
+             &GetStateAllocator());
+    }
+
+    void DestroySchemaValidator(ISchemaValidator *validator) override final
+    {
+      GenericSchemaValidator *v = static_cast<GenericSchemaValidator *>(validator);
+      v->~GenericSchemaValidator();
+      StateAllocator::Free(v);
+    }
+
+    void *CreateHasher() override final
+    {
+      return new (GetStateAllocator().Malloc(sizeof(HasherType))) HasherType(&GetStateAllocator());
+    }
+
+    uint64_t GetHashCode(void *hasher) override final
+    {
+      return static_cast<HasherType *>(hasher)->GetHashCode();
+    }
+
+    void DestroryHasher(void *hasher) override final
+    {
+      HasherType *h = static_cast<HasherType *>(hasher);
+      h->~HasherType();
+      StateAllocator::Free(h);
+    }
+
+    void *MallocState(size_t size) override final
+    {
+      return GetStateAllocator().Malloc(size);
+    }
+
+    void FreeState(void *p) override final
+    {
+      StateAllocator::Free(p);
+    }
+
+  private:
+    typedef typename SchemaType::Context Context;
+    typedef GenericValue<UTF8<>, StateAllocator> HashCodeArray;
+    typedef internal::Hasher<EncodingType, StateAllocator> HasherType;
+
+    GenericSchemaValidator(
+      const SchemaDocumentType &schemaDocument,
+      const SchemaType &root,
+      const char *basePath, size_t basePathSize,
+#if RAPIDJSON_SCHEMA_VERBOSE
+      unsigned depth,
+#endif
+      StateAllocator *allocator = 0,
+      size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
+      size_t documentStackCapacity = kDefaultDocumentStackCapacity)
+      :
+      schemaDocument_(&schemaDocument),
+      root_(root),
+      stateAllocator_(allocator),
+      ownStateAllocator_(0),
+      schemaStack_(allocator, schemaStackCapacity),
+      documentStack_(allocator, documentStackCapacity),
+      outputHandler_(0),
+      error_(kObjectType),
+      currentError_(),
+      missingDependents_(),
+      valid_(true)
+#if RAPIDJSON_SCHEMA_VERBOSE
+      , depth_(depth)
+#endif
+    {
+      if (basePath && basePathSize)
+        memcpy(documentStack_.template Push<char>(basePathSize), basePath, basePathSize);
+    }
+
+    StateAllocator &GetStateAllocator()
+    {
+      if (!stateAllocator_)
+        stateAllocator_ = ownStateAllocator_ = RAPIDJSON_NEW(StateAllocator)();
+      return *stateAllocator_;
+    }
+
+    bool BeginValue()
+    {
+      if (schemaStack_.Empty())
+        PushSchema(root_);
+      else
+        {
+          if (CurrentContext().inArray)
+            internal::TokenHelper<internal::Stack<StateAllocator>, Ch>::AppendIndexToken(documentStack_, CurrentContext().arrayElementIndex);
+
+          if (!CurrentSchema().BeginValue(CurrentContext()))
+            return false;
+
+          SizeType count = CurrentContext().patternPropertiesSchemaCount;
+          const SchemaType **sa = CurrentContext().patternPropertiesSchemas;
+          typename Context::PatternValidatorType patternValidatorType = CurrentContext().valuePatternValidatorType;
+          bool valueUniqueness = CurrentContext().valueUniqueness;
+          RAPIDJSON_ASSERT(CurrentContext().valueSchema);
+          PushSchema(*CurrentContext().valueSchema);
+
+          if (count > 0)
+            {
+              CurrentContext().objectPatternValidatorType = patternValidatorType;
+              ISchemaValidator ** &va = CurrentContext().patternPropertiesValidators;
+              SizeType &validatorCount = CurrentContext().patternPropertiesValidatorCount;
+              va = static_cast<ISchemaValidator **>(MallocState(sizeof(ISchemaValidator *) * count));
+              for (SizeType i = 0; i < count; i++)
+                va[validatorCount++] = CreateSchemaValidator(*sa[i]);
+            }
+
+          CurrentContext().arrayUniqueness = valueUniqueness;
+        }
+      return true;
+    }
+
+    bool EndValue()
+    {
+      if (!CurrentSchema().EndValue(CurrentContext()))
+        return false;
+
+#if RAPIDJSON_SCHEMA_VERBOSE
+      GenericStringBuffer<EncodingType> sb;
+      schemaDocument_->GetPointer(&CurrentSchema()).Stringify(sb);
+
+      *documentStack_.template Push<Ch>() = '\0';
+      documentStack_.template Pop<Ch>(1);
+      internal::PrintValidatorPointers(depth_, sb.GetString(), documentStack_.template Bottom<Ch>());
+#endif
+
+      uint64_t h = CurrentContext().arrayUniqueness ? static_cast<HasherType *>(CurrentContext().hasher)->GetHashCode() : 0;
+
+      PopSchema();
+
+      if (!schemaStack_.Empty())
+        {
+          Context &context = CurrentContext();
+          if (context.valueUniqueness)
+            {
+              HashCodeArray *a = static_cast<HashCodeArray *>(context.arrayElementHashCodes);
+              if (!a)
+                CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType);
+              for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr)
+                if (itr->GetUint64() == h)
+                  {
+                    DuplicateItems(static_cast<SizeType>(itr - a->Begin()), a->Size());
+                    RAPIDJSON_INVALID_KEYWORD_RETURN(SchemaType::GetUniqueItemsString());
+                  }
+              a->PushBack(h, GetStateAllocator());
+            }
+        }
+
+      // Remove the last token of document pointer
+      while (!documentStack_.Empty() && *documentStack_.template Pop<Ch>(1) != '/')
+        ;
+
+      return true;
+    }
+
+    void AppendToken(const Ch *str, SizeType len)
+    {
+      documentStack_.template Reserve<Ch>(1 + len * 2); // worst case all characters are escaped as two characters
+      *documentStack_.template PushUnsafe<Ch>() = '/';
+      for (SizeType i = 0; i < len; i++)
+        {
+          if (str[i] == '~')
+            {
+              *documentStack_.template PushUnsafe<Ch>() = '~';
+              *documentStack_.template PushUnsafe<Ch>() = '0';
+            }
+          else if (str[i] == '/')
+            {
+              *documentStack_.template PushUnsafe<Ch>() = '~';
+              *documentStack_.template PushUnsafe<Ch>() = '1';
+            }
+          else
+            *documentStack_.template PushUnsafe<Ch>() = str[i];
+        }
+    }
+
+    RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType &schema)
+    {
+      new (schemaStack_.template Push<Context>()) Context(*this, *this, &schema);
+    }
+
+    RAPIDJSON_FORCEINLINE void PopSchema()
+    {
+      Context *c = schemaStack_.template Pop<Context>(1);
+      if (HashCodeArray *a = static_cast<HashCodeArray *>(c->arrayElementHashCodes))
+        {
+          a->~HashCodeArray();
+          StateAllocator::Free(a);
+        }
+      c->~Context();
+    }
+
+    void AddErrorLocation(ValueType &result, bool parent)
+    {
+      GenericStringBuffer<EncodingType> sb;
+      PointerType instancePointer = GetInvalidDocumentPointer();
+      ((parent && instancePointer.GetTokenCount() > 0)
+       ? PointerType(instancePointer.GetTokens(), instancePointer.GetTokenCount() - 1)
+       : instancePointer).StringifyUriFragment(sb);
+      ValueType instanceRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
+                            GetStateAllocator());
+      result.AddMember(GetInstanceRefString(), instanceRef, GetStateAllocator());
+      sb.Clear();
+      memcpy(sb.Push(CurrentSchema().GetURI().GetStringLength()),
+             CurrentSchema().GetURI().GetString(),
+             CurrentSchema().GetURI().GetStringLength() * sizeof(Ch));
+      GetInvalidSchemaPointer().StringifyUriFragment(sb);
+      ValueType schemaRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
+                          GetStateAllocator());
+      result.AddMember(GetSchemaRefString(), schemaRef, GetStateAllocator());
+    }
+
+    void AddError(ValueType &keyword, ValueType &error)
+    {
+      typename ValueType::MemberIterator member = error_.FindMember(keyword);
+      if (member == error_.MemberEnd())
+        error_.AddMember(keyword, error, GetStateAllocator());
+      else
+        {
+          if (member->value.IsObject())
+            {
+              ValueType errors(kArrayType);
+              errors.PushBack(member->value, GetStateAllocator());
+              member->value = errors;
+            }
+          member->value.PushBack(error, GetStateAllocator());
+        }
+    }
+
+    void AddCurrentError(const typename SchemaType::ValueType &keyword, bool parent = false)
+    {
+      AddErrorLocation(currentError_, parent);
+      AddError(ValueType(keyword, GetStateAllocator(), false).Move(), currentError_);
+    }
+
+    void MergeError(ValueType &other)
+    {
+      for (typename ValueType::MemberIterator it = other.MemberBegin(), end = other.MemberEnd(); it != end; ++it)
+        {
+          AddError(it->name, it->value);
+        }
+    }
+
+    void AddNumberError(const typename SchemaType::ValueType &keyword, ValueType &actual, const SValue &expected,
+                        const typename SchemaType::ValueType& (*exclusive)() = 0)
+    {
+      currentError_.SetObject();
+      currentError_.AddMember(GetActualString(), actual, GetStateAllocator());
+      currentError_.AddMember(GetExpectedString(), ValueType(expected, GetStateAllocator()).Move(), GetStateAllocator());
+      if (exclusive)
+        currentError_.AddMember(ValueType(exclusive(), GetStateAllocator()).Move(), true, GetStateAllocator());
+      AddCurrentError(keyword);
+    }
+
+    void AddErrorArray(const typename SchemaType::ValueType &keyword,
+                       ISchemaValidator **subvalidators, SizeType count)
+    {
+      ValueType errors(kArrayType);
+      for (SizeType i = 0; i < count; ++i)
+        errors.PushBack(static_cast<GenericSchemaValidator *>(subvalidators[i])->GetError(), GetStateAllocator());
+      currentError_.SetObject();
+      currentError_.AddMember(GetErrorsString(), errors, GetStateAllocator());
+      AddCurrentError(keyword);
+    }
+
+    const SchemaType &CurrentSchema() const
+    {
+      return *schemaStack_.template Top<Context>()->schema;
+    }
+    Context &CurrentContext()
+    {
+      return *schemaStack_.template Top<Context>();
+    }
+    const Context &CurrentContext() const
+    {
+      return *schemaStack_.template Top<Context>();
+    }
+
+    static const size_t kDefaultSchemaStackCapacity = 1024;
+    static const size_t kDefaultDocumentStackCapacity = 256;
+    const SchemaDocumentType *schemaDocument_;
+    const SchemaType &root_;
+    StateAllocator *stateAllocator_;
+    StateAllocator *ownStateAllocator_;
+    internal::Stack<StateAllocator> schemaStack_;    //!< stack to store the current path of schema (BaseSchemaType *)
+    internal::Stack<StateAllocator> documentStack_;  //!< stack to store the current path of validating document (Ch)
+    OutputHandler *outputHandler_;
+    ValueType error_;
+    ValueType currentError_;
+    ValueType missingDependents_;
+    bool valid_;
+#if RAPIDJSON_SCHEMA_VERBOSE
+    unsigned depth_;
+#endif
+};
+
+typedef GenericSchemaValidator<SchemaDocument> SchemaValidator;
+
+///////////////////////////////////////////////////////////////////////////////
+// SchemaValidatingReader
+
+//! A helper class for parsing with validation.
+/*!
+    This helper class is a functor, designed as a parameter of \ref GenericDocument::Populate().
+
+    \tparam parseFlags Combination of \ref ParseFlag.
+    \tparam InputStream Type of input stream, implementing Stream concept.
+    \tparam SourceEncoding Encoding of the input stream.
+    \tparam SchemaDocumentType Type of schema document.
+    \tparam StackAllocator Allocator type for stack.
+*/
+template <
+  unsigned parseFlags,
+  typename InputStream,
+  typename SourceEncoding,
+  typename SchemaDocumentType = SchemaDocument,
+  typename StackAllocator = CrtAllocator>
+class SchemaValidatingReader
+{
+  public:
+    typedef typename SchemaDocumentType::PointerType PointerType;
+    typedef typename InputStream::Ch Ch;
+    typedef GenericValue<SourceEncoding, StackAllocator> ValueType;
+
+    //! Constructor
+    /*!
+        \param is Input stream.
+        \param sd Schema document.
+    */
+    SchemaValidatingReader(InputStream &is, const SchemaDocumentType &sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), error_(kObjectType), isValid_(true) {}
+
+    template <typename Handler>
+    bool operator()(Handler &handler)
+    {
+      GenericReader<SourceEncoding, typename SchemaDocumentType::EncodingType, StackAllocator> reader;
+      GenericSchemaValidator<SchemaDocumentType, Handler> validator(sd_, handler);
+      parseResult_ = reader.template Parse<parseFlags>(is_, validator);
+
+      isValid_ = validator.IsValid();
+      if (isValid_)
+        {
+          invalidSchemaPointer_ = PointerType();
+          invalidSchemaKeyword_ = 0;
+          invalidDocumentPointer_ = PointerType();
+          error_.SetObject();
+        }
+      else
+        {
+          invalidSchemaPointer_ = validator.GetInvalidSchemaPointer();
+          invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword();
+          invalidDocumentPointer_ = validator.GetInvalidDocumentPointer();
+          error_.CopyFrom(validator.GetError(), allocator_);
+        }
+
+      return parseResult_;
+    }
+
+    const ParseResult &GetParseResult() const
+    {
+      return parseResult_;
+    }
+    bool IsValid() const
+    {
+      return isValid_;
+    }
+    const PointerType &GetInvalidSchemaPointer() const
+    {
+      return invalidSchemaPointer_;
+    }
+    const Ch *GetInvalidSchemaKeyword() const
+    {
+      return invalidSchemaKeyword_;
+    }
+    const PointerType &GetInvalidDocumentPointer() const
+    {
+      return invalidDocumentPointer_;
+    }
+    const ValueType &GetError() const
+    {
+      return error_;
+    }
+
+  private:
+    InputStream &is_;
+    const SchemaDocumentType &sd_;
+
+    ParseResult parseResult_;
+    PointerType invalidSchemaPointer_;
+    const Ch *invalidSchemaKeyword_;
+    PointerType invalidDocumentPointer_;
+    StackAllocator allocator_;
+    ValueType error_;
+    bool isValid_;
+};
+
+RAPIDJSON_NAMESPACE_END
+RAPIDJSON_DIAG_POP
+
+#endif // RAPIDJSON_SCHEMA_H_
diff --git a/contrib/world_builder/include/rapidjson/stream.h.bak b/contrib/world_builder/include/rapidjson/stream.h.bak
new file mode 100644
index 00000000000..adf4ed30cff
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/stream.h.bak
@@ -0,0 +1,312 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#include "rapidjson.h"
+
+#ifndef RAPIDJSON_STREAM_H_
+#define RAPIDJSON_STREAM_H_
+
+#include "encodings.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+//  Stream
+
+/*! \class rapidjson::Stream
+    \brief Concept for reading and writing characters.
+
+    For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().
+
+    For write-only stream, only need to implement Put() and Flush().
+
+\code
+concept Stream {
+    typename Ch;    //!< Character type of the stream.
+
+    //! Read the current character from stream without moving the read cursor.
+    Ch Peek() const;
+
+    //! Read the current character from stream and moving the read cursor to next character.
+    Ch Take();
+
+    //! Get the current read cursor.
+    //! \return Number of characters read from start.
+    size_t Tell();
+
+    //! Begin writing operation at the current read pointer.
+    //! \return The begin writer pointer.
+    Ch* PutBegin();
+
+    //! Write a character.
+    void Put(Ch c);
+
+    //! Flush the buffer.
+    void Flush();
+
+    //! End the writing operation.
+    //! \param begin The begin write pointer returned by PutBegin().
+    //! \return Number of characters written.
+    size_t PutEnd(Ch* begin);
+}
+\endcode
+*/
+
+//! Provides additional information for stream.
+/*!
+    By using traits pattern, this type provides a default configuration for stream.
+    For custom stream, this type can be specialized for other configuration.
+    See TEST(Reader, CustomStringStream) in readertest.cpp for example.
+*/
+template<typename Stream>
+struct StreamTraits
+{
+  //! Whether to make local copy of stream for optimization during parsing.
+  /*!
+      By default, for safety, streams do not use local copy optimization.
+      Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
+  */
+  enum { copyOptimization = 0 };
+};
+
+//! Reserve n characters for writing to a stream.
+template<typename Stream>
+inline void PutReserve(Stream &stream, size_t count)
+{
+  (void)stream;
+  (void)count;
+}
+
+//! Write character to a stream, presuming buffer is reserved.
+template<typename Stream>
+inline void PutUnsafe(Stream &stream, typename Stream::Ch c)
+{
+  stream.Put(c);
+}
+
+//! Put N copies of a character to a stream.
+template<typename Stream, typename Ch>
+inline void PutN(Stream &stream, Ch c, size_t n)
+{
+  PutReserve(stream, n);
+  for (size_t i = 0; i < n; i++)
+    PutUnsafe(stream, c);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericStreamWrapper
+
+//! A Stream Wrapper
+/*! \tThis string stream is a wrapper for any stream by just forwarding any
+    \treceived message to the origin stream.
+    \note implements Stream concept
+*/
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
+RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
+#endif
+
+template <typename InputStream, typename Encoding = UTF8<> >
+class GenericStreamWrapper
+{
+  public:
+    typedef typename Encoding::Ch Ch;
+    GenericStreamWrapper(InputStream &is): is_(is) {}
+
+    Ch Peek() const
+    {
+      return is_.Peek();
+    }
+    Ch Take()
+    {
+      return is_.Take();
+    }
+    size_t Tell()
+    {
+      return is_.Tell();
+    }
+    Ch *PutBegin()
+    {
+      return is_.PutBegin();
+    }
+    void Put(Ch ch)
+    {
+      is_.Put(ch);
+    }
+    void Flush()
+    {
+      is_.Flush();
+    }
+    size_t PutEnd(Ch *ch)
+    {
+      return is_.PutEnd(ch);
+    }
+
+    // wrapper for MemoryStream
+    const Ch *Peek4() const
+    {
+      return is_.Peek4();
+    }
+
+    // wrapper for AutoUTFInputStream
+    UTFType GetType() const
+    {
+      return is_.GetType();
+    }
+    bool HasBOM() const
+    {
+      return is_.HasBOM();
+    }
+
+  protected:
+    InputStream &is_;
+};
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+RAPIDJSON_DIAG_POP
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// StringStream
+
+//! Read-only string stream.
+/*! \note implements Stream concept
+*/
+template <typename Encoding>
+struct GenericStringStream
+{
+  typedef typename Encoding::Ch Ch;
+
+  GenericStringStream(const Ch *src) : src_(src), head_(src) {}
+
+  Ch Peek() const
+  {
+    return *src_;
+  }
+  Ch Take()
+  {
+    return *src_++;
+  }
+  size_t Tell() const
+  {
+    return static_cast<size_t>(src_ - head_);
+  }
+
+  Ch *PutBegin()
+  {
+    RAPIDJSON_ASSERT(false);
+    return 0;
+  }
+  void Put(Ch)
+  {
+    RAPIDJSON_ASSERT(false);
+  }
+  void Flush()
+  {
+    RAPIDJSON_ASSERT(false);
+  }
+  size_t PutEnd(Ch *)
+  {
+    RAPIDJSON_ASSERT(false);
+    return 0;
+  }
+
+  const Ch *src_;     //!< Current read position.
+  const Ch *head_;    //!< Original head of the string.
+};
+
+template <typename Encoding>
+struct StreamTraits<GenericStringStream<Encoding> >
+{
+  enum { copyOptimization = 1 };
+};
+
+//! String stream with UTF8 encoding.
+typedef GenericStringStream<UTF8<> > StringStream;
+
+///////////////////////////////////////////////////////////////////////////////
+// InsituStringStream
+
+//! A read-write string stream.
+/*! This string stream is particularly designed for in-situ parsing.
+    \note implements Stream concept
+*/
+template <typename Encoding>
+struct GenericInsituStringStream
+{
+  typedef typename Encoding::Ch Ch;
+
+  GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
+
+  // Read
+  Ch Peek()
+  {
+    return *src_;
+  }
+  Ch Take()
+  {
+    return *src_++;
+  }
+  size_t Tell()
+  {
+    return static_cast<size_t>(src_ - head_);
+  }
+
+  // Write
+  void Put(Ch c)
+  {
+    RAPIDJSON_ASSERT(dst_ != 0);
+    *dst_++ = c;
+  }
+
+  Ch *PutBegin()
+  {
+    return dst_ = src_;
+  }
+  size_t PutEnd(Ch *begin)
+  {
+    return static_cast<size_t>(dst_ - begin);
+  }
+  void Flush() {}
+
+  Ch *Push(size_t count)
+  {
+    Ch *begin = dst_;
+    dst_ += count;
+    return begin;
+  }
+  void Pop(size_t count)
+  {
+    dst_ -= count;
+  }
+
+  Ch *src_;
+  Ch *dst_;
+  Ch *head_;
+};
+
+template <typename Encoding>
+struct StreamTraits<GenericInsituStringStream<Encoding> >
+{
+  enum { copyOptimization = 1 };
+};
+
+//! Insitu string stream with UTF8 encoding.
+typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_STREAM_H_
diff --git a/contrib/world_builder/include/rapidjson/stringbuffer.h.bak b/contrib/world_builder/include/rapidjson/stringbuffer.h.bak
new file mode 100644
index 00000000000..1e917796e4c
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/stringbuffer.h.bak
@@ -0,0 +1,155 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_STRINGBUFFER_H_
+#define RAPIDJSON_STRINGBUFFER_H_
+
+#include "stream.h"
+#include "internal/stack.h"
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+#include <utility> // std::move
+#endif
+
+#include "internal/stack.h"
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Represents an in-memory output stream.
+/*!
+    \tparam Encoding Encoding of the stream.
+    \tparam Allocator type for allocating memory buffer.
+    \note implements Stream concept
+*/
+template <typename Encoding, typename Allocator = CrtAllocator>
+class GenericStringBuffer
+{
+  public:
+    typedef typename Encoding::Ch Ch;
+
+    GenericStringBuffer(Allocator *allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    GenericStringBuffer(GenericStringBuffer &&rhs) : stack_(std::move(rhs.stack_)) {}
+    GenericStringBuffer &operator=(GenericStringBuffer&& rhs)
+    {
+      if (&rhs != this)
+        stack_ = std::move(rhs.stack_);
+      return *this;
+    }
+#endif
+
+    void Put(Ch c)
+    {
+      *stack_.template Push<Ch>() = c;
+    }
+    void PutUnsafe(Ch c)
+    {
+      *stack_.template PushUnsafe<Ch>() = c;
+    }
+    void Flush() {}
+
+    void Clear()
+    {
+      stack_.Clear();
+    }
+    void ShrinkToFit()
+    {
+      // Push and pop a null terminator. This is safe.
+      *stack_.template Push<Ch>() = '\0';
+      stack_.ShrinkToFit();
+      stack_.template Pop<Ch>(1);
+    }
+
+    void Reserve(size_t count)
+    {
+      stack_.template Reserve<Ch>(count);
+    }
+    Ch *Push(size_t count)
+    {
+      return stack_.template Push<Ch>(count);
+    }
+    Ch *PushUnsafe(size_t count)
+    {
+      return stack_.template PushUnsafe<Ch>(count);
+    }
+    void Pop(size_t count)
+    {
+      stack_.template Pop<Ch>(count);
+    }
+
+    const Ch *GetString() const
+    {
+      // Push and pop a null terminator. This is safe.
+      *stack_.template Push<Ch>() = '\0';
+      stack_.template Pop<Ch>(1);
+
+      return stack_.template Bottom<Ch>();
+    }
+
+    //! Get the size of string in bytes in the string buffer.
+    size_t GetSize() const
+    {
+      return stack_.GetSize();
+    }
+
+    //! Get the length of string in Ch in the string buffer.
+    size_t GetLength() const
+    {
+      return stack_.GetSize() / sizeof(Ch);
+    }
+
+    static const size_t kDefaultCapacity = 256;
+    mutable internal::Stack<Allocator> stack_;
+
+  private:
+    // Prohibit copy constructor & assignment operator.
+    GenericStringBuffer(const GenericStringBuffer &);
+    GenericStringBuffer &operator=(const GenericStringBuffer &);
+};
+
+//! String buffer with UTF8 encoding
+typedef GenericStringBuffer<UTF8<> > StringBuffer;
+
+template<typename Encoding, typename Allocator>
+inline void PutReserve(GenericStringBuffer<Encoding, Allocator> &stream, size_t count)
+{
+  stream.Reserve(count);
+}
+
+template<typename Encoding, typename Allocator>
+inline void PutUnsafe(GenericStringBuffer<Encoding, Allocator> &stream, typename Encoding::Ch c)
+{
+  stream.PutUnsafe(c);
+}
+
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(GenericStringBuffer<UTF8<> > &stream, char c, size_t n)
+{
+  std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_STRINGBUFFER_H_
diff --git a/contrib/world_builder/include/rapidjson/writer.h.bak b/contrib/world_builder/include/rapidjson/writer.h.bak
new file mode 100644
index 00000000000..815dfcdde83
--- /dev/null
+++ b/contrib/world_builder/include/rapidjson/writer.h.bak
@@ -0,0 +1,867 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_WRITER_H_
+#define RAPIDJSON_WRITER_H_
+
+#include "stream.h"
+#include "internal/meta.h"
+#include "internal/stack.h"
+#include "internal/strfunc.h"
+#include "internal/dtoa.h"
+#include "internal/itoa.h"
+#include "stringbuffer.h"
+#include <new>      // placement new
+
+#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
+#include <intrin.h>
+#pragma intrinsic(_BitScanForward)
+#endif
+#ifdef RAPIDJSON_SSE42
+#include <nmmintrin.h>
+#elif defined(RAPIDJSON_SSE2)
+#include <emmintrin.h>
+#elif defined(RAPIDJSON_NEON)
+#include <arm_neon.h>
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(unreachable-code)
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#elif defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// WriteFlag
+
+/*! \def RAPIDJSON_WRITE_DEFAULT_FLAGS
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-defined kWriteDefaultFlags definition.
+
+    User can define this as any \c WriteFlag combinations.
+*/
+#ifndef RAPIDJSON_WRITE_DEFAULT_FLAGS
+#define RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags
+#endif
+
+//! Combination of writeFlags
+enum WriteFlag
+{
+  kWriteNoFlags = 0,              //!< No flags are set.
+  kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings.
+  kWriteNanAndInfFlag = 2,        //!< Allow writing of Infinity, -Infinity and NaN.
+  kWriteDefaultFlags = RAPIDJSON_WRITE_DEFAULT_FLAGS  //!< Default write flags. Can be customized by defining RAPIDJSON_WRITE_DEFAULT_FLAGS
+};
+
+//! JSON writer
+/*! Writer implements the concept Handler.
+    It generates JSON text by events to an output os.
+
+    User may programmatically calls the functions of a writer to generate JSON text.
+
+    On the other side, a writer can also be passed to objects that generates events,
+
+    for example Reader::Parse() and Document::Accept().
+
+    \tparam OutputStream Type of output stream.
+    \tparam SourceEncoding Encoding of source string.
+    \tparam TargetEncoding Encoding of output stream.
+    \tparam StackAllocator Type of allocator for allocating memory of stack.
+    \note implements Handler concept
+*/
+template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
+class Writer
+{
+  public:
+    typedef typename SourceEncoding::Ch Ch;
+
+    static const int kDefaultMaxDecimalPlaces = 324;
+
+    //! Constructor
+    /*! \param os Output stream.
+        \param stackAllocator User supplied allocator. If it is null, it will create a private one.
+        \param levelDepth Initial capacity of stack.
+    */
+    explicit
+    Writer(OutputStream &os, StackAllocator *stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) :
+      os_(&os), level_stack_(stackAllocator, levelDepth *sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
+
+    explicit
+    Writer(StackAllocator *allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
+      os_(0), level_stack_(allocator, levelDepth *sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    Writer(Writer &&rhs) :
+      os_(rhs.os_), level_stack_(std::move(rhs.level_stack_)), maxDecimalPlaces_(rhs.maxDecimalPlaces_), hasRoot_(rhs.hasRoot_)
+    {
+      rhs.os_ = 0;
+    }
+#endif
+
+    //! Reset the writer with a new stream.
+    /*!
+        This function reset the writer with a new stream and default settings,
+        in order to make a Writer object reusable for output multiple JSONs.
+
+        \param os New output stream.
+        \code
+        Writer<OutputStream> writer(os1);
+        writer.StartObject();
+        // ...
+        writer.EndObject();
+
+        writer.Reset(os2);
+        writer.StartObject();
+        // ...
+        writer.EndObject();
+        \endcode
+    */
+    void Reset(OutputStream &os)
+    {
+      os_ = &os;
+      hasRoot_ = false;
+      level_stack_.Clear();
+    }
+
+    //! Checks whether the output is a complete JSON.
+    /*!
+        A complete JSON has a complete root object or array.
+    */
+    bool IsComplete() const
+    {
+      return hasRoot_ && level_stack_.Empty();
+    }
+
+    int GetMaxDecimalPlaces() const
+    {
+      return maxDecimalPlaces_;
+    }
+
+    //! Sets the maximum number of decimal places for double output.
+    /*!
+        This setting truncates the output with specified number of decimal places.
+
+        For example,
+
+        \code
+        writer.SetMaxDecimalPlaces(3);
+        writer.StartArray();
+        writer.Double(0.12345);                 // "0.123"
+        writer.Double(0.0001);                  // "0.0"
+        writer.Double(1.234567890123456e30);    // "1.234567890123456e30" (do not truncate significand for positive exponent)
+        writer.Double(1.23e-4);                 // "0.0"                  (do truncate significand for negative exponent)
+        writer.EndArray();
+        \endcode
+
+        The default setting does not truncate any decimal places. You can restore to this setting by calling
+        \code
+        writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces);
+        \endcode
+    */
+    void SetMaxDecimalPlaces(int maxDecimalPlaces)
+    {
+      maxDecimalPlaces_ = maxDecimalPlaces;
+    }
+
+    /*!@name Implementation of Handler
+        \see Handler
+    */
+    //@{
+
+    bool Null()
+    {
+      Prefix(kNullType);
+      return EndValue(WriteNull());
+    }
+    bool Bool(bool b)
+    {
+      Prefix(b ? kTrueType : kFalseType);
+      return EndValue(WriteBool(b));
+    }
+    bool Int(int i)
+    {
+      Prefix(kNumberType);
+      return EndValue(WriteInt(i));
+    }
+    bool Uint(unsigned u)
+    {
+      Prefix(kNumberType);
+      return EndValue(WriteUint(u));
+    }
+    bool Int64(int64_t i64)
+    {
+      Prefix(kNumberType);
+      return EndValue(WriteInt64(i64));
+    }
+    bool Uint64(uint64_t u64)
+    {
+      Prefix(kNumberType);
+      return EndValue(WriteUint64(u64));
+    }
+
+    //! Writes the given \c double value to the stream
+    /*!
+        \param d The value to be written.
+        \return Whether it is succeed.
+    */
+    bool Double(double d)
+    {
+      Prefix(kNumberType);
+      return EndValue(WriteDouble(d));
+    }
+
+    bool RawNumber(const Ch *str, SizeType length, bool copy = false)
+    {
+      RAPIDJSON_ASSERT(str != 0);
+      (void)copy;
+      Prefix(kNumberType);
+      return EndValue(WriteString(str, length));
+    }
+
+    bool String(const Ch *str, SizeType length, bool copy = false)
+    {
+      RAPIDJSON_ASSERT(str != 0);
+      (void)copy;
+      Prefix(kStringType);
+      return EndValue(WriteString(str, length));
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool String(const std::basic_string<Ch> &str)
+    {
+      return String(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool StartObject()
+    {
+      Prefix(kObjectType);
+      new (level_stack_.template Push<Level>()) Level(false);
+      return WriteStartObject();
+    }
+
+    bool Key(const Ch *str, SizeType length, bool copy = false)
+    {
+      return String(str, length, copy);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool Key(const std::basic_string<Ch> &str)
+    {
+      return Key(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool EndObject(SizeType memberCount = 0)
+    {
+      (void)memberCount;
+      RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object
+      RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray); // currently inside an Array, not Object
+      RAPIDJSON_ASSERT(0 == level_stack_.template Top<Level>()->valueCount % 2); // Object has a Key without a Value
+      level_stack_.template Pop<Level>(1);
+      return EndValue(WriteEndObject());
+    }
+
+    bool StartArray()
+    {
+      Prefix(kArrayType);
+      new (level_stack_.template Push<Level>()) Level(true);
+      return WriteStartArray();
+    }
+
+    bool EndArray(SizeType elementCount = 0)
+    {
+      (void)elementCount;
+      RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
+      RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
+      level_stack_.template Pop<Level>(1);
+      return EndValue(WriteEndArray());
+    }
+    //@}
+
+    /*! @name Convenience extensions */
+    //@{
+
+    //! Simpler but slower overload.
+    bool String(const Ch *const &str)
+    {
+      return String(str, internal::StrLen(str));
+    }
+    bool Key(const Ch *const &str)
+    {
+      return Key(str, internal::StrLen(str));
+    }
+
+    //@}
+
+    //! Write a raw JSON value.
+    /*!
+        For user to write a stringified JSON as a value.
+
+        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
+        \param length Length of the json.
+        \param type Type of the root of json.
+    */
+    bool RawValue(const Ch *json, size_t length, Type type)
+    {
+      RAPIDJSON_ASSERT(json != 0);
+      Prefix(type);
+      return EndValue(WriteRawValue(json, length));
+    }
+
+    //! Flush the output stream.
+    /*!
+        Allows the user to flush the output stream immediately.
+     */
+    void Flush()
+    {
+      os_->Flush();
+    }
+
+  protected:
+    //! Information for each nested level
+    struct Level
+    {
+      Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
+      size_t valueCount;  //!< number of values in this level
+      bool inArray;       //!< true if in array, otherwise in object
+    };
+
+    static const size_t kDefaultLevelDepth = 32;
+
+    bool WriteNull()
+    {
+      PutReserve(*os_, 4);
+      PutUnsafe(*os_, 'n');
+      PutUnsafe(*os_, 'u');
+      PutUnsafe(*os_, 'l');
+      PutUnsafe(*os_, 'l');
+      return true;
+    }
+
+    bool WriteBool(bool b)
+    {
+      if (b)
+        {
+          PutReserve(*os_, 4);
+          PutUnsafe(*os_, 't');
+          PutUnsafe(*os_, 'r');
+          PutUnsafe(*os_, 'u');
+          PutUnsafe(*os_, 'e');
+        }
+      else
+        {
+          PutReserve(*os_, 5);
+          PutUnsafe(*os_, 'f');
+          PutUnsafe(*os_, 'a');
+          PutUnsafe(*os_, 'l');
+          PutUnsafe(*os_, 's');
+          PutUnsafe(*os_, 'e');
+        }
+      return true;
+    }
+
+    bool WriteInt(int i)
+    {
+      char buffer[11];
+      const char *end = internal::i32toa(i, buffer);
+      PutReserve(*os_, static_cast<size_t>(end - buffer));
+      for (const char *p = buffer; p != end; ++p)
+        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
+      return true;
+    }
+
+    bool WriteUint(unsigned u)
+    {
+      char buffer[10];
+      const char *end = internal::u32toa(u, buffer);
+      PutReserve(*os_, static_cast<size_t>(end - buffer));
+      for (const char *p = buffer; p != end; ++p)
+        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
+      return true;
+    }
+
+    bool WriteInt64(int64_t i64)
+    {
+      char buffer[21];
+      const char *end = internal::i64toa(i64, buffer);
+      PutReserve(*os_, static_cast<size_t>(end - buffer));
+      for (const char *p = buffer; p != end; ++p)
+        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
+      return true;
+    }
+
+    bool WriteUint64(uint64_t u64)
+    {
+      char buffer[20];
+      char *end = internal::u64toa(u64, buffer);
+      PutReserve(*os_, static_cast<size_t>(end - buffer));
+      for (char *p = buffer; p != end; ++p)
+        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
+      return true;
+    }
+
+    bool WriteDouble(double d)
+    {
+      if (internal::Double(d).IsNanOrInf())
+        {
+          if (!(writeFlags & kWriteNanAndInfFlag))
+            return false;
+          if (internal::Double(d).IsNan())
+            {
+              PutReserve(*os_, 3);
+              PutUnsafe(*os_, 'N');
+              PutUnsafe(*os_, 'a');
+              PutUnsafe(*os_, 'N');
+              return true;
+            }
+          if (internal::Double(d).Sign())
+            {
+              PutReserve(*os_, 9);
+              PutUnsafe(*os_, '-');
+            }
+          else
+            PutReserve(*os_, 8);
+          PutUnsafe(*os_, 'I');
+          PutUnsafe(*os_, 'n');
+          PutUnsafe(*os_, 'f');
+          PutUnsafe(*os_, 'i');
+          PutUnsafe(*os_, 'n');
+          PutUnsafe(*os_, 'i');
+          PutUnsafe(*os_, 't');
+          PutUnsafe(*os_, 'y');
+          return true;
+        }
+
+      char buffer[25];
+      char *end = internal::dtoa(d, buffer, maxDecimalPlaces_);
+      PutReserve(*os_, static_cast<size_t>(end - buffer));
+      for (char *p = buffer; p != end; ++p)
+        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
+      return true;
+    }
+
+    bool WriteString(const Ch *str, SizeType length, bool quotes = true)
+    {
+      static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+      static const char escape[256] =
+      {
+#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+        //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
+        'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
+        'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
+        0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
+        Z16, Z16,                                                                       // 30~4F
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
+        Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
+#undef Z16
+      };
+
+      if (quotes)
+        {
+          if (TargetEncoding::supportUnicode)
+            PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
+          else
+            PutReserve(*os_, 2 + length * 12);  // "\uxxxx\uyyyy..."
+        }
+      else
+        {
+          if (TargetEncoding::supportUnicode)
+            PutReserve(*os_, length * 6); // "\uxxxx..."
+          else
+            PutReserve(*os_, length * 12);  // "\uxxxx\uyyyy..."
+        }
+
+      if (quotes)
+        PutUnsafe(*os_, '\"');
+      GenericStringStream<SourceEncoding> is(str);
+      while (ScanWriteUnescapedString(is, length))
+        {
+          const Ch c = is.Peek();
+          if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80)
+            {
+              // Unicode escaping
+              unsigned codepoint;
+              if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
+                return false;
+              PutUnsafe(*os_, '\\');
+              PutUnsafe(*os_, 'u');
+              if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF))
+                {
+                  PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
+                  PutUnsafe(*os_, hexDigits[(codepoint >>  8) & 15]);
+                  PutUnsafe(*os_, hexDigits[(codepoint >>  4) & 15]);
+                  PutUnsafe(*os_, hexDigits[(codepoint      ) & 15]);
+                }
+              else
+                {
+                  RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
+                  // Surrogate pair
+                  unsigned s = codepoint - 0x010000;
+                  unsigned lead = (s >> 10) + 0xD800;
+                  unsigned trail = (s & 0x3FF) + 0xDC00;
+                  PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
+                  PutUnsafe(*os_, hexDigits[(lead >>  8) & 15]);
+                  PutUnsafe(*os_, hexDigits[(lead >>  4) & 15]);
+                  PutUnsafe(*os_, hexDigits[(lead      ) & 15]);
+                  PutUnsafe(*os_, '\\');
+                  PutUnsafe(*os_, 'u');
+                  PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
+                  PutUnsafe(*os_, hexDigits[(trail >>  8) & 15]);
+                  PutUnsafe(*os_, hexDigits[(trail >>  4) & 15]);
+                  PutUnsafe(*os_, hexDigits[(trail      ) & 15]);
+                }
+            }
+          else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)]))
+            {
+              is.Take();
+              if (quotes)
+                PutUnsafe(*os_, '\\');
+              PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(escape[static_cast<unsigned char>(c)]));
+              if (escape[static_cast<unsigned char>(c)] == 'u')
+                {
+                  PutUnsafe(*os_, '0');
+                  PutUnsafe(*os_, '0');
+                  PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
+                  PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
+                }
+            }
+          else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ?
+                                        Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
+                                        Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
+            return false;
+        }
+      if (quotes)
+        PutUnsafe(*os_, '\"');
+      return true;
+    }
+
+    bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding> &is, size_t length)
+    {
+      return RAPIDJSON_LIKELY(is.Tell() < length);
+    }
+
+    bool WriteStartObject()
+    {
+      os_->Put('{');
+      return true;
+    }
+    bool WriteEndObject()
+    {
+      os_->Put('}');
+      return true;
+    }
+    bool WriteStartArray()
+    {
+      os_->Put('[');
+      return true;
+    }
+    bool WriteEndArray()
+    {
+      os_->Put(']');
+      return true;
+    }
+
+    bool WriteRawValue(const Ch *json, size_t length)
+    {
+      PutReserve(*os_, length);
+      GenericStringStream<SourceEncoding> is(json);
+      while (RAPIDJSON_LIKELY(is.Tell() < length))
+        {
+          RAPIDJSON_ASSERT(is.Peek() != '\0');
+          if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ?
+                                   Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
+                                   Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
+            return false;
+        }
+      return true;
+    }
+
+    void Prefix(Type type)
+    {
+      (void)type;
+      if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0))   // this value is not at root
+        {
+          Level *level = level_stack_.template Top<Level>();
+          if (level->valueCount > 0)
+            {
+              if (level->inArray)
+                os_->Put(','); // add comma if it is not the first element in array
+              else  // in object
+                os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
+            }
+          if (!level->inArray && level->valueCount % 2 == 0)
+            RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
+          level->valueCount++;
+        }
+      else
+        {
+          RAPIDJSON_ASSERT(!hasRoot_);    // Should only has one and only one root.
+          hasRoot_ = true;
+        }
+    }
+
+    // Flush the value if it is the top level one.
+    bool EndValue(bool ret)
+    {
+      if (RAPIDJSON_UNLIKELY(level_stack_.Empty()))   // end of json text
+        Flush();
+      return ret;
+    }
+
+    OutputStream *os_;
+    internal::Stack<StackAllocator> level_stack_;
+    int maxDecimalPlaces_;
+    bool hasRoot_;
+
+  private:
+    // Prohibit copy constructor & assignment operator.
+    Writer(const Writer &);
+    Writer &operator=(const Writer &);
+};
+
+// Full specialization for StringStream to prevent memory copying
+
+template<>
+inline bool Writer<StringBuffer>::WriteInt(int i)
+{
+  char *buffer = os_->Push(11);
+  const char *end = internal::i32toa(i, buffer);
+  os_->Pop(static_cast<size_t>(11 - (end - buffer)));
+  return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteUint(unsigned u)
+{
+  char *buffer = os_->Push(10);
+  const char *end = internal::u32toa(u, buffer);
+  os_->Pop(static_cast<size_t>(10 - (end - buffer)));
+  return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteInt64(int64_t i64)
+{
+  char *buffer = os_->Push(21);
+  const char *end = internal::i64toa(i64, buffer);
+  os_->Pop(static_cast<size_t>(21 - (end - buffer)));
+  return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteUint64(uint64_t u)
+{
+  char *buffer = os_->Push(20);
+  const char *end = internal::u64toa(u, buffer);
+  os_->Pop(static_cast<size_t>(20 - (end - buffer)));
+  return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteDouble(double d)
+{
+  if (internal::Double(d).IsNanOrInf())
+    {
+      // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
+      if (!(kWriteDefaultFlags & kWriteNanAndInfFlag))
+        return false;
+      if (internal::Double(d).IsNan())
+        {
+          PutReserve(*os_, 3);
+          PutUnsafe(*os_, 'N');
+          PutUnsafe(*os_, 'a');
+          PutUnsafe(*os_, 'N');
+          return true;
+        }
+      if (internal::Double(d).Sign())
+        {
+          PutReserve(*os_, 9);
+          PutUnsafe(*os_, '-');
+        }
+      else
+        PutReserve(*os_, 8);
+      PutUnsafe(*os_, 'I');
+      PutUnsafe(*os_, 'n');
+      PutUnsafe(*os_, 'f');
+      PutUnsafe(*os_, 'i');
+      PutUnsafe(*os_, 'n');
+      PutUnsafe(*os_, 'i');
+      PutUnsafe(*os_, 't');
+      PutUnsafe(*os_, 'y');
+      return true;
+    }
+
+  char *buffer = os_->Push(25);
+  char *end = internal::dtoa(d, buffer, maxDecimalPlaces_);
+  os_->Pop(static_cast<size_t>(25 - (end - buffer)));
+  return true;
+}
+
+#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
+template<>
+inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream &is, size_t length)
+{
+  if (length < 16)
+    return RAPIDJSON_LIKELY(is.Tell() < length);
+
+  if (!RAPIDJSON_LIKELY(is.Tell() < length))
+    return false;
+
+  const char *p = is.src_;
+  const char *end = is.head_ + length;
+  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+  const char *endAligned = reinterpret_cast<const char *>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
+  if (nextAligned > end)
+    return true;
+
+  while (p != nextAligned)
+    if (*p < 0x20 || *p == '\"' || *p == '\\')
+      {
+        is.src_ = p;
+        return RAPIDJSON_LIKELY(is.Tell() < length);
+      }
+    else
+      os_->PutUnsafe(*p++);
+
+  // The rest of string using SIMD
+  static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
+  static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
+  static const char space[16]  = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
+  const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
+  const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
+  const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
+
+  for (; p != endAligned; p += 16)
+    {
+      const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+      const __m128i t1 = _mm_cmpeq_epi8(s, dq);
+      const __m128i t2 = _mm_cmpeq_epi8(s, bs);
+      const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
+      const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
+      unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
+      if (RAPIDJSON_UNLIKELY(r != 0))     // some of characters is escaped
+        {
+          SizeType len;
+#ifdef _MSC_VER         // Find the index of first escaped
+          unsigned long offset;
+          _BitScanForward(&offset, r);
+          len = offset;
+#else
+          len = static_cast<SizeType>(__builtin_ffs(r) - 1);
+#endif
+          char *q = reinterpret_cast<char *>(os_->PushUnsafe(len));
+          for (size_t i = 0; i < len; i++)
+            q[i] = p[i];
+
+          p += len;
+          break;
+        }
+      _mm_storeu_si128(reinterpret_cast<__m128i *>(os_->PushUnsafe(16)), s);
+    }
+
+  is.src_ = p;
+  return RAPIDJSON_LIKELY(is.Tell() < length);
+}
+#elif defined(RAPIDJSON_NEON)
+template<>
+inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream &is, size_t length)
+{
+  if (length < 16)
+    return RAPIDJSON_LIKELY(is.Tell() < length);
+
+  if (!RAPIDJSON_LIKELY(is.Tell() < length))
+    return false;
+
+  const char *p = is.src_;
+  const char *end = is.head_ + length;
+  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+  const char *endAligned = reinterpret_cast<const char *>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
+  if (nextAligned > end)
+    return true;
+
+  while (p != nextAligned)
+    if (*p < 0x20 || *p == '\"' || *p == '\\')
+      {
+        is.src_ = p;
+        return RAPIDJSON_LIKELY(is.Tell() < length);
+      }
+    else
+      os_->PutUnsafe(*p++);
+
+  // The rest of string using SIMD
+  const uint8x16_t s0 = vmovq_n_u8('"');
+  const uint8x16_t s1 = vmovq_n_u8('\\');
+  const uint8x16_t s2 = vmovq_n_u8('\b');
+  const uint8x16_t s3 = vmovq_n_u8(32);
+
+  for (; p != endAligned; p += 16)
+    {
+      const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
+      uint8x16_t x = vceqq_u8(s, s0);
+      x = vorrq_u8(x, vceqq_u8(s, s1));
+      x = vorrq_u8(x, vceqq_u8(s, s2));
+      x = vorrq_u8(x, vcltq_u8(s, s3));
+
+      x = vrev64q_u8(x);                     // Rev in 64
+      uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
+      uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
+
+      SizeType len = 0;
+      bool escaped = false;
+      if (low == 0)
+        {
+          if (high != 0)
+            {
+              unsigned lz = (unsigned)__builtin_clzll(high);
+              len = 8 + (lz >> 3);
+              escaped = true;
+            }
+        }
+      else
+        {
+          unsigned lz = (unsigned)__builtin_clzll(low);
+          len = lz >> 3;
+          escaped = true;
+        }
+      if (RAPIDJSON_UNLIKELY(escaped))     // some of characters is escaped
+        {
+          char *q = reinterpret_cast<char *>(os_->PushUnsafe(len));
+          for (size_t i = 0; i < len; i++)
+            q[i] = p[i];
+
+          p += len;
+          break;
+        }
+      vst1q_u8(reinterpret_cast<uint8_t *>(os_->PushUnsafe(16)), s);
+    }
+
+  is.src_ = p;
+  return RAPIDJSON_LIKELY(is.Tell() < length);
+}
+#endif // RAPIDJSON_NEON
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(_MSC_VER) || defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/visualization/main.h.bak b/contrib/world_builder/include/visualization/main.h.bak
new file mode 100644
index 00000000000..de5685a9a84
--- /dev/null
+++ b/contrib/world_builder/include/visualization/main.h.bak
@@ -0,0 +1,39 @@
+/*
+  Copyright (C) 2020 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_VISUALIZATION_MAIN_H_
+#define WORLD_BUILDER_VISUALIZATION_MAIN_H_
+
+#include <vector>
+#include <string>
+
+void project_on_sphere(double, double &, double &, double &);
+
+void lay_points(double x1, double y1, double z1,
+                double x2, double y2, double z2,
+                double x3, double y3, double z3,
+                double x4, double y4, double z4,
+                std::vector<double> &x, std::vector<double> &y, std::vector<double> &z,
+                std::vector<bool> &hull, size_t level);
+
+std::vector<std::string> get_command_line_options_vector(int argc, char **argv);
+
+bool find_command_line_option(char **begin, char **end, const std::string &option);
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/assert.h.bak b/contrib/world_builder/include/world_builder/assert.h.bak
new file mode 100644
index 00000000000..c0b563cfd07
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/assert.h.bak
@@ -0,0 +1,63 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#ifndef WORLD_BUILDER_ASSERT_H_
+#define WORLD_BUILDER_ASSERT_H_
+
+#include <sstream>
+
+namespace WorldBuilder
+{
+#ifndef NDEBUG
+#   define WBAssert(condition, message) \
+  do { \
+      if (! (condition)) { \
+          std::stringstream smessage; \
+          smessage << "Assert `" #condition "` failed in " << __FILE__ \
+                   << " at line " << __LINE__ << ": " << message << std::endl << std::endl << "Error not recoverable, aborting program."; \
+          throw std::runtime_error(smessage.str()); \
+        } \
+    } while (false)
+#else
+#   define WBAssert(condition, message) do { } while (false)
+#endif
+
+#   define WBAssertThrow(condition, message) \
+  do { \
+      if (! (condition)) { \
+          std::stringstream smessage; \
+          smessage << "AssertThrow `" #condition "` failed in " << __FILE__ \
+                   << " at line " << __LINE__ << ": " << message << std::endl << std::endl << "Error not recoverable, aborting program."; \
+          throw std::runtime_error(smessage.str()); \
+        } \
+    } while (false)
+
+
+#   define WBAssertThrowExc(condition, exc, message) \
+  do { \
+      if (! (condition)) { \
+          exc \
+          std::stringstream smessage; \
+          smessage << "AssertThrow `" #condition "` failed in " << __FILE__ \
+                   << " at line " << __LINE__ << ": " << message << std::endl; \
+          throw std::runtime_error(smessage.str()); \
+        } \
+    } while (false)
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/bounding_box.h.bak b/contrib/world_builder/include/world_builder/bounding_box.h.bak
new file mode 100644
index 00000000000..808c15cb8f0
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/bounding_box.h.bak
@@ -0,0 +1,513 @@
+// ---------------------------------------------------------------------
+//
+// Copyright (C) 2017 - 2021 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE.md at
+// the top level directory of deal.II.
+//
+// ---------------------------------------------------------------------
+
+#ifndef WORLD_BUILDER_BOUNDING_BOX_H
+#define WORLD_BUILDER_BOUNDING_BOX_H
+
+
+#include "assert.h"
+#include "point.h"
+
+#include <limits>
+
+
+namespace WorldBuilder
+{
+
+
+  /**
+   * A class that represents a box of arbitrary dimension <tt>spacedim</tt> and
+   * with sides parallel to the coordinate axes, that is, a region
+   * @f[
+   * [x_0^L, x_0^U] \times ... \times [x_{spacedim-1}^L, x_{spacedim-1}^U],
+   * @f]
+   * where $(x_0^L , ..., x_{spacedim-1}^L)$ and $(x_0^U , ..., x_{spacedim-1}^U)$
+   * denote the two vertices (bottom left and top right) which are used to
+   * represent the box. The quantities $x_k^L$ and $x_k^U$ denote the "lower"
+   * and "upper" bounds of values that are within the box for each coordinate
+   * direction $k$.
+   *
+   * Geometrically, a bounding box is thus:
+   * - 1D: a segment (represented by its vertices in the proper order)
+   * - 2D: a rectangle (represented by the vertices V at bottom left, top right)
+   * @code
+   * .--------V
+   * |        |
+   * V--------.
+   * @endcode
+   *
+   * - 3D: a cuboid (in which case the two vertices V follow the convention and
+   * are not owned by the same face)
+   * @code
+   *   .------V
+   *  /      /|
+   * .------. |
+   * |      | /
+   * |      |/
+   * V------.
+   * @endcode
+   *
+   * Bounding boxes are, for example, useful in parallel distributed meshes to
+   * give a general description of the owners of each portion of the mesh. More
+   * generally, bounding boxes are often used to roughly describe a region of
+   * space in which an object is contained; if a candidate point is not within
+   * the bounding box (a test that is cheap to execute), then it is not necessary
+   * to perform an expensive test whether the candidate point is in fact inside
+   * the object itself. Bounding boxes are therefore often used as a first,
+   * cheap rejection test before more detailed checks. As such, bounding boxes
+   * serve many of the same purposes as the
+   * [convex hull](https://en.wikipedia.org/wiki/Convex_hull), for which it is
+   * also relatively straightforward to compute whether a point is inside or
+   * outside, though not quite as cheap as for the bounding box.
+   *
+   * Taking the cross section of a BoundingBox<spacedim> orthogonal to a given
+   * direction gives a box in one dimension lower: BoundingBox<spacedim - 1>.
+   * In 3D, the 2 coordinates of the cross section of BoundingBox<3> can be
+   * ordered in 2 different ways. That is, if we take the cross section orthogonal
+   * to the y direction we could either order a 3D-coordinate into a
+   * 2D-coordinate as $(x,z)$ or as $(z,x)$. This class uses the second
+   * convention, corresponding to the coordinates being ordered cyclicly
+   * $x \rightarrow y \rightarrow z \rightarrow x \rightarrow ... $
+   * To be precise, if we take a cross section:
+   *
+   * | Orthogonal to | Cross section coordinates ordered as |
+   * |:-------------:|:------------------------------------:|
+   * |      x        |               (y, z)                 |
+   * |      y        |               (z, x)                 |
+   * |      z        |               (x, y)                 |
+   *
+   * This is according to the convention set by the function
+   * <code>coordinate_to_one_dim_higher</code>.
+   *
+   * @note The majority of this class is copied from the deal.II library.
+   */
+  template <unsigned int spacedim>
+  class BoundingBox
+  {
+    public:
+      /**
+       * Standard constructor. Creates an object that corresponds to a
+       * box that corresponds to the entire space, i.e. a degenerate
+       * box with end points at minus and plus infinity.
+       */
+      BoundingBox();
+
+      /**
+       * Standard constructor for non-empty boxes: it uses a pair of points
+       * which describe the box: one for the bottom and one for the top
+       * corner.
+       */
+      BoundingBox(const std::pair<Point<spacedim>, Point<spacedim>>
+                  &boundary_points);
+
+      /**
+       * Construct the bounding box that encloses all the points in the given
+       * container.
+       *
+       * The constructor supports any Container that provides begin() and end()
+       * iterators to Point<spacedim> elements.
+       */
+      template <class Container>
+      BoundingBox(const Container &points);
+
+      /**
+       * Return a reference to the boundary_points
+       */
+      std::pair<Point<spacedim>, Point<spacedim>> &get_boundary_points();
+
+      /**
+       * Return a const reference to the boundary_points
+       */
+      const std::pair<Point<spacedim>, Point<spacedim>> &get_boundary_points() const;
+
+      /**
+       * Test for equality.
+       */
+      bool
+      operator==(const BoundingBox<spacedim> &box) const;
+
+      /**
+       * Test for inequality.
+       */
+      bool
+      operator!=(const BoundingBox<spacedim> &box) const;
+
+      /**
+       * Enlarge the current object so that it contains @p other_bbox .
+       * If the current object already contains @p other_bbox then it is not changed
+       * by this function.
+       */
+      void
+      merge_with(const BoundingBox<spacedim> &other_bbox);
+
+      /**
+       * Return true if the point is inside the Bounding Box, false otherwise. The
+       * parameter @p tolerance is a factor by which the bounding box is enlarged
+       * relative to the dimensions of the bounding box in order to determine in a
+       * numerically robust way whether the point is inside.
+       *
+       * This function is a wrapper for the function point_inside_implementation
+       * to also test point+2pi is the longtiude is smaller then zero and point-2pi
+       * if the longitude is larger than zero.
+       */
+      bool
+      point_inside(
+        const Point<spacedim> &p,
+        const double tolerance = std::numeric_limits<double>::epsilon()) const;
+
+      /**
+       * Increase (or decrease) the size of the bounding box by the given amount.
+       * After calling this method, the lower left corner of the bounding box will
+       * have each coordinate decreased by @p amount, and the upper right corner
+       * of the bounding box will have each coordinate increased by @p amount.
+       *
+       * If you call this method with a negative number, and one of the axes of the
+       * original bounding box is smaller than amount/2, the method will trigger
+       * an assertion.
+       */
+      void
+      extend(const double amount);
+
+      /**
+       * Compute the volume (i.e. the dim-dimensional measure) of the BoundingBox.
+       */
+      double
+      volume() const;
+
+      /**
+       * Returns the point in the center of the box.
+       */
+      Point<spacedim>
+      center() const;
+
+      /**
+       * Returns the side length of the box in @p direction.
+       */
+      double
+      side_length(const unsigned int direction) const;
+
+      /**
+       * Return the lower bound of the box in @p direction.
+       */
+      double
+      lower_bound(const unsigned int direction) const;
+
+      /**
+       * Return the upper bound of the box in @p direction.
+       */
+      double
+      upper_bound(const unsigned int direction) const;
+
+    private:
+      /**
+       * Return true if the point is inside the Bounding Box, false otherwise. The
+       * parameter @p tolerance is a factor by which the bounding box is enlarged
+       * relative to the dimensions of the bounding box in order to determine in a
+       * numerically robust way whether the point is inside.
+       *
+       * This function is supposed to be only used by the point_inside function.
+       */
+      bool
+      point_inside_implementation(
+        const Point<spacedim> &p,
+        const double tolerance = std::numeric_limits<double>::epsilon()) const;
+
+      std::pair<Point<spacedim>, Point<spacedim>> boundary_points;
+
+  };
+
+
+  /*------------------------ Inline functions: BoundingBox --------------------*/
+
+#ifndef DOXYGEN
+
+
+  template <>
+  inline BoundingBox<2>::BoundingBox()
+    :
+    boundary_points ({{
+      -std::numeric_limits<double>::max(),
+      -std::numeric_limits<double>::max(),
+      cartesian
+    },
+    {
+      +std::numeric_limits<double>::max(),
+      +std::numeric_limits<double>::max(),
+      cartesian
+    }
+  })
+  {}
+
+  template <>
+  inline BoundingBox<3>::BoundingBox()
+    :
+    boundary_points ({{
+      -std::numeric_limits<double>::max(),
+      -std::numeric_limits<double>::max(),
+      -std::numeric_limits<double>::max(),
+      cartesian
+    },
+    {
+      +std::numeric_limits<double>::max(),
+      +std::numeric_limits<double>::max(),
+      +std::numeric_limits<double>::max(),
+      cartesian
+    }
+  })
+  {}
+
+
+
+  template <unsigned int spacedim>
+  inline BoundingBox<spacedim>::BoundingBox(
+    const std::pair<Point<spacedim>, Point<spacedim>>
+    &boundary_points_)
+    :
+    boundary_points (boundary_points_)
+  {
+    // We check the Bounding Box is not degenerate
+    for (unsigned int i = 0; i < spacedim; ++i)
+      WBAssert(boundary_points.first[i] <= boundary_points.second[i],
+               "Bounding Box can't be created: the points' "
+               "order should be bottom left, top right!");
+  }
+
+
+
+  template <unsigned int spacedim>
+  template <class Container>
+  inline BoundingBox<spacedim>::BoundingBox(const Container &points)
+  {
+    // Use the default constructor in case points is empty instead of setting
+    // things to +oo and -oo
+    if (points.size() > 0)
+      {
+        auto &min = boundary_points.first;
+        auto &max = boundary_points.second;
+        std::fill(min.begin_raw(),
+                  min.end_raw(),
+                  std::numeric_limits<double>::infinity());
+        std::fill(max.begin_raw(),
+                  max.end_raw(),
+                  -std::numeric_limits<double>::infinity());
+
+        for (const Point<spacedim> &point : points)
+          for (unsigned int d = 0; d < spacedim; ++d)
+            {
+              min[d] = std::min(min[d], point[d]);
+              max[d] = std::max(max[d], point[d]);
+            }
+      }
+  }
+
+
+
+  template <unsigned int spacedim>
+  inline std::pair<Point<spacedim>, Point<spacedim>> &BoundingBox<spacedim>::get_boundary_points()
+  {
+    return this->boundary_points;
+  }
+
+
+
+  template <unsigned int spacedim>
+  inline const std::pair<Point<spacedim>, Point<spacedim>> &BoundingBox<spacedim>::get_boundary_points() const
+  {
+    return this->boundary_points;
+  }
+
+
+
+  template <unsigned int spacedim>
+  inline bool
+  BoundingBox<spacedim>::
+  operator==(const BoundingBox<spacedim> &box) const
+  {
+    return boundary_points == box.boundary_points;
+  }
+
+
+
+  template <unsigned int spacedim>
+  inline bool
+  BoundingBox<spacedim>::
+  operator!=(const BoundingBox<spacedim> &box) const
+  {
+    return boundary_points != box.boundary_points;
+  }
+
+
+
+  template <unsigned int spacedim>
+  inline void
+  BoundingBox<spacedim>::extend(const double amount)
+  {
+    for (unsigned int d = 0; d < spacedim; ++d)
+      {
+        boundary_points.first[d] -= amount;
+        boundary_points.second[d] += amount;
+        WBAssert(boundary_points.first[d] <= boundary_points.second[d],
+                 "Bounding Box can't be shrunk this much: the points' "
+                 "order should remain bottom left, top right.");
+      }
+  }
+
+
+  template <unsigned int spacedim>
+  inline
+  bool
+  BoundingBox<spacedim>::point_inside(const Point<spacedim> &point,
+                                      const double tolerance) const
+  {
+    WBAssert(boundary_points.first.get_coordinate_system() == point.get_coordinate_system(),
+             "Cannot compare two points which represent different coordinate systems.");
+    WBAssert(boundary_points.second.get_coordinate_system() == point.get_coordinate_system(),
+             "Cannot compare two points which represent different coordinate systems.");
+
+    if (point.get_coordinate_system() == CoordinateSystem::spherical)
+      {
+        Point<spacedim> other_point = point;
+        if (spacedim == 2)
+          {
+            other_point[0] += point[0] < 0 ? 2.0 * Consts::PI : -2.0 * Consts::PI;
+          }
+        else
+          {
+            // spacedim == 3 (rad,long,lat)
+            other_point[1] += point[1] < 0 ? 2.0 * Consts::PI : -2.0 * Consts::PI;
+          }
+
+        return (point_inside_implementation(point, tolerance) ||
+                point_inside_implementation(other_point, tolerance));
+      }
+
+    return point_inside_implementation(point, tolerance);
+
+  }
+
+  template <unsigned int spacedim>
+  inline
+  bool
+  BoundingBox<spacedim>::point_inside_implementation(const Point<spacedim> &p,
+                                                     const double tolerance) const
+  {
+    WBAssert(boundary_points.first.get_coordinate_system() == p.get_coordinate_system(),
+             "Cannot compare two points which represent different coordinate systems.");
+    WBAssert(boundary_points.second.get_coordinate_system() == p.get_coordinate_system(),
+             "Cannot compare two points which represent different coordinate systems.");
+
+    for (unsigned int i = 0; i < spacedim; ++i)
+      {
+        // Bottom left-top right convention: the point is outside if it's smaller
+        // than the first or bigger than the second boundary point The bounding
+        // box is defined as a closed set
+        if ((p[i] < this->boundary_points.first[i] -
+             tolerance * std::abs(this->boundary_points.second[i] -
+                                  this->boundary_points.first[i])) ||
+            (p[i] > this->boundary_points.second[i] +
+             tolerance * std::abs(this->boundary_points.second[i] -
+                                  this->boundary_points.first[i])))
+          return false;
+      }
+    return true;
+  }
+
+
+
+  template <unsigned int spacedim>
+  inline
+  void
+  BoundingBox<spacedim>::merge_with(
+    const BoundingBox<spacedim> &other_bbox)
+  {
+    for (unsigned int i = 0; i < spacedim; ++i)
+      {
+        this->boundary_points.first[i] =
+          std::min(this->boundary_points.first[i],
+                   other_bbox.boundary_points.first[i]);
+        this->boundary_points.second[i] =
+          std::max(this->boundary_points.second[i],
+                   other_bbox.boundary_points.second[i]);
+      }
+  }
+
+
+
+  template <unsigned int spacedim>
+  double
+  BoundingBox<spacedim>::volume() const
+  {
+    double vol = 1.0;
+    for (unsigned int i = 0; i < spacedim; ++i)
+      vol *= (this->boundary_points.second[i] - this->boundary_points.first[i]);
+    return vol;
+  }
+
+
+
+  template <unsigned int spacedim>
+  inline
+  double
+  BoundingBox<spacedim>::lower_bound(const unsigned int direction) const
+  {
+    WBAssert(direction, spacedim);
+
+    return boundary_points.first[direction];
+  }
+
+
+
+  template <unsigned int spacedim>
+  inline
+  double
+  BoundingBox<spacedim>::upper_bound(const unsigned int direction) const
+  {
+    WBAssert(direction, spacedim);
+
+    return boundary_points.second[direction];
+  }
+
+
+
+  template <unsigned int spacedim>
+  Point<spacedim>
+  BoundingBox<spacedim>::center() const
+  {
+    Point<spacedim> point = boundary_points.first; // initialize to inherit coordinate system
+    for (unsigned int i = 0; i < spacedim; ++i)
+      point[i] = .5 * (boundary_points.first[i] + boundary_points.second[i]);
+
+    return point;
+  }
+
+
+
+  template <unsigned int spacedim>
+  inline
+  double
+  BoundingBox<spacedim>::side_length(const unsigned int direction) const
+  {
+    WBAssert(direction < spacedim, "Invalid index");
+
+    return boundary_points.second[direction] - boundary_points.first[direction];
+  }
+
+
+#endif // DOXYGEN
+
+}
+
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/consts.h.bak b/contrib/world_builder/include/world_builder/consts.h.bak
new file mode 100644
index 00000000000..56d01f284a5
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/consts.h.bak
@@ -0,0 +1,35 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_GLOBAL_H
+#define WORLD_BUILDER_GLOBAL_H
+
+#include <limits>
+#include <iostream>
+
+namespace WorldBuilder
+{
+  namespace Consts
+  {
+    constexpr double PI = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066;
+  } // namespace Consts
+
+}
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/coordinate_system.h.bak b/contrib/world_builder/include/world_builder/coordinate_system.h.bak
new file mode 100644
index 00000000000..f60195abff5
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/coordinate_system.h.bak
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_COORDINATE_SYSTEM_H
+#define WORLD_BUILDER_COORDINATE_SYSTEM_H
+
+namespace WorldBuilder
+{
+  /**
+   * This enum lists available coordinate systems that can be used for the
+   * function variables. Allowed values are 'cartesian', 'spherical'.
+   * 'spherical' coordinates follow: r, phi (2D) or r, phi, theta (3D); where
+   * r is radius, phi is longitude, and theta is the polar angle (colatitude).
+   */
+  enum CoordinateSystem
+  {
+    cartesian,
+    spherical,
+    invalid
+  };
+
+  /**
+   * There are three ways to look at what should happen when the user gives an
+   * angle to go down in a sphere. The first one is the easiest, which is just
+   * to tread the system as a Cartesian system. This means taking the angle
+   * with the surface tangential at the starting point at the surface
+   * everywhere. The advantage is that it is very intuitive and easy to
+   * predict what geometry should be produced. This option is called
+   * 'angle_at_starting_point_with_surface'. The other end member is that
+   * going down with an angle in a sphere should mean that it always goes down
+   * with a constant angle relative to the surface tangential at that
+   * longitude and latitude. This means a the geometry would a a logarithmic
+   * spiral. This option is called 'continuous_angle_with_surface'. Because it
+   * is currently to time consuming to implement this option with all the
+   * required features, there is an option which approximates this behavior,
+   * by using the option 'angle_at_starting_point_with_surface'. This option
+   * uses the surface tangential at the beginning of every segment. This means
+   * that in the limit of segments going to length zero, this option produces
+   * exactly the same geometry as 'continuous_angle_with_surface'.
+   */
+  enum DepthMethod
+  {
+    angle_at_starting_point_with_surface,
+    angle_at_begin_segment_with_surface,
+    angle_at_begin_segment_applied_to_end_segment_with_surface,
+    continuous_angle_with_surface,
+    none
+  };
+} // namespace WorldBuilder
+
+#endif
+
diff --git a/contrib/world_builder/include/world_builder/coordinate_systems/cartesian.h.bak b/contrib/world_builder/include/world_builder/coordinate_systems/cartesian.h.bak
new file mode 100644
index 00000000000..cb196e4b8c4
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/coordinate_systems/cartesian.h.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_CARTESIAN_H
+#define WORLD_BUILDER_COORDINATE_SYSTEMS_CARTESIAN_H
+
+#include "world_builder/coordinate_systems/interface.h"
+
+namespace WorldBuilder
+{
+
+  namespace CoordinateSystems
+  {
+    /**
+     * Register header file
+     */
+    //WB_REGISTER_COORDINATE_SYSTEM_HEADER(Cartesian)
+
+
+    /**
+     * This implements a Cartesian geometry model.The Cartesian geometry model
+     * doesn't do anything with the coordinates, but is needed to have a common
+     * interface for all the geometry models.
+     */
+    class Cartesian final : public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        Cartesian(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~Cartesian() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+        /**
+         * Returns what the natural coordinate system for this Coordinate System is.
+         */
+        CoordinateSystem natural_coordinate_system() const override final;
+
+        /**
+         * Returns what method should be used to go down with an angle into
+         * the domain.
+         * \sa DepthMethod
+         */
+        DepthMethod depth_method() const override final;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a box
+         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
+         * model it  will be (radius, longitude) in 2d and (radius, longitude,
+         * latitude) in 3d.
+         */
+        std::array<double,3> cartesian_to_natural_coordinates(const std::array<double,3> &position) const override final;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        std::array<double,3> natural_to_cartesian_coordinates(const std::array<double,3> &position) const override final;
+
+
+        /**
+         * Computes the distance between two points which are on the same depth.
+         * The input is two 3d points at that depth. It is implemented as the
+         */
+        double distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const override final;
+
+        /**
+         * Returns the max model depth. This always returns infinity for Cartesian
+         * models.
+         */
+        virtual
+        double max_model_depth() const override final;
+
+      private:
+
+    };
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/coordinate_systems/interface.h.bak b/contrib/world_builder/include/world_builder/coordinate_systems/interface.h.bak
new file mode 100644
index 00000000000..d8147fe0d4c
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/coordinate_systems/interface.h.bak
@@ -0,0 +1,184 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_INTERFACE_H
+#define WORLD_BUILDER_COORDINATE_SYSTEMS_INTERFACE_H
+
+#include "world_builder/coordinate_systems/interface.h"
+
+#include "world_builder/coordinate_system.h"
+#include "world_builder/parameters.h"
+#include "world_builder/types/string.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+
+  namespace CoordinateSystems
+  {
+
+    class ObjectFactory;
+
+    /**
+     * This class is an interface for the specific coordinate systems.
+     */
+    class Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        Interface();
+
+        /**
+         * Destructor
+         */
+        virtual
+        ~Interface();
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm,
+                             const std::string &parent_name,
+                             const std::vector<std::string> &required_entries);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        virtual
+        void parse_entries(Parameters &prm) = 0;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is.
+         */
+        virtual
+        CoordinateSystem natural_coordinate_system() const = 0;
+
+        /**
+         * Returns what method should be used to go down with an angle into
+         * the domain.
+         * \sa DepthMethod
+         */
+        virtual
+        DepthMethod depth_method() const = 0;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a box
+         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
+         * model it  will be (radius, longitude) in 2d and (radius, longitude,
+         * latitude) in 3d.
+         */
+        virtual
+        std::array<double,3> cartesian_to_natural_coordinates(const std::array<double,3> &position) const = 0;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        virtual
+        std::array<double,3> natural_to_cartesian_coordinates(const std::array<double,3> &position) const = 0;
+
+        /**
+         * Computes the distance between two points which are on the same depth.
+         * The input is two 3d points at that depth.
+         */
+        virtual
+        double distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const = 0;
+
+        /**
+         * Returns the max model depth. This should be the infinity for Cartesian
+         * models and the radius in spherical models.
+         */
+        virtual
+        double max_model_depth() const = 0;
+
+        /**
+         * A function to register a new type. This is part of the automatic
+         * registration of the object factory.
+         */
+        static void registerType(const std::string &name,
+                                 void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                 ObjectFactory *factory);
+
+        /**
+         * A function to create a new type. This is part of the automatic
+         * registration of the object factory.
+         */
+        static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+      protected:
+        /**
+         * A pointer to the world class to retrieve variables.
+         */
+        WorldBuilder::World *world;
+
+
+
+      private:
+        static std::map<std::string, ObjectFactory *> &get_factory_map()
+        {
+          static std::map<std::string, ObjectFactory *> factories;
+          return factories;
+        }
+
+        static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+        {
+          static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+          return declares;
+        }
+    };
+
+
+
+    /**
+     * A class to create new objects
+     */
+    class ObjectFactory
+    {
+      public:
+        virtual std::unique_ptr<Interface> create(World *world) = 0;
+    };
+
+    /**
+     * A macro which should be in every derived cpp file to automatically
+     * register it. Because this is a library, we need some extra measures
+     * to ensure that the static variable is actually initialized.
+     */
+#define WB_REGISTER_COORDINATE_SYSTEM(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/coordinate_systems/invalid.h.bak b/contrib/world_builder/include/world_builder/coordinate_systems/invalid.h.bak
new file mode 100644
index 00000000000..481929abdf3
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/coordinate_systems/invalid.h.bak
@@ -0,0 +1,110 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_INVALID_H
+#define WORLD_BUILDER_COORDINATE_SYSTEMS_INVALID_H
+
+#include "world_builder/coordinate_systems/interface.h"
+#include "world_builder/nan.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace CoordinateSystems
+  {
+    /**
+     * This implements a Invalid geometry model.The Invalid geometry model
+     * doesn't do anything with the coordinates, but is needed to have a common
+     * interface for all the geometry models.
+     */
+    class Invalid final : public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        Invalid(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~Invalid() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+        /**
+         * Returns what the natural coordinate system for this Coordinate System is.
+         */
+        CoordinateSystem natural_coordinate_system() const override final;
+
+        /**
+         * Returns what method should be used to go down with an angle into
+         * the domain.
+         * \sa DepthMethod
+         */
+        DepthMethod depth_method() const override final;
+
+        /**
+         * Takes the Invalid points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a box
+         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
+         * model it  will be (radius, longitude) in 2d and (radius, longitude,
+         * latitude) in 3d.
+         */
+        std::array<double,3> cartesian_to_natural_coordinates(const std::array<double,3> &position) const override final;
+
+        /**
+         * Undoes the action of invalid_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Invalid coordinates.
+         */
+        std::array<double,3> natural_to_cartesian_coordinates(const std::array<double,3> &position) const override final;
+
+
+        /**
+         * Computes the distance between two points which are on the same depth.
+         * The input is two 3d points at that depth. It is implemented as the
+         */
+        double distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const override final;
+
+        /**
+         * Returns the max model depth. This always returns infinity for Invalid
+         * models.
+         */
+        virtual
+        double max_model_depth() const override final;
+
+      private:
+
+    };
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/coordinate_systems/spherical.h.bak b/contrib/world_builder/include/world_builder/coordinate_systems/spherical.h.bak
new file mode 100644
index 00000000000..6fe89645e40
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/coordinate_systems/spherical.h.bak
@@ -0,0 +1,130 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_SPHERICAL_H
+#define WORLD_BUILDER_COORDINATE_SYSTEMS_SPHERICAL_H
+
+#include "world_builder/coordinate_systems/interface.h"
+
+#include <string>
+
+namespace WorldBuilder
+{
+
+  namespace CoordinateSystems
+  {
+    /**
+     * Register header file
+     */
+    //WB_REGISTER_COORDINATE_SYSTEM_HEADER(Spherical)
+
+    /**
+     * This implements a Spherical geometry model.The Cartesian geometry model
+     * doesn't do anything with the coordinates, but is needed to have a common
+     * interface for all the geometry models.
+     */
+    class Spherical final : public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        Spherical(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~Spherical() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+        /**
+         * Returns what the natural coordinate system for this Coordinate System is.
+         */
+        CoordinateSystem natural_coordinate_system() const override final;
+
+        /**
+         * Returns what method should be used to go down with an angle into
+         * the domain.
+         * \sa DepthMethod
+         */
+        DepthMethod depth_method() const override final;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a box
+         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
+         * model it  will be (radius, longitude) in 2d and (radius, longitude,
+         * latitude) in 3d.
+         */
+        std::array<double,3> cartesian_to_natural_coordinates(const std::array<double,3> &position) const override final;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        std::array<double,3> natural_to_cartesian_coordinates(const std::array<double,3> &position) const override final;
+
+
+        /**
+         * Computes the distance between two points which are on the same depth.
+         * The input is two 2d points at that depth. The distance is returned
+         * in meters. To compute this distance from spherical coordinates the
+         * radius is multiplied with the central angle. The central angle is
+         * compute in the most accurate way given on wikipedia
+         * (https://en.wikipedia.org/wiki/Great-circle_distance), through a
+         * special case of the Vincenty formula for an ellipsoid with equal
+         * major and minor axes (https://doi.org/10.1179/sre.1975.23.176.88).
+         */
+        double distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const override final;
+
+        /**
+         * Returns the max model depth. This returns the radius in spherical
+         * models.
+         */
+        virtual
+        double max_model_depth() const override final;
+
+        /**
+         * What depth method the spherical coordinates use.
+         */
+        DepthMethod used_depth_method;
+
+      private:
+        /**
+         * The maximum depth of the model. In the spherical case that is equal to the
+         * radius of the sphere.
+         */
+        double radius_sphere;
+    };
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/deprecate.h.bak b/contrib/world_builder/include/world_builder/deprecate.h.bak
new file mode 100644
index 00000000000..2c7296ce4db
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/deprecate.h.bak
@@ -0,0 +1,13 @@
+// if deprecated is supported, which is definitely C++14, but some compilers support it before C++14.
+// Once the world builder switches to C++14 this can be simplified.
+#if defined(__has_cpp_attribute)
+#if __has_cpp_attribute(deprecated)
+#define DEPRECATED(msg, func) [[deprecated(msg)]] func
+#endif
+#else
+#if defined(__GNUC__) || defined(__clang__)
+#define DEPRECATED(msg, func) func __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED(msg, func) __declspec(deprecated(msg)) func
+#endif
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate.h.bak
new file mode 100644
index 00000000000..ac3f55111ad
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate.h.bak
@@ -0,0 +1,162 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_H
+
+
+#include "world_builder/features/interface.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+  class World;
+
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace ContinentalPlateModels
+
+    /**
+     * This class represents a continental plate and can implement submodules
+     * for temperature and composition. These submodules determine what
+     * the returned temperature or composition of the temperature and composition
+     * functions of this class will be.
+     */
+    class ContinentalPlate final: public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        ContinentalPlate(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~ContinentalPlate() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm,
+                             const std::string &parent_name = "",
+                             const std::vector<std::string> &required_entries = {});
+
+        /**
+         * Produce a JSON snippet for the schema
+         */
+        static
+        void make_snippet(Parameters &prm);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+        /**
+         * Returns different values at a single point in one go stored in a vector of doubles.
+         *
+         * The properties input decides what each entry means, and the output is generated in the
+         * same order as the properties input. The properties input consists of
+         * a 3D array, where the first entry identifies the property and the last two entries
+         * provide extra information about that property.
+         *
+         * Temperature is identified by 1 and no extra information is needed. So temperature
+         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
+         * vector.
+         *
+         * Composition is identified by 2. This produces one
+         * value in the output. The second entry  identifies the composition number and the third
+         * number is not used. So a commposition query asking about composition 1 looks like this:
+         * {2,1,0}. A composition query prodoces one entry in the output vector.
+         *
+         * Grains are identified by 2. The second entry is the grain composition number and the third
+         * entry is the number of grains. A query about the grains, where it asks about composition 1
+         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
+         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
+         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
+         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
+         *
+         * The entries in output variable relates the index of the property to the index in the output.
+         */
+        void
+        properties(const Point<3> &position_in_cartesian_coordinates,
+                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                   const double depth,
+                   const std::vector<std::array<unsigned int,3>> &properties,
+                   const double gravity,
+                   const std::vector<size_t> &entry_in_output,
+                   std::vector<double> &output) const override final;
+
+      private:
+        /**
+         * A vector containing all the pointers to the temperature models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::ContinentalPlateModels::Temperature::Interface> > temperature_models;
+
+        /**
+         * A vector containing all the pointers to the composition models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::ContinentalPlateModels::Composition::Interface> > composition_models;
+
+        /**
+         * A vector containing all the pointers to the grains models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::ContinentalPlateModels::Grains::Interface> > grains_models;
+
+
+        double min_depth;
+        Objects::Surface min_depth_surface;
+        double max_depth;
+        Objects::Surface max_depth_surface;
+
+    };
+
+
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/interface.h.bak
new file mode 100644
index 00000000000..61e34188168
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/interface.h.bak
@@ -0,0 +1,164 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_INTERFACE_H
+
+
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+namespace WorldBuilder
+{
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace ContinentalPlateModels
+    {
+      namespace Composition
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
+
+
+            /**
+             * takes composition and position and returns a composition.
+             */
+            virtual
+            double get_composition(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_CONTINENTAL_PLATE_COMPOSITION_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Composition
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/random.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/random.h.bak
new file mode 100644
index 00000000000..5d7a9f40110
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/random.h.bak
@@ -0,0 +1,100 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_RANDOM_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_RANDOM_H
+
+
+#include "world_builder/features/continental_plate_models/composition/interface.h"
+#include "world_builder/objects/surface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace ContinentalPlateModels
+    {
+      namespace Composition
+      {
+        /**
+         * This class represents a continental plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Random final : public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Random(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Random() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a composition based on the given position, depth in the model,
+             * gravity and current composition.
+             */
+            double get_composition(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // Random composition submodule parameters
+
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> compositions;
+            std::vector<double> min_value;
+            std::vector<double> max_value;
+            Operations operation;
+
+        };
+      } // namespace Composition
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/uniform.h.bak
new file mode 100644
index 00000000000..f6540cf8227
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/uniform.h.bak
@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_UNIFORM_H
+
+
+#include "world_builder/features/continental_plate_models/composition/interface.h"
+#include "world_builder/objects/surface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace ContinentalPlateModels
+    {
+      namespace Composition
+      {
+        /**
+         * This class represents a continental plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final : public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a composition based on the given position, depth in the model,
+             * gravity and current composition.
+             */
+            double get_composition(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // uniform composition submodule parameters
+
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> compositions;
+            std::vector<double> fractions;
+            Operations operation;
+
+        };
+      } // namespace Composition
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/interface.h.bak
new file mode 100644
index 00000000000..20693855c07
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/interface.h.bak
@@ -0,0 +1,170 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_INTERFACE_H
+
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace ContinentalPlateModels
+    {
+      namespace Grains
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
+
+
+            /**
+             * takes composition and position and returns grains.
+             */
+            virtual
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_CONTINENTAL_PLATE_GRAINS_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      virtual std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Grains
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution.h.bak
new file mode 100644
index 00000000000..dfa20197d28
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution.h.bak
@@ -0,0 +1,115 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+
+
+#include "world_builder/features/continental_plate_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a continental plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistribution final : public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistribution(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistribution() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+        };
+      } // namespace Grains
+    }   // namespace ContinentalPlateModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h.bak
new file mode 100644
index 00000000000..4e8cf717326
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h.bak
@@ -0,0 +1,115 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+
+
+#include "world_builder/features/continental_plate_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a continental plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistributionDeflected final : public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistributionDeflected(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistributionDeflected() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+            std::vector<double> deflections;
+        };
+      } // namespace Grains
+    }   // namespace ContinentalPlateModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/uniform.h.bak
new file mode 100644
index 00000000000..6a054a9506e
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/uniform.h.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_UNIFORM_H
+
+
+#include "world_builder/features/continental_plate_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a continental plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class Uniform final : public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
+            std::vector<double> grain_sizes;
+        };
+      } // namespace Grains
+    }   // namespace ContinentalPlateModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/adiabatic.h.bak
new file mode 100644
index 00000000000..d8be4739f71
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/adiabatic.h.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
+
+
+#include "world_builder/features/continental_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace ContinentalPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a continental plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Adiabatic final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Adiabatic(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Adiabatic() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // adiabatic temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            /**
+             * Todo
+             */
+            double potential_mantle_temperature;
+
+
+            /**
+             * Todo
+             */
+            double thermal_expansion_coefficient;
+
+            /**
+             * Todo
+             */
+            double specific_heat;
+
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/interface.h.bak
new file mode 100644
index 00000000000..4bc2b1bac40
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/interface.h.bak
@@ -0,0 +1,169 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_INTERFACE_H
+
+
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace ContinentalPlateModels
+    {
+      namespace Temperature
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
+
+
+            /**
+             * takes temperature and position and returns a temperature.
+             */
+            virtual
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            /**
+             * The name of the feature type.
+             */
+            std::string name;
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_CONTINENTAL_PLATE_TEMPERATURE_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Temperature
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/linear.h.bak
new file mode 100644
index 00000000000..07a2a022ed6
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/linear.h.bak
@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_LINEAR_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_LINEAR_H
+
+
+#include "world_builder/features/continental_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace ContinentalPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a continental plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Linear final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Linear(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Linear() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // linear temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            double top_temperature;
+            double bottom_temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/uniform.h.bak
new file mode 100644
index 00000000000..bb70e04a21e
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/uniform.h.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_UNIFORM_H
+
+
+#include "world_builder/features/continental_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace ContinentalPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a continental plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // uniform temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            double temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault.h.bak b/contrib/world_builder/include/world_builder/features/fault.h.bak
new file mode 100644
index 00000000000..f8e98d11242
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault.h.bak
@@ -0,0 +1,229 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_H
+#define WORLD_BUILDER_FEATURES_FAULT_H
+
+
+#include "world_builder/features/fault_models/composition/interface.h"
+#include "world_builder/features/fault_models/grains/interface.h"
+#include "world_builder/features/fault_models/temperature/interface.h"
+#include "world_builder/objects/segment.h"
+#include "world_builder/bounding_box.h"
+#include "world_builder/objects/distance_from_surface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+  class World;
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace FaultModels
+
+    /**
+     * This class represents a fault and can implement submodules
+     * for temperature and composition. These submodules determine what
+     * the returned temperature or composition of the temperature and composition
+     * functions of this class will be.
+     */
+    class Fault final: public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        Fault(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~Fault() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm,
+                             const std::string &parent_name = "",
+                             const std::vector<std::string> &required_entries = {});
+
+        /**
+         * Produce a JSON snippet for the schema
+         */
+        static
+        void make_snippet(Parameters &prm);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+        /**
+         * Computes the bounding points for a BoundingBox object using two extreme points in all the surface
+         * coordinates and an additional buffer zone that accounts for the fault thickness and length. The first and second
+         * points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
+         * documentation in include/bounding_box.h).
+         * For the spherical system, the buffer zone along the longitudal direction is calculated using the
+         * corresponding latitude points.
+         */
+        const BoundingBox<2>  &get_surface_bounding_box () const;
+
+        /**
+         * Returns different values at a single point in one go stored in a vector of doubles.
+         *
+         * The properties input decides what each entry means, and the output is generated in the
+         * same order as the properties input. The properties input consists of
+         * a 3D array, where the first entry identifies the property and the last two entries
+         * provide extra information about that property.
+         *
+         * Temperature is identified by 1 and no extra information is needed. So temperature
+         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
+         * vector.
+         *
+         * Composition is identified by 2. This produces one
+         * value in the output. The second entry  identifies the composition number and the third
+         * number is not used. So a commposition query asking about composition 1 looks like this:
+         * {2,1,0}. A composition query prodoces one entry in the output vector.
+         *
+         * Grains are identified by 2. The second entry is the grain composition number and the third
+         * entry is the number of grains. A query about the grains, where it asks about composition 1
+         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
+         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
+         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
+         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
+         *
+         * The entries in output variable relates the index of the property to the index in the output.
+         */
+        void
+        properties(const Point<3> &position_in_cartesian_coordinates,
+                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                   const double depth,
+                   const std::vector<std::array<unsigned int,3>> &properties,
+                   const double gravity,
+                   const std::vector<size_t> &entry_in_output,
+                   std::vector<double> &output) const override final;
+
+        /**
+        * Returns a PlaneDistances object that has the distance from and along a fault plane,
+        * calculated from the coordinates and the depth of the point.
+        */
+        Objects::PlaneDistances
+        distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
+                                  const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                  const double depth) const override;
+
+      private:
+        std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> > default_temperature_models;
+        std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface>  > default_composition_models;
+        std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface>  > default_grains_models;
+
+        std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
+            Features::FaultModels::Composition::Interface,
+            Features::FaultModels::Grains::Interface> > default_segment_vector;
+
+        std::vector< std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
+            Features::FaultModels::Composition::Interface,
+            Features::FaultModels::Grains::Interface> > > sections_segment_vector;
+
+        // This vector stores segments to this coordinate/section.
+        //First used (raw) pointers to the segment relevant to this coordinate/section,
+        // but I do not trust it won't fail when memory is moved. So storing the all the data now.
+        std::vector<std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
+            Features::FaultModels::Composition::Interface,
+            Features::FaultModels::Grains::Interface> > > segment_vector;
+
+        // todo: the memory of this can be greatly improved by
+        // or using a plugin system for the submodules, or
+        // putting the variables in a union. Although the memory
+        // used by this program is in real cases expected to be
+        // insignificant compared to what a calling program may
+        // use, a smaller amount of memory used in here, could
+        // theoretically speed up the computation, because more
+        // relevant data could be stored in the cache. But this
+        // not a urgent problem, and would require testing.
+
+        /**
+         * This variable stores the depth at which the fault
+         * starts. It makes this depth effectively the surface
+         * of the model for the fault.
+         */
+        double starting_depth;
+
+        /**
+         * The depth which below the fault may no longer
+         * be present. This can not only help setting up models with
+         * less effort, but can also improve performance, because
+         * the algorithm doesn't have to search in locations below
+         * this depth.
+         */
+        double maximum_depth;
+
+        /**
+         * Computee bounding points for a BoundingBox object using two extreme points in all the surface
+         * coordinates and an additional buffer zone that accounts for the fault thickness and length. The first and second
+         * points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
+         * documentation in include/bounding_box.h).
+         * For the spherical system, the buffer zone along the longitudal direction is calculated using the
+         * corresponding latitude points.
+         */
+        BoundingBox<2> surface_bounding_box;
+
+        /**
+         * A point on the surface to which the fault dips.
+         */
+        WorldBuilder::Point<2> reference_point;
+
+        std::vector<std::vector<double> > fault_segment_lengths;
+        std::vector<std::vector<Point<2> > > fault_segment_thickness;
+        std::vector<std::vector<Point<2> > > fault_segment_top_truncation;
+        std::vector<std::vector<Point<2> > > fault_segment_angles;
+        std::vector<double> total_fault_length;
+        double maximum_total_fault_length;
+        double maximum_fault_thickness;
+
+        double min_along_x;
+        double max_along_x;
+        double min_along_y;
+        double max_along_y;
+        double min_lat_cos_inv;
+        double max_lat_cos_inv;
+        double buffer_around_fault_cartesian;
+
+    };
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/composition/interface.h.bak
new file mode 100644
index 00000000000..379f23198e7
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/composition/interface.h.bak
@@ -0,0 +1,172 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_COMPOSITION_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_COMPOSITION_INTERFACE_H
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/utilities.h"
+#include "world_builder/features/feature_utilities.h"
+
+#include <map>
+#include <vector>
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as oceanic plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm) = 0;
+
+
+            /**
+             * takes composition and position and returns a composition.
+             */
+            virtual
+            double get_composition(const Point<3> &position,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_FAULT_COMPOSITION_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Composition
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/composition/smooth.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/composition/smooth.h.bak
new file mode 100644
index 00000000000..cf2797297a9
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/composition/smooth.h.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef _world_builder_features_fault_composition_smooth_h
+#define _world_builder_features_fault_composition_smooth_h
+
+#include <world_builder/features/fault_models/composition/interface.h>
+#include <world_builder/features/feature_utilities.h>
+#include <world_builder/world.h>
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Smooth: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Smooth(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Smooth();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a composition based on the given position, depth in the model,
+             * and current composition.
+             */
+            double get_composition(const Point<3> &position,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+          private:
+            // linear temperature submodule parameters
+            double min_distance;
+            double side_distance;
+            std::vector<double> center_fraction;
+            // currently not using the side composition, but maybe useful if you want another composition towards the end
+            std::vector<double> side_fraction;
+            std::vector<unsigned int> compositions;
+            Operations operation;
+
+        };
+      }
+    }
+  }
+}
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/composition/uniform.h.bak
new file mode 100644
index 00000000000..d4cf27758c6
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/composition/uniform.h.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_COMPOSITION_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_COMPOSITION_UNIFORM_H
+
+
+#include "world_builder/features/fault_models/composition/interface.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a composition based on the given position, depth in the model,
+             * gravity and current composition.
+             */
+            double get_composition(const Point<3> &position,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+
+          private:
+            // uniform composition submodule parameters
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> compositions;
+            std::vector<double> fractions;
+            Operations operation;
+
+        };
+      } // namespace Composition
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/grains/interface.h.bak
new file mode 100644
index 00000000000..64fc61674bb
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/grains/interface.h.bak
@@ -0,0 +1,173 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_INTERFACE_H
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/utilities.h"
+#include "world_builder/features/feature_utilities.h"
+
+#include <map>
+#include <vector>
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as oceanic plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace FaultModels
+    {
+      namespace Grains
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm) = 0;
+
+
+            /**
+             * takes composition and position and returns a composition.
+             */
+            virtual
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth,
+                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                       const AdditionalParameters &additional_parameters) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_FAULT_GRAINS_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      virtual std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Grains
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution.h.bak
new file mode 100644
index 00000000000..67712d21156
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution.h.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+
+
+#include "world_builder/features/fault_models/grains/interface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace FaultModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a continental plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistribution final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistribution(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistribution() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth,
+                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                       const AdditionalParameters &additional_parameters) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+        };
+      } // namespace Grains
+    }   // namespace FaultModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h.bak
new file mode 100644
index 00000000000..82d2c683f07
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+
+
+#include "world_builder/features/fault_models/grains/interface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace FaultModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a fault and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistributionDeflected final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistributionDeflected(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistributionDeflected() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth,
+                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                       const AdditionalParameters &additional_parameters) const override final;
+
+          private:
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+            std::vector<double> deflections;
+        };
+      } // namespace Grains
+    }   // namespace FaultModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/grains/uniform.h.bak
new file mode 100644
index 00000000000..d56b49a9ecf
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/grains/uniform.h.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_UNIFORM_H
+
+
+#include "world_builder/features/fault_models/grains/interface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a oceanic plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth,
+                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                       const AdditionalParameters &additional_parameters) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
+            std::vector<double> grain_sizes;
+        };
+      } // namespace Grains
+    }   // namespace FaultModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/temperature/adiabatic.h.bak
new file mode 100644
index 00000000000..0cf1e7a4686
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/temperature/adiabatic.h.bak
@@ -0,0 +1,110 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_ADIABATIC_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_ADIABATIC_H
+
+
+#include "world_builder/features/fault_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Adiabatic final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Adiabatic(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Adiabatic() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+
+          private:
+            // adiabatic temperature submodule parameters
+            double min_depth;
+            double max_depth;
+            /**
+             * Todo
+             */
+            double potential_mantle_temperature;
+
+
+            /**
+             * Todo
+             */
+            double thermal_expansion_coefficient;
+
+            /**
+             * Todo
+             */
+            double specific_heat;
+
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/temperature/interface.h.bak
new file mode 100644
index 00000000000..57a74886f30
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/temperature/interface.h.bak
@@ -0,0 +1,173 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_INTERFACE_H
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/utilities.h"
+#include "world_builder/features/feature_utilities.h"
+
+#include <map>
+#include <vector>
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as oceanic plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace FaultModels
+    {
+      namespace Temperature
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm) = 0;
+
+
+            /**
+             * takes temperature and position and returns a temperature.
+             */
+            virtual
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            /**
+             * The name of the feature type.
+             */
+            std::string name;
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_FAULT_TEMPERATURE_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Temperature
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/temperature/linear.h.bak
new file mode 100644
index 00000000000..d70b8c57c15
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/temperature/linear.h.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_LINEAR_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_LINEAR_H
+
+
+#include "world_builder/features/fault_models/temperature/interface.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Linear final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Linear(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Linear() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+
+          private:
+            // linear temperature submodule parameters
+            double min_depth;
+            double max_depth;
+            double center_temperature;
+            double side_temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/temperature/uniform.h.bak
new file mode 100644
index 00000000000..2b42e9faa4d
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/fault_models/temperature/uniform.h.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_UNIFORM_H
+
+
+#include "world_builder/features/fault_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+
+          private:
+            // uniform temperature submodule parameters
+            double min_depth;
+            double max_depth;
+            double temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/feature_utilities.h.bak b/contrib/world_builder/include/world_builder/features/feature_utilities.h.bak
new file mode 100644
index 00000000000..997eed98995
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/feature_utilities.h.bak
@@ -0,0 +1,101 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef WORLD_BUILDER_FEATURES_FEATURE_UTILITIES_H
+#define WORLD_BUILDER_FEATURES_FEATURE_UTILITIES_H
+
+#include <limits>
+#include <vector>
+
+#include "world_builder/assert.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace FeatureUtilities
+    {
+      enum class Operations
+      {
+        REPLACE,ADD,SUBTRACT,REPLACE_DEFINED_ONLY
+      };
+
+      /**
+       * transforms string operations into enums.
+       */
+      Operations
+      string_operations_to_enum(const std::string &operation);
+
+
+      /**
+       * Applies different operations such as replace, add and subtract to the original values
+       */
+      inline double
+      apply_operation(const Operations operation,
+                      const double old_value,
+                      const double new_value)
+      {
+        switch (operation)
+          {
+            case Operations::REPLACE:
+            case Operations::REPLACE_DEFINED_ONLY:
+              return new_value;
+              break;
+
+            case Operations::ADD:
+              return old_value + new_value;
+              break;
+
+            case Operations::SUBTRACT:
+              return old_value - new_value;
+
+            default:
+              WBAssert(false,"Operation not found.");
+          }
+
+        return std::numeric_limits<double>::signaling_NaN();
+      }
+
+      /**
+       * A struct that is used to hold additional values based on the output of
+       *  the function distance_point_from_curved_planes().
+       */
+      struct AdditionalParameters
+      {
+        // The total length of all the segments at the location of the plane.
+        double total_local_segment_length;
+
+        // The local thickness of the segment at the location of the plane.
+        double local_thickness;
+      };
+
+
+      /**
+       * Add a string to a vector of strings, if the exact string isn't already
+       * in the vector. Returns the location of the string in the final vector.
+       */
+      size_t
+      add_vector_unique(std::vector<std::string> &vector,const std::string &add_string);
+
+    } // namespace Utilities
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/interface.h.bak b/contrib/world_builder/include/world_builder/features/interface.h.bak
new file mode 100644
index 00000000000..a23a45c7592
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/interface.h.bak
@@ -0,0 +1,228 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_INTERFACE_H
+
+
+#include "world_builder/grains.h"
+#include "world_builder/utilities.h"
+#include "world_builder/objects/distance_from_surface.h"
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+
+
+  namespace Features
+  {
+    class ObjectFactory;
+
+    /**
+     * This class is an interface for the specific plate tectonic feature classes,
+     * such as continental plate, oceanic plate and subduction zone.
+     */
+    class Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        Interface();
+
+        /**
+         * Destructor
+         */
+        virtual
+        ~Interface();
+
+        /**
+         * helper function to parse coordinates.
+         */
+        void
+        get_coordinates(const std::string &name,
+                        Parameters &prm,
+                        const CoordinateSystem coordinate_system);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm,
+                             const std::string &parent_name,
+                             const std::vector<std::string> &required_entries);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        virtual
+        void parse_entries(Parameters &prm) = 0;
+
+
+        /**
+         * takes a set of properties and a position and return a new set of properties
+         */
+        virtual
+        void properties(const Point<3> &position_in_cartesian_coordinates,
+                        const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                        const double depth,
+                        const std::vector<std::array<unsigned int,3>> &properties,
+                        const double gravity,
+                        const std::vector<size_t> &entry_in_output,
+                        std::vector<double> &output) const = 0;
+
+        /**
+         * A function to register a new type. This is part of the automatic
+         * registration of the object factory.
+         */
+        static void registerType(const std::string &name,
+                                 void ( * /*declare_entries*/)(Parameters &, const std::string &, const std::vector<std::string> &required_entries),
+                                 void ( *make_snippet)(Parameters &),
+                                 ObjectFactory *factory);
+
+        std::string get_name() const
+        {
+          return name;
+        };
+
+
+        /**
+         * A function to create a new type. This is part of the automatic
+         * registration of the object factory.
+         */
+        static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+        /**
+        * Returns a PlaneDistances object that has the distance from and along a feature plane,
+        * calculated from the coordinates and the depth of the point.
+        */
+        virtual
+        Objects::PlaneDistances
+        distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
+                                  const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                  const double depth) const;
+
+
+      protected:
+        /**
+         * A pointer to the world class to retrieve variables.
+         */
+        WorldBuilder::World *world;
+
+        /**
+         * The name of the feature type.
+         */
+        std::string name;
+
+        /**
+         * The index of the tag for this feature.
+         * This corresponds to the index in the feature_tags variable which is store in the World.
+         */
+        size_t tag_index;
+
+        /**
+         * The type of interpolation used to get the line position between the points.
+         */
+        WorldBuilder::Utilities::InterpolationType interpolation_type;
+
+        /**
+         * number of original coordinates, before adding
+         * more automatically.
+         */
+        std::size_t original_number_of_coordinates;
+
+        /**
+         * The coordinates at the surface of the feature
+         */
+        std::vector<Point<2> > coordinates;
+
+        /**
+         * The x and y spline
+         */
+        WorldBuilder::Objects::BezierCurve bezier_curve;
+
+
+        /**
+         * The name of the temperature submodule used by this feature.
+         */
+        std::string temperature_submodule_name;
+
+        /**
+         * The name of the composition submodule used by this feature.
+         */
+        std::string composition_submodule_name;
+
+
+      private:
+        static std::map<std::string, ObjectFactory *> &get_factory_map()
+        {
+          static std::map<std::string, ObjectFactory *> factories;
+          return factories;
+        }
+
+        static std::map<std::string, void ( *)(Parameters &,
+                                               const std::string &,
+                                               const std::vector<std::string>& required_entries)> &get_declare_map()
+        {
+          static std::map<std::string, void ( *)(Parameters &,
+                                                 const std::string &,
+                                                 const std::vector<std::string>& required_entries)> declares;
+          return declares;
+        }
+
+        static std::map<std::string, void ( *)(Parameters &)> &get_snippet_map()
+        {
+          static std::map<std::string, void ( *)(Parameters &)> declares;
+          return declares;
+        }
+    };
+
+
+    /**
+     * A class to create new objects
+     */
+    class ObjectFactory
+    {
+      public:
+        virtual std::unique_ptr<Interface> create(World *world) = 0;
+    };
+
+    /**
+     * A macro which should be in every derived cpp file to automatically
+     * register it. Because this is a library, we need some extra measures
+     * to ensure that the static variable is actually initialized.
+     */
+#define WB_REGISTER_FEATURE(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, klass::make_snippet, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer.h.bak
new file mode 100644
index 00000000000..39785617f47
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer.h.bak
@@ -0,0 +1,161 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_H
+
+
+#include "world_builder/features/interface.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+  class World;
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace MantleLayerModels
+
+    /**
+     * This class represents a mantle layer and can implement submodules
+     * for temperature and composition. These submodules determine what
+     * the returned temperature or composition of the temperature and composition
+     * functions of this class will be.
+     */
+    class MantleLayer final: public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        MantleLayer(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~MantleLayer() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm,
+                             const std::string &parent_name = "",
+                             const std::vector<std::string> &required_entries = {});
+
+        /**
+         * Produce a JSON snippet for the schema
+         */
+        static
+        void make_snippet(Parameters &prm);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+        /**
+         * Returns different values at a single point in one go stored in a vector of doubles.
+         *
+         * The properties input decides what each entry means, and the output is generated in the
+         * same order as the properties input. The properties input consists of
+         * a 3D array, where the first entry identifies the property and the last two entries
+         * provide extra information about that property.
+         *
+         * Temperature is identified by 1 and no extra information is needed. So temperature
+         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
+         * vector.
+         *
+         * Composition is identified by 2. This produces one
+         * value in the output. The second entry  identifies the composition number and the third
+         * number is not used. So a commposition query asking about composition 1 looks like this:
+         * {2,1,0}. A composition query prodoces one entry in the output vector.
+         *
+         * Grains are identified by 2. The second entry is the grain composition number and the third
+         * entry is the number of grains. A query about the grains, where it asks about composition 1
+         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
+         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
+         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
+         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
+         *
+         * The entries in output variable relates the index of the property to the index in the output.
+         */
+        void
+        properties(const Point<3> &position_in_cartesian_coordinates,
+                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                   const double depth,
+                   const std::vector<std::array<unsigned int,3>> &properties,
+                   const double gravity,
+                   const std::vector<size_t> &entry_in_output,
+                   std::vector<double> &output) const override final;
+
+      private:
+        /**
+         * A vector containing all the pointers to the temperature models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::MantleLayerModels::Temperature::Interface> > temperature_models;
+
+        /**
+         * A vector containing all the pointers to the composition models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::MantleLayerModels::Composition::Interface> > composition_models;
+
+        /**
+         * A vector containing all the pointers to the grains models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::MantleLayerModels::Grains::Interface> > grains_models;
+
+        double min_depth;
+        Objects::Surface min_depth_surface;
+        double max_depth;
+        Objects::Surface max_depth_surface;
+
+    };
+
+
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/interface.h.bak
new file mode 100644
index 00000000000..280cc7471bf
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/interface.h.bak
@@ -0,0 +1,168 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_COMPOSITION_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_COMPOSITION_INTERFACE_H
+
+
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace MantleLayerModels
+    {
+      namespace Composition
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
+
+
+            /**
+             * takes composition and position and returns a composition.
+             */
+            virtual
+            double get_composition(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_MANTLE_LAYER_COMPOSITION_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Composition
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/uniform.h.bak
new file mode 100644
index 00000000000..247125db618
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/uniform.h.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_COMPOSITION_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_COMPOSITION_UNIFORM_H
+
+
+#include "world_builder/features/mantle_layer_models/composition/interface.h"
+#include "world_builder/objects/surface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace MantleLayerModels
+    {
+      namespace Composition
+      {
+        /**
+         * This class represents a mantle layer and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a composition based on the given position, depth in the model,
+             * gravity and current composition.
+             */
+            double get_composition(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // uniform composition submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> compositions;
+            std::vector<double> fractions;
+            Operations operation;
+
+        };
+      } // namespace Composition
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/interface.h.bak
new file mode 100644
index 00000000000..3d86a58fb16
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/interface.h.bak
@@ -0,0 +1,170 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_INTERFACE_H
+
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace MantleLayerModels
+    {
+      namespace Grains
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
+
+
+            /**
+             * takes composition and position and returns grains.
+             */
+            virtual
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_MANTLE_LAYER_GRAINS_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      virtual std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Grains
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h.bak
new file mode 100644
index 00000000000..ac8476e3742
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+
+
+#include "world_builder/features/mantle_layer_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a continental plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistribution final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistribution(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistribution() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+        };
+      } // namespace Grains
+    }   // namespace MantleLayerModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h.bak
new file mode 100644
index 00000000000..4d0bd807be8
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+
+
+#include "world_builder/features/mantle_layer_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a mantle layer and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistributionDeflected final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistributionDeflected(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistributionDeflected() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+            std::vector<double> deflections;
+        };
+      } // namespace Grains
+    }   // namespace MantleLayerModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/uniform.h.bak
new file mode 100644
index 00000000000..60b8cd87b96
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/uniform.h.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_UNIFORM_H
+
+
+#include "world_builder/features/mantle_layer_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a oceanic plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
+            std::vector<double> grain_sizes;
+        };
+      } // namespace Grains
+    } // namespace MantleLayerModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/adiabatic.h.bak
new file mode 100644
index 00000000000..e281a0510e2
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/adiabatic.h.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_ADIABATIC_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_ADIABATIC_H
+
+
+#include "world_builder/features/mantle_layer_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace MantleLayerModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a mantle layer and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Adiabatic final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Adiabatic(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Adiabatic() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // adiabatic temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            /**
+             * Todo
+             */
+            double potential_mantle_temperature;
+
+
+            /**
+             * Todo
+             */
+            double thermal_expansion_coefficient;
+
+            /**
+             * Todo
+             */
+            double specific_heat;
+
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/interface.h.bak
new file mode 100644
index 00000000000..cc4dc67b6bd
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/interface.h.bak
@@ -0,0 +1,169 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_INTERFACE_H
+
+
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace MantleLayerModels
+    {
+      namespace Temperature
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
+
+
+            /**
+             * takes temperature and position and returns a temperature.
+             */
+            virtual
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            /**
+             * The name of the feature type.
+             */
+            std::string name;
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_MANTLE_LAYER_TEMPERATURE_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Temperature
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/linear.h.bak
new file mode 100644
index 00000000000..df29e574412
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/linear.h.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_LINEAR_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_LINEAR_H
+
+
+#include "world_builder/features/mantle_layer_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace MantleLayerModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a mantle layer and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Linear final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Linear(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Linear() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // linear temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            double top_temperature;
+            double bottom_temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/uniform.h.bak
new file mode 100644
index 00000000000..beb7a69d9ab
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/uniform.h.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_UNIFORM_H
+
+
+#include "world_builder/features/mantle_layer_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace MantleLayerModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a mantle layer and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // uniform temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            double temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate.h.bak
new file mode 100644
index 00000000000..50ec29c9c66
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate.h.bak
@@ -0,0 +1,158 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_H
+
+
+#include "world_builder/features/interface.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+  class World;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace OceanicPlateModels
+
+    /**
+     * This class represents a oceanic plate and can implement submodules
+     * for temperature and composition. These submodules determine what
+     * the returned temperature or composition of the temperature and composition
+     * functions of this class will be.
+     */
+    class OceanicPlate final: public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        OceanicPlate(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~OceanicPlate() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm,
+                             const std::string &parent_name = "",
+                             const std::vector<std::string> &required_entries = {});
+
+        /**
+         * Produce a JSON snippet for the schema
+         */
+        static
+        void make_snippet(Parameters &prm);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+        /**
+         * Returns different values at a single point in one go stored in a vector of doubles.
+         *
+         * The properties input decides what each entry means, and the output is generated in the
+         * same order as the properties input. The properties input consists of
+         * a 3D array, where the first entry identifies the property and the last two entries
+         * provide extra information about that property.
+         *
+         * Temperature is identified by 1 and no extra information is needed. So temperature
+         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
+         * vector.
+         *
+         * Composition is identified by 2. This produces one
+         * value in the output. The second entry  identifies the composition number and the third
+         * number is not used. So a commposition query asking about composition 1 looks like this:
+         * {2,1,0}. A composition query prodoces one entry in the output vector.
+         *
+         * Grains are identified by 2. The second entry is the grain composition number and the third
+         * entry is the number of grains. A query about the grains, where it asks about composition 1
+         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
+         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
+         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
+         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
+         *
+         * The entries in output variable relates the index of the property to the index in the output.
+         */
+        void
+        properties(const Point<3> &position_in_cartesian_coordinates,
+                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                   const double depth,
+                   const std::vector<std::array<unsigned int,3>> &properties,
+                   const double gravity,
+                   const std::vector<size_t> &entry_in_output,
+                   std::vector<double> &output) const override final;
+
+      private:
+        /**
+         * A vector containing all the pointers to the temperature models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::OceanicPlateModels::Temperature::Interface> > temperature_models;
+
+        /**
+         * A vector containing all the pointers to the composition models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::OceanicPlateModels::Composition::Interface> > composition_models;
+
+        /**
+         * A vector containing all the pointers to the grains models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::OceanicPlateModels::Grains::Interface> > grains_models;
+
+        double min_depth;
+        Objects::Surface min_depth_surface;
+        double max_depth;
+        Objects::Surface max_depth_surface;
+    };
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/interface.h.bak
new file mode 100644
index 00000000000..afb2cdf25f4
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/interface.h.bak
@@ -0,0 +1,168 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_COMPOSITION_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_COMPOSITION_INTERFACE_H
+
+
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as oceanic plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace OceanicPlateModels
+    {
+      namespace Composition
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
+
+
+            /**
+             * takes composition and position and returns a composition.
+             */
+            virtual
+            double get_composition(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_OCEANIC_PLATE_COMPOSITION_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Composition
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/uniform.h.bak
new file mode 100644
index 00000000000..d4ffad6943f
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/uniform.h.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_COMPOSITION_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_COMPOSITION_UNIFORM_H
+
+
+#include "world_builder/features/oceanic_plate_models/composition/interface.h"
+#include "world_builder/objects/surface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace OceanicPlateModels
+    {
+      namespace Composition
+      {
+        /**
+         * This class represents a oceanic plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a composition based on the given position, depth in the model,
+             * gravity and current composition.
+             */
+            double get_composition(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // uniform composition submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> compositions;
+            std::vector<double> fractions;
+            Operations operation;
+
+        };
+      } // namespace Composition
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/interface.h.bak
new file mode 100644
index 00000000000..33cb8afaf05
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/interface.h.bak
@@ -0,0 +1,166 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_INTERFACE_H
+
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as oceanic plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace OceanicPlateModels
+    {
+      namespace Grains
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
+
+
+            /**
+             * takes composition and position and returns grains.
+             */
+            virtual
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_OCEANIC_PLATE_GRAINS_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      virtual std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Grains
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h.bak
new file mode 100644
index 00000000000..6b9604d0f2c
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+
+
+#include "world_builder/features/oceanic_plate_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a continental plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistribution final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistribution(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistribution() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+        };
+      } // namespace Grains
+    }   // namespace OceanicPlateModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h.bak
new file mode 100644
index 00000000000..4a80945817d
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+
+
+#include "world_builder/features/oceanic_plate_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a continental plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistributionDeflected final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistributionDeflected(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistributionDeflected() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+            std::vector<double> deflections;
+        };
+      } // namespace Grains
+    }   // namespace OceanicPlateModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/uniform.h.bak
new file mode 100644
index 00000000000..ba08f845e69
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/uniform.h.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_UNIFORM_H
+
+
+#include "world_builder/features/oceanic_plate_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a oceanic plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
+            std::vector<double> grain_sizes;
+        };
+      } // namespace Grains
+    }   // namespace OceanicPlateModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/adiabatic.h.bak
new file mode 100644
index 00000000000..9147f3b99fb
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/adiabatic.h.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
+
+
+#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a oceanic plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Adiabatic final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Adiabatic(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Adiabatic() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // adiabatic temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            /**
+             * Todo
+             */
+            double potential_mantle_temperature;
+
+
+            /**
+             * Todo
+             */
+            double thermal_expansion_coefficient;
+
+            /**
+             * Todo
+             */
+            double specific_heat;
+
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/half_space_model.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/half_space_model.h.bak
new file mode 100644
index 00000000000..967134ec5c9
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/half_space_model.h.bak
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_HALF_SPACE_MODEL_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_HALF_SPACE_MODEL_H
+
+
+#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+  class World;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a oceanic plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class HalfSpaceModel final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            HalfSpaceModel(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~HalfSpaceModel() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+          private:
+            // plate model temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            double top_temperature;
+            double bottom_temperature;
+            std::pair<std::vector<double>,std::vector<double>> spreading_velocities;
+            std::vector<std::vector<Point<2> > > mid_oceanic_ridges;
+            std::vector<std::vector<double>> spreading_velocities_at_each_ridge_point;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/interface.h.bak
new file mode 100644
index 00000000000..5239b8570b5
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/interface.h.bak
@@ -0,0 +1,169 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_INTERFACE_H
+
+
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as oceanic plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
+
+
+            /**
+             * takes temperature and position and returns a temperature.
+             */
+            virtual
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            /**
+             * The name of the feature type.
+             */
+            std::string name;
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/linear.h.bak
new file mode 100644
index 00000000000..3044603f3af
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/linear.h.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_LINEAR_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_LINEAR_H
+
+
+#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a oceanic plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Linear final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Linear(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Linear() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // linear temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            double top_temperature;
+            double bottom_temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model.h.bak
new file mode 100644
index 00000000000..ef381bd6f0a
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model.h.bak
@@ -0,0 +1,107 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_H
+
+
+#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+  class World;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a oceanic plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         * In this plugin, the temperature of the plate is derived from the plate model,
+         * featuring continuous cooling of a plate from a spreading ridge by both vertical
+         * and horizontal heat conduction.
+         */
+        class PlateModel final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            PlateModel(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~PlateModel() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // plate model temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            double top_temperature;
+            double bottom_temperature;
+            std::pair<std::vector<double>,std::vector<double>> spreading_velocities;
+            std::vector<std::vector<Point<2> > > mid_oceanic_ridges;
+            std::vector<std::vector<double>> spreading_velocities_at_each_ridge_point;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h.bak
new file mode 100644
index 00000000000..b73e6ebfc51
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h.bak
@@ -0,0 +1,105 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_CONSTANT_AGE_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_CONSTANT_AGE_H
+
+
+#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+  class World;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a oceanic plate of constant age and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         * In this plugin, the temperature of the plate is derived from the plate model,
+         * featuring cooling of a plate from a ridge by vertical heat conduction,
+         * while the effects of horizontal heat conduction are ignored.
+         */
+        class PlateModelConstantAge final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            PlateModelConstantAge(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~PlateModelConstantAge() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // plate model constant age temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            double top_temperature;
+            double bottom_temperature;
+            double plate_age;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/uniform.h.bak
new file mode 100644
index 00000000000..031e3c3a004
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/uniform.h.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_UNIFORM_H
+
+
+#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a oceanic plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // uniform temperature submodule parameters
+            double min_depth;
+            Objects::Surface min_depth_surface;
+            double max_depth;
+            Objects::Surface max_depth_surface;
+            double temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume.h.bak b/contrib/world_builder/include/world_builder/features/plume.h.bak
new file mode 100644
index 00000000000..cbd73cf8d4a
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/plume.h.bak
@@ -0,0 +1,164 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_PLUME_H
+#define WORLD_BUILDER_FEATURES_PLUME_H
+
+
+#include "world_builder/features/interface.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+  class World;
+
+  namespace Features
+  {
+    namespace PlumeModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace PlumeModels
+
+    /**
+     * This class represents a plume and can implement submodules
+     * for temperature and composition. These submodules determine what
+     * the returned temperature or composition of the temperature and composition
+     * functions of this class will be.
+     */
+    class Plume final: public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        Plume(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~Plume() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm,
+                             const std::string &parent_name = "",
+                             const std::vector<std::string> &required_entries = {});
+
+        /**
+         * Produce a JSON snippet for the schema
+         */
+        static
+        void make_snippet(Parameters &prm);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+        /**
+         * Returns different values at a single point in one go stored in a vector of doubles.
+         *
+         * The properties input decides what each entry means, and the output is generated in the
+         * same order as the properties input. The properties input consists of
+         * a 3D array, where the first entry identifies the property and the last two entries
+         * provide extra information about that property.
+         *
+         * Temperature is identified by 1 and no extra information is needed. So temperature
+         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
+         * vector.
+         *
+         * Composition is identified by 2. This produces one
+         * value in the output. The second entry  identifies the composition number and the third
+         * number is not used. So a commposition query asking about composition 1 looks like this:
+         * {2,1,0}. A composition query produces one entry in the output vector.
+         *
+         * Grains are identified by 2. The second entry is the grain composition number and the third
+         * entry is the number of grains. A query about the grains, where it asks about composition 1
+         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
+         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
+         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
+         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
+         *
+         * The entries in output variable relates the index of the property to the index in the output.
+         */
+        void
+        properties(const Point<3> &position_in_cartesian_coordinates,
+                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                   const double depth,
+                   const std::vector<std::array<unsigned int,3>> &properties,
+                   const double gravity,
+                   const std::vector<size_t> &entry_in_output,
+                   std::vector<double> &output) const override final;
+
+      private:
+        /**
+         * A vector containing all the pointers to the temperature models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::PlumeModels::Temperature::Interface> > temperature_models;
+
+        /**
+         * A vector containing all the pointers to the composition models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::PlumeModels::Composition::Interface> > composition_models;
+
+        /**
+         * A vector containing all the pointers to the grains models. This vector is
+         * responsible for the features and has ownership over them. Therefore
+         * unique pointers are used.
+         * @see Features
+         */
+        std::vector<std::unique_ptr<Features::PlumeModels::Grains::Interface> > grains_models;
+
+
+        double min_depth;
+        double max_depth;
+
+        std::vector<double> depths;
+        std::vector<double> semi_major_axis_lengths;
+        std::vector<double> eccentricities;
+        std::vector<double> rotation_angles;
+    };
+
+
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/composition/interface.h.bak
new file mode 100644
index 00000000000..ad34a427e22
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/plume_models/composition/interface.h.bak
@@ -0,0 +1,164 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_COMPOSITION_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_PLUME_MODELS_COMPOSITION_INTERFACE_H
+
+
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+namespace WorldBuilder
+{
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace PlumeModels
+    {
+      namespace Composition
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm) = 0;
+
+
+            /**
+             * takes composition and position and returns a composition.
+             */
+            virtual
+            double get_composition(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_PLUME_COMPOSITION_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Composition
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/composition/uniform.h.bak
new file mode 100644
index 00000000000..209bd78c2d6
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/plume_models/composition/uniform.h.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_COMPOSITION_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_PLUME_MODELS_COMPOSITION_UNIFORM_H
+
+
+#include "world_builder/features/plume_models/composition/interface.h"
+#include "world_builder/objects/surface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace PlumeModels
+    {
+      namespace Composition
+      {
+        /**
+         * This class represents a plume and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final : public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a composition based on the given position, depth in the model,
+             * gravity and current composition.
+             */
+            double get_composition(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth) const override final;
+
+
+          private:
+            // uniform composition submodule parameters
+
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> compositions;
+            std::vector<double> fractions;
+            Operations operation;
+
+        };
+      } // namespace Composition
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/grains/interface.h.bak
new file mode 100644
index 00000000000..b18fbd11b17
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/plume_models/grains/interface.h.bak
@@ -0,0 +1,170 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_GRAINS_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_PLUME_MODELS_GRAINS_INTERFACE_H
+
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace PlumeModels
+    {
+      namespace Grains
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm) = 0;
+
+
+            /**
+             * takes composition and position and returns grains.
+             */
+            virtual
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_PLUME_GRAINS_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      virtual std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Grains
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/grains/uniform.h.bak
new file mode 100644
index 00000000000..ad906fa95d3
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/plume_models/grains/uniform.h.bak
@@ -0,0 +1,111 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_GRAINS_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_PLUME_MODELS_GRAINS_UNIFORM_H
+
+
+#include "world_builder/features/plume_models/grains/interface.h"
+#include "world_builder/objects/surface.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace PlumeModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a plume and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class Uniform final : public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
+            std::vector<double> grain_sizes;
+        };
+      } // namespace Grains
+    }   // namespace PlumeModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/temperature/gaussian.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/temperature/gaussian.h.bak
new file mode 100644
index 00000000000..6dd80a0b8ee
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/plume_models/temperature/gaussian.h.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_GAUSSIAN_H
+#define WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_GAUSSIAN_H
+
+
+#include "world_builder/features/plume_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace PlumeModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a plume and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Gaussian final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Gaussian(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Gaussian() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const double relative_distance_from_center) const override final;
+
+
+          private:
+            // Gaussian temperature submodule parameters
+            std::vector<double> depths;
+            std::vector<double> center_temperatures;
+            std::vector<double> gaussian_sigmas;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/temperature/interface.h.bak
new file mode 100644
index 00000000000..8f4ba5dd579
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/plume_models/temperature/interface.h.bak
@@ -0,0 +1,173 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_INTERFACE_H
+
+
+#include "world_builder/parameters.h"
+#include "world_builder/objects/natural_coordinate.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+
+    namespace PlumeModels
+    {
+      namespace Temperature
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm) = 0;
+
+
+            /**
+             * takes temperature and position and returns a temperature.
+             * The relative distance from center gives the result of the ellipse
+             * equation, i.e., x^2/a^2 + y^2/b^2, i.e., it tells us how far we
+             * are between the center and margin of the ellipse.
+             */
+            virtual
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const double relative_distance_from_center) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            /**
+             * The name of the feature type.
+             */
+            std::string name;
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_PLUME_TEMPERATURE_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Temperature
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/temperature/uniform.h.bak
new file mode 100644
index 00000000000..d6032cd8d66
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/plume_models/temperature/uniform.h.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_UNIFORM_H
+
+
+#include "world_builder/features/plume_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/objects/surface.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace PlumeModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a plume and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         * In this class, the temperature within the plume is uniform.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const double relative_distance_from_center) const override final;
+
+
+          private:
+            // uniform temperature submodule parameters
+            double min_depth;
+            double max_depth;
+            double temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate.h.bak
new file mode 100644
index 00000000000..2be2f50939e
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate.h.bak
@@ -0,0 +1,230 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_H
+
+
+#include "world_builder/features/subducting_plate_models/composition/interface.h"
+#include "world_builder/features/subducting_plate_models/grains/interface.h"
+#include "world_builder/features/subducting_plate_models/temperature/interface.h"
+#include "world_builder/objects/segment.h"
+#include "world_builder/bounding_box.h"
+#include "world_builder/objects/distance_from_surface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+  class World;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace SubductingPlateModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace SubductingPlateModels
+
+    /**
+     * This class represents a subducting plate and can implement submodules
+     * for temperature and composition. These submodules determine what
+     * the returned temperature or composition of the temperature and composition
+     * functions of this class will be.
+     */
+    class SubductingPlate final: public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        SubductingPlate(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~SubductingPlate() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm,
+                             const std::string &parent_name = "",
+                             const std::vector<std::string> &required_entries = {});
+
+        /**
+         * Produce a JSON snippet for the schema
+         */
+        static
+        void make_snippet(Parameters &prm);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+        /**
+         * Returns the bounding points for a BoundingBox object using two extreme points in all the surface
+         * coordinates and an additional buffer zone that accounts for the fault thickness and length. The first and second
+         * points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
+         * documentation in include/bounding_box.h).
+         * For the spherical system, the buffer zone along the longitudal direction is calculated using the
+         * corresponding latitude points.
+         */
+        const BoundingBox<2>  &get_surface_bounding_box () const;
+
+        /**
+         * Returns different values at a single point in one go stored in a vector of doubles.
+         *
+         * The properties input decides what each entry means, and the output is generated in the
+         * same order as the properties input. The properties input consists of
+         * a 3D array, where the first entry identifies the property and the last two entries
+         * provide extra information about that property.
+         *
+         * Temperature is identified by 1 and no extra information is needed. So temperature
+         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
+         * vector.
+         *
+         * Composition is identified by 2. This produces one
+         * value in the output. The second entry  identifies the composition number and the third
+         * number is not used. So a commposition query asking about composition 1 looks like this:
+         * {2,1,0}. A composition query prodoces one entry in the output vector.
+         *
+         * Grains are identified by 2. The second entry is the grain composition number and the third
+         * entry is the number of grains. A query about the grains, where it asks about composition 1
+         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
+         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
+         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
+         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
+         *
+         * The entries in output variable relates the index of the property to the index in the output.
+         */
+        void
+        properties(const Point<3> &position_in_cartesian_coordinates,
+                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                   const double depth,
+                   const std::vector<std::array<unsigned int,3>> &properties,
+                   const double gravity,
+                   const std::vector<size_t> &entry_in_output,
+                   std::vector<double> &output) const override final;
+
+        /**
+        * Returns a PlaneDistances object that has the distance from and along a subducting plate plane,
+        * calculated from the coordinates and the depth of the point.
+        */
+        Objects::PlaneDistances
+        distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
+                                  const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                  const double depth) const override;
+
+
+      private:
+        std::vector<std::shared_ptr<Features::SubductingPlateModels::Temperature::Interface> > default_temperature_models;
+        std::vector<std::shared_ptr<Features::SubductingPlateModels::Composition::Interface>  > default_composition_models;
+        std::vector<std::shared_ptr<Features::SubductingPlateModels::Grains::Interface>  > default_grains_models;
+
+        std::vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
+            Features::SubductingPlateModels::Composition::Interface,
+            Features::SubductingPlateModels::Grains::Interface> > default_segment_vector;
+
+        std::vector< std::vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
+            Features::SubductingPlateModels::Composition::Interface,
+            Features::SubductingPlateModels::Grains::Interface> > > sections_segment_vector;
+
+        // This vector stores segments to this coordinate/section.
+        //First used (raw) pointers to the segment relevant to this coordinate/section,
+        // but I do not trust it won't fail when memory is moved. So storing the all the data now.
+        std::vector<std::vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
+            Features::SubductingPlateModels::Composition::Interface,
+            Features::SubductingPlateModels::Grains::Interface> > > segment_vector;
+
+        // todo: the memory of this can be greatly improved by
+        // or using a plugin system for the submodules, or
+        // putting the variables in a union. Although the memory
+        // used by this program is in real cases expected to be
+        // Insignificant compared to what a calling program may
+        // use, a smaller amount of memory used in here, could
+        // theoretically speed up the computation, because more
+        // relevant data could be stored in the cache. But this
+        // not a urgent problem, and would require testing.
+
+        /**
+         * This variable stores the depth at which the subducting
+         * plate starts. It makes this depth effectively the surface
+         * of the model for the slab.
+         */
+        double starting_depth;
+
+        /**
+         * The depth which below the subducting plate may no longer
+         * be present. This can not only help setting up models with
+         * less effort, but can also improve performance, because
+         * the algorithm doesn't have to search in locations below
+         * this depth.
+         */
+        double maximum_depth;
+
+        /**
+         * Stores the bounding points for a BoundingBox object using two extreme points in all the surface
+         * coordinates and an additional buffer zone that accounts for the fault thickness and length. The first and second
+         * points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
+         * documentation in include/bounding_box.h).
+         * For the spherical system, the buffer zone along the longitudal direction is calculated using the
+         * corresponding latitude points.
+         */
+        BoundingBox<2> surface_bounding_box;
+
+        /**
+         * A point on the surface to which the subducting plates subduct.
+         */
+        Point<2> reference_point;
+
+        std::vector<std::vector<double> > slab_segment_lengths;
+        std::vector<std::vector<Point<2> > > slab_segment_thickness;
+        std::vector<std::vector<Point<2> > > slab_segment_top_truncation;
+        std::vector<std::vector<Point<2> > > slab_segment_angles;
+        std::vector<double> total_slab_length;
+        double maximum_total_slab_length;
+        double maximum_slab_thickness;
+
+        double min_along_x;
+        double max_along_x;
+        double min_along_y;
+        double max_along_y;
+        double min_lat_cos_inv;
+        double max_lat_cos_inv;
+        double buffer_around_slab_cartesian;
+    };
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/interface.h.bak
new file mode 100644
index 00000000000..130ad43c0e0
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/interface.h.bak
@@ -0,0 +1,173 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_COMPOSITION_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_COMPOSITION_INTERFACE_H
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/utilities.h"
+#include "world_builder/features/feature_utilities.h"
+
+#include <map>
+#include <vector>
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as oceanic plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+
+    namespace SubductingPlateModels
+    {
+      namespace Composition
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm) = 0;
+
+
+            /**
+             * takes composition and position and returns a composition.
+             */
+            virtual
+            double get_composition(const Point<3> &position,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_SUBDUCTING_PLATE_COMPOSITION_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Composition
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/smooth.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/smooth.h.bak
new file mode 100644
index 00000000000..b6ff89a5fa8
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/smooth.h.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef _world_builder_features_subducting_plate_composition_smooth_h
+#define _world_builder_features_subducting_plate_composition_smooth_h
+
+#include <world_builder/features/subducting_plate_models/composition/interface.h>
+#include <world_builder/features/feature_utilities.h>
+#include <world_builder/world.h>
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace SubductingPlateModels
+    {
+      namespace Composition
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Smooth: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Smooth(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Smooth();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a composition based on the given position, depth in the model,
+             * and current composition.
+             */
+            double get_composition(const Point<3> &position,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+          private:
+            // linear temperature submodule parameters
+            double min_distance;
+            double max_distance;
+            double side_distance;
+            std::vector<double> top_fraction;
+            // currently not using the side composition, but maybe usefu if you want another composition towards the end
+            std::vector<double> bottom_fraction;
+            std::vector<unsigned int> compositions;
+            Operations operation;
+
+        };
+      }
+    }
+  }
+}
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/uniform.h.bak
new file mode 100644
index 00000000000..dd10cfb725d
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/uniform.h.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_COMPOSITION_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_COMPOSITION_UNIFORM_H
+
+
+#include "world_builder/features/subducting_plate_models/composition/interface.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Composition
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a composition based on the given position, depth in the model,
+             * gravity and current composition.
+             */
+            double get_composition(const Point<3> &position,
+                                   const double depth,
+                                   const unsigned int composition_number,
+                                   double composition,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+
+          private:
+            // uniform composition submodule parameters
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> compositions;
+            std::vector<double> fractions;
+            Operations operation;
+
+        };
+      } // namespace Composition
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/interface.h.bak
new file mode 100644
index 00000000000..82999be947f
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/interface.h.bak
@@ -0,0 +1,173 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_INTERFACE_H
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/utilities.h"
+#include "world_builder/features/feature_utilities.h"
+
+#include <map>
+#include <vector>
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as oceanic plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace SubductingPlateModels
+    {
+      namespace Grains
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm) = 0;
+
+
+            /**
+             * takes composition and position and returns a composition.
+             */
+            virtual
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth,
+                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                       const AdditionalParameters &additional_parameters) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            std::string name;
+
+
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_SUBDUCTING_PLATE_GRAINS_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      virtual std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Grains
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h.bak
new file mode 100644
index 00000000000..45f1e8f2395
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
+
+
+#include "world_builder/features/subducting_plate_models/grains/interface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a continental plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistribution final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistribution(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistribution() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth,
+                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                       const AdditionalParameters &additional_parameters) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+        };
+      } // namespace Grains
+    }   // namespace SubductingPlateModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h.bak
new file mode 100644
index 00000000000..ddaada0be0b
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
+
+
+#include "world_builder/features/subducting_plate_models/grains/interface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a subducting plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class RandomUniformDistributionDeflected final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            RandomUniformDistributionDeflected(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~RandomUniformDistributionDeflected() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth,
+                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                       const AdditionalParameters &additional_parameters) const override final;
+
+          private:
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<double> grain_sizes;
+            std::vector<bool> normalize_grain_sizes;
+            std::vector<double> deflections;
+
+        };
+      } // namespace Grains
+    }   // namespace SubductingPlateModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/uniform.h.bak
new file mode 100644
index 00000000000..7265453073a
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/uniform.h.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_UNIFORM_H
+
+
+#include "world_builder/features/subducting_plate_models/grains/interface.h"
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Grains
+      {
+        /**
+         * This class represents a oceanic plate and can implement
+         * submodules for temperature and grains. These submodules determine
+         * what the returned temperature or grains of the temperature and grains
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_entries(Parameters &prm,
+                                        const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void declare_grain_size_model_entries(
+              Parameters &prm, const std::string &parent_name,
+              const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            static void
+            declare_fixed_size_model_entries(Parameters &prm,
+                                             const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters
+             * class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+            /**
+             * Returns a grains based on the given position, composition (e.g.
+             * olivine and/or enstatite)depth in the model, gravity and current grains.
+             */
+            WorldBuilder::grains
+            get_grains(const Point<3> &position,
+                       const double depth,
+                       const unsigned int composition_number,
+                       WorldBuilder::grains grains,
+                       const double feature_min_depth,
+                       const double feature_max_depth,
+                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                       const AdditionalParameters &additional_parameters) const override final;
+
+          private:
+            // uniform grains submodule parameters
+            double min_depth;
+            double max_depth;
+            std::vector<unsigned int> grains;
+            std::vector<unsigned int> compositions;
+            std::string operation;
+            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
+            std::vector<double> grain_sizes;
+        };
+      } // namespace Grains
+    } // namespace SubductingPlateModels
+  }     // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/adiabatic.h.bak
new file mode 100644
index 00000000000..9fb26e304ff
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/adiabatic.h.bak
@@ -0,0 +1,110 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
+
+
+#include "world_builder/features/subducting_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Adiabatic final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Adiabatic(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Adiabatic() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+
+          private:
+            // adiabatic temperature submodule parameters
+            double min_depth;
+            double max_depth;
+            /**
+             * Todo
+             */
+            double potential_mantle_temperature;
+
+
+            /**
+             * Todo
+             */
+            double thermal_expansion_coefficient;
+
+            /**
+             * Todo
+             */
+            double specific_heat;
+
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/interface.h.bak
new file mode 100644
index 00000000000..78bf056680e
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/interface.h.bak
@@ -0,0 +1,174 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_INTERFACE_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_INTERFACE_H
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/utilities.h"
+#include "world_builder/features/feature_utilities.h"
+
+#include <map>
+#include <vector>
+
+namespace WorldBuilder
+{
+  class World;
+  class Parameters;
+  template <unsigned int dim> class Point;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as oceanic plate, oceanic plate and subduction zone.
+   */
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        class ObjectFactory;
+
+        class Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Interface();
+
+            /**
+             * Destructor
+             */
+            virtual
+            ~Interface();
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm,
+                                 const std::string &parent_name,
+                                 const std::vector<std::string> &required_entries);
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            virtual
+            void parse_entries(Parameters &prm) = 0;
+
+
+            /**
+             * takes temperature and position and returns a temperature.
+             */
+            virtual
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const = 0;
+            /**
+             * A function to register a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static void registerType(const std::string &name,
+                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                     ObjectFactory *factory);
+
+
+            /**
+             * A function to create a new type. This is part of the automatic
+             * registration of the object factory.
+             */
+            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+            /**
+             * Returns the name of the plugin
+             */
+            std::string get_name() const
+            {
+              return name;
+            };
+
+          protected:
+            /**
+             * A pointer to the world class to retrieve variables.
+             */
+            WorldBuilder::World *world;
+
+            /**
+             * The name of the feature type.
+             */
+            std::string name;
+
+          private:
+            static std::map<std::string, ObjectFactory *> &get_factory_map()
+            {
+              static std::map<std::string, ObjectFactory *> factories;
+              return factories;
+            }
+
+            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+            {
+              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+              return declares;
+            }
+
+        };
+
+
+        /**
+         * A class to create new objects
+         */
+        class ObjectFactory
+        {
+          public:
+            virtual std::unique_ptr<Interface> create(World *world) = 0;
+        };
+
+        /**
+         * A macro which should be in every derived cpp file to automatically
+         * register it. Because this is a library, we need some extra measures
+         * to ensure that the static variable is actually initialized.
+         */
+#define WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/linear.h.bak
new file mode 100644
index 00000000000..7484cf35fe8
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/linear.h.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_LINEAR_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_LINEAR_H
+
+
+#include "world_builder/features/subducting_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Linear final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Linear(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Linear() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+
+          private:
+            // linear temperature submodule parameters
+            double min_depth;
+            double max_depth;
+            double top_temperature;
+            double bottom_temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/mass_conserving.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/mass_conserving.h.bak
new file mode 100644
index 00000000000..38344fb90c1
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/mass_conserving.h.bak
@@ -0,0 +1,143 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_MASS_CONSERVING_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_MASS_CONSERVING_H
+
+
+#include "world_builder/features/subducting_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a subducting plate temperature model. The temperature
+         * model uses the heat content (proportional to to thermal mass anomaly) to
+         * define a smooth temperature profile that conserves mass along the slab length.
+         * An empirical (linear) model is used to define how the minimum temperature
+         * increases with depth and how the location of the minimum temperature shifts
+         * into the slab interior. The slab is divided in to top and bottom parts,
+         * which meet at the location where the minimum temperature occurs in the slab.
+         * For the bottom slab the temperature is defined by a half-space cooling model.
+         * For the top of the slab the temperature is defined by one side of a 1D infinite
+         * space cooling model. The age of the overriding plate is used so the slab temperature
+         * at shallow depth smoothly transitions to the temperature of the overriding plate:
+         * this is not perfect, and is affected by the value of "top truncation" parameter
+         * subducting plate. Also note that the parameter "thickness" for the subducting plate
+         * segments needs to be defined but is not used.
+         * Note that the empirical model used to define how Tmin increases with depth
+         * and how the position of Tmin shift with depth is expected to change somewhat
+         * after better calibrating with further tests.
+         */
+        class MassConserving final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            MassConserving(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~MassConserving() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+            /**
+             * Returns a temperature based on the given heat content, temperatures, effective plate age,
+             * and adjusted distance to the coldest point in the slab. The temperature is formulated by
+             * the analytical solutions.
+             */
+            double get_temperature_analytic(const double top_heat_content,
+                                            const double min_temperature,
+                                            const double background_temperature,
+                                            const double temperature_,
+                                            const double plate_velocity,
+                                            const double effective_plate_age,
+                                            const double adjusted_distance) const;
+
+
+          private:
+            //  temperature submodule parameters
+            double min_depth;
+            double max_depth;
+            double density;
+            std::vector<std::vector<double>> subducting_velocities;
+            std::pair<std::vector<double>,std::vector<double>> ridge_spreading_velocities;
+            std::vector<std::vector<double>> ridge_spreading_velocities_at_each_ridge_point;
+            double mantle_coupling_depth;
+            double forearc_cooling_factor;
+            double thermal_conductivity;
+            double thermal_expansion_coefficient;
+            double specific_heat;
+            double thermal_diffusivity;
+            double potential_mantle_temperature;
+            double surface_temperature;
+            double taper_distance;
+            bool adiabatic_heating;
+            std::vector<std::vector<Point<2>>> mid_oceanic_ridges;
+            Operations operation;
+            enum ReferenceModelName
+            {
+              half_space_model,
+              plate_model
+            };
+            ReferenceModelName reference_model_name;
+            const int plate_model_summation_number = 100; // for the plate model
+            bool apply_spline;
+            unsigned int spline_n_points;
+        };
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/plate_model.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/plate_model.h.bak
new file mode 100644
index 00000000000..b92f9e995a5
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/plate_model.h.bak
@@ -0,0 +1,102 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_H
+
+
+#include "world_builder/features/subducting_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class PlateModel final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            PlateModel(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~PlateModel() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+
+          private:
+            // plate model temperature submodule parameters
+            double min_depth;
+            double max_depth;
+            double density;
+            double plate_velocity;
+            double thermal_conductivity;
+            double thermal_expansion_coefficient;
+            double specific_heat;
+            double potential_mantle_temperature;
+            double surface_temperature;
+            bool adiabatic_heating;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/uniform.h.bak
new file mode 100644
index 00000000000..2abcc838346
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/uniform.h.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_UNIFORM_H
+#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_UNIFORM_H
+
+
+#include "world_builder/features/subducting_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        /**
+         * This class represents a subducting plate and can implement submodules
+         * for temperature and composition. These submodules determine what
+         * the returned temperature or composition of the temperature and composition
+         * functions of this class will be.
+         */
+        class Uniform final: public Interface
+        {
+          public:
+            /**
+             * constructor
+             */
+            Uniform(WorldBuilder::World *world);
+
+            /**
+             * Destructor
+             */
+            ~Uniform() override final;
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            static
+            void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+            /**
+             * declare and read in the world builder file into the parameters class
+             */
+            void parse_entries(Parameters &prm) override final;
+
+
+            /**
+             * Returns a temperature based on the given position, depth in the model,
+             * gravity and current temperature.
+             */
+            double get_temperature(const Point<3> &position,
+                                   const double depth,
+                                   const double gravity,
+                                   double temperature,
+                                   const double feature_min_depth,
+                                   const double feature_max_depth,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters &additional_parameters) const override final;
+
+
+          private:
+            // uniform temperature submodule parameters
+            double min_depth;
+            double max_depth;
+            double temperature;
+            Operations operation;
+
+        };
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/grains.h.bak b/contrib/world_builder/include/world_builder/grains.h.bak
new file mode 100644
index 00000000000..eb47b2a12d2
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/grains.h.bak
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_GRAINS_H
+#define WORLD_BUILDER_GRAINS_H
+
+#include <array>
+#include <ostream>
+#include <vector>
+
+namespace WorldBuilder
+{
+  /**
+   * This is a simple structure to store information about grains.
+   * The advantage of storing all grains in separate vectors, compared
+   * to having a vector of individual grains, is that the vectors can
+   * be empty if the information is not needed.
+   */
+  struct grains
+  {
+    grains();
+
+    grains(const std::vector<double> &vector,
+           const size_t number_of_grains,
+           const size_t start_entry = 0);
+
+    void unroll_into(std::vector<double> &vector,
+                     const size_t start_entry = 0) const;
+
+    // The sizes of the grains
+    std::vector<double> sizes;
+
+    // the rotation matrices of the latices of the grains.
+    // todo: convention.
+    std::vector<std::array<std::array<double,3>,3> > rotation_matrices;
+
+    friend std::ostream &operator<<(std::ostream &os, const grains &grains)
+    {
+      for (unsigned int i = 0; i < grains.sizes.size(); ++i)
+        {
+          os << i << ": s=" << grains.sizes[i] << ", R="
+             << grains.rotation_matrices[i][0][0] << " " << grains.rotation_matrices[i][0][1] << " " << grains.rotation_matrices[i][0][2] << " "
+             << grains.rotation_matrices[i][1][0] << " " << grains.rotation_matrices[i][1][1] << " " << grains.rotation_matrices[i][1][2] << " "
+             << grains.rotation_matrices[i][2][0] << " " << grains.rotation_matrices[i][2][1] << " " << grains.rotation_matrices[i][2][2] << " ";
+        }
+      return os;
+    }
+  };
+
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/gravity_model/interface.h.bak b/contrib/world_builder/include/world_builder/gravity_model/interface.h.bak
new file mode 100644
index 00000000000..79c20b01a24
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/gravity_model/interface.h.bak
@@ -0,0 +1,149 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_GRAVITY_MODELS_INTERFACE_H
+#define WORLD_BUILDER_GRAVITY_MODELS_INTERFACE_H
+
+#include "world_builder/gravity_model/interface.h"
+
+#include "world_builder/parameters.h"
+#include "world_builder/types/string.h"
+
+
+namespace WorldBuilder
+{
+  class World;
+
+  namespace GravityModel
+  {
+
+    class ObjectFactory;
+
+    /**
+     * This class is an interface for the specific coordinate systems.
+     */
+    class Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        Interface();
+
+        /**
+         * Destructor
+         */
+        virtual
+        ~Interface();
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm,
+                             const std::string &parent_name,
+                             const std::vector<std::string> &required_entries);
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        virtual
+        void parse_entries(Parameters &prm) = 0;
+
+        /**
+         * Returns the gravity vector in a Cartesian coordinate system at a given position.
+         */
+        virtual
+        Point<3> gravity_vector(Point<3> point) const = 0;
+
+        /**
+         * Returns the norm of the gravity at a given position.
+         */
+        virtual
+        double gravity_norm(Point<3> point) const = 0;
+
+        /**
+         * A function to register a new type. This is part of the automatic
+         * registration of the object factory.
+         */
+        static void registerType(const std::string &name,
+                                 void ( * /*declare_entries*/)(Parameters &, const std::string &),
+                                 ObjectFactory *factory);
+
+        /**
+         * A function to create a new type. This is part of the automatic
+         * registration of the object factory.
+         */
+        static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
+
+      protected:
+        /**
+         * A pointer to the world class to retrieve variables.
+         */
+        WorldBuilder::World *world;
+
+
+
+      private:
+        static std::map<std::string, ObjectFactory *> &get_factory_map()
+        {
+          static std::map<std::string, ObjectFactory *> factories;
+          return factories;
+        }
+
+        static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
+        {
+          static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
+          return declares;
+        }
+    };
+
+
+
+    /**
+     * A class to create new objects
+     */
+    class ObjectFactory
+    {
+      public:
+        virtual std::unique_ptr<Interface> create(World *world) = 0;
+    };
+
+    /**
+     * A macro which should be in every derived cpp file to automatically
+     * register it. Because this is a library, we need some extra measures
+     * to ensure that the static variable is actually initialized.
+     */
+#define WB_REGISTER_GRAVITY_MODEL(klass,name) \
+  class klass##Factory : public ObjectFactory { \
+    public: \
+      klass##Factory() \
+      { \
+        Interface::registerType(#name, klass::declare_entries, this); \
+      } \
+      std::unique_ptr<Interface> create(World *world) override final { \
+        return std::unique_ptr<Interface>(new klass(world)); \
+      } \
+  }; \
+  static klass##Factory global_##klass##Factory;
+
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/gravity_model/uniform.h.bak b/contrib/world_builder/include/world_builder/gravity_model/uniform.h.bak
new file mode 100644
index 00000000000..b3f5c29cc68
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/gravity_model/uniform.h.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_UNIFORM_H
+#define WORLD_BUILDER_COORDINATE_SYSTEMS_UNIFORM_H
+
+#include "world_builder/gravity_model/interface.h"
+
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace GravityModel
+  {
+    /**
+     * Register header file
+     */
+    //WB_REGISTER_COORDINATE_SYSTEM_HEADER(Uniform)
+
+
+    /**
+     * This implements a Uniform geometry model.The Uniform geometry model
+     * doesn't do anything with the coordinates, but is needed to have a common
+     * interface for all the geometry models.
+     */
+    class Uniform final : public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        Uniform(WorldBuilder::World *world);
+
+        /**
+         * Destructor
+         */
+        ~Uniform() override final;
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        static
+        void declare_entries(Parameters &prm, const std::string &parent_name = "");
+
+        /**
+         * declare and read in the world builder file into the parameters class
+         */
+        void parse_entries(Parameters &prm) override final;
+
+
+
+        /**
+         * Returns the gravity vector in a Cartesian coordinate system at a given position,
+         * which has a constant magitude for the whole domain. The vector points down in
+         * cartesian coordinates and to the center of the sphere in spherical coordinates.
+         */
+        virtual
+        Point<3> gravity_vector(Point<3> point) const override final;
+
+        /**
+         * Returns the norm of the gravity at a given position, which is a constant
+         * number for the whole domain.
+         */
+        virtual
+        double gravity_norm(Point<3> point) const override final;
+
+      private:
+
+        /**
+         * The uniform gravity.
+         */
+        double gravity_magnitude;
+
+    };
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/kd_tree.h.bak b/contrib/world_builder/include/world_builder/kd_tree.h.bak
new file mode 100644
index 00000000000..1dcef34f0f0
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/kd_tree.h.bak
@@ -0,0 +1,161 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef KD_TREE_H
+#define KD_TREE_H
+
+#include <vector>
+#include <cstddef>
+#include <iostream>
+#include <limits>
+
+#include "world_builder/assert.h"
+#include "world_builder/point.h"
+
+namespace WorldBuilder
+{
+  namespace KDTree
+  {
+    /**
+     * A struct to store an index for a point and the
+     * distance to that point.
+     */
+    struct IndexDistance
+    {
+      size_t index;
+      double distance;
+    };
+
+
+    /**
+     * A struct to store an index for a point and the
+     * distance to that point.
+     */
+    struct IndexDistances
+    {
+      size_t min_index;
+      double min_distance;
+      std::vector<IndexDistance> vector;
+    };
+
+    /**
+     * Each item contains an index and an x and y coordinate
+     */
+    struct Node
+    {
+      size_t index;
+      double x;
+      double y;
+
+      Node(size_t index_, double x_, double y_)
+        :
+        index(index_),
+        x(x_),
+        y(y_)
+      {}
+
+
+      /**
+       * access index (const)
+       */
+      inline
+      const double &operator[](const bool y_axis) const
+      {
+        WBAssert(std::fabs((y_axis ? y : x) - *(&x+y_axis)) < std::numeric_limits<double>::epsilon(),
+                 "Internal error: y_axis=" << y_axis << ", x=" << x << ", y=" << y <<", *(&x+y_axis)=" << *(&x+y_axis)
+                 << ", ((bool)y_axis ? x : y) - *(&x+y_axis)=" << fabs((y_axis ? x : y) - *(&x+y_axis)));
+        return *(&x+y_axis);
+      }
+    };
+
+    class KDTree
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        KDTree() = default;
+        /**
+         * Constructor. Requires a list of Nodes.
+         */
+        KDTree(const std::vector<Node> point_list);
+
+        /**
+         * Create a tree based on the current information in the
+         * node vector.
+         */
+        void create_tree(const size_t left,
+                         const size_t right,
+                         const bool x_axis);
+
+        /**
+         * Return a reference to the vector containing the nodes.
+         */
+        const std::vector<Node> &get_nodes() const;
+
+        /**
+         * Returns the index of the closest point and the distance
+         * of that point to the check point.
+         */
+        IndexDistance find_closest_point(const Point<2> &check_point) const;
+
+
+
+        /**
+         * Returns the index of the closest point and the distance
+         * of that point to the check point. Stores the points searched
+         * through in a unsorted vector.
+         * Note: I can only guarantee that the point with the least distance
+         * is the closest point. The point in the list with the second/third/etc.
+         * smallest distance may or may not actually be the global point
+         * with the second/third/etc. smallest distance. It will most likely be a
+         * very good guess though.
+         */
+        IndexDistances find_closest_points(const Point<2> &check_point) const;
+
+
+      private:
+        /**
+         * Returns the index of the closest point and the distance
+         * of that point to the check point. This function is used
+         * by find_closest_point to find the correct point.
+         */
+        void find_closest_point_recursive(const Point<2> &check_point,
+                                          const size_t left,
+                                          const size_t right,
+                                          const bool y_axis,
+                                          IndexDistance &index_distance) const;
+
+
+        /**
+         * Returns the index of the closest point and the distance
+         * of that point to the check point. This function is used
+         * by find_closest_point to find the correct point.
+         */
+        void find_closest_points_recursive(const Point<2> &check_point,
+                                           const size_t left,
+                                           const size_t right,
+                                           const bool y_axis,
+                                           IndexDistances &index_distances) const;
+
+        std::vector<Node> nodes;
+    };
+  }
+}
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/nan.h.bak b/contrib/world_builder/include/world_builder/nan.h.bak
new file mode 100644
index 00000000000..96916c783e5
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/nan.h.bak
@@ -0,0 +1,50 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_NAN_H
+#define WORLD_BUILDER_NAN_H
+
+#include <limits>
+
+namespace WorldBuilder
+{
+  namespace NaN
+  {
+    /**
+     * A double signaling NaN
+     */
+    const double DQNAN = std::numeric_limits<double>::quiet_NaN();
+
+    /**
+     * A unsigned int signaling NaN
+     */
+    const unsigned int IQNAN = std::numeric_limits<unsigned int>::quiet_NaN();
+    /**
+     * A double signaling NaN
+     */
+    const double DSNAN = std::numeric_limits<double>::signaling_NaN();
+
+    /**
+     * A unsigned int signaling NaN
+     */
+    const unsigned int ISNAN = std::numeric_limits<unsigned int>::signaling_NaN();
+  } // namespace NaN
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/objects/bezier_curve.h.bak b/contrib/world_builder/include/world_builder/objects/bezier_curve.h.bak
new file mode 100644
index 00000000000..cc0868da52a
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/objects/bezier_curve.h.bak
@@ -0,0 +1,89 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_OBJECTS_BEZIER_CURVE_H
+#define WORLD_BUILDER_OBJECTS_BEZIER_CURVE_H
+
+#include "world_builder/objects/closest_point_on_curve.h"
+#include "world_builder/point.h"
+#include <array>
+#include <vector>
+
+namespace WorldBuilder
+{
+  namespace Objects
+  {
+
+    /**
+     * @brief Class for circle line/spline, including interpolation on it
+     *
+     */
+    class BezierCurve
+    {
+      public:
+        /**
+         * @brief Construct a new Bezier Curve object
+         *
+         * @param p
+         * @param angle_constrains
+         */
+        BezierCurve() = default;
+
+        /**
+         * @brief Construct a new Bezier Curve object
+         *
+         * @param p
+         * @param angle_constrains
+         */
+        BezierCurve(const std::vector<Point<2> > &p, const std::vector<double> &angle_constrains = {});
+
+        /**
+         * @brief Finds the closest point on the curve. If the the closest point
+         *        doesn't fall on the segment, return a point with x and y being nan.
+         *
+         * @param p
+         * @param verbose Whether this function should be outputting its Newton iteration
+         * to std::cout while running. This is very expensive, but useful for debugging
+         * purposes.
+         * @return ClosestPointOnCurve
+         */
+        ClosestPointOnCurve closest_point_on_curve_segment(const Point<2> &p, const bool verbose = false) const;
+
+        /**
+         * @brief
+         *
+         * @param i
+         * @param x
+         * @return Point<2>
+         */
+        Point<2> operator()(const size_t i, const double x) const;
+
+      private:
+        std::vector<Point<2> > points;
+        std::vector<std::array<Point<2>,2 > > control_points;
+        std::vector<double> lengths;
+        std::vector<double> angles;
+
+    };
+  }
+
+}
+
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/objects/closest_point_on_curve.h.bak b/contrib/world_builder/include/world_builder/objects/closest_point_on_curve.h.bak
new file mode 100644
index 00000000000..19377d61e39
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/objects/closest_point_on_curve.h.bak
@@ -0,0 +1,56 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_OBJECTS_CLOSEST_POINT_ON_CURVE_H
+#define WORLD_BUILDER_OBJECTS_CLOSEST_POINT_ON_CURVE_H
+
+
+#include "world_builder/point.h"
+#include "world_builder/nan.h"
+
+//using namespace WorldBuilder;
+
+namespace WorldBuilder
+{
+  namespace Objects
+  {
+
+
+    struct ClosestPointOnCurve
+    {
+      ClosestPointOnCurve()
+        :
+        distance(std::numeric_limits<double>::infinity()),
+        parametric_fraction(NaN::DSNAN),
+        interpolation_fraction(NaN::DSNAN),
+        index(0),
+        point(Point<2>(NaN::DQNAN,NaN::DQNAN,CoordinateSystem::invalid)),
+        normal(Point<2>(NaN::DSNAN,NaN::DSNAN,CoordinateSystem::invalid))
+      {}
+
+      double distance;
+      double parametric_fraction;
+      double interpolation_fraction;
+      size_t index;
+      Point<2> point;
+      Point<2> normal;
+    };
+  }
+}
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/objects/distance_from_surface.h.bak b/contrib/world_builder/include/world_builder/objects/distance_from_surface.h.bak
new file mode 100644
index 00000000000..d0b45d1dfc0
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/objects/distance_from_surface.h.bak
@@ -0,0 +1,64 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_OBJECTS_DISTANCE_FROM_SURFACE_H
+#define WORLD_BUILDER_OBJECTS_DISTANCE_FROM_SURFACE_H
+
+namespace WorldBuilder
+{
+  namespace Objects
+  {
+    class PlaneDistances
+    {
+      public:
+
+        /**
+         * Constructor to create an PlaneDistances object from the distance
+         * from and along the surface of plane
+         */
+        PlaneDistances(const double distance_from_surface_, const double distance_along_surface_)
+          :
+          distance_from_surface(distance_from_surface_),
+          distance_along_surface(distance_along_surface_)
+        {}
+
+        /**
+         * Function to get the distance from the surface
+        */
+        double get_distance_from_surface() const;
+
+        /**
+         * Function to get the distance along the surface
+        */
+        double get_distance_along_surface() const;
+
+      private:
+        /**
+        * the distance from the surface of the plane
+        */
+        double distance_from_surface;
+        /**
+        * the distance along the surface of the plane
+        */
+        double distance_along_surface;
+    };
+  }
+}
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/objects/natural_coordinate.h.bak b/contrib/world_builder/include/world_builder/objects/natural_coordinate.h.bak
new file mode 100644
index 00000000000..27f82163823
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/objects/natural_coordinate.h.bak
@@ -0,0 +1,125 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_OBJECTS_NATURAL_COORDINATE_H
+#define WORLD_BUILDER_OBJECTS_NATURAL_COORDINATE_H
+
+#include <array>
+#include "world_builder/point.h"
+#include "world_builder/coordinate_systems/interface.h"
+
+namespace WorldBuilder
+{
+  namespace Objects
+  {
+    /*
+    * A class that represents a point in a chosen coordinate system.
+    */
+    class NaturalCoordinate
+    {
+      public:
+        /**
+         * Constructor based on providing the geometry model as a pointer
+         */
+        NaturalCoordinate(const std::array<double,3> &position,
+                          const ::WorldBuilder::CoordinateSystems::Interface &coordinate_system);
+
+        /**
+         * Constructor based on providing the geometry model as a pointer
+         */
+        NaturalCoordinate(const Point<3> &position,
+                          const ::WorldBuilder::CoordinateSystems::Interface &coordinate_system);
+
+        /**
+         * Returns the coordinates in the given coordinate system, which may
+         * not be Cartesian.
+         */
+        const std::array<double,3> &get_coordinates() const;
+
+        /**
+         * The coordinate that represents the 'surface' directions in the
+         * chosen coordinate system.
+         */
+        std::array<double,2> get_surface_coordinates() const;
+
+        /**
+         * The coordinate that represents the 'surface' directions in the
+         * chosen coordinate system.
+         */
+        Point<2> get_surface_point() const;
+
+        /**
+         * The coordinate that represents the 'depth' direction in the chosen
+         * coordinate system.
+         */
+        double get_depth_coordinate() const;
+
+        /**
+         * Return a reference to the coordinate that represents the 'depth' direction
+         * in the chosen coordinate system.
+         */
+        double &get_ref_depth_coordinate();
+
+        /**
+         * get the coordinate system type of this coordinate.
+         */
+        CoordinateSystem get_coordinate_system() const;
+
+      private:
+        /**
+         * An enum which stores the coordinate system of this natural
+         * point
+         */
+        CoordinateSystem coordinate_system;
+
+        /**
+         * An array which stores the coordinates in the coordinates system
+         */
+        std::array<double,3> coordinates;
+    };
+
+
+    inline
+    double
+    NaturalCoordinate::get_depth_coordinate() const
+    {
+      switch (coordinate_system)
+        {
+          case CoordinateSystem::cartesian:
+          {
+            return coordinates[2];
+            break;
+          }
+
+          case CoordinateSystem::spherical:
+          {
+            return coordinates[0];
+            break;
+          }
+
+          default:
+            WBAssertThrow (false, "Coordinate system not implemented.");
+        }
+
+      return 0;
+    }
+  }
+}
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/objects/segment.h.bak b/contrib/world_builder/include/world_builder/objects/segment.h.bak
new file mode 100644
index 00000000000..5b2b7319d91
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/objects/segment.h.bak
@@ -0,0 +1,79 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_OBJECTS_SEGMENT_H
+#define WORLD_BUILDER_OBJECTS_SEGMENT_H
+
+
+#include "world_builder/types/plugin_system.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Objects
+  {
+
+    /**
+      * This class represents an actual segment
+      */
+    template <class A, class B, class C>
+    class Segment
+    {
+      public:
+
+        /**
+         * A constructor for the clone and set_entry function
+         */
+        Segment(const double default_length,
+                const WorldBuilder::Point<2> &default_thickness,
+                const WorldBuilder::Point<2> &default_top_truncation,
+                const WorldBuilder::Point<2> &default_angle,
+                std::vector<std::shared_ptr<A> > temperature_systems,
+                std::vector<std::shared_ptr<B> > composition_systems,
+                std::vector<std::shared_ptr<C> > grains_systems);
+
+        /**
+         * Copy constructor
+         */
+        Segment(Segment const &other);
+
+        /**
+         * Destructor
+         */
+        ~Segment();
+
+        double value_length;
+        double default_length;
+        WorldBuilder::Point<2> value_thickness;
+        WorldBuilder::Point<2> value_top_truncation;
+        WorldBuilder::Point<2> value_angle;
+        std::vector<std::shared_ptr<A> > temperature_systems;
+        std::vector<std::shared_ptr<B> > composition_systems;
+        std::vector<std::shared_ptr<C> > grains_systems;
+
+      protected:
+      private:
+
+    };
+  } // namespace Objects
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/objects/surface.h.bak b/contrib/world_builder/include/world_builder/objects/surface.h.bak
new file mode 100644
index 00000000000..f55a862e040
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/objects/surface.h.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_OBJECTS_SURFACE_H
+#define WORLD_BUILDER_OBJECTS_SURFACE_H
+
+#include "world_builder/utilities.h"
+#include "world_builder/kd_tree.h"
+
+namespace WorldBuilder
+{
+  namespace Objects
+  {
+    struct SurfaceValueInfo
+    {
+      size_t triangle_index;
+      double interpolated_value;
+      double interpolator_s;
+      double interpolator_t;
+
+      SurfaceValueInfo(
+        size_t triangle_index_,
+        double interpolated_value_,
+        double interpolator_s_,
+        double interpolator_t_)
+        :
+        triangle_index(triangle_index_),
+        interpolated_value(interpolated_value_),
+        interpolator_s(interpolator_s_),
+        interpolator_t(interpolator_t_) {};
+
+      SurfaceValueInfo(double interpolated_value_)
+        :
+        triangle_index(NaN::IQNAN),
+        interpolated_value(interpolated_value_),
+        interpolator_s(NaN::DQNAN),
+        interpolator_t(NaN::DQNAN) {};
+    };
+
+    class Surface
+    {
+      public:
+        /**
+         * Constructor to create an empty surface.
+         */
+        Surface();
+
+        /**
+         * Constructor to create a surface from value at points object output.
+         */
+        Surface(std::pair<std::vector<double>,std::vector<double>> values_at_points);
+
+        /**
+         * Returns the value of the surface at the check point.
+         */
+        SurfaceValueInfo local_value(const Point<2> &check_point) const;
+
+        /**
+         * Whether the surface is a constant value or not. This is used for optimalization.
+         */
+        bool constant_value;
+
+        /**
+         * The minimum value of all provided points.
+         */
+        double minimum;
+
+        /**
+         * The maximum value of all provided points.
+         */
+        double maximum;
+
+        /**
+         * The KD tree which stores the centroids of all triangles and an index to the triangle points
+         * and values stored in the triangles member variable.
+         */
+        KDTree::KDTree tree;
+
+        /**
+         * Stores the triangles as a list of three points.
+         */
+        std::vector<std::array<std::array<double,3>,3> > triangles;
+
+        /**
+         * @brief Stores precomputed values
+         */
+        std::vector<std::array<double,8> > in_triangle_precomputed;
+
+      private:
+
+    };
+  }
+
+}
+
+#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/parameters.h.bak b/contrib/world_builder/include/world_builder/parameters.h.bak
new file mode 100644
index 00000000000..8323d981830
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/parameters.h.bak
@@ -0,0 +1,332 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_PARAMETERS_H
+#define WORLD_BUILDER_PARAMETERS_H
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "rapidjson/schema.h"
+#include "world_builder/point.h"
+#include "world_builder/types/unsigned_int.h"
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+    class Interface;
+    template<unsigned int dim>
+    class Point;
+    class Double;
+    class String;
+    class Segment;
+    class Array;
+    class Bool;
+    class UnsignedInt;
+    class Int;
+  } // namespace Types
+
+  namespace Features
+  {
+    class Interface;
+  } // namespace Features
+
+  namespace CoordinateSystems
+  {
+    class Interface;
+  } // namespace CoordinateSystems
+
+  namespace GravityModel
+  {
+    class Interface;
+  } // namespace GravityModel
+
+  class World;
+
+  /**
+   * A class to hold all the parameters needed by the world builder. Internally
+   * it holds all values in the form of vectors of class Types. Values can be
+   * entered in two ways into this class. The first way is through the
+   * load_entry function which load the value from the provided world builder
+   * file. The second way is through the set_entry function, through which
+   * values can be directly entered into the parameter class. Values can be
+   * retrieved through the get functions which take the name of the value
+   * with which it was set. It is also required for bot loading, setting and
+   * getting values to do it in the correct subsection. Subsections can be
+   * entered with the enter_subsection function and left with the
+   * leave_subsection function. The current path can be retrieved through the
+   * function get_current_path() and get_current_path_without_arrays().
+   */
+  class Parameters
+  {
+    public:
+      /**
+       * Constructor
+       * \param world A reference to the World class
+       */
+      Parameters(World &world);
+
+      /**
+       * Destructor
+       */
+      ~Parameters();
+
+      /**
+       * Initializes the parameter file
+       * \param filename A string with the path to the world builder file
+       * \param has_output_dir A bool indicating whether the world builder may write out information.
+       * \param output_dir A string with the path to the directory where it can output information if allowed by has_output_dir
+       */
+      void initialize(std::string &filename, bool has_output_dir = false, const std::string &output_dir = "");
+
+      /**
+       * A generic get function to retrieve setting from the parameter file.
+       * Note that this is dependent on the current path/subsection which you are in.
+       * \param name The name of the entry to retrieved
+       * @see path
+       * @see enter_subsection()
+       * @see leave_subsection()
+       */
+      template<class T>
+      T get(const std::string &name);
+
+      /**
+       * A specialized version of get which can return vectors/arrays.
+       * \param name The name of the entry to retrieved
+       */
+      template<class T>
+      std::vector<T> get_vector(const std::string &name);
+
+      std::vector<std::vector<double>> get_vector_or_double(const std::string &name);
+
+      /**
+       * A specialized version of get which can return a value at points type.
+       * \param name The name of the entry to retrieved
+       * \param name additional points to be added to the list at either the default value or at the value of a single value array in the list
+       */
+      std::pair<std::vector<double>,std::vector<double>>
+                                                      get(const std::string &name,
+                                                          const std::vector<Point<2> > &addition_points = {});
+
+      /**
+       * A specialized version of get which can return a values at times type.
+       * \param name The name of the entry to retrieved
+       */
+      std::pair<std::vector<double>,std::vector<double>> get_value_at_array(const std::string &name);
+
+      /**
+       * A specialized version of get which can return vectors/arrays.
+       * This version is designed for the plugin system.
+       * \param name The name of the entry to retrieved
+       */
+      template<class T, class A, class B, class C>
+      std::vector<T> get_vector(const std::string &name, std::vector<std::shared_ptr<A> > &, std::vector<std::shared_ptr<B> > &, std::vector<std::shared_ptr<C> > &);
+
+      /**
+       * A specialized version of get which can return unique pointers.
+       * \param name The name of the entry to retrieved
+       */
+      template<class T>
+      std::unique_ptr<T> get_unique_pointer(const std::string &name);
+
+      /**
+       * A specialized version of get which can return unique pointers as an argument
+       * and returns a bool to indicate whether it was successful or not.
+       * Note that this function will erase all information in the vector.
+       * \param name The name of the entry to retrieved
+       * \param vector A vector of unique pointers.
+       */
+      template<class T>
+      bool
+      get_unique_pointers(const std::string &name, std::vector<std::unique_ptr<T> > &vector);
+
+      /**
+       * A specialized version of get which can return shared pointers as an argument
+       * and returns a bool to indicate whether it was successful or not.
+       * Note that this function will erase all information in the vector.
+       * \param name The name of the entry to retrieved
+       * \param vector A vector of shared pointers.
+       */
+      template<class T>
+      bool
+      get_shared_pointers(const std::string &name, std::vector<std::shared_ptr<T> > & /*vector*/);
+
+      /**
+       * Checks for the existence of an entry in the parameter file.
+       * Return true when an entry is specified and false when it is not.
+       * This is independent of whether an entry has been declared or not.
+       * The main intended usage is to check whether the user has provided
+       * the specified entry in the user supplied parameters file, since
+       * the get functions may use default values.
+       * \param name The name of the entry to be checked.
+       */
+      bool
+      check_entry(const std::string &name) const;
+
+      /**
+       * Declares the existence an entry in the parameters class.
+       * Default values are supplied by the type.
+       * \param name The name of the entry to be declared
+       * \param type The type of entry (e.g. Double, Array, etc.)
+       * \param documentation A string containing information about this parameter.
+       */
+      void declare_entry(const std::string &name,
+                         const Types::Interface &type,
+                         const std::string &documentation);
+
+
+      /**
+       * This function is used to enter a subsection. It appends to the path
+       * variable. This action is revesed by the leave subsection function.
+       * \param name The name of the subsection to be entered.
+       * @see path
+       * @see leave_subsection()
+       */
+      void enter_subsection(const std::string &name);
+
+      /**
+       * This function is used to leave a subsection by removing the last
+       * element of the path variable. It reverses the action of the enter
+       * subsection function.
+       * @see path
+       * @see enter_subsection()
+       */
+      void leave_subsection();
+
+      /**
+       * A utilities function for declaring plugin model entries. This always contains a model declaration entry with the plugin name.
+       * @param model_group_name The name of the model group which is declared.
+       * @param parent_name The name of the parent declaration group.
+       * @param declaration_map A map containing plugin names and plugin declaration functions
+       * @param required_entries A vector containing what entries should be required from the user. Default value is empty.
+       * @param extra_declarations A vector containing extra declarations common to all plugins in this group. Default value is empty.
+       */
+      void
+      declare_model_entries(const std::string &model_group_name,
+                            const std::string &parent_name,
+                            const std::map<std::string, void ( *)(Parameters &,const std::string &)> &declare_map,
+                            const std::vector<std::string> &required_entries = {},
+                            const std::vector<std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string> > &extra_declarations = {});
+
+
+      /**
+       * A reference to the World class. This is needed to create the features.
+       */
+      World &world;
+
+      /**
+       * This variable stores what path separator is used in the property tree
+       * and in this class.
+       */
+      const std::string path_separator = ".";
+
+      /**
+       * This variable stores the path in a vector of strings.
+       * @see enter_subsection()
+       * @see leave_subsection()
+       */
+      std::vector<std::string> path;
+
+      rapidjson::Document declarations;
+      rapidjson::Document parameters;
+
+
+
+
+      /**
+       * A vector containing all the pointers to the features. This vector is
+       * responsible for the features and has ownership over them. Therefore
+       * unique pointers are used.
+       * @see Features
+       */
+      std::vector<std::unique_ptr<WorldBuilder::Features::Interface> > features;
+
+      /**
+       * A pointers to the corodinate system. This variable is responsible for
+       * the coordinate system and has ownership over it. Therefore a unique
+       * pointer are used.
+       * @see CoordinateSystem
+       */
+      std::unique_ptr<WorldBuilder::CoordinateSystems::Interface> coordinate_system;
+
+      /**
+       * A pointers to the gravity model. This variable is responsible for
+       * the gravity model and has ownership over it. Therefore a unique
+       * pointer are used.
+       * @see CoordinateSystem
+       */
+      std::unique_ptr<WorldBuilder::GravityModel::Interface> gravity_model;
+
+      /**
+       * This function return the current path as stored in the path variable
+       * as a string in json pointer format.
+       * \return std::string
+       */
+      std::string get_full_json_path(size_t max_size = std::numeric_limits<size_t>::max()) const;
+
+      /**
+       * todo: Warning: do not use before declarations is filled.
+       * This function return the current path as stored in the path variable
+       * as a string in json pointer format.
+       * \return std::string
+       */
+      std::string get_full_json_schema_path() const;
+
+      /**
+       * This function return the current path as stored in the path variable
+       * as a string.
+       * \return std::string
+       */
+      //std::string get_full_path() const;
+
+      /**
+       * This function return the current path as stored in the path variable
+       * as a string, but the arrays are striped. This is useful for working
+       * with the boost property tree.
+       * \return std::string
+       */
+      //std::string get_full_path_without_arrays() const;
+
+    private:
+
+
+      /**
+       * This is used for the get relative path functions. It stores how many
+       * top entries of the path should be ignored.
+       */
+      size_t path_level;
+
+      /**
+       * A function which returns the relative path, which is the full path
+       * minus the path_level top entries..
+       * @see get_current_path()
+       */
+      std::string get_relative_path() const;
+
+      /**
+       * A function which returns the relative path, which is the full path
+       * minus the path_level top entries., without names for the arrays.
+       * @see get_current_path_without_arrays()
+       */
+      std::string get_relative_path_without_arrays() const;
+  };
+} // namespace WorldBuilder
+#endif
diff --git a/contrib/world_builder/include/world_builder/point.h.bak b/contrib/world_builder/include/world_builder/point.h.bak
new file mode 100644
index 00000000000..c3b0bca2d85
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/point.h.bak
@@ -0,0 +1,473 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_POINT_H
+#define WORLD_BUILDER_POINT_H
+#include "nan.h"
+#define _USE_MATH_DEFINES
+#include <array>
+#include <cmath>
+#include <limits>
+#include <iostream>
+
+#include "world_builder/assert.h"
+#include "world_builder/consts.h"
+#include "world_builder/coordinate_system.h"
+
+namespace WorldBuilder
+{
+
+  /**
+   * This namespace contains some faster but less accurate version of the
+   * trigonomic functions and a faster version of the fmod function.
+   */
+  namespace FT
+  {
+    /**
+     * Fast version of the fmod function.
+     */
+    inline double fmod(const double x, const double y)
+    {
+      if (y < 0.0 || y > 0.0)
+        {
+          const double x_div_y = x/y;
+          return (x_div_y-static_cast<int>(x_div_y))*y;
+        }
+      return NaN::DQNAN;
+    }
+
+    /**
+     * Fast sin function, accurate for values between 0 and pi. The implementation is
+     * based on discussion at https://stackoverflow.com/a/6104692.
+     *
+     * The accuracy seem good enough for most purposes. The unit test tests in steps
+     * of 0.01 from -4 pi to 4 pi and compares against the std sin function and the difference
+     * is always smaller than 1.2e-5. If the test is run with intervals of 0.001 then there
+     * are 12 entries which are (very slightly) above that (<3e-8) at angles of about
+     * -174, -6, 6  and 174.
+     *
+     */
+    inline double fast_sin_d(const double angle)
+    {
+      constexpr double A = 4.0/(Consts::PI * Consts::PI);
+      constexpr double oneminPmin = 1.-0.1952403377008734-0.01915214119105392;
+
+      const double y = A* angle * ( Consts::PI - angle );
+      return y*( oneminPmin + y*( 0.1952403377008734 + y * 0.01915214119105392 ) ) ;
+    }
+
+    /**
+     * Fast but less accurate sin function for any angle.
+     * Implemented by calling fast_sin_d with a mirrored x if needed to
+     * forfill the constrained of fast_sin_d to only have values between
+     * zero and pi.
+     */
+    inline double sin(const double raw_angle)
+    {
+      const double angle = (raw_angle > -Consts::PI && raw_angle < Consts::PI)
+                           ?
+                           raw_angle
+                           :
+                           FT::fmod(raw_angle + std::copysign(Consts::PI,raw_angle), Consts::PI * 2.0) - std::copysign(Consts::PI,raw_angle);
+
+      if (angle >= 0)
+        return fast_sin_d(angle);
+      return -fast_sin_d(-angle);
+    }
+
+    /**
+     * Fast but less accurate cos function for any angle.
+     */
+    inline double cos(const double angle)
+    {
+      return FT::sin((Consts::PI*0.5)-angle);
+    }
+  } // namespace FT
+
+
+  /**
+   * A class which stores 2d and 3d arrays of doubles (depending on the dimension),
+   * and the coordinate system which the coordinates can be used for. It also
+   * implements several operations such as the computation of the l2 norm and the
+   * dot product.
+   */
+  template<unsigned int dim>
+  class Point
+  {
+    public:
+      /**
+       * Constructor. Constructs a Point at (0,0) in 2d or (0,0,0) in 3d
+       * with a Cartesian coordinate system.
+       */
+      inline
+      Point(CoordinateSystem coordinate_system_)
+        :
+        point(std::array<double,dim>()),
+        coordinate_system(coordinate_system_)
+      {}
+
+      /**
+       * Constructor. Constructs a Point from a std::array<double,dim> and
+       * a coordinate system.
+       */
+      inline
+      Point(const std::array<double,dim> &location, CoordinateSystem coordinate_system_)
+        :
+        point(location),
+        coordinate_system(coordinate_system_)
+      {}
+
+      /**
+       * Constructor. Constructs a Point from an other Point and
+       * a coordinate system.
+       */
+      inline
+      Point(const Point<dim> &location, CoordinateSystem coordinate_system_)
+        :
+        point(location.get_array()),
+        coordinate_system(coordinate_system_)
+      {}
+
+      /**
+       * Constructor. Constructs a Point from an other Point.
+       */
+      inline
+      Point(const Point<dim> &location)
+        :
+        point(location.get_array()),
+        coordinate_system(location.get_coordinate_system())
+      {}
+
+      /**
+       * Constructor. Constructs a 2d Point from two doubles and
+       * a coordinate system.
+       */
+      Point(const double x, const double y, CoordinateSystem coordinate_system);
+
+      /**
+       * Constructor. Constructs a 3d Point from three doubles and
+       * a coordinate system.
+       */
+      Point(const double x, const double y, const double z, CoordinateSystem coordinate_system);
+
+      /**
+       * Destructor
+       */
+      inline
+      ~Point() = default;
+
+      inline
+      Point<dim> &operator=(const Point<dim> &point_right)
+      {
+        point = point_right.point;
+        coordinate_system = point_right.coordinate_system;
+        return *this;
+      }
+
+      /**
+       * dot product
+       */
+      inline
+      double operator*(const Point<dim> &point_right) const
+      {
+        WBAssert(coordinate_system == point_right.get_coordinate_system(),
+                 "Cannot take the dot product of two points which represent different coordinate systems.");
+        const std::array<double,dim> &array = point_right.get_array();
+        double dot_product = 0;
+        for (unsigned int i = 0; i < dim; ++i)
+          dot_product += point[i] * array[i];
+        return dot_product;
+      }
+
+
+      /**
+       * Multiply the vector with a scalar
+       */
+      inline
+      Point<dim> operator*(const double scalar) const
+      {
+        // initialize the array to zero.
+        std::array<double,dim> array;
+        for (unsigned int i = 0; i < dim; ++i)
+          array[i] = point[i] * scalar;
+        return Point<dim>(array,coordinate_system);
+      }
+
+      /**
+       * Divide the vector through a scalar
+       */
+      inline
+      Point<dim> operator/(const double scalar) const
+      {
+        // initialize the array to zero.
+        std::array<double,dim> array;
+        const double one_over_scalar = 1/scalar;
+        for (unsigned int i = 0; i < dim; ++i)
+          array[i] = point[i] * one_over_scalar;
+        return Point<dim>(array,coordinate_system);
+      }
+
+      /**
+       * add two points
+       */
+      inline
+      Point<dim> operator+(const Point<dim> &point_right) const
+      {
+        WBAssert(coordinate_system == point_right.get_coordinate_system(),
+                 "Cannot add two points which represent different coordinate systems.");
+        Point<dim> point_tmp(point,coordinate_system);
+        for (unsigned int i = 0; i < dim; ++i)
+          point_tmp[i] += point_right[i];
+
+        return point_tmp;
+      }
+
+
+      /**
+       * Subtract two points
+       */
+      inline
+      Point<dim> operator-(const Point<dim> &point_right) const
+      {
+        WBAssert(coordinate_system == point_right.get_coordinate_system(),
+                 "Cannot subtract two points which represent different coordinate systems. Internal has type " << static_cast<int>(coordinate_system)
+                 << ", other point has type " << static_cast<int>(point_right.get_coordinate_system()));
+        Point<dim> point_tmp(point,coordinate_system);
+        for (unsigned int i = 0; i < dim; ++i)
+          point_tmp[i] -= point_right[i];
+
+        return point_tmp;
+      }
+
+
+      /**
+       * Multiply the vector with a scalar
+       */
+      inline
+      Point<dim> &operator*=(const double scalar)
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          point[i] *= scalar;
+        return *this;
+      }
+      /**
+       * Divide the vector through a scalar
+       */
+      inline
+      Point<dim> &operator/=(const double scalar)
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          point[i] /= scalar;
+        return *this;
+      }
+
+      /**
+       * add two points
+       */
+      inline
+      Point<dim> &operator+=(const Point<dim> &point_right)
+      {
+        WBAssert(coordinate_system == point_right.get_coordinate_system(),
+                 "Cannot add two points which represent different coordinate systems.");
+        for (unsigned int i = 0; i < dim; ++i)
+          point[i] += point_right[i];
+        return *this;
+      }
+
+      /**
+       * Check if all values are the same.
+       *
+       * Note: compares floating points with an epsilon
+       */
+      inline
+      bool operator==(const Point<dim> &point_) const
+      {
+        if (coordinate_system != point_.coordinate_system)
+          return false;
+        WorldBuilder::Point<dim> point_tmp(point,coordinate_system);
+        point_tmp -= point_;
+        if (std::fabs(point_tmp[0]) > std::numeric_limits<double>::epsilon())
+          return false;
+        if (std::fabs(point_tmp[1]) > std::numeric_limits<double>::epsilon())
+          return false;
+        if (dim == 3 && std::fabs(point_tmp[2]) > std::numeric_limits<double>::epsilon())
+          return false;
+
+        return true;
+      }
+
+      /**
+       * subtract two points
+       */
+      inline
+      Point<dim> &operator-=(const Point<dim> &point_right)
+      {
+        WBAssert(coordinate_system == point_right.get_coordinate_system(),
+                 "Cannot subtract two points which represent different coordinate systems.");
+        for (unsigned int i = 0; i < dim; ++i)
+          point[i] -= point_right[i];
+        return *this;
+      }
+
+      /**
+       * access index (const)
+       */
+      inline
+      const double &operator[](const size_t index) const
+      {
+        WBAssert(index <= dim, "Can't ask for element " << index << " in an point with dimension " << dim << '.');
+        return point[index];
+      }
+
+
+      /**
+       * access index
+       */
+      inline double &operator[](const size_t index)
+      {
+        WBAssert(index <= dim, "Can't ask for element " << index << " in an point with dimension " << dim << '.');
+        return point[index];
+      }
+
+      /**
+       * Computes the distance between this and a given point.
+       * In spherical coordinates it returns the central angle in radians.
+       */
+      double
+      distance(const Point<2> &two) const;
+
+      /**
+       * Computes the cheapest relative distance between this and a given point in spherical coordinates.
+       * The return value itself is only guartenteed to have the property that a
+       * larger value is further away.
+       * In the current implementation that means for the cartasian case the squared
+       * value is returned and for the spherical value the result of the havearsine
+       * function without asin and sqrt is returned.
+       */
+      double
+      cheap_relative_distance_spherical(const Point<2> &two) const
+      {
+        const double d_longitude = two[0] - this->point[0];
+        const double d_latitude = two[1] - this->point[1];
+        const double sin_d_lat = FT::sin(d_latitude * 0.5);
+        const double sin_d_long = FT::sin(d_longitude * 0.5);
+        return (sin_d_lat * sin_d_lat) + (sin_d_long*sin_d_long) * FT::cos(this->point[1]) * FT::cos(two[1]);
+      }
+
+      /**
+       * Computes the cheapest relative distance between this and a given point in cartesian coordinates.
+       * The return value itself is only guartenteed to have the property that a
+       * larger value is further away.
+       * In the current implementation that means for the cartasian case the squared
+       * value is returned and for the spherical value the result of the havearsine
+       * function without asin and sqrt is returned.
+       */
+      double
+      cheap_relative_distance_cartesian(const Point<2> &two) const
+      {
+        const double x_distance_to_reference_point = point[0]-two[0];
+        const double y_distance_to_reference_point = point[1]-two[1];
+        return (x_distance_to_reference_point*x_distance_to_reference_point) + (y_distance_to_reference_point*y_distance_to_reference_point);
+      }
+
+      /**
+       * return the internal array which stores the point data.
+       */
+      inline
+      const std::array<double,dim> &get_array() const
+      {
+        return point;
+      }
+
+
+      /**
+       * returns the coordinate system associated with the data.
+       */
+      inline
+      CoordinateSystem get_coordinate_system() const
+      {
+        return coordinate_system;
+      }
+
+
+      /**
+      * Computes the L2 norm: sqrt(x_i * x_i + y_i * y_i + z_i * z_i) in 3d.
+      */
+      inline
+      double norm() const
+      {
+        return std::sqrt(this->norm_square());
+      }
+
+
+      /**
+      * Computes the square of the norm, which is the sum of the absolute squares
+      * x_i * x_i + y_i * y_i + z_i * z_i in 3d.
+      */
+      inline
+      double norm_square() const
+      {
+        WBAssertThrow(false,"This function is only available in 2d or 3d.");
+        return 0;
+      }
+
+      /**
+       * Outputs the values of the point to std cout separated by spaces. This does not
+       * output the coordinate system.
+       */
+      friend std::ostream &operator<<( std::ostream &output, const Point<dim> &stream_point )
+      {
+        for (size_t i = 0; i < dim-1; i++)
+          {
+            output <<  stream_point[i] << ' ';
+          }
+        output << stream_point[dim-1];
+
+        return output;
+      }
+
+
+    private:
+      std::array<double,dim> point;
+      CoordinateSystem coordinate_system;
+
+  };
+
+  template <>
+  inline
+  double Point<2>::norm_square() const
+  {
+    return (point[0] * point[0]) + (point[1] * point[1]);
+  }
+
+  template <>
+  inline
+  double Point<3>::norm_square() const
+  {
+    return (point[0] * point[0]) + (point[1] * point[1]) + (point[2] * point[2]);
+  }
+
+  template<unsigned int dim>
+  inline
+  Point<dim> operator*(const double scalar, const Point<dim> &point)
+  {
+    return point*scalar;
+  }
+} // namespace WorldBuilder
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/array.h.bak b/contrib/world_builder/include/world_builder/types/array.h.bak
new file mode 100644
index 00000000000..f2dba5dc7ca
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/array.h.bak
@@ -0,0 +1,119 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_ARRAY_H
+#define WORLD_BUILDER_TYPES_ARRAY_H
+
+
+#include "world_builder/types/interface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+    /**
+     * This class represents an array of values which can be of any Types. It
+     * stores the type of values it is holding and an vector of indices where
+     * the values are actually stored in the parameters vector which hold all
+     * the values of that type. This type can also hold a unique pointer to
+     * the type is should hold. This is used for declaring types.The difference
+    * between an array and a list is that the array holds the values retrievable
+    * by index, and a list holds the values strictly ordered, only accessible
+    * an iterator. An other difference it that lists have a name.
+     */
+    class Array final: public Interface
+    {
+      public:
+        /**
+         * Constructor for the declaration
+         */
+        Array(const Interface &type,
+              const unsigned int min_items = 0,
+              const unsigned int max_items = std::numeric_limits<unsigned int>::max(),
+              const bool unique_items = false);
+
+        /**
+         * Constructor for cloning an array.
+         */
+        Array(Array const &other);
+
+
+        /**
+         * Destructor
+         */
+        ~Array() override final;
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+        /**
+         * An enum of the type which this class points to
+         * @see Types::type
+         */
+        Types::type inner_type;
+
+        /**
+         * This class is sometimes responsible for the object it points to, but
+         * sometimes it is not responsible for the object is points to.
+         * When it is responsible the unique_inner_type points to it and the
+         * inner_type should have size zero. When it is not responsible,
+         * unique_inner_type should point to the nullptr and inner_type should
+         * have a size larger then zero.
+         * @see inner_type_index
+         */
+        std::unique_ptr<Interface> inner_type_ptr;
+
+
+        /**
+         * Todo
+         */
+        bool required;
+
+        /**
+         * Todo
+         */
+        unsigned int min_items;
+
+        /**
+         * Todo
+         */
+        unsigned int max_items;
+
+        /**
+         * Todo
+         */
+        bool unique_items;
+
+      protected:
+        Array *clone_impl() const override final
+        {
+          return new Array(*this);
+        };
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/bool.h.bak b/contrib/world_builder/include/world_builder/types/bool.h.bak
new file mode 100644
index 00000000000..77bafbb7c60
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/bool.h.bak
@@ -0,0 +1,77 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_BOOL_H
+#define WORLD_BUILDER_TYPES_BOOL_H
+
+
+#include "world_builder/types/interface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+
+    /**
+     * This class represents a bool value with documentation
+     */
+    class Bool final: public Interface
+    {
+      public:
+        /**
+         * A constructor for the load_entry function
+         */
+        Bool(const bool default_value);
+
+        /**
+         * Copy constructor
+         */
+        Bool(Bool const &other);
+
+        /**
+         * Destructor
+         */
+        ~Bool() override final;
+
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+        bool default_value;
+
+      protected:
+        Bool *clone_impl() const override final
+        {
+          return new Bool(*this);
+        };
+
+      private:
+
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/double.h.bak b/contrib/world_builder/include/world_builder/types/double.h.bak
new file mode 100644
index 00000000000..05bd3b74de3
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/double.h.bak
@@ -0,0 +1,76 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_DOUBLE_H
+#define WORLD_BUILDER_TYPES_DOUBLE_H
+
+
+#include "world_builder/types/interface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+
+    /**
+     * This class represents a double value with documentation
+     */
+    class Double final: public Interface
+    {
+      public:
+        /**
+         * A constructor for the load_entry function
+         */
+        Double(const double default_value);
+
+        /**
+         * Copy constructor
+         */
+        Double(Double const &other);
+
+        /**
+         * Destructor
+         */
+        ~Double() override final;
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+        double default_value;
+
+      protected:
+        Double *clone_impl() const override final
+        {
+          return new Double(*this);
+        };
+
+      private:
+
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/int.h.bak b/contrib/world_builder/include/world_builder/types/int.h.bak
new file mode 100644
index 00000000000..44cd4f13c65
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/int.h.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_INT_H
+#define WORLD_BUILDER_TYPES_INT_H
+
+
+#include "world_builder/types/interface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+
+    /**
+     * This class represents a bool value with documentation
+     */
+    class Int final: public Interface
+    {
+      public:
+        /**
+         * A constructor for the load_entry function
+         */
+        Int(int default_value = 0);
+
+        /**
+         * Copy constructor
+         */
+        Int(Int const &other);
+
+        /**
+         * Destructor
+         */
+        ~Int() override final;
+
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+        int value {0};
+        int default_value;
+
+      protected:
+        /**
+         * This implements the actual cloneing for the clone function in the base class.
+         */
+        Int *clone_impl() const override final
+        {
+          return new Int(*this);
+        };
+      private:
+
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/interface.h.bak b/contrib/world_builder/include/world_builder/types/interface.h.bak
new file mode 100644
index 00000000000..40cd8b58616
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/interface.h.bak
@@ -0,0 +1,93 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_INTERFACE_H
+#define WORLD_BUILDER_TYPES_INTERFACE_H
+
+#include "rapidjson/pointer.h"
+#include "assert.h"
+
+#include <memory>
+#include <iostream>
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  /**
+   * This class is an interface for the specific plate tectonic feature classes,
+   * such as continental plate, oceanic plate and subduction zone.
+   */
+  namespace Types
+  {
+
+    enum class type
+    {
+      None,Bool,String,Double,Int,UnsignedInt,Array,Object,List,Point2D,Point3D,CoordinateSystem,PluginSystem,Segment,ConstantLayer,ValueAtPoints,OneOf
+    };
+
+    class Interface
+    {
+      public:
+        /**
+         * Constructor
+         */
+        Interface();
+
+        /**
+         * Destructor
+         */
+        virtual
+        ~Interface();
+
+        /**
+         * Todo
+         */
+        virtual
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const = 0;
+
+        /**
+         * clone
+         */
+        virtual
+        std::unique_ptr<Interface> clone() const
+        {
+          return std::unique_ptr<Interface>(clone_impl());
+        }
+
+        /**
+         * read in the world builder file
+         */
+
+        type get_type() const;
+
+
+      protected:
+        type type_name {type::None};
+
+
+        virtual
+        Interface *clone_impl() const = 0;
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/object.h.bak b/contrib/world_builder/include/world_builder/types/object.h.bak
new file mode 100644
index 00000000000..a188450ff13
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/object.h.bak
@@ -0,0 +1,87 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_OBJECT_H
+#define WORLD_BUILDER_TYPES_OBJECT_H
+
+#include <vector>
+
+#include "world_builder/types/interface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+    /**
+     * This class represents an object of values which can be of any Types. It
+     * stores the type of values it is holding and an vector of indices where
+     * the values are actually stored in the parameters vector which hold all
+     * the values of that type. This type can also hold a unique pointer to
+     * the type is should hold. This is used for declaring types.The difference
+    * between an object and a list is that the object holds the values retrievable
+    * by index, and a list holds the values strictly ordered, only accessible
+    * an iterator. An other difference it that lists have a name.
+     */
+    class Object final: public Interface
+    {
+      public:
+        /**
+         * Constructor for the declaration
+         */
+        Object(std::vector<std::string> required = std::vector<std::string>(),
+               const bool additional_properties = false);
+
+        /**
+         * Copy constructor
+         */
+        Object(Object const &other);
+
+        /**
+         * Destructor
+         */
+        ~Object() final;
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+
+        /**
+         * Todo
+         */
+        std::vector<std::string> required;
+        bool additional_properties;
+
+      protected:
+        Object *clone_impl() const override final
+        {
+          return new Object(*this);
+        };
+
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/one_of.h.bak b/contrib/world_builder/include/world_builder/types/one_of.h.bak
new file mode 100644
index 00000000000..c4aedcaaa89
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/one_of.h.bak
@@ -0,0 +1,89 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_ONE_OF_H
+#define WORLD_BUILDER_TYPES_ONE_OF_H
+
+
+#include "world_builder/types/interface.h"
+#include <vector>
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+    /**
+     * This class represents an a single choice between options (one of).
+     */
+    class OneOf final: public Interface
+    {
+      public:
+        /**
+         * Constructor for the declaration
+         */
+        OneOf(const Interface &type_1,
+              const Interface &type_2);
+
+        /**
+         * Constructor for cloning an array.
+         */
+        OneOf(OneOf const &other);
+
+
+        /**
+         * Destructor
+         */
+        ~OneOf() override final;
+
+        /**
+         * Write schema
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+        /**
+         * An enum of the type which this class points to
+         * @see Types::type
+         */
+        Types::type inner_type;
+
+        /**
+         * This class is sometimes responsible for the object it points to, but
+         * sometimes it is not responsible for the object is points to.
+         * When it is responsible the unique_inner_type points to it and the
+         * inner_type should have size zero. When it is not responsible,
+         * unique_inner_type should point to the nullptr and inner_type should
+         * have a size larger then zero.
+         * @see inner_type_index
+         */
+        std::vector<std::unique_ptr<Interface>> inner_types_ptr;
+
+      protected:
+        OneOf *clone_impl() const override final
+        {
+          return new OneOf(*this);
+        };
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/plugin_system.h.bak b/contrib/world_builder/include/world_builder/types/plugin_system.h.bak
new file mode 100644
index 00000000000..a3ac0827929
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/plugin_system.h.bak
@@ -0,0 +1,85 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_PLUGIN_SYSTEM_H
+#define WORLD_BUILDER_TYPES_PLUGIN_SYSTEM_H
+
+
+#include "world_builder/features/interface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+
+    /**
+     * This class represents a plate tectonic feature class, such as the
+     * continental plate class, oceanic plate class and subduction zone class.
+     */
+    class PluginSystem final: public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        PluginSystem(std::string default_value_,
+                     void ( *declare_entries)(Parameters &, const std::string &, const std::vector<std::string> &),
+                     std::vector<std::string> required_entries,
+                     const bool allow_multiple = true);
+
+
+        /**
+         * Copy constructor
+         */
+        PluginSystem(PluginSystem const &plugin_system);
+
+        /**
+         * Destructor
+         */
+        ~PluginSystem() override final;
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+
+        std::string default_value;
+        void( *declare_entries)(Parameters &, const std::string &, const std::vector<std::string> &);
+        std::vector<std::string> required_entries;
+        bool allow_multiple;
+
+      protected:
+        PluginSystem *clone_impl() const override final
+        {
+          return new PluginSystem(*this);
+        };
+
+      private:
+
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/point.h.bak b/contrib/world_builder/include/world_builder/types/point.h.bak
new file mode 100644
index 00000000000..d73ce91c3e4
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/point.h.bak
@@ -0,0 +1,132 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_POINT_H
+#define WORLD_BUILDER_TYPES_POINT_H
+
+
+#include "world_builder/point.h"
+#include "world_builder/types/interface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+
+    /**
+     * This class represents a continental plate and can implement submodules
+     * for temperature and composition. These submodules determine what
+     * the returned temperature or composition of the temperature and composition
+     * functions of this class will be.
+     */
+    template <unsigned int dim>
+    class Point final: public Interface
+    {
+      public:
+
+        /**
+         * A constructor used for the load_entry function
+         */
+        Point();
+
+        /**
+         * A constructor used for the load_entry function
+         */
+        Point(const WorldBuilder::Point<dim> &default_value, std::string description);
+
+        /**
+         * A constructor used for cloning and the set_entry function
+         */
+        Point(const WorldBuilder::Point<dim> &value, const WorldBuilder::Point<dim> &default_value, std::string description);
+
+        /**
+         * Copy constructor
+         */
+        Point(Point const &other);
+
+        /**
+         * Destructor
+         */
+        ~Point() override final;
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+        /**
+         * dot product
+         */
+        double operator*(const Point<dim> &point) const;
+
+
+        /**
+         * Multiply the vector with a scalar
+         */
+        WorldBuilder::Point<dim> operator*(const double scalar) const;
+
+        /**
+         * add two points
+         */
+        WorldBuilder::Point<dim> operator+(const Point<dim> &point) const;
+
+
+        /**
+         * Subtract two points
+         */
+        WorldBuilder::Point<dim> operator-(const Point<dim> &point) const;
+
+        /**
+         * access index (const)
+         */
+        const double &operator[](const unsigned int index) const;
+
+
+        /**
+         * access index
+         */
+        double &operator[](const unsigned int index);
+
+
+
+        WorldBuilder::Point<dim> value;
+        WorldBuilder::Point<dim> default_value;
+        std::string description;
+
+      protected:
+        Point *clone_impl() const override final
+        {
+          return new Point(*this);
+        };
+
+      private:
+
+    };
+
+    template<unsigned int dim>
+    WorldBuilder::Point<dim> operator*(const double scalar, const Point<dim> &point);
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/segment.h.bak b/contrib/world_builder/include/world_builder/types/segment.h.bak
new file mode 100644
index 00000000000..6ab28793047
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/segment.h.bak
@@ -0,0 +1,100 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_SEGMENT_H
+#define WORLD_BUILDER_TYPES_SEGMENT_H
+
+
+#include "world_builder/types/plugin_system.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+
+    /**
+     * This class represents a segment value with documentation
+     */
+    class Segment : public Interface
+    {
+      public:
+        /**
+         * A constructor
+         */
+        Segment(const double default_length,
+                const WorldBuilder::Point<2> &default_thickness,
+                const WorldBuilder::Point<2> &default_top_truncation,
+                const WorldBuilder::Point<2> &default_angle,
+                const Types::Interface &temperature_plugin_system,
+                const Types::Interface &composition_plugin_system,
+                const Types::Interface &grains_plugin_system_);
+
+        /**
+         * A constructor for the load_entry function
+         */
+        Segment(double default_length,
+                WorldBuilder::Point<2> default_thickness,
+                WorldBuilder::Point<2> default_angle,
+                std::string description);
+
+        /**
+         * Copy constructor
+         */
+        Segment(Segment const &other);
+
+
+        /**
+         * Destructor
+         */
+        ~Segment() override;
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+
+        double value_length;
+        double default_length;
+        WorldBuilder::Point<2> value_thickness;
+        WorldBuilder::Point<2> default_thickness;
+        WorldBuilder::Point<2> default_top_truncation;
+        WorldBuilder::Point<2> value_angle;
+        WorldBuilder::Point<2> default_angle;
+        std::unique_ptr<Types::Interface> temperature_plugin_system;
+        std::unique_ptr<Types::Interface> composition_plugin_system;
+        std::unique_ptr<Types::Interface> grains_plugin_system;
+
+      protected:
+        Segment *clone_impl() const override final
+        {
+          return new Segment(*this);
+        };
+      private:
+
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/string.h.bak b/contrib/world_builder/include/world_builder/types/string.h.bak
new file mode 100644
index 00000000000..6a83b654c52
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/string.h.bak
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_STRING_H
+#define WORLD_BUILDER_TYPES_STRING_H
+
+#include <vector>
+
+#include "world_builder/types/interface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+
+    /**
+     * This class represents a continental plate and can implement submodules
+     * for temperature and composition. These submodules determine what
+     * the returned temperature or composition of the temperature and composition
+     * functions of this class will be.
+     */
+    class String final: public Interface
+    {
+      public:
+        /**
+         * constructor
+         */
+        String(std::string default_value);
+
+        /**
+         * constructor
+         */
+        String(std::string default_value, const std::string &restricted_value);
+
+        /**
+         * constructor
+         */
+        String(std::string default_value, std::vector<std::string> restricted_values);
+
+        /**
+         * constructor
+         */
+        //String(std::string default_value, std::string description);
+
+
+        /**
+         * A constructor for the clone and set_entry function
+         */
+        String(std::string value, std::string default_value, std::string description);
+
+        /**
+         * Copy constructor
+         */
+        String(String const &other);
+
+        /**
+         * Destructor
+         */
+        ~String() final;
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+
+        std::string value;
+        std::string default_value;
+        std::string description;
+        std::vector<std::string> restricted_values;
+
+
+      protected:
+        String *clone_impl() const override final
+        {
+          return new String(*this);
+        };
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/unsigned_int.h.bak b/contrib/world_builder/include/world_builder/types/unsigned_int.h.bak
new file mode 100644
index 00000000000..1afd9a62f9b
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/unsigned_int.h.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_UNSIGNED_INT_H
+#define WORLD_BUILDER_TYPES_UNSIGNED_INT_H
+
+
+#include "world_builder/types/interface.h"
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+
+    /**
+     * This class represents a bool value with documentation
+     */
+    class UnsignedInt final: public Interface
+    {
+      public:
+        /**
+         * A constructor for the load_entry function
+         */
+        UnsignedInt(unsigned int default_value = 0);
+
+        /**
+         * Copy constructor
+         */
+        UnsignedInt(UnsignedInt const &other);
+
+        /**
+         * Destructor
+         */
+        ~UnsignedInt() override final;
+
+
+        /**
+         * Todo
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+        unsigned int value {0};
+        unsigned int default_value;
+
+      protected:
+        /**
+         * This implements the actual cloneing for the clone function in the base class.
+         */
+        UnsignedInt *clone_impl() const override final
+        {
+          return new UnsignedInt(*this);
+        };
+      private:
+
+    };
+  } // namespace Types
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/types/value_at_points.h.bak b/contrib/world_builder/include/world_builder/types/value_at_points.h.bak
new file mode 100644
index 00000000000..a3878b616cd
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/types/value_at_points.h.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_TYPES_VALUE_AT_POINTS_H
+#define WORLD_BUILDER_TYPES_VALUE_AT_POINTS_H
+
+#include "world_builder/types/point.h"
+#include <vector>
+
+
+namespace WorldBuilder
+{
+  class Parameters;
+
+  namespace Types
+  {
+    /**
+     * This class represents a depth surface value with documentation
+     */
+    class ValueAtPoints : public Interface
+    {
+      public:
+        /**
+         * A constructor
+         */
+        ValueAtPoints(const double default_value,
+                      uint64_t max_values_in_array,
+                      std::vector<Point<2>> default_points_ = std::vector<Point<2>>());
+
+        /**
+         * Copy constructor
+         */
+        ValueAtPoints(ValueAtPoints const &other);
+
+
+        /**
+         * Destructor
+         */
+        ~ValueAtPoints() override;
+
+        /**
+         * Write schema
+         */
+        void write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const override final;
+
+        double default_value;
+        uint64_t max_values_in_array;
+        std::vector<Point<2> > default_points;
+
+      protected:
+        ValueAtPoints *clone_impl() const override final
+        {
+          return new ValueAtPoints(*this);
+        };
+      private:
+
+    };
+  } // namespace Types
+
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/utilities.h.bak b/contrib/world_builder/include/world_builder/utilities.h.bak
new file mode 100644
index 00000000000..9b5d2687a2d
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/utilities.h.bak
@@ -0,0 +1,494 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_UTILITIES_H
+#define WORLD_BUILDER_UTILITIES_H
+
+
+#include "world_builder/nan.h"
+#include "world_builder/coordinate_systems/interface.h"
+#include "world_builder/objects/natural_coordinate.h"
+#include "world_builder/objects/bezier_curve.h"
+#include <iostream>
+
+
+namespace WorldBuilder
+{
+
+  namespace CoordinateSystems
+  {
+    class Interface;
+  } // namespace CoordinateSystems
+  namespace Utilities
+  {
+
+    /**
+     * provide a short way to test if two doubles are equal.
+     * Based on https://stackoverflow.com/a/4010279.
+     * Removed a==b test since it triggers warnings. If used in
+     * performance critical parts where this could matter, a fast
+     * version could be added.
+     */
+    inline bool approx(double a, double b, double error_factor=1e4)
+    {
+      return std::abs(a-b)<std::abs(std::min(a,b))*std::numeric_limits<double>::epsilon()*
+             error_factor;
+    }
+
+    /**
+     * Given a 2d point and a list of points which form a polygon, computes if
+     * the point falls within the polygon. For spherical coordinates it will
+     * return true if the point or the point where the longitude is shifted
+     * by 2 * PI is inside on of the polygons. It calls
+     * polygon_contains_point_implementation to do the real work.
+     */
+    bool
+    polygon_contains_point(const std::vector<Point<2> > &point_list,
+                           const Point<2> &point);
+
+    /**
+     * Given a 2d point and a list of points which form a polygon, computes if the point
+     * falls within the polygon.
+     */
+    bool
+    polygon_contains_point_implementation(const std::vector<Point<2> > &point_list,
+                                          const Point<2> &point);
+
+
+    /**
+     * Given a 2d point, a semi-major axis, and an eccentricity, computes where
+     * the point falls within the ellipse. If the fraction is larger than 1, the
+     * point is outside the ellipse.
+     */
+    double
+    fraction_from_ellipse_center (const Point<2> &ellipse_center,
+                                  const double semi_major_axis,
+                                  const double eccentricity,
+                                  const double rotation_angle,
+                                  const Point<2> &point);
+
+
+    /**
+     * Given a 2d point and a list of points which form a polygon, compute the smallest
+     * distance of the point to the polygon. The sign is negative for points outside of
+     * the polygon and positive for points inside the polygon.
+     */
+    double
+    signed_distance_to_polygon(const std::vector<Point<2> > &point_list_,
+                               const Point<2> &point_);
+
+
+    /**
+     * Returns spherical coordinates of a Cartesian point. The returned array
+     * is filled with radius, phi and theta (polar angle). If the dimension is
+     * set to 2 theta is omitted. Phi is always normalized to [0,2*pi].
+     *
+     */
+    std::array<double,3>
+    cartesian_to_spherical_coordinates(const Point<3> &position);
+
+    /**
+     * Return the Cartesian point of a spherical position defined by radius,
+     * phi and theta (polar angle). If the dimension is set to 2 theta is
+     * omitted.
+     */
+    Point<3>
+    spherical_to_cartesian_coordinates(const std::array<double,3> &scoord);
+
+    /**
+     * Returns ellipsoidal coordinates of a Cartesian point. The returned array
+     * is filled with phi, theta and radius.
+     *
+     */
+    std::array<double,3>
+    cartesian_to_ellipsoidal_coordinates(const Point<3> &position,
+                                         const double semi_major_axis_a,
+                                         const double eccentricity);
+
+    /**
+     * Return the Cartesian point of a ellipsoidal position defined by phi,
+     * phi and radius.
+     */
+    Point<3>
+    ellipsoidal_to_cartesian_coordinates(const std::array<double,3> &phi_theta_d,
+                                         const double semi_major_axis_a,
+                                         const double eccentricity);
+
+    /**
+     * A function that takes a string representation of the name of a
+     * coordinate system (as represented by the CoordinateSystem enum)
+     * and returns the corresponding value.
+     */
+    CoordinateSystem
+    string_to_coordinate_system (const std::string & /*coordinate_system*/);
+
+
+    /**
+     * Convert point to array
+     */
+    template<unsigned int dim>
+    std::array<double,dim> convert_point_to_array(const Point<dim> &point);
+
+    /**
+     * Converts a string to a double
+     */
+    double
+    string_to_double(const std::string &string);
+
+    /**
+     * Converts a string to a int
+     */
+    int
+    string_to_int(const std::string &string);
+
+
+    /**
+     * Converts a string to a unsigned int
+     */
+    unsigned int
+    string_to_unsigned_int(const std::string &string);
+
+
+    /**
+     * Cross product between two 3d points.
+     */
+    Point<3> cross_product(const Point<3> &a, const Point<3> &b);
+
+    /**
+     * Enum class for interolation type
+     */
+    enum class InterpolationType
+    {
+      None,
+      Linear,
+      MonotoneSpline,
+      ContinuousMonotoneSpline,
+      Invalid,
+    };
+
+    /**
+     * Class for linear and monotone spline interpolation
+     */
+    class interpolation
+    {
+      public:
+        /**
+         * Initialize the spline. This function assumes that all y points are spaced 1 in the x direction.
+         *
+         * @param y Values in the interpolation points.
+         */
+        void set_points(const std::vector<double> &y);
+
+
+        /**
+         * Evaluate at point @p x.
+         */
+        inline
+        double operator() (const double x) const
+        {
+          if (x >= 0. && x <= static_cast<double>(mx_size_min))
+            {
+              const size_t idx = static_cast<size_t>(x);
+              const double h = x-static_cast<double>(idx);
+              return ((m[idx][0]*h + m[idx][1])*h + m[idx][2])*h + m[idx][3];
+            }
+          const size_t idx = std::min(static_cast<size_t>(std::max( static_cast<int>(x), static_cast<int>(0))),mx_size_min);
+          const double h = x-static_cast<double>(idx);
+          return (m[idx][1]*h + m[idx][2])*h + m[idx][3];
+        }
+
+
+        inline
+        double operator() (const double x, const size_t idx, const double h) const
+        {
+          return (x >= 0. && x <= static_cast<double>(mx_size_min))
+                 ?
+                 ((m[idx][0]*h + m[idx][1])*h + m[idx][2])*h + m[idx][3]
+                 :
+                 (m[idx][1]*h + m[idx][2])*h + m[idx][3];
+        }
+
+
+        /**
+         * Evaluate at point @p x. assumes x is between 0 and mx_size_min.
+         * assume size_t idx = (size_t)x and h = x-idx.
+         */
+        inline
+        double value_inside (const size_t idx, const double h) const
+        {
+          WBAssert(idx <= mx_size_min, "Internal error: using value_inside outside the range of 0 to " << mx_size_min << ", but value was outside of this range: " << idx << ".");
+          WBAssert(h >= 0 && h <= 1., "Internal error: using value_inside outside the range of 0 to " << mx_size_min << ", but value was outside of this range: " << h << ".");
+          return ((m[idx][0]*h + m[idx][1])*h + m[idx][2])*h + m[idx][3];
+        }
+
+
+        /**
+         * Evaluate at point @p x. assumes x is between 0 and mx_size_min.
+         * assume size_t idx = (size_t)x and h = x-idx.
+         */
+        inline
+        double value_outside (const size_t idx, const double h) const
+        {
+          WBAssert(idx <= mx_size_min, "Internal error: using value_inside outside the range of 0 to " << mx_size_min << ", but value was outside of this range: " << idx << ".");
+          WBAssert(!(static_cast<double>(idx) + h >= 0 && static_cast<double>(idx) + h <= 1.), "Internal error: using value_inside outside the range of 0 to " << mx_size_min << ", but value was outside of this range: " << static_cast<double>(idx) + h << " (h=" << h << ", idx = " << idx << ").");
+          return (m[idx][1]*h + m[idx][2])*h + m[idx][3];
+        }
+
+
+        /**
+         * number of x coordinates of points
+         */
+        size_t mx_size_min;
+
+        /**
+         * interpolation parameters
+         * \[
+         * f(x) = a*(x-x_i)^3 + b*(x-x_i)^2 + c*(x-x_i) + y_i
+         * \]
+         */
+        std::vector<std::array<double,4>> m; //m_a, m_b, m_c, m_y;
+
+      private:
+    };
+
+    /**
+     * A struct that is used to hold the return values of the function
+     * distance_point_from_curved_planes(). See there for a documentation
+     * of the meaning of the member variables. The variables are describing
+     * a where a point is with respect to a plane/surface. The surface is
+     * meshed by a grid. The axis parallel to the surface are formed by
+     * sections, and the axis perpendicuar to the surface are formed segments.
+     * Both sections and elements represent a whole cell in the grid, which is
+     * an integer. This structure also provides the fraction in each direction
+     * the closest point on the plane is along these two axes (sections and
+     * segments). These variables are called fractions.
+     *
+     * This structure furthermore provides the distance the provided point is
+     * from the closest point on the surface and the average angle. The variable
+     * local_thickness will not be automatically filled by the distance_point_from_curved_planes
+     * function.
+     */
+    struct PointDistanceFromCurvedPlanes
+    {
+      /**
+       * Constructor
+       */
+      PointDistanceFromCurvedPlanes(CoordinateSystem coordinate_system)
+        :
+        distance_from_plane(NaN::DSNAN),
+        distance_along_plane(NaN::DSNAN),
+        fraction_of_section(NaN::DSNAN),
+        fraction_of_segment(NaN::DSNAN),
+        section(NaN::ISNAN),
+        segment(NaN::ISNAN),
+        average_angle(NaN::DSNAN),
+        depth_reference_surface(NaN::DSNAN),
+        closest_trench_point(Point<3>(coordinate_system))
+      {}
+
+      /**
+       * The shortest distance between point and plane.
+       */
+      double distance_from_plane;
+
+      /**
+       * The distance between the start of the first segment (usually at
+       * the surface) to the provided point following the (curved) plane.
+       */
+      double distance_along_plane;
+
+      /**
+       * The fraction of the section that lies before the projected point
+       * on the plane (when looking from the start point of the section).
+       */
+      double fraction_of_section;
+
+      /**
+       * The fraction of the segment that lies before the projected point
+       * on the plane (when looking from the start point of the segment).
+       */
+      double fraction_of_segment;
+
+      /**
+       * The number of the section that is closest to the point
+       */
+      size_t section;
+
+      /**
+       * The number of the segment that is closest to the point.
+       */
+      size_t segment;
+
+      /**
+       * The average dip angle of the plane at the location where the
+       * point is projected onto the plane.
+       */
+      double average_angle;
+
+      /**
+       * The depth of the closest point on reference surface.
+       */
+      double depth_reference_surface;
+
+      /**
+       * The closest point on the trench line in cartesian coordinates.
+       */
+      Point<3> closest_trench_point;
+    };
+
+    /**
+     * Computes the distance of a point to a curved plane.
+     * TODO: add more info on how this works/is implemented.
+     * \param check_point This is the cartesian point of which we want to know the
+     * distance to the curved planes
+     * \param check_point_natural the check_point in the natural coordinates of the
+     * current coordinate system.
+     * \param reference_point This is a 2d point in natural coordinates at the
+     * surface which the curved planes dip towards. Natural coordinates are in
+     * cartesian (x,y,z) in meters and in spherical radius in meters and longitude
+     * and latitude in radians.
+     * \param point_list This is a vector of 2d Points in natural coordinates at the
+     * surface which define the line along the surface at which the curved planes
+     * start. Natural coordinates are in cartesian (x,y,z) in meters and in spherical
+     * radius in meters and longitude and latitude in radians.
+     * \param plane_segment_lengths This is a vector of vectors of doubles. It contains
+     * the length of every segment at point in the point_list (in the same order as
+     * the point_list.
+     * \param plane_segment_angles This is a vector of vectors of 2d points. It contains
+     * the begin and end angle of every segment at point in the point_list (in the same
+     * order as the point_list.
+     * \param start_radius This value contains the radius or height from bottom of the box
+     * at which the plane starts. This means that the start_radius effectively becomes the
+     * surface for this slab.
+     * \param coordinate_system This is a reference to the coordinate system of the
+     * World Builder. This is used to convert cartesian to natural coordinates and back.
+     * \param only_positive This value determines whether only the part below the
+     * plane should count as distance or both sides of the plane. It is called only_positive
+     * because the area below the plane, the distance is positive, and above the plane the
+     * distance is negative.
+     * \param interpolation_type This value determines what interpolation type should be used
+     * when determining the location with respect to the curved plane.
+     * \param spline_x the spline representing the x coordinate.
+     * \param spline_y the spline representing the y coordinate.
+     * \param global_x_list This is a list of one dimensional coorindates, with zero or the
+     * amount of coordinates entries, used for interpolation. An empty list is interpreted
+     * as a list filled with {0,1,2,...,number of coordinates}. Filling this list with other
+     * values changes the returned section fraction. It allows for, for example, adding
+     * extra coordinates automatically, and still reference the user provided coordinates by
+     * the original number. Note that no whole numbers may be skipped. So for a list of 4 points,
+     * {0,0.5,1,2} is allowed, but {0,2,3,4} is not.
+     *
+     * The function returns a struct that contains which segment and section of the curved
+     * planes the point is closest to, what fraction of those segment and section lies before
+     * the point (looking from the start of segment/section), the distance
+     * of the point from the plane and the distance of the point along the plane,
+     * and the average angle of the closest segment/section.
+     */
+    PointDistanceFromCurvedPlanes distance_point_from_curved_planes(const Point<3> &check_point,
+                                                                    const Objects::NaturalCoordinate &check_point_natural,
+                                                                    const Point<2> &reference_point,
+                                                                    const std::vector<Point<2> > &point_list,
+                                                                    const std::vector<std::vector<double> > &plane_segment_lengths,
+                                                                    const std::vector<std::vector<Point<2> > > &plane_segment_angles,
+                                                                    const double start_radius,
+                                                                    const std::unique_ptr<CoordinateSystems::Interface> &coordinate_system,
+                                                                    const bool only_positive,
+                                                                    const Objects::BezierCurve &bezier_curve);
+
+
+
+    /**
+     * Ensure angle is between 0 and 360 degrees
+     */
+    double wrap_angle(const double angle);
+
+    /**
+     * Interpolate between two angles (angle1 and angle2),
+     * with fraction defining the weighting between the two,
+     * taking into account we might cross over from 360 to 0 degrees.
+     */
+    double interpolate_angle_across_zero(const double angle_1,
+                                         const double angle_2,
+                                         const double fraction);
+
+    /**
+     * Transform a rotation matrix into euler angles
+     */
+    std::array<double,3>
+    euler_angles_from_rotation_matrix(const std::array<std::array<double,3>,3> &rotation_matrix);
+
+    /**
+     * Transform euler angles into a rotation matrix
+     */
+    std::array<std::array<double,3>,3>
+    euler_angles_to_rotation_matrix(double phi1, double theta, double phi2);
+
+    /**
+     * Read a file and distribute the content over all MPI processes.
+     * If WB_WITH_MPI is not defined, this function will just read the file.
+     *
+     * @param filename The name of the file to read.
+     * @return The content of the file.
+    */
+    std::string
+    read_and_distribute_file_content(const std::string &filename);
+
+    /**
+     * Calculate the distance of a point from a mid oceanic ridge, and also calculate
+     * the spreading velocity of the ridge at this point.
+     * TODO: make the spreading velocity spatially/temporally variable
+     *
+     * @param mid_oceanic_ridges The coordinates of the mid oceanic ridges
+     * @param mid_oceanic_spreading_velocities The spreading rate of the mid oceanic ridges at each ridge coordinate
+     * @param coordinate_system The coordinate system
+     * @param position_in_natural_coordinates_at_min_depth the current position in natural_coordinates
+     * @param subducting_plate_velocities the subducting plate velocities, currently this is only an optional parameter
+     * that can be used in the mass conserving subducting plate temperature model. This parameter allows the user to
+     * track the effect of ridge migration on the slab thermal structure
+     * @param ridge_migration_times the times that the corresponding section of the ridge has been moving, in years. This
+     * is used in combination with subducting_plate_velocities, and mid_oceanic_spreading_velocities to compute the distance
+     * that the spreading center has migrated. This vector is obtained from the input parameter "spreading velocity" in the
+     * mass conserving model when "spreading velocity" has the form: [ [t1,[[v11, v12, ...]], [t2,[[v21, v22, ...]], ... ].
+     * where tn is the time that ridge section n has been moving.
+     * @return The content of the file.
+    */
+    std::vector<double>
+    calculate_ridge_distance_and_spreading(std::vector<std::vector<Point<2>>> mid_oceanic_ridges,
+                                           std::vector<std::vector<double>> mid_oceanic_spreading_velocities,
+                                           const std::unique_ptr<WorldBuilder::CoordinateSystems::Interface> &coordinate_system,
+                                           const Objects::NaturalCoordinate &position_in_natural_coordinates_at_min_depth,
+                                           const std::vector<std::vector<double>> &subducting_plate_velocities,
+                                           const std::vector<double> &ridge_migration_times);
+
+    // todo_effective
+    /**
+     * Calculate the effective plate ages of a point on the slab surface, and also calculates
+     * the effective trench ages at the start of subduction.
+     * @param ridge_parameters The distance and spreading velocity relative to a mid ocean ridge
+     * @param distance_along_plane The distance along the slab surface plane
+     * @return The effective plate age and the trench age
+    */
+    std::vector<double>
+    calculate_effective_trench_and_plate_ages(std::vector<double> ridge_parameters, double distance_along_plane);
+
+  } // namespace Utilities
+} // namespace WorldBuilder
+
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/world.h.bak b/contrib/world_builder/include/world_builder/world.h.bak
new file mode 100644
index 00000000000..0627eb60d84
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/world.h.bak
@@ -0,0 +1,316 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_WORLD_H
+#define WORLD_BUILDER_WORLD_H
+
+#include "world_builder/grains.h"
+#include "world_builder/parameters.h"
+#include "world_builder/utilities.h"
+#include "world_builder/objects/distance_from_surface.h"
+
+#include <random>
+
+/**
+* The global namespace for the Geodynamic World Builder
+*/
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    class Interface;
+  } // namespace Features
+
+  class World
+  {
+    public:
+      /**
+       * Constructor. This constructor requires the parameter filename. Other parameters
+       * are optional.
+       * \param filename  a string with the location of
+       * the world builder file to initialize the world.
+       * \param has_output_dir a bool indicating whether the world builder is allowed to
+       * write out information to a directly.
+       * \param output_dir a string with the location of the directory where the world builder
+       * is allowed to write information to if it is allowed by the bool has_output_dir.
+       * \param random_number_seed a double containing a seed for the random number generator.
+       * The world builder uses a deterministic random number generator for some plugins. This
+       * is a deterministic random number generator on prorpose because even though you might
+       * want to use random numbers to initialize some fields, the result should be reproducible.
+       * Note that when the world builder is used in for example MPI programs you should supply
+       * the world builder created each MPI process a different seed. You can use the MPI RANK
+       * for this (seed is seed + MPI_RANK). Because the generator is deterministic (known and
+       * documented algorithm), we can test the results and they should be the same even for different
+       * compilers and machines.
+       */
+      World(std::string filename, bool has_output_dir = false, const std::string &output_dir = "", unsigned long random_number_seed = 1, const bool limit_debug_consistency_checks = true);
+
+      /**
+       * Destructor
+       */
+      ~World();
+
+
+      /**
+       * Describe what the world builder file should look like
+       */
+      static void declare_entries(Parameters &prm);
+
+      /**
+       * read in the world builder file
+       */
+      void parse_entries(Parameters &prm);
+
+      /**
+       * Returns different values at a single point in one go stored in a vector of doubles.
+       *
+       * The properties input decides what each entry means, and the output is generated in the
+       * same order as the properties input. The properties input consists of
+       * a 3D array, where the first entry identifies the property and the last two entries
+       * provide extra information about that property.
+       *
+       * Temperature is identified by 1 and no extra information is needed. So temperature
+       * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
+       * vector.
+       *
+       * Composition is identified by 2. This produces one
+       * value in the output. The second entry  identifies the composition number and the third
+       * number is not used. So a commposition query asking about composition 1 looks like this:
+       * {2,1,0}. A composition query prodoces one entry in the output vector.
+       *
+       * Grains are identified by 2. The second entry is the grain composition number and the third
+       * entry is the number of grains. A query about the grains, where it asks about composition 1
+       * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
+       * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
+       * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
+       * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
+       */
+      std::vector<double> properties(const std::array<double, 2> &point,
+                                     const double depth,
+                                     const std::vector<std::array<unsigned int,3>> &properties) const;
+
+      /**
+       * Returns different values at a single point in one go stored in a vector of doubles.
+       *
+       * The properties input decides what each entry means, and the output is generated in the
+       * same order as the properties input. The properties input consists of
+       * a 3D array, where the first entry identifies the property and the last two entries
+       * provide extra information about that property.
+       *
+       * Temperature is identified by 1 and no extra information is needed. So temperature
+       * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
+       * vector.
+       *
+       * Composition is identified by 2. This produces one
+       * value in the output. The second entry  identifies the composition number and the third
+       * number is not used. So a composition query asking about composition 1 looks like this:
+       * {2,1,0}. A composition query prodoces one entry in the output vector.
+       *
+       * Grains are identified by 3. The second entry is the grain composition number and the third
+       * entry is the number of grains. A query about the grains, where it asks about composition 1
+       * (for example enstatite) and 500 grains, looks like this: {3,1,500}.
+       * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
+       * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
+       * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
+       *
+       * The tag is identified by 4 and no extra information is needed. So the tag
+       * input usually looks like {4,0,0}. A tag query prodoces one entry in the output
+       * vector, representing the index of the tag of the last/dominant feature.
+       */
+      std::vector<double> properties(const std::array<double, 3> &point,
+                                     const double depth,
+                                     const std::vector<std::array<unsigned int,3>> &properties) const;
+
+      /**
+       * Returns the temperature based on a 2d Cartesian point, the depth in the
+       * model at that point and the gravity norm at that point.
+       */
+      double temperature(const std::array<double, 2> &point, const double depth) const;
+
+      /**
+       * Returns the temperature based on a 3d Cartesian point, the depth in the
+       * model at that point and the gravity norm at that point.
+       */
+      double temperature(const std::array<double, 3> &point, const double depth) const;
+
+      /**
+       * Returns the temperature based on a 2d Cartesian point, the depth in the
+       * model at that point and the gravity norm at that point.
+       * Note: gravity norm is no longer used, instead use the gravity model from the input file.
+       */
+      [[deprecated("Replaced by a temperature function without the gravity. This function will be removed in future versions.")]]
+      double temperature(const std::array<double, 2> &point, const double depth, const double gravity_norm) const;
+
+      /**
+       * Returns the temperature based on a 3d Cartesian point, the depth in the
+       * model at that point and the gravity norm at that point.
+       * Note: gravity norm is no longer used, instead use the gravity model from the input file.
+       */
+      [[deprecated("Replaced by a temperature function without the gravity. This function will be removed in future versions.")]]
+      double temperature(const std::array<double, 3> &point, const double depth, const double gravity_norm) const;
+
+      /**
+       * Returns the composition value based on a 2d Cartesian point, the depth in
+       * the model at that point and the gravity norm at that point.
+       */
+      double composition(const std::array<double, 2> &point, const double depth, const unsigned int composition_number) const;
+
+      /**
+       * Returns the composition value based on a 3d Cartesian point, the depth in
+       * the model at that point and the gravity norm at that point.
+       */
+      double composition(const std::array<double, 3> &point, const double depth, const unsigned int composition_number) const;
+
+      /**
+       * Returns the grain orientations and sizes based on a 2d Cartesian point, the depth in
+       * the model at that point and the gravity norm at that point.
+       */
+      WorldBuilder::grains grains(const std::array<double, 2> &point,
+                                  const double depth,
+                                  const unsigned int composition_number,
+                                  size_t number_of_grains) const;
+
+      /**
+       * Returns the grain orientations and sizes based on a 3d Cartesian point, the depth in
+       * the model at that point and the gravity norm at that point.
+       */
+      WorldBuilder::grains grains(const std::array<double, 3> &point,
+                                  const double depth,
+                                  const unsigned int composition_number,
+                                  size_t number_of_grains) const;
+      /**
+       * Returns a PlaneDistances object that has the distance from and along a feature plane,
+       * calculated from the coordinates and the depth of the point.
+       \param point the coordinates in the cartesian geometry
+       \param depth the depth of the point
+       \param name the name of the feature (i.e. the string provided to the key word "name" in the wb file)
+      */
+      Objects::PlaneDistances
+      distance_to_plane(const std::array<double, 3> &point,
+                        const double depth,
+                        const std::string &name) const;
+
+      /**
+       * The MPI rank. Set to zero if MPI is not available.
+       */
+      int MPI_RANK;
+
+      /**
+       * The MPI size. Set to one if MPI is not available.
+       */
+      int MPI_SIZE;
+
+      /**
+       * Return a reference to the mt19937 random number.
+       * The seed is provided to the world builder at construction.
+       */
+      std::mt19937 &get_random_number_engine();
+
+      /**
+       * This is the parameter class, which stores all the values loaded in
+       * from the parameter file or which are set directly.
+       */
+      Parameters parameters;
+
+      /**
+       * Todo
+       */
+      std::vector<Point<2> > cross_section;
+
+      /**
+       * Todo
+       */
+      Point<2> surface_coord_conversions;
+
+      /**
+       * Todo
+       */
+      double potential_mantle_temperature;
+
+      /**
+       * Todo
+       */
+      double surface_temperature;
+
+      /**
+       * Todo
+       */
+      bool force_surface_temperature;
+
+      /**
+       * Todo
+       */
+      double thermal_expansion_coefficient;
+
+      /**
+       * Todo
+       */
+      double specific_heat;
+
+      /**
+       * Todo
+       */
+      double thermal_diffusivity;
+
+      /**
+       * Todo
+       */
+      double maximum_distance_between_coordinates;
+
+      /**
+       * Todo
+       */
+      std::string interpolation;
+
+      /**
+       * A list of all the feature tags.
+       */
+      std::vector<std::string> feature_tags;
+
+    private:
+      /**
+       * The minimum dimension. If cross section data is provided, it is set
+       * to 2, which means the 2d function of temperature and composition can
+       * be used. Otherwise it is set to 3, which means that they can't be
+       * used.
+       */
+      unsigned int dim;
+
+
+      /**
+       * random number generator engine
+       */
+      std::mt19937 random_number_engine;
+
+      /**
+       * limits some of the consistency checks in debug mode.
+       * Current only prevents a check whether depth in spherical
+       * coordinates is consistent with the computed depth from
+       * x,y,z and provided radius.
+       * Note: Recommended to keep it at false, unless you know what you are doing.
+       */
+      bool limit_debug_consistency_checks;
+
+
+
+  };
+} // namespace WorldBuilder
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/wrapper_c.h.bak b/contrib/world_builder/include/world_builder/wrapper_c.h.bak
new file mode 100644
index 00000000000..e1598ab666b
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/wrapper_c.h.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_WRAPPER_C_H
+#define WORLD_BUILDER_WRAPPER_C_H
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * This function creates an object of the world builder and returns a pointer
+ * to it. This pointer can then be used to call the temperature and composition
+ * functions. When done call the release world function to destroy the object.
+ */
+void create_world(void **ptr_ptr_world, const char *world_builder_file, const bool *has_output_dir, const char *output_dir, const unsigned long random_number_seed);
+
+/**
+ * This function return the temperature at a specific location given x, z, depth and
+ * gravity.
+ * Note: gravity value is no longer used, instead use the gravity model from the input file.
+ */
+void temperature_2d(void *ptr_ptr_world, double x, double z, double depth, double *temperature);
+
+/**
+ * This function return the temperature at a specific location given x, y, z, depth and
+ * gravity.
+ */
+void temperature_3d(void *ptr_ptr_world, double x, double y, double z, double depth, double *temperature);
+
+/**
+ * This function return the composition at a specific location given x, z, depth and
+ * composition number.
+ */
+void composition_2d(void *ptr_ptr_world, double x, double z, double depth, unsigned int composition_number, double *composition);
+
+/**
+ * This function return the composition at a specific location given x, y, z, depth and
+ * composition number.
+ */
+void composition_3d(void *ptr_ptr_world, double x, double y, double z, double depth, unsigned int composition_number, double *composition);
+
+/**
+ * The destructor for the world builder class. Call this function when done with the
+ * world builder.
+ */
+void release_world(void *ptr_ptr_world);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/contrib/world_builder/include/world_builder/wrapper_cpp.h.bak b/contrib/world_builder/include/world_builder/wrapper_cpp.h.bak
new file mode 100644
index 00000000000..610ff1bbc58
--- /dev/null
+++ b/contrib/world_builder/include/world_builder/wrapper_cpp.h.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef WORLD_BUILDER_WRAPPER_CPP_H
+#define WORLD_BUILDER_WRAPPER_CPP_H
+
+#include <string>
+#include "world_builder/deprecate.h"
+
+namespace wrapper_cpp
+{
+  /**
+   * This class is to be used by SWIG. To make it easy for SWIG we do not use any
+   * other world builder header file in this header file. This means that the class
+   * stores a void pointer internally. The cpp implementation can use the world builder
+   * header files.
+   */
+  class WorldBuilderWrapper
+  {
+    public:
+      /**
+       * constructor
+       */
+      WorldBuilderWrapper(std::string filename, bool has_output_dir = false, const std::string &output_dir = "", const unsigned long random_number_seed = 1.0);
+
+      /**
+       * destructor
+       */
+      ~WorldBuilderWrapper();
+
+      /**
+       * This function return the temperature at a specific location given x, z, depth and
+       * gravity.
+       */
+      double temperature_2d(double x, double z, double depth);
+
+      /**
+       * This function return the temperature at a specific location given x, y, z, depth and
+       * gravity.
+       */
+      double temperature_3d(double x, double y, double z, double depth);
+
+      /**
+       * DEPRECATED: Replaced by a temperature function without the gravity. This function will be removed in future versions.
+       * This function return the temperature at a specific location given x, z, depth and
+       * gravity.
+       * Note: gravity value is no longer used, instead use the gravity model from the input file.
+       */
+      double temperature_2d(double x, double z, double depth, double gravity);
+
+      /**
+       * DEPRECATED: Replaced by a temperature function without the gravity. This function will be removed in future versions.
+       * This function return the temperature at a specific location given x, y, z, depth and
+       * gravity.
+       * Note: gravity value is no longer used, instead use the gravity model from the input file.
+       */
+      double temperature_3d(double x, double y, double z, double depth, double gravity);
+
+      /**
+       * This function return the composition at a specific location given x, z, depth and
+       * composition number.
+       */
+      double composition_2d(double x, double z, double depth, unsigned int composition_number);
+
+      /**
+       * This function return the composition at a specific location given x, y, z, depth and
+       * composition number.
+       */
+      double composition_3d(double x, double y, double z, double depth, unsigned int composition_number);
+
+
+    private:
+      void *ptr_ptr_world;
+
+
+  };
+} // namespace wrapper_cpp
+#endif
diff --git a/contrib/world_builder/source/gwb-dat/main.cc.bak b/contrib/world_builder/source/gwb-dat/main.cc.bak
new file mode 100644
index 00000000000..0ef4ca636a2
--- /dev/null
+++ b/contrib/world_builder/source/gwb-dat/main.cc.bak
@@ -0,0 +1,343 @@
+/*
+  Copyright (C) 2018 - 2021 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+
+#include "app/main.h"
+
+#include "world_builder/assert.h"
+#include "world_builder/consts.h"
+#include "world_builder/point.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+#ifdef WB_WITH_MPI
+// we don't need the c++ MPI wrappers
+#define OMPI_SKIP_MPICXX 1
+#define MPICH_SKIP_MPICXX
+#include <mpi.h>
+#endif
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <memory>
+
+#ifndef NDEBUG
+#ifdef WB_USE_FP_EXCEPTIONS
+#include <cfenv>
+#endif
+#endif
+
+using namespace WorldBuilder::Utilities;
+
+bool find_command_line_option(char **begin, char **end, const std::string &option)
+{
+  return std::find(begin, end, option) != end;
+}
+
+int main(int argc, char **argv)
+{
+
+#ifndef NDEBUG
+#ifdef WB_USE_FP_EXCEPTIONS
+  // Some implementations seem to not initialize the floating point exception
+  // bits to zero. Make sure we start from a clean state.
+  feclearexcept(FE_DIVBYZERO|FE_INVALID);
+
+  // enable floating point exceptions
+  feenableexcept(FE_DIVBYZERO|FE_INVALID);
+#endif
+#endif
+
+  /**
+   * First parse the command line options
+   */
+  std::string wb_file;
+  std::string data_file;
+
+  unsigned int dim = 3;
+  unsigned int compositions = 0;
+  unsigned int grain_compositions = 0;
+  size_t n_grains = 0;
+  bool convert_spherical = false;
+  bool limit_debug_consistency_checks = false;
+  bool output_json_files = false;
+
+  if (find_command_line_option(argv, argv+argc, "-h") || find_command_line_option(argv, argv+argc, "--help"))
+    {
+      std::cout << "This program allows to use the world builder library directly with a world builder file and a data file. "
+                "The data file will be filled with initial conditions from the world as set by the world builder file." << std::endl
+                << "Besides providing two files, where the first is the world builder file and the second is the data file, the available options are: " << std::endl
+                << "-h or --help to get this help screen." << std::endl;
+      return 0;
+    }
+
+  if (find_command_line_option(argv, argv+argc, "-ldcc") || find_command_line_option(argv, argv+argc, "--limit-debug-consistency-checks"))
+    limit_debug_consistency_checks = true;
+
+  if (find_command_line_option(argv, argv+argc, "--output-json-files"))
+    output_json_files = true;
+
+  if (argc == 1)
+    {
+      std::cout << "Error: There where no files passed to the World Builder, use --help for more " << std::endl
+                << "information on how  to use the World Builder app." << std::endl;
+      return 0;
+    }
+
+
+  if (argc == 2)
+    {
+      std::cout << "Error:  The World Builder app requires at least two files, a World Builder file " << std::endl
+                << "and a data file to convert." << std::endl;
+      return 0;
+    }
+
+  if ((argc == 3 && limit_debug_consistency_checks && output_json_files) || (argc == 4 && !(!limit_debug_consistency_checks != !output_json_files)) || (argc == 5 && (!limit_debug_consistency_checks && !output_json_files)) || argc > 5)
+    {
+      std::cout << "Only exactly two command line arguments may be given, which should be the world builder file location and the data file location (in that order) "
+                << "or exactly three command line arguments, which should be the world builder file location, the data file location and --limit-debug-consistency-checks or --output-json-files (in that order),"
+                "or exactly four command line arguments, which should be the world builder file location, the data file location and --limit-debug-consistency-checks and --output-json-files (in that order),"
+                << ", argc = " << argc << ", limit_debug_consistency_checks = " << (limit_debug_consistency_checks ? "true" : "false") << ", output_json_files = " << (output_json_files ? "true" : "false") << std::endl;
+      return 0;
+    }
+
+  int MPI_RANK = 0;
+#ifdef WB_WITH_MPI
+  int MPI_SIZE = 1;
+  MPI_Init(&argc,&argv);
+  MPI_Comm_rank(MPI_COMM_WORLD, &MPI_RANK);
+  MPI_Comm_size(MPI_COMM_WORLD, &MPI_SIZE);
+#endif
+
+  if (MPI_RANK == 0)
+    {
+      wb_file = argv[1];
+      data_file = argv[2];
+
+      /**
+       * Try to start the world builder
+       */
+      std::unique_ptr<WorldBuilder::World> world;
+      //try
+      {
+        const std::string output_dir = wb_file.substr(0,wb_file.find_last_of("/\\") + 1);
+        world = std::make_unique<WorldBuilder::World>(wb_file, output_json_files, output_dir,1,limit_debug_consistency_checks);
+      }
+      /*catch (std::exception &e)
+        {
+          std::cerr << "Could not start the World builder, error: " << e.what() << "\n";
+          return 1;
+        }
+      catch (...)
+        {
+          std::cerr << "Exception of unknown type!\n";
+          return 1;
+        }*/
+
+
+      /**
+       * Read the data from the data files
+       */
+      std::ifstream data_stream(data_file);
+
+      // move the data into a vector of strings
+      std::vector<std::vector<std::string> > data;
+      std::string temp;
+
+      while (std::getline(data_stream, temp))
+        {
+          std::istringstream buffer(temp);
+          std::vector<std::string> line((std::istream_iterator<std::string>(buffer)),
+                                        std::istream_iterator<std::string>());
+
+          // remove the comma's in case it is a comma separated file.
+          // TODO: make it split for comma's and/or spaces
+          for (auto &line_i : line)
+            line_i.erase(std::remove(line_i.begin(), line_i.end(), ','), line_i.end());
+
+          data.push_back(line);
+        }
+
+      // Read config from data if present
+      for (auto &line_i : data)
+        {
+          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "dim" && line_i[2] == "=")
+            {
+              dim = string_to_unsigned_int(line_i[3]);
+            }
+
+          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "compositions" && line_i[2] == "=")
+            compositions = string_to_unsigned_int(line_i[3]);
+
+          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "grain" && line_i[2] == "compositions" && line_i[3] == "=")
+            grain_compositions = string_to_unsigned_int(line_i[4]);
+
+          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "number" && line_i[2] == "of" && line_i[3] == "grains" && line_i[4] == "=")
+            n_grains = string_to_unsigned_int(line_i[5]);
+
+          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "convert" && line_i[2] == "spherical" && line_i[3] == "=" && line_i[4] == "true")
+            convert_spherical = true;
+        }
+
+      // set properties
+      std::vector<std::array<unsigned ,3>> properties;
+      properties.push_back({{1,0,0}}); // temperature
+
+      for (size_t c = 0; c < compositions; ++c)
+        properties.push_back({{2,static_cast<unsigned int>(c),0}}); // composition c
+
+      for (size_t gc = 0; gc < grain_compositions; ++gc)
+        properties.push_back({{3,static_cast<unsigned int>(gc),static_cast<unsigned int>(n_grains)}}); // grains gc
+
+      properties.push_back({{4,0,0}}); // tag
+
+
+      switch (dim)
+        {
+          case 2:
+            WBAssertThrow(!convert_spherical, "Converting to spherical values is only available in 3D.");
+            // set the header
+            std::cout << "# x z d T ";
+
+            for (unsigned int c = 0; c < compositions; ++c)
+              std::cout << 'c' << c << ' ';
+
+            for (unsigned int gc = 0; gc < grain_compositions; ++gc)
+              for (size_t g = 0; g < n_grains; g++)
+                std::cout << "gs" << gc << '-' << g << ' ' // gs = grain size, gm = grain rotation matrix
+                          << "gm" << gc << '-' << g << "[0:0] " << "gm" << gc << '-' << g << "[0:1] " << "gm" << gc << '-' << g << "[0:2] "
+                          << "gm" << gc << '-' << g << "[1:0] " << "gm" << gc << '-' << g << "[1:1] " << "gm" << gc << '-' << g << "[1:2] "
+                          << "gm" << gc << '-' << g << "[2:0] " << "gm" << gc << '-' << g << "[2:1] " << "gm" << gc << '-' << g << "[2:2] ";
+
+            std::cout << "tag ";
+            std::cout <<std::endl;
+
+            // set the values
+            for (unsigned int i = 0; i < data.size(); ++i)
+              if (data[i].size() > 0 && data[i][0] != "#")
+                {
+
+                  WBAssertThrow(data[i].size() == dim + 1, "The file needs to contain dim + 1 entries, but contains " << data[i].size() << " entries "
+                                " on line " << i+1 << " of the data file (" << data_file << ").  Dim is " << dim << '.');
+                  const std::array<double,2> coords = {{
+                      string_to_double(data[i][0]),
+                      string_to_double(data[i][1])
+                    }
+                  };
+                  std::cout << data[i][0] << ' ' << data[i][1] << ' ' << data[i][2] << ' ';
+                  std::vector<double> output = world->properties(coords, string_to_double(data[i][2]),properties);
+                  std::cout << output[0]  << ' ';
+
+                  for (unsigned int c = 0; c < compositions; ++c)
+                    {
+                      std::cout << output[1+c]  << ' ';
+                    }
+
+                  for (unsigned int gc = 0; gc < grain_compositions; ++gc)
+                    {
+                      const size_t start = 1+compositions+gc*n_grains*10;
+                      for (unsigned int g = 0; g < n_grains; ++g)
+                        {
+                          std::cout << output[start+g]  << ' '
+                                    << output[start+n_grains+g*9] << ' ' << output[start+n_grains+g*9+1] << ' ' << output[start+n_grains+g*9+2] << ' '
+                                    << output[start+n_grains+g*9+3] << ' ' << output[start+n_grains+g*9+4] << ' ' << output[start+n_grains+g*9+5] << ' '
+                                    << output[start+n_grains+g*9+6] << ' ' << output[start+n_grains+g*9+7] << ' ' << output[start+n_grains+g*9+8] << ' ';
+
+                        }
+                    }
+                  std::cout << " " << output[output.size()-1] << std::endl;
+
+                }
+            break;
+          case 3:
+            // set the header
+            std::cout << "# x y z d g T ";
+
+            for (unsigned int c = 0; c < compositions; ++c)
+              std::cout << 'c' << c << ' ';
+
+            for (unsigned int gc = 0; gc < grain_compositions; ++gc)
+              for (size_t g = 0; g < n_grains; g++)
+                std::cout << "gs" << gc << '-' << g << ' ' // gs = grain size, gm = grain rotation matrix
+                          << "gm" << gc << '-' << g << "[0:0] " << "gm" << gc << '-' << g << "[0:1] " << "gm" << gc << '-' << g << "[0:2] "
+                          << "gm" << gc << '-' << g << "[1:0] " << "gm" << gc << '-' << g << "[1:1] " << "gm" << gc << '-' << g << "[1:2] "
+                          << "gm" << gc << '-' << g << "[2:0] " << "gm" << gc << '-' << g << "[2:1] " << "gm" << gc << '-' << g << "[2:2] ";
+
+            std::cout << "tag ";
+            std::cout <<std::endl;
+
+            // set the values
+            for (unsigned int i = 0; i < data.size(); ++i)
+              if (data[i].size() > 0 && data[i][0] != "#")
+                {
+                  WBAssertThrow(data[i].size() == dim + 1, "The file needs to contain dim + 1 entries, but contains " << data[i].size() << " entries "
+                                " on line " << i+1 << " of the data file (" << data_file << "). Dim is " << dim << '.');
+                  std::array<double,3> coords = {{
+                      string_to_double(data[i][0]), // x or R
+                      string_to_double(data[i][1]) *(convert_spherical ? (WorldBuilder::Consts::PI/180.): 1.), // y or long
+                      string_to_double(data[i][2]) *(convert_spherical ? (WorldBuilder::Consts::PI/180.): 1.) // z or lat
+                    }
+                  };
+
+                  if (convert_spherical)
+                    {
+                      coords = spherical_to_cartesian_coordinates(coords).get_array();
+                    }
+
+                  std::cout << data[i][0] << ' ' << data[i][1] << ' ' << data[i][2] << ' ' << data[i][3] << ' ';
+                  std::vector<double> output = world->properties(coords, string_to_double(data[i][3]),properties);
+                  std::cout << output[0]  << ' ';
+
+                  for (unsigned int c = 0; c < compositions; ++c)
+                    {
+                      std::cout << output[1+c]  << ' ';
+                    }
+
+                  for (unsigned int gc = 0; gc < grain_compositions; ++gc)
+                    {
+                      const size_t start = 1+compositions+gc*n_grains*10;
+                      for (unsigned int g = 0; g < n_grains; ++g)
+                        {
+                          std::cout << output[start+g]  << ' '
+                                    << output[start+n_grains+g*9] << ' ' << output[start+n_grains+g*9+1] << ' ' << output[start+n_grains+g*9+2] << ' '
+                                    << output[start+n_grains+g*9+3] << ' ' << output[start+n_grains+g*9+4] << ' ' << output[start+n_grains+g*9+5] << ' '
+                                    << output[start+n_grains+g*9+6] << ' ' << output[start+n_grains+g*9+7] << ' ' << output[start+n_grains+g*9+8] << ' ';
+
+                        }
+                    }
+                  std::cout << " " << output[output.size()-1] << std::endl;
+
+                }
+            break;
+          default:
+            std::cout << "The World Builder can only be run in 2d and 3d but a different space dimension " << std::endl
+                      << "is given: dim = " << dim << '.';
+
+#ifdef WB_WITH_MPI
+            MPI_Finalize();
+#endif
+            return 0;
+        }
+    }
+#ifdef WB_WITH_MPI
+  MPI_Finalize();
+#endif
+  return 0;
+}
diff --git a/contrib/world_builder/source/gwb-grid/main.cc.bak b/contrib/world_builder/source/gwb-grid/main.cc.bak
new file mode 100644
index 00000000000..a8b931b31a0
--- /dev/null
+++ b/contrib/world_builder/source/gwb-grid/main.cc.bak
@@ -0,0 +1,1672 @@
+/*
+  Copyright (C) 2018 - 2021 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+/**
+ * Much of this code was based on GHOST (https://github.com/cedrict/GHOST),
+ * and was contribute to the World Builder with the permission and help of
+ * the author of GHOST.
+ */
+
+#include "visualization/main.h"
+
+#include "world_builder/assert.h"
+#include "world_builder/coordinate_system.h"
+#include "world_builder/nan.h"
+#include "world_builder/point.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+#include "world_builder/config.h"
+
+#include <algorithm>
+#include <limits>
+
+
+#include "vtu11/vtu11.hpp"
+#undef max
+#undef min
+
+#ifdef WB_WITH_MPI
+// we don't need the c++ MPI wrappers
+#define OMPI_SKIP_MPICXX 1
+#define MPICH_SKIP_MPICXX
+#include <mpi.h>
+#endif
+
+#ifndef NDEBUG
+#ifdef WB_USE_FP_EXCEPTIONS
+#include <cfenv>
+#endif
+#endif
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <iostream>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+using namespace WorldBuilder;
+using namespace WorldBuilder::Utilities;
+
+
+
+/**
+ * Filter the cells of a VTU mesh based on a given tag. All tags with smaller value than @p first_tag will be removed
+ */
+void filter_vtu_mesh(int dim,
+                     const std::vector<bool> &include_tag,
+                     vtu11::Vtu11UnstructuredMesh &input_mesh,
+                     const std::vector<vtu11::DataSetData> &input_data,
+                     vtu11::Vtu11UnstructuredMesh &output_mesh,
+                     std::vector<vtu11::DataSetData> &output_data);
+
+void filter_vtu_mesh(int dim,
+                     const std::vector<bool> &include_tag,
+                     vtu11::Vtu11UnstructuredMesh &input_mesh,
+                     const std::vector<vtu11::DataSetData> &input_data,
+                     vtu11::Vtu11UnstructuredMesh &output_mesh,
+                     std::vector<vtu11::DataSetData> &output_data)
+{
+  output_data.resize(input_data.size());
+  const std::int64_t invalid = -1;
+  std::vector<std::int64_t> vertex_index_map(input_mesh.points().size(), invalid);
+
+  const unsigned int n_vert_per_cell = (dim==3)?8:4;
+
+  const std::size_t n_cells = input_mesh.types().size();
+  std::uint64_t dst_cellid = 0;
+  for (std::size_t cellidx = 0; cellidx <n_cells; ++cellidx)
+    {
+      int highest_tag = -1;
+      for (size_t idx=cellidx*n_vert_per_cell; idx<(cellidx+1)*n_vert_per_cell; ++idx)
+        {
+          const std::size_t src_vid = static_cast<size_t>(input_mesh.connectivity()[idx]);
+          highest_tag = std::max(highest_tag,static_cast<int>(input_data[2][src_vid]));
+        }
+      if (highest_tag < 0 || include_tag[static_cast<size_t>(highest_tag)]==false)
+        continue;
+
+      ++dst_cellid;
+
+      for (size_t idx=cellidx*n_vert_per_cell; idx<(cellidx+1)*n_vert_per_cell; ++idx)
+        {
+          const size_t src_vid = static_cast<size_t>(input_mesh.connectivity()[idx]);
+
+          std::int64_t dst_vid = vertex_index_map[src_vid];
+          if (dst_vid == invalid)
+            {
+              dst_vid = static_cast<std::int64_t>(output_mesh.points().size()/3);
+              vertex_index_map[src_vid] = dst_vid;
+
+              for (unsigned int i=0; i<3; ++i)
+                output_mesh.points().push_back(input_mesh.points()[src_vid*3+i]);
+
+              for (unsigned int d=0; d<input_data.size(); ++d)
+                output_data[d].push_back(input_data[d][src_vid]);
+            }
+
+          output_mesh.connectivity().push_back(dst_vid);
+
+        }
+      output_mesh.offsets().push_back(static_cast<long int>(dst_cellid*n_vert_per_cell));
+
+      output_mesh.types().push_back(input_mesh.types()[cellidx]);
+    }
+}
+
+/**
+ * A very simple threadpool class. The threadpool currently only supports a
+ * parallel for function, to easily parallelize the for function.
+ *
+ * Todo: might need something more advanced and safe in the future.
+ */
+class ThreadPool
+{
+  public:
+
+    /**
+     * Constructor
+     */
+    explicit ThreadPool(size_t number_of_threads)
+    {
+      pool.resize(number_of_threads);
+    }
+
+    /**
+     * A function which allows to parallelize for loops.
+     */
+    template<typename Callable>
+    void parallel_for(size_t start, size_t end, Callable func)
+    {
+      // Determine the size of the slice for the loop
+      const size_t n = end - start + 1;
+      size_t slice = static_cast<size_t>(std::round(n / static_cast<size_t>((pool.size()))));
+      slice = std::max(slice, static_cast<size_t>(1));
+
+      // Function which loops the passed function func
+      auto loop_function = [&func] (size_t k1, size_t k2)
+      {
+        for (size_t k = k1; k < k2; k++)
+          {
+            func(k);
+          }
+      };
+
+      // Launch jobs
+      size_t i1 = start;
+      size_t i2 = std::min(start + slice, end);
+      for (size_t i = 0; i + 1 < pool.size() && i1 < end; ++i)
+        {
+          pool[i] = std::thread(loop_function, i1, i2);
+          i1 = i2;
+          i2 = std::min(i2 + slice, end);
+        }
+      if (i1 < end)
+        {
+          pool[pool.size()-1] = std::thread(loop_function, i1, end);
+        }
+
+      // Wait for jobs to finish
+      for (std::thread &t : pool)
+        {
+          if (t.joinable())
+            {
+              t.join();
+            }
+        }
+    }
+
+  private:
+    std::vector<std::thread> pool;
+
+};
+
+
+void project_on_sphere(double radius, double &x_, double &y_, double &z_)
+{
+  double x = x_;
+  double y = y_;
+  double z = z_;
+  const WorldBuilder::Point<3> in_point(std::array<double,3> {{x,y,z}}, WorldBuilder::CoordinateSystem::cartesian);
+  const WorldBuilder::Point<3> output_point(std::array<double,3> {{0,0,0}}, WorldBuilder::CoordinateSystem::cartesian);
+  const double r = in_point.norm();
+  const double theta = std::atan2(in_point[1],in_point[0]);
+  const double phi = std::acos(in_point[2]/r);
+
+  x_ = radius * std::cos(theta) * std::sin(phi);
+  y_ = radius * std::sin(theta) * std::sin(phi);
+  z_ = radius * std::cos(phi);
+
+}
+
+void lay_points(double x1, double y1, double z1,
+                double x2, double y2, double z2,
+                double x3, double y3, double z3,
+                double x4, double y4, double z4,
+                std::vector<double> &x, std::vector<double> &y, std::vector<double> &z,
+                std::vector<bool> &hull, size_t level)
+{
+  // TODO: Assert that the vectors have the correct size;
+  size_t counter = 0;
+  for (size_t j = 0; j < level+1; ++j)
+    {
+      for (size_t i = 0; i < level+1; ++i)
+        {
+          // equidistant (is this irrelevant?)
+          // double r = -1.0 + (2.0 / level) * i;
+          // double s = -1.0 + (2.0 / level) * j;
+
+          // equiangular
+          const double pi4 = Consts::PI*0.25;
+          const double x0 = -pi4 + static_cast<double>(i) * 2.0 * static_cast<double>(pi4)/static_cast<double>(level);
+          const double y0 = -pi4 + static_cast<double>(j) * 2.0 * static_cast<double>(pi4)/static_cast<double>(level);
+          const double r = std::tan(x0);
+          const double s = std::tan(y0);
+
+
+          const double N1 = 0.25 * (1.0 - r) * (1.0 - s);
+          const double N2 = 0.25 * (1.0 + r) * (1.0 - s);
+          const double N3 = 0.25 * (1.0 + r) * (1.0 + s);
+          const double N4 = 0.25 * (1.0 - r) * (1.0 + s);
+
+          x[counter] = x1 * N1 + x2 * N2 + x3 * N3 + x4 * N4;
+          y[counter] = y1 * N1 + y2 * N2 + y3 * N3 + y4 * N4;
+          z[counter] = z1 * N1 + z2 * N2 + z3 * N3 + z4 * N4;
+
+          if (i == 0) hull[counter] = true;
+          if (j == 0) hull[counter] = true;
+          if (i == level) hull[counter] = true;
+          if (j == level) hull[counter] = true;
+          counter++;
+        }
+    }
+}
+
+
+std::vector<std::string> get_command_line_options_vector(int argc, char **argv)
+{
+  std::vector<std::string> vector;
+  for (int i=1; i < argc; ++i)
+    vector.emplace_back(argv[i]);
+
+  return vector;
+}
+
+bool find_command_line_option(char **begin, char **end, const std::string &option)
+{
+  return std::find(begin, end, option) != end;
+}
+
+int main(int argc, char **argv)
+{
+
+#ifndef NDEBUG
+#ifdef WB_USE_FP_EXCEPTIONS
+  // Some implementations seem to not initialize the floating point exception
+  // bits to zero. Make sure we start from a clean state.
+  feclearexcept(FE_DIVBYZERO|FE_INVALID);
+
+  // enable floating point exceptions
+  feenableexcept(FE_DIVBYZERO|FE_INVALID);
+#endif
+#endif
+
+  /**
+   * First parse the command line options
+   */
+  std::string wb_file;
+  std::string data_file;
+
+  // If set to true, we will output one visualization file per "tag"
+  // with only the cells corresponding to that tag included.
+  bool output_by_tag = false;
+  // If set to true, we output a .filtered.vtu file without the background/mantle
+  bool output_filtered = false;
+
+  size_t dim = 3;
+  size_t compositions = 0;
+
+  // common
+  std::string grid_type = "chunk";
+
+  size_t n_cell_x = NaN::ISNAN; // x or long
+  size_t n_cell_y = NaN::ISNAN; // y or lat
+  size_t n_cell_z = NaN::ISNAN; // z or depth
+
+
+  // spherical
+  double x_min = NaN::DSNAN;  // x or long
+  double x_max = NaN::DSNAN;  // x or long
+  double y_min = NaN::DSNAN; // y or lat
+  double y_max = NaN::DSNAN; // y or lat
+  double z_min = NaN::DSNAN; // z or inner_radius
+  double z_max = NaN::DSNAN; // z or outer_radius
+
+  // Conservative choice for the number of threads to use:
+  size_t number_of_threads = std::min(20u,1+std::thread::hardware_concurrency()/2);
+  unsigned int max_resolution = std::numeric_limits<unsigned int>::max();
+
+  try
+    {
+      if (find_command_line_option(argv, argv+argc, "-v") || find_command_line_option(argv, argv+argc, "--version"))
+        {
+          std::cout << "World Builder Grid Visualization tool.\n"
+                    << "GWB Version: " << WorldBuilder::Version::MAJOR << "."
+                    << WorldBuilder::Version::MINOR << "."
+                    << WorldBuilder::Version::PATCH << "."
+                    << WorldBuilder::Version::LABEL << "\n"
+                    << "git hash: " << WorldBuilder::Version::GIT_SHA1 << " branch: " << WorldBuilder::Version::GIT_BRANCH
+                    << std::endl;
+          return 0;
+        }
+
+      if (find_command_line_option(argv, argv+argc, "-h") || find_command_line_option(argv, argv+argc, "--help"))
+        {
+          std::cout << "World Builder Grid Visualization tool.\n"
+                    <<  "This program loads a world builder file and generates a visualization on a structured grid "
+                    << "based on information specified in a separate .grid configuration file.\n\n"
+                    << "Usage:\n"
+                    << argv[0] << " [-j N] [--filtered] [--by-tag] example.wb example.grid\n\n"
+                    << "Available options:\n"
+                    << "  -j N                  Specify the number of threads the visualizer is allowed to use. Default: " << number_of_threads << ".\n"
+                    << "  --filtered            Also produce a .filtered.vtu that removes cells only containing mantle or background.\n"
+                    << "  --by-tag              Also produce a sequence of .N.vtu files that only contain cells of a specific tag.\n"
+                    << "  --resolution-limit X  Specify a maximum resolution."
+                    << "  -h or --help          To get this help screen.\n"
+                    << "  -v or --version       To see version information.\n";
+          return 0;
+        }
+
+      std::vector<std::string> options_vector = get_command_line_options_vector(argc, argv);
+
+      for (size_t i = 0; i < options_vector.size(); ++i)
+        {
+          if (options_vector[i] == "-j")
+            {
+              number_of_threads = Utilities::string_to_unsigned_int(options_vector[i+1]);
+              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
+              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
+              --i;
+              continue;
+            }
+          if (options_vector[i] == "--filtered")
+            {
+              output_filtered = true;
+              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
+              --i;
+              continue;
+            }
+          if (options_vector[i] == "--by-tag")
+            {
+              output_by_tag = true;
+              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
+              --i;
+              continue;
+            }
+          if (options_vector[i] == "--resolution-limit")
+            {
+              max_resolution = Utilities::string_to_unsigned_int(options_vector[i+1]);
+              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
+              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
+              --i;
+              continue;
+            }
+        }
+
+      if (options_vector.size() != 2)
+        {
+          std::cout << "World Builder Grid Visualization tool.\n"
+                    << "Usage: " << argv[0] << " example.wb example.grid\n"
+                    << "Try '" << argv[0] << " --help' for more information." << std::endl;
+          return 0;
+        }
+
+
+      wb_file = options_vector[0];
+      data_file = options_vector[1];
+
+    }
+  catch (std::exception &e)
+    {
+      std::cerr << "error: " << e.what() << "\n";
+      return 1;
+    }
+  catch (...)
+    {
+      std::cerr << "Exception of unknown type!\n";
+      return 1;
+    }
+
+
+  int MPI_RANK = 0;
+#ifdef WB_WITH_MPI
+  MPI_Init(&argc,&argv);
+  MPI_Comm_rank(MPI_COMM_WORLD, &MPI_RANK);
+#endif
+
+  std::cout << "[1/6] Parsing file...                         \r";
+
+  if (MPI_RANK ==  0)
+    {
+      /**
+       * Try to start the world builder
+       */
+      std::cout << "[2/6] Starting the world builder with " << number_of_threads << " threads...                         \r";
+      std::cout.flush();
+
+      std::unique_ptr<WorldBuilder::World> world;
+      try
+        {
+          world = std::make_unique<WorldBuilder::World>(wb_file);
+        }
+      catch (std::exception &e)
+        {
+          std::cerr << "Could not start the World builder from file '" << wb_file << "', error: " << e.what() << "\n";
+
+#ifdef WB_WITH_MPI
+          MPI_Finalize();
+#endif
+          return 1;
+        }
+      catch (...)
+        {
+          std::cerr << "Exception of unknown type!\n";
+
+#ifdef WB_WITH_MPI
+          MPI_Finalize();
+#endif
+          return 1;
+        }
+
+      /**
+       * start the thread pool
+       */
+      ThreadPool pool(number_of_threads);
+
+      /**
+       * Read the data from the data files
+       */
+      std::cout << "[3/6] Reading grid file...                        \r";
+      std::cout.flush();
+
+
+      std::ifstream data_stream(data_file);
+
+      // if config file is available, parse it
+      WBAssertThrow(data_stream.good(),
+                    "Could not find the provided config file at the specified location: " + data_file);
+
+
+      // move the data into a vector of strings
+      std::vector<std::vector<std::string> > data;
+      std::string temp;
+
+      while (std::getline(data_stream, temp))
+        {
+          std::istringstream buffer(temp);
+          std::vector<std::string> line((std::istream_iterator<std::string>(buffer)),
+                                        std::istream_iterator<std::string>());
+
+          // remove the comma's in case it is a comma separated file.
+          // TODO: make it split for comma's and/or spaces
+          for (auto &line_i : line)
+            line_i.erase(std::remove(line_i.begin(), line_i.end(), ','), line_i.end());
+
+          data.push_back(line);
+        }
+
+      std::string vtu_output_format = "RawBinaryCompressed";
+      // Read config from data if present
+      for (auto &line_i : data)
+        {
+          if (line_i.empty())
+            continue;
+
+          if (line_i[0] == "#")
+            continue;
+
+          if (line_i[0] == "grid_type" && line_i[1] == "=")
+            {
+              grid_type = line_i[2];
+            }
+
+          if (line_i[0] == "dim" && line_i[1] == "=")
+            {
+              dim = string_to_unsigned_int(line_i[2]);
+            }
+
+          if (line_i[0] == "vtu_output_format" && line_i[1] == "=")
+            {
+              vtu_output_format = line_i[2];
+            }
+
+          if (line_i[0] == "compositions" && line_i[1] == "=")
+            compositions = string_to_unsigned_int(line_i[2]);
+
+          if (line_i[0] == "x_min" && line_i[1] == "=")
+            x_min = string_to_double(line_i[2]);
+          if (line_i[0] == "x_max" && line_i[1] == "=")
+            x_max = string_to_double(line_i[2]);
+          if (line_i[0] == "y_min" && line_i[1] == "=")
+            y_min = string_to_double(line_i[2]);
+          if (line_i[0] == "y_max" && line_i[1] == "=")
+            y_max = string_to_double(line_i[2]);
+          if (line_i[0] == "z_min" && line_i[1] == "=")
+            z_min = string_to_double(line_i[2]);
+          if (line_i[0] == "z_max" && line_i[1] == "=")
+            z_max = string_to_double(line_i[2]);
+
+          if (line_i[0] == "n_cell_x" && line_i[1] == "=")
+            n_cell_x = std::min(string_to_unsigned_int(line_i[2]),max_resolution);
+          if (line_i[0] == "n_cell_y" && line_i[1] == "=")
+            n_cell_y = std::min(string_to_unsigned_int(line_i[2]),max_resolution);
+          if (line_i[0] == "n_cell_z" && line_i[1] == "=")
+            n_cell_z = std::min(string_to_unsigned_int(line_i[2]),max_resolution);
+
+        }
+
+      WBAssertThrow(dim == 2 || dim == 3, "dim should be set in the grid file and can only be 2 or 3.");
+
+      WBAssertThrow(!std::isnan(x_min), "x_min is not a number:" << x_min << ". This value has probably not been provided in the grid file.");
+      WBAssertThrow(!std::isnan(x_max), "x_max is not a number:" << x_max << ". This value has probably not been provided in the grid file.");
+      WBAssertThrow(dim == 2 || !std::isnan(y_min), "y_min is not a number:" << y_min << ". This value has probably not been provided in the grid file.");
+      WBAssertThrow(dim == 2 || !std::isnan(y_max), "y_max is not a number:" << y_max << ". This value has probably not been provided in the grid file.");
+      WBAssertThrow(!std::isnan(z_min), "z_min is not a number:" << z_min << ". This value has probably not been provided in the grid file.");
+      WBAssertThrow(!std::isnan(z_max), "z_max is not a number:" << z_max << ". This value has probably not been provided in the grid file.");
+
+
+      WBAssertThrow(n_cell_x != 0, "n_cell_z may not be equal to zero: " << n_cell_x << '.');
+      // int's cannot generally be nan's (see https://stackoverflow.com/questions/3949457/can-an-integer-be-nan-in-c),
+      // but visual studio is giving problems over this, so it is taken out for now.
+      //WBAssertThrow(!std::isnan(n_cell_x), "n_cell_z is not a number:" << n_cell_x << '.');
+
+      WBAssertThrow(dim == 3 || n_cell_z != 0, "In 3d n_cell_z may not be equal to zero: " << n_cell_y << '.');
+      // int's cannot generally be nan's (see https://stackoverflow.com/questions/3949457/can-an-integer-be-nan-in-c),
+      // but visual studio is giving problems over this, so it is taken out for now.
+      //WBAssertThrow(!std::isnan(n_cell_z), "n_cell_z is not a number:" << n_cell_y << '.');
+
+      WBAssertThrow(n_cell_z != 0, "n_cell_z may not be equal to zero: " << n_cell_z << '.');
+      // int's cannot generally be nan's (see https://stackoverflow.com/questions/3949457/can-an-integer-be-nan-in-c),
+      // but visual studio is giving problems over this, so it is taken out for now.
+      //WBAssertThrow(!std::isnan(n_cell_z), "n_cell_z is not a number:" << n_cell_z << '.');
+
+
+
+
+
+      /**
+       * All variables set by the user
+       */
+
+      if (grid_type == "sphere")
+        WBAssert(n_cell_x == n_cell_y, "For the sphere grid the amount of cells in the x (long) and y (lat) direction have to be the same.");
+
+      if (grid_type == "spherical" ||
+          grid_type == "chunk" ||
+          grid_type == "annulus")
+        {
+          x_min *= (Consts::PI/180);
+          x_max *= (Consts::PI/180);
+          y_min *= (Consts::PI/180);
+          y_max *= (Consts::PI/180);
+        }
+
+
+
+      /**
+       * All variables needed for the visualization
+       */
+      size_t n_cell = NaN::ISNAN;
+      size_t n_p = NaN::ISNAN;
+
+      std::vector<double> grid_x(0);
+      std::vector<double> grid_y(0);
+      std::vector<double> grid_z(0);
+      std::vector<double> grid_depth(0);
+
+      std::vector<std::vector<size_t> > grid_connectivity(0);
+
+
+      const bool compress_size = true;
+
+
+
+
+      /**
+       * Begin making the grid
+       */
+      std::cout << "[4/6] Building the grid...                        \r";
+      std::cout.flush();
+      WBAssertThrow(dim == 2 || dim == 3, "Dimension should be 2d or 3d.");
+      if (grid_type == "cartesian")
+        {
+          n_cell = n_cell_x * n_cell_z * (dim == 3 ? n_cell_y : 1);
+          if (!compress_size && dim == 3)
+            n_p = n_cell * 8 ; // it shouldn't matter for 2d in the output, so just do 3d.
+          else
+            n_p = (n_cell_x + 1) * (n_cell_z + 1) * (dim == 3 ? (n_cell_y + 1) : 1);
+
+
+          const double dx = (x_max - x_min) / static_cast<double>(n_cell_x);
+          const double dy = dim == 2 ? 0 : (y_max - y_min) / static_cast<double>(n_cell_y);
+          const double dz = (z_max - z_min) / static_cast<double>(n_cell_z);
+
+
+          WBAssertThrow(!std::isnan(dx), "dz is not a number:" << dz << '.');
+          WBAssertThrow(dim == 2 || !std::isnan(dy), "dz is not a number:" << dz << '.');
+          WBAssertThrow(!std::isnan(dz), "dz is not a number:" << dz << '.');
+
+          // todo: determine whether a input variable is desirable for this.
+          const double surface = z_max;
+
+          grid_x.resize(n_p);
+          grid_z.resize(n_p);
+
+          if (dim == 3)
+            grid_y.resize(n_p);
+
+          grid_depth.resize(n_p);
+
+          // compute positions
+          size_t counter = 0;
+          if (dim == 2)
+            {
+              for (size_t j = 0; j <= n_cell_z; ++j)
+                {
+                  for (size_t i = 0; i <= n_cell_x; ++i)
+                    {
+                      grid_x[counter] = x_min + static_cast<double>(i) * dx;
+                      grid_z[counter] = z_min + static_cast<double>(j) * dz;
+                      grid_depth[counter] = (surface - z_min) - static_cast<double>(j) * dz;
+                      counter++;
+                    }
+                }
+            }
+          else
+            {
+              if (compress_size)
+                {
+                  for (size_t i = 0; i <= n_cell_x; ++i)
+                    {
+                      for (size_t j = 0; j <= n_cell_y; ++j)
+                        {
+                          for (size_t k = 0; k <= n_cell_z; ++k)
+                            {
+                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
+                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
+                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
+                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
+                              counter++;
+                            }
+                        }
+                    }
+                }
+              else
+                {
+                  for (size_t i = 0; i < n_cell_x; ++i)
+                    {
+                      for (size_t j = 0; j < n_cell_y; ++j)
+                        {
+                          for (size_t k = 0; k < n_cell_z; ++k)
+                            {
+                              // position is defined by the vtk file format
+                              // position 0 of this cell
+                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
+                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
+                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
+                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
+                              counter++;
+                              // position 1 of this cell
+                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dx;
+                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
+                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
+                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
+                              counter++;
+                              // position 2 of this cell
+                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dx;
+                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dy;
+                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
+                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
+                              counter++;
+                              // position 3 of this cell
+                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
+                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dy;
+                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
+                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
+                              counter++;
+                              // position 0 of this cell
+                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
+                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
+                              grid_z[counter] = z_min + (static_cast<double>(k) + 1.0) * dz;
+                              grid_depth[counter] = (surface - z_min) - (static_cast<double>(k) + 1.0) * dz;
+                              counter++;
+                              // position 1 of this cell
+                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dx;
+                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
+                              grid_z[counter] = z_min + (static_cast<double>(k) + 1.0) * dz;
+                              grid_depth[counter] = (surface - z_min) - (static_cast<double>(k) + 1.0) * dz;
+                              counter++;
+                              // position 2 of this cell
+                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dx;
+                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dy;
+                              grid_z[counter] = z_min + (static_cast<double>(k) + 1.0) * dz;
+                              grid_depth[counter] = (surface - z_min) - (static_cast<double>(k) + 1.0) * dz;
+                              counter++;
+                              // position 3 of this cell
+                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
+                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dy;
+                              grid_z[counter] = z_min + (static_cast<double>(k) + 1.0) * dz;
+                              grid_depth[counter] = (surface - z_min) - (static_cast<double>(k) + 1.0) * dz;
+                              WBAssert(counter < n_p, "Assert counter smaller then n_P: counter = " << counter << ", n_p = " << n_p);
+                              counter++;
+                            }
+                        }
+                    }
+                }
+            }
+
+          // compute connectivity. Local to global mapping.
+          grid_connectivity.resize(n_cell,std::vector<size_t>((dim-1)*4));
+
+          counter = 0;
+          if (dim == 2)
+            {
+              for (size_t j = 1; j <= n_cell_z; ++j)
+                {
+                  for (size_t i = 1; i <= n_cell_x; ++i)
+                    {
+                      grid_connectivity[counter][0] = i + (j - 1) * (n_cell_x + 1) - 1;
+                      grid_connectivity[counter][1] = i + 1 + (j - 1) * (n_cell_x + 1) - 1;
+                      grid_connectivity[counter][2] = i + 1  + j * (n_cell_x + 1) - 1;
+                      grid_connectivity[counter][3] = i + j * (n_cell_x + 1) - 1;
+                      counter++;
+                    }
+                }
+            }
+          else
+            {
+              if (compress_size)
+                {
+                  for (size_t i = 1; i <= n_cell_x; ++i)
+                    {
+                      for (size_t j = 1; j <= n_cell_y; ++j)
+                        {
+                          for (size_t k = 1; k <= n_cell_z; ++k)
+                            {
+                              grid_connectivity[counter][0] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j - 1) + k - 1;
+                              grid_connectivity[counter][1] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j - 1) + k - 1;
+                              grid_connectivity[counter][2] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j    ) + k - 1;
+                              grid_connectivity[counter][3] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j    ) + k - 1;
+                              grid_connectivity[counter][4] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j - 1) + k;
+                              grid_connectivity[counter][5] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j - 1) + k;
+                              grid_connectivity[counter][6] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j    ) + k;
+                              grid_connectivity[counter][7] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j    ) + k;
+                              counter++;
+                            }
+                        }
+                    }
+                }
+              else
+                {
+                  for (size_t i = 0; i < n_cell; ++i)
+                    {
+                      grid_connectivity[i][0] = counter;
+                      grid_connectivity[i][1] = counter + 1;
+                      grid_connectivity[i][2] = counter + 2;
+                      grid_connectivity[i][3] = counter + 3;
+                      grid_connectivity[i][4] = counter + 4;
+                      grid_connectivity[i][5] = counter + 5;
+                      grid_connectivity[i][6] = counter + 6;
+                      grid_connectivity[i][7] = counter + 7;
+                      counter = counter + 8;
+                    }
+                }
+            }
+        }
+      else if (grid_type == "annulus")
+        {
+          /**
+           * An annulus which is a 2d hollow sphere.
+           * TODO: make it so you can determine your own cross section.
+           */
+          WBAssertThrow(dim == 2, "The annulus only works in 2d.");
+
+
+          const double inner_radius = z_min;
+          const double outer_radius = z_max;
+
+          const double l_outer = 2.0 * Consts::PI * outer_radius;
+
+          const double lr = outer_radius - inner_radius;
+          const double dr = lr / static_cast<double>(n_cell_z);
+
+          const size_t n_cell_t = static_cast<size_t>((2.0 * Consts::PI * outer_radius)/dr);
+
+          // compute the amount of cells
+          n_cell = n_cell_t *n_cell_z;
+          n_p = n_cell_t *(n_cell_z + 1);  // one less then cartesian because two cells overlap.
+
+          const double sx = l_outer / static_cast<double>(n_cell_t);
+          const double sz = dr;
+
+          grid_x.resize(n_p);
+          grid_z.resize(n_p);
+          grid_depth.resize(n_p);
+
+          size_t counter = 0;
+          for (size_t j = 0; j <= n_cell_z; ++j)
+            {
+              for (size_t i = 1; i <= n_cell_t; ++i)
+                {
+                  grid_x[counter] = (static_cast<double>(i) - 1.0) * sx;
+                  grid_z[counter] = static_cast<double>(j) * sz;
+                  counter++;
+                }
+            }
+
+          counter = 0;
+          for (size_t j = 1; j <= n_cell_z+1; ++j)
+            {
+              for (size_t i = 1; i <= n_cell_t; ++i)
+                {
+                  const double xi = grid_x[counter];
+                  const double zi = grid_z[counter];
+                  const double theta = xi / l_outer * 2.0 * Consts::PI;
+                  grid_x[counter] = std::cos(theta) * (inner_radius + zi);
+                  grid_z[counter] = std::sin(theta) * (inner_radius + zi);
+                  grid_depth[counter] = outer_radius - std::sqrt(grid_x[counter] * grid_x[counter] + grid_z[counter] * grid_z [counter]);
+                  grid_depth[counter] = (std::fabs(grid_depth[counter]) < 1e-8 ? 0 : grid_depth[counter]);
+                  counter++;
+                }
+            }
+
+          grid_connectivity.resize(n_cell,std::vector<size_t>(4));
+          counter = 0;
+          for (size_t j = 1; j <= n_cell_z; ++j)
+            {
+              for (size_t i = 1; i <= n_cell_t; ++i)
+                {
+                  std::vector<size_t> cell_connectivity(4);
+                  cell_connectivity[0] = counter + 1;
+                  cell_connectivity[1] = counter + 1 + 1;
+                  cell_connectivity[2] = i + j * n_cell_t + 1;
+                  cell_connectivity[3] = i + j * n_cell_t;
+                  if (i == n_cell_t)
+                    {
+                      cell_connectivity[1] = cell_connectivity[1] - n_cell_t;
+                      cell_connectivity[2] = cell_connectivity[2] - n_cell_t;
+                    }
+                  grid_connectivity[counter][0] = cell_connectivity[1] - 1;
+                  grid_connectivity[counter][1] = cell_connectivity[0] - 1;
+                  grid_connectivity[counter][2] = cell_connectivity[3] - 1;
+                  grid_connectivity[counter][3] = cell_connectivity[2] - 1;
+                  counter++;
+                }
+            }
+        }
+      else if (grid_type == "chunk")
+        {
+          const double inner_radius = z_min;
+          const double outer_radius = z_max;
+
+          WBAssertThrow(x_min <= x_max, "The minimum longitude must be less than the maximum longitude.");
+          WBAssertThrow(y_min <= y_max, "The minimum latitude must be less than the maximum latitude.");
+          WBAssertThrow(inner_radius < outer_radius, "The inner radius must be less than the outer radius.");
+
+          WBAssertThrow(x_min - x_max <= 2.0 * Consts::PI, "The difference between the minimum and maximum longitude "
+                        " must be less than or equal to 360 degree.");
+
+          WBAssertThrow(y_min >= - 0.5 * Consts::PI, "The minimum latitude must be larger then or equal to -90 degree.");
+          WBAssertThrow(y_min <= 0.5 * Consts::PI, "The maximum latitude must be smaller then or equal to 90 degree.");
+
+          const double opening_angle_long_rad = (x_max - x_min);
+          const double opening_angle_lat_rad =  (y_max - y_min);
+
+          n_cell = n_cell_x * n_cell_z * (dim == 3 ? n_cell_y : 1);
+          if (!compress_size && dim == 3)
+            n_p = n_cell * 8 ; // it shouldn't matter for 2d in the output, so just do 3d.
+          else
+            n_p = (n_cell_x + 1) * (n_cell_z + 1) * (dim == 3 ? (n_cell_y + 1) : 1);
+
+          const double dlong = opening_angle_long_rad / static_cast<double>(n_cell_x);
+          const double dlat = dim == 3 ? opening_angle_lat_rad / static_cast<double>(n_cell_y) : 0.;
+          const double lr = outer_radius - inner_radius;
+          const double dr = lr / static_cast<double>(n_cell_z);
+
+          grid_x.resize(n_p);
+          grid_y.resize(dim == 3 ? n_p : 0);
+          grid_z.resize(n_p);
+          grid_depth.resize(n_p);
+
+          std::cout << "[4/6] Building the grid: stage 1 of 3                        \r";
+          std::cout.flush();
+          size_t counter = 0;
+          if (dim == 2)
+            {
+              for (size_t i = 1; i <= n_cell_x + 1; ++i)
+                for (size_t j = 1; j <= n_cell_z + 1; ++j)
+                  {
+                    grid_x[counter] = x_min + (static_cast<double>(i) - 1.0) * dlong;
+                    grid_z[counter] = inner_radius + (static_cast<double>(j) - 1.0) * dr;
+                    grid_depth[counter] = lr - (static_cast<double>(j) - 1.0) * dr;
+                    counter++;
+                  }
+            }
+          else
+            {
+              if (compress_size)
+                {
+                  for (size_t i = 1; i <= n_cell_x + 1; ++i)
+                    for (size_t j = 1; j <= n_cell_y + 1; ++j)
+                      for (size_t k = 1; k <= n_cell_z + 1; ++k)
+                        {
+                          grid_x[counter] = x_min + (static_cast<double>(i) - 1.0) * dlong;
+                          grid_y[counter] = y_min + (static_cast<double>(j) - 1.0) * dlat;
+                          grid_z[counter] = inner_radius + (static_cast<double>(k) - 1.0) * dr;
+                          grid_depth[counter] = lr - (static_cast<double>(k) - 1.0) * dr;
+                          counter++;
+                        }
+                }
+              else
+                {
+                  for (size_t i = 0; i < n_cell_x; ++i)
+                    {
+                      for (size_t j = 0; j < n_cell_y; ++j)
+                        {
+                          for (size_t k = 0; k < n_cell_z; ++k)
+                            {
+                              // position is defined by the vtk file format
+                              // position 0 of this cell
+                              grid_x[counter] = x_min + static_cast<double>(i) * dlong;
+                              grid_y[counter] = y_min + static_cast<double>(j) * dlat;
+                              grid_z[counter] = inner_radius + static_cast<double>(k) * dr;
+                              grid_depth[counter] = lr - static_cast<double>(k) * dr;
+                              counter++;
+                              // position 1 of this cell
+                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dlong;
+                              grid_y[counter] = y_min + static_cast<double>(j) * dlat;
+                              grid_z[counter] = inner_radius + static_cast<double>(k) * dr;
+                              grid_depth[counter] = lr - static_cast<double>(k) * dr;
+                              counter++;
+                              // position 2 of this cell
+                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dlong;
+                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dlat;
+                              grid_z[counter] = inner_radius + static_cast<double>(k) * dr;
+                              grid_depth[counter] = lr - static_cast<double>(k) * dr;
+                              counter++;
+                              // position 3 of this cell
+                              grid_x[counter] = x_min + static_cast<double>(i) * dlong;
+                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dlat;
+                              grid_z[counter] = inner_radius + static_cast<double>(k) * dr;
+                              grid_depth[counter] = lr - static_cast<double>(k) * dr;
+                              counter++;
+                              // position 0 of this cell
+                              grid_x[counter] = x_min + static_cast<double>(i) * dlong;
+                              grid_y[counter] = y_min + static_cast<double>(j) * dlat;
+                              grid_z[counter] = inner_radius + (static_cast<double>(k) + 1.0) * dr;
+                              grid_depth[counter] = lr - (static_cast<double>(k) + 1.0) * dr;
+                              counter++;
+                              // position 1 of this cell
+                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dlong;
+                              grid_y[counter] = y_min + static_cast<double>(j) * dlat;
+                              grid_z[counter] = inner_radius + (static_cast<double>(k) + 1.0) * dr;
+                              grid_depth[counter] = lr - (static_cast<double>(k) + 1.0) * dr;
+                              counter++;
+                              // position 2 of this cell
+                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dlong;
+                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dlat;
+                              grid_z[counter] = inner_radius + (static_cast<double>(k) + 1.0) * dr;
+                              grid_depth[counter] = lr - (static_cast<double>(k) + 1.0) * dr;
+                              counter++;
+                              // position 3 of this cell
+                              grid_x[counter] = x_min + static_cast<double>(i) * dlong;
+                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dlat;
+                              grid_z[counter] = inner_radius + (static_cast<double>(k) + 1.0) * dr;
+                              grid_depth[counter] = lr - (static_cast<double>(k) + 1.0) * dr;
+                              WBAssert(counter < n_p, "Assert counter smaller then n_P: counter = " << counter << ", n_p = " << n_p);
+                              counter++;
+                            }
+                        }
+                    }
+                }
+            }
+
+          std::cout << "[4/6] Building the grid: stage 2 of 3                        \r";
+          std::cout.flush();
+          if (dim == 2)
+            {
+              for (size_t i = 0; i < n_p; ++i)
+                {
+
+                  const double longitude = grid_x[i];
+                  const double radius = grid_z[i];
+
+                  grid_x[i] = radius * std::cos(longitude);
+                  grid_z[i] = radius * std::sin(longitude);
+                }
+            }
+          else
+            {
+              for (size_t i = 0; i < n_p; ++i)
+                {
+
+                  const double longitude = grid_x[i];
+                  const double latitutde = grid_y[i];
+                  const double radius = grid_z[i];
+
+                  grid_x[i] = radius * std::cos(latitutde) * std::cos(longitude);
+                  grid_y[i] = radius * std::cos(latitutde) * std::sin(longitude);
+                  grid_z[i] = radius * std::sin(latitutde);
+                }
+            }
+          std::cout << "[4/6] Building the grid: stage 3 of 3                        \r";
+          std::cout.flush();
+          // compute connectivity. Local to global mapping.
+          grid_connectivity.resize(n_cell,std::vector<size_t>((dim-1)*4));
+
+          counter = 0;
+          if (dim == 2)
+            {
+              for (size_t i = 1; i <= n_cell_x; ++i)
+                {
+                  for (size_t j = 1; j <= n_cell_z; ++j)
+                    {
+                      grid_connectivity[counter][0] = (n_cell_z + 1) * (i - 1) + j - 1;
+                      grid_connectivity[counter][1] = (n_cell_z + 1) * (i - 1) + j;
+                      grid_connectivity[counter][2] = (n_cell_z + 1) * (i    ) + j;
+                      grid_connectivity[counter][3] = (n_cell_z + 1) * (i    ) + j - 1;
+
+                      counter = counter+1;
+                      std::cout << "[4/6] Building the grid: stage 3 of 3 [" << (static_cast<double>(i)/static_cast<double>(n_cell))*100.0 << "%]                       \r";
+                      std::cout.flush();
+                    }
+                }
+            }
+          else
+            {
+              if (compress_size)
+                {
+                  for (size_t i = 1; i <= n_cell_x; ++i)
+                    {
+                      for (size_t j = 1; j <= n_cell_y; ++j)
+                        {
+                          for (size_t k = 1; k <= n_cell_z; ++k)
+                            {
+                              grid_connectivity[counter][0] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j - 1) + k - 1;
+                              grid_connectivity[counter][1] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j - 1) + k - 1;
+                              grid_connectivity[counter][2] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j    ) + k - 1;
+                              grid_connectivity[counter][3] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j    ) + k - 1;
+                              grid_connectivity[counter][4] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j - 1) + k;
+                              grid_connectivity[counter][5] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j - 1) + k;
+                              grid_connectivity[counter][6] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j    ) + k;
+                              grid_connectivity[counter][7] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j    ) + k;
+                              counter++;
+                            }
+                        }
+                    }
+                }
+              else
+                {
+                  for (size_t i = 0; i < n_cell; ++i)
+                    {
+                      grid_connectivity[i][0] = counter;
+                      grid_connectivity[i][1] = counter + 1;
+                      grid_connectivity[i][2] = counter + 2;
+                      grid_connectivity[i][3] = counter + 3;
+                      grid_connectivity[i][4] = counter + 4;
+                      grid_connectivity[i][5] = counter + 5;
+                      grid_connectivity[i][6] = counter + 6;
+                      grid_connectivity[i][7] = counter + 7;
+                      counter = counter + 8;
+                      std::cout << "[4/6] Building the grid: stage 3 of 3 [" << (static_cast<double>(i)/static_cast<double>(n_cell))*100.0 << "%]                       \r";
+                      std::cout.flush();
+                    }
+                }
+            }
+        }
+      else if (grid_type == "sphere")
+        {
+
+          WBAssertThrow(dim == 3, "The sphere only works in 3d.");
+
+
+          const double inner_radius = z_min;
+          const double outer_radius = z_max;
+
+          const size_t n_block = 12;
+
+          const size_t block_n_cell = n_cell_x*n_cell_x;
+          const size_t block_n_p = (n_cell_x + 1) * (n_cell_x + 1);
+          const size_t block_n_v = 4;
+
+
+          std::vector<std::vector<double> > block_grid_x(n_block,std::vector<double>(block_n_p));
+          std::vector<std::vector<double> > block_grid_y(n_block,std::vector<double>(block_n_p));
+          std::vector<std::vector<double> > block_grid_z(n_block,std::vector<double>(block_n_p));
+          std::vector<std::vector<std::vector<size_t> > > block_grid_connectivity(n_block,std::vector<std::vector<size_t> >(block_n_cell,std::vector<size_t>(block_n_v)));
+          std::vector<std::vector<bool> > block_grid_hull(n_block,std::vector<bool>(block_n_p));
+
+          /**
+           * block node layout
+           */
+          for (size_t i_block = 0; i_block < n_block; ++i_block)
+            {
+              const size_t block_n_cell_x = n_cell_x;
+              const size_t block_n_cell_y = n_cell_x;
+              const double Lx = 1.0;
+              const double Ly = 1.0;
+
+              size_t counter = 0;
+              for (size_t j = 0; j <= block_n_cell_y; ++j)
+                {
+                  for (size_t i = 0; i <= block_n_cell_y; ++i)
+                    {
+                      block_grid_x[i_block][counter] = static_cast<double>(i) * Lx / static_cast<double>(block_n_cell_x);
+                      block_grid_y[i_block][counter] = static_cast<double>(j) * Ly / static_cast<double>(block_n_cell_y);
+                      block_grid_z[i_block][counter] = 0.0;
+                      counter++;
+                    }
+                }
+
+              counter = 0;
+              // using i=1 and j=1 here because i an j are not used in lookup and storage
+              // so the code can remain very similar to ghost and the cartesian code.
+              for (size_t j = 1; j <= block_n_cell_y; ++j)
+                {
+                  for (size_t i = 1; i <= block_n_cell_x; ++i)
+                    {
+                      block_grid_connectivity[i_block][counter][0] = i + (j - 1) * (block_n_cell_x + 1) - 1;
+                      block_grid_connectivity[i_block][counter][1] = i + 1 + (j - 1) * (block_n_cell_x + 1) - 1;
+                      block_grid_connectivity[i_block][counter][2] = i + 1  + j * (block_n_cell_x + 1) - 1;
+                      block_grid_connectivity[i_block][counter][3] = i + j * (block_n_cell_x + 1) - 1;
+                      counter++;
+                    }
+                }
+            }
+
+          /**
+           * map blocks
+           */
+          double radius = 1;
+
+          // four corners
+          double xA = -1.0;
+          double yA = 0.0;
+          double zA = -1.0 / std::sqrt(2.0);
+
+          double xB = 1.0;
+          double yB = 0.0;
+          double zB = -1.0 / std::sqrt(2.0);
+
+          double xC = 0.0;
+          double yC = -1.0;
+          double zC = 1.0 / std::sqrt(2.0);
+
+          double xD = 0.0;
+          double yD = 1.0;
+          double zD = 1.0 / std::sqrt(2.0);
+
+          // middles of faces
+          double xM = (xA+xB+xC)/3.0;
+          double yM = (yA+yB+yC)/3.0;
+          double zM = (zA+zB+zC)/3.0;
+
+          double xN = (xA+xD+xC)/3.0;
+          double yN = (yA+yD+yC)/3.0;
+          double zN = (zA+zD+zC)/3.0;
+
+          double xP = (xA+xD+xB)/3.0;
+          double yP = (yA+yD+yB)/3.0;
+          double zP = (zA+zD+zB)/3.0;
+
+          double xQ = (xC+xD+xB)/3.0;
+          double yQ = (yC+yD+yB)/3.0;
+          double zQ = (zC+zD+zB)/3.0;
+
+          // middle of edges
+          double xF = (xB+xC)/2.0;
+          double yF = (yB+yC)/2.0;
+          double zF = (zB+zC)/2.0;
+
+          double xG = (xA+xC)/2.0;
+          double yG = (yA+yC)/2.0;
+          double zG = (zA+zC)/2.0;
+
+          double xE = (xB+xA)/2.0;
+          double yE = (yB+yA)/2.0;
+          double zE = (zB+zA)/2.0;
+
+          double xH = (xD+xC)/2.0;
+          double yH = (yD+yC)/2.0;
+          double zH = (zD+zC)/2.0;
+
+          double xJ = (xD+xA)/2.0;
+          double yJ = (yD+yA)/2.0;
+          double zJ = (zD+zA)/2.0;
+
+          double xK = (xD+xB)/2.0;
+          double yK = (yD+yB)/2.0;
+          double zK = (zD+zB)/2.0;
+
+          // Making sure points A..Q are on a sphere
+          project_on_sphere(radius,xA,yA,zA);
+          project_on_sphere(radius,xB,yB,zB);
+          project_on_sphere(radius,xC,yC,zC);
+          project_on_sphere(radius,xD,yD,zD);
+          project_on_sphere(radius,xE,yE,zE);
+          project_on_sphere(radius,xF,yF,zF);
+          project_on_sphere(radius,xG,yG,zG);
+          project_on_sphere(radius,xH,yH,zH);
+          project_on_sphere(radius,xJ,yJ,zJ);
+          project_on_sphere(radius,xK,yK,zK);
+          project_on_sphere(radius,xM,yM,zM);
+          project_on_sphere(radius,xN,yN,zN);
+          project_on_sphere(radius,xP,yP,zP);
+          project_on_sphere(radius,xQ,yQ,zQ);
+
+          lay_points(xM,yM,zM,xG,yG,zG,xA,yA,zA,xE,yE,zE,block_grid_x[0], block_grid_y[0], block_grid_z[0],block_grid_hull[0], n_cell_x);
+          lay_points(xF,yF,zF,xM,yM,zM,xE,yE,zE,xB,yB,zB,block_grid_x[1], block_grid_y[1], block_grid_z[1],block_grid_hull[1], n_cell_x);
+          lay_points(xC,yC,zC,xG,yG,zG,xM,yM,zM,xF,yF,zF,block_grid_x[2], block_grid_y[2], block_grid_z[2],block_grid_hull[2], n_cell_x);
+          lay_points(xG,yG,zG,xN,yN,zN,xJ,yJ,zJ,xA,yA,zA,block_grid_x[3], block_grid_y[3], block_grid_z[3],block_grid_hull[3], n_cell_x);
+          lay_points(xC,yC,zC,xH,yH,zH,xN,yN,zN,xG,yG,zG,block_grid_x[4], block_grid_y[4], block_grid_z[4],block_grid_hull[4], n_cell_x);
+          lay_points(xH,yH,zH,xD,yD,zD,xJ,yJ,zJ,xN,yN,zN,block_grid_x[5], block_grid_y[5], block_grid_z[5],block_grid_hull[5], n_cell_x);
+          lay_points(xA,yA,zA,xJ,yJ,zJ,xP,yP,zP,xE,yE,zE,block_grid_x[6], block_grid_y[6], block_grid_z[6],block_grid_hull[6], n_cell_x);
+          lay_points(xJ,yJ,zJ,xD,yD,zD,xK,yK,zK,xP,yP,zP,block_grid_x[7], block_grid_y[7], block_grid_z[7],block_grid_hull[7], n_cell_x);
+          lay_points(xP,yP,zP,xK,yK,zK,xB,yB,zB,xE,yE,zE,block_grid_x[8], block_grid_y[8], block_grid_z[8],block_grid_hull[8], n_cell_x);
+          lay_points(xQ,yQ,zQ,xK,yK,zK,xD,yD,zD,xH,yH,zH,block_grid_x[9], block_grid_y[9], block_grid_z[9],block_grid_hull[9], n_cell_x);
+          lay_points(xQ,yQ,zQ,xH,yH,zH,xC,yC,zC,xF,yF,zF,block_grid_x[10], block_grid_y[10], block_grid_z[10],block_grid_hull[10], n_cell_x);
+          lay_points(xQ,yQ,zQ,xF,yF,zF,xB,yB,zB,xK,yK,zK,block_grid_x[11], block_grid_y[11], block_grid_z[11],block_grid_hull[11], n_cell_x);
+
+          // make sure all points end up on a sphere
+          for (size_t i_block = 0; i_block < n_block; ++i_block)
+            {
+              for (size_t i_point = 0; i_point < block_n_p; ++i_point)
+                {
+                  project_on_sphere(radius,block_grid_x[i_block][i_point],block_grid_y[i_block][i_point],block_grid_z[i_block][i_point]);
+                }
+            }
+
+          /**
+           * merge blocks
+           */
+          std::vector<double> temp_x(n_block * block_n_p);
+          std::vector<double> temp_y(n_block * block_n_p);
+          std::vector<double> temp_z(n_block * block_n_p);
+          std::vector<bool> sides(n_block * block_n_p);
+
+          for (size_t i = 0; i < n_block; ++i)
+            {
+              size_t counter = 0;
+              for (size_t j = i * block_n_p; j < i * block_n_p + block_n_p; ++j)
+                {
+                  WBAssert(j < temp_x.size(), "j should be smaller then the size of the array temp_x.");
+                  WBAssert(j < temp_y.size(), "j should be smaller then the size of the array temp_y.");
+                  WBAssert(j < temp_z.size(), "j should be smaller then the size of the array temp_z.");
+                  temp_x[j] = block_grid_x[i][counter];
+                  temp_y[j] = block_grid_y[i][counter];
+                  temp_z[j] = block_grid_z[i][counter];
+                  sides[j] = block_grid_hull[i][counter];
+                  counter++;
+                }
+            }
+
+
+          std::vector<bool> double_points(n_block * block_n_p,false);
+          std::vector<size_t> point_to(n_block * block_n_p);
+
+          for (size_t i = 0; i < n_block * block_n_p; ++i)
+            point_to[i] = i;
+
+          // TODO: This becomes problematic with too large values of outer radius. Find a better way, maybe through an epsilon.
+          const double distance = 1e-12*outer_radius;
+
+          size_t counter = 0;
+          size_t amount_of_double_points = 0;
+          for (size_t i = 1; i < n_block * block_n_p; ++i)
+            {
+              if (sides[i])
+                {
+                  const double gxip = temp_x[i];
+                  const double gyip = temp_y[i];
+                  const double gzip = temp_z[i];
+                  for (size_t j = 0; j < i-1; ++j)
+                    {
+                      if (sides[j])
+                        {
+                          if (std::fabs(gxip-temp_x[j]) < distance &&
+                              std::fabs(gyip-temp_y[j]) < distance &&
+                              std::fabs(gzip-temp_z[j]) < distance)
+                            {
+                              double_points[i] = true;
+                              point_to[i] = j;
+                              amount_of_double_points++;
+                              break;
+                            }
+                        }
+                    }
+                }
+            }
+
+
+          const size_t shell_n_p = n_block * block_n_p - amount_of_double_points;
+          const size_t shell_n_cell = n_block * block_n_cell;
+          const size_t shell_n_v = block_n_v;
+
+          std::vector<double> shell_grid_x(shell_n_p);
+          std::vector<double> shell_grid_y(shell_n_p);
+          std::vector<double> shell_grid_z(shell_n_p);
+          std::vector<std::vector<size_t> > shell_grid_connectivity(shell_n_cell,std::vector<size_t>(shell_n_v));
+
+          counter = 0;
+          for (size_t i = 0; i < n_block * block_n_p; ++i)
+            {
+              if (!double_points[i])
+                {
+                  shell_grid_x[counter] = fabs(temp_x[i]) < 1e-8 ? 0. : temp_x[i];
+                  shell_grid_y[counter] = fabs(temp_y[i]) < 1e-8 ? 0. : temp_y[i];
+                  shell_grid_z[counter] = fabs(temp_z[i]) < 1e-8 ? 0. : temp_z[i];
+
+                  counter++;
+                }
+            }
+
+          for (size_t i = 0; i < n_block; ++i)
+            {
+              counter = 0;
+              for (size_t j = i * block_n_cell; j < i * block_n_cell + block_n_cell; ++j)
+                {
+                  for (size_t k = 0; k < shell_n_v; ++k)
+                    {
+                      shell_grid_connectivity[j][k] = block_grid_connectivity[i][counter][k] + i * block_n_p;
+                    }
+                  counter++;
+                }
+            }
+
+          for (size_t i = 0; i < shell_n_cell; ++i)
+            {
+              for (size_t j = 0; j < shell_n_v; ++j)
+                {
+                  shell_grid_connectivity[i][j] = point_to[shell_grid_connectivity[i][j]];
+                }
+            }
+
+          std::vector<size_t> compact(n_block * block_n_p);
+
+          counter = 0;
+          for (size_t i = 0; i < n_block * block_n_p; ++i)
+            {
+              if (!double_points[i])
+                {
+                  compact[i] = counter;
+                  counter++;
+                }
+            }
+
+
+          for (size_t i = 0; i < shell_n_cell; ++i)
+            {
+              for (size_t j = 0; j < shell_n_v; ++j)
+                {
+                  shell_grid_connectivity[i][j] = compact[shell_grid_connectivity[i][j]];
+                }
+            }
+
+
+          /**
+           * build hollow sphere
+           */
+
+          std::vector<double> temp_shell_grid_x(shell_n_p);
+          std::vector<double> temp_shell_grid_y(shell_n_p);
+          std::vector<double> temp_shell_grid_z(shell_n_p);
+
+          const size_t n_v = shell_n_v * 2;
+          n_p = (n_cell_z + 1) * shell_n_p;
+          n_cell = (n_cell_z) * shell_n_cell;
+
+          grid_x.resize(n_p);
+          grid_y.resize(n_p);
+          grid_z.resize(n_p);
+          grid_depth.resize(n_p);
+          grid_connectivity.resize(n_cell,std::vector<size_t>(n_v));
+
+
+          for (size_t i = 0; i < n_cell_z + 1; ++i)
+            {
+              temp_shell_grid_x = shell_grid_x;
+              temp_shell_grid_y = shell_grid_y;
+              temp_shell_grid_z = shell_grid_z;
+
+              // We do not need to copy the shell_grid_connectivity into a
+              // temperorary variable, because we do not change it. We can
+              // directly use it.
+
+              radius = inner_radius + ((outer_radius - inner_radius) / static_cast<double>(n_cell_z)) * static_cast<double>(i);
+              for (size_t j = 0; j < shell_n_p; ++j)
+                {
+                  WBAssert(j < temp_shell_grid_x.size(), "ERROR: j = " << j << ", temp_shell_grid_x.size() = " << temp_shell_grid_x.size());
+                  WBAssert(j < temp_shell_grid_y.size(), "ERROR: j = " << j << ", temp_shell_grid_y.size() = " << temp_shell_grid_y.size());
+                  WBAssert(j < temp_shell_grid_z.size(), "ERROR: j = " << j << ", temp_shell_grid_z.size() = " << temp_shell_grid_z.size());
+                  project_on_sphere(radius, temp_shell_grid_x[j], temp_shell_grid_y[j], temp_shell_grid_z[j]);
+                }
+
+              const size_t i_beg =  i * shell_n_p;
+              const size_t i_end = (i+1) * shell_n_p;
+              counter = 0;
+              for (size_t j = i_beg; j < i_end; ++j)
+                {
+                  WBAssert(j < grid_x.size(), "ERROR: j = " << j << ", grid_x.size() = " << grid_x.size());
+                  WBAssert(j < grid_y.size(), "ERROR: j = " << j << ", grid_y.size() = " << grid_y.size());
+                  WBAssert(j < grid_z.size(), "ERROR: j = " << j << ", grid_z.size() = " << grid_z.size());
+                  grid_x[j] = temp_shell_grid_x[counter];
+                  grid_y[j] = temp_shell_grid_y[counter];
+                  grid_z[j] = temp_shell_grid_z[counter];
+                  grid_depth[j] = outer_radius - std::sqrt(grid_x[j] * grid_x[j] + grid_y[j] * grid_y[j] + grid_z[j] * grid_z[j]);
+                  grid_depth[j] = (std::fabs(grid_depth[j]) < 1e-8 ? 0 : grid_depth[j]);
+
+                  counter++;
+                }
+            }
+
+          for (size_t i = 0; i < n_cell_z; ++i)
+            {
+              const size_t i_beg = i * shell_n_cell;
+              const size_t i_end = (i+1) * shell_n_cell;
+              counter = 0;
+              for (size_t j = i_beg; j < i_end; ++j)
+                {
+                  for (size_t k = 0; k < shell_n_v; ++k)
+                    {
+                      grid_connectivity[j][k] = shell_grid_connectivity[counter][k] + i * shell_n_p;
+                    }
+                  counter++;
+                }
+
+
+              counter = 0;
+              for (size_t j = i_beg; j < i_end; ++j)
+                {
+                  for (size_t k = shell_n_v ; k < 2 * shell_n_v; ++k)
+                    {
+                      WBAssert(k-shell_n_v < shell_grid_connectivity[counter].size(), "k - shell_n_v is larger then shell_grid_connectivity[counter]: k= " << k << ", shell_grid_connectivity[counter].size() = " << shell_grid_connectivity[counter].size());
+                      grid_connectivity[j][k] = shell_grid_connectivity[counter][k-shell_n_v] + (i+1) * shell_n_p;
+                    }
+                  counter++;
+                }
+            }
+        }
+      else
+        {
+          WBAssertThrow(false, "Geometry type '" << grid_type << "' is not a valid geometry type. Valid geometry types are: "
+                        << "'cartesian', 'annulus', 'chunk' and 'sphere'. "
+                        << "Please note that the annulus can only be used in 2d and the sphere can only be used in 3d.");
+        }
+
+      // create paraview file.
+      std::cout << "[5/6] Preparing to write the paraview file...                                                   \r";
+      std::cout.flush();
+
+      const std::string base_filename = wb_file.substr(wb_file.find_last_of("/\\") + 1);
+      std::string::size_type  const p(base_filename.find_last_of('.'));
+      const std::string file_without_extension = base_filename.substr(0, p);
+
+      const std::stringstream buffer;
+      const std::ofstream myfile;
+
+      std::cout << "[5/6] Preparing to write the paraview file: stage 1 of 6, converting the points                              \r";
+      std::cout.flush();
+      std::vector<double> points(grid_x.size()*3, 0.0);
+      if (dim == 2)
+        for (size_t i = 0; i < n_p; ++i)
+          {
+            points[i*3] = grid_x[i];
+            points[i*3+1] = grid_z[i];
+            // third one is zero
+          }
+      else
+        {
+          for (size_t i = 0; i < n_p; ++i)
+            {
+              points[i*3] = grid_x[i];
+              points[i*3+1] = grid_y[i];
+              points[i*3+2] = grid_z[i];
+            }
+        }
+      std::cout << "[5/6] Preparing to write the paraview file: stage 2 of 6, converting the connectivity                              \r";
+      std::cout.flush();
+      const size_t pow_2_dim = dim == 2 ? 4 : 8;
+      std::vector<vtu11::VtkIndexType> connectivity(n_cell*pow_2_dim);
+      if (dim == 2)
+        for (size_t i = 0; i < n_cell; ++i)
+          {
+            connectivity[i*pow_2_dim] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][0]);
+            connectivity[i*pow_2_dim+1] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][1]);
+            connectivity[i*pow_2_dim+2] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][2]);
+            connectivity[i*pow_2_dim+3] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][3]);
+          }
+      else
+        for (size_t i = 0; i < n_cell; ++i)
+          {
+
+            connectivity[i*pow_2_dim] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][0]);
+            connectivity[i*pow_2_dim+1] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][1]);
+            connectivity[i*pow_2_dim+2] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][2]);
+            connectivity[i*pow_2_dim+3] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][3]);
+            connectivity[i*pow_2_dim+4] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][4]);
+            connectivity[i*pow_2_dim+5] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][5]);
+            connectivity[i*pow_2_dim+6] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][6]);
+            connectivity[i*pow_2_dim+7] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][7]);
+          }
+      std::cout << "[5/6] Preparing to write the paraview file: stage 3 of 6, creating the offsets                              \r";
+      std::cout.flush();
+      std::vector<vtu11::VtkIndexType> offsets(n_cell);
+      if (dim == 2)
+        for (size_t i = 0; i < n_cell; ++i)
+          offsets[i] = static_cast<vtu11::VtkIndexType>((i+1) * 4);
+      else
+        for (size_t i = 0; i < n_cell; ++i)
+          offsets[i] = static_cast<vtu11::VtkIndexType>((i+1) * 8);
+
+      std::cout << "[5/6] Preparing to write the paraview file: stage 4 of 6, creating the Data set info                              \r";
+      std::cout.flush();
+      std::vector<vtu11::VtkCellType> types(n_cell, dim == 2 ? 9 : 12);
+
+      // Create tuples with (name, association, number of components) for each data set
+      std::vector<vtu11::DataSetInfo> dataSetInfo
+      {
+        { "Depth", vtu11::DataSetType::PointData, 1 },
+        { "Temperature", vtu11::DataSetType::PointData, 1 },
+        { "Tag", vtu11::DataSetType::PointData, 1 },
+      };
+      for (size_t c = 0; c < compositions; ++c)
+        {
+          dataSetInfo.emplace_back( "Composition "+std::to_string(c), vtu11::DataSetType::PointData, 1 );
+        }
+
+      std::cout << "[5/6] Preparing to write the paraview file: stage 5 of 5, computing the properties                              \r";
+      std::cout.flush();
+
+      std::vector<std::array<unsigned ,3>> properties;
+      properties.push_back({{1,0,0}}); // temperature
+
+      properties.push_back({{4,0,0}}); // tag
+
+      for (unsigned int c = 0; c < compositions; ++c)
+        properties.push_back({{2,c,0}}); // composition c
+
+
+      // compute temperature
+      std::vector<vtu11::DataSetData> data_set(3+compositions);
+      data_set[0] = grid_depth;
+      data_set[1].resize(n_p);
+      data_set[2].resize(n_p);
+      for (size_t c = 0; c < compositions; ++c)
+        data_set[3+c].resize(n_p);
+
+      if (dim == 2)
+        {
+          pool.parallel_for(0, n_p, [&] (size_t i)
+          {
+            const std::array<double,2> coords = {{grid_x[i], grid_z[i]}};
+            std::vector<double> output = world->properties(coords, grid_depth[i],properties);
+            data_set[1][i] = output[0];
+            data_set[2][i] = output[1];
+            for (size_t c = 0; c < compositions; ++c)
+              {
+                data_set[3+c][i] = output[2+c];
+              }
+          });
+        }
+      else
+        {
+          pool.parallel_for(0, n_p, [&] (size_t i)
+          {
+            const std::array<double,3> coords = {{grid_x[i], grid_y[i], grid_z[i]}};
+            std::vector<double> output = world->properties(coords, grid_depth[i],properties);
+            data_set[1][i] = output[0];
+            data_set[2][i] = output[1];
+            for (size_t c = 0; c < compositions; ++c)
+              {
+                data_set[3+c][i] = output[2+c];
+              }
+          });
+        }
+      std::cout << "[6/6] Writing the paraview file                                                                                \r";
+      std::cout.flush();
+
+      {
+        vtu11::Vtu11UnstructuredMesh mesh { points, connectivity, offsets, types };
+        vtu11::writeVtu( file_without_extension + ".vtu", mesh, dataSetInfo, data_set, vtu_output_format );
+
+        if (output_filtered)
+          {
+            std::vector<bool> include_tag(world->feature_tags.size(), true);
+            for (unsigned int idx = 0; idx<include_tag.size(); ++idx)
+              {
+                if (world->feature_tags[idx]=="mantle layer")
+                  include_tag[idx] = false;
+              }
+            std::vector<double> filtered_points;
+            std::vector<vtu11::VtkIndexType> filtered_connectivity;
+            std::vector<vtu11::VtkIndexType> filtered_offsets;
+            std::vector<vtu11::VtkCellType> filtered_types;
+
+            vtu11::Vtu11UnstructuredMesh filtered_mesh {filtered_points, filtered_connectivity, filtered_offsets, filtered_types};
+            std::vector<vtu11::DataSetData> filtered_data_set;
+
+            filter_vtu_mesh(static_cast<int>(dim), include_tag, mesh, data_set, filtered_mesh, filtered_data_set);
+            vtu11::writeVtu( file_without_extension + ".filtered.vtu", filtered_mesh, dataSetInfo, filtered_data_set, vtu_output_format );
+          }
+
+        if (output_by_tag)
+          {
+            for (unsigned int idx = 0; idx<world->feature_tags.size(); ++idx)
+              {
+                if (world->feature_tags[idx]=="mantle layer")
+                  continue;
+
+                std::vector<double> filtered_points;
+                std::vector<vtu11::VtkIndexType> filtered_connectivity;
+                std::vector<vtu11::VtkIndexType> filtered_offsets;
+                std::vector<vtu11::VtkCellType> filtered_types;
+
+                vtu11::Vtu11UnstructuredMesh filtered_mesh {filtered_points, filtered_connectivity, filtered_offsets, filtered_types};
+                std::vector<vtu11::DataSetData> filtered_data_set;
+
+                std::vector<bool> include_tag(world->feature_tags.size(), false);
+                include_tag[idx]=true;
+                filter_vtu_mesh(static_cast<int>(dim), include_tag, mesh, data_set, filtered_mesh, filtered_data_set);
+                const std::string filename = file_without_extension + "."+ std::to_string(idx)+".vtu";
+                vtu11::writeVtu( filename, filtered_mesh, dataSetInfo, filtered_data_set, vtu_output_format );
+              }
+          }
+      }
+      std::cout << "                                                                                                               \r";
+      std::cout.flush();
+    }
+
+#ifdef WB_WITH_MPI
+  MPI_Finalize();
+#endif
+  return 0;
+}
diff --git a/contrib/world_builder/source/world_builder/coordinate_systems/cartesian.cc.bak b/contrib/world_builder/source/world_builder/coordinate_systems/cartesian.cc.bak
new file mode 100644
index 00000000000..a6222ae9161
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/coordinate_systems/cartesian.cc.bak
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/coordinate_systems/cartesian.h"
+#include "world_builder/types/object.h"
+
+
+namespace WorldBuilder
+{
+  namespace CoordinateSystems
+  {
+    Cartesian::Cartesian(WorldBuilder::World *world_)
+    {
+      this->world = world_;
+    }
+
+    Cartesian::~Cartesian()
+      = default;
+
+    void
+    Cartesian::declare_entries(Parameters &prm, const std::string & /*unused*/)
+    {
+      prm.declare_entry("", Types::Object(),
+                        "A Cartesian coordinate system. Coordinates are (x,y,z) and extend infinitely in all directions.");
+    }
+
+    void
+    Cartesian::parse_entries(Parameters & /*prm*/)
+    {}
+
+
+    CoordinateSystem
+    Cartesian::natural_coordinate_system() const
+    {
+      return CoordinateSystem::cartesian;
+    }
+
+
+    DepthMethod
+    Cartesian::depth_method() const
+    {
+      return DepthMethod::none;
+    }
+
+
+    std::array<double,3>
+    Cartesian::cartesian_to_natural_coordinates(const std::array<double,3> &position) const
+    {
+      return position;
+    }
+
+
+    std::array<double,3>
+    Cartesian::natural_to_cartesian_coordinates(const std::array<double,3> &position) const
+    {
+      return position;
+    }
+
+
+    double
+    Cartesian::distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const
+    {
+      WBAssert(point_1.get_coordinate_system() == cartesian,
+               "Can not convert non-Cartesian points through the Cartesian coordinate system.");
+      WBAssert(point_2.get_coordinate_system() == cartesian,
+               "Can not convert non-Cartesian points through the Cartesian coordinate system.");
+      // Todo: check that points are at the same depth.
+      const Point<3> difference = point_1-point_2;
+      const Point<2> point_at_depth(difference[0],difference[1], cartesian);
+
+      return point_at_depth.norm();
+    }
+
+
+    double
+    Cartesian::max_model_depth() const
+    {
+      return std::numeric_limits<double>::infinity();
+    }
+
+    /**
+     * Register plugin
+     */
+    WB_REGISTER_COORDINATE_SYSTEM(Cartesian, cartesian)
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/coordinate_systems/interface.cc.bak b/contrib/world_builder/source/world_builder/coordinate_systems/interface.cc.bak
new file mode 100644
index 00000000000..6332ef2b2ce
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/coordinate_systems/interface.cc.bak
@@ -0,0 +1,100 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/coordinate_systems/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/object.h"
+
+
+namespace WorldBuilder
+{
+  namespace CoordinateSystems
+  {
+
+    Interface::Interface()
+      = default;
+
+    Interface::~Interface ()
+      = default;
+
+    void
+    Interface::declare_entries(Parameters &prm, const std::string &parent_name, const std::vector<std::string> &required_entries)
+    {
+
+      unsigned int counter = 0;
+      for (auto &iter : get_declare_map())
+        {
+          prm.enter_subsection("oneOf");
+          {
+            prm.enter_subsection(std::to_string(counter));
+            {
+              prm.enter_subsection("properties");
+              {
+                prm.declare_entry("", Types::Object(required_entries), "Coordinate system object");
+
+                prm.declare_entry("model",Types::String("",iter.first),
+                                  "The name of the coordinate system to use.");
+
+                iter.second(prm, parent_name);
+              }
+              prm.leave_subsection();
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          counter++;
+
+        }
+    }
+
+    void
+    Interface::registerType(const std::string &name,
+                            void ( *declare_entries)(Parameters &, const std::string &),
+                            ObjectFactory *factory)
+    {
+      get_factory_map()[name] = factory;
+      get_declare_map()[name] = declare_entries;
+    }
+
+    std::unique_ptr<Interface>
+    Interface::create(const std::string &name, WorldBuilder::World *world)
+    {
+      std::string lower_case_name;
+      std::transform(name.begin(),
+                     name.end(),
+                     std::back_inserter(lower_case_name),
+                     ::tolower);;
+
+      // Have a nice assert message to check whether a plugin exists in the case
+      // of a debug compilation.
+      WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                    "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                    "The size of factories is " << get_factory_map().size() << '.');
+
+      // Using at() because the [] will just insert values
+      // which is undesirable in this case. An exception is
+      // thrown when the name is not present.
+      return get_factory_map().at(lower_case_name)->create(world);
+    }
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/coordinate_systems/invalid.cc.bak b/contrib/world_builder/source/world_builder/coordinate_systems/invalid.cc.bak
new file mode 100644
index 00000000000..72ca62e9034
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/coordinate_systems/invalid.cc.bak
@@ -0,0 +1,88 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/coordinate_systems/invalid.h"
+#include "world_builder/types/object.h"
+
+
+namespace WorldBuilder
+{
+  namespace CoordinateSystems
+  {
+    Invalid::Invalid(WorldBuilder::World *world_)
+    {
+      this->world = world_;
+    }
+
+    Invalid::~Invalid()
+      = default;
+
+    void
+    Invalid::parse_entries(Parameters & /*prm*/)
+    {}
+
+
+    CoordinateSystem
+    Invalid::natural_coordinate_system() const
+    {
+      return CoordinateSystem::invalid;
+    }
+
+
+    DepthMethod
+    Invalid::depth_method() const
+    {
+      return DepthMethod::none;
+    }
+
+
+    std::array<double,3>
+    Invalid::cartesian_to_natural_coordinates(const std::array<double,3> & /*position*/) const
+    {
+      return {{NaN::DQNAN,NaN::DQNAN,NaN::DQNAN}};
+    }
+
+
+    std::array<double,3>
+    Invalid::natural_to_cartesian_coordinates(const std::array<double,3> & /*position*/) const
+    {
+      return {{NaN::DQNAN,NaN::DQNAN,NaN::DQNAN}};
+    }
+
+
+    double
+    Invalid::distance_between_points_at_same_depth(const Point<3> & /*point_1*/, const Point<3> & /*point_2*/) const
+    {
+      return NaN::DQNAN;
+    }
+
+
+    double
+    Invalid::max_model_depth() const
+    {
+      return NaN::DQNAN;
+    }
+
+    /**
+     * Not registering plugin because this is only used for testing.
+     */
+    //WB_REGISTER_COORDINATE_SYSTEM(Invalid, invalid)
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/coordinate_systems/spherical.cc.bak b/contrib/world_builder/source/world_builder/coordinate_systems/spherical.cc.bak
new file mode 100644
index 00000000000..0ed922b9b9b
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/coordinate_systems/spherical.cc.bak
@@ -0,0 +1,146 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/coordinate_systems/spherical.h"
+
+
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/utilities.h"
+
+namespace WorldBuilder
+{
+  namespace CoordinateSystems
+  {
+    Spherical::Spherical(WorldBuilder::World *world_)
+    {
+      this->world = world_;
+    }
+
+    Spherical::~Spherical()
+      = default;
+
+    void
+    Spherical::declare_entries(Parameters &prm, const std::string & /*unused*/)
+    {
+
+      // Add depth method to the required parameters.
+      prm.declare_entry("", Types::Object({"depth method"}),
+                        "A spherical coordinate system. The coordinates are (radius, longitude, latitude). "
+                        "The radius is set in this plugin, the longitude extends at least from -360 to 360 degrees, "
+                        "and the latitude extends from -90 to 90. It is required to choose a depth method. Please "
+                        "see the manual for more information.");
+
+
+      prm.declare_entry("depth method",
+                        Types::String("",std::vector<std::string>({"starting point", "begin segment","begin at end segment", "continuous"})),
+                        R"(Which depth method to use in the spherical case. The available options are 'starting point', )"
+                        R"('begin segment' and 'begin at end segment'. See the manual section on coordinate systems for )"
+                        R"(more info.)");
+
+      prm.declare_entry("radius",
+                        Types::Double(6371000.),
+                        R"(The radius of the sphere.)");
+
+
+    }
+
+    void
+    Spherical::parse_entries(Parameters &prm)
+    {
+      prm.enter_subsection("coordinate system");
+      {
+        const std::string string_depth_method = prm.get<std::string>("depth method");
+        if (string_depth_method == "starting point")
+          used_depth_method = DepthMethod::angle_at_starting_point_with_surface;
+        else if (string_depth_method == "begin segment")
+          used_depth_method = DepthMethod::angle_at_begin_segment_with_surface;
+        else if (string_depth_method == "begin at end segment")
+          used_depth_method = DepthMethod::angle_at_begin_segment_applied_to_end_segment_with_surface;
+        //else if (string_depth_method == "continuous")
+        //used_depth_method = DepthMethod::continuous_angle_with_surface;
+        else
+          WBAssertThrow(true,"Option " << string_depth_method << " is not a valid depth method for spherical "
+                        "coordinates. The available options are 'starting point', 'begin segment' and 'begin at end segment'. "
+                        "The option 'continuous' is not yet available.");
+
+        radius_sphere = prm.get<double>("radius");
+      }
+      prm.leave_subsection();
+    }
+
+
+    CoordinateSystem
+    Spherical::natural_coordinate_system() const
+    {
+      return CoordinateSystem::spherical;
+    }
+
+
+    DepthMethod
+    Spherical::depth_method() const
+    {
+      return used_depth_method;
+    }
+
+
+    std::array<double,3>
+    Spherical::cartesian_to_natural_coordinates(const std::array<double,3> &position) const
+    {
+      return Utilities::cartesian_to_spherical_coordinates(Point<3>(position,cartesian));
+    }
+
+
+    std::array<double,3>
+    Spherical::natural_to_cartesian_coordinates(const std::array<double,3> &position) const
+    {
+      return Utilities::spherical_to_cartesian_coordinates(position).get_array();
+    }
+
+    double
+    Spherical::distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const
+    {
+      WBAssert(point_1.get_coordinate_system() == spherical,
+               "Can not convert non spherical points through the spherical coordinate system.");
+      WBAssert(point_2.get_coordinate_system() == spherical,
+               "Can not convert non spherical points through the spherical coordinate system.");
+      const double radius = point_1[0];
+      WBAssert((radius - point_2[0]) < std::numeric_limits<double>::epsilon() * std::max(1.0,radius), "The radius of point 1 is not the same as the radius of point 2.");
+
+      // based on https://math.stackexchange.com/questions/1304169/distance-between-two-points-on-a-sphere
+      const Point<3> point_1_cart = Utilities::spherical_to_cartesian_coordinates(point_1.get_array());
+      const Point<3> point_2_cart = Utilities::spherical_to_cartesian_coordinates(point_2.get_array());
+
+      return radius * std::acos(std::min(1.,std::max(0.,point_1_cart*point_2_cart/(radius*radius))));
+    }
+
+
+    double
+    Spherical::max_model_depth() const
+    {
+      return radius_sphere;
+    }
+
+    /**
+     * Register plugin
+     */
+    WB_REGISTER_COORDINATE_SYSTEM(Spherical, spherical)
+  } // namespace CoordinateSystems
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate.cc.bak
new file mode 100644
index 00000000000..31ca36646b9
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate.cc.bak
@@ -0,0 +1,270 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate.h"
+
+
+#include "world_builder/features/continental_plate_models/composition/interface.h"
+#include "world_builder/features/continental_plate_models/grains/interface.h"
+#include "world_builder/features/continental_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/plugin_system.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+#include <iostream>
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    ContinentalPlate::ContinentalPlate(WorldBuilder::World *world_)
+      :
+      min_depth(NaN::DSNAN),
+      max_depth(NaN::DSNAN)
+    {
+      this->world = world_;
+      this->name = "continental plate";
+    }
+
+    ContinentalPlate::~ContinentalPlate()
+      = default;
+
+    void ContinentalPlate::make_snippet(Parameters &prm)
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+
+      const std::string path = prm.get_full_json_path();
+
+      Pointer((path + "/body").c_str()).Set(declarations,"object");
+      Pointer((path + "/body/model").c_str()).Set(declarations,"continental plate");
+      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Plate}");
+      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
+    }
+
+
+
+    void
+    ContinentalPlate::declare_entries(Parameters &prm,
+                                      const std::string & /*unused*/,
+                                      const std::vector<std::string> &required_entries)
+    {
+
+
+
+      prm.declare_entry("", Types::Object(required_entries), "Continental plate object. Requires properties `model` and `coordinates`.");
+
+      prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                        "The depth from which this feature is present");
+      prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                        "The depth to which this feature is present");
+      prm.declare_entry("temperature models",
+                        Types::PluginSystem("", Features::ContinentalPlateModels::Temperature::Interface::declare_entries, {"model"}),
+                        "A list of temperature models.");
+      prm.declare_entry("composition models",
+                        Types::PluginSystem("", Features::ContinentalPlateModels::Composition::Interface::declare_entries, {"model"}),
+                        "A list of composition models.");
+      prm.declare_entry("grains models",
+                        Types::PluginSystem("", Features::ContinentalPlateModels::Grains::Interface::declare_entries, {"model"}),
+                        "A list of grains models.");
+    }
+
+    void
+    ContinentalPlate::parse_entries(Parameters &prm)
+    {
+      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
+
+      this->name = prm.get<std::string>("name");
+
+      std::string tag = prm.get<std::string>("tag");
+      if (tag == "")
+        {
+          tag = "continental plate";
+        }
+      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
+
+      this->get_coordinates("coordinates", prm, coordinate_system);
+
+      min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+      min_depth = min_depth_surface.minimum;
+
+      max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+      max_depth = max_depth_surface.maximum;
+
+
+      prm.get_unique_pointers<Features::ContinentalPlateModels::Temperature::Interface>("temperature models", temperature_models);
+
+      prm.enter_subsection("temperature models");
+      {
+        for (unsigned int i = 0; i < temperature_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              temperature_models[i]->parse_entries(prm,coordinates);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+
+      prm.get_unique_pointers<Features::ContinentalPlateModels::Composition::Interface>("composition models", composition_models);
+
+      prm.enter_subsection("composition models");
+      {
+        for (unsigned int i = 0; i < composition_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              composition_models[i]->parse_entries(prm, coordinates);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+
+      prm.get_unique_pointers<Features::ContinentalPlateModels::Grains::Interface>("grains models", grains_models);
+
+      prm.enter_subsection("grains models");
+      {
+        for (unsigned int i = 0; i < grains_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              grains_models[i]->parse_entries(prm,coordinates);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+    }
+
+
+
+    void
+    ContinentalPlate::properties(const Point<3> &position_in_cartesian_coordinates,
+                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                 const double depth,
+                                 const std::vector<std::array<unsigned int,3>> &properties,
+                                 const double gravity_norm,
+                                 const std::vector<size_t> &entry_in_output,
+                                 std::vector<double> &output) const
+    {
+      if (depth <= max_depth && depth >= min_depth &&
+          WorldBuilder::Utilities::polygon_contains_point(coordinates, Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
+                                                                                world->parameters.coordinate_system->natural_coordinate_system())))
+        {
+          const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+          const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+          if (depth <= max_depth_local &&  depth >= min_depth_local)
+            {
+              for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
+                {
+                  switch (properties[i_property][0])
+                    {
+                      case 1:  // temperature
+                      {
+                        for (const auto &temperature_model: temperature_models)
+                          {
+                            output[entry_in_output[i_property]] = temperature_model->get_temperature(position_in_cartesian_coordinates,
+                                                                                                     position_in_natural_coordinates,
+                                                                                                     depth,
+                                                                                                     gravity_norm,
+                                                                                                     output[entry_in_output[i_property]],
+                                                                                                     min_depth_local,
+                                                                                                     max_depth_local);
+
+                            WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Temperature is not a number: " << output[entry_in_output[i_property]]
+                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+                            WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Temperature is not a finite: " << output[entry_in_output[i_property]]
+                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+
+                          }
+                        break;
+                        case 2: // composition
+
+                          for (const auto &composition_model: composition_models)
+                            {
+                              output[entry_in_output[i_property]] = composition_model->get_composition(position_in_cartesian_coordinates,
+                                                                                                       position_in_natural_coordinates,
+                                                                                                       depth,
+                                                                                                       properties[i_property][1],
+                                                                                                       output[entry_in_output[i_property]],
+                                                                                                       min_depth_local,
+                                                                                                       max_depth_local);
+
+                              WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Composition is not a number: " << output[entry_in_output[i_property]]
+                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+                              WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Composition is not a finite: " << output[entry_in_output[i_property]]
+                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+
+                            }
+
+                          break;
+                        }
+                      case 3: // grains
+                      {
+                        WorldBuilder::grains  grains(output,properties[i_property][2],entry_in_output[i_property]);
+                        for (const auto &grains_model: grains_models)
+                          {
+                            grains = grains_model->get_grains(position_in_cartesian_coordinates,
+                                                              position_in_natural_coordinates,
+                                                              depth,
+                                                              properties[i_property][1],
+                                                              grains,
+                                                              min_depth_local,
+                                                              max_depth_local);
+
+                          }
+                        grains.unroll_into(output,entry_in_output[i_property]);
+                        break;
+                      }
+                      case 4:
+                      {
+                        output[entry_in_output[i_property]] = static_cast<double>(tag_index);
+                        break;
+                      }
+                      default:
+                      {
+                        WBAssertThrow(false,
+                                      "Internal error: Unimplemented property provided. " <<
+                                      "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
+                                      "Provided property number was: " << properties[i_property][0]);
+                      }
+                    }
+                }
+            }
+        }
+    }
+
+    WB_REGISTER_FEATURE(ContinentalPlate, continental plate)
+
+  } // namespace Features
+} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/interface.cc.bak
new file mode 100644
index 00000000000..6f48a19c616
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/interface.cc.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/composition/interface.h"
+
+#include <algorithm>
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Composition
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Composition
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/random.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/random.cc.bak
new file mode 100644
index 00000000000..cfb0d2086b5
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/random.cc.bak
@@ -0,0 +1,144 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/composition/random.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+#include <random>
+
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace ContinentalPlateModels
+    {
+      namespace Composition
+      {
+        Random::Random(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+        {
+          this->world = world_;
+          this->name = "random";
+        }
+
+        Random::~Random()
+          = default;
+
+        void
+        Random::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform compositional model. Sets constant compositional field.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the labels of the composition which are present there.");
+
+          prm.declare_entry("min value", Types::Array(Types::Double(0.0),1),
+                            "Minimum value of the range within which we want to generate a random compositional value "
+                            "corresponding to the compositional field.");
+
+          prm.declare_entry("max value", Types::Array(Types::Double(1.0),1),
+                            "Maximum value of the range within which we want to generate a random compositional value "
+                            "corresponding to the compositional field.");
+
+          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value. Replacing implies that all compositions not "
+                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
+
+        }
+
+        void
+        Random::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+
+          compositions = prm.get_vector<unsigned int>("compositions");
+          min_value    = prm.get_vector<double>("min value");
+          max_value    = prm.get_vector<double>("max value");
+          operation    = string_operations_to_enum(prm.get<std::string>("operation"));
+        }
+
+
+        double
+        Random::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                const double depth,
+                                const unsigned int composition_number,
+                                double composition,
+                                const double  /*feature_min_depth*/,
+                                const double  /*feature_max_depth*/) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i : compositions)
+                    {
+                      if (i == composition_number)
+                        {
+                          std::uniform_real_distribution<> dist(min_value[0], max_value[0]);
+                          const double composition_ = dist(world->get_random_number_engine());
+                          return apply_operation(operation,composition,composition_);
+                        }
+                    }
+
+                  if (operation == Operations::REPLACE)
+                    return 0.0;
+                }
+            }
+          return composition;
+        }
+        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_COMPOSITION_MODEL(Random, random)
+      } // namespace Composition
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/uniform.cc.bak
new file mode 100644
index 00000000000..51130ef82c3
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/uniform.cc.bak
@@ -0,0 +1,136 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/composition/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace ContinentalPlateModels
+    {
+      namespace Composition
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform compositional model. Sets constant compositional field.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the labels of the composition which are present there.");
+
+          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
+                            "TA list of compositional fractions corresponding to the compositions list.");
+
+          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value. Replacing implies that all compositions not "
+                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+
+          compositions = prm.get_vector<unsigned int>("compositions");
+          fractions = prm.get_vector<double>("fractions");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          WBAssertThrow(compositions.size() == fractions.size(),
+                        "There are not the same amount of compositions and fractions.");
+        }
+
+
+        double
+        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                 const double depth,
+                                 const unsigned int composition_number,
+                                 double composition,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          return apply_operation(operation,composition,fractions[i]);
+                        }
+                    }
+
+                  if (operation == Operations::REPLACE)
+                    return 0.0;
+                }
+            }
+          return composition;
+        }
+        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_COMPOSITION_MODEL(Uniform, uniform)
+      } // namespace Composition
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/interface.cc.bak
new file mode 100644
index 00000000000..c10e151f158
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/interface.cc.bak
@@ -0,0 +1,81 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/grains/interface.h"
+
+#include <algorithm>
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Grains
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          prm.declare_model_entries("grains",parent_name, get_declare_map(),required_entries);
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Grains
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution.cc.bak
new file mode 100644
index 00000000000..516b9413ad6
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution.cc.bak
@@ -0,0 +1,225 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/grains/random_uniform_distribution.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution";
+        }
+
+        RandomUniformDistribution::~RandomUniformDistribution()
+          = default;
+
+        void
+        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistribution::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                              const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                              const double depth,
+                                              const unsigned int composition_number,
+                                              WorldBuilder::grains grains_,
+                                              const double  /*feature_min_depth*/,
+                                              const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          std::uniform_real_distribution<> dist(0.0,1.0);
+                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                            {
+                              // set a uniform random a_cosine_matrix per grain
+                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                              // and is licenend accourding to this website with the following licence:
+                              //
+                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                              // don't be a jerk, and remember that anything free comes with no guarantee.""
+                              //
+                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                              // the public domain, and is yours to study, modify, and use."
+
+                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                              const double one = dist(world->get_random_number_engine());
+                              const double two = dist(world->get_random_number_engine());
+                              const double three = dist(world->get_random_number_engine());
+
+                              const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
+                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                              const double z = 2.0* three; //For magnitude of pole deflection.
+
+                              // Compute a vector V used for distributing points over the sphere
+                              // via the reflection I - V Transpose(V).  This formulation of V
+                              // will guarantee that if x[1] and x[2] are uniformly distributed,
+                              // the reflected points will be uniform on the sphere.  Note that V
+                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                              const double r  = std::sqrt( z );
+                              const double Vx = std::sin( phi ) * r;
+                              const double Vy = std::cos( phi ) * r;
+                              const double Vz = std::sqrt( 2.F - z );
+
+                              // Compute the row vector S = Transpose(V) * R, where R is a simple
+                              // rotation by theta about the z-axis.  No need to compute Sz since
+                              // it's just Vz.
+
+                              const double st = std::sin( theta );
+                              const double ct = std::cos( theta );
+                              const double Sx = Vx * ct - Vy * st;
+                              const double Sy = Vx * st + Vy * ct;
+
+                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                              // is equivalent to V S - R.
+
+                              it_rotation_matrices[0][0] = Vx * Sx - ct;
+                              it_rotation_matrices[0][1] = Vx * Sy - st;
+                              it_rotation_matrices[0][2] = Vx * Vz;
+
+                              it_rotation_matrices[1][0] = Vy * Sx + st;
+                              it_rotation_matrices[1][1] = Vy * Sy - ct;
+                              it_rotation_matrices[1][2] = Vy * Vz;
+
+                              it_rotation_matrices[2][0] = Vz * Sx;
+                              it_rotation_matrices[2][1] = Vz * Sy;
+                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                            }
+
+                          double total_size = 0;
+                          for (auto &&it_sizes : grains_local.sizes)
+                            {
+                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                              total_size += it_sizes;
+                            }
+
+                          if (normalize_grain_sizes[i])
+                            {
+                              const double one_over_total_size = 1/total_size;
+                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                            }
+
+
+                          return grains_local;
+                        }
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
+      } // namespace Grains
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.cc.bak
new file mode 100644
index 00000000000..02150f29edc
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.cc.bak
@@ -0,0 +1,231 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution deflected";
+        }
+
+        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
+          = default;
+
+        void
+        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+          prm.declare_entry("deflections",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistributionDeflected::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+          deflections = prm.get_vector<double>("deflections");
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == deflections.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and deflections (" << deflections.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                                       const double depth,
+                                                       const unsigned int composition_number,
+                                                       WorldBuilder::grains grains_,
+                                                       const double  /*feature_min_depth*/,
+                                                       const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          std::uniform_real_distribution<> dist(0.0,1.0);
+                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                            {
+                              // set a uniform random a_cosine_matrix per grain
+                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                              // and is licenend accourding to this website with the following licence:
+                              //
+                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                              // don't be a jerk, and remember that anything free comes with no guarantee.""
+                              //
+                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                              // the public domain, and is yours to study, modify, and use."
+
+                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                              const double one = dist(world->get_random_number_engine());
+                              const double two = dist(world->get_random_number_engine());
+                              const double three = dist(world->get_random_number_engine());
+
+                              const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z)
+                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                              const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
+
+                              // Compute a vector V used for distributing points over the sphere
+                              // via the reflection I - V Transpose(V).  This formulation of V
+                              // will guarantee that if x[1] and x[2] are uniformly distributed,
+                              // the reflected points will be uniform on the sphere.  Note that V
+                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                              const double r  = std::sqrt( z );
+                              const double Vx = std::sin( phi ) * r;
+                              const double Vy = std::cos( phi ) * r;
+                              const double Vz = std::sqrt( 2.F - z );
+
+                              // Compute the row vector S = Transpose(V) * R, where R is a simple
+                              // rotation by theta about the z-axis.  No need to compute Sz since
+                              // it's just Vz.
+
+                              const double st = std::sin( theta );
+                              const double ct = std::cos( theta );
+                              const double Sx = Vx * ct - Vy * st;
+                              const double Sy = Vx * st + Vy * ct;
+
+                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                              // is equivalent to V S - R.
+
+                              it_rotation_matrices[0][0] = Vx * Sx - ct;
+                              it_rotation_matrices[0][1] = Vx * Sy - st;
+                              it_rotation_matrices[0][2] = Vx * Vz;
+
+                              it_rotation_matrices[1][0] = Vy * Sx + st;
+                              it_rotation_matrices[1][1] = Vy * Sy - ct;
+                              it_rotation_matrices[1][2] = Vy * Vz;
+
+                              it_rotation_matrices[2][0] = Vz * Sx;
+                              it_rotation_matrices[2][1] = Vz * Sy;
+                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                            }
+
+                          double total_size = 0;
+                          for (auto &&it_sizes : grains_local.sizes)
+                            {
+                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                              total_size += it_sizes;
+                            }
+
+                          if (normalize_grain_sizes[i])
+                            {
+                              const double one_over_total_size = 1/total_size;
+                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                            }
+
+
+                          return grains_local;
+                        }
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
+      } // namespace Grains
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/uniform.cc.bak
new file mode 100644
index 00000000000..110bd919078
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/uniform.cc.bak
@@ -0,0 +1,177 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/grains/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/utilities.h"
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Grains
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform grains model. All grains start exactly the same.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
+                            "A list with the rotation matrices of the grains which are present there for each compositions.");
+
+          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
+                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace", "multiply"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(-1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
+
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
+          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
+
+          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
+                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
+
+
+          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
+                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
+
+          if (set_euler_angles)
+            {
+              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
+              rotation_matrices.resize(euler_angles_vector.size());
+              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
+                {
+                  rotation_matrices[i] = Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
+                }
+
+            }
+          else
+            {
+              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
+            }
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+
+
+          WBAssertThrow(compositions.size() == rotation_matrices.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                            const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                            const double depth,
+                            const unsigned int composition_number,
+                            WorldBuilder::grains grains_,
+                            const double  /*feature_min_depth*/,
+                            const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
+
+                          const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
+                          std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
+
+                          return grains_local;
+                        }
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_GRAINS_MODEL(Uniform, uniform)
+      } // namespace Grains
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/adiabatic.cc.bak
new file mode 100644
index 00000000000..88d83639032
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/adiabatic.cc.bak
@@ -0,0 +1,171 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/temperature/adiabatic.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace ContinentalPlateModels
+    {
+      namespace Temperature
+      {
+        Adiabatic::Adiabatic(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          potential_mantle_temperature(NaN::DSNAN),
+          thermal_expansion_coefficient(NaN::DSNAN),
+          specific_heat(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "adiabatic";
+        }
+
+        Adiabatic::~Adiabatic()
+          = default;
+
+        void
+        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          prm.declare_entry("", Types::Object(),
+                            "Adiabatic temperature model. Uses global values by default.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("potential mantle temperature", Types::Double(-1),
+                            "The potential temperature of the mantle at the surface in Kelvin. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
+                            "The thermal expansion coefficient in $K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("specific heat", Types::Double(-1),
+                            "The specific heat in $J kg^{-1} K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+        }
+
+        void
+        Adiabatic::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
+          if (potential_mantle_temperature < 0)
+            potential_mantle_temperature =  this->world->potential_mantle_temperature;
+
+
+          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
+          if (thermal_expansion_coefficient < 0)
+            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
+
+          specific_heat = prm.get<double>("specific heat");
+          if (specific_heat < 0)
+            specific_heat =  this->world->specific_heat;
+
+          // Some assertions in debug mode can't hurt and have helped before.
+          WBAssert(!std::isnan(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
+          WBAssert(std::isfinite(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
+
+          WBAssert(!std::isnan(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
+
+          WBAssert(!std::isnan(specific_heat),
+                   "specific_heat is not a number: " << specific_heat << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "specific_heat is not a finite: " << specific_heat << '.');
+
+        }
+
+
+        double
+        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity_norm,
+                                   double temperature_,
+                                   const double /*feature_min_depth*/,
+                                   const double /*feature_max_depth*/) const
+        {
+
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  const double adabatic_temperature = potential_mantle_temperature *
+                                                      std::exp(((thermal_expansion_coefficient * gravity_norm) /
+                                                                specific_heat) * depth);
+
+
+                  WBAssert(!std::isnan(adabatic_temperature),
+                           "adabatic_temperature is not a number: " << adabatic_temperature << ". "
+                           <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
+                           <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
+                           << ", gravity_norm = " << gravity_norm
+                           << ", specific_heat = " << specific_heat
+                           << ", depth = " << depth);
+
+                  WBAssert(std::isfinite(adabatic_temperature),
+                           "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
+
+                  return apply_operation(operation,temperature_,adabatic_temperature);
+                }
+            }
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_TEMPERATURE_MODEL(Adiabatic, adiabatic)
+      } // namespace Temperature
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/interface.cc.bak
new file mode 100644
index 00000000000..1e582d955ce
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/interface.cc.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/temperature/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Temperature
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          // The type needs to be stored in a separate value, otherwise there are memory issues
+          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
+
+          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
+          {
+            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
+            {
+              "operation", type,
+              "Whether the value should replace any value previously defined at this location (replace), "
+              "add the value to the previously define value (add) or subtract the value to the previously "
+              "define value (subtract)."
+            }
+          });
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Temperature
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/linear.cc.bak
new file mode 100644
index 00000000000..2c92fae4f7d
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/linear.cc.bak
@@ -0,0 +1,157 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/temperature/linear.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace ContinentalPlateModels
+    {
+      namespace Temperature
+      {
+        Linear::Linear(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          top_temperature(NaN::DSNAN),
+          bottom_temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "linear";
+        }
+
+        Linear::~Linear()
+          = default;
+
+        void
+        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `max depth` to the required parameters.
+          prm.declare_entry("", Types::Object({"max depth"}),
+                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("top temperature", Types::Double(293.15),
+                            "The temperature at the top in degree Kelvin of this feature."
+                            "If the value is below zero, the an adiabatic temperature is used.");
+
+          prm.declare_entry("bottom temperature", Types::Double(-1),
+                            "The temperature at the top in degree Kelvin of this feature. "
+                            "If the value is below zero, an adiabatic temperature is used.");
+
+        }
+
+        void
+        Linear::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          top_temperature = prm.get<double>("top temperature");
+          bottom_temperature = prm.get<double>("bottom temperature");
+        }
+
+
+        double
+        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                const double depth,
+                                const double gravity_norm,
+                                double temperature_,
+                                const double feature_min_depth,
+                                const double feature_max_depth) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  const double min_depth_local_local = std::max(feature_min_depth, min_depth_local);
+                  const double max_depth_local_local = std::min(feature_max_depth, max_depth_local);
+
+                  double top_temperature_local = top_temperature;
+                  if (top_temperature_local < 0)
+                    {
+                      top_temperature_local =  this->world->potential_mantle_temperature *
+                                               std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                         this->world->specific_heat) * min_depth_local_local);
+                    }
+
+                  double bottom_temperature_local = bottom_temperature;
+                  if (bottom_temperature_local < 0)
+                    {
+                      bottom_temperature_local =  this->world->potential_mantle_temperature *
+                                                  std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                            this->world->specific_heat) * max_depth_local_local);
+                    }
+
+                  const double new_temperature = top_temperature_local + (max_depth_local_local - min_depth_local_local < 10.0*std::numeric_limits<double>::epsilon() ? 0.0 :
+                                                        (depth - min_depth_local) *
+                                                        ((bottom_temperature_local - top_temperature_local) / (max_depth_local_local - min_depth_local_local)));
+
+                  WBAssert(!std::isnan(new_temperature), "Temperature is not a number: " << new_temperature
+                           << ", based on a temperature model with the name " << this->name);
+                  WBAssert(std::isfinite(new_temperature), "Temperature is not a finite: " << new_temperature
+                           << ", based on a temperature model with the name " << this->name
+                           << ", top_temperature_local = " << top_temperature_local << ", depth = " << depth << ", min_depth_local = " << min_depth_local
+                           << ", bottom_temperature_local= " << bottom_temperature_local << ", top_temperature_local=" << top_temperature_local
+                           << ",max_depth_local_local=" << max_depth_local_local << ", min_depth_local_local =" << min_depth_local_local
+                           << ", feature_max_depth = " << feature_max_depth << ", feature_max_depth = " << feature_max_depth);
+
+                  return apply_operation(operation,temperature_,new_temperature);
+                }
+            }
+
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_TEMPERATURE_MODEL(Linear, linear)
+      } // namespace Temperature
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/uniform.cc.bak
new file mode 100644
index 00000000000..ff4b8d695b3
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/uniform.cc.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/continental_plate_models/temperature/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace ContinentalPlateModels
+    {
+      namespace Temperature
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `temperature` to the required parameters.
+          prm.declare_entry("", Types::Object({"temperature"}),
+                            "Uniform temperature model. Set the temperature to a constant value.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("temperature", Types::Double(293.15),
+                            "The temperature in degree Kelvin which this feature should have");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          temperature = prm.get<double>("temperature");
+        }
+
+
+        double
+        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                 const double depth,
+                                 const double  /*gravity*/,
+                                 double temperature_,
+                                 const double /*feature_min_depth*/,
+                                 const double /*feature_max_depth*/) const
+        {
+          const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+          const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+          if (depth <= max_depth_local &&  depth >= min_depth_local)
+            {
+              if (depth <= max_depth && depth >= min_depth)
+                {
+                  return apply_operation(operation,temperature_,temperature);
+                }
+            }
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_TEMPERATURE_MODEL(Uniform, uniform)
+      } // namespace Temperature
+    } // namespace ContinentalPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/fault.cc.bak b/contrib/world_builder/source/world_builder/features/fault.cc.bak
new file mode 100644
index 00000000000..7f0c43fd5bf
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault.cc.bak
@@ -0,0 +1,730 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "world_builder/features/fault.h"
+
+
+#include "glm/glm.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/point.h"
+#include "world_builder/types/segment.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/world.h"
+#include <algorithm>
+
+using namespace std;
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    Fault::Fault(WorldBuilder::World *world_)
+      :
+      reference_point(0,0,cartesian)
+    {
+      this->world = world_;
+      this->name = "fault";
+    }
+
+    Fault::~Fault()
+      = default;
+
+
+
+    void Fault::make_snippet(Parameters &prm)
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+
+      const std::string path = prm.get_full_json_path();
+
+      Pointer((path + "/body").c_str()).Set(declarations,"object");
+      Pointer((path + "/body/model").c_str()).Set(declarations,"fault");
+      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Fault}");
+      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/segments").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/sections").c_str()).Create(declarations).SetArray();
+    }
+
+
+
+    void
+    Fault::declare_entries(Parameters &prm,
+                           const std::string &parent_name,
+                           const std::vector<std::string> &required_entries)
+    {
+
+      // This statement is needed because of the recursion associated with
+      // the sections entry.
+      if (parent_name == "items")
+        {
+          prm.enter_subsection("properties");
+        }
+      else
+        {
+          prm.declare_entry("", Types::Object(required_entries), "Fault object. Requires properties `model` and `coordinates`.");
+        }
+      prm.declare_entry("min depth", Types::Double(0),
+                        "The depth to which this feature is present");
+      prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
+                        "The depth to which this feature is present");
+      prm.declare_entry("dip point", Types::Point<2>(),
+                        "The depth to which this feature is present");
+
+      prm.declare_entry("segments", Types::Array(Types::Segment(0,Point<2>(0,0,invalid),Point<2>(0,0,invalid),Point<2>(0,0,invalid),
+                                                                Types::PluginSystem("", Features::FaultModels::Temperature::Interface::declare_entries, {"model"}),
+                                                                Types::PluginSystem("", Features::FaultModels::Composition::Interface::declare_entries, {"model"}),
+                                                                Types::PluginSystem("", Features::FaultModels::Grains::Interface::declare_entries, {"model"}))),
+                        "The depth to which this feature is present");
+
+      prm.declare_entry("temperature models",
+                        Types::PluginSystem("", Features::FaultModels::Temperature::Interface::declare_entries, {"model"}),
+                        "A list of temperature models.");
+      prm.declare_entry("composition models",
+                        Types::PluginSystem("", Features::FaultModels::Composition::Interface::declare_entries, {"model"}),
+                        "A list of composition models.");
+      prm.declare_entry("grains models",
+                        Types::PluginSystem("", Features::FaultModels::Grains::Interface::declare_entries, {"model"}),
+                        "A list of grains models.");
+
+      if (parent_name != "items")
+        {
+          // This only happens if we are not in sections
+          prm.declare_entry("sections", Types::Array(Types::PluginSystem("",Features::Fault::declare_entries, {"coordinate"}, false)),"A list of feature properties for a coordinate.");
+        }
+      else
+        {
+
+          // this only happens in sections
+          prm.declare_entry("coordinate", Types::UnsignedInt(0),
+                            "The coordinate which should be overwritten");
+
+          prm.leave_subsection();
+        }
+    }
+
+    void
+    Fault::parse_entries(Parameters &prm)
+    {
+      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
+
+      this->name = prm.get<std::string>("name");
+
+      std::string tag = prm.get<std::string>("tag");
+      if (tag == "")
+        {
+          tag = "fault";
+        }
+      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
+
+      this->get_coordinates("coordinates", prm, coordinate_system);
+
+
+      starting_depth = prm.get<double>("min depth");
+      maximum_depth = prm.get<double>("max depth");
+
+      const size_t n_sections = this->original_number_of_coordinates;
+
+      reference_point = prm.get<Point<2> >("dip point");
+
+      if (coordinate_system == spherical)
+        {
+          // When spherical, input is in degrees, so change to radians for internal use.
+          reference_point *= (Consts::PI/180);
+        }
+
+      default_temperature_models.resize(0);
+      default_composition_models.resize(0);
+      default_grains_models.resize(0);
+      prm.get_shared_pointers<Features::FaultModels::Temperature::Interface>("temperature models", default_temperature_models);
+      prm.get_shared_pointers<Features::FaultModels::Composition::Interface>("composition models", default_composition_models);
+      prm.get_shared_pointers<Features::FaultModels::Grains::Interface>("grains models", default_grains_models);
+
+      // get the default segments.
+      default_segment_vector = prm.get_vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
+      Features::FaultModels::Composition::Interface,
+      Features::FaultModels::Grains::Interface> >("segments", default_temperature_models, default_composition_models,default_grains_models);
+
+
+      // This vector stores segments to this coordinate/section.
+      // First used (raw) pointers to the segment relevant to this coordinate/section,
+      // but I do not trust it won't fail when memory is moved. So storing the all the data now.
+      segment_vector.resize(0);
+      segment_vector.resize(n_sections, default_segment_vector);
+
+
+      // now search whether a section is present, if so, replace the default segments.
+      std::vector<std::unique_ptr<Features::Fault> > sections_vector;
+      prm.get_unique_pointers("sections", sections_vector);
+
+      prm.enter_subsection("sections");
+      for (unsigned int i_section = 0; i_section < n_sections; ++i_section)
+        {
+          // first check whether this section/coordinate has a a special overwrite
+          for (unsigned int i_sector = 0; i_sector < sections_vector.size(); ++i_sector)
+            {
+              prm.enter_subsection(std::to_string(i_sector));
+              {
+                const unsigned int change_coord_number = prm.get<unsigned int>("coordinate");
+
+                WBAssertThrow(segment_vector.size() > change_coord_number, "Error: for subducting plate with name: '" << this->name
+                              << "', trying to change the section of coordinate " << change_coord_number
+                              << " while only " << segment_vector.size() << " coordinates are defined.");
+
+                std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> > local_default_temperature_models;
+                std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface>  > local_default_composition_models;
+                std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface>  > local_default_grains_models;
+
+                if (!prm.get_shared_pointers<Features::FaultModels::Temperature::Interface>("temperature models", local_default_temperature_models))
+                  {
+                    // no local temperature model, use global default
+                    local_default_temperature_models = default_temperature_models;
+                  }
+
+                if (!prm.get_shared_pointers<Features::FaultModels::Composition::Interface>("composition models", local_default_composition_models))
+                  {
+                    // no local composition model, use global default
+                    local_default_composition_models = default_composition_models;
+                  }
+
+                if (!prm.get_shared_pointers<Features::FaultModels::Grains::Interface>("grains models", local_default_grains_models))
+                  {
+                    // no local grains model, use global default
+                    local_default_grains_models = default_grains_models;
+                  }
+
+                segment_vector[change_coord_number] = prm.get_vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
+                                                      Features::FaultModels::Composition::Interface,
+                                                      Features::FaultModels::Grains::Interface> >("segments", local_default_temperature_models, local_default_composition_models, local_default_grains_models);
+
+                WBAssertThrow(segment_vector[change_coord_number].size() == default_segment_vector.size(),
+                              "Error: There are not the same amount of segments in section with coordinate " << change_coord_number
+                              << " (" << segment_vector[change_coord_number].size() << " segments) as in the default segment ("
+                              << default_segment_vector.size() << " segments). This is not allowed.");
+
+                prm.enter_subsection("segments");
+                {
+                  for (unsigned int i = 0; i < segment_vector[change_coord_number].size(); ++i)
+                    {
+                      prm.enter_subsection(std::to_string(i));
+                      {
+                        prm.enter_subsection("temperature models");
+                        {
+                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].temperature_systems.size(); ++j)
+                            {
+                              prm.enter_subsection(std::to_string(j));
+                              {
+                                segment_vector[change_coord_number][i].temperature_systems[j]->parse_entries(prm);
+                              }
+                              prm.leave_subsection();
+                            }
+                        }
+                        prm.leave_subsection();
+
+
+                        prm.enter_subsection("composition models");
+                        {
+                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].composition_systems.size(); ++j)
+                            {
+                              prm.enter_subsection(std::to_string(j));
+                              {
+                                segment_vector[change_coord_number][i].composition_systems[j]->parse_entries(prm);
+                              }
+                              prm.leave_subsection();
+                            }
+                        }
+                        prm.leave_subsection();
+
+
+                        prm.enter_subsection("grains models");
+                        {
+                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].grains_systems.size(); ++j)
+                            {
+                              prm.enter_subsection(std::to_string(j));
+                              {
+                                segment_vector[change_coord_number][i].grains_systems[j]->parse_entries(prm);
+                              }
+                              prm.leave_subsection();
+                            }
+                        }
+                        prm.leave_subsection();
+                      }
+                      prm.leave_subsection();
+                    }
+                }
+                prm.leave_subsection();
+
+              }
+              prm.leave_subsection();
+            }
+
+        }
+      prm.leave_subsection();
+
+
+      prm.enter_subsection("segments");
+      {
+        for (unsigned int i = 0; i < default_segment_vector.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              prm.enter_subsection("temperature models");
+              {
+                for (unsigned int j = 0; j < default_segment_vector[i].temperature_systems.size(); ++j)
+                  {
+                    prm.enter_subsection(std::to_string(j));
+                    {
+                      default_segment_vector[i].temperature_systems[j]->parse_entries(prm);
+                    }
+                    prm.leave_subsection();
+                  }
+              }
+              prm.leave_subsection();
+
+
+              prm.enter_subsection("composition models");
+              {
+                for (unsigned int j = 0; j < default_segment_vector[i].composition_systems.size(); ++j)
+                  {
+                    prm.enter_subsection(std::to_string(j));
+                    {
+                      default_segment_vector[i].composition_systems[j]->parse_entries(prm);
+                    }
+                    prm.leave_subsection();
+                  }
+              }
+              prm.leave_subsection();
+
+
+              prm.enter_subsection("grains models");
+              {
+                for (unsigned int j = 0; j < default_segment_vector[i].grains_systems.size(); ++j)
+                  {
+                    prm.enter_subsection(std::to_string(j));
+                    {
+                      default_segment_vector[i].grains_systems[j]->parse_entries(prm);
+                    }
+                    prm.leave_subsection();
+                  }
+              }
+              prm.leave_subsection();
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+
+      maximum_fault_thickness = 0;
+      maximum_total_fault_length = 0;
+      total_fault_length.resize(original_number_of_coordinates);
+      fault_segment_lengths.resize(original_number_of_coordinates);
+      fault_segment_thickness.resize(original_number_of_coordinates);
+      fault_segment_top_truncation.resize(original_number_of_coordinates);
+      fault_segment_angles.resize(original_number_of_coordinates);
+
+      for (unsigned int i = 0; i < segment_vector.size(); ++i)
+        {
+          double local_total_fault_length = 0;
+          fault_segment_lengths[i].resize(segment_vector[i].size());
+          fault_segment_thickness[i].resize(segment_vector[i].size(), Point<2>(invalid));
+          fault_segment_top_truncation[i].resize(segment_vector[i].size(), Point<2>(invalid));
+          fault_segment_angles[i].resize(segment_vector[i].size(), Point<2>(invalid));
+
+          for (unsigned int j = 0; j < segment_vector[i].size(); ++j)
+            {
+              fault_segment_lengths[i][j] = segment_vector[i][j].value_length;
+              local_total_fault_length += segment_vector[i][j].value_length;
+
+              fault_segment_thickness[i][j] = segment_vector[i][j].value_thickness;
+              maximum_fault_thickness = std::max(maximum_fault_thickness, fault_segment_thickness[i][j][0]);
+              maximum_fault_thickness = std::max(maximum_fault_thickness, fault_segment_thickness[i][j][1]);
+              fault_segment_top_truncation[i][j] = segment_vector[i][j].value_top_truncation;
+
+              fault_segment_angles[i][j] = segment_vector[i][j].value_angle * (Consts::PI/180);
+            }
+          total_fault_length[i] = local_total_fault_length;
+          maximum_total_fault_length = std::max(maximum_total_fault_length, local_total_fault_length);
+        }
+
+
+      // Find minimal and maximal coordinates. Do this by finding the
+      // leftmost/rightmost point with regard to either the [0] or [1]
+      // coordinate, and then takes its [0] or [1] element.
+      auto compare_x_coordinate = [](auto p1, auto p2)
+      {
+        return p1[0]<p2[0];
+      };
+
+      min_along_x = (*std::min_element(coordinates.begin(), coordinates.end(), compare_x_coordinate)) [0];
+      max_along_x = (*std::max_element(coordinates.begin(), coordinates.end(), compare_x_coordinate)) [0];
+
+
+      auto compare_y_coordinate = [](auto p1, auto p2)
+      {
+        return p1[1]<p2[1];
+      };
+
+      min_along_y = (*std::min_element(coordinates.begin(), coordinates.end(), compare_y_coordinate)) [1];
+      max_along_y = (*std::max_element(coordinates.begin(), coordinates.end(), compare_y_coordinate)) [1];
+
+      min_lat_cos_inv = 1. / std::cos(min_along_y);
+      max_lat_cos_inv = 1. / std::cos(max_along_y);
+
+
+      // Compute the surface bounding box
+      buffer_around_fault_cartesian = (maximum_fault_thickness + maximum_total_fault_length);
+      if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical)
+        {
+          const double starting_radius_inv = 1 / (world->parameters.coordinate_system->max_model_depth());
+          std::pair<Point<2>, Point<2> > &spherical_bounding_box = surface_bounding_box.get_boundary_points();
+
+          const double buffer_around_fault_spherical = 2 * Consts::PI * buffer_around_fault_cartesian * starting_radius_inv;
+
+          spherical_bounding_box.first = {(min_along_x - buffer_around_fault_spherical * min_lat_cos_inv) ,
+                                          (min_along_y - buffer_around_fault_spherical), spherical
+                                         } ;
+
+          spherical_bounding_box.second = {(max_along_x + buffer_around_fault_spherical * max_lat_cos_inv) ,
+                                           (max_along_y + buffer_around_fault_spherical), spherical
+                                          };
+        }
+      else if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::cartesian)
+        {
+          std::pair<Point<2>, Point<2> > &bounding_box = surface_bounding_box.get_boundary_points();
+          bounding_box.first = {min_along_x, min_along_y, cartesian};
+          bounding_box.second = {max_along_x, max_along_y, cartesian};
+          surface_bounding_box.extend(buffer_around_fault_cartesian);
+        }
+    }
+
+
+    const BoundingBox<2> &
+    Fault::get_surface_bounding_box () const
+    {
+      return surface_bounding_box;
+    }
+
+
+    void
+    Fault::properties(const Point<3> &position_in_cartesian_coordinates,
+                      const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                      const double depth,
+                      const std::vector<std::array<unsigned int,3>> &properties,
+                      const double gravity_norm,
+                      const std::vector<size_t> &entry_in_output,
+                      std::vector<double> &output) const
+    {
+      // The 'depth coordinate' is the z-coordinate in Cartesian coordinates, and radius in spherical coordinates.
+      // The depth input parameter is the distance from the surface to the position,
+      // the starting radius is the distance from the bottom of the model to the surface.
+      const double starting_radius = position_in_natural_coordinates.get_depth_coordinate() + depth - starting_depth;
+
+      WBAssert(std::abs(starting_radius) > std::numeric_limits<double>::epsilon(), "World Builder error: starting_radius can not be zero. "
+               << "Position = " << position_in_cartesian_coordinates[0] << ':' << position_in_cartesian_coordinates[1] << ':' << position_in_cartesian_coordinates[2]
+               << ", position_in_natural_coordinates.get_depth_coordinate() = " << position_in_natural_coordinates.get_depth_coordinate()
+               << ", depth = " << depth
+               << ", starting_depth " << starting_depth
+              );
+
+      // todo: explain and check -starting_depth
+      if (depth <= maximum_depth && depth >= starting_depth && depth <= maximum_total_fault_length + maximum_fault_thickness &&
+          get_surface_bounding_box().point_inside(Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
+                                                           world->parameters.coordinate_system->natural_coordinate_system())))
+        {
+          // todo: explain
+          const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
+            WorldBuilder::Utilities::distance_point_from_curved_planes(position_in_cartesian_coordinates,
+                                                                       position_in_natural_coordinates,
+                                                                       reference_point,
+                                                                       coordinates,
+                                                                       fault_segment_lengths,
+                                                                       fault_segment_angles,
+                                                                       starting_radius,
+                                                                       this->world->parameters.coordinate_system,
+                                                                       true,
+                                                                       this->bezier_curve);
+
+          const double distance_from_plane = distance_from_planes.distance_from_plane;
+          const double distance_along_plane = distance_from_planes.distance_along_plane;
+          const double section_fraction = distance_from_planes.fraction_of_section;
+          const size_t current_section = distance_from_planes.section;
+          const size_t next_section = current_section + 1;
+          const size_t current_segment = distance_from_planes.segment;
+          const double segment_fraction = distance_from_planes.fraction_of_segment;
+
+          if (abs(distance_from_plane) < std::numeric_limits<double>::infinity() || (distance_along_plane) < std::numeric_limits<double>::infinity())
+            {
+              // We want to do both section (horizontal) and segment (vertical) interpolation.
+              // first for thickness
+              const double thickness_up = fault_segment_thickness[current_section][current_segment][0]
+                                          + section_fraction
+                                          * (fault_segment_thickness[next_section][current_segment][0]
+                                             - fault_segment_thickness[current_section][current_segment][0]);
+              const double thickness_down = fault_segment_thickness[current_section][current_segment][1]
+                                            + section_fraction
+                                            * (fault_segment_thickness[next_section][current_segment][1]
+                                               - fault_segment_thickness[current_section][current_segment][1]);
+              const double thickness_local = thickness_up + segment_fraction * (thickness_down - thickness_up);
+
+
+              // if the thickness is zero, we don't need to compute anything, so return.
+              if (std::fabs(thickness_local) < 2.0 * std::numeric_limits<double>::epsilon())
+                return;
+
+              // secondly for top truncation
+              const double top_truncation_up = fault_segment_top_truncation[current_section][current_segment][0]
+                                               + section_fraction
+                                               * (fault_segment_top_truncation[next_section][current_segment][0]
+                                                  - fault_segment_top_truncation[current_section][current_segment][0]);
+              const double top_truncation_down = fault_segment_top_truncation[current_section][current_segment][1]
+                                                 + section_fraction
+                                                 * (fault_segment_top_truncation[next_section][current_segment][1]
+                                                    - fault_segment_top_truncation[current_section][current_segment][1]);
+              const double top_truncation_local = top_truncation_up + segment_fraction * (top_truncation_down - top_truncation_up);
+
+              // if the thickness is smaller than what is truncated off at the top, we don't need to compute anything, so return.
+              if (thickness_local < top_truncation_local)
+                return;
+
+
+
+              const double max_fault_length = total_fault_length[current_section] +
+                                              section_fraction *
+                                              (total_fault_length[next_section] - total_fault_length[current_section]);
+              const AdditionalParameters additional_parameters = {max_fault_length,thickness_local};
+
+              // Check if we are inside the fault.
+              // Every distance from -thickness/2 to +thickness/2 is inside the fault.
+              if (std::fabs(distance_from_plane) <= thickness_local * 0.5 &&
+                  distance_along_plane > 0 &&
+                  distance_along_plane <= max_fault_length)
+                {
+                  for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
+                    {
+                      switch (properties[i_property][0])
+                        {
+                          case 1: // temperature
+                          {
+                            double temperature_current_section = output[entry_in_output[i_property]];
+                            double temperature_next_section = output[entry_in_output[i_property]];
+
+                            for (const auto &temperature_model: segment_vector[current_section][current_segment].temperature_systems)
+                              {
+                                temperature_current_section = temperature_model->get_temperature(position_in_cartesian_coordinates,
+                                                                                                 depth,
+                                                                                                 gravity_norm,
+                                                                                                 temperature_current_section,
+                                                                                                 starting_depth,
+                                                                                                 maximum_depth,
+                                                                                                 distance_from_planes,
+                                                                                                 additional_parameters);
+
+                                WBAssert(!std::isnan(temperature_current_section), "Temperature is not a number: " << temperature_current_section
+                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+                                WBAssert(std::isfinite(temperature_current_section), "Temperature is not finite: " << temperature_current_section
+                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+
+                              }
+
+                            for (const auto &temperature_model: segment_vector[next_section][current_segment].temperature_systems)
+                              {
+                                temperature_next_section = temperature_model->get_temperature(position_in_cartesian_coordinates,
+                                                                                              depth,
+                                                                                              gravity_norm,
+                                                                                              temperature_next_section,
+                                                                                              starting_depth,
+                                                                                              maximum_depth,
+                                                                                              distance_from_planes,
+                                                                                              additional_parameters);
+
+                                WBAssert(!std::isnan(temperature_next_section), "Temperature is not a number: " << temperature_next_section
+                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+                                WBAssert(std::isfinite(temperature_next_section), "Temperature is not a finite: " << temperature_next_section
+                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+
+                              }
+
+                            // linear interpolation between current and next section temperatures
+                            output[entry_in_output[i_property]] = temperature_current_section + section_fraction * (temperature_next_section - temperature_current_section);
+                            break;
+                          }
+                          case 2: // composition
+                          {
+                            double composition_current_section = output[entry_in_output[i_property]];
+                            double composition_next_section = output[entry_in_output[i_property]];
+
+                            for (const auto &composition_model: segment_vector[current_section][current_segment].composition_systems)
+                              {
+                                composition_current_section = composition_model->get_composition(position_in_cartesian_coordinates,
+                                                                                                 depth,
+                                                                                                 properties[i_property][1],
+                                                                                                 composition_current_section,
+                                                                                                 starting_depth,
+                                                                                                 maximum_depth,
+                                                                                                 distance_from_planes,
+                                                                                                 additional_parameters);
+
+                                WBAssert(!std::isnan(composition_current_section), "Composition_current_section is not a number: " << composition_current_section
+                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+                                WBAssert(std::isfinite(composition_current_section), "Composition_current_section is not finite: " << composition_current_section
+                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+
+                              }
+
+                            for (const auto &composition_model: segment_vector[next_section][current_segment].composition_systems)
+                              {
+                                composition_next_section = composition_model->get_composition(position_in_cartesian_coordinates,
+                                                                                              depth,
+                                                                                              properties[i_property][1],
+                                                                                              composition_next_section,
+                                                                                              starting_depth,
+                                                                                              maximum_depth,
+                                                                                              distance_from_planes,
+                                                                                              additional_parameters);
+
+                                WBAssert(!std::isnan(composition_next_section), "Composition_next_section is not a number: " << composition_next_section
+                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+                                WBAssert(std::isfinite(composition_next_section), "Composition_next_section is not finite: " << composition_next_section
+                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+
+                              }
+
+                            // linear interpolation between current and next section temperatures
+                            output[entry_in_output[i_property]] = composition_current_section + section_fraction * (composition_next_section - composition_current_section);
+                            break;
+                          }
+                          case 3: // grains
+                          {
+                            WorldBuilder::grains grains(output,properties[i_property][2],entry_in_output[i_property]);
+                            WorldBuilder::grains grains_current_section = grains;
+                            WorldBuilder::grains grains_next_section = grains;
+
+                            for (const auto &grains_model: segment_vector[current_section][current_segment].grains_systems)
+                              {
+                                grains_current_section = grains_model->get_grains(position_in_cartesian_coordinates,
+                                                                                  depth,
+                                                                                  properties[i_property][1],
+                                                                                  grains_current_section,
+                                                                                  starting_depth,
+                                                                                  maximum_depth,
+                                                                                  distance_from_planes,
+                                                                                  additional_parameters);
+
+                              }
+
+                            for (const auto &grains_model: segment_vector[next_section][current_segment].grains_systems)
+                              {
+                                grains_next_section = grains_model->get_grains(position_in_cartesian_coordinates,
+                                                                               depth,
+                                                                               properties[i_property][1],
+                                                                               grains_next_section,
+                                                                               starting_depth,
+                                                                               maximum_depth,
+                                                                               distance_from_planes,
+                                                                               additional_parameters);
+
+                              }
+
+                            // linear interpolation between current and next section temperatures
+                            for (size_t i = 0; i < grains.sizes.size(); i++)
+                              {
+                                grains.sizes[i] = grains_current_section.sizes[i] + section_fraction * (grains_next_section.sizes[i] - grains_current_section.sizes[i]);
+                              }
+
+                            // average two rotations matrices through quaternions.
+                            for (size_t i = 0; i < grains_current_section.rotation_matrices.size(); i++)
+                              {
+                                const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(grains_current_section.rotation_matrices[i]);
+                                const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(grains_next_section.rotation_matrices[i]);
+
+                                const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,section_fraction);
+
+                                grains.rotation_matrices[i] = glm::quaternion::mat3_cast(quat_average);
+                              }
+
+                            grains.unroll_into(output,entry_in_output[i_property]);
+                            break;
+                          }
+                          case 4:
+                          {
+                            output[entry_in_output[i_property]] = static_cast<double>(tag_index);
+                            break;
+                          }
+                          default:
+                          {
+                            WBAssertThrow(false,
+                                          "Internal error: Unimplemented property provided. " <<
+                                          "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
+                                          "Provided property number was: " << properties[i_property][0]);
+                          }
+                        }
+                    }
+
+                }
+            }
+        }
+
+    }
+
+    Objects::PlaneDistances
+    Fault::distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
+                                     const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                     const double depth) const
+    {
+      // The depth variable is the distance from the surface to the position, the depth
+      // coordinate is the distance from the bottom of the model to the position and
+      // the starting radius is the distance from the bottom of the model to the surface.
+      const double starting_radius = position_in_natural_coordinates.get_depth_coordinate() + depth - starting_depth;
+
+      WBAssert(std::abs(starting_radius) > std::numeric_limits<double>::epsilon(), "World Builder error: starting_radius can not be zero. "
+               << "Position = " << position_in_cartesian_coordinates[0] << ':' << position_in_cartesian_coordinates[1] << ':' << position_in_cartesian_coordinates[2]
+               << ", natural_coordinate.get_depth_coordinate() = " << position_in_natural_coordinates.get_depth_coordinate()
+               << ", depth = " << depth
+               << ", starting_depth " << starting_depth
+              );
+
+      const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
+        WorldBuilder::Utilities::distance_point_from_curved_planes(position_in_cartesian_coordinates,
+                                                                   position_in_natural_coordinates,
+                                                                   reference_point,
+                                                                   coordinates,
+                                                                   fault_segment_lengths,
+                                                                   fault_segment_angles,
+                                                                   starting_radius,
+                                                                   this->world->parameters.coordinate_system,
+                                                                   false,
+                                                                   this->bezier_curve);
+
+      Objects::PlaneDistances plane_distances(distance_from_planes.distance_from_plane, distance_from_planes.distance_along_plane);
+      return plane_distances;
+    }
+
+    /**
+     * Register plugin
+     */
+    WB_REGISTER_FEATURE(Fault, fault)
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/composition/interface.cc.bak
new file mode 100644
index 00000000000..ed645a38e29
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/composition/interface.cc.bak
@@ -0,0 +1,81 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/composition/interface.h"
+
+#include <algorithm>
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Composition
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/composition/smooth.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/composition/smooth.cc.bak
new file mode 100644
index 00000000000..e9e31c1bdf7
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/composition/smooth.cc.bak
@@ -0,0 +1,129 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/composition/smooth.h"
+
+#include <world_builder/assert.h>
+#include <world_builder/nan.h>
+#include <world_builder/parameters.h>
+#include <world_builder/utilities.h>
+
+#include <world_builder/types/array.h>
+#include <world_builder/types/double.h>
+#include <world_builder/types/object.h>
+#include <world_builder/types/string.h>
+#include <world_builder/types/unsigned_int.h>
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        Smooth::Smooth(WorldBuilder::World *world_)
+          :
+          min_distance(NaN::DSNAN),
+          side_distance(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "smooth";
+        }
+
+        Smooth::~Smooth()
+          = default;
+
+        void
+        Smooth::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}), "Compositional model object");
+
+          prm.declare_entry("min distance fault center", Types::Double(0),
+                            "The distance in meters from which the composition of this feature is present.");
+          prm.declare_entry("side distance fault center", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance over which the composition is reduced from 1 to 0.");
+          prm.declare_entry("center fractions",  Types::Array(Types::Double(1.0),1),
+                            "The composition fraction at the center of the fault.");
+          prm.declare_entry("side fractions",  Types::Array(Types::Double(0.0),1),
+                            "The composition fraction at the sides of this feature.");
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the labels of the composition which are present there.");
+          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value. Replacing implies that all compositions not "
+                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
+        }
+
+        void
+        Smooth::parse_entries(Parameters &prm)
+        {
+          min_distance = prm.get<double>("min distance fault center");
+          side_distance = prm.get<double>("side distance fault center");
+          WBAssert(side_distance >= min_distance, "distance at the side needs to be larger or equal than the min distance.");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          center_fraction = prm.get_vector<double>("center fractions");
+          side_fraction = prm.get_vector<double>("side fractions");
+          compositions = prm.get_vector<unsigned int>("compositions");
+        }
+
+
+        double
+        Smooth::get_composition( const Point<3> & /*position*/,
+                                 const double  /*depth*/,
+                                 const unsigned int composition_number,
+                                 double composition_,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/,
+                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                 const AdditionalParameters & /*additional_parameters*/) const
+        {
+          double composition = composition_;
+
+          for (unsigned int i =0; i < compositions.size(); ++i)
+            {
+              if (compositions[i] == composition_number)
+                {
+
+                  // Hyperbolic tangent goes from 0 to 1 over approximately x=(0, 2) without any arguments. The function is written
+                  // so that the composition returned 1 to 0 over the side_distance on either sides.
+                  composition = (center_fraction[i] - side_fraction[i]) * ( 1 - std::tanh(10 * (distance_from_planes.distance_from_plane
+                                                                                                - side_distance/2)/side_distance ) )/2 ;
+
+                  return apply_operation(operation,composition_,composition);
+                }
+            }
+
+          if (operation == Operations::REPLACE)
+            return 0.0;
+
+          return composition;
+        }
+
+        WB_REGISTER_FEATURE_FAULT_COMPOSITION_MODEL (Smooth, smooth)
+      } // namespace Composition
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/composition/uniform.cc.bak
new file mode 100644
index 00000000000..c125eb39440
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/composition/uniform.cc.bak
@@ -0,0 +1,124 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/composition/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform compositional model. Sets constant compositional field.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance fault center", Types::Double(0),
+                            "The distance in meters from which the composition of this feature is present.");
+          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance in meters to which the composition of this feature is present.");
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the labels of the composition which are present there.");
+          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
+                            "TA list of compositional fractions corresponding to the compositions list.");
+          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value. Replacing implies that all compositions not "
+                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance fault center");
+          max_depth = prm.get<double>("max distance fault center");
+          compositions = prm.get_vector<unsigned int>("compositions");
+          fractions = prm.get_vector<double>("fractions");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          WBAssertThrow(compositions.size() == fractions.size(),
+                        "There are not the same amount of compositions and fractions.");
+        }
+
+
+        double
+        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const double  /*depth*/,
+                                 const unsigned int composition_number,
+                                 double composition,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/,
+                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
+                                 const AdditionalParameters & /*additional_parameters*/) const
+        {
+          if (std::fabs(distance_from_plane.distance_from_plane) <= max_depth && std::fabs(distance_from_plane.distance_from_plane) >= min_depth)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      return apply_operation(operation,composition,fractions[i]);
+                    }
+                }
+
+              if (operation == Operations::REPLACE)
+                return 0.0;
+            }
+          return composition;
+        }
+        WB_REGISTER_FEATURE_FAULT_COMPOSITION_MODEL(Uniform, uniform)
+      } // namespace Composition
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/grains/interface.cc.bak
new file mode 100644
index 00000000000..12de398c263
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/grains/interface.cc.bak
@@ -0,0 +1,111 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/grains/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/object.h"
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Grains
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          unsigned int counter = 0;
+          for (auto &it : get_declare_map())
+            {
+              // prevent infinite recursion
+              if (it.first != parent_name)
+                {
+                  prm.enter_subsection("oneOf");
+                  {
+                    prm.enter_subsection(std::to_string(counter));
+                    {
+                      prm.enter_subsection("properties");
+                      {
+                        prm.declare_entry("", Types::Object(required_entries), "grains object");
+
+                        prm.declare_entry("model", Types::String("",it.first),
+                                          "The name of the grains model.");
+
+                        it.second(prm, parent_name);
+                      }
+                      prm.leave_subsection();
+                    }
+                    prm.leave_subsection();
+                  }
+                  prm.leave_subsection();
+
+                  counter++;
+
+                }
+            }
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Grains
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution.cc.bak
new file mode 100644
index 00000000000..06ccaebcad0
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution.cc.bak
@@ -0,0 +1,217 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/grains/random_uniform_distribution.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution";
+        }
+
+        RandomUniformDistribution::~RandomUniformDistribution()
+          = default;
+
+        void
+        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance fault center", Types::Double(0),
+                            "The distance from the fault center in meters from which the composition of this feature is present.");
+          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance from the fault in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistribution::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance fault center");
+          max_depth = prm.get<double>("max distance fault center");
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                              const double /*depth*/,
+                                              const unsigned int composition_number,
+                                              WorldBuilder::grains grains_,
+                                              const double /*feature_min_depth*/,
+                                              const double /*feature_max_depth*/,
+                                              const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                              const AdditionalParameters & /*additional_parameters*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (std::fabs(distance_from_planes.distance_from_plane) <= max_depth && std::fabs(distance_from_planes.distance_from_plane) >= min_depth)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      std::uniform_real_distribution<> dist(0.0,1.0);
+                      for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                        {
+                          // set a uniform random a_cosine_matrix per grain
+                          // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                          // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                          // and is licenend accourding to this website with the following licence:
+                          //
+                          // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                          // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                          // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                          // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                          // don't be a jerk, and remember that anything free comes with no guarantee.""
+                          //
+                          // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                          // the public domain, and is yours to study, modify, and use."
+
+                          // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                          const double one = dist(world->get_random_number_engine());
+                          const double two = dist(world->get_random_number_engine());
+                          const double three = dist(world->get_random_number_engine());
+
+                          const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
+                          const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                          const double z = 2.0* three; //For magnitude of pole deflection.
+
+                          // Compute a vector V used for distributing points over the sphere
+                          // via the reflection I - V Transpose(V).  This formulation of V
+                          // will guarantee that if x[1] and x[2] are uniformly distributed,
+                          // the reflected points will be uniform on the sphere.  Note that V
+                          // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                          const double r  = std::sqrt( z );
+                          const double Vx = std::sin( phi ) * r;
+                          const double Vy = std::cos( phi ) * r;
+                          const double Vz = std::sqrt( 2.F - z );
+
+                          // Compute the row vector S = Transpose(V) * R, where R is a simple
+                          // rotation by theta about the z-axis.  No need to compute Sz since
+                          // it's just Vz.
+
+                          const double st = std::sin( theta );
+                          const double ct = std::cos( theta );
+                          const double Sx = Vx * ct - Vy * st;
+                          const double Sy = Vx * st + Vy * ct;
+
+                          // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                          // is equivalent to V S - R.
+
+                          it_rotation_matrices[0][0] = Vx * Sx - ct;
+                          it_rotation_matrices[0][1] = Vx * Sy - st;
+                          it_rotation_matrices[0][2] = Vx * Vz;
+
+                          it_rotation_matrices[1][0] = Vy * Sx + st;
+                          it_rotation_matrices[1][1] = Vy * Sy - ct;
+                          it_rotation_matrices[1][2] = Vy * Vz;
+
+                          it_rotation_matrices[2][0] = Vz * Sx;
+                          it_rotation_matrices[2][1] = Vz * Sy;
+                          it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                        }
+
+                      double total_size = 0;
+                      for (auto &&it_sizes : grains_local.sizes)
+                        {
+                          it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                          total_size += it_sizes;
+                        }
+
+                      if (normalize_grain_sizes[i])
+                        {
+                          const double one_over_total_size = 1/total_size;
+                          std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                         [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                        }
+
+                      return grains_local;
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_FAULT_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
+      } // namespace Grains
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.cc.bak
new file mode 100644
index 00000000000..1f970ee202e
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.cc.bak
@@ -0,0 +1,223 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution deflected";
+        }
+
+        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
+          = default;
+
+        void
+        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance fault center", Types::Double(0),
+                            "The distance from the fault center in meters from which the composition of this feature is present.");
+          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance from the fault in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+          prm.declare_entry("deflections",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistributionDeflected::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance fault center");
+          max_depth = prm.get<double>("max distance fault center");
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+          deflections = prm.get_vector<double>("deflections");
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == deflections.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and deflections (" << deflections.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                                       const double /*depth*/,
+                                                       const unsigned int composition_number,
+                                                       WorldBuilder::grains grains_,
+                                                       const double /*feature_min_depth*/,
+                                                       const double /*feature_max_depth*/,
+                                                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                                       const AdditionalParameters & /*additional_parameters*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (std::fabs(distance_from_planes.distance_from_plane) <= max_depth && std::fabs(distance_from_planes.distance_from_plane) >= min_depth)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      std::uniform_real_distribution<> dist(0.0,1.0);
+                      for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                        {
+                          // set a uniform random a_cosine_matrix per grain
+                          // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                          // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                          // and is licenend accourding to this website with the following licence:
+                          //
+                          // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                          // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                          // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                          // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                          // don't be a jerk, and remember that anything free comes with no guarantee.""
+                          //
+                          // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                          // the public domain, and is yours to study, modify, and use."
+
+                          // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                          const double one = dist(world->get_random_number_engine());
+                          const double two = dist(world->get_random_number_engine());
+                          const double three = dist(world->get_random_number_engine());
+
+                          const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z).
+                          const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                          const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
+
+                          // Compute a vector V used for distributing points over the sphere
+                          // via the reflection I - V Transpose(V).  This formulation of V
+                          // will guarantee that if x[1] and x[2] are uniformly distributed,
+                          // the reflected points will be uniform on the sphere.  Note that V
+                          // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                          const double r  = std::sqrt( z );
+                          const double Vx = std::sin( phi ) * r;
+                          const double Vy = std::cos( phi ) * r;
+                          const double Vz = std::sqrt( 2.F - z );
+
+                          // Compute the row vector S = Transpose(V) * R, where R is a simple
+                          // rotation by theta about the z-axis.  No need to compute Sz since
+                          // it's just Vz.
+
+                          const double st = std::sin( theta );
+                          const double ct = std::cos( theta );
+                          const double Sx = Vx * ct - Vy * st;
+                          const double Sy = Vx * st + Vy * ct;
+
+                          // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                          // is equivalent to V S - R.
+
+                          it_rotation_matrices[0][0] = Vx * Sx - ct;
+                          it_rotation_matrices[0][1] = Vx * Sy - st;
+                          it_rotation_matrices[0][2] = Vx * Vz;
+
+                          it_rotation_matrices[1][0] = Vy * Sx + st;
+                          it_rotation_matrices[1][1] = Vy * Sy - ct;
+                          it_rotation_matrices[1][2] = Vy * Vz;
+
+                          it_rotation_matrices[2][0] = Vz * Sx;
+                          it_rotation_matrices[2][1] = Vz * Sy;
+                          it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                        }
+
+                      double total_size = 0;
+                      for (auto &&it_sizes : grains_local.sizes)
+                        {
+                          it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                          total_size += it_sizes;
+                        }
+
+                      if (normalize_grain_sizes[i])
+                        {
+                          const double one_over_total_size = 1/total_size;
+                          std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                         [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                        }
+
+                      return grains_local;
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_FAULT_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
+      } // namespace Grains
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/grains/uniform.cc.bak
new file mode 100644
index 00000000000..d1449f81bb9
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/grains/uniform.cc.bak
@@ -0,0 +1,169 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/grains/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Grains
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform grains model. All grains start exactly the same.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance fault center", Types::Double(0),
+                            "The distance from the fault center in meters from which the composition of this feature is present.");
+          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance from the fault in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
+                            "A list with the labels of the grains which are present there for each compositions.");
+
+          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
+                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(-1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
+
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance fault center");
+          max_depth = prm.get<double>("max distance fault center");
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
+          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
+
+          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
+                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
+
+
+          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
+                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
+
+          if (set_euler_angles)
+            {
+              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
+              rotation_matrices.resize(euler_angles_vector.size());
+              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
+                {
+                  rotation_matrices[i] = WorldBuilder::Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
+                }
+
+            }
+          else
+            {
+              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
+            }
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+
+
+          WBAssertThrow(compositions.size() == rotation_matrices.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                            const double /*depth*/,
+                            const unsigned int composition_number,
+                            WorldBuilder::grains grains_,
+                            const double /*feature_min_depth*/,
+                            const double /*feature_max_depth*/,
+                            const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                            const AdditionalParameters & /*additional_parameters*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (std::fabs(distance_from_planes.distance_from_plane) <= max_depth && std::fabs(distance_from_planes.distance_from_plane) >= min_depth)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
+
+                      const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
+                      std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
+
+                      return grains_local;
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_FAULT_GRAINS_MODEL(Uniform, uniform)
+      } // namespace Grains
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/temperature/adiabatic.cc.bak
new file mode 100644
index 00000000000..64b98312018
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/temperature/adiabatic.cc.bak
@@ -0,0 +1,164 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/temperature/adiabatic.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Temperature
+      {
+        Adiabatic::Adiabatic(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          potential_mantle_temperature(NaN::DSNAN),
+          thermal_expansion_coefficient(NaN::DSNAN),
+          specific_heat(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "adiabatic";
+        }
+
+        Adiabatic::~Adiabatic()
+          = default;
+
+        void
+        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          prm.declare_entry("", Types::Object(),
+                            "Adiabatic temperature model. Uses global values by default.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance fault center", Types::Double(0),
+                            "todo The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
+                            "todo The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("potential mantle temperature", Types::Double(-1),
+                            "The potential temperature of the mantle at the surface in Kelvin. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
+                            "The thermal expansion coefficient in $K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("specific heat", Types::Double(-1),
+                            "The specific heat in $J kg^{-1} K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+        }
+
+        void
+        Adiabatic::parse_entries(Parameters &prm)
+        {
+
+          min_depth = prm.get<double>("min distance fault center");
+          max_depth = prm.get<double>("max distance fault center");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
+          if (potential_mantle_temperature < 0)
+            potential_mantle_temperature =  this->world->potential_mantle_temperature;
+
+
+          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
+          if (thermal_expansion_coefficient < 0)
+            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
+
+          specific_heat = prm.get<double>("specific heat");
+          if (specific_heat < 0)
+            specific_heat =  this->world->specific_heat;
+
+          // Some assertions in debug mode can't hurt and have helped before.
+          WBAssert(!std::isnan(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
+          WBAssert(std::isfinite(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
+
+          WBAssert(!std::isnan(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
+
+          WBAssert(!std::isnan(specific_heat),
+                   "specific_heat is not a number: " << specific_heat << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "specific_heat is not a finite: " << specific_heat << '.');
+
+        }
+
+
+        double
+        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                   const double depth,
+                                   const double gravity_norm,
+                                   double temperature_,
+                                   const double  /*feature_min_depth*/,
+                                   const double  /*feature_max_depth*/,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes & /*distance_from_planes*/,
+                                   const AdditionalParameters & /*additional_parameters*/) const
+        {
+
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double adabatic_temperature = potential_mantle_temperature *
+                                                  std::exp(((thermal_expansion_coefficient * gravity_norm) /
+                                                            specific_heat) * depth);
+
+
+              WBAssert(!std::isnan(adabatic_temperature),
+                       "adabatic_temperature is not a number: " << adabatic_temperature << ". "
+                       <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
+                       <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
+                       << ", gravity_norm = " << gravity_norm
+                       << ", specific_heat = " << specific_heat
+                       << ", depth = " << depth);
+
+              WBAssert(std::isfinite(adabatic_temperature),
+                       "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
+
+              return apply_operation(operation,temperature_,adabatic_temperature);
+            }
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_FAULT_TEMPERATURE_MODEL(Adiabatic, adiabatic)
+      } // namespace Temperature
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/temperature/interface.cc.bak
new file mode 100644
index 00000000000..fe7d7b00284
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/temperature/interface.cc.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+
+#include "world_builder/features/fault_models/temperature/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Temperature
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          // The type needs to be stored in a separate value, otherwise there are memory issues
+          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
+
+          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
+          {
+            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
+            {
+              "operation", type,
+              "Whether the value should replace any value previously defined at this location (replace), "
+              "add the value to the previously define value (add) or subtract the value to the previously "
+              "define value (subtract)."
+            }
+          });
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Temperature
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/temperature/linear.cc.bak
new file mode 100644
index 00000000000..16a1f2b03d7
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/temperature/linear.cc.bak
@@ -0,0 +1,140 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/temperature/linear.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Temperature
+      {
+        Linear::Linear(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          center_temperature(NaN::DSNAN),
+          side_temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "linear";
+        }
+
+        Linear::~Linear()
+          = default;
+
+        void
+        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `max distance fault` center to the required parameters.
+          prm.declare_entry("", Types::Object({"max distance fault center"}),
+                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance fault center", Types::Double(0),
+                            "The minimum distance to the center of the fault. This determines where the linear temperature starts.");
+
+          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
+                            "The minimum distance to the center of the fault. This determines where the linear temperature end.");
+
+          prm.declare_entry("center temperature", Types::Double(293.15),
+                            "The temperature at the center of this feature in degree Kelvin."
+                            "If the value is below zero, the an adiabatic temperature is used.");
+
+          prm.declare_entry("side temperature", Types::Double(-1),
+                            "The temperature at the sides of this feature in degree Kelvin. "
+                            "If the value is below zero, an adiabatic temperature is used.");
+
+        }
+
+        void
+        Linear::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance fault center");
+          max_depth = prm.get<double>("max distance fault center");
+          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          center_temperature = prm.get<double>("center temperature");
+          side_temperature = prm.get<double>("side temperature");
+        }
+
+
+        double
+        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                const double /*depth*/,
+                                const double gravity_norm,
+                                double temperature_,
+                                const double /*feature_min_depth*/,
+                                const double /*feature_max_depth*/,
+                                const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                const AdditionalParameters & /*additional_parameters*/) const
+        {
+
+          if (std::fabs(distance_from_planes.distance_from_plane) <= max_depth && std::fabs(distance_from_planes.distance_from_plane) >= min_depth)
+            {
+              const double min_depth_local = min_depth;
+              const double max_depth_local = max_depth;
+
+              double center_temperature_local = center_temperature;
+              if (center_temperature_local < 0)
+                {
+                  center_temperature_local =  this->world->potential_mantle_temperature *
+                                              std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                        this->world->specific_heat) * min_depth_local);
+                }
+
+              double side_temperature_local = side_temperature;
+              if (side_temperature_local < 0)
+                {
+                  side_temperature_local =  this->world->potential_mantle_temperature *
+                                            std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                      this->world->specific_heat) * max_depth_local);
+                }
+
+              const double new_temperature =   center_temperature_local +
+                                               (std::fabs(distance_from_planes.distance_from_plane) - min_depth_local) *
+                                               ((side_temperature_local - center_temperature_local) / (max_depth_local - min_depth_local));
+
+              return apply_operation(operation,temperature_,new_temperature);
+
+            }
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_FAULT_TEMPERATURE_MODEL(Linear, linear)
+      } // namespace Temperature
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/temperature/uniform.cc.bak
new file mode 100644
index 00000000000..fdddb360d1a
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/fault_models/temperature/uniform.cc.bak
@@ -0,0 +1,107 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/fault_models/temperature/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Temperature
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `temperature` and to the required parameters.
+          prm.declare_entry("", Types::Object({"temperature"}),
+                            "Uniform temperature model. Set the temperature to a constant value.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance fault center", Types::Double(0),
+                            "The distance in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("temperature", Types::Double(293.15),
+                            "The temperature in degree Kelvin which this feature should have");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance fault center");
+          max_depth = prm.get<double>("max distance fault center");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          temperature = prm.get<double>("temperature");
+        }
+
+
+        double
+        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const double  /*depth*/,
+                                 const double  /*gravity*/,
+                                 double temperature_,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/,
+                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
+                                 const AdditionalParameters & /*additional_parameters*/) const
+        {
+
+          if (std::fabs(distance_from_plane.distance_from_plane) <= max_depth && std::fabs(distance_from_plane.distance_from_plane) >= min_depth)
+            {
+              return apply_operation(operation,temperature_,temperature);
+            }
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_FAULT_TEMPERATURE_MODEL(Uniform, uniform)
+      } // namespace Temperature
+    } // namespace FaultModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/feature_utilities.cc.bak b/contrib/world_builder/source/world_builder/features/feature_utilities.cc.bak
new file mode 100644
index 00000000000..4bbd05f3fa8
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/feature_utilities.cc.bak
@@ -0,0 +1,56 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/feature_utilities.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace FeatureUtilities
+    {
+      Operations
+      string_operations_to_enum(const std::string &operation)
+      {
+        if (operation == "add") return Operations::ADD;
+        if (operation == "subtract") return Operations::SUBTRACT;
+        if (operation == "replace defined only") return Operations::REPLACE_DEFINED_ONLY;
+
+        WBAssert(operation == "replace", "Could not find operation: " << operation << '.');
+        return Operations::REPLACE;
+      }
+
+      size_t
+      add_vector_unique(std::vector<std::string> &vector,const std::string &add_string)
+      {
+        for (size_t i = 0; i < vector.size(); ++i)
+          {
+            if (vector[i] == add_string)
+              {
+                return i;
+              }
+          }
+
+        vector.push_back(add_string);
+        return vector.size()-1;
+      }
+    } // namespace FeatureUtilities
+  } // namespace Features
+} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/features/interface.cc.bak b/contrib/world_builder/source/world_builder/features/interface.cc.bak
new file mode 100644
index 00000000000..0678ad0635e
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/interface.cc.bak
@@ -0,0 +1,209 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/array.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/point.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace Internal
+    {
+
+
+
+      /**
+       * A function to turn strings into interpolation type enums.
+       */
+      static InterpolationType string_to_interpolation_type (const std::string &string)
+      {
+        if (string == "continuous monotone spline")
+          {
+            return InterpolationType::ContinuousMonotoneSpline;
+          }
+
+        WBAssertThrow(false,
+                      "You provided an interpolation type which is not supported: " << string
+                      << "This may be due to all options besides continuous monotone spline have been "
+                      << "removed since version 0.5. It is best to remove the interpolation variable "
+                      << "from you input file as it may be removed in future versions.");
+
+        return InterpolationType::Invalid;
+      }
+    } // namespace Internal
+
+    Interface::Interface()
+      = default;
+
+    Interface::~Interface ()
+      = default;
+
+    void
+    Interface::declare_entries(Parameters &prm, const std::string &parent_name, const std::vector<std::string> &required_entries)
+    {
+
+      {
+        using namespace rapidjson;
+        Document &declarations = prm.declarations;
+
+        prm.enter_subsection("defaultSnippets");
+        const std::string path = prm.get_full_json_path();
+
+        unsigned int idx = 0;
+        for (auto  &it : get_snippet_map())
+          {
+            std::string item =  path + "/"+std::to_string(idx);
+
+            Pointer((item).c_str()).Set(declarations, "object");
+            Pointer((item+"/label").c_str()).Set(declarations,("add a '" + it.first + "'").c_str());
+            prm.enter_subsection(std::to_string(idx).c_str());
+            it.second(prm);
+            prm.leave_subsection();
+
+            ++idx;
+          }
+
+        prm.leave_subsection();
+      }
+
+      unsigned int counter = 0;
+      for (auto  &it : get_declare_map())
+        {
+          prm.enter_subsection("oneOf");
+          {
+            prm.enter_subsection(std::to_string(counter));
+            {
+
+              prm.enter_subsection("properties");
+              {
+                prm.declare_entry("", Types::Object(required_entries), "feature object");
+
+                prm.declare_entry("model", Types::String("",it.first),
+                                  "The model name of the feature determining its type.");
+                prm.declare_entry("name", Types::String(""),
+                                  "The name which the user has given to the feature. "
+                                  "This is mostly used for documentation purposes, and should in most cases be unique, "
+                                  "although this is not enforced.");
+                prm.declare_entry("tag", Types::String(""),
+                                  "A tag which can be given to a feature. This is meant to categorize different features. "
+                                  "If the tag is not provided or empty, it is set to the model name.");
+                prm.declare_entry("coordinates", Types::Array(Types::Point<2>(), 1),
+                                  "An array of 2d Points representing an array of coordinates where the feature is located.");
+
+                prm.declare_entry("interpolation",Types::String("global"),
+                                  "What type of interpolation should be used to enforce the minimum points per "
+                                  "distance parameter. Options are 'global' and "
+                                  "'continuous monotone spline' interpolation. If this "
+                                  "value is set to global, the global value for interpolation is used. "
+                                  "This option is deprecated and will be removed in a future release.");
+                WBAssert(it.second != NULL, "No declare entries given.");
+                it.second(prm, parent_name, {});
+              }
+              prm.leave_subsection();
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          counter++;
+
+        }
+    }
+
+
+    void
+    Interface::get_coordinates(const std::string & /*unused*/,
+                               Parameters &prm,
+                               const CoordinateSystem coordinate_system)
+    {
+      coordinates = prm.get_vector<Point<2> >("coordinates");
+      if (coordinate_system == CoordinateSystem::spherical)
+        std::transform(coordinates.begin(),coordinates.end(), coordinates.begin(),
+                       [](const WorldBuilder::Point<2> &p) -> WorldBuilder::Point<2> { return p *Consts::PI / 180.0;});
+
+
+      // If global is given, we use the global interpolation setting, otherwise use the provided value.
+      const std::string interpolation_type_string = prm.get<std::string>("interpolation") == "global" ? this->world->interpolation : prm.get<std::string>("interpolation");
+      interpolation_type = WorldBuilder::Features::Internal::string_to_interpolation_type(interpolation_type_string);
+
+      original_number_of_coordinates = coordinates.size();
+
+      WBAssert(interpolation_type == WorldBuilder::Utilities::InterpolationType::Linear ||
+               interpolation_type == WorldBuilder::Utilities::InterpolationType::MonotoneSpline ||
+               interpolation_type == WorldBuilder::Utilities::InterpolationType::ContinuousMonotoneSpline,
+               "For interpolation, linear and monotone spline are the only allowed values. "
+               << "You provided " << interpolation_type_string << '.');
+
+      bezier_curve = Objects::BezierCurve(coordinates);
+
+    }
+
+
+    void
+    Interface::registerType(const std::string &name,
+                            void ( *declare_entries)(Parameters &, const std::string &,const std::vector<std::string> &),
+                            void ( *make_snippet)(Parameters &),
+                            ObjectFactory *factory)
+    {
+      get_factory_map()[name] = factory;
+      get_declare_map()[name] = declare_entries;
+      get_snippet_map()[name] = make_snippet;
+    }
+
+    std::unique_ptr<Interface>
+    Interface::create(const std::string &name, WorldBuilder::World *world)
+    {
+      std::string lower_case_name;
+      std::transform(name.begin(),
+                     name.end(),
+                     std::back_inserter(lower_case_name),
+                     ::tolower);;
+
+      // Have a nice assert message to check whether a plugin exists in the case
+      // of a debug compilation.
+      WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                    "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                    "The size of factories is " << get_factory_map().size() << '.');
+
+      // Using at() because the [] will just insert values
+      // which is undesirable in this case. An exception is
+      // thrown when the name is not present.
+      return get_factory_map().at(lower_case_name)->create(world);
+    }
+
+    Objects::PlaneDistances
+    Interface::distance_to_feature_plane(const Point<3> & /*unused*/,
+                                         const Objects::NaturalCoordinate & /*unused*/,
+                                         const double /*unused*/) const
+    {
+      WBAssertThrow(false, "The distance_to_feature_plane is not yet implemented for the desinated object");
+    }
+
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer.cc.bak
new file mode 100644
index 00000000000..7e66108db0d
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer.cc.bak
@@ -0,0 +1,264 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer.h"
+
+
+#include "world_builder/features/mantle_layer_models/composition/interface.h"
+#include "world_builder/features/mantle_layer_models/grains/interface.h"
+#include "world_builder/features/mantle_layer_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/plugin_system.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    MantleLayer::MantleLayer(WorldBuilder::World *world_)
+    {
+      this->world = world_;
+      this->name = "mantle layer";
+    }
+
+    MantleLayer::~MantleLayer()
+      = default;
+
+
+
+    void MantleLayer::make_snippet(Parameters &prm)
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+
+      const std::string path = prm.get_full_json_path();
+
+      Pointer((path + "/body").c_str()).Set(declarations,"object");
+      Pointer((path + "/body/model").c_str()).Set(declarations,"mantle layer");
+      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Mantle Layer}");
+      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/temperature models").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/composition models").c_str()).Create(declarations).SetArray();
+    }
+
+
+
+    void
+    MantleLayer::declare_entries(Parameters &prm,
+                                 const std::string &/*parent_name*/,
+                                 const std::vector<std::string> &required_entries)
+    {
+      prm.declare_entry("", Types::Object(required_entries), "Mantle layer object. Requires properties `model` and `coordinates`.");
+
+      prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                        "The depth from which this feature is present");
+      prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                        "The depth to which this feature is present");
+      prm.declare_entry("temperature models",
+                        Types::PluginSystem("", Features::MantleLayerModels::Temperature::Interface::declare_entries, {"model"}),
+                        "A list of temperature models.");
+      prm.declare_entry("composition models",
+                        Types::PluginSystem("", Features::MantleLayerModels::Composition::Interface::declare_entries, {"model"}),
+                        "A list of composition models.");
+      prm.declare_entry("grains models",
+                        Types::PluginSystem("", Features::MantleLayerModels::Grains::Interface::declare_entries, {"model"}),
+                        "A list of grains models.");
+    }
+
+    void
+    MantleLayer::parse_entries(Parameters &prm)
+    {
+      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
+
+      this->name = prm.get<std::string>("name");
+
+      std::string tag = prm.get<std::string>("tag");
+      if (tag == "")
+        {
+          tag = "mantle layer";
+        }
+      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
+
+      this->get_coordinates("coordinates", prm, coordinate_system);
+
+      min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+      min_depth = min_depth_surface.minimum;
+
+      max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+      max_depth = max_depth_surface.maximum;
+
+
+      prm.get_unique_pointers<Features::MantleLayerModels::Temperature::Interface>("temperature models", temperature_models);
+
+      prm.enter_subsection("temperature models");
+      {
+        for (unsigned int i = 0; i < temperature_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              temperature_models[i]->parse_entries(prm,coordinates);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+
+      prm.get_unique_pointers<Features::MantleLayerModels::Composition::Interface>("composition models", composition_models);
+
+      prm.enter_subsection("composition models");
+      {
+        for (unsigned int i = 0; i < composition_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              composition_models[i]->parse_entries(prm,coordinates);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+
+      prm.get_unique_pointers<Features::MantleLayerModels::Grains::Interface>("grains models", grains_models);
+
+      prm.enter_subsection("grains models");
+      {
+        for (unsigned int i = 0; i < grains_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              grains_models[i]->parse_entries(prm,coordinates);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+    }
+
+
+    void
+    MantleLayer::properties(const Point<3> &position_in_cartesian_coordinates,
+                            const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                            const double depth,
+                            const std::vector<std::array<unsigned int,3>> &properties,
+                            const double gravity_norm,
+                            const std::vector<size_t> &entry_in_output,
+                            std::vector<double> &output) const
+    {
+      if (depth <= max_depth && depth >= min_depth &&
+          WorldBuilder::Utilities::polygon_contains_point(coordinates, Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
+                                                                                world->parameters.coordinate_system->natural_coordinate_system())))
+        {
+          const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+          const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+          if (depth <= max_depth_local &&  depth >= min_depth_local)
+            {
+              for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
+                {
+                  switch (properties[i_property][0])
+                    {
+                      case 1:  // temperature
+                      {
+                        for (const auto &temperature_model: temperature_models)
+                          {
+                            output[entry_in_output[i_property]] = temperature_model->get_temperature(position_in_cartesian_coordinates,
+                                                                                                     position_in_natural_coordinates,
+                                                                                                     depth,
+                                                                                                     gravity_norm,
+                                                                                                     output[entry_in_output[i_property]],
+                                                                                                     min_depth_local,
+                                                                                                     max_depth_local);
+
+                            WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Temperature is not a number: " << output[entry_in_output[i_property]]
+                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+                            WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Temperature is not a finite: " << output[entry_in_output[i_property]]
+                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+
+                          }
+                        break;
+                        case 2: // composition
+
+                          for (const auto &composition_model: composition_models)
+                            {
+                              output[entry_in_output[i_property]] = composition_model->get_composition(position_in_cartesian_coordinates,
+                                                                                                       position_in_natural_coordinates,
+                                                                                                       depth,
+                                                                                                       properties[i_property][1],
+                                                                                                       output[entry_in_output[i_property]],
+                                                                                                       min_depth_local,
+                                                                                                       max_depth_local);
+
+                              WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Composition is not a number: " << output[entry_in_output[i_property]]
+                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+                              WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Composition is not a finite: " << output[entry_in_output[i_property]]
+                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+
+                            }
+
+                          break;
+                        }
+                      case 3: // grains
+                      {
+                        WorldBuilder::grains  grains(output,properties[i_property][2],entry_in_output[i_property]);
+                        for (const auto &grains_model: grains_models)
+                          {
+                            grains = grains_model->get_grains(position_in_cartesian_coordinates,
+                                                              position_in_natural_coordinates,
+                                                              depth,
+                                                              properties[i_property][1],
+                                                              grains,
+                                                              min_depth_local,
+                                                              max_depth_local);
+
+                          }
+                        grains.unroll_into(output,entry_in_output[i_property]);
+                        break;
+                      }
+                      case 4:
+                      {
+                        output[entry_in_output[i_property]] = static_cast<double>(tag_index);
+                        break;
+                      }
+                      break;
+                      default:
+                      {
+                        WBAssertThrow(false,
+                                      "Internal error: Unimplemented property provided. " <<
+                                      "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
+                                      "Provided property number was: " << properties[i_property][0]);
+                      }
+                    }
+                }
+            }
+        }
+    }
+
+    WB_REGISTER_FEATURE(MantleLayer, mantle layer)
+
+  } // namespace Features
+} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/interface.cc.bak
new file mode 100644
index 00000000000..0f626ab049e
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/interface.cc.bak
@@ -0,0 +1,81 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/composition/interface.h"
+
+#include <algorithm>
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Composition
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Composition
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/uniform.cc.bak
new file mode 100644
index 00000000000..a61230f5e12
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/uniform.cc.bak
@@ -0,0 +1,131 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/composition/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Composition
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform compositional model. Sets constant compositional field.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the labels of the composition which are present there.");
+          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
+                            "TA list of compositional fractions corresponding to the compositions list.");
+          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value. Replacing implies that all compositions not "
+                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+          fractions = prm.get_vector<double>("fractions");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          WBAssertThrow(compositions.size() == fractions.size(),
+                        "There are not the same amount of compositions and fractions.");
+        }
+
+
+        double
+        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                 const double depth,
+                                 const unsigned int composition_number,
+                                 double composition,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          return apply_operation(operation,composition,fractions[i]);
+                        }
+                    }
+
+                  if (operation == Operations::REPLACE)
+                    return 0.0;
+                }
+            }
+          return composition;
+        }
+        WB_REGISTER_FEATURE_MANTLE_LAYER_COMPOSITION_MODEL(Uniform, uniform)
+      } // namespace Composition
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/interface.cc.bak
new file mode 100644
index 00000000000..259b393aa45
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/interface.cc.bak
@@ -0,0 +1,111 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/grains/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/object.h"
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Grains
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          unsigned int counter = 0;
+          for (auto &it : get_declare_map())
+            {
+              // prevent infinite recursion
+              if (it.first != parent_name)
+                {
+                  prm.enter_subsection("oneOf");
+                  {
+                    prm.enter_subsection(std::to_string(counter));
+                    {
+                      prm.enter_subsection("properties");
+                      {
+                        prm.declare_entry("", Types::Object(required_entries), "grains object");
+
+                        prm.declare_entry("model", Types::String("",it.first),
+                                          "The name of the grains model.");
+
+                        it.second(prm, parent_name);
+                      }
+                      prm.leave_subsection();
+                    }
+                    prm.leave_subsection();
+                  }
+                  prm.leave_subsection();
+
+                  counter++;
+
+                }
+            }
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Grains
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.cc.bak
new file mode 100644
index 00000000000..9d75e3de185
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.cc.bak
@@ -0,0 +1,224 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution";
+        }
+
+        RandomUniformDistribution::~RandomUniformDistribution()
+          = default;
+
+        void
+        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistribution::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                              const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                              const double depth,
+                                              const unsigned int composition_number,
+                                              WorldBuilder::grains grains_,
+                                              const double  /*feature_min_depth*/,
+                                              const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          std::uniform_real_distribution<> dist(0.0,1.0);
+                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                            {
+                              // set a uniform random a_cosine_matrix per grain
+                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                              // and is licenend accourding to this website with the following licence:
+                              //
+                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                              // don't be a jerk, and remember that anything free comes with no guarantee.""
+                              //
+                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                              // the public domain, and is yours to study, modify, and use."
+
+                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                              const double one = dist(world->get_random_number_engine());
+                              const double two = dist(world->get_random_number_engine());
+                              const double three = dist(world->get_random_number_engine());
+
+                              const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
+                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                              const double z = 2.0* three; //For magnitude of pole deflection.
+
+                              // Compute a vector V used for distributing points over the sphere
+                              // via the reflection I - V Transpose(V).  This formulation of V
+                              // will guarantee that if x[1] and x[2] are uniformly distributed,
+                              // the reflected points will be uniform on the sphere.  Note that V
+                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                              const double r  = std::sqrt( z );
+                              const double Vx = std::sin( phi ) * r;
+                              const double Vy = std::cos( phi ) * r;
+                              const double Vz = std::sqrt( 2.F - z );
+
+                              // Compute the row vector S = Transpose(V) * R, where R is a simple
+                              // rotation by theta about the z-axis.  No need to compute Sz since
+                              // it's just Vz.
+
+                              const double st = std::sin( theta );
+                              const double ct = std::cos( theta );
+                              const double Sx = Vx * ct - Vy * st;
+                              const double Sy = Vx * st + Vy * ct;
+
+                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                              // is equivalent to V S - R.
+
+                              it_rotation_matrices[0][0] = Vx * Sx - ct;
+                              it_rotation_matrices[0][1] = Vx * Sy - st;
+                              it_rotation_matrices[0][2] = Vx * Vz;
+
+                              it_rotation_matrices[1][0] = Vy * Sx + st;
+                              it_rotation_matrices[1][1] = Vy * Sy - ct;
+                              it_rotation_matrices[1][2] = Vy * Vz;
+
+                              it_rotation_matrices[2][0] = Vz * Sx;
+                              it_rotation_matrices[2][1] = Vz * Sy;
+                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                            }
+
+                          double total_size = 0;
+                          for (auto &&it_sizes : grains_local.sizes)
+                            {
+                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                              total_size += it_sizes;
+                            }
+
+                          if (normalize_grain_sizes[i])
+                            {
+                              const double one_over_total_size = 1/total_size;
+                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                            }
+
+                          return grains_local;
+                        }
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_MANTLE_LAYER_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
+      } // namespace Grains
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.cc.bak
new file mode 100644
index 00000000000..d3cf85005b2
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.cc.bak
@@ -0,0 +1,231 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution deflected";
+        }
+
+        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
+          = default;
+
+        void
+        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+          prm.declare_entry("deflections",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistributionDeflected::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+          deflections = prm.get_vector<double>("deflections");
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == deflections.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and deflections (" << deflections.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                                       const double depth,
+                                                       const unsigned int composition_number,
+                                                       WorldBuilder::grains grains_,
+                                                       const double  /*feature_min_depth*/,
+                                                       const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          std::uniform_real_distribution<> dist(0.0,1.0);
+                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                            {
+                              // set a uniform random a_cosine_matrix per grain
+                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                              // and is licenend accourding to this website with the following licence:
+                              //
+                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                              // don't be a jerk, and remember that anything free comes with no guarantee.""
+                              //
+                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                              // the public domain, and is yours to study, modify, and use."
+
+                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                              const double one = dist(world->get_random_number_engine());
+                              const double two = dist(world->get_random_number_engine());
+                              const double three = dist(world->get_random_number_engine());
+
+                              // the distribution is restricted by the deflection (between 0 and 1)
+                              const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z)
+                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                              const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
+
+                              // Compute a vector V used for distributing points over the sphere
+                              // via the reflection I - V Transpose(V).  This formulation of V
+                              // will guarantee that if x[1] and x[2] are uniformly distributed,
+                              // the reflected points will be uniform on the sphere.  Note that V
+                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                              const double r  = std::sqrt( z );
+                              const double Vx = std::sin( phi ) * r;
+                              const double Vy = std::cos( phi ) * r;
+                              const double Vz = std::sqrt( 2.F - z );
+
+                              // Compute the row vector S = Transpose(V) * R, where R is a simple
+                              // rotation by theta about the z-axis.  No need to compute Sz since
+                              // it's just Vz.
+
+                              const double st = std::sin( theta );
+                              const double ct = std::cos( theta );
+                              const double Sx = Vx * ct - Vy * st;
+                              const double Sy = Vx * st + Vy * ct;
+
+                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                              // is equivalent to V S - R.
+
+                              it_rotation_matrices[0][0] = Vx * Sx - ct;
+                              it_rotation_matrices[0][1] = Vx * Sy - st;
+                              it_rotation_matrices[0][2] = Vx * Vz;
+
+                              it_rotation_matrices[1][0] = Vy * Sx + st;
+                              it_rotation_matrices[1][1] = Vy * Sy - ct;
+                              it_rotation_matrices[1][2] = Vy * Vz;
+
+                              it_rotation_matrices[2][0] = Vz * Sx;
+                              it_rotation_matrices[2][1] = Vz * Sy;
+                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                            }
+
+                          double total_size = 0;
+                          for (auto &&it_sizes : grains_local.sizes)
+                            {
+                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                              total_size += it_sizes;
+                            }
+
+                          if (normalize_grain_sizes[i])
+                            {
+                              const double one_over_total_size = 1/total_size;
+                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                            }
+
+                          return grains_local;
+                        }
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_MANTLE_LAYER_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
+      } // namespace Grains
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/uniform.cc.bak
new file mode 100644
index 00000000000..dea13791d9e
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/uniform.cc.bak
@@ -0,0 +1,176 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/grains/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Grains
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform grains model. All grains start exactly the same.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
+                            "A list with the labels of the grains which are present there for each compositions.");
+
+          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
+                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(-1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
+
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
+          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
+
+          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
+                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
+
+
+          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
+                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
+
+          if (set_euler_angles)
+            {
+              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
+              rotation_matrices.resize(euler_angles_vector.size());
+              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
+                {
+                  rotation_matrices[i] = WorldBuilder::Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
+                }
+
+            }
+          else
+            {
+              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
+            }
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+
+
+          WBAssertThrow(compositions.size() == rotation_matrices.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                            const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                            const double depth,
+                            const unsigned int composition_number,
+                            WorldBuilder::grains grains_,
+                            const double  /*feature_min_depth*/,
+                            const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
+
+                          const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
+                          std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
+
+                          return grains_local;
+                        }
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_MANTLE_LAYER_GRAINS_MODEL(Uniform, uniform)
+      } // namespace Grains
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/adiabatic.cc.bak
new file mode 100644
index 00000000000..28c172b2e6c
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/adiabatic.cc.bak
@@ -0,0 +1,172 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/temperature/adiabatic.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace MantleLayerModels
+    {
+      namespace Temperature
+      {
+        Adiabatic::Adiabatic(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          potential_mantle_temperature(NaN::DSNAN),
+          thermal_expansion_coefficient(NaN::DSNAN),
+          specific_heat(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "adiabatic";
+        }
+
+        Adiabatic::~Adiabatic()
+          = default;
+
+        void
+        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          prm.declare_entry("", Types::Object(),
+                            "Adiabatic temperature model. Uses global values by default.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the temperature of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the temperature of this feature is present.");
+
+          prm.declare_entry("potential mantle temperature", Types::Double(-1),
+                            "The potential temperature of the mantle at the surface in Kelvin. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
+                            "The thermal expansion coefficient in $K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("specific heat", Types::Double(-1),
+                            "The specific heat in $J kg^{-1} K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+        }
+
+        void
+        Adiabatic::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
+          if (potential_mantle_temperature < 0)
+            potential_mantle_temperature =  this->world->potential_mantle_temperature;
+
+
+          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
+          if (thermal_expansion_coefficient < 0)
+            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
+
+          specific_heat = prm.get<double>("specific heat");
+          if (specific_heat < 0)
+            specific_heat =  this->world->specific_heat;
+
+          // Some assertions in debug mode can't hurt and have helped before.
+          WBAssert(!std::isnan(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
+          WBAssert(std::isfinite(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
+
+          WBAssert(!std::isnan(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
+
+          WBAssert(!std::isnan(specific_heat),
+                   "specific_heat is not a number: " << specific_heat << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "specific_heat is not a finite: " << specific_heat << '.');
+
+        }
+
+
+        double
+        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity_norm,
+                                   double temperature_,
+                                   const double  /*feature_min_depth*/,
+                                   const double  /*feature_max_depth*/) const
+        {
+
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  const double adabatic_temperature = potential_mantle_temperature *
+                                                      std::exp(((thermal_expansion_coefficient * gravity_norm) /
+                                                                specific_heat) * depth);
+
+
+                  WBAssert(!std::isnan(adabatic_temperature),
+                           "adabatic_temperature is not a number: " << adabatic_temperature << ". "
+                           <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
+                           <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
+                           << ", gravity_norm = " << gravity_norm
+                           << ", specific_heat = " << specific_heat
+                           << ", depth = " << depth);
+
+                  WBAssert(std::isfinite(adabatic_temperature),
+                           "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
+
+                  return apply_operation(operation,temperature_,adabatic_temperature);
+                }
+            }
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_MANTLE_LAYER_TEMPERATURE_MODEL(Adiabatic, adiabatic)
+      } // namespace Temperature
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/interface.cc.bak
new file mode 100644
index 00000000000..bfcd5474434
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/interface.cc.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/temperature/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Temperature
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          // The type needs to be stored in a separate value, otherwise there are memory issues
+          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
+
+          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
+          {
+            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
+            {
+              "operation", type,
+              "Whether the value should replace any value previously defined at this location (replace), "
+              "add the value to the previously define value (add) or subtract the value to the previously "
+              "define value (subtract)."
+            }
+          });
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Temperature
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/linear.cc.bak
new file mode 100644
index 00000000000..b8e64d70ec7
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/linear.cc.bak
@@ -0,0 +1,147 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/temperature/linear.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Temperature
+      {
+        Linear::Linear(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          top_temperature(NaN::DSNAN),
+          bottom_temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "linear";
+        }
+
+        Linear::~Linear()
+          = default;
+
+        void
+        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add max depth to the required parameters.
+          prm.declare_entry("", Types::Object({"max depth"}),
+                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the temperature of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the temperature of this feature is present.");
+
+          prm.declare_entry("top temperature", Types::Double(293.15),
+                            "The temperature at the top in degree Kelvin of this feature."
+                            "If the value is below zero, the an adiabatic temperature is used.");
+
+          prm.declare_entry("bottom temperature", Types::Double(-1),
+                            "The temperature at the top in degree Kelvin of this feature. "
+                            "If the value is below zero, an adiabatic temperature is used.");
+        }
+
+        void
+        Linear::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          top_temperature = prm.get<double>("top temperature");
+          bottom_temperature = prm.get<double>("bottom temperature");
+        }
+
+
+        double
+        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                const double depth,
+                                const double gravity_norm,
+                                double temperature_,
+                                const double feature_min_depth,
+                                const double feature_max_depth) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  const double min_depth_local_local = std::max(feature_min_depth, min_depth_local);
+                  const double max_depth_local_local = std::min(feature_max_depth, max_depth_local);
+
+                  double top_temperature_local = top_temperature;
+                  if (top_temperature_local < 0)
+                    {
+                      top_temperature_local =  this->world->potential_mantle_temperature *
+                                               std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                         this->world->specific_heat) * min_depth_local_local);
+                    }
+
+                  double bottom_temperature_local = bottom_temperature;
+                  if (bottom_temperature_local < 0)
+                    {
+                      bottom_temperature_local =  this->world->potential_mantle_temperature *
+                                                  std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                            this->world->specific_heat) * max_depth_local_local);
+
+                    }
+
+                  const double new_temperature =  top_temperature_local + (max_depth_local_local - min_depth_local_local < 10.0*std::numeric_limits<double>::epsilon() ? 0.0 :
+                                                                           (depth - min_depth_local_local) *
+                                                                           ((bottom_temperature_local - top_temperature_local) / (max_depth_local_local - min_depth_local_local)));
+
+                  return apply_operation(operation,temperature_,new_temperature);
+                }
+            }
+
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_MANTLE_LAYER_TEMPERATURE_MODEL(Linear, linear)
+      } // namespace Temperature
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/uniform.cc.bak
new file mode 100644
index 00000000000..742a922cb99
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/uniform.cc.bak
@@ -0,0 +1,117 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/mantle_layer_models/temperature/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace MantleLayerModels
+    {
+      namespace Temperature
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `temperature` and to the required parameters.
+          prm.declare_entry("", Types::Object({"temperature"}),
+                            "Uniform temperature model. Set the temperature to a constant value.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the temperature of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the temperature of this feature is present.");
+
+          prm.declare_entry("temperature", Types::Double(293.15),
+                            "The temperature in degree Kelvin which this feature should have");
+
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          temperature = prm.get<double>("temperature");
+        }
+
+
+        double
+        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                 const double depth,
+                                 const double  /*gravity*/,
+                                 double temperature_,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/) const
+        {
+
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  return apply_operation(operation,temperature_,temperature);
+                }
+            }
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_MANTLE_LAYER_TEMPERATURE_MODEL(Uniform, uniform)
+      } // namespace Temperature
+    } // namespace MantleLayerModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate.cc.bak
new file mode 100644
index 00000000000..d7beaaf3b50
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate.cc.bak
@@ -0,0 +1,285 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "world_builder/features/oceanic_plate.h"
+
+#include "world_builder/features/oceanic_plate_models/composition/interface.h"
+#include "world_builder/features/oceanic_plate_models/grains/interface.h"
+#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/plugin_system.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    OceanicPlate::OceanicPlate(WorldBuilder::World *world_)
+      :
+      min_depth(NaN::DSNAN),
+      max_depth(NaN::DSNAN)
+    {
+      this->world = world_;
+      this->name = "oceanic plate";
+    }
+
+    OceanicPlate::~OceanicPlate()
+      = default;
+
+
+
+    void OceanicPlate::make_snippet(Parameters &prm)
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+
+      const std::string path = prm.get_full_json_path();
+
+      /*
+      ideally:
+       {
+        "model": "fault",
+        "name": "${1:default name}",
+        "dip point":[0.0,0.0],
+        "coordinates": [[0.0,0.0]],
+        "segments": [],
+        "sections": [],
+        "temperature models":[{"model":"uniform", "temperature":600.0}],
+        "composition models":[{"model":"uniform", "compositions": [0], "fractions":[1.0]}]
+       }
+       */
+
+      Pointer((path + "/body").c_str()).Set(declarations,"object");
+      Pointer((path + "/body/model").c_str()).Set(declarations,"oceanic plate");
+      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Oceanic Plate}");
+      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/temperature models").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/composition models").c_str()).Create(declarations).SetArray();
+    }
+
+
+
+    void
+    OceanicPlate::declare_entries(Parameters &prm,
+                                  const std::string & /*unused*/,
+                                  const std::vector<std::string> &required_entries)
+    {
+      prm.declare_entry("", Types::Object(required_entries), "Oceanic plate object. Requires properties `model` and `coordinates`.");
+
+      prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                        "The depth from which this feature is present");
+      prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                        "The depth to which this feature is present");
+      prm.declare_entry("temperature models",
+                        Types::PluginSystem("", Features::OceanicPlateModels::Temperature::Interface::declare_entries, {"model"}),
+                        "A list of temperature models.");
+      prm.declare_entry("composition models",
+                        Types::PluginSystem("", Features::OceanicPlateModels::Composition::Interface::declare_entries, {"model"}),
+                        "A list of composition models.");
+      prm.declare_entry("grains models",
+                        Types::PluginSystem("", Features::OceanicPlateModels::Grains::Interface::declare_entries, {"model"}),
+                        "A list of grains models.");
+    }
+
+    void
+    OceanicPlate::parse_entries(Parameters &prm)
+    {
+
+      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
+
+      this->name = prm.get<std::string>("name");
+
+      std::string tag = prm.get<std::string>("tag");
+      if (tag == "")
+        {
+          tag = "oceanic plate";
+        }
+      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
+
+      this->get_coordinates("coordinates", prm, coordinate_system);
+
+      min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+      min_depth = min_depth_surface.minimum;
+
+      max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+      max_depth = max_depth_surface.maximum;
+
+
+      prm.get_unique_pointers<Features::OceanicPlateModels::Temperature::Interface>("temperature models", temperature_models);
+
+      prm.enter_subsection("temperature models");
+      {
+        for (unsigned int i = 0; i < temperature_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              temperature_models[i]->parse_entries(prm,coordinates);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+
+      prm.get_unique_pointers<Features::OceanicPlateModels::Composition::Interface>("composition models", composition_models);
+
+      prm.enter_subsection("composition models");
+      {
+        for (unsigned int i = 0; i < composition_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              composition_models[i]->parse_entries(prm,coordinates);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+
+      prm.get_unique_pointers<Features::OceanicPlateModels::Grains::Interface>("grains models", grains_models);
+
+      prm.enter_subsection("grains models");
+      {
+        for (unsigned int i = 0; i < grains_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              grains_models[i]->parse_entries(prm,coordinates);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+    }
+
+
+    void
+    OceanicPlate::properties(const Point<3> &position_in_cartesian_coordinates,
+                             const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                             const double depth,
+                             const std::vector<std::array<unsigned int,3>> &properties,
+                             const double gravity_norm,
+                             const std::vector<size_t> &entry_in_output,
+                             std::vector<double> &output) const
+    {
+      if (depth <= max_depth && depth >= min_depth &&
+          WorldBuilder::Utilities::polygon_contains_point(coordinates, Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
+                                                                                world->parameters.coordinate_system->natural_coordinate_system())))
+        {
+          const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+          const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+          if (depth <= max_depth_local &&  depth >= min_depth_local)
+            {
+              for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
+                {
+                  switch (properties[i_property][0])
+                    {
+                      case 1:  // temperature
+                      {
+                        for (const auto &temperature_model: temperature_models)
+                          {
+                            output[entry_in_output[i_property]] = temperature_model->get_temperature(position_in_cartesian_coordinates,
+                                                                                                     position_in_natural_coordinates,
+                                                                                                     depth,
+                                                                                                     gravity_norm,
+                                                                                                     output[entry_in_output[i_property]],
+                                                                                                     min_depth_local,
+                                                                                                     max_depth_local);
+
+                            WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Temperature is not a number: " << output[entry_in_output[i_property]]
+                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+                            WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Temperature is not a finite: " << output[entry_in_output[i_property]]
+                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+
+                          }
+                        break;
+                        case 2: // composition
+
+                          for (const auto &composition_model: composition_models)
+                            {
+                              output[entry_in_output[i_property]] = composition_model->get_composition(position_in_cartesian_coordinates,
+                                                                                                       position_in_natural_coordinates,
+                                                                                                       depth,
+                                                                                                       properties[i_property][1],
+                                                                                                       output[entry_in_output[i_property]],
+                                                                                                       min_depth_local,
+                                                                                                       max_depth_local);
+
+                              WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Composition is not a number: " << output[entry_in_output[i_property]]
+                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+                              WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Composition is not a finite: " << output[entry_in_output[i_property]]
+                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+
+                            }
+
+                          break;
+                        }
+                      case 3: // grains
+                      {
+                        WorldBuilder::grains  grains(output,properties[i_property][2],entry_in_output[i_property]);
+                        for (const auto &grains_model: grains_models)
+                          {
+                            grains = grains_model->get_grains(position_in_cartesian_coordinates,
+                                                              position_in_natural_coordinates,
+                                                              depth,
+                                                              properties[i_property][1],
+                                                              grains,
+                                                              min_depth_local,
+                                                              max_depth_local);
+
+                          }
+                        grains.unroll_into(output,entry_in_output[i_property]);
+                        break;
+                      }
+                      case 4:
+                      {
+                        output[entry_in_output[i_property]] = static_cast<double>(tag_index);
+                        break;
+                      }
+                      break;
+                      default:
+                      {
+                        WBAssertThrow(false,
+                                      "Internal error: Unimplemented property provided. " <<
+                                      "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
+                                      "Provided property number was: " << properties[i_property][0]);
+                      }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Register plugin
+     */
+    WB_REGISTER_FEATURE(OceanicPlate, oceanic plate)
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/interface.cc.bak
new file mode 100644
index 00000000000..543e29701ce
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/interface.cc.bak
@@ -0,0 +1,81 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/composition/interface.h"
+
+#include <algorithm>
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Composition
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Composition
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/uniform.cc.bak
new file mode 100644
index 00000000000..ea2c7f7c0dc
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/uniform.cc.bak
@@ -0,0 +1,129 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/composition/uniform.h"
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Composition
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform compositional model. Sets constant compositional field.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the labels of the composition which are present there.");
+          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
+                            "TA list of compositional fractions corresponding to the compositions list.");
+          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value. Replacing implies that all compositions not "
+                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+          fractions = prm.get_vector<double>("fractions");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          WBAssertThrow(compositions.size() == fractions.size(),
+                        "There are not the same amount of compositions and fractions.");
+        }
+
+
+        double
+        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                 const double depth,
+                                 const unsigned int composition_number,
+                                 double composition,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          return apply_operation(operation,composition,fractions[i]);
+                        }
+                    }
+
+                  if (operation == Operations::REPLACE)
+                    return 0.0;
+                }
+            }
+          return composition;
+        }
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_COMPOSITION_MODEL(Uniform, uniform)
+      } // namespace Composition
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/interface.cc.bak
new file mode 100644
index 00000000000..f7e1b13aa56
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/interface.cc.bak
@@ -0,0 +1,111 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/grains/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/object.h"
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Grains
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          unsigned int counter = 0;
+          for (auto &it : get_declare_map())
+            {
+              // prevent infinite recursion
+              if (it.first != parent_name)
+                {
+                  prm.enter_subsection("oneOf");
+                  {
+                    prm.enter_subsection(std::to_string(counter));
+                    {
+                      prm.enter_subsection("properties");
+                      {
+                        prm.declare_entry("", Types::Object(required_entries), "grains object");
+
+                        prm.declare_entry("model", Types::String("",it.first),
+                                          "The name of the grains model.");
+
+                        it.second(prm, parent_name);
+                      }
+                      prm.leave_subsection();
+                    }
+                    prm.leave_subsection();
+                  }
+                  prm.leave_subsection();
+
+                  counter++;
+
+                }
+            }
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Grains
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.cc.bak
new file mode 100644
index 00000000000..95f95476802
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.cc.bak
@@ -0,0 +1,224 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution";
+        }
+
+        RandomUniformDistribution::~RandomUniformDistribution()
+          = default;
+
+        void
+        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistribution::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                              const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                              const double depth,
+                                              const unsigned int composition_number,
+                                              WorldBuilder::grains grains_,
+                                              const double  /*feature_min_depth*/,
+                                              const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          std::uniform_real_distribution<> dist(0.0,1.0);
+                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                            {
+                              // set a uniform random a_cosine_matrix per grain
+                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                              // and is licenend accourding to this website with the following licence:
+                              //
+                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                              // don't be a jerk, and remember that anything free comes with no guarantee.""
+                              //
+                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                              // the public domain, and is yours to study, modify, and use."
+
+                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                              const double one = dist(world->get_random_number_engine());
+                              const double two = dist(world->get_random_number_engine());
+                              const double three = dist(world->get_random_number_engine());
+
+                              const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
+                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                              const double z = 2.0* three; //For magnitude of pole deflection.
+
+                              // Compute a vector V used for distributing points over the sphere
+                              // via the reflection I - V Transpose(V).  This formulation of V
+                              // will guarantee that if x[1] and x[2] are uniformly distributed,
+                              // the reflected points will be uniform on the sphere.  Note that V
+                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                              const double r  = std::sqrt( z );
+                              const double Vx = std::sin( phi ) * r;
+                              const double Vy = std::cos( phi ) * r;
+                              const double Vz = std::sqrt( 2.F - z );
+
+                              // Compute the row vector S = Transpose(V) * R, where R is a simple
+                              // rotation by theta about the z-axis.  No need to compute Sz since
+                              // it's just Vz.
+
+                              const double st = std::sin( theta );
+                              const double ct = std::cos( theta );
+                              const double Sx = Vx * ct - Vy * st;
+                              const double Sy = Vx * st + Vy * ct;
+
+                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                              // is equivalent to V S - R.
+
+                              it_rotation_matrices[0][0] = Vx * Sx - ct;
+                              it_rotation_matrices[0][1] = Vx * Sy - st;
+                              it_rotation_matrices[0][2] = Vx * Vz;
+
+                              it_rotation_matrices[1][0] = Vy * Sx + st;
+                              it_rotation_matrices[1][1] = Vy * Sy - ct;
+                              it_rotation_matrices[1][2] = Vy * Vz;
+
+                              it_rotation_matrices[2][0] = Vz * Sx;
+                              it_rotation_matrices[2][1] = Vz * Sy;
+                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                            }
+
+                          double total_size = 0;
+                          for (auto &&it_sizes : grains_local.sizes)
+                            {
+                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                              total_size += it_sizes;
+                            }
+
+                          if (normalize_grain_sizes[i])
+                            {
+                              const double one_over_total_size = 1/total_size;
+                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                            }
+
+                          return grains_local;
+                        }
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
+      } // namespace Grains
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.cc.bak
new file mode 100644
index 00000000000..ffac673631f
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.cc.bak
@@ -0,0 +1,230 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution deflected";
+        }
+
+        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
+          = default;
+
+        void
+        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+          prm.declare_entry("deflections",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistributionDeflected::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+          deflections = prm.get_vector<double>("deflections");
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == deflections.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and deflections (" << deflections.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                                       const double depth,
+                                                       const unsigned int composition_number,
+                                                       WorldBuilder::grains grains_,
+                                                       const double  /*feature_min_depth*/,
+                                                       const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          std::uniform_real_distribution<> dist(0.0,1.0);
+                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                            {
+                              // set a uniform random a_cosine_matrix per grain
+                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                              // and is licenend accourding to this website with the following licence:
+                              //
+                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                              // don't be a jerk, and remember that anything free comes with no guarantee.""
+                              //
+                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                              // the public domain, and is yours to study, modify, and use."
+
+                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                              const double one = dist(world->get_random_number_engine());
+                              const double two = dist(world->get_random_number_engine());
+                              const double three = dist(world->get_random_number_engine());
+
+                              const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z)
+                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                              const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
+
+                              // Compute a vector V used for distributing points over the sphere
+                              // via the reflection I - V Transpose(V).  This formulation of V
+                              // will guarantee that if x[1] and x[2] are uniformly distributed,
+                              // the reflected points will be uniform on the sphere.  Note that V
+                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                              const double r  = std::sqrt( z );
+                              const double Vx = std::sin( phi ) * r;
+                              const double Vy = std::cos( phi ) * r;
+                              const double Vz = std::sqrt( 2.F - z );
+
+                              // Compute the row vector S = Transpose(V) * R, where R is a simple
+                              // rotation by theta about the z-axis.  No need to compute Sz since
+                              // it's just Vz.
+
+                              const double st = std::sin( theta );
+                              const double ct = std::cos( theta );
+                              const double Sx = Vx * ct - Vy * st;
+                              const double Sy = Vx * st + Vy * ct;
+
+                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                              // is equivalent to V S - R.
+
+                              it_rotation_matrices[0][0] = Vx * Sx - ct;
+                              it_rotation_matrices[0][1] = Vx * Sy - st;
+                              it_rotation_matrices[0][2] = Vx * Vz;
+
+                              it_rotation_matrices[1][0] = Vy * Sx + st;
+                              it_rotation_matrices[1][1] = Vy * Sy - ct;
+                              it_rotation_matrices[1][2] = Vy * Vz;
+
+                              it_rotation_matrices[2][0] = Vz * Sx;
+                              it_rotation_matrices[2][1] = Vz * Sy;
+                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                            }
+
+                          double total_size = 0;
+                          for (auto &&it_sizes : grains_local.sizes)
+                            {
+                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                              total_size += it_sizes;
+                            }
+
+                          if (normalize_grain_sizes[i])
+                            {
+                              const double one_over_total_size = 1/total_size;
+                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                            }
+
+                          return grains_local;
+                        }
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
+      } // namespace Grains
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/uniform.cc.bak
new file mode 100644
index 00000000000..ddb408107a9
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/uniform.cc.bak
@@ -0,0 +1,177 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/grains/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Grains
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform grains model. All grains start exactly the same.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
+                            "A list with the labels of the grains which are present there for each compositions.");
+
+          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
+                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(-1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
+
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
+          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
+
+          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
+                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
+
+
+          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
+                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
+
+          if (set_euler_angles)
+            {
+              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
+              rotation_matrices.resize(euler_angles_vector.size());
+              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
+                {
+                  rotation_matrices[i] = WorldBuilder::Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
+                }
+
+            }
+          else
+            {
+              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
+            }
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+
+
+          WBAssertThrow(compositions.size() == rotation_matrices.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                            const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                            const double depth,
+                            const unsigned int composition_number,
+                            WorldBuilder::grains grains_,
+                            const double  /*feature_min_depth*/,
+                            const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  for (unsigned int i =0; i < compositions.size(); ++i)
+                    {
+                      if (compositions[i] == composition_number)
+                        {
+                          std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
+
+                          const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
+                          std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
+
+
+                          return grains_local;
+                        }
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_GRAINS_MODEL(Uniform, uniform)
+      } // namespace Grains
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/adiabatic.cc.bak
new file mode 100644
index 00000000000..d41973ad571
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/adiabatic.cc.bak
@@ -0,0 +1,173 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/temperature/adiabatic.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        Adiabatic::Adiabatic(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          potential_mantle_temperature(NaN::DSNAN),
+          thermal_expansion_coefficient(NaN::DSNAN),
+          specific_heat(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "adiabatic";
+        }
+
+        Adiabatic::~Adiabatic()
+          = default;
+
+        void
+        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          prm.declare_entry("", Types::Object(),
+                            "Adiabatic temperature model. Uses global values by default.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the temperature of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the temperature of this feature is present.");
+
+          prm.declare_entry("potential mantle temperature", Types::Double(-1),
+                            "The potential temperature of the mantle at the surface in Kelvin. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
+                            "The thermal expansion coefficient in $K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("specific heat", Types::Double(-1),
+                            "The specific heat in $J kg^{-1} K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+        }
+
+        void
+        Adiabatic::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
+          if (potential_mantle_temperature < 0)
+            potential_mantle_temperature =  this->world->potential_mantle_temperature;
+
+
+          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
+          if (thermal_expansion_coefficient < 0)
+            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
+
+          specific_heat = prm.get<double>("specific heat");
+          if (specific_heat < 0)
+            specific_heat =  this->world->specific_heat;
+
+          // Some assertions in debug mode can't hurt and have helped before.
+          WBAssert(!std::isnan(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
+          WBAssert(std::isfinite(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
+
+          WBAssert(!std::isnan(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
+
+          WBAssert(!std::isnan(specific_heat),
+                   "specific_heat is not a number: " << specific_heat << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "specific_heat is not a finite: " << specific_heat << '.');
+
+        }
+
+
+        double
+        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                   const double depth,
+                                   const double gravity_norm,
+                                   double temperature_,
+                                   const double  /*feature_min_depth*/,
+                                   const double  /*feature_max_depth*/) const
+        {
+
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  const double adabatic_temperature = potential_mantle_temperature *
+                                                      std::exp(((thermal_expansion_coefficient * gravity_norm) /
+                                                                specific_heat) * depth);
+
+
+                  WBAssert(!std::isnan(adabatic_temperature),
+                           "adabatic_temperature is not a number: " << adabatic_temperature << ". "
+                           <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
+                           <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
+                           << ", gravity_norm = " << gravity_norm
+                           << ", specific_heat = " << specific_heat
+                           << ", depth = " << depth);
+
+                  WBAssert(std::isfinite(adabatic_temperature),
+                           "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
+
+                  return apply_operation(operation,temperature_,adabatic_temperature);
+                }
+            }
+
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(Adiabatic, adiabatic)
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/half_space_model.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/half_space_model.cc.bak
new file mode 100644
index 00000000000..e6d80f203dc
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/half_space_model.cc.bak
@@ -0,0 +1,210 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/temperature/half_space_model.h"
+
+
+#include "world_builder/consts.h"
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/point.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+#include <cstdint>
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        HalfSpaceModel::HalfSpaceModel(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          top_temperature(NaN::DSNAN),
+          bottom_temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "half space model";
+        }
+
+        HalfSpaceModel::~HalfSpaceModel()
+          = default;
+
+        void
+        HalfSpaceModel::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `ridge coordinates`, `spreading velocity`, `max depth` to the required parameters.
+          prm.declare_entry("", Types::Object({"ridge coordinates", "spreading velocity", "max depth"}),
+                            "Half space cooling mode");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the temperature of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the temperature of this feature is present."
+                            "Because half-space reaches background temperature asymptotically, "
+                            "this value should be ~2 times the nominal plate thickness of 100 km" );
+
+          prm.declare_entry("top temperature", Types::Double(293.15),
+                            "The actual surface temperature in degree Kelvin for this feature.");
+
+          prm.declare_entry("bottom temperature", Types::Double(-1),
+                            "The mantle temperature for the half-space cooling model"
+                            "in degree Kelvin for this feature. If the model has an adiabatic gradient"
+                            "this should be the mantle potential temperature, and T = Tad + Thalf. ");
+
+          prm.declare_entry("spreading velocity", Types::OneOf(Types::Double(0.05),Types::Array(Types::ValueAtPoints(0.05, std::numeric_limits<uint64_t>::max()))),
+                            "The spreading velocity of the plate in meter per year. "
+                            "This is the velocity with which one side moves away from the ridge.");
+
+          prm.declare_entry("ridge coordinates", Types::Array(Types::Array(Types::Point<2>(), 2),1),
+                            "An list of ridges. Each ridge is a lists of at least 2 2d points which "
+                            "define the location of the ridge. You need to define at least one ridge."
+                            "So the an example with two ridges is "
+                            "[[[10,20],[20,30],[10,40]],[[50,10],[60,10]]].");
+        }
+
+        void
+        HalfSpaceModel::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          top_temperature = prm.get<double>("top temperature");
+          bottom_temperature = prm.get<double>("bottom temperature");
+          spreading_velocities = prm.get_value_at_array("spreading velocity");
+
+          mid_oceanic_ridges = prm.get_vector<std::vector<Point<2>>>("ridge coordinates");
+          const double dtr = prm.coordinate_system->natural_coordinate_system() == spherical ? Consts::PI / 180.0 : 1.0;
+          for (auto &ridge_coordinates : mid_oceanic_ridges)
+            for (auto &ridge_coordinate : ridge_coordinates)
+              {
+                ridge_coordinate *= dtr;
+              }
+
+          unsigned int ridge_point_index = 0;
+          for (const auto &mid_oceanic_ridge : mid_oceanic_ridges)
+            {
+              std::vector<double> spreading_rates_for_ridge;
+              for (unsigned int index_y = 0; index_y < mid_oceanic_ridge.size(); index_y++)
+                {
+                  if (spreading_velocities.second.size() <= 1)
+                    {
+                      spreading_rates_for_ridge.push_back(spreading_velocities.second[0]);
+                    }
+                  else
+                    {
+                      spreading_rates_for_ridge.push_back(spreading_velocities.second[ridge_point_index]);
+                    }
+                  ridge_point_index += 1;
+                }
+              spreading_velocities_at_each_ridge_point.push_back(spreading_rates_for_ridge);
+            }
+        }
+
+        double
+        HalfSpaceModel::get_temperature(const Point<3> &position,
+                                        const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                        const double depth,
+                                        const double gravity_norm,
+                                        double temperature_,
+                                        const double /*feature_min_depth*/,
+                                        const double /*feature_max_depth*/) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  Objects::NaturalCoordinate position_in_natural_coordinates_at_min_depth = Objects::NaturalCoordinate(position,
+                                                                                            *(world->parameters.coordinate_system));
+                  position_in_natural_coordinates_at_min_depth.get_ref_depth_coordinate() += depth-min_depth;
+                  std::vector<std::vector<double>> subducting_plate_velocities = {{0}};
+                  std::vector<double> ridge_migration_times = {0.0};
+
+                  double bottom_temperature_local = bottom_temperature;
+
+                  if (bottom_temperature_local < 0)
+                    {
+                      bottom_temperature_local =  this->world->potential_mantle_temperature *
+                                                  std::exp(((this->world->thermal_expansion_coefficient* gravity_norm) /
+                                                            this->world->specific_heat) * depth);
+                    }
+
+                  std::vector<double> ridge_parameters = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                                         spreading_velocities_at_each_ridge_point,
+                                                         world->parameters.coordinate_system,
+                                                         position_in_natural_coordinates_at_min_depth,
+                                                         subducting_plate_velocities,
+                                                         ridge_migration_times);
+
+
+
+                  const double thermal_diffusivity = this->world->thermal_diffusivity;
+                  const double age = ridge_parameters[1] / ridge_parameters[0];
+
+                  double  temperature = bottom_temperature_local;
+
+                  temperature = temperature + (age > 0 ? (top_temperature - bottom_temperature_local)*std::erfc(depth/(2*std::sqrt(thermal_diffusivity*age))) : 0.);
+
+                  WBAssert(!std::isnan(temperature), "Temperature inside half-space cooling model is not a number: " << temperature
+                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
+                           << ", top_temperature = " << top_temperature
+                           << ", max_depth = " << max_depth
+                           << ", spreading_velocity = " << ridge_parameters[0]
+                           << ", thermal_diffusivity = " << thermal_diffusivity
+                           << ", age = " << age << '.');
+                  WBAssert(std::isfinite(temperature), "Temperature inside half-space cooling model is not a finite: " << temperature                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
+                           << ", top_temperature = " << top_temperature
+                           << ", spreading_velocity = " << ridge_parameters[0]
+                           << ", thermal_diffusivity = " << thermal_diffusivity
+                           << ", age = " << age << '.');
+
+
+                  return apply_operation(operation,temperature_,temperature);
+
+                }
+            }
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(HalfSpaceModel, half space model)
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/interface.cc.bak
new file mode 100644
index 00000000000..ddebc6632c8
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/interface.cc.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          // The type needs to be stored in a separate value, otherwise there are memory issues
+          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
+
+          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
+          {
+            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
+            {
+              "operation", type,
+              "Whether the value should replace any value previously defined at this location (replace), "
+              "add the value to the previously define value (add) or subtract the value to the previously "
+              "define value (subtract)."
+            }
+          });
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/linear.cc.bak
new file mode 100644
index 00000000000..3dad3b341bb
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/linear.cc.bak
@@ -0,0 +1,145 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/temperature/linear.h"
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        Linear::Linear(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          top_temperature(NaN::DSNAN),
+          bottom_temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "linear";
+        }
+
+        Linear::~Linear()
+          = default;
+
+        void
+        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add max depth to the required parameters.
+          prm.declare_entry("", Types::Object({"max depth"}),
+                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the temperature of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the temperature of this feature is present.");
+
+          prm.declare_entry("top temperature", Types::Double(293.15),
+                            "The temperature at the top in degree Kelvin of this feature."
+                            "If the value is below zero, the an adiabatic temperature is used.");
+
+          prm.declare_entry("bottom temperature", Types::Double(-1),
+                            "The temperature at the top in degree Kelvin of this feature. "
+                            "If the value is below zero, an adiabatic temperature is used.");
+        }
+
+        void
+        Linear::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          top_temperature = prm.get<double>("top temperature");
+          bottom_temperature = prm.get<double>("bottom temperature");
+        }
+
+
+        double
+        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                const double depth,
+                                const double gravity_norm,
+                                double temperature_,
+                                const double feature_min_depth,
+                                const double feature_max_depth) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  const double min_depth_local_local = std::max(feature_min_depth, min_depth_local);
+                  const double max_depth_local_local = std::min(feature_max_depth, max_depth_local);
+
+                  double top_temperature_local = top_temperature;
+                  if (top_temperature_local < 0)
+                    {
+                      top_temperature_local =  this->world->potential_mantle_temperature *
+                                               std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                         this->world->specific_heat) * min_depth_local_local);
+                    }
+
+                  double bottom_temperature_local = bottom_temperature;
+                  if (bottom_temperature_local < 0)
+                    {
+                      bottom_temperature_local =  this->world->potential_mantle_temperature *
+                                                  std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                            this->world->specific_heat) * max_depth_local_local);
+                    }
+
+                  const double new_temperature =  top_temperature_local + (max_depth_local_local - min_depth_local_local < 10.0*std::numeric_limits<double>::epsilon() ? 0.0 :
+                                                         (depth - min_depth_local_local) *
+                                                         ((bottom_temperature_local - top_temperature_local) / (max_depth_local_local - min_depth_local_local)));
+
+                  return apply_operation(operation,temperature_,new_temperature);
+                }
+            }
+
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(Linear, linear)
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model.cc.bak
new file mode 100644
index 00000000000..9184711f9a1
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model.cc.bak
@@ -0,0 +1,214 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/temperature/plate_model.h"
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/point.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        PlateModel::PlateModel(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          top_temperature(NaN::DSNAN),
+          bottom_temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "plate model";
+        }
+
+        PlateModel::~PlateModel()
+          = default;
+
+        void
+        PlateModel::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add temperature to the required parameters.
+          prm.declare_entry("", Types::Object({"max depth"}),
+                            "Plate model.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the temperature of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the temperature of this feature is present.");
+
+          prm.declare_entry("top temperature", Types::Double(293.15),
+                            "The temperature in degree Kelvin which this feature should have");
+
+          prm.declare_entry("bottom temperature", Types::Double(-1),
+                            "The temperature in degree Kelvin which this feature should have");
+
+          prm.declare_entry("spreading velocity", Types::OneOf(Types::Double(0.05),Types::Array(Types::ValueAtPoints(0.05, std::numeric_limits<uint64_t>::max()))),
+                            "The spreading velocity of the plate in meter per year. "
+                            "This is the velocity with which one side moves away from the ridge.");
+
+          prm.declare_entry("ridge coordinates", Types::Array(Types::Array(Types::Point<2>(), 2),1),
+                            "An list of ridges. Each ridge is a lists of at least 2 2d points which "
+                            "define the location of the ridge. You need to define at least one ridge."
+                            "So the an example with two ridges is "
+                            "[[[10,20],[20,30],[10,40]],[[50,10],[60,10]]].");
+
+        }
+
+        void
+        PlateModel::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          top_temperature = prm.get<double>("top temperature");
+          bottom_temperature = prm.get<double>("bottom temperature");
+          spreading_velocities = prm.get_value_at_array("spreading velocity");
+
+          mid_oceanic_ridges = prm.get_vector<std::vector<Point<2>>>("ridge coordinates");
+          const double dtr = prm.coordinate_system->natural_coordinate_system() == spherical ? Consts::PI / 180.0 : 1.0;
+          for (auto &ridge_coordinates : mid_oceanic_ridges)
+            for (auto &ridge_coordinate : ridge_coordinates)
+              {
+                ridge_coordinate *= dtr;
+              }
+
+          unsigned int ridge_point_index = 0;
+          for (const auto &mid_oceanic_ridge : mid_oceanic_ridges)
+            {
+              std::vector<double> spreading_rates_for_ridge;
+              for (unsigned int index_y = 0; index_y < mid_oceanic_ridge.size(); index_y++)
+                {
+                  if (spreading_velocities.second.size() <= 1)
+                    {
+                      spreading_rates_for_ridge.push_back(spreading_velocities.second[0]);
+                    }
+                  else
+                    {
+                      spreading_rates_for_ridge.push_back(spreading_velocities.second[ridge_point_index]);
+                    }
+                  ridge_point_index += 1;
+                }
+              spreading_velocities_at_each_ridge_point.push_back(spreading_rates_for_ridge);
+            }
+        }
+
+
+        double
+        PlateModel::get_temperature(const Point<3> &position,
+                                    const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                    const double depth,
+                                    const double gravity_norm,
+                                    double temperature_,
+                                    const double /*feature_min_depth*/,
+                                    const double /*feature_max_depth*/) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  Objects::NaturalCoordinate position_in_natural_coordinates_at_min_depth = Objects::NaturalCoordinate(position,
+                                                                                            *(world->parameters.coordinate_system));
+                  position_in_natural_coordinates_at_min_depth.get_ref_depth_coordinate() += depth-min_depth;
+                  std::vector<std::vector<double>> subducting_plate_velocities = {{0}};
+                  std::vector<double> ridge_migration_times = {0.0};
+                  double bottom_temperature_local = bottom_temperature;
+
+                  if (bottom_temperature_local < 0)
+                    {
+                      bottom_temperature_local =  this->world->potential_mantle_temperature *
+                                                  std::exp(((this->world->thermal_expansion_coefficient* gravity_norm) /
+                                                            this->world->specific_heat) * depth);
+                    }
+
+                  const int summation_number = 100;
+
+                  std::vector<double> ridge_parameters = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                                         spreading_velocities_at_each_ridge_point,
+                                                         world->parameters.coordinate_system,
+                                                         position_in_natural_coordinates_at_min_depth,
+                                                         subducting_plate_velocities,
+                                                         ridge_migration_times);
+
+                  const double thermal_diffusivity = this->world->thermal_diffusivity;
+                  const double age = ridge_parameters[1] / ridge_parameters[0];
+                  double temperature = top_temperature + (bottom_temperature_local - top_temperature) * (depth / max_depth);
+
+                  // This formula addresses the horizontal heat transfer by having the spreading velocity and distance to the ridge in it.
+                  // (Chapter 7 Heat, Fowler M. The solid earth: an introduction to global geophysics[M]. Cambridge University Press, 1990)
+                  for (int i = 1; i<summation_number+1; ++i)
+                    {
+                      temperature = temperature + (bottom_temperature_local - top_temperature) *
+                                    ((2 / (double(i) * Consts::PI)) * std::sin((double(i) * Consts::PI * depth) / max_depth) *
+                                     std::exp((((ridge_parameters[0] * max_depth)/(2 * thermal_diffusivity)) -
+                                               std::sqrt(((ridge_parameters[0]*ridge_parameters[0]*max_depth*max_depth) /
+                                                          (4*thermal_diffusivity*thermal_diffusivity)) + double(i) * double(i) * Consts::PI * Consts::PI)) *
+                                              ((ridge_parameters[0] * age) / max_depth)));
+
+                    }
+
+                  WBAssert(!std::isnan(temperature), "Temperature inside plate model is not a number: " << temperature
+                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
+                           << ", top_temperature = " << top_temperature
+                           << ", max_depth = " << max_depth
+                           << ", spreading_velocity = " << ridge_parameters[0]
+                           << ", thermal_diffusivity = " << thermal_diffusivity
+                           << ", age = " << age << '.');
+                  WBAssert(std::isfinite(temperature), "Temperature inside plate model is not a finite: " << temperature                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
+                           << ", top_temperature = " << top_temperature
+                           << ", spreading_velocity = " << ridge_parameters[0]
+                           << ", thermal_diffusivity = " << thermal_diffusivity
+                           << ", age = " << age << '.');
+
+
+                  return apply_operation(operation,temperature_,temperature);
+
+                }
+            }
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(PlateModel, plate model)
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.cc.bak
new file mode 100644
index 00000000000..98e5b7e0413
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.cc.bak
@@ -0,0 +1,161 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h"
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/point.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        PlateModelConstantAge::PlateModelConstantAge(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          top_temperature(NaN::DSNAN),
+          bottom_temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "plate model constant age";
+        }
+
+        PlateModelConstantAge::~PlateModelConstantAge()
+          = default;
+
+        void
+        PlateModelConstantAge::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add temperature to the required parameters.
+          prm.declare_entry("", Types::Object({"max depth"}),
+                            "Plate model, but with a fixed age.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the temperature of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the temperature of this feature is present.");
+
+          prm.declare_entry("top temperature", Types::Double(293.15),
+                            "The temperature in degree Kelvin which this feature should have");
+
+          prm.declare_entry("bottom temperature", Types::Double(-1),
+                            "The temperature in degree Kelvin which this feature should have");
+
+          prm.declare_entry("plate age", Types::Double(80e3),
+                            "The age of the plate in year. "
+                            "This age is assigned to the whole plate. ");
+        }
+
+        void
+        PlateModelConstantAge::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          top_temperature = prm.get<double>("top temperature");
+          bottom_temperature = prm.get<double>("bottom temperature");
+          plate_age = prm.get<double>("plate age")*31557600;
+        }
+
+
+        double
+        PlateModelConstantAge::get_temperature(const Point<3> & /*position*/,
+                                               const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                               const double depth,
+                                               const double gravity_norm,
+                                               double temperature_,
+                                               const double /*feature_min_depth*/,
+                                               const double /*feature_max_depth*/) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  double bottom_temperature_local = bottom_temperature;
+
+                  if (bottom_temperature_local < 0)
+                    {
+                      bottom_temperature_local =  this->world->potential_mantle_temperature *
+                                                  std::exp(((this->world->thermal_expansion_coefficient* gravity_norm) /
+                                                            this->world->specific_heat) * depth);
+                    }
+                  const int sommation_number = 100;
+
+                  // some aliases
+                  //const double top_temperature = top_temperature;
+                  const double thermal_diffusivity = this->world->thermal_diffusivity;
+                  double temperature = top_temperature + (bottom_temperature_local - top_temperature) * (depth / max_depth);
+
+                  // This formula ignores the horizontal heat transfer by just having the age of the plate in it.
+                  // (Chapter 7 Heat, Fowler M. The solid earth: an introduction to global geophysics[M]. Cambridge University Press, 1990)
+                  for (int i = 1; i<sommation_number+1; ++i)
+                    {
+                      temperature = temperature + (bottom_temperature_local - top_temperature) *
+                                    ((2 / (double(i) * Consts::PI)) * std::sin((double(i) * Consts::PI * depth) / max_depth) *
+                                     std::exp(-1.0 * i * i * Consts::PI * Consts::PI * thermal_diffusivity * plate_age / (max_depth * max_depth)));
+                    }
+
+                  WBAssert(!std::isnan(temperature), "Temperature inside plate model constant age is not a number: " << temperature
+                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
+                           << ", top_temperature = " << top_temperature
+                           << ", max_depth = " << max_depth
+                           << ", thermal_diffusivity = " << thermal_diffusivity
+                           << ", age = " << plate_age << '.');
+                  WBAssert(std::isfinite(temperature), "Temperature inside plate model constant age is not a finite: " << temperature                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
+                           << ", top_temperature = " << top_temperature
+                           << ", thermal_diffusivity = " << thermal_diffusivity
+                           << ", age = " << plate_age << '.');
+
+
+                  return apply_operation(operation,temperature_,temperature);
+
+                }
+            }
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(PlateModelConstantAge, plate model constant age)
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/uniform.cc.bak
new file mode 100644
index 00000000000..ec3bf293ce9
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/uniform.cc.bak
@@ -0,0 +1,116 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/oceanic_plate_models/temperature/uniform.h"
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace OceanicPlateModels
+    {
+      namespace Temperature
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `temperature` and to the required parameters.
+          prm.declare_entry("", Types::Object({"temperature"}),
+                            "Uniform temperature model. Set the temperature to a constant value.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
+                            "The depth in meters from which the temperature of this feature is present.");
+
+          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
+                            "The depth in meters to which the temperature of this feature is present.");
+
+          prm.declare_entry("temperature", Types::Double(293.15),
+                            "The temperature in degree Kelvin which this feature should have");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
+        {
+
+          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
+          min_depth = min_depth_surface.minimum;
+          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
+          max_depth = max_depth_surface.maximum;
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          temperature = prm.get<double>("temperature");
+        }
+
+
+        double
+        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                 const double depth,
+                                 const double  /*gravity*/,
+                                 double temperature_,
+                                 const double /*feature_min_depth*/,
+                                 const double /*feature_max_depth*/) const
+        {
+
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
+              if (depth <= max_depth_local &&  depth >= min_depth_local)
+                {
+                  return apply_operation(operation,temperature_,temperature);
+                }
+            }
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(Uniform, uniform)
+      } // namespace Temperature
+    } // namespace OceanicPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/plume.cc.bak b/contrib/world_builder/source/world_builder/features/plume.cc.bak
new file mode 100644
index 00000000000..3e3ca597318
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/plume.cc.bak
@@ -0,0 +1,403 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/plume.h"
+
+
+#include "world_builder/features/plume_models/composition/interface.h"
+#include "world_builder/features/plume_models/grains/interface.h"
+#include "world_builder/features/plume_models/temperature/interface.h"
+#include "world_builder/features/feature_utilities.h"
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/plugin_system.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/world.h"
+
+#include <iostream>
+#include <algorithm>
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    Plume::Plume(WorldBuilder::World *world_)
+      :
+      min_depth(NaN::DSNAN),
+      max_depth(NaN::DSNAN)
+    {
+      this->world = world_;
+      this->name = "plume";
+    }
+
+    Plume::~Plume()
+      = default;
+
+
+
+    void Plume::make_snippet(Parameters &prm)
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+
+      const std::string path = prm.get_full_json_path();
+
+      Pointer((path + "/body").c_str()).Set(declarations,"object");
+      Pointer((path + "/body/model").c_str()).Set(declarations,"plume");
+      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Plume}");
+      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/temperature models").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/composition models").c_str()).Create(declarations).SetArray();
+    }
+
+
+
+    void
+    Plume::declare_entries(Parameters &prm,
+                           const std::string & /*unused*/,
+                           const std::vector<std::string> &required_entries)
+    {
+      prm.declare_entry("", Types::Object(required_entries), "Plume object. Requires properties `model` and `coordinates`.");
+
+      prm.declare_entry("min depth", Types::Double(0),
+                        "The depth from which this feature is present, in other words, the "
+                        "depth of the tip of the plume. If the first entry in the cross "
+                        "section depths has a greater depth, an ellipsoidal plume head will "
+                        "be added in between. Units: m.");
+      prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
+                        "The depth to which this feature is present. Units: m.");
+      prm.declare_entry("cross section depths", Types::Array(Types::Double(0)),
+                        "The depths of the elliptic cross section of the plume. Units: m.");
+      prm.declare_entry("semi-major axis", Types::Array(Types::Double(100.e3)),
+                        "The lengths of the semi-major axes of the elliptic cross sections of the plume. "
+                        "In spherical coordinates, this is in degrees, otherwise in meters.");
+      prm.declare_entry("eccentricity", Types::Array(Types::Double(0)),
+                        "The eccentricities of the cross sections.");
+      prm.declare_entry("rotation angles", Types::Array(Types::Double(0)),
+                        "The directions that the semi-major axis of the elliptic cross-sections "
+                        "are pointing to, in degrees. This direction is expressed as the angle from "
+                        "geographic North in spherical coordinates, or as the angle from the Y axis "
+                        "(clockwise) in Cartesian coordinates. "
+                        "The angle should be between 0 and 360 degrees.");
+
+      prm.declare_entry("temperature models",
+                        Types::PluginSystem("", Features::PlumeModels::Temperature::Interface::declare_entries, {"model"}),
+                        "A list of temperature models.");
+      prm.declare_entry("composition models",
+                        Types::PluginSystem("", Features::PlumeModels::Composition::Interface::declare_entries, {"model"}),
+                        "A list of composition models.");
+      prm.declare_entry("grains models",
+                        Types::PluginSystem("", Features::PlumeModels::Grains::Interface::declare_entries, {"model"}),
+                        "A list of grains models.");
+    }
+
+    void
+    Plume::parse_entries(Parameters &prm)
+    {
+      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
+
+      this->name = prm.get<std::string>("name");
+
+      std::string tag = prm.get<std::string>("tag");
+      if (tag == "")
+        {
+          tag = "plume";
+        }
+      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
+
+      this->get_coordinates("coordinates", prm, coordinate_system);
+
+      min_depth = prm.get<double>("min depth");
+      max_depth = prm.get<double>("max depth");
+
+      depths = prm.get_vector<double>("cross section depths");
+      semi_major_axis_lengths = prm.get_vector<double>("semi-major axis");
+      eccentricities = prm.get_vector<double>("eccentricity");
+      rotation_angles = prm.get_vector<double>("rotation angles");
+
+      for (unsigned int i = 0; i < depths.size()-1; ++i)
+        WBAssert(depths[i] < depths[i+1],
+                 "The depths of the elliptic cross sections of the plume need to be listed in ascending order.");
+
+      WBAssert(depths.size() == coordinates.size(),
+               "The cross section depths array needs to have the same number of entries as there are coordinates. At the moment there are: "
+               << depths.size()
+               << " depth entries but "
+               << coordinates.size()
+               << " coordinates!");
+
+      WBAssert(semi_major_axis_lengths.size() == coordinates.size(),
+               "The semi-major axis array needs to have the same number of entries as there are coordinates. At the moment there are: "
+               << semi_major_axis_lengths.size()
+               << " semi-major axis entries but "
+               << coordinates.size()
+               << " coordinates!");
+
+      WBAssert(eccentricities.size() == coordinates.size(),
+               "The eccentricity array needs to have the same number of entries as there are coordinates. At the moment there are: "
+               << eccentricities.size()
+               << " eccentricity entries but "
+               << coordinates.size()
+               << " coordinates!");
+
+      WBAssert(rotation_angles.size() == coordinates.size(),
+               "The rotation angles array needs to have the same number of entries as there are coordinates. At the moment there are: "
+               << rotation_angles.size()
+               << " rotation angle entries but "
+               << coordinates.size()
+               << " coordinates!");
+
+
+      // Convert degrees to radians, convert from geographical to mathematical
+      for (double &rotation_angle : rotation_angles)
+        rotation_angle = Consts::PI/2. - rotation_angle * Consts::PI/180.;
+
+      // convert semi_major_axis_lengths to radians if we are in spherical coordinates
+      if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical)
+        for (double &semi_major_axis_length : semi_major_axis_lengths)
+          {
+            semi_major_axis_length *= Consts::PI/180.;
+          }
+
+      prm.get_unique_pointers<Features::PlumeModels::Temperature::Interface>("temperature models", temperature_models);
+
+      prm.enter_subsection("temperature models");
+      {
+        for (unsigned int i = 0; i < temperature_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              temperature_models[i]->parse_entries(prm);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+
+      prm.get_unique_pointers<Features::PlumeModels::Composition::Interface>("composition models", composition_models);
+
+      prm.enter_subsection("composition models");
+      {
+        for (unsigned int i = 0; i < composition_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              composition_models[i]->parse_entries(prm);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+
+      prm.get_unique_pointers<Features::PlumeModels::Grains::Interface>("grains models", grains_models);
+
+      prm.enter_subsection("grains models");
+      {
+        for (unsigned int i = 0; i < grains_models.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              grains_models[i]->parse_entries(prm);
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+    }
+
+
+
+    void
+    Plume::properties(const Point<3> &position_in_cartesian_coordinates,
+                      const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                      const double depth,
+                      const std::vector<std::array<unsigned int,3>> &properties,
+                      const double gravity_norm,
+                      const std::vector<size_t> &entry_in_output,
+                      std::vector<double> &output) const
+    {
+      // Figure out if the point is within the plume
+      auto upper = std::upper_bound(depths.begin(), depths.end(), depth);
+
+      Point<2> plume_center(coordinates[0]);
+      double semi_major_axis_length;
+      double eccentricity;
+      double rotation_angle;
+
+      if (depth < min_depth)
+        return;
+      else if (upper - depths.begin() == 0)
+        {
+          // interpolate to make the top of the plume spherical
+          plume_center = coordinates.front();
+          eccentricity = eccentricities.front();
+          rotation_angle = rotation_angles.front();
+
+          const double fraction = (depth - min_depth) / (depths.front() - min_depth);
+
+          const double a = depths.front() - min_depth;
+          const double b = semi_major_axis_lengths.front();
+          const double y = (1. - fraction) * a;
+
+          // use ellipse equation:
+          semi_major_axis_length = std::sqrt((1 - std::pow(y/a,2)) * b*b);
+        }
+      else if (upper - depths.end() == 0)
+        {
+          plume_center = coordinates.back();
+          semi_major_axis_length = semi_major_axis_lengths.back();
+          eccentricity = eccentricities.back();
+          rotation_angle = rotation_angles.back();
+        }
+      else
+        {
+          const unsigned int index = static_cast<unsigned int>(std::distance(depths.begin(), upper));
+          const double fraction = (depth - depths[index-1]) / (depths[index] - depths[index-1]);
+
+          plume_center[0] = (1-fraction) * coordinates[index-1][0] + fraction * (coordinates[index][0]);
+          plume_center[1] = (1-fraction) * coordinates[index-1][1] + fraction * (coordinates[index][1]);
+
+          semi_major_axis_length = (1-fraction) * semi_major_axis_lengths[index-1] + fraction * semi_major_axis_lengths[index];
+          eccentricity = (1-fraction) * eccentricities[index-1] + fraction * eccentricities[index];
+
+          // For the angles, we only want to go between zero and pi, and we have to make sure we
+          // interpolate the values close to zero/pi correctly:
+          rotation_angle = interpolate_angle_across_zero(rotation_angles[index-1], rotation_angles[index], fraction);
+        }
+
+      const Point<2> surface_point(position_in_natural_coordinates.get_surface_coordinates(),
+                                   world->parameters.coordinate_system->natural_coordinate_system());
+
+      double relative_distance_from_center =
+        WorldBuilder::Utilities::fraction_from_ellipse_center(plume_center,
+                                                              semi_major_axis_length,
+                                                              eccentricity,
+                                                              rotation_angle,
+                                                              surface_point);
+
+      // If we are in the tip, we have to compute the difference diffently:
+      if (depth >= min_depth && depth < depths.front())
+        {
+          const double a = semi_major_axis_lengths.front();
+          const double b = a * std::sqrt(1 - std::pow(eccentricity, 2));
+          const double c = depths.front() - min_depth;
+
+          const double x = (surface_point[0] - plume_center[0]) * std::cos(rotation_angle) + (surface_point[1] - plume_center[1])* std::sin(rotation_angle);
+          const double y = -(surface_point[0] - plume_center[0]) * std::sin(rotation_angle) + (surface_point[1] - plume_center[1])* std::cos(rotation_angle);
+          const double z = depths.front() - depth;
+
+          // use ellipsoid equation:
+          relative_distance_from_center = (x*x)/(a*a) + (y*y)/(b*b) + (z*z)/(c*c);
+        }
+
+      if (depth <= max_depth && depth >= min_depth && relative_distance_from_center <= 1.)
+        {
+
+          for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
+            {
+              switch (properties[i_property][0])
+                {
+                  case 1:  // temperature
+                  {
+                    for (const auto &temperature_model: temperature_models)
+                      {
+                        output[entry_in_output[i_property]] = temperature_model->get_temperature(position_in_cartesian_coordinates,
+                                                                                                 position_in_natural_coordinates,
+                                                                                                 depth,
+                                                                                                 gravity_norm,
+                                                                                                 output[entry_in_output[i_property]],
+                                                                                                 min_depth,
+                                                                                                 max_depth,
+                                                                                                 relative_distance_from_center);
+
+                        WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Temperature is not a number: " << output[entry_in_output[i_property]]
+                                 << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+                        WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Temperature is not finite: " << output[entry_in_output[i_property]]
+                                 << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+
+                      }
+                    break;
+                    case 2: // composition
+
+                      for (const auto &composition_model: composition_models)
+                        {
+                          output[entry_in_output[i_property]] = composition_model->get_composition(position_in_cartesian_coordinates,
+                                                                                                   position_in_natural_coordinates,
+                                                                                                   depth,
+                                                                                                   properties[i_property][1],
+                                                                                                   output[entry_in_output[i_property]],
+                                                                                                   min_depth,
+                                                                                                   max_depth);
+
+                          WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Composition is not a number: " << output[entry_in_output[i_property]]
+                                   << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+                          WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Composition is not finite: " << output[entry_in_output[i_property]]
+                                   << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+
+                        }
+
+                      break;
+                    }
+                  case 3: // grains
+                  {
+                    WorldBuilder::grains  grains(output,properties[i_property][2],entry_in_output[i_property]);
+                    for (const auto &grains_model: grains_models)
+                      {
+                        grains = grains_model->get_grains(position_in_cartesian_coordinates,
+                                                          position_in_natural_coordinates,
+                                                          depth,
+                                                          properties[i_property][1],
+                                                          grains,
+                                                          min_depth,
+                                                          max_depth);
+
+                      }
+                    grains.unroll_into(output,entry_in_output[i_property]);
+                    break;
+                  }
+                  case 4:
+                  {
+                    output[entry_in_output[i_property]] = static_cast<double>(tag_index);
+                    break;
+                  }
+                  default:
+                  {
+                    WBAssertThrow(false,
+                                  "Internal error: Unimplemented property provided. " <<
+                                  "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
+                                  "Provided property number was: " << properties[i_property][0]);
+                  }
+                }
+            }
+        }
+    }
+
+    WB_REGISTER_FEATURE(Plume, plume)
+
+  } // namespace Features
+} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/composition/interface.cc.bak
new file mode 100644
index 00000000000..0921105f353
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/plume_models/composition/interface.cc.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/plume_models/composition/interface.h"
+
+#include <algorithm>
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace PlumeModels
+    {
+      namespace Composition
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Composition
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/composition/uniform.cc.bak
new file mode 100644
index 00000000000..66065e75d46
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/plume_models/composition/uniform.cc.bak
@@ -0,0 +1,129 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/plume_models/composition/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    using namespace FeatureUtilities;
+    namespace PlumeModels
+    {
+      namespace Composition
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform compositional model. Sets constant compositional field.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::Double(0),
+                            "The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
+                            "The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the labels of the composition which are present there.");
+
+          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
+                            "TA list of compositional fractions corresponding to the compositions list.");
+
+          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value. Replacing implies that all compositions not "
+                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min depth");
+          max_depth = prm.get<double>("max depth");
+
+          compositions = prm.get_vector<unsigned int>("compositions");
+          fractions = prm.get_vector<double>("fractions");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          WBAssertThrow(compositions.size() == fractions.size(),
+                        "There are not the same amount of compositions and fractions.");
+        }
+
+
+        double
+        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const Objects::NaturalCoordinate & /*position_in_natural_coordinates*/,
+                                 const double depth,
+                                 const unsigned int composition_number,
+                                 double composition,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      return apply_operation(operation,composition,fractions[i]);
+                    }
+                }
+
+              if (operation == Operations::REPLACE)
+                return 0.0;
+            }
+          return composition;
+        }
+        WB_REGISTER_FEATURE_PLUME_COMPOSITION_MODEL(Uniform, uniform)
+      } // namespace Composition
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/grains/interface.cc.bak
new file mode 100644
index 00000000000..69abaa7394a
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/plume_models/grains/interface.cc.bak
@@ -0,0 +1,81 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/plume_models/grains/interface.h"
+
+#include <algorithm>
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace PlumeModels
+    {
+      namespace Grains
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          prm.declare_model_entries("grains",parent_name, get_declare_map(),required_entries);
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Grains
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/grains/uniform.cc.bak
new file mode 100644
index 00000000000..d6976a7ff4f
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/plume_models/grains/uniform.cc.bak
@@ -0,0 +1,169 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/plume_models/grains/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/utilities.h"
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace PlumeModels
+    {
+      namespace Grains
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform grains model. All grains start exactly the same.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::Double(0),
+                            "The depth in meters from which the grains of this feature are present.");
+          prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
+                            "The depth in meters to which the grains of this feature are present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
+                            "A list with the rotation matrices of the grains which are present there for each compositions.");
+
+          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
+                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace", "multiply"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(-1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
+
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min depth");
+          max_depth = prm.get<double>("max depth");
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
+          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
+
+          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
+                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
+
+
+          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
+                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
+
+          if (set_euler_angles)
+            {
+              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
+              rotation_matrices.resize(euler_angles_vector.size());
+              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
+                {
+                  rotation_matrices[i] = Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
+                }
+
+            }
+          else
+            {
+              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
+            }
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+
+
+          WBAssertThrow(compositions.size() == rotation_matrices.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                            const Objects::NaturalCoordinate & /*position_in_natural_coordinates*/,
+                            const double depth,
+                            const unsigned int composition_number,
+                            WorldBuilder::grains grains_,
+                            const double  /*feature_min_depth*/,
+                            const double /*feature_max_depth*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
+
+                      const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
+                      std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
+
+                      return grains_local;
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_PLUME_GRAINS_MODEL(Uniform, uniform)
+      } // namespace Grains
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/temperature/gaussian.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/temperature/gaussian.cc.bak
new file mode 100644
index 00000000000..e7fc12d4277
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/plume_models/temperature/gaussian.cc.bak
@@ -0,0 +1,166 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/plume_models/temperature/gaussian.h"
+
+
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/array.h"
+#include "world_builder/world.h"
+
+#include <algorithm>
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace PlumeModels
+    {
+      namespace Temperature
+      {
+        Gaussian::Gaussian(WorldBuilder::World *world_)
+          :
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "gaussian";
+        }
+
+        Gaussian::~Gaussian()
+          = default;
+
+        void
+        Gaussian::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `max distance fault` center to the required parameters.
+          prm.declare_entry("", Types::Object({"centerline temperatures"}),
+                            "Gaussian temperature model. The temperature is interpolated between the plume center "
+                            "and margin (as defined by the plume feature) using a Gaussian function: "
+                            "T(r) = T_center(z) exp(-r^2/(2 sigma^2). "
+                            "The temperature at the plume centerline T_center can be changed with depth by defining "
+                            "an array of depths and centerline temperatures, and temperature is interpolated linearly "
+                            "with depth. Similarly, the sigma of the Gaussian function (relative to the width of "
+                            "the plume as given by the plume feature) can be changed with depth. "
+                            "Temperature is always interpolated in a horizonzal/radial plane, except for the plume "
+                            "head: If the first depth of the plume centerline and the minimum depth of the plume "
+                            "feature are different, an ellipsoidal plume head is created in this depth range. "
+                            "Within this plume head, temperature is interpolated radially, i.e., depending on the "
+                            "distance from the center of the ellipsoid.");
+
+          prm.declare_entry("depths", Types::Array(Types::Double(0)),
+                            "The list of depths where both the temperature in the center of the plume "
+                            "and the width of the temperature anomaly in terms of the sigma of a Gaussian "
+                            "function can be provided. Temperature is interpolated linearly in vertical "
+                            "direction between these depths. Units: m.");
+          prm.declare_entry("centerline temperatures", Types::Array(Types::Double(0)),
+                            "The temperature at the center of this feature in degree Kelvin."
+                            "If the value is below zero, then an adiabatic temperature is used.");
+          prm.declare_entry("gaussian sigmas", Types::Array(Types::Double(0.3)),
+                            "The sigma (standard deviation) of the Gaussian function used to compute the "
+                            "temperature distribution within the plume. This sigma is non-dimensional, i.e. "
+                            "it is defined relative to the distance between the plume center and margin as "
+                            "defined by the plume feature. Choosing a sigma of 1 therefore means that the "
+                            "temperature at the plume margin is set to a fraction of 1/sqrt(e) (approx. 0.61) "
+                            "of the centerline temperature. To achieve a smoother transition between the "
+                            "plume temperature and the outside temperature a smaller values has to be chosen "
+                            "for the gaussian sigmas.");
+        }
+
+        void
+        Gaussian::parse_entries(Parameters &prm)
+        {
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          depths = prm.get_vector<double>("depths");
+          center_temperatures = prm.get_vector<double>("centerline temperatures");
+          gaussian_sigmas = prm.get_vector<double>("gaussian sigmas");
+
+          WBAssert(center_temperatures.size() == depths.size() && gaussian_sigmas.size() == depths.size(),
+                   "The depths, center_temperatures and gaussian_sigmas arrays need to have the same number of entries. "
+                   "At the moment there are: "
+                   << depths.size() << " depth entries, "
+                   << center_temperatures.size() << " centerline temperature entries, and "
+                   << gaussian_sigmas.size() << " gaussian sigma entries!");
+        }
+
+
+        double
+        Gaussian::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                  const Objects::NaturalCoordinate & /*position_in_natural_coordinates*/,
+                                  const double depth,
+                                  const double gravity_norm,
+                                  double temperature_,
+                                  const double feature_min_depth,
+                                  const double feature_max_depth,
+                                  const double relative_distance_from_center) const
+        {
+          if (depth <= feature_max_depth && depth >= feature_min_depth && relative_distance_from_center <= 1.)
+            {
+              // Figure out if the point is within the plume
+              auto upper = std::upper_bound(depths.begin(), depths.end(), depth);
+
+              double center_temperature_local;
+              double gaussian_sigma;
+
+              if (upper - depths.begin() == 0)
+                {
+                  center_temperature_local = center_temperatures.front();
+                  gaussian_sigma = gaussian_sigmas.front();
+                }
+              else if (upper - depths.end() == 0)
+                {
+                  center_temperature_local = center_temperatures.back();
+                  gaussian_sigma = gaussian_sigmas.back();
+                }
+              else
+                {
+                  const unsigned int index = static_cast<unsigned int>(std::distance(depths.begin(), upper));
+                  const double fraction = (depth - depths[index-1]) / (depths[index] - depths[index-1]);
+
+                  center_temperature_local = (1-fraction) * center_temperatures[index-1] + fraction * center_temperatures[index];
+                  gaussian_sigma = (1-fraction) * gaussian_sigmas[index-1] + fraction * gaussian_sigmas[index];
+                }
+
+              if (center_temperature_local < 0)
+                {
+                  center_temperature_local =  this->world->potential_mantle_temperature *
+                                              std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                        this->world->specific_heat) * depth);
+                }
+
+              const double new_temperature =   center_temperature_local * std::exp(-relative_distance_from_center/(2.*std::pow(gaussian_sigma, 2)));
+
+              return apply_operation(operation,temperature_,new_temperature);
+
+            }
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_PLUME_TEMPERATURE_MODEL(Gaussian, gaussian)
+      } // namespace Temperature
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/temperature/interface.cc.bak
new file mode 100644
index 00000000000..98c36d94b9a
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/plume_models/temperature/interface.cc.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/plume_models/temperature/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace PlumeModels
+    {
+      namespace Temperature
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          // The type needs to be stored in a separate value, otherwise there are memory issues
+          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
+
+          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
+          {
+            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
+            {
+              "operation", type,
+              "Whether the value should replace any value previously defined at this location (replace), "
+              "add the value to the previously define value (add) or subtract the value to the previously "
+              "define value (subtract)."
+            }
+          });
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Temperature
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/temperature/uniform.cc.bak
new file mode 100644
index 00000000000..99438d63b31
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/plume_models/temperature/uniform.cc.bak
@@ -0,0 +1,106 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/plume_models/temperature/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/value_at_points.h"
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace PlumeModels
+    {
+      namespace Temperature
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `temperature` to the required parameters.
+          prm.declare_entry("", Types::Object({"temperature"}),
+                            "Uniform temperature model. Set the temperature to a constant value.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min depth", Types::Double(0),
+                            "The depth in meters from which the temperature of this feature is present.");
+          prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
+                            "The depth in meters to which the temperature of this feature is present.");
+
+          prm.declare_entry("temperature", Types::Double(293.15),
+                            "The temperature in degree Kelvin which this feature should have");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min depth");
+          max_depth = prm.get<double>("max depth");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          temperature = prm.get<double>("temperature");
+        }
+
+
+        double
+        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const Objects::NaturalCoordinate & /*position_in_natural_coordinates*/,
+                                 const double depth,
+                                 const double  /*gravity*/,
+                                 double temperature_,
+                                 const double /*feature_min_depth*/,
+                                 const double /*feature_max_depth*/,
+                                 const double /*relative_distance_from_center*/) const
+        {
+          if (depth <= max_depth && depth >= min_depth)
+            {
+              return apply_operation(operation,temperature_,temperature);
+            }
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_PLUME_TEMPERATURE_MODEL(Uniform, uniform)
+      } // namespace Temperature
+    } // namespace PlumeModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate.cc.bak
new file mode 100644
index 00000000000..8d5faa53360
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate.cc.bak
@@ -0,0 +1,762 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "world_builder/features/subducting_plate.h"
+
+
+#include "glm/glm.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/point.h"
+#include "world_builder/types/segment.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/world.h"
+#include <algorithm>
+
+using namespace std;
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    SubductingPlate::SubductingPlate(WorldBuilder::World *world_)
+      :
+      reference_point(0,0,cartesian)
+    {
+      this->world = world_;
+      this->name = "subducting plate";
+    }
+
+    SubductingPlate::~SubductingPlate()
+      = default;
+
+
+
+    void SubductingPlate::make_snippet(Parameters &prm)
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+
+      const std::string path = prm.get_full_json_path();
+
+      /*
+      ideally:
+       {
+        "model": "fault",
+        "name": "${1:default name}",
+        "dip point":[0.0,0.0],
+        "coordinates": [[0.0,0.0]],
+        "segments": [],
+        "sections": [],
+        "temperature models":[{"model":"uniform", "temperature":600.0}],
+        "composition models":[{"model":"uniform", "compositions": [0], "fractions":[1.0]}]
+       }
+       */
+
+      Pointer((path + "/body").c_str()).Set(declarations,"object");
+      Pointer((path + "/body/model").c_str()).Set(declarations,"subducting plate");
+      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Subducting Plate}");
+      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/temperature models").c_str()).Create(declarations).SetArray();
+      Pointer((path + "/body/composition models").c_str()).Create(declarations).SetArray();
+    }
+
+
+
+    void
+    SubductingPlate::declare_entries(Parameters &prm,
+                                     const std::string &parent_name,
+                                     const std::vector<std::string> &required_entries)
+    {
+      // This statement is needed because of the recursion associated with
+      // the sections entry.
+      if (parent_name == "items")
+        {
+          prm.enter_subsection("properties");
+        }
+      else
+        {
+          prm.declare_entry("", Types::Object(required_entries), "Subducting slab object. Requires properties `model` and `coordinates`.");
+        }
+
+
+      prm.declare_entry("min depth", Types::Double(0),
+                        "The depth to which this feature is present");
+      prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
+                        "The depth to which this feature is present");
+      prm.declare_entry("dip point", Types::Point<2>(),
+                        "The depth to which this feature is present");
+
+      /*prm.declare_entry("segments", Types::Array(Types::Segment(0,Point<2>(0,0,invalid),Point<2>(0,0,invalid),Point<2>(0,0,invalid),
+                                                                Types::PluginSystem("", Features::SubductingPlateModels::Temperature::Interface::declare_entries, {"model"}),
+                                                                Types::PluginSystem("", Features::SubductingPlateModels::Composition::Interface::declare_entries, {"model"}),
+                                                                Types::PluginSystem("", Features::SubductingPlateModels::Grains::Interface::declare_entries, {"model"}))),
+                        "The depth to which this feature is present");*/
+      prm.declare_entry("segments", Types::Array(Types::Segment(0,Point<2>(0,0,invalid),Point<2>(0,0,invalid),Point<2>(0,0,invalid),
+                                                                Types::PluginSystem("", Features::SubductingPlateModels::Temperature::Interface::declare_entries, {"model"}),
+                                                                Types::PluginSystem("", Features::SubductingPlateModels::Composition::Interface::declare_entries, {"model"}),
+                                                                Types::PluginSystem("", Features::SubductingPlateModels::Grains::Interface::declare_entries, {"model"}))),
+                        "The depth to which this feature is present");
+
+      prm.declare_entry("temperature models",
+                        Types::PluginSystem("", Features::SubductingPlateModels::Temperature::Interface::declare_entries, {"model"}),
+                        "A list of temperature models.");
+      prm.declare_entry("composition models",
+                        Types::PluginSystem("", Features::SubductingPlateModels::Composition::Interface::declare_entries, {"model"}),
+                        "A list of composition models.");
+      prm.declare_entry("grains models",
+                        Types::PluginSystem("", Features::SubductingPlateModels::Grains::Interface::declare_entries, {"model"}),
+                        "A list of grains models.");
+
+      if (parent_name != "items")
+        {
+          // This only happens if we are not in sections
+          prm.declare_entry("sections", Types::Array(Types::PluginSystem("",Features::SubductingPlate::declare_entries, {"coordinate"}, false)),"A list of feature properties for a coordinate.");
+        }
+      else
+        {
+
+          // this only happens in sections
+          prm.declare_entry("coordinate", Types::UnsignedInt(0),
+                            "The coordinate which should be overwritten");
+
+          prm.leave_subsection();
+        }
+    }
+
+    void
+    SubductingPlate::parse_entries(Parameters &prm)
+    {
+      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
+
+      this->name = prm.get<std::string>("name");
+
+      std::string tag = prm.get<std::string>("tag");
+      if (tag == "")
+        {
+          tag = "subducting plate";
+        }
+      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
+
+      this->get_coordinates("coordinates", prm, coordinate_system);
+
+
+      starting_depth = prm.get<double>("min depth");
+      maximum_depth = prm.get<double>("max depth");
+
+      const size_t n_sections = this->original_number_of_coordinates;
+
+      reference_point = prm.get<Point<2> >("dip point");
+
+      if (coordinate_system == spherical)
+        {
+          // When spherical, input is in degrees, so change to radians for internal use.
+          reference_point *= (Consts::PI/180.);
+        }
+
+      default_temperature_models.resize(0);
+      default_composition_models.resize(0);
+      default_grains_models.resize(0);
+      prm.get_shared_pointers<Features::SubductingPlateModels::Temperature::Interface>("temperature models", default_temperature_models);
+      prm.get_shared_pointers<Features::SubductingPlateModels::Composition::Interface>("composition models", default_composition_models);
+      prm.get_shared_pointers<Features::SubductingPlateModels::Grains::Interface>("grains models", default_grains_models);
+
+      // get the default segments.
+      default_segment_vector = prm.get_vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
+      Features::SubductingPlateModels::Composition::Interface,
+      Features::SubductingPlateModels::Grains::Interface> >("segments", default_temperature_models, default_composition_models, default_grains_models);
+
+
+      // This vector stores segments to this coordinate/section.
+      //First used (raw) pointers to the segment relevant to this coordinate/section,
+      // but I do not trust it won't fail when memory is moved. So storing the all the data now.
+      segment_vector.resize(0);
+      segment_vector.resize(n_sections, default_segment_vector);
+
+
+      // now search whether a section is present, if so, replace the default segments.
+      std::vector<std::unique_ptr<Features::SubductingPlate> > sections_vector;
+      prm.get_unique_pointers("sections", sections_vector);
+
+      prm.enter_subsection("sections");
+      for (unsigned int i_section = 0; i_section < n_sections; ++i_section)
+        {
+          // first check whether this section/coordinate has a a special overwrite
+          for (unsigned int i_sector = 0; i_sector < sections_vector.size(); ++i_sector)
+            {
+              prm.enter_subsection(std::to_string(i_sector));
+              {
+                const unsigned int change_coord_number = prm.get<unsigned int>("coordinate");
+
+                WBAssertThrow(segment_vector.size() > change_coord_number, "Error: for subducting plate with name: '" << this->name
+                              << "', trying to change the section of coordinate " << change_coord_number
+                              << " while only " << segment_vector.size() << " coordinates are defined.");
+
+                std::vector<std::shared_ptr<Features::SubductingPlateModels::Temperature::Interface> > local_default_temperature_models;
+                std::vector<std::shared_ptr<Features::SubductingPlateModels::Composition::Interface>  > local_default_composition_models;
+                std::vector<std::shared_ptr<Features::SubductingPlateModels::Grains::Interface>  > local_default_grains_models;
+
+                if (!prm.get_shared_pointers<Features::SubductingPlateModels::Temperature::Interface>("temperature models", local_default_temperature_models))
+                  {
+                    // no local temperature model, use global default
+                    local_default_temperature_models = default_temperature_models;
+                  }
+
+                if (!prm.get_shared_pointers<Features::SubductingPlateModels::Composition::Interface>("composition models", local_default_composition_models))
+                  {
+                    // no local composition model, use global default
+                    local_default_composition_models = default_composition_models;
+                  }
+
+                if (!prm.get_shared_pointers<Features::SubductingPlateModels::Grains::Interface>("grains models", local_default_grains_models))
+                  {
+                    // no local composition model, use global default
+                    local_default_grains_models = default_grains_models;
+                  }
+
+                segment_vector[change_coord_number] = prm.get_vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
+                                                      Features::SubductingPlateModels::Composition::Interface,
+                                                      Features::SubductingPlateModels::Grains::Interface> >("segments", local_default_temperature_models, local_default_composition_models, local_default_grains_models);
+
+
+                WBAssertThrow(segment_vector[change_coord_number].size() == default_segment_vector.size(),
+                              "Error: There are not the same amount of segments in section with coordinate " << change_coord_number
+                              << " (" << segment_vector[change_coord_number].size() << " segments) as in the default segment ("
+                              << default_segment_vector.size() << " segments). This is not allowed.");
+
+                prm.enter_subsection("segments");
+                {
+                  for (unsigned int i = 0; i < segment_vector[change_coord_number].size(); ++i)
+                    {
+                      prm.enter_subsection(std::to_string(i));
+                      {
+                        prm.enter_subsection("temperature models");
+                        {
+                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].temperature_systems.size(); ++j)
+                            {
+                              prm.enter_subsection(std::to_string(j));
+                              {
+                                segment_vector[change_coord_number][i].temperature_systems[j]->parse_entries(prm);
+                              }
+                              prm.leave_subsection();
+                            }
+                        }
+                        prm.leave_subsection();
+
+
+                        prm.enter_subsection("composition models");
+                        {
+                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].composition_systems.size(); ++j)
+                            {
+                              prm.enter_subsection(std::to_string(j));
+                              {
+                                segment_vector[change_coord_number][i].composition_systems[j]->parse_entries(prm);
+                              }
+                              prm.leave_subsection();
+                            }
+                        }
+                        prm.leave_subsection();
+
+                        prm.enter_subsection("grains models");
+                        {
+                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].grains_systems.size(); ++j)
+                            {
+                              prm.enter_subsection(std::to_string(j));
+                              {
+                                segment_vector[change_coord_number][i].grains_systems[j]->parse_entries(prm);
+                              }
+                              prm.leave_subsection();
+                            }
+                        }
+                        prm.leave_subsection();
+                      }
+                      prm.leave_subsection();
+                    }
+                }
+                prm.leave_subsection();
+
+              }
+              prm.leave_subsection();
+            }
+
+        }
+      prm.leave_subsection();
+
+
+      prm.enter_subsection("segments");
+      {
+        for (unsigned int i = 0; i < default_segment_vector.size(); ++i)
+          {
+            prm.enter_subsection(std::to_string(i));
+            {
+              prm.enter_subsection("temperature models");
+              {
+                for (unsigned int j = 0; j < default_segment_vector[i].temperature_systems.size(); ++j)
+                  {
+                    prm.enter_subsection(std::to_string(j));
+                    {
+                      default_segment_vector[i].temperature_systems[j]->parse_entries(prm);
+                    }
+                    prm.leave_subsection();
+                  }
+              }
+              prm.leave_subsection();
+
+
+              prm.enter_subsection("composition models");
+              {
+                for (unsigned int j = 0; j < default_segment_vector[i].composition_systems.size(); ++j)
+                  {
+                    prm.enter_subsection(std::to_string(j));
+                    {
+                      default_segment_vector[i].composition_systems[j]->parse_entries(prm);
+                    }
+                    prm.leave_subsection();
+                  }
+              }
+              prm.leave_subsection();
+
+
+              prm.enter_subsection("grains models");
+              {
+                for (unsigned int j = 0; j < default_segment_vector[i].grains_systems.size(); ++j)
+                  {
+                    prm.enter_subsection(std::to_string(j));
+                    {
+                      default_segment_vector[i].grains_systems[j]->parse_entries(prm);
+                    }
+                    prm.leave_subsection();
+                  }
+              }
+              prm.leave_subsection();
+            }
+            prm.leave_subsection();
+          }
+      }
+      prm.leave_subsection();
+
+      maximum_slab_thickness = 0;
+      maximum_total_slab_length = 0;
+      total_slab_length.resize(original_number_of_coordinates);
+      slab_segment_lengths.resize(original_number_of_coordinates);
+      slab_segment_thickness.resize(original_number_of_coordinates);
+      slab_segment_top_truncation.resize(original_number_of_coordinates);
+      slab_segment_angles.resize(original_number_of_coordinates);
+
+      for (unsigned int i = 0; i < segment_vector.size(); ++i)
+        {
+          double local_total_slab_length = 0;
+          slab_segment_lengths[i].resize(segment_vector[i].size());
+          slab_segment_thickness[i].resize(segment_vector[i].size(), Point<2>(invalid));
+          slab_segment_top_truncation[i].resize(segment_vector[i].size(), Point<2>(invalid));
+          slab_segment_angles[i].resize(segment_vector[i].size(), Point<2>(invalid));
+          for (unsigned int j = 0; j < segment_vector[i].size(); ++j)
+            {
+              slab_segment_lengths[i][j] = segment_vector[i][j].value_length;
+              local_total_slab_length += segment_vector[i][j].value_length;
+
+              slab_segment_thickness[i][j] = segment_vector[i][j].value_thickness;
+              maximum_slab_thickness = std::max(maximum_slab_thickness, slab_segment_thickness[i][j][0]);
+              maximum_slab_thickness = std::max(maximum_slab_thickness, slab_segment_thickness[i][j][1]);
+              slab_segment_top_truncation[i][j] = segment_vector[i][j].value_top_truncation;
+
+              slab_segment_angles[i][j] = segment_vector[i][j].value_angle * (Consts::PI/180);
+            }
+          total_slab_length[i] = local_total_slab_length;
+          maximum_total_slab_length = std::max(maximum_total_slab_length, local_total_slab_length);
+        }
+
+      // Here, we compute the spherical bounding box using the two extreme points of the box containing all the surface
+      // coordinates and an additional buffer zone that accounts for the slab thickness and length. The first and second
+      // points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
+      // documentation in include/bounding_box.h).
+      // For the spherical system, the buffer zone along the longitudal direction is calculated using the
+      // corresponding latitude points.
+
+      // Find minimal and maximal coordinates. Do this by finding the
+      // leftmost/rightmost point with regard to either the [0] or [1]
+      // coordinate, and then takes its [0] or [1] element.
+      auto compare_x_coordinate = [](auto p1, auto p2)
+      {
+        return p1[0]<p2[0];
+      };
+
+      min_along_x = (*std::min_element(coordinates.begin(), coordinates.end(), compare_x_coordinate)) [0];
+      max_along_x = (*std::max_element(coordinates.begin(), coordinates.end(), compare_x_coordinate)) [0];
+
+
+      auto compare_y_coordinate = [](auto p1, auto p2)
+      {
+        return p1[1]<p2[1];
+      };
+
+      min_along_y = (*std::min_element(coordinates.begin(), coordinates.end(), compare_y_coordinate)) [1];
+      max_along_y = (*std::max_element(coordinates.begin(), coordinates.end(), compare_y_coordinate)) [1];
+
+      min_lat_cos_inv = 1. / std::cos(min_along_y);
+      max_lat_cos_inv = 1. / std::cos(max_along_y);
+
+      buffer_around_slab_cartesian = (maximum_slab_thickness + maximum_total_slab_length);
+
+      // Compute the surface bounding box
+      buffer_around_slab_cartesian = (maximum_slab_thickness + maximum_total_slab_length);
+      if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical)
+        {
+          const double starting_radius_inv = 1 / (world->parameters.coordinate_system->max_model_depth());
+          std::pair<Point<2>, Point<2> > &spherical_bounding_box = surface_bounding_box.get_boundary_points();
+
+          const double buffer_around_slab_spherical = 2 * Consts::PI * buffer_around_slab_cartesian * starting_radius_inv;
+
+          spherical_bounding_box.first = {(min_along_x - buffer_around_slab_spherical * min_lat_cos_inv) ,
+                                          (min_along_y - buffer_around_slab_spherical), spherical
+                                         } ;
+
+          spherical_bounding_box.second = {(max_along_x + buffer_around_slab_spherical * max_lat_cos_inv) ,
+                                           (max_along_y + buffer_around_slab_spherical), spherical
+                                          };
+        }
+      else if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::cartesian)
+        {
+          std::pair<Point<2>, Point<2> > &bounding_box = surface_bounding_box.get_boundary_points();
+          bounding_box.first = {min_along_x, min_along_y, cartesian};
+          bounding_box.second = {max_along_x, max_along_y, cartesian};
+          surface_bounding_box.extend(buffer_around_slab_cartesian);
+        }
+    }
+
+
+
+    const BoundingBox<2> &
+    SubductingPlate::get_surface_bounding_box () const
+    {
+      return surface_bounding_box;
+    }
+
+
+    void
+    SubductingPlate::properties(const Point<3> &position_in_cartesian_coordinates,
+                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                const double depth,
+                                const std::vector<std::array<unsigned int,3>> &properties,
+                                const double gravity_norm,
+                                const std::vector<size_t> &entry_in_output,
+                                std::vector<double> &output) const
+    {
+      // The depth variable is the distance from the surface to the position, the depth
+      // coordinate is the distance from the bottom of the model to the position and
+      // the starting radius is the distance from the bottom of the model to the surface.
+      const double starting_radius = position_in_natural_coordinates.get_depth_coordinate() + depth - starting_depth;
+
+      WBAssert(std::abs(starting_radius) > std::numeric_limits<double>::epsilon(), "World Builder error: starting_radius can not be zero. "
+               << "Position = " << position_in_cartesian_coordinates[0] << ':' << position_in_cartesian_coordinates[1] << ':' << position_in_cartesian_coordinates[2]
+               << ", position_in_natural_coordinates.get_depth_coordinate() = " << position_in_natural_coordinates.get_depth_coordinate()
+               << ", depth = " << depth
+               << ", starting_depth " << starting_depth
+              );
+
+      // todo: explain and check -starting_depth
+      if (depth <= maximum_depth && depth >= starting_depth && depth <= maximum_total_slab_length + maximum_slab_thickness &&
+          get_surface_bounding_box().point_inside(Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
+                                                           world->parameters.coordinate_system->natural_coordinate_system())))
+        {
+          /*WBAssert(coordinates.size() == slab_segment_lengths.size(),
+                   "Internal error: The size of coordinates (" << coordinates.size()
+                   << ") and slab_segment_lengths (" << slab_segment_lengths.size() << ") are different.");
+          WBAssert(coordinates.size() == slab_segment_angles.size(),
+                   "Internal error: The size of coordinates (" << coordinates.size()
+                   << ") and slab_segment_angles (" << slab_segment_angles.size() << ") are different.");
+          WBAssert(coordinates.size() == slab_segment_angles.size(),
+                   "Internal error: The size of coordinates (" << coordinates.size()
+                   << ") and one_dimensional_coordinates (" << one_dimensional_coordinates.size() << ") are different.");*/
+          // todo: explain
+          const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
+            WorldBuilder::Utilities::distance_point_from_curved_planes(position_in_cartesian_coordinates,
+                                                                       position_in_natural_coordinates,
+                                                                       reference_point,
+                                                                       coordinates,
+                                                                       slab_segment_lengths,
+                                                                       slab_segment_angles,
+                                                                       starting_radius,
+                                                                       this->world->parameters.coordinate_system,
+                                                                       false,
+                                                                       this->bezier_curve);
+
+          const double distance_from_plane = distance_from_planes.distance_from_plane;
+          const double distance_along_plane = distance_from_planes.distance_along_plane;
+          const double section_fraction = distance_from_planes.fraction_of_section;
+          const size_t current_section = distance_from_planes.section;
+          const size_t next_section = current_section + 1;
+          const size_t current_segment = distance_from_planes.segment; // the original value was a unsigned in, converting it back.
+          //const size_t next_segment = current_segment + 1;
+          const double segment_fraction = distance_from_planes.fraction_of_segment;
+
+          if (abs(distance_from_plane) < std::numeric_limits<double>::infinity() || (distance_along_plane) < std::numeric_limits<double>::infinity())
+            {
+              // We want to do both section (horizontal) and segment (vertical) interpolation.
+              // first for thickness
+              const double thickness_up = slab_segment_thickness[current_section][current_segment][0]
+                                          + section_fraction
+                                          * (slab_segment_thickness[next_section][current_segment][0]
+                                             - slab_segment_thickness[current_section][current_segment][0]);
+              const double thickness_down = slab_segment_thickness[current_section][current_segment][1]
+                                            + section_fraction
+                                            * (slab_segment_thickness[next_section][current_segment][1]
+                                               - slab_segment_thickness[current_section][current_segment][1]);
+              const double thickness_local = thickness_up + segment_fraction * (thickness_down - thickness_up);
+
+              // if the thickness is zero, we don't need to compute anything, so return.
+              if (std::fabs(thickness_local) < 2.0 * std::numeric_limits<double>::epsilon())
+                return;
+
+              // secondly for top truncation
+              const double top_truncation_up = slab_segment_top_truncation[current_section][current_segment][0]
+                                               + section_fraction
+                                               * (slab_segment_top_truncation[next_section][current_segment][0]
+                                                  - slab_segment_top_truncation[current_section][current_segment][0]);
+              const double top_truncation_down = slab_segment_top_truncation[current_section][current_segment][1]
+                                                 + section_fraction
+                                                 * (slab_segment_top_truncation[next_section][current_segment][1]
+                                                    - slab_segment_top_truncation[current_section][current_segment][1]);
+              const double top_truncation_local = top_truncation_up + segment_fraction * (top_truncation_down - top_truncation_up);
+
+              // if the thickness is smaller than what is truncated off at the top, we don't need to compute anything, so return.
+              if (thickness_local < top_truncation_local)
+                return;
+
+              const double max_slab_length = total_slab_length[current_section] +
+                                             section_fraction *
+                                             (total_slab_length[next_section] - total_slab_length[current_section]);
+
+              if (distance_from_plane >= top_truncation_local &&
+                  distance_from_plane <= thickness_local &&
+                  distance_along_plane >= 0 &&
+                  distance_along_plane <= max_slab_length)
+                {
+                  // Inside the slab!
+                  const Features::AdditionalParameters additional_parameters = {max_slab_length,thickness_local};
+                  for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
+                    {
+                      switch (properties[i_property][0])
+                        {
+                          case 1: // temperature
+                          {
+                            double temperature_current_section = output[entry_in_output[i_property]];
+                            double temperature_next_section = output[entry_in_output[i_property]];
+
+                            for (const auto &temperature_model: segment_vector[current_section][current_segment].temperature_systems)
+                              {
+                                temperature_current_section = temperature_model->get_temperature(position_in_cartesian_coordinates,
+                                                                                                 depth,
+                                                                                                 gravity_norm,
+                                                                                                 temperature_current_section,
+                                                                                                 starting_depth,
+                                                                                                 maximum_depth,
+                                                                                                 distance_from_planes,
+                                                                                                 additional_parameters);
+
+                                WBAssert(!std::isnan(temperature_current_section), "Temperature is not a number: " << temperature_current_section
+                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+                                WBAssert(std::isfinite(temperature_current_section), "Temperature is not a finite: " << temperature_current_section
+                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+
+                              }
+
+                            for (const auto &temperature_model: segment_vector[next_section][current_segment].temperature_systems)
+                              {
+                                temperature_next_section = temperature_model->get_temperature(position_in_cartesian_coordinates,
+                                                                                              depth,
+                                                                                              gravity_norm,
+                                                                                              temperature_next_section,
+                                                                                              starting_depth,
+                                                                                              maximum_depth,
+                                                                                              distance_from_planes,
+                                                                                              additional_parameters);
+
+                                WBAssert(!std::isnan(temperature_next_section), "Temperature is not a number: " << temperature_next_section
+                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+                                WBAssert(std::isfinite(temperature_next_section), "Temperature is not a finite: " << temperature_next_section
+                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
+
+                              }
+
+                            // linear interpolation between current and next section temperatures
+                            output[entry_in_output[i_property]] = temperature_current_section + section_fraction * (temperature_next_section - temperature_current_section);
+                            break;
+                          }
+                          case 2: // composition
+                          {
+                            double composition_current_section = output[entry_in_output[i_property]];
+                            double composition_next_section = output[entry_in_output[i_property]];
+
+                            for (const auto &composition_model: segment_vector[current_section][current_segment].composition_systems)
+                              {
+                                composition_current_section = composition_model->get_composition(position_in_cartesian_coordinates,
+                                                                                                 depth,
+                                                                                                 properties[i_property][1],
+                                                                                                 composition_current_section,
+                                                                                                 starting_depth,
+                                                                                                 maximum_depth,
+                                                                                                 distance_from_planes,
+                                                                                                 additional_parameters);
+
+                                WBAssert(!std::isnan(composition_current_section), "Composition_current_section is not a number: " << composition_current_section
+                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+                                WBAssert(std::isfinite(composition_current_section), "Composition_current_section is not a finite: " << composition_current_section
+                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+
+                              }
+
+                            for (const auto &composition_model: segment_vector[next_section][current_segment].composition_systems)
+                              {
+                                composition_next_section = composition_model->get_composition(position_in_cartesian_coordinates,
+                                                                                              depth,
+                                                                                              properties[i_property][1],
+                                                                                              composition_next_section,
+                                                                                              starting_depth,
+                                                                                              maximum_depth,
+                                                                                              distance_from_planes,
+                                                                                              additional_parameters);
+
+                                WBAssert(!std::isnan(composition_next_section), "Composition_next_section is not a number: " << composition_next_section
+                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+                                WBAssert(std::isfinite(composition_next_section), "Composition_next_section is not a finite: " << composition_next_section
+                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
+
+                              }
+
+                            // linear interpolation between current and next section temperatures
+                            output[entry_in_output[i_property]] = composition_current_section + section_fraction * (composition_next_section - composition_current_section);
+                            break;
+                          }
+                          case 3: // grains
+                          {
+                            WorldBuilder::grains grains(output,properties[i_property][2],entry_in_output[i_property]);
+                            WorldBuilder::grains  grains_current_section = grains;
+                            WorldBuilder::grains  grains_next_section = grains;
+
+                            for (const auto &grains_model: segment_vector[current_section][current_segment].grains_systems)
+                              {
+                                grains_current_section = grains_model->get_grains(position_in_cartesian_coordinates,
+                                                                                  depth,
+                                                                                  properties[i_property][1],
+                                                                                  grains_current_section,
+                                                                                  starting_depth,
+                                                                                  maximum_depth,
+                                                                                  distance_from_planes,
+                                                                                  additional_parameters);
+
+                              }
+
+                            for (const auto &grains_model: segment_vector[next_section][current_segment].grains_systems)
+                              {
+                                grains_next_section = grains_model->get_grains(position_in_cartesian_coordinates,
+                                                                               depth,
+                                                                               properties[i_property][1],
+                                                                               grains_next_section,
+                                                                               starting_depth,
+                                                                               maximum_depth,
+                                                                               distance_from_planes,
+                                                                               additional_parameters);
+
+                              }
+
+                            // linear interpolation between current and next section temperatures
+                            for (size_t i = 0; i < grains.sizes.size(); i++)
+                              {
+                                grains.sizes[i] = grains_current_section.sizes[i] + section_fraction * (grains_next_section.sizes[i] - grains_current_section.sizes[i]);
+                              }
+
+                            // average two rotations matrices throu quaternions.
+                            for (size_t i = 0; i < grains_current_section.rotation_matrices.size(); i++)
+                              {
+                                const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(grains_current_section.rotation_matrices[i]);
+                                const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(grains_next_section.rotation_matrices[i]);
+
+                                const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,section_fraction);
+
+                                grains.rotation_matrices[i] = glm::quaternion::mat3_cast(quat_average);
+                              }
+
+                            grains.unroll_into(output,entry_in_output[i_property]);
+                            break;
+                          }
+                          case 4:
+                          {
+                            output[entry_in_output[i_property]] = static_cast<double>(tag_index);
+                            break;
+                          }
+                          default:
+                          {
+                            WBAssertThrow(false,
+                                          "Internal error: Unimplemented property provided. " <<
+                                          "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
+                                          "Provided property number was: " << properties[i_property][0]);
+                          }
+                        }
+                    }
+
+                }
+            }
+        }
+
+    }
+
+    Objects::PlaneDistances
+    SubductingPlate::distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
+                                               const Objects::NaturalCoordinate &position_in_natural_coordinates,
+                                               const double depth) const
+    {
+      // The depth variable is the distance from the surface to the position, the depth
+      // coordinate is the distance from the bottom of the model to the position and
+      // the starting radius is the distance from the bottom of the model to the surface.
+      const double starting_radius = position_in_natural_coordinates.get_depth_coordinate() + depth - starting_depth;
+
+      WBAssert(std::abs(starting_radius) > std::numeric_limits<double>::epsilon(), "World Builder error: starting_radius can not be zero. "
+               << "Position = " << position_in_cartesian_coordinates[0] << ':' << position_in_cartesian_coordinates[1] << ':' << position_in_cartesian_coordinates[2]
+               << ", natural_coordinate.get_depth_coordinate() = " << position_in_natural_coordinates.get_depth_coordinate()
+               << ", depth = " << depth
+               << ", starting_depth " << starting_depth
+              );
+
+      const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
+        WorldBuilder::Utilities::distance_point_from_curved_planes(position_in_cartesian_coordinates,
+                                                                   position_in_natural_coordinates,
+                                                                   reference_point,
+                                                                   coordinates,
+                                                                   slab_segment_lengths,
+                                                                   slab_segment_angles,
+                                                                   starting_radius,
+                                                                   this->world->parameters.coordinate_system,
+                                                                   false,
+                                                                   this->bezier_curve);
+
+      Objects::PlaneDistances plane_distances(distance_from_planes.distance_from_plane, distance_from_planes.distance_along_plane);
+      return plane_distances;
+    }
+
+    /**
+     * Register plugin
+     */
+    WB_REGISTER_FEATURE(SubductingPlate, subducting plate)
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/interface.cc.bak
new file mode 100644
index 00000000000..8690913524e
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/interface.cc.bak
@@ -0,0 +1,82 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/composition/interface.h"
+
+#include <algorithm>
+
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Composition
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Composition
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/smooth.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/smooth.cc.bak
new file mode 100644
index 00000000000..6501fca135a
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/smooth.cc.bak
@@ -0,0 +1,131 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/composition/smooth.h"
+
+#include <world_builder/assert.h>
+#include <world_builder/nan.h>
+#include <world_builder/parameters.h>
+#include <world_builder/utilities.h>
+
+#include <world_builder/types/array.h>
+#include <world_builder/types/double.h>
+#include <world_builder/types/object.h>
+#include <world_builder/types/string.h>
+#include <world_builder/types/unsigned_int.h>
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Composition
+      {
+        Smooth::Smooth(WorldBuilder::World *world_)
+          :
+          min_distance(NaN::DSNAN),
+          side_distance(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "smooth";
+        }
+
+        Smooth::~Smooth()
+          = default;
+
+        void
+        Smooth::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}), "Compositional model object");
+
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "The distance in meters from which the composition of this layer is present.");
+          prm.declare_entry("max distance slab top", Types::Double(0),
+                            "The distance in meters from which the composition of this layer is present.");
+          prm.declare_entry("top fractions",  Types::Array(Types::Double(1.0),1),
+                            "The composition fraction at the top of the slab (layer).");
+          prm.declare_entry("bottom fractions",  Types::Array(Types::Double(0.0),1),
+                            "The composition fraction at the bottom of the slab (layer).");
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the labels of the composition which are present there.");
+          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value. Replacing implies that all compositions not "
+                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
+        }
+
+        void
+        Smooth::parse_entries(Parameters &prm)
+        {
+          min_distance = prm.get<double>("min distance slab top");
+          max_distance = prm.get<double>("max distance slab top");
+          side_distance = std::abs(max_distance-min_distance);
+          //WBAssert(side_distance >= min_distance, "distance at the side needs to be larger or equal than the min distance.");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          top_fraction = prm.get_vector<double>("top fractions");
+          bottom_fraction = prm.get_vector<double>("bottom fractions");
+          compositions = prm.get_vector<unsigned int>("compositions");
+        }
+
+
+        double
+        Smooth::get_composition( const Point<3> & /*position*/,
+                                 const double  /*depth*/,
+                                 const unsigned int composition_number,
+                                 double composition_,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/,
+                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                 const AdditionalParameters & /*additional_parameters*/) const
+        {
+          double composition = composition_;
+          if (distance_from_planes.distance_from_plane <= max_distance && distance_from_planes.distance_from_plane >= min_distance)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+
+                      // Hyperbolic tangent goes from 0 to 1 over approximately x=(0, 2) without any arguments. The function is written
+                      // so that the composition returned 1 to 0 over the side_distance on either sides.
+                      const double scaling = ( 1 - std::tanh(10 * (distance_from_planes.distance_from_plane-side_distance/2.0-min_distance)/side_distance ) )/2.0;
+                      composition = top_fraction[i]*scaling + bottom_fraction[i] * (1-scaling);
+
+                      return apply_operation(operation,composition_,composition);
+                    }
+                }
+
+              if (operation == Operations::REPLACE)
+                return 0.0;
+            }
+          return composition;
+        }
+
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_COMPOSITION_MODEL (Smooth, smooth)
+      } // namespace Composition
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/uniform.cc.bak
new file mode 100644
index 00000000000..9d7ae9627d1
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/uniform.cc.bak
@@ -0,0 +1,123 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/composition/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Composition
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform compositional model. Sets constant compositional field.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "todo The depth in meters from which the composition of this feature is present.");
+          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
+                            "todo The depth in meters to which the composition of this feature is present.");
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the labels of the composition which are present there.");
+          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
+                            "TA list of compositional fractions corresponding to the compositions list.");
+          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value. Replacing implies that all compositions not "
+                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance slab top");
+          max_depth = prm.get<double>("max distance slab top");
+          compositions = prm.get_vector<unsigned int>("compositions");
+          fractions = prm.get_vector<double>("fractions");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          WBAssertThrow(compositions.size() == fractions.size(),
+                        "There are not the same amount of compositions and fractions.");
+        }
+
+
+        double
+        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const double /*depth*/,
+                                 const unsigned int composition_number,
+                                 double composition,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/,
+                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
+                                 const AdditionalParameters & /*additional_parameters*/) const
+        {
+          if (distance_from_plane.distance_from_plane <= max_depth && distance_from_plane.distance_from_plane >= min_depth)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      return apply_operation(operation,composition,fractions[i]);
+                    }
+                }
+
+              if (operation == Operations::REPLACE)
+                return 0.0;
+            }
+          return composition;
+        }
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_COMPOSITION_MODEL(Uniform, uniform)
+      } // namespace Composition
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/interface.cc.bak
new file mode 100644
index 00000000000..50faddd23af
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/interface.cc.bak
@@ -0,0 +1,111 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/grains/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/object.h"
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Grains
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          unsigned int counter = 0;
+          for (auto &it : get_declare_map())
+            {
+              // prevent infinite recursion
+              if (it.first != parent_name)
+                {
+                  prm.enter_subsection("oneOf");
+                  {
+                    prm.enter_subsection(std::to_string(counter));
+                    {
+                      prm.enter_subsection("properties");
+                      {
+                        prm.declare_entry("", Types::Object(required_entries), "grains object");
+
+                        prm.declare_entry("model", Types::String("",it.first),
+                                          "The name of the grains model.");
+
+                        it.second(prm, parent_name);
+                      }
+                      prm.leave_subsection();
+                    }
+                    prm.leave_subsection();
+                  }
+                  prm.leave_subsection();
+
+                  counter++;
+
+                }
+            }
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Grains
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.cc.bak
new file mode 100644
index 00000000000..4317a90579d
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.cc.bak
@@ -0,0 +1,217 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution";
+        }
+
+        RandomUniformDistribution::~RandomUniformDistribution()
+          = default;
+
+        void
+        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "The distance from the slab top in meters from which the composition of this feature is present.");
+          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance from the slab top in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistribution::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance slab top");
+          max_depth = prm.get<double>("max distance slab top");
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                              const double /*depth*/,
+                                              const unsigned int composition_number,
+                                              WorldBuilder::grains grains_,
+                                              const double /*feature_min_depth*/,
+                                              const double /*feature_max_depth*/,
+                                              const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                              const AdditionalParameters & /*additional_parameters*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (distance_from_planes.distance_from_plane <= max_depth && distance_from_planes.distance_from_plane >= min_depth)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      std::uniform_real_distribution<> dist(0.0,1.0);
+                      for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                        {
+                          // set a uniform random a_cosine_matrix per grain
+                          // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                          // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                          // and is licenend accourding to this website with the following licence:
+                          //
+                          // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                          // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                          // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                          // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                          // don't be a jerk, and remember that anything free comes with no guarantee.""
+                          //
+                          // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                          // the public domain, and is yours to study, modify, and use."
+
+                          // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                          const double one = dist(world->get_random_number_engine());
+                          const double two = dist(world->get_random_number_engine());
+                          const double three = dist(world->get_random_number_engine());
+
+                          const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
+                          const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                          const double z = 2.0* three; //For magnitude of pole deflection.
+
+                          // Compute a vector V used for distributing points over the sphere
+                          // via the reflection I - V Transpose(V).  This formulation of V
+                          // will guarantee that if x[1] and x[2] are uniformly distributed,
+                          // the reflected points will be uniform on the sphere.  Note that V
+                          // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                          const double r  = std::sqrt( z );
+                          const double Vx = std::sin( phi ) * r;
+                          const double Vy = std::cos( phi ) * r;
+                          const double Vz = std::sqrt( 2.F - z );
+
+                          // Compute the row vector S = Transpose(V) * R, where R is a simple
+                          // rotation by theta about the z-axis.  No need to compute Sz since
+                          // it's just Vz.
+
+                          const double st = std::sin( theta );
+                          const double ct = std::cos( theta );
+                          const double Sx = Vx * ct - Vy * st;
+                          const double Sy = Vx * st + Vy * ct;
+
+                          // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                          // is equivalent to V S - R.
+
+                          it_rotation_matrices[0][0] = Vx * Sx - ct;
+                          it_rotation_matrices[0][1] = Vx * Sy - st;
+                          it_rotation_matrices[0][2] = Vx * Vz;
+
+                          it_rotation_matrices[1][0] = Vy * Sx + st;
+                          it_rotation_matrices[1][1] = Vy * Sy - ct;
+                          it_rotation_matrices[1][2] = Vy * Vz;
+
+                          it_rotation_matrices[2][0] = Vz * Sx;
+                          it_rotation_matrices[2][1] = Vz * Sy;
+                          it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                        }
+
+                      double total_size = 0;
+                      for (auto &&it_sizes : grains_local.sizes)
+                        {
+                          it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                          total_size += it_sizes;
+                        }
+
+                      if (normalize_grain_sizes[i])
+                        {
+                          const double one_over_total_size = 1/total_size;
+                          std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                         [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                        }
+
+                      return grains_local;
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
+      } // namespace Grains
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.cc.bak
new file mode 100644
index 00000000000..bf9ac3a3e05
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.cc.bak
@@ -0,0 +1,223 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h"
+
+#include <algorithm>
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Grains
+      {
+        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "random uniform distribution deflected";
+        }
+
+        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
+          = default;
+
+        void
+        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions to the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Random uniform distribution grains model. The size of the grains can be independently set "
+                            "to a single value or to a random distribution.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "The distance from the slab top in meters from which the composition of this feature is present.");
+          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance from the slab top in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
+
+          prm.declare_entry("normalize grain sizes",
+                            Types::Array(Types::Bool(true),0),
+                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
+
+          prm.declare_entry("deflections",
+                            Types::Array(Types::Double(1),0),
+                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
+
+
+
+        }
+
+        void
+        RandomUniformDistributionDeflected::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance slab top");
+          max_depth = prm.get<double>("max distance slab top");
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
+          deflections = prm.get_vector<double>("deflections");
+
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
+          WBAssertThrow(compositions.size() == deflections.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and deflections (" << deflections.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                                       const double /*depth*/,
+                                                       const unsigned int composition_number,
+                                                       WorldBuilder::grains grains_,
+                                                       const double /*feature_min_depth*/,
+                                                       const double /*feature_max_depth*/,
+                                                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                                       const AdditionalParameters & /*additional_parameters*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (distance_from_planes.distance_from_plane <= max_depth && distance_from_planes.distance_from_plane >= min_depth)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      std::uniform_real_distribution<> dist(0.0,1.0);
+                      for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
+                        {
+                          // set a uniform random a_cosine_matrix per grain
+                          // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+                          // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+                          // and is licenend accourding to this website with the following licence:
+                          //
+                          // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+                          // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+                          // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+                          // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+                          // don't be a jerk, and remember that anything free comes with no guarantee.""
+                          //
+                          // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+                          // the public domain, and is yours to study, modify, and use."
+
+                          // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+                          const double one = dist(world->get_random_number_engine());
+                          const double two = dist(world->get_random_number_engine());
+                          const double three = dist(world->get_random_number_engine());
+
+                          const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z)
+                          const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
+                          const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
+
+                          // Compute a vector V used for distributing points over the sphere
+                          // via the reflection I - V Transpose(V).  This formulation of V
+                          // will guarantee that if x[1] and x[2] are uniformly distributed,
+                          // the reflected points will be uniform on the sphere.  Note that V
+                          // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+                          const double r  = std::sqrt( z );
+                          const double Vx = std::sin( phi ) * r;
+                          const double Vy = std::cos( phi ) * r;
+                          const double Vz = std::sqrt( 2.F - z );
+
+                          // Compute the row vector S = Transpose(V) * R, where R is a simple
+                          // rotation by theta about the z-axis.  No need to compute Sz since
+                          // it's just Vz.
+
+                          const double st = std::sin( theta );
+                          const double ct = std::cos( theta );
+                          const double Sx = Vx * ct - Vy * st;
+                          const double Sy = Vx * st + Vy * ct;
+
+                          // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+                          // is equivalent to V S - R.
+
+                          it_rotation_matrices[0][0] = Vx * Sx - ct;
+                          it_rotation_matrices[0][1] = Vx * Sy - st;
+                          it_rotation_matrices[0][2] = Vx * Vz;
+
+                          it_rotation_matrices[1][0] = Vy * Sx + st;
+                          it_rotation_matrices[1][1] = Vy * Sy - ct;
+                          it_rotation_matrices[1][2] = Vy * Vz;
+
+                          it_rotation_matrices[2][0] = Vz * Sx;
+                          it_rotation_matrices[2][1] = Vz * Sy;
+                          it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+                        }
+
+                      double total_size = 0;
+                      for (auto &&it_sizes : grains_local.sizes)
+                        {
+                          it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
+                          total_size += it_sizes;
+                        }
+
+                      if (normalize_grain_sizes[i])
+                        {
+                          const double one_over_total_size = 1/total_size;
+                          std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
+                                         [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
+                        }
+
+                      return grains_local;
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
+      } // namespace Grains
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/uniform.cc.bak
new file mode 100644
index 00000000000..672dac7948b
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/uniform.cc.bak
@@ -0,0 +1,169 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/grains/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Grains
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN)
+
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add compositions the required parameters.
+          prm.declare_entry("", Types::Object({"compositions"}),
+                            "Uniform grains model. All grains start exactly the same.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "The distance from the slab top in meters from which the composition of this feature is present.");
+          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance from the slab top in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
+                            "A list with the integer labels of the composition which are present there.");
+
+          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
+                            "A list with the labels of the grains which are present there for each compositions.");
+
+          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
+                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
+
+          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
+                            "Whether the value should replace any value previously defined at this location (replace) or "
+                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
+                            "explicitly defined are set to zero.");
+
+          prm.declare_entry("grain sizes",
+                            Types::Array(Types::Double(-1),0),
+                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
+
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance slab top");
+          max_depth = prm.get<double>("max distance slab top");
+          compositions = prm.get_vector<unsigned int>("compositions");
+
+          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
+          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
+
+          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
+                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
+
+
+          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
+                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
+
+          if (set_euler_angles)
+            {
+              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
+              rotation_matrices.resize(euler_angles_vector.size());
+              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
+                {
+                  rotation_matrices[i] = WorldBuilder::Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
+                }
+
+            }
+          else
+            {
+              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
+            }
+
+          operation = prm.get<std::string>("orientation operation");
+          grain_sizes = prm.get_vector<double>("grain sizes");
+
+
+          WBAssertThrow(compositions.size() == rotation_matrices.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
+          WBAssertThrow(compositions.size() == grain_sizes.size(),
+                        "There are not the same amount of compositions (" << compositions.size()
+                        << ") and grain_sizes (" << grain_sizes.size() << ").");
+        }
+
+
+        WorldBuilder::grains
+        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
+                            const double /*depth*/,
+                            const unsigned int composition_number,
+                            WorldBuilder::grains grains_,
+                            const double /*feature_min_depth*/,
+                            const double /*feature_max_depth*/,
+                            const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                            const AdditionalParameters & /*additional_parameters*/) const
+        {
+          WorldBuilder::grains  grains_local = grains_;
+          if (distance_from_planes.distance_from_plane <= max_depth && distance_from_planes.distance_from_plane >= min_depth)
+            {
+              for (unsigned int i =0; i < compositions.size(); ++i)
+                {
+                  if (compositions[i] == composition_number)
+                    {
+                      std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
+
+                      const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
+                      std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
+
+                      return grains_local;
+                    }
+                }
+            }
+          return grains_local;
+        }
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_GRAINS_MODEL(Uniform, uniform)
+      } // namespace Grains
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/adiabatic.cc.bak
new file mode 100644
index 00000000000..4bed92202a4
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/adiabatic.cc.bak
@@ -0,0 +1,166 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/temperature/adiabatic.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        Adiabatic::Adiabatic(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          potential_mantle_temperature(NaN::DSNAN),
+          thermal_expansion_coefficient(NaN::DSNAN),
+          specific_heat(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "adiabatic";
+        }
+
+        Adiabatic::~Adiabatic()
+          = default;
+
+        void
+        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          prm.declare_entry("", Types::Object(),
+                            "Adiabatic temperature model. Uses global values by default.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "todo The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
+                            "todo The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("potential mantle temperature", Types::Double(-1),
+                            "The potential temperature of the mantle at the surface in Kelvin. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
+                            "The thermal expansion coefficient in $K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+          prm.declare_entry("specific heat", Types::Double(-1),
+                            "The specific heat in $J kg^{-1} K^{-1}$. "
+                            "If the value is lower then zero, the global value is used.");
+
+        }
+
+        void
+        Adiabatic::parse_entries(Parameters &prm)
+        {
+
+          min_depth = prm.get<double>("min distance slab top");
+          max_depth = prm.get<double>("max distance slab top");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
+          if (potential_mantle_temperature < 0)
+            potential_mantle_temperature =  this->world->potential_mantle_temperature;
+
+
+          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
+          if (thermal_expansion_coefficient < 0)
+            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
+
+          specific_heat = prm.get<double>("specific heat");
+          if (specific_heat < 0)
+            specific_heat =  this->world->specific_heat;
+
+          // Some assertions in debug mode can't hurt and have helped before.
+          WBAssert(!std::isnan(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
+          WBAssert(std::isfinite(potential_mantle_temperature),
+                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
+
+          WBAssert(!std::isnan(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
+
+          WBAssert(!std::isnan(specific_heat),
+                   "specific_heat is not a number: " << specific_heat << '.');
+          WBAssert(std::isfinite(thermal_expansion_coefficient),
+                   "specific_heat is not a finite: " << specific_heat << '.');
+
+        }
+
+
+        double
+        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                   const double depth,
+                                   const double gravity_norm,
+                                   double temperature_,
+                                   const double  /*feature_min_depth*/,
+                                   const double  /*feature_max_depth*/,
+                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                   const AdditionalParameters & /*additional_parameters*/) const
+        {
+
+          const double distance_from_plane = distance_from_planes.distance_from_plane;
+          if (distance_from_plane <= max_depth && distance_from_plane >= min_depth)
+            {
+              const double adabatic_temperature = potential_mantle_temperature *
+                                                  std::exp(((thermal_expansion_coefficient * gravity_norm) /
+                                                            specific_heat) * depth);
+
+
+              WBAssert(!std::isnan(adabatic_temperature),
+                       "adabatic_temperature is not a number: " << adabatic_temperature << ". "
+                       <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
+                       <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
+                       << ", gravity_norm = " << gravity_norm
+                       << ", specific_heat = " << specific_heat
+                       << ", depth = " << depth);
+
+              WBAssert(std::isfinite(adabatic_temperature),
+                       "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
+
+              return apply_operation(operation,temperature_,adabatic_temperature);
+            }
+
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(Adiabatic, adiabatic)
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/interface.cc.bak
new file mode 100644
index 00000000000..ada29a76574
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/interface.cc.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/temperature/interface.h"
+
+#include <algorithm>
+
+#include "world_builder/types/string.h"
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        Interface::Interface()
+          = default;
+
+        Interface::~Interface ()
+          = default;
+
+        void
+        Interface::declare_entries(Parameters &prm,
+                                   const std::string &parent_name,
+                                   const std::vector<std::string> &required_entries)
+        {
+          // The type needs to be stored in a separate value, otherwise there are memory issues
+          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
+
+          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
+          {
+            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
+            {
+              "operation", type,
+              "Whether the value should replace any value previously defined at this location (replace), "
+              "add the value to the previously define value (add) or subtract the value to the previously "
+              "define value (subtract)."
+            }
+          });
+        }
+
+
+        void
+        Interface::registerType(const std::string &name,
+                                void ( *declare_entries)(Parameters &, const std::string &),
+                                ObjectFactory *factory)
+        {
+          get_factory_map()[name] = factory;
+          get_declare_map()[name] = declare_entries;
+        }
+
+        std::unique_ptr<Interface>
+        Interface::create(const std::string &name, WorldBuilder::World *world)
+        {
+          std::string lower_case_name;
+          std::transform(name.begin(),
+                         name.end(),
+                         std::back_inserter(lower_case_name),
+                         ::tolower);;
+
+          // Have a nice assert message to check whether a plugin exists in the case
+          // of a debug compilation.
+          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                        "The size of factories is " << get_factory_map().size() << '.');
+
+          // Using at() because the [] will just insert values
+          // which is undesirable in this case. An exception is
+          // thrown when the name is not present.
+          return get_factory_map().at(lower_case_name)->create(world);
+        }
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/linear.cc.bak
new file mode 100644
index 00000000000..e4c6a70dce8
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/linear.cc.bak
@@ -0,0 +1,138 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/temperature/linear.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        Linear::Linear(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          top_temperature(NaN::DSNAN),
+          bottom_temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "linear";
+        }
+
+        Linear::~Linear()
+          = default;
+
+        void
+        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `max distance slab top` center to the required parameters.
+          prm.declare_entry("", Types::Object({"max distance slab top"}),
+                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "todo The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
+                            "todo The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("top temperature", Types::Double(293.15),
+                            "The temperature at the top in degree Kelvin of this feature."
+                            "If the value is below zero, the an adiabatic temperature is used.");
+
+          prm.declare_entry("bottom temperature", Types::Double(-1),
+                            "The temperature at the bottom in degree Kelvin of this feature. "
+                            "If the value is below zero, an adiabatic temperature is used.");
+        }
+
+        void
+        Linear::parse_entries(Parameters &prm)
+        {
+          min_depth = prm.get<double>("min distance slab top");
+          max_depth = prm.get<double>("max distance slab top");
+          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          top_temperature = prm.get<double>("top temperature");
+          bottom_temperature = prm.get<double>("bottom temperature");
+        }
+
+
+        double
+        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                const double /*depth*/,
+                                const double gravity_norm,
+                                double temperature_,
+                                const double /*feature_min_depth*/,
+                                const double /*feature_max_depth*/,
+                                const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
+                                const AdditionalParameters & /*additional_parameters*/) const
+        {
+          if (distance_from_plane.distance_from_plane <= max_depth && distance_from_plane.distance_from_plane >= min_depth)
+            {
+              const double min_depth_local = min_depth;
+              const double max_depth_local = max_depth;
+
+
+              double top_temperature_local = top_temperature;
+              if (top_temperature_local < 0)
+                {
+                  top_temperature_local =  this->world->potential_mantle_temperature *
+                                           std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                     this->world->specific_heat) * min_depth_local);
+                }
+
+              double bottom_temperature_local = bottom_temperature;
+              if (bottom_temperature_local < 0)
+                {
+                  bottom_temperature_local =  this->world->potential_mantle_temperature *
+                                              std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
+                                                        this->world->specific_heat) * max_depth_local);
+                }
+
+              const double new_temperature = top_temperature_local +
+                                             (distance_from_plane.distance_from_plane - min_depth_local) *
+                                             ((bottom_temperature_local - top_temperature_local) / (max_depth_local - min_depth_local));
+              return apply_operation(operation,temperature_,new_temperature);
+
+
+            }
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(Linear, linear)
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/mass_conserving.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/mass_conserving.cc.bak
new file mode 100644
index 00000000000..f2ad576c5c2
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/mass_conserving.cc.bak
@@ -0,0 +1,639 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+   Note that the empirical model used to define how Tmin increases with depth
+   and how the position of Tmin shift with depth is expected to change somewhat
+   after better calibrating with further tests.
+*/
+
+#include "world_builder/features/subducting_plate_models/temperature/mass_conserving.h"
+#include "world_builder/features/oceanic_plate_models/temperature/plate_model.h"
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/point.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+#include "world_builder/types/int.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        MassConserving::MassConserving(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          density(NaN::DSNAN),
+          mantle_coupling_depth(NaN::DSNAN),
+          forearc_cooling_factor(NaN::DSNAN),
+          thermal_conductivity(NaN::DSNAN),
+          thermal_expansion_coefficient(NaN::DSNAN),
+          specific_heat(NaN::DSNAN),
+          thermal_diffusivity(NaN::DSNAN),
+          potential_mantle_temperature(NaN::DSNAN),
+          surface_temperature(NaN::DSNAN),
+          taper_distance(NaN::DSNAN),
+          adiabatic_heating(true),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "mass conserving";
+        }
+
+        MassConserving::~MassConserving() = default;
+
+        void
+        MassConserving::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `plate velocity` to the required parameters.
+          prm.declare_entry("", Types::Object({"plate velocity"}),
+                            "Mass conserving temperature model. The temperature "
+                            "model uses the heat content (proportional to to thermal mass anomaly) to "
+                            "define a smooth temperature profile that conserves mass along the slab length. "
+                            "An empirical model, using error functions for smooth transitions, is used to "
+                            " define how the minimum temperature increases with depth and how the location of "
+                            "the minimum temperature shifts into the slab interior. The slab is divided into top "
+                            "and bottom parts, which meet at the location where the minimum temperature occurs in the slab. "
+                            "For the bottom slab, the temperature is defined by a half-space cooling model. "
+                            "For the top of the slab the temperature is defined by one side of a 1D infinite "
+                            "space cooling model: this function was chosen to have a smoother temperature function across "
+                            "the minimum temperature position. The age of the overriding plate is used so the slab temperature "
+                            "at shallow depth smoothly transitions to the temperature of the overriding plate: "
+                            "this is not perfect, and is affected by the value of \"top truncation\" parameter "
+                            "subducting plate. Notes:"
+                            "1) the parameter \"thickness\" for the subducting plate segments needs to be defined but is not used. "
+                            "2) because we use a negative truncation for distance above the slab, it is recommended to use"
+                            "depth method:begin at end segment, in the main part of the world-builder file."
+                            "Other methods may lead to gpas in temperatures at the segment boundaries."
+                            "3)the empirical model used to define how Tmin increases with depth "
+                            "and how the position of Tmin shift with depth is expected to change somewhat "
+                            "after better calibrating with further tests.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "The distance in meters from the top surface of the slab over which the temperature is "
+                            "determined by this feature. This parameter should be negative and should be 1.5-2 times "
+                            "larger than the nominal slab thickness to allow the diffusion of cold "
+                            "temperatures from in the slab into the mantle above the slab surface. "
+                            "Also note that the top truncation value for the slab segment needs to have a value "
+                            "of -1, otherwise the temperature above the slab will be cut off at a distance less than "
+                            "the value set here.");
+
+          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
+                            "The distance in meters from the top surface of the slab over which the temperature is "
+                            "determined by this feature. This parameter should be positive and approximately 2.5-3.0 times "
+                            "larger than the nominal slab thickness to allow the diffusion of cold"
+                            "temperatures from in the slab into the mantle below the slab surface."
+                            "For example if the slab starts with cold temperatures over a 100 km wide region, this"
+                            "parameters should be about 250 km.");
+
+          prm.declare_entry("density", Types::Double(3300),
+                            "The reference density of the subducting plate in $kg/m^3$");
+
+          prm.declare_entry("plate velocity", Types::OneOf(Types::Double(0.05),Types::Array(Types::ValueAtPoints(0.05, std::numeric_limits<uint64_t>::max()))),
+                            "The velocity with which the plate subducts in meters per year. Default is 5 cm/yr");
+
+          prm.declare_entry("subducting velocity", Types::OneOf(Types::Double(-1), Types::Array(Types::Array(Types::Double(-1), 1), 1)),
+                            "The velocity with which the ridge is moving through time, and how long the ridge "
+                            "has been moving. First value is the velocity, second is the time. Default is [0 cm/yr, 0 yr]");
+
+          prm.declare_entry("coupling depth", Types::Double(100e3),
+                            "The depth at which the slab surface first comes in contact with the hot mantle wedge "
+                            "in meters. Default is 100 km.");
+
+          prm.declare_entry("forearc cooling factor", Types::Double(1.0),
+                            "Increase the value to create thin (~2 km) cold thermal boundary layer above the slab."
+                            "Any value greater than 1 does NOT meet the instantaneous conservation of mass, but does allow "
+                            "one to account for the history of insulating the forearc from heating up to this point in time. "
+                            "Note younger subducting lithosphere provides less insulation, while thicker, older slabs "
+                            "provide more insulation. Values up to 10 to 30 have been tested and don't cause any other "
+                            "extraneous effects. The larger th value the more you are not meeting the mass conserving criteria, "
+                            "so you don't want to see this affecting the temperature beyond the coupling depth as it will "
+                            "increase the mass of the slab and affect how it sinks.  If you use higher values, you will start to "
+                            "see that this creates a very thick cool layer above the entire slab - if you see this extending beyond "
+                            "the coupling zone reduce the value. You should use a value of 1 first and then "
+                            "only increase as little as possible to cool just the forearc region. "
+                            "Please examine the output temperature carefully. ");
+
+          prm.declare_entry("thermal conductivity", Types::Double(3.3),
+                            "The thermal conductivity of the subducting plate material in $W m^{-1} K^{-1}$.");
+
+          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
+                            "The thermal expansivity of the subducting plate material in $K^{-1}$. If smaller than zero, the global value is used.");
+
+          prm.declare_entry("specific heat", Types::Double(-1),
+                            "The specific heat of the subducting plate material in $J kg^{-1} K^{-1}$. If smaller than zero, the global value is used.");
+
+          prm.declare_entry("thermal diffusivity", Types::Double(-1),
+                            "The thermal conductivity of the subducting plate material in $W m^{-1} K^{-1}$.");
+
+          prm.declare_entry("adiabatic heating", Types::Bool(true),
+                            "Whether adiabatic heating should be used for the slab.");
+
+          prm.declare_entry("taper distance", Types::Double(100e3),
+                            "Distance over which to taper the slab tip."
+                            "tapers the initial heat content to zero and the minimum temperature to the background temperature.");
+
+          prm.declare_entry("potential mantle temperature", Types::Double(-1),
+                            "The potential temperature of the mantle at the surface in Kelvin. If smaller than zero, the global value is used.");
+
+          prm.declare_entry("ridge coordinates", Types::Array(Types::Array(Types::Point<2>(), 2),1),
+                            "An list of ridges. Each ridge is a lists of at least 2 2d points which "
+                            "define the location of the ridge. You need to define at least one ridge."
+                            "So the an example with two ridges is "
+                            "[[[10,20],[20,30],[10,40]],[[50,10],[60,10]]].");
+
+          prm.declare_entry("reference model name",  Types::String("half space model"),
+                            "The type of thermal model to use in the mass conserving model of slab temperature. "
+                            "Options are half space model and plate model");
+
+          prm.declare_entry("apply spline",  Types::Bool(false),
+                            "Whether a spline should be applied on the mass conserving model.");
+
+          prm.declare_entry("number of points in spline", Types::UnsignedInt(5),
+                            "The number of points in the spline");
+
+        }
+
+        void
+        MassConserving::parse_entries(Parameters &prm)
+        {
+
+          min_depth = prm.get<double>("min distance slab top");
+          max_depth = prm.get<double>("max distance slab top");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          density = prm.get<double>("density");
+          thermal_conductivity = prm.get<double>("thermal conductivity");
+          ridge_spreading_velocities = prm.get_value_at_array("plate velocity");
+          subducting_velocities = prm.get_vector_or_double("subducting velocity");
+
+          mantle_coupling_depth = prm.get<double>("coupling depth");
+          forearc_cooling_factor = prm.get<double>("forearc cooling factor");
+
+          taper_distance = prm.get<double>("taper distance");
+
+          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
+          if (thermal_expansion_coefficient < 0)
+            thermal_expansion_coefficient = this->world->thermal_expansion_coefficient;
+
+          specific_heat = prm.get<double>("specific heat");
+          if (specific_heat < 0)
+            specific_heat = this->world->specific_heat;
+
+          thermal_diffusivity = prm.get<double>("thermal diffusivity");
+          if (thermal_diffusivity < 0)
+            thermal_diffusivity = this->world->thermal_diffusivity;
+
+          adiabatic_heating = prm.get<bool>("adiabatic heating");
+
+          potential_mantle_temperature = this->world->potential_mantle_temperature >= 0
+                                         ?
+                                         this->world->potential_mantle_temperature
+                                         :
+                                         prm.get<double>("potential mantle temperature");
+
+          surface_temperature = this->world->surface_temperature;
+
+          mid_oceanic_ridges = prm.get_vector<std::vector<Point<2>>>("ridge coordinates");
+          const double dtr = prm.coordinate_system->natural_coordinate_system() == spherical ? Consts::PI / 180.0 : 1.0;
+          for (auto &ridge_coordinates : mid_oceanic_ridges)
+            for (auto &ridge_coordinate : ridge_coordinates)
+              {
+                ridge_coordinate *= dtr;
+              }
+
+          unsigned int ridge_point_index = 0;
+          for (const auto &mid_oceanic_ridge : mid_oceanic_ridges)
+            {
+              std::vector<double> ridge_spreading_velocities_for_ridge;
+              for (unsigned int index_y = 0; index_y < mid_oceanic_ridge.size(); index_y++)
+                {
+                  if (ridge_spreading_velocities.second.size() == 1)
+                    {
+                      ridge_spreading_velocities_for_ridge.push_back(ridge_spreading_velocities.second[0]);
+                    }
+                  else
+                    {
+                      ridge_spreading_velocities_for_ridge.push_back(ridge_spreading_velocities.second[ridge_point_index]);
+                    }
+                  ridge_point_index += 1;
+                }
+              ridge_spreading_velocities_at_each_ridge_point.push_back(ridge_spreading_velocities_for_ridge);
+            }
+
+          std::string reference_model_name_str = prm.get<std::string>("reference model name");
+          if (reference_model_name_str=="plate model")
+            reference_model_name = plate_model;
+          else if (reference_model_name_str=="half space model")
+            reference_model_name = half_space_model;
+
+          apply_spline = prm.get<bool>("apply spline");
+          spline_n_points = prm.get<unsigned int>("number of points in spline");
+
+          if (subducting_velocities[0].size() > 1)
+            {
+              for (unsigned int ridge_index = 0; ridge_index < mid_oceanic_ridges.size(); ridge_index++)
+                {
+                  WBAssertThrow(subducting_velocities.size() == mid_oceanic_ridges.size() &&
+                                subducting_velocities[ridge_index].size() == mid_oceanic_ridges[ridge_index].size(),
+                                "subducting velocity must have the same dimension as the ridge coordinates parameter.");
+                  for (unsigned int point_index = 0; point_index < mid_oceanic_ridges[ridge_index].size(); point_index++)
+                    {
+                      WBAssertThrow(Utilities::approx(subducting_velocities[ridge_index][point_index],
+                                                      ridge_spreading_velocities_at_each_ridge_point[ridge_index][point_index]),
+                                    "Currently, subducting velocity must equal the spreading velocity to satisfy conservation of mass. "
+                                    "This will be changed in the future to allow for the spreading center to move depending on the relative "
+                                    "difference between the spreading velocity and the subducting velocity, thereby conserving mass.");
+                    }
+                }
+            }
+        }
+
+        double
+        MassConserving::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                        const double depth,
+                                        const double gravity_norm,
+                                        double temperature_,
+                                        const double /*feature_min_depth*/,
+                                        const double /*feature_max_depth*/,
+                                        const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                        const AdditionalParameters &additional_parameters) const
+        {
+
+          const double distance_from_plane = distance_from_planes.distance_from_plane;
+
+          if (distance_from_plane <= max_depth && distance_from_plane >= min_depth)
+            {
+
+              const Point<3> trench_point = distance_from_planes.closest_trench_point;
+              const Objects::NaturalCoordinate trench_point_natural = Objects::NaturalCoordinate(trench_point,
+                                                                      *(world->parameters.coordinate_system));
+
+              std::vector<double> ridge_parameters = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                                     ridge_spreading_velocities_at_each_ridge_point,
+                                                     world->parameters.coordinate_system,
+                                                     trench_point_natural,
+                                                     subducting_velocities,
+                                                     ridge_spreading_velocities.first);
+
+              constexpr double km2m = 1.0e3; // 1000 m/km
+              constexpr double cm2m = 100; // 100 cm/m
+              constexpr double my = 1.0e6;  // 1e6 y/my
+
+              /* information about nearest point on the slab segment */
+              const double distance_along_plane = distance_from_planes.distance_along_plane;
+              const double depth_to_reference_surface = distance_from_planes.depth_reference_surface;
+              const double total_segment_length = additional_parameters.total_local_segment_length;
+              const double average_angle = distance_from_planes.average_angle;
+
+              std::vector<double> slab_ages = calculate_effective_trench_and_plate_ages(ridge_parameters, distance_along_plane);
+
+              const double seconds_in_year = 60.0 * 60.0 * 24.0 * 365.25;  // sec/y
+              const double spreading_velocity = ridge_parameters[0] * seconds_in_year; // m/yr
+              double subducting_velocity = ridge_parameters[2] * seconds_in_year; // m/yr
+
+              if (subducting_velocity <= 0)
+                subducting_velocity = spreading_velocity;
+
+              const double age_at_trench = slab_ages[0];
+              const double plate_age_sec = age_at_trench * seconds_in_year; // y --> seconds
+              // 1. Determine initial heat content of the slab based on age of plate at trench
+              // This uses the integral of the half-space temperature profile
+              // The initial heat content is also decided from the type of thermal model to use in the
+              // mass conserving model
+              double initial_heat_content;
+              if (reference_model_name == plate_model)
+                {
+                  initial_heat_content = thermal_conductivity / thermal_diffusivity *
+                                         (surface_temperature - potential_mantle_temperature) * max_depth / 2.0;
+                  for (int i = 0; i< std::floor(plate_model_summation_number/2.0); ++i)
+                    {
+                      // because n < sommation_number + 1 and n = 2k + 1
+                      // The "spreading_velocity" instead of "spreading_velocity_UI" is used for the last instance as "age_at_trench" has
+                      // a unit of yr.
+                      const double subducting_velocity_UI = subducting_velocity / seconds_in_year;
+                      const double temp_heat_content = thermal_conductivity / thermal_diffusivity *
+                                                       (surface_temperature - potential_mantle_temperature) *
+                                                       4 * max_depth / double(2*i + 1) / double(2*i + 1) / Consts::PI / Consts::PI *
+                                                       exp((subducting_velocity_UI * max_depth / 2 / thermal_diffusivity -
+                                                            std::sqrt(subducting_velocity_UI * subducting_velocity_UI * max_depth * max_depth / 4.0 / thermal_diffusivity / thermal_diffusivity +
+                                                                      double(2*i + 1) * double(2*i + 1) * Consts::PI * Consts::PI)) *
+                                                           subducting_velocity * age_at_trench / max_depth);
+                      initial_heat_content -= temp_heat_content;
+                    }
+                }
+              else
+                {
+                  initial_heat_content = 2 * thermal_conductivity * (surface_temperature - potential_mantle_temperature) *
+                                         std::sqrt(plate_age_sec / (thermal_diffusivity * Consts::PI));
+                }
+
+              // Plate age increases with distance along the slab in the mantle
+              double effective_plate_age = slab_ages[1];
+
+              // Need adiabatic temperature at position of grid point
+              const double background_temperature = adiabatic_heating ? potential_mantle_temperature *
+                                                    std::exp(thermal_expansion_coefficient * gravity_norm * depth / specific_heat)
+                                                    : potential_mantle_temperature;
+
+              WBAssert(!std::isnan(background_temperature), "Internal error: temp is not a number: " << background_temperature << ". In exponent: "
+                       << std::exp(((thermal_expansion_coefficient * gravity_norm) / specific_heat) * depth)
+                       << ", thermal_expansion_coefficient = " << thermal_expansion_coefficient << ", gravity_norm = " << gravity_norm
+                       << ", specific_heat = " << specific_heat << ", depth = " << depth);
+
+              const double adiabatic_gradient = adiabatic_heating ? background_temperature - potential_mantle_temperature : 0;
+
+              //  2. Get Tmin and offset as a function of depth: these depend on plate velocity and plate age_at_trench.
+              //     shallow-dipping slabs will take longer to reach the same depth - this leads to larger effective age at a given depth
+              //     causing these slabs to be broader than steeper dipping slabs
+              //     These equations are empirical based on fitting the temperature profiles from dynamic subduction models.
+              //     and published kinematic models for specific subduction zones.
+
+              // increases Tmin slope for slower relative to slope for maximum plate velocity
+              // will be between 0.1 (fast) and 0.35 (slow)
+              const double max_plate_vel = 20/cm2m;  // e.g., 20 cm/yr -> 0.2 m/yr
+              const double vsubfact = std::min( std::max( 0.35 + ((0.1-0.35) / max_plate_vel) * subducting_velocity, 0.1), 0.35);
+
+              // increases Tmin slope for younger plate relative to slope for old place
+              // will be between 0.1 (old) and 0.35 *(young)
+              const double max_plate_age = 100*my; // years
+              const double max_age_fact = 1.0;
+              const double agefact = std::min( std::max( max_age_fact + ((0.1-max_age_fact) / max_plate_age) * age_at_trench, 0.1), max_age_fact);
+
+              // increases offset  relative to slab surface for older plates
+              // will be between 0.1 (young) and 0.35 (old)
+              const double agefact2 = std::max( std::min( 0.1 + ((0.35-0.1) / max_plate_age) * age_at_trench, 0.35), 0.1);
+
+              // ranges between 0.5 (old and fast) and 1.0 (young and slow)
+              const double subfact = 0.3 + vsubfact + agefact;  // this has a minimum value of 0.5 for the erfc
+              // ranges between 0.5 (young and fast) and 1 (old and slow)
+              const double subfact2 = 0.3 + vsubfact + agefact2;
+
+              // Minimum Temperature
+              const double min_Tcoup = 10; // 0.3*mantle_coupling_depth/km2m; // deg C: from 0.3deg/km * 100 km = 30 deg
+              const double max_Tcoup = 350; // deg C: from Cascadia subduction models by Gao and Wang, Gcubd 2017
+              const double Tcoup = min_Tcoup + (subfact - 0.5)*(max_Tcoup - min_Tcoup);
+
+              const double min_Tmin660 = 300; //110; // based on syracruse models (with 0.5 deg/km adiabat; (265-30)-0.5*240)
+              const double max_Tmin660 = 900;
+              const double Tmin660 =  min_Tmin660 + (subfact - 0.5)*(max_Tmin660 - min_Tmin660);
+
+              // Temperature offset
+              const double min_offset_coup = 2*km2m;  // values from syracuse and time-dep Citcom run
+              const double max_offset_coup = 10*km2m;
+              const double offset_coup = min_offset_coup + (subfact2)*(max_offset_coup - min_offset_coup);
+
+              const double min_offset660 = 15*km2m;  // values from time-dep Citcom run
+              const double max_offset660 = 25*km2m;
+              const double offset660 =  min_offset660 + (subfact2)*(max_offset660 - min_offset660);
+
+              // For tapering the slab tip temperature to the mantle temperature
+              const double start_taper_distance = total_segment_length - taper_distance;
+
+              const double upper_mantle_lengthscale = 660e3 - mantle_coupling_depth; // m
+
+
+              const double taper_con = 0.8;  // controls how close taper gets to end of segment
+              double theta = 0;
+              double min_temperature = 0;
+              double offset = 0;
+
+              if (depth_to_reference_surface < mantle_coupling_depth)
+                {
+                  // above coupling depth
+                  theta = (mantle_coupling_depth - depth_to_reference_surface) / (subfact * mantle_coupling_depth); // must be scaled depth_coupling to match Tcoup ad Tsurface.
+                  min_temperature = Tcoup * std::erfc(theta);
+                  offset = offset_coup * std::erfc(theta);
+                }
+              else if (distance_along_plane >= start_taper_distance)
+                {
+                  // beyond start taper distance to taper the slab tip
+
+                  const double depth_start_taper = depth_to_reference_surface - (distance_along_plane - start_taper_distance)
+                                                   * std::sin(average_angle * Consts::PI / 180.0);
+                  const double theta_start = (mantle_coupling_depth - depth_start_taper) / (subfact * upper_mantle_lengthscale);
+                  const double Tmin_start_taper = Tcoup + Tmin660 * (std::erfc(theta_start)) - Tmin660;
+                  //keep the offset location constant in the taper
+                  const double offset_start_taper = offset_coup + (offset660) * std::erfc(theta_start) - offset660;
+
+                  // taper Tmin to the mantle temperature
+                  theta = (distance_along_plane - start_taper_distance) / (taper_distance);
+                  min_temperature =  Tmin_start_taper + (potential_mantle_temperature - Tmin_start_taper) * (1-std::erfc(taper_con*theta));
+                  offset =  offset_start_taper + (2*max_offset660 - offset_start_taper) * (1-std::erfc(taper_con*theta));
+
+                  // Also taper the initial heat content and effective plate age
+                  initial_heat_content = initial_heat_content * std::erfc(1.5*taper_con*theta);
+                  effective_plate_age = effective_plate_age * std::erfc(1.5*taper_con*theta);
+                }
+
+              else
+                {
+                  theta = (mantle_coupling_depth - depth_to_reference_surface) / (subfact * upper_mantle_lengthscale);
+                  min_temperature = Tcoup + Tmin660 * std::erfc(theta) - Tmin660;
+                  offset = offset_coup + offset660 * std::erfc(theta) - offset660;
+                }
+
+              min_temperature = min_temperature + adiabatic_gradient + surface_temperature;
+
+              // Adjust distance for the offset of the minimum temperature from the top of the slab
+              const double adjusted_distance = distance_from_plane - offset;
+
+              // Base value chosen to insure that even young slabs have some cooling of the top of the slab
+              // Use forearc_cooling_factor input variable to increase the amount of long-term cooling of the forearc.
+              const double max_top_heat_content = -1.0e9 * forearc_cooling_factor * background_temperature; // need to multiply by background temperature  since it gets divided by something of this scale.
+
+              double temperature = 0.0;  // temperature (to be determined) at this location in the mesh
+
+              if (min_temperature < background_temperature)
+                {
+
+                  // 3. Determine the heat content for side 1 (bottom) of the slab
+                  // Comes from integrating the half-space cooling model or the plate model temperature
+                  // The bottom heat content is also decided from the type of thermal model to use in the
+                  // mass conserving model
+                  double bottom_heat_content;
+                  if (reference_model_name == plate_model)
+                    {
+                      bottom_heat_content = thermal_conductivity / thermal_diffusivity *
+                                            (min_temperature - potential_mantle_temperature) * max_depth / 2.0;
+                      for (int i = 0; i< std::floor(plate_model_summation_number/2.0); ++i)
+                        {
+                          // because n < sommation_number + 1 and n = 2k + 1
+                          const double subducting_velocity_UI = subducting_velocity / seconds_in_year;
+                          const double temp_heat_content = thermal_conductivity / thermal_diffusivity *
+                                                           (min_temperature - potential_mantle_temperature) *
+                                                           4 * max_depth / double(2*i + 1) / double(2*i + 1) / Consts::PI / Consts::PI *
+                                                           exp((subducting_velocity_UI * max_depth / 2.0 / thermal_diffusivity -
+                                                                std::sqrt(subducting_velocity_UI * subducting_velocity_UI * max_depth * max_depth / 4.0 / thermal_diffusivity / thermal_diffusivity +
+                                                                          double(2*i + 1) * double(2*i + 1) * Consts::PI * Consts::PI)) *
+                                                               subducting_velocity_UI * effective_plate_age / max_depth);
+                          bottom_heat_content -= temp_heat_content;
+                        }
+                    }
+                  else
+                    {
+                      bottom_heat_content = 2 * thermal_conductivity * (min_temperature - potential_mantle_temperature) *
+                                            std::sqrt(effective_plate_age /(thermal_diffusivity * Consts::PI));
+                    }
+
+                  // 4. The difference in heat content goes into the temperature above where Tmin occurs.
+                  // Should not be a positive value
+                  //double top_heat_content = initial_heat_content - bottom_heat_content;
+
+                  double top_heat_content =  std::min(max_top_heat_content, (initial_heat_content - bottom_heat_content) );
+
+                  // Also need to taper the top_heat_content otherwise slab top will continue to thicken to the tip.
+                  // Can't do this above because need min_temperature to get bottom_heat_content first
+                  if (distance_along_plane > start_taper_distance)
+                    {
+                      top_heat_content = top_heat_content * std::erfc(taper_con*theta);
+                    }
+
+                  double nondimensional_adjusted_distance = adjusted_distance / max_depth;
+
+                  if (apply_spline)
+                    {
+                      // A total number of (2 * spline_n_points + 1) points are picked,
+                      // spline_n_points points on each side and one at the center.
+                      // These points cover a range of (-1.0, 1.0) in adjusted_distance.
+                      Utilities::interpolation monotone_cubic_spline;
+
+                      const double interval_spline_distance = 1.0 / spline_n_points;
+                      std::vector<double> i_temperatures (2*(spline_n_points + 1), 0.0);
+
+                      for (size_t i = 0; i < 2 * spline_n_points + 1; ++i)
+                        {
+                          const double i_adjusted_distance = (static_cast<double>(i) * interval_spline_distance - 1.0) * max_depth;
+                          const double i_temperature = get_temperature_analytic(top_heat_content, min_temperature, background_temperature, temperature_, spreading_velocity, effective_plate_age, i_adjusted_distance);
+                          i_temperatures[i] = i_temperature;
+                        }
+
+                      monotone_cubic_spline.set_points(i_temperatures);
+
+                      const double index_distance = (nondimensional_adjusted_distance + 1.0) / interval_spline_distance;
+                      temperature =  monotone_cubic_spline(index_distance);
+                    }
+                  else
+                    {
+                      // Call the analytic solution to compute the temperature
+                      temperature = get_temperature_analytic(top_heat_content, min_temperature, background_temperature, temperature_, spreading_velocity, effective_plate_age, adjusted_distance);
+                    }
+                }
+              else
+                {
+                  // slab temperature anomaly is gone.
+                  temperature = temperature_;
+                }
+
+              WBAssert(!std::isnan(temperature), "Internal error: temperature is not a number: " << temperature << '.');
+              WBAssert(std::isfinite(temperature), "Internal error: temperature is not finite: " << temperature << '.');
+
+              return apply_operation(operation, temperature_, temperature);
+            }
+
+          return temperature_;
+        }
+
+        double
+        MassConserving::get_temperature_analytic(const double top_heat_content,
+                                                 const double min_temperature,
+                                                 const double background_temperature,
+                                                 const double temperature_,
+                                                 const double subducting_velocity,
+                                                 const double effective_plate_age,
+                                                 const double adjusted_distance) const
+        {
+          const double seconds_in_year = 60.0 * 60.0 * 24.0 * 365.25;  // sec/y
+
+          double temperature = 0.0;
+
+          // Assign the temperature depending on whether distance is negative (above) or positive (below) the slab
+          if (adjusted_distance < 0)
+            {
+              // use 1D infinite space solution for top (side 2) of slab the slab
+              // 2 times the "top_heat_content" because all this heat needs to be on one side of the Gaussian
+              const double time_top_slab = (1/(Consts::PI*thermal_diffusivity)) *
+                                           pow(((2 * top_heat_content) / (2 * density * specific_heat * (min_temperature - temperature_ + 1e-16))),2) + 1e-16;
+
+              // for overriding plate region where plate temperature is less the minimum slab temperature
+              // need to set temperature = temperature_ otherwise end up with temperature less than surface temperature ;
+              if (temperature_ < min_temperature)
+                {
+                  temperature = temperature_;
+                }
+              else
+                {
+                  temperature  = temperature_ + (2 * top_heat_content /
+                                                 (2*density*specific_heat * std::sqrt(Consts::PI * thermal_diffusivity * time_top_slab)))*
+                                 std::exp(-(adjusted_distance*adjusted_distance)/(4*thermal_diffusivity*time_top_slab));
+                }
+            }
+          else
+            {
+              // use half-space cooling or plate model for the bottom (side 1) of the slab
+              if (reference_model_name == plate_model)
+                {
+                  if (adjusted_distance < max_depth)
+                    {
+                      const double subducting_velocity_UI = subducting_velocity / seconds_in_year;
+                      temperature = background_temperature + (min_temperature - background_temperature) * (1 - adjusted_distance / max_depth);
+                      for (int i = 1; i< std::floor(plate_model_summation_number/2.0); ++i)
+                        {
+                          temperature = temperature - (min_temperature - background_temperature) *
+                                        ((2 / (double(i) * Consts::PI)) * std::sin((double(i) * Consts::PI * adjusted_distance) / max_depth) *
+                                         std::exp((((subducting_velocity_UI * max_depth)/(2 * thermal_diffusivity)) -
+                                                   std::sqrt(((subducting_velocity_UI*subducting_velocity_UI*max_depth*max_depth) /
+                                                              (4*thermal_diffusivity*thermal_diffusivity)) + double(i) * double(i) * Consts::PI * Consts::PI)) *
+                                                  ((subducting_velocity_UI * effective_plate_age) / max_depth)));
+                        }
+                    }
+                  else
+                    {
+                      temperature = background_temperature;
+                    }
+                }
+              else
+                {
+                  temperature = background_temperature + (min_temperature - background_temperature) *
+                                std::erfc(adjusted_distance / (2 * std::sqrt(thermal_diffusivity * effective_plate_age)));
+
+                }
+            }
+          return temperature;
+        }
+
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(MassConserving, mass conserving)
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/plate_model.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/plate_model.cc.bak
new file mode 100644
index 00000000000..368adcdc09d
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/plate_model.cc.bak
@@ -0,0 +1,214 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/temperature/plate_model.h"
+
+#include "world_builder/nan.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        PlateModel::PlateModel(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          density(NaN::DSNAN),
+          plate_velocity(NaN::DSNAN),
+          thermal_conductivity(NaN::DSNAN),
+          thermal_expansion_coefficient(NaN::DSNAN),
+          specific_heat(NaN::DSNAN),
+          potential_mantle_temperature(NaN::DSNAN),
+          surface_temperature(NaN::DSNAN),
+          adiabatic_heating(true),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "plate model";
+        }
+
+        PlateModel::~PlateModel()
+          = default;
+
+        void
+        PlateModel::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `plate velocity` to the required parameters.
+          prm.declare_entry("", Types::Object({"plate velocity"}),
+                            "Plate model (based on McKenzie, 1970).");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "todo The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
+                            "todo The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("density", Types::Double(3300),
+                            "The reference density of the subducting plate in $kg/m^3$");
+
+          prm.declare_entry("plate velocity", Types::Double(NaN::DQNAN),
+                            "The velocity in meters per year with which the plate subducts in meters per year.");
+
+          prm.declare_entry("thermal conductivity", Types::Double(2.0),
+                            "The thermal conductivity of the subducting plate material in $W m^{-1} K^{-1}$.");
+
+          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
+                            "The thermal expansivity of the subducting plate material in $K^{-1}$. If smaller than zero, the global value is used.");
+
+          prm.declare_entry("specific heat", Types::Double(-1),
+                            "The specific heat of the subducting plate material in $J kg^{-1} K^{-1}$. If smaller than zero, the global value is used.");
+
+          prm.declare_entry("adiabatic heating", Types::Bool(true),
+                            "Whether adiabatic heating should be used for the slab. Setting the parameter to false leads to equation 26 from McKenzie (1970),"
+                            "which is the result obtained from McKenzie 1969.");
+
+          prm.declare_entry("potential mantle temperature", Types::Double(-1),
+                            "The potential temperature of the mantle at the surface in Kelvin. If smaller than zero, the global value is used.");
+        }
+
+        void
+        PlateModel::parse_entries(Parameters &prm)
+        {
+
+          min_depth = prm.get<double>("min distance slab top");
+          max_depth = prm.get<double>("max distance slab top");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+
+          density = prm.get<double>("density");
+          plate_velocity = prm.get<double>("plate velocity");
+          thermal_conductivity = prm.get<double>("thermal conductivity");
+          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
+
+          if (thermal_expansion_coefficient < 0 )
+            thermal_expansion_coefficient = this->world->thermal_expansion_coefficient;
+
+          specific_heat = prm.get<double>("specific heat");
+
+          if (specific_heat < 0)
+            specific_heat = this->world->specific_heat;
+
+          adiabatic_heating = prm.get<bool>("adiabatic heating");
+
+          potential_mantle_temperature = this->world->potential_mantle_temperature >= 0
+                                         ?
+                                         this->world->potential_mantle_temperature
+                                         :
+                                         prm.get<double>("potential mantle temperature");
+          surface_temperature = this->world->surface_temperature;
+        }
+
+
+        double
+        PlateModel::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                    const double depth,
+                                    const double gravity_norm,
+                                    double temperature_,
+                                    const double /*feature_min_depth*/,
+                                    const double /*feature_max_depth*/,
+                                    const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
+                                    const AdditionalParameters &additional_parameters) const
+        {
+          const double thickness_local = std::min(additional_parameters.local_thickness, max_depth);
+          const double distance_from_plane = distance_from_planes.distance_from_plane;
+          const double distance_along_plane = distance_from_planes.distance_along_plane;
+
+          if (distance_from_plane <= max_depth && distance_from_plane >= min_depth)
+            {
+              /*
+               * We now use the McKenzie (1970) equation to determine the
+               * temperature inside the slab. The McKenzie equation was
+               * designed for a straight slab, but we have a potentially
+               * curved slab. Since the angle is used to compute the depth
+               * of the point, we directly use the depth.
+               */
+              const double R = (density * specific_heat
+                                * (plate_velocity /(365.25 * 24.0 * 60.0 * 60.0))
+                                * thickness_local) / (2.0 * thermal_conductivity);
+
+              WBAssert(!std::isnan(R), "Internal error: R is not a number: " << R << '.');
+
+              const int n_sum = 500;
+              // distance_from_plane can be zero, so protect division.
+              const double z_scaled = 1 - (std::fabs(distance_from_plane) < 2.0 * std::numeric_limits<double>::epsilon() ?
+                                           2.0 * std::numeric_limits<double>::epsilon()
+                                           :
+                                           distance_from_plane/thickness_local);
+
+              // distance_along_plane can be zero, so protect division.
+              const double x_scaled = (std::fabs(distance_along_plane) < 2.0 * std::numeric_limits<double>::epsilon() ?
+                                       2.0 *std::numeric_limits<double>::epsilon()
+                                       :
+                                       distance_along_plane/thickness_local);
+
+              // the paper uses `(x_scaled * sin(average_angle) - z_scaled * cos(average_angle))` to compute the
+              // depth (execpt that you do not use average angles since they only have on angle). On recomputing
+              // their result it seems to me (Menno) that it should have been `(1-z_scaled)` instead of `z_scaled`.
+              // To avoid this whole problem we just use the depth directly since we have that.
+              // todo: get the local thickniss out of H, that prevents an other division.
+              // If we want to specify the bottom temperature, because we have defined a linear temperature increase in the
+              // mantle and/or oceanic plate, we have to switch off adiabatic heating for now.
+              // Todo: there may be a better way to deal with this.
+              ;
+              const double temp = adiabatic_heating ? std::exp(((thermal_expansion_coefficient * gravity_norm * depth) / specific_heat)) : 1;
+
+              WBAssert(!std::isnan(temp), "Internal error: temp is not a number: " << temp << ". In exponent: "
+                       << std::exp(((thermal_expansion_coefficient * gravity_norm) / specific_heat) * depth)
+                       << ", thermal_expansion_coefficient = " << thermal_expansion_coefficient << ", gravity_norm = " << gravity_norm
+                       << ", specific_heat = "<< specific_heat << ", depth = " << depth );
+
+              double sum=0;
+              for (int i=1; i<=n_sum; i++)
+                {
+                  sum += (std::pow((-1.0),i)/(i*Consts::PI)) *
+                         (exp((R - std::pow(R * R + i * i * Consts::PI * Consts::PI, 0.5)) * x_scaled))
+                         * (sin(i * Consts::PI * z_scaled));
+                }
+              // todo: investigate whether this 273.15 should just be the surface temperature.
+              const double temperature = temp * (potential_mantle_temperature
+                                                 + 2.0 * (potential_mantle_temperature - 273.15) * sum);
+
+              WBAssert(!std::isnan(temperature), "Internal error: temperature is not a number: " << temperature << '.');
+              WBAssert(std::isfinite(temperature), "Internal error: temperature is not finite: " << temperature << '.');
+
+
+              return apply_operation(operation,temperature_,temperature);
+            }
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(PlateModel, plate model)
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/uniform.cc.bak
new file mode 100644
index 00000000000..aa9a904ee7e
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/uniform.cc.bak
@@ -0,0 +1,109 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/features/subducting_plate_models/temperature/uniform.h"
+
+
+#include "world_builder/nan.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/utilities.h"
+
+
+namespace WorldBuilder
+{
+
+  using namespace Utilities;
+
+  namespace Features
+  {
+    namespace SubductingPlateModels
+    {
+      namespace Temperature
+      {
+        Uniform::Uniform(WorldBuilder::World *world_)
+          :
+          min_depth(NaN::DSNAN),
+          max_depth(NaN::DSNAN),
+          temperature(NaN::DSNAN),
+          operation(Operations::REPLACE)
+        {
+          this->world = world_;
+          this->name = "uniform";
+        }
+
+        Uniform::~Uniform()
+          = default;
+
+        void
+        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+        {
+          // Document plugin and require entries if needed.
+          // Add `temperature` and to the required parameters.
+          prm.declare_entry("", Types::Object({"temperature"}),
+                            "Uniform temperature model. Set the temperature to a constant value.");
+
+          // Declare entries of this plugin
+          prm.declare_entry("min distance slab top", Types::Double(0),
+                            "todo The depth in meters from which the composition of this feature is present.");
+
+          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
+                            "todo The depth in meters to which the composition of this feature is present.");
+
+          prm.declare_entry("temperature", Types::Double(293.15),
+                            "The temperature in degree Kelvin which this feature should have");
+
+        }
+
+        void
+        Uniform::parse_entries(Parameters &prm)
+        {
+
+          min_depth = prm.get<double>("min distance slab top");
+          max_depth = prm.get<double>("max distance slab top");
+          operation = string_operations_to_enum(prm.get<std::string>("operation"));
+          temperature = prm.get<double>("temperature");
+        }
+
+
+        double
+        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
+                                 const double  /*depth*/,
+                                 const double  /*gravity*/,
+                                 double temperature_,
+                                 const double  /*feature_min_depth*/,
+                                 const double  /*feature_max_depth*/,
+                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
+                                 const AdditionalParameters & /*additional_parameters*/) const
+        {
+
+          if (distance_from_plane.distance_from_plane <= max_depth && distance_from_plane.distance_from_plane >= min_depth)
+            {
+              return apply_operation(operation,temperature_,temperature);
+            }
+
+          return temperature_;
+        }
+
+        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(Uniform, uniform)
+      } // namespace Temperature
+    } // namespace SubductingPlateModels
+  } // namespace Features
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/grains.cc.bak b/contrib/world_builder/source/world_builder/grains.cc.bak
new file mode 100644
index 00000000000..b9e06ad2cde
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/grains.cc.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/grains.h"
+
+namespace WorldBuilder
+{
+
+  grains::grains()
+
+
+    = default;
+
+
+  grains::grains(const std::vector<double> &vector,
+                 const size_t number_of_grains,
+                 const size_t start_entry)
+  {
+    sizes.resize(number_of_grains);
+    for (unsigned int i_grain = 0; i_grain < number_of_grains; i_grain++)
+      {
+        sizes[i_grain] = vector[start_entry+i_grain];
+      }
+
+    rotation_matrices.resize(number_of_grains);
+    for (unsigned int i_grain = 0; i_grain < number_of_grains; i_grain++)
+      {
+        rotation_matrices[i_grain][0][0] = vector[start_entry+number_of_grains+i_grain*9];
+        rotation_matrices[i_grain][0][1] = vector[start_entry+number_of_grains+i_grain*9+1];
+        rotation_matrices[i_grain][0][2] = vector[start_entry+number_of_grains+i_grain*9+2];
+        rotation_matrices[i_grain][1][0] = vector[start_entry+number_of_grains+i_grain*9+3];
+        rotation_matrices[i_grain][1][1] = vector[start_entry+number_of_grains+i_grain*9+4];
+        rotation_matrices[i_grain][1][2] = vector[start_entry+number_of_grains+i_grain*9+5];
+        rotation_matrices[i_grain][2][0] = vector[start_entry+number_of_grains+i_grain*9+6];
+        rotation_matrices[i_grain][2][1] = vector[start_entry+number_of_grains+i_grain*9+7];
+        rotation_matrices[i_grain][2][2] = vector[start_entry+number_of_grains+i_grain*9+8];
+      }
+  }
+
+
+  void
+  grains::unroll_into(std::vector<double> &vector, const size_t start_entry) const
+  {
+    const size_t number_of_grains = sizes.size();
+
+    for (unsigned int i_grain = 0; i_grain < number_of_grains; i_grain++)
+      {
+        vector[start_entry+i_grain] = sizes[i_grain];
+      }
+
+    for (unsigned int i_grain = 0; i_grain < number_of_grains; i_grain++)
+      {
+        vector[start_entry+number_of_grains+i_grain*9]   = rotation_matrices[i_grain][0][0];
+        vector[start_entry+number_of_grains+i_grain*9+1] = rotation_matrices[i_grain][0][1];
+        vector[start_entry+number_of_grains+i_grain*9+2] = rotation_matrices[i_grain][0][2];
+        vector[start_entry+number_of_grains+i_grain*9+3] = rotation_matrices[i_grain][1][0];
+        vector[start_entry+number_of_grains+i_grain*9+4] = rotation_matrices[i_grain][1][1];
+        vector[start_entry+number_of_grains+i_grain*9+5] = rotation_matrices[i_grain][1][2];
+        vector[start_entry+number_of_grains+i_grain*9+6] = rotation_matrices[i_grain][2][0];
+        vector[start_entry+number_of_grains+i_grain*9+7] = rotation_matrices[i_grain][2][1];
+        vector[start_entry+number_of_grains+i_grain*9+8] = rotation_matrices[i_grain][2][2];
+      }
+  }
+} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/gravity_model/interface.cc.bak b/contrib/world_builder/source/world_builder/gravity_model/interface.cc.bak
new file mode 100644
index 00000000000..6a41777631b
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/gravity_model/interface.cc.bak
@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/gravity_model/interface.h"
+
+#include "world_builder/types/object.h"
+
+#include <algorithm>
+
+namespace WorldBuilder
+{
+  namespace GravityModel
+  {
+
+    Interface::Interface()
+      = default;
+
+    Interface::~Interface ()
+      = default;
+
+    void
+    Interface::declare_entries(Parameters &prm, const std::string &parent_name, const std::vector<std::string> &required_entries)
+    {
+
+      unsigned int counter = 0;
+      for (auto &it : get_declare_map())
+        {
+          prm.enter_subsection("oneOf");
+          {
+            prm.enter_subsection(std::to_string(counter));
+            {
+              prm.enter_subsection("properties");
+              {
+                prm.declare_entry("", Types::Object(required_entries), "gravity model");
+
+                prm.declare_entry("model",Types::String("",it.first),
+                                  "The name of the model for the gravity to use.");
+
+                it.second(prm, parent_name);
+              }
+              prm.leave_subsection();
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+
+          counter++;
+
+        }
+    }
+
+    void
+    Interface::registerType(const std::string &name,
+                            void ( *declare_entries)(Parameters &, const std::string &),
+                            ObjectFactory *factory)
+    {
+      get_factory_map()[name] = factory;
+      get_declare_map()[name] = declare_entries;
+    }
+
+    std::unique_ptr<Interface>
+    Interface::create(const std::string &name, WorldBuilder::World *world)
+    {
+      std::string lower_case_name;
+      std::transform(name.begin(),
+                     name.end(),
+                     std::back_inserter(lower_case_name),
+                     ::tolower);;
+
+      // Have a nice assert message to check whether a plugin exists in the case
+      // of a debug compilation.
+      WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
+                    "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
+                    "The size of factories is " << get_factory_map().size() << ".");
+
+      // Using at() because the [] will just insert values
+      // which is undesirable in this case. An exception is
+      // thrown when the name is not present.
+      return get_factory_map().at(lower_case_name)->create(world);
+    }
+  } // namespace GravityModel
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/gravity_model/uniform.cc.bak b/contrib/world_builder/source/world_builder/gravity_model/uniform.cc.bak
new file mode 100644
index 00000000000..9978af549c5
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/gravity_model/uniform.cc.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/gravity_model/uniform.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/world.h"
+
+
+namespace WorldBuilder
+{
+  namespace GravityModel
+  {
+    Uniform::Uniform(WorldBuilder::World *world_)
+    {
+      this->world = world_;
+    }
+
+    Uniform::~Uniform()
+      = default;
+
+    void
+    Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
+    {
+      // Add depth method to the required parameters.
+      prm.declare_entry("", Types::Object(),
+                        "Uniform gravity model. It returns the gravity vector in a Cartesian coordinate system at "
+                        "a given position, which has a constant magitude for the whole domain. The vector points "
+                        "down in cartesian coordinates and to the center of the sphere in spherical coordinates.");
+
+      prm.declare_entry("magnitude",
+                        Types::Double(9.81), "The magnitude of the gravity.");
+    }
+
+    void
+    Uniform::parse_entries(Parameters &prm)
+    {
+      gravity_magnitude = prm.get<double>("magnitude");
+    }
+
+
+    Point<3>
+    Uniform::gravity_vector(Point<3> point) const
+    {
+      const CoordinateSystem coordinate_system = world->parameters.coordinate_system->natural_coordinate_system();
+
+      switch (coordinate_system)
+        {
+          case CoordinateSystem::cartesian:
+            return Point<3>(0.,0.,-gravity_magnitude,CoordinateSystem::cartesian);
+            break;
+
+          case CoordinateSystem::spherical:
+            return (point/point.norm())*-gravity_magnitude;
+            break;
+
+          default:
+            WBAssertThrow(false, "Invalid coordinate system when using the gravity vector function.");
+        }
+
+      return Point<3>(NaN::DSNAN,NaN::DSNAN,NaN::DSNAN,CoordinateSystem::invalid);
+    }
+
+
+    double
+    Uniform::gravity_norm(Point<3> /*point*/) const
+    {
+      return gravity_magnitude;
+    }
+
+
+    /**
+     * Register plugin
+     */
+    WB_REGISTER_GRAVITY_MODEL(Uniform, uniform)
+  } // namespace GravityModel
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/kd_tree.cc.bak b/contrib/world_builder/source/world_builder/kd_tree.cc.bak
new file mode 100644
index 00000000000..6f5a8347fc6
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/kd_tree.cc.bak
@@ -0,0 +1,211 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/kd_tree.h"
+#include <algorithm>
+#include <utility>
+
+namespace WorldBuilder
+{
+  namespace KDTree
+  {
+    KDTree::KDTree(std::vector<Node> point_list)
+      : nodes(std::move(std::move(point_list)))
+    {}
+
+
+    void
+    KDTree::create_tree(const size_t left,
+                        const size_t right,
+                        const bool y_axis)
+    {
+      const size_t mid=(left+right)>>1;
+      std::nth_element(nodes.begin()+static_cast<long int>(left),nodes.begin()+static_cast<long int>(mid),nodes.begin()+static_cast<long int>(right)+1,
+                       [y_axis](Node& i, Node& j) -> bool
+      {
+        return i[y_axis] < j[y_axis];
+      });
+
+      if (left<mid)
+        create_tree(left,mid-1,!y_axis);
+      if (right>mid)
+        create_tree(mid+1,right,!y_axis);
+    }
+
+
+    const std::vector<Node> &
+    KDTree::get_nodes() const
+    {
+      return nodes;
+    }
+
+
+    IndexDistance
+    KDTree::find_closest_point(const Point<2> &check_point) const
+    {
+      const size_t start_node_index = 0;
+      IndexDistance index_distance = {start_node_index,
+                                      std::numeric_limits<double>::max()
+                                     };
+
+      find_closest_point_recursive(check_point,0,nodes.size()-1,false,index_distance);
+
+      return index_distance;
+    }
+
+
+    void
+    KDTree::find_closest_point_recursive(const Point<2> &check_point,
+                                         const size_t left,
+                                         const size_t right,
+                                         const bool y_axis,
+                                         IndexDistance &index_distance) const
+    {
+      // Calculate the index of this node
+      const size_t mid=(left+right)>>1;
+      const Node &node = nodes[mid];
+      if (check_point[static_cast<size_t>(y_axis)] < node[y_axis])
+        {
+          // Traverse left child
+          if (left<mid)
+            {
+              find_closest_point_recursive(check_point,left,mid-1,!y_axis,index_distance);
+            }
+
+          // Compare node's point to current closest point
+          const double distance = sqrt((node[false]-check_point[0])*(node[false]-check_point[0])
+                                       +(node[true]-check_point[1])*(node[true]-check_point[1]));
+          if (index_distance.distance > distance)
+            {
+              index_distance.index = mid;
+              index_distance.distance = distance;
+            }
+
+          // Traverse right child
+          if (right>mid)
+            {
+              if ((node[y_axis]-check_point[static_cast<size_t>(y_axis)]) < index_distance.distance)
+                {
+                  find_closest_point_recursive(check_point,mid+1,right,!y_axis,index_distance);
+                }
+            }
+        }
+      else
+        {
+          // Traverse right child
+          if (right>mid)
+            find_closest_point_recursive(check_point,mid+1,right,!y_axis,index_distance);
+
+          // Compare node's point to current closest point
+          const double distance = sqrt((node[false]-check_point[0])*(node[false]-check_point[0])
+                                       +(node[true]-check_point[1])*(node[true]-check_point[1]));
+          if (index_distance.distance > distance)
+            {
+              index_distance.index = mid;
+              index_distance.distance = distance;
+            }
+
+          // Traverse left child
+          if (left<mid)
+            if ((node[y_axis]-check_point[static_cast<size_t>(y_axis)]) < index_distance.distance)
+              find_closest_point_recursive(check_point,left,mid-1,!y_axis,index_distance);
+        }
+    }
+
+
+
+    IndexDistances
+    KDTree::find_closest_points(const Point<2> &check_point) const
+    {
+      const size_t start_node_index = 0;
+      IndexDistances index_distances = {start_node_index,
+                                        std::numeric_limits<double>::max(),
+                                        {}
+                                       };
+      index_distances.vector.reserve(nodes.size());
+
+      find_closest_points_recursive(check_point,0,nodes.size()-1,false,index_distances);
+
+      return index_distances;
+    }
+
+
+    void
+    KDTree::find_closest_points_recursive(const Point<2> &check_point,
+                                          const size_t left,
+                                          const size_t right,
+                                          const bool y_axis,
+                                          IndexDistances &index_distances) const
+    {
+      // Calculate the index of this node
+      const size_t mid=(left+right)>>1;
+      const Node &node = nodes[mid];
+      if (check_point[static_cast<size_t>(y_axis)] < node[y_axis])
+        {
+          // Traverse left child
+          if (left<mid)
+            {
+              find_closest_points_recursive(check_point,left,mid-1,!y_axis,index_distances);
+            }
+
+          // Compare node's point to current closest point
+          const double distance = sqrt((node[false]-check_point[0])*(node[false]-check_point[0])
+                                       +(node[true]-check_point[1])*(node[true]-check_point[1]));
+          if (index_distances.min_distance > distance)
+            {
+              index_distances.min_index = mid;
+              index_distances.min_distance = distance;
+            }
+
+          index_distances.vector.emplace_back(IndexDistance {mid, distance});
+
+          // Traverse right child
+          if (right>mid)
+            {
+              if ((node[y_axis]-check_point[static_cast<size_t>(y_axis)]) < index_distances.min_distance)
+                {
+                  find_closest_points_recursive(check_point,mid+1,right,!y_axis,index_distances);
+                }
+            }
+        }
+      else
+        {
+          // Traverse right child
+          if (right>mid)
+            find_closest_points_recursive(check_point,mid+1,right,!y_axis,index_distances);
+
+          // Compare node's point to current closest point
+          const double distance = sqrt((node[false]-check_point[0])*(node[false]-check_point[0])
+                                       +(node[true]-check_point[1])*(node[true]-check_point[1]));
+          if (index_distances.min_distance > distance)
+            {
+              index_distances.min_index = mid;
+              index_distances.min_distance = distance;
+            }
+
+          index_distances.vector.emplace_back(IndexDistance {mid, distance});
+
+          // Traverse left child
+          if (left<mid)
+            if ((node[y_axis]-check_point[static_cast<size_t>(y_axis)]) < index_distances.min_distance)
+              find_closest_points_recursive(check_point,left,mid-1,!y_axis,index_distances);
+        }
+    }
+  } // namespace KDTree
+} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/objects/bezier_curve.cc.bak b/contrib/world_builder/source/world_builder/objects/bezier_curve.cc.bak
new file mode 100644
index 00000000000..74f3b57393d
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/objects/bezier_curve.cc.bak
@@ -0,0 +1,550 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/assert.h"
+#include "world_builder/nan.h"
+#include "world_builder/objects/bezier_curve.h"
+
+#include <cmath>
+#include <cstddef>
+#include <iomanip>
+#include <limits>
+#include <sstream>
+
+using namespace WorldBuilder;
+
+namespace WorldBuilder
+{
+  namespace Objects
+  {
+    BezierCurve::BezierCurve(const std::vector<Point<2> > &p, const std::vector<double> &angle_constrains_input)
+    {
+      points = p;
+      const size_t n_points = p.size();
+      control_points.resize(n_points-1, {{p[0],p[0]}});
+      lengths.resize(n_points-1,NaN::DSNAN);
+      angles.resize(n_points,NaN::DSNAN);
+      std::vector<double> angle_constrains = angle_constrains_input;
+      angle_constrains.resize(n_points,NaN::DQNAN);
+
+      // if no angle is provided, compute the angle as the average angle between the previous and next point.
+      // The first angle points at the second point and the last angle points at the second to last point.
+      // The check points are set at a distance of 1/10th the line length from the point in the direction of the angle.
+      if (std::isnan(angle_constrains[0]))
+        {
+          Point<2> P1P2 = points[1]-points[0];
+          angles[0] = atan2(P1P2[1],P1P2[0]);
+        }
+      else
+        {
+          angles[0] = angle_constrains[0];
+        }
+
+      for (size_t p_i = 1; p_i < n_points-1; ++p_i)
+        {
+          // first determine the angle
+          if (std::isnan(angle_constrains[p_i]))
+            {
+              // get the average angle
+              const Point<2> P1P2 = points[p_i-1]-points[p_i];
+              const Point<2> P3P2 = points[p_i+1]-points[p_i];
+
+              const double angle_p1p2 = atan2(P1P2[1],P1P2[0]);
+              const double angle_p3p1 = atan2(P3P2[1],P3P2[0]);
+              const double average_angle = (angle_p1p2 + angle_p3p1)*0.5;
+              angles[p_i] = average_angle;
+              angles[p_i] -= Consts::PI*0.5;
+            }
+          else
+            {
+              angles[p_i] = angle_constrains[p_i];
+            }
+
+        }
+
+      if (std::isnan(angle_constrains[n_points-1]))
+        {
+          Point<2> P1P2 = points[n_points-2]-points[n_points-1];
+          angles[n_points-1] =  atan2(P1P2[1],P1P2[0]);
+        }
+      else
+        {
+          angles[n_points-1] = angle_constrains[n_points-1];
+        }
+
+      if (points.size() > 2)
+        {
+          // next determine the location of the control points
+          // the location of the control point is 1/10th p1p2 distance in the direction of the angle.
+          // make sure the angle is pointing away from the next point, e.g.
+          // the check point is on the other side of the of the line p1p2 compared to p3.
+          const double fraction_of_length = 0.2;
+          {
+            const Point<2> &p1 = points[0];
+            const Point<2> &p2 = points[1];
+            const Point<2> &p3 = points[2];
+            const double length = (points[0]-points[1]).norm(); // can be squared
+            control_points[0][0][0] = cos(angles[0])*length*fraction_of_length+p1[0];
+            control_points[0][0][1] = sin(angles[0])*length*fraction_of_length+p1[1];
+            control_points[0][1][0] = cos(angles[1])*length*fraction_of_length+p2[0];
+            control_points[0][1][1] = sin(angles[1])*length*fraction_of_length+p2[1];
+            {
+              const bool side_of_line_1 =  (p1[0] - p2[0]) * (control_points[0][1][1] - p1[1])
+                                           - (p1[1] - p2[1]) * (control_points[0][1][0] - p1[0])
+                                           < 0;
+              const bool side_of_line_2 =  (p1[0] - p2[0]) * (p3[1] - p1[1])
+                                           - (p1[1] - p2[1]) * (p3[0] - p1[0])
+                                           < 0;
+              if (side_of_line_1 == side_of_line_2)
+                {
+                  // use a 180 degree rotated angle to create this control_point
+                  control_points[0][1][0] = cos(angles[1]+Consts::PI)*length*fraction_of_length+p2[0];
+                  control_points[0][1][1] = sin(angles[1]+Consts::PI)*length*fraction_of_length+p2[1];
+                }
+            }
+          }
+
+          for (size_t p_i = 1; p_i < n_points-1; ++p_i)
+            {
+              const Point<2> &p1 = points[p_i];
+              const Point<2> &p2 = points[p_i+1];
+              const double length = (points[p_i]-points[p_i+1]).norm(); // can be squared
+              control_points[p_i][0][0] = cos(angles[p_i])*length*fraction_of_length+p1[0];
+              control_points[p_i][0][1] = sin(angles[p_i])*length*fraction_of_length+p1[1];
+
+              {
+                const bool side_of_line_1 =  (p1[0] - p2[0]) * (control_points[p_i-1][1][1] - p1[1])
+                                             - (p1[1] - p2[1]) * (control_points[p_i-1][1][0] - p1[0])
+                                             < 0;
+                const bool side_of_line_2 =  (p1[0] - p2[0]) * (control_points[p_i][0][1] - p1[1])
+                                             - (p1[1] - p2[1]) * (control_points[p_i][0][0] - p1[0])
+                                             < 0;
+                if (side_of_line_1 == side_of_line_2)
+                  {
+                    // use a 180 degree rotated angle to create this control_point
+                    control_points[p_i][0][0] = cos(angles[p_i]+Consts::PI)*length*fraction_of_length+p1[0];
+                    control_points[p_i][0][1] = sin(angles[p_i]+Consts::PI)*length*fraction_of_length+p1[1];
+                  }
+              }
+
+              control_points[p_i][1][0] = cos(angles[p_i+1])*length*fraction_of_length+points[p_i+1][0];
+              control_points[p_i][1][1] = sin(angles[p_i+1])*length*fraction_of_length+points[p_i+1][1];
+
+              if (p_i+1 < n_points-1)
+                {
+                  const Point<2> &p3 = points[p_i+2];
+                  const bool side_of_line_1 =  (p1[0] - p2[0]) * (control_points[p_i][1][1] - p1[1])
+                                               - (p1[1] - p2[1]) * (control_points[p_i][1][0] - p1[0])
+                                               < 0;
+                  const bool side_of_line_2 =  (p1[0] - p2[0]) * (p3[1] - p1[1])
+                                               - (p1[1] - p2[1]) * (p3[0] - p1[0])
+                                               < 0;
+                  if (side_of_line_1 == side_of_line_2)
+                    {
+                      // use a 180 degree rotated angle to create this control_point
+                      control_points[p_i][1][0] = cos(angles[p_i+1]+Consts::PI)*length*fraction_of_length+p2[0];
+                      control_points[p_i][1][1] = sin(angles[p_i+1]+Consts::PI)*length*fraction_of_length+p2[1];
+                    }
+                }
+            }
+        }
+    }
+
+
+    Point<2>
+    BezierCurve::operator()(const size_t i, const double t) const
+    {
+      WBAssert(i < points.size()-1 && i < control_points.size() ,
+               "Trying to access index " << i << ", but points.size() = " << points.size() << ", and control_points = " << control_points.size() << ".");
+      return (1-t)*(1-t)*(1-t)*points[i] + 3*(1-t)*(1-t)*t*control_points[i][0] + 3.*(1-t)*t*t*control_points[i][1]+t*t*t*points[i+1];
+    }
+
+
+    ClosestPointOnCurve
+    BezierCurve::closest_point_on_curve_segment(const Point<2> &check_point,
+                                                const bool verbose) const
+    {
+      ClosestPointOnCurve closest_point_on_curve;
+      const Point<2> &cp = check_point;
+      double min_squared_distance = std::numeric_limits<double>::infinity();
+      if (check_point.get_coordinate_system() == CoordinateSystem::cartesian)
+        {
+          for ( size_t cp_i = 0; cp_i < control_points.size(); ++cp_i)
+            {
+#ifndef NDEBUG
+              std::stringstream output;
+#endif
+              const Point<2> &p1 = points[cp_i];
+              const Point<2> &p2 = points[cp_i+1];
+              //min_squared_distance = std::min(std::min(min_squared_distance,(check_point-p1).norm_square()),(check_point-p1).norm_square());
+
+              // Getting an estimate for where the closest point is with a linear approximation
+              const Point<2> P1P2 = p2-p1;
+              const Point<2> P1Pc = check_point-p1;
+
+              const double P2P2_dot = P1P2*P1P2;
+
+              double est =  P2P2_dot > 0.0 ? std::min(1.,std::max(0.,(P1Pc*P1P2) / P2P2_dot)) : 1.0; // est=estimate of solution
+              bool found = false;
+
+              // based on https://stackoverflow.com/questions/2742610/closest-point-on-a-cubic-bezier-curve
+              const double a_0 = 3.*control_points[cp_i][0][0]-3.*control_points[cp_i][1][0]+points[cp_i+1][0]-points[cp_i][0];
+              const double a_1 = 3.*control_points[cp_i][0][1]-3.*control_points[cp_i][1][1]+points[cp_i+1][1]-points[cp_i][1];
+              const double b_0 = 3.*points[cp_i][0] - 6.*control_points[cp_i][0][0]+3.*control_points[cp_i][1][0];
+              const double b_1 = 3.*points[cp_i][1] - 6.*control_points[cp_i][0][1]+3.*control_points[cp_i][1][1];
+              const double c_0 = -3.*points[cp_i][0] + 3.*control_points[cp_i][0][0];
+              const double c_1 = -3.*points[cp_i][1] + 3.*control_points[cp_i][0][1];
+              const double d_0 = points[cp_i][0];
+              const double d_1 = points[cp_i][1];
+
+              const double d_min_cp_0 = d_0-cp[0];
+              const double d_min_cp_1 = d_1-cp[1];
+
+#ifndef NDEBUG
+              double estimate_point_min_cp_0_dg = a_0*est*est*est+b_0*est*est+c_0*est+d_min_cp_0;
+              double estimate_point_min_cp_1_dg = a_1*est*est*est+b_1*est*est+c_1*est+d_min_cp_1;
+              double min_squared_distance_cartesian_temp_dg = (estimate_point_min_cp_0_dg*estimate_point_min_cp_0_dg)+(estimate_point_min_cp_1_dg*estimate_point_min_cp_1_dg);
+#endif
+
+              for (size_t newton_i = 0; newton_i < 150; newton_i++)
+                {
+#ifndef NDEBUG
+                  output << "  wolfram alpha: (" << a_0 << "*x^3+" << b_0 << "*x^2+"<< c_0 << "*x+" << d_0 << "-" << cp[0] << ")^2+(" << a_1 << "*x^3+" << b_1 << "*x^2+"<< c_1 << "*x+" << d_1 << "-" << cp[1] << ")^2 with x=" << est << std::endl;
+#endif
+                  const double est_sq = est*est;
+                  const double estimate_point_min_cp_0 = a_0*est_sq*est+b_0*est_sq+c_0*est+d_min_cp_0;
+                  const double estimate_point_min_cp_1 = a_1*est_sq*est+b_1*est_sq+c_1*est+d_min_cp_1;
+
+                  const double deriv_0 = 3.0*a_0*est_sq+2.0*b_0*est+c_0;
+                  const double deriv_1 = 3.0*a_1*est_sq+2.0*b_1*est+c_1;
+                  const double squared_distance_cartesian = (estimate_point_min_cp_0*estimate_point_min_cp_0)+(estimate_point_min_cp_1*estimate_point_min_cp_1);
+
+                  const double squared_distance_cartesian_derivative = 2.0*(deriv_0*estimate_point_min_cp_0 + deriv_1*estimate_point_min_cp_1);
+                  const double squared_distance_cartesian_second_derivative_abs  = std::fabs(2.0*((6.0*a_0*est+2.0*b_0)*estimate_point_min_cp_0 + deriv_0*deriv_0
+                                                                                                  + (6.0*a_1*est+2.0*b_1)*estimate_point_min_cp_1 + deriv_1*deriv_1));
+
+                  if (squared_distance_cartesian_second_derivative_abs <= 0.0)
+                    {
+                      found = true;
+                      break;
+                    }
+
+                  // the local minimum is where  squared_distance_cartesian_derivative=0 and squared_distance_cartesian_derivative>=0
+                  const double update = std::min(0.5,std::max(-0.5,squared_distance_cartesian_derivative/squared_distance_cartesian_second_derivative_abs));
+                  double line_search = 1.;
+
+                  if (std::fabs(update) > 1e-1)
+                    {
+                      double est_test = est-update*line_search;
+                      double squared_distance_cartesian_test = squared_distance_cartesian;
+                      double squared_distance_cartesian_test_previous = squared_distance_cartesian;
+
+                      for (unsigned int i = 0; i < 10; i++)
+                        {
+                          est_test = est-update*line_search;
+                          const double est_test_sq = est_test*est_test;
+                          const double estimate_point_min_cp_test_0 = a_0*est_test_sq*est_test+b_0*est_test_sq+c_0*est_test+d_min_cp_0;
+                          const double estimate_point_min_cp_test_1 = a_1*est_test_sq*est_test+b_1*est_test_sq+c_1*est_test+d_min_cp_1;
+
+                          squared_distance_cartesian_test = (estimate_point_min_cp_test_0*estimate_point_min_cp_test_0)+(estimate_point_min_cp_test_1*estimate_point_min_cp_test_1);
+
+#ifndef NDEBUG
+                          const Point<2> a = 3.*control_points[cp_i][0]-3.*control_points[cp_i][1]+points[cp_i+1]-points[cp_i];
+                          const Point<2> b = 3.*points[cp_i] - 6.*control_points[cp_i][0]+3.*control_points[cp_i][1];
+                          const Point<2> c = -3.*points[cp_i] + 3.*control_points[cp_i][0];
+                          const Point<2> d = points[cp_i];
+                          const double squared_distance_cartesian_derivative_test = 2.0*(3.0*a_0*est_test*est_test+2.0*b_0*est_test+c_0)*(a_0*est_test*est_test*est_test+b_0*est_test*est_test+c_0*est_test+d_0-cp[0])
+                                                                                    + 2.0*(3.0*a_1*est_test*est_test+2.0*b_1*est_test+c_1)*(a_1*est_test*est_test*est_test+b_1*est_test*est_test+c_1*est_test+d_1-cp[1]);
+                          const double squared_distance_cartesian_second_derivative_test = 2.0*(6.0*a_0*est_test + 2.0*b_0)*(a_0*est_test*est_test*est_test+b_0*est_test*est_test+c_0*est_test+d_0-cp[0])
+                                                                                           + 2.0*(3.0*a_0*est_test*est_test + 2.0*b_0*est_test + c_0)*(3.0*a_0*est_test*est_test + 2.0*b_0*est_test + c_0)
+                                                                                           + 2.0*(6.0*a_1*est_test + 2.0*b_1)*(a_1*est_test*est_test*est_test+b_1*est_test*est_test+c_1*est_test+d_1-cp[1])
+                                                                                           + 2.0*(3.0*a_1*est_test*est_test + 2.0*b_1*est_test + c_1)*(3.0*a_1*est_test*est_test + 2.0*b_1*est_test + c_1) ;
+                          output << "    i: " << cp_i << ", ni: " << newton_i<< ", lsi: " << i << ", line_search_step=" << 2./3. << ": squared_distance_cartesian_test = " << squared_distance_cartesian_test << ", diff= " << squared_distance_cartesian_test-squared_distance_cartesian
+                                 << ", tests: " << (squared_distance_cartesian_test_previous < squared_distance_cartesian ? "true" : "false") << ":" << (squared_distance_cartesian_test > squared_distance_cartesian_test_previous ? "true" : "false") << ", est_test=" << est_test
+                                 << ", update=" << update << ", ls=" << line_search << ", up*ls=" << update *line_search << ", test deriv =" << squared_distance_cartesian_derivative_test  << ", test update=" << squared_distance_cartesian_derivative_test/fabs(squared_distance_cartesian_second_derivative_test)
+                                 << ", p1=" << p1 << ", p2= " << p2 << ", poc= " << a *est_test *est_test *est_test + b *est_test *est_test+c *est_test+d << ", cp= " <<  check_point << ", ds:" << ((a*est_test*est_test*est_test+b*est_test*est_test+c*est_test+d)-check_point).norm_square() << ":" << min_squared_distance_cartesian_temp_dg
+                                 << ", diff = " << squared_distance_cartesian_test-min_squared_distance_cartesian_temp_dg << std::endl;
+#endif
+                          if (i > 0 && (squared_distance_cartesian_test > squared_distance_cartesian_test_previous))
+                            {
+                              if (squared_distance_cartesian_test_previous-squared_distance_cartesian < 0)
+                                {
+                                  line_search *= 3./2.;
+                                  break;
+                                }
+                            }
+                          squared_distance_cartesian_test_previous = squared_distance_cartesian_test;
+
+                          line_search *=  2./3.;
+                        }
+                    }
+
+                  est -= update*line_search;
+
+                  if (std::fabs(update) < 1e-4 || est < -0.1 || est > 1.1)
+                    {
+                      found = true;
+                      break;
+                    }
+                }
+#ifndef NDEBUG
+              WBAssertThrow(found, "Could not find a good solution. " << output.str());
+#else
+              WBAssertThrow(found, "Could not find a good solution. Enable debug mode for more info.");
+#endif
+
+              const double est_min_cp_end_0 = a_0*est*est*est+b_0*est*est+c_0*est+d_min_cp_0;
+              const double est_min_cp_end_1 = a_1*est*est*est+b_1*est*est+c_1*est+d_min_cp_1;
+              const double min_squared_distance_temp = (est_min_cp_end_0*est_min_cp_end_0)+(est_min_cp_end_1*est_min_cp_end_1);
+              if (min_squared_distance_temp < min_squared_distance)
+                {
+                  if (est >= -1e-8 && static_cast<double>(cp_i)+est > 0 && est-1. <= 1e-8 && est-1. < static_cast<double>(cp_i))
+                    {
+                      min_squared_distance = min_squared_distance_temp;
+                      const Point<2> point_on_curve = Point<2>(a_0*est*est*est+b_0*est*est+c_0*est+d_0,a_1*est*est*est+b_1*est*est+c_1*est+d_1,cp.get_coordinate_system());
+                      WBAssert(!std::isnan(point_on_curve[0]) && !std::isnan(point_on_curve[1]), "Point on curve has NAN entries: " << point_on_curve);
+                      // the sign is rotating the derivative by 90 degrees.
+                      // When moving in the direction of increasing t, left is positive and right is negative.
+                      // https://www.wolframalpha.com/input?i=d%2Fdt+%281-t%29*%281-t%29*%281-t%29*a+%2B+3*%281-t%29*%281-t%29*t*b+%2B+3.*%281-t%29*t*t*c%2Bt*t*t*d
+                      const Point<2> derivative_point = points[cp_i]*((6.-3.*est)*est-3.) + control_points[cp_i][0]*(est*(9*est-12)+3)
+                                                        + control_points[cp_i][1]*(6.-9.*est)*est + points[cp_i+1]*3.*est*est;
+
+                      Point<2> tangent_point = derivative_point - point_on_curve;
+                      // if angle between check point and tangent point is larger than 90 degrees, return a negative distance
+                      const double dot_product = (tangent_point*(check_point-point_on_curve));
+                      const double sign = dot_product < 0. ? -1. : 1.;
+                      tangent_point = Point<2>(-tangent_point[1],tangent_point[0],tangent_point.get_coordinate_system());
+
+                      closest_point_on_curve.distance = sign*std::sqrt(min_squared_distance);
+                      closest_point_on_curve.parametric_fraction = est;
+                      closest_point_on_curve.interpolation_fraction = NaN::DSNAN; //arc_length(i,real_roots[root_i])/lengths[i];
+                      closest_point_on_curve.index = cp_i;
+                      closest_point_on_curve.point = point_on_curve;
+                      WBAssert(!std::isnan(point_on_curve[0]) && !std::isnan(point_on_curve[1]), "Point on curve has NAN entries: " << point_on_curve);
+                      Point<2> normal = point_on_curve;
+                      {
+                        Point<2> derivative = Point<2>(a_0*est*est+b_0*est+c_0,a_1*est*est+b_1*est+c_1,cp.get_coordinate_system());
+                        normal=derivative;
+                        const double normal_size = derivative.norm();
+                        if (normal_size > 0.)
+                          {
+                            normal[0] = derivative[1]/normal_size;
+                            normal[1] = -derivative[0]/normal_size;
+                          }
+                      }
+                      closest_point_on_curve.normal = normal;
+                    }
+                }
+            }
+        }
+      else
+        {
+          const double cos_cp_lat = cos(cp[1]);
+          for ( size_t cp_i = 0; cp_i < control_points.size(); ++cp_i)
+            {
+              const Point<2> &p1 = points[cp_i];
+              const Point<2> &p2 = points[cp_i+1];
+              // Getting an estimate for where the closest point is with a linear approximation
+              const Point<2> P1P2 = p2-p1;
+              const Point<2> P1Pc = check_point-p1;
+
+              const double P2P2_dot = P1P2*P1P2;
+
+              double est =  P2P2_dot > 0.0 ? std::min(1.,std::max(0.,(P1Pc*P1P2) / P2P2_dot)) : 1.0; // est=estimate of solution
+              bool found = false;
+
+              // only used if verbose is true
+              std::stringstream output;
+
+              Point<2> a = 3.*control_points[cp_i][0]-3.*control_points[cp_i][1]+points[cp_i+1]-points[cp_i];
+              Point<2> b = 3.*points[cp_i] - 6.*control_points[cp_i][0]+3.*control_points[cp_i][1];
+              Point<2> c = -3.*points[cp_i] + 3.*control_points[cp_i][0];
+              const Point<2> d = points[cp_i];
+
+              Point<2> estimate_point = a*est*est*est+b*est*est+c*est+d;
+
+              double cos_lat_dg = NaN::DSNAN;
+              double sin_d_long_h_dg = NaN::DSNAN;
+              double sin_d_lat_h_dg = NaN::DSNAN;
+              double min_squared_distance_cartesian_temp_dg = NaN::DSNAN;
+              if (verbose == true)
+                {
+                  cos_lat_dg = cos(estimate_point[1]);
+                  sin_d_long_h_dg = sin((estimate_point[0]-cp[0])*0.5);
+                  sin_d_lat_h_dg = sin((estimate_point[1]-cp[1])*0.5);
+                  min_squared_distance_cartesian_temp_dg = sin_d_lat_h_dg*sin_d_lat_h_dg+sin_d_long_h_dg*sin_d_long_h_dg*cos_cp_lat*cos_lat_dg;
+                  output << "cp_i=" << cp_i << ", init est = " << est << ", min_squared_distance = " << min_squared_distance << ", min_squared_distance_cartesian_temp_dg: " << min_squared_distance_cartesian_temp_dg << ", p1: " << p1 << ", p2: " << p2 << std::endl;
+                  output  << std::setprecision(6) << "  wolfram: sin((" << a[1] << "*x^3+" << b[1] << "*x^2+"<< c[1] << "*x+" << d[1] << "-" << cp[1] << ")*.5)^2+sin((" << a[0] << "*x^3+" << b[0] << "*x^2+"<< c[0] << "*x+" << d[0] << "-" << cp[0] << ")*.5)^2*cos(" << cp[1] << ")*cos(" << a[1] << "*x^3+" << b[1] << "*x^2+"<< c[1] << "*x+" << d[1] << "-" << cp[1] << ") with x=" << est << std::endl;
+                  output  << std::setprecision(10) << "  python: y=np.sin((" << a[1] << "*x**3+" << b[1] << "*x**2+"<< c[1] << "*x+" << d[1] << "-" << cp[1] << ")*.5)**2+np.sin((" << a[0] << "*x**3+" << b[0] << "*x**2+"<< c[0] << "*x+" << d[0] << "-" << cp[0] << ")*.5)**2*np.cos(" << cp[1] << ")*np.cos(" << a[1] << "*x**3+" << b[1] << "*x**2+"<< c[1] << "*x+" << d[1] << "-" << cp[1] << "); x=" << est << std::endl;
+                }
+              for (size_t newton_i = 0; newton_i < 150; newton_i++)
+                {
+                  // based on https://stackoverflow.com/questions/2742610/closest-point-on-a-cubic-bezier-curve
+                  estimate_point = a*est*est*est+b*est*est+c*est+d;
+
+                  double sin_d_long_h = sin((estimate_point[0]-cp[0])*0.5);
+                  double sin_d_lat_h = sin((estimate_point[1]-cp[1])*0.5);
+                  const double cos_d_lat = cos(estimate_point[1]-cp[1]);
+                  const double squared_distance_cartesian = sin_d_lat_h*sin_d_lat_h+sin_d_long_h*sin_d_long_h*cos_cp_lat*cos_d_lat;
+
+                  double sin_dlat = sin(estimate_point[1]-cp[1]);
+                  const double cos_dlong_h = cos(0.5*(estimate_point[0]-cp[0]));
+                  double cos_dlat_h = cos(0.5*(estimate_point[1]-cp[1]));
+                  double deriv_long = (3.0*a[0]*est*est+2.0*b[0]*est+c[0]);
+                  double deriv_lat = (3.0*a[1]*est*est+2.0*b[1]*est+c[1]);
+
+                  const double squared_distance_cartesian_derivative = cos_cp_lat*(-deriv_lat)*sin_d_long_h*sin_d_long_h*sin_dlat+cos_cp_lat*deriv_long*sin_d_long_h*cos_dlong_h*cos_d_lat+deriv_lat*sin_d_lat_h*cos_dlat_h;
+                  double update = NaN::DSNAN;
+                  if (std::fabs(squared_distance_cartesian_derivative) > 1e-15)
+                    {
+                      const double squared_distance_cartesian_second_derivative = cos_cp_lat*cos_d_lat*(-0.5*deriv_long*deriv_long*sin_d_long_h*sin_d_long_h+0.5*deriv_long*deriv_long*cos_dlong_h*cos_dlong_h+(6.0*a[0]*est+2.0*b[0])*sin_d_long_h*cos_dlong_h)+cos_cp_lat*sin_d_long_h*sin_d_long_h*(deriv_lat*deriv_lat*(-cos_d_lat)-(6.0*a[1]*est+2.0*b[1])*sin_dlat)-2.0*cos_cp_lat*deriv_long*deriv_lat*sin_d_long_h*cos_dlong_h*sin_dlat-0.5*deriv_lat*deriv_lat*sin_d_lat_h*sin_d_lat_h+0.5*deriv_lat*deriv_lat*cos_dlat_h*cos_dlat_h+(6.0*a[1]*est+2.0*b[1])*sin_d_lat_h*cos_dlat_h;
+
+                      if (verbose == true)
+                        {
+                          const double squared_distance_cartesian_full = sin((a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])*0.5)*sin((a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])*0.5)+sin((a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0])*0.5)*sin((a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0])*0.5)*cos(cp[1])*cos(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]);
+                          const double squared_distance_cartesian_derivative_full = cos(cp[1])*(-(3.0*a[1]*est*est+2.0*b[1]*est+c[1]))*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])+cos(cp[1])*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])+(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*sin(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))*cos(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]));
+                          const double squared_distance_cartesian_second_derivative_full = cos(cp[1])*cos(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])*(-0.5*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))+0.5*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))+(6.0*a[0]*est+2.0*b[0])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0])))+cos(cp[1])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*((3.0*a[1]*est*est+2.0*b[1]*est+c[1])*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*(-cos(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))-(6.0*a[1]*est+2.0*b[1])*sin(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))-2.0*cos(cp[1])*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])-0.5*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*sin(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))*sin(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))+0.5*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*cos(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))*cos(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))+(6.0*a[1]*est+2.0*b[1])*sin(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))*cos(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]));
+                          output <<"sqd = " << squared_distance_cartesian <<":" << squared_distance_cartesian_full << ", diff=" << squared_distance_cartesian-squared_distance_cartesian_full << ", sqdd: " << squared_distance_cartesian_derivative <<":" << squared_distance_cartesian_derivative_full << ", diff="<< squared_distance_cartesian_derivative-squared_distance_cartesian_derivative_full << ", sqdd: " << squared_distance_cartesian_second_derivative << ":" << squared_distance_cartesian_second_derivative_full << ", diff= " << squared_distance_cartesian_second_derivative-squared_distance_cartesian_second_derivative_full << ", est: " << est << std::endl;
+                        }
+                      // the local minimum is where  squared_distance_cartesian_derivative=0 and squared_distance_cartesian_derivative>=0
+                      update = std::min(0.5,std::max(-0.5,squared_distance_cartesian_derivative/std::fabs(squared_distance_cartesian_second_derivative)));
+                      double line_search = 1.;
+                      double est_test = est-update*line_search;
+                      double squared_distance_cartesian_test = squared_distance_cartesian;
+                      double squared_distance_cartesian_test_previous = squared_distance_cartesian;
+                      double line_search_step = 2./3.;
+
+                      for (unsigned int i = 0; i < 10; i++)
+                        {
+                          est_test = est-update*line_search;
+                          estimate_point = a*est_test*est_test*est_test+b*est_test*est_test+c*est_test+d;
+
+                          sin_d_long_h = sin((estimate_point[0]-cp[0])*0.5);
+                          sin_d_lat_h = sin((estimate_point[1]-cp[1])*0.5);
+                          squared_distance_cartesian_test = sin_d_lat_h*sin_d_lat_h+sin_d_long_h*sin_d_long_h*cos_cp_lat*cos(estimate_point[1]-cp[1]);
+
+                          if (verbose == true)
+                            {
+                              sin_dlat = sin(estimate_point[1]-cp[1]);
+                              deriv_long = (3.0*a[0]*est_test*est_test+2.0*b[0]*est_test+c[0]);
+                              deriv_lat = (3.0*a[1]*est_test*est_test+2.0*b[1]*est_test+c[1]);
+                              const double squared_distance_cartesian_derivative_test = cos_cp_lat*(-deriv_lat)*sin_d_long_h*sin_d_long_h*sin_dlat+cos_cp_lat*deriv_long*sin_d_long_h*cos_dlong_h*cos_d_lat+deriv_lat*sin_d_lat_h*cos_dlat_h;
+                              const double squared_distance_cartesian_second_derivative_test = cos_cp_lat*cos_d_lat*(-0.5*deriv_long*deriv_long*sin_d_long_h*sin_d_long_h+0.5*deriv_long*deriv_long*cos_dlong_h*cos_dlong_h+(6.0*a[0]*est_test+2.0*b[0])*sin_d_long_h*cos_dlong_h)+cos_cp_lat*sin_d_long_h*sin_d_long_h*(deriv_lat*deriv_lat*(-cos_d_lat)-(6.0*a[1]*est_test+2.0*b[1])*sin_dlat)-2.0*cos_cp_lat*deriv_long*deriv_lat*sin_d_long_h*cos_dlong_h*sin_dlat-0.5*deriv_lat*deriv_lat*sin_d_lat_h*sin_d_lat_h+0.5*deriv_lat*deriv_lat*cos_dlat_h*cos_dlat_h+(6.0*a[1]*est_test+2.0*b[1])*sin_d_lat_h*cos_dlat_h;
+                              output << "    i: " << cp_i << ", ni: " << newton_i<< ", lsi: " << i << ", line_search_step=" << line_search_step << ": squared_distance_cartesian_test = " << squared_distance_cartesian_test << ", diff= " << squared_distance_cartesian_test-squared_distance_cartesian << ", tests: " << (squared_distance_cartesian_test_previous < squared_distance_cartesian ? "true" : "false") << ":" << (squared_distance_cartesian_test > squared_distance_cartesian_test_previous ? "true" : "false") << ", est_test=" << est_test << ", update=" << update << ", ls=" << line_search << ", up*ls=" << update *line_search << ", test deriv =" << squared_distance_cartesian_derivative_test  << ", test update=" << squared_distance_cartesian_derivative_test/fabs(squared_distance_cartesian_second_derivative_test) << ", p1=" << p1 << ", p2= " << p2 << ", poc= " << a *est_test *est_test *est_test+b *est_test *est_test+c *est_test+d << ", cp= " <<  check_point << ", ds:" << ((a*est_test*est_test*est_test+b*est_test*est_test+c*est_test+d)-check_point).norm_square() << ":" << min_squared_distance_cartesian_temp_dg << ", diff = " << squared_distance_cartesian_test-min_squared_distance_cartesian_temp_dg<< std::endl;
+                            }
+                          if (i > 0 && (squared_distance_cartesian_test > squared_distance_cartesian_test_previous))
+                            {
+                              if (squared_distance_cartesian_test_previous-squared_distance_cartesian < 0)
+                                {
+                                  line_search *= 1/line_search_step;
+                                  break;
+                                }
+                              if (i> 1)
+                                {
+                                  line_search *= (1/line_search_step)*(1/line_search_step);
+                                  est_test = est-update*line_search;
+                                  estimate_point = a*est_test*est_test*est_test+b*est_test*est_test+c*est_test+d;
+
+                                  sin_d_long_h = sin((estimate_point[0]-cp[0])*0.5);
+                                  sin_d_lat_h = sin((estimate_point[1]-cp[1])*0.5);
+                                  squared_distance_cartesian_test_previous = sin_d_lat_h*sin_d_lat_h+sin_d_long_h*sin_d_long_h*cos_cp_lat*cos(estimate_point[1]-cp[1]);
+                                  line_search_step = std::min(line_search_step*(11./10.),0.95);
+                                  continue;
+                                }
+                            }
+                          squared_distance_cartesian_test_previous = squared_distance_cartesian_test;
+
+                          line_search *= line_search_step;
+                        }
+                      if (verbose == true)
+                        {
+                          output << "    i: " << cp_i << ", ni: " << newton_i<< ", est= " << est-update *line_search << ", ls:" << line_search << ": squared_distance_cartesian_test = " << squared_distance_cartesian_test << ", diff= " << squared_distance_cartesian_test-squared_distance_cartesian << std::endl;
+                        }
+                      est -= update*line_search;
+                    }
+
+                  if (std::fabs(squared_distance_cartesian_derivative) <= 1e-15 || std::fabs(update) < 1e-4 || est < -0.1 || est > 1.1)
+                    {
+                      found = true;
+                      break;
+                    }
+                }
+
+              if (verbose == true && found == false)
+                {
+                  // report the error and print the output
+                  WBAssertThrow(found, "Could not find a good solution. " << output.str());
+                }
+              else if (verbose == false && found == false)
+                {
+                  // redo the iteration with verbose=true to be able to report the error
+                  return closest_point_on_curve_segment(check_point, true);
+                }
+
+              estimate_point = a*est*est*est+b*est*est+c*est+d;
+
+              const double sin_d_long_h = sin((estimate_point[0]-cp[0])*0.5);
+              const double sin_d_lat_h = sin((estimate_point[1]-cp[1])*0.5);
+
+              const double min_squared_distance_cartesian_temp = sin_d_lat_h*sin_d_lat_h+sin_d_long_h*sin_d_long_h*cos_cp_lat*cos(estimate_point[1]-cp[1]);
+
+              if (min_squared_distance_cartesian_temp < min_squared_distance)
+                {
+                  if (est >= -1e-8 && static_cast<double>(cp_i)+est > 0 && est-1. <= 1e-8 && est-1. < static_cast<double>(cp_i))
+                    {
+                      min_squared_distance = min_squared_distance_cartesian_temp;
+                      const Point<2> point_on_curve = a*est*est*est+b*est*est+c*est+d;
+
+                      // the sign is rotating the derivative by 90 degrees.
+                      // When moving in the direction of increasing t, left is positive and right is negative.
+                      // https://www.wolframalpha.com/input?i=d%2Fdt+%281-t%29*%281-t%29*%281-t%29*a+%2B+3*%281-t%29*%281-t%29*t*b+%2B+3.*%281-t%29*t*t*c%2Bt*t*t*d
+                      const Point<2> derivative_point = points[cp_i]*((6.-3.*est)*est-3.) + control_points[cp_i][0]*(est*(9*est-12)+3)
+                                                        + control_points[cp_i][1]*(6.-9.*est)*est + points[cp_i+1]*3.*est*est;
+
+                      Point<2> tangent_point = derivative_point - point_on_curve;
+                      // if angle between check point and tangent point is larger than 90 degrees, return a negative distance
+                      const double dot_product = (tangent_point*(check_point-point_on_curve));
+                      const double sign = dot_product < 0. ? -1. : 1.;
+                      tangent_point = Point<2>(-tangent_point[1],tangent_point[0],tangent_point.get_coordinate_system());
+
+                      closest_point_on_curve.distance = sign*std::sqrt(min_squared_distance);
+                      closest_point_on_curve.parametric_fraction = est;
+                      closest_point_on_curve.interpolation_fraction = NaN::DSNAN; //arc_length(i,real_roots[root_i])/lengths[i];
+                      closest_point_on_curve.index = cp_i;
+                      closest_point_on_curve.point = point_on_curve;
+                      Point<2> normal = point_on_curve;
+                      {
+                        Point<2> derivative = a*est*est+b*est+c;
+                        normal=derivative;
+                        const double normal_size = derivative.norm();
+                        if (normal_size > 0.)
+                          {
+                            normal[0] = derivative[1]/normal_size;
+                            normal[1] = -derivative[0]/normal_size;
+                          }
+                      }
+                      closest_point_on_curve.normal = normal;
+                    }
+                }
+            }
+
+        }
+      return closest_point_on_curve;
+    }
+  } // namespace Objects
+} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/objects/distance_from_surface.cc.bak b/contrib/world_builder/source/world_builder/objects/distance_from_surface.cc.bak
new file mode 100644
index 00000000000..5024c3692da
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/objects/distance_from_surface.cc.bak
@@ -0,0 +1,36 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/objects/distance_from_surface.h"
+
+namespace WorldBuilder
+{
+  namespace Objects
+  {
+    double PlaneDistances::get_distance_from_surface() const
+    {
+      return this->distance_from_surface;
+    }
+
+    double PlaneDistances::get_distance_along_surface() const
+    {
+      return this->distance_along_surface;
+    }
+  } // namespace Objects
+} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/objects/natural_coordinate.cc.bak b/contrib/world_builder/source/world_builder/objects/natural_coordinate.cc.bak
new file mode 100644
index 00000000000..b02ddc9beb1
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/objects/natural_coordinate.cc.bak
@@ -0,0 +1,121 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/objects/natural_coordinate.h"
+
+namespace WorldBuilder
+{
+  namespace Objects
+  {
+    NaturalCoordinate::NaturalCoordinate(const std::array<double,3> &position,
+                                         const CoordinateSystems::Interface &coordinate_system_)
+    {
+      coordinate_system = coordinate_system_.natural_coordinate_system();
+      coordinates = coordinate_system_.cartesian_to_natural_coordinates(position);
+    }
+
+
+    // todo, should be possible to make this without the interface, since the Point knows the coord system.
+    NaturalCoordinate::NaturalCoordinate(const Point<3> &position,
+                                         const CoordinateSystems::Interface &coordinate_system_)
+    {
+      coordinate_system = coordinate_system_.natural_coordinate_system();
+      coordinates = coordinate_system_.cartesian_to_natural_coordinates(position.get_array());
+    }
+
+
+    const std::array<double,3> &NaturalCoordinate::get_coordinates() const
+    {
+      return coordinates;
+    }
+
+
+    std::array<double,2> NaturalCoordinate::get_surface_coordinates() const
+    {
+      std::array<double,2> coordinate;
+
+      switch (coordinate_system)
+        {
+          case CoordinateSystem::cartesian:
+            coordinate[0] = coordinates[0];
+            coordinate[1] = coordinates[1];
+            break;
+
+          case CoordinateSystem::spherical:
+            coordinate[0] = coordinates[1];
+            coordinate[1] = coordinates[2];
+            break;
+
+          default:
+            WBAssertThrow (false, "Coordinate system not implemented.");
+        }
+
+      return coordinate;
+    }
+
+
+    Point<2> NaturalCoordinate::get_surface_point() const
+    {
+      Point<2> coordinate(0,0,coordinate_system);
+
+      switch (coordinate_system)
+        {
+          case CoordinateSystem::cartesian:
+            coordinate[0] = coordinates[0];
+            coordinate[1] = coordinates[1];
+            break;
+
+          case CoordinateSystem::spherical:
+            coordinate[0] = coordinates[1];
+            coordinate[1] = coordinates[2];
+            break;
+
+          default:
+            WBAssertThrow (false, "Coordinate system not implemented.");
+        }
+
+      return coordinate;
+    }
+
+
+    CoordinateSystem
+    NaturalCoordinate::get_coordinate_system() const
+    {
+      return coordinate_system;
+    }
+
+
+    double &NaturalCoordinate::get_ref_depth_coordinate()
+    {
+      switch (coordinate_system)
+        {
+          case CoordinateSystem::cartesian:
+            return coordinates[2];
+
+          case CoordinateSystem::spherical:
+            return coordinates[0];
+
+          default:
+            WBAssertThrow (false, "Coordinate system not implemented.");
+        }
+
+      return coordinates[2];
+    }
+  } // namespace Objects
+} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/objects/segment.cc.bak b/contrib/world_builder/source/world_builder/objects/segment.cc.bak
new file mode 100644
index 00000000000..368a034ad52
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/objects/segment.cc.bak
@@ -0,0 +1,126 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include <utility>
+
+#include "world_builder/objects/segment.h"
+
+
+namespace WorldBuilder
+{
+
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace FaultModels
+    namespace SubductingPlateModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace SubductingPlateModels
+  }  // namespace Features
+
+
+  namespace Objects
+  {
+    // todo update function
+    template<class A, class B, class C>
+    Segment<A,B,C>::Segment(const double default_length_,
+                            const WorldBuilder::Point<2> &default_thickness_,
+                            const WorldBuilder::Point<2> &default_top_truncation_,
+                            const WorldBuilder::Point<2> &default_angle_,
+                            const std::vector<std::shared_ptr<A> > temperature_systems_,
+                            const std::vector<std::shared_ptr<B> > composition_systems_,
+                            const std::vector<std::shared_ptr<C> > grains_systems_)
+      :
+      value_length(default_length_),
+      default_length(default_length_),
+      value_thickness(default_thickness_),
+      value_top_truncation(default_top_truncation_),
+      value_angle(default_angle_),
+      temperature_systems(std::move(temperature_systems_)),
+      composition_systems(std::move(composition_systems_)),
+      grains_systems(std::move(grains_systems_))
+    {
+    }
+
+    template<class A, class B, class C>
+    Segment<A,B,C>::Segment(Segment const &other)
+      :
+      value_length(other.value_length),
+      default_length(other.default_length),
+      value_thickness(other.value_thickness),
+      value_top_truncation(other.value_top_truncation),
+      value_angle(other.value_angle),
+      temperature_systems(other.temperature_systems),
+      composition_systems(other.composition_systems),
+      grains_systems(other.grains_systems)
+    {
+    }
+
+    template<class A, class B, class C>
+    Segment<A,B,C>::~Segment ()
+      = default;
+
+
+    /**
+    * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+    * Note that the variable with this name has to be loaded before this function is called.
+    */
+    template class
+    Segment<Features::SubductingPlateModels::Temperature::Interface,Features::SubductingPlateModels::Composition::Interface,Features::SubductingPlateModels::Grains::Interface>;
+
+    /**
+    * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+    * Note that the variable with this name has to be loaded before this function is called.
+    */
+    template class
+    Segment<Features::FaultModels::Temperature::Interface,Features::FaultModels::Composition::Interface,Features::FaultModels::Grains::Interface>;
+
+    /**
+    * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+    * Note that the variable with this name has to be loaded before this function is called.
+    */
+    //template class
+    //Segment<char,char>;
+
+  } // namespace Objects
+} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/objects/surface.cc.bak b/contrib/world_builder/source/world_builder/objects/surface.cc.bak
new file mode 100644
index 00000000000..e509703313c
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/objects/surface.cc.bak
@@ -0,0 +1,227 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/assert.h"
+#include "world_builder/objects/surface.h"
+
+#include <iostream>
+
+#include "delaunator-cpp/delaunator.hpp"
+
+
+namespace WorldBuilder
+{
+  namespace Objects
+  {
+
+    namespace
+    {
+      /**
+       * Test whether a point is in a triangle. If that is the case is stores the interpolated
+       * value of the triangle into `interpolated_value` and returns true.
+       */
+      bool in_triangle(const std::array<std::array<double,3>,3> &points,
+                       const std::array<double,8> &precomputed,
+                       const Point<2> &check_point,
+                       double &interpolate_value,
+                       double &interpolator_s,
+                       double &interpolator_t)
+      {
+        double factor = 1e4;
+        // based on https://stackoverflow.com/questions/2049582/how-to-determine-if-a-point-is-in-a-2d-triangle
+        // compute s, t and area
+        const double s_no_area = -(precomputed[0] + precomputed[1]*check_point[0] + precomputed[2]*check_point[1]);
+        const double t_no_area = -(precomputed[3] + precomputed[4]*check_point[0] + precomputed[5]*check_point[1]);
+
+        if (s_no_area >= -factor*std::numeric_limits<double>::epsilon() && t_no_area >= -factor*std::numeric_limits<double>::epsilon() && s_no_area+t_no_area-precomputed[6]<=precomputed[6]*factor*std::numeric_limits<double>::epsilon())
+          {
+            // point is in this triangle
+            interpolator_s = precomputed[7]*s_no_area;
+            interpolator_t = precomputed[7]*t_no_area;
+            interpolate_value = points[0][2]*(1-interpolator_s-interpolator_t)+points[1][2]*interpolator_s+points[2][2]*interpolator_t;
+            return true;
+          }
+        return false;
+      }
+    }
+
+    Surface::Surface()
+      = default;
+
+
+    Surface::Surface(std::pair<std::vector<double>,std::vector<double>> values_at_points)
+    {
+      // first find the min and max. This need always to be done;
+      WBAssertThrow(!values_at_points.first.empty(), "internal error: no values in values_at_points.first.");
+      minimum = values_at_points.first[0];
+      maximum = values_at_points.first[0];
+
+      for (const auto &value: values_at_points.first)
+        {
+          if (value < minimum)
+            {
+              minimum = value;
+            }
+          if (value > maximum)
+            {
+              maximum = value;
+            }
+        }
+
+      // if there are points defined there is not a constant value,
+      // if there are no points defined there is a constant value.
+      if (!values_at_points.second.empty())
+        {
+          constant_value = false;
+
+          // Next make the triangulation and the kd-tree.
+          // Feed the delaunator
+          delaunator::Delaunator triangulation(values_at_points.second);
+
+          // now loop over all the triangles and add them to the correct vectors
+          triangles.resize(triangulation.triangles.size()/3);
+          std::vector<KDTree::Node> node_list;
+          for (std::size_t i = 0; i < triangulation.triangles.size(); i+=3)
+            {
+              delaunator::Delaunator &t = triangulation;
+              // 1. We need to create a triangle list where each entry contains the coordinates
+              //    and value of the points of the triangle:
+              //    [[[x0,y0,v0],[x1,y1,v1],[x2,y2,v2]],[[x1,y1,v1],[x0,y0,v0],[x3,y3,v3]],...]
+              // 2. we need to compute the centeroid locations and add those to the KD-tree
+              //    with the index stored on the triangle list
+              triangles[i/3][0][0] = t.coords[2 * t.triangles[i]]; // tx0
+              triangles[i/3][0][1] = t.coords[2 * t.triangles[i]+1]; // ty0
+              triangles[i/3][0][2] = values_at_points.first[t.triangles[i]]; // v0
+              triangles[i/3][1][0] = t.coords[2 * t.triangles[i+1]]; // tx1
+              triangles[i/3][1][1] = t.coords[2 * t.triangles[i+1]+1]; // ty1
+              triangles[i/3][1][2] = values_at_points.first[t.triangles[i+1]]; // v1
+              triangles[i/3][2][0] = t.coords[2 * t.triangles[i+2]]; // tx2
+              triangles[i/3][2][1] = t.coords[2 * t.triangles[i+2]+1]; // ty2
+              triangles[i/3][2][2] = values_at_points.first[t.triangles[i+2]]; // v2
+
+              node_list.emplace_back(i/3,
+                                     (t.coords[2*t.triangles[i]]+t.coords[2*t.triangles[i+1]]+t.coords[2*t.triangles[i+2]])/3.,
+                                     (t.coords[2*t.triangles[i]+1]+t.coords[2*t.triangles[i+1]+1]+t.coords[2*t.triangles[i+2]+1])/3.);
+
+            }
+          // now feed and create the KD-tree
+          tree = KDTree::KDTree(node_list);
+          tree.create_tree(0, node_list.size()-1, false);
+
+
+          // precompute values for in_triangle
+          in_triangle_precomputed.resize(tree.get_nodes().size());
+          for (size_t iii = 0; iii < tree.get_nodes().size(); iii++)
+            {
+              in_triangle_precomputed[iii][0] = triangles[iii][0][1]*triangles[iii][2][0] - triangles[iii][0][0]*triangles[iii][2][1];
+              in_triangle_precomputed[iii][1] = triangles[iii][2][1] - triangles[iii][0][1];
+              in_triangle_precomputed[iii][2] = triangles[iii][0][0] - triangles[iii][2][0];
+              in_triangle_precomputed[iii][3] = triangles[iii][0][0]*triangles[iii][1][1] - triangles[iii][0][1]*triangles[iii][1][0];
+              in_triangle_precomputed[iii][4] = triangles[iii][0][1] - triangles[iii][1][1];
+              in_triangle_precomputed[iii][5] = triangles[iii][1][0] - triangles[iii][0][0];
+              in_triangle_precomputed[iii][6] = -(-triangles[iii][1][1]*triangles[iii][2][0] + triangles[iii][0][1]*(-triangles[iii][1][0] + triangles[iii][2][0]) + triangles[iii][0][0]*(triangles[iii][1][1] - triangles[iii][2][1]) + triangles[iii][1][0]*triangles[iii][2][1]);
+              in_triangle_precomputed[iii][7] = 1./in_triangle_precomputed[iii][6];
+            }
+        }
+      else
+        {
+          constant_value = true;
+        }
+
+    }
+
+    SurfaceValueInfo
+    Surface::local_value(const Point<2> &check_point) const
+    {
+      if (constant_value)
+        {
+          // just min and max are the same since it is constant. Just return min.
+          return minimum;
+        }
+      // first find the closest centeroids
+      const KDTree::IndexDistances index_distances = tree.find_closest_points(check_point);
+
+      // try triangle of the closest centroid
+      double interpolated_value = 0;
+      double interpolator_s = NaN::DQNAN;
+      double interpolator_t = NaN::DQNAN;
+
+      if (in_triangle(triangles[tree.get_nodes()[index_distances.min_index].index],in_triangle_precomputed[tree.get_nodes()[index_distances.min_index].index],check_point,interpolated_value,interpolator_s,interpolator_t))
+        {
+          return SurfaceValueInfo {tree.get_nodes()[index_distances.min_index].index,interpolated_value,interpolator_s,interpolator_t};
+        }
+
+      Point<2> other_point = check_point;
+      KDTree::IndexDistances index_distances_other;
+      const bool spherical = check_point.get_coordinate_system() == CoordinateSystem::spherical;
+      if (spherical)
+        {
+          other_point[0] += check_point[0] < 0 ? 2.0 * WorldBuilder::Consts::PI : -2.0 * WorldBuilder::Consts::PI;
+          index_distances_other = tree.find_closest_points(other_point);
+
+          if (in_triangle(triangles[tree.get_nodes()[index_distances_other.min_index].index],in_triangle_precomputed[tree.get_nodes()[index_distances_other.min_index].index],other_point,interpolated_value,interpolator_s,interpolator_t))
+            {
+              return SurfaceValueInfo {tree.get_nodes()[index_distances_other.min_index].index,interpolated_value,interpolator_s,interpolator_t};
+            }
+        }
+
+
+      {
+        // if not found go to closets nodes
+        // Todo: could remove the cosest node, because it was already tested. Could also sort based no distance.
+        for (const auto &index_distance: index_distances.vector)
+          {
+            if (in_triangle(triangles[tree.get_nodes()[index_distance.index].index],in_triangle_precomputed[tree.get_nodes()[index_distance.index].index],check_point,interpolated_value,interpolator_s,interpolator_t))
+              {
+                return SurfaceValueInfo {tree.get_nodes()[index_distance.index].index,interpolated_value,interpolator_s,interpolator_t};
+              }
+          }
+        if (spherical)
+          {
+            for (auto &index_distance: index_distances_other.vector)
+              {
+                if (in_triangle(triangles[tree.get_nodes()[index_distance.index].index],in_triangle_precomputed[tree.get_nodes()[index_distance.index].index],other_point,interpolated_value,interpolator_s,interpolator_t))
+                  {
+                    return SurfaceValueInfo {tree.get_nodes()[index_distance.index].index,interpolated_value,interpolator_s,interpolator_t};
+                  }
+              }
+          }
+
+        // if still not found, go through all nodes
+        // Todo: Although this shouldonly very rearly happen, could remove already tested nodes.
+        for (const auto &nodes: tree.get_nodes())
+          {
+            if (in_triangle(triangles[nodes.index],in_triangle_precomputed[nodes.index],check_point,interpolated_value,interpolator_s,interpolator_t))
+              {
+                return SurfaceValueInfo {nodes.index,interpolated_value,interpolator_s,interpolator_t};
+              }
+            if (spherical && in_triangle(triangles[nodes.index],in_triangle_precomputed[nodes.index],other_point,interpolated_value,interpolator_s,interpolator_t))
+              {
+                return SurfaceValueInfo {nodes.index,interpolated_value,interpolator_s,interpolator_t};
+              }
+          }
+        WBAssertThrow(false, "Internal error: The requested point was not in any triangle. "
+                      << "This could be due to rounding errors if the difference between the check point and triangle points are small, "
+                      << "or you are requesting a point outside the boundaries defined by the additional points. The check point was "
+                      << check_point[0] <<  ":" << check_point[1] << ".");
+      }
+      return 0;
+    }
+  } // namespace Objects
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/parameters.cc.bak b/contrib/world_builder/source/world_builder/parameters.cc.bak
new file mode 100644
index 00000000000..a7b1afc63b9
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/parameters.cc.bak
@@ -0,0 +1,2229 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+
+#include "world_builder/features/continental_plate_models/composition/interface.h"
+#include "world_builder/features/continental_plate_models/grains/interface.h"
+#include "world_builder/features/continental_plate_models/temperature/interface.h"
+#include "world_builder/features/fault.h"
+#include "world_builder/features/mantle_layer_models/composition/interface.h"
+#include "world_builder/features/mantle_layer_models/grains/interface.h"
+#include "world_builder/features/mantle_layer_models/temperature/interface.h"
+#include "world_builder/features/oceanic_plate_models/composition/interface.h"
+#include "world_builder/features/oceanic_plate_models/grains/interface.h"
+#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
+#include "world_builder/features/plume_models/composition/interface.h"
+#include "world_builder/features/plume_models/grains/interface.h"
+#include "world_builder/features/plume_models/temperature/interface.h"
+#include "world_builder/features/subducting_plate.h"
+#include "world_builder/gravity_model/interface.h"
+#include "world_builder/types/object.h"
+#include "world_builder/utilities.h"
+
+#include "rapidjson/error/en.h"
+#include "rapidjson/istreamwrapper.h"
+#include "rapidjson/latexwriter.h"
+#include "rapidjson/mystwriter.h"
+#include "rapidjson/prettywriter.h"
+
+#include <fstream>
+#include <memory>
+
+using namespace rapidjson;
+
+namespace
+{
+  void remove_key(rapidjson::Value &value, const char *key)
+  {
+    if (value.IsObject())
+      {
+        auto it = value.FindMember(key);
+        if (it != value.MemberEnd())
+          value.RemoveMember(it);
+
+        for (auto &member : value.GetObject())
+          remove_key(member.value, key);
+
+      }
+    else if (value.IsArray())
+      {
+        for (auto &element : value.GetArray())
+          remove_key(element, key);
+      }
+  }
+}
+
+namespace WorldBuilder
+{
+  Parameters::Parameters(World &world_)
+    :
+    world(world_)
+  {
+  }
+
+  Parameters::~Parameters()
+    = default;
+
+  void Parameters::initialize(std::string &filename, bool has_output_dir, const std::string &output_dir)
+  {
+
+    if (has_output_dir)
+      {
+        StringBuffer buffer;
+        std::ofstream file;
+
+        // write out json schema
+        file.open (output_dir + "world_builder_declarations.schema.json");
+        WBAssertThrow(file.is_open(), "Error: Could not open file '" + output_dir + "world_builder_declarations.schema.json' for string the json declarations.");
+        PrettyWriter<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> json_writer(buffer);
+        declarations.Accept(json_writer);
+        file << buffer.GetString();
+        file.close();
+        buffer.Clear();
+
+        // remove Snippets so they don't appear in the documentation:
+        remove_key(declarations, "defaultSnippets");
+
+        // write out declarations
+        file.open (output_dir + "world_builder_declarations.tex");
+        WBAssertThrow(file.is_open(), "Error: Could not open file '" + output_dir + "world_builder_declarations.tex' for string the tex declarations.");
+
+        LatexWriter<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> tex_writer(buffer);
+        declarations.Accept(tex_writer);
+        file << buffer.GetString();
+        file.close();
+        buffer.Clear();
+
+        // write out declarations (open)
+        file.open (output_dir + "world_builder_declarations_open.md");
+        WBAssertThrow(file.is_open(), "Error: Could not open file '" + output_dir + "world_builder_declarations_open.md' for string the tex declarations.");
+
+        MySTWriter<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> myst_writer_open(buffer, true);
+        declarations.Accept(myst_writer_open);
+        file << buffer.GetString();
+        file.close();
+        buffer.Clear();
+
+        // write out declarations (closed)
+        file.open (output_dir + "world_builder_declarations_closed.md");
+        WBAssertThrow(file.is_open(), "Error: Could not open file '" + output_dir + "world_builder_declarations_closed.md' for string the tex declarations.");
+
+        MySTWriter<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> myst_writer_closed(buffer, false);
+        declarations.Accept(myst_writer_closed);
+        file << buffer.GetString();
+        file.close();
+        buffer.Clear();
+      }
+
+    path_level =0;
+    // Now read in the world builder file into a stringstream and
+    // put it into a the rapidjson document
+    std::stringstream json_input_stream(WorldBuilder::Utilities::read_and_distribute_file_content(filename));
+    rapidjson::IStreamWrapper isw(json_input_stream);
+
+    // relaxing syntax by allowing comments () for now, maybe also allow trailing commas and (kParseTrailingCommasFlag) and nan's, inf etc (kParseNanAndInfFlag)?
+    //WBAssertThrow(!parameters.ParseStream<kParseCommentsFlag>(isw).HasParseError(), "Parsing errors world builder file");
+
+    WBAssertThrowExc(!(parameters.ParseStream<kParseCommentsFlag | kParseNanAndInfFlag>(isw).HasParseError()), std::ifstream json_input_stream_error(filename.c_str()); ,
+                     "Parsing errors world builder file: Error(offset " << static_cast<unsigned>(parameters.GetErrorOffset())
+                     << "): " << GetParseError_En(parameters.GetParseError()) << std::endl << std::endl
+                     << " Showing 50 chars before and after: "
+                     << std::string((std::istreambuf_iterator<char>(json_input_stream_error.seekg(0, json_input_stream_error.beg))),
+                                    std::istreambuf_iterator<char>()).substr(static_cast<unsigned>(parameters.GetErrorOffset()) <= 50
+                                                                             ?
+                                                                             0
+                                                                             :
+                                                                             static_cast<unsigned>(parameters.GetErrorOffset()) - 50, 100
+                                                                            ) << std::endl << std::endl
+                     << " Showing 5 chars before and after: "
+                     << std::string((std::istreambuf_iterator<char>(json_input_stream_error.seekg(0, json_input_stream_error.beg))),
+                                    std::istreambuf_iterator<char>()).substr(static_cast<unsigned>(parameters.GetErrorOffset()) <= 5
+                                                                             ? 0
+                                                                             :
+                                                                             static_cast<unsigned>(parameters.GetErrorOffset())-5,
+                                                                             (static_cast<unsigned>(parameters.GetErrorOffset()) + 10 > json_input_stream_error.seekg(0,std::ios::end).tellg()
+                                                                              ?
+                                                                              static_cast<unsigned>(json_input_stream.tellg())-static_cast<unsigned>(parameters.GetErrorOffset())
+                                                                              :
+                                                                              10)
+                                                                            ));
+
+    WBAssertThrow(parameters.IsObject(), "World builder file is is not an object.");
+
+
+    const SchemaDocument schema(declarations);
+    SchemaValidator validator(schema);
+
+    if (!parameters.Accept(validator))
+      {
+        // Input JSON is invalid according to the schema
+        // Output diagnostic information
+        StringBuffer buffer;
+        std::stringstream string;
+        validator.GetInvalidSchemaPointer().StringifyUriFragment(buffer);
+        string << "Invalid schema: " << buffer.GetString() << std::endl;
+        string << "Invalid keyword: " << validator.GetInvalidSchemaKeyword();
+        buffer.Clear();
+        validator.GetInvalidDocumentPointer().StringifyUriFragment(buffer);
+        string << "Invalid schema: " << buffer.GetString() << std::endl;
+        PrettyWriter<StringBuffer> writer(buffer);
+        validator.GetError().Accept(writer);
+        WBAssertThrow(false, string.str() << "Error document: " << std::endl << buffer.GetString());
+      }
+  }
+
+  void
+  Parameters::declare_entry(const std::string &name,
+                            const Types::Interface &type,
+                            const std::string &documentation)
+  {
+    type.write_schema(*this,name,documentation);
+  }
+
+  bool
+  Parameters::check_entry(const std::string &name) const
+  {
+    return Pointer((this->get_full_json_path() + "/" + name).c_str()).Get(parameters) != nullptr;
+  }
+
+
+  template<>
+  std::string
+  Parameters::get(const std::string &name)
+  {
+    const std::string base = this->get_full_json_path();
+    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
+
+#ifdef debug
+    bool required = false;
+    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
+      {
+        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
+          {
+            if (v.GetString() == name)
+              {
+                required = true;
+              }
+          }
+      }
+
+    WBAssert(value != NULL || required == false,
+             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
+#endif
+    if (value == nullptr)
+      {
+        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << base + "/" + name + "/default value");
+      }
+
+    return value->GetString();
+  }
+
+  template<>
+  double
+  Parameters::get(const std::string &name)
+  {
+    const std::string base = this->get_full_json_path();
+    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
+
+#ifdef debug
+    bool required = false;
+    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
+      {
+        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
+          {
+            if (v.GetString() == name)
+              {
+                required = true;
+              }
+          }
+      }
+
+    WBAssert(value != NULL || required == false,
+             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
+#endif
+    if (value == nullptr)
+      {
+        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << get_full_json_schema_path() + "/" + name + "/default value, for value: " << base + "/" + name);
+      }
+
+    double return_value;
+    try
+      {
+        return_value = value->GetDouble();
+      }
+    catch (...)
+      {
+        WBAssertThrow(false, "Could not convert values of " << base << " into doubles.");
+      }
+    return return_value;
+  }
+
+  template<>
+  size_t
+  Parameters::get(const std::string &name)
+  {
+    const std::string base = this->get_full_json_path();
+    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
+
+#ifdef debug
+    bool required = false;
+    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
+      {
+        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
+          {
+            if (v.GetString() == name)
+              {
+                required = true;
+              }
+          }
+      }
+
+    WBAssert(value != NULL || required == false,
+             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
+#endif
+    if (value == nullptr)
+      {
+        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << base + "/" + name + "/default value");
+      }
+
+    return value->GetUint();
+  }
+
+  template<>
+  unsigned int
+  Parameters::get(const std::string &name)
+  {
+    const std::string base = this->get_full_json_path();
+    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
+
+#ifdef debug
+    bool required = false;
+    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
+      {
+        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
+          {
+            if (v.GetString() == name)
+              {
+                required = true;
+              }
+          }
+      }
+
+    WBAssert(value != NULL || required == false,
+             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
+#endif
+    if (value == nullptr)
+      {
+        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << base + "/" + name + "/default value");
+      }
+
+    return value->GetUint();
+  }
+
+  template<>
+  int
+  Parameters::get(const std::string &name)
+  {
+    const std::string base = this->get_full_json_path();
+    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
+
+#ifdef debug
+    bool required = false;
+    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
+      {
+        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
+          {
+            if (v.GetString() == name)
+              {
+                required = true;
+              }
+          }
+      }
+
+    WBAssert(value != NULL || required == false,
+             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
+#endif
+    if (value == nullptr)
+      {
+        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << base + "/" + name + "/default value");
+      }
+
+    return value->GetInt();
+  }
+
+  template<>
+  bool
+  Parameters::get(const std::string &name)
+  {
+    const std::string base = this->get_full_json_path();
+    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
+
+#ifdef debug
+    bool required = false;
+    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
+      {
+        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
+          {
+            if (v.GetString() == name)
+              {
+                required = true;
+              }
+          }
+      }
+
+    WBAssert(value != NULL || required == false,
+             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
+#endif
+    if (value == nullptr)
+      {
+        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << base + "/" + name + "/default value");
+      }
+
+    return value->GetBool();
+  }
+
+
+  template<>
+  Point<2>
+  Parameters::get(const std::string &name)
+  {
+
+    const std::string strict_base = this->get_full_json_path();
+    const Value *array = Pointer((strict_base + "/" + name).c_str()).Get(parameters);
+
+#ifdef debug
+    bool required = false;
+    if (Pointer((strict_base + "/required").c_str()).Get(declarations) != NULL)
+      {
+        for (auto &v : Pointer((strict_base + "/required").c_str()).Get(declarations)->GetArray())
+          {
+            if (v.GetString() == name)
+              {
+                required = true;
+              }
+          }
+      }
+
+    WBAssert(array != NULL || required == false,
+             "Internal error: Value \"" << strict_base << '/' << name << "/type\" not found in the input file, while it was set as required.");
+#endif
+    if (array != nullptr)
+      {
+        const std::string base = strict_base + "/" + name;
+        //let's assume that the file is correct, because it has been checked with the json schema.
+        // So there are exactly two values.
+        double value1;
+        double value2;
+
+        try
+          {
+            value1 = Pointer((base + "/0").c_str()).Get(parameters)->GetDouble();
+            value2 = Pointer((base + "/1").c_str()).Get(parameters)->GetDouble();
+          }
+        catch (...)
+          {
+            WBAssertThrow(false, "Could not convert values of " << base << " into Point<2>, because it could not convert the sub-elements into doubles.");
+          }
+        return Point<2>(value1,value2,this->coordinate_system->natural_coordinate_system());
+      }
+    WBAssertThrow(false, "default values not implemented in get<Point<2> >. Looked in: " + strict_base + "/" << name);
+
+    return {invalid};;
+  }
+
+  template<>
+  std::vector<bool>
+  Parameters::get_vector(const std::string &name)
+  {
+    std::vector<bool> vector;
+    const std::string strict_base = this->get_full_json_path();
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+        for (size_t i = 0; i < array->Size(); ++i )
+          {
+            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+
+            vector.push_back(Pointer(base.c_str()).Get(parameters)->GetBool());
+          }
+      }
+    else
+      {
+        const Value *value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/minItems").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the minItems value at: "
+                      << this->get_full_json_schema_path() + "/" + name + "/minItems value");
+
+        const size_t min_size = value->GetUint();
+
+        const bool default_value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/items/default value").c_str()).Get(declarations)->GetBool();
+
+        // set to min size
+        for (size_t i = 0; i < min_size; ++i)
+          {
+            vector.push_back(default_value);
+          }
+      }
+    return vector;
+  }
+
+
+  std::pair<std::vector<double>,std::vector<double>>
+                                                  Parameters::get(const std::string &name,
+                                                                  const std::vector<Point<2> > &addition_points)
+  {
+    // There are four cases:
+    // 1. No value provided: use the default value everywhere. Return first with one value and second with size 0.
+    // 2. One double provided: use the default value everywhere. Return first with one value and second with size 0.
+    // 3. One value in a double array and no points provided: use that value everywhere. Return first with one value and second with size 0.
+    // 4. Other: fill the vectors with the default value and addition points and then add new point.
+    //    If a value without points is encountered, the additional points are used.
+    std::pair<std::vector<double>,std::vector<double>> result;
+
+    const std::string strict_base = this->get_full_json_path();
+
+    // start with adding the additional points with the default value
+    // to do this we need the default value
+    double default_value = 0;
+    bool is_array = true;
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr && Pointer((strict_base + "/" + name).c_str()).Get(parameters)->IsArray())
+      {
+        const std::string value_def_path = get_full_json_schema_path() + "/" + name + "/oneOf/1/items/items/anyOf/0/default value";
+        Value *value_def = Pointer(value_def_path.c_str()).Get(declarations);
+        WBAssertThrow(value_def != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << value_def_path);
+
+        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
+        // So no try/catch needed.
+        default_value = value_def->GetDouble();
+      }
+    else
+      {
+        is_array = false;
+        Value *value_def = Pointer((get_full_json_schema_path() + "/" + name + "/oneOf/0/default value").c_str()).Get(declarations);
+        WBAssertThrow(value_def != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      <<get_full_json_schema_path() + "/" + name + "/oneOf/0/default value");
+
+
+        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
+        // So no try/catch needed.
+        default_value = value_def->GetDouble();
+      }
+
+
+    // check if there is a user defined value
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        // there is a user defined value, so either case 2, 3 or 4.
+        if (is_array)
+          {
+            Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+            if (array->Size() == 1
+                && Pointer((strict_base + "/" + name + "/0/1").c_str()).Get(parameters) == nullptr)
+              {
+                // case 2: Return first with one value and second with size 0.
+                double value = 0;
+                try
+                  {
+                    value = Pointer((strict_base + "/" + name + "/0/0").c_str()).Get(parameters)->GetDouble();
+                  }
+                catch (...)
+                  {
+                    WBAssertThrow(false, "Could not convert values of " << strict_base << "/" << name << "/0/0 into a double. "
+                                  << "The provided value was \"" <<  Pointer((strict_base + "/" + name + "/0/0").c_str()).Get(parameters)->GetString() << "\".");
+                  }
+                result.first.emplace_back(value);
+              }
+            else
+              {
+                // case 3: fill the vectors with the default value and addition points and then add new point.
+                //         If a value without points is encountered, the additional points are used.
+
+                // first fill with additional points at default value
+                for (const auto &addition_point : addition_points)
+                  {
+                    result.first.emplace_back(default_value);
+                    result.second.emplace_back(addition_point[0]);
+                    result.second.emplace_back(addition_point[1]);
+                  }
+
+                // second, go through all the points in order
+                for (size_t i = 0; i < array->Size(); ++i )
+                  {
+                    // now parse a single value_at_point.
+                    const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+                    // Let's assume that the file is correct, because it has been checked with the json schema.
+                    // So there are exactly two values, the first value is a double, the second an array of 2d arrays (points).
+
+                    // Get the double
+                    double value;
+                    Value *value_pointer = Pointer((base + "/0").c_str()).Get(parameters);
+
+                    WBAssertThrow(value_pointer != nullptr, "internal error: this should not happen.");
+
+                    try
+                      {
+                        value = value_pointer->GetDouble();
+                      }
+                    catch (...)
+                      {
+                        WBAssertThrow(false, "Could not convert values of " << base << "/0 into doubles. "
+                                      << "The provided value was \"" <<  Pointer((base + "/0").c_str()).Get(parameters)->GetString() << "\".");
+                      }
+
+                    // now get the array of points.
+                    Value *coordinates_array = Pointer((base + "/1").c_str()).Get(parameters);
+                    if (coordinates_array != nullptr)
+                      {
+                        for (size_t coordinate_i = 0; coordinate_i < coordinates_array->Size(); ++coordinate_i )
+                          {
+                            // Let's assume that the file is correct, because it has been checked with the json schema.
+                            // That means that there are exactly two values per item
+                            double coordinate_0;
+                            double coordinate_1;
+                            try
+                              {
+                                coordinate_0 = Pointer((base + "/1/" + std::to_string(coordinate_i) + "/0").c_str()).Get(parameters)->GetDouble();
+                              }
+                            catch (...)
+                              {
+                                WBAssertThrow(false, "Could not convert values of " << base + "/1/" + std::to_string(coordinate_i) + "/0"
+                                              << " into a Point<2> array, because it could not convert the 1st sub-elements into doubles. "
+                                              << "The provided value was \""
+                                              <<  Pointer((base + "/1/" + std::to_string(coordinate_i) + "/0").c_str()).Get(parameters)->GetString()
+                                              << "\".");
+                              }
+                            try
+                              {
+                                coordinate_1 = Pointer((base + "/1/" + std::to_string(coordinate_i) + "/1").c_str()).Get(parameters)->GetDouble();
+                              }
+                            catch (...)
+                              {
+                                WBAssertThrow(false, "Could not convert values of " << base + "/1/" + std::to_string(coordinate_i) + "/1"
+                                              << " into a Point<2> array, because it could not convert the 2nd sub-elements into doubles. "
+                                              << "The provided value was \""
+                                              <<  Pointer((base + "/1/" + std::to_string(coordinate_i) + "/1").c_str()).Get(parameters)->GetString()
+                                              << "\".");
+                              }
+
+                            coordinate_0 *= (coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical ? Consts::PI / 180.0 : 1.);
+                            coordinate_1 *= (coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical ? Consts::PI / 180.0 : 1.);
+
+                            bool found_same_point = false;
+                            unsigned int coordinate_pair_i = 0;
+                            for (; coordinate_pair_i < result.second.size(); coordinate_pair_i+=2)
+                              {
+                                if (Utilities::approx(result.second[coordinate_pair_i],coordinate_0) && Utilities::approx(result.second[coordinate_pair_i+1],coordinate_1))
+                                  {
+                                    found_same_point = true;
+                                    break;
+                                  }
+                              }
+                            if (found_same_point)
+                              {
+                                // set the value to the new value
+                                result.first[coordinate_pair_i/2] = value;
+                              }
+                            else
+                              {
+                                // add a new point
+                                result.first.emplace_back(value);
+                                result.second.emplace_back(coordinate_0);
+                                result.second.emplace_back(coordinate_1);
+                              }
+                          }
+
+                      }
+                    else
+                      {
+                        // no points are provided, so use the value to fill put in the additional points
+                        // at that value. Since we know that all the additional points are at the start
+                        // we can easily overwrite the values.
+                        for (unsigned int addition_point_i = 0; addition_point_i < addition_points.size(); ++addition_point_i)
+                          {
+                            result.first[addition_point_i] = value;
+                          }
+                      }
+                  }
+              }
+          }
+        else
+          {
+            // case 2: there one value, not an array
+            double value = 0;
+            try
+              {
+                value = Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetDouble();
+              }
+            catch (...)
+              {
+                WBAssertThrow(false, "Could not convert values of " << strict_base << "/" << name << " into a double. "
+                              << "The provided value was \"" <<  Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetString() << "\".");
+              }
+            result.first.emplace_back(value);
+          }
+      }
+    else
+      {
+        // there is no user defined value. Case one: return the default value and no points
+        result.first.emplace_back(default_value);
+      }
+
+    return result;
+  }
+
+
+  std::pair<std::vector<double>,std::vector<double>> Parameters::get_value_at_array(const std::string &name)
+  {
+    // There are two cases:
+    // 1. One double provided: use the default value everywhere. Return first with one value and second with size 0.
+    // 2. Other: fill the vectors with the default value and addition points and then add new point.
+    //    If a value without points is encountered, the additional points are used.
+    std::pair<std::vector<double>,std::vector<double>> result;
+
+    const std::string strict_base = this->get_full_json_path();
+
+    // start with adding the additional points with the default value
+    // to do this we need the default value
+    double default_value = 0;
+    bool is_array = true;
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr && Pointer((strict_base + "/" + name).c_str()).Get(parameters)->IsArray())
+      {
+        const std::string value_def_path = get_full_json_schema_path() + "/" + name + "/oneOf/1/items/items/anyOf/0/default value";
+        Value *value_def = Pointer(value_def_path.c_str()).Get(declarations);
+        WBAssertThrow(value_def != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << value_def_path);
+
+        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
+        // So no try/catch needed.
+        default_value = value_def->GetDouble();
+      }
+    else
+      {
+        is_array = false;
+        Value *value_def = Pointer((get_full_json_schema_path() + "/" + name + "/oneOf/0/default value").c_str()).Get(declarations);
+        WBAssertThrow(value_def != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      <<get_full_json_schema_path() + "/" + name + "/oneOf/0/default value");
+
+
+        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
+        // So no try/catch needed.
+        default_value = value_def->GetDouble();
+      }
+
+
+    // check if there is a user defined value
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        // there is a user defined value, so either case 2, 3 or 4.
+        if (is_array)
+          {
+            Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+            // go through all the points in order
+            for (size_t i = 0; i < array->Size(); ++i )
+              {
+                // now parse a single value_at_point.
+                const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+                // Let's assume that the file is correct, because it has been checked with the json schema.
+                // So there are exactly two values, the first value is a double, the second an array of 2d arrays (points).
+
+                // Get the double
+                double value;
+                Value *value_pointer = Pointer((base + "/0").c_str()).Get(parameters);
+
+                WBAssertThrow(value_pointer != nullptr, "internal error: this should not happen.");
+
+                try
+                  {
+                    value = value_pointer->GetDouble();
+                  }
+                catch (...)
+                  {
+                    WBAssertThrow(false, "Could not convert values of " << base << "/0 into doubles. "
+                                  << "The provided value was \"" <<  Pointer((base + "/0").c_str()).Get(parameters)->GetString() << "\".");
+                  }
+
+                // now get the array of points.
+                Value *array_of_doubles = Pointer((base + "/1").c_str()).Get(parameters);
+                double value_in_array;
+                if (array_of_doubles != nullptr)
+                  {
+                    for (size_t coordinate_i = 0; coordinate_i < array_of_doubles->Size(); ++coordinate_i )
+                      {
+                        Value *coordinate_j_array = Pointer((base + "/1/" + std::to_string(coordinate_i)).c_str()).Get(parameters);
+                        for (size_t coordinate_j = 0; coordinate_j < coordinate_j_array->Size(); ++coordinate_j)
+                          {
+                            // Let's assume that the file is correct, because it has been checked with the json schema.
+                            // That means that there are exactly two values per item
+                            try
+                              {
+                                value_in_array = Pointer((base + "/1/" + std::to_string(coordinate_i) + "/" + std::to_string(coordinate_j)).c_str()).Get(parameters)->GetDouble();
+                              }
+                            catch (...)
+                              {
+                                WBAssertThrow(false, "Could not convert values of " << base + "/1/" + std::to_string(coordinate_i) + "/" + std::to_string(coordinate_j)
+                                              << " into a Point<2> array, because it could not convert the 1st sub-elements into doubles. "
+                                              << "The provided value was \""
+                                              <<  Pointer((base + "/1/" + std::to_string(coordinate_i) + "/" + std::to_string(coordinate_j)).c_str()).Get(parameters)->GetString()
+                                              << "\".");
+                              }
+
+                            result.second.emplace_back(value_in_array);
+                          }
+                      }
+                    result.first.emplace_back(value);
+                  }
+              }
+          }
+        else
+          {
+            // case 1: there one value, not an array
+            double value = 0;
+            try
+              {
+                value = Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetDouble();
+              }
+            catch (...)
+              {
+                WBAssertThrow(false, "Could not convert values of " << strict_base << "/" << name << " into a double. "
+                              << "The provided value was \"" <<  Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetString() << "\".");
+              }
+            result.first.emplace_back(0.0);
+            result.second.emplace_back(value);
+          }
+      }
+    else
+      {
+        // there is no user defined value. Case one: return the default value and no points
+        result.first.emplace_back(0.0);
+        result.second.emplace_back(default_value);
+      }
+
+    return result;
+  }
+
+
+  template<>
+  std::vector<Point<2> >
+  Parameters::get_vector(const std::string &name)
+  {
+    std::vector<Point<2> > vector;
+    const std::string strict_base = this->get_full_json_path();
+    WBAssertThrow(Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr,"Error: " << name
+                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
+
+    Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+    for (size_t i = 0; i < array->Size(); ++i )
+      {
+        const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+        //let's assume that the file is correct, because it has been checked with the json schema.
+        // So there are exactly two values.
+        double value1;
+        double value2;
+
+        try
+          {
+            value1 = Pointer((base + "/0").c_str()).Get(parameters)->GetDouble();
+            value2 = Pointer((base + "/1").c_str()).Get(parameters)->GetDouble();
+          }
+        catch (...)
+          {
+            WBAssertThrow(false, "Could not convert values of " << base << " into a Point<2> array, because it could not convert the sub-elements into doubles.");
+          }
+        vector.emplace_back(value1,value2,this->coordinate_system->natural_coordinate_system());
+      }
+
+    return vector;
+  }
+
+  template<>
+  std::vector<std::array<double,3> >
+  Parameters::get_vector(const std::string &name)
+  {
+    std::vector<std::array<double,3> > vector;
+    const std::string strict_base = this->get_full_json_path();
+    WBAssertThrow(Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr,"Error: " << name
+                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
+
+    Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+    for (size_t i = 0; i < array->Size(); ++i )
+      {
+        const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+        //let's assume that the file is correct, because it has been checked with the json schema.
+        // So there are exactly three values.
+        try
+          {
+            const double value1 = Pointer((base + "/0").c_str()).Get(parameters)->GetDouble();
+            const double value2 = Pointer((base + "/1").c_str()).Get(parameters)->GetDouble();
+            const double value3 = Pointer((base + "/2").c_str()).Get(parameters)->GetDouble();
+            vector.push_back({{value1,value2,value3}});
+          }
+        catch (...)
+          {
+            WBAssertThrow(false, "Could not convert values of " << base << " into doubles.");
+          }
+      }
+
+
+    return vector;
+  }
+
+  std::vector<std::vector<double>>
+                                Parameters::get_vector_or_double(const std::string &name)
+  {
+    // There are two cases:
+    // 1. One double provided: use the default value everywhere. Return first with one value and second with size 0.
+    // 2. std::vector<std::vector<double>> provided: output this array.
+    std::vector<std::vector<double>> result;
+
+    const std::string strict_base = this->get_full_json_path();
+
+    // start with adding the additional points with the default value
+    // to do this we need the default value
+    double default_value = 0;
+    bool is_array = true;
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr && Pointer((strict_base + "/" + name).c_str()).Get(parameters)->IsArray())
+      {
+        const std::string value_def_path = get_full_json_schema_path() + "/" + name + "/oneOf/1/items/items/default value";
+        Value *value_def = Pointer(value_def_path.c_str()).Get(declarations);
+        WBAssertThrow(value_def != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << value_def_path);
+
+        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
+        // So no try/catch needed.
+        default_value = value_def->GetDouble();
+      }
+    else
+      {
+        is_array = false;
+        Value *value_def = Pointer((get_full_json_schema_path() + "/" + name + "/oneOf/0/default value").c_str()).Get(declarations);
+        WBAssertThrow(value_def != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      <<get_full_json_schema_path() + "/" + name + "/oneOf/0/default value");
+
+
+        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
+        // So no try/catch needed.
+        default_value = value_def->GetDouble();
+      }
+
+
+    // check if there is a user defined value
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        // there is a user defined value, so either case 2, 3 or 4.
+        if (is_array)
+          {
+            Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+            // go through all the 1d-arrays within the 2d-array
+            for (size_t i = 0; i < array->Size(); ++i )
+              {
+                // now parse a single value_at_point.
+                const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+
+                // now get the array of points.
+                // Value *coordinates_array = Pointer((base + "/0").c_str()).Get(parameters);
+                Value *coordinates_array = Pointer((base).c_str()).Get(parameters);
+                double value_in_array;
+                std::vector<double> array_of_values;
+                if (coordinates_array != nullptr)
+                  {
+                    for (size_t coordinate_i = 0; coordinate_i < coordinates_array->Size(); ++coordinate_i )
+                      {
+                        // Let's assume that the file is correct, because it has been checked with the json schema.
+                        // That means that there are exactly two values per item
+                        try
+                          {
+                            value_in_array = Pointer(((base + "/") + std::to_string(coordinate_i)).c_str()).Get(parameters)->GetDouble();
+                          }
+                        catch (...)
+                          {
+                            WBAssertThrow(false, "Could not convert values of " << base + "/" + std::to_string(i) + "/" + std::to_string(coordinate_i) + "/" + std::to_string(coordinate_i)
+                                          << " into a Point<2> array, because it could not convert the 1st sub-elements into doubles. "
+                                          << "The provided value was \""
+                                          <<  Pointer((base + "/" + std::to_string(i) + "/" + std::to_string(coordinate_i)).c_str()).Get(parameters)->GetString()
+                                          << "\".");
+                          }
+                        array_of_values.emplace_back(value_in_array);
+                      }
+                    result.emplace_back(array_of_values);
+
+                  }
+              }
+          }
+        else
+          {
+            // case 1: there's one value, not an array
+            double value = 0;
+            try
+              {
+                value = Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetDouble();
+              }
+            catch (...)
+              {
+                WBAssertThrow(false, "Could not convert values of " << strict_base << "/" << name << " into a double. "
+                              << "The provided value was \"" <<  Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetString() << "\".");
+              }
+            result.emplace_back(std::vector<double> {value});
+          }
+      }
+    else
+      {
+        // there is no user defined value. Case one: return the default value and no points
+        result.emplace_back(std::vector<double> {default_value});
+      }
+
+    return result;
+  }
+
+
+
+  template<>
+  std::vector<std::array<std::array<double,3>,3> >
+  Parameters::get_vector(const std::string &name)
+  {
+    std::vector<std::array<std::array<double,3>,3>  > vector;
+    const std::string strict_base = this->get_full_json_path();
+    WBAssertThrow(Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr,"Error: " << name
+                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
+
+    Value *array1 = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+    for (size_t i = 0; i < array1->Size(); ++i )
+      {
+        const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+        Value *array2 = Pointer((base).c_str()).Get(parameters);
+
+        // Not sure why cppcheck it is generating the warning
+        // Filed a question at: https://sourceforge.net/p/cppcheck/discussion/general/thread/429759f85e/
+        // cppcheck-suppress constStatement
+        std::array<std::array<double,3>,3> array;
+        WBAssertThrow(array2->Size() == 3, "Array " << i << " is supposed to be a 3x3 array, but the outer array dimensions is "
+                      << array2->Size() << '.');
+        for (size_t j = 0; j < array2->Size(); ++j )
+          {
+            const std::string base_extended = base + "/" + std::to_string(j);
+
+            WBAssertThrow(Pointer((base_extended).c_str()).Get(parameters)->Size() == 3,
+                          "Array " << i << " is supposed to be a 3x3 array, but the inner array dimensions of "
+                          << j << " is " << Pointer((base_extended).c_str()).Get(parameters)->Size() << '.');
+            double value1;
+            double value2;
+            double value3;
+
+            try
+              {
+                value1 = Pointer((base_extended + "/0").c_str()).Get(parameters)->GetDouble();
+                value2 = Pointer((base_extended + "/1").c_str()).Get(parameters)->GetDouble();
+                value3 = Pointer((base_extended + "/2").c_str()).Get(parameters)->GetDouble();
+              }
+            catch (...)
+              {
+                WBAssertThrow(false, "Could not convert values of " << base << " into doubles.");
+              }
+            array[j][0] = value1;
+            array[j][1] = value2;
+            array[j][2] = value3;
+          }
+        vector.push_back(array);
+      }
+
+    return vector;
+  }
+
+
+  template<>
+  std::vector<std::vector<Point<2> > >
+  Parameters::get_vector(const std::string &name)
+  {
+    std::vector<std::vector<Point<2> >  > vector;
+    const std::string strict_base = this->get_full_json_path();
+    WBAssertThrow(Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr,"Error: " << name
+                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
+
+    Value *array1 = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+    for (size_t i = 0; i < array1->Size(); ++i )
+      {
+        const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+        Value *array2 = Pointer((base).c_str()).Get(parameters);
+
+        // Not sure why cppcheck it is generating the warning
+        // Filed a question at: https://sourceforge.net/p/cppcheck/discussion/general/thread/429759f85e/
+        // cppcheck-suppress constStatement
+        std::vector<Point<2> > sub_vector(array2->Size(),Point<2>(NaN::DSNAN,NaN::DSNAN,coordinate_system->natural_coordinate_system()));
+        for (size_t j = 0; j < array2->Size(); ++j )
+          {
+            const std::string base_extended = base + "/" + std::to_string(j);
+
+            WBAssertThrow(Pointer((base_extended).c_str()).Get(parameters)->Size() == 2,
+                          "Array " << i << " is supposed to be a 2d point, but the inner array dimensions of "
+                          << j << " is " << Pointer((base_extended).c_str()).Get(parameters)->Size() << '.');
+            double value1;
+            double value2;
+
+            try
+              {
+                value1 = Pointer((base_extended + "/0").c_str()).Get(parameters)->GetDouble();
+                value2 = Pointer((base_extended + "/1").c_str()).Get(parameters)->GetDouble();
+              }
+            catch (...)
+              {
+                WBAssertThrow(false, "Could not convert values of " << base << " into doubles, because it could not covert the sub-elements into doubles.");
+              }
+            sub_vector[j][0] = value1;
+            sub_vector[j][1] = value2;
+          }
+        vector.push_back(sub_vector);
+      }
+
+    return vector;
+  }
+
+
+  template<>
+  std::vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
+      Features::SubductingPlateModels::Composition::Interface,
+      Features::SubductingPlateModels::Grains::Interface> >
+      Parameters::get_vector(const std::string &name,
+                             std::vector<std::shared_ptr<Features::SubductingPlateModels::Temperature::Interface> > &default_temperature_models,
+                             std::vector<std::shared_ptr<Features::SubductingPlateModels::Composition::Interface> > &default_composition_models,
+                             std::vector<std::shared_ptr<Features::SubductingPlateModels::Grains::Interface> > &default_grains_models)
+  {
+    using namespace Features::SubductingPlateModels;
+    std::vector<Objects::Segment<Temperature::Interface,Composition::Interface,Grains::Interface> > vector;
+    this->enter_subsection(name);
+    const std::string strict_base = this->get_full_json_path();
+    WBAssertThrow(Pointer((strict_base).c_str()).Get(parameters) != nullptr,"Error: " << name
+                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
+
+    // get the array of segments
+    Value *array = Pointer((strict_base).c_str()).Get(parameters);
+
+    for (size_t i = 0; i < array->Size(); ++i )
+      {
+        this->enter_subsection(std::to_string(i));
+        const std::string base = this->get_full_json_path();
+        // get one segment
+        // length
+        const double length = Pointer((base + "/length").c_str()).Get(parameters)->GetDouble();
+
+        // get thickness
+        Value *point_array = Pointer((base  + "/thickness").c_str()).Get(parameters);
+        Point<2> thickness(invalid);
+        WBAssertThrow(point_array != nullptr,"error: " << name
+                      << " was not defined in " << strict_base << "/thickness, schema path: " << this->get_full_json_schema_path() << "/thickness.");
+
+        if (point_array->Size() == 1)
+          {
+            // There is only one value, set it for both elements
+            const double local0 = Pointer((base + "/thickness/0").c_str()).Get(parameters)->GetDouble();
+            thickness = Point<2>(local0,local0,invalid);
+          }
+        else
+          {
+            const double local0 = Pointer((base + "/thickness/0").c_str()).Get(parameters)->GetDouble();
+            const double local1 = Pointer((base + "/thickness/1").c_str()).Get(parameters)->GetDouble();
+            thickness = Point<2>(local0,local1,invalid);
+          }
+
+
+        // get top truncation (default is 0,0)
+        point_array = Pointer((base  + "/top truncation").c_str()).Get(parameters);
+        Point<2> top_truncation(invalid);
+        if (point_array != nullptr)
+          {
+            if (point_array->Size() == 1)
+              {
+                // There is only one value, set it for both elements
+                const double local0 = Pointer((base + "/top truncation/0").c_str()).Get(parameters)->GetDouble();
+                top_truncation = Point<2>(local0,local0,invalid);
+              }
+            else
+              {
+                const double local0 = Pointer((base + "/top truncation/0").c_str()).Get(parameters)->GetDouble();
+                const double local1 = Pointer((base + "/top truncation/1").c_str()).Get(parameters)->GetDouble();
+                top_truncation = Point<2>(local0,local1,invalid);
+              }
+          }
+        // get thickness
+        point_array = Pointer((base  + "/angle").c_str()).Get(parameters);
+        Point<2> angle(invalid);
+        WBAssertThrow(point_array != nullptr,"error: " << name
+                      << " was not defined in " << strict_base << "/angle, schema path: " << this->get_full_json_schema_path() << "/angle.");
+
+        if (point_array->Size() == 1)
+          {
+            // There is only one value, set it for both elements
+            const double local0 = Pointer((base + "/angle/0").c_str()).Get(parameters)->GetDouble();
+            angle = Point<2>(local0,local0,invalid);
+          }
+        else
+          {
+            const double local0 = Pointer((base + "/angle/0").c_str()).Get(parameters)->GetDouble();
+            const double local1 = Pointer((base + "/angle/1").c_str()).Get(parameters)->GetDouble();
+            angle = Point<2>(local0,local1,invalid);
+          }
+
+
+        // Get temperature models
+        std::vector<std::shared_ptr<Temperature::Interface> > temperature_models;
+
+        //This is a value to look back in the path elements.
+        size_t searchback = 0;
+        if (!this->get_shared_pointers<Temperature::Interface>("temperature models", temperature_models) ||
+            Pointer((base + "/temperature model default entry").c_str()).Get(parameters) != nullptr)
+          {
+            temperature_models = default_temperature_models;
+
+            // find the default value, which is the closest to the current path
+            for (searchback = 0; searchback < path.size(); ++searchback)
+              {
+                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Get(parameters) != nullptr)
+                  {
+                    break;
+                  }
+              }
+
+            // if we can not find default value for the temperature model, skip it
+            if (searchback < path.size())
+              {
+
+                // copy the value, this unfortunately removes it.
+                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Get(parameters)->GetArray());
+
+                // now copy it
+                Value value2;
+                value2.CopyFrom(value1, parameters.GetAllocator());
+
+                // now we should have 2x the same value, so put it back and place it in the correct location.
+                Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
+
+                Pointer((base).c_str()).Get(parameters)->AddMember("temperature models", value2, parameters.GetAllocator());
+                Pointer((base + "/temperature model default entry").c_str()).Set(parameters,true);
+              }
+          }
+
+        // now do the same for compositions
+        std::vector<std::shared_ptr<Composition::Interface> > composition_models;
+        if (!this->get_shared_pointers<Composition::Interface>("composition models", composition_models) ||
+            Pointer((base + "/composition model default entry").c_str()).Get(parameters) != nullptr)
+          {
+            composition_models = default_composition_models;
+
+
+            // find the default value, which is the closest to the current path
+            for (searchback = 0; searchback < path.size(); ++searchback)
+              {
+                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Get(parameters) != nullptr)
+                  {
+                    break;
+                  }
+              }
+
+            // if we can not find default value for the temperature model, skip it
+            if (searchback < path.size())
+              {
+
+                // copy the value, this unfortunately removes it.
+                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Get(parameters)->GetArray());
+
+                // now copy it
+                Value value2;
+                value2.CopyFrom(value1, parameters.GetAllocator());
+
+                // now we should have 2x the same value, so put it back and place it in the correct location.
+                Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
+
+                Pointer((base).c_str()).Get(parameters)->AddMember("composition models", value2, parameters.GetAllocator());
+                Pointer((base + "/composition model default entry").c_str()).Set(parameters,true);
+              }
+          }
+
+        // now do the same for grains
+        std::vector<std::shared_ptr<Grains::Interface> > grains_models;
+        if (!this->get_shared_pointers<Grains::Interface>("grains models", grains_models) ||
+            Pointer((base + "/grains model default entry").c_str()).Get(parameters) != nullptr)
+          {
+            grains_models = default_grains_models;
+
+
+            // find the default value, which is the closest to the current path
+            for (searchback = 0; searchback < path.size(); ++searchback)
+              {
+                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Get(parameters) != nullptr)
+                  {
+                    break;
+                  }
+              }
+
+            // if we can not find default value for the temperature model, skip it
+            if (searchback < path.size())
+              {
+
+                // copy the value, this unfortunately removes it.
+                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Get(parameters)->GetArray());
+
+                // now copy it
+                Value value2;
+                value2.CopyFrom(value1, parameters.GetAllocator());
+
+                // now we should have 2x the same value, so put it back and place it in the correct location.
+                Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
+
+                Pointer((base).c_str()).Get(parameters)->AddMember("grains models", value2, parameters.GetAllocator());
+                Pointer((base + "/grains model default entry").c_str()).Set(parameters,true);
+              }
+          }
+        vector.emplace_back(length, thickness, top_truncation, angle, temperature_models, composition_models, grains_models);
+
+        this->leave_subsection();
+      }
+
+    this->leave_subsection();
+    return vector;
+  }
+
+
+  template<>
+  std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,Features::FaultModels::Composition::Interface, Features::FaultModels::Grains::Interface> >
+  Parameters::get_vector(const std::string &name,
+                         std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> > &default_temperature_models,
+                         std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface> > &default_composition_models,
+                         std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface> > &default_grains_models)
+  {
+    using namespace Features::FaultModels;
+    std::vector<Objects::Segment<Temperature::Interface,Composition::Interface,Grains::Interface> > vector;
+    this->enter_subsection(name);
+    const std::string strict_base = this->get_full_json_path();
+    WBAssertThrow(Pointer((strict_base).c_str()).Get(parameters) != nullptr,"error: " << name
+                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
+
+    // get the array of segments
+    Value *array = Pointer((strict_base).c_str()).Get(parameters);
+
+    for (size_t i = 0; i < array->Size(); ++i )
+      {
+        this->enter_subsection(std::to_string(i));
+        const std::string base = this->get_full_json_path();
+        // get one segment
+        // length
+        const double length = Pointer((base + "/length").c_str()).Get(parameters)->GetDouble();
+
+        // get thickness
+        Value *point_array = Pointer((base  + "/thickness").c_str()).Get(parameters);
+        Point<2> thickness(invalid);
+        WBAssertThrow(point_array != nullptr,"error: " << name
+                      << " was not defined in " << strict_base << "/thickness, schema path: " << this->get_full_json_schema_path() << "/thickness.");
+
+        if (point_array->Size() == 1)
+          {
+            // There is only one value, set it for both elements
+            const double local0 = Pointer((base + "/thickness/0").c_str()).Get(parameters)->GetDouble();
+            thickness = Point<2>(local0,local0,invalid);
+          }
+        else
+          {
+            const double local0 = Pointer((base + "/thickness/0").c_str()).Get(parameters)->GetDouble();
+            const double local1 = Pointer((base + "/thickness/1").c_str()).Get(parameters)->GetDouble();
+            thickness = Point<2>(local0,local1,invalid);
+          }
+
+
+        // get top truncation (default is 0,0)
+        point_array = Pointer((base  + "/top truncation").c_str()).Get(parameters);
+        Point<2> top_truncation(invalid);
+        if (point_array != nullptr)
+          {
+            if (point_array->Size() == 1)
+              {
+                // There is only one value, set it for both elements
+                const double local0 = Pointer((base + "/top truncation/0").c_str()).Get(parameters)->GetDouble();
+                top_truncation = Point<2>(local0,local0,invalid);
+              }
+            else
+              {
+                const double local0 = Pointer((base + "/top truncation/0").c_str()).Get(parameters)->GetDouble();
+                const double local1 = Pointer((base + "/top truncation/1").c_str()).Get(parameters)->GetDouble();
+                top_truncation = Point<2>(local0,local1,invalid);
+              }
+          }
+        // get thickness
+        point_array = Pointer((base  + "/angle").c_str()).Get(parameters);
+        Point<2> angle(invalid);
+        WBAssertThrow(point_array != nullptr,"error: " << name
+                      << " was not defined in " << strict_base << "/angle, schema path: " << this->get_full_json_schema_path() << "/angle.");
+
+        if (point_array->Size() == 1)
+          {
+            // There is only one value, set it for both elements
+            const double local0 = Pointer((base + "/angle/0").c_str()).Get(parameters)->GetDouble();
+            angle = Point<2>(local0,local0,invalid);
+          }
+        else
+          {
+            const double local0 = Pointer((base + "/angle/0").c_str()).Get(parameters)->GetDouble();
+            const double local1 = Pointer((base + "/angle/1").c_str()).Get(parameters)->GetDouble();
+            angle = Point<2>(local0,local1,invalid);
+          }
+
+
+        // Get temperature models
+        std::vector<std::shared_ptr<Temperature::Interface> > temperature_models;
+
+        //This is a value to look back in the path elements.
+        size_t searchback = 0;
+        if (!this->get_shared_pointers<Temperature::Interface>("temperature models", temperature_models) ||
+            Pointer((base + "/temperature model default entry").c_str()).Get(parameters) != nullptr)
+          {
+            temperature_models = default_temperature_models;
+
+            // find the default value, which is the closest to the current path
+            for (searchback = 0; searchback < path.size(); ++searchback)
+              {
+                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Get(parameters) != nullptr)
+                  {
+                    break;
+                  }
+              }
+
+            // if we can not find default value for the temperature model, skip it
+            if (searchback < path.size())
+              {
+
+                // copy the value, this unfortunately removes it.
+                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Get(parameters)->GetArray());
+
+                // now copy it
+                Value value2;
+                value2.CopyFrom(value1, parameters.GetAllocator());
+
+                // now we should have 2x the same value, so put it back and place it in the correct location.
+                Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
+
+                Pointer((base).c_str()).Get(parameters)->AddMember("temperature models", value2, parameters.GetAllocator());
+                Pointer((base + "/temperature model default entry").c_str()).Set(parameters,true);
+              }
+          }
+
+        // now do the same for compositions
+        std::vector<std::shared_ptr<Composition::Interface> > composition_models;
+        if (!this->get_shared_pointers<Composition::Interface>("composition models", composition_models) ||
+            Pointer((base + "/composition model default entry").c_str()).Get(parameters) != nullptr)
+          {
+            composition_models = default_composition_models;
+
+
+            // find the default value, which is the closest to the current path
+            for (searchback = 0; searchback < path.size(); ++searchback)
+              {
+                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Get(parameters) != nullptr)
+                  {
+                    break;
+                  }
+              }
+
+            // if we can not find default value for the temperature model, skip it
+            if (searchback < path.size())
+              {
+
+                // copy the value, this unfortunately removes it.
+                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Get(parameters)->GetArray());
+
+                // now copy it
+                Value value2;
+                value2.CopyFrom(value1, parameters.GetAllocator());
+
+                // now we should have 2x the same value, so put it back and place it in the correct location.
+                Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
+
+                Pointer((base).c_str()).Get(parameters)->AddMember("composition models", value2, parameters.GetAllocator());
+                Pointer((base + "/composition model default entry").c_str()).Set(parameters,true);
+              }
+          }
+
+        // now do the same for grains
+        std::vector<std::shared_ptr<Grains::Interface> > grains_models;
+        if (!this->get_shared_pointers<Grains::Interface>("grains models", grains_models) ||
+            Pointer((base + "/grains model default entry").c_str()).Get(parameters) != nullptr)
+          {
+            grains_models = default_grains_models;
+
+
+            // find the default value, which is the closest to the current path
+            for (searchback = 0; searchback < path.size(); ++searchback)
+              {
+                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Get(parameters) != nullptr)
+                  {
+                    break;
+                  }
+              }
+
+            // if we can not find default value for the temperature model, skip it
+            if (searchback < path.size())
+              {
+
+                // copy the value, this unfortunately removes it.
+                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Get(parameters)->GetArray());
+
+                // now copy it
+                Value value2;
+                value2.CopyFrom(value1, parameters.GetAllocator());
+
+                // now we should have 2x the same value, so put it back and place it in the correct location.
+                Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
+
+                Pointer((base).c_str()).Get(parameters)->AddMember("grains models", value2, parameters.GetAllocator());
+                Pointer((base + "/grains model default entry").c_str()).Set(parameters,true);
+              }
+          }
+        vector.emplace_back(length, thickness, top_truncation, angle, temperature_models, composition_models, grains_models);
+
+        this->leave_subsection();
+      }
+
+    this->leave_subsection();
+    return vector;
+  }
+
+  template<>
+  std::vector<double>
+  Parameters::get_vector(const std::string &name)
+  {
+    std::vector<double> vector;
+    const std::string strict_base = this->get_full_json_path();
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+        for (size_t i = 0; i < array->Size(); ++i )
+          {
+            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+
+            vector.push_back(Pointer(base.c_str()).Get(parameters)->GetDouble());
+          }
+      }
+    else
+      {
+        const Value *value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/minItems").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the minItems value at: "
+                      << this->get_full_json_schema_path() + "/" + name + "/minItems");
+
+        const size_t min_size = value->GetUint();
+
+        value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/items/default value").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << this->get_full_json_schema_path() + "/" + name + "/default value");
+
+        const double default_value = value->GetDouble();
+
+        // set to min size
+        for (size_t i = 0; i < min_size; ++i)
+          {
+            vector.push_back(default_value);
+          }
+      }
+    return vector;
+  }
+
+  template<>
+  std::vector<size_t>
+  Parameters::get_vector(const std::string &name)
+  {
+    std::vector<size_t> vector;
+    const std::string strict_base = this->get_full_json_path();
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+        for (size_t i = 0; i < array->Size(); ++i )
+          {
+            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+
+            vector.push_back(Pointer(base.c_str()).Get(parameters)->GetUint());
+          }
+      }
+    else
+      {
+        const Value *value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/minItems").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the minItems value at: "
+                      << this->get_full_json_schema_path() + "/" + name + "/minItems");
+
+        const size_t min_size = value->GetUint();
+
+        value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/items/default value").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << this->get_full_json_schema_path() + "/" + name + "/default value");
+
+        const size_t default_value = value->GetUint();
+
+        // set to min size
+        for (size_t i = 0; i < min_size; ++i)
+          {
+            vector.push_back(default_value);
+          }
+      }
+    return vector;
+  }
+
+  template<>
+  std::vector<unsigned int>
+  Parameters::get_vector(const std::string &name)
+  {
+    std::vector<unsigned int> vector;
+    const std::string strict_base = this->get_full_json_path();
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+        for (size_t i = 0; i < array->Size(); ++i )
+          {
+            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+
+            vector.push_back(Pointer(base.c_str()).Get(parameters)->GetUint());
+          }
+      }
+    else
+      {
+        const Value *value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/minItems").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the minItems value at: "
+                      << this->get_full_json_schema_path() + "/" + name + "/minItems value");
+
+        const size_t min_size = value->GetUint();
+
+        const unsigned int default_value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/items/default value").c_str()).Get(declarations)->GetUint();
+
+        // set to min size
+        for (size_t i = 0; i < min_size; ++i)
+          {
+            vector.push_back(default_value);
+          }
+      }
+    return vector;
+  }
+
+  template<class T>
+  std::unique_ptr<T>
+  Parameters::get_unique_pointer(const std::string &name)
+  {
+    const std::string base = this->get_full_json_path();
+    Value *value = Pointer((base + "/" + name + "/model").c_str()).Get(parameters);
+
+#ifdef debug
+    bool required = false;
+    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
+      for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
+        {
+          if (v.GetString() == name)
+            {
+              required = true;
+            }
+        }
+
+    WBAssert(value != NULL || required == false,
+             "Internal error: Value \"" << base << '/' << name << "/model\" not found in the input file, while it was set as required.");
+#endif
+    if (value == nullptr)
+      {
+        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
+        WBAssertThrow(value != nullptr,
+                      "internal error: could not retrieve the default value at: "
+                      << base + "/" + name + "/default value. Make sure the value has been declared.");
+      }
+
+    return T::create(value->GetString(),&world);
+  }
+
+  template<class T>
+  bool
+  Parameters::get_unique_pointers(const std::string &name, std::vector<std::unique_ptr<T> > &vector)
+  {
+    vector.resize(0);
+    const std::string strict_base = this->get_full_json_path();
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+        for (size_t i = 0; i < array->Size(); ++i )
+          {
+            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+
+            const std::string value = Pointer((base + "/model").c_str()).Get(parameters)->GetString();
+
+            vector.push_back(std::move(T::create(value, &world)));
+          }
+      }
+    else
+      {
+        return false;
+      }
+
+    return true;
+  }
+
+  template<>
+  bool
+  Parameters::get_unique_pointers(const std::string &name, std::vector<std::unique_ptr<Features::SubductingPlate> > &vector)
+  {
+    vector.resize(0);
+    const std::string strict_base = this->get_full_json_path();
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+        for (size_t i = 0; i < array->Size(); ++i )
+          {
+            vector.push_back(std::make_unique<Features::SubductingPlate>(&world));
+          }
+      }
+    else
+      {
+        return false;
+      }
+
+    return true;
+  }
+
+  template<>
+  bool
+  Parameters::get_unique_pointers(const std::string &name, std::vector<std::unique_ptr<Features::Fault> > &vector)
+  {
+    vector.resize(0);
+    const std::string strict_base = this->get_full_json_path();
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+        for (size_t i = 0; i < array->Size(); ++i )
+          {
+            vector.push_back(std::make_unique<Features::Fault>(&world));
+          }
+      }
+    else
+      {
+        return false;
+      }
+
+    return true;
+  }
+
+
+
+  template<class T>
+  bool
+  Parameters::get_shared_pointers(const std::string &name, std::vector<std::shared_ptr<T> > &vector)
+  {
+    vector.resize(0);
+    const std::string strict_base = this->get_full_json_path();
+    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
+      {
+        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
+
+        for (size_t i = 0; i < array->Size(); ++i )
+          {
+            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
+
+            const std::string value = Pointer((base + "/model").c_str()).Get(parameters)->GetString();
+
+            vector.push_back(std::move(T::create(value, &world)));
+          }
+      }
+    else
+      {
+        return false;
+      }
+
+    return true;
+  }
+
+  void
+  Parameters::enter_subsection(const std::string &name)
+  {
+    path.push_back(name);
+    //TODO: WBAssert(is path valid?)
+  }
+
+  void
+  Parameters::leave_subsection()
+  {
+    path.pop_back();
+  }
+
+
+
+  void
+  Parameters::declare_model_entries(const std::string &model_group_name,
+                                    const std::string &parent_name,
+                                    const std::map<std::string, void ( *)(Parameters &,const std::string &)> &declare_map,
+                                    const std::vector<std::string> &required_entries,
+                                    const std::vector<std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string> > &extra_declarations)
+  {
+    unsigned int counter = 0;
+    for (const auto &it : declare_map)
+      {
+        typedef std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string> DeclareEntry;
+        // prevent infinite recursion
+        if (it.first != parent_name)
+          {
+            enter_subsection("oneOf");
+            {
+              enter_subsection(std::to_string(counter));
+              {
+                enter_subsection("properties");
+                {
+                  declare_entry("", Types::Object(required_entries), model_group_name + " object");
+
+                  declare_entry("model", Types::String("",it.first),
+                                "The name of the " + model_group_name + " model.");
+
+                  for (DeclareEntry extra_declaration : extra_declarations)
+                    {
+                      declare_entry(std::get<0>(extra_declaration),std::get<1>(extra_declaration),std::get<2>(extra_declaration));
+                    }
+
+
+                  it.second(*this, parent_name);
+                }
+                leave_subsection();
+              }
+              leave_subsection();
+            }
+            leave_subsection();
+
+            counter++;
+
+          }
+      }
+  }
+
+
+
+  std::string
+  Parameters::get_full_json_path(size_t max_size) const
+  {
+    std::string collapse;
+    for (size_t i = 0; i < path.size() && i < max_size; i++)
+      {
+        collapse +=  "/" + path[i];
+      }
+    return collapse;
+  }
+
+  std::string
+  Parameters::get_full_json_schema_path() const
+  {
+    std::string collapse = "/properties";
+    for (size_t i = 0; i < path.size(); i++)
+      {
+        // first get the type
+        //WBAssert(Pointer((collapse + "/" + path[i] + "/type").c_str()).Get(declarations) != NULL, "Internal error: could not find " << collapse + "/" + path[i] + "/type");
+
+        const std::string base_path = Pointer((collapse + "/" + path[i] + "/type").c_str()).Get(declarations) != nullptr
+                                      ?
+                                      collapse + "/" + path[i]
+                                      :
+                                      collapse;
+
+        const std::string type = Pointer((base_path + "/type").c_str()).Get(declarations)->GetString();
+
+        if (type == "array")
+          {
+            // the type is an array. Arrays always have an items, but can also
+            // have a oneOf (todo: or anyOf ...). Find out whether this is the case
+            //collapse += path[i] + "/items";
+            if (Pointer((base_path + "/items/oneOf").c_str()).Get(declarations) != nullptr)
+              {
+                // it has a structure with oneOf. Find out which of the entries is needed.
+                // This means we have to take a sneak peak to figure out how to get to the
+                // next value.
+                const size_t size = Pointer((base_path + "/items/oneOf").c_str()).Get(declarations)->Size();
+#ifdef debug
+                bool found = false;
+#endif
+                size_t index = 0;
+                for (; index < size; ++index)
+                  {
+                    const std::string declarations_string = Pointer((base_path + "/items/oneOf/" + std::to_string(index)
+                                                                     + "/properties/model/enum/0").c_str()).Get(declarations)->GetString();
+
+                    // we need to get the json path relevant for the current declaration string
+                    // we are interested in, which requires an offset of 2.
+                    WBAssert(Pointer((get_full_json_path(i+2) + "/model").c_str()).Get(parameters) != nullptr, "Could not find model in: " << get_full_json_path(i+2) + "/model");
+                    const std::string parameters_string = Pointer((get_full_json_path(i+2) + "/model").c_str()).Get(parameters)->GetString();
+
+                    // currently in our case these are always objects, so go directly to find the option we need.
+                    if (declarations_string == parameters_string)
+                      {
+                        // found it for index i;
+#ifdef debug
+                        found = true;
+#endif
+                        break;
+                      }
+                  }
+#ifdef debug
+                WBAssert(found == true,
+                         "Internal error: This is an array with several possible values, "
+                         "but could not find the correct value " << collapse + "/" + path[i] + "/items/oneOf");
+#endif
+                collapse += "/" + path[i] + "/items/oneOf/" + std::to_string(index) + "/properties";
+                // add one to i, to skip the array
+                ++i;
+              }
+            else
+              {
+                collapse = base_path + "/items";
+              }
+          }
+        else if (type == "object")
+          {
+            // normal objects just have properties, but some have oneOf
+            if (Pointer((base_path + "/oneOf").c_str()).Get(declarations) != nullptr)
+              {
+                // it has a structure with oneOf. Find out which of the entries is needed.
+                // This means we have to take a sneak peak to figure out how to get to the
+                // next value.
+                const size_t size = Pointer((base_path + "/oneOf").c_str()).Get(declarations)->Size();
+#ifdef debug
+                bool found = false;
+#endif
+                size_t index = 0;
+                for (; index < size; ++index)
+                  {
+                    const std::string declarations_string = Pointer((base_path + "/oneOf/" + std::to_string(index)
+                                                                     + "/properties/model/enum/0").c_str()).Get(declarations)->GetString();
+
+                    // we need to get the json path relevant for the current declaration string
+                    // we are interested in, which requires an offset of 2.
+                    const Value *value = Pointer((get_full_json_path(i+2) + "/model").c_str()).Get(parameters);
+
+
+                    if (value == nullptr)
+                      {
+                        value = Pointer((collapse + "/" + path[i]  + "/default value").c_str()).Get(declarations);
+                        WBAssertThrow(value != nullptr,
+                                      "internal error: could not retrieve the default value at: "
+                                      << collapse + "/" + path[i]  + "/default value, for value: ");
+                      }
+
+                    const std::string parameters_string = value->GetString();
+
+                    // currently in our case these are always objects, so go directly to find the option we need.
+                    if (declarations_string == parameters_string)
+                      {
+                        // found it for index i;
+#ifdef debug
+                        found = true;
+#endif
+                        break;
+                      }
+                  }
+#ifdef debug
+                WBAssert(found == true,
+                         "Internal error: This is an array with several possible values, "
+                         "but could not find the correct value " << collapse + "/" + path[i] + "/items/oneOf");
+#endif
+                collapse += "/" + path[i] + "/oneOf/" + std::to_string(index) + "/properties";
+                // add one to i, to skip the array
+                ++i;
+
+              }
+            else
+              {
+                collapse += "/properties";
+              }
+          }
+        else
+          {
+            collapse += "/" + path[i];
+          }
+      }
+    return collapse;
+  }
+
+
+
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template std::unique_ptr<CoordinateSystems::Interface> Parameters::get_unique_pointer<CoordinateSystems::Interface>(const std::string &name);
+
+
+  /**
+   * Returns a vector of pointers to the Gravity Model based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template std::unique_ptr<GravityModel::Interface> Parameters::get_unique_pointer<GravityModel::Interface>(const std::string &name);
+
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template bool
+  Parameters::get_unique_pointers<Features::Interface>(const std::string &name,
+                                                       std::vector<std::unique_ptr<Features::Interface> > &vector);
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template bool
+  Parameters::get_unique_pointers<Features::ContinentalPlateModels::Temperature::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::ContinentalPlateModels::Temperature::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::ContinentalPlateModels::Composition::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::ContinentalPlateModels::Composition::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::ContinentalPlateModels::Grains::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::ContinentalPlateModels::Grains::Interface> > &vector);
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template bool
+  Parameters::get_unique_pointers<Features::PlumeModels::Temperature::Interface>(const std::string &name,
+                                                                                 std::vector<std::unique_ptr<Features::PlumeModels::Temperature::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::PlumeModels::Composition::Interface>(const std::string &name,
+                                                                                 std::vector<std::unique_ptr<Features::PlumeModels::Composition::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::PlumeModels::Grains::Interface>(const std::string &name,
+                                                                            std::vector<std::unique_ptr<Features::PlumeModels::Grains::Interface> > &vector);
+
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template bool
+  Parameters::get_unique_pointers<Features::OceanicPlateModels::Temperature::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::OceanicPlateModels::Temperature::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::OceanicPlateModels::Composition::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::OceanicPlateModels::Composition::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::OceanicPlateModels::Grains::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::OceanicPlateModels::Grains::Interface> > &vector);
+
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template bool
+  Parameters::get_unique_pointers<Features::MantleLayerModels::Temperature::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::MantleLayerModels::Temperature::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::MantleLayerModels::Composition::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::MantleLayerModels::Composition::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::MantleLayerModels::Grains::Interface>(const std::string &name,
+                                                                                  std::vector<std::unique_ptr<Features::MantleLayerModels::Grains::Interface> > &vector);
+
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template bool
+  Parameters::get_unique_pointers<Features::SubductingPlateModels::Temperature::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::SubductingPlateModels::Temperature::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::SubductingPlateModels::Composition::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::SubductingPlateModels::Composition::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::SubductingPlateModels::Grains::Interface>(const std::string &name,
+      std::vector<std::unique_ptr<Features::SubductingPlateModels::Grains::Interface> > &vector);
+
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template bool
+  Parameters::get_unique_pointers<Features::FaultModels::Temperature::Interface>(const std::string &name,
+                                                                                 std::vector<std::unique_ptr<Features::FaultModels::Temperature::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::FaultModels::Composition::Interface>(const std::string &name,
+                                                                                 std::vector<std::unique_ptr<Features::FaultModels::Composition::Interface> > &vector);
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_unique_pointers<Features::FaultModels::Grains::Interface>(const std::string &name,
+                                                                            std::vector<std::unique_ptr<Features::FaultModels::Grains::Interface> > &vector);
+
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template bool
+  Parameters::get_shared_pointers<Features::SubductingPlateModels::Temperature::Interface>(const std::string &name,
+      std::vector<std::shared_ptr<Features::SubductingPlateModels::Temperature::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_shared_pointers<Features::SubductingPlateModels::Composition::Interface>(const std::string &name,
+      std::vector<std::shared_ptr<Features::SubductingPlateModels::Composition::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_shared_pointers<Features::SubductingPlateModels::Grains::Interface>(const std::string &name,
+      std::vector<std::shared_ptr<Features::SubductingPlateModels::Grains::Interface> > &vector);
+
+
+  /**
+   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+   * Note that the variable with this name has to be loaded before this function is called.
+   */
+  template bool
+  Parameters::get_shared_pointers<Features::FaultModels::Temperature::Interface>(const std::string &name,
+                                                                                 std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> > &vector);
+
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_shared_pointers<Features::FaultModels::Composition::Interface>(const std::string &name,
+                                                                                 std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface> > &vector);
+  /**
+  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
+  * Note that the variable with this name has to be loaded before this function is called.
+  */
+  template bool
+  Parameters::get_shared_pointers<Features::FaultModels::Grains::Interface>(const std::string &name,
+                                                                            std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface> > &vector);
+
+
+
+
+
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/point.cc.bak b/contrib/world_builder/source/world_builder/point.cc.bak
new file mode 100644
index 00000000000..e04402d4158
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/point.cc.bak
@@ -0,0 +1,108 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/point.h"
+
+#include <limits>
+
+namespace WorldBuilder
+{
+
+  template<>
+  Point<2>::Point(const double x, const double y, const CoordinateSystem coordinate_system_)
+    :
+    point({{x,y}}),
+  coordinate_system(coordinate_system_)
+  {}
+
+  template<>
+  Point<3>::Point(const double /*x*/, const double /*y*/, CoordinateSystem coordinate_system_)
+    :
+    point({{std::numeric_limits<double>::signaling_NaN(),std::numeric_limits<double>::signaling_NaN(), std::numeric_limits<double>::signaling_NaN()}}),
+  coordinate_system(coordinate_system_)
+  {
+    WBAssertThrow(false,"Can't use the 2d constructor in 3d.");
+  }
+
+
+  template<>
+  Point<2>::Point(const double /*x*/, const double /*y*/, const double /*z*/, CoordinateSystem coordinate_system_)
+    :
+    point({{std::numeric_limits<double>::signaling_NaN(),std::numeric_limits<double>::signaling_NaN()}}),
+  coordinate_system(coordinate_system_)
+  {
+    WBAssertThrow(false,"Can't use the 3d constructor in 2d.");
+  }
+
+
+  template<>
+  Point<3>::Point(const double x, const double y, const double z, CoordinateSystem coordinate_system_)
+    :
+    point({{x,y,z}}),
+  coordinate_system(coordinate_system_)
+  {}
+
+
+
+
+
+
+
+  template<unsigned int dim>
+  double
+  Point<dim>::distance(const Point<2> &two) const
+  {
+    if (this->coordinate_system == spherical)
+      {
+        // spherical
+        const double d_longitude = two[0] - this->point[0];
+        const double d_latitude = two[1] - this->point[1];
+        const double sin_d_lat = std::sin(d_latitude * 0.5);
+        const double sin_d_long = std::sin(d_longitude * 0.5);
+        return 2.0 * asin(sqrt((sin_d_lat * sin_d_lat) + (sin_d_long*sin_d_long) * std::cos(this->point[1]) * std::cos(two[1])));
+      }
+
+    // cartesian
+    const double x_distance_to_reference_point = point[0]-two[0];
+    const double y_distance_to_reference_point = point[1]-two[1];
+    return sqrt((x_distance_to_reference_point*x_distance_to_reference_point) + (y_distance_to_reference_point*y_distance_to_reference_point));
+
+  }
+
+  /**
+   * The 2d version of the point class.
+   */
+  template class Point<2>;
+
+
+  /**
+   * The 3d version of the point class.
+   */
+  template class Point<3>;
+
+  /**
+   * Multiplies a 2d point with a scalar.
+   */
+  template Point<2> operator*(const double scalar, const Point<2> &point);
+
+  /**
+   * Multiplies a 3d point with a scalar.
+   */
+  template Point<3> operator*(const double scalar, const Point<3> &point);
+} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/types/array.cc.bak b/contrib/world_builder/source/world_builder/types/array.cc.bak
new file mode 100644
index 00000000000..7c62626a976
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/array.cc.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/types/array.h"
+
+#include "world_builder/parameters.h"
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+    Array::Array(const Interface &type,
+                 const unsigned int min_items_,
+                 const unsigned int max_items_,
+                 const bool unique_items_)
+      :
+      inner_type(type.get_type()),
+      inner_type_ptr(type.clone()),
+      required(false),
+      min_items(min_items_),
+      max_items(max_items_),
+      unique_items(unique_items_)
+    {
+      this->type_name = Types::type::Array;
+    }
+
+    Array::Array(Array const &other)
+      :
+      inner_type(other.inner_type),
+      inner_type_ptr(other.inner_type_ptr->clone()),
+      required(other.required),
+      min_items(other.min_items),
+      max_items(other.max_items),
+      unique_items(other.unique_items)
+    {
+      this->type_name = Types::type::Array;
+    }
+
+    Array::~Array ()
+      = default;
+
+
+    void
+    Array::write_schema(Parameters &prm,
+                        const std::string &name,
+                        const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+      const std::string &base = prm.get_full_json_path() + "/" + name;
+
+      Pointer((base + "/type").c_str()).Set(declarations,"array");
+      Pointer((base + "/minItems").c_str()).Set(declarations,min_items);
+      Pointer((base + "/maxItems").c_str()).Set(declarations,max_items);
+      Pointer((base + "/uniqueItems").c_str()).Set(declarations,unique_items);
+      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+
+      prm.enter_subsection(name);
+      {
+        WBAssertThrow(this->inner_type_ptr != nullptr, "Internal error, inner pointer is NULL.");
+        this->inner_type_ptr->write_schema(prm, "items", "");
+      }
+      prm.leave_subsection();
+
+
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/bool.cc.bak b/contrib/world_builder/source/world_builder/types/bool.cc.bak
new file mode 100644
index 00000000000..94ee122cbfb
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/bool.cc.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/types/bool.h"
+
+#include "world_builder/parameters.h"
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+    Bool::Bool(const bool default_value_)
+      :
+      default_value(default_value_)
+    {
+      this->type_name = Types::type::Bool;
+    }
+
+
+    Bool::Bool(Bool const &other)
+      :
+      default_value(other.default_value)
+    {
+      this->type_name = Types::type::Bool;
+    }
+
+
+    Bool::~Bool ()
+      = default;
+
+
+    void
+    Bool::write_schema(Parameters &prm,
+                       const std::string &name,
+                       const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+      const std::string base = prm.get_full_json_path() + "/" + name;
+
+      Pointer((base + "/default value").c_str()).Set(declarations,default_value);
+      Pointer((base + "/type").c_str()).Set(declarations,"boolean");
+      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/double.cc.bak b/contrib/world_builder/source/world_builder/types/double.cc.bak
new file mode 100644
index 00000000000..3d1e1f2a48b
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/double.cc.bak
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/types/double.h"
+
+#include "world_builder/parameters.h"
+#include <cmath>
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+    Double::Double(const double default_value_)
+      :
+      default_value(default_value_)
+    {
+      this->type_name = Types::type::Double;
+    }
+
+
+    Double::Double(Double const &other)
+      :
+      default_value(other.default_value)
+    {
+      this->type_name = Types::type::Double;
+    }
+
+
+
+    Double::~Double ()
+      = default;
+
+
+    void
+    Double::write_schema(Parameters &prm,
+                         const std::string &name,
+                         const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+      const std::string base = prm.get_full_json_path() + "/" + name;
+
+      if (std::isnan(default_value))
+        Pointer((base + "/default value").c_str()).Set(declarations,"NaN");
+      else
+        Pointer((base + "/default value").c_str()).Set(declarations,default_value);
+
+      Pointer((base + "/type").c_str()).Set(declarations,"number");
+      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/int.cc.bak b/contrib/world_builder/source/world_builder/types/int.cc.bak
new file mode 100644
index 00000000000..a18c7ef3882
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/int.cc.bak
@@ -0,0 +1,64 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/types/int.h"
+
+#include "world_builder/parameters.h"
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+    Int::Int(int default_value_)
+      :
+
+      default_value(default_value_)
+    {
+      this->type_name = Types::type::Int;
+    }
+
+
+    Int::Int(Int const &other)
+      :
+      value(other.value),
+      default_value(other.default_value)
+    {
+      this->type_name = Types::type::Int;
+    }
+
+    Int::~Int ()
+      = default;
+
+
+    void
+    Int::write_schema(Parameters &prm,
+                      const std::string &name,
+                      const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+
+      const std::string base = prm.get_full_json_path() + "/" + name;
+      Pointer((base + "/default value").c_str()).Set(declarations,default_value);
+      Pointer((base + "/type").c_str()).Set(declarations,"integer");
+      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/interface.cc.bak b/contrib/world_builder/source/world_builder/types/interface.cc.bak
new file mode 100644
index 00000000000..c1bd9560ae4
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/interface.cc.bak
@@ -0,0 +1,45 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/types/interface.h"
+
+
+
+namespace WorldBuilder
+{
+
+  namespace Types
+  {
+    Interface::Interface()
+
+
+      = default;
+
+    Interface::~Interface ()
+      = default;
+
+
+    type
+    Interface::get_type() const
+    {
+      return type_name;
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/object.cc.bak b/contrib/world_builder/source/world_builder/types/object.cc.bak
new file mode 100644
index 00000000000..fce574bd90e
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/object.cc.bak
@@ -0,0 +1,91 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/types/object.h"
+
+
+#include "world_builder/parameters.h"
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+    Object::Object(std::vector<std::string> required_,
+                   const bool additional_properties_)
+      :
+      required(std::move(required_)),
+      additional_properties(additional_properties_)
+    {
+      this->type_name = Types::type::Object;
+    }
+
+    Object::Object(Object const &other)
+      :
+      required(other.required),
+      additional_properties(other.additional_properties)
+    {
+      this->type_name = Types::type::Object;
+    }
+
+    Object::~Object ()
+      = default;
+
+    void
+    Object::write_schema(Parameters &prm,
+                         const std::string & /*name*/,
+                         const std::string &documentation) const
+    {
+      // The object has to be defined just above the properties section.
+      // because it is very inconvenient to make this object there, we
+      // take care here to do that.
+      WBAssertThrow(!prm.path.empty() && prm.path.back() == "properties",
+                    "The Object must be defined in a subsection called properties.");
+      prm.leave_subsection();
+      {
+        using namespace rapidjson;
+        Document &declarations = prm.declarations;
+        const std::string path = prm.get_full_json_path();
+
+        Pointer((path + "/type").c_str()).Set(declarations,"object");
+        Pointer((path + "/description").c_str()).Set(declarations,documentation.c_str());
+        Pointer((path + "/additionalProperties").c_str()).Set(declarations,additional_properties);
+
+        if (!required.empty())
+          {
+            for (unsigned int i = 0; i < required.size(); ++i)
+              {
+                if (i == 0 && Pointer((path + "/required").c_str()).Get(declarations) == nullptr)
+                  {
+                    // The required array doesn't exist yet, so we create it and fill it.
+                    Pointer((path + "/required/0").c_str()).Create(declarations);
+                    Pointer((path + "/required/0").c_str()).Set(declarations, required[i].c_str());
+                  }
+                else
+                  {
+                    // The required array already exist yet, so we add an element to the end.
+                    Pointer((path + "/required/-").c_str()).Set(declarations, required[i].c_str());
+                  }
+              }
+          }
+      }
+      prm.enter_subsection("properties");
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/one_of.cc.bak b/contrib/world_builder/source/world_builder/types/one_of.cc.bak
new file mode 100644
index 00000000000..8ee982bb1c1
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/one_of.cc.bak
@@ -0,0 +1,77 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/types/one_of.h"
+
+#include "world_builder/parameters.h"
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+    OneOf::OneOf(const Interface &type_1,
+                 const Interface &type_2)
+    {
+      this->type_name = Types::type::OneOf;
+      inner_types_ptr.emplace_back(type_1.clone());
+      inner_types_ptr.emplace_back(type_2.clone());
+
+    }
+
+    OneOf::OneOf(OneOf const &other)
+    {
+      this->type_name = Types::type::OneOf;
+      for (const auto &i : other.inner_types_ptr)
+        {
+          inner_types_ptr.emplace_back(i->clone());
+        }
+    }
+
+    OneOf::~OneOf ()
+      = default;
+
+
+    void
+    OneOf::write_schema(Parameters &prm,
+                        const std::string &name,
+                        const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+      const std::string &base = prm.get_full_json_path() + "/" + name;
+
+      prm.enter_subsection(name);
+      {
+        Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+        prm.enter_subsection("oneOf");
+        {
+          for (size_t i = 0; i < inner_types_ptr.size(); i++)
+            {
+              WBAssertThrow(inner_types_ptr[i] != nullptr, "Internal error, inner pointer is NULL.");
+              inner_types_ptr[i]->write_schema(prm, std::to_string(i), "");
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/plugin_system.cc.bak b/contrib/world_builder/source/world_builder/types/plugin_system.cc.bak
new file mode 100644
index 00000000000..4e5d23d1c33
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/plugin_system.cc.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/types/plugin_system.h"
+
+
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+    PluginSystem::PluginSystem(std::string default_value_,
+                               void ( *declare_entries_)(Parameters &, const std::string &, const std::vector<std::string> &),
+                               std::vector<std::string> required_entries_,
+                               const bool allow_multiple_)
+      :
+      default_value(std::move(default_value_)),
+      declare_entries(declare_entries_),
+      required_entries(std::move(required_entries_)),
+      allow_multiple(allow_multiple_)
+    {
+      this->type_name = Types::type::PluginSystem;
+
+      WBAssert(declare_entries_ != nullptr, "declare entries may not be a null pointer.");
+    }
+
+
+    PluginSystem::PluginSystem(PluginSystem const &plugin_system)
+      :
+      default_value(plugin_system.default_value),
+      declare_entries(plugin_system.declare_entries),
+      required_entries(plugin_system.required_entries),
+      allow_multiple(plugin_system.allow_multiple)
+    {
+      this->type_name = Types::type::PluginSystem;
+    }
+
+    PluginSystem::~PluginSystem ()
+      = default;
+
+    void
+    PluginSystem::write_schema(Parameters &prm,
+                               const std::string &name,
+                               const std::string &documentation) const
+    {
+      using namespace rapidjson;
+
+      prm.enter_subsection(name);
+      {
+        const std::string path = prm.get_full_json_path();
+        Pointer((path + "/description").c_str()).Set(prm.declarations,documentation.c_str());
+        Pointer((path + "/default value").c_str()).Set(prm.declarations,default_value.c_str());
+
+        if (allow_multiple)
+          {
+            Pointer((path + "/type").c_str()).Set(prm.declarations,"array");
+
+            prm.enter_subsection("items");
+            {
+              WBAssert(this->declare_entries != nullptr, "No declare entries given.");
+
+              this->declare_entries(prm, name, required_entries);
+            }
+            prm.leave_subsection();
+          }
+        else
+          {
+            Pointer((path + "/type").c_str()).Set(prm.declarations,"object");
+
+            WBAssert(this->declare_entries != nullptr, "No declare entries given.");
+            this->declare_entries(prm, name, required_entries);
+
+
+          }
+      }
+      prm.leave_subsection();
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/point.cc.bak b/contrib/world_builder/source/world_builder/types/point.cc.bak
new file mode 100644
index 00000000000..977fe601183
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/point.cc.bak
@@ -0,0 +1,185 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/types/point.h"
+
+
+#include "world_builder/parameters.h"
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+
+    template <unsigned int dim>
+    Point<dim>::Point()
+      :
+      value(WorldBuilder::Point<dim>(CoordinateSystem::cartesian)),
+      default_value(WorldBuilder::Point<dim>(CoordinateSystem::cartesian))
+
+    {
+      this->type_name = dim == 2 ? Types::type::Point2D : Types::type::Point3D;
+    }
+
+    template <unsigned int dim>
+    Point<dim>::Point(const WorldBuilder::Point<dim> &default_value_,
+                      std::string description_)
+      :
+      value(default_value_),
+      default_value(default_value_),
+      description(std::move(description_))
+    {
+      this->type_name = dim == 2 ? Types::type::Point2D : Types::type::Point3D;
+    }
+
+    template <unsigned int dim>
+    Point<dim>::Point(const WorldBuilder::Point<dim> &value_,
+                      const WorldBuilder::Point<dim> &default_value_,
+                      std::string description_)
+      :
+      value(value_),
+      default_value(default_value_),
+      description(std::move(description_))
+    {
+      this->type_name = dim == 2 ? Types::type::Point2D : Types::type::Point3D;
+    }
+
+    template <unsigned int dim>
+    Point<dim>::Point(Point const &other)
+      :
+      value(other.value),
+      default_value(other.default_value),
+      description(other.description)
+    {
+      this->type_name = dim == 2 ? Types::type::Point2D : Types::type::Point3D;
+    }
+
+    template <unsigned int dim>
+    Point<dim>::~Point ()
+      = default;
+
+    template<unsigned int dim>
+    void
+    Point<dim>::write_schema(Parameters &prm,
+                             const std::string &name,
+                             const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+      const std::string base = prm.get_full_json_path() + "/" + name;
+
+      Pointer((base + "/type").c_str()).Set(declarations,"array");
+      Pointer((base + "/minItems").c_str()).Set(declarations,dim);
+      Pointer((base + "/maxItems").c_str()).Set(declarations,dim);
+      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+      Pointer((base + "/items/type").c_str()).Set(declarations,"number");
+      // todo: default value
+    }
+
+
+    template<unsigned int dim>
+    double Point<dim>::operator*(const Point<dim> &point_) const
+    {
+      const std::array<double,dim> array = point_.value.get_array();
+      double dot_product = 0;
+      for (unsigned int i = 0; i < dim; ++i)
+        dot_product += value[i] * array[i];
+      return dot_product;
+    }
+
+
+    template<unsigned int dim>
+    WorldBuilder::Point<dim>
+    Point<dim>::operator*(const double scalar) const
+    {
+      // initialize the array to zero.
+      std::array<double,dim> array = WorldBuilder::Point<dim>(value.get_coordinate_system()).get_array();
+      for (unsigned int i = 0; i < dim; ++i)
+        array[i] += value[i] * scalar;
+      return WorldBuilder::Point<dim>(array,value.get_coordinate_system());
+    }
+
+    template<unsigned int dim>
+    WorldBuilder::Point<dim>
+    Point<dim>::operator+(const Point<dim> &point_) const
+    {
+      WorldBuilder::Point<dim> point_tmp(value);
+      point_tmp += point_.value;
+
+      return point_tmp;
+    }
+
+    template<unsigned int dim>
+    WorldBuilder::Point<dim>
+    Point<dim>::operator-(const Point<dim> &point_) const
+    {
+      WorldBuilder::Point<dim> point_tmp(value);
+      point_tmp -= point_.value;
+
+      return point_tmp;
+    }
+
+    /**
+     * access index
+     */
+    template<unsigned int dim>
+    double &
+    Point<dim>::operator[](const unsigned int index)
+    {
+      return value[index];
+    }
+
+    /**
+     * access index
+     */
+    template<unsigned int dim>
+    const double &
+    Point<dim>::operator[](const unsigned int index) const
+    {
+      return value[index];
+    }
+
+    /**
+     * Multiplies a Types::Point<dim> with a scalr and returns a
+     * WorldBuilder::Point<dim>.
+     */
+    template<unsigned int dim>
+    WorldBuilder::Point<dim>
+    operator*(const double scalar, const Point<dim> &point)
+    {
+      return point.value*scalar;
+    }
+
+    template class Point<2>;
+    template class Point<3>;
+
+    /**
+     * Multiplies a Types::Point<2> with a scalr and returns a
+     * WorldBuilder::Point<2>.
+     */
+    template WorldBuilder::Point<2> operator*(const double scalar, const Point<2> &point);
+
+
+    /**
+     * Multiplies a Types::Point<3> with a scalr and returns a
+     * WorldBuilder::Point<3>.
+     */
+    template WorldBuilder::Point<3> operator*(const double scalar, const Point<3> &point);
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/segment.cc.bak b/contrib/world_builder/source/world_builder/types/segment.cc.bak
new file mode 100644
index 00000000000..b51c63c1a7a
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/segment.cc.bak
@@ -0,0 +1,170 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/types/segment.h"
+
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace FaultModels
+    namespace SubductingPlateModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace SubductingPlateModels
+  }  // namespace Features
+
+  namespace Types
+  {
+    Segment::Segment(const double default_length_,
+                     const WorldBuilder::Point<2> &default_thickness_,
+                     const WorldBuilder::Point<2> &default_top_truncation_,
+                     const WorldBuilder::Point<2> &default_angle_,
+                     const Types::Interface &temperature_plugin_system_,
+                     const Types::Interface &composition_plugin_system_,
+                     const Types::Interface &grains_plugin_system_)
+      :
+      value_length(default_length_),
+      default_length(default_length_),
+      value_thickness(default_thickness_),
+      default_thickness(default_thickness_),
+      default_top_truncation(default_top_truncation_),
+      value_angle(default_angle_),
+      default_angle(default_angle_),
+      temperature_plugin_system(temperature_plugin_system_.clone()),
+      composition_plugin_system(composition_plugin_system_.clone()),
+      grains_plugin_system(grains_plugin_system_.clone())
+    {
+      this->type_name = Types::type::Segment;
+    }
+
+
+    Segment::Segment(Segment const &other)
+      :
+      value_length(other.default_length),
+      default_length(other.default_length),
+      value_thickness(other.default_thickness),
+      default_thickness(other.default_thickness),
+      default_top_truncation(other.default_top_truncation),
+      value_angle(other.default_angle),
+      default_angle(other.default_angle),
+      temperature_plugin_system(other.temperature_plugin_system->clone()),
+      composition_plugin_system(other.composition_plugin_system->clone()),
+      grains_plugin_system(other.grains_plugin_system->clone())
+    {
+      this->type_name = Types::type::Segment;
+    }
+
+
+    Segment::~Segment ()
+      = default;
+
+
+
+    void
+    Segment::write_schema(Parameters &prm,
+                          const std::string &name,
+                          const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      prm.enter_subsection(name);
+      {
+        Document &declarations = prm.declarations;
+        std::string base = prm.get_full_json_path();
+
+        Pointer((base + "/type").c_str()).Set(declarations,"object");
+        Pointer((base + "/additionalProperties").c_str()).Set(declarations,false);
+        Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+        std::vector<std::string> restricted_values = {"length", "thickness", "angle"};
+        for (unsigned int i = 0; i < restricted_values.size(); ++i)
+          {
+            if (!restricted_values[i].empty())
+              {
+                if (i == 0 && Pointer((base + "/required").c_str()).Get(declarations) == nullptr)
+                  {
+                    // The enum array doesn't exist yet, so we create it and fill it.
+                    Pointer((base + "/required/0").c_str()).Create(declarations);
+                    Pointer((base + "/required/0").c_str()).Set(declarations, restricted_values[i].c_str());
+                  }
+                else
+                  {
+                    // The enum array already exist yet, so we add an element to the end.
+                    Pointer((base + "/required/-").c_str()).Set(declarations, restricted_values[i].c_str());
+                  }
+              }
+          }
+
+        prm.enter_subsection("properties");
+        {
+          base = prm.get_full_json_path();
+          Pointer((base + "/length/type").c_str()).Set(declarations,"number");
+
+          Pointer((base + "/thickness/type").c_str()).Set(declarations,"array");
+          Pointer((base + "/thickness/minItems").c_str()).Set(declarations,1);
+          Pointer((base + "/thickness/maxItems").c_str()).Set(declarations,2);
+          Pointer((base + "/thickness/items/type").c_str()).Set(declarations,"number");
+
+          Pointer((base + "/top truncation/type").c_str()).Set(declarations,"array");
+          Pointer((base + "/top truncation/minItems").c_str()).Set(declarations,1);
+          Pointer((base + "/top truncation/maxItems").c_str()).Set(declarations,2);
+          Pointer((base + "/top truncation/items/type").c_str()).Set(declarations,"number");
+
+          Pointer((base + "/angle/type").c_str()).Set(declarations,"array");
+          Pointer((base + "/angle/minItems").c_str()).Set(declarations,1);
+          Pointer((base + "/angle/maxItems").c_str()).Set(declarations,2);
+          Pointer((base + "/angle/items/type").c_str()).Set(declarations,"number");
+
+          temperature_plugin_system->write_schema(prm, "temperature models", "");
+          composition_plugin_system->write_schema(prm, "composition models", "");
+          grains_plugin_system->write_schema(prm, "grains models", "");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/string.cc.bak b/contrib/world_builder/source/world_builder/types/string.cc.bak
new file mode 100644
index 00000000000..903f9ed4c24
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/string.cc.bak
@@ -0,0 +1,120 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/types/string.h"
+
+
+#include "world_builder/parameters.h"
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+
+    String::String(std::string default_value_)
+      :
+      default_value(std::move(default_value_)),
+
+      restricted_values({})
+    {
+      this->type_name = Types::type::String;
+    }
+
+    String::String(std::string default_value_,
+                   const std::string &restricted_value_)
+      :
+      default_value(std::move(default_value_)),
+      restricted_values({restricted_value_})
+    {
+      this->type_name = Types::type::String;
+    }
+
+    String::String(String const &other)
+      :
+      value(other.value),
+      default_value(other.default_value)
+    {
+      this->type_name = Types::type::String;
+    }
+
+
+    String::String(std::string default_value_,
+                   std::vector<std::string> restricted_values_)
+      :
+      default_value(std::move(default_value_)),
+      restricted_values(std::move(restricted_values_))
+    {
+      this->type_name = Types::type::String;
+    }
+
+    /*String::String(std::string default_value, std::string description)
+      :
+      value(default_value),
+      default_value(default_value),
+      description(description)
+    {
+      this->type_name = Types::type::String;
+    }*/
+
+    String::String(std::string value_,
+                   std::string default_value_,
+                   std::string description_)
+      :
+      value(std::move(value_)),
+      default_value(std::move(default_value_)),
+      description(std::move(description_))
+    {
+      this->type_name = Types::type::String;
+    }
+
+    String::~String ()
+      = default;
+
+    void
+    String::write_schema(Parameters &prm,
+                         const std::string &name,
+                         const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+      const std::string base = prm.get_full_json_path() + "/" + name;
+      Pointer((base + "/default value").c_str()).Set(declarations,default_value.c_str());
+      Pointer((base + "/type").c_str()).Set(declarations,"string");
+      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+      for (unsigned int i = 0; i < restricted_values.size(); ++i)
+        {
+          if (!restricted_values[i].empty())
+            {
+              if (i == 0 && Pointer((base + "/enum").c_str()).Get(declarations) == nullptr)
+                {
+                  // The enum array doesn't exist yet, so we create it and fill it.
+                  Pointer((base + "/enum/0").c_str()).Create(declarations);
+                  Pointer((base + "/enum/0").c_str()).Set(declarations, restricted_values[i].c_str());
+                }
+              else
+                {
+                  // The enum array already exist yet, so we add an element to the end.
+                  Pointer((base + "/enum/-").c_str()).Set(declarations, restricted_values[i].c_str());
+                }
+            }
+        }
+    }
+
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/unsigned_int.cc.bak b/contrib/world_builder/source/world_builder/types/unsigned_int.cc.bak
new file mode 100644
index 00000000000..9109cb72b1b
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/unsigned_int.cc.bak
@@ -0,0 +1,64 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include "world_builder/types/unsigned_int.h"
+
+#include "world_builder/parameters.h"
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+    UnsignedInt::UnsignedInt(unsigned int default_value_)
+      :
+
+      default_value(default_value_)
+    {
+      this->type_name = Types::type::UnsignedInt;
+    }
+
+
+    UnsignedInt::UnsignedInt(UnsignedInt const &other)
+      :
+      value(other.value),
+      default_value(other.default_value)
+    {
+      this->type_name = Types::type::UnsignedInt;
+    }
+
+    UnsignedInt::~UnsignedInt ()
+      = default;
+
+
+    void
+    UnsignedInt::write_schema(Parameters &prm,
+                              const std::string &name,
+                              const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      Document &declarations = prm.declarations;
+
+      const std::string base = prm.get_full_json_path() + "/" + name;
+      Pointer((base + "/default value").c_str()).Set(declarations,default_value);
+      Pointer((base + "/type").c_str()).Set(declarations,"integer");
+      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+
+    }
+  } // namespace Types
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/types/value_at_points.cc.bak b/contrib/world_builder/source/world_builder/types/value_at_points.cc.bak
new file mode 100644
index 00000000000..ad51d48ed97
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/types/value_at_points.cc.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+#include <utility>
+
+#include "world_builder/types/value_at_points.h"
+
+#include "world_builder/parameters.h"
+
+
+namespace WorldBuilder
+{
+  namespace Types
+  {
+
+    ValueAtPoints::ValueAtPoints(const double default_value_,
+                                 uint64_t max_values_in_array_,
+                                 std::vector<Point<2>> default_points_)
+      :
+      default_value(default_value_),
+      max_values_in_array(max_values_in_array_),
+      default_points(std::move(std::move(default_points_)))
+    {
+      this->type_name = Types::type::ValueAtPoints;
+
+      WBAssert(default_points_.size() == 0, "default points are not implemented.");
+    }
+
+    ValueAtPoints::ValueAtPoints(ValueAtPoints const &other)
+      :
+      default_value(other.default_value),
+      max_values_in_array(other.max_values_in_array),
+      default_points(other.default_points)
+    {
+      this->type_name = Types::type::ValueAtPoints;
+    }
+
+
+    ValueAtPoints::~ValueAtPoints ()
+      = default;
+
+
+    void
+    ValueAtPoints::write_schema(Parameters &prm,
+                                const std::string &name,
+                                const std::string &documentation) const
+    {
+      using namespace rapidjson;
+      prm.enter_subsection(name);
+      {
+        Document &declarations = prm.declarations;
+        const std::string base = prm.get_full_json_path();
+
+        Pointer((base + "/type").c_str()).Set(declarations,"array");
+        Pointer((base + "/additionalProperties").c_str()).Set(declarations,false);
+        Pointer((base + "/minItems").c_str()).Set(declarations,1);
+        Pointer((base + "/maxItems").c_str()).Set(declarations, max_values_in_array);
+        Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
+
+        {
+          Pointer((base + "/items/anyOf/0/type").c_str()).Set(declarations,"number");
+          Pointer((base + "/items/anyOf/0/default value").c_str()).Set(declarations,default_value);
+
+          Pointer((base + "/items/anyOf/1/type").c_str()).Set(declarations,"array");
+          Pointer((base + "/items/anyOf/1/minItems").c_str()).Set(declarations,1);
+          Pointer((base + "/items/anyOf/1/maxItems").c_str()).Set(declarations,std::numeric_limits<unsigned int>::max());
+
+          Pointer((base + "/items/anyOf/1/items/type").c_str()).Set(declarations,"array");
+          Pointer((base + "/items/anyOf/1/items/minItems").c_str()).Set(declarations,1);
+          Pointer((base + "/items/anyOf/1/items/maxItems").c_str()).Set(declarations, max_values_in_array);
+
+          Pointer((base + "/items/anyOf/1/items/items/type").c_str()).Set(declarations,"number");
+        }
+      }
+      prm.leave_subsection();
+    }
+
+  } // namespace Types
+} // namespace WorldBuilder
+
+
diff --git a/contrib/world_builder/source/world_builder/utilities.cc.bak b/contrib/world_builder/source/world_builder/utilities.cc.bak
new file mode 100644
index 00000000000..90ecdf099fe
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/utilities.cc.bak
@@ -0,0 +1,1510 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/assert.h"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <sstream>
+
+#ifdef WB_WITH_MPI
+// we don't need the c++ MPI wrappers
+#define OMPI_SKIP_MPICXX 1
+#define MPICH_SKIP_MPICXX
+#include <mpi.h>
+#endif
+
+#include "world_builder/nan.h"
+#include "world_builder/utilities.h"
+#include <world_builder/coordinate_system.h>
+
+
+namespace WorldBuilder
+{
+  namespace Utilities
+  {
+    bool
+    polygon_contains_point(const std::vector<Point<2> > &point_list,
+                           const Point<2> &point)
+    {
+      if (point.get_coordinate_system() == CoordinateSystem::spherical)
+        {
+          Point<2> other_point = point;
+          other_point[0] += point[0] < 0 ? 2.0 * Consts::PI : -2.0 * Consts::PI;
+
+          return (polygon_contains_point_implementation(point_list, point) ||
+                  polygon_contains_point_implementation(point_list, other_point));
+        }
+
+      return polygon_contains_point_implementation(point_list, point);
+
+    }
+
+    bool
+    polygon_contains_point_implementation(const std::vector<Point<2> > &point_list,
+                                          const Point<2> &point)
+    {
+      /**
+       * This code has been based on http://geomalgorithms.com/a03-_inclusion.html,
+       * and therefore requires the following copyright notice:
+       *
+       * Copyright 2000 softSurfer, 2012 Dan Sunday
+       * This code may be freely used and modified for any purpose
+       * providing that this copyright notice is included with it.
+       * SoftSurfer makes no warranty for this code, and cannot be held
+       * liable for any real or imagined damage resulting from its use.
+       * Users of this code must verify correctness for their application.
+       *
+       * The main functional difference between the original code and this
+       * code is that all the boundaries are considered to be inside the
+       * polygon. One should of course realize that with floating point
+       * arithmetic no guarantees can be made for the borders, but for
+       * exact arithmetic this algorithm would work (also see polygon
+       * in point test).
+       */
+      const size_t pointNo = point_list.size();
+      size_t    wn = 0;    // the  winding number counter
+      size_t   j=pointNo-1;
+
+      // loop through all edges of the polygon
+      for (size_t i=0; i<pointNo; i++)
+        {
+          // edge from V[i] to  V[i+1]
+          if (point_list[j][1] <= point[1])
+            {
+              // first check if a point is directly on a line (within epsilon)
+              if (approx(point_list[i][0],point[0]) && approx(point_list[i][1],point[1]))
+                return true;
+              // start y <= P.y
+              if (point_list[i][1] >= point[1])      // an upward crossing
+                {
+                  const double is_left = (point_list[i][0] - point_list[j][0]) * (point[1] - point_list[j][1])
+                                         - (point[0] -  point_list[j][0]) * (point_list[i][1] - point_list[j][1]);
+
+                  if ( is_left > 0 && point_list[i][1] > point[1])
+                    {
+                      // P left of  edge
+                      ++wn;            // have  a valid up intersect
+                    }
+                  else if ( std::abs(is_left) < std::numeric_limits<double>::epsilon())
+                    {
+                      // The point is exactly on the infinite line.
+                      // determine if it is on the segment
+                      const double dot_product = (point - point_list[j])*(point_list[i] - point_list[j]);
+
+                      if (dot_product >= 0)
+                        {
+                          const double squaredlength = (point_list[i] - point_list[j]).norm_square();
+
+                          if (dot_product <= squaredlength)
+                            {
+                              return true;
+                            }
+                        }
+                    }
+                }
+            }
+          else
+            {
+              // start y > P.y (no test needed)
+              if (point_list[i][1]  <= point[1])     // a downward crossing
+                {
+                  const double is_left = (point_list[i][0] - point_list[j][0]) * (point[1] - point_list[j][1])
+                                         - (point[0] -  point_list[j][0]) * (point_list[i][1] - point_list[j][1]);
+
+                  if ( is_left < 0)
+                    {
+                      // P right of  edge
+                      --wn;            // have  a valid down intersect
+                    }
+                  else if (std::abs(is_left) < std::numeric_limits<double>::epsilon())
+                    {
+                      // This code is to make sure that the boundaries are included in the polygon.
+                      // The point is exactly on the infinite line.
+                      // determine if it is on the segment
+                      const double dot_product = (point - point_list[j])*(point_list[i] - point_list[j]);
+
+                      if (dot_product >= 0)
+                        {
+                          const double squaredlength = (point_list[i] - point_list[j]).norm_square();
+
+                          if (dot_product <= squaredlength)
+                            {
+                              return true;
+                            }
+                        }
+                    }
+                }
+            }
+          j=i;
+        }
+
+      return (wn != 0);
+    }
+
+
+
+    double
+    fraction_from_ellipse_center(const Point<2> &ellipse_center,
+                                 const double semi_major_axis,
+                                 const double eccentricity,
+                                 const double theta,
+                                 const Point<2> &point)
+    {
+      const double x_rotated = (point[0] - ellipse_center[0]) * std::cos(theta) + (point[1] - ellipse_center[1])* std::sin(theta);
+      const double y_rotated = -(point[0] - ellipse_center[0]) * std::sin(theta) + (point[1] - ellipse_center[1])* std::cos(theta);
+
+      const double semi_minor_axis = semi_major_axis * std::sqrt(1 - std::pow(eccentricity, 2));
+
+      if (semi_major_axis < 10 * std::numeric_limits<double>::min()
+          || semi_minor_axis < 10 * std::numeric_limits<double>::min())
+        return false;
+
+      const double ellipse = std::pow((x_rotated), 2) / std::pow(semi_major_axis, 2)
+                             + std::pow((y_rotated), 2) / std::pow(semi_minor_axis, 2);
+
+      return ellipse;
+    }
+
+
+
+    double
+    signed_distance_to_polygon(const std::vector<Point<2> > &point_list,
+                               const Point<2> &point)
+    {
+      // If the point lies outside polygon, we give it a negative sign,
+      // inside a positive sign.
+      const double sign = polygon_contains_point(point_list, point) ? 1.0 : -1.0;
+
+      /**
+       * This code is based on http://geomalgorithms.com/a02-_lines.html#Distance-to-Infinite-Line,
+       * and therefore requires the following copyright notice:
+       *
+       * Copyright 2000 softSurfer, 2012 Dan Sunday
+       * This code may be freely used and modified for any purpose
+       * providing that this copyright notice is included with it.
+       * SoftSurfer makes no warranty for this code, and cannot be held
+       * liable for any real or imagined damage resulting from its use.
+       * Users of this code must verify correctness for their application.
+       *
+       */
+
+      const size_t n_poly_points = point_list.size();
+      WBAssertThrow(n_poly_points >= 3, "Not enough polygon points were specified.");
+
+      // Initialize a vector of distances for each point of the polygon with a very large distance
+      std::vector<double> distances(n_poly_points, 1e23);
+
+      // Create another polygon but with all points shifted 1 position to the right
+      std::vector<Point<2> > shifted_point_list(n_poly_points, Point<2>(point.get_coordinate_system()));
+      shifted_point_list[0] = point_list[n_poly_points-1];
+
+      for (size_t i = 0; i < n_poly_points-1; ++i)
+        shifted_point_list[i+1] = point_list[i];
+
+      for (size_t i = 0; i < n_poly_points; ++i)
+        {
+          // Create vector along the polygon line segment
+          const Point<2> vector_segment = shifted_point_list[i] - point_list[i];
+          // Create vector from point to the second segment point
+          const Point<2> vector_point_segment = point - point_list[i];
+
+          // Compute dot products to get angles
+          const double c1 = vector_point_segment * vector_segment;
+          const double c2 = vector_segment * vector_segment;
+
+          // point lies closer to not-shifted polygon point, but perpendicular base line lies outside segment
+          if (c1 <= 0.0)
+            distances[i] = (Point<2> (point_list[i] - point)).norm();
+          // point lies closer to shifted polygon point, but perpendicular base line lies outside segment
+          else if (c2 <= c1)
+            distances[i] = (Point<2> (shifted_point_list[i] - point)).norm();
+          // perpendicular base line lies on segment
+          else
+            {
+              const Point<2> point_on_segment = point_list[i] + (c1/c2) * vector_segment;
+              distances[i] = (Point<2> (point - point_on_segment)).norm();
+            }
+        }
+
+      // Return the minimum of the distances of the point to all polygon segments
+      return *std::min_element(distances.begin(),distances.end()) * sign;
+    }
+
+
+    std::array<double,3>
+    cartesian_to_spherical_coordinates(const Point<3> &position)
+    {
+      std::array<double,3> scoord;
+
+      scoord[0] = position.norm(); // R
+      scoord[1] = std::atan2(position[1],position[0]); // Phi/long -> The result is always between -180 and 180 degrees: [-pi,pi]
+      //if (scoord[1] < 0.0)
+      //scoord[1] += 2.0*Consts::PI; // correct phi to [0,2*pi]
+
+      //lat
+      if (scoord[0] > std::numeric_limits<double>::min())
+        scoord[2] = 0.5 * Consts::PI - std::acos(position[2]/scoord[0]);
+      else
+        scoord[2] = 0.0;
+
+      return scoord;
+    }
+
+    Point<3>
+    spherical_to_cartesian_coordinates(const std::array<double,3> &scoord)
+    {
+      const double cos_lat = scoord[0] * std::sin(0.5 * Consts::PI - scoord[2]);
+
+      return Point<3>(cos_lat * std::cos(scoord[1]), // X
+                      cos_lat * std::sin(scoord[1]), // Y
+                      scoord[0] * std::cos(0.5 * Consts::PI - scoord[2]), // Z
+                      cartesian);;
+    }
+
+
+
+    CoordinateSystem
+    string_to_coordinate_system(const std::string &coordinate_system)
+    {
+      if (coordinate_system == "cartesian")
+        return CoordinateSystem::cartesian;
+      if (coordinate_system == "spherical")
+        return CoordinateSystem::spherical;
+      WBAssertThrow(false, "Coordinate system not implemented.");
+
+      return invalid;
+    }
+
+
+    template<unsigned int dim>
+    std::array<double,dim>
+    convert_point_to_array(const Point<dim> &point_)
+    {
+      std::array<double,dim> array;
+      for (size_t i = 0; i < dim; ++i)
+        array[i] = point_[i];
+      return array;
+    }
+
+    double
+    string_to_double(const std::string &string)
+    {
+      // trim whitespace on either side of the text if necessary
+      std::string s = string;
+      while ((!s.empty()) && (s[0] == ' '))
+        s.erase(s.begin());
+      while ((!s.empty()) && (s[s.size() - 1] == ' '))
+        s.erase(s.end() - 1);
+
+      std::istringstream i(s);
+      double d;
+      char c;
+      if (!(i >> d) || i.get(c))
+        WBAssertThrow(false, "Could not convert \"" + s + "\" to a double.");
+
+      return d;
+    }
+
+    int
+    string_to_int(const std::string &string)
+    {
+      // trim whitespace on either side of the text if necessary
+      std::string s = string;
+      while ((!s.empty()) && (s[0] == ' '))
+        s.erase(s.begin());
+      while ((!s.empty()) && (s[s.size() - 1] == ' '))
+        s.erase(s.end() - 1);
+
+      std::istringstream i(s);
+      int d;
+      char c;
+      if (!(i >> d) || i.get(c))
+        WBAssertThrow(false, "Could not convert \"" + s + "\" to an int.");
+
+      return d;
+    }
+
+
+    unsigned int
+    string_to_unsigned_int(const std::string &string)
+    {
+      // trim whitespace on either side of the text if necessary
+      std::string s = string;
+      while ((!s.empty()) && (s[0] == ' '))
+        s.erase(s.begin());
+      while ((!s.empty()) && (s[s.size() - 1] == ' '))
+        s.erase(s.end() - 1);
+
+
+      std::istringstream i(s);
+      unsigned int d;
+      char c;
+      if (!(i >> d) || i.get(c))
+        WBAssertThrow(false, "Could not convert \"" + s + "\" to an unsigned int.");
+
+      return d;
+    }
+
+
+    Point<3>
+    cross_product(const Point<3> &a, const Point<3> &b)
+    {
+      WBAssert(a.get_coordinate_system() == b.get_coordinate_system(), "Trying to do a cross product of points of a different coordinate system.");
+      const double x = a[1] * b[2] - b[1] * a[2];
+      const double y = a[2] * b[0] - b[2] * a[0];
+      const double z = a[0] * b[1] - b[0] * a[1];
+      return Point<3>(x,y,z,a.get_coordinate_system());
+    }
+
+    PointDistanceFromCurvedPlanes
+    distance_point_from_curved_planes(const Point<3> &check_point, // cartesian point in cartesian and spherical system
+                                      const Objects::NaturalCoordinate &natural_coordinate, // cartesian point cartesian system, spherical point in spherical system
+                                      const Point<2> &reference_point, // in (rad) spherical coordinates in spherical system
+                                      const std::vector<Point<2> > &point_list, // in  (rad) spherical coordinates in spherical system
+                                      const std::vector<std::vector<double> > &plane_segment_lengths,
+                                      const std::vector<std::vector<Point<2> > > &plane_segment_angles,
+                                      const double start_radius,
+                                      const std::unique_ptr<CoordinateSystems::Interface> &coordinate_system,
+                                      const bool only_positive,
+                                      const Objects::BezierCurve &bezier_curve)
+    {
+      double distance = std::numeric_limits<double>::infinity();
+      double new_distance = std::numeric_limits<double>::infinity();
+      double along_plane_distance = std::numeric_limits<double>::infinity();
+      double new_along_plane_distance  = std::numeric_limits<double>::infinity();
+      double new_depth_reference_surface = std::numeric_limits<double>::infinity();
+
+      const CoordinateSystem natural_coordinate_system = coordinate_system->natural_coordinate_system();
+      const bool bool_cartesian = natural_coordinate_system == cartesian;
+
+      const std::array<double,3> &check_point_surface_2d_array = natural_coordinate.get_coordinates();
+      const Point<3> check_point_surface(bool_cartesian ? check_point_surface_2d_array[0] : start_radius,
+                                         check_point_surface_2d_array[1],
+                                         bool_cartesian ? start_radius : check_point_surface_2d_array[2],
+                                         natural_coordinate_system);
+      const Point<2> check_point_surface_2d(natural_coordinate.get_surface_coordinates(),
+                                            natural_coordinate_system);
+
+      // The section which is checked.
+      size_t section = 0;
+
+      // The 'horizontal' fraction between the points at the surface.
+      double section_fraction = 0.0;
+
+      // What segment the point on the line is in.
+      size_t segment = 0;
+
+      // The 'vertical' fraction, indicates how far in the current segment the
+      // point on the line is.
+      double segment_fraction = 0.0;
+      double total_average_angle = 0.0;
+      double depth_reference_surface = 0.0;
+
+      const DepthMethod depth_method = coordinate_system->depth_method();
+
+      size_t i_section_min_distance = 0;
+      double fraction_CPL_P1P2 = std::numeric_limits<double>::infinity();
+
+      // get an estimate for the closest point between P1 and P2.
+      //constexpr double parts = 1;
+      //constexpr double one_div_parts = 1./parts;
+      //double minimum_distance_to_reference_point = std::numeric_limits<double>::infinity();
+      //const size_t number_of_points = point_list.size();
+
+      const Objects::ClosestPointOnCurve closest_point_on_curve = bezier_curve.closest_point_on_curve_segment(check_point_surface_2d);
+      Point<2> closest_point_on_line_2d = closest_point_on_curve.point;
+
+      // We now need 3d points from this point on, so make them.
+      // The order of a Cartesian coordinate is x,y,z and the order of
+      // a spherical coordinate it radius, long, lat (in rad).
+      const Point<3> closest_point_on_line_surface(bool_cartesian ? closest_point_on_line_2d[0] : start_radius,
+                                                   bool_cartesian ? closest_point_on_line_2d[1] : closest_point_on_line_2d[0],
+                                                   bool_cartesian ? start_radius : closest_point_on_line_2d[1],
+                                                   natural_coordinate_system);
+
+      const Point<3> closest_point_on_line_cartesian(coordinate_system->natural_to_cartesian_coordinates(closest_point_on_line_surface.get_array()),cartesian);
+
+      if (!std::isnan(closest_point_on_line_2d[0]))
+        {
+          i_section_min_distance = closest_point_on_curve.index;
+          fraction_CPL_P1P2 = closest_point_on_curve.parametric_fraction;
+
+          Point<3> closest_point_on_line_bottom = closest_point_on_line_surface;
+          closest_point_on_line_bottom[bool_cartesian ? 2 : 0] = 0;
+
+          WBAssert(!std::isnan(closest_point_on_line_bottom[0])
+                   &&
+                   !std::isnan(closest_point_on_line_bottom[1])
+                   &&
+                   !std::isnan(closest_point_on_line_bottom[2]),
+                   "Internal error: The closest_point_on_line_bottom variables variable contains not a number: " << closest_point_on_line_bottom);
+
+          // Now that we have both the check point and the
+          // closest_point_on_line, we need to push them to cartesian.
+          const Point<3> closest_point_on_line_bottom_cartesian(coordinate_system->natural_to_cartesian_coordinates(closest_point_on_line_bottom.get_array()),cartesian);
+          const Point<3> check_point_surface_cartesian(coordinate_system->natural_to_cartesian_coordinates(check_point_surface.get_array()),cartesian);
+
+
+          WBAssert(!std::isnan(closest_point_on_line_bottom_cartesian[0]),
+                   "Internal error: The closest_point_on_line_bottom_cartesian[0] variable is not a number: " << closest_point_on_line_bottom_cartesian[0]);
+          WBAssert(!std::isnan(closest_point_on_line_bottom_cartesian[1]),
+                   "Internal error: The closest_point_on_line_bottom_cartesian[1] variable is not a number: " << closest_point_on_line_bottom_cartesian[1]);
+          WBAssert(!std::isnan(closest_point_on_line_bottom_cartesian[2]),
+                   "Internal error: The closest_point_on_line_bottom_cartesian[2] variable is not a number: " << closest_point_on_line_bottom_cartesian[2]);
+
+
+          // translate to original coordinates current and next section
+          const size_t original_current_section = i_section_min_distance;
+          const size_t original_next_section = original_current_section + 1;
+
+
+          // These are the mostly likely cases for the x and y axis, so initialize them to these values. They will be checked
+          // in the else statement or replaced in the if statement.
+          Point<3> y_axis = closest_point_on_line_cartesian - closest_point_on_line_bottom_cartesian;
+          Point<3> x_axis = closest_point_on_line_cartesian - check_point_surface_cartesian;
+
+          // This are accounting for corner cases.
+          // If the point to check is exactly on or below the line, we can not compute the x-axis with this method.
+          // We could use an other method where we use the two point before and after it, but we can also
+          // just nudge it into a direction, which seems to work very well.
+          if (std::fabs((check_point_surface - closest_point_on_line_surface).norm()) < 2e-14)
+            {
+              // If the point to check is on the line, we don't need to search any further, because we know the distance is zero.
+              if (std::fabs((check_point - closest_point_on_line_cartesian).norm()) > 2e-14)
+                {
+                  const Point<2> &P1(point_list[i_section_min_distance]);
+                  const Point<2> &P2(point_list[i_section_min_distance+1]);
+
+                  const Point<2> P1P2 = P2 - P1;
+                  const Point<2> unit_normal_to_plane_spherical = P1P2 / P1P2.norm();
+                  const Point<2> closest_point_on_line_plus_normal_to_plane_spherical = closest_point_on_line_2d + 1e-8 * (closest_point_on_line_2d.norm() > 1.0 ? closest_point_on_line_2d.norm() : 1.0) * unit_normal_to_plane_spherical;
+
+                  WBAssert(std::fabs(closest_point_on_line_plus_normal_to_plane_spherical.norm()) > std::numeric_limits<double>::epsilon(),
+                           "Internal error: The norm of variable 'closest_point_on_line_plus_normal_to_plane_spherical' "
+                           "is  zero, while this may not happen.");
+
+                  const Point<3> closest_point_on_line_plus_normal_to_plane_surface_spherical(bool_cartesian ? closest_point_on_line_plus_normal_to_plane_spherical[0] : start_radius,
+                                                                                              bool_cartesian ? closest_point_on_line_plus_normal_to_plane_spherical[1] : closest_point_on_line_plus_normal_to_plane_spherical[0],
+                                                                                              bool_cartesian ? start_radius : closest_point_on_line_plus_normal_to_plane_spherical[1],
+                                                                                              natural_coordinate_system);
+                  const Point<3> closest_point_on_line_plus_normal_to_plane_cartesian(coordinate_system->natural_to_cartesian_coordinates(closest_point_on_line_plus_normal_to_plane_surface_spherical.get_array()),cartesian);
+                  Point<3> normal_to_plane = closest_point_on_line_plus_normal_to_plane_cartesian - closest_point_on_line_cartesian;
+                  normal_to_plane = normal_to_plane / normal_to_plane.norm();
+
+                  // The y-axis is from the bottom/center to the closest_point_on_line,
+                  // the x-axis is 90 degrees rotated from that, so we rotate around
+                  // the line P1P2.
+                  // Todo: Assert that the norm of the axis are not equal to zero.
+                  y_axis = closest_point_on_line_cartesian - closest_point_on_line_bottom_cartesian;
+
+                  WBAssert(std::abs(y_axis.norm()) > std::numeric_limits<double>::epsilon(),
+                           "World Builder error: Cannot determine the up direction in the model. This is most likely due to the provided start radius being zero."
+                           << " Technical details: The y_axis.norm() is zero. Y_axis is " << y_axis[0] << ':' << y_axis[1] << ':' << y_axis[2]
+                           << ". closest_point_on_line_cartesian = " << closest_point_on_line_cartesian[0] << ':' << closest_point_on_line_cartesian[1] << ':' << closest_point_on_line_cartesian[2]
+                           << ", closest_point_on_line_bottom_cartesian = " << closest_point_on_line_bottom_cartesian[0] << ':' << closest_point_on_line_bottom_cartesian[1] << ':' << closest_point_on_line_bottom_cartesian[2]);
+
+                  WBAssert(!std::isnan(y_axis[0]),
+                           "Internal error: The y_axis variable is not a number: " << y_axis[0]);
+                  WBAssert(!std::isnan(y_axis[1]),
+                           "Internal error: The y_axis variable is not a number: " << y_axis[1]);
+                  WBAssert(!std::isnan(y_axis[2]),
+                           "Internal error: The y_axis variable is not a number: " << y_axis[2]);
+
+                  y_axis = y_axis / y_axis.norm();
+
+                  WBAssert(!std::isnan(y_axis[0]),
+                           "Internal error: The y_axis variable is not a number: " << y_axis[0]);
+                  WBAssert(!std::isnan(y_axis[1]),
+                           "Internal error: The y_axis variable is not a number: " << y_axis[1]);
+                  WBAssert(!std::isnan(y_axis[2]),
+                           "Internal error: The y_axis variable is not a number: " << y_axis[2]);
+
+
+                  // shorthand notation for computing the x_axis
+                  const double vx = y_axis[0];
+                  const double vy = y_axis[1];
+                  const double vz = y_axis[2];
+                  const double ux = normal_to_plane[0];
+                  const double uy = normal_to_plane[1];
+                  const double uz = normal_to_plane[2];
+
+                  x_axis = Point<3>(ux*ux*vx + ux*uy*vy - uz*vy + uy*uz*vz + uy*vz,
+                                    uy*ux*vx + uz*vx + uy*uy*vy + uy*uz*vz - ux*vz,
+                                    uz*ux*vx - uy*vx + uz*uy*vy + ux*vy + uz*uz*vz,
+                                    cartesian);
+
+                  // see on what side the line P1P2 reference point is. This is based on the determinant
+                  const Point<2> reference_p = ((closest_point_on_curve.normal-closest_point_on_line_2d)*1e2)+closest_point_on_line_2d;
+                  const double reference_on_side_of_line =  (closest_point_on_line_2d-reference_p).norm_square() < (check_point_surface_2d-reference_p).norm_square() ? -1 : 1;
+
+                  WBAssert(!std::isnan(x_axis[0]),
+                           "Internal error: The x_axis variable is not a number: " << x_axis[0]);
+                  WBAssert(!std::isnan(x_axis[1]),
+                           "Internal error: The x_axis variable is not a number: " << x_axis[1]);
+                  WBAssert(!std::isnan(x_axis[2]),
+                           "Internal error: The x_axis variable is not a number: " << x_axis[2]);
+
+                  x_axis = x_axis *(reference_on_side_of_line / x_axis.norm());
+
+                  WBAssert(!std::isnan(x_axis[0]),
+                           "Internal error: The x_axis variable is not a number: " << x_axis[0]);
+                  WBAssert(!std::isnan(x_axis[1]),
+                           "Internal error: The x_axis variable is not a number: " << x_axis[1]);
+                  WBAssert(!std::isnan(x_axis[2]),
+                           "Internal error: The x_axis variable is not a number: " << x_axis[2]);
+                }
+              else
+                {
+                  total_average_angle = plane_segment_angles[original_current_section][0][0]
+                                        + fraction_CPL_P1P2 * (plane_segment_angles[original_next_section][0][0]
+                                                               - plane_segment_angles[original_current_section][0][0]);
+
+                  PointDistanceFromCurvedPlanes return_values(natural_coordinate.get_coordinate_system());
+                  return_values.distance_from_plane = 0.0;
+                  return_values.distance_along_plane = 0.0;
+                  return_values.fraction_of_section = fraction_CPL_P1P2;
+                  return_values.fraction_of_segment = 0.0;
+                  return_values.section = i_section_min_distance;
+                  return_values.segment = 0;
+                  return_values.average_angle = total_average_angle;
+                  return_values.depth_reference_surface = 0.0;
+                  return_values.closest_trench_point = closest_point_on_line_cartesian;
+                  return return_values;
+                }
+            }
+          else
+            {
+              WBAssert(std::abs(y_axis.norm()) > std::numeric_limits<double>::epsilon(),
+                       "World Builder error: Cannot determine the up direction in the model. This is most likely due to the provided start radius being zero."
+                       << " Technical details: The y_axis.norm() is zero. Y_axis is " << y_axis
+                       << ". closest_point_on_line_cartesian = " << closest_point_on_line_cartesian
+                       << ", closest_point_on_line_bottom_cartesian = " << closest_point_on_line_bottom_cartesian);
+
+              WBAssert(!std::isnan(y_axis[0]),
+                       "Internal error: The y_axis variable is not a number: " << y_axis[0]);
+              WBAssert(!std::isnan(y_axis[1]),
+                       "Internal error: The y_axis variable is not a number: " << y_axis[1]);
+              WBAssert(!std::isnan(y_axis[2]),
+                       "Internal error: The y_axis variable is not a number: " << y_axis[2]);
+
+              y_axis = y_axis / y_axis.norm();
+
+              WBAssert(!std::isnan(y_axis[0]),
+                       "Internal error: The y_axis variable is not a number: " << y_axis[0]);
+              WBAssert(!std::isnan(y_axis[1]),
+                       "Internal error: The y_axis variable is not a number: " << y_axis[1]);
+              WBAssert(!std::isnan(y_axis[2]),
+                       "Internal error: The y_axis variable is not a number: " << y_axis[2]);
+
+
+              Point<2> check_point_surface_2d_temp = check_point_surface_2d;
+
+              if (!bool_cartesian)
+                {
+                  const double normal = std::fabs(point_list[i_section_min_distance+static_cast<size_t>((std::round(fraction_CPL_P1P2)))][0]-check_point_surface_2d[0]);
+                  const double plus   = std::fabs(point_list[i_section_min_distance+static_cast<size_t>((std::round(fraction_CPL_P1P2)))][0]-(check_point_surface_2d[0]+2*Consts::PI));
+                  const double min    = std::fabs(point_list[i_section_min_distance+static_cast<size_t>((std::round(fraction_CPL_P1P2)))][0]-(check_point_surface_2d[0]-2*Consts::PI));
+
+                  // find out whether the check point, checkpoint + 2pi or check point -2 pi is closest to the point list.
+                  if (plus < normal)
+                    {
+                      check_point_surface_2d_temp[0]+= 2*Consts::PI;
+                    }
+                  else if (min < normal)
+                    {
+                      check_point_surface_2d_temp[0]-= 2*Consts::PI;
+                    }
+                }
+
+              // check whether the check point and the reference point are on the same side, if not, change the side.
+              const Point<2> AB_normal = closest_point_on_curve.normal*closest_point_on_line_2d.distance(reference_point);//*AB.norm();
+              const Point<2> local_reference_point = AB_normal*1.+closest_point_on_line_2d;
+              const bool reference_normal_on_side_of_line =  (closest_point_on_line_2d-local_reference_point).norm_square() < (check_point_surface_2d_temp-local_reference_point).norm_square();
+              const bool reference_point_on_side_of_line =  (point_list[point_list.size()-1][0] - point_list[0][0])*(reference_point[1] - point_list[0][1]) - (reference_point[0] - point_list[0][0])*(point_list[point_list.size()-1][1] - point_list[0][1]) < 0.;
+              const double reference_on_side_of_line =  reference_normal_on_side_of_line == reference_point_on_side_of_line ? 1 : -1;
+
+              WBAssert(!std::isnan(x_axis[0]),
+                       "Internal error: The x_axis variable is not a number: " << x_axis[0]);
+              WBAssert(!std::isnan(x_axis[1]),
+                       "Internal error: The x_axis variable is not a number: " << x_axis[1]);
+              WBAssert(!std::isnan(x_axis[2]),
+                       "Internal error: The x_axis variable is not a number: " << x_axis[2]);
+
+              WBAssert(x_axis.norm() > 0.0, "x_axis norm is zero");
+
+              x_axis = x_axis *(reference_on_side_of_line / x_axis.norm());
+
+              WBAssert(!std::isnan(x_axis[0]),
+                       "Internal error: The x_axis variable is not a number: " << x_axis[0]);
+              WBAssert(!std::isnan(x_axis[1]),
+                       "Internal error: The x_axis variable is not a number: " << x_axis[1]);
+              WBAssert(!std::isnan(x_axis[2]),
+                       "Internal error: The x_axis variable is not a number: " << x_axis[2]);
+
+            }
+
+          WBAssert(!std::isnan(x_axis[0]),
+                   "Internal error: The x_axis[0] variable is not a number: " << x_axis[0] << ". Relevant values:  check_point = " << check_point << '.');
+          WBAssert(!std::isnan(x_axis[1]),
+                   "Internal error: The x_axis[1] variable is not a number: " << x_axis[1]);
+          WBAssert(!std::isnan(x_axis[2]),
+                   "Internal error: The x_axis[2] variable is not a number: " << x_axis[2]);
+
+          // now that we have the x and y axes computed, convert the 3d check point into a 2d one.
+          Point<2> check_point_2d(x_axis * (check_point - closest_point_on_line_bottom_cartesian),
+                                  y_axis * (check_point - closest_point_on_line_bottom_cartesian),
+                                  cartesian);
+
+          Point<2> begin_segment(x_axis * (closest_point_on_line_cartesian - closest_point_on_line_bottom_cartesian),
+                                 y_axis * (closest_point_on_line_cartesian - closest_point_on_line_bottom_cartesian),
+                                 cartesian);
+
+          WBAssert(!std::isnan(check_point_2d[0]),
+                   "Internal error: The check_point_2d variable is not a number: " << check_point_2d[0]);
+          WBAssert(!std::isnan(check_point_2d[1]),
+                   "Internal error: The check_point_2d variable is not a number: " << check_point_2d[1]);
+
+
+          WBAssert(!std::isnan(begin_segment[0]),
+                   "Internal error: The begin_segment variable is not a number: " << begin_segment[0]);
+          WBAssert(!std::isnan(begin_segment[1]),
+                   "Internal error: The begin_segment variable is not a number: " << begin_segment[1]);
+
+          Point<2> end_segment = begin_segment;
+
+          double total_length = 0.0;
+          double add_angle = 0.0;
+          double add_angle_correction = 0.0;
+          double average_angle = 0.0;
+          for (size_t i_segment = 0; i_segment < plane_segment_lengths[original_current_section].size(); i_segment++)
+            {
+              const size_t current_segment = i_segment;
+
+              // compute the angle between the previous begin and end if
+              // the depth method is angle_at_begin_segment_with_surface.
+              if (i_segment != 0
+                  &&
+                  (depth_method == DepthMethod::angle_at_begin_segment_with_surface
+                   ||
+                   depth_method == DepthMethod::angle_at_begin_segment_applied_to_end_segment_with_surface))
+                {
+                  double add_angle_inner = (begin_segment * end_segment) / (begin_segment.norm() * end_segment.norm());
+
+                  WBAssert(!std::isnan(add_angle_inner),
+                           "Internal error: The add_angle_inner variable is not a number: " << add_angle_inner
+                           << ". Variables: begin_segment = " << begin_segment
+                           << ", end_segment = " << end_segment
+                           << ", begin_segment * end_segment / (begin_segment.norm() * end_segment.norm()) = "
+                           << std::setprecision(32) << begin_segment * end_segment / (begin_segment.norm() * end_segment.norm())
+                           << '.');
+
+                  // there could be round of error problems here is the inner part is close to one
+                  if (add_angle_inner < 0. && add_angle_inner >= -1e-14)
+                    add_angle_inner = 0.;
+                  if (add_angle_inner > 1. && add_angle_inner <= 1.+1e-14)
+                    add_angle_inner = 1.;
+
+                  WBAssert(add_angle_inner >= 0 && add_angle_inner <= 1,
+                           "Internal error: The variable add_angle_inner is smaller than zero or larger then one,"
+                           "which causes the std::acos to return nan. If it is only a little bit larger then one, "
+                           "this is probably caused by that begin and end segment are the same and round off error. "
+                           "The value of add_angle_inner = " << add_angle_inner);
+
+                  add_angle_correction = std::acos(add_angle_inner);
+                  add_angle += add_angle_correction;
+
+                  WBAssert(!std::isnan(add_angle),
+                           "Internal error: The add_angle variable is not a number: " << add_angle
+                           << ". Variables: begin_segment = " << begin_segment
+                           << ", end_segment = " << end_segment
+                           << ", begin_segment * end_segment / (begin_segment.norm() * end_segment.norm()) = "
+                           << std::setprecision(32) << begin_segment * end_segment / (begin_segment.norm() * end_segment.norm())
+                           << ", std::acos(begin_segment * end_segment / (begin_segment.norm() * end_segment.norm())) = "
+                           << std::acos(begin_segment * end_segment / (begin_segment.norm() * end_segment.norm())));
+                }
+
+
+
+
+              begin_segment = end_segment;
+
+              WBAssert(!std::isnan(begin_segment[0]),
+                       "Internal error: The begin_segment variable is not a number: " << begin_segment[0]);
+              WBAssert(!std::isnan(begin_segment[1]),
+                       "Internal error: The begin_segment variable is not a number: " << begin_segment[1]);
+
+
+              // This interpolates different properties between P1 and P2 (the
+              // points of the plane at the surface)
+              const double degree_90_to_rad = 0.5 * Consts::PI;
+
+              WBAssert(plane_segment_angles.size() > original_next_section,
+                       "Error: original_next_section = " << original_next_section
+                       << ", and plane_segment_angles.size() = " << plane_segment_angles.size());
+
+
+              WBAssert(plane_segment_angles[original_next_section].size() > current_segment,
+                       "Error: current_segment = "  << current_segment
+                       << ", and current_segment.size() = " << plane_segment_angles[original_next_section].size());
+
+              const double interpolated_angle_top    = plane_segment_angles[original_current_section][current_segment][0]
+                                                       + fraction_CPL_P1P2 * (plane_segment_angles[original_next_section][current_segment][0]
+                                                                              - plane_segment_angles[original_current_section][current_segment][0])
+                                                       + add_angle
+                                                       + (depth_method == DepthMethod::angle_at_begin_segment_applied_to_end_segment_with_surface
+                                                          && i_segment != 0 ? -add_angle_correction: 0);
+
+              const double interpolated_angle_bottom = plane_segment_angles[original_current_section][current_segment][1]
+                                                       + fraction_CPL_P1P2 * (plane_segment_angles[original_next_section][current_segment][1]
+                                                                              - plane_segment_angles[original_current_section][current_segment][1])
+                                                       + add_angle;
+
+
+              const double interpolated_segment_length     = plane_segment_lengths[original_current_section][current_segment]
+                                                             + fraction_CPL_P1P2 * (plane_segment_lengths[original_next_section][current_segment]
+                                                                                    - plane_segment_lengths[original_current_section][current_segment]);
+
+              if (interpolated_segment_length < 1e-14)
+                continue;
+
+              WBAssert(!std::isnan(interpolated_angle_top),
+                       "Internal error: The interpolated_angle_top variable is not a number: " << interpolated_angle_top);
+
+              // We want to know where the end point of this segment is (and
+              // the start of the next segment). There are two cases which we
+              // will deal with separately. The first one is if the angle is
+              // constant. The second one is if the angle changes.
+              const double difference_in_angle_along_segment = interpolated_angle_top - interpolated_angle_bottom;
+
+              if (std::fabs(difference_in_angle_along_segment) < 1e-8)
+                {
+                  // The angle is constant. It is easy find find the end of
+                  // this segment and the distance.
+                  if (std::fabs(interpolated_segment_length) > std::numeric_limits<double>::epsilon())
+                    {
+                      end_segment[0] += interpolated_segment_length * std::sin(degree_90_to_rad - interpolated_angle_top);
+                      end_segment[1] -= interpolated_segment_length * std::cos(degree_90_to_rad - interpolated_angle_top);
+
+                      Point<2> begin_end_segment = end_segment - begin_segment;
+                      Point<2> normal_2d_plane(-begin_end_segment[0],begin_end_segment[1], cartesian);
+                      WBAssert(std::fabs(normal_2d_plane.norm()) > std::numeric_limits<double>::epsilon(), "Internal Error: normal_2d_plane.norm() is zero, which should not happen. "
+                               << "Extra info: begin_end_segment[0] = " << begin_end_segment[0]
+                               << ", begin_end_segment[1] = " << begin_end_segment[1]
+                               << ", end_segment: [" << end_segment[0] << ',' << end_segment[1] << ']'
+                               << ", begin_segment: [" << begin_segment[0] << ',' << begin_segment[1] << ']'
+                              );
+                      normal_2d_plane /= normal_2d_plane.norm();
+
+                      // Now find the distance of a point to this line.
+                      // Based on http://geomalgorithms.com/a02-_lines.html.
+                      const Point<2> BSP_ESP = end_segment - begin_segment;
+                      const Point<2> BSP_CP = check_point_2d - begin_segment;
+
+                      const double c1 = BSP_ESP * BSP_CP;
+                      const double c2 = BSP_ESP * BSP_ESP;
+
+                      if (c1 < 0 || c2 < c1)
+                        {
+                          new_distance = std::numeric_limits<double>::infinity();
+                          new_along_plane_distance = std::numeric_limits<double>::infinity();
+                          new_depth_reference_surface = std::numeric_limits<double>::infinity();
+                        }
+                      else
+                        {
+                          const Point<2> Pb = begin_segment + (c1/c2) * BSP_ESP;
+                          const double side_of_line =  (begin_segment[0] - end_segment[0]) * (check_point_2d[1] - begin_segment[1])
+                                                       - (begin_segment[1] - end_segment[1]) * (check_point_2d[0] - begin_segment[0])
+                                                       < 0 ? -1.0 : 1.0;
+
+                          new_distance = side_of_line * (check_point_2d - Pb).norm();
+                          new_along_plane_distance = (begin_segment - Pb).norm();
+                          new_depth_reference_surface = start_radius - Pb[1];
+
+                          WBAssert(!std::isnan(new_depth_reference_surface),
+                                   "new_depth_reference_surface is not a number: " << new_depth_reference_surface << ". "
+                                   << "start_radius = " << start_radius << ",Pb[1] = " << Pb[1] << ".");
+                        }
+                    }
+                }
+              else
+                {
+                  // The angle is not constant. This means that we need to
+                  // define a circle. First find the center of the circle.
+                  const double radius_angle_circle = std::fabs(interpolated_segment_length/difference_in_angle_along_segment);
+
+                  WBAssert(!std::isnan(radius_angle_circle),
+                           "Internal error: The radius_angle_circle variable is not a number: " << radius_angle_circle
+                           << ". interpolated_segment_length = " << interpolated_segment_length
+                           << ", difference_in_angle_along_segment = " << difference_in_angle_along_segment);
+
+                  const double cos_angle_top = std::cos(interpolated_angle_top);
+
+                  WBAssert(!std::isnan(cos_angle_top),
+                           "Internal error: The radius_angle_circle variable is not a number: " << cos_angle_top
+                           << ". interpolated_angle_top = " << interpolated_angle_top);
+
+                  Point<2> center_circle(cartesian);
+                  if (std::fabs(interpolated_angle_top - 0.5 * Consts::PI) < 1e-8)
+                    {
+                      // if interpolated_angle_top is 90 degrees, the tan function
+                      // is undefined (1/0). What we really want in this case is
+                      // set the center to the correct location which is x = the x
+                      //begin point + radius and y = the y begin point.
+                      center_circle[0] = difference_in_angle_along_segment > 0 ? begin_segment[0] + radius_angle_circle : begin_segment[0] - radius_angle_circle;
+                      center_circle[1] = begin_segment[1];
+                    }
+                  else if (std::fabs(interpolated_angle_top - 1.5 * Consts::PI) < 1e-8)
+                    {
+                      // if interpolated_angle_top is 270 degrees, the tan function
+                      // is undefined (-1/0). What we really want in this case is
+                      // set the center to the correct location which is x = the x
+                      //begin point - radius and y = the y begin point.
+                      center_circle[0] = difference_in_angle_along_segment > 0 ? begin_segment[0] - radius_angle_circle : begin_segment[0] + radius_angle_circle;
+                      center_circle[1] = begin_segment[1];
+                    }
+                  else
+                    {
+                      const double tan_angle_top = std::tan(interpolated_angle_top);
+
+                      WBAssert(!std::isnan(tan_angle_top),
+                               "Internal error: The tan_angle_top variable is not a number: " << tan_angle_top);
+                      const double center_circle_y = difference_in_angle_along_segment < 0 ?
+                                                     begin_segment[1] - radius_angle_circle * cos_angle_top
+                                                     : begin_segment[1] + radius_angle_circle * cos_angle_top;
+
+                      WBAssert(!std::isnan(center_circle_y),
+                               "Internal error: The center_circle_y variable is not a number: " << center_circle_y
+                               << ". begin_segment[1] = " << begin_segment[1]
+                               << ", radius_angle_circle = " << radius_angle_circle
+                               << ", cos_angle_top = " << cos_angle_top);
+
+                      // to prevent round off errors becoming dominant, we check
+                      // whether center_circle_y - begin_segment[1] should be zero.
+                      // TODO: improve this to some kind of relative difference.
+                      const double CCYBS = center_circle_y - begin_segment[1];
+
+                      WBAssert(!std::isnan(CCYBS),
+                               "Internal error: The CCYBS variable is not a number: " << CCYBS);
+
+
+
+                      center_circle[0] = begin_segment[0] + tan_angle_top * (CCYBS);
+                      center_circle[1] = center_circle_y;
+                    }
+
+                  WBAssert(!std::isnan(center_circle[0]) || !std::isnan(center_circle[1]),
+                           "Internal error: The center variable contains not a number: " << center_circle[0] << ':' << center_circle[0]);
+                  WBAssert(std::fabs((begin_segment-center_circle).norm() - std::fabs(radius_angle_circle))
+                           < 1e-8 * std::fabs((begin_segment-center_circle).norm() + std::fabs(radius_angle_circle)),
+                           "Internal error: The center of the circle is not a radius away from the begin point. " << std::endl
+                           << "The center is located at " << center_circle[0] << ':' << center_circle[1] << std::endl
+                           << "The begin point is located at " << begin_segment[0] << ':' << begin_segment[1] << std::endl
+                           << "The computed radius is " << std::fabs((begin_segment-center_circle).norm())
+                           << ", and it should be " << radius_angle_circle << '.');
+
+
+                  // Now compute the location of the end of the segment by
+                  // rotating P1 around the center_circle
+                  Point<2> BSPC = begin_segment - center_circle;
+                  const double sin_angle_diff = sin(difference_in_angle_along_segment);
+                  const double cos_angle_diff = cos(difference_in_angle_along_segment);
+                  end_segment[0] = cos_angle_diff * BSPC[0] - sin_angle_diff * BSPC[1] + center_circle[0];
+                  end_segment[1] = sin_angle_diff * BSPC[0] + cos_angle_diff * BSPC[1] + center_circle[1];
+
+
+
+                  WBAssert(std::fabs((end_segment-center_circle).norm() - std::fabs(radius_angle_circle))
+                           < 1e-8 * std::fabs((end_segment-center_circle).norm() + std::fabs(radius_angle_circle)) ,
+                           "Internal error: The center of the circle is not a radius away from the end point. " << std::endl
+                           << "The center is located at " << center_circle[0] << ':' << center_circle[1] << std::endl
+                           << "The end point is located at " << end_segment[0] << ':' << end_segment[1] << std::endl
+                           << "The computed radius is " << std::fabs((end_segment-center_circle).norm())
+                           << ", and it should be " << radius_angle_circle << '.');
+
+                  // Now check if the angle of the check point in this circle
+                  // is larger then the angle of P1 and smaller then P1 + angle
+                  // difference. If that is the case then the distance from the
+                  // plane is radius - (center - check_point).norm(). Otherwise
+                  // it is infinity.
+                  // The angle of the check point is computed with the help of
+                  // dot product. But before that we need to adjust the check
+                  // point 2d.
+                  const Point<2> CPCR = check_point_2d - center_circle;
+                  const double CPCR_norm = CPCR.norm();
+
+                  const double dot_product = CPCR * Point<2>(0, radius_angle_circle, cartesian);
+                  // If the x of the check point is larger then the x of center
+                  // the circle, the angle is more than 180 degree, but the dot
+                  // product will decrease instead of increase from 180 degrees.
+                  // To fix this we make a special case for this.
+                  // Furthermore, when the check point is at the same location as
+                  // the center of the circle, we count that point as belonging
+                  // to the top of the top segment (0 degree).
+                  double check_point_angle = std::fabs(CPCR_norm) < std::numeric_limits<double>::epsilon() ? 2.0 * Consts::PI : (check_point_2d[0] <= center_circle[0]
+                                             ? std::acos(dot_product/(CPCR_norm * radius_angle_circle))
+                                             : 2.0 * Consts::PI - std::acos(dot_product/(CPCR_norm * radius_angle_circle)));
+                  check_point_angle = difference_in_angle_along_segment >= 0 ? Consts::PI - check_point_angle : 2.0 * Consts::PI - check_point_angle;
+
+                  // In the case that it is exactly 2 * pi, bring it back to zero
+                  check_point_angle = (std::fabs(check_point_angle - 2 * Consts::PI) < 1e-14 ? 0 : check_point_angle);
+
+                  if ((difference_in_angle_along_segment > 0 && (check_point_angle <= interpolated_angle_top || std::fabs(check_point_angle - interpolated_angle_top) < 1e-12)
+                       && (check_point_angle >= interpolated_angle_bottom || std::fabs(check_point_angle - interpolated_angle_bottom) < 1e-12))
+                      || (difference_in_angle_along_segment < 0 && (check_point_angle >= interpolated_angle_top || std::fabs(check_point_angle - interpolated_angle_top) < 1e-12)
+                          && (check_point_angle <= interpolated_angle_bottom || std::fabs(check_point_angle - interpolated_angle_bottom) < 1e-12)))
+                    {
+                      new_distance = (radius_angle_circle - CPCR_norm) * (difference_in_angle_along_segment < 0 ? 1 : -1);
+                      new_along_plane_distance = (radius_angle_circle * check_point_angle - radius_angle_circle * interpolated_angle_top) * (difference_in_angle_along_segment < 0 ? 1 : -1);
+                      // compute the new depth by rotating the begin point to the check point location.
+                      new_depth_reference_surface = start_radius-(sin(check_point_angle + interpolated_angle_top) * BSPC[0] + cos(check_point_angle + interpolated_angle_top) * BSPC[1] + center_circle[1]);
+
+                      WBAssert(!std::isnan(new_depth_reference_surface),
+                               "new_depth_reference_surface is not a number: " << new_depth_reference_surface << ". "
+                               << "start_radius = " << start_radius << ", check_point_angle = " << check_point_angle << ", interpolated_angle_top = " << interpolated_angle_top
+                               << ", BSPC[0] = " << BSPC[0] << ".");
+                    }
+
+                }
+
+              // Now we need to see whether we need to update the information
+              // based on whether this segment is the closest one to the point
+              // up to now. To do this we first look whether the point falls
+              // within the bound of the segment and if it is actually closer.
+              // TODO: find out whether the fabs() are needed.
+              if (new_along_plane_distance >= -1e-10 &&
+                  new_along_plane_distance <= std::fabs(interpolated_segment_length) &&
+                  std::fabs(new_distance) < std::fabs(distance))
+                {
+                  // There are two specific cases we are concerned with. The
+                  // first case is that we want to have both the positive and
+                  // negative distances (above and below the line). The second
+                  // case is that we only want positive distances.
+                  distance = only_positive ? std::fabs(new_distance) : new_distance;
+                  along_plane_distance = new_along_plane_distance + total_length;
+                  section = i_section_min_distance;
+                  section_fraction = fraction_CPL_P1P2;
+                  segment = i_segment;
+                  segment_fraction = new_along_plane_distance / interpolated_segment_length;
+                  total_average_angle = (average_angle * total_length
+                                         + 0.5 * (interpolated_angle_top + interpolated_angle_bottom  - 2 * add_angle) * new_along_plane_distance);
+                  total_average_angle = (std::fabs(total_average_angle) < std::numeric_limits<double>::epsilon() ? 0 : total_average_angle /
+                                         (total_length + new_along_plane_distance));
+                  depth_reference_surface = new_depth_reference_surface;
+                }
+
+              // increase average angle
+              average_angle = (average_angle * total_length +
+                               0.5 * (interpolated_angle_top + interpolated_angle_bottom  - 2 * add_angle) * interpolated_segment_length);
+              average_angle = (std::fabs(average_angle) < std::numeric_limits<double>::epsilon() ? 0 : average_angle /
+                               (total_length + interpolated_segment_length));
+              // increase the total length for the next segment.
+              total_length += interpolated_segment_length;
+            }
+        }
+
+      WBAssert(!std::isnan(depth_reference_surface), "depth_reference_surface is not a number: " << depth_reference_surface << ".");
+
+      PointDistanceFromCurvedPlanes return_values(natural_coordinate.get_coordinate_system());
+      return_values.distance_from_plane = distance;
+      return_values.distance_along_plane = along_plane_distance;
+      return_values.fraction_of_section = section_fraction;
+      return_values.fraction_of_segment = segment_fraction;
+      return_values.section = section;
+      return_values.segment = segment;
+      return_values.average_angle = total_average_angle;
+      return_values.depth_reference_surface = depth_reference_surface;
+      return_values.closest_trench_point = closest_point_on_line_cartesian;
+      return return_values;
+    }
+
+    void interpolation::set_points(const std::vector<double> &y)
+    {
+      const size_t n = y.size();
+      mx_size_min = n;
+      m.resize(n);
+      for (unsigned int i = 0; i < n; ++i)
+        {
+          m[i][3] = y[i];
+        }
+
+      /**
+       * This monotone spline algorithm is based on the javascript version
+       * at https://en.wikipedia.org/wiki/Monotone_cubic_interpolation. The
+       * parameters from this algorithm prevent overshooting in the
+       * interpolation spline.
+       */
+
+      // get m_a parameter
+      m[0][2] = 0;
+
+      for (size_t i = 0; i < n-2; i++)
+        {
+          const double m0 = y[i+1]-y[i];
+          const double m1 =  y[i+2]-y[i+1];
+
+          if (m0 * m1 <= 0)
+            {
+              m[i+1][2] = 0;
+            }
+          else
+            {
+              m[i+1][2] = 2*m0*m1/(m0+m1);
+            }
+        }
+      m[n-1][2] =  y[n-1]-y[n-2];
+
+      // Get b and c coefficients
+      //m_a.resize(n);
+      //m_b.resize(n);
+      for (size_t i = 0; i < n-1; i++)
+        {
+          const double c1 = m[i][2];
+          const double m0 = y[i+1]-y[i];
+
+          const double common0 = c1 + m[i+1][2] - m0 - m0;
+          m[i][1] = (m0 - c1 - common0);
+          m[i][0] = common0;
+        }
+    }
+
+    double wrap_angle(const double angle)
+    {
+      return angle - 360.0*std::floor(angle/360.0);
+    }
+
+    double interpolate_angle_across_zero(const double angle_1,
+                                         const double angle_2,
+                                         const double fraction)
+    {
+      double theta_1 = angle_1;
+      double theta_2 = angle_2;
+      double rotation_angle;
+
+      if (std::abs(theta_2 - theta_1) > Consts::PI)
+        {
+          if (theta_2 > theta_1)
+            theta_1 += 2.*Consts::PI;
+          else
+            theta_2 += 2.*Consts::PI;
+        }
+      rotation_angle = (1-fraction) * theta_1 + fraction * theta_2;
+
+      // make sure angle is between 0 and 360 degrees
+      rotation_angle = rotation_angle - 2*Consts::PI*std::floor(rotation_angle/(2 * Consts::PI));
+
+      return rotation_angle;
+    }
+
+    std::array<double,3>
+    euler_angles_from_rotation_matrix(const std::array<std::array<double,3>,3> &rotation_matrix)
+    {
+      const double rad_to_degree = 180.0/Consts::PI;
+      std::array<double,3> euler_angles;
+      //const double s2 = std::sqrt(rotation_matrix[2][1] * rotation_matrix[2][1] + rotation_matrix[2][0] * rotation_matrix[2][0]);
+      const std::ostringstream os;
+      for (size_t i = 0; i < 3; i++)
+        for (size_t j = 0; j < 3; j++)
+          WBAssert(std::fabs(rotation_matrix[i][j]) <= 1.0,
+                   "rotation_matrix[" + std::to_string(i) + "][" + std::to_string(j) +
+                   "] is larger than one: " + std::to_string(rotation_matrix[i][j]) + ". rotation_matrix = \n"
+                   + std::to_string(rotation_matrix[0][0]) + " " + std::to_string(rotation_matrix[0][1]) + " " + std::to_string(rotation_matrix[0][2]) + "\n"
+                   + std::to_string(rotation_matrix[1][0]) + " " + std::to_string(rotation_matrix[1][1]) + " " + std::to_string(rotation_matrix[1][2]) + "\n"
+                   + std::to_string(rotation_matrix[2][0]) + " " + std::to_string(rotation_matrix[2][1]) + " " + std::to_string(rotation_matrix[2][2]));
+
+
+      const double theta = std::acos(rotation_matrix[2][2]);
+      const double phi1  = std::atan2(rotation_matrix[2][0]/-sin(theta),rotation_matrix[2][1]/-sin(theta));
+      const double phi2  = std::atan2(rotation_matrix[0][2]/-sin(theta),rotation_matrix[1][2]/sin(theta));
+
+      euler_angles[0] = wrap_angle(phi1 * rad_to_degree);
+      euler_angles[1] = wrap_angle(theta * rad_to_degree);
+      euler_angles[2] = wrap_angle(phi2 * rad_to_degree);
+
+      return euler_angles;
+    }
+
+    std::array<std::array<double,3>,3>
+    euler_angles_to_rotation_matrix(double phi1_d, double theta_d, double phi2_d)
+    {
+
+      const double degree_to_rad = Consts::PI/180.0;
+      const double phi1 = phi1_d * degree_to_rad;
+      const double theta = theta_d * degree_to_rad;
+      const double phi2 = phi2_d * degree_to_rad;
+      std::array<std::array<double,3>,3> rot_matrix;
+
+
+      rot_matrix[0][0] = cos(phi2)*cos(phi1) - cos(theta)*sin(phi1)*sin(phi2);
+      rot_matrix[0][1] = -cos(phi2)*sin(phi1) - cos(theta)*cos(phi1)*sin(phi2);
+      rot_matrix[0][2] = -sin(phi2)*sin(theta);
+
+      rot_matrix[1][0] = sin(phi2)*cos(phi1) + cos(theta)*sin(phi1)*cos(phi2);
+      rot_matrix[1][1] = -sin(phi2)*sin(phi1) + cos(theta)*cos(phi1)*cos(phi2);
+      rot_matrix[1][2] = cos(phi2)*sin(theta);
+
+      rot_matrix[2][0] = -sin(theta)*sin(phi1);
+      rot_matrix[2][1] = -sin(theta)*cos(phi1);
+      rot_matrix[2][2] = cos(theta);
+      return rot_matrix;
+    }
+
+    std::string
+    read_and_distribute_file_content(const std::string &filename)
+    {
+      std::string data_string;
+
+#ifdef WB_WITH_MPI
+      int mpi_initialized;
+      MPI_Initialized(&mpi_initialized);
+      if (mpi_initialized != 0)
+        {
+          const MPI_Comm comm = MPI_COMM_WORLD;
+          int my_rank = 0;
+          MPI_Comm_rank(comm, &my_rank);
+          if (my_rank == 0)
+            {
+              int filesize;
+              std::ifstream filestream;
+              filestream.open(filename.c_str());
+              WBAssertThrow (filestream.is_open(), std::string("Could not open file <") + filename + ">.");
+
+              // Need to convert to unsigned int, because MPI_Bcast does not support
+              // size_t or const unsigned int
+              int invalid_file_size = -1;
+
+              if (!filestream)
+                {
+                  // broadcast failure state, then throw
+                  const int ierr = MPI_Bcast(&invalid_file_size, 1, MPI_UNSIGNED, 0, comm);
+                  WBAssertThrow (ierr,
+                                 std::string("Could not open file <") + filename + ">.");
+                }
+
+              // Read data from disk
+              std::stringstream datastream;
+
+              try
+                {
+                  datastream << filestream.rdbuf();
+                }
+              catch (const std::ios::failure &)
+                {
+                  // broadcast failure state, then throw
+                  const int ierr = MPI_Bcast(&invalid_file_size, 1, MPI_UNSIGNED, 0, comm);
+                  WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
+                  WBAssertThrow (false,
+                                 std::string("Could not read file content from <") + filename + ">.");
+                }
+
+              data_string = datastream.str();
+              WBAssertThrow(static_cast<long int>(data_string.size()) < std::numeric_limits<int>::max(),
+                            "File is too large to be send with MPI.");
+              filesize = static_cast<int>(data_string.size());
+
+              // Distribute data_size and data across processes
+              int ierr = MPI_Bcast(&filesize, 1, MPI_UNSIGNED, 0, comm);
+              WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
+
+              // Receive and store data
+              ierr = MPI_Bcast(&data_string[0],
+                               filesize,
+                               MPI_CHAR,
+                               0,
+                               comm);
+              WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
+            }
+          else
+            {
+              // Prepare for receiving data
+              int filesize = 0;
+              int ierr = MPI_Bcast(&filesize, 1, MPI_UNSIGNED, 0, comm);
+              WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
+              WBAssertThrow(filesize != -1,
+                            std::string("Could not open file <") + filename + ">.");
+
+              data_string.resize(static_cast<size_t>(filesize));
+
+              // Receive and store data
+              ierr = MPI_Bcast(&data_string[0],
+                               filesize,
+                               MPI_CHAR,
+                               0,
+                               comm);
+              WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
+            }
+        }
+      else
+        {
+          std::ifstream filestream;
+          filestream.open(filename.c_str());
+          if (!filestream)
+            {
+              WBAssertThrow (false,
+                             std::string("Could not open file <") + filename + ">.");
+            }
+          std::stringstream datastream;
+          datastream << filestream.rdbuf();
+          data_string = datastream.str();
+        }
+#else
+      std::ifstream filestream;
+      filestream.open(filename.c_str());
+      if (!filestream)
+        {
+          WBAssertThrow (false,
+                         std::string("Could not open file <") + filename + ">.");
+        }
+      std::stringstream datastream;
+      datastream << filestream.rdbuf();
+      data_string = datastream.str();
+#endif
+
+      return data_string;
+    }
+
+    template std::array<double,2> convert_point_to_array<2>(const Point<2> &point_);
+    template std::array<double,3> convert_point_to_array<3>(const Point<3> &point_);
+
+
+    std::vector<double>
+    calculate_ridge_distance_and_spreading(std::vector<std::vector<Point<2>>> mid_oceanic_ridges,
+                                           std::vector<std::vector<double>> mid_oceanic_spreading_velocities,
+                                           const std::unique_ptr<WorldBuilder::CoordinateSystems::Interface> &coordinate_system,
+                                           const Objects::NaturalCoordinate &position_in_natural_coordinates_at_min_depth,
+                                           const std::vector<std::vector<double>> &subducting_plate_velocities,
+                                           const std::vector<double> &ridge_migration_times)
+    {
+      const double seconds_in_year = 60.0 * 60.0 * 24.0 * 365.25;  // sec/y
+
+      double distance_ridge = std::numeric_limits<double>::max();
+      double spreading_velocity_at_ridge = 0;
+      double subducting_velocity_at_trench = 0;
+      double ridge_migration_time = 0;
+
+      // first find if the coordinate is on this side of a ridge
+      unsigned int relevant_ridge = 0;
+      const Point<2> check_point(position_in_natural_coordinates_at_min_depth.get_surface_coordinates(),
+                                 position_in_natural_coordinates_at_min_depth.get_coordinate_system());
+
+      Point<2> other_check_point = check_point;
+      if (check_point.get_coordinate_system() == CoordinateSystem::spherical)
+        other_check_point[0] += check_point[0] < 0 ? 2.0 * WorldBuilder::Consts::PI : -2.0 * WorldBuilder::Consts::PI;
+
+      // if there is only one ridge, there is no transform
+      if (mid_oceanic_ridges[0].size() > 1)
+        {
+          // There are more than one ridge, so there are transform faults
+          // Find the first which is on the same side
+          for (relevant_ridge = 0; relevant_ridge < mid_oceanic_ridges.size()-1; relevant_ridge++)
+            {
+              const Point<2> transform_point_0 = mid_oceanic_ridges[relevant_ridge+1][0];
+              const Point<2> transform_point_1 = mid_oceanic_ridges[relevant_ridge][mid_oceanic_ridges[relevant_ridge].size()-1];
+              const Point<2> reference_point   = mid_oceanic_ridges[relevant_ridge][0];
+              const bool reference_on_side_of_line = (transform_point_1[0] - transform_point_0[0])
+                                                     * (reference_point[1] - transform_point_0[1])
+                                                     - (transform_point_1[1] - transform_point_0[1])
+                                                     * (reference_point[0] - transform_point_0[0])
+                                                     < 0;
+              const bool checkpoint_on_side_of_line = (transform_point_1[0] - transform_point_0[0])
+                                                      * (check_point[1] - transform_point_0[1])
+                                                      - (transform_point_1[1] - transform_point_0[1])
+                                                      * (check_point[0] - transform_point_0[0])
+                                                      < 0;
+
+
+              if (reference_on_side_of_line == checkpoint_on_side_of_line)
+                {
+                  break;
+                }
+
+            }
+        }
+
+      for (unsigned int i_coordinate = 0; i_coordinate < mid_oceanic_ridges[relevant_ridge].size() - 1; i_coordinate++)
+        {
+          const Point<2> segment_point0 = mid_oceanic_ridges[relevant_ridge][i_coordinate];
+          const Point<2> segment_point1 = mid_oceanic_ridges[relevant_ridge][i_coordinate + 1];
+
+          const double spreading_velocity_point0 = mid_oceanic_spreading_velocities[relevant_ridge][i_coordinate];
+          const double spreading_velocity_point1 = mid_oceanic_spreading_velocities[relevant_ridge][i_coordinate + 1];
+
+          // When subducting_velocities is not input by the user, default value is 0, which
+          // results in subducting velocity == spreading_velocity. When a single value is
+          // input by the user, subducting velocity != spreading_velocity, but
+          // subducting velocity is spatially constant.
+          double subducting_velocity_point0 = subducting_plate_velocities[0][0];
+          double subducting_velocity_point1 = subducting_plate_velocities[0][0];
+
+          // When subducting_velocities is input as an array, spatial variation
+          if (subducting_plate_velocities[0].size() > 1)
+            {
+              WBAssert(subducting_plate_velocities.size() == mid_oceanic_ridges.size() && \
+                       subducting_plate_velocities[relevant_ridge].size() == mid_oceanic_ridges[relevant_ridge].size(),
+                       "subducting velocity and ridge coordinates must be the same dimension");
+              WBAssert(ridge_migration_times.size() == mid_oceanic_ridges.size(),
+                       "the times for ridge migration specified in 'spreading velocity' must be the same dimension "
+                       "as ridge coordinates.");
+              subducting_velocity_point0 = subducting_plate_velocities[relevant_ridge][i_coordinate];
+              subducting_velocity_point1 = subducting_plate_velocities[relevant_ridge][i_coordinate + 1];
+              ridge_migration_time = ridge_migration_times[relevant_ridge];
+            }
+
+          {
+            // based on http://geomalgorithms.com/a02-_lines.html
+            const Point<2> v = segment_point1 - segment_point0;
+            const Point<2> w1 = check_point - segment_point0;
+            const Point<2> w2 = other_check_point - segment_point0;
+
+            const double c1 = (w1[0] * v[0] + w1[1] * v[1]);
+            const double c = (v[0] * v[0] + v[1] * v[1]);
+            const double c2 = (w2[0] * v[0] + w2[1] * v[1]);
+
+
+            Point<2> Pb1(coordinate_system->natural_coordinate_system());
+            // This part is needed when we want to consider segments instead of lines
+            // If you want to have infinite lines, use only the else statement.
+
+            // First, compare the results from the two compare points
+            double spreading_velocity_at_ridge_pt1 = 0.0;
+            double subducting_velocity_at_trench_pt1 = 0.0;
+            double spreading_velocity_at_ridge_pt2 = 0.0;
+            double subducting_velocity_at_trench_pt2 = 0.0;
+
+            if (c1 <= 0)
+              {
+                Pb1=segment_point0;
+                spreading_velocity_at_ridge_pt1 = spreading_velocity_point0;
+                subducting_velocity_at_trench_pt1 = subducting_velocity_point0;
+              }
+            else if (c <= c1)
+              {
+                Pb1=segment_point1;
+                spreading_velocity_at_ridge_pt1 = spreading_velocity_point1;
+                subducting_velocity_at_trench_pt1 = subducting_velocity_point1;
+              }
+            else
+              {
+                Pb1=segment_point0 + (c1 / c) * v;
+                spreading_velocity_at_ridge_pt1 = spreading_velocity_point0 + (spreading_velocity_point1 - spreading_velocity_point0) * (c1 / c);
+                subducting_velocity_at_trench_pt1 = subducting_velocity_point0 + (subducting_velocity_point1 - subducting_velocity_point0) * (c1 / c);
+              }
+
+            Point<2> Pb2(coordinate_system->natural_coordinate_system());
+            if (c2 <= 0)
+              {
+                Pb2=segment_point0;
+                spreading_velocity_at_ridge_pt2 = spreading_velocity_point0;
+                subducting_velocity_at_trench_pt2 = subducting_velocity_point0;
+              }
+            else if (c <= c2)
+              {
+                Pb2=segment_point1;
+                spreading_velocity_at_ridge_pt2 = spreading_velocity_point1;
+                subducting_velocity_at_trench_pt2 = spreading_velocity_point1;
+              }
+            else
+              {
+                Pb2=segment_point0 + (c2 / c) * v;
+                spreading_velocity_at_ridge_pt2 = spreading_velocity_point0 + (spreading_velocity_point1 - spreading_velocity_point0) * (c2 / c);
+                subducting_velocity_at_trench_pt2 = subducting_velocity_point0 + (subducting_velocity_point1 - subducting_velocity_point0) * (c2 / c);
+              }
+
+            Point<3> compare_point1(coordinate_system->natural_coordinate_system());
+            Point<3> compare_point2(coordinate_system->natural_coordinate_system());
+
+            compare_point1[0] = coordinate_system->natural_coordinate_system() == cartesian ? Pb1[0] :  position_in_natural_coordinates_at_min_depth.get_depth_coordinate();
+            compare_point1[1] = coordinate_system->natural_coordinate_system() == cartesian ? Pb1[1] : Pb1[0];
+            compare_point1[2] = coordinate_system->natural_coordinate_system() == cartesian ? position_in_natural_coordinates_at_min_depth.get_depth_coordinate() : Pb1[1];
+
+            compare_point2[0] = coordinate_system->natural_coordinate_system() == cartesian ? Pb2[0] :  position_in_natural_coordinates_at_min_depth.get_depth_coordinate();
+            compare_point2[1] = coordinate_system->natural_coordinate_system() == cartesian ? Pb2[1] : Pb2[0];
+            compare_point2[2] = coordinate_system->natural_coordinate_system() == cartesian ? position_in_natural_coordinates_at_min_depth.get_depth_coordinate() : Pb2[1];
+
+            const double compare_distance1 = coordinate_system->distance_between_points_at_same_depth(Point<3>(position_in_natural_coordinates_at_min_depth.get_coordinates(),
+                                             position_in_natural_coordinates_at_min_depth.get_coordinate_system()),
+                                             compare_point1);
+
+            const double compare_distance2 = coordinate_system->distance_between_points_at_same_depth(Point<3>(position_in_natural_coordinates_at_min_depth.get_coordinates(),
+                                             position_in_natural_coordinates_at_min_depth.get_coordinate_system()),
+                                             compare_point2);
+
+            double compare_distance = compare_distance1;
+            double spreading_velocity_at_ridge_pt = spreading_velocity_at_ridge_pt1;
+            double subducting_velocity_at_trench_pt = subducting_velocity_at_trench_pt1;
+
+            // This is required in spherical coordinates to ensure that the distance
+            // returned is the shortest distance around the sphere.
+            if (compare_distance2 < compare_distance1)
+              {
+                compare_distance = compare_distance2;
+                spreading_velocity_at_ridge_pt = spreading_velocity_at_ridge_pt2;
+                subducting_velocity_at_trench_pt = subducting_velocity_at_trench_pt2;
+              }
+
+            // Then, the distance and velocities are taken from the nearest point on the ridge
+            if (i_coordinate == 0 || compare_distance < distance_ridge)
+              {
+                distance_ridge = compare_distance;
+                spreading_velocity_at_ridge = spreading_velocity_at_ridge_pt;
+                subducting_velocity_at_trench = subducting_velocity_at_trench_pt;
+              }
+          }
+        }
+      std::vector<double> result;
+      result.push_back(spreading_velocity_at_ridge / seconds_in_year); // m/s
+      result.push_back(distance_ridge);
+      result.push_back(subducting_velocity_at_trench / seconds_in_year); // m/s
+      result.push_back(ridge_migration_time);
+      return result;
+    }
+
+    // TODO: implement method for modifying the age of the slab based on ridge/trench migration.
+    std::vector<double>
+    calculate_effective_trench_and_plate_ages(std::vector<double> ridge_parameters, double distance_along_plane)
+    {
+      WBAssert(ridge_parameters.size() == 4, "Internal error: ridge_parameters have the wrong size: " << ridge_parameters.size() << " instead of 4.");
+      const double seconds_in_year = 60.0 * 60.0 * 24.0 * 365.25;  // sec/y
+      const double spreading_velocity = ridge_parameters[0] * seconds_in_year; // m/yr
+      double subducting_velocity = ridge_parameters[2] * seconds_in_year; // m/yr
+
+      if (subducting_velocity <= 0)
+        subducting_velocity = spreading_velocity;
+
+      const double age_at_trench = ridge_parameters[1] / spreading_velocity; // m/(m/y) = yr
+      const double plate_age_sec = age_at_trench * seconds_in_year; // y --> seconds
+
+      // Plate age increases with distance along the slab in the mantle
+      double effective_plate_age = plate_age_sec + (distance_along_plane / subducting_velocity) * seconds_in_year; // m/(m/y) = y(seconds_in_year)
+      WBAssertThrow(effective_plate_age >= 0, "The age of the subducting plate is less than or equal to 0. "
+                    "Effective plate age: " << effective_plate_age);
+      std::vector<double> result;
+      result.push_back(age_at_trench);
+      result.push_back(effective_plate_age);
+      return result;
+
+    }
+  } // namespace Utilities
+} // namespace WorldBuilder
+
+
+
diff --git a/contrib/world_builder/source/world_builder/world.cc.bak b/contrib/world_builder/source/world_builder/world.cc.bak
new file mode 100644
index 00000000000..6871f29ea9c
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/world.cc.bak
@@ -0,0 +1,498 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/world.h"
+
+
+#include "world_builder/config.h"
+#include "world_builder/features/subducting_plate.h"
+#include "world_builder/gravity_model/interface.h"
+#include "world_builder/nan.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/plugin_system.h"
+#include "world_builder/types/point.h"
+#include "world_builder/types/int.h"
+
+#include <iostream>
+#include <world_builder/coordinate_system.h>
+#include <world_builder/objects/distance_from_surface.h>
+
+#ifdef WB_WITH_MPI
+// we don't need the c++ MPI wrappers
+#define OMPI_SKIP_MPICXX 1
+#define MPICH_SKIP_MPICXX
+#include <mpi.h>
+#endif
+
+#ifndef NDEBUG
+#ifdef WB_USE_FP_EXCEPTIONS
+#include <cfenv>
+#endif
+#endif
+
+namespace WorldBuilder
+{
+  using namespace Utilities;
+
+  World::World(std::string filename, bool has_output_dir, const std::string &output_dir, unsigned long random_number_seed, const bool limit_debug_consistency_checks_)
+    :
+    parameters(*this),
+    surface_coord_conversions(invalid),
+    dim(NaN::ISNAN),
+    random_number_engine(random_number_seed),
+    limit_debug_consistency_checks(limit_debug_consistency_checks_)
+  {
+
+#ifndef NDEBUG
+#ifdef WB_USE_FP_EXCEPTIONS
+    // Some implementations seem to not initialize the floating point exception
+    // bits to zero. Make sure we start from a clean state.
+    feclearexcept(FE_DIVBYZERO|FE_INVALID);
+
+    // enable floating point exceptions
+    feenableexcept(FE_DIVBYZERO|FE_INVALID);
+#endif
+#endif
+
+#ifdef WB_WITH_MPI
+    int mpi_initialized;
+    MPI_Initialized(&mpi_initialized);
+    if (mpi_initialized == 0)
+      {
+        MPI_RANK = 0;
+        MPI_SIZE = 1;
+      }
+    else
+      {
+        MPI_Comm_rank(MPI_COMM_WORLD, &MPI_RANK);
+        MPI_Comm_size(MPI_COMM_WORLD, &MPI_SIZE);
+      }
+#else
+    MPI_RANK = 0;
+    MPI_SIZE = 1;
+#endif
+
+    WorldBuilder::World::declare_entries(parameters);
+
+    parameters.initialize(filename, has_output_dir, output_dir);
+
+    this->parse_entries(parameters);
+  }
+
+  World::~World()
+    = default;
+
+  void World::declare_entries(Parameters &prm)
+  {
+    prm.enter_subsection("properties");
+    {
+      prm.declare_entry("", Types::Object({"version", "features"}), "Root object");
+
+      prm.declare_entry("version", Types::String(""),"The major and minor version number for which the input file was written.");
+
+      prm.declare_entry("$schema", Types::String(""),"The optional filename or https address to a JSON schema file");
+
+      prm.declare_entry("cross section", Types::Array(Types::Point<2>(),2,2),"This is an array of two points along where the cross section is taken");
+
+      prm.declare_entry("potential mantle temperature", Types::Double(1600),
+                        "The potential temperature of the mantle at the surface in Kelvin.");
+      prm.declare_entry("surface temperature", Types::Double(293.15),
+                        "The temperature at the surface in Kelvin.");
+      prm.declare_entry("force surface temperature", Types::Bool(false),
+                        "Force the provided surface temperature to be set at the surface");
+      prm.declare_entry("thermal expansion coefficient", Types::Double(3.5e-5),
+                        "The thermal expansion coefficient in $K^{-1}$.");
+      prm.declare_entry("specific heat", Types::Double(1250),
+                        "The specific heat in $J kg^{-1} K^{-1}.$");
+      prm.declare_entry("thermal diffusivity", Types::Double(0.804e-6),
+                        "The thermal diffusivity in $m^{2} s^{-1}$.");
+
+      prm.declare_entry("maximum distance between coordinates",Types::Double(0),
+                        "This enforces a maximum distance (in degree for spherical coordinates "
+                        "or meter in cartesian coordinates) between coordinates in the model. "
+                        "If the distance is larger, extra points are added by interpolation. "
+                        "Requires interpolation to be not 'none'.");
+
+      prm.declare_entry("interpolation",Types::String("continuous monotone spline"),
+                        "What type of interpolation should be used to enforce the minimum points per "
+                        "distance parameter. Options are none, linear, monotone spline and "
+                        "continuous monotone spline interpolation.");
+
+
+      prm.declare_entry("coordinate system", Types::PluginSystem("cartesian", CoordinateSystems::Interface::declare_entries, {"model"}, false),"A coordinate system. Cartesian or spherical.");
+
+      prm.declare_entry("gravity model", Types::PluginSystem("uniform", GravityModel::Interface::declare_entries, {"model"}, false),"A gravity model for the world.");
+
+      prm.declare_entry("features", Types::PluginSystem("",Features::Interface::declare_entries, {"model"}),"A list of features.");
+
+      prm.declare_entry("random number seed", Types::Int(-1),
+                        "This allows the input of a preferred random number seed to generate random numbers."
+                        " If no input is given, this value is -1 and triggers the use of default seed = 1.");
+
+    }
+    prm.leave_subsection();
+
+  }
+
+
+  void World::parse_entries(Parameters &prm)
+  {
+    using namespace rapidjson;
+
+    /**
+     * First load the major version number in the file and check the major
+     * version number of the program.
+     */
+
+    WBAssertThrow((Version::MAJOR == "0"
+                   && prm.get<std::string>("version") == Version::MAJOR + "." + Version::MINOR)
+                  || (Version::MAJOR != "0"
+                      && prm.get<std::string>("version") == Version::MAJOR),
+                  "The major and minor version combination (for major version 0) or the major "
+                  "version (for major versions after 0) for which is input file was written "
+                  "is not the same as the version of the World Builder you are running. This means "
+                  "That there may have been incompatible changes made between the versions. \n\n"
+                  "Verify those changes and whether they affect your model. If this is not "
+                  "the case, adjust the version number in the input file. \n\nThe provided version "
+                  "number is \"" << prm.get<std::string>("version") << "\", while the used world builder "
+                  "has  (major.minor) version \"" << Version::MAJOR << "." << Version::MINOR << "\". "
+                  "If you created this file from scratch, fill set the version number to \"" <<
+                  Version::MAJOR << "." << Version::MINOR << "\" to continue. If you got the world builder "
+                  "file from somewhere, make sure that the output is what you expect it to be, because "
+                  "backwards incompatible changes may have been made to the code.");
+
+    /**
+     * Secondly load the coordinate system parameters.
+     */
+    prm.coordinate_system = prm.get_unique_pointer<CoordinateSystems::Interface>("coordinate system");
+    prm.coordinate_system->parse_entries(prm);
+
+    /**
+     * Thirdly load the gravity model parameters.
+     */
+    prm.gravity_model = prm.get_unique_pointer<GravityModel::Interface>("gravity model");
+
+    prm.enter_subsection("gravity model");
+    {
+      prm.gravity_model->parse_entries(prm);
+    }
+    prm.leave_subsection();
+
+    prm.get_unique_pointers<Features::Interface>("features",prm.features);
+
+    const bool set_cross_section = prm.check_entry("cross section");
+
+    const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
+
+    if (set_cross_section)
+      {
+        dim = 2;
+        const std::vector<Point<2> > cross_section_natural = prm.get_vector<Point<2> >("cross section");
+
+        WBAssertThrow(cross_section_natural.size() == 2, "The cross section should contain two points, but it contains "
+                      << cross_section.size() << " points.");
+
+        for (const auto &it : cross_section_natural)
+          cross_section.push_back(it *  (coordinate_system == spherical ? Consts::PI / 180.0 : 1.0));
+
+
+        /**
+         * pre-compute stuff for the cross section
+         */
+        surface_coord_conversions = cross_section[0]-cross_section[1];
+        surface_coord_conversions *= -1/(surface_coord_conversions.norm());
+
+
+      }
+    else
+      {
+        dim = 3;
+      }
+
+    /**
+     * Temperature parameters.
+     */
+    potential_mantle_temperature = prm.get<double>("potential mantle temperature");
+    surface_temperature = prm.get<double>("surface temperature");
+    surface_temperature = prm.get<double>("surface temperature");
+    force_surface_temperature = prm.get<bool>("force surface temperature");
+    thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
+    specific_heat = prm.get<double>("specific heat");
+    thermal_diffusivity = prm.get<double>("thermal diffusivity");
+
+    /**
+     * Model discretization parameters
+     */
+    maximum_distance_between_coordinates = prm.get<double>("maximum distance between coordinates");
+    interpolation = prm.get<std::string>("interpolation");
+
+    /**
+     * Local random number seed parameter
+    */
+    const int local_seed = prm.get<int>("random number seed");
+
+    if (local_seed>=0)
+      random_number_engine.seed(static_cast<unsigned int>(local_seed+MPI_RANK));
+
+    /**
+     * Now load the features. Some features use for example temperature values,
+     * so it is important that this is parsed the last.
+     */
+    prm.enter_subsection("features");
+    {
+      for (unsigned int i = 0; i < prm.features.size(); ++i)
+        {
+          prm.enter_subsection(std::to_string(i));
+          {
+            prm.features[i]->parse_entries(prm);
+          }
+          prm.leave_subsection();
+        }
+    }
+    prm.leave_subsection();
+  }
+
+
+
+  std::vector<double>
+  World::properties(const std::array<double, 2> &point,
+                    const double depth,
+                    const std::vector<std::array<unsigned int,3>> &properties) const
+  {
+    // turn it into a 3d coordinate and call the 3d temperature function
+    WBAssertThrow(dim == 2, "This function can only be called when the cross section "
+                  "variable in the world builder file has been set. Dim is "
+                  << dim << '.');
+
+    const CoordinateSystem coordinate_system = this->parameters.coordinate_system->natural_coordinate_system();
+
+    Point<2> point_natural(point[0], point[1],coordinate_system);
+    if (coordinate_system == spherical)
+      {
+        point_natural[1] = std::sqrt(point[0]*point[0]+point[1]*point[1]);
+        point_natural[0] = std::atan2(point[1],point[0]);
+      }
+
+    Point<3> coord_3d(coordinate_system);
+    if (coordinate_system == spherical)
+      {
+        coord_3d[0] = point_natural[1];
+        coord_3d[1] = cross_section[0][0] + point_natural[0] * surface_coord_conversions[0];
+        coord_3d[2] = cross_section[0][1] + point_natural[0] * surface_coord_conversions[1];
+      }
+    else
+      {
+        coord_3d[0] = cross_section[0][0] + point_natural[0] * surface_coord_conversions[0];
+        coord_3d[1] = cross_section[0][1] + point_natural[0] * surface_coord_conversions[1];
+        coord_3d[2] = point_natural[1];
+      }
+
+
+    const std::array<double, 3> point_3d_cartesian = this->parameters.coordinate_system->natural_to_cartesian_coordinates(coord_3d.get_array());
+
+    return this->properties(point_3d_cartesian, depth, properties);
+  }
+
+
+  std::vector<double>
+  World::properties(const std::array<double, 3> &point_,
+                    const double depth,
+                    const std::vector<std::array<unsigned int,3>> &properties) const
+  {
+    // We receive the cartesian points from the user.
+    const Point<3> point(point_,cartesian);
+    (void) this->limit_debug_consistency_checks;
+    WBAssert(this->limit_debug_consistency_checks || this->parameters.coordinate_system->natural_coordinate_system() == cartesian
+             || approx(depth, this->parameters.coordinate_system->max_model_depth()-sqrt(point_[0]*point_[0]+point_[1]*point_[1]+point_[2]*point_[2])),
+             "Inconsistent input. Please check whether the radius in the spherical coordinates is consistent with the radius of the planet as defined "
+             << "in the program that uses the Geodynamic World Builder. This is a debug check in GWB and can be disabled by setting "
+             << "limit_debug_consistency_checks to true. "
+             << "Depth = " << depth << ", radius = " << this->parameters.coordinate_system->max_model_depth()
+             << ", point = " << point_[0] << " " << point_[1] << " " << point_[2]
+             << ", radius-point.norm() = " << this->parameters.coordinate_system->max_model_depth()-sqrt(point_[0]*point_[0]+point_[1]*point_[1]+point_[2]*point_[2]));
+
+    const Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(point,*(this->parameters.coordinate_system));
+
+    // create output vector
+    std::vector<double> output;
+    std::vector<size_t> entry_in_output;
+    std::vector<std::array<unsigned int,3>> properties_local;
+    const double gravity_norm = this->parameters.gravity_model->gravity_norm(point);
+    for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
+      {
+        switch (properties[i_property][0])
+          {
+            case 1: // Temperature
+              if (std::fabs(depth) < 2.0 * std::numeric_limits<double>::epsilon() && force_surface_temperature)
+                {
+                  entry_in_output.emplace_back(output.size());
+                  output.emplace_back(this->surface_temperature);
+                  if (properties.size() == 1)
+                    return output;
+                }
+              else
+                {
+                  entry_in_output.emplace_back(output.size());
+                  output.emplace_back(potential_mantle_temperature * std::exp(((thermal_expansion_coefficient * gravity_norm) / specific_heat) * depth));
+                }
+              properties_local.emplace_back(properties[i_property]);
+              break;
+            case 2: // composition
+              entry_in_output.emplace_back(output.size());
+              output.emplace_back(0.);
+              properties_local.emplace_back(properties[i_property]);
+              break;
+            case 3: // grains (10 entries per grain)
+            {
+              entry_in_output.emplace_back(output.size());
+              const std::vector<double> tmp_vector(properties[i_property][2]*10,0.);
+              output.insert(output.end(), tmp_vector.begin(), tmp_vector.end());
+              properties_local.emplace_back(properties[i_property]);
+              break;
+            }
+            case 4: // tag
+            {
+              entry_in_output.emplace_back(output.size());
+              output.emplace_back(-1);
+              properties_local.emplace_back(properties[i_property]);
+              break;
+            }
+            default:
+              WBAssertThrow(false,
+                            "Internal error: Unimplemented property provided. " <<
+                            "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
+                            "Provided property number was: " << properties[i_property][0]);
+          }
+      }
+    for (auto &&it : parameters.features)
+      {
+        it->properties(point, natural_coordinate, depth, properties_local, gravity_norm, entry_in_output, output);
+      }
+
+    return output;
+  }
+
+  double
+  World::temperature(const std::array<double,2> &point,
+                     const double depth) const
+  {
+    return properties(point, depth, {{{1,0,0}}})[0];
+  }
+
+  double
+  World::temperature(const std::array<double,2> &point,
+                     const double depth,
+                     const double /*gravity_norm*/) const
+  {
+    return properties(point, depth, {{{1,0,0}}})[0];
+  }
+
+  double
+  World::temperature(const std::array<double,3> &point,
+                     const double depth) const
+  {
+    return properties(point, depth, {{{1,0,0}}})[0];
+  }
+
+  double
+  World::temperature(const std::array<double,3> &point,
+                     const double depth,
+                     const double /*gravity_norm*/) const
+  {
+    return properties(point, depth, {{{1,0,0}}})[0];
+  }
+
+  double
+  World::composition(const std::array<double,2> &point,
+                     const double depth,
+                     const unsigned int composition_number) const
+  {
+    return properties(point, depth, {{{2,composition_number,0}}})[0];
+  }
+
+  double
+  World::composition(const std::array<double,3> &point,
+                     const double depth,
+                     const unsigned int composition_number) const
+  {
+    return properties(point, depth, {{{2,composition_number,0}}})[0];
+  }
+
+
+
+  WorldBuilder::grains
+  World::grains(const std::array<double,2> &point,
+                const double depth,
+                const unsigned int composition_number,
+                size_t number_of_grains) const
+  {
+    return WorldBuilder::grains(properties(point, depth, {{{3,composition_number,static_cast<unsigned int>(number_of_grains)}}}),static_cast<unsigned int>(number_of_grains),0);
+  }
+
+  WorldBuilder::grains
+  World::grains(const std::array<double,3> &point,
+                const double depth,
+                const unsigned int composition_number,
+                size_t number_of_grains) const
+  {
+    return WorldBuilder::grains(properties(point, depth, {{{3,composition_number,static_cast<unsigned int>(number_of_grains)}}}),static_cast<unsigned int>(number_of_grains),0);
+  }
+
+  std::mt19937 &
+  World::get_random_number_engine()
+  {
+    return random_number_engine;
+  }
+
+  Objects::PlaneDistances
+  World::distance_to_plane(const std::array<double, 3> &point_,
+                           const double depth,
+                           const std::string &name) const
+  {
+    // We receive the cartesian points from the user.
+    const Point<3> point(point_,cartesian);
+
+    WBAssert(this->limit_debug_consistency_checks || this->parameters.coordinate_system->natural_coordinate_system() == cartesian
+             || approx(depth, this->parameters.coordinate_system->max_model_depth()-sqrt(point_[0]*point_[0]+point_[1]*point_[1]+point_[2]*point_[2])),
+             "Inconsistent input. Please check whether the radius in the spherical coordinates is consistent with the radius of the planet as defined "
+             << "in the program that uses the Geodynamic World Builder. This is a debug check in GWB and can be disabled by setting "
+             << "limit_debug_consistency_checks to true. "
+             << "Depth = " << depth << ", radius = " << this->parameters.coordinate_system->max_model_depth()
+             << ", point = " << point_[0] << " " << point_[1] << " " << point_[2]
+             << ", radius-point.norm() = " << this->parameters.coordinate_system->max_model_depth()-sqrt(point_[0]*point_[0]+point_[1]*point_[1]+point_[2]*point_[2]));
+
+    const Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(point,*(this->parameters.coordinate_system));
+
+    Objects::PlaneDistances plane_distances(0.0, 0.0);
+    for (auto &&it : this->parameters.features)
+      {
+        if (it->get_name() == name)
+          {
+            plane_distances = it->distance_to_feature_plane(point, natural_coordinate, depth);
+            break;
+          }
+      }
+    return plane_distances;
+  }
+
+} // namespace WorldBuilder
+
diff --git a/contrib/world_builder/source/world_builder/wrapper_c.cc.bak b/contrib/world_builder/source/world_builder/wrapper_c.cc.bak
new file mode 100644
index 00000000000..e0b95e6e47a
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/wrapper_c.cc.bak
@@ -0,0 +1,108 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/wrapper_c.h"
+
+#include "world_builder/world.h"
+
+extern "C" {
+  /**
+   * This function creates an object of the world builder and returns a pointer
+   * to it. This pointer can then be used to call the temperature and composition
+   * functions. When done call the release world function to destroy the object.
+   */
+  void create_world(void **ptr_ptr_world, const char *world_builder_file, const bool *has_output_dir_, const char *output_dir_, const unsigned long random_number_seed)
+  {
+    bool has_output_dir = false;
+
+    if (has_output_dir_ != nullptr)
+      {
+        has_output_dir = *has_output_dir_;
+      }
+
+    std::string output_dir;
+    if (output_dir_ != nullptr)
+      {
+        output_dir = *output_dir_;
+      }
+
+    WorldBuilder::World *a = new WorldBuilder::World(std::string(world_builder_file), has_output_dir, output_dir,random_number_seed);
+
+    *ptr_ptr_world = reinterpret_cast<void *>(a);
+  }
+
+
+  /**
+   * This function return the temperature at a specific location given x, z, depth and
+   * gravity.
+   */
+  void temperature_2d(void *ptr_ptr_world, double x, double z, double depth, double *temperature)
+  {
+    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
+    const std::array<double,2> position = {{x,z}};
+    *temperature = a->temperature(position,depth);
+  }
+
+
+  /**
+   * This function return the temperature at a specific location given x, y, z, depth and
+   * gravity.
+   */
+  void temperature_3d(void *ptr_ptr_world, double x, double y, double z, double depth, double *temperature)
+  {
+    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
+    const std::array<double,3> position = {{x,y,z}};
+    *temperature = a->temperature(position,depth);
+  }
+
+
+  /**
+   * This function return the composition at a specific location given x, z, depth and
+   * composition number.
+   */
+  void composition_2d(void *ptr_ptr_world, double x, double z, double depth, unsigned int composition_number, double *composition)
+  {
+    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
+    const std::array<double,2> position = {{x,z}};
+    *composition = a->composition(position,depth,composition_number);
+  }
+
+
+  /**
+   * This function return the composition at a specific location given x, y, z, depth and
+   * composition number.
+   */
+  void composition_3d(void *ptr_ptr_world, double x, double y, double z, double depth, unsigned int composition_number, double *composition)
+  {
+    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
+    const std::array<double,3> position = {{x,y,z}};
+    *composition = a->composition(position,depth,composition_number);
+  }
+
+
+  /**
+   * The destructor for the world builder class. Call this function when done with the
+   * world builder.
+   */
+  void release_world(void *ptr_ptr_world)
+  {
+    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
+    delete a;
+  }
+}
diff --git a/contrib/world_builder/source/world_builder/wrapper_cpp.cc.bak b/contrib/world_builder/source/world_builder/wrapper_cpp.cc.bak
new file mode 100644
index 00000000000..d4764ab2413
--- /dev/null
+++ b/contrib/world_builder/source/world_builder/wrapper_cpp.cc.bak
@@ -0,0 +1,77 @@
+/*
+  Copyright (C) 2018-2024 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "world_builder/wrapper_cpp.h"
+
+#include "world_builder/world.h"
+
+using namespace WorldBuilder;
+namespace wrapper_cpp
+{
+  WorldBuilderWrapper::WorldBuilderWrapper(std::string filename, bool has_output_dir, const std::string &output_dir, const unsigned long random_number_seed)
+    : ptr_ptr_world(nullptr)
+  {
+    WorldBuilder::World *a = new WorldBuilder::World(std::move(filename), has_output_dir, output_dir, random_number_seed);
+    ptr_ptr_world = reinterpret_cast<void *>(a);
+  }
+
+
+  WorldBuilderWrapper::~WorldBuilderWrapper()
+  {
+    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
+    delete a;
+  }
+
+
+  double
+  WorldBuilderWrapper::temperature_2d(double x, double z, double depth)
+  {
+    const std::array<double,2> position = {{x,z}};
+    return reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world)->temperature(position,depth);
+  }
+
+  double
+  WorldBuilderWrapper::temperature_2d(double x, double z, double depth, double /*gravity*/)
+  {
+    return temperature_2d(x,z,depth);
+  }
+
+  double WorldBuilderWrapper::temperature_3d(double x, double y, double z, double depth)
+  {
+    const std::array<double,3> position = {{x,y,z}};
+    return reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world)->temperature(position,depth);
+  }
+
+  double WorldBuilderWrapper::temperature_3d(double x, double y, double z, double depth, double /*gravity*/)
+  {
+    return temperature_3d(x,y,z,depth);
+  }
+
+  double WorldBuilderWrapper::composition_2d(double x, double z, double depth, unsigned int composition_number)
+  {
+    const std::array<double,2> position = {{x,z}};
+    return reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world)->composition(position,depth,composition_number);
+  }
+
+  double WorldBuilderWrapper::composition_3d(double x, double y, double z, double depth, unsigned int composition_number)
+  {
+    const std::array<double,3> position = {{x,y,z}};
+    return reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world)->composition(position,depth,composition_number);
+  }
+} // namespace wrapper_cpp
diff --git a/contrib/world_builder/tests/unit_tests/bounding_box.cc.bak b/contrib/world_builder/tests/unit_tests/bounding_box.cc.bak
new file mode 100644
index 00000000000..a438f3ceb42
--- /dev/null
+++ b/contrib/world_builder/tests/unit_tests/bounding_box.cc.bak
@@ -0,0 +1,87 @@
+/*
+  Copyright (C) 2021 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
+
+#include "doctest/doctest.h"
+
+#include "world_builder/bounding_box.h"
+
+using namespace WorldBuilder;
+using doctest::Approx;
+
+
+TEST_CASE("bounding box 2D")
+{
+  // Check default constructor
+  const BoundingBox<2> bb1;
+  CHECK(bb1.center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
+  CHECK(BoundingBox<2>().center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
+
+  CHECK(bb1.point_inside(Point<2>(2,2.5,CoordinateSystem::cartesian)) == true);
+  const Point<2> p1 ({{1,1}}, CoordinateSystem::cartesian);
+  const Point<2> p2 ({{2,3}}, CoordinateSystem::cartesian);
+
+
+  CHECK(BoundingBox<2>().center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
+  const BoundingBox<2> bb2({p1, p2});
+  CHECK(bb2.center().distance(Point<2>(1.5,2.,CoordinateSystem::cartesian)) < 1e-12);
+
+  // Check that the function point_inside works as expected
+  CHECK(bb2.point_inside(Point<2>(1.5,2,CoordinateSystem::cartesian)) == true);
+  CHECK(bb2.point_inside(Point<2>(-1.5,2,CoordinateSystem::cartesian)) == false);
+  CHECK(bb2.point_inside(Point<2>(1.5,-2,CoordinateSystem::cartesian)) == false);
+  CHECK(bb2.point_inside(Point<2>(-1.5,-2,CoordinateSystem::cartesian)) == false);
+}
+
+
+TEST_CASE("bounding box 3D")
+{
+  // Check default constructor
+  const BoundingBox<3> bb1;
+  CHECK(bb1.center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
+  CHECK(BoundingBox<3>().center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
+
+  CHECK(bb1.point_inside(Point<3>(2,2.5,2.5,CoordinateSystem::cartesian)) == true);
+
+  // Check constructor with provided points
+  const Point<3> p1 (
+  {
+    {
+      1,1,1
+    }
+  }, CoordinateSystem::cartesian);
+  const Point<3> p2 (
+  {
+    {
+      2,3,4
+    }
+  }, CoordinateSystem::cartesian);
+  const BoundingBox<3> bb2({p1, p2});
+
+  // Check the center function
+  CHECK(bb2.center().distance(Point<2>(1.5,2,CoordinateSystem::cartesian)) < 1e-12);
+
+  // Check that the function point_inside works as expected
+  CHECK(bb2.point_inside(Point<3>(1.5,2,2.5,CoordinateSystem::cartesian)) == true);
+  CHECK(bb2.point_inside(Point<3>(-1.5,2,2.5,CoordinateSystem::cartesian)) == false);
+  CHECK(bb2.point_inside(Point<3>(1.5,-2,2.5,CoordinateSystem::cartesian)) == false);
+  CHECK(bb2.point_inside(Point<3>(1.5,2,-2.5,CoordinateSystem::cartesian)) == false);
+
+}
diff --git a/contrib/world_builder/tests/unit_tests/gwb_gravity.cc.bak b/contrib/world_builder/tests/unit_tests/gwb_gravity.cc.bak
new file mode 100644
index 00000000000..c6a586a6267
--- /dev/null
+++ b/contrib/world_builder/tests/unit_tests/gwb_gravity.cc.bak
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2021 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
+
+#include "doctest/doctest.h"
+
+#include "world_builder/config.h"
+#include "world_builder/coordinate_systems/invalid.h"
+#include "world_builder/gravity_model/uniform.h"
+#include "world_builder/parameters.h"
+#include "world_builder/point.h"
+#include "world_builder/world.h"
+
+using namespace WorldBuilder;
+using doctest::Approx;
+using doctest::Contains;
+
+TEST_CASE("Gravity uniform")
+{
+
+  const std::string file_name = Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian.wb";
+  World world(file_name);
+
+  CHECK(world.parameters.gravity_model->gravity_norm(Point<3>(10,10,10,CoordinateSystem::cartesian)) == Approx(10.));
+
+  auto vector_cartesian = world.parameters.gravity_model->gravity_vector(Point<3>(10,10,10,CoordinateSystem::cartesian));
+
+  CHECK(vector_cartesian[0] == Approx(0));
+  CHECK(vector_cartesian[1] == Approx(0));
+  CHECK(vector_cartesian[2] == Approx(-10.));
+
+
+  const std::string file_name_spherical = Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_spherical.wb";
+  World world_spherical(file_name_spherical);
+
+  auto vector_spherical = world_spherical.parameters.gravity_model->gravity_vector(Point<3>(1,2,4,CoordinateSystem::spherical));
+
+  CHECK(vector_spherical[0] == Approx(-2.1821789024));
+  CHECK(vector_spherical[1] == Approx(-4.3643578047));
+  CHECK(vector_spherical[2] == Approx(-8.7287156094));
+  CHECK(std::sqrt(vector_spherical[0]*vector_spherical[0]+
+                  vector_spherical[1]*vector_spherical[1]+
+                  vector_spherical[2]*vector_spherical[2]) == Approx(10.));
+
+  world_spherical.parameters.coordinate_system =
+    std::unique_ptr<CoordinateSystems::Interface>(new CoordinateSystems::Invalid(nullptr));
+
+  CHECK_THROWS_WITH(world_spherical.parameters.gravity_model->gravity_vector(Point<3>(1,2,4,CoordinateSystem::invalid)),
+                    Contains("Invalid coordinate system when using the gravity vector function."));
+
+}
\ No newline at end of file
diff --git a/contrib/world_builder/tests/unit_tests/kd_tree.cc.bak b/contrib/world_builder/tests/unit_tests/kd_tree.cc.bak
new file mode 100644
index 00000000000..154144bebb0
--- /dev/null
+++ b/contrib/world_builder/tests/unit_tests/kd_tree.cc.bak
@@ -0,0 +1,214 @@
+/*
+  Copyright (C) 2022 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
+
+#include "doctest/doctest.h"
+#include "world_builder/coordinate_system.h"
+#include "world_builder/kd_tree.h"
+
+#include <iostream>
+
+using namespace WorldBuilder::KDTree;
+using doctest::Approx;
+
+/**
+ * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
+ */
+inline void compare_node_trees(
+  const std::vector<Node> &computed,
+  const std::vector<Node> &expected)
+{
+  for (size_t i = 0; i < computed.size(); ++i)
+    {
+      CHECK(computed[i].index == expected[i].index);
+      CHECK(computed[i].x == Approx(expected[i].x));
+      CHECK(computed[i].y == Approx(expected[i].y));
+    }
+}
+
+TEST_CASE("create kd-tree: 15 nodes")
+{
+  const std::vector<Node> reference = {Node(8,2,3),Node(4,4,4),Node(9,5,2),
+                                       Node(2,1,5),Node(10,2,9),Node(5,5,8),
+                                       Node(11,6,7),Node(1,7,3),Node(12,9,2.5),
+                                       Node(6,10,2),Node(13,11.5,1),Node(3,11,4),
+                                       Node(14,8,6),Node(7,9,7),Node(15,11,8)
+                                      };
+  {
+    const std::vector<Node> nodes = {Node(1,7,3),Node(2,1,5),Node(3,11,4),
+                                     Node(4,4,4),Node(5,5,8),Node(6,10,2),
+                                     Node(7,9,7),Node(8,2,3),Node(9,5,2),
+                                     Node(10,2,9),Node(11,6,7),Node(12,9,2.5),
+                                     Node(13,11.5,1),Node(14,8,6),Node(15,11,8)
+                                    };
+
+    KDTree tree = KDTree(nodes);
+
+    tree.create_tree(0, nodes.size()-1, false);
+
+    compare_node_trees(tree.get_nodes(), reference);
+  }
+
+  {
+    // shuffle nodes
+    const std::vector<Node> nodes = {Node(2,1,5),Node(3,11,4),Node(9,5,2),
+                                     Node(4,4,4),Node(1,7,3),Node(5,5,8),
+                                     Node(7,9,7),Node(8,2,3),Node(11,6,7),
+                                     Node(10,2,9),Node(12,9,2.5),Node(14,8,6),
+                                     Node(13,11.5,1),Node(6,10,2),Node(15,11,8)
+                                    };
+
+    KDTree tree = KDTree(nodes);
+
+    tree.create_tree(0, nodes.size()-1, false);
+
+    compare_node_trees(tree.get_nodes(), reference);
+  }
+}
+
+
+TEST_CASE("create kd-tree: 6 nodes")
+{
+  const std::vector<Node> reference = {Node(4,4,2),Node(5,2,6),Node(2,7,6),
+                                       Node(1,9,2),Node(6,12,3),Node(3,11,6)
+                                      };
+  {
+    const std::vector<Node> nodes = {Node(1,9,2),Node(2,7,6),Node(3,11,6),
+                                     Node(4,4,2),Node(5,2,6),Node(6,12,3)
+                                    };
+
+    KDTree tree = KDTree(nodes);
+
+    tree.create_tree(0, nodes.size()-1, false);
+
+    compare_node_trees(tree.get_nodes(), reference);
+  }
+
+  {
+    // shuffle nodes
+    const std::vector<Node> nodes = {Node(5,2,6),Node(2,7,6),Node(1,9,2),
+                                     Node(6,12,3),Node(4,4,2),Node(3,11,6)
+                                    };
+
+    KDTree tree = KDTree(nodes);
+
+    tree.create_tree(0, nodes.size()-1, false);
+
+    compare_node_trees(tree.get_nodes(), reference);
+  }
+}
+
+
+TEST_CASE("create kd-tree: 10 nodes")
+{
+  const std::vector<Node> reference = {Node(3,2,1),Node(1,4,2),Node(4,1,4),
+                                       Node(7,3,6),Node(0,7,3),Node(5,9,2),
+                                       Node(8,11,1),Node(2,12,3),Node(9,10,5),
+                                       Node(6,11,6)
+                                      };
+  {
+    const std::vector<Node> nodes = {Node(0,7,3),Node(1,4,2),Node(2,12,3),
+                                     Node(3,2,1),Node(4,1,4),Node(5,9,2),
+                                     Node(7,3,6),Node(6,11,6),Node(9,10,5),
+                                     Node(8,11,1)
+                                    };
+
+    KDTree tree = KDTree(nodes);
+
+    tree.create_tree(0, nodes.size()-1, false);
+
+    compare_node_trees(tree.get_nodes(), reference);
+
+    // check some values
+    using namespace WorldBuilder;
+    std::vector<Point<2>> check_points = {Point<2>(7,2,CoordinateSystem::cartesian),
+                                          Point<2>(8,2,CoordinateSystem::cartesian),
+                                          Point<2>(9,2,CoordinateSystem::cartesian),
+                                          Point<2>(8,2.5001,CoordinateSystem::cartesian),
+                                          Point<2>(8,2.4999,CoordinateSystem::cartesian),
+                                          Point<2>(7,3,CoordinateSystem::cartesian),
+                                          Point<2>(11,1.5,CoordinateSystem::cartesian),
+                                          Point<2>(10,2,CoordinateSystem::cartesian),
+                                          Point<2>(12,2,CoordinateSystem::cartesian),
+                                          Point<2>(11,0.5,CoordinateSystem::cartesian),
+                                          Point<2>(9.25,1.75,CoordinateSystem::cartesian),
+                                          Point<2>(11,3.5,CoordinateSystem::cartesian),
+                                          Point<2>(10.5,4,CoordinateSystem::cartesian),
+                                          Point<2>(9.5,4,CoordinateSystem::cartesian),
+                                          Point<2>(9.5,5.5,CoordinateSystem::cartesian),
+                                          Point<2>(10.75,5.5,CoordinateSystem::cartesian),
+                                          Point<2>(11.75,5.5,CoordinateSystem::cartesian),
+                                          Point<2>(5,1,CoordinateSystem::cartesian),
+                                          Point<2>(3,1,CoordinateSystem::cartesian),
+                                          Point<2>(1,1,CoordinateSystem::cartesian),
+                                          Point<2>(2,3,CoordinateSystem::cartesian),
+                                          Point<2>(0.5,3,CoordinateSystem::cartesian),
+                                          Point<2>(0.5,5,CoordinateSystem::cartesian),
+                                          Point<2>(2,4.5,CoordinateSystem::cartesian),
+                                          Point<2>(3,5,CoordinateSystem::cartesian),
+                                          Point<2>(3,7,CoordinateSystem::cartesian)
+                                         };
+
+    std::vector<size_t> index_results = {4,5,5,4,5,4,6,5,7,6,5,7,8,8,8,9,9,1,0,0,2,2,2,2,3,3};
+
+    for (size_t i = 0; i < check_points.size(); ++i)
+      {
+        IndexDistance const index_distance = tree.find_closest_point(check_points[i]);
+
+        CHECK(index_distance.index == index_results[i]);
+      }
+
+    std::vector<std::vector<size_t> > index_distances_results =
+    {
+      {5,7,8,4,3,2,1,0},{5,7,4,3,2,1,0},{6,5,7,4,3,2,1},{5,6,7,8,4,3,2,1,0},
+      {5,6,7,8,4,3,2,1,0},{8,9,7,5,6,4,},{6,5,7,4,0,1},{6,5,7,4,3,2,1,0},
+      {6,5,7,4,3,2,1,0},{6,5,7,4,0,1},{6,5,7,4,0,1,3,2},{9,8,7,6,5,4,3,2,1,0},
+      {9,8,7,6,5,4,3,2,1,0},{8,9,7,6,5,4,3,2,1,0},{8,9,7,6,5,4,3,2,1,0},
+      {9,8,7,6,5,4,3,2,1,0},{9,8,7,6,5,4,3,2,1,0},{0,1,3,2,4},{0,1,4},{0,1,4},
+      {3,2,1,0,4},{2,3,1,0,4},{2,3,1,0,4},{3,2,1,0,4},{3,2,1,0,4},{3,2,1,0,4}
+    };
+
+    for (size_t i = 0; i < check_points.size(); ++i)
+      {
+        IndexDistances index_distances = tree.find_closest_points(check_points[i]);
+        CHECK(index_distances.min_index == index_results[i]);
+
+        for (size_t j = 0; j < index_distances.vector.size(); ++j)
+          {
+            CHECK(index_distances.vector[j].index == index_distances_results[i][j]);
+          }
+      }
+  }
+
+  {
+    // shuffle nodes
+    const std::vector<Node> nodes = {Node(3,2,1),Node(4,1,4),Node(5,9,2),
+                                     Node(0,7,3),Node(6,11,6),Node(2,12,3),
+                                     Node(7,3,6),Node(9,10,5),Node(1,4,2),
+                                     Node(8,11,1)
+                                    };
+
+    KDTree tree = KDTree(nodes);
+
+    tree.create_tree(0, nodes.size()-1, false);
+
+    compare_node_trees(tree.get_nodes(), reference);
+  }
+}
\ No newline at end of file
diff --git a/contrib/world_builder/tests/unit_tests/main.cc.bak b/contrib/world_builder/tests/unit_tests/main.cc.bak
new file mode 100644
index 00000000000..64fe8ac9bad
--- /dev/null
+++ b/contrib/world_builder/tests/unit_tests/main.cc.bak
@@ -0,0 +1,25 @@
+
+/*
+  Copyright (C) 2018 - 2021 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#define APPROVALS_DOCTEST // This tells Approval Tests to provide a main() - only do this in one cpp file
+#include "ApprovalTests/ApprovalTests.hpp"
+
+auto directoryDisposer = ApprovalTests::Approvals::useApprovalsSubdirectory("approval_tests");
+auto default_namer_disposer = ApprovalTests::SeparateApprovedAndReceivedDirectoriesNamer::useAsDefaultNamer();
\ No newline at end of file
diff --git a/contrib/world_builder/tests/unit_tests/unit_test_wb_glm.cc.bak b/contrib/world_builder/tests/unit_tests/unit_test_wb_glm.cc.bak
new file mode 100644
index 00000000000..f37dddd01a8
--- /dev/null
+++ b/contrib/world_builder/tests/unit_tests/unit_test_wb_glm.cc.bak
@@ -0,0 +1,253 @@
+/*
+  Copyright (C) 2020 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
+
+#include "doctest/doctest.h"
+
+#include "glm/glm.h"
+
+#include "world_builder/coordinate_system.h"
+#include "world_builder/utilities.h"
+
+#include <array>
+
+using namespace WorldBuilder;
+using doctest::Approx;
+
+
+/**
+ * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
+ */
+inline void compare_3d_arrays_approx(
+  const std::array<double,3> &computed,
+  const std::array<double,3> &expected)
+{
+  CHECK(computed.size() == expected.size());
+  for (unsigned int i=0; i< computed.size(); ++i)
+    {
+      INFO("vector index i=" << i << ": ");
+      CHECK(computed[i] == Approx(expected[i]));
+    }
+}
+
+/**
+ * Compare two rotation matrices
+ */
+inline void compare_rotation_matrices_approx(
+  const std::array<std::array<double,3>,3> &computed,
+  const std::array<std::array<double,3>,3> &expected)
+{
+  // sign of eigenvector is not important
+  INFO("rotation matrices are not the same: \n" <<
+       "expected = " << expected[0][0] << ' ' << expected[0][1] << ' ' << expected[0][2] << "\n" <<
+       "           " << expected[1][0] << ' ' << expected[1][1] << ' ' << expected[1][2] << "\n" <<
+       "           " << expected[2][0] << ' ' << expected[2][1] << ' ' << expected[2][2] << "\n" <<
+       "computed = " << computed[0][0] << ' ' << computed[0][1] << ' ' << computed[0][2] << "\n" <<
+       "           " << computed[1][0] << ' ' << computed[1][1] << ' ' << computed[1][2] << "\n" <<
+       "           " << computed[2][0] << ' ' << computed[2][1] << ' ' << computed[2][2] << "\n" );
+  CHECK((
+          (computed[0][0] == Approx(expected[0][0]) && computed[0][1] == Approx(expected[0][1]) && computed[0][2] == Approx(expected[0][2]) &&
+           computed[1][0] == Approx(expected[1][0]) && computed[1][1] == Approx(expected[1][1]) && computed[1][2] == Approx(expected[1][2]) &&
+           computed[2][0] == Approx(expected[2][0]) && computed[2][1] == Approx(expected[2][1]) && computed[2][2] == Approx(expected[2][2]))
+          ||
+          (computed[0][0] == Approx(-expected[0][0]) && computed[0][1] == Approx(-expected[0][1]) && computed[0][2] == Approx(-expected[0][2]) &&
+           computed[1][0] == Approx(-expected[1][0]) && computed[1][1] == Approx(-expected[1][1]) && computed[1][2] == Approx(-expected[1][2]) &&
+           computed[2][0] == Approx(-expected[2][0]) && computed[2][1] == Approx(-expected[2][1]) && computed[2][2] == Approx(-expected[2][2]))));
+}
+
+inline
+void
+compare_quaternions(
+  const glm::quaternion::quat &computed,
+  const glm::quaternion::quat &expected
+)
+{
+  CHECK(computed.w == Approx(expected.w));
+  CHECK(computed.x == Approx(expected.x));
+  CHECK(computed.y == Approx(expected.y));
+  CHECK(computed.z == Approx(expected.z));
+}
+
+TEST_CASE("glm quat basic functions")
+{
+  typedef glm::quaternion::quat QT;
+  QT q1(2,3,4,5);
+  QT const q2(6,7,8,9);
+  QT const q3(9,8,7,6);
+
+
+  QT q_res = -q1;
+  compare_quaternions(q_res, QT(-2,-3,-4,-5));
+
+  q_res = q1 + q2;
+  compare_quaternions(q_res, QT(8,10,12,14));
+
+  q_res = q2 - q1;
+  compare_quaternions(q_res, QT(-4,-4,-4,-4));
+  q_res = q3 - q1;
+  compare_quaternions(q_res, QT(-7,-5,-3,-1));
+
+
+  q_res = q1 * 2.0;
+  compare_quaternions(q_res, QT(4,6,8,10));
+  q_res = 2.0 * q1;
+  compare_quaternions(q_res, QT(4,6,8,10));
+
+
+  q_res = (2.0 * q1) / 2.0;
+  compare_quaternions(q_res, q1);
+
+  CHECK(glm::quaternion::dot(q1,q2) ==  Approx(110.0));
+  CHECK(glm::quaternion::dot(q2,q3) ==  Approx(220.0));
+  CHECK(glm::quaternion::dot(q2,-q3) ==  Approx(-220.0));
+  CHECK(glm::quaternion::dot(-q2,-q3) ==  Approx(220.0));
+
+  double res = glm::quaternion::mix(0.0,1.0,0.0);
+  CHECK(res == Approx(0.0));
+
+  res = glm::quaternion::mix(0.0,1.0,0.25);
+  CHECK(res == Approx(Approx(0.25)));
+
+  res = glm::quaternion::mix(0.0,1.0,0.5);
+  CHECK(res == Approx(0.5));
+
+  res = glm::quaternion::mix(0.0,1.0,0.75);
+  CHECK(res == Approx(0.75));
+
+  res = glm::quaternion::mix(0.0,1.0,1.0);
+  CHECK(res == Approx(1.0));
+
+
+  res = glm::quaternion::mix(1.0,0.0,0.0);
+  CHECK(res == Approx(1.0));
+
+  res = glm::quaternion::mix(1.0,0.0,0.25);
+  CHECK(res == Approx(0.75));
+
+  res = glm::quaternion::mix(1.0,0.0,0.5);
+  CHECK(res == Approx(0.5));
+
+  res = glm::quaternion::mix(1.0,0.0,0.75);
+  CHECK(res == Approx(0.25));
+
+  res = glm::quaternion::mix(1.0,0.0,1.0);
+  CHECK(res == Approx(0.0));
+
+
+  res = glm::quaternion::mix(-3.0,1.0,0.0);
+  CHECK(res == Approx(-3.0));
+
+  res = glm::quaternion::mix(-3.0,1.0,0.25);
+  CHECK(res == Approx(-2.0));
+
+  res = glm::quaternion::mix(-3.0,1.0,0.5);
+  CHECK(res == Approx(-1.0));
+
+  res = glm::quaternion::mix(-3.0,1.0,0.75);
+  CHECK(res == Approx(0.0));
+
+  res = glm::quaternion::mix(-3.0,1.0,1.0);
+  CHECK(res == Approx(1.0));
+
+}
+
+TEST_CASE("glm quat slerp functions")
+{
+  {
+    // This shows that two equal rotation matrices average in the same rotation matrix
+    const std::array<std::array<double,3>,3> rot1 = {{{{0.36,0.48,-0.8}},{{-0.8,0.6,0}}, {{0.48,0.64, 0.6}}}}; //{{normalize({{1,2,3}}),normalize({{4,5,6}}),normalize({{7,8,9}})}};
+    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
+    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot1);
+
+    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
+
+    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
+
+    auto ea1 = Utilities::euler_angles_from_rotation_matrix(rot1);
+    auto ear = Utilities::euler_angles_from_rotation_matrix(result1);
+
+    compare_rotation_matrices_approx(result1, rot1);
+    compare_3d_arrays_approx(ea1,ear);
+  }
+
+  {
+    // This shows that a very small difference in the rotation matrix causes a very small difference in the resulting rotation matrix.
+    const std::array<std::array<double,3>,3> rot1 = {{{{0.360000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
+    const std::array<std::array<double,3>,3> rot2 = {{{{0.350000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
+    const std::array<std::array<double,3>,3> expt = {{{{0.358571,0.479818,-0.800533}},{{-0.800533,0.599107,0.000627009}}, {{0.479818,0.640802, 0.599107}}}};
+
+    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
+    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot2);
+
+    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
+
+    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
+
+    compare_rotation_matrices_approx(result1, expt);
+  }
+
+  {
+    // This shows that a small difference in the rotation matrix causes a small difference in the resulting rotation matrix.
+    const std::array<std::array<double,3>,3> rot1 = {{{{0.360000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
+    const std::array<std::array<double,3>,3> rot2 = {{{{0.300000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
+    const std::array<std::array<double,3>,3> expt = {{{{0.351289,0.478886,-0.803242}},{{-0.803242,0.594555,0.00382358}}, {{0.478886,0.644888, 0.594555}}}};
+
+    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
+    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot2);
+
+    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
+
+    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
+
+    compare_rotation_matrices_approx(result1, expt);
+  }
+
+  {
+    // This shows that a small difference in the rotation matrix causes a small difference in the resulting rotation matrix.
+    const std::array<std::array<double,3>,3> rot1 = {{{{0.360000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
+    const std::array<std::array<double,3>,3> rot2 = {{{{0.300000,0.450000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
+    const std::array<std::array<double,3>,3> expt = {{{{0.35767,0.472227,-0.802856}},{{-0.7972,0.6014,0.000000000}}, {{0.481714,0.642285, 0.593783}}}};
+
+    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
+    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot2);
+
+    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
+
+    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
+
+    compare_rotation_matrices_approx(result1, expt);
+  }
+
+  {
+    // This shows that a significant difference in the rotation matrix causes a significant difference in the resulting rotation matrix.
+    const std::array<std::array<double,3>,3> rot1 = {{{{0.360000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
+    const std::array<std::array<double,3>,3> rot2 = {{{{0.200000,0.250000,-0.400000}},{{-0.500000,0.200000,0.300000000}}, {{0.380000,0.840000, 0.500000}}}};
+    const std::array<std::array<double,3>,3> expt = {{{{0.493495,0.403007,-0.707894}},{{-0.70133,0.664351,-0.0720395}}, {{0.414325,0.578479, 0.656215}}}};
+
+    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
+    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot2);
+
+    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
+
+    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
+
+    compare_rotation_matrices_approx(result1, expt);
+  }
+}
\ No newline at end of file
diff --git a/contrib/world_builder/tests/unit_tests/unit_test_world_builder.cc.bak b/contrib/world_builder/tests/unit_tests/unit_test_world_builder.cc.bak
new file mode 100644
index 00000000000..c3fe430775a
--- /dev/null
+++ b/contrib/world_builder/tests/unit_tests/unit_test_world_builder.cc.bak
@@ -0,0 +1,7780 @@
+/*
+  Copyright (C) 2018 - 2021 by the authors of the World Builder code.
+
+  This file is part of the World Builder.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published
+   by the Free Software Foundation, either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
+
+#include "ApprovalTests/ApprovalTests.hpp"
+#include "doctest/doctest.h"
+
+#include "world_builder/config.h"
+#include "world_builder/consts.h"
+#include "world_builder/coordinate_system.h"
+#include "world_builder/coordinate_systems/cartesian.h"
+#include "world_builder/coordinate_systems/interface.h"
+#include "world_builder/coordinate_systems/invalid.h"
+#include "world_builder/features/continental_plate.h"
+#include "world_builder/features/interface.h"
+#include "world_builder/grains.h"
+#include "world_builder/objects/natural_coordinate.h"
+#include "world_builder/objects/segment.h"
+#include "world_builder/objects/surface.h"
+#include "world_builder/parameters.h"
+#include "world_builder/point.h"
+#include "world_builder/types/array.h"
+#include "world_builder/types/bool.h"
+#include "world_builder/types/double.h"
+#include "world_builder/types/interface.h"
+#include "world_builder/types/object.h"
+#include "world_builder/types/one_of.h"
+#include "world_builder/types/plugin_system.h"
+#include "world_builder/types/point.h"
+#include "world_builder/types/segment.h"
+#include "world_builder/types/string.h"
+#include "world_builder/types/unsigned_int.h"
+#include "world_builder/types/value_at_points.h"
+#include "world_builder/utilities.h"
+#include "world_builder/world.h"
+
+
+extern "C" {
+#include "world_builder/wrapper_c.h"
+}
+#include "world_builder/wrapper_cpp.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <iomanip>
+#include <iostream>
+#include <iterator>
+#include <map>
+#include <memory>
+#include <random>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace WorldBuilder
+{
+  namespace Features
+  {
+    namespace FaultModels
+    {
+      namespace Composition
+      {
+        class Interface;
+      }  // namespace Composition
+      namespace Grains
+      {
+        class Interface;
+      }  // namespace Grains
+      namespace Temperature
+      {
+        class Interface;
+      }  // namespace Temperature
+    }  // namespace FaultModels
+  }  // namespace Features
+}  // namespace WorldBuilder
+
+using namespace WorldBuilder;
+using doctest::Approx;
+using doctest::Contains;
+
+/**
+ * normalize 3d array
+ */
+inline
+std::array<double,3> normalize(std::array<double,3> array)
+{
+  const double norm = sqrt(array[0] * array[0] + array[1] * array[1] + array[2] * array[2]);
+  return {{array[0]/norm,array[1]/norm,array[2]/norm}};
+}
+
+/**
+ * Compare the given two std::vector<double> entries with an epsilon (using Catch::Approx)
+ */
+inline void compare_vectors_approx(
+  const std::vector<double> &computed,
+  const std::vector<double> &expected)
+{
+  CHECK(computed.size() == expected.size());
+  for (unsigned int i=0; i< computed.size(); ++i)
+    {
+      INFO("vector index i=" << i << ": ");
+      CHECK(computed[i] == Approx(expected[i]));
+    }
+}
+
+/**
+ * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
+ */
+inline void compare_3d_arrays_approx(
+  const std::array<double,3> &computed,
+  const std::array<double,3> &expected)
+{
+  CHECK(computed.size() == expected.size());
+  for (unsigned int i=0; i< computed.size(); ++i)
+    {
+      INFO("vector index i=" << i << ": ");
+      CHECK(computed[i] == Approx(expected[i]));
+    }
+}
+
+/**
+ * Compare the given two std::vector<std::array<std::array<double,3>,3> > entries with an epsilon (using Catch::Approx)
+ */
+inline void compare_vectors_array3_array3_approx(
+  const std::vector<std::array<std::array<double,3>,3> > &computed,
+  const std::vector<std::array<std::array<double,3>,3> > &expected)
+{
+  CHECK(computed.size() == expected.size());
+  for (unsigned int i=0; i< computed.size(); ++i)
+    {
+      CHECK(computed[i].size() == expected[i].size());
+      for (unsigned int j=0; j< computed[i].size(); ++j)
+        {
+          CHECK(computed[i][j].size() == expected[i][j].size());
+          for (unsigned int k=0; k< computed[i][j].size(); ++k)
+            {
+              INFO("vector index i:j:k = " << i << ':' << j << ':' << k << std::setprecision(10)
+                   << " = computed: " << computed[i][j][k] << ", expected: " <<  expected[i][j][k]
+                   << ", diff = " << computed[i][j][k] - expected[i][j][k] << ", eps = " << 1e-10);
+              CHECK(std::fabs(computed[i][j][k] - expected[i][j][k]) <= 1e-10);
+            }
+        }
+    }
+}
+
+/**
+ * Compare two rotation matrices
+ */
+inline void compare_rotation_matrices_approx(
+  const std::array<std::array<double,3>,3> &computed,
+  const std::array<std::array<double,3>,3> &expected)
+{
+  // sign of eigenvector is not important
+  INFO("rotation matrices are not the same: \n" <<
+       "expected = " << expected[0][0] << ' ' << expected[0][1] << ' ' << expected[0][2] << "\n" <<
+       "           " << expected[1][0] << ' ' << expected[1][1] << ' ' << expected[1][2] << "\n" <<
+       "           " << expected[2][0] << ' ' << expected[2][1] << ' ' << expected[2][2] << "\n" <<
+       "computed = " << computed[0][0] << ' ' << computed[0][1] << ' ' << computed[0][2] << "\n" <<
+       "           " << computed[1][0] << ' ' << computed[1][1] << ' ' << computed[1][2] << "\n" <<
+       "           " << computed[2][0] << ' ' << computed[2][1] << ' ' << computed[2][2] << "\n");
+  CHECK((
+          (computed[0][0] == Approx(expected[0][0]) && computed[0][1] == Approx(expected[0][1]) && computed[0][2] == Approx(expected[0][2]) &&
+           computed[1][0] == Approx(expected[1][0]) && computed[1][1] == Approx(expected[1][1]) && computed[1][2] == Approx(expected[1][2]) &&
+           computed[2][0] == Approx(expected[2][0]) && computed[2][1] == Approx(expected[2][1]) && computed[2][2] == Approx(expected[2][2]))
+          ||
+          (computed[0][0] == Approx(-expected[0][0]) && computed[0][1] == Approx(-expected[0][1]) && computed[0][2] == Approx(-expected[0][2]) &&
+           computed[1][0] == Approx(-expected[1][0]) && computed[1][1] == Approx(-expected[1][1]) && computed[1][2] == Approx(-expected[1][2]) &&
+           computed[2][0] == Approx(-expected[2][0]) && computed[2][1] == Approx(-expected[2][1]) && computed[2][2] == Approx(-expected[2][2]))));
+}
+
+
+TEST_CASE("WorldBuilder Point: Testing initialize and operators")
+{
+  std::vector<double> approval_tests;
+
+  // Test initialization of the Point class
+  Point<2> p2(cartesian);
+  Point<3> p3(cartesian);
+
+  CHECK(p2.get_array() == std::array<double,2> {{0,0}});
+  CHECK(p3.get_array() == std::array<double,3> {{0,0,0}});
+
+  const Point<2> p2_array(std::array<double,2> {{1,2}},cartesian);
+  const Point<3> p3_array(std::array<double,3> {{1,2,3}},cartesian);
+
+  CHECK(p2_array.get_array() == std::array<double,2> {{1,2}});
+  CHECK(p3_array.get_array() == std::array<double,3> {{1,2,3}});
+
+  const Point<2> &p2_point(p2_array);
+  const Point<3> &p3_point(p3_array);
+
+  CHECK(p2_point.get_array() == std::array<double,2> {{1,2}});
+  CHECK(p3_point.get_array() == std::array<double,3> {{1,2,3}});
+
+  const Point<2> p2_explicit(3,4,cartesian);
+  const Point<3> p3_explicit(4,5,6,cartesian);
+
+  CHECK(p2_explicit.get_array() == std::array<double,2> {{3,4}});
+  CHECK(p3_explicit.get_array() == std::array<double,3> {{4,5,6}});
+
+
+  // Test Point operators
+
+  // Test assign operator
+  p2 = p2_array;
+  p3 = p3_array;
+
+  CHECK(p2.get_array() == std::array<double,2> {{1,2}});
+  CHECK(p3.get_array() == std::array<double,3> {{1,2,3}});
+
+  // Test multiply operator
+  p2 = 2 * p2 * 1.0;
+  p3 = 2 * p3 * 1.0;
+
+  CHECK(p2.get_array() == std::array<double,2> {{2,4}});
+  CHECK(p3.get_array() == std::array<double,3> {{2,4,6}});
+
+  p2 *= 2;
+  p3 *= 2;
+
+  CHECK(p2.get_array() == std::array<double,2> {{4,8}});
+  CHECK(p3.get_array() == std::array<double,3> {{4,8,12}});
+
+  // Test dot operator
+  approval_tests.emplace_back(p2_array * p2_explicit);
+  approval_tests.emplace_back(p3_array * p3_explicit);
+
+  // Test add operator
+  p2 = p2 + p2;
+  p3 = p3 + p3;
+
+  CHECK(p2.get_array() == std::array<double,2> {{8,16}});
+  CHECK(p3.get_array() == std::array<double,3> {{8,16,24}});
+
+  p2 += p2;
+  p3 += p3;
+
+  CHECK(p2.get_array() == std::array<double,2> {{16,32}});
+  CHECK(p3.get_array() == std::array<double,3> {{16,32,48}});
+
+  // Test subtract operator
+  p2 = p2 - (0.5 * p2);
+  p3 = p3 - (0.5 * p3);
+
+  CHECK(p2.get_array() == std::array<double,2> {{8,16}});
+  CHECK(p3.get_array() == std::array<double,3> {{8,16,24}});
+
+  p2 -=  (0.5 * p2);
+  p3 -=  (0.5 * p3);
+
+  CHECK(p2.get_array() == std::array<double,2> {{4,8}});
+  CHECK(p3.get_array() == std::array<double,3> {{4,8,12}});
+
+  // Test coordinate system
+  //approval_tests.emplace_back(p2.get_coordinate_system());
+  //approval_tests.emplace_back(p3.get_coordinate_system());
+
+  // Test norm and norm_square
+  approval_tests.emplace_back(p2.norm_square());
+  approval_tests.emplace_back(p3.norm_square());
+
+  approval_tests.emplace_back(p2.norm());
+  approval_tests.emplace_back(p3.norm());
+
+  // Test Point utility classes
+  const std::array<double,2> an2 = Utilities::convert_point_to_array(p2_point);
+  const std::array<double,3> an3 = Utilities::convert_point_to_array(p3_point);
+
+  CHECK(an2 == std::array<double,2> {{1,2}});
+  CHECK(an3 == std::array<double,3> {{1,2,3}});
+
+  CHECK_THROWS_WITH(Point<2>(1,2,3,cartesian),Contains("Can't use the 3d constructor in 2d."));
+  CHECK_THROWS_WITH(Point<3>(1,2,cartesian),Contains("Can't use the 2d constructor in 3d."));
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+
+TEST_CASE("WorldBuilder Utilities: string to conversions")
+{
+  // Test string to number conversion
+  CHECK(Utilities::string_to_double("1") == Approx(1.0));
+  CHECK(Utilities::string_to_double(" 1 ") == Approx(1.0));
+  CHECK(Utilities::string_to_double(" 1.01 ") == Approx(1.01));
+
+  CHECK_THROWS_WITH(Utilities::string_to_double("1a"),
+                    Contains("Could not convert \"1a\" to a double."));
+  CHECK_THROWS_WITH(Utilities::string_to_double("a1"),
+                    Contains("Could not convert \"a1\" to a double."));
+  CHECK_THROWS_WITH(Utilities::string_to_double("a"),
+                    Contains("Could not convert \"a\" to a double."));
+
+  CHECK(Utilities::string_to_int("2") == Approx(2.0));
+  CHECK(Utilities::string_to_int(" 2 ") == Approx(2.0));
+
+  CHECK_THROWS_WITH(Utilities::string_to_int(" 2.02 "),
+                    Contains("Could not convert \"2.02\" to an int."));
+  CHECK_THROWS_WITH(Utilities::string_to_int("2b"),
+                    Contains("Could not convert \"2b\" to an int."));
+  CHECK_THROWS_WITH(Utilities::string_to_int("b2"),
+                    Contains("Could not convert \"b2\" to an int."));
+  CHECK_THROWS_WITH(Utilities::string_to_int("b"),
+                    Contains("Could not convert \"b\" to an int."));
+
+  CHECK(Utilities::string_to_unsigned_int("3") == Approx(3.0));
+  CHECK(Utilities::string_to_unsigned_int(" 3 ") == Approx(3.0));
+
+  CHECK_THROWS_WITH(Utilities::string_to_unsigned_int(" 3.03 "),
+                    Contains("Could not convert \"3.03\" to an unsigned int."));
+  CHECK_THROWS_WITH(Utilities::string_to_unsigned_int("3c"),
+                    Contains("Could not convert \"3c\" to an unsigned int."));
+  CHECK_THROWS_WITH(Utilities::string_to_unsigned_int("c3"),
+                    Contains("Could not convert \"c3\" to an unsigned int."));
+  CHECK_THROWS_WITH(Utilities::string_to_unsigned_int("c"),
+                    Contains("Could not convert \"c\" to an unsigned int."));
+
+  // Test point to array conversion
+  const Point<2> p2(1,2,cartesian);
+  const Point<3> p3(1,2,3,cartesian);
+
+  CHECK(Utilities::convert_point_to_array(p2) == std::array<double,2> {{1,2}});
+  CHECK(Utilities::convert_point_to_array(p3) == std::array<double,3> {{1,2,3}});
+
+  // Test coordinate system
+  CHECK(Utilities::string_to_coordinate_system("cartesian") == CoordinateSystem::cartesian);
+  CHECK(Utilities::string_to_coordinate_system("spherical") == CoordinateSystem::spherical);
+  CHECK_THROWS_WITH(Utilities::string_to_coordinate_system("other"), Contains("Coordinate system not implemented."));
+}
+
+
+TEST_CASE("WorldBuilder Utilities: interpolation")
+{
+  std::vector<double> approval_tests;
+
+  std::vector<double> x = {{0,1,2,3}};
+  std::vector<double> y = {{10,5,5,35}};
+
+  Utilities::interpolation monotone_cubic_spline;
+  monotone_cubic_spline.set_points(y);
+
+  approval_tests.emplace_back(monotone_cubic_spline(-1));
+  approval_tests.emplace_back(monotone_cubic_spline(-0.9));
+  approval_tests.emplace_back(monotone_cubic_spline(-0.7));
+  approval_tests.emplace_back(monotone_cubic_spline(-0.5));
+  approval_tests.emplace_back(monotone_cubic_spline(-0.3));
+  approval_tests.emplace_back(monotone_cubic_spline(-0.1));
+  approval_tests.emplace_back(monotone_cubic_spline(0));
+  approval_tests.emplace_back(monotone_cubic_spline(0.1));
+  approval_tests.emplace_back(monotone_cubic_spline(0.3));
+  approval_tests.emplace_back(monotone_cubic_spline(0.5));
+  approval_tests.emplace_back(monotone_cubic_spline(0.7));
+  approval_tests.emplace_back(monotone_cubic_spline(0.9));
+  approval_tests.emplace_back(monotone_cubic_spline(1));
+  approval_tests.emplace_back(monotone_cubic_spline(1.1));
+  approval_tests.emplace_back(monotone_cubic_spline(1.3));
+  approval_tests.emplace_back(monotone_cubic_spline(1.5));
+  approval_tests.emplace_back(monotone_cubic_spline(1.7));
+  approval_tests.emplace_back(monotone_cubic_spline(1.9));
+  approval_tests.emplace_back(monotone_cubic_spline(2));
+  approval_tests.emplace_back(monotone_cubic_spline(2.025));
+  approval_tests.emplace_back(monotone_cubic_spline(2.075));
+  approval_tests.emplace_back(monotone_cubic_spline(2.125));
+  approval_tests.emplace_back(monotone_cubic_spline(2.175));
+  approval_tests.emplace_back(monotone_cubic_spline(2.225));
+  approval_tests.emplace_back(monotone_cubic_spline(2.25));
+  approval_tests.emplace_back(monotone_cubic_spline(2.275));
+  approval_tests.emplace_back(monotone_cubic_spline(2.325));
+  approval_tests.emplace_back(monotone_cubic_spline(2.375));
+  approval_tests.emplace_back(monotone_cubic_spline(2.425));
+  approval_tests.emplace_back(monotone_cubic_spline(2.475));
+  approval_tests.emplace_back(monotone_cubic_spline(2.5));
+  approval_tests.emplace_back(monotone_cubic_spline(2.625));
+  approval_tests.emplace_back(monotone_cubic_spline(2.75));
+  approval_tests.emplace_back(monotone_cubic_spline(2.875));
+  approval_tests.emplace_back(monotone_cubic_spline(3));
+  approval_tests.emplace_back(monotone_cubic_spline(3.125));
+  approval_tests.emplace_back(monotone_cubic_spline(3.25));
+
+  Utilities::interpolation monotone_cubic_spline2;
+  y[1] = -5;
+  y[3] = -35;
+  monotone_cubic_spline2.set_points(y);
+  approval_tests.emplace_back(monotone_cubic_spline2(-1));
+  approval_tests.emplace_back(monotone_cubic_spline2(-0.5));
+  approval_tests.emplace_back(monotone_cubic_spline2(0));
+  approval_tests.emplace_back(monotone_cubic_spline2(0.5));
+  approval_tests.emplace_back(monotone_cubic_spline2(1));
+  approval_tests.emplace_back(monotone_cubic_spline2(1.5));
+  approval_tests.emplace_back(monotone_cubic_spline2(2));
+  approval_tests.emplace_back(monotone_cubic_spline2(2.125) == Approx(3.828125));
+  approval_tests.emplace_back(monotone_cubic_spline2(2.25));
+  approval_tests.emplace_back(monotone_cubic_spline2(2.375) == Approx(-4.140625));
+  approval_tests.emplace_back(monotone_cubic_spline2(2.5));
+  approval_tests.emplace_back(monotone_cubic_spline2(2.625));
+  approval_tests.emplace_back(monotone_cubic_spline2(2.75));
+  approval_tests.emplace_back(monotone_cubic_spline2(2.875));
+  approval_tests.emplace_back(monotone_cubic_spline2(3));
+  approval_tests.emplace_back(monotone_cubic_spline2(3.125));
+  approval_tests.emplace_back(monotone_cubic_spline2(3.25));
+
+  Utilities::interpolation monotone_cubic_spline3;
+  y[0] = 10;
+  y[1] = -5;
+  y[2] = -10;
+  y[3] = -35;
+  monotone_cubic_spline3.set_points(y);
+  approval_tests.emplace_back(monotone_cubic_spline3(-1));
+  approval_tests.emplace_back(monotone_cubic_spline3(-0.5));
+  approval_tests.emplace_back(monotone_cubic_spline3(0));
+  approval_tests.emplace_back(monotone_cubic_spline3(0.5));
+  approval_tests.emplace_back(monotone_cubic_spline3(1));
+  approval_tests.emplace_back(monotone_cubic_spline3(1.5));
+  approval_tests.emplace_back(monotone_cubic_spline3(2));
+  approval_tests.emplace_back(monotone_cubic_spline3(2.125));
+  approval_tests.emplace_back(monotone_cubic_spline3(2.25) == Approx(-13.90625));
+  approval_tests.emplace_back(monotone_cubic_spline3(2.375));
+  approval_tests.emplace_back(monotone_cubic_spline3(2.5));
+  approval_tests.emplace_back(monotone_cubic_spline3(2.625));
+  approval_tests.emplace_back(monotone_cubic_spline3(2.75));
+  approval_tests.emplace_back(monotone_cubic_spline3(2.875));
+  approval_tests.emplace_back(monotone_cubic_spline3(3));
+  approval_tests.emplace_back(monotone_cubic_spline3(3.125));
+  approval_tests.emplace_back(monotone_cubic_spline3(3.25));
+
+  // bi monotone cubic spline
+  Utilities::interpolation monotone_cubic_spline_x;
+  Utilities::interpolation monotone_cubic_spline_y;
+  x[0] = 0;
+  x[1] = 1;
+  x[2] = 2;
+  x[3] = 3;
+  y[0] = 10;
+  y[1] = 10;
+  y[2] = 5;
+  y[3] = 0;
+  monotone_cubic_spline_x.set_points(y);
+  y[0] = 0;
+  y[1] = 5;
+  y[2] = 10;
+  y[3] = 10;
+  monotone_cubic_spline_y.set_points(y);
+
+  approval_tests.emplace_back(monotone_cubic_spline_x(0));
+  approval_tests.emplace_back(monotone_cubic_spline_x(0.25));
+  approval_tests.emplace_back(monotone_cubic_spline_x(0.5));
+  approval_tests.emplace_back(monotone_cubic_spline_x(0.75));
+  approval_tests.emplace_back(monotone_cubic_spline_x(1));
+  approval_tests.emplace_back(monotone_cubic_spline_x(1.25) == Approx(9.453125));
+  approval_tests.emplace_back(monotone_cubic_spline_x(1.5));
+  approval_tests.emplace_back(monotone_cubic_spline_x(1.75));
+  approval_tests.emplace_back(monotone_cubic_spline_x(2));
+  approval_tests.emplace_back(monotone_cubic_spline_x(2.25));
+  approval_tests.emplace_back(monotone_cubic_spline_x(2.5));
+  approval_tests.emplace_back(monotone_cubic_spline_x(2.75));
+  approval_tests.emplace_back(monotone_cubic_spline_x(3));
+
+  approval_tests.emplace_back(monotone_cubic_spline_y(0));
+  approval_tests.emplace_back(monotone_cubic_spline_y(0.25));
+  approval_tests.emplace_back(monotone_cubic_spline_y(0.5));
+  approval_tests.emplace_back(monotone_cubic_spline_y(0.75) == Approx(3.515625));
+  approval_tests.emplace_back(monotone_cubic_spline_y(1));
+  approval_tests.emplace_back(monotone_cubic_spline_y(1.25));
+  approval_tests.emplace_back(monotone_cubic_spline_y(1.5));
+  approval_tests.emplace_back(monotone_cubic_spline_y(1.75) == Approx(9.453125));
+  approval_tests.emplace_back(monotone_cubic_spline_y(2));
+  approval_tests.emplace_back(monotone_cubic_spline_y(2.25));
+  approval_tests.emplace_back(monotone_cubic_spline_y(2.5));
+  approval_tests.emplace_back(monotone_cubic_spline_y(2.75));
+  approval_tests.emplace_back(monotone_cubic_spline_y(3));
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder Utilities: Point in polygon")
+{
+  std::vector<Point<2> > point_list_4_elements(4, Point<2>(cartesian));
+  point_list_4_elements[0] = Point<2>(0,0,cartesian);
+  point_list_4_elements[1] = Point<2>(5,0,cartesian);
+  point_list_4_elements[2] = Point<2>(5,5,cartesian);
+  point_list_4_elements[3] = Point<2>(0,5,cartesian);
+
+  std::vector<Point<2> > point_list_3_elements(3, Point<2>(cartesian));
+  point_list_3_elements[0] = Point<2>(10,10,cartesian);
+  point_list_3_elements[1] = Point<2>(10,15,cartesian);
+  point_list_3_elements[2] = Point<2>(15,15,cartesian);
+
+  std::vector<Point<2> > check_points(9, Point<2>(cartesian));
+  check_points[0] = Point<2>(-1,-1,cartesian);
+  check_points[1] = Point<2>(0,0,cartesian);
+  check_points[2] = Point<2>(0,5,cartesian);
+  check_points[3] = Point<2>(5,0,cartesian);
+  check_points[4] = Point<2>(5,5,cartesian);
+  check_points[5] = Point<2>(5,5.01,cartesian);
+  check_points[6] = Point<2>(1,1,cartesian);
+  check_points[7] = Point<2>(12.5,12,cartesian);
+  check_points[8] = Point<2>(11.5,12,cartesian);
+
+  std::vector<std::array<bool,2> > answers(9);
+  answers[0] = {{false,false}};
+  answers[1] = {{true,false}};
+  answers[2] = {{true,false}};
+  answers[3] = {{true,false}};
+  answers[4] = {{true,false}};
+  answers[5] = {{false,false}};
+  answers[6] = {{true,false}};
+  answers[7] = {{false,false}};
+  answers[8] = {{false,true}};
+
+  std::vector<std::array<double,2> > answers_signed_distance(9);
+  answers_signed_distance[0] = {{-std::sqrt(2), -std::sqrt(11 * 11 + 11 * 11)}};
+  answers_signed_distance[1] = {{0,-std::sqrt(10 * 10 + 10 * 10)}};
+  answers_signed_distance[2] = {{0,-std::sqrt(125)}};
+  answers_signed_distance[3] = {{0,-std::sqrt(125)}};
+  answers_signed_distance[4] = {{0,-std::sqrt(50)}};
+  answers_signed_distance[5] = {{-std::sqrt(0.01 * 0.01),-std::sqrt(5 * 5 + 4.99 * 4.99)}};
+  answers_signed_distance[6] = {{1,-std::sqrt(9 * 9 + 9 * 9)}};
+  answers_signed_distance[7] = {{-10.2591422643,-0.3535533906}};
+  answers_signed_distance[8] = {{-9.5524865873,0.3535533906}};
+
+  for (unsigned int i = 0; i < check_points.size(); ++i)
+    {
+      INFO("checking point " << i << " = (" << check_points[i][0] << ':' << check_points[i][1] << ')');
+      CHECK(Utilities::polygon_contains_point(point_list_4_elements,check_points[i]) == answers[i][0]);
+      CHECK(Utilities::polygon_contains_point(point_list_3_elements,check_points[i]) == answers[i][1]);
+      CHECK(Utilities::signed_distance_to_polygon(point_list_4_elements,check_points[i]) == Approx(answers_signed_distance[i][0]));
+      CHECK(Utilities::signed_distance_to_polygon(point_list_3_elements,check_points[i]) == Approx(answers_signed_distance[i][1]));
+    }
+
+  const std::vector<Point<2> > point_list_2_elements(2, Point<2>(cartesian));
+  CHECK_THROWS_WITH(Utilities::signed_distance_to_polygon(point_list_2_elements,check_points[0]),
+                    Contains("Not enough polygon points were specified."));
+
+  const std::vector<Point<2> > point_list_1_elements(1, Point<2>(cartesian));
+  CHECK_THROWS_WITH(Utilities::signed_distance_to_polygon(point_list_1_elements,check_points[0]),
+                    Contains("Not enough polygon points were specified."));
+
+  const std::vector<Point<2> > point_list_0_elements(0, Point<2>(cartesian));
+  CHECK_THROWS_WITH(Utilities::signed_distance_to_polygon(point_list_0_elements,check_points[0]),
+                    Contains("Not enough polygon points were specified."));
+}
+
+
+TEST_CASE("WorldBuilder Utilities: Natural Coordinate")
+{
+  std::vector<double> approval_tests;
+
+  // Cartesian
+  const std::unique_ptr<CoordinateSystems::Interface> cartesian(CoordinateSystems::Interface::create("cartesian",nullptr));
+
+  // Test the natural coordinate system
+  const Objects::NaturalCoordinate nca1(std::array<double,3> {{1,2,3}},*cartesian);
+  CHECK(nca1.get_coordinates() == std::array<double,3> {{1,2,3}});
+  CHECK(nca1.get_surface_coordinates() == std::array<double,2> {{1,2}});
+  approval_tests.emplace_back(nca1.get_depth_coordinate());
+
+  const Objects::NaturalCoordinate ncp1(Point<3>(1,2,3,CoordinateSystem::cartesian),*cartesian);
+  CHECK(ncp1.get_coordinates() == std::array<double,3> {{1,2,3}});
+  CHECK(ncp1.get_surface_coordinates() == std::array<double,2> {{1,2}});
+  approval_tests.emplace_back(ncp1.get_depth_coordinate());
+
+
+  const std::unique_ptr<CoordinateSystems::Interface> spherical(CoordinateSystems::Interface::create("spherical",nullptr));
+
+  // Test the natural coordinate system
+  const Objects::NaturalCoordinate nsa1(std::array<double,3> {{1,2,3}},*spherical);
+  std::array<double,3> nsa1_array = nsa1.get_coordinates();
+  approval_tests.emplace_back(nsa1_array[0]);
+  approval_tests.emplace_back(nsa1_array[1]);
+  approval_tests.emplace_back(nsa1_array[2]);
+  std::array<double,2> nsa1_surface_array = nsa1.get_surface_coordinates();
+  approval_tests.emplace_back(nsa1_surface_array[0]);
+  approval_tests.emplace_back(nsa1_surface_array[1]);
+  approval_tests.emplace_back(nsa1.get_depth_coordinate());
+
+
+  const Objects::NaturalCoordinate nsp1(Point<3>(1,2,3,CoordinateSystem::spherical),*spherical);
+  std::array<double,3> nsp1_array = nsp1.get_coordinates();
+  approval_tests.emplace_back(nsp1_array[0]);
+  approval_tests.emplace_back(nsp1_array[1]);
+  approval_tests.emplace_back(nsp1_array[2]);
+  std::array<double,2> nsp1_surface_array = nsp1.get_surface_coordinates();
+  approval_tests.emplace_back(nsp1_surface_array[0]);
+  approval_tests.emplace_back(nsp1_surface_array[1]);
+  approval_tests.emplace_back(nsp1.get_depth_coordinate());
+
+  // Invalid tests
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian.wb";
+  WorldBuilder::World world(file_name);
+  Parameters prm(world);
+  std::unique_ptr<CoordinateSystems::Interface> invalid(new CoordinateSystems::Invalid(nullptr));
+  invalid->parse_entries(prm);
+  Objects::NaturalCoordinate ivp1(Point<3>(1,2,3,CoordinateSystem::invalid),*invalid);
+  std::array<double,3> ivp1_array = ivp1.get_coordinates();
+  CHECK(std::isnan(ivp1_array[0]));
+  CHECK(std::isnan(ivp1_array[1]));
+  CHECK(std::isnan(ivp1_array[2]));
+  CHECK_THROWS_WITH(ivp1.get_surface_coordinates(),Contains("Coordinate system not implemented."));
+  CHECK_THROWS_WITH(ivp1.get_surface_point(),Contains("Coordinate system not implemented."));
+  CHECK_THROWS_WITH(ivp1.get_depth_coordinate(),Contains("Coordinate system not implemented."));
+  CHECK_THROWS_WITH(ivp1.get_depth_coordinate(),Contains("Coordinate system not implemented."));
+  CHECK_THROWS_WITH(ivp1.get_ref_depth_coordinate(),Contains("Coordinate system not implemented."));
+  CHECK(std::isnan(invalid->distance_between_points_at_same_depth(Point<3>(1,2,3,CoordinateSystem::invalid),
+                                                                  Point<3>(1,2,3,CoordinateSystem::invalid))));
+  approval_tests.emplace_back(invalid->depth_method());
+
+  std::array<double,3> iv_array = invalid->natural_to_cartesian_coordinates({{1,2,3}});
+  CHECK(std::isnan(iv_array[0]));
+  CHECK(std::isnan(iv_array[1]));
+  CHECK(std::isnan(iv_array[2]));
+
+  CHECK(std::isnan(invalid->max_model_depth()));
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder Utilities: Coordinate systems transformations")
+{
+  std::vector<double> approval_tests;
+
+  // Test coordinate system transformation
+  {
+    const Point<3> cartesian(3,4,5,CoordinateSystem::cartesian);
+
+    const Point<3> spherical(Utilities::cartesian_to_spherical_coordinates(Point<3>(cartesian.get_array(),CoordinateSystem::cartesian)), CoordinateSystem::spherical);
+
+    compare_vectors_approx(std::vector<double>(std::begin(spherical.get_array()), std::end(spherical.get_array())),
+    std::vector<double> {{std::sqrt(3*3+4*4+5*5),0.927295218001613,0.7853982}});
+
+    const Point<3> cartesian_back(Utilities::spherical_to_cartesian_coordinates(spherical.get_array()), CoordinateSystem::cartesian);
+
+    compare_vectors_approx(std::vector<double>(std::begin(cartesian_back.get_array()), std::end(cartesian_back.get_array())),
+    std::vector<double> {{3,4,5}});
+  }
+
+  {
+    const Point<3> cartesian(-2,-1,6,CoordinateSystem::cartesian);
+
+    const Point<3> spherical(Utilities::cartesian_to_spherical_coordinates(Point<3>(cartesian.get_array(),CoordinateSystem::cartesian)), CoordinateSystem::spherical);
+
+    compare_vectors_approx(std::vector<double>(std::begin(spherical.get_array()), std::end(spherical.get_array())),
+    std::vector<double> {{std::sqrt(2*2+1*1+6*6),-2.6779450446,1.2140629383}});
+
+    const Point<3> cartesian_back(Utilities::spherical_to_cartesian_coordinates(spherical.get_array()), CoordinateSystem::cartesian);
+
+    approval_tests.insert(approval_tests.end(), std::begin(cartesian_back.get_array()), std::end(cartesian_back.get_array()));
+  }
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+
+}
+
+TEST_CASE("WorldBuilder Utilities: cross product")
+{
+  const std::vector<double> approval_tests;
+
+  const Point<3> unit_x(1,0,0,cartesian);
+  const Point<3> unit_y(0,1,0,cartesian);
+  const Point<3> unit_z(0,0,1,cartesian);
+
+  compare_3d_arrays_approx(Utilities::cross_product(unit_x, unit_x).get_array(), std::array<double,3> {{0,0,0}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_x, unit_y).get_array(), std::array<double,3> {{0,0,1}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_x, unit_z).get_array(), std::array<double,3> {{0,-1,0}});
+
+  compare_3d_arrays_approx(Utilities::cross_product(unit_y, unit_x).get_array(), std::array<double,3> {{0,0,-1}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_y, unit_y).get_array(), std::array<double,3> {{0,0,0}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_y, unit_z).get_array(), std::array<double,3> {{1,0,0}});
+
+  compare_3d_arrays_approx(Utilities::cross_product(unit_z, unit_x).get_array(), std::array<double,3> {{0,1,0}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_z, unit_y).get_array(), std::array<double,3> {{-1,0,0}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_z, unit_z).get_array(), std::array<double,3> {{0,0,0}});
+
+
+  const double sqrt2 = sqrt(0.5);
+  const Point<3> sqrt2_x(sqrt2,0,0,cartesian);
+  const Point<3> sqrt2_y(0,sqrt2,0,cartesian);
+  const Point<3> sqrt2_z(0,0,sqrt2,cartesian);
+
+  const Point<3> unit_xy(sqrt2,sqrt2,0,cartesian);
+  const Point<3> unit_xz(sqrt2,0,sqrt2,cartesian);
+  const Point<3> unit_yz(0,sqrt2,sqrt2,cartesian);
+
+  compare_3d_arrays_approx(Utilities::cross_product(unit_xy, sqrt2_x).get_array(), std::array<double,3> {{0,0,-0.5}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_xy, sqrt2_y).get_array(), std::array<double,3> {{0,0,0.5}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_xy, sqrt2_z).get_array(), std::array<double,3> {{0.5,-0.5,0}});
+
+  compare_3d_arrays_approx(Utilities::cross_product(unit_xz, sqrt2_x).get_array(), std::array<double,3> {{0,0.5,0}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_xz, sqrt2_y).get_array(), std::array<double,3> {{-0.5,0,0.5}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_xz, sqrt2_z).get_array(), std::array<double,3> {{0,-0.5,0}});
+
+  compare_3d_arrays_approx(Utilities::cross_product(unit_yz, sqrt2_x).get_array(), std::array<double,3> {{0,0.5,-0.5}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_yz, sqrt2_y).get_array(), std::array<double,3> {{-0.5,0,0}});
+  compare_3d_arrays_approx(Utilities::cross_product(unit_yz, sqrt2_z).get_array(), std::array<double,3> {{0.5,0,0}});
+
+  const Point<3> point1(2,3,4,cartesian);
+  const Point<3> point2(5,6,7,cartesian);
+
+  compare_3d_arrays_approx(Utilities::cross_product(point1, point2).get_array(), std::array<double,3> {{-3,6,-3}});
+  compare_3d_arrays_approx(Utilities::cross_product(point2, point1).get_array(), std::array<double,3> {{3,-6,3}});
+}
+
+TEST_CASE("WorldBuilder C wrapper")
+{
+  std::vector<double> approval_tests;
+
+  // First test a world builder file with a cross section defined
+  std::string file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb1.json";
+  void *ptr_world = nullptr;
+  void **ptr_ptr_world = &ptr_world;
+  const char *world_builder_file = file.c_str();
+  bool has_output_dir = false;
+
+  create_world(ptr_ptr_world, world_builder_file, &has_output_dir, "", 1);
+
+  double temperature = 0.;
+
+  temperature_2d(*ptr_ptr_world, 1, 2, 0, &temperature);
+  approval_tests.emplace_back(temperature);
+  temperature_3d(*ptr_ptr_world, 1, 2, 3, 0, &temperature);
+  approval_tests.emplace_back(temperature);
+  temperature_2d(*ptr_ptr_world, 550e3, 0, 0, &temperature);
+  approval_tests.emplace_back(temperature);
+  temperature_3d(*ptr_ptr_world, 120e3, 500e3, 0, 0, &temperature);
+  approval_tests.emplace_back(temperature);
+
+  // Test the compositions
+  double composition = 0.0;
+
+  composition_2d(*ptr_ptr_world, 1, 2, 0, 2, &composition);
+  approval_tests.emplace_back(composition);
+  composition_3d(*ptr_ptr_world, 1, 2, 3, 0, 2, &composition);
+  approval_tests.emplace_back(composition);
+  composition_2d(*ptr_ptr_world,  550e3, 0, 0, 3, &composition);
+  approval_tests.emplace_back(composition);
+  composition_3d(*ptr_ptr_world, 120e3, 500e3, 0, 0, 3, &composition);
+  approval_tests.emplace_back(composition);
+
+  release_world(*ptr_ptr_world);
+
+  // Now test a world builder file without a cross section defined
+  file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb2.json";
+  ptr_world = nullptr;
+  ptr_ptr_world = &ptr_world;
+  const char *world_builder_file2 = file.c_str();
+  has_output_dir = false;
+
+  create_world(ptr_ptr_world, world_builder_file2, &has_output_dir, "", 1);
+
+
+  CHECK_THROWS_WITH(temperature_2d(*ptr_ptr_world, 1, 2, 0, &temperature),
+                    Contains("This function can only be called when the cross section "
+                             "variable in the world builder file has been set. Dim is 3."));
+  temperature_3d(*ptr_ptr_world, 1, 2, 3, 0, &temperature);
+  approval_tests.emplace_back(temperature);
+  temperature_3d(*ptr_ptr_world, 120e3, 500e3, 0, 0, &temperature);
+  approval_tests.emplace_back(temperature);
+
+  // Test the compositions
+  CHECK_THROWS_WITH(composition_2d(*ptr_ptr_world, 1, 2, 0, 2, &composition),
+                    Contains("This function can only be called when the cross section "
+                             "variable in the world builder file has been set. Dim is 3."));
+
+  composition_3d(*ptr_ptr_world, 1, 2, 3, 0, 2, &composition);
+  approval_tests.emplace_back(composition);
+  composition_3d(*ptr_ptr_world, 120e3, 500e3, 0, 0, 3, &composition);
+  approval_tests.emplace_back(composition);
+
+  release_world(*ptr_ptr_world);
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder CPP wrapper")
+{
+  std::vector<double> approval_tests;
+
+  // First test a world builder file with a cross section defined
+  std::string file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb1.json";
+
+  wrapper_cpp::WorldBuilderWrapper world(file);
+
+  double temperature = 0;
+
+  temperature = world.temperature_2d(1, 2, 0);
+  approval_tests.emplace_back(temperature);
+  temperature = world.temperature_3d(1, 2, 3, 0);
+  approval_tests.emplace_back(temperature);
+  temperature = world.temperature_2d(550e3, 0, 0);
+  approval_tests.emplace_back(temperature);
+  temperature = world.temperature_3d(120e3, 500e3, 0, 0);
+  approval_tests.emplace_back(temperature);
+
+  // Test the compositions
+  double composition = 0.0;
+
+  composition = world.composition_2d(1, 2, 0, 2);
+  approval_tests.emplace_back(composition);
+  composition = world.composition_3d(1, 2, 3, 0, 2);
+  approval_tests.emplace_back(composition);
+  composition = world.composition_2d(550e3, 0, 0, 3);
+  approval_tests.emplace_back(composition);
+  composition = world.composition_3d(120e3, 500e3, 0, 0, 3);
+  approval_tests.emplace_back(composition);
+
+
+  // Now test a world builder file without a cross section defined
+  file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb2.json";
+
+  wrapper_cpp::WorldBuilderWrapper world2(file);
+
+
+  CHECK_THROWS_WITH(world2.temperature_2d(1, 2, 0),
+                    Contains("This function can only be called when the cross section "
+                             "variable in the world builder file has been set. Dim is 3."));
+  temperature = world2.temperature_3d(1, 2, 3, 0);
+  approval_tests.emplace_back(temperature);
+  temperature = world2.temperature_3d(120e3, 500e3, 0, 0);
+  approval_tests.emplace_back(temperature);
+
+  // Test the compositions
+  CHECK_THROWS_WITH(world2.composition_2d(1, 2, 0, 2),
+                    Contains("This function can only be called when the cross section "
+                             "variable in the world builder file has been set. Dim is 3."));
+
+  composition = world2.composition_3d(1, 2, 3, 0, 2);
+  approval_tests.emplace_back(composition);
+  composition = world2.composition_3d(120e3, 500e3, 0, 0, 3);
+  approval_tests.emplace_back(composition);
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder interface")
+{
+
+  std::vector<grains> approval_tests_grains;
+  const std::string file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/continental_plate.wb";
+  const WorldBuilder::World world(file);
+
+  CHECK_THROWS_WITH(world.properties({{1,2,3}},1., {{{{0,0,0}}}}),Contains("Unimplemented property provided. Only "));
+  CHECK_THROWS_WITH(world.properties({{1,2,3}},1., {{{{5,0,0}}}}),Contains("Unimplemented property provided. Only "));
+
+  approval_tests_grains.emplace_back(world.grains(std::array<double,3> {{750e3,250e3,100e3}},10e3,0,3));
+  approval_tests_grains.emplace_back(world.grains(std::array<double,2> {{750e3,100e3}},10e3,0,3));
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests_grains);
+}
+
+TEST_CASE("Worldbuilder grains")
+{
+  // creat a grains object
+  const WorldBuilder::grains grains;
+
+  CHECK(grains.sizes.size() == 0);
+  CHECK(grains.rotation_matrices.size() == 0);
+}
+
+TEST_CASE("WorldBuilder World random")
+{
+  std::vector<double> approval_tests;
+
+  // The world builder uses a deterministic random number generator. This is on prorpose
+  // because even though you might want to use random numbers, the result should be
+  // reproducible. Note that when the world builder is used in for example MPI programs
+  // you should supply the world builder created each MPI process a different seed. You
+  // can use the MPI RANK for this (seed is seed + MPI_RANK). Because the generator is
+  // deterministic (known and documented algorithm), we can test the results and they
+  // should be the same even for different compilers and machines.
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_spherical.wb";
+  WorldBuilder::World world1(file_name, false, "", 1);
+  // same result as https://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine/seed
+  approval_tests.emplace_back(world1.get_random_number_engine()());
+  approval_tests.emplace_back(world1.get_random_number_engine()());
+  std::uniform_real_distribution<> dist(1.0,2.0);
+  approval_tests.emplace_back(dist(world1.get_random_number_engine()));
+  approval_tests.emplace_back(dist(world1.get_random_number_engine()));
+
+  // test whether the seed indeed changes the resuls
+  WorldBuilder::World world2(file_name, false, "", 2);
+  approval_tests.emplace_back(world2.get_random_number_engine()());
+  approval_tests.emplace_back(world2.get_random_number_engine()());
+  approval_tests.emplace_back(dist(world2.get_random_number_engine()));
+  approval_tests.emplace_back(dist(world2.get_random_number_engine()));
+
+  // Test reproducibility with the same seed.
+  WorldBuilder::World world3(file_name, false, "", 1);
+  approval_tests.emplace_back(world3.get_random_number_engine()());
+  approval_tests.emplace_back(world3.get_random_number_engine()());
+  approval_tests.emplace_back(dist(world3.get_random_number_engine()));
+  approval_tests.emplace_back(dist(world3.get_random_number_engine()));
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder Coordinate Systems: Interface")
+{
+  std::vector<double> approval_tests;
+
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_spherical.wb";
+  WorldBuilder::World world(file_name);
+
+  CHECK_THROWS_WITH(CoordinateSystems::Interface::create("!not_implemented_coordinate_system!",&world),
+                    Contains("Internal error: Plugin with name '!not_implemented_coordinate_system!' is not found. "
+                             "The size of factories is "));
+
+  std::unique_ptr<CoordinateSystems::Interface> interface(CoordinateSystems::Interface::create("cartesian",&world));
+
+  interface->declare_entries(world.parameters, "", {});
+
+  CHECK(interface->cartesian_to_natural_coordinates(std::array<double,3> {{1,2,3}}) == std::array<double,3> {{1,2,3}});
+  CHECK(interface->natural_to_cartesian_coordinates(std::array<double,3> {{1,2,3}}) == std::array<double,3> {{1,2,3}});
+
+  approval_tests.emplace_back(interface->natural_coordinate_system());
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder Coordinate Systems: Cartesian")
+{
+  std::vector<double> approval_tests;
+
+  std::unique_ptr<CoordinateSystems::Interface> cartesian(CoordinateSystems::Interface::create("cartesian",nullptr));
+
+  //todo:fix
+  //cartesian->declare_entries();
+
+  CHECK(cartesian->cartesian_to_natural_coordinates(std::array<double,3> {{1,2,3}}) == std::array<double,3> {{1,2,3}});
+  CHECK(cartesian->natural_to_cartesian_coordinates(std::array<double,3> {{1,2,3}}) == std::array<double,3> {{1,2,3}});
+
+  approval_tests.emplace_back(cartesian->natural_coordinate_system());
+
+  // distance between two points at the same depth
+  const Point<3> point_1(0.0,0.0,10.0, CoordinateSystem::cartesian);
+  const Point<3> point_2(1.0,2.0,10.0, CoordinateSystem::cartesian);
+  const Point<3> point_3(3.0,2.0,10.0, CoordinateSystem::cartesian);
+  const Point<3> point_4(3.0,3.0,10.0, CoordinateSystem::cartesian);
+
+  approval_tests.emplace_back(cartesian->distance_between_points_at_same_depth(point_1, point_2));
+  approval_tests.emplace_back(cartesian->distance_between_points_at_same_depth(point_2, point_3));
+  approval_tests.emplace_back(cartesian->distance_between_points_at_same_depth(point_2, point_4));
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder Coordinate Systems: Spherical")
+{
+  std::vector<double> approval_tests;
+
+  // TODO: make test where a cartesian wb file is loaded into a spherical coordinate system.
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_spherical.wb";
+
+  WorldBuilder::World world(file_name);
+
+  std::unique_ptr<CoordinateSystems::Interface> spherical(CoordinateSystems::Interface::create("spherical", &world));
+
+  world.parameters.enter_subsection("coordinate system");
+  {
+    world.parameters.enter_subsection("spherical");
+    {
+      spherical->declare_entries(world.parameters,"", {});
+    }
+    world.parameters.leave_subsection();
+  }
+  world.parameters.leave_subsection();
+
+  std::array<double,3> spherical_array = spherical->cartesian_to_natural_coordinates(std::array<double,3> {{1,2,3}});
+  approval_tests.emplace_back(spherical_array[0]);
+  approval_tests.emplace_back(spherical_array[1]);
+  approval_tests.emplace_back(spherical_array[2]);
+  std::array<double,3> cartesian_array = spherical->natural_to_cartesian_coordinates(std::array<double,3> {{std::sqrt(1.0 * 1.0 + 2.0 * 2.0 + 3.0 * 3.0),1.1071487178,0.9302740141}});
+  approval_tests.emplace_back(cartesian_array[0]);
+  approval_tests.emplace_back(cartesian_array[1]);
+  approval_tests.emplace_back(cartesian_array[2]);
+
+  approval_tests.emplace_back(spherical->natural_coordinate_system());
+
+  // distance between two points at the same depth
+  const double dtr = Consts::PI / 180.0;
+  // first check unit radius, this the central angle
+  const Point<3> unit_point_1(1.0, 0.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> unit_point_2(1.0, 1.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> unit_point_3(1.0, 0.0 * dtr, 1.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> unit_point_4(1.0, 1.0 * dtr, 1.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> unit_point_5(1.0, 90.0 * dtr, 90.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> unit_point_6(1.0, -90.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> unit_point_7(1.0, 90.0 * dtr, 180.0 * dtr, CoordinateSystem::spherical);
+
+  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(unit_point_1, unit_point_2));
+  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(unit_point_1, unit_point_3));
+  CHECK(spherical->distance_between_points_at_same_depth(unit_point_1, unit_point_4) ==
+        Approx(std::acos(std::sin(0) * std::sin(1*dtr) +
+                         std::cos(0) * std::cos(1*dtr) * std::cos(1*dtr))));
+  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(unit_point_1, unit_point_5));
+  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(unit_point_6, unit_point_7));
+
+  // secondly check non-unit radius
+  const Point<3> point_1(10.0, 0.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> point_2(10.0, 1.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> point_3(10.0, 0.0 * dtr, 1.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> point_4(10.0, 1.0 * dtr, 1.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> point_5(10.0, 90.0 * dtr, 90.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> point_6(10.0, -90.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
+  const Point<3> point_7(10.0, 90.0 * dtr, 180.0 * dtr, CoordinateSystem::spherical);
+
+  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(point_1, point_2));
+  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(point_1, point_3));
+  CHECK(spherical->distance_between_points_at_same_depth(point_1, point_4) ==
+        Approx(10 * std::acos(std::sin(0) * std::sin(1*dtr) +
+                              std::cos(0) * std::cos(1*dtr) * std::cos(1*dtr))));
+  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(point_1, point_5));
+  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(point_6, point_7));
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder Features: Interface")
+{
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb1.json";
+
+  WorldBuilder::World world(file_name);
+  CHECK_THROWS_WITH(Features::Interface::create("!not_implemented_feature!", &world),
+                    Contains("Internal error: Plugin with name '!not_implemented_feature!' is not found. "
+                             "The size of factories is "));
+
+  const std::unique_ptr<Features::Interface> interface = Features::Interface::create("continental plate", &world);
+
+}
+
+TEST_CASE("WorldBuilder Features: Distance to Feature Plane")
+{
+  std::vector<double> approval_tests;
+
+  //  call the distance_to_plane to a subducting plate feature,
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_constant_angles_cartesian.wb";
+  WorldBuilder::World world1(file_name);
+  {
+    std::unique_ptr<Features::Interface> subducting_plate = Features::Interface::create("Subducting Plate", &world1);
+
+    world1.parameters.enter_subsection("features");
+    world1.parameters.enter_subsection("2");
+    subducting_plate->parse_entries(world1.parameters);
+    world1.parameters.leave_subsection();
+    world1.parameters.leave_subsection();
+    const std::array<double, 3> point1 = {{250e3,495e3,800e3}};
+    const double depth1 = 5.1e3;
+    auto plane_distances1 = world1.distance_to_plane(point1, depth1, "First subducting plate");
+    approval_tests.emplace_back(plane_distances1.get_distance_from_surface());
+    approval_tests.emplace_back(plane_distances1.get_distance_along_surface());
+    const std::array<double, 3> point2 = {{502e3,500e3,800e3}};
+    const double depth2 = 0.45e3;
+    auto plane_distances2 = world1.distance_to_plane(point2, depth2, "First subducting plate");
+    approval_tests.emplace_back(plane_distances2.get_distance_from_surface());
+    approval_tests.emplace_back(plane_distances2.get_distance_along_surface());
+    const std::array<double, 3> point3 = {{502e3,500e3,800e3}}; // point 3, shallower than point2, thus distance from plane = inf
+    const double depth3 = 0.43e3;
+    auto plane_distances3 = world1.distance_to_plane(point3, depth3, "First subducting plate");
+    approval_tests.emplace_back(plane_distances3.get_distance_from_surface());
+    approval_tests.emplace_back(plane_distances3.get_distance_along_surface());
+
+  }
+
+  // call the distance_to_plane to a fault feature.
+  const std::string file_name2 = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_constant_angles_cartesian.wb";
+  WorldBuilder::World world2(file_name2);
+  {
+    std::unique_ptr<Features::Interface> fault = Features::Interface::create("Fault", &world2);
+
+    world2.parameters.enter_subsection("features");
+    world2.parameters.enter_subsection("2");
+    fault->parse_entries(world2.parameters);
+    world2.parameters.leave_subsection();
+    world2.parameters.leave_subsection();
+    const std::array<double, 3> point1 = {{250e3,495e3,800e3}};
+    const double depth1 = 5.1e3;
+    auto plane_distances1 = world2.distance_to_plane(point1, depth1, "First fault");
+    approval_tests.emplace_back(plane_distances1.get_distance_from_surface());
+    approval_tests.emplace_back(plane_distances1.get_distance_along_surface());
+    const std::array<double, 3> point2 = {{502e3,500e3,800e3}};
+    const double depth2 = 0.45e3;
+    auto plane_distances2 = world2.distance_to_plane(point2, depth2, "First fault");
+    approval_tests.emplace_back(plane_distances2.get_distance_from_surface());
+    approval_tests.emplace_back(plane_distances2.get_distance_along_surface());
+    const std::array<double, 3> point3 = {{502e3,500e3,800e3}}; // point 3, shallower than point2, thus distance from plane = inf
+    const double depth3 = 0.43e3;
+    auto plane_distances3 = world2.distance_to_plane(point3, depth3, "First fault");
+    approval_tests.emplace_back(plane_distances3.get_distance_from_surface());
+    approval_tests.emplace_back(plane_distances3.get_distance_along_surface());
+
+    ApprovalTests::Approvals::verifyAll("Test", approval_tests);
+  }
+}
+
+
+TEST_CASE("WorldBuilder Features: Continental Plate")
+{
+  std::vector<double> approval_tests;
+  std::vector<grains> approval_tests_grains;
+
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/continental_plate.wb";
+  WorldBuilder::World world1(file_name);
+
+  // Check continental plate directly
+  {
+    std::unique_ptr<Features::Interface> continental_plate = Features::Interface::create("continental plate", &world1);
+
+    world1.parameters.enter_subsection("features");
+    world1.parameters.enter_subsection("2");
+    continental_plate->parse_entries(world1.parameters);
+    world1.parameters.leave_subsection();
+    world1.parameters.leave_subsection();
+    auto point = Point<3>(250e3,750e3,400e3,cartesian);
+    std::vector<double> vector(1,0.);
+    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
+    CHECK_THROWS_WITH(continental_plate->properties(point,nat_coord,10e3, {{{5,0,0}}},10, {0},vector),
+    Contains("Internal error: Unimplemented property provided"));
+  }
+
+  // Check continental plate through the world
+  std::array<double,3> position = {{0,0,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+
+  // the feature with composition 3
+  position = {{250e3,500e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 74e3));
+  approval_tests.emplace_back(world1.temperature(position, 76e3));
+  approval_tests.emplace_back(world1.temperature(position, 149e3));
+  approval_tests.emplace_back(world1.temperature(position, 151e3));
+  approval_tests.emplace_back(world1.temperature(position, 224e3));
+  approval_tests.emplace_back(world1.temperature(position, 226e3));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
+
+  // check grains
+  {
+    const WorldBuilder::grains grains = world1.grains(position, 0, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  // the feature with composition 2
+  position = {{1500e3,1500e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
+
+  // check grains
+  {
+    const WorldBuilder::grains grains = world1.grains(position, 0, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{250e3,1750e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
+
+  position = {{750e3,250e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
+
+  // check grains layer 1
+  {
+    const WorldBuilder::grains grains = world1.grains(position, 0, 0, 2);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  // check grains layer 2
+  {
+    const WorldBuilder::grains grains = world1.grains(position, 150e3, 0, 2);
+    approval_tests_grains.emplace_back(grains);
+
+  }
+
+  // the constant layers test
+  position = {{1500e3,250e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 1));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 249.5e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+  approval_tests.emplace_back(world1.composition(position, 0, 7));
+  approval_tests.emplace_back(world1.composition(position, 0, 8));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 0));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 1));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 2));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 3));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 4));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 5));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 6));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 7));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 8));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 0));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 5));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 6));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 7));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 8));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 0));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 1));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 2));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 3));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 4));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 5));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 6));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 7));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 8));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 0));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 5));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 6));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 7));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 8));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 8));
+
+
+  std::vector<std::string> approvals;
+  for (auto&& value : approval_tests)
+    {
+      std::stringstream s;
+      s << value;
+      approvals.emplace_back(s.str());
+    }
+  for (auto&& value : approval_tests_grains)
+    {
+      std::stringstream s;
+      s << value;
+      approvals.emplace_back(s.str());
+    }
+  ApprovalTests::Approvals::verifyAll("Test", approvals);
+}
+
+TEST_CASE("WorldBuilder Features: Mantle layer")
+{
+  std::vector<double> approval_tests;
+  std::vector<grains> approval_tests_grains;
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/mantle_layer_cartesian.wb";
+  WorldBuilder::World world1(file_name);
+
+  // Check mantle layer directly
+  {
+    std::unique_ptr<Features::Interface> mantle_layer = Features::Interface::create("mantle layer", &world1);
+
+    world1.parameters.enter_subsection("features");
+    world1.parameters.enter_subsection("2");
+    mantle_layer->parse_entries(world1.parameters);
+    world1.parameters.leave_subsection();
+    world1.parameters.leave_subsection();
+    auto point = Point<3>(250e3,750e3,400e3,cartesian);
+    std::vector<double> vector(1,0.);
+    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
+    CHECK_THROWS_WITH(mantle_layer->properties(point,nat_coord,260e3, {{{5,0,0}}},10, {0},vector),
+    Contains("Internal error: Unimplemented property provided"));
+  }
+  // Check continental plate through the world
+  std::array<double,3> position = {{0,0,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+
+  position = {{250e3,501e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0+100e3));
+  approval_tests.emplace_back(world1.temperature(position, 240e3+100e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3+100e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0+200e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 0+200e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 0+200e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 0+200e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 0+200e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 0+200e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 5));
+
+  // check grains
+  {
+    const WorldBuilder::grains grains = world1.grains(position, 200e3, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{1500e3,1500e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0+150e3));
+  approval_tests.emplace_back(world1.temperature(position, 240e3+150e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3+150e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0+150e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 0+150e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 0+150e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 0+150e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 0+150e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 0+150e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 5));
+
+  // check grains
+  {
+    const WorldBuilder::grains grains = world1.grains(position, 150e3, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{250e3,1750e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0+250e3));
+  approval_tests.emplace_back(world1.temperature(position, 240e3+250e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3+250e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0+250e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 0+250e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 0+250e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 0+250e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 0+250e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 0+250e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 5));
+
+  position = {{750e3,250e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0+300e3));
+  approval_tests.emplace_back(world1.temperature(position, 95e3+300e3));
+  approval_tests.emplace_back(world1.temperature(position, 105e3+300e3));
+  approval_tests.emplace_back(world1.temperature(position, 145e3+300e3));
+  approval_tests.emplace_back(world1.temperature(position, 155e3+300e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3+300e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0+300e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 0+300e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 0+300e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 0+300e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 0+300e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 0+300e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 0+300e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 5));
+
+  // check grains layer 1
+  {
+    const WorldBuilder::grains grains = world1.grains(position, 0+300e3, 0, 2);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  // check grains layer 2
+  {
+    const WorldBuilder::grains grains = world1.grains(position, 150e3+300e3, 0, 2);
+    approval_tests_grains.emplace_back(grains);
+
+  }
+
+  // the constant layers test
+  position = {{1500e3,250e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0+350e3));
+  approval_tests.emplace_back(world1.temperature(position, 240e3+350e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3+350e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 0+350e3, 9));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 9));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 9));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 9));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 9));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 9));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 9));
+
+  std::vector<std::string> approvals;
+  for (auto&& value : approval_tests)
+    {
+      std::stringstream s;
+      s << value;
+      approvals.emplace_back(s.str());
+    }
+  for (auto&& value : approval_tests_grains)
+    {
+      std::stringstream s;
+      s << value;
+      approvals.emplace_back(s.str());
+    }
+  ApprovalTests::Approvals::verifyAll("Test", approvals);
+}
+
+TEST_CASE("WorldBuilder Features: Oceanic Plate")
+{
+  std::vector<double> approval_tests;
+  std::vector<grains> approval_tests_grains;
+
+  // Cartesian
+  std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_cartesian.wb";
+  WorldBuilder::World world1(file_name);
+
+  // Check continental plate directly
+  {
+    std::unique_ptr<Features::Interface> oceanic_plate = Features::Interface::create("oceanic plate", &world1);
+
+    world1.parameters.enter_subsection("features");
+    world1.parameters.enter_subsection("2");
+    oceanic_plate->parse_entries(world1.parameters);
+    world1.parameters.leave_subsection();
+    world1.parameters.leave_subsection();
+    auto point = Point<3>(250e3,750e3,400e3,cartesian);
+    std::vector<double> vector(1,0.);
+    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
+    CHECK_THROWS_WITH(oceanic_plate->properties(point,nat_coord,10e3, {{{5,0,0}}},10, {0},vector),
+    Contains("Internal error: Unimplemented property provided"));
+  }
+
+  // Check continental plate through the world
+  // 2d
+  std::array<double,2> position_2d = {{0,0}};
+  approval_tests.emplace_back(world1.temperature(position_2d, 0));
+  approval_tests.emplace_back(world1.temperature(position_2d, 240e3));
+  approval_tests.emplace_back(world1.temperature(position_2d, 260e3));
+  approval_tests.emplace_back(world1.composition(position_2d, 0, 0));
+  approval_tests.emplace_back(world1.composition(position_2d, 0, 1));
+  approval_tests.emplace_back(world1.composition(position_2d, 0, 2));
+  approval_tests.emplace_back(world1.composition(position_2d, 0, 3));
+  approval_tests.emplace_back(world1.composition(position_2d, 0, 4));
+  approval_tests.emplace_back(world1.composition(position_2d, 0, 5));
+  approval_tests.emplace_back(world1.composition(position_2d, 0, 6));
+  // 3d
+  std::array<double,3> position = {{0,0,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  position = {{250e3,500e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  position = {{1500e3,1500e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  position = {{250e3,1750e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  position = {{750e3,250e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 195e3));
+  approval_tests.emplace_back(world1.temperature(position, 205e3));
+  approval_tests.emplace_back(world1.temperature(position, 247e3));
+  approval_tests.emplace_back(world1.temperature(position, 249e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 6));
+
+  position = {{1500e3, 0, 0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  // test symmetry
+  position = {{1600e3, 0, 0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+
+  position = {{1400e3, 0, 0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+
+  // the constant layers test
+  position = {{200e3,200e3,0}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+  approval_tests.emplace_back(world1.composition(position, 0, 7));
+  approval_tests.emplace_back(world1.composition(position, 0, 8));
+  approval_tests.emplace_back(world1.composition(position, 0, 9));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 0));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 1));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 2));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 3));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 4));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 5));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 6));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 7));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 8));
+  approval_tests.emplace_back(world1.composition(position, 75e3-1, 9));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 0));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 5));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 6));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 7));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 8));
+  approval_tests.emplace_back(world1.composition(position, 75e3+1, 9));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 0));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 1));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 2));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 3));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 4));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 5));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 6));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 7));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 8));
+  approval_tests.emplace_back(world1.composition(position, 150e3-1, 9));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 0));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 5));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 6));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 7));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 8));
+  approval_tests.emplace_back(world1.composition(position, 150e3+1, 9));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 240e3, 9));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 6));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 7));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 8));
+  approval_tests.emplace_back(world1.composition(position, 260e3, 9));
+
+  // spherical
+  file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_spherical.wb";
+  WorldBuilder::World world2(file_name);
+
+  // Check continental plate directly
+  const std::unique_ptr<Features::Interface> oceanic_plate = Features::Interface::create("oceanic plate", &world2);
+
+  // Check continental plate through the world
+  const double dtr = Consts::PI / 180.0;
+  std::unique_ptr<WorldBuilder::CoordinateSystems::Interface> &coordinate_system = world2.parameters.coordinate_system;
+
+  // 2d
+  position_2d = {{6371000,0}};
+  approval_tests.emplace_back(world2.temperature(position_2d, 0));
+  approval_tests.emplace_back(world2.composition(position_2d, 0, 0));
+  approval_tests.emplace_back(world2.composition(position_2d, 0, 1));
+  approval_tests.emplace_back(world2.composition(position_2d, 0, 2));
+  approval_tests.emplace_back(world2.composition(position_2d, 0, 3));
+  approval_tests.emplace_back(world2.composition(position_2d, 0, 4));
+  approval_tests.emplace_back(world2.composition(position_2d, 0, 5));
+  approval_tests.emplace_back(world2.composition(position_2d, 0, 6));
+
+  // 3d
+  position = {{6371000,0,0}};
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 2));
+  approval_tests.emplace_back(world2.composition(position, 0, 3));
+  approval_tests.emplace_back(world2.composition(position, 0, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 5));
+  approval_tests.emplace_back(world2.composition(position, 0, 6));
+
+  position = {{6371000, -5 * dtr,-5 * dtr}};
+  position = coordinate_system->natural_to_cartesian_coordinates(position);
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 240e3));
+  approval_tests.emplace_back(world2.temperature(position, 260e3));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 2));
+  approval_tests.emplace_back(world2.composition(position, 0, 3));
+  approval_tests.emplace_back(world2.composition(position, 0, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 5));
+  approval_tests.emplace_back(world2.composition(position, 0, 6));
+
+  position = {{6371000, 5 * dtr,-5 * dtr}};
+  position = coordinate_system->natural_to_cartesian_coordinates(position);
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 240e3));
+  approval_tests.emplace_back(world2.temperature(position, 260e3));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 2));
+  approval_tests.emplace_back(world2.composition(position, 240e3, 2));
+  approval_tests.emplace_back(world2.composition(position, 260e3, 2));
+  approval_tests.emplace_back(world2.composition(position, 0, 3));
+  approval_tests.emplace_back(world2.composition(position, 0, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 5));
+  approval_tests.emplace_back(world2.composition(position, 0, 6));
+
+  // check grains
+  {
+    const WorldBuilder::grains grains = world2.grains(position, 240e3, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{6371000, 5 * dtr,5 * dtr}};
+  position = coordinate_system->natural_to_cartesian_coordinates(position);
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 240e3));
+  approval_tests.emplace_back(world2.temperature(position, 260e3));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 2));
+  approval_tests.emplace_back(world2.composition(position, 0, 3));
+  approval_tests.emplace_back(world2.composition(position, 0, 4));
+  approval_tests.emplace_back(world2.composition(position, 240e3, 4));
+  approval_tests.emplace_back(world2.composition(position, 260e3, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 5));
+  approval_tests.emplace_back(world2.composition(position, 0, 6));
+
+  // check grains
+  {
+    const WorldBuilder::grains grains = world2.grains(position, 240e3, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{6371000, -15 * dtr, -15 * dtr}};
+  position = coordinate_system->natural_to_cartesian_coordinates(position);
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 240e3));
+  approval_tests.emplace_back(world2.temperature(position, 260e3));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 2));
+  approval_tests.emplace_back(world2.composition(position, 0, 3));
+  approval_tests.emplace_back(world2.composition(position, 0, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 5));
+  approval_tests.emplace_back(world2.composition(position, 0, 6));
+  approval_tests.emplace_back(world2.composition(position, 240e3, 5));
+  approval_tests.emplace_back(world2.composition(position, 240e3, 6));
+  approval_tests.emplace_back(world2.composition(position, 260e3, 5));
+  approval_tests.emplace_back(world2.composition(position, 260e3, 6));
+
+  // check grains layer 1
+  {
+    const WorldBuilder::grains grains = world2.grains(position, 0, 0, 2);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  // check grains layer 2
+  {
+    const WorldBuilder::grains grains = world2.grains(position, 150e3, 0, 2);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{6371000, 15 * dtr, -19 * dtr}};
+  position = coordinate_system->natural_to_cartesian_coordinates(position);
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 10));
+  approval_tests.emplace_back(world2.temperature(position, 240e3));
+  approval_tests.emplace_back(world2.temperature(position, 260e3));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 2));
+  approval_tests.emplace_back(world2.composition(position, 0, 3));
+  approval_tests.emplace_back(world2.composition(position, 0, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 5));
+  approval_tests.emplace_back(world2.composition(position, 0, 6));
+  approval_tests.emplace_back(world2.composition(position, 240e3, 6));
+  approval_tests.emplace_back(world2.composition(position, 260e3, 6));
+
+  // test symmetry
+  position = {{6371000, 16 * dtr, -19 * dtr}};
+  position = coordinate_system->natural_to_cartesian_coordinates(position);
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 10));
+  approval_tests.emplace_back(world2.temperature(position, 240e3));
+  approval_tests.emplace_back(world2.temperature(position, 260e3));
+
+  position = {{6371000, 14 * dtr, -19 * dtr}};
+  position = coordinate_system->natural_to_cartesian_coordinates(position);
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 10));
+  approval_tests.emplace_back(world2.temperature(position, 240e3));
+  approval_tests.emplace_back(world2.temperature(position, 260e3));
+
+  // test bend
+  position = {{6371000, 12.5 * dtr, -12.5 * dtr}};
+  position = coordinate_system->natural_to_cartesian_coordinates(position);
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 10));
+  approval_tests.emplace_back(world2.temperature(position, 240e3));
+  approval_tests.emplace_back(world2.temperature(position, 260e3));
+
+  std::vector<std::string> approvals;
+  for (auto&& value : approval_tests)
+    {
+      std::stringstream s;
+      s << value;
+      approvals.emplace_back(s.str());
+    }
+  for (auto&& value : approval_tests_grains)
+    {
+      std::stringstream s;
+      s << value;
+      approvals.emplace_back(s.str());
+    }
+  ApprovalTests::Approvals::verifyAll("Test", approvals);
+}
+
+TEST_CASE("WorldBuilder Features: Subducting Plate")
+{
+  std::vector<double> approval_tests;
+  std::vector<grains> approval_tests_grains;
+
+  // Cartesian
+  std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_constant_angles_cartesian.wb";
+  WorldBuilder::World world1(file_name);
+
+  // Check continental plate directly (upper case should automatically turn into lower case).
+  {
+    std::unique_ptr<Features::Interface> subducting_plate = Features::Interface::create("Subducting Plate", &world1);
+
+    world1.parameters.enter_subsection("features");
+    world1.parameters.enter_subsection("2");
+    subducting_plate->parse_entries(world1.parameters);
+    world1.parameters.leave_subsection();
+    world1.parameters.leave_subsection();
+    auto point = Point<3>(250e3,490e3,800e3,cartesian);
+    std::vector<double> vector(1,0.);
+    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
+    CHECK_THROWS_WITH(subducting_plate->properties(point,nat_coord,100000, {{{5,0,0}}},10, {0},vector),
+    Contains("Internal error: Unimplemented property provided"));
+  }
+  // Check continental plate through the world
+  std::array<double,3> position = {{0,0,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 240e3));
+  approval_tests.emplace_back(world1.temperature(position, 260e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+
+  position = {{0,150e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 1));
+  approval_tests.emplace_back(world1.temperature(position, 5));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100));
+  approval_tests.emplace_back(world1.temperature(position, 500));
+  approval_tests.emplace_back(world1.temperature(position, 1000));
+  approval_tests.emplace_back(world1.temperature(position, 5000));
+  approval_tests.emplace_back(world1.temperature(position, 10e3));
+  approval_tests.emplace_back(world1.temperature(position, 25e3));
+  approval_tests.emplace_back(world1.temperature(position, 50e3));
+  approval_tests.emplace_back(world1.temperature(position, 75e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 175e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+
+
+  position = {{10e3,150e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 1));
+  approval_tests.emplace_back(world1.temperature(position, 5));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100));
+  approval_tests.emplace_back(world1.temperature(position, 500));
+  approval_tests.emplace_back(world1.temperature(position, 1000));
+  approval_tests.emplace_back(world1.temperature(position, 5000));
+  approval_tests.emplace_back(world1.temperature(position, 10e3));
+  approval_tests.emplace_back(world1.temperature(position, 25e3));
+  approval_tests.emplace_back(world1.temperature(position, 50e3));
+  approval_tests.emplace_back(world1.temperature(position, 75e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 175e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+
+  position = {{0,160e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 1));
+  approval_tests.emplace_back(world1.temperature(position, 5));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100));
+  approval_tests.emplace_back(world1.temperature(position, 500));
+  approval_tests.emplace_back(world1.temperature(position, 1000));
+  approval_tests.emplace_back(world1.temperature(position, 5000));
+  approval_tests.emplace_back(world1.temperature(position, 10e3));
+  approval_tests.emplace_back(world1.temperature(position, 25e3));
+  approval_tests.emplace_back(world1.temperature(position, 50e3));
+  approval_tests.emplace_back(world1.temperature(position, 75e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 175e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+
+
+  position = {{750e3,175e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 1));
+  approval_tests.emplace_back(world1.temperature(position, 5));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100));
+  approval_tests.emplace_back(world1.temperature(position, 500));
+  approval_tests.emplace_back(world1.temperature(position, 1000));
+  approval_tests.emplace_back(world1.temperature(position, 5000));
+  approval_tests.emplace_back(world1.temperature(position, 10e3));
+  approval_tests.emplace_back(world1.temperature(position, 25e3));
+  approval_tests.emplace_back(world1.temperature(position, 50e3));
+  approval_tests.emplace_back(world1.temperature(position, 75e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 175e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+
+  //position = {{250e3,450e3,800e3}};
+  //approval_tests.emplace_back(world1.temperature(position, 0));
+  //approval_tests.emplace_back(world1.temperature(position, 1)); // we are in the plate for sure (colder than anywhere in the mantle)
+  //approval_tests.emplace_back(world1.temperature(position, 5)); // we are in the plate for sure (colder than anywhere in the mantle)
+  //approval_tests.emplace_back(world1.temperature(position, 10)); // we are in the plate for sure (colder than anywhere in the mantle)
+  //approval_tests.emplace_back(world1.temperature(position, 100)); // we are in the plate for sure (colder than anywhere in the mantle)
+  //approval_tests.emplace_back(world1.temperature(position, 500)); // we are in the plate for sure (colder than anywhere in the mantle)
+  //approval_tests.emplace_back(world1.temperature(position, 1000)); // we are in the plate for sure (colder than anywhere in the mantle)
+  //approval_tests.emplace_back(world1.temperature(position, 5000)); // we are in the plate for sure (colder than anywhere in the mantle)
+  //approval_tests.emplace_back(world1.temperature(position, 10e3));
+  //approval_tests.emplace_back(world1.temperature(position, 25e3));
+  //approval_tests.emplace_back(world1.temperature(position, 50e3));
+  //approval_tests.emplace_back(world1.temperature(position, 75e3));
+  //approval_tests.emplace_back(world1.temperature(position, 150e3));
+
+  position = {{250e3,488.750e3,800e3}};
+  position = {{250e3,500e3,800e3}};
+  // results strongly dependent on the summation number of the McKenzie temperature.
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 1));
+  approval_tests.emplace_back(world1.temperature(position, 5));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100));
+  approval_tests.emplace_back(world1.temperature(position, 500)); // we are in the plate for sure (colder than anywhere in the mantle)
+  approval_tests.emplace_back(world1.temperature(position, 1000)); // we are in the plate for sure (colder than anywhere in the mantle)
+  approval_tests.emplace_back(world1.temperature(position, 5000)); // we are in the plate for sure (colder than anywhere in the mantle)
+  approval_tests.emplace_back(world1.temperature(position, 10e3));
+  approval_tests.emplace_back(world1.temperature(position, 25e3));
+  approval_tests.emplace_back(world1.temperature(position, 50e3));
+  approval_tests.emplace_back(world1.temperature(position, 75e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  //approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 100e3 - 1));
+  //approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 100e3 + 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 10, 0));
+  approval_tests.emplace_back(world1.composition(position, 10, 1));
+  approval_tests.emplace_back(world1.composition(position, 10, 2));
+  approval_tests.emplace_back(world1.composition(position, 10, 3));
+  approval_tests.emplace_back(world1.composition(position, 10, 4));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 - 1, 0));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 + 1, 0));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 - 1, 1));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 + 1, 1));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 - 1, 1));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 + 1, 1));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 - 1, 2));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 + 1, 2));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 + 1, 3));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 - 1, 2));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 - 1, 3));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 + 1, 2));
+  // this comes form the first subducting plate
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 + 1, 3));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 100e3 - 1, 3));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 100e3 + 1, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  // check grains layer 1
+  {
+    WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 33e3 - 5e3, 0, 2);
+    // these are random numbers, but they should stay the same.
+    // note that the values are different from for example the continental plate since
+    // this performs a interpolation between segments of the slab.
+    approval_tests_grains.emplace_back(grains);
+
+    grains = world1.grains(position, std::sqrt(2) * 33e3 - 5e3, 1, 2);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  // check grains layer 2
+  {
+    const WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 66e3 - 1, 0, 2);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{250e3,550e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 45e3));
+  approval_tests.emplace_back(world1.temperature(position, 50e3-1));
+  approval_tests.emplace_back(world1.temperature(position, 50e3+1));
+  approval_tests.emplace_back(world1.temperature(position, 55e3));
+  approval_tests.emplace_back(world1.temperature(position, 100e3-1));
+  approval_tests.emplace_back(world1.temperature(position, 100e3+1));
+  approval_tests.emplace_back(world1.temperature(position, 101e3));
+  approval_tests.emplace_back(world1.temperature(position, 110e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 155e3));
+  approval_tests.emplace_back(world1.temperature(position, 175e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+  approval_tests.emplace_back(world1.temperature(position, 250e3));
+  approval_tests.emplace_back(world1.temperature(position, 300e3));
+
+  position = {{250e3,600e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 45e3));
+  approval_tests.emplace_back(world1.temperature(position, 50e3-1));
+  approval_tests.emplace_back(world1.temperature(position, 50e3+1));
+  approval_tests.emplace_back(world1.temperature(position, 55e3));
+  approval_tests.emplace_back(world1.temperature(position, 100e3-1));
+  approval_tests.emplace_back(world1.temperature(position, 100e3+1));
+  approval_tests.emplace_back(world1.temperature(position, 101e3));
+  approval_tests.emplace_back(world1.temperature(position, 110e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 155e3));
+  approval_tests.emplace_back(world1.temperature(position, 160e3));
+  approval_tests.emplace_back(world1.temperature(position, 165e3));
+  approval_tests.emplace_back(world1.temperature(position, 170e3));
+  approval_tests.emplace_back(world1.temperature(position, 175e3));
+  approval_tests.emplace_back(world1.temperature(position, 180e3));
+  approval_tests.emplace_back(world1.temperature(position, 185e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+  approval_tests.emplace_back(world1.temperature(position, 250e3));
+  approval_tests.emplace_back(world1.temperature(position, 300e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 10, 0));
+  approval_tests.emplace_back(world1.composition(position, 10, 1));
+  approval_tests.emplace_back(world1.composition(position, 10, 2));
+  approval_tests.emplace_back(world1.composition(position, 10, 3));
+  approval_tests.emplace_back(world1.composition(position, 100e3-1, 0));
+  approval_tests.emplace_back(world1.composition(position, 100e3-1, 1));
+  approval_tests.emplace_back(world1.composition(position, 100e3-1, 2));
+  approval_tests.emplace_back(world1.composition(position, 100e3-1, 3));
+  approval_tests.emplace_back(world1.composition(position, 100e3-1, 4));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 0));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 101e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  position = {{650e3,650e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100e3));
+  approval_tests.emplace_back(world1.temperature(position, 100e3+1));
+  approval_tests.emplace_back(world1.temperature(position, 101e3));
+  approval_tests.emplace_back(world1.temperature(position, 110e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 10, 0));
+  approval_tests.emplace_back(world1.composition(position, 10, 1));
+  approval_tests.emplace_back(world1.composition(position, 10, 2));
+  approval_tests.emplace_back(world1.composition(position, 10, 3));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 0));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 101e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  position = {{700e3,675e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100e3));
+  approval_tests.emplace_back(world1.temperature(position, 100e3+1));
+  approval_tests.emplace_back(world1.temperature(position, 101e3));
+  approval_tests.emplace_back(world1.temperature(position, 110e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 10, 0));
+  approval_tests.emplace_back(world1.composition(position, 10, 1));
+  approval_tests.emplace_back(world1.composition(position, 10, 2));
+  approval_tests.emplace_back(world1.composition(position, 10, 3));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 100e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 0));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 100e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 101e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 1));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 2));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 3));
+  approval_tests.emplace_back(world1.composition(position, 101e3+1, 4));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 150e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 0));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 1));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 2));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 3));
+  approval_tests.emplace_back(world1.composition(position, 200e3, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  position = {{700e3,155e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+  approval_tests.emplace_back(world1.temperature(position, 250e3));
+  approval_tests.emplace_back(world1.temperature(position, 300e3));
+
+  // check grains
+  {
+    {
+      // layer 1
+      const WorldBuilder::grains grains = world1.grains(position, 80e3, 0, 3);
+      approval_tests_grains.emplace_back(grains);
+    }
+
+    {
+      // layer 2
+      const WorldBuilder::grains grains = world1.grains(position, 100e3, 0, 3);
+      approval_tests_grains.emplace_back(grains);
+    }
+
+    {
+      // layer 3
+      const WorldBuilder::grains grains = world1.grains(position, 250e3, 0, 3);
+      approval_tests_grains.emplace_back(grains);
+    }
+  }
+
+
+  const std::string file_name2 = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian.wb";
+  const WorldBuilder::World world2(file_name2);
+
+  position = {{250e3,500e3,800e3}};
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.temperature(position, 1));
+  approval_tests.emplace_back(world2.composition(position, 1, 0));
+  approval_tests.emplace_back(world2.temperature(position, 1e3));
+  approval_tests.emplace_back(world2.composition(position, 1e3, 0));
+  approval_tests.emplace_back(world2.temperature(position, 10e3));
+  approval_tests.emplace_back(world2.composition(position, 10e3, 0));
+  approval_tests.emplace_back(world2.temperature(position, 20e3));
+  approval_tests.emplace_back(world2.composition(position, 20e3, 0));
+  approval_tests.emplace_back(world2.temperature(position, 40e3));
+  approval_tests.emplace_back(world2.composition(position, 40e3, 0));
+  approval_tests.emplace_back(world2.temperature(position, 60e3));
+  approval_tests.emplace_back(world2.composition(position, 60e3, 0));
+  approval_tests.emplace_back(world2.temperature(position, 80e3));
+  approval_tests.emplace_back(world2.composition(position, 80e3, 0));
+  approval_tests.emplace_back(world2.temperature(position, 100e3));
+  approval_tests.emplace_back(world2.composition(position, 100e3, 0));
+
+
+  file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian_2.wb";
+  const WorldBuilder::World world4(file_name);
+
+  position = {{250e3,500e3,800e3}};
+  approval_tests.emplace_back(world4.temperature(position, 0));
+  approval_tests.emplace_back(world4.composition(position, 0, 0));
+  approval_tests.emplace_back(world4.composition(position, 0, 1));
+  approval_tests.emplace_back(world4.composition(position, 0, 2));
+  approval_tests.emplace_back(world4.composition(position, 0, 3));
+  approval_tests.emplace_back(world4.temperature(position, 1));
+  approval_tests.emplace_back(world4.composition(position, 1, 0));
+  approval_tests.emplace_back(world4.composition(position, 1, 1));
+  approval_tests.emplace_back(world4.composition(position, 1, 2));
+  approval_tests.emplace_back(world4.composition(position, 1, 3));
+  approval_tests.emplace_back(world4.temperature(position, 1e3));
+  approval_tests.emplace_back(world4.composition(position, 1e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 1e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 1e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 1e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 10e3));
+  approval_tests.emplace_back(world4.composition(position, 10e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 10e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 10e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 10e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 20e3));
+  approval_tests.emplace_back(world4.composition(position, 20e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 20e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 20e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 20e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 30e3));
+  approval_tests.emplace_back(world4.composition(position, 30e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 30e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 30e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 30e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 35e3));
+  approval_tests.emplace_back(world4.composition(position, 35e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 35e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 35e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 35e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 40e3));
+  approval_tests.emplace_back(world4.composition(position, 40e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 40e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 40e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 40e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 45e3));
+  approval_tests.emplace_back(world4.composition(position, 45e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 45e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 45e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 45e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 50e3));
+  approval_tests.emplace_back(world4.composition(position, 50e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 50e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 50e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 50e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 60e3));
+  approval_tests.emplace_back(world4.composition(position, 60e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 60e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 60e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 60e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 80e3));
+  approval_tests.emplace_back(world4.composition(position, 80e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 80e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 80e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 80e3, 3));
+  approval_tests.emplace_back(world4.temperature(position, 100e3));
+  approval_tests.emplace_back(world4.composition(position, 100e3, 0));
+  approval_tests.emplace_back(world4.composition(position, 100e3, 1));
+  approval_tests.emplace_back(world4.composition(position, 100e3, 2));
+  approval_tests.emplace_back(world4.composition(position, 100e3, 3));
+
+
+  std::vector<std::string> approvals;
+  for (auto&& value : approval_tests)
+    {
+      std::stringstream s;
+      s << value;
+      approvals.emplace_back(s.str());
+    }
+  for (auto&& value : approval_tests_grains)
+    {
+      std::stringstream s;
+      s << value;
+      approvals.emplace_back(s.str());
+    }
+  ApprovalTests::Approvals::verifyAll("Test", approvals);
+}
+
+TEST_CASE("WorldBuilder Features: Fault")
+{
+  std::vector<double> approval_tests;
+  std::vector<grains> approval_tests_grains;
+
+  // Cartesian
+  std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_constant_angles_cartesian.wb";
+  WorldBuilder::World world1(file_name);
+
+  // Check continental plate directly (upper case should automatically turn into lower case).
+  {
+    std::unique_ptr<Features::Interface> fault = Features::Interface::create("Fault", &world1);
+
+    world1.parameters.enter_subsection("features");
+    world1.parameters.enter_subsection("2");
+    fault->parse_entries(world1.parameters);
+    world1.parameters.leave_subsection();
+    world1.parameters.leave_subsection();
+    auto point = Point<3>(50e3,230e3,800e3,cartesian);
+    std::vector<double> vector(1,0.);
+    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
+    CHECK_THROWS_WITH(fault->properties(point,nat_coord,1000, {{{5,0,0}}},10, {0},vector),
+    Contains("Internal error: Unimplemented property provided"));
+  }
+
+  // Check fault plate through the world
+  std::array<double,3> position = {{0,0,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 220e3));
+  approval_tests.emplace_back(world1.temperature(position, 230e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  position = {{250e3,500e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 - 1));
+  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 + 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 10, 0));
+  approval_tests.emplace_back(world1.composition(position, 10, 1));
+  approval_tests.emplace_back(world1.composition(position, 10, 2));
+  approval_tests.emplace_back(world1.composition(position, 10, 3));
+  approval_tests.emplace_back(world1.composition(position, 10, 4));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 50e3 - 1, 3));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 50e3 - 1, 4));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 50e3 + 1, 3));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 50e3 + 1, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+  // check grains
+  {
+    WorldBuilder::grains grains = world1.grains(position, 10, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+
+    grains = world1.grains(position, 10, 1, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{50e3,230e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 1));
+  approval_tests.emplace_back(world1.temperature(position, 5));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100));
+  approval_tests.emplace_back(world1.temperature(position, 500));
+  approval_tests.emplace_back(world1.temperature(position, 1000));
+  approval_tests.emplace_back(world1.temperature(position, 5000));
+  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3/2));
+  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 - 1));
+  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 + 1));
+  approval_tests.emplace_back(world1.temperature(position, 25e3));
+  approval_tests.emplace_back(world1.temperature(position, 50e3));
+  approval_tests.emplace_back(world1.temperature(position, 75e3));
+  approval_tests.emplace_back(world1.temperature(position, 80e3));
+  approval_tests.emplace_back(world1.temperature(position, 90e3));
+  approval_tests.emplace_back(world1.temperature(position, 100e3));
+  approval_tests.emplace_back(world1.temperature(position, 150e3));
+  approval_tests.emplace_back(world1.temperature(position, 200e3));
+
+  position = {{250e3,250e3,800e3}};
+  approval_tests.emplace_back(world1.temperature(position, 0));
+  approval_tests.emplace_back(world1.temperature(position, 1));
+  approval_tests.emplace_back(world1.temperature(position, 5));
+  approval_tests.emplace_back(world1.temperature(position, 10));
+  approval_tests.emplace_back(world1.temperature(position, 100));
+  approval_tests.emplace_back(world1.temperature(position, 500));
+  approval_tests.emplace_back(world1.temperature(position, 1000));
+  approval_tests.emplace_back(world1.temperature(position, 5000));
+  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3/2));
+  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 - 1));
+  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 + 1));
+  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 51e3));
+  approval_tests.emplace_back(world1.composition(position, 0, 0));
+  approval_tests.emplace_back(world1.composition(position, 0, 1));
+  approval_tests.emplace_back(world1.composition(position, 0, 2));
+  approval_tests.emplace_back(world1.composition(position, 0, 3));
+  approval_tests.emplace_back(world1.composition(position, 10, 0));
+  approval_tests.emplace_back(world1.composition(position, 10, 1));
+  approval_tests.emplace_back(world1.composition(position, 10, 2));
+  approval_tests.emplace_back(world1.composition(position, 10, 3));
+
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 0));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 1));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 2));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 0));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 1));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 2));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 * 0.5 - 1, 1));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 * 0.5 + 1, 1));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 * 0.5 - 1, 2));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 * 0.5 + 1, 2));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 * 0.5 - 1, 3));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 * 0.5 + 1, 3));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 100e3 * 0.5 - 1, 3));
+  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 100e3 * 0.5 + 1, 3));
+  approval_tests.emplace_back(world1.composition(position, 0, 4));
+  approval_tests.emplace_back(world1.composition(position, 0, 5));
+  approval_tests.emplace_back(world1.composition(position, 0, 6));
+
+
+  // check grains
+  {
+    {
+      // layer 1
+      WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 33e3 * 0.5 - 5e3, 0, 3);
+      approval_tests_grains.emplace_back(grains);
+
+      grains = world1.grains(position, std::sqrt(2) * 33e3 * 0.5 - 5e3, 1, 3);
+      approval_tests_grains.emplace_back(grains);
+    }
+
+    {
+      // layer 2
+      WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 33e3 * 0.5 + 1, 0, 3);
+      approval_tests_grains.emplace_back(grains);
+
+      grains = world1.grains(position, std::sqrt(2) * 33e3 * 0.5 + 1, 1, 3);
+      approval_tests_grains.emplace_back(grains);
+    }
+
+    {
+      // layer 3
+      const WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 99e3 * 0.5 - 5e3, 0, 3);
+      approval_tests_grains.emplace_back(grains);
+    }
+  }
+
+
+  position = {{250e3,250e3,800e3}};
+  approval_tests.emplace_back(world1.composition(position, 1, 0));
+  approval_tests.emplace_back(world1.composition(position, 1, 1));
+  approval_tests.emplace_back(world1.composition(position, 1, 2));
+  position = {{250e3,250e3-std::sqrt(2) * 33e3 * 0.5 + 1, 800e3}};
+  approval_tests.emplace_back(world1.composition(position, 1, 0));
+  approval_tests.emplace_back(world1.composition(position, 1, 1));
+  approval_tests.emplace_back(world1.composition(position, 1, 2));
+  position = {{250e3,250e3-std::sqrt(2) * 66e3 * 0.5 + 1, 800e3}};
+  approval_tests.emplace_back(world1.composition(position, 1, 0));
+  approval_tests.emplace_back(world1.composition(position, 1, 1));
+  approval_tests.emplace_back(world1.composition(position, 1, 2));
+  position = {{250e3,250e3-std::sqrt(2) * 99e3 * 0.5 + 1, 800e3}};
+  approval_tests.emplace_back(world1.composition(position, 1, 0));
+  approval_tests.emplace_back(world1.composition(position, 1, 1));
+  approval_tests.emplace_back(world1.composition(position, 1, 2));
+  approval_tests.emplace_back(world1.composition(position, 1, 3));
+
+  const std::string file_name2 = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_constant_angles_cartesian_force_temp.wb";
+  const WorldBuilder::World world2(file_name2);
+
+  // Check fault plate through the world
+  position = {{0,0,800e3}};
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 220e3));
+  approval_tests.emplace_back(world2.temperature(position, 230e3));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 2));
+  approval_tests.emplace_back(world2.composition(position, 0, 3));
+  approval_tests.emplace_back(world2.composition(position, 0, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 5));
+  approval_tests.emplace_back(world2.composition(position, 0, 6));
+
+  position = {{250e3,500e3,800e3}};
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 10));
+  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3 - 1));
+  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3 + 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 2));
+  approval_tests.emplace_back(world2.composition(position, 0, 3));
+  approval_tests.emplace_back(world2.composition(position, 10, 0));
+  approval_tests.emplace_back(world2.composition(position, 10, 1));
+  approval_tests.emplace_back(world2.composition(position, 10, 2));
+  approval_tests.emplace_back(world1.composition(position, 10, 3));
+  approval_tests.emplace_back(world1.composition(position, 10, 4));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 50e3 - 1, 3));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 50e3 - 1, 4));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 50e3 + 1, 3));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 50e3 + 1, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 5));
+  approval_tests.emplace_back(world2.composition(position, 0, 6));
+
+
+  position = {{250e3,250e3,800e3}};
+  approval_tests.emplace_back(world2.temperature(position, 0));
+  approval_tests.emplace_back(world2.temperature(position, 1));
+  approval_tests.emplace_back(world2.temperature(position, 5));
+  approval_tests.emplace_back(world2.temperature(position, 10));
+  approval_tests.emplace_back(world2.temperature(position, 100));
+  approval_tests.emplace_back(world2.temperature(position, 500));
+  approval_tests.emplace_back(world2.temperature(position, 1000));
+  approval_tests.emplace_back(world2.temperature(position, 5000));
+  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3/2));
+  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3 - 1));
+  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3 + 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 0));
+  approval_tests.emplace_back(world2.composition(position, 0, 1));
+  approval_tests.emplace_back(world2.composition(position, 0, 2));
+  approval_tests.emplace_back(world2.composition(position, 0, 3));
+  approval_tests.emplace_back(world2.composition(position, 10, 0));
+  approval_tests.emplace_back(world2.composition(position, 10, 1));
+  approval_tests.emplace_back(world2.composition(position, 10, 2));
+  approval_tests.emplace_back(world2.composition(position, 10, 3));
+
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 0));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 1));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 2));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 0));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 1));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 2));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 66e3 * 0.5 - 1, 1));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 66e3 * 0.5 + 1, 1));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 99e3 * 0.5 - 1, 2));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 99e3 * 0.5 + 1, 2));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 99e3 * 0.5 - 1, 3));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 99e3 * 0.5 + 1, 3));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 100e3 * 0.5 - 1, 3));
+  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 100e3 * 0.5 + 1, 3));
+  approval_tests.emplace_back(world2.composition(position, 0, 4));
+  approval_tests.emplace_back(world2.composition(position, 0, 5));
+  approval_tests.emplace_back(world2.composition(position, 0, 6));
+
+  position = {{250e3,250e3,800e3}};
+  approval_tests.emplace_back(world2.composition(position, 1, 0));
+  approval_tests.emplace_back(world2.composition(position, 1, 1));
+  approval_tests.emplace_back(world2.composition(position, 1, 2));
+  position = {{250e3,250e3-std::sqrt(2) * 33e3 * 0.5 + 1, 800e3}};
+  approval_tests.emplace_back(world2.composition(position, 1, 0));
+  approval_tests.emplace_back(world2.composition(position, 1, 1));
+  approval_tests.emplace_back(world2.composition(position, 1, 2));
+  position = {{250e3,250e3-std::sqrt(2) * 66e3 * 0.5 + 1, 800e3}};
+  approval_tests.emplace_back(world2.composition(position, 1, 0));
+  approval_tests.emplace_back(world2.composition(position, 1, 1));
+  approval_tests.emplace_back(world2.composition(position, 1, 2));
+  position = {{250e3,250e3-std::sqrt(2) * 99e3 * 0.5 + 1, 800e3}};
+  approval_tests.emplace_back(world2.composition(position, 1, 0));
+  approval_tests.emplace_back(world2.composition(position, 1, 1));
+  approval_tests.emplace_back(world2.composition(position, 1, 2));
+  approval_tests.emplace_back(world2.composition(position, 1, 3));
+
+
+  // Cartesian
+  file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_constant_angles_cartesian_2.wb";
+  WorldBuilder::World world3(file_name);
+
+  // Check fault directly (upper case should automatically turn into lower case).
+  const std::unique_ptr<Features::Interface> continental_plate = Features::Interface::create("Fault", &world3);
+
+  // Check fault through the world
+  position = {{0,0,800e3}};
+  approval_tests.emplace_back(world3.temperature(position, 0));
+  approval_tests.emplace_back(world3.temperature(position, 240e3));
+  approval_tests.emplace_back(world3.temperature(position, 260e3));
+  approval_tests.emplace_back(world3.composition(position, 0, 0));
+  approval_tests.emplace_back(world3.composition(position, 0, 1));
+  approval_tests.emplace_back(world3.composition(position, 0, 2));
+  approval_tests.emplace_back(world3.composition(position, 0, 3));
+  approval_tests.emplace_back(world3.composition(position, 0, 4));
+  approval_tests.emplace_back(world3.composition(position, 0, 5));
+  approval_tests.emplace_back(world3.composition(position, 0, 6));
+
+  position = {{250e3,500e3,800e3}};
+  //adibatic temperature
+  approval_tests.emplace_back(world3.temperature(position, 0));
+  approval_tests.emplace_back(world3.temperature(position, 1));
+  approval_tests.emplace_back(world3.temperature(position, 5000));
+  approval_tests.emplace_back(world3.temperature(position, 10e3));
+  approval_tests.emplace_back(world3.temperature(position, 25e3));
+  approval_tests.emplace_back(world3.temperature(position, 50e3));
+  approval_tests.emplace_back(world3.temperature(position, 75e3));
+  approval_tests.emplace_back(world3.temperature(position, 150e3));
+  //approval_tests.emplace_back(world3.temperature(position, std::sqrt(2) * 100e3 - 1));
+  //approval_tests.emplace_back(world3.temperature(position, std::sqrt(2) * 100e3 + 1));
+  approval_tests.emplace_back(world3.composition(position, 0, 0));
+  approval_tests.emplace_back(world3.composition(position, 0, 1));
+  approval_tests.emplace_back(world3.composition(position, 0, 2));
+  approval_tests.emplace_back(world3.composition(position, 0, 3));
+  approval_tests.emplace_back(world3.composition(position, 0, 4));
+  approval_tests.emplace_back(world3.composition(position, 10, 0));
+  approval_tests.emplace_back(world3.composition(position, 10, 1));
+  approval_tests.emplace_back(world3.composition(position, 10, 2));
+  approval_tests.emplace_back(world3.composition(position, 10, 3));
+  approval_tests.emplace_back(world3.composition(position, 10, 4));
+  //todo: recheck these results
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 16.5e3 - 1, 0));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 16.5e3 + 1, 0));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 16.5e3 - 1, 1));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 16.5e3 + 1, 1));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 - 1, 1));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 + 1, 1));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 - 1, 2));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 + 1, 2));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 + 1, 3));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 49.5e3 - 1, 2));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 49.5e3 - 1, 3));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 49.5e3 + 1, 2));
+  // this comes form the first subducting plate
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 49.5e3 + 1, 3));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 50e3 - 1, 3));
+  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 50e3 + 1, 3));
+  approval_tests.emplace_back(world3.composition(position, 0, 4));
+  approval_tests.emplace_back(world3.composition(position, 0, 5));
+  approval_tests.emplace_back(world3.composition(position, 0, 6));
+
+  {
+    const WorldBuilder::grains grains = world3.grains(position, std::sqrt(2) * 33e3 * 0.5 - 1, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{250e3,600e3,800e3}};
+  approval_tests.emplace_back(world3.temperature(position, 0));
+  approval_tests.emplace_back(world3.temperature(position, 10));
+  approval_tests.emplace_back(world3.temperature(position, 100e3-1));
+  approval_tests.emplace_back(world3.temperature(position, 100e3+1));
+  approval_tests.emplace_back(world3.temperature(position, 101e3));
+  approval_tests.emplace_back(world3.temperature(position, 110e3));
+  approval_tests.emplace_back(world3.temperature(position, 150e3));
+  approval_tests.emplace_back(world3.temperature(position, 200e3));
+  approval_tests.emplace_back(world3.composition(position, 0, 0));
+  approval_tests.emplace_back(world3.composition(position, 0, 1));
+  approval_tests.emplace_back(world3.composition(position, 0, 2));
+  approval_tests.emplace_back(world3.composition(position, 0, 3));
+  approval_tests.emplace_back(world3.composition(position, 10, 0));
+  approval_tests.emplace_back(world3.composition(position, 10, 1));
+  approval_tests.emplace_back(world3.composition(position, 10, 2));
+  approval_tests.emplace_back(world3.composition(position, 10, 3));
+  approval_tests.emplace_back(world3.composition(position, 100e3-1, 0));
+  approval_tests.emplace_back(world3.composition(position, 100e3-1, 1));
+  approval_tests.emplace_back(world3.composition(position, 100e3-1, 2));
+  approval_tests.emplace_back(world3.composition(position, 100e3-1, 3));
+  approval_tests.emplace_back(world3.composition(position, 100e3-1, 4));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 0));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 1));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 2));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 3));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 4));
+  approval_tests.emplace_back(world3.composition(position, 101e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 1));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 2));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 3));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 4));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 1));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 2));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 3));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 4));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 1));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 2));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 3));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 4));
+  approval_tests.emplace_back(world3.composition(position, 0, 4));
+  approval_tests.emplace_back(world3.composition(position, 0, 5));
+  approval_tests.emplace_back(world3.composition(position, 0, 6));
+
+  {
+    const WorldBuilder::grains grains = world3.grains(position, 101e3+1, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{650e3,650e3,800e3}};
+  approval_tests.emplace_back(world3.temperature(position, 0));
+  approval_tests.emplace_back(world3.temperature(position, 10));
+  approval_tests.emplace_back(world3.temperature(position, 100e3));
+  approval_tests.emplace_back(world3.temperature(position, 100e3+1));
+  approval_tests.emplace_back(world3.temperature(position, 101e3));
+  approval_tests.emplace_back(world3.temperature(position, 110e3));
+  approval_tests.emplace_back(world3.temperature(position, 150e3));
+  approval_tests.emplace_back(world3.temperature(position, 200e3));
+  approval_tests.emplace_back(world3.composition(position, 0, 0));
+  approval_tests.emplace_back(world3.composition(position, 0, 1));
+  approval_tests.emplace_back(world3.composition(position, 0, 2));
+  approval_tests.emplace_back(world3.composition(position, 0, 3));
+  approval_tests.emplace_back(world3.composition(position, 10, 0));
+  approval_tests.emplace_back(world3.composition(position, 10, 1));
+  approval_tests.emplace_back(world3.composition(position, 10, 2));
+  approval_tests.emplace_back(world3.composition(position, 10, 3));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 1));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 2));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 3));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 4));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 0));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 1));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 2));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 3));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 4));
+  approval_tests.emplace_back(world3.composition(position, 101e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 1));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 2));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 3));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 4));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 1));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 2));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 3));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 4));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 1));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 2));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 3));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 4));
+  approval_tests.emplace_back(world3.composition(position, 0, 4));
+  approval_tests.emplace_back(world3.composition(position, 0, 5));
+  approval_tests.emplace_back(world3.composition(position, 0, 6));
+
+  {
+    const WorldBuilder::grains grains = world3.grains(position, 100e3+1, 0, 3);
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  position = {{700e3,675e3,800e3}};
+  approval_tests.emplace_back(world3.temperature(position, 0));
+  approval_tests.emplace_back(world3.temperature(position, 10));
+  approval_tests.emplace_back(world3.temperature(position, 100e3));
+  approval_tests.emplace_back(world3.temperature(position, 100e3+1));
+  approval_tests.emplace_back(world3.temperature(position, 101e3));
+  approval_tests.emplace_back(world3.temperature(position, 110e3));
+  approval_tests.emplace_back(world3.temperature(position, 150e3));
+  approval_tests.emplace_back(world3.temperature(position, 200e3));
+  approval_tests.emplace_back(world3.composition(position, 0, 0));
+  approval_tests.emplace_back(world3.composition(position, 0, 1));
+  approval_tests.emplace_back(world3.composition(position, 0, 2));
+  approval_tests.emplace_back(world3.composition(position, 0, 3));
+  approval_tests.emplace_back(world3.composition(position, 10, 0));
+  approval_tests.emplace_back(world3.composition(position, 10, 1));
+  approval_tests.emplace_back(world3.composition(position, 10, 2));
+  approval_tests.emplace_back(world3.composition(position, 10, 3));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 1));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 2));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 3));
+  approval_tests.emplace_back(world3.composition(position, 100e3, 4));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 0));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 1));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 2));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 3));
+  approval_tests.emplace_back(world3.composition(position, 100e3+1, 4));
+  approval_tests.emplace_back(world3.composition(position, 101e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 1));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 2));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 3));
+  approval_tests.emplace_back(world3.composition(position, 101e3+1, 4));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 1));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 2));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 3));
+  approval_tests.emplace_back(world3.composition(position, 150e3, 4));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 0));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 1));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 2));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 3));
+  approval_tests.emplace_back(world3.composition(position, 200e3, 4));
+  approval_tests.emplace_back(world3.composition(position, 0, 4));
+  approval_tests.emplace_back(world3.composition(position, 0, 5));
+  approval_tests.emplace_back(world3.composition(position, 0, 6));
+
+  position = {{750e3,35e3,800e3}};
+  approval_tests.emplace_back(world3.temperature(position, 0));
+  approval_tests.emplace_back(world3.temperature(position, 10));
+  approval_tests.emplace_back(world3.temperature(position, 5e3));
+  approval_tests.emplace_back(world3.temperature(position, 10e3));
+  approval_tests.emplace_back(world3.temperature(position, 15e3));
+  approval_tests.emplace_back(world3.temperature(position, 20e3));
+  approval_tests.emplace_back(world3.temperature(position, 25e3));
+  approval_tests.emplace_back(world3.temperature(position, 30e3));
+  approval_tests.emplace_back(world3.temperature(position, 35e3));
+  approval_tests.emplace_back(world3.temperature(position, 40e3));
+  approval_tests.emplace_back(world3.temperature(position, 45e3));
+  approval_tests.emplace_back(world3.temperature(position, 50e3));
+  approval_tests.emplace_back(world3.temperature(position, 55e3));
+  approval_tests.emplace_back(world3.temperature(position, 60e3));
+  approval_tests.emplace_back(world3.temperature(position, 65e3));
+  approval_tests.emplace_back(world3.temperature(position, 70e3));
+  approval_tests.emplace_back(world3.temperature(position, 72.5e3));
+  approval_tests.emplace_back(world3.temperature(position, 75e3));
+  approval_tests.emplace_back(world3.temperature(position, 80e3));
+  approval_tests.emplace_back(world3.temperature(position, 85e3));
+  approval_tests.emplace_back(world3.temperature(position, 90e3));
+  approval_tests.emplace_back(world3.temperature(position, 95e3));
+  approval_tests.emplace_back(world3.temperature(position, 100e3));
+  approval_tests.emplace_back(world3.temperature(position, 105e3));
+  approval_tests.emplace_back(world3.temperature(position, 110e3));
+  approval_tests.emplace_back(world3.temperature(position, 115e3));
+  approval_tests.emplace_back(world3.temperature(position, 120e3));
+  approval_tests.emplace_back(world3.temperature(position, 125e3));
+  approval_tests.emplace_back(world3.temperature(position, 130e3));
+  approval_tests.emplace_back(world3.temperature(position, 135e3));
+  approval_tests.emplace_back(world3.temperature(position, 150e3));
+  approval_tests.emplace_back(world3.temperature(position, 160e3));
+  approval_tests.emplace_back(world3.temperature(position, 170e3));
+  approval_tests.emplace_back(world3.temperature(position, 175e3));
+  approval_tests.emplace_back(world3.temperature(position, 180e3));
+  approval_tests.emplace_back(world3.temperature(position, 190e3));
+  approval_tests.emplace_back(world3.temperature(position, 200e3));
+  approval_tests.emplace_back(world3.temperature(position, 250e3));
+  approval_tests.emplace_back(world3.temperature(position, 300e3));
+
+  // check grains layer 1
+  {
+    const WorldBuilder::grains grains = world3.grains(position, 95e3, 0, 2);
+    // these are random numbers, but they should stay the same.
+    // note that the values are different from for example the continental plate since
+    // this performs a interpolation between segments of the slab.
+    approval_tests_grains.emplace_back(grains);
+  }
+
+  // check grains layer 2 bottom (because of the randomness it will have different values.)
+  {
+    const WorldBuilder::grains grains = world3.grains(position, 150e3, 0, 2);
+    approval_tests_grains.emplace_back(grains);
+
+  }
+
+  // check grains layer 2 top
+  {
+    const WorldBuilder::grains grains = world3.grains(position, 35e3, 0, 2);
+    approval_tests_grains.emplace_back(grains);
+    //compare_vectors_approx(grains.sizes, {0.3512381923,0.6487618077});
+    //approval_tests.emplace_back(grains.sizes[0] + grains.sizes[1]);
+    //// these are random numbers, but they should stay the same.
+//
+    //std::array<std::array<double, 3>, 3> array_1 = {{{{-0.5760272563,-0.3302260164,0.7477589038}},{{-0.3927671635,-0.6904395086,-0.6074761232}},{{0.7168867103,-0.6436179481,0.26801004}}}};
+    //std::array<std::array<double, 3>, 3> array_2 = {{{{0.7622618339,-0.3280663618,0.5579689586}},{{-0.2767873192,-0.9444558064,-0.1771779043}},{{0.5851031332,-0.01938277797,-0.8107272238}}}};
+    //std::vector<std::array<std::array<double, 3>, 3> > vector_1 = {array_1,array_2};
+    //compare_vectors_array3_array3_approx(grains.rotation_matrices, vector_1);
+  }
+
+
+  file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_different_angles_cartesian.wb";
+  const WorldBuilder::World world4(file_name);
+
+  position = {{250e3,501e3,800e3}};
+  approval_tests.emplace_back(world4.temperature(position, 0));
+  approval_tests.emplace_back(world4.composition(position, 0, 0));
+  approval_tests.emplace_back(world4.temperature(position, 1));
+  approval_tests.emplace_back(world4.composition(position, 1, 0));
+  approval_tests.emplace_back(world4.temperature(position, 1e3));
+  approval_tests.emplace_back(world4.composition(position, 1e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 10e3));
+  approval_tests.emplace_back(world4.composition(position, 10e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 20e3));
+  approval_tests.emplace_back(world4.composition(position, 20e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 30e3));
+  approval_tests.emplace_back(world4.composition(position, 30e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 35e3));
+  approval_tests.emplace_back(world4.composition(position, 35e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 40e3));
+  approval_tests.emplace_back(world4.composition(position, 40e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 45e3));
+  approval_tests.emplace_back(world4.composition(position, 45e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 50e3));
+  approval_tests.emplace_back(world4.composition(position, 50e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 60e3));
+  approval_tests.emplace_back(world4.composition(position, 60e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 80e3));
+  approval_tests.emplace_back(world4.composition(position, 80e3, 0));
+  approval_tests.emplace_back(world4.temperature(position, 100e3));
+  approval_tests.emplace_back(world4.composition(position, 100e3, 0));
+
+  std::vector<std::string> approvals;
+  for (auto&& value : approval_tests)
+    {
+      std::stringstream s;
+      s << value;
+      approvals.emplace_back(s.str());
+    }
+  for (auto&& value : approval_tests_grains)
+    {
+      std::stringstream s;
+      s << value << " ";
+      approvals.emplace_back(s.str());
+    }
+  ApprovalTests::Approvals::verifyAll("Test", approvals);
+}
+
+TEST_CASE("WorldBuilder Features: coordinate interpolation")
+{
+  std::vector<double> approval_tests;
+
+  {
+    const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/interpolation_monotone_spline_cartesian.wb";
+    const WorldBuilder::World world1(file_name);
+
+    std::array<double,3> position = {{374e3,875e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+    position = {{376e3,875e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+    position = {{350e3,900e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+
+    position = {{375e3,874e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+    position = {{375e3,876e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+
+
+    position = {{374e3,625e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+    position = {{376e3,625e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+    position = {{350e3,600e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+
+    position = {{375e3,624e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+    position = {{375e3,626e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 0));
+    approval_tests.emplace_back(world1.composition(position, 0, 0));
+
+
+    position = {{638e3,425e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 10));
+    approval_tests.emplace_back(world1.composition(position, 10, 0));
+    position = {{637e3,425e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 10));
+    approval_tests.emplace_back(world1.composition(position, 10, 0));
+    position = {{617.5e3,445e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 1e3));
+    approval_tests.emplace_back(world1.composition(position, 1e3, 0));
+
+    position = {{625e3,200e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 10));
+    approval_tests.emplace_back(world1.composition(position, 10, 0));
+    position = {{624e3,200e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 10));
+    approval_tests.emplace_back(world1.composition(position, 10, 0));
+    position = {{607e3,180e3,800e3}};
+    approval_tests.emplace_back(world1.temperature(position, 3e3));
+    approval_tests.emplace_back(world1.composition(position, 3e3, 0));
+  }
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+TEST_CASE("WorldBuilder Types: Double")
+{
+#define TYPE Double
+  Types::TYPE const type(1);
+  CHECK(type.default_value == Approx(1.0));
+  CHECK(type.get_type() == Types::type::TYPE);
+
+  Types::TYPE const &type_copy(type);
+  CHECK(type_copy.default_value == Approx(1.0));
+  CHECK(type_copy.get_type() == Types::type::TYPE);
+
+  Types::TYPE const type_explicit(3);
+  CHECK(type_explicit.default_value == Approx(3.0));
+  CHECK(type_explicit.get_type() == Types::type::TYPE);
+
+  const std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->default_value == Approx(3.0));
+  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
+#undef TYPE
+}
+
+/*TEST_CASE("WorldBuilder Types: UnsignedInt")
+{
+#define TYPE UnsignedInt
+  Types::TYPE type(1,"test");
+  CHECK(type.value == Approx(1.0));
+  CHECK(type.default_value == Approx(1.0));
+  CHECK(type.description == "test");
+  CHECK(type.get_type() == Types::type::TYPE);
+  Types::TYPE type_copy(type);
+  CHECK(type_copy.value == Approx(1.0));
+  CHECK(type_copy.default_value == Approx(1.0));
+  CHECK(type_copy.description == "test");
+  CHECK(type_copy.get_type() == Types::type::TYPE);
+  Types::TYPE type_explicit(2, 3, "test explicit");
+  CHECK(type_explicit.value == Approx(2.0));
+  CHECK(type_explicit.default_value == Approx(3.0));
+  CHECK(type_explicit.description == "test explicit");
+  CHECK(type_explicit.get_type() == Types::type::TYPE);
+  std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->value == Approx(2.0));
+  CHECK(type_clone_natural->default_value == Approx(3.0));
+  CHECK(type_clone_natural->description == "test explicit");
+  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
+#undef TYPE
+}*/
+
+TEST_CASE("WorldBuilder Types: String")
+{
+#define TYPE String
+  Types::TYPE const type("1","test");
+  CHECK(type.default_value == "1");
+  CHECK(type.get_type() == Types::type::TYPE);
+
+  Types::TYPE const &type_copy(type);
+  CHECK(type_copy.default_value == "1");
+  CHECK(type_copy.get_type() == Types::type::TYPE);
+
+  Types::TYPE const type_explicit("2", "3", "test explicit");
+  CHECK(type_explicit.default_value == "3");
+  CHECK(type_explicit.get_type() == Types::type::TYPE);
+
+  const std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->default_value == "3");
+  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
+#undef TYPE
+}
+
+TEST_CASE("WorldBuilder Types: Point 2d")
+{
+#define TYPE Point<2>
+  Types::TYPE type(TYPE(1,2,cartesian),"test");
+  CHECK(type.value[0] == Approx(TYPE(1,2,cartesian)[0]));
+  CHECK(type.value[1] == Approx(TYPE(1,2,cartesian)[1]));
+  CHECK(type.default_value[0] == Approx(TYPE(1,2,cartesian)[0]));
+  CHECK(type.default_value[1] == Approx(TYPE(1,2,cartesian)[1]));
+  CHECK(type.description == "test");
+  CHECK(type.get_type() == Types::type::Point2D);
+
+  Types::TYPE type_copy(type);
+  CHECK(type_copy.value[0] == Approx(TYPE(1,2,cartesian)[0]));
+  CHECK(type_copy.value[1] == Approx(TYPE(1,2,cartesian)[1]));
+  CHECK(type.default_value[0] == Approx(TYPE(1,2,cartesian)[0]));
+  CHECK(type.default_value[1] == Approx(TYPE(1,2,cartesian)[1]));
+  CHECK(type_copy.description == "test");
+  CHECK(type_copy.get_type() == Types::type::Point2D);
+
+  Types::TYPE type_explicit(TYPE(3,4,cartesian), TYPE(5,6,cartesian), "test explicit");
+  CHECK(type_explicit.value[0] == Approx(TYPE(3,4,cartesian)[0]));
+  CHECK(type_explicit.value[1] == Approx(TYPE(3,4,cartesian)[1]));
+  CHECK(type_explicit.default_value[0] == Approx(TYPE(5,6,cartesian)[0]));
+  CHECK(type_explicit.default_value[1] == Approx(TYPE(5,6,cartesian)[1]));
+  CHECK(type_explicit.description == "test explicit");
+  CHECK(type_explicit.get_type() == Types::type::Point2D);
+
+  const std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->value[0] == Approx(TYPE(3,4,cartesian)[0]));
+  CHECK(type_clone_natural->value[1] == Approx(TYPE(3,4,cartesian)[1]));
+  CHECK(type_clone_natural->default_value[0] == Approx(TYPE(5,6,cartesian)[0]));
+  CHECK(type_clone_natural->default_value[1] == Approx(TYPE(5,6,cartesian)[1]));
+  CHECK(type_clone_natural->description == "test explicit");
+  CHECK(type_clone_natural->get_type() == Types::type::Point2D);
+
+
+
+  // Test Point operators
+
+  const TYPE point_array(std::array<double,2> {{1,2}},cartesian);
+  const TYPE point_explicit(3,4,cartesian);
+
+  Types::TYPE type_point_array(point_array, point_array, "test array");
+  const Types::TYPE type_point_array_const(point_array, point_array, "test array");
+  Types::TYPE const type_point_explicit(point_explicit, point_explicit, "test array");
+
+  CHECK(type_point_array.value.get_array() == std::array<double,2> {{1,2}});
+  CHECK(type_point_explicit.value.get_array() == std::array<double,2> {{3,4}});
+
+  // Test multiply operator
+  TYPE point = 2 * type_point_array * 1.0;
+
+  CHECK(point.get_array() == std::array<double,2> {{2,4}});
+
+  // Test dot operator
+  CHECK(type_point_array * type_point_explicit == Approx(11.0));
+
+  // Test add operator
+  point = type_point_array + type_point_explicit;
+
+  CHECK(point.get_array() == std::array<double,2> {{4,6}});
+
+  // Test subtract operator
+  point = type_point_explicit - type_point_array;
+
+  CHECK(point.get_array() == std::array<double,2> {{2,2}});
+
+  // test the access operator
+  CHECK(type_point_array[0] == Approx(1.0));
+
+  type_point_array[0] = 2;
+  CHECK(type_point_array[0] == Approx(2.0));
+
+  // test the access operator
+  CHECK(type_point_array_const[0] == Approx(1.0));
+  CHECK(type_point_array_const[1] == Approx(2.0));
+
+  // Test the point output stream.
+  std::ostringstream stream;
+  stream << point_array;
+  const std::string str =  stream.str();
+  CHECK(str == "1 2");
+#undef TYPE
+}
+
+TEST_CASE("WorldBuilder Types: Point 3d")
+{
+#define TYPE Point<3>
+  Types::TYPE type(TYPE(1,2,3,cartesian),"test");
+  const double &value_0 = type.value[0];
+  CHECK(value_0 == Approx(1.0));
+  CHECK(type.value[1] == Approx(2.0));
+  CHECK(type.value[2] == Approx(3.0));
+  CHECK(type.default_value[0] == Approx(1.0));
+  CHECK(type.default_value[1] == Approx(2.0));
+  CHECK(type.default_value[2] == Approx(3.0));
+  CHECK(type.description == "test");
+  CHECK(type.get_type() == Types::type::Point3D);
+
+  Types::TYPE type_copy(type);
+  CHECK(type_copy.value[0] == Approx(1.0));
+  CHECK(type_copy.value[1] == Approx(2.0));
+  CHECK(type_copy.value[2] == Approx(3.0));
+  CHECK(type_copy.default_value[0] == Approx(1.0));
+  CHECK(type_copy.default_value[1] == Approx(2.0));
+  CHECK(type_copy.default_value[2] == Approx(3.0));
+  CHECK(type_copy.description == "test");
+  CHECK(type_copy.get_type() == Types::type::Point3D);
+
+  Types::TYPE type_explicit(TYPE(4,5,6,cartesian), TYPE(7,8,9,cartesian), "test explicit");
+  CHECK(type_explicit.value[0] == Approx(4.0));
+  CHECK(type_explicit.value[1] == Approx(5.0));
+  CHECK(type_explicit.value[2] == Approx(6.0));
+  CHECK(type_explicit.default_value[0] == Approx(7.0));
+  CHECK(type_explicit.default_value[1] == Approx(8.0));
+  CHECK(type_explicit.default_value[2] == Approx(9.0));
+  CHECK(type_explicit.description == "test explicit");
+  CHECK(type_explicit.get_type() == Types::type::Point3D);
+
+  const std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->value[0] == Approx(4.0));
+  CHECK(type_clone_natural->value[1] == Approx(5.0));
+  CHECK(type_clone_natural->value[2] == Approx(6.0));
+  CHECK(type_clone_natural->default_value[0] == Approx(7.0));
+  CHECK(type_clone_natural->default_value[1] == Approx(8.0));
+  CHECK(type_clone_natural->default_value[2] == Approx(9.0));
+  CHECK(type_clone_natural->description == "test explicit");
+  CHECK(type_clone_natural->get_type() == Types::type::Point3D);
+
+
+  // Test Point operators
+
+  const TYPE point_array(std::array<double,3> {{1,2,3}},cartesian);
+  const TYPE point_explicit(4,5,6,cartesian);
+
+  Types::TYPE type_point_array(point_array, point_array, "test array");
+  const Types::TYPE type_point_array_const(point_array, point_array, "test array");
+  Types::TYPE const type_point_explicit(point_explicit, point_explicit, "test array");
+
+  CHECK(type_point_array.value.get_array() == std::array<double,3> {{1,2,3}});
+  CHECK(type_point_explicit.value.get_array() == std::array<double,3> {{4,5,6}});
+
+  // Test multiply operator
+  TYPE point = 2 * type_point_array;
+
+  CHECK(point.get_array() == std::array<double,3> {{2,4,6}});
+
+  // Test multiply operator
+  point = type_point_array * 2;
+
+  CHECK(point.get_array() == std::array<double,3> {{2,4,6}});
+
+  // Test dot operator
+  CHECK(type_point_array * type_point_explicit == Approx(32.0));
+
+  // Test add operator
+  point = type_point_array + type_point_explicit;
+
+  CHECK(point.get_array() == std::array<double,3> {{5,7,9}});
+
+  // Test subtract operator
+  point = type_point_explicit - type_point_array;
+
+  CHECK(point.get_array() == std::array<double,3> {{3,3,3}});
+
+  // test the access operator
+  CHECK(type_point_array[0] == Approx(1.0));
+
+  type_point_array[0] = 2;
+  CHECK(type_point_array[0] == Approx(2.0));
+
+  // const test the access operator
+  CHECK(point_array[0] == Approx(1.0));
+
+  // test the const access operator
+  CHECK(type_point_array_const[0] == Approx(1.0));
+  CHECK(type_point_array_const[1] == Approx(2.0));
+  CHECK(type_point_array_const[2] == Approx(3.0));
+
+  // Test the point output stream.
+  std::ostringstream stream;
+  stream << point_array;
+  const std::string str =  stream.str();
+  CHECK(str == "1 2 3");
+
+#undef TYPE
+}
+/*
+TEST_CASE("WorldBuilder Types: Coordinate System")
+{
+#define TYPE CoordinateSystem
+  Types::TYPE type("1","test");
+  CHECK(type.value == nullptr);
+  CHECK(type.default_value == "1");
+  CHECK(type.description == "test");
+  CHECK(type.get_type() == Types::type::TYPE);
+  std::unique_ptr<Types::Interface> type_clone = type.clone();
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->value == nullptr);
+  CHECK(type_clone_natural->default_value == "1");
+  CHECK(type_clone_natural->description == "test");
+  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
+  // todo: test the set value function.
+#undef TYPE
+}*/
+
+// not sure how to unit test this.
+TEST_CASE("WorldBuilder Types: PluginSystem")
+{
+#define TYPE PluginSystem
+  Types::TYPE type("test", Features::ContinentalPlate::declare_entries, std::vector<std::string> {{"test required"}}, false);
+  CHECK(type.default_value == "test");
+  CHECK(type.required_entries[0] == "test required");
+  CHECK(type.allow_multiple == false);
+  CHECK(type.get_type() == Types::type::TYPE);
+
+  Types::TYPE type_copy(type);
+  CHECK(type_copy.default_value == "test");
+  CHECK(type_copy.required_entries[0] == "test required");
+  CHECK(type_copy.allow_multiple == false);
+  CHECK(type_copy.get_type() == Types::type::TYPE);
+
+  const std::unique_ptr<Types::Interface> type_clone = type_copy.clone();
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->default_value == "test");
+  CHECK(type_clone_natural->required_entries[0] == "test required");
+  CHECK(type_clone_natural->allow_multiple == false);
+  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
+
+#undef TYPE
+}
+
+
+// not sure how to unit test this.
+TEST_CASE("WorldBuilder Types: Segment Object")
+{
+#define TYPE Segment
+  const WorldBuilder::Point<2> thickness(1,2,invalid);
+  const WorldBuilder::Point<2> top_trucation(3,4,invalid);
+  const WorldBuilder::Point<2> angle(5,6,invalid);
+  Objects::TYPE<Features::FaultModels::Temperature::Interface, Features::FaultModels::Composition::Interface, Features::FaultModels::Grains::Interface>
+  type (1.0, thickness, top_trucation, angle,
+        std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> >(),
+        std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface> >(),
+        std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface> >());
+  CHECK(type.value_length == Approx(1.0));
+  CHECK(type.value_thickness[0] == Approx(1.0));
+  CHECK(type.value_thickness[1] == Approx(2.0));
+  CHECK(type.value_top_truncation[0] == Approx(3.0));
+  CHECK(type.value_top_truncation[1] == Approx(4.0));
+  CHECK(type.value_angle[0] == Approx(5.0));
+  CHECK(type.value_angle[1] == Approx(6.0));
+
+  Objects::TYPE<Features::FaultModels::Temperature::Interface, Features::FaultModels::Composition::Interface, Features::FaultModels::Grains::Interface>
+  type_copy(type);
+  const double &value_length = type_copy.value_length;
+  CHECK(value_length == Approx(1.0));
+  CHECK(type_copy.value_thickness[0] == Approx(1.0));
+  CHECK(type_copy.value_thickness[1] == Approx(2.0));
+  CHECK(type_copy.value_top_truncation[0] == Approx(3.0));
+  CHECK(type_copy.value_top_truncation[1] == Approx(4.0));
+  CHECK(type_copy.value_angle[0] == Approx(5.0));
+  CHECK(type_copy.value_angle[1] == Approx(6.0));
+
+#undef TYPE
+}
+
+TEST_CASE("WorldBuilder Types: Array")
+{
+#define TYPE Array
+  Types::TYPE const type(Types::Double(0));
+  CHECK(type.inner_type == Types::type::Double);
+  CHECK(type.inner_type_ptr.get() != nullptr);
+  CHECK(type.get_type() == Types::type::TYPE);
+
+  Types::TYPE const &type_copy(type);
+  CHECK(type_copy.inner_type == Types::type::Double);
+  CHECK(type_copy.inner_type_ptr.get() != nullptr);
+  CHECK(type_copy.get_type() == Types::type::TYPE);
+
+  /*Types::TYPE type_explicit(std::vector<unsigned int> {1,2}, Types::type::Double, "array test explicit");
+  CHECK(type_explicit.inner_type == Types::type::Double);
+  CHECK(type_explicit.inner_type_ptr.get() == nullptr);
+  CHECK(type_explicit.inner_type_index.size() == 2);
+  CHECK(type_explicit.description == "array test explicit");
+  CHECK(type_explicit.get_type() == Types::type::TYPE);*/
+
+  //CHECK_THROWS_WITH(type.clone(),Contains("Error: Cloning Arrays is currently not possible."));
+  /*
+  std::unique_ptr<Types::Interface> type_clone = type_explicit.clone()
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->inner_type == Types::type::Double);
+  CHECK(type_clone_natural->inner_type_ptr.get() == nullptr);
+  CHECK(type_clone_natural->inner_type_index.size() == 2);
+  CHECK(type_clone_natural->description == "array test explicit");
+  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
+  Types::TYPE type_copy2(*type_clone_natural);
+  CHECK(type_copy2.inner_type == Types::type::Double);
+  CHECK(type_copy2.inner_type_ptr.get() == nullptr);
+  CHECK(type_copy2.inner_type_index.size() == 2);
+  CHECK(type_copy2.description == "array test explicit");
+  CHECK(type_copy2.get_type() == Types::type::TYPE);*/
+
+#undef TYPE
+}
+
+TEST_CASE("WorldBuilder Types: Object")
+{
+#define TYPE Object
+  Types::TYPE type(std::vector<std::string> {"test1","test2"},true);
+  CHECK(type.required.size() == 2);
+  CHECK(type.required[0] == "test1");
+  CHECK(type.required[1] == "test2");
+  CHECK(type.additional_properties == true);
+  CHECK(type.get_type() == Types::type::TYPE);
+
+  Types::TYPE type_copy(type);
+  CHECK(type_copy.required.size() == 2);
+  CHECK(type_copy.required[0] == "test1");
+  CHECK(type_copy.required[1] == "test2");
+  CHECK(type_copy.additional_properties == true);
+  CHECK(type_copy.get_type() == Types::type::TYPE);
+
+  const std::unique_ptr<Types::Interface> type_clone = type_copy.clone();
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->required.size() == 2);
+  CHECK(type_clone_natural->required[0] == "test1");
+  CHECK(type_clone_natural->required[1] == "test2");
+  CHECK(type_clone_natural->additional_properties == true);
+  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
+
+  Types::TYPE type_copy2(*type_clone_natural);
+  CHECK(type_copy2.required.size() == 2);
+  CHECK(type_copy2.required[0] == "test1");
+  CHECK(type_copy2.required[1] == "test2");
+  CHECK(type_copy2.additional_properties == true);
+  CHECK(type_copy2.get_type() == Types::type::TYPE);
+
+#undef TYPE
+}
+
+
+TEST_CASE("WorldBuilder Types: Bool")
+{
+#define TYPE Bool
+  Types::TYPE const type(true);
+  CHECK(type.default_value == true);
+  CHECK(type.get_type() == Types::type::TYPE);
+
+
+  Types::TYPE const &type_copy(type);
+  CHECK(type_copy.default_value == true);
+  CHECK(type_copy.get_type() == Types::type::TYPE);
+
+  const std::unique_ptr<Types::Interface> type_clone = type_copy.clone();
+  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
+  CHECK(type_clone_natural->default_value == true);
+  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
+
+  Types::TYPE const type_copy2(*type_clone_natural);
+  CHECK(type_copy2.default_value == true);
+  CHECK(type_copy2.get_type() == Types::type::TYPE);
+
+#undef TYPE
+}
+
+/*
+TEST_CASE("WorldBuilder Types: print_tree")
+{
+  std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb1.json";
+  boost::property_tree::ptree tree;
+  std::ifstream json_input_stream(file_name.c_str());
+
+  boost::property_tree::json_parser::read_json (json_input_stream, tree);
+  std::stringstream output;
+  output <<
+         "{\n"
+         "  \"version\": \"0.1\",\n"
+         "  \"coordinate system\": \n"
+         "  {\n"
+         "    \"model\": \"cartesian\"\n"
+         "   },\n"
+         "  \"cross section\": \n"
+         "  {\n"
+         "    \"\": \n"
+         "    {\n"
+         "      \"\": \"100e3\",\n"
+         "      \"\": \"100e3\"\n"
+         "     },\n"
+         "    \"\": \n"
+         "    {\n"
+         "      \"\": \"400e3\",\n"
+         "      \"\": \"500e3\"\n"
+         "     }\n"
+         "   },\n"
+         "  \"maximum distance between coordinates\": \"5\",\n"
+         "  \"features\": \n"
+         "  {\n"
+         "    \"\": \n"
+         "    {\n"
+         "      \"model\": \"continental plate\",\n"
+         "      \"name\": \"Caribbean\",\n"
+         "      \"max depth\": \"300e3\",\n"
+         "      \"coordinates\": \n"
+         "      {\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"-1e3\",\n"
+         "          \"\": \"500e3\"\n"
+         "         },\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"500e3\",\n"
+         "          \"\": \"500e3\"\n"
+         "         },\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"500e3\",\n"
+         "          \"\": \"1000e3\"\n"
+         "         },\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"-1e3\",\n"
+         "          \"\": \"1000e3\"\n"
+         "         }\n"
+         "       },\n"
+         "      \"temperature models\": \n"
+         "      {\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"model\": \"uniform\",\n"
+         "          \"min depth\": \"0\",\n"
+         "          \"max depth\": \"250e3\",\n"
+         "          \"temperature\": \"150\"\n"
+         "         }\n"
+         "       }\n"
+         "     },\n"
+         "    \"\": \n"
+         "    {\n"
+         "      \"model\": \"continental plate\",\n"
+         "      \"name\": \"Rest\",\n"
+         "      \"max depth\": \"300e3\",\n"
+         "      \"coordinates\": \n"
+         "      {\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"2000e3\",\n"
+         "          \"\": \"2000e3\"\n"
+         "         },\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"1000e3\",\n"
+         "          \"\": \"2000e3\"\n"
+         "         },\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"1000e3\",\n"
+         "          \"\": \"1000e3\"\n"
+         "         },\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"2000e3\",\n"
+         "          \"\": \"1000e3\"\n"
+         "         }\n"
+         "       },\n"
+         "      \"temperature models\": \n"
+         "      {\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"model\": \"uniform\",\n"
+         "          \"max depth\": \"250e3\",\n"
+         "          \"temperature\": \"20\"\n"
+         "         }\n"
+         "       },\n"
+         "      \"composition models\": \n"
+         "      {\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"model\": \"uniform\",\n"
+         "          \"max depth\": \"250e3\",\n"
+         "          \"compositions\": \n"
+         "          {\n"
+         "            \"\": \"2\"\n"
+         "           }\n"
+         "         }\n"
+         "       }\n"
+         "     },\n"
+         "    \"\": \n"
+         "    {\n"
+         "      \"model\": \"continental plate\",\n"
+         "      \"name\": \"Caribbean2\",\n"
+         "      \"max depth\": \"300e3\",\n"
+         "      \"coordinates\": \n"
+         "      {\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"-1e3\",\n"
+         "          \"\": \"500e3\"\n"
+         "         },\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"500e3\",\n"
+         "          \"\": \"500e3\"\n"
+         "         },\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"500e3\",\n"
+         "          \"\": \"1000e3\"\n"
+         "         },\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"\": \"-1e3\",\n"
+         "          \"\": \"1000e3\"\n"
+         "         }\n"
+         "       },\n"
+         "      \"temperature models\": \n"
+         "      {\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"model\": \"uniform\",\n"
+         "          \"min depth\": \"0\",\n"
+         "          \"max depth\": \"250e3\",\n"
+         "          \"temperature\": \"150\"\n"
+         "         }\n"
+         "       },\n"
+         "      \"composition models\": \n"
+         "      {\n"
+         "        \"\": \n"
+         "        {\n"
+         "          \"model\": \"uniform\",\n"
+         "          \"min depth\": \"0\",\n"
+         "          \"max depth\": \"250e3\",\n"
+         "          \"compositions\": \n"
+         "          {\n"
+         "            \"\": \"3\"\n"
+         "           }\n"
+         "         }\n"
+         "       }\n"
+         "     }\n"
+         "   }\n"
+         " }";
+  approval_tests.emplace_back(Utilities::print_tree(tree, 0));
+}*/
+
+TEST_CASE("WorldBuilder Parameters")
+{
+  std::vector<double> approval_tests;
+
+  // First test a world builder file with a cross section defined
+  std::string file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/type_data.json";
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian.wb";
+  WorldBuilder::World world(file_name);
+
+  world.parse_entries(world.parameters);
+  approval_tests.emplace_back(std::isinf(world.parameters.coordinate_system->max_model_depth()));
+
+  Parameters prm(world);
+  prm.initialize(file);
+
+  world.parameters.coordinate_system.swap(prm.coordinate_system);
+
+  CHECK_THROWS_WITH(prm.get<unsigned int>("non existent unsigned int"),
+                    Contains("internal error: could not retrieve the default value at"));
+
+  CHECK(prm.get<unsigned int>("unsigned int") == 4);
+
+  CHECK_THROWS_WITH(prm.get<size_t>("non existent unsigned int"),
+                    Contains("internal error: could not retrieve the default value at"));
+
+  CHECK(prm.get<size_t>("unsigned int") == 4);
+
+
+  CHECK_THROWS_WITH(prm.get<double>("non existent double"),
+                    Contains("internal error: could not retrieve the default value at"));
+
+  CHECK(prm.get<double>("double") == Approx(1.23456e2));
+
+
+  CHECK_THROWS_WITH(prm.get<double>("string"),
+                    Contains("Could not convert values of"));
+
+  CHECK_THROWS_WITH(prm.get<std::string>("non existent string"),
+                    Contains("internal error: could not retrieve the default value at"));
+
+  CHECK(prm.get<std::string>("string") == "mystring 0");
+  prm.enter_subsection("properties");
+
+  {
+    WorldBuilder::World world_temp(file_name);
+    Parameters prm_temp(world_temp);
+    prm_temp.declare_entry("test",Types::OneOf(Types::OneOf(Types::Double(101),Types::Double(102)),Types::Double(103)),"doc");
+
+    CHECK(rapidjson::Pointer("/test/oneOf/0/oneOf/0/default value").Get(prm_temp.declarations)->GetDouble() == Approx(101.));
+    CHECK(rapidjson::Pointer("/test/oneOf/0/oneOf/1/default value").Get(prm_temp.declarations)->GetDouble() == Approx(102.));
+    CHECK(rapidjson::Pointer("/test/oneOf/1/default value").Get(prm_temp.declarations)->GetDouble() == Approx(103.));
+  }
+  prm.declare_entry("one value at points one value string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
+                    "Documentation");
+  prm.declare_entry("array value at points one value string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
+                    "Documentation");
+  prm.declare_entry("value at points set ap val string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
+                    "Documentation");
+  prm.declare_entry("value at points set ap p1 string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
+                    "Documentation");
+  prm.declare_entry("value at points set ap p2 string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
+                    "Documentation");
+  prm.declare_entry("one value at points one value",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
+                    "Documentation");
+  prm.declare_entry("array value at points one value",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
+                    "Documentation");
+  prm.declare_entry("value at points",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
+                    "Documentation");
+  prm.declare_entry("value at points default ap",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
+                    "Documentation");
+  prm.declare_entry("value at array full",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., std::numeric_limits<uint64_t>::max()))),
+                    "Documentation");
+  prm.declare_entry("value at array",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., std::numeric_limits<uint64_t>::max()))),
+                    "Documentation");
+  prm.declare_entry("vector for vector or double", Types::OneOf(Types::Double(-1), Types::Array(Types::Array(Types::Double(-1), 1), 1)),
+                    "Documentation");
+  prm.leave_subsection();
+  const std::vector<Point<2> > additional_points = {Point<2>(-10,-10,cartesian),Point<2>(-10,10,cartesian),
+                                                    Point<2>(10,10,cartesian),Point<2>(10,-10,cartesian)
+                                                   };
+  CHECK_THROWS_WITH(prm.get("value at points non existent",additional_points), Contains("internal error: could not retrieve"));
+  std::pair<std::vector<double>,std::vector<double>> v_at_p_one_value = prm.get("one value at points one value",additional_points);
+
+  approval_tests.emplace_back(static_cast<double>(v_at_p_one_value.first.size()));
+  approval_tests.emplace_back(static_cast<double>(v_at_p_one_value.first[0]));
+  approval_tests.emplace_back(static_cast<double>(v_at_p_one_value.second.size()));
+
+  {
+    const Objects::Surface surface(v_at_p_one_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(0,0,CoordinateSystem::cartesian)).interpolated_value);
+  }
+  std::pair<std::vector<double>,std::vector<double>> v_at_p_one_array_value = prm.get("array value at points one value",additional_points);
+
+  approval_tests.emplace_back(static_cast<double>(v_at_p_one_array_value.first.size()));
+  approval_tests.emplace_back(static_cast<double>(v_at_p_one_array_value.first[0]));
+  approval_tests.emplace_back(static_cast<double>(v_at_p_one_array_value.second.size()));
+
+  std::pair<std::vector<double>,std::vector<double>> v_at_p_full_default = prm.get("value at points",additional_points);
+
+  approval_tests.emplace_back(static_cast<double>(v_at_p_full_default.first.size()));
+  approval_tests.emplace_back(static_cast<double>(v_at_p_full_default.first[0]));
+  approval_tests.emplace_back(static_cast<double>(v_at_p_full_default.second.size()));
+
+  std::pair<std::vector<double>,std::vector<double>> v_at_p_dap = prm.get("value at points default ap",additional_points);
+
+  approval_tests.emplace_back(static_cast<double>(v_at_p_dap.first.size()));
+  approval_tests.emplace_back(v_at_p_dap.first[0]);
+  approval_tests.emplace_back(v_at_p_dap.first[1]);
+  approval_tests.emplace_back(v_at_p_dap.first[2]);
+  approval_tests.emplace_back(v_at_p_dap.first[3]);
+  approval_tests.emplace_back(v_at_p_dap.first[4]);
+  approval_tests.emplace_back(v_at_p_dap.first[5]);
+  approval_tests.emplace_back(v_at_p_dap.first[6]);
+  approval_tests.emplace_back(static_cast<double>(v_at_p_dap.second.size()));
+  approval_tests.emplace_back(v_at_p_dap.second[0]);
+  approval_tests.emplace_back(v_at_p_dap.second[1]);
+  approval_tests.emplace_back(v_at_p_dap.second[2]);
+  approval_tests.emplace_back(v_at_p_dap.second[3]);
+  approval_tests.emplace_back(v_at_p_dap.second[4]);
+  approval_tests.emplace_back(v_at_p_dap.second[5]);
+  approval_tests.emplace_back(v_at_p_dap.second[6]);
+  approval_tests.emplace_back(v_at_p_dap.second[7]);
+  approval_tests.emplace_back(v_at_p_dap.second[8]);
+  approval_tests.emplace_back(v_at_p_dap.second[9]);
+  approval_tests.emplace_back(v_at_p_dap.second[10]);
+  approval_tests.emplace_back(v_at_p_dap.second[11]);
+  approval_tests.emplace_back(v_at_p_dap.second[12]);
+  approval_tests.emplace_back(v_at_p_dap.second[13]);
+
+  {
+    const Objects::Surface surface(v_at_p_dap);
+
+    approval_tests.emplace_back(surface.local_value(Point<2>(0,0,CoordinateSystem::cartesian)).interpolated_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(0.99,1.99,CoordinateSystem::cartesian)).interpolated_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(1.01,2.01,CoordinateSystem::cartesian)).interpolated_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(0.99,0.99,CoordinateSystem::cartesian)).interpolated_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(1.01,1.01,CoordinateSystem::cartesian)).interpolated_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(2.99,3.99,CoordinateSystem::cartesian)).interpolated_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(2.01,4.01,CoordinateSystem::cartesian)).interpolated_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(-0.5,7.48,CoordinateSystem::cartesian)).interpolated_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(-1,7.6,CoordinateSystem::cartesian)).interpolated_value);
+    approval_tests.emplace_back(surface.local_value(Point<2>(-2.4,8.2,CoordinateSystem::cartesian)).interpolated_value);
+    CHECK_THROWS_WITH(surface.local_value(Point<2>(11,11,CoordinateSystem::cartesian)), Contains("The requested point was not in any triangle."));
+  }
+
+
+  CHECK_THROWS_WITH(prm.get("one value at points one value string",additional_points),
+                    Contains("Could not convert values of /one value at points one value string into a double. The provided value was \"test1\"."));
+  CHECK_THROWS_WITH(prm.get("array value at points one value string",additional_points),
+                    Contains("Could not convert values of /array value at points one value string/0/0 into a double. The provided value was \"test2\"."));
+  CHECK_THROWS_WITH(prm.get("value at points set ap val string",additional_points),
+                    Contains("Could not convert values of /value at points set ap val string/2/0 into doubles. The provided value was \"test3\"."));
+  CHECK_THROWS_WITH(prm.get("value at points set ap p1 string",additional_points),
+                    Contains("Could not convert values of /value at points set ap p1 string/3/1/0/0 into a Point<2> array, because it could not convert the 1st sub-elements into doubles. The provided value was \"test4\"."));
+  CHECK_THROWS_WITH(prm.get("value at points set ap p2 string",additional_points),
+                    Contains("Could not convert values of /value at points set ap p2 string/3/1/0/1 into a Point<2> array, because it could not convert the 2nd sub-elements into doubles. The provided value was \"test5\"."));
+
+
+  CHECK_THROWS_WITH(prm.get_vector<unsigned int>("non existent unsigned int vector"),
+                    Contains("internal error: could not retrieve the minItems value at"));
+
+  CHECK_THROWS_WITH(prm.get_vector<bool>("non existent bool vector"),
+                    Contains("internal error: could not retrieve the minItems value at"));
+
+
+  typedef std::array<double,3> array_3d;
+  CHECK_THROWS_WITH(prm.get_vector<array_3d>("vector of 3d arrays nan"),
+                    Contains("Could not convert values of /vector of 3d arrays nan/0 into doubles."));
+
+  using array_3x3 = std::array<std::array<double, 3>, 3>;
+  CHECK_THROWS_WITH(prm.get_vector<array_3x3>("vector of 3x3 arrays nan"),
+                    Contains("Could not convert values of /vector of 3x3 arrays nan/0 into doubles."));
+
+
+  using array_3x3 = std::array<std::array<double, 3>, 3>;
+  CHECK_THROWS_WITH(prm.get_vector<array_3x3>("vector of 3x3 arrays not 3x3 1"),
+                    Contains("Array 0 is supposed to be a 3x3 array, but the inner array dimensions of 0 is 2."));
+
+
+  CHECK_THROWS_WITH(prm.get_vector<array_3x3>("vector of 3x3 arrays not 3x3 2"),
+                    Contains("Array 1 is supposed to be a 3x3 array, but the outer array dimensions is 2."));
+
+
+  prm.enter_subsection("properties");
+  {
+    prm.declare_entry("now existent unsigned int vector",
+                      Types::Array(Types::UnsignedInt(1),2),
+                      "This is an array of two points along where the cross section is taken");
+  }
+  prm.leave_subsection();
+
+  std::vector<unsigned int> v_int = prm.get_vector<unsigned int>("now existent unsigned int vector");
+  approval_tests.emplace_back(static_cast<double>(v_int.size()));
+  approval_tests.emplace_back(static_cast<double>(v_int[0]));
+  approval_tests.emplace_back(static_cast<double>(v_int[1]));
+
+  v_int = prm.get_vector<unsigned int>("unsigned int array");
+  approval_tests.emplace_back(static_cast<double>(v_int.size()));
+  approval_tests.emplace_back(static_cast<double>(v_int[0]));
+  approval_tests.emplace_back(static_cast<double>(v_int[1]));
+  approval_tests.emplace_back(static_cast<double>(v_int[2]));
+
+  CHECK_THROWS_WITH(prm.get_vector<size_t>("non existent unsigned int vector"),
+                    Contains("internal error: could not retrieve the minItems value"));
+
+
+
+  std::vector<size_t> v_size_t = prm.get_vector<size_t>("now existent unsigned int vector");
+  approval_tests.emplace_back(static_cast<double>(v_size_t.size()));
+  approval_tests.emplace_back(static_cast<double>(v_size_t[0]));
+  approval_tests.emplace_back(static_cast<double>(v_size_t[1]));
+
+  v_size_t = prm.get_vector<size_t>("unsigned int array");
+  approval_tests.emplace_back(static_cast<double>(v_size_t.size()));
+  approval_tests.emplace_back(static_cast<double>(v_size_t[0]));
+  approval_tests.emplace_back(static_cast<double>(v_size_t[1]));
+  approval_tests.emplace_back(static_cast<double>(v_size_t[2]));
+
+
+  CHECK_THROWS_WITH(prm.get_vector<size_t>("non existent unsigned int vector"),
+                    Contains("internal error: could not retrieve the minItems value"));
+
+  prm.enter_subsection("properties");
+  {
+    prm.declare_entry("now existent bool vector",
+                      Types::Array(Types::Bool(true),2),
+                      "This is an array of two bools.");
+  }
+  prm.leave_subsection();
+
+  std::vector<bool> v_bool = prm.get_vector<bool>("now existent bool vector");
+  approval_tests.emplace_back(static_cast<double>(v_bool.size()));
+  approval_tests.emplace_back(static_cast<double>(v_bool[0]));
+  approval_tests.emplace_back(static_cast<double>(v_bool[1]));
+
+  v_bool = prm.get_vector<bool>("bool array");
+  approval_tests.emplace_back(static_cast<double>(v_bool.size()));
+  approval_tests.emplace_back(static_cast<double>(v_bool[0]));
+  approval_tests.emplace_back(static_cast<double>(v_bool[1]));
+  approval_tests.emplace_back(static_cast<double>(v_bool[2]));
+  approval_tests.emplace_back(static_cast<double>(v_bool[3]));
+  approval_tests.emplace_back(static_cast<double>(v_bool[4]));
+  approval_tests.emplace_back(static_cast<double>(v_bool[1]));
+
+  CHECK_THROWS_WITH(prm.get_vector<bool>("bool array nob"),
+                    Contains("IsBool()"));
+
+
+  CHECK_THROWS_WITH(prm.get_vector<double>("non existent double vector"),
+                    Contains("internal error: could not retrieve the minItems value at"));
+
+  prm.enter_subsection("properties");
+  {
+    prm.declare_entry("now existent double vector",
+                      Types::Array(Types::Double(2.4),2),
+                      "This is an array of two points along where the cross section is taken");
+  }
+  prm.leave_subsection();
+
+  std::vector<double> v_double = prm.get_vector<double>("now existent double vector");
+  approval_tests.emplace_back(static_cast<double>(v_double.size()));
+  approval_tests.emplace_back(v_double[0]);
+  approval_tests.emplace_back(v_double[1]);
+
+  CHECK_THROWS_WITH(prm.get<Point<2> >("string array"),
+                    Contains("Could not convert values of /string array into Point<2>, because it could not convert the sub-elements into doubles."));
+
+  v_double = prm.get_vector<double>("double array");
+  approval_tests.emplace_back(static_cast<double>(v_double.size()));
+  approval_tests.emplace_back(v_double[0]);
+  approval_tests.emplace_back(v_double[1]);
+  approval_tests.emplace_back(v_double[2]);
+
+  CHECK_THROWS_WITH(prm.get_vector<Point<2> >("point<2> array nan"),
+                    Contains("Could not convert values of /point<2> array nan/0 into a Point<2> array, because it could not convert the sub-elements into doubles."));
+
+  std::vector<std::array<std::array<double,3>,3> > v_3x3_array = prm.get_vector<std::array<std::array<double,3>,3> >("vector of 3x3 arrays");
+  approval_tests.emplace_back(static_cast<double>(v_3x3_array.size()));
+  approval_tests.emplace_back(v_3x3_array[0][0][0]);
+  approval_tests.emplace_back(v_3x3_array[0][0][1]);
+  approval_tests.emplace_back(v_3x3_array[0][0][2]);
+  approval_tests.emplace_back(v_3x3_array[0][1][0]);
+  approval_tests.emplace_back(v_3x3_array[0][1][1]);
+  approval_tests.emplace_back(v_3x3_array[0][1][2]);
+  approval_tests.emplace_back(v_3x3_array[0][2][0]);
+  approval_tests.emplace_back(v_3x3_array[0][2][1]);
+  approval_tests.emplace_back(v_3x3_array[0][2][2]);
+
+  approval_tests.emplace_back(v_3x3_array[1][0][0]);
+  approval_tests.emplace_back(v_3x3_array[1][0][1]);
+  approval_tests.emplace_back(v_3x3_array[1][0][2]);
+  approval_tests.emplace_back(v_3x3_array[1][1][0]);
+  approval_tests.emplace_back(v_3x3_array[1][1][1]);
+  approval_tests.emplace_back(v_3x3_array[1][1][2]);
+  approval_tests.emplace_back(v_3x3_array[1][2][0]);
+  approval_tests.emplace_back(v_3x3_array[1][2][1]);
+  approval_tests.emplace_back(v_3x3_array[1][2][2]);
+
+  std::vector<std::vector<Point<2> > > v_v_p2 = prm.get_vector<std::vector<Point<2>>>("vector of vectors of points<2>");
+  approval_tests.emplace_back(static_cast<double>(v_v_p2.size()));
+  approval_tests.emplace_back(static_cast<double>(v_v_p2[0].size()));
+  approval_tests.emplace_back(v_v_p2[0][0][0]);
+  approval_tests.emplace_back(v_v_p2[0][0][1]);
+  approval_tests.emplace_back(v_v_p2[0][1][0]);
+  approval_tests.emplace_back(v_v_p2[0][1][1]);
+
+  approval_tests.emplace_back(static_cast<double>(v_v_p2[1].size()));
+  approval_tests.emplace_back(v_v_p2[1][0][0]);
+  approval_tests.emplace_back(v_v_p2[1][0][1]);
+  approval_tests.emplace_back(v_v_p2[1][1][0]);
+  approval_tests.emplace_back(v_v_p2[1][1][1]);
+  approval_tests.emplace_back(v_v_p2[1][2][0]);
+  approval_tests.emplace_back(v_v_p2[1][2][1]);
+
+
+  CHECK_THROWS_WITH(prm.get_vector<std::vector<Point<2>>>("vector of vectors of points<2> nan"),
+                    Contains("Could not convert values of /vector of vectors of points<2> nan/1 into doubles"));
+
+
+  std::pair<std::vector<double>,std::vector<double>> value_at_array = prm.get_value_at_array("value at array full");
+  approval_tests.emplace_back(static_cast<double>(value_at_array.first.size()));
+  approval_tests.emplace_back(value_at_array.first[0]);
+  approval_tests.emplace_back(value_at_array.first[1]);
+
+  approval_tests.emplace_back(static_cast<double>(value_at_array.second.size()));
+  approval_tests.emplace_back(value_at_array.second[0]);
+  approval_tests.emplace_back(value_at_array.second[1]);
+  approval_tests.emplace_back(value_at_array.second[2]);
+  approval_tests.emplace_back(value_at_array.second[3]);
+  approval_tests.emplace_back(value_at_array.second[4]);
+
+
+  std::pair<std::vector<double>,std::vector<double>> double_value_at_array = prm.get_value_at_array("one value at points one value");
+  approval_tests.emplace_back(static_cast<double>(double_value_at_array.first.size()));
+  approval_tests.emplace_back(double_value_at_array.first[0]);
+  approval_tests.emplace_back(static_cast<double>(double_value_at_array.second.size()));
+  approval_tests.emplace_back(double_value_at_array.second[0]);
+
+  std::pair<std::vector<double>,std::vector<double>> default_value_at_array = prm.get_value_at_array("value at array");
+  approval_tests.emplace_back(static_cast<double>(default_value_at_array.first.size()));
+  approval_tests.emplace_back(default_value_at_array.first[0]);
+  approval_tests.emplace_back(static_cast<double>(default_value_at_array.second.size()));
+  approval_tests.emplace_back(default_value_at_array.second[0]);
+
+  std::vector<std::vector<double>> vector_for_vector_or_double = prm.get_vector_or_double("vector for vector or double");
+  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double.size()));
+  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0].size()));
+  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0][0]));
+  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0][1]));
+  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0][2]));
+  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0][3]));
+
+  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[1].size()));
+  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[1][0]));
+  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[1][1]));
+
+  std::vector<std::vector<double>> double_for_vector_or_double = prm.get_vector_or_double("one value at points one value");
+  approval_tests.emplace_back(static_cast<double>(double_for_vector_or_double.size()));
+  approval_tests.emplace_back(static_cast<double>(double_for_vector_or_double[0].size()));
+  approval_tests.emplace_back(static_cast<double>(double_for_vector_or_double[0][0]));
+  /*CHECK_THROWS_WITH(prm.get_vector<std::string>("non existent string vector"),
+                    Contains("internal error: could not retrieve the default value at"));
+
+  std::vector<std::string> v_string = prm.get_vector<std::string>("string array");
+  approval_tests.emplace_back(v_string[0]);
+  approval_tests.emplace_back(v_string[1]);*/
+
+  //prm.load_entry("Coordinate system", false, Types::CoordinateSystem("cartesian","This determines the coordinate system"));
+
+  // Test the UnsignedInt functions
+  /*CHECK_THROWS_WITH(prm.load_entry("non existent unsigned int", true, Types::UnsignedInt(1,"description")),
+                    Contains("Entry undeclared: non existent unsigned int"));
+
+  #ifndef NDEBUG
+  CHECK_THROWS_WITH(prm.get_unsigned_int("non existent unsigned int"),
+                    Contains("Could not find entry 'non existent unsigned int' not found. Make sure it is loaded or set"));
+  #endif
+  CHECK(prm.load_entry("non existent unsigned int", false, Types::UnsignedInt(1,"description")) == false);
+  CHECK(prm.get_unsigned_int("non existent unsigned int") == Approx(1.0));
+
+  prm.set_entry("new unsigned int", Types::UnsignedInt(2,"description"));
+  CHECK(prm.get_unsigned_int("new unsigned int") == Approx(2.0));
+
+  prm.load_entry("unsigned int", true, Types::UnsignedInt(3,"description"));
+  CHECK(prm.get_unsigned_int("unsigned int") == Approx(4.0));*/
+// Todo: redo this with the new type system.
+  /*
+    // Test the Double functions
+    CHECK_THROWS_WITH(prm.load_entry("non existent double", true, Types::Double(1,"description")),
+                      Contains("Entry undeclared: non existent"));
+
+  #ifndef NDEBUG
+    CHECK_THROWS_WITH(prm.get_double("non existent double"),
+                      Contains("Could not find entry 'non existent double' not found. Make sure it is loaded or set"));
+  #endif
+    CHECK(prm.load_entry("non existent double", false, Types::Double(1,"description")) == false);
+    CHECK(prm.get_double("non existent double") == Approx(1.0));
+
+    prm.set_entry("new double", Types::Double(2,"description"));
+    CHECK(prm.get_double("new double") == Approx(2.0));
+
+    prm.load_entry("double", true, Types::Double(3,"description"));
+    CHECK(prm.get_double("double") == 1.23456e2);
+
+
+    // Test the String functions
+    CHECK_THROWS_WITH(prm.load_entry("non existent string", true, Types::String("1","description")),
+                      Contains("Entry undeclared: non existent string"));
+
+  #ifndef NDEBUG
+    CHECK_THROWS_WITH(prm.get_string("non existent string"),
+                      Contains("Could not find entry 'non existent string' not found. Make sure it is loaded or set"));
+  #endif
+    CHECK(prm.load_entry("non exitent string", false, Types::String("1","description")) == false);
+    CHECK(prm.get_string("non exitent string") == "1");
+
+    prm.set_entry("new string", Types::String("2","description"));
+    CHECK(prm.get_string("new string") == "2");
+
+    prm.load_entry("string", true, Types::String("3","description"));
+    CHECK(prm.get_string("string") == "mystring 0");
+
+    // Test the Point functions
+    CHECK_THROWS_WITH(prm.load_entry("non existent 2d Point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description")),
+                      Contains("Could not find .non existent 2d Point, while it is set as required."));
+    CHECK_THROWS_WITH(prm.load_entry("non existent 3d Point", true, Types::Point<3>(Point<3>(1,2,3,cartesian),"description")),
+                      Contains("Could not find .non existent 3d Point, while it is set as required."));
+
+  #ifndef NDEBUG
+    CHECK_THROWS_WITH(prm.get_point<2>("non existent 2d Point"),
+                      Contains("Could not find entry 'non existent 2d Point' not found. Make sure it is loaded or set"));
+    CHECK_THROWS_WITH(prm.get_point<3>("non existent 3d Point"),
+                      Contains("Could not find entry 'non existent 3d Point' not found. Make sure it is loaded or set"));
+  #endif
+
+    CHECK(prm.load_entry("non existent 2d Point", false, Types::Point<2>(Point<2>(1,2,cartesian),"description")) == false);
+    CHECK(prm.load_entry("non existent 3d Point", false, Types::Point<3>(Point<3>(1,2,3,cartesian),"description")) == false);
+
+    CHECK(prm.get_point<2>("non existent 2d Point").get_array() == std::array<double,2> {1,2});
+    CHECK(prm.get_point<3>("non existent 3d Point").get_array() == std::array<double,3> {1,2,3});
+
+    prm.set_entry("new Point 2d", Types::Point<2>(Point<2>(3,4,cartesian),"description"));
+    prm.set_entry("new Point 3d", Types::Point<3>(Point<3>(5,6,7,cartesian),"description"));
+
+    CHECK(prm.get_point<2>("new Point 2d").get_array() == std::array<double,2> {3,4});
+    CHECK(prm.get_point<3>("new Point 3d").get_array() == std::array<double,3> {5,6,7});
+
+
+    prm.load_entry("2d point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description"));
+    prm.load_entry("3d point", true, Types::Point<3>(Point<3>(3,4,5,cartesian),"description"));
+
+    CHECK(prm.get_point<2>("2d point").get_array() == std::array<double,2> {10,11});
+    CHECK(prm.get_point<3>("3d point").get_array() == std::array<double,3> {12,13,14});
+
+    // Test the Array<Types::Double> functions
+    CHECK_THROWS_WITH(prm.load_entry("non existent double array", true, Types::Array(Types::Double(1,"description"),"description")),
+                      Contains("Could not find .non existent double array, while it is set as required."));
+
+  #ifndef NDEBUG
+    CHECK_THROWS_WITH(prm.get_array("non existent double array"),
+                      Contains("Could not find entry 'non existent double array' not found. Make sure it is loaded or set"));
+  #endif
+
+    CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Double(2,"description"),"description")) == false);
+
+  #ifndef NDEBUG
+    CHECK(prm.get_array<Types::Double>("non exitent double array").size() == 1);
+    CHECK(prm.get_array<Types::Double>("non exitent double array")[0].value == Approx(2.0));
+    CHECK(prm.get_array<Types::Double>("non exitent double array")[0].description == "description");
+  #endif
+    // This is not desired behavior, but it is not implemented yet.
+
+    prm.set_entry("new double array", Types::Array(Types::Double(3,"description"),"description"));
+    std::vector<Types::Double> set_typed_double =  prm.get_array<Types::Double >("new double array");
+    approval_tests.emplace_back(set_typed_double.size());
+    // This is not desired behavior, but it is not implemented yet.
+
+    prm.load_entry("double array", true, Types::Array(Types::Double(4,"description"),"description"));
+    std::vector<Types::Double> true_loaded_typed_double =  prm.get_array<Types::Double >("double array");
+    approval_tests.emplace_back(true_loaded_typed_double.size());
+    approval_tests.emplace_back(true_loaded_typed_double[0].value);
+    approval_tests.emplace_back(true_loaded_typed_double[1].value);
+    approval_tests.emplace_back(true_loaded_typed_double[2].value);
+
+
+    // Test the Array<Types::Point<2> > functions
+    CHECK_THROWS_WITH(prm.load_entry("non existent point<2> array", true, Types::Array(Types::Point<2>(Point<2>(1,2,cartesian),"description"),"description")),
+                      Contains("Could not find .non existent point<2> array, while it is set as required."));
+
+  #ifndef NDEBUG
+    CHECK_THROWS_WITH(prm.get_array("non existent point<2> array"),
+                      Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set"));
+  #endif
+    CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<2>(Point<2>(3,4,cartesian),"description"),"description")) == false);
+
+  #ifndef NDEBUG
+    CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("non existent point<2> array"),
+                      Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set."));
+    // This is not desired behavior, but it is not implemented yet.
+  #endif
+
+    prm.set_entry("new point<2> array", Types::Array(Types::Point<2>(Point<2>(5,6,cartesian),"description"),"description"));
+    std::vector<Types::Point<2> > set_typed_point_2d = prm.get_array<Types::Point<2> >("new point<2> array");
+    approval_tests.emplace_back(set_typed_point_2d.size());
+    // This is not desired behavior, but it is not implemented yet.
+
+    prm.load_entry("point<2> array", true, Types::Array(Types::Point<2>(Point<2>(7,8,cartesian),"description"),"description"));
+    std::vector<Types::Point<2> > true_loaded_typed_point_2d =  prm.get_array<Types::Point<2> >("point<2> array");
+    approval_tests.emplace_back(true_loaded_typed_point_2d.size());
+    CHECK(true_loaded_typed_point_2d[0].value.get_array() == std::array<double,2> {10,11});
+    CHECK(true_loaded_typed_point_2d[1].value.get_array() == std::array<double,2> {12,13});
+    CHECK(true_loaded_typed_point_2d[2].value.get_array() == std::array<double,2> {14,15});
+
+
+    // Test the Array<Types::Point<3> > functions
+    CHECK_THROWS_WITH(prm.load_entry("non existent point<3> array", true, Types::Array(Types::Point<3>(Point<3>(1,2,3,cartesian),"description"),"description")),
+                      Contains("Could not find .non existent point<3> array, while it is set as required."));
+
+  #ifndef NDEBUG
+    CHECK_THROWS_WITH(prm.get_array("non existent point<3> array"),
+                      Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set"));
+  #endif
+    CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<3>(Point<3>(4,5,6,cartesian),"description"),"description")) == false);
+
+  #ifndef NDEBUG
+    CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("non existent point<3> array"),
+                      Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set."));
+    // This is not desired behavior, but it is not implemented yet.
+  #endif
+
+    prm.set_entry("new point<3> array", Types::Array(Types::Point<3>(Point<3>(7,8,9,cartesian),"description"),"description"));
+    std::vector<Types::Point<3> > set_typed_point_3d = prm.get_array<Types::Point<3> >("new point<3> array");
+    approval_tests.emplace_back(set_typed_point_3d.size());
+    // This is not desired behavior, but it is not implemented yet.
+
+    prm.load_entry("point<3> array", true, Types::Array(Types::Point<3>(Point<3>(10,11,12,cartesian),"description"),"description"));
+    std::vector<Types::Point<3> > true_loaded_typed_point_3d =  prm.get_array<Types::Point<3> >("point<3> array");
+    approval_tests.emplace_back(true_loaded_typed_point_3d.size());
+    CHECK(true_loaded_typed_point_3d[0].value.get_array() == std::array<double,3> {20,21,22});
+    CHECK(true_loaded_typed_point_3d[1].value.get_array() == std::array<double,3> {23,24,25});
+    CHECK(true_loaded_typed_point_3d[2].value.get_array() == std::array<double,3> {26,27,28});
+
+  #ifndef NDEBUG
+    CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<2> array"),
+                      Contains("Could not get point<2> array, because it is not a 2d Point."));
+    CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<3> array"),
+                      Contains("Could not get point<3> array, because it is not a 3d Point."));
+
+    CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("point<3> array"),
+                      Contains("Could not get point<3> array, because it is not a 3d Point."));
+    CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("double array"),
+                      Contains("Could not get double array, because it is not a Double."));
+
+    CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("point<2> array"),
+                      Contains("Could not get point<2> array, because it is not a 2d Point."));
+    CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("double array"),
+                      Contains("Could not get double array, because it is not a Double."));
+  #endif
+
+    // Test the enter_subsection and leave_subsection functions
+    prm.enter_subsection("subsection 1");
+    {
+      // Test the UnsignedInt functions
+      / *CHECK_THROWS_WITH(prm.load_entry("non existent unsigned int", true, Types::UnsignedInt(1,"description")),
+                        Contains("Entry undeclared: subsection 1.non existent unsigned int"));
+
+      #ifndef NDEBUG
+      CHECK_THROWS_WITH(prm.get_unsigned_int("non existent unsigned int"),
+                        Contains("Could not find entry 'non existent unsigned int' not found. Make sure it is loaded or set"));
+      #endif
+
+      CHECK(prm.load_entry("non existent unsigned int", false, Types::UnsignedInt(1,"description")) == false);
+      CHECK(prm.get_unsigned_int("non existent unsigned int") == Approx(1.0));
+
+      prm.set_entry("new unsigned int", Types::UnsignedInt(2,"description"));
+      CHECK(prm.get_unsigned_int("new unsigned int") == Approx(2.0));
+
+      prm.load_entry("unsigned int", true, Types::UnsignedInt(3,"description"));
+      CHECK(prm.get_unsigned_int("unsigned int") == Approx(5.0));* /
+
+
+      // Test the Double functions
+      CHECK_THROWS_WITH(prm.load_entry("non existent double", true, Types::Double(1,"description")),
+                        Contains("Entry undeclared: subsection 1.non existent"));
+
+  #ifndef NDEBUG
+      CHECK_THROWS_WITH(prm.get_double("non existent double"),
+                        Contains("Could not find entry 'non existent double' not found. Make sure it is loaded or set"));
+  #endif
+
+      CHECK(prm.load_entry("non existent double", false, Types::Double(2,"description")) == false);
+      CHECK(prm.get_double("non existent double") == Approx(2.0));
+
+      prm.set_entry("new double", Types::Double(3,"description"));
+      CHECK(prm.get_double("new double") == Approx(3.0));
+
+      prm.load_entry("double", true, Types::Double(4,"description"));
+      CHECK(prm.get_double("double") == 2.23456e2);
+
+
+      // Test the String functions
+      CHECK_THROWS_WITH(prm.load_entry("non existent string", true, Types::String("2","description")),
+                        Contains("Entry undeclared: subsection 1.non existent string"));
+
+  #ifndef NDEBUG
+      CHECK_THROWS_WITH(prm.get_string("non existent string"),
+                        Contains("Could not find entry 'non existent string' not found. Make sure it is loaded or set"));
+  #endif
+
+      CHECK(prm.load_entry("non exitent string", false, Types::String("3","description")) == false);
+      CHECK(prm.get_string("non exitent string") == "3");
+
+      prm.set_entry("new string", Types::String("4","description"));
+      CHECK(prm.get_string("new string") == "4");
+
+      prm.load_entry("string", true, Types::String("5","description"));
+      CHECK(prm.get_string("string") == "mystring 1");
+
+      // Test the Point functions
+      CHECK_THROWS_WITH(prm.load_entry("non existent 2d Point", true, Types::Point<2>(Point<2>(3,4,cartesian),"description")),
+                        Contains("Could not find subsection 1.non existent 2d Point, while it is set as required."));
+      CHECK_THROWS_WITH(prm.load_entry("non existent 3d Point", true, Types::Point<3>(Point<3>(4,5,6,cartesian),"description")),
+                        Contains("Could not find subsection 1.non existent 3d Point, while it is set as required."));
+
+  #ifndef NDEBUG
+      CHECK_THROWS_WITH(prm.get_point<2>("non existent 2d Point"),
+                        Contains("Could not find entry 'non existent 2d Point' not found. Make sure it is loaded or set"));
+      CHECK_THROWS_WITH(prm.get_point<3>("non existent 3d Point"),
+                        Contains("Could not find entry 'non existent 3d Point' not found. Make sure it is loaded or set"));
+  #endif
+
+      CHECK(prm.load_entry("non existent 2d Point", false, Types::Point<2>(Point<2>(3,4,cartesian),"description")) == false);
+      CHECK(prm.load_entry("non existent 3d Point", false, Types::Point<3>(Point<3>(4,5,6,cartesian),"description")) == false);
+
+      CHECK(prm.get_point<2>("non existent 2d Point").get_array() == std::array<double,2> {3,4});
+      CHECK(prm.get_point<3>("non existent 3d Point").get_array() == std::array<double,3> {4,5,6});
+
+      prm.set_entry("new Point 2d", Types::Point<2>(Point<2>(5,6,cartesian),"description"));
+      prm.set_entry("new Point 3d", Types::Point<3>(Point<3>(7,8,9,cartesian),"description"));
+
+      CHECK(prm.get_point<2>("new Point 2d").get_array() == std::array<double,2> {5,6});
+      CHECK(prm.get_point<3>("new Point 3d").get_array() == std::array<double,3> {7,8,9});
+
+
+      prm.load_entry("2d point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description"));
+      prm.load_entry("3d point", true, Types::Point<3>(Point<3>(3,4,5,cartesian),"description"));
+
+      CHECK(prm.get_point<2>("2d point").get_array() == std::array<double,2> {15,16});
+      CHECK(prm.get_point<3>("3d point").get_array() == std::array<double,3> {17,18,19});
+
+
+      // Test the Array functions
+      CHECK_THROWS_WITH(prm.load_entry("non existent double array", true, Types::Array(Types::Double(1,"description"),"description")),
+                        Contains("Could not find subsection 1.non existent double array, while it is set as required."));
+
+  #ifndef NDEBUG
+      CHECK_THROWS_WITH(prm.get_array("non existent double array"),
+                        Contains("Could not find entry 'non existent double array' not found. Make sure it is loaded or set"));
+
+      CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Double(2,"description"),"description")) == false);
+      CHECK(prm.get_array<Types::Double>("non exitent double array").size() == 1);
+      CHECK(prm.get_array<Types::Double>("non exitent double array")[0].value == Approx(2.0));
+      CHECK(prm.get_array<Types::Double>("non exitent double array")[0].description == "description");
+      // This is not desired behavior, but it is not implemented yet.
+  #endif
+
+      prm.set_entry("new double array", Types::Array(Types::Double(3,"description"),"description"));
+      std::vector<Types::Double > set_typed_double =  prm.get_array<Types::Double >("new double array");
+      approval_tests.emplace_back(set_typed_double.size());
+      // This is not desired behavior, but it is not implemented yet.
+
+      prm.load_entry("double array", true, Types::Array(Types::Double(4,"description"),"description"));
+      std::vector<Types::Double > true_loaded_typed_double =  prm.get_array<Types::Double >("double array");
+      approval_tests.emplace_back(true_loaded_typed_double.size());
+      approval_tests.emplace_back(true_loaded_typed_double[0].value);
+      approval_tests.emplace_back(true_loaded_typed_double[1].value);
+      approval_tests.emplace_back(true_loaded_typed_double[2].value);
+
+      // Test the Array<Types::Point<2> > functions
+      CHECK_THROWS_WITH(prm.load_entry("non existent point<2> array", true, Types::Array(Types::Point<2>(Point<2>(1,2,cartesian),"description"),"description")),
+                        Contains("Could not find subsection 1.non existent point<2> array, while it is set as required."));
+
+  #ifndef NDEBUG
+      CHECK_THROWS_WITH(prm.get_array("non existent point<2> array"),
+                        Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set"));
+
+      CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<2>(Point<2>(3,4,cartesian),"description"),"description")) == false);
+      CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("non existent point<2> array"),
+                        Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set."));
+      // This is not desired behavior, but it is not implemented yet.
+  #endif
+
+      prm.set_entry("new point<2> array", Types::Array(Types::Point<2>(Point<2>(5,6,cartesian),"description"),"description"));
+      std::vector<Types::Point<2> > set_typed_point_2d = prm.get_array<Types::Point<2> >("new point<2> array");
+      approval_tests.emplace_back(set_typed_point_2d.size());
+      // This is not desired behavior, but it is not implemented yet.
+
+      prm.load_entry("point<2> array", true, Types::Array(Types::Point<2>(Point<2>(7,8,cartesian),"description"),"description"));
+      std::vector<Types::Point<2> > true_loaded_typed_point_2d =  prm.get_array<Types::Point<2> >("point<2> array");
+      approval_tests.emplace_back(true_loaded_typed_point_2d.size());
+      CHECK(true_loaded_typed_point_2d[0].value.get_array() == std::array<double,2> {20,21});
+      CHECK(true_loaded_typed_point_2d[1].value.get_array() == std::array<double,2> {22,23});
+      CHECK(true_loaded_typed_point_2d[2].value.get_array() == std::array<double,2> {24,25});
+
+
+      // Test the Array<Types::Point<3> > functions
+      CHECK_THROWS_WITH(prm.load_entry("non existent point<3> array", true, Types::Array(Types::Point<3>(Point<3>(1,2,3,cartesian),"description"),"description")),
+                        Contains("Could not find subsection 1.non existent point<3> array, while it is set as required."));
+
+  #ifndef NDEBUG
+      CHECK_THROWS_WITH(prm.get_array("non existent point<3> array"),
+                        Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set"));
+
+      CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<3>(Point<3>(4,5,6,cartesian),"description"),"description")) == false);
+      CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("non existent point<3> array"),
+                        Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set."));
+      // This is not desired behavior, but it is not implemented yet.
+  #endif
+
+      prm.set_entry("new point<3> array", Types::Array(Types::Point<3>(Point<3>(7,8,9,cartesian),"description"),"description"));
+      std::vector<Types::Point<3> > set_typed_point_3d = prm.get_array<Types::Point<3> >("new point<3> array");
+      approval_tests.emplace_back(set_typed_point_3d.size());
+      // This is not desired behavior, but it is not implemented yet.
+
+      prm.load_entry("point<3> array", true, Types::Array(Types::Point<3>(Point<3>(10,11,12,cartesian),"description"),"description"));
+      std::vector<Types::Point<3> > true_loaded_typed_point_3d =  prm.get_array<Types::Point<3> >("point<3> array");
+      approval_tests.emplace_back(true_loaded_typed_point_3d.size());
+      CHECK(true_loaded_typed_point_3d[0].value.get_array() == std::array<double,3> {30,31,32});
+      CHECK(true_loaded_typed_point_3d[1].value.get_array() == std::array<double,3> {33,34,35});
+      CHECK(true_loaded_typed_point_3d[2].value.get_array() == std::array<double,3> {36,37,38});
+
+  #ifndef NDEBUG
+      CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<2> array"),
+                        Contains("Could not get subsection 1.point<2> array, because it is not a 2d Point."));
+      CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<3> array"),
+                        Contains("Could not get subsection 1.point<3> array, because it is not a 3d Point."));
+
+      CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("point<3> array"),
+                        Contains("Could not get subsection 1.point<3> array, because it is not a 3d Point."));
+      CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("double array"),
+                        Contains("Could not get subsection 1.double array, because it is not a Double."));
+
+      CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("point<2> array"),
+                        Contains("Could not get subsection 1.point<2> array, because it is not a 2d Point."));
+      CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("double array"),
+                        Contains("Could not get subsection 1.double array, because it is not a Double."));
+  #endif
+
+      prm.enter_subsection("subsection 2");
+      {
+        // Test the UnsignedInt functions
+        / *CHECK_THROWS_WITH(prm.load_entry("non existent unsigned int", true, Types::UnsignedInt(1,"description")),
+                          Contains("Entry undeclared: subsection 1.subsection 2.non existent unsigned int"));
+
+        #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.get_unsigned_int("non existent unsigned int"),
+                          Contains("Could not find entry 'non existent unsigned int' not found. Make sure it is loaded or set"));
+        #endif
+
+        CHECK(prm.load_entry("non existent unsigned int", false, Types::UnsignedInt(1,"description")) == false);
+        CHECK(prm.get_unsigned_int("non existent unsigned int") == Approx(1.0));
+
+        prm.set_entry("new unsigned int", Types::UnsignedInt(2,"description"));
+        CHECK(prm.get_unsigned_int("new unsigned int") == Approx(2.0));
+
+        prm.load_entry("unsigned int", true, Types::UnsignedInt(3,"description"));
+        CHECK(prm.get_unsigned_int("unsigned int") == Approx(6.0));* /
+
+
+        // Test the Double functions
+        CHECK_THROWS_WITH(prm.load_entry("non existent double", true, Types::Double(3,"description")),
+                          Contains("Entry undeclared: subsection 1.subsection 2.non existent"));
+
+  #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.get_double("non existent double"),
+                          Contains("Could not find entry 'non existent double' not found. Make sure it is loaded or set"));
+  #endif
+
+        CHECK(prm.load_entry("non existent double", false, Types::Double(4,"description")) == false);
+        CHECK(prm.get_double("non existent double") == Approx(4.0));
+
+        prm.set_entry("new double", Types::Double(5,"description"));
+        CHECK(prm.get_double("new double") == Approx(5.0));
+
+        prm.load_entry("double", true, Types::Double(6,"description"));
+        CHECK(prm.get_double("double") == 3.23456e2);
+
+
+        // Test the String functions
+        CHECK_THROWS_WITH(prm.load_entry("non existent string", true, Types::String("3","description")),
+                          Contains("Entry undeclared: subsection 1.subsection 2.non existent string"));
+
+  #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.get_string("non existent string"),
+                          Contains("Could not find entry 'non existent string' not found. Make sure it is loaded or set"));
+  #endif
+
+        CHECK(prm.load_entry("non exitent string", false, Types::String("4","description")) == false);
+        CHECK(prm.get_string("non exitent string") == "4");
+
+        prm.set_entry("new string", Types::String("5","description"));
+        CHECK(prm.get_string("new string") == "5");
+
+        prm.load_entry("string", true, Types::String("6","description"));
+        CHECK(prm.get_string("string") == "mystring 2");
+
+        // Test the Point functions
+
+        CHECK_THROWS_WITH(prm.load_entry("non existent 2d Point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description")),
+                          Contains("Could not find subsection 1.subsection 2.non existent 2d Point, while it is set as required."));
+        CHECK_THROWS_WITH(prm.load_entry("non existent 3d Point", true, Types::Point<3>(Point<3>(1,2,3,cartesian),"description")),
+                          Contains("Could not find subsection 1.subsection 2.non existent 3d Point, while it is set as required."));
+
+  #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.get_point<2>("non existent 2d Point"),
+                          Contains("Could not find entry 'non existent 2d Point' not found. Make sure it is loaded or set"));
+        CHECK_THROWS_WITH(prm.get_point<3>("non existent 3d Point"),
+                          Contains("Could not find entry 'non existent 3d Point' not found. Make sure it is loaded or set"));
+  #endif
+
+        CHECK(prm.load_entry("non existent 2d Point", false, Types::Point<2>(Point<2>(1,2,cartesian),"description")) == false);
+        CHECK(prm.load_entry("non existent 3d Point", false, Types::Point<3>(Point<3>(1,2,3,cartesian),"description")) == false);
+
+        CHECK(prm.get_point<2>("non existent 2d Point").get_array() == std::array<double,2> {1,2});
+        CHECK(prm.get_point<3>("non existent 3d Point").get_array() == std::array<double,3> {1,2,3});
+
+        prm.set_entry("new Point 2d", Types::Point<2>(Point<2>(3,4,cartesian),"description"));
+        prm.set_entry("new Point 3d", Types::Point<3>(Point<3>(5,6,7,cartesian),"description"));
+
+        CHECK(prm.get_point<2>("new Point 2d").get_array() == std::array<double,2> {3,4});
+        CHECK(prm.get_point<3>("new Point 3d").get_array() == std::array<double,3> {5,6,7});
+
+
+        prm.load_entry("2d point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description"));
+        prm.load_entry("3d point", true, Types::Point<3>(Point<3>(3,4,5,cartesian),"description"));
+
+        CHECK(prm.get_point<2>("2d point").get_array() == std::array<double,2> {20,21});
+        CHECK(prm.get_point<3>("3d point").get_array() == std::array<double,3> {22,23,24});
+
+        // Test the Array functions
+
+        CHECK_THROWS_WITH(prm.load_entry("non existent double array", true, Types::Array(Types::Double(1,"description"),"description")),
+                          Contains("Could not find subsection 1.subsection 2.non existent double array, while it is set as required."));
+  #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.get_array("non existent double array"),
+                          Contains("Could not find entry 'non existent double array' not found. Make sure it is loaded or set"));
+  #endif
+
+        CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Double(2,"description"),"description")) == false);
+
+        CHECK(prm.get_array<Types::Double >("non exitent double array").size() == 1);
+        CHECK(prm.get_array<Types::Double >("non exitent double array")[0].value == Approx(2.0));
+        CHECK(prm.get_array<Types::Double >("non exitent double array")[0].description == "description");
+
+        prm.set_entry("new double array", Types::Array(Types::Double(3,"description"),"description"));
+        std::vector<Types::Double > set_typed_double =  prm.get_array<Types::Double >("new double array");
+        approval_tests.emplace_back(set_typed_double.size());
+        // This is not desired behavior, but it is not implemented yet.
+
+        prm.load_entry("double array", true, Types::Array(Types::Double(4,"description"),"description"));
+        std::vector<Types::Double > true_loaded_typed_double =  prm.get_array<Types::Double >("double array");
+        approval_tests.emplace_back(true_loaded_typed_double.size());
+        approval_tests.emplace_back(true_loaded_typed_double[0].value);
+        approval_tests.emplace_back(true_loaded_typed_double[1].value);
+        approval_tests.emplace_back(true_loaded_typed_double[2].value);
+
+
+        // Test the Array<Types::Point<2> > functions
+  #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.load_entry("non existent point<2> array", true, Types::Array(Types::Point<2>(Point<2>(1,2,cartesian),"description"),"description")),
+                          Contains("Could not find subsection 1.subsection 2.non existent point<2> array, while it is set as required."));
+
+        CHECK_THROWS_WITH(prm.get_array("non existent point<2> array"),
+                          Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set"));
+  #endif
+
+        CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<2>(Point<2>(3,4,cartesian),"description"),"description")) == false);
+
+  #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("non existent point<2> array"),
+                          Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set."));
+        // This is not desired behavior, but it is not implemented yet.
+  #endif
+
+        prm.set_entry("new point<2> array", Types::Array(Types::Point<2>(Point<2>(5,6,cartesian),"description"),"description"));
+        std::vector<Types::Point<2> > set_typed_point_2d = prm.get_array<Types::Point<2> >("new point<2> array");
+        approval_tests.emplace_back(set_typed_point_2d.size());
+        // This is not desired behavior, but it is not implemented yet.
+
+        prm.load_entry("point<2> array", true, Types::Array(Types::Point<2>(Point<2>(7,8,cartesian),"description"),"description"));
+        std::vector<Types::Point<2> > true_loaded_typed_point_2d =  prm.get_array<Types::Point<2> >("point<2> array");
+        approval_tests.emplace_back(true_loaded_typed_point_2d.size());
+        CHECK(true_loaded_typed_point_2d[0].value.get_array() == std::array<double,2> {40,41});
+        CHECK(true_loaded_typed_point_2d[1].value.get_array() == std::array<double,2> {42,43});
+        CHECK(true_loaded_typed_point_2d[2].value.get_array() == std::array<double,2> {44,45});
+
+
+        // Test the Array<Types::Point<3> > functions
+  #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.load_entry("non existent point<3> array", true, Types::Array(Types::Point<3>(Point<3>(1,2,3,cartesian),"description"),"description")),
+                          Contains("Could not find subsection 1.subsection 2.non existent point<3> array, while it is set as required."));
+
+        CHECK_THROWS_WITH(prm.get_array("non existent point<3> array"),
+                          Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set"));
+  #endif
+
+        CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<3>(Point<3>(4,5,6,cartesian),"description"),"description")) == false);
+
+  #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("non existent point<3> array"),
+                          Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set."));
+        // This is not desired behavior, but it is not implemented yet.
+  #endif
+
+        prm.set_entry("new point<3> array", Types::Array(Types::Point<3>(Point<3>(7,8,9,cartesian),"description"),"description"));
+        std::vector<Types::Point<3> > set_typed_point_3d = prm.get_array<Types::Point<3> >("new point<3> array");
+        approval_tests.emplace_back(set_typed_point_3d.size());
+        // This is not desired behavior, but it is not implemented yet.
+
+        prm.load_entry("point<3> array", true, Types::Array(Types::Point<3>(Point<3>(10,11,12,cartesian),"description"),"description"));
+        std::vector<Types::Point<3> > true_loaded_typed_point_3d =  prm.get_array<Types::Point<3> >("point<3> array");
+        approval_tests.emplace_back(true_loaded_typed_point_3d.size());
+        CHECK(true_loaded_typed_point_3d[0].value.get_array() == std::array<double,3> {40,41,42});
+        CHECK(true_loaded_typed_point_3d[1].value.get_array() == std::array<double,3> {43,44,45});
+        CHECK(true_loaded_typed_point_3d[2].value.get_array() == std::array<double,3> {46,47,48});
+
+  #ifndef NDEBUG
+        CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<2> array"),
+                          Contains("Could not get subsection 1.subsection 2.point<2> array, because it is not a 2d Point."));
+        CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<3> array"),
+                          Contains("Could not get subsection 1.subsection 2.point<3> array, because it is not a 3d Point."));
+
+        CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("point<3> array"),
+                          Contains("Could not get subsection 1.subsection 2.point<3> array, because it is not a 3d Point."));
+        CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("double array"),
+                          Contains("Could not get subsection 1.subsection 2.double array, because it is not a Double."));
+
+        CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("point<2> array"),
+                          Contains("Could not get subsection 1.subsection 2.point<2> array, because it is not a 2d Point."));
+        CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("double array"),
+                          Contains("Could not get subsection 1.subsection 2.double array, because it is not a Double."));
+  #endif
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection();
+  */
+
+  // Todo: add tests for list,feature and coordinate system.
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+
+TEST_CASE("Euler angle functions")
+{
+  const std::vector<double> approval_tests;
+
+  // note, this is only testing consistency (can it convert back and forth) and
+  // it only works for rotation matrices which are defined in the same way (z-x-z).
+  {
+    auto rot1 = Utilities::euler_angles_to_rotation_matrix(-85,340,56);
+    auto ea1 = Utilities::euler_angles_from_rotation_matrix(rot1);
+    auto rot2 = Utilities::euler_angles_to_rotation_matrix(ea1[0],ea1[1],ea1[2]);
+    compare_rotation_matrices_approx(rot2, rot1);
+    auto ea2 = Utilities::euler_angles_from_rotation_matrix(rot2);
+    compare_3d_arrays_approx(ea2,ea1);
+    auto rot3 = Utilities::euler_angles_to_rotation_matrix(ea2[0],ea2[1],ea2[2]);
+    compare_rotation_matrices_approx(rot3, rot2);
+  }
+  {
+    auto rot1 = Utilities::euler_angles_to_rotation_matrix(90,180,270);
+    auto ea1 = Utilities::euler_angles_from_rotation_matrix(rot1);
+    auto rot2 = Utilities::euler_angles_to_rotation_matrix(ea1[0],ea1[1],ea1[2]);
+    compare_rotation_matrices_approx(rot2, rot1);
+    auto ea2 = Utilities::euler_angles_from_rotation_matrix(rot2);
+    compare_3d_arrays_approx(ea2,ea1);
+    auto rot3 = Utilities::euler_angles_to_rotation_matrix(ea2[0],ea2[1],ea2[2]);
+    compare_rotation_matrices_approx(rot3, rot2);
+  }
+
+  {
+    const std::array<double,3> ea0 = {{20,30,40}};
+    auto rot0 = Utilities::euler_angles_to_rotation_matrix(20,30,40);
+    auto ea1 = Utilities::euler_angles_from_rotation_matrix(rot0);
+    compare_3d_arrays_approx(ea1,ea0);
+    auto rot2 = Utilities::euler_angles_to_rotation_matrix(ea1[0],ea1[1],ea1[2]);
+    compare_rotation_matrices_approx(rot2, rot0);
+    auto ea2 = Utilities::euler_angles_from_rotation_matrix(rot2);
+    compare_3d_arrays_approx(ea2,ea1);
+    auto rot3 = Utilities::euler_angles_to_rotation_matrix(ea2[0],ea2[1],ea2[2]);
+    compare_rotation_matrices_approx(rot3, rot2);
+  }
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("GWB Bezier curve")
+{
+
+  std::vector<Point<2>> approval_tests;
+
+  std::vector<Point<2> > coordinates;
+  coordinates.emplace_back(0,10,cartesian);
+  coordinates.emplace_back(20,10,cartesian);
+  coordinates.emplace_back(30,20,cartesian);
+
+  const Objects::BezierCurve bezier_curve(coordinates);
+
+  approval_tests.emplace_back(bezier_curve(0,-0.1));
+  approval_tests.emplace_back(bezier_curve(0,0.0));
+  approval_tests.emplace_back(bezier_curve(0,0.1));
+  approval_tests.emplace_back(bezier_curve(0,0.2));
+  approval_tests.emplace_back(bezier_curve(0,0.3));
+  approval_tests.emplace_back(bezier_curve(0,0.4));
+  approval_tests.emplace_back(bezier_curve(0,0.5));
+  approval_tests.emplace_back(bezier_curve(0,0.6));
+  approval_tests.emplace_back(bezier_curve(0,0.7));
+  approval_tests.emplace_back(bezier_curve(0,0.8));
+  approval_tests.emplace_back(bezier_curve(0,0.9));
+  approval_tests.emplace_back(bezier_curve(0,1.0));
+  approval_tests.emplace_back(bezier_curve(0,1.1));
+
+  approval_tests.emplace_back(bezier_curve(1,-0.1));
+  approval_tests.emplace_back(bezier_curve(1,0.0));
+  approval_tests.emplace_back(bezier_curve(1,0.1));
+  approval_tests.emplace_back(bezier_curve(1,0.2));
+  approval_tests.emplace_back(bezier_curve(1,0.3));
+  approval_tests.emplace_back(bezier_curve(1,0.4));
+  approval_tests.emplace_back(bezier_curve(1,0.5));
+  approval_tests.emplace_back(bezier_curve(1,0.6));
+  approval_tests.emplace_back(bezier_curve(1,0.7));
+  approval_tests.emplace_back(bezier_curve(1,0.8));
+  approval_tests.emplace_back(bezier_curve(1,0.9));
+  approval_tests.emplace_back(bezier_curve(1,1.0));
+  approval_tests.emplace_back(bezier_curve(1,1.1));
+
+
+  const Objects::BezierCurve bezier_curve_defined(coordinates,
+  {
+    0.,Consts::PI,0.
+  });
+
+  approval_tests.emplace_back(bezier_curve_defined(0,-0.1));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.0));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.1));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.2));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.3));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.4));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.5));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.6));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.7));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.8));
+  approval_tests.emplace_back(bezier_curve_defined(0,0.9));
+  approval_tests.emplace_back(bezier_curve_defined(0,1.0));
+  approval_tests.emplace_back(bezier_curve_defined(0,1.1));
+
+  approval_tests.emplace_back(bezier_curve_defined(1,-0.1));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.0));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.1));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.2));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.3));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.4));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.5));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.6));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.7));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.8));
+  approval_tests.emplace_back(bezier_curve_defined(1,0.9));
+  approval_tests.emplace_back(bezier_curve_defined(1,1.0));
+  approval_tests.emplace_back(bezier_curve_defined(1,1.1));
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+
+TEST_CASE("WorldBuilder Utilities function: distance_point_from_curved_planes cartesian part 1")
+{
+  std::vector<double> approval_tests;
+
+  const std::unique_ptr<CoordinateSystems::Interface> cartesian_system = CoordinateSystems::Interface::create("cartesian", nullptr);;
+
+  //Todo:fix
+  //cartesian_system->declare_entries();
+
+  Point<3> position(10,0,0,cartesian);
+
+  Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(position,
+                                                                             *cartesian_system);
+  Point<2> reference_point(0,0,cartesian);
+
+  std::vector<Point<2> > coordinates;
+  coordinates.emplace_back(0,10,cartesian);
+  coordinates.emplace_back(20,10,cartesian);
+
+  std::vector<std::vector<double> > slab_segment_lengths(2);
+  slab_segment_lengths[0].push_back(std::sqrt(10*10+10*10));
+  slab_segment_lengths[0].push_back(200);
+  slab_segment_lengths[1].push_back(std::sqrt(10*10+10*10));
+  slab_segment_lengths[1].push_back(200);
+
+  const double dtr = Consts::PI/180;
+  std::vector<std::vector<Point<2> > > slab_segment_angles(2);
+  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
+
+  const double starting_radius = 10;
+
+  const std::vector<double> x_list = {0.,20.};
+  const std::vector<double> y_list = {10.,10.};
+  const std::vector<Point<2> > coordinate_list_local = coordinates;
+
+  Objects::BezierCurve bezier_curve(coordinate_list_local);
+
+  approval_tests.emplace_back(bezier_curve(0,-0.1)[0]);
+  approval_tests.emplace_back(bezier_curve(0,-0.1)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.0)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.0)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.1)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.1)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.2)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.2)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.3)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.3)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.4)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.4)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.5)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.5)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.6)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.6)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.7)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.7)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.8)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.8)[1]);
+  approval_tests.emplace_back(bezier_curve(0,0.9)[0]);
+  approval_tests.emplace_back(bezier_curve(0,0.9)[1]);
+  approval_tests.emplace_back(bezier_curve(0,1.0)[0]);
+  approval_tests.emplace_back(bezier_curve(0,1.0)[1]);
+  approval_tests.emplace_back(bezier_curve(0,1.1)[0]);
+  approval_tests.emplace_back(bezier_curve(0,1.1)[1]);
+
+
+  WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
+
+
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-4); // practically zero
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-5);
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.insert( approval_tests.end(), std::begin(distance_from_planes.closest_trench_point.get_array()),
+                         std::end(distance_from_planes.closest_trench_point.get_array()));
+
+
+  // center square test 2
+  reference_point[1] = 20;
+
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
+
+  // center square test 3
+  position[1] = 20;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
+
+  // center square test 4
+  reference_point[1] = 0;
+
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
+
+  // center square test 5
+  position[1] = -10;
+  position[2] = -10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
+
+  // begin section square test 6
+  position[0] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_section) < 1e-14);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.depth_reference_surface) > 1e-12 ? distance_from_planes.depth_reference_surface : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
+
+
+  // end section square test 7
+  position[0] = 20;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
+
+  // before begin section square test 8
+  position[0] = -10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  // The old method for slabs can not provide the corners when out of bounds and returns a nan. The new method can do this,
+  // and the old method is planned to be removed.
+  //CHECK(distance_from_planes.closest_trench_point.get_array() == std::array<double,3> {{NaN::DSNAN,NaN::DSNAN,10.}});
+
+
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.insert( approval_tests.end(), std::begin(distance_from_planes.closest_trench_point.get_array()), std::end(distance_from_planes.closest_trench_point.get_array()));
+
+
+  // beyond end section square test 9
+  position[0] = 25;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  // The old method for slabs can not provide the corners when out of bounds and returns a nan. The new method can do this,
+  // and the old method is planned to be removed.
+  //CHECK(distance_from_planes.closest_trench_point.get_array() == std::array<double,3> {{NaN::DSNAN,NaN::DSNAN,10.}});
+
+
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
+
+
+  // beyond end section square test 10
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 5;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
+  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
+
+  // beyond end section square test 10 (only positive version)
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 5;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 true,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+  // beyond end section square test 11
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = -5;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+  // beyond end section square test 11 (only positive version)
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = -5;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 true,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // add coordinate
+  position[0] = 25;
+  position[1] = 0;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  coordinates.emplace_back(30,10,cartesian);
+  bezier_curve = Objects::BezierCurve(coordinates);
+
+  slab_segment_lengths.resize(3);
+  slab_segment_lengths[2].push_back(std::sqrt(10*10+10*10));
+  slab_segment_lengths[2].push_back(200);
+
+  slab_segment_angles.resize(3);
+  slab_segment_angles[2].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[2].emplace_back(45 * dtr,45 * dtr,cartesian);
+
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14); // practically zero
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-12);
+
+  // different angle
+  slab_segment_angles[0][0][0] = 22.5 * dtr;
+  slab_segment_angles[0][0][1] = 22.5 * dtr;
+  slab_segment_angles[0][1][0] = 22.5 * dtr;
+  slab_segment_angles[0][1][1] = 22.5 * dtr;
+  slab_segment_angles[1][0][0] = 22.5 * dtr;
+  slab_segment_angles[1][0][1] = 22.5 * dtr;
+  slab_segment_angles[1][1][0] = 22.5 * dtr;
+  slab_segment_angles[1][1][1] = 22.5 * dtr;
+
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 10-10*tan(22.5*dtr);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane)<1e-10);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // check interpolation 1 (in the middle of a segment with 22.5 degree and a segment with 45)
+  position[0] = 25;
+  position[1] = 0;
+  position[2] = 10-10*tan((22.5*1.5)*dtr);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // check interpolation 2 (at the end of the segment at 45 degree)
+  position[0] = 30;
+  position[1] = 0;
+  position[2] = 10-10*tan(45*dtr);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // check length interpolation with 90 degree angles for simplicity
+  // check length interpolation first segment center 1
+  slab_segment_angles[0][0][0] = 90 * dtr;
+  slab_segment_angles[0][0][1] = 90 * dtr;
+  slab_segment_angles[0][1][0] = 90 * dtr;
+  slab_segment_angles[0][1][1] = 90 * dtr;
+  slab_segment_angles[1][0][0] = 90 * dtr;
+  slab_segment_angles[1][0][1] = 90 * dtr;
+  slab_segment_angles[1][1][0] = 90 * dtr;
+  slab_segment_angles[1][1][1] = 90 * dtr;
+  slab_segment_angles[2][0][0] = 90 * dtr;
+  slab_segment_angles[2][0][1] = 90 * dtr;
+  slab_segment_angles[2][1][0] = 90 * dtr;
+  slab_segment_angles[2][1][1] = 90 * dtr;
+
+  slab_segment_lengths[0][0] = 100;
+  slab_segment_lengths[0][1] = 100;
+  slab_segment_lengths[1][0] = 100;
+  slab_segment_lengths[1][1] = 100;
+  slab_segment_lengths[2][0] = 50;
+  slab_segment_lengths[2][1] = 50;
+
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = 10-100;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // check length interpolation first segment center 2
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = 10-101;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // check length interpolation first segment center 3
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = 10-200;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+
+  // check length interpolation first segment center 4
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = 10-201;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+
+  // Now check the center of the second segment, each segment should have a length of 75.
+  // check length interpolation second segment center 1
+  position[0] = 25;
+  position[1] = 10;
+  position[2] = 10-75;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // check length interpolation second segment center 2
+  position[0] = 25;
+  position[1] = 10;
+  position[2] = 10-76;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // check length interpolation second segment center 3
+  position[0] = 25;
+  position[1] = 10;
+  position[2] = 10-150;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+
+  // check length interpolation second segment center 4
+  position[0] = 25;
+  position[1] = 10;
+  position[2] = 10-151;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // Now check the end of the second segment, each segment should have a length of 50.
+  // check length interpolation second segment center 1
+  position[0] = 30;
+  position[1] = 10;
+  position[2] = 10-50;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // check length interpolation second segment center 2
+  position[0] = 30;
+  position[1] = 10;
+  position[2] = 10-51;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // check length interpolation second segment center 3
+  position[0] = 30;
+  position[1] = 10;
+  position[2] = 10-100;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+
+  // check length interpolation second segment center 4
+  position[0] = 30;
+  position[1] = 10;
+  position[2] = 10-101;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder Utilities function: distance_point_from_curved_planes cartesian part 2")
+{
+  std::vector<double> approval_tests;
+
+  const std::unique_ptr<CoordinateSystems::Interface> cartesian_system = CoordinateSystems::Interface::create("cartesian", nullptr);;
+
+  //todo: fix
+  //cartesian_system->declare_entries();
+
+  Point<3> position(10,0,0,cartesian);
+  Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(position,
+                                                                             *cartesian_system);
+  Point<2> reference_point(0,0,cartesian);
+
+  std::vector<Point<2> > coordinates;
+  coordinates.emplace_back(0,10,cartesian);
+  coordinates.emplace_back(20,10,cartesian);
+  coordinates.emplace_back(30,10,cartesian);
+
+  std::vector<std::vector<double> > slab_segment_lengths(3);
+  slab_segment_lengths[0].push_back(std::sqrt(10*10+10*10));
+  slab_segment_lengths[0].push_back(200);
+  slab_segment_lengths[1].push_back(std::sqrt(10*10+10*10));
+  slab_segment_lengths[1].push_back(200);
+  slab_segment_lengths[2].push_back(std::sqrt(10*10+10*10));
+  slab_segment_lengths[2].push_back(200);
+
+  const double dtr = Consts::PI/180;
+  std::vector<std::vector<Point<2> > > slab_segment_angles(3);
+  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[2].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[2].emplace_back(45 * dtr,45 * dtr,cartesian);
+
+  const double starting_radius = 10;
+  // Now test the curves into the depth
+  // curve test 1
+
+  slab_segment_angles[0][0][0] = 0.0 * dtr;
+  slab_segment_angles[0][0][1] = 45.0 * dtr;
+  slab_segment_angles[0][1][0] = 45.0 * dtr;
+  slab_segment_angles[0][1][1] = 90.0 * dtr;
+  slab_segment_angles[1][0][0] = 0.0 * dtr;
+  slab_segment_angles[1][0][1] = 45.0 * dtr;
+  slab_segment_angles[1][1][0] = 45.0 * dtr;
+  slab_segment_angles[1][1][1] = 90.0 * dtr;
+  slab_segment_angles[2][0][0] = 90 * dtr;
+  slab_segment_angles[2][0][1] = 90 * dtr;
+  slab_segment_angles[2][1][0] = 90 * dtr;
+  slab_segment_angles[2][1][1] = 90 * dtr;
+
+  slab_segment_lengths[0][0] = 10 * 45 * dtr;
+  slab_segment_lengths[0][1] = 10 * 45 * dtr;
+  slab_segment_lengths[1][0] = 10 * 45 * dtr;
+  slab_segment_lengths[1][1] = 10 * 45 * dtr;
+  slab_segment_lengths[2][0] = 5;
+  slab_segment_lengths[2][1] = 5;
+
+
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+
+
+  const std::vector<double> x_list = {0.,20., 30.};
+  const std::vector<double> y_list = {10.,10., 10.};
+  const std::vector<Point<2> > coordinate_list_local = coordinates;
+  const Objects::BezierCurve bezier_curve(coordinates);
+
+  WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinate_list_local,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-10);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+  // curve test 2
+  position[0] = 10;
+  position[1] = 5;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about 5 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+  // curve test 3
+  position[0] = 10;
+  position[1] = -5;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -5 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+
+  // curve test 4
+  position[0] = 10;
+  position[1] = 10 - 10 * sqrt(2)/2;
+  position[2] = 10 * sqrt(2)/2;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+  // curve test 5
+  position[0] = 10;
+  position[1] = 10 - 10 * sqrt(2);
+  position[2] = 10 * sqrt(2);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -10 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+  // curve test 6
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane)); // checked that it should be about 10 this with a drawing
+  // This is a special case where the point coincides with the center of the circle.
+  // Because all the points on the circle are equally close, we have chosen in the
+  // code to define this case as that this point belongs to the top of the top segment
+  // where the check point has angle 0. This means that the distanceAlongPlate is zero.
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+
+  // curve test 7
+  position[0] = 10;
+  position[1] = -5;
+  position[2] = -1;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+  // curve test 8
+  slab_segment_lengths[0][0] = 5 * 45 * dtr;
+  slab_segment_lengths[0][1] = 5 * 45 * dtr;
+  slab_segment_lengths[1][0] = 5 * 45 * dtr;
+  slab_segment_lengths[1][1] = 5 * 45 * dtr;
+
+  position[0] = 10;
+  position[1] = 5;
+  position[2] = 5;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+  // curve test 9
+  position[0] = 10;
+  position[1] = 10 - 5 * sqrt(2)/2;
+  position[2] = 5 + 5 * sqrt(2)/2;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+  // curve test 10
+  slab_segment_angles[0][0][0] = 0.0 * dtr;
+  slab_segment_angles[0][0][1] = 90.0 * dtr;
+  slab_segment_angles[0][1][0] = 90.0 * dtr;
+  slab_segment_angles[0][1][1] = 180.0 * dtr;
+  slab_segment_angles[1][0][0] = 0.0 * dtr;
+  slab_segment_angles[1][0][1] = 90.0 * dtr;
+  slab_segment_angles[1][1][0] = 90.0 * dtr;
+  slab_segment_angles[1][1][1] = 180.0 * dtr;
+
+  slab_segment_lengths[0][0] = 10 * 90 * dtr;
+  slab_segment_lengths[0][1] = 10 * 90 * dtr;
+  slab_segment_lengths[1][0] = 10 * 90 * dtr;
+  slab_segment_lengths[1][1] = 10 * 90 * dtr;
+
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 11
+  position[0] = 10;
+  position[1] = 10 - 10 * sqrt(2)/2;
+  position[2] = 10 * sqrt(2)/2;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 12
+  position[0] = 10;
+  position[1] = 10 - 10 * sqrt(2)/2;
+  position[2] = -10 * sqrt(2)/2;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
+
+
+  // curve test 13
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = -10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 14
+  slab_segment_angles[0][0][0] = 0.0 * dtr;
+  slab_segment_angles[0][0][1] = 180.0 * dtr;
+  slab_segment_angles[0][1][0] = 180.0 * dtr;
+  slab_segment_angles[0][1][1] = 270.0 * dtr;
+  slab_segment_angles[1][0][0] = 0.0 * dtr;
+  slab_segment_angles[1][0][1] = 180.0 * dtr;
+  slab_segment_angles[1][1][0] = 180.0 * dtr;
+  slab_segment_angles[1][1][1] = 270.0 * dtr;
+
+  slab_segment_lengths[0][0] = 10 * 180 * dtr;
+  slab_segment_lengths[0][1] = 10 * 90 * dtr;
+  slab_segment_lengths[1][0] = 10 * 180 * dtr;
+  slab_segment_lengths[1][1] = 10 * 90 * dtr;
+
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 15
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = -10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 16
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = -11;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -1 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 16
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = -9;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -1 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 17
+  position[0] = 10;
+  position[1] = 20;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+  // curve test 18
+  position[0] = 10;
+  position[1] = 21;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about 1 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 19
+  position[0] = 10;
+  position[1] = 19;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about 1 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+  // curve test 20
+  slab_segment_angles[0][0][0] = 0.0 * dtr;
+  slab_segment_angles[0][0][1] = 270.0 * dtr;
+  slab_segment_angles[0][1][0] = 270.0 * dtr;
+  slab_segment_angles[0][1][1] = 315.0 * dtr;
+  slab_segment_angles[1][0][0] = 0.0 * dtr;
+  slab_segment_angles[1][0][1] = 270.0 * dtr;
+  slab_segment_angles[1][1][0] = 270.0 * dtr;
+  slab_segment_angles[1][1][1] = 315.0 * dtr;
+
+  slab_segment_lengths[0][0] = 10 * 270 * dtr;
+  slab_segment_lengths[0][1] = 10 * 45 * dtr;
+  slab_segment_lengths[1][0] = 10 * 270 * dtr;
+  slab_segment_lengths[1][1] = 10 * 45 * dtr;
+
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 21
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = -10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 21
+  position[0] = 10;
+  position[1] = 20;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test 22
+  position[0] = 10;
+  position[1] = 10 + 1e-14 + 10 * sqrt(2)/2; // somehow it doesn't get the exact value here, so adding an epsiolon of 1e-14.
+  position[2] = 10 * sqrt(2)/2;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test start 45 degree 1
+  slab_segment_angles[0][0][0] = 45.0 * dtr;
+  slab_segment_angles[0][0][1] = 90.0 * dtr;
+  slab_segment_angles[0][1][0] = 90.0 * dtr;
+  slab_segment_angles[0][1][1] = 135.0 * dtr;
+  slab_segment_angles[1][0][0] = 45.0 * dtr;
+  slab_segment_angles[1][0][1] = 90.0 * dtr;
+  slab_segment_angles[1][1][0] = 90.0 * dtr;
+  slab_segment_angles[1][1][1] = 135.0 * dtr;
+
+  slab_segment_lengths[0][0] = 10 * 45 * dtr;
+  slab_segment_lengths[0][1] = 10 * 45 * dtr;
+  slab_segment_lengths[1][0] = 10 * 45 * dtr;
+  slab_segment_lengths[1][1] = 10 * 45 * dtr;
+  slab_segment_lengths[2][0] = 5;
+  slab_segment_lengths[2][1] = 5;
+
+
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -7.3 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test change reference point 1
+  reference_point[0] = 50;
+  reference_point[1] = 50;
+
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  // checked that distanceFromPlane should be infinity (it is on the other side of the circle this with a drawing
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test change reference point 2
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about 2.3 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test angle interpolation 1
+  reference_point[0] = 0;
+  reference_point[1] = 0;
+
+  slab_segment_angles[0][0][0] = 0.0 * dtr;
+  slab_segment_angles[0][0][1] = 180.0 * dtr;
+  slab_segment_angles[0][1][0] = 180.0 * dtr;
+  slab_segment_angles[0][1][1] = 270.0 * dtr;
+  slab_segment_angles[1][0][0] = 0.0 * dtr;
+  slab_segment_angles[1][0][1] = 90.0 * dtr;
+  slab_segment_angles[1][1][0] = 90.0 * dtr;
+  slab_segment_angles[1][1][1] = 135.0 * dtr;
+
+  slab_segment_lengths[0][0] = 10 * 135 * dtr;
+  slab_segment_lengths[0][1] = 10 * 67.5 * dtr;
+  slab_segment_lengths[1][0] = 10 * 135 * dtr;
+  slab_segment_lengths[1][1] = 10 * 67.5 * dtr;
+
+
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test reverse angle 1
+  reference_point[0] = 0;
+  reference_point[1] = 0;
+
+  slab_segment_angles[0][0][0] = 0.0 * dtr;
+  slab_segment_angles[0][0][1] = 90.0 * dtr;
+  slab_segment_angles[0][1][0] = 90.0 * dtr;
+  slab_segment_angles[0][1][1] = 0.0 * dtr;
+  slab_segment_angles[1][0][0] = 0.0 * dtr;
+  slab_segment_angles[1][0][1] = 90.0 * dtr;
+  slab_segment_angles[1][1][0] = 90.0 * dtr;
+  slab_segment_angles[1][1][1] = 0.0 * dtr;
+
+  slab_segment_lengths[0][0] = 10 * 90 * dtr;
+  slab_segment_lengths[0][1] = 10 * 90 * dtr;
+  slab_segment_lengths[1][0] = 10 * 90 * dtr;
+  slab_segment_lengths[1][1] = 10 * 90 * dtr;
+
+  position[0] = 10;
+  position[1] = 0;
+  position[2] = 0;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test reverse angle 2
+  position[0] = 10;
+  position[1] = -10;
+  position[2] = -10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test reverse angle 3
+  position[0] = 10;
+  position[1] = 10 - (20 - 10 * sqrt(2)/2);
+  position[2] = -10 * sqrt(2)/2;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test reverse angle 4
+  position[0] = 10;
+
+  double angle = 180+0.1;
+  position[1] = 10 - (20 * std::cos(0 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180));
+  position[2] = 0 * std::cos(0 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) ); // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+  // curve test reverse angle 5
+  position[0] = 10;
+  position[1] = 10 - (20 - 10 * std::cos(0.001 * Consts::PI/180));
+  position[2] = - 10 * std::sin(0.001 * Consts::PI/180);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test reverse angle 6
+  slab_segment_angles[0][0][0] = 0.0 * dtr;
+  slab_segment_angles[0][0][1] = 45.0 * dtr;
+  slab_segment_angles[0][1][0] = 45.0 * dtr;
+  slab_segment_angles[0][1][1] = 0.0 * dtr;
+  slab_segment_angles[1][0][0] = 0.0 * dtr;
+  slab_segment_angles[1][0][1] = 45.0 * dtr;
+  slab_segment_angles[1][1][0] = 45.0 * dtr;
+  slab_segment_angles[1][1][1] = 0.0 * dtr;
+
+  slab_segment_lengths[0][0] = 10 * 45 * dtr;
+  slab_segment_lengths[0][1] = 10 * 45 * dtr;
+  slab_segment_lengths[1][0] = 10 * 45 * dtr;
+  slab_segment_lengths[1][1] = 10 * 45 * dtr;
+
+  position[0] = 10;
+  position[1] = 10 - 10 * std::cos(45.000 * Consts::PI/180);
+  position[2] = 10 * std::sin(45.000 * Consts::PI/180);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-10); // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-10);
+
+  // curve test reverse angle 6
+  position[0] = 10;
+  angle = 45;
+  position[1] = 10 - (10 * std::cos((angle) * Consts::PI/180));
+  position[2] = 10 * std::sin((angle) * Consts::PI/180);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-10);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-10);
+
+  // curve test reverse angle 6
+  position[0] = 10;
+  angle = 180+45;
+  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180));
+  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-10);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-10);
+
+
+  // curve test reverse angle 7
+  position[0] = 10;
+  angle = 180+46;
+  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180));
+  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane)< 1e-10);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+
+  // curve test reverse angle 8
+  position[0] = 10;
+  angle = 180+46;
+  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180))+0.1;
+  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(fabs(distance_from_planes.distance_from_plane)); // checked that it should be small positive this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test reverse angle 9
+  position[0] = 10;
+  angle = 180+46;
+  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180))-0.1;
+  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be small negative this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // curve test reverse angle 10
+  position[0] = 10;
+  angle = 180+90;
+  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180));
+  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+  // global_x_list test 1
+  // reminder, coordinates are {0,10},{20,10},{30,10}
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = 10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // global_x_list test 2
+  position[0] = 10;
+  position[1] = 10;
+  position[2] = 10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // global_x_list test 3
+  position[0] = 15;
+  position[1] = 10;
+  position[2] = 10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14); // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) < 1e-14);
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // global_x_list test 4
+  position[0] = 20;
+  position[1] = 10;
+  position[2] = 10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14); // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) < 1e-14);
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // global_x_list test 5
+  position[0] = 25;
+  position[1] = 10;
+  position[2] = 10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane)); // checked that it should be about 0 this with a drawing
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-12);
+
+
+
+  // global_x_list test 6
+  position[0] = 30;
+  position[1] = 10;
+  position[2] = 10;
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *cartesian_system);
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 cartesian_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+
+TEST_CASE("WorldBuilder Utilities function: distance_point_from_curved_planes spherical")
+{
+  std::vector<double> approval_tests;
+
+  // Because most functionality is already tested by the cartesian version
+  // of this test case, the scope of this test case is only to test whether
+  // the code which is different for the spherical case is correct.
+
+  // spherical test 1
+  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_spherical.wb";
+  WorldBuilder::World world(file_name);
+
+  const double dtr = Consts::PI/180.0;
+  Point<3> position(10,0 * dtr,10 * dtr,spherical);
+  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
+
+  Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(position,
+                                                                             *(world.parameters.coordinate_system));
+  const Point<2> reference_point(0,0,spherical);
+
+  std::vector<Point<2> > coordinates;
+  coordinates.emplace_back(0 * dtr,10 * dtr,spherical);
+  coordinates.emplace_back(10 * dtr,10 * dtr,spherical);
+
+  std::vector<std::vector<double> > slab_segment_lengths(2);
+  slab_segment_lengths[0].push_back(std::sqrt(10*10+10*10));
+  slab_segment_lengths[0].push_back(200);
+  slab_segment_lengths[1].push_back(std::sqrt(10*10+10*10));
+  slab_segment_lengths[1].push_back(200);
+
+  //double dtr = Consts::PI/180;
+  std::vector<std::vector<Point<2> > > slab_segment_angles(2);
+  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
+  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
+
+  const double starting_radius = 10;
+
+  const std::vector<double> x_list = {0.,10 * dtr};
+  const std::vector<double> y_list = {10 * dtr,10 * dtr};
+  const std::vector<Point<2> > coordinate_list_local = coordinates;
+  const Objects::BezierCurve bezier_curve(coordinates);
+
+  WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 world.parameters.coordinate_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_section) < 1e-14);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14);
+
+
+  // spherical test 2
+  position = Point<3>(10,10 * dtr,10 * dtr,spherical);
+  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
+
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *(world.parameters.coordinate_system));
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 world.parameters.coordinate_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14); // practically zero
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) < 1e-14);
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14);
+
+
+  // spherical test 2
+  coordinates[0][0] = -10 * dtr;
+  coordinates[0][1] = 45 * dtr;
+  coordinates[1][0] = 10 * dtr;
+  coordinates[1][1] = 45 * dtr;
+  position = Point<3>(10,0 * dtr,45 * dtr,spherical);
+  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
+
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *(world.parameters.coordinate_system));
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 world.parameters.coordinate_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
+  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14);
+
+
+// spherical test 3
+  position = Point<3>(5,0 * dtr,45 * dtr,spherical);
+  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
+  natural_coordinate = Objects::NaturalCoordinate(position,
+                                                  *(world.parameters.coordinate_system));
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 world.parameters.coordinate_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+
+  /**
+   * I can't figure out why these are not working in the new structure, although I know it has to do with the different computation of the
+   * x-axis. In this new computation of the x-axis, the direction is no longer computed as perpendicual to the line P1-P2, but instead as
+   * the line from the closest point on the line to the check point. This is more accurate for the continuous case and seems to visually
+   * work well for the non-contiuous case, with only minor changes and of which some are clear improvements and for the rest it is not clear
+   * if is not clear whether it is an improvement or not. Since the new code seems to be an improvement, I don't have the original drawings
+   * at hand, don't have the time to redo them or spend much more time on these 18 checks, I will disable the failing parts of them for now.
+   */
+
+  /*
+  // spherical test 4
+  position = Point<3>(10*sqrt(2)/2,0 * dtr,90 * dtr,spherical);
+  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
+
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 world.parameters.coordinate_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked it with a geometric drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) < 1e-14); // checked it with a geometric drawing
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14);
+
+
+  // spherical test 5
+  position = Point<3>(10*sqrt(2)/2,0 * dtr,0 * dtr,spherical);
+  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
+
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 world.parameters.coordinate_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);  // checked it with a geometric drawing
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked it with a geometric drawing
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
+
+  // spherical curve test 1
+  // This test has not been checked analytically or with a drawing, but
+  // since the non-curved version works, and the visuals look oke, this
+  // test is used to see if this changes. Todo: Construct analytical
+  // solutions to test against.
+  slab_segment_angles[0][0][0] = 0.0 * dtr;
+  slab_segment_angles[0][0][1] = 45.0 * dtr;
+  slab_segment_angles[0][1][0] = 45.0 * dtr;
+  slab_segment_angles[0][1][1] = 0.0 * dtr;
+  slab_segment_angles[1][0][0] = 0.0 * dtr;
+  slab_segment_angles[1][0][1] = 45.0 * dtr;
+  slab_segment_angles[1][1][0] = 45.0 * dtr;
+  slab_segment_angles[1][1][1] = 0.0 * dtr;
+
+  position = Point<3>(10*sqrt(2)/2,0 * dtr,0 * dtr,spherical);
+  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
+
+  distance_from_planes =
+    Utilities::distance_point_from_curved_planes(position,
+                                                 natural_coordinate,
+                                                 reference_point,
+                                                 coordinates,
+                                                 slab_segment_lengths,
+                                                 slab_segment_angles,
+                                                 starting_radius,
+                                                 world.parameters.coordinate_system,
+                                                 false,
+                                                 bezier_curve);
+
+  approval_tests.emplace_back(distance_from_planes.distance_from_plane);  // see comment at the top of the test
+  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // see comment at the top of the test
+  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
+  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
+  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers*/
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder Utilities function: distance_point_from_curved_planes spherical depth methods")
+{
+  std::vector<double> approval_tests;
+
+  {
+    // starting point
+    const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/spherical_depth_method_starting_point.wb";
+    WorldBuilder::World world(file_name);
+
+    const double dtr = Consts::PI/180.0;
+    world.parse_entries(world.parameters);
+    approval_tests.emplace_back(world.parameters.coordinate_system->max_model_depth());
+    // slab goes down and up again
+    // origin
+    std::array<double,3> position = {{6371000 - 0, 0 * dtr, 0 * dtr}};
+    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
+    approval_tests.emplace_back(world.temperature(position, 0));
+    approval_tests.emplace_back(world.temperature(position, 1));
+    approval_tests.emplace_back(world.temperature(position, 200e3));
+    approval_tests.emplace_back(world.temperature(position, 210e3));
+
+    // ~330 km
+    position = {{6371000 - 0, 0 * dtr, -3 * dtr}};
+    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
+    approval_tests.emplace_back(world.temperature(position, 0));
+    approval_tests.emplace_back(world.temperature(position, 50e3));
+    approval_tests.emplace_back(world.temperature(position, 75e3));
+    approval_tests.emplace_back(world.temperature(position, 250e3));
+    approval_tests.emplace_back(world.temperature(position, 275e3));
+
+
+    // ~1100 km
+    position = {{6371000 - 0, 0 * dtr, -10 * dtr}};
+    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
+    approval_tests.emplace_back(world.temperature(position, 0));
+    approval_tests.emplace_back(world.temperature(position, 95e3));
+    approval_tests.emplace_back(world.temperature(position, 100e3));
+    approval_tests.emplace_back(world.temperature(position, 300e3));
+    approval_tests.emplace_back(world.temperature(position, 305e3));
+
+
+    // ~2200 km
+    position = {{6371000 - 0, 0 * dtr, -20 * dtr}};
+    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
+    approval_tests.emplace_back(world.temperature(position, 0));
+    approval_tests.emplace_back(world.temperature(position, 1));
+    approval_tests.emplace_back(world.temperature(position, 200e3));
+    approval_tests.emplace_back(world.temperature(position, 205e3));
+    approval_tests.emplace_back(world.temperature(position, 570e3));
+  }
+
+  {
+    // begin segment depth method
+    const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/spherical_depth_method_begin_segment.wb";
+    WorldBuilder::World world(file_name);
+
+    const double dtr = Consts::PI/180.0;
+    // origin
+    std::array<double,3> position = {{6371000 - 0, 0 * dtr, 0 * dtr}};
+    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
+    approval_tests.emplace_back(world.temperature(position, 0));
+    approval_tests.emplace_back(world.temperature(position, 1));
+    approval_tests.emplace_back(world.temperature(position, 200e3));
+    approval_tests.emplace_back(world.temperature(position, 210e3));
+
+    // ~330 km
+    position = {{6371000 - 0, 0 * dtr, -3 * dtr}};
+    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
+    approval_tests.emplace_back(world.temperature(position, 0));
+    approval_tests.emplace_back(world.temperature(position, 50e3));
+    approval_tests.emplace_back(world.temperature(position, 75e3));
+    approval_tests.emplace_back(world.temperature(position, 250e3));
+    approval_tests.emplace_back(world.temperature(position, 275e3));
+
+
+    // ~1100 km
+    position = {{6371000 - 0, 0 * dtr, -10 * dtr}};
+    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
+    approval_tests.emplace_back(world.temperature(position, 0));
+    approval_tests.emplace_back(world.temperature(position, 150e3));
+    approval_tests.emplace_back(world.temperature(position, 175e3));
+    approval_tests.emplace_back(world.temperature(position, 380e3));
+    approval_tests.emplace_back(world.temperature(position, 385e3));
+
+
+    // ~1100 km
+    position = {{6371000 - 0, 0 * dtr, -20 * dtr}};
+    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
+    approval_tests.emplace_back(world.temperature(position, 0));
+    approval_tests.emplace_back(world.temperature(position, 350e3));
+    approval_tests.emplace_back(world.temperature(position, 355e3));
+    approval_tests.emplace_back(world.temperature(position, 565e3));
+    approval_tests.emplace_back(world.temperature(position, 570e3));
+  }
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder parameters: invalid 1")
+{
+
+  CHECK_THROWS_WITH(WorldBuilder::World(WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/invalid_1.wb"),
+                    Contains("Invalid keyword: additionalPropertiesInvalid schema: #/test"));
+
+}
+
+TEST_CASE("Fast sin functions")
+{
+  for (int i = -400; i < 400; i++)
+    {
+      const double angle = (WorldBuilder::Consts::PI/100.)*static_cast<double>(i);
+      CHECK(fabs(FT::sin(angle)-std::sin(angle)) < 1.2e-5);
+    }
+
+  for (int i = -400; i < 400; i++)
+    {
+      const double angle = (WorldBuilder::Consts::PI/100.)*static_cast<double>(i);
+      CHECK(fabs(FT::cos(angle)-std::cos(angle)) < 1.2e-5);
+    }
+}
+
+TEST_CASE("Fast vs slow distance function")
+{
+  std::vector<double> approval_tests;
+  const Point<2> cartesian_1(1,2, cartesian);
+  const Point<2> cartesian_2(2,3, cartesian);
+  // Should be exactly the same.
+  approval_tests.emplace_back(sqrt(cartesian_1.cheap_relative_distance_cartesian(cartesian_2)));
+
+  const Point<2> spherical_1(1,2, spherical);
+  const Point<2> spherical_2(2,3, spherical);
+  // will have an error associated with the faster sin functions.
+  CHECK(fabs(2.0 * asin(sqrt((spherical_1.cheap_relative_distance_spherical(spherical_2))))- spherical_1.distance(spherical_2)) < 3e-5);
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("Fast version of fmod")
+{
+  CHECK(FT::fmod(0,1) == Approx(std::fmod(0,1)));
+  CHECK(FT::fmod(0.2,1) == Approx(std::fmod(0.2,1)));
+  CHECK(FT::fmod(1,1) == Approx(std::fmod(1,1)));
+  CHECK(FT::fmod(5.3,2) == Approx(std::fmod(5.3,2)));
+  CHECK(FT::fmod(18.5,4.2) == Approx(std::fmod(18.5,4.2)));
+  CHECK(std::isnan(FT::fmod(1,0)));
+  //CHECK(std::isnan(std::fmod(1,0))); Return a signaling NAN (FE_INVALID is raised)
+}
+
+TEST_CASE("WorldBuilder Utilities function: calculate_ridge_distance_and_spreading")
+{
+  std::vector<double> approval_tests;
+
+  const std::unique_ptr<CoordinateSystems::Interface> cartesian_system = CoordinateSystems::Interface::create("cartesian", nullptr);;
+
+  // Ridge properties
+  const Point<2> p1a(std::array<double,2> {{200e3, -1e3}},cartesian);
+  const Point<2> p1b(std::array<double,2> {{200e3, 50e3}},cartesian);
+  const Point<2> p2a(std::array<double,2> {{50e3, 50e3}},cartesian);
+  const Point<2> p2b(std::array<double,2> {{50e3, 101e3}},cartesian);
+  const Point<2> p2c(std::array<double,2> {{100e3, 151e3}},cartesian);
+  const std::vector<Point<2>> mid_ocean_ridges_segment_1 = {p1a, p1b};
+  const std::vector<Point<2>> mid_ocean_ridges_segment_2 = {p2a, p2b, p2c};
+
+  std::vector<std::vector<Point<2>>> mid_oceanic_ridges;
+  mid_oceanic_ridges.push_back(mid_ocean_ridges_segment_1);
+  mid_oceanic_ridges.push_back(mid_ocean_ridges_segment_2);
+
+  const double mid_oceanic_spreading_velocitie_1a =  1.0;
+  const double mid_oceanic_spreading_velocitie_1b =  2.0;
+  const double mid_oceanic_spreading_velocitie_2a =  3.0;
+  const double mid_oceanic_spreading_velocitie_2b =  4.0;
+  const double mid_oceanic_spreading_velocitie_2c =  5.0;
+
+  std::vector<double> mid_oceanic_spreading_velocities_segment1 = {mid_oceanic_spreading_velocitie_1a, mid_oceanic_spreading_velocitie_1b};
+  std::vector<double> mid_oceanic_spreading_velocities_segment2 = {mid_oceanic_spreading_velocitie_2a, mid_oceanic_spreading_velocitie_2b,
+                                                                   mid_oceanic_spreading_velocitie_2c
+                                                                  };
+
+  std::vector<std::vector<double>> mid_oceanic_spreading_velocities;
+  mid_oceanic_spreading_velocities.push_back(mid_oceanic_spreading_velocities_segment1);
+  mid_oceanic_spreading_velocities.push_back(mid_oceanic_spreading_velocities_segment2);
+
+  const std::vector<std::vector<double>> subducting_plate_velocities = {{0.0}};
+  const std::vector<double> &ridge_migration_times = {0.0};
+
+  // Query point 1
+  Point<3> position_1(1e3,0,0,cartesian);
+  Objects::NaturalCoordinate position_in_natural_coordinates_1 = Objects::NaturalCoordinate(position_1,
+                                                                 *cartesian_system);
+
+  const std::vector<double> result1 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                      mid_oceanic_spreading_velocities,
+                                      cartesian_system,
+                                      position_in_natural_coordinates_1,
+                                      subducting_plate_velocities,
+                                      ridge_migration_times);
+  approval_tests.emplace_back(result1[0]); // spreading velocity at ridge
+  approval_tests.emplace_back(result1[1]); // ridge distance
+  approval_tests.emplace_back(result1[2]); // subducting velocity at trench
+  approval_tests.emplace_back(result1[3]); // ridge migration time
+
+  // Query point 2: locates outside of the ridge, current solution is to take the end point as the reference point
+  Point<3> position_2(1e3,-2e3,0,cartesian);
+  Objects::NaturalCoordinate position_in_natural_coordinates_2 = Objects::NaturalCoordinate(position_2,
+                                                                 *cartesian_system);
+
+  const std::vector<double> result2 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                      mid_oceanic_spreading_velocities,
+                                      cartesian_system,
+                                      position_in_natural_coordinates_2,
+                                      subducting_plate_velocities,
+                                      ridge_migration_times);
+  approval_tests.emplace_back(result2[0]); // spreading velocity at ridge
+  approval_tests.emplace_back(result2[1]); // ridge distance
+  approval_tests.emplace_back(result2[2]); // subducting velocity at trench
+  approval_tests.emplace_back(result2[3]); // ridge migration time
+
+  // Query point 3: the nearest point on the ridge is in the middle of p2b and p2c
+  // thus it should have intermediate velocity values
+  Point<3> position_3(50e3,151e3,0,cartesian);
+  Objects::NaturalCoordinate position_in_natural_coordinates_3 = Objects::NaturalCoordinate(position_3,
+                                                                 *cartesian_system);
+
+  const std::vector<double> result3 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                      mid_oceanic_spreading_velocities,
+                                      cartesian_system,
+                                      position_in_natural_coordinates_3,
+                                      subducting_plate_velocities,
+                                      ridge_migration_times);
+  approval_tests.emplace_back(result3[0]); // spreading velocity at ridge
+  approval_tests.emplace_back(result3[1]); // ridge distance
+  approval_tests.emplace_back(result3[2]); // subducting velocity at trench
+  approval_tests.emplace_back(result3[3]); // ridge migration time
+
+  // Query point 4: the nearest point on the ridge is in the middle of p2a and p2b
+  // thus it should have intermediate velocity values
+  Point<3> position_4(100e3,76e3,0,cartesian);
+  Objects::NaturalCoordinate position_in_natural_coordinates_4 = Objects::NaturalCoordinate(position_4,
+                                                                 *cartesian_system);
+
+  const std::vector<double> result4 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                      mid_oceanic_spreading_velocities,
+                                      cartesian_system,
+                                      position_in_natural_coordinates_4,
+                                      subducting_plate_velocities,
+                                      ridge_migration_times);
+  approval_tests.emplace_back(result4[0]); // spreading velocity at ridge
+  approval_tests.emplace_back(result4[1]); // ridge distance
+  approval_tests.emplace_back(result4[2]); // subducting velocity at trench
+  approval_tests.emplace_back(result4[3]); // ridge migration time
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+TEST_CASE("WorldBuilder Utilities function: calculate_ridge_distance_and_spreading spherical")
+{
+  std::vector<double> approval_tests;
+
+  const std::unique_ptr<CoordinateSystems::Interface> spherical_system = CoordinateSystems::Interface::create("spherical", nullptr);;
+
+  // Ridge properties
+  const Point<2> p1a(std::array<double,2> {{0.3491, -0.6981}},spherical);
+  const Point<2> p1b(std::array<double,2> {{0.3491, 0.0}},spherical);
+  const Point<2> p2a(std::array<double,2> {{0.1745, 0.0}},spherical);
+  const Point<2> p2b(std::array<double,2> {{0.1745, 0.5236}},spherical);
+  const Point<2> p2c(std::array<double,2> {{0.3491, 0.6981}},spherical);
+  const std::vector<Point<2>> mid_ocean_ridges_segment_1 = {p1a, p1b};
+  const std::vector<Point<2>> mid_ocean_ridges_segment_2 = {p2a, p2b, p2c};
+
+  std::vector<std::vector<Point<2>>> mid_oceanic_ridges;
+  mid_oceanic_ridges.push_back(mid_ocean_ridges_segment_1);
+  mid_oceanic_ridges.push_back(mid_ocean_ridges_segment_2);
+
+  const double mid_oceanic_spreading_velocitie_1a =  1.0;
+  const double mid_oceanic_spreading_velocitie_1b =  2.0;
+  const double mid_oceanic_spreading_velocitie_2a =  3.0;
+  const double mid_oceanic_spreading_velocitie_2b =  4.0;
+  const double mid_oceanic_spreading_velocitie_2c =  5.0;
+
+  std::vector<double> mid_oceanic_spreading_velocities_segment1 = {mid_oceanic_spreading_velocitie_1a, mid_oceanic_spreading_velocitie_1b};
+  std::vector<double> mid_oceanic_spreading_velocities_segment2 = {mid_oceanic_spreading_velocitie_2a, mid_oceanic_spreading_velocitie_2b,
+                                                                   mid_oceanic_spreading_velocitie_2c
+                                                                  };
+
+  std::vector<std::vector<double>> mid_oceanic_spreading_velocities;
+  mid_oceanic_spreading_velocities.push_back(mid_oceanic_spreading_velocities_segment1);
+  mid_oceanic_spreading_velocities.push_back(mid_oceanic_spreading_velocities_segment2);
+
+  const std::vector<std::vector<double>> subducting_plate_velocities = {{0.0}};
+  const std::vector<double> &ridge_migration_times = {0.0};
+
+  // Query point 1, the nearest point on the ridge is in the middle of p1a and p1b
+  Point<3> position_1(6371e3, 0.1745, -0.3491, spherical);
+  Objects::NaturalCoordinate position_in_natural_coordinates_1 = Objects::NaturalCoordinate(Utilities::spherical_to_cartesian_coordinates(position_1.get_array()),
+                                                                 *spherical_system);
+
+  const std::vector<double> result1 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                      mid_oceanic_spreading_velocities,
+                                      spherical_system,
+                                      position_in_natural_coordinates_1,
+                                      subducting_plate_velocities,
+                                      ridge_migration_times);
+  approval_tests.emplace_back(result1[0]); // spreading velocity at ridge
+  approval_tests.emplace_back(result1[1]); // ridge distance
+  approval_tests.emplace_back(result1[2]); // subducting velocity at trench
+  approval_tests.emplace_back(result1[3]); // ridge migration time
+
+  // Query point 2, the nearest point on the ridge is in the middle of p2b and p2c
+  Point<3> position_2(6371e3, 0.3491, 0.5236, spherical);
+  Objects::NaturalCoordinate position_in_natural_coordinates_2 = Objects::NaturalCoordinate(Utilities::spherical_to_cartesian_coordinates(position_2.get_array()),
+                                                                 *spherical_system);
+
+  const std::vector<double> result2 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                      mid_oceanic_spreading_velocities,
+                                      spherical_system,
+                                      position_in_natural_coordinates_2,
+                                      subducting_plate_velocities,
+                                      ridge_migration_times);
+  approval_tests.emplace_back(result2[0]); // spreading velocity at ridge
+  approval_tests.emplace_back(result2[1]); // ridge distance
+  approval_tests.emplace_back(result2[2]); // subducting velocity at trench
+  approval_tests.emplace_back(result2[3]); // ridge migration time
+
+  // Query point 3, the nearest point on the ridge is p2b, the purpose is to test a negative value of longitude
+  Point<3> position_3(6371e3, -0.1745, 0.5236, spherical);
+  Objects::NaturalCoordinate position_in_natural_coordinates_3 = Objects::NaturalCoordinate(Utilities::spherical_to_cartesian_coordinates(position_3.get_array()),
+                                                                 *spherical_system);
+
+  const std::vector<double> result3 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
+                                      mid_oceanic_spreading_velocities,
+                                      spherical_system,
+                                      position_in_natural_coordinates_3,
+                                      subducting_plate_velocities,
+                                      ridge_migration_times);
+  approval_tests.emplace_back(result3[0]); // spreading velocity at ridge
+  approval_tests.emplace_back(result3[1]); // ridge distance
+  approval_tests.emplace_back(result3[2]); // subducting velocity at trench
+  approval_tests.emplace_back(result3[3]); // ridge migration time
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+}
+
+
+TEST_CASE("WorldBuilder Utilities function: calculate_effective_trench_and_plate_ages")
+{
+  std::vector<double> approval_tests;
+
+  // test 1:  trivial case, spreading velocity = subducting velocity and no ridge migration
+  const std::vector<double> ridge_parameters_1 = {4.75299e-10, 1.04512e+06, 4.75299e-10, 0.0}; // m/s, m, m/s, s
+  const double distance_along_plane_1 = 1000e3;
+  std::vector<double> result1 = Utilities::calculate_effective_trench_and_plate_ages(ridge_parameters_1, distance_along_plane_1);
+
+  approval_tests.emplace_back(result1[0]); // age at trench
+  approval_tests.emplace_back(result1[1]); // effective plate age
+
+  // test 2:  2 * spreading velocity = subducting velocity and no ridge migration, trench retreating
+  std::vector<double> ridge_parameters_2 = {4.75299e-10, 1.04512e+06, 9.50598e-10, 0.0}; // m/s, m, m/s, s
+  const double distance_along_plane_2 = 1000e3;
+  std::vector<double> result2 = Utilities::calculate_effective_trench_and_plate_ages(ridge_parameters_2, distance_along_plane_2);
+
+  approval_tests.emplace_back(result2[0]); // age at trench
+  approval_tests.emplace_back(result2[1]); // effective plate age
+
+  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
+
+  // test 3: negative subducting velocity triggers error
+  std::vector<double> ridge_parameters_3 = {4.75299e-10, 1.04512e+06, -9.50598e-10, 0.0}; // m/s, m, m/s, s
+  const double distance_along_plane_3 = 1000e3;
+  CHECK_THROWS_WITH(Utilities::calculate_effective_trench_and_plate_ages(ridge_parameters_3, distance_along_plane_3),
+                    Contains("The subducting velocity is less than 0."));
+
+  // test 4:  subducting velocity is too small, causing negative trench age at subducting initiation
+  std::vector<double> ridge_parameters_4 = {4.75299e-10, 1.04512e+06, 9.50598e-11, 0.0}; // m/s, m, m/s, s
+  const double distance_along_plane_4 = 1000e3;
+  CHECK_THROWS_WITH(Utilities::calculate_effective_trench_and_plate_ages(ridge_parameters_4, distance_along_plane_4),
+                    Contains("The age of trench at subducting initiation is less than 0. "));
+}
diff --git a/cookbooks/2d_annulus_visualization/2d_annulus_example.prm.bak b/cookbooks/2d_annulus_visualization/2d_annulus_example.prm.bak
new file mode 100644
index 00000000000..08d1554f2b4
--- /dev/null
+++ b/cookbooks/2d_annulus_visualization/2d_annulus_example.prm.bak
@@ -0,0 +1,89 @@
+# This setup is a copy of
+# cookbook/onset-of-convection/onset-of-convection.prm
+# with the difference that the geometry is a 2D cylindrical
+# annulus and the initial and boundary temperatures
+# are reduced to generate a lower Rayleigh number system.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use conduction timestep                = true
+
+subsection Termination criteria
+  set Termination criteria                 = end step
+  set End step                             = 100
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Outer radius = 6371000
+    set Inner radius = 3481000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r,phi
+    set Function expression = 1600 + 10*sin(10*phi)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2000
+    set Outer temperature = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 4000
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity                     = 1e23
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set Time steps between graphical output = 5
+  end
+end
diff --git a/cookbooks/allken_et_al_2012_rift_interaction/allken.prm b/cookbooks/allken_et_al_2012_rift_interaction/allken.prm
index a42b73d30c3..fbe89f631e1 100644
--- a/cookbooks/allken_et_al_2012_rift_interaction/allken.prm
+++ b/cookbooks/allken_et_al_2012_rift_interaction/allken.prm
@@ -5,7 +5,7 @@ set Dimension                              = 3
 set Start time                             = 0
 set End time                               = 5e6
 set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Stokes
+set Nonlinear solver scheme                = single Advection, iterated Stokes
 set Nonlinear solver tolerance             = 1e-4
 set Max nonlinear iterations               = 25
 set Output directory                       = output-allken_etal_2012
diff --git a/cookbooks/allken_et_al_2012_rift_interaction/allken.prm.bak b/cookbooks/allken_et_al_2012_rift_interaction/allken.prm.bak
new file mode 100644
index 00000000000..a42b73d30c3
--- /dev/null
+++ b/cookbooks/allken_et_al_2012_rift_interaction/allken.prm.bak
@@ -0,0 +1,155 @@
+# Input file to replicate Allken et al, G3, 2012.
+
+#  Global parameters
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 5e6
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Stokes
+set Nonlinear solver tolerance             = 1e-4
+set Max nonlinear iterations               = 25
+set Output directory                       = output-allken_etal_2012
+set Pressure normalization                 = no
+set CFL number                             = .5
+
+# Solver settings
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+    set Stokes solver type = block AMG
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 7
+    set Y repetitions = 7
+    set Z repetitions = 1
+    set X extent      = 210e3
+    set Y extent      = 210e3
+    set Z extent      = 30e3
+  end
+end
+
+# Mesh refinement specifications.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 1
+  set Refinement fraction                = 0.5
+  set Strategy                           = strain rate
+  set Coarsening fraction                = 0
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+  set Additional tangential mesh velocity boundary indicators = left,right
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+end
+
+# Velocity boundary conditions
+# The imposed velocity produces a background strain-rate of approx. 1.51e-15.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = front,back,bottom
+  set Prescribed velocity boundary indicators = left x: function, right x:function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = cm=0.01, year=1, vel=0.5
+    set Function expression = if (x<20e3 , -vel*cm/year, vel*cm/year); 0; 0
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = noninitial_plastic_strain, plastic_strain , lower_crust
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = xL=85e3 , xR=135e3
+    set Function expression = 0; \
+                              if( (y<=50e3  && abs(x-xL)<=4e3 && z>=15e3 && z<=19e3) || \
+                                  (y>=160e3 && abs(x-xR)<=4e3 && z>=15e3 && z<=19e3),1.25,0); \
+                              if(z<=15e3, 1, 0);
+  end
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# Temperature initial conditions (isothermal)
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Densities                   = 2800
+    set Reference strain rate       = 1.51e-15
+    set Maximum viscosity           = 1.e24
+    set Minimum viscosity           = 1.e19
+    set Viscous flow law            = diffusion
+    set Grain size exponents for diffusion creep = 0.
+    set Prefactors for diffusion creep          = 5e-26,1e-50,1e-50,5e-21
+    set Activation energies for diffusion creep = 0.
+    set Activation volumes for diffusion creep  = 0.
+    set Viscosity averaging scheme  = maximum composition
+    set Angles of internal friction = 15.
+    set Cohesions                   = 20.e6
+
+    # The parameters below weaken the friction and cohesion by a
+    # a factor of 4 between plastic strain values of 0.25 and 1.25.
+    set Strain weakening mechanism                   = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals  = 0.25
+    set End plasticity strain weakening intervals    = 1.25
+    set Cohesion strain weakening factors            = 0.25
+    set Friction strain weakening factors            = 0.25
+    set Use plastic damper = true
+    set Plastic damper viscosity = 5e19
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, velocity statistics, visualization, topography
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate, named additional outputs
+    set Time between graphical output = 10e3
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+end
diff --git a/cookbooks/anisotropic_viscosity/AV_Rayleigh_Taylor.prm.bak b/cookbooks/anisotropic_viscosity/AV_Rayleigh_Taylor.prm.bak
new file mode 100644
index 00000000000..8d4fc00b635
--- /dev/null
+++ b/cookbooks/anisotropic_viscosity/AV_Rayleigh_Taylor.prm.bak
@@ -0,0 +1,100 @@
+# This cookbook uses the implementation of anisotropic viscosity terms in the Stokes
+# equation. Here, it is applied to the Rayleigh-Taylor instability problem, following
+# Lev and Hager (2008) and Perry-Houts and Karlstrom (2019) and the van Keken cookbook.
+#
+
+set Additional shared libraries = ./libanisotropic_viscosity.so
+set Dimension = 2
+set CFL number                             = 0.5
+set Start time                             = 0
+set End time                               = 30
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Output directory                       = output-AV-Rayleigh-Taylor-noAV
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2 # width of the box, present in the functions of the compositional fields
+    set Y extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+# 3 compositional fields, 1 for the material, 2 for the anisotropic viscosity (AV) normals
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = gamma, ni, nj
+end
+
+subsection Material model
+  set Model name = AV material
+
+  # density is hard-coded into the AV_material.cc plugin
+  # everything else is set to 0
+
+  subsection AV
+    set Normal viscosity    = 1
+    set Shear viscosity     = 1
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926;
+    set Function expression = 0.5*(1+tanh((z-0.85-0.02*cos(2*pi*x/2))/0.02)); \
+                            (0.5*(1+tanh((z-0.85-0.02*cos(2*pi*x/2))/0.02))) > 0.8 ? sin(45*pi/180) : 0.0; \
+                            (0.5*(1+tanh((z-0.85-0.02*cos(2*pi*x/2))/0.02))) > 0.8 ? cos(45*pi/180) : 0.0;
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 6
+  set Initial adaptive refinement        = 2
+  set Strategy                           = composition
+  set Time steps between mesh refinement = 1
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics, material statistics
+
+  subsection Visualization
+    # add "named additional outputs" to the list to save the stress-strain director (AV tensor)
+    set List of output variables = compositional vector, density, viscosity, gravity, shear stress, stress, strain rate, strain rate tensor, named additional outputs
+    set Output format                 = vtu
+    set Time between graphical output = 0.5
+
+    subsection Compositional fields as vectors
+      set Names of fields = ni,nj
+      set Names of vectors = n
+    end
+  end
+end
diff --git a/cookbooks/anisotropic_viscosity/av_material.cc.bak b/cookbooks/anisotropic_viscosity/av_material.cc.bak
new file mode 100644
index 00000000000..e475d22e459
--- /dev/null
+++ b/cookbooks/anisotropic_viscosity/av_material.cc.bak
@@ -0,0 +1,831 @@
+/*
+ Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/introspection.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/plugins.h>
+#include <aspect/simulator/assemblers/interface.h>
+#include <deal.II/base/exceptions.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/patterns.h>
+#include <deal.II/base/point.h>
+#include <deal.II/base/quadrature.h>
+#include <deal.II/base/table_indices.h>
+#include <deal.II/base/tensor.h>
+#include <deal.II/fe/fe.h>
+#include <deal.II/fe/fe_update_flags.h>
+#include <deal.II/grid/tria_iterator_base.h>
+#include <array>
+#include <cmath>
+#include <functional>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <aspect/simulator_access.h>
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/base/geometry_info.h>
+
+#include <aspect/material_model/simple.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/heating_model/shear_heating.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator/assemblers/stokes.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/postprocess/particles.h>
+
+#include <deal.II/base/symmetric_tensor.h>
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * Additional output fields for anisotropic viscosities to be added to
+     * the MaterialModel::MaterialModelOutputs structure and filled in the
+     * MaterialModel::Interface::evaluate() function.
+     */
+    template <int dim>
+    class AnisotropicViscosity : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        AnisotropicViscosity(const unsigned int n_points);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * Stress-strain "director" tensors at the given positions. This
+         * variable is used to implement anisotropic viscosity.
+         *
+         * @note The strain rate term in equation (1) of the manual will be
+         * multiplied by this tensor *and* the viscosity scalar ($\eta$), as
+         * described in the manual section titled "Constitutive laws". This
+         * variable is assigned the rank-four identity tensor by default.
+         * This leaves the isotropic constitutive law unchanged if the material
+         * model does not explicitly assign a value.
+         */
+        std::vector<SymmetricTensor<4,dim>> stress_strain_directors;
+    };
+
+    namespace
+    {
+
+
+
+      template <int dim>
+      std::vector<std::string> make_AnisotropicViscosity_additional_outputs_names()
+      {
+        std::vector<std::string> names;
+
+        for (unsigned int i = 0; i < Tensor<4,dim>::n_independent_components ; ++i)
+          {
+            TableIndices<4> indices(Tensor<4,dim>::unrolled_to_component_indices(i));
+            names.push_back("anisotropic_viscosity"+std::to_string(indices[0])+std::to_string(indices[1])+std::to_string(indices[2])+std::to_string(indices[3]));
+          }
+        return names;
+      }
+    }
+
+
+
+    template <int dim>
+    AnisotropicViscosity<dim>::AnisotropicViscosity (const unsigned int n_points)
+      :
+      NamedAdditionalMaterialOutputs<dim>(make_AnisotropicViscosity_additional_outputs_names<dim>()),
+      stress_strain_directors(n_points, dealii::identity_tensor<dim> ())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    AnisotropicViscosity<dim>::get_nth_output(const unsigned int idx) const
+    {
+      std::vector<double> output(stress_strain_directors.size());
+      for (unsigned int i = 0; i < stress_strain_directors.size() ; ++i)
+        {
+          output[i]= stress_strain_directors[i][Tensor<4,dim>::unrolled_to_component_indices(idx)];
+        }
+      return output;
+    }
+  }
+}
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    /**
+     * A class containing the functions to assemble the Stokes preconditioner.
+     */
+    template <int dim>
+    class StokesPreconditionerAnisotropicViscosity : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
+
+        /**
+         * Create AnisotropicViscosities.
+         */
+        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+    };
+
+    /**
+     * This class assembles the terms for the matrix and right-hand-side of the incompressible
+     * Stokes equation for the current cell.
+     */
+    template <int dim>
+    class StokesIncompressibleTermsAnisotropicViscosity : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
+
+        /**
+         * Create AdditionalMaterialOutputsStokesRHS if we need to do so.
+         */
+        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+    };
+
+
+
+    template <int dim>
+    void
+    StokesPreconditionerAnisotropicViscosity<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
+
+      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      // First loop over all dofs and find those that are in the Stokes system
+      // save the component (pressure and dim velocities) each belongs to.
+      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+        {
+          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+            {
+              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
+              ++i_stokes;
+            }
+          ++i;
+        }
+
+      // Loop over all quadrature points and assemble their contributions to
+      // the preconditioner matrix
+      for (unsigned int q = 0; q < n_q_points; ++q)
+        {
+          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.grads_phi_u[i_stokes] =
+                    scratch.finite_element_values[introspection.extractors
+                                                  .velocities].symmetric_gradient(i, q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection
+                                                                          .extractors.pressure].value(i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const double eta = scratch.material_model_outputs.viscosities[q];
+          const double one_over_eta = 1. / eta;
+          const SymmetricTensor<4, dim> &stress_strain_director = anisotropic_viscosity->stress_strain_directors[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+            for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
+              if (scratch.dof_component_indices[i] ==
+                  scratch.dof_component_indices[j])
+                data.local_matrix(i, j) += (2.0 * eta * (scratch.grads_phi_u[i]
+                                                         * stress_strain_director
+                                                         * scratch.grads_phi_u[j])
+                                            + one_over_eta * pressure_scaling
+                                            * pressure_scaling
+                                            * (scratch.phi_p[i]
+                                               * scratch.phi_p[j]))
+                                           * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesPreconditionerAnisotropicViscosity<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      const unsigned int n_points = outputs.viscosities.size();
+
+      if (outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesIncompressibleTermsAnisotropicViscosity<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
+      *force = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  if (scratch.rebuild_stokes_matrix)
+                    {
+                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+                    }
+                  ++i_stokes;
+                }
+              ++i;
+            }
+          // Viscosity scalar
+          const double eta = (scratch.rebuild_stokes_matrix
+                              ?
+                              scratch.material_model_outputs.viscosities[q]
+                              :
+                              numbers::signaling_nan<double>());
+
+          const SymmetricTensor<4, dim> &stress_strain_director = anisotropic_viscosity->stress_strain_directors[q];
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+
+          const double density = scratch.material_model_outputs.densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i) += (density * gravity * scratch.phi_u[i])
+                                   * JxW;
+
+              if (force != nullptr)
+                data.local_rhs(i) += (force->rhs_u[q] * scratch.phi_u[i]
+                                      + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i])
+                                     * JxW;
+
+              if (scratch.rebuild_stokes_matrix)
+                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                  {
+                    data.local_matrix(i,j) += ( eta * 2.0 * (scratch.grads_phi_u[i] * stress_strain_director * scratch.grads_phi_u[j])
+                                                // assemble \nabla p as -(p, div v):
+                                                - (pressure_scaling *
+                                                   scratch.div_phi_u[i] * scratch.phi_p[j])
+                                                // assemble the term -div(u) as -(div u, q).
+                                                // Note the negative sign to make this
+                                                // operator adjoint to the grad p term:
+                                                - (pressure_scaling *
+                                                   scratch.phi_p[i] * scratch.div_phi_u[j]))
+                                              * JxW;
+                  }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesIncompressibleTermsAnisotropicViscosity<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      const unsigned int n_points = outputs.viscosities.size();
+
+      if (outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
+        }
+
+      if (this->get_parameters().enable_additional_stokes_rhs
+          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>> (n_points));
+        }
+      Assert(!this->get_parameters().enable_additional_stokes_rhs
+             ||
+             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
+             == n_points, ExcInternalError());
+    }
+  }
+
+  namespace HeatingModel
+  {
+    template <int dim>
+    class ShearHeatingAnisotropicViscosity : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Compute the heating model outputs for this class.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * Allow the heating model to attach additional material model outputs.
+         */
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const override;
+    };
+
+
+
+    template <int dim>
+    void
+    ShearHeatingAnisotropicViscosity<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.position.size(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.strain_rate.size(),
+             ExcMessage ("The shear heating plugin needs the strain rate!"));
+
+      // Some material models provide dislocation viscosities and boundary area work fractions
+      // as additional material outputs. If they are attached, use them.
+      const ShearHeatingOutputs<dim> *shear_heating_out =
+        material_model_outputs.template get_additional_output<ShearHeatingOutputs<dim>>();
+
+      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          // If there is an anisotropic viscosity, use it to compute the correct stress
+          const SymmetricTensor<2,dim> &directed_strain_rate = ((anisotropic_viscosity != nullptr)
+                                                                ?
+                                                                anisotropic_viscosity->stress_strain_directors[q]
+                                                                * material_model_inputs.strain_rate[q]
+                                                                :
+                                                                material_model_inputs.strain_rate[q]);
+
+          const SymmetricTensor<2,dim> stress =
+            2 * material_model_outputs.viscosities[q] *
+            (this->get_material_model().is_compressible()
+             ?
+             directed_strain_rate - 1./3. * trace(directed_strain_rate) * unit_symmetric_tensor<dim>()
+             :
+             directed_strain_rate);
+
+          const SymmetricTensor<2,dim> deviatoric_strain_rate =
+            (this->get_material_model().is_compressible()
+             ?
+             material_model_inputs.strain_rate[q]
+             - 1./3. * trace(material_model_inputs.strain_rate[q]) * unit_symmetric_tensor<dim>()
+             :
+             material_model_inputs.strain_rate[q]);
+
+          heating_model_outputs.heating_source_terms[q] = stress * deviatoric_strain_rate;
+
+          // If shear heating work fractions are provided, reduce the
+          // overall heating by this amount (which is assumed to be converted into other forms of energy)
+          if (shear_heating_out != nullptr)
+            heating_model_outputs.heating_source_terms[q] *= shear_heating_out->shear_heating_work_fractions[q];
+
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    ShearHeatingAnisotropicViscosity<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const
+    {
+      const unsigned int n_points = material_model_outputs.viscosities.size();
+
+      if (material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
+        {
+          material_model_outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
+        }
+
+      this->get_material_model().create_additional_named_outputs(material_model_outputs);
+    }
+  }
+
+  namespace MaterialModel
+  {
+    // The AV material model calculates an anisotropic viscosity tensor from director vectors and the normal and shear
+    // viscosities (defined in the .prm file). In contrast to the `Anisotropic` material model, the principal directions of the
+    // tensor are not read from an input file, but instead are computed at every quadrature point. This material model is used in T independent models.
+    // All the parameters are defined below.
+    template <int dim>
+    class AV : public MaterialModel::Simple<dim>
+    {
+      public:
+        void initialize() override;
+
+        void evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
+                       MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        static void declare_parameters (ParameterHandler &prm);
+
+        void parse_parameters (ParameterHandler &prm) override;
+
+        bool is_compressible () const override;
+
+        double reference_density () const;
+
+        void create_additional_named_outputs(MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+      private:
+        double eta_N, viscosity_ratio; //normal viscosity and ratio between the shear and the normal viscosities
+        static int delta (const unsigned int i, const unsigned int j); //kronecker delta function
+        void set_assemblers(const SimulatorAccess<dim> &,
+                            Assemblers::Manager<dim> &assemblers) const;
+    };
+  }
+}
+
+namespace aspect
+{
+
+//Next session is a more evolved implementation of anisotropic viscosity in the material model based on Jonathan Perry-Houts'paper
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    AV<dim>::set_assemblers(const SimulatorAccess<dim> &,
+                            Assemblers::Manager<dim> &assemblers) const
+    {
+      for (unsigned int i=0; i<assemblers.stokes_preconditioner.size(); ++i)
+        {
+          if (Plugins::plugin_type_matches<Assemblers::StokesPreconditioner<dim>>(*(assemblers.stokes_preconditioner[i])))
+            assemblers.stokes_preconditioner[i] = std::make_unique<Assemblers::StokesPreconditionerAnisotropicViscosity<dim>> ();
+        }
+
+      for (unsigned int i=0; i<assemblers.stokes_system.size(); ++i)
+        {
+          if (Plugins::plugin_type_matches<Assemblers::StokesIncompressibleTerms<dim>>(*(assemblers.stokes_system[i])))
+            assemblers.stokes_system[i] = std::make_unique<Assemblers::StokesIncompressibleTermsAnisotropicViscosity<dim>> ();
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    AV<dim>::
+    initialize()
+    {
+      this->get_signals().set_assemblers.connect (std::bind(&AV<dim>::set_assemblers,
+                                                            std::cref(*this),
+                                                            std::placeholders::_1,
+                                                            std::placeholders::_2));
+      AssertThrow((dim==2),
+                  ExcMessage("For now the anisotropic viscosity assemblers work only in 2D"));
+
+    }
+
+
+
+    template <int dim>
+    void
+    AV<dim>::evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
+                       MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        out.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      AssertThrow((this->introspection().compositional_name_exists("gamma")),
+                  ExcMessage("AV material model only works if there is a compositional field called gamma."));
+      AssertThrow(this->introspection().compositional_name_exists("ni"),
+                  ExcMessage("AV material model only works if there is a compositional field called ni."));
+      AssertThrow(this->introspection().compositional_name_exists("nj"),
+                  ExcMessage("AV material model only works if there is a compositional field called nj."));
+      if (dim == 3)
+        AssertThrow(this->introspection().compositional_name_exists("nk"),
+                    ExcMessage("AV material model only works if there is a compositional field called nk."));
+
+      const unsigned int c_idx_gamma = this->introspection().compositional_index_for_name("gamma");
+
+      std::vector<unsigned int> c_idx_n;
+      c_idx_n.push_back (this->introspection().compositional_index_for_name("ni"));
+      c_idx_n.push_back (this->introspection().compositional_index_for_name("nj"));
+      if (dim == 3)
+        c_idx_n.push_back (this->introspection().compositional_index_for_name("nk"));
+
+      // Get the grad_u tensor, at the center of this cell, if possible.
+
+      std::vector<Tensor<2,dim>> velocity_gradients (in.n_evaluation_points());
+      if (in.current_cell.state() == IteratorState::valid)
+        {
+          std::vector<Point<dim>> quadrature_positions(in.n_evaluation_points());
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            quadrature_positions[i] = this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]);
+
+          // FEValues requires a quadrature and we provide the default quadrature
+          // as we only need to evaluate the gradients of the solution.
+          FEValues<dim> fe_values (this->get_mapping(),
+                                   this->get_fe(),
+                                   Quadrature<dim>(quadrature_positions),
+                                   update_gradients);
+          fe_values.reinit (in.current_cell);
+          fe_values[this->introspection().extractors.velocities]
+          .get_function_gradients(this->get_solution(), velocity_gradients);
+        }
+
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
+        {
+          out.densities[q] = (in.composition[q][c_idx_gamma] > 0.8 ? 1 : 0);
+          out.viscosities[q] = eta_N;
+          out.thermal_expansion_coefficients[q] = 0;
+          out.specific_heat[q] = 0;
+          out.thermal_conductivities[q] = 0;
+          out.compressibilities[q] = 0.0;
+          out.entropy_derivative_pressure[q] = 0.0;
+          out.entropy_derivative_temperature[q] = 0.0;
+          for (unsigned int c=0; c<in.composition[q].size(); ++c)
+            out.reaction_terms[q][c] = 0.0;
+
+          Tensor<1,dim> n;
+          for (unsigned int i=0; i<dim; ++i)
+            n[i] = in.composition[q][c_idx_n[i]];
+
+          // The computation of the viscosity tensor is only
+          // necessary after the simulator has been initialized.
+          if (this->simulator_is_past_initialization())
+            {
+              Tensor<1,dim> n_dot;
+              if (n.norm() > 0.5 && in.composition[q][c_idx_gamma] > 0.8)
+                {
+                  // Symmetric and anti-symmetric parts of grad_u
+                  const SymmetricTensor<2,dim> D = symmetrize(velocity_gradients[q]);
+                  Tensor<2,dim> W;
+                  for (unsigned int i=0; i<dim; ++i)
+                    for (unsigned int j=0; j<dim; ++j)
+                      W[i][j] = velocity_gradients[q][i][j] - D[i][j];
+
+                  for (unsigned int i=0; i<dim; ++i)
+                    {
+                      // outer summation over each value of j.
+                      for (unsigned int j=0; j<dim; ++j)
+                        {
+                          float Wn = W[i][j];
+                          for (unsigned int k=0; k<dim; ++k)
+                            {
+                              Wn -= D[k][i]*n[k]*n[j] - D[k][j]*n[k]*n[i];
+                            }
+                          n_dot[i] += Wn * n[j];
+                        }
+                    }
+
+                  // make sure that n is a unit vector. We have checked
+                  // above that n != 0.0.
+                  // handle time step 0 differently, because time step length is 0
+                  if (this->get_timestep() == 0)
+                    {
+                      n_dot = (n/n.norm())-n;
+                    }
+                  else
+                    {
+                      Tensor<1,dim> n_new = n + (n_dot * this->get_timestep());
+                      Assert (n_new.norm() != 0, ExcInternalError());
+                      n_new /= n_new.norm();
+                      n_dot = (n_new-n)/ this->get_timestep();
+                    }
+                }
+              else
+                {
+                  n_dot = 0;
+                }
+              // update  n[i] = in.composition[q][c_idx_n[i]] with adding to it n_dot*dt
+              for (unsigned int i=0; i<dim; ++i)
+                if (this->get_timestep() == 0)
+                  out.reaction_terms[q][c_idx_n[i]] = n_dot[i];
+                else
+                  out.reaction_terms[q][c_idx_n[i]] = n_dot[i] * this->get_timestep();
+
+              if (n.norm() > 0.5)
+                {
+                  n /= n.norm();
+                  SymmetricTensor<4,dim> Lambda;
+                  for (unsigned int i=0; i<dim; ++i)
+                    for (unsigned int j=0; j<dim; ++j)
+                      for (unsigned int k=0; k<dim; ++k)
+                        for (unsigned int l=0; l<dim; ++l)
+                          Lambda[i][j][k][l] = 1./2. * (n[i]*n[k]*delta(l,j)
+                                                        + n[j]*n[k]*delta(i,l)
+                                                        + n[i]*n[l]*delta(k,j)
+                                                        + n[j]*n[l]*delta(i,k))
+                                               - 2*n[i]*n[j]*n[k]*n[l];
+
+                  if (anisotropic_viscosity != nullptr)
+                    {
+                      anisotropic_viscosity->stress_strain_directors[q] =dealii::identity_tensor<dim> ()
+                                                                         - (1. - viscosity_ratio) * Lambda;
+                      SymmetricTensor<2,3> ViscoTensor;
+                      ViscoTensor[0][0]=anisotropic_viscosity->stress_strain_directors[q][0][0][0][0];
+                      ViscoTensor[0][1]=anisotropic_viscosity->stress_strain_directors[q][0][0][1][1];
+                      ViscoTensor[0][2]=anisotropic_viscosity->stress_strain_directors[q][0][0][0][1] * std::sqrt(2);
+                      ViscoTensor[1][0]=anisotropic_viscosity->stress_strain_directors[q][1][1][0][0];
+                      ViscoTensor[1][1]=anisotropic_viscosity->stress_strain_directors[q][1][1][1][1];
+                      ViscoTensor[1][2]=anisotropic_viscosity->stress_strain_directors[q][1][1][0][1] * std::sqrt(2);
+                      ViscoTensor[2][0]=anisotropic_viscosity->stress_strain_directors[q][0][1][0][0] * std::sqrt(2);
+                      ViscoTensor[2][1]=anisotropic_viscosity->stress_strain_directors[q][0][1][1][1] * std::sqrt(2);
+                      ViscoTensor[2][2]=anisotropic_viscosity->stress_strain_directors[q][0][1][0][1] * 2;
+
+                      const std::array<double,3> Viscoeigenvalues = eigenvalues(ViscoTensor);
+                      for (unsigned int i=0; i<3; ++i)
+                        {
+                          AssertThrow((Viscoeigenvalues[i]>0),
+                                      ExcMessage("Eigenvalue "+ std::to_string(i) + " of the viscosity tensor is negative at " +
+                                                 std::to_string(Viscoeigenvalues[i]) + ". This is not allowed."));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    int
+    AV<dim>::delta (const unsigned int i,
+                    const unsigned int j)
+    {
+      return (i == j ? 1 : 0);
+    }
+
+
+
+    template <int dim>
+    bool
+    AV<dim>::is_compressible () const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    double
+    AV<dim>::reference_density () const
+    {
+      return 1.0;
+    }
+
+
+
+    template <int dim>
+    void
+    AV<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("AV");
+        {
+          eta_N = prm.get_double("Normal viscosity");
+          viscosity_ratio = prm.get_double("Shear viscosity")/eta_N;
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    AV<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("AV");
+        {
+          prm.declare_entry ("Normal viscosity", "1e-3",
+                             Patterns::Double(),
+                             "Magnitude of normal viscosity.");
+          prm.declare_entry ("Shear viscosity", "1e-4",
+                             Patterns::Double(),
+                             "Magnitude of shear viscosity.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    AV<dim>::create_additional_named_outputs(MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<AnisotropicViscosity<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
+        }
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Assemblers
+  {
+#define INSTANTIATE(dim) \
+  template class StokesPreconditioner<dim>; \
+  template class StokesIncompressibleTerms<dim>; \
+  template class StokesBoundaryTraction<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+  }
+
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(ShearHeatingAnisotropicViscosity,
+                                  "anisotropic shear heating",
+                                  "Implementation of a standard model for shear heating. "
+                                  "Adds the term: "
+                                  "$  2 \\eta \\left( \\varepsilon - \\frac{1}{3} \\text{tr} "
+                                  "\\varepsilon \\mathbf 1 \\right) : \\left( \\varepsilon - \\frac{1}{3} "
+                                  "\\text{tr} \\varepsilon \\mathbf 1 \\right)$ to the "
+                                  "right-hand side of the temperature equation.")
+  }
+
+
+
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(AV,
+                                   "AV material",
+                                   "Transverse isotropic material model.")
+  }
+}
diff --git a/cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm.bak b/cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm.bak
new file mode 100644
index 00000000000..e4a7249a52b
--- /dev/null
+++ b/cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm.bak
@@ -0,0 +1,104 @@
+# Setup for convection in a 2d shell.
+# Parameters from Bunge et al, Nature, 1996.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 5e9
+set Output directory                       = output_bunge_et_al
+set CFL number                             = 1
+
+subsection Material model
+  set Model name = depth dependent
+
+  subsection Depth dependent model
+    set Base model = simple
+    set Depth dependence method = File
+    set Data directory = $ASPECT_SOURCE_DIR/cookbooks/bunge_et_al_mantle_convection/
+    set Viscosity depth file = visc_depth_a.txt
+    set Reference viscosity = 1e22
+  end
+
+  subsection Simple model
+    set Reference density             = 4500
+    set Thermal expansion coefficient = 2.5e-5
+    set Viscosity                     = 1e22
+    set Reference specific heat       = 1000
+    set Thermal conductivity          = 4
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3480000
+    set Outer radius  = 6370000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Heating model
+  set List of model names = constant heating
+
+  subsection Constant heating
+    set Radiogenic heating rate = 1e-12
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3450
+    set Outer temperature = 1060
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names      = r,phi
+    set Function constants  = A=100, B=75, C=50, D=25, pi=3.1415926536, Ri=3480e3, Ro=6370e3, Ti=3450, To=1060
+    set Function expression = (r-Ri)/(Ro-Ri)*(To-Ti)+Ti + A*sin(7*phi) + B*sin(13*phi) + C*cos(0.123*phi+pi/3) + D*cos(0.456*phi+pi/6)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+
+  #set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 5
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set List of output variables = viscosity, strain rate, density, specific heat, thermal expansivity, gravity, heating
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e7
+    set Number of zones = 100
+  end
+end
diff --git a/cookbooks/burnman/burnman.prm.bak b/cookbooks/burnman/burnman.prm.bak
new file mode 100644
index 00000000000..c67bf3be8e9
--- /dev/null
+++ b/cookbooks/burnman/burnman.prm.bak
@@ -0,0 +1,143 @@
+# A cookbook for using adiabatic conditions and a gravity
+# profile generated by a mineral physics toolkit and read in
+# through an ascii data file. In this example, material properties
+# are based on a Birch-Murnaghan equation of state.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 2.63e8
+set Output directory                       = output-burnman
+
+subsection Material model
+  set Model name = ascii reference profile
+  set Material averaging = harmonic average
+
+  subsection Ascii reference profile
+    set Thermal viscosity exponent = 10.0
+    set Viscosity prefactors = 1.0, 0.1, 1.0, 10.0
+
+    subsection Ascii data model
+      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+      set Data file name = example_isentrope.txt
+    end
+  end
+end
+
+# The geometry is a spherical shell with the inner and
+# outer radius of the Earth's mantle.
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Adiabatic conditions model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_isentrope.txt
+  end
+end
+
+# The gravity model reads an ascii data file that contains a gravity
+# profile consistent with the material properties computed using the
+# Birch-Murnaghan equation of state. It automatically uses the same file
+# specified in the adiabatic conditions model.
+subsection Gravity model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_isentrope.txt
+  end
+end
+
+# The model uses the anelastic liquid approximation.
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
+
+# The present-day plate velocities are imposed on the upper model
+# boundary.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:gplates
+  set Tangential velocity boundary indicators = bottom
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 273
+  end
+end
+
+# The initial temperature is an adiabatic profile, which is
+# taken from the adabatic conditions model. In this case, this is
+# is the ascii data model that loads a file containing profiles
+# corresponding to the Birch-Murnaghan equation of state.
+# In addition to the adiabatic profile, there are thermal boundary
+# layers at the sirface and the core-mantle boundary.
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Mesh refinement
+  set Refinement fraction                = 0.4
+  set Coarsening fraction                = 0.05
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 5
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Number of grouped files       = 0
+    set List of output variables      = material properties, gravity, adiabat, nonadiabatic temperature, nonadiabatic pressure
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint  = 1800
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+  end
+end
diff --git a/cookbooks/burnman/doc/adiabatic_conditions.part.prm.bak b/cookbooks/burnman/doc/adiabatic_conditions.part.prm.bak
new file mode 100644
index 00000000000..4cadabb890d
--- /dev/null
+++ b/cookbooks/burnman/doc/adiabatic_conditions.part.prm.bak
@@ -0,0 +1,8 @@
+subsection Adiabatic conditions model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = isentrope_properties.txt
+  end
+end
diff --git a/cookbooks/burnman/doc/formulation.part.prm.bak b/cookbooks/burnman/doc/formulation.part.prm.bak
new file mode 100644
index 00000000000..ed9e31a69cd
--- /dev/null
+++ b/cookbooks/burnman/doc/formulation.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
diff --git a/cookbooks/burnman/doc/formulation_ica.part.prm.bak b/cookbooks/burnman/doc/formulation_ica.part.prm.bak
new file mode 100644
index 00000000000..fb0585cd286
--- /dev/null
+++ b/cookbooks/burnman/doc/formulation_ica.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Formulation
+  set Formulation = isentropic compression
+end
diff --git a/cookbooks/burnman/doc/gravity_model.part.prm.bak b/cookbooks/burnman/doc/gravity_model.part.prm.bak
new file mode 100644
index 00000000000..ac7bc06486c
--- /dev/null
+++ b/cookbooks/burnman/doc/gravity_model.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Gravity model
+  set Model name = ascii data
+end
diff --git a/cookbooks/burnman/doc/material_model.part.prm.bak b/cookbooks/burnman/doc/material_model.part.prm.bak
new file mode 100644
index 00000000000..e741a44f895
--- /dev/null
+++ b/cookbooks/burnman/doc/material_model.part.prm.bak
@@ -0,0 +1,14 @@
+subsection Material model
+  set Model name = ascii reference profile
+  set Material averaging = harmonic average
+
+  subsection Ascii data model
+    set Data file name = isentrope_properties.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+  end
+
+  subsection Ascii reference profile
+    set Thermal viscosity exponent = 10.0
+    set Viscosity prefactors = 1.0, 0.1, 1.0, 10.0
+  end
+end
diff --git a/cookbooks/burnman/doc/tala.part.prm.bak b/cookbooks/burnman/doc/tala.part.prm.bak
new file mode 100644
index 00000000000..6b71b0fb510
--- /dev/null
+++ b/cookbooks/burnman/doc/tala.part.prm.bak
@@ -0,0 +1,5 @@
+subsection Material model
+  subsection Ascii reference profile
+    set Use TALA = true
+  end
+end
diff --git a/cookbooks/christensen_yuen_phase_function/christensen_yuen_phase_function.prm.bak b/cookbooks/christensen_yuen_phase_function/christensen_yuen_phase_function.prm.bak
new file mode 100644
index 00000000000..cd508be93fd
--- /dev/null
+++ b/cookbooks/christensen_yuen_phase_function/christensen_yuen_phase_function.prm.bak
@@ -0,0 +1,172 @@
+# This is a setup for convection in a 2D box with a phase transition
+# in the center, and corresponds to the setup of the Boussinesq cases
+# in Christensen & Yuen 1985.
+
+set Dimension                              = 2
+set End time                               = 2e8
+set Output directory                       = christensen_yuen
+
+# We use a nonlinear solver to make sure any nonlinearity that may be
+# associated with the phase transition is resolved, and we use a large
+# value for the Maximum nonlinear iterations to make it obvious if the
+# nonlinear solver does not converge. Usually, the nonlinear solver
+# should converge within 1-5 iterations.
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 500
+set Maximum time step                      = 1e5
+set Adiabatic surface temperature = 500
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+# This model assumes the Boussinesq approximation, so it is
+# incompressible and has a constant reference density.
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# For the Boussinesq approximation, all heating terms are switched off.
+subsection Heating model
+  set List of model names =
+end
+
+# The model domain is a quadratic box.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1350000
+    set Y extent = 1350000
+  end
+end
+
+# Set the reference profile.
+# The temperature on the reference profile is 500 K, halfway between the
+# top temperature of 0 K and the bottom temperature of 1000 K.
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants = density=1000
+    set Function expression = 500; density*10*depth; density
+    set Variable names = depth
+  end
+end
+
+# This temperature initial condition resembles the one on Christensen & Yuen, 1985.
+# It has conductive boundary layers at the top and bottom, and sinusoidal
+# temperature perturbations.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants = delta=0.1, A=10, h=1350000, pi=3.1416
+    set Variable names = x,z
+    set Function expression = 500 + 500*(erfc(z/(h*delta)) - erfc((1-z/h)/delta)) + A*cos(pi*x/h)*sin(pi*z/h) + A*cos(2*pi*x/h)*sin(pi*z/h) + A*cos(pi*x/h)*sin(2*pi*z/h) + A*cos(2*pi*x/h)*sin(2*pi*z/h)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom, left, right
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# This material model uses phase functions.
+# The model in Christensen & Yuen is nondimensional, but we want to keep
+# Earth-like parameters. To achieve this, we set all material
+# properties to multiples of 10, and then control the three important
+# model parameters by setting:
+#
+# k = 2.460375e7 / Ra,                                      to control the Rayleigh number,
+# deltarho = 2 alpha rho DeltaT = 200 kg/m3,                to achieve Rb = 2Ra, as in Christensen & Yuen,
+# gamma = P * Ra/Rb * rho g h / DeltaT = P/2 * 1.35e7 Pa/K, to set the phase buoyancy parameter.
+#
+# (for a more detailed explanation, see the corresponding cookbook description in the manual).
+
+subsection Material model
+  set Model name = latent heat
+  set Material averaging = harmonic average only viscosity
+
+  subsection Latent heat
+    # All parameters in the equation of state are constant, and the mode is incompressible.
+    set Reference temperature                          = 500
+    set Reference density                              = 1000
+    set Reference specific heat                        = 1000
+    set Thermal expansion coefficient                  = 1e-4
+    set Compressibility                                = 0
+    set Thermal conductivity                           = 246.03750       # k = 2.460375e7/Ra, corresponds to Ra = 1e5
+
+    # There is one phase transition in the center of the box (at a depth of 675 km),
+    # with a width of 67.5 km (5% of the box height).
+    # It occurs at that depth if the temperature corresponds to the reference temperature (500 K);
+    # for different temperatures the depth changes according to the Clapeyron slope (-2.7 MPa/K).
+    # At the phase transition, the density increases from its reference value of 1000 kg/m^3 to
+    # 1200 kg/m^3.
+    set Define transition by depth instead of pressure = true
+    set Phase transition depths                        = 675000
+    set Phase transition widths                        = 67500
+    set Phase transition temperatures                  = 500
+    set Phase transition Clapeyron slopes              = -2700000        # gamma = P * Ra/Rb, corresponds to P = -0.4
+    set Phase transition density jumps                 = 200             # deltarho = 2 alpha rho DeltaT (Rb = 2Ra)
+    set Corresponding phase for density jump           = 0
+
+    # The viscosity is constant
+    set Viscosity                                      = 1e20
+    set Minimum viscosity                              = 1e20
+    set Maximum viscosity                              = 1e20
+    set Viscosity prefactors                           = 1,1
+    set Thermal viscosity exponent                     = 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 6
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# Stop the model run when a steady state heat flux is reached.
+# Some of the models do not reach steady state and will continue
+# until the end time is reached.
+subsection Termination criteria
+  set Termination criteria = end time, steady state heat flux
+
+  subsection Steady state heat flux
+    set Maximum relative deviation = 0.005
+    set Time in steady state = 1e7
+    set Boundary indicators = top
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 1e5
+    set List of output variables      = material properties, adiabat, strain rate
+
+    subsection Material properties
+      set List of material properties = viscosity, density
+    end
+  end
+end
diff --git a/cookbooks/christensen_yuen_phase_function/doc/material.part.prm.bak b/cookbooks/christensen_yuen_phase_function/doc/material.part.prm.bak
new file mode 100644
index 00000000000..4c442a8a694
--- /dev/null
+++ b/cookbooks/christensen_yuen_phase_function/doc/material.part.prm.bak
@@ -0,0 +1,35 @@
+subsection Material model
+  set Model name = latent heat
+  set Material averaging = harmonic average only viscosity
+
+  subsection Latent heat
+    # All parameters in the equation of state are constant, and the mode is incompressible.
+    set Reference temperature                          = 500
+    set Reference density                              = 1000
+    set Reference specific heat                        = 1000
+    set Thermal expansion coefficient                  = 1e-4
+    set Compressibility                                = 0
+    set Thermal conductivity                           = 246.03750       # k = 2.460375e7/Ra, corresponds to Ra = 1e5
+
+    # There is one phase transition in the center of the box (at a depth of 675 km),
+    # with a width of 67.5 km (5% of the box height).
+    # It occurs at that depth if the temperature corresponds to the reference temperature (500 K);
+    # for different temperatures the depth changes according to the Clapeyron slope (-2.7 MPa/K).
+    # At the phase transition, the density increases from its reference value of 1000 kg/m^3 to
+    # 1200 kg/m^3.
+    set Define transition by depth instead of pressure = true
+    set Phase transition depths                        = 675000
+    set Phase transition widths                        = 67500
+    set Phase transition temperatures                  = 500
+    set Phase transition Clapeyron slopes              = -2700000        # gamma = P * Ra/Rb, corresponds to P = -0.4
+    set Phase transition density jumps                 = 200             # deltarho = 2 alpha rho DeltaT (Rb = 2Ra)
+    set Corresponding phase for density jump           = 0
+
+    # The viscosity is constant
+    set Viscosity                                      = 1e20
+    set Minimum viscosity                              = 1e20
+    set Maximum viscosity                              = 1e20
+    set Viscosity prefactors                           = 1,1
+    set Thermal viscosity exponent                     = 0.0
+  end
+end
diff --git a/cookbooks/composition-reaction/composition-reaction.prm.bak b/cookbooks/composition-reaction/composition-reaction.prm.bak
new file mode 100644
index 00000000000..fe59917c746
--- /dev/null
+++ b/cookbooks/composition-reaction/composition-reaction.prm.bak
@@ -0,0 +1,113 @@
+# A description of convection in a rectangular box where we prescribe
+# temporally variable boundary conditions for the velocity along the top
+# boundary. See the manual for more information.
+
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-reaction
+
+############### Parameters describing the model
+# Let us here choose again a box domain of size 2x1
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+# We then set the temperature to one at the bottom and zero
+# at the top:
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(z<0.5,1,0);0
+  end
+end
+
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+    set Density differential for compositional field 1 = -5
+    set Density differential for compositional field 2 = 5
+    set Reaction depth                = 0.2
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+    set List of output variables = density
+  end
+end
diff --git a/cookbooks/composition-reaction/doc/initial.part.prm.bak b/cookbooks/composition-reaction/doc/initial.part.prm.bak
new file mode 100644
index 00000000000..39d359f8f51
--- /dev/null
+++ b/cookbooks/composition-reaction/doc/initial.part.prm.bak
@@ -0,0 +1,8 @@
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(z<0.5, 1, 0); 0
+  end
+end
diff --git a/cookbooks/composition-reaction/doc/material.part.prm.bak b/cookbooks/composition-reaction/doc/material.part.prm.bak
new file mode 100644
index 00000000000..8f48516b3ae
--- /dev/null
+++ b/cookbooks/composition-reaction/doc/material.part.prm.bak
@@ -0,0 +1,12 @@
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Density differential for compositional field 1 = -5
+    set Density differential for compositional field 2 = 5
+    set Reaction depth                                 = 0.2
+  end
+end
diff --git a/cookbooks/composition_active/composition_active.prm.bak b/cookbooks/composition_active/composition_active.prm.bak
new file mode 100644
index 00000000000..96c752b0a3d
--- /dev/null
+++ b/cookbooks/composition_active/composition_active.prm.bak
@@ -0,0 +1,106 @@
+#########################################################
+# This is a variation of the composition-passive.prm file.
+# Here, we choose a higher Rayleigh number and make the
+# density depend on the compositional variable as well.
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-active
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/cookbooks/composition_active/doc/active.part.prm.bak b/cookbooks/composition_active/doc/active.part.prm.bak
new file mode 100644
index 00000000000..0a354dd39b6
--- /dev/null
+++ b/cookbooks/composition_active/doc/active.part.prm.bak
@@ -0,0 +1,12 @@
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 0.1
+  end
+end
diff --git a/cookbooks/composition_active/doc/postprocess.part.prm.bak b/cookbooks/composition_active/doc/postprocess.part.prm.bak
new file mode 100644
index 00000000000..94337847f3c
--- /dev/null
+++ b/cookbooks/composition_active/doc/postprocess.part.prm.bak
@@ -0,0 +1,8 @@
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/cookbooks/composition_active_particles/composition_active_particles.prm.bak b/cookbooks/composition_active_particles/composition_active_particles.prm.bak
new file mode 100644
index 00000000000..dc6b3fa1111
--- /dev/null
+++ b/cookbooks/composition_active_particles/composition_active_particles.prm.bak
@@ -0,0 +1,127 @@
+#########################################################
+# This is a variation of the composition-active.prm file.
+# Here, we track compositional fields and their associated
+# density differences with a particle, rather than field,
+# based methods.
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-active-particles
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics,particles
+
+  subsection Visualization
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = vtu
+  end
+end
+
+# Here, we track compositional fields via active particle particles.
+# The initial composition assigned to the particles is 'mapped'
+# to the particles at each time step.  This property is accessed in
+# the material model through a compositional field (standard method)
+# whose values are interpolated from the particles.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = lower, upper
+  set Compositional field methods = particles, particles
+  set Mapped particle properties = lower:initial lower, upper:initial upper
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity, initial composition
+  set Interpolation scheme = cell average
+  set Update ghost particles = true
+  set Particle generator name = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 100000
+    end
+  end
+end
diff --git a/cookbooks/composition_active_particles/doc/composition.part.prm.bak b/cookbooks/composition_active_particles/doc/composition.part.prm.bak
new file mode 100644
index 00000000000..9248b34bd3c
--- /dev/null
+++ b/cookbooks/composition_active_particles/doc/composition.part.prm.bak
@@ -0,0 +1,6 @@
+subsection Compositional fields
+  set Number of fields            = 2
+  set Names of fields             = lower, upper
+  set Compositional field methods = particles, particles
+  set Mapped particle properties  = lower:initial lower, upper:initial upper
+end
diff --git a/cookbooks/composition_active_particles/doc/particles.part.prm.bak b/cookbooks/composition_active_particles/doc/particles.part.prm.bak
new file mode 100644
index 00000000000..d43080c8b9e
--- /dev/null
+++ b/cookbooks/composition_active_particles/doc/particles.part.prm.bak
@@ -0,0 +1,18 @@
+subsection Postprocess
+  subsection Particles
+    set Time between data output  = 0
+    set Data output format        = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity, initial composition
+  set Interpolation scheme      = cell average
+  set Particle generator name   = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles         = 100000
+    end
+  end
+end
diff --git a/cookbooks/composition_passive/composition_passive.prm.bak b/cookbooks/composition_passive/composition_passive.prm.bak
new file mode 100644
index 00000000000..1d2cb078e8f
--- /dev/null
+++ b/cookbooks/composition_passive/composition_passive.prm.bak
@@ -0,0 +1,99 @@
+#########################################################
+# This is a variation of the platelike-boundary.prm file.
+# All settings are exactly the same with the exception
+# of the ones that pertain to compositional fields.
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-passive
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/cookbooks/composition_passive/doc/passive.part.prm.bak b/cookbooks/composition_passive/doc/passive.part.prm.bak
new file mode 100644
index 00000000000..cddd8c7c649
--- /dev/null
+++ b/cookbooks/composition_passive/doc/passive.part.prm.bak
@@ -0,0 +1,18 @@
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/cookbooks/composition_passive/doc/postprocess.part.prm.bak b/cookbooks/composition_passive/doc/postprocess.part.prm.bak
new file mode 100644
index 00000000000..f9bbf737b98
--- /dev/null
+++ b/cookbooks/composition_passive/doc/postprocess.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+end
diff --git a/cookbooks/composition_passive_particles/composition_passive_particles.prm.bak b/cookbooks/composition_passive_particles/composition_passive_particles.prm.bak
new file mode 100644
index 00000000000..e7bcbabe929
--- /dev/null
+++ b/cookbooks/composition_passive_particles/composition_passive_particles.prm.bak
@@ -0,0 +1,114 @@
+#########################################################
+# This is a variation of the composition-passive.prm
+# parameter file, with the exception that we also
+# advect along a set of particles and that we do not longer
+# compute temperature statistics and composition statistics
+# as part of postprocessing
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 7.2
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-passive-particles
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format       = vtu
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
+
+subsection Particles
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 1000
+    end
+  end
+end
diff --git a/cookbooks/composition_passive_particles/composition_passive_particles_properties.prm.bak b/cookbooks/composition_passive_particles/composition_passive_particles_properties.prm.bak
new file mode 100644
index 00000000000..d5f29bcf12d
--- /dev/null
+++ b/cookbooks/composition_passive_particles/composition_passive_particles_properties.prm.bak
@@ -0,0 +1,121 @@
+#########################################################
+# This is a variation of the composition-passive.prm
+# parameter file, with the exception that we also
+# advect along a set of particles and that we do not longer
+# compute temperature statistics and composition statistics
+# as part of postprocessing
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-passive-particles-properties
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format       = vtu
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position, pT path
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0)
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 50000
+    end
+  end
+end
diff --git a/cookbooks/composition_passive_particles/doc/particle-properties.part.prm.bak b/cookbooks/composition_passive_particles/doc/particle-properties.part.prm.bak
new file mode 100644
index 00000000000..51f951526e7
--- /dev/null
+++ b/cookbooks/composition_passive_particles/doc/particle-properties.part.prm.bak
@@ -0,0 +1,17 @@
+subsection Postprocess
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position, pT path
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0)
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 50000
+    end
+  end
+end
diff --git a/cookbooks/composition_passive_particles/doc/particles.part.prm.bak b/cookbooks/composition_passive_particles/doc/particles.part.prm.bak
new file mode 100644
index 00000000000..6036ea43824
--- /dev/null
+++ b/cookbooks/composition_passive_particles/doc/particles.part.prm.bak
@@ -0,0 +1,20 @@
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format       = vtu
+  end
+end
+
+subsection Particles
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 1000
+    end
+  end
+end
diff --git a/cookbooks/continental_extension/continental_extension.prm.bak b/cookbooks/continental_extension/continental_extension.prm.bak
new file mode 100644
index 00000000000..a0dcd80a382
--- /dev/null
+++ b/cookbooks/continental_extension/continental_extension.prm.bak
@@ -0,0 +1,314 @@
+#### Continental Extension Cookbook
+# This cookbook is based off numerous published studies, five of which are listed below.
+# For additional information, see these publications and references therein.
+#   1. Brune, S., Heine, C., Perez-Gussinye, M., and Sobolev, S.V. (2014), Nat. Comm., v.5, n.4014,
+#      Rift migration explains continental margin asymmetry and crustal hyperextension
+#   2. Huismans, R., and Beaumont, C. (2011), Nature, v.473, p.71-75.
+#      Depth-dependent extension, two-stage breakup and cratonic underplating at rifted margins
+#   3. Naliboff, J., and Buiter, S.H. (2015), Earth Planet. Sci. Lett., v.421, p.58-67,
+#      "Rift Reactivation and migration during multiphase extension"
+#   4. Naliboff, J., Glerum, A., Sascha, S., Peron-Pinvidic, G., and Wrona, T. (2020), Geophys.
+#      Res. Lett., 47, e2019GL086611, "Development of 3‐D rift heterogeneity through fault
+#      network evolution"
+#   5. Sandiford, D., Brune, S., Glerum, A., Naliboff, J., and Whittaker, J.M. (2021), Geophys.
+#      Geochem. Geosys., 22, e2021GC009681, "Kinematics of footwall exhumation at oceanic
+#      detachment faults: Solid-block rotation and apparent unbending"
+
+####  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 5e6
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated defect correction Stokes
+set Nonlinear solver tolerance             = 1e-4
+set Max nonlinear iterations               = 100
+set CFL number                             = 0.5
+set Maximum time step                      = 20e3
+set Output directory                       = output-continental_extension
+set Pressure normalization                 = no
+
+#### Parameters describing the model
+
+# Governing equations
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# Model geometry (200x100 km, 20 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 5
+    set X extent      = 200e3
+    set Y extent      = 100e3
+  end
+end
+
+# Globally refine the mesh to 2.5 km spacing, and then
+# adaptively refine the mesh to 1.25 km spacing above y=50 km
+# and between x=40 and x=160 km. These values ensure areas
+# undergoing brittle deformation are in the high-resolution
+# region.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+  set Strategy = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function expression = if ( y>=50e3 && x>=40.e3 && x<=160.e3, 4, 3)
+  end
+end
+
+# Use the Eisenstat Walker method to automatically determine the
+# linear solver tolerance during the defect Picard iterations.
+# Adjusting the Maximum linear solver tolerance will affect how long
+# it takes to reach a solution, but not the actual value of the
+# solution.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+
+  subsection Newton solver parameters
+    set Maximum linear Stokes solver tolerance   = 1e-2
+    set Use Eisenstat Walker method for Picard iterations = true
+  end
+end
+
+# Advecting the free surface using a normal, rather than vertical,
+# projection. To reduce mesh instabilities and associated solver
+# issues when deformation becomes large, diffusion is applied to
+# the free surface at each time step.
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = top: free surface, top: diffusion
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+
+  subsection Diffusion
+    # Diffusivity term. Increasing this value will result
+    # in a smoother free surface and lower topography
+    # amplitudes.
+    set Hillslope transport coefficient = 1.e-8
+  end
+end
+
+# Velocity on boundaries characterized by functions
+# The outward velocity (x-direction) on the left and right walls is 0.25 cm/year
+# The vertical velocity at the base is 0.25 cm/year (balances outflow on sides)
+# Velocity components parallel to the base (x-velocity) and side walls (y-velocity)
+# are unconstrained (i.e. 'free').
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = v=0.0025, w=200.e3, d=100.e3
+    set Function expression = if (x < w/2 , -v, v) ; v*2*d/w
+  end
+end
+
+# Number and names of compositional fields
+# The five compositional fields represent:
+# 1. The plastic strain that accumulates over time, with the initial plastic strain removed
+# 2. The plastic strain that accumulated over time, including the initial plastic strain values
+# 3. The upper crust
+# 4. The lower crust
+# 5. The mantle lithosphere
+subsection Compositional fields
+  set Number of fields = 5
+  set Names of fields = noninitial_plastic_strain, plastic_strain, crust_upper, crust_lower, mantle_lithosphere
+end
+
+# Initial values of different compositional fields
+# The upper crust (20 km thick), lower crust (20 km thick)
+# and mantle (60 km thick) are continuous horizontal layers
+# of constant thickness. The non initial plastic strain is set
+# to 0 and the initial plastic strain is randomized between
+# 0.5 and 1.5.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0; \
+                              if(x>50.e3 && x<150.e3 && y>50.e3, 0.5 + rand_seed(1), 0); \
+                              if(y>=80.e3, 1, 0); \
+                              if(y<80.e3 && y>=60.e3, 1, 0); \
+                              if(y<60.e3, 1, 0);
+  end
+end
+
+# Composition: fixed on bottom (inflow boundary), free on sides and top
+subsection Boundary composition model
+  set Fixed composition boundary indicators = bottom
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+# Top and bottom (fixed) temperatures are consistent with the initial temperature field
+# Note that while temperatures are specified for the model sides, these values are
+# not used as the sides are not specified "Fixed temperature boundaries".  Rather,
+# these boundaries are insulating (zero net heat flux).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1613
+    set Top temperature    =  273
+  end
+end
+
+# Initial temperature field
+# Typical continental geotherm based on equations 4-6 from:
+#   D.S. Chapman (1986), "Thermal gradients in the continental crust",
+#   Geological Society of London Special Publications, v.24, p.63-70.
+# The initial constraints are:
+#   Surface Temperature  - upper crust (ts1) = 273 K
+#   Surface Heat Flow    - upper crust (qs1) = 0.055 mW/m^2
+#   Heat Production      - upper crust (A1)  = 1.00e-6 W/m^3;
+#   Heat Production      - lower crust (A2)  = 0.25e-6 W/m^3;
+#   Heat Production      - mantle (A3)       = 0.00e-6 W/m^3;
+#   Thermal Conductivity - all layers        = 2.5 (W/(m K));
+# To satisfy these constraints, the following values are required:
+#   Surface Temperature  - lower crust (ts2) = 633 K
+#                        - mantle (ts3)      = 893 K
+#   Surface Heat Flow    - lower crust (qs2) = 0.035 W/m^2;
+#                        - mantle      (qs3) = 0.030 W/m^2;
+# Note: The continental geotherm initial temperature model
+#       plugin can be used to compute an identical geotherm
+#       for the lithosphere. An example of how to use this
+#       plugin is illustrated in the test for this cookbook
+#       (tests/continental_extension.prm).
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=100e3, ts1=273, ts2=633, ts3=893, \
+                             A1=1.e-6, A2=0.25e-6, A3=0.0, \
+                             k1=2.5, k2=2.5, k3=2.5, \
+                             qs1=0.055, qs2=0.035, qs3=0.030
+    set Function expression = if( (h-y)<=20.e3, \
+                                  ts1 + (qs1/k1)*(h-y) - (A1*(h-y)*(h-y))/(2.0*k1), \
+                                  if( (h-y)>20.e3 && (h-y)<=40.e3, \
+                                      ts2 + (qs2/k2)*(h-y-20.e3) - (A2*(h-y-20.e3)*(h-y-20.e3))/(2.0*k2), \
+                                      ts3 + (qs3/k3)*(h-y-40.e3) - (A3*(h-y-40.e3)*(h-y-40.e3))/(2.0*k3) ) );
+  end
+end
+
+# Constant internal heat production values (W/m^3) for background material
+# and compositional fields.
+subsection Heating model
+  set List of model names = compositional heating
+
+  subsection Compositional heating
+    set Use compositional field for heat production averaging = 1, 0, 0, 1, 1, 1
+    set Compositional heating values = 0.0, 0.0, 0.0, 1.0e-6, 0.25e-6, 0.
+  end
+end
+
+# Material model
+# Rheology: Non-linear viscous flow and Drucker Prager Plasticity
+# Values for most rheological parameters are specified for a background material and
+# each compositional field.  Values for viscous deformation are based on dislocation
+# creep flow-laws, with distinct values for the upper crust (wet quartzite), lower
+# crust (wet anorthite) and mantle (dry olivine).  Table 1 of Naliboff and Buiter (2015),
+# Earth Planet. Sci. Lett., v.421, p. 58-67 contains values for each of these flow laws.
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Reference temperature and viscosity
+    set Reference temperature = 273
+
+    # The minimum strain-rate helps limit large viscosities values that arise
+    # as the strain-rate approaches zero.
+    # The reference strain-rate is used on the first non-linear iteration
+    # of the first time step when the velocity has not been determined yet.
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-16
+
+    # Limit the viscosity with minimum and maximum values
+    set Minimum viscosity = 1e18
+    set Maximum viscosity = 1e26
+
+    # Thermal diffusivity is adjusted to match thermal conductivities
+    # assumed in assigning the initial geotherm
+    set Define thermal conductivities = true
+    set Thermal conductivities        = 2.5
+    set Heat capacities               = 750.
+
+    # Density values of 1 are assigned to "strain" fields, which are not taken into
+    # account when computing material properties.
+    set Densities                     = 3300, 1.0, 1.0, 2700,  2900, 3300
+    set Thermal expansivities         = 2e-5
+
+    # Harmonic viscosity averaging
+    set Viscosity averaging scheme = harmonic
+
+    # Choose to have the viscosity (pre-yield) follow a dislocation
+    # diffusion or composite flow law.  Here, dislocation is selected
+    # so no need to specify diffusion creep parameters below, which are
+    # only used if "diffusion" or "composite" option is selected.
+    set Viscous flow law = dislocation
+
+    # Dislocation creep parameters for
+    # 1. Background material/mantle (dry olivine)
+    #    Hirth & Kohlstedt (2004),  Geophys. Monogr. Am. Geophys. Soc., v.138, p.83-105.
+    #    "Rheology of the upper mantle and the mantle wedge:a view from the experimentalists"
+    # 2. Upper crust (wet quartzite)
+    #    Rutter & Brodie (2004), J. Struct. Geol., v.26, p.2011-2023.
+    #    "Experimental grain size-sensitive flow of hot-pressed Brazilian quartz aggregates"
+    # 3. Lower crust and weak seed (wet anorthite)
+    #    Rybacki et al. (2006), J. Geophys. Res., v.111(B3).
+    #    "Influence of water fugacity and activation volume on the flow properties of fine-grained
+    #    anorthite aggregates"
+    # Note that the viscous pre-factors below are scaled to plane strain from unixial strain experiments.
+    # For ease of identification, fields tracking strain are assigned prefactors of 1e-50
+    set Prefactors for dislocation creep          = 6.52e-16, 1.00e-50, 1.00e-50, 8.57e-28, 7.13e-18, 6.52e-16
+    set Stress exponents for dislocation creep    =      3.5,      1.0,      1.0,      4.0,      3.0,      3.5
+    set Activation energies for dislocation creep =   530.e3,      0.0,      0.0,   223.e3,   345.e3,   530.e3
+    set Activation volumes for dislocation creep  =   18.e-6,      0.0,      0.0,      0.0,      0.0,   18.e-6
+
+    # Plasticity parameters
+    set Angles of internal friction = 30
+    set Cohesions                   = 20.e6
+
+    # The parameters below weaken the friction and cohesion by a
+    # a factor of 4 between plastic strain values of 0.5 and 1.5.
+    set Strain weakening mechanism                   = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals  = 0.5
+    set End plasticity strain weakening intervals    = 1.5
+    set Cohesion strain weakening factors            = 0.25
+    set Friction strain weakening factors            = 0.25
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, heat flux densities, heat flux statistics, mass flux statistics, matrix statistics, pressure statistics, temperature statistics, topography, velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = density, heat flux map, named additional outputs, strain rate, viscosity
+    set Output format                 = vtu
+    set Time between graphical output = 100.e3
+    set Interpolate output            = true
+  end
+end
diff --git a/cookbooks/continental_extension/doc/continental_extension_boundary_conditions.prm.bak b/cookbooks/continental_extension/doc/continental_extension_boundary_conditions.prm.bak
new file mode 100644
index 00000000000..60422171c39
--- /dev/null
+++ b/cookbooks/continental_extension/doc/continental_extension_boundary_conditions.prm.bak
@@ -0,0 +1,36 @@
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = v=0.0025, w=200.e3, d=100.e3
+    set Function expression = if (x < w/2 , -v, v) ; v*2*d/w
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = top: free surface, top: diffusion
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+
+  subsection Diffusion
+    set Hillslope transport coefficient = 1.e-8
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = bottom
+  set List of model names = initial composition
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1613
+    set Top temperature    =  273
+  end
+end
diff --git a/cookbooks/continental_extension/doc/continental_extension_composition.prm.bak b/cookbooks/continental_extension/doc/continental_extension_composition.prm.bak
new file mode 100644
index 00000000000..6a119dd1b49
--- /dev/null
+++ b/cookbooks/continental_extension/doc/continental_extension_composition.prm.bak
@@ -0,0 +1,16 @@
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = upper, lower, mantle, seed
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y>=80.e3, 1, 0); \
+                              if(y<80.e3 && y>=70.e3, 1, 0); \
+                              if(y<70.e3 && y>-100.e3,1, 0); \
+                              if(y<68.e3 && y>60.e3 && x>=198.e3 && x<=202.e3 , 1, 0);
+  end
+end
diff --git a/cookbooks/continental_extension/doc/continental_extension_geometry_mesh.prm.bak b/cookbooks/continental_extension/doc/continental_extension_geometry_mesh.prm.bak
new file mode 100644
index 00000000000..acd0ab7ee12
--- /dev/null
+++ b/cookbooks/continental_extension/doc/continental_extension_geometry_mesh.prm.bak
@@ -0,0 +1,23 @@
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 5
+    set X extent      = 200e3
+    set Y extent      = 100e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+  set Strategy = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function expression = if ( y>=50e3 && x>=40.e3 && x<=160.e3, 4, 3)
+  end
+end
diff --git a/cookbooks/continental_extension/doc/continental_extension_material_model.prm.bak b/cookbooks/continental_extension/doc/continental_extension_material_model.prm.bak
new file mode 100644
index 00000000000..769682e2608
--- /dev/null
+++ b/cookbooks/continental_extension/doc/continental_extension_material_model.prm.bak
@@ -0,0 +1,6 @@
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+  end
+end
diff --git a/cookbooks/convection-box-particles/convection-box-particles.prm.bak b/cookbooks/convection-box-particles/convection-box-particles.prm.bak
new file mode 100644
index 00000000000..b4a8978e456
--- /dev/null
+++ b/cookbooks/convection-box-particles/convection-box-particles.prm.bak
@@ -0,0 +1,170 @@
+# A modification of the convection box cookbook using physical units
+# and particle output. See the manual for more information.
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 3e10
+set Output directory                       = output-tutorial
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 4.2e6
+    set Y extent = 3e6
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature. Note that there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field.
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation. The variables in this equation are
+# described below, and it is important to note that in many
+# cases the values correspond to other model parameters
+# defined elsewhere. As such, if these model parameters are
+# changed, the values below will also need to be adjusted.
+#   L - Model length/width
+#   D - Model depth/height
+#   T_top - Temperature at the top boundary
+#   T_bottom - Temperature at the bottom boundary
+#   p, k - values related to the small temperature perturbation
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = p=-0.01, L=4.2e6, D=3e6, pi=3.1415926536, k=1, T_top=273, T_bottom=3600
+    set Function expression = T_top + (T_bottom-T_top)*(1-(y/D) - p*cos(k*pi*x/L)*sin(pi*y/D))
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above, whereas all other
+# parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry
+# boundaries).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 3300
+    set Top temperature    = 300
+  end
+end
+
+# The next parameters then describe on which parts of the
+# boundary we prescribe a zero or nonzero velocity and
+# on which parts the flow is allowed to be tangential.
+# Here, all four sides of the box allow tangential
+# unrestricted flow but with a zero normal component:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc).
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 3e24
+    set Reference density             = 3000
+    set Thermal conductivity          = 4.86
+    set Thermal expansion coefficient = 2e-5
+    set Reference specific heat       = 1000
+    set Reference temperature         = 0
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 1e7 years.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, particles, basic statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e7
+    set Output format                 = vtu
+    set List of output variables      = material properties
+  end
+
+  subsection Particles
+    set Time between data output = 1e7
+    set Data output format = vtu
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
+
+subsection Particles
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1000
+    end
+  end
+end
diff --git a/cookbooks/convection-box/convection-box.prm.bak b/cookbooks/convection-box/convection-box.prm.bak
new file mode 100644
index 00000000000..dd2995dda29
--- /dev/null
+++ b/cookbooks/convection-box/convection-box.prm.bak
@@ -0,0 +1,160 @@
+# A description of convection in a 2d box. See the manual for more information.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+set Output directory                       = output-convection-box
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature. Note that there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field.
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation. The variables in this equation are
+# described below, and it is important to note that in many
+# cases the values correspond to other model parameters
+# defined elsewhere. As such, if these model parameters are
+# changed, the values below will also need to be adjusted.
+#   L - Model length/width
+#   p, k - values related to the small temperature perturbation
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above, whereas all other
+# parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry
+# boundaries).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+# The next parameters then describe on which parts of the
+# boundary we prescribe a zero or nonzero velocity and
+# on which parts the flow is allowed to be tangential.
+# Here, all four sides of the box allow tangential
+# unrestricted flow but with a zero normal component:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e4   # = Ra
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0.01
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/cookbooks/convection-box/doc/disc.part.prm.bak b/cookbooks/convection-box/doc/disc.part.prm.bak
new file mode 100644
index 00000000000..472d365dfc9
--- /dev/null
+++ b/cookbooks/convection-box/doc/disc.part.prm.bak
@@ -0,0 +1,4 @@
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 3
+end
diff --git a/cookbooks/convection-box/doc/gravity.part.prm.bak b/cookbooks/convection-box/doc/gravity.part.prm.bak
new file mode 100644
index 00000000000..c4830f97d58
--- /dev/null
+++ b/cookbooks/convection-box/doc/gravity.part.prm.bak
@@ -0,0 +1,5 @@
+subsection Gravity model
+  subsection Vertical
+    set Magnitude = 1e6   # = Ra
+  end
+end
diff --git a/cookbooks/convection-box/doc/refine.part.prm.bak b/cookbooks/convection-box/doc/refine.part.prm.bak
new file mode 100644
index 00000000000..3dbcf41380f
--- /dev/null
+++ b/cookbooks/convection-box/doc/refine.part.prm.bak
@@ -0,0 +1,5 @@
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
diff --git a/cookbooks/convection-box/doc/refine2.part.prm.bak b/cookbooks/convection-box/doc/refine2.part.prm.bak
new file mode 100644
index 00000000000..cd704f93193
--- /dev/null
+++ b/cookbooks/convection-box/doc/refine2.part.prm.bak
@@ -0,0 +1,8 @@
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Additional refinement times              = 0.2, 0.3, 0.4
+  set Refinement fraction                      = 1.0
+  set Coarsening fraction                      = 0.0
+end
diff --git a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box.prm.bak b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box.prm.bak
new file mode 100644
index 00000000000..dd2995dda29
--- /dev/null
+++ b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box.prm.bak
@@ -0,0 +1,160 @@
+# A description of convection in a 2d box. See the manual for more information.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+set Output directory                       = output-convection-box
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature. Note that there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field.
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation. The variables in this equation are
+# described below, and it is important to note that in many
+# cases the values correspond to other model parameters
+# defined elsewhere. As such, if these model parameters are
+# changed, the values below will also need to be adjusted.
+#   L - Model length/width
+#   p, k - values related to the small temperature perturbation
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above, whereas all other
+# parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry
+# boundaries).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+# The next parameters then describe on which parts of the
+# boundary we prescribe a zero or nonzero velocity and
+# on which parts the flow is allowed to be tangential.
+# Here, all four sides of the box allow tangential
+# unrestricted flow but with a zero normal component:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e4   # = Ra
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0.01
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box2.prm.bak b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box2.prm.bak
new file mode 100644
index 00000000000..4cff06a310a
--- /dev/null
+++ b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box2.prm.bak
@@ -0,0 +1,161 @@
+# A description of convection in a 2d box. See the manual for more information.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.1
+set Output directory                       = output-convection-box2
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature. Note that there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field.
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation. The variables in this equation are
+# described below, and it is important to note that in many
+# cases the values correspond to other model parameters
+# defined elsewhere. As such, if these model parameters are
+# changed, the values below will also need to be adjusted.
+#   L - Model length/width
+#   p, k - values related to the small temperature perturbation
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above, whereas all other
+# parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry
+# boundaries).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+# The next parameters then describe on which parts of the
+# boundary we prescribe a zero or nonzero velocity and
+# on which parts the flow is allowed to be tangential.
+# Here, all four sides of the box allow tangential
+# unrestricted flow but with a zero normal component:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e4   # = Ra
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, heat flux map
+
+  subsection Visualization
+    set Time between graphical output = 0.00
+    set Output format = hdf5
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm
index 5c8302c747c..18e7f499a7b 100644
--- a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm
+++ b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm
@@ -82,21 +82,6 @@ end
 # whereas all other parts of the boundary are insulated (i.e.,
 # no heat flux through these boundaries; this is also often used
 # to specify symmetry boundaries).
-# subsection Model settings    OLD DEPRECATED
-#   set Fixed temperature boundary indicators   = 2,3 OLD MOVED
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all four sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-#  set Zero velocity boundary indicators       =             OLD MOVED
-#  set Prescribed velocity boundary indicators =             OLD MOVED
-#  set Tangential velocity boundary indicators = 0,1,2,3     OLD MOVED
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
 
 # The final part of this section describes whether we
 # want to include adiabatic heating (from a small
@@ -118,7 +103,11 @@ end
 # at the left and right does not matter.)
 subsection Boundary temperature model
   set Fixed temperature boundary indicators   = 2,3
-  set Model name = box
+  set List of model names = box
+
+  # subsection Model settings    OLD DEPRECATED
+  #   set Fixed temperature boundary indicators   = 2,3 OLD MOVED
+
 
   subsection Box
     set Bottom temperature = 3600
@@ -126,6 +115,20 @@ subsection Boundary temperature model
   end
 end
 
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+
+  # The next parameters then describe on which parts of the
+  # boundary we prescribe a zero or nonzero velocity and
+  # on which parts the flow is allowed to be tangential.
+  # Here, all four sides of the box allow tangential
+  # unrestricted flow but with a zero normal component:
+  #  set Zero velocity boundary indicators       =             OLD MOVED
+  #  set Prescribed velocity boundary indicators =             OLD MOVED
+  #  set Tangential velocity boundary indicators = 0,1,2,3     OLD MOVED
+
+end
+
 # The final part is to specify what ASPECT should do with the
 # solution once computed at the end of every time step. The
 # process of evaluating the solution is called `postprocessing'
diff --git a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm.bak b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm.bak
new file mode 100644
index 00000000000..5c8302c747c
--- /dev/null
+++ b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm.bak
@@ -0,0 +1,157 @@
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 1.00e10
+set Output directory                       = output-tutorial
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 4.2e6
+    set Y extent = 3e6
+  end
+end
+
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc).
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 5.099e23
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = p=-0.01, L=4.2e6, D=3e6, pi=3.1415926536, k=1, T_top=273, T_bottom=3600
+    set Function expression = T_top + (T_bottom-T_top)*(1-(y/D) - p*cos(k*pi*x/L)*sin(pi*y/D))
+  end
+end
+
+# We then also have to prescribe several other parts of the model
+# such as which boundaries actually carry a prescribed boundary
+# temperature (as described in the documentation of the `box'
+# geometry, boundaries 2 and 3 are the bottom and top boundaries)
+# whereas all other parts of the boundary are insulated (i.e.,
+# no heat flux through these boundaries; this is also often used
+# to specify symmetry boundaries).
+# subsection Model settings    OLD DEPRECATED
+#   set Fixed temperature boundary indicators   = 2,3 OLD MOVED
+
+# The next parameters then describe on which parts of the
+# boundary we prescribe a zero or nonzero velocity and
+# on which parts the flow is allowed to be tangential.
+# Here, all four sides of the box allow tangential
+# unrestricted flow but with a zero normal component:
+#  set Zero velocity boundary indicators       =             OLD MOVED
+#  set Prescribed velocity boundary indicators =             OLD MOVED
+#  set Tangential velocity boundary indicators = 0,1,2,3     OLD MOVED
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The final part of this section describes whether we
+# want to include adiabatic heating (from a small
+# compressibility of the medium) or from shear friction,
+# as well as the rate of internal heating. We do not
+# want to use any of these options here:
+#  set Include adiabatic heating               = false      OLD is false
+#  set Include shear heating                   = false      OLD is false
+# end
+
+
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above. (As will be seen
+# in the next section, the actual temperature prescribed here
+# at the left and right does not matter.)
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2,3
+  set Model name = box
+
+  subsection Box
+    set Bottom temperature = 3600
+    set Top temperature    = 273
+  end
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 1e7 years.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics , visualization, particles, basic statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e7
+    set Output format = vtu
+  end
+
+  subsection Particles
+    set Time between data output = 1e7
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1000
+    end
+  end
+end
diff --git a/cookbooks/convection_box_3d/convection_box_3d.prm.bak b/cookbooks/convection_box_3d/convection_box_3d.prm.bak
new file mode 100644
index 00000000000..88e81d1c124
--- /dev/null
+++ b/cookbooks/convection_box_3d/convection_box_3d.prm.bak
@@ -0,0 +1,152 @@
+# A description of convection in a 3d box. See the manual for more information.
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 3
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 1.0
+set Output directory                       = output-convection_box_3d
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)*y^3
+  end
+end
+
+# Then follows a section that describes the boundary conditions for the
+# temperature. The model we choose is called 'box' and allows to set a constant
+# temperature on each of the four sides of the box geometry. In our case, we
+# choose something that is heated from below and cooled from above.
+# All other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+# The next parameters then describe on which parts of the
+# boundary we prescribe a zero or nonzero velocity and
+# on which parts the flow is allowed to be tangential.
+# Here, all six sides of the box allow tangential
+# unrestricted flow but with a zero normal component:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e16   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 3
+  set Time steps between mesh refinement       = 15
+  set Additional refinement times              = 0.003
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0.0001
+  end
+end
+
+subsection Checkpointing
+  # The number of timesteps between performing checkpoints. If 0 and time
+  # between checkpoint is not specified, checkpointing will not be performed.
+  # Units: None.
+  set Steps between checkpoint = 50
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/cookbooks/convection_box_3d/doc/amr.part.prm.bak b/cookbooks/convection_box_3d/doc/amr.part.prm.bak
new file mode 100644
index 00000000000..b68e96eda57
--- /dev/null
+++ b/cookbooks/convection_box_3d/doc/amr.part.prm.bak
@@ -0,0 +1,6 @@
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 3
+  set Time steps between mesh refinement       = 15
+  set Additional refinement times              = 0.003
+end
diff --git a/cookbooks/convection_box_3d/doc/checkpoint.part.prm.bak b/cookbooks/convection_box_3d/doc/checkpoint.part.prm.bak
new file mode 100644
index 00000000000..595a2feeb79
--- /dev/null
+++ b/cookbooks/convection_box_3d/doc/checkpoint.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Checkpointing
+  set Steps between checkpoint = 50
+end
diff --git a/cookbooks/convection_box_3d/doc/gravity.part.prm.bak b/cookbooks/convection_box_3d/doc/gravity.part.prm.bak
new file mode 100644
index 00000000000..4b07cb3808e
--- /dev/null
+++ b/cookbooks/convection_box_3d/doc/gravity.part.prm.bak
@@ -0,0 +1,7 @@
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e16   # = Ra / Thermal expansion coefficient
+  end
+end
diff --git a/cookbooks/convection_box_3d/doc/initial.part.prm.bak b/cookbooks/convection_box_3d/doc/initial.part.prm.bak
new file mode 100644
index 00000000000..15b76c9dae8
--- /dev/null
+++ b/cookbooks/convection_box_3d/doc/initial.part.prm.bak
@@ -0,0 +1,9 @@
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)*y^3
+  end
+end
diff --git a/cookbooks/convection_box_3d/doc/postprocess.part.prm.bak b/cookbooks/convection_box_3d/doc/postprocess.part.prm.bak
new file mode 100644
index 00000000000..2f592ff8cfe
--- /dev/null
+++ b/cookbooks/convection_box_3d/doc/postprocess.part.prm.bak
@@ -0,0 +1,8 @@
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, \
+                       heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0.0001
+  end
+end
diff --git a/cookbooks/convection_box_3d/doc/start.part.prm.bak b/cookbooks/convection_box_3d/doc/start.part.prm.bak
new file mode 100644
index 00000000000..eb4a52a204c
--- /dev/null
+++ b/cookbooks/convection_box_3d/doc/start.part.prm.bak
@@ -0,0 +1,25 @@
+set Dimension                              = 3
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
+end
diff --git a/cookbooks/crustal_deformation/crustal_model_2D.prm.bak b/cookbooks/crustal_deformation/crustal_model_2D.prm.bak
new file mode 100644
index 00000000000..3756ca1b7d0
--- /dev/null
+++ b/cookbooks/crustal_deformation/crustal_model_2D.prm.bak
@@ -0,0 +1,134 @@
+############### Global parameters
+
+set Dimension                                       = 2
+set Start time                                      = 0
+set End time                                        = 1e6
+set Use years in output instead of seconds          = true
+set Nonlinear solver scheme                         = single Advection, iterated Stokes
+
+# This model is very sensitive to the nonlinear solver tolerance,
+# results still change slightly down to a tolerance of 1e-8, but
+# require much more resources than reasonable for a cookbook.
+set Nonlinear solver tolerance                      = 2e-6
+set Max nonlinear iterations                        = 100
+set CFL number                                      = 0.5
+set Output directory                                = output-crustal_model_2D
+set Timing output frequency                         = 1
+set Pressure normalization                          = no
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions  = 5
+    set X extent  = 80e3
+    set Y extent  = 16e3
+  end
+end
+
+# Advecting the free surface vertically rather than
+# in the surface normal direction can result in a
+# more stable mesh when the deformation is large
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Surface velocity projection = vertical
+  end
+end
+
+subsection Material model
+  #  set Model name = viscoplastic
+  #  subsection Viscoplastic model
+  #    set Reference density = 2800
+  #  end
+
+  set Model name = drucker prager
+
+  subsection Drucker Prager
+    set Reference density = 2800
+
+    subsection Viscosity
+      set Minimum viscosity = 1e19
+      set Maximum viscosity = 1e25
+      set Reference strain rate = 1e-20
+      set Angle of internal friction = 30
+      set Cohesion = 20e6
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left: function, right:function, bottom:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = cm=0.01, year=1
+    set Function expression =  if (x<40e3 , 1*cm/year, -1*cm/year) ; 0
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.95
+  set Strategy                           = strain rate
+  set Coarsening fraction                = 0.05
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, error indicator, heating, partition
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block AMG
+    set Linear solver tolerance = 1e-9
+    set Number of cheap Stokes solver steps = 0
+    set Maximum number of expensive Stokes solver steps = 5000
+    set GMRES solver restart length = 200
+  end
+end
diff --git a/cookbooks/crustal_deformation/crustal_model_3D.prm.bak b/cookbooks/crustal_deformation/crustal_model_3D.prm.bak
new file mode 100644
index 00000000000..81cebdc1e59
--- /dev/null
+++ b/cookbooks/crustal_deformation/crustal_model_3D.prm.bak
@@ -0,0 +1,128 @@
+############### Global parameters
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 1e6
+set Use years in output instead of seconds = true
+set CFL number                             = .5
+set Output directory                       = output-crustal_model_3D
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-8
+set Max nonlinear iterations               = 100
+set Pressure normalization                 = no
+set Timing output frequency                = 1
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 128e3
+    set Y extent  =  96e3
+    set Z extent  =  16e3
+    set X repetitions  = 8
+    set Y repetitions  = 3
+  end
+end
+
+# Advecting the free surface vertically rather than
+# in the surface normal direction can result in a
+# more stable mesh when the deformation is large
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Surface velocity projection = vertical
+  end
+end
+
+subsection Material model
+  set Model name = drucker prager
+
+  subsection Drucker Prager
+    set Reference density = 2800
+
+    subsection Viscosity
+      set Minimum viscosity = 1e19
+      set Maximum viscosity = 1e25
+      set Reference strain rate = 1e-20
+      set Angle of internal friction = 30
+      set Cohesion = 20e6
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = front,back
+  set Prescribed velocity boundary indicators = left: function, right:function, bottom:function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = cm=0.01, year=1
+    set Function expression =  if (x<56e3 && y<=48e3 | x<72e3 && y>48e3, -1*cm/year, 1*cm/year) ; 0 ; 0
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.9
+  set Strategy                           = strain rate
+  set Coarsening fraction                = 0.05
+  set Minimum refinement level           = 2
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography, pressure statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, error indicator, partition
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-9
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_2D_part1.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_2D_part1.prm.bak
new file mode 100644
index 00000000000..9720b54bbd6
--- /dev/null
+++ b/cookbooks/crustal_deformation/doc/crustal_model_2D_part1.prm.bak
@@ -0,0 +1,15 @@
+subsection Material model
+  set Model name = drucker prager
+
+  subsection Drucker Prager
+    set Reference density = 2800
+
+    subsection Viscosity
+      set Minimum viscosity = 1e19
+      set Maximum viscosity = 1e25
+      set Reference strain rate = 1e-20
+      set Angle internal friction = 30
+      set Cohesion = 20e6
+    end
+  end
+end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_2D_part2.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_2D_part2.prm.bak
new file mode 100644
index 00000000000..b0bea70f396
--- /dev/null
+++ b/cookbooks/crustal_deformation/doc/crustal_model_2D_part2.prm.bak
@@ -0,0 +1,7 @@
+subsection Boundary velocity model
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = cm=0.01, year=1
+    set Function expression =  if (x<40e3 , 1*cm/year, -1*cm/year) ; 0
+  end
+end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_2D_part3.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_2D_part3.prm.bak
new file mode 100644
index 00000000000..9e58f845656
--- /dev/null
+++ b/cookbooks/crustal_deformation/doc/crustal_model_2D_part3.prm.bak
@@ -0,0 +1,3 @@
+subsection Free surface
+  set Surface velocity projection = vertical
+end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_2D_part4.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_2D_part4.prm.bak
new file mode 100644
index 00000000000..3f5ec4647db
--- /dev/null
+++ b/cookbooks/crustal_deformation/doc/crustal_model_2D_part4.prm.bak
@@ -0,0 +1,9 @@
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.95
+  set Strategy                           = strain rate
+  set Coarsening fraction                = 0.05
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_3D_part1.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_3D_part1.prm.bak
new file mode 100644
index 00000000000..8d19f6bc84a
--- /dev/null
+++ b/cookbooks/crustal_deformation/doc/crustal_model_3D_part1.prm.bak
@@ -0,0 +1,7 @@
+subsection Boundary velocity model
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = cm=0.01, year=1
+    set Function expression =  if (x<56e3 && y<=48e3 | x<72e3 && y>48e3,-1*cm/year,1*cm/year);0;0
+  end
+end
diff --git a/cookbooks/fastscape_eroding_box/fastscape_eroding_box.prm.bak b/cookbooks/fastscape_eroding_box/fastscape_eroding_box.prm.bak
new file mode 100644
index 00000000000..eeadbbaae4b
--- /dev/null
+++ b/cookbooks/fastscape_eroding_box/fastscape_eroding_box.prm.bak
@@ -0,0 +1,177 @@
+# This cookbook is used as a test to ensure that FastScape is properly working with ASPECT.
+# It consists of a 2.5 km high central mountain block that is eroded through the use of
+# hillslope diffusion and the Stream Power Law. Within ASPECT, the model is based off
+# convection-box-3d. However, it is set up in a way that nothing happens in the geodynamic model.
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 2.5e5
+set Maximum time step                      = 50000
+set Output directory                       = eroding_box
+set Pressure normalization                 = no
+set Surface pressure                       = 0
+
+# A box that has an initial 60x60 km mountain block that is 2.5 km above the initial model surface.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 125e3
+    set Y extent = 100e3
+    set Z extent = 25e3
+    set X repetitions = 5
+    set Y repetitions = 4
+  end
+
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function expression = if(y>20e3 && y<80e3 && x>32.5e3 && x<92.5e3, 2500, 0)
+    end
+  end
+end
+
+# We do not consider temperature in this setup
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = initial temperature
+end
+
+# X Set all boundaries except the top to freeslip.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, front, back, left, right
+end
+
+# Here we setup the top boundary with fastscape.
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top : fastscape
+  set Additional tangential mesh velocity boundary indicators = left, right, front, back
+
+  subsection Fastscape
+    # As the highest resolution at the surface is 4 in the mesh refinement function, we set this the same.
+    set Maximum surface refinement level = 4
+
+    # Because we only have the same level across the entire surface we set this to zero.
+    # If we had multiple resolutions, e.g. 3 different cell sizes at the surface,
+    # this would be set to 2 (number of cell sizes at surface - 1).
+    set Surface refinement difference = 0
+
+    # We set FastScape as 1 level more resolved than ASPECT's initial global surface resolution.
+    set Additional fastscape refinement = 1
+
+    # Number of FastScape timesteps we want per ASPECT timestep.
+    set Number of fastscape timesteps per aspect timestep = 5
+
+    # Set the maximum allowable FastScape time step length. If the (ASPECT time step length)/(Number of FastScape steps per ASPECT step)
+    # is greater than this value, then the number of FastScape steps per ASPECT step is automatically doubled.
+    # This is continued until the FastScape timestep length is less than this value.
+    #
+    # The units of this parameter are either years or seconds, dependent on the global parameter that
+    # determines whether an input file uses one or the other.
+    set Maximum timestep length = 10000
+
+    # Seed number for initial topography noise
+    set Fastscape seed = 1000
+
+    # Because no boundaries are periodic, no flux is prescribed, and no advection occurs in FastScape,
+    # we do not need ghost nodes.
+    set Use ghost nodes = false
+    set Vertical exaggeration = 1
+
+    # Fix all boundaries in FastScape.
+    subsection Boundary conditions
+      set Front = 1
+      set Right  = 1
+      set Back    = 1
+      set Left   = 1
+    end
+
+    # We use both the Stream Power Law (SPL) and hillslope diffusion. The bedrock deposition
+    # variable allows deposition of sediment; however, because
+    # the sediment variables are not set, they are equal to
+    # bedrock values.
+    subsection Erosional parameters
+      set Drainage area exponent = 0.4
+      set Bedrock diffusivity = 1e-2
+      set Bedrock river incision rate = 1e-4
+      set Slope exponent = 1
+      set Bedrock deposition coefficient = 1
+
+      # A negative value indicates varied flow. 10 is steepest descent, and 1 is uniform distribution.
+      set Multi-direction slope exponent = -1
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+# Dimensionless
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# We set a maximum surface refinement level of 4 using the max/minimum refinement level.
+# This will make it so that the ASPECT surface refinement is the same as what we set
+# for our maximum surface refinement level for FastScape.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 1
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = minimum refinement function, maximum refinement function
+
+  subsection Maximum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y,z
+    set Function expression = if(z>=21000, 4, 2)
+  end
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y,z
+    set Function expression = if(z>=21000, 4, 2)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set List of output variables      = strain rate
+    set Interpolate output = true
+    set Write higher order output = true
+  end
+end
diff --git a/cookbooks/finite_strain/doc/finite_strain.part.prm.bak b/cookbooks/finite_strain/doc/finite_strain.part.prm.bak
new file mode 100644
index 00000000000..85b15281c49
--- /dev/null
+++ b/cookbooks/finite_strain/doc/finite_strain.part.prm.bak
@@ -0,0 +1,14 @@
+set Additional shared libraries            = ./libfinite_strain.so
+
+subsection Material model
+  set Model name = finite strain
+
+  subsection Simple model
+    set Thermal conductivity = 4.7
+    set Reference density = 3400
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity = 5e21
+    set Thermal viscosity exponent = 7
+    set Reference temperature = 1600
+  end
+end
diff --git a/cookbooks/finite_strain/finite_strain.cc.bak b/cookbooks/finite_strain/finite_strain.cc.bak
new file mode 100644
index 00000000000..88ba08af862
--- /dev/null
+++ b/cookbooks/finite_strain/finite_strain.cc.bak
@@ -0,0 +1,128 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class FiniteStrain : public MaterialModel::Simple<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+        void parse_parameters(ParameterHandler &prm) override;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    FiniteStrain<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // First, we use the material descriptions of the 'simple' material model to fill all of the material
+      // model outputs. Below, we will then overwrite selected properties (the reaction terms), which are
+      // needed to track the finite strain.
+      Simple<dim>::evaluate(in, out);
+
+      // We need the velocity gradient for the finite strain (they are not included in material model inputs),
+      // so we get them from the finite element.
+      if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0)
+        {
+          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+1);
+          FEValues<dim> fe_values (this->get_mapping(),
+                                   this->get_fe(),
+                                   quadrature_formula,
+                                   update_gradients);
+
+          std::vector<Tensor<2,dim>> velocity_gradients (quadrature_formula.size(), Tensor<2,dim>());
+
+          fe_values.reinit (in.current_cell);
+          fe_values[this->introspection().extractors.velocities].get_function_gradients (this->get_solution(),
+                                                                                         velocity_gradients);
+
+          // Assign the strain components to the compositional fields reaction terms.
+          // If there are too many fields, we simply fill only the first fields with the
+          // existing strain rate tensor components.
+          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
+            {
+              // Convert the compositional fields into the tensor quantity they represent.
+              const Tensor<2,dim> strain(make_array_view(&in.composition[q][0],
+                                                         &in.composition[q][0] + Tensor<2,dim>::n_independent_components));
+
+              // Compute the strain accumulated in this timestep.
+              const Tensor<2,dim> strain_increment = this->get_timestep() * (velocity_gradients[q] * strain);
+
+              // Output the strain increment component-wise to its respective compositional field's reaction terms.
+              strain_increment.unroll(&out.reaction_terms[q][0],
+                                      &out.reaction_terms[q][0] + Tensor<2,dim>::n_independent_components);
+            }
+        }
+    }
+
+
+    template <int dim>
+    void
+    FiniteStrain<dim>::
+    parse_parameters (ParameterHandler &prm)
+    {
+      Simple<dim>::parse_parameters (prm);
+
+      AssertThrow(this->n_compositional_fields() >= (Tensor<2,dim>::n_independent_components),
+                  ExcMessage("There must be at least as many compositional fields as independent components in the full "
+                             "strain rate tensor."));
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(FiniteStrain,
+                                   "finite strain",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but tracks the finite strain as compositional "
+                                   "fields. More precisely, the model assumes that the first 4 (in 2D) "
+                                   "or 9 (in 3D) compositional fields contain the components "
+                                   "of the deformation gradient tensor, $\\mathbf F$, which can "
+                                   "be polar-decomposed into the left stretching tensor "
+                                   "$\\mathbf L$ (the finite strain we are interested in), and the "
+                                   "rotation tensor $\\mathbf Q$. See the corresponding cookbook in "
+                                   "the manual for more detailed information.")
+  }
+}
diff --git a/cookbooks/finite_strain/finite_strain.prm.bak b/cookbooks/finite_strain/finite_strain.prm.bak
new file mode 100644
index 00000000000..1347f0827c5
--- /dev/null
+++ b/cookbooks/finite_strain/finite_strain.prm.bak
@@ -0,0 +1,119 @@
+# Listing of Parameters
+# ---------------------
+# Model for global mantle convection with tracking of the finite strain tensor.
+
+set Additional shared libraries            = ./libfinite_strain_cookbook.so
+set Adiabatic surface temperature          = 1600
+set Maximum time step                      = 1e6
+set Dimension                              = 2
+set End time                               = 6e8
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Output directory                       = output-finite_strain
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 2780
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0;0.0;0.0;1.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 8700000
+    set Y extent = 2900000
+    set X repetitions = 3
+    set X periodic = true
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 5e8
+    set Age top boundary layer    = 3e8
+    set Amplitude                 = 0
+    set Position                  = center
+    set Radius                    = 350000
+
+    subsection Function
+      set Function expression       = 0;0;0;0
+    end
+  end
+end
+
+subsection Material model
+  set Model name = finite strain
+  set Material averaging = none
+
+  subsection Simple model
+    set Thermal conductivity = 4.7
+    set Reference density = 3400
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity = 5e21
+    set Thermal viscosity exponent = 7
+    set Reference temperature = 1600
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 6
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top,bottom
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net x translation
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics
+
+  subsection Visualization
+    set List of output variables      = nonadiabatic temperature, strain rate
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Interpolate output            = true
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint = 1800
+end
diff --git a/cookbooks/free_surface/doc/free_surface.part.prm.bak b/cookbooks/free_surface/doc/free_surface.part.prm.bak
new file mode 100644
index 00000000000..a4d60719ccb
--- /dev/null
+++ b/cookbooks/free_surface/doc/free_surface.part.prm.bak
@@ -0,0 +1,41 @@
+set Maximum first time step                = 1e3
+set Maximum relative increase in time step = 30
+set Pressure normalization                 = no
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left, right, bottom, top
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = sqrt((x-250.e3)^2 + (y-100.e3)^2) < 25.e3 ? 200.0 : 0.0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set Time between graphical output = 1.e6
+  end
+end
diff --git a/cookbooks/free_surface/free_surface.prm.bak b/cookbooks/free_surface/free_surface.prm.bak
new file mode 100644
index 00000000000..ada080f9918
--- /dev/null
+++ b/cookbooks/free_surface/free_surface.prm.bak
@@ -0,0 +1,141 @@
+# This is a very simple cookbook which demonstrates the use of a free surface
+# for computing surface topography. The model is a 2D box, with a rising blob
+# beneath a free surface that generates an initially increasing and then
+# decaying surface topography while its heat diffuses. We output the maximum
+# and minimum topography at every time step to document the evolution of
+# topography.
+
+set Dimension                              = 2
+set End time                               = 2e7
+set Use years in output instead of seconds = true
+set Output directory                       = output-free_surface
+
+# Free surface calculations are typically more difficult to stabilize, and tend
+# to mesh oscillations, in particular for the initial time steps. Thus, we limit
+# the initial time steps to a smaller size (1000 years, and we allow each time
+# step to only grow by 30% compared to the last one to avoid jumps in time step
+# length). We could also reduce the CFL number to decrease all time steps, but
+# that would slow down the whole model instead of just the first time steps.
+set Maximum first time step                = 1e3
+set Maximum relative increase in time step = 30
+set CFL number                             = 1.0
+
+# Pressure normalization must be set to ``no'' for free surface models, as its
+# equations are based on the assumption that the pressure is zero at the free
+# surface.
+set Pressure normalization                 = no
+
+# We can use any of the normal geometry models for free surface modeling, we
+# just need to specify further down which surface is to be the free one. We
+# here use a box model with vertical downwards gravity.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Here is the major new section for this parameter file, specifying the
+# parameters for running free surface calculations.
+subsection Mesh deformation
+  # We specify a comma delimited list of all boundaries for which the mesh will
+  # deform (the top boundary), and the method by which their deformation is
+  # determined (in this case a free surface).
+  set Mesh deformation boundary indicators = top: free surface
+
+  # We can specify the free surface stabilization parameter
+  # theta, between zero and one with 0.5 being the default.
+  # If the parameter is zero, there is no stabilization
+  # and you are likely to see a sloshing instability develop. If
+  # it is one, the surface should be the most stable, though you
+  # may find that the rates that it moves are fairly damped.
+  # See the paper describing the free surface for more details on
+  # this parameter.
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+# Here we specify that the model has free slip velocity boundary conditions for
+# the sides and bottom. We do not specify a boundary condition for the top,
+# which is equivalent to a zero stress boundary condition. This means while the
+# section above describes how the mesh deforms, this section still describes
+# how the velocity should behave at these boundaries, and only the combination
+# of prescribing the mesh to move with the velocity and allowing the velocity
+# to move through the boundary generates the effect we commonly call "free
+# surface".
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+end
+
+# We prescribe a zero boundary temperature, as we are just modeling a single
+# rising blob
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left, right, bottom, top
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
+  end
+end
+
+# Our temperature initial conditions are simply a blob of hot
+# rock in the center of the domain.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = sqrt((x-250.e3)^2 + (y-100.e3)^2) < 25.e3 ? 200.0 : 0.0
+  end
+end
+
+# A fairly standard simple material model, except we use an
+# artificially low thermal conductivity to keep our anomaly
+# from diffusing too fast.
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 1.0
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e20
+  end
+end
+
+# For simplicity we disable adaptive mesh refinement,
+# although it would significantly speed up this model
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+# We also include the topography postprocessor, which just calculates
+# the maximum and minimum topography on your free surface at
+# every time step.
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set Time between graphical output = 1.e6
+  end
+end
diff --git a/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part1.prm.bak b/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part1.prm.bak
new file mode 100644
index 00000000000..9b69c3b729a
--- /dev/null
+++ b/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part1.prm.bak
@@ -0,0 +1,4 @@
+# This model loads an additional shared library, which provides another
+# material model that is not part of the main ASPECT code, but instead
+# lies in in a subdirectory of this cookbook folder.
+set Additional shared libraries            = ./plugin/libsimpler_with_crust.so
diff --git a/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part2.prm.bak b/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part2.prm.bak
new file mode 100644
index 00000000000..1a2d0b1f977
--- /dev/null
+++ b/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part2.prm.bak
@@ -0,0 +1,19 @@
+# Because we load the additional shared library at the top, we here have the
+# option to choose the new material model that is described inside that library
+# called 'simpler with crust'. This model has additional input options for the
+# two layers with different viscosities and the depth of the transition between
+# the two layers.
+subsection Material model
+  set Model name = simpler with crust
+
+  subsection Simpler with crust model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 1.0
+    set Thermal expansion coefficient = 4e-5
+    set Lower viscosity               = 1.e20
+    set Upper viscosity               = 1.e23
+    set Jump height                   = 170.e3
+  end
+end
diff --git a/cookbooks/free_surface_with_crust/free_surface_with_crust.prm.bak b/cookbooks/free_surface_with_crust/free_surface_with_crust.prm.bak
new file mode 100644
index 00000000000..1f17a9c109d
--- /dev/null
+++ b/cookbooks/free_surface_with_crust/free_surface_with_crust.prm.bak
@@ -0,0 +1,112 @@
+# This cookbook is an extension of the free_surface cookbook. Please see the
+# other cookbook for details about the free surface. This cookbook illustrates
+# how to use an external plugin to modify the material model, and what
+# influence a viscous crust has on the magnitude of surface topography.
+
+# This model loads an additional shared library, which provides another
+# material model that is not part of the main ASPECT code, but instead
+# lies in in a subdirectory of this cookbook folder.
+set Additional shared libraries            = ./plugin/libsimpler_with_crust.so
+set Dimension                              = 2
+set End time                               = 2e7
+set Use years in output instead of seconds = true
+set Output directory                       = output-free_surface_with_crust
+set Maximum first time step                = 1e3
+set Maximum relative increase in time step = 30
+set CFL number                             = 1.0
+set Pressure normalization                 = no
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left, right, bottom, top
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
+  end
+end
+
+# As in the free_surface cookbook our temperature initial conditions are simply
+# a blob of hot rock in the center of the domain.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = sqrt((x-250.e3)^2 + (y-100.e3)^2) < 25.e3 ? 200.0 : 0.0
+  end
+end
+
+# Because we load the additional shared library at the top, we here have the
+# option to choose the new material model that is described inside that library
+# called 'simpler with crust'. This model has additional input options for the
+# two layers with different viscosities and the depth of the transition between
+# the two layers.
+subsection Material model
+  set Model name = simpler with crust
+
+  subsection Simpler with crust model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 1.0
+    set Thermal expansion coefficient = 4e-5
+    set Lower viscosity               = 1.e20
+    set Upper viscosity               = 1.e23
+    set Jump height                   = 170.e3
+  end
+end
+
+# For simplicity we disable adaptive mesh refinement,
+# although it would significantly speed up this model
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set List of output variables = material properties
+    set Time between graphical output = 1.e6
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+end
diff --git a/cookbooks/free_surface_with_crust/plugin/simpler_with_crust.cc.bak b/cookbooks/free_surface_with_crust/plugin/simpler_with_crust.cc.bak
new file mode 100644
index 00000000000..db2922e301d
--- /dev/null
+++ b/cookbooks/free_surface_with_crust/plugin/simpler_with_crust.cc.bak
@@ -0,0 +1,220 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+#include <cmath>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model similar to the "simpler" material model, but where the
+     * viscosity has two different values dependent on whether we are above or
+     * below a line at a certain z-value, i.e., representing a crustal layer.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class SimplerWithCrust : public Interface<dim>
+    {
+      public:
+        /**
+         * Return whether the model is compressible or not. This model is
+         * incompressible.
+         */
+        bool is_compressible () const override;
+
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                      typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        double reference_density;
+        double reference_temperature;
+        double eta_L;
+        double eta_U;
+        double jump_height;
+        double thermal_expansion_coefficient;
+        double reference_specific_heat;
+        double thermal_conductivity;
+    };
+
+
+
+    template <int dim>
+    bool
+    SimplerWithCrust<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    void
+    SimplerWithCrust<dim>::
+    evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+             typename Interface<dim>::MaterialModelOutputs &out ) const
+    {
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          const double z = in.position[i][1];
+
+          if (z>jump_height)
+            out.viscosities[i] = eta_U;
+          else
+            out.viscosities[i] = eta_L;
+
+          out.densities[i] = reference_density * (1.0 - thermal_expansion_coefficient * (in.temperature[i] - reference_temperature));
+          out.thermal_expansion_coefficients[i] = thermal_expansion_coefficient;
+          out.specific_heat[i] = reference_specific_heat;
+          out.thermal_conductivities[i] = thermal_conductivity;
+          out.compressibilities[i] = 0.0;
+          out.entropy_derivative_pressure[i] = 0.0;
+          out.entropy_derivative_temperature[i] = 0.0;
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    SimplerWithCrust<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simpler with crust model");
+        {
+          prm.declare_entry ("Reference density", "3300.",
+                             Patterns::Double (0.),
+                             "Reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. The reference temperature is used "
+                             "in the density formula. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Lower viscosity", "1e20",
+                             Patterns::Double (0.),
+                             "The value of the viscosity $\\eta_L$ in the lower layer. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Upper viscosity", "1e23",
+                             Patterns::Double (0.),
+                             "The value of the viscosity $\\eta_U$ in the upper layer. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Jump height", "100000.",
+                             Patterns::Double (0.),
+                             "The height at which the viscosity changes. Units: \\si{\\meter}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250.",
+                             Patterns::Double (0.),
+                             "The value of the specific heat capacity $c_p$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\alpha$. "
+                             "Units: \\si{\\per\\kelvin}.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    SimplerWithCrust<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simpler with crust model");
+        {
+          reference_density          = prm.get_double ("Reference density");
+          reference_temperature      = prm.get_double ("Reference temperature");
+          eta_L                      = prm.get_double ("Lower viscosity");
+          eta_U                      = prm.get_double ("Upper viscosity");
+          jump_height                = prm.get_double ("Jump height");
+          thermal_conductivity       = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_expansion_coefficient = prm.get_double ("Thermal expansion coefficient");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.density = NonlinearDependence::none;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SimplerWithCrust,
+                                   "simpler with crust",
+                                   "A material model that is like the ``simpler'' model but "
+                                   "has a jump in the viscosity at a specified depth.")
+  }
+}
diff --git a/cookbooks/future/mantle_setup_restart.prm.bak b/cookbooks/future/mantle_setup_restart.prm.bak
new file mode 100644
index 00000000000..1117b749463
--- /dev/null
+++ b/cookbooks/future/mantle_setup_restart.prm.bak
@@ -0,0 +1,30 @@
+include ./mantle_setup_start.prm
+
+set Dimension                              = 2
+set End time                               = 3e8
+set Resume computation                     = true
+set Nonlinear solver tolerance             = 1e-4
+
+subsection Melt settings
+  set Include melt transport               = true
+  set Melt scaling factor threshold        = 1e-8
+end
+
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction time step                     = 2e2
+    set Reaction time steps per advection step = 20
+  end
+end
+
+subsection Material model
+  subsection Melt boukare
+    set Melting time scale for operator splitting = 1e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 2
+  set Time steps between mesh refinement       = 3
+end
diff --git a/cookbooks/future/mantle_setup_start.prm b/cookbooks/future/mantle_setup_start.prm
index 4b733a7e240..98a79045800 100644
--- a/cookbooks/future/mantle_setup_start.prm
+++ b/cookbooks/future/mantle_setup_start.prm
@@ -7,7 +7,7 @@ set Dimension                              = 2
 set Use years in output instead of seconds = true
 set End time                               = 1.5e8    # run until 1.5e8, then restart with Melt scaling factor threshold = 1e-8
 set Output directory                       = output_ULVZ_2
-set Nonlinear solver scheme                = iterated IMPES
+set Nonlinear solver scheme                = iterated Advection and Stokes
 set Max nonlinear iterations               = 20
 
 #set Resume computation = true
@@ -101,7 +101,7 @@ end
 subsection Boundary composition model
   set Allow fixed composition on outflow boundaries = false
   set Fixed composition boundary indicators   = top
-  set Model name = initial composition
+  set List of model names = initial composition
 end
 
 subsection Heating model
diff --git a/cookbooks/future/mantle_setup_start.prm.bak b/cookbooks/future/mantle_setup_start.prm.bak
new file mode 100644
index 00000000000..4b733a7e240
--- /dev/null
+++ b/cookbooks/future/mantle_setup_start.prm.bak
@@ -0,0 +1,192 @@
+# Model for melt transport within the lowermost mantle.
+# This input file runs a model without melt transport to
+# steady state, and the file mantle_setup_restart.prm
+# restarts it with melt migration enabled.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1.5e8    # run until 1.5e8, then restart with Melt scaling factor threshold = 1e-8
+set Output directory                       = output_ULVZ_2
+set Nonlinear solver scheme                = iterated IMPES
+set Max nonlinear iterations               = 20
+
+#set Resume computation = true
+set Pressure normalization                 = surface
+
+# The top of the model is 200 km above the CMB, so we have to choose the surface pressure
+# accordingly. With this value, the CMB pressure should be 136 GPa.
+set Surface pressure                       = 1.25e11
+set Adiabatic surface temperature          = 2510
+set Use conduction timestep                = true
+set Use operator splitting                 = true
+set Maximum time step                      = 1e6
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
+end
+
+# The melt scaling factor threshold controls the porosity above which melt is transported
+# in a given cell of the model. Since the value of 1e20 is never reached anywhere in the
+# model, setting the parameter to this value disables melt transport. For the restart, this
+# value is decreased to enable melt transport.
+subsection Melt settings
+  set Include melt transport               = true
+  set Melt scaling factor threshold        = 1e20
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set GMRES solver restart length = 200
+  end
+
+  subsection Operator splitting parameters
+    set Reaction time step                     = 4e3 #2e2 for the restart
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 600000
+    set Y extent = 200000
+    set X periodic = false
+    set X repetitions = 3
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 5e7
+
+    subsection Function
+      set Function expression = 0; 0.07; 0.07
+    end
+  end
+
+  subsection Function
+    set Function constants  = amplitude=500, width=50000, b=100000, x0=300000 #25000
+    set Function expression = 10 * exp(-((x-x0)*(x-x0)/(2*5000*5000)+y*y/(2*5000*5000)))
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function, porosity
+
+  subsection Function
+    set Function expression = 0; 0.07; 0.07
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       =
+  set Prescribed velocity boundary indicators =
+  set Tangential velocity boundary indicators = bottom, left, right
+end
+
+subsection Boundary temperature model
+  set Allow fixed temperature on outflow boundaries = false
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Maximal temperature = 4000
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+  set Fixed composition boundary indicators   = top
+  set Model name = initial composition
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating, latent heat melt
+
+  subsection Latent heat melt
+    set Melting entropy change = 0
+    set Retrieve entropy change from material model = true
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Material model
+  set Model name = melt boukare
+
+  subsection Melt boukare
+    set Thermal conductivity          = 8.5
+    set Reference shear viscosity     = 1e23
+    set Reference bulk viscosity      = 1e23
+    set Reference volumes             = 2.534e-05, 2.445e-05, 1.206e-05, 1.125e-05, 1.9e-5, 1.218e-05, 1.218e-05
+    set Thermal viscosity exponent    = 10
+    set Thermal bulk viscosity exponent = 10
+    set Exponential melt weakening factor    = 20
+    set Include melting and freezing  = true
+    set Melting time scale for operator splitting = 1e5
+    set Fe mantle melting temperature = 2774.5
+    set Mg mantle melting temperature = 4171.2
+    set Reference permeability        = 5e-12
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 2
+  set Time steps between mesh refinement       = 3
+  set Strategy                                 = composition threshold, minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system = cartesian
+    set Function expression = (x>285000 && x<315000) ? 7 : 4
+  end
+
+  subsection Composition threshold
+    set Compositional field thresholds = 2e-4, 1, 1
+  end
+end
+
+subsection Boundary fluid pressure model
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e6
+    set List of output variables = material properties, nonadiabatic temperature, melt fraction, melt material properties, named additional outputs
+    set Output format = vtu
+    set Interpolate output = false
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
+    end
+
+    subsection Melt material properties
+      set List of properties = compaction viscosity, permeability, fluid density
+    end
+  end
+end
+
+subsection Checkpointing
+  # The wall time between performing checkpoints. If 0, will use the
+  # checkpoint step frequency instead. Units: Seconds.
+  set Time between checkpoint  = 900
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+end
diff --git a/cookbooks/future/net_rotation.prm.bak b/cookbooks/future/net_rotation.prm.bak
new file mode 100644
index 00000000000..ed9b661979d
--- /dev/null
+++ b/cookbooks/future/net_rotation.prm.bak
@@ -0,0 +1,78 @@
+# A 2d shell with free slip top and bottom boundary to demonstrate
+# net rotation removal
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1.5e9
+set Output directory                       = output-netrot
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e20
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Nullspace removal
+  # net rotation|net translation|angular momentum|translational momentum
+  set Remove nullspace = net rotation
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 5
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/cookbooks/future/periodic_box.prm.bak b/cookbooks/future/periodic_box.prm.bak
new file mode 100644
index 00000000000..b675d2d538e
--- /dev/null
+++ b/cookbooks/future/periodic_box.prm.bak
@@ -0,0 +1,106 @@
+# This is a simple 2d setup that is periodic in x direction, which
+# requires removing the nullspace (here we use "net x translation")
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e9
+set Output directory                       = output-periodic_box
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = no
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 0.0
+    set Bottom temperature = 1000.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set X extent = 1.e6
+    set Y extent = 5.e5
+    set Z extent = 5.e5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e20
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 6
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.03
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 10
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net x translation
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables =
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+    set Time between graphical output = 1.e3
+  end
+end
diff --git a/cookbooks/future/radiogenic_heating.prm.bak b/cookbooks/future/radiogenic_heating.prm.bak
new file mode 100644
index 00000000000..1d04f7d6a78
--- /dev/null
+++ b/cookbooks/future/radiogenic_heating.prm.bak
@@ -0,0 +1,104 @@
+############### Global parameters
+# We use a 2d setup. Since it takes some time for
+# the model to reach a steady state we set the
+# end time to approximately 2 million years.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 2e6
+set Use years in output instead of seconds = false
+set Output directory                       = output-radiogenic_heating
+
+subsection Heating model
+  set List of model names = constant heating
+
+  subsection Constant heating
+    set Radiogenic heating rate = 1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+############### Boundary conditions
+# We only fix the temperature at the upper boundary, the other boundaries
+# are isolating.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# To guarantuee a steady downward flow, we fix the velocity
+# at the top and bottom, and set it to free slip on the sides.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Function expression = 0;-1
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 0.0
+    set Thermal expansion coefficient                  = 0.0
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 1e4
+    set List of output variables      = density
+  end
+end
diff --git a/cookbooks/future/radiogenic_heating_function.prm.bak b/cookbooks/future/radiogenic_heating_function.prm.bak
new file mode 100644
index 00000000000..57b8d692dac
--- /dev/null
+++ b/cookbooks/future/radiogenic_heating_function.prm.bak
@@ -0,0 +1,108 @@
+############### Global parameters
+# We use a 2d setup. Since it takes some time for
+# the model to reach a steady state we set the
+# end time to approximately 2 million years.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 3e6
+set Use years in output instead of seconds = false
+set Output directory                       = output-radiogenic_heating_function
+
+# As we only want to look at the effects of radiogenic heating, this one
+# is the only active heating plugin.
+subsection Heating model
+  set List of model names = function
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = length=1000000
+    set Function expression = if(t<2e6,x / length, 0.0)
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+############### Boundary conditions
+# We only fix the temperature at the upper boundary, the other boundaries
+# are isolating.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# To guarantuee a steady downward flow, we fix the velocity
+# at the top and bottom, and set it to free slip on the sides.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Function expression = 0;-1
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 0.0
+    set Thermal expansion coefficient                  = 0.0
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 1e4
+    set List of output variables      = density
+  end
+end
diff --git a/cookbooks/future/sphere.prm.bak b/cookbooks/future/sphere.prm.bak
new file mode 100644
index 00000000000..c12f5efbbe0
--- /dev/null
+++ b/cookbooks/future/sphere.prm.bak
@@ -0,0 +1,74 @@
+# A simple setup for convection in a sphere
+# manual for more information.
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 5.0e8
+set Output directory                       = output-sphere
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e20
+  end
+end
+
+subsection Geometry model
+  set Model name = sphere
+
+  subsection Sphere
+    set Radius  = 1250000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = top: 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if( sqrt( (x-5.e5)^2 + (y-5.e5)^2) < 1.e5, 0, 100)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial linear
+
+  subsection Radial linear
+    set Magnitude at bottom = 0.0
+    set Magnitude at surface = 4.5
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 5
+  set Initial adaptive refinement        = 2
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+end
diff --git a/cookbooks/geomio/doc/geomIO.prm.bak b/cookbooks/geomio/doc/geomIO.prm.bak
new file mode 100644
index 00000000000..3ac91a8771b
--- /dev/null
+++ b/cookbooks/geomio/doc/geomIO.prm.bak
@@ -0,0 +1,40 @@
+subsection Geometry model
+  set Model name = box
+
+  # The extents of the box is the same as the width
+  # and height of the drawing in px
+  # (an A4 page = 7350x10500 px).
+  subsection Box
+    set X extent = 7350
+    set Y extent = 10500
+  end
+end
+
+# We need one compositional field that will be assigned
+# the values read in from the ascii data plugin.
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+# We use the ascii data plugin to read in the file created with geomIO.
+subsection Initial composition model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = jelly.txt
+  end
+end
+
+# We refine the mesh where compositional gradients are
+# high, i.e. at the boundary between the different phases
+# assigned to the compositional field through the initial
+# condition.
+subsection Mesh refinement
+  set Refinement fraction                      = 0.99
+  set Coarsening fraction                      = 0
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 4
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = composition
+end
diff --git a/cookbooks/geomio/geomIO.prm.bak b/cookbooks/geomio/geomIO.prm.bak
new file mode 100644
index 00000000000..96034af10f6
--- /dev/null
+++ b/cookbooks/geomio/geomIO.prm.bak
@@ -0,0 +1,96 @@
+# A model using the ascii data plugin to read in a file
+# generated by geomIO.
+# See the manual for more information.
+
+set Output directory                       = output-geomIO
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  # The extents of the box in m is the same as the width
+  # and height of the drawing in px
+  # (an A4 page = 7350x10500 px).
+  subsection Box
+    set X extent = 7350
+    set Y extent = 10500
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+# We need one compositional field that will be assigned
+# the values read in from the ascii data plugin.
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+# We use the ascii data plugin to read in the file created with geomIO.
+subsection Initial composition model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = jelly.txt
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = box
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+# We refine the mesh where compositional gradients are
+# high, i.e. at the boundary between the different phases
+# assigned to the compositional field through the initial
+# condition.
+subsection Mesh refinement
+  set Refinement fraction                      = 0.99
+  set Coarsening fraction                      = 0
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 4
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = composition
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0.01
+  end
+end
diff --git a/cookbooks/global_melt/doc/global_melt.prm.bak b/cookbooks/global_melt/doc/global_melt.prm.bak
new file mode 100644
index 00000000000..5c82d601395
--- /dev/null
+++ b/cookbooks/global_melt/doc/global_melt.prm.bak
@@ -0,0 +1,248 @@
+# Cookbook for a global-scale 2D box mantle convection model
+# with melt migration.
+# In this file we will go through all of the steps that are
+# required for adding melting and melt transport to a mantle
+# convection simulation.
+
+# For models with melt migration, there is a nonlinear coupling between
+# the Stokes system, the temperature, and the advection equation for the
+# porosity (several material properties, such as the viscosities and the
+# permeability depend nonlinearly on the porosity; and changes in temperature
+# determine how much material is melting or freezing).
+# Because of that, we use a nonlinear solver scheme ('iterated Advection and Stokes')
+# that iterates between all of these equations, and we have to set its
+# solver tolerance and the maximum number of iterations separately from
+# the linear solver parameters.
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 20
+set Nonlinear solver tolerance             = 1e-5
+
+# In addition, melting and freezing normally happens on a much faster
+# time scale than the flow of melt, so we want to decouple the advection
+# of melt (and temperature) and the melting process itself. To do that,
+# we use the operator splitting scheme, and define that for every
+# advection time step, we want to do at least 10 reaction time steps.
+# If these time steps would be larger than 10,000 years, we will do
+# more reaction time steps (so that reaction time step size never exceeds
+# 10,000 years). Here, we also specify the Stokes linear solver tolerance
+# and maximum number of cheap Stokes solver steps to improve the nonlinear
+# convergence behavior.
+set Use operator splitting                     = true
+
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction time step                     = 1e4
+    set Reaction time steps per advection step = 10
+  end
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 100
+  end
+end
+
+subsection Melt settings
+  # In addition, we now also specify in the model settings that we want to
+  # run a model with melt transport.
+  set Include melt transport                  = true
+end
+
+##################### Settings for melt transport ########################
+
+# In models with melt transport, we always need a compositional field with
+# the name 'porosity'. Only the field with that name will be advected with
+# the melt velocity, all other compositional fields will continue to work
+# as before. Material models will typically query for the field with the
+# name porosity to compute all melt material properties.
+# In addition, the 'melt global' material model also requires a field with the
+# name 'peridotite'. This field is used to track how much material has been
+# molten at each point of the model, so it tracks the information how the
+# composition of the rock changes due to partial melting events (sometimes
+# also called depletion). This is important, because usually less melt is
+# generated for a given temperature and pressure if the rock has undergone
+# melting before. Typically, material properties like the density are also
+# different for more or less depleted material.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+##################### Initial conditions ########################
+
+# Now that our model uses compositional fields, we also need initial
+# conditions for the composition.
+# We use the function plugin to set both fields to zero at the beginning
+# of the model run.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0; 0
+    set Variable names      = x,y
+  end
+end
+
+##################### Boundary conditions ########################
+
+# We again choose the initial composition as boundary condition
+# for all compositional fields.
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Models with melt transport also need an additional boundary condition:
+# the gradient of the fluid pressure at the model boundaries. This boundary
+# condition indirectly also prescribes boundary conditions for the melt velocity,
+# as the melt velocity is related to the fluid pressure gradient via Darcy's law.
+# If we choose the fluid pressure gradient = solid density * gravity, melt will
+# flow in and out of the model (even if the solid can not flow out) according to
+# the dynamic fluid pressure in the model. Conversely, if we choose the
+# fluid pressure gradient = fluid density * gravity, melt will flow in or out
+# with the same velocity as the solid (so for a closed boundary, no melt will
+# flow in or out). This is what we choose as our boundary condition here.
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+##################### Material properties ########################
+
+# In addition to the material properties for the solid rock,
+# we also have to specify properties for the melt.
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    # First we describe the parameters for the solid, in the same way
+    # we did in the model without melt transport
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Thermal expansion coefficient     = 2e-5
+    set Reference shear viscosity         = 5e21
+    set Thermal viscosity exponent        = 7
+    set Reference temperature             = 1600
+    set Solid compressibility             = 4.2e-12
+
+    # The melt usually has a different (lower) density than the solid.
+    set Reference melt density            = 3000
+
+    # The permeability describes how well the pores of a porous material
+    # are connected (and hence how fast melt can flow through the rock).
+    # It is computed as the product of the reference value given here
+    # and the porosity cubed. This means that the lower the porosity is
+    # the more difficult it is for the melt to flow.
+    set Reference permeability            = 1e-8
+
+    # The bulk viscosity describes the resistance of the rock to dilation
+    # and compaction. Melt can only flow into a region that had no melt
+    # before if the matrix of the solid rock expands, so this parameter
+    # also limits how fast melt can flow upwards.
+    # The bulk viscosity is computed as the reference value given here times
+    # a term that scales with one over the porosity. This means that for zero
+    # porosity, the rock can not dilate/compact any more, which is the same
+    # behavior that we have for solid mantle convection.
+    set Reference bulk viscosity          = 1e19
+
+    # In dependence of how much melt is present, we also weaken the shear
+    # viscosity: The more melt is present, the weaker the rock gets.
+    # This scaling is exponential, following the relation
+    # viscosity ~ exp(-alpha * phi),
+    # where alpha is the parameter given here, and phi is the porosity.
+    set Exponential melt weakening factor = 10
+
+    # In the same way the shear viscosity is reduced with increasing temperature,
+    # we also prescribe the temperature-dependence of the bulk viscosity.
+    set Thermal bulk viscosity exponent   = 7
+
+    # Analogous to the compressibility of the solid rock, we also define a
+    # comressibility for the melt (which is generally higher than for the solid).
+    # As we do not want our compressibility to depend on depth, we set the
+    # pressure derivative to zero.
+    set Melt compressibility              = 1.25e-11
+    set Melt bulk modulus derivative      = 0.0
+
+    # Finally, we prescribe the viscosity of the melt, which is used in Darcy's
+    # law. The lower this viscosity, the faster melt can flow.
+    set Reference melt viscosity          = 1
+
+    # change the density contrast of depleted material (in kg/m^3)
+    set Depletion density change          = -200.0
+
+    # How much melt has been generated and subsequently extracted from a particular
+    # volume of rock (how 'depleted' that volume of rock is) usually changes the
+    # solidus. The more the material has been molten already, the less melt will be
+    # generated afterwards for the same pressure and temperature conditions. We
+    # model this using a simplified, linear relationship, saying that to melt 100%
+    # of the rock the temperature has to be 200 K higher than to melt it initially.
+    set Depletion solidus change          = 200
+
+    # We also have to determine how fast melting and freezing should happen.
+    # Here, we choose a time scale of 10,000 years, which is a relatively long time
+    # (or in other words, slow melting rate), but because this is a global model
+    # and the time steps are big, it should be sufficient.
+    set Melting time scale for operator splitting = 1e4
+  end
+end
+
+##################### Mesh refinement #########################
+
+# For the model with melt migration, we use adaptive refinement.
+# We make use of two different refinement criteria: we set a minimum of 5 global
+# refinements everywhere in the model (which is the same resolution as for the
+# model without melt), and we refine in regions where melt is present, to be
+# precise, everywhere where the porosity is bigger than 1e-6.
+# We adapt the mesh every 5 time steps.
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 2
+  set Initial global refinement                = 5
+  set Strategy                                 = composition threshold, minimum refinement function, boundary
+  set Time steps between mesh refinement       = 5
+
+  # minimum of 5 global refinements
+  subsection Minimum refinement function
+    set Function expression = 5
+  end
+
+  # refine where the porosity is bigger than 1e-6
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-6,1.0
+  end
+
+  # refine at top and bottom boundary
+  subsection Boundary
+    set Boundary refinement indicators = top, bottom
+  end
+end
+
+##################### Postprocessing ########################
+
+# In addition to the visualization output, we select a number
+# of postprocessors that allow us to compute some statistics
+# about the output (to see how much the model without and the
+# model with melt migration differ), and in particular we use
+# the "depth average" postprocessor that will allow us to plot
+# depth-averaged model quantities over time.
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, depth average
+
+  # For the model with melt migration, also add a visualization
+  # postprocessor that computes the material properties relevant
+  # to migration (permeability, viscosity of the melt, etc.).
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt material properties
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
diff --git a/cookbooks/global_melt/doc/global_no_melt.prm.bak b/cookbooks/global_melt/doc/global_no_melt.prm.bak
new file mode 100644
index 00000000000..c6c5eaad18b
--- /dev/null
+++ b/cookbooks/global_melt/doc/global_no_melt.prm.bak
@@ -0,0 +1,211 @@
+# Model setup for mantle convection in a 2D box without melting.
+# This file is used as a starting point for a cookbook that
+# explains how to add melting and melt transport to a mantle
+# convection simulation.
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 1600
+set Maximum time step                      = 1e6
+set Output directory                       = output-global_no_melt
+set Use years in output instead of seconds = true
+
+# The end time of the simulation. Because we want to see how upwellings
+# and downwellings evolve over time, and if differences develop between
+# the model with and without melt migration, we set the end time to 200 Ma.
+set End time                               = 2e8
+
+# We choose a stricter than default linear Stokes solver tolerance,
+# to be consistent with the global_melt cookbook.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 100
+  end
+end
+
+# We prescribe free-slip boundary conditions on all
+# sides.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+# We also choose relatively large values for the stabilization parameters:
+# The model resolution is very coarse (in order for this model to run in a
+# short time), so we want to make sure that no temperature over- and
+# undershoots will develop. In a model with melting this would be
+# particularly problematic, as large amounts of melt could be generated
+# by temperature spikes, and we want to be consistent between the model
+# with and without melt transport.
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.5
+    set cR    = 1
+  end
+end
+
+##################### Initial conditions ########################
+
+# We choose an adiabatic temperature profile as initial condition,
+# with conductive temperature profiles in the top and bottom boundary
+# layers, which were computed using a half space cooling model.
+# The cold top boundary layer corresponds to an age of 70 Ma,
+# and the hot top boundary layer corresponds to an age of 700 Ma.
+# A small temperature perturbation is added at the bottom of the
+# domain. To make the model asymmetric, we place it in a distance of
+# x = 2900 km from the left boundary.
+# Temperatures from both initial temperature models we specify are
+# added (by default).
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 7e8
+    set Age top boundary layer    = 7e7
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+
+  subsection Function
+    set Function constants        = r=350000, amplitude=50
+    set Function expression       = if((x-2900000)*(x-2900000)+y*y<r,amplitude,0)
+  end
+end
+
+##################### Boundary conditions ########################
+
+# As boundary conditions for the temperature, we just use the
+# initial conditions again. This temperature is applied as a prescribed
+# temperature at the top and bottom boundary.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3900
+  end
+end
+
+##################### Model geometry ########################
+
+# The model geometry is a box with an aspect ratio of 3,
+# extending to the base of the mantle in vertical direction.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 8700000
+    set Y extent = 2900000
+    set X repetitions = 3
+  end
+end
+
+################ Gravity and material properties ##################
+
+# The model has a constant gravity.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We use the melt global material model, which is one of the
+# material models that works with melt transport, as it also
+# specifies the material properties needed for melt migration,
+# such as the permeability, the melt density and the melt
+# viscosity.
+# It also works without melt transport, and in this case these
+# properties are not used, so we do not have to specify them
+# here.
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Thermal expansion coefficient     = 2e-5
+    set Reference shear viscosity         = 5e21
+    set Thermal viscosity exponent        = 7
+    set Reference temperature             = 1600
+    set Solid compressibility             = 4.2e-12
+  end
+end
+
+##################### Mesh refinement #########################
+
+# For the model without melt migration, we do not have to use
+# mesh adaptivity, because time- and length scales of material
+# motion does do not vary a lot across the model, and a global
+# resolution of 5 is sufficient to capture the behavior of
+# upwellings and downwellings. We nevertheless want to refine
+# the mesh near the top and bottom boundaries where large
+# thermal gradients occur.
+subsection Mesh refinement
+  set Initial adaptive refinement              = 2
+  set Initial global refinement                = 5
+  set Strategy                                 = minimum refinement function, boundary
+  set Time steps between mesh refinement       = 0
+
+  # minimum of 5 global refinements
+  subsection Minimum refinement function
+    set Function expression = 5
+  end
+
+  # refine at top and bottom boundary
+  subsection Boundary
+    set Boundary refinement indicators = top, bottom
+  end
+end
+
+# As the model is compressible and has an adiabatic temperature profile, we include
+# adiabatic heating in the list of heating models.
+# To make this model as simple as possible, we do not include shear heating (although
+# usually, adiabatic heating and shear heating should always be used together).
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+##################### Postprocessing ########################
+
+# In addition to the visualization output, we select a number
+# of postprocessors that allow us to compute some statistics
+# about the output (to see how much the model without and the
+# model with melt migration differ), and in particular we use
+# the "depth average" postprocessor that will allow us to plot
+# depth-averaged model quantities over time.
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, melt statistics, depth average
+
+  # For the model without melt migration, we only compute the
+  # equilibrium melt fraction in dependence of temperature and
+  # pressure. This is done as a postprocessing step, by adding
+  # "melt fraction" to the list of material properties in the
+  # corresponding visualization postprocessor.
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 6e5
+
+    subsection Material properties
+      set List of material properties = density, viscosity, melt fraction
+    end
+  end
+
+  subsection Depth average
+    set Number of zones = 12
+    set Time between graphical output = 6e5
+  end
+end
+
+# We write a checkpoint approximately every half an hour,
+# so that we are able to restart the computation from that
+# point.
+subsection Checkpointing
+  set Time between checkpoint = 1700
+end
diff --git a/cookbooks/global_melt/global_melt.prm.bak b/cookbooks/global_melt/global_melt.prm.bak
new file mode 100644
index 00000000000..91db6ee9ea4
--- /dev/null
+++ b/cookbooks/global_melt/global_melt.prm.bak
@@ -0,0 +1,371 @@
+# Cookbook for a global-scale 2D box mantle convection model
+# with melt migration.
+# In this file we will go through all of the steps that are
+# required for adding melting and melt transport to a mantle
+# convection simulation.
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 1600
+set Maximum time step                      = 1e6
+set Output directory                       = output-global_melt
+set Use years in output instead of seconds = true
+
+# For models with melt migration, there is a nonlinear coupling between
+# the Stokes system, the temperature, and the advection equation for the
+# porosity (several material properties, such as the viscosities and the
+# permeability depend nonlinearly on the porosity; and changes in temperature
+# determine how much material is melting or freezing).
+# Because of that, we use a nonlinear solver scheme ('iterated Advection and Stokes')
+# that iterates between all of these equations, and we have to set its
+# solver tolerance and the maximum number of iterations separately from
+# the linear solver parameters.
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 20
+set Nonlinear solver tolerance             = 1e-5
+
+# In addition, melting and freezing normally happens on a much faster
+# time scale than the flow of melt, so we want to decouple the advection
+# of melt (and temperature) and the melting process itself. To do that,
+# we use the operator splitting scheme, and define that for every
+# advection time step, we want to do at least 10 reaction time steps.
+# If these time steps would be larger than 10,000 years, we will do
+# more reaction time steps (so that reaction time step size never exceeds
+# 10,000 years). Here, we also specify the Stokes linear solver tolerance
+# and maximum number of cheap Stokes solver steps to improve the nonlinear
+# convergence behavior.
+set Use operator splitting                     = true
+
+# The end time of the simulation. Because we want to see how upwellings
+# and downwellings evolve over time, and if differences develop between
+# the model with and without melt migration, we set the end time to 200 Ma.
+set End time                               = 2e8
+
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction time step                     = 1e4
+    set Reaction time steps per advection step = 10
+  end
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 100
+  end
+end
+
+# We prescribe free-slip boundary conditions on all sides.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Melt settings
+  # In addition, we now also specify in the model settings that we want to
+  # run a model with melt transport.
+  set Include melt transport                  = true
+end
+
+##################### Settings for melt transport ########################
+
+# In models with melt transport, we always need a compositional field with
+# the name 'porosity'. Only the field with that name will be advected with
+# the melt velocity, all other compositional fields will continue to work
+# as before. Material models will typically query for the field with the
+# name porosity to compute all melt material properties.
+# In addition, the 'melt global' material model also requires a field with the
+# name 'peridotite'. This field is used to track how much material has been
+# molten at each point of the model, so it tracks the information how the
+# composition of the rock changes due to partial melting events (sometimes
+# also called depletion). This is important, because usually less melt is
+# generated for a given temperature and pressure if the rock has undergone
+# melting before. Typically, material properties like the density are also
+# different for more or less depleted material.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Discretization
+  # We also choose relatively large values for the stabilization parameters:
+  # The model resolution is very coarse (in order for this model to run in a
+  # short time), so we want to make sure that no temperature over- and
+  # undershoots will develop. In a model with melting this would be
+  # particularly problematic, as large amounts of melt could be generated
+  # by temperature spikes.
+  # However, note that in an application model with a higher resolution,
+  # we would choose much smaller values for the stabilization parameters.
+  subsection Stabilization parameters
+    set beta  = 0.5
+    set cR    = 1
+  end
+end
+
+##################### Initial conditions ########################
+
+# We choose an adiabatic temperature profile as initial condition,
+# with conductive temperature profiles in the top and bottom boundary
+# layers, which were computed using a half space cooling model.
+# The cold top boundary layer corresponds to an age of 70 Ma,
+# and the hot top boundary layer corresponds to an age of 700 Ma.
+# A small temperature perturbation is added at the bottom of the
+# domain. To make the model asymmetric, we place it in a distance of
+# x = 2900 km from the left boundary.
+# Temperatures from both initial temperature models we specify are
+# added (by default).
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 7e8
+    set Age top boundary layer    = 7e7
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+
+  subsection Function
+    set Function constants        = r=350000, amplitude=50
+    set Function expression       = if((x-2900000)*(x-2900000)+y*y<r,amplitude,0)
+  end
+end
+
+# Now that our model uses compositional fields, we also need initial
+# conditions for the composition.
+# We use the function plugin to set both fields to zero at the beginning
+# of the model run.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0; 0
+    set Variable names      = x,y
+  end
+end
+
+##################### Boundary conditions ########################
+
+# As boundary conditions for the temperature, we just use the
+# initial conditions again. This temperature is applied as a prescribed
+# temperature at the top and bottom boundary, as specified above.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3900
+  end
+end
+
+# We again choose the initial composition as boundary condition
+# for all compositional fields.
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Models with melt transport also need an additional boundary condition:
+# the gradient of the fluid pressure at the model boundaries. This boundary
+# condition indirectly also prescribes boundary conditions for the melt velocity,
+# as the melt velocity is related to the fluid pressure gradient via Darcy's law.
+# If we choose the fluid pressure gradient = solid density * gravity, melt will
+# flow in and out of the model (even if the solid can not flow out) according to
+# the dynamic fluid pressure in the model. Conversely, if we choose the
+# fluid pressure gradient = fluid density * gravity, melt will flow in or out
+# with the same velocity as the solid (so for a closed boundary, no melt will
+# flow in or out). This is what we choose as our boundary condition here.
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+##################### Model geometry ########################
+
+# The model geometry is a box with an aspect ratio of 3,
+# extending to the base of the mantle in vertical direction.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 8700000
+    set Y extent = 2900000
+    set X repetitions = 3
+  end
+end
+
+################ Gravity and material properties ##################
+
+# The model has a constant gravity.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We use the melt global material model, which is one of the
+# material models that works with melt transport, as it also
+# specifies the material properties needed for melt migration,
+# such as the permeability, the melt density and the melt
+# viscosity.
+# In addition to the material properties for the solid rock,
+# we also have to specify properties for the melt.
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    # First we describe the parameters for the solid, in the same way
+    # we did in the model without melt transport
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Thermal expansion coefficient     = 2e-5
+    set Reference shear viscosity         = 5e21
+    set Thermal viscosity exponent        = 7
+    set Reference temperature             = 1600
+    set Solid compressibility             = 4.2e-12
+
+    # The melt usually has a different (lower) density than the solid.
+    set Reference melt density            = 3000
+
+    # The permeability describes how well the pores of a porous material
+    # are connected (and hence how fast melt can flow through the rock).
+    # It is computed as the product of the reference value given here
+    # and the porosity cubed. This means that the lower the porosity is
+    # the more difficult it is for the melt to flow.
+    set Reference permeability            = 1e-8
+
+    # The bulk viscosity describes the resistance of the rock to dilation
+    # and compaction. Melt can only flow into a region that had no melt
+    # before if the matrix of the solid rock expands, so this parameter
+    # also limits how fast melt can flow upwards.
+    # The bulk viscosity is computed as the reference value given here times
+    # a term that scales with one over the porosity. This means that for zero
+    # porosity, the rock can not dilate/compact any more, which is the same
+    # behavior that we have for solid mantle convection.
+    set Reference bulk viscosity          = 1e19
+
+    # In dependence of how much melt is present, we also weaken the shear
+    # viscosity: The more melt is present, the weaker the rock gets.
+    # This scaling is exponential, following the relation
+    # viscosity ~ exp(-alpha * phi),
+    # where alpha is the parameter given here, and phi is the porosity.
+    set Exponential melt weakening factor = 10
+
+    # In the same way the shear viscosity is reduced with increasing temperature,
+    # we also prescribe the temperature-dependence of the bulk viscosity.
+    set Thermal bulk viscosity exponent   = 7
+
+    # Analogous to the compressibility of the solid rock, we also define a
+    # comressibility for the melt (which is generally higher than for the solid).
+    # As we do not want our compressibility to depend on depth, we set the
+    # pressure derivative to zero.
+    set Melt compressibility              = 1.25e-11
+    set Melt bulk modulus derivative      = 0.0
+
+    # Finally, we prescribe the viscosity of the melt, which is used in Darcy's
+    # law. The lower this viscosity, the faster melt can flow.
+    set Reference melt viscosity          = 1
+
+    # change the density contrast of depleted material (in kg/m^3)
+    set Depletion density change          = -200.0
+
+    # How much melt has been generated and subsequently extracted from a particular
+    # volume of rock (how 'depleted' that volume of rock is) usually changes the
+    # solidus. The more the material has been molten already, the less melt will be
+    # generated afterwards for the same pressure and temperature conditions. We
+    # model this using a simplified, linear relationship, saying that to melt 100%
+    # of the rock the temperature has to be 200 K higher than to melt it initially.
+    set Depletion solidus change          = 200
+
+    # We also have to determine how fast melting and freezing should happen.
+    # Here, we choose a time scale of 10,000 years, which is a relatively long time
+    # (or in other words, slow melting rate), but because this is a global model
+    # and the time steps are big, it should be sufficient.
+    set Melting time scale for operator splitting = 1e4
+  end
+end
+
+##################### Mesh refinement #########################
+
+# For the model with melt migration, we use adaptive refinement.
+# We make use of two different refinement criteria: we set a minimum of 5 global
+# refinements everywhere in the model (which is the same resolution as for the
+# model without melt), and we refine in regions where melt is present, to be
+# precise, everywhere where the porosity is bigger than 1e-6.
+# We adapt the mesh every 5 time steps.
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 2
+  set Initial global refinement                = 5
+  set Strategy                                 = composition threshold, minimum refinement function, boundary
+  set Time steps between mesh refinement       = 5
+
+  # minimum of 5 global refinements
+  subsection Minimum refinement function
+    set Function expression = 5
+  end
+
+  # refine where the porosity is bigger than 1e-6
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-6,1.0
+  end
+
+  # refine at top and bottom boundary
+  subsection Boundary
+    set Boundary refinement indicators = top, bottom
+  end
+end
+
+# As the model is compressible and has an adiabatic temperature profile, we include
+# adiabatic heating in the list of heating models.
+# To make this model as simple as possible, we do not include shear heating (although
+# usually, adiabatic heating and shear heating should always be used together).
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+##################### Postprocessing ########################
+
+# In addition to the visualization output, we select a number
+# of postprocessors that allow us to compute some statistics
+# about the output (to see how much the model without and the
+# model with melt migration differ), and in particular we use
+# the "depth average" postprocessor that will allow us to plot
+# depth-averaged model quantities over time.
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, depth average
+
+  # For the model with melt migration, also add a visualization
+  # postprocessor that computes the material properties relevant
+  # to migration (permeability, viscosity of the melt, etc.).
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 6e5
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+
+  subsection Depth average
+    set Number of zones = 12
+    set Time between graphical output = 6e5
+  end
+end
+
+# We write a checkpoint approximately every half an hour,
+# so that we are able to restart the computation from that
+# point.
+subsection Checkpointing
+  set Time between checkpoint = 1700
+end
diff --git a/cookbooks/global_melt/global_no_melt.prm.bak b/cookbooks/global_melt/global_no_melt.prm.bak
new file mode 100644
index 00000000000..c6c5eaad18b
--- /dev/null
+++ b/cookbooks/global_melt/global_no_melt.prm.bak
@@ -0,0 +1,211 @@
+# Model setup for mantle convection in a 2D box without melting.
+# This file is used as a starting point for a cookbook that
+# explains how to add melting and melt transport to a mantle
+# convection simulation.
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 1600
+set Maximum time step                      = 1e6
+set Output directory                       = output-global_no_melt
+set Use years in output instead of seconds = true
+
+# The end time of the simulation. Because we want to see how upwellings
+# and downwellings evolve over time, and if differences develop between
+# the model with and without melt migration, we set the end time to 200 Ma.
+set End time                               = 2e8
+
+# We choose a stricter than default linear Stokes solver tolerance,
+# to be consistent with the global_melt cookbook.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 100
+  end
+end
+
+# We prescribe free-slip boundary conditions on all
+# sides.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+# We also choose relatively large values for the stabilization parameters:
+# The model resolution is very coarse (in order for this model to run in a
+# short time), so we want to make sure that no temperature over- and
+# undershoots will develop. In a model with melting this would be
+# particularly problematic, as large amounts of melt could be generated
+# by temperature spikes, and we want to be consistent between the model
+# with and without melt transport.
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.5
+    set cR    = 1
+  end
+end
+
+##################### Initial conditions ########################
+
+# We choose an adiabatic temperature profile as initial condition,
+# with conductive temperature profiles in the top and bottom boundary
+# layers, which were computed using a half space cooling model.
+# The cold top boundary layer corresponds to an age of 70 Ma,
+# and the hot top boundary layer corresponds to an age of 700 Ma.
+# A small temperature perturbation is added at the bottom of the
+# domain. To make the model asymmetric, we place it in a distance of
+# x = 2900 km from the left boundary.
+# Temperatures from both initial temperature models we specify are
+# added (by default).
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 7e8
+    set Age top boundary layer    = 7e7
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+
+  subsection Function
+    set Function constants        = r=350000, amplitude=50
+    set Function expression       = if((x-2900000)*(x-2900000)+y*y<r,amplitude,0)
+  end
+end
+
+##################### Boundary conditions ########################
+
+# As boundary conditions for the temperature, we just use the
+# initial conditions again. This temperature is applied as a prescribed
+# temperature at the top and bottom boundary.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3900
+  end
+end
+
+##################### Model geometry ########################
+
+# The model geometry is a box with an aspect ratio of 3,
+# extending to the base of the mantle in vertical direction.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 8700000
+    set Y extent = 2900000
+    set X repetitions = 3
+  end
+end
+
+################ Gravity and material properties ##################
+
+# The model has a constant gravity.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We use the melt global material model, which is one of the
+# material models that works with melt transport, as it also
+# specifies the material properties needed for melt migration,
+# such as the permeability, the melt density and the melt
+# viscosity.
+# It also works without melt transport, and in this case these
+# properties are not used, so we do not have to specify them
+# here.
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Thermal expansion coefficient     = 2e-5
+    set Reference shear viscosity         = 5e21
+    set Thermal viscosity exponent        = 7
+    set Reference temperature             = 1600
+    set Solid compressibility             = 4.2e-12
+  end
+end
+
+##################### Mesh refinement #########################
+
+# For the model without melt migration, we do not have to use
+# mesh adaptivity, because time- and length scales of material
+# motion does do not vary a lot across the model, and a global
+# resolution of 5 is sufficient to capture the behavior of
+# upwellings and downwellings. We nevertheless want to refine
+# the mesh near the top and bottom boundaries where large
+# thermal gradients occur.
+subsection Mesh refinement
+  set Initial adaptive refinement              = 2
+  set Initial global refinement                = 5
+  set Strategy                                 = minimum refinement function, boundary
+  set Time steps between mesh refinement       = 0
+
+  # minimum of 5 global refinements
+  subsection Minimum refinement function
+    set Function expression = 5
+  end
+
+  # refine at top and bottom boundary
+  subsection Boundary
+    set Boundary refinement indicators = top, bottom
+  end
+end
+
+# As the model is compressible and has an adiabatic temperature profile, we include
+# adiabatic heating in the list of heating models.
+# To make this model as simple as possible, we do not include shear heating (although
+# usually, adiabatic heating and shear heating should always be used together).
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+##################### Postprocessing ########################
+
+# In addition to the visualization output, we select a number
+# of postprocessors that allow us to compute some statistics
+# about the output (to see how much the model without and the
+# model with melt migration differ), and in particular we use
+# the "depth average" postprocessor that will allow us to plot
+# depth-averaged model quantities over time.
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, melt statistics, depth average
+
+  # For the model without melt migration, we only compute the
+  # equilibrium melt fraction in dependence of temperature and
+  # pressure. This is done as a postprocessing step, by adding
+  # "melt fraction" to the list of material properties in the
+  # corresponding visualization postprocessor.
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 6e5
+
+    subsection Material properties
+      set List of material properties = density, viscosity, melt fraction
+    end
+  end
+
+  subsection Depth average
+    set Number of zones = 12
+    set Time between graphical output = 6e5
+  end
+end
+
+# We write a checkpoint approximately every half an hour,
+# so that we are able to restart the computation from that
+# point.
+subsection Checkpointing
+  set Time between checkpoint = 1700
+end
diff --git a/cookbooks/gplates/doc/gplates.part.prm.bak b/cookbooks/gplates/doc/gplates.part.prm.bak
new file mode 100644
index 00000000000..4f3d01aa47b
--- /dev/null
+++ b/cookbooks/gplates/doc/gplates.part.prm.bak
@@ -0,0 +1,17 @@
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:gplates
+  set Tangential velocity boundary indicators = bottom
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+    set Lithosphere thickness = 660000
+  end
+end
diff --git a/cookbooks/gplates/doc/slice1.part.prm.bak b/cookbooks/gplates/doc/slice1.part.prm.bak
new file mode 100644
index 00000000000..e6bacc4fdf1
--- /dev/null
+++ b/cookbooks/gplates/doc/slice1.part.prm.bak
@@ -0,0 +1,2 @@
+set Point one = 3.1416,0.0
+set Point two = 1.5708,0.0
diff --git a/cookbooks/gplates/doc/slice2.part.prm.bak b/cookbooks/gplates/doc/slice2.part.prm.bak
new file mode 100644
index 00000000000..9c267db6583
--- /dev/null
+++ b/cookbooks/gplates/doc/slice2.part.prm.bak
@@ -0,0 +1,2 @@
+set Point one = 3.1416,1.5708
+set Point two = 1.5708,1.5708
diff --git a/cookbooks/gplates/gplates_2d.prm.bak b/cookbooks/gplates/gplates_2d.prm.bak
new file mode 100644
index 00000000000..e74c9637741
--- /dev/null
+++ b/cookbooks/gplates/gplates_2d.prm.bak
@@ -0,0 +1,88 @@
+# A simple setup for for using the GPlates interface in a 2d shell. See the
+# manual for more information.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 3e8
+set Output directory                       = output-gplates-2d
+set Adiabatic surface temperature          = 1600
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e22
+    set Thermal viscosity exponent    = 5.0
+    set Reference temperature         = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:gplates
+  set Tangential velocity boundary indicators = bottom
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+    set Lithosphere thickness = 660000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/cookbooks/gplates/gplates_3d.prm.bak b/cookbooks/gplates/gplates_3d.prm.bak
new file mode 100644
index 00000000000..8616ed8d640
--- /dev/null
+++ b/cookbooks/gplates/gplates_3d.prm.bak
@@ -0,0 +1,88 @@
+# A simple setup for for using the GPlates interface in a 3d shell.
+# This model has more than 1 million unknowns, so you will most likely want to
+# compile aspect in release mode, and run this model on a powerful machine.
+# See the manual for more information.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 3e8
+set Output directory                       = output-gplates-3d
+set Adiabatic surface temperature          = 1600
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e22
+    set Thermal viscosity exponent    = 5.0
+    set Reference temperature         = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:gplates
+  set Tangential velocity boundary indicators = bottom
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Lithosphere thickness = 660000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/cookbooks/grain_size_ridge/doc/fields.part.prm.bak b/cookbooks/grain_size_ridge/doc/fields.part.prm.bak
new file mode 100644
index 00000000000..bd288470d8a
--- /dev/null
+++ b/cookbooks/grain_size_ridge/doc/fields.part.prm.bak
@@ -0,0 +1,11 @@
+# Our only compositional field is the grain size, and we use particles
+# to track it. In order for the grain size to not just be tracked, but
+# to evolve over time depending on the temperature and deformation in
+# the model, we select ``grain_size'' as the mapped particle property
+# for the grain_size compositional field.
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = grain_size
+  set Compositional field methods = particles
+  set Mapped particle properties = grain_size:grain_size
+end
diff --git a/cookbooks/grain_size_ridge/doc/material_model.part.prm.bak b/cookbooks/grain_size_ridge/doc/material_model.part.prm.bak
new file mode 100644
index 00000000000..11e48c186b3
--- /dev/null
+++ b/cookbooks/grain_size_ridge/doc/material_model.part.prm.bak
@@ -0,0 +1,48 @@
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    # Diffusion creep has a prefactor, a temperature dependence defined by the
+    # activation energy, a pressure dependence defined by the activation volume
+    # and a grain size dependence. We take the activation energy from Hirth &
+    # Kohlstedt, 2003, and pick the prefactor and activation volume so that we
+    # get a reasonable upper mantle viscosity profile and a balance between
+    # diffusion and dislocation creep.
+    set Diffusion creep prefactor                   = 5e-15
+    set Diffusion activation energy                 = 3.75e5
+    set Diffusion activation volume                 = 4e-6
+    set Diffusion creep grain size exponent         = 3
+
+    # Dislocation creep has a prefactor, a temperature dependence defined by the
+    # activation energy, a pressure dependence defined by the activation volume
+    # and a strain-rate dependence defined by the exponent. We take the activation
+    # energy and volume from Hirth & Kohlstedt, 2003, and pick the prefactor so
+    # that we get a reasonable upper mantle viscosity and a balance between
+    # diffusion and dislocation creep.
+    set Dislocation creep prefactor                 = 1e-15
+    set Dislocation activation energy               = 5.3e5
+    set Dislocation activation volume               = 1.4e-5
+    set Dislocation creep exponent                  = 3.5
+    set Dislocation viscosity iteration number      = 10000
+
+    # Grain size is reduced when work is being done by dislocation creep.
+    # Here, 10% of this work goes into reducing the grain size rather than
+    # into shear heating.
+    # Grain size increases with a rate controlled by the grain growth
+    # constant and a temperature-depndence defined by the activation
+    # energy. By setting the activation volume to zero, we disable the
+    # pressure-dependence of grain growth.
+    # The parameter values are taken from Dannberg et al., 2017, G-cubed,
+    # with the parameters being based on Faul and Jackson, 2007.
+    set Work fraction for boundary area change      = 0.1
+    set Grain growth rate constant                  = 1.92e-10
+    set Grain growth activation energy              = 4e5
+    set Grain growth activation volume              = 0
+
+    # Viscosity is cut off at a minimum value of 10^16 Pa s
+    # and a maximum value of 10^23 Pa s.
+    set Maximum viscosity                           = 1e23
+    set Minimum viscosity                           = 1e16
+    set Maximum temperature dependence of viscosity = 1e8
+  end
+end
diff --git a/cookbooks/grain_size_ridge/doc/particles.part.prm.bak b/cookbooks/grain_size_ridge/doc/particles.part.prm.bak
new file mode 100644
index 00000000000..a4c606fe089
--- /dev/null
+++ b/cookbooks/grain_size_ridge/doc/particles.part.prm.bak
@@ -0,0 +1,30 @@
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics, mass flux statistics, particles
+
+  subsection Particles
+    set Time between data output = 1e6
+  end
+end
+
+# We use particles to advect the grain size.
+subsection Particles
+  set Interpolation scheme = bilinear least squares
+  set List of particle properties = grain size
+  set Load balancing strategy = remove and add particles
+  set Minimum particles per cell = 40
+  set Maximum particles per cell = 640
+  set Integration scheme = rk2
+  set Update ghost particles = true
+
+  subsection Interpolator
+    subsection Bilinear least squares
+      set Use linear least squares limiter = true
+    end
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 500000
+    end
+  end
+end
diff --git a/cookbooks/grain_size_ridge/grain_size_ridge.prm.bak b/cookbooks/grain_size_ridge/grain_size_ridge.prm.bak
new file mode 100644
index 00000000000..5e483ec0382
--- /dev/null
+++ b/cookbooks/grain_size_ridge/grain_size_ridge.prm.bak
@@ -0,0 +1,310 @@
+# This is a model of an oceanic plate moving away from a mid-ocean ridge.
+# The rheology is grain-size dependent and the grain size evolves over
+# time, being tracked on particles. Eventually, small-scale convection
+# develops at the base of the lithosphere as it increases in age.
+
+# We want to run the model for 200 Myrs.
+set End time                               = 2e8
+set Output directory                       = grain-size-ridge
+set Dimension                              = 2
+
+# We set the average pressure at the surface to 0.
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1623
+
+# Because the problem is strongly nonlinear (the viscosity depends on
+# temperature, grain size, pressure and velocity), we use a solver scheme
+# that iterates over all equations being solved. We use a large number
+# of maximum nonlinear iterations to make sure that this nonlinear solver
+# converges every time step (although the model generally only needs 2-3
+# nonlinear iterations).
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 50
+
+# Because the grain size may be far from equilibrium in the first time
+# step, we choose a short time step in the beginning to make sure the
+# nonlinear solver converges. We then allow the time step size to
+# gradually increase by 10% in each step.
+set CFL number                             = 1
+set Maximum first time step                = 500
+set Maximum relative increase in time step = 10
+
+# We use the geometric multigrid solver, but because this is a difficult
+# linear problem to solve with a large viscosity contrast, we increase the
+# number of cheap iterations and the restart length to make sure it
+# converges.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set GMRES solver restart length = 200
+    set Number of cheap Stokes solver steps = 5000
+    set Stokes solver type = block GMG
+  end
+end
+
+# The model is a box with a width of 4000 km and a depth of 410 km.
+# The number of X and Y repetitions determine the shape of the coarsest
+# mesh cells (that will then be refined adaptively) relative to the
+# shape of the box. To achieve an aspect ratio of approximately one
+# for the cells, we choose more X than Y repetitions.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 4000000
+    set Y extent  = 410000
+    set X repetitions = 10
+    set Y repetitions = 1
+  end
+end
+
+# Since we model an oceanic plate moving away from the ridge axis (which
+# is in the top left corner of the model), we prescribed the plate velocity
+# of 5 cm/yr at the surface. At the bottom, we prescribed zero horizontal
+# flow, representing the mantle below. On the right boundary, we prescribe
+# the flow in horizontal direction, gradually changing it from the plate
+# velocity in the uppermost 100 km to a zero velocity at the base of the
+# model. The left boundary (ridge axis) is closed and a free slip boundary.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left
+  set Prescribed velocity boundary indicators = top: function, bottom x:function, right x:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y>310000,0.05,0.05*y/310000); 0
+  end
+end
+
+# We prescribe a boundary traction in vertical direction at the bottom and
+# and right boundaries, setting it to the lithostatic pressure to allow
+# for free in- and outflow of material.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right y:initial lithostatic pressure, bottom y:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Number of integration points = 1000
+    set Representative point         = 2000000,0
+  end
+end
+
+# The initial temperature follows an adiabatic profile with a cold
+# boundary layer added at the surface. Since we model a plate moving away
+# from a ridge with 5 cm/yr, we pick an according age for this boundary
+# layer (increasing from the ridge on the left towards the right as the
+# plate gets older.
+# We additionally add a small temperature perturbation near the ridge
+# to reduce the viscosity below the ridge axis where strong deformation
+# occurs due to our boundary conditions (material has to flow upwards
+# beneath the ridge axis and horizontally towards the right at the
+# surface).
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    set Age bottom boundary layer   = 0.0
+    set Top boundary layer age model = function
+
+    subsection Age function
+      set Function expression = 0.01 + x / 0.05
+    end
+  end
+
+  subsection Function
+    set Function constants  = DeltaT = 300, b = 0, width = 10000, c=410000
+    set Function expression = DeltaT * exp(-((x-b)*(x-b)+(y-c)*(y-c))/(2*width*width))
+    set Variable names      = x,y
+  end
+end
+
+# The temperature at the boundary is taken from the initial conditions.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom, right
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 1623
+  end
+end
+
+# Our only compositional field is the grain size, and we use particles
+# to track it. In order for the grain size to not just be tracked, but
+# to evolve over time depending on the temperature and deformation in
+# the model, we select ``grain_size'' as the mapped particle property
+# for the grain_size compositional field.
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = grain_size
+  set Compositional field methods = particles
+  set Mapped particle properties = grain_size:grain_size
+end
+
+# We set the initial grain size to 5 mm, with a reduction at the ridge
+# axis, again to allow for easy deformation there.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = DeltaC = -29e-4, b = 0, width = 30000, c=397000
+    set Function expression = 5e-3 + DeltaC * exp(-((x-b)*(x-b)+(y-c)*(y-c))/(2*width*width))
+    set Variable names      = x,y
+  end
+end
+
+# The composition at the boundary is taken from the initial conditions.
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = bottom, right
+  set List of model names = initial composition
+end
+
+# We use the grain size material model, which implements the equations
+# for grain size evolution.
+subsection Material model
+  # Because we use the GMG solver, we need to average the viscosity.
+  set Material averaging = project to Q1 only viscosity
+  set Model name = grain size
+
+  subsection Grain size model
+    # We use typical upper-mantle material properties.
+    set Reference density                         = 3300
+    set Reference specific heat                   = 1200
+    set Thermal expansion coefficient             = 3.3e-5
+
+    # Diffusion creep has a prefactor, a temperature dependence defined by the
+    # activation energy, a pressure dependence defined by the activation volume
+    # and a grain size dependence. We take the activation energy from Hirth &
+    # Kohlstedt, 2003, and pick the prefactor and activation volume so that we
+    # get a reasonable upper mantle viscosity profile and a balance between
+    # diffusion and dislocation creep.
+    set Diffusion creep prefactor                   = 5e-15
+    set Diffusion activation energy                 = 3.75e5
+    set Diffusion activation volume                 = 4e-6
+    set Diffusion creep grain size exponent         = 3
+
+    # Dislocation creep has a prefactor, a temperature dependence defined by the
+    # activation energy, a pressure dependence defined by the activation volume
+    # and a strain-rate dependence defined by the exponent. We take the activation
+    # energy and volume from Hirth & Kohlstedt, 2003, and pick the prefactor so
+    # that we get a reasonable upper mantle viscosity and a balance between
+    # diffusion and dislocation creep.
+    set Dislocation creep prefactor                 = 1e-15
+    set Dislocation activation energy               = 5.3e5
+    set Dislocation activation volume               = 1.4e-5
+    set Dislocation creep exponent                  = 3.5
+    set Dislocation viscosity iteration number      = 10000
+
+    # Grain size is reduced when work is being done by dislocation creep.
+    # Here, 10% of this work goes into reducing the grain size rather than
+    # into shear heating.
+    # Grain size increases with a rate controlled by the grain growth
+    # constant and a temperature-depndence defined by the activation
+    # energy. By setting the activation volume to zero, we disable the
+    # pressure-dependence of grain growth.
+    # The parameter values are taken from Dannberg et al., 2017, G-cubed,
+    # with the parameters being based on Faul and Jackson, 2007.
+    set Work fraction for boundary area change      = 0.1
+    set Grain growth rate constant                  = 1.92e-10
+    set Grain growth activation energy              = 4e5
+    set Grain growth activation volume              = 0
+
+    # Viscosity is cut off at a minimum value of 10^16 Pa s
+    # and a maximum value of 10^23 Pa s.
+    set Maximum viscosity                           = 1e23
+    set Minimum viscosity                           = 1e16
+    set Maximum temperature dependence of viscosity = 1e8
+  end
+end
+
+# The gravity points downward and is set to 10.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# We need a high resolution in locations where strong gradients
+# in grain size/viscosity occur, which is within the cold plate.
+# We therefore refine the mesh for low nonadiabatic temperatures.
+subsection Mesh refinement
+  set Time steps between mesh refinement = 5
+  set Initial global refinement = 5
+  set Initial adaptive refinement = 1
+  set Strategy = nonadiabatic temperature threshold
+  set Skip solvers on initial refinement = true
+  set Minimum refinement level = 5
+
+  subsection Nonadiabatic temperature threshold
+    set Temperature anomaly type = negative only
+    set Threshold = 25
+  end
+end
+
+# The model includes shear (dissipation) heating and adiabatic heating.
+subsection Heating model
+  set List of model names = shear heating, adiabatic heating
+end
+
+# We use a discontinuous discretization to interpolate from the particles
+# to the mesh because the bilinear least squares interpolator can lead to
+# jumps of the composition at cell boundaries.
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+# Below, we describe the variables we want to include in the graphical output.
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics, mass flux statistics, particles
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate, melt fraction, named additional outputs
+    set Point-wise stress and strain  = true
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity
+    end
+  end
+
+  subsection Particles
+    set Time between data output = 1e6
+  end
+end
+
+# Every 10 minutes (600 seconds) we write a restart file that could be used to
+# restart a simulation.
+subsection Checkpointing
+  set Time between checkpoint = 600
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+end
+
+# We use particles to advect the grain size.
+subsection Particles
+  set Interpolation scheme = bilinear least squares
+  set List of particle properties = grain size
+  set Load balancing strategy = remove and add particles
+  set Minimum particles per cell = 40
+  set Maximum particles per cell = 640
+  set Integration scheme = rk2
+  set Update ghost particles = true
+
+  subsection Interpolator
+    subsection Bilinear least squares
+      set Use linear least squares limiter = true
+    end
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 500000
+    end
+  end
+end
diff --git a/cookbooks/heat_flow/heat-flow-plume.prm.bak b/cookbooks/heat_flow/heat-flow-plume.prm.bak
new file mode 100644
index 00000000000..3da16ffb5ea
--- /dev/null
+++ b/cookbooks/heat_flow/heat-flow-plume.prm.bak
@@ -0,0 +1,154 @@
+# A model of a plume arriving at the base of a plate.
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1e7
+set Use years in output instead of seconds = true
+set Output directory                       = output-heat-flow-plume
+set Adiabatic surface temperature          = 1600
+set Maximum time step                      = 1e6
+
+############### Parameters describing the model
+# Let us choose a box domain (400 km wide and 200 km in depth)
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 400000
+    set Y extent = 200000
+    set X repetitions = 2
+  end
+end
+
+# In order to allow plume material to flow in with the
+# temperature selected in the initial temperature section,
+# we apply the initial temperature as the boundary temperature.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Maximal temperature = 1600
+    set Minimal temperature = 293
+  end
+end
+
+# In this model we want material to be able to (1) flow in freely
+# through the base, (2) flow freely in the horizontal direction
+# through the left and right walls where the vertical velocity is 0,
+# and (3) have a velocity of zero at the top boundary. This is
+# achieved through a combination of velocity and pressure boundary
+# conditions, where only the vertical (y) component of the velocity
+# is set to 0 on the left and right walls, while the x and y velocity
+# are both set to zero on the top boundary.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left y: function, right y:function, top:function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 0;0
+  end
+end
+
+# We allow inflow and outflow at the model base by setting the traction
+# boundary condition to the initial lithostatic pressure. On the left
+# and right boundaries, the x component of the  boundary traction is
+# also set to the initial lithostatic pressure, which enables horizontal
+# inflow and outflow.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = bottom:initial lithostatic pressure,right x:initial lithostatic pressure, left x:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Representative point = 0,0
+    set Number of integration points = 1000
+  end
+end
+
+# We then choose a vertical gravity model.
+subsection Gravity model
+  set Model name = vertical
+end
+
+# The initial temperature is set to the value of the
+# Adiabatic surface temperature, in this case 1600 K,
+# but with a cold boundary layer at the surface and a
+# hot thermal anomaly at the base of the model
+# representing a plume. The age of the cold top
+# boundary layer determines its thickness.
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    # This is the age of the top boundary layer in years.
+    set Age top boundary layer = 1
+  end
+
+  # The constant DeltaT determines the amplitude of the temperature anomaly,
+  # which is a 2d Gaussian located at the center of the bottom boundary.
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = DeltaT=0
+    set Function expression = DeltaT * exp(-((z*z)+(x-200000)*(x-200000))/(5e8))
+  end
+end
+
+# This model uses the composition reaction material model,
+# where most material properties are constant, except for the
+# viscosity and the density, which depend on temperature as
+# expressed by the Thermal viscosity exponent and the
+# Thermal expansion coefficient. At the Reference temperature,
+# the viscosity equals the value set with the Viscosity
+# parameter.
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 2e19
+    set Thermal viscosity exponent    = 10.0
+    set Reference temperature         = 1600
+  end
+end
+
+# This part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed.
+# Here, the mesh is designed to be finer at the surface than at
+# the bottom of the model to better capture the conductive cooling
+# of the plates. It initially undergoes two global refinements and
+# four adaptive refinements in the first time step, but is not
+# refined further (i.e., it remains static) throughout the model
+# run. The adaptive refinements use the minimum refinement function
+# to increase the resolution towards the model surface in a
+# piece-wise fashion at depths of 7 and 30 kilometers.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 4
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Variable names = depth, z
+    set Function expression = if(depth<7000,6,if(depth<30000,5,4))
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, heat flux densities
+
+  subsection Visualization
+    set Time between graphical output = 1e5
+    set List of output variables = material properties, heat flux map, vertical heat flux
+
+    subsection Material properties
+      set List of material properties = density, thermal expansivity, specific heat, viscosity, thermal conductivity
+    end
+  end
+end
diff --git a/cookbooks/heat_flow/heat-flow-terms.prm.bak b/cookbooks/heat_flow/heat-flow-terms.prm.bak
new file mode 100644
index 00000000000..68173b55a29
--- /dev/null
+++ b/cookbooks/heat_flow/heat-flow-terms.prm.bak
@@ -0,0 +1,40 @@
+include $ASPECT_SOURCE_DIR/cookbooks/heat_flow/heat-flow.prm
+
+
+# This is a copy of the heat-flow cookbook, modified to include
+# radiogenic heat production and shear heating, and to output
+# the different heating terms in a visualization postprocessor.
+
+set Output directory                       = output-heat-flow-terms
+
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 1e-4
+
+    # Changig the viscosity changes the shear heating.
+    set Viscosity                     = 3e21
+  end
+end
+
+# This is a new section specifying the heating terms
+subsection Heating model
+  set List of model names = function, shear heating
+
+  # Radiogenic heat production. Changing the variable
+  # Hcrust in the equation below changes the heat
+  # production rate in the crust.
+  subsection Function
+    set Variable names = x,y,t
+    set Function expression = if(y>93000, Hcrust, Hmantle)
+    set Function constants = Hcrust=2e-8, Hmantle=7.38e-12
+  end
+end
+
+subsection Postprocess
+  subsection Visualization
+    set List of output variables = density, heat flux map, vertical heat flux, heating, viscosity
+  end
+end
diff --git a/cookbooks/heat_flow/heat-flow.prm.bak b/cookbooks/heat_flow/heat-flow.prm.bak
new file mode 100644
index 00000000000..1f7cb70d9cc
--- /dev/null
+++ b/cookbooks/heat_flow/heat-flow.prm.bak
@@ -0,0 +1,143 @@
+# A model of spreading at a mid-ocean ridge.
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 5e6
+set Use years in output instead of seconds = true
+set Output directory                       = output-heat-flow
+
+############### Parameters describing the model
+# Let us choose a box domain (400 km wide and 100 km in depth)
+# where we fix the temperature at the bottom and top,
+# allow inflow from the bottom and outflow on the left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 400000
+    set Y extent = 100000
+    set X repetitions = 4
+    set Box origin X coordinate = -200000
+  end
+end
+
+# We fix the temperature at the top, representing the Earth's
+# surface, and at the bottom, where material flows in and we
+# need to prescribe what temperature this material should
+# have (in this case, 1600 K).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1600
+    set Top temperature    = 293
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center of a mid-ocean ridge. The horizontal component of
+# the velocity is presribed on both side boundaries to
+# cause flow away from the spreading center, while the
+# vertical component of the velocity is allowed to evolve
+# freely based on the pressure in the model. The bottom
+# boundary is left open so that material can flow in.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x:function, right x:function, top: function
+
+  subsection Function
+    set Variable names      = x,z
+
+    # We can choose a (half-)spreading rate by changing the value of v (in cm/year)
+    # This value should be somewhere between 1 and 10 (cm/yr).
+    set Function constants  = v=5, cm_per_year=0.01
+    set Function expression = if(x>0, v * cm_per_year, -v * cm_per_year); 0
+  end
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = left y:initial lithostatic pressure, right y:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Representative point = 0,0
+    set Number of integration points = 1000
+  end
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature as a constant (being equivalent to a
+# plate age of 0).
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# The initial temperature is set to a constant value that
+# corresponds to the temperature of the sublithospheric
+# mantle throughout the model, but subsequently cools
+# over time.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1600
+  end
+end
+
+# This model uses the composition reaction material model,
+# where most material properties are constant. Here, only
+# the density depends on temperature as expressed by the
+# Thermal expansion coefficient.
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1e23
+  end
+end
+
+# This part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed.
+# Here, the mesh is designed to be finer at the surface than at
+# the bottom of the model to better capture the conductive cooling
+# of the plates. It initially undergoes two global refinements and
+# four adaptive refinements in the first time step, but is not
+# refined further (i.e., it remains static) throughout the model
+# run. The adaptive refinements use the minimum refinement function
+# to increase the resolution towards the model surface in a
+# piece-wise fashion at depths of 7, 30, and 45 kilometers.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 4
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Variable names = depth, w
+    set Function expression = if(depth<7000,6,if(depth<30000,5,if(depth<45000,4,3)))
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e5
+    set List of output variables = material properties, heat flux map, vertical heat flux
+
+    subsection Material properties
+      set List of material properties = density, specific heat, thermal conductivity
+    end
+  end
+end
diff --git a/cookbooks/inclusions/ellipse_pure_shear.prm.bak b/cookbooks/inclusions/ellipse_pure_shear.prm.bak
new file mode 100644
index 00000000000..2944de60745
--- /dev/null
+++ b/cookbooks/inclusions/ellipse_pure_shear.prm.bak
@@ -0,0 +1,13 @@
+include ellipse_ref.prm
+
+set Output directory                       = output-ellipse-pure-shear
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function, top y: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = v=0.5
+    set Function expression = if (x<0.5,v,-v) ; if (y<0.5,-v,v)
+  end
+end
diff --git a/cookbooks/inclusions/ellipse_pure_shear_nonlinear.prm.bak b/cookbooks/inclusions/ellipse_pure_shear_nonlinear.prm.bak
new file mode 100644
index 00000000000..0f8d409324b
--- /dev/null
+++ b/cookbooks/inclusions/ellipse_pure_shear_nonlinear.prm.bak
@@ -0,0 +1,129 @@
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = output-ellipse-pure-shear-NL
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = true
+end
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+############### Parameters describing the compositional field
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = a=0.2, b=0.1, phi=0.52359877559
+    set Function expression = if( ( (x-.5)*cos(phi)+(y-.5)*sin(phi))^2/a^2 + \
+                                  ( (x-.5)*sin(phi)-(y-.5)*cos(phi))^2/b^2 < 1, 1, 0)
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 3
+  set Initial global refinement          = 7
+  set Refinement fraction                = 0.75
+  set Strategy                           = velocity, composition
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function, top y: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = v=0.5
+    set Function expression = if (x<0.5,v,-v) ; if (y<0.5,-v,v)
+  end
+end
+
+################################################3
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Reference temperature and viscosity
+    set Reference temperature = 273
+
+    # The minimum strain-rate helps limit large viscosities values that arise
+    # as the strain-rate approaches zero.
+    # The reference strain-rate is used on the first non-linear iteration
+    # of the first time step when the velocity has not been determined yet.
+    set Minimum strain rate   = 1.e-2
+    set Reference strain rate = 1.
+
+    # Limit the viscosity with minimum and maximum values
+    set Minimum viscosity = 1e-3
+    set Maximum viscosity = 1e3
+    set Densities              = 1
+    set Thermal expansivities  = 0
+    set Viscosity averaging scheme = harmonic
+    set Viscous flow law = dislocation
+
+    #matrix inclusion
+    set Prefactors for dislocation creep          = 0.5, 500
+    set Stress exponents for dislocation creep    =   1,      1
+    set Activation energies for dislocation creep =   0,      0
+    set Activation volumes for dislocation creep  =   0,      0
+
+    # Plasticity parameters
+    set Cohesions = 1e50
+  end
+end
diff --git a/cookbooks/inclusions/ellipse_ref.prm.bak b/cookbooks/inclusions/ellipse_ref.prm.bak
new file mode 100644
index 00000000000..d59e09701d8
--- /dev/null
+++ b/cookbooks/inclusions/ellipse_ref.prm.bak
@@ -0,0 +1,94 @@
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Pressure normalization                 = volume
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = true
+end
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Reference density = 1
+    set Viscosity         = 1
+    set Density differential for compositional field 1 = 1
+    set Composition viscosity prefactor = 0.001
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = a=0.2, b=0.1, phi=0.52359877559
+    set Function expression = if( ( (x-.5)*cos(phi)+(y-.5)*sin(phi))^2/a^2 + \
+                                  ( (x-.5)*sin(phi)-(y-.5)*cos(phi))^2/b^2 < 1, 1, 0)
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 3
+  set Initial global refinement          = 7
+  set Refinement fraction                = 0.75
+  set Strategy                           = velocity, composition
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate
+  end
+end
diff --git a/cookbooks/inclusions/ellipse_simple_shear.prm.bak b/cookbooks/inclusions/ellipse_simple_shear.prm.bak
new file mode 100644
index 00000000000..14d8f083175
--- /dev/null
+++ b/cookbooks/inclusions/ellipse_simple_shear.prm.bak
@@ -0,0 +1,13 @@
+include ellipse_ref.prm
+
+set Output directory                       = output-ellipse-simple-shear
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left y: function, right y:function, bottom: function, top: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = v=0.5
+    set Function expression = if (y<0.5,-v,+v) ; 0
+  end
+end
diff --git a/cookbooks/inclusions/rectangle_pure_shear.prm.bak b/cookbooks/inclusions/rectangle_pure_shear.prm.bak
new file mode 100644
index 00000000000..7e5d4ab1e2f
--- /dev/null
+++ b/cookbooks/inclusions/rectangle_pure_shear.prm.bak
@@ -0,0 +1,13 @@
+include rectangle_ref.prm
+
+set Output directory = output-rectangle-pure-shear
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function, top y: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = v=0.5
+    set Function expression = if (x<0.5,v,-v) ; if (y<0.5,-v,v)
+  end
+end
diff --git a/cookbooks/inclusions/rectangle_ref.prm.bak b/cookbooks/inclusions/rectangle_ref.prm.bak
new file mode 100644
index 00000000000..d287d3db6f5
--- /dev/null
+++ b/cookbooks/inclusions/rectangle_ref.prm.bak
@@ -0,0 +1,94 @@
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Pressure normalization                 = volume
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = true
+end
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Reference density = 1
+    set Viscosity         = 1
+    set Density differential for compositional field 1 = 1
+    set Composition viscosity prefactor = 1000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = a=0.2, b=0.1, phi=1.0471975512
+    set Function expression = if( abs( (x-.5)*cos(phi)+(y-.5)*sin(phi))<a &&  \
+                                  abs( (x-.5)*sin(phi)-(y-.5)*cos(phi))<b, 1, 0)
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 3
+  set Initial global refinement   = 7
+  set Refinement fraction         = 0.75
+  set Strategy                    = velocity, composition
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate
+  end
+end
diff --git a/cookbooks/inclusions/rectangle_simple_shear.prm.bak b/cookbooks/inclusions/rectangle_simple_shear.prm.bak
new file mode 100644
index 00000000000..a3a246edc64
--- /dev/null
+++ b/cookbooks/inclusions/rectangle_simple_shear.prm.bak
@@ -0,0 +1,13 @@
+include rectangle_ref.prm
+
+set Output directory = output-rectangle-simple-shear
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left y: function, right y:function, bottom: function, top: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = v=0.5
+    set Function expression = if (y<0.5,-v,+v) ; 0
+  end
+end
diff --git a/cookbooks/initial-condition-S20RTS/S20RTS.prm.bak b/cookbooks/initial-condition-S20RTS/S20RTS.prm.bak
new file mode 100644
index 00000000000..b3a8c60264a
--- /dev/null
+++ b/cookbooks/initial-condition-S20RTS/S20RTS.prm.bak
@@ -0,0 +1,152 @@
+# A description of convection in a 3d spherical shell with
+# a prescribed initial condition based on the shear wave
+# velocity model S20RTS.
+
+# Define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 3
+
+# Specify the time you want to let the model run for in
+# years and the output directory. Here we only calculate
+# the instantaneous solution.
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Output directory                       = output-S20RTS
+
+# The following variables describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain. The 'Surface pressure' and
+# 'Adiabatic surface temperature' are used to compute
+# the adiabatic reference profile.
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+# Here we specify the residual tolerance for the linear solver.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-4
+  end
+end
+
+# Here we specify the geometry of the domain, which is
+# a spherical shell with inner radius of 3481km and
+# outer radius of 6371km
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6371000
+  end
+end
+
+# This section specifies the temperature at the boundary of
+# the domain. Here we set the temperature to be constant,
+# but different from the reference temperature to approximate
+# boundary layers.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2000
+    set Outer temperature = 1000
+  end
+end
+
+# This section describes the gravity field, which is pointing
+# towards the Earth's center with the same magnitude of 10 m/s^2
+# everywhere
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+# This section prescribes the initial condition in the temperature
+# field, which is chosen as a scaled version of the S20RTS shear
+# wave velocity model (Ritsema et al., 2000). S20RTS is defined
+# by spherical harmonics up to degree 20 that are radially interpolated
+# with a cubic spline.
+subsection Initial temperature model
+  set Model name = S40RTS perturbation
+
+  subsection S40RTS perturbation
+    # The two input options here are S20RTS or the higher resolution
+    # S40RTS (Ritsema et al., 2011). One can choose to remove the
+    # degree 0 from these files so that the depth average value
+    # is zero.
+    set Initial condition file name       = S20RTS.sph
+    set Remove degree 0 from perturbation = false
+
+    # The following parameters determine the scaling from shear wave
+    # velocity perturbation to temperature differences. We chose the
+    # scaling to density perturbation as 0.15
+    set Vs to density scaling             = 0.15
+    set Thermal expansion coefficient in initial temperature scaling = 3e-5
+
+    # This specifies the background temperature to which we add the
+    # temperature difference.
+    set Reference temperature             = 1600
+  end
+end
+
+# The material model is based on the simple material model, which assumes
+# a constant density, and other parameters as stated below.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                 = 3300
+    set Viscosity                         = 1e21
+    set Thermal expansion coefficient     = 3e-5
+    set Reference temperature             = 1600
+    set Thermal conductivity              = 4.125
+    set Reference specific heat           = 1250
+  end
+end
+
+# For this calculation we only do 2 global refinement steps. This resolution
+# is too low to fully resolve the mantle flow, however it does capture
+# the main features.
+subsection Mesh refinement
+  set Time steps between mesh refinement = 0
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 0
+end
+
+# We assume free slip at the inner and outer boundary
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom
+end
+
+# We output the density, velocity, dynamic topography, geoid and heat flux density
+# for plotting.
+subsection Postprocess
+  set List of postprocessors = geoid, velocity statistics, heat flux map, heat flux statistics, dynamic topography, visualization, basic statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set List of output variables      = geoid, dynamic topography, heat flux map, density,viscosity, gravity
+    set Time between graphical output = 0
+    set Number of grouped files       = 1
+
+    # We only have dirichlet boundaries with tangential velocities, so we can
+    # increase the output resolution as described in the documentation of the 'heat
+    # flux map' postprocessor.
+    subsection Heat flux map
+      set Output point wise heat flux = true
+    end
+  end
+
+  subsection Geoid
+    set Also output the gravity anomaly  = true
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
diff --git a/cookbooks/initial-condition-S20RTS/doc/S20RTS.part.prm.bak b/cookbooks/initial-condition-S20RTS/doc/S20RTS.part.prm.bak
new file mode 100644
index 00000000000..dbee188cd78
--- /dev/null
+++ b/cookbooks/initial-condition-S20RTS/doc/S20RTS.part.prm.bak
@@ -0,0 +1,13 @@
+subsection Initial temperature model
+  set Model name = S40RTS perturbation
+
+  subsection S40RTS perturbation
+    set Data directory                    = $ASPECT_SOURCE_DIR/data/initial-temperature/S40RTS/
+    set Initial condition file name       = S20RTS.sph
+    set Spline knots depth file name      = Spline_knots.txt
+    set Remove degree 0 from perturbation = false
+    set Vs to density scaling             = 0.15
+    set Thermal expansion coefficient in initial temperature scaling = 3e-5
+    set Reference temperature             = 1600
+  end
+end
diff --git a/cookbooks/inner_core_convection/doc/inner_core_traction.part.1.prm.bak b/cookbooks/inner_core_convection/doc/inner_core_traction.part.1.prm.bak
new file mode 100644
index 00000000000..cb9f622c835
--- /dev/null
+++ b/cookbooks/inner_core_convection/doc/inner_core_traction.part.1.prm.bak
@@ -0,0 +1,15 @@
+subsection Material model
+  set Model name = inner core material
+
+  # The 'inner core material' model also contains a function that
+  # represents the resistance to melting/freezing at the inner core
+  # boundary.
+  # For P-->infinity, the boundary is a free slip boundary, and for
+  # P-->0, the boundary is an open boundary (with zero normal stress).
+  subsection Inner core
+    subsection Phase change resistance function
+      set Variable names      = x,y,z
+      set Function expression = 1e-2     # <-- P
+    end
+  end
+end
diff --git a/cookbooks/inner_core_convection/doc/inner_core_traction.part.2.prm.bak b/cookbooks/inner_core_convection/doc/inner_core_traction.part.2.prm.bak
new file mode 100644
index 00000000000..2bde3180a1e
--- /dev/null
+++ b/cookbooks/inner_core_convection/doc/inner_core_traction.part.2.prm.bak
@@ -0,0 +1,13 @@
+# The gravity has its maximum value at the boundary of inner and
+# outer core, and decreases approximately linearly to zero towards
+# the center of the core.
+# The Rayleigh number used in the model is given by the magnitude
+# of the gravity at the inner core/outer core boundary.
+subsection Gravity model
+  set Model name = radial linear
+
+  subsection Radial linear
+    set Magnitude at bottom = 0.0
+    set Magnitude at surface = 2     # <-- Ra
+  end
+end
diff --git a/cookbooks/inner_core_convection/doc/inner_core_traction.part.3.prm.bak b/cookbooks/inner_core_convection/doc/inner_core_traction.part.3.prm.bak
new file mode 100644
index 00000000000..79342416a60
--- /dev/null
+++ b/cookbooks/inner_core_convection/doc/inner_core_traction.part.3.prm.bak
@@ -0,0 +1,11 @@
+subsection Mesh refinement
+  set Initial global refinement          = 4  #this may be more expensive, and should be run on a cluster.
+  set Initial adaptive refinement        = 1
+  set Strategy                           = minimum refinement function
+  set Time steps between mesh refinement = 0
+
+  subsection Minimum refinement function
+    set Variable names = depth, phi, theta
+    set Function expression = if(depth>0.1,if(depth>0.2,2,5),6)
+  end
+end
diff --git a/cookbooks/inner_core_convection/inner_core_assembly.cc.bak b/cookbooks/inner_core_convection/inner_core_assembly.cc.bak
new file mode 100644
index 00000000000..8cd7a42d249
--- /dev/null
+++ b/cookbooks/inner_core_convection/inner_core_assembly.cc.bak
@@ -0,0 +1,140 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/simulator.h>
+#include <aspect/simulator/assemblers/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+#include "inner_core_convection.cc"
+
+namespace aspect
+{
+  /**
+   * A new assembler class that implements boundary conditions for the
+   * normal stress and the normal velocity that take into account the
+   * rate of phase change (melting/freezing) at the inner-outer core
+   * boundary. The model is based on Deguen, Alboussiere, and Cardin
+   * (2013), Thermal convection in Earth's inner core with phase change
+   * at its boundary. GJI, 194, 1310-133.
+   *
+   * The mechanical boundary conditions for the inner core are
+   * tangential stress-free and continuity of the normal stress at the
+   * inner-outer core boundary. For the non-dimensional equations, that
+   * means that we can define a 'phase change number' $\mathcal{P}$ so
+   * that the normal stress at the boundary is $-\mathcal{P} u_r$ with
+   * the radial velocity $u_r$. This number characterizes the resistance
+   * to phase change at the boundary, with $\mathcal{P}\rightarrow\infty$
+   * corresponding to infinitely slow melting/freezing (free slip
+   * boundary), and $\mathcal{P}\rightarrow0$ corresponding to
+   * instantaneous melting/freezing (zero normal stress, open boundary).
+   *
+   * In the weak form, this results in boundary conditions of the form
+   * of a surface integral:
+   * $$\int_S \mathcal{P} (\mathbf u \cdot \mathbf n) (\mathbf v \cdot \mathbf n) dS,$$,
+   * with the normal vector $\mathbf n$.
+   *
+   * The function value of $\mathcal{P}$ is taken from the inner core
+   * material model.
+   */
+  template <int dim>
+  class PhaseBoundaryAssembler :
+    public aspect::Assemblers::Interface<dim>,
+    public SimulatorAccess<dim>
+  {
+
+    public:
+
+      void
+      execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+               internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override
+      {
+        internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+        internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+        const Introspection<dim> &introspection = this->introspection();
+        const FiniteElement<dim> &fe            = this->get_fe();
+        const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+        const unsigned int n_q_points           = scratch.face_finite_element_values.n_quadrature_points;
+
+        //assemble force terms for the matrix for all boundary faces
+        if (scratch.cell->face(scratch.face_number)->at_boundary())
+          {
+            scratch.face_finite_element_values.reinit (scratch.cell, scratch.face_number);
+
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                const double P = Plugins::get_plugin_as_type<const MaterialModel::InnerCore<dim>>
+                                 (this->get_material_model()).resistance_to_phase_change
+                                 .value(scratch.material_model_inputs.position[q]);
+
+                for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+                  {
+                    if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                      {
+                        scratch.phi_u[i_stokes] = scratch.face_finite_element_values[introspection
+                                                                                     .extractors.velocities].value(i, q);
+                        ++i_stokes;
+                      }
+                    ++i;
+                  }
+
+                const Tensor<1,dim> normal_vector = scratch.face_finite_element_values.normal_vector(q);
+                const double JxW = scratch.face_finite_element_values.JxW(q);
+
+                // boundary term: P*u*n*v*n*JxW(q)
+                for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+                  for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                    data.local_matrix(i,j) += P *
+                                              scratch.phi_u[i] *
+                                              normal_vector *
+                                              scratch.phi_u[j] *
+                                              normal_vector *
+                                              JxW;
+              }
+          }
+      }
+  };
+
+  template <int dim>
+  void set_assemblers_phase_boundary(const SimulatorAccess<dim> &simulator_access,
+                                     Assemblers::Manager<dim> &assemblers)
+  {
+    AssertThrow (Plugins::plugin_type_matches<const MaterialModel::InnerCore<dim>>
+                 (simulator_access.get_material_model()),
+                 ExcMessage ("The phase boundary assembler can only be used with the "
+                             "material model 'inner core material'!"));
+
+    assemblers.stokes_system_on_boundary_face.push_back (std::make_unique<PhaseBoundaryAssembler<dim>>());
+  }
+}
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  signals.set_assemblers.connect (&aspect::set_assemblers_phase_boundary<dim>);
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/cookbooks/inner_core_convection/inner_core_convection.cc.bak b/cookbooks/inner_core_convection/inner_core_convection.cc.bak
new file mode 100644
index 00000000000..69aded1aab9
--- /dev/null
+++ b/cookbooks/inner_core_convection/inner_core_convection.cc.bak
@@ -0,0 +1,488 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/gravity_model/radial.h>
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class InnerCore : public MaterialModel::Simple<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        InnerCore ();
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the boundary values will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * A function object representing resistance to phase change at the
+         * inner core boundary as a function the position (and, optionally,
+         * the model time).
+         */
+        Functions::ParsedFunction<dim> resistance_to_phase_change;
+
+      private:
+        /**
+         * Parameters related to the phase transition.
+         */
+        double transition_radius;
+        double transition_width;
+        double transition_temperature;
+        double transition_clapeyron_slope;
+        double transition_density_change;
+        bool compute_quadratic_pressure_profile;
+
+        /**
+         * A function object representing the hydrostatic pressure in the
+         * inner core as a function of radius. This is needed to compute
+         * the depth of phase transitions.
+         * Note that we can not simply use the adiabatic pressure here,
+         * as the equations are solved for the dynamic pressure, and the
+         * adiabatic conditions are used as initial guess for the solution.
+         */
+        Functions::ParsedFunction<1> hydrostatic_pressure_profile;
+
+        /**
+         * Percentage of material that has already undergone the phase
+         * transition to the higher-pressure material.
+         */
+        double
+        phase_function (const Point<dim> &position,
+                        const double temperature) const;
+
+        /**
+         * Hydrostatic pressure profile.
+         */
+        double
+        hydrostatic_pressure (const double radius) const;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    InnerCore<dim>::InnerCore ()
+      :
+      resistance_to_phase_change (1),
+      hydrostatic_pressure_profile (1)
+    {}
+
+    template <int dim>
+    double
+    InnerCore<dim>::
+    phase_function (const Point<dim> &position,
+                    const double temperature) const
+    {
+      // We need to convert the depth to pressure,
+      // keeping in mind that for this model, the pressure is only the dynamic pressure,
+      // so we have to get the hydrostatic pressure explicitly as an input.
+      const double radius = this->get_geometry_model().maximal_depth() - this->get_geometry_model().depth(position);
+      Assert(radius >= 0,
+             ExcMessage("There is a point in the model where the depth is larger "
+                        "than the maximal depth of this geometry."));
+
+      const double pressure_deviation = hydrostatic_pressure(radius) - hydrostatic_pressure(transition_radius);
+
+      double depth_deviation = transition_radius - radius;
+      if (std::fabs(pressure_deviation) > 100.0 * std::numeric_limits<double>::epsilon()
+          * (std::fabs(hydrostatic_pressure(radius)) + std::fabs(hydrostatic_pressure(transition_radius)))/2)
+        depth_deviation *= (1.0 - transition_clapeyron_slope * (temperature - transition_temperature) / pressure_deviation);
+
+      double phase_func;
+      // use delta function for width = 0
+      if (transition_width == 0)
+        phase_func = (depth_deviation > 0) ? 1 : 0;
+      else
+        phase_func = 0.5 * (1.0 + std::tanh(depth_deviation / transition_width));
+      return phase_func;
+    }
+
+
+    template <int dim>
+    double
+    InnerCore<dim>::
+    hydrostatic_pressure (const double radius) const
+    {
+      if (compute_quadratic_pressure_profile)
+        {
+          // Compute a quadratic hydrostatic pressure profile, based on a linear gravity model.
+          AssertThrow (Plugins::plugin_type_matches<const GravityModel::RadialLinear<dim>>(this->get_gravity_model()),
+                       ExcMessage ("Automatic computation of the hydrostatic pressure profile is "
+                                   "only implemented for the 'radial linear' gravity model."));
+
+          const double max_radius = this->get_geometry_model().maximal_depth();
+          const Point<dim> surface_point = this->get_geometry_model().representative_point(0);
+          const double gravity_magnitude = this->get_gravity_model().gravity_vector(surface_point).norm();
+
+          // The gravity is zero in the center of the Earth, and we assume the density to be constant and equal to 1.
+          // We fix the surface pressure to 0 (and we are only interested in pressure differences anyway).
+          return gravity_magnitude * 0.5 * (1.0 - std::pow(radius/max_radius,2));
+        }
+      else
+        return hydrostatic_pressure_profile.value(Point<1>(radius));
+    }
+
+
+    template <int dim>
+    void
+    InnerCore<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // First, we use the material descriptions of the 'simple' material model to fill all of the material
+      // model outputs. Below, we will then overwrite selected properties (the specific heat) to make the
+      // product of density and specific heat a constant.
+      Simple<dim>::evaluate(in, out);
+
+      // We want the right-hand side of the momentum equation to be (- Ra T gravity) and
+      // density * cp to be 1
+      for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
+        {
+          out.densities[q] = - out.thermal_expansion_coefficients[q] * in.temperature[q]
+                             + phase_function (in.position[q], in.temperature[q]) * transition_density_change;
+          if (std::abs(out.densities[q]) > 0.0)
+            out.specific_heat[q] /= out.densities[q];
+        }
+    }
+
+
+    template <int dim>
+    void
+    InnerCore<dim>::update()
+    {
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        resistance_to_phase_change.set_time (this->get_time() / year_in_seconds);
+      else
+        resistance_to_phase_change.set_time (this->get_time());
+
+      if (this->convert_output_to_years())
+        hydrostatic_pressure_profile.set_time (this->get_time() / year_in_seconds);
+      else
+        hydrostatic_pressure_profile.set_time (this->get_time());
+    }
+
+
+    template <int dim>
+    void
+    InnerCore<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      Simple<dim>::declare_parameters (prm);
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Inner core");
+        {
+          prm.enter_subsection("Phase change resistance function");
+          {
+            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+          }
+          prm.leave_subsection();
+
+          prm.enter_subsection("Hydrostatic pressure function");
+          {
+            Functions::ParsedFunction<1>::declare_parameters (prm, 1);
+          }
+          prm.leave_subsection();
+
+          prm.declare_entry ("Phase transition radius", "0.0",
+                             Patterns::Double (0),
+                             "The distance from the center of the Earth where the phase "
+                             "transition occurs. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Phase transition width", "0.0",
+                             Patterns::Double (0),
+                             "The width of the phase transition. The argument of the phase function "
+                             "is scaled with this value, leading to a jump between phases "
+                             "for a value of zero and a gradual transition for larger values. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Phase transition temperature", "0.0",
+                             Patterns::Double (0),
+                             "The temperature at which the phase transition occurs in the depth "
+                             "given by the 'Phase transition depth' parameter.  Higher or lower "
+                             "temperatures lead to phase transition occurring in shallower or greater "
+                             "depths, depending on the Clapeyron slope given in 'Phase transition "
+                             "Clapeyron slope'. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Phase transition Clapeyron slope", "0.0",
+                             Patterns::Double (),
+                             "The Clapeyron slope of the phase transition. A positive "
+                             "Clapeyron slope indicates that the phase transition will occur in "
+                             "a greater depth if the temperature is higher than the one given in "
+                             "Phase transition temperatures (and in a smaller depth if the "
+                             "temperature is smaller than the one given in Phase transition temperatures). "
+                             "For negative Clapeyron slopes, the effect is in the opposite direction. "
+                             "Units: Pa/K.");
+          prm.declare_entry ("Phase transition density change", "0.0",
+                             Patterns::Double (),
+                             "The density change that occurs across the phase transition. "
+                             "A positive value means that the density increases with depth. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Compute quadratic pressure profile from gravity", "true",
+                             Patterns::Bool (),
+                             "Whether to automatically compute the hydrostatic pressure profile "
+                             "(that is used to compute the location of phase transitions) from "
+                             "the magnitude of the gravity, assuming a linear gravity profile "
+                             "and a constant density (if true), or to use the function that is "
+                             "given in 'Hydrostatic pressure function' (if false).");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    InnerCore<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      Simple<dim>::parse_parameters (prm);
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Inner core");
+        {
+          prm.enter_subsection("Phase change resistance function");
+          try
+            {
+              resistance_to_phase_change.parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Phase boundary model.Function'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+          prm.leave_subsection();
+
+          prm.enter_subsection("Hydrostatic pressure function");
+          try
+            {
+              hydrostatic_pressure_profile.parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Hydrostatic pressure model.Function'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+          prm.leave_subsection();
+
+          transition_radius          = prm.get_double ("Phase transition radius");
+          transition_width           = prm.get_double ("Phase transition width");
+          transition_temperature     = prm.get_double ("Phase transition temperature");
+          transition_clapeyron_slope = prm.get_double ("Phase transition Clapeyron slope");
+          transition_density_change  = prm.get_double ("Phase transition density change");
+          compute_quadratic_pressure_profile = prm.get_bool ("Compute quadratic pressure profile from gravity");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a constant radiogenic heating rate.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class ConstantCoreHeating : public Interface<dim>
+    {
+      public:
+        /**
+         * Return the heating terms. For the current class, this
+         * function obviously simply returns a constant value.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        double radiogenic_heating_rate;
+    };
+  }
+}
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    ConstantCoreHeating<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &/*material_model_inputs*/,
+              const MaterialModel::MaterialModelOutputs<dim> &/*material_model_outputs*/,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          // return a constant value
+          heating_model_outputs.heating_source_terms[q] = radiogenic_heating_rate;
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    ConstantCoreHeating<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Constant core heating");
+        {
+          prm.declare_entry ("Radiogenic heating rate", "0e0",
+                             Patterns::Double (0),
+                             "The specific rate of heating due to radioactive decay (or other bulk sources "
+                             "you may want to describe). This parameter corresponds to the variable "
+                             "$H$ in the temperature equation stated in the manual, and the heating "
+                             "term is $\\rho H$. Units: W/kg.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ConstantCoreHeating<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Constant core heating");
+        {
+          radiogenic_heating_rate    = prm.get_double ("Radiogenic heating rate");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(InnerCore,
+                                   "inner core material",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but has a constant $\rho c_p$, "
+                                   "and implements a function that characterizes the "
+                                   "resistance to melting/freezing at the inner core "
+                                   "boundary.")
+  }
+
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(ConstantCoreHeating,
+                                  "constant core heating",
+                                  "Implementation of a model in which the heating "
+                                  "rate is constant.")
+  }
+}
diff --git a/cookbooks/inner_core_convection/inner_core_traction.prm b/cookbooks/inner_core_convection/inner_core_traction.prm
index 215f28bc066..01137135c4c 100644
--- a/cookbooks/inner_core_convection/inner_core_traction.prm
+++ b/cookbooks/inner_core_convection/inner_core_traction.prm
@@ -131,6 +131,6 @@ end
 
 subsection Solver parameters
   subsection Stokes solver parameters
-      set Stokes solver type = block AMG
+    set Stokes solver type = block AMG
   end
 end
diff --git a/cookbooks/inner_core_convection/inner_core_traction.prm.bak b/cookbooks/inner_core_convection/inner_core_traction.prm.bak
new file mode 100644
index 00000000000..215f28bc066
--- /dev/null
+++ b/cookbooks/inner_core_convection/inner_core_traction.prm.bak
@@ -0,0 +1,136 @@
+# A simple setup for convection the inner core. See the
+# manual, Section Cookbooks/Geophysical setups/Inner core convection
+# for more information. Changing the Rayleigh number Ra
+# and the resistance to phase change P will change the mode
+# of inner core convection between translation, plume convection
+# or no convection.
+#
+# Setup and equations are given in: Deguen, Alboussiere,
+# and Cardin (2013), Thermal convection in Earth’s inner core
+# with phase change at its boundary. GJI, 194, 1310-133.
+
+set Additional shared libraries            = ./libinner_core_convection.so
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set End time                               = 1.5e9
+set Output directory                       = output-inner_core_traction
+
+# The equations are non-dimensionalized, and all of the
+# material properties are constant and set to one, except
+# for the density, which scales with temperature.
+subsection Material model
+  set Model name = inner core material
+
+  subsection Simple model
+    set Reference density             = 0
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+
+  # The 'inner core material' model also contains a function that
+  # represents the resistance to melting/freezing at the inner core
+  # boundary.
+  # This phase boundary model combines a prescribed a normal
+  # velocity and normal stress. The relation between the two scales
+  # with the phase change number P, which is given in the 'Function
+  # expression'.
+  # For P-->infinity, the boundary is a free slip boundary, and for
+  # P-->0, the boundary is an open boundary (with zero normal stress).
+
+  # For time dependence, the variable names have to have dim+1 entries,
+  # and the last variable will be the time
+  subsection Inner core
+    subsection Phase change resistance function
+      set Variable names      = x,y,z
+      set Function expression = 1e-2     # <-- P
+    end
+  end
+end
+
+# The inner core is a sphere, and the non-dimensional radius
+# is 1.
+subsection Geometry model
+  set Model name = sphere
+
+  subsection Sphere
+    set Radius  = 1
+  end
+end
+
+# We use a new boundary condition at the surface, which takes
+# into account the effect of melting/freezing of material at
+# the boundary of inner and outer core, and which is implemented
+# in the shared library.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = surface: zero traction
+end
+
+# We use a constant radiogenic heating rate.
+subsection Heating model
+  set List of model names = constant core heating
+
+  subsection Constant core heating
+    set Radiogenic heating rate = 6
+  end
+end
+
+# The (potential) temperature is set to zero at the outer boundary.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = surface
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 0.1
+    set Outer temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+# The gravity has its maximum value at the boundary of inner and
+# outer core, and decreases approximately linearly to zero towards
+# the center of the core.
+# The Rayleigh number used in the model is given by the magnitude
+# of the gravity at the inner core/outer core boundary.
+subsection Gravity model
+  set Model name = radial linear
+
+  subsection Radial linear
+    set Magnitude at bottom = 0.0
+    set Magnitude at surface = 2     # <-- Ra
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 0
+  set Strategy                           = minimum refinement function
+  set Time steps between mesh refinement = 0
+
+  subsection Minimum refinement function
+    set Variable names = depth, phi, theta
+    set Function expression = if(depth>0.1,if(depth>0.2,2,5),6)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Number of grouped files       = 0
+    set List of output variables      = strain rate, gravity, density, specific heat, heating
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+      set Stokes solver type = block AMG
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc.bak b/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc.bak
new file mode 100644
index 00000000000..c77565c10c5
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc.bak
@@ -0,0 +1,227 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "composition_trms_statistics.h"
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    CompositionTrmsStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the temperature element alone.
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      std::vector<double> temperature_values(n_q_points);
+      std::vector<double> compositional_values(n_q_points);
+
+      std::vector<double> local_temperature_square_integral (this->n_compositional_fields());
+      std::vector<double> local_area_integral (this->n_compositional_fields());
+      double local_total_temperature_square_integral = 0.;
+      double local_total_area_integral = 0.;
+      const double kelvin_to_celsius = 273.15;
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit(cell);
+
+            fe_values[this->introspection().extractors.temperature].get_function_values(this->get_solution(),
+                                                                                        temperature_values);
+
+            // Loop over the quadrature points to get the temperature and area
+            // integral for the whole domain.
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                local_total_temperature_square_integral += (((temperature_values[q]-kelvin_to_celsius) *
+                                                             (temperature_values[q]-kelvin_to_celsius)) * fe_values.JxW(q));
+                local_total_area_integral += fe_values.JxW(q);
+              }
+
+            // For each field, loop over the quadrature points to get the temperature
+            // and area per field.
+            for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+              {
+                fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
+                    compositional_values);
+
+                for (unsigned int q = 0; q < n_q_points; ++q)
+                  {
+                    if (compositional_values[q] >= 0.5)
+                      {
+                        local_temperature_square_integral[c] += (((temperature_values[q]-kelvin_to_celsius) *
+                                                                  (temperature_values[q]-kelvin_to_celsius)) * fe_values.JxW(q));
+                        local_area_integral[c] += fe_values.JxW(q);
+                      }
+                  }
+              }
+          }
+
+      std::vector<double> global_temperature_square_integral (local_temperature_square_integral.size());
+      Utilities::MPI::sum (local_temperature_square_integral, this->get_mpi_communicator(), global_temperature_square_integral);
+      std::vector<double> global_area_integral (local_area_integral.size());
+      Utilities::MPI::sum (local_area_integral, this->get_mpi_communicator(), global_area_integral);
+      const double global_total_temperature_square_integral = Utilities::MPI::sum(local_total_temperature_square_integral, this->get_mpi_communicator());
+      const double global_total_area_integral = Utilities::MPI::sum(local_total_area_integral, this->get_mpi_communicator());
+
+      // compute the RMS temperature for each compositional field and for the selected compositional fields combined
+      std::vector<double> Trms_per_composition(local_area_integral.size());
+      double temperature_square_integral_selected_fields = 0., area_integral_selected_fields = 0.;
+
+      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+        {
+          Trms_per_composition[c] = std::sqrt(global_temperature_square_integral[c]) /
+                                    std::sqrt(global_area_integral[c]);
+
+          const std::vector<std::string>::iterator selected_field_it = std::find(selected_fields.begin(), selected_fields.end(), this->introspection().name_for_compositional_index(c));
+          if (selected_field_it != selected_fields.end())
+            {
+              temperature_square_integral_selected_fields += global_temperature_square_integral[c];
+              area_integral_selected_fields += global_area_integral[c];
+            }
+        }
+
+      const double Trms_selected_fields = std::sqrt(temperature_square_integral_selected_fields) / std::sqrt(area_integral_selected_fields);
+
+      // compute the RMS temperature over the whole domain
+      const double Trms_whole_domain = std::sqrt(global_total_temperature_square_integral) / std::sqrt(global_total_area_integral);
+
+      // finally produce something for the statistics file
+      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+        {
+          statistics.add_value("RMS temperature (C) for composition " + this->introspection().name_for_compositional_index(c),
+                               Trms_per_composition[c]);
+
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          const std::string columns[] = {"RMS temperature (C) for composition " + this->introspection().name_for_compositional_index(c)};
+
+          for (unsigned int i = 0; i < sizeof(columns) / sizeof(columns[0]); ++i)
+            {
+              statistics.set_precision(columns[i], 8);
+              statistics.set_scientific(columns[i], true);
+            }
+        }
+
+      // Also output the RMS temperature for the selected fields
+      statistics.add_value("RMS temperature (C) for the selected fields",
+                           Trms_selected_fields);
+
+      const std::string column = {"RMS temperature (C) for the selected fields"};
+
+      statistics.set_precision(column, 8);
+      statistics.set_scientific(column, true);
+
+      // Also output the RMS temperature for the whole domain
+      statistics.add_value("RMS temperature (C) for the whole domain",
+                           Trms_whole_domain);
+
+      const std::string column_whole_domain = {"RMS temperature (C) for the whole domain"};
+
+      statistics.set_precision(column_whole_domain, 8);
+      statistics.set_scientific(column_whole_domain, true);
+
+      std::ostringstream output;
+      output.precision(4);
+
+      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+        {
+          output << Trms_per_composition[c]
+                 << " C";
+          output << " // ";
+        }
+      output << Trms_selected_fields << " C // ";
+      output << Trms_whole_domain << " C";
+
+      return std::pair<std::string, std::string>("RMS temperature for compositions, combined selected fields and whole domain:",
+                                                 output.str());
+    }
+
+
+
+    template <int dim>
+    void CompositionTrmsStatistics<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Composition RMS temperature statistics");
+        {
+          prm.declare_entry("Names of selected compositional fields", "",
+                            Patterns::List(Patterns::Anything()),
+                            "A list of names for each of the compositional fields that "
+                            "you want to compute the combined RMS temperature for.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void CompositionTrmsStatistics<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Composition RMS temperature statistics");
+        {
+          selected_fields = Utilities::split_string_list(prm.get("Names of selected compositional fields"));
+
+          AssertThrow((selected_fields.size() > 0) &&
+                      (selected_fields.size() <= this->n_compositional_fields()),
+                      ExcMessage("The length of the list of names for the compositional "
+                                 "fields for which the RMS temperature is to be summed must be larger than zero "
+                                 "and smaller or equal to the number of compositional fields."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(CompositionTrmsStatistics,
+                                  "composition RMS temperature statistics",
+                                  "A postprocessor that computes the root-mean-square (RMS) temperature "
+                                  "over the area spanned by each compositional field (i.e. where "
+                                  "the field values are larger or equal to 0.5). It also computes the RMS "
+                                  "temperature over the summed area of a list of fields given by the user, "
+                                  "and over the whole domain.")
+  }
+}
diff --git a/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.h.bak b/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.h.bak
new file mode 100644
index 00000000000..bcf1f80503c
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.h.bak
@@ -0,0 +1,75 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_composition_trms_statistics_h
+#define _aspect_postprocess_composition_trms_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes the root mean square temperature
+     * over the area spanned by each of the compositional fields.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class CompositionTrmsStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution to compute the root-mean-square temperature per compositional field.
+         **/
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static void
+        declare_parameters(ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters(ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        std::vector<std::string> selected_fields;
+    };
+  }
+}
+
+
+#endif
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_compositions.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_compositions.prm.bak
new file mode 100644
index 00000000000..de24a7eeb08
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_compositions.prm.bak
@@ -0,0 +1,39 @@
+# We fix composition on the right boundary,
+# because we have inflow there.
+subsection Boundary composition model
+  set Fixed composition boundary indicators = right
+  set List of model names                   = initial composition
+end
+
+# The overriding plate (OP) and subducting plate (SP)
+# are each divided into three different layers:
+# a layer of Bulk Oceanic Composition (BOC),
+# a layer of Serpentinized HarzBurgite (SHB),
+# and a "thermal layer".
+
+subsection Compositional fields
+  set Number of fields = 7
+  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = Ax=1475600.0, Az=670000.0, \
+                              Bx=1500000.0, Bz=670000.0, \
+                              Cx=1358500.0, Cz=588000.0, \
+                              Dx=1382900.0, Dz=588000.0, \
+                              Ex=1530000.0, Ez=560000.0, \
+                              Fz=663000.0, Gz=662000.0, \
+                              Hz=631000.0, Iz=630000.0
+    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
+                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
+                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
+                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
+                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
+                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
+                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
+    set Variable names      = x,z
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_materialmodel.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_materialmodel.prm.bak
new file mode 100644
index 00000000000..8f4b35a90d9
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_materialmodel.prm.bak
@@ -0,0 +1,15 @@
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature         = 0.0
+    set Viscosity averaging scheme    = maximum composition
+
+    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
+    set Densities                     = 3200.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0
+    set Thermal conductivities        = 1
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_meshrefinement.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_meshrefinement.prm.bak
new file mode 100644
index 00000000000..5ec090c8d17
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_meshrefinement.prm.bak
@@ -0,0 +1,23 @@
+# The maximum refinement level will be 6+4 levels,
+# corresponding to a maximum resolution of ~700 m.
+subsection Mesh refinement
+  set Initial adaptive refinement              = 4
+  set Initial global refinement                = 6
+  set Minimum refinement level                 = 6
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = plus
+  set Coarsening fraction                      = 0.01
+  set Refinement fraction                      = 0.95
+  set Run postprocessors on initial refinement = false
+  set Skip solvers on initial refinement       = true
+  set Skip setup initial conditions on initial refinement = true
+  set Strategy                                 = minimum refinement function, viscosity
+  set Time steps between mesh refinement       = 16
+
+  subsection Minimum refinement function
+    set Coordinate system = depth
+    set Variable names = x,z,t
+    set Function constants = vel=150e3, L=100e3, crust=10e3
+    set Function expression = if(x<crust,10,if(x<L,9,if(x<vel,8,6)))
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm
index 13f6305edf3..c894b14bc71 100644
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm
@@ -1,5 +1,5 @@
 subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, trench location
+  set List of postprocessors = visualization, velocity statistics, heating statistics, trench location
 
   subsection Visualization
     set List of output variables      = density, viscosity, strain rate, error indicator
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm.bak
new file mode 100644
index 00000000000..13f6305edf3
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm.bak
@@ -0,0 +1,16 @@
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, trench location
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, strain rate, error indicator
+    set Time between graphical output = 5e5
+  end
+
+  subsection Trench location
+    set Name of trench compositional field = BOC_OP
+  end
+
+  subsection Composition velocity statistics
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_velocity.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_velocity.prm.bak
new file mode 100644
index 00000000000..ffe1ab8e9b9
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_velocity.prm.bak
@@ -0,0 +1,13 @@
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom, top
+  set Prescribed velocity boundary indicators = right x:function
+
+  subsection Function
+    set Function constants  = cm=100.0
+    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
+                                 if(z>560000.0, -5.0/cm, \
+                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
+                              0
+    set Variable names      = x,z
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_materialmodel.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_materialmodel.prm.bak
new file mode 100644
index 00000000000..4b4372e4618
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_materialmodel.prm.bak
@@ -0,0 +1,13 @@
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature         = 473.15
+    set Densities                     = 3200.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0
+    set Thermal expansivities         = 0
+    set Thermal conductivities        = 183.33,2.5,2.5,2.5,2.5,2.5,2.5,2.5
+    set Heat capacities               = 1250.0,750.0,750.0,750.0,750.0,1250.0,1250.0,750.0
+    set Viscosity averaging scheme    = maximum composition
+    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm
index 97f6121cceb..9305efc0827 100644
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm
@@ -1,5 +1,5 @@
 subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
+  set List of postprocessors = visualization, velocity statistics, heating statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
 
   subsection Composition velocity statistics
     #Sum the velocities of the fields that make up the subducting plate.
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm.bak
new file mode 100644
index 00000000000..97f6121cceb
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm.bak
@@ -0,0 +1,20 @@
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
+
+  subsection Composition velocity statistics
+    #Sum the velocities of the fields that make up the subducting plate.
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+
+  subsection Trench location
+    set Name of trench compositional field = BOC_OP
+  end
+
+  subsection Isotherm depth
+    set Isotherm value = 1073.15
+  end
+
+  subsection Composition RMS temperature statistics
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_temperatures.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_temperatures.prm.bak
new file mode 100644
index 00000000000..e6c69a04bf0
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_temperatures.prm.bak
@@ -0,0 +1,21 @@
+# We include a shared library with a customized initial temperature plugin and the required isotherm depth, composition RMS temperature, and trench location postprocessors.
+set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/libsubduction_plate_cooling.so
+
+# We fix temperature on the top and bottom,
+# as well as on the right boundary because
+# we have inflow through the latter.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 0
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = subduction plate cooling
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case2b_materialmodel.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case2b_materialmodel.prm.bak
new file mode 100644
index 00000000000..a97345679f2
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/doc/Case2b_materialmodel.prm.bak
@@ -0,0 +1,25 @@
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    # The benchmark uses two different reference temperatures for the compositions:
+    # 1573.15 K for the asthenosphere, thermal_OP and thermal_SP, and 473.15 K for
+    # the rest of the compositions.
+    # As ASPECT only allows for one reference temperature, we have instead adapted
+    # the reference density for the mantle compositions. To do this, we took the initial
+    # temperature and the midpoint depth of the layers and equated the density equation
+    # using the benchmark reference density rho_0_1 (3200 kg/m3) and temperature T_0_1 (1573.15 K), and
+    # the density equation using the 473.15 K reference temperature to obtain the new reference density rho_0_2.
+    # For the left thermal layer, the initial temperature at the midpoint is 1355 K, so
+    # new reference density can be derived as follows:
+    # rho_0_1 * (1 - alpha * (T - T_0_1)) = rho_0_2 * (1 - alpha * (T - T_0_2)),
+    # 3200 * (1 - 2.5e-5 * (1355 - 1573.15)) = rho_0_2 * (1 - 2.5e-5 * (1355 - 473.15))
+    # rho_0_2 = 3290.66.
+    set Reference temperature         = 473.15
+    set Densities                     = 3290.66,3000.0,3000.0,3250.0,3250.0,3290.66,3290.66,3200.0
+
+    # Compared to Case 2a, thermal expansivity is no longer zero and therefore temperature
+    # feeds into the density and therefore the Stokes equations
+    set Thermal expansivities         = 2.5e-5
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc.bak b/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc.bak
new file mode 100644
index 00000000000..9e37fd89bd1
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc.bak
@@ -0,0 +1,152 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "isotherm_depth.h"
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    IsothermDepth<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the temperature element alone.
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      std::vector<Point<dim>> position_values(n_q_points);
+      std::vector<double> temperature_values(n_q_points);
+
+      double local_isotherm_depth = 0.0;
+      const double max_depth = this->get_geometry_model().maximal_depth();
+      const double dT = 1.1;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+
+            fe_values.reinit (cell);
+
+            position_values = fe_values.get_quadrature_points();
+
+            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
+                                                                                         temperature_values);
+
+            for (unsigned int i=0; i<n_q_points; ++i)
+              {
+                // Calculate the biggest depth per processor
+                if (temperature_values[i] > (isotherm_value - dT) && temperature_values[i] < (isotherm_value + dT) &&
+                    (max_depth - position_values[i][dim-1]) > local_isotherm_depth)
+                  {
+                    local_isotherm_depth = max_depth - position_values[i][dim-1];
+                  }
+              }
+          }
+
+      // compute the maximum depth over all processors
+      const  double isotherm_depth =
+        Utilities::MPI::max (local_isotherm_depth, this->get_mpi_communicator());
+
+      statistics.add_value ("Isotherm depth [m]", isotherm_depth);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      {
+        const char *columns[] = { "Isotherm depth [m]"
+                                };
+        for (unsigned int i=0; i<sizeof(columns)/sizeof(columns[0]); ++i)
+          {
+            statistics.set_precision (columns[i], 8);
+            statistics.set_scientific (columns[i], true);
+          }
+      }
+
+      std::ostringstream output;
+      output.precision(4);
+      output << isotherm_depth
+             << " m ";
+      return std::pair<std::string, std::string> ("Isotherm depth [m]:",
+                                                  output.str());
+    }
+
+
+
+    template <int dim>
+    void IsothermDepth<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Isotherm depth");
+        {
+          prm.declare_entry("Isotherm value", "1573",
+                            Patterns::Double(0),
+                            "The temperature value of the isotherm "
+                            "which maximum depth is tracked. Unit: [K].");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void IsothermDepth<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Isotherm depth");
+        {
+          isotherm_value = prm.get_double("Isotherm value");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(IsothermDepth,
+                                  "isotherm depth",
+                                  "A postprocessor that computes the maximum depth "
+                                  "of a user-given isotherm.")
+  }
+}
diff --git a/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.h.bak b/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.h.bak
new file mode 100644
index 00000000000..7553b24b75b
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.h.bak
@@ -0,0 +1,74 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_isotherm_depth_h
+#define _aspect_postprocess_isotherm_depth_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the deepest point of the last composition.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class IsothermDepth : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution to find the deepest point of a user-specified isotherm.
+         **/
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static void
+        declare_parameters(ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters(ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        double isotherm_value;
+    };
+  }
+}
+
+
+#endif
diff --git a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm
index ba095e61c31..ba634ce5f0d 100644
--- a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm
+++ b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm
@@ -174,7 +174,7 @@ subsection Formulation
 end
 
 subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, trench location
+  set List of postprocessors = visualization, velocity statistics, heating statistics, trench location
 
   subsection Visualization
     set List of output variables      = density, viscosity, strain rate, error indicator
diff --git a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm.bak b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm.bak
new file mode 100644
index 00000000000..ba095e61c31
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm.bak
@@ -0,0 +1,202 @@
+# This cookbook models oceanic subduction in a 2d
+# box of 3000 x 670 km.
+# The subducting plate is driven by inflow boundary
+# conditions on the top part of the right boundary,
+# while a balancing outflow is prescribed underneath.
+# Only density and viscosity differ per composition.
+# High resolution is required to sufficiently resolve the weak zone
+# between the subducting and overriding plate, and consequently
+# 100 MPI processes are required.
+
+# We include a shared library for the trench location postprocessor.
+set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/libsubduction_plate_cooling.so
+
+# 2D
+set Dimension                              = 2
+
+# Run for 15 My
+set Start time                             = 0
+set End time                               = 15.01e6
+set CFL number                             = 0.5
+set Use years in output instead of seconds = true
+
+# Linear solver
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = output-Case1
+set Adiabatic surface temperature          = 0
+
+# We fix composition on the right boundary,
+# because we have inflow there.
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = right
+  set List of model names = initial composition
+end
+
+# We fix temperature on the top and bottom,
+# as well as on the right boundary because
+# we have inflow through the latter.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 0
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom, top
+  set Prescribed velocity boundary indicators = right x:function
+
+  subsection Function
+    set Function constants  = cm=100.0 #*3600.0*24.0*365.25
+    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
+                                 if(z>560000.0, -5.0/cm, \
+                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
+                              0
+    set Variable names      = x,z
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 200
+  set Time between checkpoint  = 0
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature         = 0.0
+    set Viscosity averaging scheme    = maximum composition
+
+    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
+    set Densities                     = 3200.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0
+    set Thermal conductivities        = 1
+  end
+end
+
+# The overriding plate (OP) and subducting plate (SP)
+# are each divided into three different layers:
+# a layer of Bulk Oceanic Composition (BOC),
+# a layer of Serpentinized HarzBurgite (SHB),
+# and a "thermal layer".
+
+subsection Compositional fields
+  set Number of fields = 7
+  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = Ax=1475600.0, Az=670000.0, \
+                              Bx=1500000.0, Bz=670000.0, \
+                              Cx=1358500.0, Cz=588000.0, \
+                              Dx=1382900.0, Dz=588000.0, \
+                              Ex=1530000.0, Ez=560000.0, \
+                              Fz=663000.0, Gz=662000.0, \
+                              Hz=631000.0, Iz=630000.0
+    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
+                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
+                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
+                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
+                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
+                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
+                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
+    set Variable names      = x,z
+  end
+end
+
+subsection Discretization
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent   = 3000e3
+    set Y extent   = 670e3
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We ignore any temperature effects
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0
+    set Variable names      = x,y,t
+  end
+end
+
+# The maximum refinement level will be 6+4 levels,
+# corresponding to a maximum resolution of ~700 m.
+subsection Mesh refinement
+  set Initial adaptive refinement              = 4
+  set Initial global refinement                = 6
+  set Minimum refinement level                 = 6
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = plus
+  set Coarsening fraction                      = 0.01
+  set Refinement fraction                      = 0.95
+  set Run postprocessors on initial refinement = false
+  set Skip solvers on initial refinement       = true
+  set Skip setup initial conditions on initial refinement = true
+  set Strategy                                 = minimum refinement function, viscosity
+  set Time steps between mesh refinement       = 16
+
+  subsection Minimum refinement function
+    set Coordinate system = depth
+    set Variable names = x,z,t
+    set Function constants = vel=150e3, L=100e3, crust=10e3
+    set Function expression = if(x<crust,10,if(x<L,9,if(x<vel,8,6)))
+  end
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, trench location
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, strain rate, error indicator
+    set Time between graphical output = 5e5
+  end
+
+  subsection Trench location
+    set Name of trench compositional field = BOC_OP
+  end
+
+  subsection Composition velocity statistics
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end time
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm
index b7c767ab9e4..121df4b9d5c 100644
--- a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm
+++ b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm
@@ -86,7 +86,7 @@ subsection Initial temperature model
 end
 
 subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
+  set List of postprocessors = visualization, velocity statistics, heating statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
 
   subsection Composition velocity statistics
     #Sum the velocities of the fields that make up the subducting plate.
diff --git a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm.bak b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm.bak
new file mode 100644
index 00000000000..b7c767ab9e4
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm.bak
@@ -0,0 +1,107 @@
+# This cookbook models oceanic subduction in a 2d
+# box of 3000 x 670 km.
+# The subducting plate is driven by inflow boundary
+# conditions on the top part of the right boundary,
+# while a balancing outflow is prescribed underneath.
+# Only density and viscosity differ per composition.
+# Building on case 1, an initial temperature field
+# based on the plate cooling model and
+# a mantle adiabatic gradient of 0.25 degrees/km
+# is prescribed, but temperature still does not affect
+# the material parameters.
+# High resolution is required to sufficiently resolve the weak zone
+# between the subducting and overriding plate, and consequently
+# 100 MPI processes are required.
+# We include a shared library for the initial temperature plugin and the isotherm depth, composition RMS temperature, and trench location postprocessors.
+set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/libsubduction_plate_cooling.so
+
+# 2D
+set Dimension                              = 2
+
+# Reuse parts of case 1
+include kinematically_driven_subduction_2d_case1.prm
+
+set Output directory                       = output-Case2a
+
+# We fix temperature on the top and bottom
+# as well as on the right boundary because
+# we have inflow through the latter.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, right
+  set List of model names = initial temperature
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature         = 473.15
+
+    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+    set Thermal conductivities        = 183.33,2.5,2.5,2.5,2.5,2.5,2.5,2.5
+    set Heat capacities               = 1250.0,750.0,750.0,750.0,750.0,1250.0,1250.0,750.0
+    set Thermal expansivities         = 0
+  end
+end
+
+# The overriding plate (OP) and subducting plate (SP)
+# are each divided into three different layers:
+# a layer of Bulk Oceanic Composition (BOC),
+# a layer of Serpentinized HarzBurgite (SHB),
+# and a "thermal layer".
+subsection Compositional fields
+  set Number of fields = 7
+  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = Ax=1475600.0, Az=670000.0, \
+                              Bx=1500000.0, Bz=670000.0, \
+                              Cx=1358500.0, Cz=588000.0, \
+                              Dx=1382900.0, Dz=588000.0, \
+                              Ex=1530000.0, Ez=560000.0, \
+                              Fz=663000.0, Gz=662000.0, \
+                              Hz=631000.0, Iz=630000.0
+    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
+                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
+                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
+                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
+                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
+                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
+                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
+    set Variable names      = x,z
+  end
+end
+
+# The initial temperature is prescribed through a plugin
+# and uses the plate cooling model for the temperature in both
+# plates (the plates have different ages) and an adiabatic
+# gradient of 0.25 degrees per km in the sublithospheric
+# mantle.
+subsection Initial temperature model
+  set List of model names = subduction plate cooling
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
+
+  subsection Composition velocity statistics
+    #Sum the velocities of the fields that make up the subducting plate.
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+
+  subsection Trench location
+    set Name of trench compositional field = BOC_OP
+  end
+
+  subsection Isotherm depth
+    set Isotherm value = 1073.15
+  end
+
+  subsection Composition RMS temperature statistics
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2b.prm.bak b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2b.prm.bak
new file mode 100644
index 00000000000..648bb11dc00
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2b.prm.bak
@@ -0,0 +1,38 @@
+# This setup is a modification of the file
+# kinematically_driven_subduction_2d_case2a.prm
+# to include temperature-dependent density.
+set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/libsubduction_plate_cooling.so
+
+# 2D
+set Dimension                              = 2
+
+# Reuse parts of case 2a
+include $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm
+
+set Output directory                       = output-Case2b
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    # The benchmark uses two different reference temperatures for the compositions:
+    # 1573.15 K for the asthenosphere, thermal_OP and thermal_SP, and 473.15 K for
+    # the rest of the compositions.
+    # As ASPECT only allows for one reference temperature, we have instead adapted
+    # the reference density for the mantle compositions. To do this, we took the initial
+    # temperature and the midpoint depth of the layers and equated the density equation
+    # using the benchmark reference density rho_0_1 (3200 kg/m3) and temperature T_0_1 (1573.15 K), and
+    # the density equation using the 473.15 K reference temperature to obtain the new reference density rho_0_2.
+    # For the left thermal layer, the initial temperature at the midpoint is 1355 K, so
+    # new reference density can be derived as follows:
+    # rho_0_1 * (1 - alpha * (T - T_0_1)) = rho_0_2 * (1 - alpha * (T - T_0_2)),
+    # 3200 * (1 - 2.5e-5 * (1355 - 1573.15)) = rho_0_2 * (1 - 2.5e-5 * (1355 - 473.15))
+    # rho_0_2 = 3290.66.
+    set Reference temperature         = 473.15
+    set Densities                     = 3290.66,3000.0,3000.0,3250.0,3250.0,3290.66,3290.66,3200.0
+
+    # Compared to Case 2a, thermal expansivity is no longer zero and therefore temperature
+    # feeds into the density and therefore the Stokes equations
+    set Thermal expansivities         = 2.5e-5
+  end
+end
diff --git a/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc.bak b/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc.bak
new file mode 100644
index 00000000000..27c7789308c
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc.bak
@@ -0,0 +1,100 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "subduction_plate_cooling.h"
+#include <aspect/geometry_model/box.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    double
+    SubductionPlateCooling<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // This initial condition only makes sense if the geometry is a
+      // box. Throw an error if that is not the case.
+      AssertThrow(Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
+                  ExcMessage("Subduction plate cooling initial temperature is not implemented "
+                             "for any other geometry model than a box. ") );
+
+      // Model domain is 3000 x 670 km.
+      // Geometry constants:
+      // surface temperature
+      const double Ts=273.15;
+      // temperature at the base of the plates
+      const double Tm = 1573.15;
+      // the base of the subducting plate at 110 km depth
+      const double y70 = -110000.0;
+      // the base of the overriding plate at 82 km depth
+      const double y40 = -82000.0;
+      // thermal diffusivity
+      const double kappa = 1.0e-6;
+      // the age of the subducting plate
+      const double t70 = 70e6 * year_in_seconds;
+      // the age of the overriding plate
+      const double t40 = 40e6 * year_in_seconds;
+
+      // the temperature to return
+      double temperature = 0.;
+
+      // Calculate the temperature in the portions of the model domain.
+      // overriding plate + subduction interface
+      if (position[0] < 1500000.0)
+        {
+          // lithosphere
+          if (position[1] >= 588000.0)
+            temperature=Ts+(Tm-Ts)*( ((position[1]-670000.0)/y40) + (2.0/numbers::PI)*(std::exp((-kappa*numbers::PI*numbers::PI*t40)/(y40*y40))*std::sin(numbers::PI*(position[1]-670000.0)/y40) +
+                                                                                       0.5*std::exp((-kappa*2.0*2.0*numbers::PI*numbers::PI*t40)/(y40*y40))*std::sin(2.0*numbers::PI*(position[1]-670000.0)/y40)));
+          // sublithospheric mantle
+          else
+            temperature=-0.25*(position[1]/1000.0)+1720.15;
+        }
+      // subducting plate
+      else
+        {
+          // lithosphere
+          if (position[1] >= 560000.0)
+            temperature=Ts+(Tm-Ts)*( ((position[1]-670000.0)/y70) + (2.0/numbers::PI)*(std::exp((-kappa*numbers::PI*numbers::PI*t70)/(y70*y70))*std::sin(numbers::PI*(position[1]-670000.0)/y70) +
+                                                                                       0.5*std::exp((-kappa*2.0*2.0*numbers::PI*numbers::PI*t70)/(y70*y70))*std::sin(2.0*numbers::PI*(position[1]-670000.0)/y70)));
+          // sublithospheric mantle
+          else
+            temperature=-0.25*(position[1]/1000.0)+1713.15;
+        }
+      return temperature;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(SubductionPlateCooling,
+                                              "subduction plate cooling",
+                                              "An initial temperature field as specified in Quinquis (2014) "
+                                              "using the plate cooling model to prescribe temperatures "
+                                              "for an overriding and a subducting plate. ")
+  }
+}
diff --git a/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.h.bak b/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.h.bak
new file mode 100644
index 00000000000..511abb2eb57
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.h.bak
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_subduction_plate_cooling_h
+#define _aspect_initial_temperature_subduction_plate_cooling_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that prescribes the initial temperature field according to the plate cooling model
+     * and plate geometries implemented in Quinquis (2014).
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class SubductionPlateCooling : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+    };
+  }
+}
+
+#endif
diff --git a/cookbooks/kinematically_driven_subduction_2d/trench_location.cc.bak b/cookbooks/kinematically_driven_subduction_2d/trench_location.cc.bak
new file mode 100644
index 00000000000..c0d283ca959
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/trench_location.cc.bak
@@ -0,0 +1,157 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "trench_location.h"
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    TrenchLocation<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the compositional element alone.
+      AssertThrow(this->introspection().n_compositional_fields > 0,
+                  ExcMessage("This postprocessor cannot be used without compositional fields."));
+      const Quadrature<dim - 1> &quadrature_formula = this->introspection().face_quadratures.compositional_fields;
+
+      FEFaceValues<dim>
+      fe_face_values(this->get_mapping(),
+                     this->get_fe(),
+                     quadrature_formula,
+                     update_values |
+                     update_quadrature_points |
+                     update_JxW_values);
+
+      const unsigned int n_q_points = fe_face_values.n_quadrature_points;
+
+      // Vector to store the values of the field that defines the trench.
+      std::vector<double> compositional_values_trench(n_q_points);
+      // Vector to store the positions of the quadrature points.
+      std::vector<Point<dim>> position_values(n_q_points);
+      // For each process, find the right most occurrence of the trench field.
+      double local_trench_location = 0.;
+
+      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+      // For cells with a face along the domain surface, compute the trench location
+      // by looping over these cells and if the trench field is present at a location
+      // further right than the current local_trench_location, set the local_trench_location
+      // to this new x-coordinate.
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          for (const unsigned int f : cell->face_indices())
+            if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
+              {
+                fe_face_values.reinit(cell,f);
+
+                position_values = fe_face_values.get_quadrature_points();
+
+                fe_face_values[this->introspection().extractors.compositional_fields[selected_field]].get_function_values(this->get_solution(), compositional_values_trench);
+
+                // Calculate the rightmost occurrence of the selected field per processor.
+                // A field is counted as present when its value is equal or higher than 0.5.
+                for (unsigned int q = 0; q < n_q_points; ++q)
+                  {
+                    if (compositional_values_trench[q] >= 0.5 && position_values[q][0] > local_trench_location)
+                      {
+                        local_trench_location = position_values[q][0];
+                      }
+                  }
+              }
+
+      // compute the rightmost point over all processors
+      const  double global_trench_location =
+        Utilities::MPI::max (local_trench_location, this->get_mpi_communicator());
+
+      statistics.add_value ("Trench location [m]", global_trench_location);
+
+      // also make sure that the other columns filled by the this object
+      // all show up with sufficient accuracy and in scientific notation
+      {
+        const char *columns[] = { "Trench location [m]"
+                                };
+        for (unsigned int i=0; i<sizeof(columns)/sizeof(columns[0]); ++i)
+          {
+            statistics.set_precision (columns[i], 8);
+            statistics.set_scientific (columns[i], true);
+          }
+      }
+
+      std::ostringstream output;
+      output.precision(4);
+      output << global_trench_location
+             << " m";
+      return std::pair<std::string, std::string> ("Trench location [m]:",
+                                                  output.str());
+    }
+
+    template <int dim>
+    void TrenchLocation<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Trench location");
+        {
+          prm.declare_entry("Name of trench compositional field", "",
+                            Patterns::Anything(),
+                            "The name of the trench compositional field that "
+                            "you want to compute the rightmost position for.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void TrenchLocation<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Trench location");
+        {
+          selected_field = this->introspection().compositional_index_for_name(prm.get("Name of trench compositional field"));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(TrenchLocation,
+                                  "trench location",
+                                  "A postprocessor that computes the trench location at the domain surface, "
+                                  "i.e., the rightmost point of a given compositional field at the surface.")
+  }
+}
diff --git a/cookbooks/kinematically_driven_subduction_2d/trench_location.h.bak b/cookbooks/kinematically_driven_subduction_2d/trench_location.h.bak
new file mode 100644
index 00000000000..49f7a64b40d
--- /dev/null
+++ b/cookbooks/kinematically_driven_subduction_2d/trench_location.h.bak
@@ -0,0 +1,75 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_trench_location_h
+#define _aspect_postprocess_trench_location_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that tracks the most left position of a certain compositional field.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class TrenchLocation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for the most left coordinate of the user-specified compositional field
+         * along the surface of the domain.
+         **/
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static void
+        declare_parameters(ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters(ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        unsigned int selected_field;
+    };
+  }
+}
+
+
+#endif
diff --git a/cookbooks/latent-heat/doc/material.part.prm.bak b/cookbooks/latent-heat/doc/material.part.prm.bak
new file mode 100644
index 00000000000..32723b2f727
--- /dev/null
+++ b/cookbooks/latent-heat/doc/material.part.prm.bak
@@ -0,0 +1,41 @@
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    # The change of density across the phase transition. Together with the
+    # Clapeyron slope, this is what determines the entropy change.
+    set Phase transition density jumps                 = 115.6
+    set Corresponding phase for density jump           = 0
+
+    # If the temperature is equal to the phase transition temperature, the
+    # phase transition will occur at the phase transition depth. However,
+    # if the temperature deviates from this value, the Clapeyron slope
+    # determines how much the pressure (and depth) of the phase boundary
+    # changes. Here, the phase transition will be in the middle of the box
+    # for T=T1.
+    set Phase transition depths                        = 500000
+    set Phase transition temperatures                  = 1000
+    set Phase transition Clapeyron slopes              = 1e7
+
+    # We set the width of the phase transition to 5 km. You may want to
+    # change this parameter to see how latent heating depends on the width
+    # of the phase transition.
+    set Phase transition widths                        = 5000
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 2.38
+
+    # We set the thermal expansion amd the compressibility to zero, so that
+    # all temperature (and density) changes are caused by advection, diffusion
+    # and latent heating.
+    set Thermal expansion coefficient                  = 0.0
+    set Compressibility                                = 0.0
+
+    # Viscosity is constant.
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 8.44e21
+    set Viscosity prefactors                           = 1.0, 1.0
+    set Composition viscosity prefactor                = 1.0
+  end
+end
diff --git a/cookbooks/latent-heat/latent-heat.prm.bak b/cookbooks/latent-heat/latent-heat.prm.bak
new file mode 100644
index 00000000000..b8b6bc2299c
--- /dev/null
+++ b/cookbooks/latent-heat/latent-heat.prm.bak
@@ -0,0 +1,145 @@
+############### Global parameters
+# We use a 2d setup. Since it takes some time for
+# the model to reach a steady state we set the
+# end time to approximately 15 billion years.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 5e17
+set Use years in output instead of seconds = false
+set Output directory                       = output-latent-heat
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Heating model
+  # As we only want to look at the effects of latent heating, we disable all
+  # the other heating terms.
+  set List of model names =  latent heat
+end
+
+############### Boundary conditions
+# We only fix the temperature at the upper boundary, the other boundaries
+# are isolating.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# To guarantuee a steady downward flow, we fix the velocity
+# at the top and bottom, and set it to free slip on the sides.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Function expression = 0;-2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0e3
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    # The change of density across the phase transition. Together with the
+    # Clapeyron slope, this is what determines the entropy change.
+    set Phase transition density jumps                 = 115.6
+    set Corresponding phase for density jump           = 0
+
+    # If the temperature is equal to the phase transition temperature, the
+    # phase transition will occur at the phase transition depth. However,
+    # if the temperature deviates from this value, the Clapeyron slope
+    # determines how much the pressure (and depth) of the phase boundary
+    # changes. Here, the phase transition will be in the middle of the box
+    # for T=T1.
+    set Phase transition depths                        = 500000
+    set Phase transition temperatures                  = 1000
+    set Phase transition Clapeyron slopes              = 1e7
+
+    # We set the width of the phase transition to 5 km. You may want to
+    # change this parameter to see how latent heating depends on the width
+    # of the phase transition.
+    set Phase transition widths                        = 5000
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 2.38
+
+    # We set the thermal expansion amd the compressibility to zero, so that
+    # all temperature (and density) changes are caused by advection, diffusion
+    # and latent heating.
+    set Thermal expansion coefficient                  = 0.0
+    set Compressibility                                = 0.0
+
+    # Viscosity is constant.
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 8.44e21
+    set Viscosity prefactors                           = 1.0, 1.0
+    set Composition viscosity prefactor                = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 7
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 5e17
+    set List of output variables      = density
+  end
+end
diff --git a/cookbooks/lower_crustal_flow/lower_crustal_flow_obstacle.prm.bak b/cookbooks/lower_crustal_flow/lower_crustal_flow_obstacle.prm.bak
new file mode 100644
index 00000000000..3136dab8c9b
--- /dev/null
+++ b/cookbooks/lower_crustal_flow/lower_crustal_flow_obstacle.prm.bak
@@ -0,0 +1,116 @@
+# A simple setup for a lower crustal flow around an obstacle in 3D based on Clark et al, GJI, 2005.
+
+############### Global parameters
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Output directory                       = output-lower-crustal-flow-obstacle
+set Pressure normalization                 = volume
+set Timing output frequency                = 0
+
+############### Parameters of the linear solver
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+    set Maximum number of expensive Stokes solver steps = 3000
+    set Stokes solver type = block GMG
+  end
+end
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1200e3
+    set Y extent  = 600e3
+    set Z extent  = 15e3
+    set X repetitions  = 10
+    set Y repetitions  = 5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+# first  material is lower crust
+# second material is obstacle
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = a=200e3
+    set Function expression = if ((x-600e3)^2+(y)^2 < a^2,1,0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Viscosity = 2e18
+    set Density differential for compositional field 1 = 10
+    set Composition viscosity prefactor = 1000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = front,back
+  set Zero velocity boundary indicators = bottom,top
+  set Prescribed velocity boundary indicators = left: function, right:function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = cm=0.01, year=1 , b=7.5e3
+    set Function expression =  8*cm/year*(1-((z-b)/b)^2) ; 0 ; 0
+  end
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Strategy                           = composition
+  set Initial adaptive refinement        = 0
+  set Refinement fraction                = 0.9
+  set Coarsening fraction                = 0.
+  set Minimum refinement level           = 1
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, pressure statistics
+
+  subsection Visualization
+    set Output format = vtu
+    set List of output variables = density, viscosity, strain rate
+    set Time between graphical output = 0
+  end
+end
diff --git a/cookbooks/magnetic_stripes/magnetic_stripes.cc b/cookbooks/magnetic_stripes/magnetic_stripes.cc
index 5a3cd1340f2..0c13a2b6ef9 100644
--- a/cookbooks/magnetic_stripes/magnetic_stripes.cc
+++ b/cookbooks/magnetic_stripes/magnetic_stripes.cc
@@ -63,7 +63,7 @@ namespace aspect
               break;
             }
 
-      for (unsigned int i=0; i < in.position.size(); ++i)
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
         {
           const double depth = this->get_geometry_model().depth(in.position[i]);
           const double reaction_depth = 7000.0;
diff --git a/cookbooks/magnetic_stripes/magnetic_stripes.cc.bak b/cookbooks/magnetic_stripes/magnetic_stripes.cc.bak
new file mode 100644
index 00000000000..5a3cd1340f2
--- /dev/null
+++ b/cookbooks/magnetic_stripes/magnetic_stripes.cc.bak
@@ -0,0 +1,153 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/composition_reaction.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class MagneticStripes : public MaterialModel::CompositionReaction<dim>
+    {
+      public:
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        static void declare_parameters (ParameterHandler &prm);
+        void parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        std::vector<double> reversal_times;
+    };
+
+
+    template <int dim>
+    void
+    MagneticStripes<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      CompositionReaction<dim>::evaluate(in, out);
+
+      int magnetic_orientation = 1;
+      if (this->simulator_is_past_initialization())
+        for (unsigned int i=0; i < reversal_times.size(); ++i)
+          if (this->get_time() < reversal_times[i])
+            {
+              // magnetic orientation is either 1 (normal) or -1 (reverse)
+              magnetic_orientation = -2 * (i % 2) + 1;
+              break;
+            }
+
+      for (unsigned int i=0; i < in.position.size(); ++i)
+        {
+          const double depth = this->get_geometry_model().depth(in.position[i]);
+          const double reaction_depth = 7000.0;
+
+          for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+            {
+              // Magnetic lineations are only generated when material approaches the surface,
+              // i.e. above the reaction depth and when the velocity is predominantly upwards.
+              if (depth < reaction_depth && in.velocity[i][1] > std::abs(in.velocity[i][0]))
+                out.reaction_terms[i][c] = -in.composition[i][0] + magnetic_orientation;
+              else
+                out.reaction_terms[i][c] = 0.0;
+            }
+        }
+    }
+
+    template <int dim>
+    void
+    MagneticStripes<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Magnetic stripes model");
+        {
+          CompositionReaction<dim>::declare_parameters (prm);
+
+          prm.declare_entry ("Reversal times", "5.0, 5.0, 2.0, 2.0, 2.092, 2.419, 2.419",
+                             Patterns::List(Patterns::Double(0)),
+                             "Reversal times of the magnetic field."
+                             "Units: yr or s, depending on the ``Use years "
+                             "in output instead of seconds'' parameter.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    MagneticStripes<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Magnetic stripes model");
+        {
+          CompositionReaction<dim>::parse_parameters (prm);
+
+          reversal_times = Utilities::string_to_double (Utilities::split_string_list(prm.get ("Reversal times")));
+          std::sort (reversal_times.begin(), reversal_times.end());
+
+          if (this->get_parameters().convert_to_years == true)
+            for (unsigned int i=0; i<reversal_times.size(); ++i)
+              reversal_times[i] *= constants::year_in_seconds;
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(MagneticStripes,
+                                   "magnetic stripes",
+                                   "A simple material model that is like the 'composition "
+                                   "reaction' model, but with a different reaction term. "
+                                   "In areas above a depth of 7 km and with a velocity that "
+                                   "does not diverge from vertically upwards by more than 45 "
+                                   "degrees, the first compositional field used in the model "
+                                   "is set to either one or minus one. The sign depends on a "
+                                   "list of reversal times that is passed to the material "
+                                   "model as an input. Before the 1st, 3rd, 5th, ... entry, "
+                                   "the sign is positive (magnetic normal orientation), and "
+                                   "before the 2nd, 4th, 6th, ... entry, the sign is negative "
+                                   "(magnetic reverse orientation). List entries are sorted "
+                                   "automatically in ascending order.")
+  }
+}
diff --git a/cookbooks/magnetic_stripes/magnetic_stripes.prm b/cookbooks/magnetic_stripes/magnetic_stripes.prm
index 4dc64baec60..feed74fb113 100644
--- a/cookbooks/magnetic_stripes/magnetic_stripes.prm
+++ b/cookbooks/magnetic_stripes/magnetic_stripes.prm
@@ -17,9 +17,9 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
     set Global composition maximum = 1
     set Global composition minimum = -1
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
@@ -107,7 +107,7 @@ end
 
 subsection Boundary composition model
   set Fixed composition boundary indicators = bottom
-  set Model name = initial composition
+  set List of model names = initial composition
 end
 
 subsection Material model
diff --git a/cookbooks/magnetic_stripes/magnetic_stripes.prm.bak b/cookbooks/magnetic_stripes/magnetic_stripes.prm.bak
new file mode 100644
index 00000000000..4dc64baec60
--- /dev/null
+++ b/cookbooks/magnetic_stripes/magnetic_stripes.prm.bak
@@ -0,0 +1,241 @@
+# A model of a mid-ocean ridge that shows how magnetic lineations
+# are created on the seafloor as the magnetic field changes its
+# orientation over time.
+
+
+set Additional shared libraries = ./libmagnetic_stripes.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 83.5e6
+set Use years in output instead of seconds = true
+set Output directory                       = output-magnetic-stripes
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+    set Global composition maximum = 1
+    set Global composition minimum = -1
+  end
+end
+
+############### Parameters describing the model
+# Let us here choose again a box domain (400 km wide and 100 km in depth)
+# where we fix the temperature at the bottom and top,
+# allow inflow from the bottom and outflow on the left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 400000
+    set Y extent = 100000
+    set X repetitions = 4
+    set Box origin X coordinate = -200000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1600
+    set Top temperature    = 293
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center of a mid-ocean ridge.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x:function, right x:function, top: function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = v=1, cm_per_year=0.02
+    set Function expression = if(x>0, v * cm_per_year, -v * cm_per_year); 0
+  end
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = left y:initial lithostatic pressure, right y:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Representative point = 0,0
+    set Number of integration points = 1000
+  end
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature as a constant (being equivalent to a
+# plate age of 0).
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1600
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 0
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = bottom
+  set Model name = initial composition
+end
+
+subsection Material model
+  set Model name = magnetic stripes
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1e23
+  end
+
+  subsection Magnetic stripes model
+    set Reversal times = \
+8.350E+07, 8.272E+07, \
+8.251E+07, 8.243E+07, \
+8.173E+07, 8.155E+07, \
+8.136E+07, 8.135E+07, \
+8.092E+07, 8.046E+07, \
+8.039E+07, 8.028E+07, \
+8.017E+07, 7.992E+07, \
+7.932E+07, 7.921E+07, \
+7.902E+07, 7.888E+07, \
+7.870E+07, 7.861E+07, \
+7.852E+07, 7.827E+07, \
+7.761E+07, 7.736E+07, \
+7.723E+07, 7.693E+07, \
+7.657E+07, 7.641E+07, \
+7.637E+07, 7.633E+07, \
+7.616E+07, 7.613E+07, \
+7.607E+07, 7.594E+07, \
+7.585E+07, 7.543E+07, \
+7.528E+07, 7.524E+07, \
+7.480E+07, 7.448E+07, \
+7.427E+07, 7.419E+07, \
+7.392E+07, 7.386E+07, \
+7.376E+07, 7.362E+07, \
+7.358E+07, 7.255E+07, \
+7.245E+07, 7.240E+07, \
+7.202E+07, 7.197E+07, \
+7.157E+07, 7.142E+07, \
+7.132E+07, 7.110E+07, \
+7.082E+07, 7.079E+07, \
+7.073E+07, 7.068E+07, \
+7.051E+07, 7.036E+07, \
+7.020E+07, 6.999E+07, \
+6.980E+07, 6.942E+07, \
+6.932E+07, 6.889E+07, \
+6.870E+07, 6.861E+07, \
+6.847E+07, 6.835E+07, \
+6.749E+07, 6.721E+07, \
+6.717E+07, 6.701E+07, \
+6.694E+07, 6.677E+07, \
+6.622E+07, 6.589E+07, \
+6.522E+07, 6.472E+07, \
+6.445E+07, 6.337E+07, \
+6.298E+07, 6.278E+07, \
+6.250E+07, 6.218E+07, \
+6.173E+07, 6.164E+07, \
+6.135E+07, 6.125E+07, \
+6.104E+07, 6.101E+07, \
+6.091E+07, 6.075E+07, \
+6.070E+07, 6.043E+07, \
+6.015E+07, 5.997E+07, \
+5.982E+07, 5.970E+07, \
+5.950E+07, 5.938E+07, \
+5.877E+07, 5.872E+07, \
+5.867E+07, 5.832E+07, \
+5.800E+07, 5.785E+07, \
+5.768E+07, 5.755E+07, \
+5.751E+07, 5.695E+07, \
+5.647E+07, 5.553E+07, \
+5.522E+07, 5.499E+07, \
+5.492E+07, 5.476E+07, \
+5.410E+07, 5.384E+07, \
+5.374E+07, 5.340E+07, \
+5.302E+07, 5.256E+07, \
+5.044E+07, 4.996E+07, \
+4.885E+07, 4.856E+07, \
+4.816E+07, 4.797E+07, \
+4.782E+07, 4.716E+07, \
+4.688E+07, 4.603E+07, \
+4.590E+07, 4.565E+07, \
+4.558E+07, 4.539E+07, \
+4.507E+07, 4.395E+07, \
+4.387E+07, 4.337E+07, \
+4.224E+07, 4.198E+07, \
+4.096E+07, 3.971E+07, \
+3.724E+07, 3.559E+07, \
+3.446E+07, 3.379E+07, \
+3.272E+07, 3.255E+07, \
+3.245E+07, 3.176E+07, \
+3.114E+07, 3.084E+07, \
+3.074E+07, 3.070E+07, \
+3.060E+07, 3.015E+07, \
+2.760E+07, 2.711E+07, \
+2.595E+07, 2.559E+07, \
+2.258E+07, 2.222E+07, \
+2.100E+07, 1.987E+07, \
+1.952E+07, 1.876E+07, \
+1.792E+07, 1.589E+07, \
+1.577E+07, 1.476E+07, \
+1.243E+07, 1.216E+07, \
+1.191E+07, 1.050E+07, \
+1.021E+07, 1.013E+07, \
+9.881E+06, 4.425E+06, \
+5.000E+05
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 4
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Variable names = depth, w
+    set Function expression = if(depth<7000,7,if(depth<10000,6,if(depth<30000,5,if(depth<45000,4,3))))
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e5
+    set List of output variables = density, heat flux map, vertical heat flux
+  end
+end
diff --git a/cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm.bak b/cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm.bak
new file mode 100644
index 00000000000..786751a5b6b
--- /dev/null
+++ b/cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm.bak
@@ -0,0 +1,210 @@
+# input file for model R of van der Wiel et al., 2024.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e9
+set Output directory                       = output-mantle-convection-annulus
+set World builder file                     = $ASPECT_SOURCE_DIR/cookbooks/mantle_convection_with_continents_in_annulus/world.wb
+set CFL number                             = 0.7
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 10
+set Nonlinear solver tolerance             = 1e-4
+set Timing output frequency                = 10
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 5000
+    set Maximum number of expensive Stokes solver steps = 0
+    set Linear solver tolerance = 1e-6
+  end
+end
+
+subsection Formulation
+  set Formulation = isentropic compression
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = 1_mantle, 3_continent
+  set Compositional field methods = particles, particles
+  set Mapped particle properties = 1_mantle: initial 1_mantle, 3_continent: initial 3_continent
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+subsection Material model
+  set Model name = compositing
+  set Material averaging = harmonic average only viscosity
+
+  subsection Visco Plastic
+    set Reference temperature = 1600
+    set Minimum viscosity     = 1e20
+    set Maximum viscosity     = 6e24
+    set Viscous flow law      = composite
+    set Minimum strain rate   = 1e-22
+    set Reference strain rate = 1e-15
+    set Heat capacities       = background: 1250, 1_mantle: 1250 | 1250 | 1250 , 3_continent: 1250
+    set Prefactors for dislocation creep          =  background:6.51e-16 ,  1_mantle: 6.51e-16| 8.51e-16 | 6.51e-16  ,  3_continent:6.51e-28
+    set Stress exponents for dislocation creep    =  background:1        ,  1_mantle: 3       | 3        | 1         ,  3_continent:       1
+    set Activation energies for dislocation creep =  background:540e3    ,  1_mantle: 500e3   | 500e3    | 530e3     ,  3_continent:   540e3
+    set Activation volumes for dislocation creep  =  background:18e-6    ,  1_mantle: 1.3e-5  | 1.3e-5   | 1.3e-5    ,  3_continent:   18e-6
+    set Prefactors for diffusion creep            =  background:6e-18    ,  1_mantle: 6e-17   | 9e-17    | 1e-18     ,  3_continent:   6e-20
+    set Grain size exponents for diffusion creep  =  background:1        ,  1_mantle: 1       | 1        | 3         ,  3_continent:       1
+    set Activation energies for diffusion creep   =  background:166e3    ,  1_mantle: 150e3   | 155e3    | 150e3     ,  3_continent:   166e3
+    set Activation volumes for diffusion creep    =  background:6.34e-7  ,  1_mantle: 6.34e-7 | 14.34e-7 | 12.34e-7  ,  3_continent: 6.34e-7
+    set Densities                                 =  background:3300     ,  1_mantle: 3300    | 3500     | 3800      ,  3_continent:    2900
+    set Grain size                                 =   1
+    set Angles of internal friction                =   1.43373998 , 1.43373998  , 30
+    set Cohesions                                  =   7e6        , 4e6,1e7
+    set Phase transition depths                        = 1_mantle: 410000 | 660000
+    set Phase transition temperatures                  = 1_mantle:   1700 | 1900
+    set Phase transition Clapeyron slopes              = 1_mantle:    3e6 | -2.5e6
+    set Phase transition widths                        = 1_mantle: 50000  | 50000
+    set Use adiabatic pressure in creep viscosity = true
+    set Constant viscosity prefactors                   = 1, 1, 1
+  end
+
+  subsection Latent heat
+    # The change of density across the phase transition. Together with the
+    # Clapeyron slope, this is what determines the entropy change.
+    set Phase transition density jumps                 = 273, 341
+    set Corresponding phase for density jump           = 1, 1
+
+    # If the temperature is equal to the phase transition temperature, the
+    # phase transition will occur at the phase transition depth. However,
+    # if the temperature deviates from this value, the Clapeyron slope
+    # determines how much the pressure (and depth) of the phase boundary
+    # changes. Here, the phase transition will be in the middle of the box
+    # for T=T1.
+    set Phase transition depths                        = 1_mantle: 410000 | 660000
+    set Phase transition temperatures                  = 1_mantle:   1700 | 1900
+    set Phase transition Clapeyron slopes              = 1_mantle:    3e6 | -2.5e6
+    set Phase transition widths                        = 1_mantle:  50000 | 50000
+    set Reference specific heat                        = 1250
+    set Thermal conductivity                           = 6
+    set Thermal expansion coefficient                  = 3e-5
+    set Viscosity prefactors                           = 1,1,1
+    set Density differential for compositional field 1 = 400
+    set Reference density                              = 2916
+  end
+
+  subsection Compositing
+    set Viscosity = visco plastic
+    set Density = latent heat
+    set Thermal expansion coefficient = latent heat
+    set Specific heat = latent heat
+    set Thermal conductivity = latent heat
+    set Compressibility = latent heat
+    set Entropy derivative pressure = latent heat
+    set Entropy derivative temperature = latent heat
+    set Reaction terms = latent heat
+  end
+end
+
+subsection Initial composition model
+  set Model name = world builder
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3480000
+    set Outer radius = 6370000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, outer
+end
+
+subsection Heating model
+  set List of model names = latent heat, adiabatic heating, constant heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+
+  subsection Constant heating
+    set Radiogenic heating rate = 5.44e-12
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = outer, inner
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Outer temperature = 300
+    set Inner temperature = 3700
+  end
+end
+
+subsection Initial temperature model
+  set Model name = world builder
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement       = 3
+  set Initial adaptive refinement     = 4
+  set Strategy                        = minimum refinement function, viscosity, velocity
+  set Time steps between mesh refinement = 1
+
+  subsection Minimum refinement function
+    set Coordinate system = spherical
+    set Function expression = if(r>6000e3, 6, if(r>5000e3,5,3))
+    set Variable names = r,phi,t
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, visualization, heat flux statistics, depth average, particles, Stokes residual, basic statistics, mobility statistics
+
+  subsection Global statistics
+    set Write statistics for each nonlinear iteration = true
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+    set Number of zones = 100
+  end
+
+  subsection Visualization
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set List of output variables = density, viscosity, strain rate, stress, temperature anomaly, spherical velocity components, adiabat, heat flux map, heating, vertical heat flux
+  end
+
+  subsection Particles
+    set Time between data output      = 1e6
+    set Data output format            = ascii, vtu
+    set Number of grouped files       = 1
+    set Write in background thread    = true
+  end
+end
+
+subsection Particles
+  set List of particle properties   = position, velocity, initial composition, pT path, initial position
+  set Update ghost particles        = true
+  set Particle generator name       = reference cell
+  set Load balancing strategy       = remove and add particles
+  set Minimum particles per cell    = 80
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 4
+    end
+  end
+end
diff --git a/cookbooks/mid_ocean_ridge/doc/boundary_conditions.part.prm.bak b/cookbooks/mid_ocean_ridge/doc/boundary_conditions.part.prm.bak
new file mode 100644
index 00000000000..2033c6387d3
--- /dev/null
+++ b/cookbooks/mid_ocean_ridge/doc/boundary_conditions.part.prm.bak
@@ -0,0 +1,34 @@
+##################### Velocity ########################
+
+# To model the divergent velocitiy field of a mid-ocean ridge, we prescribe
+# the plate velocity (pointing away from the ridge) at the top boundary.
+# We use a closed boundary with free slip conditions as the left boundary, which
+# marks the ridge axis and also acts as a center line for our model, so that
+# material can not cross this boundary.
+# We prescribe the velocity at the top boundary using a function:
+# At the ridge axis, the velocity is zero, at a distance of 10 km from the ridge
+# axis or more, the rigid plate uniformly moves away from the ridge with a constant
+# speed, and close to the ridge we interpolate between these two conditions.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function
+  set Tangential velocity boundary indicators = left
+
+  subsection Function
+    # We choose a half-spreading rate of u0=3cm/yr.
+    set Function constants  = u0=0.03, x0=10000
+    set Variable names      = x,z
+    set Function expression = if(x<x0,(1-(x/x0-1)*(x/x0-1))*u0,u0); 0
+  end
+end
+
+# We prescribe the lithostatic pressure as a boundary traction on
+# the bottom and right side of the model, so that material can flow in and out
+# according to the flow induced by the moving plate.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    # We calculate the pressure profile at the right model boundary.
+    set Representative point         = 105000, 70000
+  end
+end
diff --git a/cookbooks/mid_ocean_ridge/doc/compaction_length.part.prm.bak b/cookbooks/mid_ocean_ridge/doc/compaction_length.part.prm.bak
new file mode 100644
index 00000000000..6bd66a77358
--- /dev/null
+++ b/cookbooks/mid_ocean_ridge/doc/compaction_length.part.prm.bak
@@ -0,0 +1,23 @@
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.5
+  set Refinement fraction                      = 0.5
+
+  # Note that we allow for more adaptive refinements than before, as only cells
+  # with a small compaction length will be marked for refinement (as opposed to
+  # all melt cells), and we want to properly resolve the compaction length.
+  set Initial adaptive refinement              = 3
+  set Initial global refinement                = 4
+  set Strategy                                 = minimum refinement function, compaction length
+  set Time steps between mesh refinement       = 5
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Function expression = 4
+    set Variable names      = x,y
+  end
+
+  # We want the cells to be 8 times smaller than the compaction length.
+  subsection Compaction length
+    set Mesh cells per compaction length = 8.0
+  end
+end
diff --git a/cookbooks/mid_ocean_ridge/doc/melting_and_freezing.part.prm.bak b/cookbooks/mid_ocean_ridge/doc/melting_and_freezing.part.prm.bak
new file mode 100644
index 00000000000..4d9a34719b3
--- /dev/null
+++ b/cookbooks/mid_ocean_ridge/doc/melting_and_freezing.part.prm.bak
@@ -0,0 +1,38 @@
+##################### Melting and freezing ########################
+
+# Because the model includes reactions that might be on a faster time scale
+# than the time step of the model (melting and the freezing of melt), we use
+# the operator splitting scheme.
+set Use operator splitting                     = true
+
+subsection Solver parameters
+  subsection Operator splitting parameters
+    # We choose the size of the reaction time step as 200 years, small enough
+    # so that it can accurately model melting and freezing.
+    set Reaction time step                     = 2e2
+
+    # Additionally, we always want to do at least 10 operator splitting time
+    # steps in each model time step, to accurately compute the reactions.
+    set Reaction time steps per advection step = 10
+  end
+end
+
+# We use the melt simple material model that includes melting and freezing of
+# melt for an average mantle composition that is characteristic for a mid-ocean
+# ridge setting, and mainly use its default parameters.
+# In particular, we have to define how fast melting and freezing should be.
+# We assume that both reactions happen on a time scale of 200 years (or a rate
+# of 5e-3/year), which should be substantially shorter than the time step size,
+# so that the melt fraction will always be close to equilibrium.
+# As the model includes melting and freezing, we do not have to extract any melt.
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Reference permeability = 1e-7
+    set Melt extraction depth = 0.0
+    set Freezing rate         = 0.005
+    set Melting time scale for operator splitting = 2e2
+  end
+end
diff --git a/cookbooks/mid_ocean_ridge/doc/mesh_refinement.part.prm.bak b/cookbooks/mid_ocean_ridge/doc/mesh_refinement.part.prm.bak
new file mode 100644
index 00000000000..b8dca956331
--- /dev/null
+++ b/cookbooks/mid_ocean_ridge/doc/mesh_refinement.part.prm.bak
@@ -0,0 +1,28 @@
+##################### Mesh refinement #########################
+
+# We use adaptive mesh refinement to increase the resolution in regions where
+# melt is present, and otherwise use a uniform grid.
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.5
+  set Refinement fraction                      = 0.5
+
+  # A refinement level of 5 (4 global + 1 adaptive refinements) corresponds to
+  # a cell size of approximately 1 km.
+  set Initial adaptive refinement              = 1
+  set Initial global refinement                = 4
+  set Strategy                                 = minimum refinement function, composition threshold
+  set Time steps between mesh refinement       = 5
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Function expression = 4
+    set Variable names      = x,y
+  end
+
+  # We use a very small refinement threshold for the porosity to make sure that
+  # all cells where the two-phase flow equations are solved (melt cells) have
+  # the higher resolution.
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-6, 1.0
+  end
+end
diff --git a/cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm.bak b/cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm.bak
new file mode 100644
index 00000000000..f6975188a3d
--- /dev/null
+++ b/cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm.bak
@@ -0,0 +1,254 @@
+# 2d model for melting and melt transport at a mid-ocean ridge.
+# As the flow at mid-ocean ridges can be assumed to be roughly symmetric
+# with respect to the ridge axis in the center, we only model one half
+# of the ridge.
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 1570
+
+# Because our model includes melt transport, it is nonlinear and we have to
+# use an iterative solver scheme, that iterates between solving the temperature
+# composition and Stokes equations.
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = output-mid_ocean_ridge
+
+# The end time of the simulation. We want to run the model until it reaches
+# steady state, which is after approximately 6 million years.
+set End time                               = 8e6
+
+##################### Melting and freezing ########################
+
+# Because the model includes reactions that might be on a faster time scale
+# than the time step of the model (melting and the freezing of melt), we use
+# the operator splitting scheme.
+set Use operator splitting                     = true
+
+subsection Solver parameters
+  # Because this model includes strong localized viscosity contrasts we
+  # increase the robustness of the solver at the cost of memory consumption.
+  subsection Stokes solver parameters
+    set GMRES solver restart length = 200
+  end
+end
+
+# We use the melt simple material model that includes melting and freezing of
+# melt for an average mantle composition that is characteristic for a mid-ocean
+# ridge setting, and mainly use its default parameters.
+# In particular, we have to define how fast melting and freezing should be.
+# We assume that both reactions happen on a time scale of 200 years (or a rate
+# of 5e-3/year), which should be substantially shorter than the time step size,
+# so that the melt fraction will always be close to equilibrium.
+# As the model includes melting and freezing, we do not have to extract any melt.
+# We also slightly reduce the dependence of shear viscosity on the melt
+# fraction, because the model is relatively coarse and would otherwise develop
+# velocity oscillations in the region of highest melt content.
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Reference permeability = 1e-7
+    set Melt extraction depth = 0.0
+    set Freezing rate         = 0.005
+    set Melting time scale for operator splitting = 2e2
+    set Exponential melt weakening factor = 20
+  end
+end
+
+##################### Model geometry ########################
+
+# Our model geometry is a box of 105x70 km. This guarantees that inflowing
+# material is solid, and will start to melt within the model domain.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent      = 105000
+    set Y extent      = 70000
+
+    # To keep the aspect ratio of our elements close to one, we chose the
+    # coarse mesh is such a way that it has more elements in X than in Y
+    # direction, in the same ratio as the aspect ratio of the model.
+    set X repetitions = 3
+    set Y repetitions = 2
+  end
+end
+
+# The gravity is constant and points downward.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+##################### Velocity ########################
+
+# To model the divergent velocitiy field of a mid-ocean ridge, we prescribe
+# the plate velocity (pointing away from the ridge) at the top boundary.
+# We use a closed boundary with free slip conditions as the left boundary, which
+# marks the ridge axis and also acts as a center line for our model, so that
+# material can not cross this boundary.
+# We prescribe the velocity at the top boundary using a function:
+# At the ridge axis, the velocity is zero, at a distance of 10 km from the ridge
+# axis or more, the rigid plate uniformly moves away from the ridge with a constant
+# speed, and close to the ridge we interpolate between these two conditions.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function
+  set Tangential velocity boundary indicators = left
+
+  subsection Function
+    # We choose a half-spreading rate of u0=3cm/yr.
+    set Function constants  = u0=0.03, x0=10000
+    set Variable names      = x,z
+    set Function expression = if(x<x0,(1-(x/x0-1)*(x/x0-1))*u0,u0); 0
+  end
+end
+
+# We prescribe the lithostatic pressure as a boundary traction on
+# the bottom and right side of the model, so that material can flow in and out
+# according to the flow induced by the moving plate.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    # We calculate the pressure profile at the right model boundary.
+    set Representative point         = 105000, 70000
+  end
+end
+
+##################### Temperature ########################
+
+# As initial temperature, we choose an adiabatic profile with boundary layers at the
+# top and the bottom. We make the top boundary layer very old (100 Ma) so that in the
+# beginning, the material is still solid and the porosity is zero.
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 1e8
+    set Age bottom boundary layer   = 1e5
+    set Amplitude                   = 0
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+end
+
+# We choose a constant temperature at the top and bottom of the domain.
+# In particular, the bottom boundary temperature will control the steady state
+# temperature profile, and we choose a potential temperature of 1570 K (1300 °C).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 293
+    set Bottom temperature = 1570
+  end
+end
+
+# We want to include latent heat of melting and freezing in the model, as it is
+# an essential process for the temperature evolution, but as the model domain
+# is quite small and this is a simple model, we do not include any other sources
+# of heat.
+subsection Heating model
+  set List of model names = latent heat
+end
+
+# Melt moves with a different velocity than the solid, and transports energy,
+# so we include this process in the model.
+subsection Melt settings
+  # We want to solve the McKenzie Equations to track the flow of melt.
+  set Include melt transport = true
+  set Heat advection by melt = true
+end
+
+##################### Composition ########################
+
+# We need two compositional fields: The porosity field to track the motion of
+# melt, and the peridotite field to track the depletion of material, which is
+# changed by the melting and freezing reactions.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+# We set both fields to zero at the start of the model: The material is solid
+# (zero porosity) and has the average mantle composition (zero depletion).
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0; 0
+    set Variable names      = x,y
+  end
+end
+
+# The boundary conditions (which are relevant for material inflowing at the
+# bottom boundary of the model) are the same as the initial conditions.
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = bottom
+  set List of model names = initial composition
+end
+
+##################### Mesh refinement #########################
+
+# We use adaptive mesh refinement to increase the resolution in regions where
+# melt is present, and otherwise use a uniform grid.
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.5
+  set Refinement fraction                      = 0.5
+
+  # A refinement level of 5 (4 global + 1 adaptive refinements) corresponds to
+  # a cell size of approximately 1 km.
+  set Initial adaptive refinement              = 1
+  set Initial global refinement                = 4
+  set Strategy                                 = minimum refinement function, composition threshold
+  set Time steps between mesh refinement       = 5
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Function expression = 4
+    set Variable names      = x,y
+  end
+
+  # We use a very small refinement threshold for the porosity to make sure that
+  # all cells where the two-phase flow equations are solved (melt cells) have
+  # the higher resolution.
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-6, 1.0
+  end
+end
+
+##################### Postprocessing ########################
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics
+
+  # We mainly want to look at material properties of the solid and the melt.
+  subsection Visualization
+    set List of output variables      = material properties, melt material properties, melt fraction
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+
+    # To see in which cells melt transport is modelled, it can be useful to look
+    # at the property 'is melt cell', so we include it in the output. In addition,
+    # we always visualize the compaction pressure 'p_c' if this postprocessor is
+    # used.
+    subsection Melt material properties
+      set List of properties = compaction viscosity, permeability, fluid density, is melt cell
+    end
+  end
+end
+
+# We write a checkpoint every 100 time steps, so that we are able to restart
+# the computation from that point.
+subsection Checkpointing
+  set Steps between checkpoint = 100
+end
diff --git a/cookbooks/morency_doin_2004/doc/morency_doin.part.prm.bak b/cookbooks/morency_doin_2004/doc/morency_doin.part.prm.bak
new file mode 100644
index 00000000000..b4b29815824
--- /dev/null
+++ b/cookbooks/morency_doin_2004/doc/morency_doin.part.prm.bak
@@ -0,0 +1,59 @@
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent      = 3000e3
+    set Y extent      = 750e3
+    set X repetitions = 4
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields  = upper_crust, lower_crust
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = if(y>=725e3,1,0);if((y<725e3&y>700e3),1,0)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=750e3, w=3000e3, mantleT=1350 # deg C
+    set Function expression = \
+      if( y < 100e3, \
+        (100e3-y)/100e3*(1600-mantleT)+mantleT+293, \
+        if(y>650e3, \
+          (h-y)/(100e3)*mantleT+293, \
+          mantleT+293))
+  end
+end
+
+subsection Material model
+  set Model name = Morency and Doin
+
+  subsection Morency and Doin
+    set Densities = 3300,2920,2920
+    set Activation energies = 500,320,320
+    set Coefficient of yield stress increase with depth = 0.25
+    set Thermal expansivities = 3.5e-5
+    set Stress exponents for viscous rheology = 3
+    set Stress exponents for plastic rheology = 30
+    set Thermal diffusivity = 0.8e-6
+    set Heat capacity = 1.25e3
+    set Activation volume = 6.4e-6
+    set Reference strain rate = 6.4e-16
+    set Preexponential constant for viscous rheology law = 7e11 ## Value used in paper is 1.24e14
+    set Cohesive strength of rocks at the surface = 117
+    set Reference temperature = 293
+    set Minimum strain rate = 5e-19                             ## Value used in paper is 1.4e-20
+  end
+end
diff --git a/cookbooks/morency_doin_2004/morency_doin.cc.bak b/cookbooks/morency_doin_2004/morency_doin.cc.bak
new file mode 100644
index 00000000000..de787747673
--- /dev/null
+++ b/cookbooks/morency_doin_2004/morency_doin.cc.bak
@@ -0,0 +1,302 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "morency_doin.h"
+#include <aspect/geometry_model/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    MorencyDoin<dim>::
+    evaluate(const MaterialModelInputs<dim> &in,
+             MaterialModelOutputs<dim> &out) const
+    {
+      const double R = 8.32; // J mol-1 K-1
+      const double g = 9.8; // m s-2
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const Point<dim> position = in.position[i];
+          const double temperature = in.temperature[i];
+          const std::vector<double> composition = in.composition[i];
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(composition);
+
+          SymmetricTensor<2,dim> strain_rate;
+          if (in.requests_property(MaterialProperties::viscosity))
+            strain_rate = in.strain_rate[i];
+
+          const double depth = this->get_geometry_model().depth(position); // Units: \\si{\\meter}
+
+          // Calculate viscosity
+          {
+            double activation_energy = 0.0;
+            for (unsigned int j=0; j < volume_fractions.size(); ++j)
+              activation_energy += volume_fractions[j] * activation_energies[j] * 1e3; // Converted to J/mol to make units work
+            double nv = 0.0;
+            for (unsigned int j=0; j < volume_fractions.size(); ++j)
+              nv += volume_fractions[j] * nvs[j];
+            double np = 0.0;
+            for (unsigned int j=0; j < volume_fractions.size(); ++j)
+              np += volume_fractions[j] * nps[j];
+
+            const double tauy = tau_0 + gamma*densities[0]*g*depth;
+
+            /**
+             * Note: The actual second invariant of strain rate is defined as $e_{00}e_{11} - e_{01}^2$,
+             * (maybe times 1/2 depending on the convention) where e is the second order strain rate
+             * tensor. The function used here reflects the equations defined in (Morency and Doin, 2004)
+             * but is otherwise unjustified. Use at your own risk.
+             */
+            const double e2inv = std::sqrt((strain_rate[0][0]*strain_rate[0][0] + strain_rate[0][1]*strain_rate[0][1])/2.0);
+
+            const double edot = std::sqrt(std::pow(e2inv,2) + std::pow(min_strain_rate,2));
+
+            // Calculate 1/(v_eff^v) and 1/(v_eff^p)
+            double one_over_veffv = 0.0;
+            if (temperature != 0.0)
+              one_over_veffv = 1.0 / (B * std::pow(edot/ref_strain_rate, -1.0+1.0/nv))
+                               * std::exp(-(activation_energy+activation_volume*densities[0]*g*depth)/(nv*R*temperature));
+            const double one_over_veffp = 1.0 / (tauy * (std::pow(edot, -1.0+1.0/np) / std::pow(ref_strain_rate, 1.0/np)));
+            // Effective viscosity = harmonic mean of diffusion and dislocation creep.
+            // = (1/(v_eff^v) + 1/(v_eff^p))^-1
+            const double veff = std::pow((one_over_veffv + one_over_veffp), -1.0);
+
+            out.viscosities[i] = veff;
+          }
+
+          // Calculate density
+          {
+            double density = 0.0;
+            for (unsigned int j=0; j < volume_fractions.size(); ++j)
+              {
+                // not strictly correct if thermal expansivities are different, since we are interpreting
+                // these compositions as volume fractions, but the error introduced should not be too bad.
+                const double temperature_factor = (1.0 - thermal_expansivities[j] * (temperature - reference_T));
+                density += volume_fractions[j] * densities[j] * temperature_factor;
+              }
+            out.densities[i] = density;
+          }
+
+          // Thermal expansion coefficients at the given positions.
+          double thermal_expansivity = 0.0;
+          for (unsigned int j=0; j < volume_fractions.size(); ++j)
+            thermal_expansivity += volume_fractions[j] * thermal_expansivities[j];
+          out.thermal_expansion_coefficients[i] = thermal_expansivity;
+          // Specific heat at the given positions.
+          out.specific_heat[i] = heat_capacity;
+          // Thermal conductivity at the given positions.
+          out.thermal_conductivities[i] = thermal_diffusivity * heat_capacity * out.densities[i];
+          // Compressibility at the given positions.
+          // The compressibility is given as
+          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
+          out.compressibilities[i] = 0.0;
+          // Pressure derivative of entropy at the given positions.
+          out.entropy_derivative_pressure[i] = 0.0;
+          // Temperature derivative of entropy at the given positions.
+          out.entropy_derivative_temperature[i] = 0.0;
+          // Change in composition due to chemical reactions at the
+          // given positions. The term reaction_terms[i][c] is the
+          // change in compositional field c at point i.
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+    template <int dim>
+    bool
+    MorencyDoin<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    MorencyDoin<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Morency and Doin");
+        {
+          prm.declare_entry ("Densities", "3300.",
+                             Patterns::List(Patterns::Double(0.)),
+                             "List of densities, $\\rho$, for background mantle and compositional fields,"
+                             "for a total of N+1 values, where N is the number of compositional fields."
+                             "If only one value is given, then all use the same value. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}");
+          prm.declare_entry ("Activation energies", "500.",
+                             Patterns::List(Patterns::Double(0.)),
+                             "List of activation energies, $E_a$, for background mantle and compositional fields,"
+                             "for a total of N+1 values, where N is the number of compositional fields."
+                             "If only one value is given, then all use the same value.  Units: \\si{\\kilo\\joule\\per\\mole}");
+          prm.declare_entry ("Thermal expansivities", "3.5e-5",
+                             Patterns::List(Patterns::Double(0.)),
+                             "List of thermal expansivities for background mantle and compositional fields,"
+                             "for a total of N+1 values, where N is the number of compositional fields."
+                             "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}");
+          prm.declare_entry ("Stress exponents for viscous rheology", "3.",
+                             Patterns::List(Patterns::Double(0.)),
+                             "List of stress exponents, $n_v$, for background mantle and compositional fields,"
+                             "for a total of N+1 values, where N is the number of compositional fields."
+                             "If only one value is given, then all use the same value.  Units: None");
+          prm.declare_entry ("Stress exponents for plastic rheology", "30.",
+                             Patterns::List(Patterns::Double(0.)),
+                             "List of stress exponents, $n_p$, for background mantle and compositional fields,"
+                             "for a total of N+1 values, where N is the number of compositional fields."
+                             "If only one value is given, then all use the same value.  Units: None");
+          prm.declare_entry ("Thermal diffusivity", "0.8e-6", Patterns::Double(0),
+                             "Units: \\si{\\meter\\squared\\per\\second}");
+          prm.declare_entry ("Heat capacity", "1.25e3", Patterns::Double(0),
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}");
+          prm.declare_entry ("Activation volume", "6.4e-6", Patterns::Double(0), "($V_a$). Units: \\si{\\meter\\cubed\\per\\mole}");
+          prm.declare_entry ("Reference strain rate", "6.4e-16", Patterns::Double(0), "($\\dot{\\epsilon}_\\text{ref}$). Units: \\si{\\per\\second}");
+          prm.declare_entry ("Preexponential constant for viscous rheology law", "1.24e14", Patterns::Double(0.), "($B$). Units: None");
+          prm.declare_entry ("Coefficient of yield stress increase with depth", "0.25", Patterns::Double(0.), "($\\gamma$). Units: None");
+          prm.declare_entry ("Cohesive strength of rocks at the surface", "117.", Patterns::Double(0.), "($\\tau_0$). Units: \\si{\\pascal}");
+          prm.declare_entry ("Reference temperature", "293.", Patterns::Double(0.), "For calculating density by thermal expansivity. Units: \\si{\\kelvin}");
+          prm.declare_entry ("Minimum strain rate", "1.4e-20", Patterns::Double(0.), "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    MorencyDoin<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // increment by one for background:
+      const unsigned int n_fields = this->n_compositional_fields() + 1;
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Morency and Doin");
+        {
+          gamma = prm.get_double("Coefficient of yield stress increase with depth");
+          thermal_diffusivity = prm.get_double("Thermal diffusivity");
+          heat_capacity = prm.get_double("Heat capacity");
+          activation_volume = prm.get_double("Activation volume");
+          ref_strain_rate = prm.get_double("Reference strain rate");
+          B = prm.get_double("Preexponential constant for viscous rheology law");
+          tau_0 = prm.get_double ("Cohesive strength of rocks at the surface");
+          min_strain_rate = prm.get_double("Minimum strain rate");
+          reference_T = prm.get_double("Reference temperature");
+
+          std::vector<double> x_values;
+
+          // Parse densities
+          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Densities")));
+          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
+                      ExcMessage("Length of density list must be either one, or n_compositional_fields+1"));
+          if (x_values.size() == 1)
+            densities.assign( n_fields , x_values[0]);
+          else
+            densities = x_values;
+
+          // Parse activation energies
+          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Activation energies")));
+          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
+                      ExcMessage("Length of activation energy list must be either one, or n_compositional_fields+1"));
+          if (x_values.size() == 1)
+            activation_energies.assign( n_fields , x_values[0] );
+          else
+            activation_energies = x_values;
+
+          // Parse thermal expansivities
+          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Thermal expansivities")));
+          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
+                      ExcMessage("Length of thermal expansivity list must be either one, or n_compositional_fields+1"));
+          if (x_values.size() == 1)
+            thermal_expansivities.assign( n_fields , x_values[0]);
+          else
+            thermal_expansivities = x_values;
+
+          // Parse stress exponents
+          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Stress exponents for viscous rheology")));
+          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
+                      ExcMessage("Length of nv list must be either one, or n_compositional_fields+1"));
+          if (x_values.size() == 1)
+            nvs.assign( n_fields , x_values[0]);
+          else
+            nvs = x_values;
+          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Stress exponents for plastic rheology")));
+          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
+                      ExcMessage("Length of np list must be either one, or n_compositional_fields+1"));
+          if (x_values.size() == 1)
+            nps.assign( n_fields , x_values[0]);
+          else
+            nps = x_values;
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(MorencyDoin,
+                                   "Morency and Doin",
+                                   "An implementation of the visco-plastic rheology described by Morency "
+                                   "and Doin in \\cite{MD04}. Compositional fields can each be assigned individual "
+                                   "activation energies, reference densities, thermal expansivities, and "
+                                   "stress exponents. The effective viscosity is defined as "
+                                   "\\[v_\\text{eff} = \\left(\\frac{1}{v_\\text{eff}^v}+\\frac{1}{v_\\text{eff}^p}\\right)^{-1}\\] "
+                                   "where "
+                                   "\\[v_\\text{eff}^v = B \\left(\\frac{\\dot{\\epsilon}}{\\dot{\\epsilon}_\\text{ref}} "
+                                   "\\right)^{-1+1/n_v} exp\\left(\\frac{E_a +V_a \\rho_m g z}{n_v R T}\\right) \\] "
+                                   "\\[v_\\text{eff}^p = (\\tau_0 + \\gamma \\rho_m g z) \\left( \\frac{\\dot{\\epsilon}^{-1+1/n_p}} "
+                                   "{\\dot{\\epsilon}_\\text{ref}^{1/n_p}} \\right) \\] "
+                                   "where $B$ is a scaling constant; $\\dot{\\epsilon}$ is defined as "
+                                   "the quadratic sum of the second invariant of the strain rate tensor and "
+                                   "a minimum strain rate, $\\dot{\\epsilon}_0$; $\\dot{\\epsilon}_\\text{ref}$ "
+                                   "is a reference strain rate; $n_v$, and $n_p$ are stress exponents; $E_a$ "
+                                   "is the activation energy; $V_a$ is the activation volume; $\\rho_m$ is the "
+                                   "mantle density; $R$ is the gas constant; $T$ is temperature; $\\tau_0$ is "
+                                   "the cohesive strength of rocks at the surface; $\\gamma$ is a coefficient "
+                                   "of yield stress increase with depth; and $z$ is depth. "
+                                   "\n\n"
+                                   "\\note{Morency and Doin define the second invariant of the strain "
+                                   "rate in a nonstandard way (see \\cite{MD04}. The formulation in the paper is given as "
+                                   "$\\epsilon_{II} = \\sqrt{\\frac{1}{2} (\\epsilon_{11}^2 +"
+                                   "\\epsilon_{12}^2)}$ where $\\epsilon$ is the strain rate tensor. "
+                                   "For consistency, that is also the formulation implemented in this material model.}"
+                                   "\n\n"
+                                   "The value for the components of this formula and additional parameters are "
+                                   "read from the parameter file in subsection 'Material model/Morency and Doin'.")
+  }
+}
diff --git a/cookbooks/morency_doin_2004/morency_doin.h.bak b/cookbooks/morency_doin_2004/morency_doin.h.bak
new file mode 100644
index 00000000000..11c0b6cd534
--- /dev/null
+++ b/cookbooks/morency_doin_2004/morency_doin.h.bak
@@ -0,0 +1,125 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_morency_doin_h
+#define _aspect_material_model_morency_doin_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <deal.II/base/parameter_handler.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model based on the rheology described in (Morency and Doin,
+     * 2004): Brittle-ductile rheology with a viscosity strongly depending on
+     * temperature and composition. Using pseudo-brittle rheology limits the
+     * strength of the lithosphere at low temperature.
+     *
+     * The effective viscosity is defined as the harmonic mean of two stress-
+     * dependent viscosity functions: a simple temperature/pressure-dependent,
+     * non-Newtonian viscosity, and a more strongly stress-dependent,
+     * "plastic" viscosity.
+     *
+     * @f[ v_{eff}^v = B \left(\frac{\dot{\varepsilon}}{\dot{\varepsilon}_{ref}}\right)^{-1+1/n_v}
+     * exp\left(\frac{E_a +V_a \rho_m g z}{n_v R T}\right) @f]
+     * @f[ v_{eff}^p = (\tau_0 + \gamma \rho_m g z) \left( \frac{\dot{\varepsilon}^{-1+1/n_p}}
+     * {\dot{\varepsilon}_{ref}^{1/n_p}} \right) @f]
+     * @f[ v_{eff} = \left(\frac{1}{v_{eff}^v}+\frac{1}{v_{eff}^p}\right)^{-1} @f]
+     *
+     * Where $v_{eff}$ is the effective viscosity, $B$ is a scaling constant,
+     * $\dot{\varepsilon}$ is related to the second invariant of the strain
+     * rate tensor, $\dot{\varepsilon}_{ref}$ is a reference strain rate,
+     * $n_v$ and $n_p$ are stress exponents, $E_a$ is the activation energy,
+     * $V_a$ is the activation volume, $\rho_m$ is the mantle density, $R$ is
+     * the gas constant, $T$ is temperature, $\tau_0$ is the cohesive
+     * strength of rocks at the surface, $\gamma$ is a coefficient of yield
+     * stress increase with depth, and $z$ is depth.
+     *
+     * Several model parameters (reference densities, activation energies,
+     * thermal expansivities, and stress exponents-- both viscous and plastic)
+     * can be defined per-compositional field. If a list of values is given
+     * for any of these parameters, the weighted sum of the values based on
+     * volume fractions of the compositional fields is used in their place. If
+     * only one value is given for any of these parameters, all compositions
+     * are assigned the same value. The first value in the list is the value
+     * assigned to "background mantle" (regions where the sum of the
+     * compositional fields is < 1.0).
+     *
+     * For more on the material model and its applications, see: Morency, C.,
+     * and M‐P. Doin. "Numerical simulations of the mantle lithosphere
+     * delamination." Journal of Geophysical Research: Solid Earth
+     * (1978–2012) 109.B3 (2004)
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class MorencyDoin : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Evaluate material properties.
+         */
+        void evaluate(const MaterialModelInputs<dim> &in,
+                      MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        std::vector<double> densities;
+        std::vector<double> activation_energies;
+        std::vector<double> thermal_expansivities;
+        std::vector<double> nvs; // Stress exponent, viscous rheology
+        std::vector<double> nps;//Stress exponent, plastic rheology
+        double thermal_diffusivity;
+        double gamma; // Coefficient of yield stress increase with depth
+        double heat_capacity;
+        double activation_volume;
+        double ref_strain_rate;
+        double B; // Preexponential constant in the viscous rheology law B
+        double tau_0; // cohesive strength of rocks at the surface
+        double reference_T;
+        double min_strain_rate;
+    };
+
+  }
+}
+
+#endif
diff --git a/cookbooks/morency_doin_2004/morency_doin.prm b/cookbooks/morency_doin_2004/morency_doin.prm
index 40880818d7c..951205a24ca 100644
--- a/cookbooks/morency_doin_2004/morency_doin.prm
+++ b/cookbooks/morency_doin_2004/morency_doin.prm
@@ -103,7 +103,7 @@ end
 
 subsection Solver parameters
   subsection Stokes solver parameters
-      set Stokes solver type = block AMG
+    set Stokes solver type = block AMG
   end
 end
 
diff --git a/cookbooks/morency_doin_2004/morency_doin.prm.bak b/cookbooks/morency_doin_2004/morency_doin.prm.bak
new file mode 100644
index 00000000000..40880818d7c
--- /dev/null
+++ b/cookbooks/morency_doin_2004/morency_doin.prm.bak
@@ -0,0 +1,113 @@
+set Dimension = 2
+set Maximum time step = 1e4
+set Nonlinear solver scheme = iterated Advection and Stokes
+set Output directory = output-morency_doin
+set Additional shared libraries            = ./libmorency_doin.so
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent      = 3000e3
+    set Y extent      = 750e3
+    set X repetitions = 4
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom, left, right
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields  = upper_crust, lower_crust
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = if(y>=725e3,1,0);if((y<725e3&y>700e3),1,0)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=750e3, w=3000e3, mantleT=1350 # deg C
+    set Function expression = \
+      if( y < 100e3, \
+        (100e3-y)/100e3*(1600-mantleT)+mantleT+293, \
+        if(y>650e3, \
+          (h-y)/(100e3)*mantleT+293, \
+          mantleT+293))
+  end
+end
+
+subsection Material model
+  set Model name = Morency and Doin
+
+  subsection Morency and Doin
+    set Densities = 3300,2920,2920
+    set Activation energies = 500,320,320
+    set Coefficient of yield stress increase with depth = 0.25
+    set Thermal expansivities = 3.5e-5
+    set Stress exponents for viscous rheology = 3
+    set Stress exponents for plastic rheology = 30
+    set Thermal diffusivity = 0.8e-6
+    set Heat capacity = 1.25e3
+    set Activation volume = 6.4e-6
+    set Reference strain rate = 6.4e-16
+    set Preexponential constant for viscous rheology law = 7e11 ## Value used in paper is 1.24e14
+    set Cohesive strength of rocks at the surface = 117
+    set Reference temperature = 293
+    set Minimum strain rate = 5e-19                             ## Value used in paper is 1.4e-20
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = initial temperature
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Mesh refinement
+  set Initial global refinement                 = 5
+  set Initial adaptive refinement               = 3
+  set Strategy                                  = minimum refinement function
+
+  subsection Minimum refinement function
+    set Variable names = d,ignored
+    set Function expression = if(d<100e3,8,5)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Number of zones = 500
+    set Output format = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+      set Stokes solver type = block AMG
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 0
+end
diff --git a/cookbooks/multicomponent_steinberger/doc/comp.field.prm.bak b/cookbooks/multicomponent_steinberger/doc/comp.field.prm.bak
new file mode 100644
index 00000000000..bbefd054421
--- /dev/null
+++ b/cookbooks/multicomponent_steinberger/doc/comp.field.prm.bak
@@ -0,0 +1,5 @@
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields  = basalt_fraction
+  set Types of fields  = chemical composition
+end
diff --git a/cookbooks/multicomponent_steinberger/doc/comp.setup.prm.bak b/cookbooks/multicomponent_steinberger/doc/comp.setup.prm.bak
new file mode 100644
index 00000000000..6e2f96548cd
--- /dev/null
+++ b/cookbooks/multicomponent_steinberger/doc/comp.setup.prm.bak
@@ -0,0 +1,12 @@
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system   = cartesian
+    set Variable names      = x, y
+    set Function constants  = a=2744.3e3, size=400e3, k=-7e-7, c=2.9367
+    set Function expression = ( (sqrt(x^2+y^2)>=3981.e3 && (x-a)^2+(y-a)^2<=size^2) ? (0.15) : \
+                              (sqrt(x^2+y^2)<3981.e3 && sqrt(x^2+y^2)>=3481.e3) ? \
+                              (c+k*sqrt(x^2+y^2)) : (0) )
+  end
+end
diff --git a/cookbooks/multicomponent_steinberger/doc/conductivity.setup.prm.bak b/cookbooks/multicomponent_steinberger/doc/conductivity.setup.prm.bak
new file mode 100644
index 00000000000..d13e458712c
--- /dev/null
+++ b/cookbooks/multicomponent_steinberger/doc/conductivity.setup.prm.bak
@@ -0,0 +1,7 @@
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Thermal conductivity formulation = p-T-dependent
+  end
+end
diff --git a/cookbooks/multicomponent_steinberger/doc/lookup.part.prm.bak b/cookbooks/multicomponent_steinberger/doc/lookup.part.prm.bak
new file mode 100644
index 00000000000..2b260351220
--- /dev/null
+++ b/cookbooks/multicomponent_steinberger/doc/lookup.part.prm.bak
@@ -0,0 +1,10 @@
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names              = pyr_MS95_with_volume_fractions_lo_res.dat, \
+                                           morb_G13_with_volume_fractions_lo_res.dat\
+  end
+  end
+end
diff --git a/cookbooks/multicomponent_steinberger/doc/temperature.setup.prm.bak b/cookbooks/multicomponent_steinberger/doc/temperature.setup.prm.bak
new file mode 100644
index 00000000000..0a93b17b41d
--- /dev/null
+++ b/cookbooks/multicomponent_steinberger/doc/temperature.setup.prm.bak
@@ -0,0 +1,26 @@
+subsection Initial temperature model
+  set List of model operators = add
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+    set Age bottom boundary layer = 7e8
+
+    subsection Function
+      set Function constants  = k=-7e-7, c=2.9367
+      set Variable names      = x, y
+
+      # if Number of fields = 2, there should be two function expressions
+      set Function expression = (sqrt(x^2+y^2)<3981.e3 ? c+k*sqrt(x^2+y^2) : 0 )
+    end
+  end
+
+  subsection Function
+    set Coordinate system   = cartesian
+    set Variable names      = x, y
+    set Function constants  = Tex=450, a=2744.3e3, size=400e3, Tb=3550, Tab=2663.3, age=2.208e16, kappa=1.16e-6,
+    set Function expression = ( ((x-a)^2+(y-a)^2<=size^2) ? \
+                               ( max(Tex - (Tb-Tab)*erfc( (-3481e3 + sqrt(x^2+y^2)) /2/sqrt(kappa*age) ),0) ) : \
+                              (0) )
+  end
+end
diff --git a/cookbooks/multicomponent_steinberger/steinberger_thermochemical_plume.prm.bak b/cookbooks/multicomponent_steinberger/steinberger_thermochemical_plume.prm.bak
new file mode 100644
index 00000000000..1a8508145cd
--- /dev/null
+++ b/cookbooks/multicomponent_steinberger/steinberger_thermochemical_plume.prm.bak
@@ -0,0 +1,166 @@
+# This is a cookbook of modeling a thermochemical plumes using the  multicomponent
+# Steinberger material model. The model setup is similar to Dannberg and Sobolev (2015).
+
+set Output directory                       = output-multicomponent-steinberger
+set CFL number                             = 1.0
+set End time                               = 3e8
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+set Maximum first time step                = 1.e4
+
+# Multiple composition setup
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields  = basalt_fraction
+  set Types of fields  = chemical composition
+end
+
+# Prescribe the initial composition.
+# The setup is similar to Supplementary Figure 2b (Dannberg and Sobolev, 2015)
+# The constants used in the function:
+# a = coordinate of the center of the circular compositional anomaly
+# size = radius of the compositional anomaly
+# k, c = slope and intercept determine the fraction of eclogite change with depth
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system   = cartesian
+    set Variable names      = x, y
+    set Function constants  = a=2744.3e3, size=400e3, k=-7e-7, c=2.9367
+    set Function expression = ( (sqrt(x^2+y^2)>=3981.e3 && (x-a)^2+(y-a)^2<=size^2) ? (0.15) : \
+                              (sqrt(x^2+y^2)<3981.e3 && sqrt(x^2+y^2)>=3481.e3) ? \
+                  (c+k*sqrt(x^2+y^2)) : (0) )
+  end
+end
+
+# The Material model setup is similar to "steinberger.prm" except we have
+# N+1 material file for N compositional fields. The material files are ordered as
+# "background, field#1, field#2, ..."
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names              = pyr_MS95_with_volume_fractions_lo_res.dat, \
+             morb_G13_with_volume_fractions_lo_res.dat
+    set Lateral viscosity file name      = temp-viscosity-prefactor.txt
+    set Radial viscosity file name       = radial-visc-simple.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+
+    # We are using default pressure-temperature dependent thermal conductivity.
+    set Thermal conductivity formulation = p-T-dependent
+
+    # You must set this to false to avoid step-wise viscosity inherited
+    # from the reference profile "radial-visc-simple.txt".
+    set Use lateral average temperature for viscosity = false
+  end
+end
+
+# Prescribe the initial temperature.
+# Here we are using half-space cooling model to set up a 50 Ma top boundary
+# layer and a 700 Ma bottom boundary layer. The setup of the plume excess
+# temperature is similar to Supplementary Figure 2a (Dannberg and Sobolev, 2015)
+# and is described by the function. All the expressions in the boundary
+# temperature model and the function are added to the adiabatic temperature
+# profile because we set the model operators as "add". You can also use
+# "subtract, minimum, maximum, replace if valid".
+
+# The constants used in the function:
+#  Tex = plume excess temperature
+#  Tb = bottom temperature
+#  Tab = the adiabatic bottom temperature, should be consistent with the
+#       adiabatic surfacetemperature of the model.
+#  age = must be consistent with the "Age bottom boundary layer" in seconds
+#  kappa = should be consistent with the characteristic Cp, rho, and k around
+#        the CMB
+subsection Initial temperature model
+  set List of model operators = add
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+    set Age bottom boundary layer = 7e8
+
+    subsection Function
+      set Function constants  = k=-7e-7, c=2.9367
+      set Variable names      = x, y
+
+      # if Number of fields = 2, there should be two function expressions
+      set Function expression = (sqrt(x^2+y^2)<3981.e3 ? c+k*sqrt(x^2+y^2) : 0 )
+    end
+  end
+
+  subsection Function
+    set Coordinate system   = cartesian
+    set Variable names      = x, y
+    set Function constants  = Tex=450, a=2744.3e3, size=400e3, Tb=3550, Tab=2663.3, age=2.208e16, kappa=1.16e-6,
+    set Function expression = ( ((x-a)^2+(y-a)^2<=size^2) ? \
+                 ( max(Tex - (Tb-Tab)*erfc( (-3481e3 + sqrt(x^2+y^2)) /2/sqrt(kappa*age) ),0) ) : \
+            (0) )
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 3550
+    set Outer temperature = 288
+  end
+end
+
+# generate visualization and statistic files.
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set List of output variables      = depth, material properties, named additional outputs
+    set Time between graphical output = 5e6
+
+    subsection Material properties
+      set List of material properties   = viscosity, density, specific heat, thermal conductivity, thermal expansivity, compressibility
+    end
+  end
+end
+
+# other model setup
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+# Free slip on all boundaries.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom, left, right
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 7
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 1
+end
diff --git a/cookbooks/muparser_temperature_example/doc/check-initial-condition.part.prm.bak b/cookbooks/muparser_temperature_example/doc/check-initial-condition.part.prm.bak
new file mode 100644
index 00000000000..ab4d227ca29
--- /dev/null
+++ b/cookbooks/muparser_temperature_example/doc/check-initial-condition.part.prm.bak
@@ -0,0 +1,18 @@
+# Dimension, end-time (years) and output directory
+# Only does zeroth time-step to show that initial condition works
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+
+# If you have a large model or a model with large viscosity variation and you
+# want to run the 0th timestep more quickly in order to just check in the initial
+# condition (IC), you can set these solver tolerance values to larger numbers, but
+# this means the solution will not be converged.
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance            = 1e-6 # can set to 1e-3 for checking IC
+  end
+end
diff --git a/cookbooks/muparser_temperature_example/doc/mesh-refinement.part.prm.bak b/cookbooks/muparser_temperature_example/doc/mesh-refinement.part.prm.bak
new file mode 100644
index 00000000000..aba6e56348e
--- /dev/null
+++ b/cookbooks/muparser_temperature_example/doc/mesh-refinement.part.prm.bak
@@ -0,0 +1,23 @@
+# Refine the upper 150 km of the mesh so lithosphere structure is resolved.
+# Function expression asks if the depth is less than the lithosphere depth and
+# then refinement level = 7, else refinement level = 0.
+# Note, the minimum refinement level for the lower 850 km of the mesh would be
+# coarser than the initial one level of global refinement. This would then lead
+# to coarsening in the future.
+# To avoid this, you may want to set this 'else' value to the same as the number
+# of initial global refinement steps.
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Minimum refinement level           = 3
+  set Initial adaptive refinement        = 4
+  set Time steps between mesh refinement = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function constants  = ymax=1.e6, lith=1.5e5
+    set Function expression = ((ymax-y<=lith) ? 7 : 0)
+  end
+end
diff --git a/cookbooks/muparser_temperature_example/doc/repetitions.part.prm.bak b/cookbooks/muparser_temperature_example/doc/repetitions.part.prm.bak
new file mode 100644
index 00000000000..1e5c71fa33f
--- /dev/null
+++ b/cookbooks/muparser_temperature_example/doc/repetitions.part.prm.bak
@@ -0,0 +1,15 @@
+# Want a 2D box 5000 km wide by 1000 km deep (5e6 x 1e6  meters)
+# The variable repetitions divides the whole domain into 5 boxes (1000 x 1000 km)
+# as the 0th level mesh refinement: this is needed so elements are squares
+# and not elongated rectangles.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 5e6
+    set Y extent = 1e6
+    set X repetitions = 5
+    set Y repetitions = 1
+  end
+end
diff --git a/cookbooks/muparser_temperature_example/doc/temperature.part.prm.bak b/cookbooks/muparser_temperature_example/doc/temperature.part.prm.bak
new file mode 100644
index 00000000000..caee45dfda6
--- /dev/null
+++ b/cookbooks/muparser_temperature_example/doc/temperature.part.prm.bak
@@ -0,0 +1,39 @@
+# Half-space cooling model increasing with age from x>0 to xtr
+# For x>xtr, half-space cooling model with a fixed age.
+# Note, we use 1-erfc instead of erf because the muparser in dealii
+# only knows about erfc. Also, we need to use ymax-y since y=0 at the
+# bottom of the box.
+# vsub is the velocity of the subducting plate in m/s
+# (x/vsub is the age of the subducting plate)
+# ageop is the age of the overriding plate in seconds.
+# Tm is the mantle temperature, Ts is the surface temperature in kelvin
+# kappa is the thermal diffusivity (m^2/s)
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = ymax=1.0e6, xtrm=2.200e6, vsub=7.927e-10, \
+                               ageop=9.46e14, Tm=1673, Ts=273, kappa=1e-6
+    set Function expression = (((x>0.0) && (x<=xtrm)) ? \
+                                 (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*(x/vsub)))))) : \
+                                 (x>xtrm) ? \
+                                  (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*ageop))))) :\
+                                  (Tm) )
+  end
+end
+
+# Set boundary types and values for temperature
+# Default is zero-flux (keep for sidewalls),
+# so only need set top and bottom to fixed temperature
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1673
+    set Top temperature    = 273
+  end
+end
diff --git a/cookbooks/muparser_temperature_example/muparser-temperature-example.prm.bak b/cookbooks/muparser_temperature_example/muparser-temperature-example.prm.bak
new file mode 100644
index 00000000000..0571836ca36
--- /dev/null
+++ b/cookbooks/muparser_temperature_example/muparser-temperature-example.prm.bak
@@ -0,0 +1,159 @@
+# Basic parameter file for using a function expression to define the
+# initial temperature structure using (? : ) syntax for if-else conditions.
+# 2D, Dimensional, Boussinesq, Simple Material Model
+
+# Dimension, end-time (years) and output directory
+# Only does zeroth time-step to show that initial condition works
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output-muparser-temperature-example
+
+# Parameters Related to the Solver and Pressure Normalization
+
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Even when using the Boussinesq approximation you need to set this parameter
+# because this will be the temperature used to calculate the reference density
+# used in the advection equation (even if a separate reference temperature is
+# specified by the material model)
+
+set Adiabatic surface temperature          = 273 # K
+
+# If you have a large model or a model with large viscosity variation and you
+# want to run the 0th timestep more quickly in order to just check in the initial
+# condition (IC), you can set these solver tolerance values to larger numbers, but
+# this means the solution will not be converged.
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance            = 1e-6 # can set to 1e-3 for checking IC
+  end
+end
+
+# The following is equivalent to the Boussinesq approximation
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+# Want a 2D box 5000 km wide by 1000 km deep (5e6 x 1e6 meters).
+# The variable repetitions divides the whole domain into 5 boxes (1000 x 1000 km)
+# as the 0th level mesh refinement: this is needed so elements are squares
+# and not elongated rectangles.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 5e6
+    set Y extent = 1e6
+    set X repetitions = 5
+    set Y repetitions = 1
+  end
+end
+
+# Refine the upper 150 km of the mesh so lithosphere structure is resolved.
+# Function expression asks if the depth is less than the lithosphere depth and
+# then refinement level = 7, else refinement level = 0.
+# Note, the minimum refinement level for the lower 850 km of the mesh would be
+# coarser than the initial one level of global refinement. This would then lead
+# to coarsening in the future.
+# To avoid this, you may want to set this 'else' value to the same as the number
+# of initial global refinement steps.
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Minimum refinement level           = 3
+  set Initial adaptive refinement        = 4
+  set Time steps between mesh refinement = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function constants  = ymax=1e6,lith=1.5e5
+    set Function expression = ((ymax-y<=lith) ? 7 : 0)
+  end
+end
+
+# Half-space cooling model increasing with age from x>0 to xtrm
+# For x>xtrm, half-space cooling model with a fixed age.
+# Note, we use 1-erfc instead of erf because the muparser in dealii
+# only knows about erfc. Also, we need to use ymax-y since y=0 at the
+# bottom of the box.
+# vsub is the velocity of the subducting plate in m/s
+# (x/vsub is the age of the subducting plate)
+# ageop is the age of the overriding plate in seconds.
+# Tm is the mantle temperature, Ts is the surface temperature in kelvin
+# kappa is the thermal diffusivity (m^2/s)
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = ymax=1.0e6, xtrm=2.200e6, vsub=7.927e-10, \
+                               ageop=9.46e14, Tm=1673, Ts=273, kappa=1e-6
+    set Function expression = (((x>0.0) && (x<=xtrm)) ? \
+                                 (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*(x/vsub)))))) : \
+                                 (x>xtrm) ? \
+                                  (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*ageop))))) :\
+                                  (Tm) )
+  end
+end
+
+# Set boundary types and values for temperature
+# Default is zero-flux (keep for sidewalls), so only need set top and bottom to fixed temperature
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1673
+    set Top temperature    = 273
+  end
+end
+
+# Free-slip on all sides (tangential velocity V-perp=0, dV/dn=0)
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300  # kg/m^3
+    set Reference specific heat       = 1250  # J/kg/K
+    set Reference temperature         = 273   # K
+    set Thermal conductivity          = 4.125 # W/m/K
+    set Thermal expansion coefficient = 2e-5  # 1/K
+    set Viscosity                     = 1e21  # Pa s
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics
+
+  subsection Visualization
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+end
diff --git a/cookbooks/onset_of_convection/onset_of_convection.prm.bak b/cookbooks/onset_of_convection/onset_of_convection.prm.bak
new file mode 100644
index 00000000000..1278a31764d
--- /dev/null
+++ b/cookbooks/onset_of_convection/onset_of_convection.prm.bak
@@ -0,0 +1,93 @@
+# This setup is a copy of the
+# benchmarks/onset-of-convection/convection-box-base.prm
+# contributed by Max Rudolph, with the difference that
+# parameter values are specified explicitly in the input file
+# (rather than through an ipython notebook).
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use conduction timestep                = true
+
+subsection Termination criteria
+  set Termination criteria                 = end step
+  set End step                             = 100
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9.424777e6 # pi * 3e6
+    set Y extent = 3e6
+    set X repetitions = 3
+    set Y repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=1, L=9.424777e6, H=3.0e6, pi=3.1415926536, k=2
+    set Function expression = 2500 * (1.0-z/H) - p*cos(k*pi*x/L)*sin(pi*z/H)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 2500
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 4000
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity                     = 1e23
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set Time steps between graphical output = 5
+  end
+end
diff --git a/cookbooks/platelike-boundary/doc/boundary.part.prm.bak b/cookbooks/platelike-boundary/doc/boundary.part.prm.bak
new file mode 100644
index 00000000000..250d9e69271
--- /dev/null
+++ b/cookbooks/platelike-boundary/doc/boundary.part.prm.bak
@@ -0,0 +1,10 @@
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
diff --git a/cookbooks/platelike-boundary/doc/platelike.prm.bak b/cookbooks/platelike-boundary/doc/platelike.prm.bak
new file mode 100644
index 00000000000..27250340f5e
--- /dev/null
+++ b/cookbooks/platelike-boundary/doc/platelike.prm.bak
@@ -0,0 +1,91 @@
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20
+set Use years in output instead of seconds = false
+set Output directory                       = output-platelike-boundary
+
+############### Parameters describing the model
+# Let us here choose again a box domain of size 2x1
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+# We then set the temperature to one at the bottom and zero
+# at the top:
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/cookbooks/platelike-boundary/platelike-boundary.prm.bak b/cookbooks/platelike-boundary/platelike-boundary.prm.bak
new file mode 100644
index 00000000000..b89539d9600
--- /dev/null
+++ b/cookbooks/platelike-boundary/platelike-boundary.prm.bak
@@ -0,0 +1,96 @@
+# A description of convection in a rectangular box where we prescribe
+# temporally variable boundary conditions for the velocity along the top
+# boundary. See the manual for more information.
+
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20
+set Use years in output instead of seconds = false
+set Output directory                       = output-platelike-boundary
+
+############### Parameters describing the model
+# Let us here choose again a box domain of size 2x1
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+# We then set the temperature to one at the bottom and zero
+# at the top:
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/cookbooks/plume_2D_chunk/opening_angle_45degrees.prm.bak b/cookbooks/plume_2D_chunk/opening_angle_45degrees.prm.bak
new file mode 100644
index 00000000000..b627610d078
--- /dev/null
+++ b/cookbooks/plume_2D_chunk/opening_angle_45degrees.prm.bak
@@ -0,0 +1,11 @@
+include ./plume2D.prm
+
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 45
+    set Chunk maximum longitude = 90
+  end
+end
diff --git a/cookbooks/plume_2D_chunk/opening_angle_90degrees.prm.bak b/cookbooks/plume_2D_chunk/opening_angle_90degrees.prm.bak
new file mode 100644
index 00000000000..3b0b3a38693
--- /dev/null
+++ b/cookbooks/plume_2D_chunk/opening_angle_90degrees.prm.bak
@@ -0,0 +1,11 @@
+include ./plume2D.prm
+
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+  end
+end
diff --git a/cookbooks/plume_2D_chunk/plume2D.prm.bak b/cookbooks/plume_2D_chunk/plume2D.prm.bak
new file mode 100644
index 00000000000..658c90f0ceb
--- /dev/null
+++ b/cookbooks/plume_2D_chunk/plume2D.prm.bak
@@ -0,0 +1,104 @@
+# A simple setup for a plume in a 2D chunk based on Kellogg \& King, EPSL 148 (1997).
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 200e9
+set Output directory                       = output_plume2D
+set Maximum time step                      = 5e7
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Reference temperature and viscosity
+    set Reference temperature = 273
+
+    # Limit the viscosity with maximum=1000*eta0
+    set Minimum viscosity = 1.25e23
+    set Maximum viscosity = 1.25e26
+
+    # Thermal diffusivity is adjusted to match thermal conductivities
+    # assumed in assigning the initial geotherm
+    set Thermal diffusivities =  5.5e-7
+    set Heat capacities       =  1250.
+    set Densities             =  3250
+    set Thermal expansivities =  3e-5
+    set Viscous flow law      = diffusion
+    set Activation volumes for diffusion creep  = 0
+    set Grain size = 1
+
+    # isoviscous
+    set Prefactors for diffusion creep          = 4e-24
+    set Activation energies for diffusion creep = 0
+
+    # Plasticity parameters - irrelevant
+    # set to very high value so that it is not used
+    set Cohesions = 1e15
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3480000
+    set Chunk outer radius = 6371000
+    set Chunk minimum longitude = 67.5
+    set Chunk maximum longitude = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+# temperature is set to 273K at the top, i.e. for r>4e6
+# where 4e6 is an arbitrary radius value falling between
+# the CMB and the surface. If r<4e6 then we wish to prescribe
+# a temperature on the bottom surface: since phi=0 at the
+# equator (i.e. x-axis) then the patch is defined by 7pi/16<phi<pi/2.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r, phi
+    set Function constants = pi=3.1415926536
+    set Function expression = if (r>4e6,273,if(phi>7*pi/16,3273,2773))
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1023
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 5
+  set Initial adaptive refinement        = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, vertical heat flux
+    set Output format                 = vtu
+    set Time between graphical output = 10e7
+    set Number of grouped files       = 0
+  end
+end
diff --git a/cookbooks/plume_2D_chunk/strongly_temperature_dependent.prm.bak b/cookbooks/plume_2D_chunk/strongly_temperature_dependent.prm.bak
new file mode 100644
index 00000000000..cf2eb62f09c
--- /dev/null
+++ b/cookbooks/plume_2D_chunk/strongly_temperature_dependent.prm.bak
@@ -0,0 +1,11 @@
+include ./plume2D.prm
+
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Prefactors for diffusion creep          = 6.26e-23
+    set Activation energies for diffusion creep = 74829.6
+  end
+end
diff --git a/cookbooks/plume_2D_chunk/weakly_temperature_dependent.prm.bak b/cookbooks/plume_2D_chunk/weakly_temperature_dependent.prm.bak
new file mode 100644
index 00000000000..67f974244e9
--- /dev/null
+++ b/cookbooks/plume_2D_chunk/weakly_temperature_dependent.prm.bak
@@ -0,0 +1,11 @@
+include ./plume2D.prm
+
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Prefactors for diffusion creep          = 5.05e-24
+    set Activation energies for diffusion creep = 6317.6
+  end
+end
diff --git a/cookbooks/prescribed_velocity/circle.prm.bak b/cookbooks/prescribed_velocity/circle.prm.bak
new file mode 100644
index 00000000000..2de956d989b
--- /dev/null
+++ b/cookbooks/prescribed_velocity/circle.prm.bak
@@ -0,0 +1,62 @@
+## First we set up a unit length box model with uniform everything.
+set Dimension   = 2
+set End time    = 0
+set Output directory = output-circle
+
+# Load the signal library.
+set Additional shared libraries = ./libprescribed_velocity.so
+
+## Turn prescribed velocities on
+set Prescribe internal velocities = true
+
+subsection Geometry model
+  set Model name = box
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top, bottom, left, right
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 7
+  set Initial adaptive refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+end
+
+subsection Prescribed velocities
+  subsection Indicator function
+    set Variable names = x,y,t
+
+    # Return where to prescribe u_x; u_y; u_z
+    # (last one only used if dimension = 3)
+    # 1 if velocity should be prescribed, 0 otherwise
+    set Function expression = if((x-.5)^2+(y-.5)^2<.125,1,0); \
+                                if((x-.5)^2+(y-.5)^2<.125,1,0)
+  end
+
+  subsection Velocity function
+    set Variable names = x,y,t
+
+    # Return u_x; u_y; u_z (u_z only used if in 3d)
+    set Function expression = 1;1
+  end
+end
diff --git a/cookbooks/prescribed_velocity/corner_flow.prm.bak b/cookbooks/prescribed_velocity/corner_flow.prm.bak
new file mode 100644
index 00000000000..1ad5cef1405
--- /dev/null
+++ b/cookbooks/prescribed_velocity/corner_flow.prm.bak
@@ -0,0 +1,62 @@
+## First we set up a unit length box model with uniform everything.
+set Dimension   = 2
+set End time    = 0
+
+# Load the signal library.
+set Additional shared libraries = ./libprescribed_velocity.so
+set Output directory = output-corner_flow
+
+## Turn prescribed velocities on
+set Prescribe internal velocities = true
+
+subsection Geometry model
+  set Model name = box
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 7
+  set Initial adaptive refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+end
+
+subsection Prescribed velocities
+  subsection Indicator function
+    set Variable names = x,y,t
+
+    # Return where to prescribe u_x; u_y; u_z
+    # (last one only used if dimension = 3)
+    # 1 if velocity should be prescribed, 0 otherwise
+    set Function expression = if(((x>.1)&(x<.9))&(abs(x-(1-y))<.01),1,0); \
+                                if(((x>.1)&(x<.9))&(abs(x-(1-y))<.01),1,0)
+  end
+
+  subsection Velocity function
+    set Variable names = x,y,t
+
+    # Return u_x; u_y; u_z (u_z only used if in 3d)
+    set Function expression = 1;-1
+  end
+end
diff --git a/cookbooks/prescribed_velocity/doc/minimal.prm.bak b/cookbooks/prescribed_velocity/doc/minimal.prm.bak
new file mode 100644
index 00000000000..22583cc03a0
--- /dev/null
+++ b/cookbooks/prescribed_velocity/doc/minimal.prm.bak
@@ -0,0 +1,24 @@
+# Load the signal library.
+set Additional shared libraries = ./libprescribed_velocity.so
+
+## Turn prescribed velocities on
+set Prescribe internal velocities = true
+
+subsection Prescribed velocities
+  subsection Indicator function
+    set Variable names = x,y,t
+
+    # Return where to prescribe u_x; u_y; u_z
+    # (last one only used if dimension = 3)
+    # 1 if velocity should be prescribed, 0 otherwise
+    set Function expression = if((x-.5)^2+(y-.5)^2<.125,1,0); \
+                                if((x-.5)^2+(y-.5)^2<.125,1,0)
+  end
+
+  subsection Velocity function
+    set Variable names = x,y,t
+
+    # Return u_x; u_y; u_z (u_z only used if in 3d)
+    set Function expression = 1;-1
+  end
+end
diff --git a/cookbooks/prescribed_velocity/prescribed_velocity.cc.bak b/cookbooks/prescribed_velocity/prescribed_velocity.cc.bak
new file mode 100644
index 00000000000..5f93f95d584
--- /dev/null
+++ b/cookbooks/prescribed_velocity/prescribed_velocity.cc.bak
@@ -0,0 +1,301 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/parsed_function.h>
+#include <deal.II/fe/fe_values.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/parameters.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  // Global variables (to be set by parameters)
+  bool prescribe_internal_velocities;
+
+  // Because we do not initially know what dimension we're in, we need
+  // function parser objects for both 2d and 3d.
+  Functions::ParsedFunction<2> prescribed_velocity_indicator_function_2d (2);
+  Functions::ParsedFunction<3> prescribed_velocity_indicator_function_3d (3);
+  Functions::ParsedFunction<2> prescribed_velocity_function_2d (2);
+  Functions::ParsedFunction<3> prescribed_velocity_function_3d (3);
+
+
+
+  /**
+   * Declare additional parameters.
+   */
+  void declare_parameters(const unsigned int dim,
+                          ParameterHandler &prm)
+  {
+    prm.declare_entry ("Prescribe internal velocities", "false",
+                       Patterns::Bool (),
+                       "Whether or not to use any prescribed internal velocities. "
+                       "Locations in which to prescribe velocities are defined "
+                       "in section ``Prescribed velocities/Indicator function'' "
+                       "and the velocities are defined in section ``Prescribed "
+                       "velocities/Velocity function''. Indicators are evaluated "
+                       "at the center of each cell, and all DOFs associated with "
+                       "the specified velocity component at the indicated cells "
+                       "are constrained."
+                      );
+
+    prm.enter_subsection ("Prescribed velocities");
+    {
+      prm.enter_subsection ("Indicator function");
+      {
+        if (dim == 2)
+          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
+        else
+          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
+      }
+      prm.leave_subsection ();
+
+      prm.enter_subsection ("Velocity function");
+      {
+        if (dim == 2)
+          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
+        else
+          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
+      }
+      prm.leave_subsection ();
+    }
+    prm.leave_subsection ();
+  }
+
+
+
+  template <int dim>
+  void parse_parameters(const Parameters<dim> &,
+                        ParameterHandler &prm)
+  {
+    prescribe_internal_velocities = prm.get_bool ("Prescribe internal velocities");
+    prm.enter_subsection ("Prescribed velocities");
+    {
+      prm.enter_subsection("Indicator function");
+      {
+        try
+          {
+            if (dim == 2)
+              prescribed_velocity_indicator_function_2d.parse_parameters (prm);
+            else
+              prescribed_velocity_indicator_function_3d.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Prescribed velocities.Indicator function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'";
+            throw;
+          }
+      }
+      prm.leave_subsection();
+
+      prm.enter_subsection("Velocity function");
+      {
+        try
+          {
+            if (dim == 2)
+              prescribed_velocity_function_2d.parse_parameters (prm);
+            else
+              prescribed_velocity_function_3d.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Prescribed velocities.Velocity function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'";
+            throw;
+          }
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection ();
+  }
+
+
+
+  /**
+   * A set of helper functions that either return the point passed to it (if
+   * the current dimension is the same) or return a dummy value (otherwise).
+   */
+  namespace
+  {
+    const Point<2> as_2d(const Point<3> &/*p*/)
+    {
+      return Point<2>();
+    }
+
+    const Point<2> &as_2d(const Point<2> &p)
+    {
+      return p;
+    }
+
+    const Point<3> as_3d(const Point<2> &/*p*/)
+    {
+      return Point<3>();
+    }
+
+    const Point<3> &as_3d(const Point<3> &p)
+    {
+      return p;
+    }
+
+  }
+
+
+
+  /**
+   * This function is called by a signal which is triggered after the other constraints
+   * have been calculated. This enables us to define additional constraints in the mass
+   * matrix on any arbitrary degree of freedom in the model space.
+   */
+  template <int dim>
+  void constrain_internal_velocities (const SimulatorAccess<dim> &simulator_access,
+                                      AffineConstraints<double> &current_constraints)
+  {
+    if (prescribe_internal_velocities)
+      {
+        const Parameters<dim> &parameters = simulator_access.get_parameters();
+        const std::vector<Point<dim>> points = aspect::Utilities::get_unit_support_points(simulator_access);
+        const Quadrature<dim> quadrature (points);
+        FEValues<dim> fe_values (simulator_access.get_fe(), quadrature, update_quadrature_points);
+
+        // Loop over all cells
+        for (const auto &cell : simulator_access.get_dof_handler().active_cell_iterators())
+          if (!cell->is_artificial())
+            {
+              fe_values.reinit (cell);
+              std::vector<types::global_dof_index> local_dof_indices(simulator_access.get_fe().dofs_per_cell);
+              cell->get_dof_indices (local_dof_indices);
+
+              for (unsigned int q=0; q<quadrature.size(); q++)
+                // If it's okay to constrain this DOF
+                if (current_constraints.can_store_line(local_dof_indices[q]) &&
+                    !current_constraints.is_constrained(local_dof_indices[q]))
+                  {
+                    // Get the velocity component index
+                    const unsigned int c_idx =
+                      simulator_access.get_fe().system_to_component_index(q).first;
+
+                    // If we're on one of the velocity DOFs
+                    if ((c_idx >=
+                         simulator_access.introspection().component_indices.velocities[0])
+                        &&
+                        (c_idx <=
+                         simulator_access.introspection().component_indices.velocities[dim-1]))
+                      {
+                        // Which velocity component is this DOF associated with?
+                        const unsigned int component_direction
+                          = (c_idx
+                             - simulator_access.introspection().component_indices.velocities[0]);
+
+                        // we get time passed as seconds (always) but may want
+                        // to reinterpret it in years
+                        double time = simulator_access.get_time();
+                        if (simulator_access.convert_output_to_years())
+                          time /= year_in_seconds;
+
+                        prescribed_velocity_indicator_function_2d.set_time (time);
+                        prescribed_velocity_indicator_function_3d.set_time (time);
+                        prescribed_velocity_function_2d.set_time (time);
+                        prescribed_velocity_function_3d.set_time (time);
+
+                        const Point<dim> p = fe_values.quadrature_point(q);
+
+                        // Because we defined and parsed our parameter
+                        // file differently for 2d and 3d we need to
+                        // be sure to query the correct object for
+                        // function values. The function parser
+                        // objects expect points of a certain
+                        // dimension, but Point p will be compiled for
+                        // both 2d and 3d, so we need to do some trickery
+                        // to make this compile.
+                        double indicator, u_i;
+                        if (dim == 2)
+                          {
+                            indicator = prescribed_velocity_indicator_function_2d.value
+                                        (as_2d(p),
+                                         component_direction);
+                            u_i       = prescribed_velocity_function_2d.value
+                                        (as_2d(p),
+                                         component_direction);
+                          }
+                        else
+                          {
+                            indicator = prescribed_velocity_indicator_function_3d.value
+                                        (as_3d(p),
+                                         component_direction);
+                            u_i       = prescribed_velocity_function_3d.value
+                                        (as_3d(p),
+                                         component_direction);
+                          }
+
+                        if (indicator > 0.5)
+                          {
+                            // Add a constraint of the form dof[q] = u_i
+                            // to the list of constraints.
+                            current_constraints.add_line (local_dof_indices[q]);
+                            // When using a defect correction solver, the constraints should only be set on
+                            // nonlinear iteration 0.
+                            if (
+                              (parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::no_Advection_iterated_defect_correction_Stokes &&
+                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::single_Advection_iterated_defect_correction_Stokes &&
+                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::iterated_Advection_and_defect_correction_Stokes &&
+                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::iterated_Advection_and_Newton_Stokes &&
+                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes ) ||
+                              simulator_access.get_nonlinear_iteration() == 0
+                            )
+                              {
+                                current_constraints.set_inhomogeneity (local_dof_indices[q], u_i);
+                              }
+                          }
+                      }
+                  }
+            }
+      }
+  }
+
+  // Connect declare_parameters and parse_parameters to appropriate signals.
+  void parameter_connector ()
+  {
+    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
+    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
+
+    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
+    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
+  }
+
+  // Connect constraints function to correct signal.
+  template <int dim>
+  void signal_connector (SimulatorSignals<dim> &signals)
+  {
+    signals.post_constraints_creation.connect (&constrain_internal_velocities<dim>);
+  }
+
+  // Tell ASPECT to send signals to the connector functions
+  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
+  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
+}
diff --git a/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.0.out.bak b/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.0.out.bak
new file mode 100644
index 00000000000..e4b8e68491c
--- /dev/null
+++ b/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.0.out.bak
@@ -0,0 +1,2 @@
+# Load the signal library.
+set Additional shared libraries = ./libprescribed_velocity_ascii_data.so
diff --git a/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.1.out.bak b/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.1.out.bak
new file mode 100644
index 00000000000..1c6dc373bfb
--- /dev/null
+++ b/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.1.out.bak
@@ -0,0 +1,18 @@
+# Turn prescribed velocities on
+set Prescribe internal velocities = true
+
+# Use the Ascii data plugin to read in the prescribed velocity ASCII file
+# In this cookbook, we use the initial composition file.
+subsection Prescribed velocities
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
+    set Data file name       = aspect_name_initial_composition.txt
+  end
+
+  subsection Velocity function
+    set Variable names = x,y,t
+
+    # Return u_x; u_y; u_z (u_z only used if in 3d)
+    set Function expression = 0;0
+  end
+end
diff --git a/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.2.out.bak b/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.2.out.bak
new file mode 100644
index 00000000000..f82ce39d5ad
--- /dev/null
+++ b/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.2.out.bak
@@ -0,0 +1,8 @@
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
+    set Data file name       = aspect_name_initial_temperature.txt
+  end
+end
diff --git a/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.cc.bak b/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.cc.bak
new file mode 100644
index 00000000000..80feb22cb17
--- /dev/null
+++ b/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.cc.bak
@@ -0,0 +1,311 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/parsed_function.h>
+#include <deal.II/fe/fe_values.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/initial_composition/ascii_data.h>
+#include <aspect/parameters.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  // Global variables (to be set by parameters)
+  bool prescribe_internal_velocities;
+  bool prescribed_velocity_ascii_file_loaded;
+
+  // Because we do not initially know what dimension we're in, we need
+  // function parser objects for both 2d and 3d.
+
+  aspect::Utilities::AsciiDataBase<2> prescribed_velocity_data_file_2d;
+  aspect::Utilities::AsciiDataBase<3> prescribed_velocity_data_file_3d;
+
+  aspect::Utilities::StructuredDataLookup<2> prescribed_velocity_field_data_2d(1, 1.);
+  aspect::Utilities::StructuredDataLookup<3> prescribed_velocity_field_data_3d(1, 1.);
+
+  Functions::ParsedFunction<2> prescribed_velocity_function_2d (2);
+  Functions::ParsedFunction<3> prescribed_velocity_function_3d (3);
+
+
+
+  /**
+   * Declare additional parameters.
+   */
+  void declare_parameters(const unsigned int dim,
+                          ParameterHandler &prm)
+  {
+    prm.declare_entry ("Prescribe internal velocities", "false",
+                       Patterns::Bool (),
+                       "Whether or not to use any prescribed internal velocities. "
+                       "Locations in which to prescribe velocities are defined "
+                       "in section ``Prescribed velocities/Indicator function'' "
+                       "and the velocities are defined in section ``Prescribed "
+                       "velocities/Velocity function''. Indicators are evaluated "
+                       "at the center of each cell, and all DOFs associated with "
+                       "the specified velocity component at the indicated cells "
+                       "are constrained."
+                      );
+
+    prm.enter_subsection ("Prescribed velocities");
+    {
+      {
+        if (dim == 2)
+          prescribed_velocity_data_file_2d.declare_parameters(prm, "./", "prescribed_velocities.txt", "Ascii data model");
+        else
+          prescribed_velocity_data_file_3d.declare_parameters(prm, "./", "prescribed_velocities.txt", "Ascii data model");
+      }
+
+      prm.enter_subsection ("Velocity function");
+      {
+        if (dim == 2)
+          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
+        else
+          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
+      }
+      prm.leave_subsection ();
+    }
+    prm.leave_subsection ();
+  }
+
+
+
+  template <int dim>
+  void parse_parameters(const Parameters<dim> &,
+                        ParameterHandler &prm)
+  {
+    prescribe_internal_velocities = prm.get_bool ("Prescribe internal velocities");
+    prm.enter_subsection ("Prescribed velocities");
+    {
+      {
+        if (dim == 2)
+          prescribed_velocity_data_file_2d.parse_parameters(prm, "Ascii data model");
+        else
+          prescribed_velocity_data_file_3d.parse_parameters(prm, "Ascii data model");
+      }
+
+      prm.enter_subsection("Velocity function");
+      {
+        try
+          {
+            if (dim == 2)
+              prescribed_velocity_function_2d.parse_parameters (prm);
+            else
+              prescribed_velocity_function_3d.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Prescribed velocities.Velocity function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'";
+            throw;
+          }
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection ();
+
+    prescribed_velocity_ascii_file_loaded = false;
+  }
+
+
+
+  /**
+   * A set of helper functions that either return the point passed to it (if
+   * the current dimension is the same) or return a dummy value (otherwise).
+   */
+  namespace
+  {
+    Point<2> as_2d(const Point<3> &/*p*/)
+    {
+      Assert (false, ExcInternalError());
+      return Point<2>();
+    }
+
+    Point<2> as_2d(const Point<2> &p)
+    {
+      return p;
+    }
+
+    Point<3> as_3d(const Point<2> &/*p*/)
+    {
+      Assert (false, ExcInternalError());
+      return Point<3>();
+    }
+
+    Point<3> as_3d(const Point<3> &p)
+    {
+      return p;
+    }
+
+  }
+
+
+
+  /**
+   * This function is called by a signal which is triggered after the other constraints
+   * have been calculated. This enables us to define additional constraints in the mass
+   * matrix on any arbitrary degree of freedom in the model space.
+   */
+  template <int dim>
+  void constrain_internal_velocities (const SimulatorAccess<dim> &simulator_access,
+                                      AffineConstraints<double> &current_constraints)
+  {
+    if (!prescribed_velocity_ascii_file_loaded)
+      {
+        if (dim == 2)
+          {
+            const std::string filename = prescribed_velocity_data_file_2d.data_directory + prescribed_velocity_data_file_2d.data_file_name;
+            prescribed_velocity_field_data_2d.load_file(filename, simulator_access.get_mpi_communicator());
+
+            std::cout << "Loaded 2D prescribed velocity ascii file" << std::endl;
+          }
+        else
+          {
+            const std::string filename = prescribed_velocity_data_file_3d.data_directory + prescribed_velocity_data_file_3d.data_file_name;
+            prescribed_velocity_field_data_3d.load_file(filename, simulator_access.get_mpi_communicator());
+
+            std::cout << "Loaded 3D prescribed velocity ascii file" << std::endl;
+          }
+        prescribed_velocity_ascii_file_loaded = true;
+      }
+
+    if (prescribe_internal_velocities)
+      {
+        const Parameters<dim> &parameters = simulator_access.get_parameters();
+        const std::vector<Point<dim>> points = aspect::Utilities::get_unit_support_points(simulator_access);
+        const Quadrature<dim> quadrature (points);
+        FEValues<dim> fe_values (simulator_access.get_fe(), quadrature, update_quadrature_points);
+        typename DoFHandler<dim>::active_cell_iterator cell;
+
+        // Loop over all cells
+        for (const auto &cell : simulator_access.get_dof_handler().active_cell_iterators())
+          if (! cell->is_artificial())
+            {
+              fe_values.reinit (cell);
+              std::vector<types::global_dof_index> local_dof_indices(simulator_access.get_fe().dofs_per_cell);
+              cell->get_dof_indices (local_dof_indices);
+
+              // we get time passed as seconds (always) but may want
+              // to reinterpret it in years
+              double time = simulator_access.get_time();
+              if (simulator_access.convert_output_to_years())
+                time /= year_in_seconds;
+
+              prescribed_velocity_function_2d.set_time (time);
+              prescribed_velocity_function_3d.set_time (time);
+
+              for (unsigned int q=0; q<quadrature.size(); ++q)
+                // If it's okay to constrain this DOF
+                if (current_constraints.can_store_line(local_dof_indices[q]) &&
+                    !current_constraints.is_constrained(local_dof_indices[q]))
+                  {
+                    // Get the velocity component index
+                    const unsigned int c_idx =
+                      simulator_access.get_fe().system_to_component_index(q).first;
+
+                    // If we're on one of the velocity DOFs
+                    if ((c_idx >=
+                         simulator_access.introspection().component_indices.velocities[0])
+                        &&
+                        (c_idx <=
+                         simulator_access.introspection().component_indices.velocities[dim-1]))
+                      {
+                        // Which velocity component is this DOF associated with?
+                        const unsigned int component_direction
+                          = (c_idx
+                             - simulator_access.introspection().component_indices.velocities[0]);
+
+                        const Point<dim> p = fe_values.quadrature_point(q);
+
+                        // Because we defined and parsed our parameter
+                        // file differently for 2d and 3d we need to
+                        // be sure to query the correct object for
+                        // function values. The function parser
+                        // objects expect points of a certain
+                        // dimension, but Point p will be compiled for
+                        // both 2d and 3d, so we need to do some trickery
+                        // to make this compile.
+                        double indicator, u_i;
+                        if (dim == 2)
+                          {
+                            indicator = prescribed_velocity_field_data_2d.get_data(as_2d(p),0);
+                            u_i       = prescribed_velocity_function_2d.value
+                                        (as_2d(p),
+                                         component_direction);
+                          }
+                        else
+                          {
+                            indicator = prescribed_velocity_field_data_3d.get_data(as_3d(p),0);
+                            u_i       = prescribed_velocity_function_3d.value
+                                        (as_3d(p),
+                                         component_direction);
+                          }
+
+                        if (indicator > 0.5)
+                          {
+                            // Add a constraint of the form dof[q] = u_i
+                            // to the list of constraints.
+                            current_constraints.add_line (local_dof_indices[q]);
+                            // When using a defect correction solver, the constraints should only be set on
+                            // nonlinear iteration 0.
+                            if (
+                              (parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::no_Advection_iterated_defect_correction_Stokes &&
+                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::single_Advection_iterated_defect_correction_Stokes &&
+                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::iterated_Advection_and_defect_correction_Stokes &&
+                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::iterated_Advection_and_Newton_Stokes &&
+                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes ) ||
+                              simulator_access.get_nonlinear_iteration() == 0
+                            )
+                              {
+                                current_constraints.set_inhomogeneity (local_dof_indices[q], u_i);
+                              }
+                          }
+                      }
+                  }
+            }
+      }
+  }
+
+  // Connect declare_parameters and parse_parameters to appropriate signals.
+  void parameter_connector ()
+  {
+    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
+    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
+
+    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
+    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
+  }
+
+  // Connect constraints function to correct signal.
+  template <int dim>
+  void signal_connector (SimulatorSignals<dim> &signals)
+  {
+    signals.post_constraints_creation.connect (&constrain_internal_velocities<dim>);
+  }
+
+  // Tell ASPECT to send signals to the connector functions
+  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
+  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
+}
diff --git a/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.prm.bak b/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.prm.bak
new file mode 100644
index 00000000000..ee0efe59bc1
--- /dev/null
+++ b/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.prm.bak
@@ -0,0 +1,152 @@
+# Before running this cookbook, you must first compile the shared library
+# (with cmake . && make) and also run the local python file
+# (python make_ascii_files_from_png.py)
+
+
+## First we set the dimension
+set Dimension   = 2
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1500
+set CFL number                             = 1.0
+set End time                               = 1e7
+set Maximum time step                      = 1e5
+set Resume computation                     = false
+set Pressure normalization = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Output directory = output-prescribed_velocity_ascii_data
+
+# Load the signal library.
+set Additional shared libraries = ./libprescribed_velocity_ascii_data.so
+
+# Turn prescribed velocities on
+set Prescribe internal velocities = true
+
+subsection Discretization
+  # The polynomial degree to use for the velocity variables in the Stokes
+  # system. Units: None.
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+
+  # Whether to use a Stokes discretization that is locally conservative at the
+  # expense of a larger number of degrees of freedom (true), or to go with a
+  # cheaper discretization that does not locally conserve mass, although it is
+  # globally conservative (false).
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  # The extents of the box in km is the same as the width
+  # and height of the drawing
+  subsection Box
+    set X extent = 799000
+    set Y extent = 499000
+    set X repetitions = 192
+    set Y repetitions = 120
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# We need one compositional field that will be assigned
+# the values read in from the ascii data plugin.
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
+    set Data file name       = aspect_name_initial_composition.txt
+  end
+end
+
+# Use the Ascii data plugin to read in the prescribed velocity ASCII file
+# In this cookbook, we use the initial composition file.
+subsection Prescribed velocities
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
+    set Data file name       = aspect_name_initial_composition.txt
+  end
+
+  subsection Velocity function
+    set Variable names = x,y,t
+
+    # Return u_x; u_y; u_z (u_z only used if in 3d)
+    set Function expression = 0;0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
+    set Data file name       = aspect_name_initial_temperature.txt
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top, bottom, left, right
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature = 0.0
+    set Densities = 3300
+    set Specific heats = 2500
+    set Thermal conductivities = 4.7
+    set Thermal expansivities = 6e-5
+    set Viscosities = 1.e19
+    set Viscosity averaging scheme = arithmetic
+  end
+end
+
+# this plugin really doesn't like mesh refinement yet...
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = strain rate, composition, temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = true
+    set Time between graphical output = 1
+    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+  end
+end
diff --git a/cookbooks/shell_3d_postprocess/doc/shell_3d_postprocess.part.prm.bak b/cookbooks/shell_3d_postprocess/doc/shell_3d_postprocess.part.prm.bak
new file mode 100644
index 00000000000..f11a192f75a
--- /dev/null
+++ b/cookbooks/shell_3d_postprocess/doc/shell_3d_postprocess.part.prm.bak
@@ -0,0 +1,9 @@
+subsection Postprocess
+  set List of postprocessors = velocity statistics, dynamic topography, visualization, basic statistics, geoid
+
+  subsection Visualization
+    set Output format                 = vtu
+    set List of output variables      = geoid, dynamic topography, density, viscosity, gravity
+    set Number of grouped files       = 1
+  end
+end
diff --git a/cookbooks/shell_3d_postprocess/shell_3d_postprocess.prm.bak b/cookbooks/shell_3d_postprocess/shell_3d_postprocess.prm.bak
new file mode 100644
index 00000000000..c7685effbe4
--- /dev/null
+++ b/cookbooks/shell_3d_postprocess/shell_3d_postprocess.prm.bak
@@ -0,0 +1,108 @@
+# A description of convection in a 3d spherical shell with
+# a prescribed initial condition based on a harmonic
+# perturbation
+
+# Define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 3
+
+# Specify the time you want to let the model run for in
+# years and the output directory. Here we only calculate
+# the instantaneous solution.
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Output directory                       = output-shell_3d_postprocess
+
+# The following variables describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Here we specify the geometry of the domain, which is
+# a spherical shell with inner radius of 3481km and
+# outer radius of 6371km
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6371000
+  end
+end
+
+# This section specifies the temperature at the boundary of
+# the domain. Here we set the temperature to be constant at
+# bottom and top.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom,top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2000
+    set Outer temperature = 1000
+  end
+end
+
+# This section describes the gravity field, which is pointing
+# towards the Earth's center with the same magnitude of 10 m/s^2
+# everywhere
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+# This section prescribes the initial condition in the temperature
+# field, which is chosen as a degree n=4, l=2 perturbation
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Lateral wave number one     = 4
+    set Lateral wave number two     = 2
+    set Magnitude                   = 500
+    set Reference temperature       = 1600
+  end
+end
+
+# The material model is based on the simple material model, which assumes
+# a constant density, and other parameters as stated below.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                 = 3300
+    set Viscosity                         = 1e21
+    set Thermal expansion coefficient     = 3e-5
+    set Reference temperature             = 1600
+    set Thermal conductivity              = 4.125
+    set Reference specific heat           = 1250
+  end
+end
+
+# For this calculation we only do 2 global refinement steps. This resolution
+# is too low to fully resolve the mantle flow, however it does capture
+# the main features.
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 0
+end
+
+# We assume free slip at the inner and outer boundary
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom,top
+end
+
+# We output the density, velocity, dynamic topography and geoid anomalies
+subsection Postprocess
+  set List of postprocessors = velocity statistics, dynamic topography, visualization, basic statistics, geoid
+
+  subsection Visualization
+    set Output format                 = vtu
+    set List of output variables      = geoid, dynamic topography, density, viscosity, gravity
+    set Number of grouped files       = 1
+  end
+end
diff --git a/cookbooks/shell_simple_2d/doc/shearheat.part.prm.bak b/cookbooks/shell_simple_2d/doc/shearheat.part.prm.bak
new file mode 100644
index 00000000000..333f2ea44d1
--- /dev/null
+++ b/cookbooks/shell_simple_2d/doc/shearheat.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Heating model
+  set List of model names =
+end
diff --git a/cookbooks/shell_simple_2d/doc/shell.prm.bak b/cookbooks/shell_simple_2d/doc/shell.prm.bak
new file mode 100644
index 00000000000..cb189517d7b
--- /dev/null
+++ b/cookbooks/shell_simple_2d/doc/shell.prm.bak
@@ -0,0 +1,72 @@
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1.5e9
+set Output directory                       = output-shell_simple_2d
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer, left, right
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 5
+  set Initial adaptive refinement        = 4
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, \
+                               heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/cookbooks/shell_simple_2d/shell_simple_2d.prm.bak b/cookbooks/shell_simple_2d/shell_simple_2d.prm.bak
new file mode 100644
index 00000000000..bb20fef1fb7
--- /dev/null
+++ b/cookbooks/shell_simple_2d/shell_simple_2d.prm.bak
@@ -0,0 +1,82 @@
+# A simple setup for convection in a quarter of a 2d shell. See the
+# manual for more information.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1.5e9
+set Output directory                       = output-shell_simple_2d
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average only viscosity
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom
+  set Tangential velocity boundary indicators = top, left, right
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 5
+  set Initial adaptive refinement        = 4
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/cookbooks/shell_simple_2d_smoothing/doc/shell_simple_2d_smoothing.part.prm.bak b/cookbooks/shell_simple_2d_smoothing/doc/shell_simple_2d_smoothing.part.prm.bak
new file mode 100644
index 00000000000..db5ffdbc80c
--- /dev/null
+++ b/cookbooks/shell_simple_2d_smoothing/doc/shell_simple_2d_smoothing.part.prm.bak
@@ -0,0 +1,20 @@
+subsection Discretization
+  set Temperature polynomial degree = 2
+
+  subsection Stabilization parameters
+    set Use artificial viscosity smoothing = true
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(sqrt(x*x+y*y)<4000000,1,0)
+  end
+end
diff --git a/cookbooks/shell_simple_2d_smoothing/shell_simple_2d_smoothing.prm.bak b/cookbooks/shell_simple_2d_smoothing/shell_simple_2d_smoothing.prm.bak
new file mode 100644
index 00000000000..99903b5d2c4
--- /dev/null
+++ b/cookbooks/shell_simple_2d_smoothing/shell_simple_2d_smoothing.prm.bak
@@ -0,0 +1,95 @@
+# An extension of the 2d shell simple cookbook that is used to show the
+# benefits of using the artificial viscosity smoothing feature. See the
+# manual for more information.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 1.5e16
+set Output directory                       = output-shell_simple_2d_smoothing
+
+subsection Discretization
+  set Temperature polynomial degree = 2
+
+  subsection Stabilization parameters
+    set Use artificial viscosity smoothing = true
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(sqrt(x*x+y*y)<4000000,1,0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom
+  set Tangential velocity boundary indicators = top, left, right
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 6
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 115
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/cookbooks/shell_simple_3d/doc/amr.part.prm.bak b/cookbooks/shell_simple_3d/doc/amr.part.prm.bak
new file mode 100644
index 00000000000..eec6a37b436
--- /dev/null
+++ b/cookbooks/shell_simple_3d/doc/amr.part.prm.bak
@@ -0,0 +1,6 @@
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 3
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
diff --git a/cookbooks/shell_simple_3d/doc/checkpoint.part.prm.bak b/cookbooks/shell_simple_3d/doc/checkpoint.part.prm.bak
new file mode 100644
index 00000000000..595a2feeb79
--- /dev/null
+++ b/cookbooks/shell_simple_3d/doc/checkpoint.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Checkpointing
+  set Steps between checkpoint = 50
+end
diff --git a/cookbooks/shell_simple_3d/doc/part1.part.prm.bak b/cookbooks/shell_simple_3d/doc/part1.part.prm.bak
new file mode 100644
index 00000000000..18a2f7b7edf
--- /dev/null
+++ b/cookbooks/shell_simple_3d/doc/part1.part.prm.bak
@@ -0,0 +1,13 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1.5e9
+set Output directory                       = output-shell_simple_3d
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
diff --git a/cookbooks/shell_simple_3d/doc/part2.part.prm.bak b/cookbooks/shell_simple_3d/doc/part2.part.prm.bak
new file mode 100644
index 00000000000..6ab568f2f99
--- /dev/null
+++ b/cookbooks/shell_simple_3d/doc/part2.part.prm.bak
@@ -0,0 +1,13 @@
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer
+end
diff --git a/cookbooks/shell_simple_3d/doc/part3.part.prm.bak b/cookbooks/shell_simple_3d/doc/part3.part.prm.bak
new file mode 100644
index 00000000000..0a9933ad22e
--- /dev/null
+++ b/cookbooks/shell_simple_3d/doc/part3.part.prm.bak
@@ -0,0 +1,9 @@
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1973
+    set Outer temperature = 973
+  end
+end
diff --git a/cookbooks/shell_simple_3d/doc/part4.part.prm.bak b/cookbooks/shell_simple_3d/doc/part4.part.prm.bak
new file mode 100644
index 00000000000..3080dc59b3e
--- /dev/null
+++ b/cookbooks/shell_simple_3d/doc/part4.part.prm.bak
@@ -0,0 +1,11 @@
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1473
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
diff --git a/cookbooks/shell_simple_3d/doc/postprocess.part.prm.bak b/cookbooks/shell_simple_3d/doc/postprocess.part.prm.bak
new file mode 100644
index 00000000000..1538ade53e3
--- /dev/null
+++ b/cookbooks/shell_simple_3d/doc/postprocess.part.prm.bak
@@ -0,0 +1,16 @@
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, \
+                temperature statistics, heat flux statistics, \
+          depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 1
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1.5e6
+    set Output format                 = vtu
+  end
+end
diff --git a/cookbooks/shell_simple_3d/shell_simple_3d.prm.bak b/cookbooks/shell_simple_3d/shell_simple_3d.prm.bak
new file mode 100644
index 00000000000..756c25ce7f3
--- /dev/null
+++ b/cookbooks/shell_simple_3d/shell_simple_3d.prm.bak
@@ -0,0 +1,79 @@
+# A simple setup for convection in a 3d shell. See the
+# manual for more information.
+
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1.5e9
+set Output directory                       = output-shell_simple_3d
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1973
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.473e3
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 3
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 1
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1.5e6
+    set Output format                 = vtu
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 50
+end
diff --git a/cookbooks/sinker-with-averaging/doc/conservative.prm.bak b/cookbooks/sinker-with-averaging/doc/conservative.prm.bak
new file mode 100644
index 00000000000..be1f44bba29
--- /dev/null
+++ b/cookbooks/sinker-with-averaging/doc/conservative.prm.bak
@@ -0,0 +1,3 @@
+subsection Discretization
+  set Use locally conservative discretization = true
+end
diff --git a/cookbooks/sinker-with-averaging/doc/full.prm.bak b/cookbooks/sinker-with-averaging/doc/full.prm.bak
new file mode 100644
index 00000000000..fbe58455e1b
--- /dev/null
+++ b/cookbooks/sinker-with-averaging/doc/full.prm.bak
@@ -0,0 +1,86 @@
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output_sinker-with-averaging
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = none
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 6
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
diff --git a/cookbooks/sinker-with-averaging/doc/harmonic.prm.bak b/cookbooks/sinker-with-averaging/doc/harmonic.prm.bak
new file mode 100644
index 00000000000..7cad0231baf
--- /dev/null
+++ b/cookbooks/sinker-with-averaging/doc/harmonic.prm.bak
@@ -0,0 +1,3 @@
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/cookbooks/sinker-with-averaging/sinker-with-averaging.prm.bak b/cookbooks/sinker-with-averaging/sinker-with-averaging.prm.bak
new file mode 100644
index 00000000000..e11a84c2755
--- /dev/null
+++ b/cookbooks/sinker-with-averaging/sinker-with-averaging.prm.bak
@@ -0,0 +1,86 @@
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output-sinker-with-averaging
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name                        = simple
+  set Material averaging                = none
+
+  subsection Simple model
+    set Reference density               = 1
+    set Viscosity                       = 1
+    set Thermal expansion coefficient   = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 6
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
diff --git a/cookbooks/steinberger/doc/geometry.part.prm.bak b/cookbooks/steinberger/doc/geometry.part.prm.bak
new file mode 100644
index 00000000000..9d29fe02553
--- /dev/null
+++ b/cookbooks/steinberger/doc/geometry.part.prm.bak
@@ -0,0 +1,10 @@
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+    set Phi periodic = true
+  end
+end
diff --git a/cookbooks/steinberger/doc/lookup.part.prm.bak b/cookbooks/steinberger/doc/lookup.part.prm.bak
new file mode 100644
index 00000000000..e8d3aade1b7
--- /dev/null
+++ b/cookbooks/steinberger/doc/lookup.part.prm.bak
@@ -0,0 +1,11 @@
+subsection Material model
+  set Model name = Steinberger
+
+  # Parameters controlling the equation of state.
+  subsection Steinberger model
+    set Data directory         = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names    = pyr-ringwood88.txt
+    set Bilinear interpolation = true
+    set Latent heat            = false
+  end
+end
diff --git a/cookbooks/steinberger/doc/nullspace.part.prm.bak b/cookbooks/steinberger/doc/nullspace.part.prm.bak
new file mode 100644
index 00000000000..fc64ac917eb
--- /dev/null
+++ b/cookbooks/steinberger/doc/nullspace.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
diff --git a/cookbooks/steinberger/doc/projected_density.part.prm.bak b/cookbooks/steinberger/doc/projected_density.part.prm.bak
new file mode 100644
index 00000000000..a80f7e617ca
--- /dev/null
+++ b/cookbooks/steinberger/doc/projected_density.part.prm.bak
@@ -0,0 +1,11 @@
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields  = density_field
+  set Types of fields = density
+  set Compositional field methods = prescribed field
+end
diff --git a/cookbooks/steinberger/doc/rheology.part.prm.bak b/cookbooks/steinberger/doc/rheology.part.prm.bak
new file mode 100644
index 00000000000..d01af634ea1
--- /dev/null
+++ b/cookbooks/steinberger/doc/rheology.part.prm.bak
@@ -0,0 +1,11 @@
+subsection Material model
+  # Parameters controlling the rheology.
+  subsection Steinberger model
+    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
+    set Radial viscosity file name                    = radial-visc-simple.txt
+    set Use lateral average temperature for viscosity = false
+    set Maximum lateral viscosity variation           = 1e3
+    set Maximum viscosity                             = 5e23
+    set Minimum viscosity                             = 1e20
+  end
+end
diff --git a/cookbooks/steinberger/doc/rheology2.part.prm.bak b/cookbooks/steinberger/doc/rheology2.part.prm.bak
new file mode 100644
index 00000000000..ea3ad01b6db
--- /dev/null
+++ b/cookbooks/steinberger/doc/rheology2.part.prm.bak
@@ -0,0 +1,5 @@
+subsection Material model
+  subsection Steinberger model
+    set Radial viscosity file name                    = radial-visc-continuous.txt
+  end
+end
diff --git a/cookbooks/steinberger/steinberger.prm.bak b/cookbooks/steinberger/steinberger.prm.bak
new file mode 100644
index 00000000000..cdd7266c2c0
--- /dev/null
+++ b/cookbooks/steinberger/steinberger.prm.bak
@@ -0,0 +1,215 @@
+# This is a cookbook for a convection model with realistic material properties.
+# Specifically, it uses material properties read in from a look-up table
+# computed with mineral physics software and the projected density approximation.
+# It is a quarter of a spherical shell and uses periodic boundary conditions.
+
+set Dimension                              = 2
+set End time                               = 3e8
+set Adiabatic surface temperature          = 1613.0
+set Output directory                       = output-steinberger
+
+# Because the model is compressible, we use a nonlinear solver.
+# We here choose a tolerance of 1e-3 to limit model runtime, but in a
+# research application one would test what tolerance would be required
+# to obtain a sufficiently accurate solution, and 1e-3 is a quite large
+# value.
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-3
+
+# We run a 2d convection model in a quarter of a spherical shell.
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+    set Phi periodic = true
+  end
+end
+
+# Both the top and bottom boundaries allow for free slip.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom
+end
+
+# Because the model has periodic side boundary conditions and free
+# slip at top and bottom, there is a rotational nullspace. We fix this
+# by setting the net rotation to zero.
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+# We use the gravity model from PREM.
+subsection Gravity model
+  set Model name = ascii data
+end
+
+# The temperature is prescribed at the top and bottom boundaries.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3773
+    set Outer temperature = 273
+  end
+end
+
+# The initial temperature model consists of an adiabatic profile,
+# thermal boundary layers at the surface and the core-mantle boundary,
+# and a small harmonic perturbation to initiate convection.
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Function
+    set Coordinate system   = spherical
+    set Variable names      = r, phi
+    set Function constants  = r0 = 3481000, r1 = 6371000
+    set Function expression = 30 * sin((r-r0)/(r1-r0)*pi)*sin(16*phi) + 20 * sin(2*(r-r0)/(r1-r0)*pi)*sin(12*phi)
+  end
+
+  subsection Adiabatic
+    set Age top boundary layer = 1e8
+    set Age bottom boundary layer = 1e8
+  end
+end
+
+# The model uses the Steinberger material model, which uses a viscosity
+# profile constrained by mineral physics and the geoid, and which can read
+# in material properties from a look-up table.
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    # This data directory contains the files for the viscosity profile,
+    # the lateral viscosity variations due to temperature, and all
+    # material files containing look-up tables computed by mineral physics
+    # software providing density, thermal expansivity and specific heat.
+    set Data directory                                = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
+    set Material file names                           = pyr-ringwood88.txt
+    set Radial viscosity file name                    = radial-visc-simple.txt
+
+    # Because of the resolution in this cookbook we limit the lateral viscosity
+    # variations to three orders of magnitude in both directions (for a total of
+    # six orders of magnitude). We then additionally limit the overall viscosity
+    # between 1e20 Pa s and 5e23 Pa s. This allows the features of the flow field
+    # to be resolved. In the Earth, we would expect higher viscosities in the
+    # lithosphere and lower viscosities in plumes and near the core-mantle boundary.
+    # In addition, this model only accounts for diffusion creep, so the
+    # lithosphere has a high viscosity and forms a stagnant lid on top of the
+    # model. In order to have more realistic subduction in a model like this,
+    # one would have to either prescribe plate velocities at the surface
+    # (forcing plates to subduct) or take into account plastic yielding (so that
+    # the lithosphere can break).
+    set Maximum lateral viscosity variation           = 1e3
+    set Maximum viscosity                             = 5e23
+    set Minimum viscosity                             = 1e20
+
+    # We base our viscosity profile on the adiabat computed based on the
+    # material properties used in the model rather than the laterally
+    # averaged temperature.
+    set Use lateral average temperature for viscosity = false
+
+    # We do not want to include latent heat in our model, mainly because it
+    # can lead to a lot of numerical problems. In a research application, a
+    # model like this should include latent heat. In that case, the formatting
+    # of the look-up table determines if this parameter needs to be set to true
+    # or false. If the look-up table contains the effective thermal expansivity
+    # and specific heat, which includes the effect of phase transformations,
+    # then this parameter still needs to be set to false, because latent heat is
+    # already included automatically when using the properties from the look-up
+    # table. If the look-up table contains thermal expansivity and specific heat
+    # without the effect of phase transitions, then this parameters can be set
+    # to true to compute latent heat effects based on the pressure and
+    # temperature derivatives of the specific enthalpy (using the approach of
+    # Nakagawa et al., 2009).
+    set Latent heat                                   = false
+  end
+end
+
+# Our material model is compressible and includes the temperature gradient
+# caused by adiabatic heating. Consequently, we include both adiabatic heating
+# and shear heating.
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+# Since our model is compressible, the most accurate way to solve the mass
+# conservation equation implemented in ASPECT is to use the 'projected density
+# approximation'. This way, ASPECT will compute the density gradients in the
+# mass conservation directly from the density field (interpolated onto the
+# finite element grid) rather than approximating it with a reference profile
+# or temperature/pressure derivatives of the density. The temperature equation
+# uses the real density (rather than a reference profile) as well.
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
+
+# In order to use the projected density approximation, the model needs a
+# compositional field that the density values can be interpolated on. Here, this
+# field is called 'density_field'. We assign the field the type 'density', so
+# that ASPECT knows that this is the field it should use to compute the density
+# gradient required to solve the equations. ASPECT does not need to solve an
+# equation for this field, it only needs to interpolate the density values onto
+# it. This is covered by the compositional field method 'prescribed field'.
+# For fields of this type, the material model provides the values that should be
+# interpolated onto the field.
+subsection Compositional fields
+  set Number of fields                   = 1
+  set Names of fields                    = density_field
+  set Types of fields                    = density
+  set Compositional field methods        = prescribed field
+end
+
+# We refine the mesh near the boundaries, and where temperature variations are
+# large. In addition, we make sure that in the transition zone, where both the
+# viscosity and the density change a lot, we use the highest refinement level.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.95
+  set Coarsening fraction                = 0.05
+  set Strategy                           = temperature, boundary, minimum refinement function
+  set Time steps between mesh refinement = 5
+
+  subsection Boundary
+    set Boundary refinement indicators = top, bottom
+  end
+
+  subsection Minimum refinement function
+    set Coordinate system   = depth
+    set Variable names      = depth, phi
+    set Function expression = if(depth<700000, 6, 5)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs
+    set Time between graphical output = 1e6
+  end
+end
+
+# This model is compressible and has moderately strong viscosity variations.
+# To make sure the Stokes solver converges, we increase the GMRES solver restart
+# length. This takes more time for each iteration, but the solver usually
+# converges within fewer iterations. We also increase the number of cheap Stokes
+# solver steps because the cheap solver can often already solve the problem, and
+# it is quicker than the expensive solver.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set GMRES solver restart length = 200
+    set Number of cheap Stokes solver steps = 500
+  end
+end
+
+# We also write out checkpoints in case we want to restart the simulation.
+subsection Checkpointing
+  set Steps between checkpoint = 10
+end
diff --git a/cookbooks/stokes/doc/stokeslaw.prm.bak b/cookbooks/stokes/doc/stokeslaw.prm.bak
new file mode 100644
index 00000000000..8b31c9a9958
--- /dev/null
+++ b/cookbooks/stokes/doc/stokeslaw.prm.bak
@@ -0,0 +1,118 @@
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Output directory                       = output-stokes
+
+############### Parameters describing the model
+# The setup is a 3d box with edge length 2890000 in which
+# all 6 sides have free slip boundary conditions. Because
+# the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2890000
+    set Y extent  = 2890000
+    set Z extent  = 2890000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Viscosity                     = 1e22
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# This, however, is the more important part: We need to describe
+# the compositional field and its influence on the density
+# function. The following blocks say that we want to
+# advect a single compositional field and that we give it an
+# initial value that is zero outside a sphere of radius
+# r=200000m and centered at the point (p,p,p) with
+# p=1445000 (which is half the diameter of the box) and one inside.
+# The last block re-opens the material model and sets the
+# density differential per unit change in compositional field to
+# 100.
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = r=200000,p=1445000
+    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 4
+  set Initial global refinement          = 4
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity
+  end
+end
diff --git a/cookbooks/stokes/stokes.prm.bak b/cookbooks/stokes/stokes.prm.bak
new file mode 100644
index 00000000000..2f441647282
--- /dev/null
+++ b/cookbooks/stokes/stokes.prm.bak
@@ -0,0 +1,121 @@
+# A description of the Stokes benchmark for which an analytic solution
+# is available. See the manual for more information.
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Output directory                       = output-stokes
+
+############### Parameters describing the model
+# The setup is a 3d box with edge length 2890000 in which
+# all 6 sides have free slip boundary conditions. Because
+# the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2890000
+    set Y extent  = 2890000
+    set Z extent  = 2890000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Viscosity                     = 1e22
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# This, however, is the more important part: We need to describe
+# the compositional field and its influence on the density
+# function. The following blocks say that we want to
+# advect a single compositional field and that we give it an
+# initial value that is zero outside a sphere of radius
+# r=200000m and centered at the point (p,p,p) with
+# p=1445000 (which is half the diameter of the box) and one inside.
+# The last block re-opens the material model and sets the
+# density differential per unit change in compositional field to
+# 100.
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = r=2e5, p=1.445e6
+    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 4
+  set Initial global refinement          = 4
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity
+  end
+end
diff --git a/cookbooks/subduction_initiation/subduction_initiation.prm.base.bak b/cookbooks/subduction_initiation/subduction_initiation.prm.base.bak
new file mode 100644
index 00000000000..dac596f3a7a
--- /dev/null
+++ b/cookbooks/subduction_initiation/subduction_initiation.prm.base.bak
@@ -0,0 +1,51 @@
+# Parameter file for replicating Matsumoto & Tomoda 1983
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 50e6
+set Use years in output instead of seconds = true
+set CFL number                             = 0.25
+set Pressure normalization                 = surface
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 400e3
+    set Y extent  = 180e3
+    set X repetitions = 2
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement   = 2
+  set Initial global refinement     = 5
+  set Refinement fraction           = 0.9
+  set Strategy                      = composition
+  set Coarsening fraction           = 0
+end
diff --git a/cookbooks/subduction_initiation/subduction_initiation_compositional_fields.prm.bak b/cookbooks/subduction_initiation/subduction_initiation_compositional_fields.prm.bak
new file mode 100644
index 00000000000..c4bd2e3bd3b
--- /dev/null
+++ b/cookbooks/subduction_initiation/subduction_initiation_compositional_fields.prm.bak
@@ -0,0 +1,50 @@
+# Parameter file for replicating Matsumoto & Tomoda 1983
+
+include subduction_initiation.prm.base
+
+set Output directory                       = output-subduction-initiation-comp
+
+#materials are:
+# asthenosphere left,
+# asthenosphere right,
+# lithosphere left,
+# lithosphere right,
+# water.
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities = 3200, 3200, 3300, 3300, 1030
+    set Viscosities = 1e21, 1e21, 1e22, 1e22, 1e18
+    set Viscosity averaging scheme = harmonic
+    set Thermal expansivities = 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = L0=300e3, H=180e3
+    set Function expression = if((x>=L0 && y<H-18e3),1,0) ;\
+                              if((x<=L0 && y>H-60e3 && y<=H-10e3),1,0) ;\
+                              if((x>=L0 && y>=H-18e3 && y<=H-8e3),1,0) ;\
+                              if((x<=L0 && y>H-10e3) || (x>=L0 && y>H-8e3),1,0)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics, pressure statistics, material statistics, global statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate
+    set Time between graphical output = 0
+    set Interpolate output = false
+  end
+end
diff --git a/cookbooks/subduction_initiation/subduction_initiation_particle_in_cell.prm.bak b/cookbooks/subduction_initiation/subduction_initiation_particle_in_cell.prm.bak
new file mode 100644
index 00000000000..e6abe384d17
--- /dev/null
+++ b/cookbooks/subduction_initiation/subduction_initiation_particle_in_cell.prm.bak
@@ -0,0 +1,66 @@
+# Parameter file for replicating Matsumoto & Tomoda 1983
+
+include subduction_initiation.prm.base
+
+set Output directory                       = output-subduction-initiation-pic
+
+subsection Material model
+  set Model name = multicomponent
+  set Material averaging = harmonic average
+
+  subsection Multicomponent
+    set Densities = 0, 3200, 3200, 3300, 3300, 1030
+    set Viscosities = 1e30, 1e21, 1e21, 1e22, 1e22, 1e18
+    set Viscosity averaging scheme = harmonic
+    set Thermal expansivities = 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 5
+  set Names of fields = asth_left, asth_right, left_lith, right_lith, water
+  set Compositional field methods = particles, particles, particles, particles, particles
+  set Mapped particle properties = asth_left:initial asth_left, asth_right:initial asth_right, left_lith:initial left_lith, right_lith:initial right_lith, water: initial water
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = L0=300e3
+    set Function expression = if((x<=L0 && y<=120e3),1,0) ;\
+                              if((x>=L0 && y<162e3),1,0) ;\
+                              if((x<=L0 && y>120e3 && y<=170e3),1,0) ;\
+                              if((x>=L0 && y>=162e3 && y<=172e3),1,0) ;\
+                              if((x<=L0 && y>170e3) || (x>=L0 && y>172e3),1,0)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics, pressure statistics, material statistics, global statistics, particles
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate
+    set Time between graphical output = 0
+    set Interpolate output = false
+  end
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format       = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition, velocity
+  set Particle generator name = random uniform
+  set Interpolation scheme = cell average
+  set Update ghost particles = true
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles      = 350000
+    end
+  end
+end
diff --git a/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm.bak b/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
new file mode 100644
index 00000000000..6258c76a5b1
--- /dev/null
+++ b/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
@@ -0,0 +1,303 @@
+# This cookbook simulates a kinematically-driven 2D subduction system containing
+# distinct lithologies for the mantle wedge and subducting sediment,
+# mid-ocean ridge basalt (MORB), gabbro, peridotite. Lithologies within the slab
+# are prescribed to an initial hydration state after a period of equilibration, and
+# subsequently dehydrate as they subduct. This cookbook utlizes the existing melt framework
+# within ASPECT which governs the mechanical coupling of a solid and fluid phase (see
+# https://doi.org/10.1093/gji/ggw329) but introduces solid-volatile reactions
+# that are governed by an approximation
+# published by Tian et al., 2019 (https://doi.org/10.1029/2019GC008488).
+# In detail, the model simulates the upper 20 km of a subducting slab with a dip
+# of 45 degrees and a convergence rate of 5 cm/yr. The Cartesian box is rotated
+# such that the x-axis aligns with the slab surface and the y-axis is orthogonal
+# to the slab surface, while gravity is imposed at an angle of 45 degrees. A surface pressure
+# of 1 GPa is imposed to account for the model simulating a portion of the slab
+# that is already subducted. For stability, the slab first subducts for 100 kyr before
+# the hydration is added, and the slab surface temperature diffuses to the mantle over
+# 10 km perpendicular to the slab surface. From the slab surface to the base of the model,
+# the composition is comprised of a 5 km thick layer of sediment with 3 wt% water,
+# below is a 7 km thick layer of MORB with 2 wt% water, and below that is an
+# 8 km thick layer of gabbro with 1 wt% water.
+
+set Adiabatic surface temperature              = 1600
+set Nonlinear solver scheme                    = iterated Advection and Stokes
+
+# We choose a low number of iterations and less restrictive nonlinear solver tolerance
+# for model efficiency. During the initial pulse of dehydration (for 3 time steps),
+# solvers do not quite converge to 1e-4, but achieve the convergence criteria for the
+# rest of the model run time. For a production model, a tolerance of at least 1e-5
+# should be selected. Reaching these tolerances may require on the order of
+# 50-100 nonlinear iterations, and the maximum number of nonlinear iterations
+# will need to be increased accordingly.
+set Max nonlinear iterations                   = 25
+set Nonlinear solver tolerance                 = 1e-4
+set Dimension                                  = 2
+set End time                                   = 2e6
+
+# Set the 'Surface pressure' to 1 GPa to simulate a slab that is at depth.
+set Surface pressure                           = 1e9
+set Maximum time step                          = 1000
+set Use operator splitting                     = true
+set Output directory                           = output_coupled_two_phase_tian_parameterization_kinematic_slab
+
+# Checkpoint the model so that a restart can be done if needed.
+subsection Checkpointing
+  set Steps between checkpoint = 20
+end
+
+subsection Discretization
+  # We choose relatively large values for the stabilization parameters:
+  # However, note that in an application model with a higher resolution,
+  # we would choose much smaller values for the stabilization parameters.
+  subsection Stabilization parameters
+    set beta  = 0.5
+    set cR    = 1
+  end
+end
+
+subsection Solver parameters
+  # Set a stricter linear solver tolerance to ensure convergence
+  subsection Stokes solver parameters
+    set Linear solver tolerance             = 1e-10
+    set Number of cheap Stokes solver steps = 1000
+  end
+end
+
+# Initialize the compositional fields. When using the tian approximation
+# Fluid-solid reaction scheme in the Reactive Fluid Transport material
+# model, the fields 'porosity', 'bound_fluid', 'peridotite', 'gabbro',
+# 'MORB', and 'sediment' are all required compositional fields. This is
+# because they are all treated as special fields by the material model.
+# The 4 lithologies ('sediment', 'MORB', 'gabbro', 'peridotite') are used
+# to determine the equilibrium wt% of water that can be incorporated into
+# the corresponding lithology at the model P-T conditions. Free fluid
+# ('porosity') is then partitioned into/out of the solid depending on the
+# current wt% water within the lithology ('bound_fluid'), and how much 'porosity'
+# is present.
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields = porosity, bound_fluid, peridotite, gabbro, MORB, sediment
+  set Compositional field methods = field, field, field, field, field, field
+end
+
+# Initially, the interior of the model is just the periodite mantle.
+# The composition (4 lithologies, porosity, bound_fluid)
+# evolves through the composition boundary conditions specified below.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0; 0; 1; 0; 0; 0
+  end
+end
+
+# The slab begins at the left most boundary, at first consisting solely of dry
+# lithologic layers. After 100 kyr, the incoming sediment is hydrated
+# (initial_bound_) variablesto 3 wt% water, MORB to 2 wt% water, and gabbro
+# to 1 wt% water.
+subsection Boundary composition model
+  set Fixed composition boundary indicators         = left
+  set List of model names                           = function
+
+  subsection Function
+    set Function constants  = initial_porosity=0, initial_bound_sediment=0.03, initial_bound_MORB=0.02, initial_bound_gabbro=0.01, \
+                              sediment_min=0, sediment_max=5e3, MORB_min=5e3, MORB_max=12e3, gabbro_min=12e3, gabbro_max=20e3, \
+                              onset_time=100e3, slab_thickness=20e3
+    set Function expression = initial_porosity; \
+                              if( t<=onset_time, 0, \
+                                  if( (y<=slab_thickness - sediment_min) & (y>slab_thickness - sediment_max), initial_bound_sediment, \
+                                      if( (y<=slab_thickness - MORB_min) & (y>slab_thickness - MORB_max), initial_bound_MORB, \
+                                          if( (y<=slab_thickness - gabbro_min) & (y>slab_thickness - gabbro_max), initial_bound_gabbro, 0.0) \
+                                        ) \
+                                    ) \
+                                ); \
+                              if(y>slab_thickness, 1, 0); \
+                              if(y<=8e3, 1, 0); \
+                              if(y>8e3 & y<=15e3, 1, 0); \
+                              if(y>15e3 & y<=slab_thickness, 1, 0)
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent      = 100e3
+    set Y extent      = 100e3
+    set Y repetitions = 2
+    set X repetitions = 2
+  end
+end
+
+# Refine the mesh globally from 50 km to 3.125 km resolution through four global refinements.
+# Next, adaptively refine the mesh as a function of the porosity.
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 1
+  set Initial global refinement                = 4
+  set Strategy                                 = composition threshold, minimum refinement function
+  set Time steps between mesh refinement       = 2
+
+  # Minimum of 4 global refinements
+  subsection Minimum refinement function
+    set Function expression = 4
+  end
+
+  # Refine where the porosity is bigger than 1e-6. Other compositions
+  # are set to 1e50 to ensure that we do not refine based on these
+  # compositions.
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-6, 1e50, 1e50, 1e50, 1e50, 1e50
+  end
+end
+
+# Impose a gravity vector at an angle of 45 degrees. This
+# accounts for the fact that the slab is subducting with a dip
+# of 45 degrees and the x-axis of our model aligns parallel to the
+# slab surface.
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = angle=0.7071067811865476
+    set Function expression = 9.81*angle; -9.81*angle
+  end
+end
+
+# Initial temperature is a constant value of 1500 K
+# The temperature field evolves through the imposed boundary conditions
+# outlined below.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function constants  = Tmantle=1500
+    set Function expression = Tmantle
+  end
+end
+
+# Fix the temperature on the left boundary to ensure that
+# the incoming slab is always colder than the mantle. The
+# temperature is unconstrained on other boundaries.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = left
+  set List of model names                     = function
+
+  subsection Function
+    set Coordinate system                     = cartesian
+    set Variable names                        = x,y
+    set Function constants                    = Tmantle=1500, Tslab=600, slab_thickness=20e3
+    set Function expression                   = if(y<=slab_thickness, Tslab - 200*y/slab_thickness, Tmantle)
+  end
+end
+
+subsection Material model
+  set Model name                                        = reactive fluid transport
+  set Material averaging                                = harmonic average only viscosity
+
+  # Use the reactive fluid transport model composited with the visco plastic material model.
+  # We use the tian approximation method for the solid-fluid reactions, and place a maximum
+  # wt% water on the 4 lithologies. We choose fluid properties appropriate for water, and
+  # set the Fluid reaction time scale for operator splitting to be 50 kyr. This parameter
+  # controls the timescales for the dehydration/hydration reactions, and decreasing this value
+  # will tend to make convergence more difficult since fluids will be released from the solid
+  # phase more rapidly, increasing compaction pressure gradients. An important parameter that
+  # can help inform model stability is the compaction length, which is defined as:
+  # sqrt((eta_c + 4/3*eta_s) * k/eta_f)
+  # Where k is the permeability, and eta_c, eta_s, and eta_f are the compaction viscosity,
+  # shear viscosity, and fluid viscosity respectively. Ensuring that the mesh can resolve the
+  # compaction length will aid in convergence. The compaction length for this problem at the
+  # reference permeability (1e-6), the minimum shear viscosity (1e19 Pa s), and a compaction
+  # viscosity of 1e19 Pa s results in a compaction length of ~4.8 km. Our mesh has a maximum
+  # resolution of ~1.6 km^2, meaning that the compaction length scales are adequately resolved.
+  subsection Reactive Fluid Transport Model
+    set Base model                                       = visco plastic
+    set Reference fluid density                          = 1000 # density of water
+    set Shear to bulk viscosity ratio                    = 0.1
+    set Reference fluid viscosity                        = 1
+    set Reference permeability                           = 1e-6
+    set Exponential fluid weakening factor               = 30
+    set Fluid compressibility                            = 0
+    set Fluid reaction time scale for operator splitting = 5e4
+    set Fluid-solid reaction scheme                      = tian approximation
+
+    # We limit the bound water in the gabbro, MORB, and sediment to their initial
+    # values to encourage water to hydrate the overlying mantle. The polynomials defined
+    # in Tian et al., 2019 also reach very large values at low P-T conditions, and so limiting
+    # the weight percent to reasonable values is recommended.
+    set Maximum weight percent water in peridotite       = 2
+    set Maximum weight percent water in gabbro           = 1
+    set Maximum weight percent water in MORB             = 2
+    set Maximum weight percent water in sediment         = 3
+  end
+
+  subsection Visco Plastic
+    # Use the composite flow law to simulate dislocation and diffusion creep
+    # of dry olivine with the parameters from Hirth & Kohlstaedt 2004 (10.1029/138GM06).
+    # This will be inconsistent with the physical state of the model (the solid is hydrated),
+    # but ongoing work will introduce a more self-consistent coupling between the hydration
+    # state and the rheology.
+    set Viscosity averaging scheme                      = harmonic
+    set Viscous flow law                                = composite
+    set Prefactors for diffusion creep                  = 4.5e-15
+    set Stress exponents for diffusion creep            = 1.0
+    set Activation energies for diffusion creep         = 375e3
+    set Activation volumes for diffusion creep          = 8.2e-6
+    set Prefactors for dislocation creep                = 7.4e-15
+    set Stress exponents for dislocation creep          = 3.5
+    set Activation energies for dislocation creep       = 530e3
+    set Activation volumes for dislocation creep        = 14e-6
+    set Angles of internal friction                     = 0
+    set Cohesions                                       = 1e50
+
+    # Limit the minimum and maximum viscosity to four orders of
+    # magnitude to improve solver convergence behavior.
+    set Minimum viscosity                               = 1e19
+    set Maximum viscosity                               = 1e23
+  end
+end
+
+# Define the velocity on all boundaries such that the velocity is 5 cm/yr on the bottom
+# boundary and the left/right boundaries from 0<=y<=20 km (slab). For y>20 km, the velocity
+# linearly decreases from 5 cm/yr to 2 cm/yr, approximating corner flow and the decreasing
+# viscous coupling of the mantle wedge with distance from the slab surface.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left: function, bottom: function, top: function, right: function
+
+  subsection Function
+    set Coordinate system   = cartesian
+    set Function constants  = basal_v = 0.05, top_v = 0.02, slab_depth = 20e3, ymax = 100e3
+    set Variable names      = x, y
+    set Function expression = if(y<=slab_depth, 0.05, 0.05 - (basal_v - top_v) * (y - slab_depth) / (ymax - slab_depth)); 0
+  end
+end
+
+# To fully couple the solid-fluid phases, Include melt transport must be set to true. The reactive
+# fluid transport model and the tian approximation can still be used when Include melt transport is
+# set to false, but this does not fully couple the solid-fluid phases. The uncoupled case is
+# presented in the investigated in the other .prm file in this cookbook.
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+# Output every 50 kyr, and visualize the melt material properties which allows us to look at the
+# compaction viscosities and compaction pressures.
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties, melt fraction
+    set Output format                 = vtu
+    set Time between graphical output = 5e4
+    set Interpolate output            = true
+    set Number of grouped files       = 0
+
+    subsection Melt material properties
+      set List of properties          = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
diff --git a/cookbooks/tian_parameterization_kinematic_slab/uncoupled-two-phase-tian-parameterization-kinematic-slab.prm.bak b/cookbooks/tian_parameterization_kinematic_slab/uncoupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
new file mode 100644
index 00000000000..5cccb864ff4
--- /dev/null
+++ b/cookbooks/tian_parameterization_kinematic_slab/uncoupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
@@ -0,0 +1,36 @@
+# This input file creates a model with the same setup as the model generated by
+# coupled-two-phase-tian-parameterization-kinematic-slab.prm, with the only difference
+# being that the solid-fluid reactions in this parameter file are not fully coupled.
+# Instead, the fluid is advected only with the Darcy velocity. See
+# coupled-two-phase-tian-parameterization-kinematic-slab.prm for more details on the model
+# setup.
+
+include $ASPECT_SOURCE_DIR/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm
+
+set Output directory = output_uncoupled_two_phase_tian_parameterization_kinematic_slab
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    # As the system of equations being solved is simpler, the linear solver tolerance can be reduced
+    # to improve efficiency. Note that in production models this value should be tested and decreased
+    # until it no longer has an effect on the model results when using the "iterated Advection and Stokes"
+    set Linear solver tolerance             = 1e-8
+    set Number of cheap Stokes solver steps = 1000
+  end
+end
+
+subsection Compositional fields
+  set Compositional field methods = darcy field, field, field, field, field, field
+end
+
+subsection Melt settings
+  set Include melt transport = false
+end
+
+subsection Postprocess
+  set List of postprocessors     = visualization, composition statistics, velocity statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, thermal expansivity, melt fraction
+  end
+end
diff --git a/cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm.bak b/cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm.bak
new file mode 100644
index 00000000000..a8defb6d961
--- /dev/null
+++ b/cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm.bak
@@ -0,0 +1,246 @@
+# This cookbook demonstrates how we can set up instantaneous mantle flow models
+# using available geophysical constraints. To avoid large computational cost,
+# this model is a 2D spherical shell with imposed plate boundaries and driven
+# by mantle forces arising from observed mantle heterogeneity.
+# The generated mantle flow field at the surface can be compared with the observed
+# surface deformation and the fit can be used to constrain the physical state
+# of the mantle.
+# We define plate boundaries and cratons using WorldBuilder.
+
+set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/plugins/libtomography_based_plate_motions.release.so
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Output directory                       = 2D-slice-with-faults-cratons
+set World builder file                     = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/world_builder_smac_cratons_faults_2D.json
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Start time                             = 0
+set End time                               = 0
+set Adiabatic surface temperature          = 1573.0
+
+# We use matrix-free solver and geometric multigrid preconditioner
+# to reduce memory consumption.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                         = 1e-4
+    set Stokes solver type                              = block GMG
+    set Number of cheap Stokes solver steps             = 500
+    set GMRES solver restart length                     = 400
+    set Maximum number of expensive Stokes solver steps = 0
+    set Use full A block as preconditioner              = true
+    set Linear solver A block tolerance                 = 1e-2
+  end
+end
+
+# The reference profile uses hydrostatic equations to define adiabatic pressure
+# and temperatures. The difference with existing compute profile plugin is that this
+# plugin uses reference densities from PREM below a certain depth defined by the
+# uppermost mantle thickness parameter to compute the adiabatic conditions.
+subsection Adiabatic conditions model
+  set Model name = reference profile
+
+  subsection Reference profile
+    subsection Ascii data model
+      set Data directory = $ASPECT_SOURCE_DIR/data/1D_reference_profiles/
+      set Data file name = prem.txt
+    end
+  end
+end
+
+# We use the spherical shell geometry using the real Earth radius values.
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6371000
+  end
+end
+
+# We use adaptive refinement to better resolve the plate boundaries and
+# the near-surface heterogeneity
+subsection Mesh refinement
+  set Initial adaptive refinement = 1
+  set Initial global refinement = 4
+  set Strategy = minimum refinement function
+  set Skip solvers on initial refinement = true
+
+  subsection Minimum refinement function
+    set Variable names = depth, y
+    set Function expression = if (depth < 350000, 5, 4)
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields = grain_size, Vp, Vs, vs_anomaly, faults, continents
+  set Compositional field methods = static, static, static, static, static, static
+end
+
+# We use world builder to define the complex geometery of plate boundaries ("faults")
+# and cratons ("continents") in our model.
+subsection Initial composition model
+  set List of model names = ascii data, world builder
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
+    set Data file name = LLNL_model_cropped_cratons_faults.txt.gz
+    set Slice dataset in 2D plane = true
+  end
+
+  subsection World builder
+    set List of relevant compositions = faults, continents
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+# We set the net rotation of the velocities at the surface to zero.
+# This is useful for comparison with the observed GPS velocities in the no
+# net rotation frame.
+subsection Nullspace removal
+  set Remove nullspace = net surface rotation
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3700
+    set Outer temperature = 273
+  end
+end
+
+# We set initial temperatures purely from an ASCII data file.
+# The only reason we also activate the adiabatic boundary plugin is that it
+# allows us to to read a dataset of lithospheric thicknesses that we use to
+# determine reference density, thermal expansivity, and compressibility.
+subsection Initial temperature model
+  set List of model names = ascii data, adiabatic boundary
+  set List of model operators = maximum
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
+    set Data file name = upper_mantle_TM1_2D.txt
+  end
+
+  subsection Adiabatic boundary
+    set Data directory = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
+    set Data file name = LAB_CAM2016_2D.txt
+    set Adiabatic temperature gradient = 0
+    set Isotherm temperature = 274
+    set Surface temperature = 273
+  end
+end
+
+# We do not solve for the temperature field and instead prescribe temperatures
+# in our material model using the initial temperature distribution and
+# temperatures computed from the input tomography data.
+subsection Temperature field
+  set Temperature method = prescribed field
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+# The material model uses diffusion/dislocation creep with prefactors, activation
+# energies and volumes for each major mantle phase chosen to facilitate combined
+# diffusion/dislocation creep in the upper mantle and transition zone, and diffusion
+# creep as the dominant deformation mechanism in the lower mantle.
+subsection Material model
+  set Model name         = tomography based plate motions
+  set Material averaging = harmonic average only viscosity
+
+  subsection Tomography based plate motions model
+    set Average specific grain boundary energy      = 1.0,1.0,1.0,1.0
+    set Use equilibrium grain size                  = false
+    set Minimum viscosity                           = 1e19
+    set Maximum viscosity                           = 1e24
+    set Diffusion activation energy                 = 375000,231000,270000,299000
+    set Diffusion activation volume                 = 6e-6,6e-6,6e-6,2e-6
+    set Diffusion creep exponent                    = 1.0,1.0,1.0,1.0
+    set Diffusion creep grain size exponent         = 3,3,3,3
+    set Diffusion creep prefactor                   = 1.25E-015,6.12E-019,2.94E-017,5.4E-022
+    set Dislocation activation energy               = 530000,530000,530000,530000
+    set Dislocation activation volume               = 1.40E-005,1.70E-005,1.70E-005,0.0
+    set Dislocation creep exponent                  = 3.5,3.5,3.5,3.5
+    set Dislocation creep prefactor                 = 8.33E-015,2.05e-12,2.05e-19,1.e-40 #1e-100, 1e-100, 1e-100, 1e-100
+    set Geometric constant                          = 3,3,3,3
+    set Grain growth activation energy              = 400000,662000,414000,299000
+    set Grain growth activation volume              = 0.0,0.0,0.0,1.5e-6
+    set Grain growth exponent                       = 3,3,4.5,5.0
+    set Grain growth rate constant                  = 1.92e-10,3.02e-4,7.63e-22,5.00E-026
+    set Work fraction for boundary area change      = 0.1,0.1,0.1,0.1
+    set Reference compressibility                   = 4e-12
+    set Reference density                           = 3400
+    set Reference specific heat                     = 1200
+    set Thermal conductivity                        = 4
+    set Thermal expansion coefficient               = 2.0e-5
+    set Maximum temperature dependence of viscosity = 1e6
+    set Phase transition Clapeyron slopes           = 0,0,0
+    set Phase transition depths                     = 410000,520000,660000
+    set Phase transition temperatures               = 1950,1950,1950
+    set Phase transition widths                     = 0,0,0
+    set Reciprocal required strain                  = 10
+    set Recrystallized grain size                   = 0.0,0.0,1e-4
+    set Uppermost mantle thickness                  = 300000
+
+    # The following parameters govern whether we want to scale the laterally
+    # averaged viscosity to a reference profile, and the location of that
+    # profile.
+    set Use depth dependent viscosity               = true
+
+    # This tells us how we want to scale the input Vs anomalies to compute density/temperature
+    # anomalies. By default, the model uses a constant scaling factor, but in this cookbook we use
+    # depth-dependent scaling factors taken from input ascii files.
+    set Use depth dependent density scaling         = true
+    set Use depth dependent temperature scaling     = true
+    set Use faults                                  = true
+    set Use cratons                                 = true
+    set Asthenosphere viscosity                     = 1e20
+    set Fault viscosity                             = 1e19
+
+    subsection Ascii data model
+      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/viscosity_profiles/
+      set Data file name                            = steinberger_source-1.txt
+    end
+
+    subsection Density velocity scaling
+      set Data file name                            = rho_vs_scaling.txt
+    end
+
+    subsection Temperature velocity scaling
+      set Data file name                            = dT_vs_scaling.txt
+    end
+
+    subsection Thermal expansivity profile
+      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
+      set Data file name                            = thermal_expansivity_steinberger_calderwood.txt
+    end
+
+    subsection Crustal depths
+      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
+      set Data file name                            = crustal_structure_2D.txt
+    end
+  end
+end
+
+subsection Formulation
+  set Mass conservation = reference density profile
+end
+
+subsection Postprocess
+  set List of postprocessors         = boundary velocity residual statistics, velocity boundary statistics, visualization, heat flux statistics, depth average
+
+  subsection Visualization
+    set List of output variables     = adiabat, material properties, gravity, nonadiabatic temperature, heat flux map, strain rate, boundary velocity residual, named additional outputs
+    set Output format  = vtu
+  end
+end
diff --git a/cookbooks/tomography_based_plate_motions/doc/tomography_based_plate_motions.part.prm.bak b/cookbooks/tomography_based_plate_motions/doc/tomography_based_plate_motions.part.prm.bak
new file mode 100644
index 00000000000..74f5416bbeb
--- /dev/null
+++ b/cookbooks/tomography_based_plate_motions/doc/tomography_based_plate_motions.part.prm.bak
@@ -0,0 +1,53 @@
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields = grain_size, Vp, Vs, vs_anomaly, faults, continents
+  set Compositional field methods = static, static, static, static, static, static
+end
+
+subsection Initial composition model
+  set List of model names = ascii data, world builder
+
+  subsection Ascii data model
+    set Data directory = ../../input_data/
+    set Data file name = LLNL_model_cropped_cratons_faults.txt.gz
+    set Slice dataset in 2D plane = true
+  end
+
+  subsection World builder
+    set List of relevant compositions = faults, continents
+  end
+end
+
+subsection Temperature field
+  set Temperature method = prescribed field
+end
+
+subsection Material model
+  set Model name         = tomography based plate motions
+  set Material averaging = harmonic average only viscosity
+
+  subsection Tomography based plate motions model
+    set Uppermost mantle thickness                  = 300000
+    set Use depth dependent viscosity               = true
+    set Use depth dependent density scaling         = true
+    set Use depth dependent temperature scaling     = true
+    set Use faults                                  = true
+    set Fault viscosity                             = 1e19
+    set Use cratons                                 = true
+    set Craton viscosity                            = 1e25
+    set Asthenosphere viscosity                     = 1e20
+
+    subsection Ascii data model
+      set Data directory                            = ../../input_data/viscosity_profiles/
+      set Data file name                            = steinberger_source-1.txt
+    end
+
+    subsection Density velocity scaling
+      set Data file name                            = rho_vs_scaling.txt
+    end
+
+    subsection Temperature velocity scaling
+      set Data file name                            = dT_vs_scaling.txt
+    end
+  end
+end
diff --git a/cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc.bak b/cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc.bak
new file mode 100644
index 00000000000..ee4ef975af3
--- /dev/null
+++ b/cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc.bak
@@ -0,0 +1,457 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include "reference_profile.h"
+#include "tomography_based_plate_motions.h"
+#include <aspect/gravity_model/interface.h>
+#include <aspect/initial_composition/interface.h>
+
+#include <deal.II/base/signaling_nan.h>
+
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    template <int dim>
+    ReferenceProfile<dim>::ReferenceProfile()
+      :
+      initialized(false),
+      surface_condition_function(2)
+    {}
+
+
+
+    template <int dim>
+    void
+    ReferenceProfile<dim>::update()
+    {
+      if (use_surface_condition_function)
+        {
+          initialized = false;
+          surface_condition_function.set_time(this->get_time());
+          initialize();
+        }
+    }
+
+
+    template <int dim>
+    void
+    ReferenceProfile<dim>::initialize()
+    {
+      if (initialized)
+        return;
+
+      reference_profile.initialize(this->get_mpi_communicator());
+      density_index = reference_profile.get_column_index_from_name("density");
+
+      temperatures.resize(n_points, numbers::signaling_nan<double>());
+      pressures.resize(n_points, numbers::signaling_nan<double>());
+      densities.resize(n_points, numbers::signaling_nan<double>());
+
+      delta_z = this->get_geometry_model().maximal_depth() / (n_points-1);
+
+      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
+
+      // Constant properties on the reference profile
+      in.strain_rate.resize(0);
+      in.velocity[0] = Tensor <1,dim> ();
+      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties;
+
+      // Check whether gravity is pointing up / out or down / in. In the normal case it should
+      // point down / in and therefore gravity should be positive, leading to increasing
+      // adiabatic pressures and temperatures with depth. In some cases it will point up / out
+      // (e.g. for backward advection), in which case the pressures and temperatures should
+      // decrease with depth and therefore gravity has to be negative in the following equations.
+      const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(this->get_geometry_model().representative_point(0));
+      const Point<dim> point_surf = this->get_geometry_model().representative_point(0);
+      const Point<dim> point_bot = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
+      const int gravity_direction =  (g * (point_bot - point_surf) >= 0) ?
+                                     1 :
+                                     -1;
+
+      // We want to use different values for the densities in the uppermost vs the lower part of the mantle.
+      double uppermost_mantle_thickness = 0.0;
+      if (Plugins::plugin_type_matches<const MaterialModel::TomographyBasedPlateMotions<dim>>(this->get_material_model()))
+        {
+          const MaterialModel::TomographyBasedPlateMotions<dim> &material_model
+            = Plugins::get_plugin_as_type<const MaterialModel::TomographyBasedPlateMotions<dim>> (this->get_material_model());
+
+          uppermost_mantle_thickness = material_model.get_depth_of_base_of_uppermost_mantle();
+        }
+
+
+      // now integrate downward using the explicit Euler method for simplicity
+      //
+      // note: p'(z) = rho(p,T) * |g|
+      //       T'(z) = alpha |g| T / C_p
+      for (unsigned int i=0; i<n_points; ++i)
+        {
+          // use material properties calculated at i-1
+          // The first column in the input ascii file is the radius from the center of the Earth,
+          // therefore we convert the depths to the radial values in the get_data_component().
+          const double current_depth = double(i)/double(n_points-1)*this->get_geometry_model().maximal_depth();
+          const double outer_radius = this->get_geometry_model().representative_point(0.).norm();
+
+          double density = reference_profile.get_data_component(Point<1>(outer_radius - current_depth),density_index);
+
+          if (i==0)
+            {
+              if (!use_surface_condition_function)
+                {
+                  pressures[0] = this->get_surface_pressure();
+                  temperatures[0] = this->get_adiabatic_surface_temperature();
+                }
+              else
+                {
+                  pressures[0] = surface_condition_function.value(Point<1>(0.0),0);
+                  temperatures[0] = surface_condition_function.value(Point<1>(0.0),1);
+                }
+            }
+          else
+            {
+              // We only want to use the PREM densities in the part of the model that also
+              // uses seismic velocities to determine the densities. Otherwise, use the density
+              // computed by the material model.
+              if (current_depth < uppermost_mantle_thickness)
+                density = out.densities[0];
+
+              const double alpha = out.thermal_expansion_coefficients[0];
+              // Handle the case that cp is zero (happens in simple Stokes test problems like sol_cx). By setting
+              // 1/cp = 0.0 we will have a constant temperature profile with depth.
+              const double one_over_cp = (out.specific_heat[0]>0.0) ? 1.0/out.specific_heat[0] : 0.0;
+              // get the magnitude of gravity. we assume
+              // that gravity always points along the depth direction. this
+              // may not strictly be true always but is likely a good enough
+              // approximation here.
+              const double gravity = gravity_direction * this->get_gravity_model().gravity_vector(in.position[0]).norm();
+
+              pressures[i] = pressures[i-1] + density * gravity * delta_z;
+              temperatures[i] = (this->include_adiabatic_heating())
+                                ?
+                                temperatures[i-1] * (1 + alpha * gravity * delta_z * one_over_cp)
+                                :
+                                temperatures[0];
+            }
+
+          const Point<dim> representative_point = this->get_geometry_model().representative_point (current_depth);
+          const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(representative_point);
+
+          in.position[0] = representative_point;
+          in.temperature[0] = temperatures[i];
+          in.pressure[0] = pressures[i];
+
+          // we approximate the pressure gradient by extrapolating the values
+          // from the two points above
+          if (i>0)
+            in.pressure_gradient[0] = g/(g.norm() != 0.0 ? g.norm() : 1.0)
+                                      * (pressures[i] - pressures[i-1]) / delta_z;
+          else
+            in.pressure_gradient[0] = Tensor <1,dim> ();
+
+          if (reference_composition == initial_composition)
+            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+              in.composition[0][c] = this->get_initial_composition_manager().initial_composition(representative_point, c);
+          else if (reference_composition == reference_function)
+            {
+              const double depth = this->get_geometry_model().depth(representative_point);
+              const Point<1> p(depth);
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                in.composition[0][c] = composition_function->value(p, c);
+            }
+          else
+            AssertThrow(false,ExcNotImplemented());
+
+          densities[i] = density;
+
+          this->get_material_model().evaluate(in, out);
+
+          // Make sure we get the first point of the profile right. We can only assign the correct
+          // value after the material model has been evaluated.
+          if (current_depth < uppermost_mantle_thickness && i==0)
+            densities[i] = out.densities[0];
+        }
+
+      if (gravity_direction == 1 && this->get_surface_pressure() >= 0)
+        {
+          Assert (*std::min_element (pressures.begin(), pressures.end()) >=
+                  -std::numeric_limits<double>::epsilon() * pressures.size(),
+                  ExcMessage("Adiabatic ReferenceProfile encountered a negative pressure of "
+                             + dealii::Utilities::to_string(*std::min_element (pressures.begin(), pressures.end()))));
+        }
+      else if (gravity_direction == -1 && this->get_surface_pressure() <= 0)
+        {
+          Assert (*std::max_element (pressures.begin(), pressures.end()) <=
+                  std::numeric_limits<double>::epsilon() * pressures.size(),
+                  ExcMessage("Adiabatic ReferenceProfile encountered a positive pressure of "
+                             + dealii::Utilities::to_string(*std::max_element (pressures.begin(), pressures.end()))));
+        }
+
+      Assert (*std::min_element (temperatures.begin(), temperatures.end()) >=
+              -std::numeric_limits<double>::epsilon() * temperatures.size(),
+              ExcMessage("Adiabatic ReferenceProfile encountered a negative temperature."));
+
+
+      initialized = true;
+    }
+
+
+
+    template <int dim>
+    bool
+    ReferenceProfile<dim>::is_initialized() const
+    {
+      return initialized;
+    }
+
+
+
+    template <int dim>
+    double ReferenceProfile<dim>::pressure (const Point<dim> &p) const
+    {
+      return get_property(p,pressures);
+    }
+
+
+
+    template <int dim>
+    double ReferenceProfile<dim>::temperature (const Point<dim> &p) const
+    {
+      return get_property(p,temperatures);
+    }
+
+
+
+    template <int dim>
+    double ReferenceProfile<dim>::density (const Point<dim> &p) const
+    {
+      return get_property(p,densities);
+    }
+
+
+
+    template <int dim>
+    double ReferenceProfile<dim>::density_derivative (const Point<dim> &p) const
+    {
+      const double z = this->get_geometry_model().depth(p);
+
+      if (z >= this->get_geometry_model().maximal_depth())
+        {
+          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
+                  ExcInternalError());
+          return (densities.back() - densities[densities.size()-2]) / delta_z;
+        }
+
+      if (z < 0)
+        {
+          Assert (z >= -delta_z, ExcInternalError());
+          return (densities[1] - densities.front()) / delta_z;
+        }
+
+      // if z/delta_z is within [k-eps, k+eps] of a whole number k, round it down to k-1
+      const unsigned int i = static_cast<unsigned int>((z/delta_z) * (1. - 2. * std::numeric_limits<double>::epsilon()));
+      Assert (i < densities.size() - 1, ExcInternalError());
+
+      return (densities[i+1]-densities[i])/delta_z;
+    }
+
+
+
+    template <int dim>
+    double ReferenceProfile<dim>::get_property (const Point<dim> &p,
+                                                const std::vector<double> &property) const
+    {
+      const double z = this->get_geometry_model().depth(p);
+
+      if (z >= this->get_geometry_model().maximal_depth())
+        {
+          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
+                  ExcInternalError());
+          return property.back();
+        }
+
+      if (z <= 0)
+        {
+          Assert (z >= -delta_z, ExcInternalError());
+          return property.front();
+        }
+
+      const double floating_index = z/delta_z;
+      const unsigned int i = static_cast<unsigned int>(floating_index);
+
+      // If p is close to an existing value use that one. This prevents
+      // asking for values at i+1 while initializing i+1 (when p is at the
+      // depth of index i).
+      if (std::abs(floating_index-std::floor(floating_index+0.5)) < 1e-6)
+        return property[i];
+
+      Assert (i+1 < property.size(), ExcInternalError());
+
+      // now do the linear interpolation
+      const double d = floating_index - i;
+      Assert ((d>=0) && (d<=1), ExcInternalError());
+
+      return d*property[i+1] + (1.-d)*property[i];
+    }
+
+
+
+
+    template <int dim>
+    void
+    ReferenceProfile<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        prm.enter_subsection("Reference profile");
+        {
+          Functions::ParsedFunction<1>::declare_parameters (prm, 1);
+          prm.declare_entry("Composition reference profile","initial composition",
+                            Patterns::Selection("initial composition|function"),
+                            "Select how the reference profile for composition "
+                            "is computed. This profile is used to evaluate the "
+                            "material model, when computing the pressure and "
+                            "temperature profile.");
+          prm.declare_entry ("Number of points", "1000",
+                             Patterns::Integer (5),
+                             "The number of points we use to compute the adiabatic "
+                             "profile. The higher the number of points, the more accurate "
+                             "the downward integration from the adiabatic surface "
+                             "temperature will be.");
+          prm.declare_entry ("Use surface condition function", "false",
+                             Patterns::Bool(),
+                             "Whether to use the 'Surface condition function' to determine surface "
+                             "conditions, or the 'Adiabatic surface temperature' and 'Surface pressure' "
+                             "parameters. If this is set to true the reference profile is updated "
+                             "every timestep. The function expression of the function should be "
+                             "independent of space, but can depend on time 't'. The function must "
+                             "return two components, the first one being reference surface pressure, "
+                             "the second one being reference surface temperature.");
+
+          prm.enter_subsection("Surface condition function");
+          {
+            Functions::ParsedFunction<1>::declare_parameters (prm, 2);
+          }
+          prm.leave_subsection();
+
+
+          Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                            "$ASPECT_SOURCE_DIR/tests/adiabatic-conditions/ascii-data/test/",
+                                                            "");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    ReferenceProfile<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        prm.enter_subsection("Reference profile");
+        {
+          const std::string composition_profile = prm.get("Composition reference profile");
+
+          if (composition_profile == "initial composition")
+            reference_composition = initial_composition;
+          else if (composition_profile == "function")
+            reference_composition = reference_function;
+          else
+            AssertThrow(false, ExcNotImplemented());
+
+          if ((this->n_compositional_fields() > 0) && (reference_composition == reference_function))
+            {
+              composition_function
+                = std::make_unique<Functions::ParsedFunction<1>>(this->n_compositional_fields());
+              try
+                {
+                  composition_function->parse_parameters (prm);
+                }
+              catch (...)
+                {
+                  std::cerr << "ERROR: FunctionParser failed to parse\n"
+                            << "\t'Adiabatic conditions model.compute profile'\n"
+                            << "with expression\n"
+                            << "\t'" << prm.get("Function expression") << "'"
+                            << "More information about the cause of the parse error \n"
+                            << "is shown below.\n";
+                  throw;
+                }
+            }
+
+          n_points = prm.get_integer ("Number of points");
+          use_surface_condition_function = prm.get_bool("Use surface condition function");
+          if (use_surface_condition_function)
+            {
+              prm.enter_subsection("Surface condition function");
+              try
+                {
+                  surface_condition_function.parse_parameters (prm);
+                }
+              catch (...)
+                {
+                  std::cerr << "ERROR: FunctionParser failed to parse\n"
+                            << "\t'Adiabatic conditions model.Initial profile.Surface condition function'\n"
+                            << "with expression\n"
+                            << "\t'" << prm.get("Function expression") << "'"
+                            << "More information about the cause of the parse error \n"
+                            << "is shown below.\n";
+                  throw;
+                }
+
+              prm.leave_subsection();
+            }
+
+          reference_profile.parse_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(ReferenceProfile,
+                                               "reference profile",
+                                               "A model in which the adiabatic profile is "
+                                               "calculated by solving the hydrostatic equations for "
+                                               "pressure and temperature in depth. "
+                                               "The gravity is assumed to be in depth direction "
+                                               "and the composition is either given by the initial "
+                                               "composition at reference points or computed "
+                                               "as a reference depth-function. "
+                                               "All material parameters are computed by the "
+                                               "material model plugin. The surface conditions are "
+                                               "either constant or changing over time as prescribed "
+                                               "by a user-provided function.")
+  }
+}
diff --git a/cookbooks/tomography_based_plate_motions/plugins/reference_profile.h.bak b/cookbooks/tomography_based_plate_motions/plugins/reference_profile.h.bak
new file mode 100644
index 00000000000..9208fe70c82
--- /dev/null
+++ b/cookbooks/tomography_based_plate_motions/plugins/reference_profile.h.bak
@@ -0,0 +1,214 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_cookbooks_tomography_based_plate_motions_reference_profile_h
+#define _aspect_cookbooks_tomography_based_plate_motions_reference_profile_h
+
+
+#include <aspect/adiabatic_conditions/interface.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    using namespace dealii;
+
+    /**
+     * A model similar to the compute profile model
+     * in which the adiabatic profile is
+     * calculated by solving the hydrostatic equations for
+     * pressure and temperature in depth.
+     * The difference is that we use densities from
+     * an input reference profile to be consistent
+     * with the reference seismic profile against which
+     * the tomography model is generated.
+     * In regions where we do not use tomography model,
+     * the reference densities come from the material model.
+     * The gravity is assumed to be in depth direction
+     * and the composition is either given by the initial
+     * composition at reference points or computed
+     * as a reference depth-function.
+     * All material parameters are computed by the
+     * material model plugin. The surface conditions are
+     * either constant or changing over time as prescribed
+     * by an user-provided function.
+     */
+    template <int dim>
+    class ReferenceProfile : public Interface<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        ReferenceProfile ();
+
+        /**
+         * Initialization function. Because this function is called after
+         * initializing the SimulatorAccess, all of the necessary information
+         * is available to calculate the adiabatic profile. It computes the
+         * adiabatic conditions along a vertical transect of the geometry
+         * based on the given material model and other quantities.
+         */
+        void initialize () override;
+
+        /**
+         * Update function. By default does nothing, but if a time-dependent
+         * surface condition function is used, this will reinitialize the
+         * adiabatic profile with the current conditions.
+         */
+        void update () override;
+
+        /**
+         * Some plugins need to know whether the adiabatic conditions are
+         * already calculated. This is for example the case for the simple
+         * compressible material model, which uses the adiabatic temperature
+         * as reference temperature to calculate the density. For the
+         * calculation of the adiabatic conditions this functionality is
+         * simply switched off, because we are always on the reference
+         * profile. This way the plugin behaves differently at initialization
+         * time of the adiabatic conditions and during the main model run.
+         */
+        bool is_initialized() const override;
+
+        /**
+         * Return the adiabatic temperature at a given point of the domain.
+         */
+        double temperature (const Point<dim> &p) const override;
+
+        /**
+         * Return the adiabatic pressure at a given point of the domain.
+         */
+        double pressure (const Point<dim> &p) const override;
+
+        /**
+         * Return the reference density at a given point of the domain.
+         */
+        double density (const Point<dim> &p) const override;
+
+        /**
+         * Return the derivative of the density with respect to depth
+         * at the given point @p p.
+         */
+        double density_derivative (const Point<dim> &p) const override;
+
+        /**
+         * Declare the parameters for the input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * Whether the adiabatic conditions are already calculated. This is
+         * important for plugins that are used by the adiabatic conditions but
+         * also depend on the adiabatic conditions. This way they can behave
+         * differently in initialization and model run.
+         */
+        bool initialized;
+
+        /**
+         * Number of points at which we compute the adiabatic values.
+         */
+        unsigned int n_points;
+
+        /**
+         * Vectors of values of temperatures, pressures and densities on a transect into
+         * depth at which we have computed them. The public member functions
+         * of this class interpolate linearly between these points.
+         */
+        std::vector<double> temperatures;
+        std::vector<double> pressures;
+        std::vector<double> densities;
+
+        /**
+         * Interval spacing between each two data points in the tables above
+         * with regard to the depth coordinate.
+         */
+        double delta_z;
+
+        /**
+         * An enum describing the different options to compute the reference
+         * profile for composition.
+         */
+        enum CompositionProfile
+        {
+          initial_composition,
+          reference_function
+        };
+
+        /**
+         * Selected option to compute the reference profile for composition.
+         */
+        CompositionProfile reference_composition;
+
+        /**
+         * Function object that computes the reference composition profile
+         * if the reference_composition variable is set to function.
+         */
+        std::unique_ptr<Functions::ParsedFunction<1>> composition_function;
+
+        /**
+         * Whether to use the surface_conditions_function to determine surface
+         * conditions, or the adiabatic_surface_temperature and surface_pressure
+         * parameters. If this is set to true the reference profile is updated
+         * every timestep.
+         */
+        bool use_surface_condition_function;
+
+        /**
+         * ParsedFunction: If provided in the inpute file it prescribes
+         * (surface pressure(t), surface temperature(t)).
+         */
+        Functions::ParsedFunction<1> surface_condition_function;
+
+        /**
+         * Internal helper function. Returns the reference property at a
+         * given point of the domain.
+         */
+        double get_property (const Point<dim> &p,
+                             const std::vector<double> &property) const;
+
+
+        /**
+         * A reference profile for density and seismic velocities.
+         */
+        Utilities::AsciiDataProfile<dim> reference_profile;
+
+        /**
+         * The column index of the density column in the reference profile file.
+         */
+        unsigned int density_index;
+    };
+  }
+}
+
+
+#endif
diff --git a/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc b/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc
index d3c61e9a379..8a9fde17252 100644
--- a/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc
+++ b/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc
@@ -1635,7 +1635,7 @@ namespace aspect
       // reduce grain size.
       if (out.template get_additional_output<DislocationViscosityOutputs<dim>>() == nullptr)
         {
-          const unsigned int n_points = out.viscosities.size();
+          const unsigned int n_points = out.n_evaluation_points();
           out.additional_outputs.push_back(
             std::make_unique<MaterialModel::DislocationViscosityOutputs<dim>> (n_points));
         }
@@ -1643,7 +1643,7 @@ namespace aspect
       // We need the prescribed field outputs to interpolate the grain size onto a compositional field.
       if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
         {
-          const unsigned int n_points = out.viscosities.size();
+          const unsigned int n_points = out.n_evaluation_points();
           out.additional_outputs.push_back(
             std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points, this->n_compositional_fields()));
         }
@@ -1652,7 +1652,7 @@ namespace aspect
       if (use_table_properties
           && out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
         {
-          const unsigned int n_points = out.viscosities.size();
+          const unsigned int n_points = out.n_evaluation_points();
           out.additional_outputs.push_back(
             std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
         }
@@ -1660,7 +1660,7 @@ namespace aspect
       if (this->get_parameters().temperature_method == Parameters<dim>::AdvectionFieldMethod::prescribed_field &&
           out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
         {
-          const unsigned int n_points = out.viscosities.size();
+          const unsigned int n_points = out.n_evaluation_points();
           out.additional_outputs.push_back(
             std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>> (n_points));
         }
@@ -1668,14 +1668,14 @@ namespace aspect
       // We need additional field outputs for the unscaled viscosity
       if (out.template get_additional_output<UnscaledViscosityAdditionalOutputs<dim>>() == nullptr)
         {
-          const unsigned int n_points = out.viscosities.size();
+          const unsigned int n_points = out.n_evaluation_points();
           out.additional_outputs.push_back(
             std::make_unique<UnscaledViscosityAdditionalOutputs<dim>> (n_points));
         }
 
       if (out.template get_additional_output<MaterialTypeAdditionalOutputs<dim>>() == nullptr)
         {
-          const unsigned int n_points = out.viscosities.size();
+          const unsigned int n_points = out.n_evaluation_points();
           out.additional_outputs.push_back(
             std::make_unique<MaterialTypeAdditionalOutputs<dim>> (n_points));
         }
diff --git a/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc.bak b/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc.bak
new file mode 100644
index 00000000000..d3c61e9a379
--- /dev/null
+++ b/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc.bak
@@ -0,0 +1,1726 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "tomography_based_plate_motions.h"
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/initial_temperature/adiabatic_boundary.h>
+#include <aspect/simulator_signals.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/signaling_nan.h>
+
+#include <iostream>
+
+using namespace dealii;
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace
+    {
+      /**
+       * Additional output fields for the viscosity prior to scaling to be added to
+       * the MaterialModel::MaterialModelOutputs structure and filled in the
+       * MaterialModel::Interface::evaluate() function.
+       */
+      template <int dim>
+      class UnscaledViscosityAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
+      {
+        public:
+          UnscaledViscosityAdditionalOutputs(const unsigned int n_points)
+            : NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1, "unscaled_viscosity"),
+                                                  n_points)
+          {}
+      };
+
+      /**
+       * Additional output fields for the the material type, describing if we are in the
+       * crust/lithosphere/asthenosphere/lower mantle.
+       */
+      template <int dim>
+      class MaterialTypeAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
+      {
+        public:
+          MaterialTypeAdditionalOutputs(const unsigned int n_points)
+            : NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1, "material_type"),
+                                                  n_points)
+          {}
+      };
+    }
+  }
+
+
+  namespace internal
+  {
+    namespace
+    {
+      template <int dim>
+      class FunctorDepthAverageUnscaledViscosity: public internal::FunctorBase<dim>
+      {
+        public:
+          FunctorDepthAverageUnscaledViscosity()
+          {}
+
+          bool need_material_properties() const override
+          {
+            return true;
+          }
+
+          void
+          create_additional_material_model_outputs (const unsigned int n_points,
+                                                    MaterialModel::MaterialModelOutputs<dim> &outputs) const override
+          {
+            if (outputs.template get_additional_output<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>() == nullptr)
+              {
+                outputs.additional_outputs.push_back(
+                  std::make_unique<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>> (n_points));
+              }
+          }
+
+          void operator()(const MaterialModel::MaterialModelInputs<dim> &,
+                          const MaterialModel::MaterialModelOutputs<dim> &out,
+                          const FEValues<dim> &,
+                          const LinearAlgebra::BlockVector &,
+                          std::vector<double> &output) override
+          {
+            const MaterialModel::UnscaledViscosityAdditionalOutputs<dim> *unscaled_viscosity_outputs
+              = out.template get_additional_output<const MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>();
+
+            Assert(unscaled_viscosity_outputs != nullptr,ExcInternalError());
+
+            for (unsigned int q=0; q<output.size(); ++q)
+              output[q] = unscaled_viscosity_outputs->output_values[0][q];
+          }
+      };
+    }
+  }
+
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    TomographyBasedPlateMotions<dim>::initialize()
+    {
+      // Get reference viscosity profile from the ascii data
+      if (use_depth_dependent_viscosity)
+        reference_viscosity_coordinates = reference_viscosity_profile->get_interpolation_point_coordinates();
+
+      // Get column index for density scaling
+      if (use_depth_dependent_rho_vs)
+        {
+          rho_vs_depth_profile.initialize(this->get_mpi_communicator());
+          density_scaling_index = rho_vs_depth_profile.get_column_index_from_name("density_scaling");
+        }
+
+      if (use_depth_dependent_thermal_expansivity)
+        {
+          thermal_expansivity_profile.initialize(this->get_mpi_communicator());
+          thermal_expansivity_column_index = thermal_expansivity_profile.get_column_index_from_name("thermal_expansivity");
+        }
+
+      if (use_depth_dependent_dT_vs)
+        {
+          dT_vs_depth_profile.initialize(this->get_mpi_communicator());
+          temperature_scaling_index = dT_vs_depth_profile.get_column_index_from_name("temperature_scaling");
+        }
+
+      // Get column for crustal depths
+      std::set<types::boundary_id> surface_boundary_set;
+      surface_boundary_set.insert(this->get_geometry_model().translate_symbolic_boundary_name_to_id("top"));
+      crustal_boundary_depth.initialize(surface_boundary_set, 1);
+
+      // The update() function updates the profile that stores the laterally averaged viscosity.
+      // This is needed to compute the viscosity in the material model (since the viscosities are rescaled
+      // so that the lateral average matches the reference profile). Since the viscosity depends on both
+      // temperature and velocity, we want to update the lateral average profile after each temperature
+      // and Stokes solve.
+      this->get_signals().post_stokes_solver.connect([&](const SimulatorAccess<dim> &,
+                                                         const unsigned int ,
+                                                         const unsigned int ,
+                                                         const SolverControl &,
+                                                         const SolverControl &)
+      {
+        this->update();
+      });
+
+      this->get_signals().post_advection_solver.connect([&](const SimulatorAccess<dim> &,
+                                                            const unsigned int ,
+                                                            const unsigned int ,
+                                                            const SolverControl &)
+      {
+        this->update();
+      });
+
+      n_material_data = material_file_names.size();
+      for (unsigned i = 0; i < n_material_data; i++)
+        {
+          if (material_file_format == perplex)
+            material_lookup.emplace_back(std::make_shared<MaterialUtilities::Lookup::PerplexReader>
+                                         (data_directory+material_file_names[i],
+                                          /*use_bilinear_interpolation*/ true,
+                                          this->get_mpi_communicator()));
+          else if (material_file_format == hefesto)
+            material_lookup.emplace_back(std::make_shared<MaterialUtilities::Lookup::HeFESToReader>
+                                         (data_directory+material_file_names[i],
+                                          data_directory+derivatives_file_names[i],
+                                          /*use_bilinear_interpolation*/ true,
+                                          this->get_mpi_communicator()));
+          else
+            AssertThrow (false, ExcNotImplemented());
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    TomographyBasedPlateMotions<dim>::update()
+    {
+      if (use_depth_dependent_viscosity)
+        {
+          std::vector<std::unique_ptr<internal::FunctorBase<dim>>> lateral_averaging_properties;
+          lateral_averaging_properties.emplace_back(std::make_unique<internal::FunctorDepthAverageUnscaledViscosity<dim>>());
+
+          std::vector<std::vector<double>> averages =
+            this->get_lateral_averaging().compute_lateral_averages(reference_viscosity_coordinates,
+                                                                   lateral_averaging_properties);
+
+          average_viscosity_profile = std::move(averages[0]);
+
+          for (const auto &lateral_viscosity_average: average_viscosity_profile)
+            AssertThrow(numbers::is_finite(lateral_viscosity_average),
+                        ExcMessage("In computing depth averages, there is at"
+                                   " least one depth band that does not have"
+                                   " any quadrature points in it."
+                                   " Consider reducing number of depth layers"
+                                   " for averaging."));
+        }
+    }
+
+
+
+    template <int dim>
+    std::pair<double, unsigned int>
+    TomographyBasedPlateMotions<dim>::get_reference_viscosity (const double depth) const
+    {
+      // Make maximal depth slightly larger to ensure depth < maximal_depth
+      const double maximal_depth = this->get_geometry_model().maximal_depth() *
+                                   (1.0+std::numeric_limits<double>::epsilon());
+      (void) maximal_depth;
+
+      Assert(depth < maximal_depth, ExcInternalError());
+      Assert(depth > -maximal_depth*std::numeric_limits<double>::epsilon(), ExcInternalError());
+
+      unsigned int depth_index;
+      if (depth < reference_viscosity_coordinates.front())
+        {
+          depth_index = 0;
+        }
+      else if (depth > reference_viscosity_coordinates.back())
+        {
+          depth_index = reference_viscosity_coordinates.size() - 1;
+        }
+      else
+        {
+          depth_index = std::distance(reference_viscosity_coordinates.begin(),
+                                      std::lower_bound(reference_viscosity_coordinates.begin(),
+                                                       reference_viscosity_coordinates.end(),
+                                                       depth));
+        }
+      if (depth_index > 0)
+        --depth_index;
+
+      // When evaluating reference viscosity, evaluate at the next lower depth that is stored
+      // in the reference profile instead of the actual depth. This makes the profile piecewise
+      // constant. This will be specific to the viscosity profile used (and ignore the entry with
+      // the largest depth in the profile).
+      double reference_viscosity = reference_viscosity_profile->compute_viscosity(reference_viscosity_coordinates.at(depth_index));
+
+      // By default, ashtenosphere_viscosity is set to the second layer in the reference profile.
+      if (depth_index == 1)
+        reference_viscosity = asthenosphere_viscosity;
+
+      return std::make_pair (reference_viscosity, depth_index);
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::get_depth_of_base_of_uppermost_mantle () const
+    {
+      return depth_to_base_of_uppermost_mantle;
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::compute_viscosity_scaling (const double depth) const
+    {
+      Assert(average_viscosity_profile.size() != 0,
+             ExcMessage("The average viscosity profile has not yet been computed. "
+                        "Unable to scale viscosities"));
+
+      const std::pair<double, unsigned int> reference_viscosity_and_depth_index = get_reference_viscosity (depth);
+
+      const double average_viscosity = std::pow(10, average_viscosity_profile[reference_viscosity_and_depth_index.second]);
+
+      return reference_viscosity_and_depth_index.first / average_viscosity;
+    }
+
+
+
+    template <int dim>
+    void
+    TomographyBasedPlateMotions<dim>::compute_equilibrium_grain_size(const typename Interface<dim>::MaterialModelInputs &in,
+                                                                     typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
+      DislocationViscosityOutputs<dim> *disl_viscosities_out = out.template get_additional_output<DislocationViscosityOutputs<dim>>();
+
+      UnscaledViscosityAdditionalOutputs<dim> *unscaled_viscosity_out =
+        out.template get_additional_output<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>();
+
+      const InitialTemperature::AdiabaticBoundary<dim> &adiabatic_boundary =
+        initial_temperature_manager->template get_matching_initial_temperature_model<InitialTemperature::AdiabaticBoundary<dim>>();
+
+      const unsigned int surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("outer");
+
+      const unsigned int grain_size_index = this->introspection().compositional_index_for_name("grain_size");
+
+      const unsigned int craton_index = (use_cratons)
+                                        ?
+                                        this->introspection().compositional_index_for_name("continents")
+                                        :
+                                        numbers::invalid_unsigned_int;
+
+      unsigned int ridge_index  = numbers::invalid_unsigned_int;
+      unsigned int trench_index = numbers::invalid_unsigned_int;
+      unsigned int fault_index  = numbers::invalid_unsigned_int;
+
+      if (use_faults)
+        {
+          if (use_varying_fault_viscosity)
+            {
+              ridge_index  = this->introspection().compositional_index_for_name("ridges");
+              trench_index = this->introspection().compositional_index_for_name("trenches");
+            }
+          else
+            fault_index  = this->introspection().compositional_index_for_name("faults");
+        }
+
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          const double depth = this->get_geometry_model().depth(in.position[i]);
+
+          // Use the adiabatic pressure instead of the real one, because of oscillations
+          const double pressure = (this->get_adiabatic_conditions().is_initialized())
+                                  ?
+                                  this->get_adiabatic_conditions().pressure(in.position[i])
+                                  :
+                                  in.pressure[i];
+
+          Assert(pressure >= 0.0,
+                 ExcMessage("Pressure has to be non-negative for the viscosity computation. Instead it is: "
+                            + std::to_string(pressure)));
+
+          double lithosphere_thickness = 100.e3;
+          // Get variable lithosphere using an adiabatic boundary ascii file
+          // Only use ascii data boundary file if not using a constant thickness for lithosphere
+          if (this->get_adiabatic_conditions().is_initialized() && !use_constant_lithosphere_thickness)
+            lithosphere_thickness = adiabatic_boundary.get_data_component(surface_boundary_id, in.position[i], 0);
+
+          const unsigned int phase_index = get_phase_index(in.position[i], in.temperature[i], pressure);
+
+          // Computed according to equation (7) in Dannberg et al., 2016, using the paleowattmeter grain size.
+          // Austin and Evans (2007): Paleowattmeters: A scaling relation for dynamically recrystallized grain size. Geology 35, 343-346.
+          const double prefactor = geometric_constant[phase_index] * grain_boundary_energy[phase_index] * grain_growth_rate_constant[phase_index]
+                                   / (boundary_area_change_work_fraction[phase_index] * grain_growth_exponent[phase_index]);
+          const double exponential = std::exp(- (grain_growth_activation_energy[phase_index] + pressure * grain_growth_activation_volume[phase_index])
+                                              / (constants::gas_constant * in.temperature[i]));
+
+          // get the dislocation viscosity to compute the dislocation strain rate
+          // If we do not have the strain rate yet, set it to a low value.
+          // TODO: make minimum strain rate an input parameter
+          const SymmetricTensor<2,dim> shear_strain_rate = in.strain_rate[i] - 1./dim * trace(in.strain_rate[i]) * unit_symmetric_tensor<dim>();
+          const double second_strain_rate_invariant = std::sqrt(std::abs(second_invariant(shear_strain_rate)));
+
+          // TODO: if we update the interface of the diffusion_viscosity and dislocation_viscosity functions,
+          // we don't need this vector anymore
+          std::vector<double> composition (in.composition[i]);
+          double grain_size = in.composition[i][grain_size_index];
+          grain_size = std::max(min_grain_size, grain_size);
+
+          // Only consider dislocation creep and equilibrium grain size if we have a sufficient strain rate
+          if (std::abs(second_strain_rate_invariant > 1e-30))
+            {
+              unsigned int j = 0;
+              double old_grain_size = 0.0;
+
+              // because the diffusion viscosity depends on the grain size itself, and we need it to compute the dislocation strain rate,
+              // we have to iterate in the computation of the equilibrium grain size
+              while ((std::abs((grain_size-old_grain_size) / grain_size) > dislocation_viscosity_iteration_threshold)
+                     && (j < dislocation_viscosity_iteration_number))
+                {
+                  composition[grain_size_index] = std::max(min_grain_size, grain_size);
+                  const double diff_viscosity = diffusion_viscosity(in.temperature[i], pressure, composition, in.strain_rate[i], in.position[i]);
+                  const double disl_viscosity = dislocation_viscosity(in.temperature[i], pressure, composition, in.strain_rate[i], in.position[i], diff_viscosity);
+
+                  if (disl_viscosities_out != nullptr)
+                    {
+                      disl_viscosities_out->diffusion_viscosities[i] = diff_viscosity;
+                      disl_viscosities_out->dislocation_viscosities[i] = std::min(std::max(min_eta,disl_viscosity),1e30);
+                    }
+
+                  out.viscosities[i] = diff_viscosity * disl_viscosity / (disl_viscosity + diff_viscosity);
+
+                  Assert(out.viscosities[i] > 0.0,
+                         ExcMessage("Negative viscosity is not allowed. Current viscosity is: " + std::to_string(out.viscosities[i])));
+
+                  // This follows from Equation (S25 - S30)
+                  const double dislocation_strain_rate_invariant = second_strain_rate_invariant
+                                                                   * out.viscosities[i] / disl_viscosity;
+                  const double stress_term = 4.0 * out.viscosities[i] * second_strain_rate_invariant * dislocation_strain_rate_invariant;
+
+                  old_grain_size = grain_size;
+
+                  if (equilibrate_grain_size)
+                    grain_size = 0.9 * old_grain_size + 0.1 * std::pow(prefactor/stress_term * exponential,1./(1+grain_growth_exponent[phase_index]));
+
+                  ++j;
+                }
+            }
+          else
+            {
+              out.viscosities[i] = diffusion_viscosity(in.temperature[i], pressure, composition, in.strain_rate[i], in.position[i]);
+
+              if (disl_viscosities_out != nullptr)
+                {
+                  disl_viscosities_out->diffusion_viscosities[i] = out.viscosities[i];
+                  disl_viscosities_out->dislocation_viscosities[i] = 1e30;
+                }
+            }
+
+          if (unscaled_viscosity_out != nullptr)
+            unscaled_viscosity_out->output_values[0][i] = std::log10(out.viscosities[i]);
+
+          if (use_depth_dependent_viscosity)
+            {
+              const double viscosity_scaling_below_this_depth = 60e3;
+
+              // Scale viscosity so that laterally averaged viscosity == reference viscosity profile
+              // Only scale if average viscosity is already available and we are below a specified depth.
+              if (average_viscosity_profile.size() != 0 && depth > viscosity_scaling_below_this_depth)
+                out.viscosities[i] *= compute_viscosity_scaling(this->get_geometry_model().depth(in.position[i]));
+            }
+
+          // We assume a constant lithospheric viscosity if using constant thickness lithosphere
+          // based on Tutu et al., (2018).
+          if (use_constant_lithosphere_thickness && depth <= lithosphere_thickness)
+            out.viscosities[i] = 1e24;
+
+          // Ensure we respect viscosity bounds
+          out.viscosities[i] = std::min(std::max(min_eta, out.viscosities[i]),max_eta);
+
+          // This represents the viscosity with respect to which we want to define cratons/faults.
+          const double background_viscosity_log = std::log10(out.viscosities[i]);
+
+          // If using faults, use the composition value to compute the viscosity instead
+          // We extend the faults to depths 40 km more than the lithospheric depths because otherwise
+          // faults do not extend through the lithosphere in our high-resolution models.
+          if (use_faults)
+            {
+              if (use_varying_fault_viscosity)
+                {
+                  if (in.composition[i][ridge_index] > 0. && depth <= lithosphere_thickness + 40e3)
+                    out.viscosities[i] = std::pow(10,
+                                                  std::log10(ridge_viscosity) * in.composition[i][ridge_index]
+                                                  + background_viscosity_log * (1. - in.composition[i][ridge_index]));
+                  if (in.composition[i][trench_index] > 0. && depth <= lithosphere_thickness + 40e3)
+                    out.viscosities[i] = std::pow(10,
+                                                  std::log10(trench_viscosity) * in.composition[i][trench_index]
+                                                  + background_viscosity_log * (1. - in.composition[i][trench_index]));
+                }
+
+              else
+                {
+                  if (in.composition[i][fault_index] > 0. && depth <= lithosphere_thickness + 40e3)
+                    out.viscosities[i] = std::pow(10,
+                                                  std::log10(fault_viscosity) * in.composition[i][fault_index]
+                                                  + background_viscosity_log * (1. - in.composition[i][fault_index]));
+                }
+            }
+
+          // If using cratons, use the composition value to compute the viscosity instead. The cratons in the
+          // compositional field extend until 300 km (Becker 2006, Miller and Becker, 2012), we assume that the
+          // cratonic keels are stiffer than the surrounding lithosphere
+          if (use_cratons && in.composition[i][craton_index] > 0. && depth <= lithosphere_thickness)
+            {
+              out.viscosities[i] = std::pow(10,
+                                            std::log10(craton_viscosity) * in.composition[i][craton_index]
+                                            + background_viscosity_log * (1. - in.composition[i][craton_index]));
+            }
+
+          Assert(out.viscosities[i] > 0,
+                 ExcMessage("Viscosity has to be positive. Instead it is: " + std::to_string(out.viscosities[i])));
+
+          // Fill the prescribed outputs for grain size and assign faults to a prescribed field for diffusion.
+          if (prescribed_field_out != nullptr)
+            for (unsigned int c=0; c<composition.size(); ++c)
+              {
+                if (c == grain_size_index)
+                  prescribed_field_out->prescribed_field_outputs[i][c] = std::max(min_grain_size, grain_size);
+                else if (c == fault_index)
+                  prescribed_field_out->prescribed_field_outputs[i][c] = in.composition[i][fault_index];
+                else
+                  prescribed_field_out->prescribed_field_outputs[i][c] = 0.;
+              }
+
+          if (this->get_nonlinear_iteration() == 0 && use_depth_dependent_viscosity)
+            out.viscosities[i] = get_reference_viscosity(depth).first;
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::
+    phase_function (const Point<dim> &position,
+                    const double temperature,
+                    const double pressure,
+                    const unsigned int phase) const
+    {
+      Assert(phase < transition_depths.size(),
+             ExcMessage("Error: Phase index is too large. This phase index does not exist!"));
+
+      // if we already have the adiabatic conditions, we can use them
+      if (this->get_adiabatic_conditions().is_initialized())
+        {
+          // first, get the pressure at which the phase transition occurs normally
+          const Point<dim,double> transition_point = this->get_geometry_model().representative_point(transition_depths[phase]);
+          const double transition_pressure = this->get_adiabatic_conditions().pressure(transition_point);
+
+          // then calculate the deviation from the transition point (both in temperature
+          // and in pressure)
+          const double pressure_deviation = pressure - transition_pressure
+                                            - transition_slopes[phase] * (temperature - transition_temperatures[phase]);
+
+          // last, calculate the percentage of material that has undergone the transition
+          return (pressure_deviation > 0) ? 1 : 0;
+        }
+
+      // if we do not have the adiabatic conditions, we have to use the depth instead
+      // this is less precise, because we do not have the exact pressure gradient, instead we use pressure/depth
+      // (this is for calculating e.g. the density in the adiabatic profile)
+      else
+        {
+          const double depth = this->get_geometry_model().depth(position);
+          const double depth_deviation = (pressure > 0
+                                          ?
+                                          depth - transition_depths[phase]
+                                          - transition_slopes[phase] * (depth / pressure) * (temperature - transition_temperatures[phase])
+                                          :
+                                          depth - transition_depths[phase]
+                                          - transition_slopes[phase] / (this->get_gravity_model().gravity_vector(position).norm() * reference_rho)
+                                          * (temperature - transition_temperatures[phase]));
+
+          return (depth_deviation > 0) ? 1 : 0;
+        }
+    }
+
+
+
+    template <int dim>
+    unsigned int
+    TomographyBasedPlateMotions<dim>::
+    get_phase_index (const Point<dim> &position,
+                     const double temperature,
+                     const double pressure) const
+    {
+      Assert(grain_growth_activation_energy.size()>0,
+             ExcMessage("Error: No grain evolution parameters are given!"));
+
+      unsigned int phase_index = 0;
+      if (transition_depths.size()>0)
+        if (phase_function(position, temperature, pressure, transition_depths.size()-1) == 1)
+          phase_index = transition_depths.size();
+
+      for (unsigned int j=1; j<transition_depths.size(); ++j)
+        if (phase_function(position, temperature, pressure, j) != phase_function(position, temperature, pressure, j-1))
+          phase_index = j;
+
+      return phase_index;
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::
+    diffusion_viscosity (const double                  temperature,
+                         const double                  pressure,
+                         const std::vector<double>    &composition,
+                         const SymmetricTensor<2,dim> &strain_rate,
+                         const Point<dim>             &position) const
+    {
+      const SymmetricTensor<2,dim> shear_strain_rate = strain_rate - 1./dim * trace(strain_rate) * unit_symmetric_tensor<dim>();
+      const double second_strain_rate_invariant = std::sqrt(std::abs(second_invariant(shear_strain_rate)));
+
+      const double grain_size = composition[this->introspection().compositional_index_for_name("grain_size")];
+
+      // Currently this will never be called without adiabatic_conditions initialized, but just in case
+      const double adiabatic_pressure = this->get_adiabatic_conditions().is_initialized()
+                                        ?
+                                        this->get_adiabatic_conditions().pressure(position)
+                                        :
+                                        pressure;
+
+      // find out in which phase we are
+      const unsigned int phase_index = get_phase_index(position, temperature, adiabatic_pressure);
+
+      Assert(temperature > 0.0,
+             ExcMessage("Temperature has to be positive for diffusion creep. Instead it is: " + std::to_string(temperature)));
+      Assert(pressure >= 0.0,
+             ExcMessage("Adiabatic pressure has to be non-negative for diffusion creep. Instead it is: " + std::to_string(adiabatic_pressure)));
+
+      double energy_term = std::exp((diffusion_activation_energy[phase_index] + diffusion_activation_volume[phase_index] * adiabatic_pressure)
+                                    / (diffusion_creep_exponent[phase_index] * constants::gas_constant * temperature));
+
+      Assert(energy_term > 0.0,
+             ExcMessage("Energy term has to be positive for diffusion creep. Instead it is: " + std::to_string(energy_term)));
+
+      // If the adiabatic profile is already calculated we can use it to limit
+      // variations in viscosity due to temperature.
+      if (this->get_adiabatic_conditions().is_initialized())
+        {
+          const double adiabatic_temperature = this->get_adiabatic_conditions().temperature(position);
+          Assert(adiabatic_temperature > 0.0,
+                 ExcMessage("Adiabatic temperature has to be positive for diffusion creep. Instead it is: " + std::to_string(adiabatic_temperature)));
+
+          const double adiabatic_energy_term
+            = std::exp((diffusion_activation_energy[phase_index] + diffusion_activation_volume[phase_index] * adiabatic_pressure)
+                       / (diffusion_creep_exponent[phase_index] * constants::gas_constant * adiabatic_temperature));
+
+          Assert(adiabatic_energy_term > 0.0,
+                 ExcMessage("Adiabatic energy term has to be positive for diffusion creep. Instead it is: " + std::to_string(adiabatic_energy_term)));
+
+          const double temperature_dependence = energy_term / adiabatic_energy_term;
+          if (temperature_dependence > max_temperature_dependence_of_eta)
+            energy_term = adiabatic_energy_term * max_temperature_dependence_of_eta;
+          if (temperature_dependence < 1.0 / max_temperature_dependence_of_eta)
+            energy_term = adiabatic_energy_term / max_temperature_dependence_of_eta;
+        }
+
+      const double strain_rate_dependence = (1.0 - diffusion_creep_exponent[phase_index]) / diffusion_creep_exponent[phase_index];
+
+      const double diffusion_viscosity = std::pow(diffusion_creep_prefactor[phase_index],-1.0/diffusion_creep_exponent[phase_index])
+                                         * std::pow(second_strain_rate_invariant,strain_rate_dependence)
+                                         * std::pow(grain_size, diffusion_creep_grain_size_exponent[phase_index]/diffusion_creep_exponent[phase_index])
+                                         * energy_term;
+
+      Assert(diffusion_viscosity > 0.0,
+             ExcMessage("Diffusion viscosity has to be positive. Instead it is: " + std::to_string(diffusion_viscosity)));
+
+      return diffusion_viscosity;
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::
+    dislocation_viscosity (const double      temperature,
+                           const double      pressure,
+                           const std::vector<double> &composition,
+                           const SymmetricTensor<2,dim> &strain_rate,
+                           const Point<dim> &position,
+                           const double viscosity_guess) const
+    {
+      const double diff_viscosity = diffusion_viscosity(temperature,pressure,composition,strain_rate,position);
+
+      // If we do not have the strain rate yet, set it to a low value.
+      // TODO: make minimum strain rate an input parameter
+      const SymmetricTensor<2,dim> shear_strain_rate = strain_rate - 1./dim * trace(strain_rate) * unit_symmetric_tensor<dim>();
+      const double second_strain_rate_invariant = std::max(std::sqrt(std::abs(second_invariant(shear_strain_rate))),1e-30);
+
+      // Start the iteration with the full strain rate
+      double dis_viscosity = viscosity_guess;
+      if (viscosity_guess == 0)
+        dis_viscosity = dislocation_viscosity_fixed_strain_rate(temperature,pressure,second_strain_rate_invariant,position);
+
+      double dis_viscosity_old = 0;
+      unsigned int i = 0;
+      while ((std::abs((dis_viscosity-dis_viscosity_old) / dis_viscosity) > dislocation_viscosity_iteration_threshold)
+             && (i < dislocation_viscosity_iteration_number))
+        {
+          const double dislocation_strain_rate = diff_viscosity / (diff_viscosity + dis_viscosity) * second_strain_rate_invariant;
+          dis_viscosity_old = dis_viscosity;
+          dis_viscosity = dislocation_viscosity_fixed_strain_rate(temperature,
+                                                                  pressure,
+                                                                  dislocation_strain_rate,
+                                                                  position);
+
+          Assert(dis_viscosity > 0.0,
+                 ExcMessage("Encountered negative dislocation viscosity in iteration " + std::to_string(i) +
+                            ". Dislocation viscosity is: " + std::to_string(dis_viscosity)));
+          ++i;
+        }
+
+      Assert(i<dislocation_viscosity_iteration_number,ExcInternalError());
+
+      return dis_viscosity;
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::
+    dislocation_viscosity_fixed_strain_rate (const double      temperature,
+                                             const double      pressure,
+                                             const double      second_strain_rate_invariant,
+                                             const Point<dim> &position) const
+    {
+      Assert(temperature > 0.0,
+             ExcMessage("Temperature has to be positive for dislocation creep. Instead it is: " + std::to_string(temperature)));
+      Assert(pressure >= 0.0,
+             ExcMessage("Pressure has to be non-negative for dislocation creep. Instead it is: " + std::to_string(pressure)));
+
+      // find out in which phase we are
+      const unsigned int phase_index = get_phase_index(position, temperature, pressure);
+
+      double energy_term = std::exp((dislocation_activation_energy[phase_index] + dislocation_activation_volume[phase_index] * pressure)
+                                    / (dislocation_creep_exponent[phase_index] * constants::gas_constant * temperature));
+
+      Assert(energy_term > 0.0,
+             ExcMessage("Energy term has to be positive for dislocation creep. Instead it is: " + std::to_string(energy_term)));
+
+      // If we are past the initialization of the adiabatic profile, use it to
+      // limit viscosity variations due to temperature.
+      if (this->get_adiabatic_conditions().is_initialized())
+        {
+          const double adiabatic_energy_term
+            = exp((dislocation_activation_energy[phase_index] + dislocation_activation_volume[phase_index] * pressure)
+                  / (dislocation_creep_exponent[phase_index] * constants::gas_constant * this->get_adiabatic_conditions().temperature(position)));
+
+          Assert(adiabatic_energy_term > 0.0,
+                 ExcMessage("Adiabatic energy term has to be positive for dislocation creep. Instead it is: " + std::to_string(adiabatic_energy_term)));
+
+          const double temperature_dependence = energy_term / adiabatic_energy_term;
+          if (temperature_dependence > max_temperature_dependence_of_eta)
+            energy_term = adiabatic_energy_term * max_temperature_dependence_of_eta;
+          if (temperature_dependence < 1.0 / max_temperature_dependence_of_eta)
+            energy_term = adiabatic_energy_term / max_temperature_dependence_of_eta;
+        }
+
+      const double strain_rate_dependence = (1.0 - dislocation_creep_exponent[phase_index]) / dislocation_creep_exponent[phase_index];
+
+      const double dislocation_viscosity = std::pow(dislocation_creep_prefactor[phase_index],-1.0/dislocation_creep_exponent[phase_index])
+                                           * std::pow(second_strain_rate_invariant,strain_rate_dependence)
+                                           * energy_term;
+
+      Assert(dislocation_viscosity > 0.0,
+             ExcMessage("Dislocation viscosity has to be positive. Instead it is: " + std::to_string(dislocation_viscosity)));
+
+      return dislocation_viscosity;
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::
+    seismic_Vp (const double      temperature,
+                const double      pressure,
+                const std::vector<double> &compositional_fields,
+                const Point<dim> &/*position*/) const
+    {
+      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
+                   ExcMessage("Currently only compressible models are supported."));
+
+      if (n_material_data == 1)
+        return material_lookup[0]->seismic_Vp(temperature,pressure);
+      else
+        {
+          double vp = 0.0;
+          for (unsigned i = 0; i < n_material_data; i++)
+            vp += compositional_fields[i] * material_lookup[i]->seismic_Vp(temperature,pressure);
+          return vp;
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::
+    seismic_Vs (const double      temperature,
+                const double      pressure,
+                const std::vector<double> &compositional_fields,
+                const Point<dim> &/*position*/) const
+    {
+      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
+                   ExcMessage("Currently only compressible models are supported."));
+
+      if (n_material_data == 1)
+        return material_lookup[0]->seismic_Vs(temperature,pressure);
+      else
+        {
+          double vs = 0.0;
+          for (unsigned i = 0; i < n_material_data; i++)
+            vs += compositional_fields[i] * material_lookup[i]->seismic_Vs(temperature,pressure);
+          return vs;
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::
+    density (const double temperature,
+             const double pressure,
+             const std::vector<double> &compositional_fields, /*composition*/
+             const Point<dim> &) const
+    {
+      double rho = 0.0;
+      if (n_material_data == 1)
+        {
+          return material_lookup[0]->density(temperature,pressure);
+        }
+      else
+        {
+          for (unsigned i = 0; i < n_material_data; i++)
+            rho += compositional_fields[i] * material_lookup[i]->density(temperature,pressure);
+          return rho;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    TomographyBasedPlateMotions<dim>::
+    is_compressible () const
+    {
+      return (reference_compressibility != 0)
+             || use_table_properties;
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::
+    compressibility (const double temperature,
+                     const double pressure,
+                     const std::vector<double> &compositional_fields,
+                     const Point<dim> &position) const
+    {
+      double dRhodp = 0.0;
+      if (n_material_data == 1)
+        dRhodp = material_lookup[0]->dRhodp(temperature,pressure);
+      else
+        {
+          for (unsigned i = 0; i < n_material_data; i++)
+            dRhodp += compositional_fields[i] * material_lookup[i]->dRhodp(temperature,pressure);
+        }
+      const double rho = density(temperature,pressure,compositional_fields,position);
+      return (1/rho)*dRhodp;
+    }
+
+
+
+    template <int dim>
+    double
+    TomographyBasedPlateMotions<dim>::
+    thermal_expansivity (const double temperature,
+                         const double pressure,
+                         const std::vector<double> &compositional_fields,
+                         const Point<dim> &) const
+    {
+      if (n_material_data == 1)
+        return material_lookup[0]->thermal_expansivity(temperature,pressure);
+      else
+        {
+          double alpha = 0.0;
+          for (unsigned i = 0; i < n_material_data; i++)
+            alpha += compositional_fields[i] * material_lookup[i]->thermal_expansivity(temperature,pressure);
+          return alpha;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    TomographyBasedPlateMotions<dim>::
+    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      // Determine some properties that are constant for all points
+      const unsigned int vs_anomaly_index = this->introspection().compositional_index_for_name("vs_anomaly");
+      const unsigned int surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("outer");
+
+      const unsigned int craton_index = (use_cratons)
+                                        ?
+                                        this->introspection().compositional_index_for_name("continents")
+                                        :
+                                        numbers::invalid_unsigned_int;
+
+      if (initial_temperature_manager == nullptr)
+        const_cast<std::shared_ptr<const aspect::InitialTemperature::Manager<dim>>&>(initial_temperature_manager)
+          = this->get_initial_temperature_manager_pointer();
+
+      const InitialTemperature::AdiabaticBoundary<dim> &adiabatic_boundary =
+        initial_temperature_manager->template get_matching_initial_temperature_model<InitialTemperature::AdiabaticBoundary<dim>>();
+
+      // This function will fill the outputs for grain size, viscosity, and dislocation viscosity
+      if (in.requests_property(MaterialProperties::viscosity))
+        compute_equilibrium_grain_size(in, out);
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          // Use the adiabatic pressure instead of the real one, because of oscillations
+          const double pressure = (this->get_adiabatic_conditions().is_initialized())
+                                  ?
+                                  this->get_adiabatic_conditions().pressure(in.position[i])
+                                  :
+                                  in.pressure[i];
+
+          out.thermal_conductivities[i] = k_value;
+          out.specific_heat[i] = reference_specific_heat;
+
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+
+          const double depth = this->get_geometry_model().depth(in.position[i]);
+          const double delta_log_vs = in.composition[i][vs_anomaly_index];
+
+          // For computing the adiabatic conditions, we want to use the temperature it hands
+          // over as input. Once the adiabatic conditions are computed, we want to use the
+          // temperature based on seismic tomography and the input temperature model.
+          double new_temperature = in.temperature[i];
+
+          // For the adiabatic conditions, assume a characteristic crustal and lithosphere thickness.
+          double crustal_thickness = 40000.;
+          double lithosphere_thickness = 100000.;
+
+          if (this->get_adiabatic_conditions().is_initialized())
+            {
+              // Get variable lithosphere and crustal depths using an adiabatic boundary ascii file
+              lithosphere_thickness = adiabatic_boundary.get_data_component(surface_boundary_id, in.position[i], 0);
+              crustal_thickness = crustal_boundary_depth.get_data_component(surface_boundary_id, in.position[i], 0);
+
+              if (use_constant_lithosphere_thickness)
+                lithosphere_thickness = 100e3;
+
+              // This variable stores the seismic tomography based temperatures
+              double mantle_temperature;
+
+              // This does not work when it is called before the adiabatic conditions are initialized, because
+              // the AsciiDataBoundary plugin needs the time, which is not yet initialized at that point.
+              const double initial_temperature = initial_temperature_manager->initial_temperature(in.position[i]);
+              const double reference_temperature = this->get_adiabatic_conditions().temperature(in.position[i]);
+
+              if (use_depth_dependent_dT_vs)
+                {
+                  // We use the dlnvs/dT profile from Steinberger and Calderwood (2006). The values in profile are in units 1/K .
+                  mantle_temperature = reference_temperature +
+                                       delta_log_vs * dT_vs_depth_profile.get_data_component(Point<1>(depth), temperature_scaling_index);
+                }
+
+              else
+                {
+                  // compute the temperature below the asthenosphere using the parameters given in the table by Becker (2006).
+                  mantle_temperature = reference_temperature + delta_log_vs * -4.2 * 1785.;
+                }
+
+              const double sigmoid_width = 2.e4;
+              const double sigmoid = 1.0 / (1.0 + std::exp( (depth_to_base_of_uppermost_mantle - depth)/sigmoid_width));
+
+              new_temperature = initial_temperature + (mantle_temperature - initial_temperature) * sigmoid;
+            }
+
+          if (PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>())
+            prescribed_temperature_out->prescribed_temperature_outputs[i] = new_temperature;
+
+          if (use_table_properties)
+            {
+              // fill seismic velocities outputs if they exist
+              if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
+                {
+                  seismic_out->vp[i] = seismic_Vp(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
+                  seismic_out->vs[i] = seismic_Vs(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
+                }
+
+              out.densities[i] = density(new_temperature, pressure, in.composition[i], in.position[i]);
+              out.thermal_expansion_coefficients[i] = thermal_expansivity(new_temperature, pressure, in.composition[i], in.position[i]);
+              out.compressibilities[i] = compressibility(new_temperature, pressure, in.composition[i], in.position[i]);
+            }
+          else
+            {
+              // Temperature and density of the upper part of the mantle are computed separately,
+              // based on Tutu et al. (2018).
+              double deltaT  = new_temperature - 293.;
+
+              unsigned int material_type = 0;
+
+              // Density computation
+              if (depth <= crustal_thickness)
+                {
+                  out.thermal_expansion_coefficients[i] = 2.7e-5;
+                  out.compressibilities[i] = 1./6.3e10;
+                  out.densities[i] = 2.85e3 * (1. - out.thermal_expansion_coefficients[i] * deltaT
+                                               + pressure * out.compressibilities[i]);
+                  material_type = 1;
+                }
+              else if (depth > crustal_thickness && depth <= lithosphere_thickness)
+                {
+                  out.thermal_expansion_coefficients[i] = 3.e-5;
+                  out.compressibilities[i] = 1./12.2e10;
+
+                  // Use adiabatic density increase when using constant lithosphere, Tutu et al., (2018)
+                  if (use_constant_lithosphere_thickness)
+                    deltaT = this->get_adiabatic_conditions().temperature(in.position[i]) - 293;
+
+                  out.densities[i] = 3.27e3 * (1. - out.thermal_expansion_coefficients[i] * deltaT
+                                               + pressure * out.compressibilities[i]);
+                  material_type = 2;
+
+                  if (use_cratons)
+                    {
+                      // Density increase along adiabatic profile
+                      const double craton_density = 3.27e3 * ( 1. - out.thermal_expansion_coefficients[i] *
+                                                               (this->get_adiabatic_conditions().temperature(in.position[i]) - 293)
+                                                               + pressure * out.compressibilities[i]);
+
+                      out.densities[i] = craton_density * in.composition[i][craton_index] +
+                                         out.densities[i] * (1. - in.composition[i][craton_index]);
+                    }
+                }
+              else if (depth > lithosphere_thickness && depth <= depth_to_base_of_uppermost_mantle)
+                {
+                  out.thermal_expansion_coefficients[i] = 3.e-5;
+                  out.compressibilities[i] = 1./12.2e10;
+                  out.densities[i] = 3.3e3 * (1. - out.thermal_expansion_coefficients[i] * deltaT
+                                              + pressure * out.compressibilities[i]);
+                  material_type = 3;
+                }
+              else
+                {
+                  // Densities below 300 km are computed using the scaling relationship from the velocity anomalies
+                  double density_vs_scaling;
+                  if (use_depth_dependent_rho_vs)
+                    density_vs_scaling = rho_vs_depth_profile.get_data_component(Point<1>(depth), density_scaling_index);
+                  else
+                    // Values from Becker (2006), GJI
+                    density_vs_scaling = 0.15;
+
+                  double density_anomaly = delta_log_vs * density_vs_scaling;
+
+                  if (!this->get_adiabatic_conditions().is_initialized())
+                    density_anomaly = 0;
+
+                  // We only want to use the reference densities in the part of the model that also
+                  // uses seismic velocities to determine the densities. Otherwise, use the density
+                  // computed by the material model.
+                  const double reference_density = this->get_adiabatic_conditions().is_initialized()
+                                                   ?
+                                                   this->get_adiabatic_conditions().density(in.position[i])
+                                                   :
+                                                   reference_rho;
+
+                  out.densities[i] = reference_density * (1. + density_anomaly);
+
+                  if (use_depth_dependent_thermal_expansivity)
+                    out.thermal_expansion_coefficients[i] = thermal_expansivity_profile.get_data_component(Point<1>(depth), thermal_expansivity_column_index);
+                  else
+                    out.thermal_expansion_coefficients[i] = thermal_alpha;
+
+                  out.compressibilities[i] = reference_compressibility;
+
+                  material_type = 4;
+                }
+
+              if (MaterialTypeAdditionalOutputs<dim> *material_type_out = out.template get_additional_output<MaterialTypeAdditionalOutputs<dim>>())
+                material_type_out->output_values[0][i] = material_type;
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    TomographyBasedPlateMotions<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Tomography based plate motions model");
+        {
+          prm.declare_entry ("Reference density", "3300",
+                             Patterns::Double (0),
+                             "The reference density $\\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference temperature", "293",
+                             Patterns::Double (0),
+                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250",
+                             Patterns::Double (0),
+                             "The value of the specific heat $cp$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                             Patterns::Double (0),
+                             "The value of the thermal expansion coefficient $\\alpha$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Reference compressibility", "4e-12",
+                             Patterns::Double (0),
+                             "The value of the reference compressibility. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("Phase transition depths", "",
+                             Patterns::List (Patterns::Double(0)),
+                             "A list of depths where phase transitions occur. Values must "
+                             "monotonically increase. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Phase transition temperatures", "",
+                             Patterns::List (Patterns::Double(0)),
+                             "A list of temperatures where phase transitions occur. Higher or lower "
+                             "temperatures lead to phase transition occurring in smaller or greater "
+                             "depths than given in Phase transition depths, depending on the "
+                             "Clapeyron slope given in Phase transition Clapeyron slopes. "
+                             "List must have the same number of entries as Phase transition depths. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Phase transition widths", "",
+                             Patterns::List (Patterns::Double(0)),
+                             "A list of widths for each phase transition. This is only use to specify "
+                             "the region where the recrystallized grain size is assigned after material "
+                             "has crossed a phase transition and should accordingly be chosen similar "
+                             "to the maximum cell width expected at the phase transition."
+                             "List must have the same number of entries as Phase transition depths. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Phase transition Clapeyron slopes", "",
+                             Patterns::List (Patterns::Double()),
+                             "A list of Clapeyron slopes for each phase transition. A positive "
+                             "Clapeyron slope indicates that the phase transition will occur in "
+                             "a greater depth, if the temperature is higher than the one given in "
+                             "Phase transition temperatures and in a smaller depth, if the "
+                             "temperature is smaller than the one given in Phase transition temperatures. "
+                             "For negative slopes the other way round. "
+                             "List must have the same number of entries as Phase transition depths. "
+                             "Units: \\si{\\pascal\\per\\kelvin}.");
+          prm.declare_entry ("Grain growth activation energy", "3.5e5",
+                             Patterns::List (Patterns::Double(0)),
+                             "The activation energy for grain growth $E_g$. "
+                             "Units: \\si{\\joule\\per\\mole}.");
+          prm.declare_entry ("Grain growth activation volume", "8e-6",
+                             Patterns::List (Patterns::Double(0)),
+                             "The activation volume for grain growth $V_g$. "
+                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
+          prm.declare_entry ("Grain growth exponent", "3",
+                             Patterns::List (Patterns::Double(0)),
+                             "The exponent of the grain growth law $p_g$. This is an experimentally determined "
+                             "grain growth constant. "
+                             "Units: none.");
+          prm.declare_entry ("Grain growth rate constant", "1.5e-5",
+                             Patterns::List (Patterns::Double(0)),
+                             "The prefactor for the Ostwald ripening grain growth law $G_0$. "
+                             "This is dependent on water content, which is assumed to be "
+                             "50 H/$10^6$ Si for the default value. "
+                             "Units: \\si{\\meter}$^{p_g}$\\si{\\per\\second}.");
+          prm.declare_entry ("Minimum grain size", "5e-6",
+                             Patterns::Double(0),
+                             "The minimum allowable grain size. The grain size will be limited to be "
+                             "larger than this value. This can be used to damp out oscillations, or "
+                             "to limit the viscosity variation due to grain size. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Reciprocal required strain", "10",
+                             Patterns::List (Patterns::Double(0)),
+                             "This parameter ($\\lambda$) gives an estimate of the strain necessary "
+                             "to achieve a new grain size. ");
+          prm.declare_entry ("Recrystallized grain size", "",
+                             Patterns::List (Patterns::Double(0)),
+                             "The grain size $d_{ph}$ to that a phase will be reduced to when crossing a phase transition. "
+                             "When set to zero, grain size will not be reduced. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Use equilibrium grain size", "true",
+                             Patterns::Bool (),
+                             "A flag indicating whether the computation should use the equilibrium grain size "
+                             "when computing the viscosity (if true), or use a constant grain size instead (if "
+                             "false).");
+          prm.declare_entry ("Average specific grain boundary energy", "1.0",
+                             Patterns::List (Patterns::Double(0)),
+                             "The average specific grain boundary energy $\\gamma$. "
+                             "Units: \\si{\\joule\\per\\meter\\squared}.");
+          prm.declare_entry ("Work fraction for boundary area change", "0.1",
+                             Patterns::List (Patterns::Double(0)),
+                             "The fraction $\\chi$ of work done by dislocation creep to change the grain boundary area. "
+                             "Units: \\si{\\joule\\per\\meter\\squared}.");
+          prm.declare_entry ("Geometric constant", "3",
+                             Patterns::List (Patterns::Double(0)),
+                             "The geometric constant $c$ used in the paleowattmeter grain size reduction law. "
+                             "Units: none.");
+          prm.declare_entry ("Dislocation viscosity iteration threshold", "1e-3",
+                             Patterns::Double(0),
+                             "We need to perform an iteration inside the computation "
+                             "of the dislocation viscosity, because it depends on the "
+                             "dislocation strain rate, which depends on the dislocation "
+                             "viscosity itself. This number determines the termination "
+                             "accuracy, i.e. if the dislocation viscosity changes by less "
+                             "than this factor we terminate the iteration.");
+          prm.declare_entry ("Dislocation viscosity iteration number", "100",
+                             Patterns::Integer(0),
+                             "We need to perform an iteration inside the computation "
+                             "of the dislocation viscosity, because it depends on the "
+                             "dislocation strain rate, which depends on the dislocation "
+                             "viscosity itself. This number determines the maximum "
+                             "number of iterations that are performed. ");
+          prm.declare_entry ("Dislocation creep exponent", "3.5",
+                             Patterns::List (Patterns::Double(0)),
+                             "The power-law exponent $n_{dis}$ for dislocation creep. "
+                             "Units: none.");
+          prm.declare_entry ("Dislocation activation energy", "4.8e5",
+                             Patterns::List (Patterns::Double(0)),
+                             "The activation energy for dislocation creep $E_{dis}$. "
+                             "Units: \\si{\\joule\\per\\mole}.");
+          prm.declare_entry ("Dislocation activation volume", "1.1e-5",
+                             Patterns::List (Patterns::Double(0)),
+                             "The activation volume for dislocation creep $V_{dis}$. "
+                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
+          prm.declare_entry ("Dislocation creep prefactor", "4.5e-15",
+                             Patterns::List (Patterns::Double(0)),
+                             "The prefactor for the dislocation creep law $A_{dis}$. "
+                             "Units: \\si{\\pascal}$^{-n_{dis}}$\\si{\\per\\second}.");
+          prm.declare_entry ("Diffusion creep exponent", "1",
+                             Patterns::List (Patterns::Double(0)),
+                             "The power-law exponent $n_{diff}$ for diffusion creep. "
+                             "Units: none.");
+          prm.declare_entry ("Diffusion activation energy", "3.35e5",
+                             Patterns::List (Patterns::Double(0)),
+                             "The activation energy for diffusion creep $E_{diff}$. "
+                             "Units: \\si{\\joule\\per\\mole}.");
+          prm.declare_entry ("Diffusion activation volume", "4e-6",
+                             Patterns::List (Patterns::Double(0)),
+                             "The activation volume for diffusion creep $V_{diff}$. "
+                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
+          prm.declare_entry ("Diffusion creep prefactor", "7.4e-15",
+                             Patterns::List (Patterns::Double(0)),
+                             "The prefactor for the diffusion creep law $A_{diff}$. "
+                             "Units: \\si{\\meter}$^{p_{diff}}$\\si{\\pascal}$^{-n_{diff}}$\\si{\\per\\second}.");
+          prm.declare_entry ("Diffusion creep grain size exponent", "3",
+                             Patterns::List (Patterns::Double(0)),
+                             "The diffusion creep grain size exponent $p_{diff}$ that determines the "
+                             "dependence of viscosity on grain size. "
+                             "Units: none.");
+          prm.declare_entry ("Maximum temperature dependence of viscosity", "100",
+                             Patterns::Double (1.0),
+                             "The factor by which viscosity at adiabatic temperature and ambient temperature "
+                             "are allowed to differ (a value of x means that the viscosity can be x times higher "
+                             "or x times lower compared to the value at adiabatic temperature. This parameter "
+                             "is introduced to limit local viscosity contrasts, but still allow for a widely "
+                             "varying viscosity over the whole mantle range. "
+                             "Units: none.");
+          prm.declare_entry ("Minimum viscosity", "1e18",
+                             Patterns::Double (0),
+                             "The minimum viscosity that is allowed in the whole model domain. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Maximum viscosity", "1e26",
+                             Patterns::Double (0),
+                             "The maximum viscosity that is allowed in the whole model domain. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/steinberger/",
+                             Patterns::DirectoryName (),
+                             "The path to the model data. The path may also include the special "
+                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                             "in which the ASPECT source files were located when ASPECT was "
+                             "compiled. This interpretation allows, for example, to reference "
+                             "files located in the 'data/' subdirectory of ASPECT. ");
+          prm.declare_entry ("Material file names", "pyr-ringwood88.txt",
+                             Patterns::List (Patterns::Anything()),
+                             "The file names of the material data. "
+                             "List with as many components as active "
+                             "compositional fields (material data is assumed to "
+                             "be in order with the ordering of the fields). ");
+          prm.declare_entry ("Derivatives file names", "",
+                             Patterns::List (Patterns::Anything()),
+                             "The file names of the enthalpy derivatives data. "
+                             "List with as many components as active "
+                             "compositional fields (material data is assumed to "
+                             "be in order with the ordering of the fields). ");
+          prm.declare_entry ("Use table properties", "false",
+                             Patterns::Bool(),
+                             "This parameter determines whether to use the table properties "
+                             "also for density, thermal expansivity and specific heat. "
+                             "If false the properties are generated as in the "
+                             "simple compressible plugin.");
+          prm.declare_entry ("Material file format", "perplex",
+                             Patterns::Selection ("perplex|hefesto"),
+                             "The material file format to be read in the property "
+                             "tables.");
+          prm.declare_entry ("Use depth dependent viscosity", "false",
+                             Patterns::Bool (),
+                             "This parameter value determines if we want to use the layered depth dependent "
+                             "rheology, which is input as an ascii data file.");
+          prm.declare_entry ("Use faults", "false",
+                             Patterns::Bool (),
+                             "This parameter value determines if we want to use the faults/plate boundaries as "
+                             "a composition field, currently input as a world builder file.");
+          prm.declare_entry ("Fault viscosity", "1e20",
+                             Patterns::Double(0),
+                             "This parameter value determines the viscosity of faults or plate boundaries. "
+                             "We would want to have weak faults/plate boundaries relative to the surrounding "
+                             "lithosphere. "
+                             "Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Asthenosphere viscosity", "2.4e20",
+                             Patterns::Double(0),
+                             "This parameter value determines the asthenosphere layer in the reference file. "
+                             "Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Use cratons", "false",
+                             Patterns::Bool (),
+                             "This parameter value determines if we want to use cratons as viscous and neutrally "
+                             "buoyant composition field, currently input as a world builder file.");
+          prm.declare_entry ("Craton viscosity", "1e25",
+                             Patterns::Double(0),
+                             "This parameter value determines the viscosity of cratons. We would want to have "
+                             "strong cratons relative to the surrounding lithosphere."
+                             "Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Use depth dependent density scaling", "false",
+                             Patterns::Bool (),
+                             "This parameter value determines if we want to use depth-dependent scaling files "
+                             "for computing the density from seismic velocities (if true) or use a constant "
+                             "value (if false).");
+          prm.declare_entry ("Use thermal expansivity profile", "true",
+                             Patterns::Bool (),
+                             "This parameter determines if we use a depth-dependent thermal expansivity read "
+                             "from a data file (if true), or if we use the constant reference value given by "
+                             "the 'Thermal expansion coefficient' (if false). In the case that material "
+                             "properties are read from a look-up table, as determined by the input parameter "
+                             "'Use table properties', this value is irrelevant and will be ignored.");
+          prm.declare_entry ("Uppermost mantle thickness", "300000",
+                             Patterns::Double (0),
+                             "The depth of the base of the uppermost mantle, which marks the transition between "
+                             "using the temperature model of Tutu et al. (above) and derived from seismic "
+                             "tomography (below). "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Use depth dependent temperature scaling", "false",
+                             Patterns::Bool (),
+                             "This parameter value determines if we want to use a depth-dependent scaling read "
+                             "in from a data file for computing the temperature from seismic velocities (if true) "
+                             "or use a constant value (if false).");
+          prm.declare_entry ("Use varying fault viscosity", "false",
+                             Patterns::Bool (),
+                             "This parameter value determines if we want to use different viscosities for ridges "
+                             "and trenches. We think that ridges are already weakened by the high temperatures "
+                             "and by prescribing additional weak zones, we are making plates surrounded by ridges "
+                             "faster than observed.");
+          prm.declare_entry ("Use constant lithosphere thickness", "false",
+                             Patterns::Bool (),
+                             "This parameter value determines if we want to a lithosphere with a constant thickness. "
+                             "We can evaluate the effects of lithospheric thickness variations on the surface plate "
+                             "motions using this. Currently, this parameter sets the lithosphere to a constant "
+                             "thickness of 100 km.");
+          // Varying fault parameters
+          prm.enter_subsection("Varying fault viscosity");
+          {
+            prm.declare_entry ("Ridge viscosity", "1e22",
+                               Patterns::Double(0),
+                               "This parameter value determines the viscosity of faults at the ridges. "
+                               "Units: \\si{\\pascal\\second}");
+            prm.declare_entry ("Trench viscosity", "1e20",
+                               Patterns::Double(0),
+                               "This parameter value determines the viscosity of faults at the trenches. "
+                               "Units: \\si{\\pascal\\second}");
+          }
+          prm.leave_subsection();
+          // Depth-dependent viscosity parameters
+          Rheology::AsciiDepthProfile<dim>::declare_parameters(prm);
+
+          // Depth-dependent density scaling parameters
+          Utilities::AsciiDataBase<dim>::declare_parameters(prm, "$ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/", "rho_vs_scaling.txt",
+                                                            "Density velocity scaling");
+
+          // Depth-dependent density scaling parameters
+          Utilities::AsciiDataBase<dim>::declare_parameters(prm, "$ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/", "dT_vs_scaling.txt",
+                                                            "Temperature velocity scaling");
+
+          // Depth-dependent thermal expansivity parameters
+          Utilities::AsciiDataBase<dim>::declare_parameters(prm, "$ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/",
+                                                            "thermal_expansivity_steinberger_calderwood.txt", "Thermal expansivity profile");
+
+          // Crustal boundary depths parameters
+          Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,  "$ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/",
+                                                                "crustal_structure.txt", "Crustal depths");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    TomographyBasedPlateMotions<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      AssertThrow (this->introspection().compositional_name_exists("grain_size"),
+                   ExcMessage("The 'grain size' material model only works if a compositional "
+                              "field with name 'grain_size' is present. Please use another material "
+                              "model or add such a field."));
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Tomography based plate motions model");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          k_value                    = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+          reference_compressibility  = prm.get_double ("Reference compressibility");
+
+
+          transition_depths         = Utilities::string_to_double
+                                      (Utilities::split_string_list(prm.get ("Phase transition depths")));
+          transition_temperatures   = Utilities::string_to_double
+                                      (Utilities::split_string_list(prm.get ("Phase transition temperatures")));
+          transition_slopes         = Utilities::string_to_double
+                                      (Utilities::split_string_list(prm.get ("Phase transition Clapeyron slopes")));
+          recrystallized_grain_size = Utilities::string_to_double
+                                      (Utilities::split_string_list(prm.get ("Recrystallized grain size")));
+          transition_widths         = Utilities::string_to_double
+                                      (Utilities::split_string_list(prm.get ("Phase transition widths")));
+
+          if (transition_temperatures.size() != transition_depths.size() ||
+              transition_slopes.size() != transition_depths.size() ||
+              transition_widths.size() != transition_depths.size() ||
+              recrystallized_grain_size.size() != transition_depths.size() )
+            AssertThrow(false,
+                        ExcMessage("Error: At least one list that gives input parameters for the phase transitions has the wrong size."));
+
+          if (transition_depths.size()>1)
+            for (unsigned int i=0; i<transition_depths.size()-2; ++i)
+              AssertThrow(transition_depths[i]<transition_depths[i+1],
+                          ExcMessage("Error: Phase transition depths have to be sorted in ascending order!"));
+
+          // grain evolution parameters
+          grain_growth_activation_energy        = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Grain growth activation energy")));
+          grain_growth_activation_volume        = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Grain growth activation volume")));
+          grain_growth_rate_constant            = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Grain growth rate constant")));
+          grain_growth_exponent                 = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Grain growth exponent")));
+          min_grain_size                        = prm.get_double("Minimum grain size");
+          reciprocal_required_strain            = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Reciprocal required strain")));
+          equilibrate_grain_size                = prm.get_bool ("Use equilibrium grain size");
+
+          grain_boundary_energy                 = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Average specific grain boundary energy")));
+          boundary_area_change_work_fraction    = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Work fraction for boundary area change")));
+          geometric_constant                    = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Geometric constant")));
+
+          // rheology parameters
+          dislocation_viscosity_iteration_threshold = prm.get_double("Dislocation viscosity iteration threshold");
+          dislocation_viscosity_iteration_number = prm.get_integer("Dislocation viscosity iteration number");
+          dislocation_creep_exponent            = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Dislocation creep exponent")));
+          dislocation_activation_energy         = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Dislocation activation energy")));
+          dislocation_activation_volume         = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Dislocation activation volume")));
+          dislocation_creep_prefactor           = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Dislocation creep prefactor")));
+          diffusion_creep_exponent              = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion creep exponent")));
+          diffusion_activation_energy           = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion activation energy")));
+          diffusion_activation_volume           = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion activation volume")));
+          diffusion_creep_prefactor             = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion creep prefactor")));
+          diffusion_creep_grain_size_exponent   = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion creep grain size exponent")));
+          max_temperature_dependence_of_eta     = prm.get_double ("Maximum temperature dependence of viscosity");
+          min_eta                               = prm.get_double ("Minimum viscosity");
+          max_eta                               = prm.get_double ("Maximum viscosity");
+
+          if (grain_growth_activation_energy.size() != grain_growth_activation_volume.size() ||
+              grain_growth_activation_energy.size() != grain_growth_rate_constant.size() ||
+              grain_growth_activation_energy.size() != grain_growth_exponent.size() ||
+              grain_growth_activation_energy.size() != dislocation_creep_exponent.size() ||
+              grain_growth_activation_energy.size() != dislocation_activation_energy.size() ||
+              grain_growth_activation_energy.size() != dislocation_activation_volume.size() ||
+              grain_growth_activation_energy.size() != dislocation_creep_prefactor.size() ||
+              grain_growth_activation_energy.size() != diffusion_creep_exponent.size() ||
+              grain_growth_activation_energy.size() != diffusion_activation_energy.size() ||
+              grain_growth_activation_energy.size() != diffusion_activation_volume.size() ||
+              grain_growth_activation_energy.size() != diffusion_creep_prefactor.size() ||
+              grain_growth_activation_energy.size() != diffusion_creep_grain_size_exponent.size() )
+            AssertThrow(false,
+                        ExcMessage("Error: The lists of grain size evolution and flow law parameters "
+                                   "need to have the same length!"));
+
+          if (equilibrate_grain_size)
+            {
+              if (grain_growth_activation_energy.size() != grain_boundary_energy.size() ||
+                  grain_growth_activation_energy.size() != boundary_area_change_work_fraction.size() ||
+                  grain_growth_activation_energy.size() != geometric_constant.size() )
+                AssertThrow(false,
+                            ExcMessage("Error: One of the lists of grain size evolution parameters "
+                                       "given for the paleowattmeter does not have the correct length!"));
+            }
+
+          AssertThrow(grain_growth_activation_energy.size() == transition_depths.size()+1,
+                      ExcMessage("Error: The lists of grain size evolution and flow law parameters need to "
+                                 "have exactly one more entry than the number of phase transitions "
+                                 "(which is defined by the length of the lists of phase transition depths, ...)!"));
+
+          // parameters for reading in tables with material properties
+          data_directory        = prm.get ("Data directory");
+          {
+            const std::string subst_text = "$ASPECT_SOURCE_DIR";
+            std::string::size_type position;
+            while (position = data_directory.find (subst_text),  position!=std::string::npos)
+              data_directory.replace (data_directory.begin()+position,
+                                      data_directory.begin()+position+subst_text.size(),
+                                      ASPECT_SOURCE_DIR);
+          }
+          material_file_names  = Utilities::split_string_list
+                                 (prm.get ("Material file names"));
+          derivatives_file_names = Utilities::split_string_list
+                                   (prm.get ("Derivatives file names"));
+
+          use_table_properties                    = prm.get_bool ("Use table properties");
+          use_depth_dependent_viscosity           = prm.get_bool ("Use depth dependent viscosity");
+          use_faults                              = prm.get_bool ("Use faults");
+          use_cratons                             = prm.get_bool ("Use cratons");
+          craton_viscosity                        = prm.get_double("Craton viscosity");
+          use_depth_dependent_rho_vs              = prm.get_bool ("Use depth dependent density scaling");
+          use_depth_dependent_dT_vs               = prm.get_bool ("Use depth dependent temperature scaling");
+          use_depth_dependent_thermal_expansivity = prm.get_bool ("Use thermal expansivity profile");
+          depth_to_base_of_uppermost_mantle       = prm.get_double ("Uppermost mantle thickness");
+          fault_viscosity                         = prm.get_double ("Fault viscosity");
+          asthenosphere_viscosity                 = prm.get_double ("Asthenosphere viscosity");
+          use_varying_fault_viscosity             = prm.get_bool ("Use varying fault viscosity");
+          use_constant_lithosphere_thickness      = prm.get_bool("Use constant lithosphere thickness");
+
+          if (use_varying_fault_viscosity)
+            AssertThrow (use_faults,
+                         ExcMessage("Variable viscosity along ridges and trenches can only be incorporated "
+                                    "if we are using faults in our model."));
+
+          prm.enter_subsection("Varying fault viscosity");
+          {
+            ridge_viscosity                         = prm.get_double ("Ridge viscosity");
+            trench_viscosity                        = prm.get_double ("Trench viscosity");
+          }
+          prm.leave_subsection();
+
+          // Parse all depth-dependent parameters
+          if (use_depth_dependent_viscosity)
+            {
+              reference_viscosity_profile = std::make_unique<Rheology::AsciiDepthProfile<dim>>();
+              reference_viscosity_profile->initialize_simulator (this->get_simulator());
+              reference_viscosity_profile->parse_parameters(prm);
+              reference_viscosity_profile->initialize();
+            }
+
+          if (use_depth_dependent_rho_vs)
+            rho_vs_depth_profile.parse_parameters(prm, "Density velocity scaling");
+
+          if (use_depth_dependent_thermal_expansivity)
+            thermal_expansivity_profile.parse_parameters(prm, "Thermal expansivity profile");
+
+          if (use_depth_dependent_dT_vs)
+            dT_vs_depth_profile.parse_parameters(prm, "Temperature velocity scaling");
+
+          crustal_boundary_depth.initialize_simulator (this->get_simulator());
+          crustal_boundary_depth.parse_parameters(prm, "Crustal depths");
+
+          // Make sure the grain size field comes after all potential material
+          // data fields. Otherwise our material model calculation uses the
+          // wrong compositional fields.
+          if (use_table_properties && material_file_names.size() > 1)
+            {
+              AssertThrow(this->introspection().compositional_index_for_name("grain_size") >= material_file_names.size(),
+                          ExcMessage("The compositional fields indicating the major element composition need to be first in the "
+                                     "list of compositional fields, but the grain size field seems to have a lower index than the number "
+                                     "of provided data files. This is likely inconsistent. Please check the number of provided data "
+                                     "files and the order of compositional fields."));
+            }
+
+          if (prm.get ("Material file format") == "perplex")
+            material_file_format = perplex;
+          else if (prm.get ("Material file format") == "hefesto")
+            material_file_format = hefesto;
+          else
+            AssertThrow (false, ExcNotImplemented());
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+
+      // Declare dependencies on solution variables
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+
+      this->model_dependence.viscosity = NonlinearDependence::temperature
+                                         | NonlinearDependence::pressure
+                                         | NonlinearDependence::strain_rate
+                                         | NonlinearDependence::compositional_fields;
+
+      this->model_dependence.density = NonlinearDependence::none;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+
+      if (use_table_properties)
+        {
+          this->model_dependence.density |= NonlinearDependence::temperature
+                                            | NonlinearDependence::pressure
+                                            | NonlinearDependence::compositional_fields;
+          this->model_dependence.compressibility = NonlinearDependence::temperature
+                                                   | NonlinearDependence::pressure
+                                                   | NonlinearDependence::compositional_fields;
+          this->model_dependence.specific_heat = NonlinearDependence::temperature
+                                                 | NonlinearDependence::pressure
+                                                 | NonlinearDependence::compositional_fields;
+        }
+      else
+        {
+          if (thermal_alpha != 0)
+            this->model_dependence.density |=NonlinearDependence::temperature;
+          if (reference_compressibility != 0)
+            this->model_dependence.density |=NonlinearDependence::pressure;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    TomographyBasedPlateMotions<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // These properties are useful as output, but will also be used by the
+      // heating model to reduce shear heating by the amount of work done to
+      // reduce grain size.
+      if (out.template get_additional_output<DislocationViscosityOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.viscosities.size();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::DislocationViscosityOutputs<dim>> (n_points));
+        }
+
+      // We need the prescribed field outputs to interpolate the grain size onto a compositional field.
+      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.viscosities.size();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points, this->n_compositional_fields()));
+        }
+
+      // These properties are only output properties. But we should only create them if they are filled.
+      if (use_table_properties
+          && out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.viscosities.size();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
+        }
+
+      if (this->get_parameters().temperature_method == Parameters<dim>::AdvectionFieldMethod::prescribed_field &&
+          out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.viscosities.size();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>> (n_points));
+        }
+
+      // We need additional field outputs for the unscaled viscosity
+      if (out.template get_additional_output<UnscaledViscosityAdditionalOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.viscosities.size();
+          out.additional_outputs.push_back(
+            std::make_unique<UnscaledViscosityAdditionalOutputs<dim>> (n_points));
+        }
+
+      if (out.template get_additional_output<MaterialTypeAdditionalOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.viscosities.size();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialTypeAdditionalOutputs<dim>> (n_points));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(TomographyBasedPlateMotions,
+                                   "tomography based plate motions",
+                                   "A material model that relies on compositional "
+                                   "fields that correspond to the average grain sizes of a "
+                                   "mineral phase and source terms that determine the grain "
+                                   "size evolution in terms of the strain rate, "
+                                   "temperature, phase transitions, and the creep regime. "
+                                   "This material model only works if a compositional field "
+                                   "named 'grain_size' is present. "
+                                   "In the diffusion creep regime, the viscosity depends "
+                                   "on this grain size field. "
+                                   "We use the grain size evolution laws described in \\cite{Behn2009}. "
+                                   "Other material parameters are either prescribed similar "
+                                   "to the 'simple' material model, or read from data files "
+                                   "that were generated by the Perplex or Hefesto software. "
+                                   "This material model is described in more detail in "
+                                   "\\citet{dannberg2017}.")
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace
+    {
+
+#define INSTANTIATE(dim) \
+  template class UnscaledViscosityAdditionalOutputs<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.h.bak b/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.h.bak
new file mode 100644
index 00000000000..6846e88afe1
--- /dev/null
+++ b/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.h.bak
@@ -0,0 +1,513 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_cookbooks_tomography_based_plate_motions_h
+#define _aspect_cookbooks_tomography_based_plate_motions_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/lateral_averaging.h>
+#include <aspect/material_model/grain_size.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/rheology/ascii_depth_profile.h>
+#include <array>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+
+    /**
+     * A material model to set up mantle flow models based on
+     * an input tomography model and a temperature model.
+     * The viscosity is computed based on dislocation and diffusion
+     * creep with lateral averages scaled to a reference viscosity
+     * profile.
+     * This material model only works if a compositional field
+     * named 'grain_size' is present. In the diffusion
+     * creep regime, the viscosity depends on this grain size.
+     * The model allows the user to prescribe different viscosity at
+     * fault boundaries and in continental regions at locations defined
+     * by the the compositional field 'faults' or 'cratons', respectively.
+     * The material model also allows the option to compute and use
+     * equilibrium grain size following paleowattmeter approximation
+     * by Austin and Evans, (2007), Paleowattmeters: "A scaling relation for
+     * dynamically recrystallized grain size", Geology, 35, 343.
+     * Other material parameters are either based on (1) an input tomography
+     * model and scaling profiles between temperature/density relative to
+     * the seismic velocity anomalies or a temperature model and constant
+     * thermal expansivities and compressibilities relative to a reference
+     * temperature, as done in Osei Tutu et al., (2018): "Evaluating the influence
+     * of plate boundary friction and mantle viscosity on plate velocities",
+     * Geochem. Geophys. Geosyst., 19 (3), 642–666, or (2) prescribed similar to
+     * the 'simple' material model, or (3) read from data files
+     * that were generated by the Perplex or Hefesto software. The material model
+     * is described in more detail in Dannberg, J., Z. Eilon, U. Faul,
+     * R. Gassmöller, P. Moulik, and R. Myhill (2017): "The importance of
+     * grain size to mantle dynamics and seismological observations",
+     * Geochem. Geophys. Geosyst., 18, 3034–3061, doi:10.1002/2017GC006944.,
+     * and in Saxena, A., Dannberg J., Gassmöller, Fraters, M., Heister, T., & Styron, (2023):
+     * "High-resolution mantle flow models reveal importance of plate boundary geometry and slab pull
+     * forces on generating tectonic plate motions", J. Geophys. Research.:Solid Earth,
+     * 128, e2022JB025877.
+
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class TomographyBasedPlateMotions : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. Loads the material data and sets up
+         * pointers. Gets the reference viscosity profile from a file.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Compute the laterally averaged viscosity
+         */
+        void
+        update() override;
+
+        /**
+         * Compute the reference viscosity against which the viscosities in the model
+         * are scaled. The reference viscosity is from a depth-dependent ascii profile and
+         * the function returns as the second parameter in the pair the support point in
+         * that profile that has the next smaller depth value than the input parameter
+         * @p depth.
+         */
+        std::pair<double, unsigned int>
+        get_reference_viscosity (const double depth) const;
+
+        /**
+         * Return the depth of the base of the uppermost mantle. Below that depth,
+         * material properties are based on seismic tomography. Above that depth, material
+         * properties are computed based on the model of Tutu et al., 2018.
+         */
+        double
+        get_depth_of_base_of_uppermost_mantle () const;
+
+        /**
+         * Compute the scaling factors for each depth layer such that the laterally
+         * averaged viscosiy in that layer is the same as the reference vicosity.
+         */
+        double
+        compute_viscosity_scaling (const double depth) const;
+
+        /**
+         * Return whether the model is compressible or not.
+         */
+        bool
+        is_compressible () const override;
+
+        void
+        evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                 typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+        /**
+         * @}
+         */
+
+      protected:
+        double reference_rho;
+        double thermal_alpha;
+        double reference_specific_heat;
+
+        /**
+         * The constant compressibility.
+         */
+        double reference_compressibility;
+
+        /**
+         * The thermal conductivity.
+         */
+        double k_value;
+
+        /**
+         * Parameters controlling the grain size evolution.
+         */
+        std::vector<double> grain_growth_activation_energy;
+        std::vector<double> grain_growth_activation_volume;
+        std::vector<double> grain_growth_rate_constant;
+        std::vector<double> grain_growth_exponent;
+        double              minimum_grain_size;
+        std::vector<double> reciprocal_required_strain;
+        std::vector<double> recrystallized_grain_size;
+        bool                equilibrate_grain_size;
+
+        /**
+         * Parameters controlling the dynamic grain recrystallization.
+         * (following paleowattmeter as described in Austin, N. J., & Evans, B.
+         * (2007). Paleowattmeters: A scaling relation for dynamically
+         * recrystallized grain size. Geology, 35(4), 343-346.).
+         */
+        std::vector<double> grain_boundary_energy;
+        std::vector<double> boundary_area_change_work_fraction;
+        std::vector<double> geometric_constant;
+
+        /**
+         * Parameters controlling the viscosity.
+         */
+        double dislocation_viscosity_iteration_threshold;
+        unsigned int dislocation_viscosity_iteration_number;
+        std::vector<double> dislocation_creep_exponent;
+        std::vector<double> dislocation_activation_energy;
+        std::vector<double> dislocation_activation_volume;
+        std::vector<double> dislocation_creep_prefactor;
+        std::vector<double> diffusion_creep_exponent;
+        std::vector<double> diffusion_activation_energy;
+        std::vector<double> diffusion_activation_volume;
+        std::vector<double> diffusion_creep_prefactor;
+        std::vector<double> diffusion_creep_grain_size_exponent;
+
+        /**
+         * Reference viscosity profile coordinates, and the corresponding viscosity.
+         */
+        std::vector<double> reference_viscosity_coordinates;
+        std::unique_ptr<Rheology::AsciiDepthProfile<dim>> reference_viscosity_profile;
+
+        /**
+         * A reference profile for density scaling.
+         */
+        Utilities::AsciiDataProfile<dim> rho_vs_depth_profile;
+
+        /**
+         * The column indices of the density scaling column in the ascii profile file.
+         */
+        unsigned int density_scaling_index;
+
+
+        /**
+         * A reference profile for the thermal expansivity.
+         */
+        Utilities::AsciiDataProfile<dim> thermal_expansivity_profile;
+        unsigned int thermal_expansivity_column_index;
+
+        /**
+         * A reference profile for temperatura scaling. Values are from Steinberger and
+         * Calderwood, 2006.
+         */
+        Utilities::AsciiDataProfile<dim> dT_vs_depth_profile;
+
+        /**
+         * The column indices of the density scaling column in the ascii profile file.
+         */
+        unsigned int temperature_scaling_index;
+
+        /**
+         * An object of ascii data boundary to input crustal depths.
+         */
+        Utilities::AsciiDataBoundary<dim> crustal_boundary_depth;
+
+        /**
+         * A depth-profile of the laterally averaged viscosity in each layer
+         * in the current model. Can be used to compare (and potentially scale)
+         * the computed viscosity to the reference profile.
+         */
+        std::vector<double> average_viscosity_profile;
+
+        /**
+         * Variable returned  to determine if the evaluate () function is called and
+         * viscosities are computed. Initially, it is set to false and then updated
+         * to true in the update () function.
+         */
+        bool initialized;
+
+        /**
+         * Because of the nonlinear nature of this material model many
+         * parameters need to be kept within bounds to ensure stability of the
+         * solution. These bounds can be adjusted as input parameters.
+         */
+        double max_temperature_dependence_of_eta;
+        double min_eta;
+        double max_eta;
+        double min_specific_heat;
+        double max_specific_heat;
+        double min_thermal_expansivity;
+        double max_thermal_expansivity;
+        unsigned int max_latent_heat_substeps;
+        double min_grain_size;
+
+        double diffusion_viscosity (const double      temperature,
+                                    const double      pressure,
+                                    const std::vector<double>    &compositional_fields,
+                                    const SymmetricTensor<2,dim> &strain_rate,
+                                    const Point<dim> &position) const;
+
+        /**
+         * Compute the equilibrium grain size for a given temperature and
+         * pressure.
+         * This computation is based on the rate of grain size growth
+         * (Ostwald ripening) or reduction (due to dynamic recrystallization
+         * and phase transformations) in dependence on temperature, pressure,
+         * strain rate, mineral phase and creep regime.
+         * We use the grain size growth laws as for example described
+         * in Behn, M. D., Hirth, G., & Elsenbeck, J. R. (2009). Implications
+         * of grain size evolution on the seismic structure of the oceanic
+         * upper mantle. Earth and Planetary Science Letters, 282(1), 178-189.
+         *
+         * For the rate of grain size reduction due to dynamic crystallization,
+         * we use paleowattmeter approximation (Austins and
+         * Evans, 2007).
+         */
+        void compute_equilibrium_grain_size (const typename Interface<dim>::MaterialModelInputs &in,
+                                             typename Interface<dim>::MaterialModelOutputs      &out) const;
+
+        /**
+         * This function calculates the dislocation viscosity. For this purpose
+         * we need the dislocation component of the strain rate, which we can
+         * only compute by knowing the dislocation viscosity. Therefore, we
+         * iteratively solve for the dislocation viscosity and update the
+         * dislocation strain rate in each iteration using the new value
+         * obtained for the dislocation viscosity. The iteration is started
+         * with a dislocation viscosity calculated for the whole strain rate
+         * unless a guess for the viscosity is provided, which can reduce the
+         * number of iterations significantly.
+         */
+        double dislocation_viscosity (const double                  temperature,
+                                      const double                  pressure,
+                                      const std::vector<double>    &compositional_fields,
+                                      const SymmetricTensor<2,dim> &strain_rate,
+                                      const Point<dim>             &position,
+                                      const double                  viscosity_guess = 0) const;
+
+        /**
+         * This function calculates the dislocation viscosity for a given
+         * dislocation strain rate.
+         */
+        double dislocation_viscosity_fixed_strain_rate (const double      temperature,
+                                                        const double      pressure,
+                                                        const double      second_strain_rate_invariant,
+                                                        const Point<dim> &position) const;
+
+        double density (const double temperature,
+                        const double pressure,
+                        const std::vector<double> &compositional_fields,
+                        const Point<dim> &position) const;
+
+        /**
+         * The column indices of the density column in the reference profile file.
+         */
+        unsigned int density_index;
+
+        double compressibility (const double temperature,
+                                const double pressure,
+                                const std::vector<double> &compositional_fields,
+                                const Point<dim> &position) const;
+
+        double thermal_expansivity (const double temperature,
+                                    const double pressure,
+                                    const std::vector<double> &compositional_fields,
+                                    const Point<dim> &position) const;
+
+        /**
+         * Returns the p-wave velocity as calculated by HeFESTo.
+         */
+        double seismic_Vp (const double      temperature,
+                           const double      pressure,
+                           const std::vector<double> &compositional_fields,
+                           const Point<dim> &position) const;
+
+        /**
+         * Returns the s-wave velocity as calculated by HeFESTo.
+         */
+        double seismic_Vs (const double      temperature,
+                           const double      pressure,
+                           const std::vector<double> &compositional_fields,
+                           const Point<dim> &position) const;
+
+        /**
+         * Function that defines the phase transition interface
+         * (0 above, 1 below the phase transition). This is done
+         * individually for each transition and summed up in the end.
+         */
+        double
+        phase_function (const Point<dim> &position,
+                        const double temperature,
+                        const double pressure,
+                        const unsigned int phase) const;
+
+        /**
+         * Function that returns the phase for a given
+         * position, temperature, pressure and compositional
+         * field index.
+         */
+        unsigned int
+        get_phase_index (const Point<dim> &position,
+                         const double temperature,
+                         const double pressure) const;
+
+
+        /**
+         * Lists of depth, width, and Clapeyron slopes for the different phase
+         * transitions and in which phase they occur.
+         */
+        std::vector<double> transition_depths;
+        std::vector<double> transition_temperatures;
+        std::vector<double> transition_slopes;
+        std::vector<double> transition_widths;
+
+
+        /**
+         * The following variables are properties of the material files
+         * we read in.
+         */
+        std::string data_directory;
+        std::vector<std::string> material_file_names;
+        std::vector<std::string> derivatives_file_names;
+        unsigned int n_material_data;
+        bool use_table_properties;
+
+        /**
+         * Parameter value that determines whether to read the viscosity with depth
+         * from an ascii data file.
+        */
+        bool use_depth_dependent_viscosity;
+
+        /**
+         * Parameter value that determines whether to read the density scaling with depth
+         * from an ascii data file.
+        */
+        bool use_depth_dependent_rho_vs;
+
+        /**
+         * Parameter value that determines whether to read the thermal expansivity
+         * from an ascii data file.
+        */
+        bool use_depth_dependent_thermal_expansivity;
+
+        /**
+         * Parameter value that determines whether to read the temperature scaling with depth
+         * from an ascii data file.
+        */
+        bool use_depth_dependent_dT_vs;
+
+        /**
+         * Parameter that determines if faults or plate boundaries are used as another
+         * compositional field.
+         */
+        bool use_faults;
+
+        /**
+         * Parameter that determines the viscosity of faults or plate boundaries.
+         */
+        double fault_viscosity;
+
+        /**
+         * Parameter that determines if ridges or trenches have different viscosities
+         */
+        bool use_varying_fault_viscosity;
+
+        /**
+         * Parameter that determines if lithospheric depths vary or not
+         */
+        bool use_constant_lithosphere_thickness;
+
+        /**
+         * Parameter that determines the viscosity of faults at ridges.
+         */
+        double ridge_viscosity;
+
+        /**
+         * Parameter that determines the viscosity of faults at trenches.
+         */
+        double trench_viscosity;
+
+        /**
+         * Parameter that determines the asthenosphere viscosity. By default, use
+         * the value from the Steinberger & Calderwood reference viscosity profile.
+         */
+        double asthenosphere_viscosity;
+
+        /**
+         * Parameter that determines if we want to use viscous and neutrally buoyant cratons as
+         * another compositional field.
+         */
+        bool use_cratons;
+
+        /**
+         * Parameter that determines the viscosity for cratons.
+         */
+        double craton_viscosity;
+
+        /**
+         * Approximate lithosphere thickness used to separate the regions of
+         * temperature derived from seismic tomography and linear temperature
+         * gradient.
+        */
+        double lithosphere_thickness;
+
+        /**
+         * Parameter used to describe the uppermost mantle based on Tutu (2018).
+         */
+        double depth_to_base_of_uppermost_mantle;
+
+        /**
+         * The format of the provided material files. Currently we support
+         * the PERPLEX and HeFESTo data formats.
+         */
+        enum formats
+        {
+          perplex,
+          hefesto
+        } material_file_format;
+
+        /**
+         * List of pointers to objects that read and process data we get from
+         * material data files. There is one pointer/object per compositional
+         * field provided.
+         */
+        std::vector<std::shared_ptr<MaterialModel::MaterialUtilities::Lookup::MaterialLookup>> material_lookup;
+
+        /**
+        * A shared pointer to the initial temperature object
+        * that ensures that the current object can continue
+        * to access the initial composition object beyond the
+        * first time step.
+        */
+        std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature_manager;
+    };
+
+  }
+}
+
+#endif
diff --git a/cookbooks/transform_fault_behn_2007/doc/material.part.prm.bak b/cookbooks/transform_fault_behn_2007/doc/material.part.prm.bak
new file mode 100644
index 00000000000..28c51d6c0ca
--- /dev/null
+++ b/cookbooks/transform_fault_behn_2007/doc/material.part.prm.bak
@@ -0,0 +1,12 @@
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 1573.15
+    set Heat capacities       = 1000
+    set Densities             = 3300           # Value from Behn et al., 2007
+    set Thermal expansivities = 0              # Thermal buoyancy is ignored in Behn et al., 2007
+    set Define thermal conductivities = true
+    set Thermal conductivities        = 3.5
+  end
+end
diff --git a/cookbooks/transform_fault_behn_2007/doc/temperature.part.prm.bak b/cookbooks/transform_fault_behn_2007/doc/temperature.part.prm.bak
new file mode 100644
index 00000000000..3cfa8800283
--- /dev/null
+++ b/cookbooks/transform_fault_behn_2007/doc/temperature.part.prm.bak
@@ -0,0 +1,28 @@
+# We use the Geodynamic World Builder to create the initial temperature.
+# Therefore, we have to specify the location of the GWB input file
+# that we want to use. The file we use here is located in the cookbooks
+# folder of the GWB repository. See the corresponding tutorial in the
+# Geodynamic World Builder on how to create this file.
+set World builder file = $ASPECT_SOURCE_DIR/contrib/world_builder/cookbooks/3d_cartesian_transform_fault/3d_cartesian_transform_fault.wb
+
+# Note that the adiabatic surface temperature should be consistent with the
+# value assumed in the GWB input file, given in the parameter 'potential
+# mantle temperature'.
+set Adiabatic surface temperature          = 1573.15
+
+# The initial temperature comes form the Geodynamic World Builder.
+subsection Initial temperature model
+  set List of model names = world builder
+end
+
+# We prescribe the surface temperature at the top and the mantle potential temperature
+# at the bottom.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 273.15
+    set Bottom temperature = 1573.15
+  end
+end
diff --git a/cookbooks/transform_fault_behn_2007/temperature_dependent.prm.bak b/cookbooks/transform_fault_behn_2007/temperature_dependent.prm.bak
new file mode 100644
index 00000000000..f4791b31f2d
--- /dev/null
+++ b/cookbooks/transform_fault_behn_2007/temperature_dependent.prm.bak
@@ -0,0 +1,24 @@
+# This is a model of a mid-ocean ridge with a transform fault,
+# specifically, it is a model that reproduces the setup of Behn et
+# al., 2007: Thermal structure of oceanic transform faults.
+# This input file covers case 2 from that publication (with a
+# temperature-dependent viscosity).
+
+include ./transform_fault_behn_2007.prm
+
+set World builder file = $ASPECT_SOURCE_DIR/contrib/world_builder/cookbooks/3d_cartesian_transform_fault/3d_cartesian_transform_fault.wb
+set Output directory = transform-fault-behn-2007-temperature-dependent
+set Dimension        = 3
+
+# In case 2, viscosity is temperature-dependent with an
+# activation energy of 250 kJ/mol. We also need to scale the
+# prefactor to account for the different formulation of the
+# diffusion creep flow law.
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Prefactors for diffusion creep          = 9.99479239e-12
+    set Activation energies for diffusion creep = 250e3
+  end
+end
diff --git a/cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm.bak b/cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm.bak
new file mode 100644
index 00000000000..d2e8a8f2aa7
--- /dev/null
+++ b/cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm.bak
@@ -0,0 +1,203 @@
+# This is a model of a mid-ocean ridge with a transform fault,
+# specifically, it is a model that reproduces the setup of Behn et
+# al., 2007: Thermal structure of oceanic transform faults.
+# This input file covers case 1 from that publication (with a
+# constant viscosity).
+
+# We use the Geodynamic World Builder to create the initial temperature.
+# Therefore, we have to specify the location of the GWB input file
+# that we want to use. The file we use here is located in the cookbooks
+# folder of the GWB repository. See the corresponding tutorial in the
+# Geodynamic World Builder on how to create this file.
+set World builder file = $ASPECT_SOURCE_DIR/contrib/world_builder/cookbooks/3d_cartesian_transform_fault/3d_cartesian_transform_fault.wb
+
+# We run the model for 10 million years.
+set End time                               = 1e7
+set Output directory                       = transform-fault-behn-2007
+set Dimension                              = 3
+
+# We set the average pressure at the surface to 0.
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Note that the adiabatic surface temperature should be consistent with the
+# value assumed in the GWB input file, given in the parameter 'potential
+# mantle temperature'.
+set Adiabatic surface temperature          = 1573.15
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 50
+
+# We use the geometric multigrid solver, but because this is a difficult
+# linear problem to solve with a large viscosity contrast, we increase the
+# number of cheap iterations and the restart length to make sure it
+# converges.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set GMRES solver restart length = 200
+    set Number of cheap Stokes solver steps = 5000
+    set Stokes solver type = block GMG
+  end
+end
+
+# The model is a box with a width of 250 x 100 km and a depth of 100 km.
+# The number of X, Y and Z repetitions determine the shape of the coarsest
+# mesh cells (that will then be refined adaptively) relative to the
+# shape of the box. To achieve an aspect ratio of approximately one
+# for the cells, we choose more X than Y and Z repetitions.
+# Note that the geometry should be consistent with the geometry assumed in
+# in the GWB input file. Specifically, that means making sure that the
+# whole model domain lies inside the area prescribed by the coordinates
+# of the oceanic plate feature given in the GWB input file.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 250000
+    set Y extent  = 100000
+    set Z extent  = 100000
+    set X repetitions = 5
+    set Y repetitions = 2
+    set Z repetitions = 2
+  end
+end
+
+# Since we model an oceanic plate moving away from the ridge axis, we
+# prescribe the plate velocity of 3 cm/yr at the surface. Depending on
+# the side of the transform fault we are on, the velocity points either
+# in negative or positive x direction.
+# As per Behn et al., 2007: The base of the model is stress free.
+# Symmetric boundary conditions are imposed on the sides of the model space
+# parallel to the spreading direction, and the boundaries perpendicular to
+# spreading are open to convective flux (we prescribe the lithostatic
+# pressure).
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = front, back
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Function constants  = spreading_rate=0.03
+    set Variable names      = x,y,z
+    set Function expression = if(x<50000 || (x<200000 && y<50000), -spreading_rate, spreading_rate); 0; 0
+  end
+end
+
+# We prescribe a boundary traction in vertical direction at the bottom and
+# and right boundaries, setting it to the lithostatic pressure to allow
+# for free in- and outflow of material.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right:initial lithostatic pressure, left:initial lithostatic pressure, bottom:initial lithostatic pressure
+
+  # We choose the representative point at 125 km from the ridge, which
+  # is in the middle between the distance of the old (200 km) and young
+  # (50 km) ridge segment at each side.
+  subsection Initial lithostatic pressure
+    set Number of integration points = 1000
+    set Representative point         = 175000,0,0
+  end
+end
+
+# The initial temperature comes form the Geodynamic World Builder.
+subsection Initial temperature model
+  set List of model names = world builder
+end
+
+# We prescribe the surface temperature at the top and the mantle potential temperature
+# at the bottom.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 273.15
+    set Bottom temperature = 1573.15
+  end
+end
+
+subsection Material model
+  # Because we use the GMG solver, we need to average the viscosity.
+  set Material averaging = project to Q1 only viscosity
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Reference temperature and viscosity
+    set Reference temperature = 1573.15
+
+    # Limit the viscosity. The maximum value is 1e23 Pa s as given in
+    # Behn et al. 2007. The minimum value should never be reached, since
+    # the viscosity should never drop below the reference value of
+    # 1e19 Pa s.
+    set Minimum viscosity = 1e18
+    set Maximum viscosity = 1e23
+    set Heat capacities       = 1000
+    set Densities             = 3300           # Value from Behn et al., 2007
+    set Thermal expansivities = 0              # Thermal buoyancy is ignored in Behn et al., 2007
+    set Define thermal conductivities = true
+    set Thermal conductivities        = 3.5
+    set Viscous flow law      = diffusion
+    set Activation volumes for diffusion creep  = 0
+    set Grain size            = 1
+
+    # The reference viscosity is 1e19 Pa s, and viscosity does
+    # not depend on pressure.
+    # Case 1 in Behn et al. (2007) has a constant viscosity as used here.
+    set Prefactors for diffusion creep          = 5e-20
+    set Activation energies for diffusion creep = 0
+
+    # Plasticity parameters - irrelevant
+    # set to very high value so that it is not used
+    set Cohesions = 1e15
+  end
+end
+
+# The gravity points downward and is set to 10.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# The highest resolution in Behn et al is 3.75 km near the transform fault.
+# The coarse cells have a size of 50 km, which corresponds to 4 global
+# refinements.
+subsection Mesh refinement
+  set Time steps between mesh refinement = 0
+  set Initial global refinement = 4
+  set Initial adaptive refinement = 0          # For a higher resolution near the transform fault, set this to 2
+  set Strategy = minimum refinement function
+  set Skip solvers on initial refinement = true
+  set Minimum refinement level = 4
+
+  # Using initial adpative refinements 2 would allow for an increased
+  # resolution near the transform faults.
+  subsection Minimum refinement function
+    set Coordinate system = cartesian
+    set Function expression = if((x<60000 && x>40000 && y>45000 && z>70000) || (x<210000 && x>190000 && y<=55000 && z>70000) || ((x>40000 && x<210000 && y>40000 && y<60000 && z>70000)), 6, 4)
+    set Variable names = x,y,z
+  end
+end
+
+# The model does not include any heating terms.
+subsection Heating model
+  set List of model names =
+end
+
+# Below, we describe the variables we want to include in the graphical output.
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, mass flux statistics
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt fraction
+    set Point-wise stress and strain  = true
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set Time between graphical output = 1e5
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, thermal conductivity
+    end
+  end
+end
diff --git a/cookbooks/van-keken-vof/doc/amr.part.prm.bak b/cookbooks/van-keken-vof/doc/amr.part.prm.bak
new file mode 100644
index 00000000000..5dab825f0a7
--- /dev/null
+++ b/cookbooks/van-keken-vof/doc/amr.part.prm.bak
@@ -0,0 +1,8 @@
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = volume of fluid interface
+  set Initial global refinement          = 6
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
diff --git a/cookbooks/van-keken-vof/doc/main.part.prm.bak b/cookbooks/van-keken-vof/doc/main.part.prm.bak
new file mode 100644
index 00000000000..27ad1a66648
--- /dev/null
+++ b/cookbooks/van-keken-vof/doc/main.part.prm.bak
@@ -0,0 +1,19 @@
+subsection Compositional fields
+  set Number of fields = 1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Initial composition model
+  set Model name = function
+  set Volume of fluid initialization type = C_1:level set
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.2+0.02*cos(pi*x/0.9142)-z
+  end
+end
diff --git a/cookbooks/van-keken-vof/doc/postprocess.part.prm.bak b/cookbooks/van-keken-vof/doc/postprocess.part.prm.bak
new file mode 100644
index 00000000000..7783beaae07
--- /dev/null
+++ b/cookbooks/van-keken-vof/doc/postprocess.part.prm.bak
@@ -0,0 +1,13 @@
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set List of output variables      = volume of fluid values
+    set Output format                 = vtu
+    set Time between graphical output = 100
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/cookbooks/van-keken-vof/doc/variation.part.prm.bak b/cookbooks/van-keken-vof/doc/variation.part.prm.bak
new file mode 100644
index 00000000000..7a9ef22da72
--- /dev/null
+++ b/cookbooks/van-keken-vof/doc/variation.part.prm.bak
@@ -0,0 +1,10 @@
+subsection Initial composition model
+  set Model name = function
+  set Volume of fluid initialization type = C_1:level set
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926, a=0.02
+    set Function expression = 0.2+a*cos(pi*x/0.9142)-z
+  end
+end
diff --git a/cookbooks/van-keken-vof/van-keken-vof.prm.bak b/cookbooks/van-keken-vof/van-keken-vof.prm.bak
new file mode 100644
index 00000000000..8ad9be7a63e
--- /dev/null
+++ b/cookbooks/van-keken-vof/van-keken-vof.prm.bak
@@ -0,0 +1,108 @@
+# A description of the van Keken et al. thermochemical composition benchmark. See the manual for more
+# information.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 2000
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output-van-keken-vof
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Initial composition model
+  set Model name = function
+  set Volume of fluid initialization type = C_1:level set
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression  =  0.2+0.02*cos(pi*x/0.9142)-z
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = volume of fluid interface
+  set Initial global refinement          = 6
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics
+
+  subsection Visualization
+    set List of output variables      = volume of fluid values
+    set Output format                 = vtu
+    set Time between graphical output = 100
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/cookbooks/van-keken/doc/main.part.prm.bak b/cookbooks/van-keken/doc/main.part.prm.bak
new file mode 100644
index 00000000000..d63eb35aab1
--- /dev/null
+++ b/cookbooks/van-keken/doc/main.part.prm.bak
@@ -0,0 +1,19 @@
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.14159
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+end
diff --git a/cookbooks/van-keken/doc/postprocess.part.prm.bak b/cookbooks/van-keken/doc/postprocess.part.prm.bak
new file mode 100644
index 00000000000..3c96e051be4
--- /dev/null
+++ b/cookbooks/van-keken/doc/postprocess.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Postprocess
+  set List of postprocessors = velocity statistics
+end
diff --git a/cookbooks/van-keken/doc/smooth.part.prm.bak b/cookbooks/van-keken/doc/smooth.part.prm.bak
new file mode 100644
index 00000000000..055cc6480b4
--- /dev/null
+++ b/cookbooks/van-keken/doc/smooth.part.prm.bak
@@ -0,0 +1,9 @@
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.14159
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
diff --git a/cookbooks/van-keken/van-keken-discontinuous.prm.bak b/cookbooks/van-keken/van-keken-discontinuous.prm.bak
new file mode 100644
index 00000000000..407f2a4cf9a
--- /dev/null
+++ b/cookbooks/van-keken/van-keken-discontinuous.prm.bak
@@ -0,0 +1,93 @@
+# A description of the van Keken et al. benchmark. See the manual for more
+# information.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 2000
+set Use years in output instead of seconds = false
+set CFL number                             = 1.0
+set Output directory                       = output-van-keken-discontinuous
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 7
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 100
+  end
+end
diff --git a/cookbooks/van-keken/van-keken-smooth.prm.bak b/cookbooks/van-keken/van-keken-smooth.prm.bak
new file mode 100644
index 00000000000..1bf4eb236a3
--- /dev/null
+++ b/cookbooks/van-keken/van-keken-smooth.prm.bak
@@ -0,0 +1,94 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 2000
+set Use years in output instead of seconds = false
+set CFL number                             = 1.0
+set Output directory                       = output-van-keken-smooth
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 7
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 100
+  end
+end
diff --git a/cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc.bak b/cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc.bak
new file mode 100644
index 00000000000..b0236866b0f
--- /dev/null
+++ b/cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc.bak
@@ -0,0 +1,367 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <deal.II/grid/manifold_lib.h>
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/grid_tools.h>
+#include <aspect/utilities.h>
+#include <deal.II/dofs/dof_tools.h>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    using namespace dealii;
+
+    /**
+     * A geometry model based on the 2D Cartesian van Keken 2008 subduction
+     * benchmark. A custom mesh that is better suited to deal with
+     * the unique constraints of this benchmark is necessary to obtain a
+     * continuous pressure field.
+     *
+     * Because this mesh is highly specific, many of these functions are
+     * present only because of the way that we need to interface with the
+     * GeometryModel class, but they return nothing.
+     */
+
+    template <int dim>
+    class vanKeken : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        vanKeken();
+
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         */
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
+
+        double length_scale () const override;
+
+        /**
+         * Return the depth that corresponds to the given
+         * position. The documentation of the base class (see
+         * GeometryModel::Interface::depth()) describes in detail how
+         * "depth" is interpreted in general.
+         */
+        double depth(const Point<dim> &position) const override;
+
+
+        double height_above_reference_surface(const Point<dim> &position) const override;
+
+        /**
+         * @copydoc Interface<dim>::representative_point()
+         */
+        Point<dim> representative_point(const double depth) const override;
+
+        /**
+         * @copydoc Interface<dim>::maximal_depth()
+         */
+        double maximal_depth() const override;
+
+        /**
+         * Return the set of boundary indicators that are used by this model.
+         * This information is used to determine what boundary indicators can
+         * be used in the input file.
+         */
+        std::set<types::boundary_id>
+        get_used_boundary_indicators () const override;
+
+        /**
+         * Return symbolic names for all boundary components. Their names are
+         * described in the documentation of this plugin, at the bottom of the
+         * .cc file.
+         */
+        std::map<std::string,types::boundary_id>
+        get_symbolic_boundary_names_map () const override;
+
+        /**
+         * Return whether the given point lies within the domain specified
+         * by the geometry. This function does not take into account
+         * initial or dynamic surface topography.
+         */
+        bool
+        point_is_in_domain(const Point<dim> &point) const override;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is,
+         * which in this case is cartesian.
+         */
+        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
+
+        /**
+         * Declare the parameters this class takes through input files. However,
+         * for this geometry there are no parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * Again, there are no parameters to be declared for this class.
+         */
+        void
+        parse_parameters (ParameterHandler &) override;
+    };
+
+
+
+    template <int dim>
+    vanKeken<dim>::vanKeken()
+    {}
+
+    template <>
+    void
+    vanKeken<2>::
+    create_coarse_mesh (parallel::distributed::Triangulation<2> &coarse_grid) const
+    {
+      const std::vector<Point<2>> vertices =
+      {
+        //   0            1             2             3             4
+        {0.0, 0.0}, {50e3, 0.0}, {330e3, 0.0}, {600e3, 0.0}, {660e3, 0.0},
+        //   5              6               7               8               9
+        {0.0, 300e3}, {50e3, 300e3}, {233e3, 183e3}, {330e3, 270e3}, {660e3, 270e3},
+        //    10             11            12              13
+        {50e3, 550e3}, {660e3, 550e3}, {0.0, 600e3}, {660e3, 600e3}
+      };
+
+      // Next, we have to define the cells and the vertices they contain.
+      const std::vector<std::array<int, GeometryInfo<2>::vertices_per_cell>>
+      cell_vertices =
+      {
+        {{0, 1, 5, 6}},
+        {{8, 9, 10, 11}},
+        {{10, 11, 12, 13}},
+        {{1, 2, 6, 7}},
+        {{2, 3, 7, 8}},
+        {{3, 4, 8, 9}},
+        {{5, 6, 12, 10}},
+        {{6, 7, 10, 8}}
+      };
+
+      std::vector<CellData<2>> cells(cell_vertices.size(), CellData<2>());
+      for (unsigned int i = 0; i < cell_vertices.size(); ++i)
+        {
+          for (unsigned int j = 0; j < cell_vertices[i].size(); ++j)
+            cells[i].vertices[j] = cell_vertices[i][j];
+          cells[i].material_id = 0;
+        }
+
+      // Here we define the boundaries and the corresponding boundary id
+      // explicitly, based on the vertices that lie on them
+      SubCellData subcell_data;
+      subcell_data.boundary_lines.resize(10);
+
+      subcell_data.boundary_lines[0].vertices = {0,1};
+      subcell_data.boundary_lines[0].boundary_id = 0;
+
+      subcell_data.boundary_lines[1].vertices = {1,2};
+      subcell_data.boundary_lines[1].boundary_id = 0;
+
+      subcell_data.boundary_lines[2].vertices = {2,3};
+      subcell_data.boundary_lines[2].boundary_id = 0;
+
+      subcell_data.boundary_lines[3].vertices = {3,4};
+      subcell_data.boundary_lines[3].boundary_id = 0;
+
+      subcell_data.boundary_lines[4].vertices = {4,9};
+      subcell_data.boundary_lines[4].boundary_id = 3;
+
+      subcell_data.boundary_lines[5].vertices = {9,11};
+      subcell_data.boundary_lines[5].boundary_id = 3;
+
+      subcell_data.boundary_lines[6].vertices = {11,13};
+      subcell_data.boundary_lines[6].boundary_id = 3;
+
+      subcell_data.boundary_lines[7].vertices = {13,12};
+      subcell_data.boundary_lines[7].boundary_id = 1;
+
+      subcell_data.boundary_lines[8].vertices = {12,5};
+      subcell_data.boundary_lines[8].boundary_id = 2;
+
+      subcell_data.boundary_lines[9].vertices = {5,0};
+      subcell_data.boundary_lines[9].boundary_id = 2;
+
+      GridTools::consistently_order_cells(cells);
+
+      // Then create the actual mesh:
+      coarse_grid.create_triangulation(vertices, cells, subcell_data);
+    }
+
+
+    // Not allow to be 3D
+    template <>
+    void
+    vanKeken<3>::
+    create_coarse_mesh (parallel::distributed::Triangulation<3> &) const
+    {
+      Assert (false, ExcNotImplemented());
+    }
+
+
+    template <int dim>
+    std::set<types::boundary_id>
+    vanKeken<dim>::
+    get_used_boundary_indicators () const
+    {
+      std::set<types::boundary_id> s;
+      for (unsigned int i=0; i<2*dim; ++i)
+        s.insert (i);
+      return s;
+    }
+
+
+
+    template <>
+    std::map<std::string,types::boundary_id>
+    vanKeken<2>::
+    get_symbolic_boundary_names_map () const
+    {
+      static const std::pair<std::string,types::boundary_id> mapping[]
+        = { std::pair<std::string,types::boundary_id> ("bottom", 0),
+            std::pair<std::string,types::boundary_id> ("top", 1),
+            std::pair<std::string,types::boundary_id> ("left",  2),
+            std::pair<std::string,types::boundary_id> ("right", 3)
+          };
+      return std::map<std::string,types::boundary_id> (std::begin(mapping),
+                                                       std::end(mapping));
+    }
+
+    template <>
+    std::map<std::string,types::boundary_id>
+    vanKeken<3>::
+    get_symbolic_boundary_names_map () const
+    {
+      Assert (false, ExcNotImplemented());
+      std::map<std::string,types::boundary_id> empty;
+      return empty;
+    }
+
+
+
+    template <int dim>
+    double
+    vanKeken<dim>::
+    length_scale () const
+    {
+      return 1e4;
+    }
+
+    template <int dim>
+    double
+    vanKeken<dim>::depth(const Point<dim> &position) const
+    {
+      // Get the surface x (,y) point
+      Point<dim-1> surface_point;
+      for (unsigned int d=0; d<dim-1; ++d)
+        surface_point[d] = position[d];
+
+      Assert(dim==2, ExcNotImplemented());
+      const double y_extent = 600e3;
+      const double d = y_extent - (position(dim-1));
+      return std::min (std::max (d, 0.), maximal_depth());
+    }
+
+
+
+    template <int dim>
+    double
+    vanKeken<dim>::height_above_reference_surface(const Point<dim> &) const
+    {
+      return 0.0;
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    vanKeken<dim>::representative_point(const double depth) const
+    {
+      Point<dim> p;
+      p(dim-1) = depth;
+      return p;
+    }
+
+
+
+    template <int dim>
+    double
+    vanKeken<dim>::maximal_depth() const
+    {
+      return 600e3;
+    }
+
+
+
+    template <int dim>
+    bool
+    vanKeken<dim>::point_is_in_domain(const Point<dim> &) const
+    {
+      return true;
+    }
+
+
+    template <int dim>
+    aspect::Utilities::Coordinates::CoordinateSystem
+    vanKeken<dim>::natural_coordinate_system() const
+    {
+      return aspect::Utilities::Coordinates::CoordinateSystem::cartesian;
+    }
+
+
+
+    template <int dim>
+    void
+    vanKeken<dim>::declare_parameters (ParameterHandler &)
+    {}
+
+
+
+    template <int dim>
+    void
+    vanKeken<dim>::parse_parameters (ParameterHandler &)
+    {}
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    ASPECT_REGISTER_GEOMETRY_MODEL(vanKeken,
+                                   "vanKeken box",
+                                   "A specialized geometry model used for the van Keken 2008 "
+                                   "corner flow style subduction benchmark. While the geometry "
+                                   "described by this plugin is just a square, a mesh consisting of non-square cells "
+                                   "is required to allow the boundaries of the mesh to lie along "
+                                   "the slab-mantle wedge interface, which allows the pressure "
+                                   "solution to be continuous."
+                                  )
+  }
+}
diff --git a/cookbooks/vankeken_subduction/vankeken_corner_flow.prm.bak b/cookbooks/vankeken_subduction/vankeken_corner_flow.prm.bak
new file mode 100644
index 00000000000..67f8fb1fdfc
--- /dev/null
+++ b/cookbooks/vankeken_subduction/vankeken_corner_flow.prm.bak
@@ -0,0 +1,157 @@
+# This is a cookbook which aims to replicate the corner flow style subduction outlined
+# in van Keken et al., 2008. In this cookbook, a slab with a thermal age of 50 Myr is
+# subducted beneath a 50 km thick overriding plate at a constant dip of 45 degrees. The
+# velocity is prescribed to be 5 cm/yr in the subducting plate, and 0 in the overriding
+# plate. Due to these constraints, and the way that ASPECT usually generates a mesh,
+# a custom mesh is used to prevent an ill-posed pressure solution at the triple point
+# intersection between the mantle wedge, overriding plate, and down going plate.
+
+# Load the prescribed velocity and pressure library
+set Additional shared libraries            = ./plugin/libvankeken_subduction.so
+set Dimension                              = 2
+set Output directory                       = vankeken-output
+set Use years in output instead of seconds = true
+set Pressure normalization                 = no
+set Surface pressure                       = 0
+set Use conduction timestep                = true
+set End time                               = 3.4e8
+set Resume computation                     = false
+set Adiabatic surface temperature          = 1600
+
+# Turn prescribed velocities on, this is necessary for the subducting
+# and overriding plates.
+set Prescribe internal velocities = true
+
+# Solver parameters
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type                              = block AMG
+    set Maximum number of expensive Stokes solver steps = 1000
+  end
+end
+
+# q2q1 discretization
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+  set Use locally conservative discretization = false
+end
+
+# Incompressible
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# Use the specialized geometry model for this cookbook
+subsection Geometry model
+  set Model name = vanKeken box
+end
+
+# Checkpoint every 200 steps
+subsection Checkpointing
+  set Steps between checkpoint = 200
+end
+
+# Prescribe a half space cooling model on the left boundary and in the overriding plate
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y,t
+
+    # H is the model Y extent, Hl is the overriding plate thickness, TS is the surface temperature
+    # T0 is the temperature at the base of the slab
+    set Function constants = H=6.0e5, Hl=5.0e4, TS=273.0, T0=1573.0, kappa=0.7272e-6, t50=1.5778463e15
+    set Function expression = if(x<=(H-y),TS+(T0-TS)*(1.0-erfc( (H-y)/(2.0*sqrt(kappa*t50))) ), \
+                              if(x>(H-y) & y>(H-Hl), TS+(T0-TS)*(H-y)/Hl, \
+                                T0 ) )
+  end
+end
+
+# Bottom and right boundary is open
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = bottom:zero traction
+end
+
+# Keep the temperature fixed on the left, top and right boundaries
+subsection Boundary temperature model
+  set List of model names                           = initial temperature
+  set Fixed temperature boundary indicators         = top, left, right
+end
+
+# Prescribe a velocity of 5 cm/yr on the left boundary, 0 on the top
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left: function, top:function
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = H=6.01e5, v=0.035355339
+    set Function expression = if( x<=(H-y), v, 0.0) ; \
+                              if( x<=(H-y),-v, 0.0 )
+  end
+end
+
+# No gravity
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.
+  end
+end
+
+# Use the visco plastic material model and specify and isoviscous material with
+# a viscosiy of 1e20 Pa s
+subsection Material model
+  set Model name         = simpler
+
+  subsection Simpler model
+    set Reference density             = 3300.0
+    set Thermal expansion coefficient = 0.000035
+    set Thermal conductivity          = 3.0
+    set Viscosity                     = 1e20
+    set Reference specific heat       = 1250.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Run postprocessors on initial refinement = true
+  set Refinement fraction                      = 1.0
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Prescribed velocities
+  subsection Indicator function
+    set Variable names = x,y,t
+
+    # Return where to prescribe u_x; u_y
+    # 1 if velocity should be prescribed, 0 otherwise
+
+    set Function constants  = H=6.0e5, W=6.6e5, de=100
+    set Function expression = if( abs(H-y-x)<=de | (y>=601e3 - x  & y>=550e3), 1, 0); \
+                              if( abs(H-y-x)<=de | (y>=601e3 - x  & y>=550e3), 1, 0)
+  end
+
+  subsection Velocity function
+    set Variable names = x,y,t
+
+    # Return the prescribed u_x; u_y;
+    set Function constants  = H=6.0e5, W=6.6e5, de=100, v=0.035355339, s2yr=31557600
+    set Function expression = if(abs(H-y-x)<=de, v/s2yr, 0.0); \
+                              if(abs(H-y-x)<=de, -v/s2yr, 0.0)
+  end
+end
+
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, velocity statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, stress second invariant, heat flux map, depth
+    set Output format = vtu
+    set Interpolate output = true
+    set Time between graphical output = 1e7
+  end
+end
diff --git a/cookbooks/visualizing_phase_diagram/doc/harzburgite.prm.bak b/cookbooks/visualizing_phase_diagram/doc/harzburgite.prm.bak
new file mode 100644
index 00000000000..42ac5feb2bc
--- /dev/null
+++ b/cookbooks/visualizing_phase_diagram/doc/harzburgite.prm.bak
@@ -0,0 +1,9 @@
+# initial composition model
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Function expression = 1.0  # change this to one
+  end
+end
diff --git a/cookbooks/visualizing_phase_diagram/doc/material_model.prm.bak b/cookbooks/visualizing_phase_diagram/doc/material_model.prm.bak
new file mode 100644
index 00000000000..a25c3ad00d5
--- /dev/null
+++ b/cookbooks/visualizing_phase_diagram/doc/material_model.prm.bak
@@ -0,0 +1,15 @@
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Maximum viscosity = 1e24
+    set Phase transition depths = background:410e3|520e3|560e3|670e3|670e3|670e3|670e3, spharz: 410e3|520e3|560e3|670e3|670e3|670e3|670e3
+    set Phase transition widths = background:5e3|5e3|5e3|5e3|5e3|5e3|5e3, spharz: 5e3|5e3|5e3|5e3|5e3|5e3|5e3
+    set Phase transition temperatures = background:1662.0|1662.0|1662.0|1662.0|1662.0|1662.0|1662.0, spharz: 1662.0|1662.0|1662.0|1662.0|1662.0|1662.0|1662.0
+    set Phase transition Clapeyron slopes = background:4e6|4.1e6|4e6|-2e6|4e6|-3.1e6|1.3e6, spharz: 4e6|4.1e6|4e6|-2e6|4e6|-3.1e6|1.3e6
+    set Densities = 3300.0
+    set Heat capacities = background: 3300.0|3394.4|3442.1|3453.2|3617.6|3691.5|3774.7|3929.1, spharz: 3235.0|3372.3|3441.7|3441.7|3680.8|3717.8|3759.4|3836.6
+    set Thermal expansivities = 0.0
+  end
+end
diff --git a/cookbooks/visualizing_phase_diagram/doc/steinberg.prm.bak b/cookbooks/visualizing_phase_diagram/doc/steinberg.prm.bak
new file mode 100644
index 00000000000..3c01f3bd620
--- /dev/null
+++ b/cookbooks/visualizing_phase_diagram/doc/steinberg.prm.bak
@@ -0,0 +1,17 @@
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                                = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
+    set Material file names                           = pyr-ringwood88.txt
+    set Radial viscosity file name                    = radial-visc.txt
+    set Maximum lateral viscosity variation           = 1e2
+    set Maximum viscosity                             = 1e23
+    set Minimum viscosity                             = 1e19
+    set Use lateral average temperature for viscosity = true
+    set Number lateral average bands                  = 10
+    set Bilinear interpolation                        = true
+    set Latent heat                                   = false
+  end
+end
diff --git a/cookbooks/visualizing_phase_diagram/visualizing_phase_diagram.prm.bak b/cookbooks/visualizing_phase_diagram/visualizing_phase_diagram.prm.bak
new file mode 100644
index 00000000000..dd7743d98ff
--- /dev/null
+++ b/cookbooks/visualizing_phase_diagram/visualizing_phase_diagram.prm.bak
@@ -0,0 +1,131 @@
+# This prm file is used to generate a phase diagram.
+# This could be useful for densities, viscosities in a material model.
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Adiabatic surface temperature          = 1673.0
+set Output directory                       = output
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme = no Advection, no Stokes
+
+# Model geometry
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 50
+    set Y repetitions = 50
+    set X extent      = 800e3
+    set Y extent      = 800e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = left, right
+  set List of model names = box
+
+  subsection Box
+    set Left temperature   = 273
+    set Right temperature  = 2273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y
+    set Function constants = XMAX=800e3, Tl=273.0, Tr=2273
+    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
+  end
+end
+
+# Uncomment this part for Steinberger model and pyrolitic lookup table
+#subsection Material model
+#  set Model name = Steinberger
+#  subsection Steinberger model
+#    set Data directory                                = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+#    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
+#    set Material file names                           = pyr-ringwood88.txt
+#    set Radial viscosity file name                    = radial-visc.txt
+#
+#    set Maximum lateral viscosity variation           = 1e2
+#    set Maximum viscosity                             = 1e23
+#    set Minimum viscosity                             = 1e19
+#
+#    set Use lateral average temperature for viscosity = true
+#    set Number lateral average bands                  = 10
+#
+#    set Bilinear interpolation                        = true
+#    set Latent heat                                   = false
+#  end
+#end
+
+# Comment the following 3 sections for steinberg model and pyrolitic lookup table
+# Fields of composition
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = spharz
+  set Compositional field methods = field
+end
+
+# Initial composition model
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Function expression = 0.0
+  end
+end
+
+# Value for material model
+# Set Densities to a constant value and thermal expansivity to 0.0 to have a constant pressure gradient
+# Set Values of Heat capacities to values of reference densities of pyrolitic phases
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Maximum viscosity = 1e24
+    set Phase transition depths = background:410e3|520e3|560e3|670e3|670e3|670e3|670e3, spharz: 410e3|520e3|560e3|670e3|670e3|670e3|670e3
+    set Phase transition widths = background:5e3|5e3|5e3|5e3|5e3|5e3|5e3, spharz: 5e3|5e3|5e3|5e3|5e3|5e3|5e3
+    set Phase transition temperatures = background:1662.0|1662.0|1662.0|1662.0|1662.0|1662.0|1662.0, spharz: 1662.0|1662.0|1662.0|1662.0|1662.0|1662.0|1662.0
+    set Phase transition Clapeyron slopes = background:4e6|4.1e6|4e6|-2e6|4e6|-3.1e6|1.3e6, spharz: 4e6|4.1e6|4e6|-2e6|4e6|-3.1e6|1.3e6
+    set Densities = 3300.0
+    set Heat capacities = background: 3300.0|3394.4|3442.1|3453.2|3617.6|3691.5|3774.7|3929.1, spharz: 3235.0|3372.3|3441.7|3441.7|3680.8|3717.8|3759.4|3836.6
+    set Thermal expansivities = 0.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom, left, right
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format                 = vtu
+    set List of output variables      = density, thermal expansivity, specific heat
+    set Time between graphical output = 0e6
+  end
+end
diff --git a/doc/logo/logo.prm.bak b/doc/logo/logo.prm.bak
new file mode 100644
index 00000000000..6ce430cd233
--- /dev/null
+++ b/doc/logo/logo.prm.bak
@@ -0,0 +1,111 @@
+# A simple setup for convection in a 2d shell.
+# This model was used to generate ASPECT's logo, which can be recreated using
+# the ASPECT version and dependencies specified below, and using the paraview
+# state file and the output file in output/ and ParaView version 5.8.1.
+# Alternatively the docker image gassmoeller/aspect-logo contains this version
+# of ASPECT as a precompiled binary.  The docker image can be rebuild from the
+# Dockerfile in this path.
+#
+# To recreate the output in paraview, load the state, adjust the file paths,
+# and create a screenshot without the mesh with 4x the suggested resolution on
+# a 1080p screen (6160 x 3176 px) and with a transparent background.
+# For the mesh output disable the background, enable the mesh, and create a
+# screenshot with 2x the suggested resolution on a 1080p screen (3080 x 1588
+# px). Then crop the resulting figures to content and use in the .svg.
+#
+#-----------------------------------------------------------------------------
+#-- This is ASPECT, the Advanced Solver for Problems in Earth's ConvecTion.
+#--     . version 2.2.0-pre (master, 148bb56fe)
+#--     . using deal.II 9.0.1
+#--     .       with 32 bit indices and vectorization level 1 (128 bits)
+#--     . using Trilinos 12.10.1
+#--     . using p4est 2.0.0
+#--     . running in OPTIMIZED mode
+#--     . running with 6 MPI processes
+#-----------------------------------------------------------------------------
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Output directory                       = output-logo
+set Use conduction timestep                = true
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 2e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6371000
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = \
+      top: 273, bottom: 4273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1973
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 2
+  set Refinement fraction                = 0.6
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 3
+  set Minimum refinement level = 3
+end
+
+# We increase the solver tolerance to speed things up
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-3
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 6.51092e8
+    set Number of grouped files       = 1
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria = end step
+  set End step = 1430
+end
diff --git a/doc/manual/cookbooks/overview/doc/boundary-conditions.part.prm.bak b/doc/manual/cookbooks/overview/doc/boundary-conditions.part.prm.bak
new file mode 100644
index 00000000000..e48524ae495
--- /dev/null
+++ b/doc/manual/cookbooks/overview/doc/boundary-conditions.part.prm.bak
@@ -0,0 +1,7 @@
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
diff --git a/doc/manual/cookbooks/overview/doc/dim.part.prm.bak b/doc/manual/cookbooks/overview/doc/dim.part.prm.bak
new file mode 100644
index 00000000000..03df82cc72b
--- /dev/null
+++ b/doc/manual/cookbooks/overview/doc/dim.part.prm.bak
@@ -0,0 +1 @@
+set Dimension                     = 2
diff --git a/doc/manual/cookbooks/overview/doc/geometry.part.prm.bak b/doc/manual/cookbooks/overview/doc/geometry.part.prm.bak
new file mode 100644
index 00000000000..2e755469d64
--- /dev/null
+++ b/doc/manual/cookbooks/overview/doc/geometry.part.prm.bak
@@ -0,0 +1,10 @@
+set Dimension = 2
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
diff --git a/doc/manual/cookbooks/overview/doc/gmg-average.part.prm.bak b/doc/manual/cookbooks/overview/doc/gmg-average.part.prm.bak
new file mode 100644
index 00000000000..7cad0231baf
--- /dev/null
+++ b/doc/manual/cookbooks/overview/doc/gmg-average.part.prm.bak
@@ -0,0 +1,3 @@
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/doc/manual/cookbooks/overview/doc/gmg-enable.part.prm.bak b/doc/manual/cookbooks/overview/doc/gmg-enable.part.prm.bak
new file mode 100644
index 00000000000..e4097ad02cc
--- /dev/null
+++ b/doc/manual/cookbooks/overview/doc/gmg-enable.part.prm.bak
@@ -0,0 +1,5 @@
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/doc/manual/cookbooks/overview/doc/simple.prm.bak b/doc/manual/cookbooks/overview/doc/simple.prm.bak
new file mode 100644
index 00000000000..b5eec069e06
--- /dev/null
+++ b/doc/manual/cookbooks/overview/doc/simple.prm.bak
@@ -0,0 +1,16 @@
+set Dimension                     = 2
+set End time                      = 1.5e9
+set Output directory              = output
+
+subsection Geometry model
+  set Model name                  = spherical shell
+end
+
+subsection Mesh refinement
+  set Initial global refinement   = 4
+  set Initial adaptive refinement = 1
+end
+
+subsection Postprocess
+  set List of postprocessors      = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+end
diff --git a/doc/manual/cookbooks/overview/doc/structure.part.prm.bak b/doc/manual/cookbooks/overview/doc/structure.part.prm.bak
new file mode 100644
index 00000000000..08f98273467
--- /dev/null
+++ b/doc/manual/cookbooks/overview/doc/structure.part.prm.bak
@@ -0,0 +1,20 @@
+set Dimension                     = 2
+set Resume computation            = false
+set End time                      = 1e10
+set CFL number                    = 1.0
+set Output directory              = output
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 1
+  set Initial global refinement   = 4
+end
+
+subsection Material model
+  set Model name                  = simple
+
+  subsection Simple model
+    set Reference density         = 3300
+    set Reference temperature     = 293
+    set Viscosity                 = 5e24
+  end
+end
diff --git a/doc/manual/empty.prm.bak b/doc/manual/empty.prm.bak
new file mode 100644
index 00000000000..b24c465d5e6
--- /dev/null
+++ b/doc/manual/empty.prm.bak
@@ -0,0 +1,32 @@
+# this nearly empty .prm is used to generate parameters.tex
+# by running aspect.
+# sadly we need to set a few where there are no default values:
+
+set End time = 0.0
+
+subsection Geometry model
+  set Model name = box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = left, right, bottom, top
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/include/aspect/adiabatic_conditions/ascii_data.h.bak b/include/aspect/adiabatic_conditions/ascii_data.h.bak
new file mode 100644
index 00000000000..fc9ca54d8e2
--- /dev/null
+++ b/include/aspect/adiabatic_conditions/ascii_data.h.bak
@@ -0,0 +1,130 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_adiabatic_conditions_ascii_data_h
+#define _aspect_adiabatic_conditions_ascii_data_h
+
+
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/point.h>
+
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    using namespace dealii;
+
+    /**
+     * A simple class that reads adiabatic conditions from a file.
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataProfile<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. Because this function is called after
+         * initializing the SimulatorAccess, all of the necessary information
+         * is available to calculate the adiabatic profile. It computes the
+         * adiabatic conditions along a vertical transect of the geometry
+         * based on the given material model and other quantities.
+         */
+        void initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataProfile<dim>::initialize;
+
+        /**
+         * Some plugins need to know whether the adiabatic conditions are
+         * already calculated. This is for example the case for the simple
+         * compressible material model, which uses the adiabatic temperature
+         * as reference temperature to calculate the density. For the
+         * calculation of the adiabatic conditions this functionality is
+         * simply switched off, because we are always on the reference
+         * profile. This way the plugin behaves differently at initialization
+         * time of the adiabatic conditions and during the main model run.
+         */
+        bool is_initialized() const override;
+
+        /**
+         * Return the adiabatic temperature at a given point of the domain.
+         */
+        double temperature (const Point<dim> &p) const override;
+
+        /**
+         * Return the adiabatic pressure at a given point of the domain.
+         */
+        double pressure (const Point<dim> &p) const override;
+
+        /**
+         * Return the reference density at a given point of the domain.
+         */
+        double density (const Point<dim> &p) const override;
+
+        /**
+         * Return the derivative of the density with respect to depth
+         * at the given point @p p.
+         */
+        double density_derivative (const Point<dim> &p) const override;
+
+        /**
+         * Declare the parameters for the input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler  &prm);
+
+        /**
+         * Read the parameters from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * Whether the adiabatic conditions are already calculated. This is
+         * important for plugins that are used by the adiabatic conditions but
+         * also depend on the adiabatic conditions. This way they can behave
+         * differently in initialization and model run.
+         */
+        bool initialized;
+
+        /**
+         * The column indices of the temperature, pressure, and density column
+         * in the data file.
+         */
+        unsigned int temperature_index;
+        unsigned int pressure_index;
+        unsigned int density_index;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/adiabatic_conditions/compute_entropy_profile.h.bak b/include/aspect/adiabatic_conditions/compute_entropy_profile.h.bak
new file mode 100644
index 00000000000..77d6d7a4dc5
--- /dev/null
+++ b/include/aspect/adiabatic_conditions/compute_entropy_profile.h.bak
@@ -0,0 +1,147 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_adiabatic_conditions_compute_entropy_profile_h
+#define _aspect_adiabatic_conditions_compute_entropy_profile_h
+
+
+#include <aspect/adiabatic_conditions/interface.h>
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    using namespace dealii;
+
+    /**
+     * A model in which the adiabatic profile is
+     * calculated by solving the hydrostatic equations for
+     * pressure and entropy in depth.
+     * Of course the entropy along an adiabat is constant.
+     * This plugin requires the material model to provide an
+     * additional output object of type PrescribedTemperatureOutputs.
+     * It also requires that there is a compositional field named
+     * 'entropy' that represents the entropy of the material.
+     */
+    template <int dim>
+    class ComputeEntropyProfile : public Interface<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        ComputeEntropyProfile ();
+
+        /**
+         * Initialization function. Because this function is called after
+         * initializing the SimulatorAccess, all of the necessary information
+         * is available to calculate the adiabatic profile. It computes the
+         * adiabatic conditions along a vertical transect of the geometry
+         * based on the given material model and other quantities.
+         */
+        void initialize () override;
+
+        /**
+         * Some plugins need to know whether the adiabatic conditions are
+         * already calculated. This is for example the case for the simple
+         * compressible material model, which uses the adiabatic temperature
+         * as reference temperature to calculate the density. For the
+         * calculation of the adiabatic conditions this functionality is
+         * simply switched off, because we are always on the reference
+         * profile. This way the plugin behaves differently at initialization
+         * time of the adiabatic conditions and during the main model run.
+         */
+        bool is_initialized() const override;
+
+        /**
+         * Return the adiabatic temperature at a given point of the domain.
+         */
+        double temperature (const Point<dim> &p) const override;
+
+        /**
+         * Return the adiabatic pressure at a given point of the domain.
+         */
+        double pressure (const Point<dim> &p) const override;
+
+        /**
+         * Return the reference density at a given point of the domain.
+         */
+        double density (const Point<dim> &p) const override;
+
+        /**
+         * Return the derivative of the density with respect to depth
+         * at the given point @p p.
+         */
+        double density_derivative (const Point<dim> &p) const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Whether the adiabatic conditions are already calculated. This is
+         * important for plugins that are used by the adiabatic conditions but
+         * also depend on the adiabatic conditions. This way they can behave
+         * differently in initialization and model run.
+         */
+        bool initialized;
+
+        /**
+         * Number of points at which we compute the adiabatic values.
+         */
+        unsigned int n_points;
+
+        /**
+         * Starting entropy for the profile.
+         */
+        double surface_entropy;
+
+        /**
+         * Vectors of values of temperatures and pressures on a transect into
+         * depth at which we have computed them. The public member functions
+         * of this class interpolate linearly between these points.
+         */
+        std::vector<double> temperatures;
+        std::vector<double> pressures;
+        std::vector<double> densities;
+
+        /**
+         * Interval spacing between each two data points in the tables above
+         * with regard to the depth coordinate.
+         */
+        double delta_z;
+
+        /**
+         * Internal helper function. Returns the reference property at a
+         * given point of the domain.
+         */
+        double get_property (const Point<dim> &p,
+                             const std::vector<double> &property) const;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/adiabatic_conditions/compute_profile.h.bak b/include/aspect/adiabatic_conditions/compute_profile.h.bak
new file mode 100644
index 00000000000..d0d2f01e76b
--- /dev/null
+++ b/include/aspect/adiabatic_conditions/compute_profile.h.bak
@@ -0,0 +1,200 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_adiabatic_conditions_compute_profile_h
+#define _aspect_adiabatic_conditions_compute_profile_h
+
+
+#include <aspect/adiabatic_conditions/interface.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    using namespace dealii;
+
+    /**
+     * A model in which the adiabatic profile is calculated by solving the
+     * hydrostatic equations for pressure and temperature in depth. The
+     * gravity is assumed to be in depth direction and the composition is
+     * either given by the initial composition at reference points or computed
+     * as a reference depth-function. All material parameters are computed by
+     * the material model plugin. The surface conditions are either constant
+     * or changing over time as prescribed by an user-provided function.
+     */
+    template <int dim>
+    class ComputeProfile : public Interface<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        ComputeProfile ();
+
+        /**
+         * Initialization function. Because this function is called after
+         * initializing the SimulatorAccess, all of the necessary information
+         * is available to calculate the adiabatic profile. It computes the
+         * adiabatic conditions along a vertical transect of the geometry
+         * based on the given material model and other quantities.
+         */
+        void initialize () override;
+
+        /**
+         * Update function. By default does nothing, but if a time-dependent
+         * surface condition function is used, this will reinitialize the
+         * adiabatic profile with the current conditions.
+         */
+        void update () override;
+
+        /**
+         * Some plugins need to know whether the adiabatic conditions are
+         * already calculated. This is for example the case for the simple
+         * compressible material model, which uses the adiabatic temperature
+         * as reference temperature to calculate the density. For the
+         * calculation of the adiabatic conditions this functionality is
+         * simply switched off, because we are always on the reference
+         * profile. This way the plugin behaves differently at initialization
+         * time of the adiabatic conditions and during the main model run.
+         */
+        bool is_initialized() const override;
+
+        /**
+         * Return the adiabatic temperature at a given point of the domain.
+         */
+        double temperature (const Point<dim> &p) const override;
+
+        /**
+         * Return the adiabatic pressure at a given point of the domain.
+         */
+        double pressure (const Point<dim> &p) const override;
+
+        /**
+         * Return the reference density at a given point of the domain.
+         */
+        double density (const Point<dim> &p) const override;
+
+        /**
+         * Return the derivative of the density with respect to depth
+         * at the given point @p p.
+         */
+        double density_derivative (const Point<dim> &p) const override;
+
+        /**
+         * Declare the parameters for the input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * Whether the adiabatic conditions are already calculated. This is
+         * important for plugins that are used by the adiabatic conditions but
+         * also depend on the adiabatic conditions. This way they can behave
+         * differently in initialization and model run.
+         */
+        bool initialized;
+
+        /**
+         * Number of points at which we compute the adiabatic values.
+         */
+        unsigned int n_points;
+
+        /**
+         * Vectors of values of temperatures and pressures on a transect into
+         * depth at which we have computed them. The public member functions
+         * of this class interpolate linearly between these points.
+         */
+        std::vector<double> temperatures;
+        std::vector<double> pressures;
+        std::vector<double> densities;
+
+        /**
+         * Interval spacing between each two data points in the tables above
+         * with regard to the depth coordinate.
+         */
+        double delta_z;
+
+        /**
+         * An enum describing the different options to compute the reference
+         * profile for composition.
+         */
+        enum CompositionProfile
+        {
+          initial_composition,
+          reference_function
+        };
+
+        /**
+         * Selected option to compute the reference profile for composition.
+         */
+        CompositionProfile reference_composition;
+
+        /**
+         * Function object that computes the reference composition profile
+         * if the reference_composition variable is set to function.
+         */
+        std::unique_ptr<Functions::ParsedFunction<1>> composition_function;
+
+        /**
+         * Whether to use the surface_conditions_function to determine surface
+         * conditions, or the adiabatic_surface_temperature and surface_pressure
+         * parameters. If this is set to true the reference profile is updated
+         * every timestep.
+         */
+        bool use_surface_condition_function;
+
+        /**
+         * ParsedFunction: If provided in the input file it prescribes
+         * (surface pressure(t), surface temperature(t)).
+         */
+        Functions::ParsedFunction<1> surface_condition_function;
+
+        /**
+         * A shared pointer to the initial composition object
+         * that ensures that the current object can continue
+         * to access the initial composition object beyond the
+         * first time step.
+         */
+        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition_manager;
+
+        /**
+         * Internal helper function. Returns the reference property at a
+         * given point of the domain.
+         */
+        double get_property (const Point<dim> &p,
+                             const std::vector<double> &property) const;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/adiabatic_conditions/function.h.bak b/include/aspect/adiabatic_conditions/function.h.bak
new file mode 100644
index 00000000000..e124766473d
--- /dev/null
+++ b/include/aspect/adiabatic_conditions/function.h.bak
@@ -0,0 +1,107 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_adiabatic_conditions_function_h
+#define _aspect_adiabatic_conditions_function_h
+
+
+#include <aspect/adiabatic_conditions/interface.h>
+#include <deal.II/base/point.h>
+#include <deal.II/base/parsed_function.h>
+
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    using namespace dealii;
+
+    /**
+     * A simple class that sets the adiabatic conditions based on given
+     * a given function with three components: temperature, pressure, density.
+     */
+    template <int dim>
+    class Function : public Interface<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        Function ();
+
+        /**
+         * Initialization function.
+         */
+        void initialize () override;
+
+        /**
+         * Some plugins need to know whether the adiabatic conditions are
+         * already calculated, this is always true for the Function class.
+         */
+        bool is_initialized() const override;
+
+        /**
+         * Return the adiabatic temperature at a given point of the domain.
+         */
+        double temperature (const Point<dim> &p) const override;
+
+
+        /**
+         * Return the adiabatic pressure at a given point of the domain.
+         */
+        double pressure (const Point<dim> &p) const override;
+
+        /**
+         * Return the reference_density at a given point of the domain.
+         */
+        double density (const Point<dim> &p) const override;
+
+        /**
+         * Return the derivative of the density with respect to depth
+         * at the given point @p p.
+         */
+        double density_derivative (const Point<dim> &p) const override;
+
+        /**
+         * Declare the parameters for the input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * ParsedFunction: depth->(temperature, pressure, density)
+         */
+        Functions::ParsedFunction<1> function;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/adiabatic_conditions/interface.h.bak b/include/aspect/adiabatic_conditions/interface.h.bak
new file mode 100644
index 00000000000..6f662e0bd9b
--- /dev/null
+++ b/include/aspect/adiabatic_conditions/interface.h.bak
@@ -0,0 +1,226 @@
+/*
+  Copyright (C) 2013 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_adiabatic_conditions_interface_h
+#define _aspect_adiabatic_conditions_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/distributed/tria.h>
+
+
+namespace aspect
+{
+  /**
+   * A namespace for the definition of things that have to do with describing
+   * the calculation of a reference adiabatic profile.
+   *
+   * @ingroup AdiabaticConditions
+   */
+  namespace AdiabaticConditions
+  {
+    using namespace dealii;
+
+    /**
+     * Base class for classes that describe adiabatic conditions,
+     * i.e. that starts at the top of the domain and integrate
+     * pressure and temperature as we go down into depth. There are
+     * several ways to do this (time-dependent or constant, using
+     * laterally averaged values or a reference profile), therefore we
+     * allow for user written plugins.
+     *
+     * @ingroup AdiabaticConditions
+     */
+    template <int dim>
+    class Interface: public SimulatorAccess<dim>, public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Some plugins need to know whether the adiabatic conditions are
+         * already calculated. Namely all plugins that are needed to create
+         * the adiabatic conditions but themselves depend on the adiabatic
+         * profile. Utilizing this function they may behave differently on
+         * initialization of the adiabatic conditions and at model runtime.
+         */
+        virtual
+        bool
+        is_initialized () const = 0;
+
+        /**
+         * Return the adiabatic temperature at a given point of the domain.
+         */
+        virtual
+        double temperature (const Point<dim> &p) const = 0;
+
+        /**
+         * Return the adiabatic pressure at a given point of the domain.
+         */
+        virtual
+        double pressure (const Point<dim> &p) const = 0;
+
+        /**
+         * Return the reference_density at a given point of the domain.
+         */
+        virtual
+        double density (const Point<dim> &p) const = 0;
+
+        /**
+         * Return the derivative of the density with respect to depth
+         * at the given point @p p.
+         */
+        virtual
+        double density_derivative (const Point<dim> &p) const = 0;
+
+        /**
+         * Return the adiabatic temperature profile as a vector of values
+         * corresponding to increasing depth.
+         *
+         * @param values The output vector of depth averaged values. The
+         * function takes the pre-existing size of this vector as the number
+         * of depth slices.
+         *
+         * @deprecated: This function is deprecated.
+         * Use the function temperature() for specific positions instead.
+         */
+        DEAL_II_DEPRECATED
+        virtual
+        void get_adiabatic_temperature_profile(std::vector<double> &values) const;
+
+        /**
+         * Like get_adiabatic_temperature_profile() but for the pressure.
+         *
+         * @deprecated: This function is deprecated.
+         * Use the function pressure() for specific positions instead.
+         */
+        DEAL_II_DEPRECATED
+        virtual
+        void get_adiabatic_pressure_profile(std::vector<double> &values) const;
+
+        /**
+         * Like get_adiabatic_temperature_profile() but for the density.
+         *
+         * @deprecated: This function is deprecated.
+         * Use the function density() for specific positions instead.
+         */
+        DEAL_II_DEPRECATED
+        virtual
+        void get_adiabatic_density_profile(std::vector<double> &values) const;
+
+        /**
+         * Like get_adiabatic_temperature_profile() but for the density derivative.
+         *
+         * @deprecated: This function is deprecated.
+         * Use the function density_derivative() for specific positions instead.
+         */
+        DEAL_II_DEPRECATED
+        virtual
+        void get_adiabatic_density_derivative_profile(std::vector<double> &values) const;
+    };
+
+
+    /**
+     * Register a adiabatic conditions model so that it can be selected from
+     * the parameter file.
+     *
+     * @param name A string that identifies the adiabatic conditions model
+     * @param description A text description of what this model does and that
+     * will be listed in the documentation of the parameter file.
+     * @param declare_parameters_function A pointer to a function that can be
+     * used to declare the parameters that this model wants to read from input
+     * files.
+     * @param factory_function A pointer to a function that can create an
+     * object of this adiabatic conditions model.
+     *
+     * @ingroup AdiabaticConditions
+     */
+    template <int dim>
+    void
+    register_adiabatic_conditions (const std::string &name,
+                                   const std::string &description,
+                                   void (*declare_parameters_function) (ParameterHandler &),
+                                   std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+    /**
+     * A function that given the name of a model returns a pointer to an
+     * object that describes it. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The model object returned is not yet initialized and has not read its
+     * runtime parameters yet.
+     *
+     * @ingroup AdiabaticConditions
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_adiabatic_conditions (ParameterHandler &prm);
+
+
+    /**
+     * Declare the runtime parameters of the registered adiabatic conditions
+     * model.
+     *
+     * @ingroup AdiabaticConditions
+     */
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm);
+
+
+    /**
+     * For the current plugin subsystem, write a connection graph of all of the
+     * plugins we know about, in the format that the
+     * programs dot and neato understand. This allows for a visualization of
+     * how all of the plugins that ASPECT knows about are interconnected, and
+     * connect to other parts of the ASPECT code.
+     *
+     * @param output_stream The stream to write the output to.
+     */
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &output_stream);
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a adiabatic conditions model, register it with the functions that
+     * can declare their parameters and create these objects.
+     *
+     * @ingroup AdiabaticConditions
+     */
+#define ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(classname, name, description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::AdiabaticConditions::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::AdiabaticConditions::register_adiabatic_conditions<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::AdiabaticConditions::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::AdiabaticConditions::register_adiabatic_conditions<3>, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_composition/ascii_data.h.bak b/include/aspect/boundary_composition/ascii_data.h.bak
new file mode 100644
index 00000000000..cfa883422fe
--- /dev/null
+++ b/include/aspect/boundary_composition/ascii_data.h.bak
@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_composition_ascii_data_h
+#define _aspect_boundary_composition_ascii_data_h
+
+#include <aspect/boundary_composition/interface.h>
+
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements prescribed boundary conditions determined from
+     * a AsciiData input file.
+     *
+     * @ingroup BoundaryCompositions
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataBoundary<dim>::initialize;
+
+        /**
+         * A function that is called at the beginning of each time step. For
+         * the current plugin, this function loads the next data files if
+         * necessary and outputs a warning if the end of the set of data files
+         * is reached.
+         */
+        void
+        update () override;
+
+        /**
+         * Return the boundary composition as a function of position. For the
+         * current class, this function returns value from the text files.
+         *
+         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
+         */
+        double
+        boundary_composition (const types::boundary_id boundary_indicator,
+                              const Point<dim> &position,
+                              const unsigned int compositional_field) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_composition/box.h.bak b/include/aspect/boundary_composition/box.h.bak
new file mode 100644
index 00000000000..3e5ea1f3a55
--- /dev/null
+++ b/include/aspect/boundary_composition/box.h.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_composition_box_h
+#define _aspect_boundary_composition_box_h
+
+#include <aspect/boundary_composition/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    /**
+     * A class that implements a composition boundary condition for a box
+     * geometry.
+     *
+     * @ingroup BoundaryCompositions
+     */
+    template <int dim>
+    class Box : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * This function returns user-defined constant compositions at the
+         * boundaries.
+         *
+         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
+         */
+        double boundary_composition (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position,
+                                     const unsigned int compositional_field) const override;
+
+        /**
+         * This function performs some basic sanity checks on the parameter
+         * values previously read from the input file.
+         */
+        void initialize () override;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary compositions.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The values of the various composition variables on each of the
+         * 2*dim boundaries of the box.
+         */
+        std::vector<double> composition_values[2*dim];
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_composition/function.h.bak b/include/aspect/boundary_composition/function.h.bak
new file mode 100644
index 00000000000..89040ac4563
--- /dev/null
+++ b/include/aspect/boundary_composition/function.h.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_composition_function_h
+#define _aspect_boundary_composition_function_h
+
+#include <aspect/boundary_composition/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements boundary composition based on a functional
+     * description provided in the input file.
+     *
+     * @ingroup BoundaryCompositions
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the boundary composition as a function of position and time.
+         *
+         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
+         */
+        double boundary_composition (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position,
+                                     const unsigned int compositional_field) const override;
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the boundary values will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        void update () override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the compositional fields.
+         */
+        std::unique_ptr<Functions::ParsedFunction<dim>> function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_composition/initial_composition.h.bak b/include/aspect/boundary_composition/initial_composition.h.bak
new file mode 100644
index 00000000000..a40fe81135d
--- /dev/null
+++ b/include/aspect/boundary_composition/initial_composition.h.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2013 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_composition_initial_composition_h
+#define _aspect_boundary_composition_initial_composition_h
+
+#include <aspect/initial_composition/interface.h>
+#include <aspect/boundary_composition/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    /**
+     * A class that implements a composition boundary condition for a
+     * spherical shell geometry in which the composition at the inner and
+     * outer surfaces (i.e. at the core-mantle and the
+     * mantle-lithosphere/atmosphere boundaries) are constant.
+     *
+     * @ingroup BoundaryCompositions
+     */
+    template <int dim>
+    class InitialComposition : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run.
+         *
+         * This specific function makes sure that the objects that describe
+         * initial conditions remain available throughout the run of the
+         * program.
+         */
+        void
+        initialize () override;
+
+        /**
+         * This function returns the boundary compositions that are defined
+         * by the initial conditions.
+         *
+         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
+         */
+        double boundary_composition (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position,
+                                     const unsigned int compositional_field) const override;
+
+        /**
+         * Return the minimal composition on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         */
+        virtual
+        double minimal_composition (const std::set<types::boundary_id> &fixed_boundary_ids) const;
+
+        /**
+         * Return the maximal composition on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         */
+        virtual
+        double maximal_composition (const std::set<types::boundary_id> &fixed_boundary_ids) const;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary compositions.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Compositions at the inner and outer boundaries.
+         */
+        double min_composition;
+        double max_composition;
+
+        /**
+         * A shared pointer to the initial composition object
+         * that ensures that the current object can continue
+         * to access the initial composition object beyond the
+         * first time step.
+         */
+        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_composition/interface.h.bak b/include/aspect/boundary_composition/interface.h.bak
new file mode 100644
index 00000000000..1d3e2213ad8
--- /dev/null
+++ b/include/aspect/boundary_composition/interface.h.bak
@@ -0,0 +1,323 @@
+/*
+  Copyright (C) 2013 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_composition_interface_h
+#define _aspect_boundary_composition_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/distributed/tria.h>
+
+#include <boost/core/demangle.hpp>
+#include <typeinfo>
+
+
+namespace aspect
+{
+  /**
+   * A namespace for the definition of things that have to do with describing
+   * the boundary values for the composition.
+   *
+   * @ingroup BoundaryCompositions
+   */
+  namespace BoundaryComposition
+  {
+    using namespace dealii;
+
+    /**
+     * Base class for classes that describe composition boundary values.
+     *
+     * @ingroup BoundaryCompositions
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Return the composition that is to hold at a particular position on
+         * the boundary of the domain.
+         *
+         * @param boundary_indicator The boundary indicator of the part of the
+         * boundary of the domain on which the point is located at which we
+         * are requesting the composition.
+         * @param position The position of the point at which we ask for the
+         * composition.
+         * @param compositional_field The index of the compositional field
+         * between 0 and @p parameters.n_compositional_fields.
+         * @return Boundary value of the compositional field @p
+         * compositional_field at the position @p position.
+         */
+        virtual
+        double
+        boundary_composition (const types::boundary_id boundary_indicator,
+                              const Point<dim> &position,
+                              const unsigned int compositional_field) const = 0;
+    };
+
+    /**
+     * A class that manages all boundary composition objects.
+     *
+     * @ingroup BoundaryCompositions
+     */
+    template <int dim>
+    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Destructor. Made virtual since this class has virtual member
+         * functions.
+         */
+        ~Manager () override;
+
+        /**
+         * A function that is called at the beginning of each time step and
+         * calls the corresponding functions of all created plugins.
+         *
+         * The point of this function is to allow complex boundary composition
+         * models to do an initialization step once at the beginning of each
+         * time step. An example would be a model that needs to call an
+         * external program to compute the composition change at a boundary.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters of all known boundary composition plugins, as
+         * well as the ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which boundary composition objects will be created;
+         * then let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * A function that calls the boundary_composition functions of all the
+         * individual boundary composition objects and uses the stored operators
+         * to combine them.
+         */
+        double
+        boundary_composition (const types::boundary_id boundary_indicator,
+                              const Point<dim> &position,
+                              const unsigned int compositional_field) const;
+
+        /**
+         * A function that is used to register boundary composition objects in such
+         * a way that the Manager can deal with all of them without having to
+         * know them by name. This allows the files in which individual
+         * plugins are implemented to register these plugins, rather than also
+         * having to modify the Manager class by adding the new boundary
+         * composition plugin class.
+         *
+         * @param name A string that identifies the boundary composition model
+         * @param description A text description of what this model does and that
+         * will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that can be
+         * used to declare the parameters that this boundary composition model
+         * wants to read from input files.
+         * @param factory_function A pointer to a function that can create an
+         * object of this boundary composition model.
+         */
+        static
+        void
+        register_boundary_composition (const std::string &name,
+                                       const std::string &description,
+                                       void (*declare_parameters_function) (ParameterHandler &),
+                                       std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+
+        /**
+         * Return a list of names of all boundary composition models currently
+         * used in the computation, as specified in the input file.
+         */
+        const std::vector<std::string> &
+        get_active_boundary_composition_names () const;
+
+        /**
+         * Return a list of pointers to all boundary composition models
+         * currently used in the computation, as specified in the input file.
+         */
+        const std::list<std::unique_ptr<Interface<dim>>> &
+        get_active_boundary_composition_conditions () const;
+
+        /**
+         * Go through the list of all boundary composition models that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename BoundaryCompositionType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryCompositionType>::value>>
+        bool
+        has_matching_boundary_composition_model () const;
+
+        /**
+         * Go through the list of all boundary composition models that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no boundary composition model is active that matches the given type,
+         * throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename BoundaryCompositionType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryCompositionType>::value>>
+        const BoundaryCompositionType &
+        get_matching_boundary_composition_model () const;
+
+        /*
+         * Return a set of boundary indicators for which boundary
+         * compositions are prescribed.
+         */
+        const std::set<types::boundary_id> &
+        get_fixed_composition_boundary_indicators() const;
+
+        /*
+         * Return whether Dirichlet boundary conditions will be applied
+         * on parts of the boundaries where material flows out.
+         */
+        bool
+        allows_fixed_composition_on_outflow_boundaries() const;
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcBoundaryCompositionNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered boundary composition objects.");
+      private:
+        /**
+         * A list of names of boundary composition objects that have been requested
+         * in the parameter file.
+         */
+        std::vector<std::string> model_names;
+
+        /**
+         * A list of enums of boundary composition operators that have been
+         * requested in the parameter file. Each name is associated
+         * with a model_name, and is used to modify the composition
+         * boundary with the values from the current plugin.
+         */
+        std::vector<aspect::Utilities::Operator> model_operators;
+
+        /**
+         * A set of boundary ids on which the boundary_composition_objects
+         * will be applied.
+         */
+        std::set<types::boundary_id> fixed_composition_boundary_indicators;
+
+        /**
+         * Whether we allow the composition to be fixed on parts of the boundary
+         * where material flows out of the domain.
+         */
+        bool allow_fixed_composition_on_outflow_boundaries;
+    };
+
+
+
+    template <int dim>
+    template <typename BoundaryCompositionType, typename>
+    inline
+    bool
+    Manager<dim>::has_matching_boundary_composition_model () const
+    {
+      return this->template has_matching_plugin_object<BoundaryCompositionType>();
+    }
+
+
+
+    template <int dim>
+    template <typename BoundaryCompositionType, typename>
+    inline
+    const BoundaryCompositionType &
+    Manager<dim>::get_matching_boundary_composition_model () const
+    {
+      return this->template get_matching_plugin_object<BoundaryCompositionType>();
+    }
+
+
+
+    /**
+     * Return a string that consists of the names of boundary composition models that can
+     * be selected. These names are separated by a vertical line '|' so
+     * that the string can be an input to the deal.II classes
+     * Patterns::Selection or Patterns::MultipleSelection.
+     */
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ();
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a boundary composition model, register it with the functions that
+     * can declare their parameters and create these objects.
+     *
+     * @ingroup BoundaryCompositions
+     */
+#define ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(classname, name, description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryComposition::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::BoundaryComposition::Manager<2>::register_boundary_composition, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryComposition::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::BoundaryComposition::Manager<3>::register_boundary_composition, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_composition/spherical_constant.h.bak b/include/aspect/boundary_composition/spherical_constant.h.bak
new file mode 100644
index 00000000000..f43e75347fc
--- /dev/null
+++ b/include/aspect/boundary_composition/spherical_constant.h.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_composition_spherical_constant_h
+#define _aspect_boundary_composition_spherical_constant_h
+
+#include <aspect/boundary_composition/interface.h>
+
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    /**
+     * A class that implements a composition boundary condition for a
+     * spherical shell geometry in which the composition at the inner and
+     * outer surfaces (i.e. at the core-mantle and the
+     * mantle-lithosphere/atmosphere boundaries) are constant.
+     * This class works for the sphere, spherical shell,
+     * chunk and ellipsoidal chunk geometries.
+     *
+     * @ingroup BoundaryCompositions
+     */
+    template <int dim>
+    class SphericalConstant : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialize some variables.
+        */
+        void
+        initialize() override;
+
+        /**
+         * This function returns the constant compositions read from the
+         * parameter file for the inner and outer boundaries.
+         *
+         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
+         */
+        double boundary_composition (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position,
+                                     const unsigned int compositional_field) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary compositions.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Compositions at the inner and outer boundaries.
+         */
+        std::vector<double> inner_composition;
+        std::vector<double> outer_composition;
+
+        /**
+         * Boundary indicators for the inner and outer boundaries.
+         */
+        types::boundary_id inner_boundary_indicator;
+        types::boundary_id outer_boundary_indicator;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_composition/two_merged_boxes.h.bak b/include/aspect/boundary_composition/two_merged_boxes.h.bak
new file mode 100644
index 00000000000..2044061e5b2
--- /dev/null
+++ b/include/aspect/boundary_composition/two_merged_boxes.h.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_composition_two_merged_boxes_h
+#define _aspect_boundary_composition_two_merged_boxes_h
+
+#include <aspect/boundary_composition/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    /**
+     * A class that implements a composition boundary condition for a
+     * box geometry with additional boundary indicators for the
+     * lithospheric part of the left and right (and front and back in 3D) boundaries.
+     *
+     * @ingroup BoundaryCompositions
+     */
+    template <int dim>
+    class TwoMergedBoxes : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * This function returns constant compositions at the boundaries.
+         *
+         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
+         */
+        double boundary_composition (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position,
+                                     const unsigned int compositional_field) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary compositions.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * This function performs some basic sanity checks on the parameter
+         * values previously read from the input file.
+         */
+        void initialize () override;
+
+      private:
+        /**
+         * The values of the various composition variables on each of the
+         * 2*dim+2*(dim-1) boundaries of the box.
+         */
+        std::vector<double> composition_values[2*dim+2*(dim-1)];
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_fluid_pressure/density.h.bak b/include/aspect/boundary_fluid_pressure/density.h.bak
new file mode 100644
index 00000000000..49df8a34b65
--- /dev/null
+++ b/include/aspect/boundary_fluid_pressure/density.h.bak
@@ -0,0 +1,92 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_fluid_pressure_density_h
+#define _aspect_boundary_fluid_pressure_density_h
+
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace BoundaryFluidPressure
+  {
+    /**
+     * A class that implements simple fluid pressure boundary conditions
+     * based on the fluid or solid density from the material model.
+     *
+     * The fluid pressure gradient can either be set to
+     * $\rho_s \textbf{g}$ (solid density times gravity) or to
+     * $\rho_f \textbf{g}$ (fluid density times gravity).
+     *
+     * @ingroup BoundaryFluidPressures
+     */
+    template <int dim>
+    class Density : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * @copydoc Interface::fluid_pressure_gradient
+         */
+        void fluid_pressure_gradient (
+          const types::boundary_id boundary_indicator,
+          const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+          const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+          const std::vector<Tensor<1,dim>> &normal_vectors,
+          std::vector<double> &fluid_pressure_gradient_outputs
+        ) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Identify which density to use to compute the fluid pressure
+         * gradient at the model boundary.
+         */
+        struct DensityFormulation
+        {
+          enum Kind
+          {
+            solid_density,
+            fluid_density,
+            average_density
+          };
+        };
+
+        typename DensityFormulation::Kind density_formulation;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_fluid_pressure/interface.h.bak b/include/aspect/boundary_fluid_pressure/interface.h.bak
new file mode 100644
index 00000000000..0ef7bc96a95
--- /dev/null
+++ b/include/aspect/boundary_fluid_pressure/interface.h.bak
@@ -0,0 +1,166 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_fluid_pressure_interface_h
+#define _aspect_boundary_fluid_pressure_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/material_model/interface.h>
+
+namespace aspect
+{
+  /**
+   * A namespace for the definition of things that have to do with describing
+   * the boundary values for fluid pressure for computations with melt
+   * transport.
+   *
+   * @ingroup BoundaryFluidPressures
+   */
+  namespace BoundaryFluidPressure
+  {
+    using namespace dealii;
+
+    /**
+     * Base class
+     *
+     * @ingroup BoundaryFluidPressures
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Compute the component of the gradient of the fluid pressure
+         * in the direction normal to a boundary for a list of quadrature
+         * points.
+         *
+         * The return value can typically contain @p material_model_outputs.fluid_densities[q]
+         * or @p material_model_outputs.densities[q], multiplied by the gravity vector
+         * and dotted with the normal.
+         * If the solid density is used, fluid is only flowing in or out due to differences in
+         * dynamic pressure, if the fluid density is used, melt flows in with the same velocity
+         * as inflowing solid material.
+         *
+         * @param boundary_indicator The boundary indicator of the part of the
+         * boundary of the domain on which the point is located at which we
+         * are requesting the fluid pressure gradients.
+         * @param material_model_inputs The material property inputs.
+         * @param material_model_outputs The material property outputs.
+         * @param normal_vectors A normal vector for each point.
+         * @param fluid_pressure_gradient_outputs Result to be filled.
+         */
+        virtual
+        void fluid_pressure_gradient (
+          const types::boundary_id boundary_indicator,
+          const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+          const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+          const std::vector<Tensor<1,dim>> &normal_vectors,
+          std::vector<double> &fluid_pressure_gradient_outputs
+        ) const = 0;
+    };
+
+
+    /**
+     * Register a fluid pressure boundary model so that it can be selected from
+     * the parameter file.
+     *
+     * @param name A string that identifies the fluid pressure boundary model
+     * @param description A text description of what this model does and that
+     * will be listed in the documentation of the parameter file.
+     * @param declare_parameters_function A pointer to a function that can be
+     * used to declare the parameters that this fluid pressure boundary model
+     * wants to read from input files.
+     * @param factory_function A pointer to a function that can create an
+     * object of this fluid pressure boundary model.
+     *
+     * @ingroup BoundaryFluidPressures
+     */
+    template <int dim>
+    void
+    register_boundary_fluid_pressure (const std::string &name,
+                                      const std::string &description,
+                                      void (*declare_parameters_function) (ParameterHandler &),
+                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+    /**
+     * A function that given the name of a model returns a pointer to an
+     * object that describes it. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The model object returned is not yet initialized and has not
+     * read its runtime parameters yet.
+     *
+     * @ingroup BoundaryFluidPressures
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_boundary_fluid_pressure (ParameterHandler &prm);
+
+
+    /**
+     * Declare the runtime parameters of the registered fluid pressure boundary
+     * models.
+     *
+     * @ingroup BoundaryFluidPressures
+     */
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm);
+
+
+    /**
+     * For the current plugin subsystem, write a connection graph of all of the
+     * plugins we know about, in the format that the
+     * programs dot and neato understand. This allows for a visualization of
+     * how all of the plugins that ASPECT knows about are interconnected, and
+     * connect to other parts of the ASPECT code.
+     *
+     * @param output_stream The stream to write the output to.
+     */
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &output_stream);
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a fluid pressure boundary model, register it with the functions that
+     * can declare their parameters and create these objects.
+     *
+     * @ingroup BoundaryFluidPressures
+     */
+#define ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(classname, name, description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryFluidPressure::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::BoundaryFluidPressure::register_boundary_fluid_pressure<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryFluidPressure::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::BoundaryFluidPressure::register_boundary_fluid_pressure<3>, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_heat_flux/function.h.bak b/include/aspect/boundary_heat_flux/function.h.bak
new file mode 100644
index 00000000000..ee10be8d535
--- /dev/null
+++ b/include/aspect/boundary_heat_flux/function.h.bak
@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_heat_flux_function_h
+#define _aspect_boundary_heat_flux_function_h
+
+#include <aspect/boundary_heat_flux/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace BoundaryHeatFlux
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements heat flux boundary conditions based on a
+     * functional description provided in the input file.
+     *
+     * @ingroup BoundaryHeatFlux
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the boundary heat flux as a function of position.
+         */
+        std::vector<Tensor<1,dim>>
+        heat_flux (const types::boundary_id boundary_indicator,
+                   const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                   const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                   const std::vector<Tensor<1,dim>> &normal_vectors) const override;
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the boundary values will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        void update () override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the boundary heat flux.
+         */
+        Functions::ParsedFunction<dim> boundary_heat_flux_function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_heat_flux/interface.h.bak b/include/aspect/boundary_heat_flux/interface.h.bak
new file mode 100644
index 00000000000..79fe574da6f
--- /dev/null
+++ b/include/aspect/boundary_heat_flux/interface.h.bak
@@ -0,0 +1,158 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_heat_flux_interface_h
+#define _aspect_boundary_heat_flux_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/material_model/interface.h>
+
+namespace aspect
+{
+  /**
+   * A namespace for the definition of things that have to do with describing
+   * the boundary heat flux values.
+   *
+   * @ingroup BoundaryHeatFlux
+   */
+  namespace BoundaryHeatFlux
+  {
+    using namespace dealii;
+
+    /**
+     * Base class
+     *
+     * @ingroup BoundaryHeatFlux
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Compute the heat flux for a list of quadrature points.
+         *
+         * The return value would typically be computed as the product of the thermal
+         * conductivity @p material_model_outputs.thermal_conductivities[q] and the
+         * temperature gradient at the boundary.
+         *
+         * @param boundary_indicator The boundary indicator of the part of the
+         * boundary of the domain on which the point is located at which we
+         * are requesting the fluid pressure gradients.
+         * @param material_model_inputs The material property inputs.
+         * @param material_model_outputs The material property outputs.
+         * @param normal_vectors The normal vector at each quadrature point.
+         * @return A vector of heat flux vectors at the evaluation points.
+         */
+        virtual
+        std::vector<Tensor<1,dim>>
+        heat_flux (const types::boundary_id boundary_indicator,
+                   const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                   const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                   const std::vector<Tensor<1,dim>> &normal_vectors) const = 0;
+    };
+
+
+    /**
+     * Register a boundary heat flux model so that it can be selected from
+     * the parameter file.
+     *
+     * @param name A string that identifies the fluid pressure boundary model
+     * @param description A text description of what this model does and that
+     * will be listed in the documentation of the parameter file.
+     * @param declare_parameters_function A pointer to a function that can be
+     * used to declare the parameters that this boundary heat flux model
+     * wants to read from input files.
+     * @param factory_function A pointer to a function that can create an
+     * object of this boundary heat flux model.
+     *
+     * @ingroup BoundaryHeatFlux
+     */
+    template <int dim>
+    void
+    register_boundary_heat_flux (const std::string &name,
+                                 const std::string &description,
+                                 void (*declare_parameters_function) (ParameterHandler &),
+                                 std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+    /**
+     * A function that given the name of a model returns a pointer to an
+     * object that describes it. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The model object returned is not yet initialized and has not
+     * read its runtime parameters yet.
+     *
+     * @ingroup BoundaryHeatFlux
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_boundary_heat_flux (ParameterHandler &prm);
+
+
+    /**
+     * Declare the runtime parameters of the registered boundary heat flux
+     * models.
+     *
+     * @ingroup BoundaryHeatFlux
+     */
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm);
+
+
+    /**
+     * For the current plugin subsystem, write a connection graph of all of the
+     * plugins we know about, in the format that the
+     * programs dot and neato understand. This allows for a visualization of
+     * how all of the plugins that ASPECT knows about are interconnected, and
+     * connect to other parts of the ASPECT code.
+     *
+     * @param output_stream The stream to write the output to.
+     */
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &output_stream);
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a boundary heat flux model, register it with the functions that
+     * can declare their parameters and create these objects.
+     *
+     * @ingroup BoundaryHeatFlux
+     */
+#define ASPECT_REGISTER_BOUNDARY_HEAT_FLUX_MODEL(classname, name, description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_BOUNDARY_HEAT_FLUX_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryHeatFlux::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::BoundaryHeatFlux::register_boundary_heat_flux<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryHeatFlux::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::BoundaryHeatFlux::register_boundary_heat_flux<3>, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_temperature/ascii_data.h.bak b/include/aspect/boundary_temperature/ascii_data.h.bak
new file mode 100644
index 00000000000..a71860d79b3
--- /dev/null
+++ b/include/aspect/boundary_temperature/ascii_data.h.bak
@@ -0,0 +1,115 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_temperature_ascii_data_h
+#define _aspect_boundary_temperature_ascii_data_h
+
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements prescribed data boundary conditions determined
+     * from a AsciiData input file.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataBoundary<dim>::initialize;
+
+        /**
+         * A function that is called at the beginning of each time step. For
+         * the current plugin, this function loads the next data files if
+         * necessary and outputs a warning if the end of the set of data files
+         * is reached.
+         */
+        void update () override;
+
+        /**
+         * Return the boundary temperature as a function of position. For the
+         * current class, this function returns value from the text files.
+         *
+         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
+         */
+        double
+        boundary_temperature (const types::boundary_id boundary_indicator,
+                              const Point<dim> &position) const override;
+
+        /**
+         * Return the minimal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Return the maximal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_temperature/box.h.bak b/include/aspect/boundary_temperature/box.h.bak
new file mode 100644
index 00000000000..425c98d3fbf
--- /dev/null
+++ b/include/aspect/boundary_temperature/box.h.bak
@@ -0,0 +1,91 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_temperature_box_h
+#define _aspect_boundary_temperature_box_h
+
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    /**
+     * A class that implements a temperature boundary condition for a box
+     * geometry.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class Box : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * This function returns user-defined constant temperatures at the
+         * boundaries.
+         *
+         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
+         */
+        double boundary_temperature (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position) const override;
+
+        /**
+         * Return the minimal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Return the maximal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary temperatures.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        double temperature_[2*dim];
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_temperature/constant.h.bak b/include/aspect/boundary_temperature/constant.h.bak
new file mode 100644
index 00000000000..36afaeedd3e
--- /dev/null
+++ b/include/aspect/boundary_temperature/constant.h.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_temperature_constant_h
+#define _aspect_boundary_temperature_constant_h
+
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <map>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    /**
+     * A class that implements a temperature boundary condition for an
+     * arbitrary geometry, where it returns a constant value for a given
+     * boundary indicator. Takes an ordered list of temperatures, where the
+     * position in the list corresponds to the indicator for that temperature.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class Constant : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * This function returns user-defined constant temperatures at the
+         * boundaries of arbitrary geometries.
+         *
+         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
+         */
+        double boundary_temperature (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position) const override;
+
+        /**
+         * Return the minimal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Return the maximal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary temperatures.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Temperatures at the boundaries.
+         */
+        std::map<types::boundary_id, double> boundary_temperatures;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_temperature/dynamic_core.h.bak b/include/aspect/boundary_temperature/dynamic_core.h.bak
new file mode 100644
index 00000000000..ff27245121d
--- /dev/null
+++ b/include/aspect/boundary_temperature/dynamic_core.h.bak
@@ -0,0 +1,517 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_boundary_temperature_dynamic_core_h
+#define _aspect_boundary_temperature_dynamic_core_h
+
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+
+    /**
+     * Data structure for core energy balance calculation
+     */
+    namespace internal
+    {
+      struct CoreData
+      {
+        /**
+         * Energy for specific heat, radioactive heating, gravitational contribution,
+         * adiabatic contribution, and latent heat. These variables are updated each time step.
+         */
+        double Qs,Qr,Qg,Qk,Ql;
+
+        /**
+         * Entropy for specific heat, radioactive heating, gravitational contribution,
+         * adiabatic contribution, latent heat, and heat solution. These entropy terms are not
+         * used for solving the core evolution. However, the total excess entropy
+         * (dE = Es*dT/dt+Er+El*dR/dt+Eg*dR/dt+Eh*dR/dt-Ek) is useful to determine the core is active or not.
+         * For dE>0, the core is likely to be active and generating magnetic field. These variables are updated each time step as well.
+         */
+        double Es,Er,Eg,Ek,El,Eh;
+
+        /**
+         * Parameters for core evolution
+         * Ri     inner core radius
+         * Ti     core-mantle boundary (CMB) temperature
+         * Xi     light component concentration in liquid core
+         */
+        double Ri,Ti,Xi;
+
+        /**
+         * Core-mantle boundary heat flux (Q) and core radioactive heating rate (H)
+         */
+        double Q,H;
+
+        /**
+         * Time step for core energy balance solver
+         */
+        double dt;
+
+        /**
+         * The changing rate of inner core radius, CMB temperature, and light component
+         * concentration.
+         */
+        double dR_dt,dT_dt,dX_dt;
+
+        /**
+         * Other energy source into the core
+         */
+        double Q_OES;
+
+        bool is_initialized;
+      };
+    }
+
+
+    /**
+     * A class that implements a temperature boundary condition for a spherical
+     * shell geometry in which the temperature at the outer surfaces are constant
+     * and the core-mantle boundaries (CMB) temperature is calculated by core energy balance.
+     * The formulation of the core energy balance is from \cite NPB+04 .
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class DynamicCore : public Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor
+         */
+        DynamicCore();
+
+        /**
+         * Return the temperature that is to hold at a particular location on the
+         * boundary of the domain. This function returns the temperatures
+         * at the inner and outer boundaries.
+         *
+         * @param boundary_indicator The boundary indicator of the part of the boundary
+         *   of the domain on which the point is located at which we are requesting the
+         *   temperature.
+         * @param location The location of the point at which we ask for the temperature.
+         */
+        double  boundary_temperature (const types::boundary_id            boundary_indicator,
+                                      const Point<dim>                    &location) const override;
+
+        /**
+         * Return the minimal temperature on that part of the boundary
+         * on which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Return the maximal temperature on that part of the boundary
+         * on which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         * This class declares the inner and outer boundary temperatures.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter
+         * file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * This function update the core-mantle boundary (CMB) temperature by
+         * the core energy balance solver using the core-mantle boundary heat flux.
+         */
+        void update() override;
+
+        /**
+         * Pass core data to other modules
+         */
+        const internal::CoreData &
+        get_core_data() const;
+
+        /**
+         * Check if other energy source in the core is in use. The 'other energy source' is used for external core energy source.
+         * For example if someone want to test the early lunar core powered by precession
+         * (Dwyer, C. A., et al. (2011). "A long-lived lunar dynamo driven by continuous mechanical stirring." Nature 479(7372): 212-214.)
+         */
+        bool
+        is_OES_used() const;
+
+
+      private:
+
+        /**
+         * Data for core energy balance
+         * it get updated each time step.
+         */
+        internal::CoreData core_data;
+
+        /**
+         * Temperature at the inner boundary.
+         */
+        double inner_temperature;
+
+        /**
+         * Temperatures at the outer boundaries.
+         */
+        double outer_temperature;
+
+        /**
+         * Initial CMB temperature changing rate
+         */
+        double init_dT_dt;
+
+        /**
+         * Initial inner core radius changing rate
+         */
+        double init_dR_dt;
+
+        /**
+         * Initial light composition changing rate
+         */
+        double init_dX_dt;
+
+        /**
+         * Flag for determining the initial call for update().
+         */
+        bool is_first_call;
+
+        /**
+         * Core radius
+         */
+        double Rc;
+
+        /**
+         * (Heat capacity) * density
+         */
+        double CpRho;
+
+        /**
+         * Initial light composition concentration
+         */
+        double X_init;
+
+        /**
+         * Partition coefficient of the light element
+         */
+        double Delta;
+
+        /**
+         * Gravitational acceleration
+         */
+        double g;
+
+        /**
+         * Pressure at the core mantle boundary
+         */
+        double P_CMB;
+
+        /**
+         * Pressure at the center of the core
+         */
+        double P_Core;
+
+        /**
+         * Parameters for core solidus following:
+         * if not dependent on composition
+         *   Tm(p)= Tm0*(1-Theta)*(1+Tm1*p+Tm2*p^2)
+         * if depend on composition X
+         *   Tm(p)= Tm0*(1-Theta*X)*(1+Tm1*p+Tm2*p^2)
+         */
+        double Tm0;
+        double Tm1;
+        double Tm2;
+        double Theta;
+        bool composition_dependency;
+
+        /**
+         * If using the Fe-FeS system solidus from Buono & Walker (2011) instead.
+         */
+        bool use_bw11;
+
+        //Variables for formulation of \cite NPB+04
+        /**
+         * Compressibility at zero pressure
+         */
+        double K0;
+
+        /**
+         * Thermal expansivity
+         */
+        double Alpha;
+
+        /**
+         * Density at zero pressure
+         */
+        double Rho_0;
+
+        /**
+         * Density at the center of the planet
+         */
+        double Rho_cen;
+
+        /**
+         * Latent heat of fusion
+         */
+        double Lh;
+
+        /**
+         * Heat of reaction
+         */
+        double Rh;
+
+        /**
+         * Compositional expansion coefficient
+         */
+        double Beta_c;
+
+        /**
+         * Heat conductivity of the core
+         */
+        double k_c;
+
+        /**
+         * Heat capacity
+         */
+        double Cp;
+
+        /**
+         * Number of radioheating element in core
+         */
+        unsigned int n_radioheating_elements;
+
+        /**
+         * Heating rates of different elements
+         */
+        std::vector<double> heating_rate;
+
+        /**
+         * Half life of different elements
+         */
+        std::vector<double> half_life;
+
+        /**
+         * Initial concentration of different elements
+         */
+        std::vector<double> initial_concentration;
+
+        /**
+         * Two length scales in \cite NPB+04 .
+         */
+        double L;
+        double D;
+
+        /**
+         * Mass of the core
+         */
+        double Mc;
+
+        /**
+         * Max iterations for the core energy balance solver.
+         */
+        int max_steps;
+
+        /**
+         * Temperature correction value for adiabatic
+         */
+        double dTa;
+
+        /**
+         * Other energy source into the core, e.g. the mechanical stirring of the moon.
+         */
+        std::string name_OES;
+        struct str_data_OES
+        {
+          double t;
+          double w;
+        };
+        std::vector<struct str_data_OES> data_OES;
+        void read_data_OES();
+        double get_OES(double t) const;
+
+
+
+        /**
+         * Solve core energy balance for each time step.
+         * When solving the change in core-mantle boundary temperature T, inner core radius R, and
+         *    light component (e.g. S, O, Si) composition X, the following relations has to be respected:
+         * 1. At the inner core boundary the adiabatic temperature should be equal to solidus temperature
+         * 2. The following energy production rate should be balanced in core:
+         *    Heat flux at core-mantle boundary         Q
+         *    Specific heat                             Qs*dT/dt
+         *    Radioactive heating                       Qr
+         *    Gravitational contribution                Qg*dR/dt
+         *    Latent heat                               Ql*dR/dt
+         *    So that         Q+Qs*dT/dt+Qr+Qg*dR/dt*Ql*dR/dt=0
+         * 3. The light component composition X depends on inner core radius (See function get_X() ),
+         *    and core solidus may dependent on X as well.
+         *    This becomes a small nonlinear problem. Directly iterate through the above three equations doesn't
+         *    converge well. Alternatively we solve the inner core radius by bisection method.
+         *    A single solution between fully liquid and fully solid core is expected. Otherwise this function will throw exception and terminate.
+         *
+         *    At Earth core condition, a inner core is forming at the center of the Earth and surrounded by a liquid outer core.
+         *    However, the core solidus is influenced by light components (e.g. S) and its slope is very closed to core adiabatic. So there is an alternative
+         *    scenario that the crystallization happens first at the core mantle boundary instead of at the center, which is called a 'snowing core'
+         *    (Stewart, A. J., et al. (2007). "Mars: a new core-crystallization regime." Science 316(5829): 1323-1325.). This also
+         *    provides a valid solution for the solver. So the returning bool is set to true for normal core, and false for 'snowing core'.
+         *    TODO: The current code is only able to treat normal core scenario, treating 'snowing core' scenario may be possible and could be added.
+         */
+        bool solve_time_step(double &X, double &T, double &R);
+
+        /**
+         * Compute the difference between solidus and adiabatic at inner
+         * core boundary for a given inner core radius.
+         */
+        double get_dT(double r) const;
+
+        /**
+         * Use energy balance to calculate core mantle boundary temperature
+         * with a given inner core radius.
+         */
+        double get_Tc(double r) const;
+
+        /**
+         * Get the solidus temperature at inner core boundary
+         * with a given inner core radius.
+         */
+        double get_Ts(double r) const;
+
+        /**
+         * Compute the core solidus at certain pressure
+         */
+        double get_solidus(double X,double p) const;
+
+        /**
+         * Get initial inner core radius with given initial core mantle temperature.
+         */
+        double get_initial_Ri(double T);
+
+        /**
+         * Get the light composition concentration in the outer core from given
+         * inner core radius r
+         */
+        double get_X(double r) const;
+
+        /**
+         * Compute the mass inside certain radius within the core_data.
+         */
+        double get_Mass(double r) const;
+
+        /**
+         * Calculate Sn(B,R), referring to \cite NPB+04 .
+         */
+        double fun_Sn(double B,double R,double n) const;
+
+        /**
+         * Calculate density at given r
+         */
+        double get_Rho(double r) const;
+
+        /**
+         * Calculate gravitational acceleration at given r
+         */
+        double get_g(double r) const;
+
+        /**
+         * Calculate the core temperature at given r
+         * Tc is the temperature at CMB
+         */
+        double get_T(double Tc, double r) const;
+
+        /**
+         * Calculate pressure at given r
+         */
+        double get_Pressure(double r) const;
+
+        /**
+         * Calculate the gravitational potential at given r
+         */
+        double get_gravity_potential(double r) const;
+
+        /**
+         * Calculate energy and entropy change rate factor (regarding the core
+         * cooling rated Tc/dt) Qs and Es with given core-mantle boundary (CMB)
+         * temperature Tc
+         */
+        void get_specific_heating(double Tc, double &Qs,double &Es);
+
+        /**
+         * Calculate energy and entropy change rate factor (regarding the
+         * radioactive heating rate H) Qr and Er with given CMB temperature Tc
+         */
+        void get_radio_heating(double Tc, double &Qr, double &Er);
+
+        /**
+         * Calculate energy and entropy change rate factor (regarding the inner core
+         * growth rate dR/dt) Qg and Eg with given Tc(CMB temperature), r(inner core
+         * radius), X(light composition concentration)
+         */
+        void get_gravity_heating(double Tc, double r,double X,double &Qg,double &Eg);
+
+        /**
+         * Calculate energy and entropy change rate factor (regarding the core
+         * cooling rate Tc/dt) Qk and Ek with given Tc(CMB temperature)
+         */
+        void get_adiabatic_heating(double Tc, double &Ek, double &Qk);
+
+        /**
+         * Calculate energy and entropy change rate factor (regarding the inner core
+         * growth rate dR/dt) Ql and El with given Tc(CMB temperature), r(inner core
+         * radius)
+         */
+        void get_latent_heating(double Tc, double r, double &El, double &Ql);
+
+        /**
+         * Calculate entropy of heat of solution Eh
+         */
+        void get_heat_solution(double Tc, double r, double X, double &Eh);
+
+        /**
+         * return radio heating rate at certain time
+         */
+        double get_radioheating_rate() const;
+
+        /**
+         * Update the data for core dynamic simulation, the data will be used
+         * in the next timestep and for postprocess.
+         */
+        void update_core_data();
+
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_temperature/function.h.bak b/include/aspect/boundary_temperature/function.h.bak
new file mode 100644
index 00000000000..d5bc2e49f84
--- /dev/null
+++ b/include/aspect/boundary_temperature/function.h.bak
@@ -0,0 +1,129 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_temperature_function_h
+#define _aspect_boundary_temperature_function_h
+
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements boundary temperature based on a functional
+     * description provided in the input file.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Function ();
+
+        /**
+         * Return the boundary temperature as a function of position and time.
+         *
+         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
+         */
+        double
+        boundary_temperature (const types::boundary_id boundary_indicator,
+                              const Point<dim> &position) const override;
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the boundary values will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        void update () override;
+
+        /**
+         * Return the minimal temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Return the maximal temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the temperature.
+         */
+        Functions::ParsedFunction<dim> boundary_temperature_function;
+
+        /**
+         * Temperatures at the inner and outer boundaries.
+         */
+        double min_temperature;
+        double max_temperature;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_temperature/initial_temperature.h.bak b/include/aspect/boundary_temperature/initial_temperature.h.bak
new file mode 100644
index 00000000000..2d6bf322ae3
--- /dev/null
+++ b/include/aspect/boundary_temperature/initial_temperature.h.bak
@@ -0,0 +1,115 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_temperature_initial_temperature_h
+#define _aspect_boundary_temperature_initial_temperature_h
+
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    /**
+     * A class that implements a temperature boundary condition for an
+     * arbitrary geometry in which the temperature at the boundaries are the
+     * same as in the initial conditions.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class InitialTemperature : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run.
+         *
+         * This specific function makes sure that the objects that describe
+         * initial conditions remain available throughout the run of the
+         * program.
+         */
+        void
+        initialize () override;
+
+        /**
+         * This function returns the boundary temperatures that are defined
+         * by the initial conditions.
+         *
+         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
+         */
+        double boundary_temperature (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position) const override;
+
+        /**
+         * Return the minimal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Return the maximal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary temperatures.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Temperatures at the inner and outer boundaries.
+         */
+        double min_temperature;
+        double max_temperature;
+
+        /**
+         * A shared pointer to the initial temperature object
+         * that ensures that the current object can continue
+         * to access the initial temperature object beyond the
+         * first time step.
+         */
+        std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_temperature/interface.h.bak b/include/aspect/boundary_temperature/interface.h.bak
new file mode 100644
index 00000000000..7b694b5f515
--- /dev/null
+++ b/include/aspect/boundary_temperature/interface.h.bak
@@ -0,0 +1,355 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_temperature_interface_h
+#define _aspect_boundary_temperature_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/distributed/tria.h>
+
+#include <boost/core/demangle.hpp>
+#include <typeinfo>
+
+
+namespace aspect
+{
+  template <int dim> class SimulatorAccess;
+
+  /**
+   * A namespace for the definition of things that have to do with describing
+   * the boundary values for the temperature.
+   *
+   * @ingroup BoundaryTemperatures
+   */
+  namespace BoundaryTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * Base class for classes that describe temperature boundary values.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Return the temperature that is to hold at a particular position on
+         * the boundary of the domain.
+         *
+         * @param boundary_indicator The boundary indicator of the part of the
+         * boundary of the domain on which the point is located at which we
+         * are requesting the temperature.
+         * @param position The position of the point at which we ask for the
+         * temperature.
+         *
+         * @return Boundary temperature at position @p position.
+         */
+        virtual
+        double boundary_temperature (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position) const = 0;
+
+        /**
+         * Return the minimal temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        virtual
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids
+                                    = std::set<types::boundary_id>()) const = 0;
+
+        /**
+         * Return the maximal temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        virtual
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids
+                                    = std::set<types::boundary_id>()) const = 0;
+    };
+
+
+    /**
+     * A class that manages all boundary temperature objects.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Destructor. Made virtual since this class has virtual member
+         * functions.
+         */
+        ~Manager () override;
+
+        /**
+         * A function that is called at the beginning of each time step and
+         * calls the corresponding functions of all created plugins.
+         *
+         * The point of this function is to allow complex boundary temperature
+         * models to do an initialization step once at the beginning of each
+         * time step. An example would be a model that needs to call an
+         * external program to compute the temperature change at a boundary.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters of all known boundary temperature plugins, as
+         * well as the ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which boundary temperature objects will be created;
+         * then let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * A function that calls the boundary_temperature functions of all the
+         * individual boundary temperature objects and uses the stored operators
+         * to combine them.
+         */
+        double
+        boundary_temperature (const types::boundary_id boundary_indicator,
+                              const Point<dim> &position) const;
+
+        /**
+         * Return the minimal temperature of all selected plugins on that
+         * part of the boundary on which Dirichlet conditions are posed.
+         */
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids
+                                    = std::set<types::boundary_id>()) const;
+
+        /**
+         * Return the maximal temperature of all selected plugins on that
+         * part of the boundary on which Dirichlet conditions are posed.
+         */
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids
+                                    = std::set<types::boundary_id>()) const;
+
+        /**
+         * A function that is used to register boundary temperature objects in such
+         * a way that the Manager can deal with all of them without having to
+         * know them by name. This allows the files in which individual
+         * plugins are implemented to register these plugins, rather than also
+         * having to modify the Manager class by adding the new boundary
+         * temperature plugin class.
+         *
+         * @param name A string that identifies the boundary temperature model
+         * @param description A text description of what this model does and that
+         * will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that can be
+         * used to declare the parameters that this boundary temperature model
+         * wants to read from input files.
+         * @param factory_function A pointer to a function that can create an
+         * object of this boundary temperature model.
+         */
+        static
+        void
+        register_boundary_temperature (const std::string &name,
+                                       const std::string &description,
+                                       void (*declare_parameters_function) (ParameterHandler &),
+                                       std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+
+        /**
+         * Return a list of names of all boundary temperature models currently
+         * used in the computation, as specified in the input file.
+         */
+        const std::vector<std::string> &
+        get_active_boundary_temperature_names () const;
+
+        /**
+         * Return a list of pointers to all boundary temperature models
+         * currently used in the computation, as specified in the input file.
+         */
+        const std::list<std::unique_ptr<Interface<dim>>> &
+        get_active_boundary_temperature_conditions () const;
+
+        /**
+         * Go through the list of all boundary temperature models that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename BoundaryTemperatureType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryTemperatureType>::value>>
+        bool
+        has_matching_boundary_temperature_model () const;
+
+        /**
+         * Go through the list of all boundary temperature models that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no boundary temperature model is active that matches the given type,
+         * throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename BoundaryTemperatureType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryTemperatureType>::value>>
+        const BoundaryTemperatureType &
+        get_matching_boundary_temperature_model () const;
+
+        /*
+         * Return a set of boundary indicators for which boundary
+         * temperatures are prescribed.
+         */
+        const std::set<types::boundary_id> &
+        get_fixed_temperature_boundary_indicators() const;
+
+        /*
+         * Return whether Dirichlet boundary conditions will be applied
+         * on parts of the boundaries where material flows out.
+         */
+        bool
+        allows_fixed_temperature_on_outflow_boundaries() const;
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcBoundaryTemperatureNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered boundary temperature objects.");
+      private:
+        /**
+         * A list of names of boundary temperature objects that have been requested
+         * in the parameter file.
+         */
+        std::vector<std::string> model_names;
+
+        /**
+         * A list of enums of boundary temperature operators that have been
+         * requested in the parameter file. Each name is associated
+         * with a model_name, and is used to modify the temperature
+         * boundary with the values from the current plugin.
+         */
+        std::vector<aspect::Utilities::Operator> model_operators;
+
+        /**
+         * A set of boundary ids on which the boundary_temperature_objects
+         * will be applied.
+         */
+        std::set<types::boundary_id> fixed_temperature_boundary_indicators;
+
+        /**
+         * Whether we allow the temperature to be fixed on parts of the boundary
+         * where material flows out of the domain.
+         */
+        bool allow_fixed_temperature_on_outflow_boundaries;
+    };
+
+
+
+    template <int dim>
+    template <typename BoundaryTemperatureType, typename>
+    inline
+    bool
+    Manager<dim>::has_matching_boundary_temperature_model () const
+    {
+      return this->template has_matching_plugin_object<BoundaryTemperatureType>();
+    }
+
+
+    template <int dim>
+    template <typename BoundaryTemperatureType, typename>
+    inline
+    const BoundaryTemperatureType &
+    Manager<dim>::get_matching_boundary_temperature_model () const
+    {
+      return this->template get_matching_plugin_object<BoundaryTemperatureType>();
+    }
+
+
+    /**
+     * Return a string that consists of the names of boundary temperature models that can
+     * be selected. These names are separated by a vertical line '|' so
+     * that the string can be an input to the deal.II classes
+     * Patterns::Selection or Patterns::MultipleSelection.
+     */
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ();
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a boundary temperature model, register it with the functions that
+     * can declare their parameters and create these objects.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+#define ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(classname, name, description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryTemperature::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::BoundaryTemperature::Manager<2>::register_boundary_temperature, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryTemperature::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::BoundaryTemperature::Manager<3>::register_boundary_temperature, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_temperature/spherical_constant.h.bak b/include/aspect/boundary_temperature/spherical_constant.h.bak
new file mode 100644
index 00000000000..5ff209a774f
--- /dev/null
+++ b/include/aspect/boundary_temperature/spherical_constant.h.bak
@@ -0,0 +1,109 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_temperature_spherical_constant_h
+#define _aspect_boundary_temperature_spherical_constant_h
+
+#include <aspect/boundary_temperature/interface.h>
+
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    /**
+     * A class that implements a temperature boundary condition for a
+     * spherical shell geometry in which the temperature at the inner and
+     * outer surfaces (i.e. at the core-mantle and the
+     * mantle-lithosphere/atmosphere boundaries) are constant.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class SphericalConstant : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+        * Initialize some variables.
+        */
+        void
+        initialize() override;
+
+        /**
+         * This function returns the constant compositions read from the
+         * parameter file for the inner and outer boundaries.
+         *
+         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
+         */
+        double boundary_temperature (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position) const override;
+
+        /**
+         * Return the minimal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Return the maximal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary temperatures.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Temperatures at the inner and outer boundaries.
+         */
+        double inner_temperature;
+        double outer_temperature;
+
+        /**
+         * The boundary indicator for the inner and outer boundaries.
+         */
+        types::boundary_id inner_boundary_indicator;
+        types::boundary_id outer_boundary_indicator;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_temperature/two_merged_boxes.h.bak b/include/aspect/boundary_temperature/two_merged_boxes.h.bak
new file mode 100644
index 00000000000..bbbac87ca35
--- /dev/null
+++ b/include/aspect/boundary_temperature/two_merged_boxes.h.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_temperature_two_merged_boxes_h
+#define _aspect_boundary_temperature_two_merged_boxes_h
+
+#include <aspect/boundary_temperature/interface.h>
+
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    /**
+     * A class that implements a temperature boundary condition for a
+     * box geometry with additional boundary indicators for the
+     * lithospheric part of left and right (and front and back in 3D) boundaries.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class TwoMergedBoxes : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * This function returns constant compositions at the boundaries.
+         *
+         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
+         */
+        double boundary_temperature (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position) const override;
+
+        /**
+         * Return the minimal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Return the maximal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary temperatures.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The values of the various temperature variables on each of the
+         * 2*dim+2*(dim-1) boundaries of the box.
+         */
+        double temperature_values[2*dim+2*(dim-1)];
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_traction/ascii_data.h.bak b/include/aspect/boundary_traction/ascii_data.h.bak
new file mode 100644
index 00000000000..f6a3b095bd3
--- /dev/null
+++ b/include/aspect/boundary_traction/ascii_data.h.bak
@@ -0,0 +1,105 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_traction_ascii_data_h
+#define _aspect_boundary_traction_ascii_data_h
+
+#include <aspect/boundary_traction/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements prescribed traction boundary conditions determined
+     * from pressures given in an AsciiData input file.
+     *
+     * @ingroup BoundaryTractions
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataBoundary<dim>::initialize;
+
+        /**
+         * Return the boundary traction as a function of position. The
+         * (outward) normal vector to the domain is also provided as
+         * a second argument.
+         */
+        Tensor<1,dim>
+        boundary_traction (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position,
+                           const Tensor<1,dim> &normal_vector) const override;
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the boundary values will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        std::set<types::boundary_id> boundary_ids;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_traction/function.h.bak b/include/aspect/boundary_traction/function.h.bak
new file mode 100644
index 00000000000..bcb2648bd54
--- /dev/null
+++ b/include/aspect/boundary_traction/function.h.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_traction_function_h
+#define _aspect_boundary_traction_function_h
+
+#include <aspect/boundary_traction/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements traction boundary conditions based on a
+     * functional description provided in the input file.
+     *
+     * @ingroup BoundaryTractions
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Function ();
+
+        /**
+         * Return the boundary traction as a function of position. The
+         * (outward) normal vector to the domain is also provided as
+         * a second argument.
+         */
+        Tensor<1,dim>
+        boundary_traction (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position,
+                           const Tensor<1,dim> &normal_vector) const override;
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the boundary values will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the components of the traction.
+         */
+        Functions::ParsedFunction<dim> boundary_traction_function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+
+        /**
+         * Whether to specify traction in x, y, z components, or
+         * r, phi, theta components.
+         */
+        bool use_spherical_unit_vectors;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_traction/initial_lithostatic_pressure.h.bak b/include/aspect/boundary_traction/initial_lithostatic_pressure.h.bak
new file mode 100644
index 00000000000..e68df505956
--- /dev/null
+++ b/include/aspect/boundary_traction/initial_lithostatic_pressure.h.bak
@@ -0,0 +1,126 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_traction_initial_lithospheric_pressure_h
+#define _aspect_boundary_traction_initial_lithospheric_pressure_h
+
+#include <aspect/boundary_traction/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements traction boundary conditions by prescribing
+     * the lithostatic pressure as the normal traction component.
+     *
+     * @ingroup BoundaryTractions
+     */
+    template <int dim>
+    class InitialLithostaticPressure : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Initialization function. Because this function is called after
+         * initializing the SimulatorAccess, all of the necessary information
+         * is available to calculate the pressure profile based on the initial
+         * temperature and pressure conditions.
+         */
+        void initialize () override;
+
+
+        /**
+         * Return the boundary traction as a function of position. The
+         * (outward) normal vector to the domain is also provided as
+         * a second argument.
+         */
+        Tensor<1,dim>
+        boundary_traction (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position,
+                           const Tensor<1,dim> &normal_vector) const override;
+
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * The number of integration points.
+         */
+        unsigned int n_points;
+
+        /**
+         * Depth interval spacing between each two data points in the pressure profile.
+         */
+        double delta_z;
+
+        /*
+         * The user-specified point where to calculate the pressure profile.
+         * The vertical coordinate/radius is ignored.
+         */
+        Point<dim> representative_point;
+
+        /**
+         * The computed lithostatic pressure profile.
+         */
+        std::vector<double> pressure;
+
+        /**
+         * Return the lithostatic pressure at a given point of the domain
+         * based on depth interpolation between computed pressure values.
+         */
+        double interpolate_pressure (const Point<dim> &p) const;
+
+        /**
+         * The id of the bottom boundary.
+         */
+        types::boundary_id bottom_boundary_id;
+
+        /**
+         * Whether or not to prescribe the
+         * largest pressure in the lithostatic pressure
+         * profile at the bottom boundary independent of
+         * actual depth.
+         */
+        bool prescribe_constant_pressure_at_bottom_boundary;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_traction/interface.h.bak b/include/aspect/boundary_traction/interface.h.bak
new file mode 100644
index 00000000000..cb6cf8c524b
--- /dev/null
+++ b/include/aspect/boundary_traction/interface.h.bak
@@ -0,0 +1,286 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_traction_interface_h
+#define _aspect_boundary_traction_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/point.h>
+#include <deal.II/base/parameter_handler.h>
+
+namespace aspect
+{
+  /**
+   * A namespace in which we define everything that has to do with defining
+   * traction boundary conditions for the Stokes equations.
+   *
+   * @ingroup BoundaryTractions
+   */
+  namespace BoundaryTraction
+  {
+    using namespace dealii;
+
+    /**
+     * A base class for parameterizations of traction boundary conditions.
+     *
+     * @ingroup BoundaryTractions
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Return the traction that is to hold at a particular position on
+         * the boundary of the domain.
+         *
+         * @param boundary_indicator The boundary indicator of the part of the
+         * boundary of the domain on which the point is located at which we
+         * are requesting the traction.
+         * @param position The position of the point at which we ask for the
+         * traction.
+         * @param normal_vector The (outward) normal vector to the boundary
+         * of the domain.
+         *
+         * @return Boundary traction at position @p position.
+         */
+        virtual
+        Tensor<1,dim>
+        boundary_traction (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position,
+                           const Tensor<1,dim> &normal_vector) const = 0;
+    };
+
+    template <int dim>
+    class Manager : public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Destructor. Made virtual since this class has virtual member
+         * functions.
+         */
+        ~Manager () override;
+
+        /**
+         * A function that is called at the beginning of each time step and
+         * calls the corresponding functions of all created plugins.
+         *
+         * The point of this function is to allow complex boundary traction
+         * models to do an initialization step once at the beginning of each
+         * time step. An example would be a model that needs to call an
+         * external program to compute the traction change at a boundary.
+         */
+        virtual
+        void
+        update ();
+
+        /**
+         * A function that calls the boundary_traction functions of all the
+         * individual boundary traction objects and uses the stored operators
+         * to combine them.
+         */
+        Tensor<1,dim>
+        boundary_traction (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position,
+                           const Tensor<1,dim> &normal_vector) const;
+
+        /**
+           * Return the names of all prescribed boundary traction models currently
+           * used in the computation as specified in the input file. The function
+           * returns a map between a boundary identifier and a pair. The
+           * first part of the pair is a string that represents the prescribed
+           * traction components on this boundary (e.g. y, xz, or xyz) and the
+           * second part is a vector of strings that represent the names of
+           * boundary traction plugins for this boundary.
+           * If there are no prescribed boundary traction plugins
+           * for a particular boundary, this boundary identifier will not appear
+           * in the map.
+           */
+        const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> &
+        get_active_boundary_traction_names () const;
+
+        /**
+         * Return pointers to all boundary traction models
+         * currently used in the computation, as specified in the input file.
+         * The function returns a map between a boundary identifier and a vector
+         * of unique pointers that represent the names of prescribed traction
+         * boundary models for this boundary. If there are no prescribed
+         * boundary traction plugins for a particular boundary this boundary
+         * identifier will not appear in the map.
+         */
+        const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryTraction::Interface<dim>>>> &
+        get_active_boundary_traction_conditions () const;
+
+        /**
+         * Declare the parameters of all known boundary traction plugins, as
+         * well as the ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which boundary traction objects will be created;
+         * then let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm);
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcBoundaryTractionNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered boundary traction objects.");
+
+        /**
+        * Register a traction boundary conditions model so that it can be
+        * selected from the parameter file.
+        *
+        * @param name A string that identifies the traction boundary conditions
+        * model
+        * @param description A text description of what this model does and that
+        * will be listed in the documentation of the parameter file.
+        * @param declare_parameters_function A pointer to a function that can be
+        * used to declare the parameters that this traction boundary conditions
+        * model wants to read from input files.
+        * @param factory_function A pointer to a function that can create an
+        * object of this traction boundary conditions model.
+        *
+        * @ingroup BoundaryTractions
+        */
+        static
+        void
+        register_boundary_traction (const std::string &name,
+                                    const std::string &description,
+                                    void (*declare_parameters_function) (ParameterHandler &),
+                                    std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+      private:
+        /**
+         * A list of boundary traction objects that have been requested in the
+         * parameter file.
+         */
+        std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryTraction::Interface<dim>>>> boundary_traction_objects;
+
+        /**
+         * Map from boundary id to a pair
+         * ("components", list of "traction boundary type"),
+         * where components is of the format "[x][y][z]" and the traction type is
+         * mapped to one of the plugins of traction boundary conditions (e.g.
+         * "function"). If the components string is empty, it is assumed the
+         * plugins are used for all components.
+         */
+        std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> boundary_traction_indicators;
+
+    };
+
+    /**
+     * A function that given the name of a model returns a pointer to an
+     * object that describes it. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The model object returned is not yet initialized and has not
+     * read its runtime parameters yet.
+     *
+     * @ingroup BoundaryTractions
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_boundary_traction (const std::string &name);
+
+    /**
+     * Return a list of names of all implemented boundary traction models,
+     * separated by '|' so that it can be used in an object of type
+     * Patterns::Selection.
+     */
+    template <int dim>
+    std::string
+    get_names ();
+
+    /**
+     * Declare the runtime parameters of the registered traction boundary
+     * conditions models.
+     *
+     * @ingroup BoundaryTractions
+     */
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm);
+
+
+    /**
+     * For the current plugin subsystem, write a connection graph of all of the
+     * plugins we know about, in the format that the
+     * programs dot and neato understand. This allows for a visualization of
+     * how all of the plugins that ASPECT knows about are interconnected, and
+     * connect to other parts of the ASPECT code.
+     *
+     * @param output_stream The stream to write the output to.
+     */
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &output_stream);
+
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a traction boundary conditions model, register it with the
+     * functions that can declare their parameters and create these objects.
+     *
+     * @ingroup BoundaryTractions
+     */
+#define ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryTraction::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::BoundaryTraction::Manager<2>::register_boundary_traction, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryTraction::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::BoundaryTraction::Manager<3>::register_boundary_traction, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_traction/zero_traction.h.bak b/include/aspect/boundary_traction/zero_traction.h.bak
new file mode 100644
index 00000000000..d3aba4229d1
--- /dev/null
+++ b/include/aspect/boundary_traction/zero_traction.h.bak
@@ -0,0 +1,61 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_traction_zero_traction_h
+#define _aspect_boundary_traction_zero_traction_h
+
+#include <aspect/boundary_traction/interface.h>
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements zero traction boundary conditions. This
+     * is equivalent to an open boundary condition in domains where
+     * hydrostatic pressure is irrelevant.
+     *
+     * @ingroup BoundaryTractions
+     */
+    template <int dim>
+    class ZeroTraction : public Interface<dim>
+    {
+      public:
+        /**
+         * Return the boundary traction as a function of position. The
+         * (outward) normal vector to the domain is also provided as
+         * a second argument.
+         *
+         * For the current class, this function obviously simply returns a zero
+         * tensor.
+         */
+        Tensor<1,dim>
+        boundary_traction (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position,
+                           const Tensor<1,dim> &normal_vector) const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_velocity/ascii_data.h.bak b/include/aspect/boundary_velocity/ascii_data.h.bak
new file mode 100644
index 00000000000..bc262ac86a4
--- /dev/null
+++ b/include/aspect/boundary_velocity/ascii_data.h.bak
@@ -0,0 +1,110 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_velocity_ascii_data_h
+#define _aspect_boundary_velocity_ascii_data_h
+
+#include <aspect/boundary_velocity/interface.h>
+
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements prescribed velocity boundary conditions
+     * determined from a AsciiData input file.
+     *
+     * @ingroup BoundaryVelocities
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataBoundary<dim>::initialize;
+
+        /**
+         * A function that is called at the beginning of each time step. For
+         * the current plugin, this function loads the next data files if
+         * necessary and outputs a warning if the end of the set of data files
+         * is reached.
+         */
+        void
+        update () override;
+
+        /**
+         * Return the boundary velocity as a function of position. For the
+         * current class, this function returns value from the text files.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position) const override;
+
+        // avoid -Woverloaded-virtual warning until the deprecated function
+        // is removed from the interface:
+        using Interface<dim>::boundary_velocity;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+      private:
+        std::set<types::boundary_id> boundary_ids;
+
+        /**
+         * Whether to specify velocity in x, y, z components, or
+         * r, phi, theta components.
+         */
+        bool use_spherical_unit_vectors;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_velocity/function.h.bak b/include/aspect/boundary_velocity/function.h.bak
new file mode 100644
index 00000000000..940840de66d
--- /dev/null
+++ b/include/aspect/boundary_velocity/function.h.bak
@@ -0,0 +1,115 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_velocity_function_h
+#define _aspect_boundary_velocity_function_h
+
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements velocity boundary conditions based on a
+     * functional description provided in the input file.
+     *
+     * @ingroup BoundaryVelocities
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Function ();
+
+        /**
+         * Return the boundary velocity as a function of position. For the
+         * current class, this function obviously simply returns a zero
+         * tensor.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position) const override;
+
+        // avoid -Woverloaded-virtual warning until the deprecated function
+        // is removed from the interface:
+        using Interface<dim>::boundary_velocity;
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the boundary values will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the components of the velocity.
+         */
+        Functions::ParsedFunction<dim> boundary_velocity_function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+
+        /**
+         * Whether to specify velocity in x, y, z components, or
+         * r, phi, theta components.
+         */
+        bool use_spherical_unit_vectors;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_velocity/gplates.h.bak b/include/aspect/boundary_velocity/gplates.h.bak
new file mode 100644
index 00000000000..7860576b75f
--- /dev/null
+++ b/include/aspect/boundary_velocity/gplates.h.bak
@@ -0,0 +1,347 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_velocity_gplates_h
+#define _aspect_boundary_velocity_gplates_h
+
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <array>
+#include <deal.II/base/function_lib.h>
+
+
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    using namespace dealii;
+
+    namespace internal
+    {
+      /**
+       * GPlatesLookup handles all kinds of tasks around looking up a certain
+       * velocity boundary condition from a gplates .gpml file.
+       */
+      template <int dim>
+      class GPlatesLookup
+      {
+        public:
+
+          /**
+           * Initialize all members and calculates any necessary rotation
+           * parameters for a 2D model.
+           */
+          GPlatesLookup(const Tensor<1,2> &surface_point_one,
+                        const Tensor<1,2> &surface_point_two);
+
+          /**
+           * Outputs the GPlates module information at model start.
+           */
+          std::string
+          screen_output(const Tensor<1,2> &surface_point_one,
+                        const Tensor<1,2> &surface_point_two) const;
+
+          /**
+           * Loads a gplates .gpml velocity file. Throws an exception if the
+           * file does not exist.
+           */
+          void load_file(const std::string &filename,
+                         const MPI_Comm comm);
+
+          /**
+           * Returns the computed surface velocity in cartesian coordinates.
+           * Takes as input the position. Actual velocity interpolation is
+           * performed in spherical coordinates.
+           *
+           * @param position The current position to compute velocity
+           */
+          Tensor<1,dim> surface_velocity(const Point<dim> &position) const;
+
+        private:
+          /**
+           * Interpolation functions to access the velocities.
+           */
+          std::array<std::unique_ptr<Functions::InterpolatedUniformGridData<2>>, 2> velocities;
+
+          /**
+           * Distances between adjacent point in the Lat/Long grid
+           */
+          double delta_phi, delta_theta;
+
+          /**
+           * The matrix, which describes the rotation by which a 2D model
+           * needs to be transformed to a plane that contains the origin and
+           * the two user prescribed points. Is not necessary and therefore
+           * not used for 3D models.
+           */
+          Tensor<2,3> rotation_matrix;
+
+          /**
+           * A function that returns the corresponding paraview angles for a
+           * rotation described by a rotation matrix. These differ from the
+           * usually used euler angles by assuming a rotation around the
+           * coordinate axes in the order y-x-z (instead of the often used
+           * z-x-z)
+           */
+          std::array<double,3>
+          angles_from_matrix (const Tensor<2,3> &rotation_matrix) const;
+
+          /**
+           * A function that returns the corresponding rotation axis/angle for
+           * a rotation described by a rotation matrix.
+           */
+          double
+          rotation_axis_from_matrix (Tensor<1,3> &rotation_axis,
+                                     const Tensor<2,3> &rotation_matrix) const;
+
+          /**
+           * Convert a tensor of rank 1 and dimension in to rank 1 and
+           * dimension out. If $out < in$ the last elements will be discarded,
+           * if $out > in$ zeroes will be appended to fill the tensor.
+           */
+          template <int in, int out>
+          Tensor<1,out> convert_tensor (const Tensor<1,in> &old_tensor) const;
+
+          /**
+           * Return the cartesian coordinates of a spherical surface position
+           * defined by theta (polar angle, not geographical latitude) and
+           * phi.
+           */
+          Tensor<1,3>
+          cartesian_surface_coordinates(const Tensor<1,3> &sposition) const;
+
+          /**
+           * This function looks up the north- and east-velocities at a given
+           * position and converts them to cartesian velocities.
+           */
+          Tensor<1,dim>
+          cartesian_velocity_at_surface_point(const std::array<double,3> &spherical_point) const;
+
+          /**
+           * Returns cartesian velocities calculated from surface velocities
+           * and position in spherical coordinates
+           *
+           * @param s_velocities Surface velocities in spherical coordinates
+           * (theta, phi)
+           * @param s_position Position in spherical coordinates
+           * (radius,phi,theta)
+           */
+          Tensor<1,3> sphere_to_cart_velocity(const Tensor<1,2> &s_velocities,
+                                              const std::array<double,3> &s_position) const;
+
+          /**
+           * Check whether the gpml file was created by GPlates1.4 or later.
+           * We need to know this, because the mesh has changed its longitude
+           * origin from 0 to -180 degrees and we need to correct for this.
+           */
+          bool
+          gplates_1_4_or_higher(const boost::property_tree::ptree &pt) const;
+      };
+    }
+
+    /**
+     * A class that implements prescribed velocity boundary conditions
+     * determined from GPlates input files. The interpolation in time is
+     * performed between two objects of the GPlatesLookup class.
+     *
+     * @ingroup BoundaryVelocities
+     */
+    template <int dim>
+    class GPlates : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        GPlates ();
+
+        /**
+         * Return the boundary velocity as a function of position. For the
+         * current class, this function returns value from gplates.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position) const override;
+
+        // avoid -Woverloaded-virtual warning until the deprecated function
+        // is removed from the interface:
+        using Interface<dim>::boundary_velocity;
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        /**
+         * A function that is called at the beginning of each time step. For
+         * the current plugin, this function loads the next velocity files if
+         * necessary and outputs a warning if the end of the set of velocity
+         * files is reached.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A variable that stores the currently used data file of a series. It
+         * gets updated if necessary by update().
+         */
+        int current_file_number;
+
+        /**
+         * Time from which on the data file with number 'First data file
+         * number' is used as boundary condition. Previous to this time, 0 is
+         * returned for every field. Depending on the setting of the global
+         * 'Use years in output instead of seconds' flag in the input file,
+         * this number is either interpreted as seconds or as years."
+         */
+        double first_data_file_model_time;
+
+        /**
+         * Number of the first data file to be loaded when the model time is
+         * larger than 'First data file model time'.
+         */
+        int first_data_file_number;
+
+        /**
+         * In some cases the boundary files are not numbered in increasing but
+         * in decreasing order (e.g. 'Ma BP'). If this flag is set to 'True'
+         * the plugin will first load the file with the number 'First data
+         * file number' and decrease the file number during the model run.
+         */
+        bool decreasing_file_order;
+
+        /**
+         * Time in model units (depends on other model inputs) between two
+         * velocity files.
+         */
+        double data_file_time_step;
+
+        /**
+         * Weight between velocity file n and n+1 while the current time is
+         * between the two values t(n) and t(n+1).
+         */
+        double time_weight;
+
+        /**
+         * State whether we have time_dependent boundary conditions. Switched
+         * off after finding no more velocity files to suppress attempts to read
+         * in new files.
+         */
+        bool time_dependent;
+
+        /**
+         * Directory in which the gplates velocity files are present.
+         */
+        std::string data_directory;
+
+        /**
+         * First part of filename of velocity files. The files have to have
+         * the pattern velocity_file_name.n.gpml where n is the number of the
+         * current timestep (starts from 0).
+         */
+        std::string velocity_file_name;
+
+        /**
+         * Scale the velocity boundary condition by a scalar factor.
+         */
+        double velocity_scaling_factor;
+
+        /**
+         * Two user defined points that prescribe the plane from which the 2D
+         * model takes the velocity boundary condition. One can think of this,
+         * as if the model is lying in this plane although no actual model
+         * coordinate is changed. The strings need to have the format "a,b"
+         * where a and b are doubles and define theta and phi on a sphere.
+         */
+        std::string point1;
+        std::string point2;
+
+        /**
+         * Parsed user input of point1 and point2
+         */
+        Tensor<1,2> pointone;
+        Tensor<1,2> pointtwo;
+
+        /**
+         * Determines the depth of the lithosphere. The user might want to apply
+         * the GPlates velocities not only at the surface of the model, but also
+         * in the whole lithosphere. At every side boundary point with a depth
+         * smaller than this value (and thus being located in the lithosphere),
+         * the surface velocity will be described.
+         */
+        double lithosphere_thickness;
+
+        /**
+         * Pointer to an object that reads and processes data we get from
+         * gplates files.
+         */
+        std::unique_ptr<internal::GPlatesLookup<dim>> lookup;
+
+        /**
+         * Pointer to an object that reads and processes data we get from
+         * gplates files. This saves the previous data time step.
+         */
+        std::unique_ptr<internal::GPlatesLookup<dim>> old_lookup;
+
+        /**
+         * Handles the update of the velocity data in lookup. The input
+         * parameter makes sure that both velocity files (n and n+1) can be
+         * reloaded if the model time step is larger than the velocity file
+         * time step.
+         */
+        void
+        update_data (const bool load_both_files);
+
+        /**
+         * Handles settings and user notification in case the time-dependent
+         * part of the boundary condition is over.
+         */
+        void
+        end_time_dependence ();
+
+        /**
+         * Create a filename out of the name template.
+         */
+        std::string
+        create_filename (const int timestep) const;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_velocity/interface.h.bak b/include/aspect/boundary_velocity/interface.h.bak
new file mode 100644
index 00000000000..e81c6e6cdfd
--- /dev/null
+++ b/include/aspect/boundary_velocity/interface.h.bak
@@ -0,0 +1,349 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_velocity_interface_h
+#define _aspect_boundary_velocity_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/simulator_access.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/point.h>
+#include <deal.II/base/parameter_handler.h>
+
+#include <boost/core/demangle.hpp>
+#include <typeinfo>
+
+
+namespace aspect
+{
+  /**
+   * A namespace in which we define everything that has to do with defining
+   * the velocity boundary conditions.
+   *
+   * @ingroup BoundaryVelocities
+   */
+  namespace BoundaryVelocity
+  {
+    using namespace dealii;
+
+    /**
+     * A base class for parameterizations of velocity boundary conditions.
+     *
+     * @ingroup BoundaryVelocities
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Return the velocity that is to hold at a particular position on
+         * the boundary of the domain.
+         *
+         * @param boundary_indicator The boundary indicator of the part of the
+         * boundary of the domain on which the point is located at which we
+         * are requesting the velocity.
+         * @param position The position of the point at which we ask for the
+         * velocity.
+         *
+         * @return Boundary velocity at position @p position.
+         */
+        virtual
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position) const = 0;
+    };
+
+    /**
+     * A class that manages all boundary velocity objects.
+     *
+     * @ingroup BoundaryVelocities
+     */
+    template <int dim>
+    class Manager : public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Destructor. Made virtual since this class has virtual member
+         * functions.
+         */
+        ~Manager () override;
+
+        /**
+         * A function that is called at the beginning of each time step and
+         * calls the corresponding functions of all created plugins.
+         *
+         * The point of this function is to allow complex boundary velocity
+         * models to do an initialization step once at the beginning of each
+         * time step. An example would be a model that needs to call an
+         * external program to compute the velocity change at a boundary.
+         */
+        virtual
+        void
+        update ();
+
+        /**
+         * A function that calls the boundary_velocity functions of all the
+         * individual boundary velocity objects and uses the stored operators
+         * to combine them.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position) const;
+
+        /**
+         * A function that is used to register boundary velocity objects in such
+         * a way that the Manager can deal with all of them without having to
+         * know them by name. This allows the files in which individual
+         * plugins are implemented to register these plugins, rather than also
+         * having to modify the Manager class by adding the new boundary
+         * velocity plugin class.
+         *
+         * @param name A string that identifies the boundary velocity model
+         * @param description A text description of what this model does and that
+         * will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that can be
+         * used to declare the parameters that this boundary velocity model
+         * wants to read from input files.
+         * @param factory_function A pointer to a function that can create an
+         * object of this boundary velocity model.
+         */
+        static
+        void
+        register_boundary_velocity (const std::string &name,
+                                    const std::string &description,
+                                    void (*declare_parameters_function) (ParameterHandler &),
+                                    std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+
+        /**
+         * Return the names of all prescribed boundary velocity models currently
+         * used in the computation as specified in the input file. The function
+         * returns a map between a boundary identifier and a pair. The
+         * first part of the pair is a string that represents the prescribed
+         * velocity components on this boundary (e.g. y, xz, or xyz) and the
+         * second part is a vector of strings that represent the names of
+         * boundary velocity plugins for this boundary.
+         * If there are no prescribed boundary velocity plugins
+         * for a particular boundary, this boundary identifier will not appear
+         * in the map.
+         */
+        const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> &
+        get_active_boundary_velocity_names () const;
+
+        /**
+         * Return pointers to all boundary velocity models
+         * currently used in the computation, as specified in the input file.
+         * The function returns a map between a boundary identifier and a vector
+         * of unique pointers that represent the names of prescribed velocity
+         * boundary models for this boundary. If there are no prescribed
+         * boundary velocity plugins for a particular boundary this boundary
+         * identifier will not appear in the map.
+         */
+        const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>> &
+        get_active_boundary_velocity_conditions () const;
+
+        /**
+         * Return a list of boundary ids on which the velocity is prescribed
+         * to be zero (no-slip).
+         */
+        const std::set<types::boundary_id> &
+        get_zero_boundary_velocity_indicators () const;
+
+        /**
+         * Return a list of boundary ids on which the velocity is prescribed
+         * to be tangential (free-slip).
+         */
+        const std::set<types::boundary_id> &
+        get_tangential_boundary_velocity_indicators () const;
+
+        /**
+         * Declare the parameters of all known boundary velocity plugins, as
+         * well as the ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which boundary velocity objects will be created;
+         * then let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm);
+
+        /**
+         * Go through the list of all boundary velocity models that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename BoundaryVelocityType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryVelocityType>::value>>
+        bool
+        has_matching_boundary_velocity_model () const;
+
+        /**
+         * Go through the list of all boundary velocity models that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no boundary velocity model is active that matches the given type,
+         * throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename BoundaryVelocityType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryVelocityType>::value>>
+        const BoundaryVelocityType &
+        get_matching_boundary_velocity_model () const;
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcBoundaryVelocityNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered boundary velocity objects.");
+      private:
+        /**
+         * A list of boundary velocity objects that have been requested in the
+         * parameter file.
+         */
+        std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>> boundary_velocity_objects;
+
+        /**
+         * Map from boundary id to a pair
+         * ("components", list of "velocity boundary type"),
+         * where components is of the format "[x][y][z]" and the velocity type is
+         * mapped to one of the plugins of velocity boundary conditions (e.g.
+         * "function"). If the components string is empty, it is assumed the
+         * plugins are used for all components.
+         */
+        std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> boundary_velocity_indicators;
+
+        /**
+         * A set of boundary indicators, on which velocities are prescribed to
+         * zero (no-slip).
+         */
+        std::set<types::boundary_id> zero_velocity_boundary_indicators;
+
+        /**
+         * A set of boundary indicators, on which velocities are prescribed to
+         * be tangential (free-slip).
+         */
+        std::set<types::boundary_id> tangential_velocity_boundary_indicators;
+    };
+
+
+
+    template <int dim>
+    template <typename BoundaryVelocityType, typename>
+    inline
+    bool
+    Manager<dim>::has_matching_boundary_velocity_model () const
+    {
+      for (const auto &boundary : boundary_velocity_objects)
+        for (const auto &p : boundary.second)
+          if (Plugins::plugin_type_matches<BoundaryVelocityType>(*p))
+            return true;
+      return false;
+    }
+
+
+    template <int dim>
+    template <typename BoundaryVelocityType, typename>
+    inline
+    const BoundaryVelocityType &
+    Manager<dim>::get_matching_boundary_velocity_model () const
+    {
+      AssertThrow(has_matching_boundary_velocity_model<BoundaryVelocityType> (),
+                  ExcMessage("You asked BoundaryVelocity::Manager::get_boundary_velocity_model() for a "
+                             "boundary velocity model of type <" + boost::core::demangle(typeid(BoundaryVelocityType).name()) + "> "
+                             "that could not be found in the current model. Activate this "
+                             "boundary velocity model in the input file."));
+
+      for (const auto &boundary : boundary_velocity_objects)
+        for (const auto &p : boundary)
+          if (Plugins::plugin_type_matches<BoundaryVelocityType>(*p))
+            return Plugins::get_plugin_as_type<BoundaryVelocityType>(*p);
+
+      // We will never get here, because we had the Assert above. Just to avoid warnings.
+      return Plugins::get_plugin_as_type<BoundaryVelocityType>(**(boundary_velocity_objects.begin()));
+    }
+
+
+    /**
+     * Return a string that consists of the names of boundary velocity models that can
+     * be selected. These names are separated by a vertical line '|' so
+     * that the string can be an input to the deal.II classes
+     * Patterns::Selection or Patterns::MultipleSelection.
+     */
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ();
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a boundary velocity model, register it with the functions that
+     * can declare their parameters and create these objects.
+     *
+     * @ingroup BoundaryVelocities
+     */
+#define ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(classname, name, description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryVelocity::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::BoundaryVelocity::Manager<2>::register_boundary_velocity, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryVelocity::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::BoundaryVelocity::Manager<3>::register_boundary_velocity, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/boundary_velocity/zero_velocity.h.bak b/include/aspect/boundary_velocity/zero_velocity.h.bak
new file mode 100644
index 00000000000..03ddb3f6e86
--- /dev/null
+++ b/include/aspect/boundary_velocity/zero_velocity.h.bak
@@ -0,0 +1,59 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_boundary_velocity_zero_velocity_h
+#define _aspect_boundary_velocity_zero_velocity_h
+
+#include <aspect/boundary_velocity/interface.h>
+
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements zero velocity (stick) boundary conditions.
+     *
+     * @ingroup BoundaryVelocities
+     */
+    template <int dim>
+    class ZeroVelocity : public Interface<dim>
+    {
+      public:
+        /**
+         * Return the boundary velocity as a function of position. For the
+         * current class, this function obviously simply returns a zero
+         * tensor.
+         */
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position) const override;
+
+        // avoid -Woverloaded-virtual warning until the deprecated function
+        // is removed from the interface:
+        using Interface<dim>::boundary_velocity;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/citation_info.h.bak b/include/aspect/citation_info.h.bak
new file mode 100644
index 00000000000..1514f29b101
--- /dev/null
+++ b/include/aspect/citation_info.h.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_citation_info_h
+#define _aspect_citation_info_h
+
+#include <string>
+#include <iostream>
+
+/**
+ * A namespace to provide information to the user about stuff to cite.
+ */
+namespace CitationInfo
+{
+  /**
+   * Get the URL in the format "citing.html?(parameters)" that describes how to
+   * cite ASPECT based on the current model you are running.
+   */
+  const std::string get_url_part ();
+
+  /**
+   * Add the paper identified by the given id to the currently used list of
+   * papers. See citing.html for the list of ids. For specific features inside
+   * ASPECT that have associated publications, call this function if the
+   * feature is used in the current computation. For example, if the
+   * computation requires melt migration, call <tt>add("melt")</tt>.
+   */
+  void add (const std::string &id);
+
+  /**
+   * Print the info text containing the citation info into the given
+   * stream.
+   */
+  template <class Stream>
+  void print_info_block (Stream &stream)
+  {
+    stream << "-----------------------------------------------------------------------------\n"
+           << "-- For information on how to cite ASPECT, see:\n"
+           << "--   https://aspect.geodynamics.org/" << get_url_part() << "\n"
+           << "-----------------------------------------------------------------------------"
+           << std::endl;
+  }
+}
+
+#endif
diff --git a/include/aspect/compat.h.bak b/include/aspect/compat.h.bak
new file mode 100644
index 00000000000..3ff1642ae4c
--- /dev/null
+++ b/include/aspect/compat.h.bak
@@ -0,0 +1,216 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_compat_h
+#define _aspect_compat_h
+
+#include <aspect/global.h>
+// C++11 related includes.
+#include <array>
+#include <functional>
+#include <memory>
+
+namespace big_mpi
+{
+
+  using dealii::Utilities::MPI::broadcast;
+
+}
+
+// deal.II 9.6 introduces the new MGTransferMF class as a replacement
+// for MGTransferMatrixFree. Instead of putting an ifdef in every place,
+// do this in one central location:
+#if !DEAL_II_VERSION_GTE(9,6,0)
+#include <deal.II/multigrid/mg_transfer_matrix_free.h>
+namespace dealii
+{
+  template <int dim, class NumberType>
+  using MGTransferMF = MGTransferMatrixFree<dim,NumberType>;
+}
+#endif
+
+
+
+// deal.II versions up to 9.5 had a poorly designed interface of the
+// SphericalManifold class that made it impossible for us to use.
+// This file thus contains a copy of it.
+#if !DEAL_II_VERSION_GTE(9,6,0)
+
+#include <deal.II/grid/manifold.h>
+#include <deal.II/grid/manifold_lib.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  /**
+   * The deal.II class SphericalManifold has a design flaw that made it
+   * impossible to derive from the class. This is fixed post-9.5,
+   * see https://github.com/dealii/dealii/pull/16242 and
+   * https://github.com/dealii/dealii/pull/16248, but we can't
+   * use deal.II 9.5 and earlier for this class. The current class
+   * here is therefore a copy of the fixed class.
+   */
+  template <int dim, int spacedim = dim>
+  class SphericalManifold : public Manifold<dim, spacedim>
+  {
+    public:
+      /**
+       * Constructor.
+       *
+       * @param[in] center The center of the coordinate system. Defaults to the
+       * origin.
+       */
+      SphericalManifold(const Point<spacedim> center = Point<spacedim>());
+
+      /**
+       * Make a clone of this Manifold object.
+       */
+      virtual std::unique_ptr<Manifold<dim, spacedim>>
+      clone() const override;
+
+      /**
+       * Given any two points in space, first project them on the surface
+       * of a sphere with unit radius, then connect them with a geodesic
+       * and find the intermediate point, and finally rescale the final
+       * radius so that the resulting one is the convex combination of the
+       * starting radii.
+       */
+      virtual Point<spacedim>
+      get_intermediate_point(const Point<spacedim> &p1,
+                             const Point<spacedim> &p2,
+                             const double           w) const override;
+
+      /**
+       * Compute the derivative of the get_intermediate_point() function
+       * with parameter w equal to zero.
+       */
+      virtual Tensor<1, spacedim>
+      get_tangent_vector(const Point<spacedim> &x1,
+                         const Point<spacedim> &x2) const override;
+
+      /**
+       * @copydoc Manifold::normal_vector()
+       */
+      virtual Tensor<1, spacedim>
+      normal_vector(
+        const typename Triangulation<dim, spacedim>::face_iterator &face,
+        const Point<spacedim> &p) const override;
+
+      /**
+       * Compute the normal vectors to the boundary at each vertex.
+       */
+      virtual void
+      get_normals_at_vertices(
+        const typename Triangulation<dim, spacedim>::face_iterator &face,
+        typename Manifold<dim, spacedim>::FaceVertexNormals &face_vertex_normals)
+      const override;
+
+      /**
+       * Compute a new set of points that interpolate between the given points @p
+       * surrounding_points. @p weights is a table with as many columns as @p
+       * surrounding_points.size(). The number of rows in @p weights must match
+       * the length of @p new_points.
+       *
+       * This function is optimized to perform on a collection
+       * of new points, by collecting operations that are not dependent on the
+       * weights outside of the loop over all new points.
+       *
+       * The implementation does not allow for @p surrounding_points and
+       * @p new_points to point to the same array, so make sure to pass different
+       * objects into the function.
+       */
+      virtual void
+      get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
+                     const Table<2, double>                 &weights,
+                     ArrayView<Point<spacedim>> new_points) const override;
+
+      /**
+       * Return a point on the spherical manifold which is intermediate
+       * with respect to the surrounding points.
+       */
+      virtual Point<spacedim>
+      get_new_point(const ArrayView<const Point<spacedim>> &vertices,
+                    const ArrayView<const double>          &weights) const override;
+
+      /**
+       * The center of the spherical coordinate system.
+       */
+      const Point<spacedim> center;
+
+    private:
+      /**
+       * Return a point on the spherical manifold which is intermediate
+       * with respect to the surrounding points. This function uses a linear
+       * average of the directions to find an estimated point. It returns a pair
+       * of radius and direction from the center point to the candidate point.
+       */
+      std::pair<double, Tensor<1, spacedim>>
+      guess_new_point(const ArrayView<const Tensor<1, spacedim>> &directions,
+                      const ArrayView<const double>              &distances,
+                      const ArrayView<const double>              &weights) const;
+
+      /**
+       * This function provides an internal implementation of the get_new_points()
+       * interface.
+       *
+       * It computes a new set of points that interpolate between the given points
+       * @p
+       * surrounding_points. @p weights is an array view with as many entries as @p
+       * surrounding_points.size() times @p new_points.size().
+       *
+       * This function is optimized to perform on a collection
+       * of new points, by collecting operations that are not dependent on the
+       * weights outside of the loop over all new points.
+       *
+       * The implementation does not allow for @p surrounding_points and
+       * @p new_points to point to the same array, so make sure to pass different
+       * objects into the function.
+       */
+      void
+      do_get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
+                        const ArrayView<const double>          &weights,
+                        ArrayView<Point<spacedim>>              new_points) const;
+
+      /**
+       * A manifold description to be used for get_new_point in 2d.
+       */
+      const PolarManifold<spacedim> polar_manifold;
+  };
+}
+
+#else
+
+// For sufficiently new deal.II versions, we can use the deal.II class, but to
+// avoid name clashes, we have to import the class into namespace aspect. Once
+// we rely on these sufficiently new versions of deal.II, we can not only remove
+// the code above, but also the following lines, and in all places where we
+// reference 'aspect::SphericalManifold' simply use 'SphericalManifold' instead
+// (which then refers to the deal.II class).
+
+#include <deal.II/grid/manifold_lib.h>
+namespace aspect
+{
+  using dealii::SphericalManifold;
+}
+
+#endif
+
+#endif
diff --git a/include/aspect/coordinate_systems.h.bak b/include/aspect/coordinate_systems.h.bak
new file mode 100644
index 00000000000..6e4b5748cff
--- /dev/null
+++ b/include/aspect/coordinate_systems.h.bak
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_coordinate_systems_h
+#define _aspect_coordinate_systems_h
+
+namespace aspect
+{
+  namespace Utilities
+  {
+    namespace Coordinates
+    {
+      /**
+       * This enum lists available coordinate systems that can be used for
+       * the function variables. Allowed values are 'cartesian',
+       * 'spherical', and 'depth'. 'spherical' coordinates follow: r, phi
+       * (2D) or r, phi, theta (3D); where r is radius, phi is longitude,
+       * and theta is the polar angle (colatitude). The 'depth' is a
+       * one-dimensional coordinate system in which only the distance
+       * below the 'top' surface (depth) as defined by each geometry model,
+       * is used.
+       */
+      enum CoordinateSystem
+      {
+        depth,
+        cartesian,
+        spherical,
+        ellipsoidal,
+        invalid
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/fe_variable_collection.h.bak b/include/aspect/fe_variable_collection.h.bak
new file mode 100644
index 00000000000..f98de32db12
--- /dev/null
+++ b/include/aspect/fe_variable_collection.h.bak
@@ -0,0 +1,288 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_fe_variable_system_h
+#define _aspect_fe_variable_system_h
+
+#include <aspect/global.h>
+#include <deal.II/fe/component_mask.h>
+#include <deal.II/fe/fe_values_extractors.h>
+#include <deal.II/fe/fe.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  /**
+   * A structure to describe everything necessary to define a single variable
+   * of the finite element system in isolation. It groups the FiniteElement<dim> with other
+   * information like a name and the block structure used in linear systems. A
+   * std::vector of these structs will be converted into an ordered collection of
+   * objects of type FEVariable represented by FEVariableCollection to form the
+   * finite element system.
+   *
+   * Blocks are used to extract or solve for certain variables separately or
+   * in block based preconditioners.  As an example, in a Stokes problem one
+   * might want velocity and pressure in a single block (for use with a direct
+   * solver), or one block for all velocity components and a second block for
+   * the pressure (for a Schur complement-based preconditioner), or separate
+   * blocks for pressure and each velocity component.
+   */
+  template <int dim>
+  struct VariableDeclaration
+  {
+    /**
+     * Constructor.
+     *
+     * @param name A user-friendly and unique string representation of the variable.
+     *
+     * @param fe The FiniteElement class to use. Currently, this needs to be a scalar
+     * finite element class (with exactly one component).
+     *
+     * @param multiplicity Number of copies of the @p fe to create.
+     *
+     * @param n_blocks Number of blocks this variable represents inside the
+     * linear system. A value of 0 will add the next variable (in the std::vector<VariableDeclaration>
+     * that is used to construct the FEVariableCollection) to the current
+     * block, while 1 will put the next variable into a new block. A value
+     * that is equal to the number of components will create a block for each
+     * component.
+     */
+    VariableDeclaration(const std::string &name,
+                        const std::shared_ptr<FiniteElement<dim>> &fe,
+                        const unsigned int multiplicity,
+                        const unsigned int n_blocks);
+
+    /**
+     * Default constructor.
+     */
+    VariableDeclaration();
+
+    /**
+     * Return the total number of components of this variable.
+     */
+    unsigned int n_components() const;
+
+    /**
+     * Name of the variable used in FEVariableCollection to identify it.
+     */
+    std::string name;
+
+    /**
+     * The FiniteElement space.
+     */
+    std::shared_ptr<FiniteElement<dim>> fe;
+
+    /**
+     * The multiplicity used in FESystem: how many copies of @p fe are there?
+     */
+    unsigned int multiplicity;
+
+    /**
+     * Number of linear algebra blocks occupied by this variable. See
+     * constructor for details.
+     */
+    unsigned int n_blocks;
+  };
+
+  /**
+   * Struct to represent a variable as part of a FEVariableCollection. Constructed
+   * from an instance of VariableDeclaration<dim> but contains additional
+   * information that can be queried.
+   */
+  template <int dim>
+  struct FEVariable: public VariableDeclaration<dim>
+  {
+      /**
+       * Initialize this variable as part of a FESystem with the given
+       * indices for @p component, @p block, and @p base.
+       */
+      FEVariable(const VariableDeclaration<dim> &fe_variable,
+                 const unsigned int component_index,
+                 const unsigned int block_index,
+                 const unsigned int base_index);
+
+      /**
+       * The first component index of this variable within the
+       * FEVariableCollection.
+       */
+      unsigned int first_component_index;
+
+      /**
+       * The index of the block of the linear system this variable is
+       * placed in (within the FEVariableCollection).
+       */
+      unsigned int block_index;
+      /**
+       * This index represents the how-manyth variable this is in the
+       * FEVariableCollection and consequently the FESystem, so the
+       *
+       */
+      unsigned int base_index;
+
+      /**
+       * The component mask of this variable.
+       */
+      ComponentMask component_mask;
+
+      /**
+       * Return a scalar FeValuesExtractor if this variable is scalar.
+       */
+      const FEValuesExtractors::Scalar &extractor_scalar() const;
+
+      /**
+       * Return a vector FeValuesExtractor if this variable is a vector.
+       */
+      const FEValuesExtractors::Vector &extractor_vector() const;
+
+    private:
+      /**
+       * Stores the object returned by extractor_scalar().
+       */
+      FEValuesExtractors::Scalar scalar_extractor;
+
+      /**
+       * Stores the object returned by extractor_vector().
+       */
+      FEValuesExtractors::Vector vector_extractor;
+  };
+
+
+  /**
+   * A class that represents a collection of variables (of type FEVariable) to
+   * form a Finite Element system.  A dealii::FESystem can be constructed
+   * from it using get_fes() and get_multiplicities().  Other information
+   * contained in this class on top of FESystem are names, and the block
+   * structure for linear systems.
+   */
+  template <int dim>
+  class FEVariableCollection
+  {
+    public:
+      /**
+       * Construct an empty object.
+       */
+      FEVariableCollection();
+
+      /**
+       * Construct object from a vector of variables (identical to calling
+       * initialize()).
+       */
+      FEVariableCollection(const std::vector<VariableDeclaration<dim>> &variable_definitions);
+
+      /**
+       * Fill this object with the given list of @p variables.
+       */
+      void initialize(const std::vector<VariableDeclaration<dim>> &variable_definitions);
+
+      /**
+       * Return the variable with name @p name. Throws an exception if this
+       * variable does not exist. If more than one variable with the same name
+       * exists, return the first one. Use variables_with_name() if you want
+       * to access all of them.
+       */
+      const FEVariable<dim> &variable(const std::string &name) const;
+
+      /**
+       * Return a vector of pointers of all variables with name @p name.
+       */
+      std::vector<const FEVariable<dim>*> variables_with_name(const std::string &name) const;
+
+      /**
+       * Returns true if the variable with @p name exists in the list of
+       * variables.
+       */
+      bool variable_exists(const std::string &name) const;
+
+      /**
+       * Return the list of all variables.
+       */
+      const std::vector<FEVariable<dim>> &get_variables() const;
+
+      /**
+       * Return the total number of components in the system.
+       */
+      unsigned int n_components() const;
+
+      /**
+       * Return the total number of block of the system.
+       */
+      unsigned int n_blocks() const;
+
+      /**
+       * Return the vector of finite element spaces used for the construction
+       * of the FESystem.
+       */
+      const std::vector<const FiniteElement<dim> *> &get_fes() const;
+
+      /**
+       * Return the vector of multiplicities used for the construction of the
+       * FESystem.
+       */
+      const std::vector<unsigned int> &get_multiplicities() const;
+
+      /**
+       * Return a variable that describes for each vector component which
+       * vector block it corresponds to.
+       */
+      const std::vector<unsigned int> &get_components_to_blocks() const;
+
+    protected:
+      /**
+       * A std::vector that contains a collection of variables.
+       */
+      std::vector<FEVariable<dim>> variables;
+
+      /**
+       * Total number of components of all variables, returned by n_components().
+       */
+      unsigned int n_components_;
+
+      /**
+       * Total number of blocks of all variables, returned by n_blocks().
+       */
+      unsigned int n_blocks_;
+
+      /**
+       * Data to be used in the FESystem constructor. The get_fes() function
+       * returns a reference to this array.
+       *
+       * The pointers stored in this area are not owned by the current object,
+       * but are instead pointers to the finite elements owned by the elements
+       * of the `variables` array. As a consequence, we do not need to
+       * explicitly manage the deallocation of these pointers.
+       */
+      std::vector<const FiniteElement<dim> *> fes;
+
+      /**
+       * Data to be used in the FESystem constructor, returned by
+       * get_multiplicities().
+       */
+      std::vector<unsigned int> multiplicities;
+
+      /**
+       * Mapping from component to block, returned by get_components_to_blocks().
+       */
+      std::vector<unsigned int> components_to_blocks;
+  };
+
+} // namespace aspect
+
+#endif
diff --git a/include/aspect/geometry_model/box.h.bak b/include/aspect/geometry_model/box.h.bak
new file mode 100644
index 00000000000..de695292bf5
--- /dev/null
+++ b/include/aspect/geometry_model/box.h.bak
@@ -0,0 +1,255 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_box_h
+#define _aspect_geometry_model_box_h
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes a box geometry of certain width, height, and
+     * depth (in 3d), and, possibly, topography.
+     */
+    template <int dim>
+    class Box : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run and after
+         * the SimulatorAccess (if applicable) is initialized.
+         */
+        void initialize () override;
+
+        /**
+         * Add initial topography to the mesh.
+         */
+        void topography (typename parallel::distributed::Triangulation<dim> &grid) const;
+
+        /**
+         * Relocate the vertical coordinate of the given point based on
+         * the topography at the surface specified by the initial topography
+         * model.
+         */
+        Point<dim> add_topography (const Point<dim> &x_y_z) const;
+
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         */
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
+
+        /**
+         * Return a point that denotes the size of the box in each dimension
+         * of the domain.
+         */
+        virtual
+        Point<dim> get_extents () const;
+
+        /**
+         * Return an integer array that denotes the number of repetitions of
+         * the box's coarse mesh.
+         */
+        const std::array<unsigned int, dim> &
+        get_repetitions () const;
+
+        /**
+         * Return a point that denotes the lower left corner of the box
+         * domain.
+         */
+        virtual
+        Point<dim> get_origin () const;
+
+        /**
+         * Return the typical length scale one would expect of features in
+         * this geometry, assuming realistic parameters.
+         *
+         * We return 1/100th of the diameter of the box.
+         */
+        double length_scale () const override;
+
+
+        /**
+         * Return the depth that corresponds to the given
+         * position. The documentation of the base class (see
+         * GeometryModel::Interface::depth()) describes in detail how
+         * "depth" is interpreted in general.
+         *
+         * Computing a depth requires a geometry model to define a
+         * "vertical" direction. The current class considers the
+         * $(0,1)^T$ vector in 2d (and the $(0,0,1)^T$ vector in 3d)
+         * as vertical and considers the "top" boundary as the
+         * surface. In almost all cases one will use a gravity model
+         * that also matches these definitions.
+         *
+         * Note that the depth is calculated with respect to the
+         * surface without initial topography.
+         */
+        double depth(const Point<dim> &position) const override;
+
+        /**
+         * Return the height of the given position relative to
+         * the initial box height.
+         */
+        double height_above_reference_surface(const Point<dim> &position) const override;
+
+        /**
+         * @copydoc Interface::representative_point()
+         */
+        Point<dim> representative_point(const double depth) const override;
+
+        /**
+         * @copydoc Interface::maximal_depth()
+         */
+        double maximal_depth() const override;
+
+        /**
+         * Return the set of boundary indicators that are used by this model.
+         * This information is used to determine what boundary indicators can
+         * be used in the input file.
+         *
+         * The box model uses boundary indicators zero through 2*dim-1, with
+         * the first two being the faces perpendicular to the x-axis, the next
+         * two perpendicular to the y-axis, etc.
+         */
+        std::set<types::boundary_id>
+        get_used_boundary_indicators () const override;
+
+        /**
+         * Return a mapping from symbolic names of each part of the boundary
+         * to the corresponding boundary indicator. This allows users to
+         * specify *names*, not just *numbers* in their input files when
+         * describing which parts of the boundary have to satisfy which
+         * boundary conditions.
+         *
+         * This geometry returns the map <code>{{"left"->0}, {"right"->1},
+         * {"bottom"->2}, {"top"->3}}</code> in 2d, and <code>{{"left"->0},
+         * {"right"->1}, {"front"->2}, {"back"->3}, {"bottom"->4},
+         * {"top"->5}}</code> in 3d.
+         */
+        std::map<std::string,types::boundary_id>
+        get_symbolic_boundary_names_map () const override;
+
+        /**
+         * Return the set of periodic boundaries as described in the input
+         * file.
+         */
+        std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
+        get_periodic_boundary_pairs () const override;
+
+        /**
+         * @copydoc Interface::adjust_positions_for_periodicity
+         *
+         * Apply a translation to all points outside of the domain
+         * to account for periodicity.
+         */
+        void
+        adjust_positions_for_periodicity (Point<dim> &position,
+                                          const ArrayView<Point<dim>> &connected_positions = {},
+                                          const ArrayView<Tensor<1, dim>> &connected_velocities = {}) const override;
+
+        /**
+         * @copydoc Interface::has_curved_elements()
+         *
+         * A box has only straight boundaries and cells, so return false.
+         */
+        bool
+        has_curved_elements() const override;
+
+        /**
+         * Return whether the given point lies within the domain specified
+         * by the geometry. This function does not take into account
+         * initial or dynamic surface topography.
+         */
+        bool
+        point_is_in_domain(const Point<dim> &point) const override;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is,
+         * which for a box is Cartesian.
+         */
+        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a box
+         * the results is unchanged and is (x,z) in 2d or (x,y,z) in 3d.
+         */
+        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A pointer to the initial topography model.
+         */
+        InitialTopographyModel::Interface<dim> *topo_model;
+
+        /**
+         * Extent of the box in x-, y-, and z-direction (in 3d).
+         */
+        Point<dim> extents;
+
+        /**
+         * Origin of the box in x, y, and z (in 3d) coordinates.
+         */
+        Point<dim> box_origin;
+
+        /**
+         * Flag whether the box is periodic in the x-, y-, and z-direction.
+         */
+        std::array<bool, dim> periodic;
+
+        /**
+         * The number of cells in each coordinate direction.
+         */
+        std::array<unsigned int, dim> repetitions;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/chunk.h.bak b/include/aspect/geometry_model/chunk.h.bak
new file mode 100644
index 00000000000..ed34f5801f3
--- /dev/null
+++ b/include/aspect/geometry_model/chunk.h.bak
@@ -0,0 +1,428 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_chunk_h
+#define _aspect_geometry_model_chunk_h
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/compat.h>
+
+#include <deal.II/grid/manifold.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/grid/grid_out.h>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    using namespace dealii;
+
+    namespace internal
+    {
+      /**
+       * ChunkGeometry is a class that implements the interface of
+       * ChartManifold. The function push_forward takes a point
+       * in the reference (radius,lon,lat) domain and transforms
+       * it into real space (cartesian). The inverse function
+       * pull_back reverses this operation.
+       * The push_forward_gradient provides derivatives of the
+       * reference coordinates to the real space coordinates,
+       * which are used in computing normal vectors.
+       * The transformations can include topography added
+       * to the initially radially symmetric mesh.
+       */
+      template <int dim>
+      class ChunkGeometry : public ChartManifold<dim,dim>
+      {
+        public:
+          /**
+           * Constructor
+           */
+          ChunkGeometry(const InitialTopographyModel::Interface<dim> &topography,
+                        const double min_longitude,
+                        const double min_radius,
+                        const double max_depth);
+
+          /**
+           * Copy constructor
+           */
+          ChunkGeometry(const ChunkGeometry &other) = default;
+
+          /**
+           * This function receives a point in cartesian coordinates x, y and z,
+           * including initial prescribed topography and returns
+           * radius, longitude, latitude without topography.
+           */
+          Point<dim>
+          pull_back(const Point<dim> &space_point) const override;
+
+          /**
+           * This function receives a point in spherical coordinates
+           * radius, longitude, latitude and returns cartesian
+           * coordinates x, y and z, including any initially prescribed
+           * topography.
+           */
+          Point<dim>
+          push_forward(const Point<dim> &chart_point) const override;
+
+          /**
+           * This function provides the derivatives of the push_forward
+           * function to the spherical coordinates, which are needed
+           * in the computation of vectors tangential to the domain boundaries.
+           */
+          DerivativeForm<1, dim, dim>
+          push_forward_gradient(const Point<dim> &chart_point) const override;
+
+          /**
+           * This function receives a point in cartesian coordinates x, y and z,
+           * and returns radius, longitude, latitude.
+           */
+          Point<dim>
+          pull_back_sphere(const Point<dim> &space_point) const;
+
+          /**
+           * This function receives a point in spherical coordinates
+           * radius, longitude, latitude and returns cartesian
+           * coordinates x, y and z.
+           */
+          Point<dim>
+          push_forward_sphere(const Point<dim> &chart_point) const;
+
+          /**
+           * Return the (normalized) normal vector at the point @p p.
+           */
+          virtual Tensor<1, dim>
+          normal_vector(
+            const typename Triangulation<dim>::face_iterator &face,
+            const Point<dim> &p) const override;
+
+          /**
+           * This function computes the outer radius of the domain
+           * at the longitude (and latitude) of the given point
+           * (given in cartesian coordinates), i.e. the unperturbed
+           * outer radius + the topography.
+           */
+          double
+          get_radius(const Point<dim> &space_point) const;
+
+          /**
+           * Return a copy of this manifold.
+           */
+          std::unique_ptr<Manifold<dim,dim>>
+          clone() const override;
+
+        private:
+          /**
+           * A pointer to the topography model.
+           */
+          const InitialTopographyModel::Interface<dim> *topo;
+
+          /**
+           * The minimum longitude of the domain.
+           */
+          double point1_lon;
+
+          /**
+           * The inner radius of the domain.
+           */
+          double inner_radius;
+
+          /**
+           * The maximum depth not taking into account
+           * topography (outer radius minus inner radius).
+           */
+          double max_depth;
+
+          /**
+           * This function removes the initial topography from a
+           * given point in spherical coordinates R+topo, lon, lat.
+           * I.e. it returns R, lon, lat.
+           */
+          virtual
+          Point<dim>
+          pull_back_topo(const Point<dim> &space_point) const;
+
+          /**
+           * This function adds the initial topography to a
+           * given point in spherical coordinates R, lon, lat.
+           * I.e. it returns R+topo, lon, lat.
+           */
+          virtual
+          Point<dim>
+          push_forward_topo(const Point<dim> &chart_point) const;
+      };
+    }
+
+    /**
+     * A geometry model class that describes a chunk of a spherical shell.
+     * In 2D, this class simulates a sector with inner and outer radius, and
+     * minimum and maximum longitude. Longitude increases anticlockwise
+     * from the positive x-axis, as per the mathematical convention of phi.
+     * In 3D, the class simulates a chunk of a sphere, bounded by arbitrary
+     * lines of longitude, latitude and radius. Boundary indicator names are
+     * west, east, south, north, inner and outer.
+     *
+     * The parameters that describe this geometry and that are read from the
+     * input file are the inner and outer radii of the shell, the minimum
+     * and maximum longitude, minimum and maximum longitude, and the
+     * number of cells initialized in each dimension.
+     *
+     * Initial topography can be added through a radial displacement of the
+     * mesh nodes.
+     */
+    template <int dim>
+    class Chunk : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run and after
+         * the SimulatorAccess (if applicable) is initialized.
+         * This function calls the initialize function of the manifold
+         * with a pointer to the initial topography model obtained
+         * from SimulatorAccess.
+         */
+        void initialize () override;
+
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         */
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
+
+
+        /**
+         * Return the set of boundary indicators that are used by this model.
+         * This information is used to determine what boundary indicators can
+         * be used in the input file.
+         *
+         * The chunk model uses boundary indicators zero through 2*dim-1, with
+         * the first two being the faces perpendicular to the radius of the shell,
+         * the next two along lines of longitude and, in 3d, the next two
+         * along lines of latitude.
+         */
+        std::set<types::boundary_id>
+        get_used_boundary_indicators () const override;
+
+        /**
+         * Return a mapping from symbolic names of each part of the boundary
+         * to the corresponding boundary indicator. This allows users to
+         * specify *names*, not just *numbers* in their input files when
+         * describing which parts of the boundary have to satisfy which
+         * boundary conditions.
+         *
+         * This geometry returns the map <code>{{"bottom"->0}, {"top"->1},
+         * {"west"->2}, {"east"->3}}</code> in 2d, and <code>{{"bottom"->0},
+         * {"top"->1}, {"west"->2}, {"east"->3}, {"south"->4},
+         * {"north"->5}}</code> in 3d.
+         */
+        std::map<std::string,types::boundary_id>
+        get_symbolic_boundary_names_map () const override;
+
+
+        /**
+         * Return the typical length scale one would expect of features in
+         * this geometry, assuming realistic parameters.
+         *
+         * As described in the first ASPECT paper, a length scale of
+         * 10km = 1e4m works well for the pressure scaling for earth
+         * sized spherical shells. use a length scale that
+         * yields this value for the R0,R1 corresponding to earth
+         * but otherwise scales like (R1-R0)
+         */
+        double length_scale () const override;
+
+        /**
+         * Return the depth that corresponds to the given
+         * position. The documentation of the base class (see
+         * GeometryModel::Interface::depth()) describes in detail how
+         * "depth" is interpreted in general.
+         *
+         * Computing a depth requires a geometry model to define a
+         * "vertical" direction. The current class considers the
+         * radial vector away from the origin as vertical and
+         * considers the "top" boundary as the surface. In almost
+         * all cases one will use a gravity model that also matches
+         * these definitions.
+         */
+        double depth(const Point<dim> &position) const override;
+
+        /**
+         * Return the height of the given position relative to the outer
+         * radius.
+         */
+        double height_above_reference_surface(const Point<dim> &position) const override;
+
+        /**
+         * @copydoc Interface::representative_point()
+         */
+        Point<dim> representative_point(const double depth) const override;
+
+        /**
+         * Return the longitude at the western edge of the chunk measured in
+         * radians.
+         */
+        virtual
+        double west_longitude() const;
+
+        /**
+         * Return the longitude at the eastern edge of the chunk measured in
+         * radians.
+         */
+        virtual
+        double east_longitude() const;
+
+        /**
+         * Return the longitude range of the chunk measured in radians.
+         */
+        virtual
+        double longitude_range() const;
+
+        /**
+         * Return the latitude at the southern edge of the chunk measured in
+         * radians from the equator.
+         */
+        virtual
+        double south_latitude() const;
+
+        /**
+         * Return the latitude at the northern edge of the chunk measured in
+         * radians from the equator.
+         */
+        virtual
+        double north_latitude() const;
+
+        /**
+         * Return the latitude range of the chunk measured in radians
+         */
+        virtual
+        double latitude_range() const;
+
+        /**
+         * Return the maximum depth from the surface of the model measured in
+         * meters.
+         */
+        double maximal_depth() const override;
+
+        /**
+         * Return the inner radius of the chunk measured in meters.
+         */
+        virtual
+        double inner_radius() const;
+
+        /**
+         * Return the outer radius of the chunk measured in meters.
+         */
+        virtual
+        double outer_radius() const;
+
+
+        /**
+         * @copydoc Interface::has_curved_elements()
+         *
+         * A chunk has curved boundaries and cells, so return true.
+         */
+        bool
+        has_curved_elements() const override;
+
+        /**
+         * Return whether the given point lies within the domain specified
+         * by the geometry. This function does not take into account
+         * initial or dynamic surface topography.
+         */
+        bool
+        point_is_in_domain(const Point<dim> &point) const override;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is,
+         * which for a chunk is Spherical.
+         */
+        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a chunk
+         * this is (radius, longitude) in 2d and (radius, longitude, latitude) in 3d.
+         */
+        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Minimum longitude-depth or
+         * longitude-latitude-depth point
+         */
+        Point<dim> point1;
+
+        /**
+         * Maximum longitude-depth or
+         * longitude-latitude-depth point
+         */
+        Point<dim> point2;
+
+        /**
+         * The number of cells in each coordinate direction
+         */
+        std::array<unsigned int, dim> repetitions;
+
+        /**
+         * An object that describes the geometry. This pointer is
+         * initialized in the initialize() function, and serves as the manifold
+         * object that the triangulation is later given in create_coarse_mesh()
+         * where the triangulation clones it.
+         *
+         * The object is marked as 'const' to make it clear that it should not
+         * be modified once created. That is because the triangulation copies it,
+         * and modifying the current object will not have any impact on the
+         * manifold used by the triangulation.
+         */
+        std::unique_ptr<const internal::ChunkGeometry<dim>> manifold;
+
+        /**
+         * Give a symbolic name to the manifold id to be used by this class.
+         */
+        static const types::manifold_id my_manifold_id = 15;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/ellipsoidal_chunk.h.bak b/include/aspect/geometry_model/ellipsoidal_chunk.h.bak
new file mode 100644
index 00000000000..516162ddfad
--- /dev/null
+++ b/include/aspect/geometry_model/ellipsoidal_chunk.h.bak
@@ -0,0 +1,346 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_ellipsoidal_chunk_h
+#define _aspect_geometry_model_ellipsoidal_chunk_h
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <deal.II/grid/manifold.h>
+
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    using namespace dealii;
+
+    namespace internal
+    {
+      /**
+       * A class which describes the manifold.
+       */
+      template <int dim>
+      class EllipsoidalChunkGeometry : public ChartManifold<dim,3,3>
+      {
+        public:
+          /**
+           * Constructor
+           */
+          EllipsoidalChunkGeometry(const InitialTopographyModel::Interface<dim> &topography,
+                                   const double para_semi_major_axis_a,
+                                   const double para_eccentricity,
+                                   const double para_semi_minor_axis_b,
+                                   const double para_bottom_depth,
+                                   const std::vector<Point<2>> &para_corners);
+
+          /**
+           * Copy constructor
+           */
+          EllipsoidalChunkGeometry(const EllipsoidalChunkGeometry &other) = default;
+
+          /**
+           * The deal.ii pull back function in 3d. This function receives
+           * cartesian points x,y and z and returns spherical/ellipsoidal
+           * coordinates phi, theta and depth, also accounting for the
+           * topography.
+           */
+          Point<3>
+          pull_back(const Point<3> &space_point) const override;
+
+          /**
+           * The deal.ii pull back function in 2d. This function should
+           * not be used, until the TODO in the cc file has been fixed.
+           */
+          virtual
+          Point<2>
+          pull_back(const Point<2> &space_point) const;
+
+          /**
+           * The deal.ii push forward function in 3d. This function receives
+           * spherical/ellipsoidal coordinates phi, theta and depth and
+           * returns cartesian points x,y and z, also accounting for the
+           * topography.
+           */
+          Point<3>
+          push_forward(const Point<3> &chart_point) const override;
+
+          /**
+           * This function does the actual pull back from the ellipsoid.
+           * For the equation details, please see deal.ii step 53.
+           */
+          Point<3> pull_back_ellipsoid (const Point<3> &x, const double semi_major_axis_a, const double eccentricity) const;
+
+          /**
+           * This function does the actual push forward to the ellipsoid.
+           * For the equation details, please see deal.ii step 53.
+           */
+          Point<3> push_forward_ellipsoid (const Point<3> &phi_theta_d, const double semi_major_axis_a, const double eccentricity) const;
+
+          /**
+           * Return a copy of this manifold.
+           */
+          std::unique_ptr<Manifold<dim,3>>
+          clone() const override;
+
+        private:
+          /**
+           * This function adds topography to the cartesian coordinates.
+           * For the equation details, please see deal.ii step 53.
+           */
+          Point<3> push_forward_topography (const Point<3> &phi_theta_d_hat) const;
+
+          /**
+           * This function removes topography from the cartesian coordinates.
+           * For the equation details, please see deal.ii step 53.
+           */
+          Point<3> pull_back_topography (const Point<3> &phi_theta_d) const;
+
+          /**
+           * A pointer to the topography model.
+           */
+          const InitialTopographyModel::Interface<dim> *topography;
+
+          const double semi_major_axis_a;
+          const double eccentricity;
+          const double semi_minor_axis_b;
+          const double bottom_depth;
+          const std::vector<Point<2>> corners;
+      };
+    }
+
+    /**
+     * A class that describes a geometry for an ellipsoid such as the WGS84 model of the earth.
+     *
+     * This geometry model implements a (3d) ellipsoidal chunk geometry where two of the axis have
+     * the same length. The ellipsoidal chunk can be a non-coordinate parallel part of the ellipsoid.
+     *
+     * @author This plugin is a joined effort of Menno Fraters, D. Sarah Stamps and Wolfgang Bangerth
+     */
+    template <int dim>
+    class EllipsoidalChunk : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialize function
+         */
+        void
+        initialize () override;
+
+
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         */
+        void
+        create_coarse_mesh(parallel::distributed::Triangulation<dim> &coarse_grid) const override;
+
+        /**
+         * Return the typical length scale one would expect of features in this geometry,
+         * assuming realistic parameters.
+         */
+        double
+        length_scale() const override;
+
+        /**
+         * Return the depth that corresponds to the given
+         * position. The documentation of the base class (see
+         * GeometryModel::Interface::depth()) describes in detail how
+         * "depth" is interpreted in general.
+         *
+         * Computing a depth requires a geometry model to define a
+         * "vertical" direction. The current class considers the
+         * radial vector away from the origin as vertical and
+         * considers the "outer" boundary as the "surface". In almost
+         * all cases one will use a gravity model that also matches
+         * these definitions.
+         */
+        double
+        depth(const Point<dim> &position) const override;
+
+        /**
+         * Placeholder for a function returning the height of the given
+         * position relative to the reference model surface.
+         */
+        double
+        height_above_reference_surface(const Point<dim> &position) const override;
+
+        /**
+         * Returns a point in the center of the domain.
+         */
+        Point<dim>
+        representative_point(const double depth) const override;
+
+        /**
+         * Return whether the given point lies within the domain specified
+         * by the geometry. This function does not take into account
+         * initial or dynamic surface topography.
+         */
+        bool
+        point_is_in_domain(const Point<dim> &point) const override;
+
+        /**
+         * Returns the bottom depth which was used to create the geometry and
+         * which is defined by the depth parameter.
+         */
+        double
+        maximal_depth() const override;
+
+        /**
+         * Return the set of boundary indicators that are used by this model. This
+         * information is used to determine what boundary indicators can be used in
+         * the input file.
+         *
+         * The box model uses boundary indicators zero through 2*dim-1, with the first
+         * two being the faces perpendicular to the x-axis, the next two perpendicular
+         * to the y-axis, etc.
+         */
+        std::set<types::boundary_id>
+        get_used_boundary_indicators() const override;
+
+        /**
+         * Set symbolic names for boundaries (mrtf)
+         */
+        std::map<std::string,types::boundary_id>
+        get_symbolic_boundary_names_map() const override;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is,
+         * which for a Ellipsoidal chunk is Ellipsoidal.
+         */
+        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a
+         * ellipsoidal chunk this is (radius, longitude) in 2d and (radius,
+         * longitude, latitude) in 3d. Note that internally the coordinates are
+         * stored in longitude, latitude, depth.
+         */
+        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters(ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter
+         * file.
+         */
+        void
+        parse_parameters(ParameterHandler &prm) override;
+
+        /**
+         * Calculate radius at current position.
+         */
+        double
+        get_radius(const Point<dim> &position) const;
+
+        /**
+         * Retrieve the semi minor axis b value.
+         */
+        double
+        get_semi_minor_axis_b() const;
+
+        /**
+         * Retrieve the semi major axis a value.
+         */
+        double
+        get_semi_major_axis_a() const;
+
+
+        /**
+         * Retrieve the value of the eccentricity.
+         */
+        double
+        get_eccentricity() const;
+
+
+        /**
+         * Retrieve the corners used to create the ellipsoid. This variable
+         * contains four vectors with each two elements. Each set of two
+         * elements represents a longitude and latitude value. The four
+         * vectors represent respectively the point in the North-East,
+         * North-West, South-West and South-East.
+         */
+        const std::vector<Point<2>> &
+        get_corners() const;
+
+
+        /**
+         * Retrieve the manifold object.
+         */
+        internal::EllipsoidalChunkGeometry<dim>
+        get_manifold() const;
+
+      private:
+        // Declare variables for reading in coordinates of the region of interest.
+        std::vector<Point<2>> corners;
+        double semi_major_axis_a;
+        double eccentricity;
+        double semi_minor_axis_b;
+        double rot_para_to_para_angle;
+        double para_to_rect_angle;
+        double rotation_longitude;
+        double rotation_latitude;
+        double bottom_depth;
+        double westLongitude;
+        double eastLongitude;
+        double northLatitude;
+        double southLatitude;
+        // Declare variables for subdividing
+        unsigned int EW_subdiv;
+        unsigned int NS_subdiv;
+        unsigned int depth_subdiv;
+
+
+
+        /**
+         * An object that describes the geometry. This pointer is
+         * initialized in the initialize() function, and serves as the manifold
+         * object that the triangulation is later given in create_coarse_mesh()
+         * where the triangulation clones it.
+         *
+         * The object is marked as 'const' to make it clear that it should not
+         * be modified once created. That is because the triangulation copies it,
+         * and modifying the current object will not have any impact on the
+         * manifold used by the triangulation.
+         */
+        std::unique_ptr<const internal::EllipsoidalChunkGeometry<dim>>   manifold;
+
+        void
+        set_boundary_ids(parallel::distributed::Triangulation<dim> &coarse_grid) const;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/ascii_data.h.bak b/include/aspect/geometry_model/initial_topography_model/ascii_data.h.bak
new file mode 100644
index 00000000000..8481e1c29e7
--- /dev/null
+++ b/include/aspect/geometry_model/initial_topography_model/ascii_data.h.bak
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_initial_topography_model_ascii_data_h
+#define _aspect_geometry_model_initial_topography_model_ascii_data_h
+
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements topography determined
+     * from an AsciiData input file.
+     *
+     * @ingroup InitialTopographyModel
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Sets the boundary id of the surface boundary.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataBoundary<dim>::initialize;
+
+
+        /**
+         * Return the surface topography as a function of position along the surface.
+         * For the current class, this function returns a value from the text files.
+         *
+         * @copydoc aspect::InitialTopographyModel::Interface::value()
+         */
+        double
+        value (const Point<dim-1> &surface_point) const override;
+
+        /**
+         * Return the maximum value of the elevation.
+         */
+        double max_topography () const override;
+
+        /**
+         * Return the gradient of the surface topography for a given position
+         * along the surface.
+         */
+        Tensor<1,dim-1>
+        vector_gradient(const Point<dim> &p) const;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        types::boundary_id surface_boundary_id;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/function.h.bak b/include/aspect/geometry_model/initial_topography_model/function.h.bak
new file mode 100644
index 00000000000..7b7421e0e00
--- /dev/null
+++ b/include/aspect/geometry_model/initial_topography_model/function.h.bak
@@ -0,0 +1,93 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_initial_topography_model_function_h
+#define _aspect_geometry_model_initial_topography_model_function_h
+
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements initial topography based
+     * on a user-defined function..
+     *
+     * @ingroup InitialTopographyModels
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Function ();
+
+        /**
+         * Return the value of the initial topography as a function
+         * of surface position.
+         */
+        double
+        value (const Point<dim-1> &p) const override;
+
+        /**
+         * Return the maximum value of the elevation.
+         */
+        double max_topography () const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * The maximum value the topography can take.
+         */
+        double max_topo;
+
+        /**
+         * A function object representing the topography.
+         */
+        Functions::ParsedFunction<dim> initial_topography_function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/interface.h.bak b/include/aspect/geometry_model/initial_topography_model/interface.h.bak
new file mode 100644
index 00000000000..f964b77f585
--- /dev/null
+++ b/include/aspect/geometry_model/initial_topography_model/interface.h.bak
@@ -0,0 +1,163 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_initial_topography_model_interface_h
+#define _aspect_geometry_model_initial_topography_model_interface_h
+
+#include <aspect/plugins.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/point.h>
+
+#include <set>
+
+
+namespace aspect
+{
+  /**
+   * A namespace for the definition of properties of the initial topography.
+   * This includes mainly the storage and retrieval of the initial topography.
+   * The retrieval is done through the value function, which requires a point
+   * of size dim-1, and it returns a double which represents the elevation.
+   *
+   * @ingroup InitialTopographyModels
+   */
+  namespace InitialTopographyModel
+  {
+    using namespace dealii;
+
+    /**
+     * Base class for classes that describe particular initial topographies
+     * for the domain.
+     *
+     * @ingroup InitialTopographyModels
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Return the value of the elevation at the given surface point.
+         *
+         * Note that different geometry models use different conventions for
+         * how they describe surface points. In general, the models use
+         * their own "natural" coordinate system. For example, box-type
+         * geometry models will generally provide points as x-y coordinates
+         * on the surface, whereas spherical-type geometry models will generally
+         * provide surface points in spherical coordinates.
+         */
+        virtual
+        double value (const Point<dim-1> &surface_point) const = 0;
+
+        /**
+         * Return the maximum value of the elevation.
+         */
+        virtual
+        double max_topography () const = 0;
+    };
+
+
+
+    /**
+     * Register a initial topography model so that it can be selected from the parameter
+     * file.
+     *
+     * @param name A string that identifies the initial topography model
+     * @param description A text description of what this model does and that
+     * will be listed in the documentation of the parameter file.
+     * @param declare_parameters_function A pointer to a function that can be
+     * used to declare the parameters that this initial topography model wants
+     * to read from input files.
+     * @param factory_function A pointer to a function that can create an
+     * object of this initial topography model.
+     *
+     * @ingroup InitialTopographyModels
+     */
+    template <int dim>
+    void
+    register_initial_topography_model (const std::string &name,
+                                       const std::string &description,
+                                       void (*declare_parameters_function) (ParameterHandler &),
+                                       std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+    /**
+     * A function that given the name of a model returns a pointer to an
+     * object that describes it. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The initial topography model will also be asked to read its runtime
+     * parameters already.
+     *
+     * @ingroup InitialTopographyModels
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_initial_topography_model (ParameterHandler &prm);
+
+
+    /**
+     * Declare the runtime parameters of the registered initial topography
+     * models.
+     *
+     * @ingroup InitialTopographyModels
+     */
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm);
+
+
+    /**
+     * For the current plugin subsystem, write a connection graph of all of the
+     * plugins we know about, in the format that the
+     * programs dot and neato understand. This allows for a visualization of
+     * how all of the plugins that ASPECT knows about are interconnected, and
+     * connect to other parts of the ASPECT code.
+     *
+     * @param output_stream The stream to write the output to.
+     */
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &output_stream);
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a initial topography model, register it with the functions that
+     * can declare their parameters and create these objects.
+     *
+     * @ingroup InitialTopographyModels
+     */
+#define ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::InitialTopographyModel::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::InitialTopographyModel::register_initial_topography_model<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::InitialTopographyModel::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::InitialTopographyModel::register_initial_topography_model<3>, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/prm_polygon.h.bak b/include/aspect/geometry_model/initial_topography_model/prm_polygon.h.bak
new file mode 100644
index 00000000000..51364d75e96
--- /dev/null
+++ b/include/aspect/geometry_model/initial_topography_model/prm_polygon.h.bak
@@ -0,0 +1,87 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_initial_topography_prm_polygon_h
+#define _aspect_geometry_model_initial_topography_prm_polygon_h
+
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+
+
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes an initial topography for the geometry model,
+     * by defining a set of polygons on the surface from the prm file. It
+     * sets the elevation in each polygon to a constant value.
+     */
+    template <int dim>
+    class PrmPolygon : public Interface<dim>
+    {
+      public:
+        /**
+         * Return the value of the topography for a point.
+         */
+        double value (const Point<dim-1> &p) const override;
+
+        /**
+         * Return the maximum value of the elevation.
+         */
+        double max_topography () const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The values of the topography are stored in a vector.
+         */
+        std::vector<double> topography_values;
+
+        /**
+         * The maximum topography in this model
+         */
+        double maximum_topography;
+
+        /**
+         * The polygons and their points are stored in this vector.
+         */
+        std::vector<std::vector<Point<2>>> point_lists;
+
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/zero_topography.h.bak b/include/aspect/geometry_model/initial_topography_model/zero_topography.h.bak
new file mode 100644
index 00000000000..ce4fad60819
--- /dev/null
+++ b/include/aspect/geometry_model/initial_topography_model/zero_topography.h.bak
@@ -0,0 +1,60 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_initial_topography_model_zero_topography_h
+#define _aspect_geometry_model_initial_topography_model_zero_topography_h
+
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements zero initial topography.
+     *
+     * @ingroup InitialTopographyModels
+     */
+    template <int dim>
+    class ZeroTopography : public Interface<dim>
+    {
+      public:
+        /**
+         * Return the value of the initial topography as a function of position.
+         *
+         * For the current class, this function obviously simply returns a zero
+         * value.
+         */
+        double
+        value (const Point<dim-1> &p) const override;
+
+        /**
+         * Return the maximum value of the elevation.
+         */
+        double max_topography () const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/interface.h.bak b/include/aspect/geometry_model/interface.h.bak
new file mode 100644
index 00000000000..a5ca7653044
--- /dev/null
+++ b/include/aspect/geometry_model/interface.h.bak
@@ -0,0 +1,447 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_interface_h
+#define _aspect_geometry_model_interface_h
+
+#include <aspect/plugins.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/distributed/tria.h>
+#include <array>
+#include <aspect/utilities.h>
+#include <aspect/coordinate_systems.h>
+
+#include <set>
+
+
+namespace aspect
+{
+  /**
+   * A namespace for the definition of properties of the geometry. This
+   * primarily includes the definition of the shape of the domain (e.g.
+   * whether it is a full spherical shell, a quadrant/octant, a description of
+   * the geoid, etc. The classes and functions of this namespace also describe
+   * which kinds of boundary conditions hold on the different parts of the
+   * boundary of the geometry.
+   *
+   * @ingroup GeometryModels
+   */
+  namespace GeometryModel
+  {
+    using namespace dealii;
+
+    /**
+     * Base class for classes that describe particular geometries for the
+     * domain. These classes must also be able to create coarse meshes and
+     * describe what kinds of boundary conditions hold where.
+     *
+     * @ingroup GeometryModels
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         */
+        virtual
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const = 0;
+
+        /**
+         * Return the typical length scale one would expect of features in
+         * this geometry, assuming realistic parameters.
+         *
+         * The result of this function is used in computing the scaling factor
+         * for the pressure in the Stokes equation. There, the scaling factor
+         * is chosen as the ratio of the reference viscosity divided by the
+         * length scale. As an example, in the step-32 tutorial program we
+         * have determined that a suitable length scale for scaling is 10km,
+         * in a domain that is 12,000km across. This length scale suitably
+         * matches the order of magnitude for the diameter of plumes in the
+         * earth.
+         */
+        virtual
+        double length_scale () const = 0;
+
+        /**
+         * Return the depth that corresponds to the given position. The
+         * returned value is between 0 and maximal_depth(), where points
+         * with a zero depth correspond to the "surface" of the model.
+         *
+         * Computing a depth requires a geometry model to define a
+         * "vertical" direction. For example, the Box model considers
+         * the $(0,1)^T$ vector in 2d (and the $(0,0,1)^T$ vector in
+         * 3d) as vertical and considers the "top" boundary as the
+         * "surface". Similarly, the spherical shell takes the radial
+         * vector as "vertical" and the outer boundary as "surface".
+         * In most cases, how geometry models define "vertical" and
+         * "surface" will be intuitive and obvious. In almost all
+         * cases one will use a gravity model that also matches these
+         * definitions.
+         *
+         * @note Implementations of this function in derived classes can
+         * only compute the depth with regard to the <i>reference
+         * configuration</i> of the geometry, i.e., the geometry initially
+         * created. If you are using a dynamic topography in your models
+         * that changes in every time step, or if you apply initial
+         * topography to your model, then the <i>actual</i> depth
+         * of a point with regard to this dynamic topography will not
+         * match the value this function returns. This is so because
+         * computing the actual depth is difficult: In parallel computations,
+         * the processor on which you want to evaluate the depth of a point
+         * may know nothing about the displacement of the surface anywhere
+         * if it happens to store only interior cells. Furthermore, it is
+         * not even clear what "depth" one would compute in such situations:
+         * The distance to the closest surface point? The vertical distance
+         * to the surface point directly above? Or the length of the line
+         * from the given point to a surface point that is locally always
+         * parallel to the gravity vector? For all of these reasons, this
+         * function simply returns the geometric vertical depth of a point
+         * in the known and fixed reference geometry, to the reference
+         * surface that defines what zero depth is.
+         */
+        virtual
+        double depth(const Point<dim> &position) const = 0;
+
+        /**
+         * Return the height of the given position relative to the reference
+         * surface of the model. Positive returned value means that the point
+         * is above (i.e., farther from the center of the model) the reference
+         * surface, negative value means that the point is below the the
+         * reference surface.
+         *
+         * Same limitations as for the depth function, apply here.
+         */
+        virtual
+        double height_above_reference_surface(const Point<dim> &position) const = 0;
+
+        /**
+         * Converts a Cartesian Point into another coordinate system and returns it
+         * as a NaturalCoordinate.
+         */
+
+        Utilities::NaturalCoordinate<dim>
+        cartesian_to_other_coordinates(const Point<dim> &position,
+                                       const Utilities::Coordinates::CoordinateSystem &coordinate_system) const;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is.
+         */
+        virtual
+        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const = 0;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a box
+         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
+         * model it  will be (radius, longitude) in 2d and (radius, longitude,
+         * latitude) in 3d.
+         */
+        virtual
+        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        virtual
+        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const;
+
+        /**
+         * Returns a representative point for a given depth. Such a point must
+         * lie inside the domain for sure (assuming the given depth is valid),
+         * but it is not important where exactly in the domain it is. A good
+         * choice would be on a middle axis, for example.
+         *
+         * The function is used, for example, in computing an initial
+         * adiabatic profile. For this, we need to be able to query the
+         * density as a function of (adiabatic) pressure and temperature.
+         * However, the functions returning the density from the material
+         * model also depend on location. Since we are interested only in
+         * computing a depth-dependent adiabatic profile without lateral
+         * variation, we need to be able to query the density at
+         * "representative points" at given depths, without caring too much
+         * where exactly that is -- but at points that we know for sure are
+         * inside the domain.
+         */
+        virtual
+        Point<dim> representative_point(const double depth) const = 0;
+
+        /**
+         * Returns the maximal depth of this geometry. For a definition of
+         * how "depth" is to be interpreted, see the documentation of the
+         * depth() member function. In particular, the maximal depth of a
+         * geometry model only represents the depth computed with regard
+         * to some reference configuration, ignoring any dynamic or initial
+         * topography.
+         */
+        virtual
+        double maximal_depth() const = 0;
+
+
+        /**
+         * Return the set of boundary indicators that are used by this model.
+         * This information is used to determine what boundary indicators can
+         * be used in the input file.
+         */
+        virtual
+        std::set<types::boundary_id>
+        get_used_boundary_indicators () const = 0;
+
+        /**
+         * Return a mapping from symbolic names of each part of the boundary
+         * to the corresponding boundary indicator. This allows users to
+         * specify *names*, not just *numbers* in their input files when
+         * describing which parts of the boundary have to satisfy which
+         * boundary conditions.
+         *
+         * An example would be that the "box" geometry returns a map of the
+         * form <code>{{"left"->0}, {"right"->1}, {"bottom"->2},
+         * {"top"->3}}</code> in 2d.
+         *
+         * The default implementation of this function returns an empty map.
+         * This still allows the use of a geometry model that does not
+         * implement this function but forces the user to identify parts of
+         * the boundary by their boundary indicator number, rather than using
+         * a symbolic name.
+         *
+         * @note Names may contain spaces and numbers, but they may not
+         * contain special characters and they should not equal the text
+         * representation of numbers (e.g., a name "10" is ill-advised).
+         *
+         * @note Since in practice boundary indicators can be provided either
+         * via number or symbolic name, the mapping from something given in
+         * the input is not entirely trivial -- in particular, because a
+         * function also has to do some error checking that a given string in
+         * fact matches any known boundary indicator. To this end, use
+         * GeometryModel::translate_boundary_indicator() and
+         * GeometryModel::translate_boundary_indicators().
+         *
+         * @return A map from symbolic names to boundary indicators. The map
+         * should provide a symbolic name for each used boundary indicator as
+         * returned by get_user_boundary_indicators(). In the end, however, a
+         * geometry model may define multiple symbolic names for the same
+         * boundary or not define any.
+         */
+        virtual
+        std::map<std::string,types::boundary_id>
+        get_symbolic_boundary_names_map () const;
+
+        /**
+         * For a given name of a boundary component, translate it to its
+         * numeric value -- either by using one of the symbolic values in the
+         * mapping that derived classes provide through the
+         * get_symbolic_boundary_names_map() function, or by converting its
+         * string representation into a number.
+         *
+         * @param name A name or number (as string). Leading and trailing
+         * spaces are removed from this string.
+         * @return A boundary indicator number corresponding to the given
+         * name. If the name does not represent either a symbolic name or a
+         * number, this function will throw an exception of type std::string
+         * that explains the error.
+         */
+        types::boundary_id
+        translate_symbolic_boundary_name_to_id (const std::string &name) const;
+
+        /**
+         * For each one of the given names of boundary components, translate
+         * it to its numeric value -- either by using one of the symbolic
+         * values in the mapping that derived classes provide through the
+         * get_symbolic_boundary_names_map() function, or by converting its
+         * string representation into a number.
+         *
+         * @param names A list of names or numbers (as strings). Leading and
+         * trailing spaces are removed from the strings.
+         * @return A list of boundary indicator numbers corresponding to the
+         * given list of names. If one of the given names does not represent
+         * either a symbolic name or a number, this function will throw an
+         * exception of type std::string that explains the error.
+         */
+        std::vector<types::boundary_id>
+        translate_symbolic_boundary_names_to_ids (const std::vector<std::string> &names) const;
+
+        /**
+         * Given a boundary indicator, try and see whether this geometry model
+         * provides a symbolic name for it. If the geometry model does not
+         * provide a symbolic name, return the empty string.
+         *
+         * @param boundary_id The boundary indicator to be translated.
+         * @return A string representation for this boundary indicator, if one
+         * is available.
+         */
+        std::string
+        translate_id_to_symbol_name (const types::boundary_id boundary_id) const;
+
+        /**
+         * Returns a set of periodic boundary pairs.  The elements of the set
+         * are a pair of boundary ids and a cartesian unit direction each. The
+         * base class returns an empty set, so this does nothing unless you
+         * specifically use a geometry model with periodic boundary conditions
+         */
+        virtual
+        std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
+        get_periodic_boundary_pairs () const;
+
+        /**
+         * Adjust positions to be inside the domain considering periodic boundary conditions.
+         *
+         * This function checks if @p position is outside the domain and if it could
+         * have reasonably crossed a periodic boundary. If so, it will adjust the position
+         * as described by the periodic boundary (e.g. a translation in a box, or a rotation
+         * in a spherical shell). Afterwards, if it adjusted @p position, it will also adjust
+         * all locations given in @p connected_positions (if any where given) and all
+         * velocities given in @p connected_velocities in the same way.
+         * Adjusting both of these allows to adjust related temporary variables,
+         * e.g. the intermediate results of an ordinary differential equation solver
+         * that are used to compute differences/directions between points. The reason
+         * positions and velocities have to be treated separately is that some geometries
+         * have to adjust them differently across a periodic boundary, e.g. a box has
+         * to translate positions but not velocities, while a spherical shell has to
+         * translate positions (by rotation around the center) and rotate velocities.
+         *
+         * This function does not check that the position after the adjustment is inside the
+         * domain; to check this is the responsibility of the calling function.
+         * A common application of this function are particles that crossed a periodic boundary.
+         */
+        virtual
+        void
+        adjust_positions_for_periodicity (Point<dim> &position,
+                                          const ArrayView<Point<dim>> &connected_positions = {},
+                                          const ArrayView<Tensor<1,dim>> &connected_velocities = {}) const;
+
+        /**
+         * If true, the geometry contains cells with boundaries that are not
+         * straight and have a deal.II boundary object attached to it. If the
+         * return value is @p false, certain operation can be optimized.The
+         * default implementation of this function will return @p true.
+         */
+        virtual
+        bool
+        has_curved_elements() const;
+
+        /**
+         * If true, the queried point (in Cartesian coordinates)
+         * lies in the domain specified by the geometry.
+         */
+        virtual
+        bool
+        point_is_in_domain(const Point<dim> &p) const = 0;
+
+        /**
+         * Collects periodic boundary constraints for the given geometry
+         * and @p dof_handler, which will be added to the existing @p constraints.
+         * The default implementation creates cartesian periodic boundary conditions
+         * for all periodic boundary indicators.
+         */
+        virtual
+        void
+        make_periodicity_constraints(const DoFHandler<dim> &dof_handler,
+                                     AffineConstraints<double> &constraints) const;
+    };
+
+
+
+    /**
+     * Register a geometry model so that it can be selected from the parameter
+     * file.
+     *
+     * @param name A string that identifies the geometry model
+     * @param description A text description of what this model does and that
+     * will be listed in the documentation of the parameter file.
+     * @param declare_parameters_function A pointer to a function that can be
+     * used to declare the parameters that this geometry model wants to read
+     * from input files.
+     * @param factory_function A pointer to a function that can create an
+     * object of this geometry model.
+     *
+     * @ingroup GeometryModels
+     */
+    template <int dim>
+    void
+    register_geometry_model (const std::string &name,
+                             const std::string &description,
+                             void (*declare_parameters_function) (ParameterHandler &),
+                             std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+    /**
+     * A function that given the name of a model returns a pointer to an
+     * object that describes it. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The geometry model will also be asked to read its runtime parameters
+     * already.
+     *
+     * @ingroup GeometryModels
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_geometry_model (ParameterHandler &prm);
+
+    /**
+     * Declare the runtime parameters of the registered geometry models.
+     *
+     * @ingroup GeometryModels
+     */
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm);
+
+    /**
+     * For the current plugin subsystem, write a connection graph of all of the
+     * plugins we know about, in the format that the
+     * programs dot and neato understand. This allows for a visualization of
+     * how all of the plugins that ASPECT knows about are interconnected, and
+     * connect to other parts of the ASPECT code.
+     *
+     * @param output_stream The stream to write the output to.
+     */
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &output_stream);
+
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a geometry model, register it with the functions that can declare
+     * their parameters and create these objects.
+     *
+     * @ingroup GeometryModels
+     */
+#define ASPECT_REGISTER_GEOMETRY_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_GEOMETRY_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::GeometryModel::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::GeometryModel::register_geometry_model<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::GeometryModel::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::GeometryModel::register_geometry_model<3>, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/sphere.h.bak b/include/aspect/geometry_model/sphere.h.bak
new file mode 100644
index 00000000000..e3e51c74ed5
--- /dev/null
+++ b/include/aspect/geometry_model/sphere.h.bak
@@ -0,0 +1,164 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#ifndef _aspect_geometry_model_sphere_h
+#define _aspect_geometry_model_sphere_h
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class Sphere : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Sphere() = default;
+
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         */
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
+
+        /**
+         * Return the typical length scale one would expect of features in
+         * this geometry, assuming realistic parameters.
+         *
+         * As discussed in the step-32 tutorial program, an appropriate length
+         * scale for this geometry is 10km, so we return $10^4$ here.
+         */
+        double length_scale () const override;
+
+        /**
+         * Return the depth that corresponds to the given
+         * position. The documentation of the base class (see
+         * GeometryModel::Interface::depth()) describes in detail how
+         * "depth" is interpreted in general.
+         *
+         * Computing a depth requires a geometry model to define a
+         * "vertical" direction. The current class considers the
+         * radial vector away from the origin as vertical and
+         * considers the "outer" boundary as the "surface". In almost
+         * all cases one will use a gravity model that also matches
+         * these definitions.
+         */
+        double depth(const Point<dim> &position) const override;
+
+        /**
+         * Return the height of the given position relative to
+         * the radius of the sphere.
+         */
+        double height_above_reference_surface(const Point<dim> &position) const override;
+
+        /**
+         * @copydoc Interface<dim>::representative_point()
+         */
+        Point<dim> representative_point(const double depth) const override;
+
+        /**
+         * @copydoc Interface<dim>::maximal_depth()
+         */
+        double maximal_depth() const override;
+
+        /**
+         * Return the set of boundary indicators that are used by this model.
+         * This information is used to determine what boundary indicators can
+         * be used in the input file.
+         *
+         * The sphere model only has one boundary, with indicator zero.
+         */
+        std::set<types::boundary_id>
+        get_used_boundary_indicators () const override;
+
+        /**
+         * Return symbolic names for all boundary components. Their names are
+         * described in the documentation of this plugin, at the bottom of the
+         * .cc file.
+         */
+        std::map<std::string,types::boundary_id>
+        get_symbolic_boundary_names_map () const override;
+
+        /**
+         * @copydoc Interface::has_curved_elements()
+         *
+         * Return true because we have a curved boundary.
+         */
+        bool
+        has_curved_elements() const override;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is,
+         * which for a sphere is Spherical.
+         */
+        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
+
+        /**
+         * Return whether the given point lies within the domain specified
+         * by the geometry. This function does not take into account
+         * initial or dynamic surface topography.
+         */
+        bool
+        point_is_in_domain(const Point<dim> &point) const override;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a sphere
+         * this is (radius, longitude) in 2d and (radius, longitude, latitude) in 3d.
+         */
+        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
+
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Return the radius of the sphere.
+         */
+        double
+        radius () const;
+
+      private:
+        /**
+         * Radius of the sphere
+         */
+        double R;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/spherical_shell.h.bak b/include/aspect/geometry_model/spherical_shell.h.bak
new file mode 100644
index 00000000000..c2286088a31
--- /dev/null
+++ b/include/aspect/geometry_model/spherical_shell.h.bak
@@ -0,0 +1,454 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_spherical_shell_h
+#define _aspect_geometry_model_spherical_shell_h
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    using namespace dealii;
+
+    namespace internal
+    {
+      /**
+       * A description of a manifold that describes a spherical shell with overlaid
+       * topography.
+       */
+      template <int dim>
+      class SphericalManifoldWithTopography : public aspect::SphericalManifold<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          SphericalManifoldWithTopography(const InitialTopographyModel::Interface<dim> &topography,
+                                          const double inner_radius,
+                                          const double outer_radius);
+
+          /**
+           * Copy constructor.
+           */
+          SphericalManifoldWithTopography(const SphericalManifoldWithTopography<dim> &) = default;
+
+          /**
+           * Make a clone of this Manifold object.
+           */
+          virtual std::unique_ptr<Manifold<dim, dim>>
+          clone() const override;
+
+          /**
+           * Given a point in the undeformed spherical geometry, push it forward to the
+           * corresponding point in the sphere with surface topography.
+           */
+          Point<dim>
+          push_forward_from_sphere (const Point<dim> &p) const;
+
+          /**
+           * Given a point in the deformed spherical geometry with topography, pull it
+           * back to the corresponding point in the undeformed sphere.
+           */
+          Point<dim>
+          pull_back_to_sphere (const Point<dim> &p) const;
+
+          /**
+           * Given any two points in space, first project them on the surface
+           * of a sphere with unit radius, then connect them with a geodesic
+           * and find the intermediate point, and finally rescale the final
+           * radius so that the resulting one is the convex combination of the
+           * starting radii.
+           */
+          virtual Point<dim>
+          get_intermediate_point(const Point<dim> &p1,
+                                 const Point<dim> &p2,
+                                 const double      w) const override;
+
+          /**
+           * Compute the derivative of the get_intermediate_point() function
+           * with parameter w equal to zero.
+           */
+          virtual Tensor<1, dim>
+          get_tangent_vector(const Point<dim> &x1,
+                             const Point<dim> &x2) const override;
+
+          /**
+           * @copydoc Manifold::normal_vector()
+           *
+           * We fudge here, but for a good reason. What the function is supposed
+           * to compute is the normal vector to the surface. This *should* be the
+           * normal to the surface with topography, but instead we return the
+           * normal to the undeformed surface -- i.e., the radial direction. This
+           * is, in particular, used to compute no-flux boundary conditions,
+           * for which we want to impose a boundary
+           * condition that allows for plate-like motion -- that is, we need
+           * to allow *horizontal motion*, even if that is not tangential to
+           * the surface along the slopes of mountains or ocean trenches. Using
+           * the radial direction, i.e., the normal vector to the undeformed surface
+           * (= a radial vector) allows for exactly this.
+           */
+          virtual Tensor<1, dim>
+          normal_vector(
+            const typename Triangulation<dim, dim>::face_iterator &face,
+            const Point<dim> &p) const override;
+
+          /**
+           * Compute the normal vectors to the boundary at each vertex.
+           */
+          virtual void
+          get_normals_at_vertices(
+            const typename Triangulation<dim, dim>::face_iterator &face,
+            typename Manifold<dim, dim>::FaceVertexNormals &face_vertex_normals)
+          const override;
+
+
+          /**
+           * Compute a new set of points that interpolate between the given points @p
+           * surrounding_points. @p weights is a table with as many columns as @p
+           * surrounding_points.size(). The number of rows in @p weights must match
+           * the length of @p new_points.
+           *
+           * This function is optimized to perform on a collection
+           * of new points, by collecting operations that are not dependent on the
+           * weights outside of the loop over all new points.
+           *
+           * The implementation does not allow for @p surrounding_points and
+           * @p new_points to point to the same array, so make sure to pass different
+           * objects into the function.
+           */
+          virtual void
+          get_new_points(const ArrayView<const Point<dim>> &surrounding_points,
+                         const Table<2, double>                 &weights,
+                         ArrayView<Point<dim>> new_points) const override;
+
+          /**
+           * Return a point on the spherical manifold which is intermediate
+           * with respect to the surrounding points.
+           */
+          virtual Point<dim>
+          get_new_point(const ArrayView<const Point<dim>> &vertices,
+                        const ArrayView<const double>          &weights) const override;
+
+        private:
+          /**
+           * A pointer to the topography model.
+           */
+          const InitialTopographyModel::Interface<dim> *topo;
+
+          /**
+           * Inner and outer radii of the spherical shell.
+           */
+          const double R0, R1;
+
+          /**
+           * Return the topography of the surface directly above the point given
+           * by the coordinates stored in the argument.
+           */
+          double topography_for_point (const Point<dim> &x_y_z) const;
+      };
+
+    }
+
+    /**
+     * A class that describes the geometry as a spherical shell. To be more
+     * precise, at least in 2d this class can also simulate just a sector of
+     * the spherical shell geometry, in particular a half ring and a quarter
+     * ring.
+     *
+     * The parameters that describe this geometry and that are read from the
+     * input file are the inner and outer radii of the shell and the opening
+     * angle of the section of the shell we want to build.
+     */
+    template <int dim>
+    class SphericalShell : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        SphericalShell() = default;
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run and after
+         * the SimulatorAccess (if applicable) is initialized.
+         * This function calls the initialize function of the manifold
+         * with a pointer to the initial topography model obtained
+         * from SimulatorAccess.
+         */
+        void initialize () override;
+
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         */
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
+
+        /**
+         * Return the typical length scale one would expect of features in
+         * this geometry, assuming realistic parameters.
+         *
+         * As discussed in the step-32 tutorial program, an appropriate length
+         * scale for this geometry is 10km, so we return $10^4$ here.
+         */
+        double length_scale () const override;
+
+        /**
+         * Return the depth that corresponds to the given
+         * position. The documentation of the base class (see
+         * GeometryModel::Interface::depth()) describes in detail how
+         * "depth" is interpreted in general.
+         *
+         * Computing a depth requires a geometry model to define a
+         * "vertical" direction. The current class considers the
+         * radial vector away from the origin as vertical and
+         * considers the "outer" boundary as the "surface". In almost
+         * all cases one will use a gravity model that also matches
+         * these definitions.
+         */
+        double depth(const Point<dim> &position) const override;
+
+        /**
+         * Return the height of the given position relative to
+         * the outer radius of the shell.
+         */
+        double height_above_reference_surface(const Point<dim> &position) const override;
+
+        /**
+         * @copydoc Interface<dim>::representative_point()
+         */
+        Point<dim> representative_point(const double depth) const override;
+
+        /**
+         * @copydoc Interface<dim>::maximal_depth()
+         */
+        double maximal_depth() const override;
+
+        /**
+         * Return the set of boundary indicators that are used by this model.
+         * This information is used to determine what boundary indicators can
+         * be used in the input file.
+         *
+         * The spherical shell may be generated as per in the original code
+         * (with respect to the inner and outer radius, and an initial number
+         * of cells along circumference) or following a custom mesh scheme:
+         * list of radial values or number of slices. A surface mesh is first
+         * generated and refined as desired, before it is extruded radially.
+         * A list of radial values subdivides the spherical shell at specified
+         * radii. The number of slices subdivides the spherical shell into N
+         * slices of equal thickness. The custom spherical shell only works
+         * with an opening angle of 360 degrees.
+         *
+         * The spherical shell model uses boundary indicators zero and one,
+         * with zero corresponding to the inner surface and one corresponding
+         * to the outer surface. In 2d, if the geometry is only a slice of the
+         * shell, boundary indicators 2 and 3 indicate the left and right
+         * radial bounding lines.
+         */
+        std::set<types::boundary_id>
+        get_used_boundary_indicators () const override;
+
+        /**
+         * Return symbolic names for all boundary components. Their names are
+         * described in the documentation of this plugin, at the bottom of the
+         * .cc file.
+         */
+        std::map<std::string,types::boundary_id>
+        get_symbolic_boundary_names_map () const override;
+
+        /**
+         * Return the set of periodic boundaries as described in the input
+         * file.
+         */
+        std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
+        get_periodic_boundary_pairs () const override;
+
+        /**
+         * @copydoc Interface::adjust_positions_for_periodicity
+         *
+         * Apply a rotation to all points outside of the domain
+         * to account for periodicity.
+         */
+        void
+        adjust_positions_for_periodicity (Point<dim> &position,
+                                          const ArrayView<Point<dim>> &connected_positions = {},
+                                          const ArrayView<Tensor<1, dim>> &connected_velocities = {}) const override;
+
+        /**
+         * @copydoc Interface::has_curved_elements()
+         *
+         * Return true because we have a curved boundary.
+         */
+        bool
+        has_curved_elements() const override;
+
+        /**
+         * Return whether the given point lies within the domain specified
+         * by the geometry. This function does not take into account
+         * initial or dynamic surface topography.
+         */
+        bool
+        point_is_in_domain(const Point<dim> &point) const override;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is,
+         * which for a spherical shell is Spherical.
+         */
+        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a spherical shell
+         * this is (radius, longitude) in 2d and (radius, longitude, latitude) in 3d.
+         */
+        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
+
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Return the inner radius of the shell.
+         */
+        double
+        inner_radius () const;
+
+        /**
+         * Return the outer radius of the shell.
+         */
+        double
+        outer_radius () const;
+
+        /**
+         * Return the opening angle of the shell sector.
+         */
+        double
+        opening_angle () const;
+
+        /**
+         * Collects periodic boundaries constraints for the given geometry,
+         * which will be added to the existing @p constraints.
+         */
+        void
+        make_periodicity_constraints(const DoFHandler<dim> &dof_handler,
+                                     AffineConstraints<double> &constraints) const override;
+
+      private:
+        /**
+         * Specify the radial subdivision of the spherical shell
+         * mesh.
+         */
+        enum CustomMeshRadialSubdivision
+        {
+          none,
+          list,
+          slices
+        } custom_mesh;
+
+        /**
+         * Initial surface refinement for the custom mesh cases.
+         */
+        unsigned int initial_lateral_refinement;
+
+        /**
+         * Initial surface refinement for the custom mesh cases.
+         */
+        unsigned int n_slices;
+
+        /**
+         * List of radial values for the list custom mesh.
+         */
+        std::vector<double> R_values_list;
+
+        /**
+         * Inner and outer radii of the spherical shell.
+         */
+        double R0, R1;
+
+        /**
+         * Opening angle of the section of the shell that we simulate.
+         */
+        double phi;
+
+        /**
+         * Number of tangential mesh cells in the initial, coarse mesh.
+         */
+        int n_cells_along_circumference;
+
+        /**
+         * Set the manifold ids on all cells (also boundaries) before
+         * refinement to generate well shaped cells.
+         */
+        void set_manifold_ids (parallel::distributed::Triangulation<dim> &triangulation) const;
+
+        /**
+         * Flag whether the 2D quarter shell is periodic in phi.
+         */
+        bool periodic;
+
+        /**
+         * An object that describes the geometry. This pointer is
+         * initialized in the initialize() function, and serves as the manifold
+         * object that the triangulation is later given in create_coarse_mesh()
+         * where the triangulation clones it.
+         *
+         * The object is marked as 'const' to make it clear that it should not
+         * be modified once created. That is because the triangulation copies it,
+         * and modifying the current object will not have any impact on the
+         * manifold used by the triangulation.
+         */
+        std::unique_ptr<const internal::SphericalManifoldWithTopography<dim>> manifold;
+
+        /**
+         * Give a symbolic name to the manifold id to be used by this class.
+         */
+        static const types::manifold_id my_manifold_id = 99;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/two_merged_boxes.h.bak b/include/aspect/geometry_model/two_merged_boxes.h.bak
new file mode 100644
index 00000000000..bfcc53789fd
--- /dev/null
+++ b/include/aspect/geometry_model/two_merged_boxes.h.bak
@@ -0,0 +1,265 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_two_merged_boxes_h
+#define _aspect_geometry_model_two_merged_boxes_h
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes a box geometry of certain width, height, and
+     * depth (in 3d) and adds two (four in 3D) additional boundary indicators
+     * for the lithospheric part of the vertical boundaries.
+     */
+    template <int dim>
+    class TwoMergedBoxes : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         */
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
+
+        /**
+         * Return a point that denotes the size of the box in each dimension
+         * of the domain.
+         */
+        Point<dim> get_extents () const;
+
+        /**
+         * Return a point that denotes the lower left corner of the box
+         * domain.
+         */
+        Point<dim> get_origin () const;
+
+        /**
+         * Return the typical length scale one would expect of features in
+         * this geometry, assuming realistic parameters.
+         *
+         * We return 1/100th of the X extent of the box.
+         */
+        double length_scale () const override;
+
+        /**
+         * Return the depth that corresponds to the given
+         * position. The documentation of the base class (see
+         * GeometryModel::Interface::depth()) describes in detail how
+         * "depth" is interpreted in general.
+         *
+         * Computing a depth requires a geometry model to define a
+         * "vertical" direction. The current class considers the
+         * $(0,1)^T$ vector in 2d (and the $(0,0,1)^T$ vector in 3d)
+         * as vertical and considers the "top" boundary as the
+         * "surface". In almost all cases one will use a gravity model
+         * that also matches these definitions.
+         */
+        double depth(const Point<dim> &position) const override;
+
+        /**
+         * Return the height of the given position relative to
+         * the initial box height.
+         */
+        double height_above_reference_surface(const Point<dim> &position) const override;
+
+        /**
+         * @copydoc Interface<dim>::representative_point()
+         */
+        Point<dim> representative_point(const double depth) const override;
+
+        /**
+         * @copydoc Interface<dim>::maximal_depth()
+         */
+        double maximal_depth() const override;
+
+        /**
+         * Return the set of boundary indicators that are used by this model.
+         * This information is used to determine what boundary indicators can
+         * be used in the input file.
+         *
+         * This box model uses boundary indicators zero through 2*dim+2*(dim-1)-1, with
+         * the first two being the faces perpendicular to the x-axis and the next
+         * two perpendicular to the y-axis. In 2D, the next two are perpendicular to
+         * the x-axis again. In 3D, two sets of two
+         * are added for the boundaries parallel to the z-axis.
+         */
+        std::set<types::boundary_id>
+        get_used_boundary_indicators () const override;
+
+        /**
+         * Return a mapping from symbolic names of each part of the boundary
+         * to the corresponding boundary indicator. This allows users to
+         * specify *names*, not just *numbers* in their input files when
+         * describing which parts of the boundary have to satisfy which
+         * boundary conditions.
+         *
+         * This geometry returns the map <code>{{"left"->0}, {"right"->1},
+         * {"bottom"->2}, {"top"->3}, {"left lithosphere"->4},
+         * {"right lithosphere"->5}}</code> in 2d, and <code>{{"left"->0},
+         * {"right"->1}, {"front"->2}, {"back"->3}, {"bottom"->4},
+         * {"top"->5}, {"left lithosphere"->6}, {"right lithosphere"->7},
+         * {"front lithosphere"->8}, {"back lithosphere"->9}}</code> in 3d.
+         */
+        std::map<std::string,types::boundary_id>
+        get_symbolic_boundary_names_map () const override;
+
+        /**
+         * Return the set of periodic boundaries as described in the input
+         * file.
+         */
+        std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
+        get_periodic_boundary_pairs () const override;
+
+        /**
+         * @copydoc Interface::adjust_positions_for_periodicity
+         *
+         * Apply a translation to all points outside of the domain
+         * to account for periodicity.
+         */
+        void
+        adjust_positions_for_periodicity (Point<dim> &position,
+                                          const ArrayView<Point<dim>> &connected_positions = {},
+                                          const ArrayView<Tensor<1, dim>> &connected_velocities = {}) const override;
+
+        /**
+         * @copydoc Interface::has_curved_elements()
+         *
+         * A box has only straight boundaries and cells, so return false.
+         */
+        bool
+        has_curved_elements() const override;
+
+        /**
+         * Return whether the given point lies within the domain specified
+         * by the geometry. This function does not take into account
+         * initial or dynamic surface topography.
+         */
+        bool
+        point_is_in_domain(const Point<dim> &point) const override;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is,
+         * which for two merged boxes is Cartesian.
+         */
+        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a box
+         * the results is unchanged and is (x,z) in 2d or (x,y,z) in 3d.
+         */
+        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Whether to make the grid by gluing together two boxes, or just
+         * use one chunk to make the grid. Using two grids glued together
+         * is a safer option, since it forces the boundary conditions
+         * to be always applied to the same depth, but one unified grid allows
+         * for a more flexible usage of the adaptive refinement.
+         */
+        bool use_merged_grids;
+
+        /**
+         * Extent of the whole model domain in x-, y-, and z-direction (in 3d).
+         */
+        Point<dim> extents;
+
+        /**
+         * Extent of the lower box in x-, y-, and z-direction (in 3d).
+         */
+        Point<dim> lower_extents;
+
+        /**
+         * Origin of the lower box in x, y, and z (in 3d) coordinates.
+         */
+        Point<dim> lower_box_origin;
+
+        /**
+         * Extent of the upper box in x-, y-, and z-direction (in 3d).
+         */
+        Point<dim> upper_extents;
+
+        /**
+         * Origin of the upper box in x, y, and z (in 3d) coordinates.
+         */
+        Point<dim> upper_box_origin;
+
+        /**
+         * Flag whether the whole domain is periodic in the x-, y-, and z-directions,
+         * the x- and y- (in 3d) direction in the lithosphere.
+         */
+        bool periodic[dim+dim-1];
+
+        /**
+         * The number of cells in each coordinate direction for the lower box.
+         */
+        std::array<unsigned int, dim> lower_repetitions;
+
+        /**
+         * The number of cells in each coordinate direction for the upper box.
+         */
+        std::array<unsigned int, dim> upper_repetitions;
+
+        /**
+         * The height where the lithospheric part of the vertical boundary begins
+         * (so in positive z-direction).
+         */
+        double height_lith;
+
+        /**
+         * Bind boundary indicators to child cells after each mesh refinement round.
+         */
+        void
+        set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/geometry_model/two_merged_chunks.h.bak b/include/aspect/geometry_model/two_merged_chunks.h.bak
new file mode 100644
index 00000000000..3c5eacd15cc
--- /dev/null
+++ b/include/aspect/geometry_model/two_merged_chunks.h.bak
@@ -0,0 +1,325 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_geometry_model_two_merged_chunks_h
+#define _aspect_geometry_model_two_merged_chunks_h
+
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/compat.h>
+
+#include <deal.II/grid/manifold.h>
+#include <deal.II/base/function_lib.h>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    using namespace dealii;
+
+
+    /**
+     * A geometry model class that describes a chunk of a spherical shell,
+     * but with two boundary indicators per side boundary. This allows
+     * for specifying two different types of boundary conditions on the
+     * side boundaries, for example prescribed plate motions along
+     * the edge of the lithosphere and an open boundary underneath.
+     * In 2D, this class simulates a sector with inner and outer radius, and
+     * minimum and maximum longitude. Longitude increases anticlockwise
+     * from the positive x-axis, as per the mathematical convention of phi.
+     * In 3D, the class simulates a chunk of a sphere, bounded by arbitrary
+     * lines of longitude, latitude and radius. Boundary indicator names are
+     * lowerwest, upperwest, lowereast, uppereast, lowersouth, uppersouth,
+     * lowernorth, uppernorth, bottom and top.
+     *
+     * The parameters that describe this geometry and that are read from the
+     * input file are the inner, outer and middle boundary radius of the shell,
+     * the minimum and maximum longitude, minimum and maximum longitude, and the
+     * number of cells initialized in each dimension. In the radial direction,
+     * this number should be specified for both the lower and the upper part of
+     * the chunk (with their boundary lying at the middle boundary radius).
+     *
+     * Initial topography can be added through a radial displacement of the
+     * mesh nodes.
+     */
+    template <int dim>
+    class TwoMergedChunks : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run and after
+         * the SimulatorAccess (if applicable) is initialized.
+         * This function calls the initialize function of the manifold
+         * with a pointer to the initial topography model obtained
+         * from SimulatorAccess.
+         */
+        void initialize () override;
+
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         */
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
+
+        /**
+         * Return the set of boundary indicators that are used by this model.
+         * This information is used to determine what boundary indicators can
+         * be used in the input file.
+         *
+         * The chunk model uses boundary indicators zero through 2*dim+2*(dim-1)-1, with
+         * the first two being the faces perpendicular to the radius of the shell,
+         * the next four along lines of longitude and, in 3d, the next four
+         * along lines of latitude.
+         */
+        std::set<types::boundary_id>
+        get_used_boundary_indicators () const override;
+
+        /**
+         * Return a mapping from symbolic names of each part of the boundary
+         * to the corresponding boundary indicator. This allows users to
+         * specify *names*, not just *numbers* in their input files when
+         * describing which parts of the boundary have to satisfy which
+         * boundary conditions.
+         */
+        std::map<std::string,types::boundary_id>
+        get_symbolic_boundary_names_map () const override;
+
+        /**
+         * Return the typical length scale one would expect of features in
+         * this geometry, assuming realistic parameters.
+         *
+         * As described in the first ASPECT paper, a length scale of
+         * 10km = 1e4m works well for the pressure scaling for earth
+         * sized spherical shells. use a length scale that
+         * yields this value for the R0,R1 corresponding to earth
+         * but otherwise scales like (R1-R0)
+         */
+        double length_scale () const override;
+
+        /**
+         * Return the depth that corresponds to the given
+         * position. The documentation of the base class (see
+         * GeometryModel::Interface::depth()) describes in detail how
+         * "depth" is interpreted in general.
+         *
+         * Computing a depth requires a geometry model to define a
+         * "vertical" direction. The current class considers the
+         * radial vector away from the origin as vertical and
+         * considers the "top" boundary as the surface. In almost
+         * all cases one will use a gravity model that also matches
+         * these definitions.
+         */
+        double depth(const Point<dim> &position) const override;
+
+        /**
+         * Return the height of the given position relative to the outer
+         * radius.
+         */
+        double height_above_reference_surface(const Point<dim> &position) const override;
+
+        /**
+         * @copydoc Interface::representative_point()
+         */
+        Point<dim> representative_point(const double depth) const override;
+
+        /**
+         * Return the longitude at the western edge of the chunk measured in
+         * radians.
+         */
+        virtual
+        double west_longitude() const;
+
+        /**
+         * Return the longitude at the eastern edge of the chunk measured in
+         * radians.
+         */
+        virtual
+        double east_longitude() const;
+
+        /**
+         * Return the longitude range of the chunk measured in radians.
+         */
+        virtual
+        double longitude_range() const;
+
+        /**
+         * Return the latitude at the southern edge of the chunk measured in
+         * radians from the equator.
+         */
+        virtual
+        double south_latitude() const;
+
+        /**
+         * Return the latitude at the northern edge of the chunk measured in
+         * radians from the equator.
+         */
+        virtual
+        double north_latitude() const;
+
+        /**
+         * Return the latitude range of the chunk measured in radians
+         */
+        virtual
+        double latitude_range() const;
+
+        /**
+         * Return the maximum depth from the surface of the model measured in
+         * meters.
+         */
+        double maximal_depth() const override;
+
+        /**
+         * Return the inner radius of the chunk measured in meters.
+         */
+        virtual
+        double inner_radius() const;
+
+        /**
+         * Return the outer radius of the chunk measured in meters.
+         */
+        virtual
+        double outer_radius() const;
+
+
+        /**
+         * @copydoc Interface::has_curved_elements()
+         *
+         * A chunk has curved boundaries and cells, so return true.
+         */
+        bool
+        has_curved_elements() const override;
+
+        /**
+         * Return whether the given point lies within the domain specified
+         * by the geometry. This function does not take into account
+         * initial or dynamic surface topography.
+         */
+        bool
+        point_is_in_domain(const Point<dim> &point) const override;
+
+        /**
+         * Returns what the natural coordinate system for this geometry model is,
+         * which for a chunk is Spherical.
+         */
+        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
+
+        /**
+         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
+         * coordinates which are most 'natural' to the geometry model. For a chunk
+         * this is (radius, longitude) in 2d and (radius, longitude, latitude) in 3d.
+         */
+        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
+
+        /**
+         * Undoes the action of cartesian_to_natural_coordinates, and turns the
+         * coordinate system which is most 'natural' to the geometry model into
+         * Cartesian coordinates.
+         */
+        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Whether to make the grid by gluing together two chunks, or just
+         * use one chunk to make the grid. Using two grids glued together
+         * is a safer option, since it forces the boundary conditions
+         * to be always applied to the same depth, but one unified grid allows
+         * for a more flexible usage of the adaptive refinement.
+         */
+        bool use_merged_grids;
+
+        /**
+         * Minimum longitude-depth (2D) or
+         * longitude-latitude-depth (3D) point
+         * of the entire merged chunk.
+         */
+        Point<dim> point1;
+
+        /**
+         * Maximum longitude-depth (2D) or
+         * longitude-latitude-depth (3D) point
+         * of the entire merged chunk.
+         */
+        Point<dim> point2;
+
+        /**
+         * Minimum longitude-depth (2D) or
+         * longitude-latitude-depth (3D) point
+         * for the upper chunk.
+         */
+        Point<dim> point3;
+
+        /**
+         * Maximum longitude-depth (2D) or
+         * longitude-latitude-depth (3D) point
+         * for the lower chunk.
+         */
+        Point<dim> point4;
+
+        /**
+         * The number of cells in each coordinate direction
+         * for the lower and upper chunk.
+         */
+        std::array<unsigned int, dim> lower_repetitions;
+        std::array<unsigned int, dim> upper_repetitions;
+
+        /**
+         * An object that describes the geometry. This pointer is
+         * initialized in the initialize() function, and serves as the manifold
+         * object that the triangulation is later given in create_coarse_mesh()
+         * where the triangulation clones it.
+         *
+         * The object is marked as 'const' to make it clear that it should not
+         * be modified once created. That is because the triangulation copies it,
+         * and modifying the current object will not have any impact on the
+         * manifold used by the triangulation.
+         */
+        std::unique_ptr<const internal::ChunkGeometry<dim>> manifold;
+
+        /**
+         * Give a symbolic name to the manifold id to be used by this class.
+         */
+        static const types::manifold_id my_manifold_id = 15;
+
+        /**
+         * Bind boundary indicators to child cells after each mesh refinement round.
+         */
+        void set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/global.h.bak b/include/aspect/global.h.bak
new file mode 100644
index 00000000000..c2de354a27a
--- /dev/null
+++ b/include/aspect/global.h.bak
@@ -0,0 +1,312 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_global_h
+#define _aspect_global_h
+
+#include <aspect/config.h>
+
+#include <deal.II/base/mpi.h>
+
+DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
+
+#include <deal.II/lac/generic_linear_algebra.h>
+
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+
+DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
+
+
+#include <aspect/compat.h>
+
+namespace aspect
+{
+  /**
+   * The following are a set of global constants which may be used by ASPECT:
+   * (for sources of data and values used by ASPECT, see source/global.cc)
+   */
+  namespace constants
+  {
+    /**
+     * Number of seconds in a year [s]
+     */
+    constexpr double year_in_seconds = 60*60*24*365.2425;
+
+    /**
+     * Zero degrees Celsius to Kelvin [K]
+     */
+    constexpr double celsius_to_kelvin = 273.15;
+
+    /**
+     * Convert angles in degree to radians.
+     */
+    constexpr double degree_to_radians = dealii::numbers::PI / 180.;
+
+    /**
+     * Convert angles in radians to degrees.
+     */
+    constexpr double radians_to_degree = 180. / dealii::numbers::PI;
+
+    /**
+     * Gas constant (also known as R) [J K^-1 mol^-1]
+     */
+    constexpr double gas_constant = 8.3144621;
+    /**
+     * Avogadro's constant [mol^-1]
+     */
+    constexpr double avogadro = 6.02214129e23;
+    /**
+     * Gravitational constant [m^3 kg^-1 s^-2]
+     * Value: 6.67430(15)E-11 (standard uncertainty in parenthesis)
+     * Source: 2018 CODATA Value: Newtonian constants of gravitation.
+     *         The NIST Reference on Constants, Units, and Uncertainty.
+     *         NIST. 20 May 2019.
+     */
+    constexpr double big_g = 6.67430e-11;
+
+    /**
+     * Constants for Earth:
+     */
+    namespace earth
+    {
+
+      /**
+       * Masses are taken from Yoder (1995)
+       */
+      namespace masses
+      {
+        /**
+         * Planet mass [kg]
+         */
+        constexpr double planet = 5.9736e24;
+        /**
+         * Mass of the whole core [kg]
+         */
+        constexpr double core = 1.932e24;
+        /**
+         * Mass of the mantle [kg]
+         */
+        constexpr double mantle = 4.043e24;
+      }
+
+      /**
+       * Earth structure radii taken from the IASP91 model
+       */
+      namespace iasp91_radii
+      {
+        /**
+         * Inner core radius [m], equivalent of 5150 km depth
+         */
+        constexpr double inner_core = 1.2171e6;
+        /**
+         * Inner core radius [m], equivalent of 2889 km depth
+         */
+        constexpr double core = 3.482e6;
+        /**
+         * Lower mantle radius [m], equivalent of 660 km depth
+         */
+        constexpr double lower_mantle = 5.711e6;
+        /**
+         * Radius [m], equivalent of 5150 km depth
+         */
+        constexpr double planet = 6.371e6;
+      }
+
+      /**
+       * Gravity values taken from the PREM (Dziewonski and Anderson, 1981)
+       */
+      namespace prem_gravity
+      {
+        /**
+         * Inner core boundary gravity [ms^-2]
+         */
+        constexpr double icb = 4.4002;
+        /**
+         * Core-mantle boundary gravity [ms^-2]
+         */
+        constexpr double cmb = 10.6823;
+        /**
+         * Upper-lower mantle boundary gravity [ms^-2]
+         */
+        constexpr double ulmb = 10.0143;
+        /**
+         * Surface gravity [ms^-2]
+         */
+        constexpr double surface = 9.8156;
+      }
+
+      /**
+       * NIST "Standard gravity" (average gravitational acceleration at surface
+       * [ms^-2]
+       */
+      constexpr double surface_gravity = 9.80665;
+    }
+
+    /**
+     * Constants for Mars
+     */
+    namespace mars
+    {
+      /**
+       * Mars structure radii
+       */
+      namespace radii
+      {
+        /**
+         * Planetary radius from Seidermann et al., 2007 [m]
+         */
+        constexpr double planet = 3.3895e6;
+        /**
+         * Core radius from Rivoldini et al., 2011 [m]
+         */
+        constexpr double core = 1.794e6;
+      }
+      /**
+       * Surface gravity from Lodders et al., 1998 [ms^-2]
+       */
+      constexpr double surface_gravity = 3.711;
+    }
+  }
+
+  /**
+   * Number of seconds in a year [s] (deprecated)
+   */
+  using constants::year_in_seconds;
+
+
+  /**
+   * A typedef that denotes the BOOST stream type for reading data during
+   * serialization. The type chosen here is a binary archive which we
+   * subsequently will have to un-compress.
+   */
+  using iarchive = boost::archive::binary_iarchive;
+
+  /**
+   * A typedef that denotes the BOOST stream type for writing data during
+   * serialization. The type chosen here is a binary archive which we compress
+   * before writing it into a file.
+   */
+  using oarchive = boost::archive::binary_oarchive;
+
+  /**
+   * A class we throw in exceptions in parallel jobs and that we can silently
+   * treat in main(). We do this, for example, in read_parameters() where each
+   * processor would otherwise throw the same exception and every processor
+   * would produce a tangle of output that is impenetrable in large parallel
+   * jobs. The same situation happens if a linear solver fails. Rather, we
+   * make processor 0 throw the real exception and every other processor
+   * converts the exception it wants to throw to an object of the current type
+   * -- which is caught in main() but doesn't produce any output (because
+   * processor 0 will already produce the output).
+   */
+  class QuietException {};
+
+
+  /**
+   * A namespace that contains typedefs for classes used in the linear algebra
+   * description.
+   */
+  namespace LinearAlgebra
+  {
+    /**
+     * Typedef for the vector type used.
+     */
+    using Vector = dealii::TrilinosWrappers::MPI::Vector;
+
+    /**
+     * Typedef for the type used to describe vectors that consist of multiple
+     * blocks.
+     */
+    using BlockVector = dealii::TrilinosWrappers::MPI::BlockVector;
+
+    /**
+     * Typedef for the sparse matrix type used.
+     */
+    using SparseMatrix = dealii::TrilinosWrappers::SparseMatrix;
+
+    /**
+     * Typedef for the type used to describe sparse matrices that consist of
+     * multiple blocks.
+     */
+    using BlockSparseMatrix = dealii::TrilinosWrappers::BlockSparseMatrix;
+
+    /**
+     * Typedef for the base class for all preconditioners.
+     */
+    using PreconditionBase = dealii::TrilinosWrappers::PreconditionBase;
+
+    /**
+     * Typedef for the AMG preconditioner type used for the top left block of
+     * the Stokes matrix.
+     */
+    using PreconditionAMG = dealii::TrilinosWrappers::PreconditionAMG;
+
+    /**
+     * Typedef for the Incomplete Cholesky preconditioner used for other
+     * blocks of the system matrix.
+     */
+    using PreconditionIC = dealii::TrilinosWrappers::PreconditionIC;
+
+    /**
+     * Typedef for the Incomplete LU decomposition preconditioner used for
+     * other blocks of the system matrix.
+     */
+    using PreconditionILU = dealii::TrilinosWrappers::PreconditionILU;
+
+    /**
+     * Typedef for the Jacobi preconditioner used for free surface velocity
+     * projection.
+     */
+    using PreconditionJacobi = dealii::TrilinosWrappers::PreconditionJacobi;
+
+    /**
+     * Typedef for the block compressed sparsity pattern type.
+     */
+    using BlockDynamicSparsityPattern = dealii::TrilinosWrappers::BlockSparsityPattern;
+
+    /**
+     * Typedef for the compressed sparsity pattern type.
+     */
+    using DynamicSparsityPattern = dealii::TrilinosWrappers::SparsityPattern;
+  }
+}
+
+
+/**
+ * Print a header into the given stream that will be written both to screen
+ * and to the log file and that provides basic information about what is
+ * running, with how many processes, and using which linear algebra library.
+ */
+template <class Stream>
+void print_aspect_header(Stream &stream);
+
+/**
+ * A macro that is used in instantiating the ASPECT classes and functions for
+ * both 2d and 3d. Call this macro with the name of another macro that when
+ * called with a single integer argument instantiates the respective classes
+ * in the given space dimension.
+ */
+#define ASPECT_INSTANTIATE(INSTANTIATIONS) \
+  INSTANTIATIONS(2) \
+  INSTANTIATIONS(3)
+
+#endif
diff --git a/include/aspect/gravity_model/ascii_data.h.bak b/include/aspect/gravity_model/ascii_data.h.bak
new file mode 100644
index 00000000000..1c1d407bd6a
--- /dev/null
+++ b/include/aspect/gravity_model/ascii_data.h.bak
@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_gravity_model_ascii_data_h
+#define _aspect_gravity_model_ascii_data_h
+
+#include <aspect/gravity_model/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace GravityModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a gravity description based on
+     * an AsciiData input file.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataProfile<dim>, public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataProfile<dim>::initialize;
+
+        /**
+         * Return the gravity as a function of position.
+         */
+        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Object containing the data profile.
+         */
+        std::unique_ptr<aspect::Utilities::StructuredDataLookup<1>> profile;
+
+        /**
+         * The column index of the gravity column in the data file.
+         */
+        unsigned int gravity_index;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/gravity_model/function.h.bak b/include/aspect/gravity_model/function.h.bak
new file mode 100644
index 00000000000..16119d1166f
--- /dev/null
+++ b/include/aspect/gravity_model/function.h.bak
@@ -0,0 +1,100 @@
+/*
+  Copyright (C) 2014 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_gravity_model_function_h
+#define _aspect_gravity_model_function_h
+
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace GravityModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements gravity based on a functional description
+     * provided in the input file.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Function ();
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the gravity will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        void update () override;
+
+        /**
+         * Return the gravity vector as a function of position.
+         */
+        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the gravity.
+         */
+        Functions::ParsedFunction<dim> function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/gravity_model/interface.h.bak b/include/aspect/gravity_model/interface.h.bak
new file mode 100644
index 00000000000..a370ebb5e5f
--- /dev/null
+++ b/include/aspect/gravity_model/interface.h.bak
@@ -0,0 +1,143 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_gravity_model_interface_h
+#define _aspect_gravity_model_interface_h
+
+#include <aspect/plugins.h>
+#include <deal.II/base/point.h>
+#include <deal.II/base/parameter_handler.h>
+
+namespace aspect
+{
+  /**
+   * A namespace in which we define everything that has to do with modeling
+   * gravity.
+   *
+   * @ingroup GravityModels
+   */
+  namespace GravityModel
+  {
+    using namespace dealii;
+
+    /**
+     * A base class for parameterizations of gravity models.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Return the gravity vector as a function of position.
+         */
+        virtual Tensor<1,dim> gravity_vector (const Point<dim> &position) const = 0;
+    };
+
+
+
+
+    /**
+     * Register a gravity model so that it can be selected from the parameter
+     * file.
+     *
+     * @param name A string that identifies the gravity model
+     * @param description A text description of what this model does and that
+     * will be listed in the documentation of the parameter file.
+     * @param declare_parameters_function A pointer to a function that can be
+     * used to declare the parameters that this gravity model wants to read
+     * from input files.
+     * @param factory_function A pointer to a function that can create an
+     * object of this gravity model.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    void
+    register_gravity_model (const std::string &name,
+                            const std::string &description,
+                            void (*declare_parameters_function) (ParameterHandler &),
+                            std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+    /**
+     * A function that given the name of a model returns a pointer to an
+     * object that describes it. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The model object returned is not yet initialized and has not read its
+     * runtime parameters yet.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_gravity_model (ParameterHandler &prm);
+
+
+    /**
+     * Declare the runtime parameters of the registered gravity models.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm);
+
+
+    /**
+     * For the current plugin subsystem, write a connection graph of all of the
+     * plugins we know about, in the format that the
+     * programs dot and neato understand. This allows for a visualization of
+     * how all of the plugins that ASPECT knows about are interconnected, and
+     * connect to other parts of the ASPECT code.
+     *
+     * @param output_stream The stream to write the output to.
+     */
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &output_stream);
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a gravity model, register it with the functions that can declare
+     * their parameters and create these objects.
+     *
+     * @ingroup GravityModels
+     */
+#define ASPECT_REGISTER_GRAVITY_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_GRAVITY_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::GravityModel::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::GravityModel::register_gravity_model<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::GravityModel::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::GravityModel::register_gravity_model<3>, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/gravity_model/radial.h.bak b/include/aspect/gravity_model/radial.h.bak
new file mode 100644
index 00000000000..df05abe5ce9
--- /dev/null
+++ b/include/aspect/gravity_model/radial.h.bak
@@ -0,0 +1,143 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_gravity_model_radial_h
+#define _aspect_gravity_model_radial_h
+
+#include <aspect/simulator_access.h>
+#include <aspect/gravity_model/interface.h>
+
+namespace aspect
+{
+  namespace GravityModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes gravity as a radial vector of constant
+     * magnitude. The magnitude's value is read from the input file.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    class RadialConstant : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the gravity vector as a function of position.
+         */
+        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Magnitude of the gravity vector.
+         */
+        double magnitude;
+    };
+
+
+    /**
+     * This model has been removed due to its misleading name. The available
+     * AsciiData gravity model (using default parameters) is much more
+     * earth-like, since it uses the gravity profile used in the construction
+     * of the Preliminary Reference Earth Model (PREM, Dziewonski and Anderson,
+     * 1981).
+     *
+     * This is the model used and discussed in the step-32 tutorial program of
+     * deal.II.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    class RadialEarthLike : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization.
+         */
+        void initialize() override;
+
+        /**
+         * Return the gravity vector as a function of position.
+         */
+        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
+    };
+
+
+    /**
+     * A class that describes gravity as a radial vector of linearly
+     * changing magnitude with depth.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    class RadialLinear : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the gravity vector as a function of position.
+         */
+        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Magnitude of the gravity vector at the surface, m/s^2
+         */
+        double magnitude_at_surface;
+
+        /**
+         * Magnitude of the gravity vector at the bottom, m/s^2.
+         * 'Bottom' means at the maximum depth of the provided geometry, for
+         * a full sphere this means the center.
+         */
+        double magnitude_at_bottom;
+
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/gravity_model/vertical.h.bak b/include/aspect/gravity_model/vertical.h.bak
new file mode 100644
index 00000000000..95d834ad3be
--- /dev/null
+++ b/include/aspect/gravity_model/vertical.h.bak
@@ -0,0 +1,72 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_gravity_model_vertical_h
+#define _aspect_gravity_model_vertical_h
+
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace GravityModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes gravity as a vector of constant magnitude
+     * pointing vertically down.
+     *
+     * @ingroup GravityModels
+     */
+    template <int dim>
+    class Vertical : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the gravity vector as a function of position.
+         */
+        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Magnitude of the gravity vector.
+         */
+        double gravity_magnitude;
+
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/heating_model/adiabatic_heating.h.bak b/include/aspect/heating_model/adiabatic_heating.h.bak
new file mode 100644
index 00000000000..bd8588b3a49
--- /dev/null
+++ b/include/aspect/heating_model/adiabatic_heating.h.bak
@@ -0,0 +1,104 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_heating_model_adiabatic_heating_h
+#define _aspect_heating_model_adiabatic_heating_h
+
+#include <aspect/heating_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a standard adiabatic heating rate.
+     *
+     * This adds the term from adiabatic compression heating
+     *    $ \alpha T (\mathbf u \cdot \nabla p) $
+     * where we use the definition of
+     *    $ \alpha = - \frac{1}{\rho} \frac{\partial \rho}{\partial T} $
+     * Note: this term is often simplified using the relationship
+     *    $ \rho \mathbf g = - \nabla p $
+     * to yield
+     *    $ - \alpha \rho T (\mathbf u \cdot \mathbf g) $
+     *
+     * The user can specify if the simplification should be used
+     * by setting the corresponding flag in the input file.
+     * Also see the Equations section in the manual.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class AdiabaticHeating : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Returns whether we compute a simplified adiabatic heating term by
+         * neglecting dynamic pressure effects. I.e. we use
+         *     $ \alpha T (\mathbf u \cdot \nabla p) $
+         * as adiabatic heating term if this function returns false, and
+         *    $ - \alpha \rho T (\mathbf u \cdot \mathbf g) $
+         * if it returns true.
+         */
+        bool
+        use_simplified_adiabatic_heating() const;
+
+        /**
+         * Compute the heating model outputs for this class.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+      private:
+        bool simplified_adiabatic_heating;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/adiabatic_heating_of_melt.h.bak b/include/aspect/heating_model/adiabatic_heating_of_melt.h.bak
new file mode 100644
index 00000000000..d992018020e
--- /dev/null
+++ b/include/aspect/heating_model/adiabatic_heating_of_melt.h.bak
@@ -0,0 +1,108 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_heating_model_adiabatic_heating_of_melt_h
+#define _aspect_heating_model_adiabatic_heating_of_melt_h
+
+#include <aspect/heating_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a standard adiabatic heating rate
+     * for partially molten material.
+     *
+     * This adds the term from adiabatic compression heating
+     *    $ \alpha T (-\phi \mathbf u_s \cdot \nabla p)
+     *    + \alpha T (\phi \mathbf u_f \cdot \nabla p)$
+     * where we use the definition of
+     *    $ \alpha = - \frac{1}{\rho} \frac{\partial \rho}{\partial T} $
+     * Note: this term is often simplified using the relationship
+     *    $ \rho \mathbf g = - \nabla p $
+     * to yield
+     *    $ \alpha \rho_s T (\phi \mathbf u_s \cdot \mathbf g)
+     *    - \alpha \rho_f T (\phi \mathbf u_f \cdot \mathbf g) $
+     *
+     * The user can specify if the simplification should be used
+     * by setting the corresponding flag in the input file.
+     * Also see the Equations section in the manual.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class AdiabaticHeatingMelt : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Compute the heating model outputs for this class.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Allow the heating model to attach additional material model outputs.
+         */
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+
+        /**
+         * Allow the heating model to attach additional material model inputs it needs.
+         */
+        void
+        create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &inputs) const override;
+
+        /**
+         * @}
+         */
+
+      private:
+        bool simplified_adiabatic_heating;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/compositional_heating.h.bak b/include/aspect/heating_model/compositional_heating.h.bak
new file mode 100644
index 00000000000..5d1a8c6dde1
--- /dev/null
+++ b/include/aspect/heating_model/compositional_heating.h.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2017 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_heating_model_compositional_heating_h
+#define _aspect_heating_model_compositional_heating_h
+
+#include <aspect/simulator_access.h>
+#include <aspect/heating_model/interface.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a heating model where each compositional field
+     * is assigned a user-defined internal heating value.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class CompositionalHeating : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the magnitude of heat production arising from values assigned
+         * to each compositional field.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Magnitude of heat production for each compositional field
+         */
+        std::vector<double> heating_values;
+
+        /**
+         * A vector with as many entries as compositional fields.
+         * If the entry for a particular field is true the field is considered
+         * during the averaging of heat production rates, if not the field is
+         * ignored. This is useful if some compositional fields
+         * are used to track properties like finite strain that should not
+         * contribute to heat production.
+         */
+        std::vector<bool> fields_used_in_heat_production_averaging;
+
+        /**
+         * Similar to fields_used_in_heat_production_averaging, except it
+         * determines whether to include the background field in the heat
+         * production computation.
+         */
+        bool use_background_field_for_heat_production_averaging;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/constant_heating.h.bak b/include/aspect/heating_model/constant_heating.h.bak
new file mode 100644
index 00000000000..8eaa75402be
--- /dev/null
+++ b/include/aspect/heating_model/constant_heating.h.bak
@@ -0,0 +1,79 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_heating_model_constant_heating_h
+#define _aspect_heating_model_constant_heating_h
+
+#include <aspect/heating_model/interface.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a constant radiogenic heating rate.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class ConstantHeating : public Interface<dim>
+    {
+      public:
+        /**
+         * Return the heating terms. For the current class, this
+         * function obviously simply returns a constant value.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+      private:
+        double radiogenic_heating_rate;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/function.h.bak b/include/aspect/heating_model/function.h.bak
new file mode 100644
index 00000000000..360677b3679
--- /dev/null
+++ b/include/aspect/heating_model/function.h.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_heating_model_function_h
+#define _aspect_heating_model_function_h
+
+#include <aspect/simulator_access.h>
+#include <aspect/heating_model/interface.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a heating model based on a functional
+     * description provided in the input file.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Function ();
+
+        /**
+         * Return the specific heating rate as calculated by the function
+         * object.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * allow the model to do whatever necessary. In this case the time of
+         * the function object is updated.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the components of the velocity.
+         */
+        Functions::ParsedFunction<dim> heating_model_function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/interface.h.bak b/include/aspect/heating_model/interface.h.bak
new file mode 100644
index 00000000000..d40d83d0ec9
--- /dev/null
+++ b/include/aspect/heating_model/interface.h.bak
@@ -0,0 +1,384 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_heating_model_interface_h
+#define _aspect_heating_model_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/point.h>
+#include <deal.II/base/parameter_handler.h>
+
+#include <boost/core/demangle.hpp>
+#include <typeinfo>
+
+
+namespace aspect
+{
+  template <int dim> class SimulatorAccess;
+  /**
+   * A namespace in which we define everything that has to do with defining
+   * the heating model.
+   *
+   * @ingroup HeatingModels
+   */
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A data structure with the output field of the
+     * HeatingModel::Interface::evaluate() function. The vectors are the
+     * values at the different positions given by
+     * MaterialModelInputs::position.
+     */
+    struct HeatingModelOutputs
+    {
+      /**
+       * Constructor. Initialize the various arrays of this structure with the
+       * given number of quadrature points and (finite element) components.
+       *
+       * @param n_points The number of quadrature points for which input
+       * quantities will be provided.
+       * @param n_comp The number of vector quantities (in the order in which
+       * the Introspection class reports them) for which input will be
+       * provided.
+       */
+      HeatingModelOutputs (const unsigned int n_points,
+                           const unsigned int n_comp);
+
+      /**
+       * All source terms of the temperature equation that represent a
+       * continuous process leading to a rate of change in temperature
+       * at the given position. This includes shear heating, adiabatic
+       * heating, radiogenic heat production, or any other heating rates
+       * on the right hand side of the energy equation.
+       */
+      std::vector<double> heating_source_terms;
+
+      /**
+       * The source terms of the temperature equation that represent
+       * fast changes in temperature (compared to the advection time
+       * scale), for example due to reactions, at the given position.
+       * On the advection time scale, these reactions might look like
+       * instantaneous changes in temperatures. This includes for example
+       * latent heat of melt.
+       *
+       * These reaction rates are only used in the operator_splitting nonlinear
+       * solver scheme, which allows it to solve reactions of compositional
+       * fields and temperature decoupled from the advection, and using a
+       * different time step size.
+       * In this case, they are used in addition to (and independent from) any
+       * heating_source_terms that a heating model defines, which are assembled
+       * as usual. For any other solver scheme, these values are ignored.
+       *
+       * In contrast to the heating source terms, these terms are actual changes
+       * in temperature (units K/s or K/yr) rather than changes in energy.
+       */
+      std::vector<double> rates_of_temperature_change;
+
+      /**
+       * Left hand side contribution of latent heat; this is added to the
+       * $\rho C_p$ term on the left hand side of the energy equation.
+       */
+      std::vector<double> lhs_latent_heat_terms;
+
+      /**
+       * Reset function. Resets all of the values in the heating model
+       * outputs to their uninitialized values (NaN for the source and latent
+       * heat terms, 0 for the rates of temperature change).
+       */
+      void
+      reset ();
+    };
+
+    /**
+     * A base class for parameterizations of heating models.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Function to compute the heating terms in @p heating_model_outputs
+         * given the inputs in @p material_model_inputs and the outputs of the
+         * material model in @p material_model_outputs.
+         * All parts of the @p heating_model_outputs structure have to be
+         * filled, heating_source_terms with the value of the heating rate and
+         * lhs_latent_heat_terms with the part of the latent heat that depends
+         * on the temperature change (and thus ends up on the left hand side of
+         * the temperature equation) at each quadrature point as defined in
+         * @p material_model_inputs, setting them to zero if they are not to
+         * be used in the computation.
+         */
+        virtual
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const = 0;
+
+        /**
+         * Allow the heating model to attach additional material model outputs.
+         * The default implementation of this function does not add any
+         * outputs. Consequently, derived classes do not have to overload
+         * this function if they do not need any additional outputs.
+         */
+        virtual
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const;
+
+        /**
+         * Allow the heating model to attach additional material model inputs
+         * it needs. The default implementation of this function does not add any
+         * inputs. Consequently, derived classes do not have to overload
+         * this function if they do not need any additional inputs.
+         */
+        virtual
+        void
+        create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &inputs) const;
+    };
+
+
+    /**
+     * A class that manages all objects that provide functionality to the
+     * heating models.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Returns true if the adiabatic heating plugin is found in the
+         * list of active heating models.
+         */
+        bool
+        adiabatic_heating_enabled() const;
+
+        /**
+         * Returns true if the shear heating plugin is found in the
+         * list of active heating models.
+         */
+        bool
+        shear_heating_enabled() const;
+
+        /**
+         * Declare the parameters of all known heating plugins, as
+         * well as of ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which heating model objects will be created; then
+         * let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * A function that calls the evaluate function of all the individual
+         * heating models and adds up the values of the individual heating
+         * model outputs.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const;
+
+        /**
+         * Allow the heating model plugins to attach additional material model
+         * inputs and outputs by looping over all registered plugins and calling
+         * their respective member functions.
+         */
+        virtual
+        void
+        create_additional_material_model_inputs_and_outputs(MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                                                            MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const;
+
+
+        /**
+         * A function that is used to register heating model objects in such
+         * a way that the Manager can deal with all of them without having to
+         * know them by name. This allows the files in which individual
+         * plugins are implemented to register these plugins, rather than also
+         * having to modify the Manager class by adding the new heating plugin
+         * class.
+         *
+         * @param name A string that identifies the heating model
+         * @param description A text description of what this model does and that
+         * will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that can be
+         * used to declare the parameters that this heating model wants to read
+         * from input files.
+         * @param factory_function A pointer to a function that can create an
+         * object of this heating model.
+         *
+         * @ingroup HeatingModels
+         */
+        static
+        void
+        register_heating_model (const std::string &name,
+                                const std::string &description,
+                                void (*declare_parameters_function) (ParameterHandler &),
+                                std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+
+        /**
+         * Return a list of names of all heating models currently used in the
+         * computation, as specified in the input file.
+         */
+        const std::vector<std::string> &
+        get_active_heating_model_names () const;
+
+        /**
+         * Return a list of pointers to all heating models currently used in the
+         * computation, as specified in the input file.
+         */
+        const std::list<std::unique_ptr<Interface<dim>>> &
+        get_active_heating_models () const;
+
+        /**
+         * Go through the list of all heating models that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename HeatingModelType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,HeatingModelType>::value>>
+        bool
+        has_matching_heating_model () const;
+
+        /**
+         * Go through the list of all heating models that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no heating model is active that matches the given type,
+         * throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename HeatingModelType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,HeatingModelType>::value>>
+        const HeatingModelType &
+        get_matching_heating_model () const;
+
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcHeatingModelNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered heating model objects.");
+      private:
+        /**
+         * A list of names of heating model objects that have been requested
+         * in the parameter file.
+         */
+        std::vector<std::string> model_names;
+    };
+
+
+
+    template <int dim>
+    template <typename HeatingModelType, typename>
+    inline
+    bool
+    Manager<dim>::has_matching_heating_model () const
+    {
+      return this->template has_matching_plugin_object<HeatingModelType>();
+    }
+
+
+    template <int dim>
+    template <typename HeatingModelType, typename>
+    inline
+    const HeatingModelType &
+    Manager<dim>::get_matching_heating_model () const
+    {
+      return this->template get_matching_plugin_object<HeatingModelType>();
+    }
+
+
+    /**
+     * Return a string that consists of the names of heating models that can
+     * be selected. These names are separated by a vertical line '|' so
+     * that the string can be an input to the deal.II classes
+     * Patterns::Selection or Patterns::MultipleSelection.
+     */
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ();
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a heating model, register it with the
+     * aspect::HeatingModel::Manager class.
+     *
+     * @ingroup HeatingModels
+     */
+#define ASPECT_REGISTER_HEATING_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_HEATING_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::HeatingModel::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::HeatingModel::Manager<2>::register_heating_model, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::HeatingModel::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::HeatingModel::Manager<3>::register_heating_model, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/latent_heat.h.bak b/include/aspect/heating_model/latent_heat.h.bak
new file mode 100644
index 00000000000..2761cccfae6
--- /dev/null
+++ b/include/aspect/heating_model/latent_heat.h.bak
@@ -0,0 +1,74 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_heating_model_latent_heat_h
+#define _aspect_heating_model_latent_heat_h
+
+#include <aspect/heating_model/interface.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a standard formulation of latent heat.
+     * This includes a left hand side and a right hand side term:
+     *
+     * The left hand side is
+     *   $ -\rho T \frac{\partial S}{\partial T} \frac{D T}{D t}$
+     * so that we can add
+     *   $ -\rho T \frac{\partial S}{\partial T} $
+     * to the $\rho C_p$ term.
+     *
+     * The right-hand side term from latent heating is
+     *   $\frac{\partial S}{\partial p} T \rho (u \dot \nabla p)$.
+     *
+     * T, u, and p are the solutions from the previous time step or
+     * are extrapolated from there, depending on what is provided
+     * in the input arguments of this function.
+     *
+     * Formulation modified after Christensen, Ulrich R. & Yuen,
+     * David A.: Layered convection induced by phase transitions,
+     * Journal of Geophysical Research: Solid Earth (1985).
+     *
+     * Also see the Equations section in the manual.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class LatentHeat : public Interface<dim>
+    {
+      public:
+        /**
+         * Compute the heating model outputs for this class.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/latent_heat_melt.h.bak b/include/aspect/heating_model/latent_heat_melt.h.bak
new file mode 100644
index 00000000000..272771e2b82
--- /dev/null
+++ b/include/aspect/heating_model/latent_heat_melt.h.bak
@@ -0,0 +1,91 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_heating_model_latent_heat_melt_h
+#define _aspect_heating_model_latent_heat_melt_h
+
+#include <aspect/heating_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a standard formulation of latent heat
+     * of melting. This assumes that there is a compositional field
+     * called porosity, and it uses the reaction term of this field
+     * (the fraction of material that melted in the current time step)
+     * multiplied by a constant entropy change for melting 100%
+     * of the material as source term of the heating model.
+     * The left-hand side term is zero.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class LatentHeatMelt : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Compute the heating model outputs for this class.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+        virtual
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+
+      private:
+        // entropy change upon melting
+        double melting_entropy_change;
+        bool   retrieve_entropy_change_from_material_model;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/radioactive_decay.h.bak b/include/aspect/heating_model/radioactive_decay.h.bak
new file mode 100644
index 00000000000..d4bf222225a
--- /dev/null
+++ b/include/aspect/heating_model/radioactive_decay.h.bak
@@ -0,0 +1,119 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_heating_model_radioactive_decay_h
+#define _aspect_heating_model_radioactive_decay_h
+
+#include <aspect/simulator_access.h>
+#include <aspect/heating_model/interface.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a heating model based on radioactive decay.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class RadioactiveDecay : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        RadioactiveDecay ();
+
+        /**
+         * Return the specific heating rate as calculated by radioactive
+         * decay.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * Number of radio active heating elements.
+         */
+        unsigned int                   n_radio_heating_elements;
+
+        /**
+         * Store the half life of different elements.
+         */
+        std::vector<double>            half_decay_times;
+
+        /**
+         * Store the unit heating rate of different elements.
+         */
+        std::vector<double>            radioactive_heating_rates;
+
+        /**
+         * Store the initial concentration in the crust.
+         */
+        std::vector<double>            radioactive_initial_concentrations_crust;
+
+        /**
+         * Store the initial concentration in the mantle.
+         */
+        std::vector<double>            radioactive_initial_concentrations_mantle;
+
+        /**
+         * Whether crust defined by composition or depth
+         */
+        bool                           is_crust_defined_by_composition;
+
+        /**
+         * Depth of the crust.
+         */
+        double                         crust_depth;
+
+        /**
+         * Composition number of crust.
+         */
+        unsigned int                   crust_composition_num;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/shear_heating.h.bak b/include/aspect/heating_model/shear_heating.h.bak
new file mode 100644
index 00000000000..ee9cd7bf53c
--- /dev/null
+++ b/include/aspect/heating_model/shear_heating.h.bak
@@ -0,0 +1,119 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_heating_model_shear_heating_h
+#define _aspect_heating_model_shear_heating_h
+
+#include <aspect/heating_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/rheology/drucker_prager.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a standard shear heating rate.
+     *
+     * Add the term
+     *    $  2 \eta \left( \varepsilon - \frac{1}{3} \text{tr}
+     *       \varepsilon \mathbf 1 \right) : \left( \varepsilon - \frac{1}{3}
+     *       \text{tr} \varepsilon \mathbf 1 \right) $
+     *
+     * Also see the Equations section in the manual.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class ShearHeating : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Compute the heating model outputs for this class.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * Allow the heating model to attach additional material model outputs.
+         */
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Parameters used for limiting the stress being used in the shear
+         * heating computation. To prevent shear heating from becoming
+         * unrealistically high, a Drucker-Prager yield criterion as given
+         * in the DruckerPrager rheology model can be used to define a
+         * maximum stress computed from the given cohesion and friction
+         * angle.
+         */
+        bool limit_stress;
+        double cohesion;
+        double friction_angle;
+        MaterialModel::Rheology::DruckerPrager<dim> drucker_prager_plasticity;
+    };
+
+
+    /**
+     * Additional output fields for the shear heating computation
+     * to be added to the MaterialModel::MaterialModelOutputs structure
+     * and filled in the MaterialModel::evaluate() function.
+     */
+    template <int dim>
+    class ShearHeatingOutputs : public MaterialModel::NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        ShearHeatingOutputs(const unsigned int n_points);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * The fraction of the deformation work that is released as shear heating
+         * rather than being converted into other forms of energy (such as, for
+         * example, surface energy of grains). If it is set to 1, all deformation
+         * work will go into shear heating.
+         */
+        std::vector<double> shear_heating_work_fractions;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/heating_model/shear_heating_with_melt.h.bak b/include/aspect/heating_model/shear_heating_with_melt.h.bak
new file mode 100644
index 00000000000..01e1847ae56
--- /dev/null
+++ b/include/aspect/heating_model/shear_heating_with_melt.h.bak
@@ -0,0 +1,78 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_heating_model_shear_heating_with_melt_h
+#define _aspect_heating_model_shear_heating_with_melt_h
+
+#include <aspect/heating_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a standard shear heating rate for dissipation
+     * heating of partially molten material.
+     *
+     * Add the term
+     *    $   \xi \left( \nabla \cdot \mathbf u_s \right)^2 $,
+     * which corresponds to bulk (compression) heating,
+     * and the term
+     *    $   \frac{\eta_f \phi^2}{k_{\phi}} \left( \mathbf u_f - \mathbf u_s \right)^2 $,
+     * which corresponds to heating due to melt segregation.
+     * Both terms are heating source terms, and the left-hand side term is zero.
+     *
+     * Also see the Equations section in the manual.
+     *
+     * @ingroup HeatingModels
+     */
+    template <int dim>
+    class ShearHeatingMelt : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Compute the heating model outputs for this class.
+         */
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
+
+        /**
+         * Allow the heating model to attach additional material model outputs.
+         */
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &) const override;
+
+        /**
+         * Allow the heating model to attach additional material model inputs it needs.
+         */
+        void
+        create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &) const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_composition/adiabatic_density.h.bak b/include/aspect/initial_composition/adiabatic_density.h.bak
new file mode 100644
index 00000000000..9229a7c753c
--- /dev/null
+++ b/include/aspect/initial_composition/adiabatic_density.h.bak
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_composition_adiabatic_density_h
+#define _aspect_initial_composition_adiabatic_density_h
+
+#include <aspect/initial_composition/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements initial conditions for the compositional fields
+     * based on the adiabatic density profile. Note that only the field
+     * of the type 'density' will be filled, for all other fields
+     * this plugin returns 0.0.
+     *
+     * @ingroup InitialCompositionModels
+     */
+    template <int dim>
+    class AdiabaticDensity : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the initial composition as the adiabatic density at this
+         * point.
+         */
+        double initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_composition/ascii_data.h.bak b/include/aspect/initial_composition/ascii_data.h.bak
new file mode 100644
index 00000000000..0a75b0af38d
--- /dev/null
+++ b/include/aspect/initial_composition/ascii_data.h.bak
@@ -0,0 +1,90 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_composition_ascii_data_h
+#define _aspect_initial_composition_ascii_data_h
+
+#include <aspect/initial_composition/interface.h>
+
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements the prescribed compositional fields determined
+     * from a AsciiData input file.
+     *
+     * @ingroup InitialCompositionModels
+     */
+    template <int dim>
+    class AsciiData : public Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the initial composition as a function of position. For the
+         * current class, this function returns value from the text files.
+         */
+        double
+        initial_composition (const Point<dim> &position,
+                             const unsigned int n_comp) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The dataset that contains the initial composition.
+         */
+        std::unique_ptr<Utilities::AsciiDataInitial<dim>> ascii_data_initial;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_composition/ascii_data_layered.h.bak b/include/aspect/initial_composition/ascii_data_layered.h.bak
new file mode 100644
index 00000000000..064e3cda15a
--- /dev/null
+++ b/include/aspect/initial_composition/ascii_data_layered.h.bak
@@ -0,0 +1,87 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_composition_ascii_data_layered_h
+#define _aspect_initial_composition_ascii_data_layered_h
+
+#include <aspect/initial_composition/interface.h>
+
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements prescribed compositional fields determined from
+     * AsciiData input files. Each file defines a layer boundary as a grid of points.
+     *
+     * @ingroup InitialCompositionModels
+     */
+    template <int dim>
+    class AsciiDataLayered : public Interface<dim>, public Utilities::AsciiDataLayered<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiDataLayered ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataLayered<dim>::initialize;
+
+        /**
+         * Return the initial composition as a function of position. For the
+         * current class, this function returns value from the text files.
+         */
+        double
+        initial_composition (const Point<dim> &position,
+                             const unsigned int n_comp) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_composition/entropy_table_lookup.h.bak b/include/aspect/initial_composition/entropy_table_lookup.h.bak
new file mode 100644
index 00000000000..fed4a58a985
--- /dev/null
+++ b/include/aspect/initial_composition/entropy_table_lookup.h.bak
@@ -0,0 +1,111 @@
+/*
+  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_composition_entropy_table_lookup_h
+#define _aspect_initial_composition_entropy_table_lookup_h
+
+#include <aspect/initial_composition/interface.h>
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements initial conditions for the entropy field
+     * Note that this plugin only
+     * works if there is a compositional field called 'entropy'.
+     * All compositional fields except entropy are not changed by this plugin.
+     *
+     * @ingroup InitialCompositionModels
+     */
+    template <int dim>
+    class EntropyTableLookUp : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialize the plugin.
+         */
+        void initialize () override;
+
+        /**
+         * Return the initial composition as a function of position and number
+         * of compositional field.
+         */
+        double initial_composition (const Point<dim> &position,
+                                    const unsigned int compositional_index) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Information about the location of data files.
+         */
+        std::string data_directory;
+        std::string material_file_name;
+
+        /**
+         * Index of the entropy in the compositional fields
+         */
+        unsigned entropy_index;
+
+        /**
+         * A shared pointer to the initial temperature object
+         * that ensures that the current object can continue
+         * to access the initial temperature object beyond the
+         * first time step.
+         */
+        std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature_manager;
+
+        /**
+         * A shared pointer to the initial composition object
+         * that ensures that the current object can continue
+         * to access the initial composition object beyond the
+         * first time step.
+         */
+        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition_manager;
+
+        /**
+         * Pointer to the StructuredDataLookup object that holds the material data.
+         */
+        std::unique_ptr<Utilities::StructuredDataLookup<2>> material_lookup;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_composition/function.h.bak b/include/aspect/initial_composition/function.h.bak
new file mode 100644
index 00000000000..15d0ffc7170
--- /dev/null
+++ b/include/aspect/initial_composition/function.h.bak
@@ -0,0 +1,89 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_composition_function_h
+#define _aspect_initial_composition_function_h
+
+#include <aspect/initial_composition/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements initial conditions for the compositional fields
+     * based on a functional description provided in the input file.
+     *
+     * @ingroup InitialCompositionModels
+     */
+    template <int dim>
+    class Function : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the initial composition as a function of position and number
+         * of compositional field.
+         */
+        double initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the compositional fields.
+         */
+        std::unique_ptr<Functions::ParsedFunction<dim>> function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_composition/interface.h.bak b/include/aspect/initial_composition/interface.h.bak
new file mode 100644
index 00000000000..96a1f5df87c
--- /dev/null
+++ b/include/aspect/initial_composition/interface.h.bak
@@ -0,0 +1,280 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_composition_interface_h
+#define _aspect_initial_composition_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/point.h>
+#include <deal.II/base/parameter_handler.h>
+
+#include <boost/core/demangle.hpp>
+#include <typeinfo>
+
+
+namespace aspect
+{
+  template <int dim> class SimulatorAccess;
+
+  /**
+   * A namespace in which we define everything that has to do with defining
+   * the initial composition.
+   *
+   * @ingroup InitialCompositions
+   */
+  namespace InitialComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A base class for parameterizations of initial conditions.
+     *
+     * @ingroup InitialCompositions
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Return the initial composition as a function of position.
+         */
+        virtual
+        double initial_composition (const Point<dim> &position, const unsigned int n_comp) const = 0;
+    };
+
+
+
+    /**
+     * A class that manages all initial composition objects.
+     *
+     * @ingroup InitialCompositions
+     */
+    template <int dim>
+    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Destructor. Made virtual since this class has virtual member
+         * functions.
+         */
+        ~Manager () override;
+
+        /**
+         * Update function. Called once at the beginning of a timestep to
+         * update all plugin objects.
+         */
+        void update () override;
+
+        /**
+         * Declare the parameters of all known initial composition plugins, as
+         * well as of ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which initial composition objects will be created;
+         * then let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * A function that calls the initial_composition functions of all
+         * individual initial composition objects for the composition given
+         * by @p n_comp, and adds up the values of the
+         * individual calls.
+         */
+        double
+        initial_composition (const Point<dim> &position,
+                             const unsigned int n_comp) const;
+
+        /**
+         * A function that is used to register initial composition objects in
+         * such a way that the Manager can deal with all of them without having
+         * to know them by name. This allows the files in which individual
+         * plugins are implemented to register these plugins, rather than also
+         * having to modify the Manager class by adding the new initial
+         * composition plugin class.
+         *
+         * @param name A string that identifies the initial composition model
+         * @param description A text description of what this model does and that
+         * will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that can be
+         * used to declare the parameters that this initial composition model
+         * wants to read from input files.
+         * @param factory_function A pointer to a function that can create an
+         * object of this initial composition model.
+         */
+        static
+        void
+        register_initial_composition (const std::string &name,
+                                      const std::string &description,
+                                      void (*declare_parameters_function) (ParameterHandler &),
+                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+
+        /**
+         * Return a list of names of all initial composition models currently
+         * used in the computation, as specified in the input file.
+         */
+        const std::vector<std::string> &
+        get_active_initial_composition_names () const;
+
+        /**
+         * Return a list of pointers to all initial composition models
+         * currently used in the computation, as specified in the input file.
+         */
+        const std::list<std::unique_ptr<Interface<dim>>> &
+        get_active_initial_composition_conditions () const;
+
+        /**
+         * Go through the list of all initial composition models that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename InitialCompositionType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,InitialCompositionType>::value>>
+        bool
+        has_matching_initial_composition_model () const;
+
+        /**
+         * Go through the list of all initial composition models that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no initial composition model is active that matches the given type,
+         * throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename InitialCompositionType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,InitialCompositionType>::value>>
+        const InitialCompositionType &
+        get_matching_initial_composition_model () const;
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcInitialCompositionNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered initial composition objects.");
+      private:
+        /**
+         * A list of names of initial composition objects that have been requested
+         * in the parameter file.
+         */
+        std::vector<std::string> model_names;
+
+        /**
+         * A list of enums of initial composition operators that have been
+         * requested in the parameter file. Each entry is used to modify the
+         * initial compositional field with the values from the associated plugin
+         * in model_names.
+         */
+        std::vector<aspect::Utilities::Operator> model_operators;
+    };
+
+
+
+    template <int dim>
+    template <typename InitialCompositionType, typename>
+    inline
+    bool
+    Manager<dim>::has_matching_initial_composition_model () const
+    {
+      return this->template has_matching_plugin_object<InitialCompositionType>();
+    }
+
+
+    template <int dim>
+    template <typename InitialCompositionType, typename>
+    inline
+    const InitialCompositionType &
+    Manager<dim>::get_matching_initial_composition_model () const
+    {
+      return this->template get_matching_plugin_object<InitialCompositionType>();
+    }
+
+
+    /**
+     * Return a string that consists of the names of initial composition models that can
+     * be selected. These names are separated by a vertical line '|' so
+     * that the string can be an input to the deal.II classes
+     * Patterns::Selection or Patterns::MultipleSelection.
+     *
+     * @ingroup InitialCompositions
+     */
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ();
+
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a initial composition model, register it with the functions that can
+     * declare their parameters and create these objects.
+     *
+     * @ingroup InitialCompositions
+     */
+#define ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::InitialComposition::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::InitialComposition::Manager<2>::register_initial_composition, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::InitialComposition::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::InitialComposition::Manager<3>::register_initial_composition, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_composition/porosity.h.bak b/include/aspect/initial_composition/porosity.h.bak
new file mode 100644
index 00000000000..ea9b6709951
--- /dev/null
+++ b/include/aspect/initial_composition/porosity.h.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_composition_porosity_h
+#define _aspect_initial_composition_porosity_h
+
+#include <aspect/initial_composition/interface.h>
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements initial conditions for the porosity field
+     * by computing the equilibrium melt fraction for the given initial
+     * condition and reference pressure profile. Note that this plugin only
+     * works if there is a compositional field called 'porosity', and the
+     * used material model implements the 'MeltFractionModel' interface.
+     * All compositional fields except porosity are not changed by this plugin.
+     *
+     * @ingroup InitialCompositionModels
+     */
+    template <int dim>
+    class Porosity : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialize the plugin.
+         */
+        void initialize () override;
+
+        /**
+         * Return the initial composition as a function of position and number
+         * of compositional field.
+         */
+        double initial_composition (const Point<dim> &position,
+                                    const unsigned int compositional_index) const override;
+
+      private:
+        /**
+         * A shared pointer to the initial temperature object
+         * that ensures that the current object can continue
+         * to access the initial temperature object beyond the
+         * first time step.
+         */
+        std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature_manager;
+
+        /**
+         * A shared pointer to the initial composition object
+         * that ensures that the current object can continue
+         * to access the initial composition object beyond the
+         * first time step.
+         */
+        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition_manager;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_composition/slab_model.h.bak b/include/aspect/initial_composition/slab_model.h.bak
new file mode 100644
index 00000000000..6750c5f9055
--- /dev/null
+++ b/include/aspect/initial_composition/slab_model.h.bak
@@ -0,0 +1,109 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_composition_slab_model_h
+#define _aspect_initial_composition_slab_model_h
+
+#include <aspect/initial_composition/interface.h>
+
+#include <aspect/simulator_access.h>
+#include <aspect/structured_data.h>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements subducted slab geometries as a compositional
+     * field determined from an input file. The file defines the depth to
+     * the top of the slab and the slab thickness.
+     *
+     * An example model that is included is Slab2 described in
+     * Hayes, G. P., Moore, G. L., Portner, D. E., Hearne, M., Flamme, H., Furtney, M.,
+     * & Smoczyk, G. M. (2018). Slab2, a comprehensive subduction zone geometry model.
+     * Science, 362(6410), 58-61.
+     *
+     * @ingroup InitialCompositionModels
+     */
+    template <int dim>
+    class SlabModel : public Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the initial composition as a function of position. For the
+         * current class, this function returns 1.0 inside subducted slabs and 0.0 outside.
+         */
+        double
+        initial_composition (const Point<dim> &position,
+                             const unsigned int n_comp) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+        * A function that returns the slab_boundary object to allow access
+        * in other places.
+        */
+        const Utilities::AsciiDataBoundary<dim> &get_slab_boundary() const;
+
+      private:
+        /**
+         * An object of ascii data boundary to input subducted slab depths
+         * and thicknesses.
+         */
+        Utilities::AsciiDataBoundary<dim> slab_boundary;
+
+        /**
+         * Cache the surface boundary id to avoid unnecessary lookups.
+         */
+        types::boundary_id surface_boundary_id;
+
+        /**
+         * Cache the compositional field index that corresponds to
+         * the slab composition to avoid unnecessary lookups.
+         */
+        unsigned int slab_index;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_composition/world_builder.h.bak b/include/aspect/initial_composition/world_builder.h.bak
new file mode 100644
index 00000000000..144e18ff530
--- /dev/null
+++ b/include/aspect/initial_composition/world_builder.h.bak
@@ -0,0 +1,105 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_initial_composition_world_builder_h
+#define _aspect_initial_composition_world_builder_h
+
+#include <aspect/global.h>
+
+#ifdef ASPECT_WITH_WORLD_BUILDER
+
+#include <aspect/initial_composition/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace WorldBuilder
+{
+  class World;
+}
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements initial conditions for the compositional fields
+     * based on a functional description provided in the input file through the
+     * World builder.
+     *
+     * @ingroup InitialCompositionModels
+     */
+    template <int dim>
+    class WorldBuilder : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run and after
+         * the SimulatorAccess (if applicable) is initialized.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the initial composition as a function of position and number
+         * of compositional field.
+         */
+        double initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A vector that specifies for each compositional field index if the world builder
+         * should be evaluated for this compositional field.
+         */
+        std::vector<bool> relevant_compositions;
+
+        /**
+         * A pointer to the WorldBuilder object. Keeping this pointer ensures
+         * that the object doesn't go away while we still need it.
+         */
+        std::shared_ptr<const ::WorldBuilder::World> world_builder;
+    };
+  }
+}
+
+#endif
+#endif
diff --git a/include/aspect/initial_temperature/S40RTS_perturbation.h.bak b/include/aspect/initial_temperature/S40RTS_perturbation.h.bak
new file mode 100644
index 00000000000..fa9bf8f7328
--- /dev/null
+++ b/include/aspect/initial_temperature/S40RTS_perturbation.h.bak
@@ -0,0 +1,233 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_S40RTS_perturbation_h
+#define _aspect_initial_temperature_S40RTS_perturbation_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    namespace internal
+    {
+      namespace S40RTS
+      {
+        class SphericalHarmonicsLookup
+        {
+          public:
+            SphericalHarmonicsLookup(const std::string &filename,
+                                     const MPI_Comm comm);
+
+            /// Declare a function that returns the cosine coefficients
+            const std::vector<double> &
+            cos_coeffs() const;
+
+            /// Declare a function that returns the sine coefficients
+            const std::vector<double> &
+            sin_coeffs() const;
+
+            unsigned int maxdegree() const;
+
+          private:
+            unsigned int order;
+            std::vector<double> a_lm;
+            std::vector<double> b_lm;
+        };
+
+        class SplineDepthsLookup
+        {
+          public:
+            SplineDepthsLookup(const std::string &filename,
+                               const MPI_Comm comm);
+
+            const std::vector<double> &
+            spline_depths() const;
+
+          private:
+            std::vector<double> depths;
+        };
+      }
+    }
+
+    template <int dim>
+    class PatchOnS40RTS;
+
+
+    /**
+     * A class that describes a perturbed initial temperature field for a
+     * spherical shell geometry model. The perturbation is based on the S20RTS
+     * / S40RTS global shear wave velocity model by Ritsema et al.
+     * http://www.earth.lsa.umich.edu/~jritsema/research.html
+     *
+     * @ingroup InitialTemperatures
+     */
+
+    template <int dim>
+    class S40RTSPerturbation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        S40RTSPerturbation ();
+
+        /**
+         * Initialization function. Loads the material data and sets up
+         * pointers.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the Vs as a function of position.
+         */
+        virtual
+        double get_Vs (const Point<dim> &position) const;
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * An enum to describe which method should be chosen to scale vs to density.
+         */
+        enum VsToDensityMethod
+        {
+          file,
+          constant
+        };
+
+        /**
+         * Currently chosen source for vs to density scaling.
+         */
+        VsToDensityMethod vs_to_density_method;
+
+        /**
+         * File directory and names
+         */
+        std::string data_directory;
+        std::string spline_depth_file_name;
+
+        /**
+         * This parameter allows setting the input file for the shear-wave
+         * perturbation. Options so far are S20RTS.sph and S40RTS.sph. For
+         * S40RTS there are different versions available that differ by the
+         * degree of damping in the seismic inversion. These models could be
+         * downloaded and used as well.
+         */
+        std::string harmonics_coeffs_file_name;
+
+        /**
+         * The parameters below describe the perturbation of shear wave
+         * velocity into a temperatures perturbation. The first parameter is
+         * constant so far but could be made depth dependent as constraint by
+         * e.g. Forte, A.M. & Woodward, R.L., 1997. Seismic-geodynamic
+         * constraints on three- dimensional structure, vertical flow, and
+         * heat transfer in the mantle, J. Geophys. Res. 102 (B8),
+         * 17,981-17,994.
+         * The last parameter is a depth down to which heterogeneities are
+         * zeroed out.
+         */
+        double vs_to_density_constant;
+        double thermal_alpha;
+        double no_perturbation_depth;
+
+        /**
+         * This parameter allows to remove the degree 0 component of the shear
+         * wave velocity perturbation, which guarantees that average
+         * temperature at a certain depth is the background temperature.
+         */
+        bool zero_out_degree_0;
+
+        /**
+         * This parameter allows to use a lower maximum degree when reading
+         * the spherical harmonic data file.
+         */
+        bool lower_max_degree;
+
+        /**
+         * The maximum degree the users specify, which is only valid when
+         * "lower_max_degree" is set to true.
+         */
+        unsigned int specified_max_degree;
+
+        /**
+         * This parameter gives the reference temperature, which will be
+         * perturbed. In the compressional case the background temperature
+         * will be the adiabat.
+         */
+        double reference_temperature;
+
+        /**
+         * Pointer to an object that reads and processes the spherical
+         * harmonics coefficients
+         */
+        std::unique_ptr<internal::S40RTS::SphericalHarmonicsLookup> spherical_harmonics_lookup;
+
+        /**
+         * Pointer to an object that reads and processes the depths for the
+         * spline knot points.
+         */
+        std::unique_ptr<internal::S40RTS::SplineDepthsLookup> spline_depths_lookup;
+
+        /**
+         * Object containing the data profile.
+         */
+        aspect::Utilities::AsciiDataProfile<dim> profile;
+
+        /**
+         * The column index of the vs to density scaling in the data file
+         */
+        unsigned int vs_to_density_index;
+
+        /**
+         * Whether to use the thermal expansion coefficient from the material model
+         */
+        bool use_material_model_thermal_alpha;
+
+        template <int dim2> friend class PatchOnS40RTS;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/initial_temperature/SAVANI_perturbation.h.bak b/include/aspect/initial_temperature/SAVANI_perturbation.h.bak
new file mode 100644
index 00000000000..ec5c4a22905
--- /dev/null
+++ b/include/aspect/initial_temperature/SAVANI_perturbation.h.bak
@@ -0,0 +1,196 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_SAVANI_perturbation_h
+#define _aspect_initial_temperature_SAVANI_perturbation_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    namespace internal
+    {
+      namespace SAVANI
+      {
+        class SphericalHarmonicsLookup;
+        class SplineDepthsLookup;
+      }
+    }
+
+    /**
+     * A class that describes a perturbed initial temperature field for a
+     * spherical shell geometry model. The perturbation is based on the SAVANI
+     * global shear wave velocity model by Auer et al.
+     * http://n.ethz.ch/~auerl/research.html
+     *
+     * @ingroup InitialTemperatures
+     */
+
+    template <int dim>
+    class SAVANIPerturbation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        SAVANIPerturbation ();
+
+
+        /**
+         * Initialization function. Loads the material data and sets up
+         * pointers.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the Vs as a function of position.
+         */
+        //TODO
+        virtual
+        double get_Vs (const Point<dim> &position) const;
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+      private:
+
+        /**
+         * An enum to describe which method should be chosen to scale vs to density.
+         */
+        enum VsToDensityMethod
+        {
+          file,
+          constant
+        };
+
+        /**
+         * Currently chosen source for vs to density scaling.
+         */
+        VsToDensityMethod vs_to_density_method;
+
+        /**
+         * File directory and names
+         */
+        std::string data_directory;
+        std::string spline_depth_file_name;
+
+        /**
+         * This parameter allows setting the input file for the SAVANI global
+         * shear-wave perturbation.
+         */
+        std::string harmonics_coeffs_file_name;
+
+        /**
+         * The parameters below describe the perturbation of shear wave
+         * velocity into a temperatures perturbation. The first parameter is
+         * constant so far but could be made depth dependent as constraint by
+         * e.g. Forte, A.M. & Woodward, R.L., 1997. Seismic-geodynamic
+         * constraints on three- dimensional structure, vertical flow, and
+         * heat transfer in the mantle, J. Geophys. Res. 102 (B8),
+         * 17,981-17,994.
+         * The last parameter is a depth down to which heterogeneities are
+         * zeroed out.
+         */
+        double vs_to_density_constant;
+        double thermal_alpha;
+        double no_perturbation_depth;
+
+        /**
+         * This parameter allows to remove the degree 0 component of the shear
+         * wave velocity perturbation, which guarantees that average
+         * temperature at a certain depth is the background temperature.
+         */
+        bool zero_out_degree_0;
+
+        /**
+         * This parameter allows to use a lower maximum degree when reading
+         * the spherical harmonic data file.
+         */
+        bool lower_max_degree;
+
+        /**
+         * The maximum degree the users specify, which is only valid when
+         * "lower_max_degree" is set to true.
+         */
+        unsigned int specified_max_degree;
+
+        /**
+         * This parameter gives the reference temperature, which will be
+         * perturbed. In the compressional case the background temperature
+         * will be the adiabat.
+         */
+        double reference_temperature;
+
+        /**
+         * Pointer to an object that reads and processes the spherical
+         * harmonics coefficients
+         */
+        std::unique_ptr<internal::SAVANI::SphericalHarmonicsLookup> spherical_harmonics_lookup;
+
+        /**
+         * Pointer to an object that reads and processes the depths for the
+         * spline knot points.
+         */
+        std::unique_ptr<internal::SAVANI::SplineDepthsLookup> spline_depths_lookup;
+
+        /**
+         * Object containing the data profile.
+         */
+        aspect::Utilities::AsciiDataProfile<dim> profile;
+
+        /**
+         * The column index of the vs to density scaling in the data file
+         */
+        unsigned int vs_to_density_index;
+
+        /**
+         * Whether to use the thermal expansion coefficient from the material model
+         */
+        bool use_material_model_thermal_alpha;
+
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/initial_temperature/adiabatic.h.bak b/include/aspect/initial_temperature/adiabatic.h.bak
new file mode 100644
index 00000000000..766ba7b786e
--- /dev/null
+++ b/include/aspect/initial_temperature/adiabatic.h.bak
@@ -0,0 +1,187 @@
+/*
+  Copyright (C) 2012 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_adiabatic_h
+#define _aspect_initial_temperature_adiabatic_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A namespace for selecting how to determine the age of a
+     * boundary layer. Current options are:
+     *
+     *  'constant': A constant age independent of position.
+     *  'ascii_data': Age is specified in an ascii data file.
+     *  'function': Age is specified as a function in the input file.
+     */
+    namespace BoundaryLayerAgeModel
+    {
+      enum Kind
+      {
+        constant,
+        ascii_data,
+        function
+      };
+
+      /**
+       * Read the lithosphere age model from the parameter file,
+       * using the parameter name given in @p parameter_name, and return the
+       * enum that corresponds to this operation.
+       */
+      BoundaryLayerAgeModel::Kind
+      parse (const std::string &parameter_name,
+             const ParameterHandler &prm);
+    }
+
+    /**
+     * A class that implements adiabatic initial conditions for the
+     * temperature field and, optional, upper and lower thermal boundary
+     * layers calculated using the half-space cooling model. The age of the
+     * boundary layers are input parameters.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class Adiabatic : public Interface<dim>, public Utilities::AsciiDataBoundary<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Adiabatic ();
+
+        void initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataBoundary<dim>::initialize;
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The boundary identifier representing the 'surface' boundary as
+         * reported by the geometry model.
+         */
+        types::boundary_id surface_boundary_id;
+
+        /**
+         * Age of the upper thermal boundary layer at the surface of the
+         * model. If set to zero, no boundary layer will be present in the
+         * model.
+         */
+        double age_top_boundary_layer;
+
+        /* Age of the lower thermal boundary layer. */
+        double age_bottom_boundary_layer;
+
+        /**
+         * Radius (in m) of the initial temperature perturbation at the bottom
+         * of the model domain.
+         */
+        double radius;
+        /**
+         * Amplitude (in K) of the initial temperature perturbation at the
+         * bottom of the model domain.
+         */
+        double amplitude;
+        /*
+         * Position of the initial temperature perturbation (in the
+         * center or at the boundary of the model domain).
+         */
+        std::string perturbation_position;
+
+        /*
+         * Deviation from adiabaticity in a subadiabatic mantle
+         * temperature profile. 0 for an adiabatic temperature
+         * profile.
+         */
+        double subadiabaticity;
+
+        /**
+         * Age model to use for the top boundary layer.
+         */
+        BoundaryLayerAgeModel::Kind top_boundary_layer_age_model;
+
+        /*
+         * Whether to use the half space cooling model, or the plate cooling
+         * model
+         */
+        std::string cooling_model;
+
+        /*
+         * Depth to the base of the lithosphere for plate cooling model, in m
+         */
+        double lithosphere_thickness;
+
+        /**
+         * A function object representing the compositional fields that will
+         * be used as a reference profile for calculating the thermal
+         * diffusivity. The function depends only on depth.
+         */
+        std::unique_ptr<Functions::ParsedFunction<1>> function;
+
+        /**
+         * A function object representing the age of the top boundary layer.
+         */
+        Functions::ParsedFunction<dim> age_function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+
+        /**
+         * Compute the top boundary layer age at the given position.
+         */
+        double top_boundary_layer_age(const Point<dim> &position) const;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_temperature/adiabatic_boundary.h.bak b/include/aspect/initial_temperature/adiabatic_boundary.h.bak
new file mode 100644
index 00000000000..02c6b0c5669
--- /dev/null
+++ b/include/aspect/initial_temperature/adiabatic_boundary.h.bak
@@ -0,0 +1,89 @@
+/*
+  Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_initial_temperature_adiabatic_boundary_h
+#define _aspect_initial_temperature_adiabatic_boundary_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that computes an initial temperature field based
+     * on a user-defined adiabatic boundary. It discretizes the model domain into
+     * two regions separated by an isotherm boundary below which
+     * the temperature increases adiabatically. Above the
+     * user-defined isotherm boundary the temperature linearly
+     * increases from a surface temperature (273.15 K or 0 degree C)
+     * to the isotherm (1673.15 K or 1400 degree C). The user
+     * defines the location of the isotherm boundary with an ascii
+     * data file with the format defined in the ASPECT manual.
+     *
+     * This plugin is developed by Tahiry Rajaonarison, Emmanuel Njinju, and D. Sarah Stamps.
+     */
+    template <int dim>
+    class AdiabaticBoundary : public Interface<dim>, public Utilities::AsciiDataBoundary<dim>
+    {
+      public:
+
+        /**
+         * Constructor.
+         */
+        AdiabaticBoundary ();
+
+        void initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataBoundary<dim>::initialize;
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters that this class needs.
+         */
+        static
+        void declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters above from the parameter file.
+         */
+        void parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        double isotherm_temperature;
+        double surface_temperature;
+        double temperature_gradient;
+        types::boundary_id surface_boundary_id;
+
+    };
+  }
+}
+#endif
diff --git a/include/aspect/initial_temperature/ascii_data.h.bak b/include/aspect/initial_temperature/ascii_data.h.bak
new file mode 100644
index 00000000000..e568cfe53ed
--- /dev/null
+++ b/include/aspect/initial_temperature/ascii_data.h.bak
@@ -0,0 +1,85 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_ascii_data_h
+#define _aspect_initial_temperature_ascii_data_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a prescribed temperature field determined from
+     * a AsciiData input file.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataInitial<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataInitial<dim>::initialize;
+
+        /**
+         * Return the boundary temperature as a function of position. For the
+         * current class, this function returns value from the text files.
+         */
+        double
+        initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_temperature/ascii_data_layered.h.bak b/include/aspect/initial_temperature/ascii_data_layered.h.bak
new file mode 100644
index 00000000000..ccb5157ab13
--- /dev/null
+++ b/include/aspect/initial_temperature/ascii_data_layered.h.bak
@@ -0,0 +1,85 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_ascii_data_layered_h
+#define _aspect_initial_temperature_ascii_data_layered_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements an initial temperature field determined from
+     * AsciiData input files. Each file defines an isotherm as a grid of points.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class AsciiDataLayered : public Utilities::AsciiDataLayered<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiDataLayered ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataLayered<dim>::initialize;
+
+        /**
+         * Return the initial temperature as a function of position. For the
+         * current class, this function returns value from the text files.
+         */
+        double
+        initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_temperature/ascii_profile.h.bak b/include/aspect/initial_temperature/ascii_profile.h.bak
new file mode 100644
index 00000000000..337605de662
--- /dev/null
+++ b/include/aspect/initial_temperature/ascii_profile.h.bak
@@ -0,0 +1,90 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_ascii_profile_h
+#define _aspect_initial_temperature_ascii_profile_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/point.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a prescribed temperature field determined from
+     * a AsciiDataProfile input file.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class AsciiProfile : public Utilities::AsciiDataProfile<dim>, public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        AsciiProfile ();
+
+        /**
+         * Initialization function.
+         */
+        void initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataProfile<dim>::initialize;
+
+        /**
+         * Return the temperature at a given point of the domain.
+         */
+        double initial_temperature (const Point<dim> &p) const override;
+
+        /**
+         * Declare the parameters for the input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler  &prm);
+
+        /**
+         * Read the parameters from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * The column index of the temperature in the data file.
+         */
+        unsigned int temperature_index;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_temperature/box.h.bak b/include/aspect/initial_temperature/box.h.bak
new file mode 100644
index 00000000000..7f9462e17d6
--- /dev/null
+++ b/include/aspect/initial_temperature/box.h.bak
@@ -0,0 +1,122 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_box_h
+#define _aspect_initial_temperature_box_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes a perturbed initial temperature field for a box
+     * geometry.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class PerturbedBox : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+    };
+
+    /**
+     * A class that describes an opposing poles initial temperature field for
+     * a box geometry.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class PolarBox : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+    };
+
+    /**
+     * A field that describes a fractal initial temperature field
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class MandelBox : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+    };
+
+    /**
+     * A class that describes a shaped inclusion initial temperature field for
+     * a box geometry.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class InclusionShapeBox : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature(const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        std::string inclusion_shape;
+        std::string inclusion_gradient;
+        double radius;
+        double ambient_temperature;
+        double inclusion_temperature;
+        double center_x;
+        double center_y;
+        double center_z;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/initial_temperature/continental_geotherm.h.bak b/include/aspect/initial_temperature/continental_geotherm.h.bak
new file mode 100644
index 00000000000..ef4af29d0b4
--- /dev/null
+++ b/include/aspect/initial_temperature/continental_geotherm.h.bak
@@ -0,0 +1,114 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_initial_temperature_continental_geotherm_h
+#define _aspect_initial_temperature_continental_geotherm_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+
+    /**
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class ContinentalGeotherm : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        ContinentalGeotherm ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the initial temperature as a function of depth,
+         * based on the solution of the steady-state heat conduction
+         * differential equation.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Surface temperature
+         */
+        double T0;
+
+        /**
+         * Value of the isotherm defining the
+         * Lithosphere-Asthenosphere boundary.
+         */
+        double LAB_isotherm;
+
+        /**
+         * Vector for the thicknesses of the compositional fields
+         * representing the layers 'upper_crust', 'lower_crust' and 'lithospheric_mantle'.
+         */
+        std::vector<double> thicknesses;
+
+        /**
+         * Vector for the heat production rates of the different
+         * compositional fields, read from parameter file.
+         */
+        std::vector<double> heat_productivities;
+
+        /**
+         * Vector for the thermal conductivities of the different
+         * compositional fields, read from parameter file.
+         */
+        std::vector<double> conductivities;
+
+        /**
+         * Vector for the densities of the different compositional
+         * fields, read from parameter file.
+         */
+        std::vector<double> densities;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_temperature/function.h.bak b/include/aspect/initial_temperature/function.h.bak
new file mode 100644
index 00000000000..65f9891f69b
--- /dev/null
+++ b/include/aspect/initial_temperature/function.h.bak
@@ -0,0 +1,93 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_function_h
+#define _aspect_initial_temperature_function_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements temperature initial conditions based on a
+     * functional description provided in the input file.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Function ();
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the temperature.
+         */
+        Functions::ParsedFunction<dim> function;
+
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_temperature/harmonic_perturbation.h.bak b/include/aspect/initial_temperature/harmonic_perturbation.h.bak
new file mode 100644
index 00000000000..ae58ff944c6
--- /dev/null
+++ b/include/aspect/initial_temperature/harmonic_perturbation.h.bak
@@ -0,0 +1,107 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_harmonic_perturbation_h
+#define _aspect_initial_temperature_harmonic_perturbation_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes a perturbed initially constant temperature field
+     * for any geometry model or dimension in shape of a harmonic function.
+     * For 3D spherical shell models this is achieved by using spherical
+     * harmonics, in any other case sine function are scaled to fit the model
+     * geometry.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class HarmonicPerturbation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+      private:
+
+        /**
+         * The radial/depth wave number of the harmonic perturbation. All wave
+         * number variables are in fact twice the wave number in a
+         * mathematical sense. This allows the user to prescribe a single
+         * up-/downswing or half periods.
+         */
+        int vertical_wave_number;
+
+        /**
+         * The lateral wave number  of the harmonic perturbation in the first
+         * dimension. This is the only lateral wave number in 2D and equals
+         * the degree of the spherical harmonics in a 3D spherical shell.
+         */
+        int lateral_wave_number_1;
+
+        /**
+         * The lateral wave number of the harmonic perturbation in the second
+         * dimension. This is not used in 2D and equals the order of the
+         * spherical harmonics in a 3D spherical shell.
+         */
+        int lateral_wave_number_2;
+
+        /**
+         * The maximal magnitude of the harmonic perturbation.
+         */
+        double magnitude;
+
+        /**
+         * The background temperature the harmonic perturbation is applied on
+         * in an incompressible material model. In case of a compressible
+         * material model the perturbation is applied on top of an adiabatic
+         * profile and this variable is not used at all.
+         */
+        double reference_temperature;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/initial_temperature/interface.h.bak b/include/aspect/initial_temperature/interface.h.bak
new file mode 100644
index 00000000000..9b726ab4f4d
--- /dev/null
+++ b/include/aspect/initial_temperature/interface.h.bak
@@ -0,0 +1,277 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_interface_h
+#define _aspect_initial_temperature_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/point.h>
+#include <deal.II/base/parameter_handler.h>
+
+#include <boost/core/demangle.hpp>
+#include <typeinfo>
+
+
+namespace aspect
+{
+  template <int dim> class SimulatorAccess;
+
+  /**
+   * A namespace in which we define everything that has to do with defining
+   * the initial conditions.
+   *
+   * @ingroup InitialTemperatures
+   */
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A base class for parameterizations of initial conditions.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        virtual
+        double initial_temperature (const Point<dim> &position) const = 0;
+    };
+
+
+    /**
+     * A class that manages all initial condition objects.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Destructor. Made virtual since this class has virtual member
+         * functions.
+         */
+        ~Manager () override;
+
+        /**
+         * Update function. Called once at the beginning of a timestep to
+         * update all plugin objects.
+        */
+        void
+        update() override;
+
+        /**
+         * Declare the parameters of all known initial conditions plugins, as
+         * well as of ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which initial conditions objects will be created; then
+         * let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * A function that calls the initial_temperature functions of all the
+         * individual initial condition objects and adds up the values of the
+         * individual calls.
+         */
+        double
+        initial_temperature (const Point<dim> &position) const;
+
+        /**
+         * A function that is used to register initial temperature objects in such
+         * a way that the Manager can deal with all of them without having to
+         * know them by name. This allows the files in which individual
+         * plugins are implemented to register these plugins, rather than also
+         * having to modify the Manager class by adding the new initial
+         * temperature plugin class.
+         *
+         * @param name A string that identifies the initial temperature model
+         * @param description A text description of what this model does and that
+         * will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that can be
+         * used to declare the parameters that this initial temperature model
+         * wants to read from input files.
+         * @param factory_function A pointer to a function that can create an
+         * object of this initial temperature model.
+         */
+        static
+        void
+        register_initial_temperature (const std::string &name,
+                                      const std::string &description,
+                                      void (*declare_parameters_function) (ParameterHandler &),
+                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+
+        /**
+         * Return a list of names of all initial temperature models currently
+         * used in the computation, as specified in the input file.
+         */
+        const std::vector<std::string> &
+        get_active_initial_temperature_names () const;
+
+        /**
+         * Return a list of pointers to all initial temperature models
+         * currently used in the computation, as specified in the input file.
+         */
+        const std::list<std::unique_ptr<Interface<dim>>> &
+        get_active_initial_temperature_conditions () const;
+
+        /**
+         * Go through the list of all initial temperature models that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename InitialTemperatureType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,InitialTemperatureType>::value>>
+        bool
+        has_matching_initial_temperature_model () const;
+
+        /**
+         * Go through the list of all initial temperature models that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no initial temperature model is active that matches the given type,
+         * throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename InitialTemperatureType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,InitialTemperatureType>::value>>
+        const InitialTemperatureType &
+        get_matching_initial_temperature_model () const;
+
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcInitialTemperatureNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered initial temperature objects.");
+      private:
+        /**
+         * A list of names of initial temperature objects that have been requested
+         * in the parameter file.
+         */
+        std::vector<std::string> model_names;
+
+        /**
+         * A list of enums of initial temperature operators that have been
+         * requested in the parameter file. Each entry is used to modify the
+         * initial temperature field with the values from the associated plugin
+         * in model_names.
+         */
+        std::vector<aspect::Utilities::Operator> model_operators;
+    };
+
+
+
+    template <int dim>
+    template <typename InitialTemperatureType, typename>
+    inline
+    bool
+    Manager<dim>::has_matching_initial_temperature_model () const
+    {
+      return this->template has_matching_plugin_object<InitialTemperatureType>();
+    }
+
+
+    template <int dim>
+    template <typename InitialTemperatureType, typename>
+    inline
+    const InitialTemperatureType &
+    Manager<dim>::get_matching_initial_temperature_model () const
+    {
+      return this->template get_matching_plugin_object<InitialTemperatureType>();
+    }
+
+
+    /**
+     * Return a string that consists of the names of initial temperature models that can
+     * be selected. These names are separated by a vertical line '|' so
+     * that the string can be an input to the deal.II classes
+     * Patterns::Selection or Patterns::MultipleSelection.
+     */
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ();
+
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a initial conditions model, register it with the functions that can
+     * declare their parameters and create these objects.
+     *
+     * @ingroup InitialTemperatures
+     */
+#define ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::InitialTemperature::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::InitialTemperature::Manager<2>::register_initial_temperature, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::InitialTemperature::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::InitialTemperature::Manager<3>::register_initial_temperature, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_temperature/lithosphere_mask.h.bak b/include/aspect/initial_temperature/lithosphere_mask.h.bak
new file mode 100644
index 00000000000..db5442d0efa
--- /dev/null
+++ b/include/aspect/initial_temperature/lithosphere_mask.h.bak
@@ -0,0 +1,168 @@
+/*
+  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_lithosphere_mask_h
+#define _aspect_initial_temperature_lithosphere_mask_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    namespace LABDepth
+    {
+      template <int dim>
+      class LABDepthLookup : public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Empty Constructor.
+           */
+          LABDepthLookup ();
+
+          /**
+           * Initialization function. This function is called once at the
+           * beginning of the program. Checks preconditions.
+           */
+          void
+          initialize ();
+
+          /**
+           * Return LAB depth as a function of position (latitude and longitude). This
+           * function returns either a constant value or values from a text file,
+           * depending on the input parameters. Text files are read in
+           * two dimensions so the third column (depth) is treated as data.
+           */
+          double
+          get_lab_depth (const Point<dim> &position) const;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+        private:
+          /**
+           * Reads in file containing input data.
+           */
+          Utilities::StructuredDataLookup<2> lab_depths;
+
+          /**
+           * Directory in which the LAB depth file is present.
+           */
+          std::string data_directory;
+
+          /**
+           * File name of the LAB depth file.
+           */
+          std::string LAB_file_name;
+
+          /**
+           * An enum to describe where the LAB depth is coming from.
+           */
+          enum LABDepthSource
+          {
+            Value,
+            File
+          };
+
+          /**
+           * Currently chosen source for the LAB depth.
+           */
+          LABDepthSource LAB_depth_source;
+
+          /**
+           * This parameter gives the maximum depth of the lithosphere. The
+           * model returns nans below this depth. This parameter is only used if LAB
+           * depth source is set to 'Value'.
+           */
+          double max_depth;
+      };
+    }
+
+    /**
+     * A class that implements a constant reference temperature
+     * above a specified depth and nans below the specified depth.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class LithosphereMask : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the initial temperature as a function of position. For the
+         * current class, this function uses the given lithosphere temperature
+         * above the lithosphere-asthenosphere boundary and nans below.
+         */
+        double
+        initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * This parameter gives the initial temperature set within the lithosphere.
+         */
+        double lithosphere_temperature;
+
+        /**
+         *
+         */
+        LABDepth::LABDepthLookup<dim> lab_depth_lookup;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/initial_temperature/patch_on_S40RTS.h.bak b/include/aspect/initial_temperature/patch_on_S40RTS.h.bak
new file mode 100644
index 00000000000..45b26fdf57d
--- /dev/null
+++ b/include/aspect/initial_temperature/patch_on_S40RTS.h.bak
@@ -0,0 +1,122 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_patch_on_S40RTS_h
+#define _aspect_initial_temperature_patch_on_S40RTS_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/initial_temperature/S40RTS_perturbation.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a prescribed temperature field determined from
+     * an upper mantle Vs model (input as an ascii file) above a specified depth
+     * and S40RTS below the specified depth.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class PatchOnS40RTS : public Utilities::AsciiDataInitial<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        PatchOnS40RTS ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataInitial<dim>::initialize;
+
+        /**
+         * Return Vs as a function of position. For the
+         * current class, this function returns value from the text files.
+         */
+        double
+        ascii_grid_vs (const Point<dim> &position) const;
+
+        /**
+         * This parameter gives the maximum depth of the Vs ascii grid. The
+         * model will read in Vs from S40RTS below this depth.
+         */
+        double max_grid_depth;
+
+        /**
+         * This parameter gives the range (above maximum grid depth) over which to smooth.
+         * Smoothing is done with a depth weighted combination of the values in the ascii grid and S40RTS
+         * at each point.
+         */
+        double smoothing_length_scale;
+
+        /**
+         * Return the initial temperature as a function of position. For the
+         * current class, this function calculates temperature from ascii grid Vs data
+         * above max_grid_depth and S40RTS Vs data below max_grid_depth.
+         */
+        double
+        initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Declare a member variable of type S40RTSPerturbation that allows us to call
+         * functions from S40RTS_perturbation.cc.
+         */
+        S40RTSPerturbation<dim> s40rts;
+
+        /**
+         * This parameter is the depth down to which shear wave perturbations are
+         * zeroed out.
+         */
+        double no_perturbation_depth_patch;
+
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_temperature/prescribed_temperature.h.bak b/include/aspect/initial_temperature/prescribed_temperature.h.bak
new file mode 100644
index 00000000000..d117b3cf8a6
--- /dev/null
+++ b/include/aspect/initial_temperature/prescribed_temperature.h.bak
@@ -0,0 +1,73 @@
+/*
+  Copyright (C) 2012 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_prescribed_temperature_h
+#define _aspect_initial_prescribed_temperature_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class sets the initial temperature to the precribed temperature
+     * outputs computed by the material model.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class PrescribedTemperature : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run.
+         *
+         * This specific function makes sure that the objects that describe
+         * initial conditions remain available throughout the run of the
+         * program.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+      private:
+        /**
+         * A shared pointer to the initial composition object
+         * that ensures that the current object can continue
+         * to access the initial composition object beyond the
+         * first time step.
+         */
+        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/initial_temperature/random_gaussian_perturbation.h.bak b/include/aspect/initial_temperature/random_gaussian_perturbation.h.bak
new file mode 100644
index 00000000000..bbc9df3bfa6
--- /dev/null
+++ b/include/aspect/initial_temperature/random_gaussian_perturbation.h.bak
@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_random_gaussian_perturbation_h
+#define _aspect_initial_temperature_random_gaussian_perturbation_h
+
+#include <aspect/initial_temperature/interface.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes a perturbation to a zero temperature field
+     * by placing several Gaussians with a given magnitude and width at
+     * random locations throughout the model domain.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class RandomGaussianPerturbation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program and computes the locations and
+         * magnitudes of all perturbations.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+      private:
+
+        /**
+         * The number of the random Gaussian perturbations.
+         */
+        unsigned int n_perturbations;
+
+        /**
+         * The maximal magnitude of the random Gaussian perturbations.
+         */
+        double max_magnitude;
+
+        /**
+         * The width of the random Gaussian perturbations.
+         */
+        double width;
+
+        /**
+         * Vectors that store all (random) locations and magnitudes of
+         * the perturbations.
+         */
+        std::vector<Point<dim>> perturbation_centers;
+        std::vector<double> perturbation_magnitudes;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/initial_temperature/spherical_shell.h.bak b/include/aspect/initial_temperature/spherical_shell.h.bak
new file mode 100644
index 00000000000..8f620e24532
--- /dev/null
+++ b/include/aspect/initial_temperature/spherical_shell.h.bak
@@ -0,0 +1,147 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_initial_temperature_spherical_shell_h
+#define _aspect_initial_temperature_spherical_shell_h
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that describes a perturbed initial temperature field for the
+     * spherical shell.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class SphericalHexagonalPerturbation : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The angular mode is the number of perturbations to apply to the
+         * spherical shell. Historically, this was permanently set to 6 (hence
+         * the class name SphericalHexagonalPerturbation) The default is 6 in
+         * order to provide backwards compatibility.
+         */
+        unsigned int angular_mode;
+
+        /**
+         * The rotation offset describes the number of degrees to rotate the
+         * perturbation counterclockwise. Setting the rotation offset to 0
+         * will cause one of the perturbations to point north/up. Rotation
+         * offset is set to -45 degrees by default in order to provide
+         * backwards compatibility.
+         */
+        double rotation_offset;
+
+        /**
+         * Outer radius.
+         */
+        double R1;
+
+    };
+
+
+    /**
+     * A class that describes a perturbed initial temperature field for the
+     * spherical shell.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class SphericalGaussianPerturbation : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Constructor.
+         */
+        SphericalGaussianPerturbation();
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        double angle;
+        double depth;
+        double amplitude;
+        double sigma;
+        double sign;
+        unsigned int npoint;
+
+        std::vector<double> radial_position;
+        std::vector<double> geotherm;
+
+        /**
+         * Inner radius.
+         */
+        double R0;
+
+        /**
+         * Outer radius.
+         */
+        double R1;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/initial_temperature/world_builder.h.bak b/include/aspect/initial_temperature/world_builder.h.bak
new file mode 100644
index 00000000000..b275e2e5388
--- /dev/null
+++ b/include/aspect/initial_temperature/world_builder.h.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_initial_temperature_world_builder_h
+#define _aspect_initial_temperature_world_builder_h
+
+#include <aspect/global.h>
+
+#ifdef ASPECT_WITH_WORLD_BUILDER
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace WorldBuilder
+{
+  class World;
+}
+
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements temperature initial conditions based on a
+     * functional description provided in the input file through the
+     * World builder.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class WorldBuilder : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        WorldBuilder ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run and after
+         * the SimulatorAccess (if applicable) is initialized.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+      private:
+        /**
+         * A pointer to the WorldBuilder object. Keeping this pointer ensures
+         * that the object doesn't go away while we still need it.
+         */
+        std::shared_ptr<const ::WorldBuilder::World> world_builder;
+    };
+  }
+}
+
+#endif
+#endif
diff --git a/include/aspect/introspection.h.bak b/include/aspect/introspection.h.bak
new file mode 100644
index 00000000000..9ce0167be3a
--- /dev/null
+++ b/include/aspect/introspection.h.bak
@@ -0,0 +1,676 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_introspection_h
+#define _aspect_introspection_h
+
+#include <deal.II/base/index_set.h>
+#include <deal.II/base/quadrature.h>
+#include <deal.II/fe/component_mask.h>
+#include <deal.II/fe/fe_values_extractors.h>
+#include <deal.II/fe/fe.h>
+
+#include <aspect/fe_variable_collection.h>
+#include <aspect/parameters.h>
+
+#include <map>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  /**
+   * Helper function to construct the default list of variables to use
+   * based on the given set of @p parameters.
+   */
+  template <int dim>
+  std::vector<VariableDeclaration<dim>>
+  construct_default_variables (const Parameters<dim> &parameters);
+
+
+  /**
+   * A data structure containing a description of each compositional field.
+   * At present, this structure only includes the field type
+   * (i.e., whether it is of type chemical composition, porosity, etc.).
+   */
+  struct CompositionalFieldDescription
+  {
+    /**
+     * This enum lists available compositional field types.
+     */
+    enum Type
+    {
+      chemical_composition = 0,
+      stress = 1,
+      strain = 2,
+      grain_size = 3,
+      porosity = 4,
+      density = 5,
+      entropy = 6,
+      generic = 7,
+      unspecified = 8
+    } type;
+
+    /**
+     * The number of different types defined in Type.
+    */
+    constexpr static unsigned int n_types = 9;
+
+    /**
+     * This function translates an input string into the
+     * available enum options for the type of compositional field.
+     */
+    static
+    Type
+    parse_type(const std::string &input)
+    {
+      if (input == "chemical composition")
+        return CompositionalFieldDescription::chemical_composition;
+      else if (input == "stress")
+        return CompositionalFieldDescription::stress;
+      else if (input == "strain")
+        return CompositionalFieldDescription::strain;
+      else if (input == "grain size")
+        return CompositionalFieldDescription::grain_size;
+      else if (input == "porosity")
+        return CompositionalFieldDescription::porosity;
+      else if (input == "density")
+        return CompositionalFieldDescription::density;
+      else if (input == "entropy")
+        return CompositionalFieldDescription::entropy;
+      else if (input == "generic")
+        return CompositionalFieldDescription::generic;
+      else if (input == "unspecified")
+        return CompositionalFieldDescription::unspecified;
+      else
+        AssertThrow(false, ExcNotImplemented());
+
+      return CompositionalFieldDescription::Type();
+    }
+  };
+
+  /**
+   * The introspection class provides information about the simulation as a
+   * whole. In particular, it provides symbolic names for things like the
+   * velocity, pressure and other variables, along with their corresponding
+   * vector and scalar FEValues extractors, component masks, etc.
+   *
+   * The purpose of this class is primarily to provide these symbolic names so
+   * that we do not have to use implicit knowledge about the ordering of
+   * variables (e.g., earlier versions of ASPECT had many places where we
+   * built a scalar FEValues extractor at component 'dim' since that is where
+   * we knew that the pressure lies in the finite element; this kind of
+   * implicit knowledge is no longer necessary with the Introspection class).
+   * The Introspection class is used both by the Simulator class itself, but
+   * is also exported to plugins via the SimulatorAccess class.
+   *
+   * @ingroup Simulator
+   */
+  template <int dim>
+  struct Introspection: public FEVariableCollection<dim>
+  {
+    public:
+      /**
+       * Constructor.
+       */
+      Introspection (const std::vector<VariableDeclaration<dim>> &variables,
+                     const Parameters<dim> &parameters);
+
+      /**
+       * Destructor.
+       */
+      ~Introspection ();
+
+
+
+      /**
+       * @name Things that are independent of the current mesh
+       * @{
+       */
+
+      /**
+       * The number of vector components used by the finite element
+       * description of this problem. It equals $d+2+n_c$ where $d$ is the
+       * dimension and equals the number of velocity components, and $n_c$ is
+       * the number of advected (compositional) fields. The remaining
+       * components are the scalar pressure and temperature fields.
+       */
+      const unsigned int n_components;
+
+      /**
+       * The number of compositional fields.
+       */
+      const unsigned int n_compositional_fields;
+
+      /**
+       * A variable that holds whether the temperature field should use a
+       * discontinuous discretization.
+       */
+      const bool use_discontinuous_temperature_discretization;
+
+      /**
+       * A variable that holds whether the composition field(s) should use a
+       * discontinuous discretization.
+       */
+      const std::vector<bool> use_discontinuous_composition_discretization;
+
+      /**
+       * A structure that enumerates the vector components of the finite
+       * element that correspond to each of the variables in this problem.
+       */
+      struct ComponentIndices
+      {
+        unsigned int       velocities[dim];
+        unsigned int       pressure;
+        unsigned int       temperature;
+        std::vector<unsigned int> compositional_fields;
+      };
+      /**
+       * A variable that enumerates the vector components of the finite
+       * element that correspond to each of the variables in this problem.
+       */
+      const ComponentIndices component_indices;
+
+      /**
+       * The number of vector blocks. This equals $3+n_c$ where, in comparison
+       * to the n_components field, the velocity components form a single
+       * block.
+       */
+      const unsigned int n_blocks;
+
+      /**
+       * A structure that enumerates the vector blocks of the finite element
+       * that correspond to each of the variables in this problem.
+       */
+      struct BlockIndices
+      {
+        unsigned int       velocities;
+        unsigned int       pressure;
+        unsigned int       temperature;
+        std::vector<unsigned int> compositional_fields;
+
+        /**
+         * This variable contains the block for each compositional field
+         * where the matrix/sparsity pattern is copied from when we need to
+         * (temporarily) create a matrix. This way, we only need to store a
+         * single sparsity pattern and reuse it for all compositional fields
+         * (assuming they have an identical FiniteElement).
+         */
+        std::vector<unsigned int> compositional_field_sparsity_pattern;
+      };
+
+      /**
+       * A variable that enumerates the vector blocks of the finite element
+       * that correspond to each of the variables in this problem.
+       */
+      const BlockIndices block_indices;
+
+      /**
+       * A structure that contains FEValues extractors for every block of the
+       * finite element used in the overall description.
+       */
+      struct Extractors
+      {
+        Extractors (const ComponentIndices &component_indices);
+
+        const FEValuesExtractors::Vector              velocities;
+        const FEValuesExtractors::Scalar              pressure;
+        const FEValuesExtractors::Scalar              temperature;
+        const std::vector<FEValuesExtractors::Scalar> compositional_fields;
+      };
+
+      /**
+       * A variable that contains extractors for every block of the finite
+       * element used in the overall description.
+       */
+      const Extractors extractors;
+
+      /**
+       * A structure that enumerates the base elements of the finite element
+       * that correspond to each of the variables in this problem.
+       *
+       * The indices here can be used to access the dealii::FiniteElement
+       * that describes the given variable. We support different finite
+       * elements for compositional fields, but we try to reuse the same
+       * element if possible.
+       */
+      struct BaseElements
+      {
+        unsigned int              velocities;
+        unsigned int              pressure;
+        unsigned int              temperature;
+        std::vector<unsigned int> compositional_fields;
+      };
+
+      /**
+       * A variable that enumerates the base elements of the finite element
+       * that correspond to each of the variables in this problem.
+       */
+      const BaseElements base_elements;
+
+      /**
+       * A structure that contains the polynomial degree of the finite element
+       * that correspond to each of the variables in this problem.
+       *
+       * If there are compositional fields, they are all discretized with the
+       * same polynomial degree and, consequently, we only need a single integer.
+       */
+      struct PolynomialDegree
+      {
+        unsigned int       velocities;
+        unsigned int       temperature;
+        unsigned int       compositional_fields;
+      };
+
+      /**
+       * A variable that enumerates the polynomial degree of the finite element
+       * that correspond to each of the variables in this problem.
+       */
+      const PolynomialDegree polynomial_degree;
+
+      /**
+       * A structure that contains appropriate quadrature formulas for the
+       * finite elements that correspond to each of the variables in this problem,
+       * as well as for the complete system (the `system` variable).
+       *
+       * If there are compositional fields, they are all discretized with the
+       * same polynomial degree and, consequently, we only need a single formula.
+       *
+       * The quadrature formulas provided here are chosen such that the
+       * compute integrals with sufficient accuracy. For hypercube cells,
+       * this means in particular that they are of Gauss type with a
+       * number of Gauss points per coordinate direction that is one larger than
+       * the polynomial degree of the finite element per direction. For
+       * example, when using quadratic elements for the velocity, the
+       * corresponding quadrature formula will have three Gauss points per
+       * direction. If the mesh is based on triangles or tetrahedra, the
+       * quadrature formula is not of tensor-product Gauss type, but the
+       * corresponding analog for simplex cells.
+       */
+      struct Quadratures
+      {
+        Quadrature<dim>       velocities;
+        Quadrature<dim>       pressure;
+        Quadrature<dim>       temperature;
+        Quadrature<dim>       compositional_fields;
+        Quadrature<dim>       system;
+      };
+
+      /**
+       * A variable that enumerates the polynomial degree of the finite element
+       * that correspond to each of the variables in this problem.
+       */
+      const Quadratures quadratures;
+
+      /**
+       * A structure that contains appropriate face quadrature formulas for the
+       * finite elements that correspond to each of the variables in this problem,
+       * as well as for the complete system (the `system` variable).
+       *
+       * This structure corresponds to the Quadratures structure above, but for
+       * face integration.
+       */
+      struct FaceQuadratures
+      {
+        Quadrature<dim-1>       velocities;
+        Quadrature<dim-1>       pressure;
+        Quadrature<dim-1>       temperature;
+        Quadrature<dim-1>       compositional_fields;
+        Quadrature<dim-1>       system;
+      };
+
+      /**
+       * A variable that enumerates the polynomial degree of the finite element
+       * that correspond to each of the variables in this problem.
+       */
+      const FaceQuadratures face_quadratures;
+
+      /**
+       * A structure that contains component masks for each of the variables
+       * in this problem. Component masks are a deal.II concept, see the
+       * deal.II glossary.
+       */
+      struct ComponentMasks
+      {
+        ComponentMasks (const FEVariableCollection<dim> &fevs, const Introspection<dim>::ComponentIndices &indices);
+
+        ComponentMask              velocities;
+        ComponentMask              pressure;
+        ComponentMask              temperature;
+        std::vector<ComponentMask> compositional_fields;
+      };
+
+      /**
+       * A variable that contains component masks for each of the variables in
+       * this problem. Component masks are a deal.II concept, see the deal.II
+       * glossary.
+       */
+      const ComponentMasks component_masks;
+
+      /**
+       * @}
+       */
+
+      /**
+       * @name Things that depend on the current mesh
+       * @{
+       */
+      /**
+       * A variable that describes how many of the degrees of freedom on the
+       * current mesh belong to each of the n_blocks blocks of the finite
+       * element.
+       */
+      std::vector<types::global_dof_index> system_dofs_per_block;
+
+      /**
+       * A structure that contains index sets describing which of the globally
+       * enumerated degrees of freedom are owned by or are relevant to the
+       * current processor in a parallel computation.
+       */
+      struct IndexSets
+      {
+        /**
+         * An index set that indicates which (among all) degrees of freedom
+         * are relevant to the current processor. See the deal.II
+         * documentation for the definition of the term "locally relevant
+         * degrees of freedom".
+         */
+        IndexSet system_relevant_set;
+
+        /**
+         * A collection of index sets that for each of the vector blocks of
+         * this finite element represents the global indices of the degrees of
+         * freedom owned by this processor. The n_blocks elements of this
+         * array form a mutually exclusive decomposition of the index set
+         * containing all locally owned degrees of freedom.
+         */
+        std::vector<IndexSet> system_partitioning;
+
+        /**
+         * A collection of index sets that for each of the vector blocks of
+         * this finite element represents the global indices of the degrees of
+         * freedom are relevant to this processor. The n_blocks elements of
+         * this array form a mutually exclusive decomposition of the index set
+         * containing all locally relevant degrees of freedom, i.e., of the
+         * system_relevant_set index set.
+         */
+        std::vector<IndexSet> system_relevant_partitioning;
+
+        /**
+         * A collection of index sets for each vector block of the Stokes
+         * system (velocity and pressure). This variable contains the first
+         * two elements of system_partitioning.
+         */
+        std::vector<IndexSet> stokes_partitioning;
+
+        /**
+         * Pressure unknowns that are locally owned. This IndexSet is needed
+         * if velocity and pressure end up in the same block and is used for
+         * pressure scaling and in make_pressure_rhs_compatible(). If melt
+         * transport is enabled, this field is unused and not filled.
+         */
+        IndexSet locally_owned_pressure_dofs;
+
+        /**
+         * Fluid and compaction pressure unknowns that are locally owned. Only
+         * valid if melt transport is enabled.
+         */
+        IndexSet locally_owned_melt_pressure_dofs;
+
+        /**
+         * Fluid pressure unknowns that are locally owned. Only valid if melt
+         * transport is enabled.
+         */
+        IndexSet locally_owned_fluid_pressure_dofs;
+      };
+
+      /**
+       * A variable that contains index sets describing which of the globally
+       * enumerated degrees of freedom are owned by the current processor in a
+       * parallel computation.
+       */
+      IndexSets index_sets;
+
+      /**
+       * A variable that contains the field method for the temperature field
+       * and is used to determine how to solve it when solving a timestep.
+       */
+      typename Parameters<dim>::AdvectionFieldMethod::Kind temperature_method;
+
+      /**
+       * A vector that contains a field method for every compositional
+       * field and is used to determine how to solve a particular field when
+       * solving a timestep.
+       */
+      std::vector<typename Parameters<dim>::AdvectionFieldMethod::Kind> compositional_field_methods;
+
+      /**
+       * @}
+       */
+
+      /**
+       * Return a vector that contains the base element indices of the deal.II FiniteElement
+       * that are used for compositional fields. Note that compositional fields can share the
+       * same base element, so this vector can (and usually will) be smaller than the number
+       * of compositional fields. The function get_compositional_field_indices_with_base_element()
+       * can be used to translate from base element index to all compositional field indices
+       * using the specified base element.
+       * If several fields are the finite element type (same degree and both continuous or both
+       * discontinuous), they share base elements. If you have no compositional fields, the
+       * vector returned has length 0. If all compositional fields have the same finite element
+       * space, the length is 1.
+       */
+      const std::vector<unsigned int> &
+      get_composition_base_element_indices() const;
+
+      /**
+       * Return a vector with all compositional field indices that belong to a given
+       * base element index as returned by get_composition_base_element_indices().
+       * The indices returned are therefore between 0 and n_compositional_fields-1.
+       * If you have a single compositional field, this function returns {0} when passing
+       * in base_element_index=0.
+       */
+      const std::vector<unsigned int> &
+      get_compositional_field_indices_with_base_element(const unsigned int base_element_index) const;
+
+      /**
+       * A function that gets the name of a compositional field as an input
+       * parameter and returns its index. If the name is not found, an
+       * exception is thrown.
+       *
+       * @param name The name of compositional field (as specified in the
+       * input file)
+       */
+      unsigned int
+      compositional_index_for_name (const std::string &name) const;
+
+      /**
+       * A function that gets the index of a compositional field as an input
+       * parameter and returns its name.
+       *
+       * @param index The index of compositional field
+       */
+      std::string
+      name_for_compositional_index (const unsigned int index) const;
+
+      /**
+       * A function that returns the full list of compositional field names.
+       */
+      const std::vector<std::string> &
+      get_composition_names () const;
+
+      /**
+       * A function that returns the full vector of compositional
+       * field descriptions.
+       */
+      const std::vector<CompositionalFieldDescription> &
+      get_composition_descriptions () const;
+
+      /**
+       * A function that returns the names of
+       * compositional fields that correspond to chemical compositions.
+       *
+       * This function is shorthand for
+       * get_names_for_fields_of_type(CompositionalFieldDescription::chemical_composition).
+       */
+      const std::vector<std::string> &
+      chemical_composition_field_names () const;
+
+      /**
+       * A function that returns the indices of
+       * compositional fields that correspond to chemical compositions.
+       *
+       * This function is shorthand for
+       * get_indices_for_fields_of_type(CompositionalFieldDescription::chemical_composition).
+       */
+      const std::vector<unsigned int> &
+      chemical_composition_field_indices () const;
+
+      /**
+       * A function that returns the number of
+       * compositional fields that correspond to chemical compositions.
+       *
+       * This function is shorthand for
+       * get_number_of_fields_of_type(CompositionalFieldDescription::chemical_composition).
+       */
+      unsigned int
+      n_chemical_composition_fields () const;
+
+      /**
+       * A function that gets the type of a compositional field as an input
+       * parameter and returns if any compositional field of that type is
+       * used in this simulation.
+       *
+       * @param type The type of compositional field (as specified in the
+       * input file)
+       */
+      bool
+      composition_type_exists (const CompositionalFieldDescription::Type &type) const;
+
+      /**
+       * A function that gets the type of a compositional field as an input
+       * parameter and returns the index of the first compositional field of
+       * this type used in this simulation. If no such field is found, the
+       * function returns the number of compositional fields.
+       *
+       * @param type The type of compositional field (as specified in the
+       * input file)
+       */
+      unsigned int
+      find_composition_type (const CompositionalFieldDescription::Type &type) const;
+
+      /**
+       * A function that gets the name of a compositional field as an input
+       * parameter and returns if the compositional field is used in this
+       * simulation.
+       *
+       * @param name The name of compositional field (as specified in the
+       * input file)
+       */
+      bool
+      compositional_name_exists (const std::string &name) const;
+
+      /**
+       * Get the indices of the compositional fields which are of a
+       * particular type (chemical composition, porosity, etc.).
+       */
+      const std::vector<unsigned int> &
+      get_indices_for_fields_of_type (const CompositionalFieldDescription::Type &type) const;
+
+      /**
+       * Get the names of the compositional fields which are of a
+       * particular type (chemical composition, porosity, etc.).
+       */
+      const std::vector<std::string> &
+      get_names_for_fields_of_type (const CompositionalFieldDescription::Type &type) const;
+
+      /**
+       * Get the number of compositional fields which are of a
+       * particular type (chemical composition, porosity, etc.).
+       */
+      unsigned int
+      get_number_of_fields_of_type (const CompositionalFieldDescription::Type &type) const;
+
+      /**
+       * A function that gets a component index as an input
+       * parameter and returns if the component is one of the stokes system
+       * (i.e. if it is the pressure or one of the velocity components).
+       *
+       * @param component_index The component index to check.
+       */
+      bool
+      is_stokes_component (const unsigned int component_index) const;
+
+      /**
+       * A function that gets a component index as an input
+       * parameter and returns if the component is one of the
+       * compositional fields.
+       *
+       * @param component_index The component index to check.
+       */
+      bool
+      is_composition_component (const unsigned int component_index) const;
+
+    private:
+      /**
+       * A vector that stores the names of the compositional fields that will
+       * be used in the simulation.
+       */
+      std::vector<std::string> composition_names;
+
+      /**
+       * A vector that stores descriptions of each compositional field,
+       * including its type (i.e. whether the compositional field corresponds
+       * to chemical composition, porosity etc.).
+       */
+      std::vector<CompositionalFieldDescription> composition_descriptions;
+
+      /**
+       * A vector of vectors of composition names that stores the
+       * names of the compositional fields corresponding to each field type
+       * given in CompositionalFieldDescription.
+       */
+      std::vector<std::vector<std::string>> composition_names_for_type;
+
+      /**
+       * A vector of vectors of composition indices that stores the
+       * indices of the compositional fields corresponding to each field type
+       * given in CompositionalFieldDescription.
+       */
+      std::vector<std::vector<unsigned int>> composition_indices_for_type;
+
+      /**
+       * List of base element indices used by compositional fields. Cached
+       * result returned by get_composition_base_element_indices().
+       */
+      std::vector<unsigned int> composition_base_element_indices;
+
+      /**
+       * Map base_element_index to list of compositional field indices that use
+       * that base element. Cached result returned by
+       * get_compositional_field_indices_with_base_element();
+       */
+      std::map<unsigned int, std::vector<unsigned int>> compositional_field_indices_with_base_element;
+  };
+}
+
+
+#endif
diff --git a/include/aspect/lateral_averaging.h.bak b/include/aspect/lateral_averaging.h.bak
new file mode 100644
index 00000000000..d18d38a9a6c
--- /dev/null
+++ b/include/aspect/lateral_averaging.h.bak
@@ -0,0 +1,326 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_lateral_averaging_h
+#define _aspect_lateral_averaging_h
+
+#include <aspect/simulator_access.h>
+
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace internal
+  {
+    /**
+     * This is the base class for all the functors implemented. Each is
+     * used to compute one of the properties that will be laterally
+     * averaged. The point of the base class is to allow handing over
+     * a variable of type
+     * <code> std::vector<std::unique_ptr<FunctorBase<dim>>> </code> to the
+     * LateralAveraging::get_averages() function.
+     */
+    template <int dim>
+    class FunctorBase
+    {
+      public:
+        /**
+         * operator() will have @p in and @p out filled out if @p true. By default
+         * returns false.
+         */
+        virtual
+        bool
+        need_material_properties() const;
+
+        /**
+         * If this functor needs additional material model outputs create them
+         * in here. By default, this does nothing.
+         */
+        virtual
+        void
+        create_additional_material_model_outputs (const unsigned int n_points,
+                                                  MaterialModel::MaterialModelOutputs<dim> &outputs) const;
+
+        /**
+         * Called once at the beginning of compute_lateral_averages() to setup
+         * internal data structures with the number of quadrature points.
+         */
+        virtual
+        void
+        setup(const unsigned int q_points);
+
+        /**
+         * This takes @p in material model inputs and @p out outputs (which are filled
+         * if need_material_properties() == true), an initialized FEValues
+         * object for a cell, and the current solution vector as inputs.
+         * Functions in derived classes should then evaluate the desired quantity
+         * and return the results in the output vector, which is q_points long.
+         */
+        virtual
+        void
+        operator()(const MaterialModel::MaterialModelInputs<dim> &in,
+                   const MaterialModel::MaterialModelOutputs<dim> &out,
+                   const FEValues<dim> &fe_values,
+                   const LinearAlgebra::BlockVector &solution,
+                   std::vector<double> &output) = 0;
+
+        /**
+         * Provide an (empty) virtual destructor.
+         */
+        virtual
+        ~FunctorBase();
+    };
+  }
+
+  /**
+   * LateralAveraging is a class that performs various averaging operations
+   * on the solution.  The functions of this class take a vector as an argument.
+   * The model is divided into depth slices where the number of slices is the
+   * length of the output vector. Each function averages a specific quantity
+   * (as specified by their name), and that quantity is averaged laterally
+   * for each depth slice.
+   *
+   * Plugins may access the LateralAveraging plugin through the SimulatorAccess
+   * function get_lateral_averaging(), and then query that for the desired
+   * averaged quantity.
+   *
+   * @ingroup Simulator
+   */
+  template <int dim>
+  class LateralAveraging : public SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * @deprecated: This function is deprecated and only maintained for backward compatibility.
+       * Use the function compute_lateral_averages() with the same arguments instead.
+       */
+      DEAL_II_DEPRECATED
+      std::vector<std::vector<double>>
+      get_averages(const unsigned int n_slices,
+                   const std::vector<std::string> &property_names) const;
+
+      /**
+       * Return a depth profile of lateral averages of the selected
+       * @p property_names. This function is a convenience interface for
+       * the other functions of the same name and is more efficient for
+       * multiple properties than calling multiple of the single property functions
+       * sequentially. This version of the function creates @p n_slices
+       * equidistant depth slices to compute averages in.
+       *
+       * @param n_slices The number of equidistant depth slices
+       * to perform the averaging in.
+       * @param property_names Names of the available quantities to average.
+       * Check the implementation of this function for available names.
+       * @return The output vector of laterally averaged values. Each vector
+       * has the same size of @p n_slices, and there are
+       * as many vectors returned as names in @p property_names.
+       */
+      std::vector<std::vector<double>>
+      compute_lateral_averages(const unsigned int n_slices,
+                               const std::vector<std::string> &property_names) const;
+
+      /**
+       * Return a depth profile of lateral averages of the selected
+       * @p property_names. This function is a convenience interface for
+       * the other functions of the same name and is more efficient for
+       * multiple properties than calling multiple of the single property
+       * functions sequentially. This version of the function uses @p depth_bounds
+       * to determine the upper and lower boundary of each depth slice,
+       * and returns one averaged value per slice (= one less than the
+       * number of depth bounds).
+       *
+       * @param depth_bounds The boundaries of the depth slices to compute
+       * averages in. It is expected to be a vector of monotonically increasing
+       * depth values with consecutive entries representing the minimum and
+       * maximum depth of each depth slice. All depths smaller than
+       * entry 0 or larger than the last entry are ignored, and depths
+       * between entries 0 and 1 fall into depth slice 0, and so on.
+       * @param property_names Names of the available quantities to average.
+       * Check the implementation of this function for available names.
+       * @return The output vector of laterally averaged values. The length
+       * of each vector is one less than the number of @p depth_bounds,
+       * and there are as many vectors returned as names in @p property_names.
+       */
+      std::vector<std::vector<double>>
+      compute_lateral_averages(const std::vector<double> &depth_bounds,
+                               const std::vector<std::string> &property_names) const;
+
+      /**
+       * Return a depth profile of lateral averages. This function is the
+       * low-level implementation for the other functions of the same name
+       * and is more efficient for multiple properties than calling multiple
+       * of the single property functions sequentially. This version of the
+       * function uses @p depth_bounds to determine the upper and lower
+       * boundary of each depth slice, and returns one averaged value per slice
+       * (= one less than the number of depth bounds).
+       * The vector of functors @p functors must contain one or more
+       * objects of classes that are derived from FunctorBase and are used to
+       * fill the values vectors. All of the other functions in this class use
+       * this low-level implementation for the actual computation.
+       * Using this function allows to provide user-defined functors to average
+       * properties not already implemented (e.g. to average additional
+       * material model outputs).
+       *
+       * @param depth_bounds The boundaries of the depth slices to compute
+       * averages in. It is expected to be a vector of monotonically increasing
+       * depth values with consecutive entries representing the minimum and
+       * maximum depth of each depth slice. All depths smaller than
+       * entry 0 or larger than the last entry are ignored, and depths
+       * between entries 0 and 1 fall into depth slice 0, and so on.
+       * @param functors Instances of a class derived from FunctorBase
+       * that are used to compute the averaged properties.
+       * @return The output vectors of depth averaged values. The
+       * function returns one vector of doubles per property and uses
+       * @p depth_bounds to determine the depth extents of each slice.
+       * Each returned vector has the same size (one entry less than
+       * the number of @p depth_bounds).
+       */
+      std::vector<std::vector<double>>
+      compute_lateral_averages(const std::vector<double> &depth_bounds,
+                               std::vector<std::unique_ptr<internal::FunctorBase<dim>>> &functors) const;
+
+      /**
+       * Fill the argument with a set of lateral averages of the current
+       * temperature field. The function fills a vector that contains average
+       * field values over slices of the domain of same depth.
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_temperature_averages(std::vector<double> &values) const;
+
+      /**
+       * Fill the argument with a set of lateral averages of the current
+       * compositional fields.
+       *
+       * @param composition_index The index of the compositional field whose
+       * matrix we want to assemble (0 <= composition_index < number of
+       * compositional fields in this problem).
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_composition_averages(const unsigned int composition_index,
+                               std::vector<double> &values) const;
+
+      /**
+       * Compute a lateral average of the current viscosity.
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_viscosity_averages(std::vector<double> &values) const;
+
+      /**
+       * Compute a lateral average of the log10 of the current viscosity.
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_log_viscosity_averages(std::vector<double> &values) const;
+
+      /**
+       * Compute a lateral average of the current velocity magnitude.
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_velocity_magnitude_averages(std::vector<double> &values) const;
+
+      /**
+       * Compute a lateral average of the current sinking velocity.
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_sinking_velocity_averages(std::vector<double> &values) const;
+
+      /**
+       * Compute a lateral average of the current rising velocity.
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_rising_velocity_averages(std::vector<double> &values) const;
+
+      /**
+       * Compute a lateral average of the seismic shear wave speed: Vs.
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_Vs_averages(std::vector<double> &values) const;
+
+      /**
+       * Compute a lateral average of the seismic pressure wave speed: Vp.
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_Vp_averages(std::vector<double> &values) const;
+
+      /**
+       * Compute a lateral average of the vertical heat flux, with the sign
+       * convention of positive heat flux when it flows upwards.
+       *
+       * @param values The output vector of laterally averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void
+      get_vertical_heat_flux_averages(std::vector<double> &values) const;
+
+      /**
+       * Compute a lateral average of the vertical mass flux. Note that
+       * while get_vertical_heat_flux_averages() computes the average
+       * vertical heat flux (positive or negative), this function computes
+       * the average of the total mass flux through a certain layer
+       * (both down- and upward motion counted positively).
+       *
+       * @param values The output vector of laterally averaged values.
+       */
+      void
+      get_vertical_mass_flux_averages(std::vector<double> &values) const;
+  };
+}
+
+
+#endif
diff --git a/include/aspect/material_model/ascii_reference_profile.h.bak b/include/aspect/material_model/ascii_reference_profile.h.bak
new file mode 100644
index 00000000000..b04a689640c
--- /dev/null
+++ b/include/aspect/material_model/ascii_reference_profile.h.bak
@@ -0,0 +1,167 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_model_ascii_reference_profile_h
+#define _aspect_model_ascii_reference_profile_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that reads in a reference profile from an ascii file
+     * and computes properties based on this profile.
+     *
+     * The viscosity is computed as
+     * \f[
+     * \eta(z,T) = \eta_r(z) \eta_0 \exp\left(-A \frac{T - T_\text{adi}}{T_\text{adi}}\right)."
+     * \f]
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class AsciiReferenceProfile : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize variables.
+         */
+        AsciiReferenceProfile ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run and after
+         * the SimulatorAccess (if applicable) is initialized.
+         */
+        void
+        initialize () override;
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+        /**
+         * Add the named outputs for seismic velocities.
+         */
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+      private:
+        /**
+         * Use truncated anelastic approximation?
+         */
+        bool tala;
+
+        /**
+         * The reference viscosity
+         */
+        double viscosity;
+
+        /**
+         * The constant $A$ in the temperature dependence of viscosity
+         * $\exp\left(-A \frac{T - T_\text{adi}}{T_\text{adi}}\right).$
+         */
+        double thermal_viscosity_exponent;
+
+        /**
+         * A list of constants that make up the piece-wise constant function
+         * $\eta_r(z)$, which determines the depth dependence of viscosity,
+         * and is multiplied with the reference viscosity and the
+         * temperature dependence to compute the viscosity $\eta(z,T)$.
+         */
+        std::vector<double> viscosity_prefactors;
+
+        /**
+         * A list of depths that determine the locations of the jumps in
+         * the piece-wise constant function $\eta_r(z)$, which describes the
+         * depth dependence of viscosity.
+         */
+        std::vector<double> transition_depths;
+
+        double thermal_conductivity;
+
+        /**
+         * Object containing the data profile.
+         */
+        aspect::Utilities::AsciiDataProfile<dim> profile;
+
+        /**
+         * The column indices of the temperature, pressure, and density column
+         * in the data file.
+         */
+        unsigned int density_index;
+        unsigned int thermal_expansivity_index;
+        unsigned int specific_heat_index;
+        unsigned int compressibility_index;
+
+        /**
+         * The column indices of the seismic velocities and their temperature
+         * derivatives columns in the data file.
+         */
+        unsigned int seismic_vp_index;
+        unsigned int seismic_vs_index;
+        unsigned int seismic_dvp_dT_index;
+        unsigned int seismic_dvs_dT_index;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/averaging.h.bak b/include/aspect/material_model/averaging.h.bak
new file mode 100644
index 00000000000..d6d4431ff42
--- /dev/null
+++ b/include/aspect/material_model/averaging.h.bak
@@ -0,0 +1,168 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_averaging_h
+#define _aspect_material_model_averaging_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * An enum to define what kind of averaging operations are implemented.
+     * These are:
+     *
+     * - No averaging, i.e., leave the values as they were provided by the
+     * material model.
+     *
+     * - Arithmetic averaging: Set the values of each output quantity at
+     * every quadrature point to \f[ \bar x = \frac 1Q \sum_{q=1}^Q x_q \f]
+     * where $x_q$ are the values at the $Q$ quadrature points.
+     *
+     * - Harmonic averaging: Set the values of each output quantity at every
+     * quadrature point to \f[ \bar x = \left(\frac 1Q \sum_{q=1}^Q
+     * \frac{1}{x_q}\right)^{-1} \f] where $x_q$ are the values at the $Q$
+     * quadrature points.
+     *
+     * - Geometric averaging: Set the values of each output quantity at
+     * every quadrature point to \f[ \bar x = \left(\prod_{q=1}^Q
+     * x_q\right)^{1/Q} \f] where $x_q$ are the values at the $Q$ quadrature
+     * points.
+     *
+     * - Pick largest: Set the values of each output quantity at every
+     * quadrature point to \f[ \bar x = \max_{1\le q\le Q} x_q \f] where $x_q$
+     * are the values at the $Q$ quadrature points.
+     *
+     * - Log average: Set the values of each output quantity at every
+     * quadrature point to \f[ \bar x = {10}^{\frac 1Q \sum_{q=1}^Q \log_{10}
+     * x_q} \f] where $x_q$ are the values at the $Q$ quadrature points.
+     *
+     * - NWD Arithmetic averaging: Set the values of each output quantity at
+     * every quadrature point to \f[ \bar x = \frac {\sum_{q=1}^Q W_q * x_q}
+     * {\sum_{q=1}^Q W_q} \f] where $x_q$ are the values and $w$ the weights
+     * at the $Q$ quadrature points.
+     *
+     * - NWD Harmonic averaging: Set the values of each output quantity at every
+     * quadrature point to \f[ \bar x = \frac{\sum_{q=1}^Q w_q }{ \sum_{q=1}^Q
+     * \frac{w_q}{x_q}} \f] where $x_q$ are the values and $w$ the weights at
+     * the $Q$ quadrature points.
+     *
+     * - NWD Geometric averaging: Set the values of each output quantity at
+     * every quadrature point to \f[ \bar x = \frac{ \sum_{q=1}^Q w_q x_q}
+     * {\sum_{q=1}^Q w_q} \f] where $x_q$ are the values and $w$ the weights
+     * at the $Q$ quadrature points.
+     */
+    enum AveragingOperation
+    {
+      none,
+      arithmetic_average,
+      harmonic_average,
+      geometric_average,
+      pick_largest,
+      log_average,
+      nwd_arithmetic_average,
+      nwd_harmonic_average,
+      nwd_geometric_average
+    };
+
+    /**
+     * A material model that applies an average of the quadrature points in a cell  to
+     * a ''base model'' chosen from any of the other available material models.
+     * @ingroup MaterialModels
+     */
+
+    template <int dim>
+    class Averaging : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void
+        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
+                  typename Interface<dim>::MaterialModelOutputs &out) const override;
+        /**
+         * Method to declare parameters related to depth-dependent model
+         */
+        static void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Method to parse parameters related to depth-dependent model
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Method that indicates whether material is compressible. Depth dependent model is compressible
+         * if and only if base model is compressible.
+         */
+        bool is_compressible () const override;
+
+
+
+      private:
+
+        /**
+         * Parse a string representing one of the options returned by
+         * get_averaging_operation_names(), and return the corresponding
+         * AveragingOperation value.
+         */
+        AveragingOperation
+        parse_averaging_operation_name (const std::string &s);
+
+        /**
+         * Given the averaging @p operation, a description of where the
+         * quadrature points are located on the given cell, and a mapping,
+         * perform this operation on all elements of the @p values structure.
+         */
+        void
+        average (const AveragingOperation averaging_operation,
+                 const std::vector<Point<dim>>    &position,
+                 std::vector<double>           &values_out) const;
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * The bell shape limit variable stores the maximum extend of the bell
+         * shape for the Normalized Weighed Distance (NWD) averages.
+         */
+        double bell_shape_limit;
+        /**
+         * The averaging operation variable stores the chosen averaging
+         * operation.
+         */
+        AveragingOperation averaging_operation;
+        /**
+         * Pointer to the material model used as the base model
+         */
+        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/compositing.h.bak b/include/aspect/material_model/compositing.h.bak
new file mode 100644
index 00000000000..8f9b30a7f1d
--- /dev/null
+++ b/include/aspect/material_model/compositing.h.bak
@@ -0,0 +1,136 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_compositing_h
+#define _aspect_material_model_compositing_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <map>
+#include <vector>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Property
+    {
+      /**
+       * An enum to define what material properties are available.
+       */
+      enum MaterialProperty
+      {
+        viscosity,
+        density,
+        thermal_expansion_coefficient,
+        specific_heat,
+        thermal_conductivity,
+        compressibility,
+        entropy_derivative_pressure,
+        entropy_derivative_temperature,
+        reaction_terms
+      };
+    }
+
+    /**
+     * A material model that selects properties from other
+     * (non-compositing) material models.
+     *
+     * @ingroup MaterialModels
+     */
+
+    template <int dim>
+    class Compositing : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * @copydoc MaterialModel::Interface::initialize()
+         */
+        void
+        initialize () override;
+
+        /**
+         * @copydoc MaterialModel::Interface::evaluate()
+         */
+        void
+        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
+                  typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * If this material model can produce additional named outputs
+         * that are derived from NamedAdditionalOutputs, create them in here.
+         */
+        void
+        create_additional_named_outputs (typename Interface<dim>::MaterialModelOutputs &outputs) const override;
+
+        /**
+         * @copydoc MaterialModel::Interface::declare_parameters()
+         */
+        static void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * @copydoc MaterialModel::Interface::parse_parameters()
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @copydoc MaterialModel::Interface::is_compressible()
+         *
+         * Returns value from material model providing compressibility.
+         */
+        bool is_compressible () const override;
+
+
+
+      private:
+        /**
+         * Copy desired properties from material model outputs
+         * produced by another material model,
+         *
+         * @param model_index Internal index for pointer to the material model evaluated
+         * @param base_output Properties generated by the material model specified
+         * @param out MaterialModelOutputs to be used.
+         */
+        void
+        copy_required_properties(const unsigned int model_index,
+                                 const typename Interface<dim>::MaterialModelOutputs &base_output,
+                                 typename Interface<dim>::MaterialModelOutputs &out) const;
+
+        /**
+         * Map specifying which material model is responsible for a
+         * property.
+         */
+        std::map<Property::MaterialProperty, unsigned int> model_property_map;
+
+        /**
+         * Names of and pointers to the material models used for
+         * compositing.
+         */
+        std::vector<std::string>                             model_names;
+        std::vector<std::unique_ptr<Interface<dim>>> models;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/composition_reaction.h.bak b/include/aspect/material_model/composition_reaction.h.bak
new file mode 100644
index 00000000000..81a83dd7815
--- /dev/null
+++ b/include/aspect/material_model/composition_reaction.h.bak
@@ -0,0 +1,125 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_composition_reaction_h
+#define _aspect_material_model_composition_reaction_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that consists of globally constant values for all
+     * material parameters except that the density decays linearly with the
+     * temperature.
+     *
+     * The model is considered incompressible, following the definition
+     * described in Interface::is_compressible. This is essentially the
+     * material model used in the step-32 tutorial program.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class CompositionReaction : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate material properties.
+         */
+        void evaluate(const MaterialModelInputs<dim> &in,
+                      MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+        /**
+         * Create additional outputs
+         */
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+      private:
+        double reference_T;
+        double eta;
+        double composition_viscosity_prefactor_1;
+        double composition_viscosity_prefactor_2;
+        double thermal_viscosity_exponent;
+
+        /**
+         * The thermal conductivity.
+         */
+        double k_value;
+
+        EquationOfState::LinearizedIncompressible<dim> equation_of_state;
+
+        /**
+         * Above this depth the compositional fields react: The first field
+         * gets converted to the second field.
+         */
+        double reaction_depth;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/depth_dependent.h.bak b/include/aspect/material_model/depth_dependent.h.bak
new file mode 100644
index 00000000000..0613ef53d9e
--- /dev/null
+++ b/include/aspect/material_model/depth_dependent.h.bak
@@ -0,0 +1,151 @@
+/*
+  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_depth_dependent_h
+#define _aspect_material_model_depth_dependent_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/rheology/ascii_depth_profile.h>
+
+#include <deal.II/base/function_lib.h>
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that applies a depth-dependent viscosity to a ''base model''
+     * chosen from any of the other available material models. This depth-dependent
+     * material model allows the user to specify a depth-dependent reference viscosity
+     * either through a parsed function, lists of depth and viscosity values, or a file.
+     * The current implementation only allows for depth-dependence of viscosity - all
+     * other properties are derived from the base model.
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class DepthDependent : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialize the base model at the beginning of the run.
+         */
+        void initialize() override;
+
+        /**
+         * Update the base model and viscosity function at the beginning of
+         * each timestep.
+         */
+        void update() override;
+
+        /**
+         * Method that indicates whether material is compressible. Depth dependent model is compressible
+         * if and only if base model is compressible.
+         */
+        bool is_compressible () const override;
+
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void
+        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
+                  typename Interface<dim>::MaterialModelOutputs &out) const override;
+        /**
+         * Method to declare parameters related to depth-dependent model
+         */
+        static void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Method to parse parameters related to depth-dependent model
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+      private:
+        /**
+         * An enum to describe where the depth dependency of the viscosity is coming from.
+         */
+        enum ViscositySource
+        {
+          function,
+          file,
+          list,
+          none
+        };
+
+        /**
+         * The viscosity that will be used as a reference for computing the depth-dependent
+         * prefactor.
+         */
+        double reference_viscosity;
+
+        /**
+         * Currently chosen source for the viscosity.
+         */
+        ViscositySource viscosity_source;
+
+        /**
+         * Data structures to store depth and viscosity lookup tables as well as interpolating
+         * function to calculate viscosity for File Depth dependence method
+         */
+        std::unique_ptr<Functions::InterpolatedTensorProductGridData<1>> viscosity_file_function;
+
+        /**
+         * Function to calculate depth-dependent multiplicative prefactor to be applied
+         * to base model viscosity.
+         */
+        double
+        calculate_depth_dependent_prefactor(const double &depth) const;
+
+        /**
+         * Values of depth specified by the user if using the depth dependence method 'list'
+         */
+        std::vector<double> depth_values;
+        std::vector<double> viscosity_values;
+
+        /**
+         * Parsed function that specifies viscosity depth-dependence when using the 'function'
+         * method.
+         */
+        Functions::ParsedFunction<1> viscosity_function;
+
+        /**
+         * Pointer to the material model used as the base model
+         */
+        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
+
+        /**
+         * Pointer to the rheology model used for depth-dependence from an
+         * ascii file
+         */
+        std::unique_ptr<Rheology::AsciiDepthProfile<dim>> depth_dependent_rheology;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/diffusion_dislocation.h.bak b/include/aspect/material_model/diffusion_dislocation.h.bak
new file mode 100644
index 00000000000..61a420891ad
--- /dev/null
+++ b/include/aspect/material_model/diffusion_dislocation.h.bak
@@ -0,0 +1,128 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_diffusion_dislocation_h
+#define _aspect_material_model_diffusion_dislocation_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/rheology/diffusion_dislocation.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model based on a viscous rheology including diffusion and
+     * dislocation creep.
+     *
+     * The effective viscosity is defined as the harmonic mean of the two
+     * effective viscosity functions describing diffusion and dislocation creep:
+     * @f[
+     *   v_\text{eff} = \left( \frac{1}{v_\text{eff}^\text{diff}} + \frac{1}{v_\text{eff}^\text{dis}} \right)^{-1}
+     * @f]
+     * where
+     * @f[
+     *   v_\text{eff}^\text{diff} = A_\text{diff}^{-1} \exp\left(\frac{E_\text{diff} + PV_\text{diff}}{RT}\right),
+     * @f]
+     * and
+     * @f[
+     *   v_\text{eff}^\text{dis} =  A_\text{dis}^{\frac{-1}{n_\text{dis}}} \dot{\varepsilon}^{\frac{1-n}{n}}
+     *                        \exp\left(\frac{E_\text{diff} + PV_\text{diff}}{n_\text{dis}RT}\right)
+     * @f]
+     * where $\dot{\varepsilon}$ is the second invariant of the strain rate tensor,
+     * $A_i$ are prefactors where $i$ corresponds to diffusion or dislocation creep,
+     * $E_i$ are the activation energies, $V_i$ are the activation volumes,
+     * $\rho_m$ is the mantle density, $R$ is the gas constant,
+     * $T$ is temperature, and $P$ is pressure.
+     *
+     * Several model parameters (reference densities, thermal expansivities
+     * and rheology parameters) can be defined per-compositional field.
+     * For each material parameter the user supplies a comma delimited list of
+     * length N+1, where N is the number of compositional fields.  The
+     * additional field corresponds to the value for background mantle.  They
+     * should be ordered ``background, composition1, composition2...''
+     *
+     * If a list of values is given for the density and thermal expansivity,
+     * the volume weighted sum of the values of each of the compositional fields
+     * is used in their place, for example
+     * $\rho = \sum \left( \rho_i V_i \right)$
+     *
+     * The individual output viscosities for each compositional field are
+     * also averaged. The user can choose from a range of options for this
+     * viscosity averaging. If only one value is given for any of these parameters,
+     * all compositions are assigned the same value.
+     * The first value in the list is the value assigned to "background mantle"
+     * (regions where the sum of the compositional fields is < 1.0).
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class DiffusionDislocation : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the
+         * continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         *
+         * This material model is incompressible.
+         */
+        bool is_compressible () const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Object for computing viscous creep viscosities.
+         */
+        Rheology::DiffusionDislocation<dim> diffusion_dislocation;
+
+        double reference_T;
+
+        double thermal_diffusivity;
+        double heat_capacity;
+
+        std::vector<double> densities;
+        std::vector<double> thermal_expansivities;
+
+        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
+
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/drucker_prager.h.bak b/include/aspect/material_model/drucker_prager.h.bak
new file mode 100644
index 00000000000..8cb0fe5581d
--- /dev/null
+++ b/include/aspect/material_model/drucker_prager.h.bak
@@ -0,0 +1,170 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_drucker_prager_h
+#define _aspect_material_model_drucker_prager_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/rheology/drucker_prager.h>
+#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that consists of globally constant values for all
+     * material parameters except density and viscosity.
+     *
+     * The model is considered incompressible, following the definition
+     * described in Interface::is_compressible.
+     *
+     * The viscosity is computed according to the Drucker Prager frictional
+     * plasticity criterion based on a user-defined internal angle of friction $\phi$
+     * and cohesion $C$. In 3D:
+     * $\sigma_y = \frac{6 C \cos(\phi)}{\sqrt{3} (3+\sin(\phi))} +
+     * \frac{6 P \sin(\phi)}{\sqrt{3} (3+\sin(\phi))}$,
+     * where $P$ is the pressure.
+     * See for example Zienkiewicz, O. C., Humpheson, C. and Lewis, R. W. (1975),
+     * G&eacute;otechnique 25, No. 4, 671-689.
+     * With this formulation we circumscribe instead of inscribe the Mohr Coulomb
+     * yield surface.
+     * In 2D the Drucker Prager yield surface is the same
+     * as the Mohr Coulomb surface:
+     * $\sigma_y = P \sin(\phi) + C \cos(\phi)$.
+     * Note that in 2D for $\phi=0$, these criteria
+     * revert to the von Mises criterion (no pressure dependence).
+     * See for example Thieulot, C. (2011), PEPI 188, 47-68.
+     *
+     * Note that we enforce the pressure to be positive in the computation of
+     * the yield strength by replacing it with
+     * a zero value whenever it is negative to prevent negative
+     * yield strengths and viscosities.
+     * We then use the computed yield strength to scale back the viscosity on
+     * to the yield surface using the Viscosity Rescaling Method described in
+     * Kachanov, L. M. (2004), Fundamentals of the Theory of Plasticity,
+     * Dover Publications, Inc.
+     *
+     * To avoid numerically unfavourably large (or even negative) viscosity ranges,
+     * we cut off the viscosity with a user-defined minimum and maximum viscosity:
+     * $\eta_eff = \frac{1}{\frac{1}{\eta_min + \eta}+\\
+     * \frac{1}{\eta_max}}$.
+     *
+     * Note that this model uses the formulation that assumes an incompressible
+     * medium despite the fact that the density follows the law
+     * $\rho(T)=\rho_0(1-\beta(T-T_{\text{ref}}))$.
+     *
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class DruckerPrager : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+
+        double reference_T;
+        double thermal_conductivities;
+
+        EquationOfState::LinearizedIncompressible<dim> equation_of_state;
+
+        /*
+         * Objects for computing plastic stresses, viscosities, and additional outputs
+         */
+        Rheology::DruckerPrager<dim> drucker_prager_plasticity;
+
+        /**
+         * The angle of internal friction
+         */
+        double angle_of_internal_friction;
+
+        /**
+         * The cohesion
+         */
+        double cohesion;
+
+        /**
+         * The applied viscosity bounds
+         */
+        double minimum_viscosity;
+        double maximum_viscosity;
+
+        /**
+         * The reference strain rate used as a first estimate
+         */
+        double reference_strain_rate;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/entropy_model.h.bak b/include/aspect/material_model/entropy_model.h.bak
new file mode 100644
index 00000000000..c245055e8b8
--- /dev/null
+++ b/include/aspect/material_model/entropy_model.h.bak
@@ -0,0 +1,187 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_entropy_model_h
+#define _aspect_material_model_entropy_model_h
+
+#include <aspect/material_model/interface.h>
+
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/rheology/ascii_depth_profile.h>
+#include <aspect/material_model/rheology/drucker_prager.h>
+#include <aspect/material_model/steinberger.h>
+#include <aspect/material_model/utilities.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+    /**
+     * A material model that is designed to use pressure and entropy (rather
+     * than pressure and temperature) as independent variables. It will look up
+     * all material properties in a data table for a given pressure and
+     * entropy, and will additionally provide an additional output object of
+     * type PrescribedTemperatureOutputs filled with the temperature, and
+     * an additional output object of type PrescribedFieldOutput filled with
+     * the densities (necessary for the projected density approximation of
+     * the Stokes equation).
+     * @ingroup MaterialModels
+     */
+
+    template <int dim>
+    class EntropyModel: public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. Loads the material data and sets up
+         * pointers.
+         */
+        void
+        initialize () override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void
+        evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                 MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+        /**
+         * Creates additional output objects of
+         * type PrescribedTemperatureOutputs filled with the temperature
+         * (necessary for solving the entropy equation), and
+         * an additional output object of type PrescribedFieldOutput filled with
+         * the densities (necessary for the projected density approximation of
+         * the Stokes equation). Also creates SeismicAdditionalOutputs for
+         * postprocessing purposes.
+         */
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+      private:
+
+        double angle_of_internal_friction;
+        double cohesion;
+
+        /**
+         * Minimum/Maximum viscosity and lateral viscosity variations.
+         */
+        double min_eta;
+        double max_eta;
+        double max_lateral_eta_variation;
+
+        /**
+         * The value for thermal conductivity. It can be a constant
+         * for the whole domain, or P-T dependent.
+         */
+        double thermal_conductivity_value;
+        double thermal_conductivity (const double temperature,
+                                     const double pressure,
+                                     const Point<dim> &position) const;
+
+        enum ConductivityFormulation
+        {
+          constant,
+          p_T_dependent
+        } conductivity_formulation;
+
+        /**
+         * Parameters for the temperature- and pressure dependence of the
+         * thermal conductivity.
+         */
+        std::vector<double> conductivity_transition_depths;
+        std::vector<double> reference_thermal_conductivities;
+        std::vector<double> conductivity_pressure_dependencies;
+        std::vector<double> conductivity_reference_temperatures;
+        std::vector<double> conductivity_exponents;
+        std::vector<double> saturation_scaling;
+        double maximum_conductivity;
+
+        /**
+         * Information about the location of data files.
+         */
+        std::string data_directory;
+        std::vector<std::string> material_file_names;
+        std::string lateral_viscosity_file_name;
+
+        /**
+         * List of pointers to the EntropyReader that reads in material data for
+         * given entropy and pressure. There is one pointer/object per lookup file.
+         */
+        std::vector<std::unique_ptr<MaterialUtilities::Lookup::EntropyReader>> entropy_reader;
+
+        /**
+         * Pointer to an object that reads and processes data for the lateral
+         * temperature dependency of viscosity.
+         */
+        std::unique_ptr<internal::LateralViscosityLookup> lateral_viscosity_prefactor_lookup;
+
+        /**
+         * Objects for computing plastic stresses, viscosities, and additional outputs
+         */
+        Rheology::DruckerPrager<dim> drucker_prager_plasticity;
+
+        /**
+         * Pointer to the rheology model used for depth-dependence from an
+         * ascii file
+         */
+        std::unique_ptr<Rheology::AsciiDepthProfile<dim>> depth_dependent_rheology;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/equation_of_state/interface.h.bak b/include/aspect/material_model/equation_of_state/interface.h.bak
new file mode 100644
index 00000000000..eee4c557502
--- /dev/null
+++ b/include/aspect/material_model/equation_of_state/interface.h.bak
@@ -0,0 +1,125 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_equation_of_state_interface_h
+#define _aspect_material_model_equation_of_state_interface_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/material_model/interface.h>
+
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A data structure containing output fields that can be filled by the
+     * evaluate() function of an EquationOfState model. It contains those
+     * properties of the MaterialModelOutputs that are connected to the
+     * equation of state (or the thermodynamic properties). Output values
+     * are computed separately for each composition and phase.
+     *
+     * Accordingly, the vectors are the values for each compositional field
+     * and individual phase at one specific location.
+     */
+    template <int dim>
+    struct EquationOfStateOutputs
+    {
+      /**
+       * Constructor. Initialize the various arrays of this structure with the
+       * given number of compositions and phases.
+       *
+       * @param n_individual_compositions_and_phases The number of vector quantities
+       * for which input will be provided, and outputs should be filled. Note that this
+       * number does not have to be the number of compositions, it can be smaller (if
+       * some compositional fields do not represent volumetric compositions, but tracked
+       * quantities like strain) or larger (if there is a background field, or some
+       * compositions have several high-pressure phases). It is the responsibility
+       * of the material model and equation of state object to interpret the
+       * entries consistently.
+       */
+      EquationOfStateOutputs (const unsigned int n_individual_compositions_and_phases);
+
+      /**
+       * Density values for each composition and phase.
+       */
+      std::vector<double> densities;
+
+      /**
+       * Thermal expansion coefficients for each composition and phase. It is defined
+       * as $\alpha = - \frac{1}{\rho} \frac{\partial\rho}{\partial T}$
+       */
+      std::vector<double> thermal_expansion_coefficients;
+
+      /**
+       * Specific heat for each composition and phase.
+       */
+      std::vector<double> specific_heat_capacities;
+
+      /**
+       * Compressibility for each composition and phase. The compressibility is defined
+       * as $\kappa = \frac{1}{\rho} \frac{\partial\rho}{\partial p}$.
+       */
+      std::vector<double> compressibilities;
+
+      /**
+       * The product of the change of entropy $\Delta S$ at a phase transition
+       * and the derivative of the phase function $X=X(p,T,\mathfrak c,\mathbf
+       * x)$ with regard to pressure for each composition and phase.
+       */
+      std::vector<double> entropy_derivative_pressure;
+
+      /**
+       * The product of (minus) the change of entropy $-\Delta S$ at a phase
+       * transition and the derivative of the phase function
+       * $X=X(p,T,\mathfrak c,\mathbf x)$ with regard to temperature for
+       * each composition and phase.
+       */
+      std::vector<double> entropy_derivative_temperature;
+    };
+
+
+
+    /**
+     * This function takes the output of an equation of state @p eos_outputs_all_phases,
+     * which contains the data for all compositions and all of their phases at the
+     * current conditions and uses a PhaseFunction object @p phase_function to compute
+     * the effective value of equation of state properties for each individual composition.
+     * Essentially it computes which phase is stable at the current conditions
+     * (described in @p phase_in) and fills the equation of state output @p eos_outputs with
+     * the properties of these stable phases.
+     * @p eos_outputs now only contains as many entries as volumetric compositions (potentially
+     * plus one for the background field, if the input @p eos_outputs_all_phases contained
+     * one and the phase function contained one as well).
+     */
+    template <int dim>
+    void
+    phase_average_equation_of_state_outputs(const EquationOfStateOutputs<dim> &eos_outputs_all_phases,
+                                            const std::vector<double> &phase_function_values,
+                                            const std::vector<unsigned int> &n_phase_transitions_per_composition,
+                                            EquationOfStateOutputs<dim> &eos_outputs);
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/equation_of_state/linearized_incompressible.h.bak b/include/aspect/material_model/equation_of_state/linearized_incompressible.h.bak
new file mode 100644
index 00000000000..5b1a4c0ffa7
--- /dev/null
+++ b/include/aspect/material_model/equation_of_state/linearized_incompressible.h.bak
@@ -0,0 +1,140 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_equation_of_state_linearized_incompressible_h
+#define _aspect_material_model_equation_of_state_linearized_incompressible_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+      using namespace dealii;
+
+      /**
+       * A simplified, incompressible equation of state where the density depends linearly
+       * on temperature and composition, using the equation
+       * $\rho(p,T,\mathfrak c) = \left(1-\alpha (T-T_0)\right)\rho_0 + \sum_i \Delta\rho_i \; \mathfrak c_i.$ "
+       * There is no pressure-dependence of the density, and all other material properties
+       * relating to the equation of state are assumed to be constant and identical for each
+       * composition.
+       */
+      template <int dim>
+      class LinearizedIncompressible
+      {
+        public:
+          /**
+           * A function that computes the output of the equation of state @p out
+           * for all compositions, given the inputs in @p in and an index @p q.
+           * More specifically, the inputs structure MaterialModelInputs contains
+           * a number of vectors, one for each input property, containing the
+           * material model inputs at a number of different locations. The equation
+           * of state model only evaluates one location (for each function call),
+           * and the index q determines which entry of each of these vectors of
+           * inputs is used.
+           * Using these inputs, the equation of state outputs are computed
+           * individually for each composition given in the inputs, and the outputs
+           * structure is filled with the equation of state outputs, which contain a
+           * number of vectors, one for each output property, with each vector
+           * containing the separate outputs for each composition.
+           */
+          void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                        const unsigned int q,
+                        MaterialModel::EquationOfStateOutputs<dim> &out) const;
+
+          /**
+           * Return whether the model is compressible or not. Incompressibility
+           * does not necessarily imply that the density is constant; rather, it
+           * may still depend on temperature or pressure. In the current
+           * context, compressibility means whether we should solve the continuity
+           * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+           * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+           */
+          bool is_compressible () const;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           * The optional parameter @p n_compositions determines the maximum
+           * number of compositions the equation of state is set up with,
+           * in other words, how many compositional fields influence the
+           * density.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm,
+                              const unsigned int n_compositions = 0);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           * The optional parameter @p n_compositions determines the maximum
+           * number of compositions the equation of state is set up with,
+           * and should have the same value as the parameter with the same
+           * name in the declare_parameters() function.
+           */
+          void
+          parse_parameters (ParameterHandler &prm,
+                            const unsigned int n_compositions = 0);
+
+
+        private:
+          /**
+           * The reference density $\rho_0$ used in the computation of the density.
+           */
+          double reference_rho;
+
+          /**
+           * The reference temperature $T_0$ used in the computation of the density.
+           */
+          double reference_T;
+
+          /**
+           * The constant thermal expansivity $\alpha$ used in the computation of the density.
+           */
+          double thermal_alpha;
+
+          /**
+           * The constant specific heat.
+           */
+          double reference_specific_heat;
+
+          /**
+           * The maximum number of compositions that densities will be computed for, and,
+           * accordingly, the maximum number of compositions the equation of state can be
+           * evaluated with.
+           */
+          unsigned int maximum_number_of_compositions;
+
+          /**
+           * The density difference $\Delta\rho_i$ between each composition $\mathfrak c_i$
+           * and the background.
+           */
+          std::vector<double> compositional_delta_rhos;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/equation_of_state/multicomponent_compressible.h.bak b/include/aspect/material_model/equation_of_state/multicomponent_compressible.h.bak
new file mode 100644
index 00000000000..33c54d2ec23
--- /dev/null
+++ b/include/aspect/material_model/equation_of_state/multicomponent_compressible.h.bak
@@ -0,0 +1,143 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_equation_of_state_multicomponent_compressible_h
+#define _aspect_material_model_equation_of_state_multicomponent_compressible_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+      using namespace dealii;
+
+      /**
+       * A compressible equation of state that is intended for use with multiple compositional
+       * fields. For each material property, the user supplies a comma delimited list of
+       * length N+1, where N is the number of compositional fields used in the computation.
+       * The first entry corresponds to the "background" (which is also why there are N+1 entries).
+       *
+       * If a single value is given, then all the compositional fields are given
+       * that value. Other lengths of lists are not allowed. The material parameters
+       * for each compositional field are calculated self-consistently,
+       * assuming a constant pressure derivative of the isothermal bulk modulus ($K_T'$)
+       * at the reference temperature (i.e. a Murnaghan equation of state),
+       * a constant ratio of the thermal expansivity ($\alpha$) and
+       * isothermal compressibility ($\beta_T$), and a constant isochoric
+       * specific heat $C_v$. This leads to the following expressions for the material
+       * properties of each material:
+       *
+       * $\rho(p,T) = \rho_0 f^{1/K_T'}$
+       * $C_p(p,T) = C_v + (\alpha T \frac{\alpha}{\beta} f^{-1-(1/K_T')} / \rho_0)$
+       * $\alpha(p, T) = \alpha_0/f$
+       * $\beta_T(p, T) = \beta_0/f$
+       * $f = (1 + (p - \frac{\alpha}{\beta}(T-T_0)) K_T' \beta)$.
+       *
+       * where $\rho$ is the density and $C_p$ is the isobaric heat capacity.
+       * $f$ is a scaling factor for $\alpha$ and $\beta_T$.
+       */
+      template <int dim>
+      class MulticomponentCompressible :  public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * A function that computes the output of the equation of state @p out
+           * for all compositions, given the inputs in @p in and an index q that
+           * determines which entry of the vector of inputs is used.
+           */
+          void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                        const unsigned int q,
+                        MaterialModel::EquationOfStateOutputs<dim> &out) const;
+
+          /**
+           * Return whether the model is compressible or not. Incompressibility
+           * does not necessarily imply that the density is constant; rather, it
+           * may still depend on temperature or pressure. In the current
+           * context, compressibility means whether we should solve the continuity
+           * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+           * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+           * This model is compressible.
+           */
+          bool is_compressible () const;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           * The optional parameter @p n_compositions determines the maximum
+           * number of compositions the equation of state is set up with,
+           * in other words, how many compositional fields influence the
+           * density.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           * The optional parameter @p n_compositions determines the maximum
+           * number of compositions the equation of state is set up with,
+           * and should have the same value as the parameter with the same
+           * name in the declare_parameters() function.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+          /**
+           * Vector for reference_densities, read from parameter file .
+           */
+          std::vector<double> reference_densities;
+
+        private:
+          /**
+           * Vector for reference temperatures, read from parameter file .
+           */
+          std::vector<double> reference_temperatures;
+
+          /**
+           * Vector for reference compressibilities, read from parameter file.
+           */
+          std::vector<double> reference_isothermal_compressibilities;
+
+          /**
+           * Vector for isothermal bulk modulus pressure derivatives, read from parameter file.
+           */
+          std::vector<double> isothermal_bulk_modulus_pressure_derivatives;
+
+          /**
+           * Vector for reference thermal expansivities, read from parameter file.
+           */
+          std::vector<double> reference_thermal_expansivities;
+
+          /**
+           * Vector for isochoric specific heats, read from parameter file.
+           */
+          std::vector<double> isochoric_specific_heats;
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/equation_of_state/multicomponent_incompressible.h.bak b/include/aspect/material_model/equation_of_state/multicomponent_incompressible.h.bak
new file mode 100644
index 00000000000..793c509b218
--- /dev/null
+++ b/include/aspect/material_model/equation_of_state/multicomponent_incompressible.h.bak
@@ -0,0 +1,127 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_equation_of_state_multicomponent_incompressible_h
+#define _aspect_material_model_equation_of_state_multicomponent_incompressible_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+      using namespace dealii;
+
+      /**
+       * An incompressible equation of state that is intended for use with multiple compositional
+       * fields and potentially phases. For each material property, the user supplies a comma
+       * delimited list of length N+P+1, where N is the number of compositional fields used in
+       * the computation, P is the total number of phase transitions.
+       * The first entry corresponds to the "background" (which is also why there are N+P+1 entries).
+       *
+       * If a single value is given, then all the compositional fields and phases are given
+       * that value. Other lengths of lists are not allowed. For a given
+       * compositional field and phase the material parameters are treated as constant,
+       * except density, which varies linearly with temperature according to the equation:
+       *
+       * $\rho(p,T,\mathfrak c) = \left(1-\alpha_i (T-T_0)\right) \rho_0(\mathfrak c_i).$
+       *
+       * There is no pressure-dependence of the density.
+       */
+      template <int dim>
+      class MulticomponentIncompressible :  public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * A function that computes the output of the equation of state @p out
+           * for all compositions and phases, given the inputs in @p in and an
+           * index input_index that determines which entry of the vector of inputs is used.
+           */
+          void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                        const unsigned int input_index,
+                        MaterialModel::EquationOfStateOutputs<dim> &out) const;
+
+          /**
+           * Return whether the model is compressible or not. Incompressibility
+           * does not necessarily imply that the density is constant; rather, it
+           * may still depend on temperature or pressure. In the current
+           * context, compressibility means whether we should solve the continuity
+           * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+           * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+           */
+          bool is_compressible () const;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           * The optional parameter @p default_thermal_expansion determines
+           * the default value of the thermal expansivity used in the
+           * equation of state.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm,
+                              const double default_thermal_expansion = 3.5e-5);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           * If @p expected_n_phases_per_composition points to a vector of
+           * unsigned integers this is considered the number of phases
+           * for each compositional field and will be checked against the parsed
+           * parameters.
+           */
+          void
+          parse_parameters (ParameterHandler &prm,
+                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
+
+        private:
+          /**
+           * Vector of reference densities $\rho_0$ with one entry per composition and phase plus one
+           * for the background field.
+           */
+          std::vector<double> densities;
+
+          /**
+           * The reference temperature $T_0$ used in the computation of the density.
+           * All components use the same reference temperature.
+           */
+          double reference_T;
+
+          /**
+           * Vector of thermal expansivities with one entry per composition and phase plus one
+           * for the background field.
+           */
+          std::vector<double> thermal_expansivities;
+
+          /**
+           * Vector of specific heat capacities with one entry per composition and phase plus one
+           * for the background field.
+           */
+          std::vector<double> specific_heats;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/equation_of_state/thermodynamic_table_lookup.h.bak b/include/aspect/material_model/equation_of_state/thermodynamic_table_lookup.h.bak
new file mode 100644
index 00000000000..2e798906904
--- /dev/null
+++ b/include/aspect/material_model/equation_of_state/thermodynamic_table_lookup.h.bak
@@ -0,0 +1,236 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_equation_of_state_thermodynamic_table_lookup_h
+#define _aspect_material_model_equation_of_state_thermodynamic_table_lookup_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+      using namespace dealii;
+
+      /**
+       * An equation of state class that reads thermodynamic properties
+       * from pressure-temperature tables in input files. These input files
+       * can be created using codes such as Perple_X or HeFESTo.
+       */
+      template <int dim>
+      class ThermodynamicTableLookup : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Initialization function. Loads the material data and sets up
+           * pointers.
+           */
+          void
+          initialize ();
+
+          /**
+           * Returns the number of lookups
+           */
+          virtual unsigned int number_of_lookups() const;
+
+          /**
+           * Return whether the model is compressible or not.  Incompressibility
+           * does not necessarily imply that the density is constant; rather, it
+           * may still depend on temperature or pressure. In the current
+           * context, compressibility means whether we should solve the continuity
+           * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+           * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+           */
+          bool is_compressible () const;
+
+          /**
+           * Function to compute the thermodynamic properties in @p out given the
+           * inputs in @p in over all evaluation points.
+           * This function also fills the mass_fraction and volume_fraction vectors.
+           */
+          void
+          evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                   std::vector<MaterialModel::EquationOfStateOutputs<dim>> &eos_outputs) const;
+
+          /**
+           * Function to fill the seismic velocity and phase volume additional outputs
+           */
+          void
+          fill_additional_outputs(const MaterialModel::MaterialModelInputs<dim> &in,
+                                  const std::vector<std::vector<double>> &volume_fractions,
+                                  MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+          void
+          create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+          const MaterialModel::MaterialUtilities::Lookup::MaterialLookup &
+          get_material_lookup (unsigned int lookup_index) const;
+
+
+        private:
+          unsigned int n_material_lookups;
+          bool use_bilinear_interpolation;
+          bool latent_heat;
+
+          /**
+           * Information about the location of data files.
+           */
+          std::string data_directory;
+          std::vector<std::string> material_file_names;
+          std::vector<std::string> derivatives_file_names;
+
+          /**
+           * The maximum number of substeps over the temperature pressure range
+           * to calculate the averaged enthalpy gradient over a cell
+           */
+          unsigned int max_latent_heat_substeps;
+
+          /**
+           * The format of the provided material files. Currently we support
+           * the Perple_X and HeFESTo data formats.
+           */
+          enum formats
+          {
+            perplex,
+            hefesto
+          } material_file_format;
+
+          /**
+           * List of pointers to objects that read and process data we get from
+           * material data files. There is one pointer/object per lookup file.
+           */
+          std::vector<std::unique_ptr<MaterialModel::MaterialUtilities::Lookup::MaterialLookup>> material_lookup;
+
+          /**
+           * Vector of strings containing the names of the unique phases in all the material lookups.
+           */
+          std::vector<std::string> unique_phase_names;
+
+          /**
+           * Vector of vector of unsigned ints which constitutes mappings
+           * between lookup phase name vectors and unique_phase_names.
+           * The element unique_phase_indices[i][j] contains the
+           * index of phase name j from lookup i as it is found in unique_phase_names.
+           */
+          std::vector<std::vector<unsigned int>> unique_phase_indices;
+
+          /**
+           * Vector of strings containing the names of the dominant phases in all the material lookups.
+           * In case the lookup table contains one string with the dominant phase rather than separate
+           * columns with volume fraction for each phase, this vector will be used instead of the
+           * unique_phase_names vector above.
+           */
+          std::vector<std::string> list_of_dominant_phases;
+
+          /**
+           * Each lookup table reads in their own dominant phases and assigns indices based
+           * on all phases in that particular lookup. Since a model can have more than one
+           * lookup, it might have more phases than present in each lookup. We want to output
+           * unique/consistent indices for each phase, so we have to convert the indices of a phase
+           * in the individual lookup to the index in the global list of phases. This vector
+           * of vectors of unsigned int stores the global index for each lookup (so there are
+           * as many inner vectors as lookups, and each one stores the indices for an individual
+           * lookup, to be filled in the initialize function).
+           *
+           * In case the lookup table contains one string with the dominant phase rather than separate
+           * columns with volume fraction for each phase, this vector will be used instead of the
+           * unique_phase_indices vector above.
+           */
+          std::vector<std::vector<unsigned int>> global_index_of_lookup_phase;
+
+          /**
+           * Compute the specific heat and thermal expansivity using the pressure
+           * and temperature derivatives of the specific enthalpy.
+           * This evaluation incorporates the effects of latent heat production.
+           */
+          void evaluate_thermal_enthalpy_derivatives(const MaterialModel::MaterialModelInputs<dim> &in,
+                                                     std::vector<MaterialModel::EquationOfStateOutputs<dim>> &eos_outputs) const;
+
+          /**
+           * Returns the cell-wise averaged enthalpy derivatives for the evaluate
+           * function and postprocessors. The function returns two pairs, the
+           * first one represents the temperature derivative, the second one the
+           * pressure derivative. The first member of each pair is the derivative,
+           * the second one the number of vertex combinations the function could
+           * use to compute the derivative. The second member is useful to handle
+           * the case no suitable combination of vertices could be found (e.g.
+           * if the temperature and pressure on all vertices of the current
+           * cell is identical.
+           */
+          std::array<std::pair<double, unsigned int>,2>
+          enthalpy_derivatives (const typename Interface<dim>::MaterialModelInputs &in) const;
+
+          void fill_seismic_velocities (const MaterialModel::MaterialModelInputs<dim> &in,
+                                        const std::vector<double> &composite_densities,
+                                        const std::vector<std::vector<double>> &volume_fractions,
+                                        SeismicAdditionalOutputs<dim> *seismic_out) const;
+
+          /**
+           * This function uses the MaterialModelInputs &in to fill the output_values
+           * of the phase_volume_fractions_out output object with the volume
+           * fractions of each of the unique phases at each of the evaluation points.
+           * These volume fractions are obtained from the Perple_X- or HeFESTo-derived
+           * pressure-temperature lookup tables.
+           * The filled output_values object is a vector of vector<double>;
+           * the outer vector is expected to have a size that equals the number
+           * of unique phases, the inner vector is expected to have a size that
+           * equals the number of evaluation points.
+           */
+          void fill_phase_volume_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                                            const std::vector<std::vector<double>> &volume_fractions,
+                                            NamedAdditionalMaterialOutputs<dim> *phase_volume_fractions_out) const;
+
+          /**
+           * This function uses the MaterialModelInputs &in to fill the output_values
+           * of the dominant_phases_out output object with the index of the
+           * dominant phase at each of the evaluation points.
+           * The phases are obtained from the Perple_X- or HeFESTo-derived
+           * pressure-temperature lookup tables.
+           * The filled output_values object is a vector of vector<unsigned int>;
+           * the outer vector is expected to have a size of 1, the inner vector is
+           * expected to have a size that equals the number of evaluation points.
+           */
+          void fill_dominant_phases (const MaterialModel::MaterialModelInputs<dim> &in,
+                                     const std::vector<std::vector<double>> &volume_fractions,
+                                     PhaseOutputs<dim> &dominant_phases_out) const;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/grain_size.h.bak b/include/aspect/material_model/grain_size.h.bak
new file mode 100644
index 00000000000..6aed6159ddc
--- /dev/null
+++ b/include/aspect/material_model/grain_size.h.bak
@@ -0,0 +1,490 @@
+/*
+  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_model_grain_size_h
+#define _aspect_model_grain_size_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/rheology/drucker_prager.h>
+
+#include <deal.II/matrix_free/fe_point_evaluation.h>
+#include <deal.II/sundials/arkode.h>
+
+#include <array>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * Additional output fields for the dislocation viscosity parameters
+     * to be added to the MaterialModel::MaterialModelOutputs structure
+     * and filled in the MaterialModel::GrainSize::evaluate() function.
+     */
+    template <int dim>
+    class DislocationViscosityOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        DislocationViscosityOutputs(const unsigned int n_points);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * Dislocation viscosities at the evaluation points passed to
+         * the instance of MaterialModel::Interface::evaluate() that fills
+         * the current object.
+         */
+        std::vector<double> dislocation_viscosities;
+
+        /**
+         * Diffusion viscosities at the evaluation points passed to
+         * the instance of MaterialModel::Interface::evaluate() that fills
+         * the current object.
+         */
+        std::vector<double> diffusion_viscosities;
+    };
+
+
+
+    /**
+     * A material model that relies on compositional fields that stand for
+     * average grain sizes of a mineral phase and source terms for them that
+     * determine the grain size evolution in dependence of the strain rate,
+     * temperature, phase transitions, and the creep regime.
+     * This material model only works if a compositional field
+     * named 'grain_size' is present. In the diffusion
+     * creep regime, the viscosity depends on this grain size. We use the grain
+     * size evolution laws described in Behn et al., 2009. Implications of grain
+     * size evolution on the seismic structure of the oceanic upper mantle, Earth
+     * Planet. Sci. Letters, 282, 178–189. Other material parameters are either
+     * prescribed similar to the 'simple' material model, or read from data files
+     * that were generated by the Perplex or Hefesto software. The material model
+     * is described in more detail in Dannberg, J., Z. Eilon, U. Faul,
+     * R. Gassmöller, P. Moulik, and R. Myhill (2017), The importance of
+     * grain size to mantle dynamics and seismological observations,
+     * Geochem. Geophys. Geosyst., 18, 3034–3061, doi:10.1002/2017GC006944.,
+     * which is the canonical reference for this material model.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class GrainSize : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. Loads the material data and sets up
+         * pointers.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+
+        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                      typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @}
+         */
+
+        /**
+         * Returns the enthalpy as calculated by HeFESTo.
+         */
+        double enthalpy (const double      temperature,
+                         const double      pressure,
+                         const std::vector<double> &compositional_fields,
+                         const Point<dim> &position) const;
+
+        /**
+         * Returns the cell-wise averaged enthalpy derivatives for the evaluate
+         * function and postprocessors. The function returns two pairs, the
+         * first one represents the temperature derivative, the second one the
+         * pressure derivative. The first member of each pair is the derivative,
+         * the second one the number of vertex combinations the function could
+         * use to compute the derivative. The second member is useful to handle
+         * the case no suitable combination of vertices could be found (e.g.
+         * if the temperature and pressure on all vertices of the current
+         * cell is identical.
+         */
+        std::array<std::pair<double, unsigned int>,2>
+        enthalpy_derivative (const typename Interface<dim>::MaterialModelInputs &in) const;
+
+      protected:
+        double reference_rho;
+        double reference_T;
+        double eta;
+        double thermal_alpha;
+        double reference_specific_heat;
+
+        /**
+         * The constant compressibility.
+         */
+        double reference_compressibility;
+
+        /**
+         * The thermal conductivity.
+         */
+        double k_value;
+
+        /**
+         * The index of the compositional field that represents the grain size.
+         */
+        unsigned int grain_size_index;
+
+        /**
+         * Parameters controlling the grain size evolution.
+         */
+        std::vector<double> grain_growth_activation_energy;
+        std::vector<double> grain_growth_activation_volume;
+        std::vector<double> grain_growth_rate_constant;
+        std::vector<double> grain_growth_exponent;
+        double              minimum_grain_size;
+        std::vector<double> reciprocal_required_strain;
+        std::vector<double> recrystallized_grain_size;
+
+        /**
+         * Parameters controlling the dynamic grain recrystallization.
+         */
+        std::vector<double> grain_boundary_energy;
+        std::vector<double> boundary_area_change_work_fraction;
+        std::vector<double> geometric_constant;
+
+        /**
+          * A struct that contains information about which
+          * formulation of grain size evolution should be used.
+          */
+        struct Formulation
+        {
+          /**
+           * This enum lists available options that
+           * determine the equations being used for grain size evolution.
+           *
+           * We currently support three approaches:
+           *
+           * 'paleowattmeter':
+           * Austin, N. J., & Evans, B. (2007). Paleowattmeters: A scaling
+           * relation for dynamically recrystallized grain size. Geology, 354), 343-346.).
+           *
+           * 'paleopiezometer':
+           * Hall, C. E., Parmentier, E. M. (2003). Influence of grain size
+           * evolution on convective instability. Geochemistry, Geophysics,
+           * Geosystems, 4(3).
+           *
+           * 'pinned_grain_damage':
+           * Mulyukova, E., & Bercovici, D. (2018). Collapse of passive margins
+           * by lithospheric damage and plunging grain size. Earth and Planetary
+           * Science Letters, 484, 341-352.
+           */
+          enum Kind
+          {
+            paleowattmeter,
+            paleopiezometer,
+            pinned_grain_damage
+          };
+
+          /**
+           * This function translates an input string into the
+           * available enum options.
+           */
+          static
+          Kind
+          parse(const std::string &input)
+          {
+            if (input == "paleowattmeter")
+              return Formulation::paleowattmeter;
+            else if (input == "paleopiezometer")
+              return Formulation::paleopiezometer;
+            else if (input == "pinned grain damage")
+              return Formulation::pinned_grain_damage;
+            else
+              AssertThrow(false, ExcNotImplemented());
+
+            return Formulation::Kind();
+          }
+        };
+
+        /**
+         * A variable that records the formulation of how to evolve grain size.
+         * See the type of this variable for a description of available options.
+        */
+        typename Formulation::Kind grain_size_evolution_formulation;
+
+        /**
+        * This function returns the fraction of shear heating energy partitioned
+        * into grain damage using the implementation by Mulyukova and Bercovici (2018)
+        * Collapse of passive margins by lithospheric damage
+        * and plunging grain size. Earth and Planetary Science Letters, 484, 341-352.
+        */
+        double  compute_partitioning_fraction (const double temperature) const;
+
+        /**
+         * Parameters controlling the partitioning of energy
+         * into grain damage in the pinned state.
+         */
+        double grain_size_reduction_work_fraction_exponent;
+        double minimum_grain_size_reduction_work_fraction;
+        double maximum_grain_size_reduction_work_fraction;
+        double temperature_minimum_partitioning_power;
+        double temperature_maximum_partitioning_power;
+
+        /**
+         * Functions and parameters controlling conversion from interface roughness to grain size,
+         * used in pinned state formulation of grain damage. This conversion depends on the
+         * proportion of the two mineral phases.
+         *
+         * A detailed description of this approach can be found in Appendix H.1, in Equation (8) in
+         * the main manuscript, and in equation (F.28) of Bercovici, David, and Yanick Ricard (2012).
+         * Mechanisms for the generation of plate tectonics by two-phase grain-damage
+         * and pinning. Physics of the Earth and Planetary Interiors 202 (2012): 27-55.
+         */
+        double phase_distribution;
+
+        /**
+         * The factor used to convert roughness into the equivalent mean grain
+         * size for a given volume fraction of a mineral in the two-phase damage model.
+        */
+        double roughness_to_grain_size;
+
+        /**
+         * Parameters controlling the viscosity.
+         */
+        double dislocation_viscosity_iteration_threshold;
+        unsigned int dislocation_viscosity_iteration_number;
+        std::vector<double> dislocation_creep_exponent;
+        std::vector<double> dislocation_activation_energy;
+        std::vector<double> dislocation_activation_volume;
+        std::vector<double> dislocation_creep_prefactor;
+        std::vector<double> diffusion_creep_exponent;
+        std::vector<double> diffusion_activation_energy;
+        std::vector<double> diffusion_activation_volume;
+        std::vector<double> diffusion_creep_prefactor;
+        std::vector<double> diffusion_creep_grain_size_exponent;
+
+        /**
+         * Because of the nonlinear nature of this material model many
+         * parameters need to be kept within bounds to ensure stability of the
+         * solution. These bounds can be adjusted as input parameters.
+         */
+        double max_temperature_dependence_of_eta;
+        double min_eta;
+        double max_eta;
+        double min_specific_heat;
+        double max_specific_heat;
+        double min_thermal_expansivity;
+        double max_thermal_expansivity;
+        unsigned int max_latent_heat_substeps;
+        double min_grain_size;
+
+        double diffusion_viscosity (const double temperature,
+                                    const double adiabatic_temperature,
+                                    const double adiabatic_pressure,
+                                    const double grain_size,
+                                    const double second_strain_rate_invariant,
+                                    const unsigned int phase_index) const;
+
+        /**
+         * This function calculates the dislocation viscosity. For this purpose
+         * we need the dislocation component of the strain rate, which we can
+         * only compute by knowing the dislocation viscosity. Therefore, we
+         * iteratively solve for the dislocation viscosity and update the
+         * dislocation strain rate in each iteration using the new value
+         * obtained for the dislocation viscosity. The iteration is started
+         * with a dislocation viscosity calculated for the whole strain rate
+         * unless a guess for the viscosity is provided, which can reduce the
+         * number of iterations significantly.
+         */
+        double dislocation_viscosity (const double temperature,
+                                      const double adiabatic_temperature,
+                                      const double adiabatic_pressure,
+                                      const SymmetricTensor<2,dim> &strain_rate,
+                                      const unsigned int phase_index,
+                                      const double diffusion_viscosity,
+                                      const double viscosity_guess = 0) const;
+
+        double density (const double temperature,
+                        const double pressure,
+                        const std::vector<double> &compositional_fields,
+                        const Point<dim> &position) const;
+
+        double compressibility (const double temperature,
+                                const double pressure,
+                                const std::vector<double> &compositional_fields,
+                                const Point<dim> &position) const;
+
+        double specific_heat (const double temperature,
+                              const double pressure,
+                              const std::vector<double> &compositional_fields,
+                              const Point<dim> &position) const;
+
+        double thermal_expansion_coefficient (const double      temperature,
+                                              const double      pressure,
+                                              const std::vector<double> &compositional_fields,
+                                              const Point<dim> &position) const;
+
+        /**
+         * Returns the p-wave velocity as calculated by HeFESTo.
+         */
+        double seismic_Vp (const double      temperature,
+                           const double      pressure,
+                           const std::vector<double> &compositional_fields,
+                           const Point<dim> &position) const;
+
+        /**
+         * Returns the s-wave velocity as calculated by HeFESTo.
+         */
+        double seismic_Vs (const double      temperature,
+                           const double      pressure,
+                           const std::vector<double> &compositional_fields,
+                           const Point<dim> &position) const;
+
+        /**
+         * Rate of grain size growth (Ostwald ripening) or reduction
+         * (due to dynamic recrystallization and phase transformations)
+         * in dependence on temperature, pressure, strain rate, mineral
+         * phase and creep regime.
+         * We use the grain size growth laws as for example described
+         * in Behn, M. D., Hirth, G., & Elsenbeck, J. R. (2009). Implications
+         * of grain size evolution on the seismic structure of the oceanic
+         * upper mantle. Earth and Planetary Science Letters, 282(1), 178-189.
+         *
+         * For the rate of grain size reduction due to dynamic crystallization
+         * there is the choice between the paleowattmeter (Austins and
+         * Evans, 2007) and the paleopiezometer (Hall and Parmentier, 2003)
+         * as described in the parameter use_paleowattmeter.
+         */
+        std::vector<std::vector<double>>
+        grain_size_change (const typename Interface<dim>::MaterialModelInputs &in,
+                           const std::vector<double>                          &adiabatic_pressure,
+                           const std::vector<unsigned int>                    &phase_indices) const;
+
+        /**
+         * Function that returns the phase for a given
+         * temperature, depth, pressure, and density gradient
+         * (which are all contained in the @p in argument).
+         * Because the function returns just the dominant
+         * phase, phase transitions are discrete in this
+         * material model (they have a zero width).
+         */
+        unsigned int
+        get_phase_index (const MaterialUtilities::PhaseFunctionInputs<dim> &in) const;
+
+
+        /**
+         * Number of phase transitions for the one chemical composition used in this model.
+         */
+        unsigned int n_phase_transitions;
+
+        /**
+         * Object that handles phase transitions.
+         * Allows it to compute the phase function for each individual phase
+         * transition in the model, given the temperature, pressure, depth,
+         * and density gradient.
+         */
+        MaterialUtilities::PhaseFunction<dim> phase_function;
+
+
+        /**
+         * The following variables are properties of the material files
+         * we read in.
+         */
+        std::string datadirectory;
+        std::vector<std::string> material_file_names;
+        std::vector<std::string> derivatives_file_names;
+        unsigned int n_material_data;
+        bool use_table_properties;
+        bool use_enthalpy;
+        bool use_bilinear_interpolation;
+
+
+        /**
+         * The format of the provided material files. Currently we support
+         * the PERPLEX and HeFESTo data formats.
+         */
+        enum formats
+        {
+          perplex,
+          hefesto
+        } material_file_format;
+
+        /**
+         * List of pointers to objects that read and process data we get from
+         * material data files. There is one pointer/object per compositional
+         * field provided.
+         */
+        std::vector<std::unique_ptr<MaterialModel::MaterialUtilities::Lookup::MaterialLookup>> material_lookup;
+
+        /**
+         * We cache the evaluators that are necessary to evaluate the temperature
+         * and pressure at the vertices of the current cell.
+         * By caching the evaluators, we can avoid recreating them
+         * every time we need them.
+         */
+        mutable std::unique_ptr<FEPointEvaluation<1, dim>> temperature_evaluator;
+        mutable std::unique_ptr<FEPointEvaluation<1, dim>> pressure_evaluator;
+
+      private:
+        /*
+         * Object for computing plastic stresses, viscosities, and additional outputs,
+         * as well as an object for the required input parameters.
+         */
+        bool enable_drucker_prager_rheology;
+        bool use_adiabatic_pressure_for_yielding;
+        Rheology::DruckerPrager<dim> drucker_prager_plasticity;
+        Rheology::DruckerPragerParameters drucker_prager_parameters;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/interface.h.bak b/include/aspect/material_model/interface.h.bak
new file mode 100644
index 00000000000..34b97c11bbd
--- /dev/null
+++ b/include/aspect/material_model/interface.h.bak
@@ -0,0 +1,1534 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_interface_h
+#define _aspect_material_model_interface_h
+
+#include <aspect/global.h>
+#include <aspect/plugins.h>
+#include <aspect/material_model/utilities.h>
+
+#include <deal.II/base/point.h>
+#include <deal.II/base/quadrature.h>
+#include <deal.II/base/symmetric_tensor.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/dofs/dof_accessor.h>
+#include <deal.II/fe/mapping.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/fe/component_mask.h>
+#include <deal.II/numerics/data_postprocessor.h>
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  template <int dim>
+  struct Introspection;
+
+
+  /**
+   * A namespace in which we define everything that has to do with modeling
+   * convecting material, including descriptions of material parameters such
+   * as viscosities, densities, etc.
+   *
+   * @ingroup MaterialModels
+   */
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A namespace whose enum members are used in querying the nonlinear
+     * dependence of physical parameters on other solution variables.
+     */
+    namespace NonlinearDependence
+    {
+      /**
+       *
+       * An enum whose members are used in querying the nonlinear dependence
+       * of physical parameters on other solution variables.
+       *
+       * The values of this enum are used in the
+       * NonlinearDependence::model_dependence, queried by get_model_dependence()
+       * to see if a coefficient like the viscosity, depends on the
+       * temperature, pressure, strain rate, or compositional field value.
+       * Because the values of the enum are chosen so that they represent
+       * single bits in an integer, the result here is a number that can be
+       * represented in base-2 as 101 (the number 100=4 for the strain rate and
+       * 001=1 for the temperature).
+       *
+       * To query nonlinear dependence of a coefficient on any other variable,
+       * you can use
+       * @code
+       *   material_model.get_model_dependence();
+       * @endcode
+       * and compare the result to NonlinearDependence::Dependence::Variable.
+       */
+      enum Dependence
+      {
+        uninitialized        = 0,
+
+        none                 = 1,
+        temperature          = 2,
+        pressure             = 4,
+        strain_rate          = 8,
+        compositional_fields = 16,
+
+        any_variable         = temperature | pressure | strain_rate | compositional_fields
+      };
+
+
+      /**
+       * Provide an operator that or's two Dependence variables.
+       */
+      inline Dependence operator | (const Dependence d1,
+                                    const Dependence d2)
+      {
+        return Dependence(static_cast<int>(d1) | static_cast<int>(d2));
+      }
+
+      inline Dependence operator |= (Dependence &d1,
+                                     const Dependence d2)
+      {
+        d1 = (d1 | d2);
+        return d1;
+      }
+
+      /**
+       * A structure that, for every output variable of a material model,
+       * describes which input variable it depends on.
+       */
+      struct ModelDependence
+      {
+        /**
+         * A field that describes which input variable the viscosity
+         * of a material model depends on.
+         */
+        Dependence viscosity;
+
+        /**
+         * A field that describes which input variable the density
+         * of a material model depends on.
+         */
+        Dependence density;
+
+        /**
+         * A field that describes which input variable the compressibility
+         * of a material model depends on.
+         */
+        Dependence compressibility;
+
+        /**
+         * A field that describes which input variable the specific heat
+         * of a material model depends on.
+         */
+        Dependence specific_heat;
+
+        /**
+         * A field that describes which input variable the thermal conductivity
+         * of a material model depends on.
+         */
+        Dependence thermal_conductivity;
+
+        /**
+         * Default constructor. Sets all dependencies to invalid values in
+         * order to ensure that material models really correctly specify
+         * which input variables their output variables depend on.
+         */
+        ModelDependence ();
+      };
+
+      /**
+       * Return whether the given argument @p dependence identifies a single
+       * variable (e.g., the pressure, the temperature, etc) or a combination
+       * of variables. Technically, this corresponds to the question of
+       * whether there is exactly one bit set in the argument.
+       *
+       * @return true if yes, false otherwise.
+       */
+      bool
+      identifies_single_variable(const Dependence dependence);
+    }
+
+    /**
+     * A namespace whose enum members are used in querying which material
+     * properties should be computed.
+     */
+    namespace MaterialProperties
+    {
+      /**
+       * An enum whose members identify material model output
+       * properties.
+       *
+       * Because the values of the enum are chosen so that they represent
+       * single bits in an integer, the result here is a number that can be
+       * represented in base-2 as 110 (the number 100=4 for the density and
+       * 010=2 for the viscosity).
+       */
+      enum Property
+      {
+        uninitialized                  = 0,
+
+        none                           = 1,
+        viscosity                      = 2,
+        density                        = 4,
+        thermal_expansion_coefficient  = 8,
+        specific_heat                  = 16,
+        thermal_conductivity           = 32,
+        compressibility                = 64,
+        entropy_derivative_pressure    = 128,
+        entropy_derivative_temperature = 256,
+        reaction_terms                 = 512,
+        reaction_rates                 = 1024,
+        additional_outputs             = 2048,
+
+        equation_of_state_properties   = density |
+                                         thermal_expansion_coefficient |
+                                         specific_heat |
+                                         compressibility |
+                                         entropy_derivative_pressure |
+                                         entropy_derivative_temperature,
+        all_properties                 = equation_of_state_properties |
+                                         viscosity |
+                                         thermal_conductivity |
+                                         reaction_terms |
+                                         reaction_rates |
+                                         additional_outputs
+      };
+
+      /**
+       * Provide an operator that or's two Property variables. This allows to
+       * combine more than one property in a single variable.
+       */
+      inline Property operator | (const Property d1,
+                                  const Property d2)
+      {
+        return Property(static_cast<int>(d1) | static_cast<int>(d2));
+      }
+
+      inline Property operator |= (Property &d1,
+                                   const Property d2)
+      {
+        return (d1 | d2);
+      }
+    }
+
+
+    // Forward declaration:
+    template <int dim>
+    class AdditionalMaterialInputs;
+
+    /**
+     * A data structure with all inputs for the
+     * MaterialModel::Interface::evaluate() method. The vectors all have the
+     * same length and refer to different evaluation points (given in
+     * #position).
+     */
+    template <int dim>
+    class MaterialModelInputs
+    {
+      public:
+        /**
+         * Constructor. Initialize the various arrays of this structure with the
+         * given number of quadrature points and (finite element) components.
+         *
+         * @param n_points The number of quadrature points for which input
+         * quantities will be provided.
+         * @param n_comp The number of vector quantities (in the order in which
+         * the Introspection class reports them) for which input will be
+         * provided.
+         */
+        MaterialModelInputs(const unsigned int n_points,
+                            const unsigned int n_comp);
+
+        /**
+         * Constructor. Initialize the arrays of the structure with the number
+         * of points in the `input_data` structure, and fills them appropriately.
+         *
+         * @param input_data The data used to populate the material model input quantities.
+         * @param introspection A reference to the simulator introspection object.
+         * @param compute_strain_rate If set to `true`, then the object that
+         *   is currently created will also store the strain rates at all evaluation
+         *   points. This is an expensive operation. If set to `false`, then the
+         *   `strain_rate` array is going to be empty, and strain rates are not
+         *   evaluated. As a consequence, strain rates are then also not
+         *   available to functions that take this MaterialModelInputs
+         *   object as input, for example to compute strain rate-dependent
+         *   viscosities.
+         */
+        MaterialModelInputs(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            const Introspection<dim> &introspection,
+                            const bool compute_strain_rate = true);
+
+
+        /**
+         * Constructor. Initializes the various arrays of this
+         * structure with the FEValues and introspection objects and
+         * the solution_vector. This constructor calls the function
+         * reinit to populate the newly created arrays.
+         *
+         * @param fe_values An FEValuesBase object used to evaluate the finite elements.
+         * @param cell The currently active cell for the fe_values object.
+         * @param introspection A reference to the simulator introspection object.
+         * @param solution_vector The finite element vector from which to construct the inputs.
+         * @param compute_strain_rate If set to `true`, then the object that
+         *   is currently created will also store the strain rates at all evaluation
+         *   points. This is an expensive operation. If set to `false`, then the
+         *   `strain_rate` array is going to be empty, and strain rates are not
+         *   evaluated. As a consequence, strain rates are then also not
+         *   available to functions that take this MaterialModelInputs
+         *   object as input, for example to compute strain rate-dependent
+         *   viscosities.
+         */
+        MaterialModelInputs(const FEValuesBase<dim,dim> &fe_values,
+                            const typename DoFHandler<dim>::active_cell_iterator &cell,
+                            const Introspection<dim> &introspection,
+                            const LinearAlgebra::BlockVector &solution_vector,
+                            const bool compute_strain_rate = true);
+
+        /**
+         * Copy constructor. This constructor copies all data members of the
+         * source object except for the additional input data (of type
+         * AdditionalMaterialInputs) pointers, stored in the
+         * `source.additional_inputs` member variable.
+         *
+         * This is because these pointers can not be copied (they
+         * are unique to the @p source object). Since they can also not
+         * be recreated without the original code that created these objects
+         * in the first place, this constructor throws an exception if the
+         * @p source object had any additional input data objects
+         * associated with it.
+         */
+        MaterialModelInputs (const MaterialModelInputs &source);
+
+        /**
+         * Move constructor. This constructor simply moves all members.
+         */
+        MaterialModelInputs (MaterialModelInputs &&)  noexcept = default;
+
+        /**
+         * Copy operator. Copying these objects is expensive and
+         * consequently prohibited
+         */
+        MaterialModelInputs &operator= (const MaterialModelInputs &source) = delete;
+
+        /**
+         * Move operator.
+         */
+        MaterialModelInputs &operator= (MaterialModelInputs &&) = default;
+
+        /**
+         * Function to re-initialize and populate the pre-existing arrays
+         * created by the constructor MaterialModelInputs. The arguments here
+         * have the same meaning as in the constructor of this class.
+         */
+        void reinit(const FEValuesBase<dim,dim>                          &fe_values,
+                    const typename DoFHandler<dim>::active_cell_iterator &cell,
+                    const Introspection<dim>                             &introspection,
+                    const LinearAlgebra::BlockVector                     &solution_vector,
+                    const bool                                            compute_strain_rate = true);
+
+        /**
+         * Function that returns the number of points at which
+         * the material model is to be evaluated.
+         */
+        unsigned int n_evaluation_points() const;
+
+        /**
+         * Function that returns if the caller requests an evaluation
+         * of the handed over @p property. This is optional, because calculating
+         * some properties can be more expensive than the other material
+         * model properties and not all are needed for all applications.
+         */
+        bool requests_property(const MaterialProperties::Property &property) const;
+
+        /**
+         * Vector with global positions where the material has to be evaluated
+         * in evaluate().
+         */
+        std::vector<Point<dim>> position;
+
+        /**
+         * Temperature values at the points given in the #position vector.
+         */
+        std::vector<double> temperature;
+
+        /**
+         * Pressure values at the points given in the #position vector.
+         */
+        std::vector<double> pressure;
+
+        /**
+         * Pressure gradients at the points given in the #position vector.
+         * This is important for the heating models.
+         */
+        std::vector<Tensor<1,dim>> pressure_gradient;
+
+        /**
+         * Velocity values at the points given in the #position vector.
+         * This value is mostly important in the case of determining
+         * whether material crossed a certain region (e.g. a phase boundary).
+         * The timestep that is needed for this check can be requested from
+         * SimulatorAccess.
+         */
+        std::vector<Tensor<1,dim>> velocity;
+
+        /**
+         * Values of the compositional fields at the points given in the
+         * #position vector: composition[i][c] is the compositional field c at
+         * point i.
+         */
+        std::vector<std::vector<double>> composition;
+
+        /**
+         * Strain rate at the points given in the #position vector. Only the
+         * viscosity may depend on these values. This std::vector can be set to
+         * size 0 if the viscosity is not needed.
+         *
+         * @note The strain rate is computed as $\varepsilon(\mathbf u)=\frac 12
+         * (\nabla \mathbf u + \nabla \mathbf u^T)$, regardless of whether the
+         * model is compressible or not. This is relevant since in some other
+         * contexts, the strain rate in the compressible case is computed as
+         * $\varepsilon(\mathbf u)=\frac 12 (\nabla \mathbf u + \nabla \mathbf
+         * u^T) - \frac 13 \nabla \cdot \mathbf u \mathbf 1$.
+         */
+        std::vector<SymmetricTensor<2,dim>> strain_rate;
+
+        /**
+         * Optional cell object that contains these quadrature
+         * points. This allows for evaluating properties at the cell vertices
+         * and interpolating to the quadrature points, or to query the cell for
+         * material ids, neighbors, or other information that is not available
+         * solely from the locations. Note that not all calling functions will
+         * set this cell iterator. In these cases it will be an invalid iterator
+         * constructed using the default constructor, so make sure that your
+         * material model either fails
+         * with a proper error message, or provides an alternative calculation for
+         * these cases. You can detect this with
+         * @code
+         * if (in.current_cell.state() == IteratorState::valid)
+         * @endcode
+         */
+        typename DoFHandler<dim>::active_cell_iterator current_cell;
+
+        /**
+         * A member variable that stores which properties the material model
+         * should compute. You can check specific properties using
+         * the requests_property function and usually do not need to access
+         * this variable directly. For documentation on the internal storage
+         * of this variable see the documentation for MaterialProperties::Property.
+         */
+        MaterialProperties::Property requested_properties;
+
+        /**
+         * Given an additional material model input class as explicitly specified
+         * template argument, returns a pointer to this additional material model
+         * input object if it is used in the current simulation. Ownership
+         * of the pointed-to object remains with the current object.
+         *
+         * If the input does not exist, i.e., if there is no additional input
+         * object of the specified type, then a null pointer is returned.
+         */
+        template <class AdditionalInputType>
+        AdditionalInputType *get_additional_input();
+
+        /**
+         * A version of the previous function that is used when the object
+         * being queried is `const`.
+         */
+        template <class AdditionalInputType>
+        const AdditionalInputType *get_additional_input() const;
+
+        /**
+         * Vector of shared pointers to additional material model input
+         * objects that can be added to MaterialModelInputs. By default,
+         * no inputs are added.
+         */
+        std::vector<std::unique_ptr<AdditionalMaterialInputs<dim>>> additional_inputs;
+    };
+
+
+    // Forward declaration:
+    template <int dim>
+    class AdditionalMaterialOutputs;
+
+
+    /**
+     * A data structure with the output field of the
+     * MaterialModel::Interface::evaluate() function. The vectors are the
+     * values at the different positions given by
+     * MaterialModelInputs::position.
+     */
+    template <int dim>
+    class MaterialModelOutputs
+    {
+      public:
+        /**
+         * Constructor. Initialize the various arrays of this structure with the
+         * given number of quadrature points and (finite element) components.
+         *
+         * @param n_points The number of quadrature points for which input
+         * quantities will be provided.
+         * @param n_comp The number of vector quantities (in the order in which
+         * the Introspection class reports them) for which input will be
+         * provided.
+         */
+        MaterialModelOutputs (const unsigned int n_points,
+                              const unsigned int n_comp);
+
+        /**
+         * Copy constructor. This constructor copies all data members of the
+         * source object except for the additional output data (of type
+         * AdditionalMaterialOutputs) pointers, stored in the
+         * `source.additional_outputs` member variable.
+         *
+         * This is because these pointers can not be copied (they
+         * are unique to the @p source object). Since they can also not
+         * be recreated without the original code that created these objects
+         * in the first place, this constructor throws an exception if the
+         * @p source object had any additional output data objects
+         * associated with it.
+         */
+        MaterialModelOutputs (const MaterialModelOutputs &source);
+
+        /**
+         * Move constructor. This constructor simply moves all members.
+         */
+        MaterialModelOutputs (MaterialModelOutputs &&)  noexcept = default;
+
+        /**
+         * Copy operator. Copying these objects is expensive, and consequently
+         * prohibited.
+         */
+        MaterialModelOutputs &operator= (const MaterialModelOutputs &source) = delete;
+
+        /**
+         * Move operator.
+         */
+        MaterialModelOutputs &operator= (MaterialModelOutputs &&)  noexcept = default;
+
+        /**
+         * Function that returns the number of points at which
+         * the material model is to be evaluated.
+         */
+        unsigned int n_evaluation_points() const;
+
+        /**
+         * Viscosity $\eta$ values at the given positions.
+         */
+        std::vector<double> viscosities;
+
+        /**
+         * Density values at the given positions.
+         */
+        std::vector<double> densities;
+
+        /**
+         * Thermal expansion coefficients at the given positions. It is defined
+         * as $\alpha = - \frac{1}{\rho} \frac{\partial\rho}{\partial T}$
+         */
+        std::vector<double> thermal_expansion_coefficients;
+
+        /**
+         * Specific heat at the given positions.
+         */
+        std::vector<double> specific_heat;
+
+        /**
+         * Thermal conductivity at the given positions.
+         */
+        std::vector<double> thermal_conductivities;
+
+        /**
+         * Compressibility at the given positions. The compressibility is defined
+         * as $\kappa = \frac{1}{\rho} \frac{\partial\rho}{\partial p}$.
+         */
+        std::vector<double> compressibilities;
+
+        /**
+         * The product of the change of entropy $\Delta S$ at a phase transition
+         * and the derivative of the phase function $X=X(p,T,\mathfrak c,\mathbf
+         * x)$ with regard to pressure at the given positions.
+         */
+        std::vector<double> entropy_derivative_pressure;
+
+        /**
+         * The product of (minus) the change of entropy $-\Delta S$ at a phase
+         * transition and the derivative of the phase function
+         * $X=X(p,T,\mathfrak c,\mathbf x)$ with regard to temperature at the
+         * given positions.
+         */
+        std::vector<double> entropy_derivative_temperature;
+
+        /**
+         * Change in composition due to chemical reactions at the given
+         * positions. The term reaction_terms[i][c] is the change in
+         * compositional field c at point i.
+         *
+         * The mental model behind prescribing actual changes in composition
+         * rather than reaction rates is that we assume that there is always an
+         * equilibrium between the compositional fields (because the time scale
+         * of reactions is normally much shorter than that of convection), so
+         * the quantity returned by this function is an actual change in the
+         * amount of material, which is added to or subtracted from the current
+         * value of the compositional field, and NOT a reaction rate. The idea
+         * is, that in dependence of temperature, pressure, position and the
+         * compositional fields themselves an equilibrium can be calculated, and
+         * the difference between the current value and the equilibrium can be
+         * added to the respective compositional field.
+         *
+         * For mass conservation it should ALWAYS be checked that what is
+         * subtracted from one field is added to another field (and the other
+         * way round) and that one never subtracts more than the actual value of
+         * a field (so it does not get negative).
+         *
+         * This function has a default implementation that sets the reaction
+         * term to zero (assuming no reactions).
+         *
+         * @note In cases where one has slow chemical reactions (or cases where
+         * compositional fields are used to track quantities different than
+         * actual compositions, for example accumulated strains in damage
+         * models), models are formulated as differential equations with right
+         * hand sides, not as instantaneous equations. In such cases, the
+         * reaction terms (i.e., the incremental additions to the previous
+         * state) are usually of the form reaction rate times time step size. To
+         * implement something like this, derive your material model from
+         * SimulatorAccess so you can query the time step used by the simulator
+         * in order to compute the reaction increment.
+         */
+        std::vector<std::vector<double>> reaction_terms;
+
+        /**
+         * Vector of shared pointers to additional material model output
+         * objects that can then be added to MaterialModelOutputs. By default,
+         * no outputs are added.
+         */
+        std::vector<std::unique_ptr<AdditionalMaterialOutputs<dim>>> additional_outputs;
+
+        /**
+         * Given an additional material model output class as explicitly specified
+         * template argument, returns a pointer to this additional material model
+         * output object if it is used in the current simulation.
+         * The output can then be filled in the MaterialModels::Interface::evaluate()
+         * function. If the output does not exist, a null pointer is returned.
+         */
+        template <class AdditionalOutputType>
+        AdditionalOutputType *get_additional_output();
+
+        /**
+         * Constant version of get_additional_output() returning a const pointer.
+         */
+        template <class AdditionalOutputType>
+        const AdditionalOutputType *get_additional_output() const;
+
+        /**
+         * Steal the additional outputs from @p other. The destination (@p
+         * this), is expected to currently have no additional outputs.
+         */
+        void move_additional_outputs_from(MaterialModelOutputs<dim> &other);
+    };
+
+
+
+    /**
+     * A namespace in which we define how material model outputs should be
+     * averaged on each cell.
+     *
+     * Material models compute output quantities such as the viscosity, the
+     * density, etc, based on pressures, temperatures, composition, and
+     * location at every quadrature point. For some models, these values vary
+     * drastically from quadrature point to quadrature point, and this creates
+     * difficulties both for the stability of the discretization as well as
+     * for the linear solvers. Some of this can be ameliorated by averaging
+     * values on every cell, although this of course reduces the ideal
+     * convergence order. This namespace defines the means to achieve such
+     * averaging.
+     */
+    namespace MaterialAveraging
+    {
+      /**
+       * An enum to define what kind of averaging operations are implemented.
+       * These are:
+       *
+       * - No averaging, i.e., leave the values as they were provided by the
+       * material model.
+       *
+       * - Arithmetic averaging: Set the values of each output quantity at
+       * every quadrature point to \f[ \bar x = \frac 1Q \sum_{q=1}^Q x_q \f]
+       * where $x_q$ are the values at the $Q$ quadrature points.
+       *
+       * - Harmonic averaging: Set the values of each output quantity at every
+       * quadrature point to \f[ \bar x = \left(\frac 1Q \sum_{q=1}^Q
+       * \frac{1}{x_q}\right)^{-1} \f] where $x_q$ are the values at the $Q$
+       * quadrature points.
+       *
+       * - Geometric averaging: Set the values of each output quantity at
+       * every quadrature point to \f[ \bar x = \left(\prod_{q=1}^Q
+       * x_q\right)^{1/Q} \f] where $x_q$ are the values at the $Q$ quadrature
+       * points.
+       *
+       * - Pick largest: Set the values of each output quantity at every
+       * quadrature point to \f[ \bar x = \max_{1\le q\le Q} x_q \f] where
+       * $x_q$ are the values at the $Q$ quadrature points.
+       *
+       * - Project to $Q_1$: This operation takes the values at the quadrature
+       * points and computes the best bi- or trilinear approximation for them.
+       * In other words, it projects the values into the $Q_1$ finite element
+       * space. It then re-evaluate this projection at the quadrature points.
+       *
+       * - Log average: Set the values of each output quantity at every
+       * quadrature point to \f[ \bar x = {10}^{\frac 1Q \sum_{q=1}^Q \log_{10} x_q} \f]
+       * where $x_q$ are the values at the $Q$ quadrature points.
+       *
+       * - Harmonic average only viscosity, Geometric  average only viscosity
+       * and project to Q1 only viscosity: Like harmonic averaging, geometric
+       * averaging and project to Q1, but only applied to the viscosity.
+       */
+      enum AveragingOperation
+      {
+        none,
+        arithmetic_average,
+        harmonic_average,
+        geometric_average,
+        pick_largest,
+        project_to_Q1,
+        log_average,
+        harmonic_average_only_viscosity,
+        geometric_average_only_viscosity,
+        project_to_Q1_only_viscosity,
+        default_averaging
+      };
+
+
+      /**
+       * Return a string that represents the various averaging options laid
+       * out above and that can be used in the declaration of an input
+       * parameter. The options are separated by "|" so that they can be used
+       * in a dealii::Patterns::Selection argument.
+       */
+      std::string get_averaging_operation_names ();
+
+      /**
+       * Parse a string representing one of the options returned by
+       * get_averaging_operation_names(), and return the corresponding
+       * AveragingOperation value.
+       */
+      AveragingOperation parse_averaging_operation_name (const std::string &s);
+
+      /**
+       * Given the averaging @p operation, a description of where the
+       * quadrature points are located on the given cell, and a mapping,
+       * perform this operation on all elements of the @p values structure.
+       */
+      template <int dim>
+      void average (const AveragingOperation operation,
+                    const typename DoFHandler<dim>::active_cell_iterator &cell,
+                    const Quadrature<dim>         &quadrature_formula,
+                    const Mapping<dim>            &mapping,
+                    const MaterialProperties::Property &requested_properties,
+                    MaterialModelOutputs<dim>     &values_out);
+
+      /**
+       * Do the requested averaging operation for one array. The
+       * projection matrix argument is only used if the operation
+       * chosen is project_to_Q1
+       */
+      void average_property (const AveragingOperation  operation,
+                             const FullMatrix<double>      &projection_matrix,
+                             const FullMatrix<double>      &expansion_matrix,
+                             std::vector<double>           &values_out);
+    }
+
+
+    /**
+     * Some material and heating models need more than just the basic material
+     * model inputs defined in the MaterialModel::MaterialModelInputs
+     * class. These additions are either for more complicated physics
+     * than the basic flow model usually solved by ASPECT (for example
+     * to support the melt migration functionality), or other derived
+     * quantities.
+     *
+     * Rather than litter the MaterialModelInputs class with additional
+     * fields that are not universally used, we use a mechanism by
+     * which MaterialModelInputs can store a set of pointers to
+     * "additional" input objects that store information such as
+     * mentioned above. These pointers are all to objects whose types
+     * are derived from the current class.
+     *
+     * The format of the additional quantities defined in derived classes
+     * should be the same as for MaterialModel::MaterialModelInputs.
+     */
+    template <int dim>
+    class AdditionalMaterialInputs
+    {
+      public:
+        /**
+         * Destructor. This destructor is made `virtual` to ensure that
+         * derived classes can be accessed via a pointer-to-base-class.
+         */
+        virtual ~AdditionalMaterialInputs() = default;
+
+        /**
+         * Fill the additional inputs. Each additional input
+         * has to implement their own version of this function.
+         */
+        virtual void
+        fill (const LinearAlgebra::BlockVector &solution,
+              const FEValuesBase<dim>          &fe_values,
+              const Introspection<dim>         &introspection) = 0;
+    };
+
+
+    /**
+     * Some material models can compute more than just the basic material
+     * coefficients defined in the MaterialModel::MaterialModelOutputs
+     * class. These additions are either for more complicated physics
+     * than the basic flow model usually solved by ASPECT (for example
+     * to support the melt migration functionality), or other derived
+     * quantities that are not coefficients in any of the equations
+     * ASPECT solves but that may be of interest for visualization
+     * (for example seismic velocities).
+     *
+     * Rather than litter the MaterialModelOutputs class with additional
+     * fields that are not universally used, we use a mechanism by
+     * which MaterialModelOutputs can store a set of pointers to
+     * "additional" output objects that store information such as
+     * mentioned above. These pointers are all to objects whose types
+     * are derived from the current class.
+     *
+     * If an implementation of the MaterialModel::Interface::evaluate()
+     * in a class derived from MaterialModel::Interface encounters
+     * a MaterialModelOutputs object that has these pointers set
+     * (and if it recognizes the type of the object pointed to),
+     * it should fill this set of additional output quantities.
+     *
+     * The format of the additional quantities defined in derived classes
+     * should be the same as for MaterialModel::MaterialModelOutputs.
+     */
+    template <int dim>
+    class AdditionalMaterialOutputs
+    {
+      public:
+        /**
+         * Destructor. Made virtual to enable storing pointers to this
+         * base class.
+         */
+        virtual ~AdditionalMaterialOutputs() = default;
+
+        virtual void average (const MaterialAveraging::AveragingOperation /*operation*/,
+                              const FullMatrix<double>  &/*projection_matrix*/,
+                              const FullMatrix<double>  &/*expansion_matrix*/)
+        {}
+    };
+
+
+    /**
+     * Some material models can compute things that are not used anywhere
+     * in the physics modules of ASPECT, but that may be of interest for
+     * visualization purposes. An example would be a material model that can
+     * compute seismic velocities -- these are irrelevant to the rest of
+     * ASPECT, but would be nice to have for postprocessing.
+     *
+     * This class is a base class for material models to provide this kind
+     * of information. It follows the scheme laid out by
+     * AdditionalMaterialModelOutputs but also provides an interface by which
+     * consumers of these objects (e.g., the
+     * Postprocess::Visualization::NamedAdditionalOutputs class) can query the
+     * names and values material models have put into these additional
+     * outputs. (Because every material model can decide by itself which --
+     * if any -- additional outputs it produces, there are no standard
+     * names. Consequently, the material models have to describe what
+     * values and how many values they can produce.)
+     *
+     * This class is then this base class for additional named material model outputs
+     * to be added to the MaterialModel::MaterialModelOutputs structure.
+     */
+    template <int dim>
+    class NamedAdditionalMaterialOutputs : public AdditionalMaterialOutputs<dim>
+    {
+      public:
+        /**
+         * Base constructor.
+         *
+         * @param output_names A list of names for the additional output variables
+         *   this object will store. The length of the list also indicates
+         *   how many additional output variables objects of derived classes
+         *   will store.
+         */
+        NamedAdditionalMaterialOutputs(const std::vector<std::string> &output_names);
+
+        /**
+         * Constructor for case where outputs are stored for a number of points.
+         *
+         * @param output_names A list of names for the additional output variables
+         *   this object will store. The length of the list also indicates
+         *   how many additional output variables objects of derived classes
+         *   will store.
+         * @param n_points The number of points for which to store each of the
+         *   output variables.
+         */
+        NamedAdditionalMaterialOutputs(const std::vector<std::string> &output_names,
+                                       const unsigned int n_points);
+
+        /**
+         * Destructor.
+         */
+        ~NamedAdditionalMaterialOutputs() override;
+
+        /**
+         * Return a reference to the vector of names of the additional
+         * outputs.
+         */
+        const std::vector<std::string> &get_names() const;
+
+        /**
+         * Given an index as input argument, return a reference the to vector of
+         * values of the additional output with that index.
+         */
+        virtual std::vector<double> get_nth_output(const unsigned int idx) const;
+
+        void average (const MaterialAveraging::AveragingOperation /*operation*/,
+                      const FullMatrix<double>  &/*projection_matrix*/,
+                      const FullMatrix<double>  &/*expansion_matrix*/) override
+        {}
+
+
+        /**
+         * Values for the outputs at a set of evaluation points
+         * output_values[i][j] is the value of output i at point j.
+         */
+        std::vector<std::vector<double>> output_values;
+
+      private:
+        const std::vector<std::string> names;
+    };
+
+
+    /**
+     * Additional output fields for the seismic velocities to be added to
+     * the MaterialModel::MaterialModelOutputs structure and filled in the
+     * MaterialModel::Interface::evaluate() function.
+     */
+    template <int dim>
+    class SeismicAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        SeismicAdditionalOutputs(const unsigned int n_points);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * Seismic s-wave velocities at the evaluation points passed to
+         * the instance of MaterialModel::Interface::evaluate() that fills
+         * the current object.
+         */
+        std::vector<double> vs;
+
+        /**
+         * Seismic p-wave velocities at the evaluation points passed to
+         * the instance of MaterialModel::Interface::evaluate() that fills
+         * the current object.
+         */
+        std::vector<double> vp;
+    };
+
+
+    /**
+     * Additional output fields for reaction rates to be added to
+     * the MaterialModel::MaterialModelOutputs structure and filled in the
+     * MaterialModel::Interface::evaluate() function.
+     *
+     * These reaction rates are only used if the "operator splitting" solver scheme
+     * option is enabled, which decouples the reactions between compositional
+     * fields from the advection, so that different time step sizes can be used.
+     * In this case, the reaction rates are used in addition to (and independent
+     * from) any reaction_terms that a material model defines, which are assembled
+     * as usual.
+     * By default, the reaction rates are initialized with quiet_NaNs, and if
+     * "operator splitting" is not enabled, these values are not used, and they
+     * are expected to either remain at that value, or to not be created at all.
+     *
+     * In contrast to the reaction_terms, which are actual changes in composition
+     * rather than reaction rates, and assume equilibrium between the compositional
+     * fields, the reaction_rates defined here allow for reaction processes that
+     * happen on shorter time scales than the advection, and disequilibrium reactions.
+     */
+    template <int dim>
+    class ReactionRateOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        ReactionRateOutputs (const unsigned int n_points,
+                             const unsigned int n_comp);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * Reaction rates for all compositional fields at the evaluation points
+         * that are passed to the instance of MaterialModel::Interface::evaluate()
+         * that fills the current object.
+         * reaction_rates[q][c] is the reaction rate at the evaluation point q
+         * for the compositional field with the index c.
+         */
+        std::vector<std::vector<double>> reaction_rates;
+    };
+
+
+
+    /**
+     * Additional output fields for the phase with the largest fraction
+     * to be added to the MaterialModel::MaterialModelOutputs structure
+     * and filled in the MaterialModel::evaluate() function.
+     */
+    template <int dim>
+    class PhaseOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        PhaseOutputs(const unsigned int n_points);
+    };
+
+
+
+    /**
+     * Additional output fields for prescribed field outputs to be added to
+     * the MaterialModel::MaterialModelOutputs structure and filled in the
+     * MaterialModel::Interface::evaluate() function.
+     *
+     * This structure is used if for one of the compositional fields employed
+     * by a simulation, the advection scheme "prescribed field" is selected.
+     * (See Parameters::AdvectionFieldMethod for more information.)
+     * Then, while updating the compositional field, a structure of this
+     * type is created, given to the material model, and the material model
+     * outputs will finally be interpolated onto the corresponding
+     * compositional field.
+     *
+     * @note This structure always has as many prescribed field
+     * outputs as there are compositional fields, even if not all of them
+     * are using the "prescribed field" method. It is the responsibility
+     * of the individual material models to fill the correct entries.
+     */
+    template <int dim>
+    class PrescribedFieldOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        PrescribedFieldOutputs (const unsigned int n_points,
+                                const unsigned int n_comp);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * Prescribed field outputs for all compositional fields at the evaluation points
+         * that are passed to the instance of MaterialModel::Interface::evaluate()
+         * that fills the current object.
+         * prescribed_field_outputs[q][c] is the prescribed field output at the evaluation point q
+         * for the compositional field with the index c.
+         */
+        std::vector<std::vector<double>> prescribed_field_outputs;
+    };
+
+    /**
+     * Additional output fields for prescribed temperature outputs to be added to
+     * the MaterialModel::MaterialModelOutputs structure and filled in the
+     * MaterialModel::Interface::evaluate() function.
+     *
+     * This structure is used if the temperature field is solved using the
+     * advection scheme "prescribed field".
+     * (See Parameters::AdvectionFieldMethod for more information.)
+     * Then, while updating the temperature field, a structure of this
+     * type is created, given to the material model, and the material model
+     * outputs will finally be interpolated onto the
+     * temperature field.
+     */
+    template <int dim>
+    class PrescribedTemperatureOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        PrescribedTemperatureOutputs (const unsigned int n_points);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * Prescribed field outputs for the temperature field at the evaluation points
+         * that are passed to the instance of MaterialModel::Interface::evaluate()
+         * that fills the current object.
+         * prescribed_temperature_outputs[q] is the prescribed field output at the evaluation point q
+         * for the temperature.
+         */
+        std::vector<double> prescribed_temperature_outputs;
+    };
+
+    /**
+     * A class for additional output fields to be added to the RHS of the
+     * Stokes system, which can be attached to the
+     * MaterialModel::MaterialModelOutputs structure and filled in the
+     * MaterialModel::Interface::evaluate() function.
+     */
+    template <int dim>
+    class AdditionalMaterialOutputsStokesRHS: public AdditionalMaterialOutputs<dim>
+    {
+      public:
+        AdditionalMaterialOutputsStokesRHS(const unsigned int n_points)
+          : rhs_u(n_points), rhs_p(n_points), rhs_melt_pc(n_points)
+        {}
+
+        ~AdditionalMaterialOutputsStokesRHS() override
+          = default;
+
+        void average (const MaterialAveraging::AveragingOperation /*operation*/,
+                      const FullMatrix<double>  &/*projection_matrix*/,
+                      const FullMatrix<double>  &/*expansion_matrix*/) override
+        {
+          // TODO: not implemented
+        }
+
+        /**
+         * Force tensor on the right-hand side for the conservation of
+         * momentum equation (first part of the Stokes equation) in each
+         * quadrature point.
+         */
+        std::vector<Tensor<1,dim>> rhs_u;
+
+        /**
+         * Force value for the conservation of mass equation (second Stokes
+         * equation) in each quadrature point.
+         */
+        std::vector<double> rhs_p;
+
+        /**
+         * Force for the compaction pressure equation (when using melt
+         * transport) in each quadrature point.
+         */
+        std::vector<double> rhs_melt_pc;
+    };
+
+
+
+    /**
+     * An AdditionalOutput that allows prescribing a dilation applied to the
+     * Stokes solution.
+     *
+     * This is typically used in a MaterialModel to add dilation when plastic
+     * failure occurs as motivated by ChoiPeterson2015. If this output
+     * (denoted by R below) is present and enable_prescribed_dilation==true
+     * the following terms will be assembled:
+     *
+     * 1) $\int - (R,q)$ to the conservation of mass equation, creating
+     *    $-(div u,q) = -(R,q)$.
+     * 2) $\int - 2.0 / 3.0 * eta * (R, div v)$ to the RHS of the momentum
+     *    equation (if the model is incompressible), otherwise this term is
+     *    already present on the left side.
+     */
+    template <int dim>
+    class PrescribedPlasticDilation : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        /**
+         * Constructor
+         */
+        explicit PrescribedPlasticDilation (const unsigned int n_points);
+
+        /**
+         * Function for NamedAdditionalMaterialOutputs interface
+         */
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * A scalar value per evaluation point that specifies the prescribed dilation
+         * in that point.
+         */
+        std::vector<double> dilation;
+    };
+
+
+
+    /**
+     * A class for an elastic force term to be added to the RHS of the
+     * Stokes system, which can be attached to the
+     * MaterialModel::MaterialModelOutputs structure and filled in the
+     * MaterialModel::Interface::evaluate() function.
+     */
+    template <int dim>
+    class ElasticOutputs: public AdditionalMaterialOutputs<dim>
+    {
+      public:
+        ElasticOutputs(const unsigned int n_points)
+          : elastic_force(n_points, numbers::signaling_nan<SymmetricTensor<2,dim>>())
+          , viscoelastic_strain_rate(n_points, numbers::signaling_nan<SymmetricTensor<2,dim>>())
+        {}
+
+        ~ElasticOutputs() override
+          = default;
+
+        void average (const MaterialAveraging::AveragingOperation operation,
+                      const FullMatrix<double>  &/*projection_matrix*/,
+                      const FullMatrix<double>  &/*expansion_matrix*/) override
+        {
+          AssertThrow(operation == MaterialAveraging::AveragingOperation::none,ExcNotImplemented());
+          return;
+        }
+
+        /**
+         * Force tensor (elastic terms) on the right-hand side for the conservation of
+         * momentum equation (first part of the Stokes equation) in each
+         * quadrature point.
+         */
+        std::vector<SymmetricTensor<2,dim>> elastic_force;
+
+        /**
+         * Strain rate tensor that includes the contribution of elastic shear, which is
+         * required by the Newton solver.
+         */
+        std::vector<SymmetricTensor<2,dim>> viscoelastic_strain_rate;
+    };
+
+
+
+    /**
+     * Additional output fields for the enthalpy change upon melting or
+     * freezing to be added to the MaterialModel::MaterialModelOutputs
+     * structure and filled in the MaterialModel::Interface::evaluate()
+     * function.
+     * These outputs are needed in heating models that compute the latent
+     * heat of melting/freezing based on the material properties in the
+     * material models (which is required for thermodynamically consistent
+     * models).
+     */
+    template <int dim>
+    class EnthalpyOutputs : public AdditionalMaterialOutputs<dim>
+    {
+      public:
+        EnthalpyOutputs(const unsigned int n_points)
+          : enthalpies_of_fusion(n_points, numbers::signaling_nan<double>())
+        {}
+
+        virtual ~EnthalpyOutputs()
+          = default;
+
+        void average (const MaterialAveraging::AveragingOperation operation,
+                      const FullMatrix<double>  &/*projection_matrix*/,
+                      const FullMatrix<double>  &/*expansion_matrix*/) override
+        {
+          AssertThrow(operation == MaterialAveraging::AveragingOperation::none,ExcNotImplemented());
+          return;
+        }
+
+        /**
+         * Enthalpies of fusion, describing the amount of heat required to
+         * melt/solidify the material. These values are used when computing
+         * latent heat effects.
+         */
+        std::vector<double> enthalpies_of_fusion;
+    };
+
+
+
+    /**
+     * A base class for parameterizations of material models. Classes derived
+     * from this class will need to implement functions that provide material
+     * parameters such as the viscosity, density, etc, typically as a function
+     * of position, temperature and pressure at that location.
+     *
+     * Implementing a material model requires you to override evaluate() and fill the output
+     * argument struct instead of implementing the functions viscosity(),
+     * density(), etc.. In this case, all other functions are being ignored.
+     *
+     * In all cases, model_dependence values, is_compressible()
+     * need to be implemented.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * A typedef to import the MaterialModelInputs name into the current
+         * class. This typedef primarily exists as a backward compatibility
+         * measure given that the referenced structure used to be a member of
+         * the current class.
+         */
+        using MaterialModelInputs = MaterialModel::MaterialModelInputs<dim>;
+
+        /**
+         * A typedef to import the MaterialModelOutputs name into the current
+         * class. This typedef primarily exists as a backward compatibility
+         * measure given that the referenced structure used to be a member of
+         * the current class.
+         */
+        using MaterialModelOutputs = MaterialModel::MaterialModelOutputs<dim>;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return a structure that describes how each of the model's
+         * output variables (such as viscosity, density, etc) depend
+         * on the input variables pressure, temperature, strain rate,
+         * and compositional fields.
+         */
+        const NonlinearDependence::ModelDependence &
+        get_model_dependence () const;
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the
+         * continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        virtual bool is_compressible () const = 0;
+        /**
+         * @}
+         */
+
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        virtual
+        void evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
+                       MaterialModel::MaterialModelOutputs<dim> &out) const = 0;
+
+        /**
+         * If this material model can produce additional named outputs
+         * that are derived from NamedAdditionalOutputs, create them in here.
+         * By default, this does nothing.
+         */
+        virtual
+        void
+        create_additional_named_outputs (MaterialModelOutputs &outputs) const;
+
+
+        /**
+         * Fill the additional material model inputs that have been attached
+         * by the individual heating or material models in the
+         * create_additional_material_model_inputs function.
+         * This is done by looping over all material model inputs that have
+         * been created and calling their respective member functions.
+         */
+        virtual
+        void
+        fill_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &input,
+                                              const LinearAlgebra::BlockVector        &solution,
+                                              const FEValuesBase<dim>                 &fe_values,
+                                              const Introspection<dim>                &introspection) const;
+
+      protected:
+        /**
+         * A structure that describes how each of the model's
+         * output variables (such as viscosity, density, etc) depend
+         * on the input variables pressure, temperature, strain rate,
+         * and compositional fields.
+         *
+         * The constructor of this class calls the default
+         * constructor of this member variable which in turn
+         * initializes the object to invalid values. Derived classes
+         * then need to fill it either in their constructor (if they
+         * already know the correct dependencies at that time) or
+         * at the end of their parse_parameter() functions where
+         * they know the correct material parameters they will
+         * use.
+         */
+        NonlinearDependence::ModelDependence model_dependence;
+    };
+
+    /**
+     * Register a material model so that it can be selected from the parameter
+     * file.
+     *
+     * @param name A string that identifies the material model
+     * @param description A text description of what this model does and that
+     * will be listed in the documentation of the parameter file.
+     * @param declare_parameters_function A pointer to a function that can be
+     * used to declare the parameters that this material model wants to read
+     * from input files.
+     * @param factory_function A pointer to a function that can create an
+     * object of this material model.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    void
+    register_material_model (const std::string &name,
+                             const std::string &description,
+                             void (*declare_parameters_function) (ParameterHandler &),
+                             std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+    /**
+     * A function that given the name of a model returns a pointer to an
+     * object that describes it. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The material model object returned is not yet initialized and has not
+     * read its runtime parameters yet.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_material_model (const std::string &model_name);
+
+
+    /**
+     * A function that reads the name of a model from the parameter object
+     * and then returns a pointer to an
+     * object that describes this model. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The material model object returned is not yet initialized and has not
+     * read its runtime parameters yet.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_material_model (ParameterHandler &prm);
+
+
+    /**
+     * Return a string that consists of the names of material models that can
+     * be selected. These names are separated by a vertical line '|' so
+     * that the string can be an input to the deal.II classes
+     * Patterns::Selection or Patterns::MultipleSelection.
+     */
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ();
+
+
+    /**
+     * Declare the runtime parameters of the registered material models.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm);
+
+
+
+    /**
+     * For the current plugin subsystem, write a connection graph of all of the
+     * plugins we know about, in the format that the
+     * programs dot and neato understand. This allows for a visualization of
+     * how all of the plugins that ASPECT knows about are interconnected, and
+     * connect to other parts of the ASPECT code.
+     *
+     * @param output_stream The stream to write the output to.
+     */
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &output_stream);
+
+
+
+// --------------------- template function definitions ----------------------------------
+
+    template <int dim>
+    template <class AdditionalInputType>
+    AdditionalInputType *MaterialModelInputs<dim>::get_additional_input()
+    {
+      for (unsigned int i=0; i<additional_inputs.size(); ++i)
+        {
+          AdditionalInputType *result = dynamic_cast<AdditionalInputType *> (additional_inputs[i].get());
+          if (result)
+            return result;
+        }
+      return nullptr;
+    }
+
+
+    template <int dim>
+    template <class AdditionalInputType>
+    const AdditionalInputType *MaterialModelInputs<dim>::get_additional_input() const
+    {
+      for (unsigned int i=0; i<additional_inputs.size(); ++i)
+        {
+          const AdditionalInputType *result = dynamic_cast<const AdditionalInputType *> (additional_inputs[i].get());
+          if (result)
+            return result;
+        }
+      return nullptr;
+    }
+
+
+    template <int dim>
+    template <class AdditionalOutputType>
+    AdditionalOutputType *MaterialModelOutputs<dim>::get_additional_output()
+    {
+      for (unsigned int i=0; i<additional_outputs.size(); ++i)
+        {
+          AdditionalOutputType *result = dynamic_cast<AdditionalOutputType *> (additional_outputs[i].get());
+          if (result)
+            return result;
+        }
+      return nullptr;
+    }
+
+
+    template <int dim>
+    template <class AdditionalOutputType>
+    const AdditionalOutputType *MaterialModelOutputs<dim>::get_additional_output() const
+    {
+      for (unsigned int i=0; i<additional_outputs.size(); ++i)
+        {
+          const AdditionalOutputType *result = dynamic_cast<const AdditionalOutputType *> (additional_outputs[i].get());
+          if (result)
+            return result;
+        }
+      return nullptr;
+    }
+
+
+    template <int dim>
+    void MaterialModelOutputs<dim>::move_additional_outputs_from(MaterialModelOutputs<dim> &other)
+    {
+      Assert(this->additional_outputs.empty(), ExcMessage("Destination of move needs to be empty!"));
+      this->additional_outputs = std::move(other.additional_outputs);
+    }
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a material model, register it with the functions that can declare
+     * their parameters and create these objects.
+     *
+     * @ingroup MaterialModels
+     */
+#define ASPECT_REGISTER_MATERIAL_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_MATERIAL_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::MaterialModel::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::MaterialModel::register_material_model<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::MaterialModel::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::MaterialModel::register_material_model<3>, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/material_model/latent_heat.h.bak b/include/aspect/material_model/latent_heat.h.bak
new file mode 100644
index 00000000000..2646a5bc2e8
--- /dev/null
+++ b/include/aspect/material_model/latent_heat.h.bak
@@ -0,0 +1,127 @@
+/*
+  Copyright (C) 2013 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_latent_heat_h
+#define _aspect_material_model_latent_heat_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that implements a standard approximation of the latent
+     * heat terms following Christensen \& Yuen, 1986. The change of entropy
+     * is calculated as $Delta S = \gamma \frac{\Delta\rho}{\rho^2}$ with the
+     * Clapeyron slope $\gamma$ and the density change $\Delta\rho$ of the
+     * phase transition being input parameters. This model employs an analytic
+     * phase function in the form $X=\frac{1}{2} \left( 1 + \tanh \left( \frac{\Delta
+     * p}{\Delta p_0} \right) \right)$ with $\Delta p = p - p_transition -
+     * \gamma \left( T - T_transition \right)$ and $\Delta p_0$ being the
+     * pressure difference over the width of the phase transition (specified
+     * as input parameter).
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class LatentHeat : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Evaluate material properties.
+         */
+        void evaluate(const MaterialModelInputs<dim> &in,
+                      MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        double reference_rho;
+        double reference_T;
+        double eta;
+        double composition_viscosity_prefactor;
+        double thermal_viscosity_exponent;
+        double thermal_alpha;
+        double reference_specific_heat;
+        double reference_compressibility;
+        double maximum_viscosity;
+        double minimum_viscosity;
+
+        /**
+         * The thermal conductivity.
+         */
+        double k_value;
+
+        double compositional_delta_rho;
+
+        // list of depth (or pressure), width and Clapeyron slopes
+        // for the different phase transitions
+        std::vector<double> density_jumps;
+        std::vector<int> transition_phases;
+        std::vector<double> phase_prefactors;
+
+        MaterialUtilities::PhaseFunction<dim> phase_function;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/latent_heat_melt.h.bak b/include/aspect/material_model/latent_heat_melt.h.bak
new file mode 100644
index 00000000000..71770705bc7
--- /dev/null
+++ b/include/aspect/material_model/latent_heat_melt.h.bak
@@ -0,0 +1,205 @@
+/*
+  Copyright (C) 2013 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_latent_heat_melt_h
+#define _aspect_material_model_latent_heat_melt_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/melt.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that implements latent heat of melting for two
+     * materials: peridotite and pyroxenite. The density and thermal
+     * expansivity depend on the melt fraction.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class LatentHeatMelt : public MaterialModel::Interface<dim>,
+      public MaterialModel::MeltFractionModel<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                             std::vector<double> &melt_fractions) const override;
+
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        double reference_rho;
+        double reference_T;
+        double eta;
+        double composition_viscosity_prefactor;
+        double thermal_viscosity_exponent;
+        double thermal_alpha;
+        double melt_thermal_alpha;
+        double reference_specific_heat;
+        double reference_compressibility;
+
+        /**
+         * The thermal conductivity.
+         */
+        double k_value;
+
+        double compositional_delta_rho;
+
+        /**
+         * Parameters for anhydrous melting of peridotite after Katz, 2003
+         */
+
+        // for the solidus temperature
+        double A1;   // °C
+        double A2; // °C/Pa
+        double A3; // °C/(Pa^2)
+
+        // for the lherzolite liquidus temperature
+        double B1;   // °C
+        double B2;   // °C/Pa
+        double B3; // °C/(Pa^2)
+
+        // for the liquidus temperature
+        double C1;   // °C
+        double C2;  // °C/Pa
+        double C3; // °C/(Pa^2)
+
+        // for the reaction coefficient of pyroxene
+        double r1;     // cpx/melt
+        double r2;     // cpx/melt/GPa
+        double M_cpx;  // mass fraction of pyroxene
+
+        // melt fraction exponent
+        double beta;
+
+        // entropy change upon melting
+        double peridotite_melting_entropy_change;
+
+        /**
+         * Parameters for melting of pyroxenite after Sobolev et al., 2011
+         */
+
+        // for the melting temperature
+        double D1;    // °C
+        double D2;  // °C/Pa
+        double D3; // °C/(Pa^2)
+        // for the melt-fraction dependence of productivity
+        double E1;
+        double E2;
+
+        // for the maximum melt fraction of pyroxenite
+        double F_px_max;
+
+        // the relative density of molten material (compared to solid)
+        double relative_melt_density;
+
+        double pyroxenite_melting_entropy_change;
+
+        /**
+         * Percentage of material that is molten. Melting model after Katz,
+         * 2003 (for peridotite) and Sobolev et al., 2011 (for pyroxenite)
+         */
+        virtual
+        double
+        melt_fraction (const double temperature,
+                       const double pressure,
+                       const std::vector<double> &compositional_fields,
+                       const Point<dim> &position) const;
+
+        virtual
+        double
+        peridotite_melt_fraction (const double temperature,
+                                  const double pressure,
+                                  const std::vector<double> &compositional_fields,
+                                  const Point<dim> &position) const;
+
+        virtual
+        double
+        pyroxenite_melt_fraction (const double temperature,
+                                  const double pressure,
+                                  const std::vector<double> &compositional_fields,
+                                  const Point<dim> &position) const;
+
+        double
+        entropy_derivative ( const double temperature,
+                             const double pressure,
+                             const std::vector<double> &compositional_fields,
+                             const Point<dim> &position,
+                             const NonlinearDependence::Dependence dependence) const;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/melt_boukare.h.bak b/include/aspect/material_model/melt_boukare.h.bak
new file mode 100644
index 00000000000..145fad241fb
--- /dev/null
+++ b/include/aspect/material_model/melt_boukare.h.bak
@@ -0,0 +1,355 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_melt_boukare_h
+#define _aspect_material_model_melt_boukare_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/melt.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * Additional output fields for the melt boukare material model.
+     */
+    template <int dim>
+    class BoukareOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        BoukareOutputs(const unsigned int n_points);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * Bulk composition of the material.
+         */
+        std::vector<double> bulk_composition;
+        std::vector<double> molar_volatiles_in_melt;
+    };
+
+    /**
+     * A material model that implements a simplified version of the melting
+     * model of Boukare et al. (https://doi.org/10.1002/2015JB011929) for the
+     * lowermost mantle. The model parameterizes the composition (which includes
+     * the components MgO, FeO and SiO2) as a mixture between two endmembers
+     * (one iron-bearing and one magnesium-bearing). The equation of state
+     * considers three phases: bridgmanite, ferropericlase, and melt (each with
+     * their individual compositions).
+     * More details can be found in Dannberg, J., Myhill, R., Gassmöller, R.,
+     * & Cottaar, S. (2021). The morphology, evolution and seismic visibility
+     * of partial melt at the core–mantle boundary: implications for ULVZs.
+     * Geophysical Journal International, 227(2), 1028-1059.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class MeltBoukare : public MaterialModel::MeltInterface<dim>,
+      public MaterialModel::MeltFractionModel<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. Computes endmember properties.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Return whether the model is compressible or not. In this model,
+         * both the melt and solid are compressible.
+         */
+        bool is_compressible () const override;
+
+        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                      typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * Compute the equilibrium melt fractions for the given input conditions.
+         * @p in and @p melt_fractions need to have the same size.
+         *
+         * @param in Object that contains the current conditions.
+         * @param melt_fractions Vector of doubles that is filled with the
+         * equilibrium melt fraction for each given input conditions.
+         */
+        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                             std::vector<double> &melt_fractions) const override;
+
+        /**
+         * @name Reference quantities
+         * @{
+         */
+        double reference_darcy_coefficient () const override;
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+      private:
+        // Thermodynamic parameters of the endmember components in the equation of state,
+        // needed to compute their material properties.
+        std::vector<std::string> endmember_names;
+        std::vector<double> molar_masses;
+        std::vector<double> number_of_atoms;
+        std::vector<double> reference_volumes;
+        std::vector<double> reference_thermal_expansivities;
+        std::vector<double> reference_bulk_moduli;
+        std::vector<double> bulk_modulus_pressure_derivatives;
+        std::vector<double> bulk_modulus_second_pressure_derivatives;
+        std::vector<double> Einstein_temperatures;
+        std::vector<double> reference_enthalpies;
+        std::vector<double> reference_entropies;
+        std::vector<double> reference_specific_heats;
+        std::vector<double> specific_heat_linear_coefficients;
+        std::vector<double> specific_heat_second_coefficients;
+        std::vector<double> specific_heat_third_coefficients;
+
+        std::vector<double> tait_parameters_a;
+        std::vector<double> tait_parameters_b;
+        std::vector<double> tait_parameters_c;
+
+        // Reference conditions for computing the material properties in the equation of state.
+        double reference_temperature;
+        double reference_pressure;
+
+        // Rheological properties.
+        double eta_0;
+        double xi_0;
+        double eta_f;
+        double thermal_viscosity_exponent;
+        double thermal_bulk_viscosity_exponent;
+        double alpha_phi;
+
+        // Transport properties that are not computed from the equation of state.
+        double thermal_conductivity;
+        double reference_permeability;
+
+        // Parameters controlling melting and solidification of melt.
+        bool include_melting_and_freezing;
+        double melting_time_scale;
+
+        // Parameters defining the molar composition of the two endmember compositions we use
+        // in the melting model.
+        const double molar_MgO_in_Mg_mantle_endmember = 0.581;
+        const double molar_SiO2_in_Mg_mantle_endmember = 0.419;
+        const double molar_FeO_in_Fe_mantle_endmember = 0.908;
+        const double molar_SiO2_in_Fe_mantle_endmember = 0.092;
+
+        // Parameters describing the melting properties of the two endmembers of the melting model.
+        const double melting_reference_pressure = 120.e9;
+
+        // reference melting temperature for Fe and Mg mantle endmember at the reference pressure
+        double Fe_mantle_melting_temperature;
+        double Mg_mantle_melting_temperature;
+
+        // molar entropy change of melting in J/mol K
+        const double Fe_mantle_melting_entropy = 33.77;
+        const double Mg_mantle_melting_entropy = 34.33;
+
+        // molar volume change of melting of solid Fe and Mg mantle endmember in m3/mol
+        const double Fe_mantle_melting_volume = 1.51e-07;
+        const double Mg_mantle_melting_volume = 9.29e-08;
+
+        // Number of moles of atoms mixing on pseudosite in mantle lattice (empirical model fitting the full Boukare model).
+        double Fe_number_of_moles;
+        double Mg_number_of_moles;
+
+        // Indices for the endmembers in the equation of state.
+        unsigned int febdg_idx;
+        unsigned int mgbdg_idx;
+        unsigned int wus_idx;
+        unsigned int per_idx;
+        unsigned int femelt_idx;
+        unsigned int mgmelt_idx;
+
+
+        // Parameter describing if an endmember in the equation of state is solid or molten.
+        struct EndmemberState
+        {
+          enum Kind
+          {
+            solid,
+            melt
+          };
+        };
+
+        std::vector<typename EndmemberState::Kind> endmember_states;
+
+
+        // Material properties of the different endmembers of the equation of state.
+        struct EndmemberProperties
+        {
+          /**
+           * Constructor. Initialize the various arrays of this structure with the
+           * given number of endmembers.
+           */
+          EndmemberProperties(const unsigned int n_endmembers);
+
+          std::vector<double> volumes;
+          std::vector<double> gibbs_energies;
+          std::vector<double> entropies;
+          std::vector<double> thermal_expansivities;
+          std::vector<double> bulk_moduli;
+          std::vector<double> heat_capacities;
+        };
+
+
+        /**
+         * Fill the endmember properties at a single point.
+         */
+        virtual
+        void
+        fill_endmember_properties (const typename Interface<dim>::MaterialModelInputs &in,
+                                   const unsigned int q,
+                                   EndmemberProperties &properties) const;
+
+
+        /**
+         * Calculate the Einstein thermal energy of an endmember component.
+         */
+        virtual
+        double
+        endmember_thermal_energy (const double temperature,
+                                  const unsigned int endmember_index) const;
+
+
+        /**
+         * Calculate the heat capacity of an endmember component.
+         */
+        virtual
+        double
+        endmember_molar_heat_capacity (const double temperature,
+                                       const unsigned int endmember_index) const;
+
+        /**
+         * Calculate the thermal pressure of an endmember component.
+         */
+        virtual
+        double
+        endmember_thermal_pressure (const double temperature,
+                                    const unsigned int endmember_index) const;
+
+        /**
+         * Calculate the thermal addition to the standard state enthalpy of an endmember component
+         * at the reference pressure.
+         */
+        virtual
+        double
+        endmember_enthalpy_thermal_addition (const double temperature,
+                                             const unsigned int endmember_index) const;
+
+        /**
+         * Calculate the thermal addition to the standard state enttropy of an endmember component
+         * at the reference pressure.
+         */
+        virtual
+        double
+        endmember_entropy_thermal_addition (const double temperature,
+                                            const unsigned int endmember_index) const;
+
+
+        /**
+         * Convert from the mole fraction of iron in the solid and melt to the mole fraction of iron
+         * and magnesium in each of the two solid phases, bridgmanite and ferropericlase, and the melt
+         * phase. In addition, compute the molar fraction of bridgmanite in the solid.
+         */
+        virtual
+        void
+        convert_composition_to_fraction_of_endmembers (const double temperature,
+                                                       const double molar_Fe_in_solid,
+                                                       const double molar_Fe_in_melt,
+                                                       const std::vector<double> &endmember_gibbs_energies,
+                                                       std::vector<double> &endmember_mole_fractions_per_phase,
+                                                       double &molar_bridgmanite_in_solid) const;
+
+
+        /**
+         * Compute the molar fraction of melt from the volume fraction of melt (the porosity).
+         * This requires knowing the densities of both solid and melt, which can be computed
+         * from the fractions and material properties of the component endmembers.
+         */
+        virtual
+        double
+        compute_melt_molar_fraction (const double porosity,
+                                     const double bridgmanite_molar_fraction_in_solid,
+                                     EndmemberProperties &properties,
+                                     const std::vector<double> &endmember_mole_fractions_per_phase) const;
+
+
+        /**
+         * Make sure that when the property @p value is updated by adding @p change_of_value,
+         * the new value is between zero and one. Otherwise, throw an error message.
+         */
+        virtual
+        double
+        assert_update_is_within_0_and_1 (const double value,
+                                         const double change_of_value) const;
+
+
+        /**
+         * Compute the equilibrium melt fraction for a given @p temperature, @p pressure,
+         * and @p bulk_composition and the corresponding composition of melt and solid. The
+         * melting model is based on Phipps Morgan, Jason. "Thermodynamics of pressure release
+         * melting of a veined plum pudding mantle." Geochemistry, Geophysics, Geosystems 2.4
+         * (2001), and additionally includes volatiles.
+         */
+        virtual
+        double
+        melt_fraction (const double temperature,
+                       const double pressure,
+                       const double bulk_composition,
+                       double &molar_volatiles_in_melt,
+                       double &solid_composition,
+                       double &melt_composition) const;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/melt_global.h.bak b/include/aspect/material_model/melt_global.h.bak
new file mode 100644
index 00000000000..cc2da5af596
--- /dev/null
+++ b/include/aspect/material_model/melt_global.h.bak
@@ -0,0 +1,149 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_melt_global_h
+#define _aspect_material_model_melt_global_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/postprocess/melt_statistics.h>
+#include <aspect/melt.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that implements a simple formulation of the
+     * material parameters required for the modeling of melt transport
+     * in a global model, including a source term for the porosity according
+     * a simplified linear melting model.
+     *
+     * The model is considered incompressible, following the definition
+     * described in Interface::is_compressible.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class MeltGlobal : public MaterialModel::MeltInterface<dim>,
+      public MaterialModel::MeltFractionModel<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+
+        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                      typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * Compute the equilibrium melt fractions for the given input conditions.
+         * @p in and @p melt_fractions need to have the same size.
+         *
+         * @param in Object that contains the current conditions.
+         * @param melt_fractions Vector of doubles that is filled with the
+         * equilibrium melt fraction for each given input conditions.
+         */
+        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                             std::vector<double> &melt_fractions) const override;
+
+        /**
+         * @name Reference quantities
+         * @{
+         */
+        double reference_darcy_coefficient () const override;
+
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+      private:
+        double reference_rho_s;
+        double reference_rho_f;
+        double reference_T;
+        double eta_0;
+        double xi_0;
+        double eta_f;
+        double thermal_viscosity_exponent;
+        double thermal_bulk_viscosity_exponent;
+        double thermal_expansivity;
+        double reference_specific_heat;
+        double thermal_conductivity;
+        double reference_permeability;
+        double alpha_phi;
+        double depletion_density_change;
+        double depletion_solidus_change;
+        double pressure_solidus_change;
+        double surface_solidus;
+        double compressibility;
+        double melt_compressibility;
+        bool include_melting_and_freezing;
+        double melting_time_scale;
+        double alpha_depletion;
+        double delta_eta_depletion_max;
+
+        // entropy change upon melting
+        double peridotite_melting_entropy_change;
+
+        virtual
+        double
+        melt_fraction (const double temperature,
+                       const double pressure,
+                       const double depletion) const;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/melt_simple.h.bak b/include/aspect/material_model/melt_simple.h.bak
new file mode 100644
index 00000000000..0d30c32c9ee
--- /dev/null
+++ b/include/aspect/material_model/melt_simple.h.bak
@@ -0,0 +1,144 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_melt_simple_h
+#define _aspect_material_model_melt_simple_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/postprocess/melt_statistics.h>
+#include <aspect/melt.h>
+#include <aspect/material_model/reaction_model/katz2003_mantle_melting.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that implements a simple formulation of the
+     * material parameters required for the modeling of melt transport,
+     * including a source term for the porosity according to the melting
+     * model for dry peridotite of Katz, 2003. This also includes a
+     * computation of the latent heat of melting (if the latent heat
+     * heating model is active).
+     *
+     * Most of the material properties are constant, except for the shear,
+     * compaction and melt viscosities and the permeability, which depend on
+     * the porosity; and the solid and melt densities, which depend on
+     * temperature and pressure.
+     *
+     * The model is compressible (following the definition described in
+     * Interface::is_compressible) only if this is specified in the input file,
+     * and contains compressibility for both solid and melt.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class MeltSimple : public MaterialModel::MeltInterface<dim>,
+      public MaterialModel::MeltFractionModel<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run and after
+         * the SimulatorAccess (if applicable) is initialized.
+         */
+        void
+        initialize () override;
+
+        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                      typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                             std::vector<double> &melt_fractions) const override;
+
+        /**
+         * @name Reference quantities
+         * @{
+         */
+        double reference_darcy_coefficient () const override;
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+      private:
+        bool model_is_compressible;
+        double thermal_expansivity;
+        double eta_0;
+        double reference_specific_heat;
+        double thermal_conductivity;
+        double compressibility;
+        double thermal_viscosity_exponent;
+        double reference_T;
+        double depletion_density_change;
+        double reference_rho_solid;
+
+
+
+        /*
+        * Object for computing the melt parameters
+        */
+        ReactionModel::Katz2003MantleMelting<dim> katz2003_model;
+
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/modified_tait.h.bak b/include/aspect/material_model/modified_tait.h.bak
new file mode 100644
index 00000000000..c889f06370b
--- /dev/null
+++ b/include/aspect/material_model/modified_tait.h.bak
@@ -0,0 +1,166 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_modified_tait_h
+#define _aspect_material_model_modified_tait_h
+
+#include <deal.II/base/function_lib.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A compressible material model that implements the thermal modified Tait
+     * equation of state as written in the paper of Holland and Powell, 2011
+     * "An improved and extended internally consistent thermodynamic dataset
+     * for phases of petrological interest, involving a new equation of state
+     * for solids".
+     *
+     * Constant values are used for the thermal conductivity and viscosity.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class ModifiedTait : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+
+      public:
+        /**
+         * Evaluate material properties.
+         */
+        void evaluate(const MaterialModelInputs<dim> &in,
+                      MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         * This model is compressible.
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+      private:
+        /**
+         * The Tait parameters
+         */
+        double tait_a, tait_b, tait_c;
+
+        /**
+         * The reference pressure
+         */
+        double reference_pressure;
+
+        /**
+         * The reference temperature
+         */
+        double reference_temperature;
+
+        /**
+         * The reference density
+         */
+        double reference_rho;
+
+        /**
+         * The reference isothermal bulk modulus
+         */
+        double reference_isothermal_bulk_modulus;
+
+        /**
+         * The reference K'
+         * (first pressure derivative of the isothermal bulk modulus)
+         */
+        double reference_Kprime;
+
+        /**
+         * The reference K''
+         * (second pressure derivative of the isothermal bulk modulus)
+         */
+        double Kdprime_0;
+
+        /**
+         * The reference thermal expansivity
+         */
+        double reference_thermal_expansivity;
+
+        /**
+         * The Einstein temperature
+         */
+        double einstein_temperature;
+
+        /**
+         * Parsed function that specifies the specific heat at P0 when using the Function
+         * method.
+         */
+        Functions::ParsedFunction<1> reference_heat_capacity_function;
+
+        /**
+         * The constant viscosity
+         */
+        double eta;
+
+        /**
+         * The constant thermal conductivity.
+         */
+        double k_value;
+
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/multicomponent.h.bak b/include/aspect/material_model/multicomponent.h.bak
new file mode 100644
index 00000000000..49524bf31e1
--- /dev/null
+++ b/include/aspect/material_model/multicomponent.h.bak
@@ -0,0 +1,139 @@
+/*
+  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_multicomponent_h
+#define _aspect_material_model_multicomponent_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/equation_of_state/multicomponent_incompressible.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * An incompressible material model which is intended for use with multiple
+     * compositional fields. Each compositional field is meant to be a single
+     * rock type, where the value of the field at a point is interpreted to be
+     * a volume fraction of that rock type.  If the sum of the compositional field
+     * volume fractions is less than one, then the remainder of the volume is
+     * assumed to be ``background mantle''.  If the sum of the compositional
+     * field volume fractions is greater than one, then they are renormalized
+     * to sum to one and there is no background mantle.
+     *
+     * For each material parameter the user supplies a comma delimited list of
+     * length N+1, where N is the number of compositional fields.  The
+     * additional field corresponds to the value for background mantle.  They
+     * should be ordered ``background, composition1, composition2...''
+     *
+     * If a single value is given, then all the compositional fields are given
+     * that value. Other lengths of lists are not allowed.  For a given
+     * compositional field the material parameters are treated as constant,
+     * except density, which varies linearly with temperature according to the
+     * thermal expansivity.
+     *
+     * When more than one field is present at a point, they are averaged
+     * arithmetically. An exception is viscosity, which may be averaged
+     * arithmetically, harmonically, geometrically, or by selecting the
+     * viscosity of the composition with the greatest volume fraction.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class Multicomponent : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * This model is not compressible, so this returns false.
+         */
+        bool is_compressible () const override;
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+      private:
+        /**
+         * Reference temperature for thermal expansion.  All components use
+         * the same reference_T.
+         */
+        double reference_T;
+
+        /**
+         * Enumeration for selecting which viscosity averaging scheme to use.
+         */
+        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
+
+        /**
+         * Vector for field viscosities, read from parameter file.
+         */
+        std::vector<double> viscosities;
+
+        /**
+         * Vector for field thermal conductivities, read from parameter file.
+         */
+        std::vector<double> thermal_conductivities;
+
+        EquationOfState::MulticomponentIncompressible<dim> equation_of_state;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/multicomponent_compressible.h.bak b/include/aspect/material_model/multicomponent_compressible.h.bak
new file mode 100644
index 00000000000..9198a5ea8b4
--- /dev/null
+++ b/include/aspect/material_model/multicomponent_compressible.h.bak
@@ -0,0 +1,133 @@
+/*
+  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_multicomponent_compressible_h
+#define _aspect_material_model_multicomponent_compressible_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/equation_of_state/multicomponent_compressible.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model which is intended for use with multiple compositional
+     * fields. Each compositional field is meant to be a single rock type,
+     * where the value of the field at a point is interpreted to be the
+     * mass fraction of that rock type. If the sum of the compositional field
+     * mass fractions is less than one, then the remainder of the mass is
+     * assumed to be ``background mantle''.  If the sum of the compositional
+     * field mass fractions is greater than one, then they are renormalized
+     * to sum to one and there is no background mantle.
+     *
+     * For each material parameter the user supplies a comma delimited list of
+     * length N+1, where N is the number of compositional fields.  The
+     * additional field corresponds to the value for background mantle.  They
+     * should be ordered ``background, composition1, composition2...''
+     *
+     * If a single value is given, then all the compositional fields are given
+     * that value. Other lengths of lists are not allowed.  The material
+     * parameters for each compositional field are derived from the
+     * multicomponent compressible equation of state, and are pressure and
+     * temperature dependent.
+     *
+     * When more than one field is present at a point, they are either averaged
+     * self-consistently (for equation of state properties) or arithmetically
+     * (for thermal conductivity). For the special case of viscosity, the user
+     * may select from a variety of averaging schemes:
+     * arithmetic, harmonic, geometric, or by selecting the
+     * viscosity of the composition with the greatest volume fraction.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class MulticomponentCompressible : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * This model is compressible, so this returns true.
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        /**
+         * Enumeration for selecting which viscosity averaging scheme to use.
+         */
+        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
+
+        /**
+         * Vector for field viscosities, read from parameter file.
+         */
+        std::vector<double> viscosities;
+
+        /**
+         * Vector for field thermal conductivities, read from parameter file.
+         */
+        std::vector<double> thermal_conductivities;
+
+        EquationOfState::MulticomponentCompressible<dim> equation_of_state;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/nondimensional.h.bak b/include/aspect/material_model/nondimensional.h.bak
new file mode 100644
index 00000000000..3dcf1482c19
--- /dev/null
+++ b/include/aspect/material_model/nondimensional.h.bak
@@ -0,0 +1,132 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_material_model_nondimensional_h
+#define _aspect_material_model_nondimensional_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model for incompressible (using the Boussinesq approximation)
+     * and compressible computations (with ALA or TALA) for a nondimensionalized
+     * problem. The viscosity is (optionally) depth and temperature dependent.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class Nondimensional : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Initialize.
+         */
+        void initialize () override;
+
+        /**
+         * Evaluate the material model.
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        /**
+         * Use truncated anelastic approximation?
+         */
+        bool tala;
+
+        /**
+         * Are we using ALA/TALA or BA? (determined by the choice of Di)
+         */
+        bool compressible;
+
+        /**
+         * Parameter describing the temperature prefactor of viscosity.
+         */
+        double exponential_viscosity_temperature_prefactor;
+
+        /**
+         * Parameter describing the depth prefactor of viscosity.
+         */
+        double exponential_viscosity_depth_prefactor;
+
+        /**
+         * The surface density.
+         */
+        double reference_rho;
+
+        /**
+         * The nondimensional numbers (Dissipation number,
+         * Rayleigh number, Grueneisen parameter).
+         */
+        double Di, Ra, gamma;
+
+        /**
+         * The constant specific heat
+         */
+        double reference_specific_heat;
+
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/perplex_lookup.h.bak b/include/aspect/material_model/perplex_lookup.h.bak
new file mode 100644
index 00000000000..5054a36f822
--- /dev/null
+++ b/include/aspect/material_model/perplex_lookup.h.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_perplex_lookup_h
+#define _aspect_material_model_perplex_lookup_h
+
+#include <aspect/material_model/interface.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that calls the thermodynamic software PerpleX
+     * in order to evaluate material properties at a given point, namely
+     * the density, heat capacity, thermal expansivity and compressibility.
+     * The viscosity and thermal conductivity are globally constant.
+     *
+     * The usual PerpleX input files are required in the working directory:
+     * an endmember dataset file, solution model dataset file and
+     * option file. The path to a PerpleX input file must be given by
+     * the user in the ASPECT parameter file; this file may be in any
+     * directory. PerpleX output files will be written to the same
+     * directory.
+     *
+     * Compositional fields are used to define the bulk composition at
+     * each point. These compositional fields correspond to the
+     * components as given in the PerpleX input file. The order of
+     * components is preserved.
+     *
+     * This model requires PerpleX. A script to download and setup the
+     * required files can be found in contrib/perplex. If the default
+     * installation directory is not changed, cmake will automatically
+     * find the required files during creation of the ASPECT build files.
+     * See ./contrib/perplex/README.md
+     *
+     * WARNING: This model is extremely slow because there are many
+     * redundant calls to evaluate the material properties;
+     * it serves only as a proof of concept.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class PerpleXLookup : public Interface<dim>
+    {
+      public:
+        /**
+         * Initialization function. Loads the material data and sets up
+         * pointers.
+         */
+        void
+        initialize () override;
+
+        bool is_compressible () const override;
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+
+      private:
+        std::string perplex_file_name;
+        double eta;
+        double k_value;
+        double min_temperature;
+        double max_temperature;
+        double min_pressure;
+        double max_pressure;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/prescribed_viscosity.h.bak b/include/aspect/material_model/prescribed_viscosity.h.bak
new file mode 100644
index 00000000000..321949d3b9b
--- /dev/null
+++ b/include/aspect/material_model/prescribed_viscosity.h.bak
@@ -0,0 +1,110 @@
+/*
+  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_prescribed_viscosity_h
+#define _aspect_material_model_prescribed_viscosity_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <deal.II/base/parsed_function.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that applies a viscosity to a ''base model'' chosen from any of
+     * the other available material models. This prescribed viscosity material model
+     * allows the user to specify a function which describes where the viscosity should be
+     * prescribed and a second function which describes the viscosity in that region.
+     * This material model requires a base model which prescribes the viscosity and the
+     * other material parameters in the rest of the model.
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class PrescribedViscosity : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialize the base model at the beginning of the run.
+         */
+        void initialize() override;
+
+        /**
+         * Update the base model and viscosity function at the beginning of
+         * each timestep.
+         */
+        void update() override;
+
+        /**
+         * Compute the material properties by evaluating the base model and
+         * then overwrite the viscosity according to the viscosity function
+         * in the locations set by the indicator function.
+         */
+        void
+        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
+                  typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * Method to declare parameters related to prescribed viscosity model
+         */
+        static void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Method to parse parameters related to prescribed viscosity model
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Method that indicates whether material is compressible. Prescribed viscosity model is compressible
+         * if and only if base model is compressible.
+         */
+        bool is_compressible () const override;
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+      private:
+
+        /**
+         * Parsed function that specifies where the viscosity is prescribed.
+         */
+        Functions::ParsedFunction<dim> prescribed_viscosity_indicator_function;
+
+        /**
+         * Parsed function that specifies what the viscosity is set to in the
+         * prescribed regions.
+         */
+        Functions::ParsedFunction<dim> prescribed_viscosity_function;
+
+        /**
+         * Pointer to the material model used as the base model
+         */
+        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/reaction_model/katz2003_mantle_melting.h.bak b/include/aspect/material_model/reaction_model/katz2003_mantle_melting.h.bak
new file mode 100644
index 00000000000..b5bf2bd066c
--- /dev/null
+++ b/include/aspect/material_model/reaction_model/katz2003_mantle_melting.h.bak
@@ -0,0 +1,168 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_reaction_melt_katz2003_mantle_melting_h
+#define _aspect_material_reaction_melt_katz2003_mantle_melting_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/postprocess/melt_statistics.h>
+#include <aspect/melt.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace ReactionModel
+    {
+
+      /**
+      * A melt model that calculates melt fraction and entropy change
+      * according to the melting model for dry peridotite of Katz, 2003.
+      * This also includes a computation of the latent heat of melting (if the latent heat
+      * heating model is active).
+      *
+      * These functions can be used in the calculation of melting and melt transport
+      * in the melt_simple material model and can be extended to other material models
+      *
+      * @ingroup ReactionModel
+      */
+      template <int dim>
+      class Katz2003MantleMelting : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          // constructor
+          Katz2003MantleMelting();
+
+          /**
+          * Declare the parameters this function takes through input files.
+          */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+
+          /**
+           * Percentage of material that is molten for a given @p temperature and
+           * @p pressure (assuming equilibrium conditions). Melting model after Katz,
+           * 2003, for dry peridotite.
+           */
+          double
+          melt_fraction (const double temperature,
+                         const double pressure) const;
+
+          /**
+          * Compute the change in entropy due to melting for a given @p temperature
+          * and @p pressure, and under the assumption that a fraction
+          * @p maximum_melt_fraction of the material has already been molten
+          * previously. The entropy change is computed with respect to temperature
+          * or pressure, depending on @p dependence.
+          * This is needed to calculate the latent heat of melt.
+          */
+          double
+          entropy_change (const double temperature,
+                          const double pressure,
+                          const double maximum_melt_fraction,
+                          const NonlinearDependence::Dependence dependence) const;
+
+
+          /**
+           * Compute all the reaction rate variables needed for a reactive transport model based on the
+           * Katz 2003 formulation. Takes the material model inputs @p in to compute the material model outputs @p out.
+           * This function mainly fills the reaction_rate_out object but populates out.reaction_terms,
+           * out.entropy_derivative_pressure and entropy_derivative_temperature
+          */
+          void calculate_reaction_rate_outputs(const typename Interface<dim>::MaterialModelInputs &in,
+                                               typename Interface<dim>::MaterialModelOutputs &out) const;
+
+          /**
+           * Compute all the fluid variables needed for a reactive transport model based on the
+           * Katz 2003 formulation. This function fills melt outputs, the out object should already contain
+           * outputs for the solid and this function uses the inputs @p in and the solid outputs @p out
+           * to fill MeltOutputs. Solid outputs such as out.Thermal_expansion_coefficients are expected
+           * to have already been computed when this function is called. Solid viscosities are also modified
+           * in the out object here because the presence of melt weakens the material.
+          */
+          void calculate_fluid_outputs(const typename Interface<dim>::MaterialModelInputs &in,
+                                       typename Interface<dim>::MaterialModelOutputs &out,
+                                       const double reference_T) const;
+
+
+          double reference_darcy_coefficient () const;
+
+        private:
+          /**
+          * Parameters for anhydrous melting of peridotite after Katz, 2003
+          */
+
+          double reference_rho_fluid;
+          double xi_0;
+          double viscosity_fluid;
+          double thermal_bulk_viscosity_exponent;
+          double alpha_phi;
+          double extraction_depth;
+          double melt_compressibility;
+          double melt_bulk_modulus_derivative;
+          double depletion_solidus_change;
+          bool fractional_melting;
+          double freezing_rate;
+          double melting_time_scale;
+          double reference_permeability;
+
+          // for the solidus temperature
+          double A1;   // °C
+          double A2; // °C/Pa
+          double A3; // °C/(Pa^2)
+
+          // for the lherzolite liquidus temperature
+          double B1;   // °C
+          double B2;   // °C/Pa
+          double B3; // °C/(Pa^2)
+
+          // for the liquidus temperature
+          double C1;   // °C
+          double C2;  // °C/Pa
+          double C3; // °C/(Pa^2)
+
+          // for the reaction coefficient of pyroxene
+          double r1;     // cpx/melt
+          double r2;     // cpx/melt/GPa
+          double M_cpx;  // mass fraction of pyroxene
+
+          // melt fraction exponent
+          double beta;
+
+          // entropy change upon melting
+          double peridotite_melting_entropy_change;
+      };
+    }
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/reactive_fluid_transport.h.bak b/include/aspect/material_model/reactive_fluid_transport.h.bak
new file mode 100644
index 00000000000..245f2e0eb2c
--- /dev/null
+++ b/include/aspect/material_model/reactive_fluid_transport.h.bak
@@ -0,0 +1,262 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_reactive_fluid_transport_h
+#define _aspect_material_model_reactive_fluid_transport_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/melt.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <aspect/melt.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/material_model/reaction_model/katz2003_mantle_melting.h>
+
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+    /**
+     * A material model that simulates both fluid-rock interactions
+     * and the advection of fluids. It is designed to be composited with another material
+     * model that computes the solid material properties.
+     * @ingroup MaterialModels
+     */
+
+    template <int dim>
+    class ReactiveFluidTransport : public MaterialModel::MeltInterface<dim>, public MaterialModel::MeltFractionModel<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * @copydoc MaterialModel::Interface::is_compressible()
+         *
+         * Returns value from material model providing compressibility.
+         */
+        bool is_compressible () const override;
+
+        /**
+         * @name Reference quantities
+         * @{
+         */
+        virtual double reference_darcy_coefficient () const override;
+
+
+        /**
+         * Compute the maximum allowed bound water content at the input
+         * pressure and temperature conditions. This is used to determine
+         * how free water interacts with the solid phase.
+         * @param in Object that contains the current conditions.
+         * @param q unsigned int from 0-3 indexing which rock phase the equilbrium
+         * bound water content is being calculated for
+         */
+        std::vector<double> tian_equilibrium_bound_water_content(const MaterialModel::MaterialModelInputs<dim> &in,
+                                                                 unsigned int q) const;
+
+        /**
+         * Compute the free fluid fraction that can be present in the material based on the
+         * fluid content of the material and the fluid solubility for the given input conditions.
+         * @p in and @p melt_fractions need to have the same size.
+         *
+         * @param in Object that contains the current conditions.
+         * @param melt_fractions Vector of doubles that is filled with the
+         * allowable free fluid fraction for each given input conditions.
+         */
+        virtual void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                                     std::vector<double> &melt_fractions) const override;
+
+        /**
+         * Initialize the base model at the beginning of the model run
+         * @copydoc MaterialModel::Interface::initialize()
+         */
+        void
+        initialize () override;
+
+        /**
+         * Update the base model at the beginning of each timestep.
+         */
+        void update() override;
+
+        /**
+         * @copydoc MaterialModel::Interface::evaluate()
+         */
+        void
+        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
+                  typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * @copydoc MaterialModel::Interface::declare_parameters()
+         */
+        static void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * @copydoc MaterialModel::Interface::parse_parameters()
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * If this material model can produce additional named outputs
+         * that are derived from NamedAdditionalOutputs, create them in here.
+         */
+        virtual
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+      private:
+
+        /**
+         * Pointer to the material model used as the base model
+         */
+        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
+
+        // Variables that describe the properties of the fluid, i.e. its density,
+        // viscosity, and compressibility.
+        // Properties of the solid are defined in the base model.
+        double reference_rho_f;
+        double eta_f;
+        double fluid_compressibility;
+
+        // Material properties governing the transport of the fluid with respect
+        // to the solid, i.e., the bulk viscosity (relative to the shear viscosity),
+        // the permeability, and how much the solid viscosity changes in the presence
+        // of fluids.
+        double shear_to_bulk_viscosity_ratio;
+        double min_compaction_visc;
+        double max_compaction_visc;
+        double reference_permeability;
+        double alpha_phi;
+        double reference_T;
+
+        // Time scale for fluid release and absorption.
+        double fluid_reaction_time_scale;
+
+        // The maximum water content for each of the 4 rock types in the tian approximation
+        // method. These are important for keeping the polynomial bounded within reasonable
+        // values.
+        double tian_max_peridotite_water;
+        double tian_max_gabbro_water;
+        double tian_max_MORB_water;
+        double tian_max_sediment_water;
+
+        // The following coefficients are taken from a publication from Tian et al., 2019, and can be found
+        // in Table 3 (Gabbro), Table B1 (MORB), Table B2 (Sediments) and Table B3 (peridotite).
+        // LR refers to the effective enthalpy change for devolatilization reactions,
+        // csat is the saturated mass fraction of water in the solid, and Td is the
+        // onset temperature of devolatilization for water.
+        std::vector<double> LR_peridotite_poly_coeffs {-19.0609, 168.983, -630.032, 1281.84, -1543.14, 1111.88, -459.142, 95.4143, 1.97246};
+        std::vector<double> csat_peridotite_poly_coeffs {0.00115628, 2.42179};
+        std::vector<double> Td_peridotite_poly_coeffs {-15.4627, 94.9716, 636.603};
+
+        std::vector<double> LR_gabbro_poly_coeffs {-1.81745, 7.67198, -10.8507, 5.09329, 8.14519};
+        std::vector<double> csat_gabbro_poly_coeffs {-0.0176673, 0.0893044, 1.52732};
+        std::vector<double> Td_gabbro_poly_coeffs {-1.72277, 20.5898, 637.517};
+
+        std::vector<double> LR_MORB_poly_coeffs {-1.78177, 7.50871, -10.4840, 5.19725, 7.96365};
+        std::vector<double> csat_MORB_poly_coeffs {0.0102725, -0.115390, 0.324452, 1.41588};
+        std::vector<double> Td_MORB_poly_coeffs {-3.81280, 22.7809, 638.049};
+
+        std::vector<double> LR_sediment_poly_coeffs {-2.03283, 10.8186, -21.2119, 18.3351, -6.48711, 8.32459};
+        std::vector<double> csat_sediment_poly_coeffs {-0.150662, 0.301807, 1.01867};
+        std::vector<double> Td_sediment_poly_coeffs {2.83277, -24.7593, 85.9090, 524.898};
+
+        // The polynomials breakdown above certain pressures, 10 GPa for peridotite, 26 GPa for gabbro, 16 GPa for MORB,
+        // and 50 GPa for sediment. These cutoff pressures were determined by extending the pressure range in Tian et al. (2019)
+        // and observing where the maximum allowed water contents jump towards infinite values.
+        const std::vector<double> pressure_cutoffs {10, 26, 16, 50};
+
+        std::vector<std::vector<double>> devolatilization_enthalpy_changes {LR_peridotite_poly_coeffs, LR_gabbro_poly_coeffs, \
+                                                                             LR_MORB_poly_coeffs, LR_sediment_poly_coeffs
+                                                                            };
+
+        std::vector<std::vector<double>> water_mass_fractions {csat_peridotite_poly_coeffs, csat_gabbro_poly_coeffs, \
+                                                                csat_MORB_poly_coeffs, csat_sediment_poly_coeffs
+                                                               };
+
+        std::vector<std::vector<double>> devolatilization_onset_temperatures {Td_peridotite_poly_coeffs, Td_gabbro_poly_coeffs, \
+                                                                               Td_MORB_poly_coeffs, Td_sediment_poly_coeffs
+                                                                              };
+
+        /*
+        * Object for computing Katz 2003 melt parameters
+        */
+        ReactionModel::Katz2003MantleMelting<dim> katz2003_model;
+
+        /**
+         * Enumeration for selecting which type of scheme to use for
+         * reactions between fluids and solids. The available
+         * reaction models are described below.
+         *
+         * The no reaction model does not include any reactions
+         * between the solid and fluid phases. As a result,
+         * there is no exchange between the bound fluid and porosity
+         * compositional fields. However, the values of each field
+         * may vary through the model evolution through advection
+         * from their initial configurations.
+         *
+         * The zero solubility model describes a scenario where the
+         * solid cannot accommodate any fluid (i.e., zero solubility).
+         * The fluid volume fraction in equilibrium with the solid
+         * at any point (stored in the melt_fractions vector) is
+         * equal to the sum of the bound fluid content and porosity,
+         * with the latter determined by the assigned initial
+         * porosity, fluid boundary conditions, and fluid
+         * transport through the model. Significantly, this reaction
+         * model is thus assuming that the bound water fraction is a
+         * volume fraction (i.e., since porosity is always a volume
+         * fraction). This latter assumption also requires the selected
+         * base model to be incompressible, as otherwise the advection
+         * equation would only be valid for mass and not volume
+         * fractions.
+         *
+         * The tian approximation model implements parametrized phase
+         * diagrams from Tian et al., 2019 G3, https://doi.org/10.1029/2019GC008488
+         * and calculates the fluid-solid reactions for four different rock types:
+         * sediments, MORB, gabbro and peridotite. This is achieved by calculating the
+         * maximum allowed bound water content for each composition at the current
+         * Pressure-Temperature conditions, and releasing bound water as free water if:
+         * (maximum bound water content < current bound water content)
+         * or incorporating free water (if present) into the solid phase as bound water:
+         * maximum bound water content > current bound water content
+         * This model requires that 4 compositional fields named after the 4 different rock
+         * types exist in the input file.
+         *
+         * The Katz2003 model implements anhydrous the mantle melting model from
+         * Katz et. al., 2003 G3, doi:10.1029/2002GC000433.
+         */
+        enum ReactionScheme
+        {
+          no_reaction,
+          zero_solubility,
+          tian_approximation,
+          katz2003
+        }
+        fluid_solid_reaction_scheme;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/replace_lithosphere_viscosity.h.bak b/include/aspect/material_model/replace_lithosphere_viscosity.h.bak
new file mode 100644
index 00000000000..e7ac2fd94b6
--- /dev/null
+++ b/include/aspect/material_model/replace_lithosphere_viscosity.h.bak
@@ -0,0 +1,102 @@
+/*
+  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_replace_lithosphere_viscosity_h
+#define _aspect_material_model_replace_lithosphere_viscosity_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+#include <aspect/initial_temperature/lithosphere_mask.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that applies a given constant viscosity in the lithosphere.
+     * Viscosity below this is taken from a ''base model'' chosen from any of the
+     * other available material models. The 'replace lithosphere viscosity'
+     * material model allows the user to specify the depth of the lithosphere-asthenosphere
+     * boundary either as one value or as a file. All other properties are derived
+     * from the base model.
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class ReplaceLithosphereViscosity : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Initialize the base model at the beginning of the run.
+         */
+        void initialize() override;
+
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void
+        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
+                  typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        /**
+         * Method to declare parameters related to replace lithosphere viscosity model
+         */
+        static void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Method to parse parameters related to replace lithosphere viscosity model
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Method that indicates whether material is compressible. Replace lithosphere viscosity model is compressible
+         * if and only if base model is compressible.
+         */
+        bool is_compressible () const override;
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+      private:
+
+        /**
+         * This parameter gives the viscosity set within the lithosphere.
+         */
+        double lithosphere_viscosity;
+
+
+        /**
+         * Pointer to the material model used as the base model
+         */
+        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
+
+
+        InitialTemperature::LABDepth::LABDepthLookup<dim> lab_depth_lookup;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/rheology/ascii_depth_profile.h.bak b/include/aspect/material_model/rheology/ascii_depth_profile.h.bak
new file mode 100644
index 00000000000..1655724499e
--- /dev/null
+++ b/include/aspect/material_model/rheology/ascii_depth_profile.h.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2020 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_material_model_rheology_ascii_depth_profile_h
+#define _aspect_material_model_rheology_ascii_depth_profile_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/point.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+
+      /**
+       * A class that implements a prescribed viscosity with depth determined from
+       * an AsciiDataProfile input file.
+       *
+       * @ingroup Rheology
+       */
+      template <int dim>
+      class AsciiDepthProfile : public Utilities::AsciiDataProfile<dim> , public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor. Initialize variables.
+           */
+          AsciiDepthProfile ();
+
+          /**
+           * Initialization function.
+           */
+          void initialize ();
+
+          // avoid -Woverloaded-virtual:
+          using Utilities::AsciiDataProfile<dim>::initialize;
+
+          /**
+           * Return the viscosity at a given point of the domain.
+           */
+          double compute_viscosity (const double depth) const;
+
+          /**
+           * Declare the parameters for the input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler  &prm,
+                              const std::string &subsection_name = "Ascii data model");
+
+          /**
+           * Read the parameters from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm,
+                            const std::string &subsection_name = "Ascii data model");
+
+        private:
+
+          /**
+           * The column index of the viscosity in the data file.
+           */
+          unsigned int viscosity_index;
+      };
+    }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/material_model/rheology/composite_visco_plastic.h.bak b/include/aspect/material_model/rheology/composite_visco_plastic.h.bak
new file mode 100644
index 00000000000..265660e8c27
--- /dev/null
+++ b/include/aspect/material_model/rheology/composite_visco_plastic.h.bak
@@ -0,0 +1,147 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_composite_visco_plastic_h
+#define _aspect_material_model_rheology_composite_visco_plastic_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/material_model/rheology/diffusion_creep.h>
+#include <aspect/material_model/rheology/dislocation_creep.h>
+#include <aspect/material_model/rheology/peierls_creep.h>
+#include <aspect/material_model/rheology/drucker_prager.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+
+      template <int dim>
+      class CompositeViscoPlastic : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          CompositeViscoPlastic();
+
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           * If @p expected_n_phases_per_composition points to a vector of
+           * unsigned integers this is considered the number of phases
+           * for each compositional field and will be checked against the parsed
+           * parameters.
+           */
+          void
+          parse_parameters (ParameterHandler &prm,
+                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
+
+          /**
+           * Compute the viscosity based on the composite viscous creep law.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          double
+          compute_viscosity (const double pressure,
+                             const double temperature,
+                             const std::vector<double> &volume_fractions,
+                             const SymmetricTensor<2,dim> &strain_rate,
+                             std::vector<double> &partial_strain_rates,
+                             const std::vector<double> &phase_function_values = std::vector<double>(),
+                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the compositional field viscosity
+           * based on the composite viscous creep law.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          double
+          compute_composition_viscosity (const double pressure,
+                                         const double temperature,
+                                         const unsigned int composition,
+                                         const SymmetricTensor<2,dim> &strain_rate,
+                                         std::vector<double> &partial_strain_rates,
+                                         const std::vector<double> &phase_function_values = std::vector<double>(),
+                                         const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the strain rate and first stress derivative
+           * as a function of stress based on the composite viscous creep law.
+           */
+          std::pair<double, double>
+          compute_strain_rate_and_derivative (const double creep_stress,
+                                              const double pressure,
+                                              const double temperature,
+                                              const DiffusionCreepParameters diffusion_creep_parameters,
+                                              const DislocationCreepParameters dislocation_creep_parameters,
+                                              const PeierlsCreepParameters peierls_creep_parameters,
+                                              const DruckerPragerParameters drucker_prager_parameters) const;
+
+        private:
+
+          /**
+           * Whether to use different deformation mechanisms
+           */
+          bool use_diffusion_creep;
+          bool use_dislocation_creep;
+          bool use_peierls_creep;
+          bool use_drucker_prager;
+
+          /**
+           * Pointers to objects for computing deformation mechanism
+           * strain rates and effective viscosities.
+           */
+          std::unique_ptr<Rheology::DiffusionCreep<dim>> diffusion_creep;
+          std::unique_ptr<Rheology::DislocationCreep<dim>> dislocation_creep;
+          std::unique_ptr<Rheology::PeierlsCreep<dim>> peierls_creep;
+          std::unique_ptr<Rheology::DruckerPrager<dim>> drucker_prager;
+
+          DruckerPragerParameters drucker_prager_parameters;
+
+          unsigned int number_of_compositions;
+          double minimum_viscosity;
+          double maximum_viscosity;
+
+          double min_strain_rate;
+          double strain_rate_residual_threshold;
+          unsigned int stress_max_iteration_number;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/compositional_viscosity_prefactors.h.bak b/include/aspect/material_model/rheology/compositional_viscosity_prefactors.h.bak
new file mode 100644
index 00000000000..970084c4a2e
--- /dev/null
+++ b/include/aspect/material_model/rheology/compositional_viscosity_prefactors.h.bak
@@ -0,0 +1,122 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_compositional_viscosity_prefactors_h
+#define _aspect_material_model_rheology_compositional_viscosity_prefactors_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      /**
+       * A class that handles multiplication of viscosity for a given compositional
+       * field. The multiplication factors for each composition (viscosity
+       * prefactors) are also declared, parsed, and in some cases calculated in this class.
+       */
+      template <int dim>
+      class CompositionalViscosityPrefactors : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          CompositionalViscosityPrefactors();
+
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+          // The flow laws that can be
+          // currently modified.
+          enum ModifiedFlowLaws
+          {
+            diffusion,
+            dislocation
+          } modified_flow_laws;
+
+          /**
+           * Compute the viscosity.
+           */
+          double
+          compute_viscosity (const MaterialModel::MaterialModelInputs<dim> &in,
+                             const double base_viscosity,
+                             const unsigned int composition_index,
+                             const unsigned int q,
+                             const ModifiedFlowLaws &modified_flow_laws) const;
+
+        private:
+          /**
+           * The viscosity prefactors or terms used to calculate the viscosity
+           * prefactors, which are read in from the input file by the
+           * parse_parameters() function. Users can choose between different schemes.
+           * none: no viscosity change
+           * hk04_olivine_hydration: calculate the viscosity change due to hydrogen
+           * incorporation into olivine using Hirth & Kohlstaedt 2004 10.1029/138GM06.
+           * This method requires a composition called 'bound_fluid' which tracks the wt%
+           * water in the solid, which is used to compute an atomic ratio of H/Si ppm
+           * assuming 90 mol% forsterite and 10 mol% fayalite, and finally calculates
+           * a water fugacity.
+           * The prefactor for a given compositional field is multiplied with a
+           * base_viscosity value provided by the material model, which is then returned
+           * to the material model.
+           */
+          enum ViscosityPrefactorScheme
+          {
+            none,
+            hk04_olivine_hydration,
+          } viscosity_prefactor_scheme;
+
+          // Initialize variables for the water fugacity calculation, from HK04
+          std::vector<double> diffusion_water_fugacity_exponents;
+          std::vector<double> dislocation_water_fugacity_exponents;
+          std::vector<double> minimum_mass_fraction_water_for_dry_creep;
+
+          // From Hirth & Kohlstaedt 2004, equation 6
+          const double A_H2O = 2.6e-5; // 1/Pa
+          const double activation_energy_H2O = 40e3; // J/mol/K
+          const double activation_volume_H2O = 10e-6; // m^3/mol
+
+          // We calculate the molar mass of olivine using the molar mass of fayalite (0.20379 kg/mol)
+          // and the molar mass of forsterite (0.140693 kg/mol), and a mole fraction of 90% forsterite
+          // in olivine.
+          const double molar_mass_olivine = 0.1470027; // kg/mol
+          const double molar_mass_H2O = 0.01801528; // kg/mol
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/constant_viscosity.h.bak b/include/aspect/material_model/rheology/constant_viscosity.h.bak
new file mode 100644
index 00000000000..987209b35c1
--- /dev/null
+++ b/include/aspect/material_model/rheology/constant_viscosity.h.bak
@@ -0,0 +1,73 @@
+/*
+  Copyright (C) 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_constant_viscosity_h
+#define _aspect_material_model_rheology_constant_viscosity_h
+
+#include <aspect/global.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      class ConstantViscosity
+      {
+        public:
+          /**
+           * Constructor. Initializes viscosity to NaN.
+           */
+          ConstantViscosity();
+
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm,
+                              const double default_viscosity = 1e21);
+
+          /**
+           * Read the parameters from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+          /**
+           * Compute the viscosity, in this case just a constant.
+           */
+          double
+          compute_viscosity () const;
+
+        private:
+          /**
+           * The constant viscosity that defines this rheology. It
+           * is read from the input file by the parse_parameters()
+           * function.
+           */
+          double viscosity;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/constant_viscosity_prefactors.h.bak b/include/aspect/material_model/rheology/constant_viscosity_prefactors.h.bak
new file mode 100644
index 00000000000..1ecc37aad36
--- /dev/null
+++ b/include/aspect/material_model/rheology/constant_viscosity_prefactors.h.bak
@@ -0,0 +1,85 @@
+/*
+  Copyright (C) 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_constant_viscosity_prefactors_h
+#define _aspect_material_model_rheology_constant_viscosity_prefactors_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      /**
+       * A class that handles multiplication of viscosity for a given compositional
+       * field. The multiplication factors for each composition (constant viscosity
+       * prefactors) are also declared and parsed in this class.
+       */
+      template <int dim>
+      class ConstantViscosityPrefactors : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ConstantViscosityPrefactors();
+
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+          /**
+           * Compute the viscosity.
+           */
+          double
+          compute_viscosity (const double base_viscosity,
+                             const unsigned int composition_index) const;
+
+        private:
+          /**
+           * The constant viscosity prefactors, which are read in
+           * from the input file by the parse_parameters() function.
+           * The total number of prefactors will be equal to one
+           * plus the number of compositional fields. The prefactor
+           * for a given compositional field is multiplied with a
+           * base_viscosity value provided by the material model, which
+           * is then returned to the material model.
+           */
+          std::vector<double> constant_viscosity_prefactors;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/diffusion_creep.h.bak b/include/aspect/material_model/rheology/diffusion_creep.h.bak
new file mode 100644
index 00000000000..5146a371806
--- /dev/null
+++ b/include/aspect/material_model/rheology/diffusion_creep.h.bak
@@ -0,0 +1,167 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_diffusion_creep_h
+#define _aspect_material_model_rheology_diffusion_creep_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      /**
+       * Data structure for diffusion creep parameters.
+       */
+      struct DiffusionCreepParameters
+      {
+        /**
+         * The diffusion creep prefactor, activation energy, activation volume
+         * and grain size exponent.
+         */
+        double prefactor;
+        double activation_energy;
+        double activation_volume;
+        double stress_exponent;
+        double grain_size_exponent;
+
+        /**
+         * Constructor. Initializes all values to NaN.
+         */
+        DiffusionCreepParameters();
+      };
+
+      template <int dim>
+      class DiffusionCreep : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          DiffusionCreep();
+
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           * If @p expected_n_phases_per_composition points to a vector of
+           * unsigned integers this is considered the number of phases
+           * for each compositional field and will be checked against the parsed
+           * parameters.
+           */
+          void
+          parse_parameters (ParameterHandler &prm,
+                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
+
+
+          /**
+           * Compute the creep parameters for the diffusion creep law.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          const DiffusionCreepParameters
+          compute_creep_parameters (const unsigned int composition,
+                                    const std::vector<double> &phase_function_values = std::vector<double>(),
+                                    const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the viscosity based on the diffusion creep law.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          double
+          compute_viscosity (const double pressure,
+                             const double temperature,
+                             const unsigned int composition,
+                             const std::vector<double> &phase_function_values = std::vector<double>(),
+                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the strain rate and first stress derivative as a function
+           * of stress based on the diffusion creep law.
+           */
+          std::pair<double, double>
+          compute_strain_rate_and_derivative (const double stress,
+                                              const double pressure,
+                                              const double temperature,
+                                              const DiffusionCreepParameters creep_parameters) const;
+
+          /**
+           * Compute the logarithm of strain rate and first derivative with respect to
+           * the logarithm of the stress based on the diffusion creep law.
+           */
+          std::pair<double, double>
+          compute_log_strain_rate_and_derivative (const double log_stress,
+                                                  const double pressure,
+                                                  const double temperature,
+                                                  const DiffusionCreepParameters creep_parameters) const;
+
+        private:
+
+          /**
+           * List of diffusion creep prefactors A.
+           */
+          std::vector<double> prefactors_diffusion;
+
+          /**
+           * List of diffusion creep stress exponents n (usually = 1).
+           */
+          std::vector<double> stress_exponents_diffusion;
+
+          /**
+           * List of diffusion creep grain size exponents m.
+           */
+          std::vector<double> grain_size_exponents_diffusion;
+
+          /**
+           * List of diffusion creep activation energies E.
+           */
+          std::vector<double> activation_energies_diffusion;
+
+          /**
+           * List of diffusion creep activation volumes V.
+           */
+          std::vector<double> activation_volumes_diffusion;
+
+          /**
+           * Diffusion creep grain size d.
+           */
+          double grain_size;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/diffusion_dislocation.h.bak b/include/aspect/material_model/rheology/diffusion_dislocation.h.bak
new file mode 100644
index 00000000000..49315dda652
--- /dev/null
+++ b/include/aspect/material_model/rheology/diffusion_dislocation.h.bak
@@ -0,0 +1,139 @@
+/*
+  Copyright (C) 2011 - 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_diffusion_dislocation_h
+#define _aspect_material_model_rheology_diffusion_dislocation_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/rheology/diffusion_creep.h>
+#include <aspect/material_model/rheology/dislocation_creep.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      /**
+       * A viscous rheology including diffusion and dislocation creep.
+       *
+       * The effective viscosity is defined as the harmonic mean of the two
+       * effective viscosity functions describing diffusion and dislocation creep:
+       * @f[
+       *   v_\text{eff} = \left( \frac{1}{v_\text{eff}^\text{diff}} + \frac{1}{v_\text{eff}^\text{dis}} \right)^{-1}
+       * @f]
+       * where
+       * @f[
+       *   v_\text{eff}^\text{diff} = A_\text{diff}^{-1} \exp\left(\frac{E_\text{diff} + PV_\text{diff}}{RT}\right),
+       * @f]
+       * and
+       * @f[
+       *   v_\text{eff}^\text{dis} =  A_\text{dis}^{\frac{-1}{n_\text{dis}}} \dot{\varepsilon}^{\frac{1-n}{n}}
+       *                        \exp\left(\frac{E_\text{diff} + PV_\text{diff}}{n_\text{dis}RT}\right)
+       * @f]
+       * where $\dot{\varepsilon}$ is the second invariant of the strain rate tensor,
+       * $A_i$ are prefactors where $i$ corresponds to diffusion or dislocation creep,
+       * $E_i$ are the activation energies, $V_i$ are the activation volumes,
+       * $\rho_m$ is the mantle density, $R$ is the gas constant,
+       * $T$ is temperature, and $P$ is pressure.
+       *
+       * Rheological parameters can be defined per-compositional field.
+       * For each material parameter the user supplies a comma delimited list of
+       * length N+1, where N is the number of compositional fields.  The
+       * additional field corresponds to the value for background mantle.  They
+       * should be ordered ``background, composition1, composition2...''
+       *
+       * The individual output viscosities for each compositional field are
+       * averaged. The user can choose from a range of options for this
+       * viscosity averaging. If only one value is given for any of these parameters,
+       * all compositions are assigned the same value.
+       * The first value in the list is the value assigned to "background mantle"
+       * (regions where the sum of the compositional fields is < 1.0).
+       */
+      template <int dim>
+      class DiffusionDislocation : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          DiffusionDislocation();
+
+          /**
+           * Calculate the viscosities for each compositional field
+           * assuming that each composition experiences the same strain rate.
+           */
+          std::vector<double>
+          calculate_isostrain_viscosities ( const double pressure,
+                                            const double temperature,
+                                            const SymmetricTensor<2,dim> &strain_rate) const;
+
+          /**
+           * Compute the viscosity based on the composite viscous creep law,
+           * averaging over all compositional fields according to their
+           * volume fractions.
+           */
+          double
+          compute_viscosity (const double pressure,
+                             const double temperature,
+                             const std::vector<double> &volume_fractions,
+                             const SymmetricTensor<2,dim> &strain_rate) const;
+
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          void
+          parse_parameters (ParameterHandler &prm);
+
+        private:
+          /**
+           * Objects for computing viscous creep viscosities.
+           */
+          Rheology::DiffusionCreep<dim> diffusion_creep;
+          Rheology::DislocationCreep<dim> dislocation_creep;
+
+          /**
+           * Defining a minimum strain rate stabilizes the viscosity calculation,
+           * which involves a division by the strain rate. Units: 1/s.
+           */
+          double min_strain_rate;
+          double minimum_viscosity;
+          double maximum_viscosity;
+
+          double log_strain_rate_residual_threshold;
+          unsigned int stress_max_iteration_number;
+
+          double grain_size;
+          unsigned int n_chemical_composition_fields;
+
+          MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
+
+      };
+
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/dislocation_creep.h.bak b/include/aspect/material_model/rheology/dislocation_creep.h.bak
new file mode 100644
index 00000000000..a655183450a
--- /dev/null
+++ b/include/aspect/material_model/rheology/dislocation_creep.h.bak
@@ -0,0 +1,155 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_dislocation_creep_h
+#define _aspect_material_model_rheology_dislocation_creep_h
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      /**
+       * Data structure for dislocation creep parameters.
+       */
+      struct DislocationCreepParameters
+      {
+        /**
+         * The dislocation creep prefactor, activation energy, activation volume
+         * and stress exponent.
+         */
+        double prefactor;
+        double activation_energy;
+        double activation_volume;
+        double stress_exponent;
+
+        /**
+         * Constructor. Initializes all values to NaN.
+         */
+        DislocationCreepParameters();
+      };
+
+      template <int dim>
+      class DislocationCreep : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          DislocationCreep();
+
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           * If @p expected_n_phases_per_composition points to a vector of
+           * unsigned integers this is considered the number of phases
+           * for each compositional field and will be checked against the parsed
+           * parameters.
+           */
+          void
+          parse_parameters (ParameterHandler &prm,
+                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
+
+          /**
+           * Compute the creep parameters for the dislocation creep law.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          const DislocationCreepParameters
+          compute_creep_parameters (const unsigned int composition,
+                                    const std::vector<double> &phase_function_values = std::vector<double>(),
+                                    const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the viscosity based on the dislocation creep law.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          double
+          compute_viscosity (const double strain_rate,
+                             const double pressure,
+                             const double temperature,
+                             const unsigned int composition,
+                             const std::vector<double> &phase_function_values = std::vector<double>(),
+                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the strain rate and first stress derivative
+           * as a function of stress based on the dislocation creep law.
+           */
+          std::pair<double, double>
+          compute_strain_rate_and_derivative (const double stress,
+                                              const double pressure,
+                                              const double temperature,
+                                              const DislocationCreepParameters creep_parameters) const;
+
+          /**
+           * Compute the logarithm of strain rate and first derivative with respect to
+           * the logarithm of the stress based on the dislocation creep law.
+           */
+          std::pair<double, double>
+          compute_log_strain_rate_and_derivative (const double log_stress,
+                                                  const double pressure,
+                                                  const double temperature,
+                                                  const DislocationCreepParameters creep_parameters) const;
+
+        private:
+
+          /**
+           * List of dislocation creep prefactors A.
+           */
+          std::vector<double> prefactors_dislocation;
+
+          /**
+           * List of dislocation creep stress exponents n.
+           */
+          std::vector<double> stress_exponents_dislocation;
+
+          /**
+           * List of dislocation creep activation energies E.
+           */
+          std::vector<double> activation_energies_dislocation;
+
+          /**
+           * List of dislocation creep activation volumes V.
+           */
+          std::vector<double> activation_volumes_dislocation;
+
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/drucker_prager.h.bak b/include/aspect/material_model/rheology/drucker_prager.h.bak
new file mode 100644
index 00000000000..d787f070357
--- /dev/null
+++ b/include/aspect/material_model/rheology/drucker_prager.h.bak
@@ -0,0 +1,161 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_drucker_prager_h
+#define _aspect_material_model_rheology_drucker_prager_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+
+#include <aspect/material_model/utilities.h>
+#include <aspect/simulator_access.h>
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      /**
+       * A data structure with all input file parameters relevant to
+       * Drucker-Prager plasticity.
+       */
+      struct DruckerPragerParameters
+      {
+        /**
+         * Internal friction angle (phi) for the current composition and phase
+         */
+        double angle_internal_friction;
+
+        /**
+         * Cohesion for the current composition and phase
+         */
+        double cohesion;
+
+        /**
+         * Limit maximum yield stress from drucker prager yield criterion.
+         */
+        double max_yield_stress;
+
+        /**
+         * Constructor. Initializes all values to NaN.
+         */
+        DruckerPragerParameters();
+      };
+
+      template <int dim>
+      class DruckerPrager : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          DruckerPrager();
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           * If @p expected_n_phases_per_composition points to a vector of
+           * unsigned integers, this is considered the number of phases
+           * for each compositional field (plus possibly a background field)
+           * and this number will be checked against the parsed parameters.
+           *
+           * @param [in] prm The ParameterHandler to read from.
+           * @param expected_n_phases_per_composition Optional list of number of phases.
+           */
+          void
+          parse_parameters (ParameterHandler &prm,
+                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
+
+          /**
+           * Compute the parameters for the Drucker Prager plasticity.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          const DruckerPragerParameters
+          compute_drucker_prager_parameters (const unsigned int composition,
+                                             const std::vector<double> &phase_function_values = std::vector<double>(),
+                                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the plastic yield stress based on the Drucker Prager yield criterion.
+           */
+          double
+          compute_yield_stress (const double cohesion,
+                                const double angle_internal_friction,
+                                const double pressure,
+                                const double max_yield_stress) const;
+
+          /**
+           * Compute the apparent viscosity using the yield stress and effective strain rate.
+           * If the non_yielding_viscosity is not infinite
+           * (i.e., if there are other rheological elements accommodating strain), the returned
+           * value is the effective composite viscosity, not the pure "plastic" viscosity.
+           */
+          double
+          compute_viscosity (const double cohesion,
+                             const double angle_internal_friction,
+                             const double pressure,
+                             const double effective_strain_rate,
+                             const double max_yield_stress,
+                             const double non_yielding_viscosity = std::numeric_limits<double>::infinity()) const;
+
+          /**
+           * Compute the strain rate and first stress derivative
+           * as a function of stress based on the damped Drucker-Prager flow law.
+           */
+          std::pair<double, double>
+          compute_strain_rate_and_derivative (const double stress,
+                                              const double pressure,
+                                              const DruckerPragerParameters p) const;
+
+          /**
+           * Compute the derivative of the plastic viscosity with respect to pressure.
+           */
+          double
+          compute_derivative (const double angle_internal_friction,
+                              const double effective_strain_rate) const;
+
+        private:
+
+          std::vector<double> angles_internal_friction;
+          std::vector<double> cohesions;
+          double max_yield_stress;
+
+          /**
+           * Whether to add a plastic damper in the computation
+           * of the drucker prager plastic viscosity.
+           */
+          bool use_plastic_damper;
+
+          /**
+           * Viscosity of a damper used to stabilize plasticity
+           */
+          double damper_viscosity;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/elasticity.h.bak b/include/aspect/material_model/rheology/elasticity.h.bak
new file mode 100644
index 00000000000..f3f3698c8f6
--- /dev/null
+++ b/include/aspect/material_model/rheology/elasticity.h.bak
@@ -0,0 +1,197 @@
+/*
+  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_elasticity_h
+#define _aspect_material_model_rheology_elasticity_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/matrix_free/fe_point_evaluation.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * Additional output fields for the elastic shear modulus to be added to
+     * the MaterialModel::MaterialModelOutputs structure and filled in the
+     * MaterialModel::Interface::evaluate() function.
+     */
+    template <int dim>
+    class ElasticAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        explicit ElasticAdditionalOutputs(const unsigned int n_points);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * Elastic shear moduli at the evaluation points passed to
+         * the instance of MaterialModel::Interface::evaluate() that fills
+         * the current object.
+         */
+        std::vector<double> elastic_shear_moduli;
+    };
+
+
+
+    namespace Rheology
+    {
+      template <int dim>
+      class Elasticity : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+          /**
+           * Create the additional material model outputs object that contains the
+           * elastic shear moduli.
+           */
+          void
+          create_elastic_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+          /**
+           * Given the stress of the previous time step in the material model inputs @p in,
+           * the elastic shear moduli @p average_elastic_shear_moduli a each point,
+           * and the (viscous) viscosities given in the material model outputs object @p out,
+           * fill an additional material model outputs objects with the elastic force terms.
+           */
+          void
+          fill_elastic_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
+                                const std::vector<double> &average_elastic_shear_moduli,
+                                MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+          /**
+           * Given the stress of the previous time step in the material model inputs @p in,
+           * the elastic shear moduli @p average_elastic_shear_moduli a each point,
+           * and the (viscous) viscosities given in the material model outputs object @p out,
+           * compute an update to the elastic stresses and use it to fill the reaction terms
+           * material model output property.
+           */
+          void
+          fill_reaction_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
+                                 const std::vector<double> &average_elastic_shear_moduli,
+                                 MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+          /**
+           * Return the values of the elastic shear moduli for each composition used in the
+           * rheology model.
+           */
+          const std::vector<double> &
+          get_elastic_shear_moduli () const;
+
+          /**
+           * Calculates the effective elastic viscosity (this is the equivalent viscosity of
+           * a material which was unstressed at the end of the previous timestep).
+           */
+          double
+          calculate_elastic_viscosity (const double shear_modulus) const;
+
+          /**
+           * Given the (viscous or visco-plastic) viscosity and the shear modulus, compute the viscoelastic
+           * viscosity (eqn 28 in Moresi et al., 2003, J. Comp. Phys.).
+           */
+          double
+          calculate_viscoelastic_viscosity (const double viscosity,
+                                            const double shear_modulus) const;
+
+          /**
+           * Calculate the effective deviatoric strain rate tensor,
+           * which equals the true deviatoric strain rate plus
+           * a fictional strain rate which would arise from stored elastic stresses.
+           * In ASPECT, this additional strain rate is
+           * supported by a fictional body force.
+           * This formulation allows the use of an isotropic effective viscosity
+           * by ensuring that the resulting strain rate tensor is equal to the
+           * total current stress tensor multiplied by a scalar.
+           */
+          SymmetricTensor<2,dim>
+          calculate_viscoelastic_strain_rate (const SymmetricTensor<2,dim> &strain_rate,
+                                              const SymmetricTensor<2,dim> &stored_stress,
+                                              const double shear_modulus) const;
+
+          /**
+           * Compute the elastic time step.
+           */
+          double
+          elastic_timestep () const;
+
+        private:
+          /**
+           * Viscosity of a damper used to stabilize elasticity.
+           * A value of 0 Pas is equivalent to not using a damper.
+           */
+          double elastic_damper_viscosity;
+
+          /**
+           * Vector for field elastic shear moduli, read from parameter file.
+           */
+          std::vector<double> elastic_shear_moduli;
+
+          /**
+           * Bool indicating whether to use a fixed material time scale in the
+           * viscoelastic rheology for all time steps (if true) or to use the
+           * actual (variable) advection time step of the model (if false). Read
+           * from parameter file.
+           */
+          bool use_fixed_elastic_time_step;
+
+          /**
+           * Double for fixed elastic time step value, read from parameter file
+           */
+          double fixed_elastic_time_step;
+
+          /**
+           * A stabilization factor for the elastic stresses that influences how
+           * fast elastic stresses adjust to deformation. 1.0 is equivalent to no
+           * stabilization, and infinity is equivalent to not applying elastic
+           * stresses at all. The factor is multiplied with the computational
+           * time step to create a time scale.
+           */
+          double stabilization_time_scale_factor;
+
+          /**
+           * We cache the evaluator that is necessary to evaluate the old velocity
+           * gradients. They are required to compute the elastic stresses, but
+           * are not provided by the material model.
+           * By caching the evaluator, we can avoid recreating it every time we
+           * need it.
+           */
+          mutable std::unique_ptr<FEPointEvaluation<dim, dim>> evaluator;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/frank_kamenetskii.h.bak b/include/aspect/material_model/rheology/frank_kamenetskii.h.bak
new file mode 100644
index 00000000000..a63e3c9d53b
--- /dev/null
+++ b/include/aspect/material_model/rheology/frank_kamenetskii.h.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_frank_kamenetskii_h
+#define _aspect_material_model_rheology_frank_kamenetskii_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      /**
+       * A class that computes a Frank-Kamenetskii viscosity approximation
+       * of the form:
+       * viscosity = A * exp(E * 0.5 * (1.0-(T/ref_T)) + F * (P-ref_P)/(rho*g*h))
+       * A: prefactor of viscosity, E: adjusted viscosity ratio,
+       * ref_T: reference temperature, T: temperature. F: prefactor of pressure,
+       * ref_P: reference pressure, rho: density, g: gravity, h, model depth
+       *
+       * Refer to Noack and Breuer, 2013, GJI. doi: 10.1093/gji/ggt248 Eq. 2.10 for reference.
+       */
+
+      template <int dim>
+      class FrankKamenetskii : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          FrankKamenetskii();
+
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+          /**
+           * Compute the viscosity based on the Frank-Kamenetskii approximation.
+           */
+          double
+          compute_viscosity (const double temperature,
+                             const unsigned int composition,
+                             const double pressure = std::numeric_limits<double>::infinity(),
+                             const double density = std::numeric_limits<double>::infinity(),
+                             const double gravity = std::numeric_limits<double>::infinity()) const;
+
+        private:
+          /**
+           * List of Frank-Kamenetskii viscosity ratios (E).
+           */
+          std::vector<double> viscosity_ratios_frank_kamenetskii;
+
+          /**
+           * List of Frank-Kamenetskii prefactors (A).
+           */
+          std::vector<double> prefactors_frank_kamenetskii;
+
+          /**
+           * List of Frank-Kamenetskii pressure prefactors (F).
+           */
+          std::vector<double> pressure_prefactors_frank_kamenetskii;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/friction_models.h.bak b/include/aspect/material_model/rheology/friction_models.h.bak
new file mode 100644
index 00000000000..fb23ef023a4
--- /dev/null
+++ b/include/aspect/material_model/rheology/friction_models.h.bak
@@ -0,0 +1,135 @@
+/*
+  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_friction_models_h
+#define _aspect_material_model_rheology_friction_models_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <deal.II/base/parsed_function.h>
+#include <aspect/utilities.h>
+
+#include <aspect/material_model/rheology/drucker_prager.h>
+#include <deal.II/fe/component_mask.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+    namespace Rheology
+    {
+      /**
+       * Enumeration for selecting which type of friction dependence to use.
+       *
+       * For the type 'static friction', the user-supplied internal angle of friction is used.
+       *
+       * For the type 'dynamic friction', the friction angle is rate dependent following
+       * Equation 13 from \\cite{van_dinther_seismic_2013}.
+       */
+      enum FrictionMechanism
+      {
+        static_friction,
+        dynamic_friction,
+        function
+      };
+
+      template <int dim>
+      class FrictionModels : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+          /**
+           * A function that computes the new friction angle when it is not independent.
+           * Given a volume fraction with the index and a vector of all compositional
+           * fields, it returns the newly calculated friction angle.
+           */
+          double
+          compute_friction_angle(const double current_edot_ii,
+                                 const unsigned int volume_fraction_index,
+                                 const double static_friction_angle,
+                                 const Point<dim> &position) const;
+
+          /**
+           * A function that returns the selected type of friction dependence.
+           */
+          FrictionMechanism
+          get_friction_mechanism () const;
+
+        private:
+          /**
+           * Select the mechanism to be used for the friction dependence.
+           * Possible options: static friction | dynamic friction | function
+           */
+          FrictionMechanism friction_mechanism;
+
+          /**
+           * Dynamic friction input parameters
+           */
+
+          /**
+           * Dynamic angles of internal friction that are used at high strain rates.
+           */
+          std::vector<double> dynamic_angles_of_internal_friction;
+
+          /**
+           * The characteristic strain rate value at which the angle of friction is taken as
+           * the mean of the dynamic and the static angle of friction. When the effective
+           * strain rate in a cell is very high the dynamic angle of friction is taken, when
+           * it is very low the static angle of internal friction is chosen.
+           */
+          double dynamic_characteristic_strain_rate;
+
+          /**
+           * An exponential factor in the equation for the calculation of the friction angle
+           * to make the transition between static and dynamic friction angle more smooth or
+           * more step-like.
+           */
+          double dynamic_friction_smoothness_exponent;
+
+          /**
+           * Parsed functions that specify the friction angle which must be
+           * given in the input file using the function method.
+           */
+          std::unique_ptr<Functions::ParsedFunction<dim>> friction_function;
+
+          /**
+           * The coordinate representation to evaluate the function for the friction angle.
+           * Possible choices are depth, cartesian and spherical.
+           */
+          Utilities::Coordinates::CoordinateSystem coordinate_system_friction_function;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/peierls_creep.h.bak b/include/aspect/material_model/rheology/peierls_creep.h.bak
new file mode 100644
index 00000000000..a63f863ebaf
--- /dev/null
+++ b/include/aspect/material_model/rheology/peierls_creep.h.bak
@@ -0,0 +1,275 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_peierls_creep_h
+#define _aspect_material_model_rheology_peierls_creep_h
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      /**
+       * Data structure for Peierls creep parameters.
+       */
+      struct PeierlsCreepParameters
+      {
+        /**
+         * The Peierls creep prefactor, stress exponent, activation energy,
+         * activation volume, Peierls stress, glide parameters p and q
+         * and fitting parameter,
+         */
+        double prefactor;
+        double stress_exponent;
+        double activation_energy;
+        double activation_volume;
+        double peierls_stress;
+        double glide_parameter_p;
+        double glide_parameter_q;
+        double fitting_parameter;
+        double stress_cutoff;
+
+        /**
+         * Constructor. Initializes all values to NaN.
+         */
+        PeierlsCreepParameters();
+      };
+
+      /**
+       * Peierls creep is a low temperature, high stress viscous deformation mechanism.
+       * Crystal deformation occurs through dislocation glide, which requires high stresses.
+       * It is considered an important deformation mechanism in the lithosphere and subducting
+       * slabs (Kumamoto et al., 2017, Science Advances). The approximate form of the Peierls
+       * flow law used here is based on a derivation from Kameyama et al., 1999, Earth and
+       * Planetary Science Letters.
+       */
+      template <int dim>
+      class PeierlsCreep : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          PeierlsCreep();
+
+          /**
+           * Compute the creep parameters for the Peierls creep law.
+           */
+          const PeierlsCreepParameters
+          compute_creep_parameters (const unsigned int composition,
+                                    const std::vector<double> &phase_function_values = std::vector<double>(),
+                                    const std::vector<unsigned int> &n_phases_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters from the parameter file.
+           * If @p expected_n_phases_per_composition points to a vector of
+           * unsigned integers this is considered the number of phases
+           * for each compositional field and will be checked against the parsed
+           * parameters.
+           */
+          void
+          parse_parameters (ParameterHandler &prm,
+                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
+
+          /**
+           * Compute the viscosity based on the approximate Peierls creep flow law.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          double
+          compute_approximate_viscosity (const double strain_rate,
+                                         const double pressure,
+                                         const double temperature,
+                                         const unsigned int composition,
+                                         const std::vector<double> &phase_function_values = std::vector<double>(),
+                                         const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the viscosity based on the exact Peierls creep flow law.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          double
+          compute_exact_viscosity (const double strain_rate,
+                                   const double pressure,
+                                   const double temperature,
+                                   const unsigned int composition,
+                                   const std::vector<double> &phase_function_values = std::vector<double>(),
+                                   const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the viscosity based on the selected Peierls creep flow law.
+           * This function uses either the compute_approximate_viscosity
+           * or the compute_exact_viscosity function.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          double
+          compute_viscosity (const double strain_rate,
+                             const double pressure,
+                             const double temperature,
+                             const unsigned int composition,
+                             const std::vector<double> &phase_function_values = std::vector<double>(),
+                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
+
+          /**
+           * Compute the strain rate and first stress derivative
+           * as a function of stress based on the approximate Peierls creep law.
+           */
+          std::pair<double, double>
+          compute_approximate_strain_rate_and_derivative (const double stress,
+                                                          const double pressure,
+                                                          const double temperature,
+                                                          const PeierlsCreepParameters creep_parameters) const;
+
+          /**
+           * Compute the strain rate and first stress derivative
+           * as a function of stress based on the exact Peierls creep law.
+           */
+          std::pair<double, double>
+          compute_exact_strain_rate_and_derivative (const double stress,
+                                                    const double pressure,
+                                                    const double temperature,
+                                                    const PeierlsCreepParameters creep_parameters) const;
+
+          /**
+           * Compute the natural logarithm of the strain rate norm and its first
+           * derivative with respect to the natural logarithm of the stress norm
+           * based on the exact Peierls creep law.
+           */
+          std::pair<double, double>
+          compute_exact_log_strain_rate_and_derivative (const double log_stress,
+                                                        const double pressure,
+                                                        const double temperature,
+                                                        const PeierlsCreepParameters creep_parameters) const;
+
+          /**
+           * Compute the strain rate and first stress derivative
+           * as a function of stress based on the selected Peierls creep law.
+           * This function uses either the
+           * compute_approximate_strain_rate_and_derivative
+           * or the compute_exact_strain_rate_and_derivative function.
+           */
+          std::pair<double, double>
+          compute_strain_rate_and_derivative (const double stress,
+                                              const double pressure,
+                                              const double temperature,
+                                              const PeierlsCreepParameters creep_parameters) const;
+
+        private:
+          /**
+           * Enumeration for selecting which type of Peierls creep flow law to use.
+           * The options are currently "exact" (which requires a Newton-Raphson iteration
+           * in compute_viscosity) and "viscosity_approximation", which
+           * uses a simplified expression where the strain rate has a power law dependence
+           * on the stress (so that the equation can be directly inverted for viscosity).
+           * This approximation requires specifying one fitting parameter (gamma) to
+           * obtain the best fit in the expected stress range for a given problem
+           * (gamma = stress / peierls_stress). The derivation for this approximation
+           * (derived by Magali Billen) can be found at:
+           * https://ucdavis.app.box.com/s/cl5mwhkjeabol4otrdukfcdwfvg9me4w/file/705438695737.
+           */
+          enum PeierlsCreepScheme
+          {
+            viscosity_approximation,
+            exact
+          } peierls_creep_flow_law;
+
+          /**
+           * List of Peierls creep prefactors (A).
+           */
+          std::vector<double> prefactors;
+
+          /**
+           * List of Peierls creep stress exponents (n).
+           */
+          std::vector<double> stress_exponents;
+
+          /**
+           * List of Peierls creep activation energies (E).
+           */
+          std::vector<double> activation_energies;
+
+          /**
+           * List of Peierls creep activation volumes (V).
+           */
+          std::vector<double> activation_volumes;
+
+          /**
+           * List of Peierls stresses (sigma_p).
+           */
+          std::vector<double> peierls_stresses;
+
+          /**
+           * List of Peierls fitting parameters (gamma).
+           */
+          std::vector<double> fitting_parameters;
+
+          /**
+           * List of the first Peierls parameter related
+           * to dislocation glide (p).
+           */
+          std::vector<double> glide_parameters_p;
+
+          /**
+           * List of the second Peierls parameter related
+           * to dislocation glide (q).
+           */
+          std::vector<double> glide_parameters_q;
+
+          std::vector<double> stress_cutoffs;
+
+          /**
+           * A parameter determines whether a strict cutoff
+           * on the stress is applied to the Peierls creep
+          */
+          bool apply_strict_cutoff;
+
+          /**
+           * Parameters governing the iteration for the exact
+           * Peierls viscosity.
+           */
+          double strain_rate_residual_threshold;
+          unsigned int stress_max_iteration_number;
+
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/strain_dependent.h.bak b/include/aspect/material_model/rheology/strain_dependent.h.bak
new file mode 100644
index 00000000000..3e23c658077
--- /dev/null
+++ b/include/aspect/material_model/rheology/strain_dependent.h.bak
@@ -0,0 +1,274 @@
+/*
+  Copyright (C) 2019 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_strain_dependent_h
+#define _aspect_material_model_rheology_strain_dependent_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+#include<deal.II/fe/component_mask.h>
+#include <deal.II/matrix_free/fe_point_evaluation.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace Rheology
+    {
+      /**
+       * Enumeration for selecting which type of weakening mechanism to use.
+       * For none, no strain weakening occurs.
+       * Otherwise, the material can be weakened based on the second
+       * invariant of the full finite strain tensor, the total accumulated
+       * strain, or the plastic strain and viscous strain can be tracked
+       * separately and used only for the corresponding (plastic or viscous)
+       * part of the viscosity computation.
+       */
+      enum WeakeningMechanism
+      {
+        none,
+        finite_strain_tensor,
+        total_strain,
+        plastic_weakening_with_plastic_strain_only,
+        plastic_weakening_with_total_strain_only,
+        plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain,
+        viscous_weakening_with_viscous_strain_only
+      };
+
+      /**
+       * Enumeration for selecting which type of healing mechanism to use.
+       * For the case no healing, no strain healing occurs.
+       * Otherwise, the strain is healed (reduced) as a function of temperature,
+       * a user defined healing time scale and additional parameters.
+       * Future models could consider strain healing formulations that are a function
+       * of time, deformation rate, or other parameters.
+       */
+      enum HealingMechanism
+      {
+        no_healing,
+        temperature_dependent
+      };
+
+      template <int dim>
+      class StrainDependent : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+          /**
+           * A function that computes by how much the rheologic parameters change
+           * if strain weakening is applied. Given a vector @p composition of all
+           * fields, it returns reduction factors for the cohesion, friction angle
+           * and the prefactor of the viscous flow law(s) for the compositional
+           * field with index @p j. The reason all fields are passed is that
+           * the weakening factors can depend on the values of fields that track
+           * different measures of previously applied strain.
+           */
+          std::array<double, 3>
+          compute_strain_weakening_factors(const std::vector<double> &composition,
+                                           const unsigned int j) const;
+
+          /**
+           * @deprecated: Deprecated version of the function of the same
+           * name described above.
+          */
+          DEAL_II_DEPRECATED
+          std::array<double, 3>
+          compute_strain_weakening_factors(const unsigned int j,
+                                           const std::vector<double> &composition) const;
+
+          /**
+           * A function that alters the viscous weakening factor based on the
+           * temperature field.
+           */
+          std::array<double, 3>
+          apply_temperature_dependence_to_strain_weakening_factors(const std::array<double, 3> &weakening_factors,
+                                                                   const double temperature,
+                                                                   const unsigned int j) const;
+
+          /**
+           * A function that computes the strain healing (reduction in accumulated strain)
+           */
+          double
+          calculate_strain_healing (const MaterialModel::MaterialModelInputs<dim> &in,
+                                    const unsigned int j) const;
+
+          /**
+           * A function that computes by how much the cohesion and internal friction
+           * angle for a given compositional field are weakened under the influence
+           * of a given strain.
+           */
+          std::pair<double, double>
+          calculate_plastic_weakening (const double strain_ii,
+                                       const unsigned int j) const;
+
+          /**
+           * A function that computes by how much the diffusion and dislocation
+           * prefactors for a given compositional field are weakened under the
+           * influence of a given strain.
+           */
+          double
+          calculate_viscous_weakening (const double strain_ii,
+                                       const unsigned int j) const;
+
+          /**
+           * Whether to use the temperature-activated viscous strain weakening.
+          */
+          bool use_temperature_activated_strain_softening;
+
+          /**
+           * A function that fills the reaction terms for the finite strain tensor in
+           * MaterialModelOutputs object that is handed over. It assumes the first
+           * component of the finite strain tensor is named 's11' and all other
+           * components follow this compositional field.
+           */
+          void compute_finite_strain_reaction_terms (const MaterialModel::MaterialModelInputs<dim> &in,
+                                                     MaterialModel::MaterialModelOutputs<dim> &out) const;
+          /**
+           * A function that fills the reaction terms for the finite strain invariant(s) in
+           * MaterialModelOutputs object that is handed over.
+           */
+          void fill_reaction_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
+                                      const int i,
+                                      const double min_strain_rate,
+                                      const bool plastic_yielding,
+                                      MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+          /**
+           * A function that returns a ComponentMask, which indicates that components
+           * associated with strain should be excluded during the volume fraction computation.
+           */
+          ComponentMask get_strain_composition_mask() const;
+
+          /**
+           * A function that returns the selected type of strain weakening mechanism.
+           */
+          WeakeningMechanism
+          get_weakening_mechanism () const;
+
+          /**
+           * A function that returns the selected type of strain healing mechanism.
+           */
+          HealingMechanism
+          get_healing_mechanism () const;
+
+        private:
+
+          WeakeningMechanism weakening_mechanism;
+
+          HealingMechanism healing_mechanism;
+
+          /**
+           * The start of the strain interval (plastic or total strain)
+           * within which cohesion and angle of friction should be weakened.
+           */
+          std::vector<double> start_plastic_strain_weakening_intervals;
+
+          /**
+           * The end of the strain interval (plastic or total strain)
+           * within which cohesion and angle of friction should be weakened.
+           */
+          std::vector<double> end_plastic_strain_weakening_intervals;
+
+          /**
+           * The factor specifying the amount of weakening of the
+           * cohesion over the prescribed strain interval (plastic or total strain).
+           */
+          std::vector<double> cohesion_strain_weakening_factors;
+
+          /**
+           * The factor specifying the amount of weakening of the
+           * internal friction angles over the prescribed strain interval
+           * (plastic or total strain).
+           */
+          std::vector<double> friction_strain_weakening_factors;
+
+          /**
+           * The start of the strain interval (viscous or total strain)
+           * within which cohesion and angle of friction should be weakened.
+           */
+          std::vector<double> start_viscous_strain_weakening_intervals;
+
+          /**
+           * The end of the strain interval (viscous or total strain)
+           * within which cohesion and angle of friction should be weakened.
+           */
+          std::vector<double> end_viscous_strain_weakening_intervals;
+
+          /**
+           * The factor specifying the amount of weakening over
+           * the prescribed strain interval (viscous or total strain).
+           */
+          std::vector<double> viscous_strain_weakening_factors;
+
+          /**
+           * The four temperatures that parameterize the temperature-activated strain softening.
+           * These can be different for each compositional field.
+           * ------            -------- 1
+           *       \          /
+           *        \        /
+           *         \______/ _ _ _ _ _ viscous_weakening_factor[2]
+           *
+           * ----------------------------> T
+           *     T0  T1   T2  T3
+           */
+          std::vector<double> viscous_strain_weakening_T0;
+          std::vector<double> viscous_strain_weakening_T1;
+          std::vector<double> viscous_strain_weakening_T2;
+          std::vector<double> viscous_strain_weakening_T3;
+
+          /**
+           * The healing rate used in the temperature dependent strain healing model.
+           */
+          double strain_healing_temperature_dependent_recovery_rate;
+
+          /**
+           * A prefactor of viscosity used in the strain healing calculation.
+           */
+          double strain_healing_temperature_dependent_prefactor;
+
+          /**
+           * We cache the evaluators that are necessary to evaluate the velocity
+           * gradients and compositions.
+           * By caching the evaluator, we can avoid recreating them
+           * every time we need it.
+           */
+          mutable std::unique_ptr<FEPointEvaluation<dim, dim>> evaluator;
+          mutable std::vector<std::unique_ptr<FEPointEvaluation<1, dim>>> composition_evaluators;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/rheology/visco_plastic.h.bak b/include/aspect/material_model/rheology/visco_plastic.h.bak
new file mode 100644
index 00000000000..e4f6b171102
--- /dev/null
+++ b/include/aspect/material_model/rheology/visco_plastic.h.bak
@@ -0,0 +1,339 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_rheology_visco_plastic_h
+#define _aspect_material_model_rheology_visco_plastic_h
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/material_model/rheology/strain_dependent.h>
+#include <aspect/material_model/rheology/friction_models.h>
+#include <aspect/material_model/rheology/diffusion_creep.h>
+#include <aspect/material_model/rheology/dislocation_creep.h>
+#include <aspect/material_model/rheology/frank_kamenetskii.h>
+#include <aspect/material_model/rheology/peierls_creep.h>
+#include <aspect/material_model/rheology/constant_viscosity_prefactors.h>
+#include <aspect/material_model/rheology/compositional_viscosity_prefactors.h>
+#include <aspect/material_model/rheology/drucker_prager.h>
+#include <aspect/material_model/rheology/elasticity.h>
+#include <aspect/simulator_access.h>
+
+#include<deal.II/fe/component_mask.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * Additional output fields for the plastic parameters weakened (or hardened)
+     * by strain to be added to the MaterialModel::MaterialModelOutputs structure
+     * and filled in the MaterialModel::Interface::evaluate() function.
+     */
+    template <int dim>
+    class PlasticAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        PlasticAdditionalOutputs(const unsigned int n_points);
+
+        std::vector<double> get_nth_output(const unsigned int idx) const override;
+
+        /**
+         * Cohesions at the evaluation points passed to
+         * the instance of MaterialModel::Interface::evaluate() that fills
+         * the current object.
+         */
+        std::vector<double> cohesions;
+
+        /**
+         * Internal angles of friction at the evaluation points passed to
+         * the instance of MaterialModel::Interface::evaluate() that fills
+         * the current object.
+         */
+        std::vector<double> friction_angles;
+
+        /**
+         * The plastic yield stress.
+         */
+        std::vector<double> yield_stresses;
+
+        /**
+         * The area where the viscous stress exceeds the plastic yield stress,
+         * and viscosity is rescaled back to the yield envelope.
+         */
+        std::vector<double> yielding;
+
+    };
+
+    /**
+     * A data structure with the output of calculate_isostrain_viscosities.
+     */
+    struct IsostrainViscosities
+    {
+      /**
+       * The composition viscosity.
+       */
+      std::vector<double> composition_viscosities;
+
+      /**
+       * The composition yielding.
+       */
+      std::vector<bool> composition_yielding;
+
+      /**
+       * The current friction angle.
+       */
+      std::vector<double> current_friction_angles;
+
+      /**
+       * The current cohesion.
+       */
+      std::vector<double> current_cohesions;
+    };
+
+    namespace Rheology
+    {
+
+      template <int dim>
+      class ViscoPlastic : public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ViscoPlastic();
+
+          /**
+           * This function calculates viscosities assuming that all the compositional fields
+           * experience the same strain rate (isostrain).
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          IsostrainViscosities
+          calculate_isostrain_viscosities ( const MaterialModel::MaterialModelInputs<dim> &in,
+                                            const unsigned int i,
+                                            const std::vector<double> &volume_fractions,
+                                            const std::vector<double> &phase_function_values = std::vector<double>(),
+                                            const std::vector<unsigned int> &n_phase_transitions_per_composition =
+                                              std::vector<unsigned int>()) const;
+
+          /**
+           * A function that fills the viscosity derivatives in the
+           * MaterialModelOutputs object that is handed over, if they exist.
+           * Does nothing otherwise.
+           * If @p n_phase_transitions_per_composition points to a vector of
+           * unsigned integers this is considered the number of phase transitions
+           * for each compositional field and viscosity will be first computed on
+           * each phase and then averaged for each compositional field.
+           */
+          void compute_viscosity_derivatives(const unsigned int point_index,
+                                             const std::vector<double> &volume_fractions,
+                                             const std::vector<double> &composition_viscosities,
+                                             const MaterialModel::MaterialModelInputs<dim> &in,
+                                             MaterialModel::MaterialModelOutputs<dim> &out,
+                                             const std::vector<double> &phase_function_values = std::vector<double>(),
+                                             const std::vector<unsigned int> &n_phase_transitions_per_composition =
+                                               std::vector<unsigned int>()) const;
+
+          /**
+           * A function that returns a ComponentMask that represents all compositional
+           * fields that should be considered 'volumetric', that is representing a
+           * physical proportion of the material, e.g. volume fraction of peridotite
+           * (as opposed to non-volumetric quantities like the amount of finite-strain).
+           */
+          ComponentMask get_volumetric_composition_mask() const;
+
+          /**
+           * Declare the parameters this function takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           * If @p expected_n_phases_per_composition points to a vector of
+           * unsigned integers this is considered the number of phases
+           * for each compositional field and will be checked against the parsed
+           * parameters.
+           */
+          void
+          parse_parameters (ParameterHandler &prm,
+                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
+
+          /**
+           * Create the additional material model outputs object that contains the
+           * plastic outputs.
+           */
+          void
+          create_plastic_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+          /**
+           * A function that fills the plastic additional output in the
+           * MaterialModelOutputs object that is handed over, if it exists.
+           * Does nothing otherwise.
+           */
+          void fill_plastic_outputs(const unsigned int point_index,
+                                    const std::vector<double> &volume_fractions,
+                                    const bool plastic_yielding,
+                                    const MaterialModel::MaterialModelInputs<dim> &in,
+                                    MaterialModel::MaterialModelOutputs<dim> &out,
+                                    const IsostrainViscosities &isostrain_viscosities) const;
+
+          /**
+           * Minimum strain rate used to stabilize the strain rate dependent rheology.
+           */
+          double min_strain_rate;
+
+          /**
+           * Enumeration for selecting which viscosity averaging scheme to use.
+           */
+          MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
+
+          /**
+           * Object for computing the strain dependence of the rheology model.
+           */
+          Rheology::StrainDependent<dim> strain_rheology;
+
+          /**
+           * Object for computing the friction dependence of the rheology model.
+           */
+          Rheology::FrictionModels<dim> friction_models;
+
+          /**
+           * Object for computing viscoelastic viscosities and stresses.
+           */
+          Rheology::Elasticity<dim> elastic_rheology;
+
+
+        private:
+
+          /**
+           * Reference strain rate for the first non-linear iteration
+           * in the first time step.
+           */
+          double ref_strain_rate;
+
+          /**
+           * Minimum and maximum viscosities used to improve the
+           * stability of the rheology model.
+           * These parameters contain one value per composition and phase (potentially the same value).
+           */
+          std::vector<double> minimum_viscosity;
+          std::vector<double> maximum_viscosity;
+
+          /**
+           * Enumeration for selecting which type of viscous flow law to use.
+           * Select between diffusion, dislocation, frank_kamenetskii or composite.
+           */
+          enum ViscosityScheme
+          {
+            diffusion,
+            dislocation,
+            frank_kamenetskii,
+            composite
+          } viscous_flow_law;
+
+          /**
+           * Enumeration for selecting which type of yield mechanism to use.
+           * Select between Drucker Prager and stress limiter.
+           */
+          enum YieldScheme
+          {
+            stress_limiter,
+            drucker_prager
+          } yield_mechanism;
+
+          /**
+           * Whether to allow negative pressures to be used in the computation
+           * of plastic yield stresses and viscosities. If false, the minimum
+           * pressure in the plasticity formulation will be set to zero.
+           */
+          bool allow_negative_pressures_in_plasticity;
+
+          /**
+           * Whether to use the adiabatic pressure instead of the full pressure (default)
+           * when calculating creep (diffusion, dislocation, and peierls) viscosity.
+           * This may be helpful in models where the full pressure has an unusually
+           * large negative value arising from large negative dynamic pressure,
+           * resulting in solver convergence issue and in some cases a viscosity
+           * of zero.
+           */
+          bool use_adiabatic_pressure_in_creep;
+
+          /**
+           * List of exponents controlling the behavior of the stress limiter
+           * yielding mechanism.
+           */
+          std::vector<double> exponents_stress_limiter;
+
+          /**
+           * Temperature gradient added to temperature used in the flow law.
+           */
+          double adiabatic_temperature_gradient_for_viscosity;
+
+          /**
+           * Objects for computing viscous creep viscosities.
+           */
+          Rheology::DiffusionCreep<dim> diffusion_creep;
+          Rheology::DislocationCreep<dim> dislocation_creep;
+          std::unique_ptr<Rheology::FrankKamenetskii<dim>> frank_kamenetskii_rheology;
+
+          /**
+           * Whether to include Peierls creep in the constitutive formulation.
+           */
+          bool use_peierls_creep;
+
+          /**
+           * Object for computing Peierls creep viscosities.
+           */
+          std::unique_ptr<Rheology::PeierlsCreep<dim>> peierls_creep;
+
+          /**
+           * Object for computing the viscosity multiplied by a constant prefactor.
+           * This multiplication step is done just prior to calculating the effective
+           * viscoelastic viscosity or plastic viscosity.
+           */
+          Rheology::ConstantViscosityPrefactors<dim> constant_viscosity_prefactors;
+
+          /**
+           * Object for computing the viscosity multiplied by a given prefactor term.
+           */
+          Rheology::CompositionalViscosityPrefactors<dim> compositional_viscosity_prefactors;
+
+          /*
+           * Object for computing plastic stresses, viscosities, and additional outputs
+           */
+          Rheology::DruckerPrager<dim> drucker_prager_plasticity;
+
+          /*
+           * Input parameters for the drucker prager plasticity.
+           */
+          Rheology::DruckerPragerParameters drucker_prager_parameters;
+
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/material_model/simple.h.bak b/include/aspect/material_model/simple.h.bak
new file mode 100644
index 00000000000..e266b0d0302
--- /dev/null
+++ b/include/aspect/material_model/simple.h.bak
@@ -0,0 +1,109 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_simple_h
+#define _aspect_material_model_simple_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that consists of globally constant values for all
+     * material parameters except density and viscosity.
+     *
+     * The model is considered incompressible, following the definition
+     * described in Interface::is_compressible. This is essentially the
+     * material model used in the step-32 tutorial program.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class Simple : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+      private:
+        double reference_T;
+        double eta;
+        double composition_viscosity_prefactor;
+        double thermal_viscosity_exponent;
+        double maximum_thermal_prefactor;
+        double minimum_thermal_prefactor;
+
+        /**
+         * The thermal conductivity.
+         */
+        double k_value;
+
+        EquationOfState::LinearizedIncompressible<dim> equation_of_state;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/simple_compressible.h.bak b/include/aspect/material_model/simple_compressible.h.bak
new file mode 100644
index 00000000000..1658b3b147c
--- /dev/null
+++ b/include/aspect/material_model/simple_compressible.h.bak
@@ -0,0 +1,137 @@
+/*
+  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_simple_compressible_h
+#define _aspect_material_model_simple_compressible_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/rheology/constant_viscosity.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that consists of globally constant values for the
+     * viscosity, thermal conductivity, thermal expansivity
+     * and compressibility. The density decays linearly with the
+     * temperature and increases exponentially with pressure.
+     *
+     * The formulation for the density assumes that the compressibility
+     * provided by the user is the adiabatic compressibility ($\beta_S$).
+     * The thermal expansivity and isentropic compressibility implied by
+     * the pressure and temperature dependence are equal to the
+     * user-defined constant values only along the reference isentrope, and
+     * there is also an implicit pressure dependence to the heat capacity
+     * $C_p$ via Maxwell's relations.
+     *
+     * The model is considered incompressible or compressible, depending on
+     * the compressibility.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class SimpleCompressible : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate material properties.
+         */
+        void evaluate(const MaterialModelInputs<dim> &in,
+                      MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+      private:
+        /**
+         * The reference density
+         */
+        double reference_rho;
+
+        /**
+         * The constant thermal expansivity
+         */
+        double thermal_alpha;
+
+        /**
+         * The constant specific heat
+         */
+        double reference_specific_heat;
+
+        /**
+         * The constant compressibility.
+         */
+        double reference_compressibility;
+
+        /**
+         * The constant thermal conductivity.
+         */
+        double k_value;
+
+        /**
+         * The constant rheology model.
+         */
+        Rheology::ConstantViscosity constant_rheology;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/simpler.h.bak b/include/aspect/material_model/simpler.h.bak
new file mode 100644
index 00000000000..f2f89c8aa02
--- /dev/null
+++ b/include/aspect/material_model/simpler.h.bak
@@ -0,0 +1,86 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_simpler_h
+#define _aspect_material_model_simpler_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/rheology/constant_viscosity.h>
+#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that consists of globally constant values for all
+     * material parameters except the density, which depends linearly on the
+     * temperature. The model is considered incompressible.
+     *
+     * This material model implements what the "Simple" model was originally
+     * intended to do, before it got too complicated.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class Simpler : public Interface<dim>
+    {
+      public:
+
+        bool is_compressible () const override;
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * @}
+         */
+
+      private:
+        double k_value;
+
+        Rheology::ConstantViscosity constant_rheology;
+        EquationOfState::LinearizedIncompressible<dim> equation_of_state;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/steinberger.h.bak b/include/aspect/material_model/steinberger.h.bak
new file mode 100644
index 00000000000..f57aa7747be
--- /dev/null
+++ b/include/aspect/material_model/steinberger.h.bak
@@ -0,0 +1,335 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_steinberger_h
+#define _aspect_material_model_steinberger_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/equation_of_state/thermodynamic_table_lookup.h>
+
+#include <aspect/simulator_access.h>
+#include <deal.II/fe/component_mask.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    namespace internal
+    {
+      /**
+       * A class that reads in a text file that contains the
+       * temperature-dependency of viscosity for a set of equidistant depth
+       * layers. See
+       * the data/material-model/steinberger directory for an example data
+       * file.
+       * The class can return the value for a given depth.
+       */
+      class LateralViscosityLookup
+      {
+        public:
+          /**
+           * Read in a file.
+           */
+          LateralViscosityLookup(const std::string &filename,
+                                 const MPI_Comm comm);
+
+          /**
+           * Returns a temperature-dependency for a given depth.
+           */
+          double lateral_viscosity(double depth) const;
+
+          /**
+           * Number of depth slices of the read file.
+           */
+          int get_nslices() const;
+        private:
+          /**
+           * Stored values
+           */
+          std::vector<double> values;
+
+          /**
+           * Stored bounds an depths.
+           */
+          double min_depth;
+          double delta_depth;
+          double max_depth;
+      };
+
+      /**
+       * A class that reads in a text file that contains the
+       * viscosity for a set of equidistant depth layers. See
+       * the data/material-model/steinberger directory for an example data
+       * file.
+       * The class can return the value for a given depth.
+       */
+      class RadialViscosityLookup
+      {
+        public:
+          /**
+           * Constructor. Reads in the given file.
+           */
+          RadialViscosityLookup(const std::string &filename,
+                                const MPI_Comm comm);
+
+          /**
+           * Return the viscosity for a given depth.
+           */
+          double radial_viscosity(double depth) const;
+
+        private:
+          /**
+           * Stored data values.
+           */
+          std::vector<double> values;
+
+          /**
+           * Depth bounds for the read in values.
+           */
+          double min_depth;
+          double delta_depth;
+          double max_depth;
+      };
+    }
+
+    /**
+     * A variable viscosity material model that reads the essential values of
+     * coefficients from tables in input files.
+     *
+     * The viscosity of this model is based on the paper
+     * Steinberger & Calderwood 2006: "Models of large-scale viscous flow in the
+     * Earth's mantle with constraints from mineral physics and surface
+     * observations". The thermal conductivity is constant and the other
+     * parameters are provided via lookup tables from the software PERPLEX.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class Steinberger: public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialization function. Loads the material data and sets up
+         * pointers.
+         */
+        void
+        initialize () override;
+
+        /**
+         * Called at the beginning of each time step and allows the material
+         * model to update internal data structures.
+         */
+        void update() override;
+
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        virtual double viscosity (const double                  temperature,
+                                  const double                  pressure,
+                                  const std::vector<double>    &compositional_fields,
+                                  const SymmetricTensor<2,dim> &strain_rate,
+                                  const Point<dim>             &position) const;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void
+        evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                 MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+      private:
+        /**
+         * Compute the pressure- and temperature-dependent thermal
+         * conductivity either as a constant value, or based on the
+         * equation given in Stackhouse et al., 2015: First-principles
+         * calculations of the lattice thermal conductivity of the
+         * lower mantle, or based on the equation given in Tosi et al.,
+         * 2013: Mantle dynamics with pressure- and temperature-dependent
+         * thermal expansivity and conductivity.
+         */
+        double thermal_conductivity (const double temperature,
+                                     const double pressure,
+                                     const Point<dim> &position) const;
+
+        /**
+         * Whether the compositional fields representing mass fractions
+         * should be normalized to one when computing their fractions
+         * (if false), or whether there is an additional composition
+         * (the background field) that is not represented by a
+         * compositional field, and makes up the remaining fraction of
+         * material if the compositional fields add up to less than one
+         * at any given location (if true).
+         */
+        bool has_background_field;
+
+        /**
+         * Pointer to a composition mask, which is meant to be filled with
+         * one entry per compositional field that determines if this
+         * field is considered to represent a mass fractions (if the entry
+         * is set to true) or not (if set to false). This is needed for
+         * averaging of material properties.
+         */
+        std::unique_ptr<ComponentMask> composition_mask;
+
+        /**
+         * The thermodynamic lookup equation of state.
+         */
+        EquationOfState::ThermodynamicTableLookup<dim> equation_of_state;
+
+        /**
+         * Boolean describing whether to use the lateral average temperature
+         * for computing the viscosity, rather than the temperature
+         * on the reference adiabat.
+         */
+        bool use_lateral_average_temperature;
+
+        /**
+         * The value of the thermal conductivity if a constant thermal
+         * conductivity is used for the whole domain.
+         */
+        double thermal_conductivity_value;
+
+        /**
+         * Enumeration for selecting which type of conductivity law to use.
+         */
+        enum ConductivityFormulation
+        {
+          constant,
+          p_T_dependent
+        } conductivity_formulation;
+
+        /**
+         * Parameters for the temperature- and pressure dependence of the
+         * thermal conductivity.
+         */
+        std::vector<double> conductivity_transition_depths;
+        std::vector<double> reference_thermal_conductivities;
+        std::vector<double> conductivity_pressure_dependencies;
+        std::vector<double> conductivity_reference_temperatures;
+        std::vector<double> conductivity_exponents;
+        std::vector<double> saturation_scaling;
+        double maximum_conductivity;
+
+        /**
+         * Compositional prefactors with which to multiply the reference viscosity.
+         * Volume fractions are used to weight the prefactors according to the
+         * assigned viscosity averaging scheme.
+         */
+        std::vector<double> viscosity_prefactors;
+        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging_scheme;
+
+        /**
+         * Information about lateral temperature averages.
+         */
+        std::vector<double> average_temperature;
+        unsigned int n_lateral_slices;
+
+        /**
+         * Minimum and maximum allowed viscosity, as well as the maximum allowed
+         * viscosity variation compared to the average radial viscosity.
+         */
+        double min_eta;
+        double max_eta;
+        double max_lateral_eta_variation;
+
+        /**
+         * Information about the location of data files.
+         */
+        std::string data_directory;
+        std::string radial_viscosity_file_name;
+        std::string lateral_viscosity_file_name;
+
+        /**
+         * Pointer to an object that reads and processes data for the lateral
+         * temperature dependency of viscosity.
+         */
+        std::unique_ptr<internal::LateralViscosityLookup> lateral_viscosity_lookup;
+
+        /**
+         * Pointer to an object that reads and processes data for the radial
+         * viscosity profile.
+         */
+        std::unique_ptr<internal::RadialViscosityLookup> radial_viscosity_lookup;
+
+        /**
+         * A function that fills the prescribed additional outputs in the
+         * MaterialModelOutputs object that is handed over, if it exists,
+         * in this case, densities for the projected density approximation.
+         * Does nothing otherwise.
+         */
+        void fill_prescribed_outputs (const unsigned int i,
+                                      const std::vector<double> &volume_fractions,
+                                      const MaterialModel::MaterialModelInputs<dim> &in,
+                                      MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/utilities.h.bak b/include/aspect/material_model/utilities.h.bak
new file mode 100644
index 00000000000..c65828f7b19
--- /dev/null
+++ b/include/aspect/material_model/utilities.h.bak
@@ -0,0 +1,680 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_utilities_h
+#define _aspect_material_model_utilities_h
+
+#include <aspect/global.h>
+#include <deal.II/base/point.h>
+#include <deal.II/base/symmetric_tensor.h>
+#include <deal.II/fe/component_mask.h>
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+namespace aspect
+{
+  template <int dim> class SimulatorAccess;
+  namespace Utilities
+  {
+    using namespace dealii;
+    using namespace dealii::Utilities;
+
+    template <int dim>
+    class StructuredDataLookup;
+  }
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim> class MaterialModelOutputs;
+    template <int dim> struct EquationOfStateOutputs;
+
+    /**
+     * A namespace in which we define utility functions that
+     * might be used in many different places in the material
+     * model to prevent code duplication.
+     */
+    namespace MaterialUtilities
+    {
+      namespace Lookup
+      {
+        /**
+         * A base class that can be used to look up material data from an external
+         * data source (e.g. a table in a file). The class consists of data members
+         * and functions to access this data, but it does not contain the functions
+         * to read this data, which has to be implemented in a derived class.
+         */
+        class MaterialLookup
+        {
+          public:
+
+            double
+            specific_heat(const double temperature,
+                          const double pressure) const;
+
+            double
+            density(const double temperature,
+                    const double pressure) const;
+
+            double
+            thermal_expansivity(const double temperature,
+                                const double pressure) const;
+
+            double
+            seismic_Vp(const double temperature,
+                       const double pressure) const;
+
+            double
+            seismic_Vs(const double temperature,
+                       const double pressure) const;
+
+            double
+            enthalpy(const double temperature,
+                     const double pressure) const;
+
+            /**
+             * Computes the derivative of enthalpy for temperature, using the
+             * resolution of the read-in table to compute a finite-difference
+             * approximation of the derivative.
+             */
+            double
+            dHdT (const double temperature,
+                  const double pressure) const;
+
+            /**
+             * Computes the derivative of enthalpy for pressure, using the
+             * resolution of the read-in table to compute a finite-difference
+             * approximation of the derivative.
+             */
+            double
+            dHdp (const double temperature,
+                  const double pressure) const;
+
+            /**
+             * Compute the enthalpy derivatives for temperature and pressure
+             * given a set of temperature and pressure points, which will be
+             * used as support points for the finite difference scheme. This
+             * is useful to not 'miss' phase transitions that are not resolved in
+             * the dHdT and dHdp functions. The third argument represents
+             * the number of substeps taken to compute this average. A number
+             * larger than one means the temperature-pressure range that is spanned
+             * by the first two input arguments is separated into @p n_substeps
+             * equally spaced pressure-temperature steps, the derivatives are
+             * computed for each substep and then averaged.
+             */
+            std::array<std::pair<double, unsigned int>,2>
+            enthalpy_derivatives(const std::vector<double> &temperatures,
+                                 const std::vector<double> &pressures,
+                                 const unsigned int n_substeps = 1) const;
+
+            double
+            dRhodp (const double temperature,
+                    const double pressure) const;
+
+            /**
+             * Returns the index that indicates the phase with the largest volume
+             * fraction at a given temperature and pressure.
+             */
+            unsigned int
+            dominant_phase (const double temperature,
+                            const double pressure) const;
+
+            /**
+             * Returns whether a lookup has a column that indicates which is the
+             * phase with the largest volume fraction is this material.
+             */
+            bool
+            has_dominant_phase() const;
+
+            /**
+             * Returns a vector of all the column names in the lookup file
+             * that start with the character string vol_fraction_
+             */
+            std::vector<std::string>
+            phase_volume_column_names() const;
+
+            /**
+             * Returns the volume fraction of the phase_idth phase
+             * at a given temperature and pressure.
+             */
+            double
+            phase_volume_fraction(const int phase_id,
+                                  const double temperature,
+                                  const double pressure) const;
+
+            /**
+             * Returns the size of the data tables in pressure (first entry)
+             * and temperature (second entry) dimensions.
+             */
+            std::array<double,2>
+            get_pT_steps() const;
+
+
+            /**
+             * Get the list of names of all of the dominant phases
+             * in a given lookup table as given by the phase column.
+             * The names of the phases are stored in the order they
+             * first appear in the table.
+             */
+            const std::vector<std::string> &
+            get_dominant_phase_names() const;
+
+          protected:
+            /**
+             * Access that data value of the property that is stored in table
+             * @p values at pressure @p pressure and temperature @p temperature.
+             * @p interpol controls whether to perform linear interpolation
+             * between the closest data points, or simply use the closest point
+             * value.
+             */
+            double
+            value (const double temperature,
+                   const double pressure,
+                   const Table<2, double> &values,
+                   const bool interpol) const;
+
+            /**
+             * Access that data value of the property that is stored in table
+             * @p values at pressure @p pressure and temperature @p temperature
+             * using the closest point value.
+             */
+            unsigned int
+            value (const double temperature,
+                   const double pressure,
+                   const Table<2, unsigned int> &values) const;
+
+            /**
+             * Find the position in a data table given a temperature.
+             */
+            double get_nT(const double temperature) const;
+
+            /**
+             * Find the position in a data table given a pressure.
+             */
+            double get_np(const double pressure) const;
+
+            dealii::Table<2,double> density_values;
+            dealii::Table<2,double> thermal_expansivity_values;
+            dealii::Table<2,double> specific_heat_values;
+            dealii::Table<2,double> vp_values;
+            dealii::Table<2,double> vs_values;
+            dealii::Table<2,double> enthalpy_values;
+            dealii::Table<2,unsigned int> dominant_phase_indices;
+
+            /**
+             * The vector of column names corresponding to each phase,
+             * and a vector of tables containing the volume fractions of
+             * each phase at a given temperature and pressure.
+             * The ordering of both vectors is the same.
+             */
+            std::vector<std::string> phase_column_names;
+            std::vector<dealii::Table<2,double>> phase_volume_fractions;
+
+            double delta_press;
+            double min_press;
+            double max_press;
+            double delta_temp;
+            double min_temp;
+            double max_temp;
+            unsigned int n_temperature;
+            unsigned int n_pressure;
+            unsigned int n_phases;
+            unsigned int n_columns;
+            bool interpolation;
+            bool has_dominant_phase_column;
+            std::vector<std::string> dominant_phase_names;
+        };
+
+        /**
+         * An implementation of the above base class that reads in files created
+         * by the HeFESTo software.
+         */
+        class HeFESToReader : public MaterialLookup
+        {
+          public:
+            HeFESToReader(const std::string &material_filename,
+                          const std::string &derivatives_filename,
+                          const bool interpol,
+                          const MPI_Comm comm);
+        };
+
+        /**
+         * An implementation of the above base class that reads in files created
+         * by the Perplex software.
+         */
+        class PerplexReader : public MaterialLookup
+        {
+          public:
+            PerplexReader(const std::string &filename,
+                          const bool interpol,
+                          const MPI_Comm comm);
+        };
+
+        /**
+        * This class reads in an entropy-pressure material table and looks up material
+        * properties for the given entropy and pressure.
+        */
+        class EntropyReader
+        {
+          public:
+
+            /**
+             * Read the table.
+             */
+            void
+            initialize(const MPI_Comm comm,
+                       const std::string &data_directory,
+                       const std::string &material_file_name);
+
+            /**
+             * Returns the specific heat for a given entropy and pressure.
+             */
+            double
+            specific_heat(const double entropy,
+                          const double pressure) const;
+
+            /**
+             * Returns the density for a given entropy and pressure.
+             */
+            double
+            density(const double entropy,
+                    const double pressure) const;
+
+            /**
+             * Returns the thermal_expansivity for a given entropy and pressure.
+             */
+            double
+            thermal_expansivity(const double entropy,
+                                const double pressure) const;
+
+            /**
+             * Returns the temperature for a given entropy and pressure.
+             */
+            double
+            temperature(const double entropy,
+                        const double pressure) const;
+
+            /**
+             * Returns the seismic p wave velocity for a given entropy and pressure.
+             */
+            double
+            seismic_vp(const double entropy,
+                       const double pressure) const;
+
+            /**
+             * Returns the seismic s wave velocity for a given entropy and pressure.
+             */
+            double
+            seismic_vs(const double entropy,
+                       const double pressure) const;
+
+            /**
+             * Returns density gradient for a given entropy and pressure.
+             */
+            Tensor<1, 2>
+            density_gradient(const double entropy,
+                             const double pressure) const;
+
+          private:
+            /**
+             * The StructuredDataLookup object that stores the material data.
+             */
+            std::unique_ptr<Utilities::StructuredDataLookup<2>> material_lookup;
+        };
+      }
+
+      /**
+       * For multicomponent material models: Given a vector of compositional
+       * field values of length N, of which M indices correspond to mass or
+       * volume fractions, this function returns a vector of fractions
+       * of length M+1, corresponding to the fraction of a ``background
+       * material'' as the first entry, and fractions for each of the input
+       * fields as the following entries. The returned vector will sum to one.
+       * If the sum of the compositional_fields is greater than
+       * one, we assume that there is no background field (i.e., that field value
+       * is zero). Otherwise, the difference between the sum of the compositional
+       * fields and 1.0 is assumed to be the amount of the background field.
+       * This function makes no assumptions about the units of the
+       * compositional field values; for example, they could correspond to
+       * mass or volume fractions.
+       */
+      std::vector<double>
+      compute_only_composition_fractions(const std::vector<double> &compositional_fields,
+                                         const std::vector<unsigned int> &indices_to_use);
+
+      /**
+       * For multicomponent material models: Given a vector of compositional
+       * field values of length N, this function returns a vector of fractions
+       * of length N+1, corresponding to the fraction of a ``background
+       * material'' as the first entry, and fractions for each of the input
+       * fields as the following entries. The returned vector will sum to one.
+       * If the sum of the compositional_fields is greater than
+       * one, we assume that there is no background field (i.e., that field value
+       * is zero). Otherwise, the difference between the sum of the compositional
+       * fields and 1.0 is assumed to be the amount of the background field.
+       * Optionally, one can input a component mask that determines which of the
+       * compositional fields to use during the computation (e.g. because
+       * some fields contain unrelated quantities (like strain,
+       * porosity, or trace elements). By default, all fields are included.
+       * This function makes no assumptions about the units of the
+       * compositional field values; for example, they could correspond to
+       * mass or volume fractions.
+       */
+      std::vector<double>
+      compute_composition_fractions(const std::vector<double> &compositional_fields,
+                                    const ComponentMask &field_mask = ComponentMask());
+
+      /**
+       * See compute_composition_fractions() for the documentation of this function.
+       * @deprecated: This function is deprecated. Please use compute_composition_fractions() instead.
+       */
+      DEAL_II_DEPRECATED
+      std::vector<double>
+      compute_volume_fractions(const std::vector<double> &compositional_fields,
+                               const ComponentMask &field_mask = ComponentMask());
+
+      /**
+       * Given a vector of component masses,
+       * and another of the corresponding densities, calculate the volumes
+       * of each component. If return_as_fraction is true, the returned vector
+       * will sum to one. If the input vectors have a length of one, the
+       * returned volume fraction is one.
+       */
+      std::vector<double>
+      compute_volumes_from_masses(const std::vector<double> &masses,
+                                  const std::vector<double> &densities,
+                                  const bool return_as_fraction);
+
+      /**
+       * For multicomponent material models:
+       * Enumeration for selecting which averaging scheme to use when
+       * averaging the properties of different compositional fields.
+       * Select between harmonic, arithmetic, geometric, and
+       * maximum_composition. The max composition scheme simply uses the
+       * viscosity of whichever field has the highest volume fraction.
+       */
+      enum CompositionalAveragingOperation
+      {
+        harmonic,
+        arithmetic,
+        geometric,
+        maximum_composition
+      };
+
+
+
+      /**
+       * Read the compositional averaging operation from the parameter file,
+       * using the parameter name given in @p parameter_name, and return the
+       * enum that corresponds to this operation.
+       */
+      CompositionalAveragingOperation
+      parse_compositional_averaging_operation (const std::string &parameter_name,
+                                               const ParameterHandler &prm);
+
+
+
+      /**
+       * For multicomponent material models:
+       * Material models compute output quantities such as the viscosity, the
+       * density, etc. For some models, these values depend strongly on the
+       * composition, and more than one compositional field might have nonzero
+       * values at a given quadrature point. This means that properties have to
+       * be averaged based on the fractions of each compositional field present.
+       * This function performs this type of averaging. The averaging is based
+       * on the choice in @p average_type. Averaging is conducted over the
+       * compositional fields given in @p volume_fractions. This means that
+       * @p volume_fractions and @p parameter_values have to have the same size,
+       * which would typically be the number of compositional fields used in the
+       * simulation (with the potential addition of a background field, in case
+       * the composition does not add up to 1). However, one might not want to
+       * average over all fields, as in some cases compositional fields do not
+       * represent a rock type, but other tracked quantities like the finite
+       * strain, so the implementation is independent of the number of entries in
+       * @p volume_fractions.
+       */
+      double average_value (const std::vector<double> &volume_fractions,
+                            const std::vector<double> &parameter_values,
+                            const CompositionalAveragingOperation &average_type);
+
+
+
+      /**
+       * This function computes averages of multicomponent thermodynamic properties
+       * that are stored in a vector of EquationOfStateOutputs.
+       * Each @p eos_outputs contains the thermodynamic properties for
+       * all materials at a given evaluation point.
+       * The averaged properties are:
+       * density, isothermal compressibility, thermal_expansivity,
+       * the specific entropy derivatives with respect to pressure and temperature
+       * and the specific heat capacity. The first three of these properties
+       * are averaged by volume fraction, and the second three
+       * (the specific properties) are averaged by mass fraction.
+       * These averages are used to fill the corresponding attributes of
+       * a MaterialModelOutputs object.
+       */
+      template <int dim>
+      void
+      fill_averaged_equation_of_state_outputs(const EquationOfStateOutputs<dim> &eos_outputs,
+                                              const std::vector<double> &mass_fractions,
+                                              const std::vector<double> &volume_fractions,
+                                              const unsigned int i,
+                                              MaterialModelOutputs<dim> &out);
+
+
+
+      /**
+       * Utilities for material models with multiple phases
+       */
+      namespace PhaseUtilities
+      {
+        /**
+         * Enumeration for selecting which averaging scheme to use when
+         * averaging the properties of different phases.
+         * Select between arithmetic and logarithmic.
+         */
+        enum PhaseAveragingOperation
+        {
+          arithmetic,
+          logarithmic
+        };
+      }
+
+      /**
+       * Material models compute output quantities such as the viscosity, the
+       * density, etc. For some models, these values may depend on the phase in
+       * addition to the composition, and more than one phase field might have
+       * nonzero values at a given quadrature point. This means that properties
+       * for each composition have to be averaged based on the fractions of each
+       * phase field present. This function performs this type of averaging.
+       * The averaging is based on the choice in @p operation. Averaging is conducted
+       * over the phase functions given in @p phase_function_values, with
+       * @p parameter_values containing values of all individual phases. Unlike the average_value
+       * function defined for compositions, averaging in this function is calculated based
+       * on phase functions and the change of variables on the trajectory of phase boundaries.
+       * Thus on a single phase boundary, values of variables change gradually from one phase
+       * to the other. The values of the phase function used to average the properties varies
+       * between 0 and 1.
+       */
+      double phase_average_value (const std::vector<double> &phase_function_values,
+                                  const std::vector<unsigned int> &n_phase_transitions_per_composition,
+                                  const std::vector<double> &parameter_values,
+                                  const unsigned int composition_index,
+                                  const PhaseUtilities::PhaseAveragingOperation operation = PhaseUtilities::arithmetic);
+
+
+
+      /**
+       * A data structure with all inputs for the
+       * PhaseFunction::phase_function_value() and
+       * PhaseFunction::phase_function_derivative() method.
+       */
+      template <int dim>
+      struct PhaseFunctionInputs
+      {
+        /**
+         * Constructor. Initializes the various variables of this
+         * structure with the input values.
+         */
+        PhaseFunctionInputs(const double temperature,
+                            const double pressure,
+                            const double depth,
+                            const double pressure_depth_derivative,
+                            const unsigned int phase_index);
+
+        double temperature;
+        double pressure;
+        double depth;
+        double pressure_depth_derivative;
+
+        /**
+         * This parameter determines which phase function of all the stored
+         * functions to compute. Phase functions are numbered consecutively,
+         * starting at 0 and the interpretation of their output is up to the
+         * calling side. For example the first phase function could be used to
+         * indicate a viscosity jump in the first compositional field,
+         * while the second function indicates a density jump in all
+         * compositions. None of this is known to the PhaseFunction object,
+         * which only has information that there are two phase functions
+         * and what their properties are.
+         */
+        unsigned int phase_index;
+      };
+
+      /**
+       * A class that bundles functionality to compute the values and
+       * derivatives of phase functions. The class can handle arbitrary
+       * numbers of phase transitions, but the calling side has to determine
+       * how to use the return values of this object (e.g. in terms of
+       * density or viscosity).
+       */
+      template <int dim>
+      class PhaseFunction: public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Percentage of material that has already undergone the phase
+           * transition to the higher-pressure material (this is done
+           * individually for each transition and summed up in the end)
+           */
+          double compute_value (const PhaseFunctionInputs<dim> &in) const;
+
+          /**
+           * Return the derivative of the phase function with respect to
+           * pressure.
+           */
+          double compute_derivative (const PhaseFunctionInputs<dim> &in) const;
+
+          /**
+           * Return the total number of phase transitions.
+           */
+          unsigned int n_phase_transitions () const;
+
+          /**
+           * Return the total number of phases.
+           */
+          unsigned int n_phases () const;
+
+          /**
+           * Return the Clapeyron slope (dp/dT of the transition) for
+           * phase transition number @p phase_index.
+           */
+          double get_transition_slope (const unsigned int phase_index) const;
+
+          /**
+           * Return the depth for phase transition number @p phase_index.
+           */
+          double get_transition_depth (const unsigned int phase_index) const;
+
+          /**
+           * Return how many phase transitions there are for each composition.
+           */
+          const std::vector<unsigned int> &
+          n_phase_transitions_for_each_composition () const;
+
+          /**
+           * Return how many phases there are for each composition.
+           */
+          const std::vector<unsigned int> &
+          n_phases_for_each_composition () const;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           * Note that this class does not declare its own subsection,
+           * i.e. the parameters will be declared in the subsection that
+           * was active before calling this function.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           * Note that this class does not declare its own subsection,
+           * i.e. the parameters will be parsed from the subsection that
+           * was active before calling this function.
+           */
+          void
+          parse_parameters (ParameterHandler &prm);
+
+
+        private:
+          /**
+           * List of depth (or pressure), width, Clapeyron slopes and
+           * limits of temperature for the different phase transitions
+           */
+          std::vector<double> transition_depths;
+          std::vector<double> transition_pressures;
+          std::vector<double> transition_temperatures;
+          std::vector<double> transition_widths;
+          std::vector<double> transition_pressure_widths;
+          std::vector<double> transition_slopes;
+          std::vector<double> transition_temperature_upper_limits;
+          std::vector<double> transition_temperature_lower_limits;
+
+          /**
+           * Whether to define the phase transitions based on depth, or pressure.
+           * Based on this parameter, either transition_depths and transition_width,
+           * or transition_pressures and transition_pressure_widths determine the
+           * depth of the phase transition.
+           */
+          bool use_depth_instead_of_pressure;
+
+          /**
+           * A vector that stores how many phase transitions there are for each compositional field.
+           */
+          std::unique_ptr<std::vector<unsigned int>> n_phase_transitions_per_composition;
+
+          /**
+           * A vector that stores how many phases there are for each compositional field.
+           */
+          std::vector<unsigned int> n_phases_per_composition;
+
+          /**
+           * Total number of phases over all compositional fields
+           */
+          unsigned int n_phases_total;
+      };
+    }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/material_model/visco_plastic.h.bak b/include/aspect/material_model/visco_plastic.h.bak
new file mode 100644
index 00000000000..9ba9bf9fa67
--- /dev/null
+++ b/include/aspect/material_model/visco_plastic.h.bak
@@ -0,0 +1,283 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_visco_plastic_h
+#define _aspect_material_model_visco_plastic_h
+
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/equation_of_state/multicomponent_incompressible.h>
+#include <aspect/material_model/rheology/visco_plastic.h>
+
+#include<deal.II/fe/component_mask.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model combining viscous and plastic deformation, with
+     * the option to also include viscoelastic deformation.
+     *
+     * Viscous deformation is defined by a viscous flow law describing
+     * dislocation and diffusion creep:
+     *   $ v = \frac{1}{2}   A^{-\frac{1}{n}} d^{\frac{m}{n}}
+     *               \dot{\varepsilon}_{ii}^{\frac{1-n}{n}}
+     *               \exp\left(\frac{E + PV}{nRT}\right) $
+     * where
+     *   where $A$ is the prefactor, $n$ is the stress exponent,
+     *   $\dot{\varepsilon}_{ii}$ is the square root of the deviatoric
+     *   strain rate tensor second invariant, $d$ is grain size,
+     *   $m$ is the grain size exponent, $E$ is activation energy,
+     *   $V$ is activation volume, $P$ is pressure, $R$ is the gas
+     *   exponent and $T$ is temperature.
+     *
+     * One may select to use the diffusion ($v_{diff}$; $n=1$, $m!=0$),
+     * dislocation ($v_{disl}$, $n>1$, $m=0$) or composite
+     * $\frac{v_{diff}v_{disl}}{v_{diff}+v_{disl}}$ equation form.
+     *
+     * Viscous stress is limited by plastic deformation, which follows
+     * a Drucker Prager yield criterion:
+     *  $\sigma_y = C\cos(\phi) + P\sin(\phi)$  (2D)
+     * or in 3D
+     *  $\sigma_y = \frac{6C\cos(\phi) + 2P\sin(\phi)}{\sqrt{3}(3+\sin(\phi))}$
+     * where
+     *   $\sigma_y$ is the yield stress, $C$ is cohesion, $phi$ is the angle
+     *   of internal friction and $P$ is pressure.
+     * If the viscous stress ($2v{\varepsilon}_{ii})$) exceeds the yield
+     * stress ($\sigma_{y}$), the viscosity is rescaled back to the yield
+     * surface: $v_{y}=\sigma_{y}/(2{\varepsilon}_{ii})$
+     *
+     * When included, the viscoelastic rheology takes into account the elastic shear
+     * strength (e.g., shear modulus), while the tensile and volumetric
+     * strength (e.g., Young's and bulk modulus) are not considered. The model
+     * is incompressible and allows specifying an arbitrary number of
+     * compositional fields, where each field represents a different rock type
+     * or component of the viscoelastic stress tensor. The symmetric stress tensor in
+     * 2D and 3D, respectively, contains 3 or 6 components. The compositional fields
+     * representing these components must be named and listed in a very specific
+     * format, which is designed to minimize mislabeling stress tensor components
+     * as distinct 'compositional rock types' (or vice versa). For 2D models,
+     * the first three compositional fields must be labeled ve_stress_xx, ve_stress_yy
+     * and ve_stress_xy. In 3D, the first six compositional fields must be labeled
+     * ve_stress_xx, ve_stress_yy, ve_stress_zz, ve_stress_xy, ve_stress_xz, ve_stress_yz.
+     *
+     * Combining this viscoelasticity implementation with non-linear viscous flow
+     * and plasticity produces a constitutive relationship commonly referred to
+     * as partial elastoviscoplastic (e.g., pEVP) in the geodynamics community.
+     * While extensively discussed and applied within the geodynamics literature,
+     * notable references include:
+     * Moresi et al. (2003), J. Comp. Phys., v. 184, p. 476-497.
+     * Gerya and Yuen (2007), Phys. Earth. Planet. Inter., v. 163, p. 83-105.
+     * Gerya (2010), Introduction to Numerical Geodynamic Modeling.
+     * Kaus (2010), Tectonophysics, v. 484, p. 36-47.
+     * Choi et al. (2013), J. Geophys. Res., v. 118, p. 2429-2444.
+     * Keller et al. (2013), Geophys. J. Int., v. 195, p. 1406-1442.
+     *
+     * The overview below directly follows Moresi et al. (2003) eqns. 23-32.
+     * However, an important distinction between this material model and
+     * the studies above is the use of compositional fields, rather than
+     * particles, to track individual components of the viscoelastic stress
+     * tensor. The material model will be updated when an option to track
+     * and calculate viscoelastic stresses with particles is implemented.
+     * Moresi et al. (2003) begins (eqn. 23) by writing the deviatoric
+     * rate of deformation ($\hat{D}$) as the sum of elastic
+     * ($\hat{D_{e}}$) and viscous ($\hat{D_{v}}$) components:
+     * $\hat{D} = \hat{D_{e}} + \hat{D_{v}}$.
+     * These terms further decompose into
+     * $\hat{D_{v}} = \frac{\tau}{2\eta}$ and
+     * $\hat{D_{e}} = \frac{\overset{\triangledown}{\tau}}{2\mu}$, where
+     * $\tau$ is the viscous deviatoric stress, $\eta$ is the shear viscosity,
+     * $\mu$ is the shear modulus and $\overset{\triangledown}{\tau}$ is the
+     * Jaumann corotational stress rate. If plasticity is included the
+     * deviatoric rate of deformation may be written as:
+     * $\hat{D} = \hat{D_{e}} + \hat{D_{v}} + \hat{D_{p}}$, where $\hat{D_{p}}$
+     * is the plastic component. As defined in the second paragraph, $\hat{D_{p}}$
+     * decomposes to $\frac{\tau_{y}}{2\eta_{y}}$, where $\tau_{y}$ is the yield
+     * stress and $\eta_{y}$ is the viscosity rescaled to the yield surface.
+     *
+     * Above, the Jaumann corotational stress rate (eqn. 24) from the elastic
+     * component contains the time derivative of the deviatoric stress ($\dot{\tau}$)
+     * and terms that  account for material spin (e.g., rotation) due to advection:
+     * $\overset{\triangledown}{\tau} = \dot{\tau} + {\tau}W -W\tau$.
+     * Above, $W$ is the material spin tensor (eqn. 25):
+     * $W_{ij} = \frac{1}{2} \left (\frac{\partial V_{i}}{\partial x_{j}} -
+     * \frac{\partial V_{j}}{\partial x_{i}} \right )$.
+     *
+     * The Jaumann stress-rate can also be approximated using terms from the time
+     * at the previous time step ($t$) and current time step ($t + \Delta t^{e}$):
+     * $\smash[t]{\overset{\triangledown}{\tau}}^{t + \Delta t^{e}} \approx
+     * \frac{\tau^{t + \Delta t^{e} - \tau^{t}}}{\Delta t^{e}} -
+     * W^{t}\tau^{t} + \tau^{t}W^{t}$.
+     * In this material model, the size of the time step above ($\Delta t^{e}$)
+     * can be specified as the numerical time step size or an independent fixed time
+     * step. If the latter case is selected, the user has an option to apply a
+     * stress averaging scheme to account for the differences between the numerical
+     * and fixed elastic time step (eqn. 32). If one selects to use a fixed elastic time
+     * step throughout the model run, an equal numerical and elastic time step can be
+     * achieved by using CFL and maximum time step values that restrict the numerical
+     * time step to the fixed elastic time step.
+     *
+     * The formulation above allows rewriting the total rate of deformation (eqn. 29) as
+     * $\tau^{t + \Delta t^{e}} = \eta_{eff} \left (
+     * 2\hat{D}^{t + \triangle t^{e}} + \frac{\tau^{t}}{\mu \Delta t^{e}} +
+     * \frac{W^{t}\tau^{t} - \tau^{t}W^{t}}{\mu}  \right )$.
+     *
+     * The effective viscosity (eqn. 28) is a function of the viscosity ($\eta$),
+     * elastic time step size ($\Delta t^{e}$) and shear relaxation time
+     * ($ \alpha = \frac{\eta}{\mu} $):
+     * $\eta_{eff} = \eta \frac{\Delta t^{e}}{\Delta t^{e} + \alpha}$
+     * The magnitude of the shear modulus thus controls how much the effective
+     * viscosity is reduced relative to the initial viscosity.
+     *
+     * Elastic effects are introduced into the governing Stokes equations through
+     * an elastic force term (eqn. 30) using stresses from the previous time step:
+     * $F^{e,t} = -\frac{\eta_{eff}}{\mu \Delta t^{e}} \tau^{t}$.
+     * This force term is added onto the right-hand side force vector in the
+     * system of equations.
+     *
+     * Several model parameters (reference densities, thermal expansivities
+     * thermal diffusivities, heat capacities and rheology parameters) can
+     * be defined per-compositional field.
+     * For each material parameter the user supplies a comma delimited list of
+     * length N+1, where N is the number of compositional fields.  The
+     * additional field corresponds to the value for background material.  They
+     * should be ordered ``background, composition1, composition2...''
+     *
+     * If a list of values is given for the density, thermal expansivity,
+     * thermal diffusivity and heat capacity, the volume weighted sum of the
+     * values of each of the compositional fields is used in their place,
+     * for example $\rho = \sum \left( \rho_i V_i \right)$
+     *
+     * The individual output viscosities for each compositional field are
+     * also averaged. The user can choose from a range of options for this
+     * viscosity averaging. If only one value is given for any of these parameters,
+     * all compositions are assigned the same value.
+     * The first value in the list is the value assigned to "background material"
+     * (regions where the sum of the compositional fields is < 1.0).
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class ViscoPlastic : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         *
+         * This material model is incompressible.
+         */
+        bool is_compressible () const override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        double get_min_strain_rate() const;
+
+        /**
+         * A function that returns whether the material is plastically yielding at
+         * the given pressure, temperature, composition, and strain rate.
+         *
+         * @deprecated: Use the other function with this name instead, which allows
+         * to pass in more general input variables.
+         */
+        DEAL_II_DEPRECATED
+        bool
+        is_yielding (const double pressure,
+                     const double temperature,
+                     const std::vector<double> &composition,
+                     const SymmetricTensor<2,dim> &strain_rate) const;
+
+        /**
+         * A function that returns whether the material is plastically
+         * yielding at the given input variables (pressure, temperature,
+         * composition, strain rate, and so on).
+         */
+        bool
+        is_yielding (const MaterialModelInputs<dim> &in) const;
+
+      private:
+
+        /**
+         * Pointer to the object used to compute the rheological properties.
+         * In this case, the rheology in question is visco(elasto)plastic. The
+         * object contains functions for parameter declaration and parsing,
+         * and further functions that calculate viscosity and viscosity
+         * derivatives. It also contains functions that create and fill
+         * additional material model outputs, specifically plastic outputs.
+         * The rheology itself is a composite rheology, and so the object
+         * contains further objects and/or pointers to objects that provide
+         * functions and parameters for all subordinate rheologies.
+         */
+        std::unique_ptr<Rheology::ViscoPlastic<dim>> rheology;
+
+        std::vector<double> thermal_diffusivities;
+
+        /**
+         * Whether to use user-defined thermal conductivities instead of thermal diffusivities.
+         */
+        bool define_conductivities;
+
+        std::vector<double> thermal_conductivities;
+
+        /**
+         * Number of phase transitions for each chemical composition (including the background field).
+         */
+        std::vector<unsigned int> n_phase_transitions_for_each_chemical_composition;
+
+        /**
+         * Total number of phases.
+         */
+        unsigned int n_phases;
+
+        /**
+         * Object for computing the equation of state.
+         */
+        EquationOfState::MulticomponentIncompressible<dim> equation_of_state;
+
+        /**
+         * Object that handles phase transitions.
+         */
+        MaterialUtilities::PhaseFunction<dim> phase_function;
+
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/material_model/viscoelastic.h.bak b/include/aspect/material_model/viscoelastic.h.bak
new file mode 100644
index 00000000000..7003201e0e7
--- /dev/null
+++ b/include/aspect/material_model/viscoelastic.h.bak
@@ -0,0 +1,220 @@
+/*
+  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_viscoelastic_h
+#define _aspect_material_model_viscoelastic_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/rheology/elasticity.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/equation_of_state/multicomponent_incompressible.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * An implementation of a simple linear viscoelastic rheology that only
+     * includes the deviatoric components of elasticity. Specifically, the
+     * viscoelastic rheology only takes into account the elastic shear
+     * strength (e.g., shear modulus), while the tensile and volumetric
+     * strength (e.g., Young's and bulk modulus) are not considered. The model
+     * is incompressible and allows specifying an arbitrary number of
+     * compositional fields, where each field represents a different rock type
+     * or component of the viscoelastic stress tensor. The stress tensor in 2D
+     * and 3D, respectively, contains 3 or 6 components. The compositional fields
+     * representing these components must be named and listed in a very specific
+     * format, which is designed to minimize mislabeling stress tensor components
+     * as distinct 'compositional rock types' (or vice versa). For 2D models,
+     * the first three compositional fields must be labeled ve_stress_xx, ve_stress_yy
+     * and ve_stress_xy. In 3D, the first six compositional fields must be labeled
+     * ve_stress_xx, ve_stress_yy, ve_stress_zz, ve_stress_xy, ve_stress_xz, ve_stress_yz.
+     *
+     * Expanding the model to include non-linear viscous flow (e.g.,
+     * diffusion/dislocation creep) and plasticity would produce a constitutive
+     * relationship commonly referred to as partial elastoviscoplastic
+     * (e.g., pEVP) in the geodynamics community. While extensively discussed
+     * and applied within the geodynamics literature, notable references include:
+     * Moresi et al. (2003), J. Comp. Phys., v. 184, p. 476-497.
+     * Gerya and Yuen (2007), Phys. Earth. Planet. Inter., v. 163, p. 83-105.
+     * Gerya (2010), Introduction to Numerical Geodynamic Modeling.
+     * Kaus (2010), Tectonophysics, v. 484, p. 36-47.
+     * Choi et al. (2013), J. Geophys. Res., v. 118, p. 2429-2444.
+     * Keller et al. (2013), Geophys. J. Int., v. 195, p. 1406-1442.
+     *
+     * The overview below directly follows Moresi et al. (2003) eqns. 23-32.
+     * However, an important distinction between this material model and
+     * the studies above is the use of compositional fields, rather than
+     * particles, to track individual components of the viscoelastic stress
+     * tensor. The material model will be updated when an option to track
+     * and calculate viscoelastic stresses with particles is implemented.
+     *
+     * Moresi et al. (2003) begins (eqn. 23) by writing the deviatoric
+     * rate of deformation ($\hat{D}$) as the sum of elastic
+     * ($\hat{D_{e}}$) and viscous ($\hat{D_{v}}$) components:
+     * $\hat{D} = \hat{D_{e}} + \hat{D_{v}}$.
+     * These terms further decompose into
+     * $\hat{D_{v}} = \frac{\tau}{2\eta}$ and
+     * $\hat{D_{e}} = \frac{\overset{\nabla}{\tau}}{2\mu}$, where
+     * $\tau$ is the viscous deviatoric stress, $\eta$ is the shear viscosity,
+     * $\mu$ is the shear modulus and $\overset{\nabla}{\tau}$ is the
+     * Jaumann corotational stress rate. This later term (eqn. 24) contains the
+     * time derivative of the deviatoric stress ($\dot{\tau}$) and terms that
+     * account for material spin (e.g., rotation) due to advection:
+     * $\overset{\nabla}{\tau} = \dot{\tau} + {\tau}W -W\tau$.
+     * Above, $W$ is the material spin tensor (eqn. 25):
+     * $W_{ij} = \frac{1}{2} \left (\frac{\partial V_{i}}{\partial x_{j}} -
+     * \frac{\partial V_{j}}{\partial x_{i}} \right )$.
+     *
+     * The Jaumann stress-rate can also be approximated using terms from the time
+     * at the previous time step ($t$) and current time step ($t + \Delta t^{e}$):
+     * $\smash[t]{\overset{\nabla}{\tau}}^{t + \Delta t^{e}} \approx
+     * \frac{\tau^{t + \Delta t^{e} - \tau^{t}}}{\Delta t^{e}} -
+     * W^{t}\tau^{t} + \tau^{t}W^{t}$.
+     * In this material model, the size of the time step above ($\Delta t^{e}$)
+     * can be specified as the numerical time step size or an independent fixed time
+     * step. If the latter case is a selected, the user has an option to apply a
+     * stress averaging scheme to account for the differences between the numerical
+     * and fixed elastic time step (eqn. 32). If one selects to use a fixed elastic time
+     * step throughout the model run, this can still be achieved by using CFL and
+     * maximum time step values that restrict the numerical time step to a specific time.
+     *
+     * The formulation above allows rewriting the total rate of deformation (eqn. 29) as
+     * $\tau^{t + \Delta t^{e}} = \eta_{eff} \left (
+     * 2\hat{D}^{t + \triangle t^{e}} + \frac{\tau^{t}}{\mu \Delta t^{e}} +
+     * \frac{W^{t}\tau^{t} - \tau^{t}W^{t}}{\mu}  \right )$.
+     *
+     * The effective viscosity (eqn. 28) is a function of the viscosity ($\eta$),
+     * elastic time step size ($\Delta t^{e}$) and shear relaxation time
+     * ($ \alpha = \frac{\eta}{\mu} $):
+     * $\eta_{eff} = \eta \frac{\Delta t^{e}}{\Delta t^{e} + \alpha}$
+     * The magnitude of the shear modulus thus controls how much the effective
+     * viscosity is reduced relative to the initial viscosity.
+     *
+     * Elastic effects are introduced into the governing stokes equations through
+     * an elastic force term (eqn. 30) using stresses from the previous time step:
+     * $F^{e,t} = -\frac{\eta_{eff}}{\mu \Delta t^{e}} \tau^{t}$.
+     * This force term is added onto the right-hand side force vector in the
+     * system of equations.
+     *
+     * The value of each compositional field representing distinct
+     * rock types at a point is interpreted to be a volume fraction of that
+     * rock type. If the sum of the compositional field volume fractions is
+     * less than one, then the remainder of the volume is assumed to be
+     * 'background material'.
+     *
+     * Several model parameters (densities, elastic shear moduli,
+     * thermal expansivities, thermal conductivies, specific heats) can
+     * be defined per-compositional field. For each material parameter the
+     * user supplies a comma delimited list of length N+1, where N is the
+     * number of compositional fields. The additional field corresponds to
+     * the value for background material. They should be ordered
+     * ``background, composition1, composition2...''. However, the first 3 (2D)
+     * or 6 (3D) composition fields correspond to components of the elastic
+     * stress tensor and their material values will not contribute to the volume
+     * fractions. If a single value is given, then all the compositional fields
+     * are given that value. Other lengths of lists are not allowed. For a given
+     * compositional field the material parameters are treated as constant,
+     * except density, which varies linearly with temperature according to the
+     * thermal expansivity.
+     *
+     * When more than one compositional field is present at a point, they are
+     * averaged arithmetically. An exception is viscosity, which may be averaged
+     * arithmetically, harmonically, geometrically, or by selecting the
+     * viscosity of the composition with the greatest volume fraction.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class Viscoelastic : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Function to compute the material properties in @p out given the
+         * inputs in @p in.
+         */
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * This model is not compressible, so this returns false.
+         */
+        bool is_compressible () const override;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+
+      private:
+        /**
+         * Enumeration for selecting which viscosity averaging scheme to use.
+         */
+        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
+
+        EquationOfState::MulticomponentIncompressible<dim> equation_of_state;
+
+        /**
+         * Vector for field viscosities, read from parameter file.
+         */
+        std::vector<double> viscosities;
+
+        /**
+         * Vector for field thermal conductivities, read from parameter file.
+         */
+        std::vector<double> thermal_conductivities;
+
+        Rheology::Elasticity<dim> elastic_rheology;
+    };
+
+  }
+}
+
+#endif
diff --git a/include/aspect/melt.h.bak b/include/aspect/melt.h.bak
new file mode 100644
index 00000000000..9db3a27b005
--- /dev/null
+++ b/include/aspect/melt.h.bak
@@ -0,0 +1,571 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _aspect_melt_h
+#define _aspect_melt_h
+
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace MaterialModel
+  {
+    /**
+     * The MeltInputs provide the compaction pressures and
+     * melt (fluid) velocities, so that they can be used as
+     * additional inputs in heating or material models.
+     */
+    template <int dim>
+    class MeltInputs : public AdditionalMaterialInputs<dim>
+    {
+      public:
+        /**
+         * Constructor. When the MeltInputs are created,
+         * all properties are initialized with signalingNaNs.
+         * This means that individual heating or material models
+         * can all attach the plugins they need, and in a later
+         * step they will all be filled together (using the fill
+         * function).
+         */
+        MeltInputs (const unsigned int n_points);
+
+        /**
+         * Compaction pressure values $p_c$ at the given positions.
+         */
+        std::vector<double> compaction_pressures;
+
+        /**
+         * An approximation for the fluid (melt) velocities
+         * at the given positions.
+         */
+        std::vector<Tensor<1,dim>> fluid_velocities;
+
+        /**
+         * Fill the compaction pressures and fluid velocities.
+         */
+        void fill (const LinearAlgebra::BlockVector &solution,
+                   const FEValuesBase<dim>          &fe_values,
+                   const Introspection<dim>         &introspection) override;
+    };
+
+    template <int dim>
+    class MeltOutputs : public AdditionalMaterialOutputs<dim>
+    {
+      public:
+        MeltOutputs (const unsigned int n_points,
+                     const unsigned int /*n_comp*/)
+        {
+          compaction_viscosities.resize(n_points);
+          fluid_viscosities.resize(n_points);
+          permeabilities.resize(n_points);
+          fluid_densities.resize(n_points);
+          fluid_density_gradients.resize(n_points, Tensor<1,dim>());
+        }
+
+        /**
+         * Compaction viscosity values $\xi$ at the given positions.
+         * This parameter describes the resistance of the solid matrix
+         * in a two-phase simulation to dilation and compaction.
+         */
+        std::vector<double> compaction_viscosities;
+
+        /**
+         * Fluid (melt) viscosity values $\eta_f$ at the given positions.
+         */
+        std::vector<double> fluid_viscosities;
+
+        /**
+         * Permeability values $k$ at the given positions.
+         */
+        std::vector<double> permeabilities;
+
+        /**
+         * Fluid (melt) density values $\rho_f$ at the given positions.
+         */
+        std::vector<double> fluid_densities;
+
+        /**
+         * An approximation for the fluid (melt) density gradients
+         * $\nabla \rho_f$ at the given positions. These values are
+         * required for compressible models to describe volume changes
+         * of melt in dependence of pressure, temperature etc.
+         */
+        std::vector<Tensor<1,dim>> fluid_density_gradients;
+
+        /**
+         * Do the requested averaging operation for the melt outputs.
+         * The projection matrix argument is only used if the operation
+         * chosen is project_to_Q1.
+         */
+        void average (const MaterialAveraging::AveragingOperation operation,
+                      const FullMatrix<double>  &projection_matrix,
+                      const FullMatrix<double>  &expansion_matrix) override;
+    };
+
+    /**
+     * Base class for material models that implement a melt fraction function.
+     * This is used to compute some statistics about the melt fraction.
+     *
+     * This class is used as a "mix-in" class: Concrete material models will
+     * be derived from MaterialModel::Interface (and consequently have to
+     * implement the `virtual` functions of that class) *and also* from the
+     * current class (and consequently have to implement the `virtual` function
+     * of the current class). The inheritance from MaterialModel::Interface is
+     * typically via the MaterialModel::MeltInterface intermediate class.
+     */
+    template <int dim>
+    class MeltFractionModel
+    {
+      public:
+        /**
+         * Destructor. Does nothing but is virtual so that derived classes
+         * destructors are also virtual.
+         */
+        virtual ~MeltFractionModel () = default;
+
+        /**
+         * Compute the equilibrium melt fractions for the given input conditions.
+         * @p in and @p melt_fractions need to have the same size.
+         *
+         * @param in Object that contains the current conditions.
+         * @param melt_fractions Vector of doubles that is filled with the
+         * equilibrium melt fraction for each given input conditions.
+         */
+        virtual void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                                     std::vector<double> &melt_fractions) const = 0;
+
+        /**
+         * Return whether an object provided as argument is of a class that is
+         * derived from the current MeltFractionModel class. (Many of these models
+         * will be derived from MaterialModel::Interface and *also* be derived
+         * from MeltFractionModel; only the latter derivation is of interest to
+         * this function.
+         */
+        template <typename ModelType>
+        static
+        bool is_melt_fraction_model (const ModelType &model_object);
+
+        /**
+         * Return a reference to the MeltFractionModel base class of
+         * the object. This function will throw an exception unless
+         * is_melt_fraction_model() returns `true` for the given argument.
+         */
+        template <typename ModelType>
+        static
+        const MeltFractionModel<dim> &
+        as_melt_fraction_model (const ModelType &model_object);
+    };
+
+
+
+    template <int dim>
+    template <typename ModelType>
+    inline
+    bool
+    MeltFractionModel<dim>::is_melt_fraction_model (const ModelType &model_object)
+    {
+      return (dynamic_cast<const MeltFractionModel<dim>*>(&model_object)
+              != nullptr);
+    }
+
+
+    template <int dim>
+    template <typename ModelType>
+    inline
+    const MeltFractionModel<dim> &
+    MeltFractionModel<dim>::as_melt_fraction_model (const ModelType &model_object)
+    {
+      Assert (is_melt_fraction_model(model_object) == true,
+              ExcMessage ("This function can only be called for model objects "
+                          "whose types are derived from MeltFractionModel."));
+
+      return dynamic_cast<const MeltFractionModel<dim>&>(model_object);
+    }
+
+
+
+    /**
+     * Base class for material models to be used with melt transport enabled.
+     */
+    template <int dim>
+    class MeltInterface: public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * Reference value for the Darcy coefficient, which is defined as
+         * permeability divided by fluid viscosity. Units: m^2/Pa/s.
+         */
+        virtual double reference_darcy_coefficient () const = 0;
+
+        /**
+         * Returns the cell-averaged and cut-off value of p_c_scale,
+         * the factor we use to rescale the compaction pressure and to
+         * decide if a cell is a melt cell.
+         * The last input argument @p consider_is_melt_cell determines if
+         * this computation takes into account if a cell is a "melt cell".
+         * Melt cells are cells where we solve the melt transport equations,
+         * as indicated by the entries stored in the is_melt_cell vector of
+         * the melt handler. In case @p consider_is_melt_cell is set to true,
+         * this function returns a value of zero if the cell is not a melt cell.
+         * If @p consider_is_melt_cell is set to false the computation
+         * disregards the information about which cells are melt cells,
+         * and computes p_c_scale from the cell-averaged Darcy coefficient
+         * for all cells. This is needed for example when we want to update
+         * the is_melt_cell vector and need to find out which cells should be
+         * marked as melt cells.
+         */
+        double p_c_scale (const MaterialModel::MaterialModelInputs<dim> &inputs,
+                          const MaterialModel::MaterialModelOutputs<dim> &outputs,
+                          const MeltHandler<dim> &melt_handler,
+                          const bool consider_is_melt_cell) const;
+    };
+
+
+  }
+
+
+
+  namespace Assemblers
+  {
+    /**
+     * A base class for the definition of assemblers that implement the linear
+     * system terms for the *melt* migration compressible or incompressible
+     * equations.
+     */
+    template <int dim>
+    class MeltInterface : public aspect::Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Attach melt outputs. Since most melt assemblers require the
+         * melt material model properties they are created in this base class
+         * already.
+         */
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+    };
+
+    /**
+     * Compute the integrals for the preconditioner for the Stokes system in
+     * the case of melt migration on a single cell.
+     */
+    template <int dim>
+    class MeltStokesPreconditioner : public MeltInterface<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * Compute the integrals for the Stokes matrix and right hand side in
+     * the case of melt migration on a single cell.
+     */
+    template <int dim>
+    class MeltStokesSystem : public MeltInterface<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+
+    /**
+     * Compute the boundary integrals for the Stokes right hand side in
+     * the case of melt migration on a single cell. These boundary terms
+     * are used to describe Neumann boundary conditions for the fluid pressure.
+     */
+    template <int dim>
+    class MeltStokesSystemBoundary : public MeltInterface<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * Compute the integrals for the Advection system matrix and right hand side in
+     * the case of melt migration on a single cell.
+     */
+    template <int dim>
+    class MeltAdvectionSystem : public MeltInterface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+
+        /**
+         * Compute the residual of the advection system on a single cell in
+         * the case of melt migration.
+         */
+        std::vector<double>
+        compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
+    };
+
+    /**
+     * Integrate the local fluid pressure shape functions on a single cell
+     * for models with melt migration, so that they can later be used to do
+     * the pressure right-hand side compatibility modification.
+     */
+    template <int dim>
+    class MeltPressureRHSCompatibilityModification : public MeltInterface<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * Assemble traction boundary condition terms for models with melt.
+     */
+    template <int dim>
+    class MeltBoundaryTraction : public MeltInterface<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+  }
+
+
+  namespace Melt
+  {
+    template <int dim>
+    struct Parameters
+    {
+      /**
+       * Declare additional parameters that are needed in models with
+       * melt transport.
+       */
+      static void declare_parameters (ParameterHandler &prm);
+
+      /**
+       * Parse additional parameters that are needed in models with
+       * melt transport.
+       *
+       * This has to be called before edit_finite_element_variables,
+       * so that the finite elements that are used for the additional melt
+       * variables can be specified in the input file and are parsed before
+       * the introspection object is created.
+       */
+      void parse_parameters (ParameterHandler &prm);
+
+      /**
+       * The factor by how much the Darcy coefficient K_D in a cell can be smaller than
+       * the reference Darcy coefficient for this cell still to be considered a melt cell
+       * (for which the melt transport equations are solved). If the Darcy coefficient
+       * is smaller than the product of this value and the reference Dracy coefficient,
+       * the cell is not considered a melt cell and the Stokes system without melt
+       * transport is solved instead. In practice, this means that all terms in the
+       * assembly related to the migration of melt are set to zero, and the compaction
+       * pressure degrees of freedom are constrained to be zero.
+       */
+      double melt_scaling_factor_threshold;
+
+      /**
+       * Whether to use a porosity weighted average of the melt and solid velocity
+       * to advect heat in the temperature equation or not. If this is set to true,
+       * additional terms are assembled on the left-hand side of the temperature
+       * advection equation in models with melt migration.
+       * If this is set to false, only the solid velocity is used (as in models
+       * without melt migration).
+       */
+      bool heat_advection_by_melt;
+
+      /**
+       * Whether to use a discontinuous element for the compaction pressure or not.
+       */
+      bool use_discontinuous_p_c;
+
+      /**
+       * Whether to cell-wise average the material properties that are used to
+       * compute the melt velocity or not. Note that the melt velocity is computed
+       * as the sum of the solid velocity and the phase separation flux (difference
+       * between melt and solid velocity). If this parameter is set to true,
+       * material properties in the computation of the phase separation flux will
+       * be averaged cell-wise.
+       */
+      bool average_melt_velocity;
+    };
+  }
+
+
+  /**
+   * Class that contains all runtime parameters and other helper functions
+   * related to melt transport. A global instance can be retrieved with
+   * SimulatorAccess<dim>::get_melt_handler(), but keep in mind that it only
+   * exists if parameters.include_melt_transport is true.
+   */
+  template <int dim>
+  class MeltHandler: public SimulatorAccess<dim>
+  {
+    public:
+      MeltHandler(ParameterHandler &prm);
+
+      /**
+       * Create an additional material model output object that contains
+       * the additional output variables needed in simulation with melt transport,
+       * and attaches a pointer to it to the corresponding vector in the
+       * MaterialModel::MaterialModelOutputs structure.
+       */
+      static void create_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output);
+
+      /**
+       * Add the additional variables we need in simulations with melt
+       * migration to the list of variables, which will be used later
+       * to set up the introspection object.
+       */
+      void edit_finite_element_variables(const Parameters<dim> &parameters,
+                                         std::vector<VariableDeclaration<dim>> &variables);
+
+      /**
+       * Determine, based on the run-time parameters of the current simulation,
+       * which functions need to be called in order to assemble linear systems,
+       * matrices, and right hand side vectors.
+       */
+      void set_assemblers (Assemblers::Manager<dim> &assemblers) const;
+
+
+      /**
+       * Initialize function. This is mainly to check that the melt transport
+       * parameters chosen in the input file are consistent with the rest of
+       * the options. We can not do this in the parse_parameters function,
+       * as we do not have simulator access at that point.
+       */
+      void initialize() const;
+
+      /**
+       * Setup SimulatorAccess for the plugins related to melt transport.
+       */
+      void initialize_simulator (const Simulator<dim> &simulator_object) override;
+
+      /**
+       * Compute fluid velocity and solid pressure in this ghosted solution vector.
+       * The fluid velocity is computed by solving a mass matrix problem, and the
+       * solid pressure is computed algebraically.
+       *
+       * @param system_matrix The system matrix with an already set up sparsity
+       * pattern that will be used by this function to compute the melt variables.
+       * @param solution The existing solution vector that contains the values
+       * for porosity, compaction pressure, fluid pressure and solid velocity
+       * obtained by solving the Stokes and advection system, and that will be
+       * updated with the computed values for fluid velocity and solid pressure.
+       * @param system_rhs The right-hand side vector that will be used by
+       * this function to compute the melt variables.
+       */
+      void compute_melt_variables(LinearAlgebra::BlockSparseMatrix &system_matrix,
+                                  LinearAlgebra::BlockVector &solution,
+                                  LinearAlgebra::BlockVector &system_rhs);
+
+      /**
+       * Return whether this object refers to the porosity field.
+       */
+      bool is_porosity (const typename Simulator<dim>::AdvectionField &advection_field) const;
+
+      /**
+       * Apply free surface stabilization to a cell of the system matrix when melt
+       * transport is used in the computation. Called during assembly of the system matrix.
+       */
+      void apply_free_surface_stabilization_with_melt (const double free_surface_theta,
+                                                       const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                                       internal::Assembly::Scratch::StokesSystem<dim>       &scratch,
+                                                       internal::Assembly::CopyData::StokesSystem<dim>      &data) const;
+
+      /**
+       * Constrain the compaction pressure to zero in all cells that are not
+       * "melt cells" (cells where the porosity is above a given threshold).
+       * This reverts the system of equations we solve back to the Stokes
+       * system without melt transport for these cells.
+       */
+      void add_current_constraints(AffineConstraints<double> &constraints);
+
+      /**
+       * Returns the entry of the private variable is_melt_cell_vector for the
+       * cell given in the input, describing if we have melt transport in this
+       * cell or not.
+       */
+      bool is_melt_cell(const typename DoFHandler<dim>::active_cell_iterator &cell) const;
+
+      /**
+       * Given the Darcy coefficient @p K_D as computed by the material model,
+       * limit the coefficient to a minimum value (computed as the K_D
+       * variation threshold given in the input file times the reference Darcy
+       * coefficient) in melt cells and return this value. If @p is_melt_cell
+       * is false, return zero.
+       */
+      double limited_darcy_coefficient(const double K_D,
+                                       const bool is_melt_cell) const;
+
+      /**
+       * Return a pointer to the boundary fluid pressure.
+       */
+      const BoundaryFluidPressure::Interface<dim> &
+      get_boundary_fluid_pressure () const;
+
+      /**
+       * The object that stores the run-time parameters that control the how the
+       * melt transport equations are solved.
+       */
+      Melt::Parameters<dim> melt_parameters;
+
+    private:
+      /**
+       * Store a pointer to the fluid pressure boundary plugin, so that the
+       * initialization can be done together with the other objects related to melt
+       * transport.
+       */
+      const std::unique_ptr<aspect::BoundaryFluidPressure::Interface<dim>> boundary_fluid_pressure;
+
+      /**
+       * is_melt_cell_vector[cell->active_cell_index()] says whether we want to
+       * solve the melt transport equations (as opposed to the Stokes equations without
+       * melt) in this cell or not. The value is set to true or false based on the
+       * porosity in the cell (only cells where the porosity is above a threshold are
+       * considered melt cells).
+       */
+      std::vector<bool> is_melt_cell_vector;
+
+      /**
+       * Constraint object. We need to save the current constraints at the
+       * start of every time step so that we can add the melt constraints,
+       * which depend on the solution of the porosity field, later after
+       * we have computed this solution.
+       */
+      AffineConstraints<double> current_constraints;
+
+  };
+
+}
+
+#endif
diff --git a/include/aspect/mesh_deformation/ascii_data.h.bak b/include/aspect/mesh_deformation/ascii_data.h.bak
new file mode 100644
index 00000000000..2b49c54566d
--- /dev/null
+++ b/include/aspect/mesh_deformation/ascii_data.h.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_deformation_ascii_data_h
+#define _aspect_mesh_deformation_ascii_data_h
+
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements initial topography determined
+     * from an AsciiData input file.
+     *
+     * @ingroup InitialTopographyModel
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Sets the boundary id of the surface boundary.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataBoundary<dim>::initialize;
+
+        /**
+         * Return the surface topography as a function of position along the surface.
+         * For the current class, this function returns a value from the text files.
+         *
+         * @copydoc aspect::InitialTopographyModel::Interface::value()
+         */
+        Tensor<1,dim>
+        compute_initial_deformation_on_boundary(const types::boundary_id boundary_indicator,
+                                                const Point<dim> &position) const override;
+
+        /**
+         * Returns whether or not the plugin requires surface stabilization
+         */
+        bool needs_surface_stabilization () const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        types::boundary_id surface_boundary_id;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/mesh_deformation/diffusion.h.bak b/include/aspect/mesh_deformation/diffusion.h.bak
new file mode 100644
index 00000000000..4459211f10c
--- /dev/null
+++ b/include/aspect/mesh_deformation/diffusion.h.bak
@@ -0,0 +1,138 @@
+/*
+  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_deformation_diffusion_h
+#define _aspect_mesh_deformation_diffusion_h
+
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+
+  namespace MeshDeformation
+  {
+    /**
+     * A plugin that computes the deformation of surface
+     * vertices according to the solution of a dim-1 diffusion
+     * problem.
+     */
+    template <int dim>
+    class Diffusion : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        Diffusion();
+
+        /**
+         * Initialize function, which sets the start time and
+         * start timestep of diffusion.
+         */
+        void initialize() override;
+
+        /**
+         * The update function sets the current time and determines
+         * whether diffusion should be applied in this timestep.
+         */
+        void update() override;
+
+
+
+        /**
+         * A function that creates constraints for the velocity of certain mesh
+         * vertices (e.g. the surface vertices) for a specific boundary.
+         * The calling class will respect
+         * these constraints when computing the new vertex positions.
+         */
+        void
+        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                 AffineConstraints<double> &mesh_velocity_constraints,
+                                                 const std::set<types::boundary_id> &boundary_id) const override;
+
+        /**
+         * Returns whether or not the plugin requires surface stabilization
+         */
+        bool needs_surface_stabilization () const override;
+
+        /**
+         * Declare parameters for the diffusion of the surface.
+         */
+        static
+        void declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Parse parameters for the diffusion of the surface.
+         */
+        void parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Compute the surface velocity from a difference
+         * in surface height given by the solution of
+         * the hillslope diffusion problem.
+         */
+        void diffuse_boundary (const DoFHandler<dim> &free_surface_dof_handler,
+                               const IndexSet &mesh_locally_owned,
+                               const IndexSet &mesh_locally_relevant,
+                               LinearAlgebra::Vector &output,
+                               const std::set<types::boundary_id> &boundary_id) const;
+
+        /**
+         * Check that the size of the next time step is not larger than the conduction
+         * timestep based on the mesh size and the diffusivity on each cell along the
+         * surface. The computed time step has to satisfy the CFL
+         * number chosen in the input parameter file on each cell of the mesh.
+         */
+        void check_diffusion_time_step (const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                        const std::set<types::boundary_id> &boundary_ids) const;
+
+        /**
+         * The hillslope transport coefficient or diffusivity [m2/s]
+         * used in the hillslope diffusion of the deformed
+         * surface.
+         */
+        double diffusivity;
+
+        /**
+         * Maximum number of steps between the application of diffusion.
+         */
+        unsigned int timesteps_between_diffusion;
+
+        /**
+         * Whether or not in the current timestep, diffusion
+         * should be applied.
+         */
+        bool apply_diffusion;
+
+        /**
+         * Boundaries along which the mesh is allowed to move tangentially
+         * despite of the Stokes velocity boundary conditions.
+         */
+        std::set<types::boundary_id> additional_tangential_mesh_boundary_indicators;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/mesh_deformation/fastscape.h.bak b/include/aspect/mesh_deformation/fastscape.h.bak
new file mode 100644
index 00000000000..f087d987365
--- /dev/null
+++ b/include/aspect/mesh_deformation/fastscape.h.bak
@@ -0,0 +1,597 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_mesh_deformation_fastscape_h
+#define _aspect_mesh_deformation_fastscape_h
+
+#include <aspect/global.h>
+
+#ifdef ASPECT_WITH_FASTSCAPE
+
+#include <aspect/mesh_deformation/interface.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace MeshDeformation
+  {
+    /**
+     * A plugin that utilizes the landscape evolution code FastScape
+     * to deform the ASPECT boundary through advection, uplift,
+     * hillslope diffusion, sediment deposition, marine diffusion,
+     * and the stream power law, which describes river incision.
+     *
+     */
+    template <int dim>
+    class FastScape : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialize variables for FastScape.
+         */
+        virtual void initialize () override;
+
+        /**
+         * Destructor for FastScape.
+         */
+        ~FastScape() override;
+
+        /**
+          * A function that creates constraints for the velocity of certain mesh
+          * vertices (e.g. the surface vertices) for a specific boundary.
+          * The calling class will respect
+          * these constraints when computing the new vertex positions.
+          */
+        virtual
+        void
+        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                 AffineConstraints<double> &mesh_velocity_constraints,
+                                                 const std::set<types::boundary_id> &boundary_id) const override;
+
+        /**
+         * Returns whether or not the plugin requires surface stabilization
+         */
+        bool needs_surface_stabilization () const override;
+
+        /**
+         * Declare parameters for the FastScape plugin.
+         */
+        static
+        void declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Parse parameters for the FastScape plugin.
+         */
+        void parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Function used to set the FastScape ghost nodes. FastScape boundaries are
+         * not uplifted or periodic for advection and diffusion. By using a layer
+         * of extra nodes in the FastScape model, we can avoid seeing FastScape boundary
+         * effects within ASPECT. Similarly, we can use these nodes to have fully
+         * periodic boundaries, where we check the flow direction and update the FastScape
+         * ghost nodes, and the nodes one layer inward (boundary nodes in ASPECT) to match
+         * the parameters on the other side (vx, vy, vz, h). This is done every ASPECT timestep
+         * before running FastScape.
+         */
+        void set_ghost_nodes(std::vector<double> &elevation,
+                             std::vector<double> &velocity_x,
+                             std::vector<double> &velocity_y,
+                             std::vector<double> &velocity_z,
+                             const double &fastscape_timestep_in_years,
+                             const bool init) const;
+
+        /**
+         * Function to determine whether the current index is a ghost node
+         */
+        bool is_ghost_node(const unsigned int &index,
+                           const bool &exclude_boundaries) const;
+
+        /**
+         * Function to fill the Fastscape arrays (height and velocities) with the data received from ASPECT in the correct index order.
+         */
+        void fill_fastscape_arrays(std::vector<double> &elevation,
+                                   std::vector<double> &bedrock_transport_coefficient_array,
+                                   std::vector<double> &bedrock_river_incision_rate_array,
+                                   std::vector<double> &velocity_x,
+                                   std::vector<double> &velocity_y,
+                                   std::vector<double> &velocity_z,
+                                   std::vector<std::vector<double>> &temporary_variables) const;
+
+        /**
+         * Function to get the ASPECT topography and velocities at the surface, and an index for transferring these to FastScape.
+         */
+        std::vector<std::vector<double>> get_aspect_values() const;
+
+        /**
+         * Function to initialize or restart FastScape
+         */
+        void initialize_fastscape(std::vector<double> &elevation,
+                                  std::vector<double> &basement,
+                                  std::vector<double> &bedrock_transport_coefficient_array,
+                                  std::vector<double> &bedrock_river_incision_rate_array,
+                                  std::vector<double> &silt_fraction) const;
+
+        /**
+         * Execute FastScape
+         */
+        void execute_fastscape(std::vector<double> &elevation,
+                               std::vector<double> &extra_vtk_field,
+                               std::vector<double> &velocity_x,
+                               std::vector<double> &velocity_y,
+                               std::vector<double> &velocity_z,
+                               const double &fastscape_timestep_in_years,
+                               const unsigned int &fastscape_iterations) const;
+
+        /**
+         * Function to apply orographic (mountain related, e.g., wind or elevation)
+         * controls to the FastScape model.
+         */
+        void apply_orographic_controls(const std::vector<double> &elevation,
+                                       std::vector<double> &bedrock_river_incision_rate_array,
+                                       std::vector<double> &bedrock_transport_coefficient_array) const;
+
+        /**
+         * Fill velocity data table to be interpolated back onto the ASPECT mesh.
+         */
+        Table<dim,double> fill_data_table(std::vector<double> &values,
+                                          TableIndices<dim> &size_idx,
+                                          const unsigned int &fastscape_nx,
+                                          const unsigned int &fastscape_ny) const;
+
+        /**
+         * Read data from file for restarting.
+         */
+        void read_restart_files(std::vector<double> &elevation,
+                                std::vector<double> &basement,
+                                std::vector<double> &silt_fraction) const;
+
+        /**
+         * Save data to file for restarting.
+         */
+        void save_restart_files(const std::vector<double> &elevation,
+                                std::vector<double> &basement,
+                                std::vector<double> &silt_fraction) const;
+
+        /**
+         * Suggestion for the number of FastScape steps to run for every ASPECT timestep,
+         * where the FastScape timestep is determined by ASPECT_timestep_length divided by
+         * this parameter.
+         */
+        unsigned int fastscape_steps_per_aspect_step;
+
+        /**
+         * Maximum timestep allowed for FastScape, if the suggested timestep exceeds this
+         * limit it is repeatedly divided by 2 until the final timestep is smaller than this parameter.
+         */
+        double maximum_fastscape_timestep;
+
+        /**
+         * Check whether FastScape needs to be restarted. This is used as
+         * a mutable bool because we determine whether the model is being resumed in
+         * initialize(), and then after reinitializing FastScape we change it to false
+         * so it does not initialize FastScape again in future timesteps.
+         * TODO: There is probably a better way to do this, and restarts should be rolled into
+         * the general ASPECT restart.
+         */
+        mutable bool restart;
+
+        /**
+         * FastScape cell size in X.
+         */
+        double fastscape_dx;
+
+        /**
+         * FastScape cell size in Y.
+         */
+        double fastscape_dy;
+
+        /**
+         * FastScape X extent (ASPECT X extent + 2*dx for ghost nodes).
+         */
+        double fastscape_x_extent;
+
+        /**
+         * Fastscape Y extent (ASPECT Y extent + 2*dy for ghost nodes).
+         */
+        double fastscape_y_extent;
+
+        /**
+         * User set FastScape Y extent for a 2D ASPECT model.
+         */
+        double fastscape_y_extent_2d;
+
+        /**
+         * Number of x points in FastScape array.
+         */
+        unsigned int fastscape_nx;
+
+        /**
+         * Number of y points in FastScape array.
+         */
+        unsigned int fastscape_ny;
+
+        /**
+         * Vertical exaggeration in FastScape visualization.
+         */
+        double vexp;
+
+        /**
+         * How many levels FastScape should be refined above the maximum ASPECT surface resolution.
+         */
+        unsigned int additional_refinement_levels;
+
+        /**
+         * Maximum expected refinement level at ASPECT's surface.
+         * This and resolution_difference are required to properly transfer node data from
+         * ASPECT to FastScape.
+         */
+        unsigned int maximum_surface_refinement_level;
+
+        /**
+         * Difference in refinement levels expected at the ASPECT surface,
+         * where this would be set to 2 if 3 refinement levels are set at the surface.
+         * This and surface_resolution are required to properly transfer node data from
+         * ASPECT to FastScape.
+         *
+         * TODO: Should this be kept this way, or make it so the input is the expected levels
+         * of refinement at the surface, and we can subtract one within the code? Also,
+         * it would be good to find a way to check these are correct, because they are a
+         * common source of errors.
+         */
+        unsigned int surface_refinement_difference;
+
+        /**
+         * If set to true, the FastScape surface is averaged along Y and returned
+         * to ASPECT. If set to false, the center slice of the FastScape model is
+         * returned to ASPECT.
+         */
+        bool average_out_of_plane_surface_topography;
+
+        /**
+         * Seed number for initial topography noise in FastScape.
+         */
+        int fastscape_seed;
+
+        /**
+         * Variable to hold ASPECT domain extents.
+         */
+        std::array<std::pair<double,double>,dim> grid_extent;
+
+        /**
+         * Table for interpolating FastScape surface velocities back to ASPECT.
+         */
+        std::array<unsigned int, dim> table_intervals;
+
+        /**
+         * Whether or not to use the ghost nodes.
+         */
+        bool use_ghost_nodes;
+
+        /**
+         * Magnitude (m) of the initial noise applied to FastScape.
+         * Applied as either a + or - value to the topography
+         * such that the total difference can be up to 2*noise_elevation.
+         */
+        double noise_elevation;
+
+        /**
+         * Sediment rain in m/yr, added as a flat increase to the FastScape surface
+         * in the marine domain every ASPECT timestep before running FastScape.
+         */
+        std::vector<double> sediment_rain_rates;
+
+        /**
+         * Time at which each interval of sediment_rain_rates is active. Should contain
+         * one less value than sediment_rain_rates, assuming that sediment_rain_rates[0]
+         * is applied from model time 0 until sediment_rain_times[0].
+         */
+        std::vector<double> sediment_rain_times;
+
+        /**
+        * Flag for having FastScape advect/uplift the surface. If the free surface is used
+        * in conjunction with FastScape, this can be set to false, then FastScape will only
+        * apply erosion/deposition to the surface and not advect or uplift it.
+        */
+        bool fastscape_advection_uplift;
+
+        /**
+         * Node tolerance for how close a ASPECT node must be to the FastScape node
+         * for the value to be transferred. This is only necessary if use_v is set to 0
+         * and the free surface is used to advect the surface with a normal projection, or
+         * if there is a surface refinement level difference leading to excess interpolation
+         * points in areas of high ASPECT resolution.
+         */
+        double node_tolerance;
+
+        /**
+          * Interval between the generation of graphical output. This parameter
+          * is read from the input file and consequently is not part of the
+          * state that needs to be saved and restored.
+          */
+        double output_interval;
+
+        /**
+          * A time (in seconds) at which the last graphical output was supposed
+          * to be produced. Used to check for the next necessary output time.
+          */
+        mutable double last_output_time;
+
+        /**
+         * @name Fastscape boundary conditions
+         * @{
+         */
+
+        /**
+         * FastScape bottom boundary condition that determines topography at the FastScape bottom boundary.
+         * Where 1 represents a fixed height boundary (though this can still be uplifted through uplift velocities), and 0 a
+         * reflective boundary. When two opposing boundaries are reflective (e.g., top and bottom are both zero), then the boundaries
+         * become cyclic.
+         */
+        unsigned int bottom;
+
+        /**
+         * FastScape top boundary condition that determines topography at the FastScape top boundary.
+         * Where 1 represents a fixed height boundary (though this can still be uplifted through uplift velocities), and 0 a
+         * reflective boundary. When two opposing boundaries are reflective (e.g., top and bottom are both zero), then the boundaries
+         * become cyclic.
+         */
+        unsigned int top;
+
+        /**
+         * FastScape right boundary condition that determines topography at the FastScape right boundary.
+         * Where 1 represents a fixed height boundary (though this can still be uplifted through uplift velocities), and 0 a
+         * reflective boundary. When two opposing boundaries are reflective (e.g., left and right are both zero), then the boundaries
+         * become cyclic.
+         */
+        unsigned int right;
+
+        /**
+         * FastScape left boundary condition that determines topography at the FastScape left boundary.
+         * Where 1 represents a fixed height boundary (though this can still be uplifted through uplift velocities), and 0 a
+         * reflective boundary. When two opposing boundaries are reflective (e.g., left and right are both zero), then the boundaries
+         * become cyclic.
+         */
+        unsigned int left;
+
+        /**
+         * Parameters that set the FastScape boundaries periodic even though the ghost nodes are set 'fixed'
+         */
+        bool topbottom_ghost_nodes_periodic;
+        bool leftright_ghost_nodes_periodic;
+
+        /**
+         * Integer that holds the full boundary conditions sent to FastScape (e.g., 1111).
+         */
+        unsigned int fastscape_boundary_conditions;
+
+        /**
+         * Prescribed flux per unit length into the model through the bottom boundary (m^2/yr).
+         */
+        double bottom_flux;
+
+        /**
+         * Prescribed flux per unit length into the model through the top boundary (m^2/yr).
+         */
+        double top_flux;
+
+        /**
+         * Prescribed flux per unit length into the model through the right boundary (m^2/yr).
+         */
+        double right_flux;
+
+        /**
+         * Prescribed flux per unit length into the model through the left boundary (m^2/yr).
+         */
+        double left_flux;
+        /**
+           * @}
+         */
+
+        /**
+         * @name FastScape subaerial erosional parameters
+         * @{
+         */
+
+        /**
+         * Drainage area exponent for the stream power law. ($m$ variable in FastScape surface equation.)
+         */
+        double drainage_area_exponent_m;
+
+        /**
+         * Slope exponent for the stream power law. ($n$ variable in FastScape surface equation.)
+         */
+        double slope_exponent_n;
+
+        /**
+         * Slope exponent for multi-direction flow, where 0 is uniform, and 10 is steepest descent. (-1 varies with slope.)
+         * ($p$ variable in FastScape surface equation.)
+         */
+        double slope_exponent_p;
+
+        /**
+         * Bedrock deposition coefficient. Higher values deposit more sediment
+         * inside the domain. ($G$ variable in FastScape surface equation.)
+         */
+        double bedrock_deposition_g;
+
+        /**
+         * Sediment deposition coefficient. Higher values deposit more sediment inside the domain.
+         * When set to -1 this is identical to the bedrock value.
+         * ($G$ variable in FastScape surface equation applied to sediment.)
+         */
+        double sediment_deposition_g;
+
+        /**
+         * Bedrock river incision rate for the stream power law.
+         * (meters^(1-2m)/yr, $kf$ variable in FastScape surface equation.)
+         */
+        double bedrock_river_incision_rate;
+
+        /**
+         * Sediment river incision rate for the stream power law (meters^(1-2m)/yr).
+         * When set to -1 this is identical to the bedrock value.
+         * ($kf$ variable in FastScape surface equation applied to sediment.)
+         */
+        double sediment_river_incision_rate;
+
+        /**
+         * Bedrock transport coefficient for hillslope diffusion (m^2/yr, kd in FastScape surface equation.)
+         */
+        double bedrock_transport_coefficient;
+
+        /**
+         * Sediment transport coefficient for hillslope diffusion (m^2/yr). When set to -1 this is
+         * identical to the bedrock value.
+         * (kd in FastScape surface equation applied to sediment).
+         */
+        double sediment_transport_coefficient;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Fastscape marine parameters
+         * @{
+         */
+
+        /**
+         * Fastscape sea level (m), set relative to the ASPECT surface where
+         * a sea level of zero will represent the initial maximum unperturbed
+         * Y (2D) or Z (3D) extent of the ASPECT domain. A negative value of
+         * the sea level means the sea level lies below the initial unperturbed
+         * top boundary of the domain.
+         */
+        double sea_level;
+
+        /**
+         * Parameters to set an extra erosional base level
+         * on the ghost nodes that differs from sea level.
+         */
+        bool use_fixed_erosional_base;
+
+        /**
+         * Height of the extra erosional base level.
+         */
+        double h_erosional_base;
+
+        /**
+         * Surface porosity for sand.
+         */
+        double sand_surface_porosity;
+
+        /**
+         * Surface porosity for silt.
+         */
+        double silt_surface_porosity;
+
+        /**
+         * Sands e-folding depth for exponential porosity law (m).
+         */
+        double sand_efold_depth;
+
+        /**
+         * Silts e-folding depth for exponential porosity law (m).
+         */
+        double silt_efold_depth;
+
+        /**
+         * Sand-silt ratio
+         */
+        double sand_silt_ratio;
+
+        /**
+         * Averaging depth/thickness for sand-silt equation (m).
+         */
+        double sand_silt_averaging_depth;
+
+        /**
+         * Sand marine transport coefficient. (marine diffusion, m^2/yr.)
+         */
+        double sand_transport_coefficient;
+
+        /**
+         * Silt marine transport coefficient. (marine diffusion, m^2/yr.)
+         */
+        double silt_transport_coefficient;
+
+        /**
+         * Flag to use the marine component of FastScape.
+         */
+        bool use_marine_component;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Orographic parameters
+         * @{
+         */
+
+        /**
+         * Set a flat height (m) after which the flat_erosional_factor
+         * is applied to the bedrock river incision rate and transport coefficient.
+         */
+        int flat_elevation;
+
+        /**
+         * Set the height (m) after which the model will track the ridge line
+         * and based on the wind direction will apply the wind_barrier_erosional_factor
+         * to the bedrock river incision rate and transport coefficient.
+         */
+        int wind_barrier_elevation;
+
+        /**
+         * Wind direction for wind_barrier_erosional_factor.
+         */
+        unsigned int wind_direction;
+
+        /**
+         * Factor to multiply the bedrock river incision rate and transport coefficient by depending on them
+         * flat_elevation.
+         */
+        double flat_erosional_factor;
+
+        /**
+         * Factor to multiply the bedrock river incision rate and transport coefficient by depending on them
+         * wind_barrier_elevation and wind direction.
+         */
+        double wind_barrier_erosional_factor;
+
+        /**
+         * Flag to stack both orographic controls.
+         */
+        bool stack_controls;
+
+        /**
+         * Flag to use orographic controls.
+         */
+        bool use_orographic_controls;
+        /**
+         * @}
+         */
+    };
+  }
+}
+
+#endif
+#endif
diff --git a/include/aspect/mesh_deformation/free_surface.h.bak b/include/aspect/mesh_deformation/free_surface.h.bak
new file mode 100644
index 00000000000..7cb6c1fd631
--- /dev/null
+++ b/include/aspect/mesh_deformation/free_surface.h.bak
@@ -0,0 +1,116 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_deformation_free_surface_h
+#define _aspect_mesh_deformation_free_surface_h
+
+#include <aspect/mesh_deformation/interface.h>
+
+#include <aspect/simulator_access.h>
+#include <aspect/simulator/assemblers/interface.h>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace MeshDeformation
+  {
+    /**
+     * A plugin that computes the deformation of surface
+     * vertices according to the solution of the flow problem.
+     * In particular this means if the surface of the domain is
+     * left open to flow, this flow will carry the mesh with it.
+     */
+    template <int dim>
+    class FreeSurface : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialize function, which connects the set_assemblers function
+         * to the appropriate Simulator signal.
+         */
+        void initialize() override;
+
+        /**
+         * Called by Simulator::set_assemblers() to allow the FreeSurface plugin
+         * to register its assembler.
+         */
+        void set_assemblers(const SimulatorAccess<dim> &simulator_access,
+                            aspect::Assemblers::Manager<dim> &assemblers) const;
+
+
+        /**
+         * A function that creates constraints for the velocity of certain mesh
+         * vertices (e.g. the surface vertices) for a specific boundary.
+         * The calling class will respect
+         * these constraints when computing the new vertex positions.
+         */
+        void
+        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                 AffineConstraints<double> &mesh_velocity_constraints,
+                                                 const std::set<types::boundary_id> &boundary_id) const override;
+
+        /**
+         * Returns whether or not the plugin requires surface stabilization
+         */
+        bool needs_surface_stabilization () const override;
+
+        /**
+         * Declare parameters for the free surface handling.
+         */
+        static
+        void declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Parse parameters for the free surface handling.
+         */
+        void parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Project the Stokes velocity solution onto the
+         * free surface. Called by make_constraints()
+         */
+        void project_velocity_onto_boundary (const DoFHandler<dim> &free_surface_dof_handler,
+                                             const IndexSet &mesh_locally_owned,
+                                             const IndexSet &mesh_locally_relevant,
+                                             LinearAlgebra::Vector &output) const;
+
+        /**
+         * A struct for holding information about how to advect the free surface.
+         */
+        struct SurfaceAdvection
+        {
+          enum Direction { normal, vertical };
+        };
+
+        /**
+         * Stores whether to advect the free surface in the normal direction
+         * or the direction of the local vertical.
+         */
+        typename SurfaceAdvection::Direction advection_direction;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/mesh_deformation/function.h.bak b/include/aspect/mesh_deformation/function.h.bak
new file mode 100644
index 00000000000..7f2d29a5258
--- /dev/null
+++ b/include/aspect/mesh_deformation/function.h.bak
@@ -0,0 +1,87 @@
+/*
+  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_deformation_boundary_function_h
+#define _aspect_mesh_deformation_boundary_function_h
+
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace MeshDeformation
+  {
+    template <int dim>
+    class BoundaryFunction : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        BoundaryFunction();
+
+        /**
+         *
+         */
+        void update() override;
+
+        /**
+         * A function that creates constraints for the velocity of certain mesh
+         * vertices (e.g. the surface vertices) for a specific boundary.
+         * The calling class will respect
+         * these constraints when computing the new vertex positions.
+         */
+        void
+        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                 AffineConstraints<double> &mesh_velocity_constraints,
+                                                 const std::set<types::boundary_id> &boundary_id) const override;
+
+        /**
+         * Returns whether or not the plugin requires surface stabilization
+         */
+        bool needs_surface_stabilization () const override;
+
+        /**
+         * Declare parameters for the free surface handling.
+         */
+        static
+        void declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Parse parameters for the free surface handling.
+         */
+        void parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the mesh deformation.
+         */
+        Functions::ParsedFunction<dim> function;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/mesh_deformation/interface.h.bak b/include/aspect/mesh_deformation/interface.h.bak
new file mode 100644
index 00000000000..210b61651d5
--- /dev/null
+++ b/include/aspect/mesh_deformation/interface.h.bak
@@ -0,0 +1,649 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_deformation_interface_h
+#define _aspect_mesh_deformation_interface_h
+
+#include <aspect/plugins.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <deal.II/fe/fe_system.h>
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/lac/affine_constraints.h>
+#include <deal.II/base/index_set.h>
+#include <deal.II/base/mg_level_object.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/multigrid/mg_constrained_dofs.h>
+#include <deal.II/multigrid/mg_transfer_matrix_free.h>
+#include <deal.II/multigrid/mg_transfer_global_coarsening.templates.h>
+#include <aspect/simulator/assemblers/interface.h>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace Assemblers
+  {
+    /**
+     * Apply stabilization to a cell of the system matrix. The
+     * stabilization is only added to cells on a free surface. The
+     * scheme is based on that of Kaus et. al., 2010. Called during
+     * assembly of the system matrix.
+     */
+    template <int dim>
+    class ApplyStabilization: public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        ApplyStabilization(const double stabilization_theta);
+
+        void
+        execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
+                 internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
+
+      private:
+        /**
+         * Stabilization parameter for the free surface. Should be between
+         * zero and one. A value of zero means no stabilization. See Kaus
+         * et. al. 2010 for more details.
+         */
+        const double free_surface_theta;
+    };
+  }
+
+  template <int dim> class Simulator;
+
+  /**
+   * A namespace that contains everything that is related to the deformation
+   * of the mesh vertices over time.
+   */
+  namespace MeshDeformation
+  {
+    /**
+     * A base class for mesh deformation plugins. Each derived class should
+     * implement a function that determines the deformation velocity for certain
+     * mesh vertices and store them in a AffineConstraints<double> object. The velocities
+     * for all non-constrained vertices will be computed by solving a Laplace
+     * problem with the given constraints.
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * A function that will be called to check whether stabilization is needed.
+         */
+        virtual bool needs_surface_stabilization() const;
+
+
+        /**
+         * A function that returns the initial deformation of points on the
+         * boundary (e.g. the surface vertices). @p position is the undeformed
+         * position and this function is expected to return the
+         * displacement vector of this position. The default implementation
+         * returns a zero displacement (= no initial deformation).
+         */
+        virtual
+        Tensor<1,dim>
+        compute_initial_deformation_on_boundary(const types::boundary_id boundary_indicator,
+                                                const Point<dim> &position) const;
+
+        /**
+         * A function that creates constraints for the velocity of certain mesh
+         * vertices (e.g. the surface vertices) for a specific set of boundaries.
+         * The calling class will respect
+         * these constraints when computing the new vertex positions.
+         * The default implementation creates no constraints.
+         */
+        virtual
+        void
+        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                 AffineConstraints<double> &mesh_velocity_constraints,
+                                                 const std::set<types::boundary_id> &boundary_id) const;
+    };
+
+
+
+    /**
+     * The MeshDeformationHandler that handles the motion
+     * of the surface, the internal nodes and computes the
+     * Arbitrary-Lagrangian-Eulerian correction terms.
+     */
+    template <int dim>
+    class MeshDeformationHandler: public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Initialize the mesh deformation handler, allowing it to read in
+         * relevant parameters as well as giving it a reference to the
+         * Simulator that owns it, since it needs to make fairly extensive
+         * changes to the internals of the simulator.
+         */
+        MeshDeformationHandler(Simulator<dim> &simulator);
+
+        /**
+         * Destructor for the mesh deformation handler.
+         */
+        ~MeshDeformationHandler() override;
+
+        /**
+         * Initialization function of the MeshDeformationHandler.
+         *
+         * The default implementation of this function does nothing.
+         */
+        void initialize();
+
+        /**
+         * Called by Simulator::set_assemblers() to allow the FreeSurface plugin
+         * to register its assembler.
+         */
+        void set_assemblers(const SimulatorAccess<dim> &simulator_access,
+                            aspect::Assemblers::Manager<dim> &assemblers) const;
+
+        /**
+         * Update function of the MeshDeformationHandler. This function
+         * allows the individual mesh deformation objects to update.
+         */
+        void update();
+
+        /**
+         * The main execution step for the mesh deformation implementation. This
+         * computes the motion of the surface, moves the boundary nodes
+         * accordingly, redistributes the internal nodes in order to
+         * preserve mesh regularity, and calculates the
+         * Arbitrary-Lagrangian-Eulerian correction terms for advected quantities.
+         */
+        void execute();
+
+        /**
+         * Allocates and sets up the members of the MeshDeformationHandler. This
+         * is called by Simulator<dim>::setup_dofs()
+         */
+        void setup_dofs();
+
+        /**
+         * Declare parameters for the mesh deformation handling.
+         */
+        static
+        void declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Parse parameters for the mesh deformation handling.
+         */
+        void parse_parameters (ParameterHandler &prm);
+
+        /**
+         * A function that is used to register mesh deformation objects in such
+         * a way that the Manager can deal with all of them without having to
+         * know them by name. This allows the files in which individual
+         * plugins are implemented to register these plugins, rather than also
+         * having to modify the Manager class by adding the new initial
+         * mesh deformation plugin class.
+         *
+         * @param name A string that identifies the mesh deformation model
+         * @param description A text description of what this model does and that
+         * will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that can be
+         * used to declare the parameters that this mesh deformation model
+         * wants to read from input files.
+         * @param factory_function A pointer to a function that can create an
+         * object of this mesh deformation model.
+         */
+        static
+        void
+        register_mesh_deformation
+        (const std::string &name,
+         const std::string &description,
+         void (*declare_parameters_function) (ParameterHandler &),
+         std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+        /**
+         * Return a map of boundary indicators to the names of all mesh deformation models currently
+         * used in the computation, as specified in the input file.
+         */
+        const std::map<types::boundary_id, std::vector<std::string>> &
+        get_active_mesh_deformation_names () const;
+
+        /**
+         * Return a map of boundary indicators to vectors of pointers to all mesh deformation models
+         * currently used in the computation, as specified in the input file.
+         */
+        const std::map<types::boundary_id,std::vector<std::unique_ptr<Interface<dim>>>> &
+        get_active_mesh_deformation_models () const;
+
+        /**
+         * Return a set of all the indicators of boundaries with
+         * mesh deformation objects on them.
+         */
+        const std::set<types::boundary_id> &
+        get_active_mesh_deformation_boundary_indicators () const;
+
+        /**
+         * Return a set of all the indicators of boundaries that
+         * require surface stabilization.
+         */
+        const std::set<types::boundary_id> &
+        get_boundary_indicators_requiring_stabilization () const;
+
+        /**
+         * Return the boundary id of the surface that has a free surface
+         * mesh deformation object. If no free surface is used,
+         * an empty set is returned.
+         */
+        const std::set<types::boundary_id> &
+        get_free_surface_boundary_indicators () const;
+
+        /**
+         * Return the stabilization parameter for the free surface.
+         */
+        double get_free_surface_theta () const;
+
+        /**
+         * Return the initial topography stored on
+         * the Q1 finite element that describes the mesh geometry.
+         * Note that a topography is set for all mesh nodes,
+         * but only the values of surface boundary nodes are correct.
+         * The internal nodes get the same initial topography as the
+         * corresponding surface node. In other words, there is
+         * no decrease of the initial topography with depth.
+         * However, only the topography stored at the surface nodes
+         * is taken into account in the diffusion plugin that
+         * uses this function. TODO Once all initial_topography
+         * is prescribed through initial_mesh_deformation, this
+         * function can be removed.
+         */
+        const LinearAlgebra::Vector &
+        get_initial_topography () const;
+
+        /**
+         * Return the mesh displacements based on the mesh deformation
+         * DoFHandler you can access with get_mesh_deformation_dof_handler().
+         */
+        const LinearAlgebra::Vector &
+        get_mesh_displacements () const;
+
+        /**
+         * Return the DoFHandler used to represent the mesh deformation space.
+         */
+        const DoFHandler<dim> &
+        get_mesh_deformation_dof_handler () const;
+
+        /**
+         * Go through the list of all mesh deformation objects that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename MeshDeformationType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,MeshDeformationType>::value>>
+        bool
+        has_matching_mesh_deformation_object () const;
+
+        /**
+         * Go through the list of all mesh deformation objects that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no mesh deformation object is active that matches the given type,
+         * throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename MeshDeformationType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,MeshDeformationType>::value>>
+        const MeshDeformationType &
+        get_matching_mesh_deformation_object () const;
+
+
+        /**
+         * If multilevel solvers are used, we need a mapping on each multigrid level. These
+         * are automatically updated by this handler class and can be accessed with this
+         * method.
+         */
+        const Mapping<dim> &
+        get_level_mapping(const unsigned int level) const;
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcMeshDeformationNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered mesh deformation objects.");
+
+      private:
+        /**
+         * Compute the initial constraints for the mesh displacement
+         * on the boundaries of the domain.  This is used on the mesh
+         * deformation boundaries to describe a displacement (initial
+         * topography) to be used during the simulation. The
+         * displacement is given by the active deformation plugins.
+         */
+        void make_initial_constraints ();
+
+        /**
+         * Compute the constraints for the mesh velocity on the
+         * boundaries of the domain.  On the mesh deformation
+         * boundaries, the velocity is given by the active deformation
+         * plugins.
+         *
+         * Velocities on free-slip boundaries are constrained to be
+         * tangential to those boundaries. Velocities on no-slip
+         * boundaries are set to be zero. If a no-slip boundary is
+         * marked as additional tangential, then velocities are
+         * constrained as tangential.
+         */
+        void make_constraints ();
+
+        /**
+         * Solve vector Laplacian equation for internal mesh displacements and update
+         * the current displacement vector based on the solution.
+         */
+        void compute_mesh_displacements ();
+
+        /**
+         * Solve vector Laplacian equation using GMG for internal mesh displacements and update
+         * the current displacement vector based on the solution.
+         */
+        void compute_mesh_displacements_gmg ();
+
+        /**
+         * Set up the vector with initial displacements of the mesh
+         * due to the initial topography, as supplied by the initial
+         * topography plugin based on the surface coordinates of the
+         * mesh nodes. We set all entries to the initial topography
+         * based on its surface coordinates, i.e. the initial topography
+         * is not corrected for depth from the surface as it is
+         * for the initial mesh deformation. TODO this is ok for now,
+         * because the surface diffusion plugin only cares about the
+         * initial topography at the surface, but it would be more correct if it
+         * sets the initial topography to the actual initial distortion of
+         * the mesh cells. When all initial_topography plugins are converted
+         * to the new initial_mesh_deformation functionality, this function
+         * can be removed.
+         */
+        void set_initial_topography ();
+
+        /**
+         * Calculate the velocity of the mesh for ALE corrections.
+         */
+        void interpolate_mesh_velocity ();
+
+        /**
+         * Update the mesh deformation for the multigrid levels.
+         */
+        void update_multilevel_deformation ();
+
+        /**
+         * Reference to the Simulator object to which a MeshDeformationHandler
+         * instance belongs.
+         */
+        Simulator<dim> &sim;
+
+        /**
+         * Finite element for the mesh deformation implementation, which is
+         * used for tracking mesh deformation.
+         */
+        const FESystem<dim> mesh_deformation_fe;
+
+        /**
+         * DoFHandler for the mesh deformation implementation.
+         */
+        DoFHandler<dim> mesh_deformation_dof_handler;
+
+        /**
+         * BlockVector which stores the mesh velocity in the
+         * Stokes finite element space.
+         * This is used for ALE corrections.
+         */
+        LinearAlgebra::BlockVector mesh_velocity;
+
+        /**
+         * Vector for storing the positions of the mesh vertices. This
+         * is used for calculating the mapping from the reference cell to
+         * the position of the cell in the deformed mesh. This must be
+         * redistributed upon mesh refinement.
+         */
+        LinearAlgebra::Vector mesh_displacements;
+
+        /**
+         * mesh_displacements from the last time step.
+         */
+        LinearAlgebra::Vector old_mesh_displacements;
+
+        /**
+         * Vector for storing the positions of the mesh vertices at the initial timestep.
+         * This must be redistributed upon mesh refinement.
+         * We need to store the initial topography because it is not taken
+         * into account into the mesh displacements used by the MappingQ1Eulerian.
+         * The current mesh displacements plus the initial topography provide
+         * the actual topography at any time.
+         */
+        LinearAlgebra::Vector initial_topography;
+
+        /**
+         * Vector for storing the mesh velocity in the mesh deformation finite
+         * element space, which is, in general, not the same finite element
+         * space as the Stokes system. This is used for interpolating
+         * the mesh velocity in the mesh deformation finite element space onto
+         * the velocity in the Stokes finite element space, which is then
+         * used for making the ALE correction in the advection equations.
+         */
+        LinearAlgebra::Vector fs_mesh_velocity;
+
+        /**
+         * IndexSet for the locally owned DoFs for the mesh system
+         */
+        IndexSet mesh_locally_owned;
+
+        /**
+         * IndexSet for the locally relevant DoFs for the mesh system
+         */
+        IndexSet mesh_locally_relevant;
+
+        /**
+         * Storage for the mesh velocity constraints for solving the
+         * elliptic problem.
+         */
+        AffineConstraints<double> mesh_velocity_constraints;
+
+        /**
+         * Storage for the mesh vertex constraints for keeping the mesh conforming
+         * upon redistribution.
+         */
+        AffineConstraints<double> mesh_vertex_constraints;
+
+        /**
+         * A map of boundary ids to mesh deformation objects that have been requested
+         * in the parameter file.
+         */
+        std::map<types::boundary_id,std::vector<std::unique_ptr<Interface<dim>>>> mesh_deformation_objects;
+
+        /**
+         * Map from boundary id to a vector of names representing
+         * mesh deformation objects.
+         */
+        std::map<types::boundary_id, std::vector<std::string>> mesh_deformation_object_names;
+
+        /**
+         * The set of boundary indicators for which mesh deformation
+         * objects are set and that therefore can deform over time as
+         * prescribed in the mesh_deformation_objects.
+         */
+        std::set<types::boundary_id> prescribed_mesh_deformation_boundary_indicators;
+
+        /**
+         * A set of boundary indicators that denote those boundaries that are
+         * allowed to move their mesh tangential to the boundary.
+         */
+        std::set<types::boundary_id> tangential_mesh_deformation_boundary_indicators;
+
+        /**
+         * A set of boundary indicators, on which mesh deformation is prescribed to
+         * be zero (fixed boundaries that never move). All boundaries except those
+         * in prescribed_mesh_deformation_boundary_indicators and
+         * tangential_mesh_deformation_boundary_indicators are in this set.
+         */
+        std::set<types::boundary_id> zero_mesh_deformation_boundary_indicators;
+
+        /**
+         * The boundary indicator(s) of the free surface(s). This is the
+         * subset of prescribed_mesh_deformation_boundary_indicators for which
+         * the 'free surface' plugin was selected.
+         */
+        std::set<types::boundary_id> free_surface_boundary_indicators;
+
+        /**
+         * The set of boundary indicators for which the mesh deformation
+         * objects need surface stabilization.
+         */
+        std::set<types::boundary_id> boundary_indicators_requiring_stabilization;
+
+        bool include_initial_topography;
+
+        /**
+         * Stabilization parameter for the free surface. Should be between
+         * zero and one. A value of zero means no stabilization.  See Kaus
+         * et. al. 2010 for more details.
+         */
+        double surface_theta;
+
+        /**
+         * If required, store a mapping for each multigrid level.
+         */
+        MGLevelObject<std::unique_ptr<Mapping<dim>>> level_mappings;
+
+        /**
+         * One vector on each multigrid level for the mesh displacement used in the mapping.
+         */
+        MGLevelObject<dealii::LinearAlgebra::distributed::Vector<double>> level_displacements;
+
+        /**
+         * Multigrid transfer operator for the displacements
+         */
+        MGTransferMF<dim, double> mg_transfer;
+
+        /**
+         * Multigrid level constraints for the displacements
+         */
+        MGConstrainedDoFs mg_constrained_dofs;
+
+        friend class Simulator<dim>;
+        friend class SimulatorAccess<dim>;
+    };
+
+
+
+    template <int dim>
+    template <typename MeshDeformationType, typename>
+    inline
+    bool
+    MeshDeformationHandler<dim>::has_matching_mesh_deformation_object () const
+    {
+      for (const auto &object_iterator : mesh_deformation_objects)
+        for (const auto &p : object_iterator.second)
+          if (Plugins::plugin_type_matches<MeshDeformationType>(*p))
+            return true;
+
+      return false;
+    }
+
+
+
+    template <int dim>
+    template <typename MeshDeformationType, typename>
+    inline
+    const MeshDeformationType &
+    MeshDeformationHandler<dim>::get_matching_mesh_deformation_object () const
+    {
+      AssertThrow(has_matching_mesh_deformation_object<MeshDeformationType> (),
+                  ExcMessage("You asked MeshDeformation::MeshDeformationHandler::get_matching_mesh_deformation_object() for a "
+                             "mesh deformation object of type <" + boost::core::demangle(typeid(MeshDeformationType).name()) + "> "
+                             "that could not be found in the current model. Activate this "
+                             "mesh deformation in the input file."));
+
+      for (const auto &object_iterator : mesh_deformation_objects)
+        for (const auto &p : object_iterator.second)
+          if (Plugins::plugin_type_matches<MeshDeformationType>(*p))
+            return Plugins::get_plugin_as_type<MeshDeformationType>(*p);
+
+      // We will never get here, because we had the Assert above. Just to avoid warnings.
+      typename std::vector<std::unique_ptr<Interface<dim>>>::const_iterator mesh_def;
+      return Plugins::get_plugin_as_type<MeshDeformationType>(*(*mesh_def));
+
+    }
+
+
+    /**
+     * Return a string that consists of the names of mesh deformation models that can
+     * be selected. These names are separated by a vertical line '|' so
+     * that the string can be an input to the deal.II classes
+     * Patterns::Selection or Patterns::MultipleSelection.
+     */
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ();
+
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a mesh deformation model, register it with the functions that can
+     * declare their parameters and create these objects.
+     *
+     * @ingroup MeshDeformations
+     */
+#define ASPECT_REGISTER_MESH_DEFORMATION_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_MESH_DEFORMATION_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::MeshDeformation::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::MeshDeformation::MeshDeformationHandler<2>::register_mesh_deformation, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::MeshDeformation::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::MeshDeformation::MeshDeformationHandler<3>::register_mesh_deformation, \
+                                name, description); \
+  }
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/artificial_viscosity.h.bak b/include/aspect/mesh_refinement/artificial_viscosity.h.bak
new file mode 100644
index 00000000000..7a1ef789a3b
--- /dev/null
+++ b/include/aspect/mesh_refinement/artificial_viscosity.h.bak
@@ -0,0 +1,78 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_artificial_viscosity_h
+#define _aspect_mesh_refinement_artificial_viscosity_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on the
+     * artificial viscosity of the temperature or compositional fields.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class ArtificialViscosity : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * @copydoc Interface<dim>::execute()
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * Scaling factor for the temperature indicator.
+         */
+        double temperature_scaling_factor;
+
+        /**
+         * The scaling factors for each compositional field.
+         */
+        std::vector<double> composition_scaling_factors;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/boundary.h.bak b/include/aspect/mesh_refinement/boundary.h.bak
new file mode 100644
index 00000000000..b74aa534652
--- /dev/null
+++ b/include/aspect/mesh_refinement/boundary.h.bak
@@ -0,0 +1,81 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_boundary_h
+#define _aspect_mesh_refinement_boundary_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion that refines the
+     * mesh on selected boundaries. This is useful for cases where one wants
+     * to accurately model processes at a boundary.  Frequently, there are
+     * also strong temperature or compositional gradients at boundaries, so
+     * this refinement criterion can be redundant.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Boundary : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A set of boundary indicators marked for refinement
+         */
+        std::set<types::boundary_id> boundary_refinement_indicators;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/compaction_length.h.bak b/include/aspect/mesh_refinement/compaction_length.h.bak
new file mode 100644
index 00000000000..60199d3d1fd
--- /dev/null
+++ b/include/aspect/mesh_refinement/compaction_length.h.bak
@@ -0,0 +1,79 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_compaction_length_h
+#define _aspect_mesh_refinement_compaction_length_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on the
+     * compaction length, a typical length scale in models with melt
+     * migration. The user can specify a desired ratio between the
+     * compaction length and the size of the mesh cells, and every cell
+     * where this ratio is smaller than specified is marked for refinement.
+     * This means that there will always be a given (minimum) number of
+     * mesh cells per compaction length.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class CompactionLength : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * After cells have been marked for coarsening/refinement, apply
+         * additional criteria independent of the error estimate.
+         */
+        void
+        tag_additional_cells () const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The desired ratio between compaction length and size of the mesh cells,
+         * in other words, how many cells the mesh should have per compaction length.
+         */
+        double cells_per_compaction_length;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/composition.h.bak b/include/aspect/mesh_refinement/composition.h.bak
new file mode 100644
index 00000000000..05e100701fa
--- /dev/null
+++ b/include/aspect/mesh_refinement/composition.h.bak
@@ -0,0 +1,78 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_composition_h
+#define _aspect_mesh_refinement_composition_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on the
+     * compositional fields (if available).
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Composition : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The scaling factors that should be applied to the individual
+         * refinement indicators before merging.
+         */
+        std::vector<double> composition_scaling_factors;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/composition_approximate_gradient.h.bak b/include/aspect/mesh_refinement/composition_approximate_gradient.h.bak
new file mode 100644
index 00000000000..357560ff0e9
--- /dev/null
+++ b/include/aspect/mesh_refinement/composition_approximate_gradient.h.bak
@@ -0,0 +1,78 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_composition_approximate_gradient_h
+#define _aspect_mesh_refinement_composition_approximate_gradient_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on
+     * the approximated gradient of the compositional fields (if available).
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class CompositionApproximateGradient : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The scaling factors that should be applied to the individual
+         * refinement indicators before merging.
+         */
+        std::vector<double> composition_scaling_factors;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/composition_gradient.h.bak b/include/aspect/mesh_refinement/composition_gradient.h.bak
new file mode 100644
index 00000000000..dae9c4daf06
--- /dev/null
+++ b/include/aspect/mesh_refinement/composition_gradient.h.bak
@@ -0,0 +1,78 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_composition_gradient_h
+#define _aspect_mesh_refinement_composition_gradient_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on the
+     * gradient of the compositional fields (if available).
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class CompositionGradient : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The scaling factors that should be applied to the individual
+         * refinement indicators before merging.
+         */
+        std::vector<double> composition_scaling_factors;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/composition_threshold.h.bak b/include/aspect/mesh_refinement/composition_threshold.h.bak
new file mode 100644
index 00000000000..159112ba6df
--- /dev/null
+++ b/include/aspect/mesh_refinement/composition_threshold.h.bak
@@ -0,0 +1,76 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_composition_threshold_h
+#define _aspect_mesh_refinement_composition_threshold_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on the
+     * absolute value of the compositional fields. Every cell that contains a
+     * value exceeding a threshold given in the input file is marked for
+     * refinement.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class CompositionThreshold : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * After cells have been marked for coarsening/refinement, apply
+         * additional criteria independent of the error estimate.
+         */
+        void
+        tag_additional_cells () const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The thresholds that should be used for the individual
+         * compositional fields.
+         */
+        std::vector<double> composition_thresholds;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/density.h.bak b/include/aspect/mesh_refinement/density.h.bak
new file mode 100644
index 00000000000..3e326927d1e
--- /dev/null
+++ b/include/aspect/mesh_refinement/density.h.bak
@@ -0,0 +1,60 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_density_h
+#define _aspect_mesh_refinement_density_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on a field
+     * representing the density $\rho$ as a spatially variable function and
+     * that we compute from the solution vector (assuming the density actually
+     * depends on the solution).
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Density : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/interface.h.bak b/include/aspect/mesh_refinement/interface.h.bak
new file mode 100644
index 00000000000..69b2a480d14
--- /dev/null
+++ b/include/aspect/mesh_refinement/interface.h.bak
@@ -0,0 +1,318 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_interface_h
+#define _aspect_mesh_refinement_interface_h
+
+#include <aspect/global.h>
+#include <aspect/plugins.h>
+#include <aspect/simulator_access.h>
+
+#include <memory>
+#include <deal.II/base/table_handler.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/distributed/tria.h>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim> class Simulator;
+  template <int dim> class SimulatorAccess;
+
+
+  /**
+   * A namespace for everything to do with the decision on how to refine the
+   * mesh every few time steps.
+   *
+   * @ingroup MeshRefinement
+   */
+  namespace MeshRefinement
+  {
+
+    /**
+     * This class declares the public interface of mesh refinement plugins.
+     * Plugins have two different ways to influence adaptive refinement (and
+     * can make use of either or both):
+     *
+     * First, execute() allows the plugin to specify weights for individual
+     * cells that are then used to coarsen and refine (where larger numbers
+     * indicate a larger error).
+     *
+     * Second, after cells get flagged for coarsening and refinement (using
+     * the first approach), tag_additional_cells() is executed for each
+     * plugin. Here the plugin is free to set or clear coarsen and refine
+     * flags on any cell.
+     *
+     * Access to the data of the simulator is granted by the @p protected
+     * member functions of the SimulatorAccess class, i.e., classes
+     * implementing this interface will in general want to derive from both
+     * this Interface class as well as from the SimulatorAccess class.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion. The default implementation
+         * sets all the error indicators to zero.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        virtual
+        void
+        execute (Vector<float> &error_indicators) const;
+
+        /**
+         * After cells have been marked for coarsening/refinement, apply
+         * additional criteria independent of the error estimate. The default
+         * implementation does nothing.
+         *
+         * This function is also called during the initial global refinement
+         * cycle. At this point you do not have access to solutions,
+         * DoFHandlers, or finite element spaces. You can check if this is the
+         * case by querying this->get_dof_handler().n_dofs() == 0.
+         */
+        virtual
+        void
+        tag_additional_cells () const;
+    };
+
+
+
+
+
+
+    /**
+     * A class that manages all objects that provide functionality to refine
+     * meshes.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Destructor. Made virtual since this class has virtual member
+         * functions.
+         */
+        ~Manager () override;
+
+        /**
+         * Update all of the mesh refinement objects that have been requested
+         * in the input file. Individual mesh refinement objects may choose to
+         * implement an update function to modify object variables once per
+         * time step.
+         */
+        void
+        update () override;
+
+        /**
+         * Execute all of the mesh refinement objects that have been requested
+         * in the input file. The error indicators are then each individually
+         * normalized and merged according to the operation specified in the
+         * input file (e.g., via a plus, a maximum operation, etc).
+         */
+        virtual
+        void
+        execute (Vector<float> &error_indicators) const;
+
+        /**
+         * Apply additional refinement criteria independent of the error
+         * estimate for all of the mesh refinement objects that have been
+         * requested in the input file.
+         */
+        virtual
+        void
+        tag_additional_cells () const;
+
+        /**
+         * Declare the parameters of all known mesh refinement plugins, as
+         * well as of ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which mesh refinement objects will be created; then
+         * let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Go through the list of all mesh refinement strategies that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename MeshRefinementType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,MeshRefinementType>::value>>
+        bool
+        has_matching_mesh_refinement_strategy () const;
+
+        /**
+         * Go through the list of all mesh refinement strategies that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no mesh refinement strategy is active that matches the
+         * given type, throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename MeshRefinementType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,MeshRefinementType>::value>>
+        const MeshRefinementType &
+        get_matching_mesh_refinement_strategy () const;
+
+        /**
+         * A function that is used to register mesh refinement objects in such
+         * a way that the Manager can deal with all of them without having to
+         * know them by name. This allows the files in which individual
+         * plugins are implemented to register these plugins, rather than also
+         * having to modify the Manager class by adding the new mesh
+         * refinement class.
+         *
+         * @param name The name under which this plugin is to be called in
+         * parameter files.
+         * @param description A text description of what this model does and
+         * that will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that
+         * declares the parameters for this plugin.
+         * @param factory_function A pointer to a function that creates such a
+         * mesh refinement object and returns a pointer to it.
+         */
+        static
+        void
+        register_mesh_refinement_criterion (const std::string &name,
+                                            const std::string &description,
+                                            void (*declare_parameters_function) (ParameterHandler &),
+                                            std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcMeshRefinementNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered mesh refinement objects.");
+      private:
+        /**
+         * An enum that describes the different ways in which we can merge the
+         * results of multiple mesh refinement criteria.
+         */
+        enum MergeOperation
+        { plus, max };
+
+        /**
+         * How to merge the results of multiple mesh refinement criteria.
+         */
+        MergeOperation merge_operation;
+
+        /**
+         * Whether to normalize the individual refinement indicators to the
+         * range $[0,1]$ before merging.
+         */
+        bool normalize_criteria;
+
+        /**
+         * The scaling factors that should be applied to the individual
+         * refinement indicators before merging.
+         */
+        std::vector<double> scaling_factors;
+    };
+
+
+
+    template <int dim>
+    template <typename MeshRefinementType, typename>
+    inline
+    bool
+    Manager<dim>::has_matching_mesh_refinement_strategy () const
+    {
+      return this->template has_matching_plugin_object<MeshRefinementType>();
+    }
+
+
+
+    template <int dim>
+    template <typename MeshRefinementType, typename>
+    inline
+    const MeshRefinementType &
+    Manager<dim>::get_matching_mesh_refinement_strategy () const
+    {
+      return this->template get_matching_plugin_object<MeshRefinementType>();
+    }
+
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a mesh refinement object, register it with the
+     * aspect::MeshRefinement::Manager class.
+     *
+     * @ingroup MeshRefinement
+     */
+#define ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_MESH_REFINEMENT_CRITERION_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::MeshRefinement::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::MeshRefinement::Manager<2>::register_mesh_refinement_criterion, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::MeshRefinement::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::MeshRefinement::Manager<3>::register_mesh_refinement_criterion, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/mesh_refinement/isosurfaces.h.bak b/include/aspect/mesh_refinement/isosurfaces.h.bak
new file mode 100644
index 00000000000..452474bb62c
--- /dev/null
+++ b/include/aspect/mesh_refinement/isosurfaces.h.bak
@@ -0,0 +1,145 @@
+/*
+  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_mesh_refinement_isosurfaces_h
+#define _aspect_mesh_refinement_isosurfaces_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    namespace internal
+    {
+      enum class PropertyType
+      {
+        Temperature,
+        Composition
+      };
+
+      struct Property
+      {
+        public:
+          /**
+           * Constructor. Converts a property name into a structure containing a property type
+           * and an index. If the property contains multiple items (e.g. the property compositional field has a
+           * field index) the index referring to the particular item of that property is stored in the variable index.
+           * @param property_name The name of a property, which can be Temperature for the temperature field or
+           * the name of a compositional field listed in the parameter available_compositions.
+           * @param available_compositions A list of names of the available compositional fields.
+           */
+          Property(const std::string &property_name,
+                   const std::vector<std::string> &available_compositions);
+
+          /**
+           * The Property type of the property
+           */
+          PropertyType type;
+
+          /**
+           * An index, in case the property type contains multiple values. This is
+           * currently only used for storing which compositional field the property
+           * corresponds to.
+           */
+          unsigned int index;
+      };
+
+      struct Isosurface
+      {
+        public:
+          /**
+           * Checks whether the provided values are between the min and max value for the
+           * set properties of the isosurface. This function assumes that the order of the
+           * provided @p values matches the order in which the properties are stored.
+           *
+           * This function assumes that @p values and all the vectors in isosurfaces already
+           * have the same length.
+           */
+          bool are_all_values_in_range(const std::vector<double> &values) const;
+
+          std::vector<double> min_values;
+          std::vector<double> max_values;
+          int min_refinement;
+          int max_refinement;
+          std::vector<Property> properties;
+      };
+
+    }
+
+    /**
+     * A class that implements an Isosurfaces mesh refinement plugin. This
+     * plugin allows for setting a minimum and a maximum refinement level in
+     * a part of the model domain where a variable/property (e.g. Temperature)
+     * is between two values (e.g. two isotherms of 274K and 1600K). This is
+     * currently implemented for temperature and compositions.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Isosurfaces : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * At the beginning of each time step, update the time for the
+         * ParsedFunction.
+         */
+        void
+        update () override;
+
+        /**
+         * After cells have been marked for coarsening/refinement, apply
+         * additional criteria independent of the error estimate.
+         *
+         */
+        void
+        tag_additional_cells () const override;
+
+        /**
+         * Declare the parameters this class takes from input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+      private:
+        /**
+         * A vector of the isosurfaces used by this class.
+         */
+        std::vector<internal::Isosurface> isosurfaces;
+
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/maximum_refinement_function.h.bak b/include/aspect/mesh_refinement/maximum_refinement_function.h.bak
new file mode 100644
index 00000000000..4728cec3b83
--- /dev/null
+++ b/include/aspect/mesh_refinement/maximum_refinement_function.h.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_mesh_refinement_maximum_refinement_function_h
+#define _aspect_mesh_refinement_maximum_refinement_function_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a maximum refinement level based on a
+     * functional description provided in the input file.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class MaximumRefinementFunction : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * At the beginning of each time step, update the time for the
+         * ParsedFunction.
+         */
+        void
+        update () override;
+
+        /**
+         * After cells have been marked for coarsening/refinement, apply
+         * additional criteria independent of the error estimate.
+         *
+         */
+        void
+        tag_additional_cells () const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+
+        /**
+         * A function object representing the maximum refinement level. The
+         * function always depends on 3 variables, although in the case of the
+         * 'depth' coordinate system only the first is used to evaluate the
+         * function.
+         */
+        Functions::ParsedFunction<dim> max_refinement_level;
+
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/minimum_refinement_function.h.bak b/include/aspect/mesh_refinement/minimum_refinement_function.h.bak
new file mode 100644
index 00000000000..c7e82d266b2
--- /dev/null
+++ b/include/aspect/mesh_refinement/minimum_refinement_function.h.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_mesh_refinement_minimum_refinement_function_h
+#define _aspect_mesh_refinement_minimum_refinement_function_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a minimum refinement level based on a
+     * functional description provided in the input file.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class MinimumRefinementFunction : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * At the beginning of each time step, update the time for the
+         * ParsedFunction.
+         */
+        void
+        update () override;
+
+        /**
+         * After cells have been marked for coarsening/refinement, apply
+         * additional criteria independent of the error estimate.
+         *
+         */
+        void
+        tag_additional_cells () const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The coordinate representation to evaluate the function. Possible
+         * choices are depth, cartesian and spherical.
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+
+        /**
+         * A function object representing the minimum refinement level. The
+         * function always depends on 3 variables, although in the case of the
+         * 'depth' coordinate system only the first is used to evaluate the
+         * function.
+         */
+        Functions::ParsedFunction<dim> min_refinement_level;
+
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/nonadiabatic_temperature.h.bak b/include/aspect/mesh_refinement/nonadiabatic_temperature.h.bak
new file mode 100644
index 00000000000..2e60b9809aa
--- /dev/null
+++ b/include/aspect/mesh_refinement/nonadiabatic_temperature.h.bak
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_nonadiabatic_temperature_h
+#define _aspect_mesh_refinement_nonadiabatic_temperature_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on the excess
+     * temperature (difference between temperature and adiabatic temperature).
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class NonadiabaticTemperature : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/nonadiabatic_temperature_threshold.h.bak b/include/aspect/mesh_refinement/nonadiabatic_temperature_threshold.h.bak
new file mode 100644
index 00000000000..fcdf35846bc
--- /dev/null
+++ b/include/aspect/mesh_refinement/nonadiabatic_temperature_threshold.h.bak
@@ -0,0 +1,90 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_nonadiabatic_temperature_threshold_h
+#define _aspect_mesh_refinement_nonadiabatic_temperature_threshold_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on the
+     * nonadiabatic temperature. Every cell that contains a value
+     * exceeding a threshold given in the input file is marked for
+     * refinement.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class NonadiabaticTemperatureThreshold : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * After cells have been marked for coarsening/refinement, apply
+         * additional criteria independent of the error estimate.
+         */
+        void
+        tag_additional_cells () const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The thresholds that should be used for the nonadiabatic
+         * temperature.
+         */
+        double threshold;
+
+        /**
+         * What type of temperature anomaly should be considered when
+         * evaluating against the threshold: Only negative anomalies
+         * (subadiabatic temperatures), only positive anomalies
+         * (superadiabatic temperatures) or the absolute value of the
+         * nonadiabatic temperature.
+         */
+        enum anomaly
+        {
+          negative_only,
+          positive_only,
+          absolute_value
+        } temperature_anomaly_type;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/particle_density.h.bak b/include/aspect/mesh_refinement/particle_density.h.bak
new file mode 100644
index 00000000000..8c8b6ab39f9
--- /dev/null
+++ b/include/aspect/mesh_refinement/particle_density.h.bak
@@ -0,0 +1,69 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_particle_density_h
+#define _aspect_mesh_refinement_particle_density_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A mesh refinement criterion that computes
+     * refinement indicators based on the density
+     * of particles. In practice this plugin
+     * equilibrates the number of particles per cell,
+     * leading to fine cells in high particle density regions
+     * and coarse cells in low particle density regions.
+     * This plugin is mostly useful for models with inhomogeneous
+     * particle density, e.g. when tracking an initial interface
+     * with a high particle density, or when the spatial particle
+     * density denotes the region of interest. Additionally, this
+     * plugin tends to balance the computational load between
+     * processes in parallel computations, because the particle
+     * and mesh density is more aligned.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class ParticleDensity : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/slope.h.bak b/include/aspect/mesh_refinement/slope.h.bak
new file mode 100644
index 00000000000..bdc7cce5690
--- /dev/null
+++ b/include/aspect/mesh_refinement/slope.h.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_slope_h
+#define _aspect_mesh_refinement_slope_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion that refines the
+     * mesh with a deforming surface.  Specifically, it calculates the slope of the
+     * surface by comparing the local normal and gravity vectors.
+     * Cells with steeper slopes get refined. This is useful for cases where
+     * there is steep topography which needs to be tracked better.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Slope : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/strain_rate.h.bak b/include/aspect/mesh_refinement/strain_rate.h.bak
new file mode 100644
index 00000000000..0ae2a83c6b9
--- /dev/null
+++ b/include/aspect/mesh_refinement/strain_rate.h.bak
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_strain_rate_h
+#define _aspect_mesh_refinement_strain_rate_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on
+     * the strain rate field.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class StrainRate : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/temperature.h.bak b/include/aspect/mesh_refinement/temperature.h.bak
new file mode 100644
index 00000000000..33b7edb1e05
--- /dev/null
+++ b/include/aspect/mesh_refinement/temperature.h.bak
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_temperature_h
+#define _aspect_mesh_refinement_temperature_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on the
+     * temperature field.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Temperature : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/thermal_energy_density.h.bak b/include/aspect/mesh_refinement/thermal_energy_density.h.bak
new file mode 100644
index 00000000000..98c7fc9c10c
--- /dev/null
+++ b/include/aspect/mesh_refinement/thermal_energy_density.h.bak
@@ -0,0 +1,59 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_thermal_energy_density_h
+#define _aspect_mesh_refinement_thermal_energy_density_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on a field
+     * representing the energy density $\rho c_P T$ as a spatially variable
+     * function and that we compute from the solution vector.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class ThermalEnergyDensity : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/topography.h.bak b/include/aspect/mesh_refinement/topography.h.bak
new file mode 100644
index 00000000000..b5ec954826f
--- /dev/null
+++ b/include/aspect/mesh_refinement/topography.h.bak
@@ -0,0 +1,59 @@
+/*
+  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_topography_h
+#define _aspect_mesh_refinement_topography_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion that refines the
+     * mesh in the uppermost nodes. This is useful for cases where one wants
+     * to accurately model processes at of close to the surface of the model.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Topography : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/velocity.h.bak b/include/aspect/mesh_refinement/velocity.h.bak
new file mode 100644
index 00000000000..4e4b3dc73ed
--- /dev/null
+++ b/include/aspect/mesh_refinement/velocity.h.bak
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_velocity_h
+#define _aspect_mesh_refinement_velocity_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on the
+     * velocity field.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Velocity : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/viscosity.h.bak b/include/aspect/mesh_refinement/viscosity.h.bak
new file mode 100644
index 00000000000..cf30f892b15
--- /dev/null
+++ b/include/aspect/mesh_refinement/viscosity.h.bak
@@ -0,0 +1,60 @@
+/*
+  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_viscosity_h
+#define _aspect_mesh_refinement_viscosity_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion based on a field
+     * representing the viscosity $\eta$ as a spatially variable function and
+     * that we compute from the solution vector (assuming the viscosity
+     * actually depends on the solution).
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class Viscosity : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute this mesh refinement criterion.
+         *
+         * @param[out] error_indicators A vector that for every active cell of
+         * the current mesh (which may be a partition of a distributed mesh)
+         * provides an error indicator. This vector will already have the
+         * correct size when the function is called.
+         */
+        void
+        execute (Vector<float> &error_indicators) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/mesh_refinement/volume_of_fluid_interface.h.bak b/include/aspect/mesh_refinement/volume_of_fluid_interface.h.bak
new file mode 100644
index 00000000000..1e906fc517b
--- /dev/null
+++ b/include/aspect/mesh_refinement/volume_of_fluid_interface.h.bak
@@ -0,0 +1,73 @@
+/*
+  Copyright (C) 2016 - 2019-2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_mesh_refinement_volume_of_fluid_interface_h
+#define _aspect_mesh_refinement_volume_of_fluid_interface_h
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    /**
+     * A class that implements a mesh refinement criterion that refines the
+     * mesh near boundaries for the volume of fluid interface tracking algorithm.
+     *
+     * @ingroup MeshRefinement
+     */
+    template <int dim>
+    class VolumeOfFluidInterface: public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Mark large unrefined neighboring cells for refinement and prevent
+         * coarsening
+         */
+        void
+        tag_additional_cells() const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * If true, flag cells for coarsening if they are not flagged for refinement
+         */
+        bool strict_coarsening;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/newton.h.bak b/include/aspect/newton.h.bak
new file mode 100644
index 00000000000..f7e4fc70c46
--- /dev/null
+++ b/include/aspect/newton.h.bak
@@ -0,0 +1,358 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _aspect_newton_h
+#define _aspect_newton_h
+
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace MaterialModel
+  {
+    /**
+     * This class holds the derivatives for the Newton solver.
+     */
+    template <int dim>
+    class MaterialModelDerivatives : public AdditionalMaterialOutputs<dim>
+    {
+      public:
+        /**
+         * Constructor. Initialize the various arrays of this structure with the
+         * given number of quadrature points.
+         */
+        MaterialModelDerivatives (const unsigned int n_points);
+
+        /**
+         * The derivatives of the viscosities with respect to pressure.
+         */
+        std::vector<double> viscosity_derivative_wrt_pressure;
+
+        /**
+         * The derivatives of the viscosities with respect to strain rate.
+         */
+        std::vector<SymmetricTensor<2,dim>> viscosity_derivative_wrt_strain_rate;
+
+        /**
+         * The weights used for calculating the averages of viscosity
+         * derivatives when material averaging is applied.
+         */
+        std::vector<double> viscosity_derivative_averaging_weights;
+    };
+  }
+
+
+  namespace Newton
+  {
+    struct Parameters
+    {
+
+      /**
+       * This enum describes the type of stabilization is used
+       * for the Newton solver. None represents no stabilization,
+       * SPD represent that the resulting matrix is made Symmetric
+       * Positive Definite, symmetric represents that the matrix is
+       * only symmetrized, and PD represents that we do the same as
+       * what we do for SPD, but without the symmetrization.
+       */
+      enum Stabilization
+      {
+        none = 0,
+        symmetric = 1,
+        PD = 2,
+        SPD = symmetric | PD
+      };
+
+
+      /**
+       * A binary 'or' operator that concatenates a set of stabilization
+       * flags by returning an object that combines the bits set in each
+       * of the two arguments.
+       */
+      friend
+      Stabilization
+      operator| (const Stabilization a,
+                 const Stabilization b)
+      {
+        return static_cast<Stabilization>(
+                 static_cast<int>(a) | static_cast<int>(b));
+      }
+
+
+      /**
+       * A binary 'and' operator that takes the intersection of two sets
+       * of stabilization flags by returning an object that selects those bits
+       * that are set in both of the two arguments.
+       */
+      friend
+      Stabilization
+      operator& (const Stabilization a,
+                 const Stabilization b)
+      {
+        return static_cast<Stabilization>(
+                 static_cast<int>(a) & static_cast<int>(b));
+      }
+
+
+      /**
+       * Declare additional parameters that are needed for the Newton.
+       * solver.
+       */
+      static void declare_parameters (ParameterHandler &prm);
+
+      /**
+       * Parse additional parameters that are needed for the Newton.
+       * solver.
+       */
+      void parse_parameters (ParameterHandler &prm);
+
+      /**
+       * A scaling factor used for scaling the
+       * derivative part of the Newton Stokes solver in the assembly.
+       *
+       * The exact Newton matrix consists of the Stokes matrix plus a term
+       * that results from the linearization of the material coefficients.
+       * The scaling factor multiplies these additional terms. In a full
+       * Newton method, it would be equal to one, but it can be chosen
+       * smaller in cases where the resulting linear system has undesirable
+       * properties.
+       *
+       * If the scaling factor is zero, the resulting matrix is simply the
+       * Stokes matrix, and the resulting scheme is a defect correction
+       * (i.e., Picard iteration).
+       */
+      double              newton_derivative_scaling_factor;
+
+      Stabilization       preconditioner_stabilization;
+      Stabilization       velocity_block_stabilization;
+
+      /**
+       * Whether to use the Newton failsafe or not. If the failsafe is used, a failure
+       * of the linear solver is caught and we try to solve it again with both the
+       * preconditioner and the velocity block being stabilized with the SPD stabilization.
+       */
+      bool                use_Newton_failsafe;
+
+      /**
+       * The nonlinear tolerance at which to switch the
+       * nonlinear solver from defect correction Picard to
+       * Newton.
+       */
+      double              nonlinear_switch_tolerance;
+
+      bool                use_Eisenstat_Walker_method_for_Picard_iterations;
+      unsigned int        max_pre_newton_nonlinear_iterations;
+      unsigned int        max_newton_line_search_iterations;
+      bool                use_newton_residual_scaling_method;
+      double              maximum_linear_stokes_solver_tolerance;
+      double              SPD_safety_factor;
+    };
+
+
+    /**
+     * Get a std::string describing the stabilization type used for the
+     * preconditioner.
+     */
+    std::string
+    to_string(const Newton::Parameters::Stabilization preconditioner_stabilization);
+  }
+
+
+
+  /**
+   * A class that supports the functionality of the Newton solver.
+   */
+  template <int dim>
+  class NewtonHandler : public SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Determine, based on the run-time parameters of the current simulation,
+       * which functions need to be called in order to assemble linear systems,
+       * matrices, and right hand side vectors.
+       */
+      void set_assemblers (Assemblers::Manager<dim> &assemblers) const;
+
+      /**
+       * Create an additional material model output object that contains
+       * the additional output variables (the derivatives) needed for the
+       * Newton solver.
+       */
+      static void create_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output);
+
+      /**
+       * The object that stores the run-time parameters that control the Newton
+       * method.
+       */
+      Newton::Parameters parameters;
+  };
+
+
+  namespace Assemblers
+  {
+    /**
+     * A base class for the definition of assemblers that implement the linear
+     * system terms for the NewtonStokes solver scheme.
+     */
+    template <int dim>
+    class NewtonInterface : public aspect::Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Attach Newton outputs. Since most Newton assemblers require the
+         * material model derivatives they are created in this base class
+         * already.
+         */
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+    };
+
+    /**
+     * This class assembles the terms of the Newton Stokes preconditioner matrix for the current cell.
+     */
+    template <int dim>
+    class NewtonStokesPreconditioner : public NewtonInterface<dim>
+    {
+      public:
+        void
+        execute (internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                 internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+
+        /**
+         * Create additional material models outputs for computing viscoelastic strain rate when
+         * elasticity is enabled.
+         */
+        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+    };
+
+    /**
+     * This class assembles the terms for the matrix and right-hand-side of the incompressible
+     * Newton Stokes system for the current cell.
+     */
+    template <int dim>
+    class NewtonStokesIncompressibleTerms : public NewtonInterface<dim>
+    {
+      public:
+        void
+        execute (internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                 internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+
+        /**
+         * Create additional material models outputs for assembly of derivatives or adding additional
+         * terms to the right hand side of the Stokes equations. The latter could include viscoelastic
+         * forces or other user-defined values calculated within the material model.
+         */
+        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+    };
+
+    /**
+     * This class assembles the term that arises in the viscosity term of the Newton Stokes matrix for
+     * compressible models, because the divergence of the velocity is not longer zero.
+     */
+    template <int dim>
+    class NewtonStokesCompressibleStrainRateViscosityTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the right-hand-side term of the Newton Stokes system
+     * that is caused by the compressibility in the mass conservation equation.
+     * This function approximates this term as
+     * $- \nabla \mathbf{u} = \frac{1}{\rho} \frac{\partial rho}{\partial z} \frac{\mathbf{g}}{||\mathbf{g}||} \cdot \mathbf{u}$
+     */
+    template <int dim>
+    class NewtonStokesReferenceDensityCompressibilityTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the compressibility term of the Newton Stokes system
+     * that is caused by the compressibility in the mass conservation equation.
+     * It includes this term implicitly in the matrix,
+     * which is therefore not longer symmetric.
+     * This function approximates this term as
+     * $ - \nabla \mathbf{u} - \frac{1}{\rho} \frac{\partial rho}{\partial z} \frac{\mathbf{g}}{||\mathbf{g}||} \cdot \mathbf{u} = 0$
+     */
+    template <int dim>
+    class NewtonStokesImplicitReferenceDensityCompressibilityTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the right-hand-side term of the Newton Stokes system
+     * that is caused by the compressibility in the mass conservation equation.
+     * This function approximates this term as
+     * $ - \nabla \mathbf{u} = \frac{1}{\rho} \frac{\partial rho}{\partial p} \rho \mathbf{g} \cdot \mathbf{u}$
+     */
+    template <int dim>
+    class NewtonStokesIsentropicCompressionTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the right-hand-side term of the Stokes equation
+     * that is caused by the variable density in the mass conservation equation.
+     * This class approximates this term as
+     * $ - \nabla \cdot \mathbf{u} = \frac{1}{\rho} \frac{\partial \rho}{\partial t} + \frac{1}{\rho} \nabla \rho \cdot \mathbf{u}$
+     * where the right-hand side velocity is explicitly taken from the last timestep,
+     * and the density is taken from a compositional field of the type 'density'.
+     */
+    template <int dim>
+    class NewtonStokesProjectedDensityFieldTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/parameters.h b/include/aspect/parameters.h
index 4890ac4c987..baabeb3865a 100644
--- a/include/aspect/parameters.h
+++ b/include/aspect/parameters.h
@@ -674,7 +674,7 @@ namespace aspect
     std::vector<double>            additional_refinement_times;
     unsigned int                   adaptive_refinement_interval;
     bool                           skip_solvers_on_initial_refinement;
-    bool                           skip_setup_initial_conditions_on_initial_refinement;
+    bool                           skip_setup_initial_temperature_on_initial_refinement;
     bool                           run_postprocessors_on_initial_refinement;
     bool                           run_postprocessors_on_nonlinear_iterations;
     /**
diff --git a/include/aspect/parameters.h.bak b/include/aspect/parameters.h.bak
new file mode 100644
index 00000000000..4890ac4c987
--- /dev/null
+++ b/include/aspect/parameters.h.bak
@@ -0,0 +1,802 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_parameters_h
+#define _aspect_parameters_h
+
+#include <deal.II/base/parameter_handler.h>
+
+#include <aspect/global.h>
+#include <aspect/material_model/interface.h>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  struct CompositionalFieldDescription;
+
+  // forward declaration:
+  namespace GeometryModel
+  {
+    template <int dim>
+    class Interface;
+  }
+
+  /**
+   * A structure that holds run-time parameters. These parameters are all
+   * declared for the ParameterHandler class in the declare_parameters()
+   * member function, and read in the parse_parameters() function.
+   *
+   * Each of the member variables of this class corresponds to a parameter
+   * declared for the ParameterHandler class. Rather than duplicating the
+   * documentation of each of these parameters for the member variables here,
+   * please refer to the documentation of run-time parameters in the ASPECT
+   * manual for more information.
+   *
+   * @ingroup Simulator
+   */
+  template <int dim>
+  struct Parameters
+  {
+
+    /**
+     * A structure that contains enum values that identify the nonlinear
+     * solver in use.
+     */
+    struct NonlinearSolver
+    {
+      enum Kind
+      {
+        single_Advection_single_Stokes,
+        iterated_Advection_and_Stokes,
+        single_Advection_iterated_Stokes,
+        no_Advection_iterated_Stokes,
+        no_Advection_single_Stokes,
+        no_Advection_iterated_defect_correction_Stokes,
+        single_Advection_iterated_defect_correction_Stokes,
+        iterated_Advection_and_defect_correction_Stokes,
+        iterated_Advection_and_Newton_Stokes,
+        single_Advection_iterated_Newton_Stokes,
+        single_Advection_no_Stokes,
+        first_timestep_only_single_Stokes,
+        no_Advection_no_Stokes
+      };
+    };
+
+    static
+    bool
+    is_defect_correction(const typename NonlinearSolver::Kind &input)
+    {
+      return input == NonlinearSolver::iterated_Advection_and_Newton_Stokes ||
+             input == NonlinearSolver::single_Advection_iterated_Newton_Stokes ||
+             input == NonlinearSolver::no_Advection_iterated_defect_correction_Stokes ||
+             input == NonlinearSolver::single_Advection_iterated_defect_correction_Stokes ||
+             input == NonlinearSolver::iterated_Advection_and_defect_correction_Stokes
+             ?
+             true
+             :
+             false;
+    }
+
+    /**
+     * @brief The NullspaceRemoval struct
+     */
+    struct NullspaceRemoval
+    {
+      enum Kind
+      {
+        none = 0,
+        net_translation_x = 0x1,
+        net_translation_y = 0x2,
+        net_translation_z = 0x4,
+        net_translation   = 0x1+0x2+0x4,
+        linear_momentum_x = 0x8,
+        linear_momentum_y = 0x10,
+        linear_momentum_z = 0x20,
+        linear_momentum   = linear_momentum_x+linear_momentum_y+linear_momentum_z,
+        net_rotation      = 0x40,
+        angular_momentum  = 0x80,
+        net_surface_rotation = 0x100,
+        any_translation = net_translation+linear_momentum,
+        any_rotation = net_rotation+angular_momentum+net_surface_rotation,
+      };
+    };
+
+    /**
+     * A struct that describes the available methods to solve
+     * advected fields. This type is at the moment only used to determine how
+     * to advect each compositional field -- or what else to do with it if
+     * it doesn't satisfy an advection equation, for example if the
+     * compositional field just contains data interpolated from
+     * particles in each time step (`particles`) or if it contains
+     * data interpolated from other sources such as material outputs
+     * (`prescribed_field`), neither of which is further advected.
+     */
+    struct AdvectionFieldMethod
+    {
+      enum Kind
+      {
+        fem_field,
+        particles,
+        volume_of_fluid,
+        static_field,
+        fem_melt_field,
+        fem_darcy_field,
+        prescribed_field,
+        prescribed_field_with_diffusion
+      };
+    };
+
+    /**
+     * A struct that contains information about which
+     * formulation of the basic equations should be solved,
+     * i.e. which terms to consider, which terms to neglect, and
+     * which to simplify in different ways.
+     */
+    struct Formulation
+    {
+      /**
+       * This enum lists available formulations that
+       * determine the combined approximations made in
+       * all solved equations. 'Custom' allows to set
+       * approximations individually for single equations.
+       */
+      enum Kind
+      {
+        boussinesq_approximation,
+        anelastic_liquid_approximation,
+        isentropic_compression,
+        custom
+      };
+
+      /**
+       * This function translates an input string into the
+       * available enum options.
+       */
+      static
+      Kind
+      parse(const std::string &input)
+      {
+        if (input == "isentropic compression")
+          return Formulation::isentropic_compression;
+        else if (input == "anelastic liquid approximation")
+          return Formulation::anelastic_liquid_approximation;
+        else if (input == "Boussinesq approximation")
+          return Formulation::boussinesq_approximation;
+        else if (input == "custom")
+          return Formulation::custom;
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        return Formulation::Kind();
+      }
+
+      /**
+       * This struct contains information about the approximation
+       * made to the term containing the gradient of the density
+       * in the mass conservation equation. The different possible
+       * ways to approximate this term are described in the manual.
+       */
+      struct MassConservation
+      {
+        /**
+         * This enum lists available approximations to the
+         * density gradient term of the mass conservation equation.
+         */
+        enum Kind
+        {
+          isentropic_compression,
+          hydrostatic_compression,
+          reference_density_profile,
+          implicit_reference_density_profile,
+          incompressible,
+          projected_density_field,
+          ask_material_model
+        };
+
+        /**
+         * This function translates an input string into the
+         * available enum options.
+         */
+        static Kind
+        parse(const std::string &input)
+        {
+          if (input == "isentropic compression")
+            return Formulation::MassConservation::isentropic_compression;
+          else if (input == "hydrostatic compression")
+            return Formulation::MassConservation::hydrostatic_compression;
+          else if (input == "reference density profile")
+            return Formulation::MassConservation::reference_density_profile;
+          else if (input == "implicit reference density profile")
+            return Formulation::MassConservation::implicit_reference_density_profile;
+          else if (input == "incompressible")
+            return Formulation::MassConservation::incompressible;
+          else if (input == "projected density field")
+            return Formulation::MassConservation::projected_density_field;
+          else if (input == "ask material model")
+            return Formulation::MassConservation::ask_material_model;
+          else
+            AssertThrow(false, ExcNotImplemented());
+
+          return Formulation::MassConservation::Kind();
+        }
+      };
+
+      /**
+       * This struct contains information about the approximation
+       * made to temperature equation. The different possible
+       * ways to approximate this term are described in the manual.
+       */
+      struct TemperatureEquation
+      {
+        /**
+         * This enum lists available approximations to the
+         * density in the temperature equation.
+         */
+        enum Kind
+        {
+          real_density,
+          reference_density_profile
+        };
+
+        /**
+         * This function translates an input string into the
+         * available enum options.
+         */
+        static
+        Kind
+        parse(const std::string &input)
+        {
+          if (input == "real density")
+            return Formulation::TemperatureEquation::real_density;
+          else if (input == "reference density profile")
+            return Formulation::TemperatureEquation::reference_density_profile;
+          else
+            AssertThrow(false, ExcNotImplemented());
+
+          return Formulation::TemperatureEquation::Kind();
+        }
+      };
+    };
+
+    /**
+     * A struct to provide the setting for "Stabilization method"
+     */
+    struct AdvectionStabilizationMethod
+    {
+      enum Kind
+      {
+        entropy_viscosity,
+        supg
+      };
+
+      /**
+       * This function translates an input string into the
+       * available enum options.
+       */
+      static
+      Kind
+      parse(const std::string &input)
+      {
+        if (input == "entropy viscosity")
+          return entropy_viscosity;
+        else if (input == "SUPG")
+          return supg;
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        return Kind();
+      }
+
+      static std::string get_options_string()
+      {
+        return "entropy viscosity|SUPG";
+      }
+    };
+
+    /**
+     * A struct to provide the different choices of limiters for
+     * the discontinuous Galerkin method.
+     */
+    struct DGLimiterType
+    {
+      enum Kind
+      {
+        bound_preserving,
+        WENO,
+        none
+      };
+
+      static
+      Kind
+      parse(const std::string &input)
+      {
+        if (input == "bound preserving")
+          return bound_preserving;
+        else if (input == "WENO")
+          return WENO;
+        else if (input == "none")
+          return none;
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        return Kind();
+      }
+
+      static const std::string pattern()
+      {
+        return "bound preserving|WENO|none";
+      }
+    };
+
+    /**
+     * This enum represents the different choices for the linear solver
+     * for the Stoke system. See @p stokes_solver_type.
+     */
+    struct StokesSolverType
+    {
+      enum Kind
+      {
+        block_amg,
+        direct_solver,
+        block_gmg,
+        default_solver
+      };
+
+      static const std::string pattern()
+      {
+        return "default solver|block AMG|direct solver|block GMG";
+      }
+
+      static Kind
+      parse(const std::string &input)
+      {
+        if (input == "block AMG")
+          return block_amg;
+        else if (input == "direct solver")
+          return direct_solver;
+        else if (input == "block GMG")
+          return block_gmg;
+        else if (input == "default solver")
+          return default_solver;
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        return Kind();
+      }
+    };
+
+    /**
+     * This enum represents the different choices for the Krylov method
+     * used in the cheap GMG Stokes solve.
+     */
+    struct StokesKrylovType
+    {
+      enum Kind
+      {
+        gmres,
+        idr_s
+      };
+
+      static const std::string pattern()
+      {
+        return "GMRES|IDR(s)";
+      }
+
+      static Kind
+      parse(const std::string &input)
+      {
+        if (input == "GMRES")
+          return gmres;
+        else if (input == "IDR(s)")
+          return idr_s;
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        return Kind();
+      }
+    };
+
+    /**
+     * This enum represents the different choices for the reaction solver.
+     * See @p reaction_solver_type.
+     */
+    struct ReactionSolverType
+    {
+      enum Kind
+      {
+        ARKode,
+        fixed_step
+      };
+
+      static const std::string pattern()
+      {
+        return "ARKode|fixed step";
+      }
+
+      static Kind
+      parse(const std::string &input)
+      {
+        if (input == "ARKode")
+          return ARKode;
+        else if (input == "fixed step")
+          return fixed_step;
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        return Kind();
+      }
+    };
+
+    /**
+     * Use the struct aspect::CompositionalFieldDescription
+     */
+    using CompositionalFieldDescription DEAL_II_DEPRECATED = aspect::CompositionalFieldDescription;
+
+    /**
+     * Constructor. Fills the values of member functions from the given
+     * parameter object.
+     *
+     * @param prm The parameter object that has previously been filled with
+     * content by reading an input file.
+     *
+     * @param mpi_communicator The MPI communicator we will use for this
+     * simulation. We need this when calling parse_parameters() so that we can
+     * verify some of the input arguments.
+     */
+    Parameters (ParameterHandler &prm,
+                const MPI_Comm mpi_communicator);
+
+    /**
+     * Declare the run-time parameters this class takes, and call the
+     * respective <code>declare_parameters</code> functions of the namespaces
+     * that describe geometries, material models, etc.
+     *
+     * @param prm The object in which the run-time parameters are to be
+     * declared.
+     */
+    static
+    void declare_parameters (ParameterHandler &prm);
+
+    /**
+     * Read run-time parameters from an object that has previously parsed an
+     * input file. This reads all parameters that do not require knowledge of
+     * the geometry model we use. There is a separate function
+     * parse_geometry_dependent_parameters() that is called as soon as the
+     * geometry object has been created and that can translate between the
+     * symbolic names for boundary components that the geometry model
+     * publishes and the boundary indicators used internally.
+     *
+     * @param prm The object from which to obtain the run-time parameters.
+     *
+     * @param mpi_communicator The MPI communicator we will use for this
+     * simulation. We need this when calling parse_parameters() so that we can
+     * verify some of the input arguments.
+     */
+    void parse_parameters (ParameterHandler &prm,
+                           const MPI_Comm mpi_communicator);
+
+    /**
+     * Read those run-time parameters from a ParameterHandler object that
+     * depend on knowing which geometry object we use. This function
+     * complements parse_parameters() but is only called once the geometry
+     * object has been created. This function is separate because we allow the
+     * use of symbolic names in defining which boundary components have which
+     * boundary conditions, and the names one can specify there are not
+     * available until after the geometry object has been created.
+     *
+     * This function is called from the GeometryModel::create_geometry()
+     * function.
+     *
+     * @param prm The object from which to obtain the run-time parameters.
+     * @param geometry_model The geometry model that provides boundary names
+     * etc.
+     */
+    void parse_geometry_dependent_parameters (ParameterHandler &prm,
+                                              const GeometryModel::Interface<dim> &geometry_model);
+
+    /**
+     * @name Global parameters
+     * @{
+     */
+    typename NonlinearSolver::Kind nonlinear_solver;
+
+    typename AdvectionStabilizationMethod::Kind advection_stabilization_method;
+    double                         nonlinear_tolerance;
+    bool                           resume_computation;
+    double                         start_time;
+    double                         end_time;
+    double                         CFL_number;
+    double                         maximum_time_step;
+    double                         maximum_relative_increase_time_step;
+    double                         maximum_first_time_step;
+    bool                           use_artificial_viscosity_smoothing;
+    bool                           use_conduction_timestep;
+    bool                           convert_to_years;
+    std::string                    output_directory;
+    double                         surface_pressure;
+    double                         adiabatic_surface_temperature;
+    unsigned int                   timing_output_frequency;
+    unsigned int                   max_nonlinear_iterations;
+    unsigned int                   max_nonlinear_iterations_in_prerefinement;
+    bool                           use_operator_splitting;
+    std::string                    world_builder_file;
+
+    /**
+     * @}
+     */
+
+    /**
+     * @name section: Solver parameters
+     * @{
+     */
+    double                         temperature_solver_tolerance;
+    double                         composition_solver_tolerance;
+
+    // subsection: Advection solver parameters
+    unsigned int                   advection_gmres_restart_length;
+
+    // subsection: Stokes solver parameters
+    bool                           use_direct_stokes_solver;
+    bool                           use_bfbt;
+    typename StokesSolverType::Kind stokes_solver_type;
+    typename StokesKrylovType::Kind stokes_krylov_type;
+    unsigned int                    idr_s_parameter;
+
+    double                         linear_stokes_solver_tolerance;
+    unsigned int                   n_cheap_stokes_solver_steps;
+    unsigned int                   n_expensive_stokes_solver_steps;
+    double                         linear_solver_A_block_tolerance;
+    bool                           use_full_A_block_preconditioner;
+    bool                           force_nonsymmetric_A_block_solver;
+    double                         linear_solver_S_block_tolerance;
+    unsigned int                   stokes_gmres_restart_length;
+
+    // subsection: AMG parameters
+    std::string                    AMG_smoother_type;
+    unsigned int                   AMG_smoother_sweeps;
+    double                         AMG_aggregation_threshold;
+    bool                           AMG_output_details;
+
+    // subsection: Operator splitting parameters
+    typename ReactionSolverType::Kind reaction_solver_type;
+    double                         ARKode_relative_tolerance;
+    double                         reaction_time_step;
+    unsigned int                   reaction_steps_per_advection_step;
+
+    // subsection: Diffusion solver parameters
+    double                         diffusion_length_scale;
+
+    /**
+     * @}
+     */
+
+    /**
+     * @name Formulation settings
+     * @{
+     */
+
+    /**
+     * This variable determines which of the several ways to formulate the
+     * equations ASPECT will solve.
+     * Common formulations are the Boussinesq or Anelastic Liquid
+     * Approximations (BA, ALA). ASPECT's original formulation is termed
+     * 'isentropic compression'. 'Custom' allows
+     * to set the approximations individually per equation.
+     */
+    typename Formulation::Kind formulation;
+
+    /**
+     * Determines how to formulate the mass conservation equation in ASPECT.
+     * Common approximations are 'incompressible' or 'reference density profile'.
+     * ASPECT's original formulation is termed 'isentropic compression'. See the
+     * manual for more details about the individual terms.
+     */
+    typename Formulation::MassConservation::Kind formulation_mass_conservation;
+
+    /**
+     * Determines how to formulate the density in the temperature equation
+     * in ASPECT. Possible approximations are 'reference density profile' or
+     * 'real density'.
+     */
+    typename Formulation::TemperatureEquation::Kind formulation_temperature_equation;
+
+    /**
+     * This variable determines whether additional terms related to elastic forces
+     * are added to the Stokes equation.
+     */
+    bool                           enable_elasticity;
+
+    /**
+     * @}
+     */
+
+    /**
+     * @name Parameters that have to do with terms in the model
+     * @{
+     */
+    bool                           include_melt_transport;
+    bool                           enable_additional_stokes_rhs;
+    bool                           enable_prescribed_dilation;
+
+    /**
+     * Map from boundary id to a pair "components", "traction boundary type",
+     * where components is of the format "[x][y][z]" and the traction type is
+     * mapped to one of the plugins of traction boundary conditions (e.g.
+     * "function")
+     */
+    std::map<types::boundary_id, std::pair<std::string,std::string>> prescribed_traction_boundary_indicators;
+
+    /**
+     * A set of boundary ids on which the boundary_heat_flux objects
+     * will be applied.
+     */
+    std::set<types::boundary_id> fixed_heat_flux_boundary_indicators;
+
+    /**
+     * Selection of operations to perform to remove nullspace from velocity
+     * field.
+     */
+    typename NullspaceRemoval::Kind nullspace_removal;
+    /**
+     * @}
+     */
+
+    /**
+     * @name Parameters that have to do with mesh refinement
+     * @{
+     */
+    unsigned int                   initial_global_refinement;
+    unsigned int                   initial_adaptive_refinement;
+    double                         refinement_fraction;
+    double                         coarsening_fraction;
+    bool                           adapt_by_fraction_of_cells;
+    unsigned int                   min_grid_level;
+    std::vector<double>            additional_refinement_times;
+    unsigned int                   adaptive_refinement_interval;
+    bool                           skip_solvers_on_initial_refinement;
+    bool                           skip_setup_initial_conditions_on_initial_refinement;
+    bool                           run_postprocessors_on_initial_refinement;
+    bool                           run_postprocessors_on_nonlinear_iterations;
+    /**
+     * @}
+     */
+
+    /**
+     * @name Parameters that have to do with the stabilization of transport
+     * equations
+     * @{
+     */
+    unsigned int                   stabilization_alpha;
+    std::vector<double>            stabilization_c_R;
+    std::vector<double>            stabilization_beta;
+    double                         stabilization_gamma;
+    double                         discontinuous_penalty;
+    typename DGLimiterType::Kind   limiter_for_discontinuous_temperature_solution;
+    std::vector<typename DGLimiterType::Kind> limiter_for_discontinuous_composition_solution;
+    double                         global_temperature_max_preset;
+    double                         global_temperature_min_preset;
+    std::vector<double>            global_composition_max_preset;
+    std::vector<double>            global_composition_min_preset;
+    double                         temperature_KXRCF_indicator_threshold;
+    std::vector<double>            composition_KXRCF_indicator_threshold;
+    double                         WENO_linear_weight;
+
+    std::vector<std::string>       compositional_fields_with_disabled_boundary_entropy_viscosity;
+    /**
+     * @}
+     */
+
+    /**
+     * @name Parameters that have to do with checkpointing
+     * @{
+     */
+    int                            checkpoint_time_secs;
+    int                            checkpoint_steps;
+    /**
+     * @}
+     */
+
+    /**
+     * @name Parameters that have to do with spatial discretizations
+     * @{
+     */
+    unsigned int                   stokes_velocity_degree;
+    bool                           use_locally_conservative_discretization;
+    bool                           use_equal_order_interpolation_for_stokes;
+    bool                           use_discontinuous_temperature_discretization;
+    std::vector<bool>              use_discontinuous_composition_discretization;
+    bool                           have_discontinuous_composition_discretization;
+    unsigned int                   temperature_degree;
+    unsigned int                   composition_degree;
+    std::string                    pressure_normalization;
+    MaterialModel::MaterialAveraging::AveragingOperation material_averaging;
+
+    /**
+     * @}
+     */
+
+    /**
+     * @name Parameters that have to do with the temperature field
+     * @{
+     */
+
+    typename AdvectionFieldMethod::Kind temperature_method;
+
+    /**
+     * @}
+     */
+
+    /**
+     * @name Parameters that have to do with compositional fields
+     * @{
+     */
+    unsigned int                   n_compositional_fields;
+    std::vector<std::string>       names_of_compositional_fields;
+    std::vector<aspect::CompositionalFieldDescription>  composition_descriptions;
+    unsigned int                   n_chemical_compositions;
+    std::vector<unsigned int>      chemical_composition_indices;
+
+    /**
+     * A vector that contains the advection field method for every compositional
+     * field. Consequently the vector has n_compositional_fields entries.
+     */
+    std::vector<typename AdvectionFieldMethod::Kind> compositional_field_methods;
+
+    /**
+     * Map from compositional index to a pair "particle property", "component",
+     * where particle property is a string that can be mapped to one of the
+     * particle property plugins.
+     * Component denotes which component of the particle property is to be
+     * mapped in case there are several. Therefore, it is optional to specify
+     * the component and it is of the format "[0][1][2]". In case no component
+     * is specified it defaults to 0.
+     */
+    std::map<unsigned int, std::pair<std::string,unsigned int>> mapped_particle_properties;
+
+    std::vector<unsigned int>      normalized_fields;
+    /**
+     * @}
+     */
+    /**
+     * @name Parameters that have to do with mesh deformation
+     * @{
+     */
+    bool                           mesh_deformation_enabled;
+    /**
+     * @}
+     */
+
+    /**
+     * @name Parameters that have to do with volume of fluid calculations
+     * @{
+     */
+    bool                           volume_of_fluid_tracking_enabled;
+    /**
+     * @}
+     */
+
+
+  };
+
+}
+#endif
diff --git a/include/aspect/particle/generator/ascii_file.h.bak b/include/aspect/particle/generator/ascii_file.h.bak
new file mode 100644
index 00000000000..035ef0a7d24
--- /dev/null
+++ b/include/aspect/particle/generator/ascii_file.h.bak
@@ -0,0 +1,80 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_generator_ascii_file_h
+#define _aspect_particle_generator_ascii_file_h
+
+#include <aspect/particle/generator/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      /**
+       * Generate a distribution of particles that is determined by the
+       * coordinates given in an ascii data file.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      class AsciiFile : public Interface<dim>
+      {
+        public:
+          /**
+           * Reads in a file and generate a set of particles at the prescribed
+           * positions.
+           *
+           * @param [in,out] particle_handler The particle handler into which
+           * the generated particles should be inserted.
+           */
+          void
+          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
+
+          // avoid -Woverloaded-virtual
+          // TODO: remove this using directive once the following deprecated
+          // function in the interface class has been removed:
+          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
+          using Generator::Interface<dim>::generate_particles;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          std::string data_directory;
+          std::string data_filename;
+      };
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/generator/interface.h.bak b/include/aspect/particle/generator/interface.h.bak
new file mode 100644
index 00000000000..13508fa1c41
--- /dev/null
+++ b/include/aspect/particle/generator/interface.h.bak
@@ -0,0 +1,251 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_generator_interface_h
+#define _aspect_particle_generator_interface_h
+
+#include <aspect/particle/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/particles/particle.h>
+#include <deal.II/particles/generators.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/exceptions.h>
+
+#include <random>
+
+#include <map>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    /**
+     * A namespace in which we define everything that has to do with defining
+     * the particle generation.
+     *
+     * @ingroup ParticleGenerators
+     */
+    namespace Generator
+    {
+      using namespace dealii::Particles;
+      using dealii::Particles::Particle;
+
+      /**
+       * Exception denoting a division by zero.
+       */
+      DeclExceptionMsg (ExcParticlePointNotInDomain,
+                        "You requested to generate a particle at a position that "
+                        "is not owned by this process, therefore the "
+                        "Particle::Generator::Interface::generate_particle() function "
+                        "refused to create it. You can circumvent this error message "
+                        "by catching the ExcParticlePointNotInDomain exception and "
+                        "do whatever you think is appropriate in this case.");
+
+      /**
+       * Abstract base class used for classes that generate particles.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      class Interface : public SimulatorAccess<dim>, public ParticleInterfaceBase
+      {
+        public:
+          virtual
+          void
+          initialize () override;
+
+          /**
+           * Generate particles. Every derived class
+           * has to decide on the method and number of particles to generate,
+           * for example using input parameters declared in their
+           * declare_parameters and parse_parameters functions. This function
+           * should generate the particles and associate them to their according
+           * cells by inserting them into a multimap between cell and particle.
+           * This map becomes very large if the particle count per process
+           * is large, so we hand it over by reference instead of returning
+           * the multimap.
+           *
+           * @param [in,out] particles A multimap between cells and their
+           * particles. This map will be filled in this function.
+           */
+          DEAL_II_DEPRECATED
+          virtual
+          void
+          generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles);
+
+          /**
+           * Generate particles. Every derived class
+           * has to decide on the method and number of particles to generate,
+           * for example using input parameters declared in their
+           * declare_parameters and parse_parameters functions. This function
+           * should generate the particles and insert them into @p particle_handler
+           * by calling its respective functions.
+           *
+           * @param [in,out] particle_handler The particle handler into which
+           * the generated particles should be inserted.
+           */
+          virtual
+          void
+          generate_particles(Particles::ParticleHandler<dim> &particle_handler);
+
+          /**
+           * Generate one particle in the given cell. This function's main purpose
+           * is to provide functionality to fill up cells with too few particles
+           * after refinement. Of course it can also be utilized by derived classes
+           * to generate the initial particle distribution.
+           */
+          std::pair<Particles::internal::LevelInd,Particle<dim>>
+          generate_particle (const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell,
+                             const types::particle_index id);
+
+        protected:
+          /**
+           * Generate a particle at the specified position and with the
+           * specified id. Many derived classes use this functionality,
+           * therefore it is implemented here to avoid duplication.
+           * In case the position is not in the local domain this function
+           * throws an exception of type ExcParticlePointNotInDomain, which
+           * can be caught in the calling plugin.
+           *
+           * @deprecated: This function uses an old return type and is deprecated.
+           * Use the insert_particle_at_position() function below instead.
+           */
+          DEAL_II_DEPRECATED
+          std::pair<Particles::internal::LevelInd,Particle<dim>>
+          generate_particle(const Point<dim> &position,
+                            const types::particle_index id) const;
+
+          /**
+           * Generate a particle at the specified position and with the
+           * specified id and insert it into the @p particle_handler.
+           * Many derived classes use this functionality,
+           * therefore it is implemented here to avoid duplication.
+           * In case the position is not in the local domain this function
+           * throws an exception of type ExcParticlePointNotInDomain, which
+           * can be caught in the calling plugin. Note that since the cell
+           * in which the particle is generated is not known, it has to be
+           * found, which is an expensive operation.
+           *
+           * @param position Position of the particle.
+           * @param id The id of the particle.
+           * @param particle_handler The particle handler into which the particle
+           * should be inserted.
+           *
+           * @return An iterator to the inserted particle. If the position was
+           * not in the local domain, an iterator to particle_handler.end() is
+           * returned.
+           */
+          Particles::ParticleIterator<dim>
+          insert_particle_at_position(const Point<dim> &position,
+                                      const types::particle_index id,
+                                      Particles::ParticleHandler<dim> &particle_handler) const;
+
+          /**
+           * Random number generator. For reproducibility of tests it is
+           * initialized in the constructor with a constant.
+           */
+          std::mt19937            random_number_generator;
+      };
+
+      /**
+       * Register a particle generator so that it can be selected from
+       * the parameter file.
+       *
+       * @param name A string that identifies the particle generator
+       * @param description A text description of what this generator does and that
+       * will be listed in the documentation of the parameter file.
+       * @param declare_parameters_function A pointer to a function that can be
+       * used to declare the parameters that this particle generator wants to read
+       * from input files.
+       * @param factory_function A pointer to a function that can create an
+       * object of this particle generator.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      void
+      register_particle_generator (const std::string &name,
+                                   const std::string &description,
+                                   void (*declare_parameters_function) (ParameterHandler &),
+                                   std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+      /**
+       * A function that given the name of a model returns a pointer to an
+       * object that describes it. Ownership of the pointer is transferred to
+       * the caller.
+       *
+       * The model object returned is not yet initialized and has not
+       * read its runtime parameters yet.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      std::unique_ptr<Interface<dim>>
+      create_particle_generator (ParameterHandler &prm);
+
+      /**
+       * Declare the runtime parameters of the registered particle generators.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      void
+      declare_parameters (ParameterHandler &prm);
+
+
+      /**
+       * For the current plugin subsystem, write a connection graph of all of the
+       * plugins we know about, in the format that the
+       * programs dot and neato understand. This allows for a visualization of
+       * how all of the plugins that ASPECT knows about are interconnected, and
+       * connect to other parts of the ASPECT code.
+       *
+       * @param output_stream The stream to write the output to.
+       */
+      template <int dim>
+      void
+      write_plugin_graph (std::ostream &output_stream);
+
+
+      /**
+       * Given a class name, a name, and a description for the parameter file
+       * for a particle generator, register it with the functions that
+       * can declare their parameters and create these objects.
+       *
+       * @ingroup ParticleGenerators
+       */
+#define ASPECT_REGISTER_PARTICLE_GENERATOR(classname, name, description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_PARTICLE_GENERATOR_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Generator::Interface<2>,classname<2 >> \
+    dummy_ ## classname ## _2d (&aspect::Particle::Generator::register_particle_generator<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Generator::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::Particle::Generator::register_particle_generator<3>, \
+                                name, description); \
+  }
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/generator/probability_density_function.h.bak b/include/aspect/particle/generator/probability_density_function.h.bak
new file mode 100644
index 00000000000..5fa3cafd224
--- /dev/null
+++ b/include/aspect/particle/generator/probability_density_function.h.bak
@@ -0,0 +1,128 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_generator_probability_density_function_h
+#define _aspect_particle_generator_probability_density_function_h
+
+#include <aspect/particle/generator/interface.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      /**
+       * Exception
+       */
+      template <int dim>
+      DeclException1 (ProbabilityFunctionNegative,
+                      Point<dim>,
+                      << "Your probability density function in the particle generator "
+                      "returned a negative probability density for the following position: "
+                      << arg1 << ". Please check your function expression.");
+
+
+      /**
+       * Generates a random distribution of particles over the simulation
+       * domain. The particle density is determined by a user-defined
+       * probability density function in the parameter file. This is done using
+       * a "roulette wheel" style selection. Every cell is weighted by the value
+       * of the provided function at its center multiplied with the cell
+       * volume. Then a map between the accumulated cell weight
+       * and the cell index of the current cell is constructed. Consequently,
+       * a random number between zero and the global integral of the
+       * probability density function uniquely defines one particular cell.
+       * Afterwards, every process generates n_global_particles random numbers,
+       * but only generates a particle if it is the owner of the active cell
+       * that is associated with this random number.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      class ProbabilityDensityFunction : public Interface<dim>
+      {
+        public:
+          /**
+           * Generate a set of particles in the given
+           * particle handler. The particle density is set by an analytically
+           * prescribed density function that is set as an input parameter.
+           *
+           * @param [in,out] particle_handler The particle handler into which
+           * the generated particles should be inserted.
+           */
+          void
+          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
+
+          // avoid -Woverloaded-virtual
+          // TODO: remove this using directive once the following deprecated
+          // function in the interface class has been removed:
+          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
+          using Generator::Interface<dim>::generate_particles;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Number of particles to create
+           */
+          types::particle_index n_particles;
+
+          /**
+           * If true, particle numbers per cell are calculated randomly
+           * according to their respective probability density. If false,
+           * first determine how many particles each cell should have based
+           * on the integral of the density over each of the cells, and then
+           * once we know how many particles we want on each cell, choose their
+           * locations randomly within each cell.
+           */
+          bool random_cell_selection;
+
+          /**
+           * The seed for the random number generator that controls the
+           * particle generation.
+           */
+          unsigned int random_number_seed;
+
+          /**
+           * A function object representing the particle location probability
+           * density.
+           */
+          Functions::ParsedFunction<dim> function;
+      };
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/generator/quadrature_points.h.bak b/include/aspect/particle/generator/quadrature_points.h.bak
new file mode 100644
index 00000000000..bbf6ad5882a
--- /dev/null
+++ b/include/aspect/particle/generator/quadrature_points.h.bak
@@ -0,0 +1,63 @@
+/*
+ Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_generator_quadrature_points_h
+#define _aspect_particle_generator_quadrature_points_h
+
+#include <aspect/particle/generator/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      /**
+       * Generates particles at the quadrature points of each active cell of the triangulation.
+       * Here, Gauss quadrature of degree, (velocity_degree + 1), is used similarly to the assembly of the
+       * Stokes matrix.
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      class QuadraturePoints : public Interface<dim>
+      {
+        public:
+          /**
+           * Generates particles at the quadrature points of each active cell of the triangulation.
+           * Here, Gauss quadrature of degree, (velocity_degree + 1), is used similarly to the assembly of the
+           * Stokes matrix.
+           *
+           * @param [in,out] particle_handler The particle handler into which
+           * the generated particles should be inserted.
+           */
+          void
+          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
+
+          // avoid -Woverloaded-virtual
+          // TODO: remove this using directive once the following deprecated
+          // function in the interface class has been removed:
+          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
+          using Generator::Interface<dim>::generate_particles;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/generator/random_uniform.h.bak b/include/aspect/particle/generator/random_uniform.h.bak
new file mode 100644
index 00000000000..a69fab590d1
--- /dev/null
+++ b/include/aspect/particle/generator/random_uniform.h.bak
@@ -0,0 +1,98 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_generator_random_uniform_h
+#define _aspect_particle_generator_random_uniform_h
+
+#include <aspect/particle/generator/probability_density_function.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      /**
+       * Generate random uniform distribution of particles over entire simulation domain.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      class RandomUniform : public Interface<dim>
+      {
+        public:
+          /**
+           * Generate a set of particles in the given
+           * particle handler. The particles are generated
+           * with a uniform density in the whole domain.
+           *
+           * @param [in,out] particle_handler The particle handler into which
+           * the generated particles should be inserted.
+           */
+          void
+          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
+
+          // avoid -Woverloaded-virtual
+          // TODO: remove this using directive once the following deprecated
+          // function in the interface class has been removed:
+          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
+          using Generator::Interface<dim>::generate_particles;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Number of particles to create
+           */
+          types::particle_index n_particles;
+
+          /**
+           * If true, particle numbers per cell are calculated randomly
+           * according to their respective probability density. If false,
+           * first determine how many particles each cell should have based
+           * on the integral of the density over each of the cells, and then
+           * once we know how many particles we want on each cell, choose their
+           * locations randomly within each cell.
+           */
+          bool random_cell_selection;
+
+          /**
+           * The seed for the random number generator that controls the
+           * particle generation.
+           */
+          unsigned int random_number_seed;
+      };
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/generator/reference_cell.h.bak b/include/aspect/particle/generator/reference_cell.h.bak
new file mode 100644
index 00000000000..2721c62e4de
--- /dev/null
+++ b/include/aspect/particle/generator/reference_cell.h.bak
@@ -0,0 +1,94 @@
+/*
+ Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_generator_reference_cell_h
+#define _aspect_particle_generator_reference_cell_h
+
+#include <aspect/particle/generator/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      /**
+       * Generate a uniform distribution of particles in the unit cell and transforms
+       * each of the particles back to real region in the model domain.
+       * Uniform here means the particles will be generated with
+       * an equal spacing in each spatial dimension.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      class ReferenceCell : public Interface<dim>
+      {
+        public:
+          /**
+           * Generate a uniform distribution of particles in the unit cell and transforms
+           * each of the particles back to real region in the model domain.
+           * Uniform here means the particles will be generated with
+           * an equal spacing in each spatial dimension.
+           *
+           * @param [in,out] particle_handler The particle handler into which
+           * the generated particles should be inserted.
+           */
+          void
+          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
+
+          // avoid -Woverloaded-virtual
+          // TODO: remove this using directive once the following deprecated
+          // function in the interface class has been removed:
+          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
+          using Generator::Interface<dim>::generate_particles;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Calculates particle position in the unit cell.
+           *
+           * @return A vector container of points each of size dim.
+           */
+          std::vector<Point<dim>> generate_particle_positions_in_unit_cell();
+
+          /**
+           * Number of particles to create for each spatial dimension as
+           * specified within the parameter file.
+           */
+          std::vector<unsigned int> number_of_particles;
+      };
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/generator/uniform_box.h.bak b/include/aspect/particle/generator/uniform_box.h.bak
new file mode 100644
index 00000000000..1ba743d6675
--- /dev/null
+++ b/include/aspect/particle/generator/uniform_box.h.bak
@@ -0,0 +1,99 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_generator_uniform_box_h
+#define _aspect_particle_generator_uniform_box_h
+
+#include <aspect/particle/generator/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      /**
+       * Generate a uniform distribution of particles in a box region in the
+       * model domain. Uniform here means the particles will be generated with
+       * an equal spacing in each spatial dimension. Note that in order
+       * to produce a regular distribution the number of generated
+       * particles might not exactly match the one specified in the
+       * input file.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      class UniformBox : public Interface<dim>
+      {
+        public:
+          /**
+           * Generate a uniformly randomly distributed set of particles in a
+           * box-like subdomain of the global domain.
+           *
+           * @param [in,out] particle_handler The particle handler into which
+           * the generated particles should be inserted.
+           */
+          void
+          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
+
+          // avoid -Woverloaded-virtual
+          // TODO: remove this using directive once the following deprecated
+          // function in the interface class has been removed:
+          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
+          using Generator::Interface<dim>::generate_particles;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Number of initial particles to create.
+           */
+          types::particle_index n_particles;
+
+          /**
+           * The minimum coordinates of the particle region, i.e. one corner of
+           * the n-dimensional box region in which particles are generated.
+           */
+          Point<dim> P_min;
+
+          /**
+           * The maximum coordinates of the particle region, i.e. the opposite
+           * corner of the n-dimensional box region in which particles are
+           * generated.
+           */
+          Point<dim> P_max;
+      };
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/generator/uniform_radial.h.bak b/include/aspect/particle/generator/uniform_radial.h.bak
new file mode 100644
index 00000000000..b403b950674
--- /dev/null
+++ b/include/aspect/particle/generator/uniform_radial.h.bak
@@ -0,0 +1,124 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_generator_uniform_radial_h
+#define _aspect_particle_generator_uniform_radial_h
+
+#include <aspect/particle/generator/interface.h>
+
+#include <array>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      using namespace dealii;
+
+      /**
+       * Generate a uniform radial distribution of particles over the entire
+       * simulation domain. Uniform here means
+       * the particles will be generated with an equal spacing in
+       * each spherical spatial dimension, i.e. the particles are
+       * created at coordinates that increase linearly with equal
+       * spacing in radius, colatitude and longitude around a
+       * certain center point. Note that in order
+       * to produce a regular distribution the number of generated
+       * particles might not exactly match the one specified in the
+       * input file.
+       *
+       * @ingroup ParticleGenerators
+       */
+      template <int dim>
+      class UniformRadial : public Interface<dim>
+      {
+        public:
+          /**
+           * Generate a uniformly distributed set of particles in a
+           * circular or spherical subdomain of the global domain.
+           *
+           * @param [in,out] particle_handler The particle handler into which
+           * the generated particles should be inserted.
+           */
+          void
+          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
+
+          // avoid -Woverloaded-virtual
+          // TODO: remove this using directive once the following deprecated
+          // function in the interface class has been removed:
+          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
+          using Generator::Interface<dim>::generate_particles;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+
+          /**
+           * The minimum spherical coordinates of the particle region, i.e.
+           * the first radius, colatitude and longitude from the given
+           * center position P_center where particles are generated.
+           */
+          std::array<double,dim> P_min;
+
+          /**
+           * The maximum spherical coordinates of the particle region, i.e.
+           * the last radius, colatitude and longitude from the given
+           * center position P_center where particles are generated.
+           */
+          std::array<double,dim> P_max;
+
+          /**
+           * The center of the particle region. Defaults to the origin.
+           */
+          Point<dim> P_center;
+
+          /**
+           * The number of radial layers of particles that will be generated.
+           * In particular this parameter determines the radial spacing between
+           * particle layers as Pmax[0] - P_min[0] / radial_layers.
+           */
+          unsigned int radial_layers;
+
+          /**
+           * Number of particles to create in total. To preserve the equal
+           * spacing (in spherical coordinates) between particles, the number
+           * of actually generated
+           * particles can differ slightly from this number.
+           */
+          types::particle_index n_particles;
+      };
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/integrator/euler.h.bak b/include/aspect/particle/integrator/euler.h.bak
new file mode 100644
index 00000000000..ad93cb6febc
--- /dev/null
+++ b/include/aspect/particle/integrator/euler.h.bak
@@ -0,0 +1,101 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_integrator_euler_h
+#define _aspect_particle_integrator_euler_h
+
+#include <aspect/particle/integrator/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      /**
+       * Explicit Euler scheme integrator.
+       * This requires only one step per integration, and doesn't involve any
+       * additional integration steps (it is a one-step method), therefore
+       * no data needs to be stored between subsequent steps.
+       *
+       * @ingroup ParticleIntegrators
+       */
+      template <int dim>
+      class Euler : public Interface<dim>, public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Perform an integration step of moving the particles of one cell
+           * by the specified timestep dt. This function implements an explicit
+           * Euler integration scheme.
+           *
+           * @param [in] begin_particle An iterator to the first particle to be moved.
+           * @param [in] end_particle An iterator to the last particle to be moved.
+           * @param [in] old_velocities The velocities at t_n, i.e. before the
+           * particle movement, for all particles between @p begin_particle
+           * and @p end_particle at their current position.
+           * @param [in] velocities The velocities at the particle positions
+           * at t_{n+1}, i.e. after the particle movement. Note that this is
+           * the velocity at the old positions, but at the new time. It is the
+           * responsibility of this function to compute the new location of
+           * the particles.
+           * @param [in] dt The length of the integration timestep.
+           */
+          void
+          local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
+                               const std::vector<Tensor<1,dim>> &old_velocities,
+                               const std::vector<Tensor<1,dim>> &velocities,
+                               const double dt) override;
+
+          /**
+           * Return a list of boolean values indicating which solution vectors
+           * are required for the integration. The first entry indicates if
+           * the particle integrator requires the solution vector at the old
+           * old time (k-1), the second entry indicates if the particle integrator
+           * requires the solution vector at the old time (k), and the third entry
+           * indicates if the particle integrator requires the solution vector
+           * at the new time (k+1).
+           *
+           * The forward Euler integrator only requires the solution vector at the
+           * old time (k), and consequently returns `{false, true, false}`.
+          */
+          std::array<bool, 3> required_solution_vectors() const override;
+
+          /**
+           * We need to tell the property manager how many intermediate properties this integrator requires,
+           * so that it can allocate sufficient space for each particle. However, the integrator is not
+           * created at the time the property manager is set up and we can not reverse the order of creation,
+           * because the integrator needs to know where to store its properties, which requires the property manager
+           * to be finished setting up properties. Luckily the number of properties is constant, so we can make it
+           * a static property of this class. Therefore, the property manager can access this variable even
+           * before any object is constructed.
+           *
+           * The forward Euler integrator does not need any intermediate storage space.
+           */
+          static const unsigned int n_integrator_properties = 0;
+      };
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/integrator/interface.h.bak b/include/aspect/particle/integrator/interface.h.bak
new file mode 100644
index 00000000000..dab8f945625
--- /dev/null
+++ b/include/aspect/particle/integrator/interface.h.bak
@@ -0,0 +1,242 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_integrator_interface_h
+#define _aspect_particle_integrator_interface_h
+
+#include <aspect/particle/interface.h>
+#include <aspect/global.h>
+
+#include <deal.II/particles/particle.h>
+#include <deal.II/particles/particle_handler.h>
+#include <deal.II/base/parameter_handler.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      using namespace dealii;
+      using namespace dealii::Particles;
+
+      /**
+       * An abstract class defining virtual methods for performing integration
+       * of particle paths through the simulation velocity field.
+       *
+       * @ingroup ParticleIntegrators
+       */
+      template <int dim>
+      class Interface : public ParticleInterfaceBase
+      {
+        public:
+          /**
+           * Perform an integration step of moving the particles of one cell
+           * by the specified timestep dt. Implementations of this function
+           * must update the particle location. Between calls to this function
+           * the velocity at the updated particle positions is evaluated and
+           * passed as input argument during the next call.
+           *
+           * @param [in] begin_particle An iterator to the first particle to be moved.
+           * @param [in] end_particle An iterator to the last particle to be moved.
+           * @param [in] old_velocities The velocities at t_n, i.e. before the
+           * particle movement, for all particles between @p begin_particle
+           * and @p end_particle at their current position.
+           * @param [in] velocities The velocities at the particle positions
+           * at t_{n+1}, i.e. after the particle movement. Note that this is
+           * the velocity at the old positions, but at the new time. It is the
+           * responsibility of this function to compute the new location of
+           * the particles.
+           * @param [in] dt The length of the integration timestep.
+           */
+          virtual
+          void
+          local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
+                               const std::vector<Tensor<1,dim>> &old_velocities,
+                               const std::vector<Tensor<1,dim>> &velocities,
+                               const double dt) = 0;
+
+          /**
+           * This function is called at the end of every integration step.
+           * In case of multi-step integrators it signals the beginning of a
+           * new integration step. The default implementation always returns
+           * false, which is ok for single-step integration methods.
+           *
+           * @return This function returns true if the integrator requires
+           * another integration step. The particle world will continue
+           * to start new integration steps until this function returns false.
+           */
+          virtual bool new_integration_step();
+
+          /**
+           * Return data length of the integration related data required for
+           * communication in terms of number of bytes. When data about
+           * particles is transported from one processor to another, or stored
+           * on disk for snapshots, integrators get the chance to store
+           * whatever information they need with each particle. This function
+           * returns how many pieces of additional information a concrete
+           * integrator class needs to store for each particle.
+           *
+           * @return The number of bytes required to store the relevant
+           * integrator data for one particle.
+           */
+          virtual std::size_t get_data_size() const;
+
+          /**
+           * Return a list of boolean values indicating which solution vectors
+           * are required for the integration. The first entry indicates if
+           * the particle integrator requires the solution vector at the old
+           * old time (k-1), the second entry indicates if the particle integrator
+           * requires the solution vector at the old time (k), and the third entry
+           * indicates if the particle integrator requires the solution vector
+           * at the new time (k+1).
+          */
+          virtual std::array<bool, 3> required_solution_vectors() const = 0;
+
+          /**
+           * Read integration related data for a particle specified by particle_id
+           * from the data array. This function is called after transferring
+           * a particle to the local domain during an integration step.
+           *
+           * @param [in] data A pointer into the data array. The pointer
+           * marks the position where this function starts reading.
+           * @param [in] particle An iterator pointing to the particle to read
+           * the data for.
+           * @return The updated position of the pointer into the data array.
+           * The return value is @p data advanced by get_data_size() bytes.
+           */
+          virtual
+          const void *
+          read_data(const typename ParticleHandler<dim>::particle_iterator &particle,
+                    const void *data);
+
+          /**
+           * Write integration related data to a vector for a particle
+           * specified by particle_id. This function is called in cases where
+           * particles leave the local domain during an integration step to
+           * transfer this data to another process.
+           *
+           * @param [in] particle An iterator pointing to the particle to
+           * write the data for.
+           * @param [in] data A pointer into the array of integrator data.
+           * @return The updated position of the pointer into the data array.
+           * The return value is @p data advanced by get_data_size() bytes.
+           */
+          virtual
+          void *
+          write_data(const typename ParticleHandler<dim>::particle_iterator &particle,
+                     void *data) const;
+      };
+
+
+      /**
+       * Return a list of names (separated by '|') of possible integrator
+       * classes for particles.
+       */
+      std::string
+      integrator_object_names ();
+
+
+      /**
+       * Register a particle integrator so that it can be selected from
+       * the parameter file.
+       *
+       * @param name A string that identifies the particle integrator
+       * @param description A text description of what this integrator does and that
+       * will be listed in the documentation of the parameter file.
+       * @param declare_parameters_function A pointer to a function that can be
+       * used to declare the parameters that this particle integrator wants to read
+       * from input files.
+       * @param factory_function A pointer to a function that can create an
+       * object of this particle integrator.
+       *
+       * @ingroup ParticleIntegrators
+       */
+      template <int dim>
+      void
+      register_particle_integrator (const std::string &name,
+                                    const std::string &description,
+                                    void (*declare_parameters_function) (ParameterHandler &),
+                                    std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+      /**
+       * A function that given the name of a model returns a pointer to an
+       * object that describes it. Ownership of the pointer is transferred to
+       * the caller.
+       *
+       * The model object returned is not yet initialized and has not
+       * read its runtime parameters yet.
+       *
+       * @ingroup ParticleIntegrators
+       */
+      template <int dim>
+      std::unique_ptr<Interface<dim>>
+      create_particle_integrator (ParameterHandler &prm);
+
+
+      /**
+       * Declare the runtime parameters of the registered particle integrators.
+       *
+       * @ingroup ParticleIntegrators
+       */
+      template <int dim>
+      void
+      declare_parameters (ParameterHandler &prm);
+
+
+      /**
+       * For the current plugin subsystem, write a connection graph of all of the
+       * plugins we know about, in the format that the
+       * programs dot and neato understand. This allows for a visualization of
+       * how all of the plugins that ASPECT knows about are interconnected, and
+       * connect to other parts of the ASPECT code.
+       *
+       * @param output_stream The stream to write the output to.
+       */
+      template <int dim>
+      void
+      write_plugin_graph (std::ostream &output_stream);
+
+      /**
+       * Given a class name, a name, and a description for the parameter file
+       * for a particle integrator, register it with the functions that
+       * can declare their parameters and create these objects.
+       *
+       * @ingroup ParticleIntegrators
+       */
+#define ASPECT_REGISTER_PARTICLE_INTEGRATOR(classname, name, description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_PARTICLE_INTEGRATOR_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Integrator::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::Particle::Integrator::register_particle_integrator<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Integrator::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::Particle::Integrator::register_particle_integrator<3>, \
+                                name, description); \
+  }
+    }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/particle/integrator/rk_2.h.bak b/include/aspect/particle/integrator/rk_2.h.bak
new file mode 100644
index 00000000000..2a307def6d8
--- /dev/null
+++ b/include/aspect/particle/integrator/rk_2.h.bak
@@ -0,0 +1,155 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_integrator_rk_2_h
+#define _aspect_particle_integrator_rk_2_h
+
+#include <aspect/particle/integrator/interface.h>
+
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      /**
+       * Runge Kutta second order integrator.
+       * This scheme requires storing the original location in the particle properties.
+       *
+       * @ingroup ParticleIntegrators
+       */
+      template <int dim>
+      class RK2 : public Interface<dim>, public SimulatorAccess<dim>
+      {
+        public:
+          RK2();
+
+          /**
+           * Look up where the RK2 data is stored. Done once and cached to
+           * avoid repeated lookups.
+           */
+          void
+          initialize () override;
+
+          /**
+           * Perform an integration step of moving the particles of one cell
+           * by the specified timestep dt. This function implements a
+           * second-order accurate Runge-Kutta integration scheme.
+           *
+           * @param [in] begin_particle An iterator to the first particle to be moved.
+           * @param [in] end_particle An iterator to the last particle to be moved.
+           * @param [in] old_velocities The velocities at t_n, i.e. before the
+           * particle movement, for all particles between @p begin_particle
+           * and @p end_particle at their current position.
+           * @param [in] velocities The velocities at the particle positions
+           * at t_{n+1}, i.e. after the particle movement. Note that this is
+           * the velocity at the old positions, but at the new time. It is the
+           * responsibility of this function to compute the new location of
+           * the particles.
+           * @param [in] dt The length of the integration timestep.
+           */
+          void
+          local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
+                               const std::vector<Tensor<1,dim>> &old_velocities,
+                               const std::vector<Tensor<1,dim>> &velocities,
+                               const double dt) override;
+
+          /**
+           * This function is called at the end of every integration step.
+           * For the current class it will either increment the step variable
+           * and return true to request another integration step, or reset the
+           * step variable to 0 and return false if we are already in step 2.
+           *
+           * @return This function returns true if the integrator requires
+           * another integration step. The particle integration will continue
+           * to start new integration steps until this function returns false.
+           */
+          bool new_integration_step() override;
+
+          /**
+           * Return a list of boolean values indicating which solution vectors
+           * are required for the integration. The first entry indicates if
+           * the particle integrator requires the solution vector at the old
+           * old time (k-1), the second entry indicates if the particle integrator
+           * requires the solution vector at the old time (k), and the third entry
+           * indicates if the particle integrator requires the solution vector
+           * at the new time (k+1).
+           *
+           * The RK2 integrator requires the solution vector at the
+           * old time (k) for the first integration step, and the solution
+           * vector at both the old and new time for the second integration step
+           * (if higher_order_in_time is set to true).
+           */
+          std::array<bool, 3> required_solution_vectors() const override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+          /**
+           * We need to tell the property manager how many intermediate properties this integrator requires,
+           * so that it can allocate sufficient space for each particle. However, the integrator is not
+           * created at the time the property manager is set up and we can not reverse the order of creation,
+           * because the integrator needs to know where to store its properties, which requires the property manager
+           * to be finished setting up properties. Luckily the number of properties is constant, so we can make it
+           * a static property of this class. Therefore, the property manager can access this variable even
+           * before any object is constructed.
+           *
+           * The Runge-Kutta 2 integrator requires a single point with dim components.
+           */
+          static const unsigned int n_integrator_properties = dim;
+
+        private:
+          /**
+           * The current integration step, i.e for RK2 a number that is either
+           * 0 or 1.
+           */
+          unsigned int integrator_substep;
+
+          /**
+           * The location of the RK2 data that is stored in the particle properties.
+           */
+          unsigned int property_index_old_location;
+
+          /**
+           * Whether to evaluate old and current velocity to compute a solution
+           * that is higher order accurate in time.
+           */
+          bool higher_order_in_time;
+      };
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/integrator/rk_4.h.bak b/include/aspect/particle/integrator/rk_4.h.bak
new file mode 100644
index 00000000000..ae27e8446bc
--- /dev/null
+++ b/include/aspect/particle/integrator/rk_4.h.bak
@@ -0,0 +1,135 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_integrator_rk_4_h
+#define _aspect_particle_integrator_rk_4_h
+
+#include <aspect/particle/integrator/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      /**
+       * Runge Kutta fourth order integrator. This scheme requires
+       * storing the original location and intermediate k1, k2, k3
+       * values in the particle properties.
+       *
+       * @ingroup ParticleIntegrators
+       */
+      template <int dim>
+      class RK4 : public Interface<dim>, public SimulatorAccess<dim>
+      {
+        public:
+          RK4();
+
+          /**
+           * Look up where the RK4 data is stored. Done once and cached to
+           * avoid repeated lookups.
+           */
+          void
+          initialize () override;
+
+          /**
+           * Perform an integration step of moving the particles of one cell
+           * by the specified timestep dt. This class implements a Runge-Kutta
+           * integration scheme that is fourth order accurate
+           * in space.
+           *
+           * @param [in] begin_particle An iterator to the first particle to be moved.
+           * @param [in] end_particle An iterator to the last particle to be moved.
+           * @param [in] old_velocities The velocities at t_n, i.e. before the
+           * particle movement, for all particles between @p begin_particle
+           * and @p end_particle at their current position.
+           * @param [in] velocities The velocities at the particle positions
+           * at t_{n+1}, i.e. after the particle movement. Note that this is
+           * the velocity at the old positions, but at the new time. It is the
+           * responsibility of this function to compute the new location of
+           * the particles.
+           * @param [in] dt The length of the integration timestep.
+           */
+          void
+          local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
+                               const std::vector<Tensor<1,dim>> &old_velocities,
+                               const std::vector<Tensor<1,dim>> &velocities,
+                               const double dt) override;
+
+          /**
+           * This function is called at the end of every integration step.
+           * For the current class it will either increment the step variable
+           * and return true to request another integration step, or reset the
+           * step variable to 0 and return false if we are already in step 4.
+           *
+           * @return This function returns true if the integrator requires
+           * another integration step. The particle integration will continue
+           * to start new integration steps until this function returns false.
+           */
+          bool new_integration_step() override;
+
+          /**
+           * Return a list of boolean values indicating which solution vectors
+           * are required for the integration. The first entry indicates if
+           * the particle integrator requires the solution vector at the old
+           * old time (k-1), the second entry indicates if the particle integrator
+           * requires the solution vector at the old time (k), and the third entry
+           * indicates if the particle integrator requires the solution vector
+           * at the new time (k+1).
+           *
+           * The RK4 integrator requires the solution vector at the
+           * old time (k) for the first integration step, the solution
+           * vector at both the old and new time for the second
+           * and third integration steps and the solution vector at the
+           * new time (k+1) for the fourth integration step.
+           */
+          std::array<bool, 3> required_solution_vectors() const override;
+
+          /**
+           * We need to tell the property manager how many intermediate properties this integrator requires,
+           * so that it can allocate sufficient space for each particle. However, the integrator is not
+           * created at the time the property manager is set up and we can not reverse the order of creation,
+           * because the integrator needs to know where to store its properties, which requires the property manager
+           * to be finished setting up properties. Luckily the number of properties is constant, so we can make it
+           * a static property of this class. Therefore, the property manager can access this variable even
+           * before any object is constructed.
+           *
+           * The Runge-Kutta 4 integrator requires 4 tensors with dim components each.
+           */
+          static const unsigned int n_integrator_properties = 4*dim;
+
+        private:
+          /**
+           * The current integration step, i.e. for RK4 a number between 0
+           * and 3.
+           */
+          unsigned int integrator_substep;
+
+          /**
+           * The location of the 4 RK4 data fields stored in the particle properties.
+           */
+          std::array<unsigned int,4> property_indices;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/interface.h.bak b/include/aspect/particle/interface.h.bak
new file mode 100644
index 00000000000..04ab2a319ba
--- /dev/null
+++ b/include/aspect/particle/interface.h.bak
@@ -0,0 +1,63 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_interface_h
+#define _aspect_particle_interface_h
+
+#include <aspect/plugins.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    /**
+     * A base class defining methods and member variables
+     * shared along all the particle plugins. This includes the generator,
+     * integrator, interpolator and the property classes.
+     *
+     * @ingroup Particle
+     */
+    class ParticleInterfaceBase : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * @brief Set which particle world the plugin belongs to.
+         *
+         * @param particle_world_index The index of the particle world this plugin belongs to.
+         */
+        void set_particle_world_index(unsigned int particle_world_index);
+
+        /**
+         * @brief Gets which particle world the plugin belong to.
+         */
+        unsigned int get_particle_world_index() const;
+
+      private:
+        /**
+         * Stores the index to the particle world, to which the plugin belongs.
+         */
+        unsigned int particle_world_index;
+    };
+
+  }
+}
+
+
+#endif
diff --git a/include/aspect/particle/interpolator/bilinear_least_squares.h.bak b/include/aspect/particle/interpolator/bilinear_least_squares.h.bak
new file mode 100644
index 00000000000..fb4f34b640d
--- /dev/null
+++ b/include/aspect/particle/interpolator/bilinear_least_squares.h.bak
@@ -0,0 +1,103 @@
+/*
+ Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_interpolator_bilinear_least_squares_h
+#define _aspect_particle_interpolator_bilinear_least_squares_h
+
+#include <aspect/particle/interpolator/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <aspect/particle/interpolator/cell_average.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      /**
+       * Evaluate the properties of all particles of the given cell
+       * using a least squares projection onto the set of bilinear
+       * (or, in 3d, trilinear) functions.
+       *
+       * @ingroup ParticleInterpolators
+       */
+      template <int dim>
+      class BilinearLeastSquares : public Interface<dim>, public aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Return the cell-wise evaluated properties of the bilinear least squares function at the positions.
+           */
+          std::vector<std::vector<double>>
+          properties_at_points(const ParticleHandler<dim> &particle_handler,
+                               const std::vector<Point<dim>> &positions,
+                               const ComponentMask &selected_properties,
+                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
+
+          // avoid -Woverloaded-virtual:
+          using Interface<dim>::properties_at_points;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * A component mask that determines whether a limiting scheme is
+           * used for each interpolated property. The limiting scheme
+           * prevents overshoot and undershoot of interpolated particle
+           * properties based on the local max and min of the particle
+           * properties in that cell (i.e. the interpolated properties
+           * will never exxceed the max and min of the properties on the particles).
+           */
+          ComponentMask use_linear_least_squares_limiter;
+
+          /**
+           * A component mask that determines whether a boundary condition
+           * can be extrapolated for use in the limiting scheme. If boundary
+           * extrapolation is enabled for a given property index, then the
+           * limiter should be as well. Boundary extrapolation should help
+           * the accuracy of properties that are smooth, although it can allow
+           * undershoots and overshoots to occur if used with characteristic
+           * functions or functions with discontinuities near a model boundary.
+           */
+          ComponentMask use_boundary_extrapolation;
+
+          /**
+           * Fallback method if there are too few particles in a cell to
+           * perform a bilinear least squares interpolation.
+           */
+          Interpolator::CellAverage<dim> fallback_interpolator;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/interpolator/cell_average.h.bak b/include/aspect/particle/interpolator/cell_average.h.bak
new file mode 100644
index 00000000000..38bdcb2fd98
--- /dev/null
+++ b/include/aspect/particle/interpolator/cell_average.h.bak
@@ -0,0 +1,80 @@
+/*
+ Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_interpolator_cell_average_h
+#define _aspect_particle_interpolator_cell_average_h
+
+#include <aspect/particle/interpolator/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      /**
+       * Return the averaged properties of all particles on the given cell.
+       *
+       * @ingroup ParticleInterpolators
+       */
+      template <int dim>
+      class CellAverage : public Interface<dim>, public aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Return the cell-wise averaged properties of all particles of the cell containing the
+           * given positions.
+           */
+          std::vector<std::vector<double>>
+          properties_at_points(const ParticleHandler<dim> &particle_handler,
+                               const std::vector<Point<dim>> &positions,
+                               const ComponentMask &selected_properties,
+                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
+
+          // avoid -Woverloaded-virtual:
+          using Interface<dim>::properties_at_points;
+
+          /**
+           * @copydoc Interface<dim>::declare_parameters()
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * @copydoc Interface<dim>::parse_parameters()
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * By default, every cell needs to contain particles to use this interpolator
+           * plugin. If this parameter is set to true, cells are allowed to have no particles,
+           * in which case the interpolator will return 0 for the cell's properties.
+           */
+          bool allow_cells_without_particles;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/interpolator/harmonic_average.h.bak b/include/aspect/particle/interpolator/harmonic_average.h.bak
new file mode 100644
index 00000000000..78effa04340
--- /dev/null
+++ b/include/aspect/particle/interpolator/harmonic_average.h.bak
@@ -0,0 +1,80 @@
+/*
+ Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_interpolator_harmonic_average_h
+#define _aspect_particle_interpolator_harmonic_average_h
+
+#include <aspect/particle/interpolator/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      /**
+       * Return the harmonic averaged properties of all particles on the given cell.
+       *
+       * @ingroup ParticleInterpolators
+       */
+      template <int dim>
+      class HarmonicAverage : public Interface<dim>, public aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Return the cell-wise harmonic averaged properties of all particles of the cell containing the
+           * given positions.
+           */
+          std::vector<std::vector<double>>
+          properties_at_points(const ParticleHandler<dim> &particle_handler,
+                               const std::vector<Point<dim>> &positions,
+                               const ComponentMask &selected_properties,
+                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
+
+          // avoid -Woverloaded-virtual:
+          using Interface<dim>::properties_at_points;
+
+          /**
+           * @copydoc Interface<dim>::declare_parameters()
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * @copydoc Interface<dim>::parse_parameters()
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * By default, every cell needs to contain particles to use this interpolator
+           * plugin. If this parameter is set to true, cells are allowed to have no particles,
+           * in which case the interpolator will return 0 for the cell's properties.
+           */
+          bool allow_cells_without_particles;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/interpolator/interface.h.bak b/include/aspect/particle/interpolator/interface.h.bak
new file mode 100644
index 00000000000..6d52b743356
--- /dev/null
+++ b/include/aspect/particle/interpolator/interface.h.bak
@@ -0,0 +1,179 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_interpolator_interface_h
+#define _aspect_particle_interpolator_interface_h
+
+#include <aspect/particle/interface.h>
+#include <aspect/global.h>
+
+#include <deal.II/particles/particle.h>
+#include <deal.II/particles/particle_handler.h>
+#include <deal.II/base/point.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/distributed/tria.h>
+#include <deal.II/fe/component_mask.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      using namespace dealii;
+      using namespace dealii::Particles;
+
+      /**
+       * An abstract class defining virtual methods for performing
+       * interpolation of particle properties to arbitrary points.
+       *
+       * @ingroup ParticleInterpolators
+       */
+      template <int dim>
+      class Interface : public ParticleInterfaceBase
+      {
+        public:
+          /**
+           * Perform an interpolation of the properties of the particles in
+           * this cell onto a vector of positions in this cell.
+           * Implementations of this function must return a vector of a vector
+           * of doubles with as many entries as positions in @p positions.
+           * Each entry is a vector with as many entries as there are  particle
+           * properties in this computation.
+           * All in @p selected_properties selected components
+           * will be filled with computed properties, all other components
+           * are not filled (or filled with invalid values).
+           *
+           * @param [in] particle_handler Reference to the particle handler
+           * that allows accessing the particles in the domain.
+           * @param [in] positions The vector of positions where the properties
+           * should be evaluated.
+           * @param [in] selected_properties A component mask that determines
+           * which particle properties are interpolated in this function.
+           * @param [in] cell An iterator to the cell containing the
+           * positions.
+           * @return A vector with as many entries as @p positions. Each entry
+           * is a vector of interpolated particle properties at this position.
+           * This property vector has as many entries as there are particle
+           * properties, however entries that have not been selected in
+           * @p selected_properties are filled with signalling NaNs.
+           */
+          virtual
+          std::vector<std::vector<double>>
+          properties_at_points(const ParticleHandler<dim> &particle_handler,
+                               const std::vector<Point<dim>> &positions,
+                               const ComponentMask &selected_properties,
+                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const = 0;
+      };
+
+
+      /**
+       * Return a list of names (separated by '|') of possible interpolator
+       * classes for particles.
+       */
+      std::string
+      interpolator_object_names ();
+
+
+      /**
+       * Register a particle interpolator so that it can be selected from
+       * the parameter file.
+       *
+       * @param name A string that identifies the particle interpolator
+       * @param description A text description of what this interpolator does and that
+       * will be listed in the documentation of the parameter file.
+       * @param declare_parameters_function A pointer to a function that can be
+       * used to declare the parameters that this particle interpolator wants to read
+       * from input files.
+       * @param factory_function A pointer to a function that can create an
+       * object of this particle interpolator.
+       *
+       * @ingroup ParticleInterpolators
+       */
+      template <int dim>
+      void
+      register_particle_interpolator (const std::string &name,
+                                      const std::string &description,
+                                      void (*declare_parameters_function) (ParameterHandler &),
+                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+      /**
+       * A function that given the name of a model returns a pointer to an
+       * object that describes it. Ownership of the pointer is transferred to
+       * the caller.
+       *
+       * The model object returned is not yet initialized and has not
+       * read its runtime parameters yet.
+       *
+       * @ingroup ParticleInterpolators
+       */
+      template <int dim>
+      std::unique_ptr<Interface<dim>>
+      create_particle_interpolator (ParameterHandler &prm);
+
+
+      /**
+       * Declare the runtime parameters of the registered particle interpolators.
+       *
+       * @ingroup ParticleInterpolators
+       */
+      template <int dim>
+      void
+      declare_parameters (ParameterHandler &prm);
+
+
+      /**
+       * For the current plugin subsystem, write a connection graph of all of the
+       * plugins we know about, in the format that the
+       * programs dot and neato understand. This allows for a visualization of
+       * how all of the plugins that ASPECT knows about are interconnected, and
+       * connect to other parts of the ASPECT code.
+       *
+       * @param output_stream The stream to write the output to.
+       */
+      template <int dim>
+      void
+      write_plugin_graph (std::ostream &output_stream);
+
+      /**
+       * Given a class name, a name, and a description for the parameter file
+       * for a particle interpolator, register it with the functions that
+       * can declare their parameters and create these objects.
+       *
+       * @ingroup ParticleInterpolators
+       */
+#define ASPECT_REGISTER_PARTICLE_INTERPOLATOR(classname, name, description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_PARTICLE_INTERPOLATOR_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Interpolator::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::Particle::Interpolator::register_particle_interpolator<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Interpolator::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::Particle::Interpolator::register_particle_interpolator<3>, \
+                                name, description); \
+  }
+    }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/particle/interpolator/nearest_neighbor.h.bak b/include/aspect/particle/interpolator/nearest_neighbor.h.bak
new file mode 100644
index 00000000000..feacd4d12f6
--- /dev/null
+++ b/include/aspect/particle/interpolator/nearest_neighbor.h.bak
@@ -0,0 +1,81 @@
+/*
+ Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_interpolator_nearest_neighbor_h
+#define _aspect_particle_interpolator_nearest_neighbor_h
+
+#include <aspect/particle/interpolator/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      /**
+       * Return the properties of the nearest particle within the current cell, or
+       * in a neighboring cell if this one is empty.
+       *
+       * @ingroup ParticleInterpolators
+       */
+      template <int dim>
+      class NearestNeighbor : public Interface<dim>, public aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Return the properties of the particles nearest to the given positions within the same cell,
+           * or adjacent cells if none is present in same cell.
+           */
+          std::vector<std::vector<double>>
+          properties_at_points(const ParticleHandler<dim> &particle_handler,
+                               const std::vector<Point<dim>> &positions,
+                               const ComponentMask &selected_properties,
+                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
+
+          // avoid -Woverloaded-virtual:
+          using Interface<dim>::properties_at_points;
+
+          /**
+           * @copydoc Interface<dim>::declare_parameters()
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * @copydoc Interface<dim>::parse_parameters()
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * By default, every cell needs to contain particles to use this interpolator
+           * plugin. If this parameter is set to true, cells are allowed to have no particles,
+           * in which case the interpolator will return 0 for the cell's properties.
+           */
+          bool allow_cells_without_particles;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/interpolator/quadratic_least_squares.h.bak b/include/aspect/particle/interpolator/quadratic_least_squares.h.bak
new file mode 100644
index 00000000000..416c705b122
--- /dev/null
+++ b/include/aspect/particle/interpolator/quadratic_least_squares.h.bak
@@ -0,0 +1,117 @@
+/*
+ Copyright (C) 2019 - 2022-2020 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_interpolator_quadratic_least_squares_h
+#define _aspect_particle_interpolator_quadratic_least_squares_h
+
+#include <aspect/particle/interpolator/interface.h>
+#include <aspect/particle/interpolator/cell_average.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      /**
+       * Return the properties of all particles of the given cell by using a least squares
+       * projection onto the space of quadratic functions.
+       * For more details on the implementation and properties of this plugin see:
+       * Mack Gregory and Elbridge Gerry Puckett (2020),
+       * "Improving the Accuracy and Efficiency of Hybrid Finite
+       * Element / Particle-In-Cell Methods for Modeling Geologic Processes",
+       * Abstract Submission ID# 743654
+       * https://agu.confex.com/agu/fm20/prelim.cgi/Paper/743654
+       * Session: A002 - Addressing Challenges for the Next Generation of Earth System Models
+       * Submitted to 2020 AGU Fall Meeting, San Francisco, CA Dec. 7-11, 2020
+       *
+       * @ingroup ParticleInterpolators
+       */
+      template <int dim>
+      class QuadraticLeastSquares : public Interface<dim>, public aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Return the cell-wise evaluated properties of the quadratic least squares function at the positions.
+           */
+          std::vector<std::vector<double>>
+          properties_at_points(const ParticleHandler<dim> &particle_handler,
+                               const std::vector<Point<dim>> &positions,
+                               const ComponentMask &selected_properties,
+                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
+
+          // avoid -Woverloaded-virtual:
+          using Interface<dim>::properties_at_points;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Use the cell average interpolator in case the quadratic least
+           * squares interpolator fails due to a lack of particles.
+           */
+          Interpolator::CellAverage<dim> fallback_interpolator;
+
+          /**
+           * Enables a limiting scheme that prevents overshoot and
+           * undershoot of interpolated particles based upon the range
+           * of property values found in the area of the cell.
+           */
+          ComponentMask use_quadratic_least_squares_limiter;
+
+          /**
+           * Enables a linear extrapolation of boundary values for the limiting scheme
+           */
+          ComponentMask use_boundary_extrapolation;
+
+          /**
+           * Calculate the value of the interpolation function at a given position
+           */
+          double evaluate_interpolation_function(const Vector<double> &coefficients, const Point<dim> &position) const;
+
+          /**
+           * Update the bounds of where the plane reaches by checking whether each of the critical points
+           * are in the cell and evauating their value.
+           */
+          std::pair<double, double> get_interpolation_bounds(const dealii::Vector<double> &coefficients) const;
+
+          /*
+           * Find all points that may contain the minimum or maximum values of the interpolation in the cell.
+           */
+          std::vector<dealii::Point<dim>> get_critical_points(const dealii::Vector<double> &coefficients) const;
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/composition.h.bak b/include/aspect/particle/property/composition.h.bak
new file mode 100644
index 00000000000..a115a811e3a
--- /dev/null
+++ b/include/aspect/particle/property/composition.h.bak
@@ -0,0 +1,98 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_composition_h
+#define _aspect_particle_property_composition_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * Implementation of a plugin in which the particle
+       * property is defined by the compositional fields in
+       * the model. This can be used to track solid composition
+       * evolution over time.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class Composition : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties over time.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * The pressure and temperature need the values of their variables.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/cpo_bingham_average.h.bak b/include/aspect/particle/property/cpo_bingham_average.h.bak
new file mode 100644
index 00000000000..a2ffd097350
--- /dev/null
+++ b/include/aspect/particle/property/cpo_bingham_average.h.bak
@@ -0,0 +1,224 @@
+/*
+ Copyright (C) 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_cpo_bingham_average_h
+#define _aspect_particle_property_cpo_bingham_average_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/particle/property/crystal_preferred_orientation.h>
+#include <aspect/simulator_access.h>
+
+#include <array>
+#include <random>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+
+      /**
+       * Computes the Bingham average of the CPO particle properties.
+       * See https://courses.eas.ualberta.ca/eas421/lecturepages/orientation.html for more info.
+       *
+       * The layout of the data vector per particle is the following (note that for this plugin the following dim's are always 3):
+       * 1 averaged a axis of olivine       -> 3 (dim) doubles, starts at:
+       *                                         data_position + 1,
+       * 2 eigenvalues of a axis of olivine -> 3 (dim) doubles, starts at:
+       *                                         data_position + 4,
+       * 3 averaged b axis of olivine       -> 3 (dim) doubles, starts at:
+       *                                         data_position + 7,
+       * 4 eigenvalues of b axis of olivine -> 3 (dim) doubles, starts at:
+       *                                         data_position + 10,
+       * 5 averaged c axis of olivine       -> 3 (dim) doubles, starts at:
+       *                                         data_position + 13,
+       * 6 eigenvalues of c axis of olivine -> 3 (dim) doubles, starts at:
+       *                                         data_position + 16,
+       * 7 averaged a axis of enstatite       -> 3 (dim) doubles, starts at:
+       *                                          data_position + 19,
+       * 8 eigenvalues of a axis of enstatite -> 3 (dim) doubles, starts at:
+       *                                          data_position + 22,
+       * 9 averaged a axis of enstatite       -> 3 (dim) doubles, starts at:
+       *                                          data_position + 25,
+       * 10 eigenvalues of a axis of enstatite -> 3 (dim) doubles, starts at:
+       *                                          data_position + 28,
+       * 11 averaged a axis of enstatite       -> 3 (dim) doubles, starts at:
+       *                                          data_position + 31,
+       * 12 eigenvalues of a axis of enstatite -> 3 (dim) doubles, starts at:
+       *                                          data_position + 34,
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class CpoBinghamAverage : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * constructor
+           */
+          CpoBinghamAverage() = default;
+
+          /**
+           * Initialization function. This function is called once at the
+           * beginning of the program after parse_parameters is run.
+           */
+          void
+          initialize () override;
+
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * Update function. This function is called every time an update is
+           * request by need_update() for every particle for every property.
+           * It is obvious that
+           * this function is called a lot, so its code should be efficient.
+           * The interface provides a default implementation that does nothing,
+           * therefore derived plugins that do not require an update do not
+           * need to implement this function.
+           *
+           * @param [in] data_position An unsigned integer that denotes which
+           * component of the particle property vector is associated with the
+           * current property. For properties that own several components it
+           * denotes the first component of this property, all other components
+           * fill consecutive entries in the @p particle_properties vector.
+           *
+           * @param [in] solution The values of the solution variables at the
+           * current particle position.
+           *
+           * @param [in] gradients The gradients of the solution variables at
+           * the current particle position.
+           *
+           * @param [in,out] particle The particle that is updated within
+           * the call of this function. The particle location can be accessed
+           * using particle->get_location() and its properties using
+           * particle->get_properties().
+           */
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties every time step.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * The integrated strains needs the gradients of the velocity.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+          /**
+           * Computes the Bingham average. This is a way to average directions. The method comes from
+           * https://courses.eas.ualberta.ca/eas421/lecturepages/orientation.html, where it is explained
+           * with the anology that each vector/pole has a weight on a sphere. This method allows to find
+           * the moment of inertia for spinning that sphere. Here we just use it to get three averaged
+           * axis associated with the densest clustering of points for each axis. the a to c axis vectors
+           * are stored in the first to last array respectively.
+           */
+          std::array<std::array<double,6>,3>
+          compute_bingham_average(std::vector<Tensor<2,3>> matrices) const;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * stores the position of the cpo data in the particle property vector
+           */
+          unsigned int cpo_data_position;
+
+          /**
+           * A pointer to the crystal preferred orientation particle property.
+           * Avoids repeated searches for that property.
+           */
+          std::unique_ptr<const Particle::Property::CrystalPreferredOrientation<dim>> cpo_particle_property;
+
+          /**
+           * Random number generator. For reproducibility of tests it is
+           * initialized in the constructor with a constant plus the MPI rank.
+           */
+          mutable std::mt19937 random_number_generator;
+
+          /**
+           * the random number generator seed used to initialize the random number generator.
+           */
+          unsigned int random_number_seed;
+
+          /**
+           * Number of grains
+           */
+          unsigned int n_grains;
+
+          /**
+           * Number of minerals
+           */
+          unsigned int n_minerals;
+
+          /**
+           * when doing the random draw volume weighting, this sets how many samples are taken.
+           */
+          unsigned int n_samples;
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/cpo_elastic_tensor.h.bak b/include/aspect/particle/property/cpo_elastic_tensor.h.bak
new file mode 100644
index 00000000000..1b7cc82a201
--- /dev/null
+++ b/include/aspect/particle/property/cpo_elastic_tensor.h.bak
@@ -0,0 +1,206 @@
+/*
+ Copyright (C) 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_cpo_elastic_tensor_h
+#define _aspect_particle_property_cpo_elastic_tensor_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/particle/property/crystal_preferred_orientation.h>
+#include <aspect/simulator_access.h>
+#include <array>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+
+      /**
+       * Computes the elastic tensor $C_{ijkl}$ based on the cpo in both olivine
+       * and enstatite. It uses a Voigt average.
+       *
+       * The layout of the data vector per particle is the following (note that
+       * for this plugin the following dims are always 3):
+       * 1 unrolled tensor -> 3x3x3x3 (dim*dim*dim*dim) doubles, starts at:
+       *                                   data_position
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class CpoElasticTensor : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor
+           */
+          CpoElasticTensor();
+
+          /**
+           * Initialization function. This function is called once at the
+           * beginning of the program after parse_parameters is run.
+           */
+          void
+          initialize () override;
+
+          /**
+           * This implements the Voigt averaging as described in the equation at the
+           * bottom of page 385 in Mainprice (1990, doi: 10.1016/0098-3004(90)90072-2):
+           * $C^V_{ijkl} = \sum^S_l F_s \sum^{N_s}_l C_{ijkl}/N_s$, where $F_s$ is the
+           * grain size, $N_s$ is the number of grains and $C_{ijkl}$ is the elastic
+           * tensor. This elastic tensor is computed by the equation above in
+           * Mainprice (1990): $C_{ijkl} = R_{ip} R_{jg} R_{kr} R_{is} C_{pgrs}$, where
+           * R_{ij} is the cpo orientation matrix.
+           */
+          SymmetricTensor<2,6>
+          voigt_average_elastic_tensor (const Particle::Property::CrystalPreferredOrientation<dim> &cpo_particle_property,
+                                        const unsigned int cpo_data_position,
+                                        const ArrayView<double> &data) const;
+
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * Update function. This function is called every time an update is
+           * request by need_update() for every particle for every property.
+           * It is obvious that
+           * this function is called a lot, so its code should be efficient.
+           * The interface provides a default implementation that does nothing,
+           * therefore derived plugins that do not require an update do not
+           * need to implement this function.
+           *
+           * @param [in] data_position An unsigned integer that denotes which
+           * component of the particle property vector is associated with the
+           * current property. For properties that own several components it
+           * denotes the first component of this property, all other components
+           * fill consecutive entries in the @p particle_properties vector.
+           *
+           * @param [in] solution The values of the solution variables at the
+           * current particle position.
+           *
+           * @param [in] gradients The gradients of the solution variables at
+           * the current particle position.
+           *
+           * @param [in,out] particle The particle that is updated within
+           * the call of this function. The particle location can be accessed
+           * using particle->get_location() and its properties using
+           * particle->get_properties().
+           */
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This function tells the particle manager that
+           * we need to update particle properties every time step.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * For example, the strains needs the gradients of the velocity.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+          /**
+           * returns the elastic tensor from the particle data
+           */
+          static
+          SymmetricTensor<2,6>
+          get_elastic_tensor(unsigned int cpo_index,
+                             const ArrayView<double> &data);
+
+          /**
+           * Stores the elastic tensor into the particle data array
+           */
+          static
+          void
+          set_elastic_tensor(unsigned int cpo_data_position,
+                             const ArrayView<double> &data,
+                             const SymmetricTensor<2,6> &elastic_tensor);
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Parses the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * The position of the cpo in the particle data array.
+           */
+          unsigned int cpo_data_position;
+
+          /**
+           * The stiffness tensors for olivine and enstatite.
+           * Todo: generalize this into a vector.
+           */
+          SymmetricTensor<2,6> stiffness_matrix_olivine;
+          SymmetricTensor<2,6> stiffness_matrix_enstatite;
+
+          /**
+           * The number of grains per particle.
+           */
+          unsigned int n_grains;
+
+          /**
+           * The number of minerals per particle.
+           */
+          unsigned int n_minerals;
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/crystal_preferred_orientation.h b/include/aspect/particle/property/crystal_preferred_orientation.h
index 1c10dcc087b..29c038f87c8 100644
--- a/include/aspect/particle/property/crystal_preferred_orientation.h
+++ b/include/aspect/particle/property/crystal_preferred_orientation.h
@@ -121,7 +121,7 @@ namespace aspect
        *
        * We store the same number of grains for all minerals (e.g. olivine and enstatite
        * grains), although their volume fractions may not be the same. This is because we need a minimum number
-       * of grains per tracer to perform reliable statistics on it. This minimum should be the same for all
+       * of grains per particle to perform reliable statistics on it. This minimum should be the same for all
        * minerals.
        *
        * @ingroup ParticleProperties
diff --git a/include/aspect/particle/property/crystal_preferred_orientation.h.bak b/include/aspect/particle/property/crystal_preferred_orientation.h.bak
new file mode 100644
index 00000000000..1c10dcc087b
--- /dev/null
+++ b/include/aspect/particle/property/crystal_preferred_orientation.h.bak
@@ -0,0 +1,649 @@
+/*
+ Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_cpo_h
+#define _aspect_particle_property_cpo_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+#include <array>
+
+DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
+#include <boost/random.hpp>
+DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * @brief The type of deformation used by the CPO code.
+       *
+       * passive: Only to be used with the spin tensor CPO Derivative algorithm.
+       * olivine_a_fabric to olivine_e_fabric: Only to be used with the D-Rex CPO Derivative algorithm.
+       *  Sets the deformation type of the mineral to a Olivine A-E Fabric, which influences the relative strength of the slip planes. See table 1 in Fraters and Billen (2021).
+       * enstatite: Only to be used with the D-Rex CPO Derivative algorithm. Sets the deformation type of the mineral to a enstatite Fabric, which influences the relative strength of the slip planes.
+       */
+      enum class DeformationType
+      {
+        passive, olivine_a_fabric, olivine_b_fabric, olivine_c_fabric, olivine_d_fabric, olivine_e_fabric, enstatite
+      };
+
+
+      /**
+       * @brief The type of deformation selector used by the CPO code.
+       *
+       * The selector is a input parameter and it can either set a deformation type directly or determine the deformation type through an algorithm.
+       * The deformation type selector is used to determine/select the deformation type. It can be a fixed deformation type, for example,
+       * by setting it to olivine_a_fabric, or it can be dynamically chosen, which is what the olivine_karato_2008 option does.
+       *
+       * passive: Only to be used with the spin tensor CPO Derivative algorithm.
+       * olivine_a_fabric to olivine_e_fabric: Only to be used with the D-Rex CPO Derivative algorithm.
+       *  Sets the deformation type of the mineral to a Olivine A-E Fabric, which influences the relative strength of the slip planes. See table 1 in Fraters and Billen (2021).
+       * enstatite: Only to be used with the D-Rex CPO Derivative algorithm. Sets the deformation type of the mineral to a enstatite Fabric, which influences the relative strength of the slip planes.
+       * olivine_karato_2008: Only to be used with the D-Rex CPO Derivative algorithm. Sets the deformation type of the mineral to a olivine fabric based on the table in Karato 2008.
+       */
+      enum class DeformationTypeSelector
+      {
+        passive, olivine_a_fabric, olivine_b_fabric, olivine_c_fabric, olivine_d_fabric, olivine_e_fabric, enstatite, olivine_karato_2008
+      };
+
+      /**
+       * @brief The type of Advection method used to advect the CPO properties.
+       */
+      enum class AdvectionMethod
+      {
+        forward_euler, backward_euler
+      };
+
+      /**
+       * @brief The algorithm used to compute the derivatives of the grain size and rotation matrix used in the advection.
+       *
+       * spin_tensor: Rotates the CPO properties soly with the rotation of the particle itself.
+       * drex_2004: Rotates the CPO properties based on the D-Rex 2004 algorithm.
+       */
+      enum class CPODerivativeAlgorithm
+      {
+        spin_tensor, drex_2004
+      };
+
+      /**
+       * @brief An enum used to determine how the initial grain sizes and orientations are set for all particles
+       *
+       * uniform_grains_and_random_uniform_rotations: all particles are set to a uniform grain-size of 1/n_grains
+       * world_builder: all particle grain-sizes and orientations are set by the world builder.
+       */
+      enum class CPOInitialGrainsModel
+      {
+        uniform_grains_and_random_uniform_rotations, world_builder
+      };
+
+      /**
+       * The plugin manages and computes the evolution of Lattice/Crystal Preferred Orientations (LPO/CPO)
+       * on particles. Each ASPECT particle represents many grains. Each grain is assigned a size and a orientation
+       * matrix. This allows tracking the LPO evolution with kinematic polycrystal CPO evolution models such
+       * as D-Rex (Kaminski and Ribe, 2001; ́Kaminski et al., 2004).
+       *
+       * This plugin stores M minerals and for each mineral it stores N grains. The total amount of memory stored is 2
+       * doubles per mineral plus 10 doubles per grain, resulting in a total memory of M * (2 + N * 10) . The layout of
+       * the data stored is the following (note that for this plugin the following dims are always 3):
+       * 1. M minerals times
+       *    1.1  Mineral deformation type   -> 1 double, at location
+       *                                      => 0 + mineral_i * (n_grains * 10 + 2)
+       *    2.1. Mineral volume fraction    -> 1 double, at location
+       *                                      => 1 + mineral_i * (n_grains * 10 + 2)
+       *    2.2. N grains times:
+       *         2.1. volume fraction grain -> 1 double, at location:
+       *                                      => 2 + grain_i * 10 + mineral_i * (n_grains * 10 + 2)
+       *         2.2. rotation_matrix grain -> 9 (Tensor<2,dim>::n_independent_components) doubles, starts at:
+       *                                      => 3 + grain_i * 10 + mineral_i * (n_grains * 10 + 2)
+       *
+       * Last used data entry is n_minerals * (n_grains * 10 + 2).
+       *
+       * We store the same number of grains for all minerals (e.g. olivine and enstatite
+       * grains), although their volume fractions may not be the same. This is because we need a minimum number
+       * of grains per tracer to perform reliable statistics on it. This minimum should be the same for all
+       * minerals.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class CrystalPreferredOrientation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor
+           */
+          CrystalPreferredOrientation() = default;
+
+          /**
+           * Initialization function. This function is called once at the
+           * beginning of the program after parse_parameters is run.
+           */
+          void
+          initialize () override;
+
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * Update function. This function is called every time an update is
+           * request by need_update() for every particle for every property.
+           * It is obvious that
+           * this function is called a lot, so its code should be efficient.
+           * The interface provides a default implementation that does nothing,
+           * therefore derived plugins that do not require an update do not
+           * need to implement this function.
+           *
+           * @param [in] data_position An unsigned integer that denotes which
+           * component of the particle property vector is associated with the
+           * current property. For properties that own several components it
+           * denotes the first component of this property, all other components
+           * fill consecutive entries in the @p particle_properties vector.
+           *
+           * @param [in] solution The values of the solution variables at the
+           * current particle position.
+           *
+           * @param [in] gradients The gradients of the solution variables at
+           * the current particle position.
+           *
+           * @param [in,out] particle The particle that is updated within
+           * the call of this function. The particle location can be accessed
+           * using particle->get_location() and its properties using
+           * particle->get_properties().
+           */
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties every time step.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * The CPO of late particles is initialized by interpolating from existing particles.
+           */
+          InitializationModeForLateParticles
+          late_initialization_mode () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * The integrated strains needs the gradients of the velocity.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+          /**
+           * @brief Computes the volume fraction and grain orientation derivatives of all the grains of a mineral.
+           *
+           * @param cpo_index The location where the CPO data starts in the data array.
+           * @param data The data array containing the CPO data.
+           * @param mineral_i The mineral for which to compute the derivatives for.
+           * @param strain_rate_3d The 3D strain rate at the location where the derivative is requested.
+           * @param velocity_gradient_tensor The velocity gradient tensor at the location where the derivative is requested.
+           * @param position the location for which the derivative is requested.
+           * @param temperature The temperature at the location where the derivative is requested.
+           * @param pressure The pressure at the location where the derivative is requested.
+           * @param velocity The veloicty at the location where the derivative is requested.
+           * @param compositions The compositios at the location where the derivative is requested.
+           * @param strain_rate The strain-rate at the location where the derivative is requested.
+           * @param deviatoric_strain_rate The deviatoric strain-rate at the location where the derivative is requested.
+           * @param water_content The water content at the location where the derivative is requested.
+           */
+          std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
+          compute_derivatives(const unsigned int cpo_index,
+                              const ArrayView<double> &data,
+                              const unsigned int mineral_i,
+                              const SymmetricTensor<2,3> &strain_rate_3d,
+                              const Tensor<2,3> &velocity_gradient_tensor,
+                              const Point<dim> &position,
+                              const double temperature,
+                              const double pressure,
+                              const Tensor<1,dim> &velocity,
+                              const std::vector<double> &compositions,
+                              const SymmetricTensor<2,dim> &strain_rate,
+                              const SymmetricTensor<2,dim> &deviatoric_strain_rate,
+                              const double water_content) const;
+
+          /**
+           * @brief Computes the CPO derivatives with the D-Rex 2004 algorithm.
+           *
+           * @param cpo_index The location where the CPO data starts in the data array.
+           * @param data The data array containing the CPO data.
+           * @param mineral_i The mineral for which to compute the derivatives for.
+           * @param strain_rate_3d The 3D strain rate
+           * @param velocity_gradient_tensor The velocity gradient tensor
+           * @param ref_resolved_shear_stress Represent one value per slip plane.
+           * The planes are ordered from weakest to strongest with relative values,
+           * where the inactive plane is infinity strong. So it is a measure of strength
+           * on each slip plane.
+           * @param prevent_nondimensionalization Prevent nondimensializing values internally.
+           * Only for unit testing purposes.
+           */
+          std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
+          compute_derivatives_drex_2004(const unsigned int cpo_index,
+                                        const ArrayView<double> &data,
+                                        const unsigned int mineral_i,
+                                        const SymmetricTensor<2,3> &strain_rate_3d,
+                                        const Tensor<2,3> &velocity_gradient_tensor,
+                                        const std::array<double,4> ref_resolved_shear_stress,
+                                        const bool prevent_nondimensionalization = false) const;
+
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+          /**
+           * Return the number of grains per particle
+           */
+          unsigned int
+          get_number_of_grains() const;
+
+          /**
+           * Return the number of minerals per particle
+           */
+          unsigned int
+          get_number_of_minerals() const;
+
+          /**
+           * @brief Determines the deformation type from the deformation type selector.
+           * If the provided @p deformation_type_selector is a specific deformation type,
+           * the function will simply return the corresponding deformation type. However,
+           * if the @p deformation_type_selector is an algorithm to determine the current
+           * deformation type (e.g. based on measured lab data or analytical models), then
+           * the function computes the appropriate deformation type at the given conditions
+           * and returns the compute deformation type.
+           */
+          DeformationType
+          determine_deformation_type(const DeformationTypeSelector deformation_type_selector,
+                                     const Point<dim> &position,
+                                     const double temperature,
+                                     const double pressure,
+                                     const Tensor<1,dim> &velocity,
+                                     const std::vector<double> &compositions,
+                                     const SymmetricTensor<2,dim> &strain_rate,
+                                     const SymmetricTensor<2,dim> &deviatoric_strain_rate,
+                                     const double water_content) const;
+
+          /**
+           * @brief Computes the deformation type given the stress and water content according to the
+           * table in Karato 2008.
+           */
+          DeformationType
+          determine_deformation_type_karato_2008(const double stress,
+                                                 const double water_content) const;
+
+          /**
+           * @brief Computes the reference resolved shear stress (RRSS) based on the selected deformation type.
+           *
+           * The inactive plane should theoretically be infinitely strong, but this is nummerically not desirable,
+           * so an optional max_value can be set to indicate an inactive plane.
+           *
+           * It is currently designed to return the relative strength of the slip planes for olivine, which are are 4,
+           * but this could be generalized.
+           */
+          std::array<double,4>
+          reference_resolved_shear_stress_from_deformation_type(DeformationType deformation_type,
+                                                                double max_value = 1e60) const;
+
+          /**
+           * @brief Returns the value in the data array representing the deformation type.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i The mineral to get the value of the deformation type for.
+           */
+          inline
+          DeformationType get_deformation_type(const unsigned int cpo_data_position,
+                                               const ArrayView<double> &data,
+                                               const unsigned int mineral_i) const
+          {
+            return static_cast<DeformationType>(data[cpo_data_position + 0 + mineral_i * (n_grains * 10 + 2)]);
+          }
+
+          /**
+           * @brief Sets the value in the data array representing the deformation type.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i The mineral to set the value deformation type for.
+           * @param deformation_type The value of the deformation type to set.
+           */
+          inline
+          void set_deformation_type(const unsigned int cpo_data_position,
+                                    const ArrayView<double> &data,
+                                    const unsigned int mineral_i,
+                                    const DeformationType deformation_type) const
+          {
+            data[cpo_data_position + 0 + mineral_i * (n_grains * 10 + 2)] = static_cast<double>(deformation_type);
+          }
+
+          /**
+           * @brief Returns the value in the data array representing the volume fraction of a mineral.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i The mineral to get the value of the volume fraction of a mineral for.
+           */
+          inline
+          double get_volume_fraction_mineral(const unsigned int cpo_data_position,
+                                             const ArrayView<double> &data,
+                                             const unsigned int mineral_i) const
+          {
+            return data[cpo_data_position + 1 + mineral_i *(n_grains * 10 + 2)];
+          }
+
+          /**
+           * @brief Sets the value in the data array representing the volume fraction of a mineral.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i The mineral to set the value of the volume fraction of a mineral for.
+           * @param volume_fraction_mineral The value of the volume fraction of a mineral to set.
+           */
+          inline
+          void set_volume_fraction_mineral(const unsigned int cpo_data_position,
+                                           const ArrayView<double> &data,
+                                           const unsigned int mineral_i,
+                                           const double volume_fraction_mineral) const
+          {
+            data[cpo_data_position + 1 + mineral_i *(n_grains * 10 + 2)] = volume_fraction_mineral;
+          }
+
+          /**
+           * @brief Returns the value in the data array representing the volume fraction of a grain.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i The mineral to get the value of the volume fraction of a grain for.
+           * @param grain_i The grain to get the value of the volume fraction of.
+           */
+          inline
+          double get_volume_fractions_grains(const unsigned int cpo_data_position,
+                                             const ArrayView<const double> &data,
+                                             const unsigned int mineral_i,
+                                             const unsigned int grain_i) const
+          {
+            return data[cpo_data_position + 2 + grain_i * 10 + mineral_i * (n_grains * 10 + 2)];
+          }
+
+          /**
+           * @brief Sets the value in the data array representing the volume fraction of a grain.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i The mineral to set the value of the volume fraction of a grain for.
+           * @param grain_i The grain to set the value of the volume fraction of.
+           * @param volume_fractions_grains The value of the volume fraction of a grain to set.
+           */
+          inline
+          void set_volume_fractions_grains(const unsigned int cpo_data_position,
+                                           const ArrayView<double> &data,
+                                           const unsigned int mineral_i,
+                                           const unsigned int grain_i,
+                                           const double volume_fractions_grains) const
+          {
+            data[cpo_data_position + 2 + grain_i * 10 + mineral_i * (n_grains * 10 + 2)] = volume_fractions_grains;
+          }
+
+          /**
+           * @brief Gets the rotation matrix for a grain in a mineral.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i The mineral to get the value of the rotation matrix of a grain for.
+           * @param grain_i The grain to get the value of the rotation matrix of.
+           * @return Tensor<2,3> The rotation matrix of a grain in a mineral
+           */
+          inline
+          Tensor<2,3> get_rotation_matrix_grains(const unsigned int cpo_data_position,
+                                                 const ArrayView<const double> &data,
+                                                 const unsigned int mineral_i,
+                                                 const unsigned int grain_i) const
+          {
+            Tensor<2,3> rotation_matrix;
+            for (unsigned int i = 0; i < Tensor<2,3>::n_independent_components ; ++i)
+              {
+                const dealii::TableIndices<2> index = Tensor<2,3>::unrolled_to_component_indices(i);
+                rotation_matrix[index] = data[cpo_data_position + 3 + grain_i * 10 + mineral_i * (n_grains * 10 + 2) + i];
+              }
+            return rotation_matrix;
+          }
+
+          /**
+           * @brief Sets the rotation matrix for a grain in a mineral.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i The mineral to set the value of the rotation matrix of a grain for.
+           * @param grain_i The grain to get the value of the rotation matrix of.
+           * @param rotation_matrix The rotation matrix to set for the grain in the mineral.
+           */
+          inline
+          void set_rotation_matrix_grains(const unsigned int cpo_data_position,
+                                          const ArrayView<double> &data,
+                                          const unsigned int mineral_i,
+                                          const unsigned int grain_i,
+                                          const Tensor<2,3> &rotation_matrix) const
+          {
+            for (unsigned int i = 0; i < Tensor<2,3>::n_independent_components ; ++i)
+              {
+                const dealii::TableIndices<2> index = Tensor<2,3>::unrolled_to_component_indices(i);
+                data[cpo_data_position + 3 + grain_i * 10 + mineral_i * (n_grains * 10 + 2) + i] = rotation_matrix[index];
+              }
+          }
+
+
+        private:
+          /**
+           * Computes a random rotation matrix.
+           */
+          void
+          compute_random_rotation_matrix(Tensor<2,3> &rotation_matrix) const;
+
+          /**
+           * @brief Updates the volume fractions and rotation matrices with a Forward Euler scheme.
+           *
+           * Updates the volume fractions and rotation matrices with a Forward Euler scheme:
+           * $x_t = x_{t-1} + dt * x_{t-1} * \frac{dx_t}{dt}$. The function returns the sum of
+           * the new volume fractions.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i Which mineral to advect for.
+           * @param dt The time step used for the advection step
+           * @param derivatives A pair containing the derivatives for the volume fractions and
+           * orientations respectively.
+           * @return double The sum of all volume fractions.
+           */
+          double
+          advect_forward_euler(const unsigned int cpo_data_position,
+                               const ArrayView<double> &data,
+                               const unsigned int mineral_i,
+                               const double dt,
+                               const std::pair<std::vector<double>, std::vector<Tensor<2,3>>> &derivatives) const;
+
+          /**
+           * @brief Updates the volume fractions and rotation matrices with a Backward Euler scheme.
+           *
+           * Updates the volume fractions and rotation matrices with a Backward Euler scheme:
+           * $x_t = x_{t-1} + dt * x_{t-1} * \frac{dx_t}{dt}$. The function returns the sum of
+           * the new volume fractions.
+           *
+           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
+           * @param data The particle data vector.
+           * @param mineral_i Which mineral to advect for.
+           * @param dt The time step used for the advection step
+           * @param derivatives A pair containing the derivatives for the volume fractions and
+           * orientations respectively.
+           * @return double The sum of all volume fractions.
+           */
+          double
+          advect_backward_euler(const unsigned int cpo_data_position,
+                                const ArrayView<double> &data,
+                                const unsigned int mineral_i,
+                                const double dt,
+                                const std::pair<std::vector<double>, std::vector<Tensor<2,3>>> &derivatives) const;
+
+
+          /**
+           * Computes and returns the volume fraction and grain orientation derivatives such that
+           * the grains stay the same size and the orientations rotating passively with the particle.
+           *
+           * @param velocity_gradient_tensor is the velocity gradient tensor at the location of the particle.
+           */
+          std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
+          compute_derivatives_spin_tensor(const Tensor<2,3> &velocity_gradient_tensor) const;
+
+          /**
+           * Random number generator used for initialization of particles
+           */
+          mutable boost::mt19937 random_number_generator;
+          unsigned int random_number_seed;
+
+          unsigned int n_grains;
+
+          unsigned int n_minerals;
+
+          /**
+           * The index of the water composition.
+           */
+          unsigned int water_index;
+
+          /**
+           * A vector containing the deformation type selectors provided by the user.
+           * Should be one of the following: "Olivine: Karato 2008", "Olivine: A-fabric",
+           * "Olivine: B-fabric", "Olivine: C-fabric", "Olivine: D-fabric", "Olivine: E-fabric",
+           * "Enstatite" or "Passive".
+           */
+          std::vector<DeformationTypeSelector> deformation_type_selector;
+
+          /**
+           * Store the volume fraction for each mineral.
+           */
+          std::vector<double> volume_fractions_minerals;
+
+          /**
+           * Advection method for particle properties
+           */
+          AdvectionMethod advection_method;
+
+          /**
+           * What algorithm to use to compute the derivatives
+           */
+          CPODerivativeAlgorithm cpo_derivative_algorithm;
+
+          /**
+           * This value determines the tolerance used for the Backward Euler and
+           * Crank-Nicolson iterations.
+           */
+          double property_advection_tolerance;
+
+          /**
+           * This value determines the the maximum number of iterations used for the
+           * Backward Euler and Crank-Nicolson iterations.
+           */
+          unsigned int property_advection_max_iterations;
+
+          /**
+           * @name D-Rex variables
+           */
+          /** @{ */
+          /**
+           * Stress exponent
+           */
+          double stress_exponent;
+
+          /**
+           * efficiency of nucleation parameter.
+           * lambda_m in equation 8 of Kaminski et al. (2004, Geophys. J. Int)
+           */
+          double nucleation_efficiency;
+
+          /**
+           * An exponent described in equation 10 of Kaminski and Ribe (2001, EPSL)
+           */
+          double exponent_p;
+
+          /**
+           * The Dimensionless Grain Boundary Sliding (GBS) threshold.
+           * This is a grain size threshold below which grain deform by GBS and
+           * become strain-free grains.
+           */
+          double threshold_GBS;
+
+          /**
+           * Dimensionless grain boundary mobility as described by equation 14
+           * in Kaminski and Ribe (2001, EPSL).
+           */
+          double mobility;
+
+          /**
+           * Sets which type of initial grain model is used to create the gain sizes and orientations
+           */
+          CPOInitialGrainsModel initial_grains_model;
+
+          /** @} */
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/elastic_stress.h.bak b/include/aspect/particle/property/elastic_stress.h.bak
new file mode 100644
index 00000000000..d4d70d7da7f
--- /dev/null
+++ b/include/aspect/particle/property/elastic_stress.h.bak
@@ -0,0 +1,104 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_elastic_stress_h
+#define _aspect_particle_property_elastic_stress_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that calculates the viscoelastic stress a particle
+       * has accumulated through time.
+       * The implementation of this property is equivalent to the implementation
+       * for compositional fields that is described in the viscoelastic material
+       * model and elastic stress rheology module.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class ElasticStress : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ElasticStress ();
+
+          void initialize () override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::initialize_one_particle_property()
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::need_update()
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::get_needed_update_flags()
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::get_property_information()
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+        private:
+          /**
+           * Objects that are used to compute the particle property. Since the
+           * object is expensive to create and is needed often it is kept as a
+           * member variable. Because it is changed inside a const member function
+           * (update_particle_property) it has to be mutable, but since it is
+           * only used inside that function and always set before being used
+           * that is not a problem. This implementation is not thread safe,
+           * but it is currently not used in a threaded context.
+           */
+          mutable MaterialModel::MaterialModelInputs<dim> material_inputs;
+          mutable MaterialModel::MaterialModelOutputs<dim> material_outputs;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/elastic_tensor_decomposition.h.bak b/include/aspect/particle/property/elastic_tensor_decomposition.h.bak
new file mode 100644
index 00000000000..76ec5a314e0
--- /dev/null
+++ b/include/aspect/particle/property/elastic_tensor_decomposition.h.bak
@@ -0,0 +1,274 @@
+/*
+ Copyright (C) 2023 by the authors of the ASPECT code.
+ This file is part of ASPECT.
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_elastic_tensor_decomposition_h
+#define _aspect_particle_property_elastic_tensor_decomposition_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      namespace Utilities
+      {
+        /**
+         * Return an even permutation based on an index. This is an internal
+         * utilities function, also used by the unit tester.
+         */
+        std::array<unsigned int, 3>
+        indexed_even_permutation(const unsigned int index);
+
+        /**
+         * Computes the Voigt stiffness tensor from the elastic tensor.
+         * The Voigt stiffness tensor (see Browaeys and Chevrot, 2004)
+         * defines the stress needed to cause an isotropic strain in the
+         * material.
+         */
+        SymmetricTensor<2,3>
+        compute_voigt_stiffness_tensor(const SymmetricTensor<2,6> &elastic_tensor);
+
+        /**
+         * Computes the dilatation stiffness tensor from the elastic tensor
+         * The dilatational stiffness tensor (see Browaeys and Chevrot, 2004)
+         * defines the stress to cause isotropic dilatation in the material.
+         */
+        SymmetricTensor<2,3>
+        compute_dilatation_stiffness_tensor(const SymmetricTensor<2,6> &elastic_tensor);
+
+        /**
+         * Computes the Symmetry Cartesian Coordinate System (SCCS).
+         *
+         * This is based on Browaeys and Chevrot (2004), GJI (doi: 10.1111/j.1365-246X.2004.024115.x),
+         * which states at the end of paragraph 3.3 that "... an important property of an orthogonal projection
+         * is that the distance between a vector $X$ and its orthogonal projection $X_H = p(X)$ on a given
+         * subspace is minimum. These two features ensure that the decomposition is optimal once a 3-D Cartesian
+         * coordinate system is chosen.". The other property they talk about is that "The space of elastic
+         * vectors has a finite dimension [...], i.e. using a different norm from eq. 2.3 will change distances
+         * but not the resulting decomposition.".
+         *
+         * With the three SCCS directions, the elastic tensor can be decomposed into the different
+         * symmetries in those three SCCS direction, that is, triclinic, monoclinic, orthorhombic,
+         * tetragonal, hexagonal, and isotropic (Browaeys & Chevrot, 2004).
+         *
+         * The dilatation_stiffness_tensor defines the stress to cause isotropic dilatation in the material.
+         * The voigt_stiffness_tensor defines the stress needed to cause an isotropic strain in the material
+         */
+        Tensor<2,3> compute_unpermutated_SCCS(const SymmetricTensor<2,3> &dilatation_stiffness_tensor,
+                                              const SymmetricTensor<2,3> &voigt_stiffness_tensor);
+
+        /**
+         * Uses the Symmetry Cartesian Coordinate System (SCCS) to try the different permutations to
+         * determine what is the best projection.
+         * This is based on Browaeys and Chevrot (2004), GJI (doi: 10.1111/j.1365-246X.2004.024115.x),
+         * which states at the end of paragraph 3.3 that "... an important property of an orthogonal projection
+         * is that the distance between a vector $X$ and its orthogonal projection $X_H = p(X)$ on a given
+         * subspace is minimum. These two features ensure that the decomposition is optimal once a 3-D Cartesian
+         * coordinate system is chosen.". The other property they talk about is that "The space of elastic
+         * vectors has a finite dimension [...], i.e. using a different norm from eq. 2.3 will change distances
+         * but not the resulting decomposition.".
+         */
+        std::array<std::array<double,3>,7>
+        compute_elastic_tensor_SCCS_decompositions(
+          const Tensor<2,3> &unpermutated_SCCS,
+          const SymmetricTensor<2,6> &elastic_matrix);
+
+
+        /**
+         * The tensors below can be used to project matrices to different symmetries.
+         * See Browaeys and Chevrot, 2004.
+         */
+        static const SymmetricTensor<2,21> projection_matrix_triclinic_to_monoclinic(
+          Tensor<2,21>(
+        {
+          {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+          {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+          {0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+          {0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+          {0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+          {0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+          {0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+          {0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
+          {0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
+          {0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0},
+          {0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0},
+          {0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0},
+          {0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0},
+          {0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0},
+          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0},
+          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0},
+          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0},
+          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0},
+          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
+          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0},
+          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
+        })
+        );
+        static const SymmetricTensor<2,9> projection_matrix_monoclinic_to_orthorhombic(
+          Tensor<2,9>(
+        {
+          {1,0,0,0,0,0,0,0,0},
+          {0,1,0,0,0,0,0,0,0},
+          {0,0,1,0,0,0,0,0,0},
+          {0,0,0,1,0,0,0,0,0},
+          {0,0,0,0,1,0,0,0,0},
+          {0,0,0,0,0,1,0,0,0},
+          {0,0,0,0,0,0,1,0,0},
+          {0,0,0,0,0,0,0,1,0},
+          {0,0,0,0,0,0,0,0,1}
+        })
+        );
+        static const SymmetricTensor<2,9> projection_matrix_orthorhombic_to_tetragonal(
+          Tensor<2,9>(
+        {
+          {0.5,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
+          {0.5,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
+          {0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0},
+          {0.0,0.0,0.0,0.5,0.5,0.0,0.0,0.0,0.0},
+          {0.0,0.0,0.0,0.5,0.5,0.0,0.0,0.0,0.0},
+          {0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0},
+          {0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.5,0.0},
+          {0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.5,0.0},
+          {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0}
+        })
+        );
+        static const SymmetricTensor<2,9> projection_matrix_tetragonal_to_hexagonal(
+          Tensor<2,9>(
+        {
+          {3./8.           , 3./8.           , 0.0, 0.0, 0.0, 1./(4.*sqrt(2.))  , 0.0, 0.0, 1./4.            },
+          {3./8.           , 3./8.           , 0.0, 0.0, 0.0, 1./(4.*sqrt(2.))  , 0.0, 0.0, 1./4.            },
+          {0.0             , 0.0             , 1.0, 0.0, 0.0, 0.0               , 0.0, 0.0, 0.0              },
+          {0.0             , 0.0             , 0.0, 0.5, 0.5, 0.0               , 0.0, 0.0, 0.0              },
+          {0.0             , 0.0             , 0.0, 0.5, 0.5, 0.0               , 0.0, 0.0, 0.0              },
+          {1./(4.*sqrt(2.)), 1./(4.*sqrt(2.)), 0.0, 0.0, 0.0, 3./4.             , 0.0, 0.0, -1./(2.*sqrt(2.))},
+          {0.0             , 0.0             , 0.0, 0.0, 0.0, 0.0               , 0.5, 0.5, 0.0              },
+          {0.0             , 0.0             , 0.0, 0.0, 0.0, 0.0               , 0.5, 0.5, 0.0              },
+          {1./4.           , 1./4.           , 0.0, 0.0, 0.0, -1./(2.*sqrt(2.)) , 0.0, 0.0, 0.5              }
+        })
+        );
+        static const SymmetricTensor<2,9> projection_matrix_hexagonal_to_isotropic(
+          Tensor<2,9>(
+        {
+          {3./15.      , 3./15.      , 3./15.      , sqrt(2.)/15. , sqrt(2.)/15. , sqrt(2.)/15. , 2./15.       , 2./15.       , 2./15.        },
+          {3./15.      , 3./15.      , 3./15.      , sqrt(2.)/15. , sqrt(2.)/15. , sqrt(2.)/15. , 2./15.       , 2./15.       , 2./15.        },
+          {3./15.      , 3./15.      , 3./15.      , sqrt(2.)/15. , sqrt(2.)/15. , sqrt(2.)/15. , 2./15.       , 2./15.       , 2./15.        },
+          {sqrt(2.)/15., sqrt(2.)/15., sqrt(2.)/15., 4./15.       , 4./15.       , 4./15.       , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15. },
+          {sqrt(2.)/15., sqrt(2.)/15., sqrt(2.)/15., 4./15.       , 4./15.       , 4./15.       , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15. },
+          {sqrt(2.)/15., sqrt(2.)/15., sqrt(2.)/15., 4./15.       , 4./15.       , 4./15.       , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15. },
+          {2./15.      , 2./15.      , 2./15.      , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15., 1./5.        , 1./5.        , 1./5.         },
+          {2./15.      , 2./15.      , 2./15.      , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15., 1./5.        , 1./5.        , 1./5.         },
+          {2./15.      , 2./15.      , 2./15.      , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15., 1./5.        , 1./5.        , 1./5.         }
+        })
+        );
+      }
+
+      /**
+       * Computes several properties of a elastic tensor stored on a particle.
+       * These include the eigenvectors and conversions between different forms of 4th order tensors.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class ElasticTensorDecomposition : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor
+           */
+          ElasticTensorDecomposition() = default;
+
+          /**
+           * Initialization function. This function is called once at the
+           * beginning of the program after parse_parameters is run.
+           */
+          void
+          initialize () override;
+
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * Update function. This function is called every time an update is
+           * request by need_update() for every particle for every property.
+           * It is obvious that
+           * this function is called a lot, so its code should be efficient.
+           * The interface provides a default implementation that does nothing,
+           * therefore derived plugins that do not require an update do not
+           * need to implement this function.
+           *
+           * @param [in] data_position An unsigned integer that denotes which
+           * component of the particle property vector is associated with the
+           * current property. For properties that own several components it
+           * denotes the first component of this property, all other components
+           * fill consecutive entries in the @p particle_properties vector.
+           *
+           * @param [in] solution The values of the solution variables at the
+           * current particle position.
+           *
+           * @param [in] gradients The gradients of the solution variables at
+           * the current particle position.
+           *
+           * @param [in,out] particle The particle that is updated within
+           * the call of this function. The particle location can be accessed
+           * using particle->get_location() and its properties using
+           * particle->get_properties().
+           */
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This function tells the particle manager that
+           * we need to update particle properties.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+        private:
+          unsigned int cpo_elastic_tensor_data_position;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/function.h.bak b/include/aspect/particle/property/function.h.bak
new file mode 100644
index 00000000000..f45d52de16c
--- /dev/null
+++ b/include/aspect/particle/property/function.h.bak
@@ -0,0 +1,101 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_function_h
+#define _aspect_particle_property_function_h
+
+#include <aspect/particle/property/interface.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that initializes particle properties based on a
+       * functional description provided in the input file.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class Function : public Interface<dim>
+      {
+        public:
+          Function();
+
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * A function object representing the particle property.
+           */
+          std::unique_ptr<Functions::ParsedFunction<dim>> function;
+
+          /**
+           * A private variable that stores the number of particle property
+           * function components.
+           */
+          unsigned int n_components;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/grain_size.h.bak b/include/aspect/particle/property/grain_size.h.bak
new file mode 100644
index 00000000000..bdfa42aac07
--- /dev/null
+++ b/include/aspect/particle/property/grain_size.h.bak
@@ -0,0 +1,123 @@
+/*
+ Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_grain_size_h
+#define _aspect_particle_property_grain_size_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that calculates the evolving grain size of a particle.
+       * The implementation of this property is equivalent to the implementation
+       * for compositional fields that is described in the grain_size material
+       * model.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class GrainSize : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          GrainSize ();
+
+          /**
+           * Initialize variables that stay constant
+           * during a model.
+           */
+          void initialize () override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::initialize_one_particle_property()
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_properties()
+           */
+          void
+          update_particle_properties (const unsigned int data_position,
+                                      const std::vector<Vector<double>> &solution,
+                                      const std::vector<std::vector<Tensor<1,dim>>> &gradients,
+                                      typename ParticleHandler<dim>::particle_iterator_range &particles) const override;
+
+          /**
+           * Returns an enum, which determines how this particle property is
+           * initialized for particles that are created later than the initial
+           * particle generation. For this property the value of
+           * generated particles is interpolated from existing particles, unless
+           * the particle is in a boundary cell that has a Dirichlet boundary
+           * condition, in which case it uses the boundary condition value.
+           */
+          InitializationModeForLateParticles
+          late_initialization_mode () const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::need_update()
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::get_needed_update_flags()
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::get_property_information()
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+        private:
+          /**
+           * Objects that are used to compute the particle property. Since the
+           * object is expensive to create and is needed often it is kept as a
+           * member variable. Because it is changed inside a const member function
+           * (update_particle_property) it has to be mutable, but since it is
+           * only used inside that function and always set before being used
+           * that is not a problem. This implementation is not thread safe,
+           * but it is currently not used in a threaded context.
+           */
+          mutable MaterialModel::MaterialModelInputs<dim> material_inputs;
+          mutable MaterialModel::MaterialModelOutputs<dim> material_outputs;
+
+          /**
+           * The index of the compositional field that stores the grain size.
+           */
+          unsigned int grain_size_index;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/initial_composition.h.bak b/include/aspect/particle/property/initial_composition.h.bak
new file mode 100644
index 00000000000..e59b2c67ca1
--- /dev/null
+++ b/include/aspect/particle/property/initial_composition.h.bak
@@ -0,0 +1,83 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_initial_composition_h
+#define _aspect_particle_property_initial_composition_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that initializes particle properties based on a
+       * functional description provided in the input file.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class InitialComposition : public Interface<dim>, public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * Returns an enum, which determines how this particle property is
+           * initialized for particles that are created later than the initial
+           * particle generation. For this property the value of
+           * generated particles is interpolated from existing particles, unless
+           * the particle is in a boundary cell that has a Dirichlet boundary
+           * condition, in which case it uses the boundary condition value.
+           */
+          InitializationModeForLateParticles
+          late_initialization_mode () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/initial_position.h.bak b/include/aspect/particle/property/initial_position.h.bak
new file mode 100644
index 00000000000..d9d86d9862b
--- /dev/null
+++ b/include/aspect/particle/property/initial_position.h.bak
@@ -0,0 +1,71 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_initial_position_h
+#define _aspect_particle_property_initial_position_h
+
+#include <aspect/particle/property/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that initializes particle properties based on the
+       * initial position of the particles.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class InitialPosition : public Interface<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/integrated_strain.h.bak b/include/aspect/particle/property/integrated_strain.h.bak
new file mode 100644
index 00000000000..e773dd9089f
--- /dev/null
+++ b/include/aspect/particle/property/integrated_strain.h.bak
@@ -0,0 +1,99 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_integrated_strain_h
+#define _aspect_particle_property_integrated_strain_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that integrates the finite strain that a particle has
+       * experienced.
+       * The implementation of this property is equivalent to the implementation
+       * for compositional fields that is described in the cookbook
+       * finite_strain <code>cookbooks/finite_strain/finite_strain.cc</code>.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class IntegratedStrain : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties every time step.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * The integrated strains needs the gradients of the velocity.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/integrated_strain_invariant.h.bak b/include/aspect/particle/property/integrated_strain_invariant.h.bak
new file mode 100644
index 00000000000..5ef0c8e78d9
--- /dev/null
+++ b/include/aspect/particle/property/integrated_strain_invariant.h.bak
@@ -0,0 +1,98 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_integrated_strain_invariant_h
+#define _aspect_particle_property_integrated_strain_invariant_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that calculates the finite strain invariant a particle has
+       * experienced. The implementation of this property is equivalent to the
+       * implementation for compositional fields that is located in the plugin
+       * <code>benchmarks/buiter_et_al_2008_jgr/plugin/finite_strain_invariant.cc</code>.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class IntegratedStrainInvariant : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties every time step.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * The integrated strains needs the gradients of the velocity.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/interface.h.bak b/include/aspect/particle/property/interface.h.bak
new file mode 100644
index 00000000000..9d943da535a
--- /dev/null
+++ b/include/aspect/particle/property/interface.h.bak
@@ -0,0 +1,816 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_interface_h
+#define _aspect_particle_property_interface_h
+
+#include <aspect/particle/interface.h>
+#include <aspect/global.h>
+
+#include <aspect/particle/interpolator/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/particles/particle.h>
+#include <deal.II/particles/particle_handler.h>
+#include <deal.II/particles/property_pool.h>
+#include <deal.II/fe/fe_update_flags.h>
+
+#include <memory>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      using namespace dealii::Particles;
+
+      /**
+       * This class is used to store all the necessary information to translate
+       * between the data structure of the particle properties (a flat vector of
+       * doubles) and the semantic meaning of these properties. It contains
+       * information about the three layers of particle property information:
+       *
+       * By 'property plugins' we mean each separate class that is derived from
+       * aspect::Particle::Property::Interface<dim>, and that is selected in
+       * the input file. This means in any model there are as many property
+       * plugins as entries in the 'List of particle properties' input parameter.
+       *
+       * Each plugin can create one or more 'property fields'. Property fields
+       * are interpreted as distinctly named particle properties. Most plugins
+       * contain only one field, but some group distinctly named properties
+       * into groups, such as the 'InitialComposition' plugin, which creates
+       * one property field per compositional field and names the property
+       * fields according to the compositional field names. When writing particle
+       * data to output files each 'property field' will be written into a
+       * separate output field.
+       *
+       * Last each field can contain several 'property components'
+       * if it represents a vector or tensor property. These components can
+       * not be named individually, but it is still important to be able to
+       * know how many components belong to a particular field.
+       *
+       * Information that is often required by other algorithms is for example
+       * the number of components (= number of doubles in the property vector)
+       * of a particle field or plugin, and its position within the particle
+       * property vector. All of this information might be required within
+       * loops over all fields, or for a specific field either identified by
+       * its index, or by its name.
+       *
+       * @ingroup ParticleProperties
+       */
+      class ParticlePropertyInformation
+      {
+        public:
+          /**
+           * Empty default constructor.
+           */
+          ParticlePropertyInformation();
+
+          /**
+           * Constructor. Initialize the various arrays of this structure with the
+           * given property information collected from the individual plugins.
+           *
+           * @p property_information A vector that contains one vector per
+           * property plugin. Each of these vectors contains one or more pairs
+           * that represent a property field name and the number of components
+           * for this field. The input argument can be constructed by
+           * concatenating the output of the
+           * Particle::Property::Interface<dim>::get_property_information()
+           * functions of all property plugins.
+           */
+          ParticlePropertyInformation(const std::vector<std::vector<std::pair<std::string,unsigned int>>> &property_information);
+
+          /**
+           * Checks if the particle property specified by @p name exists
+           * in this model.
+           */
+          bool
+          fieldname_exists(const std::string &name) const;
+
+          /**
+           * Get the field index of the particle property specified by @p name.
+           */
+          unsigned int
+          get_field_index_by_name(const std::string &name) const;
+
+          /**
+           * Get the field index of the particle property specified by @p name.
+           */
+          std::string
+          get_field_name_by_index(const unsigned int field_index) const;
+
+          /**
+           * Get the data position of the first component of the particle
+           * property specified by @p name in the property vector of a particle.
+           */
+          unsigned int
+          get_position_by_field_name(const std::string &name) const;
+
+          /**
+           * Get the number of components of the particle property specified
+           * by @p name.
+           */
+          unsigned int
+          get_components_by_field_name(const std::string &name) const;
+
+          /**
+           * Get the data position of the first component of the particle
+           * property specified by @p field_index in the property vector
+           * of a particle.
+           */
+          unsigned int
+          get_position_by_field_index(const unsigned int field_index) const;
+
+          /**
+           * Get the number of components of the particle property specified
+           * by @p field_index.
+           */
+          unsigned int
+          get_components_by_field_index(const unsigned int field_index) const;
+
+          /**
+           * Get the data position of the first component of the particle
+           * property specified by @p plugin_index in the property vector
+           * of a particle.
+           */
+          unsigned int
+          get_position_by_plugin_index(const unsigned int plugin_index) const;
+
+          /**
+           * Get the number of components of the particle property specified
+           * by @p plugin_index.
+           */
+          unsigned int
+          get_components_by_plugin_index(const unsigned int plugin_index) const;
+
+          /**
+           * Get the number of fields of the particle property specified
+           * by @p plugin_index.
+           */
+          unsigned int
+          get_fields_by_plugin_index(const unsigned int plugin_index) const;
+
+
+          /**
+           * Return the number of active particle property plugins.
+           */
+          unsigned int
+          n_plugins() const;
+
+          /**
+           * Return the number of active particle property fields.
+           */
+          unsigned int
+          n_fields() const;
+
+          /**
+           * Return the number of active particle property components.
+           */
+          unsigned int
+          n_components() const;
+
+        private:
+          /**
+           * A vector of all property field names.
+           */
+          std::vector<std::string> field_names;
+
+          /**
+           * A vector containing the number of components per property field.
+           */
+          std::vector<unsigned int> components_per_field;
+
+          /**
+           * A vector containing the position index of the first data component
+           * of each field in the property vector of every particle.
+           */
+          std::vector<unsigned int> position_per_field;
+
+          /**
+           * A vector containing the number of property fields per property
+           * plugin.
+           */
+          std::vector<unsigned int> fields_per_plugin;
+
+          /**
+           * A vector containing the number of components per property plugin.
+           */
+          std::vector<unsigned int> components_per_plugin;
+
+          /**
+           * A vector containing the position index of the first data component
+           * of each plugin in the property vector of every particle.
+           */
+          std::vector<unsigned int> position_per_plugin;
+
+          /**
+           * The number of doubles needed to represent a particle's
+           * additional properties.
+           */
+          unsigned int number_of_components;
+
+          /**
+           * The number of distinctly named particle property fields.
+           */
+          unsigned int number_of_fields;
+
+          /**
+           * The number of active particle property plugins.
+           */
+          unsigned int number_of_plugins;
+      };
+
+      enum UpdateTimeFlags
+      {
+        /**
+         * Never update the initially set properties. This is the default
+         * behavior, which is sufficient for particle properties that are
+         * set at the beginning of the model and constant for the whole
+         * simulation time.
+         */
+        update_never,
+        /**
+         * Update the particle properties before every output. This is
+         * sufficient for all passive particle properties that depend on the
+         * current solution, like the current velocity or pressure.
+         */
+        update_output_step,
+        /**
+         * Update the particle properties every nonlinear iteration. This is only necessary
+         * if the properties at the output time depend on some sort of time
+         * integration of solution properties or time varying particle
+         * properties are used while solving the model problem.
+         */
+        update_time_step
+      };
+
+      /**
+       * This enum controls how to initialize the properties of particles that
+       * have been added later than the initial particle creation, e.g. to
+       * improve the load balance or to prevent empty cells.
+       */
+      enum InitializationModeForLateParticles
+      {
+        /**
+         * Initialize the particle as if it were created at the beginning of
+         * the model at its current position with the current solution.
+         */
+        initialize,
+        /**
+         * Use the interpolated properties of the surrounding particles as
+         * calculated by the selected interpolator.
+         */
+        interpolate,
+        /**
+         * Use the interpolated properties of the surrounding particles as
+         * calculated by the selected interpolator except for particles in
+         * boundary cells. These will use the boundary condition of the
+         * compositional fields instead. This mode only makes sense for
+         * properties that are associated with compositional fields through
+         * the parameter 'Compositional fields/Mapped particle properties'.
+         */
+        interpolate_respect_boundary,
+        /**
+         * Initialize the particle properties to zero. If the property is
+         * updated over time its update function is called as usual, if not
+         * the property will remain zero throughout the model run.
+         */
+        initialize_to_zero
+      };
+
+      /**
+       * Interface provides an example of how to extend the Particle class to
+       * include related particle data. This allows users to attach
+       * scalars/vectors/tensors/etc to particles and ensure they are
+       * transmitted correctly over MPI and written to output files.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class Interface : public ParticleInterfaceBase
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          virtual
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const;
+
+          /**
+           * Update function. This function is called every time an update is
+           * requested by need_update() for every cell for every property.
+           * It is expected to update the properties of all particles in the
+           * given range @p particles, which are all in one cell.
+           * It is obvious that
+           * this function is called a lot, so its code should be efficient.
+           * The interface provides a default implementation that does nothing,
+           * therefore derived plugins that do not require an update do not
+           * need to implement this function.
+           *
+           * @param [in] data_position An unsigned integer that denotes which
+           * component of each particle property vector is associated with the
+           * current property. For properties that own several components it
+           * denotes the first component of this property, all other components
+           * fill consecutive entries in the properties vector.
+           *
+           * @param [in] solution A vector of values of the solution variables
+           * at the given particle positions.
+           *
+           * @param [in] gradients A vector of gradients of the solution
+           * variables at the given particle positions.
+           *
+           * @param [in,out] particles The particles that are to be updated
+           * within this function.
+           */
+          virtual
+          void
+          update_particle_properties (const unsigned int data_position,
+                                      const std::vector<Vector<double>> &solution,
+                                      const std::vector<std::vector<Tensor<1,dim>>> &gradients,
+                                      typename ParticleHandler<dim>::particle_iterator_range &particles) const;
+
+          /**
+           * Update function. This function is called every time an update is
+           * request by need_update() for every particle for every property.
+           * It is obvious that
+           * this function is called a lot, so its code should be efficient.
+           * The interface provides a default implementation that does nothing,
+           * therefore derived plugins that do not require an update do not
+           * need to implement this function.
+           *
+           * @param [in] data_position An unsigned integer that denotes which
+           * component of the particle property vector is associated with the
+           * current property. For properties that own several components it
+           * denotes the first component of this property, all other components
+           * fill consecutive entries in the @p particle_properties vector.
+           *
+           * @param [in] solution The values of the solution variables at the
+           * current particle position.
+           *
+           * @param [in] gradients The gradients of the solution variables at
+           * the current particle position.
+           *
+           * @param [in,out] particle The particle that is updated within
+           * the call of this function. The particle location can be accessed
+           * using particle->get_location() and its properties using
+           * particle->get_properties().
+           *
+           * @deprecated Use update_particle_properties() instead.
+           */
+          DEAL_II_DEPRECATED
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const;
+
+
+          /**
+           * Returns an enum, which determines at what times particle properties
+           * are updated. The default implementation returns update_never, which
+           * signals that particle properties should never be updated.
+           * See the documentation of UpdateTimeFlags for a list of possible
+           * values and examples for their use. Every
+           * plugin that implements this function should return the value
+           * appropriate for its purpose, unless it does not need any update,
+           * which is the default. This option saves considerable computation
+           * time in cases, when no plugin needs to update particle properties
+           * over time.
+           */
+          virtual
+          UpdateTimeFlags
+          need_update () const;
+
+          /**
+           * Return which data has to be provided to update all properties.
+           * Note that particle properties can only ask for update_default
+           * (no data), update_values (solution values), and update_gradients
+           * (solution gradients). All other update flags will have no effect.
+           *
+           * @return The necessary update flags for this particle property.
+           */
+          virtual
+          UpdateFlags
+          get_needed_update_flags () const;
+
+          /**
+           * Returns an enum, which determines how this particle property is
+           * initialized for particles that are created later than the initial
+           * particle generation, e.g. to balance the particle load or prevent
+           * empty cells. The default implementation returns
+           * interpolate, which will use the particle interpolator to
+           * set the new particle properties to a value that is interpolated
+           * from the other particles in the cell.
+           * See the documentation of InitializationModeForLateParticles for a
+           * list of possible values and examples for their use. Every
+           * plugin that implements this function should return the value
+           * appropriate for its purpose, unless it wants to use the default
+           * value.
+           */
+          virtual
+          InitializationModeForLateParticles
+          late_initialization_mode () const;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires. Derived classes need to implement this
+           * function.
+           *
+           * The purpose of this function is to return a vector of pairs of a
+           * property name and the number of components associated with this
+           * name (e.g. 1 for scalar properties,
+           * n for n-dimensional vectors).
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          virtual
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const = 0;
+      };
+
+      /**
+       * A particle property that provides storage space for
+       * the properties that particle integrators need to
+       * store. This is an internal property that is not
+       * intended for use outside of the particle integrators
+       * and that will not be written to output files.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class IntegratorProperties : public Interface<dim>
+      {
+        public:
+          /**
+           * Initialization function. Since these properties are set and used
+           * by the integrator this function only resizes them to the correct
+           * size, but does not need to do any initialization.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires. This depends on the chosen integration scheme.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+          /**
+           * Read the parameters this class needs to determine which integrator is used,
+           * and therefore how many properties to reserve.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * The number of integrator properties to store. This variable is initialized in
+           * parse_parameters().
+           */
+          unsigned int n_integrator_properties;
+      };
+
+
+
+      /**
+       * Manager class of properties - This class sets the data of the
+       * collection of particles and updates it over time if requested by the
+       * user selected properties.
+       */
+      template <int dim>
+      class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Empty constructor for Manager
+           */
+          Manager ();
+
+          /**
+           * Destructor for Manager
+           */
+          ~Manager () override;
+
+          /**
+           * Initialization function. This function is called once at the
+           * beginning of the program after parse_parameters is run.
+           */
+          void
+          initialize () override;
+
+          /**
+           * Update function. This function is called once at the
+           * beginning of each timestep.
+           */
+          void
+          update () override;
+
+          /**
+           * Initialization function for particle properties. This function is
+           * called once for each of the particles of a particle
+           * collection after it was created.
+           */
+          void
+          initialize_one_particle (typename ParticleHandler<dim>::particle_iterator &particle) const;
+
+          /**
+           * Initialization function for particle properties. This function is
+           * called once for each of the particles of a particle
+           * collection that were created later than the initial particle
+           * generation.
+           */
+          std::vector<double>
+          initialize_late_particle (const Point<dim> &particle_location,
+                                    const ParticleHandler<dim> &particle_handler,
+                                    const Interpolator::Interface<dim> &interpolator,
+                                    const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell = typename parallel::distributed::Triangulation<dim>::active_cell_iterator()) const;
+
+          /**
+           * Update function for particle properties. This function is
+           * called once every time step for every cell.
+           *
+           * @param particles The particles that are to be updated within
+           * this function.
+           * @param solution The values of the solution variables at the
+           * given particle positions.
+           * @param gradients The gradients of the solution variables at
+           * the given particle positions.
+           */
+          void
+          update_particles (typename ParticleHandler<dim>::particle_iterator_range &particles,
+                            const std::vector<Vector<double>> &solution,
+                            const std::vector<std::vector<Tensor<1,dim>>> &gradients) const;
+
+          /**
+           * Returns an enum, which denotes at what time this class needs to
+           * update particle properties. The result of this class is a
+           * combination of the need_update() functions of all individual
+           * properties that are selected. More precise, it will choose to
+           * update the particle properties as often as the plugin that needs the
+           * most frequent update option requires. This saves considerable
+           * computation time, e.g. in cases when no plugin needs to update particle
+           * properties over time, because the solution does not need to be
+           * evaluated in this case.
+           */
+          UpdateTimeFlags
+          need_update () const;
+
+          /**
+           * Return which data has to be provided to update all properties.
+           * Note that particle properties can only ask for update_default
+           * (no data), update_values (solution values), and update_gradients
+           * (solution gradients). All other update flags will have no effect.
+           */
+          UpdateFlags
+          get_needed_update_flags () const;
+
+          /**
+           * Checks if the particle plugin specified by @p name exists
+           * in this model.
+           */
+          bool
+          plugin_name_exists(const std::string &name) const;
+
+          /**
+           * Checks if the particle property plugin specified by @p first
+           * is executed before another particle property plugin specified
+           * by @p second.
+           *
+           * Throws an assert when one of the plugin names does not
+           * exist. You can use the function plugin_name_exists() to
+           * check in advance whether a plugin exists
+           */
+          bool
+          check_plugin_order(const std::string &first, const std::string &second) const;
+
+          /**
+           * Get the plugin index of the particle plugin specified by @p name.
+           */
+          unsigned int get_plugin_index_by_name(const std::string &name) const;
+
+          /**
+           * Go through the list of all particle properties that have been selected
+           * in the input file (and are consequently currently active) and return
+           * true if one of them has the desired type specified by the template
+           * argument.
+           *
+           * This function can only be called if the given template type (the first template
+           * argument) is a class derived from the Interface class in this namespace.
+           */
+          template <typename ParticlePropertyType,
+                    typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,ParticlePropertyType>::value>>
+          bool
+          has_matching_property () const;
+
+          /**
+           * Go through the list of all particle properties that have been selected
+           * in the input file (and are consequently currently active) and see
+           * if one of them has the type specified by the template
+           * argument or can be cast to that type. If so, return a reference
+           * to it. If no property is active that matches the given type,
+           * throw an exception.
+           *
+           * This function can only be called if the given template type (the first template
+           * argument) is a class derived from the Interface class in this namespace.
+           */
+          template <typename ParticlePropertyType,
+                    typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,ParticlePropertyType>::value>>
+          const ParticlePropertyType &
+          get_matching_property () const;
+
+          /**
+           * Get the number of components required to represent this particle's
+           * properties.
+           *
+           * @return Number of doubles required to represent this particle's
+           * additional properties.
+           */
+          unsigned int
+          get_n_property_components () const;
+
+          /**
+           * Get the size in number of bytes required to represent this
+           * particle's properties for communication. This is essentially the
+           * space needed for the property components plus the space for the
+           * particle position and the space needed for its ID.
+           *
+           * @return Number of bytes required to represent this particle.
+           */
+          std::size_t
+          get_particle_size () const;
+
+          /**
+           * Get the names and number of components of particle properties.
+           *
+           * @return A vector of pairs for each property name and the
+           * corresponding number of components attached to particles.
+           */
+          const ParticlePropertyInformation &
+          get_data_info() const;
+
+          /**
+           * Get the position of the property specified by name in the property
+           * vector of the particles.
+           *
+           * @deprecated This function will be replaced by
+           * ParticlePropertyInformation::get_position_by_field_name(name)
+           */
+          DEAL_II_DEPRECATED
+          unsigned int
+          get_property_component_by_name(const std::string &name) const;
+
+          /**
+           * A function that is used to register particle property
+           * objects in such a way that the Manager can deal with all of them
+           * without having to know them by name. This allows the files in which
+           * individual properties are implemented to register these
+           * properties, rather than also having to modify the Manager class
+           * by adding the new properties class.
+           *
+           * @param name The name under which this particle property
+           * is to be called in parameter files.
+           * @param description A text description of what this particle property
+           *  does and that will be listed in the documentation of the
+           * parameter file.
+           * @param declare_parameters_function A pointer to a function that
+           * declares the parameters for this property.
+           * @param factory_function A pointer to a function that creates such a
+           * property object and returns a pointer to it.
+           */
+          static
+          void
+          register_particle_property (const std::string &name,
+                                      const std::string &description,
+                                      void (*declare_parameters_function) (ParameterHandler &),
+                                      std::unique_ptr<Property::Interface<dim>> (*factory_function) ());
+
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+          /**
+           * @brief Set the particle world index for all particle properties
+           *
+           * @param particle_world_index The index of the particle world.
+           */
+          void set_particle_world_index(unsigned int particle_world_index);
+
+          /**
+           * For the current plugin subsystem, write a connection graph of all of the
+           * plugins we know about, in the format that the
+           * programs dot and neato understand. This allows for a visualization of
+           * how all of the plugins that ASPECT knows about are interconnected, and
+           * connect to other parts of the ASPECT code.
+           *
+           * @param output_stream The stream to write the output to.
+           */
+          static
+          void
+          write_plugin_graph (std::ostream &output_stream);
+
+        private:
+          /**
+           * Stores the names of the plugins which are present
+           * in the order they are executed.
+           */
+          std::vector<std::string> plugin_names;
+
+          /**
+           * A class that stores all information about the particle properties,
+           * their association with property plugins and their storage pattern.
+           */
+          ParticlePropertyInformation property_information;
+      };
+
+      /* -------------------------- inline and template functions ---------------------- */
+
+
+      template <int dim>
+      template <typename ParticlePropertyType, typename>
+      inline
+      bool
+      Manager<dim>::has_matching_property () const
+      {
+        return this->template has_matching_plugin_object<ParticlePropertyType>();
+      }
+
+
+      template <int dim>
+      template <typename ParticlePropertyType, typename>
+      inline
+      const ParticlePropertyType &
+      Manager<dim>::get_matching_property () const
+      {
+        return this->template get_matching_plugin_object<ParticlePropertyType>();
+      }
+
+
+      /**
+       * Given a class name, a name, and a description for the parameter file for
+       * a particle property, register it with the aspect::Particle:: class.
+       *
+       * @ingroup Particle
+       */
+#define ASPECT_REGISTER_PARTICLE_PROPERTY(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_PARTICLE_PROPERTY_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Property::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::Particle::Property::Manager<2>::register_particle_property, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Property::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::Particle::Property::Manager<3>::register_particle_property, \
+                                name, description); \
+  }
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/melt_particle.h.bak b/include/aspect/particle/property/melt_particle.h.bak
new file mode 100644
index 00000000000..52a8ce8efbf
--- /dev/null
+++ b/include/aspect/particle/property/melt_particle.h.bak
@@ -0,0 +1,115 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_melt_particle_h
+#define _aspect_particle_property_melt_particle_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * Implementation of a plugin in which the particle
+       * property is defined as presence of melt above the
+       * melt transport threshold. This property is set
+       * to 0 if melt is not present and set to 1 if melt
+       * is present.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class MeltParticle : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties over time.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * The pressure and temperature need the values of their variables.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          double threshold_for_melt_presence;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/pT_path.h.bak b/include/aspect/particle/property/pT_path.h.bak
new file mode 100644
index 00000000000..6c6331a883a
--- /dev/null
+++ b/include/aspect/particle/property/pT_path.h.bak
@@ -0,0 +1,119 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_pT_path_h
+#define _aspect_particle_property_pT_path_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * Implementation of a plugin in which the particle
+       * property is defined as the current pressure and
+       * temperature at this position. This can be used
+       * to generate pressure-temperature paths of
+       * material points over time.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class PTPath : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * beginning of the program after parse_parameters is run.
+           *
+           * This specific function makes sure that the objects that describe
+           * initial conditions remain available throughout the run of the
+           * program.
+           */
+          void
+          initialize () override;
+
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties over time.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * The pressure and temperature need the values of their variables.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+        private:
+          /**
+           * A shared pointer to the initial temperature object
+           * that ensures that the current object can continue
+           * to access the initial temperature object beyond the
+           * first time step.
+           */
+          std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/position.h.bak b/include/aspect/particle/property/position.h.bak
new file mode 100644
index 00000000000..67f24247df6
--- /dev/null
+++ b/include/aspect/particle/property/position.h.bak
@@ -0,0 +1,87 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_position_h
+#define _aspect_particle_property_position_h
+
+#include <aspect/particle/property/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that sets particle properties to the current position.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class Position : public Interface<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties over time.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/reference_position.h.bak b/include/aspect/particle/property/reference_position.h.bak
new file mode 100644
index 00000000000..0de6a35f06b
--- /dev/null
+++ b/include/aspect/particle/property/reference_position.h.bak
@@ -0,0 +1,87 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_reference_position_h
+#define _aspect_particle_property_reference_position_h
+
+#include <aspect/particle/property/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that sets particle properties to the current position.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class ReferencePosition : public Interface<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle reference position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties over time.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/strain_rate.h.bak b/include/aspect/particle/property/strain_rate.h.bak
new file mode 100644
index 00000000000..d8c7460757d
--- /dev/null
+++ b/include/aspect/particle/property/strain_rate.h.bak
@@ -0,0 +1,97 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_strain_rate_h
+#define _aspect_particle_property_strain_rate_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that saves the time evolution of strain rate onto the particles.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class StrainRate : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties over time.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * The velocity particle property needs the values of the velocity
+           * solution.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/velocity.h.bak b/include/aspect/particle/property/velocity.h.bak
new file mode 100644
index 00000000000..70d710430bd
--- /dev/null
+++ b/include/aspect/particle/property/velocity.h.bak
@@ -0,0 +1,96 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_velocity_h
+#define _aspect_particle_property_velocity_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that sets particle properties to the current velocity.
+       *
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class Velocity : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Initialization function. This function is called once at the
+           * creation of every particle for every property to initialize its
+           * value.
+           *
+           * @param [in] position The current particle position.
+           * @param [in,out] particle_properties The properties of the particle
+           * that is initialized within the call of this function. The purpose
+           * of this function should be to extend this vector by a number of
+           * properties.
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * This implementation tells the particle manager that
+           * we need to update particle properties over time.
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * Return which data has to be provided to update the property.
+           * The velocity particle property needs the values of the velocity
+           * solution.
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Set up the information about the names and number of components
+           * this property requires.
+           *
+           * @return A vector that contains pairs of the property names and the
+           * number of components this property plugin defines.
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/property/viscoplastic_strain_invariants.h.bak b/include/aspect/particle/property/viscoplastic_strain_invariants.h.bak
new file mode 100644
index 00000000000..d7a9c18da85
--- /dev/null
+++ b/include/aspect/particle/property/viscoplastic_strain_invariants.h.bak
@@ -0,0 +1,109 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_property_viscoplastic_strain_invariant_h
+#define _aspect_particle_property_viscoplastic_strain_invariant_h
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/visco_plastic.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      /**
+       * A class that calculates the finite strain invariant a particle has
+       * experienced and assigns it to either the plastic and/or viscous strain field based
+       * on whether the material is plastically yielding, or the total strain field
+       * used in the visco plastic material model. The implementation of this property
+       * is equivalent to the implementation for compositional fields that is located in
+       * the plugin <code>benchmarks/buiter_et_al_2008_jgr/plugin/finite_strain_invariant.cc</code>,
+       * and is effectively the same as what the visco plastic material model uses for compositional fields.
+       * @ingroup ParticleProperties
+       */
+      template <int dim>
+      class ViscoPlasticStrainInvariant : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ViscoPlasticStrainInvariant ();
+
+          void initialize () override;
+
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::initialize_one_particle_property()
+           */
+          void
+          initialize_one_particle_property (const Point<dim> &position,
+                                            std::vector<double> &particle_properties) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
+           */
+          virtual
+          void
+          update_particle_property (const unsigned int data_position,
+                                    const Vector<double> &solution,
+                                    const std::vector<Tensor<1,dim>> &gradients,
+                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::need_update()
+           */
+          UpdateTimeFlags
+          need_update () const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::get_needed_update_flags()
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * @copydoc aspect::Particle::Property::Interface::get_property_information()
+           */
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const override;
+
+        private:
+          unsigned int n_components;
+
+          /**
+           * An object that is used to compute the particle property. Since the
+           * object is expensive to create and is needed often it is kept as a
+           * member variable. Because it is changed inside a const member function
+           * (update_particle_property) it has to be mutable, but since it is
+           * only used inside that function and always set before being used
+           * that is not a problem. This implementation is not thread safe,
+           * but it is currently not used in a threaded context.
+           */
+          mutable MaterialModel::MaterialModelInputs<dim> material_inputs;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/particle/world.h.bak b/include/aspect/particle/world.h.bak
new file mode 100644
index 00000000000..ad5578d3b3e
--- /dev/null
+++ b/include/aspect/particle/world.h.bak
@@ -0,0 +1,531 @@
+/*
+ Copyright (C) 2012 - 2021 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_particle_world_h
+#define _aspect_particle_world_h
+
+#include <aspect/global.h>
+
+#include <deal.II/particles/particle.h>
+#include <deal.II/particles/particle_accessor.h>
+#include <deal.II/particles/particle_iterator.h>
+#include <deal.II/particles/particle_handler.h>
+#include <deal.II/particles/property_pool.h>
+
+#include <deal.II/matrix_free/fe_point_evaluation.h>
+
+#include <aspect/particle/generator/interface.h>
+#include <aspect/particle/integrator/interface.h>
+#include <aspect/particle/interpolator/interface.h>
+#include <aspect/particle/property/interface.h>
+
+#include <aspect/simulator_access.h>
+#include <aspect/simulator_signals.h>
+
+#include <deal.II/base/timer.h>
+#include <deal.II/base/array_view.h>
+
+#include <boost/serialization/unique_ptr.hpp>
+
+namespace aspect
+{
+  template <int dim>
+  struct SimulatorSignals;
+
+  namespace Particle
+  {
+    using namespace dealii;
+    using namespace dealii::Particles;
+
+    namespace Generator
+    {
+      template <int dim>
+      class Interface;
+    }
+
+
+    namespace Property
+    {
+      template <int dim>
+      class Manager;
+    }
+
+    namespace internal
+    {
+      /**
+       * This class evaluates the solution vector at arbitrary positions inside a cell.
+       * This base class only provides the interface for SolutionEvaluatorsImplementation.
+       * See there for more details.
+       */
+      template <int dim>
+      class SolutionEvaluators
+      {
+        public:
+          /**
+           * virtual Destructor.
+           */
+          virtual ~SolutionEvaluators() = default;
+
+          /**
+           * Reinitialize all variables to evaluate the given solution for the given cell
+           * and the given positions. The update flags control if only the solution or
+           * also the gradients should be evaluated.
+           * If other flags are set an assertion is triggered.
+           */
+          virtual void
+          reinit(const typename DoFHandler<dim>::active_cell_iterator &cell,
+                 const ArrayView<Point<dim>> &positions,
+                 const ArrayView<double> &solution_values,
+                 const UpdateFlags update_flags) = 0;
+
+          /**
+           * Fill @p solution with all solution components at the given @p evaluation_point. Note
+           * that this function only works after a successful call to reinit(),
+           * because this function only returns the results of the computation that
+           * happened in reinit().
+           */
+          virtual void get_solution(const unsigned int evaluation_point,
+                                    Vector<double> &solution) = 0;
+
+          /**
+           * Fill @p gradients with all solution gradients at the given @p evaluation_point. Note
+           * that this function only works after a successful call to reinit(),
+           * because this function only returns the results of the computation that
+           * happened in reinit().
+           */
+          virtual void get_gradients(const unsigned int evaluation_point,
+                                     std::vector<Tensor<1, dim>> &gradients) = 0;
+
+          /**
+           * Return the evaluator for velocity or fluid velocity. This is the only
+           * information necessary for advecting particles.
+           */
+          virtual FEPointEvaluation<dim, dim> &
+          get_velocity_or_fluid_velocity_evaluator(const bool use_fluid_velocity) = 0;
+
+          /**
+           * Return the cached mapping information.
+           */
+          virtual NonMatching::MappingInfo<dim> &
+          get_mapping_info() = 0;
+      };
+
+      /**
+       * A function to create a pointer to a SolutionEvaluators object.
+       */
+      template <int dim>
+      std::unique_ptr<internal::SolutionEvaluators<dim>>
+      construct_solution_evaluators(const SimulatorAccess<dim> &simulator_access,
+                                    const UpdateFlags update_flags);
+    }
+
+    /**
+     * This class manages the storage and handling of particles. It provides
+     * interfaces to generate and store particles, functions to initialize,
+     * update and advect them, and ways to retrieve information about the
+     * particles. The implementation of most of these methods is outsourced
+     * to different plugin systems, this class is mostly concerned with
+     * managing the interactions of the different systems with the code
+     * outside the particle world.
+     *
+     * @ingroup Particle
+     */
+    template <int dim>
+    class World : public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Default World constructor.
+         */
+        World();
+
+        /**
+         * Default World destructor.
+         */
+        ~World() override;
+
+        /**
+         * Initialize the particle world.
+         */
+        void initialize();
+
+        /**
+         * Update the particle world.
+        */
+        void update();
+
+        /**
+         * Get the particle property manager for this particle world.
+         *
+         * @return The property manager for this world.
+         */
+        const Property::Manager<dim> &
+        get_property_manager() const;
+
+        /**
+         * Get the const particle handler for this particle world.
+         *
+         * @return The particle handler for this world.
+         */
+        const Particles::ParticleHandler<dim> &
+        get_particle_handler() const;
+
+        /**
+         * Get the particle handler for this particle world.
+         * There is no get_particles() function in the deal.II
+         * ParticleHandler, so we get and set the positions
+         * of the particles. These getter/setter functions are
+         * not const, and neither are the calling functions,
+         * but the existing get_particle_handler is.
+         * Therefore this non-const function is added.
+         *
+         * @return The particle handler for this world.
+         */
+        Particles::ParticleHandler<dim> &
+        get_particle_handler();
+
+        /**
+         * Copy the state of particle handler @p from_particle_handler into the
+         * particle handler @p to_particle_handler. This will copy
+         * all particles and properties and leave @p to_particle_handler
+         * as an identical copy of @p from_particle_handler, assuming it
+         * was set up by this particle world class. This means we assume
+         * @p from_particle_handler uses the same triangulation and
+         * particle properties as are used in this model. Existing
+         * particles in @p to_particle_handler are deleted.
+         *
+         * This function is expensive as it has to duplicate all data
+         * in @p from_particle_handler, and insert it into @p to_particle_handler,
+         * which may be a significant amount of data. However, it can
+         * be useful to save the state of a particle
+         * collection at a certain point in time and reset this
+         * state later under certain conditions, for example if
+         * a timestep has to be undone and repeated.
+         */
+        void copy_particle_handler (const Particles::ParticleHandler<dim> &from_particle_handler,
+                                    Particles::ParticleHandler<dim> &to_particle_handler) const;
+
+        /**
+         * @brief Stores a copy of the particle handler in particle_handler_backup. This copy can be
+         * used to restore the position and properties of the particles for example after advection
+         * solver iterations of the iterated advection scheme or when a timestep has to be repeated.
+         */
+        void backup_particles ();
+
+        /**
+         * @brief Restores the particle handler particle_handler based on the copy
+         * in particle_handler_backup. This restores the position and properties of the particles
+         * to those in the copy and can be used for example after advection solver iterations
+         * of the iterated advection scheme or when a timestep has to be repeated.
+         */
+        void restore_particles ();
+
+
+        /**
+         * Do initial logic for handling pre-refinement steps
+         */
+        void setup_initial_state ();
+
+        /**
+         * Get the particle interpolator for this particle world.
+         *
+         * @return The interpolator for this world.
+         */
+        const Interpolator::Interface<dim> &
+        get_interpolator() const;
+
+        /**
+         * Initialize the particle properties.
+         */
+        void generate_particles();
+        /**
+         * Initialize the particle properties.
+         */
+        void initialize_particles();
+
+        /**
+         * Advance particles by the old timestep using the current
+         * integration scheme. This accounts for the fact that the particles
+         * are actually still at their old positions and the current timestep
+         * length is already updated for the next step at the time this
+         * function is called.
+         */
+        void advance_timestep();
+
+        /**
+         * Return the total number of particles in the simulation. This
+         * function is useful for monitoring how many particles have been
+         * lost by falling out of the domain. Note that this function does
+         * not compute the number of particles, because that is an expensive
+         * global MPI operation. Instead it returns the number, which is
+         * updated internally every time it might change by a call to
+         * update_n_global_particles().
+         *
+         * @return Total number of particles in simulation.
+         */
+        types::particle_index n_global_particles() const;
+
+        /**
+         * This callback function is registered within Simulator by the
+         * constructor of this class and will be
+         * called from Simulator during construction. It allows to attach slot
+         * functions to the provided SimulatorSignals. This world will register
+         * the register_store_callback_function() and
+         * register_load_callback_function() to the
+         * pre_refinement_store_user_data signal and the
+         * post_refinement_load_user_data signal respectively.
+         */
+        void
+        connect_to_signals(aspect::SimulatorSignals<dim> &signals);
+
+        /**
+         * Called by listener functions from Triangulation for every cell
+         * before a refinement step. A weight is attached to every cell
+         * depending on the number of contained particles.
+         */
+#if DEAL_II_VERSION_GTE(9,6,0)
+        unsigned int
+        cell_weight(const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
+                    const CellStatus status);
+#else
+        unsigned int
+        cell_weight(const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
+                    const typename parallel::distributed::Triangulation<dim>::CellStatus status);
+#endif
+
+        /**
+         * Update the particle properties if necessary.
+         */
+        void update_particles();
+
+        /**
+         * Serialize the contents of this class.
+         */
+        template <class Archive>
+        void serialize (Archive &ar, const unsigned int version);
+
+        /**
+         * Save the state of the object.
+         */
+        virtual
+        void
+        save (std::ostringstream &os) const;
+
+        /**
+         * Restore the state of the object.
+         */
+        virtual
+        void
+        load (std::istringstream &is);
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         *
+         * @param world_index Parse the parameters for the Particle world with this index.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm, const unsigned int world_index);
+
+      private:
+        struct ParticleLoadBalancing
+        {
+          enum Kind
+          {
+            no_balancing = 0x0,
+            remove_particles = 0x1,
+            add_particles = 0x2,
+            repartition = 0x4,
+            remove_and_add_particles = remove_particles | add_particles
+          };
+        };
+
+        /**
+         * Generation scheme for creating particles in this world
+         */
+        std::unique_ptr<Generator::Interface<dim>> generator;
+
+        /**
+         * Integration scheme for moving particles in this world
+         */
+        std::unique_ptr<Integrator::Interface<dim>> integrator;
+
+        /**
+         * Interpolation scheme for moving particles in this world
+         */
+        std::unique_ptr<Interpolator::Interface<dim>> interpolator;
+
+        /**
+         * Particle handler object that is responsible for storing and
+         * managing the internal particle structures.
+         */
+        std::unique_ptr<Particles::ParticleHandler<dim>> particle_handler;
+
+        /**
+         * Particle handler object that is responsible for storing and
+         * managing the internal particle structures before starting nonlinear iterations
+         * such that the particle position and properties can be restored after
+         * each outer advection iteration.
+         */
+        Particles::ParticleHandler<dim> particle_handler_backup;
+
+        /**
+         * The property manager stores information about the additional
+         * particle properties and handles the initialization and update of
+         * these properties.
+         */
+        std::unique_ptr<Property::Manager<dim>> property_manager;
+
+        /**
+         * Strategy for particle load balancing.
+         */
+        typename ParticleLoadBalancing::Kind particle_load_balancing;
+
+        /**
+         * Lower limit for particle number per cell. This limit is
+         * useful for adaptive meshes to prevent fine cells from being empty
+         * of particles. It will be checked and enforced after mesh
+         * refinement and after particle movement. If there are
+         * n_number_of_particles < min_particles_per_cell
+         * particles in one cell then
+         * min_particles_per_cell - n_number_of_particles particles are
+         * generated and randomly placed in this cell. If the particles carry
+         * properties the individual property plugins control how the
+         * properties of the new particles are initialized.
+         */
+        unsigned int min_particles_per_cell;
+
+        /**
+         * Upper limit for particle number per cell. This limit is
+         * useful for adaptive meshes to prevent coarse cells from slowing down
+         * the whole model. It will be checked and enforced after mesh
+         * refinement, after MPI transfer of particles and after particle
+         * movement. If there are
+         * n_number_of_particles > max_particles_per_cell
+         * particles in one cell then
+         * n_number_of_particles - max_particles_per_cell
+         * particles in this cell are randomly chosen and destroyed.
+         */
+        unsigned int max_particles_per_cell;
+
+        /**
+         * The computational cost of a single particle. This is an input
+         * parameter that is set during initialization and is only used if the
+         * particle load balancing strategy 'repartition' is used. This value
+         * determines how costly the computation of a single particle is compared
+         * to the computation of a whole cell, which is arbitrarily defined
+         * to represent a cost of 1000.
+         */
+        unsigned int particle_weight;
+
+        /**
+         * Some particle interpolation algorithms require knowledge
+         * about particles in neighboring cells. To allow this,
+         * particles in ghost cells need to be exchanged between the
+         * processes neighboring this cell. This parameter determines
+         * whether this transport is happening.
+         */
+        bool update_ghost_particles;
+
+        /**
+         * Get a map between subdomain id and the neighbor index. In other words
+         * the returned map answers the question: Given a subdomain id, which
+         * neighbor of the current processor's domain (in terms of a contiguous
+         * number from 0 to n_neighbors) owns this subdomain?
+         */
+        std::map<types::subdomain_id, unsigned int>
+        get_subdomain_id_to_neighbor_map() const;
+
+        /**
+         * Apply the bounds for the maximum and minimum number of particles
+         * per cell, if the appropriate @p particle_load_balancing strategy
+         * has been selected.
+         */
+        void
+        apply_particle_per_cell_bounds();
+
+        /**
+         * Advect the particle positions by one integration step. Needs to be
+         * called until integrator->continue() returns false.
+         */
+        void advect_particles();
+
+        /**
+         * Initialize the particle properties of one cell.
+         */
+        void
+        local_initialize_particles(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                                   const typename ParticleHandler<dim>::particle_iterator &end_particle);
+
+        /**
+         * Update the particle properties of one cell.
+         */
+        void
+        local_update_particles(const typename DoFHandler<dim>::active_cell_iterator &cell,
+                               internal::SolutionEvaluators<dim> &evaluators);
+
+        /**
+         * Advect the particles of one cell. Performs only one step for
+         * multi-step integrators. Needs to be called until integrator->continue()
+         * evaluates to false. Particles that moved out of their old cell
+         * during this advection step are removed from the local multimap and
+         * stored in @p particles_out_of_cell for further treatment (sorting
+         * them into the new cell).
+         */
+        void
+        local_advect_particles(const typename DoFHandler<dim>::active_cell_iterator &cell,
+                               const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
+                               internal::SolutionEvaluators<dim> &evaluators);
+
+        /**
+         * This function registers the necessary functions to the
+         * @p signals that the @p particle_handler needs to know about.
+         */
+        void
+        connect_particle_handler_signals(aspect::SimulatorSignals<dim> &signals,
+                                         ParticleHandler<dim> &particle_handler,
+                                         const bool connect_to_checkpoint_signals = true) const;
+    };
+
+    /* -------------------------- inline and template functions ---------------------- */
+
+    template <int dim>
+    template <class Archive>
+    void World<dim>::serialize (Archive &ar, const unsigned int)
+    {
+      // Note that although Boost claims to handle serialization of pointers
+      // correctly, at least for the case of unique_ptr it seems to not work.
+      // It works correctly when archiving the content of the pointer instead.
+      ar
+      &(*particle_handler)
+      ;
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/plugins.h.bak b/include/aspect/plugins.h.bak
new file mode 100644
index 00000000000..86d77fc9f1e
--- /dev/null
+++ b/include/aspect/plugins.h.bak
@@ -0,0 +1,808 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_plugins_h
+#define _aspect_plugins_h
+
+#include <aspect/global.h>
+
+#include <deal.II/base/utilities.h>
+#include <deal.II/base/parameter_handler.h>
+#include <tuple>
+#include <deal.II/base/exceptions.h>
+
+#include <boost/core/demangle.hpp>
+
+#include <string>
+#include <list>
+#include <set>
+#include <map>
+#include <iostream>
+#include <typeinfo>
+#include <type_traits>
+
+
+namespace aspect
+{
+  template <int dim> class SimulatorAccess;
+
+  namespace Plugins
+  {
+    using namespace dealii;
+
+    /**
+     * This function returns if a given plugin (e.g. a material model returned
+     * from SimulatorAccess::get_material_model() ) matches a certain plugin
+     * type (e.g. MaterialModel::Simple). This check is needed, because often
+     * it is only possible to get a reference to an Interface, not the actual
+     * plugin type, but the actual plugin type might be important. For example
+     * a radial gravity model might only be implemented for spherical geometry
+     * models, and would want to check if the current geometry is in fact a
+     * spherical shell.
+     *
+     * This function can only be called with types that correspond to the same
+     * plugin system. In other words, the type of the plugin has to either be
+     * derived from the type of the object being tested, or they have to both
+     * be derived from a common base class. This function is not appropriate
+     * to check whether a class `TestType` derived from an interface base
+     * class is *also* derived from a second base class `PluginType`. For these
+     * cases, use a `dynamic_cast`.
+     */
+    template <typename TestType, typename PluginType,
+              typename = typename std::enable_if_t<std::is_base_of<PluginType,TestType>::value>>
+    inline
+    bool
+    plugin_type_matches (const PluginType &object)
+    {
+      return (dynamic_cast<const TestType *> (&object) != nullptr);
+    }
+
+    /**
+     * This function converts a reference to a type (in particular a reference
+     * to an interface class) into a reference to a different type (in
+     * particular a plugin class). This allows accessing members of the plugin
+     * that are not specified in the interface class. Note that you should
+     * first check if the plugin type is actually convertible by calling
+     * plugin_matches_type() before calling this function. If the plugin is
+     * not convertible this function throws an exception.
+     *
+     * This function can only be called with types that correspond to the same
+     * plugin system. In other words, the type of the plugin has to either be
+     * derived from the type of the object being tested, or they have to both
+     * be derived from a common base class. This function is not appropriate
+     * to convert references to classes whether a class `TestType` derived
+     * from an interface base class is *also* derived from a second base
+     * class `PluginType`. For these cases, use a `dynamic_cast`.
+     */
+    template <typename TestType, typename PluginType,
+              typename = typename std::enable_if_t<std::is_base_of<PluginType,TestType>::value>>
+    inline
+    TestType &
+    get_plugin_as_type (PluginType &object)
+    {
+      AssertThrow(plugin_type_matches<TestType>(object),
+                  ExcMessage("You have requested to convert a plugin of type <"
+                             + boost::core::demangle(typeid(PluginType).name())
+                             + "> into type <"
+                             + boost::core::demangle(typeid(TestType).name()) +
+                             ">, but this cast cannot be performed."));
+
+      // We can safely dereference the pointer, because we checked above that
+      // the object is actually of type TestType, and so the result
+      // is not a nullptr.
+      return *dynamic_cast<TestType *> (&object);
+    }
+  }
+
+  namespace Plugins
+  {
+    using namespace dealii;
+
+
+    /**
+     * A base class for all plugin systems. The class ensures that a
+     * common set of functions is declared as `virtual` (namely, the
+     * destructor, `initialize()`, `update()`, and
+     * `parse_parameters()`) and implemented with empty bodies so that
+     * derived interface classes do not have to declare these
+     * functions themselves. Furthermore, the class provides an empty,
+     * `static` function `declare_parameters()` that derived classes
+     * can re-implement to declare their parameters.
+     */
+    class InterfaceBase
+    {
+      public:
+        /**
+         * Destructor. Made virtual to enforce that derived classes also have
+         * virtual destructors.
+         */
+        virtual ~InterfaceBase() = default;
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters() is run and after
+         * the SimulatorAccess (if applicable) is initialized.
+         *
+         * The default implementation of this function does nothing, but
+         * plugins that derive from this class (via the <code>Interface</code>
+         * classes of their respective plugin systems) may overload it
+         * if they want something to happen upon startup of the
+         * Simulator object to which the plugin contributes.
+         */
+        virtual
+        void
+        initialize ();
+
+        /**
+         * A function that is called at the beginning of each time step.
+         *
+         * The default implementation of this function does nothing, but
+         * plugins that derive from this class (via the <code>Interface</code>
+         * classes of their respective plugin systems) may overload it
+         * if they want something to happen upon startup of the
+         * Simulator object to which the plugin contributes.
+         */
+        virtual
+        void
+        update ();
+
+        /**
+         * Declare the parameters the plugin takes through input files. The
+         * default implementation of this function does not describe any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters. On
+         * the other hand, most plugins do have run-time parameters, and
+         * they may then overload this function.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * The default implementation of this function does not read any
+         * parameters. Consequently, derived classes do not have to overload
+         * this function if they do not take any runtime parameters. On
+         * the other hand, most plugins do have run-time parameters, and
+         * they may then overload this function.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+    };
+
+
+
+    /**
+     * A base class for "plugin manager" classes. Plugin manager classes are
+     * used in places where one can legitimately use more than one plugin of
+     * a certain kind. For example, while there can only ever be one geometry
+     * (and consequently, the Simulator class only stores a single object of
+     * type derived from GeometryModels::Interface), one can have many different
+     * postprocessor objects at the same time. In these circumstances, the
+     * Simulator class stores a Postprocess::Manager object that internally
+     * stores zero or more objects of type derived from Postprocess::Interface.
+     * Since there are many places inside ASPECT where we need these "plugin
+     * manager" classes, the current class provides some common functionality
+     * to all of these classes.
+     *
+     * The class takes as template argument the type of the derived
+     * class's interface type. Since a manager is always also a plugin
+     * (to the Simulator class) itself, the current class is derived from
+     * the `InterfaceBase` class as well.
+     */
+    template <typename InterfaceType>
+    class ManagerBase : public InterfaceBase
+    {
+      public:
+        /**
+         * A function that is called at the beginning of each time step,
+         * calling the update function of the individual heating models.
+         */
+        void
+        update () override;
+
+        /**
+         * Go through the list of all plugins that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename PluginType,
+                  typename = typename std::enable_if_t<std::is_base_of<InterfaceType,PluginType>::value>>
+        bool
+        has_matching_plugin_object () const;
+
+        /**
+         * Go through the list of all plugins that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no postprocessor is active that matches the given type,
+         * throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename PluginType,
+                  typename = typename std::enable_if_t<std::is_base_of<InterfaceType,PluginType>::value>>
+        const PluginType &
+        get_matching_plugin_object () const;
+
+      protected:
+        /**
+         * A list of plugin objects that have been requested in the
+         * parameter file.
+         */
+        std::list<std::unique_ptr<InterfaceType>> plugin_objects;
+    };
+
+
+    template <typename InterfaceType>
+    void ManagerBase<InterfaceType>::update()
+    {
+      for (const auto &plugin : plugin_objects)
+        {
+          plugin->update();
+        }
+    }
+
+
+    template <typename InterfaceType>
+    template <typename PluginType, typename>
+    inline
+    bool
+    ManagerBase<InterfaceType>::has_matching_plugin_object () const
+    {
+      for (const auto &p : plugin_objects)
+        if (Plugins::plugin_type_matches<PluginType>(*p))
+          return true;
+      return false;
+    }
+
+
+    template <typename InterfaceType>
+    template <typename PluginType, typename>
+    inline
+    const PluginType &
+    ManagerBase<InterfaceType>::get_matching_plugin_object () const
+    {
+      AssertThrow(has_matching_plugin_object<PluginType> (),
+                  ExcMessage("You asked the object managing a collection of plugins for a "
+                             "plugin object of type <" + boost::core::demangle(typeid(PluginType).name()) + "> "
+                             "that could not be found in the current model. You need to "
+                             "activate this plugin in the input file for it to be "
+                             "available."));
+
+      for (const auto &p : plugin_objects)
+        if (Plugins::plugin_type_matches<PluginType>(*p))
+          return Plugins::get_plugin_as_type<PluginType>(*p);
+
+      // We will never get here, because we had the Assert above. Just to avoid warnings.
+      return Plugins::get_plugin_as_type<PluginType>(**(plugin_objects.begin()));
+    }
+  }
+
+  namespace internal
+  {
+    /**
+     * A namespace for the definition of classes that have to do with the
+     * plugin architecture of ASPECT.
+     */
+    namespace Plugins
+    {
+      using namespace dealii;
+
+
+
+      /**
+       * An internal class that is used in the definition of the
+       * ASPECT_REGISTER_* macros. Given a registration function, a classname,
+       * a description of what it does, and a name for the parameter file, it
+       * registers the model with the proper authorities.
+       *
+       * The registration happens in the constructor. The typical use case of
+       * this function is thus the creation of a dummy object in some
+       * otherwise unused namespace.
+       */
+      template <typename InterfaceClass,
+                typename ModelClass>
+      struct RegisterHelper
+      {
+        /**
+         * Constructor. Given a pointer to a registration function and name
+         * and description of the class, this constructor registers the class
+         * passed as second template argument.
+         */
+        RegisterHelper (void (*register_function) (const std::string &,
+                                                   const std::string &,
+                                                   void ( *)(ParameterHandler &),
+                                                   std::unique_ptr<InterfaceClass> ( *)()),
+                        const char *name,
+                        const char *description)
+        {
+          register_function (name,
+                             description,
+                             &ModelClass::declare_parameters,
+                             &factory);
+        }
+
+        /**
+         * A factory object that just creates object of the type registered by
+         * this class.
+         */
+        static
+        std::unique_ptr<InterfaceClass> factory ()
+        {
+          return std::make_unique<ModelClass>();
+        }
+      };
+
+
+      /**
+       * A class that stores a list of registered plugins for the given
+       * interface type.
+       */
+      template <typename InterfaceClass>
+      struct PluginList
+      {
+        /**
+         * A type describing everything we need to know about a plugin.
+         *
+         * The entries in the tuple are:
+         * - The name by which it can be selected.
+         * - A description of this plugin that will show up in the
+         *   documentation in the parameter file.
+         * - A function that can declare the run-time parameters this
+         *   plugin takes from the parameter file.
+         * - A function that can produce objects of this plugin type.
+         */
+        using PluginInfo
+        = std::tuple<std::string,
+        std::string,
+        void ( *) (ParameterHandler &),
+        std::unique_ptr<InterfaceClass>( *) ()>;
+
+        /**
+         * A pointer to a list of all registered plugins.
+         *
+         * The object is a pointer rather than an object for the following
+         * reason: objects with static initializers (such as =0) are
+         * initialized before any objects for which one needs to run
+         * constructors. Consequently, we can be sure that this pointer is set
+         * to zero before we ever try to register a postprocessor, and
+         * consequently whenever we run Manager::register_postprocessor, we
+         * need not worry whether we try to add something to this list before
+         * the lists's constructor has successfully run
+         */
+        static std::list<PluginInfo> *plugins;
+
+        /**
+         * Destructor.
+         */
+        ~PluginList ();
+
+        /**
+         * Register a plugin by name, description, parameter declaration
+         * function, and factory function. See the discussion for the
+         * PluginInfo type above for more information on their meaning.
+         */
+        static
+        void register_plugin (const std::string &name,
+                              const std::string &description,
+                              void (*declare_parameters_function) (ParameterHandler &),
+                              std::unique_ptr<InterfaceClass> (*factory_function) ());
+
+        /**
+         * Generate a list of names of the registered plugins separated by '|'
+         * so that they can be taken as the input for Patterns::Selection.
+         *
+         * To make it easier to visually scan through the list of plugins,
+         * names are sorted alphabetically.
+         */
+        static
+        std::string get_pattern_of_names ();
+
+        /**
+         * Return a string that describes all registered plugins using the
+         * descriptions that have been provided at the time of registration.
+         *
+         * To make it easier to visually scan through the list of plugins,
+         * names are sorted alphabetically.
+         */
+        static
+        std::string get_description_string ();
+
+        /**
+         * Let all registered plugins define their parameters.
+         */
+        static
+        void declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Given the name of one plugin, create a corresponding object and
+         * return a pointer to it. The second argument provides a hint where
+         * this function was called from, to be printed in case there is an
+         * error.
+         *
+         * Ownership of the object is handed over to the caller of this
+         * function.
+         */
+        static
+        std::unique_ptr<InterfaceClass>
+        create_plugin (const std::string  &name,
+                       const std::string &documentation);
+
+        /**
+         * Given the name of one plugin, create a corresponding object and
+         * return a pointer to it. The second argument provides a hint where
+         * this function was called from, to be printed in case there is an
+         * error. Before returning, let the newly created object read its
+         * run-time parameters from the parameter object.
+         *
+         * Ownership of the object is handed over to the caller of this
+         * function.
+         */
+        static
+        std::unique_ptr<InterfaceClass>
+        create_plugin (const std::string  &name,
+                       const std::string &documentation,
+                       ParameterHandler &prm);
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param plugin_system_name The name to be used for the current
+         *   plugin system. This name will be used for the "Interface"
+         *   class to which all plugins connect.
+         * @param output_stream The stream to write the output to.
+         * @param attachment_point The point to which a plugin subsystem
+         *   feeds information. By default, this is the Simulator class,
+         *   but some plugin systems (most notably the visualization
+         *   postprocessors, which feeds to one of the postprocessor
+         *   classes) hook into other places. If other than the
+         *   "Simulator" default, the attachment point should be of
+         *   the form <code>typeid(ClassName).name()</code> as this is
+         *   the form used by this function to identify nodes in the
+         *   plugin graph.
+         */
+        static
+        void
+        write_plugin_graph (const std::string &plugin_system_name,
+                            std::ostream      &output_stream,
+                            const std::string &attachment_point = "Simulator");
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcUnknownPlugin,
+                        std::string,
+                        << "Can't create a plugin of name <" << arg1
+                        << "> because such a plugin hasn't been declared.");
+      };
+
+
+      /* ------------------------ template and inline functions --------------------- */
+
+      template <typename InterfaceClass>
+      PluginList<InterfaceClass>::
+      ~PluginList ()
+      {
+        // if any plugins have been registered, then delete
+        // the list
+        if (plugins != nullptr)
+          delete plugins;
+        plugins = nullptr;
+      }
+
+
+
+      template <typename InterfaceClass>
+      void
+      PluginList<InterfaceClass>::
+      register_plugin (const std::string &name,
+                       const std::string &description,
+                       void (*declare_parameters_function) (ParameterHandler &),
+                       std::unique_ptr<InterfaceClass> (*factory_function) ())
+      {
+        // see if this is the first time we get into this
+        // function and if so initialize the static member variable
+        if (plugins == nullptr)
+          plugins = new std::list<PluginInfo>();
+
+        // verify that the same name has not previously been
+        // used to register a plugin, since we would then no
+        // longer be able to identify the plugin
+        for (const auto &p : *plugins)
+          {
+            Assert (std::get<0>(p) != name,
+                    ExcMessage ("A plugin with name <" + name + "> has "
+                                "already been registered!"));
+            (void)p;
+          }
+
+
+        // now add one record to the list
+        plugins->emplace_back (name,
+                               description,
+                               declare_parameters_function,
+                               factory_function);
+      }
+
+
+
+      template <typename InterfaceClass>
+      std::string
+      PluginList<InterfaceClass>::
+      get_pattern_of_names ()
+      {
+        Assert (plugins != nullptr,
+                ExcMessage ("No plugins registered!?"));
+
+        // get all names and put them into a data structure that keeps
+        // them sorted
+        std::set<std::string> names;
+        for (typename std::list<PluginInfo>::const_iterator
+             p = plugins->begin();
+             p != plugins->end(); ++p)
+          names.insert (std::get<0>(*p));
+
+        // now create a pattern from all of these sorted names
+        std::string pattern_of_names;
+        for (const auto &name : names)
+          {
+            if (pattern_of_names.size() > 0)
+              pattern_of_names += "|";
+            pattern_of_names += name;
+          }
+
+        return pattern_of_names;
+      }
+
+
+
+      template <typename InterfaceClass>
+      std::string
+      PluginList<InterfaceClass>::
+      get_description_string ()
+      {
+        std::string description;
+
+        // get all names_and_descriptions and put them into a data structure that keeps
+        // them sorted
+        std::map<std::string,std::string> names_and_descriptions;
+        for (typename std::list<PluginInfo>::const_iterator
+             p = plugins->begin();
+             p != plugins->end(); ++p)
+          names_and_descriptions[std::get<0>(*p)] = std::get<1>(*p);
+
+        // then output it all
+        std::map<std::string,std::string>::const_iterator
+        p = names_and_descriptions.begin();
+        while (true)
+          {
+            // write the name and
+            // description of the
+            // parameter
+            description += "`";
+            description += p->first;
+            description += "': ";
+            description += p->second;
+
+            // increment the pointer
+            // by one. if we are not
+            // at the end yet then
+            // add an empty line
+            ++p;
+            if (p != names_and_descriptions.end())
+              description += "\n\n";
+            else
+              break;
+          }
+
+        return description;
+      }
+
+
+
+
+      template <typename InterfaceClass>
+      void
+      PluginList<InterfaceClass>::
+      declare_parameters (ParameterHandler &prm)
+      {
+        Assert (plugins != nullptr,
+                ExcMessage ("No postprocessors registered!?"));
+
+        for (typename std::list<PluginInfo>::const_iterator
+             p = plugins->begin();
+             p != plugins->end(); ++p)
+          (std::get<2>(*p))(prm);
+      }
+
+
+
+      template <typename InterfaceClass>
+      std::unique_ptr<InterfaceClass>
+      PluginList<InterfaceClass>::
+      create_plugin (const std::string &name,
+                     const std::string &documentation)
+      {
+        (void)documentation;
+        Assert (plugins != nullptr,
+                ExcMessage ("No postprocessors registered!?"));
+        AssertThrow (name != "unspecified",
+                     ExcMessage(std::string("A plugin must have a name!\n\n"
+                                            "This function was asked to create a plugin but no name for the "
+                                            "plugin was provided. This may be due to the fact that you did not "
+                                            "explicitly specify a name for this plugin in your input file and "
+                                            "ASPECT does not provide a default for this kind of plugin, for "
+                                            "example because no generally useful plugin exists. An example "
+                                            "is that there is no default geometry: You need to explicitly "
+                                            "provide one in the input file, and it seems like you have not "
+                                            "done so.\n\n"
+                                            "To find out which kind of plugin this function tries to create, "
+                                            "take a look at the backtrace of this error message.\n\n"
+                                            "The place that called this function also provided as "
+                                            "additional information this:\n\n"
+                                            "   <")
+                                + documentation + ">"));
+
+        for (typename std::list<PluginInfo>::const_iterator p = plugins->begin();
+             p != plugins->end(); ++p)
+          if (std::get<0>(*p) == name)
+            {
+              std::unique_ptr<InterfaceClass> i = std::get<3>(*p)();
+              return i;
+            }
+
+        AssertThrow (false, ExcUnknownPlugin(name));
+        return nullptr;
+      }
+
+
+
+      template <typename InterfaceClass>
+      std::unique_ptr<InterfaceClass>
+      PluginList<InterfaceClass>::
+      create_plugin (const std::string &name,
+                     const std::string &documentation,
+                     ParameterHandler  &prm)
+      {
+        std::unique_ptr<InterfaceClass> i = create_plugin(name, documentation);
+        i->parse_parameters (prm);
+        return i;
+      }
+
+
+
+      template <typename InterfaceClass>
+      void
+      PluginList<InterfaceClass>::
+      write_plugin_graph (const std::string &plugin_system_name,
+                          std::ostream      &output_stream,
+                          const std::string &attachment_point)
+      {
+        // first output a graph node for the interface class as the central
+        // hub of this plugin system, plotted as a square.
+        //
+        // we use the typeid name of the interface class to label
+        // nodes within this plugin system, as they are unique among
+        // all other plugin systems
+        output_stream << std::string(typeid(InterfaceClass).name())
+                      << " [label=\""
+                      << plugin_system_name
+                      << "\", height=.8,width=.8,shape=\"rect\",fillcolor=\"green\"]"
+                      << std::endl;
+
+        // then output the graph nodes for each plugin, with links to the
+        // interface class and, as appropriate, from the SimulatorAccess class
+        //
+        // we would like to establish a predictable order of output here, but
+        // plugins self-register via static global variables, and their
+        // initialization order is not deterministic. consequently, let us
+        // loop over all plugins first and put pointers to them into a
+        // map with deterministic keys. as key, we use the declared name
+        // of the plugin by which it is referred in the .prm file
+        std::map<std::string, typename std::list<PluginInfo>::const_iterator>
+        plugin_map;
+        for (typename std::list<PluginInfo>::const_iterator p = plugins->begin();
+             p != plugins->end(); ++p)
+          plugin_map[std::get<0>(*p)] = p;
+
+        // now output the information sorted by the plugin names
+        for (typename std::map<std::string, typename std::list<PluginInfo>::const_iterator>::const_iterator
+             p = plugin_map.begin();
+             p != plugin_map.end(); ++p)
+          {
+            // take the name of the plugin and split it into strings of
+            // 15 characters at most; then combine them
+            // again using \n to make dot/neato show these parts of
+            // the name on separate lines
+            const std::vector<std::string> plugin_label_parts
+              = dealii::Utilities::break_text_into_lines(p->first, 15);
+            Assert (plugin_label_parts.size()>0, ExcInternalError());
+            std::string plugin_name = plugin_label_parts[0];
+            for (unsigned int i=1; i<plugin_label_parts.size(); ++i)
+              plugin_name += "\\n" + plugin_label_parts[i];
+
+            // next create a (symbolic) node name for this plugin. because
+            // each plugin corresponds to a particular class, use the mangled
+            // name of the class
+            std::unique_ptr<InterfaceClass> instance (create_plugin (p->first, ""));
+            const std::string node_name = typeid(*instance).name();
+
+            // then output the whole shebang describing this node
+            output_stream << node_name
+                          << " [label=\""
+                          << plugin_name
+                          << "\", height=.8,width=.8,shape=\"circle\",fillcolor=\"lightblue\"];"
+                          << std::endl;
+
+            // next build connections from this plugin to the
+            // interface class
+            output_stream << node_name
+                          << " -> "
+                          << std::string(typeid(InterfaceClass).name())
+                          << " [len=3, weight=50]"
+                          << ';'
+                          << std::endl;
+
+            // finally see if this plugin is derived from
+            // SimulatorAccess; if so, draw an arrow from SimulatorAccess
+            // also to the plugin's name
+            if (dynamic_cast<const SimulatorAccess<2>*>(instance.get()) != nullptr
+                ||
+                dynamic_cast<const SimulatorAccess<3>*>(instance.get()) != nullptr)
+              output_stream << "SimulatorAccess"
+                            << " -> "
+                            << node_name
+                            << " [style=\"dotted\", arrowhead=\"empty\", constraint=false, color=\"gray\", len=20, weight=0.1];"
+                            << std::endl;
+          }
+
+        // as a last step, also draw a connection from the interface class
+        // to the Simulator class, or whatever the calling function indicates
+        // as the attachment point
+        output_stream << std::string(typeid(InterfaceClass).name())
+                      << " -> "
+                      << attachment_point
+                      << " [len=15, weight=50]"
+                      << ';'
+                      << std::endl;
+
+        // end it with an empty line to make things easier to
+        // read when looking over stuff visually
+        output_stream << std::endl;
+      }
+    }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/ODE_statistics.h.bak b/include/aspect/postprocess/ODE_statistics.h.bak
new file mode 100644
index 00000000000..ea04ec501e0
--- /dev/null
+++ b/include/aspect/postprocess/ODE_statistics.h.bak
@@ -0,0 +1,82 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_ODE_statistics_h
+#define _aspect_postprocess_ODE_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes statistics about the ODEs solved in ASPECT.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class ODEStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Connect the callback functions to the respective signals.
+         */
+        void initialize() override;
+
+        /**
+         * Write the ODE statistics into the statistics file.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+      private:
+        /**
+         * This function clears all the saved solver information that is
+         * stored in this class. It is executed every time the output is
+         * written into the statistics object.
+         */
+        void
+        clear_data();
+
+        /**
+         * Callback function that is connected to the post_ARKode_solve
+         * signal to store the solver history.
+         */
+        void
+        store_ODE_solver_history(const unsigned int iteration_count);
+
+        /**
+          * Variables that store the ODE solver history of the current
+          * timestep, until they are written into the statistics object
+          * upon the call to execute(). They are cleared after writing
+          * the content.
+          */
+        unsigned int total_iteration_count;
+        unsigned int number_of_solves;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/basic_statistics.h.bak b/include/aspect/postprocess/basic_statistics.h.bak
new file mode 100644
index 00000000000..5ddc6b16e41
--- /dev/null
+++ b/include/aspect/postprocess/basic_statistics.h.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_basic_statistics_h
+#define _aspect_postprocess_basic_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that outputs some simplified statistics
+     * like the Rayleigh number and other quantities that only
+     * make sense in certain model setups. The output is written
+     * after completing initial adaptive refinement steps.
+     * The postprocessor assumes a point at the surface at the adiabatic
+     * surface temperature and pressure is a reasonable reference condition
+     * for computing these properties. Furthermore, the Rayleigh
+     * number is computed using the model depth (i.e. not the
+     * radius of the Earth), as we need a definition that is geometry
+     * independent. Take care when comparing these values to published
+     * studies and make sure they use the same definitions.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class BasicStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some general statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/boundary_densities.h.bak b/include/aspect/postprocess/boundary_densities.h.bak
new file mode 100644
index 00000000000..e422a4de3b9
--- /dev/null
+++ b/include/aspect/postprocess/boundary_densities.h.bak
@@ -0,0 +1,79 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_boundary_densities_h
+#define _aspect_postprocess_boundary_densities_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes the laterally averaged density
+     * at the top and bottom boundaries of the solution.  This is useful
+     * for calculating the geoid at those surfaces.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class BoundaryDensities : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for laterally averaged density at the top
+         * and bottom of the domain.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Query the density at the top surface
+         */
+        double density_at_top() const;
+
+        /**
+         * Query the density at the bottom surface
+         */
+        double density_at_bottom() const;
+
+      private:
+
+        /**
+         * Density at the top of the domain.
+         * Filled when execute() is called.
+         */
+        double top_density;
+
+        /**
+         * Density at the bottom of the domain.
+         * Filled when execute() is called.
+         */
+        double bottom_density;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/boundary_pressures.h.bak b/include/aspect/postprocess/boundary_pressures.h.bak
new file mode 100644
index 00000000000..decca391fae
--- /dev/null
+++ b/include/aspect/postprocess/boundary_pressures.h.bak
@@ -0,0 +1,79 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_boundary_pressures_h
+#define _aspect_postprocess_boundary_pressures_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes the laterally averaged pressure
+     * at the top and bottom boundaries of the solution.  This is useful
+     * for calculating the dynamic topography at those surfaces.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class BoundaryPressures : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for the laterally averaged pressure at
+         * the top and bottom of the domain.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Query the pressure at the top surface
+         */
+        double pressure_at_top() const;
+
+        /**
+         * Query the pressure at the bottom surface
+         */
+        double pressure_at_bottom() const;
+
+      private:
+
+        /**
+         * Pressure at the top of the domain.
+         * Filled when execute() is called.
+         */
+        double top_pressure;
+
+        /**
+         * Pressure at the bottom of the domain.
+         * Filled when execute() is called.
+         */
+        double bottom_pressure;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/boundary_strain_rate_residual_statistics.h.bak b/include/aspect/postprocess/boundary_strain_rate_residual_statistics.h.bak
new file mode 100644
index 00000000000..1931f32ab3a
--- /dev/null
+++ b/include/aspect/postprocess/boundary_strain_rate_residual_statistics.h.bak
@@ -0,0 +1,106 @@
+/*
+  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_postprocess_boundary_strain_rate_residual_statistics_h
+#define _aspect_postprocess_boundary_strain_rate_residual_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the residual of the second invariant of the strain
+     * rate at the top surface. The residual is calculated as the difference between the second invariant of
+     * the modeled strain rate and a data file containing the second invariant of strain rate observations.
+     *
+     * @ingroup Postprocessing
+     */
+
+    template <int dim>
+    class BoundaryStrainRateResidualStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * This function reads the specified input surface strain rate data files as an ascii data file.
+         */
+        void initialize () override;
+
+        /**
+         * This function returns the reference surface strain rate read from the data file at the given point @p p.
+         */
+        double
+        get_data_surface_strain_rate (const Point<dim> &p) const;
+
+        /**
+         * Evaluate the solution to compute statistics about the residual of the second invariant of strain rate
+         * residual at the top boundary.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Pointer to the structured data containing the surface strain rate.
+         */
+        std::unique_ptr<Utilities::StructuredDataLookup<dim>> strain_rate_data_lookup;
+
+        /**
+         * Directory in which the input data files are present.
+         */
+        std::string data_directory;
+
+        /**
+         * Filename of the input ascii data file containing the surface strain rate components.
+         */
+        std::string data_file_name;
+
+        /**
+         * Scale the input data by a scalar factor. Can be used to transform
+         * the unit of the data (if they are not specified in SI units (/s or
+         * /yr depending on the "Use years in output instead of seconds"
+         * parameter).
+         */
+        double scale_factor;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/boundary_velocity_residual_statistics.h.bak b/include/aspect/postprocess/boundary_velocity_residual_statistics.h.bak
new file mode 100644
index 00000000000..2c8873beae6
--- /dev/null
+++ b/include/aspect/postprocess/boundary_velocity_residual_statistics.h.bak
@@ -0,0 +1,128 @@
+/*
+  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_postprocess_boundary_velocity_residual_statistics_h
+#define _aspect_postprocess_boundary_velocity_residual_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/boundary_velocity/gplates.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the velocity residual at the top surface.
+     * The velocity residual is calculated as the difference between the modeled velocities and
+     * input data velocities (GPlates model or ascii data).
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class BoundaryVelocityResidualStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * This function reads the specified input velocity data files, i.e., either an ascii data file or
+         * a file from the GPlates model.
+         */
+        void initialize () override;
+
+        /**
+         * This function returns the input data velocity, (GPlates model or ascii data)
+         * value at a point.  This function is called from execute() function.
+         */
+        Tensor<1,dim>
+        get_data_velocity (const Point<dim> &p) const;
+
+        /**
+         * Evaluate the solution statistics for some velocity residual at the top boundary.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Determines if the input ascii data file has velocity components in
+         * spherical, i.e., (r, phi, theta) or in cartesian, i.e., (x, y, z)
+         * coordinate system.
+         */
+        bool use_spherical_unit_vectors;
+
+        /**
+         * Determines if the model velocities are compared against ascii data
+         * files, or a gplates model.
+         */
+        bool use_ascii_data;
+
+        /**
+         * Pointer to the gplates boundary velocity model
+         */
+        std::unique_ptr<BoundaryVelocity::internal::GPlatesLookup<dim>> gplates_lookup;
+
+        /**
+         * Pointer to the structured data
+         */
+        std::unique_ptr<Utilities::StructuredDataLookup<dim>> data_lookup;
+
+        /**
+         * Directory in which the input data files, i.e., GPlates model or ascii data
+         * are present.
+         */
+        std::string data_directory;
+
+        /**
+         * Filename of the input Gplates model or ascii data file. For GPlates, the file names
+         * can contain the specifiers %s and/or %c (in this order), meaning the name of the
+         * boundary and the number of the data file time step.
+         */
+        std::string data_file_name;
+
+        /**
+         * Scale the input data by a scalar factor. Can be used to transform
+         * the unit of the data (if they are not specified in SI units (m/s or
+         * m/yr depending on the "Use years in output instead of seconds"
+         * parameter).
+         */
+        double scale_factor;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/command.h.bak b/include/aspect/postprocess/command.h.bak
new file mode 100644
index 00000000000..f354c890cba
--- /dev/null
+++ b/include/aspect/postprocess/command.h.bak
@@ -0,0 +1,72 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_command_h
+#define _aspect_postprocess_command_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <cstdlib>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that runs a shell command at the end of each time step.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class Command : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Declare new parameters
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Parse parameters
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Execute the command
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+      private:
+        std::string command;
+        bool terminate_on_failure;
+        bool on_all_processes;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/composition_statistics.h.bak b/include/aspect/postprocess/composition_statistics.h.bak
new file mode 100644
index 00000000000..6f815ca96b0
--- /dev/null
+++ b/include/aspect/postprocess/composition_statistics.h.bak
@@ -0,0 +1,53 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_composition_statistics_h
+#define _aspect_postprocess_composition_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the compositional
+     * fields, if any.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class CompositionStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some temperature statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/composition_velocity_statistics.h.bak b/include/aspect/postprocess/composition_velocity_statistics.h.bak
new file mode 100644
index 00000000000..c9e68b32173
--- /dev/null
+++ b/include/aspect/postprocess/composition_velocity_statistics.h.bak
@@ -0,0 +1,75 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_composition_velocity_statistics_h
+#define _aspect_postprocess_composition_velocity_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes the root mean square velocity
+     * over the area spanned by each of the compositional fields.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class CompositionVelocityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution to compute the RMS velocity for each composition.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static void
+        declare_parameters(ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters(ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        std::vector<std::string> selected_fields;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/core_statistics.h.bak b/include/aspect/postprocess/core_statistics.h.bak
new file mode 100644
index 00000000000..8dc7e84dc5c
--- /dev/null
+++ b/include/aspect/postprocess/core_statistics.h.bak
@@ -0,0 +1,106 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_core_statistics_h
+#define _aspect_postprocess_core_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/boundary_temperature/dynamic_core.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the dynamic core.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class CoreStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        CoreStatistics ();
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Evaluate statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Export core data stored in this object. Doing this only because the boundary
+         * temperature doesn't allowed to store restart data there. So we store the data needed
+         * for restart here and exported to boundary temperature object if required.
+         */
+        const BoundaryTemperature::internal::CoreData &
+        get_core_data() const;
+
+        /**
+         * Serialize the contents of this class as far as they are not read
+         * from input parameter files.
+         */
+        template <class Archive>
+        void serialize (Archive &ar, const unsigned int version);
+
+        /**
+         * Save the state of this object.
+         */
+        void save (std::map<std::string, std::string> &status_strings) const override;
+
+        /**
+         * Restore the state of the object.
+         */
+        void load (const std::map<std::string, std::string> &status_strings) override;
+
+      private:
+        /**
+         * Controls whether output the total excess entropy or the individual entropy terms
+         * (i.e. entropy for specific heat, radioactive heating, gravitational contribution,
+         * and adiabatic contribution).
+         */
+        bool   excess_entropy_only;
+
+        /**
+         * Stores the core data from boundary temperature.
+         */
+        struct  BoundaryTemperature::internal::CoreData core_data;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/crystal_preferred_orientation.h.bak b/include/aspect/postprocess/crystal_preferred_orientation.h.bak
new file mode 100644
index 00000000000..554f8f744af
--- /dev/null
+++ b/include/aspect/postprocess/crystal_preferred_orientation.h.bak
@@ -0,0 +1,279 @@
+/*
+ Copyright (C) 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_postprocess_crystal_preferred_orientation_h
+#define _aspect_postprocess_crystal_preferred_orientation_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/particle/world.h>
+
+#include <aspect/simulator_access.h>
+
+#include <deal.II/particles/particle_handler.h>
+#include <deal.II/base/data_out_base.h>
+#include <tuple>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    /**
+     * A Postprocessor that writes out CPO specific particle data.
+     * It can write out the CPO data as it is stored (raw) and/or as a
+     * random draw volume weighted representation. The latter one
+     * is recommended for plotting against real data. For both representations
+     * the specific output fields and their order can be set.
+     */
+    template <int dim>
+    class CrystalPreferredOrientation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        CrystalPreferredOrientation();
+
+        /**
+         * Destructor.
+         */
+        ~CrystalPreferredOrientation();
+
+
+        /**
+         * Initialize function.
+         */
+        void initialize () override;
+
+        /**
+         * A Postprocessor that writes out CPO specific particle data.
+         * It can write out the CPO data as it is stored (raw) and/or as a
+         * random draw volume weighted representation. The latter one
+         * is recommended for plotting against real data. For both representations
+         * the specific output fields and their order can be set.
+         */
+        std::pair<std::string,std::string> execute (TableHandler &statistics) override;
+
+        /**
+         * This function ensures that the particle postprocessor is run before
+         * this postprocessor.
+         */
+        std::list<std::string>
+        required_other_postprocessors () const override;
+
+        /**
+        * Declare the parameters this class takes through input files.
+        */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+
+        /**
+         * Stores the simulation end time, so that it always produces output
+         * at the last timestep.
+         */
+        double end_time;
+
+        /**
+         * Enums specifying what information to write:
+         *
+         * VolumeFraction: Write the volume fraction
+         * RotationMatrix: Write the whole rotation matrix of a grain (in deal.ii order)
+         * EulerAngles: Write out the Z-X-Z Euler angle of a grain
+         * not_found: Error enum, the requested output was not found
+         */
+        enum class Output
+        {
+          VolumeFraction, RotationMatrix, EulerAngles, not_found
+        };
+
+        /**
+         * Converts a string to an Output enum.
+         */
+        Output string_to_output_enum(const std::string &string);
+
+        /**
+         * Random number generator used for random draw volume weighting.
+         */
+        mutable std::mt19937 random_number_generator;
+
+        /**
+         * Random number generator seed used to initialize the random number generator.
+         */
+        unsigned int random_number_seed;
+
+        /**
+         * Interval between output (in years if appropriate simulation
+         * parameter is set, otherwise seconds)
+         */
+        double output_interval;
+
+        /**
+         * Records time for next output to occur
+         */
+        double last_output_time;
+
+        /**
+         * Set the time output was supposed to be written. In the simplest
+         * case, this is the previous last output time plus the interval, but
+         * in general we'd like to ensure that it is the largest supposed
+         * output time, which is smaller than the current time, to avoid
+         * falling behind with last_output_time and having to catch up once
+         * the time step becomes larger. This is done after every output.
+         */
+        void set_last_output_time (const double current_time);
+
+        /**
+         * Consecutively counted number indicating the how-manyth time we will
+         * create output the next time we get to it.
+         */
+        unsigned int output_file_number;
+
+        /**
+         * Graphical output format.
+         */
+        std::vector<std::string> output_formats;
+
+        /**
+         * A list of pairs (time, pvtu_filename) that have so far been written
+         * and that we will pass to DataOutInterface::write_pvd_record
+         * to create a main file that can make the association
+         * between simulation time and corresponding file name (this
+         * is done because there is no way to store the simulation
+         * time inside the .pvtu or .vtu files).
+         */
+        std::vector<std::pair<double,std::string>> times_and_pvtu_file_names;
+
+        /**
+         * A corresponding variable that we use for the .visit files created
+         * by DataOutInterface::write_visit_record. The second part of a
+         * pair contains all files that together form a time step.
+         */
+        std::vector<std::pair<double,std::vector<std::string>>> times_and_vtu_file_names;
+
+        /**
+         * A list of list of filenames, sorted by timestep, that correspond to
+         * what has been created as output. This is used to create a main
+         * .visit file for the entire simulation.
+         */
+        std::vector<std::vector<std::string>> output_file_names_by_timestep;
+
+        /**
+         * A set of data related to XDMF file sections describing the HDF5
+         * heavy data files created. These contain things such as the
+         * dimensions and names of data written at all steps during the
+         * simulation.
+         */
+        std::vector<XDMFEntry>  xdmf_entries;
+
+        /**
+         * VTU file output supports grouping files from several CPUs into one
+         * file using MPI I/O when writing on a parallel filesystem. 0 means
+         * no grouping (and no parallel I/O). 1 will generate one big file
+         * containing the whole solution.
+         */
+        unsigned int group_files;
+
+        /**
+         * On large clusters it can be advantageous to first write the
+         * output to a temporary file on a local file system and later
+         * move this file to a network file system. If this variable is
+         * set to a non-empty string it will be interpreted as a temporary
+         * storage location.
+         */
+        std::string temporary_output_location;
+
+        /**
+         * File operations can potentially take a long time, blocking the
+         * progress of the rest of the model run. Setting this variable to
+         * 'true' moves this process into a background thread, while the
+         * rest of the model continues.
+         */
+        bool write_in_background_thread;
+
+        /**
+         * Handle to a thread that is used to write main file data in the
+         * background. The writer() function runs on this background thread.
+         */
+        std::thread background_thread_main;
+
+        /**
+         * What "raw" CPO data to write out.
+         */
+        std::vector<std::pair<unsigned int,Output>> write_raw_cpo;
+
+        /**
+         * Whether computing raw Euler angles is needed.
+         */
+        bool compute_raw_euler_angles;
+
+        /**
+         * Handle to a thread that is used to write content file data in the
+         * background. The writer() function runs on this background thread.
+         */
+        std::thread background_thread_content_raw;
+
+        /**
+         * What "draw volume weighted" CPO data to write out. Draw volume weighted means
+         * the grain properties (size and rotation) are put in a list sorted based by volume
+         * and picked randomly, with large volumes having a higher chance of being picked.
+         */
+        std::vector<std::pair<unsigned int,Output>> write_draw_volume_weighted_cpo;
+
+        /**
+         * Whether computing weighted A matrix is needed.
+         */
+        bool compute_weighted_rotation_matrix;
+
+        /**
+         * Handle to a thread that is used to write content file data in the
+         * background. The writer() function runs on this background thread.
+         */
+        std::thread background_thread_content_draw_volume_weighting;
+
+        /**
+         * Whether to compress the raw and weighed cpo data output files with zlib.
+         */
+        bool compress_cpo_data_files;
+
+        /**
+         * A function that writes the text in the second argument to a file
+         * with the name given in the first argument. The function is run on a
+         * separate thread to allow computations to continue even though
+         * writing data is still continuing. The function takes over ownership
+         * of these arguments and deletes them at the end of its work.
+         */
+        static
+        void writer (const std::string &filename,
+                     const std::string &temporary_filename,
+                     const std::string &file_contents,
+                     const bool compress_contents);
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/depth_average.h.bak b/include/aspect/postprocess/depth_average.h.bak
new file mode 100644
index 00000000000..f8fa3dc5f0f
--- /dev/null
+++ b/include/aspect/postprocess/depth_average.h.bak
@@ -0,0 +1,156 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_depth_average_h
+#define _aspect_postprocess_depth_average_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/data_out_base.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that generates depth average output in periodic
+     * intervals or every time step.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class DepthAverage : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        DepthAverage ();
+
+        /**
+         * Evaluate the solution and compute the requested depth averages.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Save the state of this object.
+         */
+        void save (std::map<std::string, std::string> &status_strings) const override;
+
+        /**
+         * Restore the state of the object.
+         */
+        void load (const std::map<std::string, std::string> &status_strings) override;
+
+        /**
+         * Serialize the contents of this class as far as they are not read
+         * from input parameter files.
+         */
+        template <class Archive>
+        void serialize (Archive &ar, const unsigned int version);
+
+      private:
+        /**
+         * Interval between the generation of output in seconds. This parameter is read
+         * from the input file and consequently is not part of the state that
+         * needs to be saved and restored.
+         */
+        double output_interval;
+
+        /**
+         * A time (in seconds) the last output has been produced.
+         */
+        double last_output_time;
+
+        /**
+         * The formats in which to produce graphical output. This also
+         * determines the extension of the file names to which to write.
+         */
+        std::vector<std::string> output_formats;
+
+        /**
+         * Number of zones in depth direction over which we are supposed to
+         * average.
+         */
+        unsigned int n_depth_zones;
+
+        /**
+         * The boundaries of the depth zones.
+         * This vector contains exactly n_depth_zones + 1 entries,
+         * and entries i and i+1 represent the lower and upper depth bound
+         * of zone i.
+         */
+        std::vector<double> depth_bounds;
+
+        /**
+         * List of the quantities to calculate for each depth zone.
+         */
+        std::vector<std::string> variables;
+
+        /**
+         * A structure for a single time step record.
+         */
+        struct DataPoint
+        {
+          double time;
+          std::vector<std::vector<double>> values;
+
+          template <class Archive>
+          void serialize (Archive &ar, const unsigned int version);
+        };
+
+        /**
+         * An array of all the past values
+         */
+        std::vector<DataPoint> entries;
+
+        /**
+         * Set the time output was supposed to be written. In the simplest
+         * case, this is the previous last output time plus the interval, but
+         * in general we'd like to ensure that it is the largest supposed
+         * output time, which is smaller than the current time, to avoid
+         * falling behind with last_output_time and having to catch up once
+         * the time step becomes larger. This is done after every output.
+         */
+        void set_last_output_time (const double current_time);
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/domain_volume_statistics.h.bak b/include/aspect/postprocess/domain_volume_statistics.h.bak
new file mode 100644
index 00000000000..5912863fa66
--- /dev/null
+++ b/include/aspect/postprocess/domain_volume_statistics.h.bak
@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_domain_volume_statistics_h
+#define _aspect_postprocess_domain_volume_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes the total area (2D) or volume (3D)
+     * of the computational domain.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class DomainVolume : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some mass_flux statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/dynamic_topography.h.bak b/include/aspect/postprocess/dynamic_topography.h.bak
new file mode 100644
index 00000000000..a9f218cd3fe
--- /dev/null
+++ b/include/aspect/postprocess/dynamic_topography.h.bak
@@ -0,0 +1,136 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_surface_topography_h
+#define _aspect_postprocess_surface_topography_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes dynamic topography at the top and bottom of the domain.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class DynamicTopography : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for the dynamic topography.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Return the topography vector as calculated by the consistent
+         * boundary flux (CBF) formulation.
+         * The velocity components store the surface-normal traction,
+         * and the temperature component stores the dynamic topography
+         * computed from that traction.
+         */
+        const LinearAlgebra::BlockVector &
+        topography_vector() const;
+
+        /**
+         * Return the cell-wise topography vector as calculated by the CBF formulation,
+         * where indices of the vector correspond to cell indices.
+         * This vector is considerably smaller than the full topography vector returned
+         * by topography_vector(), and is useful for text output and visualization.
+         */
+        const Vector<float> &
+        cellwise_topography() const;
+
+        /**
+         * Register the other postprocessor that we need: BoundaryPressures
+         */
+        std::list<std::string>
+        required_other_postprocessors() const override;
+
+        /**
+         * Parse the parameters for the postprocessor.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Declare the parameters for the postprocessor.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+      private:
+        /**
+         * Output the dynamic topography solution to
+         * a file for a given boundary id. All the values
+         * in @p position_and_topography are written to a file
+         * with a file name determined by @p boundary_id.
+         */
+        void output_to_file(const types::boundary_id boundary_id,
+                            const std::vector<std::pair<Point<dim>, double>> &position_and_topography);
+
+        /**
+         * A vector which stores the surface stress values calculated
+         * by the postprocessor.
+         */
+        LinearAlgebra::BlockVector topo_vector;
+
+        /**
+         * A vector which stores the surface stress values calculated
+         * at the midpoint of each surface cell face. This can be
+         * given to a visualization postprocessor to output dynamic topography.
+         */
+        Vector<float> visualization_values;
+
+        /**
+         * A parameter that allows users to set the density value
+         * above the top surface.
+         */
+        double density_above;
+
+        /**
+         * A parameter that allows users to set the density value
+         * below the bottom surface.
+         */
+        double density_below;
+
+        /**
+         * Whether to output the surface topography.
+         */
+        bool output_surface;
+
+        /**
+         * Whether to output the bottom topography.
+         */
+        bool output_bottom;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/entropy_viscosity_statistics.h.bak b/include/aspect/postprocess/entropy_viscosity_statistics.h.bak
new file mode 100644
index 00000000000..17d0f002cf1
--- /dev/null
+++ b/include/aspect/postprocess/entropy_viscosity_statistics.h.bak
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_entropy_viscosity_statistics_h
+#define _aspect_postprocess_entropy_viscosity_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    /**
+     * A postprocessor that computes the maximum and volume averaged
+     * entropy viscosity stabilization for the temperature equation.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class EntropyViscosityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some entropy viscosity stabilization statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/geoid.h.bak b/include/aspect/postprocess/geoid.h.bak
new file mode 100644
index 00000000000..cecc6cad96e
--- /dev/null
+++ b/include/aspect/postprocess/geoid.h.bak
@@ -0,0 +1,188 @@
+/*
+ Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _aspect_postprocess_geoid_h
+#define _aspect_postprocess_geoid_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    /**
+     * A postprocessor that computes the geoid anomaly at the surface.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class Geoid : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for the geoid in spherical harmonics and then transfer it to grid output.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Register with the simulator the other postprocessors that we need
+         * (namely: dynamic topography).
+         */
+        std::list<std::string>
+        required_other_postprocessors() const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Find if the top or bottom boundaries are free surfaces.
+         */
+        void initialize() override;
+
+        /**
+         * Evaluate the geoid solution at a point. The evaluation point
+         * must be outside of the model domain, and it must be called
+         * after execute().
+         */
+        double
+        evaluate (const Point<dim> &) const;
+
+      private:
+        /**
+         * Parameters to set the maximum and minimum degree when computing geoid from spherical harmonics
+         */
+        unsigned int max_degree;
+        unsigned int min_degree;
+
+        /**
+         * A parameter to control whether to output the data in geographical coordinates.
+         * If true, output the data in longitudes and latitudes; if false, output data in x y z.
+         */
+        bool output_in_lat_lon;
+
+        /**
+         * A parameter to control whether to output the spherical harmonic coefficients of the geoid anomaly
+         */
+        bool output_geoid_anomaly_SH_coes;
+
+        /**
+         * A parameter to control whether to output the spherical harmonic coefficients of the surface topography contribution
+         */
+        bool output_surface_topo_contribution_SH_coes;
+
+        /**
+         * A parameter to control whether to output the spherical harmonic coefficients of the CMB topography contribution
+         */
+        bool output_CMB_topo_contribution_SH_coes;
+
+        /**
+         * A parameter to control whether to output the spherical harmonic coefficients of the density anomaly
+         */
+        bool output_density_anomaly_contribution_SH_coes;
+
+        /**
+         * A parameter to control whether to output the free-air gravity anomaly
+         */
+        bool output_gravity_anomaly;
+
+        /**
+         * Parameters to set the density value out of the surface and CMB boundary
+         */
+        double density_above;
+        double density_below;
+
+        /**
+         * A parameter to control whether to include the surface topography contribution on geoid
+         */
+        bool include_surface_topo_contribution;
+
+        /**
+         * A parameter to control whether to include the CMB topography contribution on geoid
+         */
+        bool include_CMB_topo_contribution;
+
+        /**
+         * A parameter to specify if the top boundary is an active free surface
+         */
+        bool use_free_surface_topography;
+
+        /**
+         * A parameter to specify if the bottom boundary is an active free surface
+         */
+        bool use_free_CMB_topography;
+
+        /**
+         * Function to compute the real spherical harmonic coefficients (cos and sin part) from min degree to max degree
+         * The input spherical_function is a vector of vectors.
+         * The inner vector stores theta, phi, spherical infinitesimal, and function value on a spherical surface.
+         * The outer vector stores the inner vector associated with each quadrature point on a spherical surface.
+         */
+        std::pair<std::vector<double>,std::vector<double>>
+        to_spherical_harmonic_coefficients(const std::vector<std::vector<double>> &spherical_function) const;
+
+        /**
+         * Function to compute the density contribution in spherical harmonic expansion throughout the mantle
+         * The input outer radius is needed to evaluate the density integral contribution of whole model domain at the surface
+         * This function returns a pair containing real spherical harmonics of density integral (cos and sin part) from min degree to max degree.
+         */
+        std::pair<std::vector<double>,std::vector<double>>
+        density_contribution (const double &outer_radius) const;
+
+        /**
+         * Function to compute the surface and CMB topography contribution in spherical harmonic expansion
+         * The input inner and outer radius are used to calculate spherical infinitesimal area, i.e., sin(theta)*d_theta*d_phi
+         * associated with each quadrature point on surface and bottom respectively.
+         * This function returns a pair containing surface and CMB topography's real spherical harmonic coefficients (cos and sin part)
+         * from min degree to max degree. The surface and CMB average density are also included as the first single element of each subpair respectively.
+         * The topography is based on the dynamic topography postprocessor in case of no free surface,
+         * and based on the real surface from the geometry model in case of a free surface.
+         */
+        std::pair<std::pair<double, std::pair<std::vector<double>,std::vector<double>>>, std::pair<double, std::pair<std::vector<double>,std::vector<double>>>>
+        topography_contribution(const double &outer_radius,
+                                const double &inner_radius) const;
+
+        /**
+         * A vector to store the cosine terms of the geoid anomaly spherical harmonic coefficients.
+         */
+        std::vector<double> geoid_coecos;
+        /**
+         * A vector to store the sine terms of the geoid anomaly spherical harmonic coefficients.
+         */
+        std::vector<double> geoid_coesin;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/global_statistics.h.bak b/include/aspect/postprocess/global_statistics.h.bak
new file mode 100644
index 00000000000..9e643447dad
--- /dev/null
+++ b/include/aspect/postprocess/global_statistics.h.bak
@@ -0,0 +1,153 @@
+/*
+  Copyright (C) 2017 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_global_statistics_h
+#define _aspect_postprocess_global_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/lac/solver_control.h>
+
+namespace aspect
+{
+
+  namespace Postprocess
+  {
+    /**
+     * A postprocessor that outputs all the global statistics
+     * information, e.g. the time of the simulation, the timestep
+     * number, number of degrees of freedom and solver iterations
+     * for each timestep. The postprocessor can output different
+     * formats, the first printing one line in the statistics file
+     * per nonlinear solver iteration (if a nonlinear solver scheme
+     * is selected). The second prints one line per timestep,
+     * summing the information about all nonlinear iterations in
+     * this line. Note that this postprocessor is always active
+     * independent on whether or not it is selected in the
+     * parameter file.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class GlobalStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Connect the callback functions to the respective signals.
+         */
+        void initialize() override;
+
+        /**
+         * Write all global statistics columns into the statistics object.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+
+      private:
+        /**
+         * Write global statistics such as the time step number and the
+         * number of degrees of freedom into the statistics object.
+         */
+        void
+        generate_global_statistics(TableHandler &statistics);
+
+        /**
+         * This function clears all the saved solver information that is
+         * stored in this class. It is executed every time the output is
+         * written into the statistics object, but also after each initial
+         * refinement step, in case it is not written (to avoid summing
+         * information across different refinement steps).
+         */
+        void
+        clear_data();
+
+        /**
+         * Callback function that is connected to the post_stokes_solver
+         * signal to store the solver history.
+         */
+        void
+        store_stokes_solver_history(const unsigned int number_S_iterations,
+                                    const unsigned int number_A_iterations,
+                                    const SolverControl &solver_control_cheap,
+                                    const SolverControl &solver_control_expensive);
+
+        /**
+         * Callback function that is connected to the post_advection_solver
+         * signal to store the solver history.
+         */
+        void
+        store_advection_solver_history(const bool solved_temperature_field,
+                                       const unsigned int compositional_index,
+                                       const SolverControl &solver_control);
+
+        /**
+         * Variables that store the Stokes solver history of the current
+         * timestep, until they are written into the statistics object
+         * upon the call to execute(). They are cleared after writing
+         * the content.
+         */
+        std::vector<unsigned int> list_of_S_iterations;
+        std::vector<unsigned int> list_of_A_iterations;
+        std::vector<unsigned int> stokes_iterations_cheap;
+        std::vector<unsigned int> stokes_iterations_expensive;
+
+        /**
+         * A container that stores the advection solver history of the current
+         * timestep, until it is written into the statistics object
+         * upon the call to execute(). It is cleared after writing
+         * the content. The vector contains pairs, which consist
+         * of a column name (for the temperature or one of the
+         * compositional fields), and a vector of SolverControl
+         * objects (one per nonlinear iteration for this particular
+         * field). This layout allows storing varying numbers of
+         * nonlinear iterations for temperature and compositional fields
+         * (if any nonlinear solver scheme would implement that at
+         * some point).
+         */
+        std::vector<std::pair<std::string, std::vector<unsigned int>>> advection_iterations;
+
+        /**
+         * Whether to put every nonlinear iteration into a separate
+         * line in the statistics file or to only output one line
+         * per time step.
+         */
+        bool one_line_per_iteration;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/gravity_point_values.h.bak b/include/aspect/postprocess/gravity_point_values.h.bak
new file mode 100644
index 00000000000..463a30adeb3
--- /dev/null
+++ b/include/aspect/postprocess/gravity_point_values.h.bak
@@ -0,0 +1,291 @@
+/*
+  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_gravity_point_values_h
+#define _aspect_postprocess_gravity_point_values_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes gravity, gravity anomalies, gravity potential and
+     * gravity gradients for a set of points (e.g. satellites) in or above the model
+     * surface for a user-defined range of latitudes, longitudes and radius, or a list
+     * of point coordinates. Spherical coordinates in the output file are radius,
+     * colatitude and colongitude. Gravity is here based on the density distribution
+     * from the material model (and non adiabatic). This means that the density may
+     * come directly from an ascii file. This postprocessor also computes theoretical
+     * gravity and its derivatives, which corresponds to the analytical solution of gravity
+     * in the same geometry but filled with a reference density. The reference density
+     * is also used to determine the density difference for computing gravity anomalies.
+     * Thus one must carefully evaluate the meaning of the gravity anomaly output,
+     * because the solution may not reflect the actual gravity anomaly (due to
+     * differences in the assumed reference density). One way to guarantee correct
+     * gravity anomalies is to subtract the gravity of a certain point from the average
+     * gravity on the map. Another way is to directly use density anomalies for this
+     * postprocessor.
+     * The average- minimum- and maximum gravity acceleration and potential are written
+     * into the statistics file.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class GravityPointValues : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        GravityPointValues ();
+
+        /**
+         * @copydoc Interface::initialize().
+         */
+        void initialize() override;
+
+        /**
+         * Specify the creation of output_gravity.txt.
+         */
+        std::pair<std::string,std::string> execute (TableHandler &) override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Serialize the contents of this class as far as they are not read
+         * from input parameter files.
+         */
+        template <class Archive>
+        void serialize (Archive &ar, const unsigned int version);
+
+        /**
+         * Save the state of this object.
+         */
+        void save (std::map<std::string, std::string> &status_strings) const override;
+
+        /**
+         * Restore the state of the object.
+         */
+        void load (const std::map<std::string, std::string> &status_strings) override;
+
+      private:
+        /**
+         * Interval between the generation of gravity output.
+         */
+        double output_interval;
+
+        /**
+         * A time (in seconds) at which the last graphical output was supposed
+         * to be produced. Used to check for the next necessary output time.
+         */
+        double last_output_time;
+
+        /**
+         * Maximum number of steps between the generation of gravity output.
+         */
+        unsigned int maximum_timesteps_between_outputs;
+
+        /**
+         * Timestep at which the last gravity output was produced
+         * Used to check for the next necessary output time.
+         */
+        unsigned int last_output_timestep;
+
+        /**
+         * Consecutively counted number indicating the how-manyth time we will
+         * create output the next time we get to it.
+         */
+        unsigned int output_file_number;
+
+        /**
+         * end_time is taken from parameter file. It is used to tell the
+         * postprocessor to write gravity output at the end time.
+         */
+        double end_time;
+
+        /**
+         * Set the time output was supposed to be written. In the simplest
+         * case, this is the previous last output time plus the interval, but
+         * in general we'd like to ensure that it is the largest supposed
+         * output time, which is smaller than the current time, to avoid
+         * falling behind with last_output_time and having to catch up once
+         * the time step becomes larger. This is done after every output.
+         */
+        void set_last_output_time (const double current_time);
+
+        /**
+         * Set the precision of the gravity acceleration, potential and gradients
+         * in the gravity output and statistics file.
+         */
+        unsigned int precision;
+
+        /**
+         * Quadrature degree increase over the velocity element degree may be required when
+         * gravity is calculated near the surface or inside the model. An increase in the
+         * quadrature element adds accuracy to the gravity solution from noise due to the
+         * model grid.
+         */
+        unsigned int quadrature_degree_increase;
+
+        /**
+         * Parameter for the fibonacci spiral sampling scheme:
+         */
+        unsigned int n_points_spiral;
+
+        /**
+         * Parameter for the map and fibonacci spiral sampling scheme:
+         * Gravity may be calculated for a sets of points along the radius (e.g. depth
+         * profile) between a minimum and maximum radius. Number of points along the radius
+         * is specified with n_points_radius.
+         */
+        unsigned int n_points_radius;
+
+        /**
+         * Parameter for the map sampling scheme:
+         * Gravity may be calculated for a sets of points along the longitude (e.g. satellite
+         * mapping) between a minimum and maximum longitude. Number of points along the
+         * longitude is specified with n_points_longitude.
+         */
+        unsigned int n_points_longitude;
+
+        /**
+         * Parameter for the map sampling scheme:
+         * Gravity may be calculated for a sets of points along the latitude (e.g. satellite
+         * mapping) between a minimum and maximum latitude. Number of points along the
+         * latitude is specified with n_points_latitude.
+         */
+        unsigned int n_points_latitude;
+
+        /**
+         * Parameter for the map and fibonacci spiral sampling scheme:
+         * Prescribe a minimum radius for a sampling coverage at a specific height.
+         * May be set in- or outside the model domain.
+         */
+        double minimum_radius;
+
+        /**
+         * Parameter for the map and fibonacci spiral sampling scheme:
+         * Maximum radius for the radius range.
+         * May be set in- or outside the model domain.
+         * No need to specify maximum_radius if n_points_radius is 1.
+         */
+        double maximum_radius;
+
+        /**
+         * Parameter for the map sampling scheme:
+         * Minimum longitude for longitude range.
+         */
+        double minimum_colongitude;
+
+        /**
+         * Parameter for the map sampling scheme:
+         * Maximum longitude for the longitude range.
+         * No need to specify maximum_longitude if n_points_longitude is 1.
+         */
+        double maximum_colongitude;
+
+        /**
+         * Parameter for the map sampling scheme:
+         * Minimum latitude for the latitude range.
+         */
+        double minimum_colatitude;
+
+        /**
+         * Parameter for the map sampling scheme:
+         * Maximum latitude for the latitude range.
+         * No need to specify maximum_latitude if n_points_latitude is 1.
+         */
+        double maximum_colatitude;
+
+        /**
+         * A reference density is required for two purposes:
+         * 1) benchmark the gravity postprocessor with computing analytically gravity
+         * acceleration and gradients in the domain filled with a constant density.
+         * 2) calculate the density difference of the density given by the material
+         * model and a constant density, in order to compute gravity anomalies.
+         */
+        double reference_density;
+
+        /**
+         * Specify the sampling scheme determining if gravity calculation is performed.
+         */
+        enum SamplingScheme
+        {
+          map,
+          fibonacci_spiral,
+          list_of_points
+        } sampling_scheme;
+
+        /**
+         * Parameter for the list of points sampling scheme:
+         * List of radius coordinates for the list of points sampling scheme.
+         * Must follow the same order as the lists of longitude and latitude.
+         */
+        std::vector<double> radius_list;
+
+        /**
+         * Parameter for the list of points sampling scheme:
+         * List of longitude coordinates for the list of points sampling scheme.
+         * Must follow the same order as the lists of radius and latitude.
+         */
+        std::vector<double> longitude_list;
+
+        /**
+         * Parameter for the list of points sampling scheme:
+         * List of latitude coordinates for the list of points sampling scheme.
+         * Must follow the same order as the lists of longitude and longitude.
+         */
+        std::vector<double> latitude_list;
+
+        // ------------ the following variables are not set from parameters,
+        //              but are instead computed up front from input
+        //              parameters and other parts of the overall model
+        double model_outer_radius;
+        double model_inner_radius;
+
+        /**
+         * The positions of all satellite positions in spherical and
+         * Cartesian coordinate systems.
+         */
+        std::vector<std::array<double,dim>> satellite_positions_spherical;
+        std::vector<Point<dim>>             satellite_positions_cartesian;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/heat_flux_densities.h.bak b/include/aspect/postprocess/heat_flux_densities.h.bak
new file mode 100644
index 00000000000..4167c75b2fa
--- /dev/null
+++ b/include/aspect/postprocess/heat_flux_densities.h.bak
@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_heat_flux_densities_h
+#define _aspect_postprocess_heat_flux_densities_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes average heat flux densities for each
+     * boundary.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class HeatFluxDensities : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/heat_flux_map.h.bak b/include/aspect/postprocess/heat_flux_map.h.bak
new file mode 100644
index 00000000000..84477eddbbb
--- /dev/null
+++ b/include/aspect/postprocess/heat_flux_map.h.bak
@@ -0,0 +1,109 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_heat_flux_map_h
+#define _aspect_postprocess_heat_flux_map_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace internal
+    {
+      /**
+       * Compute the heat flux for boundaries with prescribed temperature (Dirichlet
+       * boundary conditions) using the consistent boundary flux method. The method
+       * is described in
+       *
+       * Gresho, P. M., Lee, R. L., Sani, R. L., Maslanik, M. K., & Eaton, B. E. (1987).
+       * The consistent Galerkin FEM for computing derived boundary quantities in thermal and or fluids
+       * problems. International Journal for Numerical Methods in Fluids, 7(4), 371-394.
+       *
+       * In summary, the method solves the temperature equation again on the boundary faces, with known
+       * temperatures and solving for the boundary fluxes that satisfy the equation. Since the
+       * equation is only formed on the faces and it can be solved using only diagonal matrices,
+       * the computation is cheap. Conceptually simpler methods like evaluating the temperature
+       * gradient on the face are significantly less accurate.
+       *
+       * The function returns a solution vector, which contains the heat flux in the temperature
+       * block of the vector.
+       */
+      template <int dim>
+      LinearAlgebra::BlockVector
+      compute_dirichlet_boundary_heat_flux_solution_vector (const SimulatorAccess<dim> &simulator_access);
+
+      /**
+       * This function computes the combined heat flux through each boundary face (conductive + advective).
+       * For reflecting boundaries the conductive heat flux is 0, for boundaries with prescribed heat flux
+       * (inhomogeneous Neumann boundary conditions) it is simply the integral of the prescribed heat flux over
+       * the face, and for boundaries with non-tangential velocities the advective heat flux is computed as
+       * the integral over the advective heat flux density.
+       * For boundaries with prescribed temperature (Dirichlet boundary conditions) the heat flux
+       * is computed using the compute_dirichlet_boundary_heat_flux_solution_vector() function.
+       *
+       * The function returns a vector with as many entries as active cells. For each locally owned
+       * cell it contains a vector with one entry per face. Each of these entries contains a pair
+       * of doubles, containing the combined heat flux (first entry) and face area (second entry).
+       * This function is a helper function that unifies the complex heat flux computation necessary
+       * for several postprocessors.
+       */
+      template <int dim>
+      std::vector<std::vector<std::pair<double, double>>>
+      compute_heat_flux_through_boundary_faces (const SimulatorAccess<dim> &simulator_access);
+    }
+
+    /**
+     * A postprocessor that computes the point-wise heat flux density through the boundaries.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class HeatFluxMap : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for the heat flux.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+      private:
+        /**
+         * Output the heat flux density for the boundary determined
+         * by @p boundary_id to a file. The heat flux density is
+         * handed over in the vector @p heat_flux_and_area. This vector
+         * is expected to be of the structure described for the return value
+         * of the function compute_heat_flux_through_boundary_faces() and
+         * only the values at the faces of the given @p boundary_id are
+         * written to the file.
+         */
+        void output_to_file(const types::boundary_id boundary_id,
+                            const std::vector<std::vector<std::pair<double, double>>> &heat_flux_and_area);
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/heat_flux_statistics.h.bak b/include/aspect/postprocess/heat_flux_statistics.h.bak
new file mode 100644
index 00000000000..fb9e7ee6983
--- /dev/null
+++ b/include/aspect/postprocess/heat_flux_statistics.h.bak
@@ -0,0 +1,53 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_heat_flux_statistics_h
+#define _aspect_postprocess_heat_flux_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the heat_flux.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class HeatFluxStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some heat_flux statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/heating_statistics.h.bak b/include/aspect/postprocess/heating_statistics.h.bak
new file mode 100644
index 00000000000..77fa48fd012
--- /dev/null
+++ b/include/aspect/postprocess/heating_statistics.h.bak
@@ -0,0 +1,56 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_postprocess_heating_statistics_h
+#define _aspect_postprocess_heating_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the
+     * heating rate. This includes all of the heating processes
+     * specified in the parameter file, i.e. shear heating,
+     * adiabatic heating and radiogenic heat production.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class HeatingStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some heating rate statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/interface.h.bak b/include/aspect/postprocess/interface.h.bak
new file mode 100644
index 00000000000..623d4facf62
--- /dev/null
+++ b/include/aspect/postprocess/interface.h.bak
@@ -0,0 +1,380 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_interface_h
+#define _aspect_postprocess_interface_h
+
+#include <aspect/global.h>
+#include <aspect/plugins.h>
+#include <aspect/simulator_access.h>
+
+#include <memory>
+#include <deal.II/base/table_handler.h>
+#include <deal.II/base/parameter_handler.h>
+
+#include <boost/serialization/split_member.hpp>
+#include <boost/core/demangle.hpp>
+
+#include <typeinfo>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim> class Simulator;
+  template <int dim> class SimulatorAccess;
+
+
+  /**
+   * A namespace for everything to do with postprocessing solutions every time
+   * step or every few time steps.
+   *
+   * @ingroup Postprocessing
+   */
+  namespace Postprocess
+  {
+
+    /**
+     * This class declares the public interface of postprocessors.
+     * Postprocessors must implement a function that can be called at the end
+     * of each time step to evaluate the current solution, as well as
+     * functions that save the state of the object and restore it (for
+     * checkpoint/restart capabilities).
+     *
+     * Access to the data of the simulator is granted by the @p protected
+     * member functions of the SimulatorAccess class, i.e., classes
+     * implementing this interface will in general want to derive from both
+     * this Interface class as well as from the SimulatorAccess class.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Execute this postprocessor. Derived classes will implement this
+         * function to do whatever they want to do to evaluate the solution at
+         * the current time step.
+         *
+         * @param[in,out] statistics An object that contains statistics that
+         * are collected throughout the simulation and that will be written to
+         * an output file at the end of each time step. Postprocessors may
+         * deposit data in these tables for later visualization or further
+         * processing.
+         *
+         * @return A pair of strings that will be printed to the screen after
+         * running the postprocessor in two columns; typically the first
+         * column contains a description of what the data is and the second
+         * contains a numerical value of this data. If there is nothing to
+         * print, simply return two empty strings.
+         */
+        virtual
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) = 0;
+
+        /**
+         * A function that is used to indicate to the postprocessor manager which
+         * other postprocessor(s) the current one depends upon. The returned
+         * list contains the names (as strings, as you would write them in
+         * the input file) of the postprocessors it requires. The manager
+         * will ensure that these postprocessors are indeed used, even if
+         * they were not explicitly listed in the input file, and are indeed
+         * run <i>before</i> this postprocessor every time they are executed.
+         *
+         * The default implementation of this function returns an empty list.
+         *
+         * @note This mechanism is intended to support postprocessors that
+         * do not want to recompute information that other postprocessors
+         * already compute (or could compute, if they were run -- which
+         * we can ensure using the current function). To do so, a postprocessor
+         * of course needs to be able to access these other postprocessors.
+         * This can be done by deriving your postprocessor from
+         * SimulatorAccess, and then using the
+         * SimulatorAccess::get_postprocess_manager::get_matching_postprocessor
+         * function.
+         */
+        virtual
+        std::list<std::string>
+        required_other_postprocessors () const;
+
+        /**
+         * Save the state of this object to the argument given to this
+         * function. This function is in support of checkpoint/restart
+         * functionality.
+         *
+         * Derived classes can implement this function and should store their
+         * state in a string that is deposited under a key in the map through
+         * which the respective class can later find the status again when the
+         * program is restarted. A legitimate key to store data under is
+         * <code>typeid(*this).name()</code>. It is up to derived classes to
+         * decide how they want to encode their state.
+         *
+         * The default implementation of this function does nothing, i.e., it
+         * represents a stateless object for which nothing needs to be stored
+         * at checkpoint time and nothing needs to be restored at restart
+         * time.
+         *
+         * @param[in,out] status_strings The object into which implementations
+         * in derived classes can place their status under a key that they can
+         * use to retrieve the data.
+         */
+        virtual
+        void save (std::map<std::string, std::string> &status_strings) const;
+
+        /**
+         * Restore the state of the object by looking up a description of the
+         * state in the passed argument under the same key under which it was
+         * previously stored.
+         *
+         * The default implementation does nothing.
+         *
+         * @param[in] status_strings The object from which the status will be
+         * restored by looking up the value for a key specific to this derived
+         * class.
+         */
+        virtual
+        void load (const std::map<std::string, std::string> &status_strings);
+    };
+
+
+
+
+
+
+    /**
+     * A class that manages all objects that provide functionality to
+     * postprocess solutions. It declares run time parameters for input files,
+     * reads their values from such an input file, manages a list of all
+     * postprocessors selected in the input file, and upon request through the
+     * execute() function calls them in turn.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute all of the postprocessor objects that have been requested
+         * in the input file. These objects also fill the contents of the
+         * statistics object.
+         *
+         * The function returns a concatenation of the text returned by the
+         * individual postprocessors.
+         */
+        std::list<std::pair<std::string,std::string>>
+        execute (TableHandler &statistics);
+
+        /**
+         * Go through the list of all postprocessors that have been selected
+         * in the input file (and are consequently currently active) and return
+         * true if one of them has the desired type specified by the template
+         * argument.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename PostprocessorType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,PostprocessorType>::value>>
+        bool
+        has_matching_postprocessor () const;
+
+        /**
+         * Go through the list of all postprocessors that have been selected
+         * in the input file (and are consequently currently active) and see
+         * if one of them has the type specified by the template
+         * argument or can be cast to that type. If so, return a reference
+         * to it. If no postprocessor is active that matches the given type,
+         * throw an exception.
+         *
+         * This function can only be called if the given template type (the first template
+         * argument) is a class derived from the Interface class in this namespace.
+         */
+        template <typename PostprocessorType,
+                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,PostprocessorType>::value>>
+        const PostprocessorType &
+        get_matching_postprocessor () const;
+
+        /**
+         * Declare the parameters of all known postprocessors, as well as of
+         * ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which postprocessor objects will be created; then
+         * let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Write the data of this object to a stream for the purpose of
+         * serialization.
+         */
+        template <class Archive>
+        void save (Archive &ar,
+                   const unsigned int version) const;
+
+        /**
+         * Read the data of this object from a stream for the purpose of
+         * serialization.
+         */
+        template <class Archive>
+        void load (Archive &ar,
+                   const unsigned int version);
+
+        BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+
+        /**
+         * A function that is used to register postprocessor objects in such a
+         * way that the Manager can deal with all of them without having to
+         * know them by name. This allows the files in which individual
+         * postprocessors are implement to register these postprocessors,
+         * rather than also having to modify the Manager class by adding the
+         * new postprocessor class.
+         *
+         * @param name The name under which this postprocessor is to be called
+         * in parameter files.
+         * @param description A text description of what this model does and
+         * that will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that
+         * declares the parameters for this postprocessor.
+         * @param factory_function A pointer to a function that creates such a
+         * postprocessor object and returns a pointer to it.
+         */
+        static
+        void
+        register_postprocessor (const std::string &name,
+                                const std::string &description,
+                                void (*declare_parameters_function) (ParameterHandler &),
+                                std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcPostprocessorNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered postprocessors.");
+    };
+
+
+    /* -------------------------- inline and template functions ---------------------- */
+
+    template <int dim>
+    template <class Archive>
+    void Manager<dim>::save (Archive &ar,
+                             const unsigned int) const
+    {
+      // let all the postprocessors save their data in a map and then
+      // serialize that
+      std::map<std::string,std::string> saved_text;
+      for (const auto &p : this->plugin_objects)
+        p->save (saved_text);
+
+      ar &saved_text;
+    }
+
+
+    template <int dim>
+    template <class Archive>
+    void Manager<dim>::load (Archive &ar,
+                             const unsigned int)
+    {
+      // get the map back out of the stream; then let the postprocessors
+      // that we currently have get their data from there. note that this
+      // may not be the same set of postprocessors we had when we saved
+      // their data
+      std::map<std::string,std::string> saved_text;
+      ar &saved_text;
+
+      for (auto &p : this->plugin_objects)
+        p->load (saved_text);
+    }
+
+
+
+    template <int dim>
+    template <typename PostprocessorType, typename>
+    inline
+    bool
+    Manager<dim>::has_matching_postprocessor () const
+    {
+      return this->template has_matching_plugin_object<PostprocessorType>();
+    }
+
+
+
+    template <int dim>
+    template <typename PostprocessorType, typename>
+    inline
+    const PostprocessorType &
+    Manager<dim>::get_matching_postprocessor () const
+    {
+      return this->template get_matching_plugin_object<PostprocessorType>();
+    }
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a postprocessor, register it with the aspect::Postprocess::Manager
+     * class.
+     *
+     * @ingroup Postprocessing
+     */
+#define ASPECT_REGISTER_POSTPROCESSOR(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_POSTPROCESSOR_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::Postprocess::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::Postprocess::Manager<2>::register_postprocessor, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::Postprocess::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::Postprocess::Manager<3>::register_postprocessor, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/load_balance_statistics.h.bak b/include/aspect/postprocess/load_balance_statistics.h.bak
new file mode 100644
index 00000000000..43ff120abd5
--- /dev/null
+++ b/include/aspect/postprocess/load_balance_statistics.h.bak
@@ -0,0 +1,66 @@
+/*
+  Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_load_balance_statistics_h
+#define _aspect_postprocess_load_balance_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes statistics about
+     * the distribution of cells, and if present particles
+     * across subdomains.
+     *
+     * In particular, it computes maximal, average and
+     * minimal number of cells across all ranks.
+     * If there are particles it also computes the
+     * maximal, average, and minimum number of particles across
+     * all ranks, and maximal, average, and minimal ratio
+     * between local number of particles and local number
+     * of cells across all processes. All of these numbers
+     * can be useful to assess the load balance between
+     * different MPI ranks, as the difference between the
+     * minimal and maximal load should be as small as
+     * possible.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class LoadBalanceStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Compute load balance statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/mass_flux_statistics.h.bak b/include/aspect/postprocess/mass_flux_statistics.h.bak
new file mode 100644
index 00000000000..a0c7a1cb18f
--- /dev/null
+++ b/include/aspect/postprocess/mass_flux_statistics.h.bak
@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_mass_flux_statistics_h
+#define _aspect_postprocess_mass_flux_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the material_flux
+     * in and out of boundaries.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class MassFluxStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some mass_flux statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/material_statistics.h.bak b/include/aspect/postprocess/material_statistics.h.bak
new file mode 100644
index 00000000000..b63d214d5a5
--- /dev/null
+++ b/include/aspect/postprocess/material_statistics.h.bak
@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2018 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_material_statistics_h
+#define _aspect_postprocess_material_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the
+     * material properties, in particular average density,
+     * average viscosity and total mass.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class MaterialStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some material property statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/matrix_statistics.h.bak b/include/aspect/postprocess/matrix_statistics.h.bak
new file mode 100644
index 00000000000..d317c00f87f
--- /dev/null
+++ b/include/aspect/postprocess/matrix_statistics.h.bak
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_matrix_statistics_h
+#define _aspect_postprocess_matrix_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the matrices
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class MatrixStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Compute matrix statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/max_depth_field.h.bak b/include/aspect/postprocess/max_depth_field.h.bak
new file mode 100644
index 00000000000..07b6808a879
--- /dev/null
+++ b/include/aspect/postprocess/max_depth_field.h.bak
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_max_depth_field_h
+#define _aspect_postprocess_max_depth_field_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    /**
+     * A postprocessor that computes the deepest point of the given composition.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class MaxDepthField : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for the biggest depth of the
+         * compositional field indicated by the user.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/melt_statistics.h.bak b/include/aspect/postprocess/melt_statistics.h.bak
new file mode 100644
index 00000000000..dd1daf88da4
--- /dev/null
+++ b/include/aspect/postprocess/melt_statistics.h.bak
@@ -0,0 +1,57 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_postprocess_melt_statistics_h
+#define _aspect_postprocess_melt_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the
+     * melt fraction. This only works for material models that
+     * are derived from MaterialModel::MeltFractionModel and
+     * implement their own
+     * MaterialModel::MeltFractionModel::melt_fraction function.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class MeltStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the melt fraction in the material model.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/memory_statistics.h.bak b/include/aspect/postprocess/memory_statistics.h.bak
new file mode 100644
index 00000000000..f3f62f48dea
--- /dev/null
+++ b/include/aspect/postprocess/memory_statistics.h.bak
@@ -0,0 +1,68 @@
+/*
+ Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _aspect_postprocess_memory_statistics_h
+#define _aspect_postprocess_memory_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the memory consumption.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class MemoryStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Calculate some statistics about the memory.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        bool output_vmpeak;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/mobility_statistics.h.bak b/include/aspect/postprocess/mobility_statistics.h.bak
new file mode 100644
index 00000000000..d6ff4e11598
--- /dev/null
+++ b/include/aspect/postprocess/mobility_statistics.h.bak
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_mobility_statistics_h
+#define _aspect_postprocess_mobility_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about mobility following Tackley (2000) and Lourenco et al. (2020)
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class MobilityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some mobility statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/particle_count_statistics.h.bak b/include/aspect/postprocess/particle_count_statistics.h.bak
new file mode 100644
index 00000000000..7b5dd94c9d5
--- /dev/null
+++ b/include/aspect/postprocess/particle_count_statistics.h.bak
@@ -0,0 +1,60 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_particle_count_statistics_h
+#define _aspect_postprocess_particle_count_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the distribution
+     * of particles, if possible.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class ParticleCountStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some particle statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Let the postprocessor manager know about the other postprocessors
+         * this one depends on. Specifically, the particles postprocessor.
+         */
+        std::list<std::string>
+        required_other_postprocessors() const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/particles.h.bak b/include/aspect/postprocess/particles.h.bak
new file mode 100644
index 00000000000..3a05da0d581
--- /dev/null
+++ b/include/aspect/postprocess/particles.h.bak
@@ -0,0 +1,319 @@
+/*
+ Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_postprocess_particle_h
+#define _aspect_postprocess_particle_h
+
+#include <aspect/postprocess/interface.h>
+
+#include <aspect/simulator_access.h>
+#include <aspect/particle/property/interface.h>
+
+#include <deal.II/particles/particle_handler.h>
+#include <deal.II/base/data_out_base.h>
+
+#include <thread>
+#include <tuple>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace internal
+    {
+      /**
+       * This class is responsible for writing the particle data into a format that can
+       * be written by deal.II, in particular a list of 'patches' that contain one
+       * particle per patch. The base class DataOutInterface is templated with a
+       * dimension of zero (the dimension of the particle / point), and a space dimension
+       * of dim (the dimension in which this zero-dimensional particle lives).
+       */
+      template <int dim>
+      class ParticleOutput : public dealii::DataOutInterface<0,dim>
+      {
+        public:
+          /**
+           * This function prepares the data for writing. It reads the data from @p particle_handler and their
+           * property information from @p property_information, and builds a list of patches that is stored
+           * internally until the destructor is called. This function needs to be called before one of the
+           * write function of the base class can be called to write the output data.
+           */
+          void build_patches(const Particles::ParticleHandler<dim> &particle_handler,
+                             const aspect::Particle::Property::ParticlePropertyInformation &property_information,
+                             const std::vector<std::string> &exclude_output_properties,
+                             const bool only_group_3d_vectors);
+
+        private:
+          /**
+           * Implementation of the corresponding function of the base class.
+           */
+          const std::vector<DataOutBase::Patch<0,dim>> &
+          get_patches () const override;
+
+          /**
+           * Implementation of the corresponding function of the base class.
+           */
+          std::vector<std::string>
+          get_dataset_names () const override;
+
+          /**
+           * Implementation of the corresponding function of the base class.
+           */
+          std::vector<
+          std::tuple<unsigned int,
+              unsigned int,
+              std::string,
+              DataComponentInterpretation::DataComponentInterpretation>>
+              get_nonscalar_data_ranges () const override;
+
+          /**
+           * Output information that is filled by build_patches() and
+           * written by the write function of the base class.
+           */
+          std::vector<DataOutBase::Patch<0,dim>> patches;
+
+          /**
+           * A list of field names for all data components stored in patches.
+           */
+          std::vector<std::string> dataset_names;
+
+          /**
+           * Store which of the data fields are vectors.
+           */
+          std::vector<
+          std::tuple<unsigned int,
+              unsigned int,
+              std::string,
+              DataComponentInterpretation::DataComponentInterpretation>>
+              vector_datasets;
+      };
+    }
+
+    /**
+     * A Postprocessor that creates particles, which follow the
+     * velocity field of the simulation. The particles can be generated
+     * and propagated in various ways and they can carry a number of
+     * constant or time-varying properties. The postprocessor can write
+     * output positions and properties of all particles at chosen intervals,
+     * although this is not mandatory. It also allows other parts of the
+     * code to query the particles for information.
+     */
+    template <int dim>
+    class Particles : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Particles();
+
+        /**
+         * Destructor.
+         */
+        ~Particles() override;
+
+        /**
+         * Execute this postprocessor. Derived classes will implement this
+         * function to do whatever they want to do to evaluate the solution at
+         * the current time step.
+         *
+         * @param[in,out] statistics An object that contains statistics that
+         * are collected throughout the simulation and that will be written to
+         * an output file at the end of each time step. Postprocessors may
+         * deposit data in these tables for later visualization or further
+         * processing.
+         *
+         * @return A pair of strings that will be printed to the screen after
+         * running the postprocessor in two columns; typically the first
+         * column contains a description of what the data is and the second
+         * contains a numerical value of this data. If there is nothing to
+         * print, simply return two empty strings.
+         */
+        std::pair<std::string,std::string> execute (TableHandler &statistics) override;
+
+        /**
+         * Save the state of this object.
+         */
+        void save (std::map<std::string, std::string> &status_strings) const override;
+
+        /**
+         * Restore the state of the object.
+         */
+        void load (const std::map<std::string, std::string> &status_strings) override;
+
+        /**
+         * Serialize the contents of this class as far as they are not read
+         * from input parameter files.
+         */
+        template <class Archive>
+        void serialize (Archive &ar, const unsigned int version);
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Interval between output (in years if appropriate simulation
+         * parameter is set, otherwise seconds)
+         */
+        double output_interval;
+
+        /**
+         * Records time for next output to occur
+         */
+        double last_output_time;
+
+        /**
+         * Set the time output was supposed to be written. In the simplest
+         * case, this is the previous last output time plus the interval, but
+         * in general we'd like to ensure that it is the largest supposed
+         * output time, which is smaller than the current time, to avoid
+         * falling behind with last_output_time and having to catch up once
+         * the time step becomes larger. This is done after every output.
+         */
+        void set_last_output_time (const double current_time);
+
+        /**
+         * Consecutively counted number indicating the how-manyth time we will
+         * create output the next time we get to it.
+         */
+        unsigned int output_file_number;
+
+        /**
+         * Graphical output format.
+         */
+        std::vector<std::string> output_formats;
+
+        /**
+         * A list of pairs (time, pvtu_filename) that have so far been written
+         * and that we will pass to DataOutInterface::write_pvd_record
+         * to create a description file that can make the association
+         * between simulation time and corresponding file name (this
+         * is done because there is no way to store the simulation
+         * time inside the .pvtu or .vtu files).
+         */
+        std::vector<std::pair<double,std::string>> times_and_pvtu_file_names;
+
+        /**
+         * A corresponding variable that we use for the .visit files created
+         * by DataOutInterface::write_visit_record. The second part of a
+         * pair contains all files that together form a time step.
+         */
+        std::vector<std::pair<double,std::vector<std::string>>> times_and_vtu_file_names;
+
+        /**
+         * A list of list of filenames, sorted by timestep, that correspond to
+         * what has been created as output. This is used to create a descriptive
+         * .visit file for the entire simulation.
+         */
+        std::vector<std::vector<std::string>> output_file_names_by_timestep;
+
+        /**
+         * A set of data related to XDMF file sections describing the HDF5
+         * heavy data files created. These contain things such as the
+         * dimensions and names of data written at all steps during the
+         * simulation.
+         */
+        std::vector<XDMFEntry>  xdmf_entries;
+
+        /**
+         * VTU file output supports grouping files from several CPUs into one
+         * file using MPI I/O when writing on a parallel filesystem. 0 means
+         * no grouping (and no parallel I/O). 1 will generate one big file
+         * containing the whole solution.
+         */
+        unsigned int group_files;
+
+        /**
+         * On large clusters it can be advantageous to first write the
+         * output to a temporary file on a local file system and later
+         * move this file to a network file system. If this variable is
+         * set to a non-empty string it will be interpreted as a temporary
+         * storage location.
+         */
+        std::string temporary_output_location;
+
+        /**
+         * File operations can potentially take a long time, blocking the
+         * progress of the rest of the model run. Setting this variable to
+         * 'true' moves this process into a background thread, while the
+         * rest of the model continues.
+         */
+        bool write_in_background_thread;
+
+        /**
+         * Handle to a thread that is used to write data in the background.
+         * The writer() function runs on this background thread.
+         */
+        std::thread background_thread;
+
+        /**
+         * Stores the particle property fields which are excluded from output
+         * to the visualization file.
+         */
+        std::vector<std::string> exclude_output_properties;
+
+        /**
+         * A function that writes the text in the second argument to a file
+         * with the name given in the first argument. The function is run on a
+         * separate thread to allow computations to continue even though
+         * writing data is still continuing. The function takes over ownership
+         * of these arguments and deletes them at the end of its work.
+         */
+        static
+        void writer (const std::string &filename,
+                     const std::string &temporary_filename,
+                     const std::string &file_contents);
+
+        /**
+         * Write the various descriptive record files. These files are used by
+         * visualization programs to identify which of the output files in a
+         * directory, possibly one file written by each processor, belong to a
+         * single time step and/or form the different time steps of a
+         * simulation. For Paraview, this is a <code>.pvtu</code> file per
+         * time step and a <code>.pvd</code> for all time steps. For VisIt it
+         * is a <code>.visit</code> file per time step and one for all time
+         * steps.
+         *
+         * @param data_out The DataOut object that was used to write the
+         * solutions.
+         * @param solution_file_prefix The stem of the filename to be written.
+         * @param filenames List of filenames for the current output from all
+         * processors.
+         */
+        void write_description_files (const internal::ParticleOutput<dim> &data_out,
+                                      const std::string &solution_file_prefix,
+                                      const std::vector<std::string> &filenames);
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/point_values.h.bak b/include/aspect/postprocess/point_values.h.bak
new file mode 100644
index 00000000000..61b61fc887a
--- /dev/null
+++ b/include/aspect/postprocess/point_values.h.bak
@@ -0,0 +1,128 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_point_values_h
+#define _aspect_postprocess_point_values_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/data_out_base.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that evaluates the solution vector at individual
+     * points.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class PointValues : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor
+         */
+        PointValues ();
+
+        /**
+         * Evaluate the solution and determine the values at the
+         * selected points.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Save the state of this object.
+         */
+        void save (std::map<std::string, std::string> &status_strings) const override;
+
+        /**
+         * Restore the state of the object.
+         */
+        void load (const std::map<std::string, std::string> &status_strings) override;
+
+        /**
+         * Serialize the contents of this class as far as they are not read
+         * from input parameter files.
+         */
+        template <class Archive>
+        void serialize (Archive &ar, const unsigned int version);
+
+      private:
+        /**
+         * Set the time output was supposed to be written. In the simplest
+         * case, this is the previous last output time plus the interval, but
+         * in general we'd like to ensure that it is the largest supposed
+         * output time, which is smaller than the current time, to avoid
+         * falling behind with last_output_time and having to catch up once
+         * the time step becomes larger. This is done after every output.
+         */
+        void set_last_output_time (const double current_time);
+
+        /**
+         * Interval between the generation of output in seconds.
+         */
+        double output_interval;
+
+        /**
+         * A time (in seconds) the last output has been produced.
+         */
+        double last_output_time;
+
+        /**
+         * Vector of Points representing the points where the solution is to be evaluated
+         * that can be used by VectorTools.
+         */
+        std::vector<Point<dim>> evaluation_points_cartesian;
+        /**
+         * The values of the solution at the evaluation points.
+         */
+        std::vector<std::pair<double, std::vector<Vector<double>>>> point_values;
+        /**
+         * Whether or not to interpret the evaluation points in the input file
+         * as natural coordinates or not.
+         */
+        bool use_natural_coordinates;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/pressure_statistics.h.bak b/include/aspect/postprocess/pressure_statistics.h.bak
new file mode 100644
index 00000000000..b05c892ffc3
--- /dev/null
+++ b/include/aspect/postprocess/pressure_statistics.h.bak
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_pressure_statistics_h
+#define _aspect_postprocess_pressure_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the pressure.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class PressureStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some pressure statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/rotation_statistics.h.bak b/include/aspect/postprocess/rotation_statistics.h.bak
new file mode 100644
index 00000000000..031fc0e30ea
--- /dev/null
+++ b/include/aspect/postprocess/rotation_statistics.h.bak
@@ -0,0 +1,85 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_rotation_statistics_h
+#define _aspect_postprocess_rotation_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the rotational
+     * velocity of the model (i.e. integrated net rotation and angular momentum).
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class RotationStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some velocity statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Whether to use a constant density of one for the computation of the
+         * angular momentum and moment of inertia. This is an approximation
+         * that assumes that the 'volumetric' rotation is equal to the 'mass'
+         * rotation. If this parameter is true this postprocessor computes
+         * 'net rotation' instead of 'angular momentum'.
+         */
+        bool use_constant_density;
+
+        /**
+         * Whether to write the full moment of inertia tensor into the
+         * statistics output instead of its norm for the current rotation
+         * axis. This is a second-order symmetric tensor with
+         * 6 components in 3D. In 2D this option has no effect, because
+         * the rotation axis is fixed and thus it is always a scalar.
+         */
+        bool output_full_tensor;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/sea_level.h.bak b/include/aspect/postprocess/sea_level.h.bak
new file mode 100644
index 00000000000..4efe24fbc48
--- /dev/null
+++ b/include/aspect/postprocess/sea_level.h.bak
@@ -0,0 +1,178 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_sea_level_h
+#define _aspect_postprocess_sea_level_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that outputs the sea level to file. The sea level is based
+     * on the ice heights input data, the solid Earth topography input data for
+     * defining the ocean basin, the geoid displacement from the geoid postprocessor,
+     * and the free surface topography from the geometry model. The sea level
+     * postprocessor requires a 3D spherical shell geometry with a free surface.
+     * The sea level computation is based on \\cite{Martinec2018}.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class SeaLevel : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Sets up structured data lookup for topography and ice height input data.
+         */
+        void initialize() override;
+
+        /**
+         * Output non-uniform sea level change [m] to file.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Evaluate the total surface pressure from ice and water loading at
+         * a point at the top surface of the domain. While the function will
+         * return pressure values for any location, it will always assume the
+         * volume between the point and the sea level is filled with water or ice,
+         * therefore calling this function for positions inside the domain will result
+         * in unrealistic pressure values.
+         */
+        double
+        compute_total_surface_pressure(const Point<dim> &position) const;
+
+        /**
+         * Register with the simulator the other postprocessors that we need
+         * (namely: geoid).
+         */
+        std::list<std::string>
+        required_other_postprocessors() const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Save the state of this object.
+         */
+        void save (std::map<std::string, std::string> &status_strings) const override;
+
+        /**
+         * Restore the state of the object.
+         */
+        void load (const std::map<std::string, std::string> &status_strings) override;
+
+        /**
+         * Serialize the contents of this class as far as they are not read
+         * from input parameter files.
+         */
+        template <class Archive>
+        void serialize (Archive &ar, const unsigned int version);
+
+      private:
+        /**
+         * Function to determine non-uniform sea level change for any given location.
+         * This is a local computation that makes use of the computed sea level offset,
+         * so make sure to call compute_sea_level_offset() before calling this function.
+         */
+        double
+        compute_nonuniform_sea_level_change(const Point<dim> &position) const;
+
+        /**
+         * Function to determine the global sea level offset.
+         */
+        double
+        compute_sea_level_offset();
+
+        /**
+         * Information about the location of topography data files.
+         */
+        std::string data_directory_topography;
+        std::string data_file_name_topography;
+
+        /**
+         * Information about the location of ice height data files.
+         */
+        std::string data_directory_ice_height;
+        std::string data_file_name_ice_height;
+
+        /**
+         * Pointer to the StructuredDataLookup object that holds the topography and ice height data.
+         */
+        std::unique_ptr<Utilities::StructuredDataLookup<2>> topography_lookup;
+        std::unique_ptr<Utilities::StructuredDataLookup<2>> ice_height_lookup;
+
+        /**
+         * The density of water.
+         */
+        double density_water;
+
+        /**
+         * The density of ice.
+         */
+        double density_ice;
+
+        /**
+         * The global sea level offset.
+         */
+        double sea_level_offset;
+
+        /**
+         * Whether or not to produce text files with sea level values.
+         */
+        bool write_to_file;
+
+        /**
+         * Interval between the generation of text output. This parameter
+         * is read from the input file and consequently is not part of the
+         * state that needs to be saved and restored.
+         */
+        double output_interval;
+
+        /**
+         * A time (in seconds) at which the last text output was supposed
+         * to be produced. Used to check for the next necessary output time.
+         */
+        double last_output_time;
+
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/spherical_velocity_statistics.h.bak b/include/aspect/postprocess/spherical_velocity_statistics.h.bak
new file mode 100644
index 00000000000..16fa2efb7ac
--- /dev/null
+++ b/include/aspect/postprocess/spherical_velocity_statistics.h.bak
@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_postprocess_spherical_velocity_statistics_h
+#define _aspect_postprocess_spherical_velocity_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the radial and
+     * tangential components of the velocity in spherical/cylindrical models.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class SphericalVelocityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some velocity statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/stokes_residual.h.bak b/include/aspect/postprocess/stokes_residual.h.bak
new file mode 100644
index 00000000000..3890824e104
--- /dev/null
+++ b/include/aspect/postprocess/stokes_residual.h.bak
@@ -0,0 +1,108 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_stokes_residual_h
+#define _aspect_postprocess_stokes_residual_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/data_out_base.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that outputs Stokes residuals to a file stokes_residuals.txt.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class StokesResidual : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        StokesResidual ();
+
+        /**
+         * This attaches to the Stokes solver signal.
+         */
+        void initialize() override;
+
+        /**
+         * Generate the output file.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Save the state of this object.
+         */
+        void save (std::map<std::string, std::string> &status_strings) const override;
+
+        /**
+         * Restore the state of the object.
+         */
+        void load (const std::map<std::string, std::string> &status_strings) override;
+
+        /**
+         * Serialize the contents of this class as far as they are not read
+         * from input parameter files.
+         */
+        template <class Archive>
+        void serialize (Archive &ar, const unsigned int version);
+
+      private:
+        /**
+         * A structure for a single time step record.
+         */
+        struct DataPoint
+        {
+          double time;
+          unsigned int solve_index;
+          std::vector<double> values;
+
+          template <class Archive>
+          void serialize (Archive &ar, const unsigned int version);
+        };
+
+        /**
+         * Callback function to collect the data.
+         */
+        void stokes_solver_callback (const SolverControl &solver_control_cheap,
+                                     const SolverControl &solver_control_expensive);
+
+        /**
+         * An array of all the past values
+         */
+        std::vector<DataPoint> entries;
+
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/temperature_statistics.h.bak b/include/aspect/postprocess/temperature_statistics.h.bak
new file mode 100644
index 00000000000..b059802482a
--- /dev/null
+++ b/include/aspect/postprocess/temperature_statistics.h.bak
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_temperature_statistics_h
+#define _aspect_postprocess_temperature_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the temperature.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class TemperatureStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some temperature statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/topography.h.bak b/include/aspect/postprocess/topography.h.bak
new file mode 100644
index 00000000000..46f29389c9a
--- /dev/null
+++ b/include/aspect/postprocess/topography.h.bak
@@ -0,0 +1,91 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_topography_h
+#define _aspect_postprocess_topography_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that outputs the surface topography to file.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class Topography : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Output topography [m] to file
+         */
+        std::pair<std::string,std::string> execute (TableHandler &statistics) override;
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+        /**
+         * @}
+         */
+
+      private:
+        /**
+         * Whether or not to produce text files with topography values
+         */
+        bool write_to_file;
+
+        /**
+         * Interval between the generation of text output. This parameter
+         * is read from the input file and consequently is not part of the
+         * state that needs to be saved and restored.
+         */
+        double output_interval;
+
+        /**
+         * A time (in seconds) at which the last text output was supposed
+         * to be produced. Used to check for the next necessary output time.
+         */
+        double last_output_time;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/velocity_boundary_statistics.h.bak b/include/aspect/postprocess/velocity_boundary_statistics.h.bak
new file mode 100644
index 00000000000..3c6ec0496ba
--- /dev/null
+++ b/include/aspect/postprocess/velocity_boundary_statistics.h.bak
@@ -0,0 +1,55 @@
+/*
+  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_postprocess_velocity_boundary_statistics_h
+#define _aspect_postprocess_velocity_boundary_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the velocity at
+     * different parts of the boundary.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class VelocityBoundaryStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some velocity boundary statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/velocity_statistics.h.bak b/include/aspect/postprocess/velocity_statistics.h.bak
new file mode 100644
index 00000000000..0fff1d21e95
--- /dev/null
+++ b/include/aspect/postprocess/velocity_statistics.h.bak
@@ -0,0 +1,52 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_velocity_statistics_h
+#define _aspect_postprocess_velocity_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the velocity.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class VelocityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some velocity statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/viscous_dissipation_statistics.h.bak b/include/aspect/postprocess/viscous_dissipation_statistics.h.bak
new file mode 100644
index 00000000000..575b3d58070
--- /dev/null
+++ b/include/aspect/postprocess/viscous_dissipation_statistics.h.bak
@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2011 - 2021-2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_viscous_dissipation_statistics_h
+#define _aspect_postprocess_viscous_dissipation_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes the viscous dissipation over the area
+     * spanned by each compositional field and over the whole domain.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class ViscousDissipationStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution to compute the viscous dissipation
+         * per compositional field and over the whole domain.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/visualization.h.bak b/include/aspect/postprocess/visualization.h.bak
new file mode 100644
index 00000000000..f483e78ae99
--- /dev/null
+++ b/include/aspect/postprocess/visualization.h.bak
@@ -0,0 +1,747 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_h
+#define _aspect_postprocess_visualization_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/plugins.h>
+
+#include <deal.II/base/thread_management.h>
+#include <deal.II/numerics/data_postprocessor.h>
+#include <deal.II/base/data_out_base.h>
+#include <deal.II/numerics/data_out.h>
+
+#include <thread>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * Compute the arithmetic average over q for each m of the variable quantities[q](m).
+       */
+      inline void average_quantities(std::vector<Vector<double>> &quantities)
+      {
+        const unsigned int N = quantities.size();
+        const unsigned int M = quantities[0].size();
+        for (unsigned int m=0; m<M; ++m)
+          {
+            double sum = 0;
+            for (unsigned int q=0; q<N; ++q)
+              sum += quantities[q](m);
+
+            const double average = sum/N;
+            for (unsigned int q=0; q<N; ++q)
+              quantities[q](m) = average;
+          }
+      }
+
+      /**
+       * This class declares the public interface of visualization
+       * postprocessors. Visualization postprocessors are used to compute
+       * derived data, e.g. wave speeds, friction heating terms, etc, to be
+       * put into graphical output files. They are plugins for the
+       * aspect::Postprocess::Visualization class.
+       *
+       * Classes derived from this type must implement the functions that save
+       * the state of the object and restore it (for checkpoint/restart
+       * capabilities) as well as functions that declare and read parameters.
+       * However, this class also already provides default implementations of
+       * these functions that simply do nothing. This is appropriate for
+       * objects that are stateless, as is commonly the case for visualization
+       * postprocessors.
+       *
+       * Access to the data of the simulator is granted by the @p protected
+       * member functions of the SimulatorAccess class, i.e., classes
+       * implementing this interface will in general want to derive from both
+       * this Interface class as well as from the SimulatorAccess class.
+       *
+       * <h3> How visualization plugins work </h3>
+       *
+       * There are two ways in which visualization plugins can work to get
+       * data from a simulation into an output file:
+       * <ul>
+       * <li> Classes derived from this class can also derive from the deal.II
+       * class DataPostprocessor or any of the classes like
+       * DataPostprocessorScalar or DataPostprocessorVector. These classes can
+       * be thought of as filters: DataOut will call a function in them for
+       * every cell and this function will transform the values or gradients
+       * of the solution and other information such as the location of
+       * quadrature points into the desired quantity to output. A typical case
+       * would be if the quantity $g(x)$ you want to output can be written as
+       * a function $g(x) = G(u(x),\nabla u(x), x, ...)$ in a point-wise sense
+       * where $u(x)$ is the value of the solution vector (i.e., the
+       * velocities, pressure, temperature, etc) at an evaluation point. In
+       * the context of this program an example would be to output the density
+       * of the medium as a spatially variable function since this is a
+       * quantity that for realistic media depends point-wise on the values of
+       * the solution.
+       *
+       * Using this way of describing a visualization postprocessor will yield
+       * a class  that would then have the following base classes:
+       * - aspect::Postprocess::VisualizationPostprocessors::Interface
+       * - aspect::SimulatorAccess
+       * - dealii::DataPostprocessor or any of the other ones listed above
+       *
+       * <li> The second possibility is for a class to not derive from
+       * dealii::DataPostprocessor but instead from the CellDataVectorCreator
+       * class. In this case, a visualization postprocessor would generate and
+       * return a vector that consists of one element per cell. The intent of
+       * this option is to output quantities that are not point-wise functions
+       * of the solution but instead can only be computed as integrals or
+       * other functionals on a per-cell basis. A typical case would be error
+       * estimators that do depend on the solution but not in a point-wise
+       * sense; rather, they yield one value per cell of the mesh. See the
+       * documentation of the CellDataVectorCreator class for more
+       * information.
+       * </ul>
+       * @ingroup Postprocessing
+       * @ingroup Visualization
+       */
+      template <int dim>
+      class Interface : public Plugins::InterfaceBase
+      {
+        public:
+          /**
+           * Constructor. The constructor takes as argument the physical
+           * units of the quantity (scalar or vector-valued) computed by
+           * derived classes. The empty string, "", refers to an unknown
+           * or nonexistent unit.
+           *
+           * If a visualization postprocessor generates more than one
+           * output component, and if the different components have different
+           * physical units, then they should be separated by commas. If
+           * the different components have the same physical units, these units
+           * need to be specified only once and will apply to all components.
+           *
+           * There are cases where the physical units can only be determined
+           * at a time later than when this constructor is called. An example
+           * is when a velocity is output as either `m/s` or `m/year`,
+           * depending on some run-time parameter. In those cases, derived
+           * classes should simply pass in an empty string to this constructor
+           * and instead overload the get_physical_units() function.
+           */
+          explicit Interface (const std::string &physical_units = "");
+
+          /**
+           * Return the string representation of the physical units that a
+           * derived class has provided to the constructor of this class.
+           *
+           * As mentioned in the documentation of the constructor, there are
+           * cases where a derived class doesn't know the physical units yet
+           * that correspond to what is being output at the time the
+           * constructor is called. In that case, the derived class can
+           * overload this function and return the correct units when the
+           * visualization postprocessor is executed.
+           */
+          virtual
+          std::string
+          get_physical_units () const;
+
+          /**
+           * A function that is used to indicate to the postprocessor manager which
+           * other postprocessor(s) the current one depends upon. The returned
+           * list contains the names (as strings, as you would write them in
+           * the input file) of the postprocessors it requires. The manager
+           * will ensure that these postprocessors are indeed used, even if
+           * they were not explicitly listed in the input file, and are indeed
+           * run <i>before</i> this postprocessor every time they are executed.
+           *
+           * The postprocessors you can nominate here are of the general
+           * postprocessor class, not visualization postprocessors.
+           *
+           * The default implementation of this function returns an empty list.
+           */
+          virtual
+          std::list<std::string>
+          required_other_postprocessors () const;
+
+          /**
+           * Save the state of this object to the argument given to this
+           * function. This function is in support of checkpoint/restart
+           * functionality.
+           *
+           * Derived classes can implement this function and should store
+           * their state in a string that is deposited under a key in the map
+           * through which the respective class can later find the status
+           * again when the program is restarted. A legitimate key to store
+           * data under is <code>typeid(*this).name()</code>. It is up to
+           * derived classes to decide how they want to encode their state.
+           *
+           * The default implementation of this function does nothing, i.e.,
+           * it represents a stateless object for which nothing needs to be
+           * stored at checkpoint time and nothing needs to be restored at
+           * restart time.
+           *
+           * @param[in,out] status_strings The object into which
+           * implementations in derived classes can place their status under a
+           * key that they can use to retrieve the data.
+           */
+          virtual
+          void save (std::map<std::string, std::string> &status_strings) const;
+
+          /**
+           * Restore the state of the object by looking up a description of
+           * the state in the passed argument under the same key under which
+           * it was previously stored.
+           *
+           * The default implementation does nothing.
+           *
+           * @param[in] status_strings The object from which the status will
+           * be restored by looking up the value for a key specific to this
+           * derived class.
+           */
+          virtual
+          void load (const std::map<std::string, std::string> &status_strings);
+
+        private:
+          /**
+           * The physical units encoded by this visualization postprocessor.
+           */
+          const std::string physical_units;
+      };
+
+
+
+      /**
+       * As explained in the documentation of the Interface class, the second
+       * kind of visualization plugin is one that wants to generate cell-wise
+       * data. Classes derived from this class need to implement a function
+       * execute() that computes these cell-wise values and return a pair of
+       * values where the first one indicates the name of a variable and the
+       * second one is a vector with one entry per cell. This class is the
+       * interface that such plugins have to implement.
+       *
+       * @ingroup Postprocessing
+       * @ingroup Visualization
+       */
+      template <int dim>
+      class CellDataVectorCreator : public Interface<dim>
+      {
+        public:
+          /**
+           * Constructor. The constructor takes as argument the physical
+           * units of the quantity (scalar or vector-valued) computed by
+           * derived classes.
+           */
+          explicit CellDataVectorCreator (const std::string &physical_units = "");
+
+          /**
+           * Destructor.
+           */
+          ~CellDataVectorCreator ()  override = default;
+
+          /**
+           * The function classes have to implement that want to output
+           * cell-wise data.
+           *
+           * @return A pair of values with the following meaning:
+           * - The first element provides the name by which this data should
+           *   be written to the output file.
+           * - The second element is a pointer to a vector with one element
+           *   per active cell on the current processor. Elements corresponding
+           *   to active cells that are either artificial or ghost cells (in
+           *   deal.II language, see the deal.II glossary)
+           *   will be ignored but must nevertheless exist in the returned
+           *   vector.
+           * While implementations of this function must create this
+           * vector, ownership is taken over by the caller of this function
+           * and the caller will take care of destroying the vector pointed
+           * to.
+           */
+          virtual
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const = 0;
+      };
+
+
+      /**
+       * This class is a tag class: If a visualization postprocessor is derived
+       * from it, then this is interpreted as saying that the class will only
+       * be used to generate graphical output on the surface of the model,
+       * rather than for the entire domain.
+       */
+      template <int dim>
+      class SurfaceOnlyVisualization
+      {
+        public:
+          /**
+           * Destructor. Made `virtual` to ensure that it is possible to
+           * test whether a derived class is derived from this class via
+           * a `dynamic_cast`.
+           */
+          virtual
+          ~SurfaceOnlyVisualization () = default;
+      };
+    }
+
+
+    /**
+     * A postprocessor that generates graphical output in periodic intervals
+     * or every time step. The time interval between generating graphical
+     * output is obtained from the parameter file.
+     *
+     * While this class acts as a plugin, i.e. as a postprocessor that can be
+     * registered with the postprocessing manager class
+     * aspect::Postprocess::Manager, this class at the same time also acts as
+     * a manager for plugins itself, namely for classes derived from the
+     * VisualizationPostprocessors::Interface class that are used to output
+     * different aspects of the solution, such as for example a computed
+     * seismic wave speed from temperature, velocity and pressure.
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class Visualization : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Visualization ();
+
+        /**
+         * Generate graphical output from the current solution.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+
+        /**
+         * Update any temporary information needed by the visualization postprocessor.
+         */
+        void
+        update () override;
+
+        /**
+         * A function that is used to register visualization postprocessor
+         * objects in such a way that the Manager can deal with all of them
+         * without having to know them by name. This allows the files in which
+         * individual postprocessors are implement to register these
+         * postprocessors, rather than also having to modify the Manage class
+         * by adding the new postprocessor class.
+         *
+         * @param name The name under which this visualization postprocessor
+         * is to be called in parameter files.
+         * @param description A text description of what this visualization
+         * plugin does and that will be listed in the documentation of the
+         * parameter file.
+         * @param declare_parameters_function A pointer to a function that
+         * declares the parameters for this postprocessor.
+         * @param factory_function A pointer to a function that creates such a
+         * postprocessor object and returns a pointer to it.
+         */
+        static
+        void
+        register_visualization_postprocessor (const std::string &name,
+                                              const std::string &description,
+                                              void (*declare_parameters_function) (ParameterHandler &),
+                                              std::unique_ptr<VisualizationPostprocessors::Interface<dim>>(*factory_function) ());
+
+        /**
+         * A function that is used to indicate to the postprocessor manager which
+         * other postprocessor(s) the current one depends upon.
+         *
+         * For the current class, we simply loop over all of the visualization
+         * postprocessors and collect what they want.
+         */
+        std::list<std::string>
+        required_other_postprocessors () const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * Save the state of this object.
+         */
+        void save (std::map<std::string, std::string> &status_strings) const override;
+
+        /**
+         * Restore the state of the object.
+         */
+        void load (const std::map<std::string, std::string> &status_strings) override;
+
+        /**
+         * Serialize the contents of this class as far as they are not read
+         * from input parameter files.
+         */
+        template <class Archive>
+        void serialize (Archive &ar, const unsigned int version);
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+        /**
+         * Return the value of the parameter @p pointwise_stress_and_strain
+         * that is controlled by the parameter "Point-wise stress and strain".
+         */
+        bool output_pointwise_stress_and_strain() const;
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcPostprocessorNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered postprocessors.");
+
+      private:
+        /**
+         * Interval between the generation of graphical output. This parameter
+         * is read from the input file and consequently is not part of the
+         * state that needs to be saved and restored.
+         */
+        double output_interval;
+
+        /**
+         * A time (in seconds) at which the last graphical output was supposed
+         * to be produced. Used to check for the next necessary output time.
+         */
+        double last_output_time;
+
+        /**
+         * Maximum number of steps between the generation of graphical output.
+         * This parameter
+         * is read from the input file and consequently is not part of the
+         * state that needs to be saved and restored.
+         */
+        unsigned int maximum_timesteps_between_outputs;
+
+        /**
+         * Timestep at which the last graphical output was produced
+         * Used to check for the next necessary output time.
+         */
+        unsigned int last_output_timestep;
+
+        /**
+         * Consecutively counted number indicating the how-manyth time we will
+         * create output the next time we get to it.
+         */
+        unsigned int output_file_number;
+
+        /**
+         * Graphical output format.
+         */
+        std::string output_format;
+
+        /**
+         * VTU file output supports grouping files from several CPUs into one
+         * file using MPI I/O when writing on a parallel filesystem. 0 means
+         * no grouping (and no parallel I/O). 1 will generate one big file
+         * containing the whole solution.
+         */
+        unsigned int group_files;
+
+        /**
+         * On large clusters it can be advantageous to first write the
+         * output to a temporary file on a local file system and later
+         * move this file to a network file system. If this variable is
+         * set to a non-empty string it will be interpreted as a temporary
+         * storage location.
+         */
+        std::string temporary_output_location;
+
+        /**
+         * deal.II offers the possibility to linearly interpolate output
+         * fields of higher order elements to a finer resolution. This
+         * somewhat compensates the fact that most visualization software only
+         * offers linear interpolation between grid points and therefore the
+         * output file is a very coarse representation of the actual solution
+         * field. Activating this option increases the spatial resolution in
+         * each dimension by a factor equal to the polynomial degree used for
+         * the velocity finite element (usually 2).
+         */
+        bool interpolate_output;
+
+        /**
+         * deal.II offers the possibility to filter duplicate vertices in HDF5
+         * output files. This merges the vertices of adjacent cells and
+         * therefore saves disk space, but misrepresents discontinuous
+         * output properties. Activating this function reduces the disk space
+         * by about a factor of $2^{dim}$ for hdf5 output.
+         */
+        bool filter_output;
+
+        /**
+         * If true, return quantities related to stresses and strain with
+         * point-wise values. Otherwise the values will be averaged on each
+         * cell.
+         */
+        bool pointwise_stress_and_strain;
+
+        /**
+         * deal.II offers the possibility to write vtu files with higher order
+         * representations of the output data. This means each cell will correctly
+         * show the higher order representation of the output data instead of the
+         * linear interpolation between vertices that ParaView and VisIt usually show.
+         * Note that activating this option is safe and recommended, but requires that
+         * (i) ``Output format'' is set to ``vtu'', (ii) ``Interpolate output'' is
+         * set to true, (iii) you use a sufficiently new version of Paraview
+         * or VisIt to read the files (Paraview version 5.5 or newer, and VisIt version
+         * to be determined), and (iv) you use deal.II version 9.1.0 or newer.
+         */
+        bool write_higher_order_output;
+
+        /**
+         * For mesh deformation computations ASPECT uses an
+         * Arbitrary-Lagrangian-Eulerian formulation to handle deforming the
+         * domain, so the mesh has its own velocity field. This may be
+         * written as an output field by setting output_mesh_velocity to true.
+         */
+        bool output_mesh_velocity;
+
+        /**
+         * For mesh deformation computations ASPECT uses an
+         * Arbitrary-Lagrangian-Eulerian formulation to handle deforming the domain, so the mesh
+         * has a field that determines the displacement from the reference
+         * configuration. This may be written as an output field by setting
+         * this flag to true.
+         */
+        bool output_mesh_displacement;
+
+        /**
+         * For mesh deformation computations ASPECT uses an
+         * Arbitrary-Lagrangian-Eulerian formulation to handle deforming the domain, and we output the
+         * mesh in its deformed state by default. If this flag is set to true,
+         * the mesh is written undeformed.
+         */
+        bool output_undeformed_mesh;
+
+        /**
+         * Whether or not ASPECT should also generate output for the base variables
+         * velocity, (fluid pressure and velocity), pressure, temperature
+         * and the compositional fields on the surface of the mesh.
+         * The mesh surface includes all boundaries of the domain.
+         */
+        bool output_base_variables_on_mesh_surface;
+
+        /**
+         * File operations can potentially take a long time, blocking the
+         * progress of the rest of the model run. Setting this variable to
+         * 'true' moves this process into a background thread, while the
+         * rest of the model continues.
+         */
+        bool write_in_background_thread;
+
+        /**
+         * Set the time output was supposed to be written. In the simplest
+         * case, this is the previous last output time plus the interval, but
+         * in general we'd like to ensure that it is the largest supposed
+         * output time, which is smaller than the current time, to avoid
+         * falling behind with last_output_time and having to catch up once
+         * the time step becomes larger. This is done after every output.
+         */
+        void set_last_output_time (const double current_time);
+
+        /**
+         * Record that the mesh changed. This helps some output writers avoid
+         * writing the same mesh multiple times.
+         */
+        void mesh_changed_signal ();
+
+        /**
+         * A function that writes the text in the second argument to a file
+         * with the name given in the first argument. The function is run on a
+         * separate thread to allow computations to continue even though
+         * writing data is still continuing.
+         */
+        static
+        void writer (const std::string &filename,
+                     const std::string &temporary_filename,
+                     const std::string &file_contents);
+
+        /**
+         * A list of postprocessor objects that have been requested in the
+         * parameter file.
+         */
+        std::list<std::unique_ptr<VisualizationPostprocessors::Interface<dim>>> postprocessors;
+
+        /**
+         * A structure that keeps some history about past output operations.
+         * These variables are grouped into a structure because we need them
+         * twice: Once for the cell output case (via DataOut) and once for
+         * surface output (via DataOutFaces).
+         */
+        struct OutputHistory
+        {
+          /**
+           * Constructor
+           */
+          OutputHistory ();
+
+          /**
+           * Destructor. Makes sure that any background thread that may still be
+           * running writing data to disk finishes before the current object is
+           * fully destroyed.
+           */
+          ~OutputHistory ();
+
+          /**
+           * Serialize the contents of this class as far as they are not read
+           * from input parameter files.
+           */
+          template <class Archive>
+          void serialize (Archive &ar, const unsigned int version);
+
+          /**
+           * Whether the mesh changed since the last time we produced cell-based
+           * output.
+           */
+          bool mesh_changed;
+
+          /**
+           * The most recent name of the mesh file, used to avoid redundant mesh
+           * output.
+           */
+          std::string last_mesh_file_name;
+
+          /**
+           * A list of pairs (time, pvtu_filename) that have so far been written
+           * and that we will pass to DataOutInterface::write_pvd_record to
+           * create a description file that can make the association between
+           * simulation time and corresponding file name (this is done because
+           * there is no way to store the simulation time inside the .pvtu or
+           * .vtu files).
+           */
+          std::vector<std::pair<double,std::string>> times_and_pvtu_names;
+
+          /**
+           * A list of list of filenames, sorted by timestep, that correspond to
+           * what has been created as output. This is used to create a descriptive
+           * .visit file for the entire simulation.
+           */
+          std::vector<std::vector<std::string>> output_file_names_by_timestep;
+
+          /**
+           * A set of data related to XDMF file sections describing the HDF5
+           * heavy data files created. These contain things such as the
+           * dimensions and names of data written at all steps during the
+           * simulation.
+           */
+          std::vector<XDMFEntry>  xdmf_entries;
+
+          /**
+           * Handle to a thread that is used to write data in the background.
+           * The writer() function runs on this background thread when outputting
+           * data for the `data_out` object.
+           */
+          std::thread background_thread;
+        };
+
+        /**
+         * Information about the history of writing graphical
+         * output for cells (via DataOut).
+         */
+        OutputHistory cell_output_history;
+
+        /**
+         * Information about the history of writing graphical
+         * output for faces (via DataOutFaces).
+         */
+        OutputHistory face_output_history;
+
+        /**
+         * Write the various descriptive record files. These files are used by
+         * visualization programs to identify which of the output files in a
+         * directory, possibly one file written by each processor, belong to a
+         * single time step and/or form the different time steps of a
+         * simulation. For Paraview, this is a <code>.pvtu</code> file per
+         * time step and a <code>.pvd</code> for all time steps. For VisIt it
+         * is a <code>.visit</code> file per time step and one for all time
+         * steps.
+         *
+         * @param data_out The DataOut object that was used to write the
+         * solutions.
+         * @param solution_file_prefix The stem of the filename to be written.
+         * @param filenames List of filenames for the current output from all
+         * processors.
+         * @param output_history The OutputHistory object to fill.
+         */
+        template <typename DataOutType>
+        void write_description_files (const DataOutType &data_out,
+                                      const std::string &solution_file_prefix,
+                                      const std::vector<std::string> &filenames,
+                                      OutputHistory                  &output_history) const;
+
+
+        /**
+         * A function, called from the execute() function, that takes a
+         * DataOut object, does some preliminary work with it, and then
+         * writes the result out to files via the writer() function (in the
+         * case of VTU output) or through the XDMF facilities.
+         *
+         * The function returns the base name of the output files produced,
+         * which can then be used for the statistics file and screen output.
+         */
+        template <typename DataOutType>
+        std::string write_data_out_data(DataOutType   &data_out,
+                                        OutputHistory &output_history,
+                                        const std::map<std::string,std::string> &visualization_field_names_and_units) const;
+    };
+  }
+
+
+  /**
+   * Given a class name, a name, and a description for the parameter file for
+   * a postprocessor, register it with the aspect::Postprocess::Manager class.
+   *
+   * @ingroup Postprocessing
+   */
+#define ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::Postprocess::VisualizationPostprocessors::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::Postprocess::Visualization<2>::register_visualization_postprocessor, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::Postprocess::VisualizationPostprocessors::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::Postprocess::Visualization<3>::register_visualization_postprocessor, \
+                                name, description); \
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/visualization/ISA_rotation_timescale.h.bak b/include/aspect/postprocess/visualization/ISA_rotation_timescale.h.bak
new file mode 100644
index 00000000000..5c4790c8703
--- /dev/null
+++ b/include/aspect/postprocess/visualization/ISA_rotation_timescale.h.bak
@@ -0,0 +1,72 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_ISA_rotation_timescale_h
+#define _aspect_postprocess_visualization_ISA_rotation_timescale_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * This postprocessor calculates and outputs the timescale for the rotation
+       * of grains toward the infinite strain axis. Kaminski and Ribe (2002, Gcubed)
+       * call this quantity $\tau_{ISA}$, and define it as
+       * $\tau_{ISA} \approx \frac{1}{\dot{\epsilon}}$
+       * where $\dot{\epsilon}$ is the largest eigenvalue of the strain rate tensor.
+       * It can be used, along with the grain lag angle
+       * ($\Theta$), to calculate the grain orientation lag parameter (GOL).
+       * GOL is not calculated within ASPECT
+       * right now because it is proportional to the spatial gradient of theta, but in the
+       * future that calculation could be implemented in a material model with CopyOutputs
+       * (once they exist). For more thoughts on that, see the documentation for the
+       * grain lag angle postprocessor.
+       */
+      template <int dim>
+      class ISARotationTimescale: public CellDataVectorCreator<dim>, public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ISARotationTimescale();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute() const override;
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/adiabat.h.bak b/include/aspect/postprocess/visualization/adiabat.h.bak
new file mode 100644
index 00000000000..90bf7e6634b
--- /dev/null
+++ b/include/aspect/postprocess/visualization/adiabat.h.bak
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_adiabat_h
+#define _aspect_postprocess_visualization_adiabat_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that outputs adiabatic
+       * temperature, pressure, density, and density derivative.
+       */
+      template <int dim>
+      class Adiabat
+        : public DataPostprocessor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          Adiabat ();
+
+          std::vector<std::string>
+          get_names () const override;
+
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/artificial_viscosity.h.bak b/include/aspect/postprocess/visualization/artificial_viscosity.h.bak
new file mode 100644
index 00000000000..40d088828f1
--- /dev/null
+++ b/include/aspect/postprocess/visualization/artificial_viscosity.h.bak
@@ -0,0 +1,60 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_artificial_viscosity_h
+#define _aspect_postprocess_visualization_artificial_viscosity_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived that implements a function that provides the
+       * artificial viscosity for the temperature equation on each cell for
+       * graphical output.
+       */
+      template <int dim>
+      class ArtificialViscosity : public CellDataVectorCreator<dim>,
+        public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ArtificialViscosity();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/artificial_viscosity_composition.h.bak b/include/aspect/postprocess/visualization/artificial_viscosity_composition.h.bak
new file mode 100644
index 00000000000..047a2024f53
--- /dev/null
+++ b/include/aspect/postprocess/visualization/artificial_viscosity_composition.h.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_artificial_viscosity_composition_h
+#define _aspect_postprocess_visualization_artificial_viscosity_composition_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived that implements a function that provides the
+       * artificial viscosity for a given composition on each cell for
+       * graphical output.
+       */
+      template <int dim>
+      class ArtificialViscosityComposition : public CellDataVectorCreator<dim>,
+        public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ArtificialViscosityComposition();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * A parameter that tells us for which compositional field the
+           * artificial viscosity should be visualized.
+           */
+          int compositional_field;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/boundary_indicator.h.bak b/include/aspect/postprocess/visualization/boundary_indicator.h.bak
new file mode 100644
index 00000000000..7ae400a50c8
--- /dev/null
+++ b/include/aspect/postprocess/visualization/boundary_indicator.h.bak
@@ -0,0 +1,65 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_boundary_indicator_h
+#define _aspect_postprocess_visualization_boundary_indicator_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from CellDataVectorCreator that takes an output
+       * vector and computes a variable that represents the boundary
+       * indicator of the triangulation's cells' faces.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class BoundaryIndicator
+        : public CellDataVectorCreator<dim>,
+          public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          BoundaryIndicator();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const override;
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/boundary_strain_rate_residual.h.bak b/include/aspect/postprocess/visualization/boundary_strain_rate_residual.h.bak
new file mode 100644
index 00000000000..d0319a81bf4
--- /dev/null
+++ b/include/aspect/postprocess/visualization/boundary_strain_rate_residual.h.bak
@@ -0,0 +1,87 @@
+/*
+  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_boundary_strain_rate_residual_h
+#define _aspect_postprocess_visualization_boundary_strain_rate_residual_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      using namespace dealii;
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the residual between
+       * the a reference strain rate dataset and the strain rate computed for the model domain.
+       * We only compute the residual between the second invariant of the strain rate
+       * and therefore, the input data is an ascii data file with columns corresponding
+       * to coordinates and one data column representing the second invariant of the strain rate.
+       *
+       * This quantity only makes sense at the surface of the domain.
+       * Thus, the value is set to zero in all the cells inside of the domain.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class BoundaryStrainRateResidual
+        : public DataPostprocessorScalar<dim>,
+          public SurfaceOnlyVisualization<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          BoundaryStrainRateResidual ();
+
+          /**
+           * Evaluate the strain rate residual for each component at the top face of the current cell
+           * if it lies at the surface boundary.
+           *
+           * @copydoc DataPostprocessorTensor<dim>::evaluate_vector_field()
+           */
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * Let the postprocessor manager know about the other postprocessors
+           * this one depends on. Specifically, the boundary strain rate residual statistics postprocessor.
+           */
+          std::list<std::string>
+          required_other_postprocessors() const override;
+
+          std::string
+          get_physical_units () const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/boundary_velocity_residual.h.bak b/include/aspect/postprocess/visualization/boundary_velocity_residual.h.bak
new file mode 100644
index 00000000000..9847498f7e9
--- /dev/null
+++ b/include/aspect/postprocess/visualization/boundary_velocity_residual.h.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_boundary_velocity_residual_h
+#define _aspect_postprocess_visualization_boundary_velocity_residual_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      using namespace dealii;
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the velocity residual between
+       * the input velocity data and the velocity computed for the model domain.
+       * The input velocity could either be an ascii data file or a file generated
+       * by  the GPlates model.
+       * This quantity only makes sense at the surface of the domain.
+       * Thus, the value is set to zero in all the cells inside of the domain.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class BoundaryVelocityResidual
+        : public DataPostprocessorVector<dim>,
+          public SurfaceOnlyVisualization<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          BoundaryVelocityResidual ();
+
+          /**
+           * Evaluate the velocity residual for the current cell.
+           *
+           * @copydoc DataPostprocessorVector<dim>::evaluate_vector_field()
+           */
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * Let the postprocessor manager know about the other postprocessors
+           * this one depends on. Specifically, the boundary velocity residual statistics postprocessor.
+           */
+          std::list<std::string>
+          required_other_postprocessors() const override;
+
+          std::string
+          get_physical_units () const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/compositional_vector.h.bak b/include/aspect/postprocess/visualization/compositional_vector.h.bak
new file mode 100644
index 00000000000..6b04b35cec7
--- /dev/null
+++ b/include/aspect/postprocess/visualization/compositional_vector.h.bak
@@ -0,0 +1,86 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_compositional_vector_h
+#define _aspect_postprocess_visualization_compositional_vector_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that can output sets of dim
+       * compositional fields as vectors.
+       */
+      template <int dim>
+      class CompositionalVector
+        : public DataPostprocessor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          CompositionalVector ();
+
+          std::vector<std::string>
+          get_names () const override;
+
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Names of vector fields.
+           */
+          std::vector<std::string> vector_names;
+
+          /**
+           * Stores sets of compositional field indices to
+           * be visualized together as vector fields.
+           */
+          std::vector<std::vector<unsigned int>> sets;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/depth.h.bak b/include/aspect/postprocess/visualization/depth.h.bak
new file mode 100644
index 00000000000..46ad19f5d2a
--- /dev/null
+++ b/include/aspect/postprocess/visualization/depth.h.bak
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_depth_h
+#define _aspect_postprocess_visualization_depth_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that outputs the depth
+       * according to the geometry model.
+       */
+      template <int dim>
+      class Depth
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          Depth ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/dynamic_topography.h.bak b/include/aspect/postprocess/visualization/dynamic_topography.h.bak
new file mode 100644
index 00000000000..be84ab848b3
--- /dev/null
+++ b/include/aspect/postprocess/visualization/dynamic_topography.h.bak
@@ -0,0 +1,75 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_dynamic_topography_h
+#define _aspect_postprocess_visualization_dynamic_topography_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessorScalar that computes a
+       * variable that represents the dynamic topography. This
+       * quantity, strictly speaking, only makes sense at the surface
+       * of the domain.  Thus, the value is set to zero in all the
+       * cells inside of the domain. Consider using the
+       * SurfaceDynamicTopography to only output the dynamic
+       * topography at the boundary of the domain.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class DynamicTopography
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          DynamicTopography();
+
+          /**
+           * Evaluate the dynamic topography for the current cell.
+           *
+           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
+           */
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * Register the other postprocessor that we need: DynamicTopography
+           */
+          std::list<std::string>
+          required_other_postprocessors() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/error_indicator.h.bak b/include/aspect/postprocess/visualization/error_indicator.h.bak
new file mode 100644
index 00000000000..a649ba071b3
--- /dev/null
+++ b/include/aspect/postprocess/visualization/error_indicator.h.bak
@@ -0,0 +1,59 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_error_indicator_h
+#define _aspect_postprocess_visualization_error_indicator_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived that implements a function that provides the computed
+       * mesh refinement/error indicators for graphical output.
+       */
+      template <int dim>
+      class ErrorIndicator : public CellDataVectorCreator<dim>,
+        public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ErrorIndicator();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/geoid.h.bak b/include/aspect/postprocess/visualization/geoid.h.bak
new file mode 100644
index 00000000000..8bde86ac743
--- /dev/null
+++ b/include/aspect/postprocess/visualization/geoid.h.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_geoid_h
+#define _aspect_postprocess_visualization_geoid_h
+
+#include <aspect/simulator_access.h>
+#include <aspect/postprocess/visualization.h>
+#include <aspect/postprocess/geoid.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessorScalar that computes a variable
+       * that represents the geoid topography. This quantity, strictly
+       * speaking, only makes sense at the surface of the domain. Thus, the
+       * value is set to zero in all the cells inside of the domain.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class Geoid
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          Geoid();
+
+          /**
+           * Initialization function. This function is called once at the
+           * beginning of the program after parse_parameters is run and after
+           * the SimulatorAccess (if applicable) is initialized.
+           */
+          void
+          initialize () override;
+
+          /**
+           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
+           */
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+
+          /**
+           * Let the postprocessor manager know about the other postprocessors
+           * this one depends on. Specifically, the Geoid postprocessor.
+           */
+          std::list<std::string>
+          required_other_postprocessors() const override;
+
+        private:
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/grain_lag_angle.h.bak b/include/aspect/postprocess/visualization/grain_lag_angle.h.bak
new file mode 100644
index 00000000000..8d5d5eb2204
--- /dev/null
+++ b/include/aspect/postprocess/visualization/grain_lag_angle.h.bak
@@ -0,0 +1,79 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_grain_lag_angle_h
+#define _aspect_postprocess_visualization_grain_lag_angle_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+
+      /**
+       * This postprocessor calculates and outputs the angle between the ~infinite
+       * strain axis and the velocity. Kaminski & Ribe (2002, Gcubed) call this quantity
+       * $\Theta$ and define it as
+       * $\Theta = \cos^{-1}(\hat{u}\cdot\hat{e})$
+       * where $\hat{u}=\vec{u}/|{u}|$, $\vec{u}$ is the local flow velocity, and
+       * $\hat{e}$ is the local infinite strain axis, which we calculate as the
+       * first eigenvector of the "left stretch" tensor.
+       * $\Theta$ can be used to calculate the grain orientation lag parameter (GOL).
+       * Calculating GOL also requires the ISA rotation timescale ($\tau_{ISA}$).
+       * GOL is not calculated within ASPECT
+       * right now because it is proportional to the spatial gradient of $\Theta$, but in the
+       * future that calculation could be implemented in a material model with CopyOutputs
+       * (once they exist). By tracking $\Theta$ as a CopyOutput (ie, a compositional field
+       * holding a calculated value that gets copied over instead of solved for), the spatial
+       * gradient of $\Theta$ could be calculated for the previous timestep by obtaining the
+       * old solution for the input material model. That gradient, and also the time derivative
+       * of $\Theta$, could then be used to calculate GOL at the previous timestep; $\Theta$ could
+       * be updated at the current timestep; and both quantities could be stored in CopyOutputs
+       * to step forward in time. Basically, the calculation of GOL would have to lag one
+       * timestep behind the other quantities in order to get the gradients, but we're
+       * often interested in GOL in a steady-state flow anyway.
+       */
+      template <int dim>
+      class GrainLagAngle: public CellDataVectorCreator<dim>, public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          GrainLagAngle();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute() const override;
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/gravity.h.bak b/include/aspect/postprocess/visualization/gravity.h.bak
new file mode 100644
index 00000000000..c58fb4ac5ff
--- /dev/null
+++ b/include/aspect/postprocess/visualization/gravity.h.bak
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_gravity_h
+#define _aspect_postprocess_visualization_gravity_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessorVector that outputs the gravity
+       * as a vector field.
+       */
+      template <int dim>
+      class Gravity
+        : public DataPostprocessorVector<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          Gravity ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/heat_flux_map.h.bak b/include/aspect/postprocess/visualization/heat_flux_map.h.bak
new file mode 100644
index 00000000000..8797826b787
--- /dev/null
+++ b/include/aspect/postprocess/visualization/heat_flux_map.h.bak
@@ -0,0 +1,105 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_heat_flux_map_h
+#define _aspect_postprocess_visualization_heat_flux_map_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A postprocessor that computes the heat flux density through the top and bottom boundaries.
+       *
+       * @ingroup Postprocessing
+       */
+      template <int dim>
+      class HeatFluxMap
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          HeatFluxMap();
+
+          /**
+           * Fill the temporary storage variables with the
+           * heat flux for the current time step.
+           *
+           * @copydoc Interface<dim>::update()
+           */
+          void update() override;
+
+          /**
+           * Compute the heat flux for the given input cell.
+           *
+           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
+           */
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * @copydoc Interface<dim>::declare_parameters()
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * @copydoc Interface<dim>::parse_parameters()
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * A flag that determines whether to use the point-wise
+           * heat flux calculation or the cell-wise averaged calculation.
+           */
+          bool output_point_wise_heat_flux;
+
+          /**
+           * A temporary storage place for the point-wise heat flux
+           * solution. Only initialized and used if output_point_wise_heat_flux
+           * is set to true.
+           */
+          LinearAlgebra::BlockVector heat_flux_density_solution;
+
+          /**
+           * A temporary storage place for the cell-wise heat flux
+           * solution. Only initialized and used if output_point_wise_heat_flux
+           * is set to false.
+           */
+          std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area;
+      };
+    }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/postprocess/visualization/heating.h.bak b/include/aspect/postprocess/visualization/heating.h.bak
new file mode 100644
index 00000000000..ca4e2550253
--- /dev/null
+++ b/include/aspect/postprocess/visualization/heating.h.bak
@@ -0,0 +1,74 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_heating_h
+#define _aspect_postprocess_visualization_heating_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes several scalar variables that represent the heating
+       * model outputs for every point. The list of written variables
+       * corresponds to the heating models that are used in the computation
+       * as specified in the 'Heating model' subsection in the input file.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class Heating
+        : public DataPostprocessor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          Heating ();
+
+          std::vector<std::string>
+          get_names () const override;
+
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/kxrcf_indicator.h.bak b/include/aspect/postprocess/visualization/kxrcf_indicator.h.bak
new file mode 100644
index 00000000000..bcd4022612d
--- /dev/null
+++ b/include/aspect/postprocess/visualization/kxrcf_indicator.h.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_kxrcf_indicator_h
+#define _aspect_postprocess_visualization_kxrcf_indicator_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived that implements a function that provides the
+       * KXRCF indicator for a given advection field on each cell for
+       * graphical output.
+       */
+      template <int dim>
+      class KXRCFIndicator : public CellDataVectorCreator<dim>,
+        public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          KXRCFIndicator();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * A parameter that tells us for which advection field the
+           * KXRCF indicator should be visualized.
+           */
+          unsigned int field_index;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/material_properties.h.bak b/include/aspect/postprocess/visualization/material_properties.h.bak
new file mode 100644
index 00000000000..5d1f91159a8
--- /dev/null
+++ b/include/aspect/postprocess/visualization/material_properties.h.bak
@@ -0,0 +1,92 @@
+/*
+  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_material_properties_h
+#define _aspect_postprocess_visualization_material_properties_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes several scalar variables that represent the material
+       * model outputs for every point. The list of written variables can be
+       * chosen as input parameter. The principal functionality of this class
+       * is already implemented in some other visualization plugins, the
+       * purpose of this plugin is to efficiently compute all the wanted
+       * parameters in one call to the material model.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class MaterialProperties
+        : public DataPostprocessor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          MaterialProperties ();
+
+          std::vector<std::string>
+          get_names () const override;
+
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          std::vector<std::string> property_names;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h.bak b/include/aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h.bak
new file mode 100644
index 00000000000..2d178f54af6
--- /dev/null
+++ b/include/aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h.bak
@@ -0,0 +1,92 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_maximum_horizontal_compressive_stress_h
+#define _aspect_postprocess_visualization_maximum_horizontal_compressive_stress_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class that computes a field of horizontal vectors that
+       * represent the direction of maximal horizontal compressive
+       * stress. For an exact definition, see the documentation of
+       * this plugin in the manual.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class MaximumHorizontalCompressiveStress
+        : public DataPostprocessor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          MaximumHorizontalCompressiveStress();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * Return the vector of strings describing the names of the computed
+           * quantities. Given the purpose of this class, this is a vector
+           * with entries all equal to the name of the plugin.
+           */
+          std::vector<std::string> get_names () const override;
+
+          /**
+           * This functions returns information about how the individual
+           * components of output files that consist of more than one data set
+           * are to be interpreted. The returned value is
+           * DataComponentInterpretation::component_is_scalar repeated
+           * SymmetricTensor::n_independent_components times. (These
+           * components should really be part of a symmetric tensor, but
+           * deal.II does not allow marking components as such.)
+           */
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+          /**
+           * Return which data has to be provided to compute the derived
+           * quantities. The flags returned here are the ones passed to the
+           * constructor of this class.
+           */
+          UpdateFlags get_needed_update_flags () const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/melt.h.bak b/include/aspect/postprocess/visualization/melt.h.bak
new file mode 100644
index 00000000000..e44f1537923
--- /dev/null
+++ b/include/aspect/postprocess/visualization/melt.h.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_melt_h
+#define _aspect_postprocess_visualization_melt_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_out.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that outputs melt related
+       * properties of the material model.
+       */
+      template <int dim>
+      class MeltMaterialProperties
+        : public DataPostprocessor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          MeltMaterialProperties ();
+
+          std::vector<std::string>
+          get_names () const override;
+
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const  override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          std::vector<std::string> property_names;
+      };
+
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/melt_fraction.h.bak b/include/aspect/postprocess/visualization/melt_fraction.h.bak
new file mode 100644
index 00000000000..8dd561cea61
--- /dev/null
+++ b/include/aspect/postprocess/visualization/melt_fraction.h.bak
@@ -0,0 +1,116 @@
+/*
+  Copyright (C) 2013 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_melt_fraction_h
+#define _aspect_postprocess_visualization_melt_fraction_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the melt fraction at every
+       * point.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class MeltFraction
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          MeltFraction ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Parameters for anhydrous melting of peridotite after Katz, 2003
+           */
+
+          // for the solidus temperature
+          double A1;   // °C
+          double A2; // °C/Pa
+          double A3; // °C/(Pa^2)
+
+          // for the lherzolite liquidus temperature
+          double B1;   // °C
+          double B2;   // °C/Pa
+          double B3; // °C/(Pa^2)
+
+          // for the liquidus temperature
+          double C1;   // °C
+          double C2;  // °C/Pa
+          double C3; // °C/(Pa^2)
+
+          // for the reaction coefficient of pyroxene
+          double r1;     // cpx/melt
+          double r2;     // cpx/melt/GPa
+          double M_cpx;  // mass fraction of pyroxenite
+
+          // melt fraction exponent
+          double beta;
+
+          /**
+           * Parameters for melting of pyroxenite after Sobolev et al., 2011
+           */
+
+          // for the melting temperature
+          double D1;    // °C
+          double D2;  // °C/Pa
+          double D3; // °C/(Pa^2)
+
+          // for the melt-fraction dependence of productivity
+          double E1;
+          double E2;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/named_additional_outputs.h.bak b/include/aspect/postprocess/visualization/named_additional_outputs.h.bak
new file mode 100644
index 00000000000..dcfb5f08681
--- /dev/null
+++ b/include/aspect/postprocess/visualization/named_additional_outputs.h.bak
@@ -0,0 +1,79 @@
+/*
+  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_named_additional_outputs_h
+#define _aspect_postprocess_visualization_named_additional_outputs_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that generates visualization
+       * output for all additional material outputs that are derived
+       * from the 'NamedAdditionalMaterialOutputs' base class if the are
+       * filled in the evaluate function of the material model used in the
+       * computation.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class NamedAdditionalOutputs
+        : public DataPostprocessor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          NamedAdditionalOutputs ();
+
+          void
+          initialize () override;
+
+          std::vector<std::string>
+          get_names () const override;
+
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+        private:
+          std::vector<std::string> property_names;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/nonadiabatic_pressure.h.bak b/include/aspect/postprocess/visualization/nonadiabatic_pressure.h.bak
new file mode 100644
index 00000000000..c9d282fc51c
--- /dev/null
+++ b/include/aspect/postprocess/visualization/nonadiabatic_pressure.h.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_nonadiabatic_pressure_h
+#define _aspect_postprocess_visualization_nonadiabatic_pressure_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the non-adiabatic part of the
+       * pressure every point.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class NonadiabaticPressure
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          NonadiabaticPressure ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/nonadiabatic_temperature.h.bak b/include/aspect/postprocess/visualization/nonadiabatic_temperature.h.bak
new file mode 100644
index 00000000000..b71d32a5727
--- /dev/null
+++ b/include/aspect/postprocess/visualization/nonadiabatic_temperature.h.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_nonadiabatic_temperature_h
+#define _aspect_postprocess_visualization_nonadiabatic_temperature_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the non-adiabatic part of the
+       * temperature at every point.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class NonadiabaticTemperature
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          NonadiabaticTemperature ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/particle_count.h.bak b/include/aspect/postprocess/visualization/particle_count.h.bak
new file mode 100644
index 00000000000..a64a5ae8baf
--- /dev/null
+++ b/include/aspect/postprocess/visualization/particle_count.h.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_particle_count_h
+#define _aspect_postprocess_visualization_particle_count_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from CellDataVectorCreator that takes an output
+       * vector and computes a variable that represents the number of particles
+       * in each cell.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class ParticleCount
+        : public CellDataVectorCreator<dim>,
+          public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ParticleCount();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const override;
+
+          /**
+           * Let the postprocessor manager know about the other postprocessors
+           * this one depends on. Specifically, the particles postprocessor.
+           */
+          std::list<std::string>
+          required_other_postprocessors() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/partition.h.bak b/include/aspect/postprocess/visualization/partition.h.bak
new file mode 100644
index 00000000000..30527e66be5
--- /dev/null
+++ b/include/aspect/postprocess/visualization/partition.h.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_partition_h
+#define _aspect_postprocess_visualization_partition_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes puts the number of
+       * the parallel process (i.e., the partition number) for each cell into
+       * the output file.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class Partition
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          Partition ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/principal_stress.h.bak b/include/aspect/postprocess/visualization/principal_stress.h.bak
new file mode 100644
index 00000000000..5e2c24a5b21
--- /dev/null
+++ b/include/aspect/postprocess/visualization/principal_stress.h.bak
@@ -0,0 +1,82 @@
+/*
+  Copyright (C) 2020 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_principal_stress_h
+#define _aspect_postprocess_visualization_principal_stress_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that outputs the principal
+       * stress values and directions, i.e., the eigenvalues and eigenvectors
+       * of the stress tensor (or optionally of the deviatoric stress tensor).
+       */
+      template <int dim>
+      class PrincipalStress
+        : public DataPostprocessor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          PrincipalStress ();
+
+          std::vector<std::string>
+          get_names () const override;
+
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Whether to use the deviatoric stress tensor instead of the full stress
+           * tensor to compute principal directions and values.
+           */
+          bool use_deviatoric_stress;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/seismic_anomalies.h.bak b/include/aspect/postprocess/visualization/seismic_anomalies.h.bak
new file mode 100644
index 00000000000..ac482026cb5
--- /dev/null
+++ b/include/aspect/postprocess/visualization/seismic_anomalies.h.bak
@@ -0,0 +1,156 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_seismic_anomalies_h
+#define _aspect_postprocess_visualization_seismic_anomalies_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived that implements a function that provides the computed
+       * computed seismic anomaly in $V_s$ for graphical output.
+       */
+      template <int dim>
+      class SeismicVsAnomaly
+        :
+        public CellDataVectorCreator<dim>,
+        public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          SeismicVsAnomaly();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+
+          /**
+           * Scheme chosen to define the average seismic velocity as a
+           * function of depth. Reference profile evaluates the material model
+           * using the P-T profile defined by the reference adiabatic
+           * conditions and the lateral average option calculates the average
+           * velocity within a number n_slices of depth slices.
+           */
+          enum VelocityScheme
+          {
+            reference_profile,
+            lateral_average
+          } average_velocity_scheme;
+
+          /**
+           * Number of depth slices used to define average
+           * seismic shear wave velocities from which anomalies
+           * are calculated.
+           */
+          unsigned int n_slices;
+      };
+
+
+
+      /**
+       * A class derived that implements a function that provides the computed
+       * computed seismic anomaly in $V_p$ for graphical output.
+       */
+      template <int dim>
+      class SeismicVpAnomaly
+        :
+        public CellDataVectorCreator<dim>,
+        public SimulatorAccess<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          SeismicVpAnomaly();
+
+          /**
+           * @copydoc CellDataVectorCreator<dim>::execute()
+           */
+          std::pair<std::string, std::unique_ptr<Vector<float>>>
+          execute () const override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+
+          /**
+           * Scheme chosen to define the average seismic velocity as a
+           * function of depth. Reference profile evaluates the material model
+           * using the P-T profile defined by the reference adiabatic
+           * conditions and the lateral average option calculates the average
+           * velocity within a number n_slices of depth slices.
+           */
+          enum VelocityScheme
+          {
+            reference_profile,
+            lateral_average
+          } average_velocity_scheme;
+
+          /**
+           * Number of depth slices used to define average
+           * seismic compressional wave velocities from which anomalies
+           * are calculated.
+           */
+          unsigned int n_slices;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/shear_stress.h.bak b/include/aspect/postprocess/visualization/shear_stress.h.bak
new file mode 100644
index 00000000000..460ba60ade4
--- /dev/null
+++ b/include/aspect/postprocess/visualization/shear_stress.h.bak
@@ -0,0 +1,72 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_shear_stress_h
+#define _aspect_postprocess_visualization_shear_stress_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the 3 or 6 independent
+       * components (in 2d and 3d, respectively) of the shear stress tensor at
+       * every point. The shear stress is defined as $2 \eta
+       * (\varepsilon(\mathbf u) - \tfrac 13 \textrm{trace}\
+       * \varepsilon(\mathbf u) \mathbf 1) = 2\eta (\varepsilon(\mathbf u) -
+       * \frac 13 (\nabla \cdot \mathbf u) \mathbf I)$ and differs from the
+       * full stress by the absence of the pressure.  The second term in the
+       * difference is zero if the model is incompressible.
+       * If elasticity is used, the elastic contribution is being accounted for.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class ShearStress
+        : public DataPostprocessorTensor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          ShearStress ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/spd_factor.h.bak b/include/aspect/postprocess/visualization/spd_factor.h.bak
new file mode 100644
index 00000000000..a001d55120c
--- /dev/null
+++ b/include/aspect/postprocess/visualization/spd_factor.h.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2017 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_spd_factor_h
+#define _aspect_postprocess_visualization_spd_factor_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the spd factor at every point.
+       * The spd factor is a factor which scales a part of the Jacobian used
+       * for the Newton solver to make sure that the Jacobian remains positive
+       * definite.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class SPD_Factor
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          SPD_Factor ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/spherical_velocity_components.h.bak b/include/aspect/postprocess/visualization/spherical_velocity_components.h.bak
new file mode 100644
index 00000000000..e3d0749157d
--- /dev/null
+++ b/include/aspect/postprocess/visualization/spherical_velocity_components.h.bak
@@ -0,0 +1,76 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_spherical_velocity_components_h
+#define _aspect_postprocess_visualization_spherical_velocity_components_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      class SphericalVelocityComponents
+        : public DataPostprocessorVector<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          SphericalVelocityComponents ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * Return the vector of strings describing the names of the computed
+           * quantities. Given the purpose of this class, this is a vector
+           * with entries all equal to the name of the plugin.
+           */
+          std::vector<std::string> get_names () const override;
+
+          /**
+           * This functions returns information about how the individual
+           * components of output files that consist of more than one data set
+           * are to be interpreted. The returned value is
+           * DataComponentInterpretation::component_is_scalar repeated
+           * SymmetricTensor::n_independent_components times. (These
+           * components should really be part of a symmetric tensor, but
+           * deal.II does not allow marking components as such.)
+           */
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+          std::string
+          get_physical_units () const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/strain_rate.h.bak b/include/aspect/postprocess/visualization/strain_rate.h.bak
new file mode 100644
index 00000000000..72668cb4228
--- /dev/null
+++ b/include/aspect/postprocess/visualization/strain_rate.h.bak
@@ -0,0 +1,67 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_strain_rate_h
+#define _aspect_postprocess_visualization_strain_rate_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the strain rate at every
+       * point. The scalar strain rate is defined as $\sqrt{ (\varepsilon -
+       * \tfrac 13 \textrm{trace}\ \varepsilon \mathbf 1) : \varepsilon -
+       * \tfrac 13 \textrm{trace}\ \varepsilon \mathbf 1}$.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class StrainRate
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          StrainRate ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/strain_rate_tensor.h.bak b/include/aspect/postprocess/visualization/strain_rate_tensor.h.bak
new file mode 100644
index 00000000000..bdfed78dd4c
--- /dev/null
+++ b/include/aspect/postprocess/visualization/strain_rate_tensor.h.bak
@@ -0,0 +1,65 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_strain_rate_tensor_h
+#define _aspect_postprocess_visualization_strain_rate_tensor_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the 4 or 9
+       * components (in 2d and 3d, respectively) of the strain rate tensor at every
+       * point.
+       * The strain rate is defined as $\varepsilon(\mathbf u)$ in the incompressible
+       * case and as $\varepsilon(\mathbf u)
+       * - \tfrac 13 (\textrm{trace}\ \varepsilon(\mathbf u)) \mathbf I$
+       * in the compressible case.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class StrainRateTensor
+        : public DataPostprocessorTensor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          StrainRateTensor ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+#endif
diff --git a/include/aspect/postprocess/visualization/stress.h.bak b/include/aspect/postprocess/visualization/stress.h.bak
new file mode 100644
index 00000000000..ae4ea386b81
--- /dev/null
+++ b/include/aspect/postprocess/visualization/stress.h.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_stress_h
+#define _aspect_postprocess_visualization_stress_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the 3 or 6 independent
+       * components (in 2d and 3d, respectively) of the stress tensor at every
+       * point. The stress is defined as $2 \eta (\varepsilon(\mathbf u)
+       * - \tfrac 13 \textrm{trace}\ \varepsilon(\mathbf u) \mathbf 1) +pI =
+       * 2\eta (\varepsilon(\mathbf u) - \frac 13 (\nabla \cdot \mathbf u)
+       * \mathbf I) + pI$.  The second term in the parentheses is zero if the
+       * model is incompressible.
+       * If elasticity is used, the elastic contribution is being accounted for.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class Stress
+        : public DataPostprocessorTensor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          Stress ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/stress_second_invariant.h.bak b/include/aspect/postprocess/visualization/stress_second_invariant.h.bak
new file mode 100644
index 00000000000..458e7f4b1e2
--- /dev/null
+++ b/include/aspect/postprocess/visualization/stress_second_invariant.h.bak
@@ -0,0 +1,67 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_postprocess_visualization_stress_second_invariant_h
+#define _aspect_postprocess_visualization_stress_second_invariant_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the second moment invariant
+       * of the deviatoric stress.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class StressSecondInvariant
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          StressSecondInvariant ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/surface_dynamic_topography.h.bak b/include/aspect/postprocess/visualization/surface_dynamic_topography.h.bak
new file mode 100644
index 00000000000..eca7bd7e1bc
--- /dev/null
+++ b/include/aspect/postprocess/visualization/surface_dynamic_topography.h.bak
@@ -0,0 +1,72 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_surface_dynamic_topography_h
+#define _aspect_postprocess_visualization_surface_dynamic_topography_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessorScalar that computes a
+       * variable that represents the dynamic topography, and outputs
+       * it on all boundary faces.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class SurfaceDynamicTopography
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>,
+          public SurfaceOnlyVisualization<dim>
+      {
+        public:
+          SurfaceDynamicTopography();
+
+          /**
+           * Evaluate the dynamic topography for the current cell.
+           *
+           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
+           */
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * Register the other postprocessor that we need: DynamicTopography
+           */
+          std::list<std::string>
+          required_other_postprocessors() const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/surface_elevation.h.bak b/include/aspect/postprocess/visualization/surface_elevation.h.bak
new file mode 100644
index 00000000000..db80cca4cd2
--- /dev/null
+++ b/include/aspect/postprocess/visualization/surface_elevation.h.bak
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_surface_elevation_h
+#define _aspect_postprocess_visualization_surface_elevation_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessorScalar that computes a
+       * variable that represents the elevation of points on the ``top''
+       * surface relative to the geometry's undeformed state, and outputs
+       * it on boundary faces. On boundary faces not marked as ``top'',
+       * this class outputs a zero elevation.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class SurfaceElevation
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>,
+          public SurfaceOnlyVisualization<dim>
+      {
+        public:
+          SurfaceElevation();
+
+          /**
+           * Evaluate the dynamic topography for the current cell.
+           *
+           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
+           */
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/surface_strain_rate_tensor.h.bak b/include/aspect/postprocess/visualization/surface_strain_rate_tensor.h.bak
new file mode 100644
index 00000000000..15e5dfbd5c2
--- /dev/null
+++ b/include/aspect/postprocess/visualization/surface_strain_rate_tensor.h.bak
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_surface_strain_rate_tensor_h
+#define _aspect_postprocess_visualization_surface_strain_rate_tensor_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the 4 or 9
+       * components (in 2d and 3d, respectively) of the strain rate tensor at every
+       * point of the surface of the domain.
+       * The strain rate is defined as $\varepsilon(\mathbf u)$ in the incompressible
+       * case and as $\varepsilon(\mathbf u)
+       * - \tfrac 13 (\textrm{trace}\ \varepsilon(\mathbf u)) \mathbf I$
+       * in the compressible case.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class SurfaceStrainRateTensor
+        : public DataPostprocessorTensor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>,
+          public SurfaceOnlyVisualization<dim>
+      {
+        public:
+          SurfaceStrainRateTensor ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/surface_stress.h.bak b/include/aspect/postprocess/visualization/surface_stress.h.bak
new file mode 100644
index 00000000000..878c01d9351
--- /dev/null
+++ b/include/aspect/postprocess/visualization/surface_stress.h.bak
@@ -0,0 +1,73 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_surface_stress_h
+#define _aspect_postprocess_visualization_surface_stress_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the 3 or 6 independent
+       * components (in 2d and 3d, respectively) of the stress tensor at every
+       * point of the surface of the domain.
+       * The stress is defined as $2 \eta (\varepsilon(\mathbf u)
+       * - \tfrac 13 \textrm{trace}\ \varepsilon(\mathbf u) \mathbf 1) +pI =
+       * 2\eta (\varepsilon(\mathbf u) - \frac 13 (\nabla \cdot \mathbf u)
+       * \mathbf I) + pI$.  The second term in the parentheses is zero if the
+       * model is incompressible. If elasticity is used, its contribution
+       * is accounted for.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class SurfaceStress
+        : public DataPostprocessorTensor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>,
+          public SurfaceOnlyVisualization<dim>
+      {
+        public:
+          /**
+           * Constructor.
+           */
+          SurfaceStress ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/temperature_anomaly.h.bak b/include/aspect/postprocess/visualization/temperature_anomaly.h.bak
new file mode 100644
index 00000000000..bc00e09d94f
--- /dev/null
+++ b/include/aspect/postprocess/visualization/temperature_anomaly.h.bak
@@ -0,0 +1,93 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_temperature_anomaly_h
+#define _aspect_postprocess_visualization_temperature_anomaly_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that outputs the temperature
+       * anomaly (temperature-depth average of temperature).
+       */
+      template <int dim>
+      class TemperatureAnomaly
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          TemperatureAnomaly ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          void
+          update () override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Number of slices to use when computing depth average of temperature.
+           */
+          unsigned int n_slices;
+          /**
+           * Vector of temperature depth average values, padded to include two ghost values
+           * above and below the surface and bottom of the domain to allow interpolation at
+           * all depths.
+           */
+          std::vector<double> padded_temperature_depth_average;
+          /**
+           * Whether to extrapolate temperatures above/below the first/last depth-average slice
+           * or, alternatively, interpolate above the center of the first slice using the surface
+           * temperature or below the last slice using the bottom temperature.
+           */
+          bool extrapolate_surface;
+          bool extrapolate_bottom;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/vertical_heat_flux.h.bak b/include/aspect/postprocess/visualization/vertical_heat_flux.h.bak
new file mode 100644
index 00000000000..d1c00c694db
--- /dev/null
+++ b/include/aspect/postprocess/visualization/vertical_heat_flux.h.bak
@@ -0,0 +1,67 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_vertical_heat_flux_h
+#define _aspect_postprocess_visualization_vertical_heat_flux_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/numerics/data_postprocessor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the density at every point.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class VerticalHeatFlux
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          /**
+           * Constructor
+           */
+          VerticalHeatFlux ();
+
+          /**
+           * Evaluate the vertical heat flux for the current cell.
+           */
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/volume_of_fluid_values.h.bak b/include/aspect/postprocess/visualization/volume_of_fluid_values.h.bak
new file mode 100644
index 00000000000..bd9225431a5
--- /dev/null
+++ b/include/aspect/postprocess/visualization/volume_of_fluid_values.h.bak
@@ -0,0 +1,116 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_visualization_volume_of_fluid_values_h
+#define _aspect_postprocess_visualization_volume_of_fluid_values_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * Plugin to output volume fractions and reconstructed interface data
+       * from the Volume of Fluid Interface Tracking data.
+       */
+      template <int dim>
+      class VolumeOfFluidValues
+        : public DataPostprocessor<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          /**
+           * Standard constructor
+           */
+          VolumeOfFluidValues ();
+
+          /**
+           * Get the list of names for the components that will be produced by
+           * this postprocessor
+           */
+          std::vector<std::string>
+          get_names () const override;
+
+          /**
+           * Get the list of component interpretations for the components that
+           * will be produced by this postprocessor
+           */
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override;
+
+          /**
+           * Get required update flags
+           */
+          UpdateFlags
+          get_needed_update_flags () const override;
+
+          /**
+           * Produce that data based on provided solution data
+           */
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+
+          /**
+           * Declare the parameters this class takes through input files.
+           */
+          static
+          void
+          declare_parameters (ParameterHandler &prm);
+
+          /**
+           * Read the parameters this class declares from the parameter file.
+           */
+          void
+          parse_parameters (ParameterHandler &prm) override;
+
+        private:
+          /**
+           * Stored list of names for the produced components
+           */
+          std::vector<std::string> volume_of_fluid_names;
+
+          /**
+           * Stored list of interpretations for produced components
+           */
+          std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretations;
+
+          /**
+           * If true, the data output will include a field that has the
+           * reconstructed fluid interface as the zero contour
+           */
+          bool include_contour;
+
+          /**
+           * If true, the data output will include the normal vector for the reconstructed interface
+           */
+          bool include_normal;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/visualization/volumetric_strain_rate.h.bak b/include/aspect/postprocess/visualization/volumetric_strain_rate.h.bak
new file mode 100644
index 00000000000..4ceafefbd76
--- /dev/null
+++ b/include/aspect/postprocess/visualization/volumetric_strain_rate.h.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2017 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_volumetric_strain_rate_h
+#define _aspect_postprocess_volumetric_strain_rate_h
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      /**
+       * A class derived from DataPostprocessor that takes an output vector
+       * and computes a variable that represents the volumetric strain rate at every
+       * point. The volumetric strain rate is defined as the divergence of the velocity
+       * (or the trace of the strain rate tensor):
+       * $\nabla\cdot\mathbf u = \textrm{div}\; \mathbf u = \textrm{trace}\; \varepsilon(\mathbf u)$.
+       *
+       * The member functions are all implementations of those declared in the
+       * base class. See there for their meaning.
+       */
+      template <int dim>
+      class VolumetricStrainRate
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          VolumetricStrainRate ();
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override;
+      };
+    }
+  }
+}
+
+#endif
diff --git a/include/aspect/postprocess/volume_of_fluid_statistics.h.bak b/include/aspect/postprocess/volume_of_fluid_statistics.h.bak
new file mode 100644
index 00000000000..d7c04b867ff
--- /dev/null
+++ b/include/aspect/postprocess/volume_of_fluid_statistics.h.bak
@@ -0,0 +1,53 @@
+
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_postprocess_volume_of_fluid_statistics_h
+#define _aspect_postprocess_volume_of_fluid_statistics_h
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    /**
+     * A postprocessor that computes some statistics about the volume of fluid fields
+     *
+     * @ingroup Postprocessing
+     */
+    template <int dim>
+    class VolumeOfFluidStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate the solution for some velocity statistics.
+         */
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/prescribed_stokes_solution/ascii_data.h.bak b/include/aspect/prescribed_stokes_solution/ascii_data.h.bak
new file mode 100644
index 00000000000..c8311aa71be
--- /dev/null
+++ b/include/aspect/prescribed_stokes_solution/ascii_data.h.bak
@@ -0,0 +1,85 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_prescribed_stokes_solution_ascii_data_h
+#define _aspect_prescribed_stokes_solution_ascii_data_h
+
+#include <aspect/prescribed_stokes_solution/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a prescribed velocity field determined from
+     * a AsciiData input file.
+     *
+     * @ingroup PrescribedStokesSolution
+     */
+    template <int dim>
+    class AsciiData : public Utilities::AsciiDataInitial<dim>, public Interface<dim>
+    {
+      public:
+        /**
+         * Empty Constructor.
+         */
+        AsciiData ();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        void
+        initialize () override;
+
+        // avoid -Woverloaded-virtual:
+        using Utilities::AsciiDataInitial<dim>::initialize;
+
+        /**
+         * For the current class, this function returns value from the text
+         * files.
+         */
+        void
+        stokes_solution (const Point<dim> &position, Vector<double> &value) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/prescribed_stokes_solution/circle.h.bak b/include/aspect/prescribed_stokes_solution/circle.h.bak
new file mode 100644
index 00000000000..5e350d14d6c
--- /dev/null
+++ b/include/aspect/prescribed_stokes_solution/circle.h.bak
@@ -0,0 +1,51 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_prescribed_stokes_solution_circle_h
+#define _aspect_prescribed_stokes_solution_circle_h
+
+#include <aspect/prescribed_stokes_solution/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a circular, divergence-free flow field
+     * around the origin of the coordinate system.
+     *
+     * @ingroup PrescribedStokesSolution
+     */
+    template <int dim>
+    class Circle : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        void stokes_solution (const Point<dim> &p, Vector<double> &value) const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/prescribed_stokes_solution/function.h.bak b/include/aspect/prescribed_stokes_solution/function.h.bak
new file mode 100644
index 00000000000..355a6eb6eea
--- /dev/null
+++ b/include/aspect/prescribed_stokes_solution/function.h.bak
@@ -0,0 +1,105 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_prescribed_stokes_solution_function_h
+#define _aspect_prescribed_stokes_solution_function_h
+
+#include <aspect/prescribed_stokes_solution/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements velocity and pressure solutions based on a
+     * functional description provided in the input file.
+     *
+     * @ingroup PrescribedStokesSolution
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Function ();
+
+        /**
+         * Return the velocity and pressure as a function of position.
+         */
+        void
+        stokes_solution (const Point<dim> &position, Vector<double> &value) const override;
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the velocity and
+         * pressure values will next be evaluated. For the current class,
+         * the function passes to the parsed function what the current time is.
+         */
+        void
+        update () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * A function object representing the components of the velocity.
+         */
+        Functions::ParsedFunction<dim> prescribed_velocity_function;
+        /**
+         * A function object representing the pressure.
+         */
+        Functions::ParsedFunction<dim> prescribed_pressure_function;
+        /**
+         * A function object representing the fluid pressure (in models with melt transport).
+         */
+        Functions::ParsedFunction<dim> prescribed_fluid_pressure_function;
+        /**
+         * A function object representing the compaction pressure (in models with melt transport).
+         */
+        Functions::ParsedFunction<dim> prescribed_compaction_pressure_function;
+        /**
+         * A function object representing the components of the fluid velocity (in models with melt transport).
+         */
+        Functions::ParsedFunction<dim> prescribed_fluid_velocity_function;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/prescribed_stokes_solution/interface.h.bak b/include/aspect/prescribed_stokes_solution/interface.h.bak
new file mode 100644
index 00000000000..6d4f41421fa
--- /dev/null
+++ b/include/aspect/prescribed_stokes_solution/interface.h.bak
@@ -0,0 +1,159 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef _aspect_prescribed_stokes_solution_interface_h
+#define _aspect_prescribed_stokes_solution_interface_h
+
+#include <aspect/plugins.h>
+
+#include <deal.II/base/point.h>
+#include <deal.II/base/parameter_handler.h>
+
+#include <deal.II/base/function.h>
+
+namespace aspect
+{
+  /**
+   * A namespace in which we define everything that has to do with defining
+   * the prescribed Stokes solution.
+   *
+   * @ingroup PrescribedStokesSolution
+   */
+  namespace PrescribedStokesSolution
+  {
+    using namespace dealii;
+
+    /**
+     * This plugin allows the user to prescribe a Stokes solution and can be
+     * thought of as velocity and pressure's equivalent of the initial
+     * conditions plugin.
+     *
+     * Note: This can only be used if the nonlinear solver scheme is
+     * `single Advection, no Stokes'.
+     *
+     * @ingroup PrescribedStokesSolution
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Given a position @p p, fill in desired velocity and pressure at
+         * that point into @p value, which will have dim+1 components. In @p
+         * value, the velocity components come first, followed by the pressure
+         * component.
+         */
+        virtual
+        void stokes_solution (const Point<dim> &p, Vector<double> &value) const = 0;
+    };
+
+
+
+
+    /**
+     * Register initial prescribed Stokes solution model so that it can be
+     * selected from the parameter file.
+     *
+     * @param name A string that identifies the prescribed Stokes solution
+     * model
+     * @param description A text description of what this model does and that
+     * will be listed in the documentation of the parameter file.
+     * @param declare_parameters_function A pointer to a function that can be
+     * used to declare the parameters that this prescribed Stokes solution
+     * model wants to read from input files.
+     * @param factory_function A pointer to a function that can create an
+     * object of this prescribed Stokes solution model.
+     *
+     * @ingroup PrescribedStokesSolution
+     */
+    template <int dim>
+    void
+    register_prescribed_stokes_solution_model (const std::string &name,
+                                               const std::string &description,
+                                               void (*declare_parameters_function) (ParameterHandler &),
+                                               std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+    /**
+     * A function that given the name of a model returns a pointer to an
+     * object that describes it. Ownership of the pointer is transferred to
+     * the caller.
+     *
+     * The model object returned is not yet initialized and has not read its
+     * runtime parameters yet.
+     *
+     * @ingroup PrescribedStokesSolution
+     */
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_prescribed_stokes_solution (ParameterHandler &prm);
+
+
+    /**
+     * Declare the runtime parameters of the registered prescribed Stokes
+     * solution models.
+     *
+     * @ingroup PrescribedStokesSolution
+     */
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm);
+
+
+    /**
+     * For the current plugin subsystem, write a connection graph of all of the
+     * plugins we know about, in the format that the
+     * programs dot and neato understand. This allows for a visualization of
+     * how all of the plugins that ASPECT knows about are interconnected, and
+     * connect to other parts of the ASPECT code.
+     *
+     * @param output_stream The stream to write the output to.
+     */
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &output_stream);
+
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a prescribed Stokes solution model, register it with the functions
+     * that can declare their parameters and create these objects.
+     *
+     * @ingroup PrescribedStokesSolution
+     */
+#define ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::PrescribedStokesSolution::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::PrescribedStokesSolution::register_prescribed_stokes_solution_model<2>, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::PrescribedStokesSolution::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::PrescribedStokesSolution::register_prescribed_stokes_solution_model<3>, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/simulator.h.bak b/include/aspect/simulator.h.bak
new file mode 100644
index 00000000000..0c7fbd1630f
--- /dev/null
+++ b/include/aspect/simulator.h.bak
@@ -0,0 +1,2203 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_simulator_h
+#define _aspect_simulator_h
+
+#include <deal.II/base/timer.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/conditional_ostream.h>
+#include <deal.II/base/symmetric_tensor.h>
+
+DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
+
+#include <deal.II/lac/affine_constraints.h>
+
+#include <deal.II/distributed/tria.h>
+
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/dofs/dof_tools.h>
+
+#include <deal.II/fe/fe_system.h>
+#include <deal.II/fe/mapping.h>
+#include <deal.II/base/tensor_function.h>
+
+DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+#include <aspect/lateral_averaging.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/boundary_heat_flux/interface.h>
+#include <aspect/boundary_composition/interface.h>
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/initial_composition/interface.h>
+#include <aspect/prescribed_stokes_solution/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/boundary_traction/interface.h>
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/time_stepping/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/particle/world.h>
+
+#include <boost/iostreams/tee.hpp>
+#include <boost/iostreams/stream.hpp>
+
+#include <memory>
+#include <thread>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim>
+  class MeltHandler;
+
+  template <int dim>
+  class NewtonHandler;
+
+  template <int dim>
+  class StokesMatrixFreeHandler;
+
+  template <int dim, int velocity_degree>
+  class StokesMatrixFreeHandlerImplementation;
+
+  namespace MeshDeformation
+  {
+    template <int dim>
+    class MeshDeformationHandler;
+  }
+
+  template <int dim>
+  class VolumeOfFluidHandler;
+
+  namespace internal
+  {
+    namespace Assembly
+    {
+      namespace Scratch
+      {
+        template <int dim>      struct StokesPreconditioner;
+        template <int dim>      struct StokesSystem;
+        template <int dim>      struct AdvectionSystem;
+      }
+
+      namespace CopyData
+      {
+        template <int dim>      struct StokesPreconditioner;
+        template <int dim>      struct StokesSystem;
+        template <int dim>      struct AdvectionSystem;
+      }
+    }
+  }
+
+  namespace Assemblers
+  {
+    template <int dim>      class Interface;
+    template <int dim>      class Manager;
+  }
+
+  struct DefectCorrectionResiduals
+  {
+    double initial_residual;
+    double velocity_residual;
+    double pressure_residual;
+    double residual;
+    double residual_old;
+    double switch_initial_residual;
+    double newton_residual_for_derivative_scaling_factor;
+    std::pair<double,double> stokes_residuals;
+  };
+
+  /**
+   * A data structure with all properties relevant to compute angular momentum and rotation.
+   */
+  template <int dim>
+  struct RotationProperties
+  {
+    RotationProperties()
+      :
+      scalar_moment_of_inertia(numbers::signaling_nan<double>()),
+      scalar_angular_momentum(numbers::signaling_nan<double>()),
+      scalar_rotation(numbers::signaling_nan<double>()),
+      tensor_moment_of_inertia(numbers::signaling_nan<SymmetricTensor<2,dim>>()),
+      tensor_angular_momentum(numbers::signaling_nan<Tensor<1,dim>>()),
+      tensor_rotation(numbers::signaling_nan<Tensor<1,dim>>())
+    {};
+
+    /**
+     * Scalar properties for the two-dimensional case
+     * with a fixed rotation axis (z).
+     */
+    double scalar_moment_of_inertia;
+    double scalar_angular_momentum;
+    double scalar_rotation;
+
+    /**
+     * Tensor properties for the three-dimensional case.
+     */
+    SymmetricTensor<2,dim> tensor_moment_of_inertia;
+    Tensor<1,dim> tensor_angular_momentum;
+    Tensor<1,dim> tensor_rotation;
+  };
+
+  /**
+   * This is the main class of ASPECT. It implements the overall simulation
+   * algorithm using the numerical methods discussed in the papers and manuals
+   * that accompany ASPECT.
+   *
+   * @ingroup Simulator
+   */
+  template <int dim>
+  class Simulator
+  {
+    public:
+      /**
+       * Constructor.
+       *
+       * @param mpi_communicator The MPI communicator on which this class is
+       * to work. The class creates a clone of the actual communicator to make
+       * its communications private from the rest of the world.
+       *
+       * @param prm The run-time parameter object from which this class
+       * obtains its settings.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      Simulator (const MPI_Comm mpi_communicator,
+                 ParameterHandler &prm);
+
+      /**
+       * Destructor. Destroy what needs to be destroyed after waiting for all
+       * threads that may still be doing something in the background.
+       */
+      ~Simulator ();
+
+      /**
+       * Declare the run-time parameters this class takes, and call the
+       * respective <code>declare_parameters</code> functions of the
+       * namespaces that describe geometries, material models, etc.
+       *
+       * @param prm The object in which the run-time parameters are to be
+       * declared.
+       *
+       * This function is implemented in
+       * <code>source/simulator/parameters.cc</code>.
+       */
+      static
+      void declare_parameters (ParameterHandler &prm);
+
+      /**
+       * The function that runs the overall algorithm. It contains the loop
+       * over all time steps as well as the logic of what to do when before
+       * the loop starts and within the time loop.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void run ();
+
+      /**
+       * Write a connection graph of all of the plugins we know about, in the
+       * format that the programs dot and neato understand. This allows for a
+       * visualization of how all of the plugins that ASPECT knows about are
+       * interconnected, and connect to other parts of the ASPECT code.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       *
+       * @param output_stream The stream to write the output to.
+       */
+      void
+      write_plugin_graph (std::ostream &output_stream) const;
+
+      /**
+       * Import Nonlinear Solver type.
+       */
+      using NonlinearSolver = typename Parameters<dim>::NonlinearSolver;
+
+      /**
+       * Import nullspace removal type.
+       */
+      using NullspaceRemoval = typename Parameters<dim>::NullspaceRemoval;
+
+
+      /**
+       * A structure that is used as an argument to functions that can work on
+       * both the temperature and the compositional variables and that need to
+       * be told which one of the two, as well as on which of the
+       * compositional variables.
+       */
+      struct AdvectionField
+      {
+        /**
+         * An enum indicating whether the identified variable is the
+         * temperature or one of the compositional fields.
+         */
+        enum FieldType { temperature_field, compositional_field };
+
+        /**
+         * A variable indicating whether the identified variable is the
+         * temperature or one of the compositional fields.
+         */
+        const FieldType    field_type;
+
+        /**
+         * A variable identifying which of the compositional fields is
+         * selected. This variable is meaningless if the temperature is
+         * selected.
+         */
+        const unsigned int compositional_variable;
+
+        /**
+         * Constructor.
+         * @param field_type Determines whether this variable should select
+         * the temperature field or a compositional field.
+         * @param compositional_variable The number of the compositional field
+         * if the first argument in fact chooses a compositional variable.
+         * Meaningless if the first argument equals temperature.
+         *
+         * This function is implemented in
+         * <code>source/simulator/helper_functions.cc</code>.
+         */
+        AdvectionField (const FieldType field_type,
+                        const unsigned int compositional_variable = numbers::invalid_unsigned_int);
+
+        /**
+         * A static function that creates an object identifying the
+         * temperature.
+         *
+         * This function is implemented in
+         * <code>source/simulator/helper_functions.cc</code>.
+         */
+        static
+        AdvectionField temperature ();
+
+        /**
+         * A static function that creates an object identifying given
+         * compositional field.
+         *
+         * This function is implemented in
+         * <code>source/simulator/helper_functions.cc</code>.
+         */
+        static
+        AdvectionField composition (const unsigned int compositional_variable);
+
+        /**
+         * Return whether this object refers to the temperature field.
+         */
+        bool
+        is_temperature () const;
+
+        /**
+         * Return whether this object refers to a field discretized by
+         * discontinuous finite elements.
+         */
+        bool
+        is_discontinuous (const Introspection<dim> &introspection) const;
+
+        /**
+         * Return the method that is used to solve the advection of this field
+         * (i.e. 'fem_field', 'particles').
+         */
+        typename Parameters<dim>::AdvectionFieldMethod::Kind
+        advection_method (const Introspection<dim> &introspection) const;
+
+        /**
+         * Look up the component index for this temperature or compositional
+         * field. See Introspection::component_indices for more information.
+         */
+        unsigned int component_index(const Introspection<dim> &introspection) const;
+
+        /**
+         * Look up the block index for this temperature or compositional
+         * field. See Introspection::block_indices for more information.
+         */
+        unsigned int block_index(const Introspection<dim> &introspection) const;
+
+        /**
+         * Look up the block index where the sparsity pattern for this field
+         * is stored. This can be different than block_index() as several fields
+         * can use the same pattern (typically in the first compositional field
+         * if all fields are compatible). See Introspection::block_indices
+         * for more information.
+         */
+        unsigned int sparsity_pattern_block_index(const Introspection<dim> &introspection) const;
+
+        /**
+         * Returns an index that runs from 0 (temperature field) to n (nth
+         * compositional field), and uniquely identifies the current advection
+         * field among the list of all advection fields. Can be used to index
+         * vectors that contain entries for all advection fields.
+         */
+        unsigned int field_index() const;
+
+        /**
+         * Look up the base element within the larger composite finite element
+         * we used for everything, for this temperature or compositional field
+         * See Introspection::base_elements for more information.
+         */
+        unsigned int base_element(const Introspection<dim> &introspection) const;
+
+        /**
+         * Return the FEValues scalar extractor for this temperature
+         * or compositional field.
+         * This function is implemented in
+         * <code>source/simulator/helper_functions.cc</code>.
+         */
+        FEValuesExtractors::Scalar scalar_extractor(const Introspection<dim> &introspection) const;
+
+        /**
+         * Look up the polynomial degree order for this temperature or compositional
+         * field. See Introspection::polynomial_degree for more information.
+         */
+        unsigned int polynomial_degree(const Introspection<dim> &introspection) const;
+      };
+
+    private:
+
+      /**
+       * A member variable that tracks whether we are completely done
+       * with initialization and have started the time loop. This
+       * variable needs to be the first one that is initialized in
+       * the constructor, so that its value correctly tracks the
+       * status of the overall object. As a consequence, it has to
+       * be the first one declared in this class.
+       *
+       * The variable is set to @p true just before we start the time
+       * stepping loop, but may be temporarily reset to @p false
+       * if, for example, we are during the initial mesh refinement
+       * steps where we start the time loop, but then go back to
+       * initialization steps (mesh refinement, interpolation of initial
+       * conditions, etc.) before re-starting the time loop.
+       *
+       * This variable is queried by
+       * SimulatorAccess::simulator_is_past_initialization().
+       */
+      bool simulator_is_past_initialization;
+
+      /**
+       * A class that is empty but that can be used as a member variable and
+       * whose constructor will be run in the order in which the member
+       * variables are initialized. Because this class has a constructor that
+       * takes a function object that it will execute whenever the member
+       * variable is initialized, this allows running arbitrary actions in
+       * between member variable initializers, for example if some member
+       * variable is partially initialized at point A within the member
+       * variable initializer list, its initialization can only be finalized
+       * after point B (because it depends on what another member variable
+       * decides to do), but needs to be finished by point C within the member
+       * initialization. In such a case, one may have a member variable of the
+       * current time placed in the list of member variables such that it is
+       * initialized at point B, and then initialize it using a function
+       * object that performs the finalization of initialization.
+       */
+      struct IntermediaryConstructorAction
+      {
+        IntermediaryConstructorAction (const std::function<void ()> &action);
+      };
+
+      /**
+       * @name Top-level functions in the overall flow of the numerical
+       * algorithm
+       * @{
+       */
+
+      /**
+       * The function that sets up the DoFHandler objects, It also sets up the
+       * various partitioners and computes those constraints on the Stokes
+       * variable and temperature that are the same between all time steps.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void setup_dofs ();
+
+      /**
+       * This function initializes the variables of the introspection object.
+       * It is called by setup_dofs() right after distributing degrees of
+       * freedom since this is when all of the information is available.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void setup_introspection ();
+
+      /**
+       * A function that is responsible for initializing the
+       * temperature/compositional field before the first time step. The
+       * temperature field then serves as the temperature from which the
+       * velocity is computed during the first time step, and is subsequently
+       * overwritten by the temperature field one gets by advancing by one
+       * time step.
+       *
+       * This function is implemented in
+       * <code>source/simulator/initial_conditions.cc</code>.
+       */
+      void set_initial_temperature_and_compositional_fields ();
+
+      /**
+       * A function that initializes the pressure variable before the first
+       * time step. It does so by either interpolating (for continuous
+       * pressure finite elements) or projecting (for discontinuous elements)
+       * the adiabatic pressure computed from the material model.
+       *
+       * Note that the pressure so set is overwritten by the pressure in fact
+       * computed during the first time step. We need this function, however,
+       * so that the evaluation of pressure-dependent coefficients (e.g.
+       * pressure dependent densities or thermal coefficients) during the
+       * first time step has some useful pressure to start with.
+       *
+       * This function is implemented in
+       * <code>source/simulator/initial_conditions.cc</code>.
+       */
+      void compute_initial_pressure_field ();
+
+      /**
+       * Fill the given @p constraints with constraints coming from the velocity boundary
+       * conditions that do not change over time. This function is used by
+       * setup_dofs();
+       */
+      void compute_initial_velocity_boundary_constraints (AffineConstraints<double> &constraints);
+
+      /**
+       * Fill the given @p constraints with constraints coming from the velocity boundary
+       * conditions that do can change over time. This function is used by
+       * compute_current_constraints().
+       */
+      void compute_current_velocity_boundary_constraints (AffineConstraints<double> &constraints);
+
+      /**
+       * Given the 'constraints' member that contains all constraints that are
+       * independent of the time (e.g., hanging node constraints, tangential
+       * flow constraints, etc), copy it over to 'current_constraints' and add
+       * to the latter all constraints that do depend on time such as
+       * temperature or velocity Dirichlet boundary conditions. This function
+       * is therefore called at the beginning of every time step in
+       * start_timestep(), but also when setting up the initial values.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void compute_current_constraints ();
+
+      /**
+       * Compute the factor by which we scale the second of
+       * the Stokes equations (the "pressure scaling factor").
+       * We compute the factor by taking the logarithmic
+       * average of the viscosities we find on the cells in
+       * this domain and dividing this average by a reference
+       * length scale provided by the used geometry model.
+       *
+       * This function returns the pressure scaling variable.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      double compute_pressure_scaling_factor () const;
+
+      /**
+       * Do some housekeeping at the beginning of each time step. This
+       * includes generating some screen output, adding some information to
+       * the statistics file, and interpolating time-dependent boundary
+       * conditions specific to this particular time step (the time
+       * independent boundary conditions, for example for hanging nodes or for
+       * tangential flow, are computed only once per mesh in setup_dofs()).
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void start_timestep ();
+
+      /**
+       * Do the various steps necessary to assemble and solve the things
+       * necessary in each time step.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void solve_timestep ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * If `single Advection, single Stokes' is selected as the nonlinear solver scheme,
+       * no nonlinear iterations are done, and the temperature, compositional fields and
+       * Stokes equations are solved exactly once per time step, one after the other.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_single_advection_single_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `no Advection, iterated Stokes' scheme only solves the Stokes system and
+       * ignores compositions and the temperature equation (careful, the material
+       * model must not depend on the temperature; mostly useful for
+       * Stokes benchmarks).
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_no_advection_iterated_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `no Advection, single Stokes' scheme only solves the Stokes system and
+       * ignores compositions and the temperature equation.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_no_advection_single_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `first timestep only, single Stokes' scheme only solves the Stokes system,
+       * for the initial timestep. This results in a `steady state' velocity field for
+       * particle calculations.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_first_timestep_only_single_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `iterated Advection and Stokes' scheme iterates
+       * by alternating the solution of the temperature, composition and Stokes systems.
+       * This is essentially a type of Picard iterations for the whole
+       * system of equations.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_iterated_advection_and_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `single Advection, iterated Stokes' scheme solves the temperature and
+       * composition equations once at the beginning of each time step
+       * and then iterates out the solution of the Stokes equation using
+       * Picard iterations.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_single_advection_iterated_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `no Advection, iterated defect correction Stokes' scheme
+       * does not solve the temperature and composition equations
+       * but only iterates out the solution of the Stokes
+       * equation using Defect Correction (DC) Picard iterations.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_no_advection_iterated_defect_correction_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `single Advection, iterated defect correction Stokes' scheme
+       * solves the temperature and composition equations once at the beginning
+       * of each time step and then iterates out the solution of the Stokes
+       * equation using Defect Correction (DC) Picard iterations.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_single_advection_iterated_defect_correction_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `iterated Advection and defect correction Stokes' scheme
+       * iterates over both the temperature and composition equations
+       * and the Stokes equations at the same time. The Stokes equation
+       * is iterated out using the Defect Correction (DC) form of the
+       * Picard iterations.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_iterated_advection_and_defect_correction_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `iterated Advection and Newton Stokes' scheme iterates over solving the temperature,
+       * composition, and Stokes equations just like `iterated Advection and Stokes', but
+       * for the Stokes system it is able to switch from a defect correction form of
+       * Picard iterations to Newton iterations after a certain tolerance or
+       * number of iterations is reached. This can greatly improve the
+       * convergence rate for particularly nonlinear viscosities.
+       *
+       * @param use_newton_iterations Sets whether this function should only use defect
+       * correction iterations (use_newton_iterations = false) or also use Newton iterations
+       * (use_newton_iterations = true).
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_iterated_advection_and_newton_stokes (bool use_newton_iterations);
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `single Advection, iterated Newton Stokes' scheme solves the temperature and
+       * composition equations once at the beginning of each time step
+       * and then iterates out the solution of the Stokes equation using Newton iterations.
+       * For the Stokes system it is able to switch from a defect correction form of
+       * Picard iterations to Newton iterations after a certain tolerance or
+       * number of iterations is reached. This can greatly improve the
+       * convergence rate for particularly nonlinear viscosities.
+       *
+       * @param use_newton_iterations Sets whether this function should only use defect
+       * correction iterations (use_newton_iterations = false) or also use Newton iterations
+       * (use_newton_iterations = true).
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_single_advection_and_iterated_newton_stokes (bool use_newton_iterations);
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `single Advection, no Stokes' scheme only solves the temperature and other
+       * advection systems and instead of solving for the Stokes system,
+       * a prescribed velocity and pressure is used."
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_single_advection_no_stokes ();
+
+      /**
+       * This function implements one scheme for the various
+       * steps necessary to assemble and solve the nonlinear problem.
+       *
+       * The `no Advection, no Stokes' scheme skips solving the temperature,
+       * composition and Stokes equations, which permits to go directly to
+       * postprocessing after setting up the initial condition.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void solve_no_advection_no_stokes ();
+
+      /**
+       * Initiate the assembly of the Stokes preconditioner matrix via
+       * assemble_stokes_preconditioner(), then set up the data structures to
+       * actually build a preconditioner from this matrix.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void build_stokes_preconditioner ();
+
+      /**
+       * Initialize the preconditioner for the advection equation of field
+       * index.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void build_advection_preconditioner (const AdvectionField &advection_field,
+                                           aspect::LinearAlgebra::PreconditionILU &preconditioner,
+                                           const double diagonal_strengthening);
+
+      /**
+       * Initiate the assembly of the Stokes matrix and right hand side.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void assemble_stokes_system ();
+
+      /**
+       * Assemble and solve the temperature equation.
+       * This function returns the residual after solving.
+       *
+       * If the `residual` argument is not a `nullptr`, the function computes
+       * the residual and puts it into this variable. The function returns
+       * the current residual divided by the initial residual given as the
+       * first argument. The two arguments may point to the same variable,
+       * in which case the function first computes the residual and at
+       * the end scales that residual by itself, thus returning 1.0.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      double assemble_and_solve_temperature (const double &initial_residual = 0,
+                                             double *residual = nullptr);
+
+      /**
+       * Solve the composition equations with whatever method is selected
+       * (fields or particles). This function returns the residuals for
+       * all fields after solving.
+       *
+       * If the `residual` argument is not a `nullptr`, the function computes
+       * the residual and puts it into this variable. The function returns
+       * the current residual divided by the initial residual given as the
+       * first argument. The two arguments may point to the same variable,
+       * in which case the function first computes the residual and at
+       * the end scales that residual by itself, thus returning 1.0.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      std::vector<double> assemble_and_solve_composition (const std::vector<double> &initial_residual = {},
+                                                          std::vector<double> *residual = nullptr);
+
+      /**
+       * Assemble and solve the Stokes equation.
+       * This function returns the nonlinear residual after solving.
+       *
+       * If the `residual` argument is not a `nullptr`, the function computes
+       * the residual and puts it into this variable. The function returns
+       * the current residual divided by the initial residual given as the
+       * first argument. The two arguments may point to the same variable,
+       * in which case the function first computes the residual and at
+       * the end scales that residual by itself, thus returning 1.0.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      double assemble_and_solve_stokes (const double &initial_nonlinear_residual = 0,
+                                        double *nonlinear_residual = nullptr);
+
+      /**
+       * Do one step of the defect correction form of the Stokes equation;
+       * i.e., assemble and solve the defect correction equations.
+       * This function takes a structure of DefectCorrectionResiduals which
+       * contains information about different residuals. The information in
+       * this structure is updated by this function. The parameter use_picard
+       * forces the use of the defect correction Picard iteration, if set to 'true' no
+       * Newton derivatives are added to the matrix.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver_schemes.cc</code>.
+       */
+      void do_one_defect_correction_Stokes_step(DefectCorrectionResiduals &dcr,
+                                                const bool use_picard);
+
+      /**
+       * Initiate the assembly of one advection matrix and right hand side and
+       * build a preconditioner for the matrix.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void assemble_advection_system (const AdvectionField &advection_field);
+
+      /**
+       * Solve one block of the temperature/composition linear system.
+       * Return the initial nonlinear residual, i.e., if the linear system to
+       * be solved is $Ax=b$, then return $\|Ax_0-b\|$ where $x_0$ is the
+       * initial guess for the solution variable and is taken from the
+       * current_linearization_point member variable.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver.cc</code>.
+       */
+      double solve_advection (const AdvectionField &advection_field);
+
+      /**
+       * Interpolate a particular particle property to the solution field.
+       *
+       * @deprecated: Use interpolate_particle_property_vector() instead.
+       */
+      DEAL_II_DEPRECATED
+      void interpolate_particle_properties (const AdvectionField &advection_field);
+
+      /**
+       * Interpolate the corresponding particle properties into the given
+       * @p advection_fields solution fields.
+       */
+      void interpolate_particle_properties (const std::vector<AdvectionField> &advection_fields);
+
+      /**
+       * Solve the Stokes linear system.
+       *
+       * The function returns two pieces of information as a pair of doubles:
+       * - The initial nonlinear residual, i.e., if the linear system to be
+       *   solved is $Ax_{k+1}=b$, then we use $\|Ax_k-b\|$ where $x_k$ is the
+       *   initial guess for the solution variable and is taken from
+       *   the @p current_linearization_point member variable. For the
+       *   purpose of this function, this residual is computed
+       *   only from the velocity and pressure equations (i.e., for the 2x2 block
+       *   system involving the velocity and pressure variables). A rationale
+       *   for why this number is computed is given below.
+       * - The final linear residual, i.e., if the linear system to be
+       *   solved is $Ax_{k+1}=b$, then we use $\|Ax_{k+1}-b\|$ where $x_{k+1}$
+       *   is the solution just computed. If we use a direct solver to compute
+       *   the solution of the linear system, then this linear residual is of
+       *   course zero (or at least quite close to it) and the function just
+       *   returns a zero value without even attempting to compute the actual
+       *   value. On the other hand, if the function uses an iterative solver,
+       *   then the value of the final linear residual is related to the
+       *   tolerance with which we solve the linear system and generally
+       *   indicates how accurately or inaccurately the linear system has been
+       *   solved.
+       *
+       * The two values are used in nonlinear solver schemes to assess how
+       * accurate the solution was before the current solve (for the first
+       * element of the returned pair) and how accurately the next iteration
+       * will have to be solved (for the second element of the pair) when using
+       * the Eisenstat-Walker method.
+       *
+       * @note If this function is called from a nonlinear solver -- e.g., the
+       * `single Advection, iterated Stokes', or the
+       * `iterated Advection and Stokes' solvers schemes --, then the
+       * @p current_linearization_point is the solution of the previous
+       * iteration (or the solution extrapolated from the previous time
+       * steps, if this is the first nonlinear iteration). Let us call
+       * this solution $x_k$ as above, where $x$ is a two-component
+       * block vector that consists of velocity and pressure. This function
+       * then assumes that we have already built the system matrix $A_k=A(x_k)$
+       * and $F_k=F(x_k)$, both linearized around the previous solution. The
+       * function solves the linear system $A_k x_{k+1} = F_k$ for the
+       * solution $x_{k+1}$. If the linear system were solved exactly, then
+       * that would imply that the <i>linear residual</i>
+       * $\|A_k x_{k+1} - F_k\|$ were zero, or at least small. In other words,
+       * its size does not tell us anything about how accurately we have
+       * solved the nonlinear system. On the other hand, the <i>nonlinear
+       * residual</i> $\|A_k x_k - F_k\|$ tells us something about how
+       * accurately the previous guess $x_k$ already solved the nonlinear
+       * system. Consequently, this is what this function returns. (In some
+       * sense, this is not really what we are interested in: it tells us
+       * how accurate the solution <i>already</i> was, and if it was already
+       * pretty accurate, then we may not want to actually solve for
+       * $x_{k+1}$. But, this would require that this function receives a
+       * tolerance so that it can bail out early without actually solving
+       * for $x_{k+1}$ if the tolerance is already reached. This function does
+       * not actually do that -- in some sense, one may argue that if we have
+       * already built the matrix and right hand side, we may as well solve
+       * with them, whether or not the solution was already good. If it
+       * happens to have been good already, then it will be even better after
+       * the solve. If it was not good enough yet, then we have to solve
+       * anyway.) In contrast to all of this, if we are using a Newton
+       * solver, then $x_{k+1}$ is actually the Newton <i>update</i>
+       * vector, for which we have no initial guess other than the zero
+       * vector. In this case, the function simply returns $\|F_k\|$ as the
+       * first element of the pair, where $F_k=F(x_k)$ is the residual
+       * vector for the previous solution $x_k$.
+       *
+       * This function is implemented in
+       * <code>source/simulator/solver.cc</code>.
+       */
+      std::pair<double,double>
+      solve_stokes ();
+
+      /**
+       * Solve the Stokes system using a block preconditioner and GMG.
+       */
+      std::pair<double,double>
+      solve_stokes_block_gmg ();
+
+      /**
+       * This function is called at the end of every time step. It runs all
+       * the postprocessors that have been listed in the input parameter file
+       * (see the manual) in turn. In particular, this usually includes
+       * generating graphical output every few time steps.
+       *
+       * The function also updates the statistics output file at the end of
+       * each time step.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void postprocess ();
+
+      /**
+       * Refine the mesh according to error indicators calculated by
+       * compute_refinement_criterion(), set up all necessary data structures
+       * on this new mesh, and interpolate the old solutions onto the new
+       * mesh.
+       *
+       * @param[in] max_grid_level The maximum refinement level of the mesh.
+       * This is the sum of the initial global refinement and the initial
+       * adaptive refinement (as provided by the user in the input file) and
+       * in addition it gets increased by one at each additional refinement
+       * time.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void refine_mesh (const unsigned int max_grid_level);
+
+      /**
+       * @}
+       */
+
+      /**
+       * @name Functions used in saving the state of the program and
+       * restarting from a saved state
+       * @{
+       */
+      /**
+       * Save the state of this program to a set of files in the output
+       * directory. In reality, however, only some variables are stored (in
+       * particular the mesh, the solution vectors, etc) whereas others can
+       * either be re-generated (matrices, DoFHandler objects, etc) or are
+       * read from the input parameter file. See the manual for more
+       * information.
+       *
+       * This function is implemented in
+       * <code>source/simulator/checkpoint_restart.cc</code>.
+       */
+      void create_snapshot();
+
+      /**
+       * Restore the state of this program from a set of files in the output
+       * directory. In reality, however, only some variables are stored (in
+       * particular the mesh, the solution vectors, etc) whereas others can
+       * either be re-generated (matrices, DoFHandler objects, etc) or are
+       * read from the input parameter file. See the manual for more
+       * information. This function only restores those variables that can
+       * neither be re-generated from other information nor are read from the
+       * input parameter file.
+       *
+       * This function is implemented in
+       * <code>source/simulator/checkpoint_restart.cc</code>.
+       */
+      void resume_from_snapshot();
+
+      /**
+       * Save a number of variables using BOOST serialization mechanism.
+       *
+       * This function is implemented in
+       * <code>source/simulator/checkpoint_restart.cc</code>.
+       */
+      template <class Archive>
+      void serialize (Archive &ar, const unsigned int version);
+      /**
+       * @}
+       */
+
+      /**
+       * @name Functions used in setting up linear systems
+       * @{
+       */
+      /**
+       * Determine which of the components of our finite-element
+       * system couple to each other. Depending on which equations
+       * are solved and which solver is used this varies widely.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      Table<2,DoFTools::Coupling>
+      setup_system_matrix_coupling () const;
+
+      /**
+       * Set up the size and structure of the matrix used to store the
+       * elements of the linear system.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void setup_system_matrix (const std::vector<IndexSet> &system_partitioning);
+
+      /**
+       * Set up the size and structure of the matrix used to store the
+       * elements of the matrix that is used to build the
+       * preconditioner for the system. This matrix is only used for
+       * the Stokes system, so while it has the size of the whole
+       * system, it only has entries in the velocity and pressure
+       * blocks.
+       *
+       * This function is implemented in
+       * <code>source/simulator/core.cc</code>.
+       */
+      void setup_system_preconditioner (const std::vector<IndexSet> &system_partitioning);
+
+      /**
+       * @}
+       */
+
+      /**
+       * @name Functions, classes, and variables used in the assembly of linear systems
+       * @{
+       */
+
+      /**
+       * A member variable that stores, for the current simulation, what
+       * functions need to be called in order to assemble linear systems,
+       * matrices, and right hand side vectors.
+       *
+       * One would probably want this variable to just be a member of type
+       * Assemblers::Manager<dim>, but this requires that
+       * this type is declared in the current scope, and that would require
+       * including <simulator/assemblers/interface.h> which we don't want because it's big.
+       * Consequently, we just store a pointer to such an object, and create
+       * the object pointed to at the top of set_assemblers().
+       */
+      std::unique_ptr<Assemblers::Manager<dim>> assemblers;
+
+      /**
+       * Determine, based on the run-time parameters of the current simulation,
+       * which functions need to be called in order to assemble linear systems,
+       * matrices, and right hand side vectors.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void set_assemblers ();
+
+      /**
+       * Determine, based on the run-time parameters of the current simulation,
+       * which functions need to be called in order to assemble linear systems,
+       * matrices, and right hand side vectors for the advection. This function
+       * is used by both the default full Stokes solver and the Newton solvers,
+       * but not by the two-phase flow solver.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void set_advection_assemblers ();
+
+      /**
+       * Determine, based on the run-time parameters of the current simulation,
+       * which functions need to be called in order to assemble linear systems,
+       * matrices, and right hand side vectors for the default full Stokes solver
+       * i.e. without considering two-phase flow, or Newton solvers.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void set_stokes_assemblers ();
+
+      /**
+       * Initiate the assembly of the preconditioner for the Stokes system.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void assemble_stokes_preconditioner ();
+
+      /**
+       * Compute the integrals for the preconditioner for the Stokes system on
+       * a single cell.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void
+      local_assemble_stokes_preconditioner (const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                            internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch,
+                                            internal::Assembly::CopyData::StokesPreconditioner<dim> &data);
+
+      /**
+       * Copy the contribution to the preconditioner for the Stokes system
+       * from a single cell into the global matrix that stores these elements.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void
+      copy_local_to_global_stokes_preconditioner (const internal::Assembly::CopyData::StokesPreconditioner<dim> &data);
+
+      /**
+       * Compute the integrals for the Stokes matrix and right hand side on a
+       * single cell.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void
+      local_assemble_stokes_system (const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                    internal::Assembly::Scratch::StokesSystem<dim>  &scratch,
+                                    internal::Assembly::CopyData::StokesSystem<dim> &data);
+
+      /**
+       * Copy the contribution to the Stokes system from a single cell into
+       * the global matrix that stores these elements.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void
+      copy_local_to_global_stokes_system (const internal::Assembly::CopyData::StokesSystem<dim> &data);
+
+      /**
+       * Compute the integrals for one advection matrix and right hand side on
+       * the faces of a single cell.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void
+      local_assemble_advection_face_terms(const AdvectionField &advection_field,
+                                          const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                          internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
+                                          internal::Assembly::CopyData::AdvectionSystem<dim> &data);
+      /**
+       * Compute the integrals for one advection matrix and right hand side on
+       * a single cell.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void
+      local_assemble_advection_system (const AdvectionField &advection_field,
+                                       const Vector<double>           &viscosity_per_cell,
+                                       const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                       internal::Assembly::Scratch::AdvectionSystem<dim>  &scratch,
+                                       internal::Assembly::CopyData::AdvectionSystem<dim> &data);
+
+      /**
+       * Copy the contribution to the advection system from a single cell into
+       * the global matrix that stores these elements.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void
+      copy_local_to_global_advection_system (const AdvectionField &advection_field,
+                                             const internal::Assembly::CopyData::AdvectionSystem<dim> &data);
+
+      /**
+       * @}
+       */
+
+      /**
+       * @name Helper functions
+       * @{
+       */
+      /**
+       * This routine adjusts the second block of the right hand side of a
+       * Stokes system  (containing the term that comes from compressibility,
+       * so that the system becomes compatible: $0=\int div u = \int g$. The
+       * vector to adjust is given as the argument of this function. This
+       * function makes use of the helper vector
+       * pressure_shape_function_integrals that contains $h_i=(q_i,1)$ with
+       * the pressure functions $q_i$ and we adjust the right hand side $g$ by
+       * $h_i \int g / |\Omega|$.
+       *
+       * The purpose of this function is described in the second paper on the
+       * numerical methods in ASPECT.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void make_pressure_rhs_compatible(LinearAlgebra::BlockVector &vector);
+
+      /**
+       * Fills a vector with the artificial viscosity for the temperature or
+       * composition on each local cell.
+       * @param viscosity_per_cell Output vector
+       * @param advection_field Determines whether this variable should select
+       * the temperature field or a compositional field.
+       * @param skip_interior_cells A boolean flag. If set to true the function
+       * will only compute the artificial viscosity in cells at boundaries.
+       */
+      template <typename T>
+      void get_artificial_viscosity (Vector<T> &viscosity_per_cell,
+                                     const AdvectionField &advection_field,
+                                     const bool skip_interior_cells = false) const;
+
+      /**
+       * Compute the seismic shear wave speed, Vs anomaly per element. we
+       * compute the anomaly by computing a smoothed (over 200 km or so)
+       * laterally averaged temperature profile and associated seismic
+       * velocity that is then subtracted from the seismic velocity at the
+       * current pressure temperature conditions
+       *
+       * @param values The output vector of depth averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void compute_Vs_anomaly(Vector<float> &values) const;
+
+      /**
+       * Compute the seismic pressure wave speed, Vp anomaly per element. we
+       * compute the anomaly by computing a smoothed (over 200 km or so)
+       * laterally averaged temperature profile and associated seismic
+       * velocity that is then subtracted from the seismic velocity at the
+       * current pressure temperature conditions
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       *
+       * @param values The output vector of depth averaged values. The
+       * function takes the pre-existing size of this vector as the number of
+       * depth slices.
+       */
+      void compute_Vp_anomaly(Vector<float> &values) const;
+
+      /**
+       * Adjust the pressure variable (which is only determined up to
+       * a constant by the equations, though its value may enter
+       * traction boundary conditions) by adding a constant to it in
+       * such a way that the pressure on the surface or within the
+       * entire volume has a known average value. The point of this
+       * function is that the pressure that results from solving the
+       * linear system may not coincide with what we think of as the
+       * "physical pressure"; in particular, we typically think of the
+       * pressure as zero (on average) along the surface because it is
+       * the sum of the hydrostatic and dynamic pressure, where the
+       * former is thought of as zero along the surface. This function
+       * therefore converts from the "mathematical" pressure to the
+       * "physical" pressure so that all following postprocessing
+       * steps can use the latter.
+       *
+       * In the case of the surface average, whether a face is part of
+       * the surface is determined by asking whether its depth of its
+       * midpoint (as determined by the geometry model) is less than
+       * 1/3*1/sqrt(dim-1)*diameter of the face. For reasonably curved
+       * boundaries, this rules out side faces that are perpendicular
+       * to the surface boundary but includes those faces that are
+       * along the boundary even if the real boundary is curved.
+       *
+       * Whether the pressure should be normalized based on the
+       * surface or volume average is decided by a parameter in the
+       * input file.
+       *
+       * @note This function is called after setting the initial
+       * pressure field in compute_initial_pressure_field() and at the end
+       * of solve_stokes(). This makes sense because these are exactly the
+       * places where the pressure is modified or re-computed.
+       *
+       * @return This function returns the pressure adjustment by value.
+       * This is so that its negative can later be used again in
+       * denormalize_pressure().
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      double normalize_pressure(LinearAlgebra::BlockVector &vector) const;
+
+      /**
+       * Invert the action of the normalize_pressure() function above. This
+       * means that we move from a pressure that satisfies the pressure
+       * normalization (e.g., has a zero average pressure, or a zero average
+       * surface pressure) to one that does not actually satisfy this
+       * normalization, and this doesn't seem to make sense because we are
+       * not interested in such a pressure.
+       *
+       * Indeed, this function is only called at the very beginning of
+       * solve_stokes() before we compute the initial (linear) residual
+       * of the linear system $Ax=b$ that corresponds to the Stokes system,
+       * where $x$ is the variable for which the pressure is adjusted
+       * back to the "wrong" form. Because stokes_system() calls
+       * normalize_pressure() at the end of its operations, no such
+       * "wrong" pressure ever escapes the realm of solve_stokes(). The
+       * "wrong" pressure is then used for two purposes in that function:
+       * (i) To compute the initial Stokes residual, which makes sense
+       * because it can only be zero (if we solved the same linear system
+       * twice) if we re-use the exact same pressure as we got from the
+       * previous solve -- i.e., before we called normalize_pressure()
+       * at the end of the solve. (ii) To initialize the solution vector
+       * before calling the GMRES solver, which also makes sense because
+       * the best guess vector for GMRES is the one that had previously
+       * come out of GMRES, namely the one on which we later called
+       * normalize_pressure().
+       *
+       * This function modifies @p vector in-place. In some cases, we need
+       * locally_relevant values of the pressure. To avoid creating a new vector
+       * and transferring data, this function uses a second vector with relevant
+       * dofs (@p relevant_vector) for accessing these pressure values. Both
+       * @p vector and @p relevant_vector are expected to already contain
+       * the correct pressure values.
+       *
+       * @note The adjustment made in this function is done using the
+       * negative of the @p pressure_adjustment function argument that
+       * would typically have been computed and returned by the
+       * normalize_pressure() function. This value is typically stored in
+       * the member variable @p last_pressure_normalization_adjustment,
+       * but the current function doesn't read this variable but instead
+       * gets the adjustment variable from the given argument.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void denormalize_pressure(const double                      pressure_adjustment,
+                                LinearAlgebra::BlockVector       &vector,
+                                const LinearAlgebra::BlockVector &relevant_vector) const;
+
+      /**
+       * Apply the bound preserving limiter to the discontinuous Galerkin solutions:
+       * i.e., given two fixed upper and lower bound [min, max], after applying the limiter,
+       * the discontinuous Galerkin solution will stay in the prescribed bounds.
+       *
+       * This function is implemented in
+       * <code>source/simulator/limiters.cc</code>.
+       */
+      void apply_BP_limiter_to_dg_solutions (const AdvectionField &advection_field);
+
+      /**
+       * Apply the WENO limiter to the discontinuous Galerkin solutions.
+       * WENO is short for Weighted Essentially Non-Oscillatory, which is
+       * a class of high-resolution schemes used in the numerical solution
+       * of hyperbolic conservation laws. The basic idea of WENO limiter is
+       * to replace the solution in troubled cells (cells with oscillation)
+       * by a polynomial reconstruction that takes the neighbor cells into
+       * account. The WENO scheme implemented in the program is a simple
+       * variant proposed by Zhong and Shu, 2013.
+       *
+       * This function is implemented in
+       * <code>source/simulator/limiters.cc</code>.
+       */
+      void apply_WENO_limiter_to_dg_solutions (const AdvectionField &advection_field);
+
+      /**
+       * Fills a vector with the KXRCF indicator for a given advection field
+       * on each local cell. The KXRCF indicator is a metric of discontinuity
+       * for hyperbolic conservation laws. Cells with high KXRCF values are
+       * identified as "troubled cells" and will be smoothed by the WENO limiter.
+       *
+       * This function is implemented in
+       * <code>source/simulator/limiters.cc</code>.
+       */
+      template <typename T>
+      void compute_KXRCF_indicators(Vector<T> &KXRCF_indicators,
+                                    const AdvectionField &advection_field) const;
+
+      /**
+       * Compute the reactions in case of operator splitting:
+       * Using the current solution vector, this function makes a number of time
+       * steps determined by the size of the reaction time step, and solves a
+       * system of coupled ordinary differential equations for the reactions between
+       * compositional fields and temperature in each of them. To do that, is uses
+       * the reaction rates outputs from the material and heating models used in
+       * the computation. The solution vector is then updated with the new values
+       * of temperature and composition after the reactions.
+       *
+       * As the ordinary differential equation in any given point is independent
+       * from the solution at all other points, we do not have to assemble a matrix,
+       * but just need to loop over all node locations for the temperature and
+       * compositional fields and compute the update to the solution.
+       *
+       * The function also updates the old solution vectors with the reaction update
+       * so that the advection time stepping scheme will have the correct field terms
+       * for the right-hand side when assembling the advection system.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void compute_reactions ();
+
+      /**
+       * Update the indicated block of the solution vector with the
+       * corresponding block of the handed over @p distributed_vector. Also
+       * update reaction_vector with the corresponding block of @p
+       * distributed_reaction_vector.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void update_solution_vectors_with_reaction_results (const unsigned int block_index,
+                                                          const LinearAlgebra::BlockVector &distributed_vector,
+                                                          const LinearAlgebra::BlockVector &distributed_reaction_vector);
+
+      /**
+       * Initialize the current linearization point vector from the old
+       * solution vector(s). Depending on the time of the call this
+       * can be simply a copy of the solution of the last timestep,
+       * or a linear extrapolation of old and old_old timestep to
+       * the new timestep.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void initialize_current_linearization_point ();
+
+      /**
+       * Interpolate material model outputs onto an advection field (temperature
+       * or composition). For the field identified by the AdvectionField @p adv_field, this function
+       * asks the material model to fill a MaterialModel::MaterialModelOutputs
+       * object that has an attached MaterialModel::PrescribedFieldOutputs
+       * "additional outputs" object (for composition) or an attached
+       * MaterialModel::PrescribedTemperatureOutputs (for temperature).
+       * The MaterialModel::MaterialModelInputs
+       * object passed to the material model then contains the support points of
+       * the advection field, thereby allowing the outputs to be
+       * interpolated to the finite element space and consequently into the
+       * solution vector.
+       * This is useful for advection fields whose advection mode is set
+       * to Parameters::AdvectionFieldMethod::prescribed_field or
+       * Parameters::AdvectionFieldMethod::prescribed_field_with_diffusion.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void interpolate_material_output_into_advection_field (const AdvectionField &adv_field);
+
+
+      /**
+       * Interpolate the given function onto the velocity FE space and write
+       * it into the given vector.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void interpolate_onto_velocity_system(const TensorFunction<1,dim> &func,
+                                            LinearAlgebra::Vector &vec);
+
+
+      /**
+       * Add constraints to the given @p constraints object that are required
+       * for unique solvability of the velocity block based on the nullspace
+       * removal settings.
+       *
+       * This method will add a zero Dirichlet constraint for the first
+       * velocity unknown in the domain for each velocity component, which is
+       * later being processed for translational or linear momentum removal.
+       * This avoids breakdowns of the linear solvers that otherwise occurred
+       * in some instances.
+       *
+       * @note: Rotational modes are currently not handled and don't appear to
+       * require constraints so far.
+       */
+      void setup_nullspace_constraints(AffineConstraints<double> &constraints);
+
+
+      /**
+       * Eliminate the nullspace of the velocity in the given vector. Both
+       * vectors are expected to contain the up to date data.
+       *
+       * @param relevant_dst locally relevant vector for the whole FE, will be
+       * filled at the end.
+       * @param tmp_distributed_stokes only contains velocity and pressure.
+       *
+       * This function is implemented in
+       * <code>source/simulator/nullspace.cc</code>.
+       */
+      void remove_nullspace(LinearAlgebra::BlockVector &relevant_dst,
+                            LinearAlgebra::BlockVector &tmp_distributed_stokes);
+
+      /**
+       * Compute the angular momentum and other rotation properties
+       * of the velocities in the given solution vector.
+       *
+       * @param use_constant_density determines whether to use a constant
+       * density (which corresponds to computing a net rotation instead of net
+       * angular momentum).
+       * @param solution Solution vector to compute the properties for.
+       * @param limit_to_top_faces allows to only compute the net angular momentum
+       * (or net rotation) of the top surface.
+       *
+       * This function is implemented in
+       * <code>source/simulator/nullspace.cc</code>.
+       */
+      RotationProperties<dim>
+      compute_net_angular_momentum(const bool use_constant_density,
+                                   const LinearAlgebra::BlockVector &solution,
+                                   const bool limit_to_top_faces = false) const;
+
+      /**
+       * Remove the angular momentum of the given vector
+       *
+       * @param use_constant_density determines whether to use a constant
+       * density (which corresponds to removing a net rotation instead of net
+       * angular momentum).
+       * @param relevant_dst locally relevant vector for the whole FE, will be
+       * filled at the end.
+       * @param tmp_distributed_stokes only contains velocity and pressure.
+       * @param limit_to_top_faces allows to only remove the net angular momentum
+       * (or net rotation) of the top surface. This can be useful to compare surface
+       * motions against plate reconstructions in no net rotation reference frames.
+       *
+       * This function is implemented in
+       * <code>source/simulator/nullspace.cc</code>.
+       */
+      void remove_net_angular_momentum( const bool use_constant_density,
+                                        LinearAlgebra::BlockVector &relevant_dst,
+                                        LinearAlgebra::BlockVector &tmp_distributed_stokes,
+                                        const bool limit_to_top_faces = false);
+
+      /**
+       * Offset the boundary id of all faces located on an outflow boundary
+       * by a fixed value given by the input parameter @p boundary_id_offset.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void replace_outflow_boundary_ids(const unsigned int boundary_id_offset);
+
+      /**
+       * Undo the offset of the boundary ids done in replace_outflow_boundary_ids
+       * by resetting all boundary ids to their original value.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void restore_outflow_boundary_ids(const unsigned int boundary_id_offset);
+
+      /**
+       * Remove the linear momentum of the given vector
+       *
+       * @param use_constant_density determines whether to use a constant
+       * density (which corresponds to removing a net translation instead of
+       * net linear momentum).
+       * @param relevant_dst locally relevant vector for the whole FE, will be
+       * filled at the end.
+       * @param tmp_distributed_stokes only contains velocity and pressure.
+       *
+       * This function is implemented in
+       * <code>source/simulator/nullspace.cc</code>.
+       */
+      void remove_net_linear_momentum( const bool use_constant_density,
+                                       LinearAlgebra::BlockVector &relevant_dst,
+                                       LinearAlgebra::BlockVector &tmp_distributed_stokes);
+
+      /**
+       * Compute the maximal velocity throughout the domain. This is needed to
+       * compute the size of the time step.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      double get_maximal_velocity (const LinearAlgebra::BlockVector &solution) const;
+
+      /**
+       * Compute the variation (i.e., the difference between maximal and
+       * minimal value) of the entropy $(T-\bar T)^2$ where $\bar T$ is the
+       * average temperature throughout the domain given as argument to this
+       * function.
+       *
+       * This function is used in computing the artificial diffusion
+       * stabilization term.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      double get_entropy_variation (const double average_field,
+                                    const AdvectionField &advection_field) const;
+
+      /**
+       * Compute the minimal and maximal temperature throughout the domain from
+       * a solution vector extrapolated from the previous time steps. This is
+       * needed to compute the artificial diffusion stabilization terms.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      std::pair<double,double>
+      get_extrapolated_advection_field_range (const AdvectionField &advection_field) const;
+
+      /**
+       * Exchange coarsen/refinement flags set between processors so that
+       * we have the correct settings on all ghost cells.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       *
+       */
+      void exchange_refinement_flags();
+
+
+      /**
+       * Check if timing output should be written in this timestep, and if so
+       * write it.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       *
+       */
+      void maybe_write_timing_output () const;
+
+      /**
+       * Check if a checkpoint should be written in this timestep. If so create
+       * one. Returns whether a checkpoint was written.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      bool maybe_write_checkpoint (const time_t last_checkpoint_time,
+                                   const bool force_writing_checkpoint);
+
+      /**
+       * Check if we should do an initial refinement cycle in this timestep.
+       * This will only be checked in timestep 0, afterwards the variable
+       * pre_refinement_step variable is invalidated, and this function will
+       * return without doing refinement.
+       * An initial refinement cycle is different from a regular one,
+       * because time is not increased. Instead the same timestep is solved
+       * using the new mesh.
+       * Therefore, only output timing information and postprocessor output
+       * if required in the input file. But always output statistics (to have
+       * a history of the number of cells in the statistics file).
+       * This function returns whether an initial refinement was done.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      bool maybe_do_initial_refinement (const unsigned int max_refinement_level);
+
+      /**
+       * Check if refinement is requested in this timestep. If so: Refine mesh.
+       * The @p max_refinement_level might be increased from this time on
+       * if this is an additional refinement cycle.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void maybe_refine_mesh (const double new_time_step,
+                              unsigned int &max_refinement_level);
+
+      /**
+       * Advance the current time by the given @p step_size and update the
+       * solution vectors as needed.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void advance_time (const double step_size);
+
+      /**
+       * Compute the artificial diffusion coefficient value on a cell given
+       * the values and gradients of the solution passed as arguments.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      double
+      compute_viscosity(internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
+                        const double                        global_u_infty,
+                        const double                        global_field_variation,
+                        const double                        average_field,
+                        const double                        global_entropy_variation,
+                        const double                        cell_diameter,
+                        const AdvectionField     &advection_field) const;
+
+      /**
+       * Compute the residual of one advection equation to be used for the
+       * artificial diffusion coefficient value on a cell given the values and
+       * gradients of the solution passed as arguments.
+       *
+       * This function is implemented in
+       * <code>source/simulator/assembly.cc</code>.
+       */
+      void
+      compute_advection_system_residual(internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
+                                        const double                        average_field,
+                                        const AdvectionField               &advection_field,
+                                        double                             &max_residual,
+                                        double                             &max_velocity,
+                                        double                             &max_density,
+                                        double                             &max_specific_heat,
+                                        double                             &conductivity) const;
+
+      /**
+       * Return whether the Stokes matrix depends on the values of the
+       * solution at the previous time step. This is the case is the
+       * coefficients that appear in the matrix (i.e., the viscosity and, in
+       * the case of a compressible model, the density) depend on the
+       * solution.
+       *
+       * This function exists to ensure that the Stokes matrix is rebuilt in
+       * time steps where it may have changed, while we want to save the
+       * effort of rebuilding it whenever we don't need to.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      bool
+      stokes_matrix_depends_on_solution () const;
+
+      /**
+       * Return whether to the best of our knowledge the A block of the
+       * Stokes system is symmetric. This is the case for most models, except
+       * if additional non-symmetric terms are added by special assemblers
+       * (e.g., the free surface stabilization term).
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+      */
+      bool
+      stokes_A_block_is_symmetric () const;
+
+      /**
+       * This function checks that the user-selected formulations of the
+       * equations are consistent with the other inputs. If an incorrect
+       * selection is detected it throws an exception. It for example assures that
+       * correct heating terms are selected, and the material model supports
+       * the selection of the mass conservation formulation (e.g. incompressible)).
+       * If the parameter 'parameters.formulation' is set to 'custom'
+       * it only ensures very basic consistency.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void
+      check_consistency_of_formulation ();
+
+      /**
+      * This function checks if the default solver and/or material
+      * averaging were selected and if so, determines the appropriate
+      * solver and/or averaging option.
+      */
+      void
+      select_default_solver_and_averaging ();
+
+      /**
+       * This function checks that the user-selected boundary conditions do not
+       * contain contradictions. If an incorrect selection is detected it
+       * throws an exception. This for example assures that not both velocity
+       * and traction boundary conditions are prescribed at the same boundary,
+       * and that no boundary temperatures are prescribed at a periodic boundary.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void
+      check_consistency_of_boundary_conditions () const;
+
+      /**
+       * Computes the initial Newton residual.
+       */
+      double
+      compute_initial_newton_residual (const LinearAlgebra::BlockVector &linearized_stokes_initial_guess);
+
+      /**
+       * This function computes the Eisenstat Walker linear tolerance used for the Newton iterations
+       * in the `iterated Advection and Newton Stokes' and `single Advection, iterated Newton Stokes' solver schemes.
+       * The Eisenstat and Walker (1996) method is used for determining the linear tolerance of
+       * the iteration after the first iteration. The paper gives two preferred choices of computing
+       * this tolerance. Both choices are implemented here with the suggested parameter values and
+       * safeguards.
+       */
+      double
+      compute_Eisenstat_Walker_linear_tolerance(const bool EisenstatWalkerChoiceOne,
+                                                const double maximum_linear_stokes_solver_tolerance,
+                                                const double linear_stokes_solver_tolerance,
+                                                const double stokes_residual,
+                                                const double newton_residual,
+                                                const double newton_residual_old);
+
+      /**
+       * This function is called at the end of each time step and writes the
+       * statistics object that contains data like the current time, the
+       * number of linear solver iterations, and whatever the postprocessors
+       * have generated, to disk.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      void output_statistics();
+
+      /**
+       * This routine computes the initial (nonlinear) Stokes residual that is
+       * needed as a convergence criterion in models with solver schemes that do
+       * nonlinear iterations. We calculate it in the same way as the tolerance for the linear
+       * solver, using the norm of the pressure RHS for the pressure part and a
+       * residual with zero velocity for the velocity part to get the part of
+       * the RHS not balanced by the static pressure.
+       *
+       * This function is implemented in
+       * <code>source/simulator/helper_functions.cc</code>.
+       */
+      double
+      compute_initial_stokes_residual();
+
+      /**
+       * @}
+       */
+
+      /**
+       * @name Variables that have to do with input, output, parallel
+       * communication and interfacing with other parts of the program.
+       * @{
+       */
+      Parameters<dim>                     parameters;
+
+      /**
+       * Unique pointer for an instance of the MeltHandler. This way,
+       * if we do not need the machinery for doing melt stuff, we do
+       * not even allocate it.
+       */
+      std::unique_ptr<MeltHandler<dim>> melt_handler;
+
+      /**
+       * Unique pointer for an instance of the NewtonHandler. This way,
+       * if we do not need the machinery for doing Newton stuff, we do
+       * not even allocate it.
+       */
+      std::unique_ptr<NewtonHandler<dim>> newton_handler;
+
+      SimulatorSignals<dim>               signals;
+
+      const IntermediaryConstructorAction post_signal_creation;
+
+      /**
+       * Unique pointer for an instance of the VolumeOfFluidHandler. This way,
+       * if we do not need the machinery for doing volume_of_fluid stuff, we do
+       * not even allocate it.
+       *
+       * Located here due to needing signals access
+       */
+      std::unique_ptr<VolumeOfFluidHandler<dim>> volume_of_fluid_handler;
+
+      Introspection<dim>                  introspection;
+
+
+      MPI_Comm                            mpi_communicator;
+
+      /**
+       * This stream will log into the file output/log.txt (used automatically
+       * by pcout).
+       */
+      std::ofstream log_file_stream;
+
+      using TeeDevice = boost::iostreams::tee_device<std::ostream, std::ofstream>;
+      using TeeStream = boost::iostreams::stream<TeeDevice>;
+
+      TeeDevice iostream_tee_device;
+      TeeStream iostream_tee_stream;
+
+      /**
+       * Output stream for logging information. Will only output on processor
+       * 0.
+       */
+      ConditionalOStream                  pcout;
+
+      /**
+       * An object that stores a bunch of statistics such as the number of
+       * linear solver iterations, the time corresponding to each time step,
+       * etc, as well as whatever the various postprocessors want to put into
+       * it.
+       *
+       * This variable is written to disk after every time step, by the
+       * Simulator::output_statistics() function.
+       */
+      TableHandler                        statistics;
+
+      /**
+       * The following two variables keep track which parts of the statistics
+       * object have already been written. This is because the TableHandler
+       * class has no way to keep track what it has already written, and so
+       * we can not just append the last row of the table to the output
+       * file. Rather, we keep track how many bytes we already wrote,
+       * and a hash of what they contained, and if these so-many bytes have
+       * not changed between the previous and current write operation, then
+       * we only open the file in 'append' mode to add the new bytes from the
+       * last row. If what we would write now has changed from what we wrote
+       * back then in the first so-many bytes (e.g., because column widths of
+       * the table have changed), then we just replace the previous file by
+       * the current table contents in their entirety.
+       */
+      std::size_t                         statistics_last_write_size;
+      std::size_t                         statistics_last_hash;
+
+      mutable TimerOutput                 computing_timer;
+
+      /**
+       * A timer used to track the current wall time since the
+       * last snapshot (or since the program started).
+       */
+      Timer wall_timer;
+
+      /**
+       * The total wall time that has elapsed up to the last snapshot
+       * that was created.
+       */
+      double total_walltime_until_last_snapshot;
+
+      /**
+       * In output_statistics(), where we output the statistics object above,
+       * we do the actual writing on a separate thread. This variable is the
+       * handle we get for this thread so that we can wait for it to finish,
+       * either if we want to write the statistics object for the next thread,
+       * or if we want to terminate altogether.
+       */
+      std::thread                         output_statistics_thread;
+
+      /**
+       * @}
+       */
+
+      /**
+       * @name Variables that describe the physical setup of the problem
+       * @{
+       */
+      const std::unique_ptr<InitialTopographyModel::Interface<dim>>          initial_topography_model;
+      const std::unique_ptr<GeometryModel::Interface<dim>>                   geometry_model;
+      const IntermediaryConstructorAction                                    post_geometry_model_creation_action;
+      const std::unique_ptr<MaterialModel::Interface<dim>>                   material_model;
+      const std::unique_ptr<GravityModel::Interface<dim>>                    gravity_model;
+      BoundaryTemperature::Manager<dim>                                      boundary_temperature_manager;
+      BoundaryComposition::Manager<dim>                                      boundary_composition_manager;
+      const std::unique_ptr<PrescribedStokesSolution::Interface<dim>>        prescribed_stokes_solution;
+
+      /**
+       * The following two variables are pointers to objects that describe
+       * the initial temperature and composition values. The Simulator
+       * class itself releases these pointers once they are no longer
+       * needed, somewhere during the first time step once it is known
+       * that they are no longer needed. However, plugins can have their
+       * own shared pointers to these objects, and the lifetime of the
+       * objects pointed to is then until the last of these plugins
+       * gets deleted.
+       */
+      std::shared_ptr<InitialTemperature::Manager<dim>>                      initial_temperature_manager;
+      std::shared_ptr<InitialComposition::Manager<dim>>                      initial_composition_manager;
+
+      const std::unique_ptr<AdiabaticConditions::Interface<dim>>             adiabatic_conditions;
+#ifdef ASPECT_WITH_WORLD_BUILDER
+      /**
+       * A pointer to the WorldBuilder object. Like the
+       * `initial_temperature_manager` and
+       * `initial_composition_manager` objects above, the Simulator
+       * object itself releases this pointer at the end of the
+       * initialization process (right after releasing the
+       * two mentioned initial condition objects). If a part of
+       * the plugin system still needs the world builder object
+       * after this point, it needs to keep its own shared pointer
+       * to it.
+       */
+      std::shared_ptr<WorldBuilder::World>                                   world_builder;
+#endif
+      BoundaryVelocity::Manager<dim>                                         boundary_velocity_manager;
+      BoundaryTraction::Manager<dim>                                         boundary_traction_manager;
+      const std::unique_ptr<BoundaryHeatFlux::Interface<dim>>                boundary_heat_flux;
+
+      /**
+       * The world holding the particles
+       */
+      std::vector<std::unique_ptr<Particle::World<dim>>> particle_worlds;
+
+      /**
+       * @}
+       */
+      /**
+       * @name Variables that describe the time discretization
+       * @{
+       */
+      double                                                    time;
+      double                                                    time_step;
+      double                                                    old_time_step;
+      unsigned int                                              timestep_number;
+      unsigned int                                              pre_refinement_step;
+      unsigned int                                              nonlinear_iteration;
+      /**
+       * @}
+       */
+
+      /**
+       * @name Variables related to simulation time stepping
+       * @{
+       */
+      TimeStepping::Manager<dim>                                time_stepping_manager;
+      /**
+       * @}
+       */
+
+      /**
+       * @name Variables for doing lateral averaging
+       * @{
+       */
+      LateralAveraging<dim>                                     lateral_averaging;
+      /**
+       * @}
+       */
+
+      /**
+       * @name Variables that describe the spatial discretization
+       * @{
+       */
+      parallel::distributed::Triangulation<dim>                 triangulation;
+      double                                                    global_Omega_diameter;
+      double                                                    global_volume;
+
+      MeshRefinement::Manager<dim>                              mesh_refinement_manager;
+      HeatingModel::Manager<dim>                                heating_model_manager;
+
+      /**
+       * Pointer to the Mapping object used by the finite elements when
+       * going from the reference cell to the cell in the computational
+       * domain. We use a pointer since different mapping objects may
+       * be useful. In particular, when the mesh is deformable we use
+       * a MappingQ1Eulerian object to describe the mesh deformation,
+       * swapping it in for the original MappingQ or MappingCartesian object.
+       */
+      std::unique_ptr<Mapping<dim>>                            mapping;
+
+      const FESystem<dim>                                       finite_element;
+
+      DoFHandler<dim>                                           dof_handler;
+
+      Postprocess::Manager<dim>                                 postprocess_manager;
+
+      /**
+       * Constraint objects. The first of these describes all constraints that
+       * are not time dependent (e.g., hanging nodes, no-normal-flux
+       * constraints), whereas the second one is initialized at the top of
+       * every time step by copying from the first and then adding to it
+       * constraints that are time dependent (e.g., time dependent velocity or
+       * temperature boundary conditions).
+       *
+       * 'constraints' is computed in setup_dofs(), 'current_constraints' is
+       * done in compute_current_constraints().
+       */
+      AffineConstraints<double>                                          constraints;
+      AffineConstraints<double>                                          current_constraints;
+
+      /**
+       * A place to store the latest correction computed by normalize_pressure().
+       * We store this so we can undo the correction in denormalize_pressure().
+       */
+      double                                                    last_pressure_normalization_adjustment;
+
+      /**
+       * Scaling factor for the pressure as explained in the
+       * Kronbichler/Heister/Bangerth paper to ensure that the linear system
+       * that results from the Stokes equations is well conditioned.
+       */
+      double                                                    pressure_scaling;
+
+      /**
+       * A variable that determines whether we need to do the correction of
+       * the Stokes right hand side vector to ensure that the average
+       * divergence is zero. This is necessary for compressible models, but
+       * only if there are no in/outflow boundaries.
+       */
+      bool                           do_pressure_rhs_compatibility_modification;
+
+      /**
+       * @}
+       */
+
+
+      /**
+       * @name Variables that describe the linear systems and solution vectors
+       * @{
+       */
+
+      /**
+       * An object that contains the entries of the system matrix. It
+       * has a size equal to the total number of degrees of freedom,
+       * but since we typically do not solve for all variables at
+       * once, the content of the matrix at any given time is only
+       * appropriate for the part of the system we are currently
+       * solving.
+       */
+      LinearAlgebra::BlockSparseMatrix                          system_matrix;
+
+      /**
+       * This vector is used for the weighted BFBT preconditioner. It
+       * stores the inverted lumped velocity mass matrix.
+      */
+      LinearAlgebra::BlockVector                                inverse_lumped_mass_matrix;
+
+      /**
+       * An object that contains the entries of preconditioner
+       * matrices for the system matrix. It has a size equal to the
+       * total number of degrees of freedom, but is only used for the
+       * Stokes system (that's the only part of the system where we
+       * use a matrix for preconditioning that is different from the
+       * matrix we solve). Consequently, the blocks in rows and
+       * columns corresponding to temperature or compositional fields
+       * are left empty when building the sparsity pattern of this
+       * matrix in the Simulator::setup_system_preconditioner()
+       * function.
+       */
+      LinearAlgebra::BlockSparseMatrix                          system_preconditioner_matrix;
+
+      LinearAlgebra::BlockVector                                solution;
+      LinearAlgebra::BlockVector                                old_solution;
+      LinearAlgebra::BlockVector                                old_old_solution;
+      LinearAlgebra::BlockVector                                system_rhs;
+
+      LinearAlgebra::BlockVector                                current_linearization_point;
+
+      // only used if is_compressible()
+      LinearAlgebra::BlockVector                                pressure_shape_function_integrals;
+
+      // only used if operator split is enabled
+      LinearAlgebra::BlockVector                                operator_split_reaction_vector;
+
+
+
+      std::unique_ptr<LinearAlgebra::PreconditionAMG>           Amg_preconditioner;
+      std::unique_ptr<LinearAlgebra::PreconditionBase>          Mp_preconditioner;
+
+      bool                                                      rebuild_sparsity_and_matrices;
+      bool                                                      rebuild_stokes_matrix;
+      bool                                                      assemble_newton_stokes_matrix;
+      bool                                                      assemble_newton_stokes_system;
+      bool                                                      rebuild_stokes_preconditioner;
+
+      /**
+       * @}
+       */
+
+    private:
+
+      /**
+       * Unique pointer for an instance of the MeshDeformationHandler. this way,
+       * if we do not need the machinery for doing mesh deformation stuff, we do
+       * not even allocate it.
+       */
+      std::unique_ptr<MeshDeformation::MeshDeformationHandler<dim>> mesh_deformation;
+
+      /**
+       * Unique pointer for the matrix-free Stokes solver
+       */
+      std::unique_ptr<StokesMatrixFreeHandler<dim>> stokes_matrix_free;
+
+      friend class boost::serialization::access;
+      friend class SimulatorAccess<dim>;
+      friend class MeshDeformation::MeshDeformationHandler<dim>;   // MeshDeformationHandler needs access to the internals of the Simulator
+      friend class VolumeOfFluidHandler<dim>; // VolumeOfFluidHandler needs access to the internals of the Simulator
+      friend class StokesMatrixFreeHandler<dim>;
+      template <int dimension, int velocity_degree>
+      friend class StokesMatrixFreeHandlerImplementation;
+      friend struct Parameters<dim>;
+  };
+}
+
+
+#endif
diff --git a/include/aspect/simulator/assemblers/advection.h.bak b/include/aspect/simulator/assemblers/advection.h.bak
new file mode 100644
index 00000000000..cfc5a5edd10
--- /dev/null
+++ b/include/aspect/simulator/assemblers/advection.h.bak
@@ -0,0 +1,136 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_simulator_assemblers_advection_h
+#define _aspect_simulator_assemblers_advection_h
+
+
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    /**
+     * This class assembles the terms for the matrix and right-hand-side of the advection
+     * equation for the current cell.
+     */
+    template <int dim>
+    class AdvectionSystem : public Assemblers::Interface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+
+        std::vector<double>
+        compute_residual(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base) const override;
+    };
+
+    template <int dim>
+    class DarcySystem : public Assemblers::Interface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+
+        std::vector<double>
+        compute_residual(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base) const override;
+
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+    };
+
+    /**
+     * This class assembles the terms for the matrix and right-hand-side equation for the
+     * current cell in case we only want to solve the diffusion equation.
+     */
+    template <int dim>
+    class DiffusionSystem : public Assemblers::Interface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+
+        std::vector<double>
+        compute_residual(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base) const override;
+
+        virtual
+        std::vector<double>
+        advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
+
+        virtual
+        std::vector<double>
+        diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
+    };
+
+    /**
+     * This class assembles the face terms for the right-hand-side of the
+     * advection equation for a face at the boundary of the domain where
+     * Neumann boundary conditions are used (which allow to prescribe a heat flux).
+     */
+    template <int dim>
+    class AdvectionSystemBoundaryHeatFlux : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the face terms for the matrix and right-hand-side of
+     * the discontinuous advection equation for a face at the boundary of the domain.
+     */
+    template <int dim>
+    class AdvectionSystemBoundaryFace : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the face terms for the matrix and right-hand-side of
+     * the discontinuous advection equation for a face in the interior of the domain.
+     */
+    template <int dim>
+    class AdvectionSystemInteriorFace : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/simulator/assemblers/interface.h.bak b/include/aspect/simulator/assemblers/interface.h.bak
new file mode 100644
index 00000000000..fa918170c0e
--- /dev/null
+++ b/include/aspect/simulator/assemblers/interface.h.bak
@@ -0,0 +1,818 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_simulator_assemblers_interface_h
+#define _aspect_simulator_assemblers_interface_h
+
+#include <aspect/global.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/material_model/interface.h>
+
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim>
+  class Simulator;
+
+  struct AdvectionField;
+
+  /**
+   * A namespace that is used for internal scratch objects, i.e. objects that define
+   * the inputs and outputs for the individual assembler objects. The different classes
+   * are provided for the different systems of equations, and the inputs are filled
+   * by the <code>local_assemble_...</code> functions in <code>assembly.cc</code>,
+   * before being handed over to the assemblers.
+   */
+  namespace internal
+  {
+    namespace Assembly
+    {
+      namespace Scratch
+      {
+        /**
+         * Scratch objects are used to store information about a cell that is
+         * necessary for assembling matrix and right hand side terms for this
+         * cell. The ScratchBase class acts as a empty base class for
+         * individual scratch objects for the different equations.
+         */
+        template <int dim>
+        struct ScratchBase
+        {
+          ScratchBase()
+            :
+            cell(),
+            face_number(numbers::invalid_unsigned_int)
+          {}
+
+          ScratchBase(const ScratchBase &scratch)
+            :
+            cell(scratch.cell),
+            face_number(scratch.face_number)
+          {}
+
+          virtual ~ScratchBase ()  = default;
+
+          /**
+           * Cell object on which we currently operate.
+           */
+          typename DoFHandler<dim>::active_cell_iterator cell;
+
+          /**
+           * The number of the face object with respect to the current
+           * cell on which we operate. If we currently
+           * operate on a cell, this member is set to
+           * numbers::invalid_unsigned_int.
+           */
+          unsigned face_number;
+        };
+
+        /**
+         * A scratch object to store all necessary information to assemble
+         * the Stokes preconditioner terms.
+         */
+        template <int dim>
+        struct StokesPreconditioner: public ScratchBase<dim>
+        {
+          StokesPreconditioner (const FiniteElement<dim> &finite_element,
+                                const Quadrature<dim>    &quadrature,
+                                const Mapping<dim>       &mapping,
+                                const UpdateFlags         update_flags,
+                                const unsigned int        n_compositional_fields,
+                                const unsigned int        stokes_dofs_per_cell,
+                                const bool                add_compaction_pressure,
+                                const bool                rebuild_matrix,
+                                const bool                use_bfbt);
+          StokesPreconditioner (const StokesPreconditioner &scratch);
+
+          ~StokesPreconditioner () override;
+
+          FEValues<dim> finite_element_values;
+
+          void reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref);
+
+          std::vector<types::global_dof_index> local_dof_indices;
+          std::vector<unsigned int>            dof_component_indices;
+          std::vector<SymmetricTensor<2,dim>> grads_phi_u;
+          std::vector<double>                  div_phi_u;
+          std::vector<double>                  phi_p;
+          std::vector<Tensor<1,dim>>           phi_u;
+          std::vector<double>                  phi_p_c;
+          std::vector<Tensor<1,dim>>          grad_phi_p;
+
+          /**
+           * Material model inputs and outputs computed at the current
+           * linearization point.
+           */
+          MaterialModel::MaterialModelInputs<dim> material_model_inputs;
+          MaterialModel::MaterialModelOutputs<dim> material_model_outputs;
+
+          /**
+           * Whether the Stokes matrix should be rebuild during this
+           * assembly. If the matrix does not change, assembling the right
+           * hand side is sufficient.
+           */
+          const bool rebuild_stokes_matrix;
+        };
+
+
+
+        /**
+         * A scratch object to store all necessary information to assemble
+         * the terms in the Stokes equations.
+         * We derive the StokesSystem scratch class from the
+         * StokesPreconditioner class, because all the objects that
+         * are necessary for the assembly of the preconditioner are also
+         * needed for the actual system matrix and right hand side, plus some
+         * extra data that we need for the time stepping and traction boundaries
+         * on the right hand side.
+         */
+        template <int dim>
+        struct StokesSystem : public StokesPreconditioner<dim>
+        {
+          StokesSystem (const FiniteElement<dim> &finite_element,
+                        const Mapping<dim>       &mapping,
+                        const Quadrature<dim>    &quadrature,
+                        const Quadrature<dim-1>  &face_quadrature,
+                        const UpdateFlags         update_flags,
+                        const UpdateFlags         face_update_flags,
+                        const unsigned int        n_compositional_fields,
+                        const unsigned int        stokes_dofs_per_cell,
+                        const bool                add_compaction_pressure,
+                        const bool                use_reference_density_profile,
+                        const bool                rebuild_stokes_matrix,
+                        const bool                rebuild_newton_stokes_matrix,
+                        const bool                use_bfbt);
+
+          StokesSystem (const StokesSystem<dim> &scratch);
+
+          FEFaceValues<dim> face_finite_element_values;
+
+          using StokesPreconditioner<dim>::reinit;
+
+          void reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref,
+                       const unsigned face_number_ref);
+
+          std::vector<Tensor<1,dim>>          phi_u;
+          std::vector<Tensor<1,dim>>          velocity_values;
+          std::vector<double>                  velocity_divergence;
+          std::vector<Tensor<1,dim>>          temperature_gradients;
+
+          /**
+           * Material model inputs and outputs computed at the current
+           * linearization point.
+           *
+           * In contrast to the variables above, the following two
+           * variables are used in the assembly at quadrature points
+           * on faces, not on cells.
+           */
+          MaterialModel::MaterialModelInputs<dim> face_material_model_inputs;
+          MaterialModel::MaterialModelOutputs<dim> face_material_model_outputs;
+
+          /**
+           * In some approximations of the Stokes equations the density used
+           * for the mass conservation (/continuity) equation is some form
+           * of reference density, while the density used for calculating
+           * the buoyancy force is the full density. In case such a formulation
+           * is used the reference density (and its derivative in depth
+           * direction) is queried from the adiabatic conditions plugin
+           * and is stored in these variables.
+           */
+          std::vector<double> reference_densities;
+          std::vector<double> reference_densities_depth_derivative;
+
+          /**
+           * Whether the Newton solver Stokes matrix should be rebuild during
+           * this assembly. If the matrix does not change, assembling the right
+           * hand side is sufficient.
+           */
+          const bool rebuild_newton_stokes_matrix;
+        };
+
+
+
+        /**
+         * A scratch object to store all necessary information to assemble
+         * the terms in the advection equations.
+         */
+        template <int dim>
+        struct AdvectionSystem: public ScratchBase<dim>
+        {
+          AdvectionSystem (const FiniteElement<dim> &finite_element,
+                           const FiniteElement<dim> &advection_element,
+                           const Mapping<dim>       &mapping,
+                           const Quadrature<dim>    &quadrature,
+                           const Quadrature<dim-1>  &face_quadrature,
+                           const UpdateFlags         update_flags,
+                           const UpdateFlags         face_update_flags,
+                           const unsigned int        n_compositional_fields,
+                           const typename Simulator<dim>::AdvectionField     &field);
+          AdvectionSystem (const AdvectionSystem &scratch);
+
+          FEValues<dim> finite_element_values;
+
+          void reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref);
+
+          std::unique_ptr<FEFaceValues<dim>>    face_finite_element_values;
+          std::unique_ptr<FEFaceValues<dim>>    neighbor_face_finite_element_values;
+          std::unique_ptr<FESubfaceValues<dim>> subface_finite_element_values;
+
+          std::vector<types::global_dof_index>   local_dof_indices;
+
+          /**
+           * Variables describing the values and gradients of the
+           * shape functions at the quadrature points, as they are
+           * used in the advection assembly function. note that the sizes
+           * of these arrays are equal to the number of shape functions
+           * corresponding to the currently advected field (and not all of the
+           * existing fields), and that they are also correspondingly indexed.
+           */
+          std::vector<double>         phi_field;
+          std::vector<Tensor<1,dim>> grad_phi_field;
+          std::vector<double>         laplacian_phi_field;
+          std::vector<double>         face_phi_field;
+          std::vector<Tensor<1,dim>> face_grad_phi_field;
+          std::vector<double>         neighbor_face_phi_field;
+          std::vector<Tensor<1,dim>> neighbor_face_grad_phi_field;
+
+          std::vector<Tensor<1,dim>> old_velocity_values;
+          std::vector<Tensor<1,dim>> old_old_velocity_values;
+
+          std::vector<double>         old_pressure;
+          std::vector<double>         old_old_pressure;
+          std::vector<Tensor<1,dim>> old_pressure_gradients;
+          std::vector<Tensor<1,dim>> old_old_pressure_gradients;
+
+          std::vector<SymmetricTensor<2,dim>> old_strain_rates;
+          std::vector<SymmetricTensor<2,dim>> old_old_strain_rates;
+
+          std::vector<double>         old_temperature_values;
+          std::vector<double>         old_old_temperature_values;
+
+          std::vector<double>         old_field_values;
+          std::vector<double>         old_old_field_values;
+          std::vector<Tensor<1,dim>> old_field_grads;
+          std::vector<Tensor<1,dim>> old_old_field_grads;
+          std::vector<double>         old_field_laplacians;
+          std::vector<double>         old_old_field_laplacians;
+
+          std::vector<std::vector<double>> old_composition_values;
+          std::vector<std::vector<double>> old_old_composition_values;
+
+          std::vector<double>         current_temperature_values;
+          std::vector<Tensor<1,dim>> current_velocity_values;
+          std::vector<Tensor<1,dim>> face_current_velocity_values;
+          std::vector<Tensor<1,dim>> mesh_velocity_values;
+          std::vector<Tensor<1,dim>> face_mesh_velocity_values;
+
+          std::vector<SymmetricTensor<2,dim>> current_strain_rates;
+          std::vector<std::vector<double>> current_composition_values;
+          std::vector<double>         current_velocity_divergences;
+
+          /**
+           * Material model inputs and outputs computed at the current
+           * linearization point.
+           */
+          MaterialModel::MaterialModelInputs<dim> material_model_inputs;
+          MaterialModel::MaterialModelOutputs<dim> material_model_outputs;
+
+          MaterialModel::MaterialModelInputs<dim> face_material_model_inputs;
+          MaterialModel::MaterialModelOutputs<dim> face_material_model_outputs;
+
+          MaterialModel::MaterialModelInputs<dim> neighbor_face_material_model_inputs;
+          MaterialModel::MaterialModelOutputs<dim> neighbor_face_material_model_outputs;
+
+          /**
+           * Heating model outputs computed at the quadrature points of the
+           * current cell at the time of the current linearization point.
+           * As explained in the class documentation of
+           * HeatingModel::HeatingModelOutputs each term contains the sum of all
+           * enabled heating mechanism contributions.
+           */
+          HeatingModel::HeatingModelOutputs heating_model_outputs;
+          HeatingModel::HeatingModelOutputs face_heating_model_outputs;
+          HeatingModel::HeatingModelOutputs neighbor_face_heating_model_outputs;
+
+          /**
+           * This pointer contains a struct that can be used to identify the
+           * advection field that is currently assembled. It can be used to
+           * determine between temperature and the available compositional
+           * fields. See the documentation of the AdvectionField class for
+           * more details.
+           */
+          const typename Simulator<dim>::AdvectionField *advection_field;
+
+          /**
+           * The amount of entropy viscosity that should be applied to the
+           * current cell to stabilize the solution of the advection system.
+           */
+          double artificial_viscosity;
+        };
+      }
+
+
+
+      /**
+       * The CopyData arrays are similar to the Scratch arrays except they are
+       * meant as containers for the output of assembler objects. They provide a
+       * constructor and some data objects for local matrix, local vectors and
+       * the relation between local and global degrees of freedom (a.k.a.
+       * <code>local_dof_indices</code>). After all assemblers are finished
+       * the objects contain the local contributions of a particular cell to
+       * the global matrix and right hand side. This copy data object is then
+       * handed over to one of the <code>copy_local_to_global...</code>
+       * functions in assembly.cc that copy their content to the global matrix
+       * and right hand side vector.
+       */
+      namespace CopyData
+      {
+        /**
+         * The base class is empty and only allows us to hand over pointers
+         * or references of a generic type and later cast them to their actual
+         * derived class.
+         */
+        template <int dim>
+        struct CopyDataBase
+        {
+          virtual ~CopyDataBase () = default;
+        };
+
+        /**
+         * The Stokes preconditioner object only requires the bare minimum of
+         * copy data objects. Matrix contributions and degrees of freedom this
+         * cell corresponds to.
+         */
+        template <int dim>
+        struct StokesPreconditioner: public CopyDataBase<dim>
+        {
+          StokesPreconditioner (const unsigned int stokes_dofs_per_cell);
+
+          StokesPreconditioner (const StokesPreconditioner &data);
+
+          ~StokesPreconditioner () override = default;
+          StokesPreconditioner<dim> &operator= (const StokesPreconditioner<dim> &data) = default;
+
+          FullMatrix<double> local_matrix;
+          Vector<double> local_inverse_lumped_mass_matrix;
+          std::vector<types::global_dof_index> local_dof_indices;
+
+          /**
+           * Extract the values listed in @p all_dof_indices only if
+           * it corresponds to the Stokes component and copy it to the variable
+           * local_dof_indices declared above in the same class as this function
+          */
+          void extract_stokes_dof_indices(const std::vector<types::global_dof_index> &all_dof_indices,
+                                          const Introspection<dim>                   &introspection,
+                                          const FiniteElement<dim>                   &finite_element);
+        };
+
+        /**
+         * Similar to the scratch object the Stokes system requires all
+         * data from the Stokes preconditioner copy data class, plus some
+         * extras like the right hand side contribution.
+         */
+        template <int dim>
+        struct StokesSystem : public StokesPreconditioner<dim>
+        {
+          StokesSystem (const unsigned int        stokes_dofs_per_cell,
+                        const bool                do_pressure_rhs_compatibility_modification);
+          StokesSystem (const StokesSystem<dim> &data);
+
+          ~StokesSystem () override = default;
+          StokesSystem<dim> &operator= (const StokesSystem<dim> &data) = default;
+
+          Vector<double> local_rhs;
+          Vector<double> local_pressure_shape_function_integrals;
+        };
+
+        /**
+         * Additionally to the Stokes system the Advection system copy data
+         * object also needs to keep track of contributions across faces
+         * (mostly for discontinuous elements that contain DG terms).
+         */
+        template <int dim>
+        struct AdvectionSystem: public CopyDataBase<dim>
+        {
+          /**
+           * Constructor.
+           *
+           * @param finite_element The element that describes the field for
+           *    which we are trying to assemble a linear system. <b>Not</b>
+           *    the global finite element.
+           * @param field_is_discontinuous If true, the field is a DG element.
+           */
+          AdvectionSystem (const FiniteElement<dim> &finite_element,
+                           const bool                field_is_discontinuous);
+
+          /**
+           * Local contributions to the global matrix
+           * that correspond only to the variables listed in local_dof_indices
+           */
+          FullMatrix<double>          local_matrix;
+
+          /**
+           * Local contributions to the global matrix from the face terms in the
+           * discontinuous Galerkin method. These arrays are of a length sufficient
+           * to hold one matrix for each possible face or subface of the cell.
+           * The discontinuous Galerkin bilinear form contains terms arising from
+           * internal (to the cell) values and external (to the cell) values.
+           * `_int_ext` and `_ext_int` hold the terms arising from the pairing
+           * between a cell and its neighbor, while `_ext_ext` is the pairing
+           * of the neighbor's dofs with themselves. In the continuous
+           * Galerkin case, these are unused, and set to size zero.
+           */
+          std::vector<FullMatrix<double>>         local_matrices_int_ext;
+          std::vector<FullMatrix<double>>         local_matrices_ext_int;
+          std::vector<FullMatrix<double>>         local_matrices_ext_ext;
+
+          /**
+           * Local contributions to the right hand side
+           * that correspond only to the variables listed in local_dof_indices
+           */
+          Vector<double>              local_rhs;
+
+          /**
+           * Denotes which face matrices have actually been assembled in the DG field
+           * assembly. Entries for matrices not used (for example, those corresponding
+           * to non-existent subfaces; or faces being assembled by the neighboring cell)
+           * are set to false.
+           */
+          std::vector<bool>               assembled_matrices;
+
+          /**
+           * Indices of those degrees of freedom that actually correspond
+           * to the temperature or compositional field. since this structure
+           * is used to represent just contributions to the advection
+           * systems, there will be no contributions to other parts of the
+           * system and consequently, we do not need to list here indices
+           * that correspond to velocity or pressure degrees (or, in fact
+           * any other variable outside the block we are currently considering)
+           */
+          std::vector<types::global_dof_index>   local_dof_indices;
+
+          /**
+           * Indices of the degrees of freedom corresponding to the temperature
+           * or composition field on all possible neighboring cells. This is used
+           * in the discontinuous Galerkin method. The outer array has a
+           * length sufficient to hold one element for each possible face
+           * and sub-face of the current cell. The object is not used
+           * and has size zero if in the continuous Galerkin case.
+           */
+          std::vector<std::vector<types::global_dof_index>>   neighbor_dof_indices;
+        };
+      }
+    }
+  }
+
+  /**
+   * A namespace for the definition of assemblers for the various terms in the
+   * linear systems ASPECT solves.
+   */
+  namespace Assemblers
+  {
+
+    /**
+     * For a reference cell (which is typically obtained by asking the finite
+     * element to be used), determine how many interface matrices are needed.
+     * Since interface matrices are needed for as many neighbors as each
+     * cell can have, this is the number of faces for the given reference cell
+     * times the number of children each of these faces can have. This
+     * accommodates the fact that the neighbors of a cell can all be refined,
+     * though they can only be refined once.
+     */
+    unsigned int
+    n_interface_matrices (const ReferenceCell &reference_cell);
+
+    /**
+     * For a given reference cell, and a given face we are currently
+     * assembling on, return which element of an array of size
+     * `n_interface_matrices(reference_cell)` to use.
+     */
+    unsigned int
+    nth_interface_matrix (const ReferenceCell &reference_cell,
+                          const unsigned int face);
+
+    /**
+     * For a given reference cell, and a given face and sub-face we are
+     * currently assembling on, return which element of an array of size
+     * `n_interface_matrices(reference_cell)` to use.
+     */
+    unsigned int
+    nth_interface_matrix (const ReferenceCell &reference_cell,
+                          const unsigned int face,
+                          const unsigned int sub_face);
+
+    /**
+     * A base class for objects that implement assembly
+     * operations.
+     *
+     * The point of this class is primarily so that we can store
+     * pointers to such objects in a list. The objects are created
+     * in Simulator::set_assemblers() and destroyed in the destructor of
+     * the Simulator object. Derived classes of this base class usually
+     * handle groups of terms in the equations that are
+     * logically connected (such as all terms in the Stokes equations that
+     * appear independent on the selected compressibility formulation). This
+     * way selecting a certain set of assembler objects effectively controls
+     * which equation is solved.
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Execute this assembler object. This function performs the primary work
+         * of an assembler. More precisely, it uses information for the current
+         * cell that is stored in @p scratch (like the material properties on
+         * this cell and the position of quadrature points) and computes the
+         * matrix and right hand side contributions for a set of terms for
+         * the given cell. These contributions are stored in @p data. Note, that
+         * the data in @p scratch and @p data is shared between all active
+         * assemblers so that each assembler should only add contributions to
+         * @p data, not overwrite entries in the matrix. After all assemblers
+         * have finished, the final content of @p data is distributed into the
+         * global matrix and right hand side vector.
+         */
+        virtual
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim> &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const = 0;
+
+        /**
+         * This function gets called if a MaterialModelOutputs is created
+         * and allows the assembler to attach AdditionalOutputs. The
+         * function might be called more than once for a
+         * MaterialModelOutput, so it is recommended to check if
+         * get_additional_output() returns an instance before adding a new
+         * one to the additional_outputs vector. By default this function does
+         * not create additional outputs.
+         *
+         * Material models, through functions derived from
+         * MaterialModel::Interface::evaluate(), put their computed material
+         * parameters into a structure of type MaterialModel::MaterialModelOutputs.
+         * By default, material models will compute those parameters that
+         * correspond to the member variables of that structure. However,
+         * there are situations where parts of the simulator need additional
+         * pieces of information; a typical example would be the use of a
+         * Newton scheme that also requires the computation of <i>derivatives</i>
+         * of material parameters with respect to pressure, temperature, and
+         * possibly other variables.
+         *
+         * The computation of such additional information is controlled by
+         * the presence of a collection of pointers in
+         * MaterialModel::MaterialModelOutputs that point to additional
+         * objects. Whether or not one needs these additional objects depends
+         * on what assemblers are selected, or what postprocessing one
+         * wants to compute. For the purpose of assembly, the current
+         * function creates the additional objects (such as the one that stores
+         * derivatives) and adds pointers to them to the collection, based on
+         * what this assembler class requires. This function is always called
+         * before the material model is evaluated and execute() is called.
+         * This ensures the additional material model output is available when
+         * execute() is called.
+         */
+        virtual
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &) const;
+
+        /**
+         * A required function for objects that implement the assembly of terms
+         * in an equation that requires the computation of residuals
+         * (in particular the advection equation in ASPECT).
+         * Just like the assemblers itself, the residual
+         * that we use to compute the necessary entropy viscosity depend on the
+         * equation (i.e. which terms are actually included in the
+         * equation). Thus different objects compute different residuals (i.e.
+         * the residual for a melt advection equation looks different from the
+         * residual for a passive compositional field).
+         * For assemblers for the Stokes system, an implementation of this
+         * function is not necessary.
+         */
+        virtual
+        std::vector<double>
+        compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &) const;
+    };
+
+
+
+    /**
+     * A base class for objects that implement assembly
+     * operations for advection-diffusion problems.
+     *
+     * This class implements functions that provide information
+     * for stabilization mechanisms.
+     */
+    template <int dim>
+    class AdvectionStabilizationInterface
+    {
+      public:
+        virtual ~AdvectionStabilizationInterface ();
+
+        /**
+         * This function returns a representative prefactor for the advection
+         * term of the equation for each quadrature point of the current cell.
+         * In the non-dimensional case this is simply 1.0, but for other
+         * quantities like temperature it is computed using physical units
+         * (like density and specific heat capacity).
+         * This information is useful for algorithms that depend on the
+         * magnitude of individual terms, like stabilization methods.
+         */
+        virtual
+        std::vector<double>
+        advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const;
+
+        /**
+         * This function returns a representative conductivity for the
+         * diffusion part of the equation for each quadrature point of the
+         * current cell. For the pure advection case this factor is 0.0, but
+         * for other quantities like temperature it is
+         * computed using physical units (like thermal conductivity).  This
+         * information is useful for algorithms depending on the magnitude of
+         * individual terms, like stabilization methods.
+         */
+        virtual
+        std::vector<double>
+        diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const;
+    };
+
+
+
+    /**
+     * A class that owns member variables representing
+     * all assemblers that need to be called when
+     * assembling right hand side vectors, matrices, or complete linear
+     * systems. We use this approach in order to support the following
+     * cases:
+     * - Assembling different formulations: When assembling either the
+     *   full equations or only the Boussinesq approximation (to give just
+     *   two examples), one needs different terms. This could be achieved
+     *   using a large number of <code>switch</code> or <code>if</code>
+     *   statements in the code, or one could encapsulate each equation
+     *   or approximation into a collection of assemblers for this particular
+     *   purpose. The approach chosen here in essence allows the
+     *   implementation of each set of equations in its own scope, and we
+     *   then just need to store a pointer to the object that
+     *   assembles the Stokes system (for example) for the selected
+     *   approximation. The pointer to this function is stored in the
+     *   appropriate member variable of this class.
+     * - Sometimes, we want to assemble a number of terms that build on
+     *   each other. An example is the addition of free boundary terms
+     *   to the Stokes matrix. Rather than having to "know" in one
+     *   place about all of the terms that need to be assembled,
+     *   we simply add the function that computes these terms as
+     *   another object to the appropriate set of assemblers declared
+     *   in this class.
+     */
+    template <int dim>
+    class Manager
+    {
+      public:
+
+        /**
+         * Reset the state of the manager and remove all Assemblers.
+         */
+        void reset ();
+
+        /**
+         * A vector of pointers containing all assemblers for the Stokes preconditioner.
+         * These assemblers are called once per cell.
+         */
+        std::vector<std::unique_ptr<Assemblers::Interface<dim>>> stokes_preconditioner;
+
+        /**
+         * A vector of pointers containing all assemblers that compute
+         * cell contributions for the Stokes system.
+         * These assemblers are called once per cell.
+         */
+        std::vector<std::unique_ptr<Assemblers::Interface<dim>>> stokes_system;
+
+        /**
+         * A vector of pointers containing all assemblers that compute face
+         * contributions for the Stokes system. These assemblers are called
+         * once per face at a boundary with the properly initialized inputs,
+         * therefore they allow terms that only exist on boundary faces (e.g.
+         * traction boundary conditions).
+         */
+        std::vector<std::unique_ptr<Assemblers::Interface<dim>>> stokes_system_on_boundary_face;
+
+        /**
+         * A vector of vectors of pointers containing a list of all assemblers
+         * for each individual advection system.
+         * These assemblers are called once per cell.
+         */
+        std::vector<std::vector<std::unique_ptr<Assemblers::Interface<dim>>>> advection_system;
+
+        /**
+         * A vector of vectors of pointers containing a list of all assemblers
+         * for the individual advection systems that compute face contributions
+         * at boundaries. These assemblers are called once per boundary face with
+         * the properly initialized inputs, therefore they allow terms that only
+         * exist on boundary faces (e.g. flux boundary conditions).
+         */
+        std::vector<std::vector<std::unique_ptr<Assemblers::Interface<dim>>>> advection_system_on_boundary_face;
+
+        /**
+         * A vector of vectors of pointers containing a list of all assemblers
+         * for the individual advection systems that compute face contributions
+         * on faces between cells. These assemblers are called once per interior
+         * face with the properly initialized inputs, therefore they allow terms
+         * that only exist on interior faces (e.g. DG penalty terms).
+         */
+        std::vector<std::vector<std::unique_ptr<Assemblers::Interface<dim>>>> advection_system_on_interior_face;
+
+        /**
+         * A structure that describes what information an assembler function
+         * (listed as one of the assembler objects above) may need to operate.
+         *
+         * There are a number of pieces of information that are always
+         * assumed to be needed. For example, the Stokes and advection
+         * assemblers will always need to have access to the material
+         * model outputs. But the Stokes assembler may or may not need
+         * access to material model outputs for quadrature points on faces.
+         *
+         * These properties are all preset in a conservative way
+         * (i.e., disabled) in the constructor of this class, but can
+         * be enabled in Simulator::set_assemblers() when adding
+         * individual assemblers. Functions such as
+         * Simulator::local_assemble_stokes_preconditioner(),
+         * Simulator::local_assemble_stokes_system() will then query
+         * these flags to determine whether something has to be
+         * initialized for at least one of the assemblers they call.
+         */
+        struct Properties
+        {
+          /**
+           * Constructor. Disable all properties as described in the
+           * class documentation.
+           */
+          Properties ();
+
+          /**
+           * Whether or not at least one of the active assembler objects for
+           * a certain equation requires the initialization and re-computation
+           * of a MaterialModelOutputs object for each face. This
+           * property is only relevant to assemblers that operate on
+           * faces.
+           */
+          bool need_face_material_model_data;
+
+          /**
+           * Whether or not at least one of the active assembler objects for
+           * a certain equation requires the evaluation of the FEFaceValues
+           * object. This is different from need_face_material_model_data,
+           * because an assembler might assemble terms that do not require
+           * material model outputs.
+           */
+          bool need_face_finite_element_evaluation;
+
+          /**
+           * Whether or not at least one of the active assembler objects for
+           * a certain equation requires the computation of the viscosity.
+           */
+          bool need_viscosity;
+
+          /**
+           * A list of FEValues UpdateFlags that are necessary for
+           * a given operation. Assembler objects may add to this list
+           * as necessary; it will be initialized with a set of
+           * "default" flags that will always be set.
+           */
+          UpdateFlags needed_update_flags;
+        };
+
+        /**
+         * Lists of properties for the various equations we want to assemble.
+         * These property lists are set in Simulator::set_assemblers()
+         * where we add individual functions to the vectors of assembler
+         * objects above.
+         */
+        Properties stokes_preconditioner_assembler_properties;
+        Properties stokes_system_assembler_properties;
+        Properties stokes_system_assembler_on_boundary_face_properties;
+        std::vector<Properties> advection_system_assembler_properties;
+        std::vector<Properties> advection_system_assembler_on_face_properties;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/simulator/assemblers/stokes.h.bak b/include/aspect/simulator/assemblers/stokes.h.bak
new file mode 100644
index 00000000000..6ffe27fd8f3
--- /dev/null
+++ b/include/aspect/simulator/assemblers/stokes.h.bak
@@ -0,0 +1,224 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_simulator_assemblers_stokes_h
+#define _aspect_simulator_assemblers_stokes_h
+
+
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    /**
+     * A class containing the functions to assemble the Stokes preconditioner.
+     */
+    template <int dim>
+    class StokesPreconditioner : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * A class containing the functions to assemble the compressible adjustment
+     * to the Stokes preconditioner.
+     */
+    template <int dim>
+    class StokesCompressiblePreconditioner : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the terms for the matrix and right-hand-side of the incompressible
+     * Stokes equation for the current cell.
+     */
+    template <int dim>
+    class StokesIncompressibleTerms : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+
+        /**
+         * Create AdditionalMaterialOutputsStokesRHS if we need to do so.
+         */
+        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
+    };
+
+    /**
+     * This class assembles the term that arises in the viscosity term of Stokes matrix for
+     * compressible models, because the divergence of the velocity is not longer zero.
+     */
+    template <int dim>
+    class StokesCompressibleStrainRateViscosityTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the compressibility term of the Stokes equation
+     * that is caused by the compressibility in the mass conservation equation.
+     * It uses an approximation that involves the reference density profile, and
+     * includes this term explicitly in the right-hand side vector to preserve
+     * the symmetry of the matrix.
+     * This class approximates this term as
+     * $- \nabla \cdot \mathbf{u} = \frac{1}{\rho^{\ast}} \frac{\partial rho}{\partial z} \frac{\mathbf{g}}{||\mathbf{g}||} \cdot \mathbf{u}$
+     */
+    template <int dim>
+    class StokesReferenceDensityCompressibilityTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the compressibility term of the Stokes equation
+     * that is caused by the compressibility in the mass conservation equation.
+     * It uses an approximation that involves the reference density profile, and
+     * includes this term implicitly in the matrix,
+     * which is therefore not longer symmetric.
+     * This class approximates this term as
+     * $ - \nabla \cdot \mathbf{u} - \frac{1}{\rho^{\ast}} \frac{\partial rho{^\ast}}{\partial z} \frac{\mathbf{g}}{||\mathbf{g}||} \cdot \mathbf{u} = 0$
+     */
+    template <int dim>
+    class StokesImplicitReferenceDensityCompressibilityTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the right-hand-side term of the Stokes equation
+     * that is caused by the compressibility in the mass conservation equation.
+     * This class approximates this term as
+     * $ - \nabla \cdot \mathbf{u} = \kappa \rho \mathbf{g} \cdot \mathbf{u}$
+     * where $\kappa$ is the compressibility provided by the material model,
+     * which is frequently computed as
+     * $\kappa = \frac{1}{\rho} \frac{\partial rho}{\partial p}$.
+     */
+    template <int dim>
+    class StokesIsentropicCompressionTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the right-hand-side term of the Stokes equation
+     * that is caused by the variable density in the mass conservation equation.
+     * This class approximates this term as
+     * $ - \nabla \cdot \mathbf{u} = \frac{1}{\rho} \frac{\partial \rho}{\partial t} + \frac{1}{\rho} \nabla \rho \cdot \mathbf{u}$
+     * where the right-hand side velocity is explicitly taken from the last timestep,
+     * and the density is taken from a compositional field of the type 'density'.
+     */
+    template <int dim>
+    class StokesProjectedDensityFieldTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
+    };
+
+
+    /**
+     * This class assembles the right-hand-side term of the Stokes equation
+     * that is caused by the compression based on the changes in (hydrostatic)
+     * pressure and temperature in the mass conservation equation.
+     *
+     * This class approximates this term as
+     * $ -\nabla \cdot \mathbf{u} = \left( \kappa \rho \textbf{g} - \alpha \nabla T \right) \cdot \textbf{u}$
+     *
+     * where $\frac{1}{\rho} \frac{\partial \rho}{\partial p} = \kappa$ is the compressibility,
+     * $- \frac{1}{\rho}\frac{\partial \rho}{\partial T} = \alpha$ is the thermal expansion coefficient,
+     * and both are defined in the material model.
+     */
+    template <int dim>
+    class StokesHydrostaticCompressionTerm : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class assembles the right-hand-side terms that are used to weakly
+     * prescribe the boundary tractions.
+     */
+    template <int dim>
+    class StokesBoundaryTraction : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+
+    /**
+     * This class computes the local pressure shape function integrals that
+     * are later used to make the Stokes equations compatible to its right hand
+     * side. For more information why this is necessary see Section 3.2.2 of
+     * Heister et al. (2017), "High Accuracy Mantle Convection Simulation
+     * through Modern Numerical Methods. II: Realistic Models and Problems."
+     */
+    template <int dim>
+    class StokesPressureRHSCompatibilityModification : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/simulator_access.h.bak b/include/aspect/simulator_access.h.bak
new file mode 100644
index 00000000000..999a22a6980
--- /dev/null
+++ b/include/aspect/simulator_access.h.bak
@@ -0,0 +1,1002 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_simulator_access_h
+#define _aspect_simulator_access_h
+
+#include <aspect/global.h>
+#include <aspect/parameters.h>
+#include <aspect/introspection.h>
+
+#include <deal.II/base/table_handler.h>
+#include <deal.II/base/timer.h>
+#include <deal.II/base/conditional_ostream.h>
+#include <deal.II/distributed/tria.h>
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/fe/fe.h>
+#include <deal.II/fe/mapping_q.h>
+#include <deal.II/lac/affine_constraints.h>
+
+namespace WorldBuilder
+{
+  class World;
+}
+
+namespace aspect
+{
+  using namespace dealii;
+
+  // forward declarations:
+  template <int dim> class Simulator;
+  template <int dim> struct SimulatorSignals;
+  template <int dim> class LateralAveraging;
+  template <int dim> struct RotationProperties;
+
+  namespace GravityModel
+  {
+    template <int dim> class Interface;
+  }
+
+  namespace HeatingModel
+  {
+    template <int dim> class Manager;
+  }
+
+  namespace MaterialModel
+  {
+    template <int dim> class Interface;
+  }
+
+  namespace InitialTemperature
+  {
+    template <int dim> class Manager;
+    template <int dim> class Interface;
+  }
+
+  namespace BoundaryTemperature
+  {
+    template <int dim> class Manager;
+    template <int dim> class Interface;
+  }
+
+  namespace BoundaryHeatFlux
+  {
+    template <int dim> class Interface;
+  }
+
+  namespace BoundaryComposition
+  {
+    template <int dim> class Manager;
+    template <int dim> class Interface;
+  }
+
+  namespace BoundaryTraction
+  {
+    template <int dim> class Manager;
+    template <int dim> class Interface;
+  }
+
+  namespace BoundaryVelocity
+  {
+    template <int dim> class Manager;
+    template <int dim> class Interface;
+  }
+
+  namespace InitialComposition
+  {
+    template <int dim> class Manager;
+    template <int dim> class Interface;
+  }
+
+  namespace InitialTopographyModel
+  {
+    template <int dim> class Interface;
+  }
+
+  namespace MeshRefinement
+  {
+    template <int dim> class Manager;
+  }
+
+  namespace AdiabaticConditions
+  {
+    template <int dim> class Interface;
+  }
+
+  namespace Postprocess
+  {
+    template <int dim> class Manager;
+  }
+
+  template <int dim> class MeltHandler;
+  template <int dim> class VolumeOfFluidHandler;
+
+  namespace MeshDeformation
+  {
+    template <int dim> class MeshDeformationHandler;
+  }
+
+  template <int dim> class NewtonHandler;
+
+  template <int dim> class StokesMatrixFreeHandler;
+
+  namespace Particle
+  {
+    template <int dim> class World;
+  }
+
+  namespace TimeStepping
+  {
+    template <int dim> class Manager;
+  }
+
+  /**
+   * SimulatorAccess is a base class for different plugins like postprocessors.
+   * It provides access to the various variables of the main class that
+   * plugins may want to use in their evaluations, such as solution vectors,
+   * the current time, time step sizes, material models, or the triangulations
+   * and DoFHandlers that correspond to solutions.
+   *
+   * This class is the interface between plugins and the main simulator class.
+   * Using this insulation layer, the plugins need not know anything about the
+   * internal details of the simulation class.
+   *
+   * Every Postprocessor is required to derive from SimulatorAccess. It is
+   * optional for other plugins like MaterialModel, GravityModel, etc..
+   *
+   * Since the functions providing access to details of the simulator class
+   * are meant to be used only by derived classes of this class (rather than
+   * becoming part of the public interface of these classes), the functions of
+   * this class are made @p protected.
+   *
+   * @ingroup Simulator
+   */
+  template <int dim>
+  class SimulatorAccess
+  {
+    public:
+      /**
+       * Default constructor. Initialize the SimulatorAccess object without
+       * a reference to a particular Simulator object. You will later have
+       * to call initialize() to provide this reference to the Simulator
+       * object.
+       */
+      SimulatorAccess ();
+
+      /**
+       * Create a SimulatorAccess object that is already initialized for
+       * a particular Simulator.
+       */
+      SimulatorAccess (const Simulator<dim> &simulator_object);
+
+      /**
+       * Destructor. Does nothing but is virtual so that derived classes
+       * destructors are also virtual.
+       */
+      virtual ~SimulatorAccess () = default;
+
+      /**
+       * Initialize this class for a given simulator. This function is marked
+       * as virtual so that derived classes can do something upon
+       * initialization as well, for example look up and cache data; derived
+       * classes should call this function from the base class as well,
+       * however.
+       *
+       * @param simulator_object A reference to the main simulator object.
+       */
+      virtual void initialize_simulator (const Simulator<dim> &simulator_object);
+
+      /** @name Accessing variables that identify overall properties of the simulator */
+      /** @{ */
+
+      /**
+       * Return a reference to an introspection object that describes overall
+       * properties of the simulator. In particular, it provides symbolic
+       * names for extractors and component masks for each variable, etc, and
+       * thereby reduces the need for implicit knowledge throughout the code
+       * base.
+       */
+      const Introspection<dim> &
+      introspection () const;
+
+      /**
+       * Return a reference to the Simulator itself. Note that you can not
+       * access any members or functions of the Simulator. This function
+       * exists so that any class with SimulatorAccess can create other
+       * objects with SimulatorAccess (because initializing them requires a
+       * reference to the Simulator).
+       */
+      const Simulator<dim> &
+      get_simulator () const;
+
+      /**
+       * Return a reference to the parameters object that describes all run-time
+       * parameters used in the current simulation.
+       */
+      const Parameters<dim> &
+      get_parameters () const;
+
+      /**
+       * Get Access to the structure containing the signals of the simulator.
+       */
+      SimulatorSignals<dim> &
+      get_signals() const;
+
+      /**
+       * Return the MPI communicator for this simulation.
+       */
+      MPI_Comm
+      get_mpi_communicator () const;
+
+      /**
+       * Return the timer object for this simulation. Since the timer is
+       * mutable in the Simulator class, this allows plugins to define their
+       * own sections in the timer to measure the time spent in sections of
+       * their code.
+       */
+      TimerOutput &
+      get_computing_timer () const;
+
+      /**
+       * Return a reference to the stream object that only outputs something
+       * on one processor in a parallel program and simply ignores output put
+       * into it on all other processors.
+       */
+      const ConditionalOStream &
+      get_pcout () const;
+
+      /**
+       * Return the current simulation time in seconds.
+       */
+      double get_time () const;
+
+      /**
+       * Return the size of the current time step.
+       */
+      double
+      get_timestep () const;
+
+      /**
+       * Return the size of the last time step.
+       */
+      double
+      get_old_timestep () const;
+
+      /**
+       * Return the current number of a time step.
+       */
+      unsigned int
+      get_timestep_number () const;
+
+      /**
+       * Return a reference to the manager of the time stepping strategies.
+       * This can then be used, for example, to check whether a checkpoint needs to
+       * be made upon termination.
+       */
+      const TimeStepping::Manager<dim> &
+      get_timestepping_manager() const;
+
+      /**
+       * Return the current nonlinear iteration number of a time step.
+       */
+      unsigned int
+      get_nonlinear_iteration () const;
+
+      /**
+       * Return a reference to the triangulation in use by the simulator
+       * object.
+       */
+      const parallel::distributed::Triangulation<dim> &
+      get_triangulation () const;
+
+      /**
+       * Return the global volume of the computational domain.
+       */
+      double
+      get_volume () const;
+
+      /**
+       * Return a reference to the mapping used to describe the boundary of
+       * the domain.
+       */
+      const Mapping<dim> &
+      get_mapping () const;
+
+      /**
+       * Return the directory specified in the input parameter file to be the
+       * place where output files are to be placed. The string is terminated
+       * by a directory separator (i.e., '/').
+       */
+      std::string
+      get_output_directory () const;
+
+      /**
+       * Return whether we use the adiabatic heating term.
+       */
+      bool
+      include_adiabatic_heating () const;
+
+      /**
+       * Return whether we use the latent heat term.
+       */
+      bool
+      include_latent_heat () const;
+
+      /**
+       * Return whether we solve the equations for melt transport.
+       */
+      bool
+      include_melt_transport () const;
+
+      /**
+       * Return the stokes velocity degree.
+       */
+      int
+      get_stokes_velocity_degree () const;
+
+      /**
+       * Return the adiabatic surface temperature.
+       */
+      double
+      get_adiabatic_surface_temperature () const;
+
+      /**
+       * Return the adiabatic surface pressure.
+       */
+      double
+      get_surface_pressure () const;
+
+      /**
+       * Return whether things like velocities should be converted from the
+       * seconds in the MKS system to years. The value of this flag is set by
+       * the corresponding entry in the input parameter file.
+       */
+      bool
+      convert_output_to_years () const;
+
+      /**
+       * Return the number of the current pre refinement step.
+       * This can be useful for plugins that want to function differently in
+       * the initial adaptive refinements and later on.
+       * This will be not initialized before Simulator<dim>::run() is called.
+       * It iterates upward from 0 to parameters.initial_adaptive_refinement
+       * during the initial adaptive refinement steps, and equals
+       * std::numeric_limits<unsigned int>::max() afterwards.
+       */
+      unsigned int
+      get_pre_refinement_step () const;
+
+      /**
+       * Return the number of compositional fields specified in the input
+       * parameter file that will be advected along with the flow field.
+       */
+      unsigned int
+      n_compositional_fields () const;
+
+      /**
+       * Return the simulation end time in seconds.
+       */
+      double
+      get_end_time () const;
+
+      /**
+       * Compute the error indicators in the same way they are normally used
+       * for mesh refinement. The mesh is not refined when doing so, but the
+       * indicators can be used when generating graphical output to check why
+       * mesh refinement is proceeding as it is.
+       */
+      void
+      get_refinement_criteria(Vector<float> &estimated_error_per_cell) const;
+
+      /**
+       * Returns the entropy viscosity on each locally owned cell as it is
+       * used to stabilize the temperature equation.
+       *
+       * @param viscosity_per_cell Output vector with as many entries as
+       * active cells. Each entry corresponding to a locally owned active
+       * cell index will contain the artificial viscosity for this cell.
+       * @param skip_interior_cells A boolean flag. If set to true the function
+       * will only compute the artificial viscosity in cells at boundaries.
+       */
+      void
+      get_artificial_viscosity(Vector<float> &viscosity_per_cell,
+                               const bool skip_interior_cells = false) const;
+
+      /**
+       * Returns the entropy viscosity on each locally owned cell as it is
+       * used to stabilize the composition equation.
+       */
+      void
+      get_artificial_viscosity_composition(Vector<float> &viscosity_per_cell,
+                                           const unsigned int compositional_variable) const;
+
+      /**
+       * Compute the KXRCF indicator on each locally owned cell for a specific
+       * advection field.
+       */
+      void
+      compute_KXRCF_indicators(Vector<float> &KXRCF_indicators,
+                               const unsigned int field_index) const;
+      /** @} */
+
+
+      /** @name Accessing variables that identify the solution of the problem */
+      /** @{ */
+
+      /**
+       * Return a reference to the vector that has the current linearization
+       * point of the entire system, i.e. the velocity and pressure variables
+       * as well as the temperature and compositional fields. This vector is
+       * associated with the DoFHandler object returned by get_dof_handler().
+       * This vector is only different from the one returned by get_solution()
+       * during the solver phase.
+       *
+       * @note In general the vector is a distributed vector; however, it
+       * contains ghost elements for all locally relevant degrees of freedom.
+       */
+      const LinearAlgebra::BlockVector &
+      get_current_linearization_point () const;
+
+      /**
+       * Return a reference to the vector that has the current solution of the
+       * entire system, i.e. the velocity and pressure variables as well as
+       * the temperature and compositional fields.
+       * This vector is associated with the DoFHandler object returned by
+       * get_dof_handler().
+       *
+       * @note In general the vector is a distributed vector; however, it
+       * contains ghost elements for all locally relevant degrees of freedom.
+       */
+      const LinearAlgebra::BlockVector &
+      get_solution () const;
+
+      /**
+       * Return a reference to the vector that has the solution of the entire
+       * system at the previous time step. This vector is associated with the
+       * DoFHandler object returned by get_stokes_dof_handler().
+       *
+       * @note In general the vector is a distributed vector; however, it
+       * contains ghost elements for all locally relevant degrees of freedom.
+       */
+      const LinearAlgebra::BlockVector &
+      get_old_solution () const;
+
+      /**
+       * Return a reference to the vector that has the solution of the entire
+       * system at the second-to-last time step. This vector is associated with the
+       * DoFHandler object returned by get_stokes_dof_handler().
+       *
+       * @note In general the vector is a distributed vector; however, it
+       * contains ghost elements for all locally relevant degrees of freedom.
+       */
+      const LinearAlgebra::BlockVector &
+      get_old_old_solution () const;
+
+      /**
+       * Return a reference to the vector that has the reactions computed by the
+       * operator splitting scheme in the current time step.
+       *
+       * @note In general the vector is a distributed vector; however, it
+       * contains ghost elements for all locally relevant degrees of freedom.
+       */
+      const LinearAlgebra::BlockVector &
+      get_reaction_vector () const;
+
+      /**
+       * Return a reference to the vector that has the mesh velocity for
+       * simulations with mesh deformation.
+       *
+       * @note In general the vector is a distributed vector; however, it
+       * contains ghost elements for all locally relevant degrees of freedom.
+       */
+      const LinearAlgebra::BlockVector &
+      get_mesh_velocity () const;
+
+      /**
+       * Return a reference to the DoFHandler that is used to discretize the
+       * variables at the current time step.
+       */
+      const DoFHandler<dim> &
+      get_dof_handler () const;
+
+      /**
+       * Return a reference to the finite element that is
+       * used to discretize the variables at the current time step.
+       * This is the finite element for the entire, coupled problem, i.e.,
+       * it contains sub-elements for velocity, pressure, temperature and all
+       * other variables in this problem (e.g., compositional variables, if
+       * used in this simulation).
+       */
+      const FiniteElement<dim> &
+      get_fe () const;
+
+      /**
+       * Return a reference to the system matrix at the current time step.
+       */
+      const LinearAlgebra::BlockSparseMatrix &
+      get_system_matrix () const;
+
+      /**
+       * Return a reference to the system preconditioner matrix at the current time step.
+       */
+      const LinearAlgebra::BlockSparseMatrix &
+      get_system_preconditioner_matrix () const;
+
+      /** @} */
+
+
+      /** @name Accessing variables that identify aspects of the simulation */
+      /** @{ */
+
+      /**
+       * Return a pointer to the material model to access functions like
+       * density().
+       */
+      const MaterialModel::Interface<dim> &
+      get_material_model () const;
+
+      /**
+       * Return a pointer to the gravity model description.
+       */
+      const GravityModel::Interface<dim> &
+      get_gravity_model () const;
+
+      /**
+       * Return a pointer to the initial topography model.
+       */
+      const InitialTopographyModel::Interface<dim> &
+      get_initial_topography_model () const;
+
+      /**
+       * Return a pointer to the geometry model.
+       */
+      const GeometryModel::Interface<dim> &
+      get_geometry_model () const;
+
+
+      /**
+       * Return a pointer to the object that describes the adiabatic
+       * conditions.
+       */
+      const AdiabaticConditions::Interface<dim> &
+      get_adiabatic_conditions () const;
+
+      /**
+       * Return whether the current model has a boundary temperature object
+       * set. This is useful because a simulation does not actually have to
+       * declare any boundary temperature model, for example if all
+       * boundaries are insulating. In such cases, there is no
+       * boundary temperature model that can provide, for example,
+       * a minimal and maximal temperature on the boundary.
+       */
+      bool has_boundary_temperature () const;
+
+      /**
+       * Return an reference to the manager of the boundary temperature models.
+       * This can then, for example, be used to get the names of the initial temperature
+       * models used in a computation, or to compute the initial temperature
+       * for a given position.
+       */
+      const BoundaryTemperature::Manager<dim> &
+      get_boundary_temperature_manager () const;
+
+      /**
+       * Return a reference to the object that describes heat flux
+       * boundary conditions.
+       */
+      const BoundaryHeatFlux::Interface<dim> &
+      get_boundary_heat_flux () const;
+
+      /**
+       * Return whether the current model has a boundary composition object
+       * set. This is useful because a simulation does not actually have to
+       * declare any boundary composition model, for example if all
+       * boundaries are reflecting. In such cases, there is no
+       * boundary composition model.
+       */
+      bool has_boundary_composition () const;
+
+      /**
+       * Return an reference to the manager of the boundary composition models.
+       * This can then, for example, be used to get the names of the boundary composition
+       * models used in a computation, or to compute the boundary composition
+       * for a given position.
+       */
+      const BoundaryComposition::Manager<dim> &
+      get_boundary_composition_manager () const;
+
+      /**
+      * Return an reference to the manager of the boundary traction models.
+      * This can then, for example, be used to get the names of the boundary traction
+      * models used in a computation, or to compute the boundary traction
+      * for a given position.
+      */
+      const BoundaryTraction::Manager<dim> &
+      get_boundary_traction_manager () const;
+
+      /**
+       * Return a reference to the manager of the initial temperature models.
+       * This can then, for example, be used to get the names of the initial temperature
+       * models used in a computation, or to compute the initial temperature
+       * for a given position.
+       *
+       * While the Simulator class creates a shared pointer to an initial
+       * temperature manager before the first time step, it releases
+       * the pointer once it no longer needs access to the initial
+       * compositions. As a consequence, you can only call this function
+       * during the first time step.
+       *
+       * If the Simulator's shared pointer were the only
+       * one that points to the initial temperature manager object, that
+       * would also destroy the object pointed to. However, plugin classes
+       * can have member variables that are *also* shared pointers to
+       * these manager objects, and if you initialize such a shared
+       * pointer from the result of this function -- typically in the
+       * `initialize()` function of a plugin class -- then the Simulator
+       * giving up its shared pointer does not actually destroy the
+       * manager object but extends its lifetime until the last plugin
+       * that has a pointer to it is destroyed itself. As a consequence,
+       * if you need access to the initial temperature in a plugin, you
+       * will need to keep a shared pointer to it around for as long
+       * as you need it.
+       */
+      std::shared_ptr<const InitialTemperature::Manager<dim>>
+      get_initial_temperature_manager_pointer () const;
+
+      /**
+       * Return a reference to the manager of the initial temperature model.
+       * This can then, for example, be used to get the names of the initial temperature
+       * models used in a computation.
+       *
+       * While the Simulator class creates a shared pointer to an initial
+       * temperature manager before the first time step, it releases
+       * the pointer once it no longer needs access to the initial
+       * temperature. As a consequence, you can only call this function
+       * during the first time step. If a plugin needs access to the initial
+       * temperature at a later time, it has to store its own shared
+       * pointer to that object, and that is what can be achieved using
+       * the get_initial_temperature_manager_pointer() function above.
+       */
+      const InitialTemperature::Manager<dim> &
+      get_initial_temperature_manager () const;
+
+      /**
+       * Return a pointer to the manager of the initial composition model.
+       * This can then, for example, be used to get the names of the initial composition
+       * models used in a computation.
+       *
+       * While the Simulator class creates a shared pointer to an initial
+       * composition manager before the first time step, it releases
+       * the pointer once it no longer needs access to the initial
+       * compositions. As a consequence, you can only call this function
+       * during the first time step.
+       *
+       * If the Simulator's shared pointer were the only
+       * one that points to the initial composition manager object, that
+       * would also destroy the object pointed to. However, plugin classes
+       * can have member variables that are *also* shared pointers to
+       * these manager objects, and if you initialize such a shared
+       * pointer from the result of this function -- typically in the
+       * `initialize()` function of a plugin class -- then the Simulator
+       * giving up its shared pointer does not actually destroy the
+       * manager object but extends its lifetime until the last plugin
+       * that has a pointer to it is destroyed itself. As a consequence,
+       * if you need access to the initial compositions in a plugin, you
+       * will need to keep a shared pointer to it around for as long
+       * as you need it.
+       */
+      std::shared_ptr<const InitialComposition::Manager<dim>>
+      get_initial_composition_manager_pointer () const;
+
+      /**
+       * Return a reference to the manager of the initial composition model.
+       * This can then, for example, be used to get the names of the initial composition
+       * models used in a computation.
+       *
+       * While the Simulator class creates a shared pointer to an initial
+       * composition manager before the first time step, it releases
+       * the pointer once it no longer needs access to the initial
+       * compositions. As a consequence, you can only call this function
+       * during the first time step. If a plugin needs access to the initial
+       * composition at a later time, it has to store its own shared
+       * pointer to that object, and that is what can be achieved using
+       * the get_initial_composition_manager_pointer() function above.
+       */
+      const InitialComposition::Manager<dim> &
+      get_initial_composition_manager () const;
+
+      /**
+       * Return a set of boundary indicators that describes which of the
+       * boundaries have a fixed temperature.
+       */
+      const std::set<types::boundary_id> &
+      get_fixed_temperature_boundary_indicators () const;
+
+      /**
+       * Return a set of boundary indicators that describes which of the
+       * boundaries have a fixed heat flux.
+       */
+      const std::set<types::boundary_id> &
+      get_fixed_heat_flux_boundary_indicators () const;
+
+      /**
+       * Return a set of boundary indicators that describes which of the
+       * boundaries have a fixed composition.
+       */
+      const std::set<types::boundary_id> &
+      get_fixed_composition_boundary_indicators () const;
+
+      /**
+       * Return a set of boundary indicators that describes which of the
+       * boundaries have a mesh deformation boundary condition. Note that
+       * it does not specify which boundaries have which mesh deformation
+       * condition, only which boundaries have a mesh deformation condition.
+       */
+      const std::set<types::boundary_id> &
+      get_mesh_deformation_boundary_indicators () const;
+
+      /**
+       * Return an reference to the manager of the boundary velocity models.
+       * This can then, for example, be used to get the names of the boundary velocity
+       * models used in a computation, or to compute the boundary velocity
+       * for a given position.
+       */
+      const BoundaryVelocity::Manager<dim> &
+      get_boundary_velocity_manager () const;
+
+      /**
+       * Return a pointer to the manager of the heating model.
+       * This can then, for example, be used to get the names of the heating models
+       * used in a computation.
+       */
+      const HeatingModel::Manager<dim> &
+      get_heating_model_manager () const;
+
+      /**
+       * Return a reference to the manager of the mesh refinement strategies.
+       * this can then, for example, be used to get the names of the active refinement
+       * strategies for such purposes as confirming that a particular one has
+       * been included.
+       */
+      const MeshRefinement::Manager<dim> &
+      get_mesh_refinement_manager () const;
+
+      /**
+       * Return a reference to the melt handler.
+       */
+      const MeltHandler<dim> &
+      get_melt_handler () const;
+
+      /**
+       * Return a reference to the VolumeOfFluid handler.
+       */
+      const VolumeOfFluidHandler<dim> &
+      get_volume_of_fluid_handler () const;
+
+      /**
+       * Return a reference to the Newton handler that controls the Newton
+       * iteration to resolve nonlinearities.
+       */
+      const NewtonHandler<dim> &
+      get_newton_handler () const;
+
+#ifdef ASPECT_WITH_WORLD_BUILDER
+      /**
+       * Return a reference to the world builder that controls the setup of
+       * initial conditions.
+       *
+       * This call will only succeed if ASPECT was configured to use
+       * the WorldBuilder.
+       *
+       * While the Simulator class creates a shared pointer to a
+       * WorldBuilder object before the first time step, it releases
+       * the pointer once it no longer needs access to the initial
+       * conditions. As a consequence, you can only call this function
+       * during the first time step. If a plugin needs access to the object
+       * so returned at a later time, it has to store its own shared
+       * pointer to that object, and that is what can be achieved using
+       * the get_world_builder_pointer() function below.
+       */
+      const WorldBuilder::World &
+      get_world_builder () const;
+
+      /**
+       * This function is to get_world_builder() what
+       * get_initial_temperature_manager_pointer() is to
+       * the get_initial_temperature_manager() function: It returns a
+       * shared pointer so that objects that still need access to the
+       * WorldBuilder object after the Simulator class has released
+       * it, can extend the lifetime of the object pointed to by
+       * keeping a shared pointer to it.
+       */
+      std::shared_ptr<const WorldBuilder::World>
+      get_world_builder_pointer () const;
+#endif
+      /**
+       * Return a reference to the mesh deformation handler. This function will
+       * throw an exception if mesh deformation is not activated.
+       */
+      const MeshDeformation::MeshDeformationHandler<dim> &
+      get_mesh_deformation_handler () const;
+
+      /**
+       * Return a reference to the lateral averaging object owned
+       * by the simulator, which can be used to query lateral averages
+       * of various quantities at depth slices.
+       */
+      const LateralAveraging<dim> &
+      get_lateral_averaging () const;
+
+      /**
+       * Return a pointer to the object that describes the DoF
+       * constraints for the time step we are currently solving.
+       */
+      const AffineConstraints<double> &
+      get_current_constraints () const;
+
+      /**
+       * Return whether the Simulator object has been completely initialized
+       * and has started to run its time stepping loop.
+       *
+       * This function is useful to determine in a plugin whether some
+       * of the information one can query about the Simulator can be trusted
+       * because it has already been set up completely. For example,
+       * while the Simulator is being
+       * set up, plugins may already have access to it via the current
+       * SimulatorAccess object, but data such as the current time, the
+       * time step number, etc, may all still be in a state that is not
+       * reliable since it may not have been initialized at that time. (As
+       * an example, at the very beginning of the Simulator object's existence,
+       * the time step number is set to numbers::invalid_unsigned_int, and
+       * only when the time step loop is started is it set to a valid
+       * value). Similar examples are that at some point the Simulator
+       * sets the solution vector to the correct size, but only at a later
+       * time (though before the time stepping starts), the *contents* of
+       * the solution vector are set based on the initial conditions
+       * specified in the input file.
+       *
+       * Only when this function returns @p true is all of the information
+       * returned by the SimulatorAccess object reliable and correct.
+       *
+       * @note This function returns @p true starting with the moment where the
+       *   Simulator starts the time stepping loop. However, it may
+       *   temporarily revert to returning @p false if, for example,
+       *   the Simulator does the initial mesh refinement steps where
+       *   it starts the time loop, but then goes back to
+       *   initialization steps (mesh refinement, interpolation of initial
+       *   conditions, etc.) before re-starting the time loop.
+       */
+      bool simulator_is_past_initialization () const;
+
+      /**
+       * Return the value used for rescaling the pressure in the linear
+       * solver.
+       */
+      double
+      get_pressure_scaling () const;
+
+      /**
+       * Return whether we need to apply a compatibility modification
+       * to the pressure right hand side. See documentation of
+       * Simulator<dim>::do_pressure_rhs_compatibility_modification for more
+       * information.
+       */
+      bool
+      pressure_rhs_needs_compatibility_modification() const;
+
+      /**
+       * Return whether the model uses a prescribed Stokes solution.
+       */
+      bool
+      model_has_prescribed_stokes_solution () const;
+
+      /**
+       * A convenience function that copies the values of the compositional
+       * fields at the quadrature point q given as input parameter to the
+       * output vector composition_values_at_q_point.
+       */
+      static
+      void
+      get_composition_values_at_q_point (const std::vector<std::vector<double>> &composition_values,
+                                         const unsigned int                      q,
+                                         std::vector<double>                    &composition_values_at_q_point);
+
+      /**
+       * Return a writable reference to the statistics object into which
+       * you can store additional data that then shows up in the
+       * <code>output_dir/statistics</code> file.
+       *
+       * Postprocessor objects get a reference to this object automatically
+       * when called, but other plugins may not. They do not usually
+       * produce output anyway, but through this function they can still
+       * record information as necessary.
+       * @return
+       */
+      TableHandler &get_statistics_object() const;
+
+      /**
+       * Return a reference to the melt handler.
+       */
+      const Postprocess::Manager<dim> &
+      get_postprocess_manager () const;
+
+      /**
+       * Returns whether there is at least one particle world.
+       */
+      unsigned int
+      n_particle_worlds() const;
+
+      /**
+       * Returns a const reference to a single particle world, in case anyone
+       * wants to query something about particles.
+       */
+      const Particle::World<dim> &
+      get_particle_world(const unsigned int particle_world_index) const;
+
+      /**
+       * Returns a reference to a single particle world, in case anyone wants to
+       * change something within the particle world. Use with care, usually
+       * you want to only let the functions within the particle subsystem
+       * change member variables of the particle world.
+       */
+      Particle::World<dim> &
+      get_particle_world(const unsigned int particle_world_index);
+
+      /**
+       * Return true if using the block GMG Stokes solver.
+       */
+      bool is_stokes_matrix_free();
+
+      /**
+       * Return a reference to the StokesMatrixFreeHandler that controls the
+       * matrix-free Stokes solver.
+       */
+      const StokesMatrixFreeHandler<dim> &
+      get_stokes_matrix_free () const;
+
+      /**
+       * Compute the angular momentum and other rotation properties
+       * of the velocities in the given solution vector.
+       *
+       * @param use_constant_density determines whether to use a constant
+       * density (which corresponds to computing a net rotation instead of net
+       * angular momentum).
+       * @param solution Solution vector to compute the properties for.
+       * @param limit_to_top_faces allows to only compute the net angular momentum
+       * (or net rotation) of the top surface.
+       */
+      RotationProperties<dim>
+      compute_net_angular_momentum(const bool use_constant_density,
+                                   const LinearAlgebra::BlockVector &solution,
+                                   const bool limit_to_top_faces = false) const;
+
+      /** @} */
+
+    private:
+      /**
+       * A pointer to the simulator object to which we want to get access.
+       */
+      const Simulator<dim> *simulator;
+  };
+}
+
+
+#endif
diff --git a/include/aspect/simulator_signals.h.bak b/include/aspect/simulator_signals.h.bak
new file mode 100644
index 00000000000..dea23bd94be
--- /dev/null
+++ b/include/aspect/simulator_signals.h.bak
@@ -0,0 +1,420 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_simulator_signals_h
+#define _aspect_simulator_signals_h
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+#include <aspect/parameters.h>
+
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/numerics/data_out.h>
+
+#include <boost/signals2.hpp>
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    template <int dim>
+    class Manager;
+
+    template <int dim>
+    class Interface;
+  }
+
+  /**
+   * A class that collects the definition of signals that can be triggered
+   * at different points in a computation. A signal is in essence an event
+   * that is triggered whenever the program passes a certain point in a
+   * computation. Parties interested in any of these signals can attach
+   * "slots" to a signal. A slot is, in essence, a function that is called
+   * whenever the signal is triggered. Multiple slots (or none) can be
+   * attached to the same signal. To be as general as possible, slots are
+   * not actually just pointers to functions, but std::function objects
+   * that have a certain signature. Consequently, they can have much more
+   * complicated types than just function pointers, such as objects with
+   * an <code>operator()</code> or lambda functions.
+   *
+   * The documentation of each of the signals below indicates when
+   * exactly it is called.
+   *
+   * @ingroup Simulator
+   */
+  template <int dim>
+  struct SimulatorSignals
+  {
+    /**
+     * A signal that is called before the list of finite element variables is
+     * used to construct the Introspection class.
+     *
+     * The functions (slots) that can attach to this signal need to
+     * take one argument: A std::vector of VariableDeclaration<dim>
+     * representing the collection of finite element variables,
+     * that can be modified and will be used to construct the
+     * final finite element system later.
+     */
+    boost::signals2::signal<void (std::vector<VariableDeclaration<dim>> &)>
+    edit_finite_element_variables;
+
+    /**
+     * A signal that is called before setting up the initial conditions.
+     *
+     * The functions (slots) that can attach to this signal need to take one
+     * argument: A SimulatorAccess object that describes the simulator.
+     */
+    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_set_initial_state;
+
+    /**
+     * A signal that is called after setting up the initial conditions.
+     *
+     * The functions (slots) that can attach to this signal need to take one
+     * argument: A SimulatorAccess object that describes the simulator.
+     */
+    boost::signals2::signal<void (const SimulatorAccess<dim> &)>  post_set_initial_state;
+
+    /**
+     * A signal that is called at the beginning of each time step.
+     *
+     * The functions (slots) that can attach to this signal need to take one
+     * argument: A SimulatorAccess object that describes the simulator.
+     */
+    boost::signals2::signal<void (const SimulatorAccess<dim> &)>  start_timestep;
+
+    /**
+     * A signal that is called at the end of setting up the
+     * constraints for the current time step. This allows to add
+     * more constraints on degrees of freedom, for example to fix
+     * the velocity at certain points.
+     *
+     * The functions (slots) that can attach to this signal need to
+     * take two arguments: A SimulatorAccess object that
+     * describes the simulator to act on, and an (output)
+     * argument that indicates the constraints to be computed.
+     */
+    boost::signals2::signal<void (const SimulatorAccess<dim> &,
+                                  AffineConstraints<double> &)>  post_constraints_creation;
+
+    /**
+     * A signal that is called at the start of setup_dofs(). This allows for
+     * editing of the parameters struct on the fly (such as changing boundary
+     * conditions) to give ASPECT different behavior in mid-run than it
+     * otherwise would have.
+     *
+     * The functions that connect to this signal must take two arguments, a
+     * SimulatorAccess object that describes the simulator, and an object of
+     * type aspect::Parameters<dim>, which is the current parameters object
+     * that the simulator is working with.
+     */
+    boost::signals2::signal<void (const SimulatorAccess<dim> &,
+                                  Parameters<dim> &parameters)>  edit_parameters_pre_setup_dofs;
+
+    /**
+     * A signal that is called before every mesh_refinement. This signal
+     * allows for registering functions that store data that is related to
+     * mesh cells and needs to be transferred with the cells during the
+     * repartitioning.
+     *
+     * The functions that connect to this signal must take a reference to a
+     * parallel::distributed::Triangulation object as argument. This argument
+     * will point to the triangulation used by the Simulator class.
+     */
+    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_refinement_store_user_data;
+
+    /**
+     * A signal that is called after every mesh_refinement.  This signal
+     * allows for registering functions that load data related to mesh cells
+     * and that was transferred with the cells during the repartitioning.
+     *
+     * The functions that connect to this signal must take a reference to a
+     * parallel::distributed::Triangulation object as argument. This argument
+     * will point to the triangulation used by the Simulator class.
+     */
+    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  post_refinement_load_user_data;
+
+    /**
+     * A signal that is called before the computation of tangential boundary
+     * conditions for which normal vectors are needed, i.e. calls to the
+     * compute_no_normal_flux_constraints function for both the
+     * velocity variable in the main simulator and the mesh velocity
+     * variable in models with mesh deformation.
+     *
+     * The functions that connect to this signal must take a reference
+     * to a parallel::distributed::Triangulation object as
+     * argument. This argument will point to the triangulation used by
+     * the Simulator class.
+     */
+    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_compute_no_normal_flux_constraints;
+
+    /**
+     * A signal that is called after the computation of tangential boundary
+     * conditions for which normal vectors are needed, i.e. calls to the
+     * compute_no_normal_flux_constraints function for both the
+     * velocity variable in the main simulator and the mesh velocity
+     * variable in models with mesh deformation.
+     *
+     * The functions that connect to this signal must take a reference
+     * to a parallel::distributed::Triangulation object as
+     * argument. This argument will point to the triangulation used by
+     * the Simulator class.
+     */
+    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  post_compute_no_normal_flux_constraints;
+
+    /**
+     * A signal that is called before the creation of every checkpoint.  This
+     * signal allows for registering functions that store data related to mesh
+     * cells.
+     *
+     * The functions that connect to this signal must take a reference to a
+     * parallel::distributed::Triangulation object as argument. This argument
+     * will point to the triangulation used by the Simulator class.
+     */
+    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_checkpoint_store_user_data;
+
+    /**
+     * A signal that is called after resuming from a checkpoint.  This signal
+     * allows for registering functions that load data related to mesh cells
+     * that was previously stored in the checkpoint.  Note that before calling
+     * Triangulation::notify_ready_to_unpack() the function needs to call
+     * register_attach_data() with the appropriate arguments to restore the
+     * state of the triangulation.
+     *
+     * The functions that connect to this signal must take a reference to a
+     * parallel::distributed::Triangulation object as argument. This argument
+     * will point to the triangulation used by the Simulator class.
+     */
+    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  post_resume_load_user_data;
+
+    /**
+     * This signal is called whenever the pressure scaling is computed, see
+     * Simulator::compute_pressure_scaling_factor(), and allows inspection
+     * and/or modification of the computed factor.
+     *
+     * The argument @p pressure_scaling contains the computed pressure scaling (the ratio
+     * of the reference viscosity @p reference_viscosity computed by averaging
+     * the viscosity in the domain and the length scale @p length_scale reported
+     * by the geometry model). The return value of this functions will replace
+     * the computed value, therefore no changes are made if you return the value
+     * @p pressure_scaling.
+     */
+    boost::signals2::signal<double (const double pressure_scaling, const double reference_viscosity, const double length_scale)>  modify_pressure_scaling;
+
+    /**
+     * A signal that is called at the beginning of the program. It
+     * gives user extensions the ability to declare additional
+     * parameters via the provided argument. User extensions connected to
+     * this signal will likely also want to connect to the
+     * parse_additional_parameters signal.
+     *
+     * The first argument to functions that connect to this signal
+     * denotes the dimension in which ASPECT will be run. Functions
+     * connected to this signal can declare additional runtime
+     * parameters in the second argument.
+     */
+    static boost::signals2::signal<void (const unsigned int aspect_dim,
+                                         ParameterHandler &prm)>  declare_additional_parameters;
+
+    /**
+     * A signal that is called at the beginning of the program, after reading
+     * the input file. It gives user extensions the ability to read additional
+     * parameters from the provided argument. The first argument indicates an
+     * object that represents all of the other parameters (that have already
+     * been parsed at this point).
+     *
+     * User extensions connected to this signal will likely also want to
+     * connect to the declare_additional_parameters signal.
+     */
+    static boost::signals2::signal<void (const Parameters<dim> &,
+                                         ParameterHandler &)>  parse_additional_parameters;
+
+    /**
+     * A signal that is triggered when the iterative Stokes solver (either
+     * matrix-based or matrix-free) is done. The signal is not called when
+     * using a direct solver because the kind of information passed on by this
+     * signal does not exist when using a direct solver.
+     *
+     * Arguments to this signal are a reference to the SimulatorAccess, the number of
+     * preconditioner inner solver iterations for the $S$ and $A$ block of the
+     * system, and two information objects that contain information
+     * about the success of the solve, the number of outer GMRES iterations
+     * and the residual history for the cheap and expensive solver phase.
+     */
+    boost::signals2::signal<void (const SimulatorAccess<dim> &,
+                                  const unsigned int number_S_iterations,
+                                  const unsigned int number_A_iterations,
+                                  const SolverControl &solver_control_cheap,
+                                  const SolverControl &solver_control_expensive)> post_stokes_solver;
+
+    /**
+     * A signal that is triggered when the iterative advection solver is done.
+     * Arguments are a reference to the SimulatorAccess, a bool indicating
+     * whether the temperature field or a compositional field was solved,
+     * a composition index that describes which compositional field
+     * was solved, and an information object that contains information
+     * about the number of iterations and history of residuals.
+     */
+    boost::signals2::signal<void (const SimulatorAccess<dim> &,
+                                  const bool solved_temperature_field,
+                                  const unsigned int compositional_index,
+                                  const SolverControl &solver_control)> post_advection_solver;
+
+    /**
+     * A signal that is triggered when the nonlinear solver scheme is done.
+     * The signal parameter is an object that contains information
+     * about the final state (failure/success), number of
+     * iterations and history of residuals of the nonlinear solver.
+     * If there is no nonlinear solver (only a single solve), the
+     * SolverControl object will report a successful state, a single iteration
+     * and a remaining residual of zero.
+     */
+    boost::signals2::signal<void (const SolverControl &)> post_nonlinear_solver;
+
+    /**
+     * A signal that is triggered when ARKode is done solving an ODE.
+     * Arguments are a reference to the SimulatorAccess and
+     * an iteration count describing how many iterations ARKode required
+     * to solve the ODE.
+     */
+    boost::signals2::signal<void (const SimulatorAccess<dim> &,
+                                  const unsigned int iteration_count)> post_ARKode_solve;
+
+    /**
+     * A signal that is triggered when mesh deformation has occurred.
+     * The arguments to this signal is a reference to the SimulatorAccess
+     * object.
+     */
+    boost::signals2::signal<void (const SimulatorAccess<dim> &)> post_mesh_deformation;
+
+    /**
+     * A signal that is triggered at the end of the set_assemblers() function that
+     * allows modification of the assembly objects active in this simulation.
+     */
+    boost::signals2::signal<void (const SimulatorAccess<dim> &,
+                                  aspect::Assemblers::Manager<dim> &)>
+    set_assemblers;
+
+    /**
+    * A signal that is called before the build_patches() function is called during
+    * the creation of the visualization output. This signal
+    * allows for registering functions that take a DataOut object and can for example
+    * be used to select only certain cells of the mesh to be built into patches through
+    * calling the DataOut member function set_cell_selection().
+    */
+    boost::signals2::signal<void (DataOut<dim> &)>  pre_data_out_build_patches;
+  };
+
+
+  // Explain to the compiler that we instantiate this class elsewhere, along
+  // with its static members. This is necessary to avoid warnings by some
+  // compilers.
+  extern template struct SimulatorSignals<2>;
+  extern template
+  boost::signals2::signal<void (const unsigned int aspect_dim, ParameterHandler &prm)>
+  SimulatorSignals<2>::declare_additional_parameters;
+  extern template
+  boost::signals2::signal<void (const Parameters<2> &, ParameterHandler &)>
+  SimulatorSignals<2>::parse_additional_parameters;
+
+  extern template struct SimulatorSignals<3>;
+  extern template
+  boost::signals2::signal<void (const unsigned int aspect_dim, ParameterHandler &prm)>
+  SimulatorSignals<3>::declare_additional_parameters;
+  extern template
+  boost::signals2::signal<void (const Parameters<3> &, ParameterHandler &)>
+  SimulatorSignals<3>::parse_additional_parameters;
+
+
+  namespace internals
+  {
+    /**
+     * A namespace for some internal functions that have to do with how plugins
+     * can register their slots with signals.
+     */
+    namespace SimulatorSignals
+    {
+      /**
+       * Two functions that (in 2d and 3d) put a user-provided function onto a list
+       * of functions that the Simulator object will later go through when
+       * letting plugins connect their slots to signals.
+       */
+      void register_connector_function_2d (const std::function<void (aspect::SimulatorSignals<2> &)> &connector);
+      void register_connector_function_3d (const std::function<void (aspect::SimulatorSignals<3> &)> &connector);
+
+      /**
+       * A function that is called by the Simulator object and that goes
+       * through the list (with the corresponding dimension) created by the
+       * previous pair of functions and call each of the user-provided
+       * connector functions to let them register their slots with the
+       * corresponding signals.
+       */
+      template <int dim>
+      void call_connector_functions (aspect::SimulatorSignals<dim> &signals);
+    }
+  }
+
+
+  /**
+   * A macro that is used in user-provided plugins to register a function that
+   * is called at the beginning of a simulation by a Simulator object. When called,
+   * the provided function will receive a SimulatorSignals object that contains
+   * signals to which one can subscribe.
+   *
+   * For technical reasons, the macro takes two arguments denoting functions for the
+   * 2d and 3d cases. These can, for example, be the names of 2d and 3d
+   * instantiations of the same template function.
+   */
+#define ASPECT_REGISTER_SIGNALS_CONNECTOR(connector_function_2d,connector_function_3d) \
+  namespace ASPECT_REGISTER_SIGNALS_CONNECTOR \
+  { \
+    struct dummy_do_register \
+    {          \
+      dummy_do_register () \
+      { \
+        aspect::internals::SimulatorSignals::register_connector_function_2d (connector_function_2d); \
+        aspect::internals::SimulatorSignals::register_connector_function_3d (connector_function_3d); \
+      } \
+    } dummy_variable; \
+  }
+
+
+  /**
+   * A macro that is used to register a function that can be used to connect user
+   * extension functions to the parameter-related signals declared in SimulatorSignals.
+   *
+   * In essence, this function simply registers a (global) function that is called
+   * at the beginning of the program and that can be used to connect parameter
+   * declaration and parsing functions to the signals listed above.
+   */
+#define ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(connector_function) \
+  namespace ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR_ ## connector_function \
+  { \
+    struct dummy_do_register_ ## connector_function \
+    { \
+      dummy_do_register_ ## connector_function () \
+      {                \
+        connector_function (); \
+      }          \
+    } dummy_variable_ ## classname; \
+  }
+
+}
+#endif
diff --git a/include/aspect/stokes_matrix_free.h.bak b/include/aspect/stokes_matrix_free.h.bak
new file mode 100644
index 00000000000..e90f857cc4a
--- /dev/null
+++ b/include/aspect/stokes_matrix_free.h.bak
@@ -0,0 +1,702 @@
+/*
+  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_stokes_matrix_free_h
+#define _aspect_stokes_matrix_free_h
+
+#include <aspect/global.h>
+
+#include <aspect/simulator.h>
+
+#include <deal.II/matrix_free/matrix_free.h>
+#include <deal.II/matrix_free/operators.h>
+#include <deal.II/matrix_free/fe_evaluation.h>
+
+#include <deal.II/multigrid/mg_constrained_dofs.h>
+#include <deal.II/multigrid/multigrid.h>
+#include <deal.II/multigrid/mg_transfer_matrix_free.h>
+#include <deal.II/multigrid/mg_transfer_global_coarsening.templates.h>
+#include <deal.II/multigrid/mg_tools.h>
+#include <deal.II/multigrid/mg_coarse.h>
+#include <deal.II/multigrid/mg_smoother.h>
+#include <deal.II/multigrid/mg_matrix.h>
+
+#include <deal.II/lac/vector.h>
+#include <deal.II/lac/block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
+
+/**
+ * Typedef for the number type for the multigrid operators. Can be either float or double.
+ */
+using GMGNumberType = double;
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace internal
+  {
+    /**
+     * Matrix-free operators must use deal.II defined vectors, while the rest of the ASPECT
+     * software is based on Trilinos vectors. Here we define functions which copy between the
+     * vector types.
+     */
+    namespace ChangeVectorTypes
+    {
+      void import(TrilinosWrappers::MPI::Vector &out,
+                  const dealii::LinearAlgebra::ReadWriteVector<double> &rwv,
+                  const VectorOperation::values                 operation);
+
+      void copy(TrilinosWrappers::MPI::Vector &out,
+                const dealii::LinearAlgebra::distributed::Vector<double> &in);
+
+      void copy(dealii::LinearAlgebra::distributed::Vector<double> &out,
+                const TrilinosWrappers::MPI::Vector &in);
+
+      void copy(TrilinosWrappers::MPI::BlockVector &out,
+                const dealii::LinearAlgebra::distributed::BlockVector<double> &in);
+
+      void copy(dealii::LinearAlgebra::distributed::BlockVector<double> &out,
+                const TrilinosWrappers::MPI::BlockVector &in);
+    }
+  }
+
+  /**
+   * This namespace contains all matrix-free operators used in the Stokes solver.
+   */
+  namespace MatrixFreeStokesOperators
+  {
+
+    /**
+     * This struct stores the data for the current linear operator that is required to perform
+     * matrix-vector products.
+     *
+     * The members of type Table<2, VectorizedArray<X>> contain values
+     * of type X, grouped by cell batch using the VectorizedArray. The
+     * table is indexed by the index of the cell batch and quadrature
+     * point index.  In other words, you can access the value by
+     * <tt>table(cell_batch_index, q_index)[cell_index]</tt>
+     */
+    template <int dim, typename number>
+    struct OperatorCellData
+    {
+      /**
+       * Information on the compressibility of the flow.
+       */
+      bool is_compressible;
+
+      /**
+       * Pressure scaling constant.
+       */
+      double pressure_scaling;
+
+      /**
+       * If true, Newton terms are part of the operator.
+       */
+      bool enable_newton_derivatives;
+
+      /**
+       * Symmetrize the Newton system when it's true (i.e., the
+       * stabilization is symmetric or SPD).
+       */
+      bool symmetrize_newton_system;
+
+      /**
+       * If true, apply the stabilization on free surface faces.
+       */
+      bool apply_stabilization_free_surface_faces;
+
+      /**
+       * Table which stores viscosity values for each cell.
+       *
+       * If the second dimension is of size 1, the viscosity is
+       * assumed to be constant per cell.
+       */
+      Table<2, VectorizedArray<number>> viscosity;
+
+      /**
+       * Table which stores the strain rate for each cell to be used
+       * for the Newton terms.
+       */
+      Table<2, SymmetricTensor<2, dim, VectorizedArray<number>>> strain_rate_table;
+
+      /**
+       * Table which stores the product of the following three
+       * variables: viscosity derivative with respect to pressure,
+       * the Newton derivative scaling factor, and the averaging weight.
+       */
+      Table<2, VectorizedArray<number>> newton_factor_wrt_pressure_table;
+
+      /**
+       * Table which stores the product of the following four
+       * variables: viscosity derivative with respect to strain rate,
+       * newton derivative scaling factor, alpha, and the averaging
+       * weight. Here alpha is the spd factor when the stabilization
+       * is PD or SPD, otherwise, it is 1.
+       */
+      Table<2, SymmetricTensor<2, dim, VectorizedArray<number>>>
+      newton_factor_wrt_strain_rate_table;
+
+      /**
+       * Table which stores the product of the pressure perturbation
+       * and the normalized gravity. The size is n_face_boundary * n_face_q_points,
+       * but only those on the free surface are computed and stored.
+       */
+      Table<2, Tensor<1, dim, VectorizedArray<number>>> free_surface_stabilization_term_table;
+
+      /**
+       * Boundary indicators of those boundaries with a free surface.
+       */
+      std::set<types::boundary_id> free_surface_boundary_indicators;
+
+      /**
+       * Determine an estimate for the memory consumption (in bytes) of this
+       * object.
+       */
+      std::size_t
+      memory_consumption() const;
+
+      /**
+       * Reset the object and free all memory
+       */
+      void clear();
+    };
+
+    /**
+     * Operator for the entire Stokes block.
+     */
+    template <int dim, int degree_v, typename number>
+    class StokesOperator
+      : public MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::BlockVector<number>>
+    {
+      public:
+
+        /**
+         * Constructor.
+         */
+        StokesOperator ();
+
+        /**
+         * Reset object.
+         */
+        void clear () override;
+
+        /**
+         * Pass in a reference to the problem data.
+         */
+        void set_cell_data (const OperatorCellData<dim,number> &data);
+
+        /**
+         * Computes the diagonal of the matrix. Since matrix-free operators have not access
+         * to matrix elements, we must apply the matrix-free operator to the unit vectors to
+         * recover the diagonal.
+         */
+        void compute_diagonal () override;
+
+      private:
+
+        /**
+         * Performs the application of the matrix-free operator. This function is called by
+         * vmult() functions MatrixFreeOperators::Base.
+         */
+        void apply_add (dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
+                        const dealii::LinearAlgebra::distributed::BlockVector<number> &src) const override;
+
+        /**
+         * Defines the application of the cell matrix.
+         */
+        void local_apply (const dealii::MatrixFree<dim, number> &data,
+                          dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
+                          const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
+                          const std::pair<unsigned int, unsigned int> &cell_range) const;
+
+        /**
+         * This function doesn't do anything, it's created to use the matrixfree loop.
+         */
+        void local_apply_face (const dealii::MatrixFree<dim, number> &data,
+                               dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
+                               const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
+                               const std::pair<unsigned int, unsigned int> &face_range) const;
+
+        /**
+         * Apply the stabilization on free surface faces.
+         */
+        void local_apply_boundary_face (const dealii::MatrixFree<dim, number> &data,
+                                        dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
+                                        const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
+                                        const std::pair<unsigned int, unsigned int> &face_range) const;
+
+        /**
+         * A pointer to the current cell data that contains viscosity and other required parameters per cell.
+         */
+        const OperatorCellData<dim,number> *cell_data;
+    };
+
+    /**
+     * Operator for the pressure mass matrix used in the block preconditioner
+     */
+    template <int dim, int degree_p, typename number>
+    class MassMatrixOperator
+      : public MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::Vector<number>>
+    {
+      public:
+
+        /**
+         * Constructor
+         */
+        MassMatrixOperator ();
+
+        /**
+         * Reset the object.
+         */
+        void clear () override;
+
+        /**
+         * Pass in a reference to the problem data.
+         */
+        void set_cell_data (const OperatorCellData<dim,number> &data);
+
+        /**
+         * Computes the diagonal of the matrix. Since matrix-free operators have not access
+         * to matrix elements, we must apply the matrix-free operator to the unit vectors to
+         * recover the diagonal.
+         */
+        void compute_diagonal () override;
+
+      private:
+
+        /**
+         * Performs the application of the matrix-free operator. This function is called by
+         * vmult() functions MatrixFreeOperators::Base.
+         */
+        void apply_add (dealii::LinearAlgebra::distributed::Vector<number> &dst,
+                        const dealii::LinearAlgebra::distributed::Vector<number> &src) const override;
+
+        /**
+         * Defines the application of the cell matrix.
+         */
+        void local_apply (const dealii::MatrixFree<dim, number> &data,
+                          dealii::LinearAlgebra::distributed::Vector<number> &dst,
+                          const dealii::LinearAlgebra::distributed::Vector<number> &src,
+                          const std::pair<unsigned int, unsigned int> &cell_range) const;
+
+
+        /**
+         * Computes the diagonal contribution from a cell matrix.
+         */
+        void local_compute_diagonal (const MatrixFree<dim,number>                     &data,
+                                     dealii::LinearAlgebra::distributed::Vector<number>  &dst,
+                                     const unsigned int                               &dummy,
+                                     const std::pair<unsigned int,unsigned int>       &cell_range) const;
+
+        /**
+         * A pointer to the current cell data that contains viscosity and other required parameters per cell.
+         */
+        const OperatorCellData<dim,number> *cell_data;
+    };
+
+    /**
+     * Operator for the A block of the Stokes matrix. The same class is used for both
+     * active and level mesh operators.
+     */
+    template <int dim, int degree_v, typename number>
+    class ABlockOperator
+      : public MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::Vector<number>>
+    {
+      public:
+
+        /**
+         * Constructor
+         */
+        ABlockOperator ();
+
+        /**
+         * Reset the operator.
+         */
+        void clear () override;
+
+        /**
+         * Pass in a reference to the problem data.
+         */
+        void set_cell_data (const OperatorCellData<dim,number> &data);
+
+        /**
+         * Computes the diagonal of the matrix. Since matrix-free operators have not access
+         * to matrix elements, we must apply the matrix-free operator to the unit vectors to
+         * recover the diagonal.
+         */
+        void compute_diagonal () override;
+
+        /**
+         * Manually set the diagonal inside the matrix-free object. This function is needed
+         * when using tangential constraints as the function compute_diagonal() cannot handle
+         * non-Dirichlet boundary conditions.
+         */
+        void set_diagonal (const dealii::LinearAlgebra::distributed::Vector<number> &diag);
+
+      private:
+        /**
+         * Defines the inner-most operator on a single cell batch with
+         * the loop over quadrature points.
+         */
+        void inner_cell_operation(FEEvaluation<dim,
+                                  degree_v,
+                                  degree_v+1,
+                                  dim,
+                                  number> &velocity) const;
+
+        /**
+         * Defines the operation on a single cell batch including
+         * load/store and calls inner_cell_operation().
+         */
+        void cell_operation(FEEvaluation<dim,
+                            degree_v,
+                            degree_v+1,
+                            dim,
+                            number> &velocity) const;
+
+        /**
+         * Performs the application of the matrix-free operator. This
+         * function is called by vmult() functions
+         * MatrixFreeOperators::Base.
+         */
+        void apply_add (dealii::LinearAlgebra::distributed::Vector<number> &dst,
+                        const dealii::LinearAlgebra::distributed::Vector<number> &src) const override;
+
+        /**
+         * Defines the application of the cell matrix.
+         */
+        void local_apply (const dealii::MatrixFree<dim, number> &data,
+                          dealii::LinearAlgebra::distributed::Vector<number> &dst,
+                          const dealii::LinearAlgebra::distributed::Vector<number> &src,
+                          const std::pair<unsigned int, unsigned int> &cell_range) const;
+
+        /**
+         * A pointer to the current cell data that contains viscosity and other required parameters per cell.
+         */
+        const OperatorCellData<dim,number> *cell_data;
+    };
+  }
+
+  /**
+   * Base class for the matrix free GMG solver for the Stokes system. The
+   * actual implementation is found inside StokesMatrixFreeHandlerImplementation below.
+   */
+  template <int dim>
+  class StokesMatrixFreeHandler
+  {
+    public:
+      /**
+       * virtual Destructor.
+       */
+      virtual ~StokesMatrixFreeHandler() = default;
+
+      /**
+       * Solves the Stokes linear system matrix-free. This is called
+       * by Simulator<dim>::solve_stokes().
+       */
+      virtual std::pair<double,double> solve()=0;
+
+      /**
+       * Allocates and sets up the members of the StokesMatrixFreeHandler. This
+       * is called by Simulator<dim>::setup_dofs()
+       */
+      virtual void setup_dofs()=0;
+
+      /**
+       * Perform various tasks to update the linear system to solve
+       * for. Note that we are not assembling a matrix (as this is a
+       * matrix-free algorithm), but we are evaluating the material
+       * model and storing the information necessary for a later call
+       * to solve().
+       */
+      virtual void assemble()=0;
+
+      /**
+       * Computes and sets the diagonal for both the mass matrix
+       * operator and the A-block operators on each level for the
+       * purpose of smoothing inside the multigrid v-cycle.
+       */
+      virtual void build_preconditioner()=0;
+
+      /**
+       * Declare parameters.
+       */
+      static
+      void declare_parameters (ParameterHandler &prm);
+
+      /**
+       * Return a reference to the DoFHandler that is used for velocity in
+       * the block GMG solver.
+       */
+      virtual const DoFHandler<dim> &
+      get_dof_handler_v () const = 0;
+
+      /**
+       * Return a reference to the DoFHandler that is used for pressure in
+       * the block GMG solver.
+       */
+      virtual const DoFHandler<dim> &
+      get_dof_handler_p () const = 0;
+
+      /**
+       * Return a reference to the DoFHandler that is used for the coefficient
+       * projection in the block GMG solver.
+       */
+      virtual const DoFHandler<dim> &
+      get_dof_handler_projection () const = 0;
+
+      /**
+       * Return a pointer to the object that describes the velocity DoF
+       * constraints for the block GMG Stokes solver.
+       */
+      virtual const AffineConstraints<double> &
+      get_constraints_v () const = 0;
+
+      /**
+       * Return a pointer to the object that describes the pressure DoF
+       * constraints for the block GMG Stokes solver.
+       */
+      virtual const AffineConstraints<double> &
+      get_constraints_p () const = 0;
+
+      /**
+       * Return a pointer to the MGTransfer object used for the A block
+       * of the block GMG Stokes solver.
+       */
+      virtual const MGTransferMF<dim,GMGNumberType> &
+      get_mg_transfer_A () const = 0;
+
+      /**
+       * Return a pointer to the MGTransfer object used for the Schur
+       * complement block of the block GMG Stokes solver.
+       */
+      virtual const MGTransferMF<dim,GMGNumberType> &
+      get_mg_transfer_S () const = 0;
+
+      /**
+       * Return the memory consumption in bytes that are used to store
+       * equation data like viscosity to be able to apply the operators.
+       */
+      virtual std::size_t get_cell_data_memory_consumption() const = 0;
+  };
+
+  /**
+   * Main class of the Matrix-free method. Here are all the functions for
+   * setup, assembly and solving the Stokes system.
+   *
+   * We need to derive from StokesMatrixFreeHandler to be able to introduce a
+   * second template argument for the degree of the Stokes finite
+   * element. This way, the main simulator does not need to know about the
+   * degree by using a pointer to the base class and we can pick the desired
+   * velocity degree at runtime.
+   */
+  template <int dim, int velocity_degree>
+  class StokesMatrixFreeHandlerImplementation: public StokesMatrixFreeHandler<dim>
+  {
+    public:
+      /**
+       * Initialize this class, allowing it to read in
+       * relevant parameters as well as giving it a reference to the
+       * Simulator that owns it, since it needs to make fairly extensive
+       * changes to the internals of the simulator.
+       */
+      StokesMatrixFreeHandlerImplementation(Simulator<dim> &, ParameterHandler &prm);
+
+      /**
+       * Destructor.
+       */
+      ~StokesMatrixFreeHandlerImplementation() override = default;
+
+      /**
+       * Solves the Stokes linear system matrix-free. This is called
+       * by Simulator<dim>::solve_stokes().
+       */
+      std::pair<double,double> solve() override;
+
+      /**
+       * Allocates and sets up the members of the StokesMatrixFreeHandler. This
+       * is called by Simulator<dim>::setup_dofs()
+       */
+      void setup_dofs() override;
+
+      /**
+       * Perform various tasks to update the linear system to solve
+       * for. Note that we are not assembling a matrix (as this is a
+       * matrix-free algorithm), but we are evaluating the material
+       * model and storing the information necessary for a later call
+       * to solve().
+       */
+      void assemble() override;
+
+      /**
+       * Computes and sets the diagonal for both the mass matrix operator and the A-block
+       * operators on each level for the purpose of smoothing inside the multigrid v-cycle.
+       */
+      void build_preconditioner() override;
+
+      /**
+       * Declare parameters. (No actual parameters at the moment).
+       */
+      static
+      void declare_parameters (ParameterHandler &prm);
+
+      /**
+       * Return a reference to the DoFHandler that is used for velocity in
+       * the block GMG solver.
+       */
+      const DoFHandler<dim> &
+      get_dof_handler_v () const override;
+
+      /**
+       * Return a reference to the DoFHandler that is used for pressure in
+       * the block GMG solver.
+       */
+      const DoFHandler<dim> &
+      get_dof_handler_p () const override;
+
+      /**
+       * Return a reference to the DoFHandler that is used for the coefficient
+       * projection in the block GMG solver.
+       */
+      const DoFHandler<dim> &
+      get_dof_handler_projection () const override;
+
+      /**
+       * Return a pointer to the object that describes the velocity DoF
+       * constraints for the block GMG Stokes solver.
+       */
+      const AffineConstraints<double> &
+      get_constraints_v () const override;
+
+      /**
+       * Return a pointer to the object that describes the pressure DoF
+       * constraints for the block GMG Stokes solver.
+       */
+      const AffineConstraints<double> &
+      get_constraints_p () const override;
+
+      /**
+       * Return a pointer to the MGTransfer object used for the A block
+       * of the block GMG Stokes solver.
+       */
+      const MGTransferMF<dim,GMGNumberType> &
+      get_mg_transfer_A () const override;
+
+      /**
+       * Return a pointer to the MGTransfer object used for the Schur
+       * complement block of the block GMG Stokes solver.
+       */
+      const MGTransferMF<dim,GMGNumberType> &
+      get_mg_transfer_S () const override;
+
+
+      /**
+       * Return the memory consumption in bytes that are used to store
+       * equation data like viscosity to be able to apply the operators.
+       */
+      std::size_t get_cell_data_memory_consumption() const override;
+
+    private:
+      /**
+       * Parse parameters.
+       */
+      void parse_parameters (ParameterHandler &prm);
+
+      /**
+       * Evaluate the MaterialModel to query information like the viscosity and
+       * project this viscosity to the multigrid hierarchy. Also queries
+       * other parameters like pressure scaling.
+       */
+      void evaluate_material_model();
+
+      /**
+       * Add correction to system RHS for non-zero boundary condition. See description in
+       * StokesMatrixFreeHandler::correct_stokes_rhs() for more information.
+       */
+      void correct_stokes_rhs();
+
+
+      Simulator<dim> &sim;
+
+      bool print_details;
+
+      /**
+       * If true, it will time the key components of this matrix-free implementation, such as
+       * vmult of different matrices, solver IDR with the cheap preconditioner, etc.
+       */
+      bool do_timings;
+
+      /**
+       * The max/min of the evaluated viscosities.
+       */
+      double minimum_viscosity;
+      double maximum_viscosity;
+
+      DoFHandler<dim> dof_handler_v;
+      DoFHandler<dim> dof_handler_p;
+      DoFHandler<dim> dof_handler_projection;
+
+      FESystem<dim> fe_v;
+      FESystem<dim> fe_p;
+      FESystem<dim> fe_projection;
+
+      /**
+       * Store the data for the Stokes operator (viscosity, etc.) for the active cells.
+       */
+      MatrixFreeStokesOperators::OperatorCellData<dim, GMGNumberType> active_cell_data;
+
+      /**
+       * Store the data for the Stokes operator (viscosity, etc.) for each multigrid level.
+       */
+      MGLevelObject<MatrixFreeStokesOperators::OperatorCellData<dim, GMGNumberType>> level_cell_data;
+
+      using StokesMatrixType = MatrixFreeStokesOperators::StokesOperator<dim,velocity_degree,double>;
+      using SchurComplementMatrixType = MatrixFreeStokesOperators::MassMatrixOperator<dim,velocity_degree-1,double>;
+      using ABlockMatrixType = MatrixFreeStokesOperators::ABlockOperator<dim,velocity_degree,double>;
+
+      using GMGSchurComplementMatrixType = MatrixFreeStokesOperators::MassMatrixOperator<dim,velocity_degree-1,GMGNumberType>;
+      using GMGABlockMatrixType = MatrixFreeStokesOperators::ABlockOperator<dim,velocity_degree,GMGNumberType>;
+
+      StokesMatrixType stokes_matrix;
+      ABlockMatrixType A_block_matrix;
+      SchurComplementMatrixType Schur_complement_block_matrix;
+
+      AffineConstraints<double> constraints_v;
+      AffineConstraints<double> constraints_p;
+
+      MGLevelObject<GMGABlockMatrixType> mg_matrices_A_block;
+      MGLevelObject<GMGSchurComplementMatrixType> mg_matrices_Schur_complement;
+
+      MGConstrainedDoFs mg_constrained_dofs_A_block;
+      MGConstrainedDoFs mg_constrained_dofs_Schur_complement;
+      MGConstrainedDoFs mg_constrained_dofs_projection;
+
+      MGTransferMF<dim,GMGNumberType> mg_transfer_A_block;
+      MGTransferMF<dim,GMGNumberType> mg_transfer_Schur_complement;
+
+      std::vector<std::shared_ptr<MatrixFree<dim,double>>> matrix_free_objects;
+  };
+}
+
+
+#endif
diff --git a/include/aspect/structured_data.h.bak b/include/aspect/structured_data.h.bak
new file mode 100644
index 00000000000..cc569e1c2a2
--- /dev/null
+++ b/include/aspect/structured_data.h.bak
@@ -0,0 +1,778 @@
+/*
+  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_structured_data_h
+#define _aspect_structured_data_h
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+
+#include <array>
+
+namespace aspect
+{
+  namespace Utilities
+  {
+    using namespace dealii;
+
+    /**
+     * StructuredDataLookup (formerly AsciiDataLookup) represents structured
+     * data that can be read from files including in ascii format.
+     *
+     * For ascii files the files need to be formatted as follows:
+     * Note the required format of the input data: The first lines may contain
+     * any number of comments if they begin with '#', but one of these lines
+     * needs to contain the number of grid points in each dimension as for
+     * example '# POINTS: 3 3'. The comments can optionally be followed by a
+     * single line, which does not start with '#', containing the names of
+     * the data columns.
+     * The order of the following data columns has to be
+     * 'coordinates data' with @p dim coordinate columns and @p components
+     * data columns. Note that the data in the input files need to be sorted
+     * in a specific order: the first coordinate needs to ascend first,
+     * followed by the second and so on in order to assign the correct data to
+     * the prescribed coordinates. The coordinates do not need to be
+     * equidistant.
+     */
+    template <int dim>
+    class StructuredDataLookup
+    {
+      public:
+        /**
+         * Constructor that explicitly prescribes the number of data columns
+         * in the data file. If a list of data components is provided in the
+         * data file it is checked that the length of this list is consistent
+         * with this number of components. This constructor is mostly provided
+         * for backwards compatibility. Not prescribing the number of components
+         * and instead reading them from the input file allows for more
+         * flexible files.
+         */
+        StructuredDataLookup(const unsigned int n_components,
+                             const double scale_factor);
+
+        /**
+         * This constructor relies on the list of column names at the beginning
+         * of the model file to determine the number of data components,
+         * therefore when using this constructor it is necessary to provide
+         * this list in the first uncommented line of the data file.
+         */
+        explicit StructuredDataLookup(const double scale_factor);
+
+        /**
+         * Replace the data stored in this class by the data given to this function.
+         *
+         * @note This is a manual way to fill the data. Consider load_file() if your data
+         * is stored in a txt/csv file.
+         *
+         * The data consists of @p n_components (implicitly given by the size of @p column_names)
+         * specified at @p coordinate_values[d] points in each of the dim coordinate directions @p d.
+         *
+         * The data in @p data_table consists of a Table for each of the @p n_components components.
+         *
+         * The `coordinate_values` and `data_table` arguments are rvalue references,
+         * and the function will move the data so provided into another storage
+         * location. In other words, after the call, the variables passed as the
+         * second and third arguments may be empty or otherwise altered.
+         *
+         * This class
+         * is able to share data between processes located on the same
+         * machine if the last argument `root_process` is
+         * set to anything other than `numbers::invalid_unsigned_int`. Then only the
+         * indicated root process within the given MPI communicator needs to
+         * pass in valid arguments whereas on all other processes the values
+         * of `column_names`, `coordinate_values`, and `data_table` are
+         * ignored. Instead, the indicated root process will make sure that
+         * the other processes obtain valid data, for example by sharing
+         * data tables in shared memory spaces. This reduces both the
+         * computational effort in reading data from disk and parsing it on
+         * all processes, and can vastly reduce the amount of memory required
+         * on machines where many processor cores have access to shared memory
+         * resources.
+         *
+         * If `root_process` equals `numbers::invalid_unsigned_int`, then
+         * every process needs to pass data for all arguments and the
+         * `mpi_communicator` argument is ignored.
+         */
+        void reinit(const std::vector<std::string> &column_names,
+                    std::vector<std::vector<double>> &&coordinate_values,
+                    std::vector<Table<dim,double>> &&data_table,
+                    const MPI_Comm mpi_communicator = MPI_COMM_SELF,
+                    const unsigned int root_process = numbers::invalid_unsigned_int);
+
+        /**
+         * Loads a data text file replacing the current data.
+         *
+         * Throws an exception if the file does not
+         * exist, if the data file format is incorrect, or if the file data
+         * like the number and names of columns change (if this class contains
+         * existing data for example when used with a collection of ascii files
+         * changing over the simulation time).
+         *
+         * This function supports normal text / ASCII files that can optionally
+         * be compressed using .gz. If the given filename is a URL and libDAB
+         * support is enabled, the data is downloaded and parsed from the ASCII
+         * data received.
+         *
+         * This function uses the given MPI communicator to only load the data on
+         * rank 0 and broadcasting the information to all other ranks.
+         */
+        void
+        load_ascii(const std::string &filename,
+                   const MPI_Comm communicator);
+
+        /**
+         * Fill the current object with data read from a NetCDF file
+         * with filename @p filename. This call will fail if ASPECT is not
+         * configured with NetCDF support.
+         *
+         * @p data_column_names specifies the list of data columns to load (in the specified order). If
+         * an empty vector is passed, all columns will be loaded.
+         */
+        void
+        load_netcdf(const std::string &filename, const std::vector<std::string> &data_column_names = {});
+
+
+        /**
+         * Loads data from a file replacing the current data.
+         *
+         * Throws an exception if the file does not
+         * exist, if the data file format is incorrect, or if the file data
+         * like the number and names of columns change (if this class contains
+         * existing data for example when used with a collection of ascii files
+         * changing over the simulation time).
+         *
+         * The following formats are currently supported:
+         * - ASCII files (typically ending in .txt)
+         * - gzip compressed ASCII files (ending in .gz)
+         * - URLs starting with "http" (handled by libDAB)
+         */
+        void
+        load_file(const std::string &filename,
+                  const MPI_Comm communicator);
+
+        /**
+         * Returns the computed data (velocity, temperature, etc. - according
+         * to the used plugin) in Cartesian coordinates.
+         *
+         * @param position The current position to compute the data (velocity,
+         * temperature, etc.)
+         * @param component The index (starting at 0) of the data column to be
+         * returned. The index is therefore less than the number of data
+         * columns in the data file (or specified in the constructor).
+         */
+        double
+        get_data(const Point<dim> &position,
+                 const unsigned int component) const;
+
+        /**
+         * Returns the gradient of the function based on the bilinear
+         * interpolation of the data (velocity, temperature, etc. - according
+         * to the used plugin) in Cartesian coordinates.
+         *
+         * @param position The current position to compute the data (velocity,
+         * temperature, etc.)
+         * @param component The index of the data column to be returned.
+         */
+        Tensor<1,dim>
+        get_gradients(const Point<dim> &position,
+                      const unsigned int component);
+
+        /**
+         * Returns a vector that contains the names of all data columns in the
+         * order of their appearance in the data file (and their order in the
+         * memory data table). Returns an empty vector if no names are provided
+         * or the file is not read in yet.
+         */
+        std::vector<std::string>
+        get_column_names() const;
+
+        /**
+         * Returns whether the stored coordinates are equidistant. If
+         * coordinates are equidistant the lookup is more efficient. Returns
+         * false if no coordinates are loaded at the moment.
+         */
+        bool
+        has_equidistant_coordinates() const;
+
+        /**
+         * Returns the coordinates of the interpolation points at which data is
+         * stored. This function can be used to determine the number of data
+         * points in each of the coordinate directions, or to query
+         * data only at exactly the positions at which they are available (avoiding
+         * interpolation).
+         *
+         * @param dimension The spatial direction for which to return the data
+         * coordinates, e.g. 0 for $x$-direction, 1 for $y$-direction, or equivalent
+         * values if your data coordinates are other dimensions such as
+         * temperature, pressure.
+         */
+        const std::vector<double> &
+        get_interpolation_point_coordinates(const unsigned int dimension) const;
+
+        /**
+         * Returns the column index of a column with the given name
+         * @p column_name. Throws an exception if no such
+         * column exists or no names were provided in the file.
+         */
+        unsigned int
+        get_column_index_from_name(const std::string &column_name) const;
+
+        /**
+         * Returns a string that contains the name of the column with index
+         * @p column_index. Throws an exception if no such
+         * column exists or no name was provided in the file.
+         */
+        std::string
+        get_column_name_from_index(const unsigned int column_index) const;
+
+        /**
+         * Return the maximum value of the component values.
+         */
+        double get_maximum_component_value(const unsigned int component) const;
+
+      private:
+        /**
+         * The number of data components read in (=columns in the data file).
+         */
+        unsigned int n_components;
+
+        /**
+         * The names of the data components in the columns of the read file.
+         * Does not contain any strings if none are provided in the first
+         * uncommented line of the file.
+         */
+        std::vector<std::string> data_component_names;
+
+        /**
+         * Interpolation functions to access the data.
+         * Either InterpolatedUniformGridData or InterpolatedTensorProductGridData;
+         * the type is determined from the grid specified in the data file.
+         */
+        std::vector<std::unique_ptr<Function<dim>>> data;
+
+        /**
+         * The coordinate values in each direction as specified in the data file.
+         */
+        std::array<std::vector<double>,dim> coordinate_values;
+
+        /**
+         * The maximum value of each component
+         */
+        std::vector<double> maximum_component_value;
+
+        /**
+         * Number of points in the data grid as specified in the data file.
+         */
+        TableIndices<dim> table_points;
+
+        /**
+         * Scales the data boundary condition by a scalar factor. Can be used
+         * to transform the unit of the data.
+         */
+        const double scale_factor;
+
+        /**
+         * Stores whether the coordinate values are equidistant or not,
+         * this determines the type of data function stored.
+         */
+        bool coordinate_values_are_equidistant;
+
+        /**
+         * Computes the table indices given the size @p sizes of the
+         * entry with index @p idx.
+         */
+        TableIndices<dim>
+        compute_table_indices(const TableIndices<dim> &sizes, const std::size_t idx) const;
+
+    };
+
+    /**
+     * AsciDataBase is a generic plugin used for declaring and reading the
+     * parameters from the parameter file.
+     */
+    template <int dim>
+    class AsciiDataBase
+    {
+      public:
+        /**
+         * Constructor
+         */
+        AsciiDataBase();
+
+        /**
+         * Declare the parameters all derived classes take from input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler  &prm,
+                            const std::string &default_directory,
+                            const std::string &default_filename,
+                            const std::string &subsection_name = "Ascii data model");
+
+        /**
+         * Read the parameters from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm,
+                          const std::string &subsection_name = "Ascii data model");
+
+        /**
+         * Directory in which the data files are present.
+         */
+        std::string data_directory;
+
+        /**
+         * Filename of data file. The file names can contain the specifiers %s
+         * and/or %c (in this order), meaning the name of the boundary and the
+         * number of the data file time step.
+         */
+        std::string data_file_name;
+
+        /**
+         * Scale the data by a scalar factor. Can be used to transform the
+         * unit of the data (if they are not specified in SI units (m/s or
+         * m/yr depending on the "Use years in output instead of seconds"
+         * parameter).
+         */
+        double scale_factor;
+    };
+
+    /**
+     * A base class that implements boundary conditions determined from a
+     * AsciiData input file.
+     */
+    template <int dim>
+    class AsciiDataBoundary : public Utilities::AsciiDataBase<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor
+         */
+        AsciiDataBoundary();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        virtual
+        void
+        initialize (const std::set<types::boundary_id> &boundary_ids,
+                    const unsigned int components);
+
+        /**
+         * A function that is called at the beginning of each time step. For
+         * the current plugin, this function loads the next data files if
+         * necessary and outputs a warning if the end of the set of data files
+         * is reached.
+         */
+        void
+        update();
+
+        /**
+         * Returns the data component at the given position.
+         */
+        double
+        get_data_component (const types::boundary_id             boundary_indicator,
+                            const Point<dim>                    &position,
+                            const unsigned int                   component) const;
+
+        /**
+         * Returns the maximum value of the given data component.
+         */
+        double
+        get_maximum_component_value (const types::boundary_id boundary_indicator,
+                                     const unsigned int       component) const;
+
+        /**
+         * Return the gradients of the parameters from the parameter file.
+         */
+        Tensor<1,dim-1>
+        vector_gradient(const types::boundary_id boundary_indicator,
+                        const Point<dim>        &p,
+                        const unsigned int       component) const;
+
+        /**
+         * Declare the parameters all derived classes take from input files.
+         *
+         * @param prm The parameter handler in which the parameters are declared.
+         * @param default_directory The default value for the data directory parameter.
+         * @param default_filename The default value for the filename parameter.
+         * @param subsection_name The name of the parameter file subsection all
+         * parameters will be declared in. The function will enter this subsection,
+         * declare all parameters, then leave this subsection, to return @p prm in
+         * the same subsection it was in before.
+         * @param declare_time_dependent_parameters Whether to declare the parameter
+         * that are only needed for time dependent AsciiDataBoundary objects. If
+         * the caller already knows time dependence is not supported for the current
+         * application, disabling this parameter avoids introducing these parameters
+         * to the parameter handler.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler  &prm,
+                            const std::string &default_directory,
+                            const std::string &default_filename,
+                            const std::string &subsection_name = "Ascii data model",
+                            const bool declare_time_dependent_parameters = true);
+
+        /**
+         * Read the parameters from the parameter file.
+         *
+         * @param prm The parameter handler from which the parameters are parsed.
+         * @param subsection_name The name of the parameter file subsection all
+         * parameters will be parsed from. The function will enter this subsection,
+         * parse all parameters, then leave this subsection, to return @p prm in
+         * the same subsection it was in before.
+         * @param parse_time_dependent_parameters Whether to parse the parameter
+         * that are only needed for time dependent AsciiDataBoundary objects. This
+         * parameter always needs to be set to the same value that was handed over
+         * to declare_parameters().
+         */
+        void
+        parse_parameters (ParameterHandler &prm,
+                          const std::string &subsection_name = "Ascii data model",
+                          const bool parse_time_dependent_parameters = true);
+
+      protected:
+        /**
+         * A variable that stores the currently used data file of a series. It
+         * gets updated if necessary by update().
+         */
+        int current_file_number;
+
+        /**
+         * Number of the first data file to be loaded when the model time is
+         * larger than 'First data file model time'.
+         */
+        int first_data_file_number;
+
+        /**
+         * In some cases the boundary files are not numbered in increasing but
+         * in decreasing order (e.g. 'Ma BP'). If this flag is set to 'True'
+         * the plugin will first load the file with the number 'First data
+         * file number' and decrease the file number during the model run.
+         */
+        bool decreasing_file_order;
+
+        /**
+         * Time in model units (depends on other model inputs) between two
+         * data files.
+         */
+        double data_file_time_step;
+
+        /**
+         * Weight between data file n and n+1 while the current time is
+         * between the two values t(n) and t(n+1).
+         */
+        double time_weight;
+
+        /**
+         * State whether we have time_dependent boundary conditions. Switched
+         * off after finding no more data files to suppress attempts to read
+         * in new files.
+         */
+        bool time_dependent;
+
+        /**
+         * Map between the boundary id and an object that reads and processes
+         * data we get from text files.
+         */
+        std::map<types::boundary_id,
+            std::unique_ptr<aspect::Utilities::StructuredDataLookup<dim-1>>> lookups;
+
+        /**
+         * Map between the boundary id and the old data objects.
+         */
+        std::map<types::boundary_id,
+            std::unique_ptr<aspect::Utilities::StructuredDataLookup<dim-1>>> old_lookups;
+
+        /**
+         * Handles the update of the data in lookup.
+         */
+        void
+        update_data (const types::boundary_id boundary_id,
+                     const bool reload_both_files);
+
+        /**
+         * Handles settings and user notification in case the time-dependent
+         * part of the boundary condition is over.
+         */
+        void
+        end_time_dependence ();
+
+        /**
+         * Create a filename out of the name template.
+         */
+        std::string
+        create_filename (const int filenumber,
+                         const types::boundary_id boundary_id) const;
+    };
+
+
+
+    /**
+     * A base class that implements initial conditions determined from a
+     * AsciiData input file.
+     */
+    template <int dim>
+    class AsciiDataInitial : public Utilities::AsciiDataBase<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor
+         */
+        AsciiDataInitial();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        virtual
+        void
+        initialize (const unsigned int components);
+
+
+        /**
+         * Returns the data component at the given position.
+         */
+        double
+        get_data_component (const Point<dim> &position,
+                            const unsigned int component) const;
+
+        /**
+         * Declare the parameters all derived classes take from input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler  &prm,
+                            const std::string &default_directory,
+                            const std::string &default_filename,
+                            const std::string &subsection_name = "Ascii data model");
+
+        /**
+         * Read the parameters from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm,
+                          const std::string &subsection_name = "Ascii data model");
+
+      protected:
+        /**
+         * Pointer to an object that reads and processes data we get from text
+         * files.
+         */
+        std::unique_ptr<aspect::Utilities::StructuredDataLookup<dim>> lookup;
+
+        /**
+         * Pointer to an object that reads and processes data we get from text
+         * files if the current model is a slice of the input file (e.g. a 2D
+         * model and a 3D data file).
+         */
+        std::unique_ptr<aspect::Utilities::StructuredDataLookup<3>> slice_lookup;
+
+        /**
+         * Whether to use a dataset that has the same spatial dimensions as
+         * the model or not. If true only a 2D slice of a 3D dataset is used.
+         */
+        bool slice_data;
+
+        /**
+         * The matrix that describes the rotation by which a 2D model
+         * needs to be transformed to a plane that contains the origin and
+         * the two prescribed points given in the input.
+         */
+        Tensor<2,3> rotation_matrix;
+    };
+
+
+    /**
+     * A base class that implements conditions determined from a
+     * layered AsciiData input file.
+     */
+    template <int dim>
+    class AsciiDataLayered : public Utilities::AsciiDataBase<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor
+         */
+        AsciiDataLayered();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        virtual
+        void
+        initialize (const unsigned int components);
+
+
+        /**
+         * Returns the data component at the given position.
+         */
+        double
+        get_data_component (const Point<dim> &position,
+                            const unsigned int component) const;
+
+
+        /**
+         * Declare the parameters all derived classes take from input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler  &prm,
+                            const std::string &default_directory,
+                            const std::string &default_filename,
+                            const std::string &subsection_name = "Ascii data model");
+
+        /**
+         * Read the parameters from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm,
+                          const std::string &subsection_name = "Ascii data model");
+
+      protected:
+        /**
+         * Pointer to an object that reads and processes data we get from text
+         * files.
+         */
+        std::vector<std::unique_ptr<aspect::Utilities::StructuredDataLookup<dim-1>>> lookups;
+
+      private:
+
+        /**
+         * Directory in which the data files are present.
+         */
+        std::string data_directory;
+
+        /**
+         * Filenames of data files.
+         */
+        std::vector<std::string> data_file_names;
+
+        /**
+         * Number of layer boundaries in the model.
+         */
+        unsigned int number_of_layer_boundaries;
+
+        /**
+         * Interpolation scheme for profile averaging.
+         */
+        std::string interpolation_scheme;
+
+
+    };
+
+
+    /**
+     * A base class that reads in a data profile and provides its values.
+     */
+    template <int dim>
+    class AsciiDataProfile : public Utilities::AsciiDataBase<dim>
+    {
+      public:
+        /**
+         * Constructor
+         */
+        AsciiDataProfile();
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program. Checks preconditions.
+         */
+        virtual
+        void
+        initialize (const MPI_Comm communicator);
+
+
+        /**
+         * Returns the data component at the given position.
+         */
+        double
+        get_data_component (const Point<1>                      &position,
+                            const unsigned int                   component) const;
+
+        /**
+         * Returns a vector that contains the names of all data columns in the
+         * order of their appearance in the data file (and their order in the
+         * memory data table). Returns an empty vector if no names are provided
+         * or the file is not read in yet.
+         */
+        std::vector<std::string>
+        get_column_names() const;
+
+        /**
+         * Returns the coordinates of the interpolation points at which data is
+         * stored. This function can be used to determine the number of data
+         * points in each of the coordinate directions, or to query
+         * data only at exactly the positions at which they are available (avoiding
+         * interpolation).
+         *
+         * Because this class represents a one-dimensional profile, the returned
+         * values correspond to the values of the sole coordinate of the
+         * interpolation points, in contrast to the
+         * StructuredDataLookup::get_interpolation_point_coordinates()
+         * function that takes an integer argument indicating which coordinate
+         * is to be selected.
+         */
+        const std::vector<double> &
+        get_interpolation_point_coordinates() const;
+
+        /**
+         * Returns the column index of a column with the given name
+         * @p column_name. Throws an exception if no such
+         * column exists or no names were provided in the file.
+         */
+        unsigned int
+        get_column_index_from_name(const std::string &column_name) const;
+
+        /**
+         * Returns the column index of a column with the given name
+         * @p column_name. Returns an invalid unsigned int if no such
+         * column exists or no names were provided in the file.
+         */
+        unsigned int
+        maybe_get_column_index_from_name(const std::string &column_name) const;
+
+        /**
+         * Returns a string that contains the name of the column with index
+         * @p column_index. Returns an empty string if no such
+         * column exists or no name was provided in the file.
+         */
+        std::string
+        get_column_name_from_index(const unsigned int column_index) const;
+      protected:
+        /**
+         * Pointer to an object that reads and processes data we get from text
+         * files.
+         */
+        std::unique_ptr<aspect::Utilities::StructuredDataLookup<1>> lookup;
+    };
+
+
+
+    template <int dim>
+    using AsciiDataLookup DEAL_II_DEPRECATED = StructuredDataLookup<dim>;
+  }
+}
+
+#endif
diff --git a/include/aspect/termination_criteria/end_step.h.bak b/include/aspect/termination_criteria/end_step.h.bak
new file mode 100644
index 00000000000..24b3e0570af
--- /dev/null
+++ b/include/aspect/termination_criteria/end_step.h.bak
@@ -0,0 +1,70 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_termination_criteria_end_step_h
+#define _aspect_termination_criteria_end_step_h
+
+#include <aspect/termination_criteria/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+
+    /**
+     * A class that terminates the simulation when a specified end timestep is
+     * reached.
+     *
+     * @ingroup TerminationCriteria
+     */
+    template <int dim>
+    class EndStep : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate this termination criterion.
+         *
+         * @return Whether to terminate the simulation (true) or continue
+         * (false).
+         */
+        bool
+        execute () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        unsigned int end_step;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/termination_criteria/end_time.h.bak b/include/aspect/termination_criteria/end_time.h.bak
new file mode 100644
index 00000000000..9205bdae7d7
--- /dev/null
+++ b/include/aspect/termination_criteria/end_time.h.bak
@@ -0,0 +1,77 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_termination_criteria_end_time_h
+#define _aspect_termination_criteria_end_time_h
+
+#include <aspect/termination_criteria/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+
+    /**
+     * A class that terminates the simulation when a specified end time is
+     * reached.
+     *
+     * @ingroup TerminationCriteria
+     */
+    template <int dim>
+    class EndTime : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Check this termination criterion and possibly reduce time step size
+         */
+        double check_for_last_time_step (const double time_step) const override;
+
+        /**
+         * Evaluate this termination criterion.
+         *
+         * @return Whether to terminate the simulation (true) or continue
+         * (false).
+         */
+        bool
+        execute () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        double end_time;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/termination_criteria/end_walltime.h.bak b/include/aspect/termination_criteria/end_walltime.h.bak
new file mode 100644
index 00000000000..c8c1076cf1b
--- /dev/null
+++ b/include/aspect/termination_criteria/end_walltime.h.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2011 - 2019- 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_termination_criteria_end_walltime_h
+#define _aspect_termination_criteria_end_walltime_h
+
+#include <aspect/termination_criteria/interface.h>
+#include <aspect/simulator.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+
+    /**
+     * A class that terminates the simulation when a specified end time is
+     * reached.
+     *
+     * @ingroup TerminationCriteria
+     */
+    template <int dim>
+    class EndWalltime : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Evaluate this termination criterion.
+         *
+         * @return Whether to terminate the simulation (true) or continue
+         * (false).
+         */
+        bool
+        execute () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The maximum walltime duration in seconds. The program will be terminated
+         * once this value is reached.
+         */
+        unsigned int walltime_duration;
+
+        /**
+         * The start_walltime is not stored into checkpoint, so it will get reset at restart.
+         * Make start_walltime as a static variable that it gets initialized pretty much
+         * right away as the program starts, rather than several seconds in once we get
+         * to creating the plugin. It gives better estimate of the actual start time.
+         */
+        static std::time_t start_walltime;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/termination_criteria/interface.h.bak b/include/aspect/termination_criteria/interface.h.bak
new file mode 100644
index 00000000000..8306819eab6
--- /dev/null
+++ b/include/aspect/termination_criteria/interface.h.bak
@@ -0,0 +1,244 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_termination_criteria_interface_h
+#define _aspect_termination_criteria_interface_h
+
+#include <aspect/global.h>
+#include <aspect/plugins.h>
+
+#include <memory>
+#include <deal.II/base/parameter_handler.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim> class Simulator;
+
+
+  /**
+   * A namespace for everything to do with determining criteria for
+   * terminating the simulation gracefully. This does not include termination
+   * due to errors.
+   *
+   * @ingroup TerminationCriteria
+   */
+  namespace TerminationCriteria
+  {
+
+    /**
+     * This class declares the public interface of termination criteria
+     * plugins. These plugins must implement a function that can be called
+     * each time step to determine if specific criteria have been met that
+     * mean the simulation should be ended gracefully.
+     *
+     * Access to the data of the simulator is granted by the @p protected
+     * member functions of the SimulatorAccess class, i.e., classes
+     * implementing this interface will in general want to derive from both
+     * this Interface class as well as from the SimulatorAccess class if they
+     * need to find out about the state of the simulation.
+     *
+     * @ingroup TerminationCriteria
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Execute evaluation of the termination criterion.
+         *
+         * @return Whether to terminate the simulation (true) or continue
+         * (false).
+         *
+         * @note For some kinds of termination plugins, it may be difficult to
+         * ensure that all processors come to the same conclusion. An example
+         * is one that terminates the simulation after a certain amount of CPU
+         * time has expired, and this may be different from MPI process to MPI
+         * process. To avoid difficult to deal with situations, the plugin
+         * manager only requires that a single processor returns
+         * <code>true</code> for a given plugin to record that the plugin
+         * wants to terminate the simulation, even if the other processors
+         * return false.
+         */
+        virtual
+        bool
+        execute () = 0;
+
+        /**
+         * Check for last time step and if so reduce the time step to user
+         * specified end time
+         *
+         * @return Reduced or current time step size
+         *
+         * @note A reduced time step size may be returned for the last time
+         * step. For all other time steps, the current time step size
+         * (provided as argument) will be returned. The returned time step
+         * size will be greater than zero, and less than or equal to the given
+         * argument put into this function.
+         */
+        virtual double check_for_last_time_step (const double time_step) const;
+    };
+
+
+
+
+
+
+    /**
+     * A class that manages all objects that provide functionality to specify
+     * termination criteria.
+     *
+     * @ingroup TerminationCriteria
+     */
+    template <int dim>
+    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Execute all of the termination criteria objects that have been
+         * requested in the input file.
+         *
+         * The function returns a bool indicating whether the simulation should be
+         * terminated.
+         *
+         * To avoid undefined situations, this function only requires that a
+         * single processor's termination request comes back positive for a
+         * given plugin. In other words, for each plugin selected, not all
+         * processors need to return the same value: if only one of the says
+         * that the simulation should be terminated, then this is enough.
+         */
+        virtual
+        bool
+        execute () const;
+
+        /**
+         * Check all of the termination criteria objects that have been
+         * requested in the input file for criteria regarding last time step
+         * and if so get the minimum of these values.
+         *
+         * @return Reduced or current time step size
+         *
+         * @note A reduced time step size may be returned for the last time
+         * step. For all other time steps, the current time step size
+         * (provided as argument) will be returned. The returned time step
+         * size will be greater than zero, and less than or equal to the given
+         * argument put into this function.
+         */
+        double check_for_last_time_step (const double time_step) const;
+
+        /**
+         * Declare the parameters of all known termination criteria plugins,
+         * as well as of ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which termination criteria objects will be created;
+         * then let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * A function that is used to register termination criteria objects in
+         * such a way that the Manager can deal with all of them without
+         * having to know them by name. This allows the files in which
+         * individual plugins are implement to register these plugins, rather
+         * than also having to modify the Manager class by adding the new
+         * termination criteria class.
+         *
+         * @param name The name under which this plugin is to be called in
+         * parameter files.
+         * @param description A text description of what this model does and
+         * that will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that
+         * declares the parameters for this plugin.
+         * @param factory_function A pointer to a function that creates such a
+         * termination criterion object and returns a pointer to it.
+         */
+        static
+        void
+        register_termination_criterion (const std::string &name,
+                                        const std::string &description,
+                                        void (*declare_parameters_function) (ParameterHandler &),
+                                        std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+        /**
+         * Exception.
+         */
+        DeclException1 (ExcTerminationCriteriaNameNotFound,
+                        std::string,
+                        << "Could not find entry <"
+                        << arg1
+                        << "> among the names of registered termination criteria objects.");
+      private:
+        /**
+         * A list of names corresponding to the termination criteria in the
+         * termination_objects.
+         */
+        std::list<std::string>                       termination_obj_names;
+    };
+
+
+
+    /**
+     * Given a class name, a name, and a description for the parameter file
+     * for a termination criterion object, register it with the
+     * aspect::TerminationCriteria::Manager class.
+     *
+     * @ingroup TerminationCriteria
+     */
+#define ASPECT_REGISTER_TERMINATION_CRITERION(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_TERMINATION_CRITERION_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::TerminationCriteria::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::TerminationCriteria::Manager<2>::register_termination_criterion, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::TerminationCriteria::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::TerminationCriteria::Manager<3>::register_termination_criterion, \
+                                name, description); \
+  }
+  }
+}
+
+
+#endif
diff --git a/include/aspect/termination_criteria/steady_heat_flux.h.bak b/include/aspect/termination_criteria/steady_heat_flux.h.bak
new file mode 100644
index 00000000000..88f3cd3d782
--- /dev/null
+++ b/include/aspect/termination_criteria/steady_heat_flux.h.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_termination_criteria_steady_heat_flux_h
+#define _aspect_termination_criteria_steady_heat_flux_h
+
+#include <aspect/termination_criteria/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    /**
+     * A class that implements a termination criterion based on the steady state
+     * of the average heat flux.
+     *
+     * @ingroup TerminationCriteria
+     */
+    template <int dim>
+    class SteadyHeatFlux : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate this termination criterion.
+         *
+         * @return Whether to terminate the simulation (true) or continue
+         * (false).
+         */
+        bool
+        execute () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The minimum length of simulation time that the system
+         * should be in steady state before termination.
+         */
+        double necessary_time_in_steady_state;
+
+        /**
+         * The maximum relative deviation of the heat flux in recent
+         * simulation time for the system to be considered in steady state.
+         */
+        double allowed_relative_deviation;
+
+        /**
+         * A set of boundary ids on which the average heat flux will be
+         * computed.
+         */
+        std::set<types::boundary_id> boundary_indicators;
+
+        /**
+         * A list of pairs (time, heat flux) that we have computed at
+         * previous time steps. This is used to determine when we have reached
+         * steady state.
+         */
+        std::list<std::pair<double, double>>   time_heat_flux;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/termination_criteria/steady_rms_velocity.h.bak b/include/aspect/termination_criteria/steady_rms_velocity.h.bak
new file mode 100644
index 00000000000..00a23c9e132
--- /dev/null
+++ b/include/aspect/termination_criteria/steady_rms_velocity.h.bak
@@ -0,0 +1,79 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_termination_criteria_steady_rms_velocity_h
+#define _aspect_termination_criteria_steady_rms_velocity_h
+
+#include <aspect/termination_criteria/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+
+    /**
+     * A class that implements a termination criterion based on steady state
+     * of the root mean square of the velocity field.
+     *
+     * @ingroup TerminationCriteria
+     */
+    template <int dim>
+    class SteadyRMSVelocity : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate this termination criterion.
+         *
+         * @return Whether to terminate the simulation (true) or continue
+         * (false).
+         */
+        bool
+        execute () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        double                                  time_length;
+        double                                  relative_deviation;
+
+        /**
+         * A list of pairs (time, rms_velocity) that we have computed at
+         * previous time steps. This is used to determine when we have reached
+         * steady state.
+         */
+        std::list<std::pair<double, double>>   time_rmsvel;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/termination_criteria/steady_temperature.h.bak b/include/aspect/termination_criteria/steady_temperature.h.bak
new file mode 100644
index 00000000000..922df3795ab
--- /dev/null
+++ b/include/aspect/termination_criteria/steady_temperature.h.bak
@@ -0,0 +1,78 @@
+/*
+  Copyright (C) 2019 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_termination_criteria_steady_temperature_h
+#define _aspect_termination_criteria_steady_temperature_h
+
+#include <aspect/termination_criteria/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    /**
+     * A class that implements a termination criterion based on the steady state
+     * of the average temperature.
+     *
+     * @ingroup TerminationCriteria
+     */
+    template <int dim>
+    class SteadyTemperature : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate this termination criterion.
+         *
+         * @return Whether to terminate the simulation (true) or continue
+         * (false).
+         */
+        bool
+        execute () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        double                                  necessary_time_in_steady_state;
+        double                                  allowed_relative_deviation;
+
+        /**
+         * A list of pairs (time, temperature) that we have computed at
+         * previous time steps. This is used to determine when we have reached
+         * steady state.
+         */
+        std::list<std::pair<double, double>>   time_temperature;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/termination_criteria/user_request.h.bak b/include/aspect/termination_criteria/user_request.h.bak
new file mode 100644
index 00000000000..245ad1926e3
--- /dev/null
+++ b/include/aspect/termination_criteria/user_request.h.bak
@@ -0,0 +1,72 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_termination_criteria_user_request_h
+#define _aspect_termination_criteria_user_request_h
+
+#include <aspect/termination_criteria/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+
+    /**
+     * A class that terminates the simulation when a specified file appears in
+     * the working directory. This allows the user to gracefully exit the
+     * simulation at any time.
+     *
+     * @ingroup TerminationCriteria
+     */
+    template <int dim>
+    class UserRequest : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Evaluate this termination criterion.
+         *
+         * @return Whether to terminate the simulation (true) or continue
+         * (false).
+         */
+        bool
+        execute () override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        std::string             filename_to_test;
+    };
+  }
+}
+
+#endif
diff --git a/include/aspect/time_stepping/conduction_time_step.h.bak b/include/aspect/time_stepping/conduction_time_step.h.bak
new file mode 100644
index 00000000000..38101bca10e
--- /dev/null
+++ b/include/aspect/time_stepping/conduction_time_step.h.bak
@@ -0,0 +1,61 @@
+/*
+  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_time_stepping_conduction_time_step_h
+#define _aspect_time_stepping_conduction_time_step_h
+
+#include <aspect/time_stepping/interface.h>
+
+
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    using namespace dealii;
+
+    /**
+     * Compute the conduction time step based on the current solution and
+     * return this as the time step.
+     *
+     * @ingroup TimeStepping
+     */
+    template <int dim>
+    class ConductionTimeStep : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        ConductionTimeStep () = default;
+
+
+        /**
+         * @copydoc aspect::TimeStepping::Interface<dim>::execute()
+         */
+        double
+        execute() override;
+
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/time_stepping/convection_time_step.h.bak b/include/aspect/time_stepping/convection_time_step.h.bak
new file mode 100644
index 00000000000..fa18a9032e2
--- /dev/null
+++ b/include/aspect/time_stepping/convection_time_step.h.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2014 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_time_stepping_convection_time_step_h
+#define _aspect_time_stepping_convection_time_step_h
+
+#include <aspect/time_stepping/interface.h>
+
+
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    using namespace dealii;
+
+    /**
+     * Compute the convection time step based on the current solution and
+     * return it.
+     *
+     * @ingroup TimeStepping
+     */
+    template <int dim>
+    class ConvectionTimeStep : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        ConvectionTimeStep () = default;
+
+
+        /**
+         * @copydoc aspect::TimeStepping::Interface<dim>::execute()
+         */
+        double
+        execute() override;
+
+      private:
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/time_stepping/function.h.bak b/include/aspect/time_stepping/function.h.bak
new file mode 100644
index 00000000000..0a1608f0674
--- /dev/null
+++ b/include/aspect/time_stepping/function.h.bak
@@ -0,0 +1,72 @@
+/*
+  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_time_stepping_function_h
+#define _aspect_time_stepping_function_h
+
+#include <aspect/time_stepping/interface.h>
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a time stepping plugin on a function
+     * description provided in the input file.
+     *
+     * @ingroup TimeStepping
+     */
+    template <int dim>
+    class Function : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Function () = default;
+
+        /**
+         * The main execute() function.
+         */
+        double
+        execute() override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * The function object.
+         */
+        Functions::ParsedFunction<1> function;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/time_stepping/interface.h.bak b/include/aspect/time_stepping/interface.h.bak
new file mode 100644
index 00000000000..a59a5728341
--- /dev/null
+++ b/include/aspect/time_stepping/interface.h.bak
@@ -0,0 +1,284 @@
+/*
+  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _aspect_time_stepping_interface_h
+#define _aspect_time_stepping_interface_h
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+#include <aspect/termination_criteria/interface.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  /**
+   * A namespace containing all class related to the time stepping plugin system.
+   */
+  namespace TimeStepping
+  {
+
+    /**
+     * This enum describes the possible reactions by the time stepping plugins after the
+     * computation of each time step.
+     *
+     * Note: the ordering of the options is crucial, as the Manager will use the minimum
+     * of the values given by all active plugins as the reaction to take. This means the
+     * first entry has highest priority.
+     */
+    enum class Reaction
+    {
+      /**
+       * Initiate mesh refinement and go back in time to repeat the last timestep.
+       */
+      refine_and_repeat_step,
+      /**
+       * Go back in time to repeat the last timestep.
+       */
+      repeat_step,
+      /**
+       * Initiate mesh refinement and continue to the next timestep.
+       */
+      refine_and_advance,
+      /**
+       * Continue to the next timestep. The default action to take.
+       */
+      advance
+    };
+
+    /**
+     * Information passed to Interface::determine_reaction with information
+     * about the time step.
+     */
+    struct TimeStepInfo
+    {
+      /**
+       * The proposed time step size for the next step as computed by querying
+       * plugins and applying other logic.
+       */
+      double next_time_step_size;
+
+      /**
+       * If true, a termination criterion decided to shorten the time step
+       * size.
+       */
+      bool reduced_by_termination_plugin;
+    };
+
+    /**
+     * A base class for parameterizations of the time stepping models.
+     *
+     * @ingroup TimeStepping
+     */
+    template <int dim>
+    class Interface : public Plugins::InterfaceBase
+    {
+      public:
+        /**
+         * Execute the logic of the plugin.
+         *
+         * This is called after every time step to determine
+         * a) What to do (advance, repeat, etc.), see the Reaction enum.
+         * b) What timestep size to use.
+         *
+         */
+        virtual
+        double
+        execute() = 0;
+
+        /**
+         * Determine what we want with the simulation to happen next: advance,
+         * repeat, refinement, etc.. The second return value is the time step
+         * size to take in case the plugin requests a repeated time step.
+         *
+         * The argument @p info contains information like the step size that
+         * would be taken in this time step (determined as the minimum of the
+         * return value of execute() from all plugins).
+         *
+         * The default implementation of this function will always advance
+         * to the next time step.
+         */
+        virtual
+        std::pair<Reaction, double>
+        determine_reaction(const TimeStepInfo &info);
+    };
+
+
+    /**
+     * A class to handle computation of the next time step (as desired by the user) and
+     * checking if the simulation is finished.
+     */
+    template <int dim>
+    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Override initialize_simulator() so that we can also initialize the contained
+         * termination_manager.
+         */
+        void initialize_simulator (const Simulator<dim> &simulator_object) override;
+
+
+        /**
+         * Update the current state and determine what needs to happen based on the
+         * last computed solution (see functions below). This computes the size of
+         * the next time step potentially taking into account the current solution
+         * (convection time step, conduction time step), settings from parameters,
+         * and termination criteria (to hit the end time exactly).
+         */
+        void
+        update() override;
+
+        /**
+         * Return the next step size as computed from update().
+         */
+        double get_next_time_step_size() const;
+
+        /**
+         * If true, a plugin requested to redo the last computed time step. Updated
+         * when calling update().
+         */
+        bool should_repeat_time_step() const;
+
+        /**
+         * If true, execute a mesh refinement step now (potentially before repeating
+         * the current time step).
+         */
+        bool should_refine_mesh() const;
+
+        /**
+         * If true, the simulator should perform a checkpoint before terminating.
+         */
+        bool need_checkpoint_on_terminate() const;
+
+        /**
+         * Check if the simulation is ready to terminate successfully.
+         */
+        bool should_simulation_terminate_now() const;
+
+        /**
+         * Declare the parameters of all known termination criteria plugins,
+         * as well as of ones this class has itself.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         * This determines which termination criteria objects will be created;
+         * then let these objects read their parameters as well.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+        /**
+         * For the current plugin subsystem, write a connection graph of all of the
+         * plugins we know about, in the format that the
+         * programs dot and neato understand. This allows for a visualization of
+         * how all of the plugins that ASPECT knows about are interconnected, and
+         * connect to other parts of the ASPECT code.
+         *
+         * @param output_stream The stream to write the output to.
+         */
+        static
+        void
+        write_plugin_graph (std::ostream &output_stream);
+
+
+        /**
+         * A function that is used to register time stepping model objects in such
+         * a way that the Manager can deal with all of them without having to
+         * know them by name. This allows the files in which individual
+         * plugins are implemented to register these plugins, rather than also
+         * having to modify the Manager class by adding the new plugin class.
+         *
+         * @param name A string that identifies the model
+         * @param description A text description of what this model does and that
+         * will be listed in the documentation of the parameter file.
+         * @param declare_parameters_function A pointer to a function that can be
+         * used to declare the parameters that this model wants to read
+         * from input files.
+         * @param factory_function A pointer to a function that can create an
+         * object of this model.
+         *
+         * @ingroup TimeStepping
+         */
+        static
+        void
+        register_time_stepping_model (const std::string &name,
+                                      const std::string &description,
+                                      void (*declare_parameters_function) (ParameterHandler &),
+                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
+
+      private:
+
+        /**
+         * The current Reaction computed by update().
+         */
+        Reaction current_reaction;
+
+        /**
+         * The next time step size computed by update().
+         */
+        double next_time_step_size;
+
+        /**
+         * The minimum time step size specified by the user (in seconds).
+         */
+        double minimum_time_step_size;
+
+        /**
+         * Whether to do a final checkpoint before termination. This is
+         * specified in the parameters.
+         */
+        bool do_checkpoint_on_terminate;
+
+        /**
+         * The termination manager keeps track of the termination plugins and we use
+         * it to determine the time_step size in the final time step.
+         */
+        TerminationCriteria::Manager<dim> termination_manager;
+    };
+
+    /**
+     * Given a class name, a name, and a description for the parameter file, register it with the
+     * aspect::TimeStepping::Manager class.
+     *
+     * @ingroup TimeStepping
+     */
+#define ASPECT_REGISTER_TIME_STEPPING_MODEL(classname,name,description) \
+  template class classname<2>; \
+  template class classname<3>; \
+  namespace ASPECT_REGISTER_TIME_STEPPING_MODEL_ ## classname \
+  { \
+    aspect::internal::Plugins::RegisterHelper<aspect::TimeStepping::Interface<2>,classname<2>> \
+    dummy_ ## classname ## _2d (&aspect::TimeStepping::Manager<2>::register_time_stepping_model, \
+                                name, description); \
+    aspect::internal::Plugins::RegisterHelper<aspect::TimeStepping::Interface<3>,classname<3>> \
+    dummy_ ## classname ## _3d (&aspect::TimeStepping::Manager<3>::register_time_stepping_model, \
+                                name, description); \
+  }
+
+  }
+}
+
+#endif
diff --git a/include/aspect/time_stepping/repeat_on_cutback.h.bak b/include/aspect/time_stepping/repeat_on_cutback.h.bak
new file mode 100644
index 00000000000..624e2b90cea
--- /dev/null
+++ b/include/aspect/time_stepping/repeat_on_cutback.h.bak
@@ -0,0 +1,85 @@
+/*
+  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_time_stepping_repeat_on_cutback_h
+#define _aspect_time_stepping_repeat_on_cutback_h
+
+#include <aspect/time_stepping/interface.h>
+
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements a time stepping plugin to repeat a time step if the
+     * next time step is significantly smaller than the last step.
+     *
+     * @ingroup TimeStepping
+     */
+    template <int dim>
+    class RepeatOnCutback : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        RepeatOnCutback () = default;
+
+        /**
+         * @copydoc aspect::TimeStepping::Interface<dim>::execute()
+         */
+        double
+        execute() override;
+
+        /**
+         * The main execute() function.
+         */
+        std::pair<Reaction, double>
+        determine_reaction(const TimeStepInfo &info) override;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Parameter to determine how much smaller the time step should be
+         * repeated as.
+         */
+        double cut_back_amount;
+
+        /**
+         * Parameter that controls when to repeat a time step. If the newly
+         * computed step size is smaller than the last step size multiplied by
+         * this factor, the step is repeated.
+         */
+        double repeat_threshold;
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/utilities.h.bak b/include/aspect/utilities.h.bak
new file mode 100644
index 00000000000..68ed43c9d5b
--- /dev/null
+++ b/include/aspect/utilities.h.bak
@@ -0,0 +1,1392 @@
+/*
+  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_utilities_h
+#define _aspect_utilities_h
+
+#include <aspect/global.h>
+
+#include <array>
+#include <random>
+#include <deal.II/base/point.h>
+#include <deal.II/base/conditional_ostream.h>
+#include <deal.II/base/table_indices.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/fe/component_mask.h>
+
+#include <aspect/coordinate_systems.h>
+#include <aspect/structured_data.h>
+
+
+
+namespace aspect
+{
+  template <int dim> class SimulatorAccess;
+
+  namespace GeometryModel
+  {
+    template <int dim> class Interface;
+  }
+
+  /**
+   * A namespace for utility functions that might be used in many different
+   * places to prevent code duplication.
+   */
+  namespace Utilities
+  {
+    using namespace dealii;
+    using namespace dealii::Utilities;
+
+
+    /**
+     * Given an array @p values, consider three cases:
+     * - If it has size @p N, return the original array.
+     * - If it has size one, return an array of size @p N where all
+     *   elements are equal to the one element of @p value.
+     * - If it has any other size, throw an exception that uses
+     *   @p id_text as an identifying string.
+     *
+     * This function is typically used for parameter lists that can either
+     * contain different values for each of a set of objects (e.g., for
+     * each compositional field), or contain a single value that is then
+     * used for each object.
+     */
+    template <typename T>
+    std::vector<T>
+    possibly_extend_from_1_to_N (const std::vector<T> &values,
+                                 const unsigned int N,
+                                 const std::string &id_text);
+
+    namespace MapParsing
+    {
+      /**
+       * A struct that bundles all the available options for
+       * parse_map_to_double_array().
+       */
+      struct Options
+      {
+        /* A list of valid key names that are allowed
+         * to appear in the map. If this list is empty
+         * it is assumed to be equal to the list of
+         * required keys. If this list is longer than
+         * list_of_required_keys, every key that is
+         * allowed but not required will be ignored when
+         * parsing the map.
+         */
+        std::vector<std::string> list_of_allowed_keys;
+
+        /* A list of valid key names that are required
+         * to appear in the map. Only these keys will be
+         * parsed into the map structure and the order of
+         * these keys determines the order of entries
+         * in the output vector.
+         */
+        std::vector<std::string> list_of_required_keys;
+
+        /*
+         * A name that identifies the type of input property (e.g. 'density', 'viscosity')
+         * that is being parsed by this function. This name is used in generating
+         * error messages if the map does not conform to the expected format.
+         */
+        std::string property_name;
+
+        /*
+         * If true, allow multiple values
+         * for each key. If false only allow a single value per key. In either
+         * case each key is only allowed to appear once. Multiple values
+         * for a key are delimited by a "|" character, as in
+         * "key1: value1|value2|value3, key2: value1|value2".
+         */
+        bool allow_multiple_values_per_key;
+
+        /*
+         * Whether to allow for some keys in list_of_required_keys to be
+         * not set to any values, i.e. they do not appear at all.
+         * This also allows a completely empty map.
+         */
+        bool allow_missing_keys;
+
+        /*
+         * Whether to store the number of values
+         * per key in n_values_per_key while creating
+         * the map. This vector can be later accessed
+         * and used (for example) to check that subsequent calls to
+         * parse other input parameters have the same
+         * structure.
+         */
+        bool store_values_per_key;
+
+        /*
+         * Whether to check the number of values
+         * per key in the map against values stored
+         * in n_values_per_key. This allows to
+         * check that subsequent calls to
+         * parse other input parameters have the same
+         * structure.
+         */
+        bool check_values_per_key;
+
+        /*
+         * A vector of unsigned
+         * integers that is used by store_values_per_key and
+         * check_values_per_key to either store the current map
+         * structure or check the map structure against an existing
+         * map. This parameter is only used if either of these
+         * two parameters are set to true
+         */
+        std::vector<unsigned int> n_values_per_key;
+
+        /**
+         * Delete the default constructor, because we want to ensure that
+         * at least the required options are always set.
+         */
+        Options() = delete;
+
+        /**
+         * A constructor for options that only sets the required
+         * parameters and leaves all other parameters at their default values.
+         * By default the @p list_of_required_keys will be used as both
+         * the list of allowed and list of required keys. In other words
+         * exactly these keys and no other keys are allowed to appear
+         * in the input and all of the keys have to be specified and will
+         * be included in the output. For a documentation of the parameters
+         * see the documentation of the member variables of this class.
+         */
+        Options(const std::vector<std::string> &list_of_required_keys,
+                const std::string &property_name)
+          :
+          list_of_allowed_keys(list_of_required_keys),
+          list_of_required_keys(list_of_required_keys),
+          property_name(property_name),
+          allow_multiple_values_per_key(false),
+          allow_missing_keys(false),
+          store_values_per_key(false),
+          check_values_per_key(false),
+          n_values_per_key()
+        {}
+      };
+
+      /**
+       * This function takes a string argument that is interpreted as a map
+       * of the form "key1 : value1, key2 : value2, etc", and then parses
+       * it to return a vector of these values. The parsing and output
+       * is controlled by @p options, which provides control over which keys
+       * (and how many) are allowed and required, whether multiple values
+       * per keys are allowed, whether the structure of the map is recorded
+       * while parsing, or checked against an existing structure and some other
+       * options. See the documentation of MapParsing::Options for available
+       * settings.
+       *
+       * @param[in] input_string The string representation of the map
+       *   to be parsed.
+       * @param[in] options An object of type MapParsing::Options() that contains
+       *   the parsing options that are considered by this function. See the
+       *   documentation of Options() for the available settings.
+       *
+       * @return A vector of values that are parsed from the @p input_string according
+       *   to the provided @p options and is sorted according to the member variable
+       *   list_of_required_keys inside @p options.
+       *   If multiple values per key are allowed, the vector contains first all
+       *   values for key 1, then all values for key 2 and so forth. Using the
+       *   n_values_per_key vector inside @p options allows the caller to
+       *   associate entries in the returned vector with specific keys.
+       */
+      std::vector<double>
+      parse_map_to_double_array(const std::string &input_string,
+                                Options &options);
+    }
+
+    /**
+     * This function takes a string argument that is interpreted as a map
+     * of the form "key1 : value1, key2 : value2, etc", and then parses
+     * it to return a vector of these values where the values are ordered
+     * in the same order as a given set of keys. If @p allow_multiple_values_per_key
+     * is set to 'true' it also allows entries of the form
+     * "key1: value1|value2|value3, etc", in which case the returned
+     * vector will have more entries than the provided
+     * @p list_of_keys.
+     *
+     * This function also considers a number of special cases:
+     * - If the input string consists of only a comma separated
+     *   set of values "value1, value2, value3, ..." (i.e., without
+     *   the "keyx :" part), then the input string is interpreted
+     *   as if it had had the form "key1 : value1, key2 : value2, ..."
+     *   where "key1", "key2", ... are exactly the keys provided by the
+     *   @p list_of_keys in the same order as provided. In this situation,
+     *   if a background field is required, the background value is
+     *   assigned to the first element of the output vector. This form only
+     *   allows a single value per key.
+     * - Whether or not a background field is required depends on
+     *   @p expects_background_field. Requiring a background field
+     *   inserts "background" into the @p list_of_keys as the first entry
+     *   in the list. Some calling functions (like some material models)
+     *   require values for background fields, while others may not
+     *   need background values.
+     * - Two special keys are recognized:
+     *      all --> Assign the associated value to all fields.
+     *              Only one key is allowed in this case.
+     *      background --> Assign associated value to the background.
+     *
+     * @param[in] key_value_map The string representation of the map
+     *   to be parsed.
+     * @param[in] list_of_keys A list of N valid key names that are allowed
+     *   to appear in the map. The order of these keys determines the order
+     *   of values that are returned by this function.
+     * @param[in] expects_background_field If true, expect N+1 values and allow
+     *   setting of the background using the key "background".
+     * @param[in] property_name A name that identifies the type of property
+     *   that is being parsed by this function and that is used in generating
+     *   error messages if the map does not conform to the expected format.
+     * @param [in] allow_multiple_values_per_key If true allow having multiple values
+     *   for each key. If false only allow a single value per key. In either
+     *   case each key is only allowed to appear once.
+     * @param [in,out] n_values_per_key A pointer to a vector of unsigned
+     *   integers. If no pointer is handed over nothing happens. If a pointer
+     *   to an empty vector is handed over, the vector
+     *   is resized with as many components as
+     *   keys (+1 if there is a background field). Each value then stores
+     *   how many values were found for this key. The sum over all
+     *   entries is the length of the return value of this function.
+     *   If a pointer to an existing vector with one or more entries is
+     *   handed over (e.g. a n_values_per_key vector created by a
+     *   previous call to this function) then this vector is used as
+     *   expected structure of the input parameter, and it is checked that
+     *   @p key_value_map fulfills this structure. This can be used to assert
+     *   that several input parameters prescribe the same number of values
+     *   to each key.
+     * @param [in] allow_missing_keys Whether to allow that some keys are
+     *   not set to any values, i.e. they do not appear at all in the
+     *   @p key_value_map. This also allows a completely empty map.
+     *
+     * @return A vector of values that are parsed from the map, provided
+     *   in the order in which the keys appear in the @p list_of_keys argument.
+     *   If multiple values per key are allowed, the vector contains first all
+     *   values for key 1, then all values for key 2 and so forth. Using the
+     *   @p n_values_per_key vector allows the caller to associate entries in the
+     *   returned vector with specific keys.
+     *
+     * @deprecated: This function is deprecated in favor of the more general
+     *   Utilities::MapParsing::parse_map_to_double_array() function. Please
+     *   use the other function instead.
+     */
+    std::vector<double>
+    parse_map_to_double_array (const std::string &key_value_map,
+                               const std::vector<std::string> &list_of_keys,
+                               const bool expects_background_field,
+                               const std::string &property_name,
+                               const bool allow_multiple_values_per_key = false,
+                               const std::unique_ptr<std::vector<unsigned int>> &n_values_per_key = nullptr,
+                               const bool allow_missing_keys = false);
+
+    /**
+     * This function takes a string argument that is assumed to represent
+     * an input table, in which each row is separated by
+     * semicolons, and each column separated by commas. The function
+     * returns the parsed entries as a table. In addition this function
+     * utilizes the possibly_extend_from_1_to_N() function to accept
+     * inputs with only a single column/row, which will be extended
+     * to @p n_rows or @p n_columns respectively, to allow abbreviating
+     * the input string (e.g. you can provide a single value instead of
+     * n_rows by n_columns identical values). This function can for example
+     * be used by material models to read densities for different
+     * compositions and different phases for each composition.
+     */
+    template <typename T>
+    Table<2,T>
+    parse_input_table (const std::string &input_string,
+                       const unsigned int n_rows,
+                       const unsigned int n_columns,
+                       const std::string &property_name);
+
+    /**
+     * Given a vector @p var_declarations expand any entries of the form
+     * vector(str) or tensor(str) to sublists with component names of the form
+     * str_x, str_y, str_z or str_xx, str_xy... for the correct dimension
+     * value.
+     *
+     * This function is to be used for expanding lists of variable names where
+     * one or more such variable is actually intended to be a list of
+     * components.
+     *
+     * Returns the generated list of variable names
+     */
+    template <int dim>
+    std::vector<std::string>
+    expand_dimensional_variable_names (const std::vector<std::string> &var_declarations);
+
+    /**
+     * Returns an IndexSet that contains all locally active DoFs that belong to
+     * the given component_mask.
+     *
+     * This function should be moved into deal.II at some point.
+     */
+    template <int dim>
+    IndexSet extract_locally_active_dofs_with_component(const DoFHandler<dim> &dof_handler,
+                                                        const ComponentMask &component_mask);
+
+    /**
+     * This function retrieves the unit support points (in the unit cell) for the current element.
+     * The DGP element used when 'set Use locally conservative discretization = true' does not
+     * have support points. If these elements are in use, a fictitious support point at the cell
+     * center is returned for each shape function that corresponds to the pressure variable,
+     * whereas the support points for the velocity are correct. The fictitious points don't matter
+     * because we only use this function when interpolating the velocity variable, and ignore the
+     * evaluation at the pressure support points.
+     */
+    template <int dim>
+    std::vector<Point<dim>> get_unit_support_points(const SimulatorAccess<dim> &simulator_access);
+
+
+
+    /**
+     * Given a point @p point, find out if any of the MPI
+     * processes own the cell in which this point lies. If
+     * not, the point lies outside the @p triangulation.
+     */
+    template <int dim>
+    bool
+    point_is_in_triangulation(const Mapping<dim> &mapping,
+                              const parallel::distributed::Triangulation<dim> &triangulation,
+                              const Point<dim> &point,
+                              const MPI_Comm mpi_communicator);
+
+
+    namespace Coordinates
+    {
+
+      /**
+       * Returns distance from the Earth's center, latitude and longitude from a
+       * given ECEF Cartesian coordinates that account for ellipsoidal shape of
+       * the Earth with WGS84 parameters.
+       */
+      template <int dim>
+      std::array<double,dim>
+      WGS84_coordinates(const dealii::Point<dim> &position);
+
+      /**
+       * Returns spherical coordinates of a Cartesian point. If `dim==3`, then
+       * the returned array contains the three values radius, phi, and theta
+       * (polar angle). In other words, the two angles correspond to longitude
+       * and *colatitude* (instead of latitude). If `dim==2`, then theta is omitted.
+       * The longitude Phi is always considered in the interval $[0,2\pi]$. Note
+       * that that implies that input files that use spherical coordinates also
+       * have to provide data using this convention, rather than providing their
+       * data from $-\pi$ (=180 degrees west) to $+\pi$ (=180 degrees east).
+       */
+      template <int dim>
+      std::array<double,dim>
+      cartesian_to_spherical_coordinates(const dealii::Point<dim> &position);
+
+      /**
+       * Return the Cartesian point of a spherical position defined by radius,
+       * phi and theta (polar angle). If the dimension is set to 2 theta is
+       * omitted.
+       */
+      template <int dim>
+      dealii::Point<dim>
+      spherical_to_cartesian_coordinates(const std::array<double,dim> &scoord);
+
+      /**
+       * Given a vector defined in the radius, phi and theta directions, return
+       * a vector defined in Cartesian coordinates. If the dimension is set to 2
+       * theta is omitted. Position is given as a Point in Cartesian coordinates.
+       */
+      template <int dim>
+      Tensor<1,dim>
+      spherical_to_cartesian_vector(const Tensor<1,dim> &spherical_vector,
+                                    const dealii::Point<dim> &position);
+
+
+      /**
+       * Returns ellipsoidal coordinates of a Cartesian point. The returned array
+       * is filled with phi, theta and radius.
+       *
+       */
+      template <int dim>
+      std::array<double,3>
+      cartesian_to_ellipsoidal_coordinates(const dealii::Point<3> &position,
+                                           const double semi_major_axis_a,
+                                           const double eccentricity);
+
+      /**
+       * Return the Cartesian point of a ellipsoidal position defined by phi,
+       * theta and radius.
+       */
+      template <int dim>
+      dealii::Point<3>
+      ellipsoidal_to_cartesian_coordinates(const std::array<double,3> &phi_theta_d,
+                                           const double semi_major_axis_a,
+                                           const double eccentricity);
+
+
+      /**
+       * A function that takes a string representation of the name of a
+       * coordinate system (as represented by the CoordinateSystem enum)
+       * and returns the corresponding value.
+       */
+      CoordinateSystem
+      string_to_coordinate_system (const std::string &);
+    }
+
+
+    /**
+     * Given a 2d point and a list of points which form a polygon, computes if the point
+     * falls within the polygon.
+     */
+    template <int dim>
+    bool
+    polygon_contains_point(const std::vector<Point<2>> &point_list,
+                           const dealii::Point<2> &point);
+
+    /**
+     * Given a 2d point and a list of points which form a polygon, compute the smallest
+     * distance of the point to the polygon. The sign is negative for points outside of
+     * the polygon and positive for points inside the polygon.
+     */
+    template <int dim>
+    double
+    signed_distance_to_polygon(const std::vector<Point<2>> &point_list,
+                               const dealii::Point<2> &point);
+
+
+    /**
+     * Given a 2d point and a list of two points that define a line, compute the smallest
+     * distance of the point to the line segment. When the point's perpendicular
+     * base does not lie on the line segment, the smallest distance to the segment's end
+     * points is calculated.
+     */
+    double
+    distance_to_line(const std::array<dealii::Point<2>,2> &point_list,
+                     const dealii::Point<2> &point);
+
+    /**
+     * Given a vector @p v in @p dim dimensional space, return a set
+     * of (dim-1) vectors that are orthogonal to @p v and to each
+     * other. The length of each of these vectors equals that of the original
+     * vector @p v to ensure that the resulting set of vectors
+     * represents a well-conditioned basis.
+     */
+    template <int dim>
+    std::array<Tensor<1,dim>,dim-1>
+    orthogonal_vectors (const Tensor<1,dim> &v);
+
+    /**
+     * A function that returns the corresponding euler angles for a
+     * rotation described by rotation axis and angle.
+     */
+    Tensor<2,3>
+    rotation_matrix_from_axis (const Tensor<1,3> &rotation_axis,
+                               const double rotation_angle);
+
+    /**
+     * Compute the 3d rotation matrix that describes the rotation of a
+     * plane defined by the two points @p point_one and @p point_two
+     * onto the x-y-plane in a way that the vector from the origin to
+     * point_one points into the (0,1,0) direction after the rotation.
+     */
+    Tensor<2,3>
+    compute_rotation_matrix_for_slice (const Tensor<1,3> &point_one,
+                                       const Tensor<1,3> &point_two);
+
+    /**
+     * A function for evaluating real spherical harmonics. It takes the degree (l)
+     * and the order (m) of the spherical harmonic, where $l \geq 0$ and $0 \leq m \leq l$.
+     * It also takes the colatitude (theta) and longitude (phi), which are in
+     * radians.
+     *
+     * There are an unfortunate number of normalization conventions in existence
+     * for spherical harmonics. Here we use fully normalized spherical harmonics
+     * including the Condon-Shortley phase. This corresponds to the definitions
+     * given in equations B.72 and B.99-B.102 in Dahlen and Tromp (1998, ISBN: 9780691001241).
+     * The functional form of the real spherical harmonic is given by
+     *
+     * \f[
+     *    Y_{lm}(\theta, \phi) = \sqrt{2} X_{l \left| m \right| }(\theta) \cos m \phi \qquad \mathrm{if} \qquad -l \le m < 0
+     * \f]
+     * \f[
+     *    Y_{lm}(\theta, \phi) = X_{l 0 }(\theta) \qquad \mathrm{if} \qquad m = 0
+     * \f]
+     * \f[
+     *    Y_{lm}(\theta, \phi) = \sqrt{2} X_{lm}(\theta) \sin m \phi \qquad \mathrm{if}  \qquad 0< m \le m
+     * \f]
+     * where $X_{lm}( \theta )$ is an associated Legendre function.
+     *
+     * In practice it is often convenient to compute the sine ($-l \le m < 0$) and cosine ($0 < m \le l$)
+     * variants of the real spherical harmonic at the same time. That is the approach taken
+     * here, where we return a pair of numbers, the first corresponding the cosine part and the
+     * second corresponding to the sine part. Given this, it is no longer necessary to distinguish
+     * between positive and negative $m$, so this function only accepts $ m \ge 0$.
+     * For $m = 0$, there is only one part, which is stored in the first entry of the pair.
+     *
+     * @note This function uses the Boost spherical harmonics implementation internally,
+     * which is not designed for very high order (> 100) spherical harmonics computation.
+     * If you use spherical harmonics of a high order be sure to confirm the accuracy first.
+     * For more information, see:
+     * http://www.boost.org/doc/libs/1_49_0/libs/math/doc/sf_and_dist/html/math_toolkit/special/sf_poly/sph_harm.html
+     */
+    std::pair<double,double> real_spherical_harmonic( unsigned int l, // degree
+                                                      unsigned int m, // order
+                                                      double theta,   // colatitude (radians)
+                                                      double phi );   // longitude (radians)
+
+    /**
+     * A struct to enable numerical output with a comma as thousands separator
+     */
+    struct ThousandSep : std::numpunct<char>
+    {
+      protected:
+        char do_thousands_sep() const override
+        {
+          return ',';
+        }
+
+        std::string do_grouping() const override
+        {
+          return "\003";  // groups of 3 digits (this string is in octal format)
+        }
+
+    };
+
+    /**
+     * Checks whether a file named @p filename exists and is readable.
+     *
+     * Note: This function performs file access on all MPI ranks that
+     * call it. Only use this function if
+     * the file access is performed on all MPI ranks
+     * and on a reasonably fast file system.
+     *
+     * @return True if the file exists and is readable on all MPI ranks
+     * that call this function.
+     * @param filename File to check existence
+     */
+    bool fexists(const std::string &filename);
+
+    /**
+     * Check whether a file named @p filename exists and is readable
+     * on MPI rank 0. Then, broadcast the result to all MPI ranks.
+     *
+     * Note that in contrast to the other fexists() function, this function
+     * only checks for the existence of the file on a single process.
+     * This is useful to avoid overloading the file system and is sufficient
+     * if the subsequent file access is also only performed on MPI rank 0.
+     *
+     * @return True if the file exists and is readable on MPI rank 0.
+     * @param filename File to check existence
+     * @param comm MPI communicator to use.
+     */
+    bool fexists(const std::string &filename,
+                 const MPI_Comm comm);
+
+    /**
+     * Checks to see if the user is trying to use data from a url.
+     *
+     * @param filename File to check
+     */
+    bool filename_is_url(const std::string &filename);
+
+    /**
+     * Reads the content of the ascii file @p filename on process 0 and
+     * distributes the content by MPI_Bcast to all processes. The function
+     * returns the content of the file on all processes. The purpose of this
+     * function is to reduce parallel file access to a single file access on
+     * process 0.
+     *
+     * @param [in] filename The name of the ascii file to load. If the
+     *  file name ends in `.gz`, then the function assumes that the file
+     *  has been compressed using gzip; it then reads and uncompresses the file
+     *  before distributing it. If the file name is a URL (starting with either
+     *  `http://`, `https://`, or `file://`), and if ASPECT has been configured
+     *  with libDAP, then the file is read from that location via libDAP
+     *  and the returned string is an ASCII data representation of what was
+     *  obtained this way.
+     * @param [in] comm The MPI communicator in which the content is
+     * distributed.
+     * @return A string which contains the data in @p filename.
+     */
+    std::string
+    read_and_distribute_file_content(const std::string &filename,
+                                     const MPI_Comm comm);
+
+    /**
+     * Collect the content of @p file_content using MPI_Gather to process 0.
+     * Then write the content to the file @p filename on process 0.
+     * The purpose of this function is to reduce parallel file access to
+     * process 0. Note that this function assumes that the content from
+     * all processes fits into the memory of process 0.
+     *
+     * @param [in] filename The name of the file to write.
+     * @param [in] file_content The content that should be written to file.
+     * @param [in] comm The MPI communicator from which the content is
+     * collected.
+     */
+    void
+    collect_and_write_file_content(const std::string &filename,
+                                   const std::string &file_content,
+                                   const MPI_Comm comm);
+
+    /**
+     * Creates a path as if created by the shell command "mkdir -p", therefore
+     * generating directories from the highest to the lowest level if they are
+     * not already existing.
+     *
+     * @param pathname String that contains the path to create. '/' is used as
+     * directory separator.
+     * @param mode Permissions (mode bits) of the created directories. See the
+     * documentation of the chmod() command for more information.
+     * @return The function returns the error value of the last mkdir call
+     * inside. It returns zero on success. See the man page of mkdir() for
+     * more information.
+     */
+    int
+    mkdirp(std::string pathname, const mode_t mode = 0755);
+
+    /**
+     * Create directory @p pathname, optionally printing a message.
+     *
+     * @param pathname String that contains path to create. '/' is used as
+     * directory separator.
+     * @param comm MPI communicator, used to limit creation of directory to
+     * processor 0.
+     * @param silent Print a nicely formatted message on processor 0 if set
+     * to true.
+     */
+    void create_directory(const std::string &pathname,
+                          const MPI_Comm comm,
+                          bool silent);
+
+    /**
+     * A namespace defining the cubic spline interpolation that can be used
+     * between different spherical layers in the mantle.
+     */
+    namespace tk
+    {
+      /**
+       * Class for cubic spline interpolation
+       */
+      class spline
+      {
+        public:
+          /**
+           * Initialize the spline.
+           *
+           * @param x X coordinates of interpolation points.
+           * @param y Values in the interpolation points.
+           * @param cubic_spline Whether to construct a cubic spline or just do linear interpolation
+           * @param monotone_spline Whether the cubic spline should be a monotone cubic spline.
+           * Requires cubic_spline to be set to true.
+           */
+          void set_points(const std::vector<double> &x,
+                          const std::vector<double> &y,
+                          const bool cubic_spline = true,
+                          const bool monotone_spline = false);
+          /**
+           * Evaluate spline at point @p x.
+           */
+          double operator() (double x) const;
+
+        private:
+          /**
+           * x coordinates of points
+           */
+          std::vector<double> m_x;
+
+          /**
+           * interpolation parameters
+           * \[
+           * f(x) = a*(x-x_i)^3 + b*(x-x_i)^2 + c*(x-x_i) + y_i
+           * \]
+           */
+          std::vector<double> m_a, m_b, m_c, m_y;
+      };
+    }
+
+    /**
+     * Extract the compositional values at a single quadrature point with
+     * index @p q from @p composition_values, which is indexed by
+     * compositional index and quadrature point, and write them into @p
+     * composition_values_at_q_point. In other words,
+     * this extracts @p composition_values[i][q] for all @p i.
+     */
+    inline
+    void
+    extract_composition_values_at_q_point (const std::vector<std::vector<double>> &composition_values,
+                                           const unsigned int q,
+                                           std::vector<double> &composition_values_at_q_point);
+
+    /**
+     * Replace the string <tt>\$ASPECT_SOURCE_DIR</tt> in @p location by the current
+     * source directory of ASPECT and return the resulting string.
+     */
+    std::string
+    expand_ASPECT_SOURCE_DIR (const std::string &location);
+
+    /**
+     * Given a string @p s, return it in the form ' ("s")' if nonempty.
+     * Otherwise just return the empty string itself.
+     */
+    std::string parenthesize_if_nonempty (const std::string &s);
+
+    /**
+     * Given a string @p s, convert it to a boolean value.
+     */
+    bool
+    string_to_bool(const std::string &s);
+
+    /**
+     * Given a vector of strings @p s, convert it to a vector of boolean values.
+     */
+    std::vector<bool>
+    string_to_bool(const std::vector<std::string> &s);
+
+    /**
+     * Given a string @p s, convert it to an unsigned int.
+     */
+    unsigned int
+    string_to_unsigned_int(const std::string &s);
+
+    /**
+     * Given a vector of strings @p s, convert it to a vector of unsigned int values.
+     */
+    std::vector<unsigned int>
+    string_to_unsigned_int(const std::vector<std::string> &s);
+
+    /**
+     * Returns if a vector of strings @p strings only contains unique
+     * entries.
+     */
+    bool has_unique_entries (const std::vector<std::string> &strings);
+
+
+
+    /**
+     * This function computes the weighted average $\bar y$ of $y_i$  for a weighted p norm. This
+     * leads for a general p to:
+     * $\bar y = \left(\frac{\sum_{i=1}^k w_i y_i^p}{\sum_{i=1}^k w_i}\right)^{\frac{1}{p}}$.
+     * When p = 0 we take the geometric average:
+     * $\bar y = \exp\left(\frac{\sum_{i=1}^k w_i \log\left(y_i\right)}{\sum_{i=1}^k w_i}\right)$,
+     * and when $p \le -1000$ or $p \ge 1000$ we take the minimum and maximum norm respectively.
+     * This means that the smallest and largest value is respectively taken taken.
+     *
+     * This function has been set up to be very tolerant to strange values, such as negative weights.
+     * The only things we require in for the general p is that the sum of the weights and the sum of
+     * the weights times the values to the power p may not be smaller or equal to zero. Furthermore,
+     * when a value is zero, the exponent is smaller then one and the correspondent weight is non-zero,
+     * this corresponds to no resistance in a parallel system. This means that this 'path' will be followed,
+     * and we return zero.
+     *
+     * The implemented special cases (which are minimum (p <= -1000), harmonic average (p = -1), geometric
+     * average (p = 0), arithmetic average (p = 1), quadratic average (RMS) (p = 2), cubic average (p = 3)
+     * and maximum (p >= 1000) ) is, except for the harmonic and quadratic averages even more tolerant of
+     * negative values, because they only require the sum of weights to be non-zero.
+     */
+    double weighted_p_norm_average (const std::vector<double> &weights,
+                                    const std::vector<double> &values,
+                                    const double p);
+
+
+    /**
+     * This function computes the derivative ($\frac{\partial\bar y}{\partial x}$) of an average
+     * of the values $y_i(x)$ with regard to $x$, using $\frac{\partial y_i(x)}{\partial x}$.
+     * This leads for a general p to:
+     * $\frac{\partial\bar y}{\partial x} =
+     * \frac{1}{p}\left(\frac{\sum_{i=1}^k w_i y_i^p}{\sum_{i=1}^k w_i}\right)^{\frac{1}{p}-1}
+     * \frac{\sum_{i=1}^k w_i p y_i^{p-1} y'_i}{\sum_{i=1}^k w_i}$.
+     * When p = 0 we take the geometric average as a reference, which results in:
+     * $\frac{\partial\bar y}{\partial x} =
+     * \exp\left(\frac{\sum_{i=1}^k w_i \log\left(y_i\right)}{\sum_{i=1}^k w_i}\right)
+     * \frac{\sum_{i=1}^k\frac{w_i y'_i}{y_i}}{\sum_{i=1}^k w_i}$
+     * and when $p \le -1000$ or $p \ge 1000$ we take the min and max norm respectively.
+     * This means that the derivative is taken which has the min/max value.
+     *
+     * This function has, like the function weighted_p_norm_average been set up to be very tolerant to
+     * strange values, such as negative weights. The only things we require in for the general p is that
+     * the sum of the weights and the sum of the weights times the values to the power p may not be smaller
+     * or equal to zero. Furthermore, when a value is zero, the exponent is smaller then one and the
+     * correspondent weight is non-zero, this corresponds to no resistance in a parallel system. This means
+     * that this 'path' will be followed, and we return the corresponding derivative.
+     *
+     * The implemented special cases (which are minimum (p <= -1000), harmonic average (p = -1), geometric
+     * average (p = 0), arithmetic average (p = 1), and maximum (p >= 1000) ) is, except for the harmonic
+     * average even more tolerant of negative values, because they only require the sum of weights to be non-zero.
+     */
+    template <typename T>
+    T derivative_of_weighted_p_norm_average (const double averaged_parameter,
+                                             const std::vector<double> &weights,
+                                             const std::vector<double> &values,
+                                             const std::vector<T> &derivatives,
+                                             const double p);
+    /**
+     * This function computes a factor which can be used to make sure that the
+     * Jacobian remains positive definite.
+     *
+     * The goal of this function is to find a factor $\alpha$ so that
+     * $2\eta(\varepsilon(\mathbf u)) I \otimes I +  \alpha\left[a \otimes b + b \otimes a\right]$ remains a
+     * positive definite rank-4 tensor (i.e., a positive definite operator mapping
+     * rank-2 tensors to rank-2 tensors). By definition, the whole operator
+     * is symmetric. In the definition above, $a=\varepsilon(\mathbf u)$ is the @p strain_rate
+     * and $b=\frac{\partial\eta(\varepsilon(\mathbf u),p)}{\partial \varepsilon}$ is the derivative of the viscosity
+     * with respect to the strain rate and is given by @p dviscosities_dstrain_rate. Since the viscosity $\eta$
+     * must be positive, there is always a value of $\alpha$ (possibly small) so that the result is a positive
+     * definite operator. In the best case, we want to choose $\alpha=1$ because that corresponds to the full Newton step,
+     * and so the function never returns anything larger than one.
+     *
+     * One can do some algebra to determine what the optimal factor is. We did
+     * this in the Newton paper (Fraters et al., Geophysical Journal
+     * International, 2019) where we derived a factor of
+     * $\frac{2\eta(\varepsilon(\mathbf u))}{\left[1-\frac{b:a}{\|a\| \|b\|} \right]^2\|a\|\|b\|}$,
+     * which we reset to a maximum of one, and if it is smaller then one,
+     * a safety_factor scales the value to make sure that 1-alpha won't get to
+     * close to zero. However, as later pointed out by Yimin Jin, the computation
+     * is wrong, see https://github.com/geodynamics/aspect/issues/5555. Instead,
+     * the function now computes the factor as
+     * $(2 \eta) / (a:b + b:a)$, again capped at a maximal value of 1,
+     * and using a safety factor from below.
+     *
+     * In practice, $a$ and $b$ are almost always parallel to each other,
+     * and $a:b + b:a = 2a:b$, in which case one can drop the factor
+     * of $2$ everywhere in the computations.
+     */
+    template <int dim>
+    double compute_spd_factor(const double eta,
+                              const SymmetricTensor<2,dim> &strain_rate,
+                              const SymmetricTensor<2,dim> &dviscosities_dstrain_rate,
+                              const double SPD_safety_factor);
+
+    /**
+     * Converts an array of size dim to a Point of size dim.
+     */
+    template <int dim>
+    Point<dim> convert_array_to_point(const std::array<double,dim> &array);
+
+    /**
+     * Converts a Point of size dim to an array of size dim.
+     */
+    template <int dim>
+    std::array<double,dim> convert_point_to_array(const Point<dim> &point);
+
+    /**
+     * A class that represents a binary operator between two doubles. The type of
+     * operation is specified on construction time, and can be checked later
+     * by using the operator ==. The operator () executes the operation on two
+     * double parameters and returns the result. This class is helpful for
+     * user specified operations that are not known at compile time.
+     */
+    class Operator
+    {
+      public:
+        /**
+         * An enum of supported operations.
+         */
+        enum operation
+        {
+          uninitialized,
+          add,
+          subtract,
+          minimum,
+          maximum,
+          replace_if_valid
+        };
+
+        /**
+         * The default constructor creates an invalid operation that will fail
+         * if ever executed.
+         */
+        Operator();
+
+        /**
+         * Construct the selected operator.
+         */
+        Operator(const operation op);
+
+        /**
+         * Execute the selected operation with the given parameters and
+         * return the result.
+         */
+        double operator() (const double x, const double y) const;
+
+        /**
+         * Return the comparison result between the current operation and
+         * the one provided as argument.
+         */
+        bool operator== (const operation op) const;
+
+      private:
+        /**
+         * The selected operation of this object.
+         */
+        operation op;
+    };
+
+    /**
+     * Create a vector of operator objects out of a list of strings. Each
+     * entry in the list must match one of the allowed operations.
+     */
+    std::vector<Operator> create_model_operator_list(const std::vector<std::string> &operator_names);
+
+    /**
+     * Create a string of model operators for use in declare_parameters
+     */
+    const std::string get_model_operator_options();
+
+    /**
+     * A function that returns a SymmetricTensor, whose entries are zero, except for
+     * the k'th component, which is set to one. If k is not on the main diagonal the
+     * resulting tensor is symmetrized.
+     */
+    template <int dim>
+    SymmetricTensor<2,dim> nth_basis_for_symmetric_tensors (const unsigned int k);
+
+    /**
+     * A class that represents a point in a chosen coordinate system.
+     */
+    template <int dim>
+    class NaturalCoordinate
+    {
+      public:
+        /**
+         * Constructor based on providing the geometry model as a pointer.
+         */
+        NaturalCoordinate(Point<dim> &position,
+                          const GeometryModel::Interface<dim> &geometry_model);
+
+        /**
+         * Constructor based on providing the coordinates and associated
+         * coordinate system.
+         */
+        NaturalCoordinate(const std::array<double, dim> &coord,
+                          const Utilities::Coordinates::CoordinateSystem &coord_system);
+
+        /**
+         * Returns the coordinates in the given coordinate system, which may
+         * not be Cartesian.
+         */
+        std::array<double,dim> &get_coordinates();
+
+        /**
+         * Returns the coordinates in the given coordinate system, which may
+         * not be Cartesian.
+         */
+        const std::array<double,dim> &get_coordinates() const;
+
+        /**
+         * The coordinate that represents the 'surface' directions in the
+         * chosen coordinate system.
+         */
+        std::array<double,dim-1> get_surface_coordinates() const;
+
+        /**
+         * The coordinate that represents the 'depth' direction in the chosen
+         * coordinate system.
+         */
+        double get_depth_coordinate() const;
+
+      private:
+        /**
+         * An enum which stores the coordinate system of this natural
+         * point
+         */
+        Utilities::Coordinates::CoordinateSystem coordinate_system;
+
+        /**
+         * An array which stores the coordinates in the coordinates system
+         */
+        std::array<double,dim> coordinates;
+    };
+
+
+    /**
+     * Compute the cellwise projection of component @p component_index of @p function to the finite element space
+     * described by @p dof_handler.
+     *
+     * @param[in] mapping The mapping object to use.
+     * @param[in] dof_handler The DoFHandler the describes the finite element space to
+     * project into and that corresponds to @p vec_result.
+     * @param[in] component_index The component index of the @p dof_handler for which
+     * the projection is being performed. This component should be described by
+     * a DG finite element.
+     * @param[in] quadrature  The quadrature formula to use to evaluate @p function on each cell.
+     * @param[in] function The function to project into the finite element space.
+     * This function should store the value of the function at the points described
+     * by the 2nd argument into the 3rd argument as an std::vector<double>
+     * of size quadrature.size().
+     * @param[out] vec_result The output vector where the projected function will be
+     * stored in.
+     */
+    template <int dim, typename VectorType>
+    void
+    project_cellwise(const Mapping<dim>                                        &mapping,
+                     const DoFHandler<dim>                                     &dof_handler,
+                     const unsigned int                                         component_index,
+                     const Quadrature<dim>                                     &quadrature,
+                     const std::function<void(
+                       const typename DoFHandler<dim>::active_cell_iterator &,
+                       const std::vector<Point<dim>> &,
+                       std::vector<double> &)>                                 &function,
+                     VectorType                                                &vec_result);
+
+    /**
+     * Throw an exception that a linear solver failed with some helpful information for the user.
+     * This function is needed because we have multiple solvers that all require similar treatment
+     * and we would like to keep the output consistent. If the optional parameter
+     * @p output_filename is given, the solver history is additionally written to this file.
+     *
+     * @p solver_name A name that identifies the solver and appears in the error message.
+     * @p function_name The name of the function that used the solver (to identify where in the code
+     *   a solver failed).
+     * @p solver_controls One or more solver controls that describe the history of the solver(s)
+     *   that failed. The reason the function takes multiple controls is we sometimes use
+     *   multi-stage solvers, e.g. we try a cheap solver first, and use an expensive solver if the
+     *   cheap solver fails.
+     * @p exc The exception that was thrown by the solver when it failed, containing additional
+     *   information about what happened.
+     * @p mpi_communicator The MPI Communicator of the problem.
+     * @p output_filename An optional file name into which (if present) the solver history will
+     *   be written.
+     *
+     * @return This function never returns normally. It always exits via an exception, either
+     *   of type ExcMessage (on rank 0 of the parallel computation) or QuietException (on all
+     *   other ranks).
+     */
+    void throw_linear_solver_failure_exception(const std::string &solver_name,
+                                               const std::string &function_name,
+                                               const std::vector<SolverControl> &solver_controls,
+                                               const std::exception &exc,
+                                               const MPI_Comm mpi_communicator,
+                                               const std::string &output_filename = "");
+
+    /**
+     * Conversion object where one can provide a function that returns
+     * a tensor for the velocity at a given point and it returns something
+     * that matches the dealii::Function interface with a number of output
+     * components equal to the number of components of the finite element
+     * in use.
+     */
+    template <int dim>
+    class VectorFunctionFromVelocityFunctionObject : public Function<dim>
+    {
+      public:
+        /**
+         * Given a function object that takes a Point and returns a Tensor<1,dim>,
+         * convert this into an object that matches the Function@<dim@>
+         * interface.
+         *
+         * @param n_components total number of components of the finite element system.
+         * @param function_object The function that will form one component
+         *     of the resulting Function object.
+         */
+        VectorFunctionFromVelocityFunctionObject (const unsigned int n_components,
+                                                  const std::function<Tensor<1,dim> (const Point<dim> &)> &function_object);
+
+        /**
+         * Return the value of the
+         * function at the given
+         * point. Returns the value the
+         * function given to the constructor
+         * produces for this point.
+         */
+        double value (const Point<dim>   &p,
+                      const unsigned int  component = 0) const override;
+
+        /**
+         * Return all components of a
+         * vector-valued function at a
+         * given point.
+         *
+         * <tt>values</tt> shall have the right
+         * size beforehand,
+         * i.e. #n_components.
+         */
+        void vector_value (const Point<dim>   &p,
+                           Vector<double>     &values) const override;
+
+      private:
+        /**
+         * The function object which we call when this class's value() or
+         * value_list() functions are called.
+         */
+        const std::function<Tensor<1,dim> (const Point<dim> &)> function_object;
+    };
+
+    /**
+     * Create and return a permutation vector which can be used by the
+     * apply_permutation() function to put the vector in sorted order.
+     *
+     * @param vector vector to sort
+     */
+    template <typename T>
+    inline
+    std::vector<std::size_t>
+    compute_sorting_permutation(const std::vector<T> &vector);
+
+    /**
+     * Applies a permutation vector to another vector and return the resulting vector.
+     *
+     * @param vector vector to sort
+     * @param permutation_vector The permutation vector used to sort the input vector.
+     * @return The permuted input vector.
+     */
+    template <typename T>
+    inline
+    std::vector<T>
+    apply_permutation(
+      const std::vector<T> &vector,
+      const std::vector<std::size_t> &permutation_vector);
+
+    /**
+     * Get volume weighted rotation matrices, using random draws to convert
+     * to a discrete number of orientations, weighted by volume.
+     * The input is a vector of volume fractions and a vector of rotation matrices.
+     * The vectors need to have the same length.
+     *
+     * @param volume_fractions a vector of doubles representing the volume fraction of each grain
+     * @param rotation_matrices a vector of 2nd order 3D tensors representing the rotation matrix of each grain
+     * @param n_output_matrices The number of rotation matrices which are output by this function. This can be
+     * different from the number of entries in the volume fraction and rotation matrices vectors.
+     * @param random_number_generator a reference to a mt19937 random number generator.
+     */
+    std::vector<Tensor<2,3>>
+    rotation_matrices_random_draw_volume_weighting(const std::vector<double> &volume_fractions,
+                                                   const std::vector<Tensor<2,3>> &rotation_matrices,
+                                                   const unsigned int n_output_matrices,
+                                                   std::mt19937 &random_number_generator);
+
+    /**
+    * Wraps angle between 0 and 360 degrees.
+    */
+    double wrap_angle(const double angle);
+
+    /**
+     * Compute Z-X-Z Euler angles (https://en.wikipedia.org/wiki/Euler_angles) from rotation matrix.
+     * The Z-X-Z indicates the order of axis rotations to generate the Euler angles.
+     */
+    std::array<double,3> zxz_euler_angles_from_rotation_matrix(const Tensor<2,3> &rotation_matrix);
+
+    /**
+     * Compute rotation matrix from Z-X-Z Euler angles (https://en.wikipedia.org/wiki/Euler_angles)
+     * The Z-X-Z indicates the order of axis axis rotations to generate the Euler angles.
+     */
+    Tensor<2,3> zxz_euler_angles_to_rotation_matrix(const double phi1,
+                                                    const double theta,
+                                                    const double phi2);
+
+  }
+}
+
+
+// inline implementations:
+#ifndef DOXYGEN
+namespace aspect
+{
+  namespace Utilities
+  {
+
+    template <typename T>
+    inline
+    std::vector<T>
+    possibly_extend_from_1_to_N (const std::vector<T> &values,
+                                 const unsigned int N,
+                                 const std::string &id_text)
+    {
+      if (values.size() == 1)
+        {
+          return std::vector<T> (N, values[0]);
+        }
+      else if (values.size() == N)
+        {
+          return values;
+        }
+      else
+        {
+          // Non-specified behavior
+          AssertThrow(false,
+                      ExcMessage("Length of " + id_text + " list must be " +
+                                 "either one or " + Utilities::to_string(N) +
+                                 ". Currently it is " + Utilities::to_string(values.size()) + "."));
+        }
+
+      // This should never happen, but return an empty vector so the compiler
+      // will be happy
+      return std::vector<T> ();
+    }
+
+    inline
+    void
+    extract_composition_values_at_q_point (const std::vector<std::vector<double>> &composition_values,
+                                           const unsigned int q,
+                                           std::vector<double> &composition_values_at_q_point)
+    {
+      Assert(q<composition_values.size(), ExcInternalError());
+      Assert(composition_values_at_q_point.size() > 0,
+             ExcInternalError());
+
+      for (unsigned int k=0; k < composition_values_at_q_point.size(); ++k)
+        {
+          Assert(composition_values[k].size() == composition_values_at_q_point.size(),
+                 ExcInternalError());
+          composition_values_at_q_point[k] = composition_values[k][q];
+        }
+    }
+
+    template <typename T>
+    inline
+    std::vector<std::size_t>
+    compute_sorting_permutation(const std::vector<T> &vector)
+    {
+      std::vector<std::size_t> p(vector.size());
+      std::iota(p.begin(), p.end(), 0);
+      std::sort(p.begin(), p.end(),
+                [&](std::size_t i, std::size_t j)
+      {
+        return vector[i] < vector[j];
+      });
+      return p;
+    }
+
+    template <typename T>
+    inline
+    std::vector<T>
+    apply_permutation(
+      const std::vector<T> &vector,
+      const std::vector<std::size_t> &permutation_vector)
+    {
+      std::vector<T> sorted_vec(vector.size());
+      std::transform(permutation_vector.begin(), permutation_vector.end(), sorted_vec.begin(),
+                     [&](std::size_t i)
+      {
+        return vector[i];
+      });
+      return sorted_vec;
+    }
+
+    /**
+     * Contains utility functions related to tensors.
+     */
+    namespace Tensors
+    {
+      /**
+       * Convert a series of doubles to a SymmetricTensor of the same size.
+       * The input is expected to be ordered according to the
+       * SymmetricTensor::unrolled_to_component_indices() function.
+       */
+      template <int dim, class Iterator>
+      inline
+      SymmetricTensor<2,dim>
+      to_symmetric_tensor(const Iterator begin,
+                          const Iterator end)
+      {
+        AssertDimension(std::distance(begin, end), (SymmetricTensor<2,dim>::n_independent_components));
+        (void) end;
+
+        SymmetricTensor<2,dim> output;
+
+        Iterator next = begin;
+        for (unsigned int i=0; i < SymmetricTensor<2,dim>::n_independent_components; ++i, ++next)
+          output[SymmetricTensor<2,dim>::unrolled_to_component_indices(i)] = *next;
+
+        return output;
+      }
+
+      /**
+       * Unroll a SymmetricTensor into a series of doubles. The output is ordered
+       * according to the SymmetricTensor::unrolled_to_component_indices() function.
+       */
+      template <int dim, class Iterator>
+      inline
+      void
+      unroll_symmetric_tensor_into_array(const SymmetricTensor<2,dim> &tensor,
+                                         const Iterator begin,
+                                         const Iterator end)
+      {
+        AssertDimension(std::distance(begin, end), (SymmetricTensor<2,dim>::n_independent_components));
+        (void) end;
+
+        Iterator next = begin;
+        for (unsigned int i=0; i < SymmetricTensor<2,dim>::n_independent_components; ++i, ++next)
+          *next = tensor[SymmetricTensor<2,dim>::unrolled_to_component_indices(i)];
+      }
+
+      /**
+       * Rotate a 3D 4th order tensor representing the full stiffnexx matrix using a 3D 2nd order rotation tensor
+       */
+      SymmetricTensor<4,3>
+      rotate_full_stiffness_tensor(const Tensor<2,3> &rotation_tensor, const SymmetricTensor<4,3> &input_tensor);
+
+      /**
+       * Rotate a 6x6 voigt stiffness matrix using a 2nd order Voigt stiffness tensor.
+       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
+       */
+      SymmetricTensor<2,6>
+      rotate_voigt_stiffness_matrix(const Tensor<2,3> &rotation_tensor, const SymmetricTensor<2,6> &input_tensor);
+
+      /**
+       * Transform a 4th order full stiffness tensor into a 6x6 Voigt stiffness matrix.
+       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
+       */
+      SymmetricTensor<2,6>
+      to_voigt_stiffness_matrix(const SymmetricTensor<4,3> &input_tensor);
+
+      /**
+       * Transform a 6x6 Voigt stiffness matrix into a 4th order full stiffness tensor.
+       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
+       */
+      SymmetricTensor<4,3>
+      to_full_stiffness_tensor(const SymmetricTensor<2,6> &input_tensor);
+
+      /**
+       * Form a 21D voigt stiffness vector from a 6x6 Voigt stiffness matrix.
+       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
+       */
+      Tensor<1,21>
+      to_voigt_stiffness_vector(const SymmetricTensor<2,6> &input_tensor);
+
+      /**
+       * Form a 21D voigt stiffness vector from a 6x6 Voigt stiffness matrix.
+       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
+       */
+      SymmetricTensor<2,6>
+      to_voigt_stiffness_matrix(const Tensor<1,21> &input_tensor);
+
+      /**
+       * Transform a 4th order full stiffness tensor into a 21D Voigt stiffness vector.
+       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
+       */
+      Tensor<1,21>
+      to_voigt_stiffness_vector(const SymmetricTensor<4,3> &input);
+
+
+      /**
+       * Return the Levi-Civita tensor, also called a permutation or "totally antisymmetric" tensor.
+       * See https://en.wikipedia.org/wiki/Levi-Civita_symbol for a definition.
+       */
+      template <int dim>
+      const Tensor<dim,dim> &levi_civita();
+
+      // Declare the existence of a specialization:
+      template <>
+      const Tensor<3,3> &levi_civita<3>();
+    }
+
+  }
+}
+#endif
+
+#endif
diff --git a/include/aspect/volume_of_fluid/assembly.h b/include/aspect/volume_of_fluid/assembly.h
index bc212c798e2..fb46191c864 100644
--- a/include/aspect/volume_of_fluid/assembly.h
+++ b/include/aspect/volume_of_fluid/assembly.h
@@ -18,8 +18,8 @@
  <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _aspect_volume_of_fluid_assembly_h
-#define _aspect_volume_of_fluid_assembly_h
+#ifndef _aspect_volume_of_fluid_simulator/assemblers/interface.h
+#define _aspect_volume_of_fluid_simulator/assemblers/interface.h
 
 #include <aspect/global.h>
 #include <aspect/simulator_access.h>
diff --git a/include/aspect/volume_of_fluid/assembly.h.bak b/include/aspect/volume_of_fluid/assembly.h.bak
new file mode 100644
index 00000000000..bc212c798e2
--- /dev/null
+++ b/include/aspect/volume_of_fluid/assembly.h.bak
@@ -0,0 +1,231 @@
+/*
+ Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file doc/COPYING.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_volume_of_fluid_assembly_h
+#define _aspect_volume_of_fluid_assembly_h
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim>
+  class Simulator;
+
+  template <int dim>
+  struct VolumeOfFluidField;
+
+  namespace internal
+  {
+    namespace Assembly
+    {
+      namespace Scratch
+      {
+        /**
+         * Standard scratch data structure for matrix assembly
+         */
+        template <int dim>
+        struct VolumeOfFluidSystem
+        {
+          VolumeOfFluidSystem (const FiniteElement<dim> &finite_element,
+                               const FiniteElement<dim> &volume_of_fluid_element,
+                               const Mapping<dim>       &mapping,
+                               const Quadrature<dim>    &quadrature,
+                               const Quadrature<dim-1>  &face_quadrature);
+
+          VolumeOfFluidSystem (const VolumeOfFluidSystem &scratch);
+
+          /**
+           * Add a defaulted assignment operator because relying on it
+           * implicitly is deprecated.
+           */
+          VolumeOfFluidSystem &operator=(const VolumeOfFluidSystem &) = default;
+
+          FEValues<dim>          finite_element_values;
+          FEValues<dim>          neighbor_finite_element_values;
+          FEFaceValues<dim>      face_finite_element_values;
+          FEFaceValues<dim>      neighbor_face_finite_element_values;
+          FESubfaceValues<dim>   subface_finite_element_values;
+
+          std::vector<types::global_dof_index>   local_dof_indices;
+
+          // Field for exact cell volume (needed in some of the face flux calculations)
+          double volume;
+
+          /**
+           * Variables describing the values of the shape functions at the
+           * quadrature points, as they are used in the advection assembly
+           * function. note that the sizes of these arrays are equal to the
+           * number of shape functions corresponding to a single VolumeOfFluid field (and
+           * not of all VolumeOfFluid fields!), and that they are also correspondingly
+           * indexed.
+           */
+          std::vector<double>         phi_field;
+          std::vector<double>         face_phi_field;
+
+          std::vector<double>         old_field_values;
+          /* Vector for interface normal in the unit cell */
+          std::vector<Tensor<1,dim>> cell_i_n_values;
+          /* "Distance" from cell center to interface as d value for the interface in the form $\vec{n}\cdot\vec{x}=d$ */
+          std::vector<double>         cell_i_d_values;
+
+          std::vector<Tensor<1,dim>> face_current_velocity_values;
+          std::vector<Tensor<1,dim>> face_old_velocity_values;
+          std::vector<Tensor<1,dim>> face_old_old_velocity_values;
+
+          std::vector<double>         neighbor_old_values;
+          /* Vector for interface normal in the unit cell */
+          std::vector<Tensor<1,dim>> neighbor_i_n_values;
+          /* "Distance" from cell center to interface as d value for the interface in the form $\vec{n}\cdot\vec{x}=d$ */
+          std::vector<double>         neighbor_i_d_values;
+        };
+      }
+
+      namespace CopyData
+      {
+        /**
+         * Standard copy data structure for matrix assembly
+         */
+        template <int dim>
+        struct VolumeOfFluidSystem
+        {
+          /**
+           * Constructor.
+           * @param finite_element The element that describes the field for which we
+           *    are trying to assemble a linear system. <b>Not</b> the global finite
+           *    element.
+           */
+          VolumeOfFluidSystem(const FiniteElement<dim> &finite_element);
+          VolumeOfFluidSystem(const VolumeOfFluidSystem &data);
+
+          /**
+           * Add a defaulted assignment operator because relying on it
+           * implicitly is deprecated.
+           */
+          VolumeOfFluidSystem &operator=(const VolumeOfFluidSystem &) = default;
+
+          /**
+           * Local contributions to the global matrix and right hand side
+           * that correspond only to the variables listed in local_dof_indices
+           */
+          FullMatrix<double>          local_matrix;
+          Vector<double>              local_rhs;
+
+          /**
+           * Local contributions to the global rhs from the face terms in the
+           * discontinuous Galerkin interpretation of the VolumeOfFluid method.
+           *
+           * The array has a length sufficient to hold one element for each
+           * possible face and sub-face of a cell.
+           */
+          std::vector<Vector<double>> local_face_rhs;
+          std::vector<FullMatrix<double>> local_face_matrices_ext_ext;
+
+          /**
+           * Denotes which face's rhs have actually been assembled in the DG
+           * field assembly. Entries not used (for example, those corresponding
+           * to non-existent subfaces; or faces being assembled by the
+           * neighboring cell) are set to false.
+           *
+           * The array has a length sufficient to hold one element for each
+           * possible face and sub-face of a cell.
+           */
+          std::vector<bool> face_contributions_mask;
+
+          /**
+           * Indices of those degrees of freedom that actually correspond to
+           * the volume_of_fluid field. Since this structure is used to represent just
+           * contributions to the volume_of_fluid systems, there will be no contributions
+           * to other parts of the system and consequently, we do not need to
+           * list here indices that correspond to velocity or pressure degrees
+           * (or, in fact any other variable outside the block we are currently
+           * considering)
+           */
+          std::vector<types::global_dof_index>   local_dof_indices;
+
+          /**
+           * Indices of the degrees of freedom corresponding to the volume_of_fluid field
+           * on all possible neighboring cells. This is used in the
+           * discontinuous Galerkin interpretation of the VolumeOfFluid method.
+           *
+           * The array has a length sufficient to hold one element for each
+           * possible face and sub-face of a cell.
+           */
+          std::vector<std::vector<types::global_dof_index>> neighbor_dof_indices;
+        };
+      }
+    }
+  }
+
+  namespace Assemblers
+  {
+
+    /**
+     * Class to hold VolumeOfFluid assembly logic, as analogous to that used in the main simulator.
+     */
+    template <int dim>
+    class VolumeOfFluidAssembler : public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Do setup and assembly on internal quadrature points and dispatch to
+         * other functions for face assembly
+         */
+        void local_assemble_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
+                                                    const unsigned int calc_dir,
+                                                    const bool update_from_old,
+                                                    const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                                    internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
+                                                    internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const;
+
+        /**
+         * Do assembly for cell faces on the boundary
+         */
+        void local_assemble_boundary_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
+                                                                  const bool update_from_old,
+                                                                  const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                                                  const unsigned int face_no,
+                                                                  internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
+                                                                  internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const;
+
+        /**
+         * Function for assembling face fluxes for VolumeOfFluid system.
+         */
+        void local_assemble_internal_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
+                                                                  const bool update_from_old,
+                                                                  const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                                                  const unsigned int face_no,
+                                                                  internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
+                                                                  internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const;
+
+        /**
+         * Set volume fraction threshold for use in assembly
+         */
+        void set_volume_fraction_threshold(const double value);
+    };
+  }
+}
+
+
+#endif
diff --git a/include/aspect/volume_of_fluid/field.h.bak b/include/aspect/volume_of_fluid/field.h.bak
new file mode 100644
index 00000000000..da88e97ec28
--- /dev/null
+++ b/include/aspect/volume_of_fluid/field.h.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_volume_of_fluid_field_h
+#define _aspect_volume_of_fluid_field_h
+
+#include <aspect/fe_variable_collection.h>
+
+using namespace dealii;
+
+namespace aspect
+{
+  namespace VolumeOfFluid
+  {
+    /**
+     * A structure that contains enum values that identify type of input data
+     * to allow robust use of sub-mesh scale input that remain valid over
+     * multiple mesh sizes.
+     */
+    struct VolumeOfFluidInputType
+    {
+      enum Kind
+      {
+        /**
+         * Input data is a value between 0 and 1 at all points.
+         */
+        composition,
+        /**
+         * Input data is an interface defined by a signed distance level set
+         * with positive value indicating fluid presence. IE the function has
+         * gradient 1 almost everywhere, is positive where the fluid is, and is
+         * zero on the fluid interface
+         */
+        level_set
+      };
+    };
+  }
+
+  /**
+   * Structure to package the relevant data (both state and cached) in a single
+   * location for access.
+   */
+  template <int dim>
+  struct VolumeOfFluidField
+  {
+    /**
+     * Initialize the structure with FEVariables to hold the required
+     * information that must be available on all cells.
+     */
+    VolumeOfFluidField(const FEVariable<dim> &volume_fraction,
+                       const FEVariable<dim> &reconstruction,
+                       const FEVariable<dim> &level_set,
+                       const unsigned int composition_index);
+
+    /**
+     * Field to hold the current volume fraction.
+     */
+    const FEVariable<dim> &volume_fraction;
+
+    /**
+     * Field to hold the cached interface reconstruction.
+     */
+    const FEVariable<dim> &reconstruction;
+
+    /**
+     * Field to expose reconstructed interface as a zero-contour to output in
+     * visualization plugin.
+     */
+    const FEVariable<dim> &level_set;
+
+    /**
+     * Field index of the associated composition field
+     */
+    const unsigned int composition_index;
+
+  };
+}
+
+#endif
diff --git a/include/aspect/volume_of_fluid/handler.h b/include/aspect/volume_of_fluid/handler.h
index 56be01c21f6..8e741060777 100644
--- a/include/aspect/volume_of_fluid/handler.h
+++ b/include/aspect/volume_of_fluid/handler.h
@@ -24,7 +24,7 @@
 #include <aspect/simulator.h>
 #include <aspect/simulator_access.h>
 #include <aspect/volume_of_fluid/field.h>
-#include <aspect/volume_of_fluid/assembly.h>
+#include <aspect/volume_of_fluid/simulator/assemblers/interface.h>
 
 #include <boost/serialization/map.hpp>
 
diff --git a/include/aspect/volume_of_fluid/handler.h.bak b/include/aspect/volume_of_fluid/handler.h.bak
new file mode 100644
index 00000000000..56be01c21f6
--- /dev/null
+++ b/include/aspect/volume_of_fluid/handler.h.bak
@@ -0,0 +1,226 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_volume_of_fluid_handler_h
+#define _aspect_volume_of_fluid_handler_h
+
+#include <aspect/simulator.h>
+#include <aspect/simulator_access.h>
+#include <aspect/volume_of_fluid/field.h>
+#include <aspect/volume_of_fluid/assembly.h>
+
+#include <boost/serialization/map.hpp>
+
+using namespace dealii;
+
+namespace aspect
+{
+  /**
+   * A member class that isolates the functions and variables that deal
+   * with the Volume of Fluid implementation. If Volume of Fluid interface
+   * tracking is not active, there is no instantiation of this class at
+   * all.
+   */
+  template <int dim>
+  class VolumeOfFluidHandler : public SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Standard initial constructor
+       */
+      VolumeOfFluidHandler(Simulator<dim> &simulator, ParameterHandler &prm);
+
+      /**
+       * Add the Volume of Fluid field declaration to the list to be included
+       * in the solution vector.
+       */
+      void edit_finite_element_variables (std::vector<VariableDeclaration<dim>> &vars);
+
+      /**
+       * Declare the parameters this class takes through input files.
+       */
+      static
+      void declare_parameters (ParameterHandler &prm);
+
+      /**
+       * Read the parameters this class declares from the parameter file.
+       */
+      void parse_parameters (ParameterHandler &prm);
+
+      /**
+       * Get the number of volume of fluid fields in current model
+       */
+      unsigned int get_n_fields() const;
+
+      /**
+       * Get the name of volume of fluid field with index i
+       */
+      const std::string name_for_field_index(unsigned int i) const;
+
+      /**
+       * Get the structure containing the variable locations for the volume of
+       * fluid field with index i.
+       */
+      const VolumeOfFluidField<dim> &field_struct_for_field_index(unsigned int i) const;
+
+      /**
+       * Get threshold for volume fraction
+       */
+      double get_volume_fraction_threshold() const;
+
+      /**
+       * Get the local index (within vof fields) for the named composition/volume of fluid field
+       */
+      unsigned int field_index_for_name(const std::string &fieldname) const;
+
+      /**
+       * Do necessary internal initialization that is dependent on having the
+       * simulator and Finite Element initialized.
+       */
+      void initialize (ParameterHandler &prm);
+
+      /**
+       * Do initialization routine for all volume of fluid fields
+       */
+      void set_initial_volume_fractions ();
+
+      /**
+       * Initialize specified field based on a composition field initial condition
+       */
+      void initialize_from_composition_field (const VolumeOfFluidField<dim> &field);
+
+      /**
+       * Initialize specified field based on a level set initial condition
+       */
+      void initialize_from_level_set (const VolumeOfFluidField<dim> &field);
+
+      /**
+       * Do interface reconstruction for specified field and cache result in solution vector
+       */
+      void update_volume_of_fluid_normals (const VolumeOfFluidField<dim> &field,
+                                           LinearAlgebra::BlockVector &solution);
+
+      /**
+       * Use current interface reconstruction to produce a composition field
+       * approximation that is bilinear on the unit cell and write that field
+       * to the specified AdvectionField
+       */
+      void update_volume_of_fluid_composition (const typename Simulator<dim>::AdvectionField &composition_field,
+                                               const VolumeOfFluidField<dim> &volume_of_fluid_field,
+                                               LinearAlgebra::BlockVector &solution);
+
+      /**
+       * Do single timestep update, includes logic for doing Strang split update
+       */
+      void do_volume_of_fluid_update (const typename Simulator<dim>::AdvectionField &advection_field);
+
+      /**
+       * Assemble matrix and RHS for the specified field and dimension
+       * (calculation_dim).  If update_from_old_solution is true, the initial
+       * values for this update step are in old_solution, otherwise the values
+       * in solution are used. This allows a clean restart of the split update
+       * from the last timestep if necessary without requiring the overhead of
+       * copying the data.
+       */
+      void assemble_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
+                                            const unsigned int calculation_dim,
+                                            const bool update_from_old_solution);
+
+      /**
+       * Solve the diagonal matrix assembled in assemble_volume_of_fluid_system for the
+       * specified field.
+       */
+      void solve_volume_of_fluid_system (const VolumeOfFluidField<dim> &field);
+
+
+    private:
+      /**
+       * Parent simulator
+       */
+      Simulator<dim> &sim;
+
+      /**
+       * Function to copy assembled data to final system. Requires access to
+       * the full matrix, so must be in this class.
+       */
+      void copy_local_to_global_volume_of_fluid_system (const internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data);
+
+      /**
+       * Assembler object used for doing the matrix and RHS assembly
+       */
+      Assemblers::VolumeOfFluidAssembler<dim> assembler;
+
+      /**
+       * Number of volume of fluid fields to calculate for
+       */
+      unsigned int n_volume_of_fluid_fields;
+
+      /**
+       * Structures containing the locations of the associated state data for
+       * each volume of fluid field.
+       */
+      std::vector<VolumeOfFluidField<dim>> data;
+
+      /**
+       * Volume fraction threshold for the reconstruction and advection
+       * algorithms indicating minimum relevant volume fraction.
+       */
+      double volume_fraction_threshold;
+
+      /**
+       * Tolerance to use for the Newton iteration in the reconstruction step
+       */
+      static constexpr double volume_of_fluid_reconstruct_epsilon = 1e-13;
+
+      /**
+       * Tolerance to use for the matrix solve in the timestep update
+       */
+      double volume_of_fluid_solver_tolerance;
+
+      /**
+       * Number of samples in each dimension to use during the Volume of Fluid
+       * initialization, for a total of $n_init_samples^dim$ points sampled
+       */
+      unsigned int n_init_samples;
+
+      /**
+       * Vector of human readable names for the volume of fluid fields,
+       * obtained from the associated composition field name
+       */
+      std::vector<std::string> volume_of_fluid_field_names;
+
+      /**
+       * Map relating the index of a Volume of Fluid based composition field to the index of the corresponding Volume of Fluid field.
+       */
+      std::map<unsigned int, unsigned int> volume_of_fluid_composition_map_index;
+
+      /**
+       * Methods to use when initializing the volume of fluid fields.  Must be
+       * held here as all access to the actual methods for composition
+       * initialization is handled by the manager.
+       */
+      std::vector<VolumeOfFluid::VolumeOfFluidInputType::Kind> initialization_data_type;
+
+      friend class Simulator<dim>;
+  };
+
+}
+
+#endif
diff --git a/include/aspect/volume_of_fluid/utilities.h.bak b/include/aspect/volume_of_fluid/utilities.h.bak
new file mode 100644
index 00000000000..bb04f2a64d4
--- /dev/null
+++ b/include/aspect/volume_of_fluid/utilities.h.bak
@@ -0,0 +1,171 @@
+/*
+ Copyright (C) 2016 - 2020-2018 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file doc/COPYING.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _aspect_volume_of_fluid_utilities_h
+#define _aspect_volume_of_fluid_utilities_h
+
+#include <deal.II/base/point.h>
+
+#include <aspect/global.h>
+
+namespace aspect
+{
+  namespace VolumeOfFluid
+  {
+    namespace Utilities
+    {
+      using namespace dealii;
+
+      /**
+       * Function to calculate volume fraction contained by indicator function
+       * H(d-normal*(x'-x_{cen}')) on the [0, 1]^dim unit cell where x_{cen} is
+       * the unit cell center.
+       *
+       * Currently only works assuming constant Jacobian determinant.
+       */
+      double compute_fluid_fraction (const Tensor<1, 2> normal,
+                                     const double d);
+      double compute_fluid_fraction (const Tensor<1, 3> normal,
+                                     const double d);
+
+      /**
+       * Function to calculate required value of d to obtain given volume
+       * fraction for indicator function H(d-normal*(x'-x_{cen}')) on the [0,
+       * 1]^dim unit cell where x_{cen} is the unit cell center.
+       *
+       * Currently only works assuming constant Jacobian determinant.
+       */
+      double compute_interface_location (const Tensor<1, 2> normal,
+                                         const double volume_fraction);
+      double compute_interface_location (const Tensor<1, 3> normal,
+                                         const double volume_fraction);
+
+      /**
+       * Obtain values at points for a polynomial function that is equivalent to
+       * the Heaviside function $H(d-normal*xhat)$ on the unit cell when
+       * integrated against polynomials of up to the specified degree.
+       *
+       * Currently works for degree <=1
+       *
+       * @param degree Maximum degree for exact integration
+       * @param normal Interface normal vector, pointed away from the included region
+       * @param d Interface parameter specifying location of interface in unit cell
+       * @param points Locations to evaluate the constructed polynomial
+       * @param values Values of the constructed polynomial at the specified points
+       */
+      void xFEM_Heaviside(const unsigned int degree,
+                          const Tensor<1, 2> normal,
+                          const double d,
+                          const std::vector<Point<2>> &points,
+                          std::vector<double> &values);
+      void xFEM_Heaviside(const unsigned int degree,
+                          const Tensor<1, 3> normal,
+                          const double d,
+                          const std::vector<Point<3>> &points,
+                          std::vector<double> &values);
+
+      /**
+       * Obtain values at points for a polynomial function that is equivalent to
+       * the function $\frac{d}{dd}H(d-normal*xhat)$ on the unit cell when
+       * integrated against polynomials of up to the specified degree.
+       *
+       * Currently works for degree <=1
+       *
+       * @param degree Maximum degree for exact integration
+       * @param normal Interface normal vector, pointed away from the included region
+       * @param d Interface parameter specifying location of interface in unit cell
+       * @param points Locations to evaluate the constructed polynomial
+       * @param values Values of the constructed polynomial at the specified points
+       */
+      void xFEM_Heaviside_derivative_d(const unsigned int degree,
+                                       const Tensor<1, 2> normal,
+                                       const double d,
+                                       const std::vector<Point<2>> &points,
+                                       std::vector<double> &values);
+      void xFEM_Heaviside_derivative_d(const unsigned int degree,
+                                       const Tensor<1, 3> normal,
+                                       const double d,
+                                       const std::vector<Point<3>> &points,
+                                       std::vector<double> &values);
+
+
+      /**
+       * Function to do Newton iteration calculation of correct d for a given
+       * normal to get volume_fraction from xFEM_Heaviside integrated against the given
+       * weights.
+       *
+       * @param degree Maximum degree for exact integration
+       * @param normal Interface normal vector, pointed away from the included region
+       * @param volume_fraction Cell volume fraction in physical space - used for target value for integration
+       * @param vol Cell volume in physical space - used for target value for integration
+       * @param epsilon Tolerance for Newton iteration
+       * @param points Quadrature points to use for update
+       * @param weights JxW values to use for quadrature
+       */
+      template <int dim>
+      double compute_interface_location_newton(const unsigned int degree,
+                                               const Tensor<1, dim, double> normal,
+                                               const double volume_fraction,
+                                               const double vol,
+                                               const double epsilon,
+                                               const std::vector<Point<dim>> &points,
+                                               const std::vector<double> &weights);
+
+      /**
+       * Function to calculate volume contained by indicator function
+       * $H(d-normal*(x'-x_{cen}'))$ on the $[0, 1]^dim$ unit cell where
+       * $x_{cen}$ is the unit cell center, using a polynomial mapping of
+       * degree up to "degree".
+       *
+       * @param degree Maximum degree for exact integration
+       * @param normal Interface normal vector, pointed away from the included region
+       * @param d Interface parameter specifying location of interface in unit cell by distance from cell center
+       * @param points Quadrature points to use for update
+       * @param weights JxW values to use for quadrature
+       */
+      template <int dim>
+      double compute_fluid_volume(const unsigned int degree,
+                                  const Tensor<1, dim, double> normal,
+                                  const double d,
+                                  const std::vector<Point<dim>> &points,
+                                  const std::vector<double> &weights);
+
+      /**
+       * Function to calculate flux volume fraction based on a method of
+       * characteristics approximation of the interface on the cell's face over
+       * the timestep. Calculation assumes an approximation to the interface of the form
+       * $H(d-normal*(x'-x_{face center})-time_direction_derivative*t')$ where
+       * $t'$ is in terms of a "unit timestep".
+       *
+       * @param compute_direction Dimension of unit cell we are currently computing along
+       * @param time_direction_derivative Approximated gradient in time for the "level set" describing the interface.
+       * @param interface_normal_in_cell The normal vector for the current interface reconstruction in the computing cell.
+       * @param d_at_face_center The correct d value to for the interface description on the face we are computing for.
+       */
+      template <int dim>
+      double calculate_volume_flux (const unsigned int compute_direction,
+                                    const double time_direction_derivative,
+                                    const Tensor<1, dim, double> interface_normal_in_cell,
+                                    const double d_at_face_center);
+    }
+  }
+}
+
+#endif
diff --git a/source/adiabatic_conditions/ascii_data.cc.bak b/source/adiabatic_conditions/ascii_data.cc.bak
new file mode 100644
index 00000000000..b472abd43b3
--- /dev/null
+++ b/source/adiabatic_conditions/ascii_data.cc.bak
@@ -0,0 +1,168 @@
+/*
+  Copyright (C) 2016 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/adiabatic_conditions/ascii_data.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData()
+      :
+      initialized(false),
+      temperature_index(numbers::invalid_unsigned_int),
+      pressure_index(numbers::invalid_unsigned_int),
+      density_index(numbers::invalid_unsigned_int)
+    {}
+
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      if (initialized)
+        return;
+
+      this->initialize(this->get_mpi_communicator());
+      temperature_index = this->get_column_index_from_name("temperature");
+      pressure_index = this->get_column_index_from_name("pressure");
+      density_index = this->get_column_index_from_name("density");
+
+      initialized = true;
+    }
+
+
+
+    template <int dim>
+    bool
+    AsciiData<dim>::is_initialized() const
+    {
+      return initialized;
+    }
+
+
+
+    template <int dim>
+    double AsciiData<dim>::pressure (const Point<dim> &p) const
+    {
+      const double depth = this->get_geometry_model().depth(p);
+      return this->get_data_component(Point<1>(depth),pressure_index);
+    }
+
+
+
+    template <int dim>
+    double AsciiData<dim>::temperature (const Point<dim> &p) const
+    {
+      const double depth = this->get_geometry_model().depth(p);
+      return this->get_data_component(Point<1>(depth),temperature_index);
+    }
+
+
+
+    template <int dim>
+    double AsciiData<dim>::density (const Point<dim> &p) const
+    {
+      const double depth = this->get_geometry_model().depth(p);
+      return this->get_data_component(Point<1>(depth),density_index);
+    }
+
+
+
+    template <int dim>
+    double AsciiData<dim>::density_derivative (const Point<dim> &p) const
+    {
+      const double depth = this->get_geometry_model().depth(p);
+      const double eps = std::sqrt(std::numeric_limits<double>::epsilon()) * this->get_geometry_model().maximal_depth();
+      return (this->get_data_component(Point<1>(depth+eps),density_index)
+              -
+              this->get_data_component(Point<1>(depth),density_index))
+             /
+             eps;
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                          "$ASPECT_SOURCE_DIR/tests/adiabatic-conditions/ascii-data/test/",
+                                                          "");
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        Utilities::AsciiDataBase<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(AsciiData,
+                                               "ascii data",
+                                               "A model in which the adiabatic profile is "
+                                               "read from a file that describes the reference "
+                                               "state. Note the required format of the "
+                                               "input data: The first lines may contain any number of comments "
+                                               "if they begin with `#', but one of these lines needs to "
+                                               "contain the number of points in the reference state as "
+                                               "for example `# POINTS: 3'. "
+                                               "Following the comment lines there has to be a single line "
+                                               "containing the names of all data columns, separated by arbitrarily "
+                                               "many spaces. Column names are not allowed to contain spaces. "
+                                               "The file can contain unnecessary columns, but for this plugin it "
+                                               "needs to at least provide columns named `temperature', `pressure', "
+                                               "and `density'. "
+                                               "Note that the data lines in the file need to be sorted in order "
+                                               "of increasing depth from 0 to the maximal depth in the model "
+                                               "domain. Points in the model that are outside of the provided "
+                                               "depth range will be assigned the maximum or minimum depth values, "
+                                               "respectively. Points do not need to be equidistant, "
+                                               "but the computation of properties is optimized in speed "
+                                               "if they are.")
+  }
+}
diff --git a/source/adiabatic_conditions/compute_entropy_profile.cc.bak b/source/adiabatic_conditions/compute_entropy_profile.cc.bak
new file mode 100644
index 00000000000..ab2f7a072ad
--- /dev/null
+++ b/source/adiabatic_conditions/compute_entropy_profile.cc.bak
@@ -0,0 +1,315 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/adiabatic_conditions/compute_entropy_profile.h>
+#include <aspect/gravity_model/interface.h>
+
+#include <deal.II/base/signaling_nan.h>
+
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    template <int dim>
+    ComputeEntropyProfile<dim>::ComputeEntropyProfile()
+      :
+      initialized(false)
+    {}
+
+
+
+    template <int dim>
+    void
+    ComputeEntropyProfile<dim>::initialize()
+    {
+      if (initialized)
+        return;
+
+      temperatures.resize(n_points, numbers::signaling_nan<double>());
+      pressures.resize(n_points, numbers::signaling_nan<double>());
+      densities.resize(n_points, numbers::signaling_nan<double>());
+
+      delta_z = this->get_geometry_model().maximal_depth() / (n_points-1);
+
+      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
+      this->get_material_model().create_additional_named_outputs (out);
+
+      MaterialModel::PrescribedTemperatureOutputs<dim> *prescribed_temperature_out
+        = out.template get_additional_output<MaterialModel::PrescribedTemperatureOutputs<dim>>();
+
+      // check if the material model computes prescribed temperature outputs
+      AssertThrow(prescribed_temperature_out != nullptr,
+                  ExcMessage("The material model you use does not provide "
+                             "PrescribedTemperatureOutputs, which is required "
+                             "for this adiabatic conditions plugin."));
+
+      const std::vector<unsigned int> entropy_indices = this->introspection().get_indices_for_fields_of_type(CompositionalFieldDescription::entropy);
+      // TODO : need to make it work for more than one field
+      AssertThrow(entropy_indices.size() >= 1,
+                  ExcMessage("The 'compute entropy' adiabatic conditions plugin "
+                             "requires at least one field of type 'entropy'."));
+
+      // Constant properties on the reference profile
+      // We only need the material model to compute the density
+      in.requested_properties = MaterialModel::MaterialProperties::density | MaterialModel::MaterialProperties::additional_outputs;
+      in.velocity[0] = Tensor <1,dim> ();
+      // The entropy along an adiabat is constant (equals the surface entropy)
+      // When there is more than one entropy field, we use the background field to compute the adiabatic profile
+      // TODO : provide more ways to specify compositional fields like in compute_profile.cc
+      for (unsigned int i=0; i < this->n_compositional_fields(); ++i)
+        in.composition[0][i] = 0;
+
+      in.composition[0][entropy_indices[0]] = surface_entropy;
+
+      // Check whether gravity is pointing up / out or down / in. In the normal case it should
+      // point down / in and therefore gravity should be positive, leading to increasing
+      // adiabatic pressures and temperatures with depth. In some cases it will point up / out
+      // (e.g. for backward advection), in which case the pressures and temperatures should
+      // decrease with depth and therefore gravity has to be negative in the following equations.
+      const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(this->get_geometry_model().representative_point(0));
+      const Point<dim> point_surf = this->get_geometry_model().representative_point(0);
+      const Point<dim> point_bot = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
+      const int gravity_direction =  (g * (point_bot - point_surf) >= 0) ?
+                                     1 :
+                                     -1;
+
+      // now integrate downward using the explicit Euler method for simplicity
+      //
+      // note: p'(z) = rho(p,T) * |g|
+      //       T(z) = look up for reference entropy and current p(z)
+      for (unsigned int i=0; i<n_points; ++i)
+        {
+          if (i==0)
+            {
+              pressures[0] = this->get_surface_pressure();
+            }
+          else
+            {
+              // use material properties calculated at i-1
+              const double density = out.densities[0];
+              // get the magnitude of gravity. we assume
+              // that gravity always points along the depth direction. this
+              // may not strictly be true always but is likely a good enough
+              // approximation here.
+              const double gravity = gravity_direction * this->get_gravity_model().gravity_vector(in.position[0]).norm();
+
+              pressures[i] = pressures[i-1] + density * gravity * delta_z;
+            }
+
+          const double z = static_cast<double>(i)/static_cast<double>(n_points-1)*this->get_geometry_model().maximal_depth();
+          const Point<dim> representative_point = this->get_geometry_model().representative_point (z);
+
+          in.position[0] = representative_point;
+          in.pressure[0] = pressures[i];
+          this->get_material_model().evaluate(in, out);
+
+          densities[i] = out.densities[0];
+          temperatures[i] = prescribed_temperature_out->prescribed_temperature_outputs[0];
+        }
+
+      if (gravity_direction == 1 && this->get_surface_pressure() >= 0)
+        {
+          Assert (*std::min_element (pressures.begin(), pressures.end()) >=
+                  -std::numeric_limits<double>::epsilon() * pressures.size(),
+                  ExcMessage("Adiabatic ComputeProfile encountered a negative pressure of "
+                             + dealii::Utilities::to_string(*std::min_element (pressures.begin(), pressures.end()))));
+        }
+      else if (gravity_direction == -1 && this->get_surface_pressure() <= 0)
+        {
+          Assert (*std::max_element (pressures.begin(), pressures.end()) <=
+                  std::numeric_limits<double>::epsilon() * pressures.size(),
+                  ExcMessage("Adiabatic ComputeProfile encountered a positive pressure of "
+                             + dealii::Utilities::to_string(*std::max_element (pressures.begin(), pressures.end()))));
+        }
+
+      Assert (*std::min_element (temperatures.begin(), temperatures.end()) >=
+              -std::numeric_limits<double>::epsilon() * temperatures.size(),
+              ExcMessage("Adiabatic ComputeProfile encountered a negative temperature."));
+
+
+      initialized = true;
+    }
+
+
+
+    template <int dim>
+    bool
+    ComputeEntropyProfile<dim>::is_initialized() const
+    {
+      return initialized;
+    }
+
+
+
+    template <int dim>
+    double ComputeEntropyProfile<dim>::pressure (const Point<dim> &p) const
+    {
+      return get_property(p,pressures);
+    }
+
+
+
+    template <int dim>
+    double ComputeEntropyProfile<dim>::temperature (const Point<dim> &p) const
+    {
+      return get_property(p,temperatures);
+    }
+
+
+
+    template <int dim>
+    double ComputeEntropyProfile<dim>::density (const Point<dim> &p) const
+    {
+      return get_property(p,densities);
+    }
+
+
+
+    template <int dim>
+    double ComputeEntropyProfile<dim>::density_derivative (const Point<dim> &p) const
+    {
+      const double z = this->get_geometry_model().depth(p);
+
+      if (z >= this->get_geometry_model().maximal_depth())
+        {
+          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
+                  ExcInternalError());
+          return (densities.back() - densities[densities.size()-2]) / delta_z;
+        }
+
+      if (z < 0)
+        {
+          Assert (z >= -delta_z, ExcInternalError());
+          return (densities[1] - densities.front()) / delta_z;
+        }
+
+      // if z/delta_z is within [k-eps, k+eps] of a whole number k, round it down to k-1
+      const unsigned int i = static_cast<unsigned int>((z/delta_z) * (1. - 2. * std::numeric_limits<double>::epsilon()));
+      Assert (i < densities.size() - 1, ExcInternalError());
+
+      return (densities[i+1]-densities[i])/delta_z;
+    }
+
+
+
+    template <int dim>
+    double ComputeEntropyProfile<dim>::get_property (const Point<dim> &p,
+                                                     const std::vector<double> &property) const
+    {
+      const double z = this->get_geometry_model().depth(p);
+
+      if (z >= this->get_geometry_model().maximal_depth())
+        {
+          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
+                  ExcInternalError());
+          return property.back();
+        }
+
+      if (z <= 0)
+        {
+          Assert (z >= -delta_z, ExcInternalError());
+          return property.front();
+        }
+
+      const double floating_index = z/delta_z;
+      const unsigned int i = static_cast<unsigned int>(floating_index);
+
+      // If p is close to an existing value use that one. This prevents
+      // asking for values at i+1 while initializing i+1 (when p is at the
+      // depth of index i).
+      if (std::abs(floating_index-std::floor(floating_index+0.5)) < 1e-6)
+        return property[i];
+
+      Assert (i+1 < property.size(), ExcInternalError());
+
+      // now do the linear interpolation
+      const double d = floating_index - i;
+      Assert ((d>=0) && (d<=1), ExcInternalError());
+
+      return d*property[i+1] + (1.-d)*property[i];
+    }
+
+
+
+
+    template <int dim>
+    void
+    ComputeEntropyProfile<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        prm.enter_subsection("Compute entropy profile");
+        {
+          prm.declare_entry ("Number of points", "1000",
+                             Patterns::Integer (5),
+                             "The number of points we use to compute the adiabatic "
+                             "profile. The higher the number of points, the more accurate "
+                             "the downward integration from the adiabatic surface "
+                             "conditions will be.");
+
+          prm.declare_entry ("Surface entropy", "0",
+                             Patterns::Double(),
+                             "The surface entropy for the profile.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    ComputeEntropyProfile<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        prm.enter_subsection("Compute entropy profile");
+        {
+          n_points = prm.get_integer ("Number of points");
+          surface_entropy = prm.get_double ("Surface entropy");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(ComputeEntropyProfile,
+                                               "compute entropy profile",
+                                               "A model in which the adiabatic profile is "
+                                               "calculated by solving the hydrostatic equations for "
+                                               "pressure and entropy in depth. "
+                                               "Of course the entropy along an adiabat is constant. "
+                                               "This plugin requires the material model to provide an "
+                                               "additional output object of type PrescribedTemperatureOutputs. "
+                                               "It also requires that there is a compositional field of type "
+                                               "'entropy' that represents the entropy of the material.")
+  }
+}
diff --git a/source/adiabatic_conditions/compute_profile.cc.bak b/source/adiabatic_conditions/compute_profile.cc.bak
new file mode 100644
index 00000000000..5ef8d23bc22
--- /dev/null
+++ b/source/adiabatic_conditions/compute_profile.cc.bak
@@ -0,0 +1,427 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/adiabatic_conditions/compute_profile.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/initial_composition/interface.h>
+
+#include <deal.II/base/signaling_nan.h>
+
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    template <int dim>
+    ComputeProfile<dim>::ComputeProfile()
+      :
+      initialized(false),
+      surface_condition_function(2)
+    {}
+
+
+
+    template <int dim>
+    void
+    ComputeProfile<dim>::update()
+    {
+      if (use_surface_condition_function)
+        {
+          initialized = false;
+          surface_condition_function.set_time(this->get_time());
+          initialize();
+        }
+    }
+
+
+    template <int dim>
+    void
+    ComputeProfile<dim>::initialize()
+    {
+      if (initialized)
+        return;
+
+      // The simulator only keeps the initial conditions around for
+      // the first time step. As a consequence, we have to save a
+      // shared pointer to that object ourselves the first time we get
+      // here.
+      if ((reference_composition == initial_composition)
+          &&
+          (initial_composition_manager == nullptr))
+        initial_composition_manager = this->get_initial_composition_manager_pointer();
+
+      temperatures.resize(n_points, numbers::signaling_nan<double>());
+      pressures.resize(n_points, numbers::signaling_nan<double>());
+      densities.resize(n_points, numbers::signaling_nan<double>());
+
+      delta_z = this->get_geometry_model().maximal_depth() / (n_points-1);
+
+      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
+
+      // Constant properties on the reference profile
+      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties;
+      in.velocity[0] = Tensor <1,dim> ();
+
+      // Check whether gravity is pointing up / out or down / in. In the normal case it should
+      // point down / in and therefore gravity should be positive, leading to increasing
+      // adiabatic pressures and temperatures with depth. In some cases it will point up / out
+      // (e.g. for backward advection), in which case the pressures and temperatures should
+      // decrease with depth and therefore gravity has to be negative in the following equations.
+      const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(this->get_geometry_model().representative_point(0));
+      const Point<dim> point_surf = this->get_geometry_model().representative_point(0);
+      const Point<dim> point_bot = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
+      const int gravity_direction =  (g * (point_bot - point_surf) >= 0) ?
+                                     1 :
+                                     -1;
+
+      // now integrate downward using the explicit Euler method for simplicity
+      //
+      // note: p'(z) = rho(p,T) * |g|
+      //       T'(z) = alpha |g| T / C_p
+      for (unsigned int i=0; i<n_points; ++i)
+        {
+          if (i==0)
+            {
+              if (!use_surface_condition_function)
+                {
+                  pressures[0] = this->get_surface_pressure();
+                  temperatures[0] = this->get_adiabatic_surface_temperature();
+                }
+              else
+                {
+                  pressures[0] = surface_condition_function.value(Point<1>(0.0),0);
+                  temperatures[0] = surface_condition_function.value(Point<1>(0.0),1);
+                }
+            }
+          else
+            {
+              // use material properties calculated at i-1
+              const double density = out.densities[0];
+              const double alpha = out.thermal_expansion_coefficients[0];
+              // Handle the case that cp is zero (happens in simple Stokes test problems like sol_cx). By setting
+              // 1/cp = 0.0 we will have a constant temperature profile with depth.
+              const double one_over_cp = (out.specific_heat[0]>0.0) ? 1.0/out.specific_heat[0] : 0.0;
+              // get the magnitude of gravity. we assume
+              // that gravity always points along the depth direction. this
+              // may not strictly be true always but is likely a good enough
+              // approximation here.
+              const double gravity = gravity_direction * this->get_gravity_model().gravity_vector(in.position[0]).norm();
+
+              pressures[i] = pressures[i-1] + density * gravity * delta_z;
+              temperatures[i] = (this->include_adiabatic_heating())
+                                ?
+                                temperatures[i-1] * (1 + alpha * gravity * delta_z * one_over_cp)
+                                :
+                                temperatures[0];
+            }
+
+          const double z = static_cast<double>(i)/static_cast<double>(n_points-1)*this->get_geometry_model().maximal_depth();
+          const Point<dim> representative_point = this->get_geometry_model().representative_point (z);
+          const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(representative_point);
+
+          in.position[0] = representative_point;
+          in.temperature[0] = temperatures[i];
+          in.pressure[0] = pressures[i];
+
+          // we approximate the pressure gradient by extrapolating the values
+          // from the two points above
+          if (i>0)
+            in.pressure_gradient[0] = g/(g.norm() != 0.0 ? g.norm() : 1.0)
+                                      * (pressures[i] - pressures[i-1]) / delta_z;
+          else
+            in.pressure_gradient[0] = Tensor <1,dim> ();
+
+          if (reference_composition == initial_composition)
+            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+              in.composition[0][c] = initial_composition_manager->initial_composition(representative_point, c);
+          else if (reference_composition == reference_function)
+            {
+              const double depth = this->get_geometry_model().depth(representative_point);
+              const Point<1> p(depth);
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                in.composition[0][c] = composition_function->value(p, c);
+            }
+          else
+            AssertThrow(false,ExcNotImplemented());
+
+          this->get_material_model().evaluate(in, out);
+
+          densities[i] = out.densities[0];
+        }
+
+      if (gravity_direction == 1 && this->get_surface_pressure() >= 0)
+        {
+          Assert (*std::min_element (pressures.begin(), pressures.end()) >=
+                  -std::numeric_limits<double>::epsilon() * pressures.size(),
+                  ExcMessage("Adiabatic ComputeProfile encountered a negative pressure of "
+                             + dealii::Utilities::to_string(*std::min_element (pressures.begin(), pressures.end()))));
+        }
+      else if (gravity_direction == -1 && this->get_surface_pressure() <= 0)
+        {
+          Assert (*std::max_element (pressures.begin(), pressures.end()) <=
+                  std::numeric_limits<double>::epsilon() * pressures.size(),
+                  ExcMessage("Adiabatic ComputeProfile encountered a positive pressure of "
+                             + dealii::Utilities::to_string(*std::max_element (pressures.begin(), pressures.end()))));
+        }
+
+      Assert (*std::min_element (temperatures.begin(), temperatures.end()) >=
+              -std::numeric_limits<double>::epsilon() * temperatures.size(),
+              ExcMessage("Adiabatic ComputeProfile encountered a negative temperature."));
+
+
+      initialized = true;
+    }
+
+
+
+    template <int dim>
+    bool
+    ComputeProfile<dim>::is_initialized() const
+    {
+      return initialized;
+    }
+
+
+
+    template <int dim>
+    double ComputeProfile<dim>::pressure (const Point<dim> &p) const
+    {
+      return get_property(p,pressures);
+    }
+
+
+
+    template <int dim>
+    double ComputeProfile<dim>::temperature (const Point<dim> &p) const
+    {
+      return get_property(p,temperatures);
+    }
+
+
+
+    template <int dim>
+    double ComputeProfile<dim>::density (const Point<dim> &p) const
+    {
+      return get_property(p,densities);
+    }
+
+
+
+    template <int dim>
+    double ComputeProfile<dim>::density_derivative (const Point<dim> &p) const
+    {
+      const double z = this->get_geometry_model().depth(p);
+
+      if (z >= this->get_geometry_model().maximal_depth())
+        {
+          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
+                  ExcInternalError());
+          return (densities.back() - densities[densities.size()-2]) / delta_z;
+        }
+
+      if (z < 0)
+        {
+          Assert (z >= -delta_z, ExcInternalError());
+          return (densities[1] - densities.front()) / delta_z;
+        }
+
+      // if z/delta_z is within [k-eps, k+eps] of a whole number k, round it down to k-1
+      const unsigned int i = static_cast<unsigned int>((z/delta_z) * (1. - 2. * std::numeric_limits<double>::epsilon()));
+      Assert (i < densities.size() - 1, ExcInternalError());
+
+      return (densities[i+1]-densities[i])/delta_z;
+    }
+
+
+
+    template <int dim>
+    double ComputeProfile<dim>::get_property (const Point<dim> &p,
+                                              const std::vector<double> &property) const
+    {
+      const double z = this->get_geometry_model().depth(p);
+
+      if (z >= this->get_geometry_model().maximal_depth())
+        {
+          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
+                  ExcInternalError());
+          return property.back();
+        }
+
+      if (z <= 0)
+        {
+          Assert (z >= -delta_z, ExcInternalError());
+          return property.front();
+        }
+
+      const double floating_index = z/delta_z;
+      const unsigned int i = static_cast<unsigned int>(floating_index);
+
+      // If p is close to an existing value use that one. This prevents
+      // asking for values at i+1 while initializing i+1 (when p is at the
+      // depth of index i).
+      if (std::abs(floating_index-std::floor(floating_index+0.5)) < 1e-6)
+        return property[i];
+
+      Assert (i+1 < property.size(), ExcInternalError());
+
+      // now do the linear interpolation
+      const double d = floating_index - i;
+      Assert ((d>=0) && (d<=1), ExcInternalError());
+
+      return d*property[i+1] + (1.-d)*property[i];
+    }
+
+
+
+
+    template <int dim>
+    void
+    ComputeProfile<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        prm.enter_subsection("Compute profile");
+        {
+          Functions::ParsedFunction<1>::declare_parameters (prm, 1);
+          prm.declare_entry("Composition reference profile","initial composition",
+                            Patterns::Selection("initial composition|function"),
+                            "Select how the reference profile for composition "
+                            "is computed. This profile is used to evaluate the "
+                            "material model, when computing the pressure and "
+                            "temperature profile.");
+          prm.declare_entry ("Number of points", "1000",
+                             Patterns::Integer (5),
+                             "The number of points we use to compute the adiabatic "
+                             "profile. The higher the number of points, the more accurate "
+                             "the downward integration from the adiabatic surface "
+                             "temperature will be.");
+          prm.declare_entry ("Use surface condition function", "false",
+                             Patterns::Bool(),
+                             "Whether to use the 'Surface condition function' to determine surface "
+                             "conditions, or the 'Adiabatic surface temperature' and 'Surface pressure' "
+                             "parameters. If this is set to true the reference profile is updated "
+                             "every timestep. The function expression of the function should be "
+                             "independent of space, but can depend on time 't'. The function must "
+                             "return two components, the first one being reference surface pressure, "
+                             "the second one being reference surface temperature.");
+
+          prm.enter_subsection("Surface condition function");
+          {
+            Functions::ParsedFunction<1>::declare_parameters (prm, 2);
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ComputeProfile<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        prm.enter_subsection("Compute profile");
+        {
+          const std::string composition_profile = prm.get("Composition reference profile");
+
+          if (composition_profile == "initial composition")
+            reference_composition = initial_composition;
+          else if (composition_profile == "function")
+            reference_composition = reference_function;
+          else
+            AssertThrow(false, ExcNotImplemented());
+
+          if ((this->n_compositional_fields() > 0) && (reference_composition == reference_function))
+            {
+              composition_function
+                = std::make_unique<Functions::ParsedFunction<1>>(this->n_compositional_fields());
+              try
+                {
+                  composition_function->parse_parameters (prm);
+                }
+              catch (...)
+                {
+                  std::cerr << "ERROR: FunctionParser failed to parse\n"
+                            << "\t'Adiabatic conditions model.compute profile'\n"
+                            << "with expression\n"
+                            << "\t'" << prm.get("Function expression") << "'"
+                            << "More information about the cause of the parse error \n"
+                            << "is shown below.\n";
+                  throw;
+                }
+            }
+
+          n_points = prm.get_integer ("Number of points");
+          use_surface_condition_function = prm.get_bool("Use surface condition function");
+          if (use_surface_condition_function)
+            {
+              prm.enter_subsection("Surface condition function");
+              try
+                {
+                  surface_condition_function.parse_parameters (prm);
+                }
+              catch (...)
+                {
+                  std::cerr << "ERROR: FunctionParser failed to parse\n"
+                            << "\t'Adiabatic conditions model.Initial profile.Surface condition function'\n"
+                            << "with expression\n"
+                            << "\t'" << prm.get("Function expression") << "'"
+                            << "More information about the cause of the parse error \n"
+                            << "is shown below.\n";
+                  throw;
+                }
+              prm.leave_subsection();
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(ComputeProfile,
+                                               "compute profile",
+                                               "A model in which the adiabatic profile is "
+                                               "calculated by solving the hydrostatic equations for "
+                                               "pressure and temperature in depth. "
+                                               "The gravity is assumed to be in depth direction "
+                                               "and the composition is either given by the initial "
+                                               "composition at reference points or computed "
+                                               "as a reference depth-function. "
+                                               "All material parameters are computed by the "
+                                               "material model plugin. The surface conditions are "
+                                               "either constant or changing over time as prescribed "
+                                               "by a user-provided function.")
+  }
+}
diff --git a/source/adiabatic_conditions/function.cc.bak b/source/adiabatic_conditions/function.cc.bak
new file mode 100644
index 00000000000..ddad051d8b6
--- /dev/null
+++ b/source/adiabatic_conditions/function.cc.bak
@@ -0,0 +1,148 @@
+/*
+  Copyright (C) 2016 - 2017 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/adiabatic_conditions/function.h>
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    template <int dim>
+    Function<dim>::Function()
+      : function (3)
+    {}
+
+    template <int dim>
+    void
+    Function<dim>::initialize()
+    {
+    }
+
+    template <int dim>
+    bool
+    Function<dim>::is_initialized() const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    double Function<dim>::pressure (const Point<dim> &p) const
+    {
+      const double z = this->get_geometry_model().depth(p);
+      return function.value(Point<1>(z), 1);
+    }
+
+
+
+    template <int dim>
+    double Function<dim>::temperature (const Point<dim> &p) const
+    {
+      const double z = this->get_geometry_model().depth(p);
+      return function.value(Point<1>(z), 0);
+    }
+
+    template <int dim>
+    double Function<dim>::density (const Point<dim> &p) const
+    {
+      const double z = this->get_geometry_model().depth(p);
+      return function.value(Point<1>(z), 2);
+    }
+
+
+
+    template <int dim>
+    double Function<dim>::density_derivative (const Point<dim> &p) const
+    {
+      // TODO: better eps or make it a user input
+      const double z = this->get_geometry_model().depth(p);
+      const double z2 = z + (1.e6 * std::numeric_limits<double>::epsilon())
+                        * this->get_geometry_model().maximal_depth();
+      return (function.value(Point<1>(z), 2)
+              - function.value(Point<1>(z2), 2))/(z-z2);
+    }
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        prm.enter_subsection("Function");
+        Functions::ParsedFunction<1>::declare_parameters (prm, 3);
+        prm.declare_entry("Function expression","0.0; 0.0; 1.0",
+                          Patterns::Anything(),
+                          "Expression for the adiabatic temperature, "
+                          "pressure, and density separated by "
+                          "semicolons as a function of `depth'.");
+        prm.declare_entry("Variable names","depth");
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Adiabatic conditions model");
+      {
+        prm.enter_subsection("Function");
+        try
+          {
+            function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Adiabatic conditions model.Function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(Function,
+                                               "function",
+                                               "A model in which the adiabatic profile is "
+                                               "specified by a user defined function. The "
+                                               "supplied function has to contain "
+                                               "temperature, pressure, and density as a function "
+                                               "of depth in this order.")
+  }
+}
diff --git a/source/adiabatic_conditions/interface.cc.bak b/source/adiabatic_conditions/interface.cc.bak
new file mode 100644
index 00000000000..05619b509a0
--- /dev/null
+++ b/source/adiabatic_conditions/interface.cc.bak
@@ -0,0 +1,222 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace AdiabaticConditions
+  {
+    template <int dim>
+    void Interface<dim>::get_adiabatic_temperature_profile(std::vector<double> &values) const
+    {
+      const unsigned int num_slices = values.size();
+      const double max_depth = this->get_geometry_model().maximal_depth();
+      AssertThrow(num_slices > 1, ExcInternalError());
+
+      for (unsigned int n = 0 ; n < num_slices; ++n)
+        {
+          const double depth = n * max_depth / (num_slices-1);
+          const Point<dim> p = this->get_geometry_model().representative_point(depth);
+          values[n] = temperature(p);
+        }
+    }
+
+
+    template <int dim>
+    void Interface<dim>::get_adiabatic_pressure_profile(std::vector<double> &values) const
+    {
+      const unsigned int num_slices = values.size();
+      const double max_depth = this->get_geometry_model().maximal_depth();
+      AssertThrow(num_slices > 1, ExcInternalError());
+
+      for (unsigned int n = 0 ; n < num_slices; ++n)
+        {
+          const double depth = n * max_depth / (num_slices-1);
+          const Point<dim> p = this->get_geometry_model().representative_point(depth);
+          values[n] = pressure(p);
+        }
+    }
+
+    template <int dim>
+    void Interface<dim>::get_adiabatic_density_profile(std::vector<double> &values) const
+    {
+      const unsigned int num_slices = values.size();
+      const double max_depth = this->get_geometry_model().maximal_depth();
+      AssertThrow(num_slices > 1, ExcInternalError());
+
+      for (unsigned int n = 0 ; n < num_slices; ++n)
+        {
+          const double depth = n * max_depth / (num_slices-1);
+          const Point<dim> p = this->get_geometry_model().representative_point(depth);
+          values[n] = density(p);
+        }
+    }
+
+    template <int dim>
+    void Interface<dim>::get_adiabatic_density_derivative_profile(std::vector<double> &values) const
+    {
+      const unsigned int num_slices = values.size();
+      const double max_depth = this->get_geometry_model().maximal_depth();
+      AssertThrow(num_slices > 1, ExcInternalError());
+
+      for (unsigned int n = 0 ; n < num_slices; ++n)
+        {
+          const double depth = n * max_depth / (num_slices-1);
+          const Point<dim> p = this->get_geometry_model().representative_point(depth);
+          values[n] = density_derivative(p);
+        }
+    }
+
+
+// -------------------------------- Deal with registering models and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    register_adiabatic_conditions (const std::string &name,
+                                   const std::string &description,
+                                   void (*declare_parameters_function) (ParameterHandler &),
+                                   std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_adiabatic_conditions (ParameterHandler &prm)
+    {
+      std::string model_name;
+      prm.enter_subsection ("Adiabatic conditions model");
+      {
+        model_name = prm.get ("Model name");
+      }
+      prm.leave_subsection ();
+
+      std::unique_ptr<Interface<dim>>plugin = std::get<dim>(registered_plugins).create_plugin (model_name,
+                                               "Adiabatic Conditions model::Model name");
+
+      return plugin;
+
+    }
+
+
+
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm)
+    {
+      // declare the entry in the parameter file
+      prm.enter_subsection ("Adiabatic conditions model");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry ("Model name", "compute profile",
+                           Patterns::Selection (pattern_of_names),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Adiabatic conditions interface",
+                                                            out);
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<AdiabaticConditions::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<AdiabaticConditions::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<AdiabaticConditions::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<AdiabaticConditions::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace AdiabaticConditions
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_adiabatic_conditions<dim> (const std::string &, \
+                                      const std::string &, \
+                                      void ( *) (ParameterHandler &), \
+                                      std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_adiabatic_conditions<dim> (ParameterHandler &prm);
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/boundary_composition/ascii_data.cc.bak b/source/boundary_composition/ascii_data.cc.bak
new file mode 100644
index 00000000000..69c9d179284
--- /dev/null
+++ b/source/boundary_composition/ascii_data.cc.bak
@@ -0,0 +1,131 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_composition/ascii_data.h>
+
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      = default;
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      Utilities::AsciiDataBoundary<dim>::initialize(this->get_fixed_composition_boundary_indicators(),
+                                                    this->n_compositional_fields());
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::update ()
+    {
+      Interface<dim>::update ();
+
+      Utilities::AsciiDataBoundary<dim>::update();
+    }
+
+
+    template <int dim>
+    double
+    AsciiData<dim>::
+    boundary_composition (const types::boundary_id boundary_indicator,
+                          const Point<dim> &position,
+                          const unsigned int compositional_field) const
+    {
+      return Utilities::AsciiDataBoundary<dim>::get_data_component(boundary_indicator,
+                                                                   position,
+                                                                   compositional_field);
+    }
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
+                                                              "$ASPECT_SOURCE_DIR/data/boundary-composition/ascii-data/test/",
+                                                              "box_2d_%s.%d.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(AsciiData,
+                                               "ascii data",
+                                               "Implementation of a model in which the boundary "
+                                               "composition is derived from files containing data "
+                                               "in ascii format. Note the required format of the "
+                                               "input data: The first lines may contain any number of comments "
+                                               "if they begin with `#', but one of these lines needs to "
+                                               "contain the number of grid points in each dimension as "
+                                               "for example `# POINTS: 3 3'. "
+                                               "The order of the data columns "
+                                               "has to be `x', `composition1', `composition2', "
+                                               "etc. in a 2d model and "
+                                               "`x', `y', `composition1', `composition2', "
+                                               "etc., in a 3d model, according "
+                                               "to the number of compositional fields, which means that "
+                                               "there has to be a single column "
+                                               "for every composition in the model. "
+                                               "Note that the data in the input "
+                                               "files need to be sorted in a specific order: "
+                                               "the first coordinate needs to ascend first, "
+                                               "followed by the second in order to "
+                                               "assign the correct data to the prescribed coordinates."
+                                               "If you use a spherical model, "
+                                               "then the assumed grid changes. `x' will be replaced by "
+                                               "the radial distance of the point to the bottom of the model, "
+                                               "`y' by the azimuth angle and `z' by the polar angle measured "
+                                               "positive from the north pole. The grid will be assumed to be "
+                                               "a latitude-longitude grid. Note that the order "
+                                               "of spherical coordinates is `r', `phi', `theta' "
+                                               "and not `r', `theta', `phi', since this allows "
+                                               "for dimension independent expressions.")
+  }
+}
diff --git a/source/boundary_composition/box.cc.bak b/source/boundary_composition/box.cc.bak
new file mode 100644
index 00000000000..1dd7d357f1e
--- /dev/null
+++ b/source/boundary_composition/box.cc.bak
@@ -0,0 +1,180 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_composition/box.h>
+#include <aspect/geometry_model/box.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+// ------------------------------ Box -------------------
+
+    template <int dim>
+    double
+    Box<dim>::
+    boundary_composition (const types::boundary_id boundary_indicator,
+                          const Point<dim> &/*position*/,
+                          const unsigned int compositional_field) const
+    {
+      Assert (boundary_indicator<2*dim, ExcMessage ("The given boundary indicator needs to be less than 2*dimension.."));
+      return composition_values[boundary_indicator][compositional_field];
+    }
+
+    template <int dim>
+    void
+    Box<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Box");
+        {
+          prm.declare_entry ("Left composition", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the left boundary (at minimal $x$-value). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          prm.declare_entry ("Right composition", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the right boundary (at maximal $x$-value). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          prm.declare_entry ("Bottom composition", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the bottom boundary (at minimal $y$-value in 2d, or minimal "
+                             "$z$-value in 3d). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          prm.declare_entry ("Top composition", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the top boundary (at maximal $y$-value in 2d, or maximal "
+                             "$z$-value in 3d). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          if (dim==3)
+            {
+              prm.declare_entry ("Front composition", "",
+                                 Patterns::List(Patterns::Double ()),
+                                 "A comma separated list of composition boundary values "
+                                 "at the front boundary (at minimum $y$-value). This list must have as many "
+                                 "entries as there are compositional fields. Units: none.");
+              prm.declare_entry ("Back composition", "",
+                                 Patterns::List(Patterns::Double ()),
+                                 "A comma separated list of composition boundary values "
+                                 "at the back boundary (at maximum $y$-value). This list must have as many "
+                                 "entries as there are compositional fields. Units: none.");
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    Box<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Box");
+        {
+          switch (dim)
+            {
+              case 2:
+                composition_values[0] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition")));
+                composition_values[1] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition")));
+                composition_values[2] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Bottom composition")));
+                composition_values[3] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Top composition")));
+                break;
+
+              case 3:
+                composition_values[0] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition")));
+                composition_values[1] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition")));
+                composition_values[2] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Front composition")));
+                composition_values[3] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Back composition")));
+                composition_values[4] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Bottom composition")));
+                composition_values[5] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Top composition")));
+                break;
+
+              default:
+                Assert (false, ExcNotImplemented());
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+
+    template <int dim>
+    void
+    Box<dim>::initialize()
+    {
+      // verify that the geometry is a box since only for this geometry
+      // do we know for sure what boundary indicators it uses and what they mean
+      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
+                   ExcMessage ("This boundary model is only implemented if the geometry is "
+                               "a box."));
+
+      // Verify that each of the lists for boundary values
+      // has the requisite number of elements if it is in the set
+      // of prescribed boundary indicators.
+      for (unsigned int f=0; f<2*dim; ++f)
+        if (this->get_boundary_composition_manager().get_fixed_composition_boundary_indicators().count(f) != 0)
+          AssertThrow (composition_values[f].size() == this->n_compositional_fields(),
+                       ExcMessage (std::string("The specification of boundary composition values for the `box' model "
+                                               "requires as many values on each face of the box as there are compositional "
+                                               "fields. However, for face ")
+                                   +
+                                   Utilities::int_to_string(f)
+                                   +
+                                   ", the input file specifies "
+                                   +
+                                   Utilities::int_to_string(composition_values[f].size())
+                                   +
+                                   " values even though there are "
+                                   +
+                                   Utilities::int_to_string(this->n_compositional_fields())
+                                   +
+                                   " compositional fields."));
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(Box,
+                                               "box",
+                                               "A model in which the composition is chosen constant on "
+                                               "the sides of a box which are selected by the parameters "
+                                               "Left/Right/Top/Bottom/Front/Back composition")
+  }
+}
diff --git a/source/boundary_composition/function.cc.bak b/source/boundary_composition/function.cc.bak
new file mode 100644
index 00000000000..2c8a172dc51
--- /dev/null
+++ b/source/boundary_composition/function.cc.bak
@@ -0,0 +1,146 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_composition/function.h>
+#include <aspect/utilities.h>
+#include <aspect/global.h>
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+
+    template <int dim>
+    double
+    Function<dim>::
+    boundary_composition (const types::boundary_id /*boundary_indicator*/,
+                          const Point<dim> &position,
+                          const unsigned int compositional_field) const
+    {
+      const Utilities::NaturalCoordinate<dim> point =
+        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
+      return function->value(Utilities::convert_array_to_point<dim>(point.get_coordinates()), compositional_field);
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::update()
+    {
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        function->set_time (this->get_time() / year_in_seconds);
+      else
+        function->set_time (this->get_time());
+    }
+
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Function");
+        {
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are 'cartesian', 'spherical', and 'depth'. "
+                             "'spherical' coordinates are interpreted as r,phi "
+                             "or r,phi,theta in 2d/3d respectively with theta "
+                             "being the polar angle. 'depth' will create a "
+                             "function, in which only the first parameter is "
+                             "non-zero, which is interpreted to be the depth of "
+                             "the point.");
+
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Function");
+        {
+          coordinate_system = ::aspect::Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+
+          try
+            {
+              function
+                = std::make_unique<Functions::ParsedFunction<dim>>(this->n_compositional_fields());
+              function->parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Boundary composition model.Function'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(Function,
+                                               "function",
+                                               "Implementation of a model in which the boundary "
+                                               "composition is given in terms of an explicit formula "
+                                               "that is elaborated in the parameters in section "
+                                               "``Boundary composition model|Function''. "
+                                               "\n\n"
+                                               "Since the symbol $t$ indicating time "
+                                               "may appear in the formulas for the prescribed "
+                                               "composition, it is interpreted as having units "
+                                               "seconds unless the global input parameter ``Use "
+                                               "years in output instead of seconds'' is set, in "
+                                               "which case we interpret the formula expressions "
+                                               "as having units year."
+                                               "\n\n"
+                                               "The format of these "
+                                               "functions follows the syntax understood by the "
+                                               "muparser library, see "
+                                               "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+  }
+}
diff --git a/source/boundary_composition/initial_composition.cc.bak b/source/boundary_composition/initial_composition.cc.bak
new file mode 100644
index 00000000000..1e96a2d761f
--- /dev/null
+++ b/source/boundary_composition/initial_composition.cc.bak
@@ -0,0 +1,135 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_composition/initial_composition.h>
+#include <aspect/initial_composition/interface.h>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+// ------------------------------ InitialComposition -------------------
+
+    template <int dim>
+    void
+    InitialComposition<dim>::initialize()
+    {
+      // Make sure we keep track of the initial composition manager and
+      // that it continues to live beyond the time when the simulator
+      // class releases its pointer to it.
+      initial_composition = this->get_initial_composition_manager_pointer();
+    }
+
+
+
+    template <int dim>
+    double
+    InitialComposition<dim>::
+    boundary_composition (const types::boundary_id /*boundary_indicator*/,
+                          const Point<dim> &position,
+                          const unsigned int compositional_field) const
+    {
+      return initial_composition->initial_composition(position, compositional_field);
+    }
+
+
+    template <int dim>
+    double
+    InitialComposition<dim>::
+    minimal_composition (const std::set<types::boundary_id> &) const
+    {
+      return min_composition;
+    }
+
+
+
+    template <int dim>
+    double
+    InitialComposition<dim>::
+    maximal_composition (const std::set<types::boundary_id> &) const
+    {
+      return max_composition;
+    }
+
+
+
+    template <int dim>
+    void
+    InitialComposition<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Initial composition");
+        {
+          prm.declare_entry ("Minimal composition", "0.",
+                             Patterns::Double (),
+                             "Minimal composition. Units: none.");
+          prm.declare_entry ("Maximal composition", "1.",
+                             Patterns::Double (),
+                             "Maximal composition. Units: none.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    InitialComposition<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Initial composition");
+        {
+          min_composition = prm.get_double ("Minimal composition");
+          max_composition = prm.get_double ("Maximal composition");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(InitialComposition,
+                                               "initial composition",
+                                               "A model in which the composition at the boundary "
+                                               "is chosen to be the same as given in the initial "
+                                               "conditions."
+                                               "\n\n"
+                                               "Because this class simply takes what the initial "
+                                               "composition had described, this class can not "
+                                               "know certain pieces of information such as the "
+                                               "minimal and maximal composition on the boundary. "
+                                               "For operations that require this, for example in "
+                                               "post-processing, this boundary composition model "
+                                               "must therefore be told what the minimal and "
+                                               "maximal values on the boundary are. This is done "
+                                               "using parameters set in section ``Boundary composition model/Initial composition''.")
+  }
+}
diff --git a/source/boundary_composition/interface.cc.bak b/source/boundary_composition/interface.cc.bak
new file mode 100644
index 00000000000..91719a1e34f
--- /dev/null
+++ b/source/boundary_composition/interface.cc.bak
@@ -0,0 +1,376 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_composition/interface.h>
+
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/exceptions.h>
+#include <deal.II/base/signaling_nan.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    // ------------------------------ Manager -----------------------------
+    // -------------------------------- Deal with registering boundary_composition models and automating
+    // -------------------------------- their setup and selection at run time
+
+    template <int dim>
+    Manager<dim>::~Manager()
+      = default;
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::update ()
+    {
+      for (auto &p : this->plugin_objects)
+        p->update();
+    }
+
+
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_boundary_composition (const std::string &name,
+                                                 const std::string &description,
+                                                 void (*declare_parameters_function) (ParameterHandler &),
+                                                 std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // find out which plugins are requested and the various other
+      // parameters we declare here
+      prm.enter_subsection ("Boundary composition model");
+      {
+        model_names
+          = Utilities::split_string_list(prm.get("List of model names"));
+
+        AssertThrow(Utilities::has_unique_entries(model_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Boundary composition model/List of model names' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+
+        const std::string model_name = prm.get ("Model name");
+
+        AssertThrow (model_name == "unspecified" || model_names.size() == 0,
+                     ExcMessage ("The parameter 'Model name' is only used for reasons"
+                                 "of backwards compatibility and can not be used together with "
+                                 "the new functionality 'List of model names'. Please add your "
+                                 "boundary composition model to the list instead."));
+
+        if (!(model_name == "unspecified"))
+          model_names.push_back(model_name);
+
+        // create operator list
+        std::vector<std::string> model_operator_names =
+          Utilities::possibly_extend_from_1_to_N (Utilities::split_string_list(prm.get("List of model operators")),
+                                                  model_names.size(),
+                                                  "List of model operators");
+        model_operators = Utilities::create_model_operator_list(model_operator_names);
+
+        try
+          {
+            const std::vector<types::boundary_id> x_fixed_composition_boundary_indicators
+              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids (Utilities::split_string_list
+                                                                                     (prm.get ("Fixed composition boundary indicators")));
+            fixed_composition_boundary_indicators
+              = std::set<types::boundary_id> (x_fixed_composition_boundary_indicators.begin(),
+                                              x_fixed_composition_boundary_indicators.end());
+
+            // If model names have been set, but no boundaries on which to use them,
+            // ignore the set values, do not create objects that are never used.
+            if (fixed_composition_boundary_indicators.size() == 0)
+              {
+                model_names.clear();
+                model_operators.clear();
+              }
+          }
+        catch (const std::string &error)
+          {
+            AssertThrow (false, ExcMessage ("While parsing the entry <Model settings/Fixed composition "
+                                            "boundary indicators>, there was an error. Specifically, "
+                                            "the conversion function complained as follows:\n\n"
+                                            + error));
+          }
+
+        if (prm.get ("Allow fixed composition on outflow boundaries") == "true")
+          allow_fixed_composition_on_outflow_boundaries = true;
+        else if (prm.get ("Allow fixed composition on outflow boundaries") == "false")
+          allow_fixed_composition_on_outflow_boundaries = false;
+        else if (prm.get ("Allow fixed composition on outflow boundaries") == "false for models without melt")
+          allow_fixed_composition_on_outflow_boundaries = this->get_parameters().include_melt_transport;
+        else
+          AssertThrow(false, ExcMessage("'Allow fixed composition on outflow boundaries' "
+                                        "must be set to 'true' or 'false', or to its default value."));
+      }
+      prm.leave_subsection ();
+
+      // go through the list, create objects and let them parse
+      // their own parameters
+      for (auto &model_name : model_names)
+        {
+          // create boundary composition objects
+          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
+                                          (std::get<dim>(registered_plugins)
+                                           .create_plugin (model_name,
+                                                           "Boundary composition::Model names")));
+
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(this->plugin_objects.back().get()))
+            sim->initialize_simulator (this->get_simulator());
+
+          this->plugin_objects.back()->parse_parameters (prm);
+          this->plugin_objects.back()->initialize ();
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    Manager<dim>::boundary_composition (const types::boundary_id boundary_indicator,
+                                        const Point<dim> &position,
+                                        const unsigned int compositional_field) const
+    {
+      double composition = 0.0;
+
+      auto p = this->plugin_objects.begin();
+      for (unsigned int i=0; i<this->plugin_objects.size(); ++p, ++i)
+        composition = model_operators[i](composition,
+                                         (*p)->boundary_composition(boundary_indicator,
+                                                                    position,
+                                                                    compositional_field));
+
+      return composition;
+    }
+
+
+
+    template <int dim>
+    const std::vector<std::string> &
+    Manager<dim>::get_active_boundary_composition_names () const
+    {
+      return model_names;
+    }
+
+
+    template <int dim>
+    const std::list<std::unique_ptr<Interface<dim>>> &
+    Manager<dim>::get_active_boundary_composition_conditions () const
+    {
+      return this->plugin_objects;
+    }
+
+
+
+    template <int dim>
+    const std::set<types::boundary_id> &
+    Manager<dim>::get_fixed_composition_boundary_indicators() const
+    {
+      return fixed_composition_boundary_indicators;
+    }
+
+
+
+    template <int dim>
+    bool
+    Manager<dim>::allows_fixed_composition_on_outflow_boundaries() const
+    {
+      return allow_fixed_composition_on_outflow_boundaries;
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // declare the entry in the parameter file
+      prm.enter_subsection ("Boundary composition model");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry("List of model names",
+                          "",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma-separated list of boundary composition models that "
+                          "will be used to initialize the composition. "
+                          "These plugins are loaded in the order given, and modify the "
+                          "existing composition field via the operators listed "
+                          "in 'List of model operators'.\n\n"
+                          "The following boundary composition models are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+
+        prm.declare_entry("List of model operators", "add",
+                          Patterns::MultipleSelection(Utilities::get_model_operator_options()),
+                          "A comma-separated list of operators that "
+                          "will be used to append the listed composition models onto "
+                          "the previous models. If only one operator is given, "
+                          "the same operator is applied to all models.");
+
+        prm.declare_entry ("Model name", "unspecified",
+                           Patterns::Selection (pattern_of_names+"|unspecified"),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string()
+                           + "\n\n" +
+                           "\\textbf{Warning}: This parameter provides an old and "
+                           "deprecated way of specifying "
+                           "boundary composition models and shouldn't be used. "
+                           "Please use 'List of model names' instead.");
+
+        prm.declare_entry ("Fixed composition boundary indicators", "",
+                           Patterns::List (Patterns::Anything()),
+                           "A comma separated list of names denoting those boundaries "
+                           "on which the composition is fixed and described by the "
+                           "boundary composition object selected in its own section "
+                           "of this input file. All boundary indicators used by the geometry "
+                           "but not explicitly listed here will end up with no-flux "
+                           "(insulating) boundary conditions."
+                           "\n\n"
+                           "The names of the boundaries listed here can either be "
+                           "numbers (in which case they correspond to the numerical "
+                           "boundary indicators assigned by the geometry object), or they "
+                           "can correspond to any of the symbolic names the geometry object "
+                           "may have provided for each part of the boundary. You may want "
+                           "to compare this with the documentation of the geometry model you "
+                           "use in your model."
+                           "\n\n"
+                           "This parameter only describes which boundaries have a fixed "
+                           "composition, but not what composition should hold on these "
+                           "boundaries. The latter piece of information needs to be "
+                           "implemented in a plugin in the BoundaryComposition "
+                           "group, unless an existing implementation in this group "
+                           "already provides what you want.");
+        prm.declare_entry ("Allow fixed composition on outflow boundaries", "false for models without melt",
+                           Patterns::Selection("true|false|false for models without melt"),
+                           "When the composition is fixed on a given boundary as determined "
+                           "by the list of 'Fixed composition boundary indicators', there "
+                           "might be parts of the boundary where material flows out and "
+                           "one may want to prescribe the composition only on those parts of "
+                           "the boundary where there is inflow. This parameter determines "
+                           "if compositions are only prescribed at these inflow parts of the "
+                           "boundary (if false) or everywhere on a given boundary, independent "
+                           "of the flow direction (if true). By default, this parameter is set "
+                           "to false, except in models with melt transport (see below). "
+                           "Note that in this context, `fixed' refers to the fact that these "
+                           "are the boundary indicators where Dirichlet boundary conditions are "
+                           "applied, and does not imply that the boundary composition is "
+                           "time-independent. "
+                           "\n\n"
+                           "Mathematically speaking, the compositional fields satisfy an "
+                           "advection equation that has no diffusion. For this equation, one "
+                           "can only impose Dirichlet boundary conditions (i.e., prescribe a "
+                           "fixed compositional field value at the boundary) at those boundaries "
+                           "where material flows in. This would correspond to the ``false'' "
+                           "setting of this parameter, which is correspondingly the default. "
+                           "On the other hand, on a finite dimensional discretization such as "
+                           "the one one obtains from the finite element method, it is possible "
+                           "to also prescribe values on outflow boundaries, even though this may "
+                           "make no physical sense. This would then correspond to the ``true'' "
+                           "setting of this parameter. Note however that this parameter is only "
+                           "taken into account for the continuous field method and is not "
+                           "applied to the Discontinuous Galerkin (DG) field method. "
+                           "\n\n"
+                           "A warning for models with melt transport: In models with fluid flow, "
+                           "some compositional fields (in particular the porosity) might be "
+                           "transported with the fluid velocity, and would need to set the "
+                           "constraints based on the fluid velocity. However, this is currently "
+                           "not possible, because we reuse the same matrix for all compositional "
+                           "fields, and therefore can not use different constraints for different "
+                           "fields. Consequently, we set this parameter to true by default in "
+                           "models where melt transport is enabled. Be aware that if you change "
+                           "this default setting, you will not use the melt velocity, but the solid "
+                           "velocity to determine on which parts of the boundaries there is outflow.");
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary composition interface",
+                                                            out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryComposition::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryComposition::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryComposition::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryComposition::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace BoundaryComposition
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/boundary_composition/spherical_constant.cc.bak b/source/boundary_composition/spherical_constant.cc.bak
new file mode 100644
index 00000000000..7c9694813d0
--- /dev/null
+++ b/source/boundary_composition/spherical_constant.cc.bak
@@ -0,0 +1,143 @@
+/*
+  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <deal.II/base/signaling_nan.h>
+#include <aspect/boundary_composition/spherical_constant.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    template <int dim>
+    void
+    SphericalConstant<dim>::
+    initialize ()
+    {
+      // verify that the geometry is supported by this plugin
+      AssertThrow ( Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) ||
+                    Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()) ||
+                    Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()) ||
+                    Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()),
+                    ExcMessage ("This boundary model is only implemented if the geometry is "
+                                "one of the spherical geometries."));
+
+      // no inner boundary in a full sphere
+      if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()))
+        inner_boundary_indicator = numbers::invalid_unsigned_int;
+      else
+        inner_boundary_indicator = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
+
+      outer_boundary_indicator = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+    }
+
+
+
+    template <int dim>
+    double
+    SphericalConstant<dim>::
+    boundary_composition (const types::boundary_id boundary_indicator,
+                          const Point<dim> &/*position*/,
+                          const unsigned int compositional_field) const
+    {
+      if (boundary_indicator == outer_boundary_indicator)
+        return outer_composition[compositional_field];
+      else if (boundary_indicator == inner_boundary_indicator)
+        return inner_composition[compositional_field];
+      else
+        AssertThrow (false,
+                     ExcMessage ("Unknown boundary indicator for geometry model. "
+                                 "The given boundary should be ``top'' or ``bottom''."));
+
+      return numbers::signaling_nan<double>();
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalConstant<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Spherical constant");
+        {
+          prm.declare_entry ("Outer composition", "0.",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the top boundary (at maximal radius). This list must have "
+                             "one entry or as many entries as there are compositional fields. "
+                             "Units: none.");
+          prm.declare_entry ("Inner composition", "1.",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the bottom boundary (at minimal radius). This list must have "
+                             "one entry or as many entries as there are compositional fields. "
+                             "Units: none.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    SphericalConstant<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      const unsigned int n_compositional_fields = this->n_compositional_fields();
+
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Spherical constant");
+        {
+          inner_composition = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Inner composition"))),
+                                                                      n_compositional_fields,
+                                                                      "Inner boundary composition values");
+
+          outer_composition = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Outer composition"))),
+                                                                      n_compositional_fields,
+                                                                      "Outer boundary composition values");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(SphericalConstant,
+                                               "spherical constant",
+                                               "A model in which the composition is chosen constant on "
+                                               "the inner and outer boundaries of a sphere, spherical "
+                                               "shell, chunk or ellipsoidal chunk. "
+                                               "Parameters are read from subsection 'Spherical constant'.")
+  }
+}
diff --git a/source/boundary_composition/two_merged_boxes.cc.bak b/source/boundary_composition/two_merged_boxes.cc.bak
new file mode 100644
index 00000000000..78ab9d5119e
--- /dev/null
+++ b/source/boundary_composition/two_merged_boxes.cc.bak
@@ -0,0 +1,207 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_composition/two_merged_boxes.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+
+    template <int dim>
+    double
+    TwoMergedBoxes<dim>::
+    boundary_composition (const types::boundary_id boundary_indicator,
+                          const Point<dim> &/*position*/,
+                          const unsigned int compositional_field) const
+    {
+      Assert (boundary_indicator<2*dim+2*(dim-1), ExcMessage ("The given boundary indicator needs to be less than 2*dimension+2*(dim-1)."));
+
+      return composition_values[boundary_indicator][compositional_field];
+    }
+
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Box with lithosphere boundary indicators");
+        {
+          prm.declare_entry ("Left composition", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the left boundary (at minimal $x$-value). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          prm.declare_entry ("Right composition", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the right boundary (at maximal $x$-value). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          prm.declare_entry ("Left composition lithosphere", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the left boundary (at minimal $x$-value). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          prm.declare_entry ("Right composition lithosphere", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the right boundary (at maximal $x$-value). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          prm.declare_entry ("Bottom composition", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the bottom boundary (at minimal $y$-value in 2d, or minimal "
+                             "$z$-value in 3d). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          prm.declare_entry ("Top composition", "",
+                             Patterns::List(Patterns::Double ()),
+                             "A comma separated list of composition boundary values "
+                             "at the top boundary (at maximal $y$-value in 2d, or maximal "
+                             "$z$-value in 3d). This list must have as many "
+                             "entries as there are compositional fields. Units: none.");
+          if (dim==3)
+            {
+              prm.declare_entry ("Front composition", "",
+                                 Patterns::List(Patterns::Double ()),
+                                 "A comma separated list of composition boundary values "
+                                 "at the front boundary (at minimal $y$-value). This list must have as many "
+                                 "entries as there are compositional fields. Units: none.");
+              prm.declare_entry ("Back composition", "",
+                                 Patterns::List(Patterns::Double ()),
+                                 "A comma separated list of composition boundary values "
+                                 "at the back boundary (at maximal $y$-value). This list must have as many "
+                                 "entries as there are compositional fields. Units: none.");
+              prm.declare_entry ("Front composition lithosphere", "",
+                                 Patterns::List(Patterns::Double ()),
+                                 "A comma separated list of composition boundary values "
+                                 "at the front lithosphere boundary (at minimal $y$-value). This list must have as many "
+                                 "entries as there are compositional fields. Units: none.");
+              prm.declare_entry ("Back composition lithosphere", "",
+                                 Patterns::List(Patterns::Double ()),
+                                 "A comma separated list of composition boundary values "
+                                 "at the back lithosphere boundary (at maximal $y$-value). This list must have as many "
+                                 "entries as there are compositional fields. Units: none.");
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary composition model");
+      {
+        prm.enter_subsection("Box with lithosphere boundary indicators");
+        {
+          switch (dim)
+            {
+              case 2:
+                composition_values[0] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition")));
+                composition_values[1] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition")));
+                composition_values[2] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Bottom composition")));
+                composition_values[3] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Top composition")));
+                composition_values[4] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition lithosphere")));
+                composition_values[5] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition lithosphere")));
+                break;
+
+              case 3:
+                composition_values[0] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition")));
+                composition_values[1] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition")));
+                composition_values[2] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Front composition")));
+                composition_values[3] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Back composition")));
+                composition_values[4] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Bottom composition")));
+                composition_values[5] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Top composition")));
+                composition_values[6] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition lithosphere")));
+                composition_values[7] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition lithosphere")));
+                composition_values[8] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Front composition lithosphere")));
+                composition_values[9] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Back composition lithosphere")));
+                break;
+
+              default:
+                Assert (false, ExcNotImplemented());
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::initialize()
+    {
+      // verify that the geometry is a box since only for this geometry
+      // do we know for sure what boundary indicators it uses and what they mean
+      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
+                   ExcMessage ("This boundary model is only useful if the geometry is "
+                               "a box with additional lithosphere boundary indicators."));
+
+      // verify that each of the lists for boundary values
+      // has the requisite number of elements
+      for (unsigned int f=0; f<2*dim+2*(dim-1); ++f)
+        AssertThrow (composition_values[f].size() == this->n_compositional_fields(),
+                     ExcMessage (std::string("The specification of boundary composition values for the `box with "
+                                             "lithosphere boundary indicators' model "
+                                             "requires as many values for each boundary indicator the box as there "
+                                             "are compositional "
+                                             "fields. However, for boundary indicator ")
+                                 +
+                                 Utilities::int_to_string(f)
+                                 +
+                                 ", the input file specifies "
+                                 +
+                                 Utilities::int_to_string(composition_values[f].size())
+                                 +
+                                 " values even though there are "
+                                 +
+                                 Utilities::int_to_string(this->n_compositional_fields())
+                                 +
+                                 " compositional fields."));
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryComposition
+  {
+    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(TwoMergedBoxes,
+                                               "box with lithosphere boundary indicators",
+                                               "A model in which the composition is chosen constant on "
+                                               "all the sides of a box. Additional boundary indicators "
+                                               "are added to the lithospheric parts of the vertical boundaries. "
+                                               "This model is to be used with the 'Two Merged Boxes' Geometry Model.")
+  }
+}
diff --git a/source/boundary_fluid_pressure/density.cc.bak b/source/boundary_fluid_pressure/density.cc.bak
new file mode 100644
index 00000000000..c22e157c99f
--- /dev/null
+++ b/source/boundary_fluid_pressure/density.cc.bak
@@ -0,0 +1,154 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_fluid_pressure/density.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/melt.h>
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryFluidPressure
+  {
+
+    template <int dim>
+    void
+    Density<dim>::
+    fluid_pressure_gradient (
+      const types::boundary_id /*boundary_indicator*/,
+      const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+      const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+      const std::vector<Tensor<1,dim>> &normal_vectors,
+      std::vector<double> &fluid_pressure_gradient_outputs
+    ) const
+    {
+      const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+      Assert(melt_outputs!=nullptr, ExcMessage("Error, MeltOutputs are missing in fluid_pressure_gradient()"));
+      for (unsigned int q=0; q<fluid_pressure_gradient_outputs.size(); ++q)
+        {
+          const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(material_model_inputs.position[q]);
+
+          switch (density_formulation)
+            {
+              case DensityFormulation::solid_density:
+              {
+                fluid_pressure_gradient_outputs[q] = (material_model_outputs.densities[q] * gravity) * normal_vectors[q];
+                break;
+              }
+
+              case DensityFormulation::fluid_density:
+              {
+                fluid_pressure_gradient_outputs[q] = (melt_outputs->fluid_densities[q] * gravity) * normal_vectors[q];
+                break;
+              }
+
+              case DensityFormulation::average_density:
+              {
+                const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+                const double phi =  material_model_inputs.composition[q][porosity_idx];
+                fluid_pressure_gradient_outputs[q] = ((1.0 - phi) * material_model_outputs.densities[q] * gravity
+                                                      + phi * melt_outputs->fluid_densities[q] * gravity)
+                                                     * normal_vectors[q];
+                break;
+              }
+
+              default:
+                Assert (false, ExcNotImplemented());
+            }
+        }
+    }
+
+    template <int dim>
+    void
+    Density<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary fluid pressure model");
+      {
+        prm.enter_subsection("Density");
+        {
+          prm.declare_entry ("Density formulation", "solid density",
+                             Patterns::Selection ("solid density|fluid density|average density"),
+                             "The density formulation used to compute the fluid pressure gradient "
+                             "at the model boundary."
+                             "\n\n"
+                             "`solid density' prescribes the gradient of the fluid pressure as "
+                             "solid density times gravity (which is the lithostatic "
+                             "pressure) and leads to approximately the same pressure in "
+                             "the melt as in the solid, so that fluid is only flowing "
+                             "in or out due to differences in dynamic pressure."
+                             "\n\n"
+                             "`fluid density' prescribes the gradient of the fluid pressure as "
+                             "fluid density times gravity and causes melt to flow in "
+                             "with the same velocity as inflowing solid material, "
+                             "or no melt flowing in or out if the solid velocity "
+                             "normal to the boundary is zero."
+                             "\n\n"
+                             "'average density' prescribes the gradient of the fluid pressure as "
+                             "the averaged fluid and solid density times gravity "
+                             "(which is a better approximation for the lithostatic "
+                             "pressure than just the solid density) and leads to approximately the same pressure in "
+                             "the melt as in the solid, so that fluid is only flowing "
+                             "in or out due to differences in dynamic pressure.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    Density<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary fluid pressure model");
+      {
+        prm.enter_subsection("Density");
+        {
+          if (prm.get ("Density formulation") == "solid density")
+            density_formulation = DensityFormulation::solid_density;
+          else if (prm.get ("Density formulation") == "fluid density")
+            density_formulation = DensityFormulation::fluid_density;
+          else if (prm.get ("Density formulation") == "average density")
+            density_formulation = DensityFormulation::average_density;
+          else
+            AssertThrow (false, ExcNotImplemented());
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryFluidPressure
+  {
+    ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(Density,
+                                                  "density",
+                                                  "A plugin that prescribes the fluid pressure gradient at "
+                                                  "the boundary based on fluid/solid density from the material "
+                                                  "model.")
+  }
+}
diff --git a/source/boundary_fluid_pressure/interface.cc.bak b/source/boundary_fluid_pressure/interface.cc.bak
new file mode 100644
index 00000000000..f14832e9278
--- /dev/null
+++ b/source/boundary_fluid_pressure/interface.cc.bak
@@ -0,0 +1,155 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace BoundaryFluidPressure
+  {
+// -------------------------------- Deal with registering models and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    register_boundary_fluid_pressure (const std::string &name,
+                                      const std::string &description,
+                                      void (*declare_parameters_function) (ParameterHandler &),
+                                      std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_boundary_fluid_pressure (ParameterHandler &prm)
+    {
+      std::string model_name;
+      prm.enter_subsection ("Boundary fluid pressure model");
+      {
+        model_name = prm.get ("Plugin name");
+      }
+      prm.leave_subsection ();
+
+      return std::get<dim>(registered_plugins).create_plugin (model_name,
+                                                              "Boundary fluid pressure model::Plugin name");
+    }
+
+
+
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Boundary fluid pressure model");
+      const std::string pattern_of_names
+        = std::get<dim>(registered_plugins).get_pattern_of_names ();
+      prm.declare_entry ("Plugin name", "density",
+                         Patterns::Selection (pattern_of_names),
+                         "Select one of the following plugins:\n\n"
+                         +
+                         std::get<dim>(registered_plugins).get_description_string());
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary fluid pressure interface",
+                                                            out);
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryFluidPressure::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryFluidPressure::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryFluidPressure::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryFluidPressure::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace BoundaryFluidPressure
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_boundary_fluid_pressure<dim> (const std::string &, \
+                                         const std::string &, \
+                                         void ( *) (ParameterHandler &), \
+                                         std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_boundary_fluid_pressure<dim> (ParameterHandler &prm);
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/boundary_heat_flux/function.cc.bak b/source/boundary_heat_flux/function.cc.bak
new file mode 100644
index 00000000000..3d7e49fc576
--- /dev/null
+++ b/source/boundary_heat_flux/function.cc.bak
@@ -0,0 +1,179 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_heat_flux/function.h>
+#include <aspect/global.h>
+#include <aspect/geometry_model/interface.h>
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace BoundaryHeatFlux
+  {
+    template <int dim>
+    std::vector<Tensor<1,dim>>
+    Function<dim>::
+    heat_flux (const types::boundary_id /*boundary_indicator*/,
+               const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+               const MaterialModel::MaterialModelOutputs<dim> &/*material_model_outputs*/,
+               const std::vector<Tensor<1,dim>> &normal_vectors) const
+    {
+      const unsigned int n_evaluation_points = material_model_inputs.n_evaluation_points();
+      std::vector<Tensor<1,dim>> heat_flux(normal_vectors);
+
+      for (unsigned int i=0; i<n_evaluation_points; ++i)
+        {
+          const Point<dim> position = material_model_inputs.position[i];
+          if (coordinate_system == Utilities::Coordinates::cartesian)
+            {
+              heat_flux[i] *= boundary_heat_flux_function.value(position);
+            }
+          else if (coordinate_system == Utilities::Coordinates::spherical)
+            {
+              const std::array<double,dim> spherical_coordinates =
+                aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
+              Point<dim> point;
+
+              for (unsigned int d=0; d<dim; ++d)
+                point[d] = spherical_coordinates[d];
+
+              heat_flux[i] *= boundary_heat_flux_function.value(point);
+            }
+          else if (coordinate_system == Utilities::Coordinates::depth)
+            {
+              const double depth = this->get_geometry_model().depth(position);
+              Point<dim> point;
+              point(0) = depth;
+
+              heat_flux[i] *= boundary_heat_flux_function.value(point);
+            }
+          else
+            {
+              AssertThrow(false, ExcNotImplemented());
+            }
+        }
+
+      return heat_flux;
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::update()
+    {
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        boundary_heat_flux_function.set_time (this->get_time() / year_in_seconds);
+      else
+        boundary_heat_flux_function.set_time (this->get_time());
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary heat flux model");
+      {
+        prm.enter_subsection("Function");
+        {
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle. `depth' "
+                             "will create a function, in which only the first "
+                             "parameter is non-zero, which is interpreted to "
+                             "be the depth of the point.");
+
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary heat flux model");
+      {
+        prm.enter_subsection("Function");
+        {
+          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+        }
+        try
+          {
+            boundary_heat_flux_function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Boundary heat flux model.Function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryHeatFlux
+  {
+    ASPECT_REGISTER_BOUNDARY_HEAT_FLUX_MODEL(Function,
+                                             "function",
+                                             "Implementation of a model in which the boundary "
+                                             "heat flux is given in terms of an explicit formula "
+                                             "that is elaborated in the parameters in section "
+                                             "``Boundary heat flux model|Function''. The format of these "
+                                             "functions follows the syntax understood by the "
+                                             "muparser library, see "
+                                             "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`."
+                                             "\n\n"
+                                             "The formula you describe in the mentioned "
+                                             "section is a scalar value for the heat flux that is assumed "
+                                             "to be the flux normal to the boundary, and that has the unit "
+                                             "W/(m$^2$) (in 3d) or W/m (in 2d). Negative fluxes are "
+                                             "interpreted as the flow of heat into the domain, and positive "
+                                             "fluxes are interpreted as heat flowing out of the domain."
+                                             "\n\n"
+                                             "The symbol $t$ indicating time that "
+                                             "may appear in the formulas for the prescribed "
+                                             "heat flux is interpreted as having units "
+                                             "seconds unless the global parameter ``Use "
+                                             "years in output instead of seconds'' has "
+                                             "been set.")
+  }
+}
diff --git a/source/boundary_heat_flux/interface.cc.bak b/source/boundary_heat_flux/interface.cc.bak
new file mode 100644
index 00000000000..db736384b2a
--- /dev/null
+++ b/source/boundary_heat_flux/interface.cc.bak
@@ -0,0 +1,155 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_heat_flux/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace BoundaryHeatFlux
+  {
+// -------------------------------- Deal with registering models and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    register_boundary_heat_flux (const std::string &name,
+                                 const std::string &description,
+                                 void (*declare_parameters_function) (ParameterHandler &),
+                                 std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_boundary_heat_flux (ParameterHandler &prm)
+    {
+      std::string model_name;
+      prm.enter_subsection ("Boundary heat flux model");
+      {
+        model_name = prm.get ("Model name");
+      }
+      prm.leave_subsection ();
+
+      return std::get<dim>(registered_plugins).create_plugin (model_name,
+                                                              "Boundary heat flux model::Model name");
+    }
+
+
+
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Boundary heat flux model");
+      const std::string pattern_of_names
+        = std::get<dim>(registered_plugins).get_pattern_of_names ();
+      prm.declare_entry ("Model name", "function",
+                         Patterns::Selection (pattern_of_names),
+                         "Select one of the following plugins:\n\n"
+                         +
+                         std::get<dim>(registered_plugins).get_description_string());
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary heat flux interface",
+                                                            out);
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryHeatFlux::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryHeatFlux::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryHeatFlux::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryHeatFlux::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace BoundaryHeatFlux
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_boundary_heat_flux<dim> (const std::string &, \
+                                    const std::string &, \
+                                    void ( *) (ParameterHandler &), \
+                                    std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_boundary_heat_flux<dim> (ParameterHandler &prm);
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/boundary_temperature/ascii_data.cc.bak b/source/boundary_temperature/ascii_data.cc.bak
new file mode 100644
index 00000000000..5e3737ed89f
--- /dev/null
+++ b/source/boundary_temperature/ascii_data.cc.bak
@@ -0,0 +1,144 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_temperature/ascii_data.h>
+
+#include <deal.II/base/parameter_handler.h>
+
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      Utilities::AsciiDataBoundary<dim>::initialize(this->get_fixed_temperature_boundary_indicators(),
+                                                    1);
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::update ()
+    {
+      Interface<dim>::update ();
+      Utilities::AsciiDataBoundary<dim>::update();
+    }
+
+
+    template <int dim>
+    double
+    AsciiData<dim>::boundary_temperature (const types::boundary_id boundary_indicator,
+                                          const Point<dim> &position) const
+    {
+      return Utilities::AsciiDataBoundary<dim>::get_data_component(boundary_indicator,
+                                                                   position,
+                                                                   0);
+    }
+
+
+    template <int dim>
+    double
+    AsciiData<dim>::minimal_temperature (const std::set<types::boundary_id> &) const
+    {
+      return 0;
+    }
+
+
+    template <int dim>
+    double
+    AsciiData<dim>::maximal_temperature (const std::set<types::boundary_id> &) const
+    {
+      return 0;
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
+                                                              "$ASPECT_SOURCE_DIR/data/boundary-temperature/ascii-data/test/",
+                                                              "box_2d_%s.%d.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(AsciiData,
+                                               "ascii data",
+                                               "Implementation of a model in which the boundary "
+                                               "data is derived from files containing data "
+                                               "in ascii format. Note the required format of the "
+                                               "input data: The first lines may contain any number of comments "
+                                               "if they begin with `#', but one of these lines needs to "
+                                               "contain the number of grid points in each dimension as "
+                                               "for example `# POINTS: 3 3'. "
+                                               "The order of the data columns "
+                                               "has to be `x', `Temperature [K]' in a 2d model and "
+                                               " `x', `y', `Temperature [K]' in a 3d model, which means that "
+                                               "there has to be a single column "
+                                               "containing the temperature. "
+                                               "Note that the data in the input "
+                                               "files need to be sorted in a specific order: "
+                                               "the first coordinate needs to ascend first, "
+                                               "followed by the second in order to "
+                                               "assign the correct data to the prescribed coordinates. "
+                                               "If you use a spherical model, "
+                                               "then the assumed grid changes. `x' will be replaced by "
+                                               "the radial distance of the point to the bottom of the model, "
+                                               "`y' by the azimuth angle and `z' by the polar angle measured "
+                                               "positive from the north pole. The grid will be assumed to be "
+                                               "a latitude-longitude grid. Note that the order "
+                                               "of spherical coordinates is `r', `phi', `theta' "
+                                               "and not `r', `theta', `phi', since this allows "
+                                               "for dimension independent expressions.")
+  }
+}
diff --git a/source/boundary_temperature/box.cc.bak b/source/boundary_temperature/box.cc.bak
new file mode 100644
index 00000000000..f1899243c66
--- /dev/null
+++ b/source/boundary_temperature/box.cc.bak
@@ -0,0 +1,173 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/box.h>
+#include <aspect/geometry_model/box.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+// ------------------------------ Box -------------------
+
+    template <int dim>
+    double
+    Box<dim>::
+    boundary_temperature (const types::boundary_id boundary_indicator,
+                          const Point<dim> &/*position*/) const
+    {
+      Assert (boundary_indicator<2*dim, ExcMessage ("Given boundary indicator needs to be less than 2*dimension."));
+      return temperature_[boundary_indicator];
+    }
+
+
+    template <int dim>
+    double
+    Box<dim>::
+    minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
+    {
+      if (fixed_boundary_ids.empty())
+        return *std::min_element(temperature_, temperature_+2*dim);
+      else
+        {
+          double min = maximal_temperature(fixed_boundary_ids);
+          for (const auto id : fixed_boundary_ids)
+            min = std::min(min,temperature_[id]);
+          return min;
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    Box<dim>::
+    maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
+    {
+      if (fixed_boundary_ids.empty())
+        return *std::max_element(temperature_, temperature_+2*dim);
+      else
+        {
+          double max = std::numeric_limits<double>::lowest();
+          for (const auto id : fixed_boundary_ids)
+            max = std::max(max,temperature_[id]);
+          return max;
+        }
+    }
+
+    template <int dim>
+    void
+    Box<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Box");
+        {
+          prm.declare_entry ("Left temperature", "1.",
+                             Patterns::Double (),
+                             "Temperature at the left boundary (at minimal $x$-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Right temperature", "0.",
+                             Patterns::Double (),
+                             "Temperature at the right boundary (at maximal $x$-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Bottom temperature", "0.",
+                             Patterns::Double (),
+                             "Temperature at the bottom boundary (at minimal $z$-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Top temperature", "0.",
+                             Patterns::Double (),
+                             "Temperature at the top boundary (at maximal $x$-value). Units: \\si{\\kelvin}.");
+          if (dim==3)
+            {
+              prm.declare_entry ("Front temperature", "0.",
+                                 Patterns::Double (),
+                                 "Temperature at the front boundary (at minimal $y$-value). Units: \\si{\\kelvin}.");
+              prm.declare_entry ("Back temperature", "0.",
+                                 Patterns::Double (),
+                                 "Temperature at the back boundary (at maximal $y$-value). Units: \\si{\\kelvin}.");
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    Box<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Box");
+        {
+          switch (dim)
+            {
+              case 2:
+                temperature_[0] = prm.get_double ("Left temperature");
+                temperature_[1] = prm.get_double ("Right temperature");
+                temperature_[2] = prm.get_double ("Bottom temperature");
+                temperature_[3] = prm.get_double ("Top temperature");
+                break;
+
+              case 3:
+                temperature_[0] = prm.get_double ("Left temperature");
+                temperature_[1] = prm.get_double ("Right temperature");
+                temperature_[2] = prm.get_double ("Front temperature");
+                temperature_[3] = prm.get_double ("Back temperature");
+                temperature_[4] = prm.get_double ("Bottom temperature");
+                temperature_[5] = prm.get_double ("Top temperature");
+                break;
+
+              default:
+                Assert (false, ExcNotImplemented());
+            }
+
+          // verify that the geometry is a box since only for this geometry
+          // do we know for sure what boundary indicators it uses and what they mean
+          AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
+                       ExcMessage ("This boundary model is only implemented if the geometry is "
+                                   "a box."));
+
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box,
+                                               "box",
+                                               "A model in which the temperature is chosen constant on "
+                                               "the sides of a box which are selected by the parameters "
+                                               "Left/Right/Top/Bottom/Front/Back temperature")
+  }
+}
diff --git a/source/boundary_temperature/constant.cc.bak b/source/boundary_temperature/constant.cc.bak
new file mode 100644
index 00000000000..442eee8a480
--- /dev/null
+++ b/source/boundary_temperature/constant.cc.bak
@@ -0,0 +1,189 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/constant.h>
+
+#include <deal.II/base/utilities.h>
+#include <deal.II/base/signaling_nan.h>
+
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+// ------------------------------ Constant -------------------
+
+    template <int dim>
+    double
+    Constant<dim>::
+    boundary_temperature (const types::boundary_id boundary_indicator,
+                          const Point<dim> &/*position*/) const
+    {
+      const std::map<types::boundary_id, double>::const_iterator it = boundary_temperatures.find(boundary_indicator);
+      if (it != boundary_temperatures.end())
+        return it->second;
+      else
+        {
+          Assert (false,
+                  ExcMessage ("Unknown boundary indicator with number <" + Utilities::int_to_string(boundary_indicator) + ">. "
+                              "You may not have specified the temperature for this boundary indicator "
+                              "in the input file."));
+          return numbers::signaling_nan<double>();
+        }
+    }
+
+
+    template <int dim>
+    double
+    Constant<dim>::
+    minimal_temperature (const std::set<types::boundary_id> &) const
+    {
+      std::map<types::boundary_id, double>::const_iterator it = boundary_temperatures.begin();
+      double min = it->second;
+      ++it;
+
+      for ( ; it != boundary_temperatures.end(); ++it)
+        if ( it->second < min )
+          min = it->second;
+
+      return min;
+    }
+
+
+
+    template <int dim>
+    double
+    Constant<dim>::
+    maximal_temperature (const std::set<types::boundary_id> &) const
+    {
+      std::map<types::boundary_id, double>::const_iterator it = boundary_temperatures.begin();
+      double max = it->second;
+      ++it;
+
+      for ( ; it != boundary_temperatures.end(); ++it)
+        if ( it->second > max )
+          max = it->second;
+
+      return max;
+    }
+
+
+
+    template <int dim>
+    void
+    Constant<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Constant");
+        {
+          prm.declare_entry ("Boundary indicator to temperature mappings", "",
+                             Patterns::Map (Patterns::Anything(),
+                                            Patterns::Double()),
+                             "A comma separated list of mappings between boundary "
+                             "indicators and the temperature associated with the "
+                             "boundary indicators. The format for this list is "
+                             "``indicator1 : value1, indicator2 : value2, ...'', "
+                             "where each indicator is a valid boundary indicator "
+                             "(either a number or the symbolic name of a boundary as provided "
+                             "by the geometry model) "
+                             "and each value is the temperature of that boundary." );
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    Constant<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Constant");
+        {
+          // get the list of mappings
+          const std::vector<std::string> x_boundary_temperatures
+            = Utilities::split_string_list(prm.get ("Boundary indicator to temperature mappings"));
+
+
+          for (const auto &boundary_id_string : x_boundary_temperatures)
+            {
+              // each entry has the format (white space is optional):
+              // <id> : <value (might have spaces)>
+              const std::vector<std::string> parts = Utilities::split_string_list (boundary_id_string, ':');
+
+              AssertThrow (parts.size() == 2,
+                           ExcMessage (std::string("Invalid entry trying to describe boundary "
+                                                   "temperatures. Each entry needs to have the form "
+                                                   "<boundary_id : name>, "
+                                                   "but there is an entry of the form <") + boundary_id_string + ">"));
+
+              types::boundary_id boundary_id;
+              try
+                {
+                  boundary_id
+                    = this->get_geometry_model().translate_symbolic_boundary_name_to_id (parts[0]);
+                }
+              catch (const std::string &error)
+                {
+                  AssertThrow (false, ExcMessage ("While parsing the entry <Boundary temperature model/Constant>, "
+                                                  "there was an error. Specifically, "
+                                                  "the conversion function complained as follows:\n\n"
+                                                  + error));
+                }
+
+              AssertThrow((this->get_fixed_temperature_boundary_indicators().find(boundary_id) != this->get_fixed_temperature_boundary_indicators().end()),
+                          ExcMessage ("You have indicated a temperature mapping for "
+                                      "boundary indicator " + parts[0] + ", but that "
+                                      "indicator isn't in the "
+                                      "list of Fixed temperature boundary indicators."));
+
+              AssertThrow (boundary_temperatures.find(boundary_id) == boundary_temperatures.end(),
+                           ExcMessage ("Boundary indicator <" + Utilities::int_to_string(boundary_id) +
+                                       "> appears more than once in the list of indicators "
+                                       "for constant temperature boundary conditions."));
+
+              boundary_temperatures[boundary_id] = Utilities::string_to_double (parts[1]);
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Constant,
+                                               "constant",
+                                               "A model in which the temperature is chosen constant on "
+                                               "a given boundary indicator.  Parameters are read from the "
+                                               "subsection 'Constant'.")
+  }
+}
diff --git a/source/boundary_temperature/dynamic_core.cc.bak b/source/boundary_temperature/dynamic_core.cc.bak
new file mode 100644
index 00000000000..f38bbbae653
--- /dev/null
+++ b/source/boundary_temperature/dynamic_core.cc.bak
@@ -0,0 +1,986 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/boundary_temperature/dynamic_core.h>
+#include <aspect/postprocess/core_statistics.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/simulator_access.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/mpi.h>
+#include <deal.II/base/exceptions.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    boundary_temperature (const types::boundary_id            boundary_indicator,
+                          const Point<dim>                    &/*location*/) const
+    {
+      switch (boundary_indicator)
+        {
+          case 0:
+            return inner_temperature;
+          case 1:
+            return outer_temperature;
+          default:
+            Assert (false, ExcMessage ("Unknown boundary indicator."));
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+    }
+
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    minimal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
+    {
+      return std::min (inner_temperature, outer_temperature);
+    }
+
+
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    maximal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
+    {
+      return std::max (inner_temperature, outer_temperature);
+    }
+
+
+
+    template <int dim>
+    void
+    DynamicCore<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Dynamic core");
+        {
+          prm.declare_entry ("Outer temperature", "0.",
+                             Patterns::Double (),
+                             "Temperature at the outer boundary (lithosphere water/air). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Inner temperature", "6000.",
+                             Patterns::Double (),
+                             "Temperature at the inner boundary (core mantle boundary) at the "
+                             "beginning. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("dT over dt", "0.",
+                             Patterns::Double (),
+                             "Initial CMB temperature changing rate. "
+                             "Units: \\si{\\kelvin}/year.");
+          prm.declare_entry ("dR over dt", "0.",
+                             Patterns::Double (),
+                             "Initial inner core radius changing rate. "
+                             "Units: \\si{\\kilo\\meter}/year.");
+          prm.declare_entry ("dX over dt", "0.",
+                             Patterns::Double (),
+                             "Initial light composition changing rate. "
+                             "Units: 1/year.");
+          prm.declare_entry ("Core density", "12.5e3",
+                             Patterns::Double (),
+                             "Density of the core. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Gravity acceleration", "9.8",
+                             Patterns::Double (),
+                             "Gravitation acceleration at CMB. "
+                             "Units: \\si{\\meter\\per\\second\\squared}.");
+          prm.declare_entry ("CMB pressure", "0.14e12",
+                             Patterns::Double (),
+                             "Pressure at CMB. Units: \\si{\\pascal}.");
+          prm.declare_entry ("Initial light composition", "0.01",
+                             Patterns::Double (0.),
+                             "Initial light composition (eg. S,O) concentration "
+                             "in weight fraction.");
+          prm.declare_entry ("Max iteration", "30000",
+                             Patterns::Integer (0),
+                             "The max iterations for nonlinear core energy solver.");
+          prm.declare_entry ("Core heat capacity", "840.",
+                             Patterns::Double (0.),
+                             "Heat capacity of the core. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("K0", "4.111e11",
+                             Patterns::Double (0.),
+                             "Core compressibility at zero pressure. "
+                             "See \\cite{NPB+04} for more details.");
+          prm.declare_entry ("Rho0", "7.019e3",
+                             Patterns::Double (0.),
+                             "Core density at zero pressure. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}. "
+                             "See \\cite{NPB+04} for more details.");
+          prm.declare_entry ("Alpha", "1.35e-5",
+                             Patterns::Double (0.),
+                             "Core thermal expansivity. Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Lh", "750e3",
+                             Patterns::Double (0.),
+                             "The latent heat of core freeze. "
+                             "Units: \\si{\\joule\\per\\kilogram}.");
+          prm.declare_entry ("Rh","-27.7e6",
+                             Patterns::Double (),
+                             "The heat of reaction. "
+                             "Units: \\si{\\joule\\per\\kilogram}.");
+          prm.declare_entry ("Beta composition", "1.1",
+                             Patterns::Double (0.),
+                             "Compositional expansion coefficient $Beta_c$. "
+                             "See \\cite{NPB+04} for more details.");
+          prm.declare_entry ("Delta","0.5",
+                             Patterns::Double (0., 1.),
+                             "Partition coefficient of the light element.");
+          prm.declare_entry ("Core conductivity", "60.",
+                             Patterns::Double (0.),
+                             "Core heat conductivity $k_c$. Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.enter_subsection("Geotherm parameters");
+          {
+            prm.declare_entry ("Tm0","1695.",
+                               Patterns::Double (0.),
+                               "Melting curve (\\cite{NPB+04} eq. (40)) parameter Tm0. Units: \\si{\\kelvin}.");
+            prm.declare_entry ("Tm1","10.9",
+                               Patterns::Double (),
+                               "Melting curve (\\cite{NPB+04} eq. (40)) parameter Tm1. "
+                               "Units: \\si{\\per\\tera\\pascal}.");
+            prm.declare_entry ("Tm2","-8.0",
+                               Patterns::Double (),
+                               "Melting curve (\\cite{NPB+04} eq. (40)) parameter Tm2. "
+                               "Units: \\si{\\per\\tera\\pascal\\squared}.");
+            prm.declare_entry ("Theta","0.11",
+                               Patterns::Double (),
+                               "Melting curve (\\cite{NPB+04} eq. (40)) parameter Theta.");
+            prm.declare_entry ("Composition dependency","true",
+                               Patterns::Bool (),
+                               "If melting curve dependent on composition.");
+            prm.declare_entry ("Use BW11","false",
+                               Patterns::Bool (),
+                               "If using the Fe-FeS system solidus from Buono \\& Walker (2011) instead.");
+          }
+          prm.leave_subsection ();
+
+          prm.enter_subsection("Radioactive heat source");
+          {
+            prm.declare_entry ("Number of radioactive heating elements","0",
+                               Patterns::Integer (0),
+                               "Number of different radioactive heating elements in core");
+            prm.declare_entry ("Heating rates","",
+                               Patterns::List (Patterns::Double ()),
+                               "Heating rates of different elements (W/kg)");
+            prm.declare_entry ("Half life times","",
+                               Patterns::List (Patterns::Double ()),
+                               "Half decay times of different elements (Ga)");
+            prm.declare_entry ("Initial concentrations","",
+                               Patterns::List (Patterns::Double ()),
+                               "Initial concentrations of different elements (ppm)");
+          }
+          prm.leave_subsection ();
+
+          prm.enter_subsection("Other energy source");
+          {
+            prm.declare_entry ("File name","",
+                               Patterns::Anything(),
+                               "Data file name for other energy source into the core. "
+                               "The 'other energy source' is used for external core energy source."
+                               "For example if someone want to test the early lunar core powered by precession "
+                               "(Dwyer, C. A., et al. (2011). A long-lived lunar dynamo driven by continuous mechanical stirring. Nature 479(7372): 212-214.)"
+                               "Format [Time(Gyr)   Energy rate(W)]");
+          }
+          prm.leave_subsection ();
+
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    DynamicCore<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Dynamic core");
+        {
+          // verify that the geometry is in fact a spherical shell since only
+          // for this geometry do we know for sure what boundary indicators it
+          // uses and what they mean
+          AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()),
+                       ExcMessage ("This boundary model is only implemented if the geometry is "
+                                   "a spherical shell."));
+
+          inner_temperature = prm.get_double ("Inner temperature");
+          outer_temperature = prm.get_double ("Outer temperature");
+          init_dT_dt        = prm.get_double ("dT over dt") / year_in_seconds;
+          init_dR_dt        = prm.get_double ("dR over dt") / year_in_seconds * 1.e3;
+          init_dX_dt        = prm.get_double ("dX over dt") / year_in_seconds;
+          Rho_cen           = prm.get_double ("Core density");
+          g                 = prm.get_double ("Gravity acceleration");
+          P_CMB             = prm.get_double ("CMB pressure");
+          X_init            = prm.get_double ("Initial light composition");
+          max_steps         = prm.get_integer ("Max iteration");
+          Cp                = prm.get_double ("Core heat capacity");
+          CpRho             = Cp*Rho_cen;
+
+          //\cite{NPB+04}
+          K0                = prm.get_double ("K0");
+          Alpha             = prm.get_double ("Alpha");
+          Rho_0             = prm.get_double ("Rho0");
+          Lh                = prm.get_double ("Lh");
+          Beta_c            = prm.get_double ("Beta composition");
+          k_c               = prm.get_double ("Core conductivity");
+          Delta             = prm.get_double ("Delta");
+          Rh                = prm.get_double ("Rh");
+
+          prm.enter_subsection("Geotherm parameters");
+          {
+            Tm0           =  prm.get_double ("Tm0");
+            Tm1           =  prm.get_double ("Tm1");
+            Tm2           =  prm.get_double ("Tm2");
+            Theta         =  prm.get_double ("Theta");
+            composition_dependency
+              =  prm.get_bool("Composition dependency");
+            use_bw11      =  prm.get_bool("Use BW11");
+          }
+          prm.leave_subsection ();
+
+          prm.enter_subsection("Radioactive heat source");
+          {
+            n_radioheating_elements = prm.get_integer ("Number of radioactive heating elements");
+            heating_rate = Utilities::string_to_double
+                           (Utilities::split_string_list
+                            (prm.get("Heating rates")));
+            AssertThrow(n_radioheating_elements==heating_rate.size(),
+                        ExcMessage("Number of heating rate entities does not match "
+                                   "the number of radioactive elements."));
+            half_life = Utilities::string_to_double
+                        (Utilities::split_string_list
+                         (prm.get("Half life times")));
+            AssertThrow(n_radioheating_elements==half_life.size(),
+                        ExcMessage("Number of half life time entities does not match "
+                                   "the number of radioactive elements."));
+            initial_concentration = Utilities::string_to_double
+                                    (Utilities::split_string_list
+                                     (prm.get("Initial concentrations")));
+            AssertThrow(n_radioheating_elements==initial_concentration.size(),
+                        ExcMessage("Number of initial concentration entities does not match "
+                                   "the number of radioactive elements."));
+          }
+          prm.leave_subsection ();
+
+          prm.enter_subsection("Other energy source");
+          {
+            name_OES = prm.get("File name");
+          }
+          prm.leave_subsection ();
+
+          L=sqrt(3*K0*(log(Rho_cen/Rho_0)+1)/(2*M_PI*constants::big_g*Rho_0*Rho_cen));
+          D=sqrt(3*Cp/(2*M_PI*Alpha*Rho_cen*constants::big_g));
+
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+    template <int dim>
+    void
+    DynamicCore<dim>::read_data_OES()
+    {
+      data_OES.clear();
+      if (name_OES.size()==0)
+        return;
+      std::istringstream in(Utilities::read_and_distribute_file_content(name_OES,
+                                                                        this->get_mpi_communicator()));
+      if (in.good())
+        {
+          str_data_OES data_read;
+          std::string line;
+          while (!in.eof())
+            {
+              std::getline(in, line);
+              if (sscanf(line.data(), "%le\t%le\n", &data_read.t, &data_read.w)==2)
+                data_OES.push_back(data_read);
+            }
+        }
+      if (data_OES.size()!=0)
+        this->get_pcout() << "Other energy source is in use ( "
+                          << data_OES.size()
+                          << " data points is read)."
+                          << std::endl;
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::get_OES(double t) const
+    {
+      // The core evolution is quite slow, so the time units used here is billion years.
+      t/=1.e9*year_in_seconds;
+      double w=0.;
+      for (unsigned i=1; i<data_OES.size(); ++i)
+        {
+          if (t>=data_OES[i-1].t && t<data_OES[i].t )
+            {
+              w = data_OES[i-1].w + ( t - data_OES[i-1].t)
+                  /(data_OES[i].t - data_OES[i-1].t)
+                  *(data_OES[i].w - data_OES[i-1].w);
+              break;
+            }
+        }
+      return w;
+    }
+
+    template <int dim>
+    DynamicCore<dim>::DynamicCore()
+    {
+      is_first_call = true;
+      core_data.is_initialized = false;
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::get_initial_Ri(double T)
+    {
+      double r0=0.,
+             r1=Rc;
+      double dT0=get_T(T,r0)-get_solidus(get_X(r0),get_Pressure(r0)),
+             dT1=get_T(T,r1)-get_solidus(get_X(r1),get_Pressure(r1));
+      if (dT0<=0. && dT1<=0.)
+        return Rc;
+      if (dT0>=0. && dT1>=0.)
+        return 0.;
+      for (int i=0; i<max_steps; ++i)
+        {
+          double rm=(r0+r1)/2.,
+                 dTm=get_T(T,rm)-get_solidus(get_X(rm),get_Pressure(rm));
+          if (dTm==0.)
+            return rm;
+          if (dTm*dT0<0.)
+            {
+              r1=rm;
+              continue;
+            }
+          if (dTm*dT1<0.)
+            {
+              r0=rm;
+              continue;
+            }
+        }
+      if (dT0>0 && dT1<0)
+        {
+          // Snowing core
+          AssertThrow(false, ExcMessage("[Dynamic core] You had a 'Snowing Core' (i.e., core is freezing from CMB), "
+                                        "the treatment is not available at the moment."));
+        }
+      return (r0+r1)/2.;
+    }
+
+    template <int dim>
+    bool
+    DynamicCore<dim>::solve_time_step(double &X, double &T, double &R)
+    {
+      // Well solving the change in core-mantle boundary temperature T, inner core radius R, and
+      //    light component (e.g. S, O, Si) composition X, the following relations has to be respected:
+      // 1. At the inner core boundary the adiabatic temperature should be equal to solidus temperature
+      // 2. The following energy production rate should be balanced in core:
+      //    Heat flux at core-mantle boundary         Q
+      //    Specific heat                             Qs*dT/dt
+      //    Radioactive heating                       Qr
+      //    Gravitational contribution                Qg*dR/dt
+      //    Latent heat                               Ql*dR/dt
+      //    So that         Q+Qs*dT/dt+Qr+Qg*dR/dt*Ql*dR/dt=0
+      // 3. The light component composition X depends on inner core radius (See function get_X() ),
+      //    and core solidus may dependent on X as well
+      // This becomes a small nonlinear problem. Directly iterate through the above three system doesn't
+      // converge well. Alternatively we solve the inner core radius by bisection method.
+
+      int steps=1;
+      double R_0,R_1,R_2;
+      // dT is the temperature difference between adiabatic and solidus at
+      // inner-outer core boundary. If dT=0 then we found our solution.
+      double dT0,dT1,dT2;
+      R_0 = 0.;
+      R_1 = core_data.Ri;
+      R_2 = Rc;
+      dT0 = get_dT(R_0);
+      dT1 = get_dT(R_1);
+      dT2 = get_dT(R_2);
+
+      if (dT0 >= 0. && dT2 >= 0.)
+        {
+          // Fully molten core
+          R_1 = R_0;
+          dT1 = 0;
+        }
+      else if (dT2 <= 0. && dT0 <= 0. )
+        {
+          //Completely solid core
+          R_1 = R_2;
+          dT1 = 0;
+        }
+      else while (!(dT1==0 || steps>max_steps))
+          {
+            // If solution is out of the interval, then something is wrong.
+            if (dT0*dT2>0)
+              {
+                this->get_pcout()<<"Step: "<<steps<<std::endl
+                                 <<" R=["<<R_0/1e3<<","<<R_2/1e3<<"]"<<"(km)"
+                                 <<" dT0="<<dT0<<", dT2="<<dT2<<std::endl
+                                 <<"Q_CMB="<<core_data.Q<<std::endl
+                                 <<"Warning: Solution for inner core radius can not be found! Mid-point is used."<<std::endl;
+                AssertThrow(dT0*dT2<=0,ExcMessage("No single solution for inner core!"));
+              }
+            else if (dT0*dT1<0.)
+              {
+                R_2 = R_1;
+                dT2 = dT1;
+              }
+            else if (dT2*dT1<0.)
+              {
+                R_0 = R_1;
+                dT0 = dT1;
+              }
+            R_1 = (R_0 + R_2) / 2.;
+            dT1 = get_dT(R_1);
+            ++steps;
+          }
+
+      // Calculate new R,T,X
+      R = R_1;
+      T = get_Tc(R);
+      X = get_X(R);
+
+      if (dT0<0. && dT2>0.)
+        {
+          // Normal solution
+          return true;
+        }
+      else if (dT0>0. && dT2<0.)
+        {
+          // Snowing core solution
+          return false;
+        }
+      else
+        {
+          // No solution found.
+          this->get_pcout()<<"[Dynamic core] Step: "<<steps<<std::endl
+                           <<" R=["<<R_0/1e3<<","<<R_2/1e3<<"]"<<"(km)"
+                           <<" dT0="<<dT0<<", dT2="<<dT2<<std::endl
+                           <<"Q_CMB="<<core_data.Q<<std::endl;
+          AssertThrow(false, ExcMessage("[Dynamic core] No inner core radius solution found!"));
+        }
+
+      return false;
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::get_Tc(double r) const
+    {
+      // Using all Q values from last step.
+      // Qs & Qr is constant, while Qg & Ql depends on inner core radius Ri
+      // TODO: Use mid-point value for Q values.
+      return core_data.Ti - ( (core_data.Q + core_data.Qr + core_data.Q_OES) * core_data.dt
+                              + (core_data.Qg + core_data.Ql)*(r-core_data.Ri)
+                            ) / core_data.Qs;
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::get_Ts(double r) const
+    {
+      return get_solidus(get_X(r),get_Pressure(r));
+    }
+
+
+    template <int dim>
+    double
+    DynamicCore<dim>::get_dT(double r) const
+    {
+      return get_T(get_Tc(r),r) - get_Ts(r);
+    }
+
+    template <int dim>
+    void
+    DynamicCore<dim>::update_core_data()
+    {
+      get_specific_heating(core_data.Ti,core_data.Qs,core_data.Es);
+      get_radio_heating(core_data.Ti,core_data.Qr,core_data.Er);
+      get_gravity_heating(core_data.Ti,core_data.Ri,core_data.Xi,core_data.Qg,core_data.Eg);
+      get_adiabatic_heating(core_data.Ti,core_data.Ek,core_data.Qk);
+      get_latent_heating(core_data.Ti,core_data.Ri,core_data.El,core_data.Ql);
+      get_heat_solution(core_data.Ti,core_data.Ri,core_data.Xi,core_data.Eh);
+    }
+
+    template <int dim>
+    const internal::CoreData &
+    DynamicCore<dim>::get_core_data() const
+    {
+      return core_data;
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::get_solidus(double X,double p) const
+    {
+      if (use_bw11)
+        {
+          // Change from weight percent to mole percent.
+          double x,x0=32./88.;
+          if (X<x0)
+            x=56.*X/(32.*(1.-X));
+          else
+            x=1.;
+          // Change from Pa to GPa
+          p*=1e-9;
+          // Fe-FeS system solidus by Buono & Walker (2011)
+          return (-2.4724*p*p*p*p + 28.025*p*p*p + 9.1404*p*p + 581.71*p + 3394.8) * x*x*x*x
+                 +( 1.7978*p*p*p*p - 6.7881*p*p*p - 197.69*p*p - 271.69*p - 8219.5) * x*x*x
+                 +(-0.1702*p*p*p*p - 9.3959*p*p*p + 163.53*p*p - 319.35*p + 5698.6) * x*x
+                 +(-0.2308*p*p*p*p + 7.1000*p*p*p - 64.118*p*p + 105.98*p - 1621.9) * x
+                 +( 0.2302*p*p*p*p - 5.3688*p*p*p + 38.124*p*p - 46.681*p + 1813.8);
+
+        }
+      else
+        {
+          if (composition_dependency)
+            return (Tm0*(1-Theta*X)*(1+Tm1*p+Tm2*pow(p,2)));
+          else
+            return (Tm0*(1-Theta)*(1+Tm1*p+Tm2*pow(p,2)));
+        }
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::get_X(double r) const
+    {
+      double xi_3=pow(r/Rc,3);
+      return X_init/(1-xi_3+Delta*xi_3);
+    }
+
+    template <int dim>
+    void
+    DynamicCore<dim>::update()
+    {
+      core_data.dt    = this->get_timestep();
+      core_data.H     = get_radioheating_rate();
+
+      // It's a bit tricky here.
+      // Didn't use the initialize() function instead because the postprocess is initialized after boundary temperature.
+      // It is not available at the time initialize() function of boundary temperature is called.
+      if (is_first_call==true)
+        {
+          AssertThrow(this->get_postprocess_manager().template has_matching_postprocessor<const Postprocess::CoreStatistics<dim>>(),
+                      ExcMessage ("Dynamic core boundary condition has to work with dynamic core statistics postprocessor."));
+
+          const Postprocess::CoreStatistics<dim> &core_statistics
+            = this->get_postprocess_manager().template get_matching_postprocessor<const Postprocess::CoreStatistics<dim>>();
+          // The restart data is stored in 'core statistics' postprocessor.
+          // If restart from checkpoint, extract data from there.
+          core_data = core_statistics.get_core_data();
+
+          // Read data of other energy source
+          read_data_OES();
+
+          const GeometryModel::SphericalShell<dim> &spherical_shell_geometry =
+            Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
+
+          Rc=spherical_shell_geometry.inner_radius();
+          Mc=get_Mass(Rc);
+          P_Core=get_Pressure(0);
+
+          // If the material model is incompressible, we have to get correction for the real core temperature
+          if (this->get_adiabatic_conditions().is_initialized() && !this->get_material_model().is_compressible())
+            {
+              Point<dim> p1;
+              p1(0) = spherical_shell_geometry.inner_radius();
+              dTa   = this->get_adiabatic_conditions().temperature(p1)
+                      - this->get_adiabatic_surface_temperature();
+            }
+          else
+            dTa   = 0.;
+
+          // Setup initial core data from prm input.
+          // If resumed from checkpoint, core_data is read from postprocess instead of set from prm file.
+          // (The boundary_temperature doesn't seem to support restart/resume, the data has to passed and
+          // stored in the postprocessor 'core statistics')
+          if (!core_data.is_initialized)
+            {
+              core_data.Ti=inner_temperature + dTa;
+              core_data.Ri = get_initial_Ri(core_data.Ti);
+              core_data.Xi = get_X(core_data.Ri);
+
+              core_data.Q=0.;
+              core_data.dt=0.;
+              core_data.dT_dt=init_dT_dt;
+              core_data.dR_dt=init_dR_dt;
+              core_data.dX_dt=init_dX_dt;
+              update_core_data();
+              core_data.is_initialized = true;
+              std::stringstream output;
+              output<<std::setiosflags(std::ios::left)
+                    <<"   Dynamic core initialized as:"<<std::endl
+                    <<"     "<<std::setw(15)<<"Tc(K)"<<std::setw(15)<<"Ri(km)"<<std::setw(15)<<"Xi"
+                    <<std::setw(15)<<"dT/dt(K/year)"<<std::setw(15)<<"dR/dt(km/year)"<<std::setw(15)<<"dX/dt(1/year)"<<std::endl
+                    <<"     "<<std::setprecision(6)<<std::setw(15)<<inner_temperature<<std::setw(15)<<core_data.Ri/1.e3<<std::setw(15)<<core_data.Xi
+                    <<std::setw(15)<<core_data.dT_dt *year_in_seconds<<std::setw(15)<<core_data.dR_dt/1.e3 *year_in_seconds
+                    <<std::setw(15)<<core_data.dX_dt *year_in_seconds<<std::endl;
+              this->get_pcout() << output.str();
+            }
+          is_first_call = false;
+        }
+
+      // Calculate core mantle boundary heat flow
+      {
+        const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.temperature;
+        FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                          this->get_fe(),
+                                          quadrature_formula,
+                                          update_gradients      | update_values |
+                                          update_normal_vectors |
+                                          update_quadrature_points       | update_JxW_values);
+
+        std::vector<Tensor<1,dim>> temperature_gradients (quadrature_formula.size());
+        std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+
+        //std::map<types::boundary_id, double> local_boundary_fluxes;
+        double local_CMB_flux   = 0.;
+        double local_CMB_area   = 0.;
+
+        types::boundary_id CMB_id = 0;
+
+        typename MaterialModel::Interface<dim>::MaterialModelInputs in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+        typename MaterialModel::Interface<dim>::MaterialModelOutputs out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+        // Do not request viscosity or reaction rates
+        in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties |
+                                  MaterialModel::MaterialProperties::thermal_conductivity;
+
+        // for every surface face on which it makes sense to compute a
+        // heat flux and that is owned by this processor,
+        // integrate the normal heat flux given by the formula
+        //   j =  - k * n . grad T
+        //
+        // for the spherical shell geometry, note that for the inner boundary,
+        // the normal vector points *into* the core, i.e. we compute the flux
+        // *out* of the mantle, not into it. we fix this when we add the local
+        // contribution to the global flux
+
+        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned())
+            for (const unsigned int f : cell->face_indices())
+              if (cell->at_boundary(f))
+                if (cell->face(f)->boundary_id() == CMB_id)
+                  {
+                    fe_face_values.reinit (cell, f);
+
+                    in.reinit(fe_face_values, cell, this->introspection(), this->get_solution());
+
+                    fe_face_values[this->introspection().extractors.temperature].get_function_gradients (this->get_solution(),
+                        temperature_gradients);
+
+                    this->get_material_model().evaluate(in, out);
+
+
+                    double local_normal_flux = 0;
+                    double local_face_area   = 0;
+                    for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                      {
+                        const double thermal_conductivity
+                          = out.thermal_conductivities[q];
+                        double adiabatic_flux=0.;
+                        if (this->get_material_model().is_compressible()==false)
+                          {
+                            const double alpha = out.thermal_expansion_coefficients[q];
+                            const double cp = out.specific_heat[0];
+                            const double gravity = this->get_gravity_model().gravity_vector(in.position[q]).norm();
+                            if (cell->face(f)->boundary_id()==0)
+                              adiabatic_flux = - alpha * gravity / cp;
+                            else if (cell->face(f)->boundary_id()==1)
+                              adiabatic_flux = alpha * gravity / cp;
+                          }
+
+                        local_normal_flux += -thermal_conductivity *
+                                             (temperature_gradients[q] * fe_face_values.normal_vector(q)
+                                              + adiabatic_flux) * fe_face_values.JxW(q);
+                        local_face_area   += fe_face_values.JxW(q);
+
+                      }
+                    local_CMB_flux += local_normal_flux;
+                    local_CMB_area += local_face_area;
+                  }
+        // now communicate to get the global values
+        double global_CMB_flux;
+        double global_CMB_area;
+        global_CMB_flux = Utilities::MPI::sum (local_CMB_flux, this->get_mpi_communicator());
+        global_CMB_area = Utilities::MPI::sum (local_CMB_area, this->get_mpi_communicator());
+
+        // Using area averaged heat-flux density times core mantle boundary area to calculate total heat-flux on the 3d sphere.
+        // By doing this, using dynamic core evolution with geometry other than 3d spherical shell becomes possible.
+        double average_CMB_heatflux_density = global_CMB_flux / global_CMB_area;
+        core_data.Q = average_CMB_heatflux_density * 4. * M_PI * Rc * Rc;
+      }
+
+      core_data.Q_OES = get_OES(this->get_time());
+
+      if ((core_data.Q + core_data.Q_OES) * core_data.dt!=0.)
+        {
+          double X1,R1=core_data.Ri,T1;
+          solve_time_step(X1,T1,R1);
+          if (core_data.dt!=0)
+            {
+              core_data.dR_dt=(R1-core_data.Ri)/core_data.dt;
+              core_data.dT_dt=(T1-core_data.Ti)/core_data.dt;
+              core_data.dX_dt=(X1-core_data.Xi)/core_data.dt;
+            }
+          else
+            {
+              core_data.dR_dt=0.;
+              core_data.dT_dt=0.;
+              core_data.dX_dt=0.;
+            }
+          core_data.Xi=X1;
+          core_data.Ri=R1;
+          core_data.Ti=T1;
+        }
+
+      inner_temperature = core_data.Ti - dTa;
+      update_core_data();
+      if ((core_data.Q + core_data.Q_OES + core_data.Qr) * core_data.dt!=0.)
+        {
+          std::stringstream output;
+          output<<std::setiosflags(std::ios::left)
+                <<"   Dynamic core data updated."<<std::endl
+                <<"     "<<std::setw(15)<<"Tc(K)"<<std::setw(15)<<"Ri(km)"<<std::setw(15)<<"Xi"
+                <<std::setw(15)<<"dT/dt(K/year)"<<std::setw(15)<<"dR/dt(km/year)"<<std::setw(15)<<"dX/dt(1/year)"<<std::endl
+                <<"     "<<std::setprecision(6)<<std::setw(15)<<inner_temperature<<std::setw(15)<<core_data.Ri/1.e3<<std::setw(15)<<core_data.Xi
+                <<std::setw(15)<<core_data.dT_dt *year_in_seconds<<std::setw(15)<<core_data.dR_dt/1.e3 *year_in_seconds
+                <<std::setw(15)<<core_data.dX_dt *year_in_seconds<<std::endl;
+          this->get_pcout() << output.str();
+        }
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    get_Mass(double r) const
+    {
+      return 4.*M_PI*Rho_cen*(-pow(L,2)/2.*r*exp(-pow(r/L,2))+pow(L,3)/4.*sqrt(M_PI)*erf(r/L));
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    fun_Sn(double B,double R,double n) const
+    {
+      double S=R/(2.*sqrt(M_PI));
+      for (unsigned i=1; i<=n; ++i)
+        S+=B/sqrt(M_PI)*exp(-pow(i,2)/4.)/i*sinh(i*R/B);
+      return S;
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    get_Pressure(double r) const
+    {
+      return P_CMB-(4*M_PI*constants::big_g*pow(Rho_cen,2))/3
+             *((3*pow(r,2)/10.-pow(L,2)/5)*exp(-pow(r/L,2))
+               -(3*pow(Rc,2)/10-pow(L,2)/5)*exp(-pow(Rc/L,2)));
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    get_Rho(double r) const
+    {
+      return Rho_cen*exp(-pow(r/L,2));
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    get_g(double r) const
+    {
+      return (4*M_PI/3)*constants::big_g*Rho_cen*r*(1-3*pow(r,2)/(5*pow(L,2)));
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    get_T(double Tc,double r) const
+    {
+      return Tc*exp((pow(Rc,2)-pow(r,2))/pow(D,2));
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    get_gravity_potential(double r) const
+    {
+      return 2./3.*M_PI*constants::big_g*Rho_cen*(pow(r,2)*(1.-3.*pow(r,2)
+                                                            /(10.*pow(L,2)))-pow(Rc,2)*(1.-3.*pow(Rc,2)/(10.*pow(L,2))));
+    }
+
+    template <int dim>
+    void
+    DynamicCore<dim>::
+    get_specific_heating(double Tc, double &Qs,double &Es)
+    {
+      double A=sqrt(1./(pow(L,-2)+pow(D,-2)));
+      double Is=4.*M_PI*get_T(Tc,0.)*Rho_cen*(-pow(A,2)*Rc/2.*exp(-pow(Rc/A,2))+pow(A,3)*sqrt(M_PI)/4.*erf(Rc/A));
+
+      Qs=-Cp/Tc*Is;
+      Es=Cp/Tc*(Mc-Is/Tc);
+    }
+
+    template <int dim>
+    void
+    DynamicCore<dim>::
+    get_radio_heating(double Tc, double &Qr, double &Er)
+    {
+      double B,It;
+      if (D>L)
+        {
+          B=sqrt(1/(1/pow(L,2)-1/pow(D,2)));
+          It=4*M_PI*Rho_cen/get_T(Tc,0)*(-pow(B,2)*Rc/2*exp(-pow(Rc/B,2))+pow(B,3)/sqrt(M_PI)/4*erf(Rc/B));
+        }
+      else
+        {
+          B=sqrt(1/(pow(D,-2)-pow(L,-2)));
+          It=4*M_PI*Rho_cen/get_T(Tc,0)*(pow(B,2)*Rc/2*exp(pow(Rc/B,2))-pow(B,2)*fun_Sn(B,Rc,100)/2);
+        }
+      Qr=Mc*core_data.H;
+      Er=(Mc/Tc-It)*core_data.H;
+
+    }
+
+    template <int dim>
+    void
+    DynamicCore<dim>::
+    get_heat_solution(double Tc, double r, double X,double &Eh)
+    {
+      double B,It;
+      if (D>L)
+        {
+          B=sqrt(1/(1/pow(L,2)-1/pow(D,2)));
+          It=4*M_PI*Rho_cen/get_T(Tc,0)*(-pow(B,2)*Rc/2*exp(-pow(Rc/B,2))+pow(B,3)/sqrt(M_PI)/4*erf(Rc/B));
+          It-=4*M_PI*Rho_cen/get_T(Tc,0)*(-pow(B,2)*r/2*exp(-pow(r/B,2))+pow(B,3)/sqrt(M_PI)/4*erf(r/B));
+        }
+      else
+        {
+          B=sqrt(1/(pow(D,-2)-pow(L,-2)));
+          It=4*M_PI*Rho_cen/get_T(Tc,0)*(pow(B,2)*Rc/2*exp(pow(Rc/B,2))-pow(B,2)*fun_Sn(B,Rc,100)/2);
+          It-=4*M_PI*Rho_cen/get_T(Tc,0)*(pow(B,2)*r/2*exp(pow(r/B,2))-pow(B,2)*fun_Sn(B,r,100)/2);
+        }
+      double Cc=4*M_PI*pow(r,2)*get_Rho(r)*X/(Mc-get_Mass(r));
+      Eh=Rh*(It-(Mc-get_Mass(r))/get_T(Tc,r))*Cc;
+    }
+
+    template <int dim>
+    void
+    DynamicCore<dim>::
+    get_gravity_heating(double Tc, double r,double X,double &Qg,double &Eg)
+    {
+      double Cc=4*M_PI*pow(r,2)*get_Rho(r)*X/(Mc-get_Mass(r));
+      double C_2=3./16.*pow(L,2)-0.5*pow(Rc,2)*(1.-3./10.*pow(Rc/L,2));
+      if (r==Rc)
+        Qg=0.;
+      else
+        Qg=(8./3.*pow(M_PI*Rho_cen,2)*constants::big_g*(
+              ((3./20.*pow(Rc,5)-pow(L,2)*pow(Rc,3)/8.-C_2*pow(L,2)*Rc)*exp(-pow(Rc/L,2))
+               +C_2/2.*pow(L,3)*sqrt(M_PI)*erf(Rc/L))
+              -((3./20.*pow(r,5)-pow(L,2)*pow(r,3)/8.-C_2*pow(L,2)*r)*exp(-pow(r/L,2))
+                +C_2/2.*pow(L,3)*sqrt(M_PI)*erf(r/L)))
+            -(Mc-get_Mass(r))*get_gravity_potential(r))*Beta_c*Cc;
+      Eg=Qg/Tc;
+
+    }
+
+    template <int dim>
+    void
+    DynamicCore<dim>::
+    get_adiabatic_heating(double Tc, double &Ek, double &Qk)
+    {
+      Ek=16*M_PI*k_c*pow(Rc,5)/5/pow(D,4);
+      Qk=8*M_PI*pow(Rc,3)*k_c*Tc/pow(D,2);
+    }
+    template <int dim>
+    void
+    DynamicCore<dim>::
+    get_latent_heating(double Tc, double r, double &El, double &Ql)
+    {
+      Ql=4.*M_PI*pow(r,2)*Lh*get_Rho(r);
+      El=Ql*(get_T(Tc,r)-Tc)/(Tc*get_T(Tc,r));
+    }
+
+    template <int dim>
+    double
+    DynamicCore<dim>::
+    get_radioheating_rate() const
+    {
+      double time=this->get_time()+0.5*this->get_timestep();
+      double Ht=0;
+      for (unsigned i=0; i<n_radioheating_elements; ++i)
+        Ht+=heating_rate[i]*initial_concentration[i]*1e-6*pow(0.5,time/half_life[i]/year_in_seconds/1e9);
+      return Ht;
+    }
+
+    template <int dim>
+    bool
+    DynamicCore<dim>::
+    is_OES_used() const
+    {
+      if (data_OES.size()>0)
+        return true;
+      else
+        return false;
+    }
+  }
+
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(DynamicCore,
+                                               "dynamic core",
+                                               "This is a boundary temperature model working only with spherical "
+                                               "shell geometry and core statistics postprocessor. The temperature "
+                                               "at the top is constant, and the core mantle boundary temperature "
+                                               "is dynamically evolving through time by calculating the heat flux "
+                                               "into the core and solving the core energy balance. The formulation "
+                                               "is mainly following \\cite{NPB+04}, and the plugin is used in "
+                                               "Zhang et al. [2016]. The energy of core cooling and freeing of the "
+                                               "inner core is included in the plugin. However, current plugin can not "
+                                               "deal with the energy balance if the core is in the `snowing core' regime "
+                                               "(i.e., the core solidifies from the top instead of bottom)."
+                                              )
+  }
+}
diff --git a/source/boundary_temperature/function.cc.bak b/source/boundary_temperature/function.cc.bak
new file mode 100644
index 00000000000..886715dcb0e
--- /dev/null
+++ b/source/boundary_temperature/function.cc.bak
@@ -0,0 +1,186 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/function.h>
+#include <aspect/utilities.h>
+#include <aspect/global.h>
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    template <int dim>
+    Function<dim>::Function ()
+      :
+      boundary_temperature_function (1)
+    {}
+
+
+
+    template <int dim>
+    double
+    Function<dim>::
+    boundary_temperature (const types::boundary_id /*boundary_indicator*/,
+                          const Point<dim> &position) const
+    {
+      const Utilities::NaturalCoordinate<dim> point =
+        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
+      return boundary_temperature_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::update()
+    {
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        boundary_temperature_function.set_time (this->get_time() / year_in_seconds);
+      else
+        boundary_temperature_function.set_time (this->get_time());
+    }
+
+
+
+    template <int dim>
+    double
+    Function<dim>::
+    minimal_temperature (const std::set<types::boundary_id> &) const
+    {
+      return min_temperature;
+    }
+
+
+
+    template <int dim>
+    double
+    Function<dim>::
+    maximal_temperature (const std::set<types::boundary_id> &) const
+    {
+      return max_temperature;
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Function");
+        {
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle. `depth' "
+                             "will create a function, in which only the first "
+                             "parameter is non-zero, which is interpreted to "
+                             "be the depth of the point.");
+
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+
+          prm.declare_entry ("Minimal temperature", "273.",
+                             Patterns::Double (),
+                             "Minimal temperature. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Maximal temperature", "3773.",
+                             Patterns::Double (),
+                             "Maximal temperature. Units: \\si{\\kelvin}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Function");
+        {
+          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+
+          try
+            {
+              boundary_temperature_function.parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Boundary temperature model.Function'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+          min_temperature = prm.get_double ("Minimal temperature");
+          max_temperature = prm.get_double ("Maximal temperature");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Function,
+                                               "function",
+                                               "Implementation of a model in which the boundary "
+                                               "temperature is given in terms of an explicit formula "
+                                               "that is elaborated in the parameters in section "
+                                               "``Boundary temperature model|Function''. "
+                                               "\n\n"
+                                               "Since the symbol $t$ indicating time "
+                                               "may appear in the formulas for the prescribed "
+                                               "temperatures, it is interpreted as having units "
+                                               "seconds unless the global input parameter ``Use "
+                                               "years in output instead of seconds'' is set, in "
+                                               "which case we interpret the formula expressions "
+                                               "as having units year."
+                                               "\n\n"
+                                               "Because this class simply takes what the "
+                                               "function calculates, this class can not "
+                                               "know certain pieces of information such as the "
+                                               "minimal and maximal temperature on the boundary. "
+                                               "For operations that require this, for example in "
+                                               "post-processing, this boundary temperature model "
+                                               "must therefore be told what the minimal and "
+                                               "maximal values on the boundary are. This is done "
+                                               "using parameters set in section ``Boundary temperature model/Initial temperature''."
+                                               "\n\n"
+                                               "The format of these "
+                                               "functions follows the syntax understood by the "
+                                               "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+  }
+}
diff --git a/source/boundary_temperature/initial_temperature.cc.bak b/source/boundary_temperature/initial_temperature.cc.bak
new file mode 100644
index 00000000000..87fb480f1ca
--- /dev/null
+++ b/source/boundary_temperature/initial_temperature.cc.bak
@@ -0,0 +1,134 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/initial_temperature.h>
+#include <aspect/initial_temperature/interface.h>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+// ------------------------------ InitialTemperature -------------------
+
+    template <int dim>
+    void
+    InitialTemperature<dim>::initialize()
+    {
+      // Make sure we keep track of the initial temperature manager and
+      // that it continues to live beyond the time when the simulator
+      // class releases its pointer to it.
+      initial_temperature = this->get_initial_temperature_manager_pointer();
+    }
+
+
+
+    template <int dim>
+    double
+    InitialTemperature<dim>::
+    boundary_temperature (const types::boundary_id,
+                          const Point<dim> &position) const
+    {
+      return initial_temperature->initial_temperature(position);
+    }
+
+
+    template <int dim>
+    double
+    InitialTemperature<dim>::
+    minimal_temperature (const std::set<types::boundary_id> &) const
+    {
+      return min_temperature;
+    }
+
+
+
+    template <int dim>
+    double
+    InitialTemperature<dim>::
+    maximal_temperature (const std::set<types::boundary_id> &) const
+    {
+      return max_temperature;
+    }
+
+
+
+    template <int dim>
+    void
+    InitialTemperature<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Initial temperature");
+        {
+          prm.declare_entry ("Minimal temperature", "0.",
+                             Patterns::Double (),
+                             "Minimal temperature. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Maximal temperature", "3773.",
+                             Patterns::Double (),
+                             "Maximal temperature. Units: \\si{\\kelvin}.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    InitialTemperature<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Initial temperature");
+        {
+          min_temperature = prm.get_double ("Minimal temperature");
+          max_temperature = prm.get_double ("Maximal temperature");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(InitialTemperature,
+                                               "initial temperature",
+                                               "A model in which the temperature at the boundary "
+                                               "is chosen to be the same as given in the initial "
+                                               "conditions."
+                                               "\n\n"
+                                               "Because this class simply takes what the initial "
+                                               "temperature had described, this class can not "
+                                               "know certain pieces of information such as the "
+                                               "minimal and maximal temperature on the boundary. "
+                                               "For operations that require this, for example in "
+                                               "post-processing, this boundary temperature model "
+                                               "must therefore be told what the minimal and "
+                                               "maximal values on the boundary are. This is done "
+                                               "using parameters set in section ``Boundary temperature model/Initial temperature''.")
+  }
+}
diff --git a/source/boundary_temperature/interface.cc.bak b/source/boundary_temperature/interface.cc.bak
new file mode 100644
index 00000000000..f42bf0826c3
--- /dev/null
+++ b/source/boundary_temperature/interface.cc.bak
@@ -0,0 +1,390 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <aspect/utilities.h>
+
+#include <deal.II/base/exceptions.h>
+#include <deal.II/base/signaling_nan.h>
+
+#include <list>
+#include <tuple>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    // ------------------------------ Manager -----------------------------
+    // -------------------------------- Deal with registering boundary_temperature models and automating
+    // -------------------------------- their setup and selection at run time
+
+    template <int dim>
+    Manager<dim>::~Manager()
+      = default;
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::update ()
+    {
+      for (auto &p : this->plugin_objects)
+        p->update();
+    }
+
+
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_boundary_temperature (const std::string &name,
+                                                 const std::string &description,
+                                                 void (*declare_parameters_function) (ParameterHandler &),
+                                                 std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // find out which plugins are requested and the various other
+      // parameters we declare here
+      prm.enter_subsection ("Boundary temperature model");
+      {
+        model_names
+          = Utilities::split_string_list(prm.get("List of model names"));
+
+        AssertThrow(Utilities::has_unique_entries(model_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Boundary temperature model/List of model names' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+
+        const std::string model_name = prm.get ("Model name");
+
+        AssertThrow (model_name == "unspecified" || model_names.size() == 0,
+                     ExcMessage ("The parameter 'Model name' is only used for reasons"
+                                 "of backwards compatibility and can not be used together with "
+                                 "the new functionality 'List of model names'. Please add your "
+                                 "boundary temperature model to the list instead."));
+
+        if (!(model_name == "unspecified"))
+          model_names.push_back(model_name);
+
+        // create operator list
+        std::vector<std::string> model_operator_names =
+          Utilities::possibly_extend_from_1_to_N (Utilities::split_string_list(prm.get("List of model operators")),
+                                                  model_names.size(),
+                                                  "List of model operators");
+        model_operators = Utilities::create_model_operator_list(model_operator_names);
+
+        try
+          {
+            const std::vector<types::boundary_id> x_fixed_temperature_boundary_indicators
+              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
+                                                                                    (prm.get ("Fixed temperature boundary indicators")));
+            fixed_temperature_boundary_indicators
+              = std::set<types::boundary_id> (x_fixed_temperature_boundary_indicators.begin(),
+                                              x_fixed_temperature_boundary_indicators.end());
+
+            // If no fixed temperature boundary indicators have been set, there should be no model_names chosen either.
+            // If that is indeed the case, clear the model_operators vector. Otherwise, raise an exception.
+            if (fixed_temperature_boundary_indicators.size() == 0)
+              {
+                AssertThrow(model_names.size() == 0,
+                            ExcMessage ("You have indicated that you wish to apply a boundary temperature "
+                                        "model, but the <Fixed temperature boundary indicators> parameter "
+                                        "is empty. Please use this parameter to specify the boundaries "
+                                        "on which the model(s) should be applied."));
+
+                model_operators.clear();
+              }
+          }
+        catch (const std::string &error)
+          {
+            AssertThrow (false, ExcMessage ("While parsing the entry <Model settings/Fixed temperature "
+                                            "boundary indicators>, there was an error. Specifically, "
+                                            "the conversion function complained as follows:\n\n"
+                                            + error));
+          }
+
+        allow_fixed_temperature_on_outflow_boundaries = prm.get_bool ("Allow fixed temperature on outflow boundaries");
+      }
+      prm.leave_subsection ();
+
+      // go through the list, create objects and let them parse
+      // their own parameters
+      for (auto &model_name : model_names)
+        {
+          // create boundary temperature objects
+          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
+                                          (std::get<dim>(registered_plugins)
+                                           .create_plugin (model_name,
+                                                           "Boundary temperature::Model names")));
+
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(this->plugin_objects.back().get()))
+            sim->initialize_simulator (this->get_simulator());
+
+          this->plugin_objects.back()->parse_parameters (prm);
+          this->plugin_objects.back()->initialize ();
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    Manager<dim>::boundary_temperature (const types::boundary_id boundary_indicator,
+                                        const Point<dim> &position) const
+    {
+      double temperature = 0.0;
+
+      auto p = this->plugin_objects.begin();
+      for (unsigned int i=0; i<this->plugin_objects.size(); ++p, ++i)
+        temperature = model_operators[i](temperature,
+                                         (*p)->boundary_temperature(boundary_indicator,
+                                                                    position));
+
+      return temperature;
+    }
+
+
+
+    template <int dim>
+    double
+    Manager<dim>::minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
+    {
+      double temperature = std::numeric_limits<double>::max();
+
+      for (const auto &p : this->plugin_objects)
+        temperature = std::min(temperature,
+                               p->minimal_temperature(fixed_boundary_ids));
+
+      return temperature;
+    }
+
+
+
+    template <int dim>
+    double
+    Manager<dim>::maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
+    {
+      double temperature = 0.0;
+
+      for (const auto &p : this->plugin_objects)
+        temperature = std::max(temperature,
+                               p->maximal_temperature(fixed_boundary_ids));
+
+      return temperature;
+    }
+
+
+
+    template <int dim>
+    const std::vector<std::string> &
+    Manager<dim>::get_active_boundary_temperature_names () const
+    {
+      return model_names;
+    }
+
+
+    template <int dim>
+    const std::list<std::unique_ptr<Interface<dim>>> &
+    Manager<dim>::get_active_boundary_temperature_conditions () const
+    {
+      return this->plugin_objects;
+    }
+
+
+
+    template <int dim>
+    const std::set<types::boundary_id> &
+    Manager<dim>::get_fixed_temperature_boundary_indicators() const
+    {
+      return fixed_temperature_boundary_indicators;
+    }
+
+
+
+    template <int dim>
+    bool
+    Manager<dim>::allows_fixed_temperature_on_outflow_boundaries() const
+    {
+      return allow_fixed_temperature_on_outflow_boundaries;
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // declare the entry in the parameter file
+      prm.enter_subsection ("Boundary temperature model");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry("List of model names",
+                          "",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma-separated list of boundary temperature models that "
+                          "will be used to initialize the temperature. "
+                          "These plugins are loaded in the order given, and modify the "
+                          "existing temperature field via the operators listed "
+                          "in 'List of model operators'.\n\n"
+                          "The following boundary temperature models are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+
+        prm.declare_entry("List of model operators", "add",
+                          Patterns::MultipleSelection(Utilities::get_model_operator_options()),
+                          "A comma-separated list of operators that "
+                          "will be used to append the listed temperature models onto "
+                          "the previous models. If only one operator is given, "
+                          "the same operator is applied to all models.");
+
+        prm.declare_entry ("Model name", "unspecified",
+                           Patterns::Selection (pattern_of_names+"|unspecified"),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string()
+                           + "\n\n" +
+                           "\\textbf{Warning}: This parameter provides an old and "
+                           "deprecated way of specifying "
+                           "boundary temperature models and shouldn't be used. "
+                           "Please use 'List of model names' instead.");
+
+        prm.declare_entry ("Fixed temperature boundary indicators", "",
+                           Patterns::List (Patterns::Anything()),
+                           "A comma separated list of names denoting those boundaries "
+                           "on which the temperature is fixed and described by the "
+                           "boundary temperature object selected in the 'List of model names' "
+                           "parameter. All boundary indicators used by the geometry "
+                           "but not explicitly listed here will end up with no-flux "
+                           "(insulating) boundary conditions, or, if they are listed in the "
+                           "'Fixed heat flux boundary indicators', with Neumann boundary "
+                           "conditions."
+                           "\n\n"
+                           "The names of the boundaries listed here can either be "
+                           "numbers (in which case they correspond to the numerical "
+                           "boundary indicators assigned by the geometry object), or they "
+                           "can correspond to any of the symbolic names the geometry object "
+                           "may have provided for each part of the boundary. You may want "
+                           "to compare this with the documentation of the geometry model you "
+                           "use in your model."
+                           "\n\n"
+                           "This parameter only describes which boundaries have a fixed "
+                           "temperature, but not what temperature should hold on these "
+                           "boundaries. The latter piece of information needs to be "
+                           "implemented in a plugin in the BoundaryTemperature "
+                           "group, unless an existing implementation in this group "
+                           "already provides what you want.");
+        prm.declare_entry ("Allow fixed temperature on outflow boundaries", "true",
+                           Patterns::Bool (),
+                           "When the temperature is fixed on a given boundary as determined "
+                           "by the list of 'Fixed temperature boundary indicators', there "
+                           "might be parts of the boundary where material flows out and "
+                           "one may want to prescribe the temperature only on the parts of "
+                           "the boundary where there is inflow. This parameter determines "
+                           "if temperatures are only prescribed at these inflow parts of the "
+                           "boundary (if false) or everywhere on a given boundary, independent "
+                           "of the flow direction (if true)."
+                           "Note that in this context, `fixed' refers to the fact that these "
+                           "are the boundary indicators where Dirichlet boundary conditions are "
+                           "applied, and does not imply that the boundary temperature is "
+                           "time-independent. "
+                           "\n\n"
+                           "Mathematically speaking, the temperature satisfies an "
+                           "advection-diffusion equation. For this type of equation, one can "
+                           "prescribe the temperature even on outflow boundaries as long as the "
+                           "diffusion coefficient is nonzero. This would correspond to the "
+                           "``true'' setting of this parameter, which is correspondingly the "
+                           "default. In practice, however, this would only make physical sense "
+                           "if the diffusion coefficient is actually quite large to prevent "
+                           "the creation of a boundary layer. "
+                           "In addition, if there is no diffusion, one can only impose "
+                           "Dirichlet boundary conditions (i.e., prescribe a fixed temperature "
+                           "value at the boundary) at those boundaries where material flows in. "
+                           "This would correspond to the ``false'' setting of this parameter.");
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary temperature interface",
+                                                            out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryTemperature::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryTemperature::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryTemperature::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryTemperature::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace BoundaryTemperature
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/boundary_temperature/spherical_constant.cc.bak b/source/boundary_temperature/spherical_constant.cc.bak
new file mode 100644
index 00000000000..782788c322d
--- /dev/null
+++ b/source/boundary_temperature/spherical_constant.cc.bak
@@ -0,0 +1,149 @@
+/*
+  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <deal.II/base/signaling_nan.h>
+#include <aspect/boundary_temperature/spherical_constant.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    template <int dim>
+    void
+    SphericalConstant<dim>::
+    initialize ()
+    {
+      // verify that the geometry is supported by this plugin
+      AssertThrow ( Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) ||
+                    Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()) ||
+                    Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()) ||
+                    Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()),
+                    ExcMessage ("This boundary model is only implemented if the geometry is "
+                                "one of the spherical geometries."));
+
+      // no inner boundary in a full sphere
+      if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()))
+        inner_boundary_indicator = numbers::invalid_unsigned_int;
+      else
+        inner_boundary_indicator = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
+
+      outer_boundary_indicator = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+    }
+
+
+
+    template <int dim>
+    double
+    SphericalConstant<dim>::
+    boundary_temperature (const types::boundary_id boundary_indicator,
+                          const Point<dim> &) const
+    {
+      if (boundary_indicator == outer_boundary_indicator)
+        return outer_temperature;
+      else if (boundary_indicator == inner_boundary_indicator)
+        return inner_temperature;
+      else
+        AssertThrow (false,
+                     ExcMessage ("Unknown boundary indicator for geometry model. "
+                                 "The given boundary should be ``top'' or ``bottom''."));
+
+      return numbers::signaling_nan<double>();
+    }
+
+
+
+    template <int dim>
+    double
+    SphericalConstant<dim>::
+    minimal_temperature (const std::set<types::boundary_id> &) const
+    {
+      return std::min (inner_temperature, outer_temperature);
+    }
+
+
+
+    template <int dim>
+    double
+    SphericalConstant<dim>::
+    maximal_temperature (const std::set<types::boundary_id> &) const
+    {
+      return std::max (inner_temperature, outer_temperature);
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalConstant<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Spherical constant");
+        {
+          prm.declare_entry ("Outer temperature", "0.",
+                             Patterns::Double (),
+                             "Temperature at the outer boundary (lithosphere water/air). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Inner temperature", "6000.",
+                             Patterns::Double (),
+                             "Temperature at the inner boundary (core mantle boundary). Units: \\si{\\kelvin}.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalConstant<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Spherical constant");
+        {
+          inner_temperature = prm.get_double ("Inner temperature");
+          outer_temperature = prm.get_double ("Outer temperature");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(SphericalConstant,
+                                               "spherical constant",
+                                               "A model in which the temperature is chosen constant on "
+                                               "the inner and outer boundaries of a spherical shell, ellipsoidal "
+                                               "chunk or chunk. "
+                                               "Parameters are read from subsection 'Spherical constant'.")
+  }
+}
diff --git a/source/boundary_temperature/two_merged_boxes.cc.bak b/source/boundary_temperature/two_merged_boxes.cc.bak
new file mode 100644
index 00000000000..8167dc0b253
--- /dev/null
+++ b/source/boundary_temperature/two_merged_boxes.cc.bak
@@ -0,0 +1,191 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/two_merged_boxes.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+
+    template <int dim>
+    double
+    TwoMergedBoxes<dim>::
+    boundary_temperature (const types::boundary_id boundary_indicator,
+                          const Point<dim> &) const
+    {
+      Assert (boundary_indicator<2*dim+2*(dim-1), ExcMessage ("Given boundary indicator needs to be less than 2*dimension+2*(dimension-1)."));
+
+      return temperature_values[boundary_indicator];
+    }
+
+
+    template <int dim>
+    double
+    TwoMergedBoxes<dim>::
+    minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
+    {
+      if (fixed_boundary_ids.empty())
+        return *std::min_element(temperature_values, temperature_values+2*dim+2*(dim-1));
+      else
+        {
+          double min = maximal_temperature(fixed_boundary_ids);
+          for (const auto p : fixed_boundary_ids)
+            min = std::min(min,temperature_values[p]);
+          return min;
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedBoxes<dim>::
+    maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
+    {
+      if (fixed_boundary_ids.empty())
+        return *std::max_element(temperature_values, temperature_values+2*dim+2*(dim-1));
+      else
+        {
+          double max = std::numeric_limits<double>::lowest();
+          for (const auto p : fixed_boundary_ids)
+            max = std::max(max,temperature_values[p]);
+          return max;
+        }
+    }
+
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Box with lithosphere boundary indicators");
+        {
+          prm.declare_entry ("Left temperature", "1.",
+                             Patterns::Double (),
+                             "Temperature at the left boundary (at minimal $x$-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Right temperature", "0.",
+                             Patterns::Double (),
+                             "Temperature at the right boundary (at maximal $x$-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Bottom temperature", "0.",
+                             Patterns::Double (),
+                             "Temperature at the bottom boundary (at minimal $z$-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Top temperature", "0.",
+                             Patterns::Double (),
+                             "Temperature at the top boundary (at maximal $x$-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Left temperature lithosphere", "0.",
+                             Patterns::Double (),
+                             "Temperature at the additional left lithosphere boundary (specified by user in Geometry Model). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Right temperature lithosphere", "0.",
+                             Patterns::Double (),
+                             "Temperature at the additional right lithosphere boundary (specified by user in Geometry Model). Units: \\si{\\kelvin}.");
+          if (dim==3)
+            {
+              prm.declare_entry ("Front temperature", "0.",
+                                 Patterns::Double (),
+                                 "Temperature at the front boundary (at minimal $y$-value). Units: \\si{\\kelvin}.");
+              prm.declare_entry ("Back temperature", "0.",
+                                 Patterns::Double (),
+                                 "Temperature at the back boundary (at maximal $y$-value). Units: \\si{\\kelvin}.");
+              prm.declare_entry ("Front temperature lithosphere", "0.",
+                                 Patterns::Double (),
+                                 "Temperature at the additional front lithosphere boundary (at minimal $y$-value). Units: \\si{\\kelvin}.");
+              prm.declare_entry ("Back temperature lithosphere", "0.",
+                                 Patterns::Double (),
+                                 "Temperature at the additional back lithosphere boundary (at maximal $y$-value). Units: \\si{\\kelvin}.");
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Box with lithosphere boundary indicators");
+        {
+          // verify that the geometry is a box since only for this geometry
+          // do we know for sure what boundary indicators it uses and what they mean
+          AssertThrow (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
+                       ExcMessage ("This boundary model is only useful if the geometry is "
+                                   "a box with additional boundary indicators."));
+
+          switch (dim)
+            {
+              case 2:
+                temperature_values[0] = prm.get_double ("Left temperature");
+                temperature_values[1] = prm.get_double ("Right temperature");
+                temperature_values[2] = prm.get_double ("Bottom temperature");
+                temperature_values[3] = prm.get_double ("Top temperature");
+                temperature_values[4] = prm.get_double ("Left temperature lithosphere");
+                temperature_values[5] = prm.get_double ("Right temperature lithosphere");
+                break;
+
+              case 3:
+                temperature_values[0] = prm.get_double ("Left temperature");
+                temperature_values[1] = prm.get_double ("Right temperature");
+                temperature_values[2] = prm.get_double ("Front temperature");
+                temperature_values[3] = prm.get_double ("Back temperature");
+                temperature_values[4] = prm.get_double ("Bottom temperature");
+                temperature_values[5] = prm.get_double ("Top temperature");
+                temperature_values[6] = prm.get_double ("Left temperature lithosphere");
+                temperature_values[7] = prm.get_double ("Right temperature lithosphere");
+                temperature_values[8] = prm.get_double ("Front temperature lithosphere");
+                temperature_values[9] = prm.get_double ("Back temperature lithosphere");
+                break;
+
+              default:
+                Assert (false, ExcNotImplemented());
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(TwoMergedBoxes,
+                                               "box with lithosphere boundary indicators",
+                                               "A model in which the temperature is chosen constant on "
+                                               "all the sides of a box. Additional boundary indicators "
+                                               "are added to the lithospheric parts of the vertical boundaries. "
+                                               "This model is to be used with the 'Two Merged Boxes' Geometry Model.")
+  }
+}
diff --git a/source/boundary_traction/ascii_data.cc.bak b/source/boundary_traction/ascii_data.cc.bak
new file mode 100644
index 00000000000..60c293d13f7
--- /dev/null
+++ b/source/boundary_traction/ascii_data.cc.bak
@@ -0,0 +1,140 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_traction/ascii_data.h>
+#include <aspect/global.h>
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      for (const auto &bv : this->get_boundary_traction_manager().get_active_boundary_traction_conditions())
+        {
+          for (const auto &plugin : bv.second)
+            if (plugin.get() == this)
+              boundary_ids.insert(bv.first);
+        }
+      AssertThrow(*(boundary_ids.begin()) != numbers::invalid_boundary_id,
+                  ExcMessage("Did not find the boundary indicator for the traction ascii data plugin."));
+
+      Utilities::AsciiDataBoundary<dim>::initialize(boundary_ids,
+                                                    1);
+    }
+
+
+    template <int dim>
+    Tensor<1,dim>
+    AsciiData<dim>::
+    boundary_traction (const types::boundary_id boundary_indicator,
+                       const Point<dim> &position,
+                       const Tensor<1,dim> &normal_vector) const
+    {
+      const double pressure = Utilities::AsciiDataBoundary<dim>::get_data_component(boundary_indicator,
+                                                                                    position,
+                                                                                    0);
+      return -pressure * normal_vector;
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::update()
+    {
+      Interface<dim>::update ();
+      Utilities::AsciiDataBoundary<dim>::update();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary traction model");
+      {
+        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
+                                                              "$ASPECT_SOURCE_DIR/data/boundary-traction/ascii-data/test/",
+                                                              "box_2d_%s.%d.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary traction model");
+      {
+        Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(AsciiData,
+                                            "ascii data",
+                                            "Implementation of a model in which the boundary "
+                                            "traction is derived from files containing pressure data "
+                                            "in ascii format. The pressure given in the data file is "
+                                            "applied as traction normal to the surface of a given boundary, "
+                                            "pointing inwards. Note the required format of the "
+                                            "input data: The first lines may contain any number of comments "
+                                            "if they begin with `#', but one of these lines needs to "
+                                            "contain the number of grid points in each dimension as "
+                                            "for example `# POINTS: 3 3'. "
+                                            "The order of the data columns "
+                                            "has to be `x', `Pressure [Pa]' in a 2d model and "
+                                            " `x', `y', `Pressure [Pa]' in a 3d model, which means that "
+                                            "there has to be a single column "
+                                            "containing the pressure. "
+                                            "Note that the data in the input "
+                                            "files need to be sorted in a specific order: "
+                                            "the first coordinate needs to ascend first, "
+                                            "followed by the second in order to "
+                                            "assign the correct data to the prescribed coordinates. "
+                                            "If you use a spherical model, "
+                                            "then the data will still be handled as Cartesian, "
+                                            "however the assumed grid changes. `x' will be replaced by "
+                                            "the radial distance of the point to the bottom of the model, "
+                                            "`y' by the azimuth angle and `z' by the polar angle measured "
+                                            "positive from the north pole. The grid will be assumed to be "
+                                            "a latitude-longitude grid. Note that the order "
+                                            "of spherical coordinates is `r', `phi', `theta' "
+                                            "and not `r', `theta', `phi', since this allows "
+                                            "for dimension independent expressions.")
+  }
+}
diff --git a/source/boundary_traction/function.cc.bak b/source/boundary_traction/function.cc.bak
new file mode 100644
index 00000000000..82c3ab75e77
--- /dev/null
+++ b/source/boundary_traction/function.cc.bak
@@ -0,0 +1,158 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_traction/function.h>
+#include <aspect/utilities.h>
+#include <aspect/global.h>
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    template <int dim>
+    Function<dim>::Function ()
+      :
+      boundary_traction_function (dim)
+    {}
+
+
+
+    template <int dim>
+    Tensor<1,dim>
+    Function<dim>::
+    boundary_traction (const types::boundary_id,
+                       const Point<dim> &position,
+                       const Tensor<1,dim> &) const
+    {
+      Tensor<1,dim> traction;
+      Utilities::NaturalCoordinate<dim> point =
+        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
+      for (unsigned int d=0; d<dim; ++d)
+        traction[d] = boundary_traction_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()),d);
+      if (use_spherical_unit_vectors)
+        traction = Utilities::Coordinates::spherical_to_cartesian_vector(traction, position);
+
+      return traction;
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::update()
+    {
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        boundary_traction_function.set_time (this->get_time() / year_in_seconds);
+      else
+        boundary_traction_function.set_time (this->get_time());
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary traction model");
+      {
+        prm.enter_subsection("Function");
+        {
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle. `depth' "
+                             "will create a function, in which only the first "
+                             "parameter is non-zero, which is interpreted to "
+                             "be the depth of the point.");
+          prm.declare_entry ("Use spherical unit vectors", "false",
+                             Patterns::Bool (),
+                             "Specify traction as $r$, $\\phi$, and $\\theta$ components "
+                             "instead of $x$, $y$, and $z$. Positive tractions point up, east, "
+                             "and north (in 3d) or out and clockwise (in 2d). "
+                             "This setting only makes sense for spherical geometries.");
+
+          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary traction model");
+      {
+        prm.enter_subsection("Function");
+        {
+          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+          use_spherical_unit_vectors = prm.get_bool("Use spherical unit vectors");
+          if (use_spherical_unit_vectors)
+            AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
+                         ExcMessage ("Spherical unit vectors should not be used "
+                                     "when geometry model is not spherical."));
+        }
+        try
+          {
+            boundary_traction_function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Boundary traction model.Function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(Function,
+                                            "function",
+                                            "Implementation of a model in which the boundary "
+                                            "traction is given in terms of an explicit formula "
+                                            "that is elaborated in the parameters in section "
+                                            "``Boundary traction model|Function''. "
+                                            "\n\n"
+                                            "The formula you describe in the mentioned "
+                                            "section is a semicolon separated list of traction components "
+                                            "for each of the $d$ components of the traction vector. "
+                                            "These $d$ formulas are interpreted as having units "
+                                            "Pa.")
+  }
+}
diff --git a/source/boundary_traction/initial_lithostatic_pressure.cc.bak b/source/boundary_traction/initial_lithostatic_pressure.cc.bak
new file mode 100644
index 00000000000..985ca78071e
--- /dev/null
+++ b/source/boundary_traction/initial_lithostatic_pressure.cc.bak
@@ -0,0 +1,442 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_traction/initial_lithostatic_pressure.h>
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/initial_composition/interface.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <array>
+
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/two_merged_chunks.h>
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+
+    template <int dim>
+    void
+    InitialLithostaticPressure<dim>::initialize()
+    {
+      // Ensure the initial lithostatic pressure traction boundary conditions are used,
+      // and register for which boundary indicators these conditions are set.
+      std::set<types::boundary_id> traction_bi;
+      for (const auto &p : this->get_boundary_traction_manager().get_active_boundary_traction_conditions())
+        {
+          for (const auto &plugin : p.second)
+            if (plugin.get() == this)
+              traction_bi.insert(p.first);
+        }
+      AssertThrow(*(traction_bi.begin()) != numbers::invalid_boundary_id,
+                  ExcMessage("Did not find any boundary indicators for the initial lithostatic pressure plugin."));
+
+      // Determine whether traction boundary conditions are only set on the bottom
+      // boundary and initial topography is applied.
+      bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
+      if (!Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()) &&
+          traction_bi.size() == 1 &&
+          *traction_bi.begin() == bottom_boundary_id)
+        prescribe_constant_pressure_at_bottom_boundary = true;
+      else
+        prescribe_constant_pressure_at_bottom_boundary = false;
+
+      // The below is adapted from adiabatic_conditions/initial_profile.cc,
+      // but we use the initial temperature and composition and only calculate
+      // a pressure profile with depth.
+
+      // The number of compositional fields
+      const unsigned int n_compositional_fields = this->n_compositional_fields();
+
+      // The pressure at the surface
+      pressure[0]    = this->get_surface_pressure();
+
+      // For spherical(-like) domains, modify the representative point:
+      // go from degrees to radians...
+      std::array<double, dim> spherical_representative_point;
+      for (unsigned int d=0; d<dim; ++d)
+        spherical_representative_point[d] = representative_point[d];
+      spherical_representative_point[1] *= constants::degree_to_radians;
+      // and go from latitude to colatitude.
+      if (dim == 3)
+        {
+          spherical_representative_point[2] = 90.0 - spherical_representative_point[2];
+          spherical_representative_point[2] *= constants::degree_to_radians;
+        }
+
+      // Check that the representative point lies in the domain.
+      AssertThrow(((this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian) ?
+                   (this->get_geometry_model().point_is_in_domain(representative_point)) :
+                   (this->get_geometry_model().point_is_in_domain(Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_representative_point)))),
+                  ExcMessage("The reference point does not lie with the domain."));
+
+      // Set the radius of the representative point to the surface radius for spherical domains
+      // or set the vertical coordinate to the surface value for box domains.
+      // Also get the depth extent without including initial topography, and the vertical coordinate
+      // of the bottom boundary (radius for spherical and z-coordinate for Cartesian domains).
+      double depth_extent = 0.;
+      if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()))
+        {
+          spherical_representative_point[0] = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()).outer_radius();
+          // Spherical shell cannot include initial topography
+          depth_extent =  Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()).maximal_depth();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
+        {
+          // Does not include initial topography
+          spherical_representative_point[0] =  Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>(this->get_geometry_model()).outer_radius();
+          depth_extent = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>(this->get_geometry_model()).maximal_depth();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedChunks<dim>> (this->get_geometry_model()))
+        {
+          // Does not include initial topography
+          spherical_representative_point[0] =  Plugins::get_plugin_as_type<const GeometryModel::TwoMergedChunks<dim>>(this->get_geometry_model()).outer_radius();
+          depth_extent = Plugins::get_plugin_as_type<const GeometryModel::TwoMergedChunks<dim>>(this->get_geometry_model()).maximal_depth();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::EllipsoidalChunk<dim> &gm = Plugins::get_plugin_as_type<const GeometryModel::EllipsoidalChunk<dim>> (this->get_geometry_model());
+          // TODO
+          // If the eccentricity of the EllipsoidalChunk is non-zero, the radius can vary along a boundary,
+          // but the maximal depth is the same everywhere and we could calculate a representative pressure
+          // profile. However, it requires some extra logic with ellipsoidal
+          // coordinates, so for now we only allow eccentricity zero.
+          // Using the EllipsoidalChunk with eccentricity zero can still be useful,
+          // because the domain can be non-coordinate parallel.
+          AssertThrow(gm.get_eccentricity() == 0.0, ExcMessage("This initial lithospheric pressure plugin cannot be used with a non-zero eccentricity. "));
+
+          spherical_representative_point[0] = gm.get_semi_major_axis_a();
+          // Does not include initial topography
+          depth_extent = gm.maximal_depth();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()))
+        {
+          AssertThrow(false, ExcMessage("Using the initial lithospheric pressure plugin does not make sense for a Sphere geometry."));
+          spherical_representative_point[0] =  Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>>(this->get_geometry_model()).radius();
+          // Cannot include initial topography. Radius and maximum depth are the same.
+          depth_extent = spherical_representative_point[0];
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()))
+        {
+          representative_point[dim-1]=  Plugins::get_plugin_as_type<const GeometryModel::Box<dim>>(this->get_geometry_model()).get_extents()[dim-1];
+          // Maximal_depth includes the maximum topography, while we need the topography at the
+          // representative point. Therefore, we only get the undeformed (uniform) depth.
+          depth_extent = representative_point[dim-1] - Plugins::get_plugin_as_type<const GeometryModel::Box<dim>>(this->get_geometry_model()).get_origin()[dim-1];
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
+        {
+          representative_point[dim-1]=  Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()).get_extents()[dim-1];
+          // Maximal_depth includes the maximum topography, while we need the topography at the
+          // representative point. Therefore, we only get the undeformed (uniform) depth.
+          depth_extent = representative_point[dim-1] - Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()).get_origin()[dim-1];
+        }
+      else
+        AssertThrow(false, ExcNotImplemented());
+
+      // If present, retrieve initial topography at the reference point.
+      double topo = 0.;
+      if (!Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()))
+        {
+          // Get the surface x (,y) point
+          Point<dim-1> surface_point;
+          for (unsigned int d=0; d<dim-1; d++)
+            {
+              if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian)
+                surface_point[d] = representative_point[d];
+              else
+                surface_point[d] = spherical_representative_point[d];
+
+            }
+          const InitialTopographyModel::Interface<dim> *topo_model = const_cast<InitialTopographyModel::Interface<dim>*>(&this->get_initial_topography_model());
+          topo = topo_model->value(surface_point);
+        }
+
+      // The spacing of the depth profile at the location of the representative point.
+      delta_z = (depth_extent + topo) / (n_points-1);
+
+      // Set up the input for the density function of the material model.
+      typename MaterialModel::Interface<dim>::MaterialModelInputs in(1, n_compositional_fields);
+      typename MaterialModel::Interface<dim>::MaterialModelOutputs out(1, n_compositional_fields);
+      in.requested_properties = MaterialModel::MaterialProperties::density;
+
+      // Where to calculate the density
+      // for Cartesian domains
+      if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()) ||
+          Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
+        in.position[0] = representative_point;
+      // and for spherical domains
+      else
+        in.position[0] = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_representative_point);
+
+      // We need the initial temperature at this point
+      in.temperature[0] = this->get_initial_temperature_manager().initial_temperature(in.position[0]);
+
+      // and the surface pressure.
+      in.pressure[0] = pressure[0];
+
+      // Then the compositions at this point.
+      for (unsigned int c=0; c<n_compositional_fields; ++c)
+        in.composition[0][c] = this->get_initial_composition_manager().initial_composition(in.position[0], c);
+
+      // Hopefully the material model won't needed in.strain_rate, we
+      // leave it as NaNs.
+
+      // We set all entries of the velocity vector to zero since this is the lithostatic case.
+      in.velocity[0] = Tensor<1,dim> ();
+
+      // Evaluate the material model to get the density.
+      this->get_material_model().evaluate(in, out);
+      const double density0 = out.densities[0];
+
+      // Get the magnitude of gravity. We assume
+      // that gravity always points along the depth direction. This
+      // may not strictly be true always but is likely a good enough
+      // approximation here.
+      const double gravity0 = this->get_gravity_model().gravity_vector(in.position[0]).norm();
+
+      // Now integrate pressure downward using trapezoidal integration
+      // p'(z) = rho(p,c,T) * |g| * delta_z
+      double sum = delta_z * 0.5 * density0 * gravity0;
+
+      for (unsigned int i=1; i<n_points; ++i)
+        {
+          AssertThrow (i < pressure.size(), ExcMessage(std::string("The current index ")
+                                                       + dealii::Utilities::int_to_string(i)
+                                                       + std::string(" is bigger than the size of the pressure vector ")
+                                                       + dealii::Utilities::int_to_string(pressure.size())));
+
+          // Where to calculate the density:
+          // for Cartesian domains
+          if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()) ||
+              Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
+            {
+              // decrease z coordinate with depth increment
+              representative_point[dim-1] -= delta_z;
+              in.position[0] = representative_point;
+            }
+          // and for spherical domains
+          else
+            {
+              // decrease radius with depth increment
+              spherical_representative_point[0] -= delta_z;
+              in.position[0] = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_representative_point);
+            }
+
+          // Retrieve the initial temperature at this point.
+          in.temperature[0] = this->get_initial_temperature_manager().initial_temperature(in.position[0]);
+          // and use the previous pressure
+          in.pressure[0] = pressure[i-1];
+
+          // Retrieve the compositions at this point.
+          for (unsigned int c=0; c<n_compositional_fields; ++c)
+            in.composition[0][c] = this->get_initial_composition_manager().initial_composition(in.position[0], c);
+
+          // We set all entries of the velocity vector to zero since this is the lithostatic case.
+          in.velocity[0] = Tensor<1,dim> ();
+
+          // Evaluate the material model to get the density at the current point.
+          this->get_material_model().evaluate(in, out);
+          const double density = out.densities[0];
+
+          // Get the magnitude of gravity.
+          const double gravity = this->get_gravity_model().gravity_vector(in.position[0]).norm();
+
+          // Trapezoid integration
+          pressure[i] = sum + delta_z * 0.5 * density * gravity;
+          sum += delta_z * density * gravity;
+        }
+
+      Assert (*std::min_element (pressure.begin(), pressure.end()) >=
+              -std::numeric_limits<double>::epsilon() * pressure.size(),
+              ExcInternalError());
+
+    }
+
+    template <int dim>
+    Tensor<1,dim>
+    InitialLithostaticPressure<dim>::
+    boundary_traction (const types::boundary_id boundary_indicator,
+                       const Point<dim> &position,
+                       const Tensor<1,dim> &normal_vector) const
+    {
+      // We want to set the normal component to the vertical boundary
+      // to the lithostatic pressure, the rest of the traction
+      // components are left set to zero. We get the lithostatic pressure
+      // from a linear interpolation of the calculated profile,
+      // unless boundary traction is only applied to the bottom boundary
+      // and initial topography is included.
+      // In that case we return the deepest pressure of the pressure
+      // profile directly. Otherwise, points on the bottom boundary
+      // with horizontal coordinates other than the reference point
+      // will not have a depth equal to the deepest depth of the profile.
+      Tensor<1, dim> traction;
+      if (prescribe_constant_pressure_at_bottom_boundary && boundary_indicator == bottom_boundary_id)
+        traction = -pressure.back() * normal_vector;
+      else
+        traction = -interpolate_pressure(position) * normal_vector;
+
+      return traction;
+    }
+
+    template <int dim>
+    double
+    InitialLithostaticPressure<dim>::
+    interpolate_pressure (const Point<dim> &p) const
+    {
+      // The depth at which we need the pressure.
+      const double z = this->get_geometry_model().depth(p);
+
+      // Check that depth does not exceed the maximal depth.
+      if (z >= this->get_geometry_model().maximal_depth())
+        {
+          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
+                  ExcInternalError());
+          // Return deepest (last) pressure
+          return pressure.back();
+        }
+
+      const unsigned int i = static_cast<unsigned int>(z/delta_z);
+      // If mesh deformation is allowed, the depth can become
+      // negative. However, the returned depth is capped at 0
+      // by the geometry models and thus always positive.
+      Assert ((z/delta_z) >= 0, ExcInternalError());
+      Assert (i+1 < pressure.size(), ExcInternalError());
+
+      // Now do the linear interpolation.
+      const double d=1.0+i-z/delta_z;
+      Assert ((d>=0) && (d<=1), ExcInternalError());
+
+      return d*pressure[i]+(1-d)*pressure[i+1];
+    }
+
+
+    template <int dim>
+    void
+    InitialLithostaticPressure<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary traction model");
+      {
+        prm.enter_subsection("Initial lithostatic pressure");
+        {
+          prm.declare_entry ("Representative point", "",
+                             Patterns::List(Patterns::Double()),
+                             "The point where the pressure profile will be calculated. "
+                             "Cartesian coordinates $(x,y,z)$ when geometry is a box, otherwise enter radius, "
+                             "longitude, and in 3d latitude. Note that the coordinate related to the depth "
+                             "($y$ in 2d Cartesian, $z$ in 3d Cartesian and radius in spherical coordinates) is "
+                             "not used. "
+                             "Units: \\si{\\meter} or degrees.");
+          prm.declare_entry("Number of integration points", "1000",
+                            Patterns::Integer(0),
+                            "The number of integration points over which we integrate the lithostatic pressure "
+                            "downwards.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    InitialLithostaticPressure<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      unsigned int refinement;
+      prm.enter_subsection("Mesh refinement");
+      {
+        refinement = prm.get_integer("Initial adaptive refinement") + prm.get_integer("Initial global refinement");
+      }
+      prm.leave_subsection();
+
+      prm.enter_subsection("Boundary traction model");
+      {
+        prm.enter_subsection("Initial lithostatic pressure");
+        {
+          // The representative point where to calculate the depth profile.
+          const std::vector<double> rep_point =
+            dealii::Utilities::string_to_double(dealii::Utilities::split_string_list(prm.get("Representative point")));
+          AssertThrow(rep_point.size() == dim, ExcMessage("Representative point does not have the right dimensions."));
+          for (unsigned int d = 0; d<dim; ++d)
+            representative_point[d] = rep_point[d];
+          n_points = prm.get_integer("Number of integration points");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Check that we have enough integration points for this mesh.
+      AssertThrow(std::pow(2.0,refinement) <= n_points, ExcMessage("Not enough integration points for this resolution."));
+
+      pressure.resize(n_points,-1);
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(InitialLithostaticPressure,
+                                            "initial lithostatic pressure",
+                                            "Implementation of a model in which the boundary "
+                                            "traction is given in terms of a normal traction component "
+                                            "set to the lithostatic pressure "
+                                            "calculated according to the parameters in section "
+                                            "``Boundary traction model|Lithostatic pressure''. "
+                                            "\n\n"
+                                            "The lithostatic pressure is calculated by integrating "
+                                            "the pressure downward based on the initial composition "
+                                            "and temperature along the user-specified depth profile. "
+                                            "The user-specified profile is given in terms of a point "
+                                            "in Cartesian coordinates for box geometries and "
+                                            "in spherical coordinates for all "
+                                            "other geometries (radius, longitude, latitude), and "
+                                            "the number of integration points. "
+                                            "The lateral coordinates of the point are used to calculate "
+                                            "the lithostatic pressure profile with depth. This means that "
+                                            "the depth coordinate is not used. "
+                                            "Note that when initial topography is included, the initial "
+                                            "topography at the user-provided representative point is used "
+                                            "to compute the profile. If at other points the (initial) topography "
+                                            "is higher, the behavior of this plugin at later timesteps depends "
+                                            "on the domain geometry. The depth returned by the geometry model "
+                                            "does (box geometries) or does not (spherical "
+                                            "geometries) include the initial topography. This depth is used "
+                                            "to interpolate between the points of the reference pressure profile. "
+                                            "Depths outside the reference profile get returned the pressure value "
+                                            "of the closest profile depth. When only the bottom boundary is "
+                                            "prescribed initial lithostatic pressure, the pressure value of "
+                                            "the deepest depth of the profile is returned. "
+                                            "\n\n"
+                                            "Gravity is expected to point along the depth direction. ")
+  }
+}
diff --git a/source/boundary_traction/interface.cc.bak b/source/boundary_traction/interface.cc.bak
new file mode 100644
index 00000000000..fcfbd167fb5
--- /dev/null
+++ b/source/boundary_traction/interface.cc.bak
@@ -0,0 +1,321 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_traction/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    template <int dim>
+    Manager<dim>::~Manager()
+      = default;
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::update ()
+    {
+      for (const auto &boundary : boundary_traction_objects)
+        for (const auto &p : boundary.second)
+          p->update();
+    }
+
+
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+    template <int dim>
+    void
+    Manager<dim>::register_boundary_traction (const std::string &name,
+                                              const std::string &description,
+                                              void (*declare_parameters_function) (ParameterHandler &),
+                                              std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+    template <int dim>
+    Tensor<1,dim>
+    Manager<dim>::boundary_traction (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position,
+                                     const Tensor<1,dim> &normal_vector) const
+    {
+      typename std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryTraction::Interface<dim>>>>::const_iterator boundary_plugins =
+        boundary_traction_objects.find(boundary_indicator);
+
+      Assert(boundary_plugins != boundary_traction_objects.end(),
+             ExcMessage("The boundary traction manager class was asked for the "
+                        "boundary traction at a boundary that contains no active "
+                        "boundary traction plugin."));
+
+      Tensor<1,dim> traction = Tensor<1,dim>();
+
+      for (const auto &plugin : boundary_plugins->second)
+        traction += plugin->boundary_traction(boundary_indicator,
+                                              position,normal_vector);
+
+      return traction;
+    }
+
+
+
+    template <int dim>
+    const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> &
+    Manager<dim>::get_active_boundary_traction_names () const
+    {
+      return boundary_traction_indicators;
+    }
+
+
+
+    template <int dim>
+    const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryTraction::Interface<dim>>>> &
+    Manager<dim>::get_active_boundary_traction_conditions () const
+    {
+      return boundary_traction_objects;
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Boundary traction model");
+      {
+        prm.declare_entry ("Prescribed traction boundary indicators", "",
+                           Patterns::Map (Patterns::Anything(),
+                                          Patterns::Selection(std::get<dim>(registered_plugins).get_pattern_of_names ())),
+                           "A comma separated list denoting those boundaries "
+                           "on which the traction is prescribed, i.e., where unknown "
+                           "external forces act to prescribe a particular traction. This is "
+                           "often used to prescribe a traction that equals that of "
+                           "overlying plates."
+                           "\n\n"
+                           "The format of valid entries for this parameter is that of a map "
+                           "given as ``key1 [selector]: value1, key2 [selector]: value2, key3: value3, ...'' where "
+                           "each key must be a valid boundary indicator (which is either an "
+                           "integer or the symbolic name the geometry model in use may have "
+                           "provided for this part of the boundary) "
+                           "and each value must be one of the currently implemented boundary "
+                           "traction models. ``selector'' is an optional string given as a subset "
+                           "of the letters `xyz' that allows you to apply the boundary conditions "
+                           "only to the components listed. As an example, '1 y: function' applies "
+                           "the type `function' to the y component on boundary 1. Without a selector "
+                           "it will affect all components of the traction."
+                           "\n\n"
+                           "Note that traction should be given in N/m^2. "
+
+                           "The following boundary traction models are available:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Boundary traction model");
+      {
+        // find out which plugins are requested and the various other
+        // parameters we declare here
+        const std::vector<std::string> x_boundary_traction_indicators
+          = Utilities::split_string_list(prm.get("Prescribed traction boundary indicators"));
+
+        for (const auto &p : x_boundary_traction_indicators)
+          {
+            // each entry has the format (white space is optional):
+            // <id> [x][y][z] : <value (might have spaces)>
+            //
+            // first tease apart the two halves
+            const std::vector<std::string> split_parts = Utilities::split_string_list (p, ':');
+            AssertThrow (split_parts.size() == 2,
+                         ExcMessage ("The format for prescribed traction boundary indicators "
+                                     "requires that each entry has the form `"
+                                     "<id> [x][y][z] : <value>', but there does not "
+                                     "appear to be a colon in the entry <"
+                                     + p
+                                     + ">."));
+
+            // the easy part: get the value
+            const std::string &value = split_parts[1];
+
+            // now for the rest. since we don't know whether there is a
+            // component selector, start reading at the end and subtracting
+            // letters x, y and z
+            std::string key_and_comp = split_parts[0];
+            std::string comp;
+            while ((key_and_comp.size()>0) &&
+                   ((key_and_comp[key_and_comp.size()-1] == 'x')
+                    ||
+                    (key_and_comp[key_and_comp.size()-1] == 'y')
+                    ||
+                    ((key_and_comp[key_and_comp.size()-1] == 'z') && (dim==3))))
+              {
+                comp += key_and_comp[key_and_comp.size()-1];
+                key_and_comp.erase (--key_and_comp.end());
+              }
+
+            // we've stopped reading component selectors now. there are three
+            // possibilities:
+            // - no characters are left. this means that key_and_comp only
+            //   consisted of a single word that only consisted of 'x', 'y'
+            //   and 'z's. then this would have been a mistake to classify
+            //   as a component selector, and we better undo it
+            // - the last character of key_and_comp is not a whitespace. this
+            //   means that the last word in key_and_comp ended in an 'x', 'y'
+            //   or 'z', but this was not meant to be a component selector.
+            //   in that case, put these characters back.
+            // - otherwise, we split successfully. eat spaces that may be at
+            //   the end of key_and_comp to get key
+            if (key_and_comp.size() == 0)
+              key_and_comp.swap (comp);
+            else if (key_and_comp[key_and_comp.size()-1] != ' ')
+              {
+                key_and_comp += comp;
+                comp = "";
+              }
+            else
+              {
+                while ((key_and_comp.size()>0) && (key_and_comp[key_and_comp.size()-1] == ' '))
+                  key_and_comp.erase (--key_and_comp.end());
+              }
+
+            // finally, try to translate the key into a boundary_id. then
+            // make sure we haven't seen it yet
+            types::boundary_id boundary_id;
+            try
+              {
+                boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id(key_and_comp);
+              }
+            catch (const std::string &error)
+              {
+                AssertThrow (false, ExcMessage ("While parsing the entry <Boundary traction model/Prescribed "
+                                                "traction indicators>, there was an error. Specifically, "
+                                                "the conversion function complained as follows:\n\n"
+                                                + error));
+              }
+
+            if (boundary_traction_indicators.find(boundary_id) != boundary_traction_indicators.end())
+              {
+                Assert(boundary_traction_indicators[boundary_id].first == comp,
+                       ExcMessage("Different traction plugins for the same boundary have to have the same component selector. "
+                                  "This was not the case for boundary: " + key_and_comp +
+                                  ", for plugin: " + value + ", with component selector: " + comp));
+
+                // finally, put it into the list
+                boundary_traction_indicators[boundary_id].second.push_back(value);
+              }
+            else
+              {
+                boundary_traction_indicators[boundary_id] = std::make_pair(comp,std::vector<std::string>(1,value));
+              }
+          }
+      }
+      prm.leave_subsection();
+
+      // go through the list, create objects and let them parse
+      // their own parameters
+      for (const auto &boundary_id : boundary_traction_indicators)
+        {
+          for (const auto &name : boundary_id.second.second)
+            {
+              boundary_traction_objects[boundary_id.first].push_back(
+                std::unique_ptr<Interface<dim>> (std::get<dim>(registered_plugins)
+                                                  .create_plugin (name,
+                                                                  "Boundary traction::Model names")));
+
+              if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(boundary_traction_objects[boundary_id.first].back().get()))
+                sim->initialize_simulator (this->get_simulator());
+
+              boundary_traction_objects[boundary_id.first].back()->parse_parameters (prm);
+              boundary_traction_objects[boundary_id.first].back()->initialize ();
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary traction interface",
+                                                            out);
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryTraction::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryTraction::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryTraction::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryTraction::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace BoundaryTraction
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>; \
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/boundary_traction/zero_traction.cc.bak b/source/boundary_traction/zero_traction.cc.bak
new file mode 100644
index 00000000000..3d4fb01e953
--- /dev/null
+++ b/source/boundary_traction/zero_traction.cc.bak
@@ -0,0 +1,62 @@
+/*
+  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_traction/zero_traction.h>
+
+
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    template <int dim>
+    Tensor<1,dim>
+    ZeroTraction<dim>::
+    boundary_traction (const types::boundary_id,
+                       const Point<dim> &,
+                       const Tensor<1,dim> &) const
+    {
+      // return a zero tensor regardless of position
+      return Tensor<1,dim>();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTraction
+  {
+    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(ZeroTraction,
+                                            "zero traction",
+                                            "Implementation of a model in which the boundary "
+                                            "traction is zero. This is commonly referred to as "
+                                            "an ``open boundary condition'', indicating that "
+                                            "the material experiences no forces in response to "
+                                            "what might exist on the other side of the boundary. "
+                                            "However, this is only true in the case where "
+                                            "hydrostatic pressure is not relevant. If hydrostatic "
+                                            "pressure is not negligible, for example at the sides "
+                                            "of a regional model, the material at the other side "
+                                            "of the boundary does exceed a force, namely the "
+                                            "force normal to the boundary induced by the "
+                                            "hydrostatic pressure.")
+  }
+}
diff --git a/source/boundary_velocity/ascii_data.cc.bak b/source/boundary_velocity/ascii_data.cc.bak
new file mode 100644
index 00000000000..5e0843075e1
--- /dev/null
+++ b/source/boundary_velocity/ascii_data.cc.bak
@@ -0,0 +1,177 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_velocity/ascii_data.h>
+
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      for (const auto &p : this->get_boundary_velocity_manager().get_active_boundary_velocity_conditions())
+        {
+          for (const auto &plugin : p.second)
+            if (plugin.get() == this)
+              boundary_ids.insert(p.first);
+        }
+      AssertThrow(*(boundary_ids.begin()) != numbers::invalid_boundary_id,
+                  ExcMessage("Did not find the boundary indicator for the prescribed data plugin."));
+
+      Utilities::AsciiDataBoundary<dim>::initialize(boundary_ids,
+                                                    dim);
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::update ()
+    {
+      Interface<dim>::update ();
+
+      Utilities::AsciiDataBoundary<dim>::update();
+    }
+
+
+    template <int dim>
+    Tensor<1,dim>
+    AsciiData<dim>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<dim> &position) const
+    {
+      Tensor<1,dim> velocity;
+      for (unsigned int i = 0; i < dim; ++i)
+        velocity[i] = Utilities::AsciiDataBoundary<dim>::get_data_component(*(boundary_ids.begin()),
+                                                                            position,
+                                                                            i);
+      if (use_spherical_unit_vectors)
+        velocity = Utilities::Coordinates::spherical_to_cartesian_vector(velocity, position);
+
+      return velocity;
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary velocity model");
+      {
+        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
+                                                              "$ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/",
+                                                              "box_2d_%s.%d.txt");
+        prm.enter_subsection("Ascii data model");
+        {
+          prm.declare_entry ("Use spherical unit vectors", "false",
+                             Patterns::Bool (),
+                             "Specify velocity as r, phi, and theta components "
+                             "instead of x, y, and z. Positive velocities point up, east, "
+                             "and north (in 3d) or out and clockwise (in 2d). "
+                             "This setting only makes sense for spherical geometries."
+                            );
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary velocity model");
+      {
+        Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
+
+        if (this->convert_output_to_years() == true)
+          {
+            this->scale_factor               /= year_in_seconds;
+          }
+        prm.enter_subsection("Ascii data model");
+        {
+          use_spherical_unit_vectors = prm.get_bool("Use spherical unit vectors");
+          if (use_spherical_unit_vectors)
+            AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
+                         ExcMessage ("Spherical unit vectors should not be used "
+                                     "when geometry model is not spherical."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(AsciiData,
+                                            "ascii data",
+                                            "Implementation of a model in which the boundary "
+                                            "velocity is derived from files containing data "
+                                            "in ascii format. Note the required format of the "
+                                            "input data: The first lines may contain any number of comments "
+                                            "if they begin with `#', but one of these lines needs to "
+                                            "contain the number of grid points in each dimension as "
+                                            "for example `# POINTS: 3 3'. "
+                                            "The order of the data columns "
+                                            "has to be `x', `velocity${}_x$', `velocity${}_y$' in a 2d model "
+                                            "or `x', `y', `velocity${}_x$', `velocity${}_y$', "
+                                            "`velocity${}_z$' in a 3d model. "
+                                            "Note that the data in the input "
+                                            "files need to be sorted in a specific order: "
+                                            "the first coordinate needs to ascend first, "
+                                            "followed by the second in order to "
+                                            "assign the correct data to the prescribed coordinates."
+                                            "If you use a spherical model, "
+                                            "then the assumed grid changes. `x' will be replaced by "
+                                            "the radial distance of the point to the bottom of the model, "
+                                            "`y' by the azimuth angle and `z' by the polar angle measured "
+                                            "positive from the north pole. The grid will be assumed to be "
+                                            "a latitude-longitude grid. Note that the order "
+                                            "of spherical coordinates is `r', `phi', `theta' "
+                                            "and not `r', `theta', `phi', since this allows "
+                                            "for dimension independent expressions. "
+                                            "Velocities can be specified using cartesian "
+                                            "(by default) or spherical unit vectors. "
+                                            "No matter which geometry model is chosen, "
+                                            "the unit of the velocities is assumed to be "
+                                            "m/s or m/yr depending on the `Use years in output "
+                                            "instead of seconds' flag. If you provide velocities "
+                                            "in cm/yr, set the `Scale factor' option to 0.01.")
+  }
+}
diff --git a/source/boundary_velocity/function.cc.bak b/source/boundary_velocity/function.cc.bak
new file mode 100644
index 00000000000..201d814e28c
--- /dev/null
+++ b/source/boundary_velocity/function.cc.bak
@@ -0,0 +1,185 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_velocity/function.h>
+#include <aspect/utilities.h>
+#include <aspect/global.h>
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    template <int dim>
+    Function<dim>::Function ()
+      :
+      boundary_velocity_function (dim)
+    {}
+
+
+
+    template <int dim>
+    Tensor<1,dim>
+    Function<dim>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<dim> &position) const
+    {
+      Tensor<1,dim> velocity;
+
+      const Utilities::NaturalCoordinate<dim> point =
+        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
+
+      for (unsigned int d=0; d<dim; ++d)
+        velocity[d] = boundary_velocity_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()), d);
+
+      if (use_spherical_unit_vectors)
+        velocity = Utilities::Coordinates::spherical_to_cartesian_vector(velocity, position);
+
+      // ASPECT always wants things in MKS system. however, as described
+      // in the documentation of this class, we interpret the formulas
+      // given to this plugin as meters per year if the global flag
+      // for using years instead of seconds is given. so if someone
+      // write "5" in their parameter file and sets the flag, then this
+      // means "5 meters/year" and we need to convert it to the ASPECT
+      // time system by dividing by the number of seconds per year
+      // to get MKS units
+      if (this->convert_output_to_years())
+        return velocity / year_in_seconds;
+      else
+        return velocity;
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::update()
+    {
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        boundary_velocity_function.set_time (this->get_time() / year_in_seconds);
+      else
+        boundary_velocity_function.set_time (this->get_time());
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary velocity model");
+      {
+        prm.enter_subsection("Function");
+        {
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle. `depth' "
+                             "will create a function, in which only the first "
+                             "parameter is non-zero, which is interpreted to "
+                             "be the depth of the point.");
+          prm.declare_entry ("Use spherical unit vectors", "false",
+                             Patterns::Bool (),
+                             "Specify velocity as $r$, $\\phi$, and $\\theta$ components "
+                             "instead of $x$, $y$, and $z$. Positive velocities point up, east, "
+                             "and north (in 3d) or out and clockwise (in 2d). "
+                             "This setting only makes sense for spherical geometries.");
+
+          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary velocity model");
+      {
+        prm.enter_subsection("Function");
+        {
+          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+          use_spherical_unit_vectors = prm.get_bool("Use spherical unit vectors");
+          if (use_spherical_unit_vectors)
+            AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
+                         ExcMessage ("Spherical unit vectors should not be used "
+                                     "when geometry model is not spherical."));
+        }
+        try
+          {
+            boundary_velocity_function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Boundary velocity model.Function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(Function,
+                                            "function",
+                                            "Implementation of a model in which the boundary "
+                                            "velocity is given in terms of an explicit formula "
+                                            "that is elaborated in the parameters in section "
+                                            "``Boundary velocity model|Function''. The format of these "
+                                            "functions follows the syntax understood by the "
+                                            "muparser library, see "
+                                            "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`."
+                                            "\n\n"
+                                            "The formula you describe in the mentioned "
+                                            "section is a semicolon separated list of velocities "
+                                            "for each of the $d$ components of the velocity vector. "
+                                            "These $d$ formulas are interpreted as having units "
+                                            "m/s, unless the global input parameter ``Use "
+                                            "years in output instead of seconds'' is set, in "
+                                            "which case we interpret the formula expressions "
+                                            "as having units m/year."
+                                            "\n\n"
+                                            "Likewise, since the symbol $t$ indicating time "
+                                            "may appear in the formulas for the prescribed "
+                                            "velocities, it is interpreted as having units "
+                                            "seconds unless the global parameter above has "
+                                            "been set.")
+  }
+}
diff --git a/source/boundary_velocity/gplates.cc.bak b/source/boundary_velocity/gplates.cc.bak
new file mode 100644
index 00000000000..a77b5d4f281
--- /dev/null
+++ b/source/boundary_velocity/gplates.cc.bak
@@ -0,0 +1,870 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_velocity/gplates.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/utilities.h>
+#include <deal.II/base/table.h>
+
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+
+
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    namespace internal
+    {
+      template <int dim>
+      GPlatesLookup<dim>::GPlatesLookup(const Tensor<1,2> &surface_point_one,
+                                        const Tensor<1,2> &surface_point_two)
+      {
+        // get the Cartesian coordinates of the points the 2d model will lie in
+        // this computation is done also for 3d since it is not expensive and the
+        // template dim is currently not used here. Could be changed.
+        const Tensor<1,3> point_one = cartesian_surface_coordinates(convert_tensor<2,3>(surface_point_one));
+        const Tensor<1,3> point_two = cartesian_surface_coordinates(convert_tensor<2,3>(surface_point_two));
+
+        rotation_matrix = Utilities::compute_rotation_matrix_for_slice(point_one, point_two);
+      }
+
+
+
+      template <int dim>
+      std::string
+      GPlatesLookup<dim>::screen_output(const Tensor<1,2> &surface_point_one,
+                                        const Tensor<1,2> &surface_point_two) const
+      {
+        const Tensor<1,3> point_one = cartesian_surface_coordinates(convert_tensor<2,3>(surface_point_one));
+        const Tensor<1,3> point_two = cartesian_surface_coordinates(convert_tensor<2,3>(surface_point_two));
+
+        std::ostringstream output;
+
+        output << std::setprecision (3) << std::setw(3) << std::fixed << std::endl
+               << "   Setting up GPlates boundary velocity plugin."  << std::endl
+               << std::endl;
+        if (dim == 2)
+          {
+            Tensor<1,3> rotation_axis;
+            const double rotation_angle = rotation_axis_from_matrix(rotation_axis,rotation_matrix);
+
+            std::array<double,3> angles = angles_from_matrix(rotation_matrix);
+            std::array<double,3> back_angles = angles_from_matrix(transpose(rotation_matrix));
+
+            output << "   Input point 1 spherical coordinates: " << surface_point_one  << std::endl
+                   << "   Input point 1 normalized cartesian coordinates: " << point_one  << std::endl
+                   << "   Input point 1 rotated model coordinates: " << transpose(rotation_matrix) * point_one  << std::endl
+                   << "   Input point 2 spherical coordinates: " << surface_point_two  << std::endl
+                   << "   Input point 2 normalized cartesian coordinates: " << point_two  << std::endl
+                   << "   Input point 2 rotated model coordinates: " << transpose(rotation_matrix) * point_two << std::endl
+                   << std::endl <<  std::setprecision(2)
+                   << "   Model will be rotated by " << -rotation_angle *constants::radians_to_degree
+                   << " degrees around axis " << rotation_axis << std::endl
+                   << "   The ParaView rotation angles are: " << angles[0] << ' ' << angles [1] << ' ' << angles[2] << std::endl
+                   << "   The inverse ParaView rotation angles are: " << back_angles[0] << ' ' << back_angles [1] << ' ' << back_angles[2]
+
+                   << std::endl;
+          }
+
+        return output.str();
+      }
+
+
+
+      template <int dim>
+      void
+      GPlatesLookup<dim>::load_file(const std::string &filename,
+                                    const MPI_Comm comm)
+      {
+        // Read data from disk and distribute among processes
+        std::istringstream filecontent(
+          Utilities::read_and_distribute_file_content(filename, comm));
+
+        boost::property_tree::ptree pt;
+
+        // populate tree structure pt
+        read_xml(filecontent, pt);
+
+        const unsigned int n_points = pt.get_child("gpml:FeatureCollection.gml:featureMember.gpml:VelocityField.gml:domainSet.gml:MultiPoint").size();
+
+        // These formulas look magic, but they are the proper solution to the equation:
+        // n_points = n_theta * n_phi with n_phi = 2 * (n_theta - 1)
+        // From the XML information we only know n_points, but need n_theta
+        // and n_phi to properly size the arrays and get the grip point positions
+        const double dn_theta = 0.5 + std::sqrt(0.25 + n_points/2);
+        const unsigned int n_theta = static_cast<unsigned int> (dn_theta);
+        const unsigned int n_phi = static_cast<unsigned int> (2 * (dn_theta - 1));
+
+        AssertThrow(dn_theta - n_theta <= 1e-5,
+                    ExcMessage("The velocity file has a grid structure that is not readable. Please refer to the manual for a proper grid structure."));
+
+        delta_theta =   numbers::PI / (n_theta-1);
+        delta_phi   = 2*numbers::PI / n_phi;
+
+        /**
+         * Two tables (one for the theta and one for the phi component)
+         * which contain the velocities at every point.
+         * velocity_values[0] is the table for the theta component, whereas
+         * velocity_values[1] is the table for the phi component.
+         */
+        Table<2,double> velocity_values[2] = {Table<2,double>(n_theta,n_phi+1), Table<2,double>(n_theta,n_phi+1)};
+
+        std::string velos = pt.get<std::string>("gpml:FeatureCollection.gml:featureMember.gpml:VelocityField.gml:rangeSet.gml:DataBlock.gml:tupleList");
+        std::stringstream in(velos, std::ios::in);
+        AssertThrow (in,
+                     ExcMessage (std::string("Could not find velocities. Is file native gpml format for velocities?")));
+
+        // The lat-lon mesh has changed its starting longitude in gplates1.4
+        // correct for this while reading in the velocity data
+        unsigned int longitude_correction = 0;
+        if (gplates_1_4_or_higher(pt))
+          longitude_correction = n_phi/2;
+
+        unsigned int i = 0;
+        char sep;
+        Tensor<1,2> spherical_velocities;
+
+        while (in >> spherical_velocities[0] >> sep >> spherical_velocities[1])
+          {
+            const double cmyr_si = 0.01/year_in_seconds;
+
+            const unsigned int idx_theta = i / n_phi;
+            const unsigned int idx_phi = (i + longitude_correction) % n_phi;
+
+            velocity_values[0][idx_theta][idx_phi]= spherical_velocities[0] * cmyr_si;
+            velocity_values[1][idx_theta][idx_phi]= spherical_velocities[1] * cmyr_si;
+
+            ++i;
+          }
+
+        // Pad the longitude data with values for phi == 2*pi (== 0),
+        // this simplifies interpolation later.
+        for (unsigned int i=0; i<n_theta; ++i)
+          {
+            velocity_values[0][i][n_phi] = velocity_values[0][i][0];
+            velocity_values[1][i][n_phi] = velocity_values[1][i][0];
+          }
+
+        // number of intervals in the direction of theta and phi
+        std::array<unsigned int,2> table_intervals;
+        table_intervals[0] = n_theta - 1;
+        table_intervals[1] = n_phi;
+
+        // Min and Max coordinates in data file
+        std::array<std::pair<double,double>,2> grid_extent;
+
+        // min and max extent of the grid in the direction of theta and phi (whole spheres in GPlates)
+        // polar angle theta: from 0° to 180°(PI)
+        grid_extent[0].first = 0;
+        grid_extent[0].second = numbers::PI;
+        // azimuthal angle phi: from 0° to 360°(2*PI)
+        grid_extent[1].first = 0;
+        grid_extent[1].second = 2 * numbers::PI;
+
+        for (unsigned int i = 0; i < 2; ++i)
+          {
+            velocities[i]
+              = std::make_unique<Functions::InterpolatedUniformGridData<2>> (grid_extent,
+                                                                              table_intervals,
+                                                                              velocity_values[i]);
+          }
+
+        AssertThrow(i == n_points,
+                    ExcMessage (std::string("Number of read in points does not match number of points in file. File corrupted?")));
+      }
+
+
+
+      template <int dim>
+      Tensor<1,dim>
+      GPlatesLookup<dim>::surface_velocity(const Point<dim> &position) const
+      {
+        const Point<3> internal_position ((dim == 2)
+                                          ?
+                                          rotation_matrix * convert_tensor<dim,3>(position)
+                                          :
+                                          convert_tensor<dim,3>(position));
+
+        // transform internal_position in spherical coordinates
+        std::array<double,3> spherical_point =
+          Utilities::Coordinates::cartesian_to_spherical_coordinates(internal_position);
+
+        Tensor<1,dim> output_boundary_velocity;
+        // Handle all points that are not close to the poles
+        if ((spherical_point[2] >= delta_theta) && (spherical_point[2] <= numbers::PI - delta_theta))
+          {
+            output_boundary_velocity = cartesian_velocity_at_surface_point(spherical_point);
+          }
+
+        // The longitude of data points at the poles is set to zero (according to the internal
+        // GPlates routine). Because we interpolate velocities before converting them to the
+        // cartesian coordinate system, we need to evaluate them twice: First at the poles,
+        // and then at the latitude of the first data point that is not at the poles.
+        // Afterwards we average the two velocities to the real position.
+        else if (spherical_point[2] < delta_theta)
+          {
+            const double theta = spherical_point[2];
+            spherical_point[2] = delta_theta;
+            const Tensor<1,dim> first_velocity = cartesian_velocity_at_surface_point(spherical_point);
+
+            spherical_point[1] = 0.0;
+            spherical_point[2] = 0.0;
+            const Tensor<1,dim> polar_velocity = cartesian_velocity_at_surface_point(spherical_point);
+
+            output_boundary_velocity = (theta / delta_theta) * first_velocity
+                                       + (1.0 - theta / delta_theta) * polar_velocity;
+          }
+        else if (spherical_point[2] > numbers::PI - delta_theta)
+          {
+            const double theta = spherical_point[2];
+            spherical_point[2] = numbers::PI - delta_theta;
+            const Tensor<1,dim> first_velocity = cartesian_velocity_at_surface_point(spherical_point);
+
+            spherical_point[1] = 0.0;
+            spherical_point[2] = numbers::PI;
+            const Tensor<1,dim> polar_velocity = cartesian_velocity_at_surface_point(spherical_point);
+
+            output_boundary_velocity = ((numbers::PI - theta) / delta_theta) * first_velocity
+                                       + (1.0 - (numbers::PI - theta) / delta_theta) * polar_velocity;
+          }
+        else
+          Assert(false,ExcInternalError());
+
+        return output_boundary_velocity;
+      }
+
+
+
+      template <int dim>
+      Tensor<1,dim>
+      GPlatesLookup<dim>::cartesian_velocity_at_surface_point(const std::array<double,3> &spherical_point) const
+      {
+        // Re-sort the components of the spherical position from [r,phi,theta] to [theta, phi]
+        const Point<2> lookup_coordinates(spherical_point[2],spherical_point[1]);
+
+        // Main work, interpolate velocity at this point
+        Tensor<1,2> interpolated_velocity;
+
+        for (unsigned int i = 0; i < 2; ++i)
+          interpolated_velocity[i] = velocities[i]->value(lookup_coordinates);
+
+        // Transform interpolated_velocity in cartesian coordinates
+        const Tensor<1,3> interpolated_velocity_in_cart = sphere_to_cart_velocity(interpolated_velocity,spherical_point);
+
+        // Convert_tensor conveniently also handles the projection to the 2d plane by
+        // omitting the z-component of velocity (since the 2d model lies in the x-y plane).
+        const Tensor<1,dim> output_boundary_velocity = (dim == 2)
+                                                       ?
+                                                       convert_tensor<3,dim>(transpose(rotation_matrix) * interpolated_velocity_in_cart)
+                                                       :
+                                                       convert_tensor<3,dim>(interpolated_velocity_in_cart);
+
+        return output_boundary_velocity;
+      }
+
+
+
+      template <int dim>
+      Tensor<1,3>
+      GPlatesLookup<dim>::cartesian_surface_coordinates(const Tensor<1,3> &sposition) const
+      {
+        Tensor<1,3> ccoord;
+
+        ccoord[0] = std::sin(sposition[0]) * std::cos(sposition[1]); // X
+        ccoord[1] = std::sin(sposition[0]) * std::sin(sposition[1]); // Y
+        ccoord[2] = std::cos(sposition[0]); // Z
+        return ccoord;
+      }
+
+
+
+      template <int dim>
+      Tensor<1,3>
+      GPlatesLookup<dim>::sphere_to_cart_velocity(const Tensor<1,2> &s_velocities, const std::array<double,3> &s_position) const
+      {
+        Tensor<1,3> velocity;
+
+        velocity[0] = std::cos(s_position[2]) * std::cos(s_position[1]) * s_velocities[0]
+                      - 1.0 * std::sin(s_position[1]) * s_velocities[1];
+        velocity[1] = std::cos(s_position[2]) * std::sin(s_position[1]) * s_velocities[0]
+                      + std::cos(s_position[1]) * s_velocities[1];
+        velocity[2] = -1.0 * std::sin(s_position[2]) * s_velocities[0];
+
+        return velocity;
+      }
+
+
+
+      template <int dim>
+      double
+      GPlatesLookup<dim>::rotation_axis_from_matrix (Tensor<1,3> &rotation_axis,
+                                                     const Tensor<2,3> &rotation_matrix) const
+      {
+        double rotation_angle = std::acos(0.5 * (rotation_matrix[0][0] + rotation_matrix[1][1] + rotation_matrix[2][2] - 1));
+
+        if (rotation_angle > std::numeric_limits<double>::min())
+          {
+            rotation_axis[0] = (rotation_matrix[2][1] - rotation_matrix[1][2]) / (2*std::sin(rotation_angle));
+            rotation_axis[1] = (rotation_matrix[0][2] - rotation_matrix[2][0]) / (2*std::sin(rotation_angle));
+            rotation_axis[2] = (rotation_matrix[1][0] - rotation_matrix[0][1]) / (2*std::sin(rotation_angle));
+          }
+        else
+          {
+            rotation_axis[0] = 0.0;
+            rotation_axis[1] = 0.0;
+            rotation_axis[2] = 1.0;
+          }
+
+        return rotation_angle;
+      }
+
+
+
+      template <int dim>
+      std::array<double,3>
+      GPlatesLookup<dim>::angles_from_matrix(const Tensor<2,3> &rotation_matrix) const
+      {
+        std::array<double,3> orientation;
+
+        /*
+         * The following code is part of the VTK project and copied here for
+         * compatibility to the paraview rotation formalism. It is protected by
+         * the following license:
+         *
+         *
+         * Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+         * All rights reserved.
+         *
+         * Redistribution and use in source and binary forms, with or without
+         * modification, are permitted under certain conditions. See
+         * http://www.kitware.com/Copyright.htm for details.
+
+         * This software is distributed WITHOUT ANY WARRANTY; without even
+         * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+         * PURPOSE.  See the above copyright notice for more information.
+         *
+         *
+         * The original code in the VTK-6.0.0 source folder is found in:
+         * /Common/Transforms/vtkTransform.cxx in the function GetOrientation()
+         *
+         */
+
+        // first rotate about y axis
+        const double x2 = rotation_matrix[2][0];
+        const double y2 = rotation_matrix[2][1];
+        const double z2 = rotation_matrix[2][2];
+
+        const double x3 = rotation_matrix[1][0];
+        const double y3 = rotation_matrix[1][1];
+        const double z3 = rotation_matrix[1][2];
+
+        double d1 = sqrt(x2*x2 + z2*z2);
+
+        double cosTheta, sinTheta;
+        if (d1 < std::numeric_limits<double>::min())
+          {
+            cosTheta = 1.0;
+            sinTheta = 0.0;
+          }
+        else
+          {
+            cosTheta = z2/d1;
+            sinTheta = x2/d1;
+          }
+
+        double theta = atan2(sinTheta, cosTheta);
+        orientation[1] = - theta * constants::radians_to_degree;
+
+        // now rotate about x axis
+        double d = sqrt(x2*x2 + y2*y2 + z2*z2);
+
+        double sinPhi, cosPhi;
+        if (d < std::numeric_limits<double>::min())
+          {
+            sinPhi = 0.0;
+            cosPhi = 1.0;
+          }
+        else if (d1 < std::numeric_limits<double>::min())
+          {
+            sinPhi = y2/d;
+            cosPhi = z2/d;
+          }
+        else
+          {
+            sinPhi = y2/d;
+            cosPhi = (x2*x2 + z2*z2)/(d1*d);
+          }
+
+        double phi = atan2(sinPhi, cosPhi);
+        orientation[0] = phi * constants::radians_to_degree;
+
+        // finally, rotate about z
+        double x3p = x3*cosTheta - z3*sinTheta;
+        double y3p = - sinPhi*sinTheta*x3 + cosPhi*y3 - sinPhi*cosTheta*z3;
+        double d2 = sqrt(x3p*x3p + y3p*y3p);
+
+        double cosAlpha, sinAlpha;
+        if (d2 < std::numeric_limits<double>::min())
+          {
+            cosAlpha = 1.0;
+            sinAlpha = 0.0;
+          }
+        else
+          {
+            cosAlpha = y3p/d2;
+            sinAlpha = x3p/d2;
+          }
+
+        double alpha = atan2(sinAlpha, cosAlpha);
+        orientation[2] = alpha * constants::radians_to_degree;
+        return orientation;
+      }
+
+
+
+      template <int dim>
+      template <int in, int out>
+      Tensor<1,out>
+      GPlatesLookup<dim>::convert_tensor (const Tensor<1,in> &old_tensor) const
+      {
+        Tensor<1,out> new_tensor;
+        for (unsigned int i = 0; i < out; ++i)
+          if (i < in) new_tensor[i] = old_tensor[i];
+          else new_tensor[i] = 0.0;
+
+        return new_tensor;
+      }
+
+
+
+      template <int dim>
+      bool
+      GPlatesLookup<dim>::gplates_1_4_or_higher(const boost::property_tree::ptree &pt) const
+      {
+        const std::string gpml_version = pt.get<std::string>("gpml:FeatureCollection.<xmlattr>.gpml:version");
+        const std::vector<std::string> string_versions = dealii::Utilities::split_string_list(gpml_version,'.');
+        const std::vector<int> int_versions = dealii::Utilities::string_to_int(string_versions);
+
+        const int gplates_1_3_version[3] = {1,6,322};
+
+        for (unsigned int i = 0; i < int_versions.size(); ++i)
+          {
+            if (int_versions[i] > gplates_1_3_version[i])
+              return true;
+            if (int_versions[i] < gplates_1_3_version[i])
+              return false;
+          }
+
+        return false;
+      }
+    }
+
+
+
+    template <int dim>
+    GPlates<dim>::GPlates ()
+      :
+      current_file_number(0),
+      first_data_file_model_time(0.0),
+      first_data_file_number(0),
+      decreasing_file_order(false),
+      data_file_time_step(0.0),
+      time_weight(0.0),
+      time_dependent(true),
+      point1("0.0,0.0"),
+      point2("0.0,0.0"),
+      lithosphere_thickness(0.0),
+      lookup(),
+      old_lookup()
+    {}
+
+
+
+    template <int dim>
+    void
+    GPlates<dim>::initialize ()
+    {
+      char sep;
+
+      std::stringstream streampoint(point1);
+      streampoint >> pointone[0] >> sep >> pointone[1];
+
+      std::stringstream streampoint2(point2);
+      streampoint2 >> pointtwo[0] >> sep >> pointtwo[1];
+
+      if (dim == 2)
+        Assert (pointone != pointtwo,
+                ExcMessage ("To define a plane for the 2d model the two assigned points "
+                            "may not be equal."));
+
+      AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
+                   ExcMessage ("This gplates plugin can only be used when the "
+                               "preferred coordinate system of the geometry model is spherical "
+                               "(e.g. spherical shell, chunk, sphere)."));
+
+      lookup = std::make_unique<internal::GPlatesLookup<dim>>(pointone, pointtwo);
+      old_lookup = std::make_unique<internal::GPlatesLookup<dim>>(pointone, pointtwo);
+
+      // display the GPlates module information at model start.
+      this->get_pcout() << lookup->screen_output(pointone, pointtwo);
+
+      // Set the first file number and load the first files
+      current_file_number = first_data_file_number;
+
+      const int next_file_number =
+        (decreasing_file_order)
+        ?
+        (current_file_number - 1)
+        :
+        (current_file_number + 1);
+
+      this->get_pcout() << std::endl << "   Loading GPlates data boundary file "
+                        << create_filename (current_file_number) << '.' << std::endl << std::endl;
+
+      const std::string filename (create_filename (current_file_number));
+      if (Utilities::fexists(filename, this->get_mpi_communicator()))
+        lookup->load_file(filename,this->get_mpi_communicator());
+      else
+        AssertThrow(false,
+                    ExcMessage (std::string("GPlates data file <")
+                                +
+                                filename
+                                +
+                                "> not found!"));
+
+      // If the boundary condition is constant, switch off time_dependence
+      // immediately. If not, also load the second file for interpolation.
+      // This catches the case that many files are present, but the
+      // parameter file requests a single file.
+      if (create_filename (current_file_number) == create_filename (current_file_number+1))
+        {
+          end_time_dependence ();
+        }
+      else
+        {
+          const std::string filename (create_filename (next_file_number));
+          this->get_pcout() << std::endl << "   Loading GPlates data boundary file "
+                            << filename << '.' << std::endl << std::endl;
+          if (Utilities::fexists(filename, this->get_mpi_communicator()))
+            {
+              lookup.swap(old_lookup);
+              lookup->load_file(filename,this->get_mpi_communicator());
+            }
+          else
+            end_time_dependence ();
+        }
+    }
+
+
+
+    template <int dim>
+    std::string
+    GPlates<dim>::create_filename (const int timestep) const
+    {
+      std::string templ = data_directory+velocity_file_name;
+      const int size = templ.length();
+      std::vector<char> buffer(size+10);
+      snprintf (buffer.data(), size + 10, templ.c_str(), timestep);
+      std::string str_filename (buffer.data());
+      return str_filename;
+    }
+
+
+
+    template <int dim>
+    void
+    GPlates<dim>::update ()
+    {
+      const double time_since_start = this->get_time() - first_data_file_model_time;
+
+      if (time_dependent && (time_since_start >= 0.0))
+        {
+          const int time_steps_since_start = static_cast<int> (time_since_start / data_file_time_step);
+
+          // whether we need to update our data files. This looks so complicated
+          // because we need to catch increasing and decreasing file orders and all
+          // possible first_data_file_model_times and first_data_file_numbers.
+          const bool need_update = time_steps_since_start
+                                   > std::abs(current_file_number - first_data_file_number);
+
+          if (need_update)
+            {
+              // The last file, which was tried to be loaded was
+              // number current_file_number +/- 1, because current_file_number
+              // is the file older than the current model time
+              const int old_file_number =
+                (decreasing_file_order)
+                ?
+                (current_file_number - 1)
+                :
+                (current_file_number + 1);
+
+              // Calculate new file_number
+              current_file_number =
+                (decreasing_file_order)
+                ?
+                (first_data_file_number - time_steps_since_start)
+                :
+                (first_data_file_number + time_steps_since_start);
+
+              const bool load_both_files = std::abs(current_file_number - old_file_number) >= 1;
+
+              update_data(load_both_files);
+            }
+
+          time_weight = (time_since_start / data_file_time_step)
+                        - std::abs(current_file_number - first_data_file_number);
+
+          Assert ((0 <= time_weight) && (time_weight <= 1),
+                  ExcMessage (
+                    "Error in set_current_time. Time_weight has to be in [0,1]"));
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    GPlates<dim>::update_data (const bool load_both_files)
+    {
+      // If the time step was large enough to move forward more
+      // then one data file we need to load both current files
+      // to stay accurate in interpolation
+      if (load_both_files)
+        {
+          const std::string filename (create_filename (current_file_number));
+          this->get_pcout() << std::endl << "   Loading GPlates data boundary file "
+                            << filename << '.' << std::endl << std::endl;
+          if (Utilities::fexists(filename, this->get_mpi_communicator()))
+            {
+              lookup.swap(old_lookup);
+              lookup->load_file(filename,this->get_mpi_communicator());
+            }
+
+          // If loading current_time_step failed, end time dependent part with old_file_number.
+          else
+            end_time_dependence ();
+        }
+
+      // Now load the next data file. This part is the main purpose of this function.
+      const int next_file_number =
+        (decreasing_file_order) ?
+        current_file_number - 1
+        :
+        current_file_number + 1;
+
+      const std::string filename (create_filename (next_file_number));
+      this->get_pcout() << std::endl << "   Loading GPlates data boundary file "
+                        << filename << '.' << std::endl << std::endl;
+      if (Utilities::fexists(filename, this->get_mpi_communicator()))
+        {
+          lookup.swap(old_lookup);
+          lookup->load_file(filename,this->get_mpi_communicator());
+        }
+
+      // If next file does not exist, end time dependent part with current_time_step.
+      else
+        end_time_dependence ();
+    }
+
+
+
+    template <int dim>
+    void
+    GPlates<dim>::end_time_dependence ()
+    {
+      // no longer consider the problem time dependent from here on out
+      // this cancels all attempts to read files at the next time steps
+      time_dependent = false;
+      // Give warning if first processor
+      this->get_pcout() << std::endl
+                        << "   Loading new gplates velocity file did not succeed." << std::endl
+                        << "   Assuming constant boundary conditions for rest of model run."
+                        << std::endl << std::endl;
+    }
+
+
+
+    template <int dim>
+    Tensor<1,dim>
+    GPlates<dim>::
+    boundary_velocity (const types::boundary_id /*boundary_indicator*/,
+                       const Point<dim> &position) const
+    {
+      // We compare the depth of the current point to the lithosphere thickness.
+      // The depth is calculated using squares, sums, square-roots and differences
+      // of large numbers, and we possibly end up with a very small number close to
+      // the surface, thus rounding errors can get quite large. We therefore
+      // compare the depth to lithosphere_thickness plus a magic number, which we
+      // choose as 1e-7 times the maximal model depth, because we safely assume no
+      // model will have more than 1e7 quadrature points in depth direction.
+      // Without the magic number it may unintentionally happen that the GPlates
+      // velocities are not prescribed at every point on the surface.
+      const double magic_number = 1e-7 * this->get_geometry_model().maximal_depth();
+
+      if ((this->get_time() - first_data_file_model_time >= 0.0) && (this->get_geometry_model().depth(position) <= lithosphere_thickness + magic_number))
+        {
+          const Tensor<1,dim> data = velocity_scaling_factor * lookup->surface_velocity(position);
+
+          if (!time_dependent)
+            return data;
+
+          const Tensor<1,dim> old_data = velocity_scaling_factor * old_lookup->surface_velocity(position);
+
+          return time_weight * data + (1 - time_weight) * old_data;
+        }
+      else
+        return Tensor<1,dim>();
+    }
+
+
+
+    template <int dim>
+    void
+    GPlates<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Boundary velocity model");
+      {
+        prm.enter_subsection ("GPlates model");
+        {
+          prm.declare_entry ("Data directory",
+                             "$ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/",
+                             Patterns::DirectoryName (),
+                             "The name of a directory that contains the model data. This path "
+                             "may either be absolute (if starting with a '/') or relative to "
+                             "the current directory. The path may also include the special "
+                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                             "in which the ASPECT source files were located when ASPECT was "
+                             "compiled. This interpretation allows, for example, to reference "
+                             "files located in the `data/' subdirectory of ASPECT. ");
+          prm.declare_entry ("Velocity file name", "phi.%d",
+                             Patterns::Anything (),
+                             "The file name of the material data. Provide file in format: "
+                             "(Velocity file name).\\%d.gpml where \\%d is any sprintf integer "
+                             "qualifier, specifying the format of the current file number.");
+          prm.declare_entry ("First data file model time", "0.",
+                             Patterns::Double (0.),
+                             "Time from which on the velocity file with number 'First velocity "
+                             "file number' is used as boundary condition. Previous to this "
+                             "time, a no-slip boundary condition is assumed. Depending on the setting "
+                             "of the global 'Use years in output instead of seconds' flag "
+                             "in the input file, this number is either interpreted as seconds or as years.");
+          prm.declare_entry ("First data file number", "0",
+                             Patterns::Integer (),
+                             "Number of the first velocity file to be loaded when the model time "
+                             "is larger than 'First velocity file model time'.");
+          prm.declare_entry ("Decreasing file order", "false",
+                             Patterns::Bool (),
+                             "In some cases the boundary files are not numbered in increasing "
+                             "but in decreasing order (e.g. 'Ma BP'). If this flag is set to "
+                             "'True' the plugin will first load the file with the number "
+                             "'First velocity file number' and decrease the file number during "
+                             "the model run.");
+          prm.declare_entry ("Data file time step", "1e6",
+                             Patterns::Double (0.),
+                             "Time step between following velocity files. "
+                             "Depending on the setting of the global 'Use years in output instead of seconds' flag "
+                             "in the input file, this number is either interpreted as seconds or as years. "
+                             "The default is one million, i.e., either one million seconds or one million years.");
+          prm.declare_entry ("Scale factor", "1.",
+                             Patterns::Double (),
+                             "Scalar factor, which is applied to the boundary velocity. "
+                             "You might want to use this to scale the velocities to a "
+                             "reference model (e.g. with free-slip boundary) or another "
+                             "plate reconstruction.");
+          prm.declare_entry ("Point one", "1.570796,0.0",
+                             Patterns::Anything (),
+                             "Point that determines the plane in which a 2d model lies in. Has to be in the format `a,b' where a and b are theta (polar angle) and "
+                             "phi in radians. This value is not utilized in 3d geometries, and can therefore be set to the default or any user-defined quantity.");
+          prm.declare_entry ("Point two", "1.570796,1.570796",
+                             Patterns::Anything (),
+                             "Point that determines the plane in which a 2d model lies in. Has to be in the format `a,b' where a and b are theta (polar angle) and "
+                             "phi in radians. This value is not utilized in 3d geometries, and can therefore be set to the default or any user-defined quantity.");
+          prm.declare_entry ("Lithosphere thickness", "100000.",
+                             Patterns::Double (0.),
+                             "Determines the depth of the lithosphere, so that the GPlates velocities can be applied at the sides of the model "
+                             "as well as at the surface.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    GPlates<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary velocity model");
+      {
+        prm.enter_subsection("GPlates model");
+        {
+          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+
+          velocity_file_name         = prm.get        ("Velocity file name");
+          data_file_time_step        = prm.get_double ("Data file time step");
+          first_data_file_model_time = prm.get_double ("First data file model time");
+          first_data_file_number     = prm.get_integer("First data file number");
+          decreasing_file_order      = prm.get_bool   ("Decreasing file order");
+          velocity_scaling_factor    = prm.get_double ("Scale factor");
+          point1                     = prm.get        ("Point one");
+          point2                     = prm.get        ("Point two");
+          lithosphere_thickness      = prm.get_double ("Lithosphere thickness");
+
+          if (this->convert_output_to_years())
+            {
+              data_file_time_step        *= year_in_seconds;
+              first_data_file_model_time *= year_in_seconds;
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    namespace internal
+    {
+#define INSTANTIATE(dim) \
+  template class GPlatesLookup<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(GPlates,
+                                            "gplates",
+                                            "Implementation of a model in which the boundary "
+                                            "velocity is derived from files that are generated "
+                                            "by the GPlates program.")
+  }
+}
diff --git a/source/boundary_velocity/interface.cc.bak b/source/boundary_velocity/interface.cc.bak
new file mode 100644
index 00000000000..1c63df61c8f
--- /dev/null
+++ b/source/boundary_velocity/interface.cc.bak
@@ -0,0 +1,414 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    // ------------------------------ Manager -----------------------------
+    // -------------------------------- Deal with registering boundary_velocity models and automating
+    // -------------------------------- their setup and selection at run time
+
+    template <int dim>
+    Manager<dim>::~Manager()
+      = default;
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::update ()
+    {
+      for (const auto &boundary : boundary_velocity_objects)
+        for (const auto &p : boundary.second)
+          p->update();
+    }
+
+
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_boundary_velocity (const std::string &name,
+                                              const std::string &description,
+                                              void (*declare_parameters_function) (ParameterHandler &),
+                                              std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+
+    template <int dim>
+    Tensor<1,dim>
+    Manager<dim>::boundary_velocity (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position) const
+    {
+      typename std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>>::const_iterator boundary_plugins =
+        boundary_velocity_objects.find(boundary_indicator);
+
+      Assert(boundary_plugins != boundary_velocity_objects.end(),
+             ExcMessage("The boundary velocity manager class was asked for the "
+                        "boundary velocity at a boundary that contains no active "
+                        "boundary velocity plugin."));
+
+      Tensor<1,dim> velocity = Tensor<1,dim>();
+
+      for (const auto &plugin : boundary_plugins->second)
+        velocity += plugin->boundary_velocity(boundary_indicator,
+                                              position);
+
+      return velocity;
+    }
+
+
+
+    template <int dim>
+    const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> &
+    Manager<dim>::get_active_boundary_velocity_names () const
+    {
+      return boundary_velocity_indicators;
+    }
+
+
+
+    template <int dim>
+    const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>> &
+    Manager<dim>::get_active_boundary_velocity_conditions () const
+    {
+      return boundary_velocity_objects;
+    }
+
+
+
+    template <int dim>
+    const std::set<types::boundary_id> &
+    Manager<dim>::get_zero_boundary_velocity_indicators () const
+    {
+      return zero_velocity_boundary_indicators;
+    }
+
+
+
+    template <int dim>
+    const std::set<types::boundary_id> &
+    Manager<dim>::get_tangential_boundary_velocity_indicators () const
+    {
+      return tangential_velocity_boundary_indicators;
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Boundary velocity model");
+      {
+        prm.declare_entry ("Prescribed velocity boundary indicators", "",
+                           Patterns::Map (Patterns::Anything(),
+                                          Patterns::Selection(std::get<dim>(registered_plugins).get_pattern_of_names ())),
+                           "A comma separated list denoting those boundaries "
+                           "on which the velocity is prescribed, i.e., where unknown "
+                           "external forces act to prescribe a particular velocity. This is "
+                           "often used to prescribe a velocity that equals that of "
+                           "overlying plates."
+                           "\n\n"
+                           "The format of valid entries for this parameter is that of a map "
+                           "given as ``key1 [selector]: value1, key2 [selector]: value2, key3: value3, ...'' where "
+                           "each key must be a valid boundary indicator (which is either an "
+                           "integer or the symbolic name the geometry model in use may have "
+                           "provided for this part of the boundary) "
+                           "and each value must be one of the currently implemented boundary "
+                           "velocity models. ``selector'' is an optional string given as a subset "
+                           "of the letters `xyz' that allows you to apply the boundary conditions "
+                           "only to the components listed. As an example, '1 y: function' applies "
+                           "the type `function' to the y component on boundary 1. Without a selector "
+                           "it will affect all components of the velocity."
+                           "\n\n"
+                           "Note that the no-slip boundary condition is "
+                           "a special case of the current one where the prescribed velocity "
+                           "happens to be zero. It can thus be implemented by indicating that "
+                           "a particular boundary is part of the ones selected "
+                           "using the current parameter and using ``zero velocity'' as "
+                           "the boundary values. Alternatively, you can simply list the "
+                           "part of the boundary on which the velocity is to be zero with "
+                           "the parameter ``Zero velocity boundary indicator'' in the "
+                           "current parameter section."
+                           "\n\n"
+                           "Note that when ``Use years in output instead of seconds'' is set "
+                           "to true, velocity should be given in m/yr. "
+                           "The following boundary velocity models are available:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+        prm.declare_entry ("Zero velocity boundary indicators", "",
+                           Patterns::List (Patterns::Anything()),
+                           "A comma separated list of names denoting those boundaries "
+                           "on which the velocity is zero."
+                           "\n\n"
+                           "The names of the boundaries listed here can either by "
+                           "numbers (in which case they correspond to the numerical "
+                           "boundary indicators assigned by the geometry object), or they "
+                           "can correspond to any of the symbolic names the geometry object "
+                           "may have provided for each part of the boundary. You may want "
+                           "to compare this with the documentation of the geometry model you "
+                           "use in your model.");
+        prm.declare_entry ("Tangential velocity boundary indicators", "",
+                           Patterns::List (Patterns::Anything()),
+                           "A comma separated list of names denoting those boundaries "
+                           "on which the velocity is tangential and unrestrained, i.e., free-slip where "
+                           "no external forces act to prescribe a particular tangential "
+                           "velocity (although there is a force that requires the flow to "
+                           "be tangential)."
+                           "\n\n"
+                           "The names of the boundaries listed here can either by "
+                           "numbers (in which case they correspond to the numerical "
+                           "boundary indicators assigned by the geometry object), or they "
+                           "can correspond to any of the symbolic names the geometry object "
+                           "may have provided for each part of the boundary. You may want "
+                           "to compare this with the documentation of the geometry model you "
+                           "use in your model.");
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Boundary velocity model");
+      {
+        try
+          {
+            const std::vector<types::boundary_id> x_zero_velocity_boundary_indicators
+              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
+                                                                                    (prm.get ("Zero velocity boundary indicators")));
+            zero_velocity_boundary_indicators
+              = std::set<types::boundary_id> (x_zero_velocity_boundary_indicators.begin(),
+                                              x_zero_velocity_boundary_indicators.end());
+          }
+        catch (const std::string &error)
+          {
+            AssertThrow (false, ExcMessage ("While parsing the entry <Boundary velocity model/Zero velocity "
+                                            "boundary indicators>, there was an error. Specifically, "
+                                            "the conversion function complained as follows:\n\n"
+                                            + error));
+          }
+
+        try
+          {
+            const std::vector<types::boundary_id> x_tangential_velocity_boundary_indicators
+              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
+                                                                                    (prm.get ("Tangential velocity boundary indicators")));
+            tangential_velocity_boundary_indicators
+              = std::set<types::boundary_id> (x_tangential_velocity_boundary_indicators.begin(),
+                                              x_tangential_velocity_boundary_indicators.end());
+          }
+        catch (const std::string &error)
+          {
+            AssertThrow (false, ExcMessage ("While parsing the entry <Boundary velocity model/Tangential velocity "
+                                            "boundary indicators>, there was an error. Specifically, "
+                                            "the conversion function complained as follows:\n\n"
+                                            + error));
+          }
+
+        // find out which plugins are requested and the various other
+        // parameters we declare here
+        const std::vector<std::string> x_boundary_velocity_indicators
+          = Utilities::split_string_list(prm.get("Prescribed velocity boundary indicators"));
+
+        for (const auto &p : x_boundary_velocity_indicators)
+          {
+            // each entry has the format (white space is optional):
+            // <id> [x][y][z] : <value (might have spaces)>
+            //
+            // first tease apart the two halves
+            const std::vector<std::string> split_parts = Utilities::split_string_list (p, ':');
+            AssertThrow (split_parts.size() == 2,
+                         ExcMessage ("The format for prescribed velocity boundary indicators "
+                                     "requires that each entry has the form `"
+                                     "<id> [x][y][z] : <value>', but there does not "
+                                     "appear to be a colon in the entry <"
+                                     + p
+                                     + ">."));
+
+            // the easy part: get the value
+            const std::string &value = split_parts[1];
+
+            // now for the rest. since we don't know whether there is a
+            // component selector, start reading at the end and subtracting
+            // letters x, y and z
+            std::string key_and_comp = split_parts[0];
+            std::string comp;
+            while ((key_and_comp.size()>0) &&
+                   ((key_and_comp[key_and_comp.size()-1] == 'x')
+                    ||
+                    (key_and_comp[key_and_comp.size()-1] == 'y')
+                    ||
+                    ((key_and_comp[key_and_comp.size()-1] == 'z') && (dim==3))))
+              {
+                comp += key_and_comp[key_and_comp.size()-1];
+                key_and_comp.erase (--key_and_comp.end());
+              }
+
+            // we've stopped reading component selectors now. there are three
+            // possibilities:
+            // - no characters are left. this means that key_and_comp only
+            //   consisted of a single word that only consisted of 'x', 'y'
+            //   and 'z's. then this would have been a mistake to classify
+            //   as a component selector, and we better undo it
+            // - the last character of key_and_comp is not a whitespace. this
+            //   means that the last word in key_and_comp ended in an 'x', 'y'
+            //   or 'z', but this was not meant to be a component selector.
+            //   in that case, put these characters back.
+            // - otherwise, we split successfully. eat spaces that may be at
+            //   the end of key_and_comp to get key
+            if (key_and_comp.size() == 0)
+              key_and_comp.swap (comp);
+            else if (key_and_comp[key_and_comp.size()-1] != ' ')
+              {
+                key_and_comp += comp;
+                comp = "";
+              }
+            else
+              {
+                while ((key_and_comp.size()>0) && (key_and_comp[key_and_comp.size()-1] == ' '))
+                  key_and_comp.erase (--key_and_comp.end());
+              }
+
+            // finally, try to translate the key into a boundary_id. then
+            // make sure we haven't seen it yet
+            types::boundary_id boundary_id;
+            try
+              {
+                boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id(key_and_comp);
+              }
+            catch (const std::string &error)
+              {
+                AssertThrow (false, ExcMessage ("While parsing the entry <Boundary velocity model/Prescribed "
+                                                "velocity indicators>, there was an error. Specifically, "
+                                                "the conversion function complained as follows:\n\n"
+                                                + error));
+              }
+
+            if (boundary_velocity_indicators.find(boundary_id) != boundary_velocity_indicators.end())
+              {
+                Assert(boundary_velocity_indicators[boundary_id].first == comp,
+                       ExcMessage("Different velocity plugins for the same boundary have to have the same component selector. "
+                                  "This was not the case for boundary: " + key_and_comp +
+                                  ", for plugin: " + value + ", with component selector: " + comp));
+
+                // finally, put it into the list
+                boundary_velocity_indicators[boundary_id].second.push_back(value);
+              }
+            else
+              {
+                boundary_velocity_indicators[boundary_id] = std::make_pair(comp,std::vector<std::string>(1,value));
+              }
+          }
+      }
+      prm.leave_subsection();
+
+      // go through the list, create objects and let them parse
+      // their own parameters
+      for (const auto &boundary_id : boundary_velocity_indicators)
+        {
+          for (const auto &name : boundary_id.second.second)
+            {
+              boundary_velocity_objects[boundary_id.first].push_back(
+                std::unique_ptr<Interface<dim>> (std::get<dim>(registered_plugins)
+                                                  .create_plugin (name,
+                                                                  "Boundary velocity::Model names")));
+
+              if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(boundary_velocity_objects[boundary_id.first].back().get()))
+                sim->initialize_simulator (this->get_simulator());
+
+              boundary_velocity_objects[boundary_id.first].back()->parse_parameters (prm);
+              boundary_velocity_objects[boundary_id.first].back()->initialize ();
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary velocity interface",
+                                                            out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryVelocity::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryVelocity::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<BoundaryVelocity::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<BoundaryVelocity::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace BoundaryVelocity
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/boundary_velocity/zero_velocity.cc.bak b/source/boundary_velocity/zero_velocity.cc.bak
new file mode 100644
index 00000000000..23b58e8e952
--- /dev/null
+++ b/source/boundary_velocity/zero_velocity.cc.bak
@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_velocity/zero_velocity.h>
+
+
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    template <int dim>
+    Tensor<1,dim>
+    ZeroVelocity<dim>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<dim> &) const
+    {
+      // return a zero tensor regardless of position
+      return Tensor<1,dim>();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryVelocity
+  {
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(ZeroVelocity,
+                                            "zero velocity",
+                                            "Implementation of a model in which the boundary "
+                                            "velocity is zero. This is commonly referred to as "
+                                            "a ``stick boundary condition'', indicating that "
+                                            "the material ``sticks'' to the material on the "
+                                            "other side of the boundary.")
+  }
+}
diff --git a/source/citation_info.cc.bak b/source/citation_info.cc.bak
new file mode 100644
index 00000000000..f047bab8f9a
--- /dev/null
+++ b/source/citation_info.cc.bak
@@ -0,0 +1,55 @@
+/*
+  Copyright (C) 2017 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/citation_info.h>
+#include <aspect/revision.h>
+
+#include <iostream>
+#include <set>
+
+namespace CitationInfo
+{
+  std::set<std::string> citation_ids;
+
+  const std::string get_url_part ()
+  {
+    // version:
+    std::string url = "citing.html?ver=";
+    url += ASPECT_PACKAGE_VERSION;
+
+    // all ids:
+    for (const auto &id : citation_ids)
+      url += "&" + id + "=1";
+
+    // sha1:
+    url += "&sha=";
+    url += ASPECT_GIT_SHORTREV;
+
+    // src:
+    url += "&src=code";
+
+    return url;
+  }
+
+  void add (const std::string &id)
+  {
+    citation_ids.insert(id);
+  }
+}
diff --git a/source/compat.cc.bak b/source/compat.cc.bak
new file mode 100644
index 00000000000..bb71563d160
--- /dev/null
+++ b/source/compat.cc.bak
@@ -0,0 +1,800 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/compat.h>
+
+// deal.II versions up to 9.5 had a poorly designed interface of the
+// SphericalManifold class that made it impossible for us to use.
+// This file thus contains a copy of it.
+#if !DEAL_II_VERSION_GTE(9,6,0)
+
+namespace aspect
+{
+  namespace
+  {
+    template <int dim, int spacedim>
+    bool
+    spherical_face_is_horizontal(
+      const typename Triangulation<dim, spacedim>::face_iterator &face,
+      const Point<spacedim>                                      &manifold_center)
+    {
+      // We test whether a face is horizontal by checking that the vertices
+      // all have roughly the same distance from the center: If the
+      // maximum deviation for the distances from the vertices to the
+      // center is less than 1.e-5 of the distance between vertices (as
+      // measured by the minimum distance from any of the other vertices
+      // to the first vertex), then we call this a horizontal face.
+      constexpr unsigned int n_vertices =
+        GeometryInfo<spacedim>::vertices_per_face;
+      std::array<double, n_vertices>     sqr_distances_to_center;
+      std::array<double, n_vertices - 1> sqr_distances_to_first_vertex;
+      sqr_distances_to_center[0] =
+        (face->vertex(0) - manifold_center).norm_square();
+      for (unsigned int i = 1; i < n_vertices; ++i)
+        {
+          sqr_distances_to_center[i] =
+            (face->vertex(i) - manifold_center).norm_square();
+          sqr_distances_to_first_vertex[i - 1] =
+            (face->vertex(i) - face->vertex(0)).norm_square();
+        }
+      const auto minmax_sqr_distance =
+        std::minmax_element(sqr_distances_to_center.begin(),
+                            sqr_distances_to_center.end());
+      const auto min_sqr_distance_to_first_vertex =
+        std::min_element(sqr_distances_to_first_vertex.begin(),
+                         sqr_distances_to_first_vertex.end());
+
+      return (*minmax_sqr_distance.second - *minmax_sqr_distance.first <
+              1.e-10 * *min_sqr_distance_to_first_vertex);
+    }
+  } // namespace
+
+
+  // ============================================================
+  // SphericalManifold
+  // ============================================================
+
+  template <int dim, int spacedim>
+  SphericalManifold<dim, spacedim>::SphericalManifold(
+    const Point<spacedim> center)
+    : center(center)
+    , polar_manifold(center)
+  {}
+
+
+
+  template <int dim, int spacedim>
+  std::unique_ptr<Manifold<dim, spacedim>>
+  SphericalManifold<dim, spacedim>::clone() const
+  {
+    return std::make_unique<SphericalManifold<dim, spacedim>>(*this);
+  }
+
+
+
+  template <int dim, int spacedim>
+  Point<spacedim>
+  SphericalManifold<dim, spacedim>::get_intermediate_point(
+    const Point<spacedim> &p1,
+    const Point<spacedim> &p2,
+    const double           w) const
+  {
+    const double tol = 1e-10;
+
+    if ((p1 - p2).norm_square() < tol * tol || std::abs(w) < tol)
+      return p1;
+    else if (std::abs(w - 1.0) < tol)
+      return p2;
+
+    // If the points are one dimensional then there is no need for anything but
+    // a linear combination.
+    if (spacedim == 1)
+      return Point<spacedim>(w * p2 + (1 - w) * p1);
+
+    const Tensor<1, spacedim> v1 = p1 - center;
+    const Tensor<1, spacedim> v2 = p2 - center;
+    const double              r1 = v1.norm();
+    const double              r2 = v2.norm();
+
+    Assert(r1 > tol && r2 > tol,
+           ExcMessage("p1 and p2 cannot coincide with the center."));
+
+    const Tensor<1, spacedim> e1 = v1 / r1;
+    const Tensor<1, spacedim> e2 = v2 / r2;
+
+    // Find the cosine of the angle gamma described by v1 and v2.
+    const double cosgamma = e1 * e2;
+
+    // Points are collinear with the center (allow for 8*eps as a tolerance)
+    if (cosgamma < -1 + 8. * std::numeric_limits<double>::epsilon())
+      return center;
+
+    // Points are along a line, in which case e1 and e2 are essentially the same.
+    if (cosgamma > 1 - 8. * std::numeric_limits<double>::epsilon())
+      return Point<spacedim>(center + w * v2 + (1 - w) * v1);
+
+    // Find the angle sigma that corresponds to arclength equal to w. acos
+    // should never be undefined because we have ruled out the two special cases
+    // above.
+    const double sigma = w * std::acos(cosgamma);
+
+    // Normal to v1 in the plane described by v1,v2,and the origin.
+    // Since p1 and p2 do not coincide n is not zero and well defined.
+    Tensor<1, spacedim> n      = v2 - (v2 * e1) * e1;
+    const double        n_norm = n.norm();
+    Assert(n_norm > 0,
+           ExcInternalError("n should be different from the null vector. "
+                            "Probably, this means v1==v2 or v2==0."));
+
+    n /= n_norm;
+
+    // Find the point Q along O,v1 such that
+    // P1,V,P2 has measure sigma.
+    const Tensor<1, spacedim> P = std::cos(sigma) * e1 + std::sin(sigma) * n;
+
+    // Project this point on the manifold.
+    return Point<spacedim>(center + (w * r2 + (1.0 - w) * r1) * P);
+  }
+
+
+
+  template <int dim, int spacedim>
+  Tensor<1, spacedim>
+  SphericalManifold<dim, spacedim>::get_tangent_vector(
+    const Point<spacedim> &p1,
+    const Point<spacedim> &p2) const
+  {
+    const double tol = 1e-10;
+    (void)tol;
+
+    Assert(p1 != p2, ExcMessage("p1 and p2 should not concide."));
+
+    const Tensor<1, spacedim> v1 = p1 - center;
+    const Tensor<1, spacedim> v2 = p2 - center;
+    const double              r1 = v1.norm();
+    const double              r2 = v2.norm();
+
+    Assert(r1 > tol, ExcMessage("p1 cannot coincide with the center."));
+
+    Assert(r2 > tol, ExcMessage("p2 cannot coincide with the center."));
+
+    const Tensor<1, spacedim> e1 = v1 / r1;
+    const Tensor<1, spacedim> e2 = v2 / r2;
+
+    // Find the cosine of the angle gamma described by v1 and v2.
+    const double cosgamma = e1 * e2;
+
+    Assert(cosgamma > -1 + 8. * std::numeric_limits<double>::epsilon(),
+           ExcMessage("p1 and p2 cannot lie on the same diameter and be opposite "
+                      "respect to the center."));
+
+    if (cosgamma > 1 - 8. * std::numeric_limits<double>::epsilon())
+      return v2 - v1;
+
+    // Normal to v1 in the plane described by v1,v2,and the origin.
+    // Since p1 and p2 do not coincide n is not zero and well defined.
+    Tensor<1, spacedim> n      = v2 - (v2 * e1) * e1;
+    const double        n_norm = n.norm();
+    Assert(n_norm > 0,
+           ExcInternalError("n should be different from the null vector. "
+                            "Probably, this means v1==v2 or v2==0."));
+
+    n /= n_norm;
+
+    // this is the derivative of the geodesic in get_intermediate_point
+    // derived with respect to w and inserting w=0.
+    const double gamma = std::acos(cosgamma);
+    return (r2 - r1) * e1 + r1 * gamma * n;
+  }
+
+
+
+  template <int dim, int spacedim>
+  Tensor<1, spacedim>
+  SphericalManifold<dim, spacedim>::normal_vector(
+    const typename Triangulation<dim, spacedim>::face_iterator &face,
+    const Point<spacedim>                                      &p) const
+  {
+    // Let us first test whether we are on a "horizontal" face
+    // (tangential to the sphere).  In this case, the normal vector is
+    // easy to compute since it is proportional to the vector from the
+    // center to the point 'p'.
+    if (spherical_face_is_horizontal<dim, spacedim>(face, center))
+      {
+        // So, if this is a "horizontal" face, then just compute the normal
+        // vector as the one from the center to the point 'p', adequately
+        // scaled.
+        const Tensor<1, spacedim> unnormalized_spherical_normal = p - center;
+        const Tensor<1, spacedim> normalized_spherical_normal =
+          unnormalized_spherical_normal / unnormalized_spherical_normal.norm();
+        return normalized_spherical_normal;
+      }
+    else
+      // If it is not a horizontal face, just use the machinery of the
+      // base class.
+      return Manifold<dim, spacedim>::normal_vector(face, p);
+
+    return Tensor<1, spacedim>();
+  }
+
+
+
+  template <>
+  void
+  SphericalManifold<1, 1>::get_normals_at_vertices(
+    const Triangulation<1>::face_iterator &,
+    Manifold<1, 1>::FaceVertexNormals &) const
+  {
+    Assert(false, ExcImpossibleInDim(1));
+  }
+
+
+
+  template <>
+  void
+  SphericalManifold<1, 2>::get_normals_at_vertices(
+    const Triangulation<1, 2>::face_iterator &,
+    Manifold<1, 2>::FaceVertexNormals &) const
+  {
+    Assert(false, ExcImpossibleInDim(1));
+  }
+
+
+
+  template <int dim, int spacedim>
+  void
+  SphericalManifold<dim, spacedim>::get_normals_at_vertices(
+    const typename Triangulation<dim, spacedim>::face_iterator &face,
+    typename Manifold<dim, spacedim>::FaceVertexNormals &face_vertex_normals)
+  const
+  {
+    // Let us first test whether we are on a "horizontal" face
+    // (tangential to the sphere).  In this case, the normal vector is
+    // easy to compute since it is proportional to the vector from the
+    // center to the point 'p'.
+    if (spherical_face_is_horizontal<dim, spacedim>(face, center))
+      {
+        // So, if this is a "horizontal" face, then just compute the normal
+        // vector as the one from the center to the point 'p', adequately
+        // scaled.
+        for (unsigned int vertex = 0;
+             vertex < GeometryInfo<spacedim>::vertices_per_face;
+             ++vertex)
+          face_vertex_normals[vertex] = face->vertex(vertex) - center;
+      }
+    else
+      Manifold<dim, spacedim>::get_normals_at_vertices(face, face_vertex_normals);
+  }
+
+
+
+  template <int dim, int spacedim>
+  void
+  SphericalManifold<dim, spacedim>::get_new_points(
+    const ArrayView<const Point<spacedim>> &surrounding_points,
+    const Table<2, double>                 &weights,
+    ArrayView<Point<spacedim>>              new_points) const
+  {
+    AssertDimension(new_points.size(), weights.size(0));
+    AssertDimension(surrounding_points.size(), weights.size(1));
+
+    do_get_new_points(surrounding_points, make_array_view(weights), new_points);
+
+    return;
+  }
+
+
+
+  template <int dim, int spacedim>
+  Point<spacedim>
+  SphericalManifold<dim, spacedim>::get_new_point(
+    const ArrayView<const Point<spacedim>> &vertices,
+    const ArrayView<const double>          &weights) const
+  {
+    // To avoid duplicating all of the logic in get_new_points, simply call it
+    // for one position.
+    Point<spacedim> new_point;
+    do_get_new_points(vertices,
+                      weights,
+                      make_array_view(&new_point, &new_point + 1));
+
+    return new_point;
+  }
+
+
+
+  namespace internal
+  {
+    // Rotate a given unit vector u around the axis dir
+    // where the angle is given by the length of dir.
+    // This is the exponential map for a sphere.
+    Tensor<1, 3>
+    apply_exponential_map(const Tensor<1, 3> &u, const Tensor<1, 3> &dir)
+    {
+      const double theta = dir.norm();
+      if (theta < 1.e-10)
+        {
+          return u;
+        }
+      else
+        {
+          const Tensor<1, 3> dirUnit = dir / theta;
+          const Tensor<1, 3> tmp =
+            std::cos(theta) * u + std::sin(theta) * dirUnit;
+          return tmp / tmp.norm();
+        }
+    }
+
+
+    // Returns the direction to go from v to u
+    // projected to the plane perpendicular to the unit vector v.
+    // This one is more stable when u and v are nearly equal.
+    Tensor<1, 3>
+    projected_direction(const Tensor<1, 3> &u, const Tensor<1, 3> &v)
+    {
+      Tensor<1, 3> ans = u - v;
+      ans -= (ans * v) * v;
+      return ans; // ans = (u-v) - ((u-v)*v)*v
+    }
+
+
+    // helper function to compute a vector orthogonal to a given one.
+    // does nothing unless spacedim == 3.
+    template <int spacedim>
+    Point<spacedim>
+    compute_normal(const Tensor<1, spacedim> & /*vector*/,
+                   bool /*normalize*/ = false)
+    {
+      return {};
+    }
+
+    Point<3>
+    compute_normal(const Tensor<1, 3> &vector, bool normalize = false)
+    {
+      Assert(vector.norm_square() != 0.,
+             ExcMessage("The direction parameter must not be zero!"));
+      Point<3> normal;
+      if (std::abs(vector[0]) >= std::abs(vector[1]) &&
+          std::abs(vector[0]) >= std::abs(vector[2]))
+        {
+          normal[1] = -1.;
+          normal[2] = -1.;
+          normal[0] = (vector[1] + vector[2]) / vector[0];
+        }
+      else if (std::abs(vector[1]) >= std::abs(vector[0]) &&
+               std::abs(vector[1]) >= std::abs(vector[2]))
+        {
+          normal[0] = -1.;
+          normal[2] = -1.;
+          normal[1] = (vector[0] + vector[2]) / vector[1];
+        }
+      else
+        {
+          normal[0] = -1.;
+          normal[1] = -1.;
+          normal[2] = (vector[0] + vector[1]) / vector[2];
+        }
+      if (normalize)
+        normal /= normal.norm();
+      return normal;
+    }
+
+
+    namespace SphericalManifold
+    {
+      namespace
+      {
+        template <int spacedim>
+        Point<spacedim>
+        do_get_new_point(
+          const ArrayView<const Tensor<1, spacedim>> & /*directions*/,
+          const ArrayView<const double> & /*distances*/,
+          const ArrayView<const double> & /*weights*/,
+          const Point<spacedim> & /*candidate_point*/)
+        {
+          Assert(false, ExcNotImplemented());
+          return {};
+        }
+
+        template <>
+        Point<3>
+        do_get_new_point(const ArrayView<const Tensor<1, 3>> &directions,
+                         const ArrayView<const double>       &distances,
+                         const ArrayView<const double>       &weights,
+                         const Point<3>                      &candidate_point)
+        {
+          (void)distances;
+
+          AssertDimension(directions.size(), distances.size());
+          AssertDimension(directions.size(), weights.size());
+
+          Point<3>           candidate       = candidate_point;
+          const unsigned int n_merged_points = directions.size();
+          const double       tolerance       = 1e-10;
+          const int          max_iterations  = 10;
+
+          {
+            // If the candidate happens to coincide with a normalized
+            // direction, we return it. Otherwise, the Hessian would be singular.
+            for (unsigned int i = 0; i < n_merged_points; ++i)
+              {
+                const double squared_distance =
+                  (candidate - directions[i]).norm_square();
+                if (squared_distance < tolerance * tolerance)
+                  return candidate;
+              }
+
+            // check if we only have two points now, in which case we can use the
+            // get_intermediate_point function
+            if (n_merged_points == 2)
+              {
+                static const dealii::SphericalManifold<3, 3> unit_manifold;
+                Assert(std::abs(weights[0] + weights[1] - 1.0) < 1e-13,
+                       ExcMessage("Weights do not sum up to 1"));
+                const Point<3> intermediate =
+                  unit_manifold.get_intermediate_point(Point<3>(directions[0]),
+                                                       Point<3>(directions[1]),
+                                                       weights[1]);
+                return intermediate;
+              }
+
+            Tensor<1, 3> vPerp;
+            Tensor<2, 2> Hessian;
+            Tensor<1, 2> gradient;
+            Tensor<1, 2> gradlocal;
+
+            // On success we exit the loop early.
+            // Otherwise, we just take the result after max_iterations steps.
+            for (unsigned int i = 0; i < max_iterations; ++i)
+              {
+                // Step 2a: Find new descent direction
+
+                // Get local basis for the estimate candidate
+                const Tensor<1, 3> Clocalx = internal::compute_normal(candidate);
+                const Tensor<1, 3> Clocaly = cross_product_3d(candidate, Clocalx);
+
+                // For each vertices vector, compute the tangent vector from
+                // candidate towards the vertices vector -- its length is the
+                // spherical length from candidate to the vertices vector. Then
+                // compute its contribution to the Hessian.
+                gradient = 0.;
+                Hessian  = 0.;
+                for (unsigned int i = 0; i < n_merged_points; ++i)
+                  if (std::abs(weights[i]) > 1.e-15)
+                    {
+                      vPerp =
+                        internal::projected_direction(directions[i], candidate);
+                      const double sinthetaSq = vPerp.norm_square();
+                      const double sintheta   = std::sqrt(sinthetaSq);
+                      if (sintheta < tolerance)
+                        {
+                          Hessian[0][0] += weights[i];
+                          Hessian[1][1] += weights[i];
+                        }
+                      else
+                        {
+                          const double costheta = (directions[i]) * candidate;
+                          const double theta    = std::atan2(sintheta, costheta);
+                          const double sincthetaInv = theta / sintheta;
+
+                          const double cosphi = vPerp * Clocalx;
+                          const double sinphi = vPerp * Clocaly;
+
+                          gradlocal[0] = cosphi;
+                          gradlocal[1] = sinphi;
+                          gradient += (weights[i] * sincthetaInv) * gradlocal;
+
+                          const double wt       = weights[i] / sinthetaSq;
+                          const double sinphiSq = sinphi * sinphi;
+                          const double cosphiSq = cosphi * cosphi;
+                          const double tt       = sincthetaInv * costheta;
+                          const double offdiag =
+                            cosphi * sinphi * wt * (1.0 - tt);
+                          Hessian[0][0] += wt * (cosphiSq + tt * sinphiSq);
+                          Hessian[0][1] += offdiag;
+                          Hessian[1][0] += offdiag;
+                          Hessian[1][1] += wt * (sinphiSq + tt * cosphiSq);
+                        }
+                    }
+
+                Assert(determinant(Hessian) > tolerance, ExcInternalError());
+
+                const Tensor<2, 2> inverse_Hessian = invert(Hessian);
+
+                const Tensor<1, 2> xDisplocal = inverse_Hessian * gradient;
+                const Tensor<1, 3> xDisp =
+                  xDisplocal[0] * Clocalx + xDisplocal[1] * Clocaly;
+
+                // Step 2b: rotate candidate in direction xDisp for a new
+                // candidate.
+                const Point<3> candidateOld = candidate;
+                candidate =
+                  Point<3>(internal::apply_exponential_map(candidate, xDisp));
+
+                // Step 2c: return the new candidate if we didn't move
+                if ((candidate - candidateOld).norm_square() <
+                    tolerance * tolerance)
+                  break;
+              }
+          }
+          return candidate;
+        }
+      } // namespace
+    }   // namespace SphericalManifold
+  } // namespace internal
+
+
+
+  template <int dim, int spacedim>
+  void
+  SphericalManifold<dim, spacedim>::do_get_new_points(
+    const ArrayView<const Point<spacedim>> &surrounding_points,
+    const ArrayView<const double>          &weights,
+    ArrayView<Point<spacedim>>              new_points) const
+  {
+    AssertDimension(weights.size(),
+                    new_points.size() * surrounding_points.size());
+    const unsigned int weight_rows    = new_points.size();
+    const unsigned int weight_columns = surrounding_points.size();
+
+    if (surrounding_points.size() == 2)
+      {
+        for (unsigned int row = 0; row < weight_rows; ++row)
+          new_points[row] =
+            SphericalManifold<dim, spacedim>::get_intermediate_point(surrounding_points[0],
+                                                                     surrounding_points[1],
+                                                                     weights[row * weight_columns + 1]);
+        return;
+      }
+
+    boost::container::small_vector<std::pair<double, Tensor<1, spacedim>>, 100>
+    new_candidates(new_points.size());
+    boost::container::small_vector<Tensor<1, spacedim>, 100> directions(
+      surrounding_points.size(), Point<spacedim>());
+    boost::container::small_vector<double, 100> distances(
+      surrounding_points.size(), 0.0);
+    double max_distance = 0.;
+    for (unsigned int i = 0; i < surrounding_points.size(); ++i)
+      {
+        directions[i] = surrounding_points[i] - center;
+        distances[i]  = directions[i].norm();
+
+        if (distances[i] != 0.)
+          directions[i] /= distances[i];
+        else
+          Assert(false,
+                 ExcMessage("One of the vertices coincides with the center. "
+                            "This is not allowed!"));
+
+        // Check if an estimate is good enough,
+        // this is often the case for sufficiently refined meshes.
+        for (unsigned int k = 0; k < i; ++k)
+          {
+            const double squared_distance =
+              (directions[i] - directions[k]).norm_square();
+            max_distance = std::max(max_distance, squared_distance);
+          }
+      }
+
+    // Step 1: Check for some special cases, create simple linear guesses
+    // otherwise.
+    const double                              tolerance = 1e-10;
+    boost::container::small_vector<bool, 100> accurate_point_was_found(
+      new_points.size(), false);
+    const ArrayView<const Tensor<1, spacedim>> array_directions =
+      make_array_view(directions.begin(), directions.end());
+    const ArrayView<const double> array_distances =
+      make_array_view(distances.begin(), distances.end());
+    for (unsigned int row = 0; row < weight_rows; ++row)
+      {
+        new_candidates[row] =
+          guess_new_point(array_directions,
+                          array_distances,
+                          ArrayView<const double>(&weights[row * weight_columns],
+                                                  weight_columns));
+
+        // If the candidate is the center, mark it as found to avoid entering
+        // the Newton iteration in step 2, which would crash.
+        if (new_candidates[row].first == 0.0)
+          {
+            new_points[row]               = center;
+            accurate_point_was_found[row] = true;
+            continue;
+          }
+
+        // If not in 3d, just use the implementation from PolarManifold
+        // after we verified that the candidate is not the center.
+        if (spacedim < 3)
+          new_points[row] = polar_manifold.get_new_point(
+                              surrounding_points,
+                              ArrayView<const double>(&weights[row * weight_columns],
+                                                      weight_columns));
+      }
+
+    // In this case, we treated the case that the candidate is the center and
+    // obtained the new locations from the PolarManifold object otherwise.
+    if (spacedim < 3)
+      return;
+    else
+      {
+        // If all the points are close to each other, we expect the estimate to
+        // be good enough. This tolerance was chosen such that the first iteration
+        // for a at least three time refined HyperShell mesh with radii .5 and 1.
+        // doesn't already succeed.
+        if (max_distance < 2e-2)
+          {
+            for (unsigned int row = 0; row < weight_rows; ++row)
+              new_points[row] =
+                center + new_candidates[row].first * new_candidates[row].second;
+
+            return;
+          }
+
+        // Step 2:
+        // Do more expensive Newton-style iterations to improve the estimate.
+
+        // Search for duplicate directions and merge them to minimize the cost of
+        // the get_new_point function call below.
+        boost::container::small_vector<double, 1000> merged_weights(
+          weights.size());
+        boost::container::small_vector<Tensor<1, spacedim>, 100>
+        merged_directions(surrounding_points.size(), Point<spacedim>());
+        boost::container::small_vector<double, 100> merged_distances(
+          surrounding_points.size(), 0.0);
+
+        unsigned int n_unique_directions = 0;
+        for (unsigned int i = 0; i < surrounding_points.size(); ++i)
+          {
+            bool found_duplicate = false;
+
+            // This inner loop is of $O(N^2)$ complexity, but
+            // surrounding_points.size() is usually at most 8 points large.
+            for (unsigned int j = 0; j < n_unique_directions; ++j)
+              {
+                const double squared_distance =
+                  (directions[i] - directions[j]).norm_square();
+                if (!found_duplicate && squared_distance < 1e-28)
+                  {
+                    found_duplicate = true;
+                    for (unsigned int row = 0; row < weight_rows; ++row)
+                      merged_weights[row * weight_columns + j] +=
+                        weights[row * weight_columns + i];
+                  }
+              }
+
+            if (found_duplicate == false)
+              {
+                merged_directions[n_unique_directions] = directions[i];
+                merged_distances[n_unique_directions]  = distances[i];
+                for (unsigned int row = 0; row < weight_rows; ++row)
+                  merged_weights[row * weight_columns + n_unique_directions] =
+                    weights[row * weight_columns + i];
+
+                ++n_unique_directions;
+              }
+          }
+
+        // Search for duplicate weight rows and merge them to minimize the cost of
+        // the get_new_point function call below.
+        boost::container::small_vector<unsigned int, 100> merged_weights_index(
+          new_points.size(), numbers::invalid_unsigned_int);
+        for (unsigned int row = 0; row < weight_rows; ++row)
+          {
+            for (unsigned int existing_row = 0; existing_row < row;
+                 ++existing_row)
+              {
+                bool identical_weights = true;
+
+                for (unsigned int weight_index = 0;
+                     weight_index < n_unique_directions;
+                     ++weight_index)
+                  if (std::abs(
+                        merged_weights[row * weight_columns + weight_index] -
+                        merged_weights[existing_row * weight_columns +
+                                       weight_index]) > tolerance)
+                    {
+                      identical_weights = false;
+                      break;
+                    }
+
+                if (identical_weights)
+                  {
+                    merged_weights_index[row] = existing_row;
+                    break;
+                  }
+              }
+          }
+
+        // Note that we only use the n_unique_directions first entries in the
+        // ArrayView
+        const ArrayView<const Tensor<1, spacedim>> array_merged_directions =
+          make_array_view(merged_directions.begin(),
+                          merged_directions.begin() + n_unique_directions);
+        const ArrayView<const double> array_merged_distances =
+          make_array_view(merged_distances.begin(),
+                          merged_distances.begin() + n_unique_directions);
+
+        for (unsigned int row = 0; row < weight_rows; ++row)
+          if (!accurate_point_was_found[row])
+            {
+              if (merged_weights_index[row] == numbers::invalid_unsigned_int)
+                {
+                  const ArrayView<const double> array_merged_weights(
+                    &merged_weights[row * weight_columns], n_unique_directions);
+                  new_candidates[row].second =
+                    internal::SphericalManifold::do_get_new_point(
+                      array_merged_directions,
+                      array_merged_distances,
+                      array_merged_weights,
+                      Point<spacedim>(new_candidates[row].second));
+                }
+              else
+                new_candidates[row].second =
+                  new_candidates[merged_weights_index[row]].second;
+
+              new_points[row] =
+                center + new_candidates[row].first * new_candidates[row].second;
+            }
+      }
+  }
+
+
+
+  template <int dim, int spacedim>
+  std::pair<double, Tensor<1, spacedim>>
+  SphericalManifold<dim, spacedim>::guess_new_point(
+    const ArrayView<const Tensor<1, spacedim>> &directions,
+    const ArrayView<const double>              &distances,
+    const ArrayView<const double>              &weights) const
+  {
+    const double        tolerance = 1e-10;
+    double              rho       = 0.;
+    Tensor<1, spacedim> candidate;
+
+    // Perform a simple average ...
+    double total_weights = 0.;
+    for (unsigned int i = 0; i < directions.size(); ++i)
+      {
+        // if one weight is one, return its direction
+        if (std::abs(1 - weights[i]) < tolerance)
+          return std::make_pair(distances[i], directions[i]);
+
+        rho += distances[i] * weights[i];
+        candidate += directions[i] * weights[i];
+        total_weights += weights[i];
+      }
+
+    // ... and normalize if the candidate is different from the origin.
+    const double norm = candidate.norm();
+    if (norm == 0.)
+      return std::make_pair(0.0, Point<spacedim>());
+    candidate /= norm;
+    rho /= total_weights;
+
+    return std::make_pair(rho, candidate);
+  }
+
+
+  template class SphericalManifold<2>;
+  template class SphericalManifold<3>;
+}
+
+#endif
diff --git a/source/fe_variable_collection.cc.bak b/source/fe_variable_collection.cc.bak
new file mode 100644
index 00000000000..ef8b9030d77
--- /dev/null
+++ b/source/fe_variable_collection.cc.bak
@@ -0,0 +1,268 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/global.h>
+#include <aspect/fe_variable_collection.h>
+
+namespace aspect
+{
+
+
+
+  template <int dim>
+  VariableDeclaration<dim>::VariableDeclaration(const std::string &name,
+                                                const std::shared_ptr<FiniteElement<dim>> &fe,
+                                                const unsigned int multiplicity,
+                                                const unsigned int n_blocks)
+    : name(name),
+      fe(fe),
+      multiplicity(multiplicity),
+      n_blocks(n_blocks)
+  {
+    // TODO: non-scalar FEs are not tested and can not be split into >1 block in general
+    Assert(fe->n_components() == 1, ExcNotImplemented());
+
+    Assert(n_blocks == 0
+           || n_blocks == 1
+           || n_blocks == n_components(),
+           ExcMessage("A Variable can only have 0, 1, or n_components() number of blocks."));
+  }
+
+  template <int dim>
+  VariableDeclaration<dim>::VariableDeclaration()
+    = default;
+
+  template <int dim>
+  unsigned int
+  VariableDeclaration<dim>::n_components() const
+  {
+    return fe->n_components() * multiplicity;
+  }
+
+
+  template <int dim>
+  FEVariable<dim>::FEVariable(const VariableDeclaration<dim> &fe_variable,
+                              const unsigned int component_index,
+                              const unsigned int block_index,
+                              const unsigned int base_index)
+    : VariableDeclaration<dim> (fe_variable),
+      first_component_index (component_index),
+      block_index (block_index),
+      base_index (base_index),
+      scalar_extractor ( (this->n_components()==1) ? component_index : -1),
+      vector_extractor ( (this->n_components()==dim) ? component_index : -1)
+  {}
+
+
+
+  template <int dim>
+  const FEValuesExtractors::Scalar &
+  FEVariable<dim>::extractor_scalar() const
+  {
+    Assert(this->n_components()==1,
+           ExcMessage("You cannot ask for the scalar extractor of a non-scalar variable."));
+    return scalar_extractor;
+  }
+
+
+
+  template <int dim>
+  const FEValuesExtractors::Vector &
+  FEVariable<dim>::extractor_vector() const
+  {
+    Assert(this->n_components()==dim,
+           ExcMessage("You cannot ask for the vector extractor of a variable that is not a vector."));
+    return vector_extractor;
+  }
+
+
+
+  template <int dim>
+  FEVariableCollection<dim>::FEVariableCollection()
+    = default;
+
+
+
+  template <int dim>
+  FEVariableCollection<dim>::FEVariableCollection(const std::vector<VariableDeclaration<dim>> &variable_definitions)
+  {
+    initialize(variable_definitions);
+  }
+
+
+
+  template <int dim>
+  void
+  FEVariableCollection<dim>::initialize(const std::vector<VariableDeclaration<dim>> &variable_definitions)
+  {
+    variables.clear();
+    variables.reserve(variable_definitions.size());
+
+    unsigned int component_index = 0;
+    unsigned int block_index = 0;
+
+    for (unsigned int i=0; i<variable_definitions.size(); ++i)
+      {
+        variables.push_back(FEVariable<dim>(variable_definitions[i],
+                                            component_index, block_index, i));
+        component_index+= variables[i].n_components();
+        block_index += variables[i].n_blocks;
+      }
+
+    Assert(variables.back().n_blocks != 0
+           || variables.back().n_components() == 0,
+           ExcMessage("The last variable needs to have >0 blocks."));
+
+    n_components_ = component_index;
+    n_blocks_ = block_index;
+
+    fes.resize(variables.size());
+    multiplicities.resize(variables.size());
+    for (unsigned int i=0; i<variables.size(); ++i)
+      {
+        fes[i] = variables[i].fe.get();
+        multiplicities[i] = variables[i].multiplicity;
+        variables[i].component_mask = ComponentMask(n_components_, false);
+        for (unsigned int c=0; c<variables[i].n_components(); ++c)
+          variables[i].component_mask.set(c+variables[i].first_component_index, true);
+      }
+
+    components_to_blocks.clear();
+    for (unsigned int i=0; i<variables.size(); ++i)
+      {
+        for (unsigned int c=0; c<variables[i].n_components(); ++c)
+          components_to_blocks.push_back(variables[i].block_index
+                                         + ((variables[i].n_blocks>1)?c:0));
+      }
+    Assert(components_to_blocks.size() == n_components(), ExcInternalError());
+
+    Assert(fes.size() == variables.size(), ExcInternalError());
+    Assert(multiplicities.size() == variables.size(), ExcInternalError());
+  }
+
+
+
+  template <int dim>
+  const FEVariable<dim> &
+  FEVariableCollection<dim>::variable(const std::string &name) const
+  {
+    for (unsigned int i=0; i<variables.size(); ++i)
+      if (variables[i].name == name)
+        return variables[i];
+
+    Assert(false, ExcMessage("Variable '" + name + "' not found!"));
+    return *(variables.end()); // reference invalid iterator here
+  }
+
+
+
+  template <int dim>
+  std::vector<const FEVariable<dim>*>
+  FEVariableCollection<dim>::variables_with_name(const std::string &name) const
+  {
+    std::vector<const FEVariable<dim>*> result;
+    for (unsigned int i=0; i<variables.size(); ++i)
+      if (variables[i].name == name)
+        result.emplace_back(&variables[i]);
+
+    return result;
+  }
+
+
+
+  template <int dim>
+  bool
+  FEVariableCollection<dim>::variable_exists(const std::string &name) const
+  {
+    for (unsigned int i=0; i<variables.size(); ++i)
+      if (variables[i].name == name)
+        return true;
+
+    return false;
+  }
+
+
+
+  template <int dim>
+  const std::vector<FEVariable<dim>> &
+  FEVariableCollection<dim>::get_variables() const
+  {
+    return variables;
+  }
+
+
+
+  template <int dim>
+  unsigned int
+  FEVariableCollection<dim>::n_components() const
+  {
+    return n_components_;
+  }
+
+
+
+  template <int dim>
+  unsigned int
+  FEVariableCollection<dim>::n_blocks() const
+  {
+    return n_blocks_;
+  }
+
+
+
+  template <int dim>
+  const std::vector<const FiniteElement<dim> *> &
+  FEVariableCollection<dim>::get_fes() const
+  {
+    return fes;
+  }
+
+
+  template <int dim>
+  const std::vector<unsigned int> &
+  FEVariableCollection<dim>::get_multiplicities() const
+  {
+    return multiplicities;
+  }
+
+
+  template <int dim>
+  const std::vector<unsigned int> &
+  FEVariableCollection<dim>::get_components_to_blocks() const
+  {
+    return components_to_blocks;
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template struct VariableDeclaration<dim>; \
+  template struct FEVariable<dim>; \
+  template class FEVariableCollection<dim>;
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/geometry_model/box.cc.bak b/source/geometry_model/box.cc.bak
new file mode 100644
index 00000000000..882efeb7e68
--- /dev/null
+++ b/source/geometry_model/box.cc.bak
@@ -0,0 +1,524 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/grid/tria_accessor.h>
+#include <deal.II/grid/grid_tools.h>
+
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    template <int dim>
+    void
+    Box<dim>::initialize ()
+    {
+      // Get pointer to initial topography model
+      topo_model = const_cast<InitialTopographyModel::Interface<dim>*>(&this->get_initial_topography_model());
+
+      // Check that initial topography is required.
+      // If so, connect the initial topography function
+      // to the right signals: It should be applied after
+      // the final initial adaptive refinement and after a restart.
+      if (Plugins::plugin_type_matches<InitialTopographyModel::ZeroTopography<dim>>(*topo_model) == false)
+        {
+          this->get_signals().pre_set_initial_state.connect(
+            [&](typename parallel::distributed::Triangulation<dim> &tria)
+          {
+            this->topography(tria);
+          }
+          );
+          this->get_signals().post_resume_load_user_data.connect(
+            [&](typename parallel::distributed::Triangulation<dim> &tria)
+          {
+            this->topography(tria);
+          }
+          );
+        }
+    }
+
+
+    template <int dim>
+    void
+    Box<dim>::
+    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
+    {
+      const std::vector<unsigned int> rep_vec(repetitions.begin(), repetitions.end());
+      GridGenerator::subdivided_hyper_rectangle (coarse_grid,
+                                                 rep_vec,
+                                                 box_origin,
+                                                 box_origin+extents,
+                                                 true);
+
+      // Tell p4est about the periodicity of the mesh.
+      std::vector<GridTools::PeriodicFacePair<typename parallel::distributed::Triangulation<dim>::cell_iterator>>
+      periodicity_vector;
+      for (int i=0; i<dim; ++i)
+        if (periodic[i])
+          GridTools::collect_periodic_faces
+          ( coarse_grid, /*b_id1*/ 2*i, /*b_id2*/ 2*i+1,
+            /*direction*/ i, periodicity_vector);
+
+      if (periodicity_vector.size() > 0)
+        coarse_grid.add_periodicity (periodicity_vector);
+    }
+
+    template <int dim>
+    void
+    Box<dim>::
+    topography (typename parallel::distributed::Triangulation<dim> &grid) const
+    {
+      // Here we provide GridTools with the function to displace vertices
+      // in the vertical direction by an amount specified by the initial topography model
+      GridTools::transform(
+        [&](const Point<dim> &p) -> Point<dim>
+      {
+        return this->add_topography(p);
+      },
+      grid);
+
+      this->get_pcout() << "   Added initial topography to grid" << std::endl << std::endl;
+    }
+
+
+    template <int dim>
+    Point<dim>
+    Box<dim>::
+    add_topography (const Point<dim> &x_y_z) const
+    {
+      // Get the surface x (,y) point
+      Point<dim-1> surface_point;
+      for (unsigned int d=0; d<dim-1; ++d)
+        surface_point[d] = x_y_z[d];
+
+      // Get the surface topography at this point
+      const double topo = topo_model->value(surface_point);
+
+      // Compute the displacement of the z coordinate
+      const double ztopo = (x_y_z[dim-1] - box_origin[dim-1]) / extents[dim-1] * topo;
+
+      // Compute the new point
+      Point<dim> x_y_ztopo = x_y_z;
+      x_y_ztopo[dim-1] += ztopo;
+
+      return x_y_ztopo;
+    }
+
+
+    template <int dim>
+    std::set<types::boundary_id>
+    Box<dim>::
+    get_used_boundary_indicators () const
+    {
+      // boundary indicators are zero through 2*dim-1
+      std::set<types::boundary_id> s;
+      for (unsigned int i=0; i<2*dim; ++i)
+        s.insert (i);
+      return s;
+    }
+
+
+    template <int dim>
+    std::map<std::string,types::boundary_id>
+    Box<dim>::
+    get_symbolic_boundary_names_map () const
+    {
+      switch (dim)
+        {
+          case 2:
+          {
+            return
+            {
+              {"left",   0},
+              {"right",  1},
+              {"bottom", 2},
+              {"top",    3}
+            };
+          }
+
+          case 3:
+          {
+            return
+            {
+              {"left",   0},
+              {"right",  1},
+              {"front",  2},
+              {"back",   3},
+              {"bottom", 4},
+              {"top",    5}
+
+            };
+          }
+        }
+
+      Assert (false, ExcNotImplemented());
+      return {};
+    }
+
+
+    template <int dim>
+    std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
+    Box<dim>::
+    get_periodic_boundary_pairs () const
+    {
+      std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>> periodic_boundaries;
+      for ( unsigned int i=0; i<dim; ++i)
+        if (periodic[i])
+          periodic_boundaries.insert( std::make_pair( std::pair<types::boundary_id, types::boundary_id>(2*i, 2*i+1), i) );
+      return periodic_boundaries;
+    }
+
+
+
+    template <int dim>
+    void
+    Box<dim>::adjust_positions_for_periodicity (Point<dim> &position,
+                                                const ArrayView<Point<dim>> &connected_positions,
+                                                const ArrayView<Tensor<1, dim>> &/*connected_velocities*/) const
+    {
+      for (unsigned int i = 0; i < dim; ++i)
+        if (periodic[i])
+          {
+            if (position[i] < box_origin[i])
+              {
+                position[i] += extents[i];
+                for (auto &connected_position: connected_positions)
+                  connected_position[i] += extents[i];
+              }
+            else if (position[i] > box_origin[i] + extents[i])
+              {
+                position[i] -= extents[i];
+                for (auto &connected_position: connected_positions)
+                  connected_position[i] -= extents[i];
+              }
+          }
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    Box<dim>::get_extents () const
+    {
+      return extents;
+    }
+
+    template <int dim>
+    const std::array<unsigned int, dim> &
+    Box<dim>::get_repetitions () const
+    {
+      return repetitions;
+    }
+
+    template <int dim>
+    Point<dim>
+    Box<dim>::get_origin () const
+    {
+      return box_origin;
+    }
+
+    template <int dim>
+    double
+    Box<dim>::
+    length_scale () const
+    {
+      return 0.01*extents[0];
+    }
+
+
+    template <int dim>
+    double
+    Box<dim>::depth(const Point<dim> &position) const
+    {
+      // Get the surface x (,y) point
+      Point<dim-1> surface_point;
+      for (unsigned int d=0; d<dim-1; ++d)
+        surface_point[d] = position[d];
+
+      // Get the surface topography at this point
+      const double topo = topo_model->value(surface_point);
+
+      const double d = extents[dim-1] + topo - (position(dim-1)-box_origin[dim-1]);
+      return std::min (std::max (d, 0.), maximal_depth());
+    }
+
+
+    template <int dim>
+    double
+    Box<dim>::height_above_reference_surface(const Point<dim> &position) const
+    {
+      return (position(dim-1)-box_origin[dim-1]) - extents[dim-1];
+    }
+
+
+    template <int dim>
+    Point<dim>
+    Box<dim>::representative_point(const double depth) const
+    {
+      Assert (depth >= 0,
+              ExcMessage ("Given depth must be positive or zero."));
+      Assert (depth <= maximal_depth(),
+              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
+
+      // choose a point on the center axis of the domain (without topography)
+      Point<dim> p = extents/2+box_origin;
+
+      // We need a dim-1 point to get the topo value.
+      Point<dim-1> surface_point;
+      for (unsigned int d=0; d<dim-1; ++d)
+        surface_point[d] = p[d];
+
+      const double topo = topo_model->value(surface_point);
+      p[dim-1] = extents[dim-1]+box_origin[dim-1]-depth+topo;
+
+      return p;
+    }
+
+
+    template <int dim>
+    double
+    Box<dim>::maximal_depth() const
+    {
+      return extents[dim-1] + topo_model->max_topography();
+    }
+
+    template <int dim>
+    bool
+    Box<dim>::has_curved_elements() const
+    {
+      return false;
+    }
+
+    template <int dim>
+    bool
+    Box<dim>::point_is_in_domain(const Point<dim> &point) const
+    {
+      // If mesh deformation is enabled, we have to loop over all the current
+      // grid cells to see if the given point lies in the domain.
+      // If mesh deformation is not enabled, or has not happened yet,
+      // we can use the global extents of the model domain with or without
+      // initial topography instead.
+      // This function only checks if the given point lies in the domain
+      // in its current shape at the current time. It can be called before
+      // mesh deformation is applied in the first timestep (e.g., by the boundary
+      // traction plugins), and therefore there is no guarantee
+      // that the point will still lie in the domain after initial mesh deformation.
+      if (this->get_parameters().mesh_deformation_enabled &&
+          this->simulator_is_past_initialization())
+        {
+          return Utilities::point_is_in_triangulation<dim>(this->get_mapping(),
+                                                           this->get_triangulation(),
+                                                           point,
+                                                           this->get_mpi_communicator());
+        }
+      // Without mesh deformation enabled, it is much cheaper to check whether the point lies in the domain.
+      else
+        {
+          // The maximal extents of the unperturbed box domain.
+          Point<dim> max_point = extents+box_origin;
+
+          // If mesh deformation is not enabled, but initial topography
+          // was/will be applied to the mesh, include this topography in the
+          // extent of the domain.
+          if (!Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()))
+            {
+              // Get the surface x (,y) point
+              Point<dim-1> surface_point;
+              for (unsigned int d=0; d<dim-1; ++d)
+                surface_point[d] = point[d];
+
+              // Get the surface topography at this point
+              const double topo = topo_model->value(surface_point);
+              max_point[dim-1] += topo;
+            }
+
+          // Check whether point lies within the min/max coordinates of the domain including initial topography.
+          for (unsigned int d = 0; d < dim; ++d)
+            if (point[d] > max_point[d]+std::numeric_limits<double>::epsilon()*extents[d] ||
+                point[d] < box_origin[d]-std::numeric_limits<double>::epsilon()*extents[d])
+              return false;
+
+          return true;
+        }
+    }
+
+    template <int dim>
+    std::array<double,dim>
+    Box<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
+    {
+      std::array<double,dim> position_array;
+      for (unsigned int i = 0; i < dim; ++i)
+        position_array[i] = position_point(i);
+
+      return position_array;
+    }
+
+
+    template <int dim>
+    aspect::Utilities::Coordinates::CoordinateSystem
+    Box<dim>::natural_coordinate_system() const
+    {
+      return aspect::Utilities::Coordinates::CoordinateSystem::cartesian;
+    }
+
+
+    template <int dim>
+    Point<dim>
+    Box<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position_tensor) const
+    {
+      Point<dim> position_point;
+      for (unsigned int i = 0; i < dim; ++i)
+        position_point[i] = position_tensor[i];
+
+      return position_point;
+    }
+
+
+    template <int dim>
+    void
+    Box<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Box");
+        {
+          prm.declare_entry ("X extent", "1.",
+                             Patterns::Double (0.),
+                             "Extent of the box in x-direction. Units: \\si{\\meter}.");
+          prm.declare_entry ("Y extent", "1.",
+                             Patterns::Double (0.),
+                             "Extent of the box in y-direction. Units: \\si{\\meter}.");
+          prm.declare_entry ("Z extent", "1.",
+                             Patterns::Double (0.),
+                             "Extent of the box in z-direction. This value is ignored "
+                             "if the simulation is in 2d. Units: \\si{\\meter}.");
+
+          prm.declare_entry ("Box origin X coordinate", "0.",
+                             Patterns::Double (),
+                             "X coordinate of box origin. Units: \\si{\\meter}.");
+          prm.declare_entry ("Box origin Y coordinate", "0.",
+                             Patterns::Double (),
+                             "Y coordinate of box origin. Units: \\si{\\meter}.");
+          prm.declare_entry ("Box origin Z coordinate", "0.",
+                             Patterns::Double (),
+                             "Z coordinate of box origin. This value is ignored "
+                             "if the simulation is in 2d. Units: \\si{\\meter}.");
+
+          prm.declare_entry ("X repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in X direction.");
+          prm.declare_entry ("Y repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in Y direction.");
+          prm.declare_entry ("Z repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in Z direction.");
+
+          prm.declare_entry ("X periodic", "false",
+                             Patterns::Bool (),
+                             "Whether the box should be periodic in X direction");
+          prm.declare_entry ("Y periodic", "false",
+                             Patterns::Bool (),
+                             "Whether the box should be periodic in Y direction");
+          prm.declare_entry ("Z periodic", "false",
+                             Patterns::Bool (),
+                             "Whether the box should be periodic in Z direction");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Box<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Box");
+        {
+          box_origin[0] = prm.get_double ("Box origin X coordinate");
+          extents[0] = prm.get_double ("X extent");
+          periodic[0] = prm.get_bool ("X periodic");
+          repetitions[0] = prm.get_integer ("X repetitions");
+
+          if (dim >= 2)
+            {
+              box_origin[1] = prm.get_double ("Box origin Y coordinate");
+              extents[1] = prm.get_double ("Y extent");
+              periodic[1] = prm.get_bool ("Y periodic");
+              repetitions[1] = prm.get_integer ("Y repetitions");
+            }
+
+          if (dim >= 3)
+            {
+              // Use dim-1 instead of 2 to avoid compiler warning in 2d:
+              box_origin[dim-1] = prm.get_double ("Box origin Z coordinate");
+              extents[dim-1] = prm.get_double ("Z extent");
+              periodic[dim-1] = prm.get_bool ("Z periodic");
+              repetitions[dim-1] = prm.get_integer ("Z repetitions");
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    ASPECT_REGISTER_GEOMETRY_MODEL(Box,
+                                   "box",
+                                   "A box geometry parallel to the coordinate directions. "
+                                   "The extent of the box in each coordinate direction "
+                                   "is set in the parameter file. The box geometry labels its "
+                                   "2*dim sides as follows: in 2d, boundary indicators 0 through 3 "
+                                   "denote the left, right, bottom and top boundaries; in 3d, boundary "
+                                   "indicators 0 through 5 indicate left, right, front, back, bottom "
+                                   "and top boundaries (see also the documentation of the deal.II class "
+                                   "``ReferenceCell''). You can also use symbolic names ``left'', ``right'', "
+                                   "etc., to refer to these boundaries in input files. "
+                                   "It is also possible to add initial topography to the box model. Note however that "
+                                   "this is done after the last initial adaptive refinement cycle. "
+                                   "Also, initial topography is supposed to be small, as it is not taken into account "
+                                   "when depth or a representative point is computed. ")
+
+
+  }
+}
diff --git a/source/geometry_model/chunk.cc.bak b/source/geometry_model/chunk.cc.bak
new file mode 100644
index 00000000000..b81fbeb7ad3
--- /dev/null
+++ b/source/geometry_model/chunk.cc.bak
@@ -0,0 +1,949 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+#include <aspect/geometry_model/initial_topography_model/ascii_data.h>
+
+#include <aspect/simulator_signals.h>
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/grid/tria_accessor.h>
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/grid/tria.h>
+
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    namespace internal
+    {
+      template <int dim>
+      ChunkGeometry<dim>::ChunkGeometry(const InitialTopographyModel::Interface<dim> &topo,
+                                        const double min_longitude,
+                                        const double min_radius,
+                                        const double max_depth)
+        :
+        topo (&topo),
+        point1_lon(min_longitude),
+        inner_radius(min_radius),
+        max_depth(max_depth)
+      {}
+
+
+
+      template <int dim>
+      DerivativeForm<1,dim,dim>
+      ChunkGeometry<dim>::
+      push_forward_gradient(const Point<dim> &chart_point) const
+      {
+        const double R = chart_point[0]; // Radius
+
+        Assert (R > 0.0, ExcMessage("Negative radius for given point."));
+
+        Tensor<2,dim> DX;
+
+        // We only have access to the topography gradients
+        // (dtopo/dphi and dtopo/dtheta) for the AsciiData
+        // initial topography model. We assume 0.0 otherwise;
+        // while this is valid for the ZeroTopography model,
+        // this will result in incorrect gradients for
+        // other initial topography models. Hence only AsciiData
+        // and ZeroTopography are allowed for now in Chunk<dim>::initialize().
+        Tensor<1,dim-1> topo_derivatives;
+        if (const InitialTopographyModel::AsciiData<dim> *itm = dynamic_cast<const InitialTopographyModel::AsciiData<dim> *> (topo))
+          topo_derivatives = itm->vector_gradient(push_forward_sphere(chart_point));
+        else if (dynamic_cast<const InitialTopographyModel::ZeroTopography<dim> *> (topo))
+          {
+            // Gradient is zero (which it is already initialized to from before)
+          }
+        else
+          Assert (false, ExcNotImplemented());
+
+        // Construct surface point in lon(,lat) coordinates
+        Point<dim-1> surface_point;
+        for (unsigned int d=0; d<dim-1; ++d)
+          surface_point[d] = chart_point[d+1];
+
+        // Convert latitude to colatitude
+        if (dim == 3)
+          surface_point[1] = 0.5*numbers::PI - surface_point[1];
+
+        // get the maximum topography at the surface point
+        const double d_topo = topo->value(surface_point);
+
+        // get the spherical point including topography
+        const Point<dim> topo_point = push_forward_topo(chart_point);
+        const double R_topo = topo_point[0];
+        const double phi_topo = topo_point[1];
+
+        // The derivatives of topo_point to chart_point
+        Tensor<2, dim> Dtopo;
+        // The derivatives of the cartesian point to chart_point
+        DerivativeForm<1, dim, dim> Dtotal;
+
+
+        switch (dim)
+          {
+            case 2:
+            {
+              // R_topo = R + topo(phi) * ((R-R_0)/(R_1-R_0)) = R + topo(phi) * ((R-R_0)/max_depth)
+              // phi_topo = phi
+              //dR_topo/dR
+              Dtopo[0][0] = (d_topo / max_depth) + 1.;
+              //dR_topo/dphi = dR_topo/dtopo * dtopo/dphi
+              Dtopo[0][1] = (R-inner_radius)/max_depth * topo_derivatives[0];
+              //dphi_topo/dR
+              Dtopo[1][0] = 0.;
+              //dphi_topo/dphi
+              Dtopo[1][1] = 1.;
+
+              //dx/dR_topo
+              DX[0][0] =           std::cos(phi_topo);
+              //dx/dphi_topo
+              DX[0][1] = -R_topo * std::sin(phi_topo);
+              //dy/dR_topo
+              DX[1][0] =           std::sin(phi_topo);
+              //dy/dphi_topo
+              DX[1][1] =  R_topo * std::cos(phi_topo);
+
+              break;
+            }
+            case 3:
+            {
+              // R_topo = R + topo(phi,theta) * ((R-R_0)/(R_1-R_0))
+              // phi_topo = phi
+              // theta_topo = theta
+              //dR_topo/dR
+              Dtopo[0][0] = (d_topo / max_depth) + 1.;
+              //dR_topo/dphi
+              Dtopo[0][1] = (R - inner_radius) / max_depth * topo_derivatives[0];
+              //dR_topo/dtheta
+              Dtopo[0][2] = (R - inner_radius) / max_depth * topo_derivatives[1];
+              //dphi_topo/dR
+              Dtopo[1][0] = 0.;
+              //dphi_topo/dphi
+              Dtopo[1][1] = 1.;
+              //dphi_topo/dtheta
+              Dtopo[1][2] = 0.;
+              //dtheta_topo/dR
+              Dtopo[2][0] = 0.;
+              //dtheta_topo/dphi
+              Dtopo[2][1] = 0.;
+              //dtheta_topo/dtheta
+              Dtopo[2][2] = 1.;
+
+              const double theta_topo = topo_point[2];
+
+              // The derivatives of the cartesian points to topo_point
+              DX[0][0] =      std::cos(theta_topo) * std::cos(phi_topo);
+              DX[0][1] = -R_topo * std::cos(theta_topo) * std::sin(phi_topo);
+              DX[0][2] = -R_topo * std::sin(theta_topo) * std::cos(phi_topo); //reorder
+              DX[1][0] =      std::cos(theta_topo) * std::sin(phi_topo);
+              DX[1][1] =  R_topo * std::cos(theta_topo) * std::cos(phi_topo);
+              DX[1][2] = -R_topo * std::sin(theta_topo) * std::sin(phi_topo);
+              DX[2][0] =      std::sin(theta_topo);
+              DX[2][1] = 0;
+              DX[2][2] =  R_topo * std::cos(theta_topo);
+
+              break;
+            }
+            default:
+              Assert (false, ExcNotImplemented ());
+          }
+
+        Dtotal = DerivativeForm<1,dim,dim>(DX * Dtopo);
+
+        return Dtotal;
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      ChunkGeometry<dim>::
+      push_forward(const Point<dim> &r_phi_theta) const
+      {
+        // Only take into account topography when we're not using the ZeroTopography plugin
+        if (dynamic_cast<const InitialTopographyModel::ZeroTopography<dim>*>(topo) != nullptr)
+          return push_forward_sphere(r_phi_theta);
+        else
+          return push_forward_sphere(push_forward_topo(r_phi_theta));
+
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      ChunkGeometry<dim>::
+      pull_back(const Point<dim> &x_y_z) const
+      {
+        // Only take into account topography when we're not using the ZeroTopography plugin
+        if (dynamic_cast<const InitialTopographyModel::ZeroTopography<dim>*>(topo) != nullptr)
+          return pull_back_sphere(x_y_z);
+        else
+          return pull_back_topo(pull_back_sphere(x_y_z));
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      ChunkGeometry<dim>::
+      push_forward_sphere(const Point<dim> &input_vertex) const
+      {
+        Point<dim> output_vertex;
+        switch (dim)
+          {
+            case 2:
+            {
+              output_vertex[0] = input_vertex[0]*std::cos(input_vertex[1]); // x=rcosphi
+              output_vertex[1] = input_vertex[0]*std::sin(input_vertex[1]); // z=rsinphi
+              break;
+            }
+            case 3:
+            {
+              output_vertex[0] = input_vertex[0]*std::cos(input_vertex[2])*std::cos(input_vertex[1]); // x=rsinthetacosphi
+              output_vertex[1] = input_vertex[0]*std::cos(input_vertex[2])*std::sin(input_vertex[1]); // y=rsinthetasinphi
+              output_vertex[2] = input_vertex[0]*std::sin(input_vertex[2]); // z=rcostheta
+              break;
+            }
+            default:
+              Assert (false, ExcNotImplemented ());
+          }
+        return output_vertex;
+      }
+
+
+
+      template <int dim>
+      Tensor<1, dim>
+      ChunkGeometry<dim>::
+      normal_vector(const typename Triangulation<dim>::face_iterator &face,
+                    const Point<dim> &p) const
+      {
+        // Let us first test whether we are on a "horizontal" face
+        // (tangential to the sphere).  In this case, the normal vector is
+        // easy to compute since it is proportional to the vector from the
+        // center to the point 'p'.
+        //
+        // We test whether a face is horizontal by checking that the vertices
+        // all have roughly the same distance from the center: If the
+        // maximum deviation for the distances from the vertices to the
+        // center is less than 1.e-5 of the distance between vertices (as
+        // measured by the minimum distance from any of the other vertices
+        // to the first vertex), then we call this a horizontal face.
+        constexpr unsigned int max_n_vertices_per_face = (dim==2 ? 2 : 4);
+        std::array<double, max_n_vertices_per_face>     distances_to_center {};
+        std::array<double, max_n_vertices_per_face - 1> distances_to_first_vertex {};
+        distances_to_center[0] = face->vertex(0).norm_square();
+        for (unsigned int i = 1; i < face->n_vertices(); ++i)
+          {
+            AssertIndexRange (i, distances_to_center.size());
+            AssertIndexRange (i-1, distances_to_first_vertex.size());
+
+            distances_to_center[i] = face->vertex(i).norm_square();
+            distances_to_first_vertex[i - 1] =
+              (face->vertex(i) - face->vertex(0)).norm_square();
+          }
+        const auto minmax_distance =
+          std::minmax_element(distances_to_center.begin(),
+                              distances_to_center.begin()+face->n_vertices());
+        const auto min_distance_to_first_vertex =
+          std::min_element(distances_to_first_vertex.begin(),
+                           distances_to_first_vertex.begin()+face->n_vertices()-1);
+
+        // So, if this is a "horizontal" face, then just compute the normal
+        // vector as the one from the center to the point 'p', adequately
+        // scaled.
+        if (*minmax_distance.second - *minmax_distance.first <
+            1.e-10 * *min_distance_to_first_vertex)
+          {
+            const Tensor<1, dim> unnormalized_spherical_normal = p;
+            const Tensor<1, dim> normalized_spherical_normal =
+              unnormalized_spherical_normal / unnormalized_spherical_normal.norm();
+            return normalized_spherical_normal;
+          }
+
+        // If it is not a horizontal face, just use the machinery of the
+        // base class.
+        return Manifold<dim>::normal_vector(face, p);
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      ChunkGeometry<dim>::
+      pull_back_sphere(const Point<dim> &v) const
+      {
+        Point<dim> output_vertex;
+        switch (dim)
+          {
+            case 2:
+            {
+              output_vertex[1] = std::atan2(v[1], v[0]);
+              output_vertex[0] = v.norm();
+
+              // We must guarantee that all returned points have a longitude coordinate
+              // value that is larger than (or equal to) the longitude of point1.
+              // For example:
+              // If the domain runs from longitude -10 to 200 degrees,
+              // atan2 will also return a negative value (-180 to -160) for the points
+              // with longitude 180 to 200. These values must be corrected
+              // so that they are larger than the minimum longitude value of -10,
+              // by adding 360 degrees.
+              // A 100*epsilon ensures we catch all cases.
+              if (output_vertex[1] < 0.0)
+                if (output_vertex[1] < point1_lon - 100 * std::abs(point1_lon)*std::numeric_limits<double>::epsilon())
+                  output_vertex[1] += 2.0 * numbers::PI;
+              break;
+            }
+            case 3:
+            {
+              const double radius=v.norm();
+              output_vertex[0] = radius;
+              output_vertex[1] = std::atan2(v[1], v[0]);
+              // See 2d case
+              if (output_vertex[1] < 0.0)
+                if (output_vertex[1] < point1_lon - 100 * std::abs(point1_lon)*std::numeric_limits<double>::epsilon())
+                  output_vertex[1] += 2.0 * numbers::PI;
+              output_vertex[2] = std::asin(v[2]/radius);
+              break;
+            }
+            default:
+              Assert (false, ExcNotImplemented ());
+          }
+        return output_vertex;
+      }
+
+
+
+      template <int dim>
+      std::unique_ptr<Manifold<dim,dim>>
+      ChunkGeometry<dim>::
+      clone() const
+      {
+        return std::make_unique<ChunkGeometry>(*this);
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      ChunkGeometry<dim>::
+      push_forward_topo(const Point<dim> &r_phi_theta) const
+      {
+        // the radius of the current point without topography
+        const double radius = r_phi_theta[0];
+
+        // Grab lon,lat coordinates
+        Point<dim-1> surface_point;
+        for (unsigned int d=0; d<dim-1; ++d)
+          surface_point[d] = r_phi_theta[d+1];
+
+        // While throughout ASPECT we use co-latitude as a convention when
+        // representing points in spherical coordinates (see for example
+        // the Utilities::Coordinates::cartesian_to_spherical_coordinates()
+        // function), the current class uses latitude in its pull back and
+        // push forward functions. As a consequence, the argument provided
+        // to this function has latitude as one coordinate (at least in 3d).
+        // On the other hand, the InitialTopography::Interface::value()
+        // function expects colatitude (=standard form spherical coordinates)
+        // for geometry models that are (parts of) spherical objects.
+        //
+        // So do the conversion:
+        if (dim == 3)
+          surface_point[1] = 0.5*numbers::PI - surface_point[1];
+
+        // Then query the topography at this point:
+        const double topography = topo->value(surface_point);
+
+        // adjust the radius based on the radius of the point
+        // through a linear interpolation between 0 at max depth and
+        // "topography" at the surface
+        const double topo_radius = std::max(inner_radius,radius + (radius-inner_radius)/max_depth*topography);
+
+        // return the point with adjusted radius
+        Point<dim> topo_r_phi_theta = r_phi_theta;
+        topo_r_phi_theta[0] = topo_radius;
+
+        return topo_r_phi_theta;
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      ChunkGeometry<dim>::
+      pull_back_topo(const Point<dim> &topo_r_phi_theta) const
+      {
+        // the radius of the point with topography
+        const double topo_radius = topo_r_phi_theta[0];
+
+        // Grab lon,lat coordinates
+        Point<dim-1> surface_point;
+        for (unsigned int d=0; d<dim-1; ++d)
+          surface_point[d] = topo_r_phi_theta[d+1];
+
+        // While throughout ASPECT we use co-latitude as a convention when
+        // representing points in spherical coordinates (see for example
+        // the Utilities::Coordinates::cartesian_to_spherical_coordinates()
+        // function), the current class uses latitude in its pull back and
+        // push forward functions. As a consequence, the argument provided
+        // to this function has latitude as one coordinate (at least in 3d).
+        // On the other hand, the InitialTopography::Interface::value()
+        // function expects colatitude (=standard form spherical coordinates)
+        // for geometry models that are (parts of) spherical objects.
+        //
+        // So do the conversion:
+        if (dim == 3)
+          surface_point[1] = 0.5*numbers::PI - surface_point[1];
+
+        // Then query the topography at this point:
+        const double topography = topo->value(surface_point);
+
+        // remove the topography (which scales with radius)
+        const double radius = std::max(inner_radius,
+                                       (topo_radius*max_depth+inner_radius*topography)/(max_depth+topography));
+
+        // return the point without topography
+        Point<dim> r_phi_theta = topo_r_phi_theta;
+        r_phi_theta[0] = radius;
+
+        return r_phi_theta;
+      }
+
+
+
+      template <int dim>
+      double
+      ChunkGeometry<dim>::
+      get_radius(const Point<dim> &x_y_z) const
+      {
+        const Point<dim> r_phi_theta = pull_back(x_y_z);
+        Point<dim-1> surface_point;
+        for (unsigned int d=0; d<dim-1; ++d)
+          surface_point[d] = r_phi_theta[d+1];
+        // Convert latitude to colatitude
+        if (dim == 3)
+          surface_point[1] = 0.5*numbers::PI - surface_point[1];
+        const double topography = topo->value(surface_point);
+
+        // return the outer radius at this phi, theta point including topography
+        return topography + inner_radius + max_depth;
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    Chunk<dim>::initialize ()
+    {
+      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()) ||
+                  Plugins::plugin_type_matches<const InitialTopographyModel::AsciiData<dim>>(this->get_initial_topography_model()),
+                  ExcMessage("At the moment, only the Zero or AsciiData initial topography model can be used with the Chunk geometry model."));
+
+      manifold = std::make_unique<internal::ChunkGeometry<dim>>(this->get_initial_topography_model(),
+                                                                 point1[1],
+                                                                 point1[0],
+                                                                 point2[0]-point1[0]);
+    }
+
+
+    template <int dim>
+    void
+    Chunk<dim>::
+    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
+    {
+      // First create a box in Cartesian coordinates:
+      const std::vector<unsigned int> rep_vec(repetitions.begin(), repetitions.end());
+      GridGenerator::subdivided_hyper_rectangle (coarse_grid,
+                                                 rep_vec,
+                                                 point1,
+                                                 point2,
+                                                 true);
+
+      // Then transform this box into a spherical chunk (possibly with
+      // topography -- the 'manifold' has that built in):
+      GridTools::transform (
+        [&](const Point<dim> &p) -> Point<dim>
+      {
+        return manifold->push_forward(p);
+      },
+      coarse_grid);
+
+      // Deal with a curved mesh by assigning a manifold. We arbitrarily
+      // choose manifold_id 15 for this.
+      coarse_grid.set_manifold (my_manifold_id, *manifold);
+      for (const auto &cell : coarse_grid.active_cell_iterators())
+        cell->set_all_manifold_ids (my_manifold_id);
+    }
+
+
+
+    template <int dim>
+    std::set<types::boundary_id>
+    Chunk<dim>::
+    get_used_boundary_indicators () const
+    {
+      // boundary indicators are zero through 2*dim-1
+      std::set<types::boundary_id> s;
+      for (unsigned int i=0; i<2*dim; ++i)
+        s.insert (i);
+      return s;
+    }
+
+
+
+    template <int dim>
+    std::map<std::string,types::boundary_id>
+    Chunk<dim>::
+    get_symbolic_boundary_names_map () const
+    {
+      switch (dim)
+        {
+          case 2:
+          {
+            return
+            {
+              {"bottom", 0},
+              {"top",    1},
+              {"west",   2},
+              {"east",   3}
+            };
+          }
+
+          case 3:
+          {
+            return
+            {
+              {"bottom", 0},
+              {"top",    1},
+              {"west",   2},
+              {"east",   3},
+              {"south",  4},
+              {"north",  5}
+            };
+          }
+        }
+
+      Assert (false, ExcNotImplemented());
+      return {};
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::
+    length_scale () const
+    {
+      // As described in the first ASPECT paper, a length scale of
+      // 10km = 1e4m works well for the pressure scaling for earth
+      // sized spherical shells. use a length scale that
+      // yields this value for the R0,R1 corresponding to earth
+      // but otherwise scales like (R1-R0)
+      return 1e4 * maximal_depth() / (6336000.-3481000.);
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::depth(const Point<dim> &position) const
+    {
+      // depth is defined wrt the reference surface point2[0]
+      // negative depth is not allowed
+      return std::max (0., std::min (point2[0]-position.norm(), maximal_depth()));
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::height_above_reference_surface(const Point<dim> &position) const
+    {
+      return position.norm()-point2[0];
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    Chunk<dim>::representative_point(const double depth) const
+    {
+      Assert (depth >= 0,
+              ExcMessage ("Given depth must be positive or zero."));
+      Assert (depth <= maximal_depth(),
+              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
+
+      // Choose a point at the mean longitude (and latitude)
+      Point<dim> p = 0.5*(point2+point1);
+      // at a depth beneath the top surface
+      p[0] = point2[0]-depth;
+
+      // Now convert to Cartesian coordinates. This ignores the surface topography,
+      // but that is as documented.
+      return manifold->push_forward_sphere(p);
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::west_longitude () const
+    {
+      return point1[1];
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::east_longitude () const
+    {
+      return point2[1];
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::longitude_range () const
+    {
+      return point2[1] - point1[1];
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::south_latitude () const
+    {
+      if (dim == 3)
+        return point1[2];
+      else
+        return 0;
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::north_latitude () const
+    {
+      if (dim==3)
+        return point2[2];
+      else
+        return 0;
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::latitude_range () const
+    {
+      if (dim==3)
+        return point2[2] - point1[2];
+      else
+        return 0;
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::maximal_depth() const
+    {
+      // The depth is defined as relative to a reference surface (without
+      // topography) and since we don't apply topography on the CMB,
+      // the maximal depth really is the formula below, unless one applies a
+      // topography that is always strictly below zero (i.e., where the
+      // actual surface lies strictly below the reference surface).
+      return point2[0]-point1[0];
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::inner_radius () const
+    {
+      return point1[0];
+    }
+
+
+
+    template <int dim>
+    double
+    Chunk<dim>::outer_radius () const
+    {
+      return point2[0];
+    }
+
+
+
+    template <int dim>
+    bool
+    Chunk<dim>::has_curved_elements() const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    bool
+    Chunk<dim>::point_is_in_domain(const Point<dim> &point) const
+    {
+      // If mesh deformation is enabled, we have to loop over all the current
+      // grid cells to see if the given point lies in the domain.
+      // If mesh deformation is not enabled, or has not happened yet,
+      // we can use the global extents of the model domain with or without
+      // initial topography instead.
+      // This function only checks if the given point lies in the domain
+      // in its current shape at the current time. It can be called before
+      // mesh deformation is applied in the first timestep (e.g., by the boundary
+      // traction plugins), and therefore there is no guarantee
+      // that the point will still lie in the domain after initial mesh deformation.
+      if (this->get_parameters().mesh_deformation_enabled &&
+          this->simulator_is_past_initialization())
+        {
+          return Utilities::point_is_in_triangulation(this->get_mapping(), this->get_triangulation(), point, this->get_mpi_communicator());
+        }
+      // Without mesh deformation enabled, it is much cheaper to check whether the point lies in the domain.
+      else
+        {
+          const Point<dim> spherical_point = manifold->pull_back(point);
+
+          for (unsigned int d = 0; d < dim; ++d)
+            if (spherical_point[d] > point2[d]+std::numeric_limits<double>::epsilon()*std::abs(point2[d]) ||
+                spherical_point[d] < point1[d]-std::numeric_limits<double>::epsilon()*std::abs(point2[d]))
+              return false;
+
+          return true;
+        }
+    }
+
+
+
+    template <int dim>
+    std::array<double,dim>
+    Chunk<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
+    {
+      // The chunk manifold uses (radius, longitude, latitude).
+      // This is exactly what we need.
+
+      // Ignore the topography to avoid a loop when calling the
+      // AsciiDataBoundary for topography which uses this function....
+      const Point<dim> transformed_point = manifold->pull_back_sphere(position_point);
+      std::array<double,dim> position_array;
+      for (unsigned int i = 0; i < dim; ++i)
+        position_array[i] = transformed_point(i);
+
+      // Internally, the Chunk geometry uses longitudes in the range -pi...pi,
+      // and that is what pull_back_sphere() produces. But externally, we need
+      // to use 0...2*pi to match what Utilities::Coordinates::cartesian_to_spherical_coordinates()
+      // returns, for example, and what we document the AsciiBoundaryData class
+      // wants to see from input files.
+      if (position_array[1] < 0)
+        position_array[1] += 2*numbers::PI;
+
+      return position_array;
+    }
+
+
+
+    template <int dim>
+    aspect::Utilities::Coordinates::CoordinateSystem
+    Chunk<dim>::natural_coordinate_system() const
+    {
+      // TODO This will give problems somewhere down the line
+      // if geometry models are asked for their coordinate system,
+      // chunk returns spherical and then Utilitiess::Coordinates::cartesian_to_spherical
+      // is used
+      return aspect::Utilities::Coordinates::CoordinateSystem::spherical;
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    Chunk<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position_tensor) const
+    {
+      // Ignore the topography to avoid a loop when calling the
+      // AsciiDataBoundary for topography which uses this function....
+      Point<dim> position_point;
+      for (unsigned int i = 0; i < dim; ++i)
+        position_point[i] = position_tensor[i];
+      const Point<dim> transformed_point = manifold->push_forward_sphere(position_point);
+
+      return transformed_point;
+    }
+
+
+
+    template <int dim>
+    void
+    Chunk<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Chunk");
+        {
+          prm.declare_entry ("Chunk inner radius", "0.",
+                             Patterns::Double (0.),
+                             "Radius at the bottom surface of the chunk. Units: \\si{\\meter}.");
+          prm.declare_entry ("Chunk outer radius", "1.",
+                             Patterns::Double (0.),
+                             "Radius at the top surface of the chunk. Units: \\si{\\meter}.");
+
+          prm.declare_entry ("Chunk minimum longitude", "0.",
+                             Patterns::Double (-180., 360.), // enables crossing of either hemisphere
+                             "Minimum longitude of the chunk. Units: degrees.");
+          prm.declare_entry ("Chunk maximum longitude", "1.",
+                             Patterns::Double (-180., 360.), // enables crossing of either hemisphere
+                             "Maximum longitude of the chunk. Units: degrees.");
+
+          prm.declare_entry ("Chunk minimum latitude", "0.",
+                             Patterns::Double (-90., 90.),
+                             "Minimum latitude of the chunk. This value is ignored "
+                             "if the simulation is in 2d. Units: degrees.");
+          prm.declare_entry ("Chunk maximum latitude", "1.",
+                             Patterns::Double (-90., 90.),
+                             "Maximum latitude of the chunk. This value is ignored "
+                             "if the simulation is in 2d. Units: degrees.");
+
+          prm.declare_entry ("Radius repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in radius.");
+          prm.declare_entry ("Longitude repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in longitude.");
+          prm.declare_entry ("Latitude repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in latitude. This value is ignored "
+                             "if the simulation is in 2d");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Chunk<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Chunk");
+        {
+          point1[0] = prm.get_double ("Chunk inner radius");
+          point2[0] = prm.get_double ("Chunk outer radius");
+          repetitions[0] = prm.get_integer ("Radius repetitions");
+          point1[1] = prm.get_double ("Chunk minimum longitude") * constants::degree_to_radians;
+          point2[1] = prm.get_double ("Chunk maximum longitude") * constants::degree_to_radians;
+          repetitions[1] = prm.get_integer ("Longitude repetitions");
+
+          AssertThrow (point1[0] < point2[0],
+                       ExcMessage ("Inner radius must be less than outer radius."));
+          AssertThrow (point1[1] < point2[1],
+                       ExcMessage ("Minimum longitude must be less than maximum longitude."));
+          AssertThrow (point2[1] - point1[1] < 2.*numbers::PI,
+                       ExcMessage ("Maximum - minimum longitude should be less than 360 degrees."));
+
+          if (dim == 3)
+            {
+              point1[2] = prm.get_double ("Chunk minimum latitude") * constants::degree_to_radians;
+              point2[2] = prm.get_double ("Chunk maximum latitude") * constants::degree_to_radians;
+              repetitions[2] = prm.get_integer ("Latitude repetitions");
+
+              AssertThrow (point1[2] < point2[2],
+                           ExcMessage ("Minimum latitude must be less than maximum latitude."));
+              AssertThrow (point1[2] > -0.5*numbers::PI,
+                           ExcMessage ("Minimum latitude needs to be larger than -90 degrees."));
+              AssertThrow (point2[2] < 0.5*numbers::PI,
+                           ExcMessage ("Maximum latitude needs to be less than 90 degrees."));
+            }
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    namespace internal
+    {
+#define INSTANTIATE(dim) \
+  template class ChunkGeometry<dim>;
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+
+    ASPECT_REGISTER_GEOMETRY_MODEL(Chunk,
+                                   "chunk",
+                                   "A geometry which can be described as a chunk of a spherical shell, "
+                                   "bounded by lines of longitude, latitude and radius. "
+                                   "The minimum and maximum longitude, latitude (if in 3d) and depth of the chunk "
+                                   "is set in the parameter file. The chunk geometry labels its "
+                                   "2*dim sides as follows: ``west'' and ``east'': minimum and maximum "
+                                   "longitude, ``south'' and ``north'': minimum and maximum latitude, "
+                                   "``inner'' and ``outer'': minimum and maximum radii. "
+                                   "\n\n"
+                                   "The dimensions of the model are specified by parameters "
+                                   "of the following form: "
+                                   "Chunk (minimum || maximum) (longitude || latitude): "
+                                   "edges of geographical quadrangle (in degrees)"
+                                   "Chunk (inner || outer) radius: Radii at bottom and top of chunk"
+                                   "(Longitude || Latitude || Radius) repetitions: "
+                                   "number of cells in each coordinate direction."
+                                   "\n\n"
+                                   "When used in 2d, this geometry does not imply the use of "
+                                   "a spherical coordinate system. Indeed, "
+                                   "in 2d the geometry is simply a sector of an annulus in a Cartesian "
+                                   "coordinate system and consequently would correspond to "
+                                   "a sector of a cross section of the fluid filled space between two "
+                                   "infinite cylinders where one has made the assumption that "
+                                   "the velocity in direction of the cylinder axes is zero. "
+                                   "This is consistent with the definition of what we consider "
+                                   "the two-dimension case given in "
+                                   "Section~\\ref{sec:methods:2d-models}. "
+                                   "It is also possible to add initial topography to the chunk geometry, "
+                                   "based on an ascii data file. ")
+  }
+}
diff --git a/source/geometry_model/ellipsoidal_chunk.cc.bak b/source/geometry_model/ellipsoidal_chunk.cc.bak
new file mode 100644
index 00000000000..94200b97708
--- /dev/null
+++ b/source/geometry_model/ellipsoidal_chunk.cc.bak
@@ -0,0 +1,833 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+#include <aspect/utilities.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/grid/tria_accessor.h>
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/grid_tools.h>
+#include <boost/lexical_cast.hpp>
+#include <aspect/compat.h>
+
+
+/**
+ * This geometry model implements an (3d) ellipsoidal_chunk geometry which can be non-coordinate parallel.
+ * @author This plugin is a joint effort of Menno Fraters, D Sarah Stamps and Wolfgang Bangerth
+ */
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    namespace
+    {
+      template <int dim>
+      void
+      set_manifold_ids(Triangulation<dim> &triangulation)
+      {
+        for (const auto &cell : triangulation.active_cell_iterators())
+          cell->set_all_manifold_ids (15);
+      }
+
+      template <int dim>
+      void
+      clear_manifold_ids(Triangulation<dim> &triangulation)
+      {
+        for (const auto &cell : triangulation.active_cell_iterators())
+          cell->set_all_manifold_ids (numbers::flat_manifold_id);
+      }
+    }
+
+
+    namespace internal
+    {
+      /*
+       * the EllipsoidalChunkGeometry class
+       */
+
+      // Constructor
+      template <int dim>
+      EllipsoidalChunkGeometry<dim>::EllipsoidalChunkGeometry(const InitialTopographyModel::Interface<dim> &topo,
+                                                              const double para_semi_major_axis_a,
+                                                              const double para_eccentricity,
+                                                              const double para_semi_minor_axis_b,
+                                                              const double para_bottom_depth,
+                                                              const std::vector<Point<2>> &para_corners)
+        :
+        topography (&topo),
+        semi_major_axis_a (para_semi_major_axis_a),
+        eccentricity (para_eccentricity),
+        semi_minor_axis_b (para_semi_minor_axis_b),
+        bottom_depth (para_bottom_depth),
+        corners (para_corners)
+      {
+        AssertThrow (dim == 3, ExcMessage("This manifold can currently only be used in 3d."));
+      }
+
+
+
+      template <int dim>
+      Point<3>
+      EllipsoidalChunkGeometry<dim>::push_forward_ellipsoid(const Point<3> &phi_theta_d, const double semi_major_axis_a, const double eccentricity) const
+      {
+        // The following converts phi, theta and negative depth to x, y, z
+        // Depth is measured perpendicular to the ellipsoid surface
+        // (i.e. along a vector which does not generally pass through the origin)
+        // Expressions can be found in Ellipsoidal and Cartesian Coordinates Conversion
+        // Subirana, Zornoza and Hernandez-Pajares, 2011:
+        // https://gssc.esa.int/navipedia/index.php/Ellipsoidal_and_Cartesian_Coordinates_Conversion
+
+        const double phi   = phi_theta_d[0]; // Longitude in radians
+        const double theta = phi_theta_d[1]; // Latitude in radians
+        const double d     = phi_theta_d[2]; // The negative depth (a depth of 10 meters is -10)
+
+        const double R_bar = semi_major_axis_a / std::sqrt(1 - (eccentricity * eccentricity *
+                                                                std::sin(theta) * std::sin(theta))); // radius of curvature of the prime vertical
+
+        return Point<3> ((R_bar + d) * std::cos(phi) * std::cos(theta),
+                         (R_bar + d) * std::sin(phi) * std::cos(theta),
+                         ((1 - eccentricity * eccentricity) * R_bar + d) * std::sin(theta));
+      }
+
+      template <int dim>
+      Point<3>
+      EllipsoidalChunkGeometry<dim>::pull_back_ellipsoid(const Point<3> &x, const double semi_major_axis_a, const double eccentricity) const
+      {
+        // The following converts x, y, z to phi, theta and negative depth
+        // Depth is measured perpendicular to the ellipsoid surface
+        // (i.e. along a vector which does not generally pass through the origin)
+        // Expressions can be found in Ellipsoidal and Cartesian Coordinates Conversion
+        // Subirana, Zornoza and Hernandez-Pajares, 2011:
+        // https://gssc.esa.int/navipedia/index.php/Ellipsoidal_and_Cartesian_Coordinates_Conversion
+
+        const double R      = semi_major_axis_a; // semi-major axis
+        const double b      = R * std::sqrt(1 - eccentricity * eccentricity); // semi-minor axis
+        const double p      = std::sqrt(x(0) * x(0) + x(1) * x(1)); // distance from origin projected onto x-y plane
+        const double th     = std::atan2(R * x(2), b * p); // starting guess for theta
+        const double phi    = std::atan2(x(1), x(0)); // azimuth (geodetic longitude)
+        const double theta  = std::atan2(x(2) + (R * R - b * b) / b * std::pow(std::sin(th),3),
+                                         (p - (eccentricity * eccentricity * R  * std::pow(std::cos(th),3)))); // first iterate for theta
+        const double R_bar  = R / (std::sqrt(1 - eccentricity * eccentricity * std::sin(theta) * std::sin(theta))); // first iterate for R_bar
+
+        Point<3> phi_theta_d;
+        phi_theta_d[0] = phi;
+
+        phi_theta_d[1] = theta;
+        phi_theta_d[2] = p / std::cos(theta) - R_bar; // first iterate for d
+        return phi_theta_d;
+      }
+
+      template <int dim>
+      Point<3>
+      EllipsoidalChunkGeometry<dim>::push_forward_topography(const Point<3> &phi_theta_d_hat) const
+      {
+        const double d_hat = phi_theta_d_hat[2]; // long, lat, depth
+        Point<dim-1> phi_theta;
+        if (dim == 3)
+          phi_theta = Point<dim-1>(phi_theta_d_hat[0] * constants::radians_to_degree,phi_theta_d_hat[1] * constants::radians_to_degree);
+        const double h = topography != nullptr ? topography->value(phi_theta) : 0;
+        const double d = d_hat + (d_hat + bottom_depth)/bottom_depth*h;
+        const Point<3> phi_theta_d (phi_theta_d_hat[0],
+                                    phi_theta_d_hat[1],
+                                    d);
+        return phi_theta_d;
+      }
+
+      template <int dim>
+      Point<3>
+      EllipsoidalChunkGeometry<dim>::pull_back_topography(const Point<3> &phi_theta_d) const
+      {
+        const double d = phi_theta_d[2];
+        Point<dim-1> phi_theta;
+        if (dim == 3)
+          phi_theta = Point<dim-1>(phi_theta_d[0] * constants::radians_to_degree,
+                                   phi_theta_d[1] * constants::radians_to_degree);
+        const double h = topography != nullptr ? topography->value(phi_theta) : 0;
+        const double d_hat = bottom_depth * (d-h)/(bottom_depth+h);
+        const Point<3> phi_theta_d_hat (phi_theta_d[0],
+                                        phi_theta_d[1],
+                                        d_hat);
+        return phi_theta_d_hat;
+      }
+
+      /**
+       * TODO: These functions (pull back and push forward) should be changed that they always
+       * take and return 3d points, because 2d points make no sense for an ellipsoid, even with
+       * a 2d triangulation. To do this correctly we need to add the spacedim to the triangulation
+       * in ASPECT. What is now presented is just a temporary fix to get access to the pull back
+       * function from outside. The push forward function can't be fixed in this way, because
+       * it is used by a bind statement.
+       */
+      template <int dim>
+      Point<3>
+      EllipsoidalChunkGeometry<dim>::pull_back(const Point<3> &space_point) const
+      {
+        return pull_back_topography(pull_back_ellipsoid (space_point, semi_major_axis_a, eccentricity));
+
+      }
+
+      template <int dim>
+      Point<2>
+      EllipsoidalChunkGeometry<dim>::pull_back(const Point<2> &space_point) const
+      {
+        return space_point;
+
+      }
+
+      template <int dim>
+      Point<3>
+      EllipsoidalChunkGeometry<dim>::push_forward(const Point<3> &chart_point) const
+      {
+        return push_forward_ellipsoid (push_forward_topography(chart_point), semi_major_axis_a, eccentricity);
+      }
+
+      template <int dim>
+      std::unique_ptr<Manifold<dim,3>>
+      EllipsoidalChunkGeometry<dim>::clone() const
+      {
+        return std::make_unique<EllipsoidalChunkGeometry>(*this);
+      }
+    }
+
+    template <int dim>
+    void
+    EllipsoidalChunk<dim>::initialize()
+    {
+      manifold = std::make_unique<internal::EllipsoidalChunkGeometry<dim>>(this->get_initial_topography_model(),
+                                                                            semi_major_axis_a,
+                                                                            eccentricity,
+                                                                            semi_minor_axis_b,
+                                                                            bottom_depth,
+                                                                            corners);
+    }
+
+
+
+    template <>
+    void
+    EllipsoidalChunk<3>::create_coarse_mesh(parallel::distributed::Triangulation<3> &coarse_grid) const
+    {
+      const int dim = 3;
+
+      // Generate parallelepiped grid with one point (point 0) at (0,0,0) and the
+      // other corners (respectively corner 1,2 and 4) placed relative to that point.
+      const Point<3> corner_points[dim] = {Point<dim>((corners[1][0]-corners[0][0])*constants::degree_to_radians,
+                                                      (corners[1][1]-corners[0][1])*constants::degree_to_radians,
+                                                      0),
+                                           Point<dim>((corners[3][0]-corners[0][0])*constants::degree_to_radians,
+                                                      (corners[3][1]-corners[0][1])*constants::degree_to_radians,
+                                                      0),
+                                           Point<dim>(0,
+                                                      0,
+                                                      bottom_depth)
+                                          };
+      const unsigned int  subdivisions[dim] = {EW_subdiv, NS_subdiv, depth_subdiv};
+
+      GridGenerator::subdivided_parallelepiped (coarse_grid, subdivisions, corner_points, true);
+
+      // Shift the grid point at (0,0,0) (and the rest of the
+      // points with it) to the correct location at corner[0] at a
+      // negative depth.
+      const Point<3> base_point(corners[0][0] * constants::degree_to_radians,
+                                corners[0][1] * constants::degree_to_radians,
+                                -bottom_depth);
+      GridTools::shift(base_point,coarse_grid);
+
+      // Transform to the ellipsoid surface
+      GridTools::transform (
+        [&](const Point<dim> &x) -> Point<dim>
+      {
+        return manifold->push_forward(x);
+      },
+      coarse_grid);
+
+      // Also attach the real manifold to slot 15 (arbitrarily chosen).
+      // We won't use it during regular operation, but we set manifold_ids for
+      // all cells, faces and edges immediately before refinement and
+      // clear it again afterwards
+      coarse_grid.set_manifold (15, *manifold);
+
+      coarse_grid.signals.pre_refinement.connect (
+        [&] {set_manifold_ids(coarse_grid);});
+      coarse_grid.signals.post_refinement.connect (
+        [&] {clear_manifold_ids(coarse_grid);});
+      coarse_grid.signals.post_refinement.connect (
+        [&] {this->set_boundary_ids(coarse_grid);});
+    }
+
+    template <int dim>
+    void
+    EllipsoidalChunk<dim>::create_coarse_mesh(parallel::distributed::Triangulation<dim> &/*coarse_grid*/) const
+    {
+      Assert(false, ExcNotImplemented());
+    }
+
+    template <int dim>
+    void
+    EllipsoidalChunk<dim>::set_boundary_ids(parallel::distributed::Triangulation<dim> &coarse_grid) const
+    {
+      // set all boundary indicators. we want the edges to be curved
+      // as well. for this, it matters in which order we call
+      // set_all_boundary_indicators() -- we have to do it last for
+      // the inner and outer boundary, which conveniently is what
+      // happens in the following loop
+      for (const auto &cell : coarse_grid.active_cell_iterators())
+        for (const unsigned int f : cell->face_indices())
+          if (cell->face(f)->at_boundary())
+            cell->face(f)->set_boundary_id(f);
+    }
+
+    template <int dim>
+    std::set<types::boundary_id>
+    EllipsoidalChunk<dim>::get_used_boundary_indicators() const
+    {
+      // boundary indicators are zero through 2*dim-1
+      std::set<types::boundary_id> s;
+      for (unsigned int i = 0; i < 2 * dim; ++i)
+        s.insert(i);
+      return s;
+    }
+
+    template <int dim>
+    std::map<std::string,types::boundary_id>
+    EllipsoidalChunk<dim>::
+    get_symbolic_boundary_names_map () const
+    {
+      switch (dim)
+        {
+          case 2:
+          {
+            return
+            {
+              {"east",   0},
+              {"west",   1},
+              {"bottom", 2},
+              {"top",    3}
+            };
+          }
+
+          case 3:
+          {
+            return
+            {
+              {"east",   0},
+              {"west",   1},
+              {"north",  2},
+              {"south",  3},
+              {"bottom", 4},
+              {"top",    5}
+            };
+          }
+        }
+
+      Assert (false, ExcNotImplemented());
+      return {};
+    }
+
+    template <int dim>
+    void
+    EllipsoidalChunk<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Ellipsoidal chunk");
+        {
+          prm.declare_entry("NE corner",
+                            "",
+                            Patterns::Anything(),
+                            "Longitude:latitude in degrees of the North-East corner point of model region."
+                            "The North-East direction is positive. If one of the three corners is not provided "
+                            "the missing corner value will be calculated so all faces are parallel.");
+          prm.declare_entry("NW corner",
+                            "",
+                            Patterns::Anything(),
+                            "Longitude:latitude in degrees of the North-West corner point of model region. "
+                            "The North-East direction is positive. If one of the three corners is not provided "
+                            "the missing corner value will be calculated so all faces are parallel.");
+          prm.declare_entry("SW corner",
+                            "",
+                            Patterns::Anything(),
+                            "Longitude:latitude in degrees of the South-West corner point of model region. "
+                            "The North-East direction is positive. If one of the three corners is not provided "
+                            "the missing corner value will be calculated so all faces are parallel.");
+          prm.declare_entry("SE corner",
+                            "",
+                            Patterns::Anything(),
+                            "Longitude:latitude in degrees of the South-East corner point of model region. "
+                            "The North-East direction is positive. If one of the three corners is not provided "
+                            "the missing corner value will be calculated so all faces are parallel.");
+          prm.declare_entry("Depth",
+                            "500000.0",
+                            Patterns::Double(0.),
+                            "Bottom depth of model region.");
+          prm.declare_entry("Semi-major axis",
+                            "6378137.0",
+                            Patterns::Double(0.),
+                            "The semi-major axis (a) of an ellipsoid. This is the radius for a sphere (eccentricity=0). Default WGS84 semi-major axis.");
+          prm.declare_entry("Eccentricity",
+                            "8.1819190842622e-2",
+                            Patterns::Double(0.),
+                            "Eccentricity of the ellipsoid. Zero is a perfect sphere, default (8.1819190842622e-2) is WGS84.");
+          prm.declare_entry("East-West subdivisions",
+                            "1",
+                            Patterns::Integer(0),
+                            "The number of subdivisions of the coarse (initial) mesh in the East-West direction.");
+          prm.declare_entry("North-South subdivisions",
+                            "1",
+                            Patterns::Integer(0),
+                            "The number of subdivisions of the coarse (initial) mesh in the North-South direction.");
+          prm.declare_entry("Depth subdivisions",
+                            "1",
+                            Patterns::Integer(0),
+                            "The number of subdivisions of the coarse (initial) mesh in depth.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    EllipsoidalChunk<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      AssertThrow (dim == 3, ExcMessage("This geometry can currently only be used in 3d."));
+
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Ellipsoidal chunk");
+        {
+          // Get latitude and longitudes defining region of interest from
+          // the parameter file.
+          corners.resize(4);
+          std::string NEcorner = prm.get("NE corner");
+          std::string NWcorner = prm.get("NW corner");
+          std::string SWcorner = prm.get("SW corner");
+          std::string SEcorner = prm.get("SE corner");
+
+          // make a list of what corners are present and check that there should be one or two corner missing,
+          // otherwise throw an exception
+          std::vector<bool> present(4,true);
+          unsigned int missing = 0;
+          if (NEcorner == "")
+            {
+              ++missing;
+              present[0] = false;
+            }
+          if (NWcorner == "")
+            {
+              ++missing;
+              present[1] = false;
+            }
+          if (SWcorner == "")
+            {
+              ++missing;
+              present[2] = false;
+            }
+          if (SEcorner == "")
+            {
+              ++missing;
+              present[3] = false;
+            }
+
+          AssertThrow (missing != 0,
+                       ExcMessage ("Only two or three of the four corner points should be provided."));
+          AssertThrow (missing == 1 || missing == 2,
+                       ExcMessage ("Please provide two or three corner points."));
+
+          std::vector<double> temp;
+
+          if (present[0])
+            {
+              temp = Utilities::string_to_double(Utilities::split_string_list(NEcorner,':'));
+              AssertThrow (temp.size() == 2, ExcMessage ("Two coordinates should be given for the NE-corner (longitude:latitude)."));
+              corners[0] = Point<2>(temp[0],temp[1]);
+            }
+          else
+            corners[0]= Point<2>();
+
+          if (present[1])
+            {
+              temp = Utilities::string_to_double(Utilities::split_string_list(NWcorner,':'));
+              AssertThrow (temp.size() == 2, ExcMessage ("Two coordinates should be given for the NW-corner (longitude:latitude)."));
+              corners[1] = Point<2>(temp[0],temp[1]);
+            }
+          else
+            corners[1]= Point<2>();
+
+          if (present[2])
+            {
+              temp = Utilities::string_to_double(Utilities::split_string_list(SWcorner,':'));
+              AssertThrow (temp.size() == 2, ExcMessage ("Two coordinates should be given for the SW-corner (longitude:latitude)."));
+              corners[2] = Point<2>(temp[0],temp[1]);
+            }
+          else
+            corners[2]= Point<2>();
+
+          if (present[3])
+            {
+              temp = Utilities::string_to_double(Utilities::split_string_list(SEcorner,':'));
+              AssertThrow (temp.size() == 2, ExcMessage ("Two coordinates should be given for the SE-corner (longitude:latitude)."));
+              corners[3] = Point<2>(temp[0],temp[1]);
+            }
+          else
+            corners[3]= Point<2>();
+
+
+          bottom_depth = prm.get_double("Depth");
+          semi_major_axis_a = prm.get_double("Semi-major axis");
+          eccentricity = prm.get_double("Eccentricity");
+          semi_minor_axis_b = std::sqrt((1 - pow(eccentricity,2.)) * pow(semi_major_axis_a,2.));
+          EW_subdiv = prm.get_integer("East-West subdivisions");
+          NS_subdiv = prm.get_integer("North-South subdivisions");
+          depth_subdiv = prm.get_integer("Depth subdivisions");
+
+          // Check whether the corners of the rectangle are really placed correctly
+          if (present[0] == true && present[1] == true)
+            {
+              AssertThrow (corners[0][0] >= corners[1][0],
+                           ExcMessage ("The longitude of the NE corner (" + boost::lexical_cast<std::string>(corners[0][0]) + ") cannot be smaller than the longitude of the NW corner (" + boost::lexical_cast<std::string>(corners[1][0]) + ")."));
+            }
+          if (present[0] == true && present[3] == true)
+            {
+              AssertThrow (corners[0][1] >= corners[3][1],
+                           ExcMessage ("The latitude of the NE (" + boost::lexical_cast<std::string>(corners[0][1]) + ") corner cannot be smaller than the latitude of the SE corner (" + boost::lexical_cast<std::string>(corners[3][1]) + ")."));
+            }
+          if (present[2] == true && present[3] == true)
+            {
+              AssertThrow (corners[2][0] <= corners[3][0],
+                           ExcMessage ("The longitude of the SW (" + boost::lexical_cast<std::string>(corners[2][0]) + ") corner cannot be larger than the longitude of the SE corner (" + boost::lexical_cast<std::string>(corners[3][0]) + ")."));
+            }
+          if (present[2] == true && present[1] == true)
+            {
+              AssertThrow (corners[2][1] <= corners[1][1],
+                           ExcMessage ("The latitude of the SW corner (" + boost::lexical_cast<std::string>(corners[2][1]) + ") cannot be larger than the latitude of the NW corner (" + boost::lexical_cast<std::string>(corners[1][1]) + ")."));
+            }
+          if (missing == 2)
+            {
+              AssertThrow ((present[0] == true && present[2] == true) || (present[1] == true && present[3] == true),
+                           ExcMessage ("Please provide two opposing corners."));
+
+              if (present[0] == true && present[2] == true)
+                AssertThrow (corners[0][0] > corners[2][0] && corners[0][1] > corners[2][1],
+                             ExcMessage ("The Northeast corner (" + boost::lexical_cast<std::string>(corners[0][0]) + ":"  + boost::lexical_cast<std::string>(corners[0][1]) + ") must be strictly north and east of the Southwest corner (" + boost::lexical_cast<std::string>(corners[2][0]) + ":"  + boost::lexical_cast<std::string>(corners[2][1]) + ") when only two points are given."));
+
+              if (present[1] == true && present[3] == true)
+                AssertThrow (corners[1][0] < corners[3][0] && corners[1][1] > corners[3][1],
+                             ExcMessage ("The Northwest corner (" + boost::lexical_cast<std::string>(corners[1][0]) + ":"  + boost::lexical_cast<std::string>(corners[1][1]) + ") must be strictly north and west of the Southeast corner (" + boost::lexical_cast<std::string>(corners[3][0]) + ":"  + boost::lexical_cast<std::string>(corners[3][1]) + ") when only two points are given."));
+            }
+
+
+          // If one or two of the corners is not provided, calculate it.
+          if (missing == 1)
+            {
+              for (unsigned int i = 0; i <= 3; ++i)
+                {
+                  // find the corner which is missing, if there is one
+                  if (present[i] == false)
+                    {
+                      // find the location of this corner
+                      // the values for the values is:
+                      // [i] = [i+1] + ([i+3] - [i+2])
+                      unsigned int ip = i + 1;
+                      unsigned int ipp = i + 2;
+                      unsigned int ippp = i + 3;
+
+                      if (ip > 3)
+                        ip -= 4;
+                      if (ipp > 3)
+                        ipp -= 4;
+                      if (ippp > 3)
+                        ippp -=4;
+
+                      corners[i] = corners[ip];
+                      corners[i][0] = corners[ip][0] + (corners[ippp][0] - corners[ipp][0]);
+                      corners[i][1] = corners[ip][1] + (corners[ippp][1] - corners[ipp][1]);
+                    }
+                }
+            }
+          else if (missing == 2)
+            {
+              // find the location of this corner
+              if (present[0] == false)
+                {
+                  corners[0] = corners[1];
+                  corners[2] = corners[3];
+                  corners[0][0] = corners[3][0];
+                  corners[2][0] = corners[1][0];
+                }
+              else
+                {
+                  corners[1] = corners[0];
+                  corners[3] = corners[2];
+                  corners[1][0] = corners[2][0];
+                  corners[3][0] = corners[0][0];
+                }
+            }
+          // Check that the calculated corners also obey the rules for the location of the corners.
+          Assert (corners[0][0] >= corners[1][0],
+                  ExcMessage ("The longitude of the NE corner (" + boost::lexical_cast<std::string>(corners[0][0]) + ") cannot be smaller than the longitude of the NW corner (" + boost::lexical_cast<std::string>(corners[1][0]) + "). This is an internal check, if you see this please contact the developer."));
+
+          Assert (corners[0][1] >= corners[3][1],
+                  ExcMessage ("The latitude of the NE (" + boost::lexical_cast<std::string>(corners[0][1]) + ") corner cannot be smaller than the latitude of the SE corner (" + boost::lexical_cast<std::string>(corners[3][1]) + "). This is an internal check, if you see this please contact the developer."));
+
+          Assert (corners[2][0] <= corners[3][0],
+                  ExcMessage ("The longitude of the SW (" + boost::lexical_cast<std::string>(corners[2][0]) + ") corner cannot be larger than the longitude of the SE corner (" + boost::lexical_cast<std::string>(corners[3][0]) + "). This is an internal check, if you see this please contact the developer."));
+
+          Assert (corners[2][1] <= corners[1][1],
+                  ExcMessage ("The latitude of the SW corner (" + boost::lexical_cast<std::string>(corners[2][1]) + ") cannot be larger than the latitude of the NW corner (" + boost::lexical_cast<std::string>(corners[1][1]) + "). This is an internal check, if you see this please contact the developer."));
+
+          westLongitude = corners[2][0];
+          eastLongitude = corners[0][0];
+          northLatitude = corners[0][1];
+          southLatitude = corners[2][1];
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    double
+    EllipsoidalChunk<dim>::depth(const Point<dim> &position) const
+    {
+      return std::max(std::min(-manifold->pull_back(position)[dim-1], maximal_depth()), 0.0);
+    }
+
+    template <int dim>
+    double
+    EllipsoidalChunk<dim>::height_above_reference_surface(const Point<dim> &/*position*/) const
+    {
+      AssertThrow(false, ExcMessage("Function height_above_reference_surface is not yet implemented "
+                                    "for the ellipsoidal chunk geometry model. "
+                                    "Consider using a box, spherical shell, or chunk.") );
+      return numbers::signaling_nan<double>();
+    }
+
+
+    template <int dim>
+    double
+    EllipsoidalChunk<dim>::maximal_depth() const
+    {
+      return bottom_depth;
+    }
+
+    template <int dim>
+    double
+    EllipsoidalChunk<dim>::get_radius(const Point<dim> &position) const
+    {
+      const Point<dim> long_lat_depth = manifold->pull_back(position);
+      return semi_major_axis_a / (std::sqrt(1 - eccentricity * eccentricity * std::sin(long_lat_depth[1]) * std::sin(long_lat_depth[1])));
+    }
+
+    template <int dim>
+    double
+    EllipsoidalChunk<dim>::get_eccentricity() const
+    {
+      return eccentricity;
+    }
+
+    template <int dim>
+    const std::vector<Point<2>> &
+    EllipsoidalChunk<dim>::get_corners() const
+    {
+      return corners;
+    }
+
+    template <int dim>
+    double
+    EllipsoidalChunk<dim>::get_semi_minor_axis_b() const
+    {
+      return semi_minor_axis_b;
+    }
+
+    template <int dim>
+    double
+    EllipsoidalChunk<dim>::get_semi_major_axis_a() const
+    {
+      return semi_major_axis_a;
+    }
+
+
+    template <int dim>
+    double
+    EllipsoidalChunk<dim>::length_scale() const
+    {
+      // As described in the first ASPECT paper, a length scale of
+      // 10km = 1e4m works well for the pressure scaling for earth
+      // sized spherical shells. use a length scale that
+      // yields this value for the R0,R1 corresponding to earth
+      // but otherwise scales like (R1-R0)
+      return 1e4 * maximal_depth() / (6336000.-3481000.);
+    }
+
+    template <int dim>
+    Point<dim>
+    EllipsoidalChunk<dim>::representative_point(const double /*depth*/) const
+    {
+      return Point<dim>();
+    }
+
+    template <>
+    Point<3>
+    EllipsoidalChunk<3>::representative_point(const double depth) const
+    {
+      const int dim = 3;
+      Assert(depth >= 0, ExcMessage("Given depth must be positive or zero."));
+      Assert(depth <= maximal_depth(),
+             ExcMessage("Given depth must be less than or equal to the maximal depth of this geometry."));
+
+      // Choose a point on the center axis of the domain
+      Point<dim> p = Point<3>((eastLongitude + westLongitude) * 0.5 * constants::degree_to_radians,
+                              (southLatitude + northLatitude) * 0.5 * constants::degree_to_radians,
+                              -depth);
+
+      return manifold->push_forward(p);
+    }
+
+
+    template <int dim>
+    bool
+    EllipsoidalChunk<dim>::point_is_in_domain(const Point<dim> &point) const
+    {
+      AssertThrow(!this->get_parameters().mesh_deformation_enabled ||
+                  this->get_timestep_number() == 0,
+                  ExcMessage("After displacement of the mesh, this function can no longer be used to determine whether a point lies in the domain or not."));
+
+      // dim = 3
+      const Point<dim> ellipsoidal_point = manifold->pull_back(point);
+
+      // compare deflection from the ellipsoid surface
+      if (ellipsoidal_point[dim-1] > 0.0+std::numeric_limits<double>::epsilon()*bottom_depth ||
+          -ellipsoidal_point[dim-1] > bottom_depth+std::numeric_limits<double>::epsilon()*bottom_depth)
+        return false;
+
+      // compare lon/lat
+      if (!Utilities::polygon_contains_point<dim>(corners, Point<2>(ellipsoidal_point[0]*constants::radians_to_degree,ellipsoidal_point[1]*constants::radians_to_degree)))
+        return false;
+
+      return true;
+    }
+
+    template <int dim>
+    std::array<double,dim>
+    EllipsoidalChunk<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
+    {
+      // the chunk manifold works internally with a vector with longitude, latitude, depth.
+      // We need to output radius, longitude, latitude to be consistent.
+      // Ignore the topography by calling pull_back_ellipsoid to avoid a loop when calling the
+      // AsciiDataBoundary for topography which uses this function....
+      Point<3> cartesian_point;
+      for (unsigned int d=0; d<dim; ++d)
+        cartesian_point[d] = position_point[d];
+
+      Point<3> transformed_point = manifold->pull_back_ellipsoid(cartesian_point, semi_major_axis_a, eccentricity);
+
+      const double radius =  semi_major_axis_a /
+                             (std::sqrt(1 - eccentricity * eccentricity * std::sin(transformed_point[1]) * std::sin(transformed_point[1])));
+      std::array<double,dim> position_array;
+      position_array[0] = radius + transformed_point(2);
+      position_array[1] = transformed_point(0);
+      position_array[2] = transformed_point(1);
+
+      return position_array;
+    }
+
+
+    template <int dim>
+    aspect::Utilities::Coordinates::CoordinateSystem
+    EllipsoidalChunk<dim>::natural_coordinate_system() const
+    {
+      return aspect::Utilities::Coordinates::CoordinateSystem::ellipsoidal;
+    }
+
+
+    template <>
+    Point<3>
+    EllipsoidalChunk<3>::natural_to_cartesian_coordinates(const std::array<double,3> &position_tensor) const
+    {
+      // We receive radius, longitude, latitude and we need to turn it first back into
+      // longitude, latitude, depth for internal use, and push_forward to cartesian coordinates.
+      // Ignore the topography by calling push_forward_ellipsoid to avoid a loop when calling the
+      // AsciiDataBoundary for topography which uses this function....
+      Point<3> position_point;
+      position_point(0) = position_tensor[1];
+      position_point(1) = position_tensor[2];
+
+      const double radius = semi_major_axis_a / (std::sqrt(1 - eccentricity * eccentricity * std::sin(position_point(1)) * std::sin(position_point(1))));
+      position_point(2) = position_tensor[0] - radius;
+
+      Point<3> transformed_point = manifold->push_forward_ellipsoid(position_point, semi_major_axis_a, eccentricity);
+      return transformed_point;
+    }
+
+
+    template <>
+    Point<2>
+    EllipsoidalChunk<2>::natural_to_cartesian_coordinates(const std::array<double,2> &/*position_tensor*/) const
+    {
+      Assert(false, ExcMessage("This geometry model doesn't support 2d."));
+      return {};
+    }
+
+  }
+}
+
+template <int dim>
+typename aspect::GeometryModel::internal::EllipsoidalChunkGeometry<dim>
+aspect::GeometryModel::EllipsoidalChunk<dim>::get_manifold() const
+{
+  return *manifold;
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    namespace internal
+    {
+#define INSTANTIATE(dim) \
+  template class EllipsoidalChunkGeometry<dim>;
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+
+    ASPECT_REGISTER_GEOMETRY_MODEL(EllipsoidalChunk,
+                                   "ellipsoidal chunk",
+                                   "A 3d chunk geometry that accounts for Earth's ellipticity (default assuming the "
+                                   "WGS84 ellipsoid definition) which can be defined in non-coordinate directions. "
+                                   "In the description of the ellipsoidal chunk, two of the ellipsoidal axes have the "
+                                   "same length so that there is only a semi-major axis and a semi-minor axis. "
+                                   "The user has two options for creating an ellipsoidal chunk geometry: 1) by defining "
+                                   "two opposing points (SW and NE or NW and SE) a coordinate parallel ellipsoidal "
+                                   "chunk geometry will be created. 2) by defining three points a non-coordinate "
+                                   "parallel ellipsoidal chunk will be created. The points are defined in the input "
+                                   "file by longitude:latitude. It is also possible to define additional subdivisions "
+                                   "of the mesh in each direction. The boundary of the domain is formed by linear "
+                                   "interpolation in longitude-latitude space between adjacent points "
+                                   "(i.e. $[lon, lat](f) = [lon1 \\cdot f + lon2 \\cdot(1-f), lat1 \\cdot f + lat2 \\cdot (1-f)]$, "
+                                   "where f is a value between 0 and 1). Faces of the model are defined as "
+                                   "0, west; 1,east; 2, south; 3, north; 4, inner; 5, outer.\n\n"
+                                   "This geometry model supports initial topography for deforming the initial mesh.")
+  }
+}
diff --git a/source/geometry_model/initial_topography_model/ascii_data.cc.bak b/source/geometry_model/initial_topography_model/ascii_data.cc.bak
new file mode 100644
index 00000000000..121128a23ba
--- /dev/null
+++ b/source/geometry_model/initial_topography_model/ascii_data.cc.bak
@@ -0,0 +1,204 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/geometry_model/initial_topography_model/ascii_data.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/chunk.h>
+
+#include <deal.II/base/parameter_handler.h>
+#include <array>
+
+
+
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      :
+      surface_boundary_id(1)
+    {}
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+      Utilities::AsciiDataBoundary<dim>::initialize({surface_boundary_id},
+                                                    1);
+    }
+
+
+    template <int dim>
+    double
+    AsciiData<dim>::value (const Point<dim-1> &surface_point) const
+    {
+      // In a first step, create a global 'dim'-dimensional point that we can pass to the
+      // function expression as input -- because the function is a dim-dimensional
+      // function.
+      //
+      // Different geometry models pass the surface point in in different ways.
+      // In the following, we will first normalize the input to a dim-dimensional
+      // point with a dummy vertical/radial coordinate that, one would hope,
+      // the AsciiDataBoundary class will then simply ignore.
+      Point<dim> global_point;
+      if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()) ||
+          Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
+        {
+          for (unsigned int d=0; d<dim-1; ++d)
+            global_point[d] = surface_point[d];
+
+          // Now for the vertical component:
+          global_point[dim-1] = 0;
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()) ||
+               Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()) ||
+               Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
+        {
+          // AsciiDataBoundary always expects to get the input
+          // parameters for its functions in Cartesian
+          // coordinates. The get_data_component function then changes
+          // the coordinate system, or more precisely it asks the
+          // geometry model to convert the point into its natural
+          // coordinate system, before doing the table lookup.
+          //
+          // This is of course all not very efficient (TODO: Think
+          // about a better scheme), but the first step then needs to
+          // be to convert what we have into Cartesian coordinates...
+          std::array<double, dim> point;
+          point[0] = 6371000.0;
+          for (unsigned int d=0; d<dim-1; ++d)
+            point[d+1] = surface_point[d];
+
+          global_point = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(point);
+        }
+      else
+        AssertThrow(false, ExcNotImplemented());
+
+      const double topo = this->Utilities::AsciiDataBoundary<dim>::get_data_component(surface_boundary_id,
+                                                                                      global_point,
+                                                                                      0);
+
+      return topo;
+    }
+
+
+
+    template <int dim>
+    Tensor<1,dim-1>
+    AsciiData<dim>::vector_gradient(const Point<dim> &point) const
+    {
+      return Utilities::AsciiDataBoundary<dim>::vector_gradient(surface_boundary_id, point,0);
+    }
+
+
+
+    template <int dim>
+    double
+    AsciiData<dim>::max_topography () const
+    {
+      return Utilities::AsciiDataBoundary<dim>::get_maximum_component_value(surface_boundary_id,0);
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Initial topography model");
+        {
+          Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                            "$ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/",
+                                                            "box_2d_%s.0.txt");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Initial topography model");
+        {
+          Utilities::AsciiDataBase<dim>::parse_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(AsciiData,
+                                             "ascii data",
+                                             "Implementation of a model in which the surface "
+                                             "topography is derived from a file containing data "
+                                             "in ascii format. The following geometry models "
+                                             "are currently supported: box, chunk. "
+                                             "Note the required format of the "
+                                             "input data: The first lines may contain any number of comments "
+                                             "if they begin with `#', but one of these lines needs to "
+                                             "contain the number of grid points in each dimension as "
+                                             "for example `# POINTS: 3 3'. "
+                                             "The order of the data columns "
+                                             "has to be `x', `Topography [m]' in a 2d model and "
+                                             " `x', `y', `Topography [m]' in a 3d model, which means that "
+                                             "there has to be a single column "
+                                             "containing the topography. "
+                                             "Note that the data in the input "
+                                             "file needs to be sorted in a specific order: "
+                                             "the first coordinate needs to ascend first, "
+                                             "followed by the second in order to "
+                                             "assign the correct data to the prescribed coordinates. "
+                                             "If you use a spherical model, "
+                                             "then the assumed grid changes. "
+                                             "`x' will be replaced by the azimuth angle (longitude) "
+                                             "in radians (between zero and $2\\pi$, not between $-\\pi$ "
+                                             "corresponding to 180 degrees west, and $+\\pi$ corresponding "
+                                             "to 180 degrees east), "
+                                             "and `y' by the polar angle in radians (between $0$ and $\\pi$) measured "
+                                             "positive from the north pole. The grid will be assumed to be "
+                                             "a longitude-colatitude grid. Note that the order "
+                                             "of spherical coordinates is `phi', `theta' "
+                                             "and not `theta', `phi', since this allows "
+                                             "for dimension independent expressions.")
+  }
+}
diff --git a/source/geometry_model/initial_topography_model/function.cc.bak b/source/geometry_model/initial_topography_model/function.cc.bak
new file mode 100644
index 00000000000..39b15e95768
--- /dev/null
+++ b/source/geometry_model/initial_topography_model/function.cc.bak
@@ -0,0 +1,190 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/initial_topography_model/function.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/chunk.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    template <int dim>
+    Function<dim>::Function ()
+      :
+      max_topo(0),
+      initial_topography_function (1),
+      coordinate_system(Utilities::Coordinates::CoordinateSystem::cartesian)
+    {}
+
+
+
+    template <int dim>
+    double
+    Function<dim>::
+    value (const Point<dim-1> &surface_point) const
+    {
+      // In a first step, create a global 'dim'-dimensional point that we can pass to the
+      // function expression as input -- because the function is a dim-dimensional
+      // function.
+      //
+      // Different geometry models pass the surface point in in different ways.
+      // In the following, we will first normalize the input to a dim-dimensional
+      // point with a dummy vertical/radial coordinate that, one would hope,
+      // the function expression will then simply ignore.
+      Point<dim> global_point;
+
+      if (Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
+          Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
+        {
+          for (unsigned int d=0; d<dim-1; ++d)
+            global_point[d] = surface_point[d];
+
+          // Now for the vertical component:
+          global_point[dim-1] = 0;
+
+          // The point as it is would have to be translated into a different
+          // coordinate system if that was requested in the input file.
+          // This is not currently implemented.
+          Assert (coordinate_system == Utilities::Coordinates::CoordinateSystem::cartesian,
+                  ExcNotImplemented());
+        }
+      else if (Plugins::plugin_type_matches<GeometryModel::Sphere<dim>>(this->get_geometry_model()) ||
+               Plugins::plugin_type_matches<GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) ||
+               Plugins::plugin_type_matches<GeometryModel::Chunk<dim>>(this->get_geometry_model()) )
+        {
+          std::array<double, dim> point;
+          point[0] = 6371000.0;
+          for (unsigned int d=0; d<dim-1; ++d)
+            point[d+1] = surface_point[d];
+
+          global_point = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(point);
+
+          // The point as it is would have to be translated into a different
+          // coordinate system (or, perhaps, better just left in the spherical
+          // coordinates we received) if that was requested in the input file.
+          // This is not currently implemented.
+          Assert (coordinate_system == Utilities::Coordinates::CoordinateSystem::cartesian,
+                  ExcNotImplemented());
+        }
+      else
+        AssertThrow(false, ExcNotImplemented());
+
+      const double topo = initial_topography_function.value(global_point);
+
+      return topo;
+    }
+
+
+    template <int dim>
+    double
+    Function<dim>::
+    max_topography () const
+    {
+      return max_topo;
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Initial topography model");
+        {
+          prm.enter_subsection("Function");
+          {
+            prm.declare_entry ("Maximum topography value", "2000.",
+                               Patterns::Double (0.),
+                               "The maximum value the topography given by "
+                               "the function can take. ");
+            prm.declare_entry ("Coordinate system", "cartesian",
+                               Patterns::Selection ("cartesian|spherical"),
+                               "A selection that determines the assumed coordinate "
+                               "system for the function variables. Allowed values "
+                               "are `cartesian' and `spherical'. `spherical' coordinates "
+                               "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                               "respectively with theta being the polar angle. ");
+
+            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Initial topography model");
+        {
+          prm.enter_subsection("Function");
+          {
+            coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+          }
+          max_topo = prm.get_double("Maximum topography value");
+          try
+            {
+              initial_topography_function.parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Boundary traction model.Function'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(Function,
+                                             "function",
+                                             "Implementation of a model in which the initial topography "
+                                             "is described by a function in Cartesian or spherical coordinates. ")
+  }
+}
diff --git a/source/geometry_model/initial_topography_model/interface.cc.bak b/source/geometry_model/initial_topography_model/interface.cc.bak
new file mode 100644
index 00000000000..f056b45c7f0
--- /dev/null
+++ b/source/geometry_model/initial_topography_model/interface.cc.bak
@@ -0,0 +1,176 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+#include <list>
+
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+// -------------------------------- Deal with registering initial topography models and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      internal::Plugins::PluginList<Interface<2>>,
+      internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    register_initial_topography_model (const std::string &name,
+                                       const std::string &description,
+                                       void (*declare_parameters_function) (ParameterHandler &),
+                                       std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_initial_topography_model (ParameterHandler &prm)
+    {
+      std::string model_name;
+      prm.enter_subsection ("Geometry model");
+      {
+        prm.enter_subsection ("Initial topography model");
+        {
+          model_name = prm.get ("Model name");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      // If one sets the model name to an empty string in the input file,
+      // ParameterHandler produces an error while reading the file. However,
+      // if one omits specifying any model name at all (not even setting it to
+      // the empty string) then the value we get here is the empty string. If
+      // we don't catch this case here, we end up with awkward downstream
+      // errors because the value obviously does not conform to the Pattern.
+      AssertThrow(model_name != "unspecified",
+                  ExcMessage("You need to select a Initial topography model "
+                             "(`set Model name' in `subsection Initial topography model')."));
+
+      return std::get<dim>(registered_plugins).create_plugin (model_name,
+                                                              "Initial topography model::model name",
+                                                              prm);
+    }
+
+
+
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm)
+    {
+      // declare the entry in the parameter file
+      prm.enter_subsection ("Geometry model");
+      {
+        prm.enter_subsection ("Initial topography model");
+        {
+          const std::string pattern_of_names
+            = std::get<dim>(registered_plugins).get_pattern_of_names ();
+          prm.declare_entry ("Model name", "zero topography",
+                             Patterns::Selection (pattern_of_names),
+                             "Select one of the following models:\n\n"
+                             +
+                             std::get<dim>(registered_plugins).get_description_string());
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Initial topography interface",
+                                                            out);
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<InitialTopographyModel::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<InitialTopographyModel::Interface<2>>::plugins = nullptr;
+
+      template <>
+      std::list<internal::Plugins::PluginList<InitialTopographyModel::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<InitialTopographyModel::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace InitialTopographyModel
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_initial_topography_model<dim> (const std::string &, \
+                                          const std::string &, \
+                                          void ( *) (ParameterHandler &), \
+                                          std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_initial_topography_model<dim> (ParameterHandler &prm);
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/geometry_model/initial_topography_model/prm_polygon.cc.bak b/source/geometry_model/initial_topography_model/prm_polygon.cc.bak
new file mode 100644
index 00000000000..6de5df06e5c
--- /dev/null
+++ b/source/geometry_model/initial_topography_model/prm_polygon.cc.bak
@@ -0,0 +1,172 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/geometry_model/initial_topography_model/prm_polygon.h>
+#include <aspect/utilities.h>
+#include <boost/lexical_cast.hpp>
+
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    template <int dim>
+    double
+    PrmPolygon<dim>::
+    value (const Point<dim-1> &p) const
+    {
+      const Point<2> p1 = (dim == 2 ? Point<2>(p[0],0) : Point<2>(p[0],p[1]));
+
+      /**
+       * We go through the loop in the reverse order, because we
+       * want the last entry in the list to prescribe the value.
+       */
+      for (unsigned int i = point_lists.size(); i > 0; i--)
+        {
+          if (aspect::Utilities::polygon_contains_point<dim>(point_lists[i-1],p1))
+            {
+              return topography_values[i-1];
+            }
+        }
+
+      // Point is not in any of the polygons. Return zero.
+      return 0;
+    }
+
+
+
+    template <int dim>
+    double
+    PrmPolygon<dim>::
+    max_topography () const
+    {
+      return maximum_topography;
+    }
+
+
+
+    template <int dim>
+    void
+    PrmPolygon<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Initial topography model");
+        {
+          prm.enter_subsection("Prm polygon");
+          {
+            prm.declare_entry("Topography parameters",
+                              "",
+                              Patterns::Anything(),
+                              "Set the topography height and the polygon which should be set to that height. "
+                              "The format is : \"The topography height \textgreater The point list describing "
+                              "a polygon \\& The next topography height \textgreater the next point list "
+                              "describing a polygon.\" The format for the point list describing the polygon is "
+                              "\"x1,y1;x2,y2\". For example for two triangular areas of 100 and -100 meters high "
+                              "set: '100 \textgreater 0,0;5,5;0,10 \\& -100 \textgreater 10,10;10,15;20,15'. "
+                              "Units of the height are always in meters. The units of the coordinates are "
+                              "dependent on the geometry model. In the box model they are in meters, in the "
+                              "chunks they are in degrees, etc. Please refer to the manual of the individual "
+                              "geometry model to so see how the topography is implemented.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    PrmPolygon<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Initial topography model");
+        {
+          prm.enter_subsection("Prm polygon");
+          {
+            /**
+             * we need to fill the point lists and topography values. They
+             * are stored in the Topography subsection in the Topography parameter.
+             */
+            maximum_topography = std::numeric_limits<double>::lowest();
+            const std::string temptopo = prm.get("Topography parameters");
+            const std::vector<std::string> temp_topographies = Utilities::split_string_list(temptopo,'&');
+            const unsigned int temp_topographies_size = temp_topographies.size();
+
+            topography_values.resize(temp_topographies_size,0);
+            point_lists.resize(temp_topographies_size);
+            for (unsigned int i_topo = 0; i_topo < temp_topographies_size; ++i_topo)
+              {
+                const std::vector<std::string> temp_topography = Utilities::split_string_list(temp_topographies[i_topo],'>');
+                Assert(temp_topography.size() == 2,ExcMessage ("The given line '" + temp_topographies[i_topo]
+                                                               + "' is not correct. It consists of "
+                                                               + boost::lexical_cast<std::string>(temp_topography.size())
+                                                               + " parts separated by >, but it should only contain "
+                                                               "two parts: the height and the list of point coordinates,"
+                                                               " separated by a >.'"));
+
+                topography_values[i_topo] = Utilities::string_to_double(temp_topography[0]);
+                maximum_topography = std::max(topography_values[i_topo],maximum_topography);
+
+                const std::vector<std::string> temp_coordinates = Utilities::split_string_list(temp_topography[1],';');
+                const unsigned int temp_coordinate_size = temp_coordinates.size();
+                point_lists[i_topo].resize(temp_coordinate_size);
+                for (unsigned int i_coord = 0; i_coord < temp_coordinate_size; ++i_coord)
+                  {
+                    const std::vector<double> temp_point = Utilities::string_to_double(Utilities::split_string_list(temp_coordinates[i_coord],','));
+                    Assert(temp_point.size() == 2,ExcMessage ("The given coordinate '" + temp_coordinates[i_coord] + "' is not correct. "
+                                                              "It consists of " + boost::lexical_cast<std::string>(temp_topography.size())
+                                                              + " parts separated by :, but it should only contain 2 parts: "
+                                                              "the two coordinates of the polygon points, separated by a ','."));
+
+
+                    point_lists[i_topo][i_coord] = Point<2>(temp_point[0], temp_point[1]);
+                  }
+
+              }
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(PrmPolygon,
+                                             "prm polygon",
+                                             "An initial topography model that defines the initial topography "
+                                             "as constant inside each of a set of polygonal parts of the "
+                                             "surface. The polygons, and their associated surface elevation, "
+                                             "are defined in the `Geometry model/Initial topography/Prm polygon' "
+                                             "section.")
+  }
+}
diff --git a/source/geometry_model/initial_topography_model/zero_topography.cc.bak b/source/geometry_model/initial_topography_model/zero_topography.cc.bak
new file mode 100644
index 00000000000..3ed908aad28
--- /dev/null
+++ b/source/geometry_model/initial_topography_model/zero_topography.cc.bak
@@ -0,0 +1,58 @@
+/*
+  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+
+
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    template <int dim>
+    double
+    ZeroTopography<dim>::
+    value (const Point<dim-1> &/*p*/) const
+    {
+      // return a zero value regardless of position
+      return 0.0;
+    }
+
+    template <int dim>
+    double
+    ZeroTopography<dim>::
+    max_topography () const
+    {
+      return 0;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTopographyModel
+  {
+    ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(ZeroTopography,
+                                             "zero topography",
+                                             "Implementation of a model in which the initial topography "
+                                             "is zero. ")
+  }
+}
diff --git a/source/geometry_model/interface.cc.bak b/source/geometry_model/interface.cc.bak
new file mode 100644
index 00000000000..0f977683d3b
--- /dev/null
+++ b/source/geometry_model/interface.cc.bak
@@ -0,0 +1,368 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/base/utilities.h>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    template <int dim>
+    std::map<std::string,types::boundary_id>
+    Interface<dim>::get_symbolic_boundary_names_map() const
+    {
+      // return an empty map in the base class
+      return {};
+    }
+
+
+
+    template <int dim>
+    std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
+    Interface<dim>::get_periodic_boundary_pairs() const
+    {
+      // return an empty set in the base class
+      return {};
+    }
+
+
+
+    template <int dim>
+    void
+    Interface<dim>::adjust_positions_for_periodicity (Point<dim> &/*position*/,
+                                                      const ArrayView<Point<dim>> &/*connected_positions*/,
+                                                      const ArrayView<Tensor<1, dim>> &/*connected_velocities*/) const
+    {
+      AssertThrow(false,
+                  ExcMessage("Positions cannot be adjusted for periodicity in the chosen geometry model."));
+      return;
+    }
+
+
+
+    template <int dim>
+    bool
+    Interface<dim>::has_curved_elements() const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    std::array<double,dim>
+    Interface<dim>::cartesian_to_natural_coordinates(const Point<dim> &) const
+    {
+      Assert (false,
+              ExcMessage ("The cartesian_to_natural_coordinates function has "
+                          "not been implemented in this geometry model."));
+      return {};
+    }
+
+
+    template <int dim>
+    Utilities::NaturalCoordinate<dim>
+    Interface<dim>::cartesian_to_other_coordinates(const Point<dim> &position,
+                                                   const Utilities::Coordinates::CoordinateSystem &coordinate_system) const
+    {
+      std::array<double, dim> other_coord;
+      switch (coordinate_system)
+        {
+          case Utilities::Coordinates::cartesian:
+            other_coord = Utilities::convert_point_to_array(position);
+            break;
+
+          case Utilities::Coordinates::spherical:
+            other_coord = Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
+            break;
+
+          case Utilities::Coordinates::depth:
+            other_coord[0] = depth(position);
+            break;
+
+          case Utilities::Coordinates::ellipsoidal:
+          default:
+            AssertThrow(false, ExcNotImplemented());
+        }
+
+      return Utilities::NaturalCoordinate<dim>(other_coord, coordinate_system);
+    }
+
+    template <int dim>
+    Point<dim>
+    Interface<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &) const
+    {
+      Assert (false,
+              ExcMessage ("The natural_to_cartesian_coordinates function has "
+                          "not been implemented in this geometry model."));
+      return Point<dim>();
+    }
+
+
+    /* --------- functions to translate between symbolic and numeric boundary indicators ------ */
+
+    namespace
+    {
+      types::boundary_id
+      translate_boundary_indicator (const std::string &name_,
+                                    const std::map<std::string,types::boundary_id> &boundary_names_mapping)
+      {
+        // trim whitespace on either side of the name if necessary
+        std::string name = name_;
+        while ((name.size() > 0) && (name[0] == ' '))
+          name.erase (name.begin());
+        while ((name.size() > 0) && (name[name.size()-1] == ' '))
+          name.erase (name.end()-1);
+
+        // backwards compatibility (rename boundaries to all use "top" and "bottom"
+        if (name == "surface" || name == "outer")
+          name = "top";
+        else if (name == "inner")
+          name = "bottom";
+
+        // see if the given name is a symbolic one
+        if (boundary_names_mapping.find (name) != boundary_names_mapping.end())
+          return boundary_names_mapping.find(name)->second;
+        else
+          return dealii::Utilities::string_to_int(name);
+      }
+
+
+      std::vector<types::boundary_id>
+      translate_boundary_indicators (const std::vector<std::string> &names,
+                                     const std::map<std::string,types::boundary_id> &boundary_names_mapping)
+      {
+        std::vector<types::boundary_id> results;
+        results.reserve(names.size());
+        for (const auto &name : names)
+          results.push_back (translate_boundary_indicator(name, boundary_names_mapping));
+
+        return results;
+      }
+    }
+
+
+    template <int dim>
+    types::boundary_id
+    Interface<dim>::
+    translate_symbolic_boundary_name_to_id (const std::string &name) const
+    {
+      return translate_boundary_indicator(name, get_symbolic_boundary_names_map());
+    }
+
+
+
+    template <int dim>
+    std::vector<types::boundary_id>
+    Interface<dim>::
+    translate_symbolic_boundary_names_to_ids (const std::vector<std::string> &names) const
+    {
+      return translate_boundary_indicators(names, get_symbolic_boundary_names_map());
+    }
+
+
+    template <int dim>
+    std::string
+    Interface<dim>::
+    translate_id_to_symbol_name(const types::boundary_id boundary_id) const
+    {
+      const std::map<std::string,types::boundary_id> mapping = get_symbolic_boundary_names_map();
+
+      // loop over all entries in the map, and set 'name' to the key if the
+      // value matches the given 'boundary_id'. if 'name' has already been
+      // set, then this means that we had previously already found it -- i.e.,
+      // that it is in the map at least twice. produce an error in that case.
+      std::string name;
+      for (const auto &p : mapping)
+        if (p.second == boundary_id)
+          {
+            Assert (name == "",
+                    ExcMessage ("This geometry model appears to provide multiple "
+                                "names for the boundary with indicator <" +
+                                Utilities::int_to_string (boundary_id) + ">."));
+            name = p.first;
+          }
+
+      return name;
+    }
+
+
+// -------------------------------- Deal with registering geometry models and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    register_geometry_model (const std::string &name,
+                             const std::string &description,
+                             void (*declare_parameters_function) (ParameterHandler &),
+                             std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_geometry_model (ParameterHandler &prm)
+    {
+      std::string model_name;
+      prm.enter_subsection ("Geometry model");
+      {
+        model_name = prm.get ("Model name");
+      }
+      prm.leave_subsection ();
+
+      // If one sets the model name to an empty string in the input file,
+      // ParameterHandler produces an error while reading the file. However,
+      // if one omits specifying any model name at all (not even setting it to
+      // the empty string) then the value we get here is the empty string. If
+      // we don't catch this case here, we end up with awkward downstream
+      // errors because the value obviously does not conform to the Pattern.
+      AssertThrow(model_name != "unspecified",
+                  ExcMessage("You need to select a Geometry model "
+                             "(`set Model name' in `subsection Geometry model')."));
+
+      return std::get<dim>(registered_plugins).create_plugin (model_name,
+                                                              "Geometry model::model name",
+                                                              prm);
+    }
+
+
+
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm)
+    {
+      // declare the entry in the parameter file
+      prm.enter_subsection ("Geometry model");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+        prm.declare_entry ("Model name", "unspecified",
+                           Patterns::Selection (pattern_of_names+"|unspecified"),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Geometry model interface",
+                                                            out);
+    }
+
+
+
+    template <int dim>
+    void
+    Interface<dim>::make_periodicity_constraints(const DoFHandler<dim> &dof_handler,
+                                                 AffineConstraints<double> &constraints) const
+    {
+      using periodic_boundary_set
+        = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
+      periodic_boundary_set pbs = get_periodic_boundary_pairs();
+
+      for (const auto &pb : pbs)
+        {
+          DoFTools::make_periodicity_constraints(dof_handler,
+                                                 pb.first.first,  // first boundary id
+                                                 pb.first.second, // second boundary id
+                                                 pb.second,       // cartesian direction for translational symmetry
+                                                 constraints);
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<GeometryModel::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<GeometryModel::Interface<2>>::plugins = nullptr;
+
+      template <>
+      std::list<internal::Plugins::PluginList<GeometryModel::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<GeometryModel::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace GeometryModel
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_geometry_model<dim> (const std::string &, \
+                                const std::string &, \
+                                void ( *) (ParameterHandler &), \
+                                std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_geometry_model<dim> (ParameterHandler &prm);
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/geometry_model/sphere.cc.bak b/source/geometry_model/sphere.cc.bak
new file mode 100644
index 00000000000..08420710357
--- /dev/null
+++ b/source/geometry_model/sphere.cc.bak
@@ -0,0 +1,238 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/manifold_lib.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    template <int dim>
+    void
+    Sphere<dim>::
+    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
+    {
+      GridGenerator::hyper_ball (coarse_grid,
+                                 Point<dim>(),
+                                 R);
+
+      coarse_grid.set_manifold(0, SphericalManifold<dim>());
+      coarse_grid.set_all_manifold_ids_on_boundary(0);
+    }
+
+
+    template <int dim>
+    std::set<types::boundary_id>
+    Sphere<dim>::
+    get_used_boundary_indicators () const
+    {
+      const types::boundary_id s[] = { 0 };
+      return std::set<types::boundary_id>(std::begin(s), std::end(s));
+    }
+
+
+    template <int dim>
+    std::map<std::string,types::boundary_id>
+    Sphere<dim>::
+    get_symbolic_boundary_names_map () const
+    {
+      return {{"top", 0}};
+    }
+
+
+    template <int dim>
+    double
+    Sphere<dim>::
+    length_scale () const
+    {
+      // as described in the first ASPECT paper, a length scale of
+      // 10km = 1e4m works well for the pressure scaling for earth
+      // sized spherical shells. use a length scale that
+      // yields this value for the R0,R1 corresponding to earth
+      // but otherwise scales like (R1-R0)
+      return 1e4 * maximal_depth() / (6336000.-3481000.);
+    }
+
+
+
+    template <int dim>
+    double
+    Sphere<dim>::depth(const Point<dim> &position) const
+    {
+      return std::min (std::max (R-position.norm(), 0.), maximal_depth());
+    }
+
+    template <int dim>
+    double
+    Sphere<dim>::height_above_reference_surface(const Point<dim> &position) const
+    {
+      return position.norm()-radius();
+    }
+
+
+    template <int dim>
+    Point<dim>
+    Sphere<dim>::representative_point(const double depth) const
+    {
+      Point<dim> p;
+      p(dim-1) = std::min (std::max(R - depth, 0.), maximal_depth());
+      return p;
+    }
+
+
+
+    template <int dim>
+    double
+    Sphere<dim>::maximal_depth() const
+    {
+      return R;
+    }
+
+    template <int dim>
+    double Sphere<dim>::radius () const
+    {
+      return R;
+    }
+
+    template <int dim>
+    bool
+    Sphere<dim>::has_curved_elements () const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    bool
+    Sphere<dim>::point_is_in_domain(const Point<dim> &point) const
+    {
+      AssertThrow(!this->get_parameters().mesh_deformation_enabled ||
+                  this->get_timestep_number() == 0,
+                  ExcMessage("After displacement of the mesh, this function can no longer be used to determine whether a point lies in the domain or not."));
+
+      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()),
+                  ExcMessage("After adding topography, this function can no longer be used to determine whether a point lies in the domain or not."));
+
+      const double radius = point.norm();
+
+      if (radius > R+std::numeric_limits<double>::epsilon()*R)
+        return false;
+
+      return true;
+    }
+
+
+
+    template <int dim>
+    std::array<double,dim>
+    Sphere<dim>::cartesian_to_natural_coordinates(const Point<dim> &position) const
+    {
+      return Utilities::Coordinates::cartesian_to_spherical_coordinates<dim>(position);
+    }
+
+
+
+    template <int dim>
+    aspect::Utilities::Coordinates::CoordinateSystem
+    Sphere<dim>::natural_coordinate_system() const
+    {
+      return aspect::Utilities::Coordinates::CoordinateSystem::spherical;
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    Sphere<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position) const
+    {
+      return Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(position);
+    }
+
+
+
+    template <int dim>
+    void
+    Sphere<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Sphere");
+        {
+          prm.declare_entry ("Radius", "6371000.",
+                             Patterns::Double (0.),
+                             "Radius of the sphere. Units: \\si{\\meter}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Sphere<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Sphere");
+        {
+          R            = prm.get_double ("Radius");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    ASPECT_REGISTER_GEOMETRY_MODEL(Sphere,
+                                   "sphere",
+                                   "A geometry model for a sphere with a user specified "
+                                   "radius. This geometry has only a single boundary, so "
+                                   "the only valid boundary indicator to "
+                                   "specify in input files is ``0''. It can also be "
+                                   "referenced by the symbolic name ``surface'' in "
+                                   "input files."
+                                   "\n\n"
+                                   "Despite the name, this geometry does not imply the use of "
+                                   "a spherical coordinate system when used in 2d. Indeed, "
+                                   "in 2d the geometry is simply a circle in a Cartesian "
+                                   "coordinate system and consequently would correspond to "
+                                   "a cross section of the fluid filled interior of an "
+                                   "infinite cylinder where one has made the assumption that "
+                                   "the velocity in direction of the cylinder axes is zero. "
+                                   "This is consistent with the definition of what we consider "
+                                   "the two-dimension case given in "
+                                   "Section~\\ref{sec:methods:2d-models}.")
+  }
+}
diff --git a/source/geometry_model/spherical_shell.cc.bak b/source/geometry_model/spherical_shell.cc.bak
new file mode 100644
index 00000000000..0f06e10d786
--- /dev/null
+++ b/source/geometry_model/spherical_shell.cc.bak
@@ -0,0 +1,1074 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+
+#include <aspect/compat.h>
+
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/grid/manifold_lib.h>
+#include <aspect/utilities.h>
+#include <deal.II/dofs/dof_tools.h>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    namespace
+    {
+      void append_face_to_subcell_data(SubCellData &subcell_data, const CellData<1> &face)
+      {
+        subcell_data.boundary_lines.push_back(face);
+      }
+
+
+
+      void append_face_to_subcell_data(SubCellData &subcell_data, const CellData<2> &face)
+      {
+        subcell_data.boundary_quads.push_back(face);
+      }
+    }
+
+
+    namespace internal
+    {
+      template <int dim>
+      SphericalManifoldWithTopography<dim>::
+      SphericalManifoldWithTopography(const InitialTopographyModel::Interface<dim> &topography,
+                                      const double inner_radius,
+                                      const double outer_radius)
+        :
+        SphericalManifold<dim>(Point<dim>()),
+        topo (&topography),
+        R0 (inner_radius),
+        R1 (outer_radius)
+      {}
+
+
+      template <int dim>
+      std::unique_ptr<Manifold<dim, dim>>
+      SphericalManifoldWithTopography<dim>::clone() const
+      {
+        return std::make_unique<SphericalManifoldWithTopography<dim>>(*this);
+      }
+
+
+
+      template <int dim>
+      double
+      SphericalManifoldWithTopography<dim>::
+      topography_for_point(const Point<dim> &x_y_z) const
+      {
+        if (dynamic_cast<const InitialTopographyModel::ZeroTopography<dim>*>(topo) != nullptr)
+          return 0;
+        else
+          {
+            Assert (dim==3, ExcNotImplemented());
+
+            // The natural coordinate system of the sphere geometry is r/phi/theta.
+            // This is what we need to query the topography with. So start by
+            // converting into this coordinate system
+            const std::array<double, dim> r_phi_theta = Utilities::Coordinates::cartesian_to_spherical_coordinates(x_y_z);
+
+            // Grab lon,lat coordinates
+            Point<dim-1> surface_point;
+            for (unsigned int d=0; d<dim-1; ++d)
+              surface_point[d] = r_phi_theta[d+1];
+            return topo->value(surface_point);
+          }
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      SphericalManifoldWithTopography<dim>::
+      push_forward_from_sphere(const Point<dim> &p) const
+      {
+        const double topography = topography_for_point(p);
+
+        // We can short-circuit the computations here if the topography
+        // is zero.
+        if (topography == 0)
+          return p;
+        else
+          {
+            // For the case with (non-zero) topography, we have to project
+            // the point out/inward.
+
+            // We start from the undeformed sphere. So the current radius must be
+            // between R0 and R1. Check this, with a slight tolerance to account
+            // for the fact that our mesh is not *completely* spherical.
+            const double r = p.norm();
+            Assert (r>=R0*0.99, ExcInternalError());
+            Assert (r<=R1*1.01, ExcInternalError());
+
+            // Then we need to stretch the point p outward by a factor that is
+            // zero at the core-mantle boundary and results in the right topography
+            // at the top.
+            //
+            // The stretching factor is relative to the distance from the core
+            // mantle boundary.
+            const double cmb_stretching_factor = (R1+topography-R0)/(R1-R0);
+
+            // From this we can compute what the desired radius is going to be, and
+            // scale the given point accordingly:
+            const double new_radius = (r-R0)*cmb_stretching_factor + R0;
+            return p * (new_radius/r);
+          }
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      SphericalManifoldWithTopography<dim>::
+      pull_back_to_sphere(const Point<dim> &p) const
+      {
+        const double topography = topography_for_point(p);
+
+        // We can short-circuit the computations here if the topography
+        // is zero.
+        if (topography == 0)
+          return p;
+        else
+          {
+            // For the case with (non-zero) topography, we have to project
+            // the point in/outward.
+
+            // We start from the deformed sphere. So the current radius must be
+            // between R0 and R1+topography. Check this, with a slight tolerance
+            // to account for the fact that our mesh is not *completely* spherical.
+            const double r = p.norm();
+            Assert (r>=R0*0.99, ExcInternalError());
+            Assert (r<=(R1+topography)*1.01, ExcInternalError());
+
+            // Then we need to stretch(=shrink) the point p outward by a factor that is
+            // zero at the core-mantle boundary and results in the right topography
+            // at the top.
+            const double cmb_stretching_factor = (R1-R0)/(R1+topography-R0);
+
+            // From this we can compute what the desired radius is going to be, and
+            // scale the given point accordingly:
+            const double new_radius = (r-R0)*cmb_stretching_factor + R0;
+            return p * (new_radius/r);
+          }
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      SphericalManifoldWithTopography<dim>::
+      get_intermediate_point(const Point<dim> &p1,
+                             const Point<dim> &p2,
+                             const double      w) const
+      {
+        return
+          push_forward_from_sphere
+          (SphericalManifold<dim>::get_intermediate_point (pull_back_to_sphere(p1),
+                                                           pull_back_to_sphere(p2), w));
+      }
+
+
+
+      template <int dim>
+      Tensor<1, dim>
+      SphericalManifoldWithTopography<dim>::
+      get_tangent_vector(const Point<dim> &x1,
+                         const Point<dim> &x2) const
+      {
+        // TODO: Deal with pull back and push forward
+        return SphericalManifold<dim>::get_tangent_vector (x1, x2);
+      }
+
+
+
+      template <int dim>
+      Tensor<1, dim>
+      SphericalManifoldWithTopography<dim>::
+      normal_vector(const typename Triangulation<dim, dim>::face_iterator &face,
+                    const Point<dim> &p) const
+      {
+        // We calculate radial, rather than *normal*, vectors here if a face is
+        // at the boundary. This is as described in the documentation of this
+        // function.
+
+        // TODO: Add an input parameter that determines whether we use this
+        //   or the "geometrically correct" behavior.
+        return SphericalManifold<dim>::normal_vector (face, p);
+      }
+
+
+
+      template <int dim>
+      void
+      SphericalManifoldWithTopography<dim>::
+      get_normals_at_vertices(
+        const typename Triangulation<dim, dim>::face_iterator &face,
+        typename Manifold<dim, dim>::FaceVertexNormals &face_vertex_normals) const
+      {
+        // TODO: Deal with pull back and push forward
+        SphericalManifold<dim>::get_normals_at_vertices(face, face_vertex_normals);
+      }
+
+
+
+      template <int dim>
+      void
+      SphericalManifoldWithTopography<dim>::
+      get_new_points(const ArrayView<const Point<dim>> &surrounding_points,
+                     const Table<2, double>            &weights,
+                     ArrayView<Point<dim>>              new_points) const
+      {
+        // First compute the points in the untransformed coordinate system
+        // without surface topography:
+        std::vector<Point<dim>> untransformed_points;
+        untransformed_points.reserve(surrounding_points.size());
+        for (const Point<dim> &p : surrounding_points)
+          untransformed_points.emplace_back (pull_back_to_sphere(p));
+
+        // Call the function in the base class:
+        SphericalManifold<dim>::get_new_points(untransformed_points, weights, new_points);
+
+        // Since the function in the base class returned its information
+        // in a writable array, we can in-place push forward to the deformed
+        // sphere with topography:
+        for (Point<dim> &p : new_points)
+          p = push_forward_from_sphere(p);
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      SphericalManifoldWithTopography<dim>::
+      get_new_point(const ArrayView<const Point<dim>> &surrounding_points,
+                    const ArrayView<const double>          &weights) const
+      {
+        // First compute the points in the untransformed coordinate system
+        // without surface topography:
+        std::vector<Point<dim>> untransformed_points;
+        untransformed_points.reserve(surrounding_points.size());
+        for (const Point<dim> &p : surrounding_points)
+          untransformed_points.emplace_back (pull_back_to_sphere(p));
+
+        // Call the function in the base class, and transform the
+        // returned value:
+        return push_forward_from_sphere(SphericalManifold<dim>::get_new_point(untransformed_points,
+                                                                              weights));
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalShell<dim>::initialize ()
+    {
+      manifold = std::make_unique<internal::SphericalManifoldWithTopography<dim>>(this->get_initial_topography_model(),
+                                                                                   R0, R1);
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalShell<dim>::
+    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
+    {
+      AssertThrow (phi == 360 || phi == 90 || ((phi == 180) && (dim == 2)),
+                   ExcMessage ("The only opening angles that are allowed for "
+                               "this geometry are 90, 180, and 360 in 2d; "
+                               "and 90 and 360 in 3d."));
+
+      // Custom mesh extrusion is only implemented for full spherical shells
+      // for now, so check that custom mesh schemes are only being used when
+      // the opening angle is 360 degrees.
+      AssertThrow (phi == 360 || (custom_mesh == none),
+                   ExcMessage ("The only opening angle that is allowed for "
+                               "this geometry with a custom mesh is 360."));
+
+      if (phi == 360)
+        {
+          if (custom_mesh == none)
+            {
+              // If we are not using a custom mesh scheme, the mesh is generated
+              // as per the original code.
+              GridGenerator::hyper_shell (coarse_grid,
+                                          Point<dim>(),
+                                          R0,
+                                          R1,
+                                          (n_cells_along_circumference == 0
+                                           ?
+                                           // automatic choice that leads to reasonable
+                                           // meshes with the typical aspect ratio of
+                                           // the Earth
+                                           (dim==3 ? 96 : 12)
+                                           :
+                                           // user choice
+                                           n_cells_along_circumference),
+                                          true);
+            }
+          else
+            {
+              Assert(custom_mesh == slices || custom_mesh == list, ExcNotImplemented());
+              // If we are using a custom mesh scheme, we need to create
+              // a new triangulation to extrude (this will be a 1D line in
+              // 2d space, or a 2d surface in 3d space).
+              Triangulation<dim-1,dim> sphere_mesh;
+              GridGenerator::hyper_sphere (sphere_mesh);
+              sphere_mesh.refine_global (initial_lateral_refinement);
+
+              // Calculate the number of R_values wrt custom mesh scheme
+              unsigned int n_R_values;
+              if (custom_mesh == slices)
+                n_R_values = n_slices+1;
+              else
+                n_R_values = R_values_list.size()+2;
+
+              // Allocate R_values wrt the number of slices
+              std::vector<double> R_values (n_R_values);
+              if (custom_mesh == slices)
+                {
+                  for (unsigned int s=0; s<n_R_values; ++s)
+                    R_values[s] = R0 + (R1-R0)/n_slices * s;
+                }
+              if (custom_mesh == list)
+                {
+                  R_values[0] = R0;
+                  R_values[n_R_values-1] = R1;
+                  for (unsigned int s=1; s<(n_R_values-1); ++s)
+                    R_values[s] = R_values_list[s-1];
+                }
+              std::vector<Point<dim>>    points(R_values.size() * sphere_mesh.n_vertices());
+
+
+              // Copy the array of points as many times as there will be slices,
+              // one slice at a time. The z-axis value are defined in slices_coordinates
+              for (unsigned int point_layer = 0; point_layer < R_values.size(); ++point_layer)
+                {
+                  for (unsigned int vertex_n = 0; vertex_n < sphere_mesh.n_vertices();
+                       ++vertex_n)
+                    {
+                      const Point<dim> vertex = sphere_mesh.get_vertices()[vertex_n];
+                      points[point_layer * sphere_mesh.n_vertices() + vertex_n] =
+                        vertex * R_values[point_layer];
+                    }
+                }
+
+              // Then create the cells of each of the slices, one stack at a
+              // time
+              std::vector<CellData<dim>> cells;
+              cells.reserve((R_values.size() - 1) * sphere_mesh.n_active_cells());
+
+              SubCellData               subcell_data;
+
+              for (const auto &cell : sphere_mesh.active_cell_iterators())
+                {
+                  for (unsigned int cell_layer = 0; cell_layer < R_values.size() - 1; ++cell_layer)
+                    {
+                      CellData<dim> this_cell;
+                      for (const unsigned int vertex_n : cell->vertex_indices())
+                        {
+                          this_cell.vertices[vertex_n] =
+                            cell->vertex_index(vertex_n) + cell_layer * sphere_mesh.n_vertices();
+                          this_cell.vertices[vertex_n + cell->n_vertices()] =
+                            cell->vertex_index(vertex_n) +
+                            (cell_layer + 1) * sphere_mesh.n_vertices();
+                        }
+
+                      this_cell.material_id = cell->material_id();
+
+
+                      Assert(GridTools::cell_measure (points, this_cell.vertices) > 0, ExcInternalError());
+
+                      cells.push_back(this_cell);
+
+                      // Mark the bottom face of the cell as boundary 0 if we are in
+                      // the bottom layer of cells
+                      if (cell_layer == 0)
+                        {
+                          CellData<dim-1> face;
+                          for (const unsigned int vertex_n : cell->vertex_indices())
+                            face.vertices[vertex_n] =
+                              cell->vertex_index(vertex_n) + cell_layer * sphere_mesh.n_vertices();
+                          face.boundary_id = 0;
+
+                          append_face_to_subcell_data(subcell_data, face);
+                        }
+
+                      // Mark the top face of the cell as boundary 1 if we are in
+                      // the top layer of cells
+                      if (cell_layer == R_values.size()-2)
+                        {
+                          CellData<dim-1> face;
+                          for (const unsigned int vertex_n : cell->vertex_indices())
+                            face.vertices[vertex_n] =
+                              cell->vertex_index(vertex_n) +
+                              (cell_layer + 1) * sphere_mesh.n_vertices();
+                          face.boundary_id = 1;
+
+                          append_face_to_subcell_data(subcell_data, face);
+                        }
+
+                    }
+                }
+
+              // Then create the actual mesh:
+              GridTools::consistently_order_cells (cells);
+              coarse_grid.create_triangulation(points, cells, subcell_data);
+            }
+        }
+      else if (phi == 90)
+        {
+          GridGenerator::quarter_hyper_shell (coarse_grid,
+                                              Point<dim>(),
+                                              R0,
+                                              R1,
+                                              0,
+                                              true);
+
+          if (periodic)
+            {
+              // Tell p4est about the periodicity of the mesh.
+              std::vector<GridTools::PeriodicFacePair<typename parallel::distributed::Triangulation<dim>::cell_iterator>>
+              matched_pairs;
+              FullMatrix<double> rotation_matrix(dim);
+              rotation_matrix[0][1] = 1.;
+              rotation_matrix[1][0] = -1.;
+
+              GridTools::collect_periodic_faces(coarse_grid, /*b_id1*/ 2, /*b_id2*/ 3,
+                                                /*direction*/ 1, matched_pairs,
+                                                Tensor<1, dim>(), rotation_matrix);
+
+              if (matched_pairs.size() > 0)
+                coarse_grid.add_periodicity (matched_pairs);
+            }
+        }
+      else if (phi == 180)
+        {
+          GridGenerator::half_hyper_shell (coarse_grid,
+                                           Point<dim>(),
+                                           R0,
+                                           R1,
+                                           0,
+                                           true);
+        }
+      else
+        {
+          Assert (false, ExcInternalError());
+        }
+
+      // Then add the topography to the mesh by moving all vertices from the
+      // undeformed sphere to the sphere with topography:
+      GridTools::transform (
+        [&](const Point<dim> &p) -> Point<dim>
+      {
+        return manifold->push_forward_from_sphere(p);
+      },
+      coarse_grid);
+
+      // Use a manifold description for all cells. Use manifold_id 99 in order
+      // not to step on the boundary indicators used below.
+      coarse_grid.set_manifold (my_manifold_id, *manifold);
+      set_manifold_ids(coarse_grid);
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalShell<dim>::set_manifold_ids (parallel::distributed::Triangulation<dim> &triangulation) const
+    {
+      for (const auto &cell : triangulation.active_cell_iterators())
+        cell->set_all_manifold_ids (my_manifold_id);
+    }
+
+
+
+    template <int dim>
+    std::set<types::boundary_id>
+    SphericalShell<dim>::
+    get_used_boundary_indicators () const
+    {
+      // Follow what is described in the documentation of this class.
+      // see the documentation of the various GridGenerator::*hyper_shell
+      // functions for a description of which boundary indicators are
+      // set and how they correlate to what's used below
+      if (phi == 360)
+        {
+          const types::boundary_id s[] = { 0, 1 };
+          return std::set<types::boundary_id>(std::begin(s), std::end(s));
+        }
+      else if (phi == 90 && dim == 3)
+        {
+          const types::boundary_id s[] = { 0, 1, 2, 3, 4};
+          return std::set<types::boundary_id>(std::begin(s), std::end(s));
+        }
+      else
+        {
+          const types::boundary_id s[] = { 0, 1, 2, 3 };
+          return std::set<types::boundary_id>(std::begin(s), std::end(s));
+        }
+    }
+
+
+
+    template <int dim>
+    std::map<std::string,types::boundary_id>
+    SphericalShell<dim>::
+    get_symbolic_boundary_names_map () const
+    {
+      switch (dim)
+        {
+          case 2:
+          {
+            static const std::pair<std::string,types::boundary_id> mapping[]
+            = { {"bottom", 0},
+              {"top", 1},
+              {"left",  2},
+              {"right", 3}
+            };
+
+            if (phi == 360)
+              return std::map<std::string,types::boundary_id> (std::begin(mapping),
+                                                               std::begin(mapping)+2);
+            else
+              return std::map<std::string,types::boundary_id> (std::begin(mapping),
+                                                               std::begin(mapping)+4);
+          }
+
+          case 3:
+          {
+            if (phi == 360)
+              {
+                return
+                {
+                  {"bottom", 0},
+                  {"top",    1}
+                };
+              }
+            else if (phi == 90)
+              {
+                return
+                {
+                  {"bottom", 0},
+                  {"top",    1},
+                  {"east",   2},
+                  {"west",   3},
+                  {"south",  4}
+                };
+              }
+            else
+              Assert (false, ExcNotImplemented());
+          }
+        }
+
+      Assert (false, ExcNotImplemented());
+      return {};
+    }
+
+
+
+    template <int dim>
+    std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
+    SphericalShell<dim>::
+    get_periodic_boundary_pairs () const
+    {
+      std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>> periodic_boundaries;
+      if (periodic)
+        {
+          periodic_boundaries.insert( std::make_pair( std::pair<types::boundary_id, types::boundary_id>(2, 3), 1) );
+        }
+      return periodic_boundaries;
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalShell<dim>::adjust_positions_for_periodicity (Point<dim> &position,
+                                                           const ArrayView<Point<dim>> &connected_positions,
+                                                           const ArrayView<Tensor<1, dim>> &connected_velocities) const
+    {
+      AssertThrow(dim == 2,
+                  ExcMessage("Periodic boundaries currently "
+                             "only work with 2d spherical shell."));
+      AssertThrow(phi == 90,
+                  ExcMessage("Periodic boundaries currently "
+                             "only work with 90 degree opening angle in spherical shell."));
+
+      if (periodic)
+        {
+          // define a rotation matrix for the new position depending on the boundary
+          Tensor<2,dim> rotation_matrix;
+
+          if (position[0] < 0.)
+            {
+              rotation_matrix[0][1] = 1.;
+              rotation_matrix[1][0] = -1.;
+            }
+          else if (position[1] < 0.)
+            {
+              rotation_matrix[0][1] = -1.;
+              rotation_matrix[1][0] = 1.;
+            }
+          else
+            return;
+
+          position = rotation_matrix * position;
+
+          for (auto &connected_position: connected_positions)
+            connected_position = rotation_matrix * connected_position;
+
+          for (auto &connected_velocity: connected_velocities)
+            connected_velocity = rotation_matrix * connected_velocity;
+        }
+
+      return;
+    }
+
+
+
+    template <int dim>
+    double
+    SphericalShell<dim>::
+    length_scale () const
+    {
+      // As described in the first ASPECT paper, a length scale of
+      // 10km = 1e4m works well for the pressure scaling for earth
+      // sized spherical shells. So use a formulation that yields this
+      // value for the R0,R1 corresponding to earth, and that more
+      // generally scales with (R1-R0), which we can get by calling
+      // maximal_depth(). In essence, the factor in front of the call
+      // to maximal_depth() is just a magic number that has turned out
+      // to work well.
+      return (1e4 / (6336000.-3481000.)) * maximal_depth();
+    }
+
+
+
+    template <int dim>
+    double
+    SphericalShell<dim>::depth(const Point<dim> &position) const
+    {
+      return std::min (std::max (R1-position.norm(), 0.), maximal_depth());
+    }
+
+
+
+    template <int dim>
+    double
+    SphericalShell<dim>::height_above_reference_surface(const Point<dim> &position) const
+    {
+      return position.norm()-R1;
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    SphericalShell<dim>::representative_point(const double depth) const
+    {
+      Assert (depth >= 0,
+              ExcMessage ("Given depth must be positive or zero."));
+      Assert (depth <= maximal_depth(),
+              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
+
+      // Choose a point along the axes toward the north pole, at the
+      // requested depth.
+      Point<dim> p;
+      p[dim-1] = std::min (std::max(R1 - depth, R0), R1);
+
+      // Return this point. This ignores the surface topography,
+      // but that is as documented.
+      return p;
+    }
+
+
+
+    template <int dim>
+    double
+    SphericalShell<dim>::maximal_depth() const
+    {
+      // The depth is defined as relative to a reference surface (without
+      // topography) and since we don't apply topography on the CMB,
+      // the maximal depth really is R1-R0 unless one applies a
+      // topography that is always strictly below zero (i.e., where the
+      // actual surface lies strictly below the reference surface).
+      return R1-R0;
+    }
+
+
+
+    template <int dim>
+    double SphericalShell<dim>::inner_radius () const
+    {
+      return R0;
+    }
+
+
+
+    template <int dim>
+    double SphericalShell<dim>::outer_radius () const
+    {
+      return R1;
+    }
+
+
+
+    template <int dim>
+    double SphericalShell<dim>::opening_angle () const
+    {
+      return phi;
+    }
+
+
+
+    template <int dim>
+    bool
+    SphericalShell<dim>::has_curved_elements () const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    bool
+    SphericalShell<dim>::point_is_in_domain(const Point<dim> &point) const
+    {
+      AssertThrow(!this->get_parameters().mesh_deformation_enabled ||
+                  this->simulator_is_past_initialization() == false,
+                  ExcMessage("After displacement of the free surface, this function can no longer be used to determine whether a point lies in the domain or not."));
+
+      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()),
+                  ExcMessage("After adding topography, this function can no longer be used to determine whether a point lies in the domain or not."));
+
+      const std::array<double, dim> spherical_point = Utilities::Coordinates::cartesian_to_spherical_coordinates(point);
+
+      std::array<double, dim> point1, point2;
+      point1[0] = R0;
+      point2[0] = R1;
+      point1[1] = 0.0;
+      point2[1] = phi * constants::degree_to_radians;
+      if (dim == 3)
+        {
+          point1[2] = 0.0;
+
+          if (phi == 90.0)
+            // Octant
+            point2[2] = 0.5 * numbers::PI;
+          else
+            // Full shell
+            point2[2] = numbers::PI;
+        }
+
+      for (unsigned int d = 0; d < dim; ++d)
+        if (spherical_point[d] > point2[d]+std::numeric_limits<double>::epsilon()*std::abs(point2[d]) ||
+            spherical_point[d] < point1[d]-std::numeric_limits<double>::epsilon()*std::abs(point2[d]))
+          return false;
+
+      // TODO: Take into account topography
+
+      return true;
+    }
+
+
+
+    template <int dim>
+    std::array<double,dim>
+    SphericalShell<dim>::cartesian_to_natural_coordinates(const Point<dim> &position) const
+    {
+      // TODO: Take into account topography
+      return Utilities::Coordinates::cartesian_to_spherical_coordinates<dim>(position);
+    }
+
+
+
+    template <int dim>
+    aspect::Utilities::Coordinates::CoordinateSystem
+    SphericalShell<dim>::natural_coordinate_system() const
+    {
+      return aspect::Utilities::Coordinates::CoordinateSystem::spherical;
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    SphericalShell<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position) const
+    {
+      // TODO: Take into account topography
+      return Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(position);
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalShell<dim>::make_periodicity_constraints(const DoFHandler<dim> &dof_handler,
+                                                      AffineConstraints<double> &constraints) const
+    {
+      if (periodic)
+        {
+          std::vector<GridTools::PeriodicFacePair<typename DoFHandler<dim>::cell_iterator>>
+          matched_pairs;
+          FullMatrix<double> rotation_matrix(dim);
+          rotation_matrix[0][1] = 1.;
+          rotation_matrix[1][0] = -1.;
+
+          GridTools::collect_periodic_faces(dof_handler, /*b_id1*/ 2, /*b_id2*/ 3,
+                                            /*direction*/ 1, matched_pairs,
+                                            Tensor<1, dim>(), rotation_matrix);
+
+          DoFTools::make_periodicity_constraints<dim,dim,double>(matched_pairs,
+                                                                 constraints,
+                                                                 ComponentMask(),
+          {0},
+          1.);
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalShell<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Spherical shell");
+        {
+          prm.declare_entry ("Custom mesh subdivision", "none",
+                             Patterns::Selection ("none|list of radial values|number of slices"),
+                             "Choose how the spherical shell mesh is generated. "
+                             "By default, a coarse mesh is generated with respect to the "
+                             "inner and outer radius, and an initial number of cells along "
+                             "circumference. "
+                             "In the other cases, a surface mesh is first generated and "
+                             "refined as desired, before it is extruded radially following "
+                             "the specified subdivision scheme.");
+          prm.declare_entry ("List of radial values", "",
+                             Patterns::List(Patterns::Double ()),
+                             "List of radial values for the custom mesh scheme. Units: "
+                             "$\\si{m}$. "
+                             "A list of radial values subdivides the spherical shell at "
+                             "specified radii. The list must be strictly ascending, and "
+                             "the first value must be greater than the inner radius "
+                             "while the last must be less than the outer radius.");
+          prm.declare_entry ("Number of slices", "1",
+                             Patterns::Integer (1),
+                             "Number of slices for the custom mesh subdivision scheme. "
+                             "The number of slices subdivides the spherical shell into N "
+                             "slices of equal thickness. Must be greater than 0.");
+          prm.declare_entry ("Initial lateral refinement", "0",
+                             Patterns::Integer (0),
+                             "Initial lateral refinement for the custom mesh subdivision "
+                             "schemes."
+                             "The number of refinement steps performed on the initial "
+                             "coarse surface mesh, before the surface is extruded "
+                             "radially. This parameter allows the user more control "
+                             "over the ratio between radial and lateral refinement of "
+                             "the mesh.");
+          prm.declare_entry ("Inner radius", "3481000.",  // 6371-2890 in km
+                             Patterns::Double (0.),
+                             "Inner radius of the spherical shell. Units: \\si{\\meter}."
+                             "\n\n"
+                             ":::{note}\n"
+                             "The default value of 3,481,000 m equals the "
+                             "radius of a sphere with equal volume as Earth (i.e., "
+                             "6371 km) minus the average depth of the core-mantle "
+                             "boundary (i.e., 2890 km).\n"
+                             ":::");
+          prm.declare_entry ("Outer radius", "6336000.",  // 6371-35 in km
+                             Patterns::Double (0.),
+                             "Outer radius of the spherical shell. Units: \\si{\\meter}."
+                             "\n\n"
+                             ":::{note}\n"
+                             "The default value of 6,336,000 m equals the "
+                             "radius of a sphere with equal volume as Earth (i.e., "
+                             "6371 km) minus the average depth of the mantle-crust "
+                             "interface (i.e., 35 km).\n"
+                             ":::");
+          prm.declare_entry ("Opening angle", "360.",
+                             Patterns::Double (0., 360.),
+                             "Opening angle in degrees of the section of the shell "
+                             "that we want to build. "
+                             "The only opening angles that are allowed for "
+                             "this geometry are 90, 180, and 360 in 2d; "
+                             "and 90 and 360 in 3d. "
+                             "Units: degrees.");
+          prm.declare_entry ("Cells along circumference", "0",
+                             Patterns::Integer (0),
+                             "The number of cells in circumferential direction that are "
+                             "created in the coarse mesh in 2d. If zero, this number "
+                             "is chosen automatically in a way that produces meshes "
+                             "in which cells have a reasonable aspect ratio for models "
+                             "in which the depth of the mantle is roughly that of the "
+                             "Earth. For planets with much shallower mantles and larger "
+                             "cores, you may want to chose a larger number to avoid "
+                             "cells that are elongated in tangential and compressed in "
+                             "radial direction."
+                             "\n\n"
+                             "In 3d, the number of cells is computed differently and does "
+                             "not have an easy interpretation. Valid values for this parameter "
+                             "in 3d are 0 (let this class choose), 6, 12 and 96. "
+                             "Other possible values may be discussed in the documentation "
+                             "of the deal.II function GridGenerator::hyper_shell. "
+                             "The parameter is best left at its default in 3d."
+                             "\n\n"
+                             "In either case, this parameter is ignored unless the opening "
+                             "angle of the domain is 360 degrees. This parameter is also "
+                             "ignored when using a custom mesh subdivision scheme.");
+          prm.declare_entry ("Phi periodic", "false",
+                             Patterns::Bool (),
+                             "Whether the shell should be periodic in the phi direction.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalShell<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Spherical shell");
+        {
+          R0  = prm.get_double ("Inner radius");
+          R1  = prm.get_double ("Outer radius");
+          phi = prm.get_double ("Opening angle");
+          n_cells_along_circumference = prm.get_integer ("Cells along circumference");
+          initial_lateral_refinement = prm.get_integer ("Initial lateral refinement");
+          R_values_list = Utilities::string_to_double(Utilities::split_string_list(prm.get("List of radial values")));
+          n_slices = prm.get_integer ("Number of slices");
+
+          if (prm.get ("Custom mesh subdivision") == "none")
+            custom_mesh = none;
+          else if (prm.get ("Custom mesh subdivision") == "list of radial values")
+            custom_mesh = list;
+          else if (prm.get ("Custom mesh subdivision") == "number of slices")
+            custom_mesh = slices;
+          else
+            AssertThrow (false, ExcMessage ("Not a valid custom mesh subdivision scheme."));
+
+          // Check that inner radius is less than outer radius
+          AssertThrow (R0 < R1,
+                       ExcMessage ("Inner radius must be less than outer radius."));
+
+          // If we are using list of radial values for a custom mesh
+          if (custom_mesh == list)
+            {
+              // Check that list is in ascending order
+              for (unsigned int i = 1; i < R_values_list.size(); ++i)
+                AssertThrow(R_values_list[i] > R_values_list[i-1],
+                            ExcMessage("Radial values must be strictly ascending"));
+              // Check that first value is not smaller than the inner radius
+              AssertThrow(R_values_list[1] > R0,
+                          ExcMessage("First value in List of radial values must be greater than inner radius"));
+              // Check that last layer is not larger than the outer radius
+              AssertThrow( *(R_values_list.end()-1) < R1,
+                           ExcMessage("Last value in List of radial values must be less than outer radius"));
+            }
+
+
+          // If we are extruding the mesh according to a number of slices
+          if (custom_mesh == slices)
+            {
+              AssertThrow (n_slices > 0, ExcMessage("You must set a positive number of slices for extrusion"));
+            }
+
+          periodic = prm.get_bool ("Phi periodic");
+          if (periodic)
+            {
+              AssertThrow (dim == 2,  ExcMessage("Periodic boundaries in the spherical shell are only supported for 2d models."));
+              AssertThrow (phi == 90, ExcMessage("Periodic boundaries in the spherical shell are only supported for an opening angle of 90 degrees."));
+            }
+
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    ASPECT_REGISTER_GEOMETRY_MODEL(SphericalShell,
+                                   "spherical shell",
+                                   "A geometry representing a spherical shell or a piece of it. "
+                                   "Inner and outer radii are read from the parameter file "
+                                   "in subsection 'Spherical shell'."
+                                   "\n\n"
+                                   "The spherical shell may be generated as per the original "
+                                   "code (with respect to the inner and outer radius, and an "
+                                   "initial number of cells along circumference) or following "
+                                   "a custom mesh scheme: list of radial values or number of "
+                                   "slices. A surface mesh is first generated and refined as "
+                                   "desired, before it is extruded radially. A list of radial "
+                                   "values subdivides the spherical shell at specified radii. "
+                                   "The number of slices subdivides the spherical shell into N "
+                                   "slices of equal thickness. The custom spherical shell only "
+                                   "works with an opening angle of 360 degrees."
+                                   "\n\n"
+                                   "Despite the name, this geometry does not imply the use of "
+                                   "a spherical coordinate system when used in 2d. Indeed, "
+                                   "in 2d the geometry is simply an annulus in a Cartesian "
+                                   "coordinate system and consequently would correspond to "
+                                   "a cross section of the fluid filled space between two "
+                                   "infinite cylinders where one has made the assumption that "
+                                   "the velocity in direction of the cylinder axes is zero. "
+                                   "This is consistent with the definition of what we consider "
+                                   "the two-dimension case given in "
+                                   "Section~\\ref{sec:methods:2d-models}."
+                                   "\n\n"
+                                   "The model assigns boundary indicators as follows: In 2d, "
+                                   "inner and outer boundaries get boundary indicators zero "
+                                   "and one, and if the opening angle set in the input file "
+                                   "is less than 360, then left and right boundaries are "
+                                   "assigned indicators two and three. These boundaries can "
+                                   "also be referenced using the symbolic names `inner', `outer' "
+                                   "and (if applicable) `left', `right'."
+                                   "\n\n"
+                                   "In 3d, inner and "
+                                   "outer indicators are treated as in 2d. If the opening "
+                                   "angle is chosen as 90 degrees, i.e., the domain is the "
+                                   "intersection of a spherical shell and the first octant, "
+                                   "then indicator 2 is at the face $x=0$, 3 at $y=0$, "
+                                   "and 4 at $z=0$. These last three boundaries can then also "
+                                   "be referred to as `east', `west' and `south' symbolically "
+                                   "in input files.")
+  }
+}
diff --git a/source/geometry_model/two_merged_boxes.cc.bak b/source/geometry_model/two_merged_boxes.cc.bak
new file mode 100644
index 00000000000..fad3973b171
--- /dev/null
+++ b/source/geometry_model/two_merged_boxes.cc.bak
@@ -0,0 +1,570 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/grid/tria_accessor.h>
+#include <deal.II/grid/grid_tools.h>
+
+#include <functional>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::
+    set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const
+    {
+      // iterate over all active cells and (re)set the boundary indicators
+      for (const auto &cell : triangulation.active_cell_iterators())
+        {
+          // first set the default boundary indicators
+          for (const unsigned int f : cell->face_indices())
+            if (cell->face(f)->at_boundary())
+              cell->face(f)->set_boundary_id (f);
+
+          // Then for individual faces set the boundary indicators in specific ways:
+          if (cell->face(0)->at_boundary())
+            // set the lithospheric part of the left boundary to indicator 2*dim
+            if (cell->face(0)->vertex(cell->face(0)->n_vertices()-1)[dim-1] > height_lith)
+              cell->face(0)->set_boundary_id (2*dim);
+
+          if (cell->face(1)->at_boundary())
+            // set the lithospheric part of the right boundary to indicator 2*dim+1
+            if (cell->face(1)->vertex(cell->face(1)->n_vertices()-1)[dim-1] > height_lith)
+              cell->face(1)->set_boundary_id (2*dim+1);
+
+          if (dim==3)
+            {
+              // set the lithospheric part of the front boundary to indicator 2*dim+2
+              if (cell->face(2)->at_boundary())
+                if (cell->face(2)->vertex(cell->face(2)->n_vertices()-1)[dim-1] > height_lith)
+                  cell->face(2)->set_boundary_id (2*dim+2);
+
+              // set the lithospheric part of the back boundary to indicator 2*dim+3
+              if (cell->face(3)->at_boundary())
+                if (cell->face(3)->vertex(cell->face(3)->n_vertices()-1)[dim-1] > height_lith)
+                  cell->face(3)->set_boundary_id (2*dim+3);
+            }
+        }
+    }
+
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::
+    create_coarse_mesh (parallel::distributed::Triangulation<dim> &total_coarse_grid) const
+    {
+      std::vector<unsigned int> lower_rep_vec(lower_repetitions.begin(), lower_repetitions.end());
+      if (use_merged_grids)
+        {
+          std::vector<unsigned int> upper_rep_vec(upper_repetitions.begin(), upper_repetitions.end());
+
+          // the two triangulations that will be merged
+          Triangulation<dim> lower_coarse_grid;
+          Triangulation<dim> upper_coarse_grid;
+
+          // create lower_coarse_grid mesh
+          GridGenerator::subdivided_hyper_rectangle (lower_coarse_grid,
+                                                     lower_rep_vec,
+                                                     lower_box_origin,
+                                                     lower_box_origin+lower_extents,
+                                                     false);
+
+          // create upper_coarse_grid mesh
+          GridGenerator::subdivided_hyper_rectangle (upper_coarse_grid,
+                                                     upper_rep_vec,
+                                                     upper_box_origin,
+                                                     upper_box_origin+upper_extents,
+                                                     false);
+
+          // merge the lower and upper mesh into one total_coarse_grid.
+          // now we have at least two cells
+          GridGenerator::merge_triangulations(lower_coarse_grid,
+                                              upper_coarse_grid,
+                                              total_coarse_grid);
+        }
+      else
+        {
+          GridGenerator::subdivided_hyper_rectangle (total_coarse_grid,
+                                                     lower_rep_vec,
+                                                     lower_box_origin,
+                                                     upper_box_origin+upper_extents,
+                                                     false);
+        }
+
+      // set the boundary indicators
+      set_boundary_indicators(total_coarse_grid);
+
+      // tell p4est about the periodicity of the mesh.
+      std::vector<GridTools::PeriodicFacePair<typename parallel::distributed::Triangulation<dim>::cell_iterator>>
+      periodicity_vector;
+      for (int i=0; i<dim+dim-1; ++i)
+        {
+          if (periodic[i])
+            GridTools::collect_periodic_faces
+            (total_coarse_grid, /*b_id1*/ 2*i, /*b_id2*/ 2*i+1,
+             /*direction*/ i%dim, periodicity_vector);
+        }
+      if (periodicity_vector.size() > 0)
+        total_coarse_grid.add_periodicity (periodicity_vector);
+
+      // make sure the right boundary indicators are set after refinement
+      // through the function set_boundary_indicators above
+      total_coarse_grid.signals.post_refinement.connect (
+        [&]()
+      {
+        this->set_boundary_indicators(total_coarse_grid);
+      });
+    }
+
+
+    template <int dim>
+    std::set<types::boundary_id>
+    TwoMergedBoxes<dim>::
+    get_used_boundary_indicators () const
+    {
+      // boundary indicators are zero through 2*dim+2*(dim-1)-1
+      std::set<types::boundary_id> s;
+      for (unsigned int i=0; i<2*dim+2*(dim-1); ++i)
+        s.insert (i);
+      return s;
+    }
+
+
+
+    template <int dim>
+    std::map<std::string,types::boundary_id>
+    TwoMergedBoxes<dim>::
+    get_symbolic_boundary_names_map () const
+    {
+      switch (dim)
+        {
+          case 2:
+          {
+            return
+            {
+              {"left",   0},
+              {"right",  1},
+              {"bottom", 2},
+              {"top",    3},
+              {"left lithosphere", 4},
+              {"right lithosphere",5}
+            };
+          }
+
+          case 3:
+          {
+            return
+            {
+              {"left",   0},
+              {"right",  1},
+              {"front",  2},
+              {"back",   3},
+              {"bottom", 4},
+              {"top",    5},
+              {"left lithosphere",  6},
+              {"right lithosphere", 7},
+              {"front lithosphere", 8},
+              {"back lithosphere",  9}
+            };
+          }
+        }
+
+      Assert (false, ExcNotImplemented());
+      return {};
+    }
+
+
+
+    template <int dim>
+    std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
+    TwoMergedBoxes<dim>::
+    get_periodic_boundary_pairs () const
+    {
+      std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>> periodic_boundaries;
+      for ( unsigned int i=0; i<dim+dim-1; ++i)
+        if (periodic[i])
+          {
+            const unsigned int direction = i>=dim ? i-dim : i;
+            periodic_boundaries.insert( std::make_pair( std::pair<types::boundary_id, types::boundary_id>(2*i, 2*i+1), direction) );
+          }
+      return periodic_boundaries;
+    }
+
+
+
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::adjust_positions_for_periodicity (Point<dim> &position,
+                                                           const ArrayView<Point<dim>> &connected_positions,
+                                                           const ArrayView<Tensor<1, dim>> &/*connected_velocities*/) const
+    {
+      for (unsigned int i = 0; i < dim; ++i)
+        if (periodic[i])
+          {
+            if (position[i] < lower_box_origin[i])
+              {
+                position[i] += extents[i];
+                for (auto &connected_position: connected_positions)
+                  connected_position[i] += extents[i];
+              }
+            else if (position[i] > lower_box_origin[i] + extents[i])
+              {
+                position[i] -= extents[i];
+                for (auto &connected_position: connected_positions)
+                  connected_position[i] -= extents[i];
+              }
+          }
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    TwoMergedBoxes<dim>::get_extents () const
+    {
+      return extents;
+    }
+
+    template <int dim>
+    Point<dim>
+    TwoMergedBoxes<dim>::get_origin () const
+    {
+      return lower_box_origin;
+    }
+
+    template <int dim>
+    double
+    TwoMergedBoxes<dim>::
+    length_scale () const
+    {
+      return 0.01*extents[0];
+    }
+
+
+    template <int dim>
+    double
+    TwoMergedBoxes<dim>::depth(const Point<dim> &position) const
+    {
+      const double d = maximal_depth()-(position(dim-1)-lower_box_origin[dim-1]);
+      return std::min (std::max (d, 0.), maximal_depth());
+    }
+
+
+    template <int dim>
+    double
+    TwoMergedBoxes<dim>::height_above_reference_surface(const Point<dim> &position) const
+    {
+      return (position(dim-1)-lower_box_origin[dim-1]) - extents[dim-1];
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    TwoMergedBoxes<dim>::representative_point(const double depth) const
+    {
+      Assert (depth >= 0,
+              ExcMessage ("Given depth must be positive or zero."));
+      Assert (depth <= maximal_depth(),
+              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
+
+      // choose a point on the center axis of the domain
+      Point<dim> p = extents/2+lower_box_origin;
+      p[dim-1] = extents[dim-1]+lower_box_origin[dim-1]-depth;
+
+      return p;
+    }
+
+
+    template <int dim>
+    double
+    TwoMergedBoxes<dim>::maximal_depth() const
+    {
+      return extents[dim-1];
+    }
+
+    template <int dim>
+    bool
+    TwoMergedBoxes<dim>::has_curved_elements() const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    bool
+    TwoMergedBoxes<dim>::point_is_in_domain(const Point<dim> &point) const
+    {
+      AssertThrow(!this->get_parameters().mesh_deformation_enabled == 0 ||
+                  this->simulator_is_past_initialization() == false,
+                  ExcMessage("After displacement of the mesh, this function can no longer be used to determine whether a point lies in the domain or not."));
+
+      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()),
+                  ExcMessage("After adding topography, this function can no longer be used to determine whether a point lies in the domain or not."));
+
+      for (unsigned int d = 0; d < dim; ++d)
+        if (point[d] > extents[d]+lower_box_origin[d]+std::numeric_limits<double>::epsilon()*extents[d] ||
+            point[d] < lower_box_origin[d]-std::numeric_limits<double>::epsilon()*extents[d])
+          return false;
+
+      return true;
+    }
+
+
+    template <int dim>
+    aspect::Utilities::Coordinates::CoordinateSystem
+    TwoMergedBoxes<dim>::natural_coordinate_system() const
+    {
+      return aspect::Utilities::Coordinates::CoordinateSystem::cartesian;
+    }
+
+
+    template <int dim>
+    std::array<double,dim>
+    TwoMergedBoxes<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
+    {
+      std::array<double,dim> position_array;
+      for (unsigned int i = 0; i < dim; ++i)
+        position_array[i] = position_point(i);
+
+      return position_array;
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    TwoMergedBoxes<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position_tensor) const
+    {
+      Point<dim> position_point;
+      for (unsigned int i = 0; i < dim; ++i)
+        position_point[i] = position_tensor[i];
+
+      return position_point;
+    }
+
+
+
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Box with lithosphere boundary indicators");
+        {
+          prm.declare_entry ("Lithospheric thickness", "0.2",
+                             Patterns::Double (0.),
+                             "The thickness of the lithosphere used to create "
+                             "additional boundary indicators to set specific "
+                             "boundary conditions for the lithosphere. ");
+
+          // Total box extents
+          prm.declare_entry ("X extent", "1.",
+                             Patterns::Double (0.),
+                             "Extent of the box in x-direction. Units: \\si{\\meter}.");
+          prm.declare_entry ("Y extent", "1.",
+                             Patterns::Double (0.),
+                             "Extent of the box in y-direction. Units: \\si{\\meter}.");
+          prm.declare_entry ("Z extent", "1.",
+                             Patterns::Double (0.),
+                             "Extent of the box in z-direction. This value is ignored "
+                             "if the simulation is in 2d. Units: \\si{\\meter}.");
+
+          // Total box origin
+          prm.declare_entry ("Box origin X coordinate", "0.",
+                             Patterns::Double (),
+                             "X coordinate of box origin. Units: \\si{\\meter}.");
+          prm.declare_entry ("Box origin Y coordinate", "0.",
+                             Patterns::Double (),
+                             "Y coordinate of box origin. Units: \\si{\\meter}.");
+          prm.declare_entry ("Box origin Z coordinate", "0.",
+                             Patterns::Double (),
+                             "Z coordinate of box origin. This value is ignored "
+                             "if the simulation is in 2d. Units: \\si{\\meter}.");
+
+          // Lower box repetitions
+          prm.declare_entry ("X repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in X direction of the lower box. "
+                             "The same number of repetitions will be used in the upper box.");
+          prm.declare_entry ("Y repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in Y direction of the lower box. If the simulation "
+                             "is in 3d, the same number of repetitions will be used in the upper box.");
+          prm.declare_entry ("Z repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in Z direction of the lower box. "
+                             "This value is ignored if the simulation is in 2d.");
+
+          // Upper box repetitions
+          prm.declare_entry ("Y repetitions lithosphere", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in Y direction in the lithosphere. "
+                             "This value is ignored if the simulation is in 3d.");
+          prm.declare_entry ("Z repetitions lithosphere", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in Z direction in the lithosphere. "
+                             "This value is ignored if the simulation is in 2d.");
+
+          // Whole box periodicity
+          prm.declare_entry ("X periodic", "false",
+                             Patterns::Bool (),
+                             "Whether the box should be periodic in X direction.");
+          prm.declare_entry ("Y periodic", "false",
+                             Patterns::Bool (),
+                             "Whether the box should be periodic in Y direction.");
+          prm.declare_entry ("Z periodic", "false",
+                             Patterns::Bool (),
+                             "Whether the box should be periodic in Z direction. "
+                             "This value is ignored if the simulation is in 2d.");
+          prm.declare_entry ("X periodic lithosphere", "false",
+                             Patterns::Bool (),
+                             "Whether the box should be periodic in X direction in the lithosphere.");
+          prm.declare_entry ("Y periodic lithosphere", "false",
+                             Patterns::Bool (),
+                             "Whether the box should be periodic in Y direction in the lithosphere. "
+                             "This value is ignored if the simulation is in 2d. ");
+
+          // grid creation parameters
+          prm.declare_entry ("Use merged grids", "true",
+                             Patterns::Bool (),
+                             "Whether to make the grid by gluing together two boxes, or just "
+                             "use one chunk to make the grid. Using two grids glued together "
+                             "is a safer option, since it forces the boundary conditions "
+                             "to be always applied to the same depth, but using one grid allows "
+                             "for a more flexible usage of the adaptive refinement. Note that if "
+                             "there is no cell boundary exactly on the boundary between the lithosphere "
+                             "and the mantle, the velocity boundary will not be exactly at that depth. "
+                             "Therefore, using a merged grid is generally recommended over using one grid."
+                             "When using one grid, the parameter for lower repetitions is used and the upper "
+                             "repetitions are ignored.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    TwoMergedBoxes<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Box with lithosphere boundary indicators");
+        {
+          const double thickness_lith = prm.get_double("Lithospheric thickness");
+
+          extents[0]           = prm.get_double ("X extent");
+          lower_extents[0]     = extents[0];
+          upper_extents[0]     = extents[0];
+          lower_box_origin[0]  = prm.get_double ("Box origin X coordinate");
+          upper_box_origin[0]  = lower_box_origin[0];
+          periodic[0]          = prm.get_bool ("X periodic");
+          periodic[dim]        = prm.get_bool ("X periodic lithosphere");
+          // to match the two triangulations, it is required that the
+          // number of horizontal repetitions are the same
+          lower_repetitions[0] = prm.get_integer ("X repetitions");
+          upper_repetitions[0] = lower_repetitions[0];
+
+          extents[1]           = prm.get_double ("Y extent");
+          lower_box_origin[1]  = prm.get_double ("Box origin Y coordinate");
+          periodic[1]          = prm.get_bool ("Y periodic");
+          lower_repetitions[1] = prm.get_integer ("Y repetitions");
+
+          if (dim == 2)
+            {
+              lower_extents[1]     = extents[1] - thickness_lith;
+              upper_extents[1]     = thickness_lith;
+              upper_box_origin[1]  = lower_box_origin[1] + lower_extents[1];
+              upper_repetitions[1] = prm.get_integer ("Y repetitions lithosphere");
+            }
+
+          if (dim == 3)
+            {
+              lower_extents[1]     = extents[1];
+              upper_extents[1]     = extents[1];
+              upper_box_origin[1]  = lower_box_origin[1];
+              periodic[dim+1]      = prm.get_bool ("Y periodic lithosphere");
+              // to match the two triangulations, it is required that the
+              // number of horizontal repetitions are the same
+              upper_repetitions[1] = lower_repetitions[1];
+              extents[2]           = prm.get_double ("Z extent");
+              lower_extents[2]     = extents[2] - thickness_lith;
+              upper_extents[2]     = thickness_lith;
+              lower_box_origin[2]  = prm.get_double ("Box origin Z coordinate");
+              upper_box_origin[2]  = lower_box_origin[2] + lower_extents[2];
+              periodic[2]          = prm.get_bool ("Z periodic");
+              lower_repetitions[2] = prm.get_integer ("Z repetitions");
+              upper_repetitions[2] = prm.get_integer ("Z repetitions lithosphere");
+            }
+
+          height_lith = upper_box_origin[dim-1];
+          use_merged_grids = prm.get_bool ("Use merged grids");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    ASPECT_REGISTER_GEOMETRY_MODEL(TwoMergedBoxes,
+                                   "box with lithosphere boundary indicators",
+                                   "A box geometry parallel to the coordinate directions. "
+                                   "The extent of the box in each coordinate direction "
+                                   "is set in the parameter file. This geometry model labels its "
+                                   "sides with 2*dim+2*(dim-1) boundary indicators: in 2d, boundary indicators 0 through 3 "
+                                   "denote the left, right, bottom and top boundaries, while indicators"
+                                   "4 and 5 denote the upper part of the left and right vertical boundary, "
+                                   "respectively. In 3d, boundary "
+                                   "indicators 0 through 5 indicate left, right, front, back, bottom "
+                                   "and top boundaries (see also the documentation of the deal.II class "
+                                   "``ReferenceCell''), while indicators 6, 7, 8 and 9 denote the left, "
+                                   "right, front and back upper parts of the vertical boundaries, respectively. "
+                                   "You can also use symbolic names ``left'', ``right'', "
+                                   "``left lithosphere'', etc., to refer to these boundaries in input files."
+                                   "\n\n"
+                                   "Note that for a given ``Global refinement level'' and no user-specified "
+                                   "``Repetitions'', the lithosphere part of the mesh will be more refined. "
+                                   "\n\n"
+                                   "The additional boundary indicators for the lithosphere allow for "
+                                   "selecting boundary conditions for the "
+                                   "lithosphere different from those for the underlying mantle. "
+                                   "An example application of this geometry is to prescribe a velocity on "
+                                   "the lithospheric plates, but use open boundary conditions underneath. ")
+  }
+}
diff --git a/source/geometry_model/two_merged_chunks.cc.bak b/source/geometry_model/two_merged_chunks.cc.bak
new file mode 100644
index 00000000000..1c120768195
--- /dev/null
+++ b/source/geometry_model/two_merged_chunks.cc.bak
@@ -0,0 +1,635 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/geometry_model/two_merged_chunks.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+#include <aspect/geometry_model/initial_topography_model/ascii_data.h>
+
+#include <aspect/simulator_signals.h>
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/grid/tria_accessor.h>
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/grid/tria.h>
+
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    template <int dim>
+    void
+    TwoMergedChunks<dim>::initialize ()
+    {
+      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()) ||
+                  Plugins::plugin_type_matches<const InitialTopographyModel::AsciiData<dim>>(this->get_initial_topography_model()),
+                  ExcMessage("At the moment, only the Zero or AsciiData initial topography model can be used with the TwoMergedChunks geometry model."));
+
+      manifold = std::make_unique<internal::ChunkGeometry<dim>>(this->get_initial_topography_model(),
+                                                                 point1[1],
+                                                                 point1[0],
+                                                                 point2[0]-point1[0]);
+    }
+
+
+
+    template <int dim>
+    void
+    TwoMergedChunks<dim>::
+    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
+    {
+      if (use_merged_grids)
+        {
+          // The two triangulations that will be merged into coarse_grid.
+          Triangulation<dim> lower_coarse_grid;
+          Triangulation<dim> upper_coarse_grid;
+
+          const std::vector<unsigned int> lower_rep_vec(lower_repetitions.begin(), lower_repetitions.end());
+          const std::vector<unsigned int> upper_rep_vec(upper_repetitions.begin(), upper_repetitions.end());
+
+          // Create the lower box.
+          GridGenerator::subdivided_hyper_rectangle (lower_coarse_grid,
+                                                     lower_rep_vec,
+                                                     point1,
+                                                     point4,
+                                                     false);
+
+          // Create the upper box.
+          GridGenerator::subdivided_hyper_rectangle (upper_coarse_grid,
+                                                     upper_rep_vec,
+                                                     point3,
+                                                     point2,
+                                                     false);
+
+          // Merge the lower and upper mesh into one coarse_grid.
+          // Now we have at least two cells.
+          GridGenerator::merge_triangulations(lower_coarse_grid,
+                                              upper_coarse_grid,
+                                              coarse_grid);
+        }
+      else
+        {
+          const std::vector<unsigned int> lower_rep_vec(lower_repetitions.begin(), lower_repetitions.end());
+          GridGenerator::subdivided_hyper_rectangle (coarse_grid,
+                                                     lower_rep_vec,
+                                                     point1,
+                                                     point2,
+                                                     false);
+
+        }
+
+      // Transform box into spherical chunk
+      GridTools::transform (
+        [&](const Point<dim> &p) -> Point<dim>
+      {
+        return manifold->push_forward(p);
+      },
+      coarse_grid);
+
+      // Deal with a curved mesh by assigning a manifold. We arbitrarily
+      // choose manifold_id 15 for this.
+      coarse_grid.set_manifold (my_manifold_id, *manifold);
+      for (const auto &cell : coarse_grid.active_cell_iterators())
+        cell->set_all_manifold_ids (my_manifold_id);
+
+      // Set the boundary indicators.
+      set_boundary_indicators(coarse_grid);
+      // Make sure the right boundary indicators are set after refinement
+      // through the function set_boundary_indicators above.
+      coarse_grid.signals.post_refinement.connect (
+        [&]()
+      {
+        this->set_boundary_indicators(coarse_grid);
+      });
+    }
+
+
+
+    template <int dim>
+    void
+    TwoMergedChunks<dim>::
+    set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const
+    {
+      // Iterate over all active cells and (re)set the boundary indicators.
+      for (typename Triangulation<dim>::active_cell_iterator
+           cell = triangulation.begin_active();
+           cell != triangulation.end();
+           ++cell)
+        {
+          // First set the default boundary indicators.
+          for (const unsigned int f : cell->face_indices())
+            if (cell->face(f)->at_boundary())
+              cell->face(f)->set_boundary_id (f);
+
+          if (cell->face(3)->at_boundary())
+            // Set the upper part of the eastern boundary to indicator 2*dim+1
+            // by comparing the radius of the face's center point with the
+            // minimum radius of the upper radius.
+            if (cell->face(3)->center(true).norm() > point3[0])
+              cell->face(3)->set_boundary_id(2 * dim + 1);
+
+          if (cell->face(2)->at_boundary())
+            // Set the upper part of the western boundary to indicator 2*dim
+            // by comparing the radius of the face's center point with the
+            // minimum radius of the upper radius.
+            if (cell->face(2)->center(true).norm() > point3[0])
+              cell->face(2)->set_boundary_id (2*dim);
+
+          if (dim==3)
+            {
+              // Set the upper part of the southern boundary to indicator 2*dim+2.
+              if (cell->face(4)->at_boundary())
+                if ((cell->vertex(cell->face(4)->n_vertices()-1).norm() + cell->vertex(0).norm()) / 2.0 > point3[0])
+                  cell->face(4)->set_boundary_id (2*dim+2);
+
+              // Set the upper part of the northern boundary to indicator 2*dim+3.
+              if (cell->face(5)->at_boundary())
+                if ((cell->vertex((cell->face(5)->n_vertices()-1)/2).norm()  + cell->vertex(0).norm()) / 2.0 > point3[0])
+                  cell->face(5)->set_boundary_id (2*dim+3);
+            }
+
+        }
+    }
+
+
+
+    template <int dim>
+    std::set<types::boundary_id>
+    TwoMergedChunks<dim>::
+    get_used_boundary_indicators () const
+    {
+      // boundary indicators are zero through 2*dim+2*(dim-1)-1
+      std::set<types::boundary_id> s;
+      for (unsigned int i=0; i<2*dim+2*(dim-1); ++i)
+        s.insert (i);
+      return s;
+    }
+
+
+
+    template <int dim>
+    std::map<std::string,types::boundary_id>
+    TwoMergedChunks<dim>::
+    get_symbolic_boundary_names_map () const
+    {
+      switch (dim)
+        {
+          case 2:
+          {
+            return
+            {
+              {"bottom",     0},
+              {"top",        1},
+              {"lowerwest",  2},
+              {"lowereast",  3},
+              {"uppereast",  4},
+              {"upperwest",  5}
+            };
+          }
+
+          case 3:
+          {
+            return
+            {
+              {"bottom",     0},
+              {"top",        1},
+              {"lowerwest",  2},
+              {"lowereast",  3},
+              {"lowersouth", 4},
+              {"lowernorth", 5},
+              {"upperwest",  6},
+              {"uppereast",  7},
+              {"uppersouth", 8},
+              {"uppernorth", 9}
+            };
+          }
+        }
+
+      Assert (false, ExcNotImplemented());
+      return {};
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::
+    length_scale () const
+    {
+      // As described in the first ASPECT paper, a length scale of
+      // 10km = 1e4m works well for the pressure scaling for earth
+      // sized spherical shells. use a length scale that
+      // yields this value for the R0,R1 corresponding to earth
+      // but otherwise scales like (R1-R0)
+      return 1e4 * maximal_depth() / (6336000.-3481000.);
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::depth(const Point<dim> &position) const
+    {
+      // depth is defined wrt the reference surface point2[0]
+      // negative depth is not allowed
+      return std::max (0., std::min (point2[0]-position.norm(), maximal_depth()));
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::height_above_reference_surface(const Point<dim> &position) const
+    {
+      return position.norm()-point2[0];
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    TwoMergedChunks<dim>::representative_point(const double depth) const
+    {
+      Assert (depth >= 0,
+              ExcMessage ("Given depth must be positive or zero."));
+      Assert (depth <= maximal_depth(),
+              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
+
+      // Choose a point at the mean longitude (and latitude)
+      Point<dim> p = 0.5*(point2+point1);
+      // at a depth beneath the top surface
+      p[0] = point2[0]-depth;
+
+      // Now convert to Cartesian coordinates
+      return manifold->push_forward_sphere(p);
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::west_longitude () const
+    {
+      return point1[1];
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::east_longitude () const
+    {
+      return point2[1];
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::longitude_range () const
+    {
+      return point2[1] - point1[1];
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::south_latitude () const
+    {
+      if (dim == 3)
+        return point1[2];
+      else
+        return 0;
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::north_latitude () const
+    {
+      if (dim==3)
+        return point2[2];
+      else
+        return 0;
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::latitude_range () const
+    {
+      if (dim==3)
+        return point2[2] - point1[2];
+      else
+        return 0;
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::maximal_depth() const
+    {
+      return point2[0]-point1[0];
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::inner_radius () const
+    {
+      return point1[0];
+    }
+
+
+
+    template <int dim>
+    double
+    TwoMergedChunks<dim>::outer_radius () const
+    {
+      return point2[0];
+    }
+
+
+
+    template <int dim>
+    bool
+    TwoMergedChunks<dim>::has_curved_elements() const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    bool
+    TwoMergedChunks<dim>::point_is_in_domain(const Point<dim> &point) const
+    {
+      AssertThrow(!this->get_parameters().mesh_deformation_enabled ||
+                  // we are still before the first time step has started
+                  this->get_timestep_number() == 0 ||
+                  this->get_timestep_number() == numbers::invalid_unsigned_int,
+                  ExcMessage("After displacement of the mesh, this function can no longer be used to determine whether a point lies in the domain or not."));
+
+      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()),
+                  ExcMessage("After adding topography, this function can no longer be used to determine whether a point lies in the domain or not."));
+
+      const Point<dim> spherical_point = manifold->pull_back(point);
+
+      for (unsigned int d = 0; d < dim; ++d)
+        if (spherical_point[d] > point2[d]+std::numeric_limits<double>::epsilon()*std::abs(point2[d]) ||
+            spherical_point[d] < point1[d]-std::numeric_limits<double>::epsilon()*std::abs(point2[d]))
+          return false;
+
+      return true;
+    }
+
+
+
+    template <int dim>
+    std::array<double,dim>
+    TwoMergedChunks<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
+    {
+      // the chunk manifold has a order of radius, longitude, latitude.
+      // This is exactly what we need.
+      // Ignore the topography to avoid a loop when calling the
+      // AsciiDataBoundary for topography which uses this function....
+      const Point<dim> transformed_point = manifold->pull_back_sphere(position_point);
+      std::array<double,dim> position_array;
+      for (unsigned int i = 0; i < dim; ++i)
+        position_array[i] = transformed_point(i);
+
+      return position_array;
+    }
+
+
+
+    template <int dim>
+    aspect::Utilities::Coordinates::CoordinateSystem
+    TwoMergedChunks<dim>::natural_coordinate_system() const
+    {
+      // TODO This will give problems somewhere down the line
+      // if geometry models are asked for their coordinate system,
+      // chunk returns spherical and then Utilities::Coordinates::cartesian_to_spherical
+      // is used
+      return aspect::Utilities::Coordinates::CoordinateSystem::spherical;
+    }
+
+
+
+    template <int dim>
+    Point<dim>
+    TwoMergedChunks<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position_tensor) const
+    {
+      // Ignore the topography to avoid a loop when calling the
+      // AsciiDataBoundary for topography which uses this function....
+      Point<dim> position_point;
+      for (unsigned int i = 0; i < dim; ++i)
+        position_point[i] = position_tensor[i];
+      const Point<dim> transformed_point = manifold->push_forward_sphere(position_point);
+
+      return transformed_point;
+    }
+
+
+
+    template <int dim>
+    void
+    TwoMergedChunks<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Chunk with lithosphere boundary indicators");
+        {
+          prm.declare_entry ("Chunk inner radius", "0.",
+                             Patterns::Double (0.),
+                             "Radius at the bottom surface of the chunk. Units: \\si{\\meter}.");
+          prm.declare_entry ("Chunk outer radius", "1.",
+                             Patterns::Double (0.),
+                             "Radius at the top surface of the chunk. Units: \\si{\\meter}.");
+          prm.declare_entry ("Chunk middle boundary radius", "1",
+                             Patterns::Double (0),
+                             "Radius at the top surface of the lower chunk, "
+                             "where it merges with the upper chunk. Units: \\si{\\meter}.");
+
+          prm.declare_entry ("Chunk minimum longitude", "0.",
+                             Patterns::Double (-180., 360.), // enables crossing of either hemisphere
+                             "Minimum longitude of the chunk. Units: degrees.");
+          prm.declare_entry ("Chunk maximum longitude", "1.",
+                             Patterns::Double (-180., 360.), // enables crossing of either hemisphere
+                             "Maximum longitude of the chunk. Units: degrees.");
+
+          prm.declare_entry ("Chunk minimum latitude", "0.",
+                             Patterns::Double (-90., 90.),
+                             "Minimum latitude of the chunk. This value is ignored "
+                             "if the simulation is in 2d. Units: degrees.");
+          prm.declare_entry ("Chunk maximum latitude", "1.",
+                             Patterns::Double (-90., 90.),
+                             "Maximum latitude of the chunk. This value is ignored "
+                             "if the simulation is in 2d. Units: degrees.");
+
+          prm.declare_entry ("Outer chunk radius repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in radial direction for the upper chunk.");
+          prm.declare_entry ("Inner chunk radius repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in radial direction for the lower chunk.");
+          prm.declare_entry ("Longitude repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in longitude.");
+          prm.declare_entry ("Latitude repetitions", "1",
+                             Patterns::Integer (1),
+                             "Number of cells in latitude. This value is ignored "
+                             "if the simulation is in 2d");
+
+          prm.declare_entry ("Use merged grids", "true",
+                             Patterns::Bool (),
+                             "Whether to make the grid by gluing together two boxes, or just "
+                             "use one chunk to make the grid. Using two grids glued together "
+                             "is a safer option, since it forces the boundary conditions "
+                             "to be always applied to the same depth, but using one grid allows "
+                             "for a more flexible usage of the adaptive refinement. Note that if "
+                             "there is no cell boundary exactly on the boundary between the lithosphere "
+                             "and the mantle, the velocity boundary will not be exactly at that depth. "
+                             "Therefore, using a merged "
+                             "grid is generally recommended over using one grid. "
+                             "When using one grid, the parameter for lower repetitions is used and the upper "
+                             "repetitions are ignored.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    TwoMergedChunks<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Chunk with lithosphere boundary indicators");
+        {
+          point1[0] = prm.get_double("Chunk inner radius");
+          point2[0] = prm.get_double("Chunk outer radius");
+          point3[0] = prm.get_double("Chunk middle boundary radius");
+          point4[0] = point3[0];
+          lower_repetitions[0] = prm.get_integer("Inner chunk radius repetitions");
+          upper_repetitions[0] = prm.get_integer("Outer chunk radius repetitions");
+          point1[1] = prm.get_double("Chunk minimum longitude") * constants::degree_to_radians;
+          point2[1] = prm.get_double("Chunk maximum longitude") * constants::degree_to_radians;
+          point3[1] = point1[1];
+          point4[1] = point2[1];
+          lower_repetitions[1] = prm.get_integer("Longitude repetitions");
+          upper_repetitions[1] = lower_repetitions[1];
+
+          AssertThrow(point1[0] < point2[0],
+                      ExcMessage("Inner radius must be less than outer radius."));
+          AssertThrow(point1[1] < point2[1],
+                      ExcMessage("Minimum longitude must be less than maximum longitude."));
+          AssertThrow(point2[1] - point1[1] < 2. * numbers::PI,
+                      ExcMessage("Maximum - minimum longitude should be less than 360 degrees."));
+          AssertThrow(point3[0] < point2[0],
+                      ExcMessage("Middle boundary radius must be less than outer radius."));
+
+          if (dim == 3)
+            {
+              point1[2] = prm.get_double ("Chunk minimum latitude") * constants::degree_to_radians;
+              point2[2] = prm.get_double ("Chunk maximum latitude") * constants::degree_to_radians;
+              point3[2] = point1[2];
+              point4[2] = point2[2];
+              lower_repetitions[2] = prm.get_integer ("Latitude repetitions");
+              upper_repetitions[2] = lower_repetitions[2];
+
+              AssertThrow (point1[2] < point2[2],
+                           ExcMessage ("Minimum latitude must be less than maximum latitude."));
+              AssertThrow (point1[2] > -0.5*numbers::PI,
+                           ExcMessage ("Minimum latitude needs to be larger than -90 degrees."));
+              AssertThrow (point2[2] < 0.5*numbers::PI,
+                           ExcMessage ("Maximum latitude needs to be less than 90 degrees."));
+            }
+          use_merged_grids = prm.get_bool ("Use merged grids");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    ASPECT_REGISTER_GEOMETRY_MODEL(TwoMergedChunks,
+                                   "chunk with lithosphere boundary indicators",
+                                   "A geometry which can be described as a chunk of a spherical shell, "
+                                   "bounded by lines of longitude, latitude and radius. "
+                                   "The side boundaries have two boundary indicators, so the user "
+                                   "can prescribe different boundary conditions on these boundaries. "
+                                   "The minimum and maximum longitude, (latitude) and depth of the chunk "
+                                   "are set in the parameter file. The chunk geometry labels its "
+                                   "2*dim+2*(dim-1) sides as follows: ``lowerwest'' and ``lowereast'': "
+                                   "minimum and maximum longitude of the lower part of the east and west "
+                                   "side boundaries, ``upperwest'' and ``uppereast'': "
+                                   "minimum and maximum longitude of the upper part of the east and west "
+                                   "side boundaries, ``lowersouth'' and ``lowernorth'': "
+                                   "minimum and maximum latitude of the lower part of the south and north "
+                                   "side boundaries, ``uppersouth'' and ``uppernorth'': "
+                                   "minimum and maximum latitude of the upper part of the south and north "
+                                   "side boundaries, "
+                                   "\n\n"
+                                   "The dimensions of the model are specified by parameters "
+                                   "of the following form: "
+                                   "Chunk (minimum | maximum) (longitude | latitude): "
+                                   "edges of geographical quadrangle (in degrees). "
+                                   "Chunk (inner | outer | middle boundary) radius: Radii at bottom and top of chunk "
+                                   "and the radius at which the lower boundary indicator along a side "
+                                   "boundary transitions into the upper boundary indicator. "
+                                   "(Longitude | Latitude) repetitions: "
+                                   "number of cells in each coordinate direction."
+                                   "(Inner | Outer) chunk radius repetitions: "
+                                   "number of cells in the radial coordinate direction for the lower part "
+                                   "of the domain (up to the Middle boundary radius) and for the upper part "
+                                   "of the domain. "
+                                   "\n\n"
+                                   "When used in 2d, this geometry does not imply the use of "
+                                   "a spherical coordinate system. Indeed, "
+                                   "in 2d the geometry is simply a sector of an annulus in a Cartesian "
+                                   "coordinate system and consequently would correspond to "
+                                   "a sector of a cross section of the fluid filled space between two "
+                                   "infinite cylinders where one has made the assumption that "
+                                   "the velocity in direction of the cylinder axes is zero. "
+                                   "This is consistent with the definition of what we consider "
+                                   "the two-dimension case given in "
+                                   "Section~\\ref{sec:methods:2d-models}. "
+                                   "It is also possible to add initial topography to the chunk geometry, "
+                                   "based on an ascii data file. ")
+  }
+}
diff --git a/source/global.cc.bak b/source/global.cc.bak
new file mode 100644
index 00000000000..e3d9292375a
--- /dev/null
+++ b/source/global.cc.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/revision.h>
+
+#include <deal.II/base/multithread_info.h>
+#include <deal.II/base/revision.h>
+#include <deal.II/base/vectorization.h>
+
+#ifdef ASPECT_WITH_WORLD_BUILDER
+#include <world_builder/config.h>
+#endif
+
+#include <cstring>
+
+
+
+template <class Stream>
+void print_aspect_header(Stream &stream)
+{
+  const int n_tasks = dealii::Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD);
+
+  stream << "-----------------------------------------------------------------------------\n"
+         << "--                             This is ASPECT                              --\n"
+         << "-- The Advanced Solver for Planetary Evolution, Convection, and Tectonics. --\n"
+         << "-----------------------------------------------------------------------------\n"
+         << "--     . version " << ASPECT_PACKAGE_VERSION;
+  if (strcmp(ASPECT_GIT_BRANCH,"") != 0)
+    stream << " (" << ASPECT_GIT_BRANCH << ", " << ASPECT_GIT_SHORTREV << ")\n";
+  else
+    stream << "\n";
+
+  stream << "--     . using deal.II " << DEAL_II_PACKAGE_VERSION;
+  if (strcmp(DEAL_II_GIT_BRANCH,"") != 0)
+    stream << " (" << DEAL_II_GIT_BRANCH << ", " << DEAL_II_GIT_SHORTREV << ')';
+  stream << "\n";
+  stream << "--     .       with "
+#ifdef DEAL_II_WITH_64BIT_INDICES
+         << "64"
+#else
+         << "32"
+#endif
+         << " bit indices\n";
+
+  const unsigned int n_vectorization_doubles = dealii::VectorizedArray<double>::size();
+  const unsigned int n_vectorization_bits = 8 * sizeof(double) * n_vectorization_doubles;
+  const std::string vectorization_level = dealii::Utilities::System::get_current_vectorization_level();
+
+  stream << "--     .       with vectorization level ";
+  stream << DEAL_II_COMPILER_VECTORIZATION_LEVEL
+         << " (" << vectorization_level << ", "
+         << n_vectorization_doubles << " doubles, "
+         << n_vectorization_bits << " bits)\n";
+
+  stream << "--     . using Trilinos "
+         << DEAL_II_TRILINOS_VERSION_MAJOR    << '.'
+         << DEAL_II_TRILINOS_VERSION_MINOR    << '.'
+         << DEAL_II_TRILINOS_VERSION_SUBMINOR << '\n';
+  stream << "--     . using p4est "
+         << DEAL_II_P4EST_VERSION_MAJOR << '.'
+         << DEAL_II_P4EST_VERSION_MINOR << '.'
+         << DEAL_II_P4EST_VERSION_SUBMINOR << '\n';
+
+#ifdef ASPECT_WITH_WORLD_BUILDER
+  stream << "--     . using Geodynamic World Builder "
+         << WORLD_BUILDER_VERSION_MAJOR << '.'
+         << WORLD_BUILDER_VERSION_MINOR << '.'
+         << WORLD_BUILDER_VERSION_PATCH;
+
+  if (WorldBuilder::Version::GIT_SHA1 != "")
+    stream << " (" << WorldBuilder::Version::GIT_BRANCH << ", " << WorldBuilder::Version::GIT_SHA1.substr(0,9) << ')';
+
+  stream << '\n';
+#endif
+
+#ifdef DEBUG
+  stream << "--     . running in DEBUG mode\n"
+#else
+  stream << "--     . running in OPTIMIZED mode\n"
+#endif
+         << "--     . running with " << n_tasks << " MPI process" << (n_tasks == 1 ? "\n" : "es\n");
+
+  const int n_threads =
+    dealii::MultithreadInfo::n_threads();
+  if (n_threads>1)
+    stream << "--     . using " << n_threads << " threads " << (n_tasks == 1 ? "\n" : "each\n");
+
+  stream << "-----------------------------------------------------------------------------\n"
+         << std::endl;
+}
+
+template void print_aspect_header<std::ostream> (std::ostream &stream);
+template void print_aspect_header<std::ofstream> (std::ofstream &stream);
diff --git a/source/gravity_model/ascii_data.cc.bak b/source/gravity_model/ascii_data.cc.bak
new file mode 100644
index 00000000000..0bea4da69a3
--- /dev/null
+++ b/source/gravity_model/ascii_data.cc.bak
@@ -0,0 +1,126 @@
+/*
+  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/gravity_model/ascii_data.h>
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace GravityModel
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      :
+      gravity_index(numbers::invalid_unsigned_int)
+    {}
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      this->initialize(this->get_mpi_communicator());
+      gravity_index = this->get_column_index_from_name("gravity");
+    }
+
+
+    template <int dim>
+    Tensor<1,dim>
+    AsciiData<dim>::
+    gravity_vector (const Point<dim> &position) const
+    {
+      const double depth = this->get_geometry_model().depth(position);
+      const double magnitude = this->get_data_component(Point<1>(depth),gravity_index);
+
+      // in dependence of what the geometry model is, gravity points in a different direction
+      if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical ||
+          this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::ellipsoidal)
+        return - magnitude * position/position.norm();
+      else if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::cartesian)
+        {
+          Tensor<1,dim> g;
+          g[dim-1] = -magnitude;
+          return g;
+        }
+      else
+        AssertThrow (false,
+                     ExcMessage ("Not a valid geometry model for the gravity model"
+                                 "ascii data."));
+      return Tensor<1,dim>();
+    }
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // we use the same file that is used for the adiabatic conditions model,
+      // as it also contains gravity
+      prm.enter_subsection("Gravity model");
+      {
+        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                          "$ASPECT_SOURCE_DIR/data/gravity-model/",
+                                                          "prem.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Gravity model");
+      {
+        Utilities::AsciiDataBase<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GravityModel
+  {
+    ASPECT_REGISTER_GRAVITY_MODEL(AsciiData,
+                                  "ascii data",
+                                  "Gravity is read from a file that describes the reference "
+                                  "state. The default profile follows the preliminary "
+                                  "reference Earth model (PREM, Dziewonski and Anderson, 1981). "
+                                  "Note the required format of the "
+                                  "input data: The first lines may contain any number of comments "
+                                  "if they begin with `#', but one of these lines needs to "
+                                  "contain the number of points in the reference state as "
+                                  "for example `# POINTS: 3'. "
+                                  "Following the comment lines there has to be a single line "
+                                  "containing the names of all data columns, separated by arbitrarily "
+                                  "many spaces. Column names are not allowed to contain spaces. "
+                                  "The file can contain unnecessary columns, but for this plugin it "
+                                  "needs to at least provide a column named `gravity'. "
+                                  "Note that the data lines in the file need to be sorted in order "
+                                  "of increasing depth from 0 to the maximal depth in the model "
+                                  "domain. Points in the model that are outside of the provided "
+                                  "depth range will be assigned the maximum or minimum depth values, "
+                                  "respectively. Points do not need to be equidistant, "
+                                  "but the computation of properties is optimized in speed "
+                                  "if they are.")
+  }
+}
diff --git a/source/gravity_model/function.cc.bak b/source/gravity_model/function.cc.bak
new file mode 100644
index 00000000000..a3c31bef2bd
--- /dev/null
+++ b/source/gravity_model/function.cc.bak
@@ -0,0 +1,138 @@
+/*
+  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/gravity_model/function.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <iostream>
+
+namespace aspect
+{
+  namespace GravityModel
+  {
+    template <int dim>
+    Function<dim>::Function ()
+      :
+      function (dim)
+    {}
+
+    template <int dim>
+    Tensor<1,dim>
+    Function<dim>::
+    gravity_vector (const Point<dim> &position) const
+    {
+      Tensor<1,dim> gravity;
+      const Utilities::NaturalCoordinate<dim> point =
+        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
+      const Point<dim> point_in_coordinate_system = Utilities::convert_array_to_point<dim>(point.get_coordinates());
+      for (unsigned int d=0; d<dim; ++d)
+        gravity[d] = function.value(point_in_coordinate_system,d);
+      return gravity;
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::update()
+    {
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        function.set_time (this->get_time() / year_in_seconds);
+      else
+        function.set_time (this->get_time());
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Gravity model");
+      {
+        prm.enter_subsection("Function");
+        {
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle. `depth' "
+                             "will create a function, in which only the first "
+                             "parameter is non-zero, which is interpreted to "
+                             "be the depth of the point.");
+
+          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Gravity model");
+      {
+        prm.enter_subsection("Function");
+        {
+          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+        }
+        try
+          {
+            function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Gravity Model.Function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GravityModel
+  {
+    ASPECT_REGISTER_GRAVITY_MODEL(Function,
+                                  "function",
+                                  "Gravity is given in terms of an explicit formula "
+                                  "that is elaborated in the parameters in section "
+                                  "``Gravity model|Function''. The format of these "
+                                  "functions follows the syntax understood by the "
+                                  "muparser library, see "
+                                  "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+  }
+}
diff --git a/source/gravity_model/interface.cc.bak b/source/gravity_model/interface.cc.bak
new file mode 100644
index 00000000000..c657036a514
--- /dev/null
+++ b/source/gravity_model/interface.cc.bak
@@ -0,0 +1,167 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace GravityModel
+  {
+// -------------------------------- Deal with registering gravity models and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    register_gravity_model (const std::string &name,
+                            const std::string &description,
+                            void (*declare_parameters_function) (ParameterHandler &),
+                            std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_gravity_model (ParameterHandler &prm)
+    {
+      std::string model_name;
+      prm.enter_subsection ("Gravity model");
+      {
+        model_name = prm.get ("Model name");
+      }
+      prm.leave_subsection ();
+
+      // If one sets the model name to an empty string in the input file,
+      // ParameterHandler produces an error while reading the file. However,
+      // if one omits specifying any model name at all (not even setting it to
+      // the empty string) then the value we get here is the empty string. If
+      // we don't catch this case here, we end up with awkward downstream
+      // errors because the value obviously does not conform to the Pattern.
+      AssertThrow(model_name != "unspecified",
+                  ExcMessage("You need to select a Gravity model "
+                             "(`set Model name' in `subsection Gravity model')."));
+
+      return std::get<dim>(registered_plugins).create_plugin (model_name,
+                                                              "Gravity model::Model name");
+    }
+
+
+
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm)
+    {
+      // declare the entry in the parameter file
+      prm.enter_subsection ("Gravity model");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+        prm.declare_entry ("Model name", "unspecified",
+                           Patterns::Selection (pattern_of_names+"|unspecified"),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Gravity model interface",
+                                                            out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<GravityModel::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<GravityModel::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<GravityModel::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<GravityModel::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace GravityModel
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_gravity_model<dim> (const std::string &, \
+                               const std::string &, \
+                               void ( *) (ParameterHandler &), \
+                               std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_gravity_model<dim> (ParameterHandler &prm);
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/gravity_model/radial.cc.bak b/source/gravity_model/radial.cc.bak
new file mode 100644
index 00000000000..86b59a38141
--- /dev/null
+++ b/source/gravity_model/radial.cc.bak
@@ -0,0 +1,211 @@
+/*
+  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/gravity_model/radial.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/tensor.h>
+
+namespace aspect
+{
+  namespace GravityModel
+  {
+// ------------------------------ RadialConstant -------------------
+    template <int dim>
+    Tensor<1,dim>
+    RadialConstant<dim>::gravity_vector (const Point<dim> &p) const
+    {
+      if (p.norm() == 0.0)
+        return Tensor<1,dim>();
+
+      const double r = p.norm();
+      return -magnitude * p/r;
+    }
+
+
+
+    template <int dim>
+    void
+    RadialConstant<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Gravity model");
+      {
+        prm.enter_subsection("Radial constant");
+        {
+          prm.declare_entry ("Magnitude", "9.81",
+                             Patterns::Double (),
+                             "Magnitude of the gravity vector in $m/s^2$. For positive values "
+                             "the direction is radially inward towards the center of the earth.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    RadialConstant<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Gravity model");
+      {
+        prm.enter_subsection("Radial constant");
+        {
+          magnitude = prm.get_double ("Magnitude");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical ||
+                   this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::ellipsoidal,
+                   ExcMessage ("Gravity model 'radial constant' should not be used with geometry models that "
+                               "do not have either a spherical or ellipsoidal natural coordinate system."));
+    }
+
+// ------------------------------ RadialEarthLike -------------------
+
+    template <int dim>
+    void
+    RadialEarthLike<dim>::initialize ()
+    {
+      AssertThrow(false,
+                  ExcMessage("The 'radial earth-like' gravity model has been removed "
+                             "due to its misleading name. The available AsciiData gravity "
+                             "model (using default parameters) is much more earth-like, since "
+                             "it uses the gravity profile used in the construction of the "
+                             "Preliminary Reference Earth Model (PREM, Dziewonski and Anderson, "
+                             "1981). Use the 'ascii data' model instead of 'radial earth-like'."));
+    }
+
+
+
+    template <int dim>
+    Tensor<1,dim>
+    RadialEarthLike<dim>::gravity_vector (const Point<dim> &/*p*/) const
+    {
+      // We should never get here, because of the assertion in initialize().
+      AssertThrow(false,ExcInternalError());
+      return Tensor<1,dim>();
+    }
+
+
+// ----------------------------- RadialLinear ----------------------
+
+
+    template <int dim>
+    Tensor<1,dim>
+    RadialLinear<dim>::gravity_vector (const Point<dim> &p) const
+    {
+      if (p.norm() == 0.0)
+        return Tensor<1,dim>();
+
+      const double depth = this->get_geometry_model().depth(p);
+      const double maximal_depth = this->get_geometry_model().maximal_depth();
+
+      return  (-magnitude_at_surface * (1.0 - depth/maximal_depth)
+               -magnitude_at_bottom  * (depth/maximal_depth))
+              * p/p.norm();
+    }
+
+
+    template <int dim>
+    void
+    RadialLinear<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Gravity model");
+      {
+        prm.enter_subsection("Radial linear");
+        {
+          prm.declare_entry ("Magnitude at surface", "9.8",
+                             Patterns::Double (),
+                             "Magnitude of the radial gravity vector "
+                             "at the surface of the domain. "
+                             "Units: \\si{\\meter\\per\\second\\squared}.");
+          prm.declare_entry ("Magnitude at bottom", "10.7",
+                             Patterns::Double (),
+                             "Magnitude of the radial gravity vector "
+                             "at the bottom of the domain. `Bottom' means the"
+                             "maximum depth in the chosen geometry, and for "
+                             "example represents the core-mantle boundary in "
+                             "the case of the `spherical shell' geometry model, "
+                             "and the center in the case of the `sphere' "
+                             "geometry model. Units: \\si{\\meter\\per\\second\\squared}.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    RadialLinear<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Gravity model");
+      {
+        prm.enter_subsection("Radial linear");
+        {
+          magnitude_at_surface = prm.get_double ("Magnitude at surface");
+          magnitude_at_bottom = prm.get_double ("Magnitude at bottom");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical ||
+                   this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::ellipsoidal,
+                   ExcMessage ("Gravity model 'radial linear' should not be used with geometry models that "
+                               "do not have either a spherical or ellipsoidal natural coordinate system."));
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GravityModel
+  {
+    ASPECT_REGISTER_GRAVITY_MODEL(RadialConstant,
+                                  "radial constant",
+                                  "A gravity model in which the gravity has a constant magnitude "
+                                  "and the direction is radial (pointing inward if the value "
+                                  "is positive). The magnitude is read from the parameter "
+                                  "file in subsection 'Radial constant'.")
+
+    ASPECT_REGISTER_GRAVITY_MODEL(RadialEarthLike,
+                                  "radial earth-like",
+                                  "This plugin has been removed due to its misleading name. "
+                                  "The included profile was hard-coded and was less earth-like "
+                                  "than the `ascii data' plugin, which uses the profile "
+                                  "of the Preliminary Reference Earth Model (PREM). Use `ascii data' "
+                                  "instead of `radial earth-like'.")
+
+    ASPECT_REGISTER_GRAVITY_MODEL(RadialLinear,
+                                  "radial linear",
+                                  "A gravity model which is radial (pointing inward if the gravity "
+                                  "is positive) and the magnitude changes linearly with depth. The "
+                                  "magnitude of gravity at the surface and bottom is read from the "
+                                  "input file in a section ``Gravity model/Radial linear''.")
+  }
+}
diff --git a/source/gravity_model/vertical.cc.bak b/source/gravity_model/vertical.cc.bak
new file mode 100644
index 00000000000..df7c1898222
--- /dev/null
+++ b/source/gravity_model/vertical.cc.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/gravity_model/vertical.h>
+
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/tensor.h>
+
+namespace aspect
+{
+  namespace GravityModel
+  {
+    template <int dim>
+    Tensor<1,dim>
+    Vertical<dim>::gravity_vector (const Point<dim> &) const
+    {
+      Tensor<1,dim> g;
+      g[dim-1] = -gravity_magnitude;
+      return g;
+    }
+
+
+
+    template <int dim>
+    void
+    Vertical<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Gravity model");
+      {
+        prm.enter_subsection("Vertical");
+        {
+          prm.declare_entry ("Magnitude", "1.",
+                             Patterns::Double (),
+                             "Value of the gravity vector in $m/s^2$ directed "
+                             "along negative y (2d) or z (3d) axis (if the magnitude "
+                             "is positive.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+
+    template <int dim>
+    void
+    Vertical<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Gravity model");
+      {
+        prm.enter_subsection("Vertical");
+        {
+          gravity_magnitude = prm.get_double ("Magnitude");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::cartesian,
+                   ExcMessage ("Gravity model 'vertical' should not be used with geometry models that "
+                               "do not have a Cartesian natural coordinate system."));
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GravityModel
+  {
+    ASPECT_REGISTER_GRAVITY_MODEL(Vertical,
+                                  "vertical",
+                                  "A gravity model in which the gravity direction is vertical (pointing "
+                                  "downward for positive values) and at a constant magnitude by default "
+                                  "equal to one.")
+  }
+}
diff --git a/source/heating_model/adiabatic_heating.cc.bak b/source/heating_model/adiabatic_heating.cc.bak
new file mode 100644
index 00000000000..6b4f3936e34
--- /dev/null
+++ b/source/heating_model/adiabatic_heating.cc.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/heating_model/adiabatic_heating.h>
+#include <aspect/gravity_model/interface.h>
+
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    bool
+    AdiabaticHeating<dim>::use_simplified_adiabatic_heating() const
+    {
+      return simplified_adiabatic_heating;
+    }
+
+    template <int dim>
+    void
+    AdiabaticHeating<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          if (!simplified_adiabatic_heating)
+            heating_model_outputs.heating_source_terms[q] = (material_model_inputs.velocity[q] * material_model_inputs.pressure_gradient[q])
+                                                            * material_model_outputs.thermal_expansion_coefficients[q]
+                                                            * material_model_inputs.temperature[q];
+          else
+            heating_model_outputs.heating_source_terms[q] = (material_model_inputs.velocity[q]
+                                                             * this->get_gravity_model().gravity_vector(material_model_inputs.position[q]))
+                                                            * material_model_outputs.thermal_expansion_coefficients[q]
+                                                            * material_model_inputs.temperature[q]
+                                                            * material_model_outputs.densities[q];
+
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+    template <int dim>
+    void
+    AdiabaticHeating<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Adiabatic heating");
+        {
+          prm.declare_entry ("Use simplified adiabatic heating", "false",
+                             Patterns::Bool (),
+                             "A flag indicating whether the adiabatic heating should be simplified "
+                             "from $\\alpha T (\\mathbf u \\cdot \\nabla p)$ to "
+                             "$ \\alpha \\rho T (\\mathbf u \\cdot \\mathbf g) $.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    AdiabaticHeating<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Adiabatic heating");
+        {
+          simplified_adiabatic_heating = prm.get_bool ("Use simplified adiabatic heating");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(AdiabaticHeating,
+                                  "adiabatic heating",
+                                  "Implementation of a standard and a simplified model of "
+                                  "adiabatic heating.")
+  }
+}
diff --git a/source/heating_model/adiabatic_heating_of_melt.cc.bak b/source/heating_model/adiabatic_heating_of_melt.cc.bak
new file mode 100644
index 00000000000..7b5c333206f
--- /dev/null
+++ b/source/heating_model/adiabatic_heating_of_melt.cc.bak
@@ -0,0 +1,160 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/heating_model/adiabatic_heating_of_melt.h>
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+#include <deal.II/numerics/fe_field_function.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    AdiabaticHeatingMelt<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      AssertThrow(this->include_melt_transport(),
+                  ExcMessage ("Heating model Adiabatic heating with melt only works if melt transport is enabled."));
+
+      // get the melt velocity
+      const MaterialModel::MeltInputs<dim> *melt_in = material_model_inputs.template get_additional_input<MaterialModel::MeltInputs<dim>>();
+      AssertThrow(melt_in != nullptr,
+                  ExcMessage ("Need MeltInputs from the material model for adiabatic heating with melt!"));
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          const double porosity = material_model_inputs.composition[q][this->introspection().compositional_index_for_name("porosity")];
+
+          if (!simplified_adiabatic_heating)
+            heating_model_outputs.heating_source_terms[q] = ((-porosity * material_model_inputs.velocity[q] + porosity * melt_in->fluid_velocities[q])
+                                                             * material_model_inputs.pressure_gradient[q])
+                                                            * material_model_outputs.thermal_expansion_coefficients[q]
+                                                            * material_model_inputs.temperature[q];
+          else
+            {
+              const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+              Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for adiabatic heating with melt."));
+
+              heating_model_outputs.heating_source_terms[q] = (-porosity * material_model_inputs.velocity[q]
+                                                               * this->get_gravity_model().gravity_vector(material_model_inputs.position[q]))
+                                                              * material_model_outputs.thermal_expansion_coefficients[q]
+                                                              * material_model_inputs.temperature[q]
+                                                              * material_model_outputs.densities[q]
+                                                              +
+                                                              ((porosity * melt_in->fluid_velocities[q])
+                                                               * this->get_gravity_model().gravity_vector(material_model_inputs.position[q]))
+                                                              * material_model_outputs.thermal_expansion_coefficients[q]
+                                                              * material_model_inputs.temperature[q]
+                                                              * melt_outputs->fluid_densities[q];
+            }
+
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+    template <int dim>
+    void
+    AdiabaticHeatingMelt<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Adiabatic heating of melt");
+        {
+          prm.declare_entry ("Use simplified adiabatic heating", "false",
+                             Patterns::Bool (),
+                             "A flag indicating whether the adiabatic heating should be simplified "
+                             "from $\\alpha T (\\mathbf u \\cdot \\nabla p)$ to "
+                             "$ \\alpha \\rho T (\\mathbf u \\cdot \\mathbf g) $.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    AdiabaticHeatingMelt<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Adiabatic heating of melt");
+        {
+          simplified_adiabatic_heating = prm.get_bool ("Use simplified adiabatic heating");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    AdiabaticHeatingMelt<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output) const
+    {
+      MeltHandler<dim>::create_material_model_outputs(output);
+    }
+
+
+
+    template <int dim>
+    void
+    AdiabaticHeatingMelt<dim>::
+    create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &inputs) const
+    {
+      // we need the melt inputs for this adiabatic heating of melt
+      if (inputs.template get_additional_input<MaterialModel::MeltInputs<dim>>() == nullptr)
+        inputs.additional_inputs.emplace_back(
+          std::make_unique<MaterialModel::MeltInputs<dim>> (inputs.n_evaluation_points()));
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(AdiabaticHeatingMelt,
+                                  "adiabatic heating of melt",
+                                  "Implementation of a standard and a simplified model of "
+                                  "adiabatic heating of melt. The full model implements the "
+                                  "heating term \n"
+                                  "$\\alpha T (-\\phi \\mathbf u_s \\cdot \\nabla p) "
+                                  "+ \\alpha T (\\phi \\mathbf u_f \\cdot \\nabla p)$.\n"
+                                  "For full adiabatic heating, "
+                                  "this has to be used in combination with the heating model "
+                                  "`adiabatic heating' to also include adiabatic heating for "
+                                  "the solid part, and the full heating term is then "
+                                  "$\\alpha T ((1-\\phi) \\mathbf u_s \\cdot \\nabla p) "
+                                  "+ \\alpha T (\\phi \\mathbf u_f \\cdot \\nabla p)$.")
+  }
+}
diff --git a/source/heating_model/compositional_heating.cc.bak b/source/heating_model/compositional_heating.cc.bak
new file mode 100644
index 00000000000..85bc7700c26
--- /dev/null
+++ b/source/heating_model/compositional_heating.cc.bak
@@ -0,0 +1,141 @@
+/*
+  Copyright (C) 2017 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/heating_model/compositional_heating.h>
+#include <aspect/utilities.h>
+#include <aspect/global.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    CompositionalHeating<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &/*material_model_outputs*/,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      for (unsigned int q = 0; q < heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          // Compute compositional volume fractions
+          const std::vector<double> volume_fractions = MaterialModel::MaterialUtilities::compute_composition_fractions(material_model_inputs.composition[q],
+                                                       ComponentMask(fields_used_in_heat_production_averaging));
+
+          // Calculate average compositional heat production
+          double compositional_heat_production = 0.;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            if (c>0 || use_background_field_for_heat_production_averaging)
+              compositional_heat_production += volume_fractions[c] * heating_values[c];
+
+          heating_model_outputs.heating_source_terms[q] = compositional_heat_production;
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+    template <int dim>
+    void
+    CompositionalHeating<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Compositional heating");
+        {
+          prm.declare_entry("Compositional heating values","0.",
+                            Patterns::List (Patterns::Double(0.)),
+                            "List of heat production per unit volume values for "
+                            "background and compositional fields, for a total of "
+                            "N+1 values, where the first value corresponds to the "
+                            "background material, and N is the number of compositional fields. "
+                            "Units: \\si{\\watt\\per\\meter\\cubed}.");
+          prm.declare_entry ("Use compositional field for heat production averaging", "1",
+                             Patterns::List(Patterns::Integer(0,1)),
+                             "A list of integers with as many entries as compositional fields plus one. "
+                             "The first entry corresponds to the background material, each following "
+                             "entry corresponds to a particular compositional field. If the entry for "
+                             "a field is '1' this field is considered during the computation of volume "
+                             "fractions, if it is '0' the field is ignored. This is useful "
+                             "if some compositional fields are used to track properties like "
+                             "finite strain that should not contribute to heat production. The first "
+                             "entry determines whether the background field contributes to heat production "
+                             "or not (essentially similar to setting its 'Compositional heating values' to "
+                             "zero, but included for consistency in the length of the input lists).");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    CompositionalHeating<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // increment by one for background:
+      const unsigned int n_fields = this->n_compositional_fields() + 1;
+
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Compositional heating");
+        {
+          const std::vector<int> used_fields = Utilities::possibly_extend_from_1_to_N (
+                                                 Utilities::string_to_int(
+                                                   Utilities::split_string_list(
+                                                     prm.get("Use compositional field for heat production averaging"))),
+                                                 n_fields,
+                                                 "Use compositional field for heat production averaging");
+
+          use_background_field_for_heat_production_averaging = static_cast<bool>(used_fields[0]);
+
+          fields_used_in_heat_production_averaging.resize(this->n_compositional_fields());
+          for (unsigned int i=0; i<fields_used_in_heat_production_averaging.size(); ++i)
+            fields_used_in_heat_production_averaging[i] = static_cast<bool>(used_fields[i+1]);
+
+          heating_values = Utilities::possibly_extend_from_1_to_N (
+                             Utilities::string_to_double(
+                               Utilities::split_string_list(
+                                 prm.get("Compositional heating values"))),
+                             n_fields,
+                             "Compositional heating values");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(CompositionalHeating,
+                                  "compositional heating",
+                                  "Implementation of a model in which magnitude of internal heat production "
+                                  "is determined from fixed values assigned to each compositional "
+                                  "field. These values are interpreted as having units "
+                                  "\\si{\\watt\\per\\meter\\cubed}.")
+  }
+}
diff --git a/source/heating_model/constant_heating.cc.bak b/source/heating_model/constant_heating.cc.bak
new file mode 100644
index 00000000000..f6b87d3d9cb
--- /dev/null
+++ b/source/heating_model/constant_heating.cc.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/heating_model/constant_heating.h>
+
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    ConstantHeating<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &/*material_model_inputs*/,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          // return a constant value
+          heating_model_outputs.heating_source_terms[q] = radiogenic_heating_rate
+                                                          * material_model_outputs.densities[q];
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    ConstantHeating<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Constant heating");
+        {
+          prm.declare_entry ("Radiogenic heating rate", "0.",
+                             Patterns::Double (0.),
+                             "The specific rate of heating due to radioactive decay (or other bulk sources "
+                             "you may want to describe). This parameter corresponds to the variable "
+                             "$H$ in the temperature equation stated in the manual, and the heating "
+                             "term is $\\rho H$. Units: W/kg.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ConstantHeating<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Constant heating");
+        {
+          radiogenic_heating_rate    = prm.get_double ("Radiogenic heating rate");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(ConstantHeating,
+                                  "constant heating",
+                                  "Implementation of a model in which the heating "
+                                  "rate is constant.")
+  }
+}
diff --git a/source/heating_model/function.cc.bak b/source/heating_model/function.cc.bak
new file mode 100644
index 00000000000..dd7f833e2e0
--- /dev/null
+++ b/source/heating_model/function.cc.bak
@@ -0,0 +1,157 @@
+/*
+  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/heating_model/function.h>
+
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    Function<dim>::Function ()
+      :
+      heating_model_function (1)
+    {}
+
+
+    template <int dim>
+    void
+    Function<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          // convert the position into the selected coordinate system
+          const Point<dim> position = material_model_inputs.position[q];
+          const Utilities::NaturalCoordinate<dim> point =
+            this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
+
+          // then compute the heating function value at this position
+          heating_model_outputs.heating_source_terms[q] = heating_model_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()))
+                                                          * material_model_outputs.densities[q];
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::update ()
+    {
+      const double time = this->get_time();
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        heating_model_function.set_time (time / year_in_seconds);
+      else
+        heating_model_function.set_time (time);
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Function");
+        {
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle. `depth' "
+                             "will create a function, in which only the first "
+                             "parameter is non-zero, which is interpreted to "
+                             "be the depth of the point.");
+
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Function");
+        {
+          try
+            {
+              heating_model_function.parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Heating model.Function'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+
+          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(Function,
+                                  "function",
+                                  "Implementation of a model in which the heating "
+                                  "rate is given in terms of an explicit formula "
+                                  "that is elaborated in the parameters in section "
+                                  "``Heating model|Function''. The format of these "
+                                  "functions follows the syntax understood by the "
+                                  "muparser library, see "
+                                  "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`."
+                                  "\n\n"
+                                  "The formula is interpreted as having units "
+                                  "W/kg."
+                                  "\n\n"
+                                  "Since the symbol $t$ indicating time "
+                                  "may appear in the formulas for the heating rate"
+                                  ", it is interpreted as having units "
+                                  "seconds unless the global parameter ``Use "
+                                  "years in output instead of seconds'' is set.")
+  }
+}
diff --git a/source/heating_model/interface.cc.bak b/source/heating_model/interface.cc.bak
new file mode 100644
index 00000000000..ac0fff5b29e
--- /dev/null
+++ b/source/heating_model/interface.cc.bak
@@ -0,0 +1,324 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/heating_model/adiabatic_heating.h>
+#include <aspect/heating_model/shear_heating.h>
+
+#include <deal.II/base/exceptions.h>
+#include <deal.II/base/signaling_nan.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    Interface<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> & /*outputs*/) const
+    {}
+
+
+
+    template <int dim>
+    void
+    Interface<dim>::
+    create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> & /*inputs*/) const
+    {}
+
+
+    // ------------------------------ Manager -----------------------------
+
+
+
+    template <int dim>
+    bool
+    Manager<dim>::adiabatic_heating_enabled() const
+    {
+      return has_matching_heating_model<HeatingModel::AdiabaticHeating<dim>>() ;
+    }
+
+
+
+    template <int dim>
+    bool
+    Manager<dim>::shear_heating_enabled() const
+    {
+      return has_matching_heating_model<HeatingModel::ShearHeating<dim>>() ;
+    }
+
+
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_heating_model (const std::string &name,
+                                          const std::string &description,
+                                          void (*declare_parameters_function) (ParameterHandler &),
+                                          std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // find out which plugins are requested and the various other
+      // parameters we declare here
+      prm.enter_subsection ("Heating model");
+      {
+        model_names
+          = Utilities::split_string_list(prm.get("List of model names"));
+
+        AssertThrow(Utilities::has_unique_entries(model_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Heating model/List of model names' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+      }
+      prm.leave_subsection ();
+
+      // go through the list, create objects and let them parse
+      // their own parameters
+      for (auto &model_name : model_names)
+        {
+          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
+                                          (std::get<dim>(registered_plugins)
+                                           .create_plugin (model_name,
+                                                           "Heating model::Model names")));
+
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
+            sim->initialize_simulator (this->get_simulator());
+
+          this->plugin_objects.back()->parse_parameters (prm);
+          this->plugin_objects.back()->initialize ();
+        }
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                            const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                            HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      // Initialize all outputs to zero, because heating_model_outputs is
+      // often reused in loops over all cells
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          heating_model_outputs.heating_source_terms[q] = 0.0;
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+          heating_model_outputs.rates_of_temperature_change[q] = 0.0;
+        }
+
+      HeatingModel::HeatingModelOutputs individual_heating_outputs(material_model_inputs.n_evaluation_points(),
+                                                                   this->n_compositional_fields());
+
+      const MaterialModel::ReactionRateOutputs<dim> *reaction_rate_outputs
+        = material_model_outputs.template get_additional_output<MaterialModel::ReactionRateOutputs<dim>>();
+
+      for (const auto &heating_model : this->plugin_objects)
+        {
+          heating_model->evaluate(material_model_inputs, material_model_outputs, individual_heating_outputs);
+          for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+            {
+              heating_model_outputs.heating_source_terms[q] += individual_heating_outputs.heating_source_terms[q];
+              heating_model_outputs.lhs_latent_heat_terms[q] += individual_heating_outputs.lhs_latent_heat_terms[q];
+
+              if (!this->get_parameters().use_operator_splitting)
+                Assert(individual_heating_outputs.rates_of_temperature_change[q] == 0.0,
+                       ExcMessage("Rates of temperature change heating model outputs have to be zero "
+                                  "if the model does not use operator splitting."));
+              heating_model_outputs.rates_of_temperature_change[q] += individual_heating_outputs.rates_of_temperature_change[q];
+            }
+          individual_heating_outputs.reset();
+        }
+
+      // If the heating model does not get the reaction rate outputs, it can not correctly compute
+      // the rates of temperature change. To make sure these (incorrect) values are never used anywhere,
+      // overwrite them with signaling_NaNs.
+      if (reaction_rate_outputs == nullptr)
+        for (double &q : heating_model_outputs.rates_of_temperature_change)
+          q = numbers::signaling_nan<double>();
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::
+    create_additional_material_model_inputs_and_outputs(MaterialModel::MaterialModelInputs<dim>  &material_model_inputs,
+                                                        MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const
+    {
+      for (const auto &heating_model : this->plugin_objects)
+        {
+          heating_model->create_additional_material_model_inputs(material_model_inputs);
+        }
+
+      for (const auto &heating_model : this->plugin_objects)
+        {
+          heating_model->create_additional_material_model_outputs(material_model_outputs);
+        }
+    }
+
+
+
+    template <int dim>
+    const std::vector<std::string> &
+    Manager<dim>::get_active_heating_model_names () const
+    {
+      return model_names;
+    }
+
+
+    template <int dim>
+    const std::list<std::unique_ptr<Interface<dim>>> &
+    Manager<dim>::get_active_heating_models () const
+    {
+      return this->plugin_objects;
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // declare the actual entry in the parameter file
+      prm.enter_subsection ("Heating model");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry("List of model names",
+                          "",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma separated list of heating models that "
+                          "will be used to calculate the heating terms in the energy "
+                          "equation. The results of each of these criteria, i.e., "
+                          "the heating source terms and the latent heat terms for the "
+                          "left hand side will be added.\n\n"
+                          "The following heating models are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Heating model interface",
+                                                            out);
+    }
+
+
+
+    HeatingModelOutputs::HeatingModelOutputs(const unsigned int n_points,
+                                             const unsigned int)
+      :
+      heating_source_terms(n_points,numbers::signaling_nan<double>()),
+      // initialize the reaction terms with zeroes because they are not filled
+      // in all heating models
+      rates_of_temperature_change(n_points,0.0),
+      lhs_latent_heat_terms(n_points,numbers::signaling_nan<double>())
+    {
+    }
+
+
+
+    void
+    HeatingModelOutputs::reset()
+    {
+      for (unsigned int q=0; q<heating_source_terms.size(); ++q)
+        {
+          heating_source_terms[q] = numbers::signaling_nan<double>();
+          lhs_latent_heat_terms[q] = numbers::signaling_nan<double>();
+          rates_of_temperature_change[q] = 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ()
+    {
+      return std::get<dim>(registered_plugins).get_pattern_of_names ();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<HeatingModel::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<HeatingModel::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<HeatingModel::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<HeatingModel::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace HeatingModel
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>; \
+  \
+  template \
+  std::string \
+  get_valid_model_names_pattern<dim> ();
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/heating_model/latent_heat.cc.bak b/source/heating_model/latent_heat.cc.bak
new file mode 100644
index 00000000000..40e56610f0c
--- /dev/null
+++ b/source/heating_model/latent_heat.cc.bak
@@ -0,0 +1,63 @@
+/*
+  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/heating_model/latent_heat.h>
+
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    LatentHeat<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          heating_model_outputs.heating_source_terms[q] = material_model_inputs.temperature[q]
+                                                          * material_model_outputs.densities[q]
+                                                          * material_model_outputs.entropy_derivative_pressure[q]
+                                                          * (material_model_inputs.velocity[q] * material_model_inputs.pressure_gradient[q]);
+
+          heating_model_outputs.lhs_latent_heat_terms[q] = - material_model_outputs.densities[q]
+                                                           * material_model_inputs.temperature[q]
+                                                           * material_model_outputs.entropy_derivative_temperature[q];
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(LatentHeat,
+                                  "latent heat",
+                                  "Implementation of a standard model for latent heat.")
+  }
+}
diff --git a/source/heating_model/latent_heat_melt.cc.bak b/source/heating_model/latent_heat_melt.cc.bak
new file mode 100644
index 00000000000..1a69ed21502
--- /dev/null
+++ b/source/heating_model/latent_heat_melt.cc.bak
@@ -0,0 +1,187 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/heating_model/latent_heat_melt.h>
+#include <aspect/material_model/interface.h>
+
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    LatentHeatMelt<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      const bool use_operator_split = (this->get_parameters().use_operator_splitting);
+
+      const MaterialModel::ReactionRateOutputs<dim> *reaction_rate_out
+        = material_model_outputs.template get_additional_output<MaterialModel::ReactionRateOutputs<dim>>();
+
+      const MaterialModel::EnthalpyOutputs<dim> *enthalpy_out
+        = material_model_outputs.template get_additional_output<MaterialModel::EnthalpyOutputs<dim>>();
+
+      double enthalpy_change;
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          heating_model_outputs.heating_source_terms[q] = 0.0;
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+          heating_model_outputs.rates_of_temperature_change[q] = 0.0;
+
+          // Determine if the change of energy should come from the material model
+          if (retrieve_entropy_change_from_material_model && enthalpy_out)
+            enthalpy_change = - enthalpy_out->enthalpies_of_fusion[q];
+          else
+            enthalpy_change = melting_entropy_change * material_model_inputs.temperature[q];
+
+          if (this->introspection().compositional_name_exists("porosity") &&  this->get_timestep_number() > 0)
+            {
+              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+              double melting_rate = 0.0;
+
+              if (!use_operator_split)
+                {
+                  // with melt migration the reaction term is a mass reaction rate,
+                  // without melt migration, the reaction term is a constant value in terms of volume,
+                  // and we have to scale it to the correct units
+                  if (this->include_melt_transport())
+                    melting_rate = material_model_outputs.reaction_terms[q][porosity_idx];
+                  else
+                    melting_rate = material_model_outputs.reaction_terms[q][porosity_idx]
+                                   * material_model_outputs.densities[q] / this->get_timestep();
+
+                  heating_model_outputs.heating_source_terms[q] = enthalpy_change * melting_rate;
+                }
+              else if (use_operator_split && reaction_rate_out != nullptr)
+                {
+                  // if operator splitting is used in the model, we have to use the reaction rates from the
+                  // material model outputs instead of the reaction terms
+                  AssertThrow (std::isfinite(reaction_rate_out->reaction_rates[q][porosity_idx]),
+                               ExcMessage ("You are trying to use reaction rate outputs from the material "
+                                           "model to compute the latent heat of melt in an operator splitting solver scheme, "
+                                           "but the material model you use does not actually fill these reaction rate outputs."));
+
+                  // with melt migration the reaction term is a mass reaction rate,
+                  // without melt migration, the reaction term is a rate of change of the compositional field,
+                  // and we have to scale it to the same units to compute the rate of temperature change
+                  melting_rate = reaction_rate_out->reaction_rates[q][porosity_idx];
+
+                  // if operator splitting is used in the model, we want the heating rates due to latent heat of melt
+                  // to be part of the reactions (not the advection) in the operator split, and they are changes
+                  // in temperature rather than changes in energy
+                  heating_model_outputs.rates_of_temperature_change[q] = enthalpy_change
+                                                                         * melting_rate
+                                                                         / material_model_outputs.specific_heat[q];
+                }
+              else if (use_operator_split && reaction_rate_out == nullptr)
+                {
+                  // if operator plit is used, but the reaction rate outputs are not there,
+                  // fill the rates of temperature change with NaNs, so that an error is thrown
+                  // if they are used anywhere
+                  heating_model_outputs.rates_of_temperature_change[q] = std::numeric_limits<double>::quiet_NaN();
+                }
+            }
+        }
+    }
+
+    template <int dim>
+    void
+    LatentHeatMelt<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Latent heat melt");
+        {
+          prm.declare_entry ("Melting entropy change", "-300.",
+                             Patterns::Double (),
+                             "The entropy change for the phase transition "
+                             "from solid to melt. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Retrieve entropy change from material model", "false",
+                             Patterns::Bool (),
+                             "Instead of using the entropy change given in the "
+                             "'Melting entropy change' query the EnthalpyAdditionalOutputs "
+                             "in the material model to compute the entropy change for the "
+                             "phase transition from solid to melt."
+                             "Units: $J/(kg K)$.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    LatentHeatMelt<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Latent heat melt");
+        {
+          melting_entropy_change = prm.get_double ("Melting entropy change");
+          retrieve_entropy_change_from_material_model = prm.get_bool ("Retrieve entropy change from material model");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    LatentHeatMelt<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      if (this->include_melt_transport() && retrieve_entropy_change_from_material_model
+          && outputs.template get_additional_output<MaterialModel::EnthalpyOutputs<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::EnthalpyOutputs<dim>> (outputs.n_evaluation_points()));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(LatentHeatMelt,
+                                  "latent heat melt",
+                                  "Implementation of a standard model for latent heat "
+                                  "of melting. This assumes that there is a compositional field "
+                                  "called porosity, and it uses the reaction term of this field "
+                                  "(the fraction of material that melted in the current time step) "
+                                  "multiplied by a constant entropy change for melting all "
+                                  "of the material as source term of the heating model.\n"
+                                  "If there is no field called porosity, the heating terms are 0.")
+  }
+}
diff --git a/source/heating_model/radioactive_decay.cc.bak b/source/heating_model/radioactive_decay.cc.bak
new file mode 100644
index 00000000000..4fc3403c495
--- /dev/null
+++ b/source/heating_model/radioactive_decay.cc.bak
@@ -0,0 +1,206 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/heating_model/radioactive_decay.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/global.h>
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    RadioactiveDecay<dim>::RadioactiveDecay ()
+      = default;
+
+
+    template <int dim>
+    void
+    RadioactiveDecay<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      if (is_crust_defined_by_composition)
+        {
+          AssertThrow(crust_composition_num < material_model_inputs.composition[0].size(),
+                      ExcMessage("The composition number of crust is larger than number of composition fields."));
+        }
+
+      for (unsigned int q = 0; q < heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          double timedependent_radioactive_heating_rates = 0;
+
+          if (n_radio_heating_elements != 0)
+            {
+              double crust_fraction = 0;
+
+              if (is_crust_defined_by_composition)
+                {
+                  crust_fraction = material_model_inputs.composition[q][crust_composition_num];
+
+                  if (crust_fraction < 0.0)
+                    crust_fraction = 0;
+                  if (crust_fraction > 1.0)
+                    crust_fraction = 1;
+                }
+              else if ((this->get_geometry_model()).depth(material_model_inputs.position[q]) < crust_depth)
+                crust_fraction = 1;
+
+              for (unsigned element = 0; element < n_radio_heating_elements; ++element)
+                {
+                  timedependent_radioactive_heating_rates += radioactive_heating_rates[element]
+                                                             * (radioactive_initial_concentrations_mantle[element] * (1-crust_fraction)
+                                                                + radioactive_initial_concentrations_crust[element] * crust_fraction)
+                                                             * std::pow(0.5,this->get_time()/half_decay_times[element]);
+                }
+            }
+
+          heating_model_outputs.heating_source_terms[q] = timedependent_radioactive_heating_rates
+                                                          * material_model_outputs.densities[q];
+
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+    template <int dim>
+    void
+    RadioactiveDecay<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Radioactive decay");
+        {
+          prm.declare_entry("Number of elements","0",
+                            Patterns::Integer(0),
+                            "Number of radioactive elements");
+          prm.declare_entry("Heating rates","",
+                            Patterns::List (Patterns::Double ()),
+                            "Heating rates of different elements (W/kg)");
+          prm.declare_entry("Half decay times","",
+                            Patterns::List (Patterns::Double (0.)),
+                            "Half decay times. Units: (Seconds), or "
+                            "(Years) if set `use years instead of seconds'.");
+          prm.declare_entry("Initial concentrations crust","",
+                            Patterns::List (Patterns::Double (0.)),
+                            "Initial concentrations of different elements (ppm)");
+          prm.declare_entry("Initial concentrations mantle","",
+                            Patterns::List (Patterns::Double (0.)),
+                            "Initial concentrations of different elements (ppm)");
+          prm.declare_entry("Crust defined by composition","false",
+                            Patterns::Bool(),
+                            "Whether crust defined by composition or depth");
+          prm.declare_entry("Crust depth","0.",
+                            Patterns::Double(),
+                            "Depth of the crust when crust if defined by depth. "
+                            "Units: \\si{\\meter}.");
+          prm.declare_entry("Crust composition number","0",
+                            Patterns::Integer(0),
+                            "Which composition field should be treated as crust");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    RadioactiveDecay<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Radioactive decay");
+        {
+
+          n_radio_heating_elements  = prm.get_integer ("Number of elements");
+
+          radioactive_heating_rates = Utilities::string_to_double
+                                      (Utilities::split_string_list
+                                       (prm.get("Heating rates")));
+
+          half_decay_times          = Utilities::string_to_double
+                                      (Utilities::split_string_list
+                                       (prm.get("Half decay times")));
+
+          radioactive_initial_concentrations_crust  = Utilities::string_to_double
+                                                      (Utilities::split_string_list
+                                                       (prm.get("Initial concentrations crust")));
+
+          radioactive_initial_concentrations_mantle = Utilities::string_to_double
+                                                      (Utilities::split_string_list
+                                                       (prm.get("Initial concentrations mantle")));
+
+          is_crust_defined_by_composition = prm.get_bool    ("Crust defined by composition");
+          crust_depth                     = prm.get_double  ("Crust depth");
+          crust_composition_num           = prm.get_integer ("Crust composition number");
+
+
+          AssertThrow(radioactive_heating_rates.size() == n_radio_heating_elements,
+                      ExcMessage("Number of heating rate entities does not match "
+                                 "the number of radioactive elements."));
+          AssertThrow(half_decay_times.size() == n_radio_heating_elements,
+                      ExcMessage("Number of half decay time entities does not match "
+                                 "the number of radioactive elements."));
+          AssertThrow(radioactive_initial_concentrations_crust.size() == n_radio_heating_elements,
+                      ExcMessage("Number of initial concentration entities in crust "
+                                 "does not match the number of radioactive elements."));
+          AssertThrow(radioactive_initial_concentrations_mantle.size() == n_radio_heating_elements,
+                      ExcMessage("Number of initial concentration entities in mantle "
+                                 "does not match the number of radioactive elements."));
+
+          // if we get half_decay_times passed as years convert it to seconds
+          if (this->convert_output_to_years())
+            for (unsigned int i = 0; i < n_radio_heating_elements; ++i)
+              half_decay_times[i] *= year_in_seconds;
+
+          // Convert ppm to SI concentrations
+          for (unsigned int i = 0; i < n_radio_heating_elements; ++i)
+            {
+              radioactive_initial_concentrations_crust[i] *= 1e-6;
+              radioactive_initial_concentrations_mantle[i] *= 1e-6;
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(RadioactiveDecay,
+                                  "radioactive decay",
+                                  "Implementation of a model in which the internal "
+                                  "heating rate is radioactive decaying in the following rule:\n"
+                                  "\\[(\\text{initial concentration})\\cdot 0.5^{\\text{time}/(\\text{half life})}\\]\n"
+                                  "The crust and mantle can have different concentrations, and the crust can be "
+                                  "defined either by depth or by a certain compositional field.\n"
+                                  "The formula is interpreted as having units W/kg.")
+  }
+}
diff --git a/source/heating_model/shear_heating.cc.bak b/source/heating_model/shear_heating.cc.bak
new file mode 100644
index 00000000000..153ffbfe601
--- /dev/null
+++ b/source/heating_model/shear_heating.cc.bak
@@ -0,0 +1,203 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/heating_model/shear_heating.h>
+
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    ShearHeating<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      // Check if the material model has additional outputs relevant for the shear heating.
+      const ShearHeatingOutputs<dim> *shear_heating_out =
+        material_model_outputs.template get_additional_output<ShearHeatingOutputs<dim>>();
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          const SymmetricTensor<2,dim> deviatoric_strain_rate =
+            (this->get_material_model().is_compressible()
+             ?
+             material_model_inputs.strain_rate[q]
+             - 1./3. * trace(material_model_inputs.strain_rate[q]) * unit_symmetric_tensor<dim>()
+             :
+             material_model_inputs.strain_rate[q]);
+
+          SymmetricTensor<2,dim> stress = 2 * material_model_outputs.viscosities[q] * deviatoric_strain_rate;
+
+          if (limit_stress)
+            {
+              // Compute yield stress.
+              const double pressure = std::max(material_model_inputs.pressure[q], 0.0);
+              const double yield_stress = drucker_prager_plasticity.compute_yield_stress(cohesion,
+                                                                                         friction_angle,
+                                                                                         pressure,
+                                                                                         std::numeric_limits<double>::max());
+
+              // Scale the stress accordingly.
+              const double deviatoric_stress = 2 * material_model_outputs.viscosities[q] * std::sqrt(std::fabs(second_invariant(deviatoric_strain_rate)));
+              double scaling_factor = 1.0;
+              if (deviatoric_stress > 0.0)
+                scaling_factor = std::min(yield_stress / deviatoric_stress, 1.0);
+
+              stress *= scaling_factor;
+            }
+
+          heating_model_outputs.heating_source_terms[q] = stress * deviatoric_strain_rate;
+
+          // If shear heating work fractions are provided, reduce the
+          // overall heating by this amount (which is assumed to be converted into other forms of energy)
+          if (shear_heating_out != nullptr)
+            {
+              heating_model_outputs.heating_source_terms[q] *= shear_heating_out->shear_heating_work_fractions[q];
+            }
+
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+    template <int dim>
+    void
+    ShearHeating<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Shear heating");
+        {
+          prm.declare_entry ("Limit stress contribution to shear heating", "false",
+                             Patterns::Bool (),
+                             "In models with prescribed boundary velocities, stresses can become "
+                             "unrealistically large. Using these large stresses when calculating "
+                             "the amount of shear heating would then lead to an unreasonable "
+                             "increase in temperature. This parameter indicates if the stress being "
+                             "used to compute the amount of shear heating should be limited based on "
+                             "a Drucker-Prager yield criterion with the cohesion given by the "
+                             "'Cohesion for maximum shear stress' parameter and the friction angle "
+                             "given by the 'Friction angle for maximum shear stress' parameter.");
+          prm.declare_entry ("Cohesion for maximum shear stress", "2e7",
+                             Patterns::Double (0),
+                             "Cohesion for maximum shear stress that should be used for the computation "
+                             "of shear heating. It can be useful to limit the shear stress "
+                             "in models where velocities are prescribed, and actual stresses "
+                             "in the Earth would be lower than the stresses introduced by the "
+                             "boundary conditions. Only used if 'Limit stress contribution to shear heating' "
+                             "is true. "
+                             "Units: Pa.");
+          prm.declare_entry ("Friction angle for maximum shear stress", "0",
+                             Patterns::Double (0),
+                             "Friction angle for maximum shear stress that should be used for the computation "
+                             "of shear heating. It can be useful to limit the shear stress "
+                             "in models where velocities are prescribed, and actual stresses "
+                             "in the Earth would be lower than the stresses introduced by the "
+                             "boundary conditions. Only used if 'Limit stress contribution to shear heating' "
+                             "is true. "
+                             "Units: none.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ShearHeating<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Shear heating");
+        {
+          limit_stress = prm.get_bool ("Limit stress contribution to shear heating");
+          cohesion = prm.get_double ("Cohesion for maximum shear stress");
+          friction_angle = prm.get_double ("Friction angle for maximum shear stress");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+
+    template <int dim>
+    void
+    ShearHeating<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const
+    {
+      this->get_material_model().create_additional_named_outputs(material_model_outputs);
+    }
+
+
+
+    template <int dim>
+    ShearHeatingOutputs<dim>::ShearHeatingOutputs (const unsigned int n_points)
+      :
+      MaterialModel::NamedAdditionalMaterialOutputs<dim>({"shear_heating_work_fraction"}),
+                  shear_heating_work_fractions(n_points, numbers::signaling_nan<double>())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    ShearHeatingOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      (void) idx;
+      AssertIndexRange (idx, 1);
+
+      return shear_heating_work_fractions;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(ShearHeating,
+                                  "shear heating",
+                                  "Implementation of a standard model for shear heating. "
+                                  "Adds the term: "
+                                  "$  2 \\eta \\left( \\varepsilon - \\frac{1}{3} \\text{tr} "
+                                  "\\varepsilon \\mathbf 1 \\right) : \\left( \\varepsilon - \\frac{1}{3} "
+                                  "\\text{tr} \\varepsilon \\mathbf 1 \\right)$ to the "
+                                  "right-hand side of the temperature equation.")
+
+#define INSTANTIATE(dim) \
+  template class ShearHeatingOutputs<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/heating_model/shear_heating_with_melt.cc.bak b/source/heating_model/shear_heating_with_melt.cc.bak
new file mode 100644
index 00000000000..9f0dd11a508
--- /dev/null
+++ b/source/heating_model/shear_heating_with_melt.cc.bak
@@ -0,0 +1,122 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/heating_model/shear_heating_with_melt.h>
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+#include <deal.II/numerics/fe_field_function.h>
+
+
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    template <int dim>
+    void
+    ShearHeatingMelt<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      Assert(this->introspection().compositional_name_exists("porosity"),
+             ExcMessage("Heating model shear heating with melt only works if there "
+                        "is a compositional field called porosity."));
+
+      // get the melt velocity
+      const MaterialModel::MeltInputs<dim> *melt_in = material_model_inputs.template get_additional_input<MaterialModel::MeltInputs<dim>>();
+      AssertThrow(melt_in != nullptr,
+                  ExcMessage ("Need MeltInputs from the material model for shear heating with melt!"));
+
+      bool is_melt_cell = false;
+      if (material_model_inputs.current_cell.state() == IteratorState::valid)
+        is_melt_cell = this->get_melt_handler().is_melt_cell(material_model_inputs.current_cell);
+
+      const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+      Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for shear heating with melt."));
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          const double porosity = material_model_inputs.composition[q][this->introspection().compositional_index_for_name("porosity")];
+
+          if (is_melt_cell)
+            heating_model_outputs.heating_source_terms[q] = melt_outputs->compaction_viscosities[q]
+                                                            * pow(trace(material_model_inputs.strain_rate[q]),2)
+                                                            +
+                                                            (melt_outputs->permeabilities[q] > 0
+                                                             ?
+                                                             melt_outputs->fluid_viscosities[q] * porosity * porosity
+                                                             / melt_outputs->permeabilities[q]
+                                                             * (melt_in->fluid_velocities[q] - material_model_inputs.velocity[q])
+                                                             * (melt_in->fluid_velocities[q] - material_model_inputs.velocity[q])
+                                                             :
+                                                             0.0);
+          else
+            heating_model_outputs.heating_source_terms[q] = 0.0;
+
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+
+    template <int dim>
+    void
+    ShearHeatingMelt<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output) const
+    {
+      MeltHandler<dim>::create_material_model_outputs(output);
+    }
+
+
+
+    template <int dim>
+    void
+    ShearHeatingMelt<dim>::
+    create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &inputs) const
+    {
+      // we need the melt inputs for this shear heating of melt
+      if (inputs.template get_additional_input<MaterialModel::MeltInputs<dim>>() == nullptr)
+        inputs.additional_inputs.emplace_back(
+          std::make_unique<MaterialModel::MeltInputs<dim>> (inputs.n_evaluation_points()));
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(ShearHeatingMelt,
+                                  "shear heating with melt",
+                                  "Implementation of a standard model for shear heating "
+                                  "of migrating melt, including bulk (compression) heating "
+                                  "$\\xi \\left( \\nabla \\cdot \\mathbf u_s \\right)^2 $ "
+                                  "and heating due to melt segregation "
+                                  "$\\frac{\\eta_f \\phi^2}{k} \\left( \\mathbf u_f - \\mathbf u_s \\right)^2 $. "
+                                  "For full shear heating, "
+                                  "this has to be used in combination with the heating model "
+                                  "shear heating to also include shear heating for "
+                                  "the solid part.")
+  }
+}
diff --git a/source/initial_composition/adiabatic_density.cc.bak b/source/initial_composition/adiabatic_density.cc.bak
new file mode 100644
index 00000000000..64c3af31dc5
--- /dev/null
+++ b/source/initial_composition/adiabatic_density.cc.bak
@@ -0,0 +1,54 @@
+/*
+  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_composition/adiabatic_density.h>
+
+#include <aspect/adiabatic_conditions/interface.h>
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    template <int dim>
+    double
+    AdiabaticDensity<dim>::
+    initial_composition (const Point<dim> &position, const unsigned int n_comp) const
+    {
+      if (n_comp == this->introspection().find_composition_type(CompositionalFieldDescription::density))
+        return this->get_adiabatic_conditions().density(position);
+
+      return 0.0;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(AdiabaticDensity,
+                                              "adiabatic density",
+                                              "Specify the initial composition as the adiabatic reference density at "
+                                              "each position. Note that only the field of the type 'density' "
+                                              "will be filled. For all other fields this plugin returns 0.0.")
+  }
+}
diff --git a/source/initial_composition/ascii_data.cc.bak b/source/initial_composition/ascii_data.cc.bak
new file mode 100644
index 00000000000..49448b30dfd
--- /dev/null
+++ b/source/initial_composition/ascii_data.cc.bak
@@ -0,0 +1,118 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/initial_composition/ascii_data.h>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      ascii_data_initial->initialize(this->n_compositional_fields());
+    }
+
+
+    template <int dim>
+    double
+    AsciiData<dim>::
+    initial_composition (const Point<dim> &position,
+                         const unsigned int n_comp) const
+    {
+      return ascii_data_initial->get_data_component(position,n_comp);
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        Utilities::AsciiDataInitial<dim>::declare_parameters(prm,
+                                                             "$ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/",
+                                                             "box_2d.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        ascii_data_initial = std::make_unique<Utilities::AsciiDataInitial<dim>>();
+        ascii_data_initial->initialize_simulator(this->get_simulator());
+        ascii_data_initial->parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(AsciiData,
+                                              "ascii data",
+                                              "Implementation of a model in which the initial "
+                                              "composition is derived from files containing data "
+                                              "in ascii format. Note the required format of the "
+                                              "input data: The first lines may contain any number of comments "
+                                              "if they begin with `#', but one of these lines needs to "
+                                              "contain the number of grid points in each dimension as "
+                                              "for example `# POINTS: 3 3'. "
+                                              "The order of the data columns "
+                                              "has to be `x', `y', `composition1', `composition2', "
+                                              "etc. in a 2d model and `x', `y', `z', `composition1', "
+                                              "`composition2', etc. in a 3d model, according "
+                                              "to the number of compositional fields, which means that "
+                                              "there has to be a single column "
+                                              "for every composition in the model."
+                                              "Note that the data in the input "
+                                              "files need to be sorted in a specific order: "
+                                              "the first coordinate needs to ascend first, "
+                                              "followed by the second and the third at last in order to "
+                                              "assign the correct data to the prescribed coordinates. "
+                                              "If you use a spherical model, "
+                                              "then the assumed grid changes. `x' will be replaced by "
+                                              "the radial distance of the point to the bottom of the model, "
+                                              "`y' by the azimuth angle and `z' by the polar angle measured "
+                                              "positive from the north pole. The grid will be assumed to be "
+                                              "a latitude-longitude grid. Note that the order "
+                                              "of spherical coordinates is `r', `phi', `theta' "
+                                              "and not `r', `theta', `phi', since this allows "
+                                              "for dimension independent expressions.")
+  }
+}
diff --git a/source/initial_composition/ascii_data_layered.cc.bak b/source/initial_composition/ascii_data_layered.cc.bak
new file mode 100644
index 00000000000..6834f403f1a
--- /dev/null
+++ b/source/initial_composition/ascii_data_layered.cc.bak
@@ -0,0 +1,123 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/initial_composition/ascii_data_layered.h>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    template <int dim>
+    AsciiDataLayered<dim>::AsciiDataLayered ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiDataLayered<dim>::initialize ()
+    {
+      // First additional field is the layer depth, so we need one additional non-compositional field
+      Utilities::AsciiDataLayered<dim>::initialize(this->n_compositional_fields() + 1);
+    }
+
+
+    template <int dim>
+    double
+    AsciiDataLayered<dim>::
+    initial_composition (const Point<dim> &position,
+                         const unsigned int n_comp) const
+    {
+
+      // First additional field is the layer depth, so we need the data component from the n_comp+1th column
+      return Utilities::AsciiDataLayered<dim>::get_data_component(position,n_comp + 1);
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataLayered<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        Utilities::AsciiDataLayered<dim>::declare_parameters(prm,
+                                                             "$ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/",
+                                                             "initial_composition_top_mantle_box_3d.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataLayered<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        Utilities::AsciiDataLayered<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(AsciiDataLayered,
+                                              "ascii data layered",
+                                              "Implementation of a model in which the initial "
+                                              "composition is derived from files containing data "
+                                              "in ascii format. Each file defines a surface on which "
+                                              "compositional fields are defined. "
+                                              "Between the surfaces, the fields can be chosen to be "
+                                              "constant (with a value defined by the nearest shallower "
+                                              "surface), or linearly interpolated between surfaces. "
+                                              "Note the required format of the input ascii data file: "
+                                              "The first lines may contain any number of comments "
+                                              "if they begin with `#', but one of these lines needs to "
+                                              "contain the number of grid points in each dimension as "
+                                              "for example `# POINTS: 3 3'. "
+                                              "The order of the data columns "
+                                              "has to be `x', `y', `composition1', `composition2' etc. "
+                                              "in a 2d model and `x', `y', `z', `composition1', "
+                                              "`composition2' etc. in a 3d model; i.e. "
+                                              "the columns before the compositional field always contains "
+                                              "the position of the surface along the vertical direction. "
+                                              "The first column needs to ascend first, "
+                                              "followed by the second in order to assign the correct data "
+                                              "to the prescribed coordinates. If you use a spherical model, "
+                                              "then the assumed grid changes. `x' will be replaced by the "
+                                              "azimuth angle and `y' (if 3d) by the polar angle measured "
+                                              "positive from the north pole. The last column will be the "
+                                              "distance of the point from the origin "
+                                              "(i.e. radial position). The grid in this case will be "
+                                              "a latitude-longitude grid. Note that the order "
+                                              "of spherical coordinates in 3d is `phi', `theta', `r', `T'"
+                                              "and not `theta', `phi', `r', `T' as this is "
+                                              "more consistent with other ASPECT plugins. Outside of the "
+                                              "region defined by the grid, the plugin will use the value "
+                                              "at the edge of the region.")
+  }
+}
diff --git a/source/initial_composition/entropy_table_lookup.cc.bak b/source/initial_composition/entropy_table_lookup.cc.bak
new file mode 100644
index 00000000000..b388942cf44
--- /dev/null
+++ b/source/initial_composition/entropy_table_lookup.cc.bak
@@ -0,0 +1,138 @@
+/*
+  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_composition/entropy_table_lookup.h>
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    template <int dim>
+    void
+    EntropyTableLookUp<dim>::initialize()
+    {
+      AssertThrow (this->introspection().compositional_name_exists("entropy"),
+                   ExcMessage("The 'entropy table lookup' initial composition requires the existence of a compositional field "
+                              "named 'entropy'. This field does not exist."));
+
+      // Make sure we keep track of the initial temperature manager and
+      // that it continues to live beyond the time when the simulator
+      // class releases its pointer to it.
+      initial_temperature_manager = this->get_initial_temperature_manager_pointer();
+
+      // Make sure we keep track of the initial composition manager and
+      // that it continues to live beyond the time when the simulator
+      // class releases its pointer to it.
+      initial_composition_manager = this->get_initial_composition_manager_pointer();
+
+      entropy_index = this->introspection().compositional_index_for_name("entropy");
+
+      material_lookup = std::make_unique<Utilities::StructuredDataLookup<2>>(7,1.0);
+      material_lookup->load_file(data_directory+material_file_name,
+                                 this->get_mpi_communicator());
+    }
+
+
+    template <int dim>
+    double
+    EntropyTableLookUp<dim>::
+    initial_composition (const Point<dim> &position,
+                         const unsigned int compositional_index) const
+    {
+      if (compositional_index == entropy_index)
+        {
+          const double temperature = initial_temperature_manager->initial_temperature(position);
+          const double pressure = this->get_adiabatic_conditions().pressure(position);
+
+          // Convert pressure from Pa to bar, bar is used in the table.
+          Point<2> temperature_pressure(temperature, pressure / 1.e5);
+
+          const double entropy = material_lookup->get_data(temperature_pressure, 0);
+
+          return entropy;
+        }
+      return 0.0;
+    }
+
+    template <int dim>
+    void
+    EntropyTableLookUp<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Entropy table lookup");
+        {
+          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/",
+                             Patterns::DirectoryName (),
+                             "The path to the model data. The path may also include the special "
+                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                             "in which the ASPECT source files were located when ASPECT was "
+                             "compiled. This interpretation allows, for example, to reference "
+                             "files located in the `data/' subdirectory of ASPECT.");
+          prm.declare_entry ("Material file name", "material_table_temperature_pressure.txt",
+                             Patterns::List (Patterns::Anything()),
+                             "The file name of the material data.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    EntropyTableLookUp<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Entropy table lookup");
+        {
+          data_directory              = Utilities::expand_ASPECT_SOURCE_DIR(prm.get("Data directory"));
+          material_file_name          = prm.get("Material file name");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(EntropyTableLookUp,
+                                              "entropy table lookup",
+                                              "A class that implements initial conditions for the entropy field "
+                                              "by converting the initial temperature field through a look up table. "
+                                              "Note that this plugin only works if there is a compositional field "
+                                              "called `entropy', and an additional look up table that can convert "
+                                              "pressure and temperature to entropy. "
+                                              "For all compositional fields except entropy this plugin returns 0.0, "
+                                              "and they are therefore not changed as long as the default `add' "
+                                              "operator is selected for this plugin.")
+  }
+}
diff --git a/source/initial_composition/function.cc.bak b/source/initial_composition/function.cc.bak
new file mode 100644
index 00000000000..731a0ecd80c
--- /dev/null
+++ b/source/initial_composition/function.cc.bak
@@ -0,0 +1,125 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_composition/function.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+
+    template <int dim>
+    double
+    Function<dim>::
+    initial_composition (const Point<dim> &position, const unsigned int n_comp) const
+    {
+      const Utilities::NaturalCoordinate<dim> point =
+        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
+
+      return function->value(Utilities::convert_array_to_point<dim>(point.get_coordinates()),n_comp);
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Function");
+        {
+          /**
+           * Choose the coordinates to evaluate the maximum refinement level
+           * function. The function can be declared in dependence of depth,
+           * cartesian coordinates or spherical coordinates. Note that the order
+           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
+           * this allows for dimension independent expressions.
+           */
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle. `depth' "
+                             "will create a function, in which only the first "
+                             "parameter is non-zero, which is interpreted to "
+                             "be the depth of the point.");
+
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("Function");
+        {
+          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+        }
+
+        try
+          {
+            function
+              = std::make_unique<Functions::ParsedFunction<dim>>(this->n_compositional_fields());
+            function->parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Initial composition model.Function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'\n"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(Function,
+                                              "function",
+                                              "Specify the composition in terms of an explicit formula. The format of these "
+                                              "functions follows the syntax understood by the "
+                                              "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+  }
+}
diff --git a/source/initial_composition/interface.cc.bak b/source/initial_composition/interface.cc.bak
new file mode 100644
index 00000000000..cf2a64b8e42
--- /dev/null
+++ b/source/initial_composition/interface.cc.bak
@@ -0,0 +1,275 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/initial_composition/interface.h>
+
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    // ------------------------------ Manager -----------------------------
+    // ------------------------------ Deal with registering initial composition models and automating
+    // ------------------------------ their setup and selection at run time
+
+    template <int dim>
+    Manager<dim>::~Manager()
+      = default;
+
+
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_initial_composition (const std::string &name,
+                                                const std::string &description,
+                                                void (*declare_parameters_function) (ParameterHandler &),
+                                                std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // find out which plugins are requested and the various other
+      // parameters we declare here
+      prm.enter_subsection ("Initial composition model");
+      {
+        model_names
+          = Utilities::split_string_list(prm.get("List of model names"));
+
+        AssertThrow(Utilities::has_unique_entries(model_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Initial composition model/List of model names' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+
+        const std::string model_name = prm.get ("Model name");
+
+        AssertThrow (model_name == "unspecified" || model_names.size() == 0,
+                     ExcMessage ("The parameter 'Model name' is only used for reasons"
+                                 "of backwards compatibility and can not be used together with "
+                                 "the new functionality 'List of model names'. Please add your "
+                                 "initial composition model to the list instead."));
+
+        if (!(model_name == "unspecified"))
+          model_names.push_back(model_name);
+
+        // create operator list
+        const std::vector<std::string> model_operator_names =
+          Utilities::possibly_extend_from_1_to_N (Utilities::split_string_list(prm.get("List of model operators")),
+                                                  model_names.size(),
+                                                  "List of model operators");
+        model_operators = Utilities::create_model_operator_list(model_operator_names);
+
+      }
+      prm.leave_subsection ();
+
+      if (model_names.size() > 0)
+        AssertThrow(this->n_compositional_fields() > 0,
+                    ExcMessage("A plugin for the initial composition condition was specified, but there "
+                               "is no compositional field. This can lead to errors within the initialization of "
+                               "the initial composition plugin and is therefore not supported. Please remove "
+                               "the initial composition plugin or add a compositional field."));
+
+      // go through the list, create objects and let them parse
+      // their own parameters
+      for (const auto &model_name : model_names)
+        {
+          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
+                                          (std::get<dim>(registered_plugins)
+                                           .create_plugin (model_name,
+                                                           "Initial composition model::Model names")));
+
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
+            sim->initialize_simulator (this->get_simulator());
+
+          this->plugin_objects.back()->parse_parameters (prm);
+          this->plugin_objects.back()->initialize ();
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::update()
+    {
+      for (auto &initial_composition_object : this->plugin_objects)
+        initial_composition_object->update();
+    }
+
+
+
+    template <int dim>
+    double
+    Manager<dim>::initial_composition (const Point<dim> &position,
+                                       const unsigned int n_comp) const
+    {
+      double composition = 0.0;
+      int i = 0;
+
+      for (const auto &initial_composition_object : this->plugin_objects)
+        {
+          composition = model_operators[i](composition,
+                                           initial_composition_object->initial_composition(position,n_comp));
+          ++i;
+        }
+
+      return composition;
+    }
+
+
+    template <int dim>
+    const std::vector<std::string> &
+    Manager<dim>::get_active_initial_composition_names () const
+    {
+      return model_names;
+    }
+
+
+    template <int dim>
+    const std::list<std::unique_ptr<Interface<dim>>> &
+    Manager<dim>::get_active_initial_composition_conditions () const
+    {
+      return this->plugin_objects;
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // declare the entry in the parameter file
+      prm.enter_subsection ("Initial composition model");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry("List of model names",
+                          "",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma-separated list of initial composition models that "
+                          "together describe the initial composition field. "
+                          "These plugins are loaded in the order given, and modify the "
+                          "existing composition field via the operators listed "
+                          "in 'List of model operators'.\n\n"
+                          "The following composition models are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+
+        prm.declare_entry("List of model operators", "add",
+                          Patterns::MultipleSelection(Utilities::get_model_operator_options()),
+                          "A comma-separated list of operators that "
+                          "will be used to append the listed composition models onto "
+                          "the previous models. If only one operator is given, "
+                          "the same operator is applied to all models.");
+
+        prm.declare_entry ("Model name", "unspecified",
+                           Patterns::Selection (pattern_of_names+"|unspecified"),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string()
+                           + "\n\n" +
+                           "\\textbf{Warning}: This parameter provides an old and "
+                           "deprecated way of specifying "
+                           "initial composition models and shouldn't be used. "
+                           "Please use 'List of model names' instead.");
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ()
+    {
+      return std::get<dim>(registered_plugins).get_pattern_of_names ();
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Initial composition interface",
+                                                            out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<InitialComposition::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<InitialComposition::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<InitialComposition::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<InitialComposition::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace InitialComposition
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>; \
+  \
+  template \
+  std::string \
+  get_valid_model_names_pattern<dim> ();
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/initial_composition/porosity.cc.bak b/source/initial_composition/porosity.cc.bak
new file mode 100644
index 00000000000..566e1d497e1
--- /dev/null
+++ b/source/initial_composition/porosity.cc.bak
@@ -0,0 +1,116 @@
+/*
+  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_composition/porosity.h>
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/melt.h>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    template <int dim>
+    void
+    Porosity<dim>::initialize()
+    {
+      // Make sure we keep track of the initial temperature manager and
+      // that it continues to live beyond the time when the simulator
+      // class releases its pointer to it.
+      initial_temperature_manager = this->get_initial_temperature_manager_pointer();
+
+      // Make sure we keep track of the initial composition manager and
+      // that it continues to live beyond the time when the simulator
+      // class releases its pointer to it.
+      initial_composition_manager = this->get_initial_composition_manager_pointer();
+    }
+
+
+
+    template <int dim>
+    double
+    Porosity<dim>::
+    initial_composition (const Point<dim> &position,
+                         const unsigned int compositional_index) const
+    {
+      AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                  ExcMessage("The initial composition plugin `porosity' did not find a "
+                             "compositional field called `porosity' to initialize. Please add a "
+                             "compositional field with this name."));
+
+      AssertThrow(MaterialModel::MeltFractionModel<dim>::is_melt_fraction_model(this->get_material_model()),
+                  ExcMessage("The used material model is not derived from the 'MeltFractionModel' class, "
+                             "and therefore does not support computing equilibrium melt fractions. "
+                             "This is incompatible with the `porosity' "
+                             "initial composition plugin, which needs to compute these melt fractions."));
+
+      const unsigned int porosity_index = this->introspection().compositional_index_for_name("porosity");
+      if (compositional_index == porosity_index)
+        {
+          MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
+
+          in.position[0] = position;
+          in.temperature[0] = initial_temperature_manager->initial_temperature(position);
+          in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
+          in.pressure_gradient[0] = 0.0;
+          in.velocity[0] = 0.0;
+
+          // Use the initial composition, except for the porosity, to prevent
+          // infinite recursion
+          for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
+            if (i != porosity_index)
+              in.composition[0][i] = initial_composition_manager->initial_composition(position,i);
+            else
+              in.composition[0][i] = 0.0;
+
+          in.strain_rate[0] = SymmetricTensor<2,dim>();
+
+          std::vector<double> melt_fraction(1);
+
+          MaterialModel::MeltFractionModel<dim>::as_melt_fraction_model(this->get_material_model())
+          .melt_fractions(in, melt_fraction);
+
+          return melt_fraction[0];
+        }
+      return 0.0;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(Porosity,
+                                              "porosity",
+                                              "A class that implements initial conditions for the porosity field "
+                                              "by computing the equilibrium melt fraction for the given initial "
+                                              "condition and reference pressure profile. Note that this plugin only "
+                                              "works if there is a compositional field called `porosity', and the "
+                                              "used material model implements the 'MeltFractionModel' interface. "
+                                              "For all compositional fields except porosity this plugin returns 0.0, "
+                                              "and they are therefore not changed as long as the default `add' "
+                                              "operator is selected for this plugin.")
+  }
+}
diff --git a/source/initial_composition/slab_model.cc.bak b/source/initial_composition/slab_model.cc.bak
new file mode 100644
index 00000000000..e3a6e8cf0dd
--- /dev/null
+++ b/source/initial_composition/slab_model.cc.bak
@@ -0,0 +1,147 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/initial_composition/slab_model.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    template <int dim>
+    void
+    SlabModel<dim>::initialize ()
+    {
+      AssertThrow(this->introspection().compositional_name_exists("slabs"),
+                  ExcMessage("The initial composition plugin `slab model' did not find a "
+                             "compositional field called `slabs' to initialize. Please add a "
+                             "compositional field with this name."));
+
+      slab_index = this->introspection().compositional_index_for_name("slabs");
+
+      // The input slabs are defined from the surface of the model
+      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+      // The two columns correspond to slabs depth and thickness
+      slab_boundary.initialize({surface_boundary_id}, 2);
+    }
+
+
+    template <int dim>
+    double
+    SlabModel<dim>::
+    initial_composition (const Point<dim> &position,
+                         const unsigned int compositional_index) const
+    {
+      if (compositional_index != slab_index)
+        return 0.0;
+
+      // The first data column corresponds to the slab depth and the second column to the slab thickness.
+      // 'Slab depth' stands for the depth of the upper surface of the slab, 'Slab thickness'
+      // for the vertical distance between upper and lower surface.
+      const double slab_depth     = slab_boundary.get_data_component(surface_boundary_id, position, 0);
+      const double slab_thickness = slab_boundary.get_data_component(surface_boundary_id, position, 1);
+
+      // Return 0.0 if there is no slab in this location in the data. No slab is encoded in
+      // the data file as a slab thickness of 0.0 and/or a depth larger than the depth of
+      // the domain.
+      if (slab_thickness == 0.0 ||
+          slab_depth > this->get_geometry_model().maximal_depth())
+        return 0.0;
+
+      // Return 1.0 if we are inside the depth range of the slab.
+      // We use a semi-closed interval so that a slab thickness of 0.0
+      // means no slab exists.
+      const double depth = this->get_geometry_model().depth(position);
+      if ((depth >= slab_depth) && (depth < slab_depth + slab_thickness))
+        return 1.0;
+
+      return 0.0;
+    }
+
+
+    template <int dim>
+    const Utilities::AsciiDataBoundary<dim> &
+    SlabModel<dim>::get_slab_boundary () const
+    {
+      return slab_boundary;
+    }
+
+
+    template <int dim>
+    void
+    SlabModel<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
+                                                              "$ASPECT_SOURCE_DIR/data/initial-composition/slab-model/",
+                                                              "shell_3d.txt",
+                                                              "Slab model",
+                                                              /*time dependent = */ false);
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    SlabModel<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        slab_boundary.initialize_simulator (this->get_simulator());
+        slab_boundary.parse_parameters(prm, "Slab model", /*time dependent = */ false);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(SlabModel,
+                                              "slab model",
+                                              "An initial composition model that implements subducted "
+                                              "slab geometries as a compositional field determined from "
+                                              "an input file. The file defines the depth to the top of "
+                                              "the slab and the slab thickness. "
+                                              "The computed compositional value is 1 within the slabs "
+                                              "and zero elsewhere. "
+                                              "An example model that is included is Slab2 described in "
+                                              "Hayes, G. P., Moore, G. L., Portner, D. E., Hearne, M., "
+                                              "Flamme, H., Furtney, M., \\& Smoczyk, G. M. (2018). Slab2, "
+                                              "a comprehensive subduction zone geometry model. Science, "
+                                              "362(6410), 58-61. The script to convert the Slab2 model "
+                                              "into an aspect input data file is available in the directory "
+                                              "data/initial-composition/slab-model/. Please note that "
+                                              "Slab2 and the example data file assume spherical geometry "
+                                              "(latitude, longitude coordinates), however, that is not "
+                                              "necessary for this plugin, data files in "
+                                              "Cartesian coordinates will work with box geometries.")
+  }
+}
diff --git a/source/initial_composition/world_builder.cc.bak b/source/initial_composition/world_builder.cc.bak
new file mode 100644
index 00000000000..16695d0841f
--- /dev/null
+++ b/source/initial_composition/world_builder.cc.bak
@@ -0,0 +1,136 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/global.h>
+
+#ifdef ASPECT_WITH_WORLD_BUILDER
+#include <aspect/initial_composition/world_builder.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/citation_info.h>
+
+#include <world_builder/world.h>
+
+
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    template <int dim>
+    void
+    WorldBuilder<dim>::
+    initialize()
+    {
+      CitationInfo::add("GWB");
+      world_builder = this->get_world_builder_pointer();
+    }
+
+
+
+    template <int dim>
+    double
+    WorldBuilder<dim>::
+    initial_composition (const Point<dim> &position, const unsigned int n_comp) const
+    {
+      if (relevant_compositions[n_comp] == true)
+        return world_builder->composition(Utilities::convert_point_to_array(position),
+                                          -this->get_geometry_model().height_above_reference_surface(position),
+                                          n_comp);
+
+      return 0.0;
+    }
+
+
+
+    template <int dim>
+    void
+    WorldBuilder<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("World builder");
+        {
+          prm.declare_entry ("List of relevant compositions", "",
+                             Patterns::Anything(),
+                             "A list of names of compositional fields for "
+                             "which to determine the initial composition using "
+                             "the World Builder. As World Builder evaluations can "
+                             "be expensive, this parameter allows to only evaluate "
+                             "the fields that are relevant. This plugin returns 0.0 "
+                             "for all compositions that are not selected in the list. "
+                             "By default the list is empty and the world builder is "
+                             "evaluated for all compositional fields.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    WorldBuilder<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial composition model");
+      {
+        prm.enter_subsection("World builder");
+        {
+          const std::vector<std::string> composition_names = Utilities::split_string_list(prm.get("List of relevant compositions"));
+
+          relevant_compositions.resize(this->n_compositional_fields(),false);
+
+          if (composition_names.size() == 0)
+            for (unsigned int i=0; i<this->n_compositional_fields(); ++i)
+              relevant_compositions[i] = true;
+
+          for (const auto &composition_name: composition_names)
+            {
+              AssertThrow(this->introspection().compositional_name_exists (composition_name),
+                          ExcMessage("All fields in \"List of relevant compositions\" must match names of compositional "
+                                     "fields as assigned in the \"Compositional fields/Names of fields\" parameter."));
+
+              relevant_compositions[this->introspection().compositional_index_for_name(composition_name)] = true;
+            }
+        }
+
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialComposition
+  {
+    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(WorldBuilder,
+                                              "world builder",
+                                              "Specify the initial composition through the World Builder. "
+                                              "More information on the World Builder can be found at "
+                                              "\\url{https://geodynamicworldbuilder.github.io}. "
+                                              "Make sure to specify the location of the World Builder file "
+                                              "in the parameter 'World builder file'. It is possible to use "
+                                              "the World Builder only for selected compositional fields by "
+                                              "specifying the parameter 'List of relevant compositions'.")
+  }
+}
+#endif
diff --git a/source/initial_temperature/S40RTS_perturbation.cc.bak b/source/initial_temperature/S40RTS_perturbation.cc.bak
new file mode 100644
index 00000000000..013c2d83be1
--- /dev/null
+++ b/source/initial_temperature/S40RTS_perturbation.cc.bak
@@ -0,0 +1,530 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/S40RTS_perturbation.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+#include <aspect/initial_composition/interface.h>
+#include <aspect/material_model/interface.h>
+#include <array>
+
+#include <boost/lexical_cast.hpp>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    namespace internal
+    {
+      namespace S40RTS
+      {
+        // Read in the spherical harmonics that are located in data/initial-temperature/S40RTS
+        // and were downloaded from http://www.earth.lsa.umich.edu/~jritsema/research.html
+        // Ritsema et al. choose real sine and cosine coefficients that follow the normalization
+        // by Dahlen & Tromp, Theoretical Global Seismology (equations B.58 and B.99).
+
+        // NOTE: There is a factor of sqrt(2) difference between the standard orthonormalized
+        // spherical harmonics used by Dahlen & Tromp and that used for S40RTS (see PR # 966).
+        // This might need adjusting if this code is used to read in spherical harmonic
+        // based tomography models that aren't S40RTS or S20RTS.
+
+        SphericalHarmonicsLookup::
+        SphericalHarmonicsLookup(const std::string &filename,
+                                 const MPI_Comm comm)
+        {
+          std::string temp;
+          // Read data from disk and distribute among processes
+          std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
+
+          in >> order;
+          std::getline(in,temp);  // throw away the rest of the line
+
+          const unsigned int num_splines = 21;
+          const unsigned int maxnumber = num_splines * (order+1)*(order+1);
+
+          // read in all coefficients as a single data vector
+          std::vector<double> coeffs(maxnumber,0.0);
+
+          for (unsigned int i=0; i<maxnumber; ++i)
+            {
+              in >> coeffs[i];
+            }
+
+          // reorder the coefficients into sin and cos coefficients. a_lm will be the cos coefficients
+          // and b_lm the sin coefficients.
+          unsigned int ind = 0;
+
+          a_lm.reserve(maxnumber);
+          b_lm.reserve(maxnumber);
+          for (unsigned int j=0; j<num_splines; ++j)
+            for (unsigned int i=0; i<order+1; ++i)
+              {
+                a_lm.push_back(coeffs[ind]);
+                b_lm.push_back(0.0);
+                ++ind;
+
+                unsigned int ind_degree = 0;
+                while (ind_degree < i)
+                  {
+                    a_lm.push_back(coeffs[ind]);
+                    ++ind;
+                    b_lm.push_back(coeffs[ind]);
+                    ++ind;
+                    ++ind_degree;
+                  }
+              }
+        }
+
+        // Declare a function that returns the cosine coefficients
+        const std::vector<double> &
+        SphericalHarmonicsLookup::cos_coeffs() const
+        {
+          return a_lm;
+        }
+
+        // Declare a function that returns the sine coefficients
+        const std::vector<double> &
+        SphericalHarmonicsLookup::sin_coeffs() const
+        {
+          return b_lm;
+        }
+
+        unsigned int
+        SphericalHarmonicsLookup::maxdegree() const
+        {
+          return order;
+        }
+
+        // Read in the knot points for the spline interpolation. They are located in data/
+        // initial-temperature/S40RTS and were taken from the plotting script
+        // lib/libS20/splhsetup.f which is part of the plotting package downloadable at
+        // http://www.earth.lsa.umich.edu/~jritsema/research.html
+        SplineDepthsLookup::SplineDepthsLookup(const std::string &filename,
+                                               const MPI_Comm comm)
+        {
+          std::string temp;
+          // Read data from disk and distribute among processes
+          std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
+
+          std::getline(in,temp);  // throw away the rest of the line
+          std::getline(in,temp);  // throw away the rest of the line
+
+          // This is fixed for this tomography model
+          const unsigned int num_splines = 21;
+
+          depths.resize(num_splines);
+          for (unsigned int i=0; i<num_splines; ++i)
+            {
+              in >> depths[i];
+            }
+        }
+
+        const std::vector<double> &
+        SplineDepthsLookup::spline_depths() const
+        {
+          return depths;
+        }
+      }
+    }
+
+
+    template <int dim>
+    S40RTSPerturbation<dim>::S40RTSPerturbation()
+      :
+      vs_to_density_index(numbers::invalid_unsigned_int)
+    {}
+
+    template <int dim>
+    void
+    S40RTSPerturbation<dim>::initialize()
+    {
+      spherical_harmonics_lookup
+        = std::make_unique<internal::S40RTS::SphericalHarmonicsLookup>(data_directory+harmonics_coeffs_file_name,
+                                                                       this->get_mpi_communicator());
+      spline_depths_lookup
+        = std::make_unique<internal::S40RTS::SplineDepthsLookup>(data_directory+spline_depth_file_name,
+                                                                 this->get_mpi_communicator());
+
+      if (vs_to_density_method == file)
+        {
+          profile.initialize(this->get_mpi_communicator());
+          vs_to_density_index = profile.get_column_index_from_name("vs_to_density");
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    S40RTSPerturbation<dim>::
+    get_Vs (const Point<dim> &position) const
+    {
+      // get the max degree from the input data file (20 or 40)
+      const unsigned int max_degree_data_file = spherical_harmonics_lookup->maxdegree();
+
+      // set the max degree used for the calculation to the max degree from the input data file as default
+      unsigned int max_degree_to_use = max_degree_data_file;
+
+      // lower the maximum degree of the calculation if needed
+      if (lower_max_degree)
+        {
+          AssertThrow(specified_max_degree <= max_degree_data_file, ExcMessage("Specifying a maximum degree higher than the degree of spherical harmonic data is not allowed"));
+          max_degree_to_use = specified_max_degree;
+        }
+
+      // This tomography model is parameterized by 21 layers
+      const unsigned int num_spline_knots = 21;
+
+      // get the spherical harmonics coefficients
+      const std::vector<double> &a_lm = spherical_harmonics_lookup->cos_coeffs();
+      const std::vector<double> &b_lm = spherical_harmonics_lookup->sin_coeffs();
+
+      // get spline knots and rescale them from [-1 1] to [CMB Moho]
+      const std::vector<double> &r = spline_depths_lookup->spline_depths();
+      const double rmoho = 6346e3;
+      const double rcmb = 3480e3;
+      std::vector<double> depth_values(num_spline_knots, 0);
+
+      for (unsigned int i = 0; i<num_spline_knots; ++i)
+        depth_values[i] = rcmb+(rmoho-rcmb)*0.5*(r[i]+1.);
+
+      // convert coordinates from [x,y,z] to [r, phi, theta]
+      std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
+
+      // Evaluate the spherical harmonics at this position. Since they are the
+      // same for all depth splines, do it once to avoid multiple evaluations.
+      // NOTE: there is apparently a factor of sqrt(2) difference
+      // between the standard orthonormalized spherical harmonics
+      // and those used for S40RTS (see PR # 966)
+      std::vector<std::vector<double>> cosine_components(max_degree_to_use+1, std::vector<double>(max_degree_to_use+1, 0.0));
+      std::vector<std::vector<double>> sine_components(max_degree_to_use+1, std::vector<double>(max_degree_to_use+1, 0.0));
+
+      for (unsigned int degree_l = 0; degree_l < max_degree_to_use+1; ++degree_l)
+        {
+          for (unsigned int order_m = 0; order_m < degree_l+1; ++order_m)
+            {
+              const double phi = scoord[1];
+              const double theta = (dim == 3) ? scoord[2] : numbers::PI_2;
+              const std::pair<double,double> sph_harm_vals =
+                Utilities::real_spherical_harmonic(degree_l, order_m, theta, phi);
+
+              cosine_components[degree_l][order_m] = sph_harm_vals.first;
+              sine_components[degree_l][order_m] = sph_harm_vals.second;
+            }
+        }
+
+      // iterate over all degrees and orders at each depth and sum them all up.
+      std::vector<double> spline_values(num_spline_knots, 0.);
+      double prefact;
+      unsigned int ind = 0;
+
+      for (unsigned int depth_interp = 0; depth_interp < num_spline_knots; ++depth_interp)
+        {
+          for (unsigned int degree_l = 0; degree_l < max_degree_to_use+1; ++degree_l)
+            {
+              for (unsigned int order_m = 0; order_m < degree_l+1; ++order_m)
+                {
+                  if (degree_l == 0)
+                    prefact = (zero_out_degree_0
+                               ?
+                               0.
+                               :
+                               1.);
+                  else if (order_m != 0)
+                    // this removes the sqrt(2) factor difference in normalization (see PR # 966)
+                    prefact = 1./sqrt(2.);
+                  else
+                    prefact = 1.0;
+
+                  spline_values[depth_interp] += prefact * (a_lm[ind] * cosine_components[degree_l][order_m]
+                                                            + b_lm[ind] * sine_components[degree_l][order_m]);
+
+                  ++ind;
+                }
+            }
+          // Skip the higher degree spherical harminic coefficients per layer if a lower max degree is used.
+          // The formula below will calculate the total number of the spherical harmonic coefficients from
+          // the degree at max_degree_to_use+1 to the degree at max_degree_data_file.
+          // The formula below will be zero if the spherical harmonics are summed up to the degree at max_degree_data_file.
+          ind += (max_degree_to_use+max_degree_data_file+3)*(max_degree_data_file-max_degree_to_use)/2;
+        }
+
+      // We need to reorder the spline_values because the coefficients are given from
+      // the surface down to the CMB and the interpolation knots range from the CMB up to
+      // the surface.
+      std::vector<double> spline_values_inv(num_spline_knots,0);
+      for (unsigned int i=0; i<num_spline_knots; ++i)
+        spline_values_inv[i] = spline_values[num_spline_knots-1 - i];
+
+      // The boundary condition for the cubic spline interpolation is that the function is linear
+      // at the boundary (i.e. Moho and CMB). Values outside the range are linearly
+      // extrapolated.
+      aspect::Utilities::tk::spline s;
+      s.set_points(depth_values, spline_values_inv);
+
+      // Return value of Vs perturbation at specific depth
+      return s(scoord[0]);
+    }
+
+
+    template <int dim>
+    double
+    S40RTSPerturbation<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+
+      // use either the user-input reference temperature as background temperature
+      // (incompressible model) or the adiabatic temperature profile (compressible model)
+      const double background_temperature = this->get_material_model().is_compressible() ?
+                                            this->get_adiabatic_conditions().temperature(position) :
+                                            reference_temperature;
+
+      //Read in Vs perturbation data using function above
+      const double perturbation = get_Vs (position);
+
+
+      // Get the vs to density conversion
+      const double depth = this->get_geometry_model().depth(position);
+
+      double vs_to_density = 0.0;
+      if (vs_to_density_method == file)
+        vs_to_density = profile.get_data_component(Point<1>(depth), vs_to_density_index);
+      else if (vs_to_density_method == constant)
+        vs_to_density = vs_to_density_constant;
+      else
+        // we shouldn't get here but instead should already have been
+        // kicked out by the assertion in the parse_parameters()
+        // function
+        Assert (false, ExcNotImplemented());
+
+      // scale the perturbation in seismic velocity into a density perturbation
+      // vs_to_density is an input parameter
+      const double density_perturbation = vs_to_density * perturbation;
+
+      double temperature_perturbation;
+      if (depth > no_perturbation_depth)
+        {
+          // scale the density perturbation into a temperature perturbation
+          // see if we need to ask material model for the thermal expansion coefficient
+          if (use_material_model_thermal_alpha)
+            {
+              MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
+              MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
+              in.position[0] = position;
+              in.temperature[0] = background_temperature;
+              in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
+              in.velocity[0] = Tensor<1,dim> ();
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                in.composition[0][c] = this->get_initial_composition_manager().initial_composition(position, c);
+              in.requested_properties = MaterialModel::MaterialProperties::thermal_expansion_coefficient;
+
+              this->get_material_model().evaluate(in, out);
+
+              temperature_perturbation = -1./(out.thermal_expansion_coefficients[0]) * density_perturbation;
+            }
+          else
+            temperature_perturbation = -1./thermal_alpha * density_perturbation;
+        }
+      else
+        // set heterogeneity to zero down to a specified depth
+        temperature_perturbation = 0.0;
+
+      // add the temperature perturbation to the background temperature
+      return background_temperature + temperature_perturbation;
+    }
+
+
+    template <int dim>
+    void
+    S40RTSPerturbation<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("S40RTS perturbation");
+        {
+          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/initial-temperature/S40RTS/",
+                             Patterns::DirectoryName (),
+                             "The path to the model data. ");
+          prm.declare_entry ("Initial condition file name", "S40RTS.sph",
+                             Patterns::Anything(),
+                             "The file name of the spherical harmonics coefficients "
+                             "from Ritsema et al.");
+          prm.declare_entry ("Spline knots depth file name", "Spline_knots.txt",
+                             Patterns::Anything(),
+                             "The file name of the spline knot locations from "
+                             "Ritsema et al.");
+          prm.declare_entry ("Vs to density scaling method", "constant",
+                             Patterns::Selection("file|constant"),
+                             "Method that is used to specify how the vs-to-density scaling varies "
+                             "with depth.");
+          prm.declare_entry ("Vs to density scaling", "0.25",
+                             Patterns::Double (0.),
+                             "This parameter specifies how the perturbation in shear wave velocity "
+                             "as prescribed by S20RTS or S40RTS is scaled into a density perturbation. "
+                             "See the general description of this model for more detailed information.");
+          prm.declare_entry ("Thermal expansion coefficient in initial temperature scaling", "2e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\beta$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Use thermal expansion coefficient from material model", "false",
+                             Patterns::Bool (),
+                             "Option to take the thermal expansion coefficient from the "
+                             "material model instead of from what is specified in this "
+                             "section.");
+          prm.declare_entry ("Remove degree 0 from perturbation","true",
+                             Patterns::Bool (),
+                             "Option to remove the degree zero component from the perturbation, "
+                             "which will ensure that the laterally averaged temperature for a fixed "
+                             "depth is equal to the background temperature.");
+          prm.declare_entry ("Reference temperature", "1600.0",
+                             Patterns::Double (0.),
+                             "The reference temperature that is perturbed by the spherical "
+                             "harmonic functions. Only used in incompressible models.");
+          prm.declare_entry ("Remove temperature heterogeneity down to specified depth",
+                             boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
+                             Patterns::Double (),
+                             "This will set the heterogeneity prescribed by S20RTS or S40RTS to zero "
+                             "down to the specified depth (in meters). Note that your resolution has "
+                             "to be adequate to capture this cutoff. For example if you specify a depth "
+                             "of 660km, but your closest spherical depth layers are only at 500km and "
+                             "750km (due to a coarse resolution) it will only zero out heterogeneities "
+                             "down to 500km. Similar caution has to be taken when using adaptive meshing.");
+          prm.declare_entry ("Specify a lower maximum degree","false",
+                             Patterns::Bool (),
+                             "Option to use a lower maximum degree when reading the data file of spherical "
+                             "harmonic coefficients. This is probably used for the faster tests or when the "
+                             "users only want to see the spherical harmonic pattern up to a certain degree.");
+          prm.declare_entry ("Maximum degree","20",
+                             Patterns::Integer (0),
+                             "The maximum degree the users specify when reading the data file of spherical harmonic "
+                             "coefficients, which must be smaller than the maximum degree the data file stored. "
+                             "This parameter will be used only if 'Specify a lower maximum degree' is set to true.");
+
+          aspect::Utilities::AsciiDataProfile<dim>::declare_parameters(prm,
+                                                                       "$ASPECT_SOURCE_DIR/data/initial-temperature/S40RTS/",
+                                                                       "vs_to_density_Steinberger.txt",
+                                                                       "Ascii data vs to density model");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    S40RTSPerturbation<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("S40RTS perturbation");
+        {
+          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+
+          if ((data_directory.size() > 0) && (data_directory[data_directory.size()-1] != '/'))
+            data_directory += "/";
+          harmonics_coeffs_file_name = prm.get ("Initial condition file name");
+          spline_depth_file_name  = prm.get ("Spline knots depth file name");
+          vs_to_density_constant           = prm.get_double ("Vs to density scaling");
+          thermal_alpha           = prm.get_double ("Thermal expansion coefficient in initial temperature scaling");
+          use_material_model_thermal_alpha = prm.get_bool ("Use thermal expansion coefficient from material model");
+          zero_out_degree_0       = prm.get_bool ("Remove degree 0 from perturbation");
+          reference_temperature   = prm.get_double ("Reference temperature");
+          no_perturbation_depth   = prm.get_double ("Remove temperature heterogeneity down to specified depth");
+          lower_max_degree         = prm.get_bool ("Specify a lower maximum degree");
+          specified_max_degree               = prm.get_integer ("Maximum degree");
+
+          if (prm.get("Vs to density scaling method") == "file")
+            vs_to_density_method = file;
+          else if (prm.get("Vs to density scaling method") == "constant")
+            vs_to_density_method = constant;
+          else
+            {
+              AssertThrow(false, ExcMessage("Unknown method for vs to density scaling."));
+            }
+
+          profile.parse_parameters(prm,"Ascii data vs to density model");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(S40RTSPerturbation,
+                                              "S40RTS perturbation",
+                                              "An initial temperature field in which the temperature "
+                                              "is perturbed following the S20RTS or S40RTS shear wave "
+                                              "velocity model by Ritsema and others, which can be downloaded "
+                                              "here \\url{http://www.earth.lsa.umich.edu/~jritsema/research.html}. "
+                                              "Information on the vs model can be found in Ritsema, J., Deuss, "
+                                              "A., van Heijst, H.J. \\& Woodhouse, J.H., 2011. S40RTS: a "
+                                              "degree-40 shear-velocity model for the mantle from new Rayleigh "
+                                              "wave dispersion, teleseismic traveltime and normal-mode "
+                                              "splitting function measurements, Geophys. J. Int. 184, 1223-1236. "
+                                              "The scaling between the shear wave perturbation and the "
+                                              "density perturbation can be constant and set by the user with the "
+                                              "'Vs to density scaling' parameter or depth-dependent and "
+                                              "read in from a file. To convert density the user can specify "
+                                              "the 'Thermal expansion coefficient in initial temperature scaling' "
+                                              "parameter. The scaling is as follows: $\\delta \\ln \\rho "
+                                              "(r,\\theta,\\phi) = \\xi \\cdot \\delta \\ln v_s(r,\\theta, "
+                                              "\\phi)$ and $\\delta T(r,\\theta,\\phi) = - \\frac{1}{\\alpha} "
+                                              "\\delta \\ln \\rho(r,\\theta,\\phi)$. $\\xi$ is the `vs to "
+                                              "density scaling' parameter and $\\alpha$ is the 'Thermal "
+                                              "expansion coefficient in initial temperature scaling' "
+                                              "parameter. The temperature perturbation is added to an "
+                                              "otherwise constant temperature (incompressible model) or "
+                                              "adiabatic reference profile (compressible model). If a depth "
+                                              "is specified in 'Remove temperature heterogeneity down to "
+                                              "specified depth', there is no temperature perturbation "
+                                              "prescribed down to that depth."
+                                              "\n"
+                                              "Note the required file format if the vs to density scaling is read in "
+                                              "from a file: The first lines may contain any number of comments "
+                                              "if they begin with '#', but one of these lines needs to "
+                                              "contain the number of points in the reference state as "
+                                              "for example '# POINTS: 3'. "
+                                              "Following the comment lines there has to be a single line "
+                                              "containing the names of all data columns, separated by arbitrarily "
+                                              "many spaces. Column names are not allowed to contain spaces. "
+                                              "The file can contain unnecessary columns, but for this plugin it "
+                                              "needs to at least provide the columns named `depth' and "
+                                              "`vs\\_to\\_density'. "
+                                              "Note that the data lines in the file need to be sorted in order "
+                                              "of increasing depth from 0 to the maximal depth in the model "
+                                              "domain. Points in the model that are outside of the provided "
+                                              "depth range will be assigned the maximum or minimum depth values, "
+                                              "respectively. Points do not need to be equidistant, "
+                                              "but the computation of properties is optimized in speed "
+                                              "if they are."
+                                              "\n"
+                                              "If the plugin is used in 2d it will use an equatorial "
+                                              "slice of the seismic tomography model.")
+  }
+}
diff --git a/source/initial_temperature/SAVANI_perturbation.cc.bak b/source/initial_temperature/SAVANI_perturbation.cc.bak
new file mode 100644
index 00000000000..ce8881cbb66
--- /dev/null
+++ b/source/initial_temperature/SAVANI_perturbation.cc.bak
@@ -0,0 +1,537 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/SAVANI_perturbation.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+#include <aspect/initial_composition/interface.h>
+#include <aspect/material_model/interface.h>
+#include <array>
+
+#include <boost/lexical_cast.hpp>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    namespace internal
+    {
+      namespace SAVANI
+      {
+        // Read in the spherical harmonics that are located in data/initial-temperature/SAVANI
+        // and were downloaded from http://n.ethz.ch/~auerl/research.html
+        // choose real sine and cosine coefficients that follow the normalization
+        // by Dahlen & Tromp, Theoretical Global Seismology (equations B.58 and B.99).
+
+        class SphericalHarmonicsLookup
+        {
+          public:
+            SphericalHarmonicsLookup(const std::string &filename,
+                                     const MPI_Comm comm)
+            {
+              std::string temp;
+              // Read data from disk and distribute among processes
+              std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
+
+              in >> order;
+              std::getline(in,temp);  // throw away the rest of the line
+
+              const unsigned int num_layers = 28;
+
+              // read in all coefficients as a single data vector
+              std::vector<double> coeffs;
+              for (unsigned int i=0; i<num_layers; ++i)
+                {
+                  for (unsigned int j=0; j<(order+1)*(order+2); ++j)
+                    {
+                      double new_val;
+                      in >> new_val;
+                      coeffs.push_back(0.01*new_val);
+                    }
+                  std::getline(in,temp);
+                }
+
+              // reorder the coefficients into sin and cos coefficients. a_lm will be the cos coefficients
+              // and b_lm the sin coefficients.
+              unsigned int ind = 0;
+
+              for (unsigned int j=0; j<num_layers; ++j)
+                for (unsigned int i=0; i<order+1; ++i)
+                  {
+                    unsigned int ind_degree = 0;
+                    while (ind_degree <= i)
+                      {
+                        a_lm.push_back(coeffs[ind]);
+                        ++ind;
+                        b_lm.push_back(coeffs[ind]);
+                        ++ind;
+                        ++ind_degree;
+                      }
+                  }
+            }
+
+            // Declare a function that returns the cosine coefficients
+            const std::vector<double> &cos_coeffs() const
+            {
+              return a_lm;
+            }
+
+            // Declare a function that returns the sine coefficients
+            const std::vector<double> &sin_coeffs() const
+            {
+              return b_lm;
+            }
+
+            unsigned int maxdegree()
+            {
+              return order;
+            }
+
+          private:
+            unsigned int order;
+            std::vector<double> a_lm;
+            std::vector<double> b_lm;
+
+        };
+
+        // Read in the knot points for the spline interpolation. They are located in data/
+        // initial-temperature/SAVANI and were taken from the 28 spherical layers of SAVANI
+        // tomography model by a matlab script convert_to_knots.m located in the same directory.
+        class SplineDepthsLookup
+        {
+          public:
+            SplineDepthsLookup(const std::string &filename,
+                               const MPI_Comm comm)
+            {
+              std::string temp;
+              // Read data from disk and distribute among processes
+              std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
+
+              std::getline(in,temp);  // throw away the rest of the line
+              std::getline(in,temp);  // throw away the rest of the line
+
+              const unsigned int num_splines = 28;
+              depths.resize(num_splines);
+              for (unsigned int i=0; i<num_splines; ++i)
+                {
+                  in >> depths[i];
+                }
+            }
+
+            const std::vector<double> &spline_depths() const
+            {
+              return depths;
+            }
+
+          private:
+            std::vector<double> depths;
+        };
+      }
+    }
+
+    template <int dim>
+    SAVANIPerturbation<dim>::SAVANIPerturbation()
+      :
+      vs_to_density_index(numbers::invalid_unsigned_int)
+    {}
+
+
+    template <int dim>
+    void
+    SAVANIPerturbation<dim>::initialize()
+    {
+      spherical_harmonics_lookup
+        = std::make_unique<internal::SAVANI::SphericalHarmonicsLookup>(data_directory+harmonics_coeffs_file_name,
+                                                                       this->get_mpi_communicator());
+      spline_depths_lookup
+        = std::make_unique<internal::SAVANI::SplineDepthsLookup>(data_directory+spline_depth_file_name,
+                                                                 this->get_mpi_communicator());
+
+      if (vs_to_density_method == file)
+        {
+          profile.initialize(this->get_mpi_communicator());
+          vs_to_density_index = profile.get_column_index_from_name("vs_to_density");
+        }
+
+    }
+
+
+    template <>
+    double
+    SAVANIPerturbation<2>::
+    initial_temperature (const Point<2> &) const
+    {
+      // we shouldn't get here but instead should already have been
+      // kicked out by the assertion in the parse_parameters()
+      // function
+      Assert (false, ExcNotImplemented());
+      return 0;
+    }
+
+    template <>
+    double
+    SAVANIPerturbation<2>::
+    get_Vs (const Point<2> &/*position*/) const
+    {
+      Assert (false, ExcNotImplemented());
+      return 0;
+    }
+
+    template <>
+    double
+    SAVANIPerturbation<3>::
+    get_Vs (const Point<3> &position) const
+    {
+      const unsigned int dim = 3;
+
+      // get the max degree from the input data file (60)
+      const unsigned int max_degree_data_file = spherical_harmonics_lookup->maxdegree();
+
+      // set the max degree used for the calculation to the max degree from the input data file as default
+      unsigned int max_degree_to_use = max_degree_data_file;
+
+      // lower the maximum degree of the calculation if needed
+      if (lower_max_degree)
+        {
+          AssertThrow(specified_max_degree <= max_degree_data_file, ExcMessage("Specifying a maximum degree higher than the degree of spherical harmonic data is not allowed"));
+          max_degree_to_use = specified_max_degree;
+        }
+
+      const int num_spline_knots = 28; // The tomography models are parameterized by 28 layers
+
+      // get the spherical harmonics coefficients
+      const std::vector<double> &a_lm = spherical_harmonics_lookup->cos_coeffs();
+      const std::vector<double> &b_lm = spherical_harmonics_lookup->sin_coeffs();
+
+      // get spline knots and rescale them from [-1 1], i.e., CMB to Moho.
+      const std::vector<double> &r = spline_depths_lookup->spline_depths();
+      const double rmoho = 6346e3;
+      const double rcmb = 3480e3;
+      std::vector<double> depth_values(num_spline_knots, 0.);
+
+      for (unsigned int i = 0; i<num_spline_knots; ++i)
+        depth_values[i] = rcmb+(rmoho-rcmb)*0.5*(r[i]+1.);
+
+      // convert coordinates from [x,y,z] to [r, phi, theta]
+      std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
+
+      // Evaluate the spherical harmonics at this position. Since they are the
+      // same for all depth splines, do it once to avoid multiple evaluations.
+      std::vector<std::vector<double>> cosine_components(max_degree_to_use+1, std::vector<double>(max_degree_to_use+1, 0.0));
+      std::vector<std::vector<double>> sine_components(max_degree_to_use+1, std::vector<double>(max_degree_to_use+1, 0.0));
+
+      for (unsigned int degree_l = 0; degree_l < max_degree_to_use+1; ++degree_l)
+        {
+          for (unsigned int order_m = 0; order_m < degree_l+1; ++order_m)
+            {
+              const std::pair<double,double> sph_harm_vals = Utilities::real_spherical_harmonic( degree_l, order_m, scoord[2], scoord[1] );
+              cosine_components[degree_l][order_m] = sph_harm_vals.first;
+              sine_components[degree_l][order_m] = sph_harm_vals.second;
+            }
+        }
+
+      // iterate over all degrees and orders at each depth and sum them all up.
+      std::vector<double> spline_values(num_spline_knots, 0.);
+      double prefact;
+      unsigned int ind = 0;
+
+      for (unsigned int depth_interp = 0; depth_interp < num_spline_knots; ++depth_interp)
+        {
+          for (unsigned int degree_l = 0; degree_l < max_degree_to_use+1; ++degree_l)
+            {
+              for (unsigned int order_m = 0; order_m < degree_l+1; ++order_m)
+                {
+                  // normalization after Dahlen and Tromp, 1986, Appendix B.6
+                  if (degree_l == 0)
+                    prefact = (zero_out_degree_0
+                               ?
+                               0.
+                               :
+                               1.);
+                  else
+                    prefact = 1.0;
+
+                  spline_values[depth_interp] += prefact * (a_lm[ind] * cosine_components[degree_l][order_m]
+                                                            + b_lm[ind] * sine_components[degree_l][order_m]);
+
+                  ++ind;
+                }
+            }
+          // Skip the higher degree spherical harminic coefficients per layer if a lower max degree is used.
+          // The formula below will calculate the total number of the spherical harmonic coefficients from
+          // the degree at max_degree_to_use+1 to the degree at max_degree_data_file.
+          // The formula below will be zero if the spherical harmonics are summed up to the degree at max_degree_data_file.
+          ind += (max_degree_to_use+max_degree_data_file+3)*(max_degree_data_file-max_degree_to_use)/2;
+        }
+
+
+      // The boundary condition for the cubic spline interpolation is that the function is linear
+      // at the boundary (i.e. Moho and CMB). Values outside the range are linearly
+      // extrapolated.
+      aspect::Utilities::tk::spline s;
+      s.set_points(depth_values, spline_values);
+
+      // Get value at specific depth
+      return s(scoord[0]);
+
+    }
+
+
+    template <>
+    double
+    SAVANIPerturbation<3>::
+    initial_temperature (const Point<3> &position) const
+    {
+      // use either the user-input reference temperature as background temperature
+      // (incompressible model) or the adiabatic temperature profile (compressible model)
+      const double background_temperature = this->get_material_model().is_compressible() ?
+                                            this->get_adiabatic_conditions().temperature(position) :
+                                            reference_temperature;
+
+      //Read in Vs perturbation data using function above
+      const double perturbation = get_Vs (position);
+
+      // Get the vs to density conversion
+      const double depth = this->get_geometry_model().depth(position);
+
+      double vs_to_density = 0.0;
+      if (vs_to_density_method == file)
+        vs_to_density = profile.get_data_component(Point<1>(depth), vs_to_density_index);
+      else if (vs_to_density_method == constant)
+        vs_to_density = vs_to_density_constant;
+      else
+        // we shouldn't get here but instead should already have been
+        // kicked out by the assertion in the parse_parameters()
+        // function
+        Assert (false, ExcNotImplemented());
+
+      // scale the perturbation in seismic velocity into a density perturbation
+      // vs_to_density is an input parameter
+      const double density_perturbation = vs_to_density * perturbation;
+
+      double temperature_perturbation;
+      if (depth > no_perturbation_depth)
+        {
+          // scale the density perturbation into a temperature perturbation
+          // see if we need to ask material model for the thermal expansion coefficient
+          if (use_material_model_thermal_alpha)
+            {
+              MaterialModel::MaterialModelInputs<3> in(1, this->n_compositional_fields());
+              MaterialModel::MaterialModelOutputs<3> out(1, this->n_compositional_fields());
+              in.position[0] = position;
+              in.temperature[0] = background_temperature;
+              in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
+              in.velocity[0] = Tensor<1,3> ();
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                in.composition[0][c] = this->get_initial_composition_manager().initial_composition(position, c);
+              in.requested_properties = MaterialModel::MaterialProperties::thermal_expansion_coefficient;
+
+              this->get_material_model().evaluate(in, out);
+
+              temperature_perturbation = -1./(out.thermal_expansion_coefficients[0]) * density_perturbation;
+            }
+          else
+            temperature_perturbation = -1./thermal_alpha * density_perturbation;
+        }
+      else
+        // set heterogeneity to zero down to a specified depth
+        temperature_perturbation = 0.0;
+
+      // add the temperature perturbation to the background temperature
+      return background_temperature + temperature_perturbation;
+    }
+
+
+    template <int dim>
+    void
+    SAVANIPerturbation<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("SAVANI perturbation");
+        {
+          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/initial-temperature/SAVANI/",
+                             Patterns::DirectoryName (),
+                             "The path to the model data.");
+          prm.declare_entry ("Initial condition file name", "savani.dlnvs.60.m.ab",
+                             Patterns::Anything(),
+                             "The file name of the spherical harmonics coefficients "
+                             "from Auer et al.");
+          prm.declare_entry ("Spline knots depth file name", "Spline_knots.txt",
+                             Patterns::Anything(),
+                             "The file name of the spline knots taken from the 28 spherical layers "
+                             "of SAVANI tomography model.");
+          prm.declare_entry ("Vs to density scaling method", "constant",
+                             Patterns::Selection("file|constant"),
+                             "Method that is used to specify how the vs-to-density scaling varies "
+                             "with depth.");
+          prm.declare_entry ("Vs to density scaling", "0.25",
+                             Patterns::Double (0.),
+                             "This parameter specifies how the perturbation in shear wave velocity "
+                             "as prescribed by SAVANI is scaled into a density perturbation. "
+                             "See the general description of this model for more detailed information.");
+          prm.declare_entry ("Thermal expansion coefficient in initial temperature scaling", "2e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\beta$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Use thermal expansion coefficient from material model", "false",
+                             Patterns::Bool (),
+                             "Option to take the thermal expansion coefficient from the "
+                             "material model instead of from what is specified in this "
+                             "section.");
+          prm.declare_entry ("Remove degree 0 from perturbation","true",
+                             Patterns::Bool (),
+                             "Option to remove the degree zero component from the perturbation, "
+                             "which will ensure that the laterally averaged temperature for a fixed "
+                             "depth is equal to the background temperature.");
+          prm.declare_entry ("Reference temperature", "1600.0",
+                             Patterns::Double (0.),
+                             "The reference temperature that is perturbed by the spherical "
+                             "harmonic functions. Only used in incompressible models.");
+          prm.declare_entry ("Remove temperature heterogeneity down to specified depth",
+                             boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
+                             Patterns::Double (),
+                             "This will set the heterogeneity prescribed by SAVANI to zero "
+                             "down to the specified depth (in meters). Note that your resolution has "
+                             "to be adequate to capture this cutoff. For example if you specify a depth "
+                             "of 660km, but your closest spherical depth layers are only at 500km and "
+                             "750km (due to a coarse resolution) it will only zero out heterogeneities "
+                             "down to 500km. Similar caution has to be taken when using adaptive meshing.");
+          prm.declare_entry ("Specify a lower maximum degree","false",
+                             Patterns::Bool (),
+                             "Option to use a lower maximum degree when reading the data file of spherical "
+                             "harmonic coefficients. This is probably used for the faster tests or when the "
+                             "users only want to see the spherical harmonic pattern up to a certain degree.");
+          prm.declare_entry ("Maximum degree","20",
+                             Patterns::Integer (0),
+                             "The maximum degree the users specify when reading the data file of spherical harmonic "
+                             "coefficients, which must be smaller than the maximum degree the data file stored. "
+                             "This parameter will be used only if 'Specify a lower maximum degree' is set to true.");
+          aspect::Utilities::AsciiDataProfile<dim>::declare_parameters(prm,
+                                                                       "$ASPECT_SOURCE_DIR/data/initial-temperature/S40RTS/",
+                                                                       "vs_to_density_Steinberger.txt",
+                                                                       "Ascii data vs to density model");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    SAVANIPerturbation<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      AssertThrow (dim == 3,
+                   ExcMessage ("The 'SAVANI perturbation' model for the initial "
+                               "temperature is only available for 3d computations."));
+
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("SAVANI perturbation");
+        {
+          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+          if ((data_directory.size() > 0) && (data_directory[data_directory.size()-1] != '/'))
+            data_directory += "/";
+          harmonics_coeffs_file_name = prm.get ("Initial condition file name");
+          spline_depth_file_name  = prm.get ("Spline knots depth file name");
+          vs_to_density_constant           = prm.get_double ("Vs to density scaling");
+          thermal_alpha           = prm.get_double ("Thermal expansion coefficient in initial temperature scaling");
+          use_material_model_thermal_alpha = prm.get_bool ("Use thermal expansion coefficient from material model");
+          zero_out_degree_0       = prm.get_bool ("Remove degree 0 from perturbation");
+          reference_temperature   = prm.get_double ("Reference temperature");
+          no_perturbation_depth   = prm.get_double ("Remove temperature heterogeneity down to specified depth");
+          lower_max_degree         = prm.get_bool ("Specify a lower maximum degree");
+          specified_max_degree               = prm.get_integer ("Maximum degree");
+
+          if (prm.get("Vs to density scaling method") == "file")
+            vs_to_density_method = file;
+          else if (prm.get("Vs to density scaling method") == "constant")
+            vs_to_density_method = constant;
+          else
+            {
+              AssertThrow(false, ExcMessage("Unknown method for vs to density scaling."));
+            }
+
+          profile.parse_parameters(prm,"Ascii data vs to density model");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(SAVANIPerturbation,
+                                              "SAVANI perturbation",
+                                              "An initial temperature field in which the temperature "
+                                              "is perturbed following the SAVANI shear wave "
+                                              "velocity model by Auer and others, which can be downloaded "
+                                              "here \\url{http://n.ethz.ch/~auerl/savani.tar.bz2}. "
+                                              "Information on the vs model can be found in Auer, L., Boschi, "
+                                              "L., Becker, T.W., Nissen-Meyer, T. \\& Giardini, D., 2014. "
+                                              "Savani: A variable resolution whole-mantle model of anisotropic "
+                                              "shear velocity variations based on multiple data sets. Journal "
+                                              "of Geophysical Research: Solid Earth 119.4 (2014): 3006-3034. "
+                                              "The scaling between the shear wave perturbation and the "
+                                              "density perturbation can be constant and set by the user with the "
+                                              "'Vs to density scaling' parameter or depth-dependent and "
+                                              "read in from a file. To convert density the user can specify "
+                                              "the 'Thermal expansion coefficient in initial temperature scaling' "
+                                              "parameter. The scaling is as follows: $\\delta \\ln \\rho "
+                                              "(r,\\theta,\\phi) = \\xi \\cdot \\delta \\ln v_s(r,\\theta, "
+                                              "\\phi)$ and $\\delta T(r,\\theta,\\phi) = - \\frac{1}{\\alpha} "
+                                              "\\delta \\ln \\rho(r,\\theta,\\phi)$. $\\xi$ is the `vs to "
+                                              "density scaling' parameter and $\\alpha$ is the 'Thermal "
+                                              "expansion coefficient in initial temperature scaling' "
+                                              "parameter. The temperature perturbation is added to an "
+                                              "otherwise constant temperature (incompressible model) or "
+                                              "adiabatic reference profile (compressible model).If a depth "
+                                              "is specified in 'Remove temperature heterogeneity down to "
+                                              "specified depth', there is no temperature perturbation "
+                                              "prescribed down to that depth."
+                                              "\n"
+                                              "Note the required file format if the vs to density scaling is read in "
+                                              "from a file: The first lines may contain any number of comments "
+                                              "if they begin with '#', but one of these lines needs to "
+                                              "contain the number of points in the reference state as "
+                                              "for example '# POINTS: 3'. "
+                                              "Following the comment lines there has to be a single line "
+                                              "containing the names of all data columns, separated by arbitrarily "
+                                              "many spaces. Column names are not allowed to contain spaces. "
+                                              "The file can contain unnecessary columns, but for this plugin it "
+                                              "needs to at least provide the columns named `depth' and "
+                                              "`vs\\_to\\_density'. "
+                                              "Note that the data lines in the file need to be sorted in order "
+                                              "of increasing depth from 0 to the maximal depth in the model "
+                                              "domain. Points in the model that are outside of the provided "
+                                              "depth range will be assigned the maximum or minimum depth values, "
+                                              "respectively. Points do not need to be equidistant, "
+                                              "but the computation of properties is optimized in speed "
+                                              "if they are.")
+  }
+}
diff --git a/source/initial_temperature/adiabatic.cc.bak b/source/initial_temperature/adiabatic.cc.bak
new file mode 100644
index 00000000000..948475d1cc6
--- /dev/null
+++ b/source/initial_temperature/adiabatic.cc.bak
@@ -0,0 +1,572 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/adiabatic.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/chunk.h>
+
+#include <cmath>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    namespace BoundaryLayerAgeModel
+    {
+      BoundaryLayerAgeModel::Kind
+      parse (const std::string &parameter_name,
+             const ParameterHandler &prm)
+      {
+        BoundaryLayerAgeModel::Kind age_model;
+        if (prm.get (parameter_name) == "constant")
+          age_model = constant;
+        else if (prm.get (parameter_name) == "function")
+          age_model = function;
+        else if (prm.get (parameter_name) == "ascii data")
+          age_model = ascii_data;
+        else
+          {
+            AssertThrow(false, ExcMessage("Not a valid boundary layer age model."));
+
+            // We will never get here, but we have to return something
+            // so the compiler does not complain
+            return constant;
+          }
+
+        return age_model;
+      }
+    }
+
+    template <int dim>
+    Adiabatic<dim>::Adiabatic ()
+      :
+      surface_boundary_id(numbers::invalid_unsigned_int)
+    {}
+
+
+
+    template <int dim>
+    void
+    Adiabatic<dim>::initialize ()
+    {
+      if (top_boundary_layer_age_model == BoundaryLayerAgeModel::ascii_data)
+        {
+          // Find the boundary indicator that represents the surface
+          surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+          // The input ascii table contains one data column (LAB depths(m)) in addition to the coordinate columns.
+          Utilities::AsciiDataBoundary<dim>::initialize({surface_boundary_id},
+                                                        1);
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    Adiabatic<dim>::
+    top_boundary_layer_age (const Point<dim> &position) const
+    {
+      // Top boundary layer age in seconds
+      double age_top = 0.0;
+
+      if (top_boundary_layer_age_model == BoundaryLayerAgeModel::ascii_data)
+        {
+          // The input ascii contains the age of the seafloor. User must provide ages in seconds
+          age_top = Utilities::AsciiDataBoundary<dim>::get_data_component(surface_boundary_id,
+                                                                          position,
+                                                                          0);
+        }
+      else if (top_boundary_layer_age_model == BoundaryLayerAgeModel::constant)
+        {
+          age_top =    (this->convert_output_to_years()
+                        ?
+                        age_top_boundary_layer * year_in_seconds
+                        :
+                        age_top_boundary_layer);
+        }
+      else if (top_boundary_layer_age_model == BoundaryLayerAgeModel::function)
+        {
+          Utilities::NaturalCoordinate<dim> point =
+            this->get_geometry_model().cartesian_to_other_coordinates(position,
+                                                                      coordinate_system);
+
+          age_top = age_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
+          if (this->convert_output_to_years())
+            age_top *= year_in_seconds;
+        }
+      else
+        {
+          Assert(false, ExcMessage("Unknown top boundary layer age model."));
+        }
+
+      return age_top;
+    }
+
+
+    template <int dim>
+    double
+    Adiabatic<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+
+      const double age_top = top_boundary_layer_age(position);
+      const double age_bottom = (this->convert_output_to_years() ? age_bottom_boundary_layer * year_in_seconds
+                                 : age_bottom_boundary_layer);
+
+      // First, get the temperature of the adiabatic profile at a representative
+      // point at the top and bottom boundary of the model
+      // if adiabatic heating is switched off, assume a constant profile
+      const Point<dim> surface_point = this->get_geometry_model().representative_point(0.0);
+      const Point<dim> bottom_point = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
+      const double adiabatic_surface_temperature = this->get_adiabatic_conditions().temperature(surface_point);
+      const double adiabatic_bottom_temperature = (this->include_adiabatic_heating())
+                                                  ?
+                                                  this->get_adiabatic_conditions().temperature(bottom_point)
+                                                  :
+                                                  adiabatic_surface_temperature;
+
+      // then, get the temperature at the top and bottom boundary of the model
+      // if no boundary temperature is prescribed simply use the adiabatic.
+      // This implementation assumes that the top and bottom boundaries have
+      // prescribed temperatures and minimal_temperature() returns the value
+      // at the surface and maximal_temperature() the value at the bottom.
+      const double T_surface = (this->has_boundary_temperature()
+                                ?
+                                this->get_boundary_temperature_manager().minimal_temperature(
+                                  this->get_fixed_temperature_boundary_indicators())
+                                :
+                                adiabatic_surface_temperature);
+      const double T_bottom = (this->has_boundary_temperature()
+                               ?
+                               this->get_boundary_temperature_manager().maximal_temperature(
+                                 this->get_fixed_temperature_boundary_indicators())
+                               :
+                               adiabatic_bottom_temperature);
+      const double depth = this->get_geometry_model().depth(position);
+
+      // look up material properties
+      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
+
+      // compute the adiabat by referring to the Adiabatic conditions model
+      in.position[0] = position;
+      in.temperature[0] = this->get_adiabatic_conditions().temperature(position);
+      in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
+      in.velocity[0] = Tensor<1,dim> ();
+      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+        in.composition[0][c] = function->value(Point<1>(depth),c);
+      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties |
+                                MaterialModel::MaterialProperties::thermal_conductivity;
+      this->get_material_model().evaluate(in, out);
+
+      const double kappa = ( (this->get_parameters().formulation_temperature_equation ==
+                              Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+                             ?
+                             out.thermal_conductivities[0] /
+                             (this->get_adiabatic_conditions().density(in.position[0]) * out.specific_heat[0])
+                             :
+                             out.thermal_conductivities[0] / (out.densities[0] * out.specific_heat[0])
+                           );
+
+      double surface_cooling_temperature = 0;
+      double bottom_heating_temperature = 0;
+
+      if (cooling_model == "half-space cooling")
+        {
+          if (age_top > 0.0 || age_bottom > 0.0)
+            AssertThrow (kappa > 0.0,
+                         ExcMessage ("The thermal diffusivity needs to be larger than zero "
+                                     "for computing thermal boundary layers with the half-space "
+                                     "cooling model."));
+
+          // analytical solution for the thermal boundary layer from half-space cooling model
+          surface_cooling_temperature = age_top > 0.0 ?
+                                        (T_surface - adiabatic_surface_temperature) *
+                                        erfc(this->get_geometry_model().depth(position) /
+                                             (2 * sqrt(kappa * age_top)))
+                                        : 0.0;
+          bottom_heating_temperature = (age_bottom > 0.0 && this->get_adiabatic_conditions().is_initialized()) ?
+                                       (T_bottom - adiabatic_bottom_temperature + subadiabaticity)
+                                       * erfc((this->get_geometry_model().maximal_depth()
+                                               - this->get_geometry_model().depth(position)) /
+                                              (2 * sqrt(kappa * age_bottom)))
+                                       : 0.0;
+        }
+
+      if (cooling_model == "plate cooling")
+        {
+          if (depth > lithosphere_thickness)
+            {
+              surface_cooling_temperature = 0;
+            }
+          else
+            {
+              const double exponential = -kappa * std::pow(numbers::PI, 2) * age_top / std::pow(lithosphere_thickness, 2);
+              double sum_terms = 0.;
+              for (unsigned int n=1; n<11; ++n)
+                {
+                  const auto dn = static_cast<double>(n);
+                  sum_terms += 1./dn * std::exp(dn * dn * exponential) * std::sin(dn * depth * numbers::PI / lithosphere_thickness);
+                  surface_cooling_temperature = T_surface - adiabatic_surface_temperature + (adiabatic_surface_temperature - T_surface) * (depth / lithosphere_thickness + 2 / numbers::PI * sum_terms);
+                }
+            }
+        }
+
+      // set the initial temperature perturbation
+      // first: get the center of the perturbation, then check the distance to the
+      // evaluation point. the center is supposed to lie at the center of the bottom
+      // surface.
+      Point<dim> mid_point;
+      if (perturbation_position == "center")
+        {
+          if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()))
+            {
+              const GeometryModel::SphericalShell<dim> &shell_geometry_model =
+                Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
+
+              const double inner_radius = shell_geometry_model.inner_radius();
+              const double half_opening_angle = constants::degree_to_radians * 0.5 * shell_geometry_model.opening_angle();
+              if (dim==2)
+                {
+                  // choose the center of the perturbation at half angle along the inner radius
+                  mid_point(0) = inner_radius * std::sin(half_opening_angle),
+                  mid_point(1) = inner_radius * std::cos(half_opening_angle);
+                }
+              else if (dim==3)
+                {
+                  // if the opening angle is 90 degrees (an eighth of a full spherical
+                  // shell, then choose the point on the inner surface along the first
+                  // diagonal
+                  if (shell_geometry_model.opening_angle() == 90)
+                    {
+                      mid_point(0) = inner_radius*std::sqrt(1./3),
+                      mid_point(1) = inner_radius*std::sqrt(1./3),
+                      mid_point(2) = inner_radius*std::sqrt(1./3);
+                    }
+                  else
+                    {
+                      // otherwise do the same as in 2d
+                      mid_point(0) = inner_radius * std::sin(half_opening_angle) * std::cos(half_opening_angle),
+                      mid_point(1) = inner_radius * std::sin(half_opening_angle) * std::sin(half_opening_angle),
+                      mid_point(2) = inner_radius * std::cos(half_opening_angle);
+                    }
+                }
+            }
+          else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()))
+            {
+              const GeometryModel::Chunk<dim> &chunk_geometry_model =
+                Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>> (this->get_geometry_model());
+
+              const double inner_radius = chunk_geometry_model.inner_radius();
+
+              const double west_longitude = chunk_geometry_model.west_longitude(); // in radians
+              const double longitude_range = chunk_geometry_model.longitude_range(); // in radians
+              const double longitude_midpoint = west_longitude + 0.5 * longitude_range;
+
+              if (dim==2)
+                {
+                  // choose the center of the perturbation at half angle along the inner radius
+                  mid_point(0) = inner_radius * std::cos(longitude_midpoint),
+                  mid_point(1) = inner_radius * std::sin(longitude_midpoint);
+                }
+              else if (dim==3)
+                {
+
+                  const double south_latitude = chunk_geometry_model.south_latitude(); // in radians
+                  const double latitude_range = chunk_geometry_model.latitude_range(); // in radians
+                  const double latitude_midpoint = south_latitude + 0.5 * latitude_range;
+                  mid_point(0) = inner_radius * std::cos(latitude_midpoint) * std::cos(longitude_midpoint);
+                  mid_point(1) = inner_radius * std::cos(latitude_midpoint) * std::sin(longitude_midpoint);
+                  mid_point(2) = inner_radius * std::sin(latitude_midpoint);
+                }
+            }
+          else if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()))
+            {
+              const GeometryModel::Box<dim> &box_geometry_model =
+                Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
+
+              // for the box geometry, choose a point at the center of the bottom face.
+              // (note that the loop only runs over the first dim-1 coordinates, leaving
+              // the depth variable at zero)
+              mid_point = box_geometry_model.get_origin();
+              for (unsigned int i=0; i<dim-1; ++i)
+                mid_point(i) += 0.5 * box_geometry_model.get_extents()[i];
+            }
+          else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
+            {
+              const GeometryModel::TwoMergedBoxes<dim> &two_merged_boxes_geometry_model =
+                Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model());
+
+              // for the box geometry, choose a point at the center of the bottom face.
+              // (note that the loop only runs over the first dim-1 coordinates, leaving
+              // the depth variable at zero)
+              mid_point = two_merged_boxes_geometry_model.get_origin();
+              for (unsigned int i=0; i<dim-1; ++i)
+                mid_point(i) += 0.5 * two_merged_boxes_geometry_model.get_extents()[i];
+            }
+          else
+            AssertThrow (false,
+                         ExcMessage ("Not a valid geometry model for the initial temperature model"
+                                     "adiabatic."));
+        }
+
+      const double perturbation = (mid_point.distance(position) < radius) ? amplitude
+                                  : 0.0;
+
+
+      // add the subadiabaticity
+      const double zero_depth = 0.174;
+      const double nondimensional_depth = (this->get_geometry_model().depth(position) / this->get_geometry_model().maximal_depth() - zero_depth)
+                                          / (1.0 - zero_depth);
+      double subadiabatic_T = 0.0;
+      if (nondimensional_depth > 0)
+        subadiabatic_T = -subadiabaticity * nondimensional_depth * nondimensional_depth;
+
+      // If adiabatic heating is disabled, apply all perturbations to
+      // constant adiabatic surface temperature instead of adiabatic profile.
+      const double temperature_profile = (this->include_adiabatic_heating())
+                                         ?
+                                         this->get_adiabatic_conditions().temperature(position)
+                                         :
+                                         adiabatic_surface_temperature;
+
+      // return sum of the adiabatic profile, the boundary layer temperatures and the initial
+      // temperature perturbation.
+      return temperature_profile + surface_cooling_temperature
+             + (perturbation > 0.0 ? std::max(bottom_heating_temperature + subadiabatic_T,perturbation)
+                : bottom_heating_temperature + subadiabatic_T);
+    }
+
+    template <int dim>
+    void
+    Adiabatic<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                          "$ASPECT_SOURCE_DIR/data/initial-temperature/adiabatic/",
+                                                          "adiabatic.txt",
+                                                          "Adiabatic");
+        prm.enter_subsection("Adiabatic");
+        {
+          prm.declare_entry ("Age top boundary layer", "0.",
+                             Patterns::Double (0.),
+                             "The age of the upper thermal boundary layer, used for the calculation "
+                             "of the half-space cooling model temperature. Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+          prm.declare_entry ("Age bottom boundary layer", "0.",
+                             Patterns::Double (0.),
+                             "The age of the lower thermal boundary layer, used for the calculation "
+                             "of the half-space cooling model temperature. Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+          prm.declare_entry ("Radius", "0.",
+                             Patterns::Double (0.),
+                             "The Radius (in m) of the initial spherical temperature perturbation "
+                             "at the bottom of the model domain.");
+          prm.declare_entry ("Amplitude", "0.",
+                             Patterns::Double (0.),
+                             "The amplitude (in K) of the initial spherical temperature perturbation "
+                             "at the bottom of the model domain. This perturbation will be added to "
+                             "the adiabatic temperature profile, but not to the bottom thermal "
+                             "boundary layer. Instead, the maximum of the perturbation and the bottom "
+                             "boundary layer temperature will be used.");
+          prm.declare_entry ("Position", "center",
+                             Patterns::Selection ("center"),
+                             "Where the initial temperature perturbation should be placed. If `center' is "
+                             "given, then the perturbation will be centered along a `midpoint' of some "
+                             "sort of the bottom boundary. For example, in the case of a box geometry, "
+                             "this is the center of the bottom face; in the case of a spherical shell "
+                             "geometry, it is along the inner surface halfway between the bounding "
+                             "radial lines.");
+          prm.declare_entry ("Subadiabaticity", "0.",
+                             Patterns::Double (0.),
+                             "If this value is larger than 0, the initial temperature profile will "
+                             "not be adiabatic, but subadiabatic. This value gives the maximal "
+                             "deviation from adiabaticity. Set to 0 for an adiabatic temperature "
+                             "profile. Units: \\si{\\kelvin}.\n\n"
+                             "The function object in the Function subsection "
+                             "represents the compositional fields that will be used as a reference "
+                             "profile for calculating the thermal diffusivity. "
+                             "This function is one-dimensional and depends only on depth. The format of this "
+                             "functions follows the syntax understood by the "
+                             "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.");
+          prm.declare_entry ("Top boundary layer age model", "constant",
+                             Patterns::Selection ("constant|function|ascii data"),
+                             "How to define the age of the top thermal boundary layer. "
+                             "Options are: 'constant' for a constant age specified by the "
+                             "parameter 'Age top boundary layer'; 'function' for an analytical "
+                             "function describing the age as specified in the subsection "
+                             "'Age function'; and 'ascii data' to use an 'ascii data' file "
+                             "specified by the parameter 'Data file name'.");
+          prm.declare_entry ("Cooling model", "half-space cooling",
+                             Patterns::Selection ("half-space cooling|plate cooling"),
+                             "Whether to use the half space cooling model or the plate cooling model");
+          prm.declare_entry ("Lithosphere thickness", "125e3",
+                             Patterns::Double (0.),
+                             "Thickness of the lithosphere for plate cooling model. \\si{\\m}");
+
+          prm.enter_subsection("Function");
+          {
+            Functions::ParsedFunction<1>::declare_parameters (prm, 1);
+          }
+          prm.leave_subsection();
+
+          prm.enter_subsection("Age function");
+          {
+            /**
+             * Choose the coordinates to evaluate the age
+             * function. The function can be declared in dependence of depth,
+             * cartesian coordinates or spherical coordinates. Note that the order
+             * of spherical coordinates is r,phi,theta and not r,theta,phi, since
+             * this allows for dimension independent expressions.
+             */
+            prm.declare_entry ("Coordinate system", "cartesian",
+                               Patterns::Selection ("cartesian|spherical"),
+                               "A selection that determines the assumed coordinate "
+                               "system for the function variables. Allowed values "
+                               "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                               "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                               "respectively with theta being the polar angle. `depth' "
+                               "will create a function, in which only the first "
+                               "parameter is non-zero, which is interpreted to "
+                               "be the depth of the point.");
+
+            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    Adiabatic<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // we need to get the number of compositional fields here to
+      // initialize the function parser. unfortunately, we can't get it
+      // via SimulatorAccess from the simulator itself because at the
+      // current point the SimulatorAccess hasn't been initialized
+      // yet. so get it from the parameter file directly.
+      prm.enter_subsection ("Compositional fields");
+      const unsigned int n_compositional_fields = prm.get_integer ("Number of fields");
+      prm.leave_subsection ();
+
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataBase<dim>::parse_parameters(prm, "Adiabatic");
+
+        prm.enter_subsection("Adiabatic");
+        {
+          top_boundary_layer_age_model = BoundaryLayerAgeModel::parse("Top boundary layer age model",
+                                                                      prm);
+
+          age_top_boundary_layer = prm.get_double ("Age top boundary layer");
+          age_bottom_boundary_layer = prm.get_double ("Age bottom boundary layer");
+
+          radius = prm.get_double ("Radius");
+          amplitude = prm.get_double ("Amplitude");
+          perturbation_position = prm.get("Position");
+
+          subadiabaticity = prm.get_double ("Subadiabaticity");
+
+          cooling_model = prm.get ("Cooling model");
+          lithosphere_thickness = prm.get_double ("Lithosphere thickness");
+
+          if (n_compositional_fields > 0)
+            {
+              prm.enter_subsection("Function");
+              try
+                {
+                  function
+                    = std::make_unique<Functions::ParsedFunction<1>>(n_compositional_fields);
+                  function->parse_parameters (prm);
+                }
+              catch (...)
+                {
+                  std::cerr << "ERROR: FunctionParser failed to parse\n"
+                            << "\t'Initial temperature model.Adiabatic.Function'\n"
+                            << "with expression\n"
+                            << "\t'" << prm.get("Function expression") << "'"
+                            << "More information about the cause of the parse error \n"
+                            << "is shown below.\n";
+                  throw;
+                }
+
+              prm.leave_subsection();
+            }
+
+          prm.enter_subsection("Age function");
+          {
+            coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+          }
+          try
+            {
+              age_function.parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Initial temperature model.Adiabatic.Age Function'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+
+          prm.leave_subsection();
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(Adiabatic,
+                                              "adiabatic",
+                                              "Temperature is prescribed as an adiabatic "
+                                              "profile with upper and lower thermal boundary layers, "
+                                              "whose ages are given as input parameters. "
+                                              "Note that this plugin uses the 'Adiabatic conditions model' "
+                                              "to compute the adiabat. Thus, the results depend on variables "
+                                              "defined outside of this specific subsection; "
+                                              "e.g. the globally defined 'Adiabatic surface temperature', "
+                                              "and the variables defined in the 'Material model' section "
+                                              "including densities, heat capacities and thermal expansivities.")
+  }
+}
diff --git a/source/initial_temperature/adiabatic_boundary.cc.bak b/source/initial_temperature/adiabatic_boundary.cc.bak
new file mode 100644
index 00000000000..c9c5e2f17c8
--- /dev/null
+++ b/source/initial_temperature/adiabatic_boundary.cc.bak
@@ -0,0 +1,136 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/adiabatic_boundary.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/utilities.h>
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    AdiabaticBoundary<dim>::AdiabaticBoundary ()
+      :
+      surface_boundary_id(numbers::invalid_unsigned_int)
+    {}
+
+    template <int dim>
+    void
+    AdiabaticBoundary<dim>::initialize ()
+    {
+      // Find the boundary indicator that represents the surface
+      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+      std::set<types::boundary_id> surface_boundary_set;
+      surface_boundary_set.insert(surface_boundary_id);
+
+      // The input ascii table contains one data column (LAB depths(m)) in addition to the coordinate columns.
+      Utilities::AsciiDataBoundary<dim>::initialize(surface_boundary_set,
+                                                    1);
+    }
+
+    template <int dim>
+    double
+    AdiabaticBoundary<dim>::initial_temperature (const Point<dim> &position) const
+    {
+      const double depth = this->get_geometry_model().depth(position);
+      const double isotherm_depth              =
+        Utilities::AsciiDataBoundary<dim>::get_data_component(surface_boundary_id, position, 0);
+      if (depth > isotherm_depth)
+        return isotherm_temperature + (depth - isotherm_depth) * temperature_gradient;
+      else
+        return surface_temperature + (depth/isotherm_depth) * (isotherm_temperature - surface_temperature);
+    }
+
+    template <int dim>
+    void
+    AdiabaticBoundary<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                          "$ASPECT_SOURCE_DIR/data/initial-temperature/adiabatic-boundary/",
+                                                          "adiabatic_boundary.txt",
+                                                          "Adiabatic boundary");
+        prm.enter_subsection("Adiabatic boundary");
+        {
+          prm.declare_entry ("Isotherm temperature", "1673.15",
+                             Patterns::Double (0.),
+                             "The value of the isothermal boundary temperature. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Surface temperature", "273.15",
+                             Patterns::Double (0.),
+                             "The value of the surface temperature. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Adiabatic temperature gradient", "0.0005",
+                             Patterns::Double (0.),
+                             "The value of the adiabatic temperature gradient. "
+                             "Units: \\si{\\kelvin\\per\\meter}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    AdiabaticBoundary<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataBase<dim>::parse_parameters(prm,"Adiabatic boundary");
+
+        prm.enter_subsection("Adiabatic boundary");
+        {
+          isotherm_temperature = prm.get_double("Isotherm temperature");
+          surface_temperature  = prm.get_double("Surface temperature");
+          temperature_gradient = prm.get_double("Adiabatic temperature gradient");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AdiabaticBoundary,
+                                              "adiabatic boundary",
+                                              "An initial temperature condition that allows for discretizing "
+                                              "the model domain into two layers separated by a user-defined "
+                                              "isothermal boundary. The user includes an input ascii data file "
+                                              "that is formatted as 3 columns of `longitude(radians)', "
+                                              "`colatitude(radians)', and `isotherm depth(meters)', where `isotherm depth' represents the depth "
+                                              "of an initial temperature of 1673.15 K (by default). "
+                                              "The first lines in the data file may contain any number of comments if they begin "
+                                              "with `#', but one of these lines needs to contain the number of grid points "
+                                              "in each dimension as for example `# POINTS: 69 121'. Note that the coordinates need "
+                                              "to be sorted in a specific order: the `longitude' coordinate needs to ascend first, "
+                                              "followed by the `colatitude' coordinate in order to assign the correct data (isotherm depth) to the "
+                                              "prescribed coordinates. "
+                                              "The temperature is defined from the surface (273.15 K) to the isotherm depth (1673.15 K) "
+                                              "as a linear gradient. Below the isotherm depth the temperature increases "
+                                              "approximately adiabatically (0.0005 K per meter). "
+                                              "This plugin should work for all geometry models, but is currently only tested for spherical models.")
+  }
+}
diff --git a/source/initial_temperature/ascii_data.cc.bak b/source/initial_temperature/ascii_data.cc.bak
new file mode 100644
index 00000000000..3af027f8b17
--- /dev/null
+++ b/source/initial_temperature/ascii_data.cc.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/initial_temperature/ascii_data.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      Utilities::AsciiDataInitial<dim>::initialize(1);
+    }
+
+
+    template <int dim>
+    double
+    AsciiData<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      return Utilities::AsciiDataInitial<dim>::get_data_component(position,0);
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataInitial<dim>::declare_parameters(prm,
+                                                             "$ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/",
+                                                             "box_2d.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataInitial<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AsciiData,
+                                              "ascii data",
+                                              "Implementation of a model in which the initial "
+                                              "temperature is derived from files containing data "
+                                              "in ascii format. Note the required format of the "
+                                              "input data: The first lines may contain any number of comments "
+                                              "if they begin with `#', but one of these lines needs to "
+                                              "contain the number of grid points in each dimension as "
+                                              "for example `# POINTS: 3 3'. "
+                                              "The order of the data columns "
+                                              "has to be `x', `y', `Temperature [K]' in a 2d model and "
+                                              " `x', `y', `z', `Temperature [K]' in a 3d model, which means that "
+                                              "there has to be a single column "
+                                              "containing the temperature. "
+                                              "Note that the data in the input "
+                                              "files need to be sorted in a specific order: "
+                                              "the first coordinate needs to ascend first, "
+                                              "followed by the second and the third at last in order to "
+                                              "assign the correct data to the prescribed coordinates. "
+                                              "If you use a spherical model, "
+                                              "then the assumed grid changes. `x' will be replaced by "
+                                              "the radial distance of the point to the bottom of the model, "
+                                              "`y' by the azimuth angle and `z' by the polar angle measured "
+                                              "positive from the north pole. The grid will be assumed to be "
+                                              "a latitude-longitude grid. Note that the order "
+                                              "of spherical coordinates is `r', `phi', `theta' "
+                                              "and not `r', `theta', `phi', since this allows "
+                                              "for dimension independent expressions.")
+  }
+}
diff --git a/source/initial_temperature/ascii_data_layered.cc.bak b/source/initial_temperature/ascii_data_layered.cc.bak
new file mode 100644
index 00000000000..10d687f8821
--- /dev/null
+++ b/source/initial_temperature/ascii_data_layered.cc.bak
@@ -0,0 +1,124 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/initial_temperature/ascii_data_layered.h>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    AsciiDataLayered<dim>::AsciiDataLayered ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiDataLayered<dim>::initialize ()
+    {
+      // The ascii data layered class has dim-1 spatial columns
+      // (which provide the horizontal coordinates of the layer).
+      // We need another 2 columns; the first for the depth
+      // of the layer at the given horizontal coordinates,
+      // and the second for temperature (for cases where
+      // temperature varies across the layer).
+      Utilities::AsciiDataLayered<dim>::initialize(2);
+    }
+
+
+    template <int dim>
+    double
+    AsciiDataLayered<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // This is where we get the initial temperature
+      return Utilities::AsciiDataLayered<dim>::get_data_component(position,1);
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataLayered<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataLayered<dim>::declare_parameters(prm,
+                                                             "$ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/",
+                                                             "initial_isotherm_500K_box_3d.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataLayered<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataLayered<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AsciiDataLayered,
+                                              "ascii data layered",
+                                              "Implementation of a model in which the initial "
+                                              "temperature is derived from files containing data "
+                                              "in ascii format. Each file defines a surface on which "
+                                              "temperature is defined. "
+                                              "Between the surfaces, the temperatures can be chosen to be "
+                                              "constant (with a value defined by the nearest shallower "
+                                              "surface), or linearly interpolated between surfaces. "
+                                              "Note the required format of the input ascii data file: "
+                                              "The first lines may contain any number of comments "
+                                              "if they begin with `#', but one of these lines needs to "
+                                              "contain the number of grid points in each dimension as "
+                                              "for example `# POINTS: 3 3'. "
+                                              "The order of the data columns "
+                                              "has to be `x', `y', `Temperature [K]' in a 2d model and "
+                                              "`x', `y', `z', `Temperature [K]' in a 3d model; i.e. "
+                                              "the last two columns always contain the position of the "
+                                              "isotherm along the vertical direction, and the temperature "
+                                              "at that point. The first column needs to ascend first, "
+                                              "followed by the second in order to assign the correct data "
+                                              "to the prescribed coordinates. If you use a spherical model, "
+                                              "then the assumed grid changes. `x' will be replaced by the "
+                                              "azimuth angle and `y' (if 3d) by the polar angle measured "
+                                              "positive from the north pole. The last column will be the "
+                                              "distance of the point from the origin "
+                                              "(i.e. radial position). The grid in this case will be "
+                                              "a latitude-longitude grid. Note that the order "
+                                              "of spherical coordinates in 3d is `phi', `theta', `r', `T'"
+                                              "and not `theta', `phi', `r', `T' as this is "
+                                              "more consistent with other ASPECT plugins. Outside of the "
+                                              "region defined by the grid, the plugin will use the value "
+                                              "at the edge of the region.")
+  }
+}
diff --git a/source/initial_temperature/ascii_profile.cc.bak b/source/initial_temperature/ascii_profile.cc.bak
new file mode 100644
index 00000000000..49091c317c4
--- /dev/null
+++ b/source/initial_temperature/ascii_profile.cc.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/initial_temperature/ascii_profile.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    AsciiProfile<dim>::AsciiProfile ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiProfile<dim>::initialize ()
+    {
+      this->initialize(this->get_mpi_communicator());
+      temperature_index = this->get_column_index_from_name("temperature");
+    }
+
+
+
+    template <int dim>
+    double AsciiProfile<dim>::initial_temperature (const Point<dim> &p) const
+    {
+      const double depth = this->get_geometry_model().depth(p);
+      return this->get_data_component(Point<1>(depth),temperature_index);
+    }
+
+
+    template <int dim>
+    void
+    AsciiProfile<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                          "$ASPECT_SOURCE_DIR/data/initial-temperature/ascii-profile/tests/",
+                                                          "simple_test.txt",
+                                                          "Ascii profile");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiProfile<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        Utilities::AsciiDataBase<dim>::parse_parameters(prm,
+                                                        "Ascii profile");
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AsciiProfile,
+                                              "ascii profile",
+                                              "Implementation of a model in which the initial temperature is "
+                                              "read from a file that provides these values as a function of "
+                                              "depth. Note the required format of the input data: The first "
+                                              "lines may contain any number of comments if they begin with "
+                                              "`#', but one of these lines needs to contain the number of "
+                                              "points in the temperature profile, for example `# POINTS: 10'. "
+                                              "Following the comment lines, there has to be a single line "
+                                              "containing the names of all data columns, separated by arbitrarily "
+                                              "many spaces. Column names are not allowed to contain spaces. "
+                                              "The file can contain unnecessary columns, but for this plugin it "
+                                              "needs to at least provide columns named `depth' and"
+                                              "`temperature'."
+                                              "Note that the data lines in the file need to be sorted in order "
+                                              "of increasing depth from 0 to the maximal depth in the model "
+                                              "domain. Points in the model that are outside of the provided "
+                                              "depth range will be assigned the maximum or minimum depth values, "
+                                              "respectively. Points do not need to be equidistant, "
+                                              "but the computation of properties is optimized in speed "
+                                              "if they are.")
+  }
+}
diff --git a/source/initial_temperature/box.cc.bak b/source/initial_temperature/box.cc.bak
new file mode 100644
index 00000000000..bdf58376da9
--- /dev/null
+++ b/source/initial_temperature/box.cc.bak
@@ -0,0 +1,276 @@
+/*
+  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/box.h>
+#include <aspect/geometry_model/box.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    double
+    PerturbedBox<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // this initial condition only makes sense if the geometry is a
+      // Box. verify that it is indeed
+      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
+                   ExcMessage ("This initial condition can only be used if the geometry "
+                               "is a box."));
+
+      const GeometryModel::Box<dim> &geometry
+        = Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
+
+      double perturbation = 1;
+      for (unsigned int d=0; d<dim; ++d)
+        perturbation *= std::sin(numbers::PI*(position[d]-geometry.get_origin()[d])/geometry.get_extents()[d]);
+      return 1 + perturbation/10;
+    }
+
+    template <int dim>
+    double
+    PolarBox<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // this initial condition only makes sense if the geometry is a
+      // Box. verify that it is indeed
+      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
+                   ExcMessage ("This initial condition can only be used if the geometry "
+                               "is a box."));
+
+      const GeometryModel::Box<dim> &geometry
+        = Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
+
+      Point<dim> temporary1, temporary2;
+      for (int d=0; d<dim; ++d)
+        {
+          temporary1[d]=geometry.get_extents()[d]*0.625+geometry.get_origin()[d];
+          temporary2[d]=geometry.get_extents()[d]*0.375+geometry.get_origin()[d];
+        }
+
+      return 1+(1/exp(position.distance(temporary2)) - 1/exp(position.distance(temporary1)));
+    }
+
+    template <int dim>
+    double
+    MandelBox<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // this initial condition only makes sense if the geometry is a
+      // box. verify that it is indeed
+      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
+                   ExcMessage ("This initial condition can only be used if the geometry "
+                               "is a box."));
+
+      const GeometryModel::Box<dim> &geometry
+        = Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
+
+      double perturbation, ratio;
+      Point<dim> center;
+      ratio = center[0] = geometry.get_extents()[0]*0.66;
+      center[1] = geometry.get_extents()[1]*0.5;
+      if (center[1] < ratio)
+        ratio = center[1];
+
+      double zx = (position[0] - geometry.get_origin()[0] - center[0])/ratio;
+      double zy = (position[1] - geometry.get_origin()[1] - center[1])/ratio;
+      double x = zx;
+      double y = zy;
+
+      for (perturbation = 0; perturbation < 50 && (Point<2>(x,y)).norm() <= 2; ++perturbation)
+        {
+          x = x*x - y*y + zx;
+          y = 2 * x*y + zy;
+        }
+      return perturbation / 50;
+    }
+
+
+
+    template <int dim>
+    double
+    InclusionShapeBox<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // this initial condition only makes sense if the geometry is a
+      // box. verify that it is indeed
+      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
+                   ExcMessage ("This initial condition can only be used if the geometry "
+                               "is a box."));
+
+      double perturbation = 0;
+      Point<dim> center;
+      for (int d=0; d<dim; ++d)
+        center[d] = (Point<3>(center_x,center_y,center_z))[d];
+
+      if (inclusion_shape == "square")
+        {
+          if (inclusion_gradient == "gaussian")
+            {
+              perturbation = inclusion_temperature - ambient_temperature;
+              for (int d=0; d<dim; ++d)
+                perturbation *= exp(-8*pow(position.distance(center)/radius, 2));
+            }
+          else if (inclusion_gradient == "linear")
+            {
+              double x = position[0] - center[0];
+              double y = position[1] - center[1];
+              if ( x <= y && x >= -y)
+                perturbation = radius - y;
+              else if (x <= y && x <= -y)
+                perturbation = radius + x;
+              else if (x >= y && x >= -y)
+                perturbation = radius - x;
+              else if (x >= y && x <= -y)
+                perturbation = radius + y;
+              perturbation *= (inclusion_temperature - ambient_temperature) / radius;
+            }
+          else if (inclusion_gradient == "constant")
+            {
+              perturbation = inclusion_temperature - ambient_temperature;
+            }
+          for (int d = 0; d < dim; ++d)
+            if (abs (center[d] - position[d]) > radius)
+              perturbation = 0;
+        }
+      else if (inclusion_shape == "circle")
+        {
+          if (inclusion_gradient == "gaussian")
+            {
+              perturbation = inclusion_temperature - ambient_temperature;
+              perturbation *= exp(-pow(position.distance(center),2) / (2 * pow((radius / 4), 2))) / (2 * radius);
+            }
+          else if (inclusion_gradient == "linear")
+            {
+              perturbation = ((radius - position.distance(center)) / radius) * (inclusion_temperature - ambient_temperature);
+            }
+          else if (inclusion_gradient == "constant")
+            {
+              perturbation = inclusion_temperature - ambient_temperature;
+            }
+          if (position.distance(center) > radius)
+            perturbation = 0;
+        }
+
+      return ambient_temperature + perturbation;
+    }
+
+    template <int dim>
+    void
+    InclusionShapeBox<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection ("Inclusion shape perturbation");
+        {
+          prm.declare_entry("Inclusion shape", "circle",
+                            Patterns::Selection("square|circle"),
+                            "The shape of the inclusion to be generated.");
+          prm.declare_entry("Inclusion gradient", "constant",
+                            Patterns::Selection("gaussian|linear|constant"),
+                            "The gradient of the inclusion to be generated.");
+          prm.declare_entry("Shape radius", "1.0",
+                            Patterns::Double (0.),
+                            "The radius of the inclusion to be generated. For "
+                            "shapes with no radius (e.g. square), this will "
+                            "be the width, and for shapes with no width, this "
+                            "gives a general guideline for the size of the shape.");
+          prm.declare_entry("Ambient temperature", "1.0",
+                            Patterns::Double (),
+                            "The background temperature for the temperature field.");
+          prm.declare_entry("Inclusion temperature", "0.0",
+                            Patterns::Double (),
+                            "The temperature of the inclusion shape. This is only "
+                            "the true temperature in the case of the constant "
+                            "gradient. In all other cases, it gives one endpoint "
+                            "of the temperature gradient for the shape.");
+          prm.declare_entry("Center X", "0.5",
+                            Patterns::Double (),
+                            "The X coordinate for the center of the shape.");
+          prm.declare_entry("Center Y", "0.5",
+                            Patterns::Double (),
+                            "The Y coordinate for the center of the shape.");
+          prm.declare_entry("Center Z", "0.5",
+                            Patterns::Double (),
+                            "The Z coordinate for the center of the shape. This "
+                            "is only necessary for three-dimensional fields.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+    template <int dim>
+    void
+    InclusionShapeBox<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Inclusion shape perturbation");
+        {
+          inclusion_shape = prm.get ("Inclusion shape");
+          inclusion_gradient = prm.get ("Inclusion gradient");
+          radius = prm.get_double ("Shape radius");
+          ambient_temperature = prm.get_double ("Ambient temperature");
+          inclusion_temperature = prm.get_double ("Inclusion temperature");
+          center_x = prm.get_double ("Center X");
+          center_y = prm.get_double ("Center Y");
+          center_z = prm.get_double ("Center Z");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(PerturbedBox,
+                                              "perturbed box",
+                                              "An initial temperature field in which the temperature "
+                                              "is perturbed slightly from an otherwise constant value "
+                                              "equal to one. The perturbation is chosen in such a way "
+                                              "that the initial temperature is constant to one along "
+                                              "the entire boundary.")
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(PolarBox,
+                                              "polar box",
+                                              "An initial temperature field in which the temperature "
+                                              "is perturbed slightly from an otherwise constant value "
+                                              "equal to one. The perturbation is such that there are "
+                                              "two poles on opposing corners of the box. ")
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(InclusionShapeBox,
+                                              "inclusion shape perturbation",
+                                              "An initial temperature field in which there is an "
+                                              "inclusion in a constant-temperature box field. The size, "
+                                              "shape, gradient, position, and temperature of the "
+                                              "inclusion are defined by parameters.")
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(MandelBox,
+                                              "mandelbox",
+                                              "Fractal-shaped temperature field.")
+  }
+}
diff --git a/source/initial_temperature/continental_geotherm.cc.bak b/source/initial_temperature/continental_geotherm.cc.bak
new file mode 100644
index 00000000000..59c5b4bf941
--- /dev/null
+++ b/source/initial_temperature/continental_geotherm.cc.bak
@@ -0,0 +1,269 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/continental_geotherm.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/material_model/visco_plastic.h>
+#include <aspect/heating_model/interface.h>
+
+#include <cmath>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    ContinentalGeotherm<dim>::ContinentalGeotherm ()
+      = default;
+
+
+    template <int dim>
+    void
+    ContinentalGeotherm<dim>::
+    initialize ()
+    {
+      // Check that the required radioactive heating model ("compositional heating") is used
+      const std::vector<std::string> &heating_models = this->get_heating_model_manager().get_active_heating_model_names();
+      AssertThrow(std::find(heating_models.begin(), heating_models.end(), "compositional heating") != heating_models.end(),
+                  ExcMessage("The continental geotherm initial temperature plugin requires the compositional heating plugin."));
+
+      // Check that the required material model ("visco plastic") is used
+      AssertThrow(Plugins::plugin_type_matches<MaterialModel::ViscoPlastic<dim>>(this->get_material_model()),
+                  ExcMessage("The continental geotherm initial temperature plugin requires the viscoplastic material model plugin."));
+    }
+
+
+    template <int dim>
+    double
+    ContinentalGeotherm<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // Get the depth of the point with respect to the reference surface.
+      const double depth = this->get_geometry_model().depth(position);
+
+      // Compute some constants to calculate the temperatures T1 and T2 at the interfaces
+      // between the layers upper crust/lower crust (depth y=h1) and lower crust/lithospheric mantle (depth y=h1+h2).
+      // T1 = (ab + k2/h2 cdb) / (1 - k2^2/h2^2 db)
+      // T2 = (c + k2/h2 T1) d
+      // These derivations are based on the assumption that at the boundary between
+      // the layers, the heat flows of the two layers are equal, so
+      // at y=h1, q1(h1)=q2(h2)=k1 dT1/dy|h1 = k2 dT2/dy|h2 etc.
+      const double a = 0.5*densities[0]*heat_productivities[0]*thicknesses[0] + 0.5*densities[1]*heat_productivities[1]*thicknesses[1] + conductivities[0]/thicknesses[0]*T0;
+      const double b = 1./(conductivities[0]/thicknesses[0]+conductivities[1]/thicknesses[1]);
+      const double c = 0.5*densities[1]*heat_productivities[1]*thicknesses[1] + conductivities[2]/thicknesses[2]*LAB_isotherm;
+      const double d = 1./(conductivities[1]/thicknesses[1]+conductivities[2]/thicknesses[2]);
+
+      // Temperature at boundary between layer 1 and 2
+      const double T1 = (a*b + conductivities[1]/thicknesses[1]*c*d*b) / (1.-(conductivities[1]*conductivities[1])/(thicknesses[1]*thicknesses[1])*d*b);
+      // Temperature at boundary between layer 2 and 3
+      const double T2 = (c + conductivities[1]/thicknesses[1]*T1) * d;
+
+      // Temperature in layer 1
+      if (depth <= thicknesses[0])
+        return -0.5*densities[0]*heat_productivities[0]/conductivities[0]*std::pow(depth,2) + (0.5*densities[0]*heat_productivities[0]*thicknesses[0]/conductivities[0] + (T1-T0)/thicknesses[0])*depth + T0;
+      // Temperature in layer 2
+      else if (depth <= thicknesses[0]+thicknesses[1])
+        return -0.5*densities[1]*heat_productivities[1]/conductivities[1]*std::pow(depth-thicknesses[0],2.) + (0.5*densities[1]*heat_productivities[1]*thicknesses[1]/conductivities[1] + (T2-T1)/thicknesses[1])*(depth-thicknesses[0]) + T1;
+      // Temperature in layer 3
+      else if (depth <= thicknesses[0]+thicknesses[1]+thicknesses[2])
+        return (LAB_isotherm-T2)/thicknesses[2] *(depth-thicknesses[0]-thicknesses[1]) + T2;
+      // Return an unrealistically high temperature if we're below the lithosphere.
+      // This way we can combine the continental geotherm with an adiabatic profile from the input file
+      // using the "minimum" operator on the "List of initial temperature models"
+      else
+        return std::numeric_limits<double>::max();
+    }
+
+
+
+    template <int dim>
+    void
+    ContinentalGeotherm<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Continental geotherm");
+        {
+          prm.declare_entry ("Layer thicknesses", "30000.",
+                             Patterns::List(Patterns::Double(0.)),
+                             "List of the 3 thicknesses of the lithospheric layers "
+                             "'upper\\_crust', 'lower\\_crust' and 'mantle\\_lithosphere'. "
+                             "If only one thickness is given, then the same thickness is used "
+                             "for all layers. Units: \\si{meter}.");
+          prm.declare_entry ("Surface temperature", "273.15",
+                             Patterns::Double (0.),
+                             "The value of the surface temperature. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Lithosphere-Asthenosphere boundary isotherm", "1673.15",
+                             Patterns::Double (0.),
+                             "The value of the isotherm that is assumed at the Lithosphere-"
+                             "Asthenosphere boundary. Units: \\si{\\kelvin}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ContinentalGeotherm<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      unsigned int n_fields = 0;
+      prm.enter_subsection ("Compositional fields");
+      {
+        n_fields = prm.get_integer ("Number of fields");
+      }
+      prm.leave_subsection();
+
+
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Continental geotherm");
+        {
+          LAB_isotherm = prm.get_double ("Lithosphere-Asthenosphere boundary isotherm");
+          T0 = prm.get_double ("Surface temperature");
+          thicknesses = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Layer thicknesses"))),
+                                                                3,
+                                                                "Layer thicknesses");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+
+      // Retrieve the indices of the fields that represent the lithospheric layers.
+      AssertThrow(this->introspection().compositional_name_exists("upper_crust"),ExcMessage("We need a compositional field called 'upper_crust' representing the upper crust."));
+      AssertThrow(this->introspection().compositional_name_exists("lower_crust"),ExcMessage("We need a compositional field called 'lower_crust' representing the lower crust."));
+      AssertThrow(this->introspection().compositional_name_exists("lithospheric_mantle"),ExcMessage("We need a compositional field called 'lithospheric_mantle' representing the lithospheric part of the mantle."));
+
+      // For now, we assume a 3-layer system with an upper crust, lower crust and lithospheric mantle
+      const unsigned int id_upper_crust = this->introspection().compositional_index_for_name("upper_crust");
+      const unsigned int id_lower_crust = this->introspection().compositional_index_for_name("lower_crust");
+      const unsigned int id_lithospheric_mantle = this->introspection().compositional_index_for_name("lithospheric_mantle");
+
+      // Retrieve other material properties set in different sections such that there
+      // is no need to set them twice.
+
+      prm.enter_subsection("Heating model");
+      {
+        prm.enter_subsection("Compositional heating");
+        {
+          // The heating model compositional heating prefixes an entry for the background material
+          const std::vector<double> temp_heat_productivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Compositional heating values"))),
+                                                               n_fields+1,
+                                                               "Compositional heating values");
+          // This sets the heat productivity in W/m3 units
+          heat_productivities.push_back(temp_heat_productivities[id_upper_crust+1]);
+          heat_productivities.push_back(temp_heat_productivities[id_lower_crust+1]);
+          heat_productivities.push_back(temp_heat_productivities[id_lithospheric_mantle+1]);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Visco Plastic");
+        {
+          // The material model viscoplastic prefixes an entry for the background material, hence n_fields+1
+          const std::vector<double> temp_densities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Densities"))),
+                                                     n_fields+1,
+                                                     "Densities");
+          const std::vector<double> temp_thermal_diffusivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal diffusivities"))),
+                                                                 n_fields+1,
+                                                                 "Thermal diffusivities");
+          const std::vector<double> temp_heat_capacities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Heat capacities"))),
+                                                           n_fields+1,
+                                                           "Heat capacities");
+
+          // The material model viscoplastic prefixes an entry for the background material, hence id+1
+          densities.push_back(temp_densities[id_upper_crust+1]);
+          densities.push_back(temp_densities[id_lower_crust+1]);
+          densities.push_back(temp_densities[id_lithospheric_mantle+1]);
+
+          // Thermal diffusivity kappa = k/(rho*cp), so thermal conductivity k = kappa*rho*cp.
+          // The densities are already in the right order, so we don't need to use the compositional
+          // field ids.
+          conductivities.push_back(temp_thermal_diffusivities[id_upper_crust+1] * densities[0] * temp_heat_capacities[id_upper_crust+1]);
+          conductivities.push_back(temp_thermal_diffusivities[id_lower_crust+1] * densities[1] * temp_heat_capacities[id_lower_crust+1]);
+          conductivities.push_back(temp_thermal_diffusivities[id_lithospheric_mantle+1] * densities[2] * temp_heat_capacities[id_lithospheric_mantle+1]);
+
+          // To obtain the radioactive heating rate in W/kg, we divide the volumetric heating rate by density
+          AssertThrow(heat_productivities.size() == 3 && densities.size() == 3 && conductivities.size() == 3,
+                      ExcMessage("The entries for density, conductivity and heat production do not match with the expected number of layers (3)."));
+
+          for (unsigned int i = 0; i<3; ++i)
+            heat_productivities[i] /= densities[i];
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+
+
+}
+
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(ContinentalGeotherm,
+                                              "continental geotherm",
+                                              "This is a temperature initial condition that "
+                                              "computes a continental geotherm based on the solution of the "
+                                              "steady-state conductive equation $k\\frac{d^2 T}{dy^2}+\\rho H = 0$ "
+                                              "as described in e.g. Turcotte and Schubert, "
+                                              "Ch. 4.6, or Chapman (1986). As boundary conditions, we take the surface temperature and "
+                                              "the temperature of the Lithosphere-Asthenosphere Boundary (LAB). "
+                                              "\n"
+                                              "The geotherm is computed for a homogeneous lithosphere "
+                                              "composed of an upper crust, lower crust and mantle layer. "
+                                              "The crustal layers are assumed to have a constant radioactive heating, "
+                                              "and all layers are assumed to have a constant thermal conductivity. "
+                                              "Layer thicknesses, surface temperature and LAB temperature "
+                                              "should be specified by the user. "
+                                              "For consistency, the density, heat production and thermal "
+                                              "conductivity of each layer are read from the visco plastic material model "
+                                              "and the compositional heating model. "
+                                              "\n"
+                                              "For any depths below the depth of the LAB, a unrealistically high "
+                                              "temperature is returned, such that this plugin can be combined with "
+                                              "another temperature plugin through the 'minimum' operator. "
+                                              "\n"
+                                              "Note that the current implementation only works for a 3-layer lithosphere, "
+                                              "even though in principle the heat conduction equation can be solved "
+                                              "for any number of layers. The naming of the compositional fields "
+                                              "that represent the layers is also very specific, namely `upper\\_crust', "
+                                              "`lower\\_crust', and `lithospheric\\_mantle'. "
+                                              "\n"
+                                              "Make sure the top and bottom temperatures of the lithosphere "
+                                              "agree with temperatures set in for example the temperature "
+                                              "boundary conditions.")
+  }
+}
diff --git a/source/initial_temperature/function.cc.bak b/source/initial_temperature/function.cc.bak
new file mode 100644
index 00000000000..a02205ca056
--- /dev/null
+++ b/source/initial_temperature/function.cc.bak
@@ -0,0 +1,129 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/function.h>
+#include <aspect/utilities.h>
+#include <aspect/global.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <iostream>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    Function<dim>::Function ()
+      :
+      function (1)
+    {}
+
+    template <int dim>
+    double
+    Function<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      const Utilities::NaturalCoordinate<dim> point =
+        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
+
+      return function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
+    }
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Function");
+        {
+          /**
+           * Choose the coordinates to evaluate the maximum refinement level
+           * function. The function can be declared in dependence of depth,
+           * cartesian coordinates or spherical coordinates. Note that the order
+           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
+           * this allows for dimension independent expressions.
+           */
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle. `depth' "
+                             "will create a function, in which only the first "
+                             "parameter is non-zero, which is interpreted to "
+                             "be the depth of the point.");
+
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Function");
+        {
+          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+        }
+
+        try
+          {
+            function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Initial temperature model.Function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(Function,
+                                              "function",
+                                              "Specify the initial temperature in terms of an "
+                                              "explicit formula. The format of these "
+                                              "functions follows the syntax understood by the "
+                                              "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+  }
+}
diff --git a/source/initial_temperature/harmonic_perturbation.cc.bak b/source/initial_temperature/harmonic_perturbation.cc.bak
new file mode 100644
index 00000000000..ee78cf82bfe
--- /dev/null
+++ b/source/initial_temperature/harmonic_perturbation.cc.bak
@@ -0,0 +1,234 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/harmonic_perturbation.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    double
+    HarmonicPerturbation<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+
+      // use either the user-input reference temperature as background temperature
+      // (incompressible model) or the adiabatic temperature profile (compressible model)
+      const double background_temperature = this->include_adiabatic_heating() ?
+                                            this->get_adiabatic_conditions().temperature(position) :
+                                            reference_temperature;
+
+      // s = fraction of the way from
+      // the inner to the outer
+      // boundary; 0<=s<=1
+      const double s = this->get_geometry_model().depth(position) / this->get_geometry_model().maximal_depth();
+
+      const double depth_perturbation = std::sin(vertical_wave_number*s*numbers::PI);
+
+
+      double lateral_perturbation = 0.0;
+
+      if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::SphericalShell<dim> &spherical_geometry_model =
+            Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
+
+          // In case of spherical shell calculate spherical coordinates
+          const std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
+
+          if (dim==2)
+            {
+              // Use a sine as lateral perturbation that is scaled to the opening angle of the geometry.
+              // This way the perturbation is always 0 at the model boundaries.
+              const double opening_angle = spherical_geometry_model.opening_angle() * constants::degree_to_radians;
+              lateral_perturbation = std::sin(lateral_wave_number_1*scoord[1]*numbers::PI/opening_angle);
+            }
+
+          else if (dim==3)
+            {
+              // Spherical harmonics are only defined for order <= degree
+              // and degree >= 0. Verify that it is indeed.
+              Assert ( std::abs(lateral_wave_number_2) <= lateral_wave_number_1,
+                       ExcMessage ("Spherical harmonics can only be computed for "
+                                   "order <= degree."));
+              Assert ( lateral_wave_number_1 >= 0,
+                       ExcMessage ("Spherical harmonics can only be computed for "
+                                   "degree >= 0."));
+              // use a spherical harmonic function as lateral perturbation
+              std::pair<double,double> sph_harm_vals = Utilities::real_spherical_harmonic( lateral_wave_number_1, lateral_wave_number_2, scoord[2], scoord[1] );
+              // For historical reasons, this initial conditions module used an unnormalized real spherical harmonic.
+              // Here we denormalize the return value of real_spherical_harmonic to keep the original behavior.
+              lateral_perturbation = sph_harm_vals.first / ( lateral_wave_number_2 == 0 ? 1.0 : std::sqrt(2.) );
+            }
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::Chunk<dim> &chunk_geometry_model =
+            Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>> (this->get_geometry_model());
+
+          AssertThrow (dim == 2,
+                       ExcMessage ("Harmonic perturbation only implemented in 2d for chunk geometry"));
+
+          // In case of chunk calculate spherical coordinates
+          const std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
+
+          // Use a sine as lateral perturbation that is scaled to the opening angle of the geometry.
+          // This way the perturbation is always 0 at the model boundaries.
+          const double opening_angle = chunk_geometry_model.longitude_range(); // in radians
+          const double start_angle = chunk_geometry_model.west_longitude(); // in radians
+          lateral_perturbation = std::sin((lateral_wave_number_1*(scoord[1]-start_angle))*numbers::PI/opening_angle);
+
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::Box<dim> &box_geometry_model =
+            Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
+
+          // In case of Box model use a sine as lateral perturbation
+          // that is scaled to the extent of the geometry.
+          // This way the perturbation is always 0 at the model borders.
+          const Point<dim> extent = box_geometry_model.get_extents();
+
+          if (dim==2)
+            {
+              lateral_perturbation = std::sin(lateral_wave_number_1*position(0)*numbers::PI/extent(0));
+            }
+          else if (dim==3)
+            {
+              lateral_perturbation = std::sin(lateral_wave_number_1*position(0)*numbers::PI/extent(0))
+                                     * std::sin(lateral_wave_number_2*position(1)*numbers::PI/extent(1));
+            }
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::TwoMergedBoxes<dim> &two_merged_boxes_geometry_model =
+            Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model());
+
+          // In case of Box model use a sine as lateral perturbation
+          // that is scaled to the extent of the geometry.
+          // This way the perturbation is always 0 at the model borders.
+          const Point<dim> extent = two_merged_boxes_geometry_model.get_extents();
+
+          if (dim==2)
+            {
+              lateral_perturbation = std::sin(lateral_wave_number_1*position(0)*numbers::PI/extent(0));
+            }
+          else if (dim==3)
+            {
+              lateral_perturbation = std::sin(lateral_wave_number_1*position(0)*numbers::PI/extent(0))
+                                     * std::sin(lateral_wave_number_2*position(1)*numbers::PI/extent(1));
+            }
+        }
+      else
+        AssertThrow (false,
+                     ExcMessage ("Not a valid geometry model for the initial conditions model "
+                                 "harmonic perturbation."));
+
+      return background_temperature + magnitude * depth_perturbation * lateral_perturbation;
+    }
+
+    template <int dim>
+    void
+    HarmonicPerturbation<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Harmonic perturbation");
+        {
+          prm.declare_entry ("Vertical wave number", "1",
+                             Patterns::Integer (),
+                             "Doubled radial wave number of the harmonic perturbation. "
+                             " One equals half of a sine period over the model domain. "
+                             " This allows for single up-/downswings. Negative numbers "
+                             " reverse the sign of the perturbation.");
+          prm.declare_entry ("Lateral wave number one", "3",
+                             Patterns::Integer (),
+                             "Doubled first lateral wave number of the harmonic perturbation. "
+                             "Equals the spherical harmonic degree in 3d spherical shells. "
+                             "In all other cases one equals half of a sine period over "
+                             "the model domain. This allows for single up-/downswings. "
+                             "Negative numbers reverse the sign of the perturbation but are "
+                             "not allowed for the spherical harmonic case.");
+          prm.declare_entry ("Lateral wave number two", "2",
+                             Patterns::Integer (),
+                             "Doubled second lateral wave number of the harmonic perturbation. "
+                             "Equals the spherical harmonic order in 3d spherical shells. "
+                             "In all other cases one equals half of a sine period over "
+                             "the model domain. This allows for single up-/downswings. "
+                             "Negative numbers reverse the sign of the perturbation.");
+          prm.declare_entry ("Magnitude", "1.0",
+                             Patterns::Double (0.),
+                             "The magnitude of the Harmonic perturbation.");
+          prm.declare_entry ("Reference temperature", "1600.0",
+                             Patterns::Double (0.),
+                             "The reference temperature that is perturbed by the "
+                             "harmonic function. Only used in incompressible models.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    HarmonicPerturbation<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Harmonic perturbation");
+        {
+          vertical_wave_number = prm.get_integer ("Vertical wave number");
+          lateral_wave_number_1 = prm.get_integer ("Lateral wave number one");
+          lateral_wave_number_2 = prm.get_integer ("Lateral wave number two");
+          magnitude = prm.get_double ("Magnitude");
+          reference_temperature = prm.get_double ("Reference temperature");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(HarmonicPerturbation,
+                                              "harmonic perturbation",
+                                              "An initial temperature field in which the temperature "
+                                              "is perturbed following a harmonic function (spherical "
+                                              "harmonic or sine depending on geometry and dimension) "
+                                              "in lateral and radial direction from an otherwise "
+                                              "constant temperature (incompressible model) or adiabatic "
+                                              "reference profile (compressible model).")
+  }
+}
diff --git a/source/initial_temperature/interface.cc.bak b/source/initial_temperature/interface.cc.bak
new file mode 100644
index 00000000000..c747b7197b8
--- /dev/null
+++ b/source/initial_temperature/interface.cc.bak
@@ -0,0 +1,264 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/initial_temperature/interface.h>
+
+#include <deal.II/base/exceptions.h>
+#include <tuple>
+
+#include <list>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    // ------------------------------ Manager -----------------------------
+    // -------------------------------- Deal with registering initial_temperature models and automating
+    // -------------------------------- their setup and selection at run time
+
+    template <int dim>
+    Manager<dim>::~Manager()
+      = default;
+
+
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_initial_temperature (const std::string &name,
+                                                const std::string &description,
+                                                void (*declare_parameters_function) (ParameterHandler &),
+                                                std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // find out which plugins are requested and the various other
+      // parameters we declare here
+      prm.enter_subsection ("Initial temperature model");
+      {
+        model_names
+          = Utilities::split_string_list(prm.get("List of model names"));
+
+        AssertThrow(Utilities::has_unique_entries(model_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Initial temperature model/List of model names' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+
+        const std::string model_name = prm.get ("Model name");
+
+        AssertThrow (model_name == "unspecified" || model_names.size() == 0,
+                     ExcMessage ("The parameter 'Model name' is only used for reasons"
+                                 "of backwards compatibility and can not be used together with "
+                                 "the new functionality 'List of model names'. Please add your "
+                                 "initial temperature model to the list instead."));
+
+        if (!(model_name == "unspecified"))
+          model_names.push_back(model_name);
+
+        // create operator list
+        const std::vector<std::string> model_operator_names =
+          Utilities::possibly_extend_from_1_to_N (Utilities::split_string_list(prm.get("List of model operators")),
+                                                  model_names.size(),
+                                                  "List of model operators");
+        model_operators = Utilities::create_model_operator_list(model_operator_names);
+      }
+      prm.leave_subsection ();
+
+      // go through the list, create objects and let them parse
+      // their own parameters
+      for (auto &model_name : model_names)
+        {
+          // create initial temperature objects
+          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
+                                          (std::get<dim>(registered_plugins)
+                                           .create_plugin (model_name,
+                                                           "Initial temperature model::Model names")));
+
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
+            sim->initialize_simulator (this->get_simulator());
+
+          this->plugin_objects.back()->parse_parameters (prm);
+          this->plugin_objects.back()->initialize ();
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::update()
+    {
+      for (auto &initial_temperature_object : this->plugin_objects)
+        initial_temperature_object->update();
+    }
+
+
+
+    template <int dim>
+    double
+    Manager<dim>::initial_temperature (const Point<dim> &position) const
+    {
+      double temperature = 0.0;
+      int i = 0;
+
+      for (const auto &initial_temperature_object : this->plugin_objects)
+        {
+          temperature = model_operators[i](temperature,
+                                           initial_temperature_object->initial_temperature(position));
+          ++i;
+        }
+      return temperature;
+    }
+
+
+    template <int dim>
+    const std::vector<std::string> &
+    Manager<dim>::get_active_initial_temperature_names () const
+    {
+      return model_names;
+    }
+
+
+    template <int dim>
+    const std::list<std::unique_ptr<Interface<dim>>> &
+    Manager<dim>::get_active_initial_temperature_conditions () const
+    {
+      return this->plugin_objects;
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // declare the entry in the parameter file
+      prm.enter_subsection ("Initial temperature model");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry("List of model names",
+                          "",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma-separated list of initial temperature models that "
+                          "will be used to initialize the temperature. "
+                          "These plugins are loaded in the order given, and modify the "
+                          "existing temperature field via the operators listed "
+                          "in 'List of model operators'.\n\n"
+                          "The following initial temperature models are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+
+        prm.declare_entry("List of model operators", "add",
+                          Patterns::MultipleSelection(Utilities::get_model_operator_options()),
+                          "A comma-separated list of operators that "
+                          "will be used to append the listed temperature models onto "
+                          "the previous models. If only one operator is given, "
+                          "the same operator is applied to all models.");
+
+        prm.declare_entry ("Model name", "unspecified",
+                           Patterns::Selection (pattern_of_names+"|unspecified"),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string()
+                           + "\n\n" +
+                           "\\textbf{Warning}: This parameter provides an old and "
+                           "deprecated way of specifying "
+                           "initial temperature models and shouldn't be used. "
+                           "Please use 'List of model names' instead.");
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ()
+    {
+      return std::get<dim>(registered_plugins).get_pattern_of_names ();
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Initial temperature interface",
+                                                            out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<InitialTemperature::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<InitialTemperature::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<InitialTemperature::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<InitialTemperature::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace InitialTemperature
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>; \
+  \
+  template \
+  std::string \
+  get_valid_model_names_pattern<dim> ();
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/initial_temperature/lithosphere_mask.cc.bak b/source/initial_temperature/lithosphere_mask.cc.bak
new file mode 100644
index 00000000000..e1101048d37
--- /dev/null
+++ b/source/initial_temperature/lithosphere_mask.cc.bak
@@ -0,0 +1,223 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/initial_temperature/lithosphere_mask.h>
+#include <aspect/utilities.h>
+#include <limits>
+#include <aspect/geometry_model/interface.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    namespace LABDepth
+    {
+      template <int dim>
+      LABDepthLookup<dim>::LABDepthLookup ()
+        :
+        lab_depths(1, 1.0)
+      {}
+
+
+
+      template <int dim>
+      void
+      LABDepthLookup<dim>::initialize ()
+      {
+        if (LAB_depth_source == File)
+          {
+            const std::string filename = data_directory+LAB_file_name;
+            this->get_pcout() << "   Loading Ascii data lookup file " << filename << '.' << std::endl;
+
+            lab_depths.load_file(filename,this->get_mpi_communicator());
+          }
+      }
+
+
+
+      template <int dim>
+      double
+      LABDepthLookup<dim>::get_lab_depth (const Point<dim> &position) const
+      {
+        if (LAB_depth_source == File)
+          {
+            //Get spherical coordinates for model
+            Assert (dim == 3, ExcNotImplemented());
+            std::array<double,dim> scoord      = Utilities::Coordinates::cartesian_to_spherical_coordinates<dim>(position);
+            const double phi = scoord[1];
+            const double theta = scoord[2 % dim]; // work-around to compile without warnings for dim==2
+            const Point<2> phi_theta (phi, theta);
+
+            //Get lab depth for specific phi and theta
+            const double lab_depth = lab_depths.get_data(phi_theta,0);
+            return lab_depth;
+          }
+
+        else if (LAB_depth_source == Value)
+          {
+            return max_depth;
+          }
+        else
+          {
+            Assert( false, ExcMessage("Invalid method for depth specification method") );
+            return 0.0;
+          }
+
+        return 0.0;
+      }
+
+
+
+      template <int dim>
+      void
+      LABDepthLookup<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Depth specification method", "Value",
+                           Patterns::Selection("File|Value"),
+                           "Method that is used to specify the depth of the lithosphere-asthenosphere boundary.");
+        prm.declare_entry ("Maximum lithosphere depth", "200000.0",
+                           Patterns::Double (0.),"Units: \\si{\\meter}."
+                           "The maximum depth of the lithosphere. The model will be "
+                           "NaNs below this depth.");
+        prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/initial-temperature/lithosphere-mask/",
+                           Patterns::DirectoryName (),
+                           "The path to the LAB depth data file");
+        prm.declare_entry ("LAB depth filename",
+                           "LAB_CAM2016.txt",
+                           Patterns::FileName (),
+                           "File from which the lithosphere-asthenosphere boundary depth data is read.");
+      }
+
+      template <int dim>
+      void
+      LABDepthLookup<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        if ( prm.get("Depth specification method") == "File" )
+          {
+            LAB_depth_source = File;
+            data_directory = Utilities::expand_ASPECT_SOURCE_DIR (prm.get("Data directory"));
+            LAB_file_name = prm.get("LAB depth filename");
+          }
+        else if ( prm.get("Depth specification method") == "Value" )
+          {
+            LAB_depth_source = Value;
+            max_depth = prm.get_double ("Maximum lithosphere depth");
+          }
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    LithosphereMask<dim>::initialize ()
+    {
+      lab_depth_lookup.initialize();
+    }
+
+
+
+    template <int dim>
+    double
+    LithosphereMask<dim>::initial_temperature (const Point<dim> &position) const
+    {
+      double temperature;
+      const double depth = this->SimulatorAccess<dim>::get_geometry_model().depth(position);
+      const double lab_depth = lab_depth_lookup.get_lab_depth(position);
+
+      if (depth <= lab_depth)
+        temperature = lithosphere_temperature;
+      else
+        temperature = std::numeric_limits<double>::quiet_NaN();
+
+      return temperature;
+    }
+
+    template <int dim>
+    void
+    LithosphereMask<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection ("Lithosphere Mask");
+        {
+          LABDepth::LABDepthLookup<dim>::declare_parameters(prm);
+
+          prm.declare_entry ("Lithosphere temperature", "1600.",
+                             Patterns::Double (0.),
+                             "The initial temperature within lithosphere, applied above"
+                             "the maximum lithosphere depth.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    LithosphereMask<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      AssertThrow (dim == 3,
+                   ExcMessage ("The 'Lithosphere mask' model for the initial "
+                               "temperature is only available for 3d computations."));
+
+      prm.enter_subsection("Initial temperature model");
+      {
+        prm.enter_subsection ("Lithosphere Mask");
+        {
+          lab_depth_lookup.initialize_simulator(this->get_simulator());
+          lab_depth_lookup.parse_parameters(prm);
+          lithosphere_temperature = prm.get_double ("Lithosphere temperature");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template class LABDepth::LABDepthLookup<2>;
+    template class LABDepth::LABDepthLookup<3>;
+
+
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(LithosphereMask,
+                                              "lithosphere mask",
+                                              "Implementation of a model in which the initial "
+                                              "temperature is set to a specified lithosphere temperature above the "
+                                              "lithosphere-asthenosphere boundary (specified by an ascii file "
+                                              "or maximum lithosphere depth value). Below this the initial temperature is set as "
+                                              "NaN.  Note the required format of the input data file: The first lines may "
+                                              "contain any number of comments if they begin with '#', but one of these lines "
+                                              "needs to contain the number of grid points in each dimension as for example "
+                                              "'# POINTS: 3 3'. For a spherical model, the order of the data columns has to be "
+                                              "'phi', 'theta', 'depth (m)', where phi is the azimuth angle and theta is the "
+                                              "polar angle measured positive from the north pole. This plug-in can be combined "
+                                              "with another using the 'replace if valid' operator. ")
+  }
+}
diff --git a/source/initial_temperature/patch_on_S40RTS.cc.bak b/source/initial_temperature/patch_on_S40RTS.cc.bak
new file mode 100644
index 00000000000..185cc74d950
--- /dev/null
+++ b/source/initial_temperature/patch_on_S40RTS.cc.bak
@@ -0,0 +1,212 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/initial_temperature/patch_on_S40RTS.h>
+#include <aspect/utilities.h>
+
+#include <boost/lexical_cast.hpp>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    PatchOnS40RTS<dim>::PatchOnS40RTS ()
+      = default;
+
+
+    template <int dim>
+    void
+    PatchOnS40RTS<dim>::initialize ()
+    {
+      this->Utilities::AsciiDataInitial<dim>::initialize(1);
+    }
+
+
+    template <int dim>
+    double
+    PatchOnS40RTS<dim>::
+    ascii_grid_vs (const Point<dim> &position) const
+    {
+      const double vs_perturbation = Utilities::AsciiDataInitial<dim>::get_data_component(position,0);
+      return vs_perturbation;
+    }
+
+
+    template <int dim>
+    double
+    PatchOnS40RTS<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      const double depth = this->get_geometry_model().depth(position);
+
+      double vs_perturbation;
+      if (depth <= max_grid_depth - smoothing_length_scale)
+        {
+          vs_perturbation = ascii_grid_vs(position);
+        }
+      //add smoothing between the two models
+      else if (depth > max_grid_depth - smoothing_length_scale && depth < max_grid_depth)
+        {
+          const double scale_factor = (depth-(max_grid_depth-smoothing_length_scale))/smoothing_length_scale;
+          vs_perturbation = s40rts.get_Vs(position)*(scale_factor) + ascii_grid_vs(position)*(1.0-scale_factor);
+        }
+      else
+        {
+          vs_perturbation = s40rts.get_Vs(position);
+        }
+
+      // use either the user-input reference temperature as background temperature
+      // (incompressible model) or the adiabatic temperature profile (compressible model)
+      const double background_temperature = this->get_material_model().is_compressible() ?
+                                            this->get_adiabatic_conditions().temperature(position) :
+                                            s40rts.reference_temperature;
+
+      // get the Vs to density conversion
+      double vs_to_density = 0.0;
+      if (s40rts.vs_to_density_method == s40rts.file)
+        vs_to_density = s40rts.profile.get_data_component(Point<1>(depth), s40rts.vs_to_density_index);
+      else if (s40rts.vs_to_density_method == s40rts.constant)
+        vs_to_density = s40rts.vs_to_density_constant;
+      else
+        // we shouldn't get here but instead should already have been
+        // kicked out when declaring the parameter, as the pattern won't match ("file|constant")
+        Assert(false, ExcMessage("Unknown method for vs to density scaling."));
+
+      // scale the perturbation in seismic velocity into a density perturbation
+      // vs_to_density is read in from input file
+      const double density_perturbation = vs_to_density * vs_perturbation;
+      double temperature_perturbation;
+      if (depth > no_perturbation_depth_patch)
+        // scale the density perturbation into a temperature perturbation
+        temperature_perturbation =  -1./s40rts.thermal_alpha * density_perturbation;
+      else
+        // set heterogeneity to zero down to a specified depth
+        temperature_perturbation = 0.0;
+
+      return background_temperature + temperature_perturbation;
+    }
+
+    template <int dim>
+    void
+    PatchOnS40RTS<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection ("Patch on S40RTS");
+        {
+          prm.declare_entry ("Maximum grid depth", "700000.0",
+                             Patterns::Double (0.),
+                             "The maximum depth of the Vs ascii grid. The model will read in  "
+                             "Vs from S40RTS below this depth.");
+          prm.declare_entry ("Smoothing length scale", "200000.0",
+                             Patterns::Double (0.),
+                             "The depth range (above maximum grid depth) over which to smooth. "
+                             "The boundary is smoothed using a depth weighted combination of Vs "
+                             "values from the ascii grid and S40RTS at each point in the region of smoothing.");
+          prm.declare_entry ("Remove temperature heterogeneity down to specified depth",
+                             boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
+                             Patterns::Double (),
+                             "This will set the heterogeneity prescribed by the Vs ascii grid and S40RTS to zero "
+                             "down to the specified depth (in meters). Note that your resolution has "
+                             "to be adequate to capture this cutoff. For example if you specify a depth "
+                             "of 660km, but your closest spherical depth layers are only at 500km and "
+                             "750km (due to a coarse resolution) it will only zero out heterogeneities "
+                             "down to 500km. Similar caution has to be taken when using adaptive meshing.");
+
+          Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                            "$ASPECT_SOURCE_DIR/data/initial-temperature/patch-on-S40RTS/test/",
+                                                            "upper_shell_3d.txt");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    PatchOnS40RTS<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Initial temperature model");
+      {
+        prm.enter_subsection ("Patch on S40RTS");
+        {
+          max_grid_depth           = prm.get_double ("Maximum grid depth");
+          smoothing_length_scale   = prm.get_double ("Smoothing length scale");
+          no_perturbation_depth_patch   = prm.get_double ("Remove temperature heterogeneity down to specified depth");
+
+          Utilities::AsciiDataBase<dim>::parse_parameters(prm);
+
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      s40rts.initialize_simulator (this->get_simulator());
+      s40rts.parse_parameters(prm);
+      s40rts.initialize();
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(PatchOnS40RTS,
+                                              "patch on S40RTS",
+                                              "Implementation of a model in which the initial "
+                                              "temperature is derived from a file containing shear wave velocity perturbations "
+                                              "in ascii format (e.g. a high resolution upper mantle tomography) "
+                                              "combined with S40RTS. Note the required format of the "
+                                              "input ascii input data: The first lines may contain any number of comments "
+                                              "if they begin with '#', but one of these lines needs to "
+                                              "contain the number of grid points in each dimension as "
+                                              "for example '# POINTS: 3 3 3'. "
+                                              "The order of the data columns has to be "
+                                              " `x', `y', `z', 'Vs Perturbation' in a 3d model, which means that "
+                                              "there has to be a single column "
+                                              "containing the temperature. "
+                                              "Note that the data in the input "
+                                              "files need to be sorted in a specific order: "
+                                              "the first coordinate needs to ascend first, "
+                                              "followed by the second and the third at last in order to "
+                                              "assign the correct data to the prescribed coordinates. "
+                                              "In the spherical model data will be handled as Cartesian, "
+                                              "however, `x' will be replaced by "
+                                              "the radial distance of the point to the bottom of the model, "
+                                              "`y' by the azimuth angle and `z' by the polar angle measured "
+                                              "positive from the north pole. The grid will be assumed to be "
+                                              "a latitude-longitude grid. Note that the order "
+                                              "of spherical coordinates is `r', `phi', `theta' "
+                                              "and not `r', `theta', `phi', since this allows "
+                                              "for dimension independent expressions. "
+                                              "See S40RTS documentation for details on input parameters in the "
+                                              "S40RTS perturbation subsection. "
+                                              "The boundary between the two tomography models is smoothed using a depth weighted "
+                                              "combination of Vs values within the region of smoothing. ")
+  }
+}
diff --git a/source/initial_temperature/prescribed_temperature.cc.bak b/source/initial_temperature/prescribed_temperature.cc.bak
new file mode 100644
index 00000000000..7b5e5149a88
--- /dev/null
+++ b/source/initial_temperature/prescribed_temperature.cc.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/prescribed_temperature.h>
+
+#include <aspect/initial_composition/interface.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    void
+    PrescribedTemperature<dim>::initialize()
+    {
+      // Make sure we keep track of the initial composition manager and
+      // that it continues to live beyond the time when the simulator
+      // class releases its pointer to it.
+      initial_composition = this->get_initial_composition_manager_pointer();
+    }
+
+
+    template <int dim>
+    double
+    PrescribedTemperature<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // Evaluate the material model to get the temperature
+      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
+
+      in.position[0] = position;
+      in.temperature[0] = this->get_adiabatic_conditions().temperature(position);
+      in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
+      in.velocity[0] = Tensor<1,dim> ();
+
+      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+        in.composition[0][c] = initial_composition->initial_composition(position, c);
+
+      in.strain_rate.resize(0);
+
+      this->get_material_model().create_additional_named_outputs(out);
+      this->get_material_model().evaluate(in, out);
+
+      // set up variable to interpolate prescribed field outputs onto temperature field
+      double temperature = in.temperature[0];
+      if (MaterialModel::PrescribedTemperatureOutputs<dim> *prescribed_temperature_out
+          = out.template get_additional_output<MaterialModel::PrescribedTemperatureOutputs<dim>>())
+        {
+          temperature = prescribed_temperature_out->prescribed_temperature_outputs[0];
+        }
+      else
+        AssertThrow (false,
+                     ExcMessage ("The material model needs to compute precribed temperature outputs, "
+                                 "otherwise the initial temperature can not be set to the prescribed "
+                                 "temperature."));
+
+      return temperature;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(PrescribedTemperature,
+                                              "prescribed temperature",
+                                              "This model fixes the initial temperature to the prescribed "
+                                              "temperature outputs computed by the material model. This only "
+                                              "works if the material model implements prescribed temperature "
+                                              "outputs.")
+  }
+}
diff --git a/source/initial_temperature/random_gaussian_perturbation.cc.bak b/source/initial_temperature/random_gaussian_perturbation.cc.bak
new file mode 100644
index 00000000000..528caf247d3
--- /dev/null
+++ b/source/initial_temperature/random_gaussian_perturbation.cc.bak
@@ -0,0 +1,211 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/random_gaussian_perturbation.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/simulator_access.h>
+
+#include <random>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    void
+    RandomGaussianPerturbation<dim>::initialize ()
+    {
+      // Get dimension of the model from the geometry model.
+      Point<dim> min_coordinates;
+      Point<dim> max_coordinates;
+
+      perturbation_centers.resize(n_perturbations);
+      perturbation_magnitudes.resize(n_perturbations);
+
+      if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::SphericalShell<dim> &spherical_geometry_model =
+            Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
+
+          for (unsigned int d=0; d<dim; ++d)
+            {
+              min_coordinates[d] = -spherical_geometry_model.outer_radius();
+              max_coordinates[d] = spherical_geometry_model.outer_radius();
+            }
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::Sphere<dim> &sphere_geometry_model =
+            Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>> (this->get_geometry_model());
+
+          for (unsigned int d=0; d<dim; ++d)
+            {
+              min_coordinates[d] = -sphere_geometry_model.radius();
+              max_coordinates[d] = sphere_geometry_model.radius();
+            }
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::Chunk<dim> &chunk_geometry_model =
+            Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>> (this->get_geometry_model());
+
+          for (unsigned int d=0; d<dim; ++d)
+            {
+              min_coordinates[d] = -chunk_geometry_model.outer_radius();
+              max_coordinates[d] = chunk_geometry_model.outer_radius();
+            }
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::Box<dim> &box_geometry_model =
+            Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
+
+          min_coordinates = box_geometry_model.get_origin();
+          max_coordinates = min_coordinates + box_geometry_model.get_extents();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
+        {
+          const GeometryModel::TwoMergedBoxes<dim> &two_merged_boxes_geometry_model =
+            Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model());
+
+          min_coordinates = two_merged_boxes_geometry_model.get_origin();
+          max_coordinates = min_coordinates + two_merged_boxes_geometry_model.get_extents();
+        }
+      else
+        AssertThrow (false,
+                     ExcMessage ("Not a valid geometry model for the initial conditions model "
+                                 "'random Gaussian perturbation'."));
+
+      // Initialize random locations of perturbations and check they are in the model domain.
+      // Use a fixed number as seed for random generator.
+      // This is important if we run the code on more than 1 processor.
+      std::mt19937 generator(1);
+      std::uniform_real_distribution<double> random_location(0.0,1.0);
+      std::uniform_real_distribution<double> random_magnitude(-max_magnitude, max_magnitude);
+
+      for (unsigned int n=0; n<n_perturbations; ++n)
+        {
+          do
+            {
+              for (unsigned int d=0; d<dim; ++d)
+                perturbation_centers[n][d] = min_coordinates[d] + random_location(generator) * (max_coordinates[d] - min_coordinates[d]);
+            }
+          while (!this->get_geometry_model().point_is_in_domain(perturbation_centers[n]));
+
+          perturbation_magnitudes[n] = random_magnitude(generator);
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    RandomGaussianPerturbation<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      double temperature_perturbation = 0;
+      for (unsigned int n=0; n<n_perturbations; ++n)
+        {
+          const double distance_square = position.distance_square(perturbation_centers[n]);
+          const double exponent = distance_square / (2.*width*width);
+
+          temperature_perturbation += perturbation_magnitudes[n] * std::exp(-exponent);
+        }
+
+      return temperature_perturbation;
+    }
+
+
+
+    template <int dim>
+    void
+    RandomGaussianPerturbation<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Random Gaussian perturbation");
+        {
+          prm.declare_entry ("Number of perturbations", "100",
+                             Patterns::Integer (),
+                             "Total number of perturbations to be introduced into the model. "
+                             "Perturbations will be placed at random locations within the "
+                             "model domain.");
+          prm.declare_entry ("Maximum magnitude", "25.0",
+                             Patterns::Double (0.),
+                             "The maximum magnitude of the Gaussian perturbation. For each "
+                             "perturbation, a random magnitude between plus and minus the "
+                             "maximum magnitude will be chosen. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Width", "1000.0",
+                             Patterns::Double (0.),
+                             "The Gaussian RMS width of the perturbations. "
+                             "Units: \\si{\\meter}.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+
+    template <int dim>
+    void
+    RandomGaussianPerturbation<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Random Gaussian perturbation");
+        {
+          n_perturbations = prm.get_integer ("Number of perturbations");
+          max_magnitude = prm.get_double ("Maximum magnitude");
+          width = prm.get_double ("Width");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(RandomGaussianPerturbation,
+                                              "random Gaussian perturbation",
+                                              "An initial temperature field in which the temperature "
+                                              "is perturbed from a temperature of zero following a "
+                                              "given number of Gaussian perturbations placed randomly "
+                                              "throughout the model domain. The number, width, and "
+                                              "maximum magnitude of the perturbations can be chosen "
+                                              "as model parameters. "
+                                              "This plugin is meant to be used in combination with "
+                                              "another initial temperature model that determines the "
+                                              "background temperature (such as the 'function' or the "
+                                              "'adiabatic' plugin) using the 'add' operator to combine "
+                                              "them.")
+  }
+}
diff --git a/source/initial_temperature/spherical_shell.cc.bak b/source/initial_temperature/spherical_shell.cc.bak
new file mode 100644
index 00000000000..4a43ef19b92
--- /dev/null
+++ b/source/initial_temperature/spherical_shell.cc.bak
@@ -0,0 +1,378 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <deal.II/base/signaling_nan.h>
+#include <aspect/initial_temperature/spherical_shell.h>
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+#include <cstring>
+
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    double
+    SphericalHexagonalPerturbation<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // s = fraction of the way from the inner to the outer boundary; 0<=s<=1
+      const double s = this->get_geometry_model().depth(position)
+                       / this->get_geometry_model().maximal_depth();
+
+      /* now compute an angular variation of the linear temperature field by
+         stretching the variable s appropriately. note that the following
+         formula leaves the end points s=0 and s=1 fixed, but stretches the
+         region in between depending on the angle phi=atan2(x,y).
+
+         For a plot, see
+         http://www.wolframalpha.com/input/?i=plot+%28%282*sqrt%28x^2%2By^2%29-1%29%2B0.2*%282*sqrt%28x^2%2By^2%29-1%29*%281-%282*sqrt%28x^2%2By^2%29-1%29%29*sin%286*atan2%28x%2Cy%29%29%29%2C+x%3D-1+to+1%2C+y%3D-1+to+1
+      */
+      const double scale = ((dim==3)
+                            ?
+                            std::max(0.0,
+                                     std::cos(numbers::PI * std::fabs(position(2)/R1)))
+                            :
+                            1.0);
+      const double phi   = std::atan2(position(0),position(1));
+      const double s_mod = s
+                           +
+                           0.2 * s * (1-s) * std::sin(angular_mode*phi + (90 + 2*rotation_offset) * constants::degree_to_radians ) * scale;
+
+      // Check that a boundary temperature is prescribed
+      AssertThrow (this->has_boundary_temperature(),
+                   ExcMessage ("This initial condition can only be used if a boundary "
+                               "temperature is prescribed."));
+
+      return (this->get_boundary_temperature_manager().maximal_temperature()*(s_mod)
+              +
+              this->get_boundary_temperature_manager().minimal_temperature()*(1-s_mod));
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalHexagonalPerturbation<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Spherical hexagonal perturbation");
+        {
+
+          prm.declare_entry ("Angular mode", "6",
+                             Patterns::Integer (),
+                             "The number of convection cells with which to perturb the system.");
+
+          prm.declare_entry  ("Rotation offset", "-45.",
+                              Patterns::Double (),
+                              "Amount of clockwise rotation in degrees to apply to "
+                              "the perturbations. Default is set to -45 in order "
+                              "to provide backwards compatibility.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalHexagonalPerturbation<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Spherical hexagonal perturbation");
+        {
+          angular_mode = prm.get_integer ("Angular mode");
+          rotation_offset = prm.get_double  ("Rotation offset");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      // This initial condition only makes sense if the geometry is derived from
+      // a spherical model (i.e. a sphere, spherical shell or chunk)
+      if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()))
+        {
+          R1 = Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>>
+               (this->get_geometry_model()).radius();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()))
+        {
+          R1 = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
+               (this->get_geometry_model()).outer_radius();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()))
+        {
+          R1 = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
+               (this->get_geometry_model()).outer_radius();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()))
+        {
+          const auto &gm = Plugins::get_plugin_as_type<const GeometryModel::EllipsoidalChunk<dim>>
+                           (this->get_geometry_model());
+          // TODO
+          // If the eccentricity of the EllipsoidalChunk is non-zero, the radius can vary along a boundary,
+          // but the maximal depth is the same everywhere and we could calculate a representative pressure
+          // profile. However, it requires some extra logic with ellipsoidal
+          // coordinates, so for now we only allow eccentricity zero.
+          // Using the EllipsoidalChunk with eccentricity zero can still be useful,
+          // because the domain can be non-coordinate parallel.
+
+          AssertThrow(gm.get_eccentricity() == 0.0,
+                      ExcNotImplemented("This plugin cannot be used with a non-zero eccentricity. "));
+
+          R1 = gm.get_semi_major_axis_a();
+        }
+      else
+        {
+          Assert (false, ExcMessage ("This initial condition can only be used if the geometry "
+                                     "is a sphere, a spherical shell, a chunk or an "
+                                     "ellipsoidal chunk."));
+          R1 = numbers::signaling_nan<double>();
+        }
+    }
+
+
+
+    template <int dim>
+    SphericalGaussianPerturbation<dim>::
+    SphericalGaussianPerturbation()
+    {
+
+      // Note that the values we read in here have reasonable default values
+      geotherm.resize(4);
+      radial_position.resize(4);
+      geotherm[0] = 1e0;
+      geotherm[1] = 0.75057142857142856;
+      geotherm[2] = 0.32199999999999995;
+      geotherm[3] = 0.0;
+      radial_position[0] =  0e0-1e-3;
+      radial_position[1] =  0.16666666666666666;
+      radial_position[2] =  0.83333333333333337;
+      radial_position[3] =  1e0+1e-3;
+
+
+    }
+
+    template <int dim>
+    double
+    SphericalGaussianPerturbation<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      // Check that a boundary temperature is prescribed
+      AssertThrow (this->has_boundary_temperature(),
+                   ExcMessage ("This initial condition can only be used if a boundary "
+                               "temperature is prescribed."));
+
+      const double dT = this->get_boundary_temperature_manager().maximal_temperature()
+                        - this->get_boundary_temperature_manager().minimal_temperature();
+      const double T0 = this->get_boundary_temperature_manager().maximal_temperature()/dT;
+      const double T1 = this->get_boundary_temperature_manager().minimal_temperature()/dT;
+      const double h = R1-R0;
+
+      // s = fraction of the way from
+      // the inner to the outer
+      // boundary; 0<=s<=1
+      const double r = position.norm();
+      const double s = (r-R0)/h;
+
+      const double scale=R1/(R1 - R0);
+      const float eps = 1e-4;
+
+      int indx = -1;
+      for (unsigned int i=0; i<3; ++i)
+        {
+          if ((radial_position[i] - s) < eps && (radial_position[i+1] - s) > eps)
+            {
+              indx = i;
+              break;
+            }
+        }
+      Assert (indx >= 0, ExcInternalError());
+      Assert (indx < 3,  ExcInternalError());
+      int indx1 = indx + 1;
+      const float dx = radial_position[indx1] - radial_position[indx];
+      const float dy = geotherm[indx1] - geotherm[indx];
+
+      const double InterpolVal = (( dx > 0.5*eps)
+                                  ?
+                                  // linear interpolation
+                                  std::max(geotherm[3],geotherm[indx] + (s-radial_position[indx]) * (dy/dx))
+                                  :
+                                  // evaluate the point in the discontinuity
+                                  0.5*( geotherm[indx] + geotherm[indx1] ));
+
+      const double x = (scale - this->depth)*std::cos(angle);
+      const double y = (scale - this->depth)*std::sin(angle);
+      const double Perturbation = (sign * amplitude *
+                                   std::exp( -( std::pow((position(0)*scale/R1-x),2)
+                                                +
+                                                std::pow((position(1)*scale/R1-y),2) ) / sigma));
+
+      if (r > R1 - 1e-6*R1 || InterpolVal + Perturbation < T1)
+        return T1*dT;
+      else if (r < R0 + 1e-6*R0 || InterpolVal + Perturbation > T0 )
+        return T0*dT;
+      else
+        return (InterpolVal + Perturbation)*dT;
+    }
+
+
+
+    template <int dim>
+    void
+    SphericalGaussianPerturbation<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Spherical gaussian perturbation");
+        {
+          prm.declare_entry ("Angle", "0.",
+                             Patterns::Double (0.),
+                             "The angle where the center of the perturbation is placed.");
+          prm.declare_entry ("Non-dimensional depth", "0.7",
+                             Patterns::Double (0.),
+                             "The non-dimensional radial distance where the center of the "
+                             "perturbation is placed.");
+          prm.declare_entry ("Amplitude", "0.01",
+                             Patterns::Double (0.),
+                             "The amplitude of the perturbation.");
+          prm.declare_entry ("Sigma", "0.2",
+                             Patterns::Double (0.),
+                             "The standard deviation of the Gaussian perturbation.");
+          prm.declare_entry ("Sign", "1.",
+                             Patterns::Double (),
+                             "The sign of the perturbation.");
+          prm.declare_entry ("Filename for initial geotherm table", "initial-geotherm-table",
+                             Patterns::FileName(),
+                             "The file from which the initial geotherm table is to be read. "
+                             "The format of the file is defined by what is read in "
+                             "source/initial\\_temperature/spherical\\_shell.cc.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+    template <int dim>
+    void
+    SphericalGaussianPerturbation<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Spherical gaussian perturbation");
+        {
+          angle = prm.get_double ("Angle");
+          depth = prm.get_double ("Non-dimensional depth");
+          amplitude  = prm.get_double ("Amplitude");
+          sigma  = prm.get_double ("Sigma");
+          sign  = prm.get_double ("Sign");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      // This initial condition only makes sense if the geometry is derived from
+      // a spherical model
+      // (i.e. a sphere, spherical shell, chunk or ellipsoidal chunk with zero ellipticity)
+
+      if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()))
+        {
+          R0 = 0.;
+          R1 = Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>>
+               (this->get_geometry_model()).radius();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()))
+        {
+          R0 = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
+               (this->get_geometry_model()).inner_radius();
+          R1 = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
+               (this->get_geometry_model()).outer_radius();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()))
+        {
+          R0 = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
+               (this->get_geometry_model()).inner_radius();
+          R1 = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
+               (this->get_geometry_model()).outer_radius();
+        }
+
+      else if (Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()))
+        {
+
+          // TODO
+          // If the eccentricity of the EllipsoidalChunk is non-zero, the radius can vary along a boundary,
+          // but the maximal depth is the same everywhere and we could calculate a representative pressure
+          // profile. However, it requires some extra logic with ellipsoidal
+          // coordinates, so for now we only allow eccentricity zero.
+          // Using the EllipsoidalChunk with eccentricity zero can still be useful,
+          // because the domain can be non-coordinate parallel.
+
+          const auto &gm = Plugins::get_plugin_as_type<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model());
+
+          AssertThrow(gm.get_eccentricity() == 0.0,
+                      ExcNotImplemented("This plugin cannot be used with a non-zero eccentricity. "));
+
+          R0 = gm.get_semi_major_axis_a() - gm.maximal_depth();
+          R1 = gm.get_semi_major_axis_a();
+        }
+      else
+        {
+          Assert (false, ExcMessage ("This initial condition can only be used if the geometry "
+                                     "is a sphere, a spherical shell, a chunk or an "
+                                     "ellipsoidal chunk."));
+
+          R0 = numbers::signaling_nan<double>();
+          R1 = numbers::signaling_nan<double>();
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(SphericalHexagonalPerturbation,
+                                              "spherical hexagonal perturbation",
+                                              "An initial temperature field in which the temperature "
+                                              "is perturbed following an $N$-fold pattern in a specified "
+                                              "direction from an otherwise spherically symmetric "
+                                              "state. The class's name comes from previous versions "
+                                              "when the only option was $N=6$.")
+
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(SphericalGaussianPerturbation,
+                                              "spherical gaussian perturbation",
+                                              "An initial temperature field in which the temperature "
+                                              "is perturbed by a single Gaussian added to an "
+                                              "otherwise spherically symmetric state. Additional "
+                                              "parameters are read from the parameter file in subsection "
+                                              "'Spherical gaussian perturbation'.")
+  }
+}
diff --git a/source/initial_temperature/world_builder.cc.bak b/source/initial_temperature/world_builder.cc.bak
new file mode 100644
index 00000000000..ae1f5eac2c4
--- /dev/null
+++ b/source/initial_temperature/world_builder.cc.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/global.h>
+
+#ifdef ASPECT_WITH_WORLD_BUILDER
+#include <world_builder/config.h>
+#include <aspect/initial_temperature/world_builder.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/citation_info.h>
+
+#include <world_builder/world.h>
+
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    template <int dim>
+    WorldBuilder<dim>::WorldBuilder ()
+      = default;
+
+    template <int dim>
+    void
+    WorldBuilder<dim>::
+    initialize()
+    {
+      CitationInfo::add("GWB");
+      world_builder = this->get_world_builder_pointer();
+    }
+
+
+    template <int dim>
+    double
+    WorldBuilder<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+#if WORLD_BUILDER_VERSION_MAJOR > 0 || WORLD_BUILDER_VERSION_MINOR >= 5
+      return world_builder->temperature(Utilities::convert_point_to_array(position),
+                                        -this->get_geometry_model().height_above_reference_surface(position));
+#else
+
+      return world_builder->temperature(Utilities::convert_point_to_array(position),
+                                        -this->get_geometry_model().height_above_reference_surface(position),
+                                        this->get_gravity_model().gravity_vector(position).norm());
+#endif
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(WorldBuilder,
+                                              "world builder",
+                                              "Specify the initial temperature through the World Builder. "
+                                              "More information on the World Builder can be found at "
+                                              "\\url{https://geodynamicworldbuilder.github.io}. "
+                                              "Make sure to specify the location of the World Builder file "
+                                              "in the parameter 'World builder file'.")
+  }
+}
+#endif
diff --git a/source/main.cc.bak b/source/main.cc.bak
new file mode 100644
index 00000000000..77b38b6890c
--- /dev/null
+++ b/source/main.cc.bak
@@ -0,0 +1,892 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/utilities.h>
+#include <deal.II/base/mpi.h>
+#include <deal.II/base/multithread_info.h>
+#include <deal.II/base/revision.h>
+#include <csignal>
+#include <string>
+#include <thread>
+#include <regex>
+
+#ifdef DEBUG
+#ifdef ASPECT_USE_FP_EXCEPTIONS
+#include <cfenv>
+#endif
+#endif
+
+#if ASPECT_USE_SHARED_LIBS==1
+#  include <dlfcn.h>
+#  ifdef ASPECT_HAVE_LINK_H
+#    include <link.h>
+#  endif
+#endif
+
+// This define has to be in exactly one translation unit and sets up the catch testing framework
+#define CATCH_CONFIG_RUNNER
+
+// work-around for clang 6 error:
+// "error: no member named 'uncaught_exceptions' in namespace 'std'"
+// see https://github.com/catchorg/Catch2/issues/1201
+#define CATCH_INTERNAL_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS
+#define CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS
+
+#include <catch.hpp>
+
+
+// get the value of a particular parameter from the contents of the input
+// file. return an empty string if not found
+std::string
+get_last_value_of_parameter(const std::string &parameters,
+                            const std::string &parameter_name)
+{
+  std::string return_value;
+
+  std::istringstream x_file(parameters);
+  while (x_file)
+    {
+      // Get one line and then match a regex to it that matches the parameter
+      // we are looking for. Before we do that, strip spaces from the front
+      // and back of the line:
+      std::string line;
+      std::getline(x_file, line);
+
+      while ((line.size() > 0) && (line[0] == ' ' || line[0] == '\t'))
+        line.erase(0, 1);
+      while ((line.size() > 0)
+             && (line[line.size() - 1] == ' ' || line[line.size() - 1] == '\t'))
+        line.erase(line.size() - 1, std::string::npos);
+
+      std::match_results<std::string::const_iterator> matches;
+      const std::string regex = "set[ \t]+" + parameter_name + "[ \t]*=[ \t]*(.*)";
+      if (std::regex_match(line, matches, std::regex(regex)))
+        {
+          // Since the line as a whole matched, the 'matches' variable needs to
+          // contain two entries: [0] denotes the whole string, and [1] the
+          // one that was matched by the '(.*)' expression.
+          Assert (matches.size() == 2, dealii::ExcInternalError());
+          return_value = std::string(matches[1].first, matches[1].second);
+        }
+    }
+
+  return return_value;
+}
+
+
+// Extract the dimension in which to run ASPECT from the
+// the contents of the parameter file. This is something that
+// we need to do before processing the parameter file since we
+// need to know whether to use the dim=2 or dim=3 instantiation
+// of the main classes.
+//
+// This function is essentially the first part of ASPECT to look at the input
+// file, so if something is wrong with it, this is the place to generate good
+// error messages.
+unsigned int
+get_dimension(const std::string &parameters)
+{
+  const std::string dimension = get_last_value_of_parameter(parameters, "Dimension");
+  if (dimension.size() > 0)
+    {
+      // A common problem is that people have .prm files that were generated
+      // on Windows, but then run this on Linux where the line endings are
+      // different. This is pernicious because it means that the conversion
+      // of a string such as "2\r" to an integer fails, but if we print
+      // this string, it comes out completely garbled because it contains
+      // a carriage-return without a newline -- so the error message looks
+      // like this:
+      //
+      //    >.  While reading the dimension from the input file, ASPECT found a string that can not be converted to an integer: <2
+      //
+      // Note how the end of the error message overwrites the beginning
+      // of the line.
+      //
+      // To avoid this kind of error, specifically test up front that the
+      // text in question does not contain '\r' characters. If we are on
+      // linux, then this kind of character would means that the line endings
+      // are wrong. On the other hand, if we are on windows, then the
+      // getline command we have used in finding 'dimension' would have
+      // filtered it out. So its presence points to a problem.
+
+      AssertThrow (dimension.find('\r') == std::string::npos,
+                   dealii::ExcMessage ("It appears that your input file uses Windows-style "
+                                       "line endings ('\\r\\n') but you are running on a system where "
+                                       "the C++ run time environment expects input files to have "
+                                       "Unix-style line endings ('\\n'). You need to convert your "
+                                       "input file to use the correct line endings before running "
+                                       "ASPECT with it."));
+      try
+        {
+          return dealii::Utilities::string_to_int (dimension);
+        }
+      catch (...)
+        {
+          AssertThrow (false,
+                       dealii::ExcMessage("While reading the dimension from the input file, "
+                                          "ASPECT found a string that can not be converted to "
+                                          "an integer: <" + dimension + ">."));
+          return 0; // we should never get here.
+        }
+    }
+  else
+    return 2;
+}
+
+
+
+#if ASPECT_USE_SHARED_LIBS==1
+
+#ifdef ASPECT_HAVE_LINK_H
+// collect the names of the shared libraries linked to by this program. this
+// function is a callback for the dl_iterate_phdr() function we call below
+int get_names_of_shared_libs (struct dl_phdr_info *info,
+                              size_t,
+                              void *data)
+{
+  reinterpret_cast<std::set<std::string>*>(data)->insert (info->dlpi_name);
+  return 0;
+}
+#endif
+
+
+// make sure the list of shared libraries we currently link with
+// has deal.II only once
+void validate_shared_lib_list (const bool before_loading_shared_libs)
+{
+#ifdef ASPECT_HAVE_LINK_H
+  // get the list of all shared libs we currently link against
+  std::set<std::string> shared_lib_names;
+  dl_iterate_phdr(get_names_of_shared_libs, &shared_lib_names);
+
+  // find everything that is interesting
+  std::set<std::string> dealii_shared_lib_names;
+  for (const auto &p : shared_lib_names)
+    if (p.find ("libdeal_II") != std::string::npos ||
+        p.find ("libdeal.ii") != std::string::npos)
+      dealii_shared_lib_names.insert (p);
+
+  // produce an error if we load deal.II more than once
+  if (dealii_shared_lib_names.size() != 1)
+    {
+      std::ostringstream error;
+      error << "........................................................\n"
+            << "ASPECT currently links against different versions of the\n"
+            << "deal.II library, namely the ones at these locations:\n";
+      for (const auto &p : dealii_shared_lib_names)
+        error << "  " << p << '\n';
+      error << "This can not work.\n\n";
+
+      if (before_loading_shared_libs)
+        error << "Since this is happening already before opening additional\n"
+              << "shared libraries, this means that something must have gone\n"
+              << "wrong when you configured deal.II and/or ASPECT. Please\n"
+              << "contact the forum for help.\n";
+      else
+        error << "Since this is happening after opening additional shared\n"
+              << "library plugins, this likely means that you have compiled\n"
+              << "ASPECT in release mode and the plugin in debug mode, or the\n"
+              << "other way around. Please re-compile the plugin in the same\n"
+              << "mode as ASPECT.\n";
+
+      error << "........................................................\n";
+
+      // if not success, then throw an exception: ExcMessage on processor 0,
+      // QuietException on the others
+      if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
+        {
+          AssertThrow (false, dealii::ExcMessage (error.str()));
+        }
+      else
+        throw aspect::QuietException();
+    }
+#else
+  // simply mark the argument as read, to avoid compiler warnings
+  (void)before_loading_shared_libs;
+#endif
+}
+
+
+#endif
+
+
+// retrieve a list of shared libraries from the parameter file and
+// dlopen them so that we can load plugins declared in them
+void possibly_load_shared_libs (const std::string &parameters)
+{
+  using namespace dealii;
+
+
+  const std::string shared_libs
+    = get_last_value_of_parameter(parameters,
+                                  "Additional shared libraries");
+  if (shared_libs.size() > 0)
+    {
+#if ASPECT_USE_SHARED_LIBS==1
+      // check up front whether the list of shared libraries is internally
+      // consistent or whether we link, for whatever reason, with both the
+      // debug and release versions of deal.II
+      validate_shared_lib_list (true);
+
+      const std::vector<std::string>
+      shared_libs_list = Utilities::split_string_list (shared_libs);
+
+      for (const auto &shared_lib : shared_libs_list)
+        {
+          // The user can specify lib{target}.so, lib{target}.debug.so, or lib{target}.release.so but
+          // we need to load the correct file depending on our compilation mode. We will try to make
+          // it work regardless of what the users specified:
+          std::string filename = shared_lib;
+
+          auto delete_if_ends_with = [](std::string &a, const std::string &b)
+          {
+            if (a.size()<b.size())
+              return;
+            if (0==a.compare(a.size()-b.size(), b.size(), b))
+              a.erase(a.size()-b.size(), std::string::npos);
+          };
+
+          delete_if_ends_with(filename, ".debug.so");
+          delete_if_ends_with(filename, ".release.so");
+          delete_if_ends_with(filename, ".so");
+
+#ifdef DEBUG
+          filename.append(".debug.so");
+#else
+          filename.append(".release.so");
+#endif
+
+          if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
+            std::cout << "Loading shared library <"
+                      << filename
+                      << '>' << std::endl;
+
+
+          void *handle = dlopen (filename.c_str(), RTLD_LAZY);
+          AssertThrow (handle != nullptr,
+                       ExcMessage (std::string("Could not successfully load shared library <")
+                                   + filename + ">. The operating system reports "
+                                   + "that the error is this: <"
+                                   + dlerror() +
+                                   ">. Did you call 'cmake' and then compile "
+                                   "the plugin library you are trying to load, and did "
+                                   "you check the spelling of the library's name? "
+                                   "Are you running ASPECT in a directory so that the path "
+                                   "to the library in question is as specified in the "
+                                   ".prm file?"));
+
+          // check again whether the list of shared libraries is
+          // internally consistent or whether we link with both the
+          // debug and release versions of deal.II. this may happen if
+          // the plugin was compiled against the debug version of
+          // deal.II but aspect itself against the release version, or
+          // the other way around
+          validate_shared_lib_list (false);
+
+          // on systems where we can detect that both libdeal_II.so and
+          // libdeal_II.g.so is loaded, the test above function above will
+          // throw an exception and we will terminate. on the other hand, on
+          // systems where we can't detect this we should at least mitigate
+          // some of the ill effects -- in particular, make sure that
+          // deallog is set to use the desired output depth since otherwise
+          // we get lots of output from the linear solvers
+          deallog.depth_console(0);
+        }
+
+      if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
+        std::cout << std::endl;
+#else
+      if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
+        {
+          std::cerr << std::endl << std::endl
+                    << "----------------------------------------------------"
+                    << std::endl;
+          std::cerr << "You can not load plugins through additional shared libraries " << std::endl
+                    << "on systems where you link ASPECT as a static executable."
+                    << std::endl
+                    << "----------------------------------------------------"
+                    << std::endl;
+        }
+      std::exit (1);
+#endif
+    }
+}
+
+
+/**
+ * Read until we reach the end of the given stream, and return the contents
+ * so obtained in a std::string object that contains the individual
+ * lines read separated by `\n` characters.
+ */
+std::string
+read_until_end (std::istream &input)
+{
+  std::string result;
+  while (input)
+    {
+      std::string line;
+      std::getline(input, line);
+
+      result += line + '\n';
+    }
+  return result;
+}
+
+
+
+/**
+ * Take the name of a parameter file and return all parameters in that file
+ * as a string. If @p parameter_file_name is "--" read the parameters from
+ * std::cin instead.
+ */
+std::string
+read_parameter_file(const std::string &parameter_file_name,
+                    MPI_Comm comm)
+{
+  using namespace dealii;
+
+  std::string input_as_string;
+  const bool i_am_proc_0 = (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0);
+
+  if (parameter_file_name != "--")
+    {
+      if (i_am_proc_0 == true &&
+          aspect::Utilities::fexists(parameter_file_name) == false &&
+          (parameter_file_name=="parameter-file.prm"
+           || parameter_file_name=="parameter_file.prm"))
+        {
+          std::cerr << "***          You should not take everything literally!          ***\n"
+                    << "*** Please pass the name of an existing parameter file instead. ***" << std::endl;
+          exit(1);
+        }
+
+      input_as_string = aspect::Utilities::read_and_distribute_file_content(parameter_file_name, comm);
+    }
+  else
+    {
+      // As stated in the help string, treat "--" as special: as is common
+      // on unix, treat it as a way to read input from stdin.
+      // Unfortunately, if you do
+      //    echo "abc" | mpirun -np 4 ./aspect
+      // then only MPI process 0 gets the data. so we have to
+      // read it there, then broadcast it to the other processors
+      if (i_am_proc_0)
+        {
+          input_as_string = read_until_end (std::cin);
+          int size = input_as_string.size()+1;
+          int ierr = MPI_Bcast (&size,
+                                1,
+                                MPI_INT,
+                                /*root=*/0, MPI_COMM_WORLD);
+          AssertThrowMPI(ierr);
+          ierr = MPI_Bcast (const_cast<char *>(input_as_string.c_str()),
+                            size,
+                            MPI_CHAR,
+                            /*root=*/0, MPI_COMM_WORLD);
+          AssertThrowMPI(ierr);
+        }
+      else
+        {
+          // on this side, read what processor zero has broadcast about
+          // the size of the input file. then create a buffer to put the
+          // text in, get it from processor 0, and copy it to
+          // input_as_string
+          int size;
+          int ierr = MPI_Bcast (&size, 1,
+                                MPI_INT,
+                                /*root=*/0, MPI_COMM_WORLD);
+          AssertThrowMPI(ierr);
+
+          std::vector<char> p (size);
+          ierr = MPI_Bcast (p.data(), size,
+                            MPI_CHAR,
+                            /*root=*/0, MPI_COMM_WORLD);
+          AssertThrowMPI(ierr);
+          input_as_string = p.data();
+        }
+    }
+
+  return input_as_string;
+}
+
+
+
+/**
+ * Let ParameterHandler parse the input file, here given as a string.
+ * Since ParameterHandler unconditionally writes to the screen when it
+ * finds something it doesn't like, we get massive amounts of output
+ * in parallel computations since every processor writes the same
+ * stuff to screen. To avoid this, let processor 0 parse the input
+ * first and, if necessary, produce its output. Only if this
+ * succeeds, also let the other processors read their input.
+ *
+ * In case of an error, we need to abort all processors without them
+ * having read their data. This is done by throwing an exception of the
+ * special class aspect::QuietException that we can catch in main() and terminate
+ * the program quietly without generating other output.
+ */
+void
+parse_parameters (const std::string &input_as_string,
+                  dealii::ParameterHandler  &prm)
+{
+  // try reading on processor 0
+  bool success = true;
+  if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
+    try
+      {
+        prm.parse_input_from_string(input_as_string);
+      }
+    catch (const dealii::ExceptionBase &e)
+      {
+        success = false;
+        e.print_info(std::cerr);
+        std::cerr << std::endl;
+      }
+
+
+  // broadcast the result. we'd like to do this with a bool
+  // data type but MPI_C_BOOL is not part of old MPI standards.
+  // so, do the broadcast in integers
+  {
+    int isuccess = (success ? 1 : 0);
+    const int ierr = MPI_Bcast (&isuccess, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    AssertThrowMPI(ierr);
+    success = (isuccess == 1);
+  }
+
+  // if not success, then throw an exception: ExcMessage on processor 0,
+  // QuietException on the others
+  if (success == false)
+    {
+      if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
+        {
+          AssertThrow(false, dealii::ExcMessage ("Invalid input parameter file."));
+        }
+      else
+        throw aspect::QuietException();
+    }
+
+  // otherwise, processor 0 was ok reading the data, so we can expect the
+  // other processors will be ok as well
+  if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) != 0)
+    {
+      prm.parse_input_from_string(input_as_string);
+    }
+}
+
+
+
+/**
+ * Print help text
+ */
+void print_help()
+{
+  std::cout << "Usage: ./aspect [args] <parameter_file.prm>   (to read from an input file)\n"
+            << "    or ./aspect [args] --                     (to read parameters from stdin)\n"
+            << std::endl;
+  std::cout << "    optional arguments [args]:\n"
+            << "       -h, --help             (for this usage help)\n"
+            << "       -v, --version          (for information about library versions)\n"
+            << "       -j, --threads          (to use multi-threading)\n"
+            << "       --output-json          (print parameters in JSON format to standard output and exit)\n"
+            << "       --output-xml           (print parameters in XML format to standard output and exit)\n"
+            << "       --output-plugin-graph  (write a representation of all plugins to standard output and exit)\n"
+            << "       --validate             (parse parameter file and exit or report errors)\n"
+            << "       --test                 (run the unit tests from unit_tests/, run --test -h for more info)\n"
+            << std::endl;
+}
+
+
+
+// hook into SIGABRT/SIGFPE and kill off the program
+void signal_handler(int signal)
+{
+  if (signal == SIGABRT)
+    {
+      std::cerr << "SIGABRT received\n";
+    }
+  else if (signal == SIGFPE)
+    {
+      std::cerr << "SIGFPE received\n";
+    }
+  else
+    {
+      std::cerr << "Unexpected signal " << signal << " received\n";
+    }
+
+  // Kill the program without performing any other cleanup, which would likely
+  // lead to a deadlock.
+  std::_Exit(EXIT_FAILURE);
+}
+
+
+
+template <int dim>
+void
+run_simulator(const std::string &raw_input_as_string,
+              const std::string &input_as_string,
+              const bool output_json,
+              const bool output_xml,
+              const bool output_plugin_graph,
+              const bool validate_only)
+{
+  using namespace dealii;
+
+  ParameterHandler prm;
+  const bool i_am_proc_0 = (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0);
+  aspect::Simulator<dim>::declare_parameters(prm);
+
+  if (validate_only)
+    {
+      try
+        {
+          parse_parameters (input_as_string, prm);
+        }
+      catch (...)
+        {
+          throw aspect::QuietException();
+        }
+      if (i_am_proc_0)
+        std::cout << "The provided parameter file is valid."
+                  "\n\n"
+                  "Note: This validation only checks parameter file syntax errors, like typos\n"
+                  "in keywords or parameter names, and that each parameter value satisfies a\n"
+                  "basic check by itself. However, it may miss more nuanced errors that\n"
+                  "are only checked when the model actually begins running. In particular,\n"
+                  "checks that involve two or more parameters can not be verified at this\n"
+                  "stage of an ASPECT run. Examples for such errors that can not already\n"
+                  "be reported here are: (i) That every boundary is assigned exactly one type\n"
+                  "of boundary condition; (ii) that parameters that take a list with values for\n"
+                  "each composition field receive a list of the correct size."
+                  << std::endl;
+      return;
+    }
+
+  parse_parameters (input_as_string, prm);
+
+  if (output_json)
+    {
+      if (i_am_proc_0)
+        prm.print_parameters(std::cout, ParameterHandler::JSON);
+    }
+  else if (output_xml)
+    {
+      if (i_am_proc_0)
+        prm.print_parameters(std::cout, ParameterHandler::XML);
+    }
+  else if (output_plugin_graph)
+    {
+      aspect::Simulator<dim> simulator(MPI_COMM_WORLD, prm);
+      if (i_am_proc_0)
+        simulator.write_plugin_graph (std::cout);
+    }
+  else
+    {
+      aspect::Simulator<dim> simulator(MPI_COMM_WORLD, prm);
+      if (i_am_proc_0)
+        {
+          // write create output/original.prm containing exactly what we got
+          // started with:
+          std::string output_directory = prm.get ("Output directory");
+          if (output_directory.size() == 0)
+            output_directory = "./";
+          else if (output_directory[output_directory.size()-1] != '/')
+            output_directory += "/";
+
+          std::ofstream file(output_directory + "original.prm");
+          file << raw_input_as_string;
+        }
+
+      simulator.run();
+    }
+}
+
+
+
+int main (int argc, char *argv[])
+{
+  using namespace dealii;
+
+#ifdef DEBUG
+#ifdef ASPECT_USE_FP_EXCEPTIONS
+  // Some implementations seem to not initialize the floating point exception
+  // bits to zero. Make sure we start from a clean state.
+  feclearexcept(FE_DIVBYZERO|FE_INVALID);
+
+  // enable floating point exceptions
+  feenableexcept(FE_DIVBYZERO|FE_INVALID);
+#endif
+#endif
+
+  std::string prm_name = "";
+  bool output_json         = false;
+  bool output_xml          = false;
+  bool output_plugin_graph = false;
+  bool output_version      = false;
+  bool output_help         = false;
+  bool use_threads         = false;
+  bool run_unittests       = false;
+  bool validate_only       = false;
+  int current_argument = 1;
+
+  // Loop over all command line arguments. Handle a number of special ones
+  // starting with a dash, and then take the first non-special one as the
+  // name of the input file. We will later check that there are no further
+  // arguments left after that.
+  while (current_argument<argc)
+    {
+      const std::string arg = argv[current_argument];
+      ++current_argument;
+      if (arg == "--output-json")
+        {
+          output_json = true;
+        }
+      else if (arg == "--output-xml")
+        {
+          output_xml = true;
+        }
+      else if (arg == "--output-plugin-graph")
+        {
+          output_plugin_graph = true;
+        }
+      else if (arg=="-h" || arg =="--help")
+        {
+          output_help = true;
+        }
+      else if (arg=="-v" || arg =="--version")
+        {
+          output_version = true;
+        }
+      else if (arg=="-j" || arg =="--threads")
+        {
+          use_threads = true;
+        }
+      else if (arg == "--test")
+        {
+          run_unittests = true;
+          break;
+        }
+      else if (arg == "--validate")
+        {
+          validate_only = true;
+        }
+      else
+        {
+          // Not a special argument, so we assume that this is the .prm
+          // filename (or "--"). We can now break out of this loop because
+          // we are not going to parse arguments passed after the filename.
+          prm_name = arg;
+          break;
+        }
+    }
+
+  // There might be remaining arguments for PETSc, only hand those over to
+  // the MPI initialization, but not the ones we parsed above.
+  int n_remaining_arguments = argc - current_argument;
+  char **remaining_arguments = (n_remaining_arguments > 0) ? &argv[current_argument] : nullptr;
+
+  try
+    {
+      // Note: we initialize this class inside the try/catch block and not
+      // before, so that the destructor of this instance can react if we are
+      // currently unwinding the stack if an unhandled exception is being
+      // thrown to avoid MPI deadlocks.
+      Utilities::MPI::MPI_InitFinalize mpi_initialization(n_remaining_arguments,
+                                                          remaining_arguments,
+                                                          (use_threads ?
+                                                           numbers::invalid_unsigned_int :
+                                                           1));
+
+      if (run_unittests)
+        {
+          // Construct new_argc, new_argv from argc, argv for catch without
+          // the "--test" arg, so we can control catch from the command
+          // line. It turns out catch needs argv[0] to be the executable name
+          // so we can not use remaining_arguments from above.
+          int new_argc = n_remaining_arguments + 1;
+          std::vector<char *> args; // use to construct a new argv of type char **
+          args.emplace_back(argv[0]);
+          for (int i=0; i<n_remaining_arguments; ++i)
+            args.emplace_back(argv[i+current_argument]);
+          char **new_argv = args.data();
+
+          // Finally run catch
+          return Catch::Session().run(new_argc, new_argv);
+        }
+
+
+      deallog.depth_console(0);
+
+      const bool i_am_proc_0 = (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0);
+
+      if (i_am_proc_0)
+        {
+          // Output header, except for a clean output for xml or plugin graph
+          if (!output_xml && !output_json && !output_plugin_graph && !validate_only)
+            print_aspect_header(std::cout);
+
+          if (output_help)
+            print_help();
+
+          // If only help or version is requested, we are done.
+          if (output_help || output_version)
+            return 0;
+        }
+      else
+        {
+          // If only help or version is requested, we are done.
+          if (output_help || output_version)
+            return 0;
+
+          // We hook into the abort handler on ranks != 0 to avoid an MPI
+          // deadlock. The deal.II library will call std::abort() when an
+          // Assert is triggered, which can lead to a deadlock because it
+          // runs the things that are associated with atexit() which may
+          // itself trigger MPI communication. The same happens for other
+          // signals we may trigger, such as floating point exceptions
+          // (SIGFPE).
+          //
+          // We work around this by immediately calling _Exit in the
+          // signal handler and thus aborting the program without running
+          // cleanup functions set via atexit(). This is only necessary on
+          // rank != 0 for some reason.
+          std::signal(SIGABRT, signal_handler);
+          std::signal(SIGFPE, signal_handler);
+        }
+
+      // If no parameter given or somebody gave additional parameters,
+      // show help and exit.
+      if ((prm_name == "") || (current_argument < argc))
+        {
+          if (i_am_proc_0)
+            print_help();
+          return 0;
+        }
+
+      // See where to read input from, then do the reading and
+      // put the contents of the input into a string.
+      const std::string raw_input_as_string = read_parameter_file(prm_name, MPI_COMM_WORLD);
+
+      // Replace $ASPECT_SOURCE_DIR in the input so that include statements
+      // like "include $ASPECT_SOURCE_DIR/tests/bla.prm" work.
+      const std::string input_as_string = aspect::Utilities::expand_ASPECT_SOURCE_DIR(raw_input_as_string);
+
+      // Determine the dimension we want to work in. the default
+      // is 2, but if we find a line of the kind "set Dimension = ..."
+      // then the last such line wins.
+      const unsigned int dim = get_dimension(input_as_string);
+
+      // Do the same with lines potentially indicating shared libs to
+      // be loaded. These shared libs could contain additional module
+      // instantiations for geometries, etc, that would then be
+      // available as part of the possible parameters of the input
+      // file, so they need to be loaded before we even start processing
+      // the parameter file.
+      possibly_load_shared_libs (input_as_string);
+
+      // Now switch between the templates that start the model for 2d or 3d.
+      switch (dim)
+        {
+          case 2:
+          {
+            run_simulator<2>(raw_input_as_string,input_as_string,output_json,output_xml,output_plugin_graph,validate_only);
+            break;
+          }
+          case 3:
+          {
+            run_simulator<3>(raw_input_as_string,input_as_string,output_json,output_xml,output_plugin_graph,validate_only);
+            break;
+          }
+          default:
+            AssertThrow((dim >= 2) && (dim <= 3),
+                        ExcMessage ("ASPECT can only be run in 2d and 3d but a "
+                                    "different space dimension is given in the parameter file."));
+        }
+    }
+  catch (ExceptionBase &exc)
+    {
+      // report name of the deal.II exception:
+      std::cerr << std::endl << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+      std::cerr << "Exception '" << exc.get_exc_name() << "'"
+                << " on rank " << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                << " on processing: " << std::endl
+                << exc.what() << std::endl
+                << "Aborting!" << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+
+      MPI_Abort(MPI_COMM_WORLD, 1);
+      return 1;
+    }
+  catch (std::exception &exc)
+    {
+      std::cerr << std::endl << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+      std::cerr << "Exception"
+                << " on rank " << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                << " on processing: " << std::endl
+                << exc.what() << std::endl
+                << "Aborting!" << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+
+      MPI_Abort(MPI_COMM_WORLD, 1);
+      return 1;
+    }
+  catch (aspect::QuietException &)
+    {
+      // Quietly treat an exception used on processors other than root
+      // when we already know that processor 0 will generate an
+      // exception. We do this to avoid creating too much (duplicate)
+      // screen output. Note that QuietException is not derived from
+      // std::exception, so the order of this and the previous 'catch'
+      // block does not matter.
+      //
+      // Sleep a few seconds before aborting. This allows text output from
+      // other ranks to be printed before the MPI implementation might kill
+      // the computation.
+      std::this_thread::sleep_for(std::chrono::seconds(5));
+
+      MPI_Abort(MPI_COMM_WORLD, 1);
+      return 1;
+    }
+  catch (...)
+    {
+      std::cerr << std::endl << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+      std::cerr << "Unknown exception!" << std::endl
+                << "Aborting!" << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+
+      MPI_Abort(MPI_COMM_WORLD, 1);
+      return 1;
+    }
+
+  return 0;
+}
diff --git a/source/material_model/ascii_reference_profile.cc.bak b/source/material_model/ascii_reference_profile.cc.bak
new file mode 100644
index 00000000000..d43d40df713
--- /dev/null
+++ b/source/material_model/ascii_reference_profile.cc.bak
@@ -0,0 +1,280 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/ascii_reference_profile.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    AsciiReferenceProfile<dim>::AsciiReferenceProfile()
+      :
+      density_index(numbers::invalid_unsigned_int),
+      thermal_expansivity_index(numbers::invalid_unsigned_int),
+      specific_heat_index(numbers::invalid_unsigned_int),
+      compressibility_index(numbers::invalid_unsigned_int),
+      seismic_vp_index(numbers::invalid_unsigned_int),
+      seismic_vs_index(numbers::invalid_unsigned_int),
+      seismic_dvp_dT_index(numbers::invalid_unsigned_int),
+      seismic_dvs_dT_index(numbers::invalid_unsigned_int)
+    {}
+
+    template <int dim>
+    void
+    AsciiReferenceProfile<dim>::initialize ()
+    {
+      profile.initialize(this->get_mpi_communicator());
+
+      density_index = profile.get_column_index_from_name("density");
+      thermal_expansivity_index = profile.get_column_index_from_name("thermal_expansivity");
+      specific_heat_index = profile.get_column_index_from_name("specific_heat");
+      compressibility_index = profile.get_column_index_from_name("compressibility");
+
+      // these are only optional entries in the data file, read them in if they exist,
+      // but keep the invalid unsigned int entry if the columns do not exist
+      // the strings have to be all lower case for the lookup class to find them
+      seismic_vp_index = profile.maybe_get_column_index_from_name("seismic_vp");
+      seismic_vs_index = profile.maybe_get_column_index_from_name("seismic_vs");
+      seismic_dvp_dT_index = profile.maybe_get_column_index_from_name("seismic_dvp_dt");
+      seismic_dvs_dT_index = profile.maybe_get_column_index_from_name("seismic_dvs_dt");
+    }
+
+    template <int dim>
+    void
+    AsciiReferenceProfile<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const Point<dim> position = in.position[i];
+          const double temperature_deviation = in.temperature[i] - this->get_adiabatic_conditions().temperature(position);
+          const double pressure_deviation = in.pressure[i] - this->get_adiabatic_conditions().pressure(position);
+
+          const double depth = this->get_geometry_model().depth(position);
+          const Point<1> profile_position(depth);
+
+          double visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*temperature_deviation/this->get_adiabatic_conditions().temperature(position)),1e3),1e-3);
+          if (std::isnan(visc_temperature_dependence))
+            visc_temperature_dependence = 1.0;
+
+          double visc_depth_dependence = viscosity_prefactors[0];
+          for (unsigned int j=0; j < transition_depths.size(); ++j)
+            {
+              if (depth>transition_depths[j])
+                visc_depth_dependence = viscosity_prefactors[j+1];
+            }
+
+          out.viscosities[i] = viscosity * visc_temperature_dependence * visc_depth_dependence;
+
+          out.thermal_conductivities[i] = thermal_conductivity;
+
+          out.thermal_expansion_coefficients[i] = profile.get_data_component(profile_position,thermal_expansivity_index);
+          out.specific_heat[i] = profile.get_data_component(profile_position,specific_heat_index);
+          out.compressibilities[i] = profile.get_data_component(profile_position,compressibility_index);
+
+          out.densities[i] = profile.get_data_component(profile_position,density_index)
+                             * (1.0 - out.thermal_expansion_coefficients[i] * temperature_deviation)
+                             * (tala ? 1.0 : (1.0 + out.compressibilities[i] * pressure_deviation));
+
+          out.entropy_derivative_pressure[i] = 0.0;
+          out.entropy_derivative_temperature[i] = 0.0;
+
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+
+          // fill seismic velocities outputs if they exist
+          if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
+            {
+              if (seismic_vp_index != numbers::invalid_unsigned_int)
+                seismic_out->vp[i] = profile.get_data_component(profile_position,seismic_vp_index);
+              if (seismic_vs_index != numbers::invalid_unsigned_int)
+                seismic_out->vs[i] = profile.get_data_component(profile_position,seismic_vs_index);
+              if (seismic_dvp_dT_index != numbers::invalid_unsigned_int)
+                seismic_out->vp[i] += profile.get_data_component(profile_position,seismic_dvp_dT_index)
+                                      * temperature_deviation;
+              if (seismic_dvs_dT_index != numbers::invalid_unsigned_int)
+                seismic_out->vs[i] += profile.get_data_component(profile_position,seismic_dvs_dT_index)
+                                      * temperature_deviation;
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    AsciiReferenceProfile<dim>::
+    is_compressible () const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiReferenceProfile<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Ascii reference profile");
+        {
+          prm.declare_entry ("Thermal conductivity", "4.0",
+                             Patterns::Double (0.),
+                             "Reference conductivity");
+          prm.declare_entry ("Viscosity", "1e21",
+                             Patterns::Double (0.),
+                             "Viscosity");
+          prm.declare_entry ("Use TALA", "false",
+                             Patterns::Bool (),
+                             "Whether to use the TALA instead of the ALA "
+                             "approximation.");
+          prm.declare_entry ("Thermal viscosity exponent", "0.",
+                             Patterns::Double (0.),
+                             "The temperature dependence of viscosity. Dimensionless exponent.");
+          prm.declare_entry ("Transition depths", "1.5e5, 4.1e5, 6.6e5",
+                             Patterns::List (Patterns::Double(0.)),
+                             "A list of depths where the viscosity changes. Values must "
+                             "monotonically increase. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Viscosity prefactors", "10., 0.1, 1., 10.",
+                             Patterns::List (Patterns::Double(0.)),
+                             "A list of prefactors for the viscosity that determine the viscosity "
+                             "profile. Each prefactor is applied in a depth range specified by the "
+                             "list of `Transition depths', i.e. the first prefactor is applied above "
+                             "the first transition depth, the second one between the first and second "
+                             "transition depth, and so on. "
+                             "To compute the viscosity profile, this prefactor is multiplied by the "
+                             "reference viscosity specified through the parameter `Viscosity'. "
+                             "List must have one more entry than Transition depths. "
+                             "Units: non-dimensional.");
+
+          aspect::Utilities::AsciiDataProfile<dim>::declare_parameters(prm,
+                                                                       "$ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/",
+                                                                       "");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiReferenceProfile<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Ascii reference profile");
+        {
+          tala                 = prm.get_bool ("Use TALA");
+          thermal_conductivity = prm.get_double ("Thermal conductivity");
+          viscosity            = prm.get_double ("Viscosity");
+          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
+          transition_depths    = Utilities::string_to_double
+                                 (Utilities::split_string_list(prm.get ("Transition depths")));
+          viscosity_prefactors = Utilities::string_to_double
+                                 (Utilities::split_string_list(prm.get ("Viscosity prefactors")));
+
+          // make sure to check against the depth lists for size errors, since using depth
+          if (viscosity_prefactors.size() != transition_depths.size()+1)
+            AssertThrow(false, ExcMessage("Error: The list of Viscosity prefactors needs to have exactly "
+                                          "one more entry than the list of Transition depths. "));
+
+          profile.parse_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.density = NonlinearDependence::pressure | NonlinearDependence::temperature;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiReferenceProfile<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr
+          && seismic_vp_index != numbers::invalid_unsigned_int
+          && seismic_vs_index != numbers::invalid_unsigned_int)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(AsciiReferenceProfile,
+                                   "ascii reference profile",
+                                   "A material model that reads in a reference "
+                                   "state for density, thermal expansivity, compressibility "
+                                   "and specific heat from a text file. "
+                                   "\n"
+                                   "Note the required format of the "
+                                   "input data: The first lines may contain any number of comments "
+                                   "if they begin with `#', but one of these lines needs to "
+                                   "contain the number of points in the reference state as "
+                                   "for example `# POINTS: 3'. "
+                                   "Following the comment lines there has to be a single line "
+                                   "containing the names of all data columns, separated by arbitrarily "
+                                   "many spaces. Column names are not allowed to contain spaces. "
+                                   "The file can contain unnecessary columns, but for this plugin it "
+                                   "needs to at least provide the columns named `density', "
+                                   "`thermal\\_expansivity', `specific\\_heat', and `compressibility'. "
+                                   "Note that the data lines in the file need to be sorted in order "
+                                   "of increasing depth from 0 to the maximal depth in the model "
+                                   "domain. Points in the model that are outside of the provided "
+                                   "depth range will be assigned the maximum or minimum depth values, "
+                                   "respectively. Points do not need to be equidistant, "
+                                   "but the computation of properties is optimized in speed "
+                                   "if they are."
+                                   "\n"
+                                   "\n"
+                                   "The viscosity $\\eta$ is computed as "
+                                   "$\\eta(z,T) = \\eta_r(z) \\eta_0 \\exp\\left(-A \\frac{T - T_{\\text{adi}}}{T_{\\text{adi}}}\\right)$, "
+                                   "where $\\eta_r(z)$ is the depth-dependence, which is a "
+                                   "piecewise constant function computed according to the "
+                                   "list of ``Viscosity prefactors'' and ``Transition depths'', "
+                                   "$\\eta_0$ is the reference viscosity specified by the parameter ``Viscosity'' "
+                                   "and $A$ describes the dependence on temperature and corresponds to "
+                                   "the parameter ``Thermal viscosity exponent''.")
+  }
+}
diff --git a/source/material_model/averaging.cc.bak b/source/material_model/averaging.cc.bak
new file mode 100644
index 00000000000..d9ad5a02ea4
--- /dev/null
+++ b/source/material_model/averaging.cc.bak
@@ -0,0 +1,464 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <array>
+#include <aspect/material_model/averaging.h>
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    AveragingOperation
+    Averaging<dim>::parse_averaging_operation_name (const std::string &s)
+    {
+      if (s == "none")
+        return none;
+      else if (s == "arithmetic average")
+        return arithmetic_average;
+      else if (s == "harmonic average")
+        return harmonic_average;
+      else if (s == "geometric average")
+        return geometric_average;
+      else if (s == "pick largest")
+        return pick_largest;
+      else if (s == "log average")
+        return log_average;
+      else if (s == "nwd arithmetic average")
+        return nwd_arithmetic_average;
+      else if (s == "nwd harmonic average")
+        return nwd_harmonic_average;
+      else if (s == "nwd geometric average")
+        return nwd_geometric_average;
+      else
+        AssertThrow (false,
+                     ExcMessage ("The value <" + s + "> for a material "
+                                 "averaging operation is not one of the "
+                                 "valid values."));
+
+      return none;
+    }
+
+    // Do the requested averaging operation for one array.
+    template <int dim>
+    void
+    Averaging<dim>::average (const AveragingOperation averaging_operation,
+                             const std::vector<Point<dim>>    &position,
+                             std::vector<double>           &values_out) const
+    {
+      // if an output field has not been filled (because it was
+      // not requested), then simply do nothing -- no harm no foul
+      if (values_out.size() == 0)
+        return;
+
+      const unsigned int N = values_out.size();
+
+      // alfad is a constant which is dependent on the dimension and is used to define the shape of the bell shape.
+      const double alfad = (dim == 2 ? 5/(numbers::PI * bell_shape_limit * bell_shape_limit) : 106/(numbers::PI * bell_shape_limit * bell_shape_limit * bell_shape_limit));
+
+      // perform the requested averaging
+      switch (averaging_operation)
+        {
+          case none:
+          {
+            break;
+          }
+          case arithmetic_average:
+          {
+            double sum = 0;
+            for (unsigned int i=0; i<N; ++i)
+              sum += values_out[i];
+
+            const double average = sum/N;
+            for (unsigned int i=0; i<N; ++i)
+              values_out[i] = average;
+            break;
+          }
+          case harmonic_average:
+          {
+            // if one of the values is zero, the average is 0.0
+            for (unsigned int i=0; i<N; ++i)
+              if (values_out[i] == 0.0)
+                {
+                  for (unsigned int j=0; j<N; ++j)
+                    values_out[j] = 0.0;
+                  return;
+                }
+
+            double sum = 0;
+            for (unsigned int i=0; i<N; ++i)
+              sum += 1./values_out[i];
+
+            const double average = 1./(sum/N);
+            for (unsigned int i=0; i<N; ++i)
+              values_out[i] = average;
+            break;
+          }
+          case geometric_average:
+          {
+            double prod = 1;
+            for (unsigned int i=0; i<N; ++i)
+              {
+                Assert (values_out[i] >= 0,
+                        ExcMessage ("Computing the geometric average "
+                                    "only makes sense for non-negative "
+                                    "quantities."));
+                prod *= values_out[i];
+              }
+
+            const double average = std::pow (prod, 1./N);
+            for (unsigned int i=0; i<N; ++i)
+              values_out[i] = average;
+            break;
+          }
+          case pick_largest:
+          {
+            double max = std::numeric_limits<double>::lowest();
+            for (unsigned int i=0; i<N; ++i)
+              max = std::max(max, values_out[i]);
+
+            for (unsigned int i=0; i<N; ++i)
+              values_out[i] = max;
+            break;
+          }
+          case log_average:
+          {
+            double sum = 0;
+            for (unsigned int i=0; i<N; ++i)
+              {
+                Assert (values_out[i] >= 0,
+                        ExcMessage ("Computing the log average "
+                                    "only makes sense for non-negative "
+                                    "quantities."));
+                sum += std::log10(values_out[i]);
+              }
+            const double log_value_average = std::pow (10.,sum/N);
+            for (unsigned int i=0; i<N; ++i)
+              values_out[i] = log_value_average;
+            break;
+          }
+          case nwd_arithmetic_average:
+          {
+            // initialize variables
+            double sum_value = 0;
+            double sum_weights = 0;
+            std::vector<double> temp_values(N,0);
+
+            // determine the maximum distance between all the points
+            double max_distance = 0;
+            for (unsigned int i=0; i<N; ++i)
+              {
+                for (unsigned int j=0; j<N; ++j)
+                  {
+                    max_distance = std::max (max_distance, position[i].distance(position[j]));
+                  }
+              }
+
+            // apply the averaging to the values
+            for (unsigned int i=0; i<N; ++i)
+              {
+                sum_value = 0;
+                sum_weights = 0;
+
+                for (unsigned int j=0; j<N; ++j)
+                  {
+                    const double distance = position[i].distance(position[j])/max_distance;
+                    double weight = alfad * ((1 + 3 * (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)));
+                    if (distance / bell_shape_limit > 1)
+                      weight = 0;
+                    sum_value += weight * values_out[j];
+                    sum_weights += weight;
+                  }
+
+                const double average = sum_value / sum_weights;
+
+                temp_values[i] = average;
+              };
+            for (unsigned int i = 0; i<N; ++i)
+              {
+                values_out[i] = temp_values[i];
+              }
+            break;
+          }
+          case nwd_harmonic_average:
+          {
+            // if one of the values is zero, the average is 0.0
+            for (unsigned int i=0; i<N; ++i)
+              if (values_out[i] == 0.0)
+                {
+                  for (unsigned int j=0; j<N; ++j)
+                    values_out[j] = 0.0;
+                  return;
+                }
+
+            // initialize variables
+            double sum_value = 0;
+            double sum_weights = 0;
+            std::vector<double> temp_values(N,0);
+
+            // determine the maximum distance between all the points
+            double max_distance = 0;
+            for (unsigned int i=0; i<N; ++i)
+              {
+                for (unsigned int j=0; j<N; ++j)
+                  {
+                    max_distance = std::max (max_distance, position[i].distance(position[j]));
+                  }
+              }
+
+            // apply the averaging to the values
+            for (unsigned int i=0; i<N; ++i)
+              {
+                sum_value = 0;
+                sum_weights = 0;
+
+                for (unsigned int j=0; j<N; ++j)
+                  {
+                    const double distance = position[i].distance(position[j])/max_distance;
+                    double weight = alfad * ((1 + 3 * (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)));
+                    if (distance > bell_shape_limit )
+                      weight = 0;
+                    if (values_out[j] != 0)
+                      {
+                        sum_value += weight / values_out[j];
+                      }
+                    sum_weights += weight;
+                  }
+                const double average = sum_weights / sum_value;
+
+                temp_values[i] = average;
+              };
+            for (unsigned int i = 0; i<N; ++i)
+              {
+                values_out[i] = temp_values[i];
+              }
+            break;
+          }
+          case nwd_geometric_average:
+          {
+            // initialize variables
+            double sum_value = 0;
+            double sum_weights = 0;
+            std::vector<double> temp_values(N,0);
+
+            // determine the maximum distance between all the points
+            double max_distance = 0;
+            for (unsigned int i=0; i<N; ++i)
+              {
+                for (unsigned int j=0; j<N; ++j)
+                  {
+                    max_distance = std::max (max_distance, position[i].distance(position[j]));
+                  }
+              }
+
+            // apply the averaging to the values
+            for (unsigned int i=0; i<N; ++i)
+              {
+                sum_value = 0;
+                sum_weights = 0;
+
+                Assert (values_out[i] >= 0,
+                        ExcMessage ("Computing the geometric average "
+                                    "only makes sense for non-negative "
+                                    "quantities."));
+
+                for (unsigned int j=0; j<N; ++j)
+                  {
+
+                    const double distance = position[i].distance(position[j])/max_distance;
+                    double weight = alfad * ((1 + 3 * (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)));
+
+                    // the weight beyond the bell shape limit should always be zero.
+                    if (distance > bell_shape_limit )
+                      weight = 0;
+
+                    /**
+                     * If the value is zero to begin with the log of that value will return nan.
+                     * To prevent this from happening nothing is added to sum_value in this case.
+                     */
+                    if (values_out[j] != 0)
+                      {
+                        sum_value += weight*log(values_out[j]);
+                      }
+
+                    sum_weights += weight;
+
+                  }
+                const double average = std::exp (sum_value/sum_weights);
+
+
+                temp_values[i] = average;
+              };
+            for (unsigned int i = 0; i<N; ++i)
+              {
+                values_out[i] = temp_values[i];
+              }
+            break;
+          }
+          default:
+          {
+            AssertThrow (false,
+                         ExcMessage ("This averaging operation is not implemented."));
+          }
+        }
+    }
+
+    template <int dim>
+    void
+    Averaging<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                             typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      // fill variable out with the results form the base material model
+      base_model -> evaluate(in,out);
+
+      /**
+       * Check if the size of the densities (and thereby all the other vectors) is larger
+       * than one. Averaging over one or zero points does not make a difference anyway,
+       * and the normalized weighted distance averaging schemes need the distance between
+       * the points and can not handle a distance of zero.
+       */
+      if (out.n_evaluation_points() > 1)
+        {
+          /* Average the base model values based on the chosen average */
+          average (averaging_operation,in.position,out.viscosities);
+          average (averaging_operation,in.position,out.densities);
+          average (averaging_operation,in.position,out.thermal_expansion_coefficients);
+          average (averaging_operation,in.position,out.specific_heat);
+          average (averaging_operation,in.position,out.thermal_conductivities);
+          average (averaging_operation,in.position,out.compressibilities);
+          average (averaging_operation,in.position,out.entropy_derivative_pressure);
+          average (averaging_operation,in.position,out.entropy_derivative_temperature);
+        }
+    }
+
+    template <int dim>
+    void
+    Averaging<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Averaging");
+        {
+          prm.declare_entry("Base model","simple",
+                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
+                            "The name of a material model that will be modified by an "
+                            "averaging operation. Valid values for this parameter "
+                            "are the names of models that are also valid for the "
+                            "``Material models/Model name'' parameter. See the documentation for "
+                            "that for more information.");
+          prm.declare_entry ("Averaging operation", "none",
+                             Patterns::Selection ("none|arithmetic average|harmonic average|geometric average|pick largest|log average|nwd arithmetic average|nwd harmonic average|nwd geometric average"),
+                             "Choose the averaging operation to use.");
+          prm.declare_entry ("Bell shape limit", "1.",
+                             Patterns::Double(0.),
+                             "The limit normalized distance between 0 and 1 where the bell shape becomes zero. See the manual for a more information.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    Averaging<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Averaging");
+        {
+          Assert( prm.get("Base model") != "averaging",
+                  ExcMessage("You may not use ``averaging'' as the base model for "
+                             "a averaging model.") );
+
+          // create the base model and initialize its SimulatorAccess base
+          // class; it will get a chance to read its parameters below after we
+          // leave the current section
+          base_model = create_material_model<dim>(prm.get("Base model"));
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
+            sim->initialize_simulator (this->get_simulator());
+
+          averaging_operation = Averaging<dim>::parse_averaging_operation_name(prm.get ("Averaging operation"));
+          bell_shape_limit = prm.get_double ("Bell shape limit");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      /* After parsing the parameters for averaging, it is essential to parse
+      parameters related to the base model. */
+      base_model->parse_parameters(prm);
+      this->model_dependence = base_model->get_model_dependence();
+    }
+
+    template <int dim>
+    bool
+    Averaging<dim>::
+    is_compressible () const
+    {
+      return base_model->is_compressible();
+    }
+
+    template <int dim>
+    void
+    Averaging<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      base_model->create_additional_named_outputs(out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Averaging,
+                                   "averaging",
+                                   "The ``averaging'' Material model applies an averaging of the quadrature points "
+                                   "within a cell. The values to average are supplied by any of the other available "
+                                   "material models. In other words, it is a ``compositing material model''. "
+                                   "Parameters related to the average model are read from a subsection "
+                                   "``Material model/Averaging''."
+                                   "\n\n"
+                                   "The user must specify a ``Base model'' from which material properties are "
+                                   "derived. Furthermore an averaging operation must be selected, where the "
+                                   "Choice should be from the list none|arithmetic average|harmonic average|"
+                                   "geometric average|pick largest|log average|NWD arithmetic average|NWD harmonic average"
+                                   "|NWD geometric average."
+                                   "\n\n"
+                                   "NWD stands for Normalized Weighed Distance. The models with this in front "
+                                   "of their name work with a weighed average, which means each quadrature point "
+                                   "requires an individual weight. The weight is determined by the distance, where "
+                                   "the exact relation is determined by a bell shaped curve. A bell shaped curve is "
+                                   "a continuous function which is one at its maximum and exactly zero at and beyond "
+                                   "its limit. This bell shaped curve is spanned around each quadrature point to "
+                                   "determine the weighting map for each quadrature point. The used bell shape comes "
+                                   "from Lucy (1977). The distance is normalized so the largest distance becomes one. "
+                                   "This means that if variable ''Bell shape limit'' is exactly one, the farthest "
+                                   "quadrature point is just on the limit and its weight will be exactly zero. In "
+                                   "this plugin it is not implemented as larger and equal than the limit, but larger "
+                                   "than, to ensure the quadrature point at distance zero is always included."
+                                  )
+  }
+}
diff --git a/source/material_model/compositing.cc.bak b/source/material_model/compositing.cc.bak
new file mode 100644
index 00000000000..c091017a1be
--- /dev/null
+++ b/source/material_model/compositing.cc.bak
@@ -0,0 +1,259 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/compositing.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Property
+    {
+      namespace
+      {
+        const std::pair<std::string, MaterialProperty> property_map_pairs[]
+        =
+        {
+          {"Viscosity", viscosity},
+          {"Density", density},
+          {"Thermal expansion coefficient", thermal_expansion_coefficient},
+          {"Specific heat", specific_heat},
+          {"Thermal conductivity", thermal_conductivity},
+          {"Compressibility", compressibility},
+          {"Entropy derivative pressure", entropy_derivative_pressure},
+          {"Entropy derivative temperature", entropy_derivative_temperature},
+          {"Reaction terms", reaction_terms}
+        };
+
+
+        const std::map<std::string, MaterialProperty>
+        property_map (std::begin(property_map_pairs),
+                      std::end(property_map_pairs));
+      }
+    }
+
+
+    template <int dim>
+    void
+    Compositing<dim>::copy_required_properties(const unsigned int model_index,
+                                               const typename Interface<dim>::MaterialModelOutputs &base_output,
+                                               typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      if (model_property_map.find(Property::viscosity)->second == model_index)
+        out.viscosities = base_output.viscosities;
+      if (model_property_map.find(Property::density)->second == model_index)
+        out.densities = base_output.densities;
+      if (model_property_map.find(Property::thermal_expansion_coefficient)->second == model_index)
+        out.thermal_expansion_coefficients = base_output.thermal_expansion_coefficients;
+      if (model_property_map.find(Property::specific_heat)->second == model_index)
+        out.specific_heat = base_output.specific_heat;
+      if (model_property_map.find(Property::thermal_conductivity)->second == model_index)
+        out.thermal_conductivities = base_output.thermal_conductivities;
+      if (model_property_map.find(Property::compressibility)->second == model_index)
+        out.compressibilities = base_output.compressibilities;
+      if (model_property_map.find(Property::entropy_derivative_pressure)->second == model_index)
+        out.entropy_derivative_pressure = base_output.entropy_derivative_pressure;
+      if (model_property_map.find(Property::entropy_derivative_temperature)->second == model_index)
+        out.entropy_derivative_temperature = base_output.entropy_derivative_temperature;
+      if (model_property_map.find(Property::reaction_terms)->second == model_index)
+        out.reaction_terms = base_output.reaction_terms;
+    }
+
+
+
+    template <int dim>
+    void
+    Compositing<dim>::initialize ()
+    {
+      // initialize all models
+      for (auto &model : models)
+        model->initialize();
+    }
+
+
+    template <int dim>
+    void
+    Compositing<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                               typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      typename Interface<dim>::MaterialModelOutputs base_output(out.n_evaluation_points(),
+                                                                this->introspection().n_compositional_fields);
+
+      // Move the additional outputs to base_output so that our models can fill them if desired:
+      base_output.move_additional_outputs_from(out);
+
+      for (unsigned int i=0; i<models.size(); ++i)
+        {
+          models[i]->evaluate(in, base_output);
+          copy_required_properties(i, base_output, out);
+        }
+
+      // Finally, we move the additional outputs back into place:
+      out.move_additional_outputs_from(base_output);
+    }
+
+
+
+    template <int dim>
+    void
+    Compositing<dim>::
+    create_additional_named_outputs (typename Interface<dim>::MaterialModelOutputs &outputs) const
+    {
+      for (unsigned int i=0; i<models.size(); ++i)
+        {
+          models[i]->create_additional_named_outputs(outputs);
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Compositing<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Compositing");
+        {
+          std::map<std::string, Property::MaterialProperty>::const_iterator prop_it = Property::property_map.begin();
+          for (; prop_it != Property::property_map.end(); ++prop_it)
+            {
+              prm.declare_entry(prop_it->first, "unspecified",
+                                Patterns::Selection(
+                                  MaterialModel::get_valid_model_names_pattern<dim>()+"|unspecified"
+                                ),
+                                "Material model to use for " + prop_it->first +". Valid values for this "
+                                "parameter are the names of models that are also valid for the "
+                                "``Material models/Model name'' parameter. See the documentation for "
+                                "that for more information.");
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Compositing<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Compositing");
+        {
+          model_names.clear();
+          std::map<std::string, Property::MaterialProperty>::const_iterator prop_it = Property::property_map.begin();
+          for (; prop_it != Property::property_map.end(); ++prop_it)
+            {
+              const Property::MaterialProperty prop = prop_it->second;
+              const std::string model_name = prm.get(prop_it->first);
+
+              AssertThrow(model_name != "averaging",
+                          ExcMessage("You may not use ``averaging'' as the base model for the "
+                                     + prop_it->first +" property of a compositing material model."));
+              AssertThrow(model_name != "compositing",
+                          ExcMessage("You may not use ``compositing'' as the base model for the "
+                                     + prop_it->first +" property of a compositing material model."));
+
+              // see if we've encountered this base model before. If not,
+              // otherwise put it into a new slot. otherwise
+              // record its number for the current coefficient.
+              std::vector<std::string>::iterator model_position
+                = std::find(model_names.begin(), model_names.end(), model_name);
+              if ( model_position == model_names.end() )
+                {
+                  model_property_map[prop] = model_names.size();
+                  model_names.push_back(model_name);
+                }
+              else
+                model_property_map[prop] = std::distance(model_names.begin(), model_position);
+            }
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // create the models and initialize their SimulatorAccess base
+      // After parsing the parameters for averaging, it is essential to parse
+      // parameters related to the base models
+      models.resize(model_names.size());
+      for (unsigned int i=0; i<model_names.size(); ++i)
+        {
+          models[i] = create_material_model<dim>(model_names[i]);
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(models[i].get()))
+            sim->initialize_simulator (this->get_simulator());
+          models[i]->parse_parameters(prm);
+          // All models will need to compute all quantities, so do so
+          this->model_dependence.viscosity |= models[i]->get_model_dependence().viscosity;
+          this->model_dependence.density |= models[i]->get_model_dependence().density;
+          this->model_dependence.compressibility |= models[i]->get_model_dependence().compressibility;
+          this->model_dependence.specific_heat |= models[i]->get_model_dependence().specific_heat;
+          this->model_dependence.thermal_conductivity |= models[i]->get_model_dependence().thermal_conductivity;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    Compositing<dim>::
+    is_compressible () const
+    {
+      const unsigned int ind = model_property_map.find(Property::compressibility)->second;
+      return models[ind]->is_compressible();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Compositing,
+                                   "compositing",
+                                   "The ``compositing'' Material model selects material model properties from a "
+                                   "given set of other material models, and is intended to make mixing different "
+                                   "material models easier. This is useful, for example, when wanting to "
+                                   "use the melting parameterization of the ``melt simple'' model (which has "
+                                   "a relatively simple viscosity model that only allows for a "
+                                   "temperature- but not strain rate-dependent viscosity) with a more "
+                                   "realistic viscosity model such as that provided by the "
+                                   "``diffusion dislocation'' model."
+                                   "\n\n"
+                                   "Specifically, this material model works by allowing to specify "
+                                   "the name of another material model for each coefficient that material "
+                                   "models are asked for (such as the viscosity, density, etc.). Whenever "
+                                   "the material model is asked for the values of coefficients, it then "
+                                   "evaluates all of the ``base models'' that were listed for the various "
+                                   "coefficients, and copies the values returned by these base models "
+                                   "into the output structure."
+                                   "\n\n"
+                                   "The implementation of this material model is somewhat expensive "
+                                   "because it has to evaluate all material coefficients of all underlying "
+                                   "material models. Consequently, if performance of assembly and postprocessing "
+                                   "is important, then implementing a separate material model is "
+                                   "a better choice than using this material model."
+                                  )
+  }
+}
diff --git a/source/material_model/composition_reaction.cc.bak b/source/material_model/composition_reaction.cc.bak
new file mode 100644
index 00000000000..71f4fdd01ce
--- /dev/null
+++ b/source/material_model/composition_reaction.cc.bak
@@ -0,0 +1,250 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/composition_reaction.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    CompositionReaction<dim>::
+    evaluate(const MaterialModelInputs<dim> &in,
+             MaterialModelOutputs<dim> &out) const
+    {
+      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
+
+      // The Composition reaction model has up to two compositional fields (plus one background field)
+      // that can influence the density
+      const unsigned int n_compositions_for_eos = std::min(this->n_compositional_fields()+1, 3u);
+      EquationOfStateOutputs<dim> eos_outputs (n_compositions_for_eos);
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double temperature = in.temperature[i];
+          const std::vector<double> &composition = in.composition[i];
+          const double delta_temp = temperature-reference_T;
+          double temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/reference_T),1e2),1e-2);
+
+          if (std::isnan(temperature_dependence))
+            temperature_dependence = 1.0;
+
+          switch (composition.size())
+            {
+              case 0:
+                out.viscosities[i] = temperature_dependence * eta;
+                break;
+              case 1:
+                // geometric interpolation
+                out.viscosities[i] = (pow(10, ((1-composition[0]) * log10(eta*temperature_dependence)
+                                               + composition[0] * log10(eta*composition_viscosity_prefactor_1*temperature_dependence))));
+                break;
+              default:
+                out.viscosities[i] = (pow(10, ((1 - 0.5*composition[0] - 0.5*composition[1]) * log10(eta*temperature_dependence)
+                                               + 0.5 * composition[0] * log10(eta*composition_viscosity_prefactor_1*temperature_dependence)
+                                               + 0.5 * composition[1] * log10(eta*composition_viscosity_prefactor_2*temperature_dependence))));
+                break;
+            }
+
+          equation_of_state.evaluate(in, i, eos_outputs);
+
+          std::vector<double> volume_fractions (n_compositions_for_eos, 1.0);
+          for (unsigned int c=0; c<n_compositions_for_eos-1; ++c)
+            {
+              volume_fractions[c+1] = std::max(0.0, in.composition[i][c]);
+              volume_fractions[0] -= volume_fractions[c+1];
+            }
+
+          out.densities[i] = MaterialUtilities::average_value(volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
+
+
+          const double depth = this->get_geometry_model().depth(in.position[i]);
+          for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+            {
+              double delta_C = 0.0;
+              switch (c)
+                {
+                  case 0:
+                    if (depth < reaction_depth) delta_C = -composition[0];
+                    break;
+                  case 1:
+                    if (depth < reaction_depth) delta_C = composition[0];
+                    break;
+                  default:
+                    delta_C = 0.0;
+                    break;
+                }
+              out.reaction_terms[i][c] = delta_C;
+
+              // Fill reaction rate outputs instead of the reaction terms if we use operator splitting
+              // (and then set the latter to zero).
+              if (this->get_parameters().use_operator_splitting)
+                {
+                  if (reaction_rate_out != nullptr)
+                    reaction_rate_out->reaction_rates[i][c] = (this->get_timestep_number() > 0
+                                                               ?
+                                                               out.reaction_terms[i][c] / this->get_timestep()
+                                                               :
+                                                               0.0);
+                  out.reaction_terms[i][c] = 0.0;
+                }
+            }
+
+          out.thermal_expansion_coefficients[i] = eos_outputs.thermal_expansion_coefficients[0];
+          out.specific_heat[i] = eos_outputs.specific_heat_capacities[0];
+          out.thermal_conductivities[i] = k_value;
+          out.compressibilities[i] = eos_outputs.compressibilities[0];
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    CompositionReaction<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    void
+    CompositionReaction<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Composition reaction model");
+        {
+          EquationOfState::LinearizedIncompressible<dim>::declare_parameters (prm, 2);
+
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Viscosity", "5e24",
+                             Patterns::Double (0.),
+                             "The value of the constant viscosity. Units: \\si{\\kilogram\\per\\meter\\per\\second}.");
+          prm.declare_entry ("Composition viscosity prefactor 1", "1.0",
+                             Patterns::Double (0.),
+                             "A linear dependency of viscosity on the first compositional field. "
+                             "Dimensionless prefactor. With a value of 1.0 (the default) the "
+                             "viscosity does not depend on the composition.");
+          prm.declare_entry ("Composition viscosity prefactor 2", "1.0",
+                             Patterns::Double (0.),
+                             "A linear dependency of viscosity on the second compositional field. "
+                             "Dimensionless prefactor. With a value of 1.0 (the default) the "
+                             "viscosity does not depend on the composition.");
+          prm.declare_entry ("Thermal viscosity exponent", "0.0",
+                             Patterns::Double (0.),
+                             "The temperature dependence of viscosity. Dimensionless exponent.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reaction depth", "0.",
+                             Patterns::Double (0.),
+                             "Above this depth the compositional fields react: "
+                             "The first field gets converted to the second field. "
+                             "Units: \\si{\\meter}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    CompositionReaction<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Composition reaction model");
+        {
+          equation_of_state.parse_parameters (prm, 2);
+
+          reference_T                = prm.get_double ("Reference temperature");
+          eta                        = prm.get_double ("Viscosity");
+          composition_viscosity_prefactor_1 = prm.get_double ("Composition viscosity prefactor 1");
+          composition_viscosity_prefactor_2 = prm.get_double ("Composition viscosity prefactor 2");
+          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
+          k_value                    = prm.get_double ("Thermal conductivity");
+          reaction_depth             = prm.get_double ("Reaction depth");
+
+          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
+            AssertThrow(false, ExcMessage("Error: Material model composition reaction with Thermal viscosity exponent can not have reference_T=0."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+
+      if (thermal_viscosity_exponent != 0)
+        this->model_dependence.viscosity |= NonlinearDependence::temperature;
+      if ((composition_viscosity_prefactor_1 != 1.0) ||
+          (composition_viscosity_prefactor_2 != 1.0))
+        this->model_dependence.viscosity |= NonlinearDependence::compositional_fields;
+    }
+
+
+    template <int dim>
+    void
+    CompositionReaction<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (this->get_parameters().use_operator_splitting
+          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points,
+                                                                        this->n_compositional_fields()));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(CompositionReaction,
+                                   "composition reaction",
+                                   "A material model that behaves in the same way as "
+                                   "the simple material model, but includes two compositional "
+                                   "fields and a reaction between them. Above a depth given "
+                                   "in the input file, the first fields gets converted to the "
+                                   "second field. ")
+  }
+}
diff --git a/source/material_model/depth_dependent.cc.bak b/source/material_model/depth_dependent.cc.bak
new file mode 100644
index 00000000000..9efd80cd564
--- /dev/null
+++ b/source/material_model/depth_dependent.cc.bak
@@ -0,0 +1,350 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/depth_dependent.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <boost/lexical_cast.hpp>
+
+#include <limits>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    DepthDependent<dim>::initialize()
+    {
+      base_model->initialize();
+    }
+
+
+
+    template <int dim>
+    void
+    DepthDependent<dim>::update()
+    {
+      base_model->update();
+
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        viscosity_function.set_time (this->get_time() / year_in_seconds);
+      else
+        viscosity_function.set_time (this->get_time());
+    }
+
+
+
+    template <int dim>
+    bool
+    DepthDependent<dim>::
+    is_compressible () const
+    {
+      return base_model->is_compressible();
+    }
+
+
+
+    template <int dim>
+    double
+    DepthDependent<dim>::calculate_depth_dependent_prefactor(const double &depth) const
+    {
+      if (viscosity_source == file)
+        {
+          return depth_dependent_rheology->compute_viscosity(depth) / reference_viscosity;
+        }
+      else if (viscosity_source == function)
+        {
+          const Point<1> dpoint(depth);
+          const double viscosity = viscosity_function.value(dpoint);
+          Assert (viscosity > 0.0, ExcMessage("Viscosity depth function should be larger than zero"));
+          return viscosity / reference_viscosity;
+        }
+      else if (viscosity_source == list)
+        {
+          const unsigned int nlayers = depth_values.size()-1;
+          unsigned int i=0;
+          /* find the layer containing the specified depth and return the corresponding viscosity */
+          while (depth > depth_values[i] && i<nlayers)
+            {
+              /* increment i until depth is above base of layer i */
+              ++i;
+            }
+
+          return viscosity_values[i] / reference_viscosity;
+        }
+      else if (viscosity_source == none)
+        {
+          return 1.0;
+        }
+      else
+        {
+          Assert(false, ExcMessage("Invalid method for viscosity depth dependence"));
+          return 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    DepthDependent<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                                  typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      base_model->evaluate(in,out);
+      if (in.requests_property(MaterialProperties::viscosity))
+        {
+          // Scale the base model viscosity value by the depth dependent prefactor
+          for (unsigned int i=0; i < out.n_evaluation_points(); ++i)
+            {
+              const double depth = this->get_geometry_model().depth(in.position[i]);
+              out.viscosities[i] *= calculate_depth_dependent_prefactor(depth);
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    DepthDependent<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        // Depth-dependent parameters from the rheology plugin
+        Rheology::AsciiDepthProfile<dim>::declare_parameters(prm,
+                                                             "Depth dependent model");
+
+        prm.enter_subsection("Depth dependent model");
+        {
+          prm.declare_entry("Base model","simple",
+                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
+                            "The name of a material model that will be modified by a depth "
+                            "dependent viscosity. Valid values for this parameter "
+                            "are the names of models that are also valid for the "
+                            "``Material models/Model name'' parameter. See the documentation for "
+                            "that for more information.");
+          prm.declare_entry ("Depth dependence method", "None",
+                             Patterns::Selection("Function|File|List|None"),
+                             "Method that is used to specify how the viscosity should vary with depth.");
+          prm.declare_entry("Depth list", "", Patterns::List(Patterns::Double ()),
+                            "A comma-separated list of depth values for use with the ``List'' "
+                            "``Depth dependence method''. The list must be provided in order of "
+                            "increasing depth, and the last value must be greater than or equal to "
+                            "the maximal depth of the model. The depth list is interpreted as a layered "
+                            "viscosity structure and the depth values specify the maximum depths of each "
+                            "layer.");
+          prm.declare_entry("Viscosity list", "", Patterns::List(Patterns::Double ()),
+                            "A comma-separated list of viscosity values, corresponding to the depth values "
+                            "provided in ``Depth list''. The number of viscosity values specified here must "
+                            "be the same as the number of depths provided in ``Depth list''.");
+
+          prm.declare_entry ("Reference viscosity",
+                             boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
+                             Patterns::Double (0.),
+                             "The value of the constant reference viscosity $\\eta_r$ that is used to scale "
+                             "the non-dimensional depth-dependent viscosity prefactor. "
+                             "Units: \\si{\\pascal\\second}.");
+
+          prm.declare_alias ("Data file name","Viscosity depth file");
+
+          prm.enter_subsection("Viscosity depth function");
+          {
+            Functions::ParsedFunction<1>::declare_parameters(prm,1);
+            prm.declare_entry("Function expression","1.0e21");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    DepthDependent<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Depth dependent model");
+        {
+          AssertThrow( prm.get("Base model") != "depth dependent",
+                       ExcMessage("You may not use ``depth dependent'' as the base model for "
+                                  "a depth-dependent model.") );
+
+          // create the base model and initialize its SimulatorAccess base
+          // class; it will get a chance to read its parameters below after we
+          // leave the current section
+          base_model = create_material_model<dim>(prm.get("Base model"));
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
+            sim->initialize_simulator (this->get_simulator());
+
+          if (prm.get("Depth dependence method") == "Function")
+            viscosity_source = function;
+          else if (prm.get("Depth dependence method") == "File")
+            viscosity_source = file;
+          else if (prm.get("Depth dependence method") == "List")
+            viscosity_source = list;
+          else if (prm.get("Depth dependence method") == "None")
+            viscosity_source = none;
+          else
+            {
+              AssertThrow(false, ExcMessage("Unknown method for depth dependence."));
+            }
+
+          depth_values     = Utilities::string_to_double(Utilities::split_string_list(prm.get("Depth list")));
+          viscosity_values = Utilities::string_to_double(Utilities::split_string_list(prm.get("Viscosity list")));
+          /*
+           * check sanity of viscosity list values and depth list values input
+           */
+          if (viscosity_source == list)
+            {
+              /* check that length of depth values and viscosity values are compatible */
+              AssertThrow( depth_values.size() == viscosity_values.size() ,
+                           ExcMessage("Depth list must be same size as Viscosity list"));
+              /* check that list is in ascending order */
+              for (unsigned int i=1; i<depth_values.size(); ++i)
+                AssertThrow(depth_values[i] > depth_values[i-1],
+                            ExcMessage("Viscosity depth values must be strictly ascending"));
+              /* check that last layer includes base of model */
+              AssertThrow( *(depth_values.end()-1) >= this->get_geometry_model().maximal_depth(),
+                           ExcMessage("Last value in Depth list must be greater than or equal to maximal depth of domain"));
+            }
+
+          prm.enter_subsection("Viscosity depth function");
+          {
+            try
+              {
+                viscosity_function.parse_parameters(prm);
+              }
+            catch (...)
+              {
+                std::cerr << "FunctionParser failed to parse\n"
+                          << "\t Viscosity depth function\n"
+                          << "with expression \n"
+                          << "\t' " << prm.get("Function expression") << "'";
+                throw;
+              }
+          }
+          prm.leave_subsection();
+
+          reference_viscosity = prm.get_double("Reference viscosity");
+
+          AssertThrow(reference_viscosity != std::numeric_limits<double>::max(),
+                      ExcMessage("You have to set a reference viscosity for the depth dependent model."));
+        }
+        prm.leave_subsection();
+
+        if (viscosity_source == file)
+          {
+            depth_dependent_rheology = std::make_unique<Rheology::AsciiDepthProfile<dim>>();
+            depth_dependent_rheology->initialize_simulator (this->get_simulator());
+            depth_dependent_rheology->parse_parameters(prm, "Depth dependent model");
+            depth_dependent_rheology->initialize();
+          }
+      }
+      prm.leave_subsection();
+
+      /* After parsing the parameters for depth dependent, it is essential to parse
+      parameters related to the base model. */
+      base_model->parse_parameters(prm);
+      this->model_dependence = base_model->get_model_dependence();
+    }
+
+
+
+    template <int dim>
+    void
+    DepthDependent<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      base_model->create_additional_named_outputs(out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(DepthDependent,
+                                   "depth dependent",
+                                   "The ``depth dependent'' Material model applies a depth-dependent scaling "
+                                   "to the viscosity of any other available material models. In other words, it "
+                                   "is a ``compositing material model''."
+                                   "\n\n"
+                                   "Parameters related to the depth dependent model are read from a subsection "
+                                   "``Material model/Depth dependent model''. "
+                                   "The user must specify a ``Base model'' from which material properties are "
+                                   "derived. Currently the depth dependent model only allows depth dependence of "
+                                   "viscosity - other material properties are taken from the ``Base model''. "
+                                   "Viscosity $\\eta$ at depth $z$ is calculated according to:"
+                                   "$ \\eta(z,p,T,X,...) = \\eta(z) \\eta_b(p,T,X,..)/\\eta_{r}$ "
+                                   "where $\\eta(z)$ is the depth-dependence specified by the depth dependent "
+                                   "model, $\\eta_b(p,T,X,...)$ is the viscosity calculated from the base model, "
+                                   "and $\\eta_{r}$ is the reference viscosity. "
+                                   "In addition to the specification of the ``Base model'', the user must specify "
+                                   "the method to be used to calculate the depth-dependent viscosity $\\eta(z)$ as "
+                                   "``Material model/Depth dependent model/Depth dependence method'', which can be "
+                                   "chosen among ``None|Function|File|List''. Each method and the associated parameters "
+                                   "are as follows:"
+                                   "\n"
+                                   "\n"
+                                   "``Function'': read a user-specified parsed function from the input file in a "
+                                   "subsection ``Material model/Depth dependent model/Viscosity depth function''. "
+                                   "By default, this function is uniformly equal to 1.0e21. Specifying a function "
+                                   "that returns a value less than or equal to 0.0 anywhere in the model domain will "
+                                   "produce an error. "
+                                   "\n"
+                                   "\n"
+                                   "``File'': read a user-specified file containing viscosity values at specified "
+                                   "depths. The file containing depth-dependent viscosities is read from a "
+                                   "directory specified by the user as "
+                                   "``Material model/Depth dependent model/Data directory'', from a file with name "
+                                   "specified as ``Material model/Depth dependent model/Viscosity depth file''. "
+                                   "The format of this file is ascii text and contains two columns with one header line:"
+                                   "\n"
+                                   "\n"
+                                   "example Viscosity depth file:\\\\"
+                                   "Depth (m)    Viscosity (Pa-s)\\\\"
+                                   "0.0000000e+00     1.0000000e+21\\\\"
+                                   "6.7000000e+05     1.0000000e+22\\\\"
+                                   "\n"
+                                   "\n"
+                                   "Viscosity is interpolated from this file using linear interpolation. "
+                                   "``None'': no depth-dependence. Viscosity is taken directly from ``Base model''"
+                                   "\n"
+                                   "\n"
+                                   "``List:'': read a comma-separated list of depth values corresponding to the maximum "
+                                   "depths of layers having constant depth-dependence $\\eta(z)$. The layers must be "
+                                   "specified in order of increasing depth, and the last layer in the list must have a depth "
+                                   "greater than or equal to the maximal depth of the model. The list of layer depths is "
+                                   "specified as ``Material model/Depth dependent model/Depth list'' and the corresponding "
+                                   "list of layer viscosities is specified as "
+                                   "``Material model/Depth dependent model/Viscosity list''"
+                                  )
+  }
+}
diff --git a/source/material_model/diffusion_dislocation.cc.bak b/source/material_model/diffusion_dislocation.cc.bak
new file mode 100644
index 00000000000..70c3147579b
--- /dev/null
+++ b/source/material_model/diffusion_dislocation.cc.bak
@@ -0,0 +1,219 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/diffusion_dislocation.h>
+#include <aspect/utilities.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    DiffusionDislocation<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
+        {
+          // const Point<dim> position = in.position[i];
+          const double temperature = in.temperature[i];
+          const double pressure= in.pressure[i];
+          const std::vector<double> composition = in.composition[i];
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(composition,
+                                                       this->introspection().chemical_composition_field_indices());
+
+          // densities
+          double density = 0.0;
+          for (unsigned int j=0; j < volume_fractions.size(); ++j)
+            {
+              // not strictly correct if thermal expansivities are different, since we are interpreting
+              // these compositions as volume fractions, but the error introduced should not be too bad.
+              const double temperature_factor= (1.0 - thermal_expansivities[j] * (temperature - reference_T));
+              density += volume_fractions[j] * densities[j] * temperature_factor;
+            }
+
+          // thermal expansivities
+          double thermal_expansivity = 0.0;
+          for (unsigned int j=0; j < volume_fractions.size(); ++j)
+            thermal_expansivity += volume_fractions[j] * thermal_expansivities[j];
+
+          // calculate effective viscosity
+          if (in.requests_property(MaterialProperties::viscosity))
+            {
+              Assert(std::isfinite(in.strain_rate[i].norm()),
+                     ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                                "not filled by the caller."));
+              out.viscosities[i] = diffusion_dislocation.compute_viscosity(pressure, temperature, volume_fractions, in.strain_rate[i]);
+            }
+
+          out.densities[i] = density;
+          out.thermal_expansion_coefficients[i] = thermal_expansivity;
+          // Specific heat at the given positions.
+          out.specific_heat[i] = heat_capacity;
+          // Thermal conductivity at the given positions. If the temperature equation uses
+          // the reference density profile formulation, use the reference density to
+          // calculate thermal conductivity. Otherwise, use the real density. If the adiabatic
+          // conditions are not yet initialized, the real density will still be used.
+          if (this->get_parameters().formulation_temperature_equation ==
+              Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile &&
+              this->get_adiabatic_conditions().is_initialized())
+            out.thermal_conductivities[i] = thermal_diffusivity * heat_capacity *
+                                            this->get_adiabatic_conditions().density(in.position[i]);
+          else
+            out.thermal_conductivities[i] = thermal_diffusivity * heat_capacity * density;
+          // Compressibility at the given positions.
+          // The compressibility is given as
+          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
+          out.compressibilities[i] = 0.0;
+          // Pressure derivative of entropy at the given positions.
+          out.entropy_derivative_pressure[i] = 0.0;
+          // Temperature derivative of entropy at the given positions.
+          out.entropy_derivative_temperature[i] = 0.0;
+          // Change in composition due to chemical reactions at the
+          // given positions. The term reaction_terms[i][c] is the
+          // change in compositional field c at point i.
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+    template <int dim>
+    bool
+    DiffusionDislocation<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    DiffusionDislocation<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Diffusion dislocation");
+        {
+          Rheology::DiffusionDislocation<dim>::declare_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    DiffusionDislocation<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Diffusion dislocation");
+        {
+          reference_T = prm.get_double("Reference temperature");
+
+          // Retrieve the list of composition names
+          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+          // Establish that a background field is required here
+          compositional_field_names.insert(compositional_field_names.begin(),"background");
+
+          // Make options file for parsing maps to double arrays
+          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+          // Establish that a background field is required here
+          chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+          Utilities::MapParsing::Options options(chemical_field_names, "Densities");
+          options.list_of_allowed_keys = compositional_field_names;
+
+          densities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Densities"),
+                                                                        options);
+
+          options.property_name = "Thermal expansivities";
+          thermal_expansivities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Thermal expansivities"),
+                                                                                    options);
+
+          // Phenomenological parameters
+          thermal_diffusivity = prm.get_double("Thermal diffusivity");
+          heat_capacity = prm.get_double("Heat capacity");
+
+          diffusion_dislocation.initialize_simulator (this->get_simulator());
+          diffusion_dislocation.parse_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(DiffusionDislocation,
+                                   "diffusion dislocation",
+                                   "An implementation of a viscous rheology including diffusion "
+                                   "and dislocation creep. "
+                                   "Compositional fields can each be assigned individual "
+                                   "activation energies, reference densities, thermal expansivities, "
+                                   "and stress exponents. The effective viscosity is defined as "
+                                   "\n\n"
+                                   "$\\eta_{\\text{eff}} = \\left(\\frac{1}{\\eta_{\\text{eff}}^\\text{diff}}+ "
+                                   "\\frac{1}{\\eta_{\\text{eff}}^\\text{dis}}\\right)^{-1}$ "
+                                   "where "
+                                   "$\\eta_{\\text{i}} = \\frac{1}{2} A^{-\\frac{1}{n_i}} d^\\frac{m_i}{n_i} "
+                                   "\\dot{\\varepsilon_i}^{\\frac{1-n_i}{n_i}} "
+                                   "\\exp\\left(\\frac{E_i^\\ast + PV_i^\\ast}{n_iRT}\\right)$ "
+                                   "\n\n"
+                                   "where $d$ is grain size, $i$ corresponds to diffusion or dislocation creep, "
+                                   "$\\dot{\\varepsilon}$ is the square root of the second invariant of the "
+                                   "strain rate tensor, $R$ is the gas constant, $T$ is temperature, "
+                                   "and $P$ is pressure. "
+                                   "$A_i$ are prefactors, $n_i$ and $m_i$ are stress and grain size exponents "
+                                   "$E_i$ are the activation energies and $V_i$ are the activation volumes. "
+                                   "\n\n"
+                                   "This form of the viscosity equation is commonly used in geodynamic simulations "
+                                   "See, for example, Billen and Hirth (2007), G3, 8, Q08012. Significantly, "
+                                   "other studies may use slightly different forms of the viscosity equation "
+                                   "leading to variations in how specific terms are defined or combined. For "
+                                   "example, the grain size exponent should always be positive in the diffusion "
+                                   "viscosity equation used here, while other studies place the grain size term "
+                                   "in the denominator and invert the sign of the grain size exponent. When "
+                                   "examining previous work, one should carefully check how the viscous "
+                                   "prefactor and grain size terms are defined. "
+                                   " \n\n"
+                                   "The ratio of diffusion to dislocation strain rate is found by Newton's "
+                                   "method, iterating to find the stress which satisfies the above equations. "
+                                   "The value for the components of this formula and additional "
+                                   "parameters are read from the parameter file in subsection "
+                                   "'Material model/DiffusionDislocation'.")
+  }
+}
diff --git a/source/material_model/drucker_prager.cc.bak b/source/material_model/drucker_prager.cc.bak
new file mode 100644
index 00000000000..e59c6808b7a
--- /dev/null
+++ b/source/material_model/drucker_prager.cc.bak
@@ -0,0 +1,323 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/drucker_prager.h>
+#include <aspect/utilities.h>
+#include <aspect/newton.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    DruckerPrager<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // set up additional output for the derivatives
+      MaterialModel::MaterialModelDerivatives<dim> *derivatives;
+      derivatives = out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
+
+      EquationOfStateOutputs<dim> eos_outputs (1);
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          // To avoid negative yield strengths and eventually viscosities,
+          // we make sure the pressure is not negative
+          const double pressure=std::max(in.pressure[i],0.0);
+
+          // calculate effective viscosity
+          if (in.requests_property(MaterialProperties::viscosity))
+            {
+              Assert(std::isfinite(in.strain_rate[i].norm()),
+                     ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                                "not filled by the caller."));
+              const SymmetricTensor<2,dim> strain_rate_deviator = deviator(in.strain_rate[i]);
+
+              // For the very first time this function is called
+              // (the first iteration of the first timestep), this function is called
+              // with a zero input strain rate. We provide a representative reference
+              // strain rate for this case, which avoids division by zero and produces
+              // a representative first guess of the viscosities.
+              //
+              // In later iterations and timesteps we calculate the second moment
+              // invariant of the deviatoric strain rate tensor.
+              // This is equal to the negative of the second principle
+              // invariant of the deviatoric strain rate (calculated with the function second_invariant),
+              // as shown in Appendix A of Zienkiewicz and Taylor (Solid Mechanics, 2000).
+              //
+              // The negative of the second principle invariant is equal to 0.5 e_dot_dev_ij e_dot_dev_ji,
+              // where e_dot_dev is the deviatoric strain rate tensor. The square root of this quantity
+              // gives the common definition of effective strain rate.
+              const double edot_ii_strict = (this->simulator_is_past_initialization() == false
+                                             ?
+                                             // no simulator object available via
+                                             // the SimulatorAccess base class, or the
+                                             // Simulator itself has not been completely
+                                             // initialized. This might mean that we are
+                                             // in a unit test, or at least that we can't
+                                             // rely on any simulator information
+                                             std::fabs(second_invariant(strain_rate_deviator))
+                                             :
+                                             // simulator object is available, but we need to treat the
+                                             // first time step separately
+                                             ((this->get_timestep_number() == 0)
+                                              &&
+                                              (in.strain_rate[i].norm() <= std::numeric_limits<double>::min())
+                                              ?
+                                              reference_strain_rate * reference_strain_rate
+                                              :
+                                              std::fabs(second_invariant(strain_rate_deviator))));
+
+              const double strain_rate_effective = edot_ii_strict;
+
+              // In later time steps, we still need to care about cases of very small
+              // strain rates. We expect the viscosity to approach the maximum_viscosity
+              // in these cases. This check prevents a division-by-zero.
+              if (std::sqrt(strain_rate_effective) <= std::numeric_limits<double>::min())
+                {
+                  out.viscosities[i] = maximum_viscosity;
+
+                  if (derivatives != nullptr)
+                    {
+                      derivatives->viscosity_derivative_wrt_strain_rate[i] = 0.0;
+                      derivatives->viscosity_derivative_wrt_pressure[i] = 0.0;
+                    }
+                }
+              else
+                {
+                  // plasticity
+                  const double eta_plastic = drucker_prager_plasticity.compute_viscosity(cohesion,
+                                                                                         angle_of_internal_friction,
+                                                                                         pressure,
+                                                                                         std::sqrt(strain_rate_effective),
+                                                                                         std::numeric_limits<double>::infinity());
+
+                  const double viscosity_pressure_derivative = drucker_prager_plasticity.compute_derivative(angle_of_internal_friction,std::sqrt(strain_rate_effective));
+
+                  // Cut off the viscosity between a minimum and maximum value to avoid
+                  // a numerically unfavourable large viscosity range.
+                  const double effective_viscosity = 1.0 / ( ( 1.0 / ( eta_plastic + minimum_viscosity ) ) + ( 1.0 / maximum_viscosity ) );
+
+                  Assert(dealii::numbers::is_finite(effective_viscosity), ExcMessage ("Error: Viscosity is not finite."));
+
+                  out.viscosities[i] = effective_viscosity;
+
+                  Assert(dealii::numbers::is_finite(out.viscosities[i]),
+                         ExcMessage ("Error: Averaged viscosity is not finite."));
+
+                  if (derivatives != nullptr)
+                    {
+                      const double averaging_factor = maximum_viscosity * maximum_viscosity
+                                                      / ((eta_plastic + minimum_viscosity + maximum_viscosity) * (eta_plastic + minimum_viscosity + maximum_viscosity));
+                      const SymmetricTensor<2,dim> effective_viscosity_strain_rate_derivatives
+                        = -0.5 * averaging_factor * (eta_plastic / edot_ii_strict) * strain_rate_deviator;
+                      const double effective_viscosity_pressure_derivatives = averaging_factor * viscosity_pressure_derivative;
+
+                      derivatives->viscosity_derivative_wrt_strain_rate[i] = deviator_tensor<dim>() * effective_viscosity_strain_rate_derivatives;
+
+                      derivatives->viscosity_derivative_wrt_pressure[i] = effective_viscosity_pressure_derivatives;
+
+                      Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_pressure[i]),
+                             ExcMessage ("Error: Averaged viscosity_derivative_wrt_pressure is not finite."));
+                      for (int x = 0; x < dim; ++x)
+                        for (int y = 0; y < dim; ++y)
+                          Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]),
+                                 ExcMessage ("Error: Averaged viscosity_derivative_wrt_strain_rate is not finite."));
+
+                    }
+                }
+            }
+
+          equation_of_state.evaluate(in, i, eos_outputs);
+
+          out.densities[i] = eos_outputs.densities[0];
+          out.thermal_expansion_coefficients[i] = eos_outputs.thermal_expansion_coefficients[0];
+          out.specific_heat[i] = eos_outputs.specific_heat_capacities[0];
+          out.thermal_conductivities[i] = thermal_conductivities;
+          out.compressibilities[i] = eos_outputs.compressibilities[0];
+          out.entropy_derivative_pressure[i] = eos_outputs.entropy_derivative_pressure[0];
+          out.entropy_derivative_temperature[i] = eos_outputs.entropy_derivative_temperature[0];
+
+          for (unsigned int c=0; c < in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    DruckerPrager<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    void
+    DruckerPrager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Drucker Prager");
+        {
+          EquationOfState::LinearizedIncompressible<dim>::declare_parameters (prm);
+
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. The reference temperature is used "
+                             "in the density calculation. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.enter_subsection ("Viscosity");
+          {
+
+            prm.declare_entry ("Minimum viscosity", "1e19",
+                               Patterns::Double (0.),
+                               "The value of the minimum viscosity cutoff $\\eta_min$. Units: \\si{\\pascal\\second}.");
+            prm.declare_entry ("Maximum viscosity", "1e24",
+                               Patterns::Double (0.),
+                               "The value of the maximum viscosity cutoff $\\eta_max$. Units: \\si{\\pascal\\second}.");
+            prm.declare_entry ("Reference strain rate", "1e-15",
+                               Patterns::Double (0.),
+                               "The value of the initial strain rate prescribed during the "
+                               "first nonlinear iteration $\\dot{\\epsilon}_ref$. Units: \\si{\\per\\second}.");
+            prm.declare_entry ("Angle of internal friction", "0.",
+                               Patterns::Double (0.),
+                               "The value of the angle of internal friction $\\phi$. "
+                               "For a value of zero, in 2d the von Mises "
+                               "criterion is retrieved. Angles higher than 30 degrees are "
+                               "harder to solve numerically. Units: degrees.");
+            prm.declare_entry ("Cohesion", "2e7",
+                               Patterns::Double (0.),
+                               "The value of the cohesion $C$. Units: \\si{\\pascal}.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    DruckerPrager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Drucker Prager");
+        {
+          equation_of_state.parse_parameters (prm);
+
+          reference_T                = prm.get_double ("Reference temperature");
+          thermal_conductivities     = prm.get_double ("Thermal conductivity");
+          prm.enter_subsection ("Viscosity");
+          {
+            minimum_viscosity          = prm.get_double ("Minimum viscosity");
+            maximum_viscosity          = prm.get_double ("Maximum viscosity");
+            reference_strain_rate      = prm.get_double ("Reference strain rate");
+            // Convert degrees to radians
+            angle_of_internal_friction = prm.get_double ("Angle of internal friction") * constants::degree_to_radians;
+            cohesion                   = prm.get_double ("Cohesion");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+      this->model_dependence.viscosity = NonlinearDependence::strain_rate;
+      this->model_dependence.density = NonlinearDependence::temperature;
+
+      if (angle_of_internal_friction==0.0)
+        this->model_dependence.viscosity |= NonlinearDependence::pressure;
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(DruckerPrager,
+                                   "drucker prager",
+                                   "A material model that has constant values "
+                                   "for all coefficients but the density and viscosity. The defaults for all "
+                                   "coefficients are chosen to be similar to what is believed to be correct "
+                                   "for Earth's mantle. All of the values that define this model are read "
+                                   "from a section ``Material model/Drucker Prager'' in the input file, see "
+                                   "Section~\\ref{parameters:Material_20model/Drucker_20Prager}. "
+                                   "Note that the model does not take into account any dependencies of "
+                                   "material properties on compositional fields. "
+                                   "\n\n"
+                                   "The viscosity is computed according to the Drucker Prager frictional "
+                                   "plasticity criterion (non-associative) based on a user-defined "
+                                   "internal friction angle $\\phi$ and cohesion $C$. In 3d: "
+                                   " $\\sigma_y = \\frac{6 C \\cos(\\phi)}{\\sqrt{3} (3+\\sin(\\phi))} + "
+                                   "\\frac{6 P \\sin(\\phi)}{\\sqrt{3} (3+\\sin(\\phi))}$, "
+                                   "where $P$ is the pressure. "
+                                   "See for example Zienkiewicz, O. C., Humpheson, C. and Lewis, R. W. (1975), "
+                                   "G\\'{e}otechnique 25, No. 4, 671-689. "
+                                   "With this formulation we circumscribe instead of inscribe the Mohr Coulomb "
+                                   "yield surface. "
+                                   "In 2d the Drucker Prager yield surface is the same "
+                                   "as the Mohr Coulomb surface: "
+                                   " $\\sigma_y = P \\sin(\\phi) + C \\cos(\\phi)$. "
+                                   "Note that in 2d for $\\phi=0$, these criteria "
+                                   "revert to the von Mises criterion (no pressure dependence). "
+                                   "See for example \\cite{thieulot:2011}. "
+                                   "\n\n"
+                                   "Note that we enforce the pressure to be positive to prevent negative "
+                                   "yield strengths and viscosities. "
+                                   "\n\n"
+                                   "We then use the computed yield strength to scale back the viscosity on "
+                                   "to the yield surface using the Viscosity Rescaling Method described in "
+                                   "Kachanov, L. M. (2004), Fundamentals of the Theory of Plasticity, "
+                                   "Dover Publications, Inc. (Not Radial Return.)"
+                                   "A similar implementation can be found in GALE "
+                                   "(<https://geodynamics.org/resources/gale>). "
+                                   "\n\n"
+                                   "To avoid numerically unfavourably large (or even negative) viscosity ranges, "
+                                   "we cut off the viscosity with a user-defined minimum and maximum viscosity: "
+                                   "$\\eta_{eff} = \\frac{1}{\\frac{1}{\\eta_{min} + \\eta}+ "
+                                   "\\frac{1}{\\eta_{max}}}$. "
+                                   "\n\n"
+                                   "Note that this model uses the formulation that assumes an incompressible "
+                                   "medium despite the fact that the density follows the law "
+                                   "$\\rho(T)=\\rho_0(1-\\beta(T-T_{\\text{ref}}))$. ")
+  }
+}
diff --git a/source/material_model/entropy_model.cc.bak b/source/material_model/entropy_model.cc.bak
new file mode 100644
index 00000000000..9a4089a3358
--- /dev/null
+++ b/source/material_model/entropy_model.cc.bak
@@ -0,0 +1,577 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/entropy_model.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/table.h>
+#include <fstream>
+#include <iostream>
+#include <aspect/material_model/rheology/visco_plastic.h>
+#include <aspect/material_model/steinberger.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace
+    {
+      template <int dim>
+      bool solver_scheme_is_supported(const Parameters<dim> &parameters)
+      {
+        // If we solve advection equations, we need to iterate them, because this material
+        // models splits temperature diffusion from entropy advection.
+        switch (parameters.nonlinear_solver)
+          {
+            case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_defect_correction_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Newton_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::no_Advection_no_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_defect_correction_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::no_Advection_single_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::first_timestep_only_single_Stokes:
+              return true;
+
+            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_single_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_defect_correction_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Newton_Stokes:
+            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_no_Stokes:
+              return false;
+          }
+        Assert(false, ExcNotImplemented());
+        return false;
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    EntropyModel<dim>::initialize()
+    {
+      AssertThrow (this->get_parameters().formulation_mass_conservation ==
+                   Parameters<dim>::Formulation::MassConservation::projected_density_field,
+                   ExcMessage("The 'entropy model' material model was only tested with the "
+                              "'projected density field' approximation "
+                              "for the mass conservation equation, which is not selected."));
+
+      AssertThrow (this->introspection().composition_type_exists(CompositionalFieldDescription::Type::entropy),
+                   ExcMessage("The 'entropy model' material model requires the existence of a compositional field "
+                              "named 'entropy'. This field does not exist."));
+
+      AssertThrow(solver_scheme_is_supported(this->get_parameters()) == true,
+                  ExcMessage("The 'entropy model' material model requires the use of a solver scheme that "
+                             "iterates over the advection equations but a non iterating solver scheme was selected. "
+                             "Please check the consistency of your solver scheme."));
+
+      AssertThrow(material_file_names.size() == 1 || SimulatorAccess<dim>::get_end_time () == 0,
+                  ExcMessage("The 'entropy model' material model can only handle one composition, "
+                             "and can therefore only read one material lookup table."));
+
+
+
+      for (unsigned int i = 0; i < material_file_names.size(); ++i)
+        {
+          entropy_reader.push_back(std::make_unique<MaterialUtilities::Lookup::EntropyReader>());
+          entropy_reader[i]->initialize(this->get_mpi_communicator(), data_directory, material_file_names[i]);
+        }
+
+      lateral_viscosity_prefactor_lookup = std::make_unique<internal::LateralViscosityLookup>(data_directory+lateral_viscosity_file_name,
+                                           this->get_mpi_communicator());
+    }
+
+
+
+    template <int dim>
+    bool
+    EntropyModel<dim>::
+    is_compressible () const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    double
+    EntropyModel<dim>::
+    thermal_conductivity (const double temperature,
+                          const double pressure,
+                          const Point<dim> &position) const
+    {
+      if (conductivity_formulation == constant)
+        return thermal_conductivity_value;
+
+      else if (conductivity_formulation == p_T_dependent)
+        {
+          // Find the conductivity layer that corresponds to the depth of the evaluation point.
+          const double depth = this->get_geometry_model().depth(position);
+          unsigned int layer_index = std::distance(conductivity_transition_depths.begin(),
+                                                   std::lower_bound(conductivity_transition_depths.begin(),conductivity_transition_depths.end(), depth));
+
+          const double p_dependence = reference_thermal_conductivities[layer_index] + conductivity_pressure_dependencies[layer_index] * pressure;
+
+          // Make reasonably sure we will not compute any invalid values due to the temperature-dependence.
+          // Since both the temperature-dependence and the saturation time scale with (Tref/T), we have to
+          // make sure we can compute the square of this number. If the temperature is small enough to
+          // be close to yielding NaN values, the conductivity will be set to the maximum value anyway.
+          const double T = std::max(temperature, std::sqrt(std::numeric_limits<double>::min()) * conductivity_reference_temperatures[layer_index]);
+          const double T_dependence = std::pow(conductivity_reference_temperatures[layer_index] / T, conductivity_exponents[layer_index]);
+
+          // Function based on the theory of Roufosse and Klemens (1974) that accounts for saturation.
+          // For the Tosi formulation, the scaling should be zero so that this term is 1.
+          double saturation_function = 1.0;
+          if (1./T_dependence > 1.)
+            saturation_function = (1. - saturation_scaling[layer_index])
+                                  + saturation_scaling[layer_index] * (2./3. * std::sqrt(T_dependence) + 1./3. * 1./T_dependence);
+
+          return std::min(p_dependence * saturation_function * T_dependence, maximum_conductivity);
+        }
+      else
+        {
+          AssertThrow(false, ExcNotImplemented());
+          return numbers::signaling_nan<double>();
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    EntropyModel<dim>::evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                                MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      const unsigned int projected_density_index = this->introspection().compositional_index_for_name("density_field");
+      //TODO : need to make it work for more than one field
+      const std::vector<unsigned int> &entropy_indices = this->introspection().get_indices_for_fields_of_type(CompositionalFieldDescription::entropy);
+      const unsigned int entropy_index = entropy_indices[0];
+      const std::vector<unsigned int> &composition_indices = this->introspection().get_indices_for_fields_of_type(CompositionalFieldDescription::chemical_composition);
+
+      AssertThrow(composition_indices.size() == material_file_names.size() - 1,
+                  ExcMessage("The 'entropy model' material model assumes that there exists a background field in addition to the compositional fields, "
+                             "and therefore it requires one more lookup table than there are chemical compositional fields."));
+
+      EquationOfStateOutputs<dim> eos_outputs (material_file_names.size());
+      std::vector<double> volume_fractions (material_file_names.size());
+      std::vector<double> mass_fractions (material_file_names.size());
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          // Use the adiabatic pressure instead of the real one,
+          // to stabilize against pressure oscillations in phase transitions.
+          // This is a requirement of the projected density approximation for
+          // the Stokes equation and not related to the entropy formulation.
+          // Also convert pressure from Pa to bar, bar is used in the table.
+          const double entropy = in.composition[i][entropy_index];
+          const double pressure = this->get_adiabatic_conditions().pressure(in.position[i]) / 1.e5;
+
+          // Loop over all material files, and store the looked-up values for all compositions.
+          for (unsigned int j=0; j<material_file_names.size(); ++j)
+            {
+              eos_outputs.densities[j] = entropy_reader[j]->density(entropy, pressure);
+              eos_outputs.thermal_expansion_coefficients[j] = entropy_reader[j]->thermal_expansivity(entropy,pressure);
+              eos_outputs.specific_heat_capacities[j] = entropy_reader[j]->specific_heat(entropy,pressure);
+
+              const Tensor<1, 2> pressure_unit_vector({0.0, 1.0});
+              eos_outputs.compressibilities[j] = ((entropy_reader[j]->density_gradient(entropy,pressure)) * pressure_unit_vector) / eos_outputs.densities[j];
+            }
+
+          // Calculate volume fractions from mass fractions
+          // If there is only one lookup table, set the mass and volume fractions to 1
+          if (material_file_names.size() == 1)
+            mass_fractions [0] = 1.0;
+
+          else
+            {
+              // We only want to compute mass/volume fractions for fields that are chemical compositions.
+              mass_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[i], this->introspection().chemical_composition_field_indices());
+            }
+
+          volume_fractions = MaterialUtilities::compute_volumes_from_masses(mass_fractions,
+                                                                            eos_outputs.densities,
+                                                                            true);
+
+          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
+          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
+
+          out.specific_heat[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
+
+          out.compressibilities[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
+
+          // Thermal conductivity can be pressure temperature dependent
+          const double temperature_lookup =  entropy_reader[0]->temperature(entropy,pressure);
+          out.thermal_conductivities[i] = thermal_conductivity(temperature_lookup, in.pressure[i], in.position[i]);
+
+          out.entropy_derivative_pressure[i]    = 0.;
+          out.entropy_derivative_temperature[i] = 0.;
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c]            = 0.;
+
+          // set up variable to interpolate prescribed field outputs onto compositional fields
+          if (PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>())
+            {
+              prescribed_field_out->prescribed_field_outputs[i][projected_density_index] = out.densities[i];
+            }
+
+          // set up variable to interpolate prescribed field outputs onto temperature field
+          if (PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>())
+            {
+              prescribed_temperature_out->prescribed_temperature_outputs[i] = temperature_lookup;
+            }
+
+          // Calculate Viscosity
+          if (in.requests_property(MaterialProperties::viscosity))
+            {
+              // read in the viscosity profile
+              const double depth = this->get_geometry_model().depth(in.position[i]);
+              const double viscosity_profile = depth_dependent_rheology->compute_viscosity(depth);
+
+              // lateral viscosity variations
+              const double reference_temperature = this->get_adiabatic_conditions().is_initialized()
+                                                   ?
+                                                   this->get_adiabatic_conditions().temperature(in.position[i])
+                                                   :
+                                                   this->get_parameters().adiabatic_surface_temperature;
+
+              const double delta_temperature = temperature_lookup-reference_temperature;
+
+              // Steinberger & Calderwood viscosity
+              if (temperature_lookup*reference_temperature == 0)
+                out.viscosities[i] = max_eta;
+              else
+                {
+                  double vis_lateral = std::exp(-lateral_viscosity_prefactor_lookup->lateral_viscosity(depth)*delta_temperature/(temperature_lookup*reference_temperature));
+                  // lateral vis variation
+                  vis_lateral = std::max(std::min((vis_lateral),max_lateral_eta_variation),1/max_lateral_eta_variation);
+
+                  if (std::isnan(vis_lateral))
+                    vis_lateral = 1.0;
+
+                  double effective_viscosity = vis_lateral * viscosity_profile;
+
+                  const double strain_rate_effective = std::fabs(second_invariant(deviator(in.strain_rate[i])));
+
+                  if (std::sqrt(strain_rate_effective) >= std::numeric_limits<double>::min())
+                    {
+                      const double pressure =  this->get_adiabatic_conditions().pressure(in.position[i]);
+                      const double eta_plastic = drucker_prager_plasticity.compute_viscosity(cohesion,
+                                                                                             angle_of_internal_friction,
+                                                                                             pressure,
+                                                                                             std::sqrt(strain_rate_effective),
+                                                                                             std::numeric_limits<double>::infinity());
+
+                      effective_viscosity = 1.0 / ( ( 1.0 /  eta_plastic  ) + ( 1.0 / (vis_lateral * viscosity_profile) ) );
+
+                      PlasticAdditionalOutputs<dim> *plastic_out = out.template get_additional_output<PlasticAdditionalOutputs<dim>>();
+                      if (plastic_out != nullptr)
+                        {
+                          plastic_out->cohesions[i] = cohesion;
+                          plastic_out->friction_angles[i] = angle_of_internal_friction;
+                          plastic_out->yielding[i] = eta_plastic < (vis_lateral * viscosity_profile) ? 1 : 0;
+                        }
+                    }
+                  out.viscosities[i] = std::max(std::min(effective_viscosity,max_eta),min_eta);
+                }
+            }
+
+          // fill seismic velocities outputs if they exist
+          if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
+            {
+
+              std::vector<double> vp (material_file_names.size());
+              std::vector<double> vs (material_file_names.size());
+              for (unsigned int j=0; j<material_file_names.size(); ++j)
+                {
+                  vp[j] = entropy_reader[j]->seismic_vp(entropy,pressure);
+                  vs[j] = entropy_reader[j]->seismic_vs(entropy,pressure);
+                }
+              seismic_out->vp[i] = MaterialUtilities::average_value (volume_fractions, vp, MaterialUtilities::arithmetic);
+              seismic_out->vs[i] = MaterialUtilities::average_value (volume_fractions, vs, MaterialUtilities::arithmetic);
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    EntropyModel<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Entropy model");
+        {
+          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/",
+                             Patterns::DirectoryName (),
+                             "The path to the model data. The path may also include the special "
+                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                             "in which the ASPECT source files were located when ASPECT was "
+                             "compiled. This interpretation allows, for example, to reference "
+                             "files located in the `data/' subdirectory of ASPECT.");
+          prm.declare_entry ("Material file name", "material_table.txt",
+                             Patterns::List (Patterns::Anything()),
+                             "The file name of the material data. The first material data file is intended for the background composition. ");
+          prm.declare_entry ("Reference viscosity", "1e22",
+                             Patterns::Double(0),
+                             "The viscosity that is used in this model. "
+                             "\n\n"
+                             "Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Lateral viscosity file name", "temp-viscosity-prefactor.txt",
+                             Patterns::Anything (),
+                             "The file name of the lateral viscosity prefactor.");
+          prm.declare_entry ("Minimum viscosity", "1e19",
+                             Patterns::Double (0.),
+                             "The minimum viscosity that is allowed in the viscosity "
+                             "calculation. Smaller values will be cut off.");
+          prm.declare_entry ("Maximum viscosity", "1e23",
+                             Patterns::Double (0.),
+                             "The maximum viscosity that is allowed in the viscosity "
+                             "calculation. Larger values will be cut off.");
+          prm.declare_entry ("Maximum lateral viscosity variation", "1e2",
+                             Patterns::Double (0.),
+                             "The relative cutoff value for lateral viscosity variations "
+                             "caused by temperature deviations. The viscosity may vary "
+                             "laterally by this factor squared.");
+          prm.declare_entry ("Angle of internal friction", "0.",
+                             Patterns::Double (0.),
+                             "The value of the angle of internal friction, $\\phi$."
+                             "For a value of zero, in 2D the von Mises criterion is retrieved. "
+                             "Angles higher than 30 degrees are harder to solve numerically."
+                             "Units: degrees.");
+          prm.declare_entry ("Cohesion", "1e20",
+                             Patterns::Double (0.),
+                             "The value of the cohesion, $C$. The extremely large default"
+                             "cohesion value (1e20 Pa) prevents the viscous stress from "
+                             "exceeding the yield stress. Units: \\si{\\pascal}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Thermal conductivity formulation", "constant",
+                             Patterns::Selection("constant|p-T-dependent"),
+                             "Which law should be used to compute the thermal conductivity. "
+                             "The 'constant' law uses a constant value for the thermal "
+                             "conductivity. The 'p-T-dependent' formulation uses equations "
+                             "from Stackhouse et al. (2015): First-principles calculations "
+                             "of the lattice thermal conductivity of the lower mantle "
+                             "(https://doi.org/10.1016/j.epsl.2015.06.050), and Tosi et al. "
+                             "(2013): Mantle dynamics with pressure- and temperature-dependent "
+                             "thermal expansivity and conductivity "
+                             "(https://doi.org/10.1016/j.pepi.2013.02.004) to compute the "
+                             "thermal conductivity in dependence of temperature and pressure. "
+                             "The thermal conductivity parameter sets can be chosen in such a "
+                             "way that either the Stackhouse or the Tosi relations are used. "
+                             "The conductivity description can consist of several layers with "
+                             "different sets of parameters. Note that the Stackhouse "
+                             "parametrization is only valid for the lower mantle (bridgmanite).");
+          prm.declare_entry ("Thermal conductivity transition depths", "410000, 520000, 660000",
+                             Patterns::List(Patterns::Double (0.)),
+                             "A list of depth values that indicate where the transitions between "
+                             "the different conductivity parameter sets should occur in the "
+                             "'p-T-dependent' Thermal conductivity formulation (in most cases, "
+                             "this will be the depths of major mantle phase transitions). "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Reference thermal conductivities", "2.47, 3.81, 3.52, 4.9",
+                             Patterns::List(Patterns::Double (0.)),
+                             "A list of base values of the thermal conductivity for each of the "
+                             "horizontal layers in the 'p-T-dependent' thermal conductivity "
+                             "formulation. Pressure- and temperature-dependence will be applied"
+                             "on top of this base value, according to the parameters 'Pressure "
+                             "dependencies of thermal conductivity' and 'Reference temperatures "
+                             "for thermal conductivity'. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}");
+          prm.declare_entry ("Pressure dependencies of thermal conductivity", "3.3e-10, 3.4e-10, 3.6e-10, 1.05e-10",
+                             Patterns::List(Patterns::Double ()),
+                             "A list of values that determine the linear scaling of the "
+                             "thermal conductivity with the pressure in the 'p-T-dependent' "
+                             "thermal conductivity formulation. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin\\per\\pascal}.");
+          prm.declare_entry ("Reference temperatures for thermal conductivity", "300, 300, 300, 1200",
+                             Patterns::List(Patterns::Double (0.)),
+                             "A list of values of reference temperatures used to determine "
+                             "the temperature-dependence of the thermal conductivity in the "
+                             "'p-T-dependent' thermal conductivity formulation. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Thermal conductivity exponents", "0.48, 0.56, 0.61, 1.0",
+                             Patterns::List(Patterns::Double (0.)),
+                             "A list of exponents in the temperature-dependent term of the "
+                             "'p-T-dependent' thermal conductivity formulation. Note that this "
+                             "exponent is not used (and should have a value of 1) in the "
+                             "formulation of Stackhouse et al. (2015). "
+                             "Units: none.");
+          prm.declare_entry ("Saturation prefactors", "0, 0, 0, 1",
+                             Patterns::List(Patterns::Double (0., 1.)),
+                             "A list of values that indicate how a given layer in the "
+                             "conductivity formulation should take into account the effects "
+                             "of saturation on the temperature-dependence of the thermal "
+                             "conducitivity. This factor is multiplied with a saturation function "
+                             "based on the theory of Roufosse and Klemens, 1974. A value of 1 "
+                             "reproduces the formulation of Stackhouse et al. (2015), a value of "
+                             "0 reproduces the formulation of Tosi et al., (2013). "
+                             "Units: none.");
+          prm.declare_entry ("Maximum thermal conductivity", "1000",
+                             Patterns::Double (0.),
+                             "The maximum thermal conductivity that is allowed in the "
+                             "model. Larger values will be cut off.");
+          prm.leave_subsection();
+        }
+
+        // Depth-dependent parameters from the rheology plugin
+        Rheology::AsciiDepthProfile<dim>::declare_parameters(prm,
+                                                             "Depth dependent viscosity");
+
+        prm.leave_subsection();
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    EntropyModel<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Entropy model");
+        {
+          data_directory              = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+          material_file_names          = Utilities::split_string_list(prm.get ("Material file name"));
+          lateral_viscosity_file_name  = prm.get ("Lateral viscosity file name");
+          min_eta                     = prm.get_double ("Minimum viscosity");
+          max_eta                     = prm.get_double ("Maximum viscosity");
+          max_lateral_eta_variation    = prm.get_double ("Maximum lateral viscosity variation");
+          thermal_conductivity_value  = prm.get_double ("Thermal conductivity");
+
+          if (prm.get ("Thermal conductivity formulation") == "constant")
+            conductivity_formulation = constant;
+          else if (prm.get ("Thermal conductivity formulation") == "p-T-dependent")
+            conductivity_formulation = p_T_dependent;
+          else
+            AssertThrow(false, ExcMessage("Not a valid thermal conductivity formulation"));
+
+          conductivity_transition_depths = Utilities::string_to_double
+                                           (Utilities::split_string_list(prm.get ("Thermal conductivity transition depths")));
+          const unsigned int n_conductivity_layers = conductivity_transition_depths.size() + 1;
+          AssertThrow (std::is_sorted(conductivity_transition_depths.begin(), conductivity_transition_depths.end()),
+                       ExcMessage("The list of 'Thermal conductivity transition depths' must "
+                                  "be sorted such that the values increase monotonically."));
+
+          reference_thermal_conductivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Reference thermal conductivities"))),
+                                                                                     n_conductivity_layers,
+                                                                                     "Reference thermal conductivities");
+          conductivity_pressure_dependencies = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Pressure dependencies of thermal conductivity"))),
+                                                                                       n_conductivity_layers,
+                                                                                       "Pressure dependencies of thermal conductivity");
+          conductivity_reference_temperatures = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Reference temperatures for thermal conductivity"))),
+                                                                                        n_conductivity_layers,
+                                                                                        "Reference temperatures for thermal conductivity");
+          conductivity_exponents = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal conductivity exponents"))),
+                                                                           n_conductivity_layers,
+                                                                           "Thermal conductivity exponents");
+          saturation_scaling = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Saturation prefactors"))),
+                                                                       n_conductivity_layers,
+                                                                       "Saturation prefactors");
+          maximum_conductivity = prm.get_double ("Maximum thermal conductivity");
+
+          angle_of_internal_friction = prm.get_double ("Angle of internal friction") * constants::degree_to_radians;
+          cohesion = prm.get_double("Cohesion");
+
+          prm.leave_subsection();
+        }
+
+        depth_dependent_rheology = std::make_unique<Rheology::AsciiDepthProfile<dim>>();
+        depth_dependent_rheology->initialize_simulator (this->get_simulator());
+        depth_dependent_rheology->parse_parameters(prm, "Depth dependent viscosity");
+        depth_dependent_rheology->initialize();
+
+        prm.leave_subsection();
+
+        // Declare dependencies on solution variables
+        this->model_dependence.viscosity = NonlinearDependence::temperature;
+        this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+        this->model_dependence.compressibility = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+        this->model_dependence.specific_heat = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+        this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    EntropyModel<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
+        }
+
+      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>>
+            (n_points, this->n_compositional_fields()));
+        }
+
+      if (out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>>
+            (n_points));
+        }
+
+      if (out.template get_additional_output<PlasticAdditionalOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<PlasticAdditionalOutputs<dim>> (n_points));
+        }
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(EntropyModel,
+                                   "entropy model",
+                                   "A material model that is designed to use pressure and entropy (rather "
+                                   "than pressure and temperature) as independent variables. "
+                                   "It requires a thermodynamic data table that contains "
+                                   "all relevant properties in a specific format as illustrated in "
+                                   "the data/material-model/entropy-table/opxtable example folder. "
+                                   "The material model requires the use of the projected density "
+                                   "approximation for compressibility, and the existence of a "
+                                   "compositional field called 'entropy'.")
+  }
+}
diff --git a/source/material_model/equation_of_state/interface.cc.bak b/source/material_model/equation_of_state/interface.cc.bak
new file mode 100644
index 00000000000..d414d108ca0
--- /dev/null
+++ b/source/material_model/equation_of_state/interface.cc.bak
@@ -0,0 +1,85 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/equation_of_state/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    EquationOfStateOutputs<dim>::EquationOfStateOutputs(const unsigned int n_individual_compositions_and_phases)
+      :
+      densities(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
+      thermal_expansion_coefficients(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
+      specific_heat_capacities(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
+      compressibilities(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
+      entropy_derivative_pressure(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
+      entropy_derivative_temperature(n_individual_compositions_and_phases, numbers::signaling_nan<double>())
+    {}
+
+
+
+    template <int dim>
+    void
+    phase_average_equation_of_state_outputs(const EquationOfStateOutputs<dim> &eos_outputs_all_phases,
+                                            const std::vector<double> &phase_function_values,
+                                            const std::vector<unsigned int> &n_phase_transitions_per_composition,
+                                            EquationOfStateOutputs<dim> &eos_outputs)
+    {
+      for (unsigned int c=0; c<eos_outputs.densities.size(); ++c)
+        {
+          eos_outputs.densities[c] =
+            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.densities, c);
+          eos_outputs.thermal_expansion_coefficients[c] =
+            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.thermal_expansion_coefficients, c);
+          eos_outputs.specific_heat_capacities[c] =
+            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.specific_heat_capacities, c);
+          eos_outputs.compressibilities[c] =
+            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.compressibilities, c);
+          eos_outputs.entropy_derivative_pressure[c] =
+            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.entropy_derivative_pressure, c);
+          eos_outputs.entropy_derivative_temperature[c] =
+            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.entropy_derivative_temperature, c);
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  template struct EquationOfStateOutputs<dim>; \
+  template void phase_average_equation_of_state_outputs<dim> (const EquationOfStateOutputs<dim> &, \
+                                                              const std::vector<double> &phase_function_values, \
+                                                              const std::vector<unsigned int> &n_phase_transitions_per_composition, \
+                                                              EquationOfStateOutputs<dim> &);
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/equation_of_state/linearized_incompressible.cc.bak b/source/material_model/equation_of_state/linearized_incompressible.cc.bak
new file mode 100644
index 00000000000..93459dbb073
--- /dev/null
+++ b/source/material_model/equation_of_state/linearized_incompressible.cc.bak
@@ -0,0 +1,160 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+      template <int dim>
+      void
+      LinearizedIncompressible<dim>::
+      evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+               const unsigned int q,
+               MaterialModel::EquationOfStateOutputs<dim> &out) const
+      {
+
+        Assert(maximum_number_of_compositions+1 >= out.densities.size(),
+               ExcMessage("Error: You are trying to evaluate the equation of state with "
+                          + Utilities::to_string(out.densities.size()-1) +
+                          " compositional fields, which is larger than "
+                          + Utilities::to_string(maximum_number_of_compositions) +
+                          ", the number of fields the equation of state was set up with."));
+
+
+        for (unsigned int c=0; c < out.densities.size(); ++c)
+          {
+            out.densities[c] = reference_rho * (1 - thermal_alpha * (in.temperature[q] - reference_T));
+            if (c>0)
+              out.densities[c] += compositional_delta_rhos[c-1];
+
+            out.thermal_expansion_coefficients[c] = thermal_alpha;
+            out.specific_heat_capacities[c] = reference_specific_heat;
+            out.compressibilities[c] = 0.0;
+            out.entropy_derivative_pressure[c] = 0.0;
+            out.entropy_derivative_temperature[c] = 0.0;
+          }
+      }
+
+
+
+      template <int dim>
+      bool
+      LinearizedIncompressible<dim>::
+      is_compressible () const
+      {
+        return false;
+      }
+
+
+
+      template <int dim>
+      void
+      LinearizedIncompressible<dim>::declare_parameters (ParameterHandler &prm,
+                                                         const unsigned int n_compositions)
+      {
+        prm.declare_entry ("Reference density", "3300.",
+                           Patterns::Double (0.),
+                           "Reference density $\\rho_0$. "
+                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+        prm.declare_entry ("Reference temperature", "293.",
+                           Patterns::Double (0.),
+                           "The reference temperature $T_0$. The reference temperature is used "
+                           "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
+        prm.declare_entry ("Reference specific heat", "1250.",
+                           Patterns::Double (0.),
+                           "The value of the specific heat $C_p$. "
+                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+        prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                           Patterns::Double (0.),
+                           "The value of the thermal expansion coefficient $\\alpha$. "
+                           "Units: \\si{\\per\\kelvin}.");
+        if (n_compositions > 0)
+          prm.declare_entry ("Density differential for compositional field 1", "0.",
+                             Patterns::Double(),
+                             "If compositional fields are used, then one would frequently want "
+                             "to make the density depend on these fields. In this simple material "
+                             "model, we make the following assumptions: if no compositional fields "
+                             "are used in the current simulation, then the density is simply the usual "
+                             "one with its linear dependence on the temperature. If there are compositional "
+                             "fields, then the material model determines how many of them influence the density. "
+                             "The composition-dependence adds a term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
+                             "This parameter describes the value of $\\Delta \\rho$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
+        if (n_compositions > 1)
+          prm.declare_entry ("Density differential for compositional field 2", "0.",
+                             Patterns::Double(),
+                             "If compositional fields are used, then one would frequently want "
+                             "to make the density depend on these fields. In this simple material "
+                             "model, we make the following assumptions: if no compositional fields "
+                             "are used in the current simulation, then the density is simply the usual "
+                             "one with its linear dependence on the temperature. If there are compositional "
+                             "fields, then the material model determines how many of them influence the density. "
+                             "The composition-dependence adds a term of the kind $+\\Delta \\rho \\; c_2(\\mathbf x)$. "
+                             "This parameter describes the value of $\\Delta \\rho$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
+      }
+
+
+
+      template <int dim>
+      void
+      LinearizedIncompressible<dim>::parse_parameters (ParameterHandler &prm,
+                                                       const unsigned int n_compositions)
+      {
+        reference_rho              = prm.get_double ("Reference density");
+        reference_T                = prm.get_double ("Reference temperature");
+        reference_specific_heat    = prm.get_double ("Reference specific heat");
+        thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+
+        maximum_number_of_compositions = n_compositions;
+        compositional_delta_rhos.resize(maximum_number_of_compositions);
+        if (maximum_number_of_compositions > 0)
+          compositional_delta_rhos[0]    = prm.get_double ("Density differential for compositional field 1");
+        if (maximum_number_of_compositions > 1)
+          compositional_delta_rhos[1]    = prm.get_double ("Density differential for compositional field 2");
+      }
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+#define INSTANTIATE(dim) \
+  template class LinearizedIncompressible<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/source/material_model/equation_of_state/multicomponent_compressible.cc.bak b/source/material_model/equation_of_state/multicomponent_compressible.cc.bak
new file mode 100644
index 00000000000..a7652424cd4
--- /dev/null
+++ b/source/material_model/equation_of_state/multicomponent_compressible.cc.bak
@@ -0,0 +1,177 @@
+/*
+  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/equation_of_state/multicomponent_compressible.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+      template <int dim>
+      void
+      MulticomponentCompressible<dim>::
+      evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+               const unsigned int q,
+               MaterialModel::EquationOfStateOutputs<dim> &out) const
+      {
+
+        const double pressure = in.pressure[q];
+        const double temperature = std::max(in.temperature[q], 1.); // temperature can't be zero for correct evaluation
+
+        for (unsigned int c=0; c < out.densities.size(); ++c)
+          {
+            const double ak = reference_thermal_expansivities[c]/reference_isothermal_compressibilities[c];
+            const double f = (1. + (pressure - ak*(temperature - reference_temperatures[c])) *
+                              isothermal_bulk_modulus_pressure_derivatives[c] *
+                              reference_isothermal_compressibilities[c]);
+
+            out.densities[c] = reference_densities[c]*std::pow(f, 1./isothermal_bulk_modulus_pressure_derivatives[c]);
+            out.thermal_expansion_coefficients[c] = reference_thermal_expansivities[c] / f;
+            out.specific_heat_capacities[c] = (isochoric_specific_heats[c] +
+                                               (temperature*reference_thermal_expansivities[c] *
+                                                ak * std::pow(f, -1.-(1./isothermal_bulk_modulus_pressure_derivatives[c]))
+                                                / reference_densities[c]));
+            out.compressibilities[c] = reference_isothermal_compressibilities[c]/f;
+            out.entropy_derivative_pressure[c] = 0.;
+            out.entropy_derivative_temperature[c] = 0.;
+          }
+      }
+
+
+
+      template <int dim>
+      bool
+      MulticomponentCompressible<dim>::
+      is_compressible () const
+      {
+        return true;
+      }
+
+
+
+      template <int dim>
+      void
+      MulticomponentCompressible<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Reference temperatures", "298.15",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of reference temperatures $T_0$ for background mantle and compositional fields,"
+                           "for a total of N+1 values, where N is the number of compositional fields."
+                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
+        prm.declare_entry ("Reference densities", "3300.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of densities for background mantle and compositional fields,"
+                           "for a total of N+1 values, where N is the number of compositional fields."
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+        prm.declare_entry ("Reference isothermal compressibilities", "4e-12",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of isothermal compressibilities for background mantle and compositional fields,"
+                           "for a total of N+1 values, where N is the number of compositional fields."
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\per\\pascal}.");
+        prm.declare_entry ("Isothermal bulk modulus pressure derivatives", "4.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of isothermal pressure derivatives of the bulk moduli for background mantle and compositional fields,"
+                           "for a total of N+1 values, where N is the number of compositional fields."
+                           "If only one value is given, then all use the same value. "
+                           "Units: [].");
+        prm.declare_entry ("Reference thermal expansivities", "4.e-5",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of thermal expansivities for background mantle and compositional fields,"
+                           "for a total of N+1 values, where N is the number of compositional fields."
+                           "If only one value is given, then all use the same value. Units: \\si{\\per\\kelvin}.");
+        prm.declare_entry ("Isochoric specific heats", "1250.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of isochoric specific heats $C_v$ for background mantle and compositional fields,"
+                           "for a total of N+1 values, where N is the number of compositional fields."
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+      }
+
+
+
+      template <int dim>
+      void
+      MulticomponentCompressible<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        // Establish that a background field is required here
+        const bool has_background_field = true;
+
+        // Retrieve the list of composition names
+        const std::vector<std::string> list_of_composition_names = this->introspection().get_composition_names();
+
+        // Parse multicomponent properties
+        reference_temperatures = Utilities::parse_map_to_double_array (prm.get("Reference temperatures"),
+                                                                       list_of_composition_names,
+                                                                       has_background_field,
+                                                                       "Reference temperatures");
+
+        reference_densities = Utilities::parse_map_to_double_array (prm.get("Reference densities"),
+                                                                    list_of_composition_names,
+                                                                    has_background_field,
+                                                                    "Reference densities");
+
+        reference_isothermal_compressibilities = Utilities::parse_map_to_double_array (prm.get("Reference isothermal compressibilities"),
+                                                                                       list_of_composition_names,
+                                                                                       has_background_field,
+                                                                                       "Reference isothermal compressibilities");
+
+        isothermal_bulk_modulus_pressure_derivatives = Utilities::parse_map_to_double_array (prm.get("Isothermal bulk modulus pressure derivatives"),
+                                                       list_of_composition_names,
+                                                       has_background_field,
+                                                       "Isothermal bulk modulus pressure derivatives");
+
+        reference_thermal_expansivities = Utilities::parse_map_to_double_array (prm.get("Reference thermal expansivities"),
+                                                                                list_of_composition_names,
+                                                                                has_background_field,
+                                                                                "Reference thermal expansivities");
+
+        isochoric_specific_heats = Utilities::parse_map_to_double_array (prm.get("Isochoric specific heats"),
+                                                                         list_of_composition_names,
+                                                                         has_background_field,
+                                                                         "Isochoric specific heats");
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+#define INSTANTIATE(dim) \
+  template class MulticomponentCompressible<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/source/material_model/equation_of_state/multicomponent_incompressible.cc.bak b/source/material_model/equation_of_state/multicomponent_incompressible.cc.bak
new file mode 100644
index 00000000000..3e8c0066e8d
--- /dev/null
+++ b/source/material_model/equation_of_state/multicomponent_incompressible.cc.bak
@@ -0,0 +1,156 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/equation_of_state/multicomponent_incompressible.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+      template <int dim>
+      void
+      MulticomponentIncompressible<dim>::
+      evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+               const unsigned int input_index,
+               MaterialModel::EquationOfStateOutputs<dim> &out) const
+      {
+
+
+        // If adiabatic heating is used, the reference temperature used to calculate density should be the adiabatic
+        // temperature at the current position. This definition is consistent with the Extended Boussinesq Approximation.
+        const double reference_temperature = (this->include_adiabatic_heating()
+                                              ?
+                                              this->get_adiabatic_conditions().temperature(in.position[input_index])
+                                              :
+                                              reference_T);
+
+        for (unsigned int c=0; c < out.densities.size(); ++c)
+          {
+            out.densities[c] = densities[c] * (1 - thermal_expansivities[c] * (in.temperature[input_index] - reference_temperature));
+            out.thermal_expansion_coefficients[c] = thermal_expansivities[c];
+            out.specific_heat_capacities[c] = specific_heats[c];
+            out.compressibilities[c] = 0.0;
+            out.entropy_derivative_pressure[c] = 0.0;
+            out.entropy_derivative_temperature[c] = 0.0;
+          }
+      }
+
+
+
+      template <int dim>
+      bool
+      MulticomponentIncompressible<dim>::
+      is_compressible () const
+      {
+        return false;
+      }
+
+
+
+      template <int dim>
+      void
+      MulticomponentIncompressible<dim>::declare_parameters (ParameterHandler &prm,
+                                                             const double default_thermal_expansion)
+      {
+        prm.declare_entry ("Reference temperature", "293.",
+                           Patterns::Double (0.),
+                           "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
+        prm.declare_entry ("Densities", "3300.",
+                           Patterns::Anything(),
+                           "List of densities for background mantle and compositional fields,"
+                           "for a total of N+M+1 values, where N is the number of compositional fields and M is the number of phases. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+        prm.declare_entry ("Thermal expansivities", std::to_string(default_thermal_expansion),
+                           Patterns::Anything(),
+                           "List of thermal expansivities for background mantle and compositional fields,"
+                           "for a total of N+M+1 values, where N is the number of compositional fields and M is the number of phases. "
+                           "If only one value is given, then all use the same value. Units: \\si{\\per\\kelvin}.");
+        prm.declare_entry ("Heat capacities", "1250.",
+                           Patterns::Anything(),
+                           "List of specific heats $C_p$ for background mantle and compositional fields,"
+                           "for a total of N+M+1 values, where N is the number of compositional fields and M is the number of phases. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+        prm.declare_alias ("Heat capacities", "Specific heats");
+      }
+
+
+
+      template <int dim>
+      void
+      MulticomponentIncompressible<dim>::parse_parameters (ParameterHandler &prm,
+                                                           const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
+      {
+        reference_T = prm.get_double ("Reference temperature");
+
+        // Make options file for parsing maps to double arrays
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+        chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+        compositional_field_names.insert(compositional_field_names.begin(),"background");
+
+        Utilities::MapParsing::Options options(chemical_field_names, "Densities");
+        options.list_of_allowed_keys = compositional_field_names;
+        options.allow_multiple_values_per_key = true;
+        if (expected_n_phases_per_composition)
+          {
+            options.n_values_per_key = *expected_n_phases_per_composition;
+
+            // check_values_per_key is required to be true to duplicate single values
+            // if they are to be used for all phases associated with a given key.
+            options.check_values_per_key = true;
+          }
+
+        // Parse multicomponent properties
+        densities = Utilities::MapParsing::parse_map_to_double_array(prm.get("Densities"), options);
+        options.property_name = "Thermal expansivities";
+        thermal_expansivities = Utilities::MapParsing::parse_map_to_double_array(prm.get("Thermal expansivities"), options);
+        options.property_name = "Heat capacities";
+        specific_heats = Utilities::MapParsing::parse_map_to_double_array (prm.get("Heat capacities"), options);
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+#define INSTANTIATE(dim) \
+  template class MulticomponentIncompressible<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/source/material_model/equation_of_state/thermodynamic_table_lookup.cc.bak b/source/material_model/equation_of_state/thermodynamic_table_lookup.cc.bak
new file mode 100644
index 00000000000..40ebfaac66e
--- /dev/null
+++ b/source/material_model/equation_of_state/thermodynamic_table_lookup.cc.bak
@@ -0,0 +1,579 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/equation_of_state/thermodynamic_table_lookup.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::initialize()
+      {
+        // This model allows the user to provide several PerpleX or HeFESTo
+        // P-T lookup files, each of which corresponds to a different material.
+        // The thermodynamic properties and stable mineral phases within each material
+        // will in general be different, and must be averaged in a reasonable way.
+
+        // In the following, we populate the material_lookups.
+        // We also populate the unique_phase_names vector, which is used to
+        // calculate the phase volumes if they are provided by the lookup.
+        // This equation of state sums the volume fractions of
+        // phases from different lookups if they have the same phase name.
+        std::set<std::string> set_phase_volume_column_names;
+
+        unique_phase_indices.resize(n_material_lookups, std::vector<unsigned int>());
+        global_index_of_lookup_phase.resize (n_material_lookups, std::vector<unsigned int>());
+
+        for (unsigned i = 0; i < n_material_lookups; ++i)
+          {
+            if (material_file_format == perplex)
+              material_lookup
+              .push_back(std::make_unique<MaterialModel::MaterialUtilities::Lookup::PerplexReader>(data_directory+material_file_names[i],
+                         use_bilinear_interpolation,
+                         this->get_mpi_communicator()));
+            else if (material_file_format == hefesto)
+              material_lookup
+              .push_back(std::make_unique<MaterialModel::MaterialUtilities::Lookup::HeFESToReader>(data_directory+material_file_names[i],
+                         data_directory+derivatives_file_names[i],
+                         use_bilinear_interpolation,
+                         this->get_mpi_communicator()));
+            else
+              AssertThrow (false, ExcNotImplemented());
+
+            // Here we look up all of the column names and insert
+            // unique names into the unique_phase_names vector and
+            // filling the unique_phase_indices object.
+            std::vector<std::string> phase_volume_column_names = material_lookup[i]->phase_volume_column_names();
+            for (const auto &phase_volume_column_name : phase_volume_column_names)
+              {
+                // iterate over the present unique_phase_names object
+                // to find phase_volume_column_name.
+                std::vector<std::string>::iterator it = std::find(unique_phase_names.begin(),
+                                                                  unique_phase_names.end(),
+                                                                  phase_volume_column_name);
+
+                // If phase_volume_column_name already exists in unique_phase_names,
+                // std::distance finds its index. Otherwise, std::distance will return
+                // the size of the present object, which is the index where we are
+                // about to push the new name. Either way, this is the index we want
+                // to add to the unique_phase_indices[i] vector.
+                unsigned int i_unique = std::distance(unique_phase_names.begin(), it);
+                unique_phase_indices[i].push_back(i_unique);
+
+                // If phase_volume_column_name did not already exist
+                // in unique_phase_names, we add it here.
+                if (it == unique_phase_names.end())
+                  unique_phase_names.push_back(phase_volume_column_name);
+              }
+
+            // Do the same for the dominant phases
+            std::vector<std::string> phase_names_one_lookup = material_lookup[i]->get_dominant_phase_names();
+            for (const auto &phase_name : phase_names_one_lookup)
+              {
+                std::vector<std::string>::iterator it = std::find(list_of_dominant_phases.begin(),
+                                                                  list_of_dominant_phases.end(),
+                                                                  phase_name);
+
+                // Each lookup only stores the index for the individual lookup, so we have to know
+                // how to convert from the indices of the individual lookup to the index in the
+                // list_of_dominant_phases vector. Here we fill the global_index_of_lookup_phase
+                // object to contain the global indices.
+                global_index_of_lookup_phase[i].push_back(std::distance(list_of_dominant_phases.begin(), it));
+
+                if (it == list_of_dominant_phases.end())
+                  list_of_dominant_phases.push_back(phase_name);
+              }
+
+            // Make sure that either all or none of the tables have a column with the dominant phase.
+            AssertThrow(material_lookup[0]->has_dominant_phase() == material_lookup[i]->has_dominant_phase(),
+                        ExcMessage("Some of the lookup tables you read in contain outputs for the dominant phase, "
+                                   "as indicated by the column 'phase', but in at least of of the tables you use "
+                                   "this column is missing."));
+          }
+
+        // Since the visualization output can only contain numbers and not strings
+        // we have to output the index instead of the name of the phase.
+        // We write out a data file that contains the list of dominant phases so
+        // that it is clear which index corresponds to which phase from the table.
+        const std::string filename = (this->get_output_directory() +
+                                      "thermodynamic_lookup_table_phases.txt");
+
+        if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0
+            && list_of_dominant_phases.size() > 0)
+          {
+            std::ofstream file;
+            file.open(filename);
+            file << "# <index>  <phase> " << std::endl;
+            for (unsigned int p=0; p<list_of_dominant_phases.size(); ++p)
+              {
+                file << p
+                     << ' '
+                     << list_of_dominant_phases[p]
+                     << std::endl;
+              }
+            AssertThrow (file, ExcMessage("Writing data to <" + filename +
+                                          "> did not succeed in the `phase outputs' additional names outputs "
+                                          "visualization postprocessor."));
+            file.close();
+          }
+      }
+
+
+
+      template <int dim>
+      unsigned int
+      ThermodynamicTableLookup<dim>::number_of_lookups() const
+      {
+        return n_material_lookups;
+      }
+
+
+
+      template <int dim>
+      bool
+      ThermodynamicTableLookup<dim>::
+      is_compressible () const
+      {
+        return true;
+      }
+
+
+
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::
+      fill_seismic_velocities (const MaterialModel::MaterialModelInputs<dim> &in,
+                               const std::vector<double> &composite_densities,
+                               const std::vector<std::vector<double>> &volume_fractions,
+                               SeismicAdditionalOutputs<dim> *seismic_out) const
+      {
+        // This function returns the Voigt-Reuss-Hill averages of the
+        // seismic velocities of the different materials.
+
+        // Now we calculate the averaged moduli.
+        // mu = rho*Vs^2; K_s = rho*Vp^2 - 4./3.*mu
+        // The Voigt average is an arithmetic volumetric average,
+        // while the Reuss average is a harmonic volumetric average.
+        for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
+          {
+            if (material_lookup.size() == 1)
+              {
+                seismic_out->vs[i] = material_lookup[0]->seismic_Vs(in.temperature[i],in.pressure[i]);
+                seismic_out->vp[i] = material_lookup[0]->seismic_Vp(in.temperature[i],in.pressure[i]);
+              }
+            else
+              {
+                double k_voigt = 0.;
+                double mu_voigt = 0.;
+                double invk_reuss = 0.;
+                double invmu_reuss = 0.;
+
+                for (unsigned int j = 0; j < material_lookup.size(); ++j)
+                  {
+                    const double mu = material_lookup[j]->density(in.temperature[i],in.pressure[i])*std::pow(material_lookup[j]->seismic_Vs(in.temperature[i],in.pressure[i]), 2.);
+                    const double k =  material_lookup[j]->density(in.temperature[i],in.pressure[i])*std::pow(material_lookup[j]->seismic_Vp(in.temperature[i],in.pressure[i]), 2.) - 4./3.*mu;
+
+                    k_voigt += volume_fractions[i][j] * k;
+                    mu_voigt += volume_fractions[i][j] * mu;
+                    invk_reuss += volume_fractions[i][j] / k;
+                    invmu_reuss += volume_fractions[i][j] / mu;
+                  }
+
+                const double k_VRH = (k_voigt + 1./invk_reuss)/2.;
+                const double mu_VRH = (mu_voigt + 1./invmu_reuss)/2.;
+                seismic_out->vp[i] = std::sqrt((k_VRH + 4./3.*mu_VRH)/composite_densities[i]);
+                seismic_out->vs[i] = std::sqrt(mu_VRH/composite_densities[i]);
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::
+      fill_phase_volume_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                                   const std::vector<std::vector<double>> &volume_fractions,
+                                   NamedAdditionalMaterialOutputs<dim> *phase_volume_fractions_out) const
+      {
+        // Each call to material_lookup[j]->phase_volume_fraction(k,temperature,pressure)
+        // returns the volume fraction of the kth phase which is present in that material lookup
+        // at the requested temperature and pressure.
+        // The total volume fraction of each phase at each evaluation point is equal to
+        // sum_j (volume_fraction_of_material_j * phase_volume_fraction_in_material_j).
+        // In the following function,
+        // the index i corresponds to the ith evaluation point
+        // the index j corresponds to the jth compositional field
+        // the index k corresponds to the kth phase in the lookup
+        std::vector<std::vector<double>> phase_volume_fractions(unique_phase_names.size(),
+                                                                 std::vector<double>(in.n_evaluation_points(), 0.));
+        for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
+          for (unsigned j = 0; j < material_lookup.size(); ++j)
+            for (unsigned int k = 0; k < unique_phase_indices[j].size(); ++k)
+              phase_volume_fractions[unique_phase_indices[j][k]][i] += volume_fractions[i][j] * material_lookup[j]->phase_volume_fraction(k,in.temperature[i],in.pressure[i]);
+
+        phase_volume_fractions_out->output_values = phase_volume_fractions;
+      }
+
+
+
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::
+      fill_dominant_phases (const MaterialModel::MaterialModelInputs<dim> &in,
+                            const std::vector<std::vector<double>> &volume_fractions,
+                            PhaseOutputs<dim> &dominant_phases_out) const
+      {
+        Assert(material_lookup[0]->has_dominant_phase(),
+               ExcMessage("You are trying to fill in outputs for the dominant phase, "
+                          "but these values do not exist in the material lookup."));
+
+        // Each call to material_lookup[j]->dominant_phase(temperature,pressure)
+        // returns the phase with the largest volume fraction in that material lookup
+        // at the requested temperature and pressure.
+        // In the following function,
+        // the index i corresponds to the ith evaluation point
+        // the index j corresponds to the jth compositional field
+        std::vector<std::vector<double>> dominant_phase_indices(1, std::vector<double>(in.n_evaluation_points(),
+                                                                                        std::numeric_limits<double>::quiet_NaN()));
+        for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
+          {
+            const unsigned int dominant_material_index = std::distance(volume_fractions[i].begin(), std::max_element(volume_fractions[i].begin(), volume_fractions[i].end()));
+            const unsigned int dominant_phase_in_material = material_lookup[dominant_material_index]->dominant_phase(in.temperature[i],in.pressure[i]);
+            dominant_phase_indices[0][i] = global_index_of_lookup_phase[dominant_material_index][dominant_phase_in_material];
+          }
+        dominant_phases_out.output_values = dominant_phase_indices;
+      }
+
+
+
+      template <int dim>
+      std::array<std::pair<double, unsigned int>,2>
+      ThermodynamicTableLookup<dim>::
+      enthalpy_derivatives (const typename Interface<dim>::MaterialModelInputs &in) const
+      {
+        std::array<std::pair<double, unsigned int>,2> derivative;
+
+        // get the pressures and temperatures at the vertices of the cell
+        const QTrapezoid<dim> quadrature_formula;
+
+        const unsigned int n_q_points = quadrature_formula.size();
+        FEValues<dim> fe_values (this->get_mapping(),
+                                 this->get_fe(),
+                                 quadrature_formula,
+                                 update_values);
+
+        std::vector<double> temperatures(n_q_points), pressures(n_q_points);
+        fe_values.reinit (in.current_cell);
+
+        fe_values[this->introspection().extractors.temperature]
+        .get_function_values (this->get_current_linearization_point(), temperatures);
+        fe_values[this->introspection().extractors.pressure]
+        .get_function_values (this->get_current_linearization_point(), pressures);
+
+        AssertThrow (n_material_lookups == 1,
+                     ExcMessage("This formalism is only implemented for one material "
+                                "table."));
+
+        // We have to take into account here that the p,T spacing of the table of material properties
+        // we use might be on a finer grid than our model. Because of that we compute the enthalpy
+        // derivatives by using finite differences that average over the whole temperature and
+        // pressure range that is used in this cell. This way we should not miss any phase transformation.
+        derivative = material_lookup[0]->enthalpy_derivatives(temperatures,
+                                                              pressures,
+                                                              max_latent_heat_substeps);
+
+        return derivative;
+      }
+
+
+
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::
+      evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+               std::vector<MaterialModel::EquationOfStateOutputs<dim>> &eos_outputs) const
+      {
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          {
+            const double pressure = in.pressure[i];
+            const double temperature = in.temperature[i];
+
+            for (unsigned int j=0; j<eos_outputs[i].densities.size(); ++j)
+              {
+                eos_outputs[i].densities[j] = material_lookup[j]->density(temperature, pressure);
+                eos_outputs[i].compressibilities[j] = material_lookup[j]->dRhodp(temperature, pressure)/eos_outputs[i].densities[j];
+
+                // Only calculate the non-reactive specific heat and
+                // thermal expansivity if latent heat is to be ignored.
+                if (!latent_heat)
+                  {
+                    eos_outputs[i].thermal_expansion_coefficients[j] = material_lookup[j]->thermal_expansivity(temperature, pressure);
+                    eos_outputs[i].specific_heat_capacities[j] = material_lookup[j]->specific_heat(temperature, pressure);
+                  }
+
+                eos_outputs[i].entropy_derivative_pressure[j] = 0.;
+                eos_outputs[i].entropy_derivative_temperature[j] = 0.;
+              }
+          }
+        // Calculate the specific heat and thermal expansivity
+        // including the effects of reaction.
+        if (latent_heat)
+          {
+            evaluate_thermal_enthalpy_derivatives(in, eos_outputs);
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::
+      evaluate_thermal_enthalpy_derivatives(const MaterialModel::MaterialModelInputs<dim> &in,
+                                            std::vector<MaterialModel::EquationOfStateOutputs<dim>> &eos_outputs) const
+      {
+        // The second derivatives of the thermodynamic potentials (compressibility, thermal expansivity, specific heat)
+        // are dependent not only on the phases present in the assemblage at the given temperature and pressure,
+        // but also on any reactions between phases in the assemblage. PerpleX and HeFESTo output only "static" properties
+        // (properties not including any reaction effects), and so do not capture the latent heat of reaction.
+
+        // In this material model, we always use a compressibility which includes the effects of reaction,
+        // but we allow the user the option to switch on or off thermal (latent heat) effects.
+        // If the latent_heat bool is set to true, thermal expansivity and specific heat are calculated from
+        // the change in enthalpy with pressure and temperature.
+
+        // There are alternative ways to capture the latent heat effect (by preprocessing the P-T table, for example),
+        // which may be a more appropriate approach in some cases, but the latent heat should always be considered if
+        // thermodynamic self-consistency is intended.
+
+        // The affected properties are computed using the partial derivatives of the enthalpy
+        // with respect to pressure and temperature:
+        // thermal expansivity = (1 - rho * (dH/dp)_T) / T
+        // specific heat capacity = (dH/dT)_P
+        // where the subscript indicates the natural variable which is held constant.
+        double average_temperature(0.0);
+        double average_density(0.0);
+        std::array<std::pair<double, unsigned int>,2> dH;
+
+        for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
+          {
+            average_temperature += in.temperature[i];
+            average_density += eos_outputs[i].densities[0];
+          }
+        average_temperature /= in.n_evaluation_points();
+        average_density /= in.n_evaluation_points();
+
+        if (in.current_cell.state() == IteratorState::valid)
+          dH = enthalpy_derivatives(in);
+
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          {
+            // Use the adiabatic pressure instead of the real one,
+            // to stabilize against pressure oscillations in phase transitions
+            const double pressure = this->get_adiabatic_conditions().pressure(in.position[i]);
+
+            if ((in.current_cell.state() == IteratorState::valid)
+                && (dH[0].second > 0) && (dH[1].second > 0))
+              {
+                eos_outputs[i].thermal_expansion_coefficients[0] = (1 - average_density * dH[1].first) / average_temperature;
+                eos_outputs[i].specific_heat_capacities[0] = dH[0].first;
+              }
+            else
+              {
+                eos_outputs[i].thermal_expansion_coefficients[0] = (1 - eos_outputs[i].densities[0] * material_lookup[0]->dHdp(in.temperature[i],pressure)) / in.temperature[i];
+                eos_outputs[i].specific_heat_capacities[0] = material_lookup[0]->dHdT(in.temperature[i],pressure);
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::fill_additional_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
+                                                              const std::vector<std::vector<double>> &volume_fractions,
+                                                              MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+        // fill seismic velocity outputs if they exist
+        if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
+          fill_seismic_velocities(in, out.densities, volume_fractions, seismic_out);
+
+        // fill phase volume outputs if they exist
+        if (NamedAdditionalMaterialOutputs<dim> *phase_volume_fractions_out = out.template get_additional_output<NamedAdditionalMaterialOutputs<dim>>())
+          fill_phase_volume_fractions(in, volume_fractions, phase_volume_fractions_out);
+
+        if (PhaseOutputs<dim> *dominant_phases_out = out.template get_additional_output<PhaseOutputs<dim>>())
+          fill_dominant_phases(in, volume_fractions, *dominant_phases_out);
+      }
+
+
+
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/steinberger/",
+                           Patterns::DirectoryName (),
+                           "The path to the model data. The path may also include the special "
+                           "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                           "in which the ASPECT source files were located when ASPECT was "
+                           "compiled. This interpretation allows, for example, to reference "
+                           "files located in the `data/' subdirectory of ASPECT. ");
+        prm.declare_entry ("Material file names", "pyr-ringwood88.txt",
+                           Patterns::List (Patterns::Anything()),
+                           "The file names of the material data (material "
+                           "data is assumed to be in order with the ordering "
+                           "of the compositional fields). Note that there are "
+                           "three options on how many files need to be listed "
+                           "here: 1. If only one file is provided, it is used "
+                           "for the whole model domain, and compositional fields "
+                           "are ignored. 2. If there is one more file name than the "
+                           "number of compositional fields, then the first file is "
+                           "assumed to define a `background composition' that is "
+                           "modified by the compositional fields. If there are "
+                           "exactly as many files as compositional fields, the fields are "
+                           "assumed to represent the fractions of different materials "
+                           "and the average property is computed as a sum of "
+                           "the value of the compositional field times the "
+                           "material property of that field.");
+        prm.declare_entry ("Derivatives file names", "",
+                           Patterns::List (Patterns::Anything()),
+                           "The file names of the enthalpy derivatives data. "
+                           "List with as many components as active "
+                           "compositional fields (material data is assumed to "
+                           "be in order with the ordering of the fields).");
+        prm.declare_entry ("Material file format", "perplex",
+                           Patterns::Selection ("perplex|hefesto"),
+                           "The material file format to be read in the property "
+                           "tables.");
+        prm.declare_entry ("Bilinear interpolation", "true",
+                           Patterns::Bool (),
+                           "Whether to use bilinear interpolation to compute "
+                           "material properties (slower but more accurate). ");
+        prm.declare_entry ("Latent heat", "false",
+                           Patterns::Bool (),
+                           "Whether to include latent heat effects in the "
+                           "calculation of thermal expansivity and specific heat. "
+                           "If true, ASPECT follows the approach of Nakagawa et al. 2009, "
+                           "using pressure and temperature derivatives of the enthalpy "
+                           "to calculate the thermal expansivity and specific heat. "
+                           "If false, ASPECT uses the thermal expansivity and "
+                           "specific heat values from the material properties table.");
+        prm.declare_entry ("Maximum latent heat substeps", "1",
+                           Patterns::Integer (1),
+                           "The maximum number of substeps over the temperature pressure range "
+                           "to calculate the averaged enthalpy gradient over a cell.");
+      }
+
+
+
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        data_directory               = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+        material_file_names          = Utilities::split_string_list(prm.get ("Material file names"));
+        n_material_lookups           = material_file_names.size();
+
+        derivatives_file_names       = Utilities::split_string_list(prm.get ("Derivatives file names"));
+        use_bilinear_interpolation   = prm.get_bool ("Bilinear interpolation");
+        latent_heat                  = prm.get_bool ("Latent heat");
+        max_latent_heat_substeps     = prm.get_integer ("Maximum latent heat substeps");
+
+        if (prm.get ("Material file format") == "perplex")
+          material_file_format       = perplex;
+        else if (prm.get ("Material file format") == "hefesto")
+          material_file_format       = hefesto;
+        else
+          AssertThrow (false, ExcNotImplemented());
+
+        if (latent_heat)
+          AssertThrow (n_material_lookups == 1,
+                       ExcMessage("Isochemical latent heat calculations are only implemented for a single material lookup."));
+
+      }
+
+
+
+      template <int dim>
+      void
+      ThermodynamicTableLookup<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+        if (out.template get_additional_output<NamedAdditionalMaterialOutputs<dim>>() == nullptr)
+          {
+            const unsigned int n_points = out.n_evaluation_points();
+            out.additional_outputs.push_back(
+              std::make_unique<MaterialModel::NamedAdditionalMaterialOutputs<dim>> (unique_phase_names, n_points));
+          }
+
+        if (out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
+          {
+            const unsigned int n_points = out.n_evaluation_points();
+            out.additional_outputs.push_back(
+              std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
+          }
+
+        if (out.template get_additional_output<PhaseOutputs<dim>>() == nullptr
+            && material_lookup[0]->has_dominant_phase())
+          {
+            const unsigned int n_points = out.n_evaluation_points();
+            out.additional_outputs.push_back(
+              std::make_unique<MaterialModel::PhaseOutputs<dim>> (n_points));
+          }
+      }
+
+
+
+      template <int dim>
+      const MaterialModel::MaterialUtilities::Lookup::MaterialLookup &
+      ThermodynamicTableLookup<dim>::get_material_lookup (unsigned int lookup_index) const
+      {
+        return *material_lookup[lookup_index].get();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace EquationOfState
+    {
+#define INSTANTIATE(dim) \
+  template class ThermodynamicTableLookup<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/source/material_model/grain_size.cc.bak b/source/material_model/grain_size.cc.bak
new file mode 100644
index 00000000000..5f807ffa1ad
--- /dev/null
+++ b/source/material_model/grain_size.cc.bak
@@ -0,0 +1,1687 @@
+/*
+  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/grain_size.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/heating_model/shear_heating.h>
+#include <aspect/material_model/rheology/visco_plastic.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/signaling_nan.h>
+
+#include <iostream>
+
+using namespace dealii;
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace
+    {
+      std::vector<std::string> make_dislocation_viscosity_outputs_names()
+      {
+        std::vector<std::string> names;
+        names.emplace_back("dislocation_viscosity");
+        names.emplace_back("diffusion_viscosity");
+        return names;
+      }
+    }
+
+
+
+    template <int dim>
+    DislocationViscosityOutputs<dim>::DislocationViscosityOutputs (const unsigned int n_points)
+      :
+      NamedAdditionalMaterialOutputs<dim>(make_dislocation_viscosity_outputs_names()),
+      dislocation_viscosities(n_points, numbers::signaling_nan<double>()),
+      diffusion_viscosities(n_points, numbers::signaling_nan<double>())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    DislocationViscosityOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      AssertIndexRange (idx, 2);
+      switch (idx)
+        {
+          case 0:
+            return dislocation_viscosities;
+
+          case 1:
+            return diffusion_viscosities;
+
+          default:
+            AssertThrow(false, ExcInternalError());
+        }
+      // we will never get here, so just return something
+      return dislocation_viscosities;
+    }
+
+
+
+    template <int dim>
+    void
+    GrainSize<dim>::initialize()
+    {
+      n_material_data = material_file_names.size();
+      for (unsigned i = 0; i < n_material_data; ++i)
+        {
+          if (material_file_format == perplex)
+            material_lookup
+            .push_back(std::make_unique<MaterialModel::MaterialUtilities::Lookup::PerplexReader>(datadirectory+material_file_names[i],
+                       use_bilinear_interpolation,
+                       this->get_mpi_communicator()));
+          else if (material_file_format == hefesto)
+            material_lookup
+            .push_back(std::make_unique<MaterialModel::MaterialUtilities::Lookup::HeFESToReader>(datadirectory+material_file_names[i],
+                       datadirectory+derivatives_file_names[i],
+                       use_bilinear_interpolation,
+                       this->get_mpi_communicator()));
+          else
+            AssertThrow (false, ExcNotImplemented());
+        }
+
+      AssertThrow( (grain_size_evolution_formulation != Formulation::paleopiezometer || !this->get_heating_model_manager().shear_heating_enabled()),
+                   ExcMessage("Shear heating output should not be used with the Paleopiezometer grain damage formulation."));
+    }
+
+
+
+    template <int dim>
+    unsigned int
+    GrainSize<dim>::
+    get_phase_index (const MaterialUtilities::PhaseFunctionInputs<dim> &in) const
+    {
+      Assert(grain_growth_activation_energy.size()>0,
+             ExcMessage("Error: No grain evolution parameters are given!"));
+
+      // Since phase transition depth increases monotonically, we only need
+      // to check for the first phase that has not yet undergone the transition
+      // (phase function value lower than 0.5).
+      for (unsigned int j=0; j<n_phase_transitions; ++j)
+        {
+          MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature,
+                                                                   in.pressure,
+                                                                   in.depth,
+                                                                   in.pressure_depth_derivative,
+                                                                   j);
+
+          if (phase_function.compute_value(phase_inputs) < 0.5)
+            return j;
+        }
+
+      return n_phase_transitions;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    compute_partitioning_fraction (const double temperature) const
+    {
+      const double power_term_base = maximum_grain_size_reduction_work_fraction/minimum_grain_size_reduction_work_fraction;
+
+      const double power_term_numerator    =  temperature_minimum_partitioning_power -
+                                              std::pow (temperature, grain_size_reduction_work_fraction_exponent);
+
+      const double power_term_denominator  =  temperature_minimum_partitioning_power -
+                                              temperature_maximum_partitioning_power;
+
+      // We have to ensure the power term exponent is between 0 and 1, otherwise the partitioning fraction
+      // will be outside the set bounds for the work fraction.
+      const double power_term_exponent = std::max(std::min(power_term_numerator / power_term_denominator, 1.0), 0.0);
+
+      const double power_term = std::pow(power_term_base,
+                                         power_term_exponent);
+
+      return minimum_grain_size_reduction_work_fraction * power_term;
+    }
+
+
+
+    namespace
+    {
+      double moment_of_grain_size_distribution (const unsigned int n)
+      {
+        // This function normalizes the grain size distribution using the nth moment.
+        // Description can be found in eq 8 of Bercovici and Richard (2012)
+        // This is the variance of the log-normal distribution
+        const double sigma = 0.8;
+
+        return std::exp(n * n * sigma * sigma / 2.);
+      }
+
+
+
+      double phase_distribution_function (const double volume_fraction_phase_one)
+      {
+        // This factor is used in pinned state grain damage formulation.
+        const double volume_fraction_phase_two = 1. - volume_fraction_phase_one;
+
+        return (volume_fraction_phase_one * volume_fraction_phase_two);
+      }
+
+
+
+      double
+      roughness_to_grain_size_factor (const double volume_fraction_phase_one)
+      {
+        // This factor is used to convert from an interface roughness equation to a mean grain size
+        // Refer to Appendix H.1, eqs 8, F.28 in Bercovici and Richard (2012) for more details.
+        const double b1 = 1./20 ;
+        const double c1 = 3.0 * b1 * moment_of_grain_size_distribution(4) / (8.0 * moment_of_grain_size_distribution (2));
+
+        const double volume_fraction_phase_two = 1. - volume_fraction_phase_one;
+
+        const double h1 = c1 * (1 - volume_fraction_phase_one);
+        const double h2 = c1 * (1 - volume_fraction_phase_two);
+
+        const double one_over_sqrt_h = volume_fraction_phase_one / std::sqrt(h1) + volume_fraction_phase_two / std::sqrt(h2);
+
+        return (1./one_over_sqrt_h);
+      }
+    }
+
+
+
+    template <int dim>
+    std::vector<std::vector<double>>
+    GrainSize<dim>::
+    grain_size_change (const typename Interface<dim>::MaterialModelInputs &in,
+                       const std::vector<double>                          &pressures,
+                       const std::vector<unsigned int>                    &phase_indices) const
+    {
+      // We want to iterate over the grain size evolution here, as we solve in fact an ordinary differential equation
+      // and it is not correct to use the starting grain size (and it introduces instabilities).
+      // We assume that the strain rate is constant across all substeps for the ODE (within one advection step).
+      // Even though this assumption may not always be the most accurate (compared to assuming a constant stress),
+      // it leads to a more stable behavior because it implies that a reduction in grain size leads to less work
+      // being done by dislocation creep, so that the grain size reduction rate is lower in the next substep.
+      std::vector<std::vector<double>> reaction_terms (in.n_evaluation_points(), std::vector<double>(this->n_compositional_fields(), 0.0));
+
+      // Set up a vector that tells us which phase transition has been crossed for each point we are evaluating.
+      std::vector<int> crossed_transitions (in.n_evaluation_points(), -1);
+
+      using VectorType = Vector<double>;
+      VectorType grain_sizes(in.n_evaluation_points());
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        grain_sizes[i] = std::max(min_grain_size, in.composition[i][grain_size_index]);
+
+      const double timestep = this->simulator_is_past_initialization()
+                              ?
+                              this->get_timestep()
+                              :
+                              0.0;
+
+      if (std::all_of(grain_sizes.begin(), grain_sizes.end(), [](double gs)
+      {
+        return gs != gs || gs < std::numeric_limits<double>::min();
+        })
+      || timestep == 0.0)
+      return reaction_terms;
+
+      SUNDIALS::ARKode<VectorType>::AdditionalData data;
+
+      data.initial_time = 0.0;
+      data.final_time = this->get_timestep();
+
+      // TODO: make this an input parameter.
+      data.initial_step_size = 0.001 * this->get_timestep();
+      data.output_period = this->get_timestep();
+      data.minimum_step_size = 1.e-6*this->get_timestep();
+      data.maximum_order = 3;
+      data.maximum_non_linear_iterations = 30;
+
+      // Because both tolerances are added, we set the absolute
+      // tolerance to 0.
+      data.relative_tolerance = 1e-3;
+      data.absolute_tolerance = 0;
+
+      SUNDIALS::ARKode<VectorType> ode(data);
+      ode.explicit_function = [&] (const double     /*time*/,
+                                   const VectorType &y,
+                                   VectorType       &grain_size_rates_of_change)
+      {
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            const double grain_size = std::max(min_grain_size, y[i]);
+
+            // Precompute the partitioning_fraction since it is constant during the evolution.
+            // This is only used for the pinned_grain_damage formulation.
+            const double partitioning_fraction = (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
+                                                 ?
+                                                 compute_partitioning_fraction(in.temperature[i])
+                                                 :
+                                                 0.0;
+
+            // We keep the dislocation viscosity of the last iteration as guess
+            // for the next one.
+            double current_dislocation_viscosity = 0.0;
+
+            const double adiabatic_temperature = this->get_adiabatic_conditions().is_initialized()
+                                                 ?
+                                                 this->get_adiabatic_conditions().temperature(in.position[i])
+                                                 :
+                                                 in.temperature[i];
+
+
+
+            // grain size growth due to Ostwald ripening
+            const double m = grain_growth_exponent[phase_indices[i]];
+
+            double grain_size_growth_rate = grain_growth_rate_constant[phase_indices[i]] / (m * std::pow(grain_size,m-1))
+                                            * std::exp(- (grain_growth_activation_energy[phase_indices[i]] + pressures[i] * grain_growth_activation_volume[phase_indices[i]])
+                                                       / (constants::gas_constant * in.temperature[i]));
+
+            // in the two-phase damage model grain growth depends on the proportion of the two phases
+            if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
+              grain_size_growth_rate *= geometric_constant[phase_indices[i]] * phase_distribution /
+                                        std::pow(roughness_to_grain_size, m);
+
+            // grain size reduction in dislocation creep regime
+            const SymmetricTensor<2,dim> shear_strain_rate = in.strain_rate[i] - 1./dim * trace(in.strain_rate[i]) * unit_symmetric_tensor<dim>();
+            const double second_strain_rate_invariant = std::sqrt(std::max(-second_invariant(shear_strain_rate), 0.));
+
+            const double current_diffusion_viscosity   = diffusion_viscosity(in.temperature[i], adiabatic_temperature, pressures[i], grain_size, second_strain_rate_invariant, phase_indices[i]);
+            current_dislocation_viscosity = dislocation_viscosity(in.temperature[i], adiabatic_temperature, pressures[i], in.strain_rate[i], phase_indices[i], current_diffusion_viscosity, current_dislocation_viscosity);
+
+            double current_viscosity;
+            if (std::abs(second_strain_rate_invariant) > 1e-30)
+              current_viscosity = current_dislocation_viscosity * current_diffusion_viscosity / (current_dislocation_viscosity + current_diffusion_viscosity);
+            else
+              current_viscosity = current_diffusion_viscosity;
+
+            const double dislocation_strain_rate = second_strain_rate_invariant
+                                                   * current_viscosity / current_dislocation_viscosity;
+
+            double grain_size_reduction_rate = 0.0;
+
+            if (grain_size_evolution_formulation == Formulation::paleowattmeter)
+              {
+                // paleowattmeter: Austin and Evans (2007): Paleowattmeters: A scaling relation for dynamically recrystallized grain size. Geology 35, 343-346
+                const double stress = 2.0 * second_strain_rate_invariant * std::min(std::max(min_eta,current_viscosity),max_eta);
+                grain_size_reduction_rate = 2.0 * stress * boundary_area_change_work_fraction[phase_indices[i]] * dislocation_strain_rate * grain_size * grain_size
+                                            / (geometric_constant[phase_indices[i]] * grain_boundary_energy[phase_indices[i]]);
+              }
+            else if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
+              {
+                // pinned_grain_damage: Mulyukova and Bercovici (2018) Collapse of passive margins by lithospheric damage and plunging grain size. Earth and Planetary Science Letters, 484, 341-352.
+                const double stress = 2.0 * second_strain_rate_invariant * std::min(std::max(min_eta,current_viscosity),max_eta);
+                grain_size_reduction_rate = 2.0 * stress * partitioning_fraction * second_strain_rate_invariant * grain_size * grain_size
+                                            * roughness_to_grain_size
+                                            / (geometric_constant[phase_indices[i]] * grain_boundary_energy[phase_indices[i]] * phase_distribution);
+              }
+            else if (grain_size_evolution_formulation == Formulation::paleopiezometer)
+              {
+                // paleopiezometer: Hall and Parmentier (2003): Influence of grain size evolution on convective instability. Geochem. Geophys. Geosyst., 4(3).
+                grain_size_reduction_rate = reciprocal_required_strain[phase_indices[i]] * dislocation_strain_rate * grain_size;
+              }
+            else
+              AssertThrow(false, ExcNotImplemented());
+
+            grain_size_rates_of_change[i] = grain_size_growth_rate - grain_size_reduction_rate;
+          }
+      };
+
+
+      const unsigned int iteration_count = ode.solve_ode(grain_sizes);
+      this->get_signals().post_ARKode_solve(*this, iteration_count);
+
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          Assert(grain_sizes[i] > 0,
+                 ExcMessage("The grain size became smaller than zero. This is not valid, "
+                            "and likely an effect of a too large sub-timestep, or unrealistic "
+                            "input parameters."));
+
+          // reduce grain size to recrystallized_grain_size when crossing phase transitions
+          // if the distance in radial direction a grain moved compared to the last time step
+          // is crossing a phase transition, reduce grain size
+
+          const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[i]).norm();
+          Tensor<1,dim> vertical_direction = this->get_gravity_model().gravity_vector(in.position[i]);
+          if (gravity_norm > 0.0)
+            vertical_direction /= gravity_norm;
+
+          int crossed_transition = -1;
+
+          // Figure out if the material in the current cell underwent a phase change.
+          // To do so, check if a grain has moved further than the distance from the phase transition and
+          // if the velocity is in the direction of the phase change. After the check 'crossed_transition' will
+          // be -1 if we crossed no transition, or the index of the phase transition, if we crossed it.
+          for (unsigned int phase=0; phase<n_phase_transitions; ++phase)
+            {
+              // Both distances are positive when they are downward from the transition (since gravity points down)
+              const double distance_from_transition = this->get_geometry_model().depth(in.position[i]) - phase_function.get_transition_depth(phase);
+              const double distance_moved = in.velocity[i] * vertical_direction * timestep;
+
+              // If we are close to the phase boundary (closer than the distance a grain has moved
+              // within one time step) and the velocity points away from the phase transition,
+              // then the material has crossed the transition.
+              // To make sure we actually reset the grain size of all the material passing through
+              // the transition, we take 110% of the distance a grain has moved for the check.
+              if (std::abs(distance_moved) * 1.1 > std::abs(distance_from_transition)
+                  &&
+                  distance_moved * distance_from_transition >= 0)
+                crossed_transition = phase;
+            }
+
+          // TODO: recrystallize first, and then do grain size growth/reduction for grains that crossed the transition
+          // in dependence of the distance they have moved
+          double phase_grain_size_reduction = 0.0;
+          if (this->get_timestep_number() > 0)
+            {
+              // check if material has crossed any phase transition, if yes, reset grain size
+              if (crossed_transition != -1)
+                if (recrystallized_grain_size[crossed_transition] > 0.0)
+                  phase_grain_size_reduction = grain_sizes[i] - recrystallized_grain_size[crossed_transition];
+            }
+
+          grain_sizes[i] = std::max(grain_sizes[i], minimum_grain_size);
+          const double grain_size_change = grain_sizes[i] - in.composition[i][grain_size_index] - phase_grain_size_reduction;
+
+          reaction_terms[i][grain_size_index] = grain_size_change;
+          // We do not have to fill the other fields because we have initialized them with zero.
+        }
+
+      return reaction_terms;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    diffusion_viscosity (const double temperature,
+                         const double adiabatic_temperature,
+                         const double adiabatic_pressure,
+                         const double grain_size,
+                         const double second_strain_rate_invariant,
+                         const unsigned int phase_index) const
+    {
+      double energy_term = std::exp((diffusion_activation_energy[phase_index] + diffusion_activation_volume[phase_index] * adiabatic_pressure)
+                                    / (diffusion_creep_exponent[phase_index] * constants::gas_constant * temperature));
+
+      // If the adiabatic profile is already calculated we can use it to limit
+      // variations in viscosity due to temperature.
+      if (this->get_adiabatic_conditions().is_initialized())
+        {
+          const double adiabatic_energy_term
+            = std::exp((diffusion_activation_energy[phase_index] + diffusion_activation_volume[phase_index] * adiabatic_pressure)
+                       / (diffusion_creep_exponent[phase_index] * constants::gas_constant * adiabatic_temperature));
+
+          const double temperature_dependence = energy_term / adiabatic_energy_term;
+          if (temperature_dependence > max_temperature_dependence_of_eta)
+            energy_term = adiabatic_energy_term * max_temperature_dependence_of_eta;
+          if (temperature_dependence < 1.0 / max_temperature_dependence_of_eta)
+            energy_term = adiabatic_energy_term / max_temperature_dependence_of_eta;
+        }
+
+      const double strain_rate_dependence = (1.0 - diffusion_creep_exponent[phase_index]) / diffusion_creep_exponent[phase_index];
+
+      return diffusion_creep_prefactor[phase_index]
+             * std::pow(second_strain_rate_invariant,strain_rate_dependence)
+             * std::pow(grain_size, diffusion_creep_grain_size_exponent[phase_index]/diffusion_creep_exponent[phase_index])
+             * energy_term;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    dislocation_viscosity (const double temperature,
+                           const double adiabatic_temperature,
+                           const double adiabatic_pressure,
+                           const SymmetricTensor<2,dim> &strain_rate,
+                           const unsigned int phase_index,
+                           const double diffusion_viscosity,
+                           const double viscosity_guess) const
+    {
+      // find out in which phase we are
+      double energy_term = std::exp((dislocation_activation_energy[phase_index] + dislocation_activation_volume[phase_index] * adiabatic_pressure)
+                                    / (dislocation_creep_exponent[phase_index] * constants::gas_constant * temperature));
+
+      // If we are past the initialization of the adiabatic profile, use it to
+      // limit viscosity variations due to temperature.
+      if (this->get_adiabatic_conditions().is_initialized())
+        {
+          const double adiabatic_energy_term
+            = std::exp((dislocation_activation_energy[phase_index] + dislocation_activation_volume[phase_index] * adiabatic_pressure)
+                       / (dislocation_creep_exponent[phase_index] * constants::gas_constant * adiabatic_temperature));
+
+          const double temperature_dependence = energy_term / adiabatic_energy_term;
+          if (temperature_dependence > max_temperature_dependence_of_eta)
+            energy_term = adiabatic_energy_term * max_temperature_dependence_of_eta;
+          if (temperature_dependence < 1.0 / max_temperature_dependence_of_eta)
+            energy_term = adiabatic_energy_term / max_temperature_dependence_of_eta;
+        }
+
+      const double strain_rate_dependence = (1.0 - dislocation_creep_exponent[phase_index]) / dislocation_creep_exponent[phase_index];
+      const SymmetricTensor<2,dim> shear_strain_rate = strain_rate - 1./dim * trace(strain_rate) * unit_symmetric_tensor<dim>();
+      const double second_strain_rate_invariant = std::sqrt(std::max(-second_invariant(shear_strain_rate), 0.));
+
+      // If the strain rate is zero, the dislocation viscosity is infinity.
+      if (second_strain_rate_invariant <= std::numeric_limits<double>::min())
+        return std::numeric_limits<double>::min();
+
+      // Start the iteration with the full strain rate
+      double dis_viscosity;
+      if (viscosity_guess == 0)
+        dis_viscosity = dislocation_creep_prefactor[phase_index]
+                        * std::pow(second_strain_rate_invariant,strain_rate_dependence)
+                        * energy_term;
+      else
+        dis_viscosity = viscosity_guess;
+
+      double dis_viscosity_old = 0;
+      unsigned int i = 0;
+      while ((std::abs((dis_viscosity-dis_viscosity_old) / dis_viscosity) > dislocation_viscosity_iteration_threshold)
+             && (i < dislocation_viscosity_iteration_number))
+        {
+          const SymmetricTensor<2,dim> dislocation_strain_rate = diffusion_viscosity
+                                                                 / (diffusion_viscosity + dis_viscosity) * shear_strain_rate;
+          const double dislocation_strain_rate_invariant = std::sqrt(std::max(-second_invariant(dislocation_strain_rate), 0.));
+
+          dis_viscosity_old = dis_viscosity;
+          dis_viscosity = dislocation_creep_prefactor[phase_index]
+                          * std::pow(dislocation_strain_rate_invariant,strain_rate_dependence)
+                          * energy_term;
+          ++i;
+        }
+
+      Assert(i<dislocation_viscosity_iteration_number,ExcInternalError());
+
+      return dis_viscosity;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    enthalpy (const double      temperature,
+              const double      pressure,
+              const std::vector<double> &compositional_fields,
+              const Point<dim> &/*position*/) const
+    {
+      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
+                   ExcMessage("Currently only compressible models are supported."));
+
+      double enthalpy = 0.0;
+      if (n_material_data == 1)
+        enthalpy = material_lookup[0]->enthalpy(temperature,pressure);
+      else
+        {
+          for (unsigned i = 0; i < n_material_data; ++i)
+            enthalpy += compositional_fields[i] * material_lookup[i]->enthalpy(temperature,pressure);
+        }
+      return enthalpy;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    seismic_Vp (const double      temperature,
+                const double      pressure,
+                const std::vector<double> &compositional_fields,
+                const Point<dim> &/*position*/) const
+    {
+      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
+                   ExcMessage("Currently only compressible models are supported."));
+
+      double vp = 0.0;
+      if (n_material_data == 1)
+        vp = material_lookup[0]->seismic_Vp(temperature,pressure);
+      else
+        {
+          for (unsigned i = 0; i < n_material_data; ++i)
+            vp += compositional_fields[i] * material_lookup[i]->seismic_Vp(temperature,pressure);
+        }
+      return vp;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    seismic_Vs (const double      temperature,
+                const double      pressure,
+                const std::vector<double> &compositional_fields,
+                const Point<dim> &/*position*/) const
+    {
+      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
+                   ExcMessage("Currently only compressible models are supported."));
+
+      double vs = 0.0;
+      if (n_material_data == 1)
+        vs = material_lookup[0]->seismic_Vs(temperature,pressure);
+      else
+        {
+          for (unsigned i = 0; i < n_material_data; ++i)
+            vs += compositional_fields[i] * material_lookup[i]->seismic_Vs(temperature,pressure);
+        }
+      return vs;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    density (const double temperature,
+             const double pressure,
+             const std::vector<double> &compositional_fields, /*composition*/
+             const Point<dim> &) const
+    {
+      if (!use_table_properties)
+        {
+          return reference_rho * std::exp(reference_compressibility * (pressure - this->get_surface_pressure()))
+                 * (1 - thermal_alpha * (temperature - reference_T));
+        }
+      else
+        {
+          double rho = 0.0;
+          if (n_material_data == 1)
+            {
+              rho = material_lookup[0]->density(temperature,pressure);
+            }
+          else
+            {
+              for (unsigned i = 0; i < n_material_data; ++i)
+                rho += compositional_fields[i] * material_lookup[i]->density(temperature,pressure);
+            }
+
+          return rho;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    GrainSize<dim>::
+    is_compressible () const
+    {
+      return (reference_compressibility != 0)
+             || use_table_properties;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    compressibility (const double temperature,
+                     const double pressure,
+                     const std::vector<double> &compositional_fields,
+                     const Point<dim> &position) const
+    {
+      if (!use_table_properties)
+        return reference_compressibility;
+
+      double dRhodp = 0.0;
+      if (n_material_data == 1)
+        dRhodp = material_lookup[0]->dRhodp(temperature,pressure);
+      else
+        {
+          for (unsigned i = 0; i < n_material_data; ++i)
+            dRhodp += compositional_fields[i] * material_lookup[i]->dRhodp(temperature,pressure);
+        }
+      const double rho = density(temperature,pressure,compositional_fields,position);
+      return (1/rho)*dRhodp;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    thermal_expansion_coefficient (const double      temperature,
+                                   const double      pressure,
+                                   const std::vector<double> &compositional_fields,
+                                   const Point<dim> &/*position*/) const
+    {
+      double alpha = 0.0;
+      if (!use_table_properties)
+        return thermal_alpha;
+      else
+        {
+          if (n_material_data == 1)
+            alpha = material_lookup[0]->thermal_expansivity(temperature,pressure);
+          else
+            {
+              for (unsigned i = 0; i < n_material_data; ++i)
+                alpha += compositional_fields[i] * material_lookup[i]->thermal_expansivity(temperature,pressure);
+            }
+        }
+      alpha = std::max(std::min(alpha,max_thermal_expansivity),min_thermal_expansivity);
+      return alpha;
+    }
+
+
+
+    template <int dim>
+    double
+    GrainSize<dim>::
+    specific_heat (const double temperature,
+                   const double pressure,
+                   const std::vector<double> &compositional_fields,
+                   const Point<dim> &/*position*/) const
+    {
+      double cp = 0.0;
+      if (!use_table_properties)
+        return reference_specific_heat;
+      else
+        {
+          if (n_material_data == 1)
+            cp = material_lookup[0]->specific_heat(temperature,pressure);
+          else
+            {
+              for (unsigned i = 0; i < n_material_data; ++i)
+                cp += compositional_fields[i] * material_lookup[i]->specific_heat(temperature,pressure);
+            }
+        }
+      cp = std::max(std::min(cp,max_specific_heat),min_specific_heat);
+      return cp;
+    }
+
+
+
+    template <int dim>
+    std::array<std::pair<double, unsigned int>,2>
+    GrainSize<dim>::
+    enthalpy_derivative (const typename Interface<dim>::MaterialModelInputs &in) const
+    {
+      std::array<std::pair<double, unsigned int>,2> derivative;
+
+      if (in.current_cell.state() == IteratorState::valid)
+        {
+          // get the pressures and temperatures at the vertices of the cell
+          const QTrapezoid<dim> quadrature_formula;
+
+          std::vector<double> solution_values(this->get_fe().dofs_per_cell);
+          in.current_cell->get_dof_values(this->get_current_linearization_point(),
+                                          solution_values.begin(),
+                                          solution_values.end());
+
+          // Only create the evaluator the first time we get here
+          if (!temperature_evaluator)
+            temperature_evaluator
+              = std::make_unique<FEPointEvaluation<1,dim>>(this->get_mapping(),
+                                                            this->get_fe(),
+                                                            update_values,
+                                                            this->introspection().component_indices.temperature);
+          if (!pressure_evaluator)
+            pressure_evaluator
+              = std::make_unique<FEPointEvaluation<1,dim>>(this->get_mapping(),
+                                                            this->get_fe(),
+                                                            update_values,
+                                                            this->introspection().component_indices.pressure);
+
+
+          // Initialize the evaluator for the temperature
+          temperature_evaluator->reinit(in.current_cell, quadrature_formula.get_points());
+          temperature_evaluator->evaluate(solution_values,
+                                          EvaluationFlags::values);
+
+          // Initialize the evaluator for the pressure
+          pressure_evaluator->reinit(in.current_cell, quadrature_formula.get_points());
+          pressure_evaluator->evaluate(solution_values,
+                                       EvaluationFlags::values);
+
+          std::vector<double> temperatures(quadrature_formula.size());
+          std::vector<double> pressures(quadrature_formula.size());
+
+          for (unsigned int i=0; i<quadrature_formula.size(); ++i)
+            {
+              temperatures[i] = temperature_evaluator->get_value(i);
+              pressures[i] = pressure_evaluator->get_value(i);
+            }
+
+          AssertThrow (material_lookup.size() == 1,
+                       ExcMessage("This formalism is only implemented for one material "
+                                  "table."));
+
+          // We have to take into account here that the p,T spacing of the table of material properties
+          // we use might be on a finer grid than our model. Because of that we compute the enthalpy
+          // derivatives by using finite differences that average over the whole temperature and
+          // pressure range that is used in this cell. This way we should not miss any phase transformation.
+          derivative = material_lookup[0]->enthalpy_derivatives(temperatures,
+                                                                pressures,
+                                                                max_latent_heat_substeps);
+        }
+
+      return derivative;
+    }
+
+
+
+    template <int dim>
+    void
+    GrainSize<dim>::
+    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      std::vector<double> adiabatic_pressures (in.n_evaluation_points());
+      std::vector<unsigned int> phase_indices (in.n_evaluation_points());
+
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          // Use the adiabatic pressure instead of the real one, because of oscillations
+          adiabatic_pressures[i] = (this->get_adiabatic_conditions().is_initialized())
+                                   ?
+                                   this->get_adiabatic_conditions().pressure(in.position[i])
+                                   :
+                                   in.pressure[i];
+
+          const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[i]).norm();
+
+          out.densities[i] = density(in.temperature[i], adiabatic_pressures[i], in.composition[i], in.position[i]);
+          out.thermal_conductivities[i] = k_value;
+          out.compressibilities[i] = compressibility(in.temperature[i], adiabatic_pressures[i], in.composition[i], in.position[i]);
+
+          // We do not fill the phase function index, because that will be done internally in the get_phase_index() function
+          const double depth = this->get_geometry_model().depth(in.position[i]);
+          const double rho_g = out.densities[i] * gravity_norm;
+          MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature[i], adiabatic_pressures[i], depth, rho_g, numbers::invalid_unsigned_int);
+          phase_indices[i] = get_phase_index(phase_inputs);
+
+          if (in.requests_property(MaterialProperties::viscosity))
+            {
+              double effective_viscosity;
+              double disl_viscosity = std::numeric_limits<double>::max();
+              Assert(std::isfinite(in.strain_rate[i].norm()),
+                     ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                                "not filled by the caller."));
+              const SymmetricTensor<2,dim> shear_strain_rate = deviator(in.strain_rate[i]);
+              const double second_strain_rate_invariant = std::sqrt(std::max(-second_invariant(shear_strain_rate), 0.));
+
+              const double adiabatic_temperature = this->get_adiabatic_conditions().is_initialized()
+                                                   ?
+                                                   this->get_adiabatic_conditions().temperature(in.position[i])
+                                                   :
+                                                   in.temperature[i];
+
+              // Make sure grain size is not negative/too small.
+              std::vector<double> composition (in.composition[i]);
+              composition[grain_size_index] = std::max(min_grain_size,composition[grain_size_index]);
+
+              const double diff_viscosity = diffusion_viscosity(in.temperature[i],
+                                                                adiabatic_temperature,
+                                                                adiabatic_pressures[i],
+                                                                composition[grain_size_index],
+                                                                second_strain_rate_invariant,
+                                                                phase_indices[i]);
+
+              if (std::abs(second_strain_rate_invariant) > 1e-30)
+                {
+                  disl_viscosity = dislocation_viscosity(in.temperature[i], adiabatic_temperature, adiabatic_pressures[i], in.strain_rate[i], phase_indices[i], diff_viscosity);
+                  effective_viscosity = disl_viscosity * diff_viscosity / (disl_viscosity + diff_viscosity);
+                }
+              else
+                effective_viscosity = diff_viscosity;
+
+              if (enable_drucker_prager_rheology)
+                {
+                  // Calculate non-yielding (viscous) stress magnitude.
+                  const double non_yielding_stress = 2. * effective_viscosity * second_strain_rate_invariant;
+
+                  // The following handles phases
+                  std::vector<unsigned int> n_phases = {n_phase_transitions+1};
+                  std::vector<double> phase_function_values(n_phase_transitions, 0.0);
+
+                  for (unsigned int k=0; k<n_phase_transitions; ++k)
+                    {
+                      phase_inputs.phase_index = k;
+                      phase_function_values[k] = phase_function.compute_value(phase_inputs);
+                    }
+
+                  // In the grain size material model, viscosity does not depend on composition,
+                  // so we set the compositional index for the Drucker-Prager parameters to 0.
+                  const Rheology::DruckerPragerParameters drucker_prager_parameters = drucker_prager_plasticity.compute_drucker_prager_parameters(0,
+                                                                                      phase_function_values,
+                                                                                      n_phases);
+                  const double pressure_for_yielding = use_adiabatic_pressure_for_yielding
+                                                       ?
+                                                       adiabatic_pressures[i]
+                                                       :
+                                                       std::max(in.pressure[i],0.0);
+
+                  const double yield_stress = drucker_prager_plasticity.compute_yield_stress(drucker_prager_parameters.cohesion,
+                                                                                             drucker_prager_parameters.angle_internal_friction,
+                                                                                             pressure_for_yielding,
+                                                                                             drucker_prager_parameters.max_yield_stress);
+
+                  // Apply plastic yielding:
+                  // If the non-yielding stress is greater than the yield stress,
+                  // rescale the viscosity back to yield surface
+                  if (non_yielding_stress >= yield_stress)
+                    {
+                      effective_viscosity = drucker_prager_plasticity.compute_viscosity(drucker_prager_parameters.cohesion,
+                                                                                        drucker_prager_parameters.angle_internal_friction,
+                                                                                        pressure_for_yielding,
+                                                                                        second_strain_rate_invariant,
+                                                                                        drucker_prager_parameters.max_yield_stress,
+                                                                                        effective_viscosity);
+                    }
+
+                  PlasticAdditionalOutputs<dim> *plastic_out = out.template get_additional_output<PlasticAdditionalOutputs<dim>>();
+
+                  if (plastic_out != nullptr)
+                    {
+                      plastic_out->cohesions[i] = drucker_prager_parameters.cohesion;
+                      plastic_out->friction_angles[i] = drucker_prager_parameters.angle_internal_friction;
+                      plastic_out->yield_stresses[i] = yield_stress;
+                      plastic_out->yielding[i] = non_yielding_stress >= yield_stress ? 1 : 0;
+                    }
+                }
+
+              out.viscosities[i] = std::min(std::max(min_eta,effective_viscosity),max_eta);
+
+              if (DislocationViscosityOutputs<dim> *disl_viscosities_out = out.template get_additional_output<DislocationViscosityOutputs<dim>>())
+                {
+                  disl_viscosities_out->dislocation_viscosities[i] = std::min(std::max(min_eta,disl_viscosity),1e300);
+                  disl_viscosities_out->diffusion_viscosities[i] = std::min(std::max(min_eta,diff_viscosity),1e300);
+                }
+
+              if (HeatingModel::ShearHeatingOutputs<dim> *shear_heating_out = out.template get_additional_output<HeatingModel::ShearHeatingOutputs<dim>>())
+                {
+                  if (grain_size_evolution_formulation == Formulation::paleowattmeter)
+                    {
+                      const double f = boundary_area_change_work_fraction[phase_indices[i]];
+                      shear_heating_out->shear_heating_work_fractions[i] = 1. - f * out.viscosities[i] / std::min(std::max(min_eta,disl_viscosity),1e300);
+                    }
+                  else if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
+                    {
+                      const double f = compute_partitioning_fraction(in.temperature[i]);
+                      shear_heating_out->shear_heating_work_fractions[i] = 1. - f;
+                    }
+                  else
+                    AssertThrow(false, ExcNotImplemented());
+                }
+            }
+
+          // fill seismic velocities outputs if they exist
+          if (use_table_properties)
+            if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
+              {
+                seismic_out->vp[i] = seismic_Vp(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
+                seismic_out->vs[i] = seismic_Vs(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
+              }
+        }
+
+      if (in.requests_property(MaterialProperties::reaction_terms))
+        out.reaction_terms = grain_size_change(in, adiabatic_pressures, phase_indices);
+
+
+      /* We separate the calculation of specific heat and thermal expansivity,
+       * because they depend on cell-wise averaged values that are only available
+       * here
+       */
+      double average_temperature(0.0);
+      double average_density(0.0);
+      for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
+        {
+          average_temperature += in.temperature[i];
+          average_density += out.densities[i];
+        }
+      average_temperature /= in.n_evaluation_points();
+      average_density /= in.n_evaluation_points();
+
+      std::array<std::pair<double, unsigned int>,2> dH;
+
+      if (use_table_properties && use_enthalpy)
+        dH = enthalpy_derivative(in);
+
+      for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
+        {
+          if (!use_table_properties)
+            {
+              out.thermal_expansion_coefficients[i] = thermal_alpha;
+              out.specific_heat[i] = reference_specific_heat;
+            }
+          else if (use_enthalpy)
+            {
+              if (this->get_adiabatic_conditions().is_initialized()
+                  && (in.current_cell.state() == IteratorState::valid)
+                  && (dH[0].second > 0)
+                  && (dH[1].second > 0))
+                {
+                  out.thermal_expansion_coefficients[i] = (1 - average_density * dH[1].first) / average_temperature;
+                  out.specific_heat[i] = dH[0].first;
+                }
+              else
+                {
+                  if (material_lookup.size() == 1)
+                    {
+                      out.thermal_expansion_coefficients[i] = (1 - out.densities[i] * material_lookup[0]->dHdp(in.temperature[i],adiabatic_pressures[i])) / in.temperature[i];
+                      out.specific_heat[i] = material_lookup[0]->dHdT(in.temperature[i],adiabatic_pressures[i]);
+                    }
+                  else
+                    {
+                      ExcNotImplemented();
+                    }
+                }
+            }
+          else
+            {
+              out.thermal_expansion_coefficients[i] = thermal_expansion_coefficient(in.temperature[i], adiabatic_pressures[i], in.composition[i], in.position[i]);
+              out.specific_heat[i] = specific_heat(in.temperature[i], adiabatic_pressures[i], in.composition[i], in.position[i]);
+            }
+
+          out.thermal_expansion_coefficients[i] = std::max(std::min(out.thermal_expansion_coefficients[i],max_thermal_expansivity),min_thermal_expansivity);
+          out.specific_heat[i] = std::max(std::min(out.specific_heat[i],max_specific_heat),min_specific_heat);
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    GrainSize<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Grain size model");
+        {
+          prm.declare_entry ("Reference density", "3300",
+                             Patterns::Double (0.),
+                             "The reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Viscosity", "5e24",
+                             Patterns::Double (0.),
+                             "The value of the constant viscosity. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250.",
+                             Patterns::Double (0.),
+                             "The value of the specific heat $cp$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\alpha$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Reference compressibility", "4e-12",
+                             Patterns::Double (0.),
+                             "The value of the reference compressibility. "
+                             "Units: \\si{\\per\\pascal}.");
+
+          MaterialUtilities::PhaseFunction<dim>::declare_parameters(prm);
+
+          prm.declare_entry ("Grain growth activation energy", "3.5e5",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The activation energy for grain growth $E_g$. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\joule\\per\\mole}.");
+          prm.declare_entry ("Grain growth activation volume", "8e-6",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The activation volume for grain growth $V_g$. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
+          prm.declare_entry ("Grain growth exponent", "3.",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The exponent of the grain growth law $p_g$. This is an experimentally determined "
+                             "grain growth constant. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: none.");
+          prm.declare_entry ("Grain growth rate constant", "1.5e-5",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The prefactor for the Ostwald ripening grain growth law $G_0$. "
+                             "This is dependent on water content, which is assumed to be "
+                             "50 H/$10^6$ Si for the default value. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\meter}$^{p_g}$\\si{\\per\\second}.");
+          prm.declare_entry ("Minimum grain size", "5e-6",
+                             Patterns::Double (0.),
+                             "The minimum allowable grain size. The grain size will be limited to be "
+                             "larger than this value. This can be used to damp out oscillations, or "
+                             "to limit the viscosity variation due to grain size. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Reciprocal required strain", "10.",
+                             Patterns::List (Patterns::Double (0.)),
+                             "This parameter ($\\lambda$) gives an estimate of the strain necessary "
+                             "to achieve a new grain size. "
+                             "List must have one more entry than the Phase transition depths.");
+          prm.declare_entry ("Recrystallized grain size", "",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The grain size $d_{ph}$ to that a phase will be reduced to when crossing a phase transition. "
+                             "When set to zero, grain size will not be reduced. "
+                             "List must have the same number of entries as Phase transition depths. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Phase volume fraction", "0.4",
+                             Patterns::Double (0., 1.),
+                             "The volume fraction of one of the phases in the two-phase damage model of Bercovici and Ricard (2012). "
+                             "The volume fraction of the other phase can be simply calculated by subtracting from one. "
+                             "This parameter is only used in the pinned state grain damage formulation."
+                             "Units: none.");
+          prm.declare_entry ("Grain size evolution formulation", "paleowattmeter",
+                             Patterns::Selection ("paleowattmeter|paleopiezometer|pinned grain damage"),
+                             "A flag indicating whether the material model should use the "
+                             "paleowattmeter approach of Austin and Evans (2007) for grain size reduction "
+                             "in the dislocation creep regime, the paleopiezometer approach "
+                             "from Hall and Parmetier (2003), or the pinned grain damage approach "
+                             "from Mulyukova and Bercovici (2018).");
+          prm.declare_entry ("Use paleowattmeter", "default",
+                             Patterns::Selection ("true|false|default"),
+                             "A flag indicating whether the computation should use the "
+                             "paleowattmeter approach of Austin and Evans (2007) for grain size reduction "
+                             "in the dislocation creep regime (if true) or the paleopiezometer approach "
+                             "from Hall and Parmetier (2003) (if false). This parameter has been removed. "
+                             "Use 'Grain size evolution formulation' instead.");
+          prm.declare_entry ("Average specific grain boundary energy", "1.0",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The average specific grain boundary energy $\\gamma$. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\joule\\per\\meter\\squared}.");
+          prm.declare_entry ("Work fraction for boundary area change", "0.1",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The fraction $\\chi$ of work done by dislocation creep to change the grain boundary area. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\joule\\per\\meter\\squared}.");
+          prm.declare_entry ("Geometric constant", "3.",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The geometric constant $c$ used in the paleowattmeter grain size reduction law. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: none.");
+          prm.declare_entry ("Dislocation viscosity iteration threshold", "1e-3",
+                             Patterns::Double (0.),
+                             "We need to perform an iteration inside the computation "
+                             "of the dislocation viscosity, because it depends on the "
+                             "dislocation strain rate, which depends on the dislocation "
+                             "viscosity itself. This number determines the termination "
+                             "accuracy, i.e. if the dislocation viscosity changes by less "
+                             "than this factor we terminate the iteration.");
+          prm.declare_entry ("Dislocation viscosity iteration number", "100",
+                             Patterns::Integer(0),
+                             "We need to perform an iteration inside the computation "
+                             "of the dislocation viscosity, because it depends on the "
+                             "dislocation strain rate, which depends on the dislocation "
+                             "viscosity itself. This number determines the maximum "
+                             "number of iterations that are performed. ");
+          prm.declare_entry ("Dislocation creep exponent", "3.5",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The power-law exponent $n_{dis}$ for dislocation creep. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: none.");
+          prm.declare_entry ("Dislocation activation energy", "4.8e5",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The activation energy for dislocation creep $E_{dis}$. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\joule\\per\\mole}.");
+          prm.declare_entry ("Dislocation activation volume", "1.1e-5",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The activation volume for dislocation creep $V_{dis}$. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
+          prm.declare_entry ("Dislocation creep prefactor", "4.5e-15",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The prefactor for the dislocation creep law $A_{dis}$. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\pascal}$^{-n_{dis}}$\\si{\\per\\second}.");
+          prm.declare_entry ("Diffusion creep exponent", "1.",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The power-law exponent $n_{diff}$ for diffusion creep. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: none.");
+          prm.declare_entry ("Diffusion activation energy", "3.35e5",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The activation energy for diffusion creep $E_{diff}$. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\joule\\per\\mole}.");
+          prm.declare_entry ("Diffusion activation volume", "4e-6",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The activation volume for diffusion creep $V_{diff}$. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
+          prm.declare_entry ("Diffusion creep prefactor", "7.4e-15",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The prefactor for the diffusion creep law $A_{diff}$. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: \\si{\\meter}$^{p_{diff}}$\\si{\\pascal}$^{-n_{diff}}$\\si{\\per\\second}.");
+          prm.declare_entry ("Diffusion creep grain size exponent", "3.",
+                             Patterns::List (Patterns::Double (0.)),
+                             "The diffusion creep grain size exponent $p_{diff}$ that determines the "
+                             "dependence of viscosity on grain size. "
+                             "List must have one more entry than the Phase transition depths. "
+                             "Units: none.");
+          prm.declare_entry ("Maximum temperature dependence of viscosity", "100.",
+                             Patterns::Double (0.),
+                             "The factor by which viscosity at adiabatic temperature and ambient temperature "
+                             "are allowed to differ (a value of x means that the viscosity can be x times higher "
+                             "or x times lower compared to the value at adiabatic temperature. This parameter "
+                             "is introduced to limit local viscosity contrasts, but still allow for a widely "
+                             "varying viscosity over the whole mantle range. "
+                             "Units: none.");
+          prm.declare_entry ("Minimum viscosity", "1e18",
+                             Patterns::Double (0.),
+                             "The minimum viscosity that is allowed in the whole model domain. "
+                             "Units: Pa \\, s.");
+          prm.declare_entry ("Maximum viscosity", "1e26",
+                             Patterns::Double (0.),
+                             "The maximum viscosity that is allowed in the whole model domain. "
+                             "Units: Pa \\, s.");
+          prm.declare_entry ("Minimum specific heat", "500.",
+                             Patterns::Double (0.),
+                             "The minimum specific heat that is allowed in the whole model domain. "
+                             "Units: J/kg/K.");
+          prm.declare_entry ("Maximum specific heat", "6000.",
+                             Patterns::Double (0.),
+                             "The maximum specific heat that is allowed in the whole model domain. "
+                             "Units: J/kg/K.");
+          prm.declare_entry ("Minimum thermal expansivity", "1e-5",
+                             Patterns::Double (),
+                             "The minimum thermal expansivity that is allowed in the whole model domain. "
+                             "Units: 1/K.");
+          prm.declare_entry ("Maximum thermal expansivity", "1e-3",
+                             Patterns::Double (),
+                             "The maximum thermal expansivity that is allowed in the whole model domain. "
+                             "Units: 1/K.");
+          prm.declare_entry ("Maximum latent heat substeps", "1",
+                             Patterns::Integer (1),
+                             "The maximum number of substeps over the temperature pressure range "
+                             "to calculate the averaged enthalpy gradient over a cell.");
+          prm.declare_entry ("Minimum grain size", "1e-5",
+                             Patterns::Double (0.),
+                             "The minimum grain size that is used for the material model. This parameter "
+                             "is introduced to limit local viscosity contrasts, but still allows for a widely "
+                             "varying viscosity over the whole mantle range. "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Lower mantle grain size scaling", "1.0",
+                             Patterns::Double (0.),
+                             "This option does not exist any more.");
+          prm.declare_entry ("Advect logarithm of grain size", "false",
+                             Patterns::Bool (),
+                             "This option does not exist any more.");
+          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/steinberger/",
+                             Patterns::DirectoryName (),
+                             "The path to the model data. The path may also include the special "
+                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                             "in which the ASPECT source files were located when ASPECT was "
+                             "compiled. This interpretation allows, for example, to reference "
+                             "files located in the 'data/' subdirectory of ASPECT. ");
+          prm.declare_entry ("Material file names", "pyr-ringwood88.txt",
+                             Patterns::List (Patterns::Anything()),
+                             "The file names of the material data. "
+                             "List with as many components as active "
+                             "compositional fields (material data is assumed to "
+                             "be in order with the ordering of the fields). ");
+          prm.declare_entry ("Derivatives file names", "",
+                             Patterns::List (Patterns::Anything()),
+                             "The file names of the enthalpy derivatives data. "
+                             "List with as many components as active "
+                             "compositional fields (material data is assumed to "
+                             "be in order with the ordering of the fields). ");
+          prm.declare_entry ("Use table properties", "false",
+                             Patterns::Bool(),
+                             "This parameter determines whether to use the table properties "
+                             "also for density, thermal expansivity and specific heat. "
+                             "If false the properties are generated as in the "
+                             "simple compressible plugin.");
+          prm.declare_entry ("Material file format", "perplex",
+                             Patterns::Selection ("perplex|hefesto"),
+                             "The material file format to be read in the property "
+                             "tables.");
+          prm.declare_entry ("Use enthalpy for material properties", "true",
+                             Patterns::Bool(),
+                             "This parameter determines whether to use the enthalpy to calculate "
+                             "the thermal expansivity and specific heat (if true) or use the "
+                             "thermal expansivity and specific heat values from "
+                             "the material properties table directly (if false).");
+          prm.declare_entry ("Bilinear interpolation", "true",
+                             Patterns::Bool (),
+                             "This parameter determines whether to use bilinear interpolation "
+                             "to compute material properties (slower but more accurate).");
+
+          prm.enter_subsection("Grain damage partitioning");
+          {
+            prm.declare_entry ("Temperature for minimum grain damage partitioning", "1600",
+                               Patterns::Double (0.),
+                               "This parameter determines the temperature at which the computed coefficient of shear energy "
+                               "partitioned into grain damage is minimum. This is used in the pinned state limit of the grain "
+                               "size evolution. One choice of this parameter is the mantle temperature at the ridge axis, "
+                               "see Mulyukova and Bercovici (2018) for details.");
+            prm.declare_entry ("Temperature for maximum grain damage partitioning", "283",
+                               Patterns::Double (0.),
+                               "This parameter determines the temperature at which the computed coefficient of shear energy "
+                               "partitioned into grain damage is maximum. This is used in the pinned state limit of the grain "
+                               "size evolution. One choice of this parameter is the surface temperature of the seafloor, see "
+                               "Mulyukova and Bercovici (2018) for details.");
+            prm.declare_entry ("Minimum grain size reduction work fraction", "1e-12",
+                               Patterns::Double (0., 1.),
+                               "This parameter determines the minimum value of the partitioning coefficient, which governs "
+                               "the amount of shear heating partitioned into grain damage in the pinned state limit.");
+            prm.declare_entry ("Maximum grain size reduction work fraction", "1e-1",
+                               Patterns::Double (0., 1.),
+                               "This parameter determines the maximum value of the partitioning coefficient, which governs "
+                               "the amount of shear heating partitioned into grain damage in the pinned state limit.");
+            prm.declare_entry ("Grain size reduction work fraction exponent", "10",
+                               Patterns::Double (0.),
+                               "This parameter determines the variability in how much shear heating is partitioned into "
+                               "grain damage. A higher value suggests a wider temperature range over which the partitioning "
+                               "coefficient is high.");
+          }
+          prm.leave_subsection();
+
+          // Drucker Prager plasticity parameters
+          prm.declare_entry ("Use Drucker-Prager rheology", "false",
+                             Patterns::Bool(),
+                             "This parameter determines whether to apply plastic yielding "
+                             "according to a Drucker-Prager rheology after computing the viscosity "
+                             "from the (grain-size dependent) visous creep flow laws (if true) "
+                             "or not (if false).");
+          prm.declare_entry ("Use adiabatic pressure for yield stress", "false",
+                             Patterns::Bool (),
+                             "Whether to use the adiabatic pressure (if true) instead of the full "
+                             "(non-negative) pressure (if false) when calculating the yield stress. "
+                             "Using the adiabatic pressure (which is analogous to the depth-dependent "
+                             "von Mises model) can be useful to avoid the strong non-linearity associated "
+                             "with dynamic pressure variations affecting the yield strength, which can "
+                             "make the problem ill-posed. However, dynamic pressure can affect the "
+                             "localization of the strain rate and the resulting deformation, and neglecting "
+                             "it therefore changes the solution.");
+          Rheology::DruckerPrager<dim>::declare_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    GrainSize<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      AssertThrow (this->introspection().compositional_name_exists("grain_size"),
+                   ExcMessage("The 'grain size' material model only works if a compositional "
+                              "field with name 'grain_size' is present. Please use another material "
+                              "model or add such a field."));
+      grain_size_index = this->introspection().compositional_index_for_name("grain_size");
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Grain size model");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          reference_T                = prm.get_double ("Reference temperature");
+          eta                        = prm.get_double ("Viscosity");
+          k_value                    = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+          reference_compressibility  = prm.get_double ("Reference compressibility");
+
+          // Phase transition parameters
+          phase_function.initialize_simulator (this->get_simulator());
+          phase_function.parse_parameters (prm);
+
+          std::vector<unsigned int> n_phases_for_each_composition = phase_function.n_phases_for_each_composition();
+          n_phase_transitions = n_phases_for_each_composition[0] - 1;
+
+          recrystallized_grain_size = Utilities::string_to_double
+                                      (Utilities::split_string_list(prm.get ("Recrystallized grain size")));
+
+          if (recrystallized_grain_size.size() != n_phase_transitions)
+            AssertThrow(false,
+                        ExcMessage("Error: The list of recrystallized grain sizes has to have as many entries as there are phases."));
+
+          for (unsigned int i=1; i<n_phase_transitions; ++i)
+            AssertThrow(phase_function.get_transition_depth(i-1)<phase_function.get_transition_depth(i),
+                        ExcMessage("Error: Phase transition depths have to be sorted in ascending order!"));
+
+          // grain evolution parameters
+          grain_growth_activation_energy        = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Grain growth activation energy")));
+          grain_growth_activation_volume        = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Grain growth activation volume")));
+          grain_growth_rate_constant            = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Grain growth rate constant")));
+          grain_growth_exponent                 = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Grain growth exponent")));
+          minimum_grain_size                    = prm.get_double("Minimum grain size");
+          reciprocal_required_strain            = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Reciprocal required strain")));
+
+          grain_size_evolution_formulation      = Formulation::parse(prm.get("Grain size evolution formulation"));
+
+          // TODO: Remove deprecated parameter in next release.
+          const std::string use_paleowattmeter  = prm.get ("Use paleowattmeter");
+          Assert(use_paleowattmeter == "default",
+                 ExcMessage("The parameter 'Use paleowattmeter' has been removed. "
+                            "Use the parameter 'Grain size evolution formulation instead'."));
+
+          const double volume_fraction_phase_one = prm.get_double ("Phase volume fraction");
+
+          AssertThrow(volume_fraction_phase_one != 0. && volume_fraction_phase_one != 1.,
+                      ExcMessage("Volume fraction must be between (0, 1) to use two phase damage in the pinned state!"));
+
+          phase_distribution = phase_distribution_function(volume_fraction_phase_one);
+          roughness_to_grain_size = roughness_to_grain_size_factor(volume_fraction_phase_one);
+
+          grain_boundary_energy                 = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Average specific grain boundary energy")));
+          boundary_area_change_work_fraction    = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Work fraction for boundary area change")));
+          geometric_constant                    = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Geometric constant")));
+
+          if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
+            {
+              prm.enter_subsection("Grain damage partitioning");
+              {
+                grain_size_reduction_work_fraction_exponent = prm.get_double ("Grain size reduction work fraction exponent");
+                maximum_grain_size_reduction_work_fraction  = prm.get_double ("Maximum grain size reduction work fraction");
+                minimum_grain_size_reduction_work_fraction  = prm.get_double ("Minimum grain size reduction work fraction");
+
+                AssertThrow(maximum_grain_size_reduction_work_fraction > 0. && maximum_grain_size_reduction_work_fraction < 1.,
+                            ExcMessage("Maximum grain size reduction work fraction cannot be smaller or equal to 0 or larger or equal to 1."));
+                AssertThrow(minimum_grain_size_reduction_work_fraction > 0. && minimum_grain_size_reduction_work_fraction < 1.,
+                            ExcMessage("Minimum grain size reduction work fraction cannot be smaller or equal to 0 or larger or equal to 1."));
+                AssertThrow(maximum_grain_size_reduction_work_fraction >= minimum_grain_size_reduction_work_fraction,
+                            ExcMessage("Maximum grain size reduction work fraction must be larger than minimum grain size reduction work fraction."));
+
+                const double temperature_minimum_partition  = prm.get_double ("Temperature for minimum grain damage partitioning");
+                const double temperature_maximum_partition  = prm.get_double ("Temperature for maximum grain damage partitioning");
+
+                AssertThrow(temperature_minimum_partition > temperature_maximum_partition,
+                            ExcMessage("Temperature for minimum grain damage partitioning must be larger than Temperature for maximum grain damage partitioning."));
+
+                temperature_minimum_partitioning_power = std::pow(temperature_minimum_partition,grain_size_reduction_work_fraction_exponent);
+                temperature_maximum_partitioning_power = std::pow(temperature_maximum_partition,grain_size_reduction_work_fraction_exponent);
+              }
+              prm.leave_subsection();
+            }
+
+          // rheology parameters
+          dislocation_viscosity_iteration_threshold = prm.get_double("Dislocation viscosity iteration threshold");
+          dislocation_viscosity_iteration_number = prm.get_integer("Dislocation viscosity iteration number");
+          dislocation_creep_exponent            = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Dislocation creep exponent")));
+          dislocation_activation_energy         = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Dislocation activation energy")));
+          dislocation_activation_volume         = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Dislocation activation volume")));
+          dislocation_creep_prefactor           = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Dislocation creep prefactor")));
+          diffusion_creep_exponent              = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion creep exponent")));
+          diffusion_activation_energy           = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion activation energy")));
+          diffusion_activation_volume           = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion activation volume")));
+          diffusion_creep_prefactor             = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion creep prefactor")));
+          diffusion_creep_grain_size_exponent   = Utilities::string_to_double
+                                                  (Utilities::split_string_list(prm.get ("Diffusion creep grain size exponent")));
+          max_temperature_dependence_of_eta     = prm.get_double ("Maximum temperature dependence of viscosity");
+          min_eta                               = prm.get_double ("Minimum viscosity");
+          max_eta                               = prm.get_double ("Maximum viscosity");
+          min_specific_heat                     = prm.get_double ("Minimum specific heat");
+          max_specific_heat                     = prm.get_double ("Maximum specific heat");
+          min_thermal_expansivity               = prm.get_double ("Minimum thermal expansivity");
+          max_thermal_expansivity               = prm.get_double ("Maximum thermal expansivity");
+          max_latent_heat_substeps              = prm.get_integer ("Maximum latent heat substeps");
+          min_grain_size                        = prm.get_double ("Minimum grain size");
+
+          // scale recrystallized grain size, diffusion creep and grain growth prefactor accordingly
+          diffusion_creep_prefactor[diffusion_creep_prefactor.size()-1] *= std::pow(1.0,diffusion_creep_grain_size_exponent[diffusion_creep_grain_size_exponent.size()-1]);
+          grain_growth_rate_constant[grain_growth_rate_constant.size()-1] *= std::pow(1.0,grain_growth_exponent[grain_growth_exponent.size()-1]);
+
+          // prefactors never appear without their exponents. perform some calculations here to save time later
+          for (unsigned int i=0; i<diffusion_creep_prefactor.size(); ++i)
+            diffusion_creep_prefactor[i] = std::pow(diffusion_creep_prefactor[i],-1.0/diffusion_creep_exponent[i]);
+          for (unsigned int i=0; i<dislocation_creep_prefactor.size(); ++i)
+            dislocation_creep_prefactor[i] = std::pow(dislocation_creep_prefactor[i],-1.0/dislocation_creep_exponent[i]);
+
+          // TODO: Remove deprecated parameters in next release.
+          const double pv_grain_size_scaling         = prm.get_double ("Lower mantle grain size scaling");
+          AssertThrow(pv_grain_size_scaling == 1.0,
+                      ExcMessage("Error: The 'Lower mantle grain size scaling' parameter "
+                                 "has been removed. Please remove it from your input file. For models "
+                                 "with large spatial variations in grain size, please advect your "
+                                 "grain size on particles."));
+
+          const bool advect_log_grainsize            = prm.get_bool ("Advect logarithm of grain size");
+          AssertThrow(advect_log_grainsize == false,
+                      ExcMessage("Error: The 'Advect logarithm of grain size' parameter "
+                                 "has been removed. Please remove it from your input file. For models "
+                                 "with large spatial variations in grain size, please advect your "
+                                 "grain size on particles."));
+
+          if (grain_growth_activation_energy.size() != grain_growth_activation_volume.size() ||
+              grain_growth_activation_energy.size() != grain_growth_rate_constant.size() ||
+              grain_growth_activation_energy.size() != grain_growth_exponent.size() ||
+              grain_growth_activation_energy.size() != dislocation_creep_exponent.size() ||
+              grain_growth_activation_energy.size() != dislocation_activation_energy.size() ||
+              grain_growth_activation_energy.size() != dislocation_activation_volume.size() ||
+              grain_growth_activation_energy.size() != dislocation_creep_prefactor.size() ||
+              grain_growth_activation_energy.size() != diffusion_creep_exponent.size() ||
+              grain_growth_activation_energy.size() != diffusion_activation_energy.size() ||
+              grain_growth_activation_energy.size() != diffusion_activation_volume.size() ||
+              grain_growth_activation_energy.size() != diffusion_creep_prefactor.size() ||
+              grain_growth_activation_energy.size() != diffusion_creep_grain_size_exponent.size() )
+            AssertThrow(false,
+                        ExcMessage("Error: The lists of grain size evolution and flow law parameters "
+                                   "need to have the same length!"));
+
+          if (grain_size_evolution_formulation == Formulation::paleowattmeter)
+            {
+              if (grain_growth_activation_energy.size() != grain_boundary_energy.size() ||
+                  grain_growth_activation_energy.size() != boundary_area_change_work_fraction.size() ||
+                  grain_growth_activation_energy.size() != geometric_constant.size() )
+                AssertThrow(false,
+                            ExcMessage("Error: One of the lists of grain size evolution parameters "
+                                       "given for the paleowattmeter does not have the correct length!"));
+            }
+          else if (grain_size_evolution_formulation == Formulation::paleopiezometer)
+            {
+              AssertThrow(grain_growth_activation_energy.size() == reciprocal_required_strain.size(),
+                          ExcMessage("Error: The list of grain size evolution parameters in the "
+                                     "paleopiezometer does not have the correct length!"));
+            }
+          else if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
+            {
+              AssertThrow(n_phase_transitions == 0,
+                          ExcMessage("Error: Currently, the pinned grain damage formulation is only implemented for one mineral phase."));
+            }
+          else
+            AssertThrow(false,
+                        ExcMessage("Error: The size of lists in grain size evolution and flow law parameters "
+                                   "should follow either of the 'paleowattmeter|paleopiezometer|pinned grain damage' "
+                                   "formulations!"));
+
+          AssertThrow(grain_growth_activation_energy.size() == n_phase_transitions+1,
+                      ExcMessage("Error: The lists of grain size evolution and flow law parameters need to "
+                                 "have exactly one more entry than the number of phase transitions "
+                                 "(which is defined by the length of the lists of phase transition depths, ...)!"));
+
+          // parameters for reading in tables with material properties
+          datadirectory        = prm.get ("Data directory");
+          datadirectory = Utilities::expand_ASPECT_SOURCE_DIR(datadirectory);
+          material_file_names  = Utilities::split_string_list
+                                 (prm.get ("Material file names"));
+          derivatives_file_names = Utilities::split_string_list
+                                   (prm.get ("Derivatives file names"));
+          use_table_properties = prm.get_bool ("Use table properties");
+          use_enthalpy = prm.get_bool ("Use enthalpy for material properties");
+
+          // Make sure the grain size field comes after all potential material
+          // data fields. Otherwise our material model calculation uses the
+          // wrong compositional fields.
+          if (use_table_properties && material_file_names.size() > 1)
+            {
+              AssertThrow(grain_size_index >= material_file_names.size(),
+                          ExcMessage("The compositional fields indicating the major element composition need to be first in the "
+                                     "list of compositional fields, but the grain size field seems to have a lower index than the number "
+                                     "of provided data files. This is likely inconsistent. Please check the number of provided data "
+                                     "files and the order of compositional fields."));
+            }
+
+          if (prm.get ("Material file format") == "perplex")
+            material_file_format = perplex;
+          else if (prm.get ("Material file format") == "hefesto")
+            material_file_format = hefesto;
+          else
+            AssertThrow (false, ExcNotImplemented());
+
+          use_bilinear_interpolation = prm.get_bool ("Bilinear interpolation");
+
+          // Plasticity parameters
+          enable_drucker_prager_rheology = prm.get_bool ("Use Drucker-Prager rheology");
+          use_adiabatic_pressure_for_yielding = prm.get_bool ("Use adiabatic pressure for yield stress");
+          drucker_prager_plasticity.initialize_simulator (this->get_simulator());
+
+          std::vector<unsigned int> n_phases = {n_phase_transitions+1};
+          drucker_prager_plasticity.parse_parameters(prm, std::make_unique<std::vector<unsigned int>> (n_phases));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+
+      // Declare dependencies on solution variables
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+
+      this->model_dependence.viscosity = NonlinearDependence::temperature
+                                         | NonlinearDependence::pressure
+                                         | NonlinearDependence::strain_rate
+                                         | NonlinearDependence::compositional_fields;
+
+      this->model_dependence.density = NonlinearDependence::none;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+
+      if (use_table_properties)
+        {
+          this->model_dependence.density |= NonlinearDependence::temperature
+                                            | NonlinearDependence::pressure
+                                            | NonlinearDependence::compositional_fields;
+          this->model_dependence.compressibility = NonlinearDependence::temperature
+                                                   | NonlinearDependence::pressure
+                                                   | NonlinearDependence::compositional_fields;
+          this->model_dependence.specific_heat = NonlinearDependence::temperature
+                                                 | NonlinearDependence::pressure
+                                                 | NonlinearDependence::compositional_fields;
+        }
+      else
+        {
+          if (thermal_alpha != 0)
+            this->model_dependence.density |=NonlinearDependence::temperature;
+          if (reference_compressibility != 0)
+            this->model_dependence.density |=NonlinearDependence::pressure;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    GrainSize<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // These properties are useful as output.
+      if (out.template get_additional_output<DislocationViscosityOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::DislocationViscosityOutputs<dim>> (n_points));
+        }
+
+      // These properties will be used by the heating model to reduce
+      // shear heating by the amount of work done to reduce grain size.
+      if (out.template get_additional_output<HeatingModel::ShearHeatingOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<HeatingModel::ShearHeatingOutputs<dim>> (n_points));
+        }
+
+      // These properties are only output properties.
+      if (use_table_properties && out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
+        }
+
+      if (enable_drucker_prager_rheology && out.template get_additional_output<PlasticAdditionalOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<PlasticAdditionalOutputs<dim>> (n_points));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(GrainSize,
+                                   "grain size",
+                                   "A material model that relies on compositional "
+                                   "fields that correspond to the average grain sizes of a "
+                                   "mineral phase and source terms that determine the grain "
+                                   "size evolution in terms of the strain rate, "
+                                   "temperature, phase transitions, and the creep regime. "
+                                   "This material model only works if a compositional field "
+                                   "named 'grain_size' is present. "
+                                   "In the diffusion creep regime, the viscosity depends "
+                                   "on this grain size field. "
+                                   "We use the grain size evolution laws described in Behn "
+                                   "et al., 2009. Implications of grain size evolution on the "
+                                   "seismic structure of the oceanic upper mantle, "
+                                   "Earth Planet. Sci. Letters, 282, 178–189. "
+                                   "Other material parameters are either prescribed similar "
+                                   "to the 'simple' material model, or read from data files "
+                                   "that were generated by the Perplex or Hefesto software. "
+                                   "This material model "
+                                   "is described in more detail in Dannberg, J., Z. Eilon, "
+                                   "U. Faul, R. Gassmoeller, P. Moulik, and R. Myhill (2017), "
+                                   "The importance of grain size to mantle dynamics and "
+                                   "seismological observations, Geochem. Geophys. Geosyst., "
+                                   "18, 3034–3061, doi:10.1002/2017GC006944.")
+
+#define INSTANTIATE(dim) \
+  template class DislocationViscosityOutputs<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/interface.cc.bak b/source/material_model/interface.cc.bak
new file mode 100644
index 00000000000..11ffbae6d08
--- /dev/null
+++ b/source/material_model/interface.cc.bak
@@ -0,0 +1,1239 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/newton.h>
+
+#include <deal.II/base/exceptions.h>
+#include <deal.II/base/signaling_nan.h>
+#include <tuple>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/fe/fe_q.h>
+
+#include <list>
+
+#ifdef DEBUG
+#ifdef ASPECT_USE_FP_EXCEPTIONS
+#include <cfenv>
+#endif
+#endif
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace NonlinearDependence
+    {
+      bool
+      identifies_single_variable(const Dependence dependence)
+      {
+        Assert (dependence != uninitialized,
+                ExcMessage ("You cannot call this function on an uninitialized dependence value!"));
+        return ((dependence == temperature)
+                ||
+                (dependence == pressure)
+                ||
+                (dependence == strain_rate)
+                ||
+                (dependence == compositional_fields));
+      }
+
+
+
+      ModelDependence::ModelDependence ()
+        :
+        viscosity (uninitialized),
+        density (uninitialized),
+        compressibility (uninitialized),
+        specific_heat (uninitialized),
+        thermal_conductivity (uninitialized)
+      {}
+    }
+
+
+
+// -------------------------------- Deal with registering material models and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    register_material_model (const std::string &name,
+                             const std::string &description,
+                             void (*declare_parameters_function) (ParameterHandler &),
+                             std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_material_model (const std::string &model_name)
+    {
+      return std::get<dim>(registered_plugins).create_plugin (model_name, "Material model::Model name");
+    }
+
+
+
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_material_model (ParameterHandler &prm)
+    {
+      std::string model_name;
+      prm.enter_subsection ("Material model");
+      {
+        model_name = prm.get ("Model name");
+      }
+      prm.leave_subsection ();
+
+      // If one sets the model name to an empty string in the input file,
+      // ParameterHandler produces an error while reading the file. However,
+      // if one omits specifying any model name at all (not even setting it to
+      // the empty string) then the value we get here is the empty string. If
+      // we don't catch this case here, we end up with awkward downstream
+      // errors because the value obviously does not conform to the Pattern.
+      AssertThrow(model_name != "unspecified",
+                  ExcMessage("You need to select a material model "
+                             "(`set Model name' in `subsection Material model')."));
+
+      return create_material_model<dim> (model_name);
+    }
+
+
+
+    template <int dim>
+    const NonlinearDependence::ModelDependence &
+    Interface<dim>::
+    get_model_dependence() const
+    {
+      return model_dependence;
+    }
+
+
+
+    template <int dim>
+    void
+    Interface<dim>::
+    create_additional_named_outputs (MaterialModelOutputs &/*outputs*/) const
+    {
+      // by default we do nothing!
+    }
+
+
+
+    template <int dim>
+    void
+    Interface<dim>::
+    fill_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &input,
+                                          const LinearAlgebra::BlockVector        &solution,
+                                          const FEValuesBase<dim>                 &fe_values,
+                                          const Introspection<dim>                &introspection) const
+    {
+      // go through the list of additional inputs and fill them
+      for (unsigned int i=0; i<input.additional_inputs.size(); ++i)
+        input.additional_inputs[i]->fill(solution, fe_values, introspection);
+    }
+
+
+
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ()
+    {
+      return std::get<dim>(registered_plugins).get_pattern_of_names ();
+    }
+
+
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm)
+    {
+      // declare the actual entry in the parameter file
+      prm.enter_subsection ("Material model");
+      {
+        const std::string pattern_of_names = get_valid_model_names_pattern<dim>();
+        prm.declare_entry ("Model name", "unspecified",
+                           Patterns::Selection (pattern_of_names+"|unspecified"),
+                           "The name of the material model to be used in "
+                           "this simulation. There are many material models "
+                           "you can choose from, as listed below. They generally "
+                           "fall into two category: (i) models that implement "
+                           "a particular case of material behavior, (ii) models "
+                           "that modify other models in some way. We sometimes "
+                           "call the latter ``compositing models''. An example "
+                           "of a compositing model is the ``depth dependent'' model "
+                           "below in that it takes another, freely choosable "
+                           "model as its base and then modifies that model's "
+                           "output in some way."
+                           "\n\n"
+                           "You can select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Material model interface",
+                                                            out);
+    }
+
+
+    template <int dim>
+    MaterialModelInputs<dim>::MaterialModelInputs(const unsigned int n_points,
+                                                  const unsigned int n_comp)
+      :
+      position(n_points, Point<dim>(numbers::signaling_nan<Tensor<1,dim>>())),
+      temperature(n_points, numbers::signaling_nan<double>()),
+      pressure(n_points, numbers::signaling_nan<double>()),
+      pressure_gradient(n_points, numbers::signaling_nan<Tensor<1,dim>>()),
+      velocity(n_points, numbers::signaling_nan<Tensor<1,dim>>()),
+      composition(n_points, std::vector<double>(n_comp, numbers::signaling_nan<double>())),
+      strain_rate(n_points, numbers::signaling_nan<SymmetricTensor<2,dim>>()),
+      current_cell(),
+      requested_properties(MaterialProperties::all_properties)
+    {}
+
+
+
+    template <int dim>
+    MaterialModelInputs<dim>::MaterialModelInputs(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                                  const Introspection<dim> &introspection,
+                                                  const bool compute_strain_rate)
+      :
+      position(input_data.evaluation_points),
+      temperature(input_data.solution_values.size(), numbers::signaling_nan<double>()),
+      pressure(input_data.solution_values.size(), numbers::signaling_nan<double>()),
+      pressure_gradient(input_data.solution_values.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+      velocity(input_data.solution_values.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+      composition(input_data.solution_values.size(), std::vector<double>(introspection.n_compositional_fields, numbers::signaling_nan<double>())),
+      strain_rate(input_data.solution_values.size(), numbers::signaling_nan<SymmetricTensor<2,dim>>()),
+      current_cell(input_data.template get_cell<dim>()),
+      requested_properties(MaterialProperties::all_properties)
+    {
+      AssertThrow (compute_strain_rate == true,
+                   ExcMessage ("The option to not compute the strain rate is no longer supported."));
+
+      for (unsigned int q=0; q<input_data.solution_values.size(); ++q)
+        {
+          Tensor<2,dim> grad_u;
+          for (unsigned int d=0; d<dim; ++d)
+            {
+              grad_u[d] = input_data.solution_gradients[q][introspection.component_indices.velocities[d]];
+              this->velocity[q][d] = input_data.solution_values[q][introspection.component_indices.velocities[d]];
+              this->pressure_gradient[q][d] = input_data.solution_gradients[q][introspection.component_indices.pressure][d];
+            }
+
+          this->strain_rate[q] = symmetrize (grad_u);
+          this->pressure[q] = input_data.solution_values[q][introspection.component_indices.pressure];
+          this->temperature[q] = input_data.solution_values[q][introspection.component_indices.temperature];
+
+          for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+            this->composition[q][c] = input_data.solution_values[q][introspection.component_indices.compositional_fields[c]];
+        }
+    }
+
+
+
+    template <int dim>
+    MaterialModelInputs<dim>::MaterialModelInputs(const FEValuesBase<dim,dim> &fe_values,
+                                                  const typename DoFHandler<dim>::active_cell_iterator &cell_x,
+                                                  const Introspection<dim> &introspection,
+                                                  const LinearAlgebra::BlockVector &solution_vector,
+                                                  const bool compute_strain_rate)
+      :
+      position(fe_values.get_quadrature_points()),
+      temperature(fe_values.n_quadrature_points, numbers::signaling_nan<double>()),
+      pressure(fe_values.n_quadrature_points, numbers::signaling_nan<double>()),
+      pressure_gradient(fe_values.n_quadrature_points, numbers::signaling_nan<Tensor<1,dim>>()),
+      velocity(fe_values.n_quadrature_points, numbers::signaling_nan<Tensor<1,dim>>()),
+      composition(fe_values.n_quadrature_points, std::vector<double>(introspection.n_compositional_fields, numbers::signaling_nan<double>())),
+      strain_rate(fe_values.n_quadrature_points, numbers::signaling_nan<SymmetricTensor<2,dim>>()),
+      current_cell (cell_x),
+      requested_properties(MaterialProperties::all_properties)
+    {
+      // Call the function reinit to populate the new arrays.
+      this->reinit(fe_values, current_cell, introspection, solution_vector, compute_strain_rate);
+    }
+
+
+
+    template <int dim>
+    MaterialModelInputs<dim>::MaterialModelInputs(const MaterialModelInputs &source)
+      :
+      position(source.position),
+      temperature(source.temperature),
+      pressure(source.pressure),
+      pressure_gradient(source.pressure_gradient),
+      velocity(source.velocity),
+      composition(source.composition),
+      strain_rate(source.strain_rate),
+      current_cell(source.current_cell),
+      requested_properties(source.requested_properties)
+    {
+      Assert (source.additional_inputs.size() == 0,
+              ExcMessage ("You can not copy MaterialModelInputs objects that have "
+                          "additional input objects attached"));
+    }
+
+
+
+    template <int dim>
+    void
+    MaterialModelInputs<dim>::reinit(const FEValuesBase<dim,dim> &fe_values,
+                                     const typename DoFHandler<dim>::active_cell_iterator &cell_x,
+                                     const Introspection<dim> &introspection,
+                                     const LinearAlgebra::BlockVector &solution_vector,
+                                     const bool compute_strain_rate)
+    {
+      AssertThrow (compute_strain_rate == true,
+                   ExcMessage ("The option to not compute the strain rate is no longer supported."));
+
+      // Populate the arrays that hold solution values and gradients
+      fe_values[introspection.extractors.temperature].get_function_values (solution_vector, this->temperature);
+      fe_values[introspection.extractors.velocities].get_function_values (solution_vector, this->velocity);
+      fe_values[introspection.extractors.pressure].get_function_values (solution_vector, this->pressure);
+      fe_values[introspection.extractors.pressure].get_function_gradients (solution_vector, this->pressure_gradient);
+      fe_values[introspection.extractors.velocities].get_function_symmetric_gradients (solution_vector, this->strain_rate);
+
+      // Vectors for evaluating the compositional field parts of the finite element solution
+      std::vector<std::vector<double>> composition_values (introspection.n_compositional_fields,
+                                                            std::vector<double> (fe_values.n_quadrature_points));
+      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+        fe_values[introspection.extractors.compositional_fields[c]]
+        .get_function_values(solution_vector,composition_values[c]);
+
+      // Then copy these values to exchange the inner and outer vector, because for the material
+      // model we need a vector with values of all the compositional fields for every quadrature point
+      for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
+        {
+          for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+            this->composition[q][c] = composition_values[c][q];
+        }
+
+      // Finally also record quadrature point positions and the cell
+      this->position = fe_values.get_quadrature_points();
+      this->current_cell = cell_x;
+    }
+
+
+
+    template <int dim>
+    unsigned int
+    MaterialModelInputs<dim>::n_evaluation_points() const
+    {
+      return position.size();
+    }
+
+
+
+    template <int dim>
+    bool
+    MaterialModelInputs<dim>::requests_property(const MaterialProperties::Property &property) const
+    {
+      // Note that this means 'requested_properties' can include other properties than
+      // just 'property', but in any case it at least requests 'property'.
+      return (requested_properties & property) != 0;
+    }
+
+
+
+    template <int dim>
+    MaterialModelOutputs<dim>::MaterialModelOutputs(const unsigned int n_points,
+                                                    const unsigned int n_comp)
+      :
+      viscosities(n_points, numbers::signaling_nan<double>()),
+      densities(n_points, numbers::signaling_nan<double>()),
+      thermal_expansion_coefficients(n_points, numbers::signaling_nan<double>()),
+      specific_heat(n_points, numbers::signaling_nan<double>()),
+      thermal_conductivities(n_points, numbers::signaling_nan<double>()),
+      compressibilities(n_points, numbers::signaling_nan<double>()),
+      entropy_derivative_pressure(n_points, numbers::signaling_nan<double>()),
+      entropy_derivative_temperature(n_points, numbers::signaling_nan<double>()),
+      reaction_terms(n_points, std::vector<double>(n_comp, numbers::signaling_nan<double>()))
+    {}
+
+
+    template <int dim>
+    MaterialModelOutputs<dim>::MaterialModelOutputs(const MaterialModelOutputs<dim> &source)
+      :
+      viscosities(source.viscosities),
+      densities(source.densities),
+      thermal_expansion_coefficients(source.thermal_expansion_coefficients),
+      specific_heat(source.specific_heat),
+      thermal_conductivities(source.thermal_conductivities),
+      compressibilities(source.compressibilities),
+      entropy_derivative_pressure(source.entropy_derivative_pressure),
+      entropy_derivative_temperature(source.entropy_derivative_temperature),
+      reaction_terms(source.reaction_terms),
+      additional_outputs()
+    {
+      Assert (source.additional_outputs.size() == 0,
+              ExcMessage ("You can not copy MaterialModelOutputs objects that have "
+                          "additional output objects attached"));
+    }
+
+
+
+    template <int dim>
+    unsigned int
+    MaterialModelOutputs<dim>::n_evaluation_points() const
+    {
+      return densities.size();
+    }
+
+
+
+    namespace MaterialAveraging
+    {
+      std::string get_averaging_operation_names ()
+      {
+        return "none|default averaging|arithmetic average|harmonic average|geometric average|pick largest|project to Q1|log average|harmonic average only viscosity|geometric average only viscosity|project to Q1 only viscosity";
+      }
+
+
+      AveragingOperation parse_averaging_operation_name (const std::string &s)
+      {
+        if (s == "none")
+          return none;
+        else if (s == "arithmetic average")
+          return arithmetic_average;
+        else if (s == "harmonic average")
+          return harmonic_average;
+        else if (s == "geometric average")
+          return geometric_average;
+        else if (s == "pick largest")
+          return pick_largest;
+        else if (s == "project to Q1")
+          return project_to_Q1;
+        else if (s == "log average")
+          return log_average;
+        else if (s == "harmonic average only viscosity")
+          return harmonic_average_only_viscosity;
+        else if (s == "geometric average only viscosity")
+          return geometric_average_only_viscosity;
+        else if (s == "project to Q1 only viscosity")
+          return project_to_Q1_only_viscosity;
+        else if (s == "default averaging")
+          return default_averaging;
+        else
+          AssertThrow (false,
+                       ExcMessage ("The value <" + s + "> for a material "
+                                   "averaging operation is not one of the "
+                                   "valid values."));
+
+        return none;
+      }
+
+
+
+      namespace
+      {
+        bool
+        all_entries_NaN (const std::vector<double> &values)
+        {
+          for (const double value : values)
+            if (std::isnan(value) == false)
+              return false;
+
+          return true;
+        }
+      }
+
+
+
+      // Do the requested averaging operation for one array. The
+      // projection matrix argument is only used if the operation
+      // chosen is project_to_Q1.
+      void average_property (const AveragingOperation  operation,
+                             const FullMatrix<double>      &projection_matrix,
+                             const FullMatrix<double>      &expansion_matrix,
+                             std::vector<double>           &values_out)
+      {
+#ifdef DEBUG
+#ifdef ASPECT_USE_FP_EXCEPTIONS
+        // disable floating point exceptions while averaging. Errors will be reported
+        // as soon as somebody will try to use the averaged values later.
+        fedisableexcept(FE_DIVBYZERO|FE_INVALID);
+#endif
+#endif
+
+        // if an output field has not been filled (because it was
+        // not requested), then simply do nothing -- no harm no foul
+        // note that it is still an error if only some entries are NaN
+        if (values_out.size() == 0 || all_entries_NaN(values_out) == true)
+          return;
+
+        const unsigned int N = values_out.size();
+        const unsigned int P = expansion_matrix.n();
+        Assert ((P==0) || (/*dim=2*/ P==4) || (/*dim=3*/ P==8),
+                ExcInternalError());
+        Assert (((operation == project_to_Q1) &&
+                 (projection_matrix.m() == P) &&
+                 (projection_matrix.n() == N) &&
+                 (expansion_matrix.m() == N) &&
+                 (expansion_matrix.n() == P))
+                ||
+                ((projection_matrix.m() == 0) &&
+                 (projection_matrix.n() == 0)),
+                ExcInternalError());
+
+        // otherwise do as instructed
+        switch (operation)
+          {
+            case none:
+            {
+              break;
+            }
+
+            case arithmetic_average:
+            {
+              double sum = 0;
+              for (unsigned int i=0; i<N; ++i)
+                sum += values_out[i];
+
+              const double average = sum/N;
+              for (unsigned int i=0; i<N; ++i)
+                values_out[i] = average;
+              break;
+            }
+
+            case harmonic_average:
+            {
+              // if one of the values is zero, the average is 0.0
+              for (unsigned int i=0; i<N; ++i)
+                if (values_out[i] == 0.0)
+                  {
+                    for (unsigned int j=0; j<N; ++j)
+                      values_out[j] = 0.0;
+                    return;
+                  }
+
+              double sum = 0;
+              for (unsigned int i=0; i<N; ++i)
+                sum += 1./values_out[i];
+
+              const double average = 1./(sum/N);
+              for (unsigned int i=0; i<N; ++i)
+                values_out[i] = average;
+              break;
+            }
+
+            case geometric_average:
+            {
+              double average = 1;
+              for (unsigned int i=0; i<N; ++i)
+                {
+                  Assert (values_out[i] >= 0,
+                          ExcMessage ("Computing the geometric average "
+                                      "only makes sense for non-negative "
+                                      "quantities."));
+                  average *= std::pow (values_out[i], 1./N);
+                }
+
+              for (unsigned int i=0; i<N; ++i)
+                values_out[i] = average;
+              break;
+            }
+
+            case pick_largest:
+            {
+              double max = std::numeric_limits<double>::lowest();
+              for (unsigned int i=0; i<N; ++i)
+                max = std::max(max, values_out[i]);
+
+              for (unsigned int i=0; i<N; ++i)
+                values_out[i] = max;
+              break;
+            }
+
+            case project_to_Q1:
+            {
+              // we will need the min/max values below, for use
+              // after the projection operation
+              double min = std::numeric_limits<double>::max();
+              for (unsigned int i=0; i<N; ++i)
+                min = std::min(min, values_out[i]);
+
+              double max = std::numeric_limits<double>::lowest();
+              for (unsigned int i=0; i<N; ++i)
+                max = std::max(max, values_out[i]);
+
+              // take the projection matrix and apply it to the
+              // values. as explained in the documentation of the
+              // compute_projection_matrix, this performs the operation
+              // we want in the current context
+              Vector<double> x (N), z(P), y(N);
+              for (unsigned int i=0; i<N; ++i)
+                y(i) = values_out[i];
+              projection_matrix.vmult (z, y);
+
+              // now that we have the Q1 values, restrict them to
+              // the min/max range of the original data
+              for (unsigned int i=0; i<P; ++i)
+                z[i] = std::max (min,
+                                 std::min (max,
+                                           z[i]));
+
+              // then expand back to the quadrature points
+              expansion_matrix.vmult (x, z);
+              for (unsigned int i=0; i<N; ++i)
+                values_out[i] = x(i);
+
+              break;
+            }
+
+            case log_average:
+            {
+              double sum = 0;
+              for (unsigned int i=0; i<N; ++i)
+                {
+                  if (values_out[i] == 0.0)
+                    {
+                      sum = -std::numeric_limits<double>::infinity();
+                      break;
+                    }
+                  Assert (values_out[i] > 0.0,
+                          ExcMessage ("Computing the log average "
+                                      "only makes sense for positive "
+                                      "quantities."));
+                  sum += std::log10(values_out[i]);
+                }
+              const double log_value_average = std::pow (10., sum/N);
+              for (unsigned int i=0; i<N; ++i)
+                values_out[i] = log_value_average;
+              break;
+            }
+
+            default:
+            {
+              AssertThrow (false,
+                           ExcMessage ("This averaging operation is not implemented."));
+            }
+          }
+
+#ifdef DEBUG
+#ifdef ASPECT_USE_FP_EXCEPTIONS
+        // enable floating point exceptions again:
+        feenableexcept(FE_DIVBYZERO|FE_INVALID);
+#endif
+#endif
+      }
+
+
+      /**
+       * Given a quadrature formula, compute a matrices $E, M^{-1}F$
+       * representing a linear operator in the following way: Let
+       * there be a vector $F$ with $N$ elements where the elements
+       * are data stored at each of the $N$ quadrature points of the
+       * given quadrature formula. (For this quadrature formula, we only
+       * care about the locations of the quadrature points on the
+       * reference cell, but not about quadrature weights.)
+       * Then project this data into a $Q_1$ space and evaluate this
+       * projection at the same quadrature points.
+       *
+       * This operator can be expressed in the following way where $P=2^{dim}$
+       * is the number of degrees of freedom of the $Q_1$ element:
+       *
+       * Let $y$ be the input vector with $N$ elements. We would like to find
+       * a function $u_h(x)$ that is a $Q_1$ function that is closest to
+       * the data points, i.e., we seek
+       * @f{align*}{
+       *   min_{u_h \in Q_1(K)} \frac 12 \sum_q |u_h(x_q) - y_q|^2 |J(x_q)| w_q.
+       * @f}
+       * where $x_q$ are the evaluation points, $J$ is the Jacobian matrix of the
+       * mapping from reference to real cell, and $w_q$ are the
+       * quadrature weights.
+       * Expanding $u_h = \sum_j U_j \varphi_j$, this leads to the following
+       * minimization problem for the vector of coefficients $U$:
+       * @f{align*}{
+       *   min_{U} \frac 12 \sum_q |\sum_j U_j \varphi_j(x_q) - y_q|^2 w_q,
+       * @f}
+       * which can be rewritten as
+       * @f{align*}{
+       *   min_{U} \frac 12 \sum_q
+       *       [ \sum_i \sum_j U_i U_j \varphi_i(x_q)\varphi_j(x_q)
+       *        - 2 \sum_j U_j \varphi_j(x_q) y_q
+       *        + y_q^2                                             ].
+       * @f}
+       * This optimization problem has the following solution that one can arrive at
+       * simply by setting the derivative of the objective function with regard to
+       * $U$ to zero:
+       * @f{align*}{
+       *       \sum q \sum_i \sum_j \varphi_i(x_q)\varphi_j(x_q) |J(x_q)| w_q U_j
+       *       =
+       *       \sum_q \varphi_i(x_q) |J(x_q)| w_q y_q
+       * @f}
+       * If we let $F$ be the $P \times N$ matrix so that
+       * @f{align*}{
+       *   F_{iq} = \varphi_i(x_q) |J(x_q)| w_q
+       * @f}
+       * Next, let $M_{ij}$ be the $P\times P$ mass matrix on the
+       * $Q_1$ space with regard to the given evaluation points and corresponding
+       * weights. Then $U = M^{-1}Fy$ corresponds to the projection
+       * of $y$ into the $Q_1$ space (or, more correctly, it
+       * corresponds to vector of the nodal values of this projection).
+       *
+       * Finally, let $E_{qi} = \varphi_i(x_q)$ be the evaluation
+       * operation of shape functions at quadrature points.
+       *
+       * Then, the operation $X=EM^{-1}F$ is the operation we seek.
+       * This function computes the matrices $E$ and $M^{-1}F$.
+       */
+      template <int dim>
+      void compute_projection_matrix (const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                      const Quadrature<dim>   &quadrature_formula,
+                                      const Mapping<dim>      &mapping,
+                                      FullMatrix<double>      &projection_matrix,
+                                      FullMatrix<double>      &expansion_matrix)
+      {
+        static const FE_Q<dim> fe(1);
+        FEValues<dim> fe_values (mapping, fe, quadrature_formula,
+                                 update_values | update_JxW_values);
+
+        const unsigned int P = fe.dofs_per_cell;
+        const unsigned int N = quadrature_formula.size();
+
+        FullMatrix<double> F (P, N);
+        FullMatrix<double> M (P, P);
+
+        projection_matrix.reinit (P, N);
+        expansion_matrix.reinit (N, P);
+
+        // reinitialize the fe_values object with the current cell. we get a
+        // DoFHandler cell, but we are not going to use it with the
+        // finite element associated with that DoFHandler, so cast it back
+        // to just a tria iterator (all we need anyway is the geometry)
+        fe_values.reinit (typename Triangulation<dim>::active_cell_iterator(cell));
+
+        // compute the matrices F, M, E
+        for (unsigned int i=0; i<P; ++i)
+          for (unsigned int q=0; q<N; ++q)
+            F(i,q) = fe_values.shape_value(i,q) *
+                     fe_values.JxW(q);
+
+        for (unsigned int i=0; i<P; ++i)
+          for (unsigned int j=0; j<P; ++j)
+            for (unsigned int q=0; q<N; ++q)
+              M(i,j) += fe_values.shape_value(i,q) *
+                        fe_values.shape_value(j,q) *
+                        fe_values.JxW(q);
+
+        for (unsigned int q=0; q<N; ++q)
+          for (unsigned int i=0; i<P; ++i)
+            expansion_matrix(q,i) = fe_values.shape_value(i,q);
+
+        // replace M by M^{-1}
+        M.gauss_jordan();
+
+        // form M^{-1} F
+        M.mmult (projection_matrix, F);
+      }
+
+
+      /**
+       * Calculate the weight for viscosity derivative, which depends on
+       * the material averaging scheme. Currently the newton method is
+       * only compatible with arithmetic average, harmonic average and
+       * geometric/log average for viscosity.
+       */
+      double
+      compute_viscosity_derivative_averaging_weight(const AveragingOperation operation,
+                                                    const double average_viscosity,
+                                                    const double viscosity_before_averaging,
+                                                    const double one_over_Nq)
+      {
+        switch (operation)
+          {
+            case none:
+              // should never reach here:
+              return numbers::signaling_nan<double>();
+
+            case arithmetic_average:
+              return one_over_Nq;
+
+            case harmonic_average:
+            case harmonic_average_only_viscosity:
+              return Utilities::fixed_power<2,double>(average_viscosity / viscosity_before_averaging)
+                     * one_over_Nq;
+
+            case geometric_average:
+            case geometric_average_only_viscosity:
+            case log_average:
+              return (average_viscosity / viscosity_before_averaging)
+                     * one_over_Nq;
+
+            default:
+              AssertThrow(false,
+                          ExcMessage("The Newton method currently only works if the material "
+                                     "averaging scheme is ``none'', ``arithmetic average'', "
+                                     "``harmonic average (only viscosity)'', ``geometric "
+                                     "average (only viscosity)'' or ``log average''."));
+          }
+      }
+
+
+      template <int dim>
+      void average (const AveragingOperation operation,
+                    const typename DoFHandler<dim>::active_cell_iterator &cell,
+                    const Quadrature<dim>         &quadrature_formula,
+                    const Mapping<dim>            &mapping,
+                    const MaterialProperties::Property &requested_properties,
+                    MaterialModelOutputs<dim>     &values_out)
+      {
+        if (operation == none)
+          return;
+
+        FullMatrix<double> projection_matrix;
+        FullMatrix<double> expansion_matrix;
+
+        const bool average_viscosity = requested_properties & MaterialProperties::Property::viscosity;
+
+        if (operation == project_to_Q1
+            ||
+            operation == project_to_Q1_only_viscosity)
+          {
+            Assert (quadrature_formula.size() == values_out.n_evaluation_points(),
+                    ExcMessage("When asking for a Q1-type averaging operation, "
+                               "this function requires to know the locations of "
+                               "the evaluation points."));
+            projection_matrix.reinit (quadrature_formula.size(),
+                                      quadrature_formula.size());
+            compute_projection_matrix (cell,
+                                       quadrature_formula,
+                                       mapping,
+                                       projection_matrix,
+                                       expansion_matrix);
+          }
+
+        // store the original viscosities if we need to compute the
+        // system jacobian later on
+        MaterialModelDerivatives<dim> *derivatives =
+          values_out.template get_additional_output<MaterialModelDerivatives<dim>>();
+
+        std::vector<double> viscosity_before_averaging;
+        if (derivatives != nullptr)
+          viscosity_before_averaging = values_out.viscosities;
+
+        // compute the average of viscosity
+        if (average_viscosity)
+          {
+            if (operation == harmonic_average_only_viscosity)
+              average_property (harmonic_average, projection_matrix, expansion_matrix,
+                                values_out.viscosities);
+
+            else if (operation == geometric_average_only_viscosity)
+              average_property (geometric_average, projection_matrix, expansion_matrix,
+                                values_out.viscosities);
+
+            else if (operation == project_to_Q1_only_viscosity)
+              average_property (project_to_Q1, projection_matrix, expansion_matrix,
+                                values_out.viscosities);
+
+            else
+              average_property (operation, projection_matrix, expansion_matrix,
+                                values_out.viscosities);
+
+            // calculate the weight of viscosity derivative at each
+            // quadrature point
+            if (derivatives != nullptr)
+              {
+                for (unsigned int q = 0; q < values_out.n_evaluation_points(); ++q)
+                  derivatives->viscosity_derivative_averaging_weights[q] =
+                    compute_viscosity_derivative_averaging_weight(
+                      operation, values_out.viscosities[q], viscosity_before_averaging[q],
+                      1. / values_out.n_evaluation_points());
+              }
+          }
+
+        if (operation == harmonic_average_only_viscosity ||
+            operation == geometric_average_only_viscosity ||
+            operation == project_to_Q1_only_viscosity)
+          return;
+
+        average_property (operation, projection_matrix, expansion_matrix,
+                          values_out.densities);
+        average_property (operation, projection_matrix, expansion_matrix,
+                          values_out.thermal_expansion_coefficients);
+        average_property (operation, projection_matrix, expansion_matrix,
+                          values_out.specific_heat);
+        average_property (operation, projection_matrix, expansion_matrix,
+                          values_out.thermal_conductivities);
+        average_property (operation, projection_matrix, expansion_matrix,
+                          values_out.compressibilities);
+        average_property (operation, projection_matrix, expansion_matrix,
+                          values_out.entropy_derivative_pressure);
+        average_property (operation, projection_matrix, expansion_matrix,
+                          values_out.entropy_derivative_temperature);
+
+        // The reaction terms are unfortunately stored in reverse
+        // indexing. It's also not quite clear whether these should
+        // really be averaged, so avoid this for now.
+
+        // average all additional outputs
+        for (unsigned int i=0; i<values_out.additional_outputs.size(); ++i)
+          values_out.additional_outputs[i]->average (operation, projection_matrix, expansion_matrix);
+      }
+    }
+
+
+
+    template <int dim>
+    NamedAdditionalMaterialOutputs<dim>::
+    NamedAdditionalMaterialOutputs(const std::vector<std::string> &output_names)
+      :
+      names(output_names)
+    {}
+
+
+
+    template <int dim>
+    NamedAdditionalMaterialOutputs<dim>::
+    NamedAdditionalMaterialOutputs(const std::vector<std::string> &output_names,
+                                   const unsigned int n_points)
+      :
+      output_values(output_names.size(), std::vector<double>(n_points, numbers::signaling_nan<double>())),
+      names(output_names)
+    {}
+
+
+
+    template <int dim>
+    NamedAdditionalMaterialOutputs<dim>::
+    ~NamedAdditionalMaterialOutputs()
+      = default;
+
+
+
+    template <int dim>
+    const std::vector<std::string> &
+    NamedAdditionalMaterialOutputs<dim>::get_names() const
+    {
+      return names;
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    NamedAdditionalMaterialOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      // In this function we extract the values for the nth output
+      // The number of outputs is the outer vector
+      Assert (output_values.size() > idx,
+              ExcMessage ("The requested output index is out of range for output_values."));
+      Assert (output_values[idx].size() > 0,
+              ExcMessage ("There must be one or more points for the nth output."));
+      return output_values[idx];
+    }
+
+
+
+    template <int dim>
+    PrescribedPlasticDilation<dim>::PrescribedPlasticDilation (const unsigned int n_points)
+      : NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1, "prescribed_dilation")),
+        dilation(n_points, numbers::signaling_nan<double>())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double> PrescribedPlasticDilation<dim>::get_nth_output(const unsigned int idx) const
+    {
+      (void)idx;
+      Assert(idx==0, ExcInternalError());
+      return dilation;
+    }
+
+
+
+    namespace
+    {
+      std::vector<std::string> make_seismic_additional_outputs_names()
+      {
+        std::vector<std::string> names;
+        names.emplace_back("seismic_Vs");
+        names.emplace_back("seismic_Vp");
+        return names;
+      }
+    }
+
+
+
+    template <int dim>
+    SeismicAdditionalOutputs<dim>::SeismicAdditionalOutputs (const unsigned int n_points)
+      :
+      NamedAdditionalMaterialOutputs<dim>(make_seismic_additional_outputs_names()),
+      vs(n_points, numbers::signaling_nan<double>()),
+      vp(n_points, numbers::signaling_nan<double>())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    SeismicAdditionalOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      AssertIndexRange (idx, 2);
+      switch (idx)
+        {
+          case 0:
+            return vs;
+
+          case 1:
+            return vp;
+
+          default:
+            AssertThrow(false, ExcInternalError());
+        }
+      // we will never get here, so just return something
+      return vs;
+    }
+
+
+
+    namespace
+    {
+      std::vector<std::string> make_reaction_rate_outputs_names(const unsigned int n_comp)
+      {
+        std::vector<std::string> names;
+        for (unsigned int c=0; c<n_comp; ++c)
+          names.push_back("reaction_rate_C" + Utilities::int_to_string(c));
+
+        return names;
+      }
+
+
+
+      std::vector<std::string> make_prescribed_field_output_names(const unsigned int n_comp)
+      {
+        std::vector<std::string> names;
+        for (unsigned int c=0; c<n_comp; ++c)
+          names.push_back("prescribed_field_output_C" + Utilities::int_to_string(c));
+        return names;
+      }
+    }
+
+
+
+    template <int dim>
+    ReactionRateOutputs<dim>::ReactionRateOutputs (const unsigned int n_points,
+                                                   const unsigned int n_comp)
+      :
+      NamedAdditionalMaterialOutputs<dim>(make_reaction_rate_outputs_names(n_comp)),
+      reaction_rates(n_points, std::vector<double>(n_comp, std::numeric_limits<double>::quiet_NaN()))
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    ReactionRateOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      // we have to extract the reaction rate outputs for one particular compositional
+      // field, but the vector in the material model outputs is sorted so that the
+      // number of evaluation points (and not the compositional fields) is the outer
+      // vector
+      std::vector<double> cth_reaction_rates(reaction_rates.size());
+      for (unsigned int q=0; q<reaction_rates.size(); ++q)
+        cth_reaction_rates[q] = reaction_rates[q][idx];
+
+      return cth_reaction_rates;
+    }
+
+
+
+    namespace
+    {
+      std::vector<std::string> make_phase_outputs_names()
+      {
+        std::vector<std::string> names;
+        names.emplace_back("phase");
+        return names;
+      }
+    }
+
+
+
+    template <int dim>
+    PhaseOutputs<dim>::PhaseOutputs (const unsigned int n_points)
+      :
+      NamedAdditionalMaterialOutputs<dim>(make_phase_outputs_names(), n_points)
+    {}
+
+
+
+    template <int dim>
+    PrescribedFieldOutputs<dim>::PrescribedFieldOutputs (const unsigned int n_points,
+                                                         const unsigned int n_comp)
+      :
+      NamedAdditionalMaterialOutputs<dim>(make_prescribed_field_output_names(n_comp)),
+      prescribed_field_outputs(n_points, std::vector<double>(n_comp, std::numeric_limits<double>::quiet_NaN()))
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    PrescribedFieldOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      // we have to extract the prescribed field outputs for one particular compositional
+      // field, but the vector in the material model outputs is sorted so that the
+      // number of evaluation points (and not the compositional fields) is the outer
+      // vector
+      std::vector<double> nth_prescribed_field_output(prescribed_field_outputs.size());
+      for (unsigned int q=0; q<prescribed_field_outputs.size(); ++q)
+        nth_prescribed_field_output[q] = prescribed_field_outputs[q][idx];
+      return nth_prescribed_field_output;
+    }
+
+
+
+    template <int dim>
+    PrescribedTemperatureOutputs<dim>::PrescribedTemperatureOutputs (const unsigned int n_points)
+      :
+      NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1,"prescribed_temperature")),
+      prescribed_temperature_outputs(n_points, std::numeric_limits<double>::quiet_NaN())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    PrescribedTemperatureOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      (void)idx;
+      AssertIndexRange (idx, 1);
+      return prescribed_temperature_outputs;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<MaterialModel::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<MaterialModel::Interface<2>>::plugins = nullptr;
+
+      template <>
+      std::list<internal::Plugins::PluginList<MaterialModel::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<MaterialModel::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_material_model<dim> (const std::string &, \
+                                const std::string &, \
+                                void ( *) (ParameterHandler &), \
+                                std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template \
+  std::string \
+  get_valid_model_names_pattern<dim> (); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_material_model<dim> (const std::string &model_name); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_material_model<dim> (ParameterHandler &prm); \
+  \
+  template class MaterialModelInputs<dim>; \
+  \
+  template class MaterialModelOutputs<dim>; \
+  \
+  template class AdditionalMaterialOutputs<dim>; \
+  \
+  template class NamedAdditionalMaterialOutputs<dim>; \
+  \
+  template class SeismicAdditionalOutputs<dim>; \
+  \
+  template class ReactionRateOutputs<dim>; \
+  \
+  template class PhaseOutputs<dim>; \
+  \
+  template class PrescribedPlasticDilation<dim>; \
+  \
+  template class PrescribedFieldOutputs<dim>; \
+  \
+  template class PrescribedTemperatureOutputs<dim>; \
+  \
+  namespace MaterialAveraging \
+  { \
+    template                \
+    void average (const AveragingOperation operation, \
+                  const DoFHandler<dim>::active_cell_iterator &cell, \
+                  const Quadrature<dim>     &quadrature_formula, \
+                  const Mapping<dim>        &mapping, \
+                  const MaterialProperties::Property &requested_properties, \
+                  MaterialModelOutputs<dim> &values_out); \
+  }
+
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/latent_heat.cc.bak b/source/material_model/latent_heat.cc.bak
new file mode 100644
index 00000000000..dd4a69ccac8
--- /dev/null
+++ b/source/material_model/latent_heat.cc.bak
@@ -0,0 +1,422 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/latent_heat.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/gravity_model/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    LatentHeat<dim>::
+    evaluate(const MaterialModelInputs<dim> &in,
+             MaterialModelOutputs<dim> &out) const
+    {
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double temperature = in.temperature[i];
+          const double pressure = in.pressure[i];
+          const std::vector<double> composition = in.composition[i];
+          const Point<dim> position = in.position[i];
+
+          // Assign constant material properties
+          {
+            out.specific_heat[i] = reference_specific_heat;
+            out.thermal_conductivities[i] = k_value;
+            out.thermal_expansion_coefficients[i] = thermal_alpha;
+            out.compressibilities[i] = reference_compressibility;
+          }
+
+          // Calculate Viscosity
+          {
+            const double reference_temperature = (this->include_adiabatic_heating()
+                                                  ?
+                                                  this->get_adiabatic_conditions().temperature(in.position[i])
+                                                  :
+                                                  reference_T);
+
+            const double delta_temp = temperature-reference_temperature;
+            const double T_dependence = ( thermal_viscosity_exponent == 0.0
+                                          ?
+                                          0.0
+                                          :
+                                          thermal_viscosity_exponent * delta_temp / reference_temperature );
+
+            double visc_temperature_dependence = std::max(std::min(std::exp(-T_dependence),1e2),1e-2);
+
+            if (std::isnan(visc_temperature_dependence))
+              visc_temperature_dependence = 1.0;
+
+            double visc_composition_dependence = 1.0;
+            if ((composition_viscosity_prefactor != 1.0) && (composition.size() > 0))
+              {
+                // geometric interpolation
+                out.viscosities[i] = (pow(10, ((1-composition[0]) * log10(eta*visc_temperature_dependence)
+                                               + composition[0] * log10(eta*composition_viscosity_prefactor*visc_temperature_dependence))));
+              }
+            else
+              out.viscosities[i] = visc_composition_dependence * visc_temperature_dependence * eta;
+          }
+
+          // Calculate density
+          // and phase dependence of viscosity
+          {
+            // first, calculate temperature dependence of density
+            // temperature dependence is 1 - alpha * (T - T(adiabatic))
+            const double density_temperature_dependence = 1.0 - (temperature - this->get_adiabatic_conditions().temperature(position))
+                                                          * thermal_alpha;
+
+            // second, calculate composition dependence of density
+            // constant density difference between peridotite and eclogite
+            const double density_composition_dependence = composition.size()>0
+                                                          ?
+                                                          compositional_delta_rho * composition[0]
+                                                          :
+                                                          0.0;
+
+            // third, calculate the density (and viscosity) differences due to phase
+            // transitions (temperature- and pressure dependence included).
+            // the phase function gives the percentage of material that has
+            // already undergone the phase transition to the higher-pressure material
+            // (this is done individual for each transitions and summed up
+            // in the end)
+            // this means, that there are no actual density or viscosity "jumps", but
+            // gradual transitions between the materials
+            double phase_dependence = 0.0;
+            double viscosity_phase_dependence = 1.0;
+
+            // Loop through phase transitions
+            for (unsigned int phase=0; phase<phase_function.n_phase_transitions(); ++phase)
+              {
+                const double depth = this->get_geometry_model().depth(position);
+                const double pressure_depth_derivative = (depth > 0.0)
+                                                         ?
+                                                         this->get_adiabatic_conditions().pressure(position) / depth
+                                                         :
+                                                         this->get_gravity_model().gravity_vector(position).norm() * reference_rho;
+
+                const MaterialUtilities::PhaseFunctionInputs<dim> phase_in(temperature,
+                                                                           pressure,
+                                                                           depth,
+                                                                           pressure_depth_derivative,
+                                                                           phase);
+
+                const double phaseFunction = phase_function.compute_value(phase_in);
+
+                // Note that for the densities we have a list of jumps, so the index used
+                // in the loop corresponds to the index of the phase transition. For the
+                // viscosities we have a list of prefactors, which has one more entry
+                // for the first layer, so we have to use phase+1 as the index.
+                if (composition.size()==0)
+                  {
+                    phase_dependence += phaseFunction * density_jumps[phase];
+                    viscosity_phase_dependence *= 1. + phaseFunction * (phase_prefactors[phase+1]-1.);
+                  }
+                else if (composition.size()>0)
+                  {
+                    if (transition_phases[phase] == 0)     // 1st compositional field
+                      phase_dependence += phaseFunction * density_jumps[phase] * (1.0 - composition[0]);
+                    else if (transition_phases[phase] == 1) // 2nd compositional field
+                      phase_dependence += phaseFunction * density_jumps[phase] * composition[0];
+
+                    viscosity_phase_dependence *= 1. + phaseFunction * (phase_prefactors[phase]-1.);
+                  }
+              }
+
+            // fourth, pressure dependence of density
+            const double kappa = reference_compressibility;
+            const double pressure_dependence = reference_rho * kappa * (pressure - this->get_surface_pressure());
+
+            // In the end, all the influences are added up.
+            // In the non-Boussinesq case, we chose to add the composition-, pressure-, and phase-dependent terms
+            // first, before applying the density changes due to thermal expansion, because they can be relatively
+            // large and should be taken into account for the temperature dependence (for example, if the material
+            // has a different density because it is in a new phase, we should take the density of that new phase
+            // to compute thermal expansion effects).
+            out.densities[i] = (reference_rho + density_composition_dependence + pressure_dependence + phase_dependence)
+                               * density_temperature_dependence;
+
+            // For the Boussinesq approximation, all terms are linearized and added separately (that is simply how
+            // the Boussinesq approximation is defined). This means we have to apply the temperature term first
+            // since it is (1 - alpha T).
+            if (this->get_parameters().formulation == Parameters<dim>::Formulation::boussinesq_approximation)
+              out.densities[i] = (reference_rho * density_temperature_dependence + density_composition_dependence + phase_dependence);
+
+            out.viscosities[i] = std::max(minimum_viscosity, std::min(maximum_viscosity, out.viscosities[i] * viscosity_phase_dependence));
+          }
+
+          // Calculate entropy derivative
+          {
+            double entropy_gradient_pressure = 0.0;
+            double entropy_gradient_temperature = 0.0;
+            const double rho = out.densities[i];
+
+            if (this->get_adiabatic_conditions().is_initialized() && this->include_latent_heat())
+              for (unsigned int phase=0; phase<phase_function.n_phase_transitions(); ++phase)
+                {
+                  const double depth = this->get_geometry_model().depth(in.position[i]);
+                  const double pressure_depth_derivative = (this->get_adiabatic_conditions().pressure(position) > 0)
+                                                           ?
+                                                           depth / this->get_adiabatic_conditions().pressure(position)
+                                                           :
+                                                           this->get_gravity_model().gravity_vector(in.position[i]).norm() * reference_rho;
+
+                  const MaterialUtilities::PhaseFunctionInputs<dim> phase_in(temperature,
+                                                                             pressure,
+                                                                             depth,
+                                                                             pressure_depth_derivative,
+                                                                             phase);
+
+                  const double PhaseFunctionDerivative = phase_function.compute_derivative(phase_in);
+                  const double clapeyron_slope = phase_function.get_transition_slope(phase);
+
+                  double entropy_change = 0.0;
+                  if (composition.size()==0)      // only one compositional field
+                    entropy_change = clapeyron_slope * density_jumps[phase] / (rho * rho);
+                  else
+                    {
+                      if (transition_phases[phase] == 0)     // 1st compositional field
+                        entropy_change = clapeyron_slope * density_jumps[phase] / (rho * rho) * (1.0 - composition[0]);
+                      else if (transition_phases[phase] == 1) // 2nd compositional field
+                        entropy_change = clapeyron_slope * density_jumps[phase] / (rho * rho) * composition[0];
+                    }
+                  // we need DeltaS * DX/Dpressure_deviation for the pressure derivative
+                  // and - DeltaS * DX/Dpressure_deviation * gamma for the temperature derivative
+                  entropy_gradient_pressure += PhaseFunctionDerivative * entropy_change;
+                  entropy_gradient_temperature -= PhaseFunctionDerivative * entropy_change * clapeyron_slope;
+                }
+
+            out.entropy_derivative_pressure[i] = entropy_gradient_pressure;
+            out.entropy_derivative_temperature[i] = entropy_gradient_temperature;
+          }
+
+          // Assign reaction terms
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    LatentHeat<dim>::
+    is_compressible () const
+    {
+      if (reference_compressibility > 0)
+        return true;
+      else
+        return false;
+    }
+
+
+
+    template <int dim>
+    void
+    LatentHeat<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Latent heat");
+        {
+          prm.declare_entry ("Reference density", "3300.",
+                             Patterns::Double (0.),
+                             "Reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Viscosity", "5e24",
+                             Patterns::Double (0.),
+                             "The value of the constant viscosity. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Composition viscosity prefactor", "1.0",
+                             Patterns::Double (0.),
+                             "A linear dependency of viscosity on composition. Dimensionless prefactor.");
+          prm.declare_entry ("Thermal viscosity exponent", "0.0",
+                             Patterns::Double (0.),
+                             "The temperature dependence of viscosity. Dimensionless exponent.");
+          prm.declare_entry ("Thermal conductivity", "2.38",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250.",
+                             Patterns::Double (0.),
+                             "The value of the specific heat $C_p$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "4e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\beta$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Compressibility", "5.124e-12",
+                             Patterns::Double (0.),
+                             "The value of the compressibility $\\kappa$. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("Density differential for compositional field 1", "0.",
+                             Patterns::Double(),
+                             "If compositional fields are used, then one would frequently want "
+                             "to make the density depend on these fields. In this simple material "
+                             "model, we make the following assumptions: if no compositional fields "
+                             "are used in the current simulation, then the density is simply the usual "
+                             "one with its linear dependence on the temperature. If there are compositional "
+                             "fields, then the density only depends on the first one in such a way that "
+                             "the density has an additional term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
+                             "This parameter describes the value of $\\Delta \\rho$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
+          prm.declare_entry ("Phase transition density jumps", "",
+                             Patterns::List (Patterns::Double (0.)),
+                             "A list of density jumps at each phase transition. A positive value means "
+                             "that the density increases with depth. The corresponding entry in "
+                             "Corresponding phase for density jump determines if the density jump occurs "
+                             "in peridotite, eclogite or none of them."
+                             "List must have the same number of entries as Phase transition depths. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Corresponding phase for density jump", "",
+                             Patterns::List (Patterns::Integer(0)),
+                             "A list of phases, which correspond to the Phase transition density jumps. "
+                             "The density jumps occur only in the phase that is given by this phase value. "
+                             "0 stands for the 1st compositional fields, 1 for the second compositional field "
+                             "and -1 for none of them. "
+                             "List must have the same number of entries as Phase transition depths. "
+                             "Units: \\si{\\pascal\\per\\kelvin}.");
+          prm.declare_entry ("Viscosity prefactors", "",
+                             Patterns::List (Patterns::Double (0.)),
+                             "A list of prefactors for the viscosity for each phase. The reference "
+                             "viscosity will be multiplied by this factor to get the corresponding "
+                             "viscosity for each phase. "
+                             "List must have one more entry than Phase transition depths. "
+                             "Units: non-dimensional.");
+          prm.declare_entry ("Minimum viscosity", "1e19",
+                             Patterns::Double (0.),
+                             "Limit for the minimum viscosity in the model. "
+                             "Units: Pa \\, s.");
+          prm.declare_entry ("Maximum viscosity", "1e24",
+                             Patterns::Double (0.),
+                             "Limit for the maximum viscosity in the model. "
+                             "Units: Pa \\, s.");
+
+          MaterialUtilities::PhaseFunction<dim>::declare_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    LatentHeat<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Latent heat");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          reference_T                = prm.get_double ("Reference temperature");
+          eta                        = prm.get_double ("Viscosity");
+          composition_viscosity_prefactor = prm.get_double ("Composition viscosity prefactor");
+          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
+          k_value                    = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+          reference_compressibility  = prm.get_double ("Compressibility");
+          compositional_delta_rho    = prm.get_double ("Density differential for compositional field 1");
+          minimum_viscosity              = prm.get_double ("Minimum viscosity");
+          maximum_viscosity              = prm.get_double ("Maximum viscosity");
+
+          phase_function.initialize_simulator (this->get_simulator());
+          phase_function.parse_parameters (prm);
+
+          density_jumps = Utilities::string_to_double
+                          (Utilities::split_string_list(prm.get ("Phase transition density jumps")));
+          transition_phases = Utilities::string_to_int
+                              (Utilities::split_string_list(prm.get ("Corresponding phase for density jump")));
+          phase_prefactors = Utilities::string_to_double
+                             (Utilities::split_string_list(prm.get ("Viscosity prefactors")));
+
+          const unsigned int n_transitions = phase_function.n_phase_transitions();
+          if (density_jumps.size() != n_transitions ||
+              transition_phases.size() != n_transitions ||
+              phase_prefactors.size() != n_transitions+1)
+            AssertThrow(false, ExcMessage("Error: At least one list that provides input parameters for phase "
+                                          "transitions has the wrong size. The phase function object reports that "
+                                          "there are " + std::to_string(n_transitions) + " transitions, "
+                                          "therefore the material model expects " + std::to_string(n_transitions) +
+                                          " density jumps and corresponding phases, and "
+                                          + std::to_string(n_transitions+1) + " viscosity prefactors."));
+
+          // as the phase viscosity prefactors are all applied multiplicatively on top of each other,
+          // we have to scale them here so that they are relative factors in comparison to the product
+          // of the prefactors of all phase above the current one
+          for (unsigned int phase=1; phase<phase_prefactors.size(); ++phase)
+            {
+              phase_prefactors[phase] /= phase_prefactors[phase-1];
+            }
+
+          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
+            AssertThrow(false, ExcMessage("Error: Material model latent heat with Thermal viscosity exponent can not have reference_T=0."));
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(LatentHeat,
+                                   "latent heat",
+                                   "A material model that includes phase transitions "
+                                   "and the possibility that latent heat is released "
+                                   "or absorbed when material crosses one of the "
+                                   "phase transitions of up to two different materials "
+                                   "(compositional fields). "
+                                   "This model implements a standard approximation "
+                                   "of the latent heat terms following Christensen \\& Yuen, 1985 \\cite{christensen:yuen:1985}. "
+                                   "The change of entropy is calculated as "
+                                   "$\\Delta S = \\gamma \\frac{\\Delta\\rho}{\\rho^2}$ with the "
+                                   "Clapeyron slope $\\gamma$ and the density change $\\Delta\\rho$ "
+                                   "of the phase transition being input parameters. "
+                                   "The model employs an analytic phase function in the form "
+                                   "$X=\\frac{1}{2} \\left( 1 + \\tanh \\left( \\frac{\\Delta p}{\\Delta p_0} \\right) \\right)$ "
+                                   "with $\\Delta p = p - p_{\\text{transition}} - \\gamma \\left( T - T_{\\text{transition}} \\right)$ "
+                                   "and $\\Delta p_0$ being the pressure difference over the width "
+                                   "of the phase transition (specified as input parameter).")
+  }
+}
diff --git a/source/material_model/latent_heat_melt.cc.bak b/source/material_model/latent_heat_melt.cc.bak
new file mode 100644
index 00000000000..1cfab292052
--- /dev/null
+++ b/source/material_model/latent_heat_melt.cc.bak
@@ -0,0 +1,660 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/latent_heat_melt.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    LatentHeatMelt<dim>::
+
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+
+          out.entropy_derivative_pressure[i] = 0;
+          out.entropy_derivative_temperature[i] = 0;
+
+          for (unsigned int c=0; c < in.composition[i].size(); ++c )
+            {
+              out.reaction_terms[i][c]            = 0;
+            }
+
+          std::vector<double> composition = in.composition[i];
+
+          const double reference_temperature = (this->include_adiabatic_heating()
+                                                ?
+                                                this->get_adiabatic_conditions().temperature(in.position[i])
+                                                :
+                                                reference_T);
+
+          const double delta_temp = in.temperature[i] - reference_temperature;
+          const double T_dependence = ( thermal_viscosity_exponent == 0.0
+                                        ?
+                                        0.0
+                                        :
+                                        thermal_viscosity_exponent * delta_temp / reference_temperature );
+
+
+          double temperature_dependence = std::max (std::min ( std::exp( - T_dependence ), 1e2 ), 1e-2 );
+
+          if (std::isnan(temperature_dependence))
+            temperature_dependence = 1.0;
+
+          double composition_dependence = 1.0;
+          if ((composition_viscosity_prefactor != 1.0) && (composition.size() > 0))
+            {
+              //geometric interpolation
+              out.viscosities[i] = (pow (10, ( (1 - composition[0] ) * log10 ( eta * temperature_dependence )
+                                               + composition[0] * log10 ( eta * composition_viscosity_prefactor * temperature_dependence))));
+            }
+          else
+            {
+              out.viscosities[i] = composition_dependence * temperature_dependence * eta;
+            }
+
+          out.specific_heat[i] = reference_specific_heat;
+          out.thermal_conductivities[i] = k_value;
+          out.thermal_expansion_coefficients[i] = thermal_alpha;
+          out.compressibilities[i] = reference_compressibility;
+
+          temperature_dependence = 1.0;
+
+          if (this->include_adiabatic_heating ())
+            {
+              // temperature dependence is 1 - alpha * (T - T(adiabatic))
+              temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i])) * thermal_alpha;
+            }
+          else
+            {
+              temperature_dependence -= in.temperature[i] * thermal_alpha;
+            }
+          // second, calculate composition dependence of density
+          // constant density difference between peridotite and eclogite
+          composition_dependence = composition.size()>0
+                                   ?
+                                   compositional_delta_rho * composition[0]
+                                   :
+                                   0.0;
+
+          // third, pressure dependence of density
+          const double kappa = reference_compressibility;
+          const double pressure_dependence = reference_rho * kappa * (in.pressure[i] - this->get_surface_pressure());
+
+          // fourth, melt fraction dependence
+          double melt_dependence = (1.0 - relative_melt_density)
+                                   * melt_fraction(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
+
+          // in the end, all the influences are added up
+          out.densities[i] = (reference_rho + composition_dependence + pressure_dependence) * temperature_dependence
+                             * (1.0 - melt_dependence);
+
+
+          out.entropy_derivative_pressure[i] = entropy_derivative (in.temperature[i], in.pressure[i], composition,
+                                                                   in.position[i], NonlinearDependence::pressure) ; // for pressure dependence
+
+          out.entropy_derivative_temperature[i] = entropy_derivative (in.temperature[i], in.pressure[i], composition,
+                                                                      in.position[i], NonlinearDependence::temperature) ; // for temperature dependence
+
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    LatentHeatMelt<dim>::
+    entropy_derivative (const double temperature,
+                        const double pressure,
+                        const std::vector<double> &compositional_fields,
+                        const Point<dim> &position,
+                        const NonlinearDependence::Dependence dependence) const
+    {
+      double entropy_gradient = 0.0;
+
+      // calculate latent heat of melting
+      // we need the change of melt fraction in dependence of pressure and temperature
+
+      // for peridotite after Katz, 2003
+      const double T_solidus        = A1 + 273.15
+                                      + A2 * pressure
+                                      + A3 * pressure * pressure;
+      const double T_lherz_liquidus = B1 + 273.15
+                                      + B2 * pressure
+                                      + B3 * pressure * pressure;
+      const double T_liquidus       = C1 + 273.15
+                                      + C2 * pressure
+                                      + C3 * pressure * pressure;
+
+      const double dT_solidus_dp        = A2 + 2 * A3 * pressure;
+      const double dT_lherz_liquidus_dp = B2 + 2 * B3 * pressure;
+      const double dT_liquidus_dp       = C2 + 2 * C3 * pressure;
+
+      const double peridotite_fraction = (this->n_compositional_fields()>0
+                                          ?
+                                          1.0 - compositional_fields[0]
+                                          :
+                                          1.0);
+
+      if (temperature > T_solidus && temperature < T_liquidus && pressure < 1.3e10)
+        {
+          // melt fraction when clinopyroxene is still present
+          double melt_fraction_derivative_temperature
+            = beta * pow((temperature - T_solidus)/(T_lherz_liquidus - T_solidus),beta-1)
+              / (T_lherz_liquidus - T_solidus);
+
+          double melt_fraction_derivative_pressure
+            = beta * pow((temperature - T_solidus)/(T_lherz_liquidus - T_solidus),beta-1)
+              * (dT_solidus_dp * (temperature - T_lherz_liquidus)
+                 + dT_lherz_liquidus_dp * (T_solidus - temperature))
+              / pow(T_lherz_liquidus - T_solidus,2);
+
+          // melt fraction after melting of all clinopyroxene
+          const double R_cpx = r1 + r2 * pressure;
+          const double F_max = M_cpx / R_cpx;
+
+          if (peridotite_melt_fraction(temperature, pressure, compositional_fields, position) > F_max)
+            {
+              const double T_max = std::pow(F_max,1.0/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
+              const double dF_max_dp = - M_cpx * std::pow(r1 + r2 * pressure,-2) * r2;
+              const double dT_max_dp = dT_solidus_dp
+                                       + 1.0/beta * std::pow(F_max,1.0/beta - 1.0) * dF_max_dp * (T_lherz_liquidus - T_solidus)
+                                       + std::pow(F_max,1.0/beta) * (dT_lherz_liquidus_dp - dT_solidus_dp);
+
+              melt_fraction_derivative_temperature
+                = (1.0 - F_max) * beta * std::pow((temperature - T_max)/(T_liquidus - T_max),beta-1)
+                  / (T_liquidus - T_max);
+
+              melt_fraction_derivative_pressure
+                = dF_max_dp
+                  - dF_max_dp * std::pow((temperature - T_max)/(T_liquidus - T_max),beta)
+                  + (1.0 - F_max) * beta * std::pow((temperature - T_max)/(T_liquidus - T_max),beta-1)
+                  * (dT_max_dp * (T_max - T_liquidus) - (dT_liquidus_dp - dT_max_dp) * (temperature - T_max)) / std::pow(T_liquidus - T_max, 2);
+            }
+
+          double melt_fraction_derivative = 0;
+          if (dependence == NonlinearDependence::temperature)
+            melt_fraction_derivative = melt_fraction_derivative_temperature;
+          else if (dependence == NonlinearDependence::pressure)
+            melt_fraction_derivative = melt_fraction_derivative_pressure;
+          else
+            AssertThrow(false, ExcMessage("Error in calculating melt fraction derivative: not implemented"));
+
+          entropy_gradient += melt_fraction_derivative * peridotite_melting_entropy_change * peridotite_fraction;
+        }
+
+
+      // for melting of pyroxenite after Sobolev et al., 2011
+      if (this->n_compositional_fields()>0)
+        {
+          // calculate change of entropy for melting all material
+          const double X = pyroxenite_melt_fraction(temperature, pressure, compositional_fields, position);
+
+          // calculate change of melt fraction in dependence of pressure and temperature
+          const double T_melting = D1 + 273.15
+                                   + D2 * pressure
+                                   + D3 * pressure * pressure;
+          const double dT_melting_dp = 2*D3*pressure + D2;
+          const double discriminant = E1*E1/(E2*E2*4) + (temperature-T_melting)/E2;
+
+          double melt_fraction_derivative = 0.0;
+          if (temperature > T_melting && X < F_px_max && pressure < 1.3e10)
+            {
+              if (dependence == NonlinearDependence::temperature)
+                melt_fraction_derivative = -1.0/(2*E2 * sqrt(discriminant));
+              else if (dependence == NonlinearDependence::pressure)
+                melt_fraction_derivative = (dT_melting_dp)/(2*E2 * sqrt(discriminant));
+              else
+                AssertThrow(false, ExcMessage("Error in calculating melt fraction derivative: not implemented"));
+            }
+
+          entropy_gradient += melt_fraction_derivative * pyroxenite_melting_entropy_change * compositional_fields[0];
+        }
+
+      return entropy_gradient;
+    }
+
+
+    template <int dim>
+    void
+    LatentHeatMelt<dim>::
+    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                    std::vector<double> &melt_fractions) const
+    {
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
+        melt_fractions[q] = melt_fraction(in.temperature[q],
+                                          std::max(0.0, in.pressure[q]),
+                                          in.composition[q],
+                                          in.position[q]);
+    }
+
+    template <int dim>
+    double
+    LatentHeatMelt<dim>::
+    peridotite_melt_fraction (const double temperature,
+                              const double pressure,
+                              const std::vector<double> &,
+                              const Point<dim> &) const
+    {
+      // anhydrous melting of peridotite after Katz, 2003
+      const double T_solidus  = A1 + 273.15
+                                + A2 * pressure
+                                + A3 * pressure * pressure;
+      const double T_lherz_liquidus = B1 + 273.15
+                                      + B2 * pressure
+                                      + B3 * pressure * pressure;
+      const double T_liquidus = C1 + 273.15
+                                + C2 * pressure
+                                + C3 * pressure * pressure;
+
+      // melt fraction for peridotite with clinopyroxene
+      double peridotite_melt_fraction;
+      if (temperature < T_solidus || pressure > 1.3e10)
+        peridotite_melt_fraction = 0.0;
+      else if (temperature > T_lherz_liquidus)
+        peridotite_melt_fraction = 1.0;
+      else
+        peridotite_melt_fraction = std::pow((temperature - T_solidus) / (T_lherz_liquidus - T_solidus),beta);
+
+      // melt fraction after melting of all clinopyroxene
+      const double R_cpx = r1 + r2 * pressure;
+      const double F_max = M_cpx / R_cpx;
+
+      if (peridotite_melt_fraction > F_max && temperature < T_liquidus)
+        {
+          const double T_max = std::pow(F_max,1/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
+          peridotite_melt_fraction = F_max + (1 - F_max) * pow((temperature - T_max) / (T_liquidus - T_max),beta);
+        }
+      return peridotite_melt_fraction;
+
+    }
+
+    template <int dim>
+    double
+    LatentHeatMelt<dim>::
+    pyroxenite_melt_fraction (const double temperature,
+                              const double pressure,
+                              const std::vector<double> &,
+                              const Point<dim> &) const
+    {
+      // melting of pyroxenite after Sobolev et al., 2011
+      const double T_melting = D1 + 273.15
+                               + D2 * pressure
+                               + D3 * pressure * pressure;
+
+      const double discriminant = E1*E1/(E2*E2*4) + (temperature-T_melting)/E2;
+
+      double pyroxenite_melt_fraction;
+      if (temperature < T_melting || pressure > 1.3e10)
+        pyroxenite_melt_fraction = 0.0;
+      else if (discriminant < 0)
+        pyroxenite_melt_fraction = F_px_max;
+      else
+        pyroxenite_melt_fraction = -E1/(2*E2) - std::sqrt(discriminant);
+
+      return pyroxenite_melt_fraction;
+    }
+
+    template <int dim>
+    double
+    LatentHeatMelt<dim>::
+    melt_fraction (const double temperature,
+                   const double pressure,
+                   const std::vector<double> &composition, /*composition*/
+                   const Point<dim> &position) const
+    {
+      return (this->n_compositional_fields()>0
+              ?
+              pyroxenite_melt_fraction(temperature, pressure, composition, position)
+              * composition[0]
+              +
+              peridotite_melt_fraction(temperature, pressure, composition, position)
+              * (1.0 - composition[0])
+              :
+              peridotite_melt_fraction(temperature, pressure, composition, position));
+
+    }
+
+
+
+    template <int dim>
+    bool
+    LatentHeatMelt<dim>::
+    is_compressible () const
+    {
+      if (reference_compressibility > 0)
+        return true;
+      else
+        return false;
+    }
+
+
+
+    template <int dim>
+    void
+    LatentHeatMelt<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Latent heat melt");
+        {
+          prm.declare_entry ("Reference density", "3300.",
+                             Patterns::Double (0.),
+                             "Reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Viscosity", "5e24",
+                             Patterns::Double (0.),
+                             "The value of the constant viscosity. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Composition viscosity prefactor", "1.0",
+                             Patterns::Double (0.),
+                             "A linear dependency of viscosity on composition. Dimensionless prefactor.");
+          prm.declare_entry ("Thermal viscosity exponent", "0.0",
+                             Patterns::Double (0.),
+                             "The temperature dependence of viscosity. Dimensionless exponent.");
+          prm.declare_entry ("Thermal conductivity", "2.38",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250.",
+                             Patterns::Double (0.),
+                             "The value of the specific heat $C_p$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "4e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\alpha_s$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Thermal expansion coefficient of melt", "6.8e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\alpha_f$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Compressibility", "5.124e-12",
+                             Patterns::Double (0.),
+                             "The value of the compressibility $\\kappa$. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("Density differential for compositional field 1", "0.",
+                             Patterns::Double(),
+                             "If compositional fields are used, then one would frequently want "
+                             "to make the density depend on these fields. In this simple material "
+                             "model, we make the following assumptions: if no compositional fields "
+                             "are used in the current simulation, then the density is simply the usual "
+                             "one with its linear dependence on the temperature. If there are compositional "
+                             "fields, then the density only depends on the first one in such a way that "
+                             "the density has an additional term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
+                             "This parameter describes the value of $\\Delta \\rho$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
+          prm.declare_entry ("A1", "1085.7",
+                             Patterns::Double (),
+                             "Constant parameter in the quadratic "
+                             "function that approximates the solidus "
+                             "of peridotite. "
+                             "Units: \\si{\\degreeCelsius}.");
+          prm.declare_entry ("A2", "1.329e-7",
+                             Patterns::Double (),
+                             "Prefactor of the linear pressure term "
+                             "in the quadratic function that approximates "
+                             "the solidus of peridotite. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
+          prm.declare_entry ("A3", "-5.1e-18",
+                             Patterns::Double (),
+                             "Prefactor of the quadratic pressure term "
+                             "in the quadratic function that approximates "
+                             "the solidus of peridotite. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
+          prm.declare_entry ("B1", "1475.0",
+                             Patterns::Double (),
+                             "Constant parameter in the quadratic "
+                             "function that approximates the lherzolite "
+                             "liquidus used for calculating the fraction "
+                             "of peridotite-derived melt. "
+                             "Units: \\si{\\degreeCelsius}.");
+          prm.declare_entry ("B2", "8.0e-8",
+                             Patterns::Double (),
+                             "Prefactor of the linear pressure term "
+                             "in the quadratic function that approximates "
+                             "the  lherzolite liquidus used for "
+                             "calculating the fraction of peridotite-"
+                             "derived melt. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
+          prm.declare_entry ("B3", "-3.2e-18",
+                             Patterns::Double (),
+                             "Prefactor of the quadratic pressure term "
+                             "in the quadratic function that approximates "
+                             "the  lherzolite liquidus used for "
+                             "calculating the fraction of peridotite-"
+                             "derived melt. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
+          prm.declare_entry ("C1", "1780.0",
+                             Patterns::Double (),
+                             "Constant parameter in the quadratic "
+                             "function that approximates the liquidus "
+                             "of peridotite. "
+                             "Units: \\si{\\degreeCelsius}.");
+          prm.declare_entry ("C2", "4.50e-8",
+                             Patterns::Double (),
+                             "Prefactor of the linear pressure term "
+                             "in the quadratic function that approximates "
+                             "the liquidus of peridotite. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
+          prm.declare_entry ("C3", "-2.0e-18",
+                             Patterns::Double (),
+                             "Prefactor of the quadratic pressure term "
+                             "in the quadratic function that approximates "
+                             "the liquidus of peridotite. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
+          prm.declare_entry ("r1", "0.5",
+                             Patterns::Double (),
+                             "Constant in the linear function that "
+                             "approximates the clinopyroxene reaction "
+                             "coefficient. "
+                             "Units: non-dimensional.");
+          prm.declare_entry ("r2", "8e-11",
+                             Patterns::Double (),
+                             "Prefactor of the linear pressure term "
+                             "in the linear function that approximates "
+                             "the clinopyroxene reaction coefficient. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("beta", "1.5",
+                             Patterns::Double (),
+                             "Exponent of the melting temperature in "
+                             "the melt fraction calculation. "
+                             "Units: non-dimensional.");
+          prm.declare_entry ("Peridotite melting entropy change", "-300.",
+                             Patterns::Double (),
+                             "The entropy change for the phase transition "
+                             "from solid to melt of peridotite. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Mass fraction cpx", "0.15",
+                             Patterns::Double (),
+                             "Mass fraction of clinopyroxene in the "
+                             "peridotite to be molten. "
+                             "Units: non-dimensional.");
+          prm.declare_entry ("D1", "976.0",
+                             Patterns::Double (),
+                             "Constant parameter in the quadratic "
+                             "function that approximates the solidus "
+                             "of pyroxenite. "
+                             "Units: \\si{\\degreeCelsius}.");
+          prm.declare_entry ("D2", "1.329e-7",
+                             Patterns::Double (),
+                             "Prefactor of the linear pressure term "
+                             "in the quadratic function that approximates "
+                             "the solidus of pyroxenite. "
+                             "Note that this factor is different from the "
+                             "value given in Sobolev, 2011, because they use "
+                             "the potential temperature whereas we use the "
+                             "absolute temperature. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
+          prm.declare_entry ("D3", "-5.1e-18",
+                             Patterns::Double (),
+                             "Prefactor of the quadratic pressure term "
+                             "in the quadratic function that approximates "
+                             "the solidus of pyroxenite. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
+          prm.declare_entry ("E1", "663.8",
+                             Patterns::Double (),
+                             "Prefactor of the linear depletion term "
+                             "in the quadratic function that approximates "
+                             "the melt fraction of pyroxenite. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
+          prm.declare_entry ("E2", "-611.4",
+                             Patterns::Double (),
+                             "Prefactor of the quadratic depletion term "
+                             "in the quadratic function that approximates "
+                             "the melt fraction of pyroxenite. "
+                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
+          prm.declare_entry ("Pyroxenite melting entropy change", "-400.",
+                             Patterns::Double (),
+                             "The entropy change for the phase transition "
+                             "from solid to melt of pyroxenite. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Maximum pyroxenite melt fraction", "0.5429",
+                             Patterns::Double (),
+                             "Maximum melt fraction of pyroxenite "
+                             "in this parameterization. At higher "
+                             "temperatures peridotite begins to melt.");
+          prm.declare_entry ("Relative density of melt", "0.9",
+                             Patterns::Double (),
+                             "The relative density of melt compared to the "
+                             "solid material. This means, the density change "
+                             "upon melting is this parameter times the density "
+                             "of solid material."
+                             "Units: non-dimensional.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    LatentHeatMelt<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Latent heat melt");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          reference_T                = prm.get_double ("Reference temperature");
+          eta                        = prm.get_double ("Viscosity");
+          composition_viscosity_prefactor = prm.get_double ("Composition viscosity prefactor");
+          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
+          k_value                    = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+          melt_thermal_alpha         = prm.get_double ("Thermal expansion coefficient of melt");
+          reference_compressibility  = prm.get_double ("Compressibility");
+          compositional_delta_rho    = prm.get_double ("Density differential for compositional field 1");
+
+          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
+            AssertThrow(false, ExcMessage("Error: Material model latent heat with Thermal viscosity exponent can not have reference_T=0."));
+
+          A1              = prm.get_double ("A1");
+          A2              = prm.get_double ("A2");
+          A3              = prm.get_double ("A3");
+          B1              = prm.get_double ("B1");
+          B2              = prm.get_double ("B2");
+          B3              = prm.get_double ("B3");
+          C1              = prm.get_double ("C1");
+          C2              = prm.get_double ("C2");
+          C3              = prm.get_double ("C3");
+          r1              = prm.get_double ("r1");
+          r2              = prm.get_double ("r2");
+          beta            = prm.get_double ("beta");
+          peridotite_melting_entropy_change
+            = prm.get_double ("Peridotite melting entropy change");
+
+          M_cpx           = prm.get_double ("Mass fraction cpx");
+          D1              = prm.get_double ("D1");
+          D2              = prm.get_double ("D2");
+          D3              = prm.get_double ("D3");
+          E1              = prm.get_double ("E1");
+          E2              = prm.get_double ("E2");
+          pyroxenite_melting_entropy_change
+            = prm.get_double ("Pyroxenite melting entropy change");
+
+          F_px_max        = prm.get_double ("Maximum pyroxenite melt fraction");
+          relative_melt_density = prm.get_double ("Relative density of melt");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(LatentHeatMelt,
+                                   "latent heat melt",
+                                   "A material model that includes the latent heat of melting "
+                                   "for two materials: peridotite and pyroxenite. The melting model "
+                                   "for peridotite is taken from Katz et al., 2003 (A new "
+                                   "parameterization of hydrous mantle melting) and the one for "
+                                   "pyroxenite from Sobolev et al., 2011 (Linking mantle plumes, "
+                                   "large igneous provinces and environmental catastrophes). "
+                                   "The model assumes a constant entropy change for melting 100\\% "
+                                   "of the material, which can be specified in the input file. "
+                                   "The partial derivatives of entropy with respect to temperature "
+                                   "and pressure required for calculating the latent heat consumption "
+                                   "are then calculated as product of this constant entropy change, "
+                                   "and the respective derivative of the function the describes the "
+                                   "melt fraction. This is linearly averaged with respect to the "
+                                   "fractions of the two materials present. "
+                                   "If no compositional fields are specified in the input file, the "
+                                   "model assumes that the material is peridotite. If compositional "
+                                   "fields are specified, the model assumes that the first compositional "
+                                   "field is the fraction of pyroxenite and the rest of the material "
+                                   "is peridotite. "
+                                   "\n\n"
+                                   "Otherwise, this material model has a temperature- and pressure-"
+                                   "dependent density and viscosity and the density and thermal "
+                                   "expansivity depend on the melt fraction present. "
+                                   "It is possible to extent this model to include a melt fraction "
+                                   "dependence of all the material parameters by calling the "
+                                   "function melt_fraction in the calculation of the respective "
+                                   "parameter. "
+                                   "However, melt and solid move with the same velocity and "
+                                   "melt extraction is not taken into account (batch melting). ")
+  }
+}
diff --git a/source/material_model/melt_boukare.cc b/source/material_model/melt_boukare.cc
index 2e0b0ab91c2..4022c8161ae 100644
--- a/source/material_model/melt_boukare.cc
+++ b/source/material_model/melt_boukare.cc
@@ -508,7 +508,7 @@ namespace aspect
       const unsigned int n_endmembers = endmember_names.size();
       EndmemberProperties endmembers(n_endmembers);
 
-      for (unsigned int q=0; q<in.temperature.size(); ++q)
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
         {
           std::vector<double> endmember_mole_fractions_per_phase(n_endmembers);
 
@@ -627,7 +627,7 @@ namespace aspect
       const unsigned int n_endmembers = endmember_names.size();
       EndmemberProperties endmembers(n_endmembers);
 
-      for (unsigned int q=0; q<in.temperature.size(); ++q)
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
         {
           std::vector<double> endmember_mole_fractions_per_phase(n_endmembers);
           std::vector<double> endmember_mole_fractions_in_composite(n_endmembers);
diff --git a/source/material_model/melt_boukare.cc.bak b/source/material_model/melt_boukare.cc.bak
new file mode 100644
index 00000000000..2e0b0ab91c2
--- /dev/null
+++ b/source/material_model/melt_boukare.cc.bak
@@ -0,0 +1,1314 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/material_model/melt_boukare.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace
+    {
+      std::vector<std::string> make_boukare_additional_outputs_names()
+      {
+        std::vector<std::string> names;
+        names.emplace_back("bulk_composition");
+        names.emplace_back("molar_volatiles_in_melt");
+        return names;
+      }
+    }
+
+
+
+    template <int dim>
+    BoukareOutputs<dim>::BoukareOutputs (const unsigned int n_points)
+      :
+      NamedAdditionalMaterialOutputs<dim>(make_boukare_additional_outputs_names()),
+      bulk_composition(n_points, numbers::signaling_nan<double>()),
+      molar_volatiles_in_melt(n_points, numbers::signaling_nan<double>())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    BoukareOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      AssertIndexRange (idx, 2);
+      if (idx == 0)
+        return bulk_composition;
+      else
+        return molar_volatiles_in_melt;
+    }
+
+
+
+    template <int dim>
+    void
+    MeltBoukare<dim>::initialize()
+    {
+      // Compute parameters for the modified Tait equation of state for the different endmembers
+      // derived from the isothermal bulk modulus and its two first pressure derivatives.
+      // This corresponds to Equation 4 from Holland and Powell, 2011 (https://doi.org/10.1111/j.1525-1314.2010.00923.x).
+
+      const unsigned int n_endmembers = reference_bulk_moduli.size();
+
+      tait_parameters_a.resize(n_endmembers);
+      tait_parameters_b.resize(n_endmembers);
+      tait_parameters_c.resize(n_endmembers);
+
+      for (unsigned int i=0; i<n_endmembers; ++i)
+        {
+          tait_parameters_a[i] = (1. + bulk_modulus_pressure_derivatives[i]) /
+                                 (1. + bulk_modulus_pressure_derivatives[i] + reference_bulk_moduli[i] * bulk_modulus_second_pressure_derivatives[i]);
+          tait_parameters_b[i] = bulk_modulus_pressure_derivatives[i] / reference_bulk_moduli[i]
+                                 - bulk_modulus_second_pressure_derivatives[i] / (1. + bulk_modulus_pressure_derivatives[i]);
+          tait_parameters_c[i] = (1. + bulk_modulus_pressure_derivatives[i] + reference_bulk_moduli[i] * bulk_modulus_second_pressure_derivatives[i]) /
+                                 (std::pow(bulk_modulus_pressure_derivatives[i],2) + bulk_modulus_pressure_derivatives[i]
+                                  - reference_bulk_moduli[i] * bulk_modulus_second_pressure_derivatives[i]);
+        }
+
+      febdg_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "FeSiO3_bridgmanite"));
+      mgbdg_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "MgSiO3_bridgmanite"));
+      wus_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "FeO_periclase"));
+      per_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "MgO_periclase"));
+      femelt_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "FeO_melt"));
+      mgmelt_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "MgO_melt"));
+    }
+
+
+
+    template <int dim>
+    double
+    MeltBoukare<dim>::
+    reference_darcy_coefficient () const
+    {
+      // 0.01 = 1% melt
+      return reference_permeability * std::pow(0.01,3.0) / eta_f;
+    }
+
+    template <int dim>
+    bool
+    MeltBoukare<dim>::
+    is_compressible () const
+    {
+      return true;
+    }
+
+
+    template <int dim>
+    MeltBoukare<dim>::
+    EndmemberProperties::EndmemberProperties(const unsigned int n_endmembers)
+      :
+      volumes(n_endmembers, numbers::signaling_nan<double>()),
+      gibbs_energies(n_endmembers, numbers::signaling_nan<double>()),
+      entropies(n_endmembers, numbers::signaling_nan<double>()),
+      thermal_expansivities(n_endmembers, numbers::signaling_nan<double>()),
+      bulk_moduli(n_endmembers, numbers::signaling_nan<double>()),
+      heat_capacities(n_endmembers, numbers::signaling_nan<double>())
+    {}
+
+
+
+    template <int dim>
+    void
+    MeltBoukare<dim>::
+    fill_endmember_properties (const typename Interface<dim>::MaterialModelInputs &in,
+                               const unsigned int q,
+                               EndmemberProperties &properties) const
+    {
+      const double n_endmembers = properties.volumes.size();
+
+      for (unsigned int i=0; i<n_endmembers; ++i)
+        {
+          const double a = tait_parameters_a[i];
+          const double b = tait_parameters_b[i];
+          const double c = tait_parameters_c[i];
+
+          const double Pth = endmember_thermal_pressure(in.temperature[q], i) - endmember_thermal_pressure(reference_temperature, i);
+
+          const double heat_capacity_ratio = endmember_molar_heat_capacity(in.temperature[q], i)
+                                             / endmember_molar_heat_capacity(reference_temperature, i) ;
+
+          // Integrate the gibbs free energy along the isobaric path from (P_ref, T_ref) to (P_ref, T_final)
+          const double G_Pref_Tf = reference_enthalpies[i] + endmember_enthalpy_thermal_addition(in.temperature[q], i)
+                                   - in.temperature[q] * (reference_entropies[i] + endmember_entropy_thermal_addition(in.temperature[q], i));
+
+          // Integrate the gibbs free energy along the isothermal path from (P_ref, T_final) to (P_final, T_final)
+          long double intVdP = 0.;
+          long double dintVdpdT = 0.;
+
+          const double pressure = this->get_adiabatic_conditions().pressure(in.position[q]);
+
+          if (pressure != reference_pressure && pressure > 0.0)
+            {
+              intVdP = reference_volumes[i]
+                       * ((pressure - reference_pressure) * (1. - a)
+                          + (a * (std::pow((1. + b * (reference_pressure - Pth)), 1. - c) - std::pow((1. + b * (pressure - Pth)), 1. - c)) / (b * (c - 1.))));
+
+              const double prefactor = reference_volumes[i] * reference_thermal_expansivities[i] * reference_bulk_moduli[i] * a * heat_capacity_ratio;
+              dintVdpdT = prefactor * (std::pow(1. + b * (pressure - Pth), -c) - std::pow(1. + b * (reference_pressure - Pth), -c));
+            }
+
+          properties.gibbs_energies[i] = G_Pref_Tf + intVdP;
+          properties.entropies[i] =  reference_entropies[i] + endmember_entropy_thermal_addition(in.temperature[q], i) + dintVdpdT;
+          properties.volumes[i] = reference_volumes[i] * (1 - a * (1. - std::pow(1. + b * (pressure - Pth), -c)));
+
+          properties.bulk_moduli[i] = reference_bulk_moduli[i] * (1. + b * (pressure - Pth))
+                                      * (a + (1. - a) * std::pow(1. + b * (pressure - Pth), c));
+
+          const double C_V0 = endmember_molar_heat_capacity(reference_temperature, i);
+          const double C_V = endmember_molar_heat_capacity(in.temperature[q], i);
+          properties.thermal_expansivities[i] = reference_thermal_expansivities[i] * (C_V / C_V0) *
+                                                1. / ((1. + b * (pressure - Pth)) *
+                                                      (a + (1. - a) * std::pow(1 + b * (pressure - Pth), c)));
+
+          const double Cp_ref = reference_specific_heats[i] + specific_heat_linear_coefficients[i] * in.temperature[q]
+                                + specific_heat_second_coefficients[i] * std::pow(in.temperature[q], -2.)
+                                + specific_heat_third_coefficients[i] * std::pow(in.temperature[q], -0.5);
+
+          const long double dSdT0 = reference_volumes[i] * reference_bulk_moduli[i] * std::pow(heat_capacity_ratio * reference_thermal_expansivities[i], 2.0)
+                                    * (std::pow(1. + b * (pressure - Pth), -1.-c) - std::pow(1. + b * (reference_pressure - Pth), -1.- c));
+
+          const double relative_T = Einstein_temperatures[i] / in.temperature[q];
+          const double dSdT = dSdT0 + dintVdpdT * (1 - 2./relative_T + 2./(std::exp(relative_T) - 1.)) * relative_T/in.temperature[q];
+
+          properties.heat_capacities[i] = Cp_ref + in.temperature[q] * dSdT;
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    MeltBoukare<dim>::
+    endmember_thermal_energy (const double temperature,
+                              const unsigned int endmember_index) const
+    {
+      AssertThrow(temperature > 0.0,
+                  ExcMessage("The temperature has to be larger than 0, but it is "
+                             + std::to_string(temperature) + " for endmember " + std::to_string(endmember_index) + "."));
+
+      const double relative_T = Einstein_temperatures[endmember_index] / temperature;
+      const double energy = 3. * number_of_atoms[endmember_index] * constants::gas_constant * Einstein_temperatures[endmember_index]
+                            * (0.5 + 1. / (std::exp(relative_T) - 1.0));
+
+      return energy;
+    }
+
+
+
+    template <int dim>
+    double
+    MeltBoukare<dim>::
+    endmember_molar_heat_capacity (const double temperature,
+                                   const unsigned int endmember_index) const
+    {
+      AssertThrow(temperature > 0.0,
+                  ExcMessage("The temperature has to be larger than 0!"));
+
+      const double relative_T = Einstein_temperatures[endmember_index] / temperature;
+      const double heat_capacity = 3. * number_of_atoms[endmember_index] * constants::gas_constant * std::pow(relative_T, 2)
+                                   * std::exp(relative_T) / std::pow(std::exp(relative_T) - 1.0, 2);
+
+      return heat_capacity;
+    }
+
+
+
+    template <int dim>
+    double
+    MeltBoukare<dim>::
+    endmember_thermal_pressure (const double temperature,
+                                const unsigned int endmember_index) const
+    {
+      const double thermal_energy = endmember_thermal_energy(temperature, endmember_index);
+      const double heat_capacity = endmember_molar_heat_capacity(reference_temperature, endmember_index);
+      const double thermal_pressure = reference_thermal_expansivities[endmember_index] * reference_bulk_moduli[endmember_index] / heat_capacity * thermal_energy;
+
+      return thermal_pressure;
+    }
+
+
+
+    template <int dim>
+    double
+    MeltBoukare<dim>::
+    endmember_enthalpy_thermal_addition (const double temperature,
+                                         const unsigned int i) const
+    {
+      const double addition = reference_specific_heats[i] * temperature
+                              + 0.5 * specific_heat_linear_coefficients[i] * std::pow(temperature, 2.)
+                              - specific_heat_second_coefficients[i] / temperature
+                              + 2. * specific_heat_third_coefficients[i] * std::sqrt(temperature)
+                              - (reference_specific_heats[i] * reference_temperature
+                                 + 0.5 * specific_heat_linear_coefficients[i] * std::pow(reference_temperature, 2.)
+                                 - specific_heat_second_coefficients[i] / reference_temperature
+                                 + 2.0 * specific_heat_third_coefficients[i] * std::sqrt(reference_temperature));
+
+      return addition;
+    }
+
+
+
+    template <int dim>
+    double
+    MeltBoukare<dim>::
+    endmember_entropy_thermal_addition (const double temperature,
+                                        const unsigned int i) const
+    {
+      const double addition = reference_specific_heats[i] * std::log(temperature)
+                              + specific_heat_linear_coefficients[i] * temperature
+                              - 0.5 * specific_heat_second_coefficients[i] / std::pow(temperature, 2.)
+                              - 2.0 * specific_heat_third_coefficients[i] / std::sqrt(temperature)
+                              - (reference_specific_heats[i] * std::log(reference_temperature)
+                                 + specific_heat_linear_coefficients[i] * reference_temperature
+                                 - 0.5 * specific_heat_second_coefficients[i] / std::pow(reference_temperature, 2.)
+                                 - 2.0 * specific_heat_third_coefficients[i] / std::sqrt(reference_temperature));
+
+      return addition;
+    }
+
+
+
+    template <int dim>
+    void
+    MeltBoukare<dim>::
+    convert_composition_to_fraction_of_endmembers (const double temperature,
+                                                   const double molar_Fe_in_solid,
+                                                   const double molar_Fe_in_melt,
+                                                   const std::vector<double> &endmember_gibbs_energies,
+                                                   std::vector<double> &endmember_mole_fractions_per_phase,
+                                                   double &molar_bridgmanite_in_solid) const
+    {
+      const double x_FeO = molar_Fe_in_solid * molar_FeO_in_Fe_mantle_endmember;
+      const double x_MgO = (1. - molar_Fe_in_solid) * molar_MgO_in_Mg_mantle_endmember;
+      const double x_SiO2 = molar_Fe_in_solid * molar_SiO2_in_Fe_mantle_endmember + (1. - molar_Fe_in_solid) * molar_SiO2_in_Mg_mantle_endmember;
+
+      const double molar_fraction_FeO = x_FeO/(x_MgO + x_FeO);
+      const double molar_fraction_SiO2 = x_SiO2/(x_MgO + x_FeO);
+      molar_bridgmanite_in_solid = molar_fraction_SiO2;
+
+      const double gibbs_energy_of_reaction = endmember_gibbs_energies[mgbdg_idx] + endmember_gibbs_energies[wus_idx]
+                                              - endmember_gibbs_energies[febdg_idx] - endmember_gibbs_energies[per_idx];
+      const double partition_coefficient = std::exp(gibbs_energy_of_reaction / (constants::gas_constant * temperature));
+
+      // Solving equation 6 in Nakajima et al., 2012 for X_Fe_fp and X_Fe_pv
+      // Solved using the definition of the distribution coefficient to define X_Fe_fp as a function of X_Fe_pv
+
+      const double num_to_sqrt = -4. * molar_fraction_FeO * (partition_coefficient - 1.) * partition_coefficient * molar_fraction_SiO2
+                                 + std::pow(1. + (molar_fraction_FeO + molar_fraction_SiO2) * (partition_coefficient - 1.0), 2.);
+
+      endmember_mole_fractions_per_phase[febdg_idx] = (-1. + molar_fraction_FeO - (molar_fraction_FeO * partition_coefficient) + molar_fraction_SiO2 - (molar_fraction_SiO2 * partition_coefficient) + std::sqrt(num_to_sqrt)) /
+                                                      (2. * molar_fraction_SiO2 * (1. - partition_coefficient));
+
+      endmember_mole_fractions_per_phase[wus_idx] = endmember_mole_fractions_per_phase[febdg_idx] / (((1. - endmember_mole_fractions_per_phase[febdg_idx]) * partition_coefficient) + endmember_mole_fractions_per_phase[febdg_idx]);
+
+      endmember_mole_fractions_per_phase[mgbdg_idx] = 1.0 - endmember_mole_fractions_per_phase[febdg_idx];
+      endmember_mole_fractions_per_phase[per_idx] = 1.0 - endmember_mole_fractions_per_phase[wus_idx];
+
+      endmember_mole_fractions_per_phase[mgmelt_idx] = 1. - molar_Fe_in_melt;
+      endmember_mole_fractions_per_phase[femelt_idx] = molar_Fe_in_melt;
+
+      return;
+    }
+
+
+
+    template <int dim>
+    double
+    MeltBoukare<dim>::
+    compute_melt_molar_fraction (const double porosity,
+                                 const double bridgmanite_molar_fraction_in_solid,
+                                 EndmemberProperties &endmembers,
+                                 const std::vector<double> &endmember_mole_fractions_per_phase) const
+    {
+      double melt_molar_volume = 0.0;
+      double solid_molar_volume = 0.0;
+      for (unsigned int i=0; i<endmember_names.size(); ++i)
+        {
+          // We assume here that the first 2 endmembers are the (solid) bridgmanite endmembers,
+          // and the 3rd and 4th are the (solid) ferropericlase endmembers. The endmember_phase_fraction_in_solid
+          // variable therefore indicates the fraction of bridgmanite or ferropericlase in the solid
+          // (depending on which phase the endmember belongs to).
+          const double endmember_phase_fraction_in_solid = i<2 ? bridgmanite_molar_fraction_in_solid : 1.0 - bridgmanite_molar_fraction_in_solid;
+
+          if (endmember_states[i] == EndmemberState::melt)
+            melt_molar_volume += endmember_mole_fractions_per_phase[i] * endmembers.volumes[i];
+          else if (endmember_states[i] == EndmemberState::solid)
+            solid_molar_volume += endmember_phase_fraction_in_solid * endmember_mole_fractions_per_phase[i] * endmembers.volumes[i];
+          else
+            AssertThrow (false, ExcNotImplemented());
+        }
+
+      // The porosity needs to be between 0 and 1,
+      // but that may not always be the case, because it is advected using the finite element.
+      const double bounded_porosity = std::min(1.0, std::max(0.0, porosity));
+
+      double melt_molar_fraction = 0.0;
+      if (melt_molar_volume > 0.0)
+        {
+          const double n_moles_total = bounded_porosity / melt_molar_volume + (1.0 - bounded_porosity) / solid_molar_volume;
+          melt_molar_fraction = bounded_porosity / (melt_molar_volume * n_moles_total);
+        }
+
+      return melt_molar_fraction;
+    }
+
+
+
+    template <int dim>
+    double
+    MeltBoukare<dim>::
+    assert_update_is_within_0_and_1 (const double old_value,
+                                     const double change_of_value) const
+    {
+      if (old_value + change_of_value < 0.0)
+        {
+          AssertThrow (false, ExcMessage("Update below 0. Proposed update: " + std::to_string(old_value + change_of_value)));
+          return -old_value;
+        }
+      else if (old_value + change_of_value > 1.0)
+        {
+          AssertThrow (false, ExcMessage("Update above 1. Proposed update: " + std::to_string(old_value + change_of_value)));
+          return 1.0 - old_value;
+        }
+      else
+        return change_of_value;
+    }
+
+
+
+    template <int dim>
+    double
+    MeltBoukare<dim>::
+    melt_fraction (const double temperature,
+                   const double pressure,
+                   const double molar_composition_of_bulk,
+                   double &molar_volatiles_in_melt,
+                   double &new_molar_composition_of_solid,
+                   double &new_molar_composition_of_melt) const
+    {
+      if (temperature == 0.0)
+        return 0.0;
+
+      const double molar_volatiles_in_bulk = 1.e-4;
+      {
+        // after Phipps Morgan, Jason. "Thermodynamics of pressure release melting of a veined plum pudding mantle."
+        // Geochemistry, Geophysics, Geosystems 2.4 (2001).
+        // See also Appendix B of Dannberg et al., 2021. "The morphology, evolution and seismic visibility of partial
+        // melt at the core-mantle boundary: Implications for ULVZs".
+        const double P = pressure;                   // pressure in Pa
+        const double T = temperature;                // temperature in K
+        const double R = constants::gas_constant;    // Ideal Gas Constant
+
+        // Free Energy Change Delta_G due to melting as a function of temperature and pressure
+        const double dG_Fe_mantle = (Fe_mantle_melting_temperature - T) * Fe_mantle_melting_entropy
+                                    + (P - melting_reference_pressure) * Fe_mantle_melting_volume;
+        const double dG_Mg_mantle = (Mg_mantle_melting_temperature - T) * Mg_mantle_melting_entropy
+                                    + (P - melting_reference_pressure) * Mg_mantle_melting_volume;
+
+        // Equations (B.13) and (B.14) in Appendix B of Dannberg et al., 2021.
+        const double c_Fe_endmember = std::exp(dG_Fe_mantle/(Fe_number_of_moles*R*T));
+        const double c_Mg_endmember = std::exp(dG_Mg_mantle/(Mg_number_of_moles*R*T));
+
+        // Mole composition of the solid and liquid (corresponds to the molar fraction of X_Fe, the iron-bearing endmember).
+        // In addition to the Phipps Morgan model, we also include volatiles here.
+        // Equations (B.8) and (B.10) to (B.12) in Appendix B of Dannberg et al., 2021.
+        const double q0 = (c_Fe_endmember - c_Mg_endmember) * c_Fe_endmember/c_Mg_endmember;
+        const double q1 = c_Fe_endmember * (1. - 1./c_Mg_endmember) - molar_composition_of_bulk * (c_Fe_endmember - c_Mg_endmember)/c_Mg_endmember + molar_volatiles_in_bulk * (1. - c_Fe_endmember);
+        const double q2 = -molar_composition_of_bulk * (1. - 1./c_Mg_endmember);
+        const double molar_composition_of_melt = (-q1 + std::sqrt(q1*q1 - 4.*q0*q2))/(2.*q0);
+
+        const double T_Fe_mantle = dG_Fe_mantle / Fe_mantle_melting_entropy;
+        const double T_Mg_mantle = dG_Mg_mantle / Mg_mantle_melting_entropy;
+
+        double melt_molar_fraction;
+
+        if (molar_composition_of_bulk < std::numeric_limits<double>::min())
+          {
+            melt_molar_fraction = T_Mg_mantle < 0.0 ? 1.0 : molar_volatiles_in_bulk;
+            new_molar_composition_of_melt = 0.0;
+            new_molar_composition_of_solid = 0.0;
+          }
+        else if (molar_composition_of_melt <= molar_composition_of_bulk
+                 && std::min(T_Fe_mantle, T_Mg_mantle) < 0.0) // above the liquidus
+          {
+            melt_molar_fraction = 1.0;
+            new_molar_composition_of_melt = molar_composition_of_bulk;
+            new_molar_composition_of_solid = molar_composition_of_bulk;
+
+            molar_volatiles_in_melt = molar_volatiles_in_bulk;
+          }
+        else
+          {
+            // Equations (B.9) in Appendix B of Dannberg et al., 2021.
+            const double molar_composition_of_solid = molar_composition_of_melt * c_Fe_endmember;
+
+            new_molar_composition_of_solid = std::max(std::min(molar_composition_of_solid, molar_composition_of_bulk), 0.0);
+            new_molar_composition_of_melt = std::min(std::max(molar_composition_of_melt, molar_composition_of_bulk), 1.0);
+
+            if (std::abs(molar_composition_of_melt - molar_composition_of_solid) > std::numeric_limits<double>::min())
+              melt_molar_fraction = std::min(std::max((molar_composition_of_bulk - molar_composition_of_solid) / (molar_composition_of_melt - molar_composition_of_solid), 0.0), 1.0);
+            // If solid and melt composition are the same, there is no two-phase region.
+            // If we are not above the liquidus, we are below the solidus.
+            else
+              melt_molar_fraction = molar_volatiles_in_bulk;
+
+            if (molar_volatiles_in_bulk > 0.0 && std::abs(molar_composition_of_bulk - molar_composition_of_solid) > std::numeric_limits<double>::min())
+              molar_volatiles_in_melt = molar_volatiles_in_bulk*(molar_composition_of_melt - molar_composition_of_solid)/(molar_composition_of_bulk - molar_composition_of_solid);
+          }
+
+        return melt_molar_fraction;
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    MeltBoukare<dim>::
+    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                    std::vector<double> &melt_fractions) const
+    {
+      const unsigned int Fe_solid_idx = this->introspection().compositional_index_for_name("molar_Fe_in_solid");
+      unsigned int Fe_melt_idx = numbers::invalid_unsigned_int;
+      unsigned int porosity_idx = numbers::invalid_unsigned_int;
+
+      if (this->include_melt_transport())
+        {
+          Fe_melt_idx = this->introspection().compositional_index_for_name("molar_Fe_in_melt");
+          porosity_idx = this->introspection().compositional_index_for_name("porosity");
+        }
+
+      const unsigned int n_endmembers = endmember_names.size();
+      EndmemberProperties endmembers(n_endmembers);
+
+      for (unsigned int q=0; q<in.temperature.size(); ++q)
+        {
+          std::vector<double> endmember_mole_fractions_per_phase(n_endmembers);
+
+          fill_endmember_properties(in, q, endmembers);
+
+          // We need the compositions of all phases.
+          double solid_composition = in.composition[q][Fe_solid_idx];
+          double melt_composition = 0.0, melt_molar_fraction = 0.0;
+          double bridgmanite_molar_fraction_in_solid;
+
+          if (this->include_melt_transport())
+            melt_composition = in.composition[q][Fe_melt_idx];
+
+          convert_composition_to_fraction_of_endmembers(in.temperature[q],
+                                                        solid_composition,
+                                                        melt_composition,
+                                                        endmembers.gibbs_energies,
+                                                        endmember_mole_fractions_per_phase,
+                                                        bridgmanite_molar_fraction_in_solid);
+
+
+          if (this->include_melt_transport())
+            melt_molar_fraction = compute_melt_molar_fraction(in.composition[q][porosity_idx],
+                                                              bridgmanite_molar_fraction_in_solid,
+                                                              endmembers,
+                                                              endmember_mole_fractions_per_phase);
+
+          const double solid_molar_fraction = 1.0 - melt_molar_fraction;
+          const double bulk_composition = melt_composition * melt_molar_fraction + solid_composition * solid_molar_fraction;
+          double molar_volatiles_in_melt = 0.0;
+
+          const double eq_melt_molar_fraction = this->melt_fraction(in.temperature[q],
+                                                                    this->get_adiabatic_conditions().pressure(in.position[q]),
+                                                                    bulk_composition,
+                                                                    molar_volatiles_in_melt,
+                                                                    solid_composition,
+                                                                    melt_composition);
+
+          // We have to compute the endmember fractions again here because the porosity is now different.
+          convert_composition_to_fraction_of_endmembers(in.temperature[q],
+                                                        solid_composition,
+                                                        melt_composition,
+                                                        endmembers.gibbs_energies,
+                                                        endmember_mole_fractions_per_phase,
+                                                        bridgmanite_molar_fraction_in_solid);
+
+
+          // convert from melt molar fraction to porosity
+          const double solid_molar_volume = bridgmanite_molar_fraction_in_solid * endmember_mole_fractions_per_phase[febdg_idx] * endmembers.volumes[febdg_idx]
+                                            + bridgmanite_molar_fraction_in_solid * endmember_mole_fractions_per_phase[mgbdg_idx] * endmembers.volumes[mgbdg_idx]
+                                            + (1. - bridgmanite_molar_fraction_in_solid) * endmember_mole_fractions_per_phase[per_idx] * endmembers.volumes[per_idx]
+                                            + (1. - bridgmanite_molar_fraction_in_solid) * endmember_mole_fractions_per_phase[wus_idx] * endmembers.volumes[wus_idx];
+          const double melt_molar_volume = endmember_mole_fractions_per_phase[mgmelt_idx] * endmembers.volumes[mgmelt_idx]
+                                           + endmember_mole_fractions_per_phase[femelt_idx] * endmembers.volumes[femelt_idx];
+
+          melt_fractions[q] = eq_melt_molar_fraction * melt_molar_volume
+                              / (eq_melt_molar_fraction * melt_molar_volume + (1.0 - eq_melt_molar_fraction) * solid_molar_volume);
+        }
+      return;
+    }
+
+
+
+    template <int dim>
+    void
+    MeltBoukare<dim>::
+    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
+      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
+      BoukareOutputs<dim> *boukare_out = out.template get_additional_output<BoukareOutputs<dim>>();
+      EnthalpyOutputs<dim> *enthalpy_out = out.template get_additional_output<EnthalpyOutputs<dim>>();
+
+      const unsigned int Fe_solid_idx = this->introspection().compositional_index_for_name("molar_Fe_in_solid");
+      unsigned int Fe_melt_idx = numbers::invalid_unsigned_int;
+      unsigned int porosity_idx = numbers::invalid_unsigned_int;
+
+      if (this->include_melt_transport())
+        {
+          Fe_melt_idx = this->introspection().compositional_index_for_name("molar_Fe_in_melt");
+          porosity_idx = this->introspection().compositional_index_for_name("porosity");
+        }
+
+      // If the temperature or pressure are zero, this model does not work.
+      // This should only happen when setting the melt constraints before we have the initial temperature.
+      // In this case, just fill the permeabilities and fluid viscosities and return.
+      const unsigned int n_points = in.n_evaluation_points();
+      for (unsigned int q=0; q<n_points; ++q)
+        {
+          if (in.temperature[q] == 0.0)
+            {
+              if (melt_out != nullptr)
+                {
+                  for (unsigned int q=0; q<n_points; ++q)
+                    {
+                      const double porosity = std::max(in.composition[q][porosity_idx],0.0);
+                      melt_out->fluid_viscosities[q] = eta_f;
+                      melt_out->permeabilities[q] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+                    }
+                }
+              return;
+            }
+        }
+
+      // We need the reaction step here to conserve bulk composition.
+      double reaction_time_step_size = 1.0;
+      double reaction_fraction = 0.0;
+      if (this->simulator_is_past_initialization())
+        {
+          const unsigned int number_of_reaction_steps = std::max(static_cast<unsigned int>(this->get_timestep() / this->get_parameters().reaction_time_step),
+                                                                 std::max(this->get_parameters().reaction_steps_per_advection_step,1U));
+          reaction_time_step_size = this->get_timestep() / static_cast<double>(number_of_reaction_steps);
+          reaction_fraction = reaction_time_step_size / melting_time_scale;
+        }
+
+      const unsigned int n_endmembers = endmember_names.size();
+      EndmemberProperties endmembers(n_endmembers);
+
+      for (unsigned int q=0; q<in.temperature.size(); ++q)
+        {
+          std::vector<double> endmember_mole_fractions_per_phase(n_endmembers);
+          std::vector<double> endmember_mole_fractions_in_composite(n_endmembers);
+
+          fill_endmember_properties(in, q, endmembers);
+
+          // We need the compositions of all phases.
+          const double solid_composition = in.composition[q][Fe_solid_idx];
+          double melt_composition = 0.0;
+          double melt_molar_fraction = 0.0;
+          double bridgmanite_molar_fraction_in_solid;
+
+          if (this->include_melt_transport())
+            melt_composition = in.composition[q][Fe_melt_idx];
+
+          convert_composition_to_fraction_of_endmembers(in.temperature[q],
+                                                        solid_composition,
+                                                        melt_composition,
+                                                        endmembers.gibbs_energies,
+                                                        endmember_mole_fractions_per_phase,
+                                                        bridgmanite_molar_fraction_in_solid);
+
+          if (this->include_melt_transport())
+            melt_molar_fraction = compute_melt_molar_fraction(in.composition[q][porosity_idx],
+                                                              bridgmanite_molar_fraction_in_solid,
+                                                              endmembers,
+                                                              endmember_mole_fractions_per_phase);
+
+          const double solid_molar_fraction = 1.0 - melt_molar_fraction;
+
+          // Compute endmember molar fractions in the composite.
+          std::vector<double> phase_mole_fractions_in_composite(n_endmembers);
+          double solid_molar_mass = 0.0;
+          double melt_molar_mass = 0.0;
+          double melt_molar_volume = 0.0;
+          double solid_molar_volume = 0.0;
+
+          for (unsigned int i=0; i<n_endmembers; ++i)
+            {
+              // We assume here that the first 2 endmembers are the (solid) bridgmanite endmembers,
+              // and the 3rd and 4th are the (solid) ferropericlase endmembers. The endmember_phase_fraction_in_solid
+              // variable therefore indicates the fraction of bridgmanite or ferropericlase in the solid
+              // (depending on which phase the endmember belongs to).
+              // TODO: allow for more flexibility by letting the user set a phase vector in the input file
+              // (then we can check if phase == 'bridgmanite').
+              const double endmember_phase_fraction_in_solid = i<2 ? bridgmanite_molar_fraction_in_solid : (1.0 - bridgmanite_molar_fraction_in_solid);
+
+              if (endmember_states[i] == EndmemberState::solid)
+                {
+                  // There are two phases in the solid (bridgmanite and ferropericlase). The mole fraction of each
+                  // phase in the composite is the product of the solid fraction in the composite and the fraction
+                  // of that individual phase in the solid.
+                  phase_mole_fractions_in_composite[i] = solid_molar_fraction * endmember_phase_fraction_in_solid;
+                  endmember_mole_fractions_in_composite[i] = phase_mole_fractions_in_composite[i] * endmember_mole_fractions_per_phase[i];
+                  solid_molar_mass += endmember_mole_fractions_in_composite[i] * molar_masses[i];
+                  solid_molar_volume += endmember_mole_fractions_in_composite[i] * endmembers.volumes[i];
+                }
+              else if (endmember_states[i] == EndmemberState::melt)
+                {
+                  // There is only one phase in the melt, so the mole fraction of that phase equals the melt fraction.
+                  phase_mole_fractions_in_composite[i] = melt_molar_fraction;
+                  endmember_mole_fractions_in_composite[i] = phase_mole_fractions_in_composite[i] * endmember_mole_fractions_per_phase[i];
+                  melt_molar_mass += endmember_mole_fractions_in_composite[i] * molar_masses[i];
+                  melt_molar_volume += endmember_mole_fractions_in_composite[i] * endmembers.volumes[i];
+                }
+              else
+                AssertThrow (false, ExcNotImplemented());
+            }
+
+          const double total_molar_mass = melt_molar_mass + solid_molar_mass;
+          const double total_volume = melt_molar_volume + solid_molar_volume;
+
+          out.thermal_expansion_coefficients[q] = 0.0;
+          out.specific_heat[q] = 0.0;
+          out.compressibilities[q] = 0.0;
+
+          // Average the individual endmember properties
+          for (unsigned int i=0; i<n_endmembers; ++i)
+            {
+              out.thermal_expansion_coefficients[q] += (endmember_mole_fractions_in_composite[i] * endmembers.volumes[i] * endmembers.thermal_expansivities[i]) / total_volume;
+              out.specific_heat[q] += endmember_mole_fractions_in_composite[i] * endmembers.heat_capacities[i] / total_molar_mass;
+
+
+              if (endmember_states[i] == EndmemberState::solid && solid_molar_volume > 0.0)
+                {
+                  out.compressibilities[q] += (endmember_mole_fractions_in_composite[i] * endmembers.volumes[i])
+                                              / (solid_molar_volume * endmembers.bulk_moduli[i]);
+                }
+            }
+
+          if (solid_molar_volume > 0.0)
+            out.densities[q] = solid_molar_mass / solid_molar_volume;
+          else
+            out.densities[q] = melt_molar_mass / melt_molar_volume;
+
+          if (melt_out != nullptr)
+            {
+              double melt_compressiblity = 0.0;
+              for (unsigned int i=0; i<n_endmembers; ++i)
+                if (endmember_states[i] == EndmemberState::melt && melt_molar_volume > 0.0)
+                  melt_compressiblity += (endmember_mole_fractions_in_composite[i] * endmembers.volumes[i]) / (melt_molar_volume * endmembers.bulk_moduli[i]);
+
+              if (melt_molar_volume > 0.0)
+                melt_out->fluid_densities[q] = melt_molar_mass / melt_molar_volume;
+              else
+                {
+                  // make sure we have a useful melt density even if there is no melt to avoid density jumps
+                  double mass = 0.0;
+                  double volume = 0.0;
+                  for (unsigned int i=0; i<n_endmembers; ++i)
+                    if (endmember_states[i] == EndmemberState::melt)
+                      {
+                        mass += endmember_mole_fractions_per_phase[i] * molar_masses[i];
+                        volume += endmember_mole_fractions_per_phase[i] * endmembers.volumes[i];
+                      }
+                  melt_out->fluid_densities[q] = mass/volume;
+                }
+
+              // This does not take into account the volume change due to thermal expansion of melt
+              melt_out->fluid_density_gradients[q] = melt_out->fluid_densities[q] * melt_out->fluid_densities[q]
+                                                     * melt_compressiblity
+                                                     * this->get_gravity_model().gravity_vector(in.position[q]);
+            }
+
+
+          if (this->include_melt_transport())
+            {
+              // TODO: Alternatively, this could also be done by summing over endmember_mole_fractions_in_composite
+              const double old_porosity = in.composition[q][porosity_idx];
+              const double old_solid_composition = in.composition[q][Fe_solid_idx];
+              const double old_melt_composition = in.composition[q][Fe_melt_idx];
+              const double old_melt_molar_fraction = melt_molar_fraction;
+
+              // in this simple model, the bulk composition is just one number, namely
+              // the molar fraction of the combined iron endmembers
+              const double bulk_composition = old_melt_composition * melt_molar_fraction + old_solid_composition * solid_molar_fraction;
+              double molar_volatiles_in_melt = 0.0;
+              double solid_composition, melt_composition;
+
+              // calculate the melting rate as difference between the equilibrium melt fraction
+              // and the solution of the previous time step, and also update melt and solid composition
+              melt_molar_fraction = melt_fraction(in.temperature[q],
+                                                  this->get_adiabatic_conditions().pressure(in.position[q]),
+                                                  bulk_composition,
+                                                  molar_volatiles_in_melt,
+                                                  solid_composition,
+                                                  melt_composition);
+
+              if (boukare_out != nullptr)
+                {
+                  boukare_out->bulk_composition[q] = bulk_composition;
+                  boukare_out->molar_volatiles_in_melt[q] = molar_volatiles_in_melt;
+                }
+
+              // We have to compute the update to the melt fraction in such a way that the bulk composition is conserved.
+              const double change_of_melt_composition = reaction_fraction * assert_update_is_within_0_and_1(old_melt_composition, melt_composition - old_melt_composition);
+              const double change_of_melt_fraction = reaction_fraction * assert_update_is_within_0_and_1(old_melt_molar_fraction, melt_molar_fraction - old_melt_molar_fraction);
+
+              melt_composition = old_melt_composition + change_of_melt_composition;
+              melt_molar_fraction = old_melt_molar_fraction + change_of_melt_fraction;
+
+              if (melt_molar_fraction > 0.0 && melt_molar_fraction < 1.0)
+                solid_composition = (bulk_composition - melt_molar_fraction * melt_composition)
+                                    / (1.0 - melt_molar_fraction);
+              const double change_of_solid_composition = solid_composition - old_solid_composition;
+
+
+              // We have to compute the endmember fractions again here because the porosity is now different.
+              convert_composition_to_fraction_of_endmembers(in.temperature[q],
+                                                            solid_composition,
+                                                            melt_composition,
+                                                            endmembers.gibbs_energies,
+                                                            endmember_mole_fractions_per_phase,
+                                                            bridgmanite_molar_fraction_in_solid);
+
+
+              // convert from melt molar fraction to porosity
+              const double solid_molar_volume = bridgmanite_molar_fraction_in_solid * endmember_mole_fractions_per_phase[febdg_idx] * endmembers.volumes[febdg_idx]
+                                                + bridgmanite_molar_fraction_in_solid * endmember_mole_fractions_per_phase[mgbdg_idx] * endmembers.volumes[mgbdg_idx]
+                                                + (1. - bridgmanite_molar_fraction_in_solid) * endmember_mole_fractions_per_phase[per_idx] * endmembers.volumes[per_idx]
+                                                + (1. - bridgmanite_molar_fraction_in_solid) * endmember_mole_fractions_per_phase[wus_idx] * endmembers.volumes[wus_idx];
+              const double melt_molar_volume = endmember_mole_fractions_per_phase[mgmelt_idx] * endmembers.volumes[mgmelt_idx]
+                                               + endmember_mole_fractions_per_phase[femelt_idx] * endmembers.volumes[femelt_idx];
+
+              const double new_porosity = melt_molar_fraction * melt_molar_volume
+                                          / (melt_molar_fraction * melt_molar_volume + (1.0 - melt_molar_fraction) * solid_molar_volume);
+              const double porosity_change = new_porosity - old_porosity;
+
+              // For this simple model, we only track the iron in the solid (bridgmanite) and the iron in the melt
+              for (unsigned int c=0; c<in.composition[q].size(); ++c)
+                {
+                  // fill reaction rate outputs
+                  if (reaction_rate_out != nullptr)
+                    {
+                      if (!include_melting_and_freezing)
+                        reaction_rate_out->reaction_rates[q][c] = 0.0;
+                      else if (c == Fe_solid_idx && this->get_timestep_number() > 0)
+                        reaction_rate_out->reaction_rates[q][c] = change_of_solid_composition / reaction_time_step_size;
+                      else if (c == Fe_melt_idx && this->get_timestep_number() > 0)
+                        reaction_rate_out->reaction_rates[q][c] = change_of_melt_composition / reaction_time_step_size;
+                      else if (c == porosity_idx && this->get_timestep_number() > 0)
+                        reaction_rate_out->reaction_rates[q][c] = porosity_change / reaction_time_step_size;
+                      else
+                        reaction_rate_out->reaction_rates[q][c] = 0.0;
+                    }
+                  out.reaction_terms[q][c] = 0.0;
+                }
+
+              if (enthalpy_out != nullptr)
+                {
+                  const double melt_molar_mass = endmember_mole_fractions_per_phase[mgmelt_idx] * molar_masses[mgmelt_idx]
+                                                 + endmember_mole_fractions_per_phase[femelt_idx] * molar_masses[femelt_idx];
+                  const double Fe_enthalpy_of_fusion = Fe_mantle_melting_temperature * Fe_mantle_melting_entropy
+                                                       + (this->get_adiabatic_conditions().pressure(in.position[q]) - melting_reference_pressure) * Fe_mantle_melting_volume;
+                  const double Mg_enthalpy_of_fusion = Mg_mantle_melting_temperature * Mg_mantle_melting_entropy
+                                                       + (this->get_adiabatic_conditions().pressure(in.position[q]) - melting_reference_pressure) * Mg_mantle_melting_volume;
+                  double enthalpy_of_fusion = Fe_enthalpy_of_fusion * bulk_composition + Mg_enthalpy_of_fusion * (1.0-bulk_composition);
+                  enthalpy_of_fusion /= melt_molar_mass;
+
+                  enthalpy_out->enthalpies_of_fusion[q] = enthalpy_of_fusion;
+                }
+
+              // cutoff for viscosity at 30%
+              const double porosity = std::min(0.3, std::max(in.composition[q][porosity_idx],0.0));
+              out.viscosities[q] = (1.0 - porosity) * eta_0 * std::exp(- alpha_phi * porosity);
+            }
+          else
+            {
+              out.viscosities[q] = eta_0;
+
+              // no melting/freezing is used in the model --> set all reactions to zero
+              for (unsigned int c=0; c<in.composition[q].size(); ++c)
+                {
+                  if (reaction_rate_out != nullptr)
+                    reaction_rate_out->reaction_rates[q][c] = 0.0;
+                }
+            }
+
+          out.entropy_derivative_pressure[q]    = 0.0;
+          out.entropy_derivative_temperature[q] = 0.0;
+          out.thermal_conductivities[q] = thermal_conductivity;
+
+          for (unsigned int c=0; c<in.composition[q].size(); ++c)
+            out.reaction_terms[q][c] = 0.0;
+
+          const double delta_temp = in.temperature[q]-this->get_adiabatic_conditions().temperature(in.position[q]);
+          const double viscosity_bound = 1.e8;
+          const double visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[q])),viscosity_bound),1./viscosity_bound);
+          out.viscosities[q] *= visc_temperature_dependence;
+        }
+
+      // fill melt outputs if they exist
+      if (melt_out != nullptr)
+        {
+          const unsigned int n_points = in.n_evaluation_points();
+          for (unsigned int q=0; q<n_points; ++q)
+            {
+              double porosity = std::max(in.composition[q][porosity_idx],0.0);
+
+              melt_out->fluid_viscosities[q] = eta_f;
+              melt_out->permeabilities[q] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+
+              // limit porosity to disaggregation threshold
+              porosity = std::min(0.3, porosity);
+
+              const double porosity_threshold = 0.01 * std::pow(this->get_melt_handler().melt_parameters.melt_scaling_factor_threshold, 1./3.);
+              melt_out->compaction_viscosities[q] = (1.0 - porosity) * xi_0 / std::max(porosity, porosity_threshold);
+
+              const double delta_temp = in.temperature[q]-this->get_adiabatic_conditions().temperature(in.position[q]);
+              const double compaction_viscosity_bound = 1.e4;
+              const double visc_temperature_dependence = std::max(std::min(std::exp(-thermal_bulk_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[q])),compaction_viscosity_bound),1./compaction_viscosity_bound);
+
+              melt_out->compaction_viscosities[q] *= visc_temperature_dependence;
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    MeltBoukare<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Melt boukare");
+        {
+          prm.declare_entry ("Reference shear viscosity", "5e20",
+                             Patterns::Double (0),
+                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
+                             "This viscosity may be modified by both temperature and porosity "
+                             "dependencies. Units: $Pa \\, s$.");
+          prm.declare_entry ("Reference bulk viscosity", "1e22",
+                             Patterns::Double (0),
+                             "The value of the constant bulk viscosity $\\xi_0$ of the solid matrix. "
+                             "This viscosity may be modified by both temperature and porosity "
+                             "dependencies. Units: $Pa \\, s$.");
+          prm.declare_entry ("Reference melt viscosity", "10",
+                             Patterns::Double (0),
+                             "The value of the constant melt viscosity $\\eta_f$. Units: $Pa \\, s$.");
+          prm.declare_entry ("Exponential melt weakening factor", "27",
+                             Patterns::Double (),
+                             "The porosity dependence of the viscosity. Units: dimensionless.");
+          prm.declare_entry ("Thermal viscosity exponent", "0.0",
+                             Patterns::Double (0),
+                             "The temperature dependence of the shear viscosity. Dimensionless exponent. "
+                             "See the general documentation "
+                             "of this model for a formula that states the dependence of the "
+                             "viscosity on this factor, which is called $\\beta$ there.");
+          prm.declare_entry ("Thermal bulk viscosity exponent", "0.0",
+                             Patterns::Double (0),
+                             "The temperature dependence of the bulk viscosity. Dimensionless exponent. "
+                             "See the general documentation "
+                             "of this model for a formula that states the dependence of the "
+                             "viscosity on this factor, which is called $\\beta$ there.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: $W/m/K$.");
+          prm.declare_entry ("Reference permeability", "1e-8",
+                             Patterns::Double(),
+                             "Reference permeability of the solid host rock."
+                             "Units: $m^2$.");
+          prm.declare_entry ("Include melting and freezing", "true",
+                             Patterns::Bool (),
+                             "Whether to include melting and freezing (according to a simplified "
+                             "linear melting approximation in the model (if true), or not (if "
+                             "false).");
+          prm.declare_entry ("Melting time scale for operator splitting", "1e3",
+                             Patterns::Double (0),
+                             "In case the operator splitting scheme is used, the porosity field can not "
+                             "be set to a new equilibrium melt fraction instantly, but the model has to "
+                             "provide a melting time scale instead. This time scale defines how fast melting "
+                             "happens, or more specifically, the parameter defines the time after which "
+                             "the deviation of the porosity from the equilibrium melt fraction will be "
+                             "reduced to a fraction of $1/e$. So if the melting time scale is small compared "
+                             "to the time step size, the reaction will be so fast that the porosity is very "
+                             "close to the equilibrium melt fraction after reactions are computed. Conversely, "
+                             "if the melting time scale is large compared to the time step size, almost no "
+                             "melting and freezing will occur."
+                             "\n\n"
+                             "Also note that the melting time scale has to be larger than or equal to the reaction "
+                             "time step used in the operator splitting scheme, otherwise reactions can not be "
+                             "computed. If the model does not use operator splitting, this parameter is not used. "
+                             "Units: yr or s, depending on the ``Use years "
+                             "in output instead of seconds'' parameter.");
+          prm.declare_entry ("Fe mantle melting temperature", "3424.5",
+                             Patterns::Double(),
+                             "The melting temperature of one of the components in the melting "
+                             "model, the Fe mantle endmember."
+                             "Units: K.");
+          prm.declare_entry ("Mg mantle melting temperature", "4821.2",
+                             Patterns::Double(),
+                             "The melting temperature of one of the components in the melting "
+                             "model, the Mg mantle endmember."
+                             "Units: K.");
+          prm.declare_entry ("Fe number of moles", "0.48",
+                             Patterns::Double(),
+                             "The number of moles of Fe atoms mixing on a pseudosite in the "
+                             "mantle lattice, This is needed because we use an empirical model "
+                             "fitting the full Boukare model, and can be changed to reflect "
+                             "partition coefficients from other sources."
+                             "Units: none.");
+          prm.declare_entry ("Mg number of moles", "0.62",
+                             Patterns::Double(),
+                             "The number of moles of Mg atoms mixing on a pseudosite in the "
+                             "mantle lattice, This is needed because we use an empirical model "
+                             "fitting the full Boukare model, and can be changed to reflect "
+                             "partition coefficients from other sources."
+                             "Units: none.");
+          prm.declare_entry ("Reference temperature", "298.15",
+                             Patterns::Double(),
+                             "Reference temperature used to compute the material properties"
+                             "of the different endmember components."
+                             "Units: K.");
+          prm.declare_entry ("Reference pressure", "1e11",
+                             Patterns::Double(),
+                             "Reference pressure used to compute the material properties"
+                             "of the different endmember components."
+                             "Units: Pa.");
+
+          prm.declare_entry ("Endmember names", "FeSiO3_bridgmanite, MgSiO3_bridgmanite, FeO_periclase, MgO_periclase, FeO_melt, MgO_melt, SiO2_melt",
+                             Patterns::List(Patterns::MultipleSelection("MgSiO3_bridgmanite|FeSiO3_bridgmanite|MgO_periclase|FeO_periclase|MgO_melt|FeO_melt|SiO2_melt")),
+                             "Names of the endmember components used in the equation of state and the melting model, "
+                             "and whose parameters are determined by the other input parameters of this material model. "
+                             "The order the parameters are given in has to be the same as the order the endmember names "
+                             "are given in. "
+                             "Units: none.");
+          prm.declare_entry ("Endmember states", "solid, solid, solid, solid, melt, melt, melt",
+                             Patterns::List(Patterns::MultipleSelection("solid|melt")),
+                             "States of the endmember components used in the equation of state and the melting model. "
+                             "For each endmember, this list has to define if they belong to the melt or to the solid. "
+                             "The order the states are given in has to be the same as the order the 'Endmember names' "
+                             "are given in. "
+                             "Units: none.");
+
+          prm.declare_entry ("Molar masses", "0.1319287, 0.1003887, 0.0718444, 0.0403044, 0.0707624708, 0.048592178, 0.048592178",
+                             Patterns::List(Patterns::Double(0)),
+                             "Molar masses of the different endmembers"
+                             "Units: kg/mol.");
+          prm.declare_entry ("Number of atoms", "5.0, 5.0, 2.0, 2.0, 2.092, 2.419, 2.419",
+                             Patterns::List(Patterns::Double(0)),
+                             "Number of atoms per in the formula of each endmember."
+                             "Units: none.");
+          prm.declare_entry ("Reference volumes", "2.534e-05, 2.445e-05, 1.206e-05, 1.125e-05, 1.2325484447664221e-05, 1.218e-05, 1.218e-05",
+                             Patterns::List(Patterns::Double(0)),
+                             "Reference volumes of the different endmembers."
+                             "Units: $m^3$.");
+          prm.declare_entry ("Reference thermal expansivities", "1.87e-05, 1.87e-05, 3.22e-05, 3.11e-05, 2.9614332469401705e-05, 2.06e-05, 2.06e-05",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of thermal expansivities for each different endmember at the reference temperature "
+                             "and reference pressure."
+                             "Units: 1/K.");
+          prm.declare_entry ("Reference bulk moduli", "2.81e11, 2.51e+11, 1.52e11, 1.616e11, 166652774642.11273, 2.317e11, 2.317e11",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of bulk moduli for each different endmember at the reference temperature "
+                             "and reference pressure."
+                             "Units: Pa.");
+          prm.declare_entry ("First derivatives of the bulk modulus", "4.14, 4.14, 4.9, 3.95, 5.0802472229003905, 4.25, 4.25",
+                             Patterns::List(Patterns::Double()),
+                             "The pressure derivative of the bulk modulus at the reference temperature and reference "
+                             "pressure for each different endmember component."
+                             "Units: none.");
+          prm.declare_entry ("Second derivatives of the bulk modulus", "-1.6e-11, -1.6e-11, -3.2e-11, -2.4e-11, -3.9742163085937504e-11, -2.14e-11, -2.14e-11",
+                             Patterns::List(Patterns::Double()),
+                             "The second pressure derivative of the bulk modulus at the reference temperature and reference "
+                             "pressure for each different endmember component."
+                             "Units: 1/Pa.");
+          prm.declare_entry ("Einstein temperatures", "418.1, 561.0, 297.6, 540.2, 505.75, 558.1, 558.1",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of Einstein temperatures for each different endmember."
+                             "Units: K.");
+          prm.declare_entry ("Reference enthalpies", "-1082910.0, -1442310.0, -262240.0, -601570.0, -195245.49100022088, -538009.8, -538009.8",
+                             Patterns::List(Patterns::Double()),
+                             "List of enthalpies at the reference temperature and reference "
+                             "pressure for each different endmember component."
+                             "Units: J/mol.");
+          prm.declare_entry ("Reference entropies", "95.0, 62.6, 58.6, 26.5, 95.0299295525918, 64.9, 64.9",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of entropies at the reference temperature and reference "
+                             "pressure for each different endmember component."
+                             "Units: J/K/mol.");
+          prm.declare_entry ("Reference specific heat capacities", "139.546209, 161.546581, 52.0016403, 73.1147154, 79.5326013, 79.5326013, 79.5326013",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of specific heat capacities for each different endmember at the reference temperature "
+                             "and reference pressure."
+                             "Units: J/kg/K.");
+          prm.declare_entry ("Linear coefficients for specific heat polynomial", "6.36191292e-03, -3.31714290e-03, 3.36163516e-03, -6.35318887e-03, -2.41909947e-03, -2.41909947e-03, -2.41909947e-03",
+                             Patterns::List(Patterns::Double()),
+                             "The first of three coefficients that are used to compute the specific heat capacities for each "
+                             "different endmember at the reference temperature and reference pressure. "
+                             "This coefficient describes the linear part of the temperature dependence. "
+                             "Units: J/kg/K/K.");
+          prm.declare_entry ("Second coefficients for specific heat polynomial", "-4.13886524e+06, -3.57533814e+06, -1.19540964e+06, -7.33679285e+05, -1.61692272e+06, -1.61692272e+06, -1.61692272e+06",
+                             Patterns::List(Patterns::Double()),
+                             "The second of three coefficients that are used to compute the specific heat capacities for each "
+                             "different endmember at the reference temperature and reference pressure. This coefficient describes "
+                             "the part of the temperature dependence that scales as the inverse of the square of the temperature. "
+                             "Units: J K/kg.");
+          prm.declare_entry ("Third coefficients for specific heat polynomial", "-464.775577, -1112.54791, 25.5067110, -592.994207, -562.222634, -562.222634, -562.222634",
+                             Patterns::List(Patterns::Double()),
+                             "The third of three coefficients that are used to compute the specific heat capacities for each "
+                             "different endmember at the reference temperature and reference pressure. This coefficient describes "
+                             "the part of the temperature dependence that scales as the inverse of the square root of the temperature"
+                             "Units: J/kg/sqrt(K).");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    MeltBoukare<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Melt boukare");
+        {
+          eta_0                             = prm.get_double ("Reference shear viscosity");
+          xi_0                              = prm.get_double ("Reference bulk viscosity");
+          eta_f                             = prm.get_double ("Reference melt viscosity");
+          reference_permeability            = prm.get_double ("Reference permeability");
+          thermal_viscosity_exponent        = prm.get_double ("Thermal viscosity exponent");
+          thermal_bulk_viscosity_exponent   = prm.get_double ("Thermal bulk viscosity exponent");
+          thermal_conductivity              = prm.get_double ("Thermal conductivity");
+          alpha_phi                         = prm.get_double ("Exponential melt weakening factor");
+          include_melting_and_freezing      = prm.get_bool ("Include melting and freezing");
+          melting_time_scale                = prm.get_double ("Melting time scale for operator splitting");
+          Fe_mantle_melting_temperature     = prm.get_double ("Fe mantle melting temperature");
+          Mg_mantle_melting_temperature     = prm.get_double ("Mg mantle melting temperature");
+          Fe_number_of_moles                = prm.get_double ("Fe number of moles");
+          Mg_number_of_moles                = prm.get_double ("Mg number of moles");
+
+          reference_temperature             = prm.get_double ("Reference temperature");
+          reference_pressure                = prm.get_double ("Reference pressure");
+
+          if (this->convert_output_to_years() == true)
+            melting_time_scale *= year_in_seconds;
+
+          AssertThrow(this->get_parameters().use_operator_splitting &&
+                      this->get_parameters().reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step,
+                      ExcMessage("The melt boukare material model has to be used with operator splitting, "
+                                 "and the reaction solver needs to be `fixed step'."));
+
+          AssertThrow(melting_time_scale >= this->get_parameters().reaction_time_step,
+                      ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
+                                 + " in the operator splitting scheme is too large to compute melting rates! "
+                                 "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
+                                 "operator splitting' chosen in the material model, which is currently "
+                                 + Utilities::to_string(melting_time_scale) + "."));
+          AssertThrow(melting_time_scale > 0.0,
+                      ExcMessage("The Melting time scale for operator splitting must be larger than 0!"));
+
+          // Equation of state parameters
+          endmember_names = Utilities::split_string_list(prm.get("Endmember names"));
+          AssertThrow(Utilities::has_unique_entries(endmember_names),
+                      ExcMessage("The list of strings for the parameter "
+                                 "'Material model/Melt boukare/Endmember names' contains entries more than once. "
+                                 "This is not allowed. Please check your parameter file."));
+
+          const unsigned int n_endmembers = endmember_names.size();
+          AssertThrow(n_endmembers == 7 || (!this->include_melt_transport() && n_endmembers == 4),
+                      ExcMessage("The list of strings for the parameter "
+                                 "'Material model/Melt boukare/Endmember names' does not contain the correct "
+                                 "number of entries. Please check your parameter file."));
+
+          std::vector<std::string> endmember_states_string = Utilities::split_string_list(prm.get("Endmember states"));
+          endmember_states.resize(endmember_states_string.size());
+
+          for (unsigned int i=0; i<endmember_states_string.size(); ++i)
+            {
+              if (endmember_states_string[i] == "solid")
+                endmember_states[i] = EndmemberState::solid;
+              else if (endmember_states_string[i] == "melt")
+                endmember_states[i] = EndmemberState::melt;
+              else
+                AssertThrow (false, ExcNotImplemented());
+            }
+
+          molar_masses = Utilities::parse_map_to_double_array (prm.get("Molar masses"),
+                                                               endmember_names,
+                                                               false,
+                                                               "Molar masses");
+
+          number_of_atoms = Utilities::parse_map_to_double_array (prm.get("Number of atoms"),
+                                                                  endmember_names,
+                                                                  false,
+                                                                  "Number of atoms");
+
+          reference_volumes = Utilities::parse_map_to_double_array (prm.get("Reference volumes"),
+                                                                    endmember_names,
+                                                                    false,
+                                                                    "Reference volumes");
+
+          reference_thermal_expansivities = Utilities::parse_map_to_double_array (prm.get("Reference thermal expansivities"),
+                                                                                  endmember_names,
+                                                                                  false,
+                                                                                  "Reference thermal expansivities");
+
+          reference_bulk_moduli = Utilities::parse_map_to_double_array (prm.get("Reference bulk moduli"),
+                                                                        endmember_names,
+                                                                        false,
+                                                                        "Reference bulk moduli");
+
+          bulk_modulus_pressure_derivatives = Utilities::parse_map_to_double_array (prm.get("First derivatives of the bulk modulus"),
+                                                                                    endmember_names,
+                                                                                    false,
+                                                                                    "First derivatives of the bulk modulus");
+
+          bulk_modulus_second_pressure_derivatives = Utilities::parse_map_to_double_array (prm.get("Second derivatives of the bulk modulus"),
+                                                     endmember_names,
+                                                     false,
+                                                     "Second derivatives of the bulk modulus");
+
+          Einstein_temperatures = Utilities::parse_map_to_double_array (prm.get("Einstein temperatures"),
+                                                                        endmember_names,
+                                                                        false,
+                                                                        "Einstein temperatures");
+
+          reference_enthalpies = Utilities::parse_map_to_double_array (prm.get("Reference enthalpies"),
+                                                                       endmember_names,
+                                                                       false,
+                                                                       "Reference enthalpies");
+
+          reference_entropies = Utilities::parse_map_to_double_array (prm.get("Reference entropies"),
+                                                                      endmember_names,
+                                                                      false,
+                                                                      "Reference entropies");
+
+          reference_specific_heats = Utilities::parse_map_to_double_array (prm.get("Reference specific heat capacities"),
+                                                                           endmember_names,
+                                                                           false,
+                                                                           "Reference specific heat capacities");
+
+          specific_heat_linear_coefficients = Utilities::parse_map_to_double_array (prm.get("Linear coefficients for specific heat polynomial"),
+                                                                                    endmember_names,
+                                                                                    false,
+                                                                                    "Linear coefficients for specific heat polynomial");
+
+          specific_heat_second_coefficients = Utilities::parse_map_to_double_array (prm.get("Second coefficients for specific heat polynomial"),
+                                                                                    endmember_names,
+                                                                                    false,
+                                                                                    "Second coefficients for specific heat polynomial");
+
+          specific_heat_third_coefficients = Utilities::parse_map_to_double_array (prm.get("Third coefficients for specific heat polynomial"),
+                                                                                   endmember_names,
+                                                                                   false,
+                                                                                   "Third coefficients for specific heat polynomial");
+
+          // Check all lists have the correct length.
+          AssertThrow(endmember_names.size() == endmember_states.size(),
+                      ExcMessage("One of the lists that define the endmember parameters does not have the "
+                                 "correct size.  Please check your parameter file."));
+
+
+          // All of these are molar fractions
+          // Check that all compositional fields we need exist
+          AssertThrow(this->introspection().compositional_name_exists("molar_Fe_in_solid"),
+                      ExcMessage("Material model melt boukare only works if there is a "
+                                 "compositional field called 'molar_Fe_in_solid'."));
+
+          if (this->include_melt_transport())
+            {
+              AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                          ExcMessage("Material model melt boukare only works if there is a "
+                                     "compositional field called porosity."));
+              AssertThrow(this->introspection().compositional_name_exists("molar_Fe_in_melt"),
+                          ExcMessage("Material model melt boukare only works if there is a "
+                                     "compositional field called 'molar_Fe_in_melt'."));
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    MeltBoukare<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (this->get_parameters().use_operator_splitting
+          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
+        {
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (out.n_evaluation_points(), this->n_compositional_fields()));
+        }
+
+      if (out.template get_additional_output<BoukareOutputs<dim>>() == nullptr)
+        {
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::BoukareOutputs<dim>> (out.n_evaluation_points()));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(MeltBoukare,
+                                   "melt boukare",
+                                   "A material model that implements a simplified version of the melting "
+                                   "model of Boukare et al. (https://doi.org/10.1002/2015JB011929) for the "
+                                   "lowermost mantle and uses it to compute the material parameters "
+                                   "required for the modeling of melt transport, including melting and "
+                                   "solidification and the corresponding changes in composition."
+                                   "The model parameterizes the composition (which includes the components "
+                                   "MgO, FeO and SiO2) as a mixture between two endmembers (one iron-bearing "
+                                   "and one magnesium-bearing). The equation of state considers three phases: "
+                                   "bridgmanite, ferropericlase, and melt (each with their individual "
+                                   "compositions). "
+                                   "More details can be found in Dannberg, J., Myhill, R., Gassmöller, R., "
+                                   "and Cottaar, S. (2021). The morphology, evolution and seismic visibility "
+                                   "of partial melt at the core–mantle boundary: implications for ULVZs. "
+                                   "Geophysical Journal International, 227(2), 1028-1059.")
+  }
+}
diff --git a/source/material_model/melt_global.cc.bak b/source/material_model/melt_global.cc.bak
new file mode 100644
index 00000000000..b0c48491595
--- /dev/null
+++ b/source/material_model/melt_global.cc.bak
@@ -0,0 +1,556 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/melt_global.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/numerics/fe_field_function.h>
+
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    double
+    MeltGlobal<dim>::
+    reference_darcy_coefficient () const
+    {
+      // 0.01 = 1% melt
+      return reference_permeability * std::pow(0.01,3.0) / eta_f;
+    }
+
+    template <int dim>
+    bool
+    MeltGlobal<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    double
+    MeltGlobal<dim>::
+    melt_fraction (const double temperature,
+                   const double pressure,
+                   const double depletion) const
+    {
+      const double T_solidus  = surface_solidus
+                                + pressure_solidus_change * pressure
+                                + std::max(depletion_solidus_change * depletion, -200.0);
+      const double T_liquidus = T_solidus + 500.0;
+
+      double melt_fraction;
+      if (temperature < T_solidus)
+        melt_fraction = 0.0;
+      else if (temperature > T_liquidus)
+        melt_fraction = 1.0;
+      else
+        melt_fraction = (temperature - T_solidus) / (T_liquidus - T_solidus);
+
+      return melt_fraction;
+    }
+
+
+    template <int dim>
+    void
+    MeltGlobal<dim>::
+    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                    std::vector<double> &melt_fractions) const
+    {
+      double depletion = 0.0;
+
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
+        {
+          if (this->include_melt_transport())
+            {
+              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+              const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
+              depletion = in.composition[q][peridotite_idx] - in.composition[q][porosity_idx];
+            }
+          melt_fractions[q] = this->melt_fraction(in.temperature[q],
+                                                  std::max(0.0, in.pressure[q]),
+                                                  depletion);
+        }
+    }
+
+
+    template <int dim>
+    void
+    MeltGlobal<dim>::
+    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      std::vector<double> old_porosity(in.n_evaluation_points());
+
+      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
+
+      // we want to get the porosity field from the old solution here,
+      // because we need a field that is not updated in the nonlinear iterations
+      if (this->include_melt_transport() && in.current_cell.state() == IteratorState::valid
+          && this->get_timestep_number() > 0 && !this->get_parameters().use_operator_splitting)
+        {
+          // Prepare the field function
+
+          Functions::FEFieldFunction<dim, LinearAlgebra::BlockVector>
+
+          fe_value(this->get_dof_handler(), this->get_old_solution(), this->get_mapping());
+
+          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+          fe_value.set_active_cell(in.current_cell);
+          fe_value.value_list(in.position,
+                              old_porosity,
+                              this->introspection().component_indices.compositional_fields[porosity_idx]);
+        }
+      else if (this->get_parameters().use_operator_splitting)
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+            old_porosity[i] = in.composition[i][porosity_idx];
+          }
+
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          // calculate density first, we need it for the reaction term
+          // temperature dependence of density is 1 - alpha * (T - T(adiabatic))
+          double temperature_dependence = 1.0;
+          if (this->include_adiabatic_heating ())
+            temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]))
+                                      * thermal_expansivity;
+          else
+            temperature_dependence -= (in.temperature[i] - reference_T) * thermal_expansivity;
+
+          // calculate composition dependence of density
+          const double delta_rho = this->introspection().compositional_name_exists("peridotite")
+                                   ?
+                                   depletion_density_change * in.composition[i][this->introspection().compositional_index_for_name("peridotite")]
+                                   :
+                                   0.0;
+          out.densities[i] = (reference_rho_s + delta_rho) * temperature_dependence
+                             * std::exp(compressibility * (in.pressure[i] - this->get_surface_pressure()));
+
+          out.viscosities[i] = eta_0;
+          // By default, no melting or freezing --> set all reactions to zero
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            {
+              out.reaction_terms[i][c] = 0.0;
+
+              if (this->get_parameters().use_operator_splitting && reaction_rate_out != nullptr)
+                reaction_rate_out->reaction_rates[i][c] = 0.0;
+            }
+
+          if (this->include_melt_transport())
+            {
+              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+              const double porosity = std::min(1.0, std::max(in.composition[i][porosity_idx],0.0));
+
+              // calculate viscosity based on local melt
+              out.viscosities[i] *= exp(- alpha_phi * porosity);
+
+              if (include_melting_and_freezing && (in.requests_property(MaterialProperties::reaction_terms) ||
+                                                   in.requests_property(MaterialProperties::reaction_rates) ||
+                                                   in.requests_property(MaterialProperties::viscosity)))
+                {
+                  Assert(this->get_timestep_number()<=1 || std::isfinite(in.strain_rate[i].norm()),
+                         ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                                    "not filled by the caller."));
+                  const double trace_strain_rate =
+                    (this->get_timestep_number() > 1) ?
+                    (trace(in.strain_rate[i]))
+                    :
+                    numbers::signaling_nan<double>();
+
+                  const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
+
+                  // Calculate the melting rate as difference between the equilibrium melt fraction
+                  // and the solution of the previous time step (or the current solution, in case
+                  // operator splitting is used).
+                  // The solidus is lowered by previous melting events (fractional melting).
+                  const double eq_melt_fraction = melt_fraction(in.temperature[i],
+                                                                this->get_adiabatic_conditions().pressure(in.position[i]),
+                                                                in.composition[i][peridotite_idx] - in.composition[i][porosity_idx]);
+                  double porosity_change = eq_melt_fraction - old_porosity[i];
+                  // do not allow negative porosity
+                  if (old_porosity[i] + porosity_change < 0)
+                    porosity_change = -old_porosity[i];
+
+                  for (unsigned int c = 0; c < in.composition[i].size(); ++c)
+                    {
+                      if (c == peridotite_idx && this->get_timestep_number() > 1)
+                        out.reaction_terms[i][c] = porosity_change - in.composition[i][peridotite_idx] * trace_strain_rate * this->get_timestep();
+                      else if (c == porosity_idx && this->get_timestep_number() > 1)
+                        out.reaction_terms[i][c] = porosity_change * out.densities[i] / this->get_timestep();
+                      else
+                        out.reaction_terms[i][c] = 0.0;
+
+                      // fill reaction rate outputs if the model uses operator splitting
+                      if (this->get_parameters().use_operator_splitting)
+                        {
+                          if (reaction_rate_out != nullptr)
+                            {
+                              if (c == peridotite_idx && this->get_timestep_number() > 0)
+                                reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale - in.composition[i][peridotite_idx] * trace(in.strain_rate[i]);
+                              else if (c == porosity_idx && this->get_timestep_number() > 0)
+                                reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale;
+                              else
+                                reaction_rate_out->reaction_rates[i][c] = 0.0;
+                            }
+                          out.reaction_terms[i][c] = 0.0;
+                        }
+                    }
+
+                  // find depletion = peridotite, which might affect shear viscosity:
+                  const double depletion_visc = std::min(1.0, std::max(in.composition[i][peridotite_idx], 0.0));
+
+                  // calculate strengthening due to depletion:
+                  const double depletion_strengthening = std::min(exp(alpha_depletion * depletion_visc), delta_eta_depletion_max);
+
+                  // calculate viscosity change due to local melt and depletion:
+                  out.viscosities[i] *= depletion_strengthening;
+                }
+            }
+
+          out.entropy_derivative_pressure[i]    = 0.0;
+          out.entropy_derivative_temperature[i] = 0.0;
+          out.thermal_expansion_coefficients[i] = thermal_expansivity;
+          out.specific_heat[i] = reference_specific_heat;
+          out.thermal_conductivities[i] = thermal_conductivity;
+          out.compressibilities[i] = 0.0;
+
+          double visc_temperature_dependence = 1.0;
+          if (this->include_adiabatic_heating ())
+            {
+              const double delta_temp = in.temperature[i]-this->get_adiabatic_conditions().temperature(in.position[i]);
+              visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[i])),1e4),1e-4);
+            }
+          else if (thermal_viscosity_exponent != 0.0)
+            {
+              const double delta_temp = in.temperature[i]-reference_T;
+              visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/reference_T),1e4),1e-4);
+            }
+          out.viscosities[i] *= visc_temperature_dependence;
+        }
+
+      // fill melt outputs if they exist
+      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
+
+      if (melt_out != nullptr)
+        {
+          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+            {
+              double porosity = std::max(in.composition[i][porosity_idx],0.0);
+
+              melt_out->fluid_viscosities[i] = eta_f;
+              melt_out->permeabilities[i] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+              melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+
+              // temperature dependence of density is 1 - alpha * (T - T(adiabatic))
+              double temperature_dependence = 1.0;
+              if (this->include_adiabatic_heating ())
+                temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]))
+                                          * thermal_expansivity;
+              else
+                temperature_dependence -= (in.temperature[i] - reference_T) * thermal_expansivity;
+              melt_out->fluid_densities[i] = reference_rho_f * temperature_dependence
+                                             * std::exp(melt_compressibility * (in.pressure[i] - this->get_surface_pressure()));
+
+              melt_out->compaction_viscosities[i] = xi_0 * exp(- alpha_phi * porosity);
+
+              double visc_temperature_dependence = 1.0;
+              if (this->include_adiabatic_heating ())
+                {
+                  const double delta_temp = in.temperature[i]-this->get_adiabatic_conditions().temperature(in.position[i]);
+                  visc_temperature_dependence = std::max(std::min(std::exp(-thermal_bulk_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[i])),1e4),1e-4);
+                }
+              else if (thermal_viscosity_exponent != 0.0)
+                {
+                  const double delta_temp = in.temperature[i]-reference_T;
+                  visc_temperature_dependence = std::max(std::min(std::exp(-thermal_bulk_viscosity_exponent*delta_temp/reference_T),1e4),1e-4);
+                }
+              melt_out->compaction_viscosities[i] *= visc_temperature_dependence;
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    MeltGlobal<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Melt global");
+        {
+          prm.declare_entry ("Reference solid density", "3000.",
+                             Patterns::Double (0.),
+                             "Reference density of the solid $\\rho_{s,0}$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference melt density", "2500.",
+                             Patterns::Double (0.),
+                             "Reference density of the melt/fluid$\\rho_{f,0}$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. The reference temperature is used "
+                             "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Reference shear viscosity", "5e20",
+                             Patterns::Double (0.),
+                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
+                             "This viscosity may be modified by both temperature and porosity "
+                             "dependencies. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Reference bulk viscosity", "1e22",
+                             Patterns::Double (0.),
+                             "The value of the constant bulk viscosity $\\xi_0$ of the solid matrix. "
+                             "This viscosity may be modified by both temperature and porosity "
+                             "dependencies. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Reference melt viscosity", "10.",
+                             Patterns::Double (0.),
+                             "The value of the constant melt viscosity $\\eta_f$. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Exponential melt weakening factor", "27.",
+                             Patterns::Double (0.),
+                             "The porosity dependence of the viscosity. Units: dimensionless.");
+          prm.declare_entry ("Thermal viscosity exponent", "0.0",
+                             Patterns::Double (0.),
+                             "The temperature dependence of the shear viscosity. Dimensionless exponent. "
+                             "See the general documentation "
+                             "of this model for a formula that states the dependence of the "
+                             "viscosity on this factor, which is called $\\beta$ there.");
+          prm.declare_entry ("Thermal bulk viscosity exponent", "0.0",
+                             Patterns::Double (0.),
+                             "The temperature dependence of the bulk viscosity. Dimensionless exponent. "
+                             "See the general documentation "
+                             "of this model for a formula that states the dependence of the "
+                             "viscosity on this factor, which is called $\\beta$ there.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250.",
+                             Patterns::Double (0.),
+                             "The value of the specific heat $C_p$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\beta$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Reference permeability", "1e-8",
+                             Patterns::Double(),
+                             "Reference permeability of the solid host rock."
+                             "Units: \\si{\\meter\\squared}.");
+          prm.declare_entry ("Depletion density change", "0.0",
+                             Patterns::Double (),
+                             "The density contrast between material with a depletion of 1 and a "
+                             "depletion of zero. Negative values indicate lower densities of "
+                             "depleted material. Depletion is indicated by the compositional "
+                             "field with the name peridotite. Not used if this field does not "
+                             "exist in the model. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Surface solidus", "1300.",
+                             Patterns::Double (0.),
+                             "Solidus for a pressure of zero. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Depletion solidus change", "200.0",
+                             Patterns::Double (),
+                             "The solidus temperature change for a depletion of 100\\%. For positive "
+                             "values, the solidus gets increased for a positive peridotite field "
+                             "(depletion) and lowered for a negative peridotite field (enrichment). "
+                             "Scaling with depletion is linear. Only active when fractional melting "
+                             "is used. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Pressure solidus change", "6e-8",
+                             Patterns::Double (),
+                             "The linear solidus temperature change with pressure. For positive "
+                             "values, the solidus gets increased for positive pressures. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("Solid compressibility", "0.0",
+                             Patterns::Double (0.),
+                             "The value of the compressibility of the solid matrix. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("Melt compressibility", "0.0",
+                             Patterns::Double (0.),
+                             "The value of the compressibility of the melt. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("Melt bulk modulus derivative", "0.0",
+                             Patterns::Double (0.),
+                             "The value of the pressure derivative of the melt bulk "
+                             "modulus. "
+                             "Units: None.");
+          prm.declare_entry ("Include melting and freezing", "true",
+                             Patterns::Bool (),
+                             "Whether to include melting and freezing (according to a simplified "
+                             "linear melting approximation in the model (if true), or not (if "
+                             "false).");
+          prm.declare_entry ("Melting time scale for operator splitting", "1e3",
+                             Patterns::Double (0.),
+                             "In case the operator splitting scheme is used, the porosity field can not "
+                             "be set to a new equilibrium melt fraction instantly, but the model has to "
+                             "provide a melting time scale instead. This time scale defines how fast melting "
+                             "happens, or more specifically, the parameter defines the time after which "
+                             "the deviation of the porosity from the equilibrium melt fraction will be "
+                             "reduced to a fraction of $1/e$. So if the melting time scale is small compared "
+                             "to the time step size, the reaction will be so fast that the porosity is very "
+                             "close to the equilibrium melt fraction after reactions are computed. Conversely, "
+                             "if the melting time scale is large compared to the time step size, almost no "
+                             "melting and freezing will occur."
+                             "\n\n"
+                             "Also note that the melting time scale has to be larger than or equal to the reaction "
+                             "time step used in the operator splitting scheme, otherwise reactions can not be "
+                             "computed. If the model does not use operator splitting, this parameter is not used. "
+                             "Units: yr or s, depending on the ``Use years "
+                             "in output instead of seconds'' parameter.");
+          prm.declare_entry ("Exponential depletion strengthening factor", "0.0",
+                             Patterns::Double (0.),
+                             "$\\alpha_F$: exponential dependency of viscosity on the depletion "
+                             "field $F$ (called peridotite). "
+                             "Dimensionless factor. With a value of 0.0 (the default) the "
+                             "viscosity does not depend on the depletion. The effective viscosity increase"
+                             "due to depletion is defined as $exp( \\alpha_F * F)$. "
+                             "Rationale: melting dehydrates the source rock by removing most of the volatiles,"
+                             "and makes it stronger. Hirth and Kohlstedt (1996) report typical values around a "
+                             "factor 100 to 1000 viscosity contrast between wet and dry rocks, although some "
+                             "experimental studies report a smaller (factor 10) contrast (e.g. Fei et al., 2013).");
+          prm.declare_entry ("Maximum Depletion viscosity change", "1.0e3",
+                             Patterns::Double (0.),
+                             "$\\Delta \\eta_{F,max}$: maximum depletion strengthening of viscosity. "
+                             "Rationale: melting dehydrates the source rock by removing most of the volatiles,"
+                             "and makes it stronger. Hirth and Kohlstedt (1996) report typical values around a "
+                             "factor 100 to 1000 viscosity contrast between wet and dry rocks, although some "
+                             "experimental studies report a smaller (factor 10) contrast (e.g. Fei et al., 2013).");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    MeltGlobal<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Melt global");
+        {
+          reference_rho_s                   = prm.get_double ("Reference solid density");
+          reference_rho_f                   = prm.get_double ("Reference melt density");
+          reference_T                       = prm.get_double ("Reference temperature");
+          eta_0                             = prm.get_double ("Reference shear viscosity");
+          xi_0                              = prm.get_double ("Reference bulk viscosity");
+          eta_f                             = prm.get_double ("Reference melt viscosity");
+          reference_permeability            = prm.get_double ("Reference permeability");
+          thermal_viscosity_exponent        = prm.get_double ("Thermal viscosity exponent");
+          thermal_bulk_viscosity_exponent   = prm.get_double ("Thermal bulk viscosity exponent");
+          thermal_conductivity              = prm.get_double ("Thermal conductivity");
+          reference_specific_heat           = prm.get_double ("Reference specific heat");
+          thermal_expansivity               = prm.get_double ("Thermal expansion coefficient");
+          alpha_phi                         = prm.get_double ("Exponential melt weakening factor");
+          depletion_density_change          = prm.get_double ("Depletion density change");
+          surface_solidus                   = prm.get_double ("Surface solidus");
+          depletion_solidus_change          = prm.get_double ("Depletion solidus change");
+          pressure_solidus_change           = prm.get_double ("Pressure solidus change");
+          compressibility                   = prm.get_double ("Solid compressibility");
+          melt_compressibility              = prm.get_double ("Melt compressibility");
+          include_melting_and_freezing      = prm.get_bool ("Include melting and freezing");
+          melting_time_scale                = prm.get_double ("Melting time scale for operator splitting");
+          alpha_depletion                   = prm.get_double ("Exponential depletion strengthening factor");
+          delta_eta_depletion_max           = prm.get_double ("Maximum Depletion viscosity change");
+
+          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
+            AssertThrow(false, ExcMessage("Error: Material model Melt global with Thermal viscosity exponent can not have reference_T=0."));
+
+          if (this->convert_output_to_years() == true)
+            melting_time_scale *= year_in_seconds;
+
+          if (this->get_parameters().use_operator_splitting)
+            {
+              if (this->get_parameters().reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
+                AssertThrow(melting_time_scale >= this->get_parameters().reaction_time_step,
+                            ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
+                                       + " in the operator splitting scheme is too large to compute melting rates! "
+                                       "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
+                                       "operator splitting' chosen in the material model, which is currently "
+                                       + Utilities::to_string(melting_time_scale) + "."));
+              AssertThrow(melting_time_scale > 0,
+                          ExcMessage("The Melting time scale for operator splitting must be larger than 0!"));
+              AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                          ExcMessage("Material model Melt global with melt transport only "
+                                     "works if there is a compositional field called porosity."));
+            }
+
+          if (this->include_melt_transport())
+            {
+              AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                          ExcMessage("Material model Melt global with melt transport only "
+                                     "works if there is a compositional field called porosity."));
+              if (include_melting_and_freezing)
+                {
+                  AssertThrow(this->introspection().compositional_name_exists("peridotite"),
+                              ExcMessage("Material model Melt global only works if there is a "
+                                         "compositional field called peridotite."));
+                }
+            }
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    MeltGlobal<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (this->get_parameters().use_operator_splitting
+          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(MeltGlobal,
+                                   "melt global",
+                                   "A material model that implements a simple formulation of the "
+                                   "material parameters required for the modeling of melt transport, "
+                                   "including a source term for the porosity according to a simplified "
+                                   "linear melting model similar to \\cite{schmeling2006}:\n"
+                                   "$\\phi_{\\text{equilibrium}} = \\frac{T-T_{\\text{sol}}}{T_{\\text{liq}}-T_{\\text{sol}}}$\n"
+                                   "with "
+                                   "$T_{\\text{sol}} = T_{\\text{sol,0}} + \\Delta T_p \\, p + \\Delta T_c \\, C$ \n"
+                                   "$T_{\\text{liq}} = T_{\\text{sol}}  + \\Delta T_{\\text{sol-liq}}$.")
+  }
+}
diff --git a/source/material_model/melt_simple.cc.bak b/source/material_model/melt_simple.cc.bak
new file mode 100644
index 00000000000..1debe1eb863
--- /dev/null
+++ b/source/material_model/melt_simple.cc.bak
@@ -0,0 +1,284 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/material_model/melt_simple.h>
+#include <aspect/material_model/reaction_model/katz2003_mantle_melting.h>
+#include <aspect/utilities.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/numerics/fe_field_function.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    double
+    MeltSimple<dim>::
+    reference_darcy_coefficient () const
+    {
+      // 0.01 = 1% melt
+      return katz2003_model.reference_darcy_coefficient();
+    }
+
+    template <int dim>
+    bool
+    MeltSimple<dim>::
+    is_compressible () const
+    {
+      return model_is_compressible;
+    }
+
+    template <int dim>
+    void
+    MeltSimple<dim>::
+    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                    std::vector<double> &melt_fractions) const
+    {
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
+        melt_fractions[q] = katz2003_model.melt_fraction(in.temperature[q],
+                                                         this->get_adiabatic_conditions().pressure(in.position[q]));
+    }
+
+
+    template <int dim>
+    void
+    MeltSimple<dim>::initialize ()
+    {
+      if (this->include_melt_transport())
+        {
+          AssertThrow(this->get_parameters().use_operator_splitting,
+                      ExcMessage("The material model ``Melt simple'' can only be used with operator splitting!"));
+          AssertThrow(this->introspection().compositional_name_exists("peridotite"),
+                      ExcMessage("Material model Melt simple only works if there is a "
+                                 "compositional field called peridotite."));
+          AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                      ExcMessage("Material model Melt simple with melt transport only "
+                                 "works if there is a compositional field called porosity."));
+        }
+    }
+
+
+    template <int dim>
+    void
+    MeltSimple<dim>::
+    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          // calculate density first, we need it for the reaction term
+          // first, calculate temperature dependence of density
+          double temperature_dependence = 1.0;
+          if (this->include_adiabatic_heating ())
+            {
+              // temperature dependence is 1 - alpha * (T - T(adiabatic))
+              temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]))
+                                        * thermal_expansivity;
+            }
+          else
+            temperature_dependence -= (in.temperature[i] - reference_T) * thermal_expansivity;
+
+          // calculate composition dependence of density
+          const double delta_rho = this->introspection().compositional_name_exists("peridotite")
+                                   ?
+                                   depletion_density_change * in.composition[i][this->introspection().compositional_index_for_name("peridotite")]
+                                   :
+                                   0.0;
+          out.densities[i] = (reference_rho_solid + delta_rho)
+                             * temperature_dependence * std::exp(compressibility * (in.pressure[i] - this->get_surface_pressure()));
+
+          out.viscosities[i] = eta_0;
+          out.thermal_expansion_coefficients[i] = thermal_expansivity;
+          out.specific_heat[i] = reference_specific_heat;
+          out.thermal_conductivities[i] = thermal_conductivity;
+          out.compressibilities[i] = compressibility;
+
+          double visc_temperature_dependence = 1.0;
+          if (this->include_adiabatic_heating ())
+            {
+              const double delta_temp = in.temperature[i]-this->get_adiabatic_conditions().temperature(in.position[i]);
+              visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[i])),1e4),1e-4);
+            }
+          else
+            {
+              const double delta_temp = in.temperature[i]-reference_T;
+              const double T_dependence = (thermal_viscosity_exponent == 0.0
+                                           ?
+                                           0.0
+                                           :
+                                           thermal_viscosity_exponent*delta_temp/reference_T);
+              visc_temperature_dependence = std::max(std::min(std::exp(-T_dependence),1e4),1e-4);
+            }
+          out.viscosities[i] *= visc_temperature_dependence;
+
+        }
+
+      katz2003_model.calculate_reaction_rate_outputs(in, out);
+      katz2003_model.calculate_fluid_outputs(in, out, reference_T);
+    }
+
+
+    template <int dim>
+    void
+    MeltSimple<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Melt simple");
+        {
+          // Melt Fraction Parameters
+          ReactionModel::Katz2003MantleMelting<dim>::declare_parameters(prm);
+
+
+          prm.declare_entry ("Use full compressibility", "false",
+                             Patterns::Bool (),
+                             "If the compressibility should be used everywhere in the code "
+                             "(if true), changing the volume of material when the density changes, "
+                             "or only in the momentum conservation and advection equations "
+                             "(if false).");
+          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\beta$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Reference shear viscosity", "5e20",
+                             Patterns::Double (0.),
+                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
+                             "This viscosity may be modified by both temperature and porosity "
+                             "dependencies. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Reference specific heat", "1250.",
+                             Patterns::Double (0.),
+                             "The value of the specific heat $C_p$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Solid compressibility", "0.0",
+                             Patterns::Double (0.),
+                             "The value of the compressibility of the solid matrix. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("Thermal viscosity exponent", "0.0",
+                             Patterns::Double (0.),
+                             "The temperature dependence of the shear viscosity. Dimensionless exponent. "
+                             "See the general documentation "
+                             "of this model for a formula that states the dependence of the "
+                             "viscosity on this factor, which is called $\\beta$ there.");
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. The reference temperature is used "
+                             "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Depletion density change", "0.0",
+                             Patterns::Double (),
+                             "The density contrast between material with a depletion of 1 and a "
+                             "depletion of zero. Negative values indicate lower densities of "
+                             "depleted material. Depletion is indicated by the compositional "
+                             "field with the name peridotite. Not used if this field does not "
+                             "exist in the model. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference solid density", "3000.",
+                             Patterns::Double (0.),
+                             "Reference density of the solid $\\rho_{s,0}$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    MeltSimple<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Melt simple");
+        {
+          model_is_compressible      = prm.get_bool ("Use full compressibility");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          eta_0                      = prm.get_double ("Reference shear viscosity");
+          thermal_expansivity        = prm.get_double ("Thermal expansion coefficient");
+          thermal_conductivity       = prm.get_double ("Thermal conductivity");
+          compressibility            = prm.get_double ("Solid compressibility");
+          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
+          reference_T                = prm.get_double ("Reference temperature");
+          depletion_density_change   = prm.get_double ("Depletion density change");
+          reference_rho_solid        = prm.get_double ("Reference solid density");
+
+
+
+          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
+            AssertThrow(false, ExcMessage("Error: Material model Melt simple with Thermal viscosity exponent can not have reference_T=0."));
+
+          // Melt model
+          katz2003_model.initialize_simulator (this->get_simulator());
+          katz2003_model.parse_parameters(prm);
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    MeltSimple<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (this->get_parameters().use_operator_splitting && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(MeltSimple,
+                                   "melt simple",
+                                   "A material model that implements a simple formulation of the "
+                                   "material parameters required for the modeling of melt transport, "
+                                   "including a source term for the porosity according to the melting "
+                                   "model for dry peridotite of \\cite{katz:etal:2003}. This also includes a "
+                                   "computation of the latent heat of melting (if the `latent heat' "
+                                   "heating model is active)."
+                                   "\n\n"
+                                   "Most of the material properties are constant, except for the shear, "
+                                   "viscosity $\\eta$, the compaction viscosity $\\xi$, and the "
+                                   "permeability $k$, which depend on the porosity; and the solid and melt "
+                                   "densities, which depend on temperature and pressure:\n "
+                                   "$\\eta(\\phi,T) = \\eta_0 e^{\\alpha(\\phi-\\phi_0)} e^{-\\beta(T-T_0)/T_0}$, "
+                                   "$\\xi(\\phi,T) = \\xi_0 \\frac{\\phi_0}{\\phi} e^{-\\beta(T-T_0)/T_0}$, "
+                                   "$k=k_0 \\phi^n (1-\\phi)^m$, "
+                                   "$\\rho=\\rho_0 (1 - \\alpha (T - T_{\\text{adi}})) e^{\\kappa p}$."
+                                   "\n\n"
+                                   "The model is compressible only if this is specified in the input file, "
+                                   "and contains compressibility for both solid and melt.")
+  }
+}
diff --git a/source/material_model/modified_tait.cc.bak b/source/material_model/modified_tait.cc.bak
new file mode 100644
index 00000000000..6340609a461
--- /dev/null
+++ b/source/material_model/modified_tait.cc.bak
@@ -0,0 +1,271 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/modified_tait.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    ModifiedTait<dim>::
+    evaluate(const MaterialModelInputs<dim> &in,
+             MaterialModelOutputs<dim> &out) const
+    {
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double temperature = in.temperature[i];
+          const double pressure = in.pressure[i];
+
+          AssertThrow(temperature > 100., ExcMessage("The current temperature is <100 K. "
+                                                     "The modified Tait equations of state is "
+                                                     "not designed for such temperatures. "
+                                                     "If this exception is triggered at the "
+                                                     "beginning of a run, you may need to "
+                                                     "set Adiabatic surface temperature "
+                                                     "to a value > 100 in the parameter file."));
+          out.viscosities[i] = eta;
+          out.thermal_conductivities[i] = k_value;
+
+          // Einstein equations for the heat capacity at constant volume
+          const double x_einstein = einstein_temperature/temperature;
+          const double x_einstein0 = einstein_temperature/reference_temperature;
+
+
+          AssertThrow(x_einstein < 35., ExcMessage("The current temperature is less than 1/35th "
+                                                   "of the Einstein temperature. This is not "
+                                                   "expected for geological materials."));
+          AssertThrow(x_einstein0 < 35., ExcMessage("The reference temperature of the "
+                                                    "equation of state is less than 1/35th "
+                                                    "of the Einstein temperature. This is not "
+                                                    "expected for geological materials."));
+
+          // The following Einstein energies and heat capacities are divided through by 3nR.
+          // This doesn't matter, as the equation of state relies only on ratios of these quantities.
+          const double E_th0 = einstein_temperature * (0.5 + 1. / (std::exp(x_einstein0) - 1.0));
+          const double C_V0 = x_einstein0 * x_einstein0 * std::exp(x_einstein0) / std::pow(std::exp(x_einstein0) - 1.0, 2.0);
+
+          const double E_th = einstein_temperature * (0.5 + 1. / (std::exp(x_einstein) - 1.0));
+          const double C_V = x_einstein * x_einstein * std::exp(x_einstein) / std::pow(std::exp(x_einstein) - 1.0, 2.0);
+
+          // The relative thermal pressure
+          const double Pth_rel = reference_thermal_expansivity * reference_isothermal_bulk_modulus * (E_th - E_th0) / C_V0;
+          const double psubpth = pressure - reference_pressure - Pth_rel;
+
+          // x = rho0/rho
+          const double x = 1 - tait_a * (1. - std::pow((1. + tait_b * psubpth), -1.0 * tait_c));
+
+          // xi
+          const double xi = (C_V / C_V0);
+
+          // Here we calculate the pressure effect on the heat capacity. It is a bit involved.
+          const double dintVdpdT = ((reference_thermal_expansivity *
+                                     reference_isothermal_bulk_modulus / reference_rho *
+                                     tait_a * xi) *
+                                    (std::pow((1. + tait_b * psubpth), - tait_c) -
+                                     std::pow((1. - tait_b * Pth_rel), - tait_c)));
+
+          const double dSdT = (reference_isothermal_bulk_modulus / reference_rho *
+                               std::pow((xi * reference_thermal_expansivity), 2) *
+                               (std::pow((1. + tait_b * psubpth), -1. - tait_c) -
+                                std::pow((1. - tait_b * Pth_rel), -1. - tait_c)) +
+                               dintVdpdT * (( 1 - 2./x_einstein + 2./(std::exp(x_einstein) - 1.))
+                                            * einstein_temperature/(temperature*temperature)));
+
+          const double rho = reference_rho / x;
+          const double isothermal_compressibility = 1./(reference_isothermal_bulk_modulus * (1. + tait_b * psubpth) * (tait_a + (1. - tait_a) * std::pow((1. + tait_b * psubpth), tait_c)));
+          const double alpha = reference_thermal_expansivity * xi * 1. / ((1. + tait_b * psubpth) * (tait_a + (1. - tait_a) * std::pow((1 + tait_b * psubpth), tait_c)));
+          const double heat_capacity = reference_heat_capacity_function.value(Point<1>(temperature)) + temperature * dSdT;
+
+          // The following line might be useful for some compressibility models
+          // double isentropic_compressibility = isothermal_compressibility - alpha*alpha*temperature/(rho*heat_capacity);
+          out.densities[i] = rho;
+          out.compressibilities[i] = isothermal_compressibility;
+          out.thermal_expansion_coefficients[i] = alpha;
+          out.specific_heat[i] = heat_capacity;
+
+          out.entropy_derivative_pressure[i] = -alpha / rho;
+          out.entropy_derivative_temperature[i] = heat_capacity/temperature;
+          // Change in composition due to chemical reactions at the
+          // given positions. The term reaction_terms[i][c] is the
+          // change in compositional field c at point i.
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    ModifiedTait<dim>::
+    is_compressible () const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    void
+    ModifiedTait<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Modified Tait model");
+        {
+          prm.declare_entry ("Reference pressure", "1e5",
+                             Patterns::Double (0.),
+                             "Reference pressure $P_0$. Units: \\si{\\pascal}.");
+          prm.declare_entry ("Reference temperature", "298.15",
+                             Patterns::Double (0.),
+                             "Reference temperature $T_0$. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Reference density", "3300.",
+                             Patterns::Double (0.),
+                             "The density at the reference pressure and temperature. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference isothermal bulk modulus", "125e9",
+                             Patterns::Double (0.),
+                             "The isothermal bulk modulus at the reference pressure and temperature. "
+                             "Units: \\si{\\pascal}.");
+          prm.declare_entry ("Reference bulk modulus derivative", "4.",
+                             Patterns::Double (0.),
+                             "The value of the first pressure derivative of the isothermal bulk modulus "
+                             "at the reference pressure and temperature. "
+                             "Units: None.");
+          prm.declare_entry ("Reference thermal expansivity", "2e-5",
+                             Patterns::Double (0.),
+                             "The thermal expansion coefficient at the reference pressure and temperature. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Einstein temperature", "600.",
+                             Patterns::Double (0.),
+                             "The Einstein temperature at the reference pressure and temperature. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Viscosity", "1e21",
+                             Patterns::Double (0.),
+                             "The value of the constant viscosity $\\eta_0$. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the constant thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+
+          prm.enter_subsection("Reference heat capacity function");
+          {
+            Functions::ParsedFunction<1>::declare_parameters(prm,1);
+            prm.declare_entry("Function expression","1.25e3");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ModifiedTait<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Modified Tait model");
+        {
+          reference_pressure                = prm.get_double ("Reference pressure");
+          reference_temperature             = prm.get_double ("Reference temperature");
+          reference_rho                     = prm.get_double ("Reference density");
+          reference_isothermal_bulk_modulus = prm.get_double ("Reference isothermal bulk modulus");
+          reference_Kprime                  = prm.get_double ("Reference bulk modulus derivative");
+          reference_thermal_expansivity     = prm.get_double ("Reference thermal expansivity");
+          einstein_temperature              = prm.get_double ("Einstein temperature");
+
+          eta                               = prm.get_double ("Viscosity");
+          k_value                           = prm.get_double ("Thermal conductivity");
+
+          prm.enter_subsection("Reference heat capacity function");
+          {
+            try
+              {
+                reference_heat_capacity_function.parse_parameters(prm);
+              }
+            catch (...)
+              {
+                std::cerr << "FunctionParser failed to parse\n"
+                          << "\t Reference heat capacity function\n"
+                          << "with expression \n"
+                          << "\t' " << prm.get("Function expression") << "'";
+                throw;
+              }
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Calculate dependent parameters
+      Kdprime_0 = -reference_Kprime/reference_isothermal_bulk_modulus;
+      tait_a = (1. + reference_Kprime) / (1. + reference_Kprime  + reference_isothermal_bulk_modulus * Kdprime_0);
+      tait_b = (reference_Kprime  / reference_isothermal_bulk_modulus) - (Kdprime_0  / (1. + reference_Kprime ));
+      tait_c = (1. + reference_Kprime  + reference_isothermal_bulk_modulus * Kdprime_0) /
+               (reference_Kprime * reference_Kprime + reference_Kprime - reference_isothermal_bulk_modulus * Kdprime_0);
+
+      // Declare dependencies on solution variables
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+      this->model_dependence.viscosity = NonlinearDependence::none;
+
+
+      this->model_dependence.density = NonlinearDependence::temperature
+                                       | NonlinearDependence::pressure
+                                       | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::temperature
+                                               | NonlinearDependence::pressure
+                                               | NonlinearDependence::compositional_fields;
+      this->model_dependence.specific_heat = NonlinearDependence::temperature
+                                             | NonlinearDependence::pressure
+                                             | NonlinearDependence::compositional_fields;
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ModifiedTait,
+                                   "modified tait",
+                                   "A material model that implements the thermal modified Tait "
+                                   "equation of state as written in \\cite{HP2011}. "
+                                   "Constant values are used for the thermal conductivity and "
+                                   "viscosity. The defaults for all coefficients are chosen "
+                                   "to be similar to what is believed to be correct "
+                                   "for Earth's mantle. "
+                                   "All of the values that define this model are read "
+                                   "from a section ``Material model/Modified Tait model'' "
+                                   "in the input file, see "
+                                   "Section~\\ref{parameters:Material_20model/Modified_20Tait_20model}.")
+  }
+}
diff --git a/source/material_model/multicomponent.cc.bak b/source/material_model/multicomponent.cc.bak
new file mode 100644
index 00000000000..66040fe62ac
--- /dev/null
+++ b/source/material_model/multicomponent.cc.bak
@@ -0,0 +1,179 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/multicomponent.h>
+#include <aspect/utilities.h>
+
+#include <numeric>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    Multicomponent<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      EquationOfStateOutputs<dim> eos_outputs (this->introspection().n_chemical_composition_fields()+1);
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          // The (incompressible) Boussinesq approximation treats the
+          // buoyancy term as Delta rho[i] * C[i], which implies that
+          // compositional fields are given as volume fractions.
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[i],
+                                                       this->introspection().chemical_composition_field_indices());
+
+          equation_of_state.evaluate(in, i, eos_outputs);
+          out.viscosities[i] = MaterialUtilities::average_value(volume_fractions, viscosities, viscosity_averaging);
+          out.specific_heat[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
+          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
+          out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
+          out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
+          out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
+
+          // Arithmetic averaging of thermal conductivities
+          // This may not be strictly the most reasonable thing, but for most Earth materials we hope
+          // that they do not vary so much that it is a big problem.
+          out.thermal_conductivities[i] = MaterialUtilities::average_value (volume_fractions, thermal_conductivities, MaterialUtilities::arithmetic);
+
+          // not strictly correct if thermal expansivities are different, since we are interpreting
+          // these compositions as volume fractions, but the error introduced should not be too bad.
+          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
+
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+
+        }
+    }
+
+    template <int dim>
+    bool
+    Multicomponent<dim>::
+    is_compressible () const
+    {
+      return equation_of_state.is_compressible();
+    }
+
+    template <int dim>
+    void
+    Multicomponent<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Multicomponent");
+        {
+          EquationOfState::MulticomponentIncompressible<dim>::declare_parameters (prm, 4.e-5);
+
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Viscosities", "1.e21",
+                             Patterns::Anything(),
+                             "List of viscosities for background mantle and compositional fields,"
+                             "for a total of N+1 values, where N is the number of compositional fields."
+                             "If only one value is given, then all use the same value. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Thermal conductivities", "4.7",
+                             Patterns::Anything(),
+                             "List of thermal conductivities for background mantle and compositional fields,"
+                             "for a total of N+1 values, where N is the number of compositional fields."
+                             "If only one value is given, then all use the same value. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
+                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
+                             "When more than one compositional field is present at a point "
+                             "with different viscosities, we need to come up with an average "
+                             "viscosity at that point.  Select a weighted harmonic, arithmetic, "
+                             "geometric, or maximum composition.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    Multicomponent<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Multicomponent");
+        {
+          equation_of_state.initialize_simulator (this->get_simulator());
+          equation_of_state.parse_parameters (prm);
+
+          reference_T = prm.get_double ("Reference temperature");
+
+          viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
+                                prm);
+
+          // Make options file for parsing maps to double arrays
+          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+          chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+          compositional_field_names.insert(compositional_field_names.begin(),"background");
+
+          Utilities::MapParsing::Options options(chemical_field_names, "Viscosities");
+          options.list_of_allowed_keys = compositional_field_names;
+          options.allow_multiple_values_per_key = true;
+
+          // Parse multicomponent properties
+          viscosities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Viscosities"), options);
+          options.property_name = "Thermal conductivities";
+          thermal_conductivities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Thermal conductivities"), options);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::compositional_fields;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Multicomponent,
+                                   "multicomponent",
+                                   "This incompressible model is for use with an arbitrary number of"
+                                   " compositional fields, where each field represents a rock type which"
+                                   " can have completely different properties from the others."
+                                   " However, each rock type itself has constant material properties.  The value of the "
+                                   " compositional field is interpreted as a volume fraction. If the sum of the fields is"
+                                   " greater than one, they are renormalized.  If it is less than one, material properties "
+                                   " for ``background mantle'' make up the rest. When more than one field is present, the"
+                                   " material properties are averaged arithmetically.  An exception is the viscosity,"
+                                   " where the averaging should make more of a difference.  For this, the user selects"
+                                   " between arithmetic, harmonic, geometric, or maximum composition averaging.")
+  }
+}
diff --git a/source/material_model/multicomponent_compressible.cc.bak b/source/material_model/multicomponent_compressible.cc.bak
new file mode 100644
index 00000000000..09bc2634bb3
--- /dev/null
+++ b/source/material_model/multicomponent_compressible.cc.bak
@@ -0,0 +1,184 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/multicomponent_compressible.h>
+#include <aspect/utilities.h>
+
+#include <numeric>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    MulticomponentCompressible<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      EquationOfStateOutputs<dim> eos_outputs (this->n_compositional_fields()+1);
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          equation_of_state.evaluate(in, i, eos_outputs);
+
+          // Calculate volume fractions from mass fractions
+          const std::vector<double> mass_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_volumes_from_masses(mass_fractions,
+                                                       eos_outputs.densities,
+                                                       true);
+
+          // Specific quantities are mass averaged
+          out.specific_heat[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
+          out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
+          out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
+
+          // Density, thermal expansivity and compressibility are all volume averaged
+          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
+          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
+          out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
+
+          // Arithmetic volume fraction averaging of thermal conductivities
+          // This may not be the most reasonable thing, but for most Earth materials we hope
+          // that they do not vary so much that it is a big problem.
+          out.thermal_conductivities[i] = MaterialUtilities::average_value (volume_fractions, thermal_conductivities, MaterialUtilities::arithmetic);
+
+          // User-defined volume fraction averaging of viscosities
+          out.viscosities[i] = MaterialUtilities::average_value (volume_fractions, viscosities, viscosity_averaging);
+
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+
+        }
+    }
+
+    template <int dim>
+    bool
+    MulticomponentCompressible<dim>::
+    is_compressible () const
+    {
+      return equation_of_state.is_compressible();
+    }
+
+    template <int dim>
+    void
+    MulticomponentCompressible<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Multicomponent compressible");
+        {
+          EquationOfState::MulticomponentCompressible<dim>::declare_parameters (prm);
+
+          prm.declare_entry ("Viscosities", "1.e21",
+                             Patterns::Anything(),
+                             "List of viscosities for background mantle and compositional fields,"
+                             "for a total of N+1 values, where N is the number of compositional fields."
+                             "If only one value is given, then all use the same value. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Thermal conductivities", "4.7",
+                             Patterns::Anything(),
+                             "List of thermal conductivities for background mantle and compositional fields,"
+                             "for a total of N+1 values, where N is the number of compositional fields."
+                             "If only one value is given, then all use the same value. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
+                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
+                             "When more than one compositional field is present at a point "
+                             "with different viscosities, we need to come up with an average "
+                             "viscosity at that point.  Select a weighted harmonic, arithmetic, "
+                             "geometric, or maximum composition.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    MulticomponentCompressible<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Multicomponent compressible");
+        {
+          equation_of_state.initialize_simulator (this->get_simulator());
+          equation_of_state.parse_parameters (prm);
+
+          viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
+                                prm);
+
+          // Establish that a background field is required here
+          const bool has_background_field = true;
+
+          // Retrieve the list of composition names
+          const std::vector<std::string> list_of_composition_names = this->introspection().get_composition_names();
+
+          viscosities = Utilities::parse_map_to_double_array (prm.get("Viscosities"),
+                                                              list_of_composition_names,
+                                                              has_background_field,
+                                                              "Viscosities");
+
+          thermal_conductivities = Utilities::parse_map_to_double_array (prm.get("Thermal conductivities"),
+                                                                         list_of_composition_names,
+                                                                         has_background_field,
+                                                                         "Thermal conductivities");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.thermal_conductivity = NonlinearDependence::compositional_fields;
+      this->model_dependence.viscosity = NonlinearDependence::compositional_fields;
+      this->model_dependence.density |= NonlinearDependence::temperature
+                                        | NonlinearDependence::pressure
+                                        | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::temperature
+                                               | NonlinearDependence::pressure
+                                               | NonlinearDependence::compositional_fields;
+      this->model_dependence.specific_heat = NonlinearDependence::temperature
+                                             | NonlinearDependence::pressure
+                                             | NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(MulticomponentCompressible,
+                                   "multicomponent compressible",
+                                   "This model is for use with an arbitrary number of compositional fields, where each field"
+                                   " represents a rock type which can have completely different properties from the others."
+                                   " Each rock type is described by a self-consistent equation of state.  The value of the "
+                                   " compositional field is interpreted as a mass fraction. If the sum of the fields is"
+                                   " greater than one, they are renormalized.  If it is less than one, material properties "
+                                   " for ``background mantle'' make up the rest. When more than one field is present, the "
+                                   "material properties are averaged arithmetically by mass fraction (for specific heat), "
+                                   "or volume fraction (for density, thermal expansivity and compressibility). "
+                                   "The thermal conductivity is also arithmetically averaged by volume fraction. "
+                                   "Finally, the viscosity is averaged by volume fraction, but the user can choose "
+                                   "between arithmetic, harmonic, geometric or maximum composition averaging.")
+  }
+}
diff --git a/source/material_model/nondimensional.cc.bak b/source/material_model/nondimensional.cc.bak
new file mode 100644
index 00000000000..88607a5573f
--- /dev/null
+++ b/source/material_model/nondimensional.cc.bak
@@ -0,0 +1,216 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/nondimensional.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    Nondimensional<dim>::initialize ()
+    {
+      Assert(this->get_parameters().formulation_temperature_equation
+             == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile,
+             ExcMessage("The Nondimensional material model can only work with a "
+                        "temperature formulation that is based on the reference "
+                        "profile."));
+      Assert((this->get_parameters().formulation_mass_conservation
+              == Parameters<dim>::Formulation::MassConservation::incompressible
+              && !compressible)
+             ||
+             (this->get_parameters().formulation_mass_conservation
+              == Parameters<dim>::Formulation::MassConservation::reference_density_profile
+              && compressible)
+             ||
+             (this->get_parameters().formulation_mass_conservation
+              == Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile
+              && compressible)
+             ,
+             ExcMessage("The Nondimensional material model can only work with a "
+                        "mass formulation that is incompressible or based on "
+                        "the reference profile and the Di has to be chosen "
+                        "accordingly."));
+    }
+
+
+    template <int dim>
+    void
+    Nondimensional<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const Point<dim> position = in.position[i];
+          const double temperature_deviation = in.temperature[i] - this->get_adiabatic_conditions().temperature(position);
+          const double pressure_deviation = in.pressure[i] - this->get_adiabatic_conditions().pressure(position);
+
+          const double depth = this->get_geometry_model().depth(position);
+
+          out.viscosities[i] = (compressible ? Di : 1.0) / Ra
+                               * std::exp( -exponential_viscosity_temperature_prefactor * temperature_deviation
+                                           + exponential_viscosity_depth_prefactor * depth);
+
+          out.specific_heat[i] = reference_specific_heat;
+          out.thermal_conductivities[i] = 1.0;
+          out.thermal_expansion_coefficients[i] = compressible ? Di : 1.0;
+
+          out.densities[i] = reference_rho
+                             * std::exp(depth * Di/gamma)
+                             * (1.0
+                                - out.thermal_expansion_coefficients[i] * temperature_deviation
+                                + (tala ? 0.0 : 1.0) * Di * gamma * pressure_deviation);
+
+          out.compressibilities[i] = 0.0;
+          out.entropy_derivative_pressure[i] = 0.0;
+          out.entropy_derivative_temperature[i] = 0.0;
+
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    Nondimensional<dim>::
+    is_compressible () const
+    {
+      return compressible;
+    }
+
+
+
+    template <int dim>
+    void
+    Nondimensional<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Nondimensional model");
+        {
+          prm.declare_entry ("Reference density", "1.0",
+                             Patterns::Double (0.),
+                             "Reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Ra", "1e4",
+                             Patterns::Double (0.),
+                             "Rayleigh number Ra");
+          prm.declare_entry ("Di", "0.0",
+                             Patterns::Double (0.),
+                             "Dissipation number. Pick 0.0 for incompressible "
+                             "computations.");
+          prm.declare_entry ("gamma", "1.0",
+                             Patterns::Double (0.),
+                             "Grueneisen parameter");
+          prm.declare_entry ("Reference specific heat", "1.0",
+                             Patterns::Double (0.),
+                             "The value of the specific heat $C_p$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Viscosity temperature prefactor", "0.0",
+                             Patterns::Double (0.),
+                             "Exponential temperature prefactor for viscosity.");
+          prm.declare_entry ("Viscosity depth prefactor", "0.0",
+                             Patterns::Double (0.),
+                             "Exponential depth prefactor for viscosity.");
+          prm.declare_entry ("Use TALA", "false",
+                             Patterns::Bool (),
+                             "Whether to use the TALA instead of the ALA "
+                             "approximation.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Nondimensional<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Nondimensional model");
+        {
+          reference_rho   = prm.get_double ("Reference density");
+          exponential_viscosity_temperature_prefactor = prm.get_double ("Viscosity temperature prefactor");
+          exponential_viscosity_depth_prefactor = prm.get_double ("Viscosity depth prefactor");
+          Di              = prm.get_double ("Di");
+          Ra              = prm.get_double ("Ra");
+          gamma           = prm.get_double ("gamma");
+          tala            = prm.get_bool ("Use TALA");
+          reference_specific_heat = prm.get_double ("Reference specific heat");
+
+          compressible = (Di!=0.0);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature;
+      this->model_dependence.density = NonlinearDependence::pressure | NonlinearDependence::temperature;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Nondimensional,
+                                   "nondimensional",
+                                   "A material model for nondimensionalized "
+                                   "computations for compressible or incompressible "
+                                   "computations defined through Rayleigh number \text{Ra} "
+                                   "and Dissipation number Di. This model is made "
+                                   "to be used with the Boussinesq, ALA, or TALA "
+                                   "formulation."
+                                   "\n\n"
+                                   "The viscosity is defined as $\\eta = \\text{Di} / \\text{Ra} \\cdot \\exp(-b T^\\prime + c z)$ "
+                                   "where $T^\\prime$ is the temperature variation from the "
+                                   "adiabatic temperature, $z$ is the depth, "
+                                   "$b$ is given by ``Viscosity temperature prefactor'', "
+                                   "and $c$ by ``Viscosity depth prefactor''. If "
+                                   "$\\text{Di}$ is zero, it will be replaced by 1.0 in $\\eta$."
+                                   "\n\n"
+                                   "The density is defined as $\\rho = \\exp(\\text{Di}/\\gamma \\cdot z) "
+                                   " (1.0 - \\alpha T^\\prime + \\text{Di} \\gamma p^\\prime),$ where "
+                                   "$\\alpha=\\text{Di}$ is the thermal expansion coefficient, "
+                                   "$\\gamma$ is the Grueneisen parameter, and $p^\\prime$ is "
+                                   "the pressure variation from the adiabatic "
+                                   "pressure. The pressure dependent term is not present "
+                                   "if ``TALA'' is enabled.")
+  }
+}
diff --git a/source/material_model/perplex_lookup.cc.bak b/source/material_model/perplex_lookup.cc.bak
new file mode 100644
index 00000000000..46daf562cf7
--- /dev/null
+++ b/source/material_model/perplex_lookup.cc.bak
@@ -0,0 +1,230 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/perplex_lookup.h>
+
+#ifdef ASPECT_WITH_PERPLEX
+extern "C" {
+#include <perplex_c.h>
+}
+#include <deal.II/base/multithread_info.h>
+#endif
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    PerpleXLookup<dim>::initialize()
+    {
+#ifdef ASPECT_WITH_PERPLEX
+      AssertThrow(dealii::MultithreadInfo::is_running_single_threaded(),
+                  ExcMessage("The PerpleXLookup MaterialModel only works in single threaded mode (do not use -j)!"));
+
+      ini_phaseq(perplex_file_name.c_str()); // this line initializes meemum
+#else
+      Assert (false, ExcMessage("ASPECT has not been compiled with the PerpleX libraries"));
+#endif
+    }
+
+    template <int dim>
+    bool
+    PerpleXLookup<dim>::
+    is_compressible () const
+    {
+      return true;
+    }
+
+    template <int dim>
+    void
+    PerpleXLookup<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      /* Instead of evaluating at every quadrature point per cell,
+       * we here average the P, T and X values, and evaluate once.
+       * This is much quicker than evaluating at all quadrature
+       * points, and if the grid is fine, it should be a reasonable
+       * approximation
+       */
+
+#ifdef ASPECT_WITH_PERPLEX
+      std::vector<double> wtphases(p_size_phases);
+      std::vector<double> cphases(p_size_phases * p_size_components);
+      std::vector<char> namephases(p_size_phases * p_pname_len);
+      std::vector<double> sysprop(p_size_sysprops);
+
+      int phaseq_dbg = 0;
+
+      unsigned int n_quad = in.n_evaluation_points(); // number of quadrature points in cell
+      unsigned int n_comp = in.composition[0].size(); // number of components in rock
+
+      const double average_temperature = std::min(max_temperature,
+                                                  std::max(min_temperature,
+                                                           (accumulate( in.temperature.begin(), in.temperature.end(), 0.0) /
+                                                            n_quad)));
+      const double average_pressure = std::min(max_pressure,
+                                               std::max(min_pressure,
+                                                        (accumulate( in.pressure.begin(), in.pressure.end(), 0.0) /
+                                                         n_quad)));
+
+      std::vector<double> comp;
+      comp.resize(n_comp);
+
+      for (unsigned int c=0; c<n_comp; ++c)
+        {
+          for (unsigned int i=0; i<n_quad; ++i)
+            {
+              comp[c] += in.composition[i][c];
+              out.reaction_terms[i][c] = 0.0;
+            }
+          comp[c] /= (double)n_quad;
+        }
+
+      // Here is the call to PerpleX/meemum
+      int nphases;
+
+      phaseq(average_pressure/1.e5, average_temperature,
+             n_comp, comp.data(), &nphases, wtphases.data(), cphases.data(),
+             sysprop.data(), namephases.data(), phaseq_dbg);
+
+      AssertThrow(!isnan(sysprop[9]) && !isnan(sysprop[11]) && !isnan(sysprop[12]) && !isnan(sysprop[13]),
+                  ExcMessage("PerpleX returned NaN for at least one material property at " +
+                             std::to_string(average_pressure) +" bar, " +
+                             std::to_string(average_temperature) + " K. Aborting. " +
+                             "Please adjust the P-T bounds in the parameter file or adjust the PerpleX files."));
+
+      for (unsigned int i=0; i<n_quad; ++i)
+        {
+          out.viscosities[i] = eta;
+          out.thermal_conductivities[i] = k_value;
+          out.densities[i] = sysprop[9];
+          out.specific_heat[i] = sysprop[11]*(1000./sysprop[16]); // molar Cp * (1000/molar mass) (g)
+          out.thermal_expansion_coefficients[i] = sysprop[12];
+          out.compressibilities[i] = sysprop[13]*1.e5;
+        }
+#else
+      (void)in;
+      (void)out;
+      Assert (false, ExcMessage("ASPECT has not been compiled with the PerpleX libraries"));
+#endif
+
+    }
+
+
+    template <int dim>
+    void
+    PerpleXLookup<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("PerpleX lookup model");
+        {
+
+          prm.declare_entry ("PerpleX input file name", "rock.dat",
+                             Patterns::Anything (),
+                             "The name of the PerpleX input file (should end with .dat).");
+          prm.declare_entry ("Viscosity", "5e24",
+                             Patterns::Double (0.),
+                             "The value of the viscosity $\\eta$. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Minimum material temperature", "0.",
+                             Patterns::Double (0.),
+                             "The value of the minimum temperature used to query PerpleX. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Maximum material temperature", "6000.",
+                             Patterns::Double (0.),
+                             "The value of the maximum temperature used to query PerpleX. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Minimum material pressure", "1.e5",
+                             Patterns::Double (0.),
+                             "The value of the minimum pressure used to query PerpleX. "
+                             "Units: \\si{\\pascal}.");
+          prm.declare_entry ("Maximum material pressure", "1.e12",
+                             Patterns::Double (0.),
+                             "The value of the maximum pressure used to query PerpleX. "
+                             "Units: \\si{\\pascal}.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    PerpleXLookup<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("PerpleX lookup model");
+        {
+          perplex_file_name   = prm.get ("PerpleX input file name");
+          eta                 = prm.get_double ("Viscosity");
+          k_value             = prm.get_double ("Thermal conductivity");
+          min_temperature     = prm.get_double ("Minimum material temperature");
+          max_temperature     = prm.get_double ("Maximum material temperature");
+          min_pressure        = prm.get_double ("Minimum material pressure");
+          max_pressure        = prm.get_double ("Maximum material pressure");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+
+      this->model_dependence.density = NonlinearDependence::temperature
+                                       | NonlinearDependence::pressure
+                                       | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::temperature
+                                               | NonlinearDependence::pressure
+                                               | NonlinearDependence::compositional_fields;
+      this->model_dependence.specific_heat = NonlinearDependence::temperature
+                                             | NonlinearDependence::pressure
+                                             | NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(PerpleXLookup,
+                                   "perplex lookup",
+                                   "A material model that has constant values "
+                                   "for viscosity and thermal conductivity, and "
+                                   "calculates other properties on-the-fly using "
+                                   "PerpleX meemum. Compositional fields correspond "
+                                   "to the individual components in the order given "
+                                   "in the PerpleX file.")
+  }
+}
diff --git a/source/material_model/prescribed_viscosity.cc.bak b/source/material_model/prescribed_viscosity.cc.bak
new file mode 100644
index 00000000000..25f647ae177
--- /dev/null
+++ b/source/material_model/prescribed_viscosity.cc.bak
@@ -0,0 +1,210 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/prescribed_viscosity.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    PrescribedViscosity<dim>::initialize()
+    {
+      base_model->initialize();
+    }
+
+
+
+    template <int dim>
+    void
+    PrescribedViscosity<dim>::update()
+    {
+      base_model->update();
+
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      const double time = this->convert_output_to_years() ? this->get_time() / year_in_seconds : this->get_time();
+      prescribed_viscosity_indicator_function.set_time (time);
+      prescribed_viscosity_function.set_time (time);
+    }
+
+
+
+    template <int dim>
+    void
+    PrescribedViscosity<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                                       typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      base_model->evaluate(in,out);
+      for (unsigned int i=0; i<out.n_evaluation_points(); ++i)
+        {
+          if (in.requests_property(MaterialProperties::viscosity))
+            {
+              const double indicator = prescribed_viscosity_indicator_function.value(in.position[i]);
+
+              if (indicator > 0.5)
+                {
+                  out.viscosities[i] = prescribed_viscosity_function.value(in.position[i]);
+                }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    PrescribedViscosity<dim>::
+    is_compressible () const
+    {
+      return base_model->is_compressible();
+    }
+
+
+
+    template <int dim>
+    void
+    PrescribedViscosity<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Prescribed viscosity");
+        {
+
+          prm.declare_entry("Base model","simple",
+                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
+                            "The name of a material model that will be modified by the prescribed "
+                            "viscosity material model. Valid values for this parameter "
+                            "are the names of models that are also valid for the "
+                            "``Material models/Model name'' parameter. See the documentation for "
+                            "that for more information.");
+
+          prm.enter_subsection ("Indicator function");
+          {
+            Functions::ParsedFunction<dim>::declare_parameters (prm, 3);
+          }
+          prm.leave_subsection ();
+
+          prm.enter_subsection ("Viscosity function");
+          {
+            Functions::ParsedFunction<dim>::declare_parameters (prm, 3);
+          }
+          prm.leave_subsection ();
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+
+    template <int dim>
+    void
+    PrescribedViscosity<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Prescribed viscosity");
+        {
+          AssertThrow( prm.get("Base model") != "prescribed viscosity",
+                       ExcMessage("You may not use ``prescribed viscosity'' as the base model for "
+                                  "a prescribed viscosity model.") );
+
+          // create the base model and initialize its SimulatorAccess base
+          // class; it will get a chance to read its parameters below after we
+          // leave the current section
+          base_model = create_material_model<dim>(prm.get("Base model"));
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
+            sim->initialize_simulator (this->get_simulator());
+
+          prm.enter_subsection("Indicator function");
+          {
+            try
+              {
+                prescribed_viscosity_indicator_function.parse_parameters (prm);
+              }
+            catch (...)
+              {
+                std::cerr << "ERROR: FunctionParser failed to parse\n"
+                          << "\t'Prescribed viscosity.Indicator function'\n"
+                          << "with expression\n"
+                          << "\t'" << prm.get("Function expression") << "'";
+                throw;
+              }
+          }
+          prm.leave_subsection();
+
+          prm.enter_subsection("Viscosity function");
+          {
+            try
+              {
+                prescribed_viscosity_function.parse_parameters (prm);
+              }
+            catch (...)
+              {
+                std::cerr << "ERROR: FunctionParser failed to parse\n"
+                          << "\t'Prescribed viscosity.Viscosity function'\n"
+                          << "with expression\n"
+                          << "\t'" << prm.get("Function expression") << "'";
+                throw;
+              }
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      /* After parsing the parameters for prescribed viscosity, it is essential to parse
+      parameters related to the base model. */
+      base_model->parse_parameters(prm);
+      this->model_dependence = base_model->get_model_dependence();
+    }
+
+
+
+    template <int dim>
+    void
+    PrescribedViscosity<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      base_model->create_additional_named_outputs(out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedViscosity,
+                                   "prescribed viscosity",
+                                   "A material model that applies a viscosity to a ''base model'' chosen from any of "
+                                   "the other available material models. This prescribed viscosity material model "
+                                   "allows the user to specify a function which describes where the viscosity should be "
+                                   "prescribed and a second function which describes the viscosity in that region. "
+                                   "This material model requires a base model which prescribes the viscosity and the "
+                                   "other material parameters in the rest of the model."
+                                  )
+  }
+}
diff --git a/source/material_model/reaction_model/katz2003_mantle_melting.cc.bak b/source/material_model/reaction_model/katz2003_mantle_melting.cc.bak
new file mode 100644
index 00000000000..71993bc7ea7
--- /dev/null
+++ b/source/material_model/reaction_model/katz2003_mantle_melting.cc.bak
@@ -0,0 +1,651 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/reaction_model/katz2003_mantle_melting.h>
+#include <aspect/utilities.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace ReactionModel
+    {
+
+
+      template <int dim>
+      Katz2003MantleMelting<dim>::Katz2003MantleMelting()
+        = default;
+
+
+
+      template <int dim>
+      double
+      Katz2003MantleMelting<dim>::
+      reference_darcy_coefficient () const
+      {
+        // 0.01 = 1% melt
+        return reference_permeability * std::pow(0.01,3.0) / viscosity_fluid;
+      }
+
+
+      template <int dim>
+      double
+      Katz2003MantleMelting<dim>::
+      melt_fraction (const double temperature,
+                     const double pressure) const
+      {
+        // anhydrous melting of peridotite after Katz, 2003
+        const double T_solidus  = A1 + 273.15
+                                  + A2 * pressure
+                                  + A3 * pressure * pressure;
+        const double T_lherz_liquidus = B1 + 273.15
+                                        + B2 * pressure
+                                        + B3 * pressure * pressure;
+        const double T_liquidus = C1 + 273.15
+                                  + C2 * pressure
+                                  + C3 * pressure * pressure;
+
+        // melt fraction for peridotite with clinopyroxene
+        double peridotite_melt_fraction;
+        if (temperature < T_solidus || pressure > 1.3e10)
+          peridotite_melt_fraction = 0.0;
+        else if (temperature > T_lherz_liquidus)
+          peridotite_melt_fraction = 1.0;
+        else
+          peridotite_melt_fraction = std::pow((temperature - T_solidus) / (T_lherz_liquidus - T_solidus),beta);
+
+        // melt fraction after melting of all clinopyroxene
+        const double R_cpx = r1 + r2 * std::max(0.0, pressure);
+        const double F_max = M_cpx / R_cpx;
+
+        if (peridotite_melt_fraction > F_max && temperature < T_liquidus)
+          {
+            const double T_max = std::pow(F_max,1/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
+            peridotite_melt_fraction = F_max + (1 - F_max) * pow((temperature - T_max) / (T_liquidus - T_max),beta);
+          }
+        return peridotite_melt_fraction;
+      }
+
+
+
+      template <int dim>
+      double
+      Katz2003MantleMelting<dim>::
+      entropy_change (const double temperature,
+                      const double pressure,
+                      const double maximum_melt_fraction,
+                      const NonlinearDependence::Dependence dependence) const
+      {
+        double entropy_gradient = 0.0;
+
+        // calculate latent heat of melting
+        // we need the change of melt fraction in dependence of pressure and temperature
+
+        // for peridotite after Katz, 2003
+        const double T_solidus        = A1 + 273.15
+                                        + A2 * pressure
+                                        + A3 * pressure * pressure;
+        const double T_lherz_liquidus = B1 + 273.15
+                                        + B2 * pressure
+                                        + B3 * pressure * pressure;
+        const double T_liquidus       = C1 + 273.15
+                                        + C2 * pressure
+                                        + C3 * pressure * pressure;
+
+        const double dT_solidus_dp        = A2 + 2 * A3 * pressure;
+        const double dT_lherz_liquidus_dp = B2 + 2 * B3 * pressure;
+        const double dT_liquidus_dp       = C2 + 2 * C3 * pressure;
+
+        if (temperature > T_solidus && temperature < T_liquidus && pressure < 1.3e10)
+          {
+            // melt fraction when clinopyroxene is still present
+            double melt_fraction_derivative_temperature
+              = beta * pow((temperature - T_solidus)/(T_lherz_liquidus - T_solidus),beta-1)
+                / (T_lherz_liquidus - T_solidus);
+
+            double melt_fraction_derivative_pressure
+              = beta * pow((temperature - T_solidus)/(T_lherz_liquidus - T_solidus),beta-1)
+                * (dT_solidus_dp * (temperature - T_lherz_liquidus)
+                   + dT_lherz_liquidus_dp * (T_solidus - temperature))
+                / pow(T_lherz_liquidus - T_solidus,2);
+
+            // melt fraction after melting of all clinopyroxene
+            const double R_cpx = r1 + r2 * std::max(0.0, pressure);
+            const double F_max = M_cpx / R_cpx;
+
+            if (melt_fraction(temperature, pressure) > F_max)
+              {
+                const double T_max = std::pow(F_max,1.0/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
+                const double dF_max_dp = - M_cpx * std::pow(r1 + r2 * pressure,-2) * r2;
+                const double dT_max_dp = dT_solidus_dp
+                                         + 1.0/beta * std::pow(F_max,1.0/beta - 1.0) * dF_max_dp * (T_lherz_liquidus - T_solidus)
+                                         + std::pow(F_max,1.0/beta) * (dT_lherz_liquidus_dp - dT_solidus_dp);
+
+                melt_fraction_derivative_temperature
+                  = (1.0 - F_max) * beta * std::pow((temperature - T_max)/(T_liquidus - T_max),beta-1)
+                    / (T_liquidus - T_max);
+
+                melt_fraction_derivative_pressure
+                  = dF_max_dp
+                    - dF_max_dp * std::pow((temperature - T_max)/(T_liquidus - T_max),beta)
+                    + (1.0 - F_max) * beta * std::pow((temperature - T_max)/(T_liquidus - T_max),beta-1)
+                    * (dT_max_dp * (T_max - T_liquidus) - (dT_liquidus_dp - dT_max_dp) * (temperature - T_max)) / std::pow(T_liquidus - T_max, 2);
+              }
+
+            double melt_fraction_derivative = 0;
+            if (dependence == NonlinearDependence::temperature)
+              melt_fraction_derivative = melt_fraction_derivative_temperature;
+            else if (dependence == NonlinearDependence::pressure)
+              melt_fraction_derivative = melt_fraction_derivative_pressure;
+            else
+              AssertThrow(false, ExcMessage("not implemented"));
+
+            if (melt_fraction(temperature, pressure) >= maximum_melt_fraction)
+              entropy_gradient = melt_fraction_derivative * peridotite_melting_entropy_change;
+          }
+        return entropy_gradient;
+      }
+
+
+
+      template <int dim>
+      void
+      Katz2003MantleMelting<dim>::
+      calculate_reaction_rate_outputs(const typename Interface<dim>::MaterialModelInputs &in,
+                                      typename Interface<dim>::MaterialModelOutputs &out) const
+      {
+        ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
+
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+
+            if (this->include_melt_transport())
+              {
+                const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+                const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
+                const double old_porosity = in.composition[i][porosity_idx];
+                const double maximum_melt_fraction = in.composition[i][peridotite_idx];
+
+                // calculate the melting rate as difference between the equilibrium melt fraction
+                // and the solution of the previous time step
+                double porosity_change = 0.0;
+                if (fractional_melting)
+                  {
+                    // solidus is lowered by previous melting events (fractional melting)
+                    const double solidus_change = (maximum_melt_fraction - old_porosity) * depletion_solidus_change;
+                    const double eq_melt_fraction = melt_fraction(in.temperature[i] - solidus_change, this->get_adiabatic_conditions().pressure(in.position[i]));
+                    porosity_change = eq_melt_fraction - old_porosity;
+                  }
+                else
+                  {
+                    // batch melting
+                    porosity_change = melt_fraction(in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]))
+                                      - std::max(maximum_melt_fraction, 0.0);
+                    porosity_change = std::max(porosity_change, 0.0);
+
+                    // freezing of melt below the solidus
+
+                    // If the porosity is larger than the equilibrium melt fraction, melt should freeze again.
+                    // Because we do not track the melt composition, we have to use a workaround here for freezing of melt:
+                    // We reduce the porosity until either it reaches the equilibrium melt fraction, or the depletion
+                    // (peridotite field), which decreases as melt freezes, reaches the same value as the equilibrium
+                    // melt fraction, whatever happens earlier. An exception is when the melt fraction is zero; in this case
+                    // all melt should freeze.
+                    const double eq_melt_fraction = melt_fraction(in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]));
+
+                    // If the porosity change is not negative, there is no freezing, and the change in porosity
+                    // is covered by the melting relation above.
+
+                    // porosity reaches the equilibrium melt fraction:
+                    const double porosity_change_wrt_melt_fraction = std::min(eq_melt_fraction - old_porosity - porosity_change,0.0);
+
+                    // depletion reaches the equilibrium melt fraction:
+                    const double porosity_change_wrt_depletion = std::min((eq_melt_fraction - std::max(maximum_melt_fraction, 0.0))
+                                                                          * (1.0 - old_porosity) / (1.0 - maximum_melt_fraction),0.0);
+                    double freezing_amount = std::max(porosity_change_wrt_melt_fraction, porosity_change_wrt_depletion);
+
+                    if (eq_melt_fraction == 0.0)
+                      freezing_amount = - old_porosity;
+
+                    porosity_change += freezing_amount;
+
+                    // Adapt time scale of freezing with respect to melting.
+                    // We have to multiply with the melting time scale here to obtain the porosity change
+                    // that happens in the time defined by the melting time scale (as opposed to a rate).
+                    // This is important because we want to perform some checks on this quantity (for example,
+                    // we want to make sure that this change does not lead to a negative porosity, see below).
+                    // Later on, the overall porosity change is then divided again by the melting time scale
+                    // to obtain the rate of melting or freezing, which is used in the operator splitting scheme.
+                    if (porosity_change < 0 )
+                      porosity_change *= freezing_rate * melting_time_scale;
+
+                  }
+
+                // remove melt that gets close to the surface
+                if (this->get_geometry_model().depth(in.position[i]) < extraction_depth)
+                  porosity_change = -old_porosity * (in.position[i](1) - (this->get_geometry_model().maximal_depth() - extraction_depth))/extraction_depth;
+
+                // do not allow negative porosity
+                porosity_change = std::max(porosity_change, -old_porosity);
+
+                // because depletion is a volume-based, and not a mass-based property that is advected,
+                // additional scaling factors on the right hand side apply
+                for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                  {
+                    // fill reaction rate outputs
+                    if (reaction_rate_out != nullptr && in.requests_property(MaterialProperties::reaction_rates))
+                      {
+                        if (c == peridotite_idx && this->get_timestep_number() > 0)
+                          reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale * (1 - maximum_melt_fraction) / (1 - old_porosity);
+                        else if (c == porosity_idx && this->get_timestep_number() > 0)
+                          reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale;
+                        else
+                          reaction_rate_out->reaction_rates[i][c] = 0.0;
+                      }
+                    out.reaction_terms[i][c] = 0.0;
+                  }
+
+                out.entropy_derivative_pressure[i]    = entropy_change (in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]), maximum_melt_fraction, NonlinearDependence::pressure);
+                out.entropy_derivative_temperature[i] = entropy_change (in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]), maximum_melt_fraction, NonlinearDependence::temperature);
+              }
+            else
+              {
+                out.entropy_derivative_pressure[i]    = entropy_change (in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]), 0, NonlinearDependence::pressure);
+                out.entropy_derivative_temperature[i] = entropy_change (in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]), 0, NonlinearDependence::temperature);
+
+                // no melting/freezing is used in the model --> set all reactions to zero
+                for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                  {
+                    out.reaction_terms[i][c] = 0.0;
+
+                    if (reaction_rate_out != nullptr)
+                      reaction_rate_out->reaction_rates[i][c] = 0.0;
+                  }
+              }
+          }
+
+      }
+
+
+      template <int dim>
+      void
+      Katz2003MantleMelting<dim>::
+      calculate_fluid_outputs(const typename Interface<dim>::MaterialModelInputs &in,
+                              typename Interface<dim>::MaterialModelOutputs &out,
+                              const double reference_T) const
+      {
+        MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
+        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+        if (melt_out != nullptr)
+          {
+
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                double porosity = std::max(in.composition[i][porosity_idx],0.0);
+
+                melt_out->fluid_viscosities[i] = viscosity_fluid;
+                melt_out->permeabilities[i] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+
+                // first, calculate temperature dependence of density
+                double temperature_dependence = 1.0;
+                if (this->include_adiabatic_heating ())
+                  {
+                    // temperature dependence is 1 - alpha * (T - T(adiabatic))
+                    temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]))
+                                              * out.thermal_expansion_coefficients[i];
+                  }
+                else
+                  temperature_dependence -= (in.temperature[i] - reference_T) * out.thermal_expansion_coefficients[i];
+
+                // the fluid compressibility includes two parts, a constant compressibility, and a pressure-dependent one
+                // this is a simplified formulation, experimental data are often fit to the Birch-Murnaghan equation of state
+                const double fluid_compressibility = melt_compressibility / (1.0 + in.pressure[i] * melt_bulk_modulus_derivative * melt_compressibility);
+
+                melt_out->fluid_densities[i] = reference_rho_fluid * std::exp(fluid_compressibility * (in.pressure[i] - this->get_surface_pressure()))
+                                               * temperature_dependence;
+
+                melt_out->fluid_density_gradients[i] = melt_out->fluid_densities[i] * melt_out->fluid_densities[i]
+                                                       * fluid_compressibility
+                                                       * this->get_gravity_model().gravity_vector(in.position[i]);
+
+                const double phi_0 = 0.05;
+                porosity = std::max(std::min(porosity,0.995),1e-4);
+                melt_out->compaction_viscosities[i] = xi_0 * phi_0 / porosity;
+
+                double visc_temperature_dependence = 1.0;
+                if (this->include_adiabatic_heating ())
+                  {
+                    const double delta_temp = in.temperature[i]-this->get_adiabatic_conditions().temperature(in.position[i]);
+                    visc_temperature_dependence = std::max(std::min(std::exp(-thermal_bulk_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[i])),1e4),1e-4);
+                  }
+                else
+                  {
+                    const double delta_temp = in.temperature[i]-reference_T;
+                    const double T_dependence = (thermal_bulk_viscosity_exponent == 0.0
+                                                 ?
+                                                 0.0
+                                                 :
+                                                 thermal_bulk_viscosity_exponent*delta_temp/reference_T);
+                    visc_temperature_dependence = std::max(std::min(std::exp(-T_dependence),1e4),1e-4);
+                  }
+                melt_out->compaction_viscosities[i] *= visc_temperature_dependence;
+
+
+              }
+          }
+
+        if (this->include_melt_transport() && in.requests_property(MaterialProperties::viscosity))
+          {
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                const double porosity = std::min(1.0, std::max(in.composition[i][porosity_idx],0.0));
+                out.viscosities[i] *= exp(- alpha_phi * porosity);
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      Katz2003MantleMelting<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("A1", "1085.7",
+                           Patterns::Double (),
+                           "Constant parameter in the quadratic "
+                           "function that approximates the solidus "
+                           "of peridotite. "
+                           "Units: \\si{\\degreeCelsius}.");
+        prm.declare_entry ("A2", "1.329e-7",
+                           Patterns::Double (),
+                           "Prefactor of the linear pressure term "
+                           "in the quadratic function that approximates "
+                           "the solidus of peridotite. "
+                           "Units: \\si{\\degreeCelsius\\per\\pascal}.");
+        prm.declare_entry ("A3", "-5.1e-18",
+                           Patterns::Double (),
+                           "Prefactor of the quadratic pressure term "
+                           "in the quadratic function that approximates "
+                           "the solidus of peridotite. "
+                           "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
+        prm.declare_entry ("B1", "1475.0",
+                           Patterns::Double (),
+                           "Constant parameter in the quadratic "
+                           "function that approximates the lherzolite "
+                           "liquidus used for calculating the fraction "
+                           "of peridotite-derived melt. "
+                           "Units: \\si{\\degreeCelsius}.");
+        prm.declare_entry ("B2", "8.0e-8",
+                           Patterns::Double (),
+                           "Prefactor of the linear pressure term "
+                           "in the quadratic function that approximates "
+                           "the  lherzolite liquidus used for "
+                           "calculating the fraction of peridotite-"
+                           "derived melt. "
+                           "Units: \\si{\\degreeCelsius\\per\\pascal}.");
+        prm.declare_entry ("B3", "-3.2e-18",
+                           Patterns::Double (),
+                           "Prefactor of the quadratic pressure term "
+                           "in the quadratic function that approximates "
+                           "the  lherzolite liquidus used for "
+                           "calculating the fraction of peridotite-"
+                           "derived melt. "
+                           "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
+        prm.declare_entry ("C1", "1780.0",
+                           Patterns::Double (),
+                           "Constant parameter in the quadratic "
+                           "function that approximates the liquidus "
+                           "of peridotite. "
+                           "Units: \\si{\\degreeCelsius}.");
+        prm.declare_entry ("C2", "4.50e-8",
+                           Patterns::Double (),
+                           "Prefactor of the linear pressure term "
+                           "in the quadratic function that approximates "
+                           "the liquidus of peridotite. "
+                           "Units: \\si{\\degreeCelsius\\per\\pascal}.");
+        prm.declare_entry ("C3", "-2.0e-18",
+                           Patterns::Double (),
+                           "Prefactor of the quadratic pressure term "
+                           "in the quadratic function that approximates "
+                           "the liquidus of peridotite. "
+                           "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
+        prm.declare_entry ("r1", "0.5",
+                           Patterns::Double (),
+                           "Constant in the linear function that "
+                           "approximates the clinopyroxene reaction "
+                           "coefficient. "
+                           "Units: non-dimensional.");
+        prm.declare_entry ("r2", "8e-11",
+                           Patterns::Double (),
+                           "Prefactor of the linear pressure term "
+                           "in the linear function that approximates "
+                           "the clinopyroxene reaction coefficient. "
+                           "Units: \\si{\\per\\pascal}.");
+        prm.declare_entry ("beta", "1.5",
+                           Patterns::Double (),
+                           "Exponent of the melting temperature in "
+                           "the melt fraction calculation. "
+                           "Units: non-dimensional.");
+        prm.declare_entry ("Mass fraction cpx", "0.15",
+                           Patterns::Double (),
+                           "Mass fraction of clinopyroxene in the "
+                           "peridotite to be molten. "
+                           "Units: non-dimensional.");
+        prm.declare_entry ("Peridotite melting entropy change", "-300.",
+                           Patterns::Double (),
+                           "The entropy change for the phase transition "
+                           "from solid to melt of peridotite. "
+                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+        prm.declare_entry ("Reference melt density", "2500.",
+                           Patterns::Double (0.),
+                           "Reference density of the melt/fluid$\\rho_{f,0}$. "
+                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+        prm.declare_entry ("Reference bulk viscosity", "1e22",
+                           Patterns::Double (0.),
+                           "The value of the constant bulk viscosity $\\xi_0$ of the solid matrix. "
+                           "This viscosity may be modified by both temperature and porosity "
+                           "dependencies. Units: \\si{\\pascal\\second}.");
+        prm.declare_entry ("Reference melt viscosity", "10.",
+                           Patterns::Double (0.),
+                           "The value of the constant melt viscosity $\\viscosity_fluid$. Units: \\si{\\pascal\\second}.");
+        prm.declare_entry ("Exponential melt weakening factor", "27.",
+                           Patterns::Double (0.),
+                           "The porosity dependence of the viscosity. Units: dimensionless.");
+        prm.declare_entry ("Thermal bulk viscosity exponent", "0.0",
+                           Patterns::Double (0.),
+                           "The temperature dependence of the bulk viscosity. Dimensionless exponent. "
+                           "See the general documentation "
+                           "of this model for a formula that states the dependence of the "
+                           "viscosity on this factor, which is called $\\beta$ there.");
+        prm.declare_entry ("Melt extraction depth", "1000.0",
+                           Patterns::Double (0.),
+                           "Depth above that melt will be extracted from the model, "
+                           "which is done by a negative reaction term proportional to the "
+                           "porosity field. "
+                           "Units: \\si{\\meter}.");
+        prm.declare_entry ("Melt compressibility", "0.0",
+                           Patterns::Double (0.),
+                           "The value of the compressibility of the melt. "
+                           "Units: \\si{\\per\\pascal}.");
+        prm.declare_entry ("Melt bulk modulus derivative", "0.0",
+                           Patterns::Double (0.),
+                           "The value of the pressure derivative of the melt bulk "
+                           "modulus. "
+                           "Units: None.");
+        prm.declare_entry ("Use fractional melting", "false",
+                           Patterns::Bool (),
+                           "If fractional melting should be used (if true), including a solidus "
+                           "change based on depletion (in this case, the amount of melt that has "
+                           "migrated away from its origin), and freezing of melt when it has moved "
+                           "to a region with temperatures lower than the solidus; or if batch "
+                           "melting should be used (if false), assuming that the melt fraction only "
+                           "depends on temperature and pressure, and how much melt has already been "
+                           "generated at a given point, but not considering movement of melt in "
+                           "the melting parameterization."
+                           "\n\n"
+                           "Note that melt does not freeze unless the 'Freezing rate' parameter is set "
+                           "to a value larger than 0.");
+        prm.declare_entry ("Freezing rate", "0.0",
+                           Patterns::Double (0.),
+                           "Freezing rate of melt when in subsolidus regions. "
+                           "If this parameter is set to a number larger than 0.0, it specifies the "
+                           "fraction of melt that will freeze per year (or per second, depending on the "
+                           "``Use years in output instead of seconds'' parameter), as soon as the porosity "
+                           "exceeds the equilibrium melt fraction, and the equilibrium melt fraction "
+                           "falls below the depletion. In this case, melt will freeze according to the "
+                           "given rate until one of those conditions is not fulfilled anymore. The "
+                           "reasoning behind this is that there should not be more melt present than "
+                           "the equilibrium melt fraction, as melt production decreases with increasing "
+                           "depletion, but the freezing process of melt also reduces the depletion by "
+                           "the same amount, and as soon as the depletion falls below the equilibrium "
+                           "melt fraction, we expect that material should melt again (no matter how "
+                           "much melt is present). This is quite a simplification and not a realistic "
+                           "freezing parameterization, but without tracking the melt composition, there "
+                           "is no way to compute freezing rates accurately. "
+                           "If this parameter is set to zero, no freezing will occur. "
+                           "Note that freezing can never be faster than determined by the "
+                           "``Melting time scale for operator splitting''. The product of the "
+                           "``Freezing rate'' and the ``Melting time scale for operator splitting'' "
+                           "defines how fast freezing occurs with respect to melting (if the "
+                           "product is 0.5, melting will occur twice as fast as freezing). "
+                           "Units: 1/yr or 1/s, depending on the ``Use years "
+                           "in output instead of seconds'' parameter.");
+        prm.declare_entry ("Melting time scale for operator splitting", "1e3",
+                           Patterns::Double (0.),
+                           "Because the operator splitting scheme is used, the porosity field can not "
+                           "be set to a new equilibrium melt fraction instantly, but the model has to "
+                           "provide a melting time scale instead. This time scale defines how fast melting "
+                           "happens, or more specifically, the parameter defines the time after which "
+                           "the deviation of the porosity from the equilibrium melt fraction will be "
+                           "reduced to a fraction of $1/e$. So if the melting time scale is small compared "
+                           "to the time step size, the reaction will be so fast that the porosity is very "
+                           "close to the equilibrium melt fraction after reactions are computed. Conversely, "
+                           "if the melting time scale is large compared to the time step size, almost no "
+                           "melting and freezing will occur."
+                           "\n\n"
+                           "Also note that the melting time scale has to be larger than or equal to the reaction "
+                           "time step used in the operator splitting scheme, otherwise reactions can not be "
+                           "computed. "
+                           "Units: yr or s, depending on the ``Use years in output instead of seconds'' parameter.");
+        prm.declare_entry ("Depletion solidus change", "200.0",
+                           Patterns::Double (0.),
+                           "The solidus temperature change for a depletion of 100\\%. For positive "
+                           "values, the solidus gets increased for a positive peridotite field "
+                           "(depletion) and lowered for a negative peridotite field (enrichment). "
+                           "Scaling with depletion is linear. Only active when fractional melting "
+                           "is used. "
+                           "Units: \\si{\\kelvin}.");
+        prm.declare_entry ("Reference permeability", "1e-8",
+                           Patterns::Double(),
+                           "Reference permeability of the solid host rock."
+                           "Units: \\si{\\meter\\squared}.");
+
+
+      }
+
+
+      template <int dim>
+      void
+      Katz2003MantleMelting<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        A1    = prm.get_double ("A1");
+        A2    = prm.get_double ("A2");
+        A3    = prm.get_double ("A3");
+        B1    = prm.get_double ("B1");
+        B2    = prm.get_double ("B2");
+        B3    = prm.get_double ("B3");
+        C1    = prm.get_double ("C1");
+        C2    = prm.get_double ("C2");
+        C3    = prm.get_double ("C3");
+        r1    = prm.get_double ("r1");
+        r2    = prm.get_double ("r2");
+        beta  = prm.get_double ("beta");
+        M_cpx = prm.get_double ("Mass fraction cpx");
+        peridotite_melting_entropy_change
+          = prm.get_double ("Peridotite melting entropy change");
+
+        reference_rho_fluid        = prm.get_double ("Reference melt density");
+        xi_0                       = prm.get_double ("Reference bulk viscosity");
+        viscosity_fluid            = prm.get_double ("Reference melt viscosity");
+        thermal_bulk_viscosity_exponent = prm.get_double ("Thermal bulk viscosity exponent");
+        alpha_phi                  = prm.get_double ("Exponential melt weakening factor");
+        extraction_depth           = prm.get_double ("Melt extraction depth");
+        melt_compressibility       = prm.get_double ("Melt compressibility");
+        fractional_melting         = prm.get_bool ("Use fractional melting");
+        freezing_rate              = prm.get_double ("Freezing rate");
+        melting_time_scale         = prm.get_double ("Melting time scale for operator splitting");
+        melt_bulk_modulus_derivative = prm.get_double ("Melt bulk modulus derivative");
+        depletion_solidus_change   = prm.get_double ("Depletion solidus change");
+        reference_permeability     = prm.get_double ("Reference permeability");
+
+
+        if (this->convert_output_to_years() == true)
+          {
+            melting_time_scale *= year_in_seconds;
+            freezing_rate /= year_in_seconds;
+          }
+
+        AssertThrow(melting_time_scale > 0,
+                    ExcMessage("The Melting time scale for operator splitting must be larger than 0!"));
+
+        if (this->get_parameters().reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
+          {
+            AssertThrow(melting_time_scale >= this->get_parameters().reaction_time_step,
+                        ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
+                                   + " in the operator splitting scheme is too large to compute melting rates! "
+                                   "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
+                                   "operator splitting' chosen in the material model, which is currently "
+                                   + Utilities::to_string(melting_time_scale) + "."));
+
+            AssertThrow(freezing_rate * this->get_parameters().reaction_time_step <= 1.0,
+                        ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
+                                   + " in the operator splitting scheme is too large to compute freezing rates! "
+                                   "You have to choose it in such a way that it is smaller than the inverse of the "
+                                   "'Freezing rate' chosen in the material model, which is currently "
+                                   + Utilities::to_string(1.0/freezing_rate) + "."));
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace ReactionModel \
+  { \
+    template class Katz2003MantleMelting<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/reactive_fluid_transport.cc b/source/material_model/reactive_fluid_transport.cc
index 84bd54dc09f..1f2d76610bb 100644
--- a/source/material_model/reactive_fluid_transport.cc
+++ b/source/material_model/reactive_fluid_transport.cc
@@ -123,7 +123,7 @@ namespace aspect
     melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
                     std::vector<double> &melt_fractions) const
     {
-      for (unsigned int q=0; q<in.temperature.size(); ++q)
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
         {
           const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
           switch (fluid_solid_reaction_scheme)
diff --git a/source/material_model/reactive_fluid_transport.cc.bak b/source/material_model/reactive_fluid_transport.cc.bak
new file mode 100644
index 00000000000..84bd54dc09f
--- /dev/null
+++ b/source/material_model/reactive_fluid_transport.cc.bak
@@ -0,0 +1,585 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/reactive_fluid_transport.h>
+#include <aspect/simulator_access.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/numerics/fe_field_function.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    bool
+    ReactiveFluidTransport<dim>::
+    is_compressible () const
+    {
+      return base_model->is_compressible();
+    }
+
+
+
+    template <int dim>
+    double
+    ReactiveFluidTransport<dim>::
+    reference_darcy_coefficient () const
+    {
+      if (fluid_solid_reaction_scheme == katz2003)
+        {
+          return katz2003_model.reference_darcy_coefficient();
+        }
+      else
+        {
+          // 0.01 = 1% melt
+          return reference_permeability * std::pow(0.01,3.0) / eta_f;
+        }
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    ReactiveFluidTransport<dim>::
+    tian_equilibrium_bound_water_content (const MaterialModel::MaterialModelInputs<dim> &in,
+                                          unsigned int q) const
+    {
+      // Create arrays that will store the values of the polynomials at the current pressure
+      std::vector<double> LR_values(4);
+      std::vector<double> csat_values(4);
+      std::vector<double> Td_values(4);
+
+      // Loop over the four rock types (peridotite, gabbro, MORB, sediment) and the polynomial
+      // coefficients to fill the vectors defined above. The polynomials for LR are defined in
+      // equations 13, B2, B10, and B18. csat polynomials are defined in equations 14, B1, B9, and B17.
+      // Td polynomials are defined in equations 15, B3, B11, and B19.
+      for (unsigned int i = 0; i<devolatilization_enthalpy_changes.size(); ++i)
+        {
+          // Pressure, which must be in GPa for the parametrization, or GPa^-1. The polynomials for each lithology
+          // breaks down above certain pressures, make sure that we cap the pressure just before this break down.
+          // Introduce minimum pressure to avoid a division by 0.
+          const double minimum_pressure = 1e-12;
+          const double pressure = std::min(std::max(minimum_pressure, in.pressure[q]/1.e9), pressure_cutoffs[i]);
+          const double inverse_pressure = 1.0/pressure;
+          for (unsigned int j = 0; j<devolatilization_enthalpy_changes[i].size(); ++j)
+            {
+              LR_values[i] += devolatilization_enthalpy_changes[i][j] * std::pow(inverse_pressure, devolatilization_enthalpy_changes[i].size() - 1 - j);
+            }
+
+          for (unsigned int j = 0; j<water_mass_fractions[i].size(); ++j)
+            {
+              csat_values[i] += i==3 ? water_mass_fractions[i][j] * std::pow(std::log10(pressure), water_mass_fractions[i].size() - 1 - j) :\
+                                water_mass_fractions[i][j] * std::pow(pressure, water_mass_fractions[i].size() - 1 - j);
+            }
+
+          for (unsigned int j = 0; j<devolatilization_onset_temperatures[i].size(); ++j)
+            {
+              Td_values[i] += devolatilization_onset_temperatures[i][j] * std::pow(pressure, devolatilization_onset_temperatures[i].size() - 1 - j);
+            }
+        }
+
+      // Create an array for the equilibrium bound water content that is calculated from these polynomials
+      std::vector<double> eq_bound_water_content(4);
+
+      // Define the maximum bound water content allowed for the four different rock compositions
+      std::vector<double> max_bound_water_content = {tian_max_peridotite_water, tian_max_gabbro_water, tian_max_MORB_water, tian_max_sediment_water};
+
+      // Loop over all rock compositions and fill the equilibrium bound water content, divide by 100 to convert
+      // from percentage to fraction (equation 1)
+      for (unsigned int k = 0; k<LR_values.size(); ++k)
+        {
+          eq_bound_water_content[k] = (std::min(std::exp(csat_values[k]) * \
+                                                std::exp(std::exp(LR_values[k]) * (1/in.temperature[q] - 1/Td_values[k])), \
+                                                max_bound_water_content[k]) / 100.0);
+        }
+      return eq_bound_water_content;
+    }
+
+
+
+    template <int dim>
+    void
+    ReactiveFluidTransport<dim>::
+    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                    std::vector<double> &melt_fractions) const
+    {
+      for (unsigned int q=0; q<in.temperature.size(); ++q)
+        {
+          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+          switch (fluid_solid_reaction_scheme)
+            {
+              case no_reaction:
+              {
+                // No reactions occur between the solid and fluid phases,
+                // and the fluid volume fraction (stored in the melt_fractions
+                // vector) is equal to the porosity.
+                melt_fractions[q] = in.composition[q][porosity_idx];
+                break;
+              }
+              case zero_solubility:
+              {
+                // The fluid volume fraction in equilibrium with the solid
+                // at any point (stored in the melt_fractions vector) is
+                // equal to the sum of the bound fluid content and porosity.
+                const unsigned int bound_fluid_idx = this->introspection().compositional_index_for_name("bound_fluid");
+                melt_fractions[q] = in.composition[q][bound_fluid_idx] + in.composition[q][porosity_idx];
+                break;
+              }
+              case tian_approximation:
+              {
+                // The bound fluid content is calculated using parametrized phase
+                // diagrams for four different rock types: sediment, MORB, gabbro, and
+                // peridotite.
+                const unsigned int bound_fluid_idx = this->introspection().compositional_index_for_name("bound_fluid");
+                const unsigned int sediment_idx = this->introspection().compositional_index_for_name("sediment");
+                const unsigned int MORB_idx = this->introspection().compositional_index_for_name("MORB");
+                const unsigned int gabbro_idx = this->introspection().compositional_index_for_name("gabbro");
+                const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
+
+                // Initialize a vector that stores the compositions (mass fractions) for
+                // the four different rock compositions,
+                std::vector<double> tracked_rock_mass_fractions(4);
+                tracked_rock_mass_fractions[0] = (in.composition[q][peridotite_idx]);
+                tracked_rock_mass_fractions[1] = (in.composition[q][gabbro_idx]);
+                tracked_rock_mass_fractions[2] = (in.composition[q][MORB_idx]);
+                tracked_rock_mass_fractions[3] = (in.composition[q][sediment_idx]);
+
+                // The bound water content (water within the solid phase) for the four different rock types
+                std::vector<double> tian_eq_bound_water_content = tian_equilibrium_bound_water_content(in, q);
+
+                // average the water content between the four different rock types
+                double average_eq_bound_water_content = MaterialUtilities::average_value (tracked_rock_mass_fractions, tian_eq_bound_water_content, MaterialUtilities::arithmetic);
+
+                // The fluid volume fraction in equilibrium with the solid (stored in the melt_fractions vector)
+                // is equal to the sum of the porosity and the change in bound fluid content
+                // (current bound fluid - updated average bound fluid).
+                melt_fractions[q] = std::max(in.composition[q][bound_fluid_idx] + in.composition[q][porosity_idx] - average_eq_bound_water_content, 0.0);
+                break;
+              }
+              case katz2003:
+              {
+                melt_fractions[q] = katz2003_model.melt_fraction(in.temperature[q],
+                                                                 this->get_adiabatic_conditions().pressure(in.position[q]));
+                break;
+              }
+              default:
+              {
+                AssertThrow(false, ExcNotImplemented());
+                break;
+              }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    ReactiveFluidTransport<dim>::initialize()
+    {
+      base_model->initialize();
+    }
+
+
+
+    template <int dim>
+    void
+    ReactiveFluidTransport<dim>::update()
+    {
+      base_model->update();
+    }
+
+
+
+    template <int dim>
+    void
+    ReactiveFluidTransport<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                                          typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      base_model->evaluate(in,out);
+
+      if (fluid_solid_reaction_scheme != katz2003)
+        {
+          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+          // Modify the viscosity from the base model based on the presence of fluid.
+          if (in.requests_property(MaterialProperties::viscosity))
+            {
+              // Scale the base model viscosity value based on the porosity.
+              for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
+                {
+                  const double porosity = std::max(in.composition[q][porosity_idx],0.0);
+                  out.viscosities[q] *= (1.0 - porosity) * exp(- alpha_phi * porosity);
+                }
+            }
+
+          // Fill the melt outputs if they exist. Note that the MeltOutputs class was originally
+          // designed for two-phase flow material models in ASPECT that model the flow of melt,
+          // but can be reused for a geofluid of arbitrary composition.
+          MeltOutputs<dim> *fluid_out = out.template get_additional_output<MeltOutputs<dim>>();
+
+          if (fluid_out != nullptr)
+            {
+              for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
+                {
+                  double porosity = std::max(in.composition[q][porosity_idx],0.0);
+
+                  fluid_out->fluid_viscosities[q] = eta_f;
+                  fluid_out->permeabilities[q] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+
+                  fluid_out->fluid_densities[q] = reference_rho_f * std::exp(fluid_compressibility * (in.pressure[q] - this->get_surface_pressure()));
+
+                  if (in.requests_property(MaterialProperties::viscosity))
+                    {
+                      const double phi_0 = 0.05;
+
+                      // Limit the porosity to be no smaller than 1e-8 when
+                      // calculating fluid effects on viscosities.
+                      porosity = std::max(porosity,1e-8);
+                      fluid_out->compaction_viscosities[q] = std::max(std::min(out.viscosities[q] * shear_to_bulk_viscosity_ratio * phi_0/porosity, max_compaction_visc), min_compaction_visc);
+                    }
+                }
+            }
+
+          ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
+
+          // Fill reaction rate outputs if the model uses operator splitting.
+          // Specifically, change the porosity (representing the amount of free fluid)
+          // based on the water solubility and the fluid content.
+          if (this->get_parameters().use_operator_splitting && reaction_rate_out != nullptr)
+            {
+              std::vector<double> eq_free_fluid_fractions(out.n_evaluation_points());
+              melt_fractions(in, eq_free_fluid_fractions);
+
+              for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
+                for (unsigned int c=0; c<in.composition[q].size(); ++c)
+                  {
+                    double porosity_change = eq_free_fluid_fractions[q] - in.composition[q][porosity_idx];
+                    // do not allow negative porosity
+                    if (in.composition[q][porosity_idx] + porosity_change < 0)
+                      porosity_change = -in.composition[q][porosity_idx];
+
+                    if (fluid_solid_reaction_scheme != katz2003)
+                      {
+                        const unsigned int bound_fluid_idx = this->introspection().compositional_index_for_name("bound_fluid");
+                        if (c == bound_fluid_idx && this->get_timestep_number() > 0)
+                          reaction_rate_out->reaction_rates[q][c] = - porosity_change / fluid_reaction_time_scale;
+                        else if (c == porosity_idx && this->get_timestep_number() > 0)
+                          reaction_rate_out->reaction_rates[q][c] = porosity_change / fluid_reaction_time_scale;
+                        else
+                          reaction_rate_out->reaction_rates[q][c] = 0.0;
+                      }
+                    else
+                      {
+                        if (c == porosity_idx && this->get_timestep_number() > 0)
+                          reaction_rate_out->reaction_rates[q][c] = porosity_change / fluid_reaction_time_scale;
+                        else
+                          reaction_rate_out->reaction_rates[q][c] = 0.0;
+                      }
+
+                  }
+            }
+        }
+      else
+        {
+          katz2003_model.calculate_reaction_rate_outputs(in, out);
+          katz2003_model.calculate_fluid_outputs(in, out, reference_T);
+        }
+    }
+
+    template <int dim>
+    void
+    ReactiveFluidTransport<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Reactive Fluid Transport Model");
+        {
+          prm.enter_subsection("Katz 2003 model");
+          {
+            // read in melting model parameters
+            ReactionModel::Katz2003MantleMelting<dim>::declare_parameters(prm);
+          }
+          prm.leave_subsection();
+
+          prm.declare_entry("Base model","visco plastic",
+                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
+                            "The name of a material model incorporating the "
+                            "addition of fluids. Valid values for this parameter "
+                            "are the names of models that are also valid for the "
+                            "``Material models/Model name'' parameter. See the documentation for "
+                            "that for more information.");
+          prm.declare_entry ("Reference fluid density", "2500",
+                             Patterns::Double (0),
+                             "Reference density of the melt/fluid$\\rho_{f,0}$. Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Shear to bulk viscosity ratio", "0.1",
+                             Patterns::Double (0),
+                             "Ratio between shear and bulk viscosity at the reference "
+                             "permeability $\\phi_0=0.05$. The bulk viscosity additionally "
+                             "scales with $\\phi_0/\\phi$. The shear viscosity is read in "
+                             "from the base model. Units: dimensionless.");
+          prm.declare_entry ("Minimum compaction viscosity", "0",
+                             Patterns::Double (0),
+                             "Lower cutoff for the compaction viscosity. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Maximum compaction viscosity",
+                             boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
+                             Patterns::Double (0),
+                             "Upper cutoff for the compaction viscosity. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Reference fluid viscosity", "10",
+                             Patterns::Double (0),
+                             "The value of the constant melt/fluid viscosity $\\eta_f$. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Exponential fluid weakening factor", "27",
+                             Patterns::Double (0),
+                             "The porosity dependence of the viscosity. Units: dimensionless.");
+          prm.declare_entry ("Reference permeability", "1e-8",
+                             Patterns::Double(),
+                             "Reference permeability of the solid host rock."
+                             "Units: \\si{\\meter\\squared}.");
+          prm.declare_entry ("Fluid compressibility", "0.0",
+                             Patterns::Double (0),
+                             "The value of the compressibility of the fluid. "
+                             "Units: \\si{\\per\\pascal}.");
+          prm.declare_entry ("Fluid reaction time scale for operator splitting", "1e3",
+                             Patterns::Double (0),
+                             "In case the operator splitting scheme is used, the porosity field can not "
+                             "be set to a new equilibrium fluid fraction instantly, but the model has to "
+                             "provide a reaction time scale instead. This time scale defines how fast fluid "
+                             "release and absorption happen, or more specifically, the parameter defines the "
+                             "time after which the deviation of the porosity from the free fluid fraction "
+                             "that would be in equilibrium with the solid will be reduced to a fraction of "
+                             "$1/e$. So if the fluid reaction time scale is small compared "
+                             "to the time step size, the reaction will be so fast that the porosity is very "
+                             "close to this equilibrium value after reactions are computed. Conversely, "
+                             "if the fluid reaction time scale is large compared to the time step size, almost no "
+                             "fluid release and absorption will occur."
+                             "\n\n"
+                             "Also note that the fluid reaction time scale has to be larger than or equal to the reaction "
+                             "time step used in the operator splitting scheme, otherwise reactions can not be "
+                             "computed. If the model does not use operator splitting, this parameter is not used. "
+                             "Units: yr or s, depending on the ``Use years "
+                             "in output instead of seconds'' parameter.");
+          prm.declare_entry ("Maximum weight percent water in sediment", "3",
+                             Patterns::Double (0),
+                             "The maximum allowed weight percent that the sediment composition can hold.");
+          prm.declare_entry ("Maximum weight percent water in MORB", "2",
+                             Patterns::Double (0),
+                             "The maximum allowed weight percent that the sediment composition can hold.");
+          prm.declare_entry ("Maximum weight percent water in gabbro", "1",
+                             Patterns::Double (0),
+                             "The maximum allowed weight percent that the sediment composition can hold.");
+          prm.declare_entry ("Maximum weight percent water in peridotite", "8",
+                             Patterns::Double (0),
+                             "The maximum allowed weight percent that the sediment composition can hold.");
+          prm.declare_entry ("Fluid-solid reaction scheme", "no reaction",
+                             Patterns::Selection("no reaction|zero solubility|tian approximation|katz2003"),
+                             "Select what type of scheme to use for reactions between fluid and solid phases. "
+                             "The current available options are models where no reactions occur between "
+                             "the two phases, or the solid phase is insoluble (zero solubility) and all "
+                             "of the bound fluid is released into the fluid phase, tian approximation "
+                             "use polynomials to describe hydration and dehydration reactions for four different "
+                             "rock compositions as defined in Tian et al., 2019, or the Katz et. al. 2003 mantle "
+                             "melting model. If the Katz 2003 melting model is used, its parameters are declared "
+                             "in its own subsection.");
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$ for the katz2003 reaction model. "
+                             "The reference temperature is used in both the density and "
+                             "viscosity formulas of this model. Units: \\si{\\kelvin}.");
+        }
+        prm.leave_subsection();
+
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    ReactiveFluidTransport<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Reactive Fluid Transport Model");
+        {
+          AssertThrow( prm.get("Base model") != "reactive fluid transport",
+                       ExcMessage("You may not use ``reactive fluid transport'' "
+                                  "as the base model for the reactive fluid transport "
+                                  "model itself.") );
+
+          reference_rho_f                   = prm.get_double ("Reference fluid density");
+          shear_to_bulk_viscosity_ratio     = prm.get_double ("Shear to bulk viscosity ratio");
+          max_compaction_visc               = prm.get_double ("Maximum compaction viscosity");
+          min_compaction_visc               = prm.get_double ("Minimum compaction viscosity");
+          eta_f                             = prm.get_double ("Reference fluid viscosity");
+          reference_permeability            = prm.get_double ("Reference permeability");
+          alpha_phi                         = prm.get_double ("Exponential fluid weakening factor");
+          fluid_compressibility             = prm.get_double ("Fluid compressibility");
+          fluid_reaction_time_scale         = prm.get_double ("Fluid reaction time scale for operator splitting");
+          reference_T                       = prm.get_double ("Reference temperature");
+
+          tian_max_peridotite_water         = prm.get_double ("Maximum weight percent water in peridotite");
+          tian_max_gabbro_water             = prm.get_double ("Maximum weight percent water in gabbro");
+          tian_max_MORB_water               = prm.get_double ("Maximum weight percent water in MORB");
+          tian_max_sediment_water           = prm.get_double ("Maximum weight percent water in sediment");
+
+          // Create the base model and initialize its SimulatorAccess base
+          // class; it will get a chance to read its parameters below after we
+          // leave the current section.
+          base_model = create_material_model<dim>(prm.get("Base model"));
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
+            sim->initialize_simulator (this->get_simulator());
+
+          if (this->convert_output_to_years() == true)
+            fluid_reaction_time_scale *= year_in_seconds;
+
+          // Reaction scheme parameter
+          if (prm.get ("Fluid-solid reaction scheme") == "zero solubility")
+            {
+              fluid_solid_reaction_scheme = zero_solubility;
+            }
+          else if (prm.get ("Fluid-solid reaction scheme") == "no reaction")
+            {
+              fluid_solid_reaction_scheme = no_reaction;
+            }
+          else if (prm.get ("Fluid-solid reaction scheme") == "tian approximation")
+            {
+              AssertThrow(this->introspection().compositional_name_exists("sediment"),
+                          ExcMessage("The Tian approximation only works "
+                                     "if there is a compositional field called sediment."));
+              AssertThrow(this->introspection().compositional_name_exists("MORB"),
+                          ExcMessage("The Tian approximation only works "
+                                     "if there is a compositional field called MORB."));
+              AssertThrow(this->introspection().compositional_name_exists("gabbro"),
+                          ExcMessage("The Tian approximation only works "
+                                     "if there is a compositional field called gabbro."));
+              AssertThrow(this->introspection().compositional_name_exists("peridotite"),
+                          ExcMessage("The Tian approximation only works "
+                                     "if there is a compositional field called peridotite."));
+              fluid_solid_reaction_scheme = tian_approximation;
+            }
+          else if (prm.get ("Fluid-solid reaction scheme") == "katz2003")
+            {
+              fluid_solid_reaction_scheme = katz2003;
+              prm.enter_subsection("Katz 2003 model");
+              {
+                katz2003_model.initialize_simulator (this->get_simulator());
+                katz2003_model.parse_parameters(prm);
+              }
+              prm.leave_subsection();
+            }
+          else
+            AssertThrow(false, ExcMessage("Not a valid fluid-solid reaction scheme"));
+
+          if (fluid_solid_reaction_scheme == no_reaction)
+            {
+              AssertThrow(this->get_parameters().use_operator_splitting == false,
+                          ExcMessage("The Fluid-reaction scheme no reaction should not be used with operator splitting."));
+            }
+
+          if (fluid_solid_reaction_scheme == zero_solubility)
+            {
+              AssertThrow(this->get_parameters().use_operator_splitting,
+                          ExcMessage("The Fluid-reaction scheme zero solubility must be used with operator splitting."));
+            }
+
+          if (fluid_solid_reaction_scheme == tian_approximation)
+            {
+              AssertThrow(this->get_parameters().use_operator_splitting,
+                          ExcMessage("The Fluid-reaction scheme tian approximation must be used with operator splitting."));
+            }
+
+          if (this->get_parameters().use_operator_splitting)
+            {
+              if (this->get_parameters().reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
+                AssertThrow(fluid_reaction_time_scale >= this->get_parameters().reaction_time_step,
+                            ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
+                                       + " in the operator splitting scheme is too large to compute fluid release rates! "
+                                       "You have to choose it in such a way that it is smaller than the 'Fluid reaction time scale for "
+                                       "operator splitting' chosen in the material model, which is currently "
+                                       + Utilities::to_string(fluid_reaction_time_scale) + "."));
+              AssertThrow(fluid_reaction_time_scale > 0,
+                          ExcMessage("The Fluid reaction time scale for operator splitting must be larger than 0!"));
+            }
+
+          AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                      ExcMessage("Material model Reactive Fluid Transport only "
+                                 "works if there is a compositional field called porosity."));
+
+          if (fluid_solid_reaction_scheme != katz2003)
+            {
+              AssertThrow(this->introspection().compositional_name_exists("bound_fluid"),
+                          ExcMessage("Material model Reactive Fluid Transport only "
+                                     "works if there is a compositional field called bound_fluid."));
+            }
+          else
+            {
+              AssertThrow(this->introspection().compositional_name_exists("peridotite"),
+                          ExcMessage("Material model Katz 2003 Mantle Melting only "
+                                     "works if there is a compositional field called peridotite."));
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // After parsing the parameters for this model, parse parameters related to the base model.
+      base_model->parse_parameters(prm);
+      this->model_dependence = base_model->get_model_dependence();
+      if (fluid_solid_reaction_scheme == zero_solubility)
+        {
+          AssertThrow(this->get_material_model().is_compressible() == false,
+                      ExcMessage("The Fluid-reaction scheme zero solubility must be used with an incompressible base model."));
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    ReactiveFluidTransport<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (this->get_parameters().use_operator_splitting
+          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
+        {
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (out.n_evaluation_points(), this->n_compositional_fields()));
+        }
+      base_model->create_additional_named_outputs(out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ReactiveFluidTransport,
+                                   "reactive fluid transport",
+                                   "Material model that is designed to advect fluids and compute "
+                                   "fluid release and absorption based on different models for "
+                                   "fluid-rock interaction. At present, models where no fluid-rock "
+                                   "interactions occur or the solid has zero solubility are available. "
+                                   "The properties of the solid can be taken from another material model "
+                                   "that is used as a base model.")
+  }
+}
diff --git a/source/material_model/replace_lithosphere_viscosity.cc.bak b/source/material_model/replace_lithosphere_viscosity.cc.bak
new file mode 100644
index 00000000000..1107255f18d
--- /dev/null
+++ b/source/material_model/replace_lithosphere_viscosity.cc.bak
@@ -0,0 +1,172 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/replace_lithosphere_viscosity.h>
+#include <aspect/initial_temperature/lithosphere_mask.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <limits>
+
+#include <array>
+#include <utility>
+
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    ReplaceLithosphereViscosity<dim>::initialize()
+    {
+      base_model->initialize();
+
+      lab_depth_lookup.initialize();
+    }
+
+
+    template <int dim>
+    void
+    ReplaceLithosphereViscosity<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                                               typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      base_model->evaluate(in,out);
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double depth = this->SimulatorAccess<dim>::get_geometry_model().depth(in.position[i]);
+          const double lab_depth = lab_depth_lookup.get_lab_depth(in.position[i]);
+
+          if (depth <= lab_depth)
+            out.viscosities[i] = lithosphere_viscosity;
+        }
+
+    }
+
+
+    template <int dim>
+    void
+    ReplaceLithosphereViscosity<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Replace lithosphere viscosity");
+        {
+          prm.declare_entry("Base model","simple",
+                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
+                            "The name of a material model that will be modified by a replacing"
+                            "the viscosity in the lithosphere by a constant value. Valid values for this parameter "
+                            "are the names of models that are also valid for the "
+                            "``Material models/Model name'' parameter. See the documentation for "
+                            "more information.");
+          prm.declare_entry ("Lithosphere viscosity", "1e23",
+                             Patterns::Double (0.),
+                             "The viscosity within lithosphere, applied above"
+                             "the maximum lithosphere depth.");
+
+          InitialTemperature::LABDepth::LABDepthLookup<dim>::declare_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    ReplaceLithosphereViscosity<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      AssertThrow (dim == 3,
+                   ExcMessage ("The 'Replace lithosphere viscosity' material model "
+                               "is only available for 3d computations."));
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Replace lithosphere viscosity");
+        {
+          AssertThrow( prm.get("Base model") != "replace lithosphere viscosity",
+                       ExcMessage("You may not use ``replace lithosphere viscosity'' as the base model for "
+                                  "a replace lithosphere viscosity model.") );
+
+          // create the base model and initialize its SimulatorAccess base
+          // class; it will get a chance to read its parameters below after we
+          // leave the current section
+          base_model = create_material_model<dim>(prm.get("Base model"));
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
+            sim->initialize_simulator (this->get_simulator());
+
+          lab_depth_lookup.initialize_simulator(this->get_simulator());
+          lab_depth_lookup.parse_parameters(prm);
+          lithosphere_viscosity   = prm.get_double ("Lithosphere viscosity");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      /* After parsing the parameters for replace lithosphere viscosity, it is essential to parse
+      parameters related to the base model. */
+      base_model->parse_parameters(prm);
+      this->model_dependence = base_model->get_model_dependence();
+    }
+
+    template <int dim>
+    bool
+    ReplaceLithosphereViscosity<dim>::
+    is_compressible () const
+    {
+      return base_model->is_compressible();
+    }
+
+    template <int dim>
+    void
+    ReplaceLithosphereViscosity<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      base_model->create_additional_named_outputs(out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ReplaceLithosphereViscosity,
+                                   "replace lithosphere viscosity",
+                                   "The ``replace lithosphere viscosity'' Material model sets viscosity to a "
+                                   "prescribed constant above the lithosphere-asthenosphere boundary (specified by "
+                                   "an ascii file or maximum lithosphere depth). Below the lithosphere-asthenosphere"
+                                   "boundary the viscosity is taken from any of the other available material model. "
+                                   "In other words, it is a ``compositing material model''."
+                                   "\n"
+                                   "Parameters related to the replace lithosphere viscosity model are read from a subsection "
+                                   "``Material model/Replace lithosphere viscosity''. "
+                                   "The user must specify a ``Base model'' from which other material properties are "
+                                   "derived.  "
+                                   "\n"
+                                   "Note the required format of the input data file: The first lines may "
+                                   "contain any number of comments if they begin with ‘#’, but one of these lines "
+                                   "needs to contain the number of grid points in each dimension as for example "
+                                   "‘# POINTS: 3 3’. For a spherical model, the order of the data columns has to be"
+                                   "'phi', 'theta','depth (m)', where phi is the  azimuth angle and theta is the "
+                                   "polar angle measured positive from the north pole.")
+  }
+}
diff --git a/source/material_model/rheology/ascii_depth_profile.cc.bak b/source/material_model/rheology/ascii_depth_profile.cc.bak
new file mode 100644
index 00000000000..7b2a90bb529
--- /dev/null
+++ b/source/material_model/rheology/ascii_depth_profile.cc.bak
@@ -0,0 +1,99 @@
+/*
+  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/material_model/rheology/ascii_depth_profile.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+
+      template <int dim>
+      AsciiDepthProfile<dim>::AsciiDepthProfile ()
+        = default;
+
+
+
+      template <int dim>
+      void
+      AsciiDepthProfile<dim>::initialize ()
+      {
+        this->initialize(this->get_mpi_communicator());
+        viscosity_index = this->get_column_index_from_name("viscosity");
+      }
+
+
+
+      template <int dim>
+      double
+      AsciiDepthProfile<dim>::compute_viscosity (const double depth) const
+      {
+        return this->get_data_component (Point<1>(depth), viscosity_index);
+      }
+
+
+
+      template <int dim>
+      void
+      AsciiDepthProfile<dim>::declare_parameters (ParameterHandler &prm,
+                                                  const std::string &subsection_name)
+      {
+        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                          "$ASPECT_SOURCE_DIR/data/material-model/rheology/",
+                                                          "ascii_depth_profile.txt",
+                                                          subsection_name);
+      }
+
+
+
+      template <int dim>
+      void
+      AsciiDepthProfile<dim>::parse_parameters (ParameterHandler &prm,
+                                                const std::string &subsection_name)
+      {
+        Utilities::AsciiDataBase<dim>::parse_parameters(prm,
+                                                        subsection_name);
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class AsciiDepthProfile<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/composite_visco_plastic.cc.bak b/source/material_model/rheology/composite_visco_plastic.cc.bak
new file mode 100644
index 00000000000..39ea0204c7b
--- /dev/null
+++ b/source/material_model/rheology/composite_visco_plastic.cc.bak
@@ -0,0 +1,458 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/composite_visco_plastic.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      // The following function is not yet used by ASPECT, so
+      // it is commented out to avoid tester issues.
+      //
+      // It will provide useful output when a material model which
+      // uses the CompositeViscoPlastic rheology has been implemented.
+      //
+      // The composite visco plastic rheology calculates the decomposed strain
+      // rates for each of the following deformation mechanisms:
+      // diffusion creep, dislocation creep, Peierls creep,
+      // Drucker-Prager plasticity and a constant (high) viscosity limiter.
+      // The values are provided in this order as a vector of additional
+      // outputs. If the user declares one or more mechanisms inactive
+      // (by assigning use_mechanism = False) then the corresponding
+      // strain rate output will be equal to zero.
+      //namespace
+      //{
+      //  std::vector<std::string> make_strain_rate_additional_outputs_names()
+      //  {
+      //    std::vector<std::string> names;
+      //    names.emplace_back("edot_diffusion");
+      //    names.emplace_back("edot_dislocation");
+      //    names.emplace_back("edot_peierls");
+      //    names.emplace_back("edot_drucker_prager");
+      //    names.emplace_back("edot_limiter");
+      //    return names;
+      //  }
+      //}
+
+
+      template <int dim>
+      CompositeViscoPlastic<dim>::CompositeViscoPlastic ()
+        = default;
+
+
+
+      template <int dim>
+      double
+      CompositeViscoPlastic<dim>::compute_viscosity (const double pressure,
+                                                     const double temperature,
+                                                     const std::vector<double> &volume_fractions,
+                                                     const SymmetricTensor<2,dim> &strain_rate,
+                                                     std::vector<double> &partial_strain_rates,
+                                                     const std::vector<double> &phase_function_values,
+                                                     const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        double viscosity = 0.;
+        partial_strain_rates.resize(5, 0.);
+
+        // Isostrain averaging
+        double total_volume_fraction = 1.;
+        for (unsigned int composition=0; composition < number_of_compositions; ++composition)
+          {
+            // Only include the contribution to the viscosity
+            // from a given composition if the volume fraction exceeds
+            // a certain (small) fraction.
+            if (volume_fractions[composition] > 2.*std::numeric_limits<double>::epsilon())
+              {
+                std::vector<double> partial_strain_rates_composition(5, 0.);
+                viscosity += (volume_fractions[composition]
+                              * compute_composition_viscosity (pressure,
+                                                               temperature,
+                                                               composition,
+                                                               strain_rate,
+                                                               partial_strain_rates_composition,
+                                                               phase_function_values,
+                                                               n_phase_transitions_per_composition));
+                for (unsigned int j=0; j < 5; ++j)
+                  partial_strain_rates[j] += volume_fractions[composition] * partial_strain_rates_composition[j];
+              }
+            else
+              {
+                total_volume_fraction -= volume_fractions[composition];
+              }
+
+            viscosity /= total_volume_fraction;
+            for (unsigned int j=0; j < 5; ++j)
+              partial_strain_rates[j] /= total_volume_fraction;
+          }
+        return viscosity;
+      }
+
+
+
+      template <int dim>
+      double
+      CompositeViscoPlastic<dim>::compute_composition_viscosity (const double pressure,
+                                                                 const double temperature,
+                                                                 const unsigned int composition,
+                                                                 const SymmetricTensor<2,dim> &strain_rate,
+                                                                 std::vector<double> &partial_strain_rates,
+                                                                 const std::vector<double> &phase_function_values,
+                                                                 const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        // If strain rate is zero (like during the first time step) set it to some very small number
+        // to prevent a division-by-zero, and a floating point exception.
+        // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
+        // strain rate (often simplified as epsilondot_ii)
+        const double edot_ii = std::max(std::sqrt(std::max(-second_invariant(deviator(strain_rate)), 0.)),
+                                        min_strain_rate);
+
+        Rheology::DiffusionCreepParameters diffusion_creep_parameters;
+        Rheology::DislocationCreepParameters dislocation_creep_parameters;
+        Rheology::PeierlsCreepParameters peierls_creep_parameters;
+        Rheology::DruckerPragerParameters drucker_prager_parameters;
+
+        double eta_diff = maximum_viscosity;
+        double eta_disl = maximum_viscosity;
+        double eta_prls = maximum_viscosity;
+
+        if (use_diffusion_creep)
+          {
+            diffusion_creep_parameters = diffusion_creep->compute_creep_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
+            eta_diff = diffusion_creep->compute_viscosity(pressure, temperature, composition, phase_function_values, n_phase_transitions_per_composition);
+          }
+
+        if (use_dislocation_creep)
+          {
+            dislocation_creep_parameters = dislocation_creep->compute_creep_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
+            eta_disl = dislocation_creep->compute_viscosity(edot_ii, pressure, temperature, composition, phase_function_values, n_phase_transitions_per_composition);
+          }
+
+        if (use_peierls_creep)
+          {
+            peierls_creep_parameters = peierls_creep->compute_creep_parameters(composition);
+            eta_prls = peierls_creep->compute_approximate_viscosity(edot_ii, pressure, temperature, composition);
+          }
+        // First guess at a stress using diffusion, dislocation, and Peierls creep viscosities calculated with the total second strain rate invariant.
+        const double eta_guess = std::min(std::max(minimum_viscosity, eta_diff*eta_disl*eta_prls/(eta_diff*eta_disl + eta_diff*eta_prls + eta_disl*eta_prls)), maximum_viscosity);
+
+        double creep_stress = 2.*eta_guess*edot_ii;
+
+        // Crude modification of the creep stress to be no higher than the
+        // Drucker-Prager yield stress. Probably fine for a first guess.
+        if (use_drucker_prager)
+          {
+            drucker_prager_parameters = drucker_prager->compute_drucker_prager_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
+            const double yield_stress = drucker_prager->compute_yield_stress(drucker_prager_parameters.cohesion,
+                                                                             drucker_prager_parameters.angle_internal_friction,
+                                                                             pressure,
+                                                                             drucker_prager_parameters.max_yield_stress);
+
+            creep_stress = std::min(creep_stress, yield_stress);
+          }
+
+        // In this rheology model, the total strain rate is partitioned between
+        // different flow laws. We do not know how the strain is partitioned
+        // between these flow laws, nor do we know the creep stress, which is
+        // required to calculate the partitioning.
+
+        // The following while loop conducts a Newton iteration to obtain the
+        // creep stress, which we need in order to calculate the viscosity.
+        double strain_rate_residual = 2*strain_rate_residual_threshold;
+        double strain_rate_deriv = 0;
+        unsigned int stress_iteration = 0;
+        while (std::abs(strain_rate_residual) > strain_rate_residual_threshold
+               && stress_iteration < stress_max_iteration_number)
+          {
+
+            const std::pair<double, double> creep_edot_and_deriv = compute_strain_rate_and_derivative (creep_stress,
+                                                                   pressure,
+                                                                   temperature,
+                                                                   diffusion_creep_parameters,
+                                                                   dislocation_creep_parameters,
+                                                                   peierls_creep_parameters,
+                                                                   drucker_prager_parameters);
+
+            const double strain_rate = creep_stress/(2.*maximum_viscosity) + (maximum_viscosity/(maximum_viscosity - minimum_viscosity))*creep_edot_and_deriv.first;
+            strain_rate_deriv = 1./(2.*maximum_viscosity) + (maximum_viscosity/(maximum_viscosity - minimum_viscosity))*creep_edot_and_deriv.second;
+
+            strain_rate_residual = strain_rate - edot_ii;
+
+            // If the strain rate derivative is zero, we catch it below.
+            if (strain_rate_deriv>std::numeric_limits<double>::min())
+              creep_stress -= strain_rate_residual/strain_rate_deriv;
+            stress_iteration += 1;
+
+            // If anything that would be used in the next iteration is not finite, the
+            // Newton iteration would trigger an exception and we want to abort the
+            // iteration instead.
+            // Currently, we still throw an exception, but if this exception is thrown,
+            // another more robust iterative scheme should be implemented
+            // (similar to that seen in the diffusion-dislocation material model).
+            const bool abort_newton_iteration = !numbers::is_finite(creep_stress)
+                                                || !numbers::is_finite(strain_rate_residual)
+                                                || !numbers::is_finite(strain_rate_deriv)
+                                                || strain_rate_deriv < std::numeric_limits<double>::min()
+                                                || stress_iteration == stress_max_iteration_number;
+            AssertThrow(!abort_newton_iteration,
+                        ExcMessage("No convergence has been reached in the loop that determines "
+                                   "the composite viscous creep stress. Aborting! "
+                                   "Residual is " + Utilities::to_string(strain_rate_residual) +
+                                   " after " + Utilities::to_string(stress_iteration) + " iterations. "
+                                   "You can increase the number of iterations by adapting the "
+                                   "parameter 'Maximum creep strain rate iterations'."));
+          }
+
+        // The creep stress is not the total stress, so we still need to do a little work to obtain the effective viscosity.
+        // First, we compute the stress running through the strain rate limiter, and then add that to the creep stress
+        // NOTE: The viscosity of the strain rate limiter is equal to (minimum_viscosity*maximum_viscosity)/(maximum_viscosity - minimum_viscosity)
+        const double lim_stress = 2.*minimum_viscosity*(edot_ii - creep_stress/(2.*maximum_viscosity));
+        const double total_stress = creep_stress + lim_stress;
+
+        // Compute the strain rate experienced by the different mechanisms
+        // These should sum to the total strain rate
+
+        // The components of partial_strain_rates must be provided in the order
+        // dictated by make_strain_rate_additional_outputs_names
+        if (use_diffusion_creep)
+          {
+            const std::pair<double, double> diff_edot_and_deriv = diffusion_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, diffusion_creep_parameters);
+            partial_strain_rates[0] = diff_edot_and_deriv.first;
+          }
+
+        if (use_dislocation_creep)
+          {
+            const std::pair<double, double> disl_edot_and_deriv = dislocation_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, dislocation_creep_parameters);
+            partial_strain_rates[1] = disl_edot_and_deriv.first;
+          }
+
+        if (use_peierls_creep)
+          {
+            const std::pair<double, double> prls_edot_and_deriv = peierls_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, peierls_creep_parameters);
+            partial_strain_rates[2] = prls_edot_and_deriv.first;
+          }
+
+        if (use_drucker_prager)
+          {
+            const std::pair<double, double> drpr_edot_and_deriv = drucker_prager->compute_strain_rate_and_derivative(creep_stress, pressure, drucker_prager_parameters);
+            partial_strain_rates[3] = drpr_edot_and_deriv.first;
+          }
+
+        partial_strain_rates[4] = total_stress/(2.*maximum_viscosity);
+
+        // Now we return the viscosity using the total stress
+        return total_stress/(2.*edot_ii);
+      }
+
+
+
+      // Overload the + operator to act on two pairs of doubles.
+      std::pair<double,double> operator+(const std::pair<double,double> &x, const std::pair<double,double> &y)
+      {
+        return std::make_pair(x.first+y.first, x.second+y.second);
+      }
+
+
+
+      template <int dim>
+      std::pair<double, double>
+      CompositeViscoPlastic<dim>::compute_strain_rate_and_derivative (const double creep_stress,
+                                                                      const double pressure,
+                                                                      const double temperature,
+                                                                      const DiffusionCreepParameters diffusion_creep_parameters,
+                                                                      const DislocationCreepParameters dislocation_creep_parameters,
+                                                                      const PeierlsCreepParameters peierls_creep_parameters,
+                                                                      const DruckerPragerParameters drucker_prager_parameters) const
+      {
+        std::pair<double, double> creep_edot_and_deriv = std::make_pair(0., 0.);
+
+        if (use_diffusion_creep)
+          creep_edot_and_deriv = creep_edot_and_deriv + diffusion_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, diffusion_creep_parameters);
+
+        if (use_dislocation_creep)
+          creep_edot_and_deriv = creep_edot_and_deriv + dislocation_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, dislocation_creep_parameters);
+
+        if (use_peierls_creep)
+          creep_edot_and_deriv = creep_edot_and_deriv + peierls_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, peierls_creep_parameters);
+
+        if (use_drucker_prager)
+          creep_edot_and_deriv = creep_edot_and_deriv + drucker_prager->compute_strain_rate_and_derivative(creep_stress, pressure, drucker_prager_parameters);
+
+        return creep_edot_and_deriv;
+      }
+
+
+
+      template <int dim>
+      void
+      CompositeViscoPlastic<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Include diffusion creep in composite rheology", "true",
+                           Patterns::Bool (),
+                           "Whether to include diffusion creep in the composite rheology formulation.");
+
+        prm.declare_entry ("Include dislocation creep in composite rheology", "true",
+                           Patterns::Bool (),
+                           "Whether to include dislocation creep in the composite rheology formulation.");
+
+        prm.declare_entry ("Include Peierls creep in composite rheology", "true",
+                           Patterns::Bool (),
+                           "Whether to include Peierls creep in the composite rheology formulation.");
+
+        prm.declare_entry ("Include Drucker Prager plasticity in composite rheology", "true",
+                           Patterns::Bool (),
+                           "Whether to include Drucker-Prager plasticity in the composite rheology formulation.");
+
+        // Diffusion creep parameters
+        Rheology::DiffusionCreep<dim>::declare_parameters(prm);
+
+        // Dislocation creep parameters
+        Rheology::DislocationCreep<dim>::declare_parameters(prm);
+
+        // Dislocation creep parameters
+        Rheology::PeierlsCreep<dim>::declare_parameters(prm);
+
+        // Drucker Prager parameters
+        Rheology::DruckerPrager<dim>::declare_parameters(prm);
+
+        // Some of the parameters below are shared with the subordinate
+        // rheology models (diffusion, dislocation, ...),
+        // and will already have been declared. This is fine, the deal.II
+        // parameter handler allows repeated declarations. The default values
+        // below will override any defaults given in the subordinate
+        // rheology models. The new defaults will apply both to
+        // this rheology model and to the subordinate rheology modules.
+        prm.declare_entry ("Minimum strain rate", "1.4e-20", Patterns::Double(0.),
+                           "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}.");
+
+        // Viscosity iteration parameters
+        prm.declare_entry ("Strain rate residual tolerance", "1e-22", Patterns::Double(0.),
+                           "Tolerance for correct diffusion/dislocation strain rate ratio.");
+        prm.declare_entry ("Maximum creep strain rate iterations", "40", Patterns::Integer(0),
+                           "Maximum number of iterations to find the correct "
+                           "creep strain rate.");
+
+        // Strain rate and stress limiting parameters
+        prm.declare_entry ("Minimum viscosity", "1.e17",
+                           Patterns::Double(0.),
+                           "Minimum effective viscosity. Units: \\si{\\pascal\\second}.");
+
+        prm.declare_entry ("Maximum viscosity", "1.e28",
+                           Patterns::Double(0.),
+                           "Maximum effective viscosity. Units: \\si{\\pascal\\second}.");
+      }
+
+
+
+      template <int dim>
+      void
+      CompositeViscoPlastic<dim>::parse_parameters (ParameterHandler &prm,
+                                                    const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
+      {
+        // Retrieve the list of composition names
+        const std::vector<std::string> list_of_composition_names = this->introspection().get_composition_names();
+
+        // A background field is required by the subordinate material models
+        number_of_compositions = list_of_composition_names.size() + 1;
+
+        min_strain_rate = prm.get_double("Minimum strain rate");
+
+        // Iteration parameters
+        strain_rate_residual_threshold = prm.get_double ("Strain rate residual tolerance");
+        stress_max_iteration_number = prm.get_integer ("Maximum creep strain rate iterations");
+
+        // Read min and max viscosity parameters
+        minimum_viscosity = prm.get_double ("Minimum viscosity");
+        maximum_viscosity = prm.get_double ("Maximum viscosity");
+
+        // Rheological parameters
+
+        // Diffusion creep parameters
+        use_diffusion_creep = prm.get_bool ("Include diffusion creep in composite rheology");
+        if (use_diffusion_creep)
+          {
+            diffusion_creep = std::make_unique<Rheology::DiffusionCreep<dim>>();
+            diffusion_creep->initialize_simulator (this->get_simulator());
+            diffusion_creep->parse_parameters(prm, expected_n_phases_per_composition);
+          }
+
+        // Dislocation creep parameters
+        use_dislocation_creep = prm.get_bool ("Include dislocation creep in composite rheology");
+        if (use_dislocation_creep)
+          {
+            dislocation_creep = std::make_unique<Rheology::DislocationCreep<dim>>();
+            dislocation_creep->initialize_simulator (this->get_simulator());
+            dislocation_creep->parse_parameters(prm, expected_n_phases_per_composition);
+          }
+
+        // Peierls creep parameters
+        use_peierls_creep = prm.get_bool ("Include Peierls creep in composite rheology");
+        if (use_peierls_creep)
+          {
+            peierls_creep = std::make_unique<Rheology::PeierlsCreep<dim>>();
+            peierls_creep->initialize_simulator (this->get_simulator());
+            peierls_creep->parse_parameters(prm, expected_n_phases_per_composition);
+          }
+
+        // Drucker Prager parameters
+        use_drucker_prager = prm.get_bool ("Include Drucker Prager plasticity in composite rheology");
+        if (use_drucker_prager)
+          {
+            drucker_prager = std::make_unique<Rheology::DruckerPrager<dim>>();
+            drucker_prager->initialize_simulator (this->get_simulator());
+            drucker_prager->parse_parameters(prm, expected_n_phases_per_composition);
+
+            AssertThrow(prm.get_bool("Use plastic damper") && prm.get_double("Plastic damper viscosity") > 0.,
+                        ExcMessage("If Drucker-Prager plasticity is included in the rheological formulation, you must use a viscous damper with a positive viscosity."));
+          }
+
+        AssertThrow(use_diffusion_creep == true || use_dislocation_creep == true || use_peierls_creep == true || use_drucker_prager == true,
+                    ExcMessage("You need to include at least one deformation mechanism."));
+
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class CompositeViscoPlastic<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/compositional_viscosity_prefactors.cc.bak b/source/material_model/rheology/compositional_viscosity_prefactors.cc.bak
new file mode 100644
index 00000000000..45dae88661a
--- /dev/null
+++ b/source/material_model/rheology/compositional_viscosity_prefactors.cc.bak
@@ -0,0 +1,178 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/compositional_viscosity_prefactors.h>
+#include <aspect/utilities.h>
+#include <aspect/global.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/parameters.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      template <int dim>
+      CompositionalViscosityPrefactors<dim>::CompositionalViscosityPrefactors ()
+        = default;
+
+      template <int dim>
+      double
+      CompositionalViscosityPrefactors<dim>::compute_viscosity (const MaterialModel::MaterialModelInputs<dim> &in,
+                                                                const double base_viscosity,
+                                                                const unsigned int composition_index,
+                                                                const unsigned int q,
+                                                                const ModifiedFlowLaws &modified_flow_laws) const
+      {
+        double factored_viscosities = base_viscosity;
+        switch (viscosity_prefactor_scheme)
+          {
+            case none:
+            {
+              factored_viscosities = base_viscosity;
+              break;
+            }
+            case hk04_olivine_hydration:
+            {
+              // We calculate the atomic H/Si ppm (C_OH) at each point to compute the water fugacity of
+              // olivine assuming a composition of 90 mol% Forsterite and 10 mol% Fayalite from Hirth
+              // and Kohlstaedt 2004 10.1029/138GM06.
+              const unsigned int bound_fluid_idx = this->introspection().compositional_index_for_name("bound_fluid");
+              const double mass_fraction_H2O = std::max(minimum_mass_fraction_water_for_dry_creep[composition_index], in.composition[q][bound_fluid_idx]); // mass fraction of bound water
+              const double mass_fraction_olivine = 1 - mass_fraction_H2O; // mass fraction of olivine
+              const double COH = (mass_fraction_H2O/molar_mass_H2O) / (mass_fraction_olivine/molar_mass_olivine) * 1e6; // COH in H / Si ppm
+              const double point_water_fugacity = COH / A_H2O *
+                                                  std::exp((activation_energy_H2O + in.pressure[q]*activation_volume_H2O)/
+                                                           (constants::gas_constant * in.temperature[q]));
+              const double r = modified_flow_laws == diffusion
+                               ?
+                               -diffusion_water_fugacity_exponents[composition_index]
+                               :
+                               -dislocation_water_fugacity_exponents[composition_index];
+              factored_viscosities = base_viscosity*std::pow(point_water_fugacity, r);
+              break;
+            }
+          }
+        return factored_viscosities;
+      }
+
+
+      template <int dim>
+      void
+      CompositionalViscosityPrefactors<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Minimum mass fraction bound water content for fugacity", "6.15e-6",
+                           Patterns::List(Patterns::Double(0)),
+                           "The minimum water content for the HK04 olivine hydration viscosity "
+                           "prefactor scheme. This acts as the cutoff between 'dry' creep and 'wet' creep "
+                           "for olivine, and the default value is chosen based on the value reported by "
+                           "Hirth & Kohlstaedt 2004. For a mass fraction of bound water beneath this value, "
+                           "this value is used instead to compute the water fugacity. Units: \\si{\\kg} / \\si{\\kg} %.");
+
+        prm.declare_entry ("Water fugacity exponents for diffusion creep", "0.0",
+                           Patterns::List(Patterns::Double(0)),
+                           "List of water fugacity exponents for diffusion creep for "
+                           "background material and compositional fields, for a total of N+1 "
+                           "where N is the number of all compositional fields or only those "
+                           "corresponding to chemical compositions. This is only applied when using the "
+                           "Viscosity prefactor scheme 'HK04 olivine hydration'. Note, the water fugacity exponent "
+                           "required by ASPECT for diffusion creep is r/n, where n is the stress exponent "
+                           "for diffusion creep, which typically is 1. Units: none.");
+
+        prm.declare_entry ("Water fugacity exponents for dislocation creep", "0.0",
+                           Patterns::List(Patterns::Double(0)),
+                           "List of water fugacity exponents for dislocation creep for "
+                           "background material and compositional fields, for a total of N+1 "
+                           "where N is the number of all compositional fields or only those "
+                           "corresponding to chemical compositions. This is only applied when using the "
+                           "Viscosity prefactor scheme 'HK04 olivine hydration'. Note, the water fugacity exponent "
+                           "required by ASPECT for dislocation creep is r/n, where n is the stress exponent "
+                           "for dislocation creep, which typically is 3.5. Units: none.");
+
+        prm.declare_entry ("Viscosity prefactor scheme", "none",
+                           Patterns::Selection("none|HK04 olivine hydration"),
+                           "Select what type of viscosity multiplicative prefactor scheme to apply. "
+                           "Allowed entries are 'none', and 'HK04 olivine hydration'. HK04 olivine "
+                           "hydration calculates the viscosity change due to hydrogen incorporation "
+                           "into olivine following Hirth & Kohlstaedt 2004 (10.1029/138GM06). none "
+                           "does not modify the viscosity. Units: none.");
+      }
+
+
+
+      template <int dim>
+      void
+      CompositionalViscosityPrefactors<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        if (prm.get ("Viscosity prefactor scheme") == "none")
+          viscosity_prefactor_scheme = none;
+        if (prm.get ("Viscosity prefactor scheme") == "HK04 olivine hydration")
+          {
+            // Retrieve the list of compositional names
+            std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+            AssertThrow(this->introspection().compositional_name_exists("bound_fluid"),
+                        ExcMessage("The HK04 olivine hydration pre-exponential factor only works if "
+                                   "there is a compositional field called bound_fluid."));
+            viscosity_prefactor_scheme = hk04_olivine_hydration;
+
+            // Retrieve the list of chemical names
+            std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+            // Establish that a background field is required here
+            compositional_field_names.insert(compositional_field_names.begin(), "background");
+            chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+            Utilities::MapParsing::Options options(chemical_field_names, "Water fugacity exponents for diffusion creep");
+
+            options.list_of_allowed_keys = compositional_field_names;
+            diffusion_water_fugacity_exponents = Utilities::MapParsing::parse_map_to_double_array (prm.get("Water fugacity exponents for diffusion creep"),
+                                                 options);
+            dislocation_water_fugacity_exponents = Utilities::MapParsing::parse_map_to_double_array (prm.get("Water fugacity exponents for dislocation creep"),
+                                                   options);
+            minimum_mass_fraction_water_for_dry_creep = Utilities::MapParsing::parse_map_to_double_array (prm.get("Minimum mass fraction bound water content for fugacity"),
+                                                        options);
+          }
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class CompositionalViscosityPrefactors<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/constant_viscosity.cc.bak b/source/material_model/rheology/constant_viscosity.cc.bak
new file mode 100644
index 00000000000..06da2a5b933
--- /dev/null
+++ b/source/material_model/rheology/constant_viscosity.cc.bak
@@ -0,0 +1,67 @@
+/*
+  Copyright (C) 2019 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/constant_viscosity.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      ConstantViscosity::ConstantViscosity ()
+        :
+        viscosity(numbers::signaling_nan<double>())
+      {}
+
+
+
+      double
+      ConstantViscosity::compute_viscosity () const
+      {
+        return viscosity;
+      }
+
+
+
+      void
+      ConstantViscosity::declare_parameters (ParameterHandler &prm,
+                                             const double default_viscosity)
+      {
+        prm.declare_entry ("Viscosity", std::to_string(default_viscosity),
+                           Patterns::Double (0.),
+                           "The value of the viscosity $\\eta$. Units: \\si{\\pascal\\second}.");
+      }
+
+
+
+      void
+      ConstantViscosity::parse_parameters (ParameterHandler &prm)
+      {
+        viscosity = prm.get_double ("Viscosity");
+      }
+    }
+  }
+}
diff --git a/source/material_model/rheology/constant_viscosity_prefactors.cc.bak b/source/material_model/rheology/constant_viscosity_prefactors.cc.bak
new file mode 100644
index 00000000000..4b3b91d6cfc
--- /dev/null
+++ b/source/material_model/rheology/constant_viscosity_prefactors.cc.bak
@@ -0,0 +1,105 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/constant_viscosity_prefactors.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      template <int dim>
+      ConstantViscosityPrefactors<dim>::ConstantViscosityPrefactors ()
+        = default;
+
+
+
+      template <int dim>
+      double
+      ConstantViscosityPrefactors<dim>::compute_viscosity (const double base_viscosity,
+                                                           const unsigned int composition_index) const
+      {
+        return base_viscosity * constant_viscosity_prefactors[composition_index];
+      }
+
+
+
+      template <int dim>
+      void
+      ConstantViscosityPrefactors<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Constant viscosity prefactors", "1.0",
+                           Patterns::List(Patterns::Double(0)),
+                           "List of constant viscosity prefactors (i.e., multiplicative factors) "
+                           "for background material and compositional fields, for a total of N+1 "
+                           "where N is the number of all compositional fields or only those "
+                           "corresponding to chemical compositions. Units: none.");
+      }
+
+
+
+      template <int dim>
+      void
+      ConstantViscosityPrefactors<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+        Utilities::MapParsing::Options options(chemical_field_names, "Constant viscosity prefactors");
+        options.list_of_allowed_keys = compositional_field_names;
+
+        constant_viscosity_prefactors = Utilities::MapParsing::parse_map_to_double_array (prm.get("Constant viscosity prefactors"),
+                                        options);
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class ConstantViscosityPrefactors<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/diffusion_creep.cc.bak b/source/material_model/rheology/diffusion_creep.cc.bak
new file mode 100644
index 00000000000..b2b3f0d087d
--- /dev/null
+++ b/source/material_model/rheology/diffusion_creep.cc.bak
@@ -0,0 +1,303 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/diffusion_creep.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      DiffusionCreepParameters::DiffusionCreepParameters()
+        : prefactor (numbers::signaling_nan<double>()),
+          activation_energy (numbers::signaling_nan<double>()),
+          activation_volume (numbers::signaling_nan<double>()),
+          stress_exponent (numbers::signaling_nan<double>()),
+          grain_size_exponent (numbers::signaling_nan<double>())
+      {}
+
+
+
+      template <int dim>
+      DiffusionCreep<dim>::DiffusionCreep ()
+        = default;
+
+
+
+      template <int dim>
+      const DiffusionCreepParameters
+      DiffusionCreep<dim>::compute_creep_parameters (const unsigned int composition,
+                                                     const std::vector<double> &phase_function_values,
+                                                     const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        DiffusionCreepParameters creep_parameters;
+        if (phase_function_values == std::vector<double>())
+          {
+            // no phases
+            creep_parameters.prefactor = prefactors_diffusion[composition];
+            creep_parameters.activation_energy = activation_energies_diffusion[composition];
+            creep_parameters.activation_volume = activation_volumes_diffusion[composition];
+            creep_parameters.stress_exponent = stress_exponents_diffusion[composition];
+            creep_parameters.grain_size_exponent = grain_size_exponents_diffusion[composition];
+          }
+        else
+          {
+            // Average among phases
+            creep_parameters.prefactor = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                         prefactors_diffusion, composition,  MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic);
+            creep_parameters.activation_energy = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 activation_energies_diffusion, composition);
+            creep_parameters.activation_volume = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 activation_volumes_diffusion, composition);
+            creep_parameters.stress_exponent = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                               stress_exponents_diffusion, composition);
+            creep_parameters.grain_size_exponent = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                   grain_size_exponents_diffusion, composition);
+          }
+        return creep_parameters;
+      }
+
+
+
+      template <int dim>
+      double
+      DiffusionCreep<dim>::compute_viscosity (const double pressure,
+                                              const double temperature,
+                                              const unsigned int composition,
+                                              const std::vector<double> &phase_function_values,
+                                              const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        const DiffusionCreepParameters p = compute_creep_parameters(composition,
+                                                                    phase_function_values,
+                                                                    n_phase_transitions_per_composition);
+
+        // Power law creep equation
+        //    viscosity = 0.5 * A^(-1) * d^(m) * exp((E + P*V)/(RT))
+        // A: prefactor,
+        // d: grain size, m: grain size exponent, E: activation energy, P: pressure,
+        // V; activation volume, R: gas constant, T: temperature.
+        double viscosity_diffusion = 0.5 / p.prefactor *
+                                     std::exp((p.activation_energy +
+                                               pressure*p.activation_volume)/
+                                              (constants::gas_constant*temperature)) *
+                                     std::pow(grain_size, p.grain_size_exponent);
+
+        Assert (viscosity_diffusion > 0.0,
+                ExcMessage ("Negative diffusion viscosity detected. This is unphysical and should not happen. "
+                            "Check for negative parameters. Temperature and pressure are "
+                            + Utilities::to_string(temperature) + " K, " + Utilities::to_string(pressure) + " Pa. "));
+
+        // Creep viscosities become extremely large at low
+        // temperatures and can therefore provoke floating-point overflow errors. In
+        // real rocks, other deformation mechanisms become dominant at low temperatures,
+        // so these high viscosities are never achieved. It is therefore both reasonable
+        // and desirable to require the single-mechanism viscosity to be smaller than
+        // std::sqrt(max_double).
+        viscosity_diffusion = std::min(viscosity_diffusion, std::sqrt(std::numeric_limits<double>::max()));
+
+        return viscosity_diffusion;
+      }
+
+
+      template <int dim>
+      std::pair<double, double>
+      DiffusionCreep<dim>::compute_strain_rate_and_derivative (const double stress,
+                                                               const double pressure,
+                                                               const double temperature,
+                                                               const DiffusionCreepParameters creep_parameters) const
+      {
+        // Power law creep equation
+        //   edot_ii_partial = A * stress^n * d^-m * exp(-(E + P*V)/(RT))
+        //   d(edot_ii_partial)/d(stress) = A * n * stress^(n-1) * d^-m * exp(-(E + P*V)/(RT))
+        // A: prefactor, edot_ii_partial: square root of second invariant of deviatoric strain rate tensor attributable to the creep mechanism,
+        // d: grain size, m: grain size exponent, E: activation energy, P: pressure,
+        // V; activation volume, R: gas constant, T: temperature.
+        // For diffusion creep, n = 1 (strain rate is linearly dependent on stress).
+        const double dstrain_rate_dstress_diffusion = creep_parameters.prefactor *
+                                                      std::pow(grain_size, -creep_parameters.grain_size_exponent) *
+                                                      std::exp(-(creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
+                                                               (constants::gas_constant*temperature));
+
+        const double strain_rate_diffusion = stress * dstrain_rate_dstress_diffusion;
+
+        return std::make_pair(strain_rate_diffusion, dstrain_rate_dstress_diffusion);
+      }
+
+
+      template <int dim>
+      std::pair<double, double>
+      DiffusionCreep<dim>::compute_log_strain_rate_and_derivative (const double log_stress,
+                                                                   const double pressure,
+                                                                   const double temperature,
+                                                                   const DiffusionCreepParameters creep_parameters) const
+      {
+        // Power law creep equation
+        // log(edot_ii_partial) = std::log(A) + n*std::log(stress) - m*std::log(d) - (E + P*V)/(RT)
+        //   d(log_edot_ii_partial)/d(log_stress) = n
+        // A: prefactor, edot_ii_partial: square root of second invariant of deviatoric strain rate tensor attributable to the creep mechanism,
+        // d: grain size, m: grain size exponent, E: activation energy, P: pressure,
+        // V; activation volume, R: gas constant, T: temperature.
+        // For diffusion creep, n = 1 (strain rate is linearly dependent on stress).
+        const double log_strain_rate_diffusion = std::log(creep_parameters.prefactor) +
+                                                 log_stress -
+                                                 creep_parameters.grain_size_exponent * std::log(grain_size) -
+                                                 (creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
+                                                 (constants::gas_constant*temperature);
+
+        const double dlog_strain_rate_dlog_stress_diffusion = 1.0;
+
+        return std::make_pair(log_strain_rate_diffusion, dlog_strain_rate_dlog_stress_diffusion);
+      }
+
+
+
+
+      template <int dim>
+      void
+      DiffusionCreep<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Prefactors for diffusion creep", "1.5e-15",
+                           Patterns::Anything(),
+                           "List of viscosity prefactors, $A$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\per\\pascal\\meter}$^{m_{\\text{diffusion}}}$\\si{\\per\\second}.");
+        prm.declare_entry ("Stress exponents for diffusion creep", "1.",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of stress exponents, $n_{\\text{diffusion}}$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "The stress exponent for diffusion creep is almost always equal to one. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+        prm.declare_entry ("Grain size exponents for diffusion creep", "3.",
+                           Patterns::Anything(),
+                           "List of grain size exponents, $m_{\\text{diffusion}}$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. Units: None.");
+        prm.declare_entry ("Activation energies for diffusion creep", "375e3",
+                           Patterns::Anything(),
+                           "List of activation energies, $E_a$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\joule\\per\\mole}.");
+        prm.declare_entry ("Activation volumes for diffusion creep", "6e-6",
+                           Patterns::Anything(),
+                           "List of activation volumes, $V_a$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
+        prm.declare_entry ("Grain size", "1e-3", Patterns::Double (0.),
+                           "Units: \\si{\\meter}.");
+      }
+
+
+
+      template <int dim>
+      void
+      DiffusionCreep<dim>::parse_parameters (ParameterHandler &prm,
+                                             const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
+      {
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(), "background");
+
+        // Make options file for parsing maps to double arrays
+        Utilities::MapParsing::Options options(chemical_field_names, "Prefactors for diffusion creep");
+        options.list_of_allowed_keys = compositional_field_names;
+        options.allow_multiple_values_per_key = true;
+        if (expected_n_phases_per_composition)
+          {
+            options.n_values_per_key = *expected_n_phases_per_composition;
+
+            // check_values_per_key is required to be true to duplicate single values
+            // if they are to be used for all phases associated with a given key.
+            options.check_values_per_key = true;
+          }
+
+        // Read parameters, each of size of number of composition + number of phases + 1
+        prefactors_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactors for diffusion creep"),
+                                                                                options);
+
+        options.property_name = "Stress exponents for diffusion creep";
+        stress_exponents_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Stress exponents for diffusion creep"),
+                                                                                      options);
+
+        options.property_name = "Grain size exponents for diffusion creep";
+        grain_size_exponents_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Grain size exponents for diffusion creep"),
+                                         options);
+
+        options.property_name = "Activation energies for diffusion creep";
+        activation_energies_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation energies for diffusion creep"),
+                                        options);
+
+        options.property_name = "Activation volumes for diffusion creep";
+        activation_volumes_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation volumes for diffusion creep"),
+                                                                                        options);
+
+        grain_size = prm.get_double("Grain size");
+
+        // Check that there are no entries set to zero,
+        // for example because the entry is for a field
+        // that is masked anyway, like strain. Despite
+        // these compositions being masked, their viscosities
+        // are computed anyway and this will lead to division by zero.
+        for (const double prefactor : prefactors_diffusion)
+          AssertThrow(prefactor > 0.,
+                      ExcMessage("The diffusion prefactor should be larger than zero."));
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class DiffusionCreep<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/diffusion_dislocation.cc.bak b/source/material_model/rheology/diffusion_dislocation.cc.bak
new file mode 100644
index 00000000000..d86b36f491c
--- /dev/null
+++ b/source/material_model/rheology/diffusion_dislocation.cc.bak
@@ -0,0 +1,386 @@
+/*
+  Copyright (C) 2020 - 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/diffusion_dislocation.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      template <int dim>
+      DiffusionDislocation<dim>::DiffusionDislocation ()
+        = default;
+
+      template <int dim>
+      std::vector<double>
+      DiffusionDislocation<dim>::
+      calculate_isostrain_viscosities ( const double pressure,
+                                        const double temperature,
+                                        const SymmetricTensor<2,dim> &strain_rate) const
+      {
+        // This function calculates viscosities assuming that all the compositional fields
+        // experience the same strain rate (isostrain).
+
+        // If strain rate is zero (like during the first time step) set it to some very small number
+        // to prevent a division-by-zero, and a floating point exception.
+        // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
+        // strain rate (often simplified as epsilondot_ii)
+        const double edot_ii = std::max(std::sqrt(std::max(-second_invariant(deviator(strain_rate)), 0.)),
+                                        min_strain_rate);
+        const double log_edot_ii = std::log(edot_ii);
+
+
+        // Find effective viscosities for each of the individual phases
+        // Viscosities should have same number of entries as compositional fields
+        std::vector<double> composition_viscosities(n_chemical_composition_fields);
+        for (unsigned int j=0; j < n_chemical_composition_fields; ++j)
+          {
+            // Power law creep equation
+            // edot_ii_i = A_i * stress_ii_i^{n_i} * d^{-m} \exp\left(-\frac{E_i^\ast + PV_i^\ast}{n_iRT}\right)
+            // where ii indicates the square root of the second invariant and
+            // i corresponds to diffusion or dislocation creep
+
+            // For diffusion creep, viscosity is grain size dependent
+            const Rheology::DiffusionCreepParameters diffusion_creep_parameters = diffusion_creep.compute_creep_parameters(j);
+
+            // For dislocation creep, viscosity is grain size independent (m=0)
+            const Rheology::DislocationCreepParameters dislocation_creep_parameters = dislocation_creep.compute_creep_parameters(j);
+
+            // For diffusion creep, viscosity is grain size dependent
+            const double prefactor_stress_diffusion = diffusion_creep_parameters.prefactor *
+                                                      std::pow(grain_size, -diffusion_creep_parameters.grain_size_exponent) *
+                                                      std::exp(-(std::max(diffusion_creep_parameters.activation_energy + pressure*diffusion_creep_parameters.activation_volume,0.0))/
+                                                               (constants::gas_constant*temperature));
+
+            // Because the ratios of the diffusion and dislocation strain rates are not known, stress is also unknown
+            // We use Newton's method to find the second invariant of the stress tensor.
+            // Start with the assumption that all strain is accommodated by diffusion creep:
+            // If the diffusion creep prefactor is very small, that means that the diffusion viscosity is very large.
+            // In this case, use the maximum viscosity instead to compute the starting guess.
+            double stress_ii = (prefactor_stress_diffusion > (0.5 / maximum_viscosity)
+                                ?
+                                edot_ii/prefactor_stress_diffusion
+                                :
+                                0.5 / maximum_viscosity);
+            double log_stress_ii = std::log(stress_ii);
+            double log_strain_rate_residual = 2 * log_strain_rate_residual_threshold;
+            double log_strain_rate_deriv = 0;
+            unsigned int stress_iteration = 0;
+            while (std::abs(log_strain_rate_residual) > log_strain_rate_residual_threshold
+                   && stress_iteration < stress_max_iteration_number)
+              {
+                const std::pair<double, double> log_diff_edot_and_deriv = diffusion_creep.compute_log_strain_rate_and_derivative(log_stress_ii, pressure, temperature, diffusion_creep_parameters);
+                const std::pair<double, double> log_disl_edot_and_deriv = dislocation_creep.compute_log_strain_rate_and_derivative(log_stress_ii, pressure, temperature, dislocation_creep_parameters);
+
+                const double strain_rate_diffusion = std::exp(log_diff_edot_and_deriv.first);
+                const double strain_rate_dislocation = std::exp(log_disl_edot_and_deriv.first);
+                log_strain_rate_residual = std::log(strain_rate_diffusion + strain_rate_dislocation) - log_edot_ii;
+                log_strain_rate_deriv = (strain_rate_diffusion * log_diff_edot_and_deriv.second + strain_rate_dislocation * log_disl_edot_and_deriv.second)/
+                                        (strain_rate_diffusion + strain_rate_dislocation);
+
+                // If the log strain rate derivative is zero, we catch it below.
+                if (log_strain_rate_deriv>std::numeric_limits<double>::min())
+                  log_stress_ii -= log_strain_rate_residual/log_strain_rate_deriv;
+                stress_ii = std::exp(log_stress_ii);
+                stress_iteration += 1;
+
+                // In case the Newton iteration does not succeed, we do a fixpoint iteration.
+                // This allows us to bound both the diffusion and dislocation viscosity
+                // between a minimum and maximum value, so that we can compute the correct
+                // viscosity values even if the parameters lead to one or both of the
+                // viscosities being essentially zero or infinity.
+                // If anything that would be used in the next iteration is not finite, the
+                // Newton iteration would trigger an exception and we want to do the fixpoint
+                // iteration instead.
+                const bool abort_newton_iteration = !numbers::is_finite(stress_ii)
+                                                    || !numbers::is_finite(log_strain_rate_residual)
+                                                    || !numbers::is_finite(log_strain_rate_deriv)
+                                                    || log_strain_rate_deriv < std::numeric_limits<double>::min()
+                                                    || !numbers::is_finite(std::pow(stress_ii, diffusion_creep_parameters.stress_exponent-1))
+                                                    || !numbers::is_finite(std::pow(stress_ii, dislocation_creep_parameters.stress_exponent-1))
+                                                    || stress_iteration == stress_max_iteration_number;
+                if (abort_newton_iteration)
+                  {
+                    double diffusion_strain_rate = edot_ii;
+                    double dislocation_strain_rate = min_strain_rate;
+                    stress_iteration = 0;
+
+                    do
+                      {
+                        const double old_diffusion_strain_rate = diffusion_strain_rate;
+
+                        const double diffusion_prefactor = 0.5 * std::pow(diffusion_creep_parameters.prefactor,-1.0/diffusion_creep_parameters.stress_exponent);
+                        const double diffusion_grain_size_dependence = std::pow(grain_size, diffusion_creep_parameters.grain_size_exponent/diffusion_creep_parameters.stress_exponent);
+                        const double diffusion_strain_rate_dependence = std::pow(diffusion_strain_rate, (1.-diffusion_creep_parameters.stress_exponent)/diffusion_creep_parameters.stress_exponent);
+                        const double diffusion_T_and_P_dependence = std::exp(std::max(diffusion_creep_parameters.activation_energy + pressure*diffusion_creep_parameters.activation_volume,0.0)/
+                                                                             (constants::gas_constant*temperature));
+
+                        const double diffusion_viscosity = std::min(std::max(diffusion_prefactor * diffusion_grain_size_dependence
+                                                                             * diffusion_strain_rate_dependence * diffusion_T_and_P_dependence,
+                                                                             minimum_viscosity), maximum_viscosity);
+
+                        const double dislocation_prefactor = 0.5 * std::pow(dislocation_creep_parameters.prefactor,-1.0/dislocation_creep_parameters.stress_exponent);
+                        const double dislocation_strain_rate_dependence = std::pow(dislocation_strain_rate, (1.-dislocation_creep_parameters.stress_exponent)/dislocation_creep_parameters.stress_exponent);
+                        const double dislocation_T_and_P_dependence = std::exp(std::max(dislocation_creep_parameters.activation_energy + pressure*dislocation_creep_parameters.activation_volume,0.0)/
+                                                                               (dislocation_creep_parameters.stress_exponent*constants::gas_constant*temperature));
+
+                        const double dislocation_viscosity = std::min(std::max(dislocation_prefactor * dislocation_strain_rate_dependence
+                                                                               * dislocation_T_and_P_dependence,
+                                                                               minimum_viscosity), maximum_viscosity);
+
+                        diffusion_strain_rate = dislocation_viscosity / (diffusion_viscosity + dislocation_viscosity) * edot_ii;
+                        dislocation_strain_rate = diffusion_viscosity / (diffusion_viscosity + dislocation_viscosity) * edot_ii;
+
+                        ++stress_iteration;
+                        AssertThrow(stress_iteration < stress_max_iteration_number,
+                                    ExcMessage("No convergence has been reached in the loop that determines "
+                                               "the ratio of diffusion/dislocation viscosity. Aborting! "
+                                               "Residual is " + Utilities::to_string(log_strain_rate_residual) +
+                                               " after " + Utilities::to_string(stress_iteration) + " iterations. "
+                                               "You can increase the number of iterations by adapting the "
+                                               "parameter 'Maximum strain rate ratio iterations'."));
+
+                        log_strain_rate_residual = std::abs(std::log(diffusion_strain_rate/old_diffusion_strain_rate));
+                        stress_ii = 2.0 * edot_ii * 1./(1./diffusion_viscosity + 1./dislocation_viscosity);
+                      }
+                    while (log_strain_rate_residual > log_strain_rate_residual_threshold);
+
+                    break;
+                  }
+              }
+
+            // The effective viscosity, with minimum and maximum bounds
+            composition_viscosities[j] = std::min(std::max(stress_ii/edot_ii/2, minimum_viscosity), maximum_viscosity);
+          }
+        return composition_viscosities;
+      }
+
+      template <int dim>
+      double
+      DiffusionDislocation<dim>::compute_viscosity (const double pressure,
+                                                    const double temperature,
+                                                    const std::vector<double> &volume_fractions,
+                                                    const SymmetricTensor<2,dim> &strain_rate) const
+      {
+        // Currently, the viscosities for each of the compositional fields are calculated assuming
+        // isostrain amongst all compositions, allowing calculation of the viscosity ratio.
+        // TODO: This is only consistent with viscosity averaging if the arithmetic averaging
+        // scheme is chosen. It would be useful to have a function to calculate isostress viscosities.
+        const std::vector<double> composition_viscosities =
+          calculate_isostrain_viscosities(pressure, temperature, strain_rate);
+
+        // The isostrain condition implies that the viscosity averaging should be arithmetic (see above).
+        // We have given the user freedom to apply alternative bounds, because in diffusion-dominated
+        // creep (where n_diff=1) viscosities are stress and strain-rate independent, so the calculation
+        // of compositional field viscosities is consistent with any averaging scheme.
+        return MaterialUtilities::average_value(volume_fractions, composition_viscosities, viscosity_averaging);
+      }
+
+
+      template <int dim>
+      void
+      DiffusionDislocation<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        // Reference and minimum/maximum values
+        prm.declare_entry ("Reference temperature", "293.", Patterns::Double(0.),
+                           "For calculating density by thermal expansivity. Units: \\si{\\kelvin}.");
+        prm.declare_entry ("Minimum strain rate", "1.4e-20", Patterns::Double(0.),
+                           "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}.");
+        prm.declare_entry ("Minimum viscosity", "1e17", Patterns::Double(0.),
+                           "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}.");
+        prm.declare_entry ("Maximum viscosity", "1e28", Patterns::Double(0.),
+                           "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}.");
+        prm.declare_entry ("Effective viscosity coefficient", "1.0", Patterns::Double(0.),
+                           "Scaling coefficient for effective viscosity.");
+
+        // Viscosity iteration parameters
+        prm.declare_entry ("Strain rate residual tolerance", "1e-10", Patterns::Double(0.),
+                           "Tolerance for determining the correct stress and viscosity from the "
+                           "strain rate by internal iteration. The tolerance is expressed as the "
+                           "difference between the natural logarithm of the input strain rate and "
+                           "the strain rate at the current iteration. This determines that strain "
+                           "rate is correctly partitioned between diffusion and dislocation creep "
+                           "assuming that both mechanisms experience the same stress.");
+        prm.declare_entry ("Maximum strain rate ratio iterations", "40", Patterns::Integer(0),
+                           "Maximum number of iterations to find the correct "
+                           "diffusion/dislocation strain rate ratio.");
+
+        // Equation of state parameters
+        prm.declare_entry ("Thermal diffusivity", "0.8e-6", Patterns::Double(0.),
+                           "Units: \\si{\\meter\\squared\\per\\second}.");
+        prm.declare_entry ("Heat capacity", "1.25e3",
+                           Patterns::Double(0.),
+                           "The value of the specific heat $C_p$. "
+                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+        prm.declare_entry ("Densities", "3300.",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of densities, $\\rho$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+        prm.declare_entry ("Thermal expansivities", "3.5e-5",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of thermal expansivities for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}.");
+
+        // Rheological parameters
+        prm.declare_entry ("Viscosity averaging scheme", "harmonic",
+                           Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
+                           "When more than one compositional field is present at a point "
+                           "with different viscosities, we need to come up with an average "
+                           "viscosity at that point.  Select a weighted harmonic, arithmetic, "
+                           "geometric, or maximum composition.");
+        // Diffusion creep parameters
+        prm.declare_entry ("Prefactors for diffusion creep", "1.5e-15",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of viscosity prefactors, $A$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\per\\pascal} \\si{\\meter}$^{m_{\\text{diffusion}}}$ \\si{\\per\\second}.");
+        prm.declare_entry ("Stress exponents for diffusion creep", "1.",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of stress exponents, $n_{\\text{diffusion}}$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+        prm.declare_entry ("Grain size exponents for diffusion creep", "3.",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of grain size exponents, $m_{\\text{diffusion}}$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+        prm.declare_entry ("Activation energies for diffusion creep", "375e3",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of activation energies, $E_a$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\joule\\per\\mole}.");
+        prm.declare_entry ("Activation volumes for diffusion creep", "6e-6",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of activation volumes, $V_a$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
+
+        // Dislocation creep parameters
+        prm.declare_entry ("Prefactors for dislocation creep", "1.1e-16",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of viscosity prefactors, $A$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\pascal}$^{-n_{\\text{dislocation}}}$\\si{\\per\\second}.");
+        prm.declare_entry ("Stress exponents for dislocation creep", "3.5",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of stress exponents, $n_{\\text{dislocation}}$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+        prm.declare_entry ("Activation energies for dislocation creep", "530e3",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of activation energies, $E_a$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\joule\\per\\mole}.");
+        prm.declare_entry ("Activation volumes for dislocation creep", "1.4e-5",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of activation volumes, $V_a$, for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
+
+        // Diffusion creep parameters
+        Rheology::DiffusionCreep<dim>::declare_parameters(prm);
+
+        // Dislocation creep parameters
+        Rheology::DislocationCreep<dim>::declare_parameters(prm);
+      }
+
+
+
+      template <int dim>
+      void
+      DiffusionDislocation<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        // Reference and minimum/maximum values
+        min_strain_rate = prm.get_double("Minimum strain rate");
+        minimum_viscosity = prm.get_double ("Minimum viscosity");
+        maximum_viscosity = prm.get_double ("Maximum viscosity");
+
+        // Iteration parameters
+        log_strain_rate_residual_threshold = prm.get_double ("Strain rate residual tolerance");
+        stress_max_iteration_number = prm.get_integer ("Maximum strain rate ratio iterations");
+
+        // ---- Compositional parameters
+        grain_size = prm.get_double("Grain size");
+
+        viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
+                              prm);
+
+        // Rheological parameters for chemical compositions
+        // increment by one for background:
+        n_chemical_composition_fields = this->introspection().n_chemical_composition_fields() + 1;
+
+        // Diffusion creep parameters
+        diffusion_creep.initialize_simulator (this->get_simulator());
+        diffusion_creep.parse_parameters(prm, std::make_unique<std::vector<unsigned int>>(n_chemical_composition_fields));
+
+        // Dislocation creep parameters
+        dislocation_creep.initialize_simulator (this->get_simulator());
+        dislocation_creep.parse_parameters(prm, std::make_unique<std::vector<unsigned int>>(n_chemical_composition_fields));
+
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class DiffusionDislocation<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/dislocation_creep.cc.bak b/source/material_model/rheology/dislocation_creep.cc.bak
new file mode 100644
index 00000000000..511444fb281
--- /dev/null
+++ b/source/material_model/rheology/dislocation_creep.cc.bak
@@ -0,0 +1,285 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/dislocation_creep.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      DislocationCreepParameters::DislocationCreepParameters()
+        :  prefactor (numbers::signaling_nan<double>()),
+           activation_energy (numbers::signaling_nan<double>()),
+           activation_volume (numbers::signaling_nan<double>()),
+           stress_exponent (numbers::signaling_nan<double>())
+      {}
+
+
+
+      template <int dim>
+      DislocationCreep<dim>::DislocationCreep ()
+        = default;
+
+
+
+      template <int dim>
+      const DislocationCreepParameters
+      DislocationCreep<dim>::compute_creep_parameters (const unsigned int composition,
+                                                       const std::vector<double> &phase_function_values,
+                                                       const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        DislocationCreepParameters creep_parameters;
+        if (phase_function_values == std::vector<double>())
+          {
+            // no phases
+            creep_parameters.prefactor = prefactors_dislocation[composition];
+            creep_parameters.activation_energy = activation_energies_dislocation[composition];
+            creep_parameters.activation_volume = activation_volumes_dislocation[composition];
+            creep_parameters.stress_exponent = stress_exponents_dislocation[composition];
+          }
+        else
+          {
+            // Average among phases
+            creep_parameters.prefactor = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                         prefactors_dislocation, composition,
+                                         MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic);
+            creep_parameters.activation_energy = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 activation_energies_dislocation, composition);
+            creep_parameters.activation_volume = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 activation_volumes_dislocation , composition);
+            creep_parameters.stress_exponent = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                               stress_exponents_dislocation, composition);
+          }
+
+        return creep_parameters;
+      }
+
+
+
+      template <int dim>
+      double
+      DislocationCreep<dim>::compute_viscosity (const double strain_rate,
+                                                const double pressure,
+                                                const double temperature,
+                                                const unsigned int composition,
+                                                const std::vector<double> &phase_function_values,
+                                                const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        const DislocationCreepParameters p = compute_creep_parameters(composition,
+                                                                      phase_function_values,
+                                                                      n_phase_transitions_per_composition);
+
+        // Power law creep equation:
+        //    viscosity = 0.5 * A^(-1/n) * edot_ii^((1-n)/n) * exp((E + P*V)/(nRT))
+        // A: prefactor, edot_ii: square root of second invariant of deviatoric strain rate tensor,
+        // E: activation energy, P: pressure,
+        // V; activation volume, n: stress exponent, R: gas constant, T: temperature.
+        double viscosity_dislocation = 0.5 * std::pow(p.prefactor,-1/p.stress_exponent) *
+                                       std::exp((p.activation_energy + pressure*p.activation_volume)/
+                                                (constants::gas_constant*temperature*p.stress_exponent)) *
+                                       std::pow(strain_rate,((1. - p.stress_exponent)/p.stress_exponent));
+
+        Assert (viscosity_dislocation > 0.0,
+                ExcMessage ("Negative dislocation viscosity detected. This is unphysical and should not happen. "
+                            "Check for negative parameters. Temperature and pressure are "
+                            + Utilities::to_string(temperature) + " K, " + Utilities::to_string(pressure) + " Pa. "));
+
+        // Creep viscosities become extremely large at low
+        // temperatures and can therefore provoke floating-point overflow errors. In
+        // real rocks, other deformation mechanisms become dominant at low temperatures,
+        // so these high viscosities are never achieved. It is therefore both reasonable
+        // and desirable to require the single-mechanism viscosity to be smaller than
+        // std::sqrt(max_double).
+        viscosity_dislocation = std::min(viscosity_dislocation, std::sqrt(std::numeric_limits<double>::max()));
+
+        return viscosity_dislocation;
+      }
+
+
+
+      template <int dim>
+      std::pair<double, double>
+      DislocationCreep<dim>::compute_strain_rate_and_derivative (const double stress,
+                                                                 const double pressure,
+                                                                 const double temperature,
+                                                                 const DislocationCreepParameters creep_parameters) const
+      {
+        // Power law creep equation:
+        //   edot_ii_partial = A * stress^n * exp(-(E + P*V)/(RT))
+        //   d(edot_ii_partial)/d(stress) = A * n * stress^(n-1) * exp(-(E + P*V)/(RT))
+        // A: prefactor, edot_ii_partial: square root of second invariant of deviatoric strain rate tensor attributable to the creep mechanism,
+        // stress: deviatoric stress, E: activation energy, P: pressure,
+        // V; activation volume, n: stress exponent, R: gas constant, T: temperature.
+        const double strain_rate_dislocation = creep_parameters.prefactor *
+                                               std::pow(stress,creep_parameters.stress_exponent) *
+                                               std::exp(-(creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
+                                                        (constants::gas_constant*temperature));
+
+        const double dstrain_rate_dstress_dislocation = creep_parameters.prefactor *
+                                                        creep_parameters.stress_exponent *
+                                                        std::pow(stress,creep_parameters.stress_exponent-1.) *
+                                                        std::exp(-(creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
+                                                                 (constants::gas_constant*temperature));
+
+        return std::make_pair(strain_rate_dislocation, dstrain_rate_dstress_dislocation);
+      }
+
+
+      template <int dim>
+      std::pair<double, double>
+      DislocationCreep<dim>::compute_log_strain_rate_and_derivative (const double log_stress,
+                                                                     const double pressure,
+                                                                     const double temperature,
+                                                                     const DislocationCreepParameters creep_parameters) const
+      {
+        // Power law creep equation
+        // log(edot_ii_partial) = std::log(A) + n*std::log(stress) - m*std::log(d) - (E + P*V)/(RT)
+        //   d(log_edot_ii_partial)/d(log_stress) = n
+        // A: prefactor, edot_ii_partial: square root of second invariant of deviatoric strain rate tensor attributable to the creep mechanism,
+        // stress: deviatoric stress, E: activation energy, P: pressure,
+        // V; activation volume, n: stress exponent, R: gas constant, T: temperature.
+        const double log_strain_rate_dislocation = std::log(creep_parameters.prefactor) +
+                                                   creep_parameters.stress_exponent * log_stress -
+                                                   (creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
+                                                   (constants::gas_constant*temperature);
+
+        const double dlog_strain_rate_dlog_stress_dislocation = creep_parameters.stress_exponent;
+
+        return std::make_pair(log_strain_rate_dislocation, dlog_strain_rate_dlog_stress_dislocation);
+      }
+
+
+
+      template <int dim>
+      void
+      DislocationCreep<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Prefactors for dislocation creep", "1.1e-16",
+                           Patterns::Anything(),
+                           "List of viscosity prefactors, $A$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\pascal}$^{-n_{\\text{dislocation}}}$ \\si{\\per\\second}.");
+        prm.declare_entry ("Stress exponents for dislocation creep", "3.5",
+                           Patterns::Anything(),
+                           "List of stress exponents, $n_{\\text{dislocation}}$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+        prm.declare_entry ("Activation energies for dislocation creep", "530e3",
+                           Patterns::Anything(),
+                           "List of activation energies, $E_a$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\joule\\per\\mole}.");
+        prm.declare_entry ("Activation volumes for dislocation creep", "1.4e-5",
+                           Patterns::Anything(),
+                           "List of activation volumes, $V_a$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
+      }
+
+
+
+      template <int dim>
+      void
+      DislocationCreep<dim>::parse_parameters (ParameterHandler &prm,
+                                               const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
+      {
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(), "background");
+
+        // Make options file for parsing maps to double arrays
+        Utilities::MapParsing::Options options(chemical_field_names, "Prefactors for dislocation creep");
+        options.list_of_allowed_keys = compositional_field_names;
+        options.allow_multiple_values_per_key = true;
+        if (expected_n_phases_per_composition)
+          {
+            options.n_values_per_key = *expected_n_phases_per_composition;
+
+            // check_values_per_key is required to be true to duplicate single values
+            // if they are to be used for all phases associated with a given key.
+            options.check_values_per_key = true;
+          }
+
+        // Read parameters, each of size of number of composition + number of phases + 1
+        prefactors_dislocation = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactors for dislocation creep"),
+                                                                                  options);
+
+        options.property_name = "Stress exponents for dislocation creep";
+        stress_exponents_dislocation = Utilities::MapParsing::parse_map_to_double_array(prm.get("Stress exponents for dislocation creep"),
+                                                                                        options);
+
+        options.property_name = "Activation energies for dislocation creep";
+        activation_energies_dislocation = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation energies for dislocation creep"),
+                                          options);
+
+        options.property_name = "Activation volumes for dislocation creep";
+        activation_volumes_dislocation = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation volumes for dislocation creep"),
+                                         options);
+
+        // Check that there are no prefactor entries set to zero,
+        // for example because the entry is for a field
+        // that is masked anyway, like strain. Despite
+        // these compositions being masked, their viscosities
+        // are computed anyway and this will lead to division by zero.
+        for (const double prefactor : prefactors_dislocation)
+          AssertThrow(prefactor > 0., ExcMessage("The dislocation prefactor should be larger than zero."));
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class DislocationCreep<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/drucker_prager.cc.bak b/source/material_model/rheology/drucker_prager.cc.bak
new file mode 100644
index 00000000000..aa5856a7a5e
--- /dev/null
+++ b/source/material_model/rheology/drucker_prager.cc.bak
@@ -0,0 +1,294 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/drucker_prager.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      DruckerPragerParameters::DruckerPragerParameters()
+        : angle_internal_friction (numbers::signaling_nan<double>()),
+          cohesion  (numbers::signaling_nan<double>()),
+          max_yield_stress (numbers::signaling_nan<double>())
+      {}
+
+
+
+      template <int dim>
+      DruckerPrager<dim>::DruckerPrager ()
+        = default;
+
+
+
+      template <int dim>
+      const DruckerPragerParameters
+      DruckerPrager<dim>::compute_drucker_prager_parameters (const unsigned int composition,
+                                                             const std::vector<double> &phase_function_values,
+                                                             const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        DruckerPragerParameters drucker_prager_parameters;
+
+        drucker_prager_parameters.max_yield_stress = max_yield_stress;
+
+        if (phase_function_values == std::vector<double>())
+          {
+            // no phases
+            drucker_prager_parameters.angle_internal_friction = angles_internal_friction[composition];
+            drucker_prager_parameters.cohesion = cohesions[composition];
+          }
+        else
+          {
+            // Average among phases
+            drucker_prager_parameters.angle_internal_friction = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                                angles_internal_friction, composition);
+            drucker_prager_parameters.cohesion = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 cohesions, composition);
+          }
+        return drucker_prager_parameters;
+      }
+
+      template <int dim>
+      double
+      DruckerPrager<dim>::compute_yield_stress (const double cohesion,
+                                                const double angle_internal_friction,
+                                                const double pressure,
+                                                const double max_yield_stress) const
+      {
+        const double sin_phi = std::sin(angle_internal_friction);
+        const double cos_phi = std::cos(angle_internal_friction);
+
+        // The expression below differs from Eq. 9 of Glerum et al, 2018.
+        // There are actually three different ways of choosing this parameter, which
+        // correspond to the Drucker-Prager yield surface either
+        // circumscribing (Glerum et al 2018), middle circumscribing or
+        // inscribing the Mohr-Coulomb yield surface.
+        // See for instance Owen & Hinton, Finite Elements in Plasticity, 1980.
+        // Here the middle circumscribing approach is taken.
+        const double stress_inv_part = 1. / (std::sqrt(3.0) * (3.0 + sin_phi));
+
+        // Initial yield stress (no stabilization terms)
+        const double yield_stress = ( (dim==3)
+                                      ?
+                                      ( 6.0 * cohesion * cos_phi + 6.0 * pressure * sin_phi) * stress_inv_part
+                                      :
+                                      cohesion * cos_phi + pressure * sin_phi);
+
+        return std::min(yield_stress, max_yield_stress);
+      }
+
+
+
+      template <int dim>
+      double
+      DruckerPrager<dim>::compute_viscosity (const double cohesion,
+                                             const double angle_internal_friction,
+                                             const double pressure,
+                                             const double effective_strain_rate,
+                                             const double max_yield_stress,
+                                             const double non_yielding_viscosity) const
+      {
+        const double yield_stress = compute_yield_stress(cohesion, angle_internal_friction, pressure, max_yield_stress);
+
+        // If there is no damper, the yielding plastic element accommodates all the strain
+        double apparent_viscosity = yield_stress / (2. * effective_strain_rate);
+
+        // If the plastic damper is used, the effective strain rate is partitioned between the
+        // viscoelastic and damped plastic (Bingham) elements. Assuming that the viscoelastic
+        // elements have viscosities that are not strain rate dependent, we have:
+        // edot_eff = tau_T / (2 * eta_ve) + (tau_T - tau_yield) / (2 * eta_d)
+        // The apparent viscosity is defined such that:
+        // tau_T = 2 * eta_app * edot_eff.
+        // Substituting one equation into the other and rearranging yields the expression
+        // eta_app = ((1 + tau_yield / (2 * eta_d * edot_eff)) / (1 / eta_d + 1 / eta_ve)).
+        if (use_plastic_damper)
+          {
+            apparent_viscosity = ((damper_viscosity + apparent_viscosity) /
+                                  (1. + damper_viscosity / non_yielding_viscosity));
+          }
+
+        return apparent_viscosity;
+      }
+
+
+
+      template <int dim>
+      std::pair<double, double>
+      DruckerPrager<dim>::compute_strain_rate_and_derivative (const double stress,
+                                                              const double pressure,
+                                                              const DruckerPragerParameters p) const
+      {
+
+        const double yield_stress = compute_yield_stress(p.cohesion, p.angle_internal_friction, pressure, p.max_yield_stress);
+
+        if (stress > yield_stress)
+          {
+            return std::make_pair((stress - yield_stress)/(2.*damper_viscosity), 1./(2.*damper_viscosity));
+          }
+        else
+          {
+            return std::make_pair(0., 0.);
+          }
+      }
+
+
+
+      template <int dim>
+      double
+      DruckerPrager<dim>::compute_derivative (const double angle_internal_friction,
+                                              const double effective_strain_rate) const
+      {
+        const double sin_phi = std::sin(angle_internal_friction);
+
+        const double stress_inv_part = 1. / (std::sqrt(3.0) * (3.0 + sin_phi));
+
+        const double strain_rate_effective_inv = 1./(2.*effective_strain_rate);
+
+        const double viscosity_pressure_derivative = sin_phi * strain_rate_effective_inv *
+                                                     (dim == 3
+                                                      ?
+                                                      (6.0 * stress_inv_part)
+                                                      :
+                                                      1);
+
+        return viscosity_pressure_derivative;
+      }
+
+
+
+      template <int dim>
+      void
+      DruckerPrager<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Angles of internal friction", "0.",
+                           Patterns::Anything(),
+                           "List of angles of internal friction, $\\phi$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "For a value of zero, in 2d the von Mises criterion is retrieved. "
+                           "Angles higher than 30 degrees are harder to solve numerically. Units: degrees.");
+        prm.declare_entry ("Cohesions", "1e20",
+                           Patterns::Anything(),
+                           "List of cohesions, $C$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "The extremely large default cohesion value (1e20 Pa) prevents the viscous stress from "
+                           "exceeding the yield stress. Units: \\si{\\pascal}.");
+        prm.declare_entry ("Maximum yield stress", "1e12", Patterns::Double (0.),
+                           "Limits the maximum value of the yield stress determined by the "
+                           "Drucker-Prager plasticity parameters. Default value is chosen so this "
+                           "is not automatically used. Values of 100e6--1000e6 $Pa$ have been used "
+                           "in previous models. Units: \\si{\\pascal}.");
+        prm.declare_entry ("Use plastic damper","false",
+                           Patterns::Bool (),
+                           "Whether to use a plastic damper when computing the Drucker-Prager "
+                           "plastic viscosity. The damper acts to stabilize the plastic shear "
+                           "band width and remove associated mesh-dependent behavior at "
+                           "sufficient resolutions.");
+        prm.declare_entry ("Plastic damper viscosity", "0.0", Patterns::Double(0),
+                           "Viscosity of the damper that acts in parallel with the plastic viscosity "
+                           "to produce mesh-independent behavior at sufficient resolutions. Units: \\si{\\pascal\\second}");
+      }
+
+
+
+      template <int dim>
+      void
+      DruckerPrager<dim>::parse_parameters (ParameterHandler &prm,
+                                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
+      {
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(), "background");
+
+        Utilities::MapParsing::Options options(chemical_field_names, "Angles of internal friction");
+        options.list_of_allowed_keys = compositional_field_names;
+
+        if (expected_n_phases_per_composition)
+          {
+            options.allow_multiple_values_per_key = true;
+            options.n_values_per_key = *expected_n_phases_per_composition;
+
+            // check_values_per_key is required to be true to duplicate single values
+            // if they are to be used for all phases associated with a given key.
+            options.check_values_per_key = true;
+          }
+
+        angles_internal_friction = Utilities::MapParsing::parse_map_to_double_array(prm.get("Angles of internal friction"),
+                                                                                    options);
+
+        // Convert angles from degrees to radians
+        for (double &angle : angles_internal_friction)
+          angle *= constants::degree_to_radians;
+
+        options.property_name = "Cohesions";
+        cohesions = Utilities::MapParsing::parse_map_to_double_array(prm.get("Cohesions"),
+                                                                     options);
+
+        // Limit maximum value of the Drucker-Prager yield stress
+        max_yield_stress = prm.get_double("Maximum yield stress");
+
+        // Whether to include a plastic damper when computing the Drucker-Prager plastic viscosity
+        use_plastic_damper = prm.get_bool("Use plastic damper");
+
+        // Stabilize plasticity through a viscous damper.
+        // The viscosity of the damper is implicitly zero if it is not used
+        if (use_plastic_damper)
+          damper_viscosity = prm.get_double("Plastic damper viscosity");
+        else
+          damper_viscosity = 0.;
+
+      }
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class DruckerPrager<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/elasticity.cc.bak b/source/material_model/rheology/elasticity.cc.bak
new file mode 100644
index 00000000000..dd4022c4650
--- /dev/null
+++ b/source/material_model/rheology/elasticity.cc.bak
@@ -0,0 +1,529 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/elasticity.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/quadrature_lib.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace
+    {
+      std::vector<std::string> make_elastic_additional_outputs_names()
+      {
+        std::vector<std::string> names;
+        names.emplace_back("elastic_shear_modulus");
+        return names;
+      }
+    }
+
+    template <int dim>
+    ElasticAdditionalOutputs<dim>::ElasticAdditionalOutputs (const unsigned int n_points)
+      :
+      NamedAdditionalMaterialOutputs<dim>(make_elastic_additional_outputs_names()),
+      elastic_shear_moduli(n_points, numbers::signaling_nan<double>())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    ElasticAdditionalOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      (void)idx; // suppress warning in release mode
+      AssertIndexRange (idx, 1);
+      return elastic_shear_moduli;
+    }
+
+
+
+    namespace Rheology
+    {
+      template <int dim>
+      void
+      Elasticity<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Elastic shear moduli", "75.0e9",
+                           Patterns::List(Patterns::Double(0.)),
+                           "List of elastic shear moduli, $G$, "
+                           "for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "The default value of 75 GPa is representative of mantle rocks. Units: Pa.");
+        prm.declare_entry ("Use fixed elastic time step", "unspecified",
+                           Patterns::Selection("true|false|unspecified"),
+                           "Select whether the material time scale in the viscoelastic constitutive "
+                           "relationship uses the regular numerical time step or a separate fixed "
+                           "elastic time step throughout the model run. The fixed elastic time step "
+                           "is always used during the initial time step. If a fixed elastic time "
+                           "step is used throughout the model run, a stress averaging scheme is "
+                           "applied to account for differences with the numerical time step. An "
+                           "alternative approach is to limit the maximum time step size so that it "
+                           "is equal to the elastic time step. The default value of this parameter is "
+                           "'unspecified', which throws an exception during runtime. In order for "
+                           "the model to run the user must select 'true' or 'false'.");
+        prm.declare_entry ("Fixed elastic time step", "1.e3",
+                           Patterns::Double (0.),
+                           "The fixed elastic time step $dte$. Units: years if the "
+                           "'Use years in output instead of seconds' parameter is set; "
+                           "seconds otherwise.");
+        prm.declare_entry ("Stabilization time scale factor", "1.",
+                           Patterns::Double (1.),
+                           "A stabilization factor for the elastic stresses that influences how fast "
+                           "elastic stresses adjust to deformation. 1.0 is equivalent to no stabilization "
+                           "and may lead to oscillatory motion. Setting the factor to 2 "
+                           "avoids oscillations, but still enables an immediate elastic response. "
+                           "However, in complex models this can lead to problems of convergence, in which "
+                           "case the factor needs to be increased slightly. Setting the factor to "
+                           "infinity is equivalent to not applying elastic stresses at all. The "
+                           "factor is multiplied with the computational time step to create a time scale. ");
+        prm.declare_entry ("Elastic damper viscosity", "0.0",
+                           Patterns::Double (0.),
+                           "Viscosity of a viscous damper that acts in parallel with the elastic "
+                           "element to stabilize behavior. Units: \\si{\\pascal\\second}");
+      }
+
+
+
+      template <int dim>
+      void
+      Elasticity<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+        Utilities::MapParsing::Options options(chemical_field_names, "Elastic shear moduli");
+        options.list_of_allowed_keys = compositional_field_names;
+
+        elastic_shear_moduli = Utilities::MapParsing::parse_map_to_double_array (prm.get("Elastic shear moduli"),
+                                                                                 options);
+
+        // Stabilize elasticity through a viscous damper
+        elastic_damper_viscosity = prm.get_double("Elastic damper viscosity");
+
+        if (prm.get ("Use fixed elastic time step") == "true")
+          use_fixed_elastic_time_step = true;
+        else if (prm.get ("Use fixed elastic time step") == "false")
+          use_fixed_elastic_time_step = false;
+        else
+          AssertThrow(false, ExcMessage("'Use fixed elastic time step' must be set to 'true' or 'false'"));
+
+        stabilization_time_scale_factor = prm.get_double ("Stabilization time scale factor");
+
+        fixed_elastic_time_step = prm.get_double ("Fixed elastic time step");
+        AssertThrow(fixed_elastic_time_step > 0,
+                    ExcMessage("The fixed elastic time step must be greater than zero"));
+
+        if (this->convert_output_to_years())
+          fixed_elastic_time_step *= year_in_seconds;
+
+        AssertThrow(this->get_parameters().enable_elasticity == true,
+                    ExcMessage ("Material model Viscoelastic only works if 'Enable elasticity' is set to true"));
+
+        // Check whether the compositional fields representing the viscoelastic
+        // stress tensor are both named correctly and listed in the right order.
+        AssertThrow(this->introspection().compositional_index_for_name("ve_stress_xx") == 0,
+                    ExcMessage("Rheology model Elasticity only works if the first "
+                               "compositional field is called ve_stress_xx."));
+        AssertThrow(this->introspection().compositional_index_for_name("ve_stress_yy") == 1,
+                    ExcMessage("Rheology model Elasticity only works if the second "
+                               "compositional field is called ve_stress_yy."));
+        if (dim == 2)
+          {
+            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_xy") == 2,
+                        ExcMessage("Rheology model Elasticity only works if the third "
+                                   "compositional field is called ve_stress_xy."));
+          }
+        else if (dim == 3)
+          {
+            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_zz") == 2,
+                        ExcMessage("Rheology model Elasticity only works if the third "
+                                   "compositional field is called ve_stress_zz."));
+            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_xy") == 3,
+                        ExcMessage("Rheology model Elasticity only works if the fourth "
+                                   "compositional field is called ve_stress_xy."));
+            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_xz") == 4,
+                        ExcMessage("Rheology model Elasticity only works if the fifth "
+                                   "compositional field is called ve_stress_xz."));
+            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_yz") == 5,
+                        ExcMessage("Rheology model Elasticity only works if the sixth "
+                                   "compositional field is called ve_stress_yz."));
+          }
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        // Currently, it only makes sense to use this material model when the nonlinear solver
+        // scheme does a single Advection iteration and at minimum one Stokes iteration. More
+        // than one nonlinear Advection iteration will produce an unrealistic build-up of
+        // viscoelastic stress, which are tracked through compositional fields.
+        AssertThrow((this->get_parameters().nonlinear_solver ==
+                     Parameters<dim>::NonlinearSolver::single_Advection_single_Stokes
+                     ||
+                     this->get_parameters().nonlinear_solver ==
+                     Parameters<dim>::NonlinearSolver::single_Advection_iterated_Stokes
+                     ||
+                     this->get_parameters().nonlinear_solver ==
+                     Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes
+                     ||
+                     this->get_parameters().nonlinear_solver ==
+                     Parameters<dim>::NonlinearSolver::single_Advection_iterated_defect_correction_Stokes),
+                    ExcMessage("The material model will only work with the nonlinear "
+                               "solver schemes 'single Advection, single Stokes', "
+                               "'single Advection, iterated Stokes', "
+                               "'single Advection, iterated Newton Stokes', and "
+                               "'single Advection, iterated defect correction Stokes' "));
+
+        // Functionality to average the additional RHS terms over the cell is not implemented.
+        // Also, there is no option implemented in this rheology module to project to Q1 the viscosity
+        // in the elastic force term for the RHS.
+        // Consequently, it is only possible to use elasticity with the Material averaging schemes
+        // 'none', 'harmonic average only viscosity', and 'geometric average only viscosity'.
+        // TODO: Find a way to include 'project to Q1 only viscosity'.
+        AssertThrow((this->get_parameters().material_averaging == MaterialModel::MaterialAveraging::none
+                     ||
+                     this->get_parameters().material_averaging == MaterialModel::MaterialAveraging::harmonic_average_only_viscosity
+                     ||
+                     this->get_parameters().material_averaging == MaterialModel::MaterialAveraging::geometric_average_only_viscosity
+                     ||
+                     this->get_parameters().material_averaging == MaterialModel::MaterialAveraging::default_averaging),
+                    ExcMessage("Material models with elasticity can only be used with the material "
+                               "averaging schemes 'none', 'harmonic average only viscosity' and "
+                               "'geometric average only viscosity'. This parameter ('Material averaging') "
+                               "is located within the 'Material model' subsection."));
+      }
+
+
+
+      template <int dim>
+      void
+      Elasticity<dim>::create_elastic_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+        if (out.template get_additional_output<ElasticAdditionalOutputs<dim>>() == nullptr)
+          {
+            const unsigned int n_points = out.n_evaluation_points();
+            out.additional_outputs.push_back(
+              std::make_unique<ElasticAdditionalOutputs<dim>> (n_points));
+          }
+      }
+
+
+      namespace
+      {
+        MaterialAveraging::AveragingOperation
+        get_averaging_operation_for_viscosity(const MaterialAveraging::AveragingOperation operation)
+        {
+          MaterialAveraging::AveragingOperation operation_for_viscosity = operation;
+          switch (operation)
+            {
+              case MaterialAveraging::harmonic_average:
+                operation_for_viscosity = MaterialAveraging::harmonic_average_only_viscosity;
+                break;
+
+              case MaterialAveraging::geometric_average:
+                operation_for_viscosity = MaterialAveraging::geometric_average_only_viscosity;
+                break;
+
+              case MaterialAveraging::project_to_Q1:
+                operation_for_viscosity = MaterialAveraging::project_to_Q1_only_viscosity;
+                break;
+
+              default:
+                operation_for_viscosity = operation;
+            }
+
+          return operation_for_viscosity;
+        }
+      }
+
+
+
+      template <int dim>
+      void
+      Elasticity<dim>::fill_elastic_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
+                                             const std::vector<double> &average_elastic_shear_moduli,
+                                             MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+        // Create a reference to the structure for the elastic outputs
+        MaterialModel::ElasticOutputs<dim>
+        *elastic_out = out.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
+
+        if (elastic_out == nullptr)
+          return;
+
+        if (in.requests_property(MaterialProperties::additional_outputs))
+          {
+            // The viscosity should be averaged if material averaging is applied.
+            std::vector<double> effective_creep_viscosities;
+            if (this->get_parameters().material_averaging != MaterialAveraging::none)
+              {
+                MaterialModelOutputs<dim> out_copy(out.n_evaluation_points(),
+                                                   this->introspection().n_compositional_fields);
+                out_copy.viscosities = out.viscosities;
+
+                const MaterialAveraging::AveragingOperation averaging_operation_for_viscosity =
+                  get_averaging_operation_for_viscosity(this->get_parameters().material_averaging);
+                MaterialAveraging::average(averaging_operation_for_viscosity,
+                                           in.current_cell,
+                                           this->introspection().quadratures.velocities,
+                                           this->get_mapping(),
+                                           in.requested_properties,
+                                           out_copy);
+
+                effective_creep_viscosities = out_copy.viscosities;
+              }
+            else
+              effective_creep_viscosities = out.viscosities;
+
+            for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+              {
+                // Get old stresses from compositional fields
+                const SymmetricTensor<2,dim> stress_old (Utilities::Tensors::to_symmetric_tensor<dim>(&in.composition[i][0],
+                                                         &in.composition[i][0]+SymmetricTensor<2,dim>::n_independent_components));
+
+                elastic_out->elastic_force[i] = -effective_creep_viscosities[i] / calculate_elastic_viscosity(average_elastic_shear_moduli[i]) * stress_old;
+                // The viscoelastic strain rate is needed only when the Newton method is selected.
+                const typename Parameters<dim>::NonlinearSolver::Kind nonlinear_solver = this->get_parameters().nonlinear_solver;
+                if ((nonlinear_solver == Parameters<dim>::NonlinearSolver::iterated_Advection_and_Newton_Stokes) ||
+                    (nonlinear_solver == Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes))
+                  elastic_out->viscoelastic_strain_rate[i] = calculate_viscoelastic_strain_rate(in.strain_rate[i], stress_old, average_elastic_shear_moduli[i]);
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      Elasticity<dim>::fill_reaction_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
+                                              const std::vector<double> &average_elastic_shear_moduli,
+                                              MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+        if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0 && in.requests_property(MaterialProperties::reaction_terms))
+          {
+            // Get old (previous time step) velocity gradients
+            std::vector<Point<dim>> quadrature_positions(in.n_evaluation_points());
+            for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+              quadrature_positions[i] = this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]);
+
+            std::vector<double> solution_values(this->get_fe().dofs_per_cell);
+            in.current_cell->get_dof_values(this->get_old_solution(),
+                                            solution_values.begin(),
+                                            solution_values.end());
+
+            // Only create the evaluator the first time we get here
+            if (!evaluator)
+              evaluator = std::make_unique<FEPointEvaluation<dim,dim>>(this->get_mapping(),
+                                                                        this->get_fe(),
+                                                                        update_gradients,
+                                                                        this->introspection().component_indices.velocities[0]);
+
+            // Initialize the evaluator for the old velocity gradients
+            evaluator->reinit(in.current_cell, quadrature_positions);
+            evaluator->evaluate(solution_values,
+                                EvaluationFlags::gradients);
+
+            const double dte = elastic_timestep();
+            const double dt = this->get_timestep();
+
+            // The viscosity should be averaged if material averaging is applied.
+            // Here the averaging scheme "project to Q1 (only viscosity)"  is
+            // excluded, because there is no way to know the quadrature formula
+            // used for evaluation.
+            // TODO: find a way to include "project to Q1 (only viscosity)" as well.
+            std::vector<double> effective_creep_viscosities;
+            if (this->get_parameters().material_averaging != MaterialAveraging::none &&
+                this->get_parameters().material_averaging != MaterialAveraging::project_to_Q1 &&
+                this->get_parameters().material_averaging != MaterialAveraging::project_to_Q1_only_viscosity)
+              {
+                MaterialModelOutputs<dim> out_copy(out.n_evaluation_points(),
+                                                   this->introspection().n_compositional_fields);
+                out_copy.viscosities = out.viscosities;
+
+                const MaterialAveraging::AveragingOperation averaging_operation_for_viscosity =
+                  get_averaging_operation_for_viscosity(this->get_parameters().material_averaging);
+                MaterialAveraging::average(averaging_operation_for_viscosity,
+                                           in.current_cell,
+                                           this->introspection().quadratures.compositional_fields,
+                                           this->get_mapping(),
+                                           in.requested_properties,
+                                           out_copy);
+
+                effective_creep_viscosities = out_copy.viscosities;
+              }
+            else
+              effective_creep_viscosities = out.viscosities;
+
+            for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+              {
+                // Get old stresses from compositional fields
+                const SymmetricTensor<2,dim> stress_old(Utilities::Tensors::to_symmetric_tensor<dim>(&in.composition[i][0],
+                                                        &in.composition[i][0]+SymmetricTensor<2,dim>::n_independent_components));
+
+                // Calculate the rotated stresses
+                // Rotation (vorticity) tensor (equation 25 in Moresi et al., 2003, J. Comp. Phys.)
+                const Tensor<2,dim> rotation = 0.5 * (evaluator->get_gradient(i) - transpose(evaluator->get_gradient(i)));
+
+                // Calculate the current (new) stored elastic stress, which is a function of the material
+                // properties (viscoelastic viscosity, shear modulus), elastic time step size, strain rate,
+                // vorticity, prior (inherited) viscoelastic stresses and viscosity of the elastic damper.
+                // In the absence of the elastic damper, the expression for "stress_new" is identical
+                // to the one found in Moresi et al. (2003, J. Comp. Phys., equation 29).
+                const double damped_elastic_viscosity = calculate_elastic_viscosity(average_elastic_shear_moduli[i]);
+
+                // stress_0 is the combination of the elastic stress tensor stored at the end of the last time step and the change in that stress generated by local rotation
+                const SymmetricTensor<2,dim> stress_0 = (stress_old + dte * ( symmetrize(rotation * Tensor<2,dim>(stress_old) ) - symmetrize(Tensor<2,dim>(stress_old) * rotation) ) );
+
+                // stress_creep is the stress experienced by the viscous and elastic components.
+                Assert(std::isfinite(in.strain_rate[i].norm()),
+                       ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                                  "not filled by the caller."));
+                const SymmetricTensor<2,dim> stress_creep = 2. * effective_creep_viscosities[i] * ( deviator(in.strain_rate[i]) + stress_0 / (2. * damped_elastic_viscosity ) );
+
+                // stress_new is the (new) stored elastic stress
+                SymmetricTensor<2,dim> stress_new = stress_creep * (1. - (elastic_damper_viscosity / damped_elastic_viscosity)) + elastic_damper_viscosity * stress_0 / damped_elastic_viscosity;
+
+                // Stress averaging scheme to account for difference between the elastic time step
+                // and the numerical time step (see equation 32 in Moresi et al., 2003, J. Comp. Phys.)
+                // Note that if there is no difference between the elastic timestep and the numerical
+                // timestep, then no averaging occurs as dt/dte = 1.
+                stress_new = ( ( 1. - ( dt / dte ) ) * stress_old ) + ( ( dt / dte ) * stress_new ) ;
+
+                const SymmetricTensor<2,dim> stress_update = stress_new - stress_old;
+
+                // Fill reaction terms
+                Utilities::Tensors::unroll_symmetric_tensor_into_array(stress_update,
+                                                                       &out.reaction_terms[i][0],
+                                                                       &out.reaction_terms[i][0]+SymmetricTensor<2,dim>::n_independent_components);
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      double
+      Elasticity<dim>::elastic_timestep () const
+      {
+        // The elastic time step (dte) is equal to the numerical time step if the time step number
+        // is greater than 0 and the parameter 'use_fixed_elastic_time_step' is set to false.
+        // On the first (0) time step the elastic time step is always equal to the value
+        // specified in 'fixed_elastic_time_step', which is also used in all subsequent time
+        // steps if 'use_fixed_elastic_time_step' is set to true.
+        //
+        // We also use this parameter when we are still *before* the first time step,
+        // i.e., if the time step number is numbers::invalid_unsigned_int.
+        const double dte = ( ( this->get_timestep_number() > 0 &&
+                               this->simulator_is_past_initialization() &&
+                               use_fixed_elastic_time_step == false )
+                             ?
+                             this->get_timestep() * stabilization_time_scale_factor
+                             :
+                             fixed_elastic_time_step);
+        return dte;
+      }
+
+
+
+      template <int dim>
+      const std::vector<double> &
+      Elasticity<dim>::get_elastic_shear_moduli () const
+      {
+        return elastic_shear_moduli;
+      }
+
+
+
+      template <int dim>
+      double
+      Elasticity<dim>::
+      calculate_elastic_viscosity (const double shear_modulus) const
+      {
+        return shear_modulus*elastic_timestep() + elastic_damper_viscosity;
+      }
+
+
+
+      template <int dim>
+      double
+      Elasticity<dim>::
+      calculate_viscoelastic_viscosity (const double viscosity,
+                                        const double shear_modulus) const
+      {
+        const double elastic_viscosity = calculate_elastic_viscosity(shear_modulus);
+        return 1. / (1./elastic_viscosity + 1./viscosity);
+      }
+
+
+
+      template <int dim>
+      SymmetricTensor<2,dim>
+      Elasticity<dim>::
+      calculate_viscoelastic_strain_rate(const SymmetricTensor<2,dim> &strain_rate,
+                                         const SymmetricTensor<2,dim> &stored_stress,
+                                         const double shear_modulus) const
+      {
+        // The first term in the following expression is the deviator of the true strain rate
+        // of one or more isostress rheological elements (in series).
+        // One of these elements must be an elastic component (potentially damped).
+        // The second term corresponds to a fictional strain rate arising from
+        // elastic stresses stored from the last time step.
+        // Note the parallels with the viscous part of the strain rate deviator,
+        // which is equal to 0.5 * stress / viscosity.
+        return deviator(strain_rate) + 0.5 * deviator(stored_stress) /
+               calculate_elastic_viscosity(shear_modulus);
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  template class ElasticAdditionalOutputs<dim>; \
+  \
+  namespace Rheology \
+  { \
+    template class Elasticity<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/frank_kamenetskii.cc.bak b/source/material_model/rheology/frank_kamenetskii.cc.bak
new file mode 100644
index 00000000000..fc61a80485e
--- /dev/null
+++ b/source/material_model/rheology/frank_kamenetskii.cc.bak
@@ -0,0 +1,156 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/frank_kamenetskii.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      template <int dim>
+      FrankKamenetskii<dim>::FrankKamenetskii ()
+        = default;
+
+
+
+      template <int dim>
+      double
+      FrankKamenetskii<dim>::compute_viscosity (const double temperature,
+                                                const unsigned int composition,
+                                                const double pressure,
+                                                const double density,
+                                                const double gravity) const
+      {
+        const double reference_temperature = this->get_adiabatic_surface_temperature();
+        const double reference_pressure = this->get_surface_pressure();
+        const double max_depth = this->get_geometry_model().maximal_depth();
+
+        //Frank-Kamenetskii equation with added pressure dependence terms
+        const double viscosity_frank_kamenetskii = prefactors_frank_kamenetskii[composition] * std::exp(viscosity_ratios_frank_kamenetskii[composition] * 0.5 * (1.0-temperature/reference_temperature)
+                                                   + pressure_prefactors_frank_kamenetskii[composition] * (pressure-reference_pressure)/(density*gravity*max_depth));
+
+
+        return viscosity_frank_kamenetskii;
+      }
+
+
+
+
+
+      template <int dim>
+      void
+      FrankKamenetskii<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Viscosity ratios for Frank Kamenetskii", "15.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "An adjusted viscosity ratio, $E$, for the viscosity approximation, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: None");
+        prm.declare_entry ("Prefactors for Frank Kamenetskii", "1.e21",
+                           Patterns::List(Patterns::Double (0.)),
+                           "A viscosity prefactor for the viscosity approximation, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None");
+
+        prm.declare_entry ("Pressure prefactors for Frank Kamenetskii", "0.0",
+                           Patterns::List(Patterns::Double (0.)),
+                           "A prefactor for the pressure term in the viscosity approximation, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: None");
+      }
+
+
+
+      template <int dim>
+      void
+      FrankKamenetskii<dim>::parse_parameters (ParameterHandler &prm)
+      {
+
+        AssertThrow (this->include_adiabatic_heating() == false,
+                     ExcMessage("The Frank-Kamenetskii rheology is currently only implemented for "
+                                "models without adiabatic heating. Please implement the necessary "
+                                "temperature adjustment if you need this feature."));
+
+        AssertThrow (this->get_adiabatic_surface_temperature() > 0.0,
+                     ExcMessage("The Frank-Kamenetskii rheology can only be used when the adiabatic "
+                                "surface temperature (reference_temperature in equation for viscosity) "
+                                "is non-zero."));
+
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+        // Make options file for parsing maps to double arrays
+        Utilities::MapParsing::Options options(chemical_field_names, "Viscosity ratios for Frank Kamenetskii");
+        options.list_of_allowed_keys = compositional_field_names;
+
+        viscosity_ratios_frank_kamenetskii = Utilities::MapParsing::parse_map_to_double_array (prm.get("Viscosity ratios for Frank Kamenetskii"),
+                                             options);
+
+        options.property_name = "Prefactors for Frank Kamenetskii";
+        prefactors_frank_kamenetskii = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactors for Frank Kamenetskii"),
+                                                                                        options);
+
+        options.property_name = "Pressure prefactors for Frank Kamenetskii";
+        pressure_prefactors_frank_kamenetskii = Utilities::MapParsing::parse_map_to_double_array(prm.get("Pressure prefactors for Frank Kamenetskii"),
+                                                options);
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class FrankKamenetskii<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/friction_models.cc.bak b/source/material_model/rheology/friction_models.cc.bak
new file mode 100644
index 00000000000..bb2d49361bb
--- /dev/null
+++ b/source/material_model/rheology/friction_models.cc.bak
@@ -0,0 +1,312 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/rheology/friction_models.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/quadrature_lib.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      template <int dim>
+      double
+      FrictionModels<dim>::
+      compute_friction_angle(const double current_edot_ii,
+                             const unsigned int volume_fraction_index,
+                             const double static_friction_angle,
+                             const Point<dim> &position) const
+      {
+
+        switch (friction_mechanism)
+          {
+            case static_friction:
+            {
+              return static_friction_angle;
+            }
+            case dynamic_friction:
+            {
+              // Calculate effective steady-state friction coefficient.
+              // This is based on the former material model dynamic friction.
+              // The formula below is equivalent to the equation 13 in \cite{van_dinther_seismic_2013}.
+              // Although here the dynamic friction coefficient is directly specified. In addition,
+              // we also use a reference strain rate in place of a characteristic
+              // velocity divided by local element size. This reference strain rate is called
+              // the dynamic characteristic strain rate and is used to compute what value between
+              // dynamic and static angle of internal friction should be used.
+              // Furthermore a smoothness exponent X is added, which determines whether the
+              // friction vs strain rate curve is rather step-like or more gradual.
+              // mu  = mu_d + (mu_s - mu_d) / ( (1 + strain_rate_dev_inv2/dynamic_characteristic_strain_rate)^X );
+              // Angles of friction are used in radians within ASPECT. The coefficient
+              // of friction (mu) is the tangent of the internal angle of friction, hence convergence is needed.
+              // The incoming variable static_friction_angle holds the static friction angle. It's value is
+              // then updated with the strain rate dependent friction angle which is returned by the function.
+              const double mu = (std::tan(dynamic_angles_of_internal_friction[volume_fraction_index])
+                                 + (std::tan(static_friction_angle) - std::tan(dynamic_angles_of_internal_friction[volume_fraction_index]))
+                                 / (1. + std::pow((current_edot_ii / dynamic_characteristic_strain_rate),
+                                                  dynamic_friction_smoothness_exponent)));
+              const double dynamic_friction_angle = std::atan (mu);
+              Assert((mu < 1) && (0 < dynamic_friction_angle) && (dynamic_friction_angle <= 1.6), ExcMessage(
+                       "The friction coefficient should be larger than zero and smaller than 1. "
+                       "The friction angle should be smaller than 1.6 rad."));
+              return dynamic_friction_angle;
+            }
+            case function:
+            {
+              // Use a given function input per composition to get the friction angle
+              Utilities::NaturalCoordinate<dim> point =
+                this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system_friction_function);
+
+              // we get time passed as seconds (always) but may want
+              // to reinterpret it in years
+              if (this->convert_output_to_years())
+                friction_function->set_time (this->get_time() / year_in_seconds);
+              else
+                friction_function->set_time (this->get_time());
+
+              // determine the friction angle based on position and composition
+              // The volume_fraction_index is based on the number of chemical compositional fields.
+              // However, this plugin reads a function for every compositional field, regardless of
+              // its type. Therefore we have to get the correct index.
+              // If no fields or no chemical fields are present, but only background material, the index is zero.
+              // If chemical fields are present, volume_fractions will be of size 1+n_chemical_composition_fields.
+              // The size of chemical_composition_field_indices will be one less.
+              unsigned int index = 0;
+              if (this->introspection().composition_type_exists(CompositionalFieldDescription::chemical_composition))
+                index = this->introspection().chemical_composition_field_indices()[volume_fraction_index-1];
+              double friction_from_function =
+                friction_function->value(Utilities::convert_array_to_point<dim>(point.get_coordinates()),index);
+
+              // Convert angles from degrees to radians
+              friction_from_function *= constants::degree_to_radians;
+
+              return friction_from_function;
+            }
+          }
+        // we should never get here, return something anyway, so the compiler does not complain...
+        AssertThrow (false, ExcMessage("Unknown friction model."));
+        return static_friction_angle;
+      }
+
+
+
+      template <int dim>
+      FrictionMechanism
+      FrictionModels<dim>::
+      get_friction_mechanism() const
+      {
+        return friction_mechanism;
+      }
+
+
+
+      template <int dim>
+      void
+      FrictionModels<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Friction mechanism", "none",
+                           Patterns::Selection("none|dynamic friction|function"),
+                           "Whether to make the friction angle dependent on strain rate or not. This rheology "
+                           "is intended to be used together with the visco-plastic rheology model."
+                           "\n\n"
+                           "\\item ``none'': No dependence of the friction angle is applied. "
+                           "\n\n"
+                           "\\item ``dynamic friction'': The friction angle is rate dependent."
+                           "When 'dynamic angles of internal friction' are specified, "
+                           "the friction angle will be weakened for high strain rates with: "
+                           "$\\mu = \\mu_d + \\frac{\\mu_s-\\mu_d}{1+\\frac{\\dot{\\epsilon}_{ii}}{\\dot{\\epsilon}_C}}^x$  "
+                           "where $\\mu_s$ and $\\mu_d$ are the friction angles at low and high strain rates, "
+                           "respectively. $\\dot{\\epsilon}_{ii}$ is the second invariant of the strain rate and "
+                           "$\\dot{\\epsilon}_C$ is the 'dynamic characteristic strain rate' where $\\mu = (\\mu_s+\\mu_d)/2$. "
+                           "The 'dynamic friction smoothness exponent' x controls how "
+                           "smooth or step-like the change from $\\mu_s$ to $\\mu_d$ is. "
+                           "The equation is modified after Equation (13) in \\cite{van_dinther_seismic_2013}. "
+                           "$\\mu_s$ and $\\mu_d$ can be specified by setting 'Angles of internal friction' and "
+                           "'Dynamic angles of internal friction', respectively. "
+                           "This relationship is similar to rate-and-state friction constitutive relationships, which "
+                           "are applicable to the strength of rocks during earthquakes."
+                           "\n\n"
+                           "\\item ``function'': Specify the friction angle as a function of space and time "
+                           "for each compositional field.");
+
+        // Dynamic friction parameters
+        prm.declare_entry ("Dynamic characteristic strain rate", "1e-12",
+                           Patterns::Double (0),
+                           "The characteristic strain rate value at which the angle of friction is "
+                           "equal to $\\mu = (\\mu_s+\\mu_d)/2$. When the effective strain rate "
+                           "is very high, the dynamic angle of friction is taken, when it is very low, "
+                           "the static angle of internal friction is used. Around the dynamic characteristic "
+                           "strain rate, there is a smooth gradient from the static to the dynamic angle "
+                           "of internal friction. "
+                           "Units: \\si{\\per\\second}.");
+
+        prm.declare_entry ("Dynamic angles of internal friction", "2",
+                           Patterns::List(Patterns::Double(0)),
+                           "List of dynamic angles of internal friction, $\\phi$, for background material and compositional "
+                           "fields, for a total of N$+$1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "Dynamic angles of friction are used as the current friction angle when the effective "
+                           "strain rate is well above the 'dynamic characteristic strain rate'. "
+                           "Units: \\si{\\degree}.");
+
+        prm.declare_entry ("Dynamic friction smoothness exponent", "1",
+                           Patterns::Double (0),
+                           "An exponential factor in the equation for the calculation of the friction angle when a "
+                           "static and a dynamic angle of internal friction are specified. A factor of 1 returns the equation "
+                           "to Equation (13) in \\cite{van_dinther_seismic_2013}. A factor between 0 and 1 makes the "
+                           "curve of the friction angle vs. the strain rate smoother, while a factor $>$ 1 makes "
+                           "the change between static and dynamic friction angle more steplike. "
+                           "Units: none.");
+
+        /**
+         * If friction is specified as a function input.
+         */
+        prm.enter_subsection("Friction function");
+        {
+          /**
+           * The function to specify the friction angle per composition can be declared in dependence
+           * of depth, cartesian coordinates or spherical coordinates. Note that the order
+           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
+           * this allows for dimension independent expressions.
+           */
+          prm.declare_entry ("Coordinate system", "cartesian",
+                             Patterns::Selection ("cartesian|spherical|depth"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle. `depth' "
+                             "will create a function, in which only the first "
+                             "parameter is non-zero, which is interpreted to "
+                             "be the depth of the point.");
+
+          Functions::ParsedFunction<dim>::declare_parameters(prm,1);
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      FrictionModels<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        // Friction dependence parameters
+        if (prm.get ("Friction mechanism") == "none")
+          friction_mechanism = static_friction;
+        else if (prm.get ("Friction mechanism") == "dynamic friction")
+          friction_mechanism = dynamic_friction;
+        else if (prm.get ("Friction mechanism") == "function")
+          friction_mechanism = function;
+        else
+          AssertThrow(false, ExcMessage("Not a valid friction mechanism option!"));
+
+        // Dynamic friction parameters
+        dynamic_characteristic_strain_rate = prm.get_double("Dynamic characteristic strain rate");
+
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(), "background");
+
+        Utilities::MapParsing::Options options(chemical_field_names, "Dynamic angles of internal friction");
+        options.list_of_allowed_keys = compositional_field_names;
+
+        dynamic_angles_of_internal_friction = Utilities::MapParsing::parse_map_to_double_array (prm.get("Dynamic angles of internal friction"),
+                                              options);
+
+        // Convert angles from degrees to radians
+        for (double &angle : dynamic_angles_of_internal_friction)
+          {
+            AssertThrow(angle <= 90,
+                        ExcMessage("Dynamic angles of friction must be <= 90 degrees"));
+            angle *= constants::degree_to_radians;
+          }
+
+        dynamic_friction_smoothness_exponent = prm.get_double("Dynamic friction smoothness exponent");
+
+
+        // Get the number of fields for composition-dependent material properties
+        // including the background field.
+        // TODO Make sure functions only have to be specified per chemical composition,
+        // but can still be specified for all fields for backwards compatibility.
+        const unsigned int n_fields = this->n_compositional_fields() + 1;
+
+        // if friction is specified as a function
+        if (friction_mechanism == function)
+          {
+            prm.enter_subsection("Friction function");
+            {
+              coordinate_system_friction_function = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
+              try
+                {
+                  friction_function
+                    = std::make_unique<Functions::ParsedFunction<dim>>(n_fields);
+                  friction_function->parse_parameters (prm);
+                }
+              catch (...)
+                {
+                  std::cerr << "FunctionParser failed to parse\n"
+                            << "\t friction function\n"
+                            << "with expression \n"
+                            << "\t' " << prm.get("Function expression") << "'";
+                  throw;
+                }
+            }
+            prm.leave_subsection();
+          }
+
+      }
+    }
+  }
+}
+
+
+
+// Explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class FrictionModels<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/peierls_creep.cc.bak b/source/material_model/rheology/peierls_creep.cc.bak
new file mode 100644
index 00000000000..8b46fd86b72
--- /dev/null
+++ b/source/material_model/rheology/peierls_creep.cc.bak
@@ -0,0 +1,679 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/peierls_creep.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      PeierlsCreepParameters::PeierlsCreepParameters()
+        : prefactor (numbers::signaling_nan<double>()),
+          stress_exponent (numbers::signaling_nan<double>()),
+          activation_energy (numbers::signaling_nan<double>()),
+          activation_volume (numbers::signaling_nan<double>()),
+          peierls_stress (numbers::signaling_nan<double>()),
+          glide_parameter_p (numbers::signaling_nan<double>()),
+          glide_parameter_q (numbers::signaling_nan<double>()),
+          fitting_parameter (numbers::signaling_nan<double>()),
+          stress_cutoff (numbers::signaling_nan<double>())
+      {}
+
+
+
+      template <int dim>
+      PeierlsCreep<dim>::PeierlsCreep ()
+        = default;
+
+
+
+      /**
+       * Compute the creep parameters for the Peierls creep law.
+       */
+      template <int dim>
+      const PeierlsCreepParameters
+      PeierlsCreep<dim>::compute_creep_parameters (const unsigned int composition,
+                                                   const std::vector<double> &phase_function_values,
+                                                   const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        PeierlsCreepParameters creep_parameters;
+        if (phase_function_values == std::vector<double>())
+          {
+            // no phases
+            creep_parameters.prefactor = prefactors[composition];
+            creep_parameters.stress_exponent = stress_exponents[composition];
+            creep_parameters.activation_energy = activation_energies[composition];
+            creep_parameters.activation_volume = activation_volumes[composition];
+            creep_parameters.peierls_stress = peierls_stresses[composition];
+            creep_parameters.glide_parameter_p = glide_parameters_p[composition];
+            creep_parameters.glide_parameter_q = glide_parameters_q[composition];
+            creep_parameters.fitting_parameter = fitting_parameters[composition];
+            creep_parameters.stress_cutoff = stress_cutoffs[composition];
+          }
+        else
+          {
+            // Average among phases. This averaging is not strictly correct, but
+            // it will not matter much if the parameters are similar across transitions.
+            creep_parameters.prefactor = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                         prefactors, composition,  MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic);
+            creep_parameters.stress_exponent = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                               stress_exponents, composition);
+            creep_parameters.activation_energy = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 activation_energies, composition);
+            creep_parameters.activation_volume = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 activation_volumes, composition);
+            creep_parameters.peierls_stress = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                              peierls_stresses, composition);
+            creep_parameters.glide_parameter_p = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 glide_parameters_p, composition);
+            creep_parameters.glide_parameter_q = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 glide_parameters_q, composition);
+            creep_parameters.fitting_parameter = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                                 fitting_parameters, composition);
+            creep_parameters.stress_cutoff = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
+                                             stress_cutoffs, composition);
+          }
+        return creep_parameters;
+      }
+
+
+
+      template <int dim>
+      double
+      PeierlsCreep<dim>::compute_approximate_viscosity (const double strain_rate,
+                                                        const double pressure,
+                                                        const double temperature,
+                                                        const unsigned int composition,
+                                                        const std::vector<double> &phase_function_values,
+                                                        const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        /**
+         * An approximation of the Peierls creep formulation, where stress is replaced with strain rate
+         * (second invariant) when calculating viscosity. This substitution requires a fitting parameter (gamma),
+         * which describes the relationship between stress and the Peierls stress (gamma = stress/stress_peierls).
+         * Details of this derivation can be found in the following document:
+         * https://ucdavis.app.box.com/s/cl5mwhkjeabol4otrdukfcdwfvg9me4w/file/705438695737
+         * The formulation for the viscosity is:
+         *   stress_term * arrhenius_term * strain_rate_term, where
+         * stress_term      = (0.5 * gamma * sigma_p) / (A * ((gamma * sigma_p)^n)^(1/(s+n)))
+         * arrhenius_term   = exp(( (E + P * V) / (R * T)) * (1 - gamma^p)^q / (s + n) )
+         * strain_rate_term = edot_ii^(1 / (s + n) - 1)
+         * Above,
+         * s = ((E + P * V) / (R * T)) * p * q * (1 - gamma^p)^(q-1) * (gamma^p)
+         * sigma_p is the Peierls stress
+         * gamma is the Peierls creep fitting parameter
+         * p is the first Peierls glide parameter
+         * q is the second Peierls creep glide parameter
+         * A is the Peierls prefactor term (1/s 1/Pa^2)
+         * n is the Peierls stress exponent
+         * E is the Peierls activation energy (J/mol)
+         * V is the Peierls activation volume (m^3/mol). However, to date V has always been set to 0.
+         * edot_ii is the second invariant of the deviatoric strain rate (1/s)
+         * T is temperature (K)
+         * R is the gas constant
+         */
+
+        const PeierlsCreepParameters p = compute_creep_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
+
+        const double s = ( (p.activation_energy + pressure * p.activation_volume) / (constants::gas_constant * temperature)) *
+                         p.glide_parameter_p * p.glide_parameter_q *
+                         std::pow((1. - std::pow(p.fitting_parameter, p.glide_parameter_p)),(p.glide_parameter_q - 1.)) *
+                         std::pow(p.fitting_parameter, p.glide_parameter_p);
+
+        const double stress_term = 0.5 * (p.fitting_parameter * p.peierls_stress) /
+                                   std::pow((p.prefactor * std::pow(p.fitting_parameter * p.peierls_stress,p.stress_exponent)),( 1. / (s + p.stress_exponent)));
+
+        const double arrhenius_term = std::exp( ((p.activation_energy + pressure * p.activation_volume) / (constants::gas_constant * temperature)) *
+                                                (std::pow((1. - std::pow(p.fitting_parameter,p.glide_parameter_p)),p.glide_parameter_q)) /
+                                                (s + p.stress_exponent) );
+
+        const double strain_rate_term = std::pow(strain_rate, (1. / (s + p.stress_exponent)) - 1.);
+
+        double viscosity_peierls = stress_term * arrhenius_term * strain_rate_term;
+
+        Assert (viscosity_peierls > 0.0,
+                ExcMessage ("Negative peierls viscosity detected. This is unphysical and should not happen. "
+                            "Check for negative parameters."));
+
+        // Creep viscosities become extremely large at low
+        // temperatures and can therefore provoke floating-point overflow errors. In
+        // real rocks, other deformation mechanisms become dominant at low temperatures,
+        // so these high viscosities are never achieved. It is therefore both reasonable
+        // and desirable to require the single-mechanism viscosity to be smaller than
+        // std::sqrt(max_double).
+        viscosity_peierls = std::min(viscosity_peierls, std::sqrt(std::numeric_limits<double>::max()));
+
+        return viscosity_peierls;
+      }
+
+
+
+      template <int dim>
+      double
+      PeierlsCreep<dim>::compute_exact_viscosity (const double strain_rate,
+                                                  const double pressure,
+                                                  const double temperature,
+                                                  const unsigned int composition,
+                                                  const std::vector<double> &phase_function_values,
+                                                  const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        /**
+         * A generalized Peierls creep formulation. The Peierls creep expression
+         * for the strain rate has multiple stress-dependent terms, and cannot be
+         * directly inverted to find an expression for viscosity in terms of
+         * strain rate. For this reason, a Newton-Raphson iteration is required,
+         * which can be quite expensive.
+         * The equation for the strain rate is given in
+         * compute_exact_strain_rate_and_derivative.
+         */
+        const PeierlsCreepParameters p = compute_creep_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
+
+        // The generalized Peierls creep flow law cannot be expressed as viscosity in
+        // terms of strain rate, because there are two stress-dependent terms
+        // in the strain rate expression.
+        // We use Newton's method to find the second invariant of the stress tensor.
+
+        // Apply a strict cutoff if this option is chosen by user. A strain rate cutoff
+        // will be first computed and then compared to the input strain rate. A cutoff
+        // on stress will be triggered if the input strain rate is smaller.
+        const double log_strain_rate = std::log(strain_rate);
+
+        if (apply_strict_cutoff)
+          {
+            const std::pair<double, double> log_edot_and_deriv = compute_exact_log_strain_rate_and_derivative(std::log(p.stress_cutoff), pressure, temperature, p);
+            if (log_strain_rate < log_edot_and_deriv.first)
+              {
+                double viscosity = 0.5 * p.stress_cutoff / strain_rate;
+                return viscosity;
+              }
+          }
+
+        // Create a starting guess for the stress using
+        // the approximate form of the viscosity expression
+        double viscosity = compute_approximate_viscosity(strain_rate, pressure, temperature, composition);
+        double log_stress_ii = std::log(2.*viscosity*strain_rate);
+
+        // Before the first iteration, compute the residual
+        // of the initial guess and the derivative
+        unsigned int stress_iteration = 0;
+        const std::pair<double, double> log_edot_and_deriv = compute_exact_log_strain_rate_and_derivative(log_stress_ii, pressure, temperature, p);
+        double strain_rate_residual = log_edot_and_deriv.first - log_strain_rate;
+        double log_strain_rate_deriv = log_edot_and_deriv.second;
+
+        while (std::abs(strain_rate_residual) > strain_rate_residual_threshold
+               && stress_iteration < stress_max_iteration_number)
+          {
+            // If the strain rate derivative is zero, we catch it below.
+            if (log_strain_rate_deriv>std::numeric_limits<double>::min())
+              log_stress_ii -= strain_rate_residual/log_strain_rate_deriv;
+
+            const std::pair<double, double> log_edot_and_deriv = compute_exact_log_strain_rate_and_derivative(log_stress_ii, pressure, temperature, p);
+
+            strain_rate_residual = log_edot_and_deriv.first - log_strain_rate;
+            log_strain_rate_deriv = log_edot_and_deriv.second;
+
+            stress_iteration += 1;
+
+            // If anything that would be used in the next iteration is not finite, the
+            // Newton iteration would trigger an exception and we want to abort the
+            // iteration instead.
+            // Currently, we still throw an exception, but if this exception is thrown,
+            // another more robust iterative scheme should be implemented
+            // (similar to that seen in the diffusion-dislocation material model).
+            const bool abort_newton_iteration = !numbers::is_finite(log_stress_ii)
+                                                || !numbers::is_finite(strain_rate_residual)
+                                                || !numbers::is_finite(log_strain_rate_deriv)
+                                                || log_strain_rate_deriv < std::numeric_limits<double>::min()
+                                                || stress_iteration == stress_max_iteration_number;
+            AssertThrow(!abort_newton_iteration,
+                        ExcMessage("No convergence has been reached in the loop that determines "
+                                   "the Peierls creep viscosity. Aborting! "
+                                   "Residual is " + Utilities::to_string(strain_rate_residual) +
+                                   " after " + Utilities::to_string(stress_iteration) + " iterations. "
+                                   "You can increase the number of iterations by adapting the "
+                                   "parameter 'Maximum Peierls strain rate iterations'."));
+          }
+
+        viscosity = 0.5*std::exp(log_stress_ii)/strain_rate;
+
+        return viscosity;
+      }
+
+
+
+      template <int dim>
+      double
+      PeierlsCreep<dim>::compute_viscosity (const double strain_rate,
+                                            const double pressure,
+                                            const double temperature,
+                                            const unsigned int composition,
+                                            const std::vector<double> &phase_function_values,
+                                            const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        double viscosity = 0.0;
+
+        switch (peierls_creep_flow_law)
+          {
+            case viscosity_approximation:
+            {
+              viscosity = compute_approximate_viscosity(strain_rate, pressure, temperature, composition, phase_function_values, n_phase_transitions_per_composition);
+              break;
+            }
+            case exact:
+            {
+              viscosity = compute_exact_viscosity(strain_rate, pressure, temperature, composition, phase_function_values, n_phase_transitions_per_composition);
+              break;
+            }
+            default:
+            {
+              AssertThrow(false, ExcNotImplemented());
+              break;
+            }
+          }
+
+        return viscosity;
+      }
+
+
+
+      template <int dim>
+      std::pair<double, double>
+      PeierlsCreep<dim>::compute_approximate_strain_rate_and_derivative (const double stress,
+                                                                         const double pressure,
+                                                                         const double temperature,
+                                                                         const PeierlsCreepParameters creep_parameters) const
+      {
+        /**
+        * b = (E+P*V)/(R*T)
+        * c = std::pow(gamma, p)
+        * d = std::pow(1. - c, q)
+        * s = b*p*q*c*d/(1. - c)
+        * arrhenius = std::exp(-b*d)
+        *
+        * edot_ii = A * std::pow(stress, s + n) * std::pow(gamma*peierls_stress, -s) * arrhenius
+        * deriv = edot_ii / stress * (s + n)
+        */
+        const PeierlsCreepParameters p = creep_parameters;
+
+        const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
+        const double c = std::pow(p.fitting_parameter, p.glide_parameter_p);
+        const double d = std::pow(1. - c, p.glide_parameter_q);
+        const double s = b*p.glide_parameter_p*p.glide_parameter_q*c*d/(1. - c);
+        const double arrhenius = std::exp(-b*d);
+
+        const double edot_ii = p.prefactor * std::pow(stress, s + p.stress_exponent) * std::pow(p.fitting_parameter*p.peierls_stress, -s) * arrhenius;
+        const double deriv = edot_ii / stress * (s + p.stress_exponent);
+
+        return std::make_pair(edot_ii, deriv);
+      }
+
+
+
+      template <int dim>
+      std::pair<double, double>
+      PeierlsCreep<dim>::compute_exact_strain_rate_and_derivative (const double stress,
+                                                                   const double pressure,
+                                                                   const double temperature,
+                                                                   const PeierlsCreepParameters creep_parameters) const
+      {
+        /**
+        * b = (E+P*V)/(R*T)
+        * c = std::pow(stress/peierls_stress, p)
+        * d = std::pow(1 - c, q)
+        * s = b*p*q*c*d/(1 - c)
+        * arrhenius = std::exp(-b*d)
+        *
+        * edot_ii = A * std::pow(stress, n) * arrhenius
+        * deriv = edot_ii / stress * (s + n)
+        */
+        const PeierlsCreepParameters p = creep_parameters;
+        if (stress < p.stress_cutoff)
+          {
+
+            /**
+            * For Peierls creep flow laws that have a stress exponent equal to zero the strain rate does not approach zero as
+            * stress approaches zero. To ensure convergence in the solver, the strain rate is modelled as a quadratic function
+            * of stress;
+            * edot_ii = quadratic_term*stress^2 + linear_term*stress
+            * Where the quadratic and linear terms are defined at a constant cutoff temperature and pressure.
+            * T_cutoff = (E/R), P_cutoff = 0
+            * s_cutoff = p*q*c_cutoff*d_cutoff / (1 - c_cutoff)
+            * arrhenius_cutoff = std::exp(-d_cutoff)
+            */
+            const double c_cutoff = std::pow(p.stress_cutoff/p.peierls_stress, p.glide_parameter_p);
+            const double d_cutoff = std::pow(1. - c_cutoff, p.glide_parameter_q);
+            const double s_cutoff = p.glide_parameter_p*p.glide_parameter_q*c_cutoff*d_cutoff/(1. - c_cutoff);
+            const double arrhenius_cutoff = std::exp(-d_cutoff);
+            const double edot_ii_cutoff = p.prefactor * std::pow(p.stress_cutoff, p.stress_exponent) * arrhenius_cutoff;
+            const double deriv_cutoff = edot_ii_cutoff / p.stress_cutoff * (s_cutoff + p.stress_exponent);
+            const double quadratic_term = (deriv_cutoff - edot_ii_cutoff / p.stress_cutoff) / p.stress_cutoff / arrhenius_cutoff;
+            const double linear_term = (2*(edot_ii_cutoff / p.stress_cutoff) - deriv_cutoff) / arrhenius_cutoff;
+
+            const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
+            const double arrhenius = std::exp(-b*d_cutoff);
+            const double edot_ii = (quadratic_term*std::pow(stress, 2.) + linear_term*stress) * arrhenius;
+            const double deriv = (2*quadratic_term*stress + linear_term) * arrhenius;
+
+            return std::make_pair(edot_ii, deriv);
+          }
+
+        else
+          {
+            const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
+            const double c = std::pow(stress/p.peierls_stress, p.glide_parameter_p);
+            const double d = std::pow(1. - c, p.glide_parameter_q);
+            const double s = b*p.glide_parameter_p*p.glide_parameter_q*c*d/(1. - c);
+            const double arrhenius = std::exp(-b*d);
+
+            const double edot_ii = p.prefactor * std::pow(stress, p.stress_exponent) * arrhenius;
+            const double deriv = edot_ii / stress * (s + p.stress_exponent);
+
+            return std::make_pair(edot_ii, deriv);
+          }
+      }
+
+
+
+      template <int dim>
+      std::pair<double, double>
+      PeierlsCreep<dim>::compute_exact_log_strain_rate_and_derivative (const double log_stress,
+                                                                       const double pressure,
+                                                                       const double temperature,
+                                                                       const PeierlsCreepParameters creep_parameters) const
+      {
+        /**
+        * b = (E+P*V)/(R*T)
+        * c = std::pow(stress/peierls_stress, p)
+        * d = std::pow(1 - c, q)
+        *
+        * log_edot_ii = std::log(A) + n * std::log(stress) - b*d
+        * deriv_log = n + p * q * b * std::(1-c, p.q - 1)
+        * The deriv_log is the derivative of log(edot_ii) to log(stress).
+        */
+        const PeierlsCreepParameters p = creep_parameters;
+        const double stress = std::exp(log_stress);
+        if (stress < p.stress_cutoff)
+          {
+
+            /**
+            * For Peierls creep flow laws that have a stress exponent equal to zero the strain rate does not approach zero as
+            * stress approaches zero. To ensure convergence in the solver, the strain rate is modelled as a quadratic function
+            * of stress;
+            * edot_ii = quadratic_term*stress^2 + linear_term*stress
+            * Where the quadratic and linear terms are defined at a constant cutoff temperature and pressure.
+            * T_cutoff = (E/R), P_cutoff = 0
+            * s_cutoff = p*q*c_cutoff*d_cutoff / (1 - c_cutoff)
+            * arrhenius_cutoff = std::exp(-d_cutoff)
+            */
+            const double c_cutoff = std::pow(p.stress_cutoff/p.peierls_stress, p.glide_parameter_p);
+            const double d_cutoff = std::pow(1. - c_cutoff, p.glide_parameter_q);
+            const double s_cutoff = p.glide_parameter_p*p.glide_parameter_q*c_cutoff*d_cutoff/(1. - c_cutoff);
+            const double arrhenius_cutoff = std::exp(-d_cutoff);
+            const double edot_ii_cutoff = p.prefactor * std::pow(p.stress_cutoff, p.stress_exponent) * arrhenius_cutoff;
+            const double deriv_cutoff = edot_ii_cutoff / p.stress_cutoff * (s_cutoff + p.stress_exponent);
+            const double quadratic_term = (deriv_cutoff - edot_ii_cutoff / p.stress_cutoff) / p.stress_cutoff / arrhenius_cutoff;
+            const double linear_term = (2*(edot_ii_cutoff / p.stress_cutoff) - deriv_cutoff) / arrhenius_cutoff;
+
+            const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
+            const double arrhenius = std::exp(-b*d_cutoff);
+            const double edot_ii = (quadratic_term*std::pow(stress, 2.) + linear_term*stress) * arrhenius;
+            const double deriv_log = 2 - linear_term / (quadratic_term * stress + linear_term);
+
+            return std::make_pair(std::log(edot_ii), deriv_log);
+          }
+        else
+          {
+            const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
+            const double c = std::pow(stress/p.peierls_stress, p.glide_parameter_p);
+            const double d = std::pow(1. - c, p.glide_parameter_q);
+
+            const double log_edot_ii = std::log(p.prefactor) + p.stress_exponent * log_stress - b*d ;
+            const double deriv_log = p.stress_exponent + p.glide_parameter_p * p.glide_parameter_q * b * c * std::pow(1-c, p.glide_parameter_q - 1);
+
+            return std::make_pair(log_edot_ii, deriv_log);
+          }
+      }
+
+
+
+      template <int dim>
+      std::pair<double, double>
+      PeierlsCreep<dim>::compute_strain_rate_and_derivative (const double stress,
+                                                             const double pressure,
+                                                             const double temperature,
+                                                             const PeierlsCreepParameters creep_parameters) const
+      {
+        std::pair<double, double> strain_rate_and_deriv;
+
+        switch (peierls_creep_flow_law)
+          {
+            case viscosity_approximation:
+            {
+              strain_rate_and_deriv = compute_approximate_strain_rate_and_derivative(stress, pressure, temperature, creep_parameters);
+              break;
+            }
+            case exact:
+            {
+              strain_rate_and_deriv = compute_exact_strain_rate_and_derivative(stress, pressure, temperature, creep_parameters);
+              break;
+            }
+            default:
+            {
+              AssertThrow(false, ExcNotImplemented());
+              break;
+            }
+          }
+        return strain_rate_and_deriv;
+      }
+
+
+
+      template <int dim>
+      void
+      PeierlsCreep<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Peierls creep flow law", "viscosity approximation",
+                           Patterns::Selection("viscosity approximation|exact"),
+                           "Select what type of Peierls creep flow law to use. Currently, the "
+                           "available options are 'exact', which uses a Newton-Raphson iterative method "
+                           "to find the stress and then compute viscosity, and 'viscosity approximation', "
+                           "in which viscosity is an explicit function of the strain rate invariant, "
+                           "rather than stress. ");
+
+        // Viscosity iteration parameters
+        prm.declare_entry ("Peierls strain rate residual tolerance", "1e-10", Patterns::Double(0.),
+                           "Tolerance for the iterative solve to find the correct Peierls creep strain rate. "
+                           "The tolerance is expressed as the difference between the natural logarithm of the "
+                           "input strain rate and the strain rate at the current iteration.");
+        prm.declare_entry ("Maximum Peierls strain rate iterations", "40", Patterns::Integer(0),
+                           "Maximum number of iterations to find the correct "
+                           "Peierls strain rate.");
+
+        // Rheological parameters
+        prm.declare_entry ("Prefactors for Peierls creep", "1.4e-19",
+                           Patterns::Anything(),
+                           "List of viscosity prefactors, $A$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\pascal}$^{-n_{\\text{peierls}}}$ \\si{\\per\\second}");
+        prm.declare_entry ("Stress exponents for Peierls creep", "2.0",
+                           Patterns::Anything(),
+                           "List of stress exponents, $n_{\\text{peierls}}$, for background material and compositional "
+                           "fields, for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+        prm.declare_entry ("Activation energies for Peierls creep", "320e3",
+                           Patterns::Anything(),
+                           "List of activation energies, $E$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. Units: \\si{\\joule\\per\\mole}.");
+        prm.declare_entry ("Activation volumes for Peierls creep", "1.4e-5",
+                           Patterns::Anything(),
+                           "List of activation volumes, $V$, for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
+        prm.declare_entry ("Peierls stresses", "5.e9",
+                           Patterns::Anything(),
+                           "List of stress limits for Peierls creep $\\sigma_{\\text{peierls}}$ for background "
+                           "material and compositional fields, for a total of N+1 values, where N is the number "
+                           "of all compositional fields or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. "
+                           "Units: \\si{\\pascal}");
+        prm.declare_entry ("Peierls fitting parameters", "0.17",
+                           Patterns::Anything(),
+                           "List of fitting parameters $\\gamma$ between stress $\\sigma$ and the Peierls "
+                           "stress $\\sigma_{\\text{peierls}}$ for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. If only one value is given, "
+                           "then all use the same value. Units: none");
+        prm.declare_entry ("Peierls glide parameters p", "0.5",
+                           Patterns::Anything(),
+                           "List of the first Peierls creep glide parameters, $p$, for background and compositional "
+                           "fields for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. Units: none");
+        prm.declare_entry ("Peierls glide parameters q", "1.0",
+                           Patterns::Anything(),
+                           "List of the second Peierls creep glide parameters, $q$, for background and compositional "
+                           "fields for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. Units: none");
+        prm.declare_entry ("Cutoff stresses for Peierls creep", "0.0",
+                           Patterns::Anything(),
+                           "List of the Stress thresholds below which the strain rate is solved for as a quadratic "
+                           "function of stress to aid with convergence when stress exponent n=0. Units: \\si{\\pascal}");
+        prm.declare_entry ("Apply strict stress cutoff for Peierls creep", "false", Patterns::Bool(),
+                           "Whether the cutoff stresses for Peierls creep are used as the minimum "
+                           "stresses in the Peierls rheology");
+
+      }
+
+
+
+      template <int dim>
+      void
+      PeierlsCreep<dim>::parse_parameters (ParameterHandler &prm,
+                                           const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
+      {
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+        if (prm.get ("Peierls creep flow law") == "viscosity approximation")
+          peierls_creep_flow_law = viscosity_approximation;
+        else if (prm.get ("Peierls creep flow law") == "exact")
+          peierls_creep_flow_law = exact;
+        else
+          AssertThrow(false, ExcMessage("Not a valid Peierls creep flow law"));
+
+        // Iteration parameters
+        strain_rate_residual_threshold = prm.get_double ("Peierls strain rate residual tolerance");
+        stress_max_iteration_number = prm.get_integer ("Maximum Peierls strain rate iterations");
+
+        // Rheological parameters
+        // Make options file for parsing maps to double arrays
+        Utilities::MapParsing::Options options(chemical_field_names, "Prefactors for Peierls creep");
+        options.list_of_allowed_keys = compositional_field_names;
+        options.allow_multiple_values_per_key = true;
+        if (expected_n_phases_per_composition)
+          {
+            options.n_values_per_key = *expected_n_phases_per_composition;
+
+            // check_values_per_key is required to be true to duplicate single values
+            // if they are to be used for all phases associated with a given key.
+            options.check_values_per_key = true;
+          }
+
+        prefactors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactors for Peierls creep"),
+                                                                      options);
+
+        options.property_name = "Stress exponents for Peierls creep";
+        stress_exponents = Utilities::MapParsing::parse_map_to_double_array(prm.get("Stress exponents for Peierls creep"),
+                                                                            options);
+
+        options.property_name = "Activation energies for Peierls creep";
+        activation_energies = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation energies for Peierls creep"),
+                                                                               options);
+
+        options.property_name = "Activation volumes for Peierls creep";
+        activation_volumes = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation volumes for Peierls creep"),
+                                                                              options);
+
+        options.property_name = "Peierls stresses";
+        peierls_stresses = Utilities::MapParsing::parse_map_to_double_array(prm.get("Peierls stresses"),
+                                                                            options);
+
+        options.property_name = "Peierls fitting parameters";
+        fitting_parameters = Utilities::MapParsing::parse_map_to_double_array(prm.get("Peierls fitting parameters"),
+                                                                              options);
+
+        options.property_name = "Peierls glide parameters p";
+        glide_parameters_p = Utilities::MapParsing::parse_map_to_double_array(prm.get("Peierls glide parameters p"),
+                                                                              options);
+
+        options.property_name = "Peierls glide parameters q";
+        glide_parameters_q = Utilities::MapParsing::parse_map_to_double_array(prm.get("Peierls glide parameters q"),
+                                                                              options);
+
+        options.property_name = "Cutoff stresses for Peierls creep";
+        stress_cutoffs = Utilities::MapParsing::parse_map_to_double_array(prm.get("Cutoff stresses for Peierls creep"),
+                                                                          options);
+
+        apply_strict_cutoff = prm.get_bool("Apply strict stress cutoff for Peierls creep");
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class PeierlsCreep<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/strain_dependent.cc.bak b/source/material_model/rheology/strain_dependent.cc.bak
new file mode 100644
index 00000000000..d50c760d20c
--- /dev/null
+++ b/source/material_model/rheology/strain_dependent.cc.bak
@@ -0,0 +1,917 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/rheology/strain_dependent.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+#include <aspect/utilities.h>
+#include <aspect/postprocess/particles.h>
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/numerics/fe_field_function.h>
+#include <deal.II/base/quadrature_lib.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace Rheology
+    {
+      template <int dim>
+      void
+      StrainDependent<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Strain weakening mechanism", "default",
+                           Patterns::Selection("none|finite strain tensor|total strain|plastic weakening with plastic strain only|plastic weakening with total strain only|plastic weakening with plastic strain and viscous weakening with viscous strain|viscous weakening with viscous strain only|default"),
+                           "Whether to apply strain weakening to viscosity, cohesion and internal angle"
+                           "of friction based on accumulated finite strain, and if yes, which method to "
+                           "use. The following methods are available:"
+                           "\n\n"
+                           "\\item ``none'': No strain weakening is applied. "
+                           "\n\n"
+                           "\\item ``finite strain tensor'': The full finite strain tensor is tracked, "
+                           "and its second invariant is used to weaken both the plastic yield stress "
+                           "(specifically, the cohesion and friction angle) and the pre-yield viscosity "
+                           "that arises from diffusion and/or dislocation creep."
+                           "\n\n"
+                           "\\item ``total strain'': The finite strain is approximated as the product of "
+                           "the second invariant of the strain rate in each time step and the time step "
+                           "size, and this quantity is integrated and tracked over time. It is used to "
+                           "weaken both the plastic yield stress (specifically, the cohesion and friction "
+                           "angle) and the pre-yield viscosity."
+                           "\n\n"
+                           "\\item ``plastic weakening with plastic strain only'': The finite strain is "
+                           "approximated as the product of the second invariant of the strain rate"
+                           "in each time step and the time step size in regions where material is "
+                           "plastically yielding. This quantity is integrated and tracked over time, and "
+                           "used to weaken the cohesion and friction angle. The pre-yield viscosity is "
+                           "not weakened."
+                           "\n\n"
+                           "\\item ``plastic weakening with total strain only'': The finite strain is "
+                           "approximated as the product of the second invariant of the strain rate in each "
+                           "time step and the time step size, and this quantity is integrated and tracked "
+                           "over time. It is used to weaken the plastic yield stress (specifically, the "
+                           "cohesion and internal friction angle). The pre-yield viscosity is not weakened."
+                           "\n\n"
+                           "\\item ``plastic weakening with plastic strain and viscous weakening with viscous strain'': "
+                           "Both the finite strain accumulated by plastic deformation and by viscous deformation are "
+                           "computed separately (each approximated as the product of the second invariant of the "
+                           "corresponding strain rate in each time step and the time step size). The plastic strain "
+                           "is used to weaken the plastic yield stress (specifically, the cohesion and yield angle), and "
+                           "the viscous strain is used to weaken the pre-yield viscosity."
+                           "\n\n"
+                           "\\item ``viscous weakening with viscous strain only'': The finite strain is "
+                           "approximated as the product of the second invariant of the strain rate "
+                           "in each time step and the time step size in regions where material is "
+                           "not plastically yielding. This quantity is integrated and tracked over time, and "
+                           "used to weaken the pre-yield viscosity. The cohesion and friction angle are "
+                           "not weakened."
+                           "\n\n"
+                           "\\item ``default'': The default option has the same behavior as ``none'', "
+                           "but is there to make sure that the original parameters for specifying the "
+                           "strain weakening mechanism (``Use plastic/viscous strain weakening'') are still allowed, "
+                           "but to guarantee that one uses either the old parameter names or the new ones, "
+                           "never both."
+                           "\n\n"
+                           "If a compositional field named 'noninitial\\_plastic\\_strain' is "
+                           "included in the parameter file, this field will automatically be excluded from "
+                           "from volume fraction calculation and track the cumulative plastic strain with "
+                           "the initial plastic strain values removed.");
+
+        prm.declare_entry ("Start plasticity strain weakening intervals", "0.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of strain weakening interval initial strains "
+                           "for the cohesion and friction angle parameters of the "
+                           "background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. Units: None.");
+
+        prm.declare_entry ("End plasticity strain weakening intervals", "1.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of strain weakening interval final strains "
+                           "for the cohesion and friction angle parameters of the "
+                           "background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+
+        prm.declare_entry ("Cohesion strain weakening factors", "1.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of cohesion strain weakening factors "
+                           "for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+
+        prm.declare_entry ("Friction strain weakening factors", "1.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of friction strain weakening factors "
+                           "for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+
+        prm.declare_entry ("Start prefactor strain weakening intervals", "0.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of strain weakening interval initial strains "
+                           "for the diffusion and dislocation prefactor parameters of the "
+                           "background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+
+        prm.declare_entry ("End prefactor strain weakening intervals", "1.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of strain weakening interval final strains "
+                           "for the diffusion and dislocation prefactor parameters of the "
+                           "background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+
+        prm.declare_entry ("Prefactor strain weakening factors", "1.",
+                           Patterns::List(Patterns::Double(0., 1.)),
+                           "List of viscous strain weakening factors "
+                           "for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value.  Units: None.");
+
+
+        prm.declare_entry ("Use temperature activated strain softening", "false",
+                           Patterns::Bool (),
+                           "Whether viscous strain softening factor depends on temperature");
+
+        prm.declare_entry ("Lower temperature for onset of strain weakening", "823.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of lower temperature for onset of strain weakening "
+                           "for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
+
+        prm.declare_entry ("Lower temperature for maximum strain weakening", "923.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of lower temperature for maximum strain weakening "
+                           "for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
+
+        prm.declare_entry ("Upper temperature for maximum strain weakening", "1023.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of upper temperatures for maximum strain weakening "
+                           "for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
+
+        prm.declare_entry ("Upper temperature for onset of strain weakening", "1123.",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of upper temperatures for onset of strain weakening"
+                           "for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields "
+                           "or only those corresponding to chemical compositions. "
+                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
+
+        prm.declare_entry ("Strain healing mechanism", "no healing",
+                           Patterns::Selection("no healing|temperature dependent"),
+                           "Whether to apply strain healing to plastic yielding and viscosity terms, "
+                           "and if yes, which method to use. The following methods are available:"
+                           "\n\n"
+                           "\\item ``no healing'': No strain healing is applied. "
+                           "\n\n"
+                           "\\item ``temperature dependent'': Purely temperature dependent "
+                           "strain healing applied to plastic yielding and viscosity terms, similar "
+                           "to the temperature-dependent Frank Kamenetskii formulation, computes "
+                           "strain healing as removing strain as a function of temperature, time, "
+                           "and a user-defined healing rate and prefactor "
+                           "as done in Fuchs and Becker, 2019, for mantle convection");
+
+        prm.declare_entry ("Strain healing temperature dependent recovery rate", "1.e-15", Patterns::Double(0),
+                           "Recovery rate prefactor for temperature dependent "
+                           "strain healing. Units: $1/s$");
+
+        prm.declare_entry ("Strain healing temperature dependent prefactor", "15.", Patterns::Double(0),
+                           "Prefactor for temperature dependent "
+                           "strain healing. Units: None");
+      }
+
+      template <int dim>
+      void
+      StrainDependent<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        // number of required compositional fields for full finite strain tensor
+        const unsigned int s = Tensor<2,dim>::n_independent_components;
+
+        // Strain weakening parameters
+        if (prm.get ("Strain weakening mechanism") == "none")
+          weakening_mechanism = none;
+        else if (prm.get ("Strain weakening mechanism") == "finite strain tensor")
+          weakening_mechanism = finite_strain_tensor;
+        else if (prm.get ("Strain weakening mechanism") == "total strain")
+          weakening_mechanism = total_strain;
+        else if (prm.get ("Strain weakening mechanism") == "plastic weakening with plastic strain only")
+          weakening_mechanism = plastic_weakening_with_plastic_strain_only;
+        else if (prm.get ("Strain weakening mechanism") == "plastic weakening with total strain only")
+          weakening_mechanism = plastic_weakening_with_total_strain_only;
+        else if (prm.get ("Strain weakening mechanism") == "plastic weakening with plastic strain and viscous weakening with viscous strain")
+          weakening_mechanism = plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain;
+        else if (prm.get ("Strain weakening mechanism") == "viscous weakening with viscous strain only")
+          weakening_mechanism = viscous_weakening_with_viscous_strain_only;
+        else if (prm.get ("Strain weakening mechanism") == "default")
+          weakening_mechanism = none;
+        else
+          AssertThrow(false, ExcMessage("Not a valid Strain weakening mechanism!"));
+
+        if (weakening_mechanism == plastic_weakening_with_plastic_strain_only
+            || weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
+          {
+            AssertThrow(this->introspection().compositional_name_exists("plastic_strain"),
+                        ExcMessage("Material model visco_plastic with plastic strain weakening only works if there is a "
+                                   "compositional field called plastic_strain."));
+          }
+
+        if (weakening_mechanism == viscous_weakening_with_viscous_strain_only
+            || weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
+          {
+            AssertThrow(this->introspection().compositional_name_exists("viscous_strain"),
+                        ExcMessage("Material model visco_plastic with viscous strain weakening only works if there is a "
+                                   "compositional field called viscous_strain."));
+          }
+
+        if (weakening_mechanism == finite_strain_tensor)
+          {
+            AssertThrow(this->n_compositional_fields() >= s,
+                        ExcMessage("There must be enough compositional fields to track all components of the finite strain tensor (4 in 2d, 9 in 3d). "));
+            // Assert that fields exist and that they are in the right order
+            const unsigned int n_s11 = this->introspection().compositional_index_for_name("s11");
+            const unsigned int n_s12 = this->introspection().compositional_index_for_name("s12");
+            const unsigned int n_s21 = this->introspection().compositional_index_for_name("s21");
+            const unsigned int n_s22 = this->introspection().compositional_index_for_name("s22");
+            if (dim==2)
+              {
+                AssertThrow(n_s11 < n_s12 && n_s12 < n_s21 && n_s21 < n_s22,
+                            ExcMessage("A material model with strain weakening using the full strain tensor only works if there are "
+                                       "compositional fields called sij, with i=1,..,dim and j=1,...,dim listed in the following order: "
+                                       "s11, s12, s21, s22."));
+                AssertThrow(n_s22 == n_s11+s-1, ExcMessage("The strain tensor components should be represented by consecutive fields."));
+              }
+            if (dim==3)
+              {
+                const unsigned int n_s13 = this->introspection().compositional_index_for_name("s13");
+                const unsigned int n_s23 = this->introspection().compositional_index_for_name("s23");
+                const unsigned int n_s31 = this->introspection().compositional_index_for_name("s31");
+                const unsigned int n_s32 = this->introspection().compositional_index_for_name("s32");
+                const unsigned int n_s33 = this->introspection().compositional_index_for_name("s33");
+                AssertThrow(n_s11 < n_s12 && n_s12 < n_s13 && n_s13 < n_s21 && n_s21 < n_s22 && n_s22 < n_s23 && n_s23 < n_s31 && n_s31 < n_s32 && n_s32 < n_s33,
+                            ExcMessage("A material model with strain weakening using the full strain tensor only works if there are "
+                                       "compositional fields called sij, with i=1,..,dim and j=1,...,dim listed in the following order: "
+                                       "s11, s12, s13, s21, s22, s23, s31, s32, s33."));
+                AssertThrow(n_s33 == n_s11+s-1, ExcMessage("The strain tensor components should be represented by consecutive fields."));
+              }
+          }
+
+
+        if (weakening_mechanism == total_strain || weakening_mechanism == plastic_weakening_with_total_strain_only)
+          AssertThrow(this->introspection().compositional_name_exists("total_strain"),
+                      ExcMessage("Material model visco_plastic with total strain weakening only works if there is a "
+                                 "compositional field called total_strain."));
+
+        // Currently, it only makes sense to use this material model with strain weakening when the
+        // nonlinear solver scheme does a single advection iteration. More than one nonlinear advection
+        // iteration will result in the incorrect value of strain being used in the material model, as
+        // the compositional fields representing strain are updated through the reaction terms.
+        if (weakening_mechanism != none)
+          {
+            AssertThrow((this->get_parameters().nonlinear_solver ==
+                         Parameters<dim>::NonlinearSolver::single_Advection_single_Stokes
+                         ||
+                         this->get_parameters().nonlinear_solver ==
+                         Parameters<dim>::NonlinearSolver::single_Advection_iterated_Stokes
+                         ||
+                         this->get_parameters().nonlinear_solver ==
+                         Parameters<dim>::NonlinearSolver::iterated_Advection_and_Stokes
+                         ||
+                         this->get_parameters().nonlinear_solver ==
+                         Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes
+                         ||
+                         this->get_parameters().nonlinear_solver ==
+                         Parameters<dim>::NonlinearSolver::iterated_Advection_and_Newton_Stokes
+                         ||
+                         this->get_parameters().nonlinear_solver ==
+                         Parameters<dim>::NonlinearSolver::single_Advection_iterated_defect_correction_Stokes
+                         ||
+                         this->get_parameters().nonlinear_solver ==
+                         Parameters<dim>::NonlinearSolver::iterated_Advection_and_defect_correction_Stokes
+                         ||
+                         this->get_parameters().nonlinear_solver ==
+                         Parameters<dim>::NonlinearSolver::no_Advection_no_Stokes),
+                        ExcMessage("The material model will only work with the nonlinear "
+                                   "solver schemes 'single Advection, single Stokes', "
+                                   "'single Advection, iterated Stokes', "
+                                   "'iterated Advection and Stokes', "
+                                   "'single Advection, iterated Newton Stokes', "
+                                   "'iterated Advection and Newton Stokes', "
+                                   "'single Advection, iterated defect correction Stokes', "
+                                   "'iterated Advection and defect correction Stokes, and' "
+                                   "'no Advection, no Stokes' "
+                                   "when strain weakening is enabled."));
+          }
+
+
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+        Utilities::MapParsing::Options options(chemical_field_names, "Start plasticity strain weakening intervals");
+        options.list_of_allowed_keys = compositional_field_names;
+
+        start_plastic_strain_weakening_intervals = Utilities::MapParsing::parse_map_to_double_array(prm.get("Start plasticity strain weakening intervals"),
+                                                   options);
+
+        options.property_name = "End plasticity strain weakening intervals";
+        end_plastic_strain_weakening_intervals = Utilities::MapParsing::parse_map_to_double_array(prm.get("End plasticity strain weakening intervals"),
+                                                 options);
+
+        options.property_name = "Start prefactor strain weakening intervals";
+        start_viscous_strain_weakening_intervals = Utilities::MapParsing::parse_map_to_double_array(prm.get("Start prefactor strain weakening intervals"),
+                                                   options);
+
+        options.property_name = "End prefactor strain weakening intervals";
+        end_viscous_strain_weakening_intervals = Utilities::MapParsing::parse_map_to_double_array(prm.get("End prefactor strain weakening intervals"),
+                                                 options);
+
+        options.property_name = "Prefactor strain weakening factors";
+        viscous_strain_weakening_factors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactor strain weakening factors"),
+                                           options);
+
+        options.property_name = "Lower temperature for onset of strain weakening";
+        viscous_strain_weakening_T0 = Utilities::MapParsing::parse_map_to_double_array(prm.get("Lower temperature for onset of strain weakening"),
+                                                                                       options);
+
+        options.property_name = "Lower temperature for maximum strain weakening";
+        viscous_strain_weakening_T1 = Utilities::MapParsing::parse_map_to_double_array(prm.get("Lower temperature for maximum strain weakening"),
+                                                                                       options);
+
+        options.property_name = "Upper temperature for maximum strain weakening";
+        viscous_strain_weakening_T2 = Utilities::MapParsing::parse_map_to_double_array(prm.get("Upper temperature for maximum strain weakening"),
+                                                                                       options);
+
+        options.property_name = "Upper temperature for onset of strain weakening";
+        viscous_strain_weakening_T3 = Utilities::MapParsing::parse_map_to_double_array(prm.get("Upper temperature for onset of strain weakening"),
+                                                                                       options);
+
+        use_temperature_activated_strain_softening = prm.get_bool("Use temperature activated strain softening");
+
+
+        options.property_name = "Cohesion strain weakening factors";
+        cohesion_strain_weakening_factors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Cohesion strain weakening factors"),
+                                            options);
+
+        options.property_name = "Friction strain weakening factors";
+        friction_strain_weakening_factors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Friction strain weakening factors"),
+                                            options);
+
+        if (prm.get ("Strain healing mechanism") == "no healing")
+          healing_mechanism = no_healing;
+        else if (prm.get ("Strain healing mechanism") == "temperature dependent")
+          healing_mechanism = temperature_dependent;
+        else
+          AssertThrow(false, ExcMessage("Not a valid Strain healing mechanism!"));
+
+        // Currently this functionality only works in field composition
+        if (healing_mechanism != no_healing && this->n_particle_worlds() > 0)
+          {
+            const Particle::Property::Manager<dim> &particle_property_manager = this->get_particle_world(0).get_property_manager();
+            AssertThrow(particle_property_manager.plugin_name_exists("viscoplastic strain invariants") == false, ExcMessage("This healing mechanism currently does not work if the strain is tracked on particles."));
+          }
+
+        // Temperature dependent strain healing requires that adiabatic surface temperature is non zero
+        if (healing_mechanism == temperature_dependent)
+          {
+            AssertThrow (this->get_adiabatic_surface_temperature() > 0.0,
+                         ExcMessage("The temperature dependent strain healing can only be used when the adiabatic "
+                                    "surface temperature (reference_temperature in equation for strain healing) "
+                                    "is non-zero."));
+          }
+
+        strain_healing_temperature_dependent_recovery_rate = prm.get_double ("Strain healing temperature dependent recovery rate");
+
+        strain_healing_temperature_dependent_prefactor = prm.get_double ("Strain healing temperature dependent prefactor");
+      }
+
+
+
+      template <int dim>
+      std::array<double, 3>
+      StrainDependent<dim>::
+      compute_strain_weakening_factors(const std::vector<double> &composition,
+                                       const unsigned int j) const
+      {
+        double viscous_weakening = 1.0;
+        std::pair<double, double> brittle_weakening (1.0, 1.0);
+
+        switch (weakening_mechanism)
+          {
+            case none:
+            {
+              break;
+            }
+            case finite_strain_tensor:
+            {
+              // Calculate second invariant of left stretching tensor "L"
+              const Tensor<2,dim> strain(make_array_view(&composition[0],
+                                                         &composition[0] + Tensor<2,dim>::n_independent_components));
+              const SymmetricTensor<2,dim> L = symmetrize( strain * transpose(strain) );
+
+              const double strain_ii = std::fabs(second_invariant(L));
+              brittle_weakening = calculate_plastic_weakening(strain_ii, j);
+              viscous_weakening = calculate_viscous_weakening(strain_ii, j);
+              break;
+            }
+            case total_strain:
+            {
+              const unsigned int total_strain_index = this->introspection().compositional_index_for_name("total_strain");
+              brittle_weakening = calculate_plastic_weakening(composition[total_strain_index], j);
+              viscous_weakening = calculate_viscous_weakening(composition[total_strain_index], j);
+              break;
+            }
+            case plastic_weakening_with_total_strain_only:
+            {
+              const unsigned int total_strain_index = this->introspection().compositional_index_for_name("total_strain");
+              brittle_weakening = calculate_plastic_weakening(composition[total_strain_index], j);
+              break;
+            }
+            case plastic_weakening_with_plastic_strain_only:
+            {
+              const unsigned int plastic_strain_index = this->introspection().compositional_index_for_name("plastic_strain");
+              brittle_weakening = calculate_plastic_weakening(composition[plastic_strain_index], j);
+              break;
+            }
+            case plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain:
+            {
+              const unsigned int plastic_strain_index = this->introspection().compositional_index_for_name("plastic_strain");
+              brittle_weakening = calculate_plastic_weakening(composition[plastic_strain_index], j);
+              const unsigned int viscous_strain_index = this->introspection().compositional_index_for_name("viscous_strain");
+              viscous_weakening = calculate_viscous_weakening(composition[viscous_strain_index], j);
+              break;
+            }
+            case viscous_weakening_with_viscous_strain_only:
+            {
+              const unsigned int viscous_strain_index = this->introspection().compositional_index_for_name("viscous_strain");
+              viscous_weakening = calculate_viscous_weakening(composition[viscous_strain_index], j);
+              break;
+            }
+            default:
+            {
+              AssertThrow(false, ExcNotImplemented());
+              break;
+            }
+          }
+
+        const std::array<double, 3> weakening_factors = {{brittle_weakening.first,brittle_weakening.second,viscous_weakening}};
+
+        return weakening_factors;
+
+      }
+
+
+
+      template <int dim>
+      std::array<double, 3>
+      StrainDependent<dim>::
+      compute_strain_weakening_factors(const unsigned int j,
+                                       const std::vector<double> &composition) const
+      {
+        return compute_strain_weakening_factors(composition,j);
+      }
+
+
+
+      template <int dim>
+      std::array<double, 3>
+      StrainDependent<dim>::
+      apply_temperature_dependence_to_strain_weakening_factors(const std::array<double, 3> &weakening_factors,
+                                                               const double temperature,
+                                                               const unsigned int j) const
+      {
+
+        double factor = 1;
+        const double T0 = viscous_strain_weakening_T0[j];
+        const double T1 = viscous_strain_weakening_T1[j];
+        const double T2 = viscous_strain_weakening_T2[j];
+        const double T3 = viscous_strain_weakening_T3[j];
+        std::array<double, 3> output = weakening_factors;
+
+        if (temperature>T0 && temperature<=T1)
+          factor = (output[2]-1.) / (T1-T0)*(temperature-T0) + 1.;
+        else if (temperature>T1 && temperature<=T2)
+          factor = output[2];
+        else if (temperature>T2 && temperature<=T3)
+          factor = (1-output[2]) / (T3-T2)*(temperature-T2) + output[2];
+        output[2] = factor;
+
+        return output;
+
+      }
+
+
+
+      template <int dim>
+      double
+      StrainDependent<dim>::
+      calculate_strain_healing(const MaterialModel::MaterialModelInputs<dim> &in,
+                               const unsigned int j) const
+      {
+        const double reference_temperature = this->get_adiabatic_surface_temperature();
+        double healed_strain = 0.0;
+
+        switch (healing_mechanism)
+          {
+            case no_healing:
+            {
+              break;
+            }
+            case temperature_dependent:
+            {
+              healed_strain = strain_healing_temperature_dependent_recovery_rate *
+                              std::exp(-strain_healing_temperature_dependent_prefactor * 0.5 * (1.0 - in.temperature[j]/reference_temperature))
+                              * this->get_timestep();
+              break;
+            }
+          }
+        return healed_strain;
+      }
+
+      template <int dim>
+      std::pair<double, double>
+      StrainDependent<dim>::
+      calculate_plastic_weakening(const double strain_ii,
+                                  const unsigned int j) const
+      {
+        // Constrain the second strain invariant of the previous timestep by the strain interval
+        const double cut_off_strain_ii = std::max(std::min(strain_ii,end_plastic_strain_weakening_intervals[j]),start_plastic_strain_weakening_intervals[j]);
+
+        // Linear strain weakening of cohesion and internal friction angle between specified strain values
+        const double strain_fraction = (cut_off_strain_ii - start_plastic_strain_weakening_intervals[j]) /
+                                       (start_plastic_strain_weakening_intervals[j] - end_plastic_strain_weakening_intervals[j]);
+
+        const double weakening_cohesion = 1. + (1. - cohesion_strain_weakening_factors[j]) * strain_fraction;
+        const double weakening_friction = 1. + (1. - friction_strain_weakening_factors[j]) * strain_fraction;
+
+        return std::make_pair (weakening_cohesion, weakening_friction);
+      }
+
+
+      template <int dim>
+      double
+      StrainDependent<dim>::
+      calculate_viscous_weakening(const double strain_ii,
+                                  const unsigned int j) const
+      {
+        // Constrain the second strain invariant of the previous timestep by the strain interval
+        const double cut_off_strain_ii = std::max(std::min(strain_ii,end_viscous_strain_weakening_intervals[j]),start_viscous_strain_weakening_intervals[j]);
+
+        // Linear strain weakening of the viscous flow law prefactors between specified strain values
+        const double strain_fraction = (cut_off_strain_ii - start_viscous_strain_weakening_intervals[j]) /
+                                       (start_viscous_strain_weakening_intervals[j] - end_viscous_strain_weakening_intervals[j]);
+        return 1. + ( 1. - viscous_strain_weakening_factors[j] ) * strain_fraction;
+      }
+
+      template <int dim>
+      void
+      StrainDependent<dim>::
+      fill_reaction_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
+                             const int i,
+                             const double min_strain_rate,
+                             const bool plastic_yielding,
+                             MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+
+        // If strain weakening is used, overwrite the first reaction term,
+        // which represents the second invariant of the (plastic) strain tensor.
+        // If plastic strain is tracked (so not the total strain), only overwrite
+        // when plastically yielding.
+        // If viscous strain is also tracked, overwrite the second reaction term as well.
+        // Calculate changes in strain and update the reaction terms
+        if  (this->simulator_is_past_initialization() && this->get_timestep_number() > 0 && in.requests_property(MaterialProperties::reaction_terms))
+          {
+            Assert(std::isfinite(in.strain_rate[i].norm()),
+                   ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                              "not filled by the caller."));
+
+            const double edot_ii = std::max(std::sqrt(std::max(-second_invariant(deviator(in.strain_rate[i])), 0.)),
+                                            min_strain_rate);
+            double delta_e_ii = edot_ii*this->get_timestep();
+
+            // Assign accumulated strain value according to active deformation mechanism
+
+            // Plastic strain
+            double delta_e_ii_plastic = 0.;
+            if (plastic_yielding == true)
+              delta_e_ii_plastic = delta_e_ii;
+
+            // Viscous strain
+            double delta_e_ii_viscous = 0.;
+            if (plastic_yielding == false)
+              delta_e_ii_viscous = delta_e_ii;
+
+            // Now account for strain healing
+            if (healing_mechanism != no_healing)
+              {
+                // Temperature-dependent healing occurs independent of deformation state
+                const double healed_strain = calculate_strain_healing(in,i);
+
+                delta_e_ii_plastic -= healed_strain;
+                delta_e_ii_viscous -= healed_strain;
+                delta_e_ii -= healed_strain;
+              }
+
+            // We need to obtain the strain values from compositional fields at the previous time step,
+            // as the values from the current linearization point are an extrapolation of the solution
+            // from the old timesteps.
+            // Prepare the field function and extract the old solution values at the current cell.
+            std::vector<Point<dim>> quadrature_positions(1,this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]));
+
+            // Use a boost::small_vector to avoid memory allocation if possible.
+            // Create 100 values by default, which should be enough for most cases.
+            // If there are more than 100 DoFs per cell, this will work like a normal vector.
+            boost::container::small_vector<double, 100> old_solution_values(this->get_fe().dofs_per_cell);
+            in.current_cell->get_dof_values(this->get_old_solution(),
+                                            old_solution_values.begin(),
+                                            old_solution_values.end());
+
+            // If we have not been here before, create one evaluator for each compositional field
+            if (composition_evaluators.size() == 0)
+              composition_evaluators.resize(this->n_compositional_fields());
+
+            // Make sure the evaluators have been initialized correctly, and have not been tampered with
+            Assert(composition_evaluators.size() == this->n_compositional_fields(),
+                   ExcMessage("The number of composition evaluators should be equal to the number of compositional fields."));
+
+            const auto &component_indices = this->introspection().component_indices.compositional_fields;
+
+            // Assign incremental strain values to reaction terms
+            if (weakening_mechanism == plastic_weakening_with_plastic_strain_only)
+              {
+                const unsigned int strain_index = this->introspection().compositional_index_for_name("plastic_strain");
+                // Only create the evaluator the first time we get here
+                if (!composition_evaluators[strain_index])
+                  composition_evaluators[strain_index]
+                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
+                                                                   this->get_fe(),
+                                                                   update_values,
+                                                                   component_indices[strain_index]);
+
+                composition_evaluators[strain_index]->reinit(in.current_cell, quadrature_positions);
+                composition_evaluators[strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
+                                                               EvaluationFlags::values);
+                out.reaction_terms[i][strain_index] = std::max(delta_e_ii_plastic,
+                                                               -composition_evaluators[strain_index]->get_value(0));
+              }
+            if (weakening_mechanism == viscous_weakening_with_viscous_strain_only)
+              {
+                const unsigned int strain_index = this->introspection().compositional_index_for_name("viscous_strain");
+                // Only create the evaluator the first time we get here
+                if (!composition_evaluators[strain_index])
+                  composition_evaluators[strain_index]
+                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
+                                                                   this->get_fe(),
+                                                                   update_values,
+                                                                   component_indices[strain_index]);
+
+                composition_evaluators[strain_index]->reinit(in.current_cell, quadrature_positions);
+                composition_evaluators[strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
+                                                               EvaluationFlags::values);
+                out.reaction_terms[i][strain_index] = std::max(delta_e_ii_viscous,
+                                                               -composition_evaluators[strain_index]->get_value(0));
+              }
+            if (weakening_mechanism == total_strain || weakening_mechanism == plastic_weakening_with_total_strain_only)
+              {
+                const unsigned int strain_index = this->introspection().compositional_index_for_name("total_strain");
+                // Only create the evaluator the first time we get here
+                if (!composition_evaluators[strain_index])
+                  composition_evaluators[strain_index]
+                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
+                                                                   this->get_fe(),
+                                                                   update_values,
+                                                                   component_indices[strain_index]);
+                composition_evaluators[strain_index]->reinit(in.current_cell, quadrature_positions);
+                composition_evaluators[strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
+                                                               EvaluationFlags::values);
+                out.reaction_terms[i][strain_index] = std::max(delta_e_ii,
+                                                               -composition_evaluators[strain_index]->get_value(0));
+              }
+            if (weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
+              {
+                const unsigned int plastic_strain_index = this->introspection().compositional_index_for_name("plastic_strain");
+                // Only create the evaluator the first time we get here
+                if (!composition_evaluators[plastic_strain_index])
+                  composition_evaluators[plastic_strain_index]
+                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
+                                                                   this->get_fe(),
+                                                                   update_values,
+                                                                   component_indices[plastic_strain_index]);
+                composition_evaluators[plastic_strain_index]->reinit(in.current_cell, quadrature_positions);
+                composition_evaluators[plastic_strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
+                                                                       EvaluationFlags::values);
+                out.reaction_terms[i][plastic_strain_index] = std::max(delta_e_ii_plastic,
+                                                                       -composition_evaluators[plastic_strain_index]->get_value(0));
+
+                const unsigned viscous_strain_index = this->introspection().compositional_index_for_name("viscous_strain");
+                // Only create the evaluator the first time we get here
+                if (!composition_evaluators[viscous_strain_index])
+                  composition_evaluators[viscous_strain_index]
+                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
+                                                                   this->get_fe(),
+                                                                   update_values,
+                                                                   component_indices[viscous_strain_index]);
+                composition_evaluators[viscous_strain_index]->reinit(in.current_cell, quadrature_positions);
+                composition_evaluators[viscous_strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
+                                                                       EvaluationFlags::values);
+                out.reaction_terms[i][viscous_strain_index] = std::max(delta_e_ii_viscous,
+                                                                       -composition_evaluators[viscous_strain_index]->get_value(0));
+              }
+            if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
+              {
+                const unsigned int strain_index = this->introspection().compositional_index_for_name("noninitial_plastic_strain");
+                // Only create the evaluator the first time we get here
+                if (!composition_evaluators[strain_index])
+                  composition_evaluators[strain_index]
+                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
+                                                                   this->get_fe(),
+                                                                   update_values,
+                                                                   component_indices[strain_index]);
+
+                composition_evaluators[strain_index]->reinit(in.current_cell, quadrature_positions);
+                composition_evaluators[strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
+                                                               EvaluationFlags::values);
+                out.reaction_terms[i][strain_index] = std::max(delta_e_ii_plastic,
+                                                               -composition_evaluators[strain_index]->get_value(0));
+              }
+          }
+      }
+
+
+      template <int dim>
+      void
+      StrainDependent<dim>::
+      compute_finite_strain_reaction_terms(const MaterialModel::MaterialModelInputs<dim> &in,
+                                           MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+
+        if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0 &&
+            in.requests_property(MaterialProperties::reaction_terms) && weakening_mechanism == finite_strain_tensor)
+          {
+            // We need the velocity gradient for the finite strain (they are not
+            // in material model inputs), so we get them from the finite element.
+            std::vector<Point<dim>> quadrature_positions(in.n_evaluation_points());
+            for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
+              quadrature_positions[i] = this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]);
+
+            std::vector<double> solution_values(this->get_fe().dofs_per_cell);
+            in.current_cell->get_dof_values(this->get_solution(),
+                                            solution_values.begin(),
+                                            solution_values.end());
+
+            // Only create the evaluator the first time we get here
+            if (!evaluator)
+              evaluator = std::make_unique<FEPointEvaluation<dim, dim>>(this->get_mapping(),
+                                                                         this->get_fe(),
+                                                                         update_gradients,
+                                                                         this->introspection().component_indices.velocities[0]);
+
+            // Initialize the evaluator for the old velocity gradients
+            evaluator->reinit(in.current_cell, quadrature_positions);
+            evaluator->evaluate(solution_values,
+                                EvaluationFlags::gradients);
+
+            // Assign the strain components to the compositional fields reaction terms.
+            // If there are too many fields, we simply fill only the first fields with the
+            // existing strain tensor components.
+
+            for (unsigned int q = 0; q < in.n_evaluation_points(); ++q)
+              {
+                if (in.current_cell.state() == IteratorState::valid)
+
+                  {
+                    // Convert the compositional fields into the tensor quantity they represent.
+                    Tensor<2, dim> strain;
+                    const unsigned int n_first = this->introspection().compositional_index_for_name("s11");
+                    for (unsigned int i = n_first; i < n_first + Tensor<2, dim>::n_independent_components; ++i)
+                      {
+                        strain[Tensor<2, dim>::unrolled_to_component_indices(i)] = in.composition[q][i];
+                      }
+
+                    // Compute the strain accumulated in this timestep.
+                    const Tensor<2, dim> strain_increment = this->get_timestep() * (evaluator->get_gradient(q) * strain);
+
+                    // Output the strain increment component-wise to its respective compositional field's reaction terms.
+                    for (unsigned int i = n_first; i < n_first + Tensor<2, dim>::n_independent_components; ++i)
+                      {
+                        out.reaction_terms[q][i] = strain_increment[Tensor<2, dim>::unrolled_to_component_indices(i)];
+                      }
+                  }
+              }
+          }
+      }
+
+      template <int dim>
+      ComponentMask
+      StrainDependent<dim>::
+      get_strain_composition_mask() const
+      {
+
+        // Store which components to exclude during volume fraction computation.
+        ComponentMask strain_mask(this->n_compositional_fields(),true);
+
+        if (weakening_mechanism != none)
+          {
+            if (weakening_mechanism == plastic_weakening_with_plastic_strain_only || weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
+              strain_mask.set(this->introspection().compositional_index_for_name("plastic_strain"),false);
+
+            if (weakening_mechanism == viscous_weakening_with_viscous_strain_only || weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
+              strain_mask.set(this->introspection().compositional_index_for_name("viscous_strain"),false);
+
+            if (weakening_mechanism == total_strain || weakening_mechanism == plastic_weakening_with_total_strain_only)
+              strain_mask.set(this->introspection().compositional_index_for_name("total_strain"),false);
+
+            if (weakening_mechanism == finite_strain_tensor)
+              {
+                const unsigned int n_start = this->introspection().compositional_index_for_name("s11");
+                for (unsigned int i = n_start; i < n_start + Tensor<2,dim>::n_independent_components ; ++i)
+                  strain_mask.set(i,false);
+              }
+          }
+
+        if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
+          strain_mask.set(this->introspection().compositional_index_for_name("noninitial_plastic_strain"),false);
+
+        return strain_mask;
+      }
+
+      template <int dim>
+      WeakeningMechanism
+      StrainDependent<dim>::
+      get_weakening_mechanism() const
+      {
+        return weakening_mechanism;
+      }
+
+      template <int dim>
+      HealingMechanism
+      StrainDependent<dim>::
+      get_healing_mechanism() const
+      {
+        return healing_mechanism;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  namespace Rheology \
+  { \
+    template class StrainDependent<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/rheology/visco_plastic.cc.bak b/source/material_model/rheology/visco_plastic.cc.bak
new file mode 100644
index 00000000000..2fe6259e7d2
--- /dev/null
+++ b/source/material_model/rheology/visco_plastic.cc.bak
@@ -0,0 +1,855 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/rheology/visco_plastic.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/utilities.h>
+#include <aspect/newton.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace
+    {
+      std::vector<std::string> make_plastic_additional_outputs_names()
+      {
+        std::vector<std::string> names;
+        names.emplace_back("current_cohesions");
+        names.emplace_back("current_friction_angles");
+        names.emplace_back("current_yield_stresses");
+        names.emplace_back("plastic_yielding");
+        return names;
+      }
+    }
+
+    template <int dim>
+    PlasticAdditionalOutputs<dim>::PlasticAdditionalOutputs(const unsigned int n_points)
+      : NamedAdditionalMaterialOutputs<dim>(make_plastic_additional_outputs_names()),
+        cohesions(n_points, numbers::signaling_nan<double>()),
+        friction_angles(n_points, numbers::signaling_nan<double>()),
+        yield_stresses(n_points, numbers::signaling_nan<double>()),
+        yielding(n_points, numbers::signaling_nan<double>())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    PlasticAdditionalOutputs<dim>::get_nth_output(const unsigned int idx) const
+    {
+      AssertIndexRange (idx, 4);
+      switch (idx)
+        {
+          case 0:
+            return cohesions;
+
+          case 1:
+            return friction_angles;
+
+          case 2:
+            return yield_stresses;
+
+          case 3:
+            return yielding;
+
+          default:
+            AssertThrow(false, ExcInternalError());
+        }
+      // We will never get here, so just return something
+      return cohesions;
+    }
+
+
+
+    namespace Rheology
+    {
+
+      template <int dim>
+      ViscoPlastic<dim>::ViscoPlastic ()
+        = default;
+
+
+
+      template <int dim>
+      IsostrainViscosities
+      ViscoPlastic<dim>::
+      calculate_isostrain_viscosities (const MaterialModel::MaterialModelInputs<dim> &in,
+                                       const unsigned int i,
+                                       const std::vector<double> &volume_fractions,
+                                       const std::vector<double> &phase_function_values,
+                                       const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        IsostrainViscosities output_parameters;
+
+        // Initialize or fill variables used to calculate viscosities
+        output_parameters.composition_yielding.resize(volume_fractions.size(), false);
+        output_parameters.composition_viscosities.resize(volume_fractions.size(), numbers::signaling_nan<double>());
+        output_parameters.current_friction_angles.resize(volume_fractions.size(), numbers::signaling_nan<double>());
+        output_parameters.current_cohesions.resize(volume_fractions.size(), numbers::signaling_nan<double>());
+
+        // Assemble stress tensor if elastic behavior is enabled
+        SymmetricTensor<2,dim> stress_old = numbers::signaling_nan<SymmetricTensor<2,dim>>();
+        if (this->get_parameters().enable_elasticity)
+          {
+            for (unsigned int j=0; j < SymmetricTensor<2,dim>::n_independent_components; ++j)
+              stress_old[SymmetricTensor<2,dim>::unrolled_to_component_indices(j)] = in.composition[i][j];
+          }
+
+        // Use a specified "reference" strain rate if the strain rate is not yet available,
+        // or close to zero. This is to avoid division by zero.
+        const bool use_reference_strainrate = this->simulator_is_past_initialization() == false
+                                              ||
+                                              (this->get_timestep_number() == 0 &&
+                                               this->get_nonlinear_iteration() == 0)
+                                              ||
+                                              (in.strain_rate[i].norm() <= std::numeric_limits<double>::min());
+
+        double edot_ii;
+        if (use_reference_strainrate)
+          edot_ii = ref_strain_rate;
+        else
+          // Calculate the square root of the second moment invariant for the deviatoric strain rate tensor.
+          edot_ii = std::max(std::sqrt(std::max(-second_invariant(deviator(in.strain_rate[i])), 0.)),
+                             min_strain_rate);
+
+        // Calculate viscosities for each of the individual compositional phases
+        for (unsigned int j=0; j < volume_fractions.size(); ++j)
+          {
+            // Step 1: viscous behavior
+            double non_yielding_viscosity = numbers::signaling_nan<double>();
+
+            // Choice of activation volume depends on whether there is an adiabatic temperature
+            // gradient used when calculating the viscosity. This allows the same activation volume
+            // to be used in incompressible and compressible models.
+            const double temperature_for_viscosity = (this->simulator_is_past_initialization())
+                                                     ?
+                                                     in.temperature[i] + adiabatic_temperature_gradient_for_viscosity*in.pressure[i]
+                                                     :
+                                                     this->get_adiabatic_conditions().temperature(in.position[i]);
+
+            AssertThrow(temperature_for_viscosity != 0, ExcMessage(
+                          "The temperature used in the calculation of the visco-plastic rheology is zero. "
+                          "This is not allowed, because this value is used to divide through. It is probably "
+                          "being caused by the temperature being zero somewhere in the model. The relevant "
+                          "values for debugging are: temperature (" + Utilities::to_string(in.temperature[i]) +
+                          "), adiabatic_temperature_gradient_for_viscosity ("
+                          + Utilities::to_string(adiabatic_temperature_gradient_for_viscosity) + ") and pressure ("
+                          + Utilities::to_string(in.pressure[i]) + ")."));
+            {
+
+              // Step 1a: compute viscosity from diffusion creep law, at least if it is going to be used
+
+              // Determine whether to use the adiabatic pressure instead of the full pressure (default)
+              // when calculating creep viscosity.
+              double pressure_for_creep = in.pressure[i];
+
+              if (use_adiabatic_pressure_in_creep)
+                pressure_for_creep = this->get_adiabatic_conditions().pressure(in.position[i]);
+
+              const double viscosity_diffusion
+                = (viscous_flow_law != dislocation
+                   ?
+                   diffusion_creep.compute_viscosity(pressure_for_creep, temperature_for_viscosity, j,
+                                                     phase_function_values,
+                                                     n_phase_transitions_per_composition)
+                   :
+                   numbers::signaling_nan<double>());
+
+              // Step 1b: compute viscosity from dislocation creep law
+              const double viscosity_dislocation
+                = (viscous_flow_law != diffusion
+                   ?
+                   dislocation_creep.compute_viscosity(edot_ii, pressure_for_creep, temperature_for_viscosity, j,
+                                                       phase_function_values,
+                                                       n_phase_transitions_per_composition)
+                   :
+                   numbers::signaling_nan<double>());
+
+              // Step 1c: select which form of viscosity to use (diffusion, dislocation, fk, or composite), and apply
+              // pre-exponential weakening, if required.
+              switch (viscous_flow_law)
+                {
+                  case diffusion:
+                  {
+                    non_yielding_viscosity = compositional_viscosity_prefactors.compute_viscosity(in, viscosity_diffusion, j, i, \
+                                                                                                  CompositionalViscosityPrefactors<dim>::ModifiedFlowLaws::diffusion);
+                    break;
+                  }
+                  case dislocation:
+                  {
+                    non_yielding_viscosity = compositional_viscosity_prefactors.compute_viscosity(in, viscosity_dislocation, j, i, \
+                                                                                                  CompositionalViscosityPrefactors<dim>::ModifiedFlowLaws::dislocation);
+                    break;
+                  }
+                  case frank_kamenetskii:
+                  {
+                    non_yielding_viscosity = frank_kamenetskii_rheology->compute_viscosity(in.temperature[i], j,
+                                                                                           in.pressure[i],
+                                                                                           this->get_adiabatic_conditions().density(this->get_geometry_model().representative_point(0)),
+                                                                                           this->get_gravity_model().gravity_vector(in.position[0]).norm());
+                    break;
+                  }
+                  case composite:
+                  {
+                    const double scaled_viscosity_diffusion = compositional_viscosity_prefactors.compute_viscosity(in, viscosity_diffusion, j, i, \
+                                                              CompositionalViscosityPrefactors<dim>::ModifiedFlowLaws::diffusion);
+                    const double scaled_viscosity_dislocation = compositional_viscosity_prefactors.compute_viscosity(in, viscosity_dislocation, j, i, \
+                                                                CompositionalViscosityPrefactors<dim>::ModifiedFlowLaws::dislocation);
+                    non_yielding_viscosity = (scaled_viscosity_diffusion * scaled_viscosity_dislocation)/
+                                             (scaled_viscosity_diffusion + scaled_viscosity_dislocation);
+                    break;
+                  }
+                  default:
+                  {
+                    AssertThrow(false, ExcNotImplemented());
+                    break;
+                  }
+                }
+
+              // Step 1d: compute the viscosity from the Peierls creep law and harmonically average with current viscosities
+              if (use_peierls_creep)
+                {
+                  const double viscosity_peierls = peierls_creep->compute_viscosity(edot_ii, pressure_for_creep, temperature_for_viscosity, j,
+                                                                                    phase_function_values,
+                                                                                    n_phase_transitions_per_composition);
+                  non_yielding_viscosity = (non_yielding_viscosity * viscosity_peierls) / (non_yielding_viscosity + viscosity_peierls);
+                }
+            }
+
+
+            // Step 1e: multiply the viscosity by a constant (default value is 1)
+            non_yielding_viscosity = constant_viscosity_prefactors.compute_viscosity(non_yielding_viscosity, j);
+
+            // Step 2: calculate strain weakening factors for the cohesion, friction, and pre-yield viscosity
+            // If no strain weakening is applied, the factors are 1.
+            std::array<double, 3> weakening_factors = strain_rheology.compute_strain_weakening_factors(in.composition[i], j);
+
+            if (strain_rheology.use_temperature_activated_strain_softening)
+              weakening_factors = strain_rheology.apply_temperature_dependence_to_strain_weakening_factors(weakening_factors,temperature_for_viscosity,j);
+
+            // Apply strain weakening to the viscous viscosity.
+            non_yielding_viscosity *= weakening_factors[2];
+
+
+            // Step 3: calculate the viscous stress magnitude
+            // and strain rate. If requested compute visco-elastic contributions.
+            double effective_edot_ii = edot_ii;
+
+            if (this->get_parameters().enable_elasticity)
+              {
+                const std::vector<double> &elastic_shear_moduli = elastic_rheology.get_elastic_shear_moduli();
+
+                if (use_reference_strainrate == true)
+                  effective_edot_ii = ref_strain_rate;
+                else
+                  {
+                    // Overwrite effective_edot_ii with a value that includes a term that accounts for
+                    // elastic stress arising from a previous time step.
+                    // If used, this variable is no longer the "true" strain rate, but is instead
+                    // an effective value that enables the use of a standard isotropic viscosity
+                    // formulation (i.e. where stress and strain are related by a scalar viscosity).
+                    // The additional strain rate component is supported by a corresponding fictional body force.
+                    Assert(std::isfinite(in.strain_rate[i].norm()),
+                           ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                                      "not filled by the caller."));
+                    const SymmetricTensor<2,dim> effective_strain_rate =
+                      elastic_rheology.calculate_viscoelastic_strain_rate(in.strain_rate[i],
+                                                                          stress_old,
+                                                                          elastic_shear_moduli[j]);
+
+                    effective_edot_ii = std::max(std::sqrt(std::max(-second_invariant(effective_strain_rate), 0.)),
+                                                 min_strain_rate);
+                  }
+
+                // Step 3a: calculate the viscoelastic (effective) viscosity
+                non_yielding_viscosity = elastic_rheology.calculate_viscoelastic_viscosity(non_yielding_viscosity,
+                                                                                           elastic_shear_moduli[j]);
+              }
+
+            // Step 3b: calculate non yielding (viscous or viscous + elastic) stress magnitude
+            double non_yielding_stress = 2. * non_yielding_viscosity * effective_edot_ii;
+
+            // Step 4a: calculate the strain-weakened friction and cohesion
+            const DruckerPragerParameters drucker_prager_parameters = drucker_prager_plasticity.compute_drucker_prager_parameters(j,
+                                                                      phase_function_values,
+                                                                      n_phase_transitions_per_composition);
+            const double current_cohesion = drucker_prager_parameters.cohesion * weakening_factors[0];
+            double current_friction = drucker_prager_parameters.angle_internal_friction * weakening_factors[1];
+
+            // Step 4b: calculate the friction angle dependent on strain rate if specified
+            // apply the strain rate dependence to the friction angle (including strain weakening if present)
+            // Note: Maybe this should also be turned around to first apply strain rate dependence and then
+            // the strain weakening to the dynamic friction angle. Didn't come up with a clear argument for
+            // one order or the other.
+            current_friction = friction_models.compute_friction_angle(effective_edot_ii,
+                                                                      j,
+                                                                      current_friction,
+                                                                      in.position[i]);
+            output_parameters.current_friction_angles[j] = current_friction;
+            output_parameters.current_cohesions[j] = current_cohesion;
+
+            // Step 5: plastic yielding
+
+            // Determine if the pressure used in Drucker Prager plasticity will be capped at 0 (default).
+            // This may be necessary in models without gravity and when the dynamic stresses are much higher
+            // than the lithostatic pressure.
+
+            double pressure_for_plasticity = in.pressure[i];
+            if (allow_negative_pressures_in_plasticity == false)
+              pressure_for_plasticity = std::max(in.pressure[i],0.0);
+
+            // Step 5a: calculate the Drucker-Prager yield stress
+            const double yield_stress = drucker_prager_plasticity.compute_yield_stress(current_cohesion,
+                                                                                       current_friction,
+                                                                                       pressure_for_plasticity,
+                                                                                       drucker_prager_parameters.max_yield_stress);
+
+            // Step 5b: select if the yield viscosity is based on Drucker Prager or a stress limiter rheology
+            double effective_viscosity = non_yielding_viscosity;
+            switch (yield_mechanism)
+              {
+                case stress_limiter:
+                {
+                  //Step 5b-1: always rescale the viscosity back to the yield surface
+                  const double viscosity_limiter = yield_stress / (2.0 * ref_strain_rate)
+                                                   * std::pow((edot_ii/ref_strain_rate),
+                                                              1./exponents_stress_limiter[j] - 1.0);
+                  effective_viscosity = 1. / ( 1./viscosity_limiter + 1./non_yielding_viscosity);
+                  break;
+                }
+                case drucker_prager:
+                {
+                  // Step 5b-2: if the non-yielding stress is greater than the yield stress,
+                  // rescale the viscosity back to yield surface
+                  if (non_yielding_stress >= yield_stress)
+                    {
+                      // The following uses the effective_edot_ii
+                      // (which has been modified for elastic effects, above),
+                      // and calculates the effective viscosity over all active rheological elements
+                      // assuming that the non-yielding viscosity is not strain rate dependent
+                      effective_viscosity = drucker_prager_plasticity.compute_viscosity(current_cohesion,
+                                                                                        current_friction,
+                                                                                        pressure_for_plasticity,
+                                                                                        effective_edot_ii,
+                                                                                        drucker_prager_parameters.max_yield_stress,
+                                                                                        non_yielding_viscosity);
+                      output_parameters.composition_yielding[j] = true;
+                    }
+                  break;
+                }
+                default:
+                {
+                  AssertThrow(false, ExcNotImplemented());
+                  break;
+                }
+              }
+
+            // Step 6: limit the viscosity with specified minimum and maximum bounds
+            const double maximum_viscosity_for_composition = MaterialModel::MaterialUtilities::phase_average_value(
+                                                               phase_function_values,
+                                                               n_phase_transitions_per_composition,
+                                                               maximum_viscosity,
+                                                               j,
+                                                               MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic
+                                                             );
+            const double minimum_viscosity_for_composition = MaterialModel::MaterialUtilities::phase_average_value(
+                                                               phase_function_values,
+                                                               n_phase_transitions_per_composition,
+                                                               minimum_viscosity,
+                                                               j,
+                                                               MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic
+                                                             );
+            output_parameters.composition_viscosities[j] = std::min(std::max(effective_viscosity, minimum_viscosity_for_composition), maximum_viscosity_for_composition);
+          }
+        return output_parameters;
+      }
+
+
+
+      template <int dim>
+      void
+      ViscoPlastic<dim>::
+      compute_viscosity_derivatives(const unsigned int i,
+                                    const std::vector<double> &volume_fractions,
+                                    const std::vector<double> &composition_viscosities,
+                                    const MaterialModel::MaterialModelInputs<dim> &in,
+                                    MaterialModel::MaterialModelOutputs<dim> &out,
+                                    const std::vector<double> &phase_function_values,
+                                    const std::vector<unsigned int> &n_phase_transitions_per_composition) const
+      {
+        MaterialModel::MaterialModelDerivatives<dim> *derivatives =
+          out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
+
+        if (derivatives != nullptr)
+          {
+            // compute derivatives if necessary
+            std::vector<SymmetricTensor<2,dim>> composition_viscosities_derivatives(volume_fractions.size());
+            std::vector<double> composition_dviscosities_dpressure(volume_fractions.size());
+
+            const double finite_difference_accuracy = 1e-7;
+
+            // A new material model inputs variable that uses the strain rate and pressure difference.
+            MaterialModel::MaterialModelInputs<dim> in_derivatives = in;
+
+            Assert(std::isfinite(in.strain_rate[i].norm()),
+                   ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                              "not filled by the caller."));
+
+            const SymmetricTensor<2,dim> deviatoric_strain_rate = deviator(in.strain_rate[i]);
+
+            // For each independent component, compute the derivative.
+            for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
+              {
+                const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
+
+                const SymmetricTensor<2,dim> strain_rate_difference = deviatoric_strain_rate
+                                                                      + std::max(std::fabs(deviatoric_strain_rate[strain_rate_indices]), min_strain_rate)
+                                                                      * finite_difference_accuracy
+                                                                      * Utilities::nth_basis_for_symmetric_tensors<dim>(component);
+
+                in_derivatives.strain_rate[i] = strain_rate_difference;
+
+                std::vector<double> eta_component =
+                  calculate_isostrain_viscosities(in_derivatives, i, volume_fractions,
+                                                  phase_function_values, n_phase_transitions_per_composition).composition_viscosities;
+
+                // For each composition of the independent component, compute the derivative.
+                for (unsigned int composition_index = 0; composition_index < eta_component.size(); ++composition_index)
+                  {
+                    // compute the difference between the viscosity with and without the strain-rate difference.
+                    double viscosity_derivative = eta_component[composition_index] - composition_viscosities[composition_index];
+                    if (viscosity_derivative != 0)
+                      {
+                        // when the difference is non-zero, divide by the difference.
+                        viscosity_derivative /= std::max(std::fabs(strain_rate_difference[strain_rate_indices]), min_strain_rate)
+                                                * finite_difference_accuracy;
+                      }
+                    composition_viscosities_derivatives[composition_index][strain_rate_indices] = viscosity_derivative;
+                  }
+              }
+
+            // Now compute the derivative of the viscosity to the pressure
+            const double pressure_difference = in.pressure[i] + (std::fabs(in.pressure[i]) * finite_difference_accuracy);
+
+            in_derivatives.pressure[i] = pressure_difference;
+
+            // Modify the in_derivatives object again to take the original strain rate.
+            in_derivatives.strain_rate[i] = in.strain_rate[i];
+
+            const std::vector<double> viscosity_difference =
+              calculate_isostrain_viscosities(in_derivatives, i, volume_fractions,
+                                              phase_function_values, n_phase_transitions_per_composition).composition_viscosities;
+
+            for (unsigned int composition_index = 0; composition_index < viscosity_difference.size(); ++composition_index)
+              {
+                double viscosity_derivative = viscosity_difference[composition_index] - composition_viscosities[composition_index];
+                if (viscosity_difference[composition_index] != 0)
+                  {
+                    if (in.pressure[i] != 0)
+                      {
+                        viscosity_derivative /= std::fabs(in.pressure[i]) * finite_difference_accuracy;
+                      }
+                    else
+                      {
+                        viscosity_derivative = 0;
+                      }
+                  }
+                composition_dviscosities_dpressure[composition_index] = viscosity_derivative;
+              }
+
+            double viscosity_averaging_p = 0; // Geometric
+            if (viscosity_averaging == MaterialUtilities::harmonic)
+              viscosity_averaging_p = -1;
+            if (viscosity_averaging == MaterialUtilities::arithmetic)
+              viscosity_averaging_p = 1;
+            if (viscosity_averaging == MaterialUtilities::maximum_composition)
+              viscosity_averaging_p = 1000;
+
+            derivatives->viscosity_derivative_wrt_strain_rate[i] =
+              Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],
+                                                               volume_fractions,
+                                                               composition_viscosities,
+                                                               composition_viscosities_derivatives,
+                                                               viscosity_averaging_p);
+            derivatives->viscosity_derivative_wrt_pressure[i] =
+              Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],
+                                                               volume_fractions,
+                                                               composition_viscosities,
+                                                               composition_dviscosities_dpressure,
+                                                               viscosity_averaging_p);
+          }
+      }
+
+
+
+      template <int dim>
+      ComponentMask
+      ViscoPlastic<dim>::
+      get_volumetric_composition_mask() const
+      {
+        // Store which components to exclude during the volume fraction computation.
+        ComponentMask composition_mask = strain_rheology.get_strain_composition_mask();
+
+        if (this->get_parameters().enable_elasticity)
+          {
+            for (unsigned int i = 0; i < SymmetricTensor<2,dim>::n_independent_components ; ++i)
+              composition_mask.set(i,false);
+          }
+
+        return composition_mask;
+      }
+
+
+
+      template <int dim>
+      void
+      ViscoPlastic<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        Rheology::StrainDependent<dim>::declare_parameters (prm);
+
+        Rheology::FrictionModels<dim>::declare_parameters (prm);
+
+        Rheology::Elasticity<dim>::declare_parameters (prm);
+
+        // Reference and minimum/maximum values
+        prm.declare_entry ("Minimum strain rate", "1.0e-20", Patterns::Double (0.),
+                           "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}.");
+        prm.declare_entry ("Reference strain rate","1.0e-15",Patterns::Double (0.),
+                           "Reference strain rate for first time step. Units: \\si{\\per\\second}.");
+        prm.declare_entry ("Minimum viscosity", "1e17", Patterns::Anything(),
+                           "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}. "
+                           "List with as many components as active "
+                           "compositional fields (material data is assumed to "
+                           "be in order with the ordering of the fields). ");
+        prm.declare_entry ("Maximum viscosity", "1e28", Patterns::Anything(),
+                           "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}. "
+                           "List with as many components as active "
+                           "compositional fields (material data is assumed to "
+                           "be in order with the ordering of the fields). ");
+
+        // Rheological parameters
+        prm.declare_entry ("Viscosity averaging scheme", "harmonic",
+                           Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
+                           "When more than one compositional field is present at a point "
+                           "with different viscosities, we need to come up with an average "
+                           "viscosity at that point.  Select a weighted harmonic, arithmetic, "
+                           "geometric, or maximum composition.");
+        prm.declare_entry ("Viscous flow law", "composite",
+                           Patterns::Selection("diffusion|dislocation|frank kamenetskii|composite"),
+                           "Select what type of viscosity law to use between diffusion, "
+                           "dislocation, frank kamenetskii, and composite options. Soon there will be an option "
+                           "to select a specific flow law for each assigned composition ");
+        prm.declare_entry ("Yield mechanism", "drucker",
+                           Patterns::Selection("drucker|limiter"),
+                           "Select what type of yield mechanism to use between Drucker Prager "
+                           "and stress limiter options.");
+        prm.declare_entry ("Allow negative pressures in plasticity", "false",
+                           Patterns::Bool (),
+                           "Whether to allow negative pressures to be used in the computation "
+                           "of plastic yield stresses and viscosities. Setting this parameter "
+                           "to true may be advantageous in models without gravity where the "
+                           "dynamic stresses are much higher than the lithostatic pressure. "
+                           "If false, the minimum pressure in the plasticity formulation will "
+                           "be set to zero.");
+        prm.declare_entry ("Use adiabatic pressure in creep viscosity", "false",
+                           Patterns::Bool (),
+                           "Whether to use the adiabatic pressure instead of the full "
+                           "pressure (default) when calculating creep (diffusion, dislocation, "
+                           "and peierls) viscosity. This may be helpful in models where the "
+                           "full pressure has an unusually large negative value arising from "
+                           "large negative dynamic pressure, resulting in solver convergence "
+                           "issue and in some cases a viscosity of zero.");
+
+        // Diffusion creep parameters
+        Rheology::DiffusionCreep<dim>::declare_parameters(prm);
+
+        // Dislocation creep parameters
+        Rheology::DislocationCreep<dim>::declare_parameters(prm);
+
+        // Frank-Kamenetskii viscosity parameters
+        Rheology::FrankKamenetskii<dim>::declare_parameters(prm);
+
+        // Peierls creep parameters
+        Rheology::PeierlsCreep<dim>::declare_parameters(prm);
+
+        prm.declare_entry ("Include Peierls creep", "false",
+                           Patterns::Bool (),
+                           "Whether to include Peierls creep in the rheological formulation.");
+
+        // Constant viscosity prefactor parameters
+        Rheology::ConstantViscosityPrefactors<dim>::declare_parameters(prm);
+
+        // Variable viscosity prefactor parameters
+        Rheology::CompositionalViscosityPrefactors<dim>::declare_parameters(prm);
+
+        // Drucker Prager plasticity parameters
+        Rheology::DruckerPrager<dim>::declare_parameters(prm);
+
+        // Stress limiter parameters
+        prm.declare_entry ("Stress limiter exponents", "1.0",
+                           Patterns::List(Patterns::Double (0.)),
+                           "List of stress limiter exponents, $n_{\\text{lim}}$, "
+                           "for background material and compositional fields, "
+                           "for a total of N+1 values, where N is the number of all compositional fields or only "
+                           "those corresponding to chemical compositions. Units: none.");
+
+        // Temperature gradient in viscosity laws to include an adiabat (note units of K/Pa)
+        prm.declare_entry ("Adiabat temperature gradient for viscosity", "0.0", Patterns::Double (0.),
+                           "Add an adiabatic temperature gradient to the temperature used in the flow law "
+                           "so that the activation volume is consistent with what one would use in a "
+                           "earth-like (compressible) model. Default is set so this is off. "
+                           "Note that this is a linear approximation of the real adiabatic gradient, which "
+                           "is okay for the upper mantle, but is not really accurate for the lower mantle. "
+                           "Using a pressure gradient of 32436 Pa/m, then a value of "
+                           "0.3 K/km = 0.0003 K/m = 9.24e-09 K/Pa gives an earth-like adiabat."
+                           "Units: \\si{\\kelvin\\per\\pascal}.");
+      }
+
+
+
+      template <int dim>
+      void
+      ViscoPlastic<dim>::parse_parameters (ParameterHandler &prm,
+                                           const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
+      {
+        strain_rheology.initialize_simulator (this->get_simulator());
+        strain_rheology.parse_parameters(prm);
+
+        friction_models.initialize_simulator (this->get_simulator());
+        friction_models.parse_parameters(prm);
+
+        if (this->get_parameters().enable_elasticity)
+          {
+            elastic_rheology.initialize_simulator (this->get_simulator());
+            elastic_rheology.parse_parameters(prm);
+          }
+
+        // Reference and minimum/maximum values
+        min_strain_rate = prm.get_double("Minimum strain rate");
+        ref_strain_rate = prm.get_double("Reference strain rate");
+
+        // Retrieve the list of composition names
+        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
+        // plastic strain
+        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+
+        // Establish that a background field is required here
+        compositional_field_names.insert(compositional_field_names.begin(), "background");
+        chemical_field_names.insert(chemical_field_names.begin(), "background");
+
+        Utilities::MapParsing::Options options(chemical_field_names, "Minimum viscosity");
+        options.list_of_allowed_keys = compositional_field_names;
+        options.allow_multiple_values_per_key = true;
+        if (expected_n_phases_per_composition)
+          {
+            options.n_values_per_key = *expected_n_phases_per_composition;
+
+            // check_values_per_key is required to be true to duplicate single values
+            // if they are to be used for all phases associated with a given key.
+            options.check_values_per_key = true;
+          }
+
+        minimum_viscosity = Utilities::MapParsing::parse_map_to_double_array (prm.get("Minimum viscosity"),
+                                                                              options);
+
+        options.property_name = "Maximum viscosity";
+        maximum_viscosity = Utilities::MapParsing::parse_map_to_double_array (prm.get("Maximum viscosity"),
+                                                                              options);
+
+        Assert(maximum_viscosity.size() == minimum_viscosity.size(),
+               ExcMessage("The input parameters 'Maximum viscosity' and 'Minimum viscosity' should have the same number of entries."));
+        for (auto p1 = maximum_viscosity.begin(), p2 = minimum_viscosity.begin();
+             p1 != maximum_viscosity.end(); ++p1, ++p2)
+          AssertThrow(*p1 >= *p2, ExcMessage("Maximum viscosity should be larger or equal to the minimum viscosity."));
+
+        viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
+                              prm);
+
+        // Rheological parameters
+        if (prm.get ("Viscous flow law") == "composite")
+          viscous_flow_law = composite;
+        else if (prm.get ("Viscous flow law") == "diffusion")
+          viscous_flow_law = diffusion;
+        else if (prm.get ("Viscous flow law") == "dislocation")
+          viscous_flow_law = dislocation;
+        else if (prm.get ("Viscous flow law") == "frank kamenetskii")
+          viscous_flow_law = frank_kamenetskii;
+        else
+          AssertThrow(false, ExcMessage("Not a valid viscous flow law"));
+
+        if (prm.get ("Yield mechanism") == "drucker")
+          yield_mechanism = drucker_prager;
+        else if (prm.get ("Yield mechanism") == "limiter")
+          yield_mechanism = stress_limiter;
+        else
+          AssertThrow(false, ExcMessage("Not a valid yield mechanism."));
+
+        AssertThrow(this->get_parameters().enable_elasticity == false || yield_mechanism == drucker_prager,
+                    ExcMessage("Elastic behavior is only tested with the "
+                               "'drucker prager' plasticity option."));
+
+        allow_negative_pressures_in_plasticity = prm.get_bool ("Allow negative pressures in plasticity");
+        use_adiabatic_pressure_in_creep = prm.get_bool("Use adiabatic pressure in creep viscosity");
+
+        // Diffusion creep parameters
+        diffusion_creep.initialize_simulator (this->get_simulator());
+        diffusion_creep.parse_parameters(prm, expected_n_phases_per_composition);
+
+        // Dislocation creep parameters
+        dislocation_creep.initialize_simulator (this->get_simulator());
+        dislocation_creep.parse_parameters(prm, expected_n_phases_per_composition);
+
+        // Frank Kamenetskii viscosity parameters
+        if (viscous_flow_law == frank_kamenetskii)
+          {
+            frank_kamenetskii_rheology = std::make_unique<Rheology::FrankKamenetskii<dim>>();
+            frank_kamenetskii_rheology->initialize_simulator (this->get_simulator());
+            frank_kamenetskii_rheology->parse_parameters(prm);
+          }
+
+        // Peierls creep parameters
+        use_peierls_creep = prm.get_bool ("Include Peierls creep");
+        if (use_peierls_creep)
+          {
+            peierls_creep = std::make_unique<Rheology::PeierlsCreep<dim>>();
+            peierls_creep->initialize_simulator (this->get_simulator());
+            peierls_creep->parse_parameters(prm, expected_n_phases_per_composition);
+          }
+
+        // Constant viscosity prefactor parameters
+        constant_viscosity_prefactors.initialize_simulator (this->get_simulator());
+        constant_viscosity_prefactors.parse_parameters(prm);
+
+        compositional_viscosity_prefactors.initialize_simulator (this->get_simulator());
+        compositional_viscosity_prefactors.parse_parameters(prm);
+
+        // Plasticity parameters
+        drucker_prager_plasticity.initialize_simulator (this->get_simulator());
+        drucker_prager_plasticity.parse_parameters(prm, expected_n_phases_per_composition);
+
+        // Stress limiter parameter (does not allow for phases per composition)
+        options.property_name = "Stress limiter exponents";
+        options.allow_multiple_values_per_key = false;
+        options.check_values_per_key = false;
+
+        exponents_stress_limiter = Utilities::MapParsing::parse_map_to_double_array (prm.get("Stress limiter exponents"),
+                                                                                     options);
+
+        // Include an adiabat temperature gradient in flow laws
+        adiabatic_temperature_gradient_for_viscosity = prm.get_double("Adiabat temperature gradient for viscosity");
+        if (this->get_heating_model_manager().adiabatic_heating_enabled())
+          AssertThrow (adiabatic_temperature_gradient_for_viscosity == 0.0,
+                       ExcMessage("If adiabatic heating is enabled you should not add another adiabatic gradient"
+                                  "to the temperature for computing the viscosity, because the ambient"
+                                  "temperature profile already includes the adiabatic gradient."));
+
+      }
+
+
+
+      template <int dim>
+      void
+      ViscoPlastic<dim>::create_plastic_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+        if (out.template get_additional_output<PlasticAdditionalOutputs<dim>>() == nullptr)
+          {
+            const unsigned int n_points = out.n_evaluation_points();
+            out.additional_outputs.push_back(
+              std::make_unique<PlasticAdditionalOutputs<dim>> (n_points));
+          }
+      }
+
+      template <int dim>
+      void
+      ViscoPlastic<dim>::
+      fill_plastic_outputs(const unsigned int i,
+                           const std::vector<double> &volume_fractions,
+                           const bool plastic_yielding,
+                           const MaterialModel::MaterialModelInputs<dim> &in,
+                           MaterialModel::MaterialModelOutputs<dim> &out,
+                           const IsostrainViscosities &isostrain_viscosities) const
+      {
+        PlasticAdditionalOutputs<dim> *plastic_out = out.template get_additional_output<PlasticAdditionalOutputs<dim>>();
+
+        if (plastic_out != nullptr)
+          {
+            AssertThrow(in.requests_property(MaterialProperties::viscosity),
+                        ExcMessage("The PlasticAdditionalOutputs cannot be filled when the viscosity has not been computed."));
+
+            plastic_out->cohesions[i] = 0;
+            plastic_out->friction_angles[i] = 0;
+            plastic_out->yield_stresses[i] = 0;
+            plastic_out->yielding[i] = plastic_yielding ? 1 : 0;
+
+            const std::vector<double> friction_angles_RAD = isostrain_viscosities.current_friction_angles;
+            const std::vector<double> cohesions = isostrain_viscosities.current_cohesions;
+
+            // The max yield stress is the same for each composition, so we give the 0th field value.
+            const double max_yield_stress = drucker_prager_plasticity.compute_drucker_prager_parameters(0).max_yield_stress;
+
+            double pressure_for_plasticity = in.pressure[i];
+            if (allow_negative_pressures_in_plasticity == false)
+              pressure_for_plasticity = std::max(in.pressure[i], 0.0);
+
+            // average over the volume volume fractions
+            for (unsigned int j = 0; j < volume_fractions.size(); ++j)
+              {
+                plastic_out->cohesions[i]   += volume_fractions[j] * cohesions[j];
+                // Also convert radians to degrees
+                plastic_out->friction_angles[i] += constants::radians_to_degree * volume_fractions[j] * friction_angles_RAD[j];
+                plastic_out->yield_stresses[i] += volume_fractions[j] * drucker_prager_plasticity.compute_yield_stress(cohesions[j],
+                                                  friction_angles_RAD[j],
+                                                  pressure_for_plasticity,
+                                                  max_yield_stress);
+
+              }
+          }
+      }
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+#define INSTANTIATE(dim) \
+  template class PlasticAdditionalOutputs<dim>; \
+  \
+  namespace Rheology \
+  { \
+    template class ViscoPlastic<dim>; \
+  }
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/material_model/simple.cc.bak b/source/material_model/simple.cc.bak
new file mode 100644
index 00000000000..ac2003a3744
--- /dev/null
+++ b/source/material_model/simple.cc.bak
@@ -0,0 +1,265 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/simple.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    Simple<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // The Simple model has up to one compositional field (plus one background field)
+      // that can influence the density
+      const unsigned int n_compositions_for_eos = std::min(this->n_compositional_fields()+1, 2u);
+      EquationOfStateOutputs<dim> eos_outputs (n_compositions_for_eos);
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double delta_temp = in.temperature[i]-reference_T;
+          const double temperature_dependence
+            = (reference_T > 0
+               ?
+               std::max(std::min(std::exp(-thermal_viscosity_exponent *
+                                          delta_temp/reference_T),
+                                 maximum_thermal_prefactor),
+                        minimum_thermal_prefactor)
+               :
+               1.0);
+
+          out.viscosities[i] = ((composition_viscosity_prefactor != 1.0) && (in.composition[i].size()>0))
+                               ?
+                               // Geometric interpolation
+                               std::pow(10.0, ((1-in.composition[i][0]) * std::log10(eta *
+                                                                                     temperature_dependence)
+                                               + in.composition[i][0] * std::log10(eta *
+                                                                                   composition_viscosity_prefactor *
+                                                                                   temperature_dependence)))
+                               :
+                               temperature_dependence * eta;
+
+          equation_of_state.evaluate(in, i, eos_outputs);
+
+          // except for the density, all material properties are constant across compositions
+          out.thermal_expansion_coefficients[i] = eos_outputs.thermal_expansion_coefficients[0];
+          out.specific_heat[i] = eos_outputs.specific_heat_capacities[0];
+          out.thermal_conductivities[i] = k_value;
+          out.compressibilities[i] = eos_outputs.compressibilities[0];
+          out.entropy_derivative_pressure[i] = eos_outputs.entropy_derivative_pressure[0];
+          out.entropy_derivative_temperature[i] = eos_outputs.entropy_derivative_temperature[0];
+
+          // Change in composition due to chemical reactions at the
+          // given positions. The term reaction_terms[i][c] is the
+          // change in compositional field c at point i.
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+
+          std::vector<double> volume_fractions (n_compositions_for_eos, 1.0);
+          if (in.composition[i].size()>0)
+            {
+              volume_fractions[1] = std::max(0.0, in.composition[i][0]);
+              volume_fractions[0] = 1.0 - volume_fractions[1];
+            }
+
+          out.densities[i] = MaterialUtilities::average_value(volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    Simple<dim>::
+    is_compressible () const
+    {
+      return equation_of_state.is_compressible ();
+    }
+
+
+
+    template <int dim>
+    void
+    Simple<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simple model");
+        {
+          EquationOfState::LinearizedIncompressible<dim>::declare_parameters (prm, 1);
+
+          prm.declare_entry ("Reference temperature", "293.",
+                             Patterns::Double (0.),
+                             "The reference temperature $T_0$. The reference temperature is used "
+                             "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Viscosity", "5e24",
+                             Patterns::Double (0.),
+                             "The value of the constant viscosity $\\eta_0$. This viscosity may be "
+                             "modified by both temperature and compositional dependencies. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Composition viscosity prefactor", "1.0",
+                             Patterns::Double (0.),
+                             "A linear dependency of viscosity on the first compositional field. "
+                             "Dimensionless prefactor. With a value of 1.0 (the default) the "
+                             "viscosity does not depend on the composition. See the general documentation "
+                             "of this model for a formula that states the dependence of the "
+                             "viscosity on this factor, which is called $\\xi$ there.");
+          prm.declare_entry ("Thermal viscosity exponent", "0.0",
+                             Patterns::Double (0.),
+                             "The temperature dependence of viscosity. Dimensionless exponent. "
+                             "See the general documentation "
+                             "of this model for a formula that states the dependence of the "
+                             "viscosity on this factor, which is called $\\beta$ there.");
+          prm.declare_entry("Maximum thermal prefactor","1.0e2",
+                            Patterns::Double (0.),
+                            "The maximum value of the viscosity prefactor associated with temperature "
+                            "dependence.");
+          prm.declare_entry("Minimum thermal prefactor","1.0e-2",
+                            Patterns::Double (0.),
+                            "The minimum value of the viscosity prefactor associated with temperature "
+                            "dependence.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Simple<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simple model");
+        {
+          equation_of_state.parse_parameters (prm, 1);
+
+          reference_T                = prm.get_double ("Reference temperature");
+          eta                        = prm.get_double ("Viscosity");
+          composition_viscosity_prefactor = prm.get_double ("Composition viscosity prefactor");
+          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
+          maximum_thermal_prefactor       = prm.get_double ("Maximum thermal prefactor");
+          minimum_thermal_prefactor       = prm.get_double ("Minimum thermal prefactor");
+          if ( maximum_thermal_prefactor == 0.0 ) maximum_thermal_prefactor = std::numeric_limits<double>::max();
+          if ( minimum_thermal_prefactor == 0.0 ) minimum_thermal_prefactor = std::numeric_limits<double>::min();
+
+          k_value                    = prm.get_double ("Thermal conductivity");
+
+          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
+            AssertThrow(false, ExcMessage("Error: Material model simple with Thermal viscosity exponent can not have reference_T=0."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.density = NonlinearDependence::temperature|NonlinearDependence::compositional_fields;
+
+      if (thermal_viscosity_exponent != 0)
+        this->model_dependence.viscosity |= NonlinearDependence::temperature;
+      if (composition_viscosity_prefactor != 1.0)
+        this->model_dependence.viscosity |= NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Simple,
+                                   "simple",
+                                   "A material model that has constant values "
+                                   "for all coefficients but the density and viscosity. The defaults for all "
+                                   "coefficients are chosen to be similar to what is believed to be correct "
+                                   "for Earth's mantle. All of the values that define this model are read "
+                                   "from a section ``Material model/Simple model'' in the input file, see "
+                                   "Section~\\ref{parameters:Material_20model/Simple_20model}."
+                                   "\n\n"
+                                   "This model uses the following set of equations for the two coefficients that "
+                                   "are non-constant: "
+                                   "\\begin{align}"
+                                   "  \\eta(p,T,\\mathfrak c) &= \\tau(T) \\zeta(\\mathfrak c) \\eta_0, \\\\"
+                                   "  \\rho(p,T,\\mathfrak c) &= \\left(1-\\alpha (T-T_0)\\right)\\rho_0 + \\Delta\\rho \\; c_0,"
+                                   "\\end{align}"
+                                   "where $c_0$ is the first component of the compositional vector "
+                                   "$\\mathfrak c$ if the model uses compositional fields, or zero otherwise. "
+                                   "\n\n"
+                                   "The temperature pre-factor for the viscosity formula above is "
+                                   "defined as "
+                                   "\\begin{align}"
+                                   "  \\tau(T) &= H\\left(e^{-\\beta (T-T_0)/T_0}\\right),"
+                                   "\\intertext{with} "
+                                   "  \\qquad\\qquad H(x) &= \\begin{cases}"
+                                   "                            \\tau_{\\text{min}} & \\text{if}\\; x<\\tau_{\\text{min}}, \\\\"
+                                   "                            x & \\text{if}\\; 10^{-2}\\le x \\le 10^2, \\\\"
+                                   "                            \\tau_{\\text{max}} & \\text{if}\\; x>\\tau_{\\text{max}}, \\\\"
+                                   "                         \\end{cases}"
+                                   "\\end{align} "
+                                   "where $x=e^{-\\beta (T-T_0)/T_0}$, "
+                                   "$\\beta$ corresponds to the input parameter ``Thermal viscosity exponent'', "
+                                   "and $T_0$ to the parameter ``Reference temperature''. If you set $T_0=0$ "
+                                   "in the input file, the thermal pre-factor $\\tau(T)=1$. The parameters $\\tau_{\\text{min}}$ "
+                                   "and $\\tau_{\\text{max}}$ set the minimum and maximum values of the temperature pre-factor "
+                                   "and are set using ``Maximum thermal prefactor'' and ``Minimum thermal prefactor''. "
+                                   "Specifying a value of 0.0 for the minimum or maximum values will disable pre-factor limiting."
+                                   "\n\n"
+                                   "The compositional pre-factor for the viscosity is defined as "
+                                   "$ \\zeta(\\mathfrak c) = \\xi^{c_0}$ "
+                                   "if the model has compositional fields and equals one otherwise. $\\xi$ "
+                                   "corresponds to the parameter ``Composition viscosity prefactor'' in the "
+                                   "input file."
+                                   "\n\n"
+                                   "Finally, in the formula for the density, $\\alpha$ corresponds to the "
+                                   "``Thermal expansion coefficient'' and "
+                                   "$\\Delta\\rho$ "
+                                   "corresponds to the parameter ``Density differential for compositional field 1''."
+                                   "\n\n"
+                                   "Note that this model uses the formulation that assumes an incompressible "
+                                   "medium despite the fact that the density follows the law "
+                                   "$\\rho(T)=\\rho_0(1-\\alpha(T-T_{\\text{ref}}))$. "
+                                   "\n\n"
+                                   ":::{note}\n"
+                                   "Despite its name, this material model is not exactly ``simple'', "
+                                   "as indicated by the formulas above. While it was originally intended "
+                                   "to be simple, it has over time acquired all sorts of temperature "
+                                   "and compositional dependencies that weren't initially intended. "
+                                   "Consequently, there is now a ``simpler'' material model that now fills "
+                                   "the role the current model was originally intended to fill.\n"
+                                   ":::")
+  }
+}
diff --git a/source/material_model/simple_compressible.cc.bak b/source/material_model/simple_compressible.cc.bak
new file mode 100644
index 00000000000..fae99bbc633
--- /dev/null
+++ b/source/material_model/simple_compressible.cc.bak
@@ -0,0 +1,170 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple_compressible.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    SimpleCompressible<dim>::
+    evaluate(const MaterialModelInputs<dim> &in,
+             MaterialModelOutputs<dim> &out) const
+    {
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const Point<dim> position = in.position[i];
+          const double temperature = in.temperature[i];
+          const double pressure = in.pressure[i];
+
+          out.viscosities[i] = constant_rheology.compute_viscosity();
+          out.specific_heat[i] = reference_specific_heat;
+          out.thermal_conductivities[i] = k_value;
+          out.thermal_expansion_coefficients[i] = thermal_alpha;
+
+          double rho = reference_rho * std::exp(reference_compressibility * (pressure - this->get_surface_pressure()));
+          rho *= (1 - thermal_alpha * (temperature - this->get_adiabatic_conditions().temperature(position)));
+
+          out.densities[i] = rho;
+          out.compressibilities[i] = reference_compressibility; // 1/rho drho/dp
+          out.entropy_derivative_pressure[i] = 0.0;
+          out.entropy_derivative_temperature[i] = 0.0;
+          // Change in composition due to chemical reactions at the
+          // given positions. The term reaction_terms[i][c] is the
+          // change in compositional field c at point i.
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    SimpleCompressible<dim>::
+    is_compressible () const
+    {
+      return (reference_compressibility != 0);
+    }
+
+
+
+    template <int dim>
+    void
+    SimpleCompressible<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simple compressible model");
+        {
+          prm.declare_entry ("Reference density", "3300.",
+                             Patterns::Double (0.),
+                             "Reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250.",
+                             Patterns::Double (0.),
+                             "The value of the specific heat $C_p$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                             Patterns::Double (0.),
+                             "The value of the thermal expansion coefficient $\\alpha$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Reference compressibility", "4e-12",
+                             Patterns::Double (0.),
+                             "The value of the reference compressibility. "
+                             "Units: \\si{\\per\\pascal}.");
+
+          Rheology::ConstantViscosity::declare_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    SimpleCompressible<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simple compressible model");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          k_value                    = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+          reference_compressibility  = prm.get_double ("Reference compressibility");
+
+          constant_rheology.parse_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+      this->model_dependence.density = NonlinearDependence::none;
+
+      if (thermal_alpha != 0)
+        this->model_dependence.density |= NonlinearDependence::temperature;
+      if (reference_compressibility != 0)
+        this->model_dependence.density |= NonlinearDependence::pressure;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SimpleCompressible,
+                                   "simple compressible",
+                                   "A material model that has constant values "
+                                   "for all coefficients but the density. The defaults for all "
+                                   "coefficients are chosen to be similar to what is believed to be correct "
+                                   "for Earth's mantle. All of the values that define this model are read "
+                                   "from a section ``Material model/Simple compressible model'' in the input file, see "
+                                   "Section~\\ref{parameters:Material_20model/Simple_20compressible_20model}."
+                                   "\n\n"
+                                   "This model uses the following equations for the density: "
+                                   "$ \\rho(p,T) = \\rho_0 \\left(1-\\alpha (T-T_a)\\right) \\exp{\\beta (P-P_0))}$ "
+                                   "This formulation for the density assumes that the compressibility "
+                                   "provided by the user is the adiabatic compressibility ($\\beta_S$). "
+                                   "The thermal expansivity and isentropic compressibility implied by "
+                                   "the pressure and temperature dependence are equal to the "
+                                   "user-defined constant values only along the reference isentrope, and "
+                                   "there is also an implicit pressure dependence to the heat capacity "
+                                   "$C_p$ via Maxwell's relations.")
+  }
+}
diff --git a/source/material_model/simpler.cc.bak b/source/material_model/simpler.cc.bak
new file mode 100644
index 00000000000..684666df8fc
--- /dev/null
+++ b/source/material_model/simpler.cc.bak
@@ -0,0 +1,131 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/simpler.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    bool
+    Simpler<dim>::
+    is_compressible () const
+    {
+      return equation_of_state.is_compressible ();
+    }
+
+    template <int dim>
+    void
+    Simpler<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // The Simpler model does not depend on composition
+      EquationOfStateOutputs<dim> eos_outputs (1);
+
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          equation_of_state.evaluate(in, i, eos_outputs);
+
+          out.viscosities[i] = constant_rheology.compute_viscosity();
+          out.densities[i] = eos_outputs.densities[0];
+          out.thermal_expansion_coefficients[i] = eos_outputs.thermal_expansion_coefficients[0];
+          out.specific_heat[i] = eos_outputs.specific_heat_capacities[0];
+          out.thermal_conductivities[i] = k_value;
+          out.compressibilities[i] = eos_outputs.compressibilities[0];
+
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+
+    }
+
+
+    template <int dim>
+    void
+    Simpler<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simpler model");
+        {
+          EquationOfState::LinearizedIncompressible<dim>::declare_parameters (prm);
+
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          Rheology::ConstantViscosity::declare_parameters(prm,5e24);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Simpler<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simpler model");
+        {
+          equation_of_state.parse_parameters (prm);
+
+          k_value                    = prm.get_double ("Thermal conductivity");
+
+          constant_rheology.parse_parameters(prm);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.density = NonlinearDependence::temperature;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Simpler,
+                                   "simpler",
+                                   "A material model that has constant values "
+                                   "except for density, which depends linearly on temperature: "
+                                   "$ \\rho(p,T) = \\left(1-\\alpha (T-T_0)\\right)\\rho_0.$ "
+                                   "\n\n"
+                                   "Note that this material model fills the role the ``simple'' material "
+                                   "model was originally intended to fill, before the latter acquired "
+                                   "all sorts of complicated temperature and compositional dependencies. ")
+  }
+}
diff --git a/source/material_model/steinberger.cc.bak b/source/material_model/steinberger.cc.bak
new file mode 100644
index 00000000000..061f7c649e3
--- /dev/null
+++ b/source/material_model/steinberger.cc.bak
@@ -0,0 +1,631 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/steinberger.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/utilities.h>
+#include <aspect/lateral_averaging.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/table.h>
+#include <memory>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace internal
+    {
+      LateralViscosityLookup::LateralViscosityLookup(const std::string &filename,
+                                                     const MPI_Comm comm)
+      {
+        std::string temp;
+        // Read data from disk and distribute among processes
+        std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
+
+        std::getline(in, temp); // eat first line
+
+        min_depth=1e20;
+        max_depth=-1;
+
+        while (!in.eof())
+          {
+            double visc, depth;
+            in >> visc;
+            if (in.eof())
+              break;
+            in >> depth;
+            depth *=1000.0;
+            std::getline(in, temp);
+
+            min_depth = std::min(depth, min_depth);
+            max_depth = std::max(depth, max_depth);
+
+            values.push_back(visc);
+          }
+        delta_depth = (max_depth-min_depth)/(values.size()-1);
+      }
+
+      double LateralViscosityLookup::lateral_viscosity(double depth) const
+      {
+        depth=std::max(min_depth, depth);
+        depth=std::min(depth, max_depth);
+
+        Assert(depth>=min_depth, ExcMessage("ASPECT found a depth less than min_depth."));
+        Assert(depth<=max_depth, ExcMessage("ASPECT found a depth greater than max_depth."));
+        const unsigned int idx = static_cast<unsigned int>((depth-min_depth)/delta_depth);
+        Assert(idx<values.size(), ExcMessage("Attempting to look up a depth with an index that would be out of range. (depth-min_depth)/delta_depth too large."));
+        return values[idx];
+      }
+
+      int LateralViscosityLookup::get_nslices() const
+      {
+        return values.size();
+      }
+
+      RadialViscosityLookup::RadialViscosityLookup(const std::string &filename,
+                                                   const MPI_Comm comm)
+      {
+        std::string temp;
+        // Read data from disk and distribute among processes
+        std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
+
+        min_depth=1e20;
+        max_depth=-1;
+
+        while (!in.eof())
+          {
+            double visc, depth;
+            in >> visc;
+            if (in.eof())
+              break;
+            in >> depth;
+            depth *=1000.0;
+            std::getline(in, temp);
+
+            min_depth = std::min(depth, min_depth);
+            max_depth = std::max(depth, max_depth);
+
+            values.push_back(visc);
+          }
+        delta_depth = (max_depth-min_depth)/(values.size()-1);
+      }
+
+      double RadialViscosityLookup::radial_viscosity(double depth) const
+      {
+        depth=std::max(min_depth, depth);
+        depth=std::min(depth, max_depth);
+
+        Assert(depth>=min_depth, ExcMessage("ASPECT found a depth less than min_depth."));
+        Assert(depth<=max_depth, ExcMessage("ASPECT found a depth greater than max_depth."));
+        const unsigned int idx = static_cast<unsigned int>((depth-min_depth)/delta_depth);
+        Assert(idx<values.size(), ExcMessage("Attempting to look up a depth with an index that would be out of range. (depth-min_depth)/delta_depth too large."));
+        return values[idx];
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    Steinberger<dim>::initialize()
+    {
+      equation_of_state.initialize();
+
+      lateral_viscosity_lookup
+        = std::make_unique<internal::LateralViscosityLookup>(data_directory+lateral_viscosity_file_name,
+                                                             this->get_mpi_communicator());
+      radial_viscosity_lookup
+        = std::make_unique<internal::RadialViscosityLookup>(data_directory+radial_viscosity_file_name,
+                                                            this->get_mpi_communicator());
+      average_temperature.resize(n_lateral_slices);
+    }
+
+
+
+    template <int dim>
+    void
+    Steinberger<dim>::
+    update()
+    {
+      if (use_lateral_average_temperature)
+        {
+          this->get_lateral_averaging().get_temperature_averages(average_temperature);
+          for (double temperature : average_temperature)
+            AssertThrow(numbers::is_finite(temperature),
+                        ExcMessage("In computing depth averages, there is at"
+                                   " least one depth band that does not have"
+                                   " any quadrature points in it."
+                                   " Consider reducing number of depth layers"
+                                   " for averaging specified in the parameter"
+                                   " file.(Number lateral average bands)"));
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    Steinberger<dim>::
+    viscosity (const double temperature,
+               const double /*pressure*/,
+               const std::vector<double> &volume_fractions,
+               const SymmetricTensor<2,dim> &,
+               const Point<dim> &position) const
+    {
+      const double depth = this->get_geometry_model().depth(position);
+      const double adiabatic_temperature = this->get_adiabatic_conditions().temperature(position);
+
+      double delta_temperature;
+      if (use_lateral_average_temperature)
+        {
+          const unsigned int idx = static_cast<unsigned int>((average_temperature.size()-1) * depth / this->get_geometry_model().maximal_depth());
+          delta_temperature = temperature-average_temperature[idx];
+        }
+      else
+        delta_temperature = temperature-adiabatic_temperature;
+
+      // For an explanation on this formula see the Steinberger & Calderwood 2006 paper
+      // We here compute the lateral variation of viscosity due to temperature (thermal_prefactor) as
+      // V_lT = exp [-(H/nR)*dT/(T_adiabatic*(T_adiabatic + dT))] as in Eq. 6 of the paper.
+      // We get H/nR from the lateral_viscosity_lookup->lateral_viscosity function.
+      const double log_thermal_prefactor = -1.0 * lateral_viscosity_lookup->lateral_viscosity(depth) * delta_temperature / (temperature * adiabatic_temperature);
+
+      // Limit the lateral viscosity variation to a reasonable interval
+      const double thermal_prefactor = std::max(std::min(std::exp(log_thermal_prefactor), max_lateral_eta_variation), 1/max_lateral_eta_variation);
+
+      const double compositional_prefactor = MaterialUtilities::average_value (volume_fractions, viscosity_prefactors, viscosity_averaging_scheme);
+
+      // Visc_rT = exp[(H/nR)/T_adiabatic], Eq. 7 of the paper
+      const double eta_ref = radial_viscosity_lookup->radial_viscosity(depth);
+
+      // Radial viscosity profile is multiplied by thermal and compositional prefactors
+      return std::max(std::min(thermal_prefactor * compositional_prefactor * eta_ref, max_eta), min_eta);
+    }
+
+
+
+    template <int dim>
+    bool
+    Steinberger<dim>::
+    is_compressible () const
+    {
+      return equation_of_state.is_compressible();
+    }
+
+
+
+    template <int dim>
+    double
+    Steinberger<dim>::
+    thermal_conductivity (const double temperature,
+                          const double pressure,
+                          const Point<dim> &position) const
+    {
+      if (conductivity_formulation == constant)
+        return thermal_conductivity_value;
+
+      else if (conductivity_formulation == p_T_dependent)
+        {
+          // Find the conductivity layer that corresponds to the depth of the evaluation point.
+          const double depth = this->get_geometry_model().depth(position);
+          unsigned int layer_index = std::distance(conductivity_transition_depths.begin(),
+                                                   std::lower_bound(conductivity_transition_depths.begin(),conductivity_transition_depths.end(), depth));
+
+          const double p_dependence = reference_thermal_conductivities[layer_index] + conductivity_pressure_dependencies[layer_index] * pressure;
+
+          // Make reasonably sure we will not compute any invalid values due to the temperature-dependence.
+          // Since both the temperature-dependence and the saturation term scale with (Tref/T), we have to
+          // make sure we can compute the square of this number. If the temperature is small enough to
+          // be close to yielding NaN values, the conductivity will be set to the maximum value anyway.
+          const double T = std::max(temperature, std::sqrt(std::numeric_limits<double>::min()) * conductivity_reference_temperatures[layer_index]);
+          const double T_dependence = std::pow(conductivity_reference_temperatures[layer_index] / T, conductivity_exponents[layer_index]);
+
+          // Function based on the theory of Roufosse and Klemens (1974) that accounts for saturation.
+          // For the Tosi formulation, the scaling should be zero so that this term is 1.
+          double saturation_function = 1.0;
+          if (1./T_dependence > 1.)
+            saturation_function = (1. - saturation_scaling[layer_index])
+                                  + saturation_scaling[layer_index] * (2./3. * std::sqrt(T_dependence) + 1./3. * 1./T_dependence);
+
+          return std::min(p_dependence * saturation_function * T_dependence, maximum_conductivity);
+        }
+      else
+        {
+          AssertThrow(false, ExcNotImplemented());
+          return numbers::signaling_nan<double>();
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Steinberger<dim>::evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                               MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      std::vector<EquationOfStateOutputs<dim>> eos_outputs (in.n_evaluation_points(), equation_of_state.number_of_lookups());
+      std::vector<std::vector<double>> volume_fractions (in.n_evaluation_points(), std::vector<double> (equation_of_state.number_of_lookups()));
+
+      // We need to make a copy of the material model inputs because we want to use the adiabatic pressure
+      // rather than the real pressure for the equations of state (to avoid numerical instabilities).
+      MaterialModel::MaterialModelInputs<dim> eos_in(in);
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        eos_in.pressure[i] = this->get_adiabatic_conditions().pressure(in.position[i]);
+
+      // Evaluate the equation of state properties over all evaluation points
+      equation_of_state.evaluate(eos_in, eos_outputs);
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          out.thermal_conductivities[i] = thermal_conductivity(in.temperature[i], in.pressure[i], in.position[i]);
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0;
+
+          // Calculate volume fractions from mass fractions
+          // If there is only one lookup table, set the mass and volume fractions to 1
+          std::vector<double> mass_fractions;
+          if (equation_of_state.number_of_lookups() == 1)
+            mass_fractions.push_back(1.0);
+          else
+            {
+              // We only want to compute mass/volume fractions for fields that are chemical compositions.
+              mass_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[i],
+                                                                                     this->introspection().chemical_composition_field_indices());
+
+              // The function compute_volumes_from_masses expects as many mass_fractions as densities.
+              // But the function compute_composition_fractions always adds another element at the start
+              // of the vector that represents the background field. If there is no lookup table for
+              // the background field, the mass_fractions vector is too long and we remove this element.
+              if (!has_background_field)
+                mass_fractions.erase(mass_fractions.begin());
+            }
+
+          volume_fractions[i] = MaterialUtilities::compute_volumes_from_masses(mass_fractions,
+                                                                               eos_outputs[i].densities,
+                                                                               true);
+
+          if (in.requests_property(MaterialProperties::viscosity))
+            out.viscosities[i] = viscosity(in.temperature[i], in.pressure[i], volume_fractions[i], in.strain_rate[i], in.position[i]);
+
+          MaterialUtilities::fill_averaged_equation_of_state_outputs(eos_outputs[i], mass_fractions, volume_fractions[i], i, out);
+          fill_prescribed_outputs(i, volume_fractions[i], in, out);
+        }
+
+      // fill additional outputs if they exist
+      equation_of_state.fill_additional_outputs(in, volume_fractions, out);
+    }
+
+
+
+    template <int dim>
+    void
+    Steinberger<dim>::
+    fill_prescribed_outputs(const unsigned int q,
+                            const std::vector<double> &,
+                            const MaterialModel::MaterialModelInputs<dim> &,
+                            MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // set up variable to interpolate prescribed field outputs onto compositional field
+      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
+
+      if (this->introspection().composition_type_exists(CompositionalFieldDescription::density)
+          && prescribed_field_out != nullptr)
+        {
+          const unsigned int projected_density_index = this->introspection().find_composition_type(CompositionalFieldDescription::density);
+          prescribed_field_out->prescribed_field_outputs[q][projected_density_index] = out.densities[q];
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Steinberger<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Steinberger model");
+        {
+          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/steinberger/",
+                             Patterns::DirectoryName (),
+                             "The path to the model data. The path may also include the special "
+                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                             "in which the ASPECT source files were located when ASPECT was "
+                             "compiled. This interpretation allows, for example, to reference "
+                             "files located in the `data/' subdirectory of ASPECT. ");
+          prm.declare_entry ("Radial viscosity file name", "radial-visc.txt",
+                             Patterns::Anything (),
+                             "The file name of the radial viscosity data. ");
+          prm.declare_entry ("Lateral viscosity file name", "temp-viscosity-prefactor.txt",
+                             Patterns::Anything (),
+                             "The file name of the lateral viscosity data. ");
+          prm.declare_entry ("Use lateral average temperature for viscosity", "true",
+                             Patterns::Bool (),
+                             "Whether to use the laterally averaged temperature "
+                             "instead of the adiabatic temperature as reference for the "
+                             "viscosity calculation. This ensures that the laterally averaged "
+                             "viscosities remain more or less constant over the model "
+                             "runtime. This behavior might or might not be desired.");
+          prm.declare_entry ("Number lateral average bands", "10",
+                             Patterns::Integer (1),
+                             "Number of bands to compute laterally averaged temperature within.");
+          prm.declare_entry ("Minimum viscosity", "1e19",
+                             Patterns::Double (0.),
+                             "The minimum viscosity that is allowed in the viscosity "
+                             "calculation. Smaller values will be cut off.");
+          prm.declare_entry ("Maximum viscosity", "1e23",
+                             Patterns::Double (0.),
+                             "The maximum viscosity that is allowed in the viscosity "
+                             "calculation. Larger values will be cut off.");
+          prm.declare_entry ("Maximum lateral viscosity variation", "1e2",
+                             Patterns::Double (0.),
+                             "The relative cutoff value for lateral viscosity variations "
+                             "caused by temperature deviations. The viscosity may vary "
+                             "laterally by this factor squared.");
+          prm.declare_entry ("Composition viscosity prefactors", "1",
+                             Patterns::Anything (),
+                             "List of N prefactors that are used to modify the reference viscosity, "
+                             "where N is either equal to one or the number of chemical components "
+                             "in the simulation. If only one value is given, then all components "
+                             "use the same value. Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
+                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
+                             "Method to average viscosities over multiple compositional fields. "
+                             "One of arithmetic, harmonic, geometric or maximum composition.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0.),
+                             "The value of the thermal conductivity $k$. Only used in case "
+                             "the 'constant' Thermal conductivity formulation is selected. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Thermal conductivity formulation", "constant",
+                             Patterns::Selection("constant|p-T-dependent"),
+                             "Which law should be used to compute the thermal conductivity. "
+                             "The 'constant' law uses a constant value for the thermal "
+                             "conductivity. The 'p-T-dependent' formulation uses equations "
+                             "from Stackhouse et al. (2015): First-principles calculations "
+                             "of the lattice thermal conductivity of the lower mantle "
+                             "(https://doi.org/10.1016/j.epsl.2015.06.050), and Tosi et al. "
+                             "(2013): Mantle dynamics with pressure- and temperature-dependent "
+                             "thermal expansivity and conductivity "
+                             "(https://doi.org/10.1016/j.pepi.2013.02.004) to compute the "
+                             "thermal conductivity in dependence of temperature and pressure. "
+                             "The thermal conductivity parameter sets can be chosen in such a "
+                             "way that either the Stackhouse or the Tosi relations are used. "
+                             "The conductivity description can consist of several layers with "
+                             "different sets of parameters. Note that the Stackhouse "
+                             "parametrization is only valid for the lower mantle (bridgmanite).");
+          prm.declare_entry ("Thermal conductivity transition depths", "410000, 520000, 660000",
+                             Patterns::List(Patterns::Double (0.)),
+                             "A list of depth values that indicate where the transitions between "
+                             "the different conductivity parameter sets should occur in the "
+                             "'p-T-dependent' Thermal conductivity formulation (in most cases, "
+                             "this will be the depths of major mantle phase transitions). "
+                             "Units: \\si{\\meter}.");
+          prm.declare_entry ("Reference thermal conductivities", "2.47, 3.81, 3.52, 4.9",
+                             Patterns::List(Patterns::Double (0.)),
+                             "A list of base values of the thermal conductivity for each of the "
+                             "horizontal layers in the 'p-T-dependent' Thermal conductivity "
+                             "formulation. Pressure- and temperature-dependence will be applied"
+                             "on top of this base value, according to the parameters 'Pressure "
+                             "dependencies of thermal conductivity' and 'Reference temperatures "
+                             "for thermal conductivity'. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}");
+          prm.declare_entry ("Pressure dependencies of thermal conductivity", "3.3e-10, 3.4e-10, 3.6e-10, 1.05e-10",
+                             Patterns::List(Patterns::Double ()),
+                             "A list of values that determine the linear scaling of the "
+                             "thermal conductivity with the pressure in the 'p-T-dependent' "
+                             "Thermal conductivity formulation. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin\\per\\pascal}.");
+          prm.declare_entry ("Reference temperatures for thermal conductivity", "300, 300, 300, 1200",
+                             Patterns::List(Patterns::Double (0.)),
+                             "A list of values of reference temperatures used to determine "
+                             "the temperature-dependence of the thermal conductivity in the "
+                             "'p-T-dependent' Thermal conductivity formulation. "
+                             "Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Thermal conductivity exponents", "0.48, 0.56, 0.61, 1.0",
+                             Patterns::List(Patterns::Double (0.)),
+                             "A list of exponents in the temperature-dependent term of the "
+                             "'p-T-dependent' Thermal conductivity formulation. Note that this "
+                             "exponent is not used (and should have a value of 1) in the "
+                             "formulation of Stackhouse et al. (2015). "
+                             "Units: none.");
+          prm.declare_entry ("Saturation prefactors", "0, 0, 0, 1",
+                             Patterns::List(Patterns::Double (0., 1.)),
+                             "A list of values that indicate how a given layer in the "
+                             "conductivity formulation should take into account the effects "
+                             "of saturation on the temperature-dependence of the thermal "
+                             "conducitivity. This factor is multiplied with a saturation function "
+                             "based on the theory of Roufosse and Klemens, 1974. A value of 1 "
+                             "reproduces the formulation of Stackhouse et al. (2015), a value of "
+                             "0 reproduces the formulation of Tosi et al., (2013). "
+                             "Units: none.");
+          prm.declare_entry ("Maximum thermal conductivity", "1000",
+                             Patterns::Double (0.),
+                             "The maximum thermal conductivity that is allowed in the "
+                             "model. Larger values will be cut off.");
+
+          // Table lookup parameters
+          EquationOfState::ThermodynamicTableLookup<dim>::declare_parameters(prm);
+
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    Steinberger<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Steinberger model");
+        {
+          data_directory                  = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+          radial_viscosity_file_name      = prm.get ("Radial viscosity file name");
+          lateral_viscosity_file_name     = prm.get ("Lateral viscosity file name");
+          use_lateral_average_temperature = prm.get_bool ("Use lateral average temperature for viscosity");
+          n_lateral_slices                = prm.get_integer("Number lateral average bands");
+          min_eta                         = prm.get_double ("Minimum viscosity");
+          max_eta                         = prm.get_double ("Maximum viscosity");
+          max_lateral_eta_variation       = prm.get_double ("Maximum lateral viscosity variation");
+          viscosity_averaging_scheme      = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
+                                            prm);
+          thermal_conductivity_value      = prm.get_double ("Thermal conductivity");
+
+          // Rheological parameters
+          if (prm.get ("Thermal conductivity formulation") == "constant")
+            conductivity_formulation = constant;
+          else if (prm.get ("Thermal conductivity formulation") == "p-T-dependent")
+            conductivity_formulation = p_T_dependent;
+          else
+            AssertThrow(false, ExcMessage("Not a valid thermal conductivity formulation"));
+
+          conductivity_transition_depths = Utilities::string_to_double
+                                           (Utilities::split_string_list(prm.get ("Thermal conductivity transition depths")));
+          const unsigned int n_conductivity_layers = conductivity_transition_depths.size() + 1;
+
+          AssertThrow (std::is_sorted(conductivity_transition_depths.begin(), conductivity_transition_depths.end()),
+                       ExcMessage("The list of 'Thermal conductivity transition depths' must "
+                                  "be sorted such that the values increase monotonically."));
+
+          reference_thermal_conductivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Reference thermal conductivities"))),
+                                                                                     n_conductivity_layers,
+                                                                                     "Reference thermal conductivities");
+          conductivity_pressure_dependencies = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Pressure dependencies of thermal conductivity"))),
+                                                                                       n_conductivity_layers,
+                                                                                       "Pressure dependencies of thermal conductivity");
+          conductivity_reference_temperatures = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Reference temperatures for thermal conductivity"))),
+                                                                                        n_conductivity_layers,
+                                                                                        "Reference temperatures for thermal conductivity");
+          conductivity_exponents = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal conductivity exponents"))),
+                                                                           n_conductivity_layers,
+                                                                           "Thermal conductivity exponents");
+          saturation_scaling = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Saturation prefactors"))),
+                                                                       n_conductivity_layers,
+                                                                       "Saturation prefactors");
+          maximum_conductivity = prm.get_double ("Maximum thermal conductivity");
+
+          // Parse the table lookup parameters
+          equation_of_state.initialize_simulator (this->get_simulator());
+          equation_of_state.parse_parameters(prm);
+
+          // Assign background field and do some error checking
+          const unsigned int n_chemical_composition_fields = this->introspection().get_number_of_fields_of_type(CompositionalFieldDescription::chemical_composition);
+          has_background_field = ((equation_of_state.number_of_lookups() == 1) ||
+                                  (equation_of_state.number_of_lookups() == n_chemical_composition_fields + 1));
+          AssertThrow ((equation_of_state.number_of_lookups() == 1) ||
+                       (equation_of_state.number_of_lookups() == n_chemical_composition_fields) ||
+                       (equation_of_state.number_of_lookups() == n_chemical_composition_fields + 1),
+                       ExcMessage("The Steinberger material model assumes that either there is a single material "
+                                  "in the simulation, or that all compositional fields of the type "
+                                  "chemical composition correspond to mass fractions of different materials. "
+                                  "There must either be one material lookup file, the same number of "
+                                  "material lookup files as compositional fields of type chemical composition, "
+                                  "or one additional file (if a background field is used). You have "
+                                  + Utilities::int_to_string(equation_of_state.number_of_lookups())
+                                  + " material data files, but there are "
+                                  + Utilities::int_to_string(n_chemical_composition_fields)
+                                  + " fields of type chemical composition."));
+
+          // Parse the Composition viscosity prefactors parameter
+          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+
+          // If there is only one lookup, the list of Viscosity prefactors should have length one.
+          // The following if statement applies when defined fields of type chemical composition
+          // are not intended to be used as volume fractions of distinct materials.
+          if (equation_of_state.number_of_lookups() == 1)
+            {
+              chemical_field_names.clear();
+              compositional_field_names.clear();
+            }
+
+          if (has_background_field)
+            {
+              chemical_field_names.insert(chemical_field_names.begin(),"background");
+              compositional_field_names.insert(compositional_field_names.begin(),"background");
+            }
+
+          Utilities::MapParsing::Options options(chemical_field_names, "Composition viscosity prefactors");
+          options.list_of_allowed_keys = compositional_field_names;
+          viscosity_prefactors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Composition viscosity prefactors"), options);
+
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+
+        // Declare dependencies on solution variables
+        this->model_dependence.viscosity = NonlinearDependence::temperature;
+        this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+        this->model_dependence.compressibility = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+        this->model_dependence.specific_heat = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+        this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    Steinberger<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      equation_of_state.create_additional_named_outputs(out);
+
+      if (this->introspection().composition_type_exists(CompositionalFieldDescription::density)
+          && out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points, this->n_compositional_fields()));
+        }
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Steinberger,
+                                   "Steinberger",
+                                   "This material model looks up the viscosity from the tables that "
+                                   "correspond to the paper of Steinberger and Calderwood "
+                                   "2006 (``Models of large-scale viscous flow in the Earth's "
+                                   "mantle with constraints from mineral physics and surface observations'', "
+                                   "Geophys. J. Int., 167, 1461-1481, "
+                                   "<http://dx.doi.org/10.1111/j.1365-246X.2006.03131.x>) and material "
+                                   "data from a database generated by the thermodynamics code \\texttt{Perplex}, "
+                                   "see <http://www.perplex.ethz.ch/>. "
+                                   "The default example data builds upon the thermodynamic "
+                                   "database by Stixrude 2011 and assumes a pyrolitic composition by "
+                                   "Ringwood 1988 but is easily replaceable by other data files. ")
+  }
+}
diff --git a/source/material_model/utilities.cc.bak b/source/material_model/utilities.cc.bak
new file mode 100644
index 00000000000..2c426e215c6
--- /dev/null
+++ b/source/material_model/utilities.cc.bak
@@ -0,0 +1,1546 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+#include <aspect/structured_data.h>
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/gravity_model/interface.h>
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/equation_of_state/interface.h>
+#include <aspect/material_model/utilities.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/exceptions.h>
+#include <boost/lexical_cast.hpp>
+#include <list>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace MaterialUtilities
+    {
+      namespace Lookup
+      {
+        double
+        MaterialLookup::specific_heat(const double temperature,
+                                      const double pressure) const
+        {
+          return value(temperature,pressure,specific_heat_values,interpolation);
+        }
+
+        double
+        MaterialLookup::density(const double temperature,
+                                const double pressure) const
+        {
+          return value(temperature,pressure,density_values,interpolation);
+        }
+
+        double
+        MaterialLookup::thermal_expansivity(const double temperature,
+                                            const double pressure) const
+        {
+          return value(temperature,pressure,thermal_expansivity_values,interpolation);
+        }
+
+        double
+        MaterialLookup::seismic_Vp(const double temperature,
+                                   const double pressure) const
+        {
+          return value(temperature,pressure,vp_values,false);
+        }
+
+        double
+        MaterialLookup::seismic_Vs(const double temperature,
+                                   const double pressure) const
+        {
+          return value(temperature,pressure,vs_values,false);
+        }
+
+        double
+        MaterialLookup::enthalpy(const double temperature,
+                                 const double pressure) const
+        {
+          return value(temperature,pressure,enthalpy_values,true);
+        }
+
+        double
+        MaterialLookup::dHdT (const double temperature,
+                              const double pressure) const
+        {
+          const double h = value(temperature,pressure,enthalpy_values,interpolation);
+          const double dh = value(temperature+delta_temp,pressure,enthalpy_values,interpolation);
+          return (dh - h) / delta_temp;
+        }
+
+        double
+        MaterialLookup::dHdp (const double temperature,
+                              const double pressure) const
+        {
+          const double h = value(temperature,pressure,enthalpy_values,interpolation);
+          const double dh = value(temperature,pressure+delta_press,enthalpy_values,interpolation);
+          return (dh - h) / delta_press;
+        }
+
+        std::array<std::pair<double, unsigned int>,2>
+        MaterialLookup::enthalpy_derivatives(const std::vector<double> &temperatures,
+                                             const std::vector<double> &pressures,
+                                             const unsigned int n_substeps) const
+        {
+          Assert(temperatures.size() == pressures.size(),ExcInternalError());
+          const unsigned int n_q_points = temperatures.size();
+          unsigned int n_T(0), n_p(0);
+          double dHdT(0.0), dHdp(0.0);
+
+          for (unsigned int q=0; q<n_q_points; ++q)
+            {
+              for (unsigned int p=0; p<n_q_points; ++p)
+                {
+                  if (std::fabs(temperatures[q] - temperatures[p]) > 100.0 * std::numeric_limits<double>::epsilon() * std::fabs(temperatures[q] + std::numeric_limits<double>::epsilon()))
+                    {
+                      for (unsigned int substep = 0; substep < n_substeps; ++substep)
+                        {
+                          const double step_ratio = static_cast<double>(substep)/static_cast<double>(n_substeps);
+                          const double step_ratio_next = static_cast<double>(substep+1)/static_cast<double>(n_substeps);
+
+                          const double current_pressure = pressures[q]
+                                                          + step_ratio
+                                                          * (pressures[p]-pressures[q]);
+                          const double T1_substep = temperatures[q]
+                                                    + step_ratio
+                                                    * (temperatures[p]-temperatures[q]);
+                          const double T2_substep = temperatures[q]
+                                                    + step_ratio_next
+                                                    * (temperatures[p]-temperatures[q]);
+                          const double enthalpy2 = enthalpy(T2_substep,current_pressure);
+                          const double enthalpy1 = enthalpy(T1_substep,current_pressure);
+                          dHdT += (enthalpy2-enthalpy1)/(T2_substep-T1_substep);
+                          ++n_T;
+                        }
+                    }
+                  if (std::fabs(pressures[q] - pressures[p]) > 100.0 * std::numeric_limits<double>::epsilon() * std::fabs(pressures[q] + std::numeric_limits<double>::epsilon()))
+                    {
+                      for (unsigned int substep = 0; substep < n_substeps; ++substep)
+                        {
+                          const double step_ratio = static_cast<double>(substep)/static_cast<double>(n_substeps);
+                          const double step_ratio_next = static_cast<double>(substep+1)/static_cast<double>(n_substeps);
+                          const double current_temperature = temperatures[q]
+                                                             + step_ratio
+                                                             * (temperatures[p]-temperatures[q]);
+                          const double p1_substep = pressures[q]
+                                                    + step_ratio
+                                                    * (pressures[p]-pressures[q]);
+                          const double p2_substep = pressures[q]
+                                                    + step_ratio_next
+                                                    * (pressures[p]-pressures[q]);
+                          const double enthalpy2 = enthalpy(current_temperature,p2_substep);
+                          const double enthalpy1 = enthalpy(current_temperature,p1_substep);
+                          dHdp += (enthalpy2-enthalpy1)/(p2_substep-p1_substep);
+                          ++n_p;
+                        }
+                    }
+                }
+            }
+
+          if ((n_T > 0)
+              && (n_p > 0))
+            {
+              dHdT /= n_T;
+              dHdp /= n_p;
+            }
+
+          std::array<std::pair<double, unsigned int>,2> derivatives;
+          derivatives[0] = std::make_pair(dHdT,n_T);
+          derivatives[1] = std::make_pair(dHdp,n_p);
+          return derivatives;
+        }
+
+        double
+        MaterialLookup::dRhodp (const double temperature,
+                                const double pressure) const
+        {
+          const double rho = value(temperature,pressure,density_values,interpolation);
+          const double drho = value(temperature,pressure+delta_press,density_values,interpolation);
+          return (drho - rho) / delta_press;
+        }
+
+        unsigned int
+        MaterialLookup::dominant_phase (const double temperature,
+                                        const double pressure) const
+        {
+          if (!has_dominant_phase_column)
+            AssertThrow(false, ExcMessage("You can not ask for the column with the dominant phase if it does not exist in the data file."));
+          return value(temperature, pressure, dominant_phase_indices);
+        }
+
+        bool
+        MaterialLookup::has_dominant_phase() const
+        {
+          return has_dominant_phase_column;
+        }
+
+        std::vector<std::string>
+        MaterialLookup::phase_volume_column_names() const
+        {
+          return phase_column_names;
+        }
+
+        double
+        MaterialLookup::phase_volume_fraction(const int phase_id,
+                                              const double temperature,
+                                              const double pressure) const
+        {
+          return value(temperature,pressure,phase_volume_fractions[phase_id],interpolation);
+        }
+
+
+        const std::vector<std::string> &
+        MaterialLookup::get_dominant_phase_names() const
+        {
+          return dominant_phase_names;
+        }
+
+        double
+        MaterialLookup::value (const double temperature,
+                               const double pressure,
+                               const Table<2, double> &values,
+                               const bool interpol) const
+        {
+          const double nT = get_nT(temperature);
+          const unsigned int inT = static_cast<unsigned int>(nT);
+
+          const double np = get_np(pressure);
+          const unsigned int inp = static_cast<unsigned int>(np);
+
+          Assert(inT<values.n_rows(), ExcMessage("Attempting to look up a temperature value with index greater than the number of rows."));
+          Assert(inp<values.n_cols(), ExcMessage("Attempting to look up a pressure value with index greater than the number of columns."));
+
+          if (!interpol)
+            return values[inT][inp];
+          else
+            {
+              // compute the coordinates of this point in the
+              // reference cell between the data points
+              const double xi = nT-inT;
+              const double eta = np-inp;
+
+              Assert ((0 <= xi) && (xi <= 1), ExcInternalError());
+              Assert ((0 <= eta) && (eta <= 1), ExcInternalError());
+
+              // use these coordinates for a bilinear interpolation
+              return ((1-xi)*(1-eta)*values[inT][inp] +
+                      xi    *(1-eta)*values[inT+1][inp] +
+                      (1-xi)*eta    *values[inT][inp+1] +
+                      xi    *eta    *values[inT+1][inp+1]);
+            }
+        }
+
+        unsigned int
+        MaterialLookup::value (const double temperature,
+                               const double pressure,
+                               const Table<2, unsigned int> &values) const
+        {
+          const double nT = get_nT(temperature);
+          const unsigned int inT = static_cast<unsigned int>(nT);
+
+          const double np = get_np(pressure);
+          const unsigned int inp = static_cast<unsigned int>(np);
+
+          Assert(inT<values.n_rows(), ExcMessage("Attempting to look up a temperature value with index greater than the number of rows."));
+          Assert(inp<values.n_cols(), ExcMessage("Attempting to look up a pressure value with index greater than the number of columns."));
+
+          return values[inT][inp];
+        }
+
+        std::array<double,2>
+        MaterialLookup::get_pT_steps() const
+        {
+          std::array<double,2> pt_steps;
+          pt_steps[0] = delta_press;
+          pt_steps[1] = delta_temp;
+          return pt_steps;
+        }
+
+        double
+        MaterialLookup::get_nT(const double temperature) const
+        {
+          double bounded_temperature=std::max(min_temp, temperature);
+          bounded_temperature=std::min(bounded_temperature, max_temp-delta_temp);
+
+          return (bounded_temperature-min_temp)/delta_temp;
+        }
+
+        double
+        MaterialLookup::get_np(const double pressure) const
+        {
+          double bounded_pressure=std::max(min_press, pressure);
+          bounded_pressure=std::min(bounded_pressure, max_press-delta_press);
+
+          return (bounded_pressure-min_press)/delta_press;
+        }
+
+        HeFESToReader::HeFESToReader(const std::string &material_filename,
+                                     const std::string &derivatives_filename,
+                                     const bool interpol,
+                                     const MPI_Comm comm)
+        {
+          /* Initializing variables */
+          interpolation = interpol;
+          delta_press=numbers::signaling_nan<double>();
+          min_press=std::numeric_limits<double>::max();
+          max_press=std::numeric_limits<double>::lowest();
+          delta_temp=numbers::signaling_nan<double>();
+          min_temp=std::numeric_limits<double>::max();
+          max_temp=std::numeric_limits<double>::lowest();
+          n_temperature=0;
+          n_pressure=0;
+
+          std::string temp;
+
+          // Read material data
+          {
+            // Read data from disk and distribute among processes
+            std::istringstream in(Utilities::read_and_distribute_file_content(material_filename, comm));
+
+            bool parsed_first_column = false;
+            unsigned int i = 0;
+            double current_pressure = 0.0;
+            double old_pressure = -1.0;
+            while (!in.eof())
+              {
+                in >> current_pressure;
+                if (in.fail())
+                  {
+                    in.clear();
+                  }
+
+                if (!parsed_first_column)
+                  {
+                    if (current_pressure > old_pressure)
+                      old_pressure = current_pressure;
+                    else if (current_pressure <= old_pressure)
+                      {
+                        n_pressure = i;
+                        parsed_first_column = true;
+                      }
+                  }
+
+                std::getline(in, temp);
+                if (in.eof())
+                  break;
+                ++i;
+              }
+
+            in.clear();
+            in.seekg (0, in.beg);
+
+            n_temperature = i / n_pressure;
+
+            Assert(i == n_temperature * n_pressure,
+                   ExcMessage("Material table size not consistent."));
+
+            density_values.reinit(n_temperature,n_pressure);
+            thermal_expansivity_values.reinit(n_temperature,n_pressure);
+            specific_heat_values.reinit(n_temperature,n_pressure);
+            vp_values.reinit(n_temperature,n_pressure);
+            vs_values.reinit(n_temperature,n_pressure);
+            enthalpy_values.reinit(n_temperature,n_pressure);
+
+            i = 0;
+            while (!in.eof())
+              {
+                double P = 0.0;
+                double depth,T;
+                double rho,vb,vs,vp,vsq,vpq,h;
+                std::string code;
+                double alpha = 0.0;
+                double cp = 0.0;
+
+                in >> P >> depth >> T;
+                if (in.fail())
+                  in.clear();
+                // conversion from [GPa] to [Pa]
+                P *= 1e9;
+
+                min_press=std::min(P,min_press);
+                min_temp=std::min(T,min_temp);
+                max_temp = std::max(T,max_temp);
+                max_press = std::max(P,max_press);
+
+                in >> rho;
+                if (in.fail())
+                  {
+                    in.clear();
+                    rho = density_values[(i-1)%n_temperature][(i-1)/n_temperature];
+                  }
+                else
+                  rho *= 1e3; // conversion from [g/cm^3] to [kg/m^3]
+
+                in >> vb;
+                if (in.fail())
+                  in.clear();
+
+                in >> vs;
+                if (in.fail())
+                  {
+                    in.clear();
+                    vs = vs_values[(i-1)%n_temperature][(i-1)/n_temperature];
+                  }
+                in >> vp;
+                if (in.fail())
+                  {
+                    in.clear();
+                    vp = vp_values[(i-1)%n_temperature][(i-1)/n_temperature];
+                  }
+                in >> vsq >> vpq;
+
+                in >> h;
+                if (in.fail())
+                  {
+                    in.clear();
+                    h = enthalpy_values[(i-1)%n_temperature][(i-1)/n_temperature];
+                  }
+                else
+                  h *= 1e6; // conversion from [kJ/g] to [J/kg]
+
+                std::getline(in, temp);
+                if (in.eof())
+                  break;
+
+                density_values[i/n_pressure][i%n_pressure]=rho;
+                thermal_expansivity_values[i/n_pressure][i%n_pressure]=alpha;
+                specific_heat_values[i/n_pressure][i%n_pressure]=cp;
+                vp_values[i/n_pressure][i%n_pressure]=vp;
+                vs_values[i/n_pressure][i%n_pressure]=vs;
+                enthalpy_values[i/n_pressure][i%n_pressure]=h;
+
+                ++i;
+              }
+
+            delta_temp = (max_temp - min_temp) / (n_temperature - 1);
+            delta_press = (max_press - min_press) / (n_pressure - 1);
+
+            AssertThrow(max_temp >= 0.0, ExcMessage("Read in of Material header failed (max_temp)."));
+            AssertThrow(delta_temp > 0, ExcMessage("Read in of Material header failed (delta_temp)."));
+            AssertThrow(n_temperature > 0, ExcMessage("Read in of Material header failed (numtemp)."));
+            AssertThrow(max_press >= 0, ExcMessage("Read in of Material header failed (max_press)."));
+            AssertThrow(delta_press > 0, ExcMessage("Read in of Material header failed (delta_press)."));
+            AssertThrow(n_pressure > 0, ExcMessage("Read in of Material header failed (numpress)."));
+          }
+
+          // If requested read derivative data
+          if (derivatives_filename != "")
+            {
+              std::string temp;
+              // Read data from disk and distribute among processes
+              std::istringstream in(Utilities::read_and_distribute_file_content(derivatives_filename, comm));
+
+              int i = 0;
+              while (!in.eof())
+                {
+                  double P = 0.0;
+                  double depth,T;
+                  double cp,alpha,alpha_eff;
+                  double temp1,temp2;
+
+                  in >> P >> depth >> T;
+                  if (in.fail())
+                    in.clear();
+
+
+                  in >> cp;
+                  if (in.fail() || (cp <= std::numeric_limits<double>::min()))
+                    {
+                      in.clear();
+                      cp = specific_heat_values[(i-1)%n_temperature][(i-1)/n_temperature];
+                    }
+                  else
+                    cp *= 1e3; // conversion from [J/g/K] to [J/kg/K]
+
+                  in >> alpha >> alpha_eff;
+                  if (in.fail() || (alpha_eff <= std::numeric_limits<double>::min()))
+                    {
+                      in.clear();
+                      alpha_eff = thermal_expansivity_values[(i-1)%n_temperature][(i-1)/n_temperature];
+                    }
+                  else
+                    {
+                      alpha *= 1e-5;
+                      alpha_eff *= 1e-5;
+                    }
+
+                  in >> temp1 >> temp2;
+                  if (in.fail())
+                    in.clear();
+
+
+                  std::getline(in, temp);
+                  if (in.eof())
+                    break;
+
+                  specific_heat_values[i/n_pressure][i%n_pressure]=cp;
+                  thermal_expansivity_values[i/n_pressure][i%n_pressure]=alpha_eff;
+
+                  ++i;
+                }
+            }
+        }
+
+        PerplexReader::PerplexReader(const std::string &filename,
+                                     const bool interpol,
+                                     const MPI_Comm comm)
+        {
+          /* Initializing variables */
+          interpolation = interpol;
+          delta_press=numbers::signaling_nan<double>();
+          min_press=std::numeric_limits<double>::max();
+          max_press=std::numeric_limits<double>::lowest();
+          delta_temp=numbers::signaling_nan<double>();
+          min_temp=std::numeric_limits<double>::max();
+          max_temp=std::numeric_limits<double>::lowest();
+          n_temperature=0;
+          n_pressure=0;
+          has_dominant_phase_column = false;
+
+          std::string temp;
+          // Read data from disk and distribute among processes
+          std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
+
+          // The following lines read in a PerpleX tab file in standard format
+          // The first 13 lines are a header in the format:
+          // |<perplex version>
+          // <table filename>
+          // <grid dim>
+          // <grid variable 1> (usually T(K) or P(bar))
+          // <min grid variable 1>
+          // <delta grid variable 1>
+          // <n steps grid variable 1>
+          // <grid variable 2> (usually T(K) or P(bar))
+          // <min grid variable 2>
+          // <delta grid variable 2>
+          // <n steps grid variable 2>
+          // Number of property columns in the table
+          // Column names
+
+          // First line is the Perplex version number
+          std::getline(in, temp); // get next line, table file name
+
+          std::getline(in, temp); // get next line, dimension of table
+          unsigned int n_variables;
+          in >> n_variables;
+          AssertThrow (n_variables==2, ExcMessage("The PerpleX file " + filename + " must be two dimensional (P(bar)-T(K))."));
+
+          std::getline(in, temp); // get next line, either T(K) or P(bar)
+
+          for (unsigned int i=0; i<2; ++i)
+            {
+              std::string natural_variable;
+              in >> natural_variable;
+
+              if (natural_variable == "T(K)")
+                {
+                  std::getline(in, temp);
+                  in >> min_temp;
+                  std::getline(in, temp);
+                  in >> delta_temp;
+                  std::getline(in, temp);
+                  in >> n_temperature;
+                  std::getline(in, temp); // get next line, either T(K), P(bar) or number of columns
+                }
+              else if (natural_variable == "P(bar)")
+                {
+                  std::getline(in, temp);
+                  in >> min_press;
+                  min_press *= 1e5;  // conversion from [bar] to [Pa]
+                  std::getline(in, temp);
+                  in >> delta_press;
+                  delta_press *= 1e5; // conversion from [bar] to [Pa]
+                  std::getline(in, temp);
+                  in >> n_pressure;
+                  std::getline(in, temp); // get next line, either T(K), P(bar) or number of columns
+                }
+              else
+                {
+                  AssertThrow (false, ExcMessage("The start of the PerpleX file " + filename + " does not have the expected format."));
+                }
+            }
+
+          in >> n_columns;
+          std::getline(in, temp); // get next line, column labels
+
+          // here we string match to assign properties to columns
+          // column i in text file -> column j in properties
+          // Properties are stored in the order rho, alpha, cp, vp, vs, h
+          std::vector<int> prp_indices(6, -1);
+          std::vector<int> phase_column_indices;
+          unsigned int dominant_phase_column_index = numbers::invalid_unsigned_int;
+
+          // First two columns should be P(bar) and T(K).
+          // Here we find the order.
+          std::string column_name;
+          in >> column_name;
+
+          std::string first_natural_variable;
+          if (column_name == "P(bar)")
+            {
+              first_natural_variable = column_name;
+              in >> column_name;
+              AssertThrow(column_name == "T(K)", ExcMessage("The second column name in PerpleX lookup file " + filename + " should be T(K)."));
+            }
+          else if (column_name == "T(K)")
+            {
+              first_natural_variable = column_name;
+              in >> column_name;
+              AssertThrow(column_name == "P(bar)", ExcMessage("The second column name in PerpleX lookup file " + filename + " should be P(bar)."));
+            }
+          else
+            {
+              AssertThrow(false, ExcMessage("The first column name in the PerpleX lookup file " + filename + " should be P(bar) or T(K)."));
+            }
+
+          for (unsigned int n=2; n<n_columns; ++n)
+            {
+              in >> column_name;
+              if (column_name == "rho,kg/m3")
+                prp_indices[0] = n;
+              else if (column_name == "alpha,1/K")
+                prp_indices[1] = n;
+              else if (column_name == "cp,J/K/kg")
+                prp_indices[2] = n;
+              else if (column_name == "vp,km/s")
+                prp_indices[3] = n;
+              else if (column_name == "vs,km/s")
+                prp_indices[4] = n;
+              else if (column_name == "h,J/kg")
+                prp_indices[5] = n;
+              else if (column_name == "phase")
+                {
+                  has_dominant_phase_column = true;
+                  dominant_phase_column_index = n;
+                }
+              else if (column_name.length() > 3)
+                {
+                  if (column_name.substr(0,13).compare("vol_fraction_") == 0)
+                    {
+                      if (std::find(phase_column_names.begin(),
+                                    phase_column_names.end(),
+                                    column_name) != phase_column_names.end())
+                        {
+                          AssertThrow(false,
+                                      ExcMessage("The PerpleX lookup file " + filename + " must have unique column names. "
+                                                 "Sometimes, the same phase is stable with >1 composition at the same "
+                                                 "pressure and temperature, so you may see several columns with the same name. "
+                                                 "Either combine columns with the same name, or change the names."));
+                        }
+                      // Populate phase_column_names with the column name
+                      // and phase_column_indices with the column index in the current lookup file.
+                      phase_column_indices.push_back(n);
+                      phase_column_names.push_back(column_name);
+                    }
+                }
+            }
+          AssertThrow(std::all_of(prp_indices.begin(), prp_indices.end(), [](int i)
+          {
+            return i>=0;
+          }),
+          ExcMessage("The PerpleX lookup file " + filename + " must contain columns with names "
+                     "rho,kg/m3, alpha,1/K, cp,J/K/kg, vp,km/s, vs,km/s and h,J/kg."));
+
+          std::getline(in, temp); // first data line
+
+          AssertThrow(min_temp >= 0.0, ExcMessage("Read in of Material header failed (mintemp)."));
+          AssertThrow(delta_temp > 0, ExcMessage("Read in of Material header failed (delta_temp)."));
+          AssertThrow(n_temperature > 0, ExcMessage("Read in of Material header failed (numtemp)."));
+          AssertThrow(min_press >= 0, ExcMessage("Read in of Material header failed (min_press)."));
+          AssertThrow(delta_press > 0, ExcMessage("Read in of Material header failed (delta_press)."));
+          AssertThrow(n_pressure > 0, ExcMessage("Read in of Material header failed (numpress)."));
+
+
+          max_temp = min_temp + (n_temperature-1) * delta_temp;
+          max_press = min_press + (n_pressure-1) * delta_press;
+
+          density_values.reinit(n_temperature,n_pressure);
+          thermal_expansivity_values.reinit(n_temperature,n_pressure);
+          specific_heat_values.reinit(n_temperature,n_pressure);
+          vp_values.reinit(n_temperature,n_pressure);
+          vs_values.reinit(n_temperature,n_pressure);
+          enthalpy_values.reinit(n_temperature,n_pressure);
+
+          if (has_dominant_phase_column)
+            dominant_phase_indices.reinit(n_temperature,n_pressure);
+
+          phase_volume_fractions.resize(phase_column_names.size());
+          for (auto &phase_volume_fraction : phase_volume_fractions)
+            phase_volume_fraction.reinit(n_temperature,n_pressure);
+
+          unsigned int i = 0;
+          std::vector<double> previous_row_values(n_columns, 0.);
+
+          while (!in.eof())
+            {
+              std::vector<double> row_values(n_columns);
+              std::string phase;
+
+              for (unsigned int n=0; n<n_columns; ++n)
+                {
+                  if (n == dominant_phase_column_index)
+                    in >> phase;
+                  else
+                    in >> row_values[n]; // assigned as 0 if in.fail() == True
+
+                  // P-T grids created with PerpleX-werami sometimes contain rows
+                  // filled with NaNs at extreme P-T conditions where the thermodynamic
+                  // models break down. These P-T regions are typically not relevant to
+                  // geodynamic modeling (they most commonly appear above
+                  // mantle liquidus temperatures at low pressures).
+                  // More frustratingly, PerpleX-vertex occasionally fails to find a
+                  // valid mineral assemblage in small, isolated regions within the domain,
+                  // and so PerpleX-werami also returns NaNs for pixels within these regions.
+                  // It is recommended that the user preprocesses their input
+                  // files to replace these NaNs before plugging them into ASPECT.
+                  // If this lookup encounters invalid doubles it replaces them
+                  // with the most recent valid double.
+                  if (in.fail())
+                    {
+                      in.clear();
+                      row_values[n] = previous_row_values[n];
+                    }
+                }
+              previous_row_values = row_values;
+
+              std::getline(in, temp); // read next line
+              if (in.eof())
+                break;
+
+              if (std::find(dominant_phase_names.begin(), dominant_phase_names.end(), phase) == dominant_phase_names.end())
+                dominant_phase_names.push_back(phase);
+
+              // The ordering of the first two columns in the PerpleX table files
+              // dictates whether the inner loop is over temperature or pressure.
+              // The first column is always the inner loop.
+              // The following lines populate the material property tables
+              // according to that implicit loop structure.
+              if (first_natural_variable == "T(K)")
+                {
+                  density_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[0]];
+                  thermal_expansivity_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[1]];
+                  specific_heat_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[2]];
+                  vp_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[3]];
+                  vs_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[4]];
+                  enthalpy_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[5]];
+
+                  if (has_dominant_phase_column)
+                    {
+                      std::vector<std::string>::iterator it = std::find(dominant_phase_names.begin(), dominant_phase_names.end(), phase);
+                      dominant_phase_indices[i%n_temperature][i/n_temperature] = std::distance(dominant_phase_names.begin(), it);
+                    }
+
+                  for (unsigned int n=0; n<phase_volume_fractions.size(); ++n)
+                    {
+                      phase_volume_fractions[n][i%n_temperature][i/n_temperature]=row_values[phase_column_indices[n]];
+                    }
+                }
+              else // first_natural_variable == "P(bar)"
+                {
+                  density_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[0]];
+                  thermal_expansivity_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[1]];
+                  specific_heat_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[2]];
+                  vp_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[3]];
+                  vs_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[4]];
+                  enthalpy_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[5]];
+
+                  if (has_dominant_phase_column)
+                    {
+                      std::vector<std::string>::iterator it = std::find(dominant_phase_names.begin(), dominant_phase_names.end(), phase);
+                      dominant_phase_indices[i/n_pressure][i%n_pressure] = std::distance(dominant_phase_names.begin(), it);
+                    }
+
+                  for (unsigned int n=0; n<phase_volume_fractions.size(); ++n)
+                    {
+                      phase_volume_fractions[n][i/n_pressure][i%n_pressure]=row_values[phase_column_indices[n]];
+                    }
+                }
+              ++i;
+            }
+          AssertThrow(i == n_temperature*n_pressure, ExcMessage("Material table size not consistent with header."));
+
+        }
+
+
+
+        void
+        EntropyReader::initialize(const MPI_Comm comm,
+                                  const std::string &data_directory,
+                                  const std::string &material_file_name)
+        {
+          material_lookup = std::make_unique<Utilities::StructuredDataLookup<2>>(7,1.0);
+          material_lookup->load_file(data_directory+material_file_name,
+                                     comm);
+        }
+
+
+
+        double
+        EntropyReader::specific_heat(const double entropy,
+                                     const double pressure) const
+        {
+          const double specific_heat = material_lookup->get_data({entropy,pressure}, 3);
+          return specific_heat;
+        }
+
+
+
+        double
+        EntropyReader::density(const double entropy,
+                               const double pressure) const
+        {
+          const double density = material_lookup->get_data({entropy,pressure}, 1);
+          return density;
+        }
+
+
+
+        double
+        EntropyReader::thermal_expansivity(const double entropy,
+                                           const double pressure) const
+        {
+          const double thermal_expansivity = material_lookup->get_data({entropy,pressure}, 2);
+          return thermal_expansivity;
+        }
+
+
+
+        double
+        EntropyReader::temperature(const double entropy,
+                                   const double pressure) const
+        {
+          const double temperature = material_lookup->get_data({entropy,pressure}, 0);
+          return temperature;
+        }
+
+
+
+        double
+        EntropyReader::seismic_vp(const double entropy,
+                                  const double pressure) const
+        {
+          const double seismic_vp = material_lookup->get_data({entropy,pressure}, 4);
+          return seismic_vp;
+        }
+
+
+
+        double
+        EntropyReader::seismic_vs(const double entropy,
+                                  const double pressure) const
+        {
+          const double seismic_vs = material_lookup->get_data({entropy,pressure}, 5);
+          return seismic_vs;
+        }
+
+
+
+        Tensor<1, 2>
+        EntropyReader::density_gradient(const double entropy,
+                                        const double pressure) const
+        {
+          const Tensor<1, 2> density_gradient= material_lookup->get_gradients({entropy,pressure}, 1);
+          return density_gradient;
+        }
+
+
+      }
+
+
+
+      std::vector<double>
+      compute_only_composition_fractions(const std::vector<double> &compositional_fields,
+                                         const std::vector<unsigned int> &indices_to_use)
+      {
+        std::vector<double> composition_fractions(indices_to_use.size()+1);
+
+        // Clip the compositional fields so they are between zero and one,
+        // and sum the compositional fields for normalization purposes.
+        double sum_composition = 0.0;
+        std::vector<double> x_comp (indices_to_use.size());
+
+        for (unsigned int i=0; i < x_comp.size(); ++i)
+          {
+            x_comp[i] = std::min(std::max(compositional_fields[indices_to_use[i]], 0.0), 1.0);
+            sum_composition += x_comp[i];
+          }
+
+        // Compute background field fraction
+        if (sum_composition >= 1.0)
+          composition_fractions[0] = 0.0;
+        else
+          composition_fractions[0] = 1.0 - sum_composition;
+
+        // Compute and possibly normalize field fractions
+        for (unsigned int i=0; i < x_comp.size(); ++i)
+          {
+            if (sum_composition >= 1.0)
+              composition_fractions[i+1] = x_comp[i]/sum_composition;
+            else
+              composition_fractions[i+1] = x_comp[i];
+          }
+
+        return composition_fractions;
+      }
+
+
+
+      std::vector<double>
+      compute_composition_fractions(const std::vector<double> &compositional_fields,
+                                    const ComponentMask &field_mask)
+      {
+        std::vector<double> composition_fractions(compositional_fields.size()+1);
+
+        // Clip the compositional fields so they are between zero and one,
+        // and sum the compositional fields for normalization purposes.
+        double sum_composition = 0.0;
+        std::vector<double> x_comp = compositional_fields;
+        for (unsigned int i=0; i < x_comp.size(); ++i)
+          if (field_mask[i] == true)
+            {
+              x_comp[i] = std::min(std::max(x_comp[i], 0.0), 1.0);
+              sum_composition += x_comp[i];
+            }
+
+        // Compute background field fraction
+        if (sum_composition >= 1.0)
+          composition_fractions[0] = 0.0;
+        else
+          composition_fractions[0] = 1.0 - sum_composition;
+
+        // Compute and possibly normalize field fractions
+        for (unsigned int i=0; i < x_comp.size(); ++i)
+          if (field_mask[i] == true)
+            {
+              if (sum_composition >= 1.0)
+                composition_fractions[i+1] = x_comp[i]/sum_composition;
+              else
+                composition_fractions[i+1] = x_comp[i];
+            }
+
+        return composition_fractions;
+      }
+
+
+
+      std::vector<double>
+      compute_volume_fractions(const std::vector<double> &compositional_fields,
+                               const ComponentMask &field_mask)
+      {
+        return compute_composition_fractions(compositional_fields, field_mask);
+      }
+
+
+
+      std::vector<double>
+      compute_volumes_from_masses(const std::vector<double> &masses,
+                                  const std::vector<double> &densities,
+                                  const bool return_as_fraction)
+      {
+        Assert(masses.size() == densities.size(),
+               ExcMessage ("The mass fractions and densities vectors used for computing "
+                           "volumes from masses have to have the same length! "
+                           "You have provided "
+                           + Utilities::int_to_string(masses.size()) +
+                           " mass fractions and "
+                           + Utilities::int_to_string(densities.size()) +
+                           " densities."));
+
+        const unsigned int n_fields = masses.size();
+        std::vector<double> volumes(n_fields);
+
+        if (n_fields == 1 && return_as_fraction)
+          {
+            volumes[0] = 1.0;
+            return volumes;
+          }
+
+        double sum_volumes = 0.0;
+        for (unsigned int j=0; j < n_fields; ++j)
+          {
+            volumes[j] = masses[j] / densities[j];
+            sum_volumes += volumes[j];
+          }
+
+        if (return_as_fraction)
+          {
+            for (unsigned int j=0; j < n_fields; ++j)
+              volumes[j] /= sum_volumes;
+          }
+        return volumes;
+      }
+
+
+
+      CompositionalAveragingOperation
+      parse_compositional_averaging_operation (const std::string &parameter_name,
+                                               const ParameterHandler &prm)
+      {
+        CompositionalAveragingOperation averaging_operation;
+        if (prm.get (parameter_name) == "harmonic")
+          averaging_operation = MaterialUtilities::harmonic;
+        else if (prm.get (parameter_name) == "arithmetic")
+          averaging_operation = MaterialUtilities::arithmetic;
+        else if (prm.get (parameter_name) == "geometric")
+          averaging_operation = MaterialUtilities::geometric;
+        else if (prm.get (parameter_name) == "maximum composition")
+          averaging_operation = MaterialUtilities::maximum_composition;
+        else
+          {
+            AssertThrow(false, ExcMessage("Not a valid viscosity averaging scheme"));
+
+            //We will never get here, but we have to return something so the compiler does not complain
+            return MaterialUtilities::harmonic;
+          }
+
+        return averaging_operation;
+      }
+
+
+
+      double
+      average_value (const std::vector<double> &volume_fractions,
+                     const std::vector<double> &parameter_values,
+                     const enum CompositionalAveragingOperation &average_type)
+      {
+        Assert(volume_fractions.size() == parameter_values.size(),
+               ExcMessage ("The volume fractions and parameter values vectors used for averaging "
+                           "have to have the same length! You have provided "
+                           + Utilities::int_to_string(volume_fractions.size()) +
+                           " volume fractions and "
+                           + Utilities::int_to_string(parameter_values.size()) +
+                           " parameter values."));
+
+        double averaged_parameter = 0.0;
+
+        switch (average_type)
+          {
+            case arithmetic:
+            {
+              for (unsigned int i=0; i<volume_fractions.size(); ++i)
+                averaged_parameter += volume_fractions[i] * parameter_values[i];
+              break;
+            }
+            case harmonic:
+            {
+              for (unsigned int i=0; i<volume_fractions.size(); ++i)
+                {
+                  AssertThrow(parameter_values[i] > 0,
+                              ExcMessage ("All parameter values must be greater than 0 for harmonic averaging!"));
+                  averaged_parameter += volume_fractions[i]/(parameter_values[i]);
+                }
+              averaged_parameter = 1.0/averaged_parameter;
+              break;
+            }
+            case geometric:
+            {
+              for (unsigned int i=0; i<volume_fractions.size(); ++i)
+                {
+                  AssertThrow(parameter_values[i] > 0,
+                              ExcMessage ("All parameter values must be greater than 0 for geometric averaging!"));
+                  averaged_parameter += volume_fractions[i] * std::log(parameter_values[i]);
+                }
+              averaged_parameter = std::exp(averaged_parameter);
+              break;
+            }
+            case maximum_composition:
+            {
+              const unsigned int idx = static_cast<unsigned int>(std::max_element( volume_fractions.begin(),
+                                                                                   volume_fractions.end() )
+                                                                 - volume_fractions.begin());
+              averaged_parameter = parameter_values[idx];
+              break;
+            }
+            default:
+            {
+              AssertThrow(false, ExcNotImplemented());
+              break;
+            }
+          }
+        return averaged_parameter;
+      }
+
+
+
+      template <int dim>
+      void
+      fill_averaged_equation_of_state_outputs(const EquationOfStateOutputs<dim> &eos_outputs,
+                                              const std::vector<double> &mass_fractions,
+                                              const std::vector<double> &volume_fractions,
+                                              const unsigned int i,
+                                              MaterialModelOutputs<dim> &out)
+      {
+        // The density, isothermal compressibility and thermal expansivity are volume-averaged
+        // The specific entropy derivatives and heat capacity are mass-averaged
+        out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
+        out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
+        out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
+        out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
+        out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
+        out.specific_heat[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
+      }
+
+
+
+      double phase_average_value (const std::vector<double> &phase_function_values,
+                                  const std::vector<unsigned int> &n_phase_transitions_per_composition,
+                                  const std::vector<double> &parameter_values,
+                                  const unsigned int composition_index,
+                                  const PhaseUtilities::PhaseAveragingOperation operation)
+      {
+        // Calculate base index and assign base value
+        unsigned int start_phase_index = 0;
+        for (unsigned int i=0; i<composition_index; ++i)
+          start_phase_index += n_phase_transitions_per_composition[i] + 1;
+
+        double averaged_parameter = parameter_values[start_phase_index];
+        if (n_phase_transitions_per_composition[composition_index] > 0)
+          {
+            // Do averaging when there are multiple phases
+            if (operation == PhaseUtilities::logarithmic)
+              averaged_parameter = log(averaged_parameter);
+
+            for (unsigned int i=0; i<n_phase_transitions_per_composition[composition_index]; ++i)
+              {
+                const unsigned int phase_index = start_phase_index + i;
+
+                Assert(phase_index+1<parameter_values.size(), ExcInternalError());
+                if (operation == PhaseUtilities::logarithmic)
+                  {
+                    // First average by log values and then take the exponential.
+                    // This is used for averaging prefactors in flow laws.
+                    averaged_parameter += phase_function_values[phase_index-composition_index] * (std::log(parameter_values[phase_index+1]) - averaged_parameter);
+                  }
+                else if (operation == PhaseUtilities::arithmetic)
+                  averaged_parameter += phase_function_values[phase_index-composition_index] * (parameter_values[phase_index+1] - averaged_parameter);
+
+                else
+                  AssertThrow(false, ExcInternalError());
+              }
+            if (operation == PhaseUtilities::logarithmic)
+              averaged_parameter = exp(averaged_parameter);
+          }
+        return averaged_parameter;
+      }
+
+      template <int dim>
+      PhaseFunctionInputs<dim>::PhaseFunctionInputs(const double temperature_,
+                                                    const double pressure_,
+                                                    const double depth_,
+                                                    const double pressure_depth_derivative_,
+                                                    const unsigned int phase_index_)
+
+        :
+        temperature(temperature_),
+        pressure(pressure_),
+        depth(depth_),
+        pressure_depth_derivative(pressure_depth_derivative_),
+        phase_index(phase_index_)
+      {}
+
+
+
+      template <int dim>
+      double
+      PhaseFunction<dim>::compute_value (const PhaseFunctionInputs<dim> &in) const
+      {
+        AssertIndexRange (in.phase_index, transition_temperature_lower_limits.size());
+        AssertIndexRange (in.phase_index, transition_temperature_upper_limits.size());
+
+        // the percentage of material that has undergone the transition
+        double function_value;
+        if (in.temperature < transition_temperature_lower_limits[in.phase_index] ||
+            in.temperature >= transition_temperature_upper_limits[in.phase_index])
+          {
+            // assign 0.0 if temperature is out of range
+            function_value = 0.0;
+          }
+        else
+          {
+            if (use_depth_instead_of_pressure)
+              {
+                AssertIndexRange (in.phase_index, transition_depths.size());
+
+                // calculate the deviation from the transition point (convert temperature to depth)
+                double depth_deviation = in.depth - transition_depths[in.phase_index];
+
+                if (in.pressure_depth_derivative != 0.0)
+                  {
+                    AssertIndexRange (in.phase_index, transition_slopes.size());
+                    AssertIndexRange (in.phase_index, transition_temperatures.size());
+
+                    depth_deviation -= transition_slopes[in.phase_index] / in.pressure_depth_derivative
+                                       * (in.temperature - transition_temperatures[in.phase_index]);
+                  }
+
+                // use delta function for width = 0
+                AssertIndexRange (in.phase_index, transition_widths.size());
+                if (transition_widths[in.phase_index] == 0)
+                  function_value = (depth_deviation > 0) ? 1. : 0.;
+                else
+                  function_value = 0.5*(1.0 + std::tanh(depth_deviation / transition_widths[in.phase_index]));
+              }
+            else
+              {
+                // calculate the deviation from the transition point (convert temperature to pressure)
+                AssertIndexRange (in.phase_index, transition_pressures.size());
+                const double pressure_deviation = in.pressure - transition_pressures[in.phase_index]
+                                                  - transition_slopes[in.phase_index] * (in.temperature - transition_temperatures[in.phase_index]);
+
+                // use delta function for width = 0
+                AssertIndexRange (in.phase_index, transition_pressure_widths.size());
+                if (transition_pressure_widths[in.phase_index] == 0)
+                  function_value = (pressure_deviation > 0) ? 1. : 0.;
+                else
+                  function_value = 0.5*(1.0 + std::tanh(pressure_deviation / transition_pressure_widths[in.phase_index]));
+              }
+          }
+
+        return function_value;
+      }
+
+
+
+      template <int dim>
+      double
+      PhaseFunction<dim>::compute_derivative (const PhaseFunctionInputs<dim> &in) const
+      {
+        double transition_pressure;
+        double pressure_width;
+        double width_temp;
+
+        // we already should have the adiabatic conditions here
+        Assert (this->get_adiabatic_conditions().is_initialized(),
+                ExcMessage("The adiabatic conditions need to be already initialized "
+                           "to calculate the derivative of phase functions. Either call this "
+                           "function after the reference conditions have been computed, or implement "
+                           "a workaround for the case without reference profile."));
+
+        // phase transition based on depth
+        if (use_depth_instead_of_pressure)
+          {
+            const Point<dim,double> transition_point = this->get_geometry_model().representative_point(transition_depths[in.phase_index]);
+            const Point<dim,double> transition_plus_width = this->get_geometry_model().representative_point(transition_depths[in.phase_index] + transition_widths[in.phase_index]);
+            const Point<dim,double> transition_minus_width = this->get_geometry_model().representative_point(transition_depths[in.phase_index] - transition_widths[in.phase_index]);
+            transition_pressure = this->get_adiabatic_conditions().pressure(transition_point);
+            pressure_width = 0.5 * (this->get_adiabatic_conditions().pressure(transition_plus_width)
+                                    - this->get_adiabatic_conditions().pressure(transition_minus_width));
+            width_temp = transition_widths[in.phase_index];
+          }
+        // using pressure instead of depth to define the phase transition
+        else
+          {
+            transition_pressure = transition_pressures[in.phase_index];
+            pressure_width = transition_pressure_widths[in.phase_index];
+            width_temp = transition_pressure_widths[in.phase_index];
+          }
+
+        // calculate the deviation from the transition point
+        const double pressure_deviation = in.pressure - transition_pressure
+                                          - transition_slopes[in.phase_index] * (in.temperature - transition_temperatures[in.phase_index]);
+
+        // calculate the analytical derivative of the phase function
+        if (
+          (in.temperature < transition_temperature_lower_limits[in.phase_index]) ||
+          (in.temperature >= transition_temperature_upper_limits[in.phase_index])
+        )
+          {
+            // return 0 if temperature is out of range
+            return 0;
+          }
+        else if (width_temp == 0)
+          return 0;
+        else
+          return 0.5 / pressure_width * (1.0 - std::tanh(pressure_deviation / pressure_width)
+                                         * std::tanh(pressure_deviation / pressure_width));
+      }
+
+
+
+      template <int dim>
+      unsigned int
+      PhaseFunction<dim>::
+      n_phase_transitions () const
+      {
+        if (use_depth_instead_of_pressure)
+          return transition_depths.size();
+        else
+          return transition_pressures.size();
+      }
+
+      template <int dim>
+      unsigned int
+      PhaseFunction<dim>::
+      n_phases () const
+      {
+        return n_phases_total;
+      }
+
+      template <int dim>
+      const std::vector<unsigned int> &
+      PhaseFunction<dim>::n_phase_transitions_for_each_composition () const
+      {
+        return *n_phase_transitions_per_composition;
+      }
+
+      template <int dim>
+      const std::vector<unsigned int> &
+      PhaseFunction<dim>::n_phases_for_each_composition () const
+      {
+        return n_phases_per_composition;
+      }
+
+
+
+      template <int dim>
+      double
+      PhaseFunction<dim>::
+      get_transition_slope (const unsigned int phase_index) const
+      {
+        return transition_slopes[phase_index];
+      }
+
+
+
+      template <int dim>
+      double
+      PhaseFunction<dim>::
+      get_transition_depth (const unsigned int phase_index) const
+      {
+        return transition_depths[phase_index];
+      }
+
+
+
+      template <int dim>
+      void
+      PhaseFunction<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Phase transition depths", "",
+                           Patterns::Anything(),
+                           "A list of depths where phase transitions occur. Values must "
+                           "monotonically increase. "
+                           "Units: \\si{\\meter}.");
+        prm.declare_entry ("Phase transition widths", "",
+                           Patterns::Anything(),
+                           "A list of widths for each phase transition, in terms of depth. The phase functions "
+                           "are scaled with these values, leading to a jump between phases "
+                           "for a value of zero and a gradual transition for larger values. "
+                           "List must have the same number of entries as Phase transition depths. "
+                           "Units: \\si{\\meter}.");
+        prm.declare_entry ("Phase transition pressures", "",
+                           Patterns::Anything(),
+                           "A list of pressures where phase transitions occur. Values must "
+                           "monotonically increase. Define transition by depth instead of "
+                           "pressure must be set to false to use this parameter. "
+                           "Units: \\si{\\pascal}.");
+        prm.declare_entry ("Phase transition pressure widths", "",
+                           Patterns::Anything(),
+                           "A list of widths for each phase transition, in terms of pressure. The phase functions "
+                           "are scaled with these values, leading to a jump between phases "
+                           "for a value of zero and a gradual transition for larger values. "
+                           "List must have the same number of entries as Phase transition pressures. "
+                           "Define transition by depth instead of pressure must be set to false "
+                           "to use this parameter. "
+                           "Units: \\si{\\pascal}.");
+        prm.declare_entry ("Define transition by depth instead of pressure", "true",
+                           Patterns::Bool (),
+                           "Whether to list phase transitions by depth or pressure. If this parameter is true, "
+                           "then the input file will use Phase transitions depths and Phase transition widths "
+                           "to define the phase transition. If it is false, the parameter file will read in "
+                           "phase transition data from Phase transition pressures and "
+                           "Phase transition pressure widths.");
+        prm.declare_entry ("Phase transition temperatures", "",
+                           Patterns::Anything(),
+                           "A list of temperatures where phase transitions occur. Higher or lower "
+                           "temperatures lead to phase transition occurring in smaller or greater "
+                           "depths than given in Phase transition depths, depending on the "
+                           "Clapeyron slope given in Phase transition Clapeyron slopes. "
+                           "List must have the same number of entries as Phase transition depths. "
+                           "Units: \\si{\\kelvin}.");
+        prm.declare_entry ("Phase transition temperature upper limits",
+                           boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
+                           Patterns::Anything(),
+                           "A list of upper temperature limits for each phase transition. Above "
+                           "this temperature the respective phase transition is deactivated. The default "
+                           "value means there is no upper limit for any phase transitions. "
+                           "List must have the same number of entries as Phase transition depths. "
+                           "When the optional temperature limits are applied, the user has to be "
+                           "careful about the consistency between adjacent phases. Phase transitions "
+                           "should be continuous in pressure-temperature space. "
+                           "We recommend producing a phase diagram with "
+                           "simple model setups to check the implementation as a starting point."
+                           "Units: \\si{\\kelvin}.");
+        prm.declare_entry ("Phase transition temperature lower limits",
+                           boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
+                           Patterns::Anything(),
+                           "A list of lower temperature limits for each phase transition. Below "
+                           "this temperature the respective phase transition is deactivated. The default "
+                           "value means there is no lower limit for any phase transition. "
+                           "List must have the same number of entries as Phase transition depths. "
+                           "When the optional temperature limits are applied, the user has to be "
+                           "careful about the consistency between adjacent phases. Phase transitions "
+                           "should be continuous in pressure-temperature space. "
+                           "We recommend producing a phase diagram with "
+                           "simple model setups to check the implementation as a starting point."
+                           "Units: \\si{\\kelvin}.");
+        prm.declare_entry ("Phase transition Clapeyron slopes", "",
+                           Patterns::Anything(),
+                           "A list of Clapeyron slopes for each phase transition. A positive "
+                           "Clapeyron slope indicates that the phase transition will occur in "
+                           "a greater depth, if the temperature is higher than the one given in "
+                           "Phase transition temperatures and in a smaller depth, if the "
+                           "temperature is smaller than the one given in Phase transition temperatures. "
+                           "For negative slopes the other way round. "
+                           "List must have the same number of entries as Phase transition depths. "
+                           "Units: \\si{\\pascal\\per\\kelvin}.");
+      }
+
+
+
+      template <int dim>
+      void
+      PhaseFunction<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        // Establish that a background field is required here
+        const bool has_background_field = true;
+
+        // Retrieve the list of composition names
+        const std::vector<std::string> list_of_composition_names = this->introspection().get_composition_names();
+
+        n_phase_transitions_per_composition = std::make_unique<std::vector<unsigned int>>();
+
+        use_depth_instead_of_pressure = prm.get_bool ("Define transition by depth instead of pressure");
+
+        if (use_depth_instead_of_pressure)
+          {
+            transition_depths          = Utilities::parse_map_to_double_array (prm.get("Phase transition depths"),
+                                                                               list_of_composition_names,
+                                                                               has_background_field,
+                                                                               "Phase transition depths",
+                                                                               true,
+                                                                               n_phase_transitions_per_composition,
+                                                                               true);
+
+            transition_widths          = Utilities::parse_map_to_double_array (prm.get("Phase transition widths"),
+                                                                               list_of_composition_names,
+                                                                               has_background_field,
+                                                                               "Phase transition widths",
+                                                                               true,
+                                                                               n_phase_transitions_per_composition,
+                                                                               true);
+          }
+        else
+          {
+            transition_pressures = Utilities::parse_map_to_double_array (prm.get("Phase transition pressures"),
+                                                                         list_of_composition_names,
+                                                                         has_background_field,
+                                                                         "Phase transition pressures",
+                                                                         true,
+                                                                         n_phase_transitions_per_composition,
+                                                                         true);
+
+            transition_pressure_widths = Utilities::parse_map_to_double_array (prm.get("Phase transition pressure widths"),
+                                                                               list_of_composition_names,
+                                                                               has_background_field,
+                                                                               "Phase transition pressure widths",
+                                                                               true,
+                                                                               n_phase_transitions_per_composition,
+                                                                               true);
+          }
+
+        transition_temperatures = Utilities::parse_map_to_double_array (prm.get("Phase transition temperatures"),
+                                                                        list_of_composition_names,
+                                                                        has_background_field,
+                                                                        "Phase transition temperatures",
+                                                                        true,
+                                                                        n_phase_transitions_per_composition,
+                                                                        true);
+
+        transition_temperature_upper_limits = Utilities::parse_map_to_double_array (prm.get("Phase transition temperature upper limits"),
+                                                                                    list_of_composition_names,
+                                                                                    has_background_field,
+                                                                                    "Phase transition temperature upper limits",
+                                                                                    true,
+                                                                                    n_phase_transitions_per_composition,
+                                                                                    true);
+
+        transition_temperature_lower_limits = Utilities::parse_map_to_double_array (prm.get("Phase transition temperature lower limits"),
+                                                                                    list_of_composition_names,
+                                                                                    has_background_field,
+                                                                                    "Phase transition temperature lower limits",
+                                                                                    true,
+                                                                                    n_phase_transitions_per_composition,
+                                                                                    true);
+
+        transition_slopes = Utilities::parse_map_to_double_array (prm.get("Phase transition Clapeyron slopes"),
+                                                                  list_of_composition_names,
+                                                                  has_background_field,
+                                                                  "Phase transition Clapeyron slopes",
+                                                                  true,
+                                                                  n_phase_transitions_per_composition,
+                                                                  true);
+
+        n_phases_total = 0;
+        n_phases_per_composition.clear();
+        for (unsigned int n : *n_phase_transitions_per_composition)
+          {
+            n_phases_per_composition.push_back(n+1);
+            n_phases_total += n+1;
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    namespace MaterialUtilities
+    {
+#define INSTANTIATE(dim) \
+  template void fill_averaged_equation_of_state_outputs<dim> (const EquationOfStateOutputs<dim> &, \
+                                                              const std::vector<double> &, \
+                                                              const std::vector<double> &, \
+                                                              const unsigned int, \
+                                                              MaterialModelOutputs<dim> &); \
+  template struct PhaseFunctionInputs<dim>; \
+  template class PhaseFunction<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/source/material_model/visco_plastic.cc.bak b/source/material_model/visco_plastic.cc.bak
new file mode 100644
index 00000000000..cef81e360e1
--- /dev/null
+++ b/source/material_model/visco_plastic.cc.bak
@@ -0,0 +1,678 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/visco_plastic.h>
+#include <aspect/utilities.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/signaling_nan.h>
+#include <aspect/newton.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/gravity_model/interface.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    bool
+    ViscoPlastic<dim>::
+    is_yielding (const double pressure,
+                 const double temperature,
+                 const std::vector<double> &composition,
+                 const SymmetricTensor<2,dim> &strain_rate) const
+    {
+      /* The following returns whether or not the material is plastically yielding
+       * as documented in evaluate.
+       */
+      bool plastic_yielding = false;
+
+      MaterialModel::MaterialModelInputs <dim> in (/*n_evaluation_points=*/1,
+                                                                           this->n_compositional_fields());
+      unsigned int i = 0;
+
+      in.pressure[i] = pressure;
+      in.temperature[i] = temperature;
+      in.composition[i] = composition;
+      in.strain_rate[i] = strain_rate;
+
+      const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(composition,
+                                                   this->introspection().chemical_composition_field_indices());
+
+      const IsostrainViscosities isostrain_viscosities
+        = rheology->calculate_isostrain_viscosities(in, i, volume_fractions);
+
+      std::vector<double>::const_iterator max_composition
+        = std::max_element(volume_fractions.begin(),volume_fractions.end());
+
+      plastic_yielding = isostrain_viscosities.composition_yielding[std::distance(volume_fractions.begin(),
+                                                                                  max_composition)];
+
+      return plastic_yielding;
+    }
+
+
+
+    template <int dim>
+    bool
+    ViscoPlastic<dim>::
+    is_yielding(const MaterialModelInputs<dim> &in) const
+    {
+      Assert(in.n_evaluation_points() == 1, ExcInternalError());
+
+      const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[0],
+                                                   this->introspection().chemical_composition_field_indices());
+
+      /* The following handles phases in a similar way as in the 'evaluate' function.
+       * Results then enter the calculation of plastic yielding.
+       */
+      std::vector<double> phase_function_values(phase_function.n_phase_transitions(), 0.0);
+
+      if (phase_function.n_phase_transitions() > 0)
+        {
+          const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[0]).norm();
+
+          double reference_density;
+          if (this->get_adiabatic_conditions().is_initialized())
+            {
+              reference_density = this->get_adiabatic_conditions().density(in.position[0]);
+            }
+          else
+            {
+              EquationOfStateOutputs<dim> eos_outputs_all_phases (n_phases);
+              equation_of_state.evaluate(in, 0, eos_outputs_all_phases);
+              reference_density = eos_outputs_all_phases.densities[0];
+            }
+
+          MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature[0],
+                                                                   in.pressure[0],
+                                                                   this->get_geometry_model().depth(in.position[0]),
+                                                                   gravity_norm*reference_density,
+                                                                   numbers::invalid_unsigned_int);
+
+          for (unsigned int j=0; j < phase_function.n_phase_transitions(); ++j)
+            {
+              phase_inputs.phase_index = j;
+              phase_function_values[j] = phase_function.compute_value(phase_inputs);
+            }
+        }
+
+      /* The following returns whether or not the material is plastically yielding
+       * as documented in evaluate.
+       */
+      const IsostrainViscosities isostrain_viscosities = rheology->calculate_isostrain_viscosities(in, 0, volume_fractions, phase_function_values, phase_function.n_phase_transitions_for_each_composition());
+
+      std::vector<double>::const_iterator max_composition = std::max_element(volume_fractions.begin(), volume_fractions.end());
+      const bool plastic_yielding = isostrain_viscosities.composition_yielding[std::distance(volume_fractions.begin(), max_composition)];
+
+      return plastic_yielding;
+    }
+
+
+
+    template <int dim>
+    void
+    ViscoPlastic<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      EquationOfStateOutputs<dim> eos_outputs (this->introspection().get_number_of_fields_of_type(CompositionalFieldDescription::chemical_composition)+1);
+      EquationOfStateOutputs<dim> eos_outputs_all_phases (n_phases);
+
+      std::vector<double> average_elastic_shear_moduli (in.n_evaluation_points());
+
+      // Store value of phase function for each phase and composition
+      // While the number of phases is fixed, the value of the phase function is updated for every point
+      std::vector<double> phase_function_values(phase_function.n_phase_transitions(), 0.0);
+
+      // Loop through all requested points
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          // First compute the equation of state variables and thermodynamic properties
+          equation_of_state.evaluate(in, i, eos_outputs_all_phases);
+
+          const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[i]).norm();
+          const double reference_density = (this->get_adiabatic_conditions().is_initialized())
+                                           ?
+                                           this->get_adiabatic_conditions().density(in.position[i])
+                                           :
+                                           eos_outputs_all_phases.densities[0];
+
+          // The phase index is set to invalid_unsigned_int, because it is only used internally
+          // in phase_average_equation_of_state_outputs to loop over all existing phases
+          MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature[i],
+                                                                   in.pressure[i],
+                                                                   this->get_geometry_model().depth(in.position[i]),
+                                                                   gravity_norm*reference_density,
+                                                                   numbers::invalid_unsigned_int);
+
+          // Compute value of phase functions
+          for (unsigned int j=0; j < phase_function.n_phase_transitions(); ++j)
+            {
+              phase_inputs.phase_index = j;
+              phase_function_values[j] = phase_function.compute_value(phase_inputs);
+            }
+
+          // Average by value of gamma function to get value of compositions
+          phase_average_equation_of_state_outputs(eos_outputs_all_phases,
+                                                  phase_function_values,
+                                                  n_phase_transitions_for_each_chemical_composition,
+                                                  eos_outputs);
+
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[i],
+                                                       this->introspection().chemical_composition_field_indices());
+
+          // not strictly correct if thermal expansivities are different, since we are interpreting
+          // these compositions as volume fractions, but the error introduced should not be too bad.
+          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
+          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
+          out.specific_heat[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
+
+          if (define_conductivities == false)
+            {
+              double thermal_diffusivity = 0.0;
+
+              for (unsigned int j=0; j < volume_fractions.size(); ++j)
+                thermal_diffusivity += volume_fractions[j] * thermal_diffusivities[j];
+
+              // Thermal conductivity at the given positions. If the temperature equation uses
+              // the reference density profile formulation, use the reference density to
+              // calculate thermal conductivity. Otherwise, use the real density. If the adiabatic
+              // conditions are not yet initialized, the real density will still be used.
+              if (this->get_parameters().formulation_temperature_equation ==
+                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile &&
+                  this->get_adiabatic_conditions().is_initialized())
+                out.thermal_conductivities[i] = thermal_diffusivity * out.specific_heat[i] *
+                                                this->get_adiabatic_conditions().density(in.position[i]);
+              else
+                out.thermal_conductivities[i] = thermal_diffusivity * out.specific_heat[i] * out.densities[i];
+            }
+          else
+            {
+              // Use thermal conductivity values specified in the parameter file, if this
+              // option was selected.
+              out.thermal_conductivities[i] = MaterialUtilities::average_value (volume_fractions, thermal_conductivities, MaterialUtilities::arithmetic);
+            }
+
+          out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
+          out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
+          out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
+
+          // Compute the effective viscosity if requested and retrieve whether the material is plastically yielding.
+          // Also always compute the viscosity if additional outputs are requested, because the viscosity is needed
+          // to compute the elastic force term.
+          bool plastic_yielding = false;
+          IsostrainViscosities isostrain_viscosities;
+          if (in.requests_property(MaterialProperties::viscosity) || in.requests_property(MaterialProperties::additional_outputs))
+            {
+              // Currently, the viscosities for each of the compositional fields are calculated assuming
+              // isostrain amongst all compositions, allowing calculation of the viscosity ratio.
+              // TODO: This is only consistent with viscosity averaging if the arithmetic averaging
+              // scheme is chosen. It would be useful to have a function to calculate isostress viscosities.
+              isostrain_viscosities =
+                rheology->calculate_isostrain_viscosities(in, i, volume_fractions, phase_function_values, n_phase_transitions_for_each_chemical_composition);
+
+              // The isostrain condition implies that the viscosity averaging should be arithmetic (see above).
+              // We have given the user freedom to apply alternative bounds, because in diffusion-dominated
+              // creep (where n_diff=1) viscosities are stress and strain-rate independent, so the calculation
+              // of compositional field viscosities is consistent with any averaging scheme.
+              out.viscosities[i] = MaterialUtilities::average_value(volume_fractions, isostrain_viscosities.composition_viscosities, rheology->viscosity_averaging);
+
+              // Decide based on the maximum composition if material is yielding.
+              // This avoids for example division by zero for harmonic averaging (as plastic_yielding
+              // holds values that are either 0 or 1), but might not be consistent with the viscosity
+              // averaging chosen.
+              std::vector<double>::const_iterator max_composition = std::max_element(volume_fractions.begin(), volume_fractions.end());
+              plastic_yielding = isostrain_viscosities.composition_yielding[std::distance(volume_fractions.begin(), max_composition)];
+
+              // Compute viscosity derivatives if they are requested
+              if (MaterialModel::MaterialModelDerivatives<dim> *derivatives =
+                    out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>())
+
+                rheology->compute_viscosity_derivatives(i, volume_fractions,
+                                                        isostrain_viscosities.composition_viscosities,
+                                                        in, out, phase_function_values,
+                                                        n_phase_transitions_for_each_chemical_composition);
+            }
+          else
+            {
+              // The viscosity was not requested. Poison its value, along with the other
+              // quantities we set above and that would otherwise remain uninitialized
+              isostrain_viscosities.composition_yielding.clear();
+              isostrain_viscosities.composition_viscosities.clear();
+              isostrain_viscosities.current_friction_angles.clear();
+              isostrain_viscosities.current_cohesions.clear();
+
+              out.viscosities[i] = numbers::signaling_nan<double>();
+
+              if (MaterialModel::MaterialModelDerivatives<dim> *derivatives =
+                    out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>())
+                {
+                  derivatives->viscosity_derivative_wrt_strain_rate[i] = numbers::signaling_nan<SymmetricTensor<2,dim>>();
+                  derivatives->viscosity_derivative_wrt_pressure[i] = numbers::signaling_nan<double>();
+                }
+            }
+
+          // Now compute changes in the compositional fields (i.e. the accumulated strain).
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+
+          // Calculate changes in strain invariants and update the reaction terms
+          rheology->strain_rheology.fill_reaction_outputs(in, i, rheology->min_strain_rate, plastic_yielding, out);
+
+          // Fill plastic outputs if they exist.
+          // The values in isostrain_viscosities only make sense when the calculate_isostrain_viscosities function
+          // has been called.
+          // TODO do we even need a separate function? We could compute the PlasticAdditionalOutputs here like
+          // the ElasticAdditionalOutputs.
+          rheology->fill_plastic_outputs(i, volume_fractions, plastic_yielding, in, out, isostrain_viscosities);
+
+          if (this->get_parameters().enable_elasticity)
+            {
+              // Compute average elastic shear modulus
+              average_elastic_shear_moduli[i] = MaterialUtilities::average_value(volume_fractions,
+                                                                                 rheology->elastic_rheology.get_elastic_shear_moduli(),
+                                                                                 rheology->viscosity_averaging);
+
+              // Fill the material properties that are part of the elastic additional outputs
+              if (ElasticAdditionalOutputs<dim> *elastic_out = out.template get_additional_output<ElasticAdditionalOutputs<dim>>())
+                {
+                  elastic_out->elastic_shear_moduli[i] = average_elastic_shear_moduli[i];
+                }
+            }
+        }
+
+      // If we use the full strain tensor, compute the change in the individual tensor components.
+      rheology->strain_rheology.compute_finite_strain_reaction_terms(in, out);
+
+      if (this->get_parameters().enable_elasticity)
+        {
+          rheology->elastic_rheology.fill_elastic_outputs(in, average_elastic_shear_moduli, out);
+          rheology->elastic_rheology.fill_reaction_outputs(in, average_elastic_shear_moduli, out);
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    ViscoPlastic<dim>::
+    is_compressible () const
+    {
+      return equation_of_state.is_compressible();
+    }
+
+
+
+    template <int dim>
+    double ViscoPlastic<dim>::
+    get_min_strain_rate () const
+    {
+      return rheology->min_strain_rate;
+    }
+
+
+
+    template <int dim>
+    void
+    ViscoPlastic<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Visco Plastic");
+        {
+          MaterialUtilities::PhaseFunction<dim>::declare_parameters(prm);
+
+          EquationOfState::MulticomponentIncompressible<dim>::declare_parameters (prm);
+
+          Rheology::ViscoPlastic<dim>::declare_parameters(prm);
+
+          // Equation of state parameters
+          prm.declare_entry ("Thermal diffusivities", "0.8e-6",
+                             Patterns::List(Patterns::Double (0.)),
+                             "List of thermal diffusivities, for background material and compositional fields, "
+                             "for a total of N+1 values, where N is the number of all compositional fields or only "
+                             "those corresponding to chemical compositions. "
+                             "If only one value is given, then all use the same value.  "
+                             "Units: \\si{\\meter\\squared\\per\\second}.");
+          prm.declare_entry ("Define thermal conductivities","false",
+                             Patterns::Bool (),
+                             "Whether to directly define thermal conductivities for each compositional field "
+                             "instead of calculating the values through the specified thermal diffusivities, "
+                             "densities, and heat capacities. ");
+          prm.declare_entry ("Thermal conductivities", "3.0",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of thermal conductivities, for background material and compositional fields, "
+                             "for a total of N+1 values, where N is the number of all compositional fields or only "
+                             "those corresponding to chemical compositions. "
+                             "If only one value is given, then all use the same value. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ViscoPlastic<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Visco Plastic");
+        {
+          // Phase transition parameters
+          phase_function.initialize_simulator (this->get_simulator());
+          phase_function.parse_parameters (prm);
+
+          std::vector<unsigned int> n_phases_for_each_composition = phase_function.n_phases_for_each_composition();
+
+          // Currently, phase_function.n_phases_for_each_composition() returns a list of length
+          // equal to the total number of compositions, whether or not they are chemical compositions.
+          // The equation_of_state (multicomponent incompressible) requires a list only for
+          // chemical compositions.
+          std::vector<unsigned int> n_phases_for_each_chemical_composition = {n_phases_for_each_composition[0]};
+          n_phase_transitions_for_each_chemical_composition = {n_phases_for_each_composition[0] - 1};
+          n_phases = n_phases_for_each_composition[0];
+          for (auto i : this->introspection().chemical_composition_field_indices())
+            {
+              n_phases_for_each_chemical_composition.push_back(n_phases_for_each_composition[i+1]);
+              n_phase_transitions_for_each_chemical_composition.push_back(n_phases_for_each_composition[i+1] - 1);
+              n_phases += n_phases_for_each_composition[i+1];
+            }
+
+          // Equation of state parameters
+          equation_of_state.initialize_simulator (this->get_simulator());
+          equation_of_state.parse_parameters (prm,
+                                              std::make_unique<std::vector<unsigned int>>(n_phases_for_each_chemical_composition));
+
+          // Make options file for parsing maps to double arrays
+          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+          chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+          compositional_field_names.insert(compositional_field_names.begin(),"background");
+
+          Utilities::MapParsing::Options options(chemical_field_names, "Thermal diffusivities");
+          options.list_of_allowed_keys = compositional_field_names;
+          options.allow_multiple_values_per_key = true;
+          options.n_values_per_key = n_phases_for_each_chemical_composition;
+          options.check_values_per_key = (options.n_values_per_key.size() != 0);
+          options.store_values_per_key = (options.n_values_per_key.size() == 0);
+
+          thermal_diffusivities = Utilities::MapParsing::parse_map_to_double_array(prm.get("Thermal diffusivities"), options);
+          define_conductivities = prm.get_bool ("Define thermal conductivities");
+
+          options.property_name = "Thermal conductivities";
+          thermal_conductivities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Thermal conductivities"), options);
+
+          rheology = std::make_unique<Rheology::ViscoPlastic<dim>>();
+          rheology->initialize_simulator (this->get_simulator());
+          rheology->parse_parameters(prm, std::make_unique<std::vector<unsigned int>>(n_phases_for_each_chemical_composition));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+    }
+
+
+
+    template <int dim>
+    void
+    ViscoPlastic<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      rheology->create_plastic_outputs(out);
+
+      if (this->get_parameters().enable_elasticity)
+        rheology->elastic_rheology.create_elastic_outputs(out);
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ViscoPlastic,
+                                   "visco plastic",
+                                   "An implementation of an incompressible visco(elastic)-plastic rheology "
+                                   "with options for selecting dislocation creep, diffusion creep or "
+                                   "composite viscous flow laws. Prior to yielding, one may select to "
+                                   "modify the viscosity to account for viscoelastic effects by setting the "
+                                   "parameter 'Enable elasticity' in subsection Formulation to true. Plasticity "
+                                   "limits viscous stresses through a Drucker Prager yield criterion. "
+                                   "The implementation of this material model is based heavily on the "
+                                   "`DiffusionDislocation' (Bob Myhill), `DruckerPrager' "
+                                   "(Anne Glerum), and `Viscoelastic' (John Naliboff) material models. "
+                                   "\n\n "
+                                   "The viscosity for dislocation or diffusion creep is defined as "
+                                   "$ \\eta = \\frac 12 A^{-\\frac{1}{n}} d^{\\frac{m}{n}} "
+                                   "\\dot{\\varepsilon}_{ii}^{\\frac{1-n}{n}} "
+                                   "\\exp\\left(\\frac{E + PV}{nRT}\\right)$ "
+                                   "where $A$ is the prefactor, $n$ is the stress exponent, "
+                                   "$\\dot{\\varepsilon}_{ii}$ is the square root of the deviatoric "
+                                   "strain rate tensor second invariant, $d$ is grain size, "
+                                   "$m$ is the grain size exponent, $E$ is activation energy, "
+                                   "$V$ is activation volume, $P$ is pressure, $R$ is the gas "
+                                   "exponent and $T$ is temperature. "
+                                   "This form of the viscosity equation is commonly used in "
+                                   "geodynamic simulations. See, for example, Billen and Hirth "
+                                   "(2007), G3, 8, Q08012. Significantly, other studies may use "
+                                   "slightly different forms of the viscosity equation leading to "
+                                   "variations in how specific terms are defined or combined. For "
+                                   "example, the grain size exponent should always be positive in "
+                                   "the diffusion viscosity equation used here, while other studies "
+                                   "place the grain size term in the denominator and invert the sign "
+                                   "of the grain size exponent. When examining previous work, one "
+                                   "should carefully check how the viscous prefactor and grain size "
+                                   "terms are defined. "
+                                   "\n\n "
+                                   "One may select to use the diffusion ($\\eta_{\\text{diff}}$; $n=1$, $m\\neq 0$), "
+                                   "dislocation ($\\eta_{\\text{disl}}$, $n>1$, $m=0$) or composite "
+                                   "$\\frac{\\eta_{\\text{diff}} \\eta_{\\text{disl}}}{\\eta_{\\text{diff}}+\\eta_{\\text{disl}}}$ equation form. "
+                                   "\n\n "
+                                   "The diffusion and dislocation prefactors can be weakened with a factor "
+                                   "between 0 and 1 according to the total or the viscous strain only. "
+                                   "\n\n "
+                                   "Viscosity is limited through one of two different `yielding' mechanisms. "
+                                   "\n\n"
+                                   "The first plasticity mechanism limits viscous stress through a "
+                                   "Drucker Prager yield criterion, where the yield stress in 3d is  "
+                                   "$\\sigma_y = \\frac{6C\\cos(\\phi) + 2P\\sin(\\phi)} "
+                                   "{\\sqrt{3}(3+\\sin(\\phi))}$ "
+                                   "and "
+                                   "$\\sigma_y = C\\cos(\\phi) + P\\sin(\\phi)$ "
+                                   "in 2d. Above, $C$ is cohesion and $\\phi$  is the angle of "
+                                   "internal friction.  Note that the 2d form is equivalent to the "
+                                   "Mohr Coulomb yield surface.  If $\\phi$ is 0, the yield stress "
+                                   "is fixed and equal to the cohesion (Von Mises yield criterion). "
+                                   "When the viscous stress ($2\\eta {\\varepsilon}_{ii}$) exceeds "
+                                   "the yield stress, the viscosity is rescaled back to the yield "
+                                   "surface: $\\eta_{y}=\\sigma_{y}/(2{\\varepsilon}_{ii})$. "
+                                   "This form of plasticity is commonly used in geodynamic models. "
+                                   "See, for example, Thieulot, C. (2011), PEPI 188, pp. 47-68. "
+                                   "\n\n"
+                                   "The user has the option to linearly reduce the cohesion and "
+                                   "internal friction angle as a function of the finite strain magnitude. "
+                                   "The finite strain invariant or full strain tensor is calculated through "
+                                   "compositional fields within the material model. This implementation is "
+                                   "identical to the compositional field finite strain plugin and cookbook "
+                                   "described in the manual (author: Gassmoeller, Dannberg). If the user selects to track "
+                                   "the finite strain invariant ($e_{ii}$), a single compositional field tracks "
+                                   "the value derived from $e_{ii}^t = (e_{ii})^{(t-1)} + \\dot{e}_{ii}\\; dt$, where $t$ and $t-1$ "
+                                   "are the current and prior time steps, $\\dot{e}_{ii}$ is the second invariant of the "
+                                   "strain rate tensor and $dt$ is the time step size. In the case of the "
+                                   "full strain tensor $F$, the finite strain magnitude is derived from the "
+                                   "second invariant of the symmetric stretching tensor $L$, where "
+                                   "$L = F [F]^T$. The user must specify a single compositional "
+                                   "field for the finite strain invariant or multiple fields (4 in 2d, 9 in 3d) "
+                                   "for the finite strain tensor. These field(s) must be the first listed "
+                                   "compositional fields in the parameter file. Note that one or more of the finite strain "
+                                   "tensor components must be assigned a non-zero value initially. This value can be "
+                                   "be quite small (e.g., 1.e-8), but still non-zero. While the option to track and use "
+                                   "the full finite strain tensor exists, tracking the associated compositional fields "
+                                   "is computationally expensive in 3d. Similarly, the finite strain magnitudes "
+                                   "may in fact decrease if the orientation of the deformation field switches "
+                                   "through time. Consequently, the ideal solution is track the finite strain "
+                                   "invariant (single compositional) field within the material and track "
+                                   "the full finite strain tensor through particles."
+                                   "When only the second invariant of the strain is tracked, one has the option to "
+                                   "track the full strain or only the plastic strain. In the latter case, strain is only tracked "
+                                   "in case the material is plastically yielding, i.e. the viscous stress > yield stress. "
+                                   "\n\n"
+                                   "Viscous stress may also be limited by a non-linear stress limiter "
+                                   "that has a form similar to the Peierls creep mechanism. "
+                                   "This stress limiter assigns an effective viscosity "
+                                   "$\\sigma_{\\text{eff}} = \\frac{\\tau_y}{2\\varepsilon_y} "
+                                   "{\\frac{\\varepsilon_{ii}}{\\varepsilon_y}}^{\\frac{1}{n_y}-1}$ "
+                                   "Above $\\tau_y$ is a yield stress, $\\varepsilon_y$ is the "
+                                   "reference strain rate, $\\varepsilon_{ii}$ is the strain rate "
+                                   "and $n_y$ is the stress limiter exponent.  The yield stress, "
+                                   "$\\tau_y$, is defined through the Drucker Prager yield criterion "
+                                   "formulation. This method of limiting viscous stress has been used "
+                                   "in various forms within the geodynamic literature \\cite{chri92,vavv02,cibi13,cibi15}."
+                                   "When $n_y$ is 1, it essentially becomes a linear viscosity model, "
+                                   "and in the limit $n_y\\rightarrow \\infty$ it converges to the "
+                                   "standard viscosity rescaling method (concretely, values $n_y>20$ "
+                                   "are large enough)."
+                                   "\n\n "
+                                   "The visco-plastic rheology described above may also be modified to include "
+                                   "viscoelastic deformation, thus producing a viscoelastic plastic constitutive "
+                                   "relationship. "
+                                   "\n\n "
+                                   "The viscoelastic rheology behavior takes into account the elastic shear "
+                                   "strength (e.g., shear modulus), while the tensile and volumetric "
+                                   "strength (e.g., Young's and bulk modulus) are not considered. The "
+                                   "model is incompressible and allows specifying an arbitrary number "
+                                   "of compositional fields, where each field represents a different "
+                                   "rock type or component of the viscoelastic stress tensor. The stress "
+                                   "tensor in 2d and 3d, respectively, contains 3 or 6 components. The "
+                                   "compositional fields representing these components must be named "
+                                   "and listed in a very specific format, which is designed to minimize "
+                                   "mislabeling stress tensor components as distinct 'compositional "
+                                   "rock types' (or vice versa). For 2d models, the first three "
+                                   "compositional fields must be labeled 'stress\\_xx', 'stress\\_yy' and 'stress\\_xy'. "
+                                   "In 3d, the first six compositional fields must be labeled 'stress\\_xx', "
+                                   "'stress\\_yy', 'stress\\_zz', 'stress\\_xy', 'stress\\_xz', 'stress\\_yz'. "
+                                   "\n\n "
+                                   "Combining this viscoelasticity implementation with non-linear viscous flow "
+                                   "and plasticity produces a constitutive relationship commonly referred to "
+                                   "as partial elastoviscoplastic (e.g., pEVP) in the geodynamics community. "
+                                   "While extensively discussed and applied within the geodynamics "
+                                   "literature, notable references include: "
+                                   "Moresi et al. (2003), J. Comp. Phys., v. 184, p. 476-497. "
+                                   "Gerya and Yuen (2007), Phys. Earth. Planet. Inter., v. 163, p. 83-105. "
+                                   "Gerya (2010), Introduction to Numerical Geodynamic Modeling. "
+                                   "Kaus (2010), Tectonophysics, v. 484, p. 36-47. "
+                                   "Choi et al. (2013), J. Geophys. Res., v. 118, p. 2429-2444. "
+                                   "Keller et al. (2013), Geophys. J. Int., v. 195, p. 1406-1442. "
+                                   "\n\n "
+                                   "The overview below directly follows Moresi et al. (2003) eqns. 23-38. "
+                                   "However, an important distinction between this material model and "
+                                   "the studies above is the use of compositional fields, rather than "
+                                   "particles, to track individual components of the viscoelastic stress "
+                                   "tensor. The material model will be updated when an option to track "
+                                   "and calculate viscoelastic stresses with particles is implemented. "
+                                   "\n\n "
+                                   "Moresi et al. (2003) begins (eqn. 23) by writing the deviatoric "
+                                   "rate of deformation ($\\hat{D}$) as the sum of elastic "
+                                   "($\\hat{D_{e}}$) and viscous ($\\hat{D_{v}}$) components: "
+                                   "$\\hat{D} = \\hat{D_{e}} + \\hat{D_{v}}$.  "
+                                   "These terms further decompose into "
+                                   "$\\hat{D_{v}} = \\frac{\\tau}{2\\eta}$ and "
+                                   "$\\hat{D_{e}} = \\frac{\\overset{\\nabla}{\\tau}}{2\\mu}$, where "
+                                   "$\\tau$ is the viscous deviatoric stress, $\\eta$ is the shear viscosity, "
+                                   "$\\mu$ is the shear modulus and $\\overset{\\nabla}{\\tau}$ is the "
+                                   "Jaumann corotational stress rate. This later term (eqn. 24) contains the "
+                                   "time derivative of the deviatoric stress ($\\dot{\\tau}$) and terms that "
+                                   "account for material spin (e.g., rotation) due to advection: "
+                                   "$\\overset{\\nabla}{\\tau} = \\dot{\\tau} + {\\tau}W -W\\tau$. "
+                                   "Above, $W$ is the material spin tensor (eqn. 25): "
+                                   "$W_{ij} = \\frac{1}{2} \\left (\\frac{\\partial V_{i}}{\\partial x_{j}} - "
+                                   "\\frac{\\partial V_{j}}{\\partial x_{i}} \\right )$. "
+                                   "\n\n "
+                                   "If plasticity is included, the deviatoric rate of deformation may be written as: "
+                                   "$\\hat{D} = \\hat{D_{e}} + \\hat{D_{v}} + \\hat{D_{p}}$, where $\\hat{D_{p}}$ "
+                                   "is the plastic component. $\\hat{D_{p}}$ decomposes to $\\frac{\\tau_{y}}{2\\eta_{y}}$, "
+                                   "where $\\tau_{y}$ is the yield stress and $\\eta_{y}$ is the viscosity rescaled "
+                                   "to the yield surface. "
+                                   "The Jaumann stress-rate can also be approximated using terms from the "
+                                   "previous time step ($t$) and current time step ($t + \\Delta t^{e}$): "
+                                   "$\\smash[t]{\\overset{\\nabla}{\\tau}}^{t + \\Delta t^{e}} \\approx "
+                                   "\\frac{\\tau^{t + \\Delta t^{e} - \\tau^{t}}}{\\Delta t^{e}} - "
+                                   "W^{t}\\tau^{t} + \\tau^{t}W^{t}$. "
+                                   "In this material model, the size of the time step above ($\\Delta t^{e}$) "
+                                   "can be specified as the numerical time step size or an independent fixed time "
+                                   "step. If the latter case is selected, the user has an option to apply a "
+                                   "stress averaging scheme to account for the differences between the numerical "
+                                   "and fixed elastic time step (eqn. 32). If one selects to use a fixed elastic time "
+                                   "step throughout the model run, this can still be achieved by using CFL and "
+                                   "maximum time step values that restrict the numerical time step to a specific time."
+                                   "\n\n "
+                                   "The formulation above allows rewriting the total rate of deformation (eqn. 29) as\n "
+                                   "$\\tau^{t + \\Delta t^{e}} = \\eta_{eff} \\left ( "
+                                   "2\\hat{D}^{t + \\triangle t^{e}} + \\frac{\\tau^{t}}{\\mu \\Delta t^{e}} + "
+                                   "\\frac{W^{t}\\tau^{t} - \\tau^{t}W^{t}}{\\mu}  \\right )$. "
+                                   "\n\n "
+                                   "The effective viscosity (eqn. 28) is a function of the viscosity ($\\eta$), "
+                                   "elastic time step size ($\\Delta t^{e}$) and shear relaxation time "
+                                   "($ \\alpha = \\frac{\\eta}{\\mu} $): "
+                                   "$\\eta_{eff} = \\eta \\frac{\\Delta t^{e}}{\\Delta t^{e} + \\alpha}$ "
+                                   "The magnitude of the shear modulus thus controls how much the effective "
+                                   "viscosity is reduced relative to the initial viscosity. "
+                                   "\n\n "
+                                   "Elastic effects are introduced into the governing Stokes equations through "
+                                   "an elastic force term (eqn. 30) using stresses from the previous time step: "
+                                   "$F^{e,t} = -\\frac{\\eta_{eff}}{\\mu \\Delta t^{e}} \\tau^{t}$. "
+                                   "This force term is added onto the right-hand side force vector in the "
+                                   "system of equations. "
+                                   "\n\n "
+                                   "When plastic yielding occurs, the effective viscosity in equation 29 and 30 is the "
+                                   "plastic viscosity (equation 36). If the current stress is below the plastic "
+                                   "yield stress, the effective viscosity is still as defined in equation 28. "
+                                   "During non-linear iterations, we define the current stress prior to yielding "
+                                   "(e.g., value compared to yield stress) as "
+                                   "$\\tau^{t + \\Delta t^{e}} = \\eta_{eff} \\left ( 2\\hat{D}^{t + \\triangle t^{e}} + "
+                                   "\\frac{\\tau^{t}}{\\mu \\Delta t^{e}} \\right ) $"
+                                   "\n\n "
+                                   "Compositional fields can each be assigned individual values of "
+                                   "thermal diffusivity, heat capacity, density, thermal "
+                                   "expansivity and rheological parameters. "
+                                   "\n\n "
+                                   "If more than one compositional field is present at a given "
+                                   "point, viscosities are averaged with an arithmetic, geometric "
+                                   "harmonic (default) or maximum composition scheme. "
+                                   "\n\n "
+                                   "The value for the components of this formula and additional "
+                                   "parameters are read from the parameter file in subsection "
+                                   " 'Material model/Visco Plastic'.")
+  }
+}
diff --git a/source/material_model/viscoelastic.cc.bak b/source/material_model/viscoelastic.cc.bak
new file mode 100644
index 00000000000..f25c6375a4a
--- /dev/null
+++ b/source/material_model/viscoelastic.cc.bak
@@ -0,0 +1,313 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/viscoelastic.h>
+#include <aspect/utilities.h>
+#include <aspect/global.h>
+#include <numeric>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    Viscoelastic<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      EquationOfStateOutputs<dim> eos_outputs (this->introspection().get_number_of_fields_of_type(CompositionalFieldDescription::chemical_composition)+1);
+
+      // Store which components to exclude during volume fraction computation.
+      ComponentMask composition_mask(this->n_compositional_fields(), true);
+      // assign compositional fields associated with viscoelastic stress a value of 0
+      // assume these fields are listed first
+      for (unsigned int i=0; i < SymmetricTensor<2,dim>::n_independent_components; ++i)
+        composition_mask.set(i,false);
+
+      std::vector<double> average_elastic_shear_moduli (in.n_evaluation_points());
+      std::vector<double> elastic_shear_moduli(elastic_rheology.get_elastic_shear_moduli());
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const std::vector<double> composition = in.composition[i];
+
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(composition,
+                                                       this->introspection().chemical_composition_field_indices());
+
+          equation_of_state.evaluate(in, i, eos_outputs);
+
+          // Arithmetic averaging of thermal conductivities
+          // This may not be strictly the most reasonable thing, but for most Earth materials we hope
+          // that they do not vary so much that it is a big problem.
+          out.thermal_conductivities[i] = MaterialUtilities::average_value(volume_fractions, thermal_conductivities, MaterialUtilities::arithmetic);
+
+          // not strictly correct if thermal expansivities are different, since we are interpreting
+          // these compositions as volume fractions, but the error introduced should not be too bad.
+          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
+          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
+          out.specific_heat[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
+
+          out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
+          out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
+          out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
+
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+
+          // Average viscosity and shear modulus
+          const double average_viscosity = MaterialUtilities::average_value(volume_fractions, viscosities, viscosity_averaging);
+          average_elastic_shear_moduli[i] = MaterialUtilities::average_value(volume_fractions, elastic_shear_moduli, viscosity_averaging);
+
+          // Average viscoelastic (e.g., effective) viscosity (equation 28 in Moresi et al., 2003, J. Comp. Phys.)
+          out.viscosities[i] = elastic_rheology.calculate_viscoelastic_viscosity(average_viscosity,
+                                                                                 average_elastic_shear_moduli[i]);
+
+          // Fill the material properties that are part of the elastic additional outputs
+          if (ElasticAdditionalOutputs<dim> *elastic_out = out.template get_additional_output<ElasticAdditionalOutputs<dim>>())
+            {
+              elastic_out->elastic_shear_moduli[i] = average_elastic_shear_moduli[i];
+            }
+        }
+
+      elastic_rheology.fill_elastic_outputs(in, average_elastic_shear_moduli, out);
+      elastic_rheology.fill_reaction_outputs(in, average_elastic_shear_moduli, out);
+
+    }
+
+    template <int dim>
+    bool
+    Viscoelastic<dim>::
+    is_compressible () const
+    {
+      return equation_of_state.is_compressible();
+    }
+
+    template <int dim>
+    void
+    Viscoelastic<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Viscoelastic");
+        {
+          EquationOfState::MulticomponentIncompressible<dim>::declare_parameters (prm);
+          Rheology::Elasticity<dim>::declare_parameters (prm);
+
+          prm.declare_entry ("Viscosities", "1.e21",
+                             Patterns::List(Patterns::Double (0.)),
+                             "List of viscosities for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of all compositional fields or only "
+                             "those corresponding to chemical compositions. "
+                             "If only one value is given, then all use the same value. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Thermal conductivities", "4.7",
+                             Patterns::List(Patterns::Double (0.)),
+                             "List of thermal conductivities for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of all compositional fields or only "
+                             "those corresponding to chemical compositions. "
+                             "If only one value is given, then all use the same value. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
+                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition "),
+                             "When more than one compositional field is present at a point "
+                             "with different viscosities, we need to come up with an average "
+                             "viscosity at that point.  Select a weighted harmonic, arithmetic, "
+                             "geometric, or maximum composition.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    Viscoelastic<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Viscoelastic");
+        {
+          // Equation of state parameters
+          equation_of_state.initialize_simulator (this->get_simulator());
+          equation_of_state.parse_parameters (prm);
+
+          elastic_rheology.initialize_simulator (this->get_simulator());
+          elastic_rheology.parse_parameters(prm);
+
+          viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
+                                prm);
+
+          // Make options file for parsing maps to double arrays
+          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+          chemical_field_names.insert(chemical_field_names.begin(),"background");
+
+          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
+          compositional_field_names.insert(compositional_field_names.begin(),"background");
+
+          Utilities::MapParsing::Options options(chemical_field_names, "Viscosities");
+          options.list_of_allowed_keys = compositional_field_names;
+
+          viscosities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Viscosities"), options);
+          options.property_name = "Thermal conductivities";
+          thermal_conductivities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Thermal conductivities"), options);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::compositional_fields;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::compositional_fields;
+    }
+
+
+
+    template <int dim>
+    void
+    Viscoelastic<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      elastic_rheology.create_elastic_outputs(out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Viscoelastic,
+                                   "viscoelastic",
+                                   "An implementation of a simple linear viscoelastic rheology that "
+                                   "only includes the deviatoric components of elasticity. Specifically, "
+                                   "the viscoelastic rheology only takes into account the elastic shear "
+                                   "strength (e.g., shear modulus), while the tensile and volumetric "
+                                   "strength (e.g., Young's and bulk modulus) are not considered. The "
+                                   "model is incompressible and allows specifying an arbitrary number "
+                                   "of compositional fields, where each field represents a different "
+                                   "rock type or component of the viscoelastic stress tensor. The stress "
+                                   "tensor in 2d and 3d, respectively, contains 3 or 6 components. The "
+                                   "compositional fields representing these components must be named "
+                                   "and listed in a very specific format, which is designed to minimize "
+                                   "mislabeling stress tensor components as distinct 'compositional "
+                                   "rock types' (or vice versa). For 2d models, the first three "
+                                   "compositional fields must be labeled 'stress\\_xx', 'stress\\_yy' and 'stress\\_xy'. "
+                                   "In 3d, the first six compositional fields must be labeled 'stress\\_xx', "
+                                   "'stress\\_yy', 'stress\\_zz', 'stress\\_xy', 'stress\\_xz', 'stress\\_yz'. "
+                                   "\n\n "
+                                   "Expanding the model to include non-linear viscous flow (e.g., "
+                                   "diffusion/dislocation creep) and plasticity would produce a "
+                                   "constitutive relationship commonly referred to as partial "
+                                   "elastoviscoplastic (e.g., pEVP) in the geodynamics community. "
+                                   "While extensively discussed and applied within the geodynamics "
+                                   "literature, notable references include: "
+                                   "Moresi et al. (2003), J. Comp. Phys., v. 184, p. 476-497. "
+                                   "Gerya and Yuen (2007), Phys. Earth. Planet. Inter., v. 163, p. 83-105. "
+                                   "Gerya (2010), Introduction to Numerical Geodynamic Modeling. "
+                                   "Kaus (2010), Tectonophysics, v. 484, p. 36-47. "
+                                   "Choi et al. (2013), J. Geophys. Res., v. 118, p. 2429-2444. "
+                                   "Keller et al. (2013), Geophys. J. Int., v. 195, p. 1406-1442. "
+                                   "\n\n "
+                                   "The overview below directly follows Moresi et al. (2003) eqns. 23-32. "
+                                   "However, an important distinction between this material model and "
+                                   "the studies above is the use of compositional fields, rather than "
+                                   "particles, to track individual components of the viscoelastic stress "
+                                   "tensor. The material model will be updated when an option to track "
+                                   "and calculate viscoelastic stresses with particles is implemented. "
+                                   "\n\n "
+                                   "Moresi et al. (2003) begins (eqn. 23) by writing the deviatoric "
+                                   "rate of deformation ($\\hat{D}$) as the sum of elastic "
+                                   "($\\hat{D_{e}}$) and viscous ($\\hat{D_{v}}$) components: "
+                                   "$\\hat{D} = \\hat{D_{e}} + \\hat{D_{v}}$.  "
+                                   "These terms further decompose into "
+                                   "$\\hat{D_{v}} = \\frac{\\tau}{2\\eta}$ and "
+                                   "$\\hat{D_{e}} = \\frac{\\overset{\\nabla}{\\tau}}{2\\mu}$, where "
+                                   "$\\tau$ is the viscous deviatoric stress, $\\eta$ is the shear viscosity, "
+                                   "$\\mu$ is the shear modulus and $\\overset{\\nabla}{\\tau}$ is the "
+                                   "Jaumann corotational stress rate. This later term (eqn. 24) contains the "
+                                   "time derivative of the deviatoric stress ($\\dot{\\tau}$) and terms that "
+                                   "account for material spin (e.g., rotation) due to advection: "
+                                   "$\\overset{\\nabla}{\\tau} = \\dot{\\tau} + {\\tau}W -W\\tau$. "
+                                   "Above, $W$ is the material spin tensor (eqn. 25): "
+                                   "$W_{ij} = \\frac{1}{2} \\left (\\frac{\\partial V_{i}}{\\partial x_{j}} - "
+                                   "\\frac{\\partial V_{j}}{\\partial x_{i}} \\right )$. "
+                                   "\n\n "
+                                   "The Jaumann stress-rate can also be approximated using terms from the "
+                                   "previous time step ($t$) and current time step ($t + \\Delta t^{e}$): "
+                                   "$\\smash[t]{\\overset{\\nabla}{\\tau}}^{t + \\Delta t^{e}} \\approx "
+                                   "\\frac{\\tau^{t + \\Delta t^{e} - \\tau^{t}}}{\\Delta t^{e}} - "
+                                   "W^{t}\\tau^{t} + \\tau^{t}W^{t}$. "
+                                   "In this material model, the size of the time step above ($\\Delta t^{e}$) "
+                                   "can be specified as the numerical time step size or an independent fixed time "
+                                   "step. If the latter case is selected, the user has an option to apply a "
+                                   "stress averaging scheme to account for the differences between the numerical "
+                                   "and fixed elastic time step (eqn. 32). If one selects to use a fixed elastic time "
+                                   "step throughout the model run, this can still be achieved by using CFL and "
+                                   "maximum time step values that restrict the numerical time step to a specific time."
+                                   "\n\n "
+                                   "The formulation above allows rewriting the total deviatoric stress (eqn. 29) as\n "
+                                   "$\\tau^{t + \\Delta t^{e}} = \\eta_\\text{eff} \\left ( "
+                                   "2\\hat{D}^{t + \\triangle t^{e}} + \\frac{\\tau^{t}}{\\mu \\Delta t^{e}} + "
+                                   "\\frac{W^{t}\\tau^{t} - \\tau^{t}W^{t}}{\\mu}  \\right )$. "
+                                   "\n\n "
+                                   "The effective viscosity (eqn. 28) is a function of the viscosity ($\\eta$), "
+                                   "elastic time step size ($\\Delta t^{e}$) and shear relaxation time "
+                                   "($ \\alpha = \\frac{\\eta}{\\mu} $): "
+                                   "$\\eta_\\text{eff} = \\eta \\frac{\\Delta t^{e}}{\\Delta t^{e} + \\alpha}$ "
+                                   "The magnitude of the shear modulus thus controls how much the effective "
+                                   "viscosity is reduced relative to the initial viscosity. "
+                                   "\n\n "
+                                   "Elastic effects are introduced into the governing Stokes equations through "
+                                   "an elastic force term (eqn. 30) using stresses from the previous time step: "
+                                   "$F^{e,t} = -\\frac{\\eta_\\text{eff}}{\\mu \\Delta t^{e}} \\tau^{t}$. "
+                                   "This force term is added onto the right-hand side force vector in the "
+                                   "system of equations. "
+                                   "\n\n "
+                                   "The value of each compositional field representing distinct rock types at a "
+                                   "point is interpreted to be a volume fraction of that rock type. If the sum of "
+                                   "the compositional field volume fractions is less than one, then the remainder "
+                                   "of the volume is assumed to be 'background material'."
+                                   "\n\n "
+                                   "Several model parameters (densities, elastic shear moduli, thermal expansivities, "
+                                   "thermal conductivies, specific heats) can be defined per-compositional field. "
+                                   "For each material parameter the user supplies a comma delimited list of length "
+                                   "N+1, where N is the number of compositional fields. The additional field corresponds "
+                                   "to the value for background material. They should be ordered ''background, "
+                                   "composition1, composition2...''. However, the first 3 (2d) or 6 (3d) composition "
+                                   "fields correspond to components of the elastic stress tensor and their material "
+                                   "values will not contribute to the volume fractions. If a single value is given, then "
+                                   "all the compositional fields are given that value. Other lengths of lists are not "
+                                   "allowed. For a given compositional field the material parameters are treated as "
+                                   "constant, except density, which varies linearly with temperature according to the "
+                                   "thermal expansivity. "
+                                   "\n\n "
+                                   "When more than one compositional field is present at a point, they are averaged "
+                                   "arithmetically. An exception is viscosity, which may be averaged arithmetically, "
+                                   "harmonically, geometrically, or by selecting the viscosity of the composition field "
+                                   "with the greatest volume fraction.")
+  }
+}
diff --git a/source/mesh_deformation/ascii_data.cc.bak b/source/mesh_deformation/ascii_data.cc.bak
new file mode 100644
index 00000000000..4c8a6b6f3c3
--- /dev/null
+++ b/source/mesh_deformation/ascii_data.cc.bak
@@ -0,0 +1,151 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/mesh_deformation/ascii_data.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/parameter_handler.h>
+#include <array>
+
+
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      :
+      surface_boundary_id(1)
+    {}
+
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+      Utilities::AsciiDataBoundary<dim>::initialize({surface_boundary_id},
+                                                    1);
+    }
+
+
+
+    template <int dim>
+    Tensor<1,dim>
+    AsciiData<dim>::compute_initial_deformation_on_boundary(const types::boundary_id boundary_indicator,
+                                                            const Point<dim> &position) const
+    {
+      const double topo = Utilities::AsciiDataBoundary<dim>::get_data_component(boundary_indicator,
+                                                                                position,
+                                                                                0);
+
+      const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(position);
+
+      Tensor<1,dim> topography_direction;
+      if (gravity.norm() > 0.0)
+        topography_direction = -gravity / gravity.norm();
+
+      return topo * topography_direction;
+    }
+
+
+
+    template <int dim>
+    bool
+    AsciiData<dim>::
+    needs_surface_stabilization () const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh deformation");
+      {
+        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                          "$ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/",
+                                                          "box_3d_%s.0.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh deformation");
+      {
+        Utilities::AsciiDataBase<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(AsciiData,
+                                           "ascii data",
+                                           "Implementation of a model in which the initial mesh "
+                                           "deformation (initial topography) is "
+                                           "derived from a file containing data "
+                                           "in ascii format. The following geometry models "
+                                           "are currently supported: box, chunk, spherical. "
+                                           "Note the required format of the "
+                                           "input data: The first lines may contain any number of comments "
+                                           "if they begin with `#', but one of these lines needs to "
+                                           "contain the number of grid points in each dimension as "
+                                           "for example `# POINTS: 3 3'. "
+                                           "The order of the data columns "
+                                           "has to be `x', `Topography [m]' in a 2d model and "
+                                           " `x', `y', `Topography [m]' in a 3d model, which means that "
+                                           "there has to be a single column "
+                                           "containing the topography. "
+                                           "Note that the data in the input "
+                                           "file needs to be sorted in a specific order: "
+                                           "the first coordinate needs to ascend first, "
+                                           "followed by the second in order to "
+                                           "assign the correct data to the prescribed coordinates. "
+                                           "If you use a spherical model, "
+                                           "then the assumed grid changes. "
+                                           "`x' will be replaced by the azimuth angle in radians "
+                                           " and `y' by the polar angle in radians measured "
+                                           "positive from the north pole. The grid will be assumed to be "
+                                           "a longitude-colatitude grid. Note that the order "
+                                           "of spherical coordinates is `phi', `theta' "
+                                           "and not `theta', `phi', since this allows "
+                                           "for dimension independent expressions.")
+  }
+}
diff --git a/source/mesh_deformation/diffusion.cc.bak b/source/mesh_deformation/diffusion.cc.bak
new file mode 100644
index 00000000000..abe769a856c
--- /dev/null
+++ b/source/mesh_deformation/diffusion.cc.bak
@@ -0,0 +1,582 @@
+/*
+  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/mesh_deformation/diffusion.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/simulator.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/base/symmetric_tensor.h>
+#include <deal.II/numerics/vector_tools.h>
+#include <deal.II/lac/precondition.h>
+#include <deal.II/lac/trilinos_precondition.h>
+#include <boost/lexical_cast.hpp>
+
+namespace aspect
+{
+
+  namespace MeshDeformation
+  {
+    template <int dim>
+    Diffusion<dim>::Diffusion()
+      :
+      diffusivity(0.),
+      timesteps_between_diffusion (1),
+      apply_diffusion(false)
+    {}
+
+
+
+    template <int dim>
+    void
+    Diffusion<dim>::initialize ()
+    {
+      AssertThrow(Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
+                  Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
+                  ExcMessage("The surface diffusion mesh deformation plugin only works for Box geometries."));
+    }
+
+
+
+    template <int dim>
+    void
+    Diffusion<dim>::update ()
+    {
+      // Set the current timestep number
+      const unsigned int current_timestep_number = this->get_timestep_number();
+
+      // Determine whether we need to apply diffusion based
+      // on the timestep interval between applications.
+      // Because mesh deformation is computed at the beginning
+      // of each timestep, we do not apply diffusion in the first timestep.
+      if (current_timestep_number != 0)
+        {
+          if (current_timestep_number % timesteps_between_diffusion == 0)
+            apply_diffusion = true;
+          else
+            apply_diffusion = false;
+        }
+    }
+
+
+
+    template <int dim>
+    void Diffusion<dim>::diffuse_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                          const IndexSet &mesh_locally_owned,
+                                          const IndexSet &mesh_locally_relevant,
+                                          LinearAlgebra::Vector &output,
+                                          const std::set<types::boundary_id> &boundary_ids) const
+    {
+      // Check that the current timestep does not exceed the diffusion timestep
+      check_diffusion_time_step(mesh_deformation_dof_handler, boundary_ids);
+
+      // Set up constraints
+      AffineConstraints<double> matrix_constraints(mesh_locally_relevant);
+      DoFTools::make_hanging_node_constraints(mesh_deformation_dof_handler, matrix_constraints);
+
+      std::set<types::boundary_id> periodic_boundary_indicators;
+      using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
+      const periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
+      for (const auto &p : pbp)
+        {
+          DoFTools::make_periodicity_constraints(mesh_deformation_dof_handler,
+                                                 p.first.first, p.first.second, p.second, matrix_constraints);
+          periodic_boundary_indicators.insert(p.first.first);
+          periodic_boundary_indicators.insert(p.first.second);
+        }
+
+      // A boundary can be:
+      // 1) A mesh deformation boundary with its deformation computed by this plugin.
+      // 2) A zero mesh displacement boundary:
+      //    a) boundaries with zero Stokes velocity that are not an Additional tangential mesh boundary or mesh deformation boundary,
+      //    b) boundaries with prescribed Stokes velocity that are not an Additional tangential mesh boundary or mesh deformation boundary.
+      // 3) A tangential mesh displacement boundary (no normal flux):
+      //    a) tangential Stokes boundaries that are not a mesh deformation boundary,
+      //    b) additional tangential mesh boundaries other than those in a) and c),
+      //    c) periodic boundaries that are not a mesh deformation boundary.
+      // We obtain the zero mesh displacement boundaries by subtracting the mesh deformation ones (1+3) from all used boundary indicators. In this
+      // case, when no Stokes velocity boundary conditions are set (e.g. when using the single Advection,
+      // no Stokes solver scheme, we do end up with mesh displacement boundary conditions.
+
+      // All boundary indicators used by the current geometry.
+      const std::set<types::boundary_id> all_boundaries = this->get_geometry_model().get_used_boundary_indicators();
+
+      // Get the tangential Stokes velocity boundary indicators.
+      const std::set<types::boundary_id> tangential_velocity_boundary_indicators =
+        this->get_boundary_velocity_manager().get_tangential_boundary_velocity_indicators();
+
+      // The list of all tangential mesh deformation boundary indicators.
+      std::set<types::boundary_id> tmp_tangential_boundaries, tmp2_tangential_boundaries, all_tangential_boundaries;
+      std::set_union(tangential_velocity_boundary_indicators.begin(),tangential_velocity_boundary_indicators.end(),
+                     additional_tangential_mesh_boundary_indicators.begin(),additional_tangential_mesh_boundary_indicators.end(),
+                     std::inserter(tmp_tangential_boundaries, tmp_tangential_boundaries.end()));
+      std::set_union(tmp_tangential_boundaries.begin(),tmp_tangential_boundaries.end(),
+                     periodic_boundary_indicators.begin(),periodic_boundary_indicators.end(),
+                     std::inserter(tmp2_tangential_boundaries, tmp2_tangential_boundaries.end()));
+      // Tangential Stokes velocity boundaries can also be mesh deformation boundaries,
+      // so correct for that.
+      std::set_difference(tmp2_tangential_boundaries.begin(),tmp2_tangential_boundaries.end(),
+                          boundary_ids.begin(),boundary_ids.end(),
+                          std::inserter(all_tangential_boundaries, all_tangential_boundaries.end()));
+
+      // The list of mesh deformation boundary indicators of boundaries that are allowed to move either
+      // tangentially or in all directions.
+      std::set<types::boundary_id> all_deformable_boundaries;
+      std::set_union(all_tangential_boundaries.begin(),all_tangential_boundaries.end(),
+                     boundary_ids.begin(),boundary_ids.end(),
+                     std::inserter(all_deformable_boundaries, all_deformable_boundaries.end()));
+
+      // The list of mesh deformation boundary indicators of boundaries that are not allowed to move.
+      std::set<types::boundary_id> all_fixed_boundaries;
+      std::set_difference(all_boundaries.begin(),all_boundaries.end(),
+                          all_deformable_boundaries.begin(),all_deformable_boundaries.end(),
+                          std::inserter(all_fixed_boundaries, all_fixed_boundaries.end()));
+
+      // Make the no flux boundary constraints
+      for (const types::boundary_id &boundary_id : all_fixed_boundaries)
+        {
+          VectorTools::interpolate_boundary_values (this->get_mapping(),
+                                                    mesh_deformation_dof_handler,
+                                                    boundary_id,
+                                                    dealii::Functions::ZeroFunction<dim>(dim),
+                                                    matrix_constraints);
+        }
+
+      // Make the no normal flux boundary constraints
+      VectorTools::compute_no_normal_flux_constraints (mesh_deformation_dof_handler,
+                                                       /* first_vector_component= */
+                                                       0,
+                                                       all_tangential_boundaries,
+                                                       matrix_constraints, this->get_mapping());
+
+      matrix_constraints.close();
+
+      // Set up the system to solve
+      LinearAlgebra::SparseMatrix matrix;
+
+      // Sparsity of the matrix
+      TrilinosWrappers::SparsityPattern sp (mesh_locally_owned,
+                                            mesh_locally_owned,
+                                            mesh_locally_relevant,
+                                            this->get_mpi_communicator());
+      DoFTools::make_sparsity_pattern (mesh_deformation_dof_handler, sp, matrix_constraints, false,
+                                       Utilities::MPI::this_mpi_process(this->get_mpi_communicator()));
+
+      sp.compress();
+      matrix.reinit (sp);
+
+      LinearAlgebra::Vector system_rhs, solution;
+      system_rhs.reinit(mesh_locally_owned, this->get_mpi_communicator());
+      solution.reinit(mesh_locally_owned, this->get_mpi_communicator());
+
+      // Initialize Gauss-Legendre quadrature for degree+1 quadrature points of the surface faces
+      const QGauss<dim-1> face_quadrature(mesh_deformation_dof_handler.get_fe().degree+1);
+      // Update shape function values and gradients, the quadrature points and the Jacobian x quadrature weights.
+      const UpdateFlags update_flags = UpdateFlags(update_values | update_gradients | update_quadrature_points | update_normal_vectors | update_JxW_values);
+      // We want to extract the displacement at the free surface faces of the mesh deformation element.
+      FEFaceValues<dim> fs_fe_face_values (this->get_mapping(), mesh_deformation_dof_handler.get_fe(), face_quadrature, update_flags);
+      // and to solve on the whole mesh deformation mesh
+      // The number of quadrature points on a mesh deformation surface face
+      const unsigned int n_fs_face_q_points = fs_fe_face_values.n_quadrature_points;
+
+      // What we need to build our system on the mesh deformation element
+
+      // The nr of shape functions per mesh deformation element
+      const unsigned int dofs_per_cell = mesh_deformation_dof_handler.get_fe().dofs_per_cell;
+
+      // Map of local to global cell dof indices
+      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
+
+      // The local rhs vector
+      Vector<double> cell_vector (dofs_per_cell);
+      // The local matrix
+      FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
+
+      // Vector for getting the local dim displacement values
+      std::vector<Tensor<1, dim>> displacement_values(n_fs_face_q_points);
+
+      // Vector for getting the local dim initial topography values
+      std::vector<Tensor<1, dim>> initial_topography_values(n_fs_face_q_points);
+
+      // The global displacements on the MeshDeformation FE
+      LinearAlgebra::Vector displacements = this->get_mesh_deformation_handler().get_mesh_displacements();
+
+      // The global initial topography on the MeshDeformation FE
+      // TODO Once the initial mesh deformation is ready, this
+      // can be removed.
+      LinearAlgebra::Vector initial_topography = this->get_mesh_deformation_handler().get_initial_topography();
+
+      // Do nothing at time zero
+      if (this->get_timestep_number() < 1)
+        return;
+
+      // An extractor for the dim-valued displacement vectors
+      // Later on we will compute the gravity-parallel displacement
+      FEValuesExtractors::Vector extract_vertical_displacements(0);
+
+      // An extractor for the dim-valued initial topography vectors
+      // Later on we will compute the gravity-parallel displacement
+      FEValuesExtractors::Vector extract_initial_topography(0);
+
+      // Cell iterator over the MeshDeformation FE
+      typename DoFHandler<dim>::active_cell_iterator
+      fscell = mesh_deformation_dof_handler.begin_active(),
+      fsendc = mesh_deformation_dof_handler.end();
+
+      // Iterate over all cells to find those at the mesh deformation boundary
+      for (; fscell!=fsendc; ++fscell)
+        if (fscell->at_boundary() && fscell->is_locally_owned())
+          for (const unsigned int face_no : fscell->face_indices())
+            if (fscell->face(face_no)->at_boundary())
+              {
+                // Boundary indicator of current cell face
+                const types::boundary_id boundary_indicator
+                  = fscell->face(face_no)->boundary_id();
+
+                // Only apply diffusion to the requested boundaries
+                if (boundary_ids.find(boundary_indicator) == boundary_ids.end())
+                  continue;
+
+                // Recompute values, gradients, etc on the faces
+                fs_fe_face_values.reinit (fscell, face_no);
+
+                // Get the global numbers of the local DoFs of the mesh deformation cell
+                fscell->get_dof_indices (cell_dof_indices);
+
+                // Extract the displacement values
+                fs_fe_face_values[extract_vertical_displacements].get_function_values (displacements, displacement_values);
+
+                // Extract the initial topography values
+                fs_fe_face_values[extract_initial_topography].get_function_values (initial_topography, initial_topography_values);
+
+                // Reset local rhs and matrix
+                cell_vector = 0;
+                cell_matrix = 0;
+
+                // Loop over the quadrature points of the current face
+                for (unsigned int point=0; point<n_fs_face_q_points; ++point)
+                  {
+                    // Get the gravity vector to compute the outward direction of displacement
+                    Tensor<1,dim> direction = -(this->get_gravity_model().gravity_vector(fs_fe_face_values.quadrature_point(point)));
+                    // Normalize direction vector
+                    if (direction.norm() > 0.0)
+                      direction *= 1./direction.norm();
+                    // TODO this is only correct for box geometries
+                    else
+                      {
+                        AssertThrow(Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
+                                    Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
+                                    ExcMessage("The surface diffusion mesh deformation plugin only works for Box geometries."));
+                        direction[dim-1] = 1.;
+                      }
+
+                    // Compute the total displacement in the gravity direction,
+                    // i.e. the initial topography + any additional mesh displacement.
+                    const double displacement = direction * (displacement_values[point] + initial_topography_values[point]);
+
+                    // To project onto the tangent space of the surface,
+                    // we define the projection P:= I- n x n,
+                    // with I the unit tensor and n the unit normal to the surface.
+                    // The surface gradient then is P times the usual gradient of the shape functions.
+                    const Tensor<2, dim, double> projection = unit_symmetric_tensor<dim>() -
+                                                              outer_product(fs_fe_face_values.normal_vector(point), fs_fe_face_values.normal_vector(point));
+
+
+                    // The shape values for the i-loop
+                    std::vector<double> phi(dofs_per_cell);
+
+                    // The projected gradients of the shape values for the i-loop
+                    std::vector<Tensor<1, dim, double>> projected_grad_phi(dofs_per_cell);
+
+                    // Loop over the shape functions
+                    for (unsigned int i=0; i<dofs_per_cell; ++i)
+                      {
+                        // Make sure we only assemble for the y-component
+                        // TODO this is only correct for box geometries
+                        // Check that a box geometry is used
+                        AssertThrow(Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
+                                    Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
+                                    ExcMessage("The surface diffusion mesh deformation plugin only works for Box geometries."));
+                        if (mesh_deformation_dof_handler.get_fe().system_to_component_index(i).first == dim-1)
+                          {
+                            // Precompute shape values and projected shape value gradients
+                            phi[i] = fs_fe_face_values.shape_value (i, point);
+                            projected_grad_phi[i] = projection * fs_fe_face_values.shape_grad(i, point);
+
+                            // Assemble the RHS
+                            // RHS = M*H_old
+                            cell_vector(i) += phi[i] * displacement * fs_fe_face_values.JxW(point);
+
+                            for (unsigned int j=0; j<dofs_per_cell; ++j)
+                              {
+                                // Make sure we only assemble for the y-component
+                                // TODO this is only correct for box geometries
+                                if (mesh_deformation_dof_handler.get_fe().system_to_component_index(j).first == dim-1)
+                                  {
+                                    // Assemble the matrix, for backward first order time discretization:
+                                    // Matrix := (M+dt*K) = (M+dt*B^T*kappa*B)
+                                    cell_matrix(i,j) +=
+                                      (
+                                        phi[i] * fs_fe_face_values.shape_value (j, point) +
+                                        this->get_timestep() * diffusivity *
+                                        projected_grad_phi[i] *
+                                        (projection * fs_fe_face_values.shape_grad(j, point))
+                                      )
+                                      * fs_fe_face_values.JxW(point);
+                                  }
+                              }
+                          }
+                      }
+                  }
+
+                matrix_constraints.distribute_local_to_global (cell_matrix, cell_vector,
+                                                               cell_dof_indices, matrix, system_rhs, false);
+              }
+
+      system_rhs.compress (VectorOperation::add);
+      matrix.compress(VectorOperation::add);
+
+      // Jacobi seems to be fine here.  Other preconditioners (ILU, IC) run into trouble
+      // because the matrix is mostly empty, since we don't touch internal vertices.
+      LinearAlgebra::PreconditionJacobi preconditioner_mass;
+      LinearAlgebra::PreconditionJacobi::AdditionalData preconditioner_control(1,1e-16,1);
+      preconditioner_mass.initialize(matrix, preconditioner_control);
+
+      this->get_pcout() << "   Solving mesh surface diffusion" << std::endl;
+      SolverControl solver_control(5*system_rhs.size(), this->get_parameters().linear_stokes_solver_tolerance*system_rhs.l2_norm());
+      SolverCG<LinearAlgebra::Vector> cg(solver_control);
+      cg.solve (matrix, solution, system_rhs, preconditioner_mass);
+
+      // Distribute constraints on mass matrix
+      matrix_constraints.distribute (solution);
+
+      // The solution contains the new displacements, but we need to return a velocity.
+      // Therefore, we compute v=d_displacement/d_t.
+      // d_displacement are the new mesh node locations
+      // minus the old locations, which are initial_topography + displacements.
+      LinearAlgebra::Vector velocity(mesh_locally_owned, mesh_locally_relevant, this->get_mpi_communicator());
+      velocity = solution;
+      velocity -= initial_topography;
+      velocity -= displacements;
+
+      // The velocity
+      if (this->get_timestep() > 0.)
+        velocity /= this->get_timestep();
+      else
+        AssertThrow(false, ExcZero());
+
+      output = velocity;
+    }
+
+
+
+    template <int dim>
+    void Diffusion<dim>::check_diffusion_time_step (const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                    const std::set<types::boundary_id> &boundary_ids) const
+    {
+      double min_local_conduction_timestep = std::numeric_limits<double>::max();
+
+      for (const auto &fscell : mesh_deformation_dof_handler.active_cell_iterators())
+        if (fscell->at_boundary() && fscell->is_locally_owned())
+          for (const unsigned int face_no : fscell->face_indices())
+            if (fscell->face(face_no)->at_boundary())
+              {
+                // Get the boundary indicator of current cell face
+                const types::boundary_id boundary_indicator
+                  = fscell->face(face_no)->boundary_id();
+
+                // Only consider the requested boundaries
+                if (boundary_ids.find(boundary_indicator) == boundary_ids.end())
+                  continue;
+
+                // Calculate the corresponding conduction timestep
+                min_local_conduction_timestep = std::min(min_local_conduction_timestep,
+                                                         this->get_parameters().CFL_number*std::pow(fscell->face(face_no)->minimum_vertex_distance(),2.)
+                                                         / diffusivity);
+              }
+
+      // Get the global minimum timestep
+      const double min_conduction_timestep = Utilities::MPI::min (min_local_conduction_timestep, this->get_mpi_communicator());
+
+      double conduction_timestep = min_conduction_timestep;
+      if (this->convert_output_to_years())
+        conduction_timestep /= year_in_seconds;
+
+      AssertThrow (this->get_timestep() <= min_conduction_timestep,
+                   ExcMessage("The numerical timestep is too large for diffusion of the surface. Although the "
+                              "diffusion scheme is stable, note that the error increases linearly with the timestep. "
+                              "The diffusion timestep is: " + std::to_string(conduction_timestep) + ", while "
+                              "the advection timestep is: " + std::to_string (this->get_timestep ())));
+    }
+
+
+
+    template <int dim>
+    void
+    Diffusion<dim>::compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                             AffineConstraints<double> &mesh_velocity_constraints,
+                                                             const std::set<types::boundary_id> &boundary_id) const
+    {
+      if (!apply_diffusion)
+        return;
+
+      LinearAlgebra::Vector boundary_velocity;
+
+      const IndexSet &mesh_locally_owned = mesh_deformation_dof_handler.locally_owned_dofs();
+      IndexSet mesh_locally_relevant;
+      DoFTools::extract_locally_relevant_dofs (mesh_deformation_dof_handler,
+                                               mesh_locally_relevant);
+      boundary_velocity.reinit(mesh_locally_owned, mesh_locally_relevant,
+                               this->get_mpi_communicator());
+
+      // Determine the mesh velocity at the surface based on diffusion of
+      // the topography
+      diffuse_boundary(mesh_deformation_dof_handler, mesh_locally_owned,
+                       mesh_locally_relevant, boundary_velocity, boundary_id);
+
+      // now insert the relevant part of the solution into the mesh constraints
+      const IndexSet constrained_dofs =
+        DoFTools::extract_boundary_dofs(mesh_deformation_dof_handler,
+                                        ComponentMask(dim, true),
+                                        boundary_id);
+
+      for (unsigned int i = 0; i < constrained_dofs.n_elements();  ++i)
+        {
+          types::global_dof_index index = constrained_dofs.nth_index_in_set(i);
+          if (mesh_velocity_constraints.can_store_line(index))
+            if (mesh_velocity_constraints.is_constrained(index)==false)
+              {
+                mesh_velocity_constraints.add_line(index);
+                mesh_velocity_constraints.set_inhomogeneity(index, boundary_velocity[index]);
+              }
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    Diffusion<dim>::
+    needs_surface_stabilization () const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    void Diffusion<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh deformation");
+      {
+        prm.enter_subsection("Diffusion");
+        {
+          prm.declare_entry("Hillslope transport coefficient", "1e-6",
+                            Patterns::Double(0),
+                            "The hillslope transport coefficient $\\kappa$ used to "
+                            "diffuse the free surface, either as a  "
+                            "stabilization step or to mimic erosional "
+                            "and depositional processes. Units: $\\si{m^2/s}$. ");
+          prm.declare_entry("Time steps between diffusion", "1",
+                            Patterns::Integer(0,std::numeric_limits<int>::max()),
+                            "The number of time steps between each application of "
+                            "diffusion.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void Diffusion<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Mesh deformation");
+      {
+        // Create the list of tangential mesh movement boundary indicators.
+        try
+          {
+            const std::vector<types::boundary_id> x_additional_tangential_mesh_boundary_indicators
+              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
+                                                                                    (prm.get ("Additional tangential mesh velocity boundary indicators")));
+
+            additional_tangential_mesh_boundary_indicators.insert(x_additional_tangential_mesh_boundary_indicators.begin(),
+                                                                  x_additional_tangential_mesh_boundary_indicators.end());
+          }
+        catch (const std::string &error)
+          {
+            AssertThrow (false, ExcMessage ("While parsing the entry <Mesh deformation/Additional tangential "
+                                            "mesh velocity boundary indicators>, there was an error. Specifically, "
+                                            "the conversion function complained as follows:\n\n"
+                                            + error));
+          }
+
+        prm.enter_subsection ("Diffusion");
+        {
+          diffusivity                 = prm.get_double("Hillslope transport coefficient");
+          timesteps_between_diffusion = prm.get_integer("Time steps between diffusion");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(Diffusion,
+                                           "diffusion",
+                                           "A plugin that computes the deformation of surface "
+                                           "vertices according to the solution of the hillslope diffusion problem. "
+                                           "Specifically, at the end of each timestep, or after a specific number "
+                                           "of timesteps, this plugin solves the following equation: "
+                                           "\\begin{align*}"
+                                           "  \\frac{\\partial h}{\\partial t} = \\kappa \\left( \\frac{\\partial^{2} h}{\\partial x^{2}} "
+                                           "+ \\frac{\\partial^{2} h}{\\partial y^{2}} \\right), "
+                                           "\\end{align*} "
+                                           "where $\\kappa$ is the hillslope diffusion coefficient (diffusivity), and $h(x,y)$ the "
+                                           "height of a point along the top boundary with respect to the surface of the unperturbed domain. "
+                                           "\n\n"
+                                           "Using this definition, the plugin then solves for one time step, i.e., "
+                                           "using as initial condition $h(t_{n-1})$ the current surface elevation, "
+                                           "and computing $h(t_n)$ from it by solving the equation above over "
+                                           "the time interval $t_n-t_{n-1}$. From this, one can then compute "
+                                           "a surface velocity $v = \\frac{h(t_n)-h(t_{n-1})}{t_n-t_{n-1}}$. "
+                                           "\n\n"
+                                           "This surface velocity is used to deform the surface and as a boundary condition "
+                                           "for solving the Laplace equation to determine the mesh velocity in the "
+                                           "domain interior. "
+                                           "Diffusion can be applied every timestep, mimicking surface processes of erosion "
+                                           "and deposition, or at a user-defined timestep interval to purely smooth the surface "
+                                           "topography to avoid too great a distortion of mesh elements when a free "
+                                           "surface is also used.")
+  }
+}
diff --git a/source/mesh_deformation/fastscape.cc.bak b/source/mesh_deformation/fastscape.cc.bak
new file mode 100644
index 00000000000..e0adde32c31
--- /dev/null
+++ b/source/mesh_deformation/fastscape.cc.bak
@@ -0,0 +1,1997 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+#include <aspect/global.h>
+
+#ifdef ASPECT_WITH_FASTSCAPE
+
+#include <aspect/mesh_deformation/fastscape.h>
+#include <aspect/geometry_model/box.h>
+#include <deal.II/numerics/vector_tools.h>
+#include <aspect/postprocess/visualization.h>
+#include <ctime>
+#include <aspect/simulator.h>
+
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    /**
+     * Define FastScape functions as C functions. Must use the exact same function/variable name
+     * and type as used in FastScape. All function names must be made lowercase, and an
+     * underscore added at the end. Types must be defined as pointers, and sent to
+     * FastScape as a reference. Additional functions are available within FastScape,
+     * see https://fastscape.org/fastscapelib-fortran/ for a list of all functions and
+     * their input parameters. These functions must be defined at the top here before
+     * they are used.
+     */
+    extern"C"
+    {
+      /**
+       * Function to initialize FastScape.
+       */
+      void fastscape_init_();
+
+      /**
+       * Set the x and y extent of the FastScape model.
+       */
+      void fastscape_set_xl_yl_(const double *xxl,
+                                const double *yyl);
+
+      /**
+       * Set number of grid points in x (nx) and y (ny)
+       */
+      void fastscape_set_nx_ny_(const unsigned int *nnx,
+                                const unsigned int *nny);
+
+      /**
+       * Allocate memory, must be called after set nx/ny.
+       */
+      void fastscape_setup_();
+
+      /**
+       * Set FastScape boundary conditions.
+       */
+      void fastscape_set_bc_(const unsigned int *jbc);
+
+      /**
+       * Set FastScape timestep. This will vary based on the ASPECT timestep.
+       */
+      void fastscape_set_dt_(const double *dtt);
+
+      /**
+       * Initialize FastScape topography.
+       */
+      void fastscape_init_h_(double *hp);
+
+      /**
+       * Initialize FastScape silt fraction during a restart.
+       */
+      void fastscape_init_f_(double *sf);
+
+      /**
+       * Set FastScape erosional parameters on land. These parameters will apply to the stream power law (SPL)
+       * and hillslope diffusion for basement and sediment. This can be set between timesteps.
+       */
+      void fastscape_set_erosional_parameters_(double *kkf,
+                                               const double *kkfsed,
+                                               const double *mm,
+                                               const double *nnn,
+                                               double *kkd,
+                                               const double *kkdsed,
+                                               const double *gg1,
+                                               const double *gg2,
+                                               const double *pp);
+
+      /**
+       * Set FastScape marine erosional parameters. This can be set between timesteps.
+       */
+      void fastscape_set_marine_parameters_(const double *sl,
+                                            const double *p1,
+                                            const double *p2,
+                                            const double *z1,
+                                            const double *z2,
+                                            const double *r,
+                                            const double *l,
+                                            const double *kds1,
+                                            const double *kds2);
+
+      /**
+       * Set advection velocities for FastScape. This can be set between timesteps.
+       */
+      void fastscape_set_v_(double *ux,
+                            double *uy);
+
+      /**
+       * Set FastScape uplift rate. This can be set between timesteps.
+       */
+      void fastscape_set_u_(double *up);
+
+      /**
+       * Set FastScape topography. This can be set between timesteps.
+       */
+      void fastscape_set_h_(double *hp);
+
+      /**
+      * Set FastScape basement. This can be set between timesteps. Sediment within FastScape
+      * is considered as the difference between the topography and basement, though this may differ
+      * from sediment as seen in ASPECT because the FastScape basement only takes the surface
+      * velocities into consideration.
+      */
+      void fastscape_set_basement_(double *b);
+
+      /**
+       * Run FastScape for a single FastScape timestep.
+       */
+      void fastscape_execute_step_();
+
+      /**
+       * Create a .VTK file for the FastScape surface within the FastScape folder of the
+       * ASPECT output folder.
+       */
+      void fastscape_named_vtk_(double *fp,
+                                const double *vexp,
+                                unsigned int *astep,
+                                const char *c,
+                                const unsigned int *length);
+
+      /**
+       * Copy the current FastScape topography.
+       */
+      void fastscape_copy_h_(double *hp);
+
+      /**
+       * Copy the current FastScape basement.
+       */
+      void fastscape_copy_basement_(double *b);
+
+      /**
+       * Copy the current FastScape silt fraction.
+       */
+      void fastscape_copy_f_(double *sf);
+
+      /**
+       * Copy the current FastScape slopes.
+       */
+      void fastscape_copy_slope_(double *slopep);
+
+      /**
+       * Destroy FastScape.
+       */
+      void fastscape_destroy_();
+    }
+
+
+    template <int dim>
+    FastScape<dim>::~FastScape ()
+    {
+      // It doesn't seem to matter if this is done on all processors or only on the one that runs
+      // FastScape as the destroy function checks if the memory is allocated.
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        fastscape_destroy_();
+    }
+
+    template <int dim>
+    void
+    FastScape<dim>::initialize ()
+    {
+      AssertThrow(Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
+                  ExcMessage("FastScape can only be run with a box geometry model."));
+
+      const GeometryModel::Box<dim> *geometry
+        = dynamic_cast<const GeometryModel::Box<dim>*> (&this->get_geometry_model());
+
+      // Find the id associated with the top boundary and boundaries that call mesh deformation.
+      const types::boundary_id top_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id ("top");
+      const std::set<types::boundary_id> mesh_deformation_boundary_ids
+        = this->get_mesh_deformation_handler().get_active_mesh_deformation_boundary_indicators();
+
+      // Get the deformation type names called for each boundary.
+      std::map<types::boundary_id, std::vector<std::string>> mesh_deformation_boundary_indicators_map
+        = this->get_mesh_deformation_handler().get_active_mesh_deformation_names();
+
+      // Loop over each mesh deformation boundary, and make sure FastScape is only called on the surface.
+      for (const types::boundary_id id : mesh_deformation_boundary_ids)
+        {
+          const std::vector<std::string> &names = mesh_deformation_boundary_indicators_map[id];
+          for (const auto &name : names)
+            {
+              if (name == "fastscape")
+                AssertThrow(id == top_boundary,
+                            ExcMessage("FastScape can only be called on the surface boundary."));
+            }
+        }
+
+      // Several compositional fields are commonly used in conjunction with the FastScape plugin, i.e.
+      // "sediment_age" to track the age of the sediment deposited and "deposition_depth" to track the depth
+      // with respect to the unperturbed surface of the model domain. Their values are controlled by setting
+      // boundary conditions on the top boundary that is deformed by FastScape. While it is useful to track these
+      // fields, they are not needed for any function in the FastScape plugin. If they exist however, we need
+      // to make sure that these fields do not have the type "chemical composition" and are therefore not taken
+      // into account when computing material properties.
+      const std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
+      if (this->introspection().compositional_name_exists("sediment_age"))
+        {
+          const std::vector<std::string>::const_iterator
+          it = std::find(chemical_field_names.begin(), chemical_field_names.end(), "sediment_age");
+          AssertThrow (it == chemical_field_names.end(),
+                       ExcMessage("There is a field sediment_age that is of type chemical composition. "
+                                  "Please change it to type generic so that it does not affect material properties."));
+        }
+      if (this->introspection().compositional_name_exists("deposition_depth"))
+        {
+          const std::vector<std::string>::const_iterator
+          it = std::find(chemical_field_names.begin(), chemical_field_names.end(), "deposition_depth");
+          AssertThrow (it == chemical_field_names.end(),
+                       ExcMessage("There is a field deposition_depth that is of type chemical composition. "
+                                  "Please change it to type generic so that it does not affect material properties."));
+        }
+
+      // Initialize parameters for restarting FastScape
+      restart = this->get_parameters().resume_computation;
+
+      // Since we don't open these until we're on one process, we need to check if the
+      // restart files exist beforehand.
+      if (restart)
+        {
+          if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+            {
+              AssertThrow(Utilities::fexists(this->get_output_directory() + "fastscape_elevation_restart.txt"),
+                          ExcMessage("Cannot open topography file to restart FastScape."));
+              AssertThrow(Utilities::fexists(this->get_output_directory() + "fastscape_basement_restart.txt"),
+                          ExcMessage("Cannot open basement file to restart FastScape."));
+              AssertThrow(Utilities::fexists(this->get_output_directory() + "fastscape_silt_fraction_restart.txt"),
+                          ExcMessage("Cannot open silt fraction file to restart FastScape."));
+            }
+        }
+
+      // The first entry represents the minimum coordinates of the model domain, the second the model extent.
+      for (unsigned int d=0; d<dim; ++d)
+        {
+          grid_extent[d].first = geometry->get_origin()[d];
+          grid_extent[d].second = geometry->get_extents()[d];
+        }
+
+      // Get the x and y repetitions used in the parameter file so
+      // the FastScape cell size can be properly set.
+      const std::array<unsigned int, dim> repetitions = geometry->get_repetitions();
+
+      // Set number of x points, which is generally 1+(FastScape refinement level)^2.
+      // The FastScape refinement level is a combination of the maximum ASPECT refinement level
+      // at the surface and any additional refinement we want in FastScape. If
+      // repetitions are specified we need to adjust the number of points to match what ASPECT has,
+      // which can be determined by multiplying the points by the repetitions before adding 1.
+      // Finally, if ghost nodes are used we add two additional points on each side.
+      const unsigned int ghost_nodes = 2*use_ghost_nodes;
+      const unsigned int fastscape_refinement_level = maximum_surface_refinement_level + additional_refinement_levels;
+      const unsigned int fastscape_nodes = std::pow(2,fastscape_refinement_level);
+      fastscape_nx = fastscape_nodes * repetitions[0] + ghost_nodes + 1;
+
+      // Size of FastScape cell.
+      fastscape_dx = (grid_extent[0].second)/(fastscape_nodes * repetitions[0]);
+
+      // FastScape X extent, which is generally ASPECT's extent unless the ghost nodes are used,
+      // in which case 2 cells are added on either side.
+      fastscape_x_extent = (grid_extent[0].second) + fastscape_dx * ghost_nodes;
+
+      // Sub intervals are 3 less than points, if including the ghost nodes. Otherwise 1 less.
+      table_intervals[0] = fastscape_nodes * repetitions[0];
+      table_intervals[dim-1] = 1;
+
+      if (dim == 2)
+        {
+          fastscape_dy = fastscape_dx;
+          fastscape_y_extent = round(fastscape_y_extent_2d/fastscape_dy)*fastscape_dy + fastscape_dy * ghost_nodes;
+          fastscape_ny = 1+fastscape_y_extent/fastscape_dy;
+        }
+      else
+        {
+          fastscape_ny = fastscape_nodes * repetitions[1] + ghost_nodes + 1;
+          fastscape_dy = (grid_extent[1].second)/(fastscape_nodes * repetitions[1]);
+          table_intervals[1] = fastscape_nodes * repetitions[1];
+          fastscape_y_extent = (grid_extent[1].second) + fastscape_dy * ghost_nodes;
+        }
+
+      // Create a folder for the FastScape visualization files.
+      Utilities::create_directory (this->get_output_directory() + "fastscape/",
+                                   this->get_mpi_communicator(),
+                                   false);
+
+      last_output_time = 0;
+    }
+
+
+    template <int dim>
+    void
+    FastScape<dim>::compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                             AffineConstraints<double> &mesh_velocity_constraints,
+                                                             const std::set<types::boundary_id> &boundary_ids) const
+    {
+
+      // Because there is no increase in time during timestep 0, we return and only
+      // initialize and run FastScape from timestep 1 and on.
+      if (this->get_timestep_number() == 0)
+        return;
+
+      TimerOutput::Scope timer_section(this->get_computing_timer(), "FastScape plugin");
+
+      const unsigned int current_timestep = this->get_timestep_number ();
+      const double aspect_timestep_in_years = this->get_timestep() / year_in_seconds;
+
+      // Find a FastScape timestep that is below our maximum timestep.
+      unsigned int fastscape_iterations = fastscape_steps_per_aspect_step;
+      double fastscape_timestep_in_years = aspect_timestep_in_years/fastscape_iterations;
+      while (fastscape_timestep_in_years>maximum_fastscape_timestep)
+        {
+          fastscape_iterations *= 2;
+          fastscape_timestep_in_years *= 0.5;
+        }
+
+      // Vector to hold the velocities that represent the change to the surface.
+      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
+      std::vector<double> mesh_velocity_z(fastscape_array_size);
+
+      // FastScape requires multiple specially defined and ordered variables sent to its functions. To make
+      // the transfer of these down to one process easier, we first fill out a vector of local_aspect_values,
+      // then when we get down to one process we use these local_aspect_values to fill the double arrays
+      // in the order needed for FastScape.
+      std::vector<std::vector<double>> local_aspect_values = get_aspect_values();
+
+      // Run FastScape on single process.
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          // Initialize the variables that will be sent to FastScape.
+          // Elevation is initialized at a very high number so that we can later check that all points
+          // received data from ASPECT, and if not throw an assert.
+          std::vector<double> elevation(fastscape_array_size, std::numeric_limits<double>::max());
+          std::vector<double> velocity_x(fastscape_array_size);
+          std::vector<double> velocity_y(fastscape_array_size);
+          std::vector<double> velocity_z(fastscape_array_size);
+          std::vector<double> bedrock_river_incision_rate_array(fastscape_array_size);
+          std::vector<double> bedrock_transport_coefficient_array(fastscape_array_size);
+          std::vector<double> basement(fastscape_array_size);
+          std::vector<double> silt_fraction(fastscape_array_size);
+          std::vector<double> elevation_old(fastscape_array_size);
+
+          fill_fastscape_arrays(elevation,
+                                bedrock_transport_coefficient_array,
+                                bedrock_river_incision_rate_array,
+                                velocity_x,
+                                velocity_y,
+                                velocity_z,
+                                local_aspect_values);
+
+          if (current_timestep == 1 || restart)
+            {
+              this->get_pcout() << "   Initializing FastScape... " << (1+maximum_surface_refinement_level+additional_refinement_levels) <<
+                                " levels, cell size: " << fastscape_dx << " m." << std::endl;
+
+              // Set ghost nodes before initializing.
+              if (use_ghost_nodes && !restart)
+                set_ghost_nodes(elevation,
+                                velocity_x,
+                                velocity_y,
+                                velocity_z,
+                                fastscape_timestep_in_years,
+                                true);
+
+              // If we are restarting from a checkpoint, load h values for FastScape instead of using the ASPECT values.
+              if (restart)
+                {
+                  read_restart_files(elevation,
+                                     basement,
+                                     silt_fraction);
+
+                  restart = false;
+                }
+
+              initialize_fastscape(elevation,
+                                   basement,
+                                   bedrock_transport_coefficient_array,
+                                   bedrock_river_incision_rate_array,
+                                   silt_fraction);
+            }
+          else
+            {
+              // If it isn't the first timestep we ignore initialization and instead copy all height values from FastScape.
+              // Generally, we overwrite the topography data from ASPECT as FastScape may be at a higher resolution. However,
+              // if we are not using FastScape to advect then we do not want to do this and instead use the ASPECT values.
+              if (fastscape_advection_uplift)
+                fastscape_copy_h_(elevation.data());
+            }
+
+          // Find the appropriate sediment rain based off the time interval.
+          const double time_in_years = this->get_time() / year_in_seconds;
+          auto it = std::lower_bound(sediment_rain_times.begin(), sediment_rain_times.end(), time_in_years);
+          const unsigned int inds = std::distance(sediment_rain_times.begin(), it);
+          const double sediment_rain = sediment_rain_rates[inds];
+
+          // Keep initial h values so we can calculate velocity later.
+          // In the first timestep, h will be given from other processes.
+          // In later timesteps, we copy h directly from FastScape.
+          std::mt19937 random_number_generator(fastscape_seed);
+          std::uniform_real_distribution<double> random_distribution(-noise_elevation,noise_elevation);
+          for (unsigned int i=0; i<fastscape_array_size; ++i)
+            {
+              elevation_old[i] = elevation[i];
+
+              // Initialize random noise after elevation_old is set, so ASPECT sees this initial topography change.
+              // Changing boundary height directly on a fixed FastScape boundary causes reproducibility issues,
+              // as such we do not add noise to the boundaries regardless of whether they are ghost nodes
+              // or not. However, the boundaries can be changed using the uplift velocity and not cause
+              // these issues.
+              // TODO: Should this be done through velocities instead of a flat height change?
+              if (!is_ghost_node(i,true))
+                {
+                  if (current_timestep == 1)
+                    {
+                      // + or - topography based on the initial noise magnitude.
+                      const double elevation_seed = random_distribution(random_number_generator);
+                      elevation[i] = elevation[i] + elevation_seed;
+                    }
+
+                  // Here we add the sediment rain (m/yr) as a flat increase in height.
+                  // This is done because adding it as an uplift rate would affect the basement.
+                  if (sediment_rain > 0 && use_marine_component)
+                    {
+                      // Only apply sediment rain to areas below sea level.
+                      if (elevation[i] < sea_level)
+                        {
+                          // If the rain would put us above sea level, set height to sea level.
+                          if (elevation[i] + sediment_rain*aspect_timestep_in_years > sea_level)
+                            elevation[i] = sea_level;
+                          else
+                            elevation[i] = std::min(sea_level,elevation[i] + sediment_rain*aspect_timestep_in_years);
+                        }
+                    }
+                }
+            }
+
+          // The ghost nodes are added as a single layer of points surrounding the entire model.
+          // For example, if ASPECT's surface mesh is a 2D surface that is 3x3 (nx x ny) points,
+          // FastScape will be set as a 2D 5x5 point surface. On return to ASPECT, the outer ghost nodes
+          // will be ignored, and ASPECT will see only the inner 3x3 surface of FastScape.
+          if (use_ghost_nodes)
+            set_ghost_nodes(elevation,
+                            velocity_x,
+                            velocity_y,
+                            velocity_z,
+                            fastscape_timestep_in_years,
+                            false);
+
+          // If specified, apply the orographic controls to the FastScape model.
+          if (use_orographic_controls)
+            apply_orographic_controls(elevation,
+                                      bedrock_transport_coefficient_array,
+                                      bedrock_river_incision_rate_array);
+
+          // Set velocity components.
+          if (fastscape_advection_uplift)
+            {
+              fastscape_set_u_(velocity_z.data());
+              fastscape_set_v_(velocity_x.data(),
+                               velocity_y.data());
+            }
+
+          // Set h to new values, and erosional parameters if there have been changes.
+          fastscape_set_h_(elevation.data());
+
+          fastscape_set_erosional_parameters_(bedrock_river_incision_rate_array.data(),
+                                              &sediment_river_incision_rate,
+                                              &drainage_area_exponent_m,
+                                              &slope_exponent_n,
+                                              bedrock_transport_coefficient_array.data(),
+                                              &sediment_transport_coefficient,
+                                              &bedrock_deposition_g,
+                                              &sediment_deposition_g,
+                                              &slope_exponent_p);
+
+          // Find timestep size, run FastScape, and make visualizations.
+          execute_fastscape(elevation,
+                            bedrock_transport_coefficient_array,
+                            velocity_x,
+                            velocity_y,
+                            velocity_z,
+                            fastscape_timestep_in_years,
+                            fastscape_iterations);
+
+          // Write a file to store h, b & step for restarting.
+          // TODO: It would be good to roll this into the general ASPECT checkpointing,
+          // and when we do this needs to be changed.
+          if (((this->get_parameters().checkpoint_time_secs == 0) &&
+               (this->get_parameters().checkpoint_steps > 0) &&
+               ((current_timestep + 1) % this->get_parameters().checkpoint_steps == 0)) ||
+              (this->get_time() == this->get_end_time() && this->get_timestepping_manager().need_checkpoint_on_terminate()))
+            {
+              save_restart_files(elevation,
+                                 basement,
+                                 silt_fraction);
+            }
+
+          // Find out our velocities from the change in height.
+          // Where mesh_velocity_z is a vector of array size that exists on all processes.
+          for (unsigned int i=0; i<fastscape_array_size; ++i)
+            {
+              mesh_velocity_z[i] = (elevation[i] - elevation_old[i])/aspect_timestep_in_years;
+            }
+
+          Utilities::MPI::broadcast(this->get_mpi_communicator(), mesh_velocity_z, 0);
+        }
+      else
+        {
+          for (unsigned int i=0; i<local_aspect_values.size(); ++i)
+            MPI_Ssend(&local_aspect_values[i][0], local_aspect_values[1].size(), MPI_DOUBLE, 0, 42, this->get_mpi_communicator());
+
+          // Check whether the FastScape mesh was filled with data.
+          const bool fastscape_mesh_filled = Utilities::MPI::broadcast (this->get_mpi_communicator(), true, 0);
+          if (fastscape_mesh_filled != true)
+            throw aspect::QuietException();
+
+          // This is called solely so we can set the timer and will return immediately.
+          execute_fastscape(mesh_velocity_z,
+                            mesh_velocity_z,
+                            mesh_velocity_z,
+                            mesh_velocity_z,
+                            mesh_velocity_z,
+                            aspect_timestep_in_years,
+                            fastscape_steps_per_aspect_step);
+
+          mesh_velocity_z = Utilities::MPI::broadcast(this->get_mpi_communicator(), mesh_velocity_z, 0);
+        }
+
+      // Get the sizes needed for a data table of the mesh velocities.
+      TableIndices<dim> size_idx;
+      for (unsigned int d=0; d<dim; ++d)
+        {
+          size_idx[d] = table_intervals[d]+1;
+        }
+
+      // Initialize a table to hold all velocity values that will be interpolated back to ASPECT.
+      const Table<dim,double> velocity_table = fill_data_table(mesh_velocity_z, size_idx, fastscape_nx, fastscape_ny);
+
+      // As our grid_extent variable end points do not account for the change related to an origin
+      // not at 0, we adjust this here into an interpolation extent.
+      std::array<std::pair<double,double>,dim> interpolation_extent;
+      for (unsigned int d=0; d<dim; ++d)
+        {
+          interpolation_extent[d].first = grid_extent[d].first;
+          interpolation_extent[d].second = (grid_extent[d].second + grid_extent[d].first);
+        }
+
+      //Functions::InterpolatedUniformGridData<dim> *velocities;
+      Functions::InterpolatedUniformGridData<dim> velocities (interpolation_extent,
+                                                              table_intervals,
+                                                              velocity_table);
+
+      VectorFunctionFromScalarFunctionObject<dim> vector_function_object(
+        [&](const Point<dim> &p) -> double
+      {
+        return velocities.value(p);
+      },
+      dim-1,
+      dim);
+
+      VectorTools::interpolate_boundary_values (mesh_deformation_dof_handler,
+                                                *boundary_ids.begin(),
+                                                vector_function_object,
+                                                mesh_velocity_constraints);
+    }
+
+
+    template <int dim>
+    std::vector<std::vector<double>>
+    FastScape<dim>::get_aspect_values() const
+    {
+
+      const types::boundary_id relevant_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id ("top");
+      std::vector<std::vector<double>> local_aspect_values(dim+2, std::vector<double>());
+
+      // Get a quadrature rule that exists only on the corners, and increase the refinement if specified.
+      const QIterated<dim-1> face_corners (QTrapezoid<1>(),
+                                           std::pow(2,additional_refinement_levels+surface_refinement_difference));
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        face_corners,
+                                        update_values |
+                                        update_quadrature_points);
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          for (unsigned int face_no = 0; face_no < GeometryInfo<dim>::faces_per_cell; ++face_no)
+            if (cell->face(face_no)->at_boundary())
+              {
+                if ( cell->face(face_no)->boundary_id() != relevant_boundary)
+                  continue;
+
+                std::vector<Tensor<1,dim>> vel(face_corners.size());
+                fe_face_values.reinit(cell, face_no);
+                fe_face_values[this->introspection().extractors.velocities].get_function_values(this->get_solution(), vel);
+
+                for (unsigned int corner = 0; corner < face_corners.size(); ++corner)
+                  {
+                    const Point<dim> vertex = fe_face_values.quadrature_point(corner);
+
+                    // Find what x point we're at. Add 1 or 2 depending on if ghost nodes are used.
+                    // Subtract the origin point so that it corresponds to an origin of 0,0 in FastScape.
+                    const double indx = 1+use_ghost_nodes+(vertex(0) - grid_extent[0].first)/fastscape_dx;
+
+                    // The quadrature rule is created so that there are enough interpolation points in the
+                    // lowest resolved ASPECT surface cell to fill out the FastScape mesh. However, as the
+                    // same rule is used for all cell sizes, higher resolution areas will have interpolation
+                    // points that do not correspond to a FastScape node. In which case, indx will not be a
+                    // whole number and we can ignore the point.
+                    if (std::abs(indx - round(indx)) >= node_tolerance)
+                      continue;
+
+
+                    // If we're in 2D, we want to take the values and apply them to every row of X points.
+                    if (dim == 2)
+                      {
+                        for (unsigned int ys=0; ys<fastscape_ny; ++ys)
+                          {
+                            // FastScape indexes from 1 to n, starting at X and Y = 0, and increases
+                            // across the X row. At the end of the row, it jumps back to X = 0
+                            // and up to the next X row in increasing Y direction. We track
+                            // this to correctly place the variables later on.
+                            // Nx*ys effectively tells us what row we are in
+                            // and then indx tells us what position in that row.
+                            const double index = round(indx)+fastscape_nx*ys;
+
+                            local_aspect_values[0].push_back(vertex(dim-1) - grid_extent[dim-1].second);
+                            local_aspect_values[1].push_back(index-1);
+
+                            for (unsigned int d=0; d<dim; ++d)
+                              {
+                                // Always convert to m/yr for FastScape
+                                local_aspect_values[2+d].push_back(vel[corner][d]*year_in_seconds);
+                              }
+                          }
+                      }
+                    // 3D case
+                    else
+                      {
+                        // Because indy only gives us the row we're in, we don't need to add 2 for the ghost node.
+                        const double indy = 1+use_ghost_nodes+(vertex(1) - grid_extent[1].first)/fastscape_dy;
+
+                        if (std::abs(indy - round(indy)) >= node_tolerance)
+                          continue;
+
+                        const double index = round((indy-1))*fastscape_nx+round(indx);
+
+                        local_aspect_values[0].push_back(vertex(dim-1) - grid_extent[dim-1].second);   //z component
+                        local_aspect_values[1].push_back(index-1);
+
+                        for (unsigned int d=0; d<dim; ++d)
+                          {
+                            local_aspect_values[2+d].push_back(vel[corner][d]*year_in_seconds);
+                          }
+                      }
+                  }
+              }
+
+      return local_aspect_values;
+    }
+
+
+    template <int dim>
+    void FastScape<dim>::fill_fastscape_arrays(std::vector<double> &elevation,
+                                               std::vector<double> &bedrock_transport_coefficient_array,
+                                               std::vector<double> &bedrock_river_incision_rate_array,
+                                               std::vector<double> &velocity_x,
+                                               std::vector<double> &velocity_y,
+                                               std::vector<double> &velocity_z,
+                                               std::vector<std::vector<double>> &local_aspect_values) const
+    {
+      for (unsigned int i=0; i<local_aspect_values[1].size(); ++i)
+        {
+
+          unsigned int index = local_aspect_values[1][i];
+          elevation[index] = local_aspect_values[0][i];
+          velocity_x[index] = local_aspect_values[2][i];
+          velocity_z[index] = local_aspect_values[dim+1][i];
+
+          if (dim == 2)
+            velocity_y[index] = 0;
+          else
+            velocity_y[index] = local_aspect_values[3][i];
+        }
+
+      for (unsigned int p=1; p<Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()); ++p)
+        {
+          // First, find out the size of the array a process wants to send.
+          MPI_Status status;
+          MPI_Probe(p, 42, this->get_mpi_communicator(), &status);
+          int incoming_size = 0;
+          MPI_Get_count(&status, MPI_DOUBLE, &incoming_size);
+
+          // Resize the array so it fits whatever the process sends.
+          for (unsigned int i=0; i<local_aspect_values.size(); ++i)
+            {
+              local_aspect_values[i].resize(incoming_size);
+            }
+
+          for (unsigned int i=0; i<local_aspect_values.size(); ++i)
+            MPI_Recv(&local_aspect_values[i][0], incoming_size, MPI_DOUBLE, p, 42, this->get_mpi_communicator(), &status);
+
+          // Now, place the numbers into the correct place based off the index.
+          for (unsigned int i=0; i<local_aspect_values[1].size(); ++i)
+            {
+              const unsigned int index = local_aspect_values[1][i];
+              elevation[index] = local_aspect_values[0][i];
+              velocity_x[index] = local_aspect_values[2][i];
+              velocity_z[index] = local_aspect_values[dim+1][i];
+
+              // In 2D there are no y velocities, so we set them to zero.
+              if (dim == 2 )
+                velocity_y[index] = 0;
+              else
+                velocity_y[index] = local_aspect_values[3][i];
+            }
+        }
+
+      // Initialize the bedrock river incision rate and transport coefficient,
+      // and check that there are no empty mesh points due to
+      // an improperly set maximum_surface_refinement_level, additional_refinement_levels,
+      // and surface_refinement_difference
+      bool fastscape_mesh_filled = true;
+      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
+      for (unsigned int i=0; i<fastscape_array_size; ++i)
+        {
+          bedrock_river_incision_rate_array[i] = bedrock_river_incision_rate;
+          bedrock_transport_coefficient_array[i] = bedrock_transport_coefficient;
+
+          // If this is a boundary node that is a ghost node then ignore that it
+          // has not filled yet as the ghost nodes haven't been set.
+          if (elevation[i] == std::numeric_limits<double>::max() && !is_ghost_node(i,false))
+            fastscape_mesh_filled = false;
+        }
+
+      Utilities::MPI::broadcast(this->get_mpi_communicator(), fastscape_mesh_filled, 0);
+      AssertThrow (fastscape_mesh_filled == true,
+                   ExcMessage("The FastScape mesh is missing data. A likely cause for this is that the "
+                              "maximum surface refinement or surface refinement difference are improperly set."));
+    }
+
+
+    template <int dim>
+    void FastScape<dim>::initialize_fastscape(std::vector<double> &elevation,
+                                              std::vector<double> &basement,
+                                              std::vector<double> &bedrock_transport_coefficient_array,
+                                              std::vector<double> &bedrock_river_incision_rate_array,
+                                              std::vector<double> &silt_fraction) const
+    {
+      Assert (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0, ExcInternalError());
+
+      const unsigned int current_timestep = this->get_timestep_number ();
+
+      // Initialize FastScape with grid and extent.
+      fastscape_init_();
+      fastscape_set_nx_ny_(&fastscape_nx,
+                           &fastscape_ny);
+      fastscape_setup_();
+      fastscape_set_xl_yl_(&fastscape_x_extent,
+                           &fastscape_y_extent);
+
+      // Set boundary conditions
+      fastscape_set_bc_(&fastscape_boundary_conditions);
+
+      // Initialize topography
+      fastscape_init_h_(elevation.data());
+
+      // Set erosional parameters.
+      fastscape_set_erosional_parameters_(bedrock_river_incision_rate_array.data(),
+                                          &sediment_river_incision_rate,
+                                          &drainage_area_exponent_m,
+                                          &slope_exponent_n,
+                                          bedrock_transport_coefficient_array.data(),
+                                          &sediment_transport_coefficient,
+                                          &bedrock_deposition_g,
+                                          &sediment_deposition_g,
+                                          &slope_exponent_p);
+
+      if (use_marine_component)
+        fastscape_set_marine_parameters_(&sea_level,
+                                         &sand_surface_porosity,
+                                         &silt_surface_porosity,
+                                         &sand_efold_depth,
+                                         &silt_efold_depth,
+                                         &sand_silt_ratio,
+                                         &sand_silt_averaging_depth,
+                                         &sand_transport_coefficient,
+                                         &silt_transport_coefficient);
+
+      // Only set the basement and silt_fraction if it's a restart
+      if (current_timestep != 1)
+        {
+          fastscape_set_basement_(basement.data());
+          if (use_marine_component)
+            fastscape_init_f_(silt_fraction.data());
+        }
+
+    }
+
+
+    template <int dim>
+    void FastScape<dim>::execute_fastscape(std::vector<double> &elevation,
+                                           std::vector<double> &extra_vtk_field,
+                                           std::vector<double> &velocity_x,
+                                           std::vector<double> &velocity_y,
+                                           std::vector<double> &velocity_z,
+                                           const double &fastscape_timestep_in_years,
+                                           const unsigned int &fastscape_iterations) const
+    {
+      TimerOutput::Scope timer_section(this->get_computing_timer(), "Execute FastScape");
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) != 0)
+        return;
+
+      // Because on the first timestep we will create an initial VTK file before running FastScape
+      // and a second after, we first set the visualization step to zero.
+      unsigned int visualization_step = 0;
+      const unsigned int current_timestep = this->get_timestep_number ();
+      std::string dirname = (this->get_output_directory() + "fastscape/");
+      const char *dirname_char=dirname.c_str();
+      const unsigned int dirname_length = dirname.length();
+
+      // Set time step
+      fastscape_set_dt_(&fastscape_timestep_in_years);
+      this->get_pcout() << "   Executing FastScape... " << (fastscape_iterations) << " timesteps of " << fastscape_timestep_in_years << " years." << std::endl;
+      {
+        // If it is the first timestep, write an initial VTK file.
+        if (current_timestep == 1)
+          {
+            this->get_pcout() << "      Writing initial VTK..." << std::endl;
+            // FastScape by default visualizes a field called HHHHH,
+            // and the parameter this shows will be whatever is given as the first
+            // position. At the moment it visualizes the bedrock diffusivity.
+            fastscape_named_vtk_(extra_vtk_field.data(),
+                                 &vexp,
+                                 &visualization_step,
+                                 dirname_char,
+                                 &dirname_length);
+          }
+
+        for (unsigned int fastscape_iteration = 0; fastscape_iteration < fastscape_iterations; ++fastscape_iteration)
+          {
+            fastscape_execute_step_();
+
+            // If we are using the ghost nodes we want to reset them every FastScape timestep.
+            if (use_ghost_nodes)
+              {
+                fastscape_copy_h_(elevation.data());
+
+                set_ghost_nodes(elevation,
+                                velocity_x,
+                                velocity_y,
+                                velocity_z,
+                                fastscape_timestep_in_years,
+                                false);
+
+                // Set velocity components.
+                if (fastscape_advection_uplift)
+                  {
+                    fastscape_set_u_(velocity_z.data());
+                    fastscape_set_v_(velocity_x.data(),
+                                     velocity_y.data());
+                  }
+
+                // Set h to new values, and erosional parameters if there have been changes.
+                fastscape_set_h_(elevation.data());
+              }
+          }
+
+        // Copy h values.
+        fastscape_copy_h_(elevation.data());
+
+
+        // Determine whether to create a VTK file this timestep.
+        bool write_vtk = false;
+
+        if (this->get_time() >= last_output_time + output_interval || this->get_time() == this->get_end_time())
+          {
+            write_vtk = true;
+
+            if (output_interval > 0)
+              {
+                // We need to find the last time output was supposed to be written.
+                // this is the last_output_time plus the largest positive multiple
+                // of output_intervals that passed since then. We need to handle the
+                // edge case where last_output_time+output_interval==current_time,
+                // we did an output and std::floor sadly rounds to zero. This is done
+                // by forcing std::floor to round 1.0-eps to 1.0.
+                const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+                last_output_time = last_output_time + std::floor((this->get_time()-last_output_time)/output_interval*magic) * output_interval/magic;
+              }
+          }
+
+        if (write_vtk)
+          {
+            this->get_pcout() << "      Writing FastScape VTK..." << std::endl;
+            visualization_step = current_timestep;
+            fastscape_named_vtk_(extra_vtk_field.data(),
+                                 &vexp,
+                                 &visualization_step,
+                                 dirname_char,
+                                 &dirname_length);
+          }
+      }
+    }
+
+
+    template <int dim>
+    void FastScape<dim>::apply_orographic_controls(const std::vector<double> &elevation,
+                                                   std::vector<double> &bedrock_transport_coefficient_array,
+                                                   std::vector<double> &bedrock_river_incision_rate_array) const
+    {
+      // First for the wind barrier, we find the maximum height and index
+      // along each line in the x and y direction.
+      // If wind is east or west, we find maximum point for each ny row along x.
+      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
+      std::vector<std::vector<double>> max_elevation_along_x(2, std::vector<double>(fastscape_ny, 0.0));
+      if (wind_direction == 0 || wind_direction == 1)
+        {
+          for (unsigned int i=0; i<fastscape_ny; ++i)
+            {
+              for (unsigned int j=0; j<fastscape_nx; ++j)
+                {
+                  if ( elevation[fastscape_nx*i+j] > max_elevation_along_x[0][i])
+                    {
+                      // Maximum elevation value along the ny row.
+                      max_elevation_along_x[0][i] = elevation[fastscape_nx*i+j];
+                      // Location of maximum elevation.
+                      max_elevation_along_x[1][i] = j;
+                    }
+                }
+            }
+        }
+
+      // If wind is north or south, we find maximum point for each nx row along y.
+      std::vector<std::vector<double>> max_elevation_along_y(2, std::vector<double>(fastscape_nx, 0.0));
+      if (wind_direction == 2 || wind_direction == 3)
+        {
+          for (unsigned int i=0; i<fastscape_nx; ++i)
+            {
+              for (unsigned int j=0; j<fastscape_ny; ++j)
+                {
+                  if ( elevation[fastscape_nx*j+i] > max_elevation_along_y[0][i])
+                    {
+                      max_elevation_along_y[0][i] = elevation[fastscape_nx*j+i];
+                      max_elevation_along_y[1][i] = j;
+                    }
+                }
+            }
+        }
+
+      // Now we loop through all the points again and apply the factors.
+      std::vector<double> control_applied(fastscape_array_size, 0);
+      for (unsigned int i=0; i<fastscape_ny; ++i)
+        {
+          // Factor from wind barrier. Apply a switch based off wind direction.
+          // Where 0 is wind going to the west, 1 the east, 2 the south, and 3 the north.
+          for (unsigned int j=0; j<fastscape_nx; ++j)
+            {
+              switch (wind_direction)
+                {
+                  case 0 :
+                  {
+                    // If we are above the set elevation, and on the correct side based on the wind direction apply
+                    // the factor. Apply this regardless of whether or not we stack controls.
+                    if ( (max_elevation_along_x[0][i] > wind_barrier_elevation) && (j < max_elevation_along_x[1][i]) )
+                      {
+                        bedrock_river_incision_rate_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
+                        bedrock_transport_coefficient_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
+                        control_applied[fastscape_nx*i+j] = 1;
+                      }
+                    break;
+                  }
+                  case 1 :
+                  {
+                    if ( (max_elevation_along_x[0][i] > wind_barrier_elevation) && (j > max_elevation_along_x[1][i]) )
+                      {
+                        bedrock_river_incision_rate_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
+                        bedrock_transport_coefficient_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
+                        control_applied[fastscape_nx*i+j] = 1;
+                      }
+                    break;
+                  }
+                  case 2 :
+                  {
+                    if ( (max_elevation_along_y[0][j] > wind_barrier_elevation) && (i > max_elevation_along_y[1][j]) )
+                      {
+                        bedrock_river_incision_rate_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
+                        bedrock_transport_coefficient_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
+                        control_applied[fastscape_nx*i+j] = 1;
+                      }
+                    break;
+                  }
+                  case 3 :
+                  {
+                    if ( (max_elevation_along_y[0][j] > wind_barrier_elevation) && (i < max_elevation_along_y[1][j]) )
+                      {
+                        bedrock_river_incision_rate_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
+                        bedrock_transport_coefficient_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
+                        control_applied[fastscape_nx*i+j] = 1;
+                      }
+                    break;
+                  }
+                  default :
+                    AssertThrow(false, ExcMessage("This does not correspond with a wind direction."));
+                    break;
+                }
+
+              // If we are above the flat elevation and stack controls, apply the flat elevation factor. If we are not
+              // stacking controls, apply the factor if the wind barrier was not applied to this point.
+              if (elevation[fastscape_nx*i+j] > flat_elevation)
+                {
+                  if ( stack_controls==true || !stack_controls && (control_applied[fastscape_nx*i+j]==0) )
+                    {
+                      bedrock_river_incision_rate_array[fastscape_nx*i+j] *= flat_erosional_factor;
+                      bedrock_transport_coefficient_array[fastscape_nx*i+j] *= flat_erosional_factor;
+                    }
+                  // If we are not stacking controls and the wind barrier was applied to this point, only
+                  // switch to this control if the factor is greater.
+                  else if ( stack_controls==false && (control_applied[fastscape_nx*i+j]==1) && (flat_erosional_factor > wind_barrier_erosional_factor) )
+                    {
+                      if ( wind_barrier_erosional_factor != 0)
+                        {
+                          bedrock_river_incision_rate_array[fastscape_nx*i+j] = (bedrock_river_incision_rate_array[fastscape_nx*i+j]/wind_barrier_erosional_factor)*flat_erosional_factor;
+                          bedrock_transport_coefficient_array[fastscape_nx*i+j] = (bedrock_transport_coefficient_array[fastscape_nx*i+j]/wind_barrier_erosional_factor)*flat_erosional_factor;
+                        }
+                      // If a wind barrier factor of zero was applied for some reason, we set it back to the default
+                      // and apply the flat_erosional_factor.
+                      else
+                        {
+                          bedrock_river_incision_rate_array[fastscape_nx*i+j] = bedrock_river_incision_rate*flat_erosional_factor;
+                          bedrock_transport_coefficient_array[fastscape_nx*i+j] = bedrock_transport_coefficient*flat_erosional_factor;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    template <int dim>
+    void FastScape<dim>::set_ghost_nodes(std::vector<double> &elevation,
+                                         std::vector<double> &velocity_x,
+                                         std::vector<double> &velocity_y,
+                                         std::vector<double> &velocity_z,
+                                         const double &fastscape_timestep_in_years,
+                                         const bool init) const
+    {
+      // Copy the slopes at each point, this will be used to set an H
+      // at the ghost nodes if a boundary mass flux is given.
+      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
+      std::vector<double> slopep(fastscape_array_size);
+
+      if (!init)
+        fastscape_copy_slope_(slopep.data());
+
+      // Here we set the ghost nodes at the left and right boundaries. In most cases,
+      // this involves setting the node to the same values of v and h as the inward node.
+      // With the inward node being above or below for the bottom and top rows of ghost nodes,
+      // or to the left and right for the right and left columns of ghost nodes.
+      for (unsigned int j=0; j<fastscape_ny; ++j)
+        {
+          // Nx*j will give us the row we're in, and one is subtracted as FastScape starts from 1 not zero.
+          // If we're on the left, the multiple of the row will always represent the first node.
+          // Subtracting one from the row above this gives us the last node of the previous row.
+          const unsigned int index_left = fastscape_nx*j;
+          const unsigned int index_right = fastscape_nx*(j+1)-1;
+          double slope = 0;
+
+          // Here we set the ghost nodes to the value of the nodes next to them, where for the left we
+          // add one to go to the node to the right, and for the right side
+          // we subtract one to go to the inner node to the left.
+          // For velocities, this is done whether it is the call before
+          // initialization or not.
+          if (left == 0 || !use_fixed_erosional_base)
+            {
+              velocity_z[index_left] = velocity_z[index_left+1];
+              velocity_y[index_left] = velocity_y[index_left+1];
+              velocity_x[index_left] = velocity_x[index_left+1];
+            }
+
+          if (right == 0 || !use_fixed_erosional_base)
+            {
+              velocity_z[index_right] = velocity_z[index_right-1];
+              velocity_y[index_right] = velocity_y[index_right-1];
+              velocity_x[index_right] = velocity_x[index_right-1];
+            }
+
+          if (init)
+            {
+              // We need to set h on initialization. If we use a fixed base level we set it to
+              // the user specified base level. If it is open or we do not have a fixed base, we
+              // will set it equal to the node next to it, and finally adjust based on user-defined
+              // influx if necessary. FastScape calculates the slope by looking at all
+              // nodes surrounding the point so we need to consider the slope over 2 dx.
+              slope = left_flux/bedrock_transport_coefficient;
+              if (left == 1 && use_fixed_erosional_base)
+                elevation[index_left] = h_erosional_base;
+              else
+                elevation[index_left] = elevation[index_left+1] + slope*2*fastscape_dx;
+
+              slope = right_flux/bedrock_transport_coefficient;
+              if (right == 1 && use_fixed_erosional_base)
+                elevation[index_right] = h_erosional_base;
+              else
+                elevation[index_right] = elevation[index_right-1] + slope*2*fastscape_dx;
+            }
+
+          if (left == 0 && !init)
+            {
+              // If it is not the initialization step, we set the h value for open boundaries depending on
+              // whether or not there is prescribed influx.
+              // If we have flux through a boundary, we need to update the height to keep the correct slope.
+              // Because the corner nodes always show a slope of zero, this will update them according to
+              // the closest non-ghost node. E.g. if we're at a corner node, look instead up a row and inward.
+              // If this is no flux, we set the node to the one next to it.
+              if (left_flux > 0)
+                {
+                  slope = 0;
+                  if (j == 0)
+                    slope = left_flux / bedrock_transport_coefficient - std::tan(slopep[index_left + fastscape_nx + 1] * numbers::PI / 180.);
+                  else if (j == (fastscape_ny - 1))
+                    slope = left_flux / bedrock_transport_coefficient - std::tan(slopep[index_left - fastscape_nx + 1] * numbers::PI / 180.);
+                  else
+                    slope = left_flux / bedrock_transport_coefficient - std::tan(slopep[index_left + 1] * numbers::PI / 180.);
+
+                  elevation[index_left] = elevation[index_left] + slope * 2 * fastscape_dx;
+                }
+              else
+                elevation[index_left] = elevation[index_left + 1];
+            }
+
+          if (right == 0 && !init)
+            {
+
+              if (right_flux > 0)
+                {
+                  slope = 0;
+                  if (j == 0)
+                    slope = right_flux / bedrock_transport_coefficient - std::tan(slopep[index_right + fastscape_nx - 1] * numbers::PI / 180.);
+                  else if (j == (fastscape_ny - 1))
+                    slope = right_flux / bedrock_transport_coefficient - std::tan(slopep[index_right - fastscape_nx - 1] * numbers::PI / 180.);
+                  else
+                    slope = right_flux / bedrock_transport_coefficient - std::tan(slopep[index_right - 1] * numbers::PI / 180.);
+
+                  elevation[index_right] = elevation[index_right] + slope * 2 * fastscape_dx;
+                }
+              else
+                elevation[index_right] = elevation[index_right - 1];
+
+
+            }
+
+          // If the boundaries are periodic, then we look at the velocities on both sides of the
+          // model, and set the ghost node according to the direction of flow. As FastScape will
+          // receive all velocities it will have a direction, and we only need to look at the (non-ghost)
+          // nodes directly to the left and right.
+          if (left == 0 && right == 0 || leftright_ghost_nodes_periodic == true)
+            {
+              // First we assume that flow is going to the left.
+              unsigned int side = index_left;
+              unsigned int op_side = index_right;
+
+              // Indexing depending on which side the ghost node is being set to.
+              int jj = 1;
+
+              // If nodes on both sides are going the same direction, then set the respective
+              // ghost nodes to equal these sides. By doing this, the ghost nodes at the opposite
+              // side of flow will work as a mirror mimicking what is happening on the other side.
+              if (velocity_x[index_right-1] > 0 && velocity_x[index_left+1] >= 0)
+                {
+                  side = index_right;
+                  op_side = index_left;
+                  jj = -1;
+                }
+              else if (velocity_x[index_right-1] <= 0 && velocity_x[index_left+1] < 0)
+                {
+                  side = index_left;
+                  op_side = index_right;
+                  jj = 1;
+                }
+              else
+                continue;
+
+              // Now set the nodes for periodic boundaries. As an example, assume we have 9 FastScape nodes in x:
+              //
+              // 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8
+              //
+              // Of these 9 nodes, 0 and 8 are ghost nodes and 1 and 7 are the periodic ASPECT boundaries.
+              // If we assume that the horizontal ASPECT direction of travel is towards node 7, then we would
+              // set the ghost node 8 velocities and heights to that of node 2, ghost node 0 to node 6, and
+              // ASPECT boundary node 1 to ASPECT boundary node 7. E.g., based on the FastScape values for
+              // vx, vy, vz, and elevation, the nodes could be rewritten as:
+              //
+              // 6 - 7 - 2 - 3 - 4 - 5 - 6 - 7 - 2
+              //
+              // This makes it so that effectively both periodic ASPECT boundaries see the same
+              // topography on either side of them to try and make sure they experience the same
+              // amount of diffusion and SPL.
+              velocity_x[index_right] = velocity_x[index_left+2];
+              velocity_y[index_right] = velocity_y[index_left+2];
+              velocity_z[index_right] = velocity_z[index_left+2] + (elevation[index_left+2] - elevation[index_right])/fastscape_timestep_in_years;
+
+              velocity_x[index_left] = velocity_x[index_right-2];
+              velocity_y[index_left] = velocity_y[index_right-2];
+              velocity_z[index_left] = velocity_z[index_right-2] + (elevation[index_right-2] - elevation[index_left])/fastscape_timestep_in_years;
+
+              // Set opposing ASPECT boundary so it's periodic.
+              elevation[op_side-jj] = elevation[side+jj];
+              velocity_x[op_side-jj] = velocity_x[side+jj];
+              velocity_y[op_side-jj] = velocity_y[side+jj];
+              velocity_z[op_side-jj] = velocity_z[side+jj];
+
+            }
+        }
+
+      // Now do the same for the top and bottom ghost nodes.
+      for (unsigned int j=0; j<fastscape_nx; ++j)
+        {
+          // The bottom row indexes are 0 to nx-1.
+          const unsigned int index_bot = j;
+
+          // Nx multiplied by (total rows - 1) gives us the start of
+          // the top row, and j gives the position in the row.
+          const unsigned int index_top = fastscape_nx*(fastscape_ny-1)+j;
+          double slope = 0;
+
+          if (top == 0 || !use_fixed_erosional_base)
+            {
+              velocity_z[index_top] = velocity_z[index_top-fastscape_nx];
+              velocity_y[index_top] = velocity_y[index_top-fastscape_nx];
+              velocity_x[index_top] = velocity_x[index_top-fastscape_nx];
+            }
+
+          if (bottom ==0 || !use_fixed_erosional_base)
+            {
+              velocity_z[index_bot] = velocity_z[index_bot+fastscape_nx];
+              velocity_y[index_bot] = velocity_y[index_bot+fastscape_nx];
+              velocity_x[index_bot] = velocity_x[index_bot+fastscape_nx];
+            }
+
+          if (init)
+            {
+              slope = top_flux / bedrock_transport_coefficient;
+              if (top == 1 && use_fixed_erosional_base)
+                elevation[index_top] = h_erosional_base;
+              else
+                elevation[index_top] = elevation[index_top-fastscape_nx] + slope*2*fastscape_dx;
+
+              slope = bottom_flux / bedrock_transport_coefficient;
+              if (bottom == 1 && use_fixed_erosional_base)
+                elevation[index_bot] = h_erosional_base;
+              else
+                elevation[index_bot] = elevation[index_bot + fastscape_nx] + slope*2*fastscape_dx;
+            }
+
+          if (top == 0 && !init)
+            {
+              if (top_flux > 0)
+                {
+                  slope = 0;
+                  if (j == 0)
+                    slope = top_flux / bedrock_transport_coefficient - std::tan(slopep[index_top - fastscape_nx + 1] * numbers::PI / 180.);
+                  else if (j == (fastscape_nx - 1))
+                    slope = top_flux / bedrock_transport_coefficient - std::tan(slopep[index_top - fastscape_nx - 1] * numbers::PI / 180.);
+                  else
+                    slope = top_flux / bedrock_transport_coefficient - std::tan(slopep[index_top - fastscape_nx] * numbers::PI / 180.);
+
+                  elevation[index_top] = elevation[index_top] + slope * 2 * fastscape_dx;
+                }
+              else
+                elevation[index_top] = elevation[index_top - fastscape_nx];
+            }
+
+          if (bottom == 0 && !init)
+            {
+              if (left_flux > 0)
+                {
+                  slope = 0;
+                  if (j == 0)
+                    slope = bottom_flux / bedrock_transport_coefficient - std::tan(slopep[index_bot + fastscape_nx + 1] * numbers::PI / 180.);
+                  else if (j == (fastscape_nx - 1))
+                    slope = bottom_flux / bedrock_transport_coefficient - std::tan(slopep[index_bot + fastscape_nx - 1] * numbers::PI / 180.);
+                  else
+                    slope = bottom_flux / bedrock_transport_coefficient - std::tan(slopep[index_bot + fastscape_nx] * numbers::PI / 180.);
+
+                  elevation[index_bot] = elevation[index_bot] + slope * 2 * fastscape_dx;
+                }
+              else
+                elevation[index_bot] = elevation[index_bot + fastscape_nx];
+            }
+
+          if (bottom == 0 && top == 0 || topbottom_ghost_nodes_periodic == true)
+            {
+              unsigned int side = index_bot;
+              unsigned int op_side = index_top;
+              int jj = fastscape_nx;
+
+              if (velocity_y[index_bot+fastscape_nx-1] > 0 && velocity_y[index_top-fastscape_nx-1] >= 0)
+                {
+                  side = index_top;
+                  op_side = index_bot;
+                  jj = -fastscape_nx;
+                }
+              else if (velocity_y[index_bot+fastscape_nx-1] <= 0 && velocity_y[index_top-fastscape_nx-1] < 0)
+                {
+                  side = index_bot;
+                  op_side = index_top;
+                  jj = fastscape_nx;
+                }
+              else
+                continue;
+
+              // Set top ghost node
+              velocity_x[index_top] = velocity_x[index_bot + 2*fastscape_nx];
+              velocity_y[index_top] = velocity_y[index_bot + 2*fastscape_nx];
+              velocity_z[index_top] = velocity_z[index_bot + 2*fastscape_nx] + (elevation[index_bot + 2*fastscape_nx] - elevation[index_top])/fastscape_timestep_in_years;
+
+              // Set bottom ghost node
+              velocity_x[index_bot] = velocity_x[index_top - 2*fastscape_nx];
+              velocity_y[index_bot] = velocity_y[index_top - 2*fastscape_nx];
+              velocity_z[index_bot] = velocity_z[index_top - 2*fastscape_nx] + (elevation[index_top - 2*fastscape_nx] - elevation[index_bot])/fastscape_timestep_in_years;
+
+              // Set opposing ASPECT boundary so it's periodic.
+              elevation[op_side-jj] = elevation[side+jj];
+              velocity_x[op_side-jj] = velocity_x[side+jj];
+              velocity_y[op_side-jj] = velocity_y[side+jj];
+              velocity_z[op_side-jj] = velocity_z[side+jj];
+            }
+        }
+    }
+
+    template <int dim>
+    bool FastScape<dim>::is_ghost_node(const unsigned int &index,
+                                       const bool &exclude_boundaries) const
+    {
+      if (use_ghost_nodes == false && exclude_boundaries == false)
+        return false;
+
+      const unsigned int row = index / fastscape_nx; // Calculate the row index
+      const unsigned int col = index % fastscape_nx; // Calculate the column index
+
+      // If we are at a boundary node and ghost nodes are enabled
+      // or we are excluding the boundaries then return true.
+      if (row == 0 || row == fastscape_ny-1 || col == 0 || col == fastscape_nx-1)
+        return true;
+      else
+        return false;
+    }
+
+
+    template <int dim>
+    Table<dim,double>
+    FastScape<dim>::fill_data_table(std::vector<double> &values,
+                                    TableIndices<dim> &size_idx,
+                                    const unsigned int &fastscape_nx,
+                                    const unsigned int &fastscape_ny) const
+    {
+      // Create data table based off of the given size.
+      Table<dim,double> data_table;
+      data_table.TableBase<dim,double>::reinit(size_idx);
+      TableIndices<dim> idx;
+
+      // Loop through the data table and fill it with the velocities from FastScape.
+      if (dim == 2)
+        {
+          std::vector<double> values_2d(fastscape_nx);
+
+          for (unsigned int x=use_ghost_nodes; x<(fastscape_nx-use_ghost_nodes); ++x)
+            {
+              // If we do not average the values, then use a slice near the center.
+              if (!average_out_of_plane_surface_topography)
+                {
+                  const unsigned int index = x+fastscape_nx*(round((fastscape_ny-use_ghost_nodes)/2));
+
+                  // If we are using the ghost nodes, then the x value locations need to be shifted back 1
+                  // e.g., given a 4x4 mesh an index of 5 would correspond to an x of 1 and y of 1 in the loop,
+                  // but should correspond to 0,0 for ASPECT.
+                  values_2d[x-use_ghost_nodes] = values[index];
+                }
+              // Here we use average velocities across the y nodes, excluding the ghost nodes (top and bottom row).
+              // Note: If ghost nodes are turned off, boundary effects may influence this.
+              else
+                {
+                  for (unsigned int y=use_ghost_nodes; y<(fastscape_ny-use_ghost_nodes); ++y)
+                    {
+                      const unsigned int index = x+fastscape_nx*y;
+                      values_2d[x-use_ghost_nodes] += values[index];
+                    }
+                  values_2d[x-use_ghost_nodes] = values_2d[x-use_ghost_nodes]/(fastscape_ny-2*use_ghost_nodes);
+                }
+            }
+
+          for (unsigned int x=0; x<data_table.size()[0]; ++x)
+            {
+              idx[0] = x;
+
+              for (unsigned int y=0; y<(data_table.size()[1]); ++y)
+                {
+                  idx[1] = y;
+
+                  // Convert back to m/s.
+                  data_table(idx) = values_2d[x] / year_in_seconds;
+                }
+            }
+        }
+      else
+        {
+          // Indexes through x, y, and z.
+          for (unsigned int x=0; x<data_table.size()[0]; ++x)
+            {
+              idx[0] = x;
+
+              for (unsigned int y=0; y<data_table.size()[1]; ++y)
+                {
+                  idx[1] = y;
+
+                  for (unsigned int z=0; z<data_table.size()[2]; ++z)
+                    {
+                      idx[2] = z;
+
+                      // Convert back to m/s.
+                      data_table(idx) = values[(fastscape_nx+1)*use_ghost_nodes+fastscape_nx*y+x] / year_in_seconds;
+
+                    }
+                }
+            }
+        }
+
+      return data_table;
+    }
+
+
+
+    template <int dim>
+    void FastScape<dim>::read_restart_files(std::vector<double> &elevation,
+                                            std::vector<double> &basement,
+                                            std::vector<double> &silt_fraction) const
+    {
+      this->get_pcout() << "   Loading FastScape restart file... " << std::endl;
+
+      // Create variables for output directory and restart file
+      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
+      std::string dirname = this->get_output_directory();
+      const std::string restart_filename_elevation = dirname + "fastscape_elevation_restart.txt";
+      const std::string restart_filename_basement = dirname + "fastscape_basement_restart.txt";
+      const std::string restart_filename_silt_fraction = dirname + "fastscape_silt_fraction_restart.txt";
+      const std::string restart_filename_time = dirname + "fastscape_last_output_time.txt";
+
+      // Load in h values.
+      std::ifstream in_elevation(restart_filename_elevation);
+      AssertThrow (in_elevation, ExcIO());
+      {
+        unsigned int line = 0;
+        while (line < fastscape_array_size)
+          {
+            in_elevation >> elevation[line];
+            line++;
+          }
+      }
+
+      // Load in b values.
+      std::ifstream in_basement(restart_filename_basement);
+      AssertThrow (in_basement, ExcIO());
+      {
+        unsigned int line = 0;
+        while (line < fastscape_array_size)
+          {
+            in_basement >> basement[line];
+            line++;
+          }
+      }
+
+      // Load in silt_fraction values if
+      // marine sediment transport and deposition is active.
+      if (use_marine_component)
+        {
+          std::ifstream in_silt_fraction(restart_filename_silt_fraction);
+          AssertThrow (in_silt_fraction, ExcIO());
+
+          if (sand_surface_porosity > 0. || silt_surface_porosity > 0.)
+            this->get_pcout() << "   Restarting runs with nonzero porosity can lead to a different system after restart. " << std::endl;
+          unsigned int line = 0;
+          while (line < fastscape_array_size)
+            {
+              in_silt_fraction >> silt_fraction[line];
+              line++;
+            }
+        }
+
+      // Now load the last output at time of restart.
+      // this allows us to correctly track when to call
+      // FastScape to make new VTK files.
+      std::ifstream in_last_output_time(restart_filename_time);
+      AssertThrow (in_last_output_time, ExcIO());
+      {
+        in_last_output_time >> last_output_time;
+      }
+    }
+
+    template <int dim>
+    void FastScape<dim>::save_restart_files(const std::vector<double> &elevation,
+                                            std::vector<double> &basement,
+                                            std::vector<double> &silt_fraction) const
+    {
+      this->get_pcout() << "      Writing FastScape restart file... " << std::endl;
+
+      // Create variables for output directory and restart file
+      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
+      std::string dirname = this->get_output_directory();
+      const std::string restart_filename_elevation = dirname + "fastscape_elevation_restart.txt";
+      const std::string restart_filename_basement = dirname + "fastscape_basement_restart.txt";
+      const std::string restart_filename_silt_fraction = dirname + "fastscape_silt_fraction_restart.txt";
+      const std::string restart_filename_time = dirname + "fastscape_last_output_time.txt";
+
+      std::ofstream out_elevation(restart_filename_elevation);
+      std::ofstream out_basement(restart_filename_basement);
+      std::ofstream out_silt_fraction(restart_filename_silt_fraction);
+      std::ofstream out_last_output_time(restart_filename_time);
+      std::stringstream buffer_basement;
+      std::stringstream buffer_elevation;
+      std::stringstream buffer_silt_fraction;
+      std::stringstream buffer_time;
+
+      fastscape_copy_basement_(basement.data());
+
+      // If marine sediment transport and deposition is active,
+      // we also need to store the silt fraction.
+      if (use_marine_component)
+        fastscape_copy_f_(silt_fraction.data());
+
+      out_last_output_time << last_output_time << "\n";
+
+      for (unsigned int i = 0; i < fastscape_array_size; ++i)
+        {
+          buffer_elevation << elevation[i] << "\n";
+          buffer_basement << basement[i] << "\n";
+          if (use_marine_component)
+            buffer_silt_fraction << silt_fraction[i] << "\n";
+        }
+
+      out_elevation << buffer_elevation.str();
+      out_basement << buffer_basement.str();
+      if (use_marine_component)
+        out_silt_fraction << buffer_silt_fraction.str();
+    }
+
+
+
+    template <int dim>
+    bool
+    FastScape<dim>::
+    needs_surface_stabilization () const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    void FastScape<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Mesh deformation");
+      {
+        prm.enter_subsection ("Fastscape");
+        {
+          prm.declare_entry("Number of fastscape timesteps per aspect timestep", "5",
+                            Patterns::Integer(),
+                            "Initial number of fastscape time steps per ASPECT timestep, this value will double if"
+                            "the FastScape timestep is above the maximum FastScape timestep.");
+          prm.declare_entry("Maximum timestep length", "10e3",
+                            Patterns::Double(0),
+                            "Maximum timestep for FastScape. Units: $\\{yrs}$");
+          prm.declare_entry("Vertical exaggeration", "-1",
+                            Patterns::Double(),
+                            "Vertical exaggeration for FastScape's VTK file. -1 outputs topography, basement, and sealevel.");
+          prm.declare_entry("Additional fastscape refinement", "0",
+                            Patterns::Integer(),
+                            "How many levels above ASPECT FastScape should be refined.");
+          prm.declare_entry ("Average out of plane surface topography in 2d", "true",
+                             Patterns::Bool (),
+                             "If this is set to false, then a 2D model will only consider the "
+                             "center slice FastScape gives. If set to true, then ASPECT will"
+                             "average the mesh along Y excluding the ghost nodes.");
+          prm.declare_entry("Fastscape seed", "1000",
+                            Patterns::Integer(),
+                            "Seed used for adding an initial noise to FastScape topography based on the initial noise magnitude.");
+          prm.declare_entry("Maximum surface refinement level", "1",
+                            Patterns::Integer(),
+                            "This should be set to the highest ASPECT refinement level expected at the surface.");
+          prm.declare_entry("Surface refinement difference", "0",
+                            Patterns::Integer(),
+                            "The difference between the lowest and highest refinement level at the surface. E.g., if three resolution "
+                            "levels are expected, this would be set to 2.");
+          prm.declare_entry ("Use marine component", "false",
+                             Patterns::Bool (),
+                             "Flag to use the marine component of FastScape.");
+          prm.declare_entry("Y extent in 2d", "100000",
+                            Patterns::Double(),
+                            "FastScape Y extent when using a 2D ASPECT model. Units: $\\{m}$");
+          prm.declare_entry ("Use ghost nodes", "true",
+                             Patterns::Bool (),
+                             "Flag to use ghost nodes");
+          prm.declare_entry ("Uplift and advect with fastscape", "true",
+                             Patterns::Bool (),
+                             "Flag to use FastScape advection and uplift.");
+          prm.declare_entry("Node tolerance", "0.001",
+                            Patterns::Double(),
+                            "Node tolerance for how close an ASPECT node must be to the FastScape node for the value to be transferred.");
+          prm.declare_entry ("Sediment rain rates", "0,0",
+                             Patterns::List (Patterns::Double(0)),
+                             "Sediment rain rates given as a list 1 greater than the number of sediment rain time intervals. E.g, "
+                             " If the time interval is given at 5 Myr, there will be one value for 0-5 Myr model time and a second value "
+                             " for 5+ Myr. Units: $\\{m/yr}$");
+          prm.declare_entry ("Sediment rain time intervals", "0",
+                             Patterns::List (Patterns::Double(0)),
+                             "A list of times to change the sediment rain rate. Units: $\\{yrs}$");
+          prm.declare_entry("Initial noise magnitude", "5",
+                            Patterns::Double(),
+                            "Maximum topography change from the initial noise. Units: $\\{m}$");
+
+          prm.enter_subsection ("Boundary conditions");
+          {
+            prm.declare_entry ("Front", "1",
+                               Patterns::Integer (0, 1),
+                               "Front (bottom) boundary condition, where 1 is fixed and 0 is reflective.");
+            prm.declare_entry ("Right", "1",
+                               Patterns::Integer (0, 1),
+                               "Right boundary condition, where 1 is fixed and 0 is reflective.");
+            prm.declare_entry ("Back", "1",
+                               Patterns::Integer (0, 1),
+                               "Back (top) boundary condition, where 1 is fixed and 0 is reflective.");
+            prm.declare_entry ("Left", "1",
+                               Patterns::Integer (0, 1),
+                               "Left boundary condition, where 1 is fixed and 0 is reflective.");
+            prm.declare_entry("Left mass flux", "0",
+                              Patterns::Double(),
+                              "Flux per unit length through left boundary. Units: $\\{m^2/yr}$ ");
+            prm.declare_entry("Right mass flux", "0",
+                              Patterns::Double(),
+                              "Flux per unit length through right boundary. Units: $\\{m^2/yr}$ ");
+            prm.declare_entry("Back mass flux", "0",
+                              Patterns::Double(),
+                              "Flux per unit length through back boundary. Units: $\\{m^2/yr}$ ");
+            prm.declare_entry("Front mass flux", "0",
+                              Patterns::Double(),
+                              "Flux per unit length through front boundary. Units: $\\{m^2/yr}$ ");
+            prm.declare_entry ("Back front ghost nodes periodic", "false",
+                               Patterns::Bool (),
+                               "Whether to set the ghost nodes at the FastScape back and front boundary "
+                               "to periodic even if 'Back' and 'Front' are set to fixed boundary.");
+            prm.declare_entry ("Left right ghost nodes periodic", "false",
+                               Patterns::Bool (),
+                               "Whether to set the ghost nodes at the FastScape left and right boundary "
+                               "to periodic even if 'Left' and 'Right' are set to fixed boundary.");
+          }
+          prm.leave_subsection();
+
+          prm.enter_subsection ("Erosional parameters");
+          {
+            prm.declare_entry("Drainage area exponent", "0.4",
+                              Patterns::Double(),
+                              "Exponent for drainage area.");
+            prm.declare_entry("Slope exponent", "1",
+                              Patterns::Double(),
+                              "The  slope  exponent  for  SPL (n).  Generally  m/n  should  equal  approximately 0.4");
+            prm.declare_entry("Multi-direction slope exponent", "1",
+                              Patterns::Double(),
+                              "Exponent to determine the distribution from the SPL to neighbor nodes, with"
+                              "10 being steepest decent and 1 being more varied.");
+            prm.declare_entry("Bedrock deposition coefficient", "1",
+                              Patterns::Double(),
+                              "Deposition coefficient for bedrock.");
+            prm.declare_entry("Sediment deposition coefficient", "-1",
+                              Patterns::Double(),
+                              "Deposition coefficient for sediment, -1 sets this to the same as the bedrock deposition coefficient.");
+            prm.declare_entry("Bedrock river incision rate", "1e-5",
+                              Patterns::Double(),
+                              "River incision rate for bedrock in the Stream Power Law. Units: $\\{m^(1-2*drainage_area_exponent)/yr}$");
+            prm.declare_entry("Sediment river incision rate", "-1",
+                              Patterns::Double(),
+                              "River incision rate for sediment in the Stream Power Law. -1 sets this to the bedrock river incision rate. Units: $\\{m^(1-2*drainage_area_exponent)/yr}$ ");
+            prm.declare_entry("Bedrock diffusivity", "1e-2",
+                              Patterns::Double(),
+                              "Transport coefficient (diffusivity) for bedrock. Units: $\\{m^2/yr}$ ");
+            prm.declare_entry("Sediment diffusivity", "-1",
+                              Patterns::Double(),
+                              "Transport coefficient (diffusivity) for sediment. -1 sets this to the bedrock diffusivity. Units: $\\{m^2/yr}$");
+            prm.declare_entry("Orographic elevation control", "2000",
+                              Patterns::Integer(),
+                              "Above this height, the elevation factor is applied. Units: $\\{m}$");
+            prm.declare_entry("Orographic wind barrier height", "500",
+                              Patterns::Integer(),
+                              "When terrain reaches this height the wind barrier factor is applied. Units: $\\{m}$");
+            prm.declare_entry("Elevation factor", "1",
+                              Patterns::Double(),
+                              "Amount to multiply the bedrock river incision rate nad transport coefficient by past the given orographic elevation control.");
+            prm.declare_entry("Wind barrier factor", "1",
+                              Patterns::Double(),
+                              "Amount to multiply the bedrock river incision rate nad transport coefficient by past given wind barrier height.");
+            prm.declare_entry ("Stack orographic controls", "true",
+                               Patterns::Bool (),
+                               "Whether or not to apply both controls to a point, or only a maximum of one set as the wind barrier.");
+            prm.declare_entry ("Flag to use orographic controls", "false",
+                               Patterns::Bool (),
+                               "Whether or not to apply orographic controls.");
+            prm.declare_entry ("Wind direction", "west",
+                               Patterns::Selection("east|west|south|north"),
+                               "This parameter assumes a wind direction, deciding which side is reduced from the wind barrier.");
+            prm.declare_entry ("Use a fixed erosional base level", "false",
+                               Patterns::Bool (),
+                               "Whether or not to use an erosional base level that differs from sea level. Setting this parameter to "
+                               "true will set all ghost nodes of fixed FastScape boundaries to the height you specify in "
+                               "'set Erosional base level'. \nThis can make "
+                               "sense for a continental model where the model surrounding topography is assumed above sea level, "
+                               "e.g. highlands. If the sea level would be used as an erosional base level in this case, all topography "
+                               "erodes away with lots of 'sediment volume' lost through the sides of the model. This is mostly "
+                               "important, when there are mountains in the middle of the model, while it is less important when there "
+                               "is lower relief in the middle of the model. \n"
+                               "In the FastScape  visualization files, setting the extra base level may show up as a strong "
+                               "slope at the fixed boundaries of the model. However, in the ASPECT visualization files it will not "
+                               "show up, as the ghost nodes only exist in FastScape.");
+            prm.declare_entry("Erosional base level", "0",
+                              Patterns::Double(),
+                              "When 'Use a fixed erosional base level' is set to true, all ghost nodes of fixed "
+                              "FastScape boundaries where no mass flux is specified by the user (FastScape boundary condition set to 1 "
+                              "and 'Left/Right/Bottom/Top mass flux' set to 0) will be fixed to this elevation. The "
+                              "reflecting boundaries (FastScape boundary condition set to 0) will not be affected, nor are the "
+                              "boundaries where a mass flux is specified. \n"
+                              "Units: m");
+          }
+          prm.leave_subsection();
+
+          prm.enter_subsection ("Marine parameters");
+          {
+            prm.declare_entry("Sea level", "0",
+                              Patterns::Double(),
+                              "Sea level relative to the ASPECT surface, where the maximum Z or Y extent in ASPECT is a sea level of zero. Units: $\\{m}$ ");
+            prm.declare_entry("Sand porosity", "0.0",
+                              Patterns::Double(),
+                              "Porosity of sand. ");
+            prm.declare_entry("Silt porosity", "0.0",
+                              Patterns::Double(),
+                              "Porosity of silt. ");
+            prm.declare_entry("Sand e-folding depth", "1e3",
+                              Patterns::Double(),
+                              "E-folding depth for the exponential of the sand porosity law. Units: $\\{m}$");
+            prm.declare_entry("Silt e-folding depth", "1e3",
+                              Patterns::Double(),
+                              "E-folding depth for the exponential of the silt porosity law. Units: $\\{m}$");
+            prm.declare_entry("Sand-silt ratio", "0.5",
+                              Patterns::Double(),
+                              "Ratio of sand to silt for material leaving continent.");
+            prm.declare_entry("Depth averaging thickness", "1e2",
+                              Patterns::Double(),
+                              "Depth averaging for the sand-silt equation. Units: $\\{m}$");
+            prm.declare_entry("Sand transport coefficient", "5e2",
+                              Patterns::Double(),
+                              "Transport coefficient (diffusivity) for sand. Units: $\\{m^2/yr}$");
+            prm.declare_entry("Silt transport coefficient", "2.5e2",
+                              Patterns::Double(),
+                              "Transport coefficient (diffusivity) for silt. Units: $\\{m^2/yr}$ ");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void FastScape<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Mesh deformation");
+      {
+        prm.enter_subsection("Fastscape");
+        {
+          fastscape_steps_per_aspect_step = prm.get_integer("Number of fastscape timesteps per aspect timestep");
+          maximum_fastscape_timestep = prm.get_double("Maximum timestep length");
+          vexp = prm.get_double("Vertical exaggeration");
+          additional_refinement_levels = prm.get_integer("Additional fastscape refinement");
+          average_out_of_plane_surface_topography = prm.get_bool("Average out of plane surface topography in 2d");
+          fastscape_seed = prm.get_integer("Fastscape seed");
+          maximum_surface_refinement_level = prm.get_integer("Maximum surface refinement level");
+          surface_refinement_difference = prm.get_integer("Surface refinement difference");
+          use_marine_component = prm.get_bool("Use marine component");
+          fastscape_y_extent_2d = prm.get_double("Y extent in 2d");
+          use_ghost_nodes = prm.get_bool("Use ghost nodes");
+          fastscape_advection_uplift = prm.get_bool("Uplift and advect with fastscape");
+          node_tolerance = prm.get_double("Node tolerance");
+          noise_elevation = prm.get_double("Initial noise magnitude");
+          sediment_rain_rates = Utilities::string_to_double
+                                (Utilities::split_string_list(prm.get ("Sediment rain rates")));
+          sediment_rain_times = Utilities::string_to_double
+                                (Utilities::split_string_list(prm.get ("Sediment rain time intervals")));
+
+          if (!this->convert_output_to_years())
+            {
+              maximum_fastscape_timestep /= year_in_seconds;
+              for (unsigned int j=0; j<sediment_rain_rates.size(); ++j)
+                sediment_rain_rates[j] *= year_in_seconds;
+            }
+
+          if (sediment_rain_rates.size() != sediment_rain_times.size()+1)
+            AssertThrow(false, ExcMessage("Error: There must be one more sediment rain rate than time interval."));
+
+          for (unsigned int i=1; i<sediment_rain_times.size(); ++i)
+            AssertThrow(sediment_rain_times[i] > sediment_rain_times[i-1], ExcMessage("Sediment rain time intervals must be an increasing array."));
+
+          prm.enter_subsection("Boundary conditions");
+          {
+            bottom = prm.get_integer("Front");
+            right = prm.get_integer("Right");
+            top = prm.get_integer("Back");
+            left = prm.get_integer("Left");
+            left_flux = prm.get_double("Left mass flux");
+            right_flux = prm.get_double("Right mass flux");
+            top_flux = prm.get_double("Back mass flux");
+            bottom_flux = prm.get_double("Front mass flux");
+
+            if (!this->convert_output_to_years())
+              {
+                left_flux *= year_in_seconds;
+                right_flux *= year_in_seconds;
+                top_flux *= year_in_seconds;
+                bottom_flux *= year_in_seconds;
+              }
+
+            // Put the boundary condition values into a four digit value to send to FastScape.
+            fastscape_boundary_conditions = bottom*1000+right*100+top*10+left;
+
+            if ((left_flux != 0 && top_flux != 0) || (left_flux != 0 && bottom_flux != 0) ||
+                (right_flux != 0 && bottom_flux != 0) || (right_flux != 0 && top_flux != 0))
+              AssertThrow(false,ExcMessage("Currently the plugin does not support mass flux through adjacent boundaries."));
+
+            topbottom_ghost_nodes_periodic = prm.get_bool("Back front ghost nodes periodic");
+            leftright_ghost_nodes_periodic = prm.get_bool("Left right ghost nodes periodic");
+          }
+          prm.leave_subsection();
+
+          prm.enter_subsection("Erosional parameters");
+          {
+            drainage_area_exponent_m = prm.get_double("Drainage area exponent");
+            slope_exponent_n = prm.get_double("Slope exponent");
+            sediment_river_incision_rate = prm.get_double("Sediment river incision rate");
+            bedrock_river_incision_rate = prm.get_double("Bedrock river incision rate");
+            sediment_transport_coefficient = prm.get_double("Sediment diffusivity");
+            bedrock_transport_coefficient = prm.get_double("Bedrock diffusivity");
+            bedrock_deposition_g = prm.get_double("Bedrock deposition coefficient");
+            sediment_deposition_g = prm.get_double("Sediment deposition coefficient");
+            slope_exponent_p = prm.get_double("Multi-direction slope exponent");
+            flat_elevation = prm.get_integer("Orographic elevation control");
+            wind_barrier_elevation = prm.get_integer("Orographic wind barrier height");
+            flat_erosional_factor = prm.get_double("Elevation factor");
+            wind_barrier_erosional_factor = prm.get_double("Wind barrier factor");
+            stack_controls = prm.get_bool("Stack orographic controls");
+            use_orographic_controls = prm.get_bool("Flag to use orographic controls");
+
+            if (!this->convert_output_to_years())
+              {
+                bedrock_river_incision_rate *= year_in_seconds;
+                bedrock_transport_coefficient *= year_in_seconds;
+                sediment_river_incision_rate *= year_in_seconds;
+                bedrock_transport_coefficient *= year_in_seconds;
+              }
+
+            // Wind direction
+            if (prm.get ("Wind direction") == "west")
+              wind_direction = 0;
+            else if (prm.get ("Wind direction") == "east")
+              wind_direction = 1;
+            else if (prm.get ("Wind direction") == "north")
+              wind_direction = 2;
+            else if (prm.get ("Wind direction") == "south")
+              wind_direction = 3;
+            else
+              AssertThrow(false, ExcMessage("Not a valid wind direction."));
+
+            // set fixed ghost nodes to a base level for erosion that differs from sea level
+            use_fixed_erosional_base = prm.get_bool("Use a fixed erosional base level");
+            if (use_fixed_erosional_base)
+              AssertThrow(use_fixed_erosional_base && use_ghost_nodes, ExcMessage(
+                            "If you want to use an erosional base level differing from sea level, "
+                            "you need to use ghost nodes."));
+            h_erosional_base = prm.get_double("Erosional base level");
+          }
+          prm.leave_subsection();
+
+          prm.enter_subsection("Marine parameters");
+          {
+            sea_level = prm.get_double("Sea level");
+            sand_surface_porosity = prm.get_double("Sand porosity");
+            silt_surface_porosity = prm.get_double("Silt porosity");
+            sand_efold_depth = prm.get_double("Sand e-folding depth");
+            silt_efold_depth = prm.get_double("Silt e-folding depth");
+            sand_silt_ratio = prm.get_double("Sand-silt ratio");
+            sand_silt_averaging_depth = prm.get_double("Depth averaging thickness");
+            sand_transport_coefficient = prm.get_double("Sand transport coefficient");
+            silt_transport_coefficient = prm.get_double("Silt transport coefficient");
+
+            if (!this->convert_output_to_years())
+              {
+                sand_transport_coefficient *= year_in_seconds;
+                silt_transport_coefficient *= year_in_seconds;
+              }
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection ();
+
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Visualization");
+        {
+          output_interval = prm.get_double ("Time between graphical output");
+          if (this->convert_output_to_years())
+            output_interval *= year_in_seconds;
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(FastScape,
+                                           "fastscape",
+                                           "A plugin that uses the program FastScape to compute the deformation of the mesh surface. "
+                                           "FastScape is a surface processes code that computes the erosion, transport and "
+                                           "deposition of sediments both on land and in the marine domain. These surface processes "
+                                           "include river incision (through the stream power law), hillslope diffusion and "
+                                           "marine diffusion, as described in Braun and Willett 2013; Yuan et al. 2019; "
+                                           "Yuan et al. 2019b. "
+                                           "\n"
+                                           "Upon initialization, FastScape requires the initial topography of the surface boundary "
+                                           "of ASPECT's model domain and several user-specified erosional and depositional parameters. "
+                                           "In each ASPECT timestep, FastScape is then fed ASPECT's material velocity at the surface "
+                                           "boundary. The z-component of this velocity is used to uplift the FastScape surface, "
+                                           "while the horizontal components are used to advect the topography in the x-y plane. "
+                                           "\n"
+                                           "After solving its governing equations (this can be done in several timesteps "
+                                           "that are smaller than the ASPECT timestep), FastScape returns a new topography of the surface. "
+                                           "The difference in topography before and after the call to FastScape divided by the ASPECT "
+                                           "timestep provides the mesh velocity at the domain's surface that is used to displace the surface "
+                                           "and internal mesh nodes. "
+                                           "\n"
+                                           "FastScape can be used in both 2D and 3D ASPECT simulations. In 2D, one can think of the coupled "
+                                           "model as a T-model.The ASPECT domain spans the x - z plane, while FastScape acts on the horizontal "
+                                           "x-y plane. This means that to communicate ASPECT's material velocities to FastScape, "
+                                           "FastScape mesh nodes with the same x-coordinate (so lying along the y-direction) get the same velocities. "
+                                           "In turn, the FastScape topography is collapsed back onto the line of the ASPECT surface boundary "
+                                           "by averaging the topography over the y-direction. In 3D no such actions are necessary. "
+                                           "\n"
+                                           "The FastScape manual (https://fastscape.org/fastscapelib-fortran/) provides more information "
+                                           "on the input parameters. ")
+
+  }
+}
+#endif
diff --git a/source/mesh_deformation/free_surface.cc.bak b/source/mesh_deformation/free_surface.cc.bak
new file mode 100644
index 00000000000..83d083d7b07
--- /dev/null
+++ b/source/mesh_deformation/free_surface.cc.bak
@@ -0,0 +1,336 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/mesh_deformation/free_surface.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/dofs/dof_tools.h>
+
+
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    template <int dim>
+    void
+    FreeSurface<dim>::initialize ()
+    {
+      // Pressure normalization doesn't really make sense with a free surface, and if we do
+      // use it, we can run into problems with geometry_model->depth().
+      AssertThrow ( this->get_parameters().pressure_normalization == "no",
+                    ExcMessage("The free surface scheme can only be used with no pressure normalization") );
+
+      // Check that we do not use the free surface on a boundary that has zero slip,
+      // free slip or prescribed velocity boundary conditions on it.
+
+      // Get the zero velocity boundary indicators
+      std::set<types::boundary_id> velocity_boundary_indicators = this->get_boundary_velocity_manager().get_zero_boundary_velocity_indicators();
+
+      // Get the tangential velocity boundary indicators
+      const std::set<types::boundary_id> tmp_tangential_vel_boundary_indicators = this->get_boundary_velocity_manager().get_tangential_boundary_velocity_indicators();
+      velocity_boundary_indicators.insert(tmp_tangential_vel_boundary_indicators.begin(),
+                                          tmp_tangential_vel_boundary_indicators.end());
+
+      // Get the active velocity boundary indicators
+      const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>>
+      tmp_active_vel_boundary_indicators = this->get_boundary_velocity_manager().get_active_boundary_velocity_names();
+
+      for (const auto &p : tmp_active_vel_boundary_indicators)
+        velocity_boundary_indicators.insert(p.first);
+
+      // Get the mesh deformation boundary indicators
+      const std::set<types::boundary_id> tmp_mesh_deformation_boundary_indicators = this->get_mesh_deformation_boundary_indicators();
+      for (const auto &p : tmp_mesh_deformation_boundary_indicators)
+        AssertThrow(velocity_boundary_indicators.find(p) == velocity_boundary_indicators.end(),
+                    ExcMessage("The free surface mesh deformation plugin cannot be used with the current velocity boundary conditions"));
+    }
+
+
+    template <int dim>
+    void FreeSurface<dim>::project_velocity_onto_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                          const IndexSet &mesh_locally_owned,
+                                                          const IndexSet &mesh_locally_relevant,
+                                                          LinearAlgebra::Vector &output) const
+    {
+      // TODO: should we use the extrapolated solution?
+
+      // stuff for iterating over the mesh
+      const QGauss<dim-1> face_quadrature(mesh_deformation_dof_handler.get_fe().degree+1);
+      UpdateFlags update_flags = UpdateFlags(update_values | update_quadrature_points
+                                             | update_normal_vectors | update_JxW_values);
+      FEFaceValues<dim> fs_fe_face_values (this->get_mapping(), mesh_deformation_dof_handler.get_fe(), face_quadrature, update_flags);
+      FEFaceValues<dim> fe_face_values (this->get_mapping(), this->get_fe(), face_quadrature, update_flags);
+      const unsigned int n_face_q_points = fe_face_values.n_quadrature_points,
+                         dofs_per_cell = fs_fe_face_values.dofs_per_cell;
+
+      // stuff for assembling system
+      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
+      Vector<double> cell_vector (dofs_per_cell);
+      FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
+
+      // stuff for getting the velocity values
+      std::vector<Tensor<1,dim>> velocity_values(n_face_q_points);
+
+      // set up constraints
+      AffineConstraints<double> mass_matrix_constraints(
+#if DEAL_II_VERSION_GTE(9,6,0)
+        mesh_deformation_dof_handler.locally_owned_dofs(),
+#endif
+        mesh_locally_relevant);
+      DoFTools::make_hanging_node_constraints(mesh_deformation_dof_handler, mass_matrix_constraints);
+
+      using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
+      periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
+      for (const auto &p : pbp)
+        DoFTools::make_periodicity_constraints(mesh_deformation_dof_handler,
+                                               p.first.first, p.first.second, p.second, mass_matrix_constraints);
+
+      mass_matrix_constraints.close();
+
+      // set up the matrix
+      LinearAlgebra::SparseMatrix mass_matrix;
+      TrilinosWrappers::SparsityPattern sp (mesh_locally_owned,
+                                            mesh_locally_owned,
+                                            mesh_locally_relevant,
+                                            this->get_mpi_communicator());
+      DoFTools::make_sparsity_pattern (mesh_deformation_dof_handler, sp, mass_matrix_constraints, false,
+                                       Utilities::MPI::this_mpi_process(this->get_mpi_communicator()));
+      sp.compress();
+      mass_matrix.reinit (sp);
+
+      FEValuesExtractors::Vector extract_vel(0);
+
+      // make distributed vectors.
+      LinearAlgebra::Vector rhs, dist_solution;
+      rhs.reinit(mesh_locally_owned, this->get_mpi_communicator());
+      dist_solution.reinit(mesh_locally_owned, this->get_mpi_communicator());
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell = this->get_dof_handler().begin_active(), endc= this->get_dof_handler().end();
+      typename DoFHandler<dim>::active_cell_iterator
+      fscell = mesh_deformation_dof_handler.begin_active();
+
+      // Get the boundary indicators of those boundaries with
+      // a free surface.
+      const std::set<types::boundary_id> tmp_free_surface_boundary_indicators = this->get_mesh_deformation_handler().get_free_surface_boundary_indicators();
+
+      for (; cell!=endc; ++cell, ++fscell)
+        if (cell->at_boundary() && cell->is_locally_owned())
+          for (const unsigned int face_no : cell->face_indices())
+            if (cell->face(face_no)->at_boundary())
+              {
+                const types::boundary_id boundary_indicator
+                  = cell->face(face_no)->boundary_id();
+
+                // Only project onto the free surface boundary/boundaries.
+                if (tmp_free_surface_boundary_indicators.find(boundary_indicator) == tmp_free_surface_boundary_indicators.end())
+                  continue;
+
+                fscell->get_dof_indices (cell_dof_indices);
+                fs_fe_face_values.reinit (fscell, face_no);
+                fe_face_values.reinit (cell, face_no);
+                fe_face_values[this->introspection().extractors.velocities].get_function_values(this->get_solution(), velocity_values);
+
+                cell_vector = 0;
+                cell_matrix = 0;
+                for (unsigned int point=0; point<n_face_q_points; ++point)
+                  {
+                    // Select the direction onto which to project the velocity solution
+                    Tensor<1,dim> direction;
+                    if ( advection_direction == SurfaceAdvection::normal ) // project onto normal vector
+                      direction = fs_fe_face_values.normal_vector(point);
+                    else if ( advection_direction == SurfaceAdvection::vertical ) // project onto local gravity
+                      direction = this->get_gravity_model().gravity_vector(fs_fe_face_values.quadrature_point(point));
+                    else
+                      AssertThrow(false, ExcInternalError());
+
+                    direction *= ( direction.norm() > 0.0 ? 1./direction.norm() : 0.0 );
+
+                    for (unsigned int i=0; i<dofs_per_cell; ++i)
+                      {
+                        for (unsigned int j=0; j<dofs_per_cell; ++j)
+                          {
+                            cell_matrix(i,j) += (fs_fe_face_values[extract_vel].value(j,point) *
+                                                 fs_fe_face_values[extract_vel].value(i,point) ) *
+                                                fs_fe_face_values.JxW(point);
+                          }
+
+                        cell_vector(i) += (fs_fe_face_values[extract_vel].value(i,point) * direction)
+                                          * (velocity_values[point] * direction)
+                                          * fs_fe_face_values.JxW(point);
+                      }
+                  }
+
+                mass_matrix_constraints.distribute_local_to_global (cell_matrix, cell_vector,
+                                                                    cell_dof_indices, mass_matrix, rhs, false);
+              }
+
+      rhs.compress (VectorOperation::add);
+      mass_matrix.compress(VectorOperation::add);
+
+      // Jacobi seems to be fine here.  Other preconditioners (ILU, IC) run into troubles
+      // because the matrix is mostly empty, since we don't touch internal vertices.
+      LinearAlgebra::PreconditionJacobi preconditioner_mass;
+      preconditioner_mass.initialize(mass_matrix);
+
+      SolverControl solver_control(5*rhs.size(), this->get_parameters().linear_stokes_solver_tolerance*rhs.l2_norm());
+      SolverCG<LinearAlgebra::Vector> cg(solver_control);
+      cg.solve (mass_matrix, dist_solution, rhs, preconditioner_mass);
+
+      mass_matrix_constraints.distribute (dist_solution);
+      output = dist_solution;
+    }
+
+
+
+    /**
+     * A function that creates constraints for the velocity of certain mesh
+     * vertices (e.g. the surface vertices) for a specific boundary.
+     * The calling class will respect
+     * these constraints when computing the new vertex positions.
+     */
+    template <int dim>
+    void
+    FreeSurface<dim>::compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                               AffineConstraints<double> &mesh_velocity_constraints,
+                                                               const std::set<types::boundary_id> &boundary_id) const
+    {
+      // For the free surface indicators we constrain the displacement to be v.n
+      LinearAlgebra::Vector boundary_velocity;
+
+      const IndexSet &mesh_locally_owned = mesh_deformation_dof_handler.locally_owned_dofs();
+      IndexSet mesh_locally_relevant;
+      DoFTools::extract_locally_relevant_dofs (mesh_deformation_dof_handler,
+                                               mesh_locally_relevant);
+      boundary_velocity.reinit(mesh_locally_owned, mesh_locally_relevant,
+                               this->get_mpi_communicator());
+      project_velocity_onto_boundary(mesh_deformation_dof_handler, mesh_locally_owned,
+                                     mesh_locally_relevant, boundary_velocity);
+
+      // now insert the relevant part of the solution into the mesh constraints
+      const IndexSet constrained_dofs =
+        DoFTools::extract_boundary_dofs(mesh_deformation_dof_handler,
+                                        ComponentMask(dim, true),
+                                        boundary_id);
+
+      for (unsigned int i = 0; i < constrained_dofs.n_elements();  ++i)
+        {
+          types::global_dof_index index = constrained_dofs.nth_index_in_set(i);
+          if (mesh_velocity_constraints.can_store_line(index))
+            if (mesh_velocity_constraints.is_constrained(index)==false)
+              {
+#if DEAL_II_VERSION_GTE(9,6,0)
+                mesh_velocity_constraints.add_constraint(index,
+                                                         {},
+                                                         boundary_velocity[index]);
+#else
+                mesh_velocity_constraints.add_line(index);
+                mesh_velocity_constraints.set_inhomogeneity(index, boundary_velocity[index]);
+#endif
+              }
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    FreeSurface<dim>::
+    needs_surface_stabilization () const
+    {
+      return true;
+    }
+
+
+
+    template <int dim>
+    void FreeSurface<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Mesh deformation");
+      {
+        prm.enter_subsection ("Free surface");
+        {
+          prm.declare_entry("Surface velocity projection", "normal",
+                            Patterns::Selection("normal|vertical"),
+                            "After each time step the free surface must be "
+                            "advected in the direction of the velocity field. "
+                            "Mass conservation requires that the mesh velocity "
+                            "is in the normal direction of the surface. However, "
+                            "for steep topography or large curvature, advection "
+                            "in the normal direction can become ill-conditioned, "
+                            "and instabilities in the mesh can form. Projection "
+                            "of the mesh velocity onto the local vertical direction "
+                            "can preserve the mesh quality better, but at the "
+                            "cost of slightly poorer mass conservation of the "
+                            "domain.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+
+    template <int dim>
+    void FreeSurface<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Mesh deformation");
+      {
+        prm.enter_subsection ("Free surface");
+        {
+          std::string advection_dir = prm.get("Surface velocity projection");
+
+          if ( advection_dir == "normal")
+            advection_direction = SurfaceAdvection::normal;
+          else if ( advection_dir == "vertical")
+            advection_direction = SurfaceAdvection::vertical;
+          else
+            AssertThrow(false, ExcMessage("The surface velocity projection must be ``normal'' or ``vertical''."));
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(FreeSurface,
+                                           "free surface",
+                                           "A plugin that computes the deformation of surface "
+                                           "vertices according to the solution of the flow problem. "
+                                           "In particular this means if the surface of the domain is "
+                                           "left open to flow, this flow will carry the mesh with it. "
+                                           "The implementation was described in \\cite{rose_freesurface}, "
+                                           "with the stabilization of the free surface originally described "
+                                           "in \\cite{kaus:etal:2010}.")
+  }
+}
diff --git a/source/mesh_deformation/function.cc.bak b/source/mesh_deformation/function.cc.bak
new file mode 100644
index 00000000000..32027eafd2e
--- /dev/null
+++ b/source/mesh_deformation/function.cc.bak
@@ -0,0 +1,149 @@
+/*
+  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/mesh_deformation/function.h>
+
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    template <int dim>
+    BoundaryFunction<dim>::BoundaryFunction()
+      :
+      function(dim)
+    {}
+
+
+
+    template <int dim>
+    void
+    BoundaryFunction<dim>::update ()
+    {
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        function.set_time (this->get_time() / year_in_seconds);
+      else
+        function.set_time (this->get_time());
+    }
+
+
+
+    /**
+     * A function that creates constraints for the velocity of certain mesh
+     * vertices (e.g. the surface vertices) for a specific boundary.
+     * The calling class will respect
+     * these constraints when computing the new vertex positions.
+     */
+    template <int dim>
+    void
+    BoundaryFunction<dim>::compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
+                                                                    AffineConstraints<double> &mesh_velocity_constraints,
+                                                                    const std::set<types::boundary_id> &boundary_ids) const
+    {
+      // Loop over all boundary indicators to set the velocity constraints
+      for (const auto boundary_id : boundary_ids)
+        VectorTools::interpolate_boundary_values (this->get_mapping(),
+                                                  mesh_deformation_dof_handler,
+                                                  boundary_id,
+                                                  function,
+                                                  mesh_velocity_constraints);
+    }
+
+
+
+    template <int dim>
+    bool
+    BoundaryFunction<dim>::
+    needs_surface_stabilization () const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    void BoundaryFunction<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Mesh deformation");
+      {
+        prm.enter_subsection ("Boundary function");
+        {
+          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection ();
+    }
+
+    template <int dim>
+    void BoundaryFunction<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Mesh deformation");
+      {
+        prm.enter_subsection("Boundary function");
+        {
+          try
+            {
+              function.parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Mesh deformation.BoundaryFunction'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(BoundaryFunction,
+                                           "boundary function",
+                                           "A plugin, which prescribes the surface mesh to "
+                                           "deform according to an analytically prescribed "
+                                           "function. Note that the function prescribes a "
+                                           "deformation velocity, i.e. the return value of "
+                                           "this plugin is later multiplied by the time step length "
+                                           "to compute the displacement increment in this time step. "
+                                           "Although the function's time variable is interpreted as "
+                                           "years when Use years in output instead of seconds is set to true, "
+                                           "the boundary deformation velocity should still be given "
+                                           "in m/s. The format of the "
+                                           "functions follows the syntax understood by the "
+                                           "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+  }
+}
diff --git a/source/mesh_deformation/interface.cc.bak b/source/mesh_deformation/interface.cc.bak
new file mode 100644
index 00000000000..50d4f2307e8
--- /dev/null
+++ b/source/mesh_deformation/interface.cc.bak
@@ -0,0 +1,1605 @@
+/*
+  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/simulator.h>
+#include <aspect/stokes_matrix_free.h>
+
+#include <deal.II/dofs/dof_renumbering.h>
+#include <deal.II/dofs/dof_accessor.h>
+#include <deal.II/dofs/dof_tools.h>
+
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/fe/fe_q.h>
+#include <deal.II/fe/mapping_q1_eulerian.h>
+#include <deal.II/fe/mapping_q_eulerian.h>
+
+#include <deal.II/lac/sparsity_tools.h>
+
+#include <deal.II/numerics/vector_tools.h>
+
+#include <aspect/melt.h>
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    template <int dim>
+    ApplyStabilization<dim>::ApplyStabilization(const double stabilization_theta)
+      :
+      free_surface_theta(stabilization_theta)
+    {}
+
+    template <int dim>
+    void
+    ApplyStabilization<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>       &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim>      &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>& > (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>& > (data_base);
+
+      AssertThrow(!this->get_mesh_deformation_handler().get_boundary_indicators_requiring_stabilization().empty(),
+                  ExcMessage("Applying surface stabilization, even though no boundary requires it."));
+
+
+      if (this->get_parameters().include_melt_transport)
+        {
+          this->get_melt_handler().apply_free_surface_stabilization_with_melt (free_surface_theta,
+                                                                               scratch.cell,
+                                                                               scratch,
+                                                                               data);
+          return;
+        }
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const typename DoFHandler<dim>::active_cell_iterator cell (&this->get_triangulation(),
+                                                                 scratch.finite_element_values.get_cell()->level(),
+                                                                 scratch.finite_element_values.get_cell()->index(),
+                                                                 &this->get_dof_handler());
+
+      const unsigned int n_face_q_points = scratch.face_finite_element_values.n_quadrature_points;
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+
+      // Get the boundary indicators of those boundaries that require stabilization
+      const std::set<types::boundary_id> tmp_boundary_indicators_requiring_stabilization = this->get_mesh_deformation_handler().get_boundary_indicators_requiring_stabilization();
+
+      // only apply on mesh deformation faces that require stabilization
+      if (cell->at_boundary() && cell->is_locally_owned())
+        for (const unsigned int face_no : cell->face_indices())
+          if (cell->face(face_no)->at_boundary())
+            {
+              const types::boundary_id boundary_indicator
+                = cell->face(face_no)->boundary_id();
+
+              if (tmp_boundary_indicators_requiring_stabilization.find(boundary_indicator)
+                  == tmp_boundary_indicators_requiring_stabilization.end())
+                continue;
+
+              scratch.face_finite_element_values.reinit(cell, face_no);
+
+              scratch.face_material_model_inputs.reinit  (scratch.face_finite_element_values,
+                                                          cell,
+                                                          this->introspection(),
+                                                          this->get_solution());
+              scratch.face_material_model_inputs.requested_properties = MaterialModel::MaterialProperties::density;
+
+              this->get_material_model().evaluate(scratch.face_material_model_inputs, scratch.face_material_model_outputs);
+
+              for (unsigned int q_point = 0; q_point < n_face_q_points; ++q_point)
+                {
+                  for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+                    {
+                      if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                        {
+                          scratch.phi_u[i_stokes] = scratch.face_finite_element_values[introspection.extractors.velocities].value(i, q_point);
+                          ++i_stokes;
+                        }
+                      ++i;
+                    }
+
+                  const Tensor<1,dim>
+                  gravity = this->get_gravity_model().gravity_vector(scratch.face_finite_element_values.quadrature_point(q_point));
+                  const double g_norm = gravity.norm();
+
+                  // construct the relevant vectors
+                  const Tensor<1,dim> n_hat = scratch.face_finite_element_values.normal_vector(q_point);
+                  const Tensor<1,dim> g_hat = (g_norm == 0.0 ? Tensor<1,dim>() : gravity/g_norm);
+
+                  const double pressure_perturbation = scratch.face_material_model_outputs.densities[q_point] *
+                                                       this->get_timestep() *
+                                                       free_surface_theta *
+                                                       g_norm;
+
+                  // see Kaus et al 2010 for details of the stabilization term
+                  for (unsigned int i=0; i< stokes_dofs_per_cell; ++i)
+                    for (unsigned int j=0; j< stokes_dofs_per_cell; ++j)
+                      {
+                        // The fictive stabilization stress is (phi_u[i].g)*(phi_u[j].n)
+                        const double stress_value = -pressure_perturbation*
+                                                    (scratch.phi_u[i]*g_hat) * (scratch.phi_u[j]*n_hat)
+                                                    *scratch.face_finite_element_values.JxW(q_point);
+
+                        data.local_matrix(i,j) += stress_value;
+                      }
+                }
+            }
+    }
+  }
+
+
+
+  namespace MeshDeformation
+  {
+    template <int dim>
+    bool
+    Interface<dim>::needs_surface_stabilization () const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    Tensor<1,dim>
+    Interface<dim>::
+    compute_initial_deformation_on_boundary(const types::boundary_id /*boundary_indicator*/,
+                                            const Point<dim> &/*position*/) const
+    {
+      return Tensor<1,dim>();
+    }
+
+
+
+    template <int dim>
+    void
+    Interface<dim>::
+    compute_velocity_constraints_on_boundary(const DoFHandler<dim> &/*mesh_deformation_dof_handler*/,
+                                             AffineConstraints<double> &/*mesh_velocity_constraints*/,
+                                             const std::set<types::boundary_id> &/*boundary_id*/) const
+    {}
+
+
+
+    template <int dim>
+    MeshDeformationHandler<dim>::MeshDeformationHandler (Simulator<dim> &simulator)
+      : sim(simulator),  // reference to the simulator that owns the MeshDeformationHandler
+        mesh_deformation_fe (FE_Q<dim>(1),dim), // Q1 elements which describe the mesh geometry
+        mesh_deformation_dof_handler (sim.triangulation),
+        include_initial_topography(false)
+    {
+      // Now reset the mapping of the simulator to be something that captures mesh deformation in time.
+      sim.mapping = std::make_unique<MappingQ1Eulerian<dim, LinearAlgebra::Vector>> (mesh_deformation_dof_handler,
+                                                                                      mesh_displacements);
+    }
+
+
+
+    template <int dim>
+    MeshDeformationHandler<dim>::~MeshDeformationHandler ()
+    {
+      // Free the Simulator's mapping object, otherwise
+      // when the MeshDeformationHandler gets destroyed,
+      // the mapping's reference to the mesh displacement
+      // vector will be invalid.
+      sim.mapping.reset();
+    }
+
+
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    MeshDeformationHandler<dim>::initialize ()
+    {
+      // In case we prescribed initial topography, we should take this into
+      // account. However, it is not included in the mesh displacements,
+      // so we need to fetch it separately.
+      if (!Plugins::plugin_type_matches<InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()))
+        include_initial_topography = true;
+
+      // If a surface needs to be stabilized, set up the assemblers.
+      if (!this->get_mesh_deformation_handler().get_boundary_indicators_requiring_stabilization().empty())
+        {
+          this->get_signals().set_assemblers.connect(
+            [&](const SimulatorAccess<dim> &sim_access,
+                aspect::Assemblers::Manager<dim> &assemblers)
+          {
+            this->set_assemblers(sim_access, assemblers);
+          });
+        }
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::set_assemblers(const SimulatorAccess<dim> &,
+                                                     aspect::Assemblers::Manager<dim> &assemblers) const
+    {
+      assemblers.stokes_system.push_back(
+        std::make_unique<aspect::Assemblers::ApplyStabilization<dim>> (surface_theta));
+
+      // Note that we do not want face_material_model_data, because we do not
+      // connect to a face assembler. We instead connect to a normal assembler,
+      // and compute our own material_model_inputs in apply_stabilization
+      // (because we want to use the solution instead of the current_linearization_point
+      // to compute the material properties).
+      assemblers.stokes_system_assembler_on_boundary_face_properties.needed_update_flags |= (update_values  |
+          update_gradients |
+          update_quadrature_points |
+          update_normal_vectors |
+          update_JxW_values);
+    }
+
+
+
+    template <int dim>
+    void
+    MeshDeformationHandler<dim>::register_mesh_deformation (const std::string &name,
+                                                            const std::string &description,
+                                                            void (*declare_parameters_function) (ParameterHandler &),
+                                                            std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+
+    template <int dim>
+    void
+    MeshDeformationHandler<dim>::update ()
+    {
+      AssertThrow(sim.parameters.mesh_deformation_enabled, ExcInternalError());
+
+      for (const auto &boundary_and_deformation_objects : mesh_deformation_objects)
+        {
+          for (const auto &model : boundary_and_deformation_objects.second)
+            model->update();
+        }
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Mesh deformation");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry ("Additional tangential mesh velocity boundary indicators", "",
+                           Patterns::List (Patterns::Anything()),
+                           "A comma separated list of names denoting those boundaries "
+                           "where there the mesh is allowed to move tangential to the "
+                           "boundary. All tangential mesh movements along "
+                           "those boundaries that have tangential material velocity "
+                           "boundary conditions are allowed by default, this parameters "
+                           "allows to generate mesh movements along other boundaries that are "
+                           "open, or have prescribed material velocities or tractions."
+                           "\n\n"
+                           "The names of the boundaries listed here can either be "
+                           "numbers (in which case they correspond to the numerical "
+                           "boundary indicators assigned by the geometry object), or they "
+                           "can correspond to any of the symbolic names the geometry object "
+                           "may have provided for each part of the boundary. You may want "
+                           "to compare this with the documentation of the geometry model you "
+                           "use in your model.");
+        prm.declare_entry ("Mesh deformation boundary indicators", "",
+                           Patterns::List (Patterns::Anything()),
+                           "A comma separated list of names denoting those boundaries "
+                           "where there the mesh is allowed to move according to the "
+                           "specified mesh deformation objects. "
+                           "\n\n"
+                           "The names of the boundaries listed here can either be "
+                           "numbers (in which case they correspond to the numerical "
+                           "boundary indicators assigned by the geometry object), or they "
+                           "can correspond to any of the symbolic names the geometry object "
+                           "may have provided for each part of the boundary. You may want "
+                           "to compare this with the documentation of the geometry model you "
+                           "use in your model. "
+                           "\n\n"
+                           "The format is id1: object1 \\& object2, id2: object3 \\& object2, where "
+                           "objects are one of " + std::get<dim>(registered_plugins).get_description_string());
+
+        prm.enter_subsection ("Free surface");
+        {
+          prm.declare_entry("Free surface stabilization theta", "0.5",
+                            Patterns::Double(0., 1.),
+                            "Theta parameter described in \\cite{kaus:etal:2010}. "
+                            "An unstabilized free surface can overshoot its "
+                            "equilibrium position quite easily and generate "
+                            "unphysical results.  One solution is to use a "
+                            "quasi-implicit correction term to the forces near the "
+                            "free surface.  This parameter describes how much "
+                            "the free surface is stabilized with this term, "
+                            "where zero is no stabilization, and one is fully "
+                            "implicit.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Mesh deformation");
+      {
+        // Create the map of prescribed mesh movement boundary indicators
+        // Each boundary indicator can carry a number of mesh deformation plugin names.
+        const std::vector<std::string> x_mesh_deformation_boundary_indicators
+          = Utilities::split_string_list(prm.get("Mesh deformation boundary indicators"),",");
+
+        for (const auto &entry : x_mesh_deformation_boundary_indicators)
+          {
+            // each entry has the format (white space is optional):
+            // <boundary_id> : <object_name & object_name, ...>
+            const std::vector<std::string> split_parts = Utilities::split_string_list (entry, ':');
+            AssertThrow (split_parts.size() == 2,
+                         ExcMessage ("The format for mesh deformation indicators "
+                                     "requires that each entry has the form `"
+                                     "<id> : <value & value & ...>', but there does not "
+                                     "appear to be a colon in the entry <"
+                                     + entry
+                                     + ">."));
+
+            // Get the values, i.e. the mesh deformation plugin names
+            const std::vector<std::string> object_names = Utilities::split_string_list(split_parts[1],"&");
+
+            // Try to translate the id into a boundary_id.
+            types::boundary_id boundary_id;
+            try
+              {
+                boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id(split_parts[0]);
+              }
+            catch (const std::string &error)
+              {
+                AssertThrow (false, ExcMessage ("While parsing the entry <Mesh deformation/"
+                                                "Mesh deformation boundary indicators>, there was an error. Specifically, "
+                                                "the conversion function complained as follows:\n\n"
+                                                + error));
+              }
+
+            // Store the boundary indicator. If the entry exists this does nothing.
+            prescribed_mesh_deformation_boundary_indicators.insert(boundary_id);
+
+            for (const auto &object_name : object_names)
+              {
+                // Make sure there are no duplicated entries. If this boundary is not
+                // already in the map the first call to map[key] will create an empty entry.
+                AssertThrow(std::find(mesh_deformation_object_names[boundary_id].begin(),
+                                      mesh_deformation_object_names[boundary_id].end(), object_name)
+                            == mesh_deformation_object_names[boundary_id].end(),
+                            ExcMessage("The current mesh deformation object is listed twice for boundary indicator "
+                                       + dealii::Utilities::int_to_string(boundary_id)));
+
+                mesh_deformation_object_names[boundary_id].push_back(object_name);
+
+                if (object_name == "free surface")
+                  free_surface_boundary_indicators.insert(boundary_id);
+              }
+          }
+
+        // Create the list of tangential mesh movement boundary indicators
+        try
+          {
+            const std::vector<types::boundary_id> x_additional_tangential_mesh_boundary_indicators
+              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
+                                                                                    (prm.get ("Additional tangential mesh velocity boundary indicators")));
+
+            tangential_mesh_deformation_boundary_indicators.insert(x_additional_tangential_mesh_boundary_indicators.begin(),
+                                                                   x_additional_tangential_mesh_boundary_indicators.end());
+          }
+        catch (const std::string &error)
+          {
+            AssertThrow (false, ExcMessage ("While parsing the entry <Mesh deformation/Additional tangential "
+                                            "mesh velocity boundary indicators>, there was an error. Specifically, "
+                                            "the conversion function complained as follows:\n\n"
+                                            + error));
+          }
+
+        // Boundaries with tangential Stokes velocity boundary conditions are implicitly
+        // treated as tangential mesh boundaries, but only if they do not have
+        // assigned mesh deformation objects.
+        for (const auto &boundary_id : this->get_boundary_velocity_manager().get_tangential_boundary_velocity_indicators())
+          tangential_mesh_deformation_boundary_indicators.insert(boundary_id);
+
+        // The tangential mesh boundaries can accidentally contain prescribed mesh
+        // boundaries if they were in the list of tangential Stokes boundaries.
+        // If so remove them.
+        for (const auto &boundary_id : prescribed_mesh_deformation_boundary_indicators)
+          tangential_mesh_deformation_boundary_indicators.erase(boundary_id);
+
+        // All periodic boundaries are implicitly treated as tangential mesh deformation boundaries.
+        using periodic_boundary_pair = std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>;
+        for (const periodic_boundary_pair &p : this->get_geometry_model().get_periodic_boundary_pairs())
+          {
+            tangential_mesh_deformation_boundary_indicators.insert(p.first.first);
+            tangential_mesh_deformation_boundary_indicators.insert(p.first.second);
+          }
+
+        // Create the list of zero mesh movement (fixed) boundary indicators, these are
+        // all boundaries, which are not prescribed or tangential.
+        zero_mesh_deformation_boundary_indicators = this->get_geometry_model().get_used_boundary_indicators();
+
+        for (const auto &boundary_id : prescribed_mesh_deformation_boundary_indicators)
+          zero_mesh_deformation_boundary_indicators.erase(boundary_id);
+
+        for (const auto &boundary_id : tangential_mesh_deformation_boundary_indicators)
+          zero_mesh_deformation_boundary_indicators.erase(boundary_id);
+
+        prm.enter_subsection ("Free surface");
+        {
+          surface_theta = prm.get_double("Free surface stabilization theta");
+        }
+        prm.leave_subsection ();
+
+      }
+      prm.leave_subsection ();
+
+      // go through the list of object names, create objects and let them parse
+      // their own parameters
+      for (const auto &boundary_and_object_names : mesh_deformation_object_names)
+        {
+          for (const auto &object_name : boundary_and_object_names.second)
+            {
+              mesh_deformation_objects[boundary_and_object_names.first].push_back(
+                std::unique_ptr<Interface<dim>> (std::get<dim>(registered_plugins)
+                                                  .create_plugin (object_name,
+                                                                  "Mesh deformation::Model names")));
+
+              if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(mesh_deformation_objects[boundary_and_object_names.first].back().get()))
+                sim->initialize_simulator (this->get_simulator());
+
+              mesh_deformation_objects[boundary_and_object_names.first].back()->parse_parameters (prm);
+              mesh_deformation_objects[boundary_and_object_names.first].back()->initialize ();
+            }
+        }
+
+      // Go through the objects, and get the indicators for boundaries that need to be stabilized.
+      for (const auto &boundary_and_deformation_objects : mesh_deformation_objects)
+        {
+          for (const auto &model : boundary_and_deformation_objects.second)
+            if (model->needs_surface_stabilization() == true)
+              boundary_indicators_requiring_stabilization.insert(boundary_and_deformation_objects.first);
+        }
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::execute()
+    {
+      AssertThrow(sim.parameters.mesh_deformation_enabled, ExcInternalError());
+
+      TimerOutput::Scope timer (sim.computing_timer, "Mesh deformation");
+
+      old_mesh_displacements = mesh_displacements;
+
+      // Make the constraints for the elliptic problem.
+      make_constraints();
+
+      // Assemble and solve the vector Laplace problem which determines
+      // the mesh displacements in the interior of the domain
+      if (this->is_stokes_matrix_free())
+        compute_mesh_displacements_gmg();
+      else
+        compute_mesh_displacements();
+
+      // Interpolate the mesh velocity into the same
+      // finite element space as used in the Stokes solve, which
+      // is needed for the ALE corrections.
+      interpolate_mesh_velocity();
+
+      // After changing the mesh we need to rebuild things
+      sim.rebuild_stokes_matrix = sim.rebuild_stokes_preconditioner = true;
+    }
+
+
+
+    template <int dim>
+    const Mapping<dim> &
+    MeshDeformationHandler<dim>::get_level_mapping(const unsigned int level) const
+    {
+      return *level_mappings[level].get();
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::make_constraints()
+    {
+      AssertThrow(sim.parameters.mesh_deformation_enabled, ExcInternalError());
+
+      // Now construct the mesh displacement constraints
+      mesh_velocity_constraints.clear();
+#if DEAL_II_VERSION_GTE(9,6,0)
+      mesh_velocity_constraints.reinit(mesh_deformation_dof_handler.locally_owned_dofs(),
+                                       mesh_locally_relevant);
+#else
+      mesh_velocity_constraints.reinit(mesh_locally_relevant);
+#endif
+      // mesh_velocity_constraints can use the same hanging node
+      // information that was used for mesh_vertex constraints.
+      mesh_velocity_constraints.merge(mesh_vertex_constraints);
+
+      // Add the vanilla periodic boundary constraints
+      using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
+      const periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
+      for (const auto &p : pbp)
+        DoFTools::make_periodicity_constraints(mesh_deformation_dof_handler,
+                                               p.first.first,
+                                               p.first.second,
+                                               p.second,
+                                               mesh_velocity_constraints);
+
+      // Zero out the displacement for the zero-velocity boundaries
+      // if the boundary is not in the set of tangential mesh boundaries and not in the set of mesh deformation boundary indicators
+      for (const auto &boundary_id : zero_mesh_deformation_boundary_indicators)
+        {
+          VectorTools::interpolate_boundary_values (this->get_mapping(),
+                                                    mesh_deformation_dof_handler,
+                                                    boundary_id,
+                                                    Functions::ZeroFunction<dim>(dim),
+                                                    mesh_velocity_constraints);
+        }
+
+      this->get_signals().pre_compute_no_normal_flux_constraints(sim.triangulation);
+      // Make the no flux boundary constraints
+      VectorTools::compute_no_normal_flux_constraints (mesh_deformation_dof_handler,
+                                                       /* first_vector_component= */
+                                                       0,
+                                                       tangential_mesh_deformation_boundary_indicators,
+                                                       mesh_velocity_constraints,
+                                                       this->get_mapping());
+
+      this->get_signals().post_compute_no_normal_flux_constraints(sim.triangulation);
+
+      // Ask all plugins to add their constraints.
+      // For the moment add constraints from all plugins into one matrix, then
+      // merge that matrix with the existing constraints (respecting the existing
+      // constraints as more important)
+      AffineConstraints<double> plugin_constraints(mesh_vertex_constraints.get_local_lines());
+
+      for (const auto &boundary_id : mesh_deformation_objects)
+        {
+          std::set<types::boundary_id> boundary_id_set;
+          boundary_id_set.insert(boundary_id.first);
+
+          for (const auto &model : boundary_id.second)
+            {
+              AffineConstraints<double> current_plugin_constraints(mesh_vertex_constraints.get_local_lines());
+
+              model->compute_velocity_constraints_on_boundary(mesh_deformation_dof_handler,
+                                                              current_plugin_constraints,
+                                                              boundary_id_set);
+              if ((this->is_stokes_matrix_free()))
+                {
+                  mg_constrained_dofs.make_zero_boundary_constraints(mesh_deformation_dof_handler,
+                                                                     boundary_id_set);
+                }
+
+              const IndexSet local_lines = current_plugin_constraints.get_local_lines();
+              for (dealii::IndexSet::size_type local_line : local_lines)
+                {
+                  if (current_plugin_constraints.is_constrained(local_line))
+                    {
+                      if (plugin_constraints.is_constrained(local_line) == false)
+                        {
+#if DEAL_II_VERSION_GTE(9,6,0)
+                          plugin_constraints.add_constraint(local_line,
+                                                            {},
+                                                            current_plugin_constraints.get_inhomogeneity(local_line));
+#else
+                          plugin_constraints.add_line(local_line);
+                          plugin_constraints.set_inhomogeneity(local_line,
+                                                               current_plugin_constraints.get_inhomogeneity(local_line));
+#endif
+                        }
+                      else
+                        {
+                          // Add the inhomogeneity of the current plugin to the existing constraints
+                          const double inhomogeneity = plugin_constraints.get_inhomogeneity(local_line);
+                          plugin_constraints.set_inhomogeneity(local_line, current_plugin_constraints.get_inhomogeneity(local_line) + inhomogeneity);
+                        }
+                    }
+                }
+            }
+        }
+
+      mesh_velocity_constraints.merge(plugin_constraints,AffineConstraints<double>::left_object_wins);
+      mesh_velocity_constraints.close();
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::make_initial_constraints()
+    {
+      AssertThrow(this->get_parameters().mesh_deformation_enabled, ExcInternalError());
+
+      // This might look incorrect at first glance, but it is okay to
+      // overwrite the velocity constraints with our displacements
+      // because this object is used for updating the displacement in
+      // compute_mesh_displacements().
+      mesh_velocity_constraints.clear();
+#if DEAL_II_VERSION_GTE(9,6,0)
+      mesh_velocity_constraints.reinit(mesh_deformation_dof_handler.locally_owned_dofs(),
+                                       mesh_locally_relevant);
+#else
+      mesh_velocity_constraints.reinit(mesh_locally_relevant);
+#endif
+      // mesh_velocity_constraints can use the same hanging node
+      // information that was used for mesh_vertex constraints.
+      mesh_velocity_constraints.merge(mesh_vertex_constraints);
+
+      // Add the vanilla periodic boundary constraints
+      std::set<types::boundary_id> periodic_boundaries;
+      using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
+      const periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
+      for (const auto &p : pbp)
+        {
+          periodic_boundaries.insert(p.first.first);
+          periodic_boundaries.insert(p.first.second);
+
+          DoFTools::make_periodicity_constraints(mesh_deformation_dof_handler,
+                                                 p.first.first,
+                                                 p.first.second,
+                                                 p.second,
+                                                 mesh_velocity_constraints);
+        }
+
+      // Zero out the displacement for the fixed boundaries
+      for (const types::boundary_id &boundary_id : zero_mesh_deformation_boundary_indicators)
+        {
+          VectorTools::interpolate_boundary_values (this->get_mapping(),
+                                                    mesh_deformation_dof_handler,
+                                                    boundary_id,
+                                                    Functions::ZeroFunction<dim>(dim),
+                                                    mesh_velocity_constraints);
+        }
+
+      // Make tangential deformation constraints for tangential boundaries
+      this->get_signals().pre_compute_no_normal_flux_constraints(sim.triangulation);
+      VectorTools::compute_no_normal_flux_constraints (mesh_deformation_dof_handler,
+                                                       /* first_vector_component= */
+                                                       0,
+                                                       tangential_mesh_deformation_boundary_indicators,
+                                                       mesh_velocity_constraints,
+                                                       this->get_mapping());
+      this->get_signals().post_compute_no_normal_flux_constraints(sim.triangulation);
+
+      // Ask all plugins to add their constraints.
+      // For the moment add constraints from all plugins into one matrix, then
+      // merge that matrix with the existing constraints (respecting the existing
+      // constraints as more important)
+      AffineConstraints<double> plugin_constraints(mesh_vertex_constraints.get_local_lines());
+
+      std::set<types::boundary_id> boundary_id_set;
+
+      for (const auto &boundary_id_and_deformation_objects: mesh_deformation_objects)
+        {
+          for (const auto &deformation_object : boundary_id_and_deformation_objects.second)
+            {
+              AffineConstraints<double> current_plugin_constraints(mesh_vertex_constraints.get_local_lines());
+
+              Utilities::VectorFunctionFromVelocityFunctionObject<dim> vel
+              (dim,
+               [&] (const Point<dim> &x) -> Tensor<1,dim>
+              {
+                return deformation_object->compute_initial_deformation_on_boundary(boundary_id_and_deformation_objects.first, x);
+              });
+
+              VectorTools::interpolate_boundary_values (this->get_mapping(),
+                                                        mesh_deformation_dof_handler,
+                                                        boundary_id_and_deformation_objects.first,
+                                                        vel,
+                                                        current_plugin_constraints);
+
+              boundary_id_set.insert(boundary_id_and_deformation_objects.first);
+
+
+              const IndexSet local_lines = current_plugin_constraints.get_local_lines();
+              for (dealii::IndexSet::size_type local_line : local_lines)
+                {
+                  if (current_plugin_constraints.is_constrained(local_line))
+                    {
+                      if (plugin_constraints.is_constrained(local_line) == false)
+                        {
+#if DEAL_II_VERSION_GTE(9,6,0)
+                          plugin_constraints.add_constraint(local_line,
+                                                            {},
+                                                            current_plugin_constraints.get_inhomogeneity(local_line));
+#else
+                          plugin_constraints.add_line(local_line);
+                          plugin_constraints.set_inhomogeneity(local_line,
+                                                               current_plugin_constraints.get_inhomogeneity(local_line));
+#endif
+                        }
+                      else
+                        {
+                          // Add the current plugin constraints to the existing inhomogeneity
+                          const double inhomogeneity = plugin_constraints.get_inhomogeneity(local_line);
+                          plugin_constraints.set_inhomogeneity(local_line, current_plugin_constraints.get_inhomogeneity(local_line) + inhomogeneity);
+                        }
+                    }
+                }
+            }
+        }
+      if ((this->is_stokes_matrix_free()))
+        {
+          mg_constrained_dofs.make_zero_boundary_constraints(mesh_deformation_dof_handler,
+                                                             boundary_id_set);
+        }
+      mesh_velocity_constraints.merge(plugin_constraints,
+                                      AffineConstraints<double>::left_object_wins);
+      mesh_velocity_constraints.close();
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::compute_mesh_displacements()
+    {
+      // This functions updates the mesh displacement of the whole
+      // domain (stored in the vector mesh_displacements) based on
+      // information on the boundary.
+      //
+      // Each step, we get the velocity specified on the free surface
+      // boundary (stored in mesh_velocity_constraints) and solve for
+      // the velocity in the interior by solving a vector Laplace
+      // problem. This velocity is then used to update the
+      // displacement vector.
+      //
+      // This is different in timestep 0. Here, the information on the
+      // boundary is actually a displacement (given initial
+      // topography), which is used to set the initial
+      // displacement. The process in this function is otherwise
+      // identical.
+
+      const QGauss<dim> quadrature(mesh_deformation_fe.degree + 1);
+      UpdateFlags update_flags = UpdateFlags(update_values | update_JxW_values | update_gradients);
+      FEValues<dim> fe_values (*sim.mapping, mesh_deformation_fe, quadrature, update_flags);
+
+      const unsigned int dofs_per_cell = fe_values.dofs_per_cell,
+                         dofs_per_face = sim.finite_element.dofs_per_face,
+                         n_q_points    = fe_values.n_quadrature_points;
+
+      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
+      std::vector<unsigned int> face_dof_indices (dofs_per_face);
+      Vector<double> cell_vector (dofs_per_cell);
+      FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
+
+      // We are just solving a Laplacian in each spatial direction, so
+      // the degrees of freedom for different dimensions do not couple.
+      Table<2,DoFTools::Coupling> coupling (dim, dim);
+      coupling.fill(DoFTools::none);
+
+      for (unsigned int c=0; c<dim; ++c)
+        coupling[c][c] = DoFTools::always;
+
+      LinearAlgebra::SparseMatrix mesh_matrix;
+      TrilinosWrappers::SparsityPattern sp (mesh_locally_owned,
+                                            mesh_locally_owned,
+                                            mesh_locally_relevant,
+                                            sim.mpi_communicator);
+      DoFTools::make_sparsity_pattern (mesh_deformation_dof_handler,
+                                       coupling, sp,
+                                       mesh_velocity_constraints, false,
+                                       Utilities::MPI::
+                                       this_mpi_process(sim.mpi_communicator));
+      sp.compress();
+      mesh_matrix.reinit (sp);
+
+      // carry out the solution
+      FEValuesExtractors::Vector extract_vel(0);
+
+      LinearAlgebra::Vector rhs, solution;
+      rhs.reinit(mesh_locally_owned, sim.mpi_communicator);
+      solution.reinit(mesh_locally_owned, sim.mpi_communicator);
+
+      for (const auto &cell : mesh_deformation_dof_handler.active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            cell->get_dof_indices (cell_dof_indices);
+            fe_values.reinit (cell);
+
+            cell_vector = 0;
+            cell_matrix = 0;
+            for (unsigned int point=0; point<n_q_points; ++point)
+              for (unsigned int i=0; i<dofs_per_cell; ++i)
+                {
+                  for (unsigned int j=0; j<dofs_per_cell; ++j)
+                    cell_matrix(i,j) += scalar_product( fe_values[extract_vel].gradient(i,point),
+                                                        fe_values[extract_vel].gradient(j,point) ) *
+                                        fe_values.JxW(point);
+                }
+
+            mesh_velocity_constraints.distribute_local_to_global (cell_matrix, cell_vector,
+                                                                  cell_dof_indices, mesh_matrix, rhs, false);
+          }
+
+      rhs.compress (VectorOperation::add);
+      mesh_matrix.compress (VectorOperation::add);
+
+      // Make the AMG preconditioner
+      std::vector<std::vector<bool>> constant_modes;
+      DoFTools::extract_constant_modes (mesh_deformation_dof_handler,
+                                        ComponentMask(dim, true),
+                                        constant_modes);
+      // TODO: think about keeping object between time steps
+      LinearAlgebra::PreconditionAMG preconditioner_stiffness;
+      LinearAlgebra::PreconditionAMG::AdditionalData Amg_data;
+      Amg_data.constant_modes = constant_modes;
+      Amg_data.elliptic = true;
+      Amg_data.higher_order_elements = false;
+      Amg_data.smoother_sweeps = 2;
+      Amg_data.aggregation_threshold = 0.02;
+      preconditioner_stiffness.initialize(mesh_matrix);
+
+      // we solve with higher accuracy in the initial timestep:
+      const double tolerance
+        = sim.parameters.linear_stokes_solver_tolerance
+          * ((this->simulator_is_past_initialization()) ? 1.0 : 1e-5);
+
+      SolverControl solver_control(5*rhs.size(), tolerance * rhs.l2_norm());
+      SolverCG<LinearAlgebra::Vector> cg(solver_control);
+
+      cg.solve (mesh_matrix, solution, rhs, preconditioner_stiffness);
+      this->get_pcout() << "   Solving mesh displacement system... " << solver_control.last_step() <<" iterations."<< std::endl;
+
+      mesh_velocity_constraints.distribute (solution);
+
+      // Update the mesh velocity vector
+      fs_mesh_velocity = solution;
+
+      // Update the mesh displacement vector
+      if (this->simulator_is_past_initialization())
+        {
+          // during the simulation, we add dt*solution
+          LinearAlgebra::Vector distributed_mesh_displacements(mesh_locally_owned, sim.mpi_communicator);
+          distributed_mesh_displacements = mesh_displacements;
+          distributed_mesh_displacements.add(this->get_timestep(), solution);
+          mesh_displacements = distributed_mesh_displacements;
+        }
+      else
+        {
+          // In the initial step we apply 100% of the initial displacement
+          mesh_displacements = solution;
+        }
+
+      if (this->is_stokes_matrix_free())
+        update_multilevel_deformation();
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::compute_mesh_displacements_gmg()
+    {
+      // Same as compute_mesh_displacements, but using matrix-free GMG
+      // instead of matrix-based AMG.
+
+      // We use this gmg solver only when the gmg stokes solver is used
+      // for the following reasons (TODO):
+      // 1. this gmg solver does not support periodic boundary conditions
+      // 2. To use this solver even when gmg stokes solver is not used, we need to
+      //    initialize the triangulation with Triangulation<dim>::limit_level_difference_at_vertices
+      //    and parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy
+      // 3. Although this gmg solver is much faster than the amg solver, it's only tested for
+      //    limited free surface cases.
+
+      Assert(mesh_deformation_fe.degree == 1, ExcNotImplemented());
+      // To be efficient, the operations performed in the matrix-free implementation require
+      // knowledge of loop lengths at compile time, which are given by the degree of the finite element.
+      const unsigned int mesh_deformation_fe_degree = 1;
+
+      using SystemOperatorType = dealii::MatrixFreeOperators::
+                                 LaplaceOperator<dim, mesh_deformation_fe_degree, mesh_deformation_fe_degree + 1, dim>;
+
+      SystemOperatorType laplace_operator;
+
+      MGLevelObject<SystemOperatorType> mg_matrices;
+
+      typename MatrixFree<dim, double>::AdditionalData additional_data;
+      additional_data.tasks_parallel_scheme =
+        MatrixFree<dim, double>::AdditionalData::none;
+      const UpdateFlags update_flags(update_values | update_JxW_values | update_gradients);
+      additional_data.mapping_update_flags = update_flags;
+      std::shared_ptr<MatrixFree<dim, double>> system_mf_storage
+        = std::make_shared<MatrixFree<dim, double>>();
+      system_mf_storage->reinit(*sim.mapping,
+                                mesh_deformation_dof_handler,
+                                mesh_velocity_constraints,
+                                QGauss<1>(mesh_deformation_fe_degree + 1),
+                                additional_data);
+      laplace_operator.initialize(system_mf_storage);
+
+      // correct rhs:
+      // In a matrix-free method, since the LaplaceOperator class represents
+      // the matrix-vector product of a homogeneous operator (the left-hand
+      // side of the last formula). It does not matter whether the AffineConstraints
+      // object passed to the MatrixFree::reinit() contains inhomogeneous constraints or not,
+      // the MatrixFree::cell_loop() call will only resolve the homogeneous
+      // part of the constraints as long as it represents a linear operator.
+
+      // What this function does is to move the inhomogeneous constraints to the
+      // right-hand side of the system by computing the residual of the system
+      // and subtracting it from the right-hand side: r = b - A*u0,
+      // where u0 is the initial guess and stored the degrees of freedom constrained by
+      // Inhomogeneous Dirichlet boundary conditions, and r is rhs.
+      // Then we have a new system Ax = r, and the solution is u = u0 + x.
+      // More details can be found in deal.II tutorial step-37 Section Possibilities for extensions.
+      dealii::LinearAlgebra::distributed::Vector<double> u0, rhs, solution;
+      laplace_operator.initialize_dof_vector(u0);
+      laplace_operator.initialize_dof_vector(rhs);
+      laplace_operator.initialize_dof_vector(solution);
+      u0 = 0.;
+      mesh_velocity_constraints.distribute(u0);
+      u0.update_ghost_values();
+
+      rhs = 0.;
+
+      FEEvaluation<dim, mesh_deformation_fe_degree, mesh_deformation_fe_degree + 1, dim, double> mesh_deformation(*laplace_operator.get_matrix_free());
+      for (unsigned int cell = 0;
+           cell < laplace_operator.get_matrix_free()->n_cell_batches();
+           ++cell)
+        {
+          mesh_deformation.reinit(cell);
+          mesh_deformation.read_dof_values_plain(u0);
+          mesh_deformation.evaluate(EvaluationFlags::gradients);
+          for (unsigned int q = 0; q < mesh_deformation.n_q_points; ++q)
+            {
+              mesh_deformation.submit_gradient(-1.0 * mesh_deformation.get_gradient(q), q);
+            }
+          mesh_deformation.integrate(EvaluationFlags::gradients);
+          mesh_deformation.distribute_local_to_global(rhs);
+        }
+      rhs.compress(VectorOperation::add);
+
+      // clear the level constraints of the previous time step
+      mg_constrained_dofs.clear_user_constraints();
+
+      // setup GMG, following deal.II step-37:
+      const unsigned int n_levels = sim.triangulation.n_global_levels();
+
+      // Currently does not support periodic boundary constraints
+      {
+        using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
+        const periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
+        AssertThrow(pbp.size() == 0,
+                    ExcMessage("Periodic boundary constraints are not supported in computing mesh displacements using GMG."));
+      }
+
+      mg_constrained_dofs.make_zero_boundary_constraints(mesh_deformation_dof_handler,
+                                                         zero_mesh_deformation_boundary_indicators);
+
+      mg_matrices.clear_elements();
+      mg_matrices.resize(0, n_levels-1);
+
+      for (unsigned int level = 0; level < n_levels; ++level)
+        {
+          IndexSet relevant_dofs;
+          DoFTools::extract_locally_relevant_level_dofs(mesh_deformation_dof_handler,
+                                                        level,
+                                                        relevant_dofs);
+          AffineConstraints<double> level_constraints;
+#if DEAL_II_VERSION_GTE(9,6,0)
+          level_constraints.reinit(mesh_deformation_dof_handler.locally_owned_mg_dofs(level),
+                                   relevant_dofs);
+          for (const auto index : mg_constrained_dofs.get_boundary_indices(level))
+            level_constraints.constrain_dof_to_zero(index);
+#else
+          level_constraints.reinit(relevant_dofs);
+          level_constraints.add_lines(mg_constrained_dofs.get_boundary_indices(level));
+#endif
+          level_constraints.close();
+
+          const Mapping<dim> &mapping = get_level_mapping(level);
+
+          std::set<types::boundary_id> no_flux_boundary
+            = sim.boundary_velocity_manager.get_tangential_boundary_velocity_indicators();
+          if (!no_flux_boundary.empty())
+            {
+              AffineConstraints<double> user_level_constraints;
+#if DEAL_II_VERSION_GTE(9,6,0)
+              user_level_constraints.reinit(mesh_deformation_dof_handler.locally_owned_mg_dofs(level),
+                                            relevant_dofs);
+#else
+              user_level_constraints.reinit(relevant_dofs);
+#endif
+              const IndexSet &refinement_edge_indices =
+                mg_constrained_dofs.get_refinement_edge_indices(level);
+              dealii::VectorTools::compute_no_normal_flux_constraints_on_level(
+                mesh_deformation_dof_handler,
+                0,
+                no_flux_boundary,
+                user_level_constraints,
+                mapping,
+                refinement_edge_indices,
+                level);
+
+              user_level_constraints.close();
+              mg_constrained_dofs.add_user_constraints(level, user_level_constraints);
+
+              // let Dirichlet values win over no normal flux:
+              level_constraints.merge(user_level_constraints, AffineConstraints<double>::left_object_wins);
+              level_constraints.close();
+            }
+
+          typename MatrixFree<dim, double>::AdditionalData additional_data;
+          additional_data.tasks_parallel_scheme =
+            MatrixFree<dim, double>::AdditionalData::none;
+          additional_data.mapping_update_flags = update_flags;
+          additional_data.mg_level = level;
+          std::shared_ptr<MatrixFree<dim, double>> mg_mf_storage_level
+            = std::make_shared<MatrixFree<dim, double>>();
+
+          mg_mf_storage_level->reinit(mapping,
+                                      mesh_deformation_dof_handler,
+                                      level_constraints,
+                                      QGauss<1>(mesh_deformation_fe_degree + 1),
+                                      additional_data);
+          mg_matrices[level].clear();
+          mg_matrices[level].initialize(mg_mf_storage_level,
+                                        mg_constrained_dofs,
+                                        level);
+        }
+
+      MGTransferMF<dim, double> mg_transfer(mg_constrained_dofs);
+      mg_transfer.build(mesh_deformation_dof_handler);
+
+      using SmootherType =
+        PreconditionChebyshev<SystemOperatorType, dealii::LinearAlgebra::distributed::Vector<double>>;
+
+      mg::SmootherRelaxation<SmootherType, dealii::LinearAlgebra::distributed::Vector<double>> mg_smoother;
+
+      MGLevelObject<typename SmootherType::AdditionalData> smoother_data;
+      smoother_data.resize(0, n_levels - 1);
+
+      // Smoother: Chebyshev, degree 5. We use a relatively high degree here (5),
+      // since matrix-vector products are comparably cheap. We choose to smooth out
+      // a range of [1.2lambda_max/15,1.2lambda_max] in the smoother where lambda_max
+      // is an estimate of the largest eigenvalue (the factor 1.2 is applied inside
+      // PreconditionChebyshev). In order to compute that eigenvalue,
+      // the Chebyshev initialization performs a few steps of a CG algorithm without preconditioner.
+      // Since the highest eigenvalue is usually the easiest one to find
+      // and a rough estimate is enough, we choose 10 iterations.
+      for (unsigned int level = 0; level < n_levels;
+           ++level)
+        {
+          if (level > 0)
+            {
+              smoother_data[level].smoothing_range = 15.;
+              smoother_data[level].degree = 5;
+              smoother_data[level].eig_cg_n_iterations = 10;
+            }
+          else
+            {
+              // On level zero, we initialize the smoother differently
+              // because we want to use the Chebyshev iteration as a solver.
+              smoother_data[0].smoothing_range = 1e-3;
+              smoother_data[0].degree = numbers::invalid_unsigned_int;
+              smoother_data[0].eig_cg_n_iterations = mg_matrices[0].m();
+            }
+          mg_matrices[level].compute_diagonal();
+          smoother_data[level].preconditioner =
+            mg_matrices[level].get_matrix_diagonal_inverse();
+        }
+      mg_smoother.initialize(mg_matrices, smoother_data);
+      MGCoarseGridApplySmoother<dealii::LinearAlgebra::distributed::Vector<double>> mg_coarse;
+      mg_coarse.initialize(mg_smoother);
+
+      // set up the interface matrices
+      mg::Matrix<dealii::LinearAlgebra::distributed::Vector<double>> mg_matrix(mg_matrices);
+      MGLevelObject<MatrixFreeOperators::MGInterfaceOperator<SystemOperatorType>> mg_interface_matrices;
+      mg_interface_matrices.resize(0, n_levels - 1);
+      for (unsigned int level = 0; level < n_levels;
+           ++level)
+        mg_interface_matrices[level].initialize(mg_matrices[level]);
+      mg::Matrix<dealii::LinearAlgebra::distributed::Vector<double>> mg_interface(mg_interface_matrices);
+      Multigrid<dealii::LinearAlgebra::distributed::Vector<double>> mg(mg_matrix, mg_coarse, mg_transfer, mg_smoother, mg_smoother);
+      mg.set_edge_matrices(mg_interface, mg_interface);
+      PreconditionMG<dim,
+                     dealii::LinearAlgebra::distributed::Vector<double>,
+                     MGTransferMF<dim, double>>
+                     preconditioner(mesh_deformation_dof_handler, mg, mg_transfer);
+
+
+      // solve
+      const double tolerance
+        = sim.parameters.linear_stokes_solver_tolerance
+          * ((this->simulator_is_past_initialization()) ? 1.0 : 1e-5);
+
+      SolverControl solver_control_mf(5 * rhs.size(),
+                                      tolerance * rhs.l2_norm());
+      SolverCG<dealii::LinearAlgebra::distributed::Vector<double>> cg(solver_control_mf);
+
+      mesh_velocity_constraints.set_zero(solution);
+      cg.solve(laplace_operator, solution, rhs, preconditioner);
+      this->get_pcout() << "   Solving mesh displacement system... " << solver_control_mf.last_step() <<" iterations."<< std::endl;
+
+      mesh_velocity_constraints.distribute(solution);
+      solution.update_ghost_values();
+
+      // copy solution:
+      LinearAlgebra::Vector solution_tmp;
+      solution_tmp.reinit(mesh_locally_owned, sim.mpi_communicator);
+      internal::ChangeVectorTypes::copy(solution_tmp, solution);
+
+      // Update the mesh velocity vector
+      fs_mesh_velocity = solution_tmp;
+
+      // Update the mesh displacement vector
+      if (this->simulator_is_past_initialization())
+        {
+          // during the simulation, we add dt*solution
+          LinearAlgebra::Vector distributed_mesh_displacements(mesh_locally_owned, sim.mpi_communicator);
+          distributed_mesh_displacements = mesh_displacements;
+          distributed_mesh_displacements.add(this->get_timestep(), solution_tmp);
+          mesh_displacements = distributed_mesh_displacements;
+        }
+      else
+        {
+          // In the initial step we apply 100% of the initial displacement
+          mesh_displacements = solution_tmp;
+        }
+
+      update_multilevel_deformation();
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::set_initial_topography()
+    {
+      LinearAlgebra::Vector distributed_initial_topography;
+      distributed_initial_topography.reinit(mesh_locally_owned, sim.mpi_communicator);
+
+      if (!include_initial_topography)
+        distributed_initial_topography = 0.;
+      else
+        {
+          const std::vector<Point<dim>> support_points
+            = mesh_deformation_fe.base_element(0).get_unit_support_points();
+
+          const Quadrature<dim> quad(support_points);
+          const UpdateFlags update_flags = UpdateFlags(update_quadrature_points);
+          FEValues<dim> fs_fe_values (*sim.mapping, mesh_deformation_fe, quad, update_flags);
+
+          const unsigned int n_q_points = fs_fe_values.n_quadrature_points,
+                             dofs_per_cell = fs_fe_values.dofs_per_cell;
+
+          std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
+
+          for (const auto &cell : mesh_deformation_dof_handler.active_cell_iterators())
+            if (cell->is_locally_owned())
+              {
+                cell->get_dof_indices (cell_dof_indices);
+
+                fs_fe_values.reinit (cell);
+                for (unsigned int j=0; j<n_q_points; ++j)
+                  {
+                    Point<dim-1> surface_point;
+                    std::array<double, dim> natural_coord = this->get_geometry_model().cartesian_to_natural_coordinates(fs_fe_values.quadrature_point(j));
+                    if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()))
+                      {
+                        for (unsigned int d=0; d<dim-1; ++d)
+                          surface_point[d] = natural_coord[d];
+                      }
+                    else
+                      {
+                        for (unsigned int d=1; d<dim; ++d)
+                          surface_point[d-1] = natural_coord[d];
+                      }
+                    // Get the topography at this point.
+                    const double topo = this->get_initial_topography_model().value(surface_point);
+
+
+                    // TODO adapt to radial topography
+                    const unsigned int support_point_index
+                      = mesh_deformation_fe.component_to_system_index(dim-1,/*dof index within component=*/ j);
+                    distributed_initial_topography[cell_dof_indices[support_point_index]] = topo;
+                  }
+              }
+        }
+
+      distributed_initial_topography.compress(VectorOperation::insert);
+      initial_topography = distributed_initial_topography;
+    }
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::interpolate_mesh_velocity()
+    {
+      // Interpolate the mesh vertex velocity onto the Stokes velocity system for use in ALE corrections
+      LinearAlgebra::BlockVector distributed_mesh_velocity;
+      distributed_mesh_velocity.reinit(sim.introspection.index_sets.system_partitioning, sim.mpi_communicator);
+
+      const std::vector<Point<dim>> support_points
+        = sim.finite_element.base_element(sim.introspection.component_indices.velocities[0]).get_unit_support_points();
+
+      const Quadrature<dim> quad(support_points);
+      const UpdateFlags update_flags = UpdateFlags(update_values | update_JxW_values);
+      FEValues<dim> fs_fe_values (*sim.mapping, mesh_deformation_fe, quad, update_flags);
+      FEValues<dim> fe_values (*sim.mapping, sim.finite_element, quad, update_flags);
+      const unsigned int n_q_points = fe_values.n_quadrature_points,
+                         dofs_per_cell = fe_values.dofs_per_cell;
+
+      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
+      FEValuesExtractors::Vector extract_vel(0);
+      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
+
+      typename DoFHandler<dim>::active_cell_iterator
+      fscell = mesh_deformation_dof_handler.begin_active();
+
+      for (const auto &cell : sim.dof_handler.active_cell_iterators())
+        {
+          if (cell->is_locally_owned())
+            {
+              cell->get_dof_indices (cell_dof_indices);
+
+              fe_values.reinit (cell);
+              fs_fe_values.reinit (fscell);
+              fs_fe_values[extract_vel].get_function_values(fs_mesh_velocity, velocity_values);
+              for (unsigned int j=0; j<n_q_points; ++j)
+                for (unsigned int dir=0; dir<dim; ++dir)
+                  {
+                    const unsigned int support_point_index
+                      = sim.finite_element.component_to_system_index(/*velocity component=*/ sim.introspection.component_indices.velocities[dir],
+                                                                                             /*dof index within component=*/ j);
+                    distributed_mesh_velocity[cell_dof_indices[support_point_index]] = velocity_values[j][dir];
+                  }
+            }
+          ++fscell;
+        }
+
+      distributed_mesh_velocity.compress(VectorOperation::insert);
+      mesh_velocity = distributed_mesh_velocity;
+    }
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::setup_dofs()
+    {
+      AssertThrow(sim.parameters.mesh_deformation_enabled, ExcInternalError());
+
+      // these live in the same FE as the velocity variable:
+      mesh_velocity.reinit(sim.introspection.index_sets.system_partitioning,
+                           sim.introspection.index_sets.system_relevant_partitioning,
+                           sim.mpi_communicator);
+
+      mesh_deformation_dof_handler.distribute_dofs(mesh_deformation_fe);
+
+      // Renumber the DoFs hierarchical so that we get the
+      // same numbering if we resume the computation. This
+      // is because the numbering depends on the order the
+      // cells are created.
+      DoFRenumbering::hierarchical (mesh_deformation_dof_handler);
+
+      if (this->is_stokes_matrix_free())
+        {
+          mesh_deformation_dof_handler.distribute_mg_dofs();
+
+          mg_constrained_dofs.initialize(mesh_deformation_dof_handler);
+
+          const unsigned int n_levels = this->get_triangulation().n_global_levels();
+
+          level_displacements.resize(0, n_levels-1);
+          // Important! Preallocate level vectors with all needed ghost
+          // entries. While interpolate_to_mg can create these vectors
+          // automatically, they will not contain all ghost values that we
+          // need to evaluate the mapping later.
+          for (unsigned int level = 0; level < n_levels; ++level)
+            {
+              IndexSet relevant_mg_dofs;
+              DoFTools::extract_locally_relevant_level_dofs(mesh_deformation_dof_handler,
+                                                            level,
+                                                            relevant_mg_dofs);
+              level_displacements[level].reinit(mesh_deformation_dof_handler.locally_owned_mg_dofs(level),
+                                                relevant_mg_dofs,
+                                                sim.mpi_communicator);
+              level_displacements[level].update_ghost_values();
+            }
+
+          // create the mappings on each level:
+          level_mappings.resize(0, n_levels-1);
+          level_mappings.apply([&](const unsigned int level, std::unique_ptr<Mapping<dim>> &object)
+          {
+            object = std::make_unique<MappingQEulerian<dim,
+            dealii::LinearAlgebra::distributed::Vector<double>>>(
+              /* degree = */ 1,
+              mesh_deformation_dof_handler,
+              level_displacements[level],
+              level);
+          });
+
+          mg_transfer.build(mesh_deformation_dof_handler);
+
+        }
+
+      {
+        std::locale s = this->get_pcout().get_stream().getloc();
+        // Creating std::locale with an empty string previously caused problems
+        // on some platforms, so the functionality to catch the exception and ignore
+        // is kept here, even though explicitly setting a facet should always work.
+        try
+          {
+            // Imbue the stream with a locale that does the right thing. The
+            // locale is responsible for later deleting the object pointed
+            // to by the last argument (the "facet"), see
+            // https://en.cppreference.com/w/cpp/locale/locale/locale
+            this->get_pcout().get_stream().imbue(std::locale(std::locale(),
+                                                             new aspect::Utilities::ThousandSep));
+          }
+        catch (const std::runtime_error &e)
+          {
+            // If the locale doesn't work, just give up
+          }
+
+        this->get_pcout() << "Number of mesh deformation degrees of freedom: "
+                          << mesh_deformation_dof_handler.n_dofs()
+                          << std::endl;
+
+        this->get_pcout().get_stream().imbue(s);
+      }
+
+      mesh_locally_owned = mesh_deformation_dof_handler.locally_owned_dofs();
+      DoFTools::extract_locally_relevant_dofs (mesh_deformation_dof_handler,
+                                               mesh_locally_relevant);
+
+      // This will initialize the mesh displacement and free surface
+      // mesh velocity vectors with zero-valued entries.
+      mesh_displacements.reinit(mesh_locally_owned, mesh_locally_relevant, sim.mpi_communicator);
+      old_mesh_displacements.reinit(mesh_locally_owned, mesh_locally_relevant, sim.mpi_communicator);
+      initial_topography.reinit(mesh_locally_owned, mesh_locally_relevant, sim.mpi_communicator);
+      fs_mesh_velocity.reinit(mesh_locally_owned, mesh_locally_relevant, sim.mpi_communicator);
+
+      // if we are just starting, we need to set the initial topography.
+      if (this->simulator_is_past_initialization() == false ||
+          this->get_timestep_number() == 0)
+        set_initial_topography();
+
+      // We would like to make sure that the mesh stays conforming upon
+      // redistribution, so we construct mesh_vertex_constraints, which
+      // keeps track of hanging node constraints.
+      // Note: this would be a more natural fit in make_constraints(),
+      // but we would like to be able to apply vertex constraints directly
+      // after setup_dofs(), as is done, for instance, during mesh
+      // refinement.
+      mesh_vertex_constraints.clear();
+#if DEAL_II_VERSION_GTE(9,6,0)
+      mesh_vertex_constraints.reinit(mesh_deformation_dof_handler.locally_owned_dofs(),
+                                     mesh_locally_relevant);
+#else
+      mesh_vertex_constraints.reinit(mesh_locally_relevant);
+#endif
+      DoFTools::make_hanging_node_constraints(mesh_deformation_dof_handler, mesh_vertex_constraints);
+
+      // We can safely close this now
+      mesh_vertex_constraints.close();
+
+      // if we are just starting, we need to prescribe the initial deformation
+      if (this->simulator_is_past_initialization() == false ||
+          this->get_timestep_number() == 0)
+        {
+          TimerOutput::Scope timer (sim.computing_timer, "Mesh deformation initialize");
+
+          make_initial_constraints();
+          if (this->is_stokes_matrix_free())
+            compute_mesh_displacements_gmg();
+          else
+            compute_mesh_displacements();
+        }
+
+      if (this->is_stokes_matrix_free())
+        update_multilevel_deformation();
+    }
+
+
+
+    template <int dim>
+    void MeshDeformationHandler<dim>::update_multilevel_deformation ()
+    {
+      Assert(this->is_stokes_matrix_free(), ExcInternalError());
+
+      // Convert the mesh_displacements to a d:Vector that we can use
+      // to transfer to the MG levels below. The conversion is done by
+      // going through a ReadWriteVector.
+      dealii::LinearAlgebra::distributed::Vector<double> displacements(mesh_deformation_dof_handler.locally_owned_dofs(),
+                                                                       this->get_triangulation().get_communicator());
+      dealii::LinearAlgebra::ReadWriteVector<double> rwv;
+      rwv.reinit(mesh_displacements);
+      displacements.import(rwv, VectorOperation::insert);
+
+      const unsigned int n_levels = sim.triangulation.n_global_levels();
+      for (unsigned int level = 0; level < n_levels; ++level)
+        {
+          level_displacements[level].zero_out_ghost_values();
+        }
+
+      mg_transfer.interpolate_to_mg(mesh_deformation_dof_handler,
+                                    level_displacements,
+                                    displacements);
+
+      for (unsigned int level = 0; level < n_levels; ++level)
+        {
+          level_displacements[level].update_ghost_values();
+        }
+
+    }
+
+
+
+    template <int dim>
+    const std::map<types::boundary_id, std::vector<std::string>> &
+    MeshDeformationHandler<dim>::get_active_mesh_deformation_names () const
+    {
+      return mesh_deformation_object_names;
+    }
+
+
+
+    template <int dim>
+    const std::map<types::boundary_id,std::vector<std::unique_ptr<Interface<dim>>>> &
+    MeshDeformationHandler<dim>::get_active_mesh_deformation_models () const
+    {
+      return mesh_deformation_objects;
+    }
+
+
+
+    template <int dim>
+    const std::set<types::boundary_id> &
+    MeshDeformationHandler<dim>::get_active_mesh_deformation_boundary_indicators () const
+    {
+      return prescribed_mesh_deformation_boundary_indicators;
+    }
+
+
+
+    template <int dim>
+    const std::set<types::boundary_id> &
+    MeshDeformationHandler<dim>::get_boundary_indicators_requiring_stabilization () const
+    {
+      return boundary_indicators_requiring_stabilization;
+    }
+
+
+
+    template <int dim>
+    const std::set<types::boundary_id> &
+    MeshDeformationHandler<dim>::get_free_surface_boundary_indicators () const
+    {
+      return free_surface_boundary_indicators;
+    }
+
+
+
+    template <int dim>
+    double MeshDeformationHandler<dim>::get_free_surface_theta()const
+    {
+      return surface_theta;
+    }
+
+
+
+    template <int dim>
+    const LinearAlgebra::Vector &
+    MeshDeformationHandler<dim>::get_mesh_displacements () const
+    {
+      return mesh_displacements;
+    }
+
+
+
+    template <int dim>
+    const DoFHandler<dim> &
+    MeshDeformationHandler<dim>::get_mesh_deformation_dof_handler () const
+    {
+      return mesh_deformation_dof_handler;
+    }
+
+
+
+    template <int dim>
+    const LinearAlgebra::Vector &
+    MeshDeformationHandler<dim>::get_initial_topography () const
+    {
+      return initial_topography;
+    }
+
+
+
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ()
+    {
+      return std::get<dim>(registered_plugins).get_pattern_of_names ();
+    }
+
+
+
+    template <int dim>
+    void
+    MeshDeformationHandler<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Mesh deformation interface",
+                                                            out);
+    }
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<MeshDeformation::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<MeshDeformation::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<MeshDeformation::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<MeshDeformation::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace MeshDeformation
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class MeshDeformationHandler<dim>; \
+  \
+  template \
+  std::string \
+  get_valid_model_names_pattern<dim> ();
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/mesh_refinement/artificial_viscosity.cc.bak b/source/mesh_refinement/artificial_viscosity.cc.bak
new file mode 100644
index 00000000000..55573204606
--- /dev/null
+++ b/source/mesh_refinement/artificial_viscosity.cc.bak
@@ -0,0 +1,132 @@
+/*
+  Copyright (C) 2015 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/artificial_viscosity.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    ArtificialViscosity<dim>::execute(Vector<float> &indicators) const
+    {
+      indicators = 0;
+      Vector<float> this_indicator(indicators.size());
+      if (temperature_scaling_factor > 0.0)
+        {
+          this->get_artificial_viscosity(indicators);
+          indicators *= temperature_scaling_factor;
+        }
+
+      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+        {
+          this_indicator = 0;
+          this->get_artificial_viscosity_composition(this_indicator, c);
+
+          // compute indicators += c*this_indicator:
+          indicators.add(composition_scaling_factors[c], this_indicator);
+        }
+    }
+
+    template <int dim>
+    void
+    ArtificialViscosity<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Artificial viscosity");
+        {
+          prm.declare_entry("Temperature scaling factor",
+                            "0.0",
+                            Patterns::Double (0.),
+                            "A scaling factor for the artificial viscosity "
+                            " of the temperature equation. Use 0.0 to disable.");
+          prm.declare_entry("Compositional field scaling factors",
+                            "",
+                            Patterns::List (Patterns::Double (0.)),
+                            "A list of scaling factors by which every individual compositional "
+                            "field will be multiplied. These "
+                            "factors are used to weigh the various indicators relative to "
+                            "each other and to the temperature. "
+                            "\n\n"
+                            "If the list of scaling factors given in this parameter is empty, then this "
+                            "indicates that they should all be chosen equal to 0. If the list "
+                            "is not empty then it needs to have as many entries as there are "
+                            "compositional fields.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    ArtificialViscosity<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Artificial viscosity");
+        {
+          temperature_scaling_factor = prm.get_double("Temperature scaling factor");
+
+          composition_scaling_factors
+            = Utilities::string_to_double(
+                Utilities::split_string_list(prm.get("Compositional field scaling factors")));
+
+          AssertThrow (composition_scaling_factors.size() == this->n_compositional_fields()
+                       ||
+                       composition_scaling_factors.size() == 0,
+                       ExcMessage ("The number of scaling factors given here must either be "
+                                   "zero or equal to the number of chosen refinement criteria."));
+
+          if (composition_scaling_factors.size() == 0)
+            composition_scaling_factors.resize (this->n_compositional_fields(), 0.0);
+
+          const double sum_composition_factors =
+            std::accumulate (composition_scaling_factors.begin(),
+                             composition_scaling_factors.end(), 0.0);
+
+          AssertThrow(sum_composition_factors + temperature_scaling_factor > 0.0,
+                      ExcMessage("You need to have a positive scaling factor "
+                                 "for at least one variable."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(ArtificialViscosity,
+                                              "artificial viscosity",
+                                              "A mesh refinement criterion that computes "
+                                              "refinement indicators from the artificial viscosity "
+                                              "of the temperature or compositional fields "
+                                              "based on user specified weights.")
+  }
+}
diff --git a/source/mesh_refinement/boundary.cc.bak b/source/mesh_refinement/boundary.cc.bak
new file mode 100644
index 00000000000..e51173946f2
--- /dev/null
+++ b/source/mesh_refinement/boundary.cc.bak
@@ -0,0 +1,122 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/boundary.h>
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    Boundary<dim>::execute(Vector<float> &indicators) const
+    {
+      indicators = 0;
+
+      // iterate over all of the cells and choose the ones at the indicated
+      // boundaries for refinement (assign the largest error to them)
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          for (const unsigned int face_no : cell->face_indices())
+            if (cell->face(face_no)->at_boundary())
+              {
+                const types::boundary_id boundary_indicator
+                  = cell->face(face_no)->boundary_id();
+                if ( boundary_refinement_indicators.find(boundary_indicator) !=
+                     boundary_refinement_indicators.end() )
+                  {
+                    indicators(cell->active_cell_index()) = 1.0;
+                    break;  // no need to loop over the rest of the faces
+                  }
+              }
+
+    }
+
+    template <int dim>
+    void
+    Boundary<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Boundary");
+        {
+          prm.declare_entry ("Boundary refinement indicators", "",
+                             Patterns::List (Patterns::Anything()),
+                             "A comma separated list of names denoting those boundaries "
+                             "where there should be mesh refinement."
+                             "\n\n"
+                             "The names of the boundaries listed here can either be "
+                             "numbers (in which case they correspond to the numerical "
+                             "boundary indicators assigned by the geometry object), or they "
+                             "can correspond to any of the symbolic names the geometry object "
+                             "may have provided for each part of the boundary. You may want "
+                             "to compare this with the documentation of the geometry model you "
+                             "use in your model.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    Boundary<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Boundary");
+        {
+          const std::vector<types::boundary_id> x_boundary_refinement_indicators
+            = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
+                                                                                  (prm.get ("Boundary refinement indicators")));
+          boundary_refinement_indicators
+            = std::set<types::boundary_id> (x_boundary_refinement_indicators.begin(),
+                                            x_boundary_refinement_indicators.end());
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Boundary,
+                                              "boundary",
+                                              "A class that implements a mesh refinement criterion which "
+                                              "always flags all cells on specified boundaries for refinement. "
+                                              "This is useful to provide high accuracy for processes at or "
+                                              "close to the edge of the model domain."
+                                              "\n\n"
+                                              "To use this refinement criterion, you may want to combine "
+                                              "it with other refinement criteria, setting the 'Normalize "
+                                              "individual refinement criteria' flag and using the `max' "
+                                              "setting for 'Refinement criteria merge operation'.")
+  }
+}
diff --git a/source/mesh_refinement/compaction_length.cc.bak b/source/mesh_refinement/compaction_length.cc.bak
new file mode 100644
index 00000000000..13d0ac9f614
--- /dev/null
+++ b/source/mesh_refinement/compaction_length.cc.bak
@@ -0,0 +1,158 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/compaction_length.h>
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    CompactionLength<dim>::tag_additional_cells () const
+    {
+      // tag_additional_cells is executed before the equations are solved
+      // for the very first time. If we do not have the finite element, we
+      // do not have any material properties and just do nothing in this plugin.
+      if (this->get_dof_handler().n_locally_owned_dofs() == 0)
+        return;
+
+      // Use a quadrature in the support points of the porosity to compute the
+      // compaction length at:
+      const typename Simulator<dim>::AdvectionField porosity = Simulator<dim>::AdvectionField::composition(
+                                                                 this->introspection().compositional_index_for_name("porosity"));
+
+      const unsigned int base_element_index = porosity.base_element(this->introspection());
+      const Quadrature<dim> quadrature(this->get_fe().base_element(base_element_index).get_unit_support_points());
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature,
+                               update_quadrature_points | update_values | update_gradients);
+
+      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
+      MeltHandler<dim>::create_material_model_outputs(out);
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            bool refine = false;
+            bool clear_coarsen = false;
+
+            fe_values.reinit(cell);
+            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+            this->get_material_model().evaluate(in, out);
+
+            MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+            AssertThrow(melt_out != nullptr,
+                        ExcMessage("Need MeltOutputs from the material model for computing the melt properties."));
+
+            // for each composition dof, check if the compaction length exceeds the cell size
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                const double compaction_length = std::sqrt((out.viscosities[i] + 4./3. * melt_out->compaction_viscosities[i])
+                                                           * melt_out->permeabilities[i] / melt_out->fluid_viscosities[i]);
+
+                // If the compaction length exceeds the cell diameter anywhere in the cell, cell is marked for refinement.
+                // Do not apply any refinement if the porosity is so small that melt can not migrate.
+                if (compaction_length < 2.0 * cells_per_compaction_length * cell->minimum_vertex_distance()
+                    && this->get_melt_handler().is_melt_cell(cell))
+                  clear_coarsen = true;
+
+                if (compaction_length < cells_per_compaction_length * cell->minimum_vertex_distance()
+                    && this->get_melt_handler().is_melt_cell(cell))
+                  {
+                    refine = true;
+                    break;
+                  }
+              }
+
+            if (clear_coarsen)
+              cell->clear_coarsen_flag ();
+            if (refine)
+              cell->set_refine_flag ();
+          }
+    }
+
+    template <int dim>
+    void
+    CompactionLength<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Compaction length");
+        {
+          prm.declare_entry("Mesh cells per compaction length", "1.0",
+                            Patterns::Double (0.),
+                            "The desired ratio between compaction length and size of the "
+                            "mesh cells, or, in other words, how many cells the mesh should "
+                            "(at least) have per compaction length. Every cell where this "
+                            "ratio is smaller than the value specified by this parameter "
+                            "(in places with fewer mesh cells per compaction length) is "
+                            "marked for refinement.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    CompactionLength<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Compaction length");
+        {
+          cells_per_compaction_length = prm.get_double ("Mesh cells per compaction length");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(CompactionLength,
+                                              "compaction length",
+                                              "A mesh refinement criterion for models with melt transport "
+                                              "that computes refinement indicators based on the compaction "
+                                              "length, defined as "
+                                              "$\\delta = \\sqrt{\\frac{(\\xi + 4 \\eta/3) k}{\\eta_f}}$. "
+                                              "$\\xi$ is the bulk viscosity, $\\eta$ is the shear viscosity, "
+                                              "$k$ is the permeability and $\\eta_f$ is the melt viscosity. "
+                                              "If the cell width or height exceeds a multiple (which is "
+                                              "specified as an input parameter) of this compaction length, "
+                                              "the cell is marked for refinement.")
+  }
+}
diff --git a/source/mesh_refinement/composition.cc.bak b/source/mesh_refinement/composition.cc.bak
new file mode 100644
index 00000000000..69a9c76d6a0
--- /dev/null
+++ b/source/mesh_refinement/composition.cc.bak
@@ -0,0 +1,152 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/composition.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    Composition<dim>::execute(Vector<float> &indicators) const
+    {
+      AssertThrow (this->n_compositional_fields() >= 1,
+                   ExcMessage ("This refinement criterion cannot be used when no "
+                               "compositional fields are active!"));
+      indicators = 0;
+      Vector<float> this_indicator (indicators.size());
+
+      const Quadrature<dim-1> &quadrature = this->introspection().face_quadratures.compositional_fields;
+
+      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+        {
+          this_indicator = 0;
+          KellyErrorEstimator<dim>::estimate (this->get_mapping(),
+                                              this->get_dof_handler(),
+                                              quadrature,
+                                              std::map<types::boundary_id,const Function<dim>*>(),
+                                              this->get_solution(),
+                                              this_indicator,
+                                              this->introspection().component_masks.compositional_fields[c],
+                                              nullptr,
+                                              0,
+                                              this->get_triangulation().locally_owned_subdomain());
+          // compute indicators += c*this_indicator:
+          indicators.add(composition_scaling_factors[c], this_indicator);
+        }
+    }
+
+    template <int dim>
+    void
+    Composition<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Composition");
+        {
+          prm.declare_entry("Compositional field scaling factors",
+                            "",
+                            Patterns::List (Patterns::Double (0.)),
+                            "A list of scaling factors by which every individual compositional "
+                            "field will be multiplied. If only a single compositional "
+                            "field exists, then this parameter has no particular meaning. "
+                            "On the other hand, if multiple criteria are chosen, then these "
+                            "factors are used to weigh the various indicators relative to "
+                            "each other. "
+                            "\n\n"
+                            "If the list of scaling factors given in this parameter is empty, then this "
+                            "indicates that they should all be chosen equal to one. If the list "
+                            "is not empty then it needs to have as many entries as there are "
+                            "compositional fields.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    Composition<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Composition");
+        {
+          composition_scaling_factors
+            = Utilities::string_to_double(
+                Utilities::split_string_list(prm.get("Compositional field scaling factors")));
+
+          AssertThrow (composition_scaling_factors.size() == this->n_compositional_fields()
+                       ||
+                       composition_scaling_factors.size() == 0,
+                       ExcMessage ("The number of scaling factors given here must either be "
+                                   "zero or equal to the number of chosen refinement criteria."));
+
+          if (composition_scaling_factors.size() == 0)
+            composition_scaling_factors.resize (this->n_compositional_fields(), 1.0);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Composition,
+                                              "composition",
+                                              "A mesh refinement criterion that computes "
+                                              "refinement indicators from the compositional fields. "
+                                              "If there is more than one compositional field, then "
+                                              "it simply takes the sum of the indicators computed "
+                                              "from each of the compositional field."
+                                              "\n\n"
+                                              "The way these indicators are computed is by "
+                                              "evaluating the `Kelly error indicator' on each "
+                                              "compositional field. This error indicator takes the "
+                                              "finite element approximation of the compositional "
+                                              "field and uses it to compute an approximation "
+                                              "of the second derivatives of the composition for "
+                                              "each cell. This approximation is then multiplied "
+                                              "by an appropriate power of the cell's diameter "
+                                              "to yield an indicator for how large the error "
+                                              "is likely going to be on this cell. This "
+                                              "construction rests on the observation that for "
+                                              "many partial differential equations, the error "
+                                              "on each cell is proportional to some power of "
+                                              "the cell's diameter times the second derivatives "
+                                              "of the solution on that cell."
+                                              "\n\n"
+                                              "For complex equations such as those we solve "
+                                              "here, this observation may not be strictly "
+                                              "true in the mathematical sense, but it often "
+                                              "yields meshes that are surprisingly good.")
+  }
+}
diff --git a/source/mesh_refinement/composition_approximate_gradient.cc.bak b/source/mesh_refinement/composition_approximate_gradient.cc.bak
new file mode 100644
index 00000000000..0397704160a
--- /dev/null
+++ b/source/mesh_refinement/composition_approximate_gradient.cc.bak
@@ -0,0 +1,153 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/composition_approximate_gradient.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/derivative_approximation.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    CompositionApproximateGradient<dim>::execute(Vector<float> &indicators) const
+    {
+      AssertThrow (this->n_compositional_fields() >= 1,
+                   ExcMessage ("This refinement criterion can not be used when no "
+                               "compositional fields are active!"));
+      indicators = 0;
+      // create a vector with the requisite ghost elements
+      // and use it for estimating the gradients of compositional field
+      LinearAlgebra::BlockVector vec(this->introspection().index_sets.system_partitioning,
+                                     this->introspection().index_sets.system_relevant_partitioning,
+                                     this->get_mpi_communicator());
+      Vector<float> indicators_tmp(this->get_triangulation().n_active_cells());
+      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+        {
+          const unsigned int block_idx = this->introspection().block_indices.compositional_fields[c];
+          vec.block(block_idx) = this->get_solution().block(block_idx);
+          vec.compress(VectorOperation::insert);
+          indicators_tmp = 0;
+          DerivativeApproximation::approximate_gradient(this->get_mapping(),
+                                                        this->get_dof_handler(),
+                                                        vec,
+                                                        indicators_tmp,
+                                                        this->introspection().component_indices.compositional_fields[c]);
+
+          indicators_tmp *= composition_scaling_factors[c];
+
+          // Scale approximated gradient in each cell with the correct power of h. Otherwise,
+          // error indicators do not reduce when refined if there is a density
+          // jump. We need at least order 1 for the error not to grow when
+          // refining, so anything >1 should work. (note that the gradient
+          // itself scales like 1/h, so multiplying it with any factor h^s, s>1
+          // will yield convergence of the error indicators to zero as h->0)
+          const double power = 1.0 + dim / 2.0;
+          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+            if (cell->is_locally_owned())
+              indicators_tmp(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
+
+          indicators += indicators_tmp;
+        }
+    }
+
+
+    template <int dim>
+    void
+    CompositionApproximateGradient<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Composition approximate gradient");
+        {
+          prm.declare_entry("Compositional field scaling factors",
+                            "",
+                            Patterns::List (Patterns::Double (0.)),
+                            "A list of scaling factors by which every individual compositional "
+                            "field gradient will be multiplied. If only a single compositional "
+                            "field exists, then this parameter has no particular meaning. "
+                            "On the other hand, if multiple criteria are chosen, then these "
+                            "factors are used to weigh the various indicators relative to "
+                            "each other. "
+                            "\n\n"
+                            "If the list of scaling factors given in this parameter is empty, then this "
+                            "indicates that they should all be chosen equal to one. If the list "
+                            "is not empty then it needs to have as many entries as there are "
+                            "compositional fields.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    CompositionApproximateGradient<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Composition approximate gradient");
+        {
+          composition_scaling_factors
+            = Utilities::string_to_double(
+                Utilities::split_string_list(prm.get("Compositional field scaling factors")));
+
+          AssertThrow (composition_scaling_factors.size() == this->n_compositional_fields()
+                       ||
+                       composition_scaling_factors.size() == 0,
+                       ExcMessage ("The number of scaling factors given here must either be "
+                                   "zero or equal to the number of chosen refinement criteria."));
+
+          if (composition_scaling_factors.size() == 0)
+            composition_scaling_factors.resize (this->n_compositional_fields(), 1.0);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(CompositionApproximateGradient,
+                                              "composition approximate gradient",
+                                              "A mesh refinement criterion that computes refinement "
+                                              "indicators from the gradients of compositional fields. "
+                                              "If there is more than one compositional field, then "
+                                              "it simply takes the sum of the indicators times "
+                                              "a user-specified weight for each field."
+                                              "\n\n"
+                                              "In contrast to the `composition gradient' refinement "
+                                              "criterion, the current criterion does not "
+                                              "compute the gradient at quadrature points on each cell, "
+                                              "but by a finite difference approximation between the "
+                                              "centers of cells. Consequently, it also works if "
+                                              "the compositional fields are computed using discontinuous "
+                                              "finite elements.")
+  }
+}
diff --git a/source/mesh_refinement/composition_gradient.cc.bak b/source/mesh_refinement/composition_gradient.cc.bak
new file mode 100644
index 00000000000..47eace30bb8
--- /dev/null
+++ b/source/mesh_refinement/composition_gradient.cc.bak
@@ -0,0 +1,185 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/mesh_refinement/composition_gradient.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    CompositionGradient<dim>::execute(Vector<float> &indicators) const
+    {
+      AssertThrow (this->n_compositional_fields() >= 1,
+                   ExcMessage ("This refinement criterion can not be used when no "
+                               "compositional fields are active!"));
+
+      indicators = 0;
+      const double power = 1.0 + dim/2.0;
+
+      for (const unsigned int base_element_index : this->introspection().get_composition_base_element_indices())
+        {
+          const Quadrature<dim> quadrature (this->get_fe().base_element(base_element_index).get_unit_support_points());
+          const unsigned int dofs_per_cell = quadrature.size();
+          FEValues<dim> fe_values (this->get_mapping(),
+                                   this->get_fe(),
+                                   quadrature,
+                                   update_quadrature_points | update_gradients);
+
+          // the values of the compositional fields are stored as block vectors for each field
+          // we have to extract them in this structure
+          std::vector<Tensor<1,dim>> composition_gradients (quadrature.size());
+
+          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+            if (cell->is_locally_owned())
+              {
+                const unsigned int idx = cell->active_cell_index();
+                fe_values.reinit(cell);
+
+                for (const unsigned int c : this->introspection().get_compositional_field_indices_with_base_element(base_element_index))
+                  {
+                    const typename Simulator<dim>::AdvectionField composition = Simulator<dim>::AdvectionField::composition(c);
+                    fe_values[composition.scalar_extractor(this->introspection())].get_function_gradients (this->get_solution(),
+                        composition_gradients);
+
+                    // Some up the indicators for this composition on this cell. Note that quadrature points and dofs
+                    // are enumerated in the same order.
+                    double this_indicator = 0.0;
+                    for (unsigned int j=0; j<dofs_per_cell; ++j)
+                      this_indicator += composition_gradients[j].norm();
+
+                    // Scale gradient in each cell with the correct power of h. Otherwise,
+                    // error indicators do not reduce when refined if there is a density
+                    // jump. We need at least order 1 for the error not to grow when
+                    // refining, so anything >1 should work. (note that the gradient
+                    // itself scales like 1/h, so multiplying it with any factor h^s, s>1
+                    // will yield convergence of the error indicators to zero as h->0)
+                    this_indicator *= std::pow(cell->diameter(), power);
+
+                    indicators[idx] += composition_scaling_factors[c] * this_indicator;
+                  }
+              }
+        }
+    }
+
+    template <int dim>
+    void
+    CompositionGradient<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Composition gradient");
+        {
+          prm.declare_entry("Compositional field scaling factors",
+                            "",
+                            Patterns::List (Patterns::Double (0.)),
+                            "A list of scaling factors by which every individual compositional "
+                            "field gradient will be multiplied. If only a single compositional "
+                            "field exists, then this parameter has no particular meaning. "
+                            "On the other hand, if multiple criteria are chosen, then these "
+                            "factors are used to weigh the various indicators relative to "
+                            "each other. "
+                            "\n\n"
+                            "If the list of scaling factors given in this parameter is empty, then this "
+                            "indicates that they should all be chosen equal to one. If the list "
+                            "is not empty then it needs to have as many entries as there are "
+                            "compositional fields.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    CompositionGradient<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Composition gradient");
+        {
+          composition_scaling_factors
+            = Utilities::string_to_double(
+                Utilities::split_string_list(prm.get("Compositional field scaling factors")));
+
+          AssertThrow (composition_scaling_factors.size() == this->n_compositional_fields()
+                       ||
+                       composition_scaling_factors.size() == 0,
+                       ExcMessage ("The number of scaling factors given here must either be "
+                                   "zero or equal to the number of chosen refinement criteria."));
+
+          if (composition_scaling_factors.size() == 0)
+            composition_scaling_factors.resize (this->n_compositional_fields(), 1.0);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(CompositionGradient,
+                                              "composition gradient",
+                                              "A mesh refinement criterion that computes refinement "
+                                              "indicators from the gradients of compositional fields. "
+                                              "If there is more than one compositional field, then "
+                                              "it simply takes the sum of the indicators times "
+                                              "a user-specified weight for each field."
+                                              "\n\n"
+                                              "This refinement criterion computes the gradient of "
+                                              "the compositional field at quadrature points on each "
+                                              "cell, and then averages them in some way to obtain a "
+                                              "refinement indicator for each cell. This will give a "
+                                              "reasonable approximation of the true gradient of the "
+                                              "compositional field if you are using a continuous "
+                                              "finite element."
+                                              "\n\n"
+                                              "On the other hand, for discontinuous "
+                                              "finite elements (see the `Use discontinuous composition "
+                                              "discretization' parameter in the `Discretization' "
+                                              "section), the gradient at quadrature points does not "
+                                              "include the contribution of jumps in the compositional "
+                                              "field between cells, and consequently will not be an "
+                                              "accurate approximation of the true gradient. As an "
+                                              "extreme example, consider the case of using piecewise "
+                                              "constant finite elements for compositional fields; in "
+                                              "that case, the gradient of the solution at quadrature "
+                                              "points inside each cell will always be exactly zero, "
+                                              "even if the finite element solution is different "
+                                              "from each cell to the next. Consequently, the "
+                                              "current refinement criterion will likely not be "
+                                              "useful in this situation. That said, "
+                                              "the `composition approximate "
+                                              "gradient' refinement criterion exists for exactly "
+                                              "this purpose.")
+  }
+}
diff --git a/source/mesh_refinement/composition_threshold.cc.bak b/source/mesh_refinement/composition_threshold.cc.bak
new file mode 100644
index 00000000000..d2ad3cbf622
--- /dev/null
+++ b/source/mesh_refinement/composition_threshold.cc.bak
@@ -0,0 +1,137 @@
+/*
+  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/composition_threshold.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    CompositionThreshold<dim>::tag_additional_cells () const
+    {
+      AssertThrow (this->n_compositional_fields() >= 1,
+                   ExcMessage ("This refinement criterion can not be used when no "
+                               "compositional fields are active!"));
+
+      // tag_additional_cells is executed before the equations are solved
+      // for the very first time. If we do not have the finite element, we
+      // do not have the compositional fields and just do nothing in this plugin.
+      if (this->get_dof_handler().n_locally_owned_dofs() == 0)
+        return;
+
+      const unsigned int dofs_per_cell = this->get_fe().dofs_per_cell;
+      std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            cell->get_dof_indices (local_dof_indices);
+            bool refine = false;
+
+            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+              {
+                const unsigned int component_idx = this->introspection().component_indices.compositional_fields[c];
+                for (unsigned int i=0; i<dofs_per_cell; ++i)
+                  {
+                    if (this->get_fe().system_to_component_index(i).first == component_idx)
+                      {
+                        const double composition_value = this->get_solution()[local_dof_indices[i]];
+                        // if the composition exceeds the threshold, cell is marked for refinement
+                        if (composition_value > composition_thresholds[c])
+                          {
+                            refine = true;
+                            break;
+                          }
+                      }
+                  }
+                if (refine)
+                  break;
+              }
+
+            if (refine)
+              {
+                cell->clear_coarsen_flag ();
+                cell->set_refine_flag ();
+              }
+          }
+    }
+
+    template <int dim>
+    void
+    CompositionThreshold<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Composition threshold");
+        {
+          prm.declare_entry("Compositional field thresholds",
+                            "",
+                            Patterns::List (Patterns::Double()),
+                            "A list of thresholds that every individual compositional "
+                            "field will be evaluated against.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    CompositionThreshold<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Composition threshold");
+        {
+          composition_thresholds
+            = Utilities::string_to_double(
+                Utilities::split_string_list(prm.get("Compositional field thresholds")));
+
+          AssertThrow (composition_thresholds.size() == this->n_compositional_fields(),
+                       ExcMessage ("The number of thresholds given here must be "
+                                   "equal to the number of chosen refinement criteria."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(CompositionThreshold,
+                                              "composition threshold",
+                                              "A mesh refinement criterion that computes refinement "
+                                              "indicators from the compositional fields. If any field "
+                                              "exceeds the threshold given in the input file, the cell "
+                                              "is marked for refinement.")
+  }
+}
diff --git a/source/mesh_refinement/density.cc.bak b/source/mesh_refinement/density.cc.bak
new file mode 100644
index 00000000000..9f97b335d85
--- /dev/null
+++ b/source/mesh_refinement/density.cc.bak
@@ -0,0 +1,143 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/density.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/numerics/derivative_approximation.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    Density<dim>::execute(Vector<float> &indicators) const
+    {
+      indicators = 0;
+
+//TODO: if the density doesn't actually depend on the solution
+      // then we can get away with simply interpolating it spatially
+
+
+      // create a vector in which we set the temperature block to
+      // be a finite element interpolation of the density.
+      // we do so by setting up a quadrature formula with the
+      // temperature unit support points, then looping over these
+      // points, compute the output quantity at them, and writing
+      // the result into the output vector in the same order
+      // (because quadrature points and temperature dofs are,
+      // by design of the quadrature formula, numbered in the
+      // same way)
+      LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
+                                                  this->get_mpi_communicator());
+
+      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
+      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature,
+                               update_quadrature_points | update_values | update_gradients);
+
+      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(),
+                                                 this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(),
+                                                   this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::density;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit(cell);
+            // Set use_strain_rates to false since we don't need viscosity
+            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+            this->get_material_model().evaluate(in, out);
+
+            cell->get_dof_indices (local_dof_indices);
+
+            // for each temperature dof, write into the output
+            // vector the density. note that quadrature points and
+            // dofs are enumerated in the same order
+            for (unsigned int i=0; i<this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell; ++i)
+              {
+                const unsigned int system_local_dof
+                  = this->get_fe().component_to_system_index(this->introspection().component_indices.temperature,
+                                                             /*dof index within component=*/i);
+
+                vec_distributed(local_dof_indices[system_local_dof])
+                  = out.densities[i];
+              }
+          }
+
+      vec_distributed.compress(VectorOperation::insert);
+
+      // now create a vector with the requisite ghost elements
+      // and use it for estimating the gradients
+      LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
+                                      this->introspection().index_sets.system_relevant_partitioning,
+                                      this->get_mpi_communicator());
+      vec = vec_distributed;
+
+      DerivativeApproximation::approximate_gradient  (this->get_mapping(),
+                                                      this->get_dof_handler(),
+                                                      vec,
+                                                      indicators,
+                                                      this->introspection().component_indices.temperature);
+
+      // Scale gradient in each cell with the correct power of h. Otherwise,
+      // error indicators do not reduce when refined if there is a density
+      // jump. We need at least order 1 for the error not to grow when
+      // refining, so anything >1 should work. (note that the gradient
+      // itself scales like 1/h, so multiplying it with any factor h^s, s>1
+      // will yield convergence of the error indicators to zero as h->0)
+      const double power = 1.0 + dim/2.0;
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          indicators(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Density,
+                                              "density",
+                                              "A mesh refinement criterion that computes "
+                                              "refinement indicators from a field that describes "
+                                              "the spatial variability of the density, $\\rho$. "
+                                              "Because this quantity may not be a continuous function ($\\rho$ "
+                                              "and $C_p$ may be discontinuous functions along discontinuities in the "
+                                              "medium, for example due to phase changes), we approximate the "
+                                              "gradient of this quantity to refine the mesh. The error indicator "
+                                              "defined here takes the magnitude of the approximate gradient "
+                                              "and scales it by $h_K^{1+d/2}$ where $h_K$ is the diameter of each cell "
+                                              "and $d$ is the dimension. "
+                                              "This scaling ensures that the error indicators converge to zero as "
+                                              "$h_K\\rightarrow 0$ even if the energy density is discontinuous, since "
+                                              "the gradient of a discontinuous function grows like $1/h_K$.")
+  }
+}
diff --git a/source/mesh_refinement/interface.cc.bak b/source/mesh_refinement/interface.cc.bak
new file mode 100644
index 00000000000..8e16815ddd4
--- /dev/null
+++ b/source/mesh_refinement/interface.cc.bak
@@ -0,0 +1,519 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/utilities.h>
+
+#include <typeinfo>
+
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+// ------------------------------ Interface -----------------------------
+
+    template <int dim>
+    void
+    Interface<dim>::execute (Vector<float> &error_indicators) const
+    {
+      for (float &error_indicator : error_indicators)
+        error_indicator = 0;
+    }
+
+
+    template <int dim>
+    void
+    Interface<dim>::tag_additional_cells () const
+    {}
+
+
+
+// ------------------------------ Manager -----------------------------
+
+    template <int dim>
+    Manager<dim>::~Manager()
+      = default;
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::update ()
+    {
+      Assert (this->plugin_objects.size() > 0, ExcInternalError());
+
+      // call the update() functions of all refinement plugins.
+      for (const auto &p : this->plugin_objects)
+        {
+          try
+            {
+              p->update ();
+            }
+
+          // plugins that throw exceptions usually do not result in
+          // anything good because they result in an unwinding of the stack
+          // and, if only one processor triggers an exception, the
+          // destruction of objects often causes a deadlock. thus, if
+          // an exception is generated, catch it, print an error message,
+          // and abort the program
+          catch (std::exception &exc)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running mesh refinement plugin <"
+                        << typeid(*p).name()
+                        << ">: " << std::endl
+                        << exc.what() << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+          catch (...)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running mesh refinement plugin <"
+                        << typeid(*p).name()
+                        << ">: " << std::endl;
+              std::cerr << "Unknown exception!" << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::execute (Vector<float> &error_indicators) const
+    {
+      Assert (this->plugin_objects.size() > 0, ExcInternalError());
+
+      // call the execute() functions of all plugins we have
+      // here in turns. then normalize the output vector and
+      // verify that its values are non-negative numbers
+      std::vector<Vector<float>> all_error_indicators (this->plugin_objects.size(),
+                                                        Vector<float>(error_indicators.size()));
+      unsigned int index = 0;
+      for (typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
+           p = this->plugin_objects.begin();
+           p != this->plugin_objects.end(); ++p, ++index)
+        {
+          try
+            {
+              (*p)->execute (all_error_indicators[index]);
+
+              for (unsigned int i=0; i<error_indicators.size(); ++i)
+                Assert (all_error_indicators[index](i) >= 0,
+                        ExcMessage ("Error indicators must be non-negative numbers!"));
+
+              // see if we want to normalize the criteria
+              if (normalize_criteria == true)
+                {
+                  const double global_max = Utilities::MPI::max (all_error_indicators[index].linfty_norm(),
+                                                                 this->get_mpi_communicator());
+                  if (global_max != 0)
+                    all_error_indicators[index] /= global_max;
+                }
+
+              // then also scale them
+              all_error_indicators[index] *= scaling_factors[index];
+            }
+          // plugins that throw exceptions usually do not result in
+          // anything good because they result in an unwinding of the stack
+          // and, if only one processor triggers an exception, the
+          // destruction of objects often causes a deadlock. thus, if
+          // an exception is generated, catch it, print an error message,
+          // and abort the program
+          catch (std::exception &exc)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running mesh refinement plugin <"
+                        << typeid(**p).name()
+                        << ">: " << std::endl
+                        << exc.what() << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+          catch (...)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running mesh refinement plugin <"
+                        << typeid(**p).name()
+                        << ">: " << std::endl;
+              std::cerr << "Unknown exception!" << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+        }
+
+      // now merge the results
+      switch  (merge_operation)
+        {
+          case plus:
+          {
+            for (unsigned int i=0; i<this->plugin_objects.size(); ++i)
+              error_indicators += all_error_indicators[i];
+            break;
+          }
+
+          case max:
+          {
+            error_indicators = all_error_indicators[0];
+            for (unsigned int i=1; i<this->plugin_objects.size(); ++i)
+              {
+                Assert (error_indicators.size() == all_error_indicators[i].size(),
+                        ExcInternalError());
+                for (unsigned int j=0; j<error_indicators.size(); ++j)
+                  error_indicators(j) = std::max (error_indicators(j),
+                                                  all_error_indicators[i](j));
+              }
+            break;
+          }
+
+          default:
+            Assert (false, ExcNotImplemented());
+        }
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::tag_additional_cells () const
+    {
+      Assert (this->plugin_objects.size() > 0, ExcInternalError());
+
+      // call the tag_additional_cells() functions of all
+      // plugins we have here in turns.
+      for (const auto &p : this->plugin_objects)
+        {
+          try
+            {
+              p->tag_additional_cells ();
+            }
+
+          // plugins that throw exceptions usually do not result in
+          // anything good because they result in an unwinding of the stack
+          // and, if only one processor triggers an exception, the
+          // destruction of objects often causes a deadlock. thus, if
+          // an exception is generated, catch it, print an error message,
+          // and abort the program
+          catch (std::exception &exc)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running mesh refinement plugin <"
+                        << typeid(*p).name()
+                        << ">: " << std::endl
+                        << exc.what() << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+          catch (...)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running mesh refinement plugin <"
+                        << typeid(*p).name()
+                        << ">: " << std::endl;
+              std::cerr << "Unknown exception!" << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+        }
+    }
+
+
+
+
+
+// -------------------------------- Deal with registering plugins and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // first declare the postprocessors we know about to
+      // choose from
+      prm.enter_subsection("Mesh refinement");
+      {
+        // construct a string for Patterns::MultipleSelection that
+        // contains the names of all registered plugins
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+        prm.declare_entry("Strategy",
+                          "thermal energy density",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma separated list of mesh refinement criteria that "
+                          "will be run whenever mesh refinement is required. The "
+                          "results of each of these criteria, i.e., the refinement "
+                          "indicators they produce for all the cells of the mesh "
+                          "will then be normalized to a range between zero and one "
+                          "and the results of different criteria will then be "
+                          "merged through the operation selected in this section.\n\n"
+                          "The following criteria are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+
+        prm.declare_entry("Normalize individual refinement criteria",
+                          "true",
+                          Patterns::Bool(),
+                          "If multiple refinement criteria are specified in the "
+                          "``Strategy'' parameter, then they need to be combined "
+                          "somehow to form the final refinement indicators. This "
+                          "is done using the method described by the ``Refinement "
+                          "criteria merge operation'' parameter which can either "
+                          "operate on the raw refinement indicators returned by "
+                          "each strategy (i.e., dimensional quantities) or using "
+                          "normalized values where the indicators of each strategy "
+                          "are first normalized to the interval $[0,1]$ (which also "
+                          "makes them non-dimensional). This parameter determines "
+                          "whether this normalization will happen.");
+        prm.declare_entry("Refinement criteria scaling factors",
+                          "",
+                          Patterns::List (Patterns::Double (0.)),
+                          "A list of scaling factors by which every individual refinement "
+                          "criterion will be multiplied by. If only a single refinement "
+                          "criterion is selected (using the ``Strategy'' parameter, then "
+                          "this parameter has no particular meaning. On the other hand, if "
+                          "multiple criteria are chosen, then these factors are used to "
+                          "weigh the various indicators relative to each other. "
+                          "\n\n"
+                          "If ``Normalize individual refinement criteria'' is set to true, "
+                          "then the criteria will first be normalized to the interval $[0,1]$ "
+                          "and then multiplied by the factors specified here. You will likely "
+                          "want to choose the factors to be not too far from 1 in that case, say "
+                          "between 1 and 10, to avoid essentially disabling those criteria "
+                          "with small weights. On the other hand, if the criteria are not "
+                          "normalized to $[0,1]$ using the parameter mentioned above, then "
+                          "the factors you specify here need to take into account the relative "
+                          "numerical size of refinement indicators (which in that case carry "
+                          "physical units)."
+                          "\n\n"
+                          "You can experimentally play with these scaling factors by choosing "
+                          "to output the refinement indicators into the graphical output of "
+                          "a run."
+                          "\n\n"
+                          "If the list of indicators given in this parameter is empty, then this "
+                          "indicates that they should all be chosen equal to one. If the list "
+                          "is not empty then it needs to have as many entries as there are "
+                          "indicators chosen in the ``Strategy'' parameter.");
+        prm.declare_entry("Refinement criteria merge operation",
+                          "max",
+                          Patterns::Selection("plus|max"),
+                          "If multiple mesh refinement criteria are computed for each cell "
+                          "(by passing a list of more than element to the \\texttt{Strategy} "
+                          "parameter in this section of the input file) "
+                          "then one will have to decide which criteria should win when deciding "
+                          "which cells to refine. The operation that determines how to combine these competing "
+                          "criteria is the one that is selected here. The options are:\n\n"
+                          "\\begin{itemize}\n"
+                          "\\item \\texttt{plus}: Add the various error indicators together and "
+                          "refine those cells on which the sum of indicators is largest.\n"
+                          "\\item \\texttt{max}: Take the maximum of the various error indicators and "
+                          "refine those cells on which the maximal indicators is largest.\n"
+                          "\\end{itemize}"
+                          "The refinement indicators computed by each strategy are modified by "
+                          "the ``Normalize individual refinement criteria'' and ``Refinement "
+                          "criteria scale factors'' parameters.");
+      }
+      prm.leave_subsection();
+
+      // now declare the parameters of each of the registered
+      // plugins in turn
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      Assert (std::get<dim>(registered_plugins).plugins != nullptr,
+              ExcMessage ("No mesh refinement plugins registered!?"));
+
+      // find out which plugins are requested and the various other
+      // parameters we declare here
+      std::vector<std::string> plugin_names;
+      prm.enter_subsection("Mesh refinement");
+      {
+        plugin_names
+          = Utilities::split_string_list(prm.get("Strategy"));
+
+        AssertThrow(Utilities::has_unique_entries(plugin_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Mesh refinement/Strategy' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+
+        normalize_criteria = prm.get_bool ("Normalize individual refinement criteria");
+
+        scaling_factors
+          = Utilities::string_to_double(
+              Utilities::split_string_list(prm.get("Refinement criteria scaling factors")));
+        AssertThrow (scaling_factors.size() == plugin_names.size()
+                     ||
+                     scaling_factors.size() == 0,
+                     ExcMessage ("The number of scaling factors given here must either be "
+                                 "zero or equal to the number of chosen refinement criteria."));
+        if (scaling_factors.size() == 0)
+          scaling_factors = std::vector<double> (plugin_names.size(), 1.0);
+
+        if (prm.get("Refinement criteria merge operation") == "plus")
+          merge_operation = plus;
+        else if (prm.get("Refinement criteria merge operation") == "max")
+          merge_operation = max;
+        else
+          AssertThrow (false, ExcNotImplemented());
+      }
+      prm.leave_subsection();
+
+      // go through the list, create objects and let them parse
+      // their own parameters
+      AssertThrow (plugin_names.size() >= 1,
+                   ExcMessage ("You need to provide at least one mesh refinement criterion in the input file!"));
+      for (auto &plugin_name : plugin_names)
+        {
+          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
+                                          (std::get<dim>(registered_plugins)
+                                           .create_plugin (plugin_name,
+                                                           "Mesh refinement::Refinement criteria merge operation")));
+
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
+            sim->initialize_simulator (this->get_simulator());
+
+          this->plugin_objects.back()->parse_parameters (prm);
+          this->plugin_objects.back()->initialize ();
+        }
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_mesh_refinement_criterion (const std::string &name,
+                                                      const std::string &description,
+                                                      void (*declare_parameters_function) (ParameterHandler &),
+                                                      std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Mesh refinement criteria interface",
+                                                            out);
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<MeshRefinement::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<MeshRefinement::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<MeshRefinement::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<MeshRefinement::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace MeshRefinement
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/mesh_refinement/isosurfaces.cc.bak b/source/mesh_refinement/isosurfaces.cc.bak
new file mode 100644
index 00000000000..c834b26fc08
--- /dev/null
+++ b/source/mesh_refinement/isosurfaces.cc.bak
@@ -0,0 +1,404 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <algorithm>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/mesh_refinement/isosurfaces.h>
+#include <aspect/utilities.h>
+#include <cmath>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    namespace internal
+    {
+      bool
+      Isosurface::are_all_values_in_range(const std::vector<double> &values) const
+      {
+        // This assumes that all the vectors in isosurfaces already have the
+        // same length.
+        Assert(values.size() == min_values.size(),
+               ExcMessage("internal error: Vector of values passed to the isosurface class "
+                          "function are_all_values_in_range, does not have the correct size."));
+        for (unsigned int index = 0; index < values.size(); ++index)
+          {
+            if (values[index] < min_values[index] || values[index] > max_values[index])
+              {
+                // outside this isosurface, no need to search further
+                return false;
+              }
+          }
+        // If we made it this far, then we are inside the conditions, so return true.
+        return true;
+      }
+
+      Property::Property(const std::string &property_name,
+                         const std::vector<std::string> &available_compositions)
+      {
+        bool found = false;
+        if (property_name == "Temperature")
+          {
+            type = PropertyType::Temperature;
+            index = 0;
+            found = true;
+          }
+        else
+          {
+            auto p = std::find(available_compositions.begin(), available_compositions.end(), property_name);
+            if (p != available_compositions.end())
+              {
+                type = PropertyType::Composition;
+                index = std::distance(available_compositions.begin(), p);
+                found = true;
+              }
+          }
+        if (found == false)
+          {
+            // The property name has not been found. This could be because the compositional field is not present.
+            // Abort and warn the user.
+            std::string key_list = "Temperature";
+            for (auto &composition : available_compositions)
+              key_list += ", " + composition;
+
+            AssertThrow(false,
+                        ExcMessage("The key given for the isosurface could not be converted. The provided key was: " + property_name + ". "
+                                   "The following keys are allowed for this model: " + key_list + "."));
+          }
+      }
+
+      /**
+       * Convert a string describing the refinement level which potentially contains the words "min"
+       * or "max" to an integer. The format is "min", "max", "min+X", "max-X", or "X", where X is a positive integer.
+       *
+       * For example if minimum_refinement_level  is 1, and the string is 'min+1', it will return 2.
+       * The returned value will be capped  by the provided @p minimum_refinement_level and @p maximum_refinement_level.
+       * The @p minimum_refinement_level and @p maximum_refinement_level are set in this input file subsection for this
+       * plugin, but in the Mesh refinement subsection.
+       *
+       * This function will throw an assertion when the string contains `max+` or `min-` since
+       * that is always incorrect.
+       */
+      unsigned int min_max_string_to_int(const std::string &string_value,
+                                         const unsigned int minimum_refinement_level,
+                                         const unsigned int maximum_refinement_level)
+      {
+        // start with removing the spaces so that a ' min + 1 ' would become 'min+1'.
+        std::string string = string_value;
+        std::string::iterator end_pos = std::remove(string.begin(), string.end(), ' ');
+        string.erase(end_pos, string.end());
+
+        // check whether the field starts with a 'min'
+        if (string.compare(0,3,"min") == 0)
+          {
+            if (string.compare(0,4,"min+") == 0)
+              {
+                std::vector<std::string> tmpNumber = Utilities::split_string_list(string,'+');
+                AssertThrow(tmpNumber.size() == 2,
+                            ExcMessage("Could not convert value '" + string + "' to an int because it contains more than one '+' sign."));
+                return std::min(std::max(minimum_refinement_level+Utilities::string_to_int(tmpNumber[1]),minimum_refinement_level),maximum_refinement_level);
+              }
+            else
+              {
+                AssertThrow(string == "min",
+                            ExcMessage("A value of " + string_value + " was provided, but you can't provide a smaller value than the minimum."));
+                return minimum_refinement_level;
+              }
+          }
+        else if (string.compare(0,3,"max") == 0)
+          {
+            if (string.compare(0,4,"max-") == 0)
+              {
+                std::vector<std::string> tmpNumber = Utilities::split_string_list(string,'-');
+                AssertThrow(tmpNumber.size() == 2,
+                            ExcMessage("Could not convert value '" + string + "' to an int because it contains more than one '-' sign."));
+                return std::min(std::max(maximum_refinement_level-Utilities::string_to_int(tmpNumber[1]),minimum_refinement_level),maximum_refinement_level);
+              }
+            else
+              {
+                AssertThrow(string=="max",
+                            ExcMessage("A value of " + string_value + " was provided, but you can't provide a larger value than the maximum."));
+                return maximum_refinement_level;
+              }
+          }
+        else
+          {
+            return std::min(std::max(static_cast<unsigned int>(Utilities::string_to_int(string)),minimum_refinement_level),maximum_refinement_level);
+          }
+
+      }
+    }
+
+    template <int dim>
+    void
+    Isosurfaces<dim>::update ()
+    { }
+
+    template <int dim>
+    void
+    Isosurfaces<dim>::tag_additional_cells () const
+    {
+      if (this->get_dof_handler().n_locally_owned_dofs() == 0)
+        return;
+
+      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature,
+                               update_quadrature_points | update_values | update_gradients);
+
+      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(),
+                                                 this->n_compositional_fields());
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        {
+          if (cell->is_locally_owned())
+            {
+              bool coarsen = false;
+              bool clear_refine = false;
+              bool refine = false;
+              bool clear_coarsen = false;
+
+              fe_values.reinit(cell);
+              in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+              for (unsigned int i_quad=0; i_quad<quadrature.size(); ++i_quad)
+                {
+                  for (auto &isosurface : isosurfaces)
+                    {
+                      // setup the vector containing the isosurfaces
+                      std::vector<double> values(isosurface.min_values.size());
+                      for (unsigned int index = 0; index < isosurface.properties.size(); ++index)
+                        {
+                          if (isosurface.properties[index].type == internal::PropertyType::Temperature)
+                            {
+                              values[index] = in.temperature[i_quad];
+                            }
+                          else if (isosurface.properties[index].type == internal::PropertyType::Composition)
+                            {
+                              values[index] = in.composition[i_quad][isosurface.properties[index].index];
+                            }
+                        }
+
+                      if ( isosurface.are_all_values_in_range(values))
+                        {
+                          // If the current refinement level is smaller than or equal to the minimum
+                          // refinement level, any coarsening flag should be cleared.
+                          if (cell->level() <= isosurface.min_refinement)
+                            {
+                              clear_coarsen = true;
+                            }
+
+                          // If the current refinement level is smaller than the minimum
+                          // refinement level, a refinement flag should be placed.
+                          if (cell->level() <  isosurface.min_refinement)
+                            {
+                              refine = true;
+                              break;
+                            }
+
+                          // If the current refinement level is larger than or equal to the maximum refinement
+                          // level, any refinement flag should be cleared.
+                          if (cell->level() >= isosurface.max_refinement)
+                            {
+                              clear_refine = true;
+                            }
+
+                          // If the current refinement level is larger than the maximum refinement level,
+                          // a coarsening flag should be placed.
+                          if (cell->level() >  isosurface.max_refinement)
+                            {
+                              coarsen = true;
+                            }
+                        }
+                    }
+                }
+
+              // if both coarsen and refine are true, give preference to refinement
+              if (coarsen && refine)
+                coarsen = false;
+              if (refine)
+                clear_refine = false;
+              if (clear_coarsen)
+                coarsen = false;
+
+              // Perform the actual placement of the coarsening and refinement flags.
+              if (clear_coarsen)
+                cell->clear_coarsen_flag ();
+              if (clear_refine)
+                cell->clear_refine_flag ();
+              if (coarsen)
+                cell->set_coarsen_flag ();
+              if (refine)
+                cell->set_refine_flag ();
+            }
+        }
+    }
+
+    template <int dim>
+    void
+    Isosurfaces<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Isosurfaces");
+        {
+          prm.declare_entry ("Isosurfaces", "",
+                             Patterns::Anything(),
+                             "A list of isosurfaces separated by semi-colons (;). Each isosurface entry consists of "
+                             "multiple entries separated by a comma. The first two entries indicate the minimum and maximum "
+                             "refinement levels respectively. The entries after the first two describe the fields the isosurface "
+                             "applies to, followed by a colon (:), which is again followed by the minimum and maximum property values separated by "
+                             "bar (|). An example for an isosurface is '0, 2, Temperature: 300 | 600; 2, 2, C\\_1: 0.5 | 1'. "
+                             "In this example the mesh refinement is kept between level 0 and level 2 if the temperature is between "
+                             "300 and 600 and at level 2 when the compositional field C\\_1 is between 0.5 and 1. If both happen at "
+                             "the same location and the current refinement level is 1, it means that the first isoline will not set any flag and the "
+                             "second isoline will set a refinement flag. This means the cell will be refined. If both the coarsening and refinement flags "
+                             "are set, preference is given to refinement. "
+                             "\n\n"
+                             "The first two entries for each isosurface, describing the minimum and maximum grid levels, can be "
+                             "two numbers or contain one of the key values 'min' and 'max'. This indicates the key will be replaced with "
+                             "the global minimum and maximum refinement levels. The 'min' and 'max' keys also accept adding "
+                             "values to be added or subtracted from them respectively. This is done by adding a '+' or '-' and a "
+                             "number behind them (e.g. min+2 or max-1). Note that you can't subtract a value from a minimum value or "
+                             "add a value to the maximum value. If, for example, `max-4` drops below the minimum or `min+4` goes above the "
+                             "maximum, it will simply use the global minimum and maximum values respectively. The same holds for any "
+                             "mesh refinement level below the global minimum or above the global maximum.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    Isosurfaces<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        // lookup the minimum and maximum refinement
+        const unsigned int minimum_refinement_level = this->get_parameters().min_grid_level;
+        const unsigned int maximum_refinement_level = this->get_parameters().initial_global_refinement +
+                                                      this->get_parameters().initial_adaptive_refinement;
+
+        const std::vector<std::string> &compositions = this->introspection().get_composition_names();
+        prm.enter_subsection("Isosurfaces");
+        {
+          // Split the list by comma delimited components.
+          const std::vector<std::string> isosurface_entries = dealii::Utilities::split_string_list(prm.get("Isosurfaces"), ';');
+          unsigned int isosurface_entry_number = 0;
+          for (auto &isosurface_entry : isosurface_entries)
+            {
+              ++isosurface_entry_number;
+              aspect::MeshRefinement::internal::Isosurface isosurface;
+              std::vector<aspect::MeshRefinement::internal::Property> properties;
+              std::vector<double> min_value_inputs;
+              std::vector<double> max_value_inputs;
+              const std::vector<std::string> field_entries = dealii::Utilities::split_string_list(isosurface_entry, ',');
+
+              AssertThrow(field_entries.size() >= 3,
+                          ExcMessage("An isosurface needs to contain at least 3 entries, but isosurface " + std::to_string(isosurface_entry_number)
+                                     + " contains  only " +  std::to_string(field_entries.size()) + " entries: " + isosurface_entry + "."));
+
+              // convert a potential min, min+1, min + 1, min+10, max, max-1, etc. to actual integers.
+              isosurface.min_refinement = internal::min_max_string_to_int(field_entries[0], minimum_refinement_level, maximum_refinement_level);
+              isosurface.max_refinement = internal::min_max_string_to_int(field_entries[1], minimum_refinement_level, maximum_refinement_level);
+              AssertThrow(isosurface.min_refinement <= isosurface.max_refinement,
+                          ExcMessage("The provided maximum refinement level has to be larger than the minimum refinement level."));
+              for (auto field_entry = field_entries.begin()+2; field_entry != field_entries.end(); ++field_entry)
+                {
+                  AssertThrow(Patterns::Map(Patterns::Anything(),
+                                            Patterns::List(Patterns::Double(), 0, std::numeric_limits<unsigned int>::max(), "|")
+                                           ).match(*field_entry),
+                              ExcMessage("The isosurface is not formatted correctly."));
+                  std::vector<std::string> key_and_value = Utilities::split_string_list (*field_entry, ':');
+                  AssertThrow(key_and_value.size() == 2,
+                              ExcMessage("The isosurface property must have a key (e.g. Temperature) and two values separated by a | (e.g. (300 | 600)."));
+                  properties.emplace_back(key_and_value[0], compositions); // convert key to property name
+                  const std::vector<std::string> values = dealii::Utilities::split_string_list(key_and_value[1], '|');
+                  AssertThrow(values.size() == 2,
+                              ExcMessage("Both a maximum and a minimum value are required for each isosurface."));
+                  min_value_inputs.push_back(Utilities::string_to_double(values[0]));  // get min and max values of the range
+                  max_value_inputs.push_back(Utilities::string_to_double(values[1]));
+                  AssertThrow(min_value_inputs.back() < max_value_inputs.back(),
+                              ExcMessage("The provided maximum property value has to be larger than the provided minimum property value."));
+                }
+              isosurface.min_values = min_value_inputs;
+              isosurface.max_values = max_value_inputs;
+              isosurface.properties = properties;
+              isosurfaces.push_back(isosurface);
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Isosurfaces,
+                                              "isosurfaces",
+                                              "A mesh refinement criterion that computes "
+                                              "coarsening and refinement indicators between two isosurfaces of "
+                                              "specific field entries (e.g. temperature, composition)."
+                                              "\n\n"
+                                              "The way these indicators are derived between pairs of isosurfaces is by "
+                                              "checking whether the solutions of specific "
+                                              "fields are within the ranges of the isosurface values given. If these conditions "
+                                              "hold, then coarsening and refinement indicators are set such that "
+                                              "the mesh refinement levels lies within the range of levels "
+                                              "given. Usage of this plugin allows the user to put a conditional "
+                                              "minimum and maximum refinement function onto fields that they "
+                                              "are interested in."
+                                              "\n\n"
+                                              "For now, only temperature and compositional fields are allowed as "
+                                              "field entries. The key words could be 'Temperature' or one of the names "
+                                              "of the compositional fields which are either specified by user or set up "
+                                              "as C\\_0, C\\_1, etc."
+                                              "\n\n"
+                                              "Usage: A list of isosurfaces separated by semi-colons (;). Each "
+                                              "isosurface entry consists of multiple entries separated by a comma. "
+                                              "The first two entries indicate the minimum and maximum refinement "
+                                              "levels respectively. The entries after the first two describe the "
+                                              "fields the isosurface applies to, followed by a colon (:), which again "
+                                              "is followed by the minimum and maximum field values separated by a bar (|). An "
+                                              "example for two isosurface entries is '0, 2, Temperature: 300 | 600; 2, 2, C\\_1: 0.5 | 1'. "
+                                              "If both isoterm entries are triggered at the same location and the current refinement level is 1, "
+                                              "it means that the first isoline will not set any flag and the second isoline will set a refinement flag. "
+                                              "This means the cell will be refined. If both the coarsening and refinement flags "
+                                              "are set, preference is given to refinement. "
+                                              "\n\n"
+                                              "The minimum and maximum refinement levels per isosurface can be provided in absolute values relative to "
+                                              "the global minimum and maximum refinement. This is done with the 'min' and 'max' key words. For example: "
+                                              "'set Isosurfaces = max-2,  max,    Temperature: 0 | 600 ; min + 1,min+2, Temperature: 1600 | 3000,   C\\_2 : 0.0 | 0.5'."
+                                             )
+  }
+}
diff --git a/source/mesh_refinement/maximum_refinement_function.cc.bak b/source/mesh_refinement/maximum_refinement_function.cc.bak
new file mode 100644
index 00000000000..1d133dbb817
--- /dev/null
+++ b/source/mesh_refinement/maximum_refinement_function.cc.bak
@@ -0,0 +1,193 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/mesh_refinement/maximum_refinement_function.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <cmath>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    MaximumRefinementFunction<dim>::update ()
+    {
+      const double time = this->get_time() /
+                          (this->convert_output_to_years()
+                           ?
+                           year_in_seconds
+                           :
+                           1.0);
+
+      max_refinement_level.set_time(time);
+    }
+
+    template <int dim>
+    void
+    MaximumRefinementFunction<dim>::tag_additional_cells () const
+    {
+      for (const auto &cell : this->get_triangulation().active_cell_iterators())
+        {
+          if (cell->is_locally_owned())
+            {
+              const Point<dim> center = cell->center();
+              const Utilities::NaturalCoordinate<dim> point =
+                this->get_geometry_model().cartesian_to_other_coordinates(center, coordinate_system);
+
+              const double maximum_refinement_level = max_refinement_level.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
+
+              if (cell->level() >= static_cast<int>(std::round(maximum_refinement_level)))
+                cell->clear_refine_flag ();
+
+              if (cell->level() > static_cast<int>(std::round(maximum_refinement_level)))
+                cell->set_coarsen_flag ();
+            }
+        }
+    }
+
+    template <int dim>
+    void
+    MaximumRefinementFunction<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+
+        prm.enter_subsection("Maximum refinement function");
+        {
+          /**
+           * Choose the coordinates to evaluate the maximum refinement level
+           * function. The function can be declared in dependence of depth,
+           * cartesian coordinates or spherical coordinates. Note that the order
+           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
+           * this allows for dimension independent expressions.
+           */
+          prm.declare_entry ("Coordinate system", "depth",
+                             Patterns::Selection ("depth|cartesian|spherical"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `depth', `cartesian' and `spherical'. `depth' "
+                             "will create a function, in which only the first "
+                             "variable is non-zero, which is interpreted to "
+                             "be the depth of the point. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle.");
+          /**
+           * Let the function that describes the maximal level of refinement
+           * as a function of position declare its parameters.
+           * This defines the maximum refinement level each cell should have,
+           * and that can not be exceeded by coarsening.
+           */
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    MaximumRefinementFunction<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Maximum refinement function");
+        {
+          if (prm.get ("Coordinate system") == "depth")
+            coordinate_system = Utilities::Coordinates::depth;
+          else if (prm.get ("Coordinate system") == "cartesian")
+            coordinate_system = Utilities::Coordinates::cartesian;
+          else if (prm.get ("Coordinate system") == "spherical")
+            coordinate_system = Utilities::Coordinates::spherical;
+          else
+            AssertThrow (false, ExcNotImplemented());
+
+          try
+            {
+              max_refinement_level.parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Mesh refinement.Maximum refinement function'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(MaximumRefinementFunction,
+                                              "maximum refinement function",
+                                              "A mesh refinement criterion that ensures a "
+                                              "maximum refinement level described by an "
+                                              "explicit formula with the depth or position "
+                                              "as argument. Which coordinate representation "
+                                              "is used is determined by an input parameter. "
+                                              "Whatever the coordinate system chosen, the "
+                                              "function you provide in the input file will "
+                                              "by default depend on variables `x', `y' and "
+                                              "`z' (if in 3d). However, the meaning of these "
+                                              "symbols depends on the coordinate system. In "
+                                              "the Cartesian coordinate system, they simply "
+                                              "refer to their natural meaning. If you have "
+                                              "selected `depth' for the coordinate system, "
+                                              "then `x' refers to the depth variable and `y' "
+                                              "and `z' will simply always be zero. If you "
+                                              "have selected a spherical coordinate system, "
+                                              "then `x' will refer to the radial distance of "
+                                              "the point to the origin, `y' to the azimuth "
+                                              "angle and `z' to the polar angle measured "
+                                              "positive from the north pole. Note that the "
+                                              "order of spherical coordinates is r,phi,theta "
+                                              "and not r,theta,phi, since this allows for "
+                                              "dimension independent expressions. "
+                                              "Each coordinate system also includes a final `t' "
+                                              "variable which represents the model time, evaluated "
+                                              "in years if the 'Use years in output instead of seconds' "
+                                              "parameter is set, otherwise evaluated in seconds. "
+                                              "After evaluating the function, its values are "
+                                              "rounded to the nearest integer."
+                                              "\n\n"
+                                              "The format of these "
+                                              "functions follows the syntax understood by the "
+                                              "muparser library, see "
+                                              "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+  }
+}
diff --git a/source/mesh_refinement/minimum_refinement_function.cc.bak b/source/mesh_refinement/minimum_refinement_function.cc.bak
new file mode 100644
index 00000000000..4c5b67b64d2
--- /dev/null
+++ b/source/mesh_refinement/minimum_refinement_function.cc.bak
@@ -0,0 +1,192 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/mesh_refinement/minimum_refinement_function.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <cmath>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    MinimumRefinementFunction<dim>::update ()
+    {
+      const double time = this->get_time() /
+                          (this->convert_output_to_years()
+                           ?
+                           year_in_seconds
+                           :
+                           1.0);
+
+      min_refinement_level.set_time(time);
+    }
+
+    template <int dim>
+    void
+    MinimumRefinementFunction<dim>::tag_additional_cells () const
+    {
+      for (const auto &cell : this->get_triangulation().active_cell_iterators())
+        {
+          if (cell->is_locally_owned())
+            {
+              const Point<dim> center = cell->center();
+              const Utilities::NaturalCoordinate<dim> point =
+                this->get_geometry_model().cartesian_to_other_coordinates(center, coordinate_system);
+
+              const double minimum_refinement_level = min_refinement_level.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
+
+              if (cell->level() <= static_cast<int>(std::round(minimum_refinement_level)))
+                cell->clear_coarsen_flag ();
+              if (cell->level() < static_cast<int>(std::round(minimum_refinement_level)))
+                cell->set_refine_flag ();
+            }
+        }
+    }
+
+    template <int dim>
+    void
+    MinimumRefinementFunction<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+
+        prm.enter_subsection("Minimum refinement function");
+        {
+          /**
+           * Choose the coordinates to evaluate the minimum refinement level
+           * function. The function can be declared in dependence of depth,
+           * cartesian coordinates or spherical coordinates. Note that the order
+           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
+           * this allows for dimension independent expressions.
+           */
+          prm.declare_entry ("Coordinate system", "depth",
+                             Patterns::Selection ("depth|cartesian|spherical"),
+                             "A selection that determines the assumed coordinate "
+                             "system for the function variables. Allowed values "
+                             "are `depth', `cartesian' and `spherical'. `depth' "
+                             "will create a function, in which only the first "
+                             "variable is non-zero, which is interpreted to "
+                             "be the depth of the point. `spherical' coordinates "
+                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
+                             "respectively with theta being the polar angle.");
+          /**
+           * Let the function that describes the minimal level of refinement
+           * as a function of position declare its parameters.
+           * This defines the minimum refinement level each cell should have,
+           * and that can not be exceeded by coarsening.
+           */
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    MinimumRefinementFunction<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Minimum refinement function");
+        {
+          if (prm.get ("Coordinate system") == "depth")
+            coordinate_system = Utilities::Coordinates::depth;
+          else if (prm.get ("Coordinate system") == "cartesian")
+            coordinate_system = Utilities::Coordinates::cartesian;
+          else if (prm.get ("Coordinate system") == "spherical")
+            coordinate_system = Utilities::Coordinates::spherical;
+          else
+            AssertThrow (false, ExcNotImplemented());
+
+          try
+            {
+              min_refinement_level.parse_parameters (prm);
+            }
+          catch (...)
+            {
+              std::cerr << "ERROR: FunctionParser failed to parse\n"
+                        << "\t'Mesh refinement.Minimum refinement function'\n"
+                        << "with expression\n"
+                        << "\t'" << prm.get("Function expression") << "'"
+                        << "More information about the cause of the parse error \n"
+                        << "is shown below.\n";
+              throw;
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(MinimumRefinementFunction,
+                                              "minimum refinement function",
+                                              "A mesh refinement criterion that ensures a "
+                                              "minimum refinement level described by an "
+                                              "explicit formula with the depth or position "
+                                              "as argument. Which coordinate representation "
+                                              "is used is determined by an input parameter. "
+                                              "Whatever the coordinate system chosen, the "
+                                              "function you provide in the input file will "
+                                              "by default depend on variables `x', `y' and "
+                                              "`z' (if in 3d). However, the meaning of these "
+                                              "symbols depends on the coordinate system. In "
+                                              "the Cartesian coordinate system, they simply "
+                                              "refer to their natural meaning. If you have "
+                                              "selected `depth' for the coordinate system, "
+                                              "then `x' refers to the depth variable and `y' "
+                                              "and `z' will simply always be zero. If you "
+                                              "have selected a spherical coordinate system, "
+                                              "then `x' will refer to the radial distance of "
+                                              "the point to the origin, `y' to the azimuth "
+                                              "angle and `z' to the polar angle measured "
+                                              "positive from the north pole. Note that the "
+                                              "order of spherical coordinates is r,phi,theta "
+                                              "and not r,theta,phi, since this allows for "
+                                              "dimension independent expressions. "
+                                              "Each coordinate system also includes a final `t' "
+                                              "variable which represents the model time, evaluated "
+                                              "in years if the 'Use years in output instead of seconds' "
+                                              "parameter is set, otherwise evaluated in seconds. "
+                                              "After evaluating the function, its values are "
+                                              "rounded to the nearest integer."
+                                              "\n\n"
+                                              "The format of these "
+                                              "functions follows the syntax understood by the "
+                                              "muparser library, see "
+                                              "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+  }
+}
diff --git a/source/mesh_refinement/nonadiabatic_temperature.cc.bak b/source/mesh_refinement/nonadiabatic_temperature.cc.bak
new file mode 100644
index 00000000000..3177c52d25b
--- /dev/null
+++ b/source/mesh_refinement/nonadiabatic_temperature.cc.bak
@@ -0,0 +1,127 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/nonadiabatic_temperature.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/numerics/derivative_approximation.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    NonadiabaticTemperature<dim>::execute(Vector<float> &indicators) const
+    {
+      indicators = 0;
+
+      // create a vector in which we set the temperature block to
+      // be a finite element interpolation of the nonadiabatic temperature.
+      // we do so by setting up a quadrature formula with the
+      // temperature unit support points, then looping over these
+      // points, compute the output quantity at them, and writing
+      // the result into the output vector in the same order
+      // (because quadrature points and temperature dofs are,
+      // by design of the quadrature formula, numbered in the
+      // same way)
+      LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
+                                                  this->get_mpi_communicator());
+
+      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
+      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature,
+                               update_quadrature_points | update_values);
+
+      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(),
+                                                 this->n_compositional_fields());
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit(cell);
+            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
+                                                                                         in.temperature);
+            in.position = fe_values.get_quadrature_points();
+
+            cell->get_dof_indices (local_dof_indices);
+
+            // for each temperature dof, write into the output
+            // vector the nonadiabatic temperature. note that quadrature points and
+            // dofs are enumerated in the same order
+            for (unsigned int i=0; i<this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell; ++i)
+              {
+                const unsigned int system_local_dof
+                  = this->get_fe().component_to_system_index(this->introspection().component_indices.temperature,
+                                                             /*dof index within component=*/i);
+
+                vec_distributed(local_dof_indices[system_local_dof])
+                  = in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]);
+              }
+          }
+
+      vec_distributed.compress(VectorOperation::insert);
+
+      // now create a vector with the requisite ghost elements
+      // and use it for estimating the gradients
+      LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
+                                      this->introspection().index_sets.system_relevant_partitioning,
+                                      this->get_mpi_communicator());
+      vec = vec_distributed;
+
+      DerivativeApproximation::approximate_gradient  (this->get_mapping(),
+                                                      this->get_dof_handler(),
+                                                      vec,
+                                                      indicators,
+                                                      this->introspection().component_indices.temperature);
+
+      // Scale gradient in each cell with the correct power of h. Otherwise,
+      // error indicators do not reduce when refined if there is a density
+      // jump. We need at least order 1 for the error not to grow when
+      // refining, so anything >1 should work. (note that the gradient
+      // itself scales like 1/h, so multiplying it with any factor h^s, s>1
+      // will yield convergence of the error indicators to zero as h->0)
+      const double power = 1.0 + dim/2.0;
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          indicators(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(NonadiabaticTemperature,
+                                              "nonadiabatic temperature",
+                                              "A mesh refinement criterion that computes "
+                                              "refinement indicators from the excess temperature"
+                                              "(difference between temperature and adiabatic "
+                                              "temperature.")
+  }
+}
diff --git a/source/mesh_refinement/nonadiabatic_temperature_threshold.cc.bak b/source/mesh_refinement/nonadiabatic_temperature_threshold.cc.bak
new file mode 100644
index 00000000000..eb8b2c8007d
--- /dev/null
+++ b/source/mesh_refinement/nonadiabatic_temperature_threshold.cc.bak
@@ -0,0 +1,158 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/nonadiabatic_temperature_threshold.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    NonadiabaticTemperatureThreshold<dim>::tag_additional_cells () const
+    {
+      // tag_additional_cells is executed before the equations are solved
+      // for the very first time. If we do not have the finite element, we
+      // do not have the temperature and just do nothing in this plugin.
+      if (this->get_dof_handler().n_locally_owned_dofs() == 0)
+        return;
+
+      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature,
+                               update_quadrature_points | update_values);
+
+      std::vector<double> temperature_values (quadrature.size());
+      const unsigned int n_dofs_per_cell = this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            bool refine = false;
+
+            fe_values.reinit(cell);
+            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
+                                                                                         temperature_values);
+
+            // if the nonadiabatic temperature exceeds the threshold, cell is marked for refinement
+            for (unsigned int j=0; j<n_dofs_per_cell; ++j)
+              {
+                const double adiabatic_temperature = this->get_adiabatic_conditions().temperature(fe_values.quadrature_point(j));
+
+                double nonadiabatic_temperature = 0;
+                if (temperature_anomaly_type == absolute_value)
+                  nonadiabatic_temperature = std::abs(temperature_values[j] - adiabatic_temperature);
+                else if (temperature_anomaly_type == positive_only)
+                  nonadiabatic_temperature = temperature_values[j] - adiabatic_temperature;
+                else if (temperature_anomaly_type == negative_only)
+                  nonadiabatic_temperature = adiabatic_temperature - temperature_values[j];
+                else
+                  AssertThrow (false, ExcNotImplemented());
+
+                if (nonadiabatic_temperature > threshold)
+                  {
+                    refine = true;
+                    break;
+                  }
+              }
+
+            if (refine)
+              {
+                cell->clear_coarsen_flag ();
+                cell->set_refine_flag ();
+              }
+          }
+    }
+
+    template <int dim>
+    void
+    NonadiabaticTemperatureThreshold<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Nonadiabatic temperature threshold");
+        {
+          prm.declare_entry ("Threshold",
+                             "100",
+                             Patterns::Double (0.),
+                             "A threshold that the nonadiabatic temperature "
+                             "will be evaluated against. "
+                             "Units: \\si{\\kelvin}");
+          prm.declare_entry ("Temperature anomaly type",
+                             "absolute value",
+                             Patterns::Selection ("negative only|positive only|absolute value"),
+                             "What type of temperature anomaly should be considered when "
+                             "evaluating against the threshold: Only negative anomalies "
+                             "(negative only), only positive anomalies (positive only) "
+                             "or the absolute value of the nonadiabatic temperature.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    NonadiabaticTemperatureThreshold<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Nonadiabatic temperature threshold");
+        {
+          threshold = prm.get_double("Threshold");
+
+          if (prm.get ("Temperature anomaly type") == "negative only")
+            temperature_anomaly_type = negative_only;
+          else if (prm.get ("Temperature anomaly type") == "positive only")
+            temperature_anomaly_type = positive_only;
+          else if (prm.get ("Temperature anomaly type") == "absolute value")
+            temperature_anomaly_type = absolute_value;
+          else
+            AssertThrow (false, ExcNotImplemented());
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(NonadiabaticTemperatureThreshold,
+                                              "nonadiabatic temperature threshold",
+                                              "A mesh refinement criterion that computes refinement "
+                                              "indicators from the temperature difference between the "
+                                              "actual temperature and the adiabatic conditions (the "
+                                              "nonadiabatic temperature). If the temperature anomaly "
+                                              "exceeds the threshold given in the input file, the cell "
+                                              "is marked for refinement.")
+  }
+}
diff --git a/source/mesh_refinement/particle_density.cc.bak b/source/mesh_refinement/particle_density.cc.bak
new file mode 100644
index 00000000000..9113dcd71e4
--- /dev/null
+++ b/source/mesh_refinement/particle_density.cc.bak
@@ -0,0 +1,75 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/particle_density.h>
+
+#include <aspect/particle/world.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    ParticleDensity<dim>::execute(Vector<float> &indicators) const
+    {
+      AssertThrow(this->n_particle_worlds() > 0,
+                  ExcMessage("The mesh refinement plugin `particle density' requires the "
+                             "postprocessor plugin `particles' to be selected. Please activate the "
+                             "particles or deactivate this mesh refinement plugin."));
+
+      const Particle::ParticleHandler<dim> &particle_handler = this->get_particle_world(0).get_particle_handler();
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            // Note  that this refinement indicator will level out the number
+            // of particles per cell, therefore creating fine cells in regions
+            // of high particle density and coarse cells in low particle
+            // density regions.
+            indicators(cell->active_cell_index()) = static_cast<float>(particle_handler.n_particles_in_cell(cell));
+          }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(ParticleDensity,
+                                              "particle density",
+                                              "A mesh refinement criterion that computes "
+                                              "refinement indicators based on the density "
+                                              "of particles. In practice this plugin "
+                                              "equilibrates the number of particles per cell, "
+                                              "leading to fine cells in high particle density regions "
+                                              "and coarse cells in low particle density regions. "
+                                              "This plugin is mostly useful for models with inhomogeneous "
+                                              "particle density, e.g. when tracking an initial interface "
+                                              "with a high particle density, or when the spatial particle "
+                                              "density denotes the region of interest. Additionally, this "
+                                              "plugin tends to balance the computational load between "
+                                              "processes in parallel computations, because the particle "
+                                              "and mesh density is more aligned.")
+  }
+}
diff --git a/source/mesh_refinement/slope.cc.bak b/source/mesh_refinement/slope.cc.bak
new file mode 100644
index 00000000000..e0804b371d6
--- /dev/null
+++ b/source/mesh_refinement/slope.cc.bak
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/slope.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    Slope<dim>::execute(Vector<float> &indicators) const
+    {
+      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+      indicators = 0;
+
+      QMidpoint<dim-1> quadrature;
+      UpdateFlags update_flags = UpdateFlags(update_normal_vectors | update_quadrature_points );
+      FEFaceValues<dim> fe_face_values (this->get_mapping(), this->get_fe(), quadrature, update_flags);
+
+      // iterate over all of the cells, get a face normal, then
+      // dot it with the local gravity
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          {
+            const unsigned int idx = cell->active_cell_index();
+            for (const unsigned int face_no : cell->face_indices())
+              if (cell->face(face_no)->at_boundary())
+                {
+                  const types::boundary_id boundary_indicator
+                    = cell->face(face_no)->boundary_id();
+
+                  // Use cases for this plugin include a deforming mesh,
+                  // or a fixed mesh with initial topography
+                  if ( (this->get_parameters().mesh_deformation_enabled &&
+                        this->get_mesh_deformation_boundary_indicators().find(boundary_indicator) !=
+                        this->get_mesh_deformation_boundary_indicators().end()) ||
+                       (Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()) &&
+                        boundary_indicator == top_boundary_id)  )
+                    {
+                      fe_face_values.reinit(cell, face_no);
+
+                      const Tensor<1,dim> normal( fe_face_values.normal_vector(0) ); // Only one q point
+                      const Point<dim> midpoint = fe_face_values.quadrature_point(0);
+                      const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(midpoint);
+
+                      indicators(idx) = std::acos( std::abs ( normal * gravity / gravity.norm() ) ) // Don't care whether gravity is in the opposite direction
+                                        * std::pow( cell->diameter(), static_cast<double>(dim-1)); // scale with approximate surface area of the cell
+                      break;  // no need to loop over the rest of the faces
+                    }
+                }
+          }
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Slope,
+                                              "slope",
+                                              "A class that implements a mesh refinement criterion intended for "
+                                              "use with deforming mesh boundaries, like the free surface. "
+                                              "It calculates a local slope based on "
+                                              "the angle between the surface normal and the local gravity vector. "
+                                              "Cells with larger angles are marked for refinement."
+                                              "\n\n"
+                                              "To use this refinement criterion, you may want to combine "
+                                              "it with other refinement criteria, setting the 'Normalize "
+                                              "individual refinement criteria' flag and using the `max' "
+                                              "setting for 'Refinement criteria merge operation'.")
+  }
+}
diff --git a/source/mesh_refinement/strain_rate.cc.bak b/source/mesh_refinement/strain_rate.cc.bak
new file mode 100644
index 00000000000..e12467a1f18
--- /dev/null
+++ b/source/mesh_refinement/strain_rate.cc.bak
@@ -0,0 +1,75 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/strain_rate.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/numerics/derivative_approximation.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    StrainRate<dim>::execute(Vector<float> &indicators) const
+    {
+      indicators = 0;
+
+      const QMidpoint<dim> quadrature;
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature,
+                               update_quadrature_points | update_values | update_gradients);
+
+      std::vector<SymmetricTensor<2,dim>> strain_rates (quadrature.size());
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            const unsigned int idx = cell->active_cell_index();
+            fe_values.reinit(cell);
+
+            fe_values[this->introspection().extractors.velocities].get_function_symmetric_gradients (this->get_solution(),
+                strain_rates);
+
+            indicators(idx) = strain_rates[0].norm();
+          }
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(StrainRate,
+                                              "strain rate",
+                                              "A mesh refinement criterion that computes the "
+                                              "refinement indicators equal to the strain rate "
+                                              "norm computed at the center of the elements.")
+  }
+}
diff --git a/source/mesh_refinement/temperature.cc.bak b/source/mesh_refinement/temperature.cc.bak
new file mode 100644
index 00000000000..a8216ccc404
--- /dev/null
+++ b/source/mesh_refinement/temperature.cc.bak
@@ -0,0 +1,83 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/temperature.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    Temperature<dim>::execute(Vector<float> &indicators) const
+    {
+      indicators = 0;
+
+      const Quadrature<dim-1> &quadrature = this->introspection().face_quadratures.temperature;
+      KellyErrorEstimator<dim>::estimate (this->get_mapping(),
+                                          this->get_dof_handler(),
+                                          quadrature,
+                                          std::map<types::boundary_id,const Function<dim>*>(),
+                                          this->get_solution(),
+                                          indicators,
+                                          this->introspection().component_masks.temperature,
+                                          nullptr,
+                                          0,
+                                          this->get_triangulation().locally_owned_subdomain());
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Temperature,
+                                              "temperature",
+                                              "A mesh refinement criterion that computes "
+                                              "refinement indicators from the temperature field."
+                                              "\n\n"
+                                              "The way these indicators are computed is by "
+                                              "evaluating the `Kelly error indicator' on the "
+                                              "temperature field. This error indicator takes the "
+                                              "finite element approximation of the temperature "
+                                              "field and uses it to compute an approximation "
+                                              "of the second derivatives of the temperature for "
+                                              "each cell. This approximation is then multiplied "
+                                              "by an appropriate power of the cell's diameter "
+                                              "to yield an indicator for how large the error "
+                                              "is likely going to be on this cell. This "
+                                              "construction rests on the observation that for "
+                                              "many partial differential equations, the error "
+                                              "on each cell is proportional to some power of "
+                                              "the cell's diameter times the second derivatives "
+                                              "of the solution on that cell."
+                                              "\n\n"
+                                              "For complex equations such as those we solve "
+                                              "here, this observation may not be strictly "
+                                              "true in the mathematical sense, but it often "
+                                              "yields meshes that are surprisingly good.")
+  }
+}
diff --git a/source/mesh_refinement/thermal_energy_density.cc.bak b/source/mesh_refinement/thermal_energy_density.cc.bak
new file mode 100644
index 00000000000..61b3d2ed4cc
--- /dev/null
+++ b/source/mesh_refinement/thermal_energy_density.cc.bak
@@ -0,0 +1,144 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/thermal_energy_density.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/numerics/derivative_approximation.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    ThermalEnergyDensity<dim>::execute(Vector<float> &indicators) const
+    {
+      indicators = 0;
+
+      // create a vector in which we set the temperature block to
+      // be a finite element interpolation of the thermal energy density
+      // rho*C_p*T. we do so by setting up a quadrature formula with the
+      // temperature unit support points, then looping over these
+      // points, compute the output quantity at them, and writing
+      // the result into the output vector in the same order
+      // (because quadrature points and temperature dofs are,
+      // by design of the quadrature formula, numbered in the
+      // same way)
+      LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
+                                                  this->get_mpi_communicator());
+
+      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
+      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature,
+                               update_quadrature_points | update_values | update_gradients);
+
+      // the values of the compositional fields are stored as block vectors for each field
+      // we have to extract them in this structure
+      std::vector<std::vector<double>> prelim_composition_values (this->n_compositional_fields(),
+                                                                   std::vector<double> (quadrature.size()));
+
+      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit(cell);
+            // Set use_strain_rates to false since we don't need viscosity
+            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+            this->get_material_model().evaluate(in, out);
+
+            cell->get_dof_indices (local_dof_indices);
+
+            // for each temperature dof, write into the output
+            // vector the density. note that quadrature points and
+            // dofs are enumerated in the same order
+            for (unsigned int i=0; i<this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell; ++i)
+              {
+                const unsigned int system_local_dof
+                  = this->get_fe().component_to_system_index(this->introspection().component_indices.temperature,
+                                                             /*dof index within component=*/i);
+
+                vec_distributed(local_dof_indices[system_local_dof])
+                  = out.densities[i]
+                    * in.temperature[i]
+                    * out.specific_heat[i];
+              }
+          }
+
+      vec_distributed.compress(VectorOperation::insert);
+
+      // now create a vector with the requisite ghost elements
+      // and use it for estimating the gradients
+      LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
+                                      this->introspection().index_sets.system_relevant_partitioning,
+                                      this->get_mpi_communicator());
+      vec = vec_distributed;
+
+      DerivativeApproximation::approximate_gradient  (this->get_mapping(),
+                                                      this->get_dof_handler(),
+                                                      vec,
+                                                      indicators,
+                                                      this->introspection().component_indices.temperature);
+
+      // Scale gradient in each cell with the correct power of h. Otherwise,
+      // error indicators do not reduce when refined if there is a density
+      // jump. We need at least order 1 for the error not to grow when
+      // refining, so anything >1 should work. (note that the gradient
+      // itself scales like 1/h, so multiplying it with any factor h^s, s>1
+      // will yield convergence of the error indicators to zero as h->0)
+      const double power = 1.5;
+      {
+        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned())
+            indicators(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(ThermalEnergyDensity,
+                                              "thermal energy density",
+                                              "A mesh refinement criterion that computes "
+                                              "refinement indicators from a field that describes "
+                                              "the spatial variability of the thermal energy density, $\\rho C_p T$. "
+                                              "Because this quantity may not be a continuous function ($\\rho$ "
+                                              "and $C_p$ may be discontinuous functions along discontinuities in the "
+                                              "medium, for example due to phase changes), we approximate the "
+                                              "gradient of this quantity to refine the mesh. The error indicator "
+                                              "defined here takes the magnitude of the approximate gradient "
+                                              "and scales it by $h_K^{1.5}$ where $h_K$ is the diameter of each cell. "
+                                              "This scaling ensures that the error indicators converge to zero as "
+                                              "$h_K\\rightarrow 0$ even if the energy density is discontinuous, since "
+                                              "the gradient of a discontinuous function grows like $1/h_K$.")
+  }
+}
diff --git a/source/mesh_refinement/topography.cc.bak b/source/mesh_refinement/topography.cc.bak
new file mode 100644
index 00000000000..8606afd221e
--- /dev/null
+++ b/source/mesh_refinement/topography.cc.bak
@@ -0,0 +1,87 @@
+/*
+  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/topography.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    Topography<dim>::execute(Vector<float> &indicators) const
+    {
+      // For calculating surface topography in the respective postprocessor
+      // we use the pressure in the middle of the cell. Thus, to get an
+      // accurate result, all the cells at the upper boundary should have
+      // the same level of refinement. This postprocessor causes a refinement
+      // in the uppermost cells, which also makes sure that the upper
+      // boundary layer is resolved as good as possible.
+
+      indicators = 0;
+
+      // need quadrature formula to calculate the depth
+      // evaluate a single point per cell
+      const QMidpoint<dim> quadrature_formula;
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      // iterate over all of the cells and choose the ones at the upper
+      // boundary for refinement (assign the largest error to them)
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            const double depth = this->get_geometry_model().depth(fe_values.quadrature_point(0));
+            if (cell->at_boundary() && depth < cell->diameter())
+              indicators(cell->active_cell_index()) = 1.0;
+          }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Topography,
+                                              "topography",
+                                              "A class that implements a mesh refinement criterion, which "
+                                              "always flags all cells in the uppermost layer for refinement. "
+                                              "This is useful to provide high accuracy for processes at or "
+                                              "close to the surface."
+                                              "\n\n"
+                                              "To use this refinement criterion, you may want to combine "
+                                              "it with other refinement criteria, setting the 'Normalize "
+                                              "individual refinement criteria' flag and using the `max' "
+                                              "setting for 'Refinement criteria merge operation'.")
+  }
+}
diff --git a/source/mesh_refinement/velocity.cc.bak b/source/mesh_refinement/velocity.cc.bak
new file mode 100644
index 00000000000..0690d20f828
--- /dev/null
+++ b/source/mesh_refinement/velocity.cc.bak
@@ -0,0 +1,83 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/velocity.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    Velocity<dim>::execute(Vector<float> &indicators) const
+    {
+      indicators = 0;
+
+      const Quadrature<dim-1> &quadrature = this->introspection().face_quadratures.velocities;
+      KellyErrorEstimator<dim>::estimate (this->get_mapping(),
+                                          this->get_dof_handler(),
+                                          quadrature,
+                                          std::map<types::boundary_id,const Function<dim>*>(),
+                                          this->get_solution(),
+                                          indicators,
+                                          this->introspection().component_masks.velocities,
+                                          nullptr,
+                                          0,
+                                          this->get_triangulation().locally_owned_subdomain());
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Velocity,
+                                              "velocity",
+                                              "A mesh refinement criterion that computes "
+                                              "refinement indicators from the velocity field."
+                                              "\n\n"
+                                              "The way these indicators are computed is by "
+                                              "evaluating the `Kelly error indicator' on the "
+                                              "velocity field. This error indicator takes the "
+                                              "finite element approximation of the velocity "
+                                              "field and uses it to compute an approximation "
+                                              "of the second derivatives of the velocity for "
+                                              "each cell. This approximation is then multiplied "
+                                              "by an appropriate power of the cell's diameter "
+                                              "to yield an indicator for how large the error "
+                                              "is likely going to be on this cell. This "
+                                              "construction rests on the observation that for "
+                                              "many partial differential equations, the error "
+                                              "on each cell is proportional to some power of "
+                                              "the cell's diameter times the second derivatives "
+                                              "of the solution on that cell."
+                                              "\n\n"
+                                              "For complex equations such as those we solve "
+                                              "here, this observation may not be strictly "
+                                              "true in the mathematical sense, but it often "
+                                              "yields meshes that are surprisingly good.")
+  }
+}
diff --git a/source/mesh_refinement/viscosity.cc.bak b/source/mesh_refinement/viscosity.cc.bak
new file mode 100644
index 00000000000..ab4cc0b167a
--- /dev/null
+++ b/source/mesh_refinement/viscosity.cc.bak
@@ -0,0 +1,148 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/viscosity.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/numerics/derivative_approximation.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    template <int dim>
+    void
+    Viscosity<dim>::execute(Vector<float> &indicators) const
+    {
+      indicators = 0;
+
+//TODO: if the viscosity doesn't actually depend on the solution
+      // then we can get away with simply interpolating it spatially
+
+
+      // create a vector in which we set the temperature block to
+      // be a finite element interpolation of the viscosity.
+      // we do so by setting up a quadrature formula with the
+      // temperature unit support points, then looping over these
+      // points, compute the output quantity at them, and writing
+      // the result into the output vector in the same order
+      // (because quadrature points and temperature dofs are,
+      // by design of the quadrature formula, numbered in the
+      // same way)
+      LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
+                                                  this->get_mpi_communicator());
+
+      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
+      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature,
+                               update_quadrature_points | update_values | update_gradients);
+
+      // the values of the compositional fields are stored as block vectors for each field
+      // we have to extract them in this structure
+      std::vector<std::vector<double>> prelim_composition_values (this->n_compositional_fields(),
+                                                                   std::vector<double> (quadrature.size()));
+
+      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(),
+                                                 this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(),
+                                                   this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit(cell);
+            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+            this->get_material_model().evaluate(in, out);
+
+            cell->get_dof_indices (local_dof_indices);
+
+            // for each temperature dof, write into the output
+            // vector the viscosity. note that quadrature points and
+            // dofs are enumerated in the same order
+            for (unsigned int i=0; i<this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell; ++i)
+              {
+                const unsigned int system_local_dof
+                  = this->get_fe().component_to_system_index(this->introspection().component_indices.temperature,
+                                                             /*dof index within component=*/i);
+
+                vec_distributed(local_dof_indices[system_local_dof])
+                  = std::log(out.viscosities[i]);
+              }
+          }
+
+      vec_distributed.compress(VectorOperation::insert);
+
+      // now create a vector with the requisite ghost elements
+      // and use it for estimating the gradients
+      LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
+                                      this->introspection().index_sets.system_relevant_partitioning,
+                                      this->get_mpi_communicator());
+      vec = vec_distributed;
+
+      DerivativeApproximation::approximate_gradient  (this->get_mapping(),
+                                                      this->get_dof_handler(),
+                                                      vec,
+                                                      indicators,
+                                                      this->introspection().component_indices.temperature);
+
+      // Scale gradient in each cell with the correct power of h. Otherwise,
+      // error indicators do not reduce when refined if there is a viscosity
+      // jump. We need at least order 1 for the error not to grow when
+      // refining, so anything >1 should work. (note that the gradient
+      // itself scales like 1/h, so multiplying it with any factor h^s, s>1
+      // will yield convergence of the error indicators to zero as h->0)
+      const double power = 1.0 + dim/2.0;
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          indicators(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Viscosity,
+                                              "viscosity",
+                                              "A mesh refinement criterion that computes "
+                                              "refinement indicators from a field that describes "
+                                              "the spatial variability of the logarithm of the viscosity, $\\log\\eta$. "
+                                              "(We choose the logarithm of the viscosity because it can vary by "
+                                              "orders of magnitude.)"
+                                              "Because this quantity may not be a continuous function ($\\eta$ "
+                                              "may be a discontinuous function along discontinuities in the "
+                                              "medium, for example due to phase changes), we approximate the "
+                                              "gradient of this quantity to refine the mesh. The error indicator "
+                                              "defined here takes the magnitude of the approximate gradient "
+                                              "and scales it by $h_K^{1+d/2}$ where $h_K$ is the diameter of each cell "
+                                              "and $d$ is the dimension. "
+                                              "This scaling ensures that the error indicators converge to zero as "
+                                              "$h_K\\rightarrow 0$ even if the viscosity is discontinuous, since "
+                                              "the gradient of a discontinuous function grows like $1/h_K$.")
+  }
+}
diff --git a/source/mesh_refinement/volume_of_fluid_interface.cc.bak b/source/mesh_refinement/volume_of_fluid_interface.cc.bak
new file mode 100644
index 00000000000..3bc7d3e2d51
--- /dev/null
+++ b/source/mesh_refinement/volume_of_fluid_interface.cc.bak
@@ -0,0 +1,345 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_refinement/volume_of_fluid_interface.h>
+#include <aspect/volume_of_fluid/handler.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/geometry_info.h>
+
+#include <deal.II/numerics/error_estimator.h>
+
+#include <deal.II/fe/fe_values.h>
+
+#include <deal.II/grid/grid_tools.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+
+    template <int dim>
+    void
+    VolumeOfFluidInterface<dim>::tag_additional_cells() const
+    {
+      // Break early if DoFs have not been distributed yet.
+      if (this->get_dof_handler().n_dofs() == 0)
+        return;
+
+      const QMidpoint<dim> qMidC;
+
+      // Create a map from vertices to adjacent cells
+      const std::vector<std::set<typename Triangulation<dim>::active_cell_iterator>>
+      vertex_to_cells(GridTools::vertex_to_cell_map(this->get_triangulation()));
+
+      std::set<typename Triangulation<dim>::active_cell_iterator> marked_cells;
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               qMidC,
+                               update_values |
+                               update_quadrature_points);
+
+      // Create block vector to indicate when other mpi process believes cell
+      // borders an interface cell and therefore neighbors should be refined
+      // Use the first vof block, due to being the correct size, and only
+      // needing one indicator
+      LinearAlgebra::BlockVector interface_contained_local(
+        this->introspection().index_sets.system_partitioning,
+        this->get_mpi_communicator());
+
+      const FiniteElement<dim> &system_fe = this->get_fe();
+
+      const VolumeOfFluidField<dim> vof_field = this->get_volume_of_fluid_handler().field_struct_for_field_index(0);
+      const unsigned int volume_fraction_block = vof_field.volume_fraction.block_index;
+      const unsigned int volume_of_fluid_c_index = vof_field.volume_fraction.first_component_index;
+      const unsigned int volume_of_fluid_ind
+        = this->get_fe().component_to_system_index(volume_of_fluid_c_index, 0);
+
+      interface_contained_local.block(volume_fraction_block) = 0.0;
+
+      std::vector<types::global_dof_index> local_dof_indices (system_fe.dofs_per_cell);
+
+      for (unsigned int f=0; f<this->get_volume_of_fluid_handler().get_n_fields(); ++f)
+        {
+
+          const double volume_fraction_threshold = this->get_volume_of_fluid_handler().get_volume_fraction_threshold();
+
+          const FEValuesExtractors::Scalar volume_of_fluid_field = this->get_volume_of_fluid_handler().field_struct_for_field_index(f)
+                                                                   .volume_fraction.extractor_scalar();
+
+          std::vector<double> volume_of_fluid_values(qMidC.size());
+          std::vector<double> neighbor_volume_of_fluid_values(qMidC.size());
+
+
+          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+            if (!cell->is_artificial())
+              {
+                bool refine_current_cell = false;
+
+                // Get cell volume_of_fluid
+                fe_values.reinit(cell);
+                fe_values[volume_of_fluid_field].get_function_values(this->get_solution(),
+                                                                     volume_of_fluid_values);
+
+                // Handle overshoots
+                volume_of_fluid_values[0] = std::min(volume_of_fluid_values[0], 1.0);
+                volume_of_fluid_values[0] = std::max(volume_of_fluid_values[0], 0.0);
+
+                // Check if at interface
+                if (volume_of_fluid_values[0] > volume_fraction_threshold && volume_of_fluid_values[0] < (1.0 - volume_fraction_threshold))
+                  {
+                    refine_current_cell = true;
+                  }
+
+                if (!refine_current_cell)
+                  {
+                    for (const unsigned int f : cell->face_indices())
+                      {
+                        const bool cell_has_periodic_neighbor = cell->has_periodic_neighbor(f);
+                        const typename DoFHandler<dim>::face_iterator face = cell->face(f);
+
+                        // Skip if face is at boundary, and does not have a periodic neighbor
+                        if (face->at_boundary() && !cell_has_periodic_neighbor)
+                          continue;
+
+                        const typename DoFHandler<dim>::cell_iterator neighbor = cell->neighbor_or_periodic_neighbor(f);
+
+                        Assert(cell.state()==IteratorState::valid, ExcInternalError());
+
+                        if ((!face->at_boundary() && !face->has_children())
+                            ||
+                            (face->at_boundary() && cell->periodic_neighbor_is_coarser(f))
+                            ||
+                            (face->at_boundary() && neighbor->level() == cell->level() && neighbor->is_active()))
+                          {
+                            if (neighbor->is_active() && !neighbor->is_artificial())
+                              {
+                                fe_values.reinit(neighbor);
+                                fe_values[volume_of_fluid_field].get_function_values(this->get_solution(),
+                                                                                     neighbor_volume_of_fluid_values);
+
+                                // Handle overshoots
+                                neighbor_volume_of_fluid_values[0] = std::min(neighbor_volume_of_fluid_values[0], 1.0);
+                                neighbor_volume_of_fluid_values[0] = std::max(neighbor_volume_of_fluid_values[0], 0.0);
+
+                                if (std::abs(neighbor_volume_of_fluid_values[0]-volume_of_fluid_values[0])>volume_fraction_threshold)
+                                  {
+                                    refine_current_cell = true;
+                                    break;
+                                  }
+                              }
+                          }
+                        else
+                          {
+                            for (unsigned int subface=0; subface < face->n_children(); ++subface)
+                              {
+                                const typename DoFHandler<dim>::active_cell_iterator neighbor_sub =
+                                  (cell_has_periodic_neighbor
+                                   ?
+                                   cell->periodic_neighbor_child_on_subface(f, subface)
+                                   :
+                                   cell->neighbor_child_on_subface(f, subface));
+
+                                Assert(neighbor_sub.state()==IteratorState::valid, ExcInternalError());
+
+                                if (neighbor_sub->is_artificial())
+                                  continue;
+
+                                fe_values.reinit(neighbor_sub);
+                                fe_values[volume_of_fluid_field].get_function_values(this->get_solution(),
+                                                                                     neighbor_volume_of_fluid_values);
+
+                                // Handle overshoots
+                                neighbor_volume_of_fluid_values[0] = std::min(neighbor_volume_of_fluid_values[0], 1.0);
+                                neighbor_volume_of_fluid_values[0] = std::max(neighbor_volume_of_fluid_values[0], 0.0);
+
+                                if (std::abs(neighbor_volume_of_fluid_values[0]-volume_of_fluid_values[0])>volume_fraction_threshold)
+                                  {
+                                    refine_current_cell = true;
+                                    break;
+                                  }
+
+                              }
+                            if (refine_current_cell)
+                              break;
+                          }
+                      }
+                  }
+
+                if (refine_current_cell)
+                  {
+                    // Fractional volume
+                    marked_cells.insert(cell);
+                    if (cell->is_locally_owned())
+                      {
+                        cell->clear_coarsen_flag ();
+                        cell->set_refine_flag ();
+                        // Mark in vector, will be true here if true on any process
+                        cell->get_dof_indices(local_dof_indices);
+                        interface_contained_local(local_dof_indices[volume_of_fluid_ind]) = 1.0;
+                      }
+                  }
+
+              }
+        }
+
+      // Now communicate and mark any cells not already included, this could be
+      // reduced to only loop over cells bordering another process
+      LinearAlgebra::BlockVector interface_contained_global(
+        this->introspection().index_sets.system_partitioning,
+        this->introspection().index_sets.system_relevant_partitioning,
+        this->get_mpi_communicator());
+
+      interface_contained_global.block(volume_fraction_block) = interface_contained_local.block(volume_fraction_block);
+      interface_contained_global.update_ghost_values();
+
+      const FEValuesExtractors::Scalar ic_extract = this->get_volume_of_fluid_handler().field_struct_for_field_index(0)
+                                                    .volume_fraction.extractor_scalar();
+      std::vector<double> ic_values(qMidC.size());
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (!cell->is_artificial())
+          {
+            fe_values.reinit(cell);
+            fe_values[ic_extract].get_function_values(interface_contained_global,
+                                                      ic_values);
+
+            // If the cell has been indicated to need refinement add it
+            if (ic_values[0]>0.5)
+              {
+                marked_cells.insert(cell);
+              }
+          }
+
+      // Now mark for refinement all cells that are a neighbor of a cell that contains the interface
+
+      std::set<typename Triangulation<dim>::active_cell_iterator> marked_cells_and_neighbors = marked_cells;
+      typename std::set<typename parallel::distributed::Triangulation<dim>::active_cell_iterator>::const_iterator mcells = marked_cells.begin(),
+                                                                                                                  endmc = marked_cells.end();
+      for (; mcells != endmc; ++mcells)
+        {
+          typename parallel::distributed::Triangulation<dim>::active_cell_iterator mcell = *mcells;
+          for (const unsigned int vertex_index : mcell->vertex_indices())
+            {
+              const std::set<typename Triangulation<dim>::active_cell_iterator> &neighbor_cells = vertex_to_cells[mcell->vertex_index(vertex_index)];
+              for (const auto &neighbor_cell : neighbor_cells)
+                {
+                  if (neighbor_cell->is_active() && neighbor_cell->is_locally_owned())
+                    {
+                      neighbor_cell->clear_coarsen_flag ();
+                      neighbor_cell->set_refine_flag ();
+                      marked_cells_and_neighbors.insert(neighbor_cell);
+                    }
+                }
+            }
+
+          // Check for periodic neighbors, and refine if existing
+          for (const unsigned int f : mcell->face_indices())
+            {
+              if (mcell->has_periodic_neighbor(f))
+                {
+                  typename Triangulation<dim>::cell_iterator itr_tmp = mcell->periodic_neighbor(f);
+
+                  if (itr_tmp->is_active() && itr_tmp->is_locally_owned())
+                    {
+                      itr_tmp->clear_coarsen_flag ();
+                      itr_tmp->set_refine_flag ();
+                      marked_cells_and_neighbors.insert(itr_tmp);
+                    }
+                }
+            }
+        }
+
+      if (strict_coarsening)
+        {
+          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+            if (cell->is_locally_owned())
+              {
+                if (marked_cells_and_neighbors.find(cell) != marked_cells_and_neighbors.end())
+                  {
+                    //Refinement already requested
+                  }
+                else
+                  {
+                    if (cell->is_active())
+                      {
+                        cell->set_coarsen_flag();
+                        cell->clear_refine_flag();
+                      }
+                  }
+              }
+
+        }
+
+    }
+
+    template <int dim>
+    void
+    VolumeOfFluidInterface<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Volume of fluid interface");
+        {
+          prm.declare_entry("Strict coarsening", "false",
+                            Patterns::Bool(),
+                            "If true, then explicitly coarsen any cells not "
+                            "neighboring the VolumeOfFluid interface.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    VolumeOfFluidInterface<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      AssertThrow(this->get_parameters().volume_of_fluid_tracking_enabled,
+                  ExcMessage("The 'volume_of_fluid boundary' mesh refinement strategy requires that the 'Use interface tracking' parameter is enabled."));
+
+      prm.enter_subsection("Mesh refinement");
+      {
+        prm.enter_subsection("Volume of fluid interface");
+        {
+          strict_coarsening = prm.get_bool("Strict coarsening");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(VolumeOfFluidInterface,
+                                              "volume of fluid interface",
+                                              "A class that implements a mesh refinement criterion, which "
+                                              "ensures a minimum level of refinement near the volume of fluid interface boundary.")
+  }
+}
diff --git a/source/particle/generator/ascii_file.cc.bak b/source/particle/generator/ascii_file.cc.bak
new file mode 100644
index 00000000000..539c55f496f
--- /dev/null
+++ b/source/particle/generator/ascii_file.cc.bak
@@ -0,0 +1,133 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/generator/ascii_file.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      template <int dim>
+      void
+      AsciiFile<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
+      {
+        const std::string filename = data_directory+data_filename;
+
+        // Read data from disk and distribute among processes
+        std::istringstream in(Utilities::read_and_distribute_file_content(filename, this->get_mpi_communicator()));
+
+        // Skip header lines
+        while (in.peek() == '#')
+          {
+            std::string temp;
+            std::getline(in,temp);
+          }
+
+        // Read data lines
+        types::particle_index particle_index = 0;
+        Point<dim> particle_position;
+
+        while (in >> particle_position)
+          {
+            this->insert_particle_at_position(particle_position, particle_index, particle_handler);
+            ++particle_index;
+          }
+        particle_handler.update_cached_numbers();
+      }
+
+
+      template <int dim>
+      void
+      AsciiFile<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Ascii file");
+          {
+            prm.declare_entry ("Data directory",
+                               "$ASPECT_SOURCE_DIR/data/particle/generator/ascii/",
+                               Patterns::DirectoryName (),
+                               "The name of a directory that contains the particle data. This path "
+                               "may either be absolute (if starting with a '/') or relative to "
+                               "the current directory. The path may also include the special "
+                               "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                               "in which the ASPECT source files were located when ASPECT was "
+                               "compiled. This interpretation allows, for example, to reference "
+                               "files located in the `data/' subdirectory of ASPECT. ");
+            prm.declare_entry ("Data file name", "particle.dat",
+                               Patterns::Anything (),
+                               "The name of the particle file.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      AsciiFile<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Ascii file");
+          {
+            data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+
+            data_filename    = prm.get ("Data file name");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      ASPECT_REGISTER_PARTICLE_GENERATOR(AsciiFile,
+                                         "ascii file",
+                                         "Generates a distribution of particles from coordinates "
+                                         "specified in an Ascii data file. The file format is "
+                                         "a simple text file, with as many columns as spatial "
+                                         "dimensions and as many lines as particles to be generated. "
+                                         "Initial comment lines starting with `#' will be discarded. "
+                                         "Note that this plugin always generates as many particles "
+                                         "as there are coordinates in the data file, the "
+                                         "``Particles/Number of particles'' parameter "
+                                         "has no effect on this plugin. "
+                                         "All of the values that define this generator are read "
+                                         "from a section ``Particles/Generator/Ascii file'' in the "
+                                         "input file, see "
+                                         "Section~\\ref{parameters:Particles/Generator/Ascii_20file}.")
+    }
+  }
+}
diff --git a/source/particle/generator/interface.cc.bak b/source/particle/generator/interface.cc.bak
new file mode 100644
index 00000000000..f48c36c2525
--- /dev/null
+++ b/source/particle/generator/interface.cc.bak
@@ -0,0 +1,306 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/generator/interface.h>
+
+#include <tuple>
+#include <deal.II/grid/grid_tools.h>
+
+#include <boost/lexical_cast.hpp>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      template <int dim>
+      void
+      Interface<dim>::initialize ()
+      {
+        const unsigned int my_rank = Utilities::MPI::this_mpi_process(this->get_mpi_communicator());
+        random_number_generator.seed(5432+my_rank);
+      }
+
+
+
+      template <int dim>
+      void
+      Interface<dim>::generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &/*particles*/)
+      {
+        AssertThrow(false,ExcInternalError());
+      }
+
+
+
+      template <int dim>
+      void
+      Interface<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
+      {
+        // This function is implemented to ensure backwards compatibility to an old interface.
+        // Once the old interface function has been removed this implementation can be removed
+        // as well and the function can be made pure.
+
+        std::multimap<Particles::internal::LevelInd, Particles::Particle<dim>> particles;
+
+        // avoid deprecation warnings about calling the old interface
+        DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
+        generate_particles(particles);
+        DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
+
+        std::multimap<typename Triangulation<dim>::active_cell_iterator, Particles::Particle<dim>> new_particles;
+
+        for (const auto &particle : particles)
+          new_particles.insert(new_particles.end(),
+                               std::make_pair(typename Triangulation<dim>::active_cell_iterator(&this->get_triangulation(),
+                                              particle.first.first, particle.first.second),
+                                              particle.second));
+
+        particle_handler.insert_particles(new_particles);
+      }
+
+
+
+      template <int dim>
+      std::pair<Particles::internal::LevelInd,Particle<dim>>
+      Interface<dim>::generate_particle(const Point<dim> &position,
+                                        const types::particle_index id) const
+      {
+        // Try to find the cell of the given position. If the position is not
+        // in the domain on the local process, throw a ExcParticlePointNotInDomain
+        // exception.
+        std::pair<const typename parallel::distributed::Triangulation<dim>::active_cell_iterator,
+            Point<dim>> it =
+              GridTools::find_active_cell_around_point<> (this->get_mapping(), this->get_triangulation(), position);
+
+        // Only try to add the point if the cell it is in, is on this processor
+        AssertThrow(it.first.state() == IteratorState::valid && it.first->is_locally_owned(),
+                    ExcParticlePointNotInDomain());
+
+        const Particle<dim> particle(position, it.second, id);
+        const Particles::internal::LevelInd cell(it.first->level(), it.first->index());
+        return std::make_pair(cell,particle);
+
+        // Avoid warnings about missing return
+        return {};
+      }
+
+
+
+      template <int dim>
+      Particles::ParticleIterator<dim>
+      Interface<dim>::insert_particle_at_position(const Point<dim> &position,
+                                                  const types::particle_index id,
+                                                  Particles::ParticleHandler<dim> &particle_handler) const
+      {
+        // Try to find the cell of the given position.
+        const std::pair<const typename parallel::distributed::Triangulation<dim>::active_cell_iterator,
+              Point<dim>> it =
+                GridTools::find_active_cell_around_point<> (this->get_mapping(), this->get_triangulation(), position);
+
+        if (it.first.state() != IteratorState::valid || it.first->is_locally_owned() == false)
+          return particle_handler.end();
+
+        return particle_handler.insert_particle(Particle<dim>(position, it.second, id), it.first);
+      }
+
+
+
+      template <int dim>
+      std::pair<Particles::internal::LevelInd,Particle<dim>>
+      Interface<dim>::generate_particle (const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell,
+                                         const types::particle_index id)
+      {
+        // Uniform distribution on the interval [0,1]. This
+        // will be used to generate random particle locations.
+        std::uniform_real_distribution<double> uniform_distribution_01(0.0, 1.0);
+
+        const BoundingBox<dim> cell_bounding_box = cell->bounding_box();
+
+        // Generate random points in these bounds until one is within the cell
+        unsigned int iteration = 0;
+        const unsigned int maximum_iterations = 100;
+        Point<dim> particle_position;
+        while (iteration < maximum_iterations)
+          {
+            // First generate a random point in the bounding box...
+            for (unsigned int d=0; d<dim; ++d)
+              particle_position[d] = cell_bounding_box.lower_bound(d)
+                                     + (uniform_distribution_01(random_number_generator) *
+                                        cell_bounding_box.side_length(d));
+
+            // ...then check whether it is actually in the cell:
+            try
+              {
+                const Point<dim> p_unit = this->get_mapping().transform_real_to_unit_cell(cell, particle_position);
+                if (
+                  cell->reference_cell().contains_point(p_unit)
+                )
+                  {
+                    // Add the generated particle to the set
+                    const Particle<dim> new_particle(particle_position, p_unit, id);
+                    const Particles::internal::LevelInd cellid(cell->level(), cell->index());
+                    return std::make_pair(cellid,new_particle);
+                  }
+              }
+            catch (typename Mapping<dim>::ExcTransformationFailed &)
+              {
+                // The point is not in this cell. Do nothing, just try again.
+              }
+            ++iteration;
+          }
+
+        // If the above algorithm has not worked (e.g. because of badly
+        // deformed cells), retry generating particles
+        // randomly within the reference cell. This is not generating a
+        // uniform distribution in real space, but will always succeed.
+        for (unsigned int d=0; d<dim; ++d)
+          particle_position[d] = uniform_distribution_01(random_number_generator);
+
+        const Point<dim> p_real = this->get_mapping().transform_unit_to_real_cell(cell,particle_position);
+
+        // Add the generated particle to the set
+        const Particle<dim> new_particle(p_real, particle_position, id);
+        const Particles::internal::LevelInd cellid(cell->level(), cell->index());
+
+        return std::make_pair(cellid, new_particle);
+      }
+
+
+// -------------------------------- Deal with registering models and automating
+// -------------------------------- their setup and selection at run time
+
+      namespace
+      {
+        std::tuple
+        <void *,
+        void *,
+        aspect::internal::Plugins::PluginList<Interface<2>>,
+        aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+      }
+
+
+
+      template <int dim>
+      void
+      register_particle_generator (const std::string &name,
+                                   const std::string &description,
+                                   void (*declare_parameters_function) (ParameterHandler &),
+                                   std::unique_ptr<Interface<dim>> (*factory_function) ())
+      {
+        std::get<dim>(registered_plugins).register_plugin (name,
+                                                           description,
+                                                           declare_parameters_function,
+                                                           factory_function);
+      }
+
+
+
+      template <int dim>
+      std::unique_ptr<Interface<dim>>
+      create_particle_generator (ParameterHandler &prm)
+      {
+        std::string name;
+        name = prm.get ("Particle generator name");
+
+        return std::get<dim>(registered_plugins).create_plugin (name,
+                                                                "Particle::Generator name");
+      }
+
+
+
+      template <int dim>
+      void
+      declare_parameters (ParameterHandler &prm)
+      {
+        // declare the entry in the parameter file
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry ("Particle generator name", "random uniform",
+                           Patterns::Selection (pattern_of_names),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+
+        std::get<dim>(registered_plugins).declare_parameters (prm);
+      }
+
+
+
+      template <int dim>
+      void
+      write_plugin_graph (std::ostream &out)
+      {
+        std::get<dim>(registered_plugins).write_plugin_graph ("Particle generator interface",
+                                                              out);
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<Particle::Generator::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<Particle::Generator::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<Particle::Generator::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<Particle::Generator::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace Particle
+  {
+    namespace Generator
+    {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_particle_generator<dim> (const std::string &, \
+                                    const std::string &, \
+                                    void ( *) (ParameterHandler &), \
+                                    std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_particle_generator<dim> (ParameterHandler &prm);
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/source/particle/generator/probability_density_function.cc.bak b/source/particle/generator/probability_density_function.cc.bak
new file mode 100644
index 00000000000..d276fd2399e
--- /dev/null
+++ b/source/particle/generator/probability_density_function.cc.bak
@@ -0,0 +1,149 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/generator/probability_density_function.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/geometry_info.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      template <int dim>
+      void
+      ProbabilityDensityFunction<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
+      {
+        Particles::Generators::probabilistic_locations(this->get_triangulation(),
+                                                       function,
+                                                       random_cell_selection,
+                                                       n_particles,
+                                                       particle_handler,
+                                                       this->get_mapping(),
+                                                       random_number_seed);
+      }
+
+
+
+      template <int dim>
+      void
+      ProbabilityDensityFunction<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Probability density function");
+          {
+            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+
+            prm.declare_entry ("Number of particles", "1000",
+                               Patterns::Double (0.),
+                               "Total number of particles to create (not per processor or per element). "
+                               "The number is parsed as a floating point number (so that one can "
+                               "specify, for example, '1e4' particles) but it is interpreted as "
+                               "an integer, of course.");
+
+            prm.declare_entry ("Random cell selection", "true",
+                               Patterns::Bool(),
+                               "If true, particle numbers per cell are calculated randomly "
+                               "according to their respective probability density. "
+                               "This means particle numbers per cell can deviate statistically from "
+                               "the integral of the probability density. If false, "
+                               "first determine how many particles each cell should have "
+                               "based on the integral of the density over each of the cells, "
+                               "and then once we know how many particles we want on each cell, "
+                               "choose their locations randomly within each cell.");
+
+            prm.declare_entry ("Random number seed", "5432",
+                               Patterns::Integer(0),
+                               "The seed for the random number generator that controls "
+                               "the particle generation. Keep constant to generate "
+                               "identical particle distributions in subsequent model "
+                               "runs. Change to get a different distribution. In parallel "
+                               "computations the seed is further modified on each process "
+                               "to ensure different particle patterns on different "
+                               "processes. Note that the number of particles per processor "
+                               "is not affected by the seed.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      ProbabilityDensityFunction<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Probability density function");
+          {
+            n_particles = static_cast<types::particle_index>(prm.get_double ("Number of particles"));
+            random_cell_selection = prm.get_bool("Random cell selection");
+            random_number_seed = prm.get_integer("Random number seed");
+
+            try
+              {
+                function.parse_parameters (prm);
+              }
+            catch (...)
+              {
+                std::cerr << "ERROR: FunctionParser failed to parse\n"
+                          << "\t'Particle.Generator.Probability density function'\n"
+                          << "with expression\n"
+                          << "\t'" << prm.get("Function expression") << "'";
+                throw;
+              }
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      ASPECT_REGISTER_PARTICLE_GENERATOR(ProbabilityDensityFunction,
+                                         "probability density function",
+                                         "Generate a random distribution of "
+                                         "particles over the entire simulation domain. "
+                                         "The probability density is prescribed in the "
+                                         "form of a user-prescribed function. The "
+                                         "format of this function follows the syntax "
+                                         "understood by the muparser library, see "
+                                         "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`. The "
+                                         "return value of the function is always "
+                                         "checked to be a non-negative probability "
+                                         "density but it can be zero in "
+                                         "parts of the domain.")
+    }
+  }
+}
diff --git a/source/particle/generator/quadrature_points.cc.bak b/source/particle/generator/quadrature_points.cc.bak
new file mode 100644
index 00000000000..5264920e257
--- /dev/null
+++ b/source/particle/generator/quadrature_points.cc.bak
@@ -0,0 +1,63 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/generator/quadrature_points.h>
+
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      template <int dim>
+      void
+      QuadraturePoints<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
+      {
+        const Quadrature<dim> &quadrature_formula
+          = this->introspection().quadratures.velocities;
+
+        Particles::Generators::regular_reference_locations(
+          this->get_triangulation(),
+          quadrature_formula.get_points(),
+          particle_handler,
+          this->get_mapping());
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      ASPECT_REGISTER_PARTICLE_GENERATOR(QuadraturePoints,
+                                         "quadrature points",
+                                         "Generates particles at the quadrature points of each active cell of "
+                                         "the triangulation. Here, Gauss quadrature of degree (velocity\\_degree + 1), "
+                                         "is used similarly to the assembly of Stokes matrix.")
+    }
+  }
+}
diff --git a/source/particle/generator/random_uniform.cc.bak b/source/particle/generator/random_uniform.cc.bak
new file mode 100644
index 00000000000..3fa2c84efca
--- /dev/null
+++ b/source/particle/generator/random_uniform.cc.bak
@@ -0,0 +1,123 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/generator/random_uniform.h>
+
+#include <deal.II/base/function.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      template <int dim>
+      void
+      RandomUniform<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
+      {
+        Particles::Generators::probabilistic_locations(this->get_triangulation(),
+                                                       Functions::ConstantFunction<dim>(1.0),
+                                                       random_cell_selection,
+                                                       n_particles,
+                                                       particle_handler,
+                                                       this->get_mapping(),
+                                                       random_number_seed);
+      }
+
+
+
+      template <int dim>
+      void
+      RandomUniform<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Probability density function");
+          {
+            prm.declare_entry ("Number of particles", "1000",
+                               Patterns::Double (0.),
+                               "Total number of particles to create (not per processor or per element). "
+                               "The number is parsed as a floating point number (so that one can "
+                               "specify, for example, '1e4' particles) but it is interpreted as "
+                               "an integer, of course.");
+
+            prm.declare_entry ("Random cell selection", "true",
+                               Patterns::Bool(),
+                               "If true, particle numbers per cell are calculated randomly "
+                               "according to their respective probability density. "
+                               "This means particle numbers per cell can deviate statistically from "
+                               "the integral of the probability density. If false, "
+                               "first determine how many particles each cell should have "
+                               "based on the integral of the density over each of the cells, "
+                               "and then once we know how many particles we want on each cell, "
+                               "choose their locations randomly within each cell.");
+
+            prm.declare_entry ("Random number seed", "5432",
+                               Patterns::Integer(0),
+                               "The seed for the random number generator that controls "
+                               "the particle generation. Keep constant to generate "
+                               "identical particle distributions in subsequent model "
+                               "runs. Change to get a different distribution. In parallel "
+                               "computations the seed is further modified on each process "
+                               "to ensure different particle patterns on different "
+                               "processes. Note that the number of particles per processor "
+                               "is not affected by the seed.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      RandomUniform<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Probability density function");
+          {
+            n_particles = static_cast<types::particle_index>(prm.get_double ("Number of particles"));
+            random_cell_selection = prm.get_bool("Random cell selection");
+            random_number_seed = prm.get_integer("Random number seed");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      ASPECT_REGISTER_PARTICLE_GENERATOR(RandomUniform,
+                                         "random uniform",
+                                         "Generates a random uniform distribution of "
+                                         "particles over the entire simulation domain.")
+    }
+  }
+}
diff --git a/source/particle/generator/reference_cell.cc.bak b/source/particle/generator/reference_cell.cc.bak
new file mode 100644
index 00000000000..cc63692f827
--- /dev/null
+++ b/source/particle/generator/reference_cell.cc.bak
@@ -0,0 +1,148 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/generator/reference_cell.h>
+
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      template <int dim>
+      void
+      ReferenceCell<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
+      {
+        const std::vector<Point<dim>> reference_locations = generate_particle_positions_in_unit_cell();
+
+        Particles::Generators::regular_reference_locations(this->get_triangulation(),
+                                                           reference_locations,
+                                                           particle_handler,
+                                                           this->get_mapping());
+      }
+
+
+      template <int dim>
+      std::vector<Point<dim>>
+      ReferenceCell<dim>::generate_particle_positions_in_unit_cell()
+      {
+        std::vector<Point<dim>> particle_positions;
+        std::array<double, dim> spacing;
+
+        // Calculate separation of particles
+        for (unsigned int i = 0; i < dim; ++i)
+          spacing[i] = 1.0 / number_of_particles[i];
+
+        for (unsigned int i = 0; i < number_of_particles[0]; ++i)
+          {
+            for (unsigned int j = 0; j < number_of_particles[1]; ++j)
+              {
+                if (dim == 2)
+                  {
+                    const Point<dim> position_unit = Point<dim>(i * spacing[0] + spacing[0] / 2,
+                                                                j * spacing[1] + spacing[1] / 2);
+                    particle_positions.push_back(position_unit);
+                  }
+                else if (dim == 3)
+                  {
+                    for (unsigned int k = 0; k < number_of_particles[2]; ++k)
+                      {
+                        const Point<dim> position_unit = Point<dim>(i * spacing[0] + spacing[0] / 2,
+                                                                    j * spacing[1] + spacing[1] / 2,
+                                                                    k * spacing[2] + spacing[2] / 2);
+                        particle_positions.push_back(position_unit);
+                      }
+                  }
+                else
+                  ExcNotImplemented();
+              }
+          }
+
+        return particle_positions;
+      }
+
+
+      template <int dim>
+      void
+      ReferenceCell<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Reference cell");
+          {
+            prm.declare_entry ("Number of particles per cell per direction", "2",
+                               Patterns::List(Patterns::Integer(1)),
+                               "List of number of particles to create per cell and spatial dimension. "
+                               "The size of the list is the number of spatial dimensions. If only "
+                               "one value is given, then each spatial dimension is set to the same value. "
+                               "The list of numbers are parsed as a floating point number (so that one can "
+                               "specify, for example, '1e4' particles) but it is interpreted as "
+                               "an integer, of course.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      ReferenceCell<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Reference cell");
+          {
+            const auto n_particles_per_direction = Utilities::possibly_extend_from_1_to_N (
+                                                     Utilities::string_to_int(
+                                                       Utilities::split_string_list(prm.get("Number of particles per cell per direction"))),
+                                                     dim,
+                                                     "Number of particles per cell per direction");
+
+            for (const auto &n_particle_direction: n_particles_per_direction)
+              number_of_particles.push_back(static_cast<unsigned int> (n_particle_direction));
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      ASPECT_REGISTER_PARTICLE_GENERATOR(ReferenceCell,
+                                         "reference cell",
+                                         "Generates a uniform distribution of particles per cell and spatial direction in "
+                                         "the unit cell and transforms each of the particles back to real region in the model "
+                                         "domain. Uniform here means the particles will be generated with an equal spacing in "
+                                         "each spatial dimension.")
+    }
+  }
+}
diff --git a/source/particle/generator/uniform_box.cc.bak b/source/particle/generator/uniform_box.cc.bak
new file mode 100644
index 00000000000..ca452055b7a
--- /dev/null
+++ b/source/particle/generator/uniform_box.cc.bak
@@ -0,0 +1,175 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/generator/uniform_box.h>
+
+#include <random>
+
+#include <array>
+#include <deal.II/base/exceptions.h>
+
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      template <int dim>
+      void
+      UniformBox<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
+      {
+        const Tensor<1,dim> P_diff = P_max - P_min;
+
+        double volume(1.0);
+        for (unsigned int i = 0; i < dim; ++i)
+          volume *= P_diff[i];
+
+        std::array<unsigned int,dim> n_particles_per_direction;
+        std::array<double,dim> spacing;
+
+        // Calculate separation of particles
+        for (unsigned int i = 0; i < dim; ++i)
+          {
+            n_particles_per_direction[i] = static_cast<unsigned int>(round(std::pow(n_particles * std::pow(P_diff[i],dim) / volume, 1./dim)));
+            spacing[i] = P_diff[i] / fmax(n_particles_per_direction[i] - 1,1);
+          }
+
+        types::particle_index particle_index = 0;
+
+        for (unsigned int i = 0; i < n_particles_per_direction[0]; ++i)
+          {
+            for (unsigned int j = 0; j < n_particles_per_direction[1]; ++j)
+              {
+                if (dim == 2)
+                  {
+                    const Point<dim> particle_position = Point<dim> (P_min[0]+i*spacing[0],P_min[1]+j*spacing[1]);
+                    this->insert_particle_at_position(particle_position, particle_index, particle_handler);
+                    ++particle_index;
+                  }
+                else if (dim == 3)
+                  for (unsigned int k = 0; k < n_particles_per_direction[2]; ++k)
+                    {
+                      const Point<dim> particle_position = Point<dim> (P_min[0]+i*spacing[0],P_min[1]+j*spacing[1],P_min[2]+k*spacing[2]);
+                      this->insert_particle_at_position(particle_position, particle_index, particle_handler);
+                      ++particle_index;
+                    }
+
+              }
+          }
+
+        particle_handler.update_cached_numbers();
+      }
+
+
+      template <int dim>
+      void
+      UniformBox<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Uniform box");
+          {
+            prm.declare_entry ("Number of particles", "1000",
+                               Patterns::Double (0.),
+                               "Total number of particles to create (not per processor or per element). "
+                               "The number is parsed as a floating point number (so that one can "
+                               "specify, for example, '1e4' particles) but it is interpreted as "
+                               "an integer, of course.");
+
+            prm.declare_entry ("Minimum x", "0.",
+                               Patterns::Double (),
+                               "Minimum x coordinate for the region of particles.");
+            prm.declare_entry ("Maximum x", "1.",
+                               Patterns::Double (),
+                               "Maximum x coordinate for the region of particles.");
+            prm.declare_entry ("Minimum y", "0.",
+                               Patterns::Double (),
+                               "Minimum y coordinate for the region of particles.");
+            prm.declare_entry ("Maximum y", "1.",
+                               Patterns::Double (),
+                               "Maximum y coordinate for the region of particles.");
+            prm.declare_entry ("Minimum z", "0.",
+                               Patterns::Double (),
+                               "Minimum z coordinate for the region of particles.");
+            prm.declare_entry ("Maximum z", "1.",
+                               Patterns::Double (),
+                               "Maximum z coordinate for the region of particles.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      UniformBox<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Uniform box");
+          {
+            n_particles    = static_cast<types::particle_index>(prm.get_double ("Number of particles"));
+
+            P_min(0) = prm.get_double ("Minimum x");
+            P_max(0) = prm.get_double ("Maximum x");
+            P_min(1) = prm.get_double ("Minimum y");
+            P_max(1) = prm.get_double ("Maximum y");
+
+            AssertThrow(P_min(0) < P_max(0), ExcMessage("Minimum x must be less than maximum x"));
+            AssertThrow(P_min(1) < P_max(1), ExcMessage("Minimum y must be less than maximum y"));
+
+            if (dim == 3)
+              {
+                P_min(2) = prm.get_double ("Minimum z");
+                P_max(2) = prm.get_double ("Maximum z");
+
+                AssertThrow(P_min(2) < P_max(2), ExcMessage("Minimum z must be less than maximum z"));
+              }
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      ASPECT_REGISTER_PARTICLE_GENERATOR(UniformBox,
+                                         "uniform box",
+                                         "Generate a uniform distribution of particles "
+                                         "over a rectangular domain in 2d or 3d. Uniform here means "
+                                         "the particles will be generated with an equal spacing in "
+                                         "each spatial dimension. Note that in order "
+                                         "to produce a regular distribution the number of generated "
+                                         "particles might not exactly match the one specified in the "
+                                         "input file.")
+    }
+  }
+}
diff --git a/source/particle/generator/uniform_radial.cc.bak b/source/particle/generator/uniform_radial.cc.bak
new file mode 100644
index 00000000000..5604feb5ecb
--- /dev/null
+++ b/source/particle/generator/uniform_radial.cc.bak
@@ -0,0 +1,254 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/generator/uniform_radial.h>
+
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      template <int dim>
+      void
+      UniformRadial<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
+      {
+        // Create the array of shell to deal with
+        const double radial_spacing = (P_max[0] - P_min[0]) / fmax(radial_layers-1,1);
+
+        // Calculate number of particles per shell.
+        // The number of particles depend on the fraction of the area
+        // (or length in 2d) that this shell occupies compared to the total domain
+        std::vector<unsigned int> particles_per_layer(radial_layers);
+        if (dim == 2)
+          {
+            double total_radius = 0;
+            for (unsigned int i = 0; i < radial_layers; ++i)
+              total_radius += P_min[0] + (radial_spacing * i);
+            for (unsigned int i = 0; i < radial_layers; ++i)
+              {
+                const double radius = P_min[0] + (radial_spacing * i);
+                particles_per_layer[i] = static_cast<unsigned int>(round(n_particles * radius / total_radius));
+              }
+          }
+        else if (dim == 3)
+          {
+            double total_area = 0;
+            for (unsigned int i = 0; i < radial_layers; ++i)
+              total_area += std::pow(P_min[0] + (radial_spacing * i),2);
+            for (unsigned int i = 0; i < radial_layers; ++i)
+              {
+                const double area = std::pow(P_min[0] + (radial_spacing * i),2);
+                particles_per_layer[i] = static_cast<unsigned int>(round(n_particles * area / total_area));
+              }
+          }
+        else
+          ExcNotImplemented();
+
+        // Generate particles
+
+        types::particle_index particle_index = 0;
+        std::array<double,dim> spherical_coordinates;
+        for (unsigned int i = 0; i < radial_layers; ++i)
+          {
+            spherical_coordinates[0] = P_min[0] + (radial_spacing * i);
+            if (dim == 2)
+              {
+                const double phi_spacing = (P_max[1] - P_min[1]) / fmax(particles_per_layer[i]-1,1);
+
+                for (unsigned int j = 0; j < particles_per_layer[i]; ++j)
+                  {
+                    spherical_coordinates[1] = P_min[1] + j * phi_spacing;
+                    const Point<dim> particle_position = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_coordinates) + P_center;
+                    this->insert_particle_at_position(particle_position, particle_index, particle_handler);
+                    ++particle_index;
+                  }
+              }
+            else if (dim == 3)
+              {
+                const unsigned int theta_particles = static_cast<unsigned int>(
+                                                       round(sqrt(particles_per_layer[i])));
+                const unsigned int phi_particles = static_cast<unsigned int>(
+                                                     round(
+                                                       static_cast<double>(particles_per_layer[i])
+                                                       /
+                                                       static_cast<double>(theta_particles)));
+                const double theta_spacing = (P_max[2] - P_min[2]) / fmax(theta_particles-1,1);
+
+                for (unsigned int j = 0; j < theta_particles; ++j)
+                  {
+                    spherical_coordinates[2] = P_min[2] + j * theta_spacing;
+
+                    // Average value of sin(n) from 0 to 180 degrees is (2/pi)
+                    const unsigned int adjusted_phi_particles = std::max(static_cast<unsigned int> (phi_particles * std::sin(spherical_coordinates[2])), 1u);
+                    const double phi_spacing = (P_max[1] - P_min[1]) / fmax(adjusted_phi_particles-1,1);
+                    for (unsigned int k = 0; k < adjusted_phi_particles; ++k)
+                      {
+                        spherical_coordinates[1] = P_min[1] + k * phi_spacing;
+                        const Point<dim> particle_position = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_coordinates) + P_center;
+                        this->insert_particle_at_position(particle_position, particle_index, particle_handler);
+                        ++particle_index;
+                      }
+                  }
+              }
+          }
+
+        particle_handler.update_cached_numbers();
+      }
+
+
+      template <int dim>
+      void
+      UniformRadial<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Uniform radial");
+          {
+            prm.declare_entry ("Number of particles", "1000",
+                               Patterns::Double (0.),
+                               "Total number of particles to create (not per processor or per element). "
+                               "The number is parsed as a floating point number (so that one can "
+                               "specify, for example, '1e4' particles) but it is interpreted as "
+                               "an integer, of course.");
+
+            prm.declare_entry ("Center x", "0.",
+                               Patterns::Double (),
+                               "x coordinate for the center of the spherical region, "
+                               "where particles are generated.");
+            prm.declare_entry ("Center y", "0.",
+                               Patterns::Double (),
+                               "y coordinate for the center of the spherical region, "
+                               "where particles are generated.");
+            prm.declare_entry ("Center z", "0.",
+                               Patterns::Double (),
+                               "z coordinate for the center of the spherical region, "
+                               "where particles are generated.");
+            prm.declare_entry ("Minimum radius", "0.",
+                               Patterns::Double (0.),
+                               "Minimum radial coordinate for the region of particles. "
+                               "Measured from the center position.");
+            prm.declare_entry ("Maximum radius", "1.",
+                               Patterns::Double (),
+                               "Maximum radial coordinate for the region of particles. "
+                               "Measured from the center position.");
+            prm.declare_entry ("Minimum longitude", "0.",
+                               Patterns::Double (-180., 360.),
+                               "Minimum longitude coordinate for the region of particles "
+                               "in degrees. Measured from the center position.");
+            prm.declare_entry ("Maximum longitude", "360.",
+                               Patterns::Double (-180., 360.),
+                               "Maximum longitude coordinate for the region of particles "
+                               "in degrees. Measured from the center position.");
+            prm.declare_entry ("Minimum latitude", "0.",
+                               Patterns::Double (0., 180.),
+                               "Minimum latitude coordinate for the region of particles "
+                               "in degrees. Measured from the center position, and from "
+                               "the north pole.");
+            prm.declare_entry ("Maximum latitude", "180.",
+                               Patterns::Double (0., 180.),
+                               "Maximum latitude coordinate for the region of particles "
+                               "in degrees. Measured from the center position, and from "
+                               "the north pole.");
+            prm.declare_entry ("Radial layers", "1",
+                               Patterns::Integer(1),
+                               "The number of radial shells of particles that will be generated "
+                               "around the central point.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      UniformRadial<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Generator");
+        {
+          prm.enter_subsection("Uniform radial");
+          {
+            n_particles    = static_cast<types::particle_index>(prm.get_double ("Number of particles"));
+
+            P_center[0] = prm.get_double ("Center x");
+            P_center[1] = prm.get_double ("Center y");
+
+            P_min[0] = prm.get_double ("Minimum radius");
+            P_max[0] = prm.get_double ("Maximum radius");
+            P_min[1] = prm.get_double ("Minimum longitude") * constants::degree_to_radians;
+            P_max[1] = prm.get_double ("Maximum longitude") * constants::degree_to_radians;
+
+            AssertThrow(P_max[1] > P_min[1],
+                        ExcMessage("The maximum longitude you prescribed in the uniform radial"
+                                   "particle generator has to be higher than the minimum longitude."));
+            AssertThrow(P_max[1] - P_min[1] <= 2.0 * numbers::PI,
+                        ExcMessage("The difference between the maximum and minimum longitude you "
+                                   "prescribed in the uniform radial particle generator has to be "
+                                   "less than 360 degrees."));
+
+            if (dim ==3)
+              {
+                P_center[2] = prm.get_double ("Center z");
+
+                P_min[2]    = prm.get_double ("Minimum latitude") * constants::degree_to_radians;
+                P_max[2]    = prm.get_double ("Maximum latitude") * constants::degree_to_radians;
+
+                AssertThrow(P_max[2] > P_min[2],
+                            ExcMessage("The maximum latitude you prescribed in the uniform radial"
+                                       "particle generator has to be higher than the minimum latitude."));
+              }
+
+            radial_layers   = prm.get_integer("Radial layers");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Generator
+    {
+      ASPECT_REGISTER_PARTICLE_GENERATOR(UniformRadial,
+                                         "uniform radial",
+                                         "Generate a uniform distribution of particles "
+                                         "over a spherical domain in 2d or 3d. Uniform here means "
+                                         "the particles will be generated with an equal spacing in "
+                                         "each spherical spatial dimension, i.e., the particles are "
+                                         "created at positions that increase linearly with equal "
+                                         "spacing in radius, colatitude and longitude around a "
+                                         "certain center point. Note that in order "
+                                         "to produce a regular distribution the number of generated "
+                                         "particles might not exactly match the one specified in the "
+                                         "input file.")
+    }
+  }
+}
diff --git a/source/particle/integrator/euler.cc.bak b/source/particle/integrator/euler.cc.bak
new file mode 100644
index 00000000000..791d7e095df
--- /dev/null
+++ b/source/particle/integrator/euler.cc.bak
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/integrator/euler.h>
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      template <int dim>
+      void
+      Euler<dim>::local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                                       const typename ParticleHandler<dim>::particle_iterator &end_particle,
+                                       const std::vector<Tensor<1,dim>> &old_velocities,
+                                       const std::vector<Tensor<1,dim>> &,
+                                       const double dt)
+      {
+        Assert(static_cast<unsigned int> (std::distance(begin_particle, end_particle)) == old_velocities.size(),
+               ExcMessage("The particle integrator expects the velocity vector to be of equal size "
+                          "to the number of particles to advect. For some unknown reason they are different, "
+                          "most likely something went wrong in the calling function."));
+
+        const auto cell = begin_particle->get_surrounding_cell();
+        bool at_periodic_boundary = false;
+        if (this->get_triangulation().get_periodic_face_map().empty() == false)
+          for (const auto face_index: cell->face_indices())
+            if (cell->at_boundary(face_index))
+              if (cell->has_periodic_neighbor(face_index))
+                {
+                  at_periodic_boundary = true;
+                  break;
+                }
+
+        typename std::vector<Tensor<1,dim>>::const_iterator old_velocity = old_velocities.begin();
+
+        for (typename ParticleHandler<dim>::particle_iterator it = begin_particle;
+             it != end_particle; ++it, ++old_velocity)
+          {
+#if DEAL_II_VERSION_GTE(9, 6, 0)
+            // Get a reference to the particle location, so that we can update it in-place
+            Point<dim> &location = it->get_location();
+#else
+            Point<dim> location = it->get_location();
+#endif
+            location += dt * (*old_velocity);
+
+            if (at_periodic_boundary)
+              this->get_geometry_model().adjust_positions_for_periodicity(location);
+
+#if !DEAL_II_VERSION_GTE(9, 6, 0)
+            it->set_location(location);
+#endif
+          }
+      }
+
+
+
+      template <int dim>
+      std::array<bool, 3>
+      Euler<dim>::required_solution_vectors() const
+      {
+        return {{false, true, false}};
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      ASPECT_REGISTER_PARTICLE_INTEGRATOR(Euler,
+                                          "euler",
+                                          "Explicit Euler scheme integrator, where "
+                                          "$y_{n+1} = y_n + \\Delta t \\, v(y_n)$. "
+                                          "This requires only one integration substep per timestep.")
+    }
+  }
+}
diff --git a/source/particle/integrator/interface.cc.bak b/source/particle/integrator/interface.cc.bak
new file mode 100644
index 00000000000..88a8342876f
--- /dev/null
+++ b/source/particle/integrator/interface.cc.bak
@@ -0,0 +1,248 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/integrator/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <tuple>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      template <int dim>
+      bool
+      Interface<dim>::new_integration_step()
+      {
+        return false;
+      }
+
+
+
+      template <int dim>
+      std::size_t
+      Interface<dim>::get_data_size() const
+      {
+        return 0;
+      }
+
+
+
+      template <int dim>
+      const void *
+      Interface<dim>::read_data(const typename ParticleHandler<dim>::particle_iterator &/*particle*/,
+                                const void *data)
+      {
+        return data;
+      }
+
+
+
+      template <int dim>
+      void *
+      Interface<dim>::write_data(const typename ParticleHandler<dim>::particle_iterator &/*particle*/,
+                                 void *data) const
+      {
+        return data;
+      }
+
+
+
+// -------------------------------- Deal with registering models and automating
+// -------------------------------- their setup and selection at run time
+
+      namespace
+      {
+        std::tuple
+        <void *,
+        void *,
+        aspect::internal::Plugins::PluginList<Interface<2>>,
+        aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+      }
+
+
+
+      template <int dim>
+      void
+      register_particle_integrator (const std::string &name,
+                                    const std::string &description,
+                                    void (*declare_parameters_function) (ParameterHandler &),
+                                    std::unique_ptr<Interface<dim>> (*factory_function) ())
+      {
+        std::get<dim>(registered_plugins).register_plugin (name,
+                                                           description,
+                                                           declare_parameters_function,
+                                                           factory_function);
+      }
+
+
+
+      template <int dim>
+      std::unique_ptr<Interface<dim>>
+      create_particle_integrator (ParameterHandler &prm)
+      {
+        std::string name;
+        name = prm.get ("Integration scheme");
+
+        return std::get<dim>(registered_plugins).create_plugin (name,
+                                                                "Particle::Integrator name");
+      }
+
+
+
+      template <int dim>
+      void
+      declare_parameters (ParameterHandler &prm)
+      {
+        // declare the entry in the parameter file
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry ("Integration scheme", "rk2",
+                           Patterns::Selection (pattern_of_names),
+                           "This parameter is used to decide which method to "
+                           "use to solve the equation that describes the position "
+                           "of particles, i.e., $\\frac{d}{dt}\\mathbf x_k(t) = "
+                           "\\mathbf u(\\mathbf x_k(t),t)$, where $k$ is an index "
+                           "that runs over all particles, and $\\mathbf u(\\mathbf x,t)$ "
+                           "is the velocity field that results from the Stokes "
+                           "equations."
+                           "\n\n"
+                           "In practice, the exact velocity $\\mathbf u(\\mathbf x,t)$ "
+                           "is of course not available, but only a numerical "
+                           "approximation $\\mathbf u_h(\\mathbf x,t)$. Furthermore, "
+                           "this approximation is only available at discrete time steps, "
+                           "$\\mathbf u^n(\\mathbf x)=\\mathbf u(\\mathbf x,t^n)$, and "
+                           "these need to be interpolated between time steps if the "
+                           "integrator for the equation above requires an evaluation at "
+                           "time points between the discrete time steps. If we denote this "
+                           "interpolation in time by $\\tilde{\\mathbf u}_h(\\mathbf x,t)$ "
+                           "where $\\tilde{\\mathbf u}_h(\\mathbf x,t^n)="
+                           "\\mathbf u^n(\\mathbf x)$, then the equation the differential "
+                           "equation solver really tries to solve is "
+                           "$\\frac{d}{dt}\\tilde{\\mathbf x}_k(t) = "
+                           " \\tilde{\\mathbf u}_h(\\mathbf x_k(t),t)$."
+                           "\n\n"
+                           "As a consequence of these considerations, if you try to "
+                           "assess convergence properties of an ODE integrator -- for "
+                           "example to verify that the RK4 integrator converges with "
+                           "fourth order --, it is important to recall that the "
+                           "integrator may not solve the equation you think it "
+                           "solves. If, for example, we call the numerical solution "
+                           "of the ODE $\\tilde{\\mathbf x}_{k,h}(t)$, then the "
+                           "error will typically satisfy a relationship like "
+                           "\\["
+                           "  \\| \\tilde{\\mathbf x}_k(T) - \\tilde{\\mathbf x}_{k,h}(T) \\|"
+                           "  \\le"
+                           "  C(T) \\Delta t^p"
+                           "\\] "
+                           "where $\\Delta t$ is the time step and $p$ the convergence order "
+                           "of the method, and $C(T)$ is a (generally unknown) constant "
+                           "that depends on the end time $T$ at which one compares the "
+                           "solutions. On the other hand, an analytically computed "
+                           "trajectory would likely use the \\textit{exact} velocity, "
+                           "and one may be tempted to compute "
+                           "$\\| \\mathbf x_k(T) - \\tilde{\\mathbf x}_{k,h}(T) \\|$, "
+                           "but this quantity will, in the best case, only satisfy an "
+                           "estimate of the form "
+                           "\\["
+                           "  \\| \\mathbf x_k(T) - \\tilde{\\mathbf x}_{k,h}(T) \\|"
+                           "  \\le"
+                           "  C_1(T) \\Delta t^p"
+                           "  + C_2(T) \\| \\mathbf u-\\mathbf u_h \\|"
+                           "  + C_3(T) \\| \\mathbf u_h-\\tilde{\\mathbf u}_h \\|"
+                           "\\] "
+                           "with appropriately chosen norms for the second and third "
+                           "term. These second and third terms typically converge to "
+                           "zero at relatively low rates (compared to the order $p$ of "
+                           "the integrator, which can often be chosen relatively high) "
+                           "in the mesh size $h$ and the time step size $\\\\Delta t$, "
+                           "limiting the overall accuracy of the ODE integrator."
+                           "\n\n"
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+
+        std::get<dim>(registered_plugins).declare_parameters (prm);
+      }
+
+
+
+      template <int dim>
+      void
+      write_plugin_graph (std::ostream &out)
+      {
+        std::get<dim>(registered_plugins).write_plugin_graph ("Particle integrator interface",
+                                                              out);
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<Particle::Integrator::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<Particle::Integrator::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<Particle::Integrator::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<Particle::Integrator::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace Particle
+  {
+    namespace Integrator
+    {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_particle_integrator<dim> (const std::string &, \
+                                     const std::string &, \
+                                     void ( *) (ParameterHandler &), \
+                                     std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_particle_integrator<dim> (ParameterHandler &prm);
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/source/particle/integrator/rk_2.cc.bak b/source/particle/integrator/rk_2.cc.bak
new file mode 100644
index 00000000000..eec91bde25c
--- /dev/null
+++ b/source/particle/integrator/rk_2.cc.bak
@@ -0,0 +1,242 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/integrator/rk_2.h>
+#include <aspect/particle/property/interface.h>
+#include <aspect/particle/world.h>
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      template <int dim>
+      RK2<dim>::RK2()
+        :
+        integrator_substep(0)
+      {}
+
+
+
+      template <int dim>
+      void
+      RK2<dim>::initialize ()
+      {
+        const auto &property_information = this->get_particle_world(this->get_particle_world_index()).get_property_manager().get_data_info();
+        property_index_old_location = property_information.get_position_by_field_name("internal: integrator properties");
+      }
+
+
+
+      template <int dim>
+      void
+      RK2<dim>::local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                                     const typename ParticleHandler<dim>::particle_iterator &end_particle,
+                                     const std::vector<Tensor<1,dim>> &old_velocities,
+                                     const std::vector<Tensor<1,dim>> &velocities,
+                                     const double dt)
+      {
+        Assert(static_cast<unsigned int> (std::distance(begin_particle, end_particle)) == old_velocities.size(),
+               ExcMessage("The particle integrator expects the old velocity vector to be of equal size "
+                          "to the number of particles to advect. For some unknown reason they are different, "
+                          "most likely something went wrong in the calling function."));
+
+        if (higher_order_in_time == true && integrator_substep == 1)
+          Assert(old_velocities.size() == velocities.size(),
+                 ExcMessage("The particle integrator expects the velocity vector to be of equal size "
+                            "to the number of particles to advect. For some unknown reason they are different, "
+                            "most likely something went wrong in the calling function."));
+
+        const auto cell = begin_particle->get_surrounding_cell();
+        bool at_periodic_boundary = false;
+        if (this->get_triangulation().get_periodic_face_map().empty() == false)
+          for (const auto &face_index: cell->face_indices())
+            if (cell->at_boundary(face_index))
+              if (cell->has_periodic_neighbor(face_index))
+                {
+                  at_periodic_boundary = true;
+                  break;
+                }
+
+        typename std::vector<Tensor<1,dim>>::const_iterator old_velocity = old_velocities.begin();
+        typename std::vector<Tensor<1,dim>>::const_iterator velocity = velocities.begin();
+
+        for (typename ParticleHandler<dim>::particle_iterator it = begin_particle;
+             it != end_particle; ++it, ++velocity, ++old_velocity)
+          {
+            ArrayView<double> properties = it->get_properties();
+
+            if (integrator_substep == 0)
+              {
+                const Tensor<1,dim> k1 = dt * (*old_velocity);
+#if DEAL_II_VERSION_GTE(9, 6, 0)
+                // Get a reference to the particle location, so that we can update it in-place
+                Point<dim> &location = it->get_location();
+#else
+                Point<dim> location = it->get_location();
+#endif
+                Point<dim> new_location = location + 0.5 * k1;
+
+                // Check if we crossed a periodic boundary and if necessary adjust positions
+                if (at_periodic_boundary)
+                  this->get_geometry_model().adjust_positions_for_periodicity(new_location,
+                                                                              ArrayView<Point<dim>>(location));
+
+                for (unsigned int i=0; i<dim; ++i)
+                  {
+                    properties[property_index_old_location + i] = location[i];
+#if DEAL_II_VERSION_GTE(9, 6, 0)
+                    location[i] = new_location[i];
+#endif
+                  }
+#if !DEAL_II_VERSION_GTE(9, 6, 0)
+                it->set_location(new_location);
+#endif
+              }
+            else if (integrator_substep == 1)
+              {
+                const Tensor<1,dim> k2 = (higher_order_in_time == true)
+                                         ?
+                                         dt * (*old_velocity + *velocity) * 0.5
+                                         :
+                                         dt * (*old_velocity);
+
+#if DEAL_II_VERSION_GTE(9, 6, 0)
+                Point<dim> &location = it->get_location();
+#else
+                Point<dim> location = it->get_location();
+#endif
+
+                for (unsigned int i=0; i<dim; ++i)
+                  location[i] = properties[property_index_old_location + i] + k2[i];
+
+                // no need to adjust old location, because this is the last integrator step
+                if (at_periodic_boundary)
+                  this->get_geometry_model().adjust_positions_for_periodicity(location);
+
+#if !DEAL_II_VERSION_GTE(9, 6, 0)
+                it->set_location(location);
+#endif
+              }
+            else
+              {
+                Assert(false,
+                       ExcMessage("The RK2 integrator should never continue after two integration steps."));
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      bool
+      RK2<dim>::new_integration_step()
+      {
+        integrator_substep = (integrator_substep + 1) % 2;
+
+        // Continue until we're at the last step
+        return (integrator_substep != 0);
+      }
+
+
+
+      template <int dim>
+      std::array<bool, 3>
+      RK2<dim>::required_solution_vectors() const
+      {
+        switch (integrator_substep)
+          {
+            case 0:
+              return {{false, true, false}};
+            case 1:
+            {
+              if (higher_order_in_time)
+                return {{false, true, true}};
+              else
+                return {{false, true, false}};
+            }
+            default:
+              Assert(false,
+                     ExcMessage("The RK4 integrator should never continue after four integration steps."));
+
+              return {{false, false, false}};
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      RK2<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Integrator");
+        {
+          prm.enter_subsection("RK2");
+          {
+            prm.declare_entry ("Higher order accurate in time", "true",
+                               Patterns::Bool(),
+                               "Whether to correctly evaluate old and current velocity "
+                               "solution to reach higher-order accuracy in time. If set to "
+                               "'false' only the old velocity solution is evaluated to "
+                               "simulate a first order method in time. This is only "
+                               "recommended for benchmark purposes.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      RK2<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Integrator");
+        {
+          prm.enter_subsection("RK2");
+          {
+            higher_order_in_time = prm.get_bool("Higher order accurate in time");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      ASPECT_REGISTER_PARTICLE_INTEGRATOR(RK2,
+                                          "rk2",
+                                          "Second Order Runge Kutta integrator "
+                                          "$y_{n+1} = y_n + \\Delta t\\, v(t_{n+1/2}, y_{n} + \\frac{1}{2} k_1)$ "
+                                          "where $k_1 = \\Delta t\\, v(t_{n}, y_{n})$")
+    }
+  }
+}
diff --git a/source/particle/integrator/rk_4.cc.bak b/source/particle/integrator/rk_4.cc.bak
new file mode 100644
index 00000000000..e94b454783f
--- /dev/null
+++ b/source/particle/integrator/rk_4.cc.bak
@@ -0,0 +1,281 @@
+/*
+  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/integrator/rk_4.h>
+#include <aspect/particle/property/interface.h>
+#include <aspect/particle/world.h>
+#include <aspect/geometry_model/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      template <int dim>
+      RK4<dim>::RK4()
+        :
+        integrator_substep(0)
+      {}
+
+
+
+      template <int dim>
+      void
+      RK4<dim>::initialize ()
+      {
+        const auto &property_information = this->get_particle_world(this->get_particle_world_index()).get_property_manager().get_data_info();
+
+        property_indices[0] = property_information.get_position_by_field_name("internal: integrator properties");
+        property_indices[1] = property_indices[0] + dim;
+        property_indices[2] = property_indices[1] + dim;
+        property_indices[3] = property_indices[2] + dim;
+      }
+
+
+
+      template <int dim>
+      void
+      RK4<dim>::local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                                     const typename ParticleHandler<dim>::particle_iterator &end_particle,
+                                     const std::vector<Tensor<1,dim>> &old_velocities,
+                                     const std::vector<Tensor<1,dim>> &velocities,
+                                     const double dt)
+      {
+        if (integrator_substep < 3)
+          {
+            Assert(static_cast<unsigned int> (std::distance(begin_particle, end_particle)) == old_velocities.size(),
+                   ExcMessage("The particle integrator expects the old velocity vector to be of equal size "
+                              "to the number of particles to advect. For some unknown reason they are different, "
+                              "most likely something went wrong in the calling function."));
+          }
+
+        if (integrator_substep >= 1 && integrator_substep < 4)
+          {
+            Assert(static_cast<unsigned int> (std::distance(begin_particle, end_particle)) == velocities.size(),
+                   ExcMessage("The particle integrator expects the velocity vector to be of equal size "
+                              "to the number of particles to advect. For some unknown reason they are different, "
+                              "most likely something went wrong in the calling function."));
+          }
+
+        const auto cell = begin_particle->get_surrounding_cell();
+        bool at_periodic_boundary = false;
+        if (this->get_triangulation().get_periodic_face_map().empty() == false)
+          for (const auto &face_index: cell->face_indices())
+            if (cell->at_boundary(face_index))
+              if (cell->has_periodic_neighbor(face_index))
+                {
+                  at_periodic_boundary = true;
+                  break;
+                }
+
+        typename std::vector<Tensor<1,dim>>::const_iterator old_velocity = old_velocities.begin();
+        typename std::vector<Tensor<1,dim>>::const_iterator velocity = velocities.begin();
+
+        std::array<Tensor<1,dim>,4> k;
+        for (typename ParticleHandler<dim>::particle_iterator it = begin_particle;
+             it != end_particle; ++it, ++velocity, ++old_velocity)
+          {
+            ArrayView<double> properties = it->get_properties();
+
+            if (integrator_substep == 0)
+              {
+#if DEAL_II_VERSION_GTE(9, 6, 0)
+                // Get a reference to the particle location, so that we can update it in-place
+                Point<dim> &location = it->get_location();
+#else
+                Point<dim> location = it->get_location();
+#endif
+                k[0] = dt * (*old_velocity);
+
+                Point<dim> new_location = location + 0.5 * k[0];
+
+                // Check if we crossed a periodic boundary and if necessary adjust positions
+                if (at_periodic_boundary)
+                  this->get_geometry_model().adjust_positions_for_periodicity(new_location,
+                                                                              ArrayView<Point<dim>>(&location,1),
+                                                                              ArrayView<Tensor<1,dim>>(&k[0],1));
+
+                for (unsigned int i=0; i<dim; ++i)
+                  {
+                    properties[property_indices[0] + i] = location[i];
+                    properties[property_indices[1] + i] = k[0][i];
+#if DEAL_II_VERSION_GTE(9, 6, 0)
+                    location[i] = new_location[i];
+#endif
+                  }
+
+#if !DEAL_II_VERSION_GTE(9, 6, 0)
+                it->set_location(new_location);
+#endif
+              }
+            else if (integrator_substep == 1)
+              {
+                k[1] = dt * ((*old_velocity) + (*velocity)) * 0.5;
+
+                Point<dim> old_location;
+                for (unsigned int i=0; i<dim; ++i)
+                  old_location[i] = properties[property_indices[0] + i];
+
+                Point<dim> new_location = old_location + 0.5 * k[1];
+
+                if (at_periodic_boundary)
+                  {
+                    for (unsigned int i=0; i<dim; ++i)
+                      k[0][i] = properties[property_indices[1] + i];
+
+                    this->get_geometry_model().adjust_positions_for_periodicity(new_location,
+                                                                                ArrayView<Point<dim>>(&old_location,1),
+                                                                                ArrayView<Tensor<1,dim>>(&k[0],2));
+
+                    for (unsigned int i=0; i<dim; ++i)
+                      {
+                        properties[property_indices[0] + i] = old_location[i];
+                        properties[property_indices[1] + i] = k[0][i];
+                        // k[1] will always be set below
+                      }
+                  }
+
+                for (unsigned int i=0; i<dim; ++i)
+                  properties[property_indices[2] + i] = k[1][i];
+
+                it->set_location(new_location);
+              }
+            else if (integrator_substep == 2)
+              {
+                k[2] = dt * (*old_velocity + *velocity) * 0.5;
+
+                Point<dim> old_location;
+                for (unsigned int i=0; i<dim; ++i)
+                  old_location[i] = properties[property_indices[0] + i];
+
+                Point<dim> new_location = old_location + k[2];
+
+                if (at_periodic_boundary)
+                  {
+                    for (unsigned int i=0; i<dim; ++i)
+                      {
+                        k[0][i] = properties[property_indices[1] + i];
+                        k[1][i] = properties[property_indices[2] + i];
+                      }
+
+                    this->get_geometry_model().adjust_positions_for_periodicity(new_location,
+                                                                                ArrayView<Point<dim>>(&old_location,1),
+                                                                                ArrayView<Tensor<1,dim>>(&k[0],3));
+
+                    for (unsigned int i=0; i<dim; ++i)
+                      {
+                        properties[property_indices[0] + i] = old_location[i];
+                        properties[property_indices[1] + i] = k[0][i];
+                        properties[property_indices[2] + i] = k[1][i];
+                      }
+                  }
+
+                for (unsigned int i=0; i<dim; ++i)
+                  properties[property_indices[3] + i] = k[2][i];
+
+                it->set_location(new_location);
+              }
+            else if (integrator_substep == 3)
+              {
+                k[3] = dt * (*velocity);
+
+                Point<dim> old_location;
+                for (unsigned int i=0; i<dim; ++i)
+                  old_location[i] = properties[property_indices[0] + i];
+
+                for (unsigned int i=0; i<dim; ++i)
+                  {
+                    k[0][i] = properties[property_indices[1] + i];
+                    k[1][i] = properties[property_indices[2] + i];
+                    k[2][i] = properties[property_indices[3] + i];
+                  }
+
+                Point<dim> new_location = old_location + (k[0] + 2.0*k[1] + 2.0*k[2] + k[3])/6.0;
+
+                // No need to fix intermediate values, this is the last integrator step
+                if (at_periodic_boundary)
+                  this->get_geometry_model().adjust_positions_for_periodicity(new_location);
+
+                it->set_location(new_location);
+              }
+            else
+              {
+                Assert(false,
+                       ExcMessage("The RK4 integrator should never continue after four integration stages."));
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      bool
+      RK4<dim>::new_integration_step()
+      {
+        integrator_substep = (integrator_substep+1)%4;
+
+        // Continue until we're at the last step
+        return (integrator_substep != 0);
+      }
+
+
+      template <int dim>
+      std::array<bool, 3>
+      RK4<dim>::required_solution_vectors() const
+      {
+        switch (integrator_substep)
+          {
+            case 0:
+              return {{false, true, false}};
+            case 1:
+              return {{false, true, true}};
+            case 2:
+              return {{false, true, true}};
+            case 3:
+              return {{false, false, true}};
+            default:
+              Assert(false,
+                     ExcMessage("The RK4 integrator should never continue after four integration steps."));
+          }
+
+        return {{false, false, false}};
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Integrator
+    {
+      ASPECT_REGISTER_PARTICLE_INTEGRATOR(RK4,
+                                          "rk4",
+                                          "Runge Kutta fourth order integrator, where "
+                                          "$y_{n+1} = y_n + \\frac{1}{6} k_1 + \\frac{1}{3} k_2 "
+                                          "+ \\frac{1}{3} k_3 + \\frac{1}{6} k_4$ "
+                                          "and $k_1$, $k_2$, $k_3$, $k_4$ are defined as usual.")
+    }
+  }
+}
diff --git a/source/particle/interface.cc.bak b/source/particle/interface.cc.bak
new file mode 100644
index 00000000000..659e348739c
--- /dev/null
+++ b/source/particle/interface.cc.bak
@@ -0,0 +1,42 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/interface.h>
+
+
+namespace aspect
+{
+  namespace Particle
+  {
+    void
+    ParticleInterfaceBase::set_particle_world_index(const unsigned int particle_world_index)
+    {
+      this->particle_world_index = particle_world_index;
+    }
+
+
+
+    unsigned int
+    ParticleInterfaceBase::get_particle_world_index() const
+    {
+      return particle_world_index;
+    }
+  }
+}
diff --git a/source/particle/interpolator/bilinear_least_squares.cc.bak b/source/particle/interpolator/bilinear_least_squares.cc.bak
new file mode 100644
index 00000000000..da2fc320bce
--- /dev/null
+++ b/source/particle/interpolator/bilinear_least_squares.cc.bak
@@ -0,0 +1,364 @@
+/*
+  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/interpolator/bilinear_least_squares.h>
+#include <aspect/particle/world.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/lac/qr.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      template <int dim>
+      std::vector<std::vector<double>>
+      BilinearLeastSquares<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
+                                                      const std::vector<Point<dim>> &positions,
+                                                      const ComponentMask &selected_properties,
+                                                      const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
+      {
+        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
+        const unsigned int property_index = selected_properties.first_selected_component(selected_properties.size());
+
+        AssertThrow(property_index != numbers::invalid_unsigned_int,
+                    ExcMessage("Internal error: the particle property interpolator was "
+                               "called without a specified component to interpolate."));
+
+        const typename ParticleHandler<dim>::particle_iterator_range particle_range =
+          particle_handler.particles_in_cell(cell);
+
+        std::vector<std::vector<double>> cell_properties(positions.size(),
+                                                          std::vector<double>(n_particle_properties,
+                                                                              numbers::signaling_nan<double>()));
+
+        const unsigned int n_particles = std::distance(particle_range.begin(), particle_range.end());
+        const unsigned int n_matrix_columns = (dim == 2) ? 3 : 4;
+
+        // If there are too few particles, we can not perform a least squares interpolation
+        // fall back to a simpler method instead.
+        if (n_particles < n_matrix_columns)
+          return fallback_interpolator.properties_at_points(particle_handler,
+                                                            positions,
+                                                            selected_properties,
+                                                            cell);
+
+        // Noticed that the size of matrix A is n_particles x n_matrix_columns
+        // which usually is not a square matrix. Therefore, we find the
+        // least squares solution of Ac=r by solving the reduced QR factorization
+        // Ac = QRc = b -> Q^TQRc = Rc =Q^Tb
+        // A is a std::vector of Vectors(which are it's columns) so that we
+        // create what the ImplicitQR class needs.
+        std::vector<Vector<double>> A(n_matrix_columns, Vector<double>(n_particles));
+        std::vector<Vector<double>> b(n_particle_properties, Vector<double>(n_particles));
+
+        unsigned int particle_index = 0;
+        // The unit cell of deal.II is [0,1]^dim. The limiter needs a 'unit' cell of [-.5,.5]^dim.
+        const double unit_offset = 0.5;
+        std::vector<double> property_minimums(n_particle_properties, std::numeric_limits<double>::max());
+        std::vector<double> property_maximums(n_particle_properties, std::numeric_limits<double>::lowest());
+        for (typename ParticleHandler<dim>::particle_iterator particle = particle_range.begin();
+             particle != particle_range.end(); ++particle, ++particle_index)
+          {
+            const ArrayView<double> particle_property_value = particle->get_properties();
+            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+              {
+                if (selected_properties[property_index] == true)
+                  {
+                    b[property_index][particle_index] = particle_property_value[property_index];
+                    if (use_linear_least_squares_limiter[property_index] == true)
+                      {
+                        property_minimums[property_index] = std::min(property_minimums[property_index], particle_property_value[property_index]);
+                        property_maximums[property_index] = std::max(property_maximums[property_index], particle_property_value[property_index]);
+                      }
+                  }
+              }
+            Point<dim> relative_particle_position = particle->get_reference_location();
+
+            // A is accessed by A[column][row] here since we will need to append
+            // columns into the qr matrix
+            A[0][particle_index] = 1;
+            for (unsigned int i = 1; i < n_matrix_columns; ++i)
+              {
+                relative_particle_position[i - 1] -= unit_offset;
+                A[i][particle_index] = relative_particle_position[i - 1];
+              }
+          }
+
+        // If the limiter is enabled for at least one property then we know that we can access ghost cell
+        // particles to determine the bounds of the properties on the mode (due to the assert of
+        // 'Exchange ghost particles' in parse_parameters). Otherwise we do not need to access those particles
+        if (use_linear_least_squares_limiter.n_selected_components() != 0)
+          {
+            std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> active_neighbors;
+            GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell, active_neighbors);
+            for (const auto &active_neighbor : active_neighbors)
+              {
+                if (active_neighbor->is_artificial())
+                  continue;
+                const std::vector<double> neighbor_cell_average = fallback_interpolator.properties_at_points(particle_handler, positions, selected_properties, active_neighbor)[0];
+                for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+                  {
+                    if (selected_properties[property_index] == true && use_linear_least_squares_limiter[property_index] == true)
+                      {
+                        property_minimums[property_index] = std::min(property_minimums[property_index], neighbor_cell_average[property_index]);
+                        property_maximums[property_index] = std::max(property_maximums[property_index], neighbor_cell_average[property_index]);
+                      }
+                  }
+              }
+            if (cell->at_boundary())
+              {
+                const std::vector<double> cell_average_values = fallback_interpolator.properties_at_points(particle_handler, {positions[0]}, selected_properties, cell)[0];
+                for (unsigned int face_id = 0; face_id < cell->reference_cell().n_faces(); ++face_id)
+                  {
+                    if (cell->at_boundary(face_id))
+                      {
+                        const unsigned int opposing_face_id = GeometryInfo<dim>::opposite_face[face_id];
+                        const auto &opposing_cell = cell->neighbor(opposing_face_id);
+                        if (opposing_cell.state() == IteratorState::IteratorStates::valid && opposing_cell->is_active() && opposing_cell->is_artificial() == false)
+                          {
+                            const auto neighbor_cell_average = fallback_interpolator.properties_at_points(particle_handler, {positions[0]}, selected_properties, opposing_cell)[0];
+                            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+                              {
+                                if (selected_properties[property_index] == true && use_boundary_extrapolation[property_index] == true)
+                                  {
+                                    Assert(cell->reference_cell().is_hyper_cube() == true, ExcNotImplemented());
+                                    const double expected_boundary_value = 1.5 * cell_average_values[property_index] - 0.5 * neighbor_cell_average[property_index];
+                                    property_minimums[property_index] = std::min(property_minimums[property_index], expected_boundary_value);
+                                    property_maximums[property_index] = std::max(property_maximums[property_index], expected_boundary_value);
+                                  }
+                              }
+                          }
+                      }
+                  }
+              }
+          }
+
+        ImplicitQR<Vector<double>> qr;
+        for (const auto &column : A)
+          qr.append_column(column);
+        // If A is rank deficent then qr.append_column will not append
+        // the first column that can be written as a linear combination of
+        // other columns. We check that all columns were added or we
+        // rely on the fallback interpolator
+        if (qr.size() != n_matrix_columns)
+          return fallback_interpolator.properties_at_points(particle_handler,
+                                                            positions,
+                                                            selected_properties,
+                                                            cell);
+
+        std::vector<Vector<double>> QTb(n_particle_properties, Vector<double>(n_matrix_columns));
+        std::vector<Vector<double>> c(n_particle_properties, Vector<double>(n_matrix_columns));
+        for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+          {
+            if (selected_properties[property_index] == true)
+              {
+                qr.multiply_with_QT(QTb[property_index], b[property_index]);
+                qr.solve(c[property_index], QTb[property_index]);
+              }
+          }
+        const double half_h = .5;
+        for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+          {
+            if (selected_properties[property_index] == true)
+              {
+                if (use_linear_least_squares_limiter[property_index] == true)
+                  {
+                    c[property_index][0] = std::max(c[property_index][0], property_minimums[property_index]);
+                    c[property_index][0] = std::min(c[property_index][0], property_maximums[property_index]);
+
+                    const double max_total_slope = std::min(c[property_index][0] - property_minimums[property_index],
+                                                            property_maximums[property_index] - c[property_index][0])
+                                                   / half_h;
+                    double current_total_slope = 0.0;
+                    for (unsigned int i = 1; i < n_matrix_columns; ++i)
+                      {
+                        current_total_slope += std::abs(c[property_index][i]);
+                      }
+
+                    if (current_total_slope > max_total_slope && current_total_slope > std::numeric_limits<double>::min())
+                      {
+                        double slope_change_ratio = max_total_slope/current_total_slope;
+                        for (unsigned int i = 1; i < n_matrix_columns; ++i)
+                          c[property_index][i] *= slope_change_ratio;
+                      }
+                  }
+                std::size_t positions_index = 0;
+                for (typename std::vector<Point<dim>>::const_iterator itr = positions.begin(); itr != positions.end(); ++itr, ++positions_index)
+                  {
+                    Point<dim> relative_support_point_location = this->get_mapping().transform_real_to_unit_cell(cell, *itr);
+                    double interpolated_value = c[property_index][0];
+                    for (unsigned int i = 1; i < n_matrix_columns; ++i)
+                      {
+                        relative_support_point_location[i - 1] -= unit_offset;
+                        interpolated_value += c[property_index][i] * relative_support_point_location[i - 1];
+                      }
+                    if (use_linear_least_squares_limiter[property_index] == true)
+                      {
+                        // Assert that the limiter was reasonably effective. We can not expect perfect accuracy
+                        // due to inaccuracies e.g. in the inversion of the mapping.
+                        const double tolerance = std::sqrt(std::numeric_limits<double>::epsilon())
+                                                 * std::max(std::abs(property_minimums[property_index]),
+                                                            std::abs(property_maximums[property_index]));
+                        (void) tolerance;
+                        Assert(interpolated_value >= property_minimums[property_index] - tolerance,
+                               ExcMessage("The particle interpolation limiter did not succeed. Interpolated value: " + std::to_string(interpolated_value)
+                                          + " is smaller than the minimum particle property value: " + std::to_string(property_minimums[property_index]) + "."));
+                        Assert(interpolated_value <= property_maximums[property_index] + tolerance,
+                               ExcMessage("The particle interpolation limiter did not succeed. Interpolated value: " + std::to_string(interpolated_value)
+                                          + " is larger than the maximum particle property value: " + std::to_string(property_maximums[property_index]) + "."));
+
+                        interpolated_value = std::min(interpolated_value, property_maximums[property_index]);
+                        interpolated_value = std::max(interpolated_value, property_minimums[property_index]);
+                      }
+                    cell_properties[positions_index][property_index] = interpolated_value;
+                  }
+
+              }
+          }
+        return cell_properties;
+      }
+
+
+
+      template <int dim>
+      void
+      BilinearLeastSquares<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Interpolator");
+        {
+          prm.enter_subsection("Bilinear least squares");
+          {
+            prm.declare_entry("Use linear least squares limiter", "false",
+                              Patterns::List(Patterns::Bool()),
+                              "Limit the interpolation of particle properties onto the cell, so that "
+                              "the value of each property is no smaller than its minimum and no "
+                              "larger than its maximum on the particles of each cell, and the "
+                              "average of neighboring cells. If more than one value is given, "
+                              "it will be treated as a list with one component per particle property.");
+            prm.declare_entry("Use boundary extrapolation", "false",
+                              Patterns::List(Patterns::Bool()),
+                              "Extends the range used by 'Use linear least squares limiter' "
+                              "by linearly interpolating values at cell boundaries from neighboring "
+                              "cells. If more than one value is given, it will be treated as a list "
+                              "with one component per particle property. Enabling 'Use boundary "
+                              "extrapolation' requires enabling 'Use linear least squares "
+                              "limiter'.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      BilinearLeastSquares<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        fallback_interpolator.parse_parameters(prm);
+        prm.enter_subsection("Interpolator");
+        {
+          prm.enter_subsection("Bilinear least squares");
+          {
+            const auto &particle_property_information = this->get_particle_world(this->get_particle_world_index()).get_property_manager().get_data_info();
+            const unsigned int n_property_components = particle_property_information.n_components();
+            const unsigned int n_internal_components = particle_property_information.get_components_by_field_name("internal: integrator properties");
+
+            std::vector<std::string> linear_least_squares_limiter_split = Utilities::split_string_list(prm.get("Use linear least squares limiter"));
+            std::vector<bool> linear_least_squares_limiter_parsed;
+            if (linear_least_squares_limiter_split.size() == 1)
+              {
+                linear_least_squares_limiter_parsed = std::vector<bool>(n_property_components - n_internal_components, Utilities::string_to_bool(linear_least_squares_limiter_split[0]));
+              }
+            else if (linear_least_squares_limiter_split.size() == n_property_components - n_internal_components)
+              {
+                for (const auto &component: linear_least_squares_limiter_split)
+                  linear_least_squares_limiter_parsed.push_back(Utilities::string_to_bool(component));
+              }
+            else
+              {
+                AssertThrow(false, ExcMessage("The size of 'Use linear least squares limiter' should either be 1 or the number of particle properties"));
+              }
+            for (unsigned int i = 0; i < n_internal_components; ++i)
+              linear_least_squares_limiter_parsed.push_back(false);
+            use_linear_least_squares_limiter = ComponentMask(linear_least_squares_limiter_parsed);
+
+
+
+            const std::vector<std::string> boundary_extrapolation_split = Utilities::split_string_list(prm.get("Use boundary extrapolation"));
+            std::vector<bool> boundary_extrapolation_parsed;
+            if (boundary_extrapolation_split.size() == 1)
+              {
+                boundary_extrapolation_parsed = std::vector<bool>(n_property_components - n_internal_components, Utilities::string_to_bool(boundary_extrapolation_split[0]));
+              }
+            else if (boundary_extrapolation_split.size() == n_property_components - n_internal_components)
+              {
+                for (const auto &component: boundary_extrapolation_split)
+                  boundary_extrapolation_parsed.push_back(Utilities::string_to_bool(component));
+              }
+            else
+              {
+                AssertThrow(false, ExcMessage("The size of 'Use boundary extrapolation' should either be 1 or the number of particle properties"));
+              }
+            for (unsigned int i = 0; i < n_internal_components; ++i)
+              boundary_extrapolation_parsed.push_back(false);
+            use_boundary_extrapolation = ComponentMask(boundary_extrapolation_parsed);
+            for (unsigned int property_index = 0; property_index < n_property_components - n_internal_components; ++property_index)
+              {
+                AssertThrow(use_linear_least_squares_limiter[property_index] || !use_boundary_extrapolation[property_index],
+                            ExcMessage("'Use boundary extrapolation' must be set with 'Use linear least squares limiter' to be valid."));
+              }
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+        const bool limiter_enabled_for_at_least_one_property = (use_linear_least_squares_limiter.n_selected_components() != 0);
+        AssertThrow(limiter_enabled_for_at_least_one_property == false || prm.get_bool("Update ghost particles") == true,
+                    ExcMessage("If 'Use linear least squares limiter' is enabled for any particle property, then 'Update ghost particles' must be set to true"));
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(BilinearLeastSquares,
+                                            "bilinear least squares",
+                                            "Uses linear least squares to obtain the slopes and center of a 2d or "
+                                            "3d plane from the particle positions and a particular property value "
+                                            "on those particles. "
+                                            "Interpolate this property onto a vector of points. If the limiter is "
+                                            "enabled then it will ensure the interpolated properties do not exceed the "
+                                            "range of the minimum and maximum of the values of the property on the "
+                                            "particles. Note that deal.II must be configured with BLAS and LAPACK to "
+                                            "support this operation.")
+    }
+  }
+}
diff --git a/source/particle/interpolator/cell_average.cc.bak b/source/particle/interpolator/cell_average.cc.bak
new file mode 100644
index 00000000000..1a7f4ddfc35
--- /dev/null
+++ b/source/particle/interpolator/cell_average.cc.bak
@@ -0,0 +1,161 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/interpolator/cell_average.h>
+
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      template <int dim>
+      std::vector<std::vector<double>>
+      CellAverage<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
+                                             const std::vector<Point<dim>> &positions,
+                                             const ComponentMask &selected_properties,
+                                             const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
+      {
+        const typename ParticleHandler<dim>::particle_iterator_range particle_range =
+          particle_handler.particles_in_cell(cell);
+
+        const unsigned int n_particles = std::distance(particle_range.begin(),particle_range.end());
+        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
+
+        std::vector<double> cell_properties (n_particle_properties,numbers::signaling_nan<double>());
+
+        for (unsigned int i = 0; i < n_particle_properties; ++i)
+          if (selected_properties[i])
+            cell_properties[i] = 0.0;
+
+        if (n_particles > 0)
+          {
+            for (const auto &particle : particle_range)
+              {
+                const ArrayView<const double> &particle_properties = particle.get_properties();
+
+                for (unsigned int i = 0; i < particle_properties.size(); ++i)
+                  if (selected_properties[i])
+                    cell_properties[i] += particle_properties[i];
+              }
+
+            for (unsigned int i = 0; i < n_particle_properties; ++i)
+              if (selected_properties[i])
+                cell_properties[i] /= n_particles;
+          }
+        // If there are no particles in this cell use the average of the
+        // neighboring cells.
+        else
+          {
+            std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> neighbors;
+            GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell,neighbors);
+
+            unsigned int non_empty_neighbors = 0;
+            for (unsigned int i=0; i<neighbors.size(); ++i)
+              {
+                // Only recursively evaluate with cells whose particles can be accessed safely.
+                if (!neighbors[i]->is_locally_owned())
+                  continue;
+                // Only recursively call this function if the neighbor cell contains
+                // particles (else we end up in an endless recursion)
+                if (particle_handler.n_particles_in_cell(neighbors[i]) == 0)
+                  continue;
+
+                const std::vector<double> neighbor_properties = properties_at_points(particle_handler,
+                                                                                     std::vector<Point<dim>> (1,neighbors[i]->center(true,false)),
+                                                                                     selected_properties,
+                                                                                     neighbors[i])[0];
+
+                for (unsigned int i = 0; i < n_particle_properties; ++i)
+                  if (selected_properties[i])
+                    cell_properties[i] += neighbor_properties[i];
+
+                ++non_empty_neighbors;
+              }
+
+            if (!allow_cells_without_particles)
+              {
+                AssertThrow(non_empty_neighbors != 0,
+                            ExcMessage("A cell and all of its neighbors do not contain any particles. "
+                                       "The `cell average' interpolation scheme does not support this case unless specified "
+                                       "in Allow cells without particles."));
+              }
+
+            for (unsigned int i = 0; i < n_particle_properties; ++i)
+              {
+                if (selected_properties[i] && non_empty_neighbors != 0)
+                  cell_properties[i] /= non_empty_neighbors;
+                // Assume property is zero for any areas with no particles
+                else if (allow_cells_without_particles && non_empty_neighbors == 0)
+                  cell_properties[i] = 0;
+              }
+
+          }
+
+        return std::vector<std::vector<double>> (positions.size(),cell_properties);
+      }
+
+
+
+      template <int dim>
+      void
+      CellAverage<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Allow cells without particles", "false",
+                           Patterns::Bool (),
+                           "By default, every cell needs to contain particles to use this interpolator "
+                           "plugin. If this parameter is set to true, cells are allowed to have no particles, "
+                           "In case both the current cell and its neighbors are empty, "
+                           "the interpolator will return 0 for the current cell's properties.");
+      }
+
+
+
+      template <int dim>
+      void
+      CellAverage<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        allow_cells_without_particles = prm.get_bool("Allow cells without particles");
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(CellAverage,
+                                            "cell average",
+                                            "Return the arithmetic average of all particle properties in the given cell, "
+                                            "or in the neighboring cells if the given cell is empty. "
+                                            "In case the neighboring cells are also empty, and 'Allow cells "
+                                            "without particles' is set to true, the interpolator returns 0. "
+                                            "Otherwise, an exception is thrown. ")
+    }
+  }
+}
diff --git a/source/particle/interpolator/harmonic_average.cc.bak b/source/particle/interpolator/harmonic_average.cc.bak
new file mode 100644
index 00000000000..6ae071041e3
--- /dev/null
+++ b/source/particle/interpolator/harmonic_average.cc.bak
@@ -0,0 +1,169 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/interpolator/harmonic_average.h>
+
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      template <int dim>
+      std::vector<std::vector<double>>
+      HarmonicAverage<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
+                                                 const std::vector<Point<dim>> &positions,
+                                                 const ComponentMask &selected_properties,
+                                                 const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
+      {
+        const typename ParticleHandler<dim>::particle_iterator_range particle_range =
+          particle_handler.particles_in_cell(cell);
+
+        const unsigned int n_particles = std::distance(particle_range.begin(),particle_range.end());
+        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
+
+        std::vector<double> cell_properties (n_particle_properties,numbers::signaling_nan<double>());
+
+        for (unsigned int i = 0; i < n_particle_properties; ++i)
+          if (selected_properties[i])
+            cell_properties[i] = 0.0;
+
+        if (n_particles > 0)
+          {
+            for (const auto &particle : particle_range)
+              {
+                const ArrayView<const double> &particle_properties = particle.get_properties();
+
+                for (unsigned int i = 0; i < particle_properties.size(); ++i)
+                  if (selected_properties[i])
+                    {
+                      AssertThrow(particle_properties[i] > 0,
+                                  ExcMessage ("All particle property values must be greater than 0 for harmonic averaging!"));
+                      cell_properties[i] += 1/particle_properties[i];
+                    }
+              }
+
+            for (unsigned int i = 0; i < n_particle_properties; ++i)
+              if (selected_properties[i])
+                {
+                  cell_properties[i] = n_particles/cell_properties[i];
+                }
+          }
+        // If there are no particles in this cell use the average of the
+        // neighboring cells.
+        else
+          {
+            std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> neighbors;
+            GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell,neighbors);
+
+            unsigned int non_empty_neighbors = 0;
+            for (unsigned int i=0; i<neighbors.size(); ++i)
+              {
+                // Only recursively call this function if the neighbor cell contains
+                // particles (else we end up in an endless recursion)
+                if (particle_handler.n_particles_in_cell(neighbors[i]) == 0)
+                  continue;
+
+                const std::vector<double> neighbor_properties = properties_at_points(particle_handler,
+                                                                                     std::vector<Point<dim>> (1,neighbors[i]->center(true,false)),
+                                                                                     selected_properties,
+                                                                                     neighbors[i])[0];
+
+                for (unsigned int i = 0; i < n_particle_properties; ++i)
+                  if (selected_properties[i])
+                    {
+                      AssertThrow(neighbor_properties[i] > 0,
+                                  ExcMessage ("All particle property values must be greater than 0 for harmonic averaging!"));
+                      cell_properties[i] += 1/neighbor_properties[i];
+                    }
+
+                ++non_empty_neighbors;
+              }
+
+            if (!allow_cells_without_particles)
+              {
+                AssertThrow(non_empty_neighbors != 0,
+                            ExcMessage("A cell and all of its neighbors do not contain any particles. "
+                                       "The `harmonic average' interpolation scheme does not support this case unless specified "
+                                       "in Allow cells without particles."));
+              }
+
+            for (unsigned int i = 0; i < n_particle_properties; ++i)
+              {
+                if (selected_properties[i] && non_empty_neighbors !=0)
+                  cell_properties[i] = non_empty_neighbors/cell_properties[i];
+                // Assume property is zero for any areas with no particles
+                else if (allow_cells_without_particles && non_empty_neighbors == 0)
+                  cell_properties[i] = 0;
+              }
+
+          }
+
+        return std::vector<std::vector<double>> (positions.size(),cell_properties);
+      }
+
+
+
+      template <int dim>
+      void
+      HarmonicAverage<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Allow cells without particles", "false",
+                           Patterns::Bool (),
+                           "By default, every cell needs to contain particles to use this interpolator "
+                           "plugin. If this parameter is set to true, cells are allowed to have no particles. "
+                           "In case both the current cell and its neighbors are empty, "
+                           "the interpolator will return 0 for the current cell's properties.");
+      }
+
+
+
+      template <int dim>
+      void
+      HarmonicAverage<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        allow_cells_without_particles = prm.get_bool("Allow cells without particles");
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(HarmonicAverage,
+                                            "harmonic average",
+                                            "Return the harmonic average of all particle properties in the "
+                                            "given cell. If the cell contains no particles, return the "
+                                            "harmonic average of the properties in the neighboring cells. "
+                                            "In case the neighboring cells are also empty, and 'Allow cells "
+                                            "without particles' is set to true, the interpolator returns 0. "
+                                            "Otherwise, an exception is thrown. ")
+    }
+  }
+}
diff --git a/source/particle/interpolator/interface.cc.bak b/source/particle/interpolator/interface.cc.bak
new file mode 100644
index 00000000000..83a50104dec
--- /dev/null
+++ b/source/particle/interpolator/interface.cc.bak
@@ -0,0 +1,149 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/interpolator/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+// -------------------------------- Deal with registering models and automating
+// -------------------------------- their setup and selection at run time
+
+      namespace
+      {
+        std::tuple
+        <void *,
+        void *,
+        aspect::internal::Plugins::PluginList<Interface<2>>,
+        aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+      }
+
+
+
+      template <int dim>
+      void
+      register_particle_interpolator (const std::string &name,
+                                      const std::string &description,
+                                      void (*declare_parameters_function) (ParameterHandler &),
+                                      std::unique_ptr<Interface<dim>> (*factory_function) ())
+      {
+        std::get<dim>(registered_plugins).register_plugin (name,
+                                                           description,
+                                                           declare_parameters_function,
+                                                           factory_function);
+      }
+
+
+
+      template <int dim>
+      std::unique_ptr<Interface<dim>>
+      create_particle_interpolator (ParameterHandler &prm)
+      {
+        std::string name;
+        name = prm.get ("Interpolation scheme");
+
+        return std::get<dim>(registered_plugins).create_plugin (name,
+                                                                "Particle::Interpolator name");
+      }
+
+
+
+      template <int dim>
+      void
+      declare_parameters (ParameterHandler &prm)
+      {
+        // declare the entry in the parameter file
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry ("Interpolation scheme", "cell average",
+                           Patterns::Selection (pattern_of_names),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+
+        std::get<dim>(registered_plugins).declare_parameters (prm);
+      }
+
+
+
+      template <int dim>
+      void
+      write_plugin_graph (std::ostream &out)
+      {
+        std::get<dim>(registered_plugins).write_plugin_graph ("Particle interpolator interface",
+                                                              out);
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<Particle::Interpolator::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<Particle::Interpolator::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<Particle::Interpolator::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<Particle::Interpolator::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_particle_interpolator<dim> (const std::string &, \
+                                       const std::string &, \
+                                       void ( *) (ParameterHandler &), \
+                                       std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_particle_interpolator<dim> (ParameterHandler &prm);
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/source/particle/interpolator/nearest_neighbor.cc.bak b/source/particle/interpolator/nearest_neighbor.cc.bak
new file mode 100644
index 00000000000..9903cb18a4d
--- /dev/null
+++ b/source/particle/interpolator/nearest_neighbor.cc.bak
@@ -0,0 +1,161 @@
+/*
+ Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/interpolator/nearest_neighbor.h>
+
+#include <deal.II/grid/grid_tools.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      template <int dim>
+      std::vector<std::vector<double>>
+      NearestNeighbor<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
+                                                 const std::vector<Point<dim>> &positions,
+                                                 const ComponentMask &selected_properties,
+                                                 const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
+      {
+        const typename ParticleHandler<dim>::particle_iterator_range particle_range = particle_handler.particles_in_cell(cell);
+
+        const unsigned int n_particles = std::distance(particle_range.begin(),particle_range.end());
+        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
+
+        std::vector<double> temp(n_particle_properties, 0.0);
+        std::vector<std::vector<double>> point_properties(positions.size(), temp);
+
+        for (unsigned int pos_idx=0; pos_idx < positions.size(); ++pos_idx)
+          {
+            double minimum_distance = std::numeric_limits<double>::max();
+            if (n_particles > 0)
+              {
+                typename ParticleHandler<dim>::particle_iterator nearest_neighbor;
+                for (typename ParticleHandler<dim>::particle_iterator particle = particle_range.begin();
+                     particle != particle_range.end(); ++particle)
+                  {
+                    const double dist = (positions[pos_idx] - particle->get_location()).norm_square();
+                    if (dist < minimum_distance)
+                      {
+                        minimum_distance = dist;
+                        nearest_neighbor = particle;
+                      }
+                  }
+                const dealii::ArrayView<const double> neighbor_props = nearest_neighbor->get_properties();
+                for (unsigned int i = 0; i < n_particle_properties; ++i)
+                  if (selected_properties[i])
+                    point_properties[pos_idx][i] = neighbor_props[i];
+              }
+            else
+              {
+                std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> neighbors;
+                GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell,neighbors);
+
+                unsigned int nearest_neighbor_cell = numbers::invalid_unsigned_int;
+                for (unsigned int i=0; i<neighbors.size(); ++i)
+                  {
+                    // Only recursively call this function if the neighbor cell contains
+                    // particles (else we end up in an endless recursion)
+                    if (particle_handler.n_particles_in_cell(neighbors[i]) == 0)
+                      continue;
+
+                    const double dist = (positions[pos_idx] - neighbors[i]->center()).norm_square();
+                    if (dist < minimum_distance)
+                      {
+                        minimum_distance = dist;
+                        nearest_neighbor_cell = i;
+                      }
+                  }
+
+                if (!allow_cells_without_particles)
+                  {
+                    AssertThrow(nearest_neighbor_cell != numbers::invalid_unsigned_int,
+                                ExcMessage("A cell and all of its neighbors do not contain any particles. "
+                                           "The `nearest neighbor' interpolation scheme does not support this case unless specified "
+                                           "in Allow cells without particles."));
+                  }
+
+                if (nearest_neighbor_cell != numbers::invalid_unsigned_int)
+                  {
+                    point_properties[pos_idx] = properties_at_points(particle_handler,
+                                                                     std::vector<Point<dim>> (1,positions[pos_idx]),
+                                                                     selected_properties,
+                                                                     neighbors[nearest_neighbor_cell])[0];
+                  }
+                else if (allow_cells_without_particles && nearest_neighbor_cell == numbers::invalid_unsigned_int)
+                  {
+                    for (unsigned int i = 0; i < n_particle_properties; ++i)
+                      if (selected_properties[i])
+                        point_properties[pos_idx][i] = 0;
+                  }
+
+              }
+
+          }
+
+        return point_properties;
+      }
+
+
+
+      template <int dim>
+      void
+      NearestNeighbor<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.declare_entry ("Allow cells without particles", "false",
+                           Patterns::Bool (),
+                           "By default, every cell needs to contain particles to use this interpolator "
+                           "plugin. If this parameter is set to true, cells are allowed to have no particles. "
+                           "In case both the current cell and its neighbors are empty, "
+                           "the interpolator will return 0 for the current cell's properties.");
+      }
+
+
+
+      template <int dim>
+      void
+      NearestNeighbor<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        allow_cells_without_particles = prm.get_bool("Allow cells without particles");
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(NearestNeighbor,
+                                            "nearest neighbor",
+                                            "Return the properties of the nearest neighboring particle "
+                                            "in the current cell, or nearest particle in nearest neighboring "
+                                            "cell if current cell is empty. "
+                                            "In case the neighboring cells are also empty, and 'Allow cells "
+                                            "without particles' is set to true, the interpolator returns 0. "
+                                            "Otherwise, an exception is thrown. ")
+    }
+  }
+}
diff --git a/source/particle/interpolator/quadratic_least_squares.cc.bak b/source/particle/interpolator/quadratic_least_squares.cc.bak
new file mode 100644
index 00000000000..4dfdfe715f6
--- /dev/null
+++ b/source/particle/interpolator/quadratic_least_squares.cc.bak
@@ -0,0 +1,640 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/interpolator/quadratic_least_squares.h>
+#include <aspect/particle/world.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/lac/qr.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      template <int dim>
+      double QuadraticLeastSquares<dim>::evaluate_interpolation_function(const Vector<double> &coefficients, const Point<dim> &position) const
+      {
+        if (dim == 2)
+          {
+            return coefficients[0] +
+                   coefficients[1] * position[0] +
+                   coefficients[2] * position[1] +
+                   coefficients[3] * position[0] * position[1] +
+                   coefficients[4] * position[0] * position[0] +
+                   coefficients[5] * position[1] * position[1];
+          }
+        else
+          {
+            return coefficients[0] +
+                   coefficients[1] * position[0] +
+                   coefficients[2] * position[1] +
+                   coefficients[3] * position[2] +
+                   coefficients[4] * position[0] * position[1] +
+                   coefficients[5] * position[0] * position[2] +
+                   coefficients[6] * position[1] * position[2] +
+                   coefficients[7] * position[0] * position[0] +
+                   coefficients[8] * position[1] * position[1] +
+                   coefficients[9] * position[2] * position[2];
+          }
+      }
+
+
+      template <int dim>
+      std::pair<double, double> QuadraticLeastSquares<dim>::get_interpolation_bounds(const Vector<double> &coefficients) const
+      {
+        double interpolation_min = std::numeric_limits<double>::max();
+        double interpolation_max = std::numeric_limits<double>::lowest();
+        for (const auto &critical_point : get_critical_points(coefficients))
+          {
+            bool critical_point_in_cell = true;
+            for (unsigned int d = 0; d < dim; ++d)
+              {
+                if (critical_point[d] < -0.5 || critical_point[d] > 0.5)
+                  critical_point_in_cell = false;
+              }
+            if (critical_point_in_cell)
+              {
+                const double value_at_critical_point = evaluate_interpolation_function(coefficients, critical_point);
+                interpolation_min = std::min(interpolation_min, value_at_critical_point);
+                interpolation_max = std::max(interpolation_max, value_at_critical_point);
+              }
+          }
+        return {interpolation_min, interpolation_max};
+      }
+
+
+      template <int dim>
+      std::vector<Point<dim>> QuadraticLeastSquares<dim>::get_critical_points(const Vector<double> &coefficients) const
+      {
+        std::vector<Point<dim>> critical_points;
+        const double epsilon = 10. * coefficients.linfty_norm() * std::numeric_limits<double>::epsilon();
+        if (dim == 2)
+          {
+            // reserve the maximum number of critical points
+            // in 2d: one inside, 4 edges, and 4 corners
+            critical_points.reserve(1 + 4 + 4);
+            // If finding the critical point of the function (or along a cell edge) would
+            // require division by 0, or the solve of a singular matrix, then there is not
+            // a unique critical point. There cannot be two critical points to this function,
+            // so there must be infinitely many points with the same value, so it should be
+            // caught by one of the other checks of the value of the interpolation
+
+            // compute the location of the global critical point
+            Tensor<2, dim, double> critical_point_A;
+            critical_point_A[0][0] = 2 * coefficients[4];
+            critical_point_A[0][1] = coefficients[3];
+            critical_point_A[1][0] = coefficients[3];
+            critical_point_A[1][1] = 2 * coefficients[5];
+            Tensor<1, dim, double> critical_point_b;
+            critical_point_b[0] = -coefficients[1];
+            critical_point_b[1] = -coefficients[2];
+            if (std::abs(determinant(critical_point_A)) > epsilon)
+              {
+                critical_points.emplace_back(invert(critical_point_A) * critical_point_b);
+              }
+
+            // Compute the critical value for each of the edges. This is necessary even if we found the
+            // critical point inside the unit cell, because the value at the edges can be a minimum, while
+            // the critical point inside the cell is a maximum, or vice-versa. Additionally the critical
+            // point could be a saddle point, in which case we would still need to find a minimum and maximum over the cell.
+            if (std::abs(coefficients[5]) > epsilon)
+              {
+                critical_points.emplace_back(-0.5, -(2 * coefficients[2] - coefficients[3])/(4 * coefficients[5]));
+                critical_points.emplace_back( 0.5, -(2 * coefficients[2] + coefficients[3])/(4 * coefficients[5]));
+              }
+            if (std::abs(coefficients[4]) > epsilon)
+              {
+                critical_points.emplace_back(-(2 * coefficients[1] - coefficients[3])/(4 * coefficients[4]), -0.5);
+                critical_points.emplace_back(-(2 * coefficients[1] + coefficients[3])/(4 * coefficients[4]),  0.5);
+              }
+
+            // Compute the critical value for each of the corners. This is necessary even if critical points
+            // have already been found in previous steps, as the global critical point could be a minimum,
+            // and the edge critical points could also be minimums.
+            for (double x = -0.5; x <= 0.5; ++x)
+              {
+                for (double y = -0.5; y <= 0.5; ++y)
+                  {
+                    critical_points.emplace_back(x,y);
+                  }
+              }
+          }
+        else if (dim == 3)
+          {
+            // reserve the maximum number of critical points
+            // in 3d: one inside, 6 faces, 12 edges, and 8 corners
+            critical_points.reserve(1 + 6 + 12 + 8);
+            // If finding the critical point of the function (or along a cell edge) would
+            // require division by 0, or the solve of a singular matrix, then there is not
+            // a unique critical point. There cannot be two critical points to this function,
+            // so there must be infinitely many points with the same value, so it should be
+            // caught by one of the other checks of the value of the interpolation
+
+            // Compute the location of the global critical point
+            {
+              Tensor<2, dim, double> critical_point_A;
+              critical_point_A[0][0] = 2 * coefficients[7];
+              critical_point_A[0][1] = coefficients[4];
+              critical_point_A[0][2] = coefficients[5];
+              critical_point_A[1][0] = coefficients[4];
+              critical_point_A[1][1] = 2 * coefficients[8];
+              critical_point_A[1][2] = coefficients[6];
+              critical_point_A[2][0] = coefficients[5];
+              critical_point_A[2][1] = coefficients[6];
+              critical_point_A[2][2] = 2 * coefficients[9];
+              Tensor<1, dim, double> critical_point_b;
+              critical_point_b[0] = -coefficients[1];
+              critical_point_b[1] = -coefficients[2];
+              critical_point_b[2] = -coefficients[3];
+              if (std::abs(determinant(critical_point_A)) > epsilon)
+                {
+                  critical_points.emplace_back(invert(critical_point_A) * critical_point_b);
+                }
+            }
+
+            // Compute the location of critical points along the faces of the cell.
+            // This is is necessary even if we found a global critical point as it
+            // could be a minimum and the faces could have a maximum or vice-versa.
+            Tensor<2, 2, double> critical_point_A;
+            Tensor<1, 2, double> critical_point_b;
+            Tensor<1, 2, double> critical_point_X;
+            // The columns of this critical_point_A correspond to Y and Z.
+            critical_point_A[0][0] = 2 * coefficients[8];
+            critical_point_A[0][1] = coefficients[6];
+            critical_point_A[1][0] = coefficients[6];
+            critical_point_A[1][1] = 2 * coefficients[9];
+            if (std::abs(determinant(critical_point_A)) > epsilon)
+              {
+                const Tensor<2, 2, double> critical_point_A_inv = invert(critical_point_A);
+                double x = -0.5;
+                critical_point_b[0] = -(coefficients[2] + coefficients[4] * x);
+                critical_point_b[1] = -(coefficients[3] + coefficients[5] * x);
+                critical_point_X = critical_point_A_inv * critical_point_b;
+                critical_points.emplace_back(x, critical_point_X[0], critical_point_X[1]);
+                x = 0.5;
+                critical_point_b[0] = -(coefficients[2] + coefficients[4] * x);
+                critical_point_b[1] = -(coefficients[3] + coefficients[5] * x);
+                critical_point_X = critical_point_A_inv * critical_point_b;
+                critical_points.emplace_back(x, critical_point_X[0], critical_point_X[1]);
+              }
+            // The columns of this critical_point_A correspond to X and Z.
+            critical_point_A[0][0] = 2 * coefficients[7];
+            critical_point_A[0][1] = coefficients[5];
+            critical_point_A[1][0] = coefficients[5];
+            critical_point_A[1][1] = 2 * coefficients[9];
+            if (std::abs(determinant(critical_point_A)) > epsilon)
+              {
+                const Tensor<2, 2, double> critical_point_A_inv = invert(critical_point_A);
+                double y = -0.5;
+                critical_point_b[0] = -(coefficients[1] + coefficients[4] * y);
+                critical_point_b[1] = -(coefficients[3] + coefficients[6] * y);
+                critical_point_X = critical_point_A_inv * critical_point_b;
+                critical_points.emplace_back(critical_point_X[0], y, critical_point_X[1]);
+                y = 0.5;
+                critical_point_b[0] = -(coefficients[1] + coefficients[4] * y);
+                critical_point_b[1] = -(coefficients[3] + coefficients[6] * y);
+                critical_point_X = critical_point_A_inv * critical_point_b;
+                critical_points.emplace_back(critical_point_X[0], y, critical_point_X[1]);
+              }
+            // The columns of this critical_point_A correspond to X and Y.
+            critical_point_A[0][0] = 2 * coefficients[7];
+            critical_point_A[0][1] = coefficients[4];
+            critical_point_A[1][0] = coefficients[4];
+            critical_point_A[1][1] = 2 * coefficients[8];
+            if (std::abs(determinant(critical_point_A)) > epsilon)
+              {
+                const Tensor<2, 2, double> critical_point_A_inv = invert(critical_point_A);
+                double z = -0.5;
+                critical_point_b[0] = -(coefficients[1] + coefficients[5] * z);
+                critical_point_b[1] = -(coefficients[2] + coefficients[6] * z);
+                critical_point_X = critical_point_A_inv * critical_point_b;
+                critical_points.emplace_back(critical_point_X[0], critical_point_X[1], z);
+                z = 0.5;
+                critical_point_b[0] = -(coefficients[1] + coefficients[5] * z);
+                critical_point_b[1] = -(coefficients[2] + coefficients[6] * z);
+                critical_point_X = critical_point_A_inv * critical_point_b;
+                critical_points.emplace_back(critical_point_X[0], critical_point_X[1], z);
+              }
+
+            // Compute the location of critical points along the edges.
+            // This is necessary even if critical points have been found in previous
+            // steps, as the global critial point and critical points on faces could
+            // all be minimums.
+            if (std::abs(coefficients[9]) > epsilon)
+              {
+                for (double x = -0.5; x <= 0.5; ++x)
+                  {
+                    for (double y = -0.5; y <= 0.5; ++y)
+                      {
+                        critical_points.emplace_back(x,y, -(coefficients[3] + coefficients[5] * x + coefficients[6] * y)/(2 * coefficients[9]));
+                      }
+                  }
+              }
+            if (std::abs(coefficients[8]) > epsilon)
+              {
+                for (double x = -0.5; x <= 0.5; ++x)
+                  {
+                    for (double z = -0.5; z <= 0.5; ++z)
+                      {
+                        critical_points.emplace_back(x, -(coefficients[2] + coefficients[4] * x + coefficients[6] * z) / (2 * coefficients[8]), z);
+                      }
+                  }
+              }
+            if (std::abs(coefficients[7]) > epsilon)
+              {
+                for (double y = -0.5; y <= 0.5; ++y)
+                  {
+                    for (double z = -0.5; z <= 0.5; ++z)
+                      {
+                        critical_points.emplace_back(-(coefficients[1] + coefficients[4] * y + coefficients[5] * z)/(2*coefficients[7]), y, z);
+                      }
+                  }
+              }
+
+            // Compute the location of critical points along the corners
+            // This is necessary even if critical points have been found in previous
+            // steps, as the previously found critical points could all be minimums
+            // and the corners could hold the maximum value over the cell.
+            for (double x = -0.5; x <= 0.5; ++x)
+              {
+                for (double y = -0.5; y <= 0.5; ++y)
+                  {
+                    for (double z = -0.5; z <= 0.5; ++z)
+                      {
+                        critical_points.emplace_back(x, y, z);
+                      }
+                  }
+              }
+          }
+        return critical_points;
+      }
+
+      template <int dim>
+      std::vector<std::vector<double>>
+      QuadraticLeastSquares<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
+                                                       const std::vector<Point<dim>> &positions,
+                                                       const ComponentMask &selected_properties,
+                                                       const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
+      {
+        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
+
+        const unsigned int property_index = selected_properties.first_selected_component(selected_properties.size());
+
+        AssertThrow(property_index != numbers::invalid_unsigned_int,
+                    ExcMessage("Internal error: the particle property interpolator was "
+                               "called without a specified component to interpolate."));
+
+        const typename ParticleHandler<dim>::particle_iterator_range particle_range =
+          particle_handler.particles_in_cell(cell);
+
+        std::vector<std::vector<double>> cell_properties(positions.size(),
+                                                          std::vector<double>(n_particle_properties,
+                                                                              numbers::signaling_nan<double>()));
+
+        const unsigned int n_particles = std::distance(particle_range.begin(), particle_range.end());
+
+        const unsigned int n_matrix_columns = (dim == 2) ? 6 : 10;
+        if (n_particles < n_matrix_columns)
+          return fallback_interpolator.properties_at_points(particle_handler,
+                                                            positions,
+                                                            selected_properties,
+                                                            cell);
+        const std::vector<double> cell_average_values = fallback_interpolator.properties_at_points(particle_handler,
+        {positions[0]},
+        selected_properties,
+        cell)[0];
+
+
+        // Notice that the size of matrix A is n_particles x n_matrix_columns
+        // which usually is not a square matrix. Therefore, we find the
+        // least squares solution of Ac=r by solving the reduced QR factorization
+        // Ac = QRc = b -> Q^TQRc = Rc =Q^Tb
+        // A is a std::vector of Vectors(which are it's columns) so that we
+        // create what the ImplicitQR class needs.
+        std::vector<Vector<double>> A(n_matrix_columns, Vector<double>(n_particles));
+        std::vector<Vector<double>> b(n_particle_properties, Vector<double>(n_particles));
+
+        unsigned int particle_index = 0;
+        // The unit cell of deal.II is [0, 1]^dim. The limiter needs a 'unit' cell of [-0.5, 0.5]^dim
+        const double unit_offset = 0.5;
+        std::vector<double> property_minimums(n_particle_properties, std::numeric_limits<double>::max());
+        std::vector<double> property_maximums(n_particle_properties, std::numeric_limits<double>::lowest());
+        for (typename ParticleHandler<dim>::particle_iterator particle = particle_range.begin();
+             particle != particle_range.end(); ++particle, ++particle_index)
+          {
+            const ArrayView<double> particle_property_value = particle->get_properties();
+            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+              {
+                if (selected_properties[property_index] == true)
+                  {
+                    b[property_index][particle_index] = particle_property_value[property_index];
+                    property_minimums[property_index] = std::min(property_minimums[property_index], particle_property_value[property_index]);
+                    property_maximums[property_index] = std::max(property_maximums[property_index], particle_property_value[property_index]);
+                  }
+              }
+
+            Point<dim> relative_particle_position = particle->get_reference_location();
+            for (unsigned int d = 0; d < dim; ++d)
+              relative_particle_position[d] -= unit_offset;
+            // A is accessed by A[column][row] here since we need to append
+            // columns into the qr matrix.
+
+            // There is a potential that in the future we may change to
+            // interpolate to $Q_2$ instead of the current $P_2$. This would
+            // involve adding more terms to the interpolation for some problems.
+            // We for now leave those terms out of the interpolation because they
+            // would require more particles per cell and we are not yet aware of
+            // a benchmark where those terms have affected the convegence.
+            A[0][particle_index] = 1;
+            A[1][particle_index] = relative_particle_position[0];
+            A[2][particle_index] = relative_particle_position[1];
+            if (dim == 2)
+              {
+                A[3][particle_index] = relative_particle_position[0] * relative_particle_position[1];
+                A[4][particle_index] = relative_particle_position[0] * relative_particle_position[0];
+                A[5][particle_index] = relative_particle_position[1] * relative_particle_position[1];
+              }
+            else
+              {
+                A[3][particle_index] = relative_particle_position[2];
+                A[4][particle_index] = relative_particle_position[0] * relative_particle_position[1];
+                A[5][particle_index] = relative_particle_position[0] * relative_particle_position[2];
+                A[6][particle_index] = relative_particle_position[1] * relative_particle_position[2];
+                A[7][particle_index] = relative_particle_position[0] * relative_particle_position[0];
+                A[8][particle_index] = relative_particle_position[1] * relative_particle_position[1];
+                A[9][particle_index] = relative_particle_position[2] * relative_particle_position[2];
+              }
+          }
+
+        // If the limiter is enabled for at least one property then we know that we can access ghost cell
+        // particles to determine the bounds of the properties on the model (due to the assert of
+        // 'Exchange ghost particles' in parse_parameters). Otherwise we do not need to access those particles
+        if (use_quadratic_least_squares_limiter.n_selected_components(n_particle_properties) != 0)
+          {
+            std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> active_neighbors;
+            GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell, active_neighbors);
+            for (const auto &active_neighbor : active_neighbors)
+              {
+                if (active_neighbor->is_artificial())
+                  continue;
+                const std::vector<double> neighbor_cell_average = fallback_interpolator.properties_at_points(particle_handler, positions, selected_properties, active_neighbor)[0];
+                for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+                  {
+                    if (selected_properties[property_index] == true && use_quadratic_least_squares_limiter[property_index] == true)
+                      {
+                        property_minimums[property_index] = std::min(property_minimums[property_index], neighbor_cell_average[property_index]);
+                        property_maximums[property_index] = std::max(property_maximums[property_index], neighbor_cell_average[property_index]);
+                      }
+                  }
+
+              }
+            if (cell->at_boundary())
+              {
+                for (unsigned int face_id = 0; face_id < cell->reference_cell().n_faces(); ++face_id)
+                  {
+                    if (cell->at_boundary(face_id))
+                      {
+                        const unsigned int opposing_face_id = GeometryInfo<dim>::opposite_face[face_id];
+                        const auto &opposing_cell = cell->neighbor(opposing_face_id);
+                        if (opposing_cell.state() == IteratorState::IteratorStates::valid && opposing_cell->is_active() && !opposing_cell->is_artificial())
+                          {
+
+                            const auto neighbor_cell_average = fallback_interpolator.properties_at_points(particle_handler, {positions[0]}, selected_properties, opposing_cell)[0];
+                            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+                              {
+                                if (selected_properties[property_index] == true && use_boundary_extrapolation[property_index] == true)
+                                  {
+                                    Assert(cell->reference_cell().is_hyper_cube() == true, ExcNotImplemented());
+                                    const double expected_boundary_value = 1.5 * cell_average_values[property_index] - 0.5 * neighbor_cell_average[property_index];
+                                    property_minimums[property_index] = std::min(property_minimums[property_index], expected_boundary_value);
+                                    property_maximums[property_index] = std::max(property_maximums[property_index], expected_boundary_value);
+                                  }
+                              }
+                          }
+                      }
+                  }
+              }
+          }
+        ImplicitQR<Vector<double>> qr;
+        for (const auto &column : A)
+          qr.append_column(column);
+        // If A is rank deficent then qr.append_column will not append
+        // the first column that can be written as a linear combination of
+        // other columns. We check that all columns were added or we
+        // rely on the fallback interpolator
+        if (qr.size() != n_matrix_columns)
+          return fallback_interpolator.properties_at_points(particle_handler,
+                                                            positions,
+                                                            selected_properties,
+                                                            cell);
+        std::vector<Vector<double>> QTb(n_particle_properties, Vector<double>(n_matrix_columns));
+        std::vector<Vector<double>> c(n_particle_properties, Vector<double>(n_matrix_columns));
+        for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+          {
+            if (selected_properties[property_index])
+              {
+                qr.multiply_with_QT(QTb[property_index], b[property_index]);
+                qr.solve(c[property_index], QTb[property_index]);
+                if (use_quadratic_least_squares_limiter[property_index])
+                  {
+
+                    const std::pair<double, double> interpolation_bounds = get_interpolation_bounds(c[property_index]);
+                    const double interpolation_min = interpolation_bounds.first;
+                    const double interpolation_max = interpolation_bounds.second;
+                    if ((interpolation_max - cell_average_values[property_index]) > std::numeric_limits<double>::epsilon() &&
+                        (cell_average_values[property_index] - interpolation_min) > std::numeric_limits<double>::epsilon())
+                      {
+                        const double alpha = std::max(std::min((cell_average_values[property_index] - property_minimums[property_index])/(cell_average_values[property_index] - interpolation_min),
+                                                               (property_maximums[property_index]-cell_average_values[property_index])/(interpolation_max - cell_average_values[property_index])), 0.0);
+                        // If alpha > 1, then using it would make the function grow to meet the bounds.
+                        if (alpha < 1.0)
+                          {
+                            c[property_index] *= alpha;
+                            c[property_index][0] += (1-alpha) * cell_average_values[property_index];
+                          }
+                      }
+                  }
+              }
+          }
+        unsigned int index_positions = 0;
+        for (typename std::vector<Point<dim>>::const_iterator itr = positions.begin(); itr != positions.end(); ++itr, ++index_positions)
+          {
+            Point<dim> relative_support_point_location = this->get_mapping().transform_real_to_unit_cell(cell, *itr);
+            for (unsigned int d = 0; d < dim; ++d)
+              relative_support_point_location[d] -= unit_offset;
+            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
+              {
+                if (selected_properties[property_index] == true)
+                  {
+                    double interpolated_value = evaluate_interpolation_function(c[property_index], relative_support_point_location);
+                    // Overshoot and undershoot correction of interpolated particle property.
+                    if (use_quadratic_least_squares_limiter[property_index])
+                      {
+                        // Assert that the limiter was reasonably effective. We can not expect perfect accuracy
+                        // due to inaccuracies e.g. in the inversion of the mapping.
+                        const double tolerance = std::sqrt(std::numeric_limits<double>::epsilon())
+                                                 * std::max(std::abs(property_minimums[property_index]),
+                                                            std::abs(property_maximums[property_index]));
+                        (void) tolerance;
+                        Assert(interpolated_value >= property_minimums[property_index] - tolerance,
+                               ExcMessage("The particle interpolation limiter did not succeed. Interpolated value: " + std::to_string(interpolated_value)
+                                          + " is smaller than the minimum particle property value: " + std::to_string(property_minimums[property_index]) + "."));
+                        Assert(interpolated_value <= property_maximums[property_index] + tolerance,
+                               ExcMessage("The particle interpolation limiter did not succeed. Interpolated value: " + std::to_string(interpolated_value)
+                                          + " is larger than the maximum particle property value: " + std::to_string(property_maximums[property_index]) + "."));
+
+                        // This chopping is done to avoid values that are just outside
+                        // of the limiting bounds.
+                        interpolated_value = std::min(interpolated_value, property_maximums[property_index]);
+                        interpolated_value = std::max(interpolated_value, property_minimums[property_index]);
+                      }
+                    cell_properties[index_positions][property_index] = interpolated_value;
+                  }
+
+              }
+          }
+        return cell_properties;
+      }
+
+
+
+      template <int dim>
+      void
+      QuadraticLeastSquares<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Interpolator");
+        {
+          prm.enter_subsection("Quadratic least squares");
+          {
+            prm.declare_entry("Use quadratic least squares limiter", "true",
+                              Patterns::List(Patterns::Bool()),
+                              "Limit the interpolation of particle properties onto the cell, so that "
+                              "the value of each property is no smaller than its minimum and no "
+                              "larger than its maximum on the particles of each cell, and the "
+                              "average of neighboring cells. If more than one value is given, "
+                              "it will be treated as a list with one component per particle property.");
+            prm.declare_entry("Use boundary extrapolation", "false",
+                              Patterns::List(Patterns::Bool()),
+                              "Extends the range used by 'Use quadratic least squares limiter' "
+                              "by linearly interpolating values at cell boundaries from neighboring "
+                              "cells. If more than one value is given, it will be treated as a list "
+                              "with one component per particle property. Enabling 'Use boundary "
+                              "extrapolation' requires enabling 'Use quadratic least squares "
+                              "limiter'.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+      template <int dim>
+      void
+      QuadraticLeastSquares<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        fallback_interpolator.parse_parameters(prm);
+
+        prm.enter_subsection("Interpolator");
+        {
+          prm.enter_subsection("Quadratic least squares");
+          {
+            const auto &particle_property_information = this->get_particle_world(this->get_particle_world_index()).get_property_manager().get_data_info();
+            const unsigned int n_property_components = particle_property_information.n_components();
+            const unsigned int n_internal_components = particle_property_information.get_components_by_field_name("internal: integrator properties");
+
+            const std::vector<std::string> quadratic_least_squares_limiter_split = Utilities::split_string_list(prm.get("Use quadratic least squares limiter"));
+            std::vector<bool> quadratic_least_squares_limiter_parsed;
+            if (quadratic_least_squares_limiter_split.size() == 1)
+              {
+                quadratic_least_squares_limiter_parsed = std::vector<bool>(n_property_components - n_internal_components, Utilities::string_to_bool(quadratic_least_squares_limiter_split[0]));
+              }
+            else if (quadratic_least_squares_limiter_split.size() == n_property_components - n_internal_components)
+              {
+                for (const auto &component: quadratic_least_squares_limiter_split)
+                  quadratic_least_squares_limiter_parsed.push_back(Utilities::string_to_bool(component));
+              }
+            else
+              {
+                AssertThrow(false, ExcMessage("The size of 'Use quadratic least squares limiter' should either be 1 or the number of particle properties"));
+              }
+            for (unsigned int i = 0; i < n_internal_components; ++i)
+              quadratic_least_squares_limiter_parsed.push_back(false);
+            use_quadratic_least_squares_limiter = ComponentMask(quadratic_least_squares_limiter_parsed);
+
+
+            const std::vector<std::string> boundary_extrapolation_split = Utilities::split_string_list(prm.get("Use boundary extrapolation"));
+            std::vector<bool> boundary_extrapolation_parsed;
+            if (boundary_extrapolation_split.size() == 1)
+              {
+                boundary_extrapolation_parsed = std::vector<bool>(n_property_components - n_internal_components, Utilities::string_to_bool(boundary_extrapolation_split[0]));
+              }
+            else if (boundary_extrapolation_split.size() == n_property_components - n_internal_components)
+              {
+                for (const auto &component: boundary_extrapolation_split)
+                  boundary_extrapolation_parsed.push_back(Utilities::string_to_bool(component));
+              }
+            else
+              {
+                AssertThrow(false, ExcMessage("The size of 'Use boundary extrapolation' should either be 1 or the number of particle properties"));
+              }
+            for (unsigned int i = 0; i < n_internal_components; ++i)
+              boundary_extrapolation_parsed.push_back(false);
+            use_boundary_extrapolation = ComponentMask(boundary_extrapolation_parsed);
+            for (unsigned int property_index = 0; property_index < n_property_components - n_internal_components; ++property_index)
+              {
+                AssertThrow(use_quadratic_least_squares_limiter[property_index] || !use_boundary_extrapolation[property_index],
+                            ExcMessage("'Use boundary extrapolation' must be set with 'Use quadratic least squares limiter' to be valid."));
+              }
+
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+
+        // In general n_selected_components() requests an argument of the ComponentMask's size since it could be initialized to be entirely true without a size.
+        // Here it is given a size equal to n_property_components, so that argument is not necessary.
+        const bool limiter_enabled_for_at_least_one_property = (use_quadratic_least_squares_limiter.n_selected_components() != 0);
+        AssertThrow(limiter_enabled_for_at_least_one_property == false || prm.get_bool("Update ghost particles") == true,
+                    ExcMessage("If 'Use quadratic least squares limiter' is enabled for any particle property, then 'Update ghost particles' must be set to true"));
+
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Interpolator
+    {
+      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(QuadraticLeastSquares,
+                                            "quadratic least squares",
+                                            "Interpolates particle properties onto a vector of points using a "
+                                            "quadratic least squares method. Note that deal.II must be configured "
+                                            "with BLAS/LAPACK.")
+    }
+  }
+}
diff --git a/source/particle/property/composition.cc.bak b/source/particle/property/composition.cc.bak
new file mode 100644
index 00000000000..8584d0f65ad
--- /dev/null
+++ b/source/particle/property/composition.cc.bak
@@ -0,0 +1,110 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/particle/property/composition.h>
+#include <aspect/initial_composition/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      Composition<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                         std::vector<double> &data) const
+      {
+        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
+          data.push_back(this->get_initial_composition_manager().initial_composition(position,i));
+      }
+
+      template <int dim>
+      void
+      Composition<dim>::update_particle_property(const unsigned int data_position,
+                                                 const Vector<double> &solution,
+                                                 const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                                 typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
+          {
+            const unsigned int solution_component = this->introspection().component_indices.compositional_fields[i];
+            particle->get_properties()[data_position+i] = solution[solution_component];
+          }
+      }
+
+      template <int dim>
+      UpdateTimeFlags
+      Composition<dim>::need_update() const
+      {
+        return update_time_step;
+      }
+
+      template <int dim>
+      UpdateFlags
+      Composition<dim>::get_needed_update_flags () const
+      {
+        return update_values;
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      Composition<dim>::get_property_information() const
+      {
+
+        AssertThrow(this->n_compositional_fields() > 0,
+                    ExcMessage("You have requested the particle property <composition>, "
+                               "but the number of compositional fields is 0. "
+                               "Please add compositional fields to your model, or remove "
+                               "this particle property."));
+
+        std::vector<std::pair<std::string,unsigned int>> property_information;
+
+
+
+        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
+          {
+            const std::string field_name = this->introspection().name_for_compositional_index(i);
+            property_information.emplace_back(field_name,1);
+          }
+        return property_information;
+      }
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(Composition,
+                                        "composition",
+                                        "Implementation of a plugin in which the particle "
+                                        "property is defined by the compositional fields in "
+                                        "the model. This can be used to track solid composition"
+                                        "evolution over time.")
+    }
+  }
+}
diff --git a/source/particle/property/cpo_bingham_average.cc.bak b/source/particle/property/cpo_bingham_average.cc.bak
new file mode 100644
index 00000000000..8ccba63ae27
--- /dev/null
+++ b/source/particle/property/cpo_bingham_average.cc.bak
@@ -0,0 +1,284 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/cpo_bingham_average.h>
+#include <aspect/particle/world.h>
+
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      CpoBinghamAverage<dim>::initialize ()
+      {
+        const unsigned int my_rank = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
+        this->random_number_generator.seed(random_number_seed+my_rank);
+        const auto &manager = this->get_particle_world(this->get_particle_world_index()).get_property_manager();
+        AssertThrow(manager.plugin_name_exists("crystal preferred orientation"),
+                    ExcMessage("No crystal preferred orientation property plugin found."));
+
+        AssertThrow(manager.check_plugin_order("crystal preferred orientation","cpo bingham average"),
+                    ExcMessage("To use the cpo bingham average plugin, the cpo plugin need to be defined before this plugin."));
+
+        cpo_data_position = manager.get_data_info().get_position_by_plugin_index(manager.get_plugin_index_by_name("crystal preferred orientation"));
+
+      }
+
+
+
+      template <int dim>
+      void
+      CpoBinghamAverage<dim>::initialize_one_particle_property(const Point<dim> &,
+                                                               std::vector<double> &data) const
+      {
+        std::vector<double> volume_fractions_grains(n_grains);
+        std::vector<Tensor<2,3>> rotation_matrices_grains(n_grains);
+        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
+          {
+            // create volume fractions and rotation matrix vectors in the order that it is stored in the data array
+            for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
+              {
+                volume_fractions_grains[grain_i] = cpo_particle_property->get_volume_fractions_grains(cpo_data_position,data,mineral_i,grain_i);
+                rotation_matrices_grains[grain_i] = cpo_particle_property->get_rotation_matrix_grains(cpo_data_position,data,mineral_i,grain_i);
+              }
+
+            const std::vector<Tensor<2,3>> weighted_rotation_matrices =
+              Utilities::rotation_matrices_random_draw_volume_weighting(volume_fractions_grains,
+                                                                        rotation_matrices_grains,
+                                                                        n_samples,
+                                                                        this->random_number_generator);
+            const std::array<std::array<double,6>,3> bingham_average = compute_bingham_average(weighted_rotation_matrices);
+
+            for (unsigned int i = 0; i < 3; ++i)
+              for (unsigned int j = 0; j < 6; ++j)
+                data.emplace_back(bingham_average[i][j]);
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      CpoBinghamAverage<dim>::update_particle_property(const unsigned int data_position,
+                                                       const Vector<double> &/*solution*/,
+                                                       const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                                       typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        std::vector<double> volume_fractions_grains(n_grains);
+        std::vector<Tensor<2,3>> rotation_matrices_grains(n_grains);
+        ArrayView<double> data = particle->get_properties();
+        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
+          {
+            // create volume fractions and rotation matrix vectors in the order that it is stored in the data array
+            for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
+              {
+                volume_fractions_grains[grain_i] = cpo_particle_property->get_volume_fractions_grains(cpo_data_position,data,mineral_i,grain_i);
+                rotation_matrices_grains[grain_i] = cpo_particle_property->get_rotation_matrix_grains(cpo_data_position,data,mineral_i,grain_i);
+              }
+
+            const std::vector<Tensor<2,3>> weighted_rotation_matrices = Utilities::rotation_matrices_random_draw_volume_weighting(volume_fractions_grains, rotation_matrices_grains, n_samples, this->random_number_generator);
+            std::array<std::array<double,6>,3> bingham_average = compute_bingham_average(weighted_rotation_matrices);
+
+            for (unsigned int i = 0; i < 3; ++i)
+              for (unsigned int j = 0; j < 6; ++j)
+                {
+                  data[data_position + mineral_i*18 + i*3 + j] = bingham_average[i][j];
+                }
+          }
+      }
+
+
+
+      template <int dim>
+      std::array<std::array<double,6>,3>
+      CpoBinghamAverage<dim>::compute_bingham_average(std::vector<Tensor<2,3>> matrices) const
+      {
+        SymmetricTensor<2,3> sum_matrix_a;
+        SymmetricTensor<2,3> sum_matrix_b;
+        SymmetricTensor<2,3> sum_matrix_c;
+
+        // extracting the a, b and c orientations from the olivine a matrix
+        // see https://courses.eas.ualberta.ca/eas421/lecturepages/orientation.html
+        const unsigned int n_matrices = matrices.size();
+        for (unsigned int i_grain = 0; i_grain < n_matrices; ++i_grain)
+          {
+            sum_matrix_a[0][0] += matrices[i_grain][0][0] * matrices[i_grain][0][0]; // SUM(l^2)
+            sum_matrix_a[1][1] += matrices[i_grain][0][1] * matrices[i_grain][0][1]; // SUM(m^2)
+            sum_matrix_a[2][2] += matrices[i_grain][0][2] * matrices[i_grain][0][2]; // SUM(n^2)
+            sum_matrix_a[0][1] += matrices[i_grain][0][0] * matrices[i_grain][0][1]; // SUM(l*m)
+            sum_matrix_a[0][2] += matrices[i_grain][0][0] * matrices[i_grain][0][2]; // SUM(l*n)
+            sum_matrix_a[1][2] += matrices[i_grain][0][1] * matrices[i_grain][0][2]; // SUM(m*n)
+
+
+            sum_matrix_b[0][0] += matrices[i_grain][1][0] * matrices[i_grain][1][0]; // SUM(l^2)
+            sum_matrix_b[1][1] += matrices[i_grain][1][1] * matrices[i_grain][1][1]; // SUM(m^2)
+            sum_matrix_b[2][2] += matrices[i_grain][1][2] * matrices[i_grain][1][2]; // SUM(n^2)
+            sum_matrix_b[0][1] += matrices[i_grain][1][0] * matrices[i_grain][1][1]; // SUM(l*m)
+            sum_matrix_b[0][2] += matrices[i_grain][1][0] * matrices[i_grain][1][2]; // SUM(l*n)
+            sum_matrix_b[1][2] += matrices[i_grain][1][1] * matrices[i_grain][1][2]; // SUM(m*n)
+
+
+            sum_matrix_c[0][0] += matrices[i_grain][2][0] * matrices[i_grain][2][0]; // SUM(l^2)
+            sum_matrix_c[1][1] += matrices[i_grain][2][1] * matrices[i_grain][2][1]; // SUM(m^2)
+            sum_matrix_c[2][2] += matrices[i_grain][2][2] * matrices[i_grain][2][2]; // SUM(n^2)
+            sum_matrix_c[0][1] += matrices[i_grain][2][0] * matrices[i_grain][2][1]; // SUM(l*m)
+            sum_matrix_c[0][2] += matrices[i_grain][2][0] * matrices[i_grain][2][2]; // SUM(l*n)
+            sum_matrix_c[1][2] += matrices[i_grain][2][1] * matrices[i_grain][2][2]; // SUM(m*n)
+
+          }
+        const std::array<std::pair<double,Tensor<1,3,double>>, 3> eigenvectors_a = eigenvectors(sum_matrix_a, SymmetricTensorEigenvectorMethod::jacobi);
+        const std::array<std::pair<double,Tensor<1,3,double>>, 3> eigenvectors_b = eigenvectors(sum_matrix_b, SymmetricTensorEigenvectorMethod::jacobi);
+        const std::array<std::pair<double,Tensor<1,3,double>>, 3> eigenvectors_c = eigenvectors(sum_matrix_c, SymmetricTensorEigenvectorMethod::jacobi);
+
+        // average axis = eigenvector * largest eigenvalue
+        const Tensor<1,3,double> averaged_a = eigenvectors_a[0].second * eigenvectors_a[0].first;
+        const Tensor<1,3,double> averaged_b = eigenvectors_b[0].second * eigenvectors_b[0].first;
+        const Tensor<1,3,double> averaged_c = eigenvectors_c[0].second * eigenvectors_a[0].first;
+
+        // eigenvalues of all axes, used in the anisotropic viscosity material model to compute Hill's coefficients
+        const double eigenvalue_a1 = eigenvectors_a[0].first/matrices.size();
+        const double eigenvalue_a2 = eigenvectors_a[1].first/matrices.size();
+        const double eigenvalue_a3 = eigenvectors_a[2].first/matrices.size();
+        const double eigenvalue_b1 = eigenvectors_b[0].first/matrices.size();
+        const double eigenvalue_b2 = eigenvectors_b[1].first/matrices.size();
+        const double eigenvalue_b3 = eigenvectors_b[2].first/matrices.size();
+        const double eigenvalue_c1 = eigenvectors_c[0].first/matrices.size();
+        const double eigenvalue_c2 = eigenvectors_c[1].first/matrices.size();
+        const double eigenvalue_c3 = eigenvectors_c[2].first/matrices.size();
+
+        return
+        {
+          {
+            {{averaged_a[0],averaged_a[1],averaged_a[2], eigenvalue_a1, eigenvalue_a2, eigenvalue_a3}},
+            {{averaged_b[0],averaged_b[1],averaged_b[2], eigenvalue_b1, eigenvalue_b2, eigenvalue_b3}},
+            {{averaged_c[0],averaged_c[1],averaged_c[2], eigenvalue_c1, eigenvalue_c2, eigenvalue_c3}}
+          }
+        };
+
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      CpoBinghamAverage<dim>::need_update() const
+      {
+        return update_output_step;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      CpoBinghamAverage<dim>::get_needed_update_flags () const
+      {
+        return update_default;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      CpoBinghamAverage<dim>::get_property_information() const
+      {
+        std::vector<std::pair<std::string,unsigned int>> property_information;
+        property_information.reserve(6*n_minerals);
+        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
+          {
+            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " bingham average a axis",3);
+            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " eigenvalues a axis",3);
+            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " bingham average b axis",3);
+            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " eigenvalues b axis",3);
+            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " bingham average c axis",3);
+            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " eigenvalues c axis",3);
+          }
+
+        return property_information;
+      }
+
+
+
+      template <int dim>
+      void
+      CpoBinghamAverage<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("CPO Bingham Average");
+        {
+          prm.declare_entry ("Random number seed", "1",
+                             Patterns::Integer (0),
+                             "The seed used to generate random numbers. This will make sure that "
+                             "results are reproducible as long as the problem is run with the "
+                             "same amount of MPI processes. It is implemented as final seed = "
+                             "Random number seed + MPI Rank. ");
+
+          prm.declare_entry ("Number of samples", "0",
+                             Patterns::Double(0),
+                             "This determines how many samples are taken when using the random "
+                             "draw volume averaging. Setting it to zero means that the number of "
+                             "samples is set to be equal to the number of grains.");
+        }
+        prm.leave_subsection ();
+      }
+
+
+
+      template <int dim>
+      void
+      CpoBinghamAverage<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("CPO Bingham Average");
+        {
+          // Get a pointer to the CPO particle property.
+          cpo_particle_property = std::make_unique<const Particle::Property::CrystalPreferredOrientation<dim>> (
+                                    this->get_particle_world(this->get_particle_world_index()).get_property_manager().template get_matching_property<Particle::Property::CrystalPreferredOrientation<dim>>());
+
+          random_number_seed = prm.get_integer ("Random number seed");
+          n_grains = cpo_particle_property->get_number_of_grains();
+          n_minerals = cpo_particle_property->get_number_of_minerals();
+          n_samples = prm.get_integer("Number of samples");
+          if (n_samples == 0)
+            n_samples = n_grains;
+        }
+        prm.leave_subsection ();
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(CpoBinghamAverage,
+                                        "cpo bingham average",
+                                        "This is a particle property plugin which computes the Bingham "
+                                        "average for the Crystal Preferred Orientation particle property "
+                                        "plugin so that it can be visualized.")
+    }
+  }
+}
diff --git a/source/particle/property/cpo_elastic_tensor.cc.bak b/source/particle/property/cpo_elastic_tensor.cc.bak
new file mode 100644
index 00000000000..e15c4436b70
--- /dev/null
+++ b/source/particle/property/cpo_elastic_tensor.cc.bak
@@ -0,0 +1,261 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/cpo_elastic_tensor.h>
+#include <aspect/particle/world.h>
+
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+
+
+      template <int dim>
+      CpoElasticTensor<dim>::CpoElasticTensor ()
+      {
+        // The following values are directly from D-Rex.
+        // Todo: make them a input parameter
+        // Stiffness matrix for Olivine (GigaPascals)
+        stiffness_matrix_olivine[0][0] = 320.71;
+        stiffness_matrix_olivine[0][1] = 69.84;
+        stiffness_matrix_olivine[0][2] = 71.22;
+        stiffness_matrix_olivine[1][1] = 197.25;
+        stiffness_matrix_olivine[1][2] = 74.8;
+        stiffness_matrix_olivine[2][2] = 234.32;
+        stiffness_matrix_olivine[3][3] = 63.77;
+        stiffness_matrix_olivine[4][4] = 77.67;
+        stiffness_matrix_olivine[5][5] = 78.36;
+
+
+        // Stiffness matrix for Enstatite (GPa)
+        stiffness_matrix_enstatite[0][0] = 236.9;
+        stiffness_matrix_enstatite[0][1] = 79.6;
+        stiffness_matrix_enstatite[0][2] = 63.2;
+        stiffness_matrix_enstatite[1][1] = 180.5;
+        stiffness_matrix_enstatite[1][2] = 56.8;
+        stiffness_matrix_enstatite[2][2] = 230.4;
+        stiffness_matrix_enstatite[3][3] = 84.3;
+        stiffness_matrix_enstatite[4][4] = 79.4;
+        stiffness_matrix_enstatite[5][5] = 80.1;
+      }
+
+
+
+      template <int dim>
+      void
+      CpoElasticTensor<dim>::initialize ()
+      {
+        const auto &manager = this->get_particle_world(this->get_particle_world_index()).get_property_manager();
+        AssertThrow(manager.plugin_name_exists("crystal preferred orientation"),
+                    ExcMessage("No crystal preferred orientation property plugin found."));
+
+        AssertThrow(manager.check_plugin_order("crystal preferred orientation","cpo elastic tensor"),
+                    ExcMessage("To use the cpo elastic tensor plugin, the cpo plugin needs to be defined before this plugin."));
+
+        cpo_data_position = manager.get_data_info().get_position_by_plugin_index(manager.get_plugin_index_by_name("crystal preferred orientation"));
+      }
+
+
+
+      template <int dim>
+      SymmetricTensor<2,6>
+      CpoElasticTensor<dim>::voigt_average_elastic_tensor (const Particle::Property::CrystalPreferredOrientation<dim> &cpo_particle_property,
+                                                           const unsigned int cpo_data_position,
+                                                           const ArrayView<double> &data) const
+      {
+        SymmetricTensor<2,6> C_average;
+        const SymmetricTensor<2,6> *stiffness_matrix = &stiffness_matrix_olivine;
+        for (size_t mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
+          {
+            if (cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_a_fabric
+                || cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_b_fabric
+                || cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_d_fabric
+                || cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_c_fabric
+                || cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_e_fabric
+               )
+              {
+                stiffness_matrix = &stiffness_matrix_olivine;
+              }
+            else if (cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::enstatite)
+              {
+                stiffness_matrix = &stiffness_matrix_enstatite;
+              }
+            else
+              {
+                AssertThrow(false, ExcMessage("Stiffness matrix not implemented for deformation type "
+                                              + std::to_string(static_cast<unsigned int>(cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i)))));
+              }
+
+            for (size_t grain_i = 0; grain_i < n_grains; grain_i++)
+              {
+                const auto rotated_matrix = Utilities::Tensors::rotate_voigt_stiffness_matrix(transpose(cpo_particle_property.get_rotation_matrix_grains(cpo_data_position,data,mineral_i,grain_i)),*stiffness_matrix);
+                C_average += cpo_particle_property.get_volume_fractions_grains(cpo_data_position,data,mineral_i,grain_i) * cpo_particle_property.get_volume_fraction_mineral(cpo_data_position,data,mineral_i) * rotated_matrix;
+              }
+          }
+
+        return C_average;
+      }
+
+
+
+      template <int dim>
+      void
+      CpoElasticTensor<dim>::initialize_one_particle_property(const Point<dim> &,
+                                                              std::vector<double> &data) const
+      {
+
+        // At initialization, the deformation type for cpo is initialized to -1.
+        // Initialize with the stiffness matrix of olivine to avoid errors in the computation.
+
+        for (unsigned int i = 0; i < SymmetricTensor<2,6>::n_independent_components ; ++i)
+          {
+            data.push_back(stiffness_matrix_olivine[SymmetricTensor<2,6>::unrolled_to_component_indices(i)]);
+          }
+
+
+      }
+
+
+
+      template <int dim>
+      void
+      CpoElasticTensor<dim>::update_particle_property(const unsigned int data_position,
+                                                      const Vector<double> &/*solution*/,
+                                                      const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                                      typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        // Get a reference to the CPO particle property.
+        const Particle::Property::CrystalPreferredOrientation<dim> &cpo_particle_property =
+          this->get_particle_world(this->get_particle_world_index()).get_property_manager().template get_matching_property<Particle::Property::CrystalPreferredOrientation<dim>>();
+
+
+        const SymmetricTensor<2,6> C_average = voigt_average_elastic_tensor(cpo_particle_property,
+                                                                            cpo_data_position,
+                                                                            particle->get_properties());
+
+        Particle::Property::CpoElasticTensor<dim>::set_elastic_tensor(data_position,
+                                                                      particle->get_properties(),
+                                                                      C_average);
+
+
+      }
+
+
+
+      template <int dim>
+      SymmetricTensor<2,6>
+      CpoElasticTensor<dim>::get_elastic_tensor(unsigned int cpo_data_position,
+                                                const ArrayView<double> &data)
+      {
+        return Utilities::Tensors::to_symmetric_tensor<6>(&data[cpo_data_position],
+                                                          &data[cpo_data_position]+SymmetricTensor<2,6>::n_independent_components);
+      }
+
+
+
+      template <int dim>
+      void
+      CpoElasticTensor<dim>::set_elastic_tensor(unsigned int cpo_data_position,
+                                                const ArrayView<double> &data,
+                                                const SymmetricTensor<2,6> &elastic_tensor)
+      {
+        Utilities::Tensors::unroll_symmetric_tensor_into_array(elastic_tensor,
+                                                               &data[cpo_data_position],
+                                                               &data[cpo_data_position]+SymmetricTensor<2,6>::n_independent_components);
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      CpoElasticTensor<dim>::need_update() const
+      {
+        return update_output_step;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      CpoElasticTensor<dim>::get_needed_update_flags () const
+      {
+        return update_default;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      CpoElasticTensor<dim>::get_property_information() const
+      {
+        std::vector<std::pair<std::string,unsigned int>> property_information;
+
+        property_information.emplace_back("cpo_elastic_tensor", SymmetricTensor<2,6>::n_independent_components);
+        return property_information;
+      }
+
+
+
+      template <int dim>
+      void
+      CpoElasticTensor<dim>::declare_parameters (ParameterHandler &)
+      {}
+
+
+
+      template <int dim>
+      void
+      CpoElasticTensor<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Crystal Preferred Orientation");
+        {
+          n_grains = prm.get_integer("Number of grains per particle");
+          prm.enter_subsection("Initial grains");
+          {
+            n_minerals = dealii::Utilities::split_string_list(prm.get("Minerals")).size();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(CpoElasticTensor,
+                                        "cpo elastic tensor",
+                                        "A plugin in which the particle property tensor is "
+                                        "defined as the Voigt average of the "
+                                        "elastic tensors of the minerals in the textured rock."
+                                        "Currently only Olivine and Enstatite are supported.")
+    }
+  }
+}
diff --git a/source/particle/property/crystal_preferred_orientation.cc b/source/particle/property/crystal_preferred_orientation.cc
index 3f849f0ca4d..58aab2dfdcb 100644
--- a/source/particle/property/crystal_preferred_orientation.cc
+++ b/source/particle/property/crystal_preferred_orientation.cc
@@ -139,7 +139,7 @@ namespace aspect
         //
         // Note that we store exactly the same number of grains of all minerals (e.g. olivine and enstatite
         // grains), although their volume fractions may not be the same. We need a minimum amount
-        // of grains per tracer to perform reliable statistics on it. This minimum is the same for all phases.
+        // of grains per particle to perform reliable statistics on it. This minimum is the same for all phases.
         // and enstatite.
         //
         // Furthermore, for this plugin the following dims are always 3. When using 2d an infinitely thin 3d domain is assumed.
diff --git a/source/particle/property/crystal_preferred_orientation.cc.bak b/source/particle/property/crystal_preferred_orientation.cc.bak
new file mode 100644
index 00000000000..3f849f0ca4d
--- /dev/null
+++ b/source/particle/property/crystal_preferred_orientation.cc.bak
@@ -0,0 +1,1275 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/crystal_preferred_orientation.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/citation_info.h>
+#include <aspect/utilities.h>
+
+#include <world_builder/grains.h>
+#include <world_builder/world.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+
+      template <int dim>
+      void
+      CrystalPreferredOrientation<dim>::initialize ()
+      {
+        CitationInfo::add("CPO");
+        const unsigned int my_rank = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
+        this->random_number_generator.seed(random_number_seed+my_rank);
+
+        // Don't assert when called by the unit tester.
+        if (this->simulator_is_past_initialization())
+          {
+            AssertThrow(this->introspection().compositional_name_exists("water"),
+                        ExcMessage("Particle property CPO only works if"
+                                   "there is a compositional field called water."));
+            water_index = this->introspection().compositional_index_for_name("water");
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      CrystalPreferredOrientation<dim>::compute_random_rotation_matrix(Tensor<2,3> &rotation_matrix) const
+      {
+
+        // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
+        // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
+        // and is licenced according to this website with the following licence:
+        //
+        // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
+        // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
+        // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
+        // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
+        // don't be a jerk, and remember that anything free comes with no guarantee.""
+        //
+        // The book states in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
+        // the public domain, and is yours to study, modify, and use."
+
+        // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
+
+        boost::random::uniform_real_distribution<double> uniform_distribution(0,1);
+        double one = uniform_distribution(this->random_number_generator);
+        double two = uniform_distribution(this->random_number_generator);
+        double three = uniform_distribution(this->random_number_generator);
+
+        double theta = 2.0 * M_PI * one; // Rotation about the pole (Z)
+        double phi = 2.0 * M_PI * two; // For direction of pole deflection.
+        double z = 2.0* three; //For magnitude of pole deflection.
+
+        // Compute a vector V used for distributing points over the sphere
+        // via the reflection I - V Transpose(V).  This formulation of V
+        // will guarantee that if x[1] and x[2] are uniformly distributed,
+        // the reflected points will be uniform on the sphere.  Note that V
+        // has length sqrt(2) to eliminate the 2 in the Householder matrix.
+
+        double r  = std::sqrt( z );
+        double Vx = std::sin( phi ) * r;
+        double Vy = std::cos( phi ) * r;
+        double Vz = std::sqrt( 2.f - z );
+
+        // Compute the row vector S = Transpose(V) * R, where R is a simple
+        // rotation by theta about the z-axis.  No need to compute Sz since
+        // it's just Vz.
+
+        double st = std::sin( theta );
+        double ct = std::cos( theta );
+        double Sx = Vx * ct - Vy * st;
+        double Sy = Vx * st + Vy * ct;
+
+        // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
+        // is equivalent to V S - R.
+
+        rotation_matrix[0][0] = Vx * Sx - ct;
+        rotation_matrix[0][1] = Vx * Sy - st;
+        rotation_matrix[0][2] = Vx * Vz;
+        rotation_matrix[1][0] = Vy * Sx + st;
+        rotation_matrix[1][1] = Vy * Sy - ct;
+        rotation_matrix[1][2] = Vy * Vz;
+        rotation_matrix[2][0] = Vz * Sx;
+        rotation_matrix[2][1] = Vz * Sy;
+        rotation_matrix[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
+      }
+
+
+
+      template <int dim>
+      void
+      CrystalPreferredOrientation<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                                         std::vector<double> &data) const
+      {
+        // the layout of the data vector per particle is the following:
+        // 1. M mineral times
+        //    1.1  olivine deformation type   -> 1 double, at location
+        //                                      => data_position + 0 + mineral_i * (n_grains * 10 + 2)
+        //    2.1. Mineral volume fraction    -> 1 double, at location
+        //                                      => data_position + 1 + mineral_i *(n_grains * 10 + 2)
+        //    2.2. N grains times:
+        //         2.1. volume fraction grain -> 1 double, at location:
+        //                                      => data_position + 2 + i_grain * 10 + mineral_i *(n_grains * 10 + 2), or
+        //                                      => data_position + 2 + i_grain * (2 * Tensor<2,3>::n_independent_components+ 2) + mineral_i * (n_grains * 10 + 2)
+        //         2.2. rotation matrix grain -> 9 (Tensor<2,dim>::n_independent_components) doubles, starts at:
+        //                                      => data_position + 3 + i_grain * 10 + mineral_i * (n_grains * 10 + 2), or
+        //                                      => data_position + 3 + i_grain * (2 * Tensor<2,3>::n_independent_components+ 2) + mineral_i * (n_grains * 10 + 2)
+        //
+        // Note that we store exactly the same number of grains of all minerals (e.g. olivine and enstatite
+        // grains), although their volume fractions may not be the same. We need a minimum amount
+        // of grains per tracer to perform reliable statistics on it. This minimum is the same for all phases.
+        // and enstatite.
+        //
+        // Furthermore, for this plugin the following dims are always 3. When using 2d an infinitely thin 3d domain is assumed.
+        //
+        // The rotation matrix is a direction cosine matrix, representing the orientation of the grain in the domain.
+        // The fabric is determined later in the computations, so initialize it to -1.
+        std::vector<double> deformation_type(n_minerals, -1.0);
+        std::vector<std::vector<double >>volume_fractions_grains(n_minerals);
+        std::vector<std::vector<Tensor<2,3>>> rotation_matrices_grains(n_minerals);
+
+        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
+          {
+            volume_fractions_grains[mineral_i].resize(n_grains);
+            rotation_matrices_grains[mineral_i].resize(n_grains);
+
+            // This will be set by the initial grain subsection.
+            if (initial_grains_model == CPOInitialGrainsModel::world_builder)
+              {
+#ifdef ASPECT_WITH_WORLD_BUILDER
+                WorldBuilder::grains wb_grains = this->get_world_builder().grains(Utilities::convert_point_to_array(position),
+                                                                                  -this->get_geometry_model().height_above_reference_surface(position),
+                                                                                  mineral_i,
+                                                                                  n_grains);
+                double sum_volume_fractions = 0;
+                for (unsigned int grain_i = 0; grain_i < n_grains ; ++grain_i)
+                  {
+                    sum_volume_fractions += wb_grains.sizes[grain_i];
+                    volume_fractions_grains[mineral_i][grain_i] = wb_grains.sizes[grain_i];
+                    // we are receiving a array<array<double,3>,3> from the world builder,
+                    // which needs to be copied in the correct way into a tensor<2,3>.
+                    for (unsigned int component_i = 0; component_i < 3 ; ++component_i)
+                      {
+                        for (unsigned int component_j = 0; component_j < 3 ; ++component_j)
+                          {
+                            Assert(!std::isnan(wb_grains.rotation_matrices[grain_i][component_i][component_j]), ExcMessage("Error: not a number."));
+                            rotation_matrices_grains[mineral_i][grain_i][component_i][component_j] = wb_grains.rotation_matrices[grain_i][component_i][component_j];
+                          }
+                      }
+                  }
+
+                AssertThrow(sum_volume_fractions != 0, ExcMessage("Sum of volumes is equal to zero, which is not supposed to happen. "
+                                                                  "Make sure that all parts of the domain which contain particles are covered by the world builder."));
+#else
+                AssertThrow(false,
+                            ExcMessage("The world builder was requested but not provided. Make sure that aspect is "
+                                       "compiled with the World Builder and that you provide a world builder file in the input."));
+#endif
+              }
+            else
+              {
+                // set volume fraction
+                const double initial_volume_fraction = 1.0/n_grains;
+
+                for (unsigned int grain_i = 0; grain_i < n_grains ; ++grain_i)
+                  {
+                    // set volume fraction
+                    volume_fractions_grains[mineral_i][grain_i] = initial_volume_fraction;
+
+                    // set a uniform random rotation_matrix per grain
+                    this->compute_random_rotation_matrix(rotation_matrices_grains[mineral_i][grain_i]);
+                  }
+              }
+          }
+
+        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
+          {
+            data.emplace_back(deformation_type[mineral_i]);
+            data.emplace_back(volume_fractions_minerals[mineral_i]);
+            for (unsigned int grain_i = 0; grain_i < n_grains ; ++grain_i)
+              {
+                data.emplace_back(volume_fractions_grains[mineral_i][grain_i]);
+                for (unsigned int i = 0; i < Tensor<2,3>::n_independent_components ; ++i)
+                  {
+                    const dealii::TableIndices<2> index = Tensor<2,3>::unrolled_to_component_indices(i);
+                    data.emplace_back(rotation_matrices_grains[mineral_i][grain_i][index]);
+                  }
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      CrystalPreferredOrientation<dim>::update_particle_property(const unsigned int data_position,
+                                                                 const Vector<double> &solution,
+                                                                 const std::vector<Tensor<1,dim>> &gradients,
+                                                                 typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        // STEP 1: Load data and preprocess it.
+
+        // need access to the pressure, viscosity,
+        // get velocity
+        Tensor<1,dim> velocity;
+        for (unsigned int i = 0; i < dim; ++i)
+          velocity[i] = solution[this->introspection().component_indices.velocities[i]];
+
+        // get velocity gradient tensor.
+        Tensor<2,dim> velocity_gradient;
+        for (unsigned int i = 0; i < dim; ++i)
+          velocity_gradient[i] = gradients[this->introspection().component_indices.velocities[i]];
+
+        // Calculate strain rate from velocity gradients
+        const SymmetricTensor<2,dim> strain_rate = symmetrize (velocity_gradient);
+        const SymmetricTensor<2,dim> deviatoric_strain_rate
+          = (this->get_material_model().is_compressible()
+             ?
+             strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
+             :
+             strain_rate);
+
+        const double pressure = solution[this->introspection().component_indices.pressure];
+        const double temperature = solution[this->introspection().component_indices.temperature];
+        const double water_content = solution[this->introspection().component_indices.compositional_fields[water_index]];
+
+        // get the composition of the particle
+        std::vector<double> compositions;
+        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
+          {
+            const unsigned int solution_component = this->introspection().component_indices.compositional_fields[i];
+            compositions.push_back(solution[solution_component]);
+          }
+
+        const double dt = this->get_timestep();
+
+        // even in 2d we need 3d strain-rates and velocity gradient tensors. So we make them 3d by
+        // adding an extra dimension which is zero.
+        SymmetricTensor<2,3> strain_rate_3d;
+        strain_rate_3d[0][0] = strain_rate[0][0];
+        strain_rate_3d[0][1] = strain_rate[0][1];
+        //sym: strain_rate_3d[1][0] = strain_rate[1][0];
+        strain_rate_3d[1][1] = strain_rate[1][1];
+
+        if (dim == 3)
+          {
+            strain_rate_3d[0][2] = strain_rate[0][2];
+            strain_rate_3d[1][2] = strain_rate[1][2];
+            //sym: strain_rate_3d[2][0] = strain_rate[0][2];
+            //sym: strain_rate_3d[2][1] = strain_rate[1][2];
+            strain_rate_3d[2][2] = strain_rate[2][2];
+          }
+        Tensor<2,3> velocity_gradient_3d;
+        velocity_gradient_3d[0][0] = velocity_gradient[0][0];
+        velocity_gradient_3d[0][1] = velocity_gradient[0][1];
+        velocity_gradient_3d[1][0] = velocity_gradient[1][0];
+        velocity_gradient_3d[1][1] = velocity_gradient[1][1];
+        if (dim == 3)
+          {
+            velocity_gradient_3d[0][2] = velocity_gradient[0][2];
+            velocity_gradient_3d[1][2] = velocity_gradient[1][2];
+            velocity_gradient_3d[2][0] = velocity_gradient[2][0];
+            velocity_gradient_3d[2][1] = velocity_gradient[2][1];
+            velocity_gradient_3d[2][2] = velocity_gradient[2][2];
+          }
+
+        ArrayView<double> data = particle->get_properties();
+
+        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
+          {
+
+            /**
+            * Now we have loaded all the data and can do the actual computation.
+            * The computation consists of two parts. The first part is computing
+            * the derivatives for the directions and grain sizes. Then those
+            * derivatives are used to advect the particle properties.
+            */
+            double sum_volume_mineral = 0;
+            std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
+            derivatives_grains = this->compute_derivatives(data_position,
+                                                           data,
+                                                           mineral_i,
+                                                           strain_rate_3d,
+                                                           velocity_gradient_3d,
+                                                           particle->get_location(),
+                                                           temperature,
+                                                           pressure,
+                                                           velocity,
+                                                           compositions,
+                                                           strain_rate,
+                                                           deviatoric_strain_rate,
+                                                           water_content);
+
+            switch (advection_method)
+              {
+                case AdvectionMethod::forward_euler:
+
+                  sum_volume_mineral = this->advect_forward_euler(data_position,
+                                                                  data,
+                                                                  mineral_i,
+                                                                  dt,
+                                                                  derivatives_grains);
+
+                  break;
+
+                case AdvectionMethod::backward_euler:
+                  sum_volume_mineral = this->advect_backward_euler(data_position,
+                                                                   data,
+                                                                   mineral_i,
+                                                                   dt,
+                                                                   derivatives_grains);
+
+                  break;
+              }
+
+            // normalize the volume fractions back to a total of 1 for each mineral
+            const double inv_sum_volume_mineral = 1.0/sum_volume_mineral;
+
+            Assert(std::isfinite(inv_sum_volume_mineral),
+                   ExcMessage("inv_sum_volume_mineral is not finite. sum_volume_enstatite = "
+                              + std::to_string(sum_volume_mineral)));
+
+            for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
+              {
+                const double volume_fraction_grains = get_volume_fractions_grains(data_position,data,mineral_i,grain_i)*inv_sum_volume_mineral;
+                set_volume_fractions_grains(data_position,data,mineral_i,grain_i,volume_fraction_grains);
+                Assert(isfinite(get_volume_fractions_grains(data_position,data,mineral_i,grain_i)),
+                       ExcMessage("volume_fractions_grains[mineral_i]" + std::to_string(grain_i) + "] is not finite: "
+                                  + std::to_string(get_volume_fractions_grains(data_position,data,mineral_i,grain_i)) + ", inv_sum_volume_mineral = "
+                                  + std::to_string(inv_sum_volume_mineral) + "."));
+
+                /**
+                 * Correct direction rotation matrices numerical error (orthnormality) after integration
+                 * Follows same method as in matlab version from Thissen (see https://github.com/cthissen/Drex-MATLAB/)
+                 * of finding the nearest orthonormal matrix using the SVD
+                 */
+                Tensor<2,3> rotation_matrix = get_rotation_matrix_grains(data_position,data,mineral_i,grain_i);
+                for (size_t i = 0; i < 3; ++i)
+                  {
+                    for (size_t j = 0; j < 3; ++j)
+                      {
+                        Assert(!std::isnan(rotation_matrix[i][j]), ExcMessage("rotation_matrix is nan before orthogonalization."));
+                      }
+                  }
+
+                rotation_matrix = dealii::project_onto_orthogonal_tensors(rotation_matrix);
+                for (size_t i = 0; i < 3; ++i)
+                  for (size_t j = 0; j < 3; ++j)
+                    {
+                      // I don't think this should happen with the projection, but D-Rex
+                      // does not do the orthogonal projection, but just clamps the values
+                      // to 1 and -1.
+                      Assert(std::fabs(rotation_matrix[i][j]) <= 1.0,
+                             ExcMessage("The rotation_matrix has a entry larger than 1."));
+
+                      Assert(!std::isnan(rotation_matrix[i][j]),
+                             ExcMessage("rotation_matrix is nan after orthoganalization: "
+                                        + std::to_string(rotation_matrix[i][j])));
+
+                      Assert(abs(rotation_matrix[i][j]) <= 1.0,
+                             ExcMessage("3. rotation_matrix[" + std::to_string(i) + "][" + std::to_string(j) +
+                                        "] is larger than one: "
+                                        + std::to_string(rotation_matrix[i][j]) + " (" + std::to_string(rotation_matrix[i][j]-1.0) + "). rotation_matrix = \n"
+                                        + std::to_string(rotation_matrix[0][0]) + " " + std::to_string(rotation_matrix[0][1]) + " " + std::to_string(rotation_matrix[0][2]) + "\n"
+                                        + std::to_string(rotation_matrix[1][0]) + " " + std::to_string(rotation_matrix[1][1]) + " " + std::to_string(rotation_matrix[1][2]) + "\n"
+                                        + std::to_string(rotation_matrix[2][0]) + " " + std::to_string(rotation_matrix[2][1]) + " " + std::to_string(rotation_matrix[2][2])));
+                    }
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      CrystalPreferredOrientation<dim>::need_update() const
+      {
+        return update_time_step;
+      }
+
+
+
+      template <int dim>
+      InitializationModeForLateParticles
+      CrystalPreferredOrientation<dim>::late_initialization_mode () const
+      {
+        return InitializationModeForLateParticles::interpolate;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      CrystalPreferredOrientation<dim>::get_needed_update_flags () const
+      {
+        return update_values | update_gradients;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      CrystalPreferredOrientation<dim>::get_property_information() const
+      {
+        std::vector<std::pair<std::string,unsigned int>> property_information;
+        property_information.reserve(n_minerals * n_grains * (1+Tensor<2,3>::n_independent_components));
+
+        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
+          {
+            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " type",1);
+            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " volume fraction",1);
+
+            for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
+              {
+                property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " grain " + std::to_string(grain_i) + " volume fraction",1);
+
+                for (unsigned int index = 0; index < Tensor<2,3>::n_independent_components; ++index)
+                  {
+                    property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " grain " + std::to_string(grain_i) + " rotation_matrix " + std::to_string(index),1);
+                  }
+              }
+          }
+
+        return property_information;
+      }
+
+
+
+      template <int dim>
+      double
+      CrystalPreferredOrientation<dim>::advect_forward_euler(const unsigned int cpo_index,
+                                                             const ArrayView<double> &data,
+                                                             const unsigned int mineral_i,
+                                                             const double dt,
+                                                             const std::pair<std::vector<double>, std::vector<Tensor<2,3>>> &derivatives) const
+      {
+        double sum_volume_fractions = 0;
+        Tensor<2,3> rotation_matrix;
+        for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
+          {
+            // Do the volume fraction of the grain
+            Assert(std::isfinite(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i)),ExcMessage("volume_fractions[grain_i] is not finite before it is set."));
+            double volume_fraction_grains = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
+            volume_fraction_grains =  volume_fraction_grains + dt * volume_fraction_grains * derivatives.first[grain_i];
+            set_volume_fractions_grains(cpo_index,data,mineral_i,grain_i, volume_fraction_grains);
+            Assert(std::isfinite(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i)),ExcMessage("volume_fractions[grain_i] is not finite. grain_i = "
+                   + std::to_string(grain_i) + ", volume_fractions[grain_i] = " + std::to_string(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i))
+                   + ", derivatives.first[grain_i] = " + std::to_string(derivatives.first[grain_i])));
+
+            sum_volume_fractions += get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
+
+            // Do the rotation matrix for this grain
+            rotation_matrix = get_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i);
+            rotation_matrix += dt * rotation_matrix * derivatives.second[grain_i];
+            set_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i,rotation_matrix);
+          }
+
+        Assert(sum_volume_fractions != 0, ExcMessage("The sum of all grain volume fractions of a mineral is equal to zero. This should not happen."));
+        return sum_volume_fractions;
+      }
+
+
+
+      template <int dim>
+      double
+      CrystalPreferredOrientation<dim>::advect_backward_euler(const unsigned int cpo_index,
+                                                              const ArrayView<double> &data,
+                                                              const unsigned int mineral_i,
+                                                              const double dt,
+                                                              const std::pair<std::vector<double>, std::vector<Tensor<2,3>>> &derivatives) const
+      {
+        double sum_volume_fractions = 0;
+        Tensor<2,3> cosine_ref;
+        for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
+          {
+            // Do the volume fraction of the grain
+            double vf_old = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
+            double vf_new = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
+            Assert(std::isfinite(vf_new),ExcMessage("vf_new is not finite before it is set."));
+            for (size_t iteration = 0; iteration < property_advection_max_iterations; ++iteration)
+              {
+                Assert(std::isfinite(vf_new),ExcMessage("vf_new is not finite before it is set. grain_i = "
+                                                        + std::to_string(grain_i) + ", volume_fractions[grain_i] = " + std::to_string(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i))
+                                                        + ", derivatives.first[grain_i] = " + std::to_string(derivatives.first[grain_i])));
+
+                vf_new = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i) + dt * vf_new * derivatives.first[grain_i];
+
+                Assert(std::isfinite(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i)),ExcMessage("volume_fractions[grain_i] is not finite. grain_i = "
+                       + std::to_string(grain_i) + ", volume_fractions[grain_i] = " + std::to_string(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i))
+                       + ", derivatives.first[grain_i] = " + std::to_string(derivatives.first[grain_i])));
+                if (std::fabs(vf_new-vf_old) < property_advection_tolerance)
+                  {
+                    break;
+                  }
+                vf_old = vf_new;
+              }
+
+            set_volume_fractions_grains(cpo_index,data,mineral_i,grain_i,vf_new);
+            sum_volume_fractions += vf_new;
+
+            // Do the rotation matrix for this grain
+            cosine_ref = get_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i);
+            Tensor<2,3> cosine_old = cosine_ref;
+            Tensor<2,3> cosine_new = cosine_ref;
+
+            for (size_t iteration = 0; iteration < property_advection_max_iterations; ++iteration)
+              {
+                cosine_new = cosine_ref + dt * cosine_new * derivatives.second[grain_i];
+
+                if ((cosine_new-cosine_old).norm() < property_advection_tolerance)
+                  {
+                    break;
+                  }
+                cosine_old = cosine_new;
+              }
+
+            set_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i,cosine_new);
+
+          }
+
+
+        Assert(sum_volume_fractions != 0, ExcMessage("The sum of all grain volume fractions of a mineral is equal to zero. This should not happen."));
+        return sum_volume_fractions;
+      }
+
+
+
+      template <int dim>
+      std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
+      CrystalPreferredOrientation<dim>::compute_derivatives(const unsigned int cpo_index,
+                                                            const ArrayView<double> &data,
+                                                            const unsigned int mineral_i,
+                                                            const SymmetricTensor<2,3> &strain_rate_3d,
+                                                            const Tensor<2,3> &velocity_gradient_tensor,
+                                                            const Point<dim> &position,
+                                                            const double temperature,
+                                                            const double pressure,
+                                                            const Tensor<1,dim> &velocity,
+                                                            const std::vector<double> &compositions,
+                                                            const SymmetricTensor<2,dim> &strain_rate,
+                                                            const SymmetricTensor<2,dim> &deviatoric_strain_rate,
+                                                            const double water_content) const
+      {
+        std::pair<std::vector<double>, std::vector<Tensor<2,3>>> derivatives;
+        switch (cpo_derivative_algorithm)
+          {
+            case CPODerivativeAlgorithm::spin_tensor:
+            {
+              return compute_derivatives_spin_tensor(velocity_gradient_tensor);
+              break;
+            }
+            case CPODerivativeAlgorithm::drex_2004:
+            {
+
+              const DeformationType deformation_type = determine_deformation_type(deformation_type_selector[mineral_i],
+                                                                                  position,
+                                                                                  temperature,
+                                                                                  pressure,
+                                                                                  velocity,
+                                                                                  compositions,
+                                                                                  strain_rate,
+                                                                                  deviatoric_strain_rate,
+                                                                                  water_content);
+
+              set_deformation_type(cpo_index,data,mineral_i,deformation_type);
+
+              const std::array<double,4> ref_resolved_shear_stress = reference_resolved_shear_stress_from_deformation_type(deformation_type);
+
+              return compute_derivatives_drex_2004(cpo_index,
+                                                   data,
+                                                   mineral_i,
+                                                   strain_rate_3d,
+                                                   velocity_gradient_tensor,
+                                                   ref_resolved_shear_stress);
+              break;
+            }
+            default:
+              AssertThrow(false, ExcMessage("Internal error."));
+              break;
+          }
+        AssertThrow(false, ExcMessage("Internal error."));
+        return derivatives;
+      }
+
+
+
+      template <int dim>
+      std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
+      CrystalPreferredOrientation<dim>::compute_derivatives_spin_tensor(const Tensor<2,3> &velocity_gradient_tensor) const
+      {
+        // dA/dt = W * A, where W is the spin tensor and A is the rotation matrix
+        // The spin tensor is defined as W = 0.5 * ( L - L^T ), where L is the velocity gradient tensor.
+        const Tensor<2,3> spin_tensor = -0.5 *(velocity_gradient_tensor - dealii::transpose(velocity_gradient_tensor));
+
+        return std::pair<std::vector<double>, std::vector<Tensor<2,3>>>(std::vector<double>(n_grains,0.0), std::vector<Tensor<2,3>>(n_grains, spin_tensor));
+      }
+
+
+      template <int dim>
+      std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
+      CrystalPreferredOrientation<dim>::compute_derivatives_drex_2004(const unsigned int cpo_index,
+                                                                      const ArrayView<double> &data,
+                                                                      const unsigned int mineral_i,
+                                                                      const SymmetricTensor<2,3> &strain_rate_3d,
+                                                                      const Tensor<2,3> &velocity_gradient_tensor,
+                                                                      const std::array<double,4> ref_resolved_shear_stress,
+                                                                      const bool prevent_nondimensionalization) const
+      {
+        // This if statement is only there for the unit test. In normal situations it should always be set to false,
+        // because the nondimensionalization should always be done (in this exact way), unless you really know what
+        // you are doing.
+        double nondimensionalization_value = 1.0;
+        if (!prevent_nondimensionalization)
+          {
+            const std::array< double, 3 > eigenvalues = dealii::eigenvalues(strain_rate_3d);
+            nondimensionalization_value = std::max(std::abs(eigenvalues[0]),std::abs(eigenvalues[2]));
+
+            Assert(!std::isnan(nondimensionalization_value), ExcMessage("The second invariant of the strain rate is not a number."));
+          }
+
+
+        // Make the strain-rate and velocity gradient tensor non-dimensional
+        // by dividing it through the second invariant
+        const Tensor<2,3> strain_rate_nondimensional = nondimensionalization_value != 0 ? strain_rate_3d/nondimensionalization_value : strain_rate_3d;
+        const Tensor<2,3> velocity_gradient_tensor_nondimensional = nondimensionalization_value != 0 ? velocity_gradient_tensor/nondimensionalization_value : velocity_gradient_tensor;
+
+        // create output variables
+        std::vector<double> deriv_volume_fractions(n_grains);
+        std::vector<Tensor<2,3>> deriv_a_cosine_matrices(n_grains);
+
+        // create shortcuts
+        const std::array<double, 4> &tau = ref_resolved_shear_stress;
+
+        std::vector<double> strain_energy(n_grains);
+        double mean_strain_energy = 0;
+
+        for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
+          {
+            // Compute the Schmidt tensor for this grain (nu), s is the slip system.
+            // We first compute beta_s,nu (equation 5, Kaminski & Ribe, 2001)
+            // Then we use the beta to calculate the Schmidt tensor G_{ij} (Eq. 5, Kaminski & Ribe, 2001)
+            Tensor<2,3> G;
+            Tensor<1,3> w;
+            Tensor<1,4> beta({1.0, 1.0, 1.0, 1.0});
+            std::array<Tensor<1,3>,4> slip_normal_reference {{Tensor<1,3>({0,1,0}),Tensor<1,3>({0,0,1}),Tensor<1,3>({0,1,0}),Tensor<1,3>({1,0,0})}};
+            std::array<Tensor<1,3>,4> slip_direction_reference {{Tensor<1,3>({1,0,0}),Tensor<1,3>({1,0,0}),Tensor<1,3>({0,0,1}),Tensor<1,3>({0,0,1})}};
+
+            // these are variables we only need for olivine, but we need them for both
+            // within this if block and the next ones
+            // Ordered vector where the first entry is the max/weakest and the last entry is the inactive slip system.
+            std::array<unsigned int,4> indices {};
+
+            // compute G and beta
+            Tensor<1,4> bigI;
+            const Tensor<2,3> rotation_matrix = get_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i);
+            const Tensor<2,3> rotation_matrix_transposed = transpose(rotation_matrix);
+            for (unsigned int slip_system_i = 0; slip_system_i < 4; ++slip_system_i)
+              {
+                const Tensor<1,3> slip_normal_global = rotation_matrix_transposed*slip_normal_reference[slip_system_i];
+                const Tensor<1,3> slip_direction_global = rotation_matrix_transposed*slip_direction_reference[slip_system_i];
+                const Tensor<2,3> slip_cross_product = outer_product(slip_direction_global,slip_normal_global);
+                bigI[slip_system_i] = scalar_product(slip_cross_product,strain_rate_nondimensional);
+              }
+
+            if (bigI.norm() < 1e-10)
+              {
+                // In this case there is no shear, only (possibly) a rotation. So \gamma_y and/or G should be zero.
+                // Which is the default value, so do nothing.
+              }
+            else
+              {
+                // compute the element wise absolute value of the element wise
+                // division of BigI by tau (tau = ref_resolved_shear_stress).
+                std::array<double,4> q_abs;
+                for (unsigned int i = 0; i < 4; ++i)
+                  {
+                    q_abs[i] = std::abs(bigI[i] / tau[i]);
+                  }
+
+                // here we find the indices starting at the largest value and ending at the smallest value
+                // and assign them to special variables. Because all the variables are absolute values,
+                // we can set them to a negative value to ignore them. This should be faster then deleting
+                // the element, which would require allocation. (not tested)
+                for (unsigned int slip_system_i = 0; slip_system_i < 4; ++slip_system_i)
+                  {
+                    indices[slip_system_i] = std::distance(q_abs.begin(),std::max_element(q_abs.begin(), q_abs.end()));
+                    q_abs[indices[slip_system_i]] = -1;
+                  }
+
+                // compute the ordered beta vector, which is the relative slip rates of the active slip systems.
+                // Test whether the max element is not equal to zero.
+                Assert(bigI[indices[0]] != 0.0, ExcMessage("Internal error: bigI is zero."));
+                beta[indices[0]] = 1.0; // max q_abs, weak system (most deformation) "s=1"
+
+                const double ratio = tau[indices[0]]/bigI[indices[0]];
+                for (unsigned int slip_system_i = 1; slip_system_i < 4-1; ++slip_system_i)
+                  {
+                    beta[indices[slip_system_i]] = std::pow(std::abs(ratio * (bigI[indices[slip_system_i]]/tau[indices[slip_system_i]])), stress_exponent);
+                  }
+                beta[indices.back()] = 0.0;
+
+                // Now compute the crystal rate of deformation tensor. equation 4 of Kaminski&Ribe 2001
+                // rotation_matrix_transposed = inverse of rotation matrix
+                // (see Engler et al., 2024 book: Intro to Texture analysis chp 2.3.2 The Rotation Matrix)
+                // this transform the crystal reference frame to specimen reference frame
+                for (unsigned int slip_system_i = 0; slip_system_i < 4; ++slip_system_i)
+                  {
+                    const Tensor<1,3> slip_normal_global = rotation_matrix_transposed*slip_normal_reference[slip_system_i];
+                    const Tensor<1,3> slip_direction_global = rotation_matrix_transposed*slip_direction_reference[slip_system_i];
+                    const Tensor<2,3> slip_cross_product = outer_product(slip_direction_global,slip_normal_global);
+                    G += 2.0 * beta[slip_system_i] * slip_cross_product;
+                  }
+              }
+
+            // Now calculate the analytic solution to the deformation minimization problem
+            // compute gamma (equation 7, Kaminiski & Ribe, 2001)
+
+            // Top is the numerator and bottom is the denominator in equation 7.
+            double top = 0;
+            double bottom = 0;
+            for (unsigned int i = 0; i < 3; ++i)
+              {
+                // Following the actual Drex implementation we use i+2, which differs
+                // from the EPSL paper, which says gamma_nu depends on i+1
+                const unsigned int i_offset = (i==0) ? (i+2) : (i-1);
+
+                top = top - (velocity_gradient_tensor_nondimensional[i][i_offset]-velocity_gradient_tensor_nondimensional[i_offset][i])*(G[i][i_offset]-G[i_offset][i]);
+                bottom = bottom - (G[i][i_offset]-G[i_offset][i])*(G[i][i_offset]-G[i_offset][i]);
+
+                for (unsigned int j = 0; j < 3; ++j)
+                  {
+                    top = top + 2.0 * G[i][j]*velocity_gradient_tensor_nondimensional[i][j];
+                    bottom = bottom + 2.0* G[i][j] * G[i][j];
+                  }
+              }
+            // see comment on if all BigI are zero. In that case gamma should be zero.
+            const double gamma = (bottom != 0.0) ? top/bottom : 0.0;
+
+            // compute w (equation 8, Kaminiski & Ribe, 2001)
+            // w is the Rotation rate vector of the crystallographic axes of grain
+            w[0] = 0.5*(velocity_gradient_tensor_nondimensional[2][1]-velocity_gradient_tensor_nondimensional[1][2]) - 0.5*(G[2][1]-G[1][2])*gamma;
+            w[1] = 0.5*(velocity_gradient_tensor_nondimensional[0][2]-velocity_gradient_tensor_nondimensional[2][0]) - 0.5*(G[0][2]-G[2][0])*gamma;
+            w[2] = 0.5*(velocity_gradient_tensor_nondimensional[1][0]-velocity_gradient_tensor_nondimensional[0][1]) - 0.5*(G[1][0]-G[0][1])*gamma;
+
+            // Compute strain energy for this grain (abbreviated Estr)
+            // For olivine: DREX only sums over 1-3. But Christopher Thissen's matlab
+            // code (https://github.com/cthissen/Drex-MATLAB) corrected
+            // this and writes each term using the indices created when calculating bigI.
+            // Note tau = RRSS = (tau_m^s/tau_o), this why we get tau^(p-n)
+            for (unsigned int slip_system_i = 0; slip_system_i < 4; ++slip_system_i)
+              {
+                const double rhos = std::pow(tau[indices[slip_system_i]],exponent_p-stress_exponent) *
+                                    std::pow(std::abs(gamma*beta[indices[slip_system_i]]),exponent_p/stress_exponent);
+                strain_energy[grain_i] += rhos * std::exp(-nucleation_efficiency * rhos * rhos);
+
+                Assert(isfinite(strain_energy[grain_i]), ExcMessage("strain_energy[" + std::to_string(grain_i) + "] is not finite: " + std::to_string(strain_energy[grain_i])
+                                                                    + ", rhos (" + std::to_string(slip_system_i) + ") = " + std::to_string(rhos)
+                                                                    + ", nucleation_efficiency = " + std::to_string(nucleation_efficiency) + "."));
+              }
+
+
+            // compute the derivative of the rotation matrix: \frac{\partial a_{ij}}{\partial t}
+            // (Eq. 9, Kaminski & Ribe 2001)
+            deriv_a_cosine_matrices[grain_i] = 0;
+            const double volume_fraction_grain = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
+            if (volume_fraction_grain >= threshold_GBS/n_grains)
+              {
+                deriv_a_cosine_matrices[grain_i] = Utilities::Tensors::levi_civita<3>() * w * nondimensionalization_value;
+
+                // volume averaged strain energy
+                mean_strain_energy += volume_fraction_grain * strain_energy[grain_i];
+
+                Assert(isfinite(mean_strain_energy), ExcMessage("mean_strain_energy when adding grain " + std::to_string(grain_i) + " is not finite: " + std::to_string(mean_strain_energy)
+                                                                + ", volume_fraction_grain = " + std::to_string(volume_fraction_grain) + "."));
+              }
+            else
+              {
+                strain_energy[grain_i] = 0;
+              }
+          }
+
+        // Change of volume fraction of grains by grain boundary migration
+        for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
+          {
+            // Different than D-Rex. Here we actually only compute the derivative and do not multiply it with the volume_fractions. We do that when we advect.
+            deriv_volume_fractions[grain_i] = get_volume_fraction_mineral(cpo_index,data,mineral_i) * mobility * (mean_strain_energy - strain_energy[grain_i]) * nondimensionalization_value;
+
+            Assert(isfinite(deriv_volume_fractions[grain_i]),
+                   ExcMessage("deriv_volume_fractions[" + std::to_string(grain_i) + "] is not finite: "
+                              + std::to_string(deriv_volume_fractions[grain_i])));
+          }
+
+        return std::pair<std::vector<double>, std::vector<Tensor<2,3>>>(deriv_volume_fractions, deriv_a_cosine_matrices);
+      }
+
+
+      template <int dim>
+      DeformationType
+      CrystalPreferredOrientation<dim>::determine_deformation_type(const DeformationTypeSelector deformation_type_selector,
+                                                                   const Point<dim> &position,
+                                                                   const double temperature,
+                                                                   const double pressure,
+                                                                   const Tensor<1,dim> &velocity,
+                                                                   const std::vector<double> &compositions,
+                                                                   const SymmetricTensor<2,dim> &strain_rate,
+                                                                   const SymmetricTensor<2,dim> &deviatoric_strain_rate,
+                                                                   const double water_content) const
+      {
+        // Now compute what type of deformation takes place.
+        switch (deformation_type_selector)
+          {
+            case DeformationTypeSelector::passive:
+              return DeformationType::passive;
+            case DeformationTypeSelector::olivine_a_fabric:
+              return DeformationType::olivine_a_fabric;
+            case DeformationTypeSelector::olivine_b_fabric:
+              return DeformationType::olivine_b_fabric;
+            case DeformationTypeSelector::olivine_c_fabric:
+              return DeformationType::olivine_c_fabric;
+            case DeformationTypeSelector::olivine_d_fabric:
+              return DeformationType::olivine_d_fabric;
+            case DeformationTypeSelector::olivine_e_fabric:
+              return DeformationType::olivine_e_fabric;
+            case DeformationTypeSelector::enstatite:
+              return DeformationType::enstatite;
+            case DeformationTypeSelector::olivine_karato_2008:
+              // construct the material model inputs and outputs
+              // Since this function is only evaluating one particle,
+              // we use 1 for the amount of quadrature points.
+              MaterialModel::MaterialModelInputs<dim> material_model_inputs(1,this->n_compositional_fields());
+              material_model_inputs.position[0] = position;
+              material_model_inputs.temperature[0] = temperature;
+              material_model_inputs.pressure[0] = pressure;
+              material_model_inputs.velocity[0] = velocity;
+              material_model_inputs.composition[0] = compositions;
+              material_model_inputs.strain_rate[0] = strain_rate;
+
+              MaterialModel::MaterialModelOutputs<dim> material_model_outputs(1,this->n_compositional_fields());
+              this->get_material_model().evaluate(material_model_inputs, material_model_outputs);
+              double eta = material_model_outputs.viscosities[0];
+
+              const SymmetricTensor<2,dim> stress = 2*eta*deviatoric_strain_rate +
+                                                    pressure * unit_symmetric_tensor<dim>();
+              const std::array< double, dim > eigenvalues = dealii::eigenvalues(stress);
+              double differential_stress = eigenvalues[0]-eigenvalues[dim-1];
+              return determine_deformation_type_karato_2008(differential_stress, water_content);
+
+          }
+
+        AssertThrow(false, ExcMessage("Internal error. Deformation type not implemented."));
+        return DeformationType::passive;
+      }
+
+
+      template <int dim>
+      DeformationType
+      CrystalPreferredOrientation<dim>::determine_deformation_type_karato_2008(const double stress, const double water_content) const
+      {
+        constexpr double MPa = 1e6;
+        constexpr double ec_line_slope = -500./1050.;
+        if (stress > (380. - 0.05 * water_content)*MPa)
+          {
+            if (stress > (625. - 2.5 * water_content)*MPa)
+              {
+                return DeformationType::olivine_b_fabric;
+              }
+            else
+              {
+                return DeformationType::olivine_d_fabric;
+              }
+          }
+        else
+          {
+            if (stress < (625.0 -2.5 * water_content)*MPa)
+              {
+                return DeformationType::olivine_a_fabric;
+              }
+            else
+              {
+                if (stress < (500.0 + ec_line_slope*-100. + ec_line_slope * water_content)*MPa)
+                  {
+                    return DeformationType::olivine_e_fabric;
+                  }
+                else
+                  {
+                    return DeformationType::olivine_c_fabric;
+                  }
+              }
+          }
+      }
+
+
+      template <int dim>
+      std::array<double,4>
+      CrystalPreferredOrientation<dim>::reference_resolved_shear_stress_from_deformation_type(DeformationType deformation_type,
+          double max_value) const
+      {
+        std::array<double,4> ref_resolved_shear_stress;
+        switch (deformation_type)
+          {
+            // from Kaminski and Ribe, GJI 2004 and
+            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
+            case DeformationType::olivine_a_fabric :
+              ref_resolved_shear_stress[0] = 1;
+              ref_resolved_shear_stress[1] = 2;
+              ref_resolved_shear_stress[2] = 3;
+              ref_resolved_shear_stress[3] = max_value;
+              break;
+
+            // from Kaminski and Ribe, GJI 2004 and
+            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
+            case DeformationType::olivine_b_fabric :
+              ref_resolved_shear_stress[0] = 3;
+              ref_resolved_shear_stress[1] = 2;
+              ref_resolved_shear_stress[2] = 1;
+              ref_resolved_shear_stress[3] = max_value;
+              break;
+
+            // from Kaminski and Ribe, GJI 2004 and
+            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
+            case DeformationType::olivine_c_fabric :
+              ref_resolved_shear_stress[0] = 3;
+              ref_resolved_shear_stress[1] = max_value;
+              ref_resolved_shear_stress[2] = 2;
+              ref_resolved_shear_stress[3] = 1;
+              break;
+
+            // from Kaminski and Ribe, GRL 2002 and
+            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
+            case DeformationType::olivine_d_fabric :
+              ref_resolved_shear_stress[0] = 1;
+              ref_resolved_shear_stress[1] = 1;
+              ref_resolved_shear_stress[2] = 3;
+              ref_resolved_shear_stress[3] = max_value;
+              break;
+
+            // Kaminski, Ribe and Browaeys, GJI, 2004 (same as in the matlab code) and
+            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
+            case DeformationType::olivine_e_fabric :
+              ref_resolved_shear_stress[0] = 2;
+              ref_resolved_shear_stress[1] = 1;
+              ref_resolved_shear_stress[2] = max_value;
+              ref_resolved_shear_stress[3] = 3;
+              break;
+
+            // from Kaminski and Ribe, GJI 2004.
+            // Todo: this one is not used in practice, since there is an optimization in
+            // the code. So maybe remove it in the future.
+            case DeformationType::enstatite :
+              ref_resolved_shear_stress[0] = max_value;
+              ref_resolved_shear_stress[1] = max_value;
+              ref_resolved_shear_stress[2] = max_value;
+              ref_resolved_shear_stress[3] = 1;
+              break;
+
+            default:
+              AssertThrow(false,
+                          ExcMessage("Deformation type enum with number " + std::to_string(static_cast<unsigned int>(deformation_type))
+                                     + " was not found."));
+              break;
+          }
+        return ref_resolved_shear_stress;
+      }
+
+      template <int dim>
+      unsigned int
+      CrystalPreferredOrientation<dim>::get_number_of_grains() const
+      {
+        return n_grains;
+      }
+
+
+
+      template <int dim>
+      unsigned int
+      CrystalPreferredOrientation<dim>::get_number_of_minerals() const
+      {
+        return n_minerals;
+      }
+
+
+
+      template <int dim>
+      void
+      CrystalPreferredOrientation<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Crystal Preferred Orientation");
+        {
+          prm.declare_entry ("Random number seed", "1",
+                             Patterns::Integer (0),
+                             "The seed used to generate random numbers. This will make sure that "
+                             "results are reproducible as long as the problem is run with the "
+                             "same number of MPI processes. It is implemented as final seed = "
+                             "user seed + MPI Rank. ");
+
+          prm.declare_entry ("Number of grains per particle", "50",
+                             Patterns::Integer (1),
+                             "The number of grains of each different mineral "
+                             "each particle contains.");
+
+          prm.declare_entry ("Property advection method", "Backward Euler",
+                             Patterns::Anything(),
+                             "Options: Forward Euler, Backward Euler");
+
+          prm.declare_entry ("Property advection tolerance", "1e-10",
+                             Patterns::Double(0),
+                             "The Backward Euler property advection method involve internal iterations. "
+                             "This option allows for setting a tolerance. When the norm of tensor new - tensor old is "
+                             "smaller than this tolerance, the iteration is stopped.");
+
+          prm.declare_entry ("Property advection max iterations", "100",
+                             Patterns::Integer(0),
+                             "The Backward Euler property advection method involve internal iterations. "
+                             "This option allows for setting the maximum number of iterations. Note that when the iteration "
+                             "is ended by the max iteration amount an assert is thrown.");
+
+          prm.declare_entry ("CPO derivatives algorithm", "Spin tensor",
+                             Patterns::List(Patterns::Anything()),
+                             "Options: Spin tensor");
+
+          prm.enter_subsection("Initial grains");
+          {
+            prm.declare_entry("Model name","Uniform grains and random uniform rotations",
+                              Patterns::Anything(),
+                              "The model used to initialize the CPO for all particles. "
+                              "Currently 'Uniform grains and random uniform rotations' and 'World Builder' are the only valid option.");
+
+            prm.declare_entry ("Minerals", "Olivine: Karato 2008, Enstatite",
+                               Patterns::List(Patterns::Anything()),
+                               "This determines what minerals and fabrics or fabric selectors are used used for the LPO/CPO calculation. "
+                               "The options are Olivine: Passive, A-fabric, Olivine: B-fabric, Olivine: C-fabric, Olivine: D-fabric, "
+                               "Olivine: E-fabric, Olivine: Karato 2008 or Enstatite. Passive sets all RRSS entries to the maximum. The "
+                               "Karato 2008 selector selects a fabric based on stress and water content as defined in "
+                               "figure 4 of the Karato 2008 review paper (doi: 10.1146/annurev.earth.36.031207.124120).");
+
+
+            prm.declare_entry ("Volume fractions minerals", "0.7, 0.3",
+                               Patterns::List(Patterns::Double(0)),
+                               "The volume fractions for the different minerals. "
+                               "There need to be the same number of values as there are minerals."
+                               "Note that the currently implemented scheme is incompressible and "
+                               "does not allow chemical interaction or the formation of new phases");
+          }
+          prm.leave_subsection ();
+
+          prm.enter_subsection("D-Rex 2004");
+          {
+
+            prm.declare_entry ("Mobility", "50",
+                               Patterns::Double(0),
+                               "The dimensionless intrinsic grain boundary mobility for both olivine and enstatite.");
+
+            prm.declare_entry ("Volume fractions minerals", "0.5, 0.5",
+                               Patterns::List(Patterns::Double(0)),
+                               "The volume fraction for the different minerals. "
+                               "There need to be the same amount of values as there are minerals");
+
+            prm.declare_entry ("Stress exponents", "3.5",
+                               Patterns::Double(0),
+                               "This is the power law exponent that characterizes the rheology of the "
+                               "slip systems. It is used in equation 11 of Kaminski et al., 2004.");
+
+            prm.declare_entry ("Exponents p", "1.5",
+                               Patterns::Double(0),
+                               "This is exponent p as defined in equation 11 of Kaminski et al., 2004. ");
+
+            prm.declare_entry ("Nucleation efficiency", "5",
+                               Patterns::Double(0),
+                               "This is the dimensionless nucleation rate as defined in equation 8 of "
+                               "Kaminski et al., 2004. ");
+
+            prm.declare_entry ("Threshold GBS", "0.3",
+                               Patterns::Double(0),
+                               "The Dimensionless Grain Boundary Sliding (GBS) threshold. "
+                               "This is a grain size threshold below which grain deform by GBS and "
+                               "become strain-free grains.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection ();
+      }
+
+
+
+      template <int dim>
+      void
+      CrystalPreferredOrientation<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        AssertThrow(dim == 3, ExcMessage("CPO computations are currently only supported for 3d models. "
+                                         "2d computations will work when this assert is removed, but you will need to make sure that the "
+                                         "correct 3d strain-rate and velocity gradient tensors are provided to the algorithm."));
+
+        prm.enter_subsection("Crystal Preferred Orientation");
+        {
+          random_number_seed = prm.get_integer ("Random number seed");
+          n_grains = prm.get_integer("Number of grains per particle");
+
+          property_advection_tolerance = prm.get_double("Property advection tolerance");
+          property_advection_max_iterations = prm.get_integer ("Property advection max iterations");
+
+          const std::string temp_cpo_derivative_algorithm = prm.get("CPO derivatives algorithm");
+
+          if (temp_cpo_derivative_algorithm == "Spin tensor")
+            {
+              cpo_derivative_algorithm = CPODerivativeAlgorithm::spin_tensor;
+            }
+          else if (temp_cpo_derivative_algorithm ==  "D-Rex 2004")
+            {
+              cpo_derivative_algorithm = CPODerivativeAlgorithm::drex_2004;
+            }
+          else
+            {
+              AssertThrow(false,
+                          ExcMessage("The CPO derivatives algorithm needs to be one of the following: "
+                                     "Spin tensor, D-Rex 2004."));
+            }
+
+          const std::string temp_advection_method = prm.get("Property advection method");
+          if (temp_advection_method == "Forward Euler")
+            {
+              advection_method = AdvectionMethod::forward_euler;
+            }
+          else if (temp_advection_method == "Backward Euler")
+            {
+              advection_method = AdvectionMethod::backward_euler;
+            }
+          else
+            {
+              AssertThrow(false, ExcMessage("particle property advection method not found: \"" + temp_advection_method + "\""));
+            }
+
+          prm.enter_subsection("Initial grains");
+          {
+            const std::string model_name = prm.get("Model name");
+            if (model_name == "Uniform grains and random uniform rotations")
+              {
+                initial_grains_model = CPOInitialGrainsModel::uniform_grains_and_random_uniform_rotations;
+              }
+            else if (model_name == "World Builder")
+              {
+                initial_grains_model = CPOInitialGrainsModel::world_builder;
+              }
+            else
+              {
+                AssertThrow(false,
+                            ExcMessage("No model named " + model_name + "for CPO particle property initialization. "
+                                       + "Only the model \"Uniform grains and random uniform rotations\"  and "
+                                       "\"World Builder\" are available."));
+              }
+
+            const std::vector<std::string> temp_deformation_type_selector = dealii::Utilities::split_string_list(prm.get("Minerals"));
+            n_minerals = temp_deformation_type_selector.size();
+            deformation_type_selector.resize(n_minerals);
+
+            for (size_t mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
+              {
+                if (temp_deformation_type_selector[mineral_i] == "Passive")
+                  {
+                    deformation_type_selector[mineral_i] = DeformationTypeSelector::passive;
+                  }
+                else if (temp_deformation_type_selector[mineral_i] == "Olivine: Karato 2008")
+                  {
+                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_karato_2008;
+                  }
+                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: A-fabric")
+                  {
+                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_a_fabric;
+                  }
+                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: B-fabric")
+                  {
+                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_b_fabric;
+                  }
+                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: C-fabric")
+                  {
+                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_c_fabric;
+                  }
+                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: D-fabric")
+                  {
+                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_d_fabric;
+                  }
+                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: E-fabric")
+                  {
+                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_e_fabric;
+                  }
+                else if (temp_deformation_type_selector[mineral_i] ==  "Enstatite")
+                  {
+                    deformation_type_selector[mineral_i] = DeformationTypeSelector::enstatite;
+                  }
+                else
+                  {
+                    AssertThrow(false,
+                                ExcMessage("The fabric needs to be assigned one of the following comma-delimited values: Olivine: Karato 2008, "
+                                           "Olivine: A-fabric, Olivine: B-fabric, Olivine: C-fabric, Olivine: D-fabric,"
+                                           "Olivine: E-fabric, Enstatite, Passive."));
+                  }
+              }
+
+            volume_fractions_minerals = Utilities::string_to_double(dealii::Utilities::split_string_list(prm.get("Volume fractions minerals")));
+            double volume_fractions_minerals_sum = 0;
+            for (auto fraction : volume_fractions_minerals)
+              {
+                volume_fractions_minerals_sum += fraction;
+              }
+
+            AssertThrow(abs(volume_fractions_minerals_sum-1.0) < 2.0 * std::numeric_limits<double>::epsilon(),
+                        ExcMessage("The sum of the CPO volume fractions should be one."));
+          }
+          prm.leave_subsection();
+
+          prm.enter_subsection("D-Rex 2004");
+          {
+            mobility = prm.get_double("Mobility");
+            volume_fractions_minerals = Utilities::string_to_double(dealii::Utilities::split_string_list(prm.get("Volume fractions minerals")));
+            stress_exponent = prm.get_double("Stress exponents");
+            exponent_p = prm.get_double("Exponents p");
+            nucleation_efficiency = prm.get_double("Nucleation efficiency");
+            threshold_GBS = prm.get_double("Threshold GBS");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection ();
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(CrystalPreferredOrientation,
+                                        "crystal preferred orientation",
+                                        "WARNING: all the CPO plugins are a work in progress and not ready for production use yet. "
+                                        "See https://github.com/geodynamics/aspect/issues/3885 for current status and alternatives. "
+                                        "The plugin manages and computes the evolution of Lattice/Crystal Preferred Orientations (LPO/CPO) "
+                                        "on particles. Each ASPECT particle can be assigned many grains. Each grain is assigned a size and a orientation "
+                                        "matrix. This allows for CPO evolution tracking with polycrystalline kinematic CrystalPreferredOrientation evolution models such "
+                                        "as D-Rex (Kaminski and Ribe, 2001; Kaminski et al., 2004).")
+    }
+  }
+}
diff --git a/source/particle/property/elastic_stress.cc.bak b/source/particle/property/elastic_stress.cc.bak
new file mode 100644
index 00000000000..f0be9a72362
--- /dev/null
+++ b/source/particle/property/elastic_stress.cc.bak
@@ -0,0 +1,199 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/elastic_stress.h>
+#include <aspect/material_model/visco_plastic.h>
+#include <aspect/material_model/viscoelastic.h>
+#include <aspect/initial_composition/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      ElasticStress<dim>::ElasticStress ()
+        :
+        material_inputs(1,0),
+        material_outputs(1,0)
+      {}
+
+
+
+      template <int dim>
+      void
+      ElasticStress<dim>::initialize ()
+      {
+        material_inputs = MaterialModel::MaterialModelInputs<dim>(1, this->n_compositional_fields());
+
+        material_outputs = MaterialModel::MaterialModelOutputs<dim>(1, this->n_compositional_fields());
+
+        AssertThrow((Plugins::plugin_type_matches<const MaterialModel::ViscoPlastic<dim>>(this->get_material_model())
+                     ||
+                     Plugins::plugin_type_matches<const MaterialModel::Viscoelastic<dim>>(this->get_material_model())),
+                    ExcMessage("This particle property only makes sense in combination with the viscoelastic or visco_plastic material model."));
+
+        AssertThrow(this->get_parameters().enable_elasticity == true,
+                    ExcMessage ("This particle property should only be used if 'Enable elasticity' is set to true"));
+
+      }
+
+
+
+      template <int dim>
+      void
+      ElasticStress<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                           std::vector<double> &data) const
+      {
+        // Give each elastic stress field its initial composition if one is prescribed.
+        data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_xx")));
+
+        data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_yy")));
+
+        if (dim == 2)
+          {
+            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_xy")));
+          }
+        else if (dim == 3)
+          {
+            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_zz")));
+
+            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_xy")));
+
+            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_xz")));
+
+            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_yz")));
+          }
+
+      }
+
+
+
+      template <int dim>
+      void
+      ElasticStress<dim>::update_particle_property(const unsigned int data_position,
+                                                   const Vector<double> &solution,
+                                                   const std::vector<Tensor<1,dim>> &gradients,
+                                                   typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        material_inputs.position[0] = particle->get_location();
+
+
+        material_inputs.current_cell = typename DoFHandler<dim>::active_cell_iterator(*particle->get_surrounding_cell(),
+                                                                                      &(this->get_dof_handler()));
+
+        material_inputs.temperature[0] = solution[this->introspection().component_indices.temperature];
+
+        material_inputs.pressure[0] = solution[this->introspection().component_indices.pressure];
+
+        for (unsigned int d = 0; d < dim; ++d)
+          material_inputs.velocity[0][d] = solution[this->introspection().component_indices.velocities[d]];
+
+        for (unsigned int n = 0; n < this->n_compositional_fields(); ++n)
+          material_inputs.composition[0][n] = solution[this->introspection().component_indices.compositional_fields[n]];
+
+        Tensor<2,dim> grad_u;
+        for (unsigned int d=0; d<dim; ++d)
+          grad_u[d] = gradients[d];
+        material_inputs.strain_rate[0] = symmetrize (grad_u);
+
+        this->get_material_model().evaluate (material_inputs,material_outputs);
+
+        for (unsigned int i = 0; i < SymmetricTensor<2,dim>::n_independent_components ; ++i)
+          particle->get_properties()[data_position + i] += material_outputs.reaction_terms[0][i];
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      ElasticStress<dim>::need_update() const
+      {
+        return update_time_step;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      ElasticStress<dim>::get_needed_update_flags () const
+      {
+        return update_values | update_gradients;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      ElasticStress<dim>::get_property_information() const
+      {
+        std::vector<std::pair<std::string,unsigned int>> property_information;
+
+        //Check which fields are used in model and make an output for each.
+        if (this->introspection().compositional_name_exists("ve_stress_xx"))
+          property_information.emplace_back("ve_stress_xx",1);
+
+        if (this->introspection().compositional_name_exists("ve_stress_yy"))
+          property_information.emplace_back("ve_stress_yy",1);
+
+        if (dim == 2)
+          {
+            if (this->introspection().compositional_name_exists("ve_stress_xy"))
+              property_information.emplace_back("ve_stress_xy",1);
+          }
+        else if (dim == 3)
+          {
+            if (this->introspection().compositional_name_exists("ve_stress_zz"))
+              property_information.emplace_back("ve_stress_zz",1);
+
+            if (this->introspection().compositional_name_exists("ve_stress_xy"))
+              property_information.emplace_back("ve_stress_xy",1);
+
+            if (this->introspection().compositional_name_exists("ve_stress_xz"))
+              property_information.emplace_back("ve_stress_xz",1);
+
+            if (this->introspection().compositional_name_exists("ve_stress_yz"))
+              property_information.emplace_back("ve_stress_yz",1);
+          }
+
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(ElasticStress,
+                                        "elastic stress",
+                                        "A plugin in which the particle property tensor is "
+                                        "defined as the total elastic stress a particle has "
+                                        "accumulated. See the viscoelastic material model "
+                                        "documentation for more detailed information.")
+
+    }
+  }
+}
diff --git a/source/particle/property/elastic_tensor_decomposition.cc.bak b/source/particle/property/elastic_tensor_decomposition.cc.bak
new file mode 100644
index 00000000000..25308ff2623
--- /dev/null
+++ b/source/particle/property/elastic_tensor_decomposition.cc.bak
@@ -0,0 +1,468 @@
+/*
+ Copyright (C) 2023 by the authors of the ASPECT code.
+ This file is part of ASPECT.
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/elastic_tensor_decomposition.h>
+#include <aspect/particle/property/cpo_elastic_tensor.h>
+#include <aspect/particle/property/crystal_preferred_orientation.h>
+#include <aspect/particle/world.h>
+
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      namespace Utilities
+      {
+        std::array<unsigned int, 3>
+        indexed_even_permutation(const unsigned int index)
+        {
+          // there are 6 permutations, but only the odd or even are needed. We use the even
+          // permutation here.
+          switch (index)
+            {
+              case 0 :
+                return {{0,1,2}};
+              case 1 :
+                return {{1,2,0}};
+              case 2:
+                return {{2,0,1}};
+              /*case 3:
+                return {0,2,1};
+              case 4 :
+                return {1,0,2};
+              case 5:
+                return {2,1,0};*/
+              default:
+                AssertThrow(false,ExcMessage("Provided index larger then 2 (" + std::to_string(index)+ ")."));
+                return {{0,0,0}};
+            }
+
+        }
+
+
+
+        SymmetricTensor<2,3>
+        compute_voigt_stiffness_tensor(const SymmetricTensor<2,6> &elastic_matrix)
+        {
+          /**
+           * the Voigt stiffness tensor (see Browaeys and Chevrot, 2004)
+           * It defines the stress needed to cause an isotropic strain in the
+           * material
+           */
+          SymmetricTensor<2,3> voigt_stiffness_tensor;
+          voigt_stiffness_tensor[0][0]=elastic_matrix[0][0]+elastic_matrix[5][5]+elastic_matrix[4][4];
+          voigt_stiffness_tensor[1][1]=elastic_matrix[5][5]+elastic_matrix[1][1]+elastic_matrix[3][3];
+          voigt_stiffness_tensor[2][2]=elastic_matrix[4][4]+elastic_matrix[3][3]+elastic_matrix[2][2];
+          voigt_stiffness_tensor[1][0]=elastic_matrix[0][5]+elastic_matrix[1][5]+elastic_matrix[3][4];
+          voigt_stiffness_tensor[2][0]=elastic_matrix[0][4]+elastic_matrix[2][4]+elastic_matrix[3][5];
+          voigt_stiffness_tensor[2][1]=elastic_matrix[1][3]+elastic_matrix[2][3]+elastic_matrix[4][5];
+
+          return voigt_stiffness_tensor;
+        }
+
+
+
+        SymmetricTensor<2,3>
+        compute_dilatation_stiffness_tensor(const SymmetricTensor<2,6> &elastic_matrix)
+        {
+          /**
+           * The dilatational stiffness tensor (see Browaeys and Chevrot, 2004)
+           * It defines the stress to cause isotropic dilatation in the material.
+           */
+          SymmetricTensor<2,3> dilatation_stiffness_tensor;
+          for (size_t i = 0; i < 3; i++)
+            {
+              dilatation_stiffness_tensor[0][0]=elastic_matrix[0][i]+dilatation_stiffness_tensor[0][0];
+              dilatation_stiffness_tensor[1][1]=elastic_matrix[1][i]+dilatation_stiffness_tensor[1][1];
+              dilatation_stiffness_tensor[2][2]=elastic_matrix[2][i]+dilatation_stiffness_tensor[2][2];
+              dilatation_stiffness_tensor[1][0]=elastic_matrix[5][i]+dilatation_stiffness_tensor[1][0];
+              dilatation_stiffness_tensor[2][0]=elastic_matrix[4][i]+dilatation_stiffness_tensor[2][0];
+              dilatation_stiffness_tensor[2][1]=elastic_matrix[3][i]+dilatation_stiffness_tensor[2][1];
+            }
+          return dilatation_stiffness_tensor;
+        }
+
+
+
+        Tensor<2,3>
+        compute_unpermutated_SCCS(const SymmetricTensor<2,3> &dilatation_stiffness_tensor,
+                                  const SymmetricTensor<2,3> &voigt_stiffness_tensor)
+        {
+          // computing the eigenvector of the dilation and Voigt stiffness matrices and then averaging them by bysection.
+          const std::array<std::pair<double,Tensor<1,3,double>>, 3> voigt_eigenvectors_a = eigenvectors(voigt_stiffness_tensor, SymmetricTensorEigenvectorMethod::jacobi);
+          const std::array<std::pair<double,Tensor<1,3,double>>, 3> dilatation_eigenvectors_a = eigenvectors(dilatation_stiffness_tensor, SymmetricTensorEigenvectorMethod::jacobi);
+
+
+          std::array<Tensor<1,3,double>,3> unpermutated_SCCS;
+          // Averaging dilatation and voigt eigenvectors
+          // To do this we need to find the eigenvectors which are closest to each other and average those.
+          // The next function looks for the smallest angle and returns the corresponding vector index for
+          // that vector.
+          int vector_index_signed = 0;
+          for (unsigned int i1 = 0; i1 < 3; i1++)
+            {
+              vector_index_signed = 0;
+              double smallest_angle = std::numeric_limits<double>::max(); // angle D VeCtor
+              for (unsigned int i2 = 0; i2 < 3; i2++)
+                {
+                  double dv_dot_product = dilatation_eigenvectors_a[i1].second*voigt_eigenvectors_a[i2].second;
+                  // limit the dot product between 1 and -1 so we can use the arccos function safely.
+                  if (std::abs(dv_dot_product) >= 1.0)
+                    dv_dot_product = std::copysign(1.0,dv_dot_product);
+                  // Compute the angle between the vectors and account for that vector in the opposite
+                  // direction are the same (0 == 180 degrees). So limit the direction of the vectors between
+                  // 0 and 90 degrees such that it represents the minimum angle between the two lines.
+                  const double angle = dv_dot_product < 0.0 ? std::acos(-1.0)-std::acos(dv_dot_product) : std::acos(dv_dot_product);
+                  // store this if the angle is smaller
+                  if (angle < smallest_angle)
+                    {
+                      vector_index_signed = (dv_dot_product < 0.0) ? -i2 : i2;
+                      smallest_angle = angle;
+                    }
+                }
+
+              // Adds to the dilatation eigenvectors to the Voigt eigenvectors with the smallest angle
+              // Note that the voigt eigenvector is multiplied with a value which can be negative, which means it would be a subtraction.
+              // Lastly we normalize the unpermutated_SCCS.
+              unpermutated_SCCS[i1] = 0.5*(dilatation_eigenvectors_a[i1].second + static_cast<double>(vector_index_signed)*voigt_eigenvectors_a[std::abs(vector_index_signed)].second);
+              unpermutated_SCCS[i1] /= unpermutated_SCCS[i1].norm();
+            }
+
+          return Tensor<2,3>(
+          {
+            {unpermutated_SCCS[0][0],unpermutated_SCCS[0][1],unpermutated_SCCS[0][2]},
+            {unpermutated_SCCS[1][0],unpermutated_SCCS[1][1],unpermutated_SCCS[1][2]},
+            {unpermutated_SCCS[2][0],unpermutated_SCCS[2][1],unpermutated_SCCS[2][2]}
+          });
+        }
+
+
+
+        std::array<std::array<double,3>,7>
+        compute_elastic_tensor_SCCS_decompositions(
+          const Tensor<2,3> &unpermutated_SCCS,
+          const SymmetricTensor<2,6> &elastic_matrix)
+        {
+          /**
+           * Try the different permutations to determine what is the best hexagonal projection.
+           * This is based on Browaeys and Chevrot (2004), GJI (doi: 10.1111/j.1365-246X.2004.024115.x),
+           * which states at the end of paragraph 3.3 that "... an important property of an orthogonal projection
+           * is that the distance between a vector $X$ and its orthogonal projection $X_H = p(X)$ on a given
+           * subspace is minimum. These two features ensure that the decomposition is optimal once a 3-D Cartesian
+           * coordinate system is chosen.". The other property they talk about is that "The space of elastic
+           * vectors has a finite dimension [...], i.e. using a different norm from eq. (2.3 will change distances
+           * but not the resulting decomposition.".
+           */
+          std::array<Tensor<2,3>,3> permutated;
+          std::array<SymmetricTensor<2,6>,3> rotated_elastic_matrix;
+          // The norms variable contains the square norms of the different symmetry approximations of the elastic tensor.
+          std::array<std::array<double,3>,7> squared_norms_to_projections;
+
+          for (unsigned int permutation_i = 0; permutation_i < 3; permutation_i++)
+            {
+              std::array<unsigned int, 3> permutation = indexed_even_permutation(permutation_i);
+
+              for (size_t j = 0; j < 3; j++)
+                {
+                  permutated[permutation_i][j] = unpermutated_SCCS[permutation[j]];
+                }
+
+              rotated_elastic_matrix[permutation_i] = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix((permutated[permutation_i]),elastic_matrix);
+
+              const Tensor<1,21> full_elastic_vector_rotated = aspect::Utilities::Tensors::to_voigt_stiffness_vector(rotated_elastic_matrix[permutation_i]);
+
+
+              const double full_norm_square = full_elastic_vector_rotated.norm_square();
+              squared_norms_to_projections[6][permutation_i] = full_norm_square;
+
+              // Get the monoclinic and higher symmetry axes, which can be comptued by taking specific elements from the full vector.
+              // This means that this vector contains all symmetry axes, but the isotropic part is removed.
+              // The following line would do the same as the lines below, but is is very slow. It has therefore been
+              // replaced by the lines below.
+              //auto monoclinic_and_higher_vector = projection_matrix_triclinic_to_monoclinic*full_elastic_vector_rotated;
+              dealii::Tensor<1,21> monoclinic_and_higher_vector;
+              monoclinic_and_higher_vector[0] = full_elastic_vector_rotated[0];
+              monoclinic_and_higher_vector[1] = full_elastic_vector_rotated[1];
+              monoclinic_and_higher_vector[2] = full_elastic_vector_rotated[2];
+              monoclinic_and_higher_vector[3] = full_elastic_vector_rotated[3];
+              monoclinic_and_higher_vector[4] = full_elastic_vector_rotated[4];
+              monoclinic_and_higher_vector[5] = full_elastic_vector_rotated[5];
+              monoclinic_and_higher_vector[6] = full_elastic_vector_rotated[6];
+              monoclinic_and_higher_vector[7] = full_elastic_vector_rotated[7];
+              monoclinic_and_higher_vector[8] = full_elastic_vector_rotated[8];
+              monoclinic_and_higher_vector[11] = full_elastic_vector_rotated[11];
+              monoclinic_and_higher_vector[14] = full_elastic_vector_rotated[14];
+              monoclinic_and_higher_vector[17] = full_elastic_vector_rotated[17];
+              monoclinic_and_higher_vector[20] = full_elastic_vector_rotated[20];
+
+              // The triclinic vector is the full elastic tensor minux the monoclinic and higher symmetry axes vector.
+              auto triclinic_vector = full_elastic_vector_rotated-monoclinic_and_higher_vector;
+              squared_norms_to_projections[0][permutation_i] = triclinic_vector.norm_square();
+
+              // Only the first 9 elements are now non-zero, so crop the vector to the first 9 elements.
+              // The following line would do the same as the lines below, but it is slow. It has therefore been
+              // replaced by the lines below.
+              //auto orthorhombic_and_higher_vector = projection_matrix_monoclinic_to_orthorhombic*monoclinic_and_higher_vector;
+              dealii::Tensor<1,9>  monoclinic_and_higher_vector_cropped;
+              monoclinic_and_higher_vector_cropped[0] = monoclinic_and_higher_vector[0];
+              monoclinic_and_higher_vector_cropped[1] = monoclinic_and_higher_vector[1];
+              monoclinic_and_higher_vector_cropped[2] = monoclinic_and_higher_vector[2];
+              monoclinic_and_higher_vector_cropped[3] = monoclinic_and_higher_vector[3];
+              monoclinic_and_higher_vector_cropped[4] = monoclinic_and_higher_vector[4];
+              monoclinic_and_higher_vector_cropped[5] = monoclinic_and_higher_vector[5];
+              monoclinic_and_higher_vector_cropped[6] = monoclinic_and_higher_vector[6];
+              monoclinic_and_higher_vector_cropped[7] = monoclinic_and_higher_vector[7];
+              monoclinic_and_higher_vector_cropped[8] = monoclinic_and_higher_vector[8];
+              dealii::Tensor<1,9> orthorhombic_and_higher_vector;
+              orthorhombic_and_higher_vector[0] = monoclinic_and_higher_vector[0];
+              orthorhombic_and_higher_vector[1] = monoclinic_and_higher_vector[1];
+              orthorhombic_and_higher_vector[2] = monoclinic_and_higher_vector[2];
+              orthorhombic_and_higher_vector[3] = monoclinic_and_higher_vector[3];
+              orthorhombic_and_higher_vector[4] = monoclinic_and_higher_vector[4];
+              orthorhombic_and_higher_vector[5] = monoclinic_and_higher_vector[5];
+              orthorhombic_and_higher_vector[6] = monoclinic_and_higher_vector[6];
+              orthorhombic_and_higher_vector[7] = monoclinic_and_higher_vector[7];
+              orthorhombic_and_higher_vector[8] = monoclinic_and_higher_vector[8];
+
+              // The monoclinic vector is the monoclinic and higher symmetry axes vector minux the orthoclinic and higher symmetry axes vector.
+              auto monoclinic_vector = monoclinic_and_higher_vector_cropped-orthorhombic_and_higher_vector;
+              squared_norms_to_projections[1][permutation_i] = monoclinic_vector.norm_square();
+
+
+              auto tetragonal_and_higher_vector = projection_matrix_orthorhombic_to_tetragonal*orthorhombic_and_higher_vector;
+              auto orthorhombic_vector = orthorhombic_and_higher_vector-tetragonal_and_higher_vector;
+              squared_norms_to_projections[2][permutation_i] = orthorhombic_vector.norm_square();
+
+              auto hexagonal_and_higher_vector = projection_matrix_tetragonal_to_hexagonal*tetragonal_and_higher_vector;
+              auto tetragonal_vector = tetragonal_and_higher_vector-hexagonal_and_higher_vector;
+              squared_norms_to_projections[3][permutation_i] = tetragonal_vector.norm_square();
+
+              auto isotropic_vector = projection_matrix_hexagonal_to_isotropic*hexagonal_and_higher_vector;
+              auto hexagonal_vector = hexagonal_and_higher_vector-isotropic_vector;
+              squared_norms_to_projections[4][permutation_i] = hexagonal_vector.norm_square();
+              squared_norms_to_projections[5][permutation_i] = isotropic_vector.norm_square();
+
+            }
+          return squared_norms_to_projections;
+
+        }
+      }
+
+
+
+      template <int dim>
+      void
+      ElasticTensorDecomposition<dim>::initialize ()
+      {
+        const Particle::Property::Manager<dim> &manager = this->get_particle_world(this->get_particle_world_index()).get_property_manager();
+        AssertThrow(manager.plugin_name_exists("crystal preferred orientation"),
+                    ExcMessage("No cpo property plugin found."));
+        AssertThrow(manager.plugin_name_exists("cpo elastic tensor"),
+                    ExcMessage("No cpo elastic tensor property plugin found."));
+
+        AssertThrow(manager.check_plugin_order("crystal preferred orientation","elastic tensor decomposition"),
+                    ExcMessage("To use the elastic tensor decomposition plugin, the cpo plugin needs to be defined before this plugin."));
+
+        AssertThrow(manager.check_plugin_order("cpo elastic tensor","elastic tensor decomposition"),
+                    ExcMessage("To use the elastic tensor decomposition plugin, the cpo elastic tensor plugin needs to be defined before this plugin."));
+
+        cpo_elastic_tensor_data_position = manager.get_data_info().get_position_by_plugin_index(manager.get_plugin_index_by_name("cpo elastic tensor"));
+      }
+
+
+
+      template <int dim>
+      void
+      ElasticTensorDecomposition<dim>::initialize_one_particle_property(const Point<dim> &,
+                                                                        std::vector<double> &data) const
+      {
+        const SymmetricTensor<2,6> elastic_matrix = Particle::Property::CpoElasticTensor<dim>::get_elastic_tensor(cpo_elastic_tensor_data_position,
+                                                    data);
+
+        const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = Property::Utilities::compute_dilatation_stiffness_tensor(elastic_matrix);
+        const SymmetricTensor<2,3> voigt_stiffness_tensor_full = Property::Utilities::compute_voigt_stiffness_tensor(elastic_matrix);
+        const Tensor<2,3> SCCS_full = Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
+
+        const std::array<std::array<double,3>,7 > norms = Property::Utilities::compute_elastic_tensor_SCCS_decompositions(SCCS_full, elastic_matrix);
+
+        // get max hexagonal element index, which is the same as the permutation index
+        const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
+        std::array<unsigned int, 3> permutation = Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
+        // reorder the SCCS be the SCCS permutation which yields the largest hexagonal vector (percentage of anisotropy)
+        Tensor<2,3> hexagonal_permutated_SCCS;
+        for (size_t index = 0; index < 3; ++index)
+          {
+            hexagonal_permutated_SCCS[index] = SCCS_full[permutation[index]];
+          }
+
+        data.push_back(SCCS_full[0][0]);
+        data.push_back(SCCS_full[0][1]);
+        data.push_back(SCCS_full[0][2]);
+        data.push_back(SCCS_full[1][0]);
+        data.push_back(SCCS_full[1][1]);
+        data.push_back(SCCS_full[1][2]);
+        data.push_back(SCCS_full[2][0]);
+        data.push_back(SCCS_full[2][1]);
+        data.push_back(SCCS_full[2][2]);
+        data.push_back(hexagonal_permutated_SCCS[2][0]);
+        data.push_back(hexagonal_permutated_SCCS[2][1]);
+        data.push_back(hexagonal_permutated_SCCS[2][2]);
+        data.push_back(norms[6][0]);
+        data.push_back(norms[0][0]); // triclinic
+        data.push_back(norms[0][1]); // triclinic
+        data.push_back(norms[0][2]); // triclinic
+        data.push_back(norms[1][0]); // monoclinic
+        data.push_back(norms[1][1]); // monoclinic
+        data.push_back(norms[1][2]); // monoclinic
+        data.push_back(norms[2][0]); // orthorhomic
+        data.push_back(norms[2][1]); // orthorhomic
+        data.push_back(norms[2][2]); // orthorhomic
+        data.push_back(norms[3][0]); // tetragonal
+        data.push_back(norms[3][1]); // tetragonal
+        data.push_back(norms[3][2]); // tetragonal
+        data.push_back(norms[4][0]); // hexagonal
+        data.push_back(norms[4][1]); // hexagonal
+        data.push_back(norms[4][2]); // hexagonal
+        data.push_back(norms[5][0]); // isotropic
+
+      }
+
+
+
+      template <int dim>
+      void
+      ElasticTensorDecomposition<dim>::update_particle_property(const unsigned int data_position,
+                                                                const Vector<double> &/*solution*/,
+                                                                const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                                                typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        ArrayView<double> data = particle->get_properties();
+        const SymmetricTensor<2,6> elastic_matrix = Particle::Property::CpoElasticTensor<dim>::get_elastic_tensor(cpo_elastic_tensor_data_position,
+                                                    data);
+
+        const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = Utilities::compute_dilatation_stiffness_tensor(elastic_matrix);
+        const SymmetricTensor<2,3> voigt_stiffness_tensor_full = Utilities::compute_voigt_stiffness_tensor(elastic_matrix);
+        const Tensor<2,3> SCCS_full = Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
+
+        const std::array<std::array<double,3>,7 > norms = Utilities::compute_elastic_tensor_SCCS_decompositions(SCCS_full, elastic_matrix);
+
+        // get max hexagonal element index, which is the same as the permutation index
+        const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
+        std::array<unsigned int, 3> permutation = Utilities::indexed_even_permutation(max_hexagonal_element_index);
+        // reorder the SCCS by the SCCS permutation which yields the largest hexagonal vector (percentage of anisotropy)
+        Tensor<2,3> hexagonal_permutated_SCCS;
+        for (size_t index = 0; index < 3; ++index)
+          {
+            hexagonal_permutated_SCCS[index] = SCCS_full[permutation[index]];
+          }
+
+        data[data_position]    = SCCS_full[0][0];
+        data[data_position+1]  = SCCS_full[0][1];
+        data[data_position+2]  = SCCS_full[0][2];
+        data[data_position+3]  = SCCS_full[1][0];
+        data[data_position+4]  = SCCS_full[1][1];
+        data[data_position+5]  = SCCS_full[1][2];
+        data[data_position+6]  = SCCS_full[2][0];
+        data[data_position+7]  = SCCS_full[2][1];
+        data[data_position+8]  = SCCS_full[2][2];
+        data[data_position+9]  = hexagonal_permutated_SCCS[2][0];
+        data[data_position+10] = hexagonal_permutated_SCCS[2][1];
+        data[data_position+11] = hexagonal_permutated_SCCS[2][2];
+        data[data_position+12] = norms[6][0];
+        data[data_position+13] = norms[0][0]; // triclinic
+        data[data_position+14] = norms[0][1]; // triclinic
+        data[data_position+15] = norms[0][2]; // triclinic
+        data[data_position+16] = norms[1][0]; // monoclinic
+        data[data_position+17] = norms[1][1]; // monoclinic
+        data[data_position+18] = norms[1][2]; // monoclinic
+        data[data_position+19] = norms[2][0]; // orthorhomic
+        data[data_position+20] = norms[2][1]; // orthorhomic
+        data[data_position+21] = norms[2][2]; // orthorhomic
+        data[data_position+22] = norms[3][0]; // tetragonal
+        data[data_position+23] = norms[3][1]; // tetragonal
+        data[data_position+24] = norms[3][2]; // tetragonal
+        data[data_position+25] = norms[4][0]; // hexagonal
+        data[data_position+26] = norms[4][1]; // hexagonal
+        data[data_position+27] = norms[4][2]; // hexagonal
+        data[data_position+28] = norms[5][0]; // isotropic
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      ElasticTensorDecomposition<dim>::need_update() const
+      {
+        return update_output_step;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      ElasticTensorDecomposition<dim>::get_property_information() const
+      {
+        std::vector<std::pair<std::string,unsigned int>> property_information =
+        {
+          {"cpo elastic axis e1",3},
+          {"cpo elastic axis e2",3},
+          {"cpo elastic axis e3",3},
+          {"cpo elastic hexagonal axis",3},
+          {"cpo elastic vector norm square",1},
+          {"cpo elastic triclinic vector norm square p1",1},
+          {"cpo elastic triclinic vector norm square p2",1},
+          {"cpo elastic triclinic vector norm square p3",1},
+          {"cpo elastic monoclinic vector norm square p1",1},
+          {"cpo elastic monoclinic vector norm square p2",1},
+          {"cpo elastic monoclinic vector norm square p3",1},
+          {"cpo elastic orthorhombic vector norm square p1",1},
+          {"cpo elastic orthorhombic vector norm square p2",1},
+          {"cpo elastic orthorhombic vector norm square p3",1},
+          {"cpo elastic tetragonal vector norm square p1",1},
+          {"cpo elastic tetragonal vector norm square p2",1},
+          {"cpo elastic tetragonal vector norm square p3",1},
+          {"cpo elastic hexagonal vector norm square p1",1},
+          {"cpo elastic hexagonal vector norm square p2",1},
+          {"cpo elastic hexagonal vector norm square p3",1},
+          {"cpo elastic isotropic vector norm square",1}
+        };
+
+        return property_information;
+      }
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(ElasticTensorDecomposition,
+                                        "elastic tensor decomposition",
+                                        "A plugin which decomposes the elastic tensor into different approximations "
+                                        "(Isotropic, Hexagonal, Tetragonal, Orthorhombic, Monoclinic and Triclinic) "
+                                        "and provides the eigenvectors of the tensor.")
+    }
+  }
+}
diff --git a/source/particle/property/function.cc.bak b/source/particle/property/function.cc.bak
new file mode 100644
index 00000000000..d88dd252001
--- /dev/null
+++ b/source/particle/property/function.cc.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/function.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      Function<dim>::Function()
+        :
+        n_components (0)
+      {}
+
+      template <int dim>
+      void
+      Function<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                      std::vector<double> &data) const
+      {
+        for (unsigned int i = 0; i < n_components; ++i)
+          data.push_back(function->value(position, i));
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      Function<dim>::get_property_information() const
+      {
+        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("function",n_components));
+        return property_information;
+      }
+
+
+      template <int dim>
+      void
+      Function<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Function");
+        {
+          prm.declare_entry ("Number of components", "1",
+                             Patterns::Integer (0),
+                             "The number of function components where each component is described "
+                             "by a function expression delimited by a ';'.");
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      Function<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Function");
+        n_components = prm.get_integer ("Number of components");
+        try
+          {
+            function = std::make_unique<Functions::ParsedFunction<dim>>(n_components);
+            function->parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Particles.Function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'";
+            throw;
+          }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(Function,
+                                        "function",
+                                        "Implementation of a model in which the particle "
+                                        "property is set by evaluating an explicit function "
+                                        "at the initial position of each particle. The "
+                                        "function is defined in the parameters in section "
+                                        "``Particles|Function''. The format of these "
+                                        "functions follows the syntax understood by the "
+                                        "muparser library, see "
+                                        "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+    }
+  }
+}
diff --git a/source/particle/property/grain_size.cc.bak b/source/particle/property/grain_size.cc.bak
new file mode 100644
index 00000000000..145d00f267c
--- /dev/null
+++ b/source/particle/property/grain_size.cc.bak
@@ -0,0 +1,173 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/grain_size.h>
+#include <aspect/material_model/grain_size.h>
+#include <aspect/initial_composition/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      GrainSize<dim>::GrainSize ()
+        :
+        material_inputs(1,0),
+        material_outputs(1,0)
+      {}
+
+
+
+      template <int dim>
+      void
+      GrainSize<dim>::initialize ()
+      {
+        material_inputs  = MaterialModel::MaterialModelInputs<dim>(1, this->n_compositional_fields());
+        material_outputs = MaterialModel::MaterialModelOutputs<dim>(1, this->n_compositional_fields());
+
+        AssertThrow(this->introspection().compositional_name_exists("grain_size"),
+                    ExcMessage("This particle property only makes sense if "
+                               "there is a compositional field named 'grain_size'."));
+
+        grain_size_index = this->introspection().compositional_index_for_name("grain_size");
+      }
+
+
+
+      template <int dim>
+      void
+      GrainSize<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                       std::vector<double> &data) const
+      {
+        // Set the initial composition to the initial grain size.
+        data.push_back(this->get_initial_composition_manager().initial_composition(position,grain_size_index));
+      }
+
+
+
+      template <int dim>
+      void
+      GrainSize<dim>::update_particle_properties(const unsigned int data_position,
+                                                 const std::vector<Vector<double>> &solution,
+                                                 const std::vector<std::vector<Tensor<1,dim>>> &gradients,
+                                                 typename ParticleHandler<dim>::particle_iterator_range &particles) const
+      {
+        material_inputs  = MaterialModel::MaterialModelInputs<dim>(solution.size(), this->n_compositional_fields());
+        material_outputs = MaterialModel::MaterialModelOutputs<dim>(solution.size(), this->n_compositional_fields());
+        material_inputs.requested_properties = MaterialModel::MaterialProperties::reaction_terms;
+        material_inputs.current_cell = typename DoFHandler<dim>::active_cell_iterator(*particles.begin()->get_surrounding_cell(),
+                                                                                      &(this->get_dof_handler()));
+
+        unsigned int i = 0;
+        for (auto particle: particles)
+          {
+            // Make sure all particles are in the same cell
+            Assert(particle.get_surrounding_cell() == particles.begin()->get_surrounding_cell(),
+                   ExcMessage("All particles must be in the same cell."));
+
+            material_inputs.position[i] = particle.get_location();
+            material_inputs.temperature[i] = solution[i][this->introspection().component_indices.temperature];
+            material_inputs.pressure[i] = solution[i][this->introspection().component_indices.pressure];
+
+            for (unsigned int d = 0; d < dim; ++d)
+              material_inputs.velocity[i][d] = solution[i][this->introspection().component_indices.velocities[d]];
+
+            for (unsigned int n = 0; n < this->n_compositional_fields(); ++n)
+              material_inputs.composition[i][n] = solution[i][this->introspection().component_indices.compositional_fields[n]];
+
+            material_inputs.composition[i][grain_size_index] = particle.get_properties()[data_position];
+
+            Tensor<2,dim> grad_u;
+            for (unsigned int d=0; d<dim; ++d)
+              grad_u[d] = gradients[i][d];
+            material_inputs.strain_rate[i] = symmetrize (grad_u);
+
+            ++i;
+          }
+
+        this->get_material_model().evaluate(material_inputs,
+                                            material_outputs);
+
+        i = 0;
+        for (auto particle: particles)
+          {
+            particle.get_properties()[data_position] += material_outputs.reaction_terms[i][grain_size_index];
+            ++i;
+          }
+      }
+
+
+
+      template <int dim>
+      InitializationModeForLateParticles
+      GrainSize<dim>::late_initialization_mode () const
+      {
+        return interpolate_respect_boundary;
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      GrainSize<dim>::need_update() const
+      {
+        return update_time_step;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      GrainSize<dim>::get_needed_update_flags () const
+      {
+        return update_values | update_gradients;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      GrainSize<dim>::get_property_information() const
+      {
+        return {{"grain_size",1}};
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(GrainSize,
+                                        "grain size",
+                                        "A plugin in which the particle property is "
+                                        "defined as the evolving grain size of a particle. "
+                                        "See the grain_size material model "
+                                        "documentation for more detailed information.")
+
+    }
+  }
+}
diff --git a/source/particle/property/initial_composition.cc.bak b/source/particle/property/initial_composition.cc.bak
new file mode 100644
index 00000000000..4c603e02744
--- /dev/null
+++ b/source/particle/property/initial_composition.cc.bak
@@ -0,0 +1,91 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/initial_composition.h>
+#include <aspect/initial_composition/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      InitialComposition<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                                std::vector<double> &data) const
+      {
+        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
+          data.push_back(this->get_initial_composition_manager().initial_composition(position,i));
+      }
+
+
+
+      template <int dim>
+      InitializationModeForLateParticles
+      InitialComposition<dim>::late_initialization_mode () const
+      {
+        return interpolate_respect_boundary;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      InitialComposition<dim>::get_property_information() const
+      {
+        AssertThrow(this->n_compositional_fields() > 0,
+                    ExcMessage("You have requested the particle property <initial "
+                               "composition>, but the number of compositional fields is 0. "
+                               "Please add compositional fields to your model, or remove "
+                               "this particle property."));
+
+        std::vector<std::pair<std::string,unsigned int>> property_information;
+
+        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
+          {
+            std::ostringstream field_name;
+            field_name << "initial " << this->introspection().name_for_compositional_index(i);
+            property_information.emplace_back(field_name.str(),1);
+          }
+
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(InitialComposition,
+                                        "initial composition",
+                                        "Implementation of a plugin in which the particle "
+                                        "property is given as the initial composition "
+                                        "at the particle's initial position. The particle "
+                                        "gets as many properties as there are "
+                                        "compositional fields.")
+    }
+  }
+}
diff --git a/source/particle/property/initial_position.cc.bak b/source/particle/property/initial_position.cc.bak
new file mode 100644
index 00000000000..ee44d3f0874
--- /dev/null
+++ b/source/particle/property/initial_position.cc.bak
@@ -0,0 +1,72 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/global.h>
+#include <aspect/particle/property/initial_position.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      InitialPosition<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                             std::vector<double> &data) const
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          data.push_back(position[i]);
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      InitialPosition<dim>::get_property_information() const
+      {
+        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("initial position",static_cast<unsigned int> (dim)));
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(InitialPosition,
+                                        "initial position",
+                                        "Implementation of a plugin in which the particle "
+                                        "property is given as the initial position "
+                                        "of the particle. This property is vector-valued with "
+                                        "as many components as there are space dimensions. "
+                                        "In practice, it is often most useful to only "
+                                        "visualize one of the components of this vector, "
+                                        "or the magnitude of the vector. For example, in "
+                                        "a spherical mantle simulation, the magnitude of this "
+                                        "property equals the starting radius of a particle, "
+                                        "and is thereby indicative of which part of the "
+                                        "mantle a particle comes from.")
+    }
+  }
+}
diff --git a/source/particle/property/integrated_strain.cc.bak b/source/particle/property/integrated_strain.cc.bak
new file mode 100644
index 00000000000..7afa788bad3
--- /dev/null
+++ b/source/particle/property/integrated_strain.cc.bak
@@ -0,0 +1,124 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/integrated_strain.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      IntegratedStrain<dim>::initialize_one_particle_property(const Point<dim> &,
+                                                              std::vector<double> &data) const
+      {
+        const static Tensor<2,dim> identity = unit_symmetric_tensor<dim>();
+        for (unsigned int i = 0; i < Tensor<2,dim>::n_independent_components ; ++i)
+          data.push_back(identity[Tensor<2,dim>::unrolled_to_component_indices(i)]);
+      }
+
+      template <int dim>
+      void
+      IntegratedStrain<dim>::update_particle_property(const unsigned int data_position,
+                                                      const Vector<double> &/*solution*/,
+                                                      const std::vector<Tensor<1,dim>> &gradients,
+                                                      typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        const Tensor<2,dim> old_strain(make_array_view(&particle->get_properties()[data_position],
+                                                       &particle->get_properties()[data_position] + Tensor<2,dim>::n_independent_components));
+
+        Tensor<2,dim> grad_u;
+        for (unsigned int d=0; d<dim; ++d)
+          grad_u[d] = gradients[d];
+
+        const double dt = this->get_timestep();
+
+        Tensor<2,dim> new_strain;
+
+        // here we integrate the equation
+        // new_deformation_gradient = velocity_gradient * old_deformation_gradient
+        // using a RK4 integration scheme.
+        const Tensor<2,dim> k1 = grad_u * old_strain * dt;
+        new_strain = old_strain + 0.5*k1;
+
+        const Tensor<2,dim> k2 = grad_u * new_strain * dt;
+        new_strain = old_strain + 0.5*k2;
+
+        const Tensor<2,dim> k3 = grad_u * new_strain * dt;
+        new_strain = old_strain + k3;
+
+        const Tensor<2,dim> k4 = grad_u * new_strain * dt;
+
+        // the new strain is the rotated old strain plus the
+        // strain of the current time step
+        new_strain = old_strain + (k1 + 2.0*k2 + 2.0*k3 + k4)/6.0;
+
+        // unroll and store the new strain
+        new_strain.unroll(&particle->get_properties()[data_position],
+                          &particle->get_properties()[data_position] + Tensor<2,dim>::n_independent_components);
+      }
+
+      template <int dim>
+      UpdateTimeFlags
+      IntegratedStrain<dim>::need_update() const
+      {
+        return update_time_step;
+      }
+
+      template <int dim>
+      UpdateFlags
+      IntegratedStrain<dim>::get_needed_update_flags () const
+      {
+        return update_gradients;
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      IntegratedStrain<dim>::get_property_information() const
+      {
+        const unsigned int n_components = Tensor<2,dim>::n_independent_components;
+        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("integrated strain",n_components));
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(IntegratedStrain,
+                                        "integrated strain",
+                                        "A plugin in which the particle property tensor is "
+                                        "defined as the deformation gradient tensor "
+                                        "$\\mathbf F$ this particle has experienced. "
+                                        "$\\mathbf F$ can be polar-decomposed into the left stretching tensor "
+                                        "$\\mathbf L$ (the finite strain we are interested in), and the "
+                                        "rotation tensor $\\mathbf Q$. See the corresponding cookbook in "
+                                        "the manual for more detailed information.")
+    }
+  }
+}
diff --git a/source/particle/property/integrated_strain_invariant.cc.bak b/source/particle/property/integrated_strain_invariant.cc.bak
new file mode 100644
index 00000000000..a0d13bb0f82
--- /dev/null
+++ b/source/particle/property/integrated_strain_invariant.cc.bak
@@ -0,0 +1,118 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/integrated_strain_invariant.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      IntegratedStrainInvariant<dim>::initialize_one_particle_property(const Point<dim> &,
+                                                                       std::vector<double> &data) const
+      {
+        data.push_back(0.0);
+      }
+
+
+
+      template <int dim>
+      void
+      IntegratedStrainInvariant<dim>::update_particle_property(const unsigned int data_position,
+                                                               const Vector<double> &/*solution*/,
+                                                               const std::vector<Tensor<1,dim>> &gradients,
+                                                               typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        // Integrated strain invariant from prior time step
+        const auto data = particle->get_properties();
+        double old_strain = data[data_position];
+
+        // Current timestep
+        const double dt = this->get_timestep();
+
+        // Velocity gradients
+        Tensor<2,dim> grad_u;
+        for (unsigned int d=0; d<dim; ++d)
+          grad_u[d] = gradients[d];
+
+        // Calculate strain rate from velocity gradients
+        const SymmetricTensor<2,dim> strain_rate = symmetrize (grad_u);
+
+        // Calculate strain rate second invariant
+        const double edot_ii = std::sqrt(std::max(-second_invariant(deviator(strain_rate)), 0.));
+
+        // New strain is the old strain plus dt*edot_ii
+        const double new_strain = old_strain + dt*edot_ii;
+        data[data_position] = new_strain;
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      IntegratedStrainInvariant<dim>::need_update() const
+      {
+        return update_time_step;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      IntegratedStrainInvariant<dim>::get_needed_update_flags () const
+      {
+        return update_gradients;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      IntegratedStrainInvariant<dim>::get_property_information() const
+      {
+        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("integrated strain invariant",1));
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(IntegratedStrainInvariant,
+                                        "integrated strain invariant",
+                                        "A plugin in which the particle property is defined as "
+                                        "the finite strain invariant ($\\varepsilon_{ii}$). "
+                                        "This property is calculated with the timestep ($dt$) and "
+                                        "the second invariant of the deviatoric strain rate tensor "
+                                        "($\\dot{\\varepsilon}_{ii}$), where the value at time step $n$ is "
+                                        "$\\varepsilon_{ii}^{n} = \\varepsilon_{ii}^{n-1} + "
+                                        "dt\\dot{\\varepsilon}_{ii}$.")
+    }
+  }
+}
diff --git a/source/particle/property/interface.cc.bak b/source/particle/property/interface.cc.bak
new file mode 100644
index 00000000000..47027dc7d45
--- /dev/null
+++ b/source/particle/property/interface.cc.bak
@@ -0,0 +1,820 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/interface.h>
+#include <aspect/utilities.h>
+
+#include <aspect/particle/integrator/euler.h>
+#include <aspect/particle/integrator/rk_2.h>
+#include <aspect/particle/integrator/rk_4.h>
+
+
+#include <aspect/boundary_composition/interface.h>
+
+#include <deal.II/grid/grid_tools.h>
+
+#include <list>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ParticlePropertyInformation::ParticlePropertyInformation()
+        :
+        number_of_components(numbers::invalid_unsigned_int),
+        number_of_fields(numbers::invalid_unsigned_int),
+        number_of_plugins(numbers::invalid_unsigned_int)
+      {}
+
+
+
+      ParticlePropertyInformation::ParticlePropertyInformation(const std::vector<
+                                                               std::vector<
+                                                               std::pair<std::string,unsigned int>>> &properties)
+      {
+        unsigned int global_component_index = 0;
+        for (const auto &property : properties)
+          {
+            unsigned int component_per_plugin = 0;
+            unsigned int field_per_plugin = 0;
+
+            position_per_plugin.push_back(global_component_index);
+
+            for (const auto &entry : property)
+              {
+                const std::string  name         = entry.first;
+                const unsigned int n_components = entry.second;
+
+                field_names.push_back(name);
+                components_per_field.push_back(n_components);
+                position_per_field.push_back(global_component_index);
+                component_per_plugin += n_components;
+                global_component_index += n_components;
+                ++field_per_plugin;
+              }
+
+            fields_per_plugin.push_back(field_per_plugin);
+            components_per_plugin.push_back(component_per_plugin);
+          }
+
+        number_of_components = global_component_index;
+        number_of_fields = field_names.size();
+        number_of_plugins = properties.size();
+      }
+
+
+
+      bool
+      ParticlePropertyInformation::fieldname_exists(const std::string &name) const
+      {
+        return (std::find(field_names.begin(),field_names.end(),name) != field_names.end());
+      }
+
+      unsigned int
+      ParticlePropertyInformation::get_field_index_by_name(const std::string &name) const
+      {
+        const std::vector<std::string>::const_iterator field = std::find(field_names.begin(),
+                                                                         field_names.end(),
+                                                                         name);
+
+        AssertThrow(field != field_names.end(),
+                    ExcMessage("The particle property manager was asked for a property "
+                               "field with the name <" + name + ">, but no such field could "
+                               "be found."));
+        return std::distance(field_names.begin(),field);
+      }
+
+      std::string
+      ParticlePropertyInformation::get_field_name_by_index(const unsigned int field_index) const
+      {
+        Assert(field_index < field_names.size(),
+               ExcMessage("The number of field names (" + std::to_string(field_names.size())
+                          + ") is smaller than the requested field index ("
+                          + std::to_string(field_index) + ")."));
+
+        return field_names[field_index];
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::get_position_by_field_name(const std::string &name) const
+      {
+        const unsigned int field_index = get_field_index_by_name(name);
+        return position_per_field[field_index];
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::get_components_by_field_name(const std::string &name) const
+      {
+        const unsigned int field_index = get_field_index_by_name(name);
+        return components_per_field[field_index];
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::get_position_by_field_index(const unsigned int field_index) const
+      {
+        return position_per_field[field_index];
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::get_components_by_field_index(const unsigned int field_index) const
+      {
+        return components_per_field[field_index];
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::get_position_by_plugin_index(const unsigned int plugin_index) const
+      {
+        return position_per_plugin[plugin_index];
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::get_components_by_plugin_index(const unsigned int plugin_index) const
+      {
+        return components_per_plugin[plugin_index];
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::get_fields_by_plugin_index(const unsigned int plugin_index) const
+      {
+        return fields_per_plugin[plugin_index];
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::n_plugins() const
+      {
+        return number_of_plugins;
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::n_fields() const
+      {
+        return number_of_fields;
+      }
+
+
+
+      unsigned int
+      ParticlePropertyInformation::n_components() const
+      {
+        return number_of_components;
+      }
+
+
+
+      template <int dim>
+      void
+      Interface<dim>::initialize_one_particle_property (const Point<dim> &,
+                                                        std::vector<double> &) const
+      {}
+
+
+
+      DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
+      template <int dim>
+      void
+      Interface<dim>::update_particle_properties (const unsigned int data_position,
+                                                  const std::vector<Vector<double>> &solution,
+                                                  const std::vector<std::vector<Tensor<1,dim>>> &gradients,
+                                                  typename ParticleHandler<dim>::particle_iterator_range &particles) const
+      {
+        unsigned int i = 0;
+        for (typename ParticleHandler<dim>::particle_iterator particle = particles.begin();
+             particle != particles.end(); ++particle, ++i)
+          {
+            // call the deprecated version of this function
+            update_particle_property(data_position,
+                                     solution[i],
+                                     gradients[i],
+                                     particle);
+          }
+      }
+      DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
+
+
+
+      template <int dim>
+      void
+      Interface<dim>::update_particle_property (const unsigned int /*data_position*/,
+                                                const Vector<double> &/*solution*/,
+                                                const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                                typename ParticleHandler<dim>::particle_iterator &/*particle*/) const
+      {}
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      Interface<dim>::need_update () const
+      {
+        return update_never;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      Interface<dim>::get_needed_update_flags () const
+      {
+        return update_default;
+      }
+
+
+
+      template <int dim>
+      InitializationModeForLateParticles
+      Interface<dim>::late_initialization_mode () const
+      {
+        return interpolate;
+      }
+
+
+
+      template <int dim>
+      void
+      IntegratorProperties<dim>::initialize_one_particle_property(const Point<dim> &/*position*/,
+                                                                  std::vector<double> &data) const
+      {
+        data.resize(data.size() + n_integrator_properties, 0.0);
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      IntegratorProperties<dim>::get_property_information() const
+      {
+        return {{"internal: integrator properties", n_integrator_properties}};
+      }
+
+
+
+      template <int dim>
+      void
+      IntegratorProperties<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        std::string name;
+        name = prm.get ("Integration scheme");
+
+        if (name == "rk2")
+          n_integrator_properties = Particle::Integrator::RK2<dim>::n_integrator_properties;
+        else if (name == "rk4")
+          n_integrator_properties = Particle::Integrator::RK4<dim>::n_integrator_properties;
+        else if (name == "euler")
+          n_integrator_properties = Particle::Integrator::Euler<dim>::n_integrator_properties;
+        else
+          AssertThrow(false,
+                      ExcMessage("Unknown integrator scheme. The particle property 'Integrator properties' "
+                                 "does not know how many particle properties to store for this integration scheme."));
+      }
+
+
+
+      template <int dim>
+      inline
+      Manager<dim>::Manager ()
+        = default;
+
+
+
+      template <int dim>
+      inline
+      Manager<dim>::~Manager ()
+        = default;
+
+
+
+      template <int dim>
+      void
+      Manager<dim>::initialize ()
+      {
+        std::vector<std::vector<std::pair<std::string, unsigned int>>> info;
+
+        // Get the property information of the selected plugins
+        for (const auto &p : this->plugin_objects)
+          {
+            info.push_back(p->get_property_information());
+          }
+
+        // Initialize our property information
+        property_information = ParticlePropertyInformation(info);
+        for (const auto &p : this->plugin_objects)
+          {
+            p->initialize();
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      Manager<dim>::update ()
+      {
+        for (const auto &p : this->plugin_objects)
+          p->update();
+      }
+
+
+
+      template <int dim>
+      void
+      Manager<dim>::initialize_one_particle (typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        if (property_information.n_components() == 0)
+          return;
+
+        std::vector<double> particle_properties;
+        particle_properties.reserve(property_information.n_components());
+
+        for (const auto &p : this->plugin_objects)
+          {
+            p->initialize_one_particle_property(particle->get_location(),
+                                                particle_properties);
+          }
+
+        Assert(particle_properties.size() == property_information.n_components(),
+               ExcMessage("The reported numbers of particle property components do not sum up "
+                          "to the number of particle properties that were initialized by "
+                          "the property plugins. Check the selected property plugins for "
+                          "consistency between reported size and actually set properties."));
+
+        particle->set_properties(particle_properties);
+      }
+
+
+
+      template <int dim>
+      std::vector<double>
+      Manager<dim>::initialize_late_particle (const Point<dim> &particle_location,
+                                              const ParticleHandler<dim> &particle_handler,
+                                              const Interpolator::Interface<dim> &interpolator,
+                                              const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
+      {
+        if (property_information.n_components() == 0)
+          return {};
+
+        std::vector<double> particle_properties;
+        particle_properties.reserve(property_information.n_components());
+
+        unsigned int property_index = 0;
+        for (typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
+             p = this->plugin_objects.begin(); p!=this->plugin_objects.end(); ++p, ++property_index)
+          {
+            switch ((*p)->late_initialization_mode())
+              {
+                case aspect::Particle::Property::initialize_to_zero:
+                {
+                  for (unsigned int property_component = 0; property_component < property_information.get_components_by_plugin_index(property_index); ++property_component)
+                    particle_properties.push_back(0.0);
+                  break;
+                }
+
+                case aspect::Particle::Property::initialize:
+                {
+                  (*p)->initialize_one_particle_property(particle_location,
+                                                         particle_properties);
+                  break;
+                }
+
+                case aspect::Particle::Property::interpolate:
+                {
+                  typename parallel::distributed::Triangulation<dim>::cell_iterator found_cell;
+
+                  if (cell == typename parallel::distributed::Triangulation<dim>::active_cell_iterator())
+                    {
+                      found_cell = (GridTools::find_active_cell_around_point<> (this->get_mapping(),
+                                                                                this->get_triangulation(),
+                                                                                particle_location)).first;
+                    }
+                  else
+                    found_cell = cell;
+
+                  std::vector<std::vector<double>> interpolated_properties;
+
+                  try
+                    {
+                      interpolated_properties = interpolator.properties_at_points(particle_handler,
+                                                                                  std::vector<Point<dim>> (1,particle_location),
+                                                                                  ComponentMask(property_information.n_components(),true),
+                                                                                  found_cell);
+                    }
+                  // interpolators that throw exceptions usually do not result in
+                  // anything good, because they result in an unwinding of the stack
+                  // and, if only one processor triggers an exception, the
+                  // destruction of objects often causes a deadlock or completely
+                  // unrelated MPI error messages. Thus, if an exception is
+                  // generated, catch it, print an error message, and abort the program.
+                  catch (std::exception &exc)
+                    {
+                      std::cerr << std::endl << std::endl
+                                << "----------------------------------------------------"
+                                << std::endl;
+                      std::cerr << "Exception on MPI process <"
+                                << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                                << "> while generating new particle properties: "
+                                << std::endl
+                                << exc.what() << std::endl
+                                << "Aborting!" << std::endl
+                                << "----------------------------------------------------"
+                                << std::endl;
+
+                      // terminate the program!
+                      MPI_Abort (MPI_COMM_WORLD, 1);
+                    }
+
+                  for (unsigned int property_component = 0; property_component < property_information.get_components_by_plugin_index(property_index); ++property_component)
+                    particle_properties.push_back(interpolated_properties[0][property_information.get_position_by_plugin_index(property_index)+property_component]);
+                  break;
+                }
+
+                case aspect::Particle::Property::interpolate_respect_boundary:
+                {
+                  typename parallel::distributed::Triangulation<dim>::cell_iterator found_cell;
+
+                  if (cell == typename parallel::distributed::Triangulation<dim>::active_cell_iterator())
+                    {
+                      found_cell = (GridTools::find_active_cell_around_point<> (this->get_mapping(),
+                                                                                this->get_triangulation(),
+                                                                                particle_location)).first;
+                    }
+                  else
+                    found_cell = cell;
+
+                  const auto &manager = this->get_boundary_composition_manager();
+                  const auto &fixed_boundaries = manager.get_fixed_composition_boundary_indicators();
+
+                  // Determine if the current cell is at a Dirichlet boundary
+                  bool cell_at_fixed_boundary = false;
+                  unsigned int boundary_face = numbers::invalid_unsigned_int;
+                  double minimum_face_distance = std::numeric_limits<double>::max();
+                  for (const unsigned int f : cell->face_indices())
+                    if (cell->at_boundary(f) && fixed_boundaries.count(cell->face(f)->boundary_id()) == 1)
+                      {
+                        const double face_center_distance = particle_location.distance_square(cell->face(f)->center(true));
+                        if (face_center_distance < minimum_face_distance)
+                          {
+                            minimum_face_distance = face_center_distance;
+                            boundary_face = f;
+                            cell_at_fixed_boundary = true;
+                          }
+                      }
+
+                  // If no Dirichlet boundary, interpolate
+                  if (cell_at_fixed_boundary == false)
+                    {
+                      const std::vector<std::vector<double>> interpolated_properties = interpolator.properties_at_points(particle_handler,
+                                                                                        std::vector<Point<dim>> (1,particle_location),
+                                                                                        ComponentMask(property_information.n_components(),true),
+                                                                                        found_cell);
+                      for (unsigned int property_component = 0; property_component < property_information.get_components_by_plugin_index(property_index); ++property_component)
+                        particle_properties.push_back(interpolated_properties[0][property_information.get_position_by_plugin_index(property_index)+property_component]);
+                    }
+                  // Otherwise use the boundary condition
+                  else
+                    {
+                      Assert(property_information.get_components_by_plugin_index(property_index) == this->n_compositional_fields(),
+                             ExcInternalError());
+
+                      const types::boundary_id boundary_id = cell->face(boundary_face)->boundary_id();
+
+                      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                        {
+                          const double composition = manager.boundary_composition(boundary_id,particle_location,c);
+                          particle_properties.push_back(composition);
+                        }
+                    }
+
+                  break;
+                }
+
+                default:
+                  Assert (false, ExcInternalError());
+              }
+          }
+
+        Assert (particle_properties.size() == property_information.n_components(), ExcInternalError());
+
+        return particle_properties;
+      }
+
+
+
+      template <int dim>
+      void
+      Manager<dim>::update_particles (typename ParticleHandler<dim>::particle_iterator_range &particles,
+                                      const std::vector<Vector<double>> &solution,
+                                      const std::vector<std::vector<Tensor<1,dim>>> &gradients) const
+      {
+        unsigned int plugin_index = 0;
+        for (typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
+             p = this->plugin_objects.begin(); p!=this->plugin_objects.end(); ++p,++plugin_index)
+          {
+            (*p)->update_particle_properties(property_information.get_position_by_plugin_index(plugin_index),
+                                             solution,
+                                             gradients,
+                                             particles);
+          }
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      Manager<dim>::need_update () const
+      {
+        UpdateTimeFlags update = update_never;
+        for (const auto &p : this->plugin_objects)
+          {
+            update = std::max(update, p->need_update());
+          }
+        return update;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      Manager<dim>::get_needed_update_flags () const
+      {
+        UpdateFlags update = update_default;
+        for (const auto &p : this->plugin_objects)
+          {
+            update |= p->get_needed_update_flags();
+          }
+
+        return (update & (update_default | update_values | update_gradients));
+      }
+
+
+
+      template <int dim>
+      bool
+      Manager<dim>::plugin_name_exists(const std::string &name) const
+      {
+        return (std::find(plugin_names.begin(),plugin_names.end(),name) != plugin_names.end());
+      }
+
+
+
+      template <int dim>
+      bool
+      Manager<dim>::check_plugin_order(const std::string &first, const std::string &second) const
+      {
+
+        AssertThrow(first != second,
+                    ExcMessage("The first and second string are the same, so can not check the order."));
+        AssertThrow(plugin_name_exists(first),
+                    ExcMessage("Could not find a plugin with the name <" + first + ">."));
+        AssertThrow(plugin_name_exists(second),
+                    ExcMessage("Could not find a plugin with the name <" + second + ">."));
+
+        return (std::find(plugin_names.begin(),plugin_names.end(),first)
+                < std::find(plugin_names.begin(),plugin_names.end(),second));
+      }
+
+
+
+      template <int dim>
+      unsigned int
+      Manager<dim>::get_plugin_index_by_name(const std::string &name) const
+      {
+        const std::vector<std::string>::const_iterator plugin = std::find(plugin_names.begin(),
+                                                                          plugin_names.end(),
+                                                                          name);
+
+        AssertThrow(plugin != plugin_names.end(),
+                    ExcMessage("The particle property manager was asked for a plugin "
+                               "with the name <" + name + ">, but no such plugin could "
+                               "be found."));
+        return std::distance(plugin_names.begin(),plugin);
+      }
+
+
+
+      template <int dim>
+      unsigned int
+      Manager<dim>::get_n_property_components () const
+      {
+        return property_information.n_components();
+      }
+
+
+
+      template <int dim>
+      std::size_t
+      Manager<dim>::get_particle_size () const
+      {
+        return (property_information.n_components()+2*dim) * sizeof(double) + sizeof(types::particle_index);
+      }
+
+
+
+      template <int dim>
+      const ParticlePropertyInformation &
+      Manager<dim>::get_data_info () const
+      {
+        return property_information;
+      }
+
+
+
+      template <int dim>
+      unsigned int
+      Manager<dim>::get_property_component_by_name(const std::string &name) const
+      {
+        return property_information.get_position_by_field_name(name);
+      }
+
+
+
+      namespace
+      {
+        std::tuple
+        <void *,
+        void *,
+        aspect::internal::Plugins::PluginList<Property::Interface<2>>,
+        aspect::internal::Plugins::PluginList<Property::Interface<3>>> registered_plugins;
+      }
+
+
+
+      template <int dim>
+      void
+      Manager<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        // finally also construct a string for Patterns::MultipleSelection that
+        // contains the names of all registered particle properties
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry("List of particle properties",
+                          "",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma separated list of particle properties that should be tracked. "
+                          "By default none is selected, which means only position, velocity "
+                          "and id of the particles are output. \n\n"
+                          "The following properties are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+
+        // now declare the parameters of each of the registered
+        // particle properties in turn
+        std::get<dim>(registered_plugins).declare_parameters (prm);
+      }
+
+
+
+      template <int dim>
+      void
+      Manager<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        Assert (std::get<dim>(registered_plugins).plugins != nullptr,
+                ExcMessage ("No postprocessors registered!?"));
+
+        // now also see which derived quantities we are to compute
+        plugin_names = Utilities::split_string_list(prm.get("List of particle properties"));
+        AssertThrow(Utilities::has_unique_entries(plugin_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Particles/List of particle properties' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+
+        // see if 'all' was selected (or is part of the list). if so
+        // simply replace the list with one that contains all names
+        if (std::find (plugin_names.begin(),
+                       plugin_names.end(),
+                       "all") != plugin_names.end())
+          {
+            plugin_names.clear();
+            for (typename std::list<typename aspect::internal::Plugins::PluginList<aspect::Particle::Property::Interface<dim>>::PluginInfo>::const_iterator
+                 p = std::get<dim>(registered_plugins).plugins->begin();
+                 p != std::get<dim>(registered_plugins).plugins->end(); ++p)
+              plugin_names.push_back (std::get<0>(*p));
+          }
+
+        // then go through the list, create objects and let them parse
+        // their own parameters
+        for (auto &plugin_name : plugin_names)
+          {
+            this->plugin_objects.emplace_back (std::get<dim>(registered_plugins)
+                                               .create_plugin (plugin_name,
+                                                               "Particle property plugins"));
+
+            if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(this->plugin_objects.back().get()))
+              sim->initialize_simulator (this->get_simulator());
+
+            this->plugin_objects.back()->parse_parameters (prm);
+          }
+
+        // lastly store internal integrator properties
+        this->plugin_objects.emplace_back (std::make_unique<IntegratorProperties<dim>>());
+        this->plugin_objects.back()->parse_parameters (prm);
+      }
+
+
+
+      template <int dim>
+      void
+      Manager<dim>::set_particle_world_index(unsigned int particle_world_index)
+      {
+        for (auto &property : this->plugin_objects)
+          {
+            property->set_particle_world_index(particle_world_index);
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      Manager<dim>::
+      register_particle_property (const std::string &name,
+                                  const std::string &description,
+                                  void (*declare_parameters_function) (ParameterHandler &),
+                                  std::unique_ptr<Property::Interface<dim>> (*factory_function) ())
+      {
+        std::get<dim>(registered_plugins).register_plugin (name,
+                                                           description,
+                                                           declare_parameters_function,
+                                                           factory_function);
+      }
+
+
+
+      template <int dim>
+      void
+      Manager<dim>::write_plugin_graph (std::ostream &out)
+      {
+        std::get<dim>(registered_plugins).write_plugin_graph ("Particle property interface",
+                                                              out);
+      }
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<Particle::Property::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<Particle::Property::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<Particle::Property::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<Particle::Property::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace Particle
+  {
+    namespace Property
+    {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/source/particle/property/melt_particle.cc.bak b/source/particle/property/melt_particle.cc.bak
new file mode 100644
index 00000000000..fa80b32bee3
--- /dev/null
+++ b/source/particle/property/melt_particle.cc.bak
@@ -0,0 +1,126 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/particle/property/melt_particle.h>
+#include <aspect/simulator.h>
+#include <aspect/melt.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      MeltParticle<dim>::initialize_one_particle_property(const Point<dim> &/*position*/,
+                                                          std::vector<double> &data) const
+      {
+        data.push_back(0.0);
+      }
+
+      template <int dim>
+      void
+      MeltParticle<dim>::update_particle_property(const unsigned int data_position,
+                                                  const Vector<double> &solution,
+                                                  const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                                  typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                    ExcMessage("Particle property melt particle only works if"
+                               "there is a compositional field called porosity."));
+        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+        if (solution[this->introspection().component_indices.compositional_fields[porosity_idx]] > threshold_for_melt_presence)
+          particle->get_properties()[data_position] = 1.0;
+        else
+          particle->get_properties()[data_position] = 0.0;
+      }
+
+      template <int dim>
+      UpdateTimeFlags
+      MeltParticle<dim>::need_update() const
+      {
+        return update_time_step;
+      }
+
+      template <int dim>
+      UpdateFlags
+      MeltParticle<dim>::get_needed_update_flags () const
+      {
+        return update_values;
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      MeltParticle<dim>::get_property_information() const
+      {
+        std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("melt_presence",1));
+        return property_information;
+      }
+
+      template <int dim>
+      void
+      MeltParticle<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Melt particle");
+        {
+          prm.declare_entry ("Threshold for melt presence", "1e-3",
+                             Patterns::Double (0., 1.),
+                             "The minimum porosity that has to be present at the position of a particle "
+                             "for it to be considered a melt particle (in the sense that the melt presence "
+                             "property is set to 1).");
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      MeltParticle<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Melt particle");
+        {
+          threshold_for_melt_presence = prm.get_double ("Threshold for melt presence");
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(MeltParticle,
+                                        "melt particle",
+                                        "Implementation of a plugin in which the particle "
+                                        "property is defined as presence of melt above a "
+                                        "threshold, which can be set as an input parameter. "
+                                        "This property is set to 0 if melt is not present and "
+                                        "set to 1 if melt is present.")
+    }
+  }
+}
diff --git a/source/particle/property/pT_path.cc.bak b/source/particle/property/pT_path.cc.bak
new file mode 100644
index 00000000000..ffff2519a9e
--- /dev/null
+++ b/source/particle/property/pT_path.cc.bak
@@ -0,0 +1,123 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/pT_path.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/initial_temperature/interface.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      PTPath<dim>::initialize()
+      {
+        // Make sure we keep track of the initial temperature manager and
+        // that it continues to live beyond the time when the simulator
+        // class releases its pointer to it.
+        initial_temperature = this->get_initial_temperature_manager_pointer();
+      }
+
+
+
+
+      template <int dim>
+      void
+      PTPath<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                    std::vector<double> &data) const
+      {
+        // The following is strictly only correct whenever a particle is
+        // created in the first time step. After that, taking pressure and
+        // temperature from adiabatic and initial temperature objects is
+        // not quite correct -- instead, we should be initializing from
+        // the current pressure and temperature, but that is substantially
+        // more complicated since we are not passed this information.
+        //
+        // The issue is probably not terribly important because at least for
+        // all following time steps, we set temperature and pressure to
+        // their correct then-current values.
+        data.push_back(this->get_adiabatic_conditions().pressure(position));
+        data.push_back(initial_temperature->initial_temperature(position));
+      }
+
+
+
+      template <int dim>
+      void
+      PTPath<dim>::update_particle_property(const unsigned int data_position,
+                                            const Vector<double> &solution,
+                                            const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                            typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        particle->get_properties()[data_position]   = solution[this->introspection().component_indices.pressure];
+        particle->get_properties()[data_position+1] = solution[this->introspection().component_indices.temperature];
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      PTPath<dim>::need_update() const
+      {
+        return update_output_step;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      PTPath<dim>::get_needed_update_flags () const
+      {
+        return update_values;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      PTPath<dim>::get_property_information() const
+      {
+        return {{"p", 1}, {"T", 1}};
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(PTPath,
+                                        "pT path",
+                                        "Implementation of a plugin in which the particle "
+                                        "property is defined as the current pressure and "
+                                        "temperature at this position. This can be used "
+                                        "to generate pressure-temperature paths of "
+                                        "material points over time.")
+    }
+  }
+}
diff --git a/source/particle/property/position.cc.bak b/source/particle/property/position.cc.bak
new file mode 100644
index 00000000000..a21a0837482
--- /dev/null
+++ b/source/particle/property/position.cc.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/position.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      Position<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                      std::vector<double> &data) const
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          data.push_back(position[i]);
+      }
+
+      template <int dim>
+      void
+      Position<dim>::update_particle_property(const unsigned int data_position,
+                                              const Vector<double> &/*solution*/,
+                                              const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                              typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          particle->get_properties()[data_position+i] = particle->get_location()[i];
+      }
+
+      template <int dim>
+      UpdateTimeFlags
+      Position<dim>::need_update() const
+      {
+        return update_output_step;
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      Position<dim>::get_property_information() const
+      {
+        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("position",dim));
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(Position,
+                                        "position",
+                                        "Implementation of a plugin in which the particle "
+                                        "property is defined as the current position.")
+    }
+  }
+}
diff --git a/source/particle/property/reference_position.cc.bak b/source/particle/property/reference_position.cc.bak
new file mode 100644
index 00000000000..6d5fa5f978e
--- /dev/null
+++ b/source/particle/property/reference_position.cc.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/reference_position.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      ReferencePosition<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                               std::vector<double> &data) const
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          data.push_back(position[i]);
+      }
+
+      template <int dim>
+      void
+      ReferencePosition<dim>::update_particle_property(const unsigned int data_position,
+                                                       const Vector<double> &/*solution*/,
+                                                       const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                                       typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          particle->get_properties()[data_position+i] = particle->get_reference_location()[i];
+      }
+
+      template <int dim>
+      UpdateTimeFlags
+      ReferencePosition<dim>::need_update() const
+      {
+        return update_output_step;
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      ReferencePosition<dim>::get_property_information() const
+      {
+        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("reference position",dim));
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(ReferencePosition,
+                                        "reference position",
+                                        "Implementation of a plugin in which the particle "
+                                        "property is defined as the current reference position.")
+    }
+  }
+}
diff --git a/source/particle/property/strain_rate.cc.bak b/source/particle/property/strain_rate.cc.bak
new file mode 100644
index 00000000000..be79a182387
--- /dev/null
+++ b/source/particle/property/strain_rate.cc.bak
@@ -0,0 +1,102 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/strain_rate.h>
+#include <aspect/particle/property/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      StrainRate<dim>::initialize_one_particle_property(const Point<dim> &,
+                                                        std::vector<double> &data) const
+      {
+        const static Tensor<2,dim> identity = unit_symmetric_tensor<dim>();
+        for (unsigned int i = 0; i < Tensor<2,dim>::n_independent_components ; ++i)
+          data.push_back(identity[Tensor<2,dim>::unrolled_to_component_indices(i)]);
+
+      }
+
+      template <int dim>
+      void
+      StrainRate<dim>::update_particle_property(const unsigned int data_position,
+                                                const Vector<double> &/*solution*/,
+                                                const std::vector<Tensor<1,dim>> &gradients,
+                                                typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        const auto data = particle->get_properties();
+        // Velocity gradients
+        Tensor<2,dim> grad_u;
+        for (unsigned int d=0; d<dim; ++d)
+          grad_u[d] = gradients[d];
+
+        // Calculate strain rate from velocity gradients
+        const SymmetricTensor<2,dim> strain_rate = symmetrize (grad_u);
+
+        for (unsigned int i = 0; i < Tensor<2,dim>::n_independent_components ; ++i)
+          data[data_position + i] = strain_rate[Tensor<2,dim>::unrolled_to_component_indices(i)];
+
+      }
+
+      template <int dim>
+      UpdateTimeFlags
+      StrainRate<dim>::need_update() const
+      {
+        return update_time_step;
+      }
+
+      template <int dim>
+      UpdateFlags
+      StrainRate<dim>::get_needed_update_flags () const
+      {
+        return update_gradients;
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      StrainRate<dim>::get_property_information() const
+      {
+        const unsigned int n_components = Tensor<2,dim>::n_independent_components;
+        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("strainrate",n_components));
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(StrainRate,
+                                        "strain rate",
+                                        "Implementation of a plugin in which the time evolution of "
+                                        "strain rate is saved and stored on the particles.")
+    }
+  }
+}
diff --git a/source/particle/property/velocity.cc.bak b/source/particle/property/velocity.cc.bak
new file mode 100644
index 00000000000..82270e8db5b
--- /dev/null
+++ b/source/particle/property/velocity.cc.bak
@@ -0,0 +1,88 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/velocity.h>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      void
+      Velocity<dim>::initialize_one_particle_property(const Point<dim> &,
+                                                      std::vector<double> &data) const
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          data.push_back(0.0);
+      }
+
+      template <int dim>
+      void
+      Velocity<dim>::update_particle_property(const unsigned int data_position,
+                                              const Vector<double> &solution,
+                                              const std::vector<Tensor<1,dim>> &/*gradients*/,
+                                              typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          particle->get_properties()[data_position+i] = solution[this->introspection().component_indices.velocities[i]];
+      }
+
+      template <int dim>
+      UpdateTimeFlags
+      Velocity<dim>::need_update() const
+      {
+        return update_output_step;
+      }
+
+      template <int dim>
+      UpdateFlags
+      Velocity<dim>::get_needed_update_flags () const
+      {
+        return update_values;
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      Velocity<dim>::get_property_information() const
+      {
+        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("velocity",dim));
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(Velocity,
+                                        "velocity",
+                                        "Implementation of a plugin in which the particle "
+                                        "property is defined as the recent velocity at "
+                                        "this position.")
+    }
+  }
+}
diff --git a/source/particle/property/viscoplastic_strain_invariants.cc.bak b/source/particle/property/viscoplastic_strain_invariants.cc.bak
new file mode 100644
index 00000000000..8ea89a2cda2
--- /dev/null
+++ b/source/particle/property/viscoplastic_strain_invariants.cc.bak
@@ -0,0 +1,243 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/particle/property/viscoplastic_strain_invariants.h>
+#include <aspect/material_model/visco_plastic.h>
+#include <aspect/initial_composition/interface.h>
+
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+
+      template <int dim>
+      ViscoPlasticStrainInvariant<dim>::ViscoPlasticStrainInvariant ()
+        :
+        n_components(0),
+        material_inputs(1,0)
+      {}
+
+
+
+      template <int dim>
+      void
+      ViscoPlasticStrainInvariant<dim>::initialize ()
+      {
+        AssertThrow(Plugins::plugin_type_matches<const MaterialModel::ViscoPlastic<dim>>
+                    (this->get_material_model()),
+                    ExcMessage("This initial condition only makes sense in combination "
+                               "with the visco_plastic material model."));
+
+        n_components = 0;
+        material_inputs = MaterialModel::MaterialModelInputs<dim>(1,this->n_compositional_fields());
+
+        // Find out which fields are used.
+        if (this->introspection().compositional_name_exists("plastic_strain"))
+          n_components += 1;
+
+        if (this->introspection().compositional_name_exists("viscous_strain"))
+          n_components += 1;
+
+        if (this->introspection().compositional_name_exists("total_strain"))
+          n_components += 1;
+
+        if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
+          n_components += 1;
+
+        if (n_components == 0)
+          AssertThrow(false,
+                      ExcMessage("This particle property requires a compositional "
+                                 "strain field (plastic_strain, viscous_strain, "
+                                 "or total_strain)."));
+      }
+
+
+
+      template <int dim>
+      void
+      ViscoPlasticStrainInvariant<dim>::initialize_one_particle_property(const Point<dim> &position,
+                                                                         std::vector<double> &data) const
+      {
+        // Give each strain field its initial composition if one is prescribed.
+        if (this->introspection().compositional_name_exists("plastic_strain"))
+          data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("plastic_strain")));
+
+        if (this->introspection().compositional_name_exists("viscous_strain"))
+          data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("viscous_strain")));
+
+        if (this->introspection().compositional_name_exists("total_strain"))
+          data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("total_strain")));
+
+        if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
+          data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("noninitial_plastic_strain")));
+
+      }
+
+
+
+      template <int dim>
+      void
+      ViscoPlasticStrainInvariant<dim>::update_particle_property(const unsigned int data_position,
+                                                                 const Vector<double> &solution,
+                                                                 const std::vector<Tensor<1,dim>> &gradients,
+                                                                 typename ParticleHandler<dim>::particle_iterator &particle) const
+      {
+        // Current timestep
+        const double dt = this->get_timestep();
+
+        // Velocity gradients
+        Tensor<2,dim> grad_u;
+        for (unsigned int d=0; d<dim; ++d)
+          grad_u[d] = gradients[d];
+
+        material_inputs.pressure[0] = solution[this->introspection().component_indices.pressure];
+        material_inputs.temperature[0] = solution[this->introspection().component_indices.temperature];
+        material_inputs.position[0] = particle->get_location();
+
+        // Calculate strain rate from velocity gradients
+        material_inputs.strain_rate[0] = symmetrize (grad_u);
+
+        // Put compositional fields into single variable
+        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
+          {
+            material_inputs.composition[0][i] = solution[this->introspection().component_indices.compositional_fields[i]];
+          }
+
+        // Find out plastic yielding by calling function in material model.
+        const MaterialModel::ViscoPlastic<dim> &viscoplastic
+          = Plugins::get_plugin_as_type<const MaterialModel::ViscoPlastic<dim>>(this->get_material_model());
+
+        const bool plastic_yielding = viscoplastic.is_yielding(material_inputs);
+
+        // Next take the integrated strain invariant from the prior time step.
+        const auto data = particle->get_properties();
+
+        // Calculate strain rate second invariant
+        const double edot_ii = std::sqrt(std::max(-second_invariant(deviator(material_inputs.strain_rate[0])), 0.));
+
+        // Calculate strain invariant magnitude over the last time step
+        const double strain_update = dt*edot_ii;
+
+        /* Update the strain values that are used in the simulation, which use the following assumptions
+         * to identify the correct position in the data vector for each value:
+         * (1) Total strain cannot be used in combination with any other strain field
+         * (2) If plastic strain is tracked, it will always be in the first data position
+         * (3) If noninitial plastic strain is tracked, it will always be in the last data position
+         * (4) If noninitial plastic strain is tracked, plastic strain is also being tracked
+         * (5) If only viscous strain is tracked, it will be in the first data position.
+         * (6) If both viscous and plastic strain are tracked, viscous strain will be in the second data position
+         * If these assumptions change in the future, they will need to be updated.
+         * */
+
+        if (this->introspection().compositional_name_exists("plastic_strain") && plastic_yielding == true)
+          data[data_position] += strain_update;
+
+        if (this->introspection().compositional_name_exists("viscous_strain") && plastic_yielding == false)
+          {
+            // Not yielding and only one field, which tracks the viscous strain.
+            if (n_components == 1)
+              data[data_position] += strain_update;
+
+            // Not yielding and either two or three fields are tracked. If two fields are tracked,
+            // they represent plastic strain (first data position) and viscous strain (second data
+            // data position, updated below). If three fields are tracked, they represent plastic
+            // strain (first data position), viscous strain (second data position, updated below),
+            // and noninitial plastic strain (third data position). In either case, the viscous
+            // strain is in the second data position, allowing us to use a single expression.
+            if (n_components > 1)
+              data[data_position+1] += strain_update;
+          }
+
+        // Only one field, which tracks total strain and is updated regardless of whether the
+        // material is yielding or not.
+        if (this->introspection().compositional_name_exists("total_strain"))
+          data[data_position] += strain_update;
+
+        // Yielding, and noninitial plastic strain (last data position, updated below) is tracked.
+        if (this->introspection().compositional_name_exists("noninitial_plastic_strain") && plastic_yielding == true)
+          data[data_position+(n_components-1)] += strain_update;
+      }
+
+
+
+      template <int dim>
+      UpdateTimeFlags
+      ViscoPlasticStrainInvariant<dim>::need_update() const
+      {
+        return update_time_step;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      ViscoPlasticStrainInvariant<dim>::get_needed_update_flags () const
+      {
+        // Need to update both of these to send into material model.
+        return update_values | update_gradients;
+      }
+
+      template <int dim>
+      std::vector<std::pair<std::string, unsigned int>>
+      ViscoPlasticStrainInvariant<dim>::get_property_information() const
+      {
+        std::vector<std::pair<std::string,unsigned int>> property_information;
+
+        //Check which fields are used in model and make an output for each.
+        if (this->introspection().compositional_name_exists("plastic_strain"))
+          property_information.emplace_back("plastic_strain", 1);
+
+        if (this->introspection().compositional_name_exists("viscous_strain"))
+          property_information.emplace_back("viscous_strain", 1);
+
+        if (this->introspection().compositional_name_exists("total_strain"))
+          property_information.emplace_back("total_strain", 1);
+
+        if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
+          property_information.emplace_back("noninitial_plastic_strain", 1);
+
+        return property_information;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(ViscoPlasticStrainInvariant,
+                                        "viscoplastic strain invariants",
+                                        "A plugin that calculates the finite strain invariant a particle has "
+                                        "experienced and assigns it to either the plastic and/or viscous strain field based "
+                                        "on whether the material is plastically yielding, or the total strain field "
+                                        "used in the visco plastic material model. The implementation of this property "
+                                        "is equivalent to the implementation for compositional fields that is located in "
+                                        "the plugin in \\texttt{benchmarks/buiter\\_et\\_al\\_2008\\_jgr/plugin/},"
+                                        "and is effectively the same as what the visco plastic material model uses for compositional fields.")
+    }
+  }
+}
diff --git a/source/particle/world.cc.bak b/source/particle/world.cc.bak
new file mode 100644
index 00000000000..0c558f8a996
--- /dev/null
+++ b/source/particle/world.cc.bak
@@ -0,0 +1,1384 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/particle/world.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/citation_info.h>
+#include <aspect/simulator.h>
+#include <aspect/melt.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/grid/grid_tools.h>
+
+#include <deal.II/fe/mapping_cartesian.h>
+
+#include <boost/serialization/map.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+
+namespace aspect
+{
+  namespace Particle
+  {
+    template <int dim>
+    World<dim>::World()
+      = default;
+
+    template <int dim>
+    World<dim>::~World()
+      = default;
+
+    template <int dim>
+    void
+    World<dim>::initialize()
+    {
+      CitationInfo::add("particles");
+      if (particle_load_balancing & ParticleLoadBalancing::repartition)
+        this->get_triangulation().signals.weight.connect(
+#if DEAL_II_VERSION_GTE(9,6,0)
+          [&] (const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
+               const CellStatus status)
+          -> unsigned int
+#else
+          [&] (const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
+               const typename parallel::distributed::Triangulation<dim>::CellStatus status)
+          -> unsigned int
+#endif
+        {
+          return this->cell_weight(cell, status);
+        });
+
+      // Create a particle handler that stores the future particles.
+      // If we restarted from a checkpoint we will fill this particle handler
+      // later with its serialized variables and stored particles
+      particle_handler = std::make_unique<ParticleHandler<dim>>(this->get_triangulation(),
+                                                                 this->get_mapping(),
+                                                                 property_manager->get_n_property_components());
+
+      particle_handler_backup.initialize(this->get_triangulation(),
+                                         this->get_mapping(),
+                                         property_manager->get_n_property_components());
+
+      connect_to_signals(this->get_signals());
+
+      AssertThrow(this->introspection().get_composition_base_element_indices().size()<=1,
+                  ExcNotImplemented("Particles are not supported in computations with compositional fields with different finite element types."));
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::update()
+    {
+      generator->update();
+      integrator->update();
+      interpolator->update();
+      property_manager->update();
+    }
+
+
+
+    template <int dim>
+    const Property::Manager<dim> &
+    World<dim>::get_property_manager() const
+    {
+      return *property_manager;
+    }
+
+
+
+    template <int dim>
+    const Particles::ParticleHandler<dim> &
+    World<dim>::get_particle_handler() const
+    {
+      return *particle_handler.get();
+    }
+
+
+
+    template <int dim>
+    Particles::ParticleHandler<dim> &
+    World<dim>::get_particle_handler()
+    {
+      return *particle_handler.get();
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::copy_particle_handler (const Particles::ParticleHandler<dim> &from_particle_handler,
+                                       Particles::ParticleHandler<dim> &to_particle_handler) const
+    {
+      {
+        TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Copy");
+
+        to_particle_handler.copy_from(from_particle_handler);
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::backup_particles ()
+    {
+      copy_particle_handler (*particle_handler.get(), particle_handler_backup);
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::restore_particles ()
+    {
+      copy_particle_handler (particle_handler_backup, *particle_handler.get());
+    }
+
+
+
+    template <int dim>
+    const Interpolator::Interface<dim> &
+    World<dim>::get_interpolator() const
+    {
+      return *interpolator;
+    }
+
+
+
+    template <int dim>
+    types::particle_index
+    World<dim>::n_global_particles() const
+    {
+      return particle_handler->n_global_particles();
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::connect_to_signals(aspect::SimulatorSignals<dim> &signals)
+    {
+      signals.post_set_initial_state.connect(
+        [&] (const SimulatorAccess<dim> &)
+      {
+        this->setup_initial_state();
+      });
+
+      connect_particle_handler_signals(signals,*particle_handler);
+      // Particle handler backup will not be stored for checkpointing
+      connect_particle_handler_signals(signals, particle_handler_backup, false);
+
+      signals.post_refinement_load_user_data.connect(
+        [&] (typename parallel::distributed::Triangulation<dim> &)
+      {
+        this->apply_particle_per_cell_bounds();
+      });
+
+      signals.post_resume_load_user_data.connect(
+        [&] (typename parallel::distributed::Triangulation<dim> &)
+      {
+        this->apply_particle_per_cell_bounds();
+      });
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::connect_particle_handler_signals(aspect::SimulatorSignals<dim> &signals,
+                                                 ParticleHandler<dim> &particle_handler_,
+                                                 const bool connect_to_checkpoint_signals) const
+    {
+      signals.pre_refinement_store_user_data.connect(
+        [&] (typename parallel::distributed::Triangulation<dim> &)
+      {
+        particle_handler_.prepare_for_coarsening_and_refinement();
+      });
+
+      signals.post_refinement_load_user_data.connect(
+        [&] (typename parallel::distributed::Triangulation<dim> &)
+      {
+        particle_handler_.unpack_after_coarsening_and_refinement();
+      });
+
+      // Only connect to checkpoint signals if requested
+      if (connect_to_checkpoint_signals)
+        {
+          signals.pre_checkpoint_store_user_data.connect(
+            [&] (typename parallel::distributed::Triangulation<dim> &)
+          {
+            particle_handler_.prepare_for_serialization();
+          });
+
+          signals.post_resume_load_user_data.connect(
+            [&] (typename parallel::distributed::Triangulation<dim> &)
+          {
+            particle_handler_.deserialize();
+          });
+        }
+
+      if (update_ghost_particles &&
+          dealii::Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()) > 1)
+        {
+          auto do_ghost_exchange = [&] (typename parallel::distributed::Triangulation<dim> &)
+          {
+            particle_handler_.exchange_ghost_particles();
+          };
+          signals.post_refinement_load_user_data.connect(do_ghost_exchange);
+          signals.post_resume_load_user_data.connect(do_ghost_exchange);
+        }
+
+      signals.post_mesh_deformation.connect(
+        [&] (const SimulatorAccess<dim> &)
+      {
+        particle_handler->sort_particles_into_subdomains_and_cells();
+      },
+      boost::signals2::at_front);
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::apply_particle_per_cell_bounds()
+    {
+      // If any load balancing technique is selected that creates/destroys particles
+      if (particle_load_balancing & ParticleLoadBalancing::remove_and_add_particles)
+        {
+          // First do some preparation for particle generation in poorly
+          // populated areas. For this we need to know which particle ids to
+          // generate so that they are globally unique.
+          // Ensure this by communicating the number of particles that every
+          // process is going to generate.
+          particle_handler->update_cached_numbers();
+          types::particle_index local_next_particle_index = particle_handler->get_next_free_particle_index();
+          if (particle_load_balancing & ParticleLoadBalancing::add_particles)
+            {
+              types::particle_index particles_to_add_locally = 0;
+
+              // Loop over all cells and determine the number of particles to generate
+              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+                if (cell->is_locally_owned())
+                  {
+                    const unsigned int particles_in_cell = particle_handler->n_particles_in_cell(cell);
+
+                    if (particles_in_cell < min_particles_per_cell)
+                      particles_to_add_locally += static_cast<types::particle_index> (min_particles_per_cell - particles_in_cell);
+                  }
+
+              // Determine the starting particle index of this process, which
+              // is the highest currently existing particle index plus the sum
+              // of the number of newly generated particles of all
+              // processes with a lower rank.
+
+              types::particle_index local_start_index = 0.0;
+
+              const int ierr = MPI_Scan(&particles_to_add_locally, &local_start_index, 1, DEAL_II_PARTICLE_INDEX_MPI_TYPE, MPI_SUM, this->get_mpi_communicator());
+              AssertThrowMPI(ierr);
+
+              local_start_index -= particles_to_add_locally;
+              local_next_particle_index += local_start_index;
+
+              const types::particle_index globally_generated_particles =
+                dealii::Utilities::MPI::sum(particles_to_add_locally,this->get_mpi_communicator());
+
+              AssertThrow (particle_handler->get_next_free_particle_index()
+                           <= std::numeric_limits<types::particle_index>::max() - globally_generated_particles,
+                           ExcMessage("There is no free particle index left to generate a new particle id. Please check if your "
+                                      "model generates unusually many new particles (by repeatedly deleting and regenerating particles), or "
+                                      "recompile deal.II with the DEAL_II_WITH_64BIT_INDICES option enabled, to use 64-bit integers for "
+                                      "particle ids."));
+            }
+
+          std::mt19937 random_number_generator;
+
+          // Loop over all cells and generate or remove the particles cell-wise
+          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+            if (cell->is_locally_owned())
+              {
+                const unsigned int n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
+
+                // Add particles if necessary
+                if ((particle_load_balancing & ParticleLoadBalancing::add_particles) &&
+                    (n_particles_in_cell < min_particles_per_cell))
+                  {
+                    for (unsigned int i = n_particles_in_cell; i < min_particles_per_cell; ++i,++local_next_particle_index)
+                      {
+                        std::pair<Particles::internal::LevelInd,Particles::Particle<dim>> new_particle = generator->generate_particle(cell,local_next_particle_index);
+
+                        const std::vector<double> particle_properties =
+                          property_manager->initialize_late_particle(new_particle.second.get_location(),
+                                                                     *particle_handler,
+                                                                     *interpolator,
+                                                                     cell);
+
+                        typename ParticleHandler<dim>::particle_iterator particle = particle_handler->insert_particle(new_particle.second,
+                                                                                    typename parallel::distributed::Triangulation<dim>::cell_iterator (&this->get_triangulation(),
+                                                                                        new_particle.first.first,
+                                                                                        new_particle.first.second));
+                        particle->set_properties(particle_properties);
+                      }
+                  }
+
+                // Remove particles if necessary
+                else if ((particle_load_balancing & ParticleLoadBalancing::remove_particles) &&
+                         (n_particles_in_cell > max_particles_per_cell))
+                  {
+                    const unsigned int n_particles_to_remove = n_particles_in_cell - max_particles_per_cell;
+                    for (unsigned int i=0; i < n_particles_to_remove; ++i)
+                      {
+                        const unsigned int current_n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
+                        const unsigned int index_to_remove = std::uniform_int_distribution<unsigned int>
+                                                             (0,current_n_particles_in_cell-1)(random_number_generator);
+
+                        auto particle_to_remove = particle_handler->particles_in_cell(cell).begin();
+                        std::advance(particle_to_remove, index_to_remove);
+                        particle_handler->remove_particle(particle_to_remove);
+                      }
+
+                  }
+              }
+
+          particle_handler->update_cached_numbers();
+        }
+    }
+
+    template <int dim>
+    unsigned int
+    World<dim>::cell_weight(const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
+#if DEAL_II_VERSION_GTE(9,6,0)
+                            const CellStatus status
+#else
+                            const typename parallel::distributed::Triangulation<dim>::CellStatus status
+#endif
+                           )
+    {
+      if (cell->is_active() && !cell->is_locally_owned())
+        return 0;
+
+      const unsigned int base_weight = 1000;
+      unsigned int n_particles_in_cell = 0;
+      switch (status)
+        {
+#if DEAL_II_VERSION_GTE(9,6,0)
+          case CellStatus::cell_will_persist:
+          case CellStatus::cell_will_be_refined:
+            n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
+            break;
+
+          case CellStatus::cell_invalid:
+            break;
+
+          case CellStatus::children_will_be_coarsened:
+            for (const auto &child : cell->child_iterators())
+              n_particles_in_cell += particle_handler->n_particles_in_cell(child);
+            break;
+#else
+          case parallel::distributed::Triangulation<dim>::CELL_PERSIST:
+          case parallel::distributed::Triangulation<dim>::CELL_REFINE:
+            n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
+            break;
+
+          case parallel::distributed::Triangulation<dim>::CELL_INVALID:
+            break;
+
+          case parallel::distributed::Triangulation<dim>::CELL_COARSEN:
+            for (const auto &child : cell->child_iterators())
+              n_particles_in_cell += particle_handler->n_particles_in_cell(child);
+            break;
+#endif
+          default:
+            Assert(false, ExcInternalError());
+            break;
+        }
+      return base_weight + n_particles_in_cell * particle_weight;
+    }
+
+
+    template <int dim>
+    std::map<types::subdomain_id, unsigned int>
+    World<dim>::get_subdomain_id_to_neighbor_map() const
+    {
+      std::map<types::subdomain_id, unsigned int> subdomain_id_to_neighbor_map;
+      const std::set<types::subdomain_id> ghost_owners = this->get_triangulation().ghost_owners();
+      std::set<types::subdomain_id>::const_iterator ghost_owner = ghost_owners.begin();
+
+      for (unsigned int neighbor_id=0; neighbor_id<ghost_owners.size(); ++neighbor_id,++ghost_owner)
+        {
+          subdomain_id_to_neighbor_map.insert(std::make_pair(*ghost_owner,neighbor_id));
+        }
+      return subdomain_id_to_neighbor_map;
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::local_initialize_particles(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                                           const typename ParticleHandler<dim>::particle_iterator &end_particle)
+    {
+      for (typename ParticleHandler<dim>::particle_iterator it = begin_particle; it!=end_particle; ++it)
+        property_manager->initialize_one_particle(it);
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::local_update_particles(const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                       internal::SolutionEvaluators<dim> &evaluators)
+    {
+      const unsigned int n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
+      typename ParticleHandler<dim>::particle_iterator_range particles = particle_handler->particles_in_cell(cell);
+
+      std::vector<Point<dim>> positions;
+      positions.reserve(n_particles_in_cell);
+
+      for (const auto &particle : particles)
+        positions.push_back(particle.get_reference_location());
+
+      const UpdateFlags update_flags = property_manager->get_needed_update_flags();
+
+      boost::container::small_vector<double, 100> solution_values(this->get_fe().dofs_per_cell);
+
+      cell->get_dof_values(this->get_solution(),
+                           solution_values.begin(),
+                           solution_values.end());
+
+      if (update_flags & (update_values | update_gradients))
+        evaluators.reinit(cell, positions, {solution_values.data(), solution_values.size()}, update_flags);
+
+      std::vector<Vector<double>> solution;
+      if (update_flags & update_values)
+        solution.resize(n_particles_in_cell,Vector<double>(this->introspection().n_components));
+
+      std::vector<std::vector<Tensor<1,dim>>> gradients;
+      if (update_flags & update_gradients)
+        gradients.resize(n_particles_in_cell,std::vector<Tensor<1,dim>>(this->introspection().n_components));
+
+      for (unsigned int i = 0; i<n_particles_in_cell; ++i)
+        {
+          // Evaluate the solution, but only if it is requested in the update_flags
+          if (update_flags & update_values)
+            evaluators.get_solution(i, solution[i]);
+
+          // Evaluate the gradients, but only if they are requested in the update_flags
+          if (update_flags & update_gradients)
+            evaluators.get_gradients(i, gradients[i]);
+        }
+
+      property_manager->update_particles(particles,
+                                         solution,
+                                         gradients);
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::local_advect_particles(const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                       const typename ParticleHandler<dim>::particle_iterator &begin_particle,
+                                       const typename ParticleHandler<dim>::particle_iterator &end_particle,
+                                       internal::SolutionEvaluators<dim> &evaluators)
+    {
+      const unsigned int n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
+
+      boost::container::small_vector<Point<dim>, 100>   positions;
+      positions.reserve(n_particles_in_cell);
+      for (auto particle = begin_particle; particle!=end_particle; ++particle)
+        positions.push_back(particle->get_reference_location());
+
+      const std::array<bool, 3> required_solution_vectors = integrator->required_solution_vectors();
+
+      AssertThrow (required_solution_vectors[0] == false,
+                   ExcMessage("The integrator requires the old old solution vector, but it is not available."));
+
+
+      const bool use_fluid_velocity = this->include_melt_transport() &&
+                                      property_manager->get_data_info().fieldname_exists("melt_presence");
+
+      auto &evaluator = evaluators.get_velocity_or_fluid_velocity_evaluator(use_fluid_velocity);
+      auto &mapping_info = evaluators.get_mapping_info();
+      mapping_info.reinit(cell, {positions.data(),positions.size()});
+
+      std::vector<Tensor<1,dim>> velocities;
+      std::vector<Tensor<1,dim>> old_velocities;
+
+      if (required_solution_vectors[1] == true)
+        {
+          boost::container::small_vector<double, 100> old_solution_values(this->get_fe().dofs_per_cell);
+          cell->get_dof_values(this->get_old_solution(),
+                               old_solution_values.begin(),
+                               old_solution_values.end());
+
+          evaluator.evaluate({old_solution_values.data(),old_solution_values.size()},
+                             EvaluationFlags::values);
+
+          old_velocities.resize(n_particles_in_cell);
+          for (unsigned int i=0; i<n_particles_in_cell; ++i)
+            old_velocities[i] = evaluator.get_value(i);
+        }
+
+      if (required_solution_vectors[2] == true)
+        {
+          boost::container::small_vector<double, 100> solution_values(this->get_fe().dofs_per_cell);
+          cell->get_dof_values(this->get_current_linearization_point(),
+                               solution_values.begin(),
+                               solution_values.end());
+          evaluator.evaluate({solution_values.data(),solution_values.size()},
+                             EvaluationFlags::values);
+
+          velocities.resize(n_particles_in_cell);
+          for (unsigned int i=0; i<n_particles_in_cell; ++i)
+            velocities[i] = evaluator.get_value(i);
+        }
+
+      integrator->local_integrate_step(begin_particle,
+                                       end_particle,
+                                       old_velocities,
+                                       velocities,
+                                       this->get_timestep());
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::setup_initial_state ()
+    {
+      // If we are in the first adaptive refinement cycle generate particles
+      if (this->get_pre_refinement_step() == 0)
+        generate_particles();
+
+      // And initialize the particle properties according to the initial
+      // conditions on the current mesh
+      initialize_particles();
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::generate_particles()
+    {
+      TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Generate");
+      generator->generate_particles(*particle_handler);
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::initialize_particles()
+    {
+      // TODO: Change this loop over all cells to use the WorkStream interface
+      if (property_manager->get_n_property_components() > 0)
+        {
+          TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Initialize properties");
+
+          particle_handler->get_property_pool().reserve(2 * particle_handler->n_locally_owned_particles());
+
+
+          if (particle_handler->n_locally_owned_particles() > 0)
+            local_initialize_particles(particle_handler->begin(),
+                                       particle_handler->end());
+
+          if (update_ghost_particles &&
+              dealii::Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()) > 1)
+            {
+              TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Exchange ghosts");
+              particle_handler->exchange_ghost_particles();
+            }
+        }
+    }
+
+
+
+    namespace internal
+    {
+      // This class evaluates the solution vector at arbitrary positions inside a cell.
+      // It uses the deal.II class FEPointEvaluation to do this efficiently. Because
+      // FEPointEvaluation only supports a single finite element, but ASPECT uses a FESystem with
+      // many components, this class creates several FEPointEvaluation objects that are used for
+      // the individual finite elements of our solution (pressure, velocity, temperature, and
+      // all other optional variables). Because FEPointEvaluation is templated based on the
+      // number of components, but ASPECT only knows the number of components at runtime
+      // we create this derived class with an additional template. This makes it possible
+      // to access the functionality through the base class, but create an object of this
+      // derived class with the correct number of components at runtime.
+      template <int dim, int n_compositional_fields>
+      class SolutionEvaluatorsImplementation: public SolutionEvaluators<dim>
+      {
+        public:
+          // Constructor. Create the member variables given a simulator and a set of
+          // update flags. The update flags control if only the solution or also the gradients
+          // should be evaluated.
+          SolutionEvaluatorsImplementation(const SimulatorAccess<dim> &simulator,
+                                           const UpdateFlags update_flags);
+
+          // Reinitialize all variables to evaluate the given solution for the given cell
+          // and the given positions. The update flags control if only the solution or
+          // also the gradients should be evaluated.
+          // If other flags are set an assertion is triggered.
+          void
+          reinit(const typename DoFHandler<dim>::active_cell_iterator &cell,
+                 const ArrayView<Point<dim>> &positions,
+                 const ArrayView<double> &solution_values,
+                 const UpdateFlags update_flags) override;
+
+          // Return the value of all solution components at the given evaluation point. Note
+          // that this function only works after a successful call to reinit(),
+          // because this function only returns the results of the computation that
+          // happened in reinit().
+          void get_solution(const unsigned int evaluation_point,
+                            Vector<double> &solution) override;
+
+          // Return the value of all solution gradients at the given evaluation point. Note
+          // that this function only works after a successful call to reinit(),
+          // because this function only returns the results of the computation that
+          // happened in reinit().
+          void get_gradients(const unsigned int evaluation_point,
+                             std::vector<Tensor<1,dim>> &gradients) override;
+
+          // Return the evaluator for velocity or fluid velocity. This is the only
+          // information necessary for advecting particles.
+          FEPointEvaluation<dim, dim> &
+          get_velocity_or_fluid_velocity_evaluator(const bool use_fluid_velocity) override;
+
+          // Return the cached mapping information.
+          NonMatching::MappingInfo<dim> &
+          get_mapping_info() override;
+        private:
+          // MappingInfo object for the FEPointEvaluation objects
+          NonMatching::MappingInfo<dim> mapping_info;
+
+          // FEPointEvaluation objects for all common
+          // components of ASPECT's finite element solution.
+          // These objects are used inside of the member functions of this class.
+          FEPointEvaluation<dim, dim> velocity;
+          std::unique_ptr<FEPointEvaluation<1, dim>> pressure;
+          FEPointEvaluation<1, dim> temperature;
+
+          // If instantiated evaluate multiple compositions at once, if
+          // not fall back to evaluating them individually.
+          FEPointEvaluation<n_compositional_fields, dim> compositions;
+          std::vector<FEPointEvaluation<1, dim>> additional_compositions;
+
+          // Pointers to FEPointEvaluation objects for all melt
+          // components of ASPECT's finite element solution, which only
+          // point to valid objects in case we use melt transport. Other
+          // documentation like for the objects directly above.
+          std::unique_ptr<FEPointEvaluation<dim, dim>> fluid_velocity;
+          std::unique_ptr<FEPointEvaluation<1, dim>> compaction_pressure;
+          std::unique_ptr<FEPointEvaluation<1, dim>> fluid_pressure;
+
+          // The component indices for the three melt formulation
+          // variables fluid velocity, compaction pressure, and
+          // fluid pressure (in this order). They are cached
+          // to avoid repeated expensive lookups.
+          std::array<unsigned int, 3> melt_component_indices;
+
+          // Reference to the active simulator access object. Provides
+          // access to the general simulation variables.
+          const SimulatorAccess<dim> &simulator_access;
+      };
+
+
+
+      template <int dim, int n_compositional_fields>
+      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::SolutionEvaluatorsImplementation(const SimulatorAccess<dim> &simulator,
+          const UpdateFlags update_flags)
+        :
+        mapping_info(simulator.get_mapping(),
+                     update_flags),
+        velocity(mapping_info,
+                 simulator.get_fe(),
+                 simulator.introspection().component_indices.velocities[0]),
+        pressure(std::make_unique<FEPointEvaluation<1, dim>>(mapping_info,
+                                                              simulator.get_fe(),
+                                                              simulator.introspection().component_indices.pressure)),
+        temperature(mapping_info,
+                    simulator.get_fe(),
+                    simulator.introspection().component_indices.temperature),
+        compositions(mapping_info,
+                     simulator.get_fe(),
+                     simulator.n_compositional_fields() > 0 ? simulator.introspection().component_indices.compositional_fields[0] : simulator.introspection().component_indices.temperature),
+
+        melt_component_indices(),
+        simulator_access(simulator)
+      {
+        // Create the evaluators for all compositional fields beyond the ones this class was
+        // instantiated for
+        const unsigned int n_total_compositional_fields = simulator_access.n_compositional_fields();
+        const auto &component_indices = simulator_access.introspection().component_indices.compositional_fields;
+        for (unsigned int composition = n_compositional_fields; composition < n_total_compositional_fields; ++composition)
+          additional_compositions.emplace_back(FEPointEvaluation<1, dim>(mapping_info,
+                                                                         simulator_access.get_fe(),
+                                                                         component_indices[composition]));
+
+        // The FE_DGP pressure element used in locally conservative discretization is not
+        // supported by the fast path of FEPointEvaluation. Replace with slow path.
+        if (simulator_access.get_parameters().use_locally_conservative_discretization == true)
+          pressure = std::make_unique<FEPointEvaluation<1, dim>>(simulator_access.get_mapping(),
+                                                                  simulator_access.get_fe(),
+                                                                  update_flags,
+                                                                  simulator.introspection().component_indices.pressure);
+
+        // Create the melt evaluators, but only if we use melt transport in the model
+        if (simulator_access.include_melt_transport())
+          {
+            // Store the melt component indices to avoid repeated string lookups later on
+            melt_component_indices[0] = simulator_access.introspection().variable("fluid velocity").first_component_index;
+            melt_component_indices[1] = simulator_access.introspection().variable("fluid pressure").first_component_index;
+            melt_component_indices[2] = simulator_access.introspection().variable("compaction pressure").first_component_index;
+
+            fluid_velocity = std::make_unique<FEPointEvaluation<dim, dim>>(mapping_info,
+                                                                            simulator_access.get_fe(),
+                                                                            melt_component_indices[0]);
+            if (simulator_access.get_parameters().use_locally_conservative_discretization == false)
+              fluid_pressure = std::make_unique<FEPointEvaluation<1, dim>>(mapping_info,
+                                                                            simulator_access.get_fe(),
+                                                                            melt_component_indices[1]);
+            else
+              {
+                fluid_pressure = std::make_unique<FEPointEvaluation<1, dim>>(simulator_access.get_mapping(),
+                                                                              simulator_access.get_fe(),
+                                                                              update_flags,
+                                                                              melt_component_indices[1]);
+              }
+
+            if (simulator_access.get_melt_handler().melt_parameters.use_discontinuous_p_c == false)
+              compaction_pressure = std::make_unique<FEPointEvaluation<1, dim>>(mapping_info,
+                                                                                 simulator_access.get_fe(),
+                                                                                 melt_component_indices[2]);
+            else
+              compaction_pressure = std::make_unique<FEPointEvaluation<1, dim>>(simulator_access.get_mapping(),
+                                                                                 simulator_access.get_fe(),
+                                                                                 update_flags,
+                                                                                 melt_component_indices[2]);
+
+
+          }
+      }
+
+
+
+      template <int dim, int n_compositional_fields>
+      void
+      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::reinit(const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                                                            const ArrayView<Point<dim>> &positions,
+                                                                            const ArrayView<double> &solution_values,
+                                                                            const UpdateFlags update_flags)
+      {
+        // FEPointEvaluation uses different evaluation flags than the common UpdateFlags.
+        // Translate between the two.
+        EvaluationFlags::EvaluationFlags evaluation_flags = EvaluationFlags::nothing;
+
+        if (update_flags & update_values)
+          evaluation_flags = evaluation_flags | EvaluationFlags::values;
+
+        if (update_flags & update_gradients)
+          evaluation_flags = evaluation_flags | EvaluationFlags::gradients;
+
+        // Make sure only the flags are set that we can deal with at the moment
+        Assert ((update_flags & ~(update_gradients | update_values)) == false,
+                ExcNotImplemented());
+
+        // Reinitialize and evaluate all evaluators.
+        // TODO: It would be nice to be able to hand over a ComponentMask
+        // to specify which evaluators to use. Currently, this is only
+        // possible by manually accessing the public members of this class.
+        mapping_info.reinit(cell,positions);
+
+        if (simulator_access.get_parameters().use_locally_conservative_discretization == true)
+          {
+            pressure->reinit(cell, positions);
+
+            if (simulator_access.include_melt_transport())
+              {
+                fluid_pressure->reinit (cell, positions);
+              }
+          }
+
+        if (simulator_access.include_melt_transport()
+            && simulator_access.get_melt_handler().melt_parameters.use_discontinuous_p_c == true)
+          {
+            compaction_pressure->reinit (cell, positions);
+          }
+
+
+        velocity.evaluate (solution_values, evaluation_flags);
+        pressure->evaluate (solution_values, evaluation_flags);
+        temperature.evaluate (solution_values, evaluation_flags);
+        compositions.evaluate (solution_values, evaluation_flags);
+
+        for (auto &evaluator_composition: additional_compositions)
+          evaluator_composition.evaluate (solution_values, evaluation_flags);
+
+        if (simulator_access.include_melt_transport())
+          {
+            fluid_velocity->evaluate (solution_values, evaluation_flags);
+            fluid_pressure->evaluate (solution_values, evaluation_flags);
+            compaction_pressure->evaluate (solution_values, evaluation_flags);
+          }
+      }
+
+      namespace
+      {
+        template <int n_compositional_fields>
+        double
+        get_value(const Tensor<1,n_compositional_fields> &solution,
+                  const unsigned int component_index)
+        {
+          AssertIndexRange(component_index, n_compositional_fields);
+          return solution[component_index];
+        }
+
+        template <int n_compositional_fields>
+        double
+        get_value(const double &solution,
+                  const unsigned int component_index)
+        {
+          (void) component_index;
+          AssertIndexRange(component_index, 1);
+          return solution;
+        }
+
+        template <int dim, int n_compositional_fields>
+        Tensor<1,dim>
+        get_gradient(const Tensor<1,n_compositional_fields,Tensor<1,dim>> &gradient,
+                     const unsigned int component_index)
+        {
+          AssertIndexRange(component_index, n_compositional_fields);
+          return gradient[component_index];
+        }
+
+
+        template <int dim, int n_compositional_fields>
+        Tensor<1,dim>
+        get_gradient(const Tensor<1,dim> &gradient,
+                     const unsigned int component_index)
+        {
+          (void) component_index;
+          AssertIndexRange(component_index, 1);
+          return gradient;
+        }
+      }
+
+
+      template <int dim, int n_compositional_fields>
+      void
+      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::get_solution(const unsigned int evaluation_point,
+                                                                                  Vector<double> &solution)
+      {
+        Assert(solution.size() == simulator_access.introspection().n_components,
+               ExcDimensionMismatch(solution.size(), simulator_access.introspection().n_components));
+
+        const auto &component_indices = simulator_access.introspection().component_indices;
+
+        const Tensor<1,dim> velocity_value = velocity.get_value(evaluation_point);
+        for (unsigned int j=0; j<dim; ++j)
+          solution[component_indices.velocities[j]] = velocity_value[j];
+
+        solution[component_indices.pressure] = pressure->get_value(evaluation_point);
+        solution[component_indices.temperature] = temperature.get_value(evaluation_point);
+
+        if (n_compositional_fields > 0)
+          for (unsigned int j=0; j<n_compositional_fields; ++j)
+            solution[component_indices.compositional_fields[j]] = get_value<n_compositional_fields>(
+                                                                    compositions.get_value(evaluation_point),
+                                                                    j);
+
+        const unsigned int n_additional_compositions = additional_compositions.size();
+        for (unsigned int j=0; j<n_additional_compositions; ++j)
+          solution[component_indices.compositional_fields[n_compositional_fields+j]] = additional_compositions[j].get_value(evaluation_point);
+
+        if (simulator_access.include_melt_transport())
+          {
+            const Tensor<1,dim> fluid_velocity_value = velocity.get_value(evaluation_point);
+            for (unsigned int j=0; j<dim; ++j)
+              solution[melt_component_indices[0]+j] = fluid_velocity_value[j];
+
+            solution[melt_component_indices[1]] = fluid_pressure->get_value(evaluation_point);
+            solution[melt_component_indices[2]] = compaction_pressure->get_value(evaluation_point);
+          }
+      }
+
+
+
+      template <int dim, int n_compositional_fields>
+      void
+      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::get_gradients(const unsigned int evaluation_point,
+                                                                                   std::vector<Tensor<1,dim>> &gradients)
+      {
+        Assert(gradients.size() == simulator_access.introspection().n_components,
+               ExcDimensionMismatch(gradients.size(), simulator_access.introspection().n_components));
+
+        const auto &component_indices = simulator_access.introspection().component_indices;
+
+        const Tensor<2,dim> velocity_gradient = velocity.get_gradient(evaluation_point);
+        for (unsigned int j=0; j<dim; ++j)
+          gradients[component_indices.velocities[j]] = velocity_gradient[j];
+
+        gradients[component_indices.pressure] = pressure->get_gradient(evaluation_point);
+        gradients[component_indices.temperature] = temperature.get_gradient(evaluation_point);
+
+        if (n_compositional_fields > 0)
+          for (unsigned int j=0; j<n_compositional_fields; ++j)
+            gradients[component_indices.compositional_fields[j]] = get_gradient<dim,n_compositional_fields>(
+                                                                     compositions.get_gradient(evaluation_point),
+                                                                     j);
+
+        const unsigned int n_additional_compositions = additional_compositions.size();
+        for (unsigned int j=0; j<n_additional_compositions; ++j)
+          gradients[component_indices.compositional_fields[n_compositional_fields+j]] = additional_compositions[j].get_gradient(evaluation_point);
+
+        if (simulator_access.include_melt_transport())
+          {
+            const Tensor<2,dim> fluid_velocity_gradient = velocity.get_gradient(evaluation_point);
+            for (unsigned int j=0; j<dim; ++j)
+              gradients[melt_component_indices[0]+j] = fluid_velocity_gradient[j];
+
+            gradients[melt_component_indices[1]] = fluid_pressure->get_gradient(evaluation_point);
+            gradients[melt_component_indices[2]] = compaction_pressure->get_gradient(evaluation_point);
+          }
+      }
+
+
+      template <int dim, int n_compositional_fields>
+      FEPointEvaluation<dim, dim> &
+      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::get_velocity_or_fluid_velocity_evaluator(const bool use_fluid_velocity)
+      {
+        if (use_fluid_velocity)
+          return *fluid_velocity;
+        else
+          return velocity;
+
+        return velocity;
+      }
+      template <int dim, int n_compositional_fields>
+      NonMatching::MappingInfo<dim> &
+      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::get_mapping_info()
+      {
+        return mapping_info;
+      }
+
+
+
+      // A function to create a pointer to a SolutionEvaluators object.
+      template <int dim>
+      std::unique_ptr<internal::SolutionEvaluators<dim>>
+      construct_solution_evaluators (const SimulatorAccess<dim> &simulator_access,
+                                     const UpdateFlags update_flags)
+      {
+        switch (simulator_access.n_compositional_fields())
+          {
+            case 0:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,0>>(simulator_access, update_flags);
+            case 1:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,1>>(simulator_access, update_flags);
+            case 2:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,2>>(simulator_access, update_flags);
+            case 3:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,3>>(simulator_access, update_flags);
+            case 4:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,4>>(simulator_access, update_flags);
+            case 5:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,5>>(simulator_access, update_flags);
+            case 6:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,6>>(simulator_access, update_flags);
+            case 7:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,7>>(simulator_access, update_flags);
+            case 8:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,8>>(simulator_access, update_flags);
+            case 9:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,9>>(simulator_access, update_flags);
+            case 10:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,10>>(simulator_access, update_flags);
+            case 11:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,11>>(simulator_access, update_flags);
+            case 12:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,12>>(simulator_access, update_flags);
+            case 13:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,13>>(simulator_access, update_flags);
+            case 14:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,14>>(simulator_access, update_flags);
+            case 15:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,15>>(simulator_access, update_flags);
+            case 16:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,16>>(simulator_access, update_flags);
+            case 17:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,17>>(simulator_access, update_flags);
+            case 18:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,18>>(simulator_access, update_flags);
+            case 19:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,19>>(simulator_access, update_flags);
+            // Return the maximally instantiated object. The class will handle additional compositional fields
+            // by dynamically allocating additional scalar evaluators.
+            default:
+              return std::make_unique<SolutionEvaluatorsImplementation<dim,20>>(simulator_access, update_flags);
+          }
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::update_particles()
+    {
+      // TODO: Change this loop over all cells to use the WorkStream interface
+
+      if (property_manager->get_n_property_components() > 0)
+        {
+          TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Update properties");
+
+          Assert(dealii::internal::FEPointEvaluation::is_fast_path_supported(this->get_mapping()) == true,
+                 ExcMessage("The particle system was optimized for deal.II mappings that support the fast evaluation path "
+                            "of the class FEPointEvaluation. The mapping currently in use does not support this path. "
+                            "It is safe to uncomment this assertion, but you can expect a performance penalty."));
+
+          const UpdateFlags update_flags = property_manager->get_needed_update_flags();
+
+          std::unique_ptr<internal::SolutionEvaluators<dim>> evaluators = internal::construct_solution_evaluators(*this,
+                                                                           update_flags);
+
+          // Loop over all cells and update the particles cell-wise
+          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+            if (cell->is_locally_owned())
+              {
+                // Only update particles if there are any in this cell
+                if (particle_handler->n_particles_in_cell(cell) > 0)
+                  {
+                    local_update_particles(cell,
+                                           *evaluators);
+                  }
+
+              }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::advect_particles()
+    {
+      {
+        // TODO: Change this loop over all cells to use the WorkStream interface
+        TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Advect");
+
+        Assert(dealii::internal::FEPointEvaluation::is_fast_path_supported(this->get_mapping()) == true,
+               ExcMessage("The particle system was optimized for deal.II mappings that support the fast evaluation path "
+                          "of the class FEPointEvaluation. The mapping currently in use does not support this path. "
+                          "It is safe to uncomment this assertion, but you can expect a performance penalty."));
+
+        std::unique_ptr<internal::SolutionEvaluators<dim>> evaluators =
+          std::make_unique<internal::SolutionEvaluatorsImplementation<dim, 0>>(*this,
+                                                                                update_values);
+
+        // Loop over all cells and advect the particles cell-wise
+        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              const typename ParticleHandler<dim>::particle_iterator_range
+              particles_in_cell = particle_handler->particles_in_cell(cell);
+
+              // Only advect particles, if there are any in this cell
+              if (particles_in_cell.begin() != particles_in_cell.end())
+                {
+                  local_advect_particles(cell,
+                                         particles_in_cell.begin(),
+                                         particles_in_cell.end(),
+                                         *evaluators);
+                }
+            }
+      }
+
+      {
+        TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Sort");
+        // Find the cells that the particles moved to
+        particle_handler->sort_particles_into_subdomains_and_cells();
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::advance_timestep()
+    {
+      this->get_pcout() << "   Advecting particles... " << std::flush;
+      do
+        {
+          advect_particles();
+        }
+      // Keep calling the integrator until it indicates it is finished
+      while (integrator->new_integration_step());
+
+      apply_particle_per_cell_bounds();
+
+      // Update particle properties
+      if (property_manager->need_update() == Property::update_time_step)
+        update_particles();
+
+      // Now that all particle information was updated, exchange the new
+      // ghost particles.
+      if (update_ghost_particles &&
+          dealii::Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()) > 1)
+        {
+          TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Exchange ghosts");
+          particle_handler->exchange_ghost_particles();
+        }
+      this->get_pcout() << " done." << std::endl;
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::save (std::ostringstream &os) const
+    {
+      aspect::oarchive oa (os);
+      oa << (*this);
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::load (std::istringstream &is)
+    {
+      aspect::iarchive ia (is);
+      ia >> (*this);
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      constexpr unsigned int number_of_particle_worlds = 1;
+      for (unsigned int world_index = 0; world_index < number_of_particle_worlds; ++world_index)
+        {
+          if (world_index == 0)
+            {
+              prm.enter_subsection("Particles");
+            }
+          else
+            {
+              prm.enter_subsection("Particles " + std::to_string(world_index+1));
+            }
+          {
+            prm.declare_entry ("Load balancing strategy", "repartition",
+                               Patterns::MultipleSelection ("none|remove particles|add particles|"
+                                                            "remove and add particles|repartition"),
+                               "Strategy that is used to balance the computational "
+                               "load across processors for adaptive meshes.");
+            prm.declare_entry ("Minimum particles per cell", "0",
+                               Patterns::Integer (0),
+                               "Lower limit for particle number per cell. This limit is "
+                               "useful for adaptive meshes to prevent fine cells from being empty "
+                               "of particles. It will be checked and enforced after mesh "
+                               "refinement and after particle movement. "
+                               "If there are "
+                               "\\texttt{n\\_number\\_of\\_particles} $<$ \\texttt{min\\_particles\\_per\\_cell} "
+                               "particles in one cell then "
+                               "\\texttt{min\\_particles\\_per\\_cell} - \\texttt{n\\_number\\_of\\_particles} "
+                               "particles are generated and randomly placed in "
+                               "this cell. If the particles carry properties the "
+                               "individual property plugins control how the "
+                               "properties of the new particles are initialized.");
+            prm.declare_entry ("Maximum particles per cell", "100",
+                               Patterns::Integer (0),
+                               "Upper limit for particle number per cell. This limit is "
+                               "useful for adaptive meshes to prevent coarse cells from slowing down "
+                               "the whole model. It will be checked and enforced after mesh "
+                               "refinement, after MPI transfer of particles and after particle "
+                               "movement. If there are "
+                               "\\texttt{n\\_number\\_of\\_particles} $>$ \\texttt{max\\_particles\\_per\\_cell} "
+                               "particles in one cell then "
+                               "\\texttt{n\\_number\\_of\\_particles} - \\texttt{max\\_particles\\_per\\_cell} "
+                               "particles in this cell are randomly chosen and destroyed.");
+            prm.declare_entry ("Particle weight", "10",
+                               Patterns::Integer (0),
+                               "Weight that is associated with the computational load of "
+                               "a single particle. The sum of particle weights will be added "
+                               "to the sum of cell weights to determine the partitioning of "
+                               "the mesh if the `repartition' particle load balancing strategy "
+                               "is selected. The optimal weight depends on the used "
+                               "integrator and particle properties. In general for a more "
+                               "expensive integrator and more expensive properties a larger "
+                               "particle weight is recommended. Before adding the weights "
+                               "of particles, each cell already carries a weight of 1000 to "
+                               "account for the cost of field-based computations.");
+            prm.declare_entry ("Update ghost particles", "false",
+                               Patterns::Bool (),
+                               "Some particle interpolation algorithms require knowledge "
+                               "about particles in neighboring cells. To allow this, "
+                               "particles in ghost cells need to be exchanged between the "
+                               "processes neighboring this cell. This parameter determines "
+                               "whether this transport is happening.");
+
+            Generator::declare_parameters<dim>(prm);
+            Integrator::declare_parameters<dim>(prm);
+            Interpolator::declare_parameters<dim>(prm);
+
+            Property::Manager<dim>::declare_parameters(prm);
+          }
+          prm.leave_subsection ();
+        }
+
+    }
+
+
+
+    template <int dim>
+    void
+    World<dim>::parse_parameters (ParameterHandler &prm, const unsigned int world_index)
+    {
+      // First do some error checking. The current algorithm does not find
+      // the cells around particles, if the particles moved more than one
+      // cell in one timestep and we are running in parallel, because they
+      // skip the layer of ghost cells around our local domain. Assert this
+      // is not possible.
+      const double CFL_number = prm.get_double ("CFL number");
+      const unsigned int n_processes = Utilities::MPI::n_mpi_processes(this->get_mpi_communicator());
+
+      AssertThrow((n_processes == 1) || (CFL_number <= 1.0),
+                  ExcMessage("The current particle algorithm does not work in "
+                             "parallel if the CFL number is larger than 1.0, because "
+                             "in this case particles can move more than one cell "
+                             "diameter in one time step and therefore skip the layer "
+                             "of ghost cells around the local subdomain."));
+
+      if (world_index == 0)
+        {
+          prm.enter_subsection("Particles");
+        }
+      else
+        {
+          prm.enter_subsection("Particles " + std::to_string(world_index+1));
+        }
+      {
+        min_particles_per_cell = prm.get_integer("Minimum particles per cell");
+        max_particles_per_cell = prm.get_integer("Maximum particles per cell");
+
+        AssertThrow(min_particles_per_cell <= max_particles_per_cell,
+                    ExcMessage("Please select a 'Minimum particles per cell' parameter "
+                               "that is smaller than or equal to the 'Maximum particles per cell' parameter."));
+
+        particle_weight = prm.get_integer("Particle weight");
+
+        update_ghost_particles = prm.get_bool("Update ghost particles");
+
+        const std::vector<std::string> strategies = Utilities::split_string_list(prm.get ("Load balancing strategy"));
+        AssertThrow(Utilities::has_unique_entries(strategies),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Particles/Load balancing strategy' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+
+        particle_load_balancing = ParticleLoadBalancing::no_balancing;
+
+        for (std::vector<std::string>::const_iterator strategy = strategies.begin(); strategy != strategies.end(); ++strategy)
+          {
+            if (*strategy == "remove particles")
+              particle_load_balancing = typename ParticleLoadBalancing::Kind(particle_load_balancing | ParticleLoadBalancing::remove_particles);
+            else if (*strategy == "add particles")
+              particle_load_balancing = typename ParticleLoadBalancing::Kind(particle_load_balancing | ParticleLoadBalancing::add_particles);
+            else if (*strategy == "remove and add particles")
+              particle_load_balancing = typename ParticleLoadBalancing::Kind(particle_load_balancing | ParticleLoadBalancing::remove_and_add_particles);
+            else if (*strategy == "repartition")
+              particle_load_balancing = typename ParticleLoadBalancing::Kind(particle_load_balancing | ParticleLoadBalancing::repartition);
+            else if (*strategy == "none")
+              {
+                particle_load_balancing = ParticleLoadBalancing::no_balancing;
+                AssertThrow(strategies.size() == 1,
+                            ExcMessage("The particle load balancing strategy `none' is not compatible "
+                                       "with any other strategy, yet it seems another is selected as well. "
+                                       "Please check the parameter file."));
+              }
+            else
+              AssertThrow(false,
+                          ExcMessage("The 'Load balancing strategy' parameter contains an unknown value: <" + *strategy
+                                     + ">. This value does not correspond to any known load balancing strategy. Possible values "
+                                     "are listed in the corresponding manual subsection."));
+          }
+
+
+        TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Initialization");
+
+        // Create a generator object depending on what the parameters specify
+        generator = Generator::create_particle_generator<dim> (prm);
+        if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(generator.get()))
+          sim->initialize_simulator (this->get_simulator());
+        generator->set_particle_world_index(world_index);
+        generator->parse_parameters(prm);
+        generator->initialize();
+
+        // Create a property_manager object and initialize its properties
+        property_manager = std::make_unique<Property::Manager<dim>> ();
+        SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(property_manager.get());
+        sim->initialize_simulator (this->get_simulator());
+        property_manager->set_particle_world_index(world_index);
+        property_manager->parse_parameters(prm);
+        property_manager->initialize();
+
+        // Create an integrator object depending on the specified parameter
+        integrator = Integrator::create_particle_integrator<dim> (prm);
+        if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(integrator.get()))
+          sim->initialize_simulator (this->get_simulator());
+        integrator->set_particle_world_index(world_index);
+        integrator->parse_parameters(prm);
+        integrator->initialize();
+
+        // Create an interpolator object depending on the specified parameter
+        interpolator = Interpolator::create_particle_interpolator<dim> (prm);
+        if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(interpolator.get()))
+          sim->initialize_simulator (this->get_simulator());
+        interpolator->set_particle_world_index(world_index);
+        interpolator->parse_parameters(prm);
+        interpolator->initialize();
+
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace Particle
+  {
+#define INSTANTIATE(dim) \
+  template class World<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/plugins.cc.bak b/source/plugins.cc.bak
new file mode 100644
index 00000000000..2964077a074
--- /dev/null
+++ b/source/plugins.cc.bak
@@ -0,0 +1,50 @@
+/*
+  Copyright (C) 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/plugins.h>
+
+namespace aspect
+{
+  namespace Plugins
+  {
+    void
+    InterfaceBase::initialize ()
+    {}
+
+
+
+    void
+    InterfaceBase::update ()
+    {}
+
+
+
+    void
+    InterfaceBase::
+    declare_parameters (dealii::ParameterHandler &)
+    {}
+
+
+
+    void
+    InterfaceBase::parse_parameters (dealii::ParameterHandler &)
+    {}
+  }
+}
diff --git a/source/postprocess/ODE_statistics.cc.bak b/source/postprocess/ODE_statistics.cc.bak
new file mode 100644
index 00000000000..263bf22f7ba
--- /dev/null
+++ b/source/postprocess/ODE_statistics.cc.bak
@@ -0,0 +1,108 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/ODE_statistics.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <aspect/simulator.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    void
+    ODEStatistics<dim>::initialize()
+    {
+      this->get_signals().post_ARKode_solve.connect(
+        [&](const SimulatorAccess<dim> &/*simulator_access*/,
+            const unsigned int iteration_count)
+      {
+        this->store_ODE_solver_history(iteration_count);
+      });
+
+      this->clear_data();
+    }
+
+
+
+    template <int dim>
+    void
+    ODEStatistics<dim>::clear_data()
+    {
+      total_iteration_count = 0;
+      number_of_solves = 0;
+    }
+
+
+
+    template <int dim>
+    void
+    ODEStatistics<dim>::store_ODE_solver_history(const unsigned int iteration_count)
+    {
+      total_iteration_count += iteration_count;
+      number_of_solves += 1;
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    ODEStatistics<dim>::execute (TableHandler &statistics)
+    {
+#if DEAL_II_VERSION_GTE(9,6,0)
+      const double average_iteration_count = number_of_solves > 0
+                                             ?
+                                             total_iteration_count / number_of_solves
+                                             :
+                                             total_iteration_count;
+#else
+      // The computation is not correct for dealii versions older than
+      // June 2024.
+      const double average_iteration_count = std::numeric_limits<double>::quiet_NaN();
+#endif
+      statistics.add_value("Average iterations for ODE solver",
+                           average_iteration_count);
+
+      clear_data();
+
+      return std::make_pair (std::string(),std::string());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(ODEStatistics,
+                                  "ODE statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "ODEs solved during the model evolution, specifically, "
+                                  "how many iterations are needed to solve these ODEs "
+                                  "on average. ")
+  }
+}
diff --git a/source/postprocess/basic_statistics.cc.bak b/source/postprocess/basic_statistics.cc.bak
new file mode 100644
index 00000000000..ae0cea991ba
--- /dev/null
+++ b/source/postprocess/basic_statistics.cc.bak
@@ -0,0 +1,165 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/basic_statistics.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/global.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    BasicStatistics<dim>::execute (TableHandler &)
+    {
+      if (!Plugins::plugin_type_matches<const MaterialModel::Simple<dim>>(this->get_material_model()))
+        return std::make_pair (std::string(),std::string());
+
+      if ((this->get_timestep_number() == 0) &&
+          (this->get_pre_refinement_step() == std::numeric_limits<unsigned int>::max()))
+        {
+          // Define the representative point (in this case a point with depth 0 -> at the surface)
+          const double reference_depth = 0.0;
+          const Point<dim> representative_point = this->get_geometry_model().representative_point(reference_depth);
+          const double gravity = this->get_gravity_model().gravity_vector(representative_point).norm();
+          const double model_depth = this->get_geometry_model().maximal_depth();
+
+          // temperature contrast is only meaningful if boundary temperatures are prescribed, otherwise it is 0
+          const double temperature_contrast = (this->has_boundary_temperature()
+                                               ?
+                                               this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators())
+                                               - this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators())
+                                               :
+                                               0);
+
+          // Compute material properties at the reference point using the adiabatic
+          // profile as reference temperature and pressure
+          const double temperature = this->get_adiabatic_conditions().temperature(representative_point);
+          const double pressure = this->get_adiabatic_conditions().pressure(representative_point);
+
+          MaterialModel::MaterialModelInputs<dim> in (1, this->n_compositional_fields());
+          MaterialModel::MaterialModelOutputs<dim> out (1, this->n_compositional_fields());
+          in.requested_properties = MaterialModel::MaterialProperties::thermal_conductivity |
+                                    MaterialModel::MaterialProperties::equation_of_state_properties |
+                                    MaterialModel::MaterialProperties::viscosity;
+
+          in.position[0] = representative_point;
+          in.temperature[0] = temperature;
+          in.pressure[0] = pressure;
+          for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+            in.composition[0][c] = 0.0;
+
+          this->get_material_model().evaluate(in, out);
+
+          const double thermal_diffusivity = ( (this->get_parameters().formulation_temperature_equation ==
+                                                Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+                                               ?
+                                               out.thermal_conductivities[0] /
+                                               (this->get_adiabatic_conditions().density(in.position[0]) * out.specific_heat[0])
+                                               :
+                                               out.thermal_conductivities[0] / (out.densities[0] * out.specific_heat[0])
+                                             );
+
+          // check whether diffusivity is set to 0 (in case of backward advection)
+          const double Ra = (thermal_diffusivity != 0) ?
+                            out.densities[0] *
+                            gravity *
+                            out.thermal_expansion_coefficients[0] *
+                            temperature_contrast * std::pow(model_depth,3)/
+                            (thermal_diffusivity * out.viscosities[0])
+                            :
+                            std::numeric_limits<double>::infinity();
+
+          this->get_pcout() <<  std::endl;
+          this->get_pcout() << "     Model domain depth (m):                        "
+                            << model_depth
+                            << std::endl;
+          this->get_pcout() << "     Temperature contrast across model domain (K):  "
+                            << temperature_contrast
+                            << std::endl;
+          this->get_pcout() << "     Reference depth (m):                           "
+                            << reference_depth
+                            << std::endl;
+          this->get_pcout() << "     Reference temperature (K):                     "
+                            << temperature
+                            << std::endl;
+          this->get_pcout() << "     Reference pressure (Pa):                       "
+                            << pressure
+                            << std::endl;
+          this->get_pcout() << "     Reference gravity (m/s^2):                     "
+                            << gravity
+                            << std::endl;
+          this->get_pcout() << "     Reference density (kg/m^3):                    "
+                            << out.densities[0]
+                            << std::endl;
+          this->get_pcout() << "     Reference thermal expansion coefficient (1/K): "
+                            << out.thermal_expansion_coefficients[0]
+                            << std::endl;
+          this->get_pcout() << "     Reference specific heat capacity (J/(K*kg)):   "
+                            << out.specific_heat[0]
+                            << std::endl;
+          this->get_pcout() << "     Reference thermal conductivity (W/(m*K)):      "
+                            << out.thermal_conductivities[0]
+                            << std::endl;
+          this->get_pcout() << "     Reference viscosity (Pa*s):                    "
+                            << out.viscosities[0]
+                            << std::endl;
+          this->get_pcout() << "     Reference thermal diffusivity (m^2/s):         "
+                            << thermal_diffusivity
+                            << std::endl;
+          this->get_pcout() << "     Rayleigh number:                               "
+                            << Ra
+                            << std::endl;
+
+          this->get_pcout() << std::endl;
+        }
+      return std::make_pair (std::string(),std::string());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(BasicStatistics,
+                                  "basic statistics",
+                                  "A postprocessor that outputs some simplified statistics "
+                                  "like the Rayleigh number and other quantities that only "
+                                  "make sense in certain model setups. The output is written "
+                                  "after completing initial adaptive refinement steps. "
+                                  "The postprocessor assumes a point at the surface at the adiabatic "
+                                  "surface temperature and pressure is a reasonable reference condition "
+                                  "for computing these properties. Furthermore, the Rayleigh "
+                                  "number is computed using the model depth (i.e. not the "
+                                  "radius of the Earth), as we need a definition that is geometry "
+                                  "independent. Take care when comparing these values to published "
+                                  "studies and make sure they use the same definitions.")
+  }
+}
diff --git a/source/postprocess/boundary_densities.cc.bak b/source/postprocess/boundary_densities.cc.bak
new file mode 100644
index 00000000000..ce4d9b71df1
--- /dev/null
+++ b/source/postprocess/boundary_densities.cc.bak
@@ -0,0 +1,177 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/boundary_densities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    BoundaryDensities<dim>::execute (TableHandler &statistics)
+    {
+      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.temperature;
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula,
+                                        update_values |
+                                        update_gradients |
+                                        update_quadrature_points |
+                                        update_JxW_values);
+
+      double local_top_density = 0.;
+      double local_bottom_density = 0.;
+      double local_top_area = 0.;
+      double local_bottom_area = 0.;
+
+      typename MaterialModel::Interface<dim>::MaterialModelInputs in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+      typename MaterialModel::Interface<dim>::MaterialModelOutputs out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::density;
+      std::vector<std::vector<double>> composition_values(this->n_compositional_fields(), std::vector<double>(fe_face_values.n_quadrature_points));
+
+      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+      const types::boundary_id bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
+
+      // loop over all of the surface cells and if one less than h/3 away from
+      // the top or bottom surface, evaluate the density on that face
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          for (const unsigned int f : cell->face_indices())
+            {
+              bool cell_at_top = false;
+              bool cell_at_bottom = false;
+
+              // Test for top or bottom surface cell faces
+              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
+                cell_at_top = true;
+              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
+                cell_at_bottom = true;
+
+              if (cell_at_top || cell_at_bottom)
+                {
+                  // handle surface cells
+                  fe_face_values.reinit (cell, f);
+                  fe_face_values[this->introspection().extractors.temperature]
+                  .get_function_values (this->get_solution(), in.temperature);
+                  fe_face_values[this->introspection().extractors.pressure]
+                  .get_function_values (this->get_solution(), in.pressure);
+                  fe_face_values[this->introspection().extractors.velocities]
+                  .get_function_symmetric_gradients (this->get_solution(), in.strain_rate);
+
+                  in.position = fe_face_values.get_quadrature_points();
+
+                  for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                    fe_face_values[this->introspection().extractors.compositional_fields[c]]
+                    .get_function_values(this->get_solution(),
+                                         composition_values[c]);
+                  for (unsigned int i=0; i<fe_face_values.n_quadrature_points; ++i)
+                    {
+                      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                        in.composition[i][c] = composition_values[c][i];
+                    }
+
+                  this->get_material_model().evaluate(in, out);
+
+                  // calculate the top/bottom properties
+                  if (cell_at_top)
+                    for ( unsigned int q = 0; q < fe_face_values.n_quadrature_points; ++q)
+                      {
+                        local_top_density += out.densities[q] * fe_face_values.JxW(q);
+                        local_top_area += fe_face_values.JxW(q);
+                      }
+                  if (cell_at_bottom)
+                    for ( unsigned int q = 0; q < fe_face_values.n_quadrature_points; ++q)
+                      {
+                        local_bottom_density += out.densities[q] * fe_face_values.JxW(q);
+                        local_bottom_area += fe_face_values.JxW(q);
+                      }
+                }
+            }
+
+      // vector for packing local values before MPI summing them
+      double values[4] = {local_bottom_area, local_top_area, local_bottom_density, local_top_density};
+
+      Utilities::MPI::sum<double, 4>( values, this->get_mpi_communicator(), values );
+
+      top_density = values[3] / values[1]; // density over area
+      bottom_density = values[2] / values[0]; // density over area
+
+      statistics.add_value ("Density at top (kg/m^3)",
+                            top_density);
+      statistics.add_value ("Density at bottom (kg/m^3)",
+                            bottom_density);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      {
+        const char *columns[] = { "Density at top (kg/m^3)",
+                                  "Density at bottom (kg/m^3)"
+                                };
+        for (auto &column : columns)
+          {
+            statistics.set_precision (column, 8);
+            statistics.set_scientific (column, true);
+          }
+      }
+
+      std::ostringstream output;
+      output.precision(4);
+      output << top_density << " kg/m^3, "
+             << bottom_density << " kg/m^3";
+
+      return std::pair<std::string, std::string> ("Density at top/bottom of domain:",
+                                                  output.str());
+    }
+
+    template <int dim>
+    double
+    BoundaryDensities<dim>::density_at_top() const
+    {
+      return top_density;
+    }
+
+    template <int dim>
+    double
+    BoundaryDensities<dim>::density_at_bottom() const
+    {
+      return bottom_density;
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(BoundaryDensities,
+                                  "boundary densities",
+                                  "A postprocessor that computes the laterally averaged "
+                                  "density at the top and bottom of the domain.")
+  }
+}
diff --git a/source/postprocess/boundary_pressures.cc.bak b/source/postprocess/boundary_pressures.cc.bak
new file mode 100644
index 00000000000..4e52f793394
--- /dev/null
+++ b/source/postprocess/boundary_pressures.cc.bak
@@ -0,0 +1,156 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/boundary_pressures.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    BoundaryPressures<dim>::execute (TableHandler &statistics)
+    {
+      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.pressure;
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula,
+                                        update_values |
+                                        update_gradients |
+                                        update_quadrature_points |
+                                        update_JxW_values);
+
+      double local_top_pressure = 0.;
+      double local_bottom_pressure = 0.;
+      double local_top_area = 0.;
+      double local_bottom_area = 0.;
+
+      std::vector<double> pressure_vals (fe_face_values.n_quadrature_points);
+
+      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+      const types::boundary_id bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
+
+      // loop over all of the surface cells and if one less than h/3 away from
+      // the top or bottom surface, evaluate the pressure on that face
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          for (const unsigned int f : cell->face_indices())
+            {
+              bool cell_at_top = false;
+              bool cell_at_bottom = false;
+
+              // Test for top or bottom surface cell faces
+              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
+                cell_at_top = true;
+              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
+                cell_at_bottom = true;
+
+
+              if (cell_at_top || cell_at_bottom)
+                {
+                  // evaluate the pressure on the face
+                  fe_face_values.reinit (cell, f);
+                  fe_face_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(), pressure_vals);
+
+                  // calculate the top properties
+                  if (cell_at_top)
+                    for ( unsigned int q = 0; q < fe_face_values.n_quadrature_points; ++q)
+                      {
+                        local_top_pressure += pressure_vals[q] * fe_face_values.JxW(q);
+                        local_top_area += fe_face_values.JxW(q);
+                      }
+                  if (cell_at_bottom)
+                    for ( unsigned int q = 0; q < fe_face_values.n_quadrature_points; ++q)
+                      {
+                        local_bottom_pressure += pressure_vals[q] * fe_face_values.JxW(q);
+                        local_bottom_area += fe_face_values.JxW(q);
+                      }
+                }
+            }
+
+      // vector for packing local values before MPI summing them
+      double values[4] = {local_bottom_area, local_top_area, local_bottom_pressure, local_top_pressure};
+
+      Utilities::MPI::sum<double, 4>( values, this->get_mpi_communicator(), values );
+
+      top_pressure = values[3] / values[1]; // density over area
+      bottom_pressure = values[2] / values[0]; // density over area
+
+      statistics.add_value ("Pressure at top (Pa)",
+                            top_pressure);
+      statistics.add_value ("Pressure at bottom (Pa)",
+                            bottom_pressure);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      {
+        const char *columns[] = { "Pressure at top (Pa)",
+                                  "Pressure at bottom (Pa)"
+                                };
+        for (auto &column : columns)
+          {
+            statistics.set_precision (column, 8);
+            statistics.set_scientific (column, true);
+          }
+      }
+
+      std::ostringstream output;
+      output.precision(4);
+      output << top_pressure << " Pa, "
+             << bottom_pressure << " Pa";
+
+      return std::pair<std::string, std::string> ("Pressure at top/bottom of domain:",
+                                                  output.str());
+    }
+
+    template <int dim>
+    double
+    BoundaryPressures<dim>::pressure_at_top() const
+    {
+      return top_pressure;
+    }
+
+    template <int dim>
+    double
+    BoundaryPressures<dim>::pressure_at_bottom() const
+    {
+      return bottom_pressure;
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(BoundaryPressures,
+                                  "boundary pressures",
+                                  "A postprocessor that computes the laterally averaged "
+                                  "pressure at the top and bottom of the domain.")
+  }
+}
diff --git a/source/postprocess/boundary_strain_rate_residual_statistics.cc.bak b/source/postprocess/boundary_strain_rate_residual_statistics.cc.bak
new file mode 100644
index 00000000000..251880b9451
--- /dev/null
+++ b/source/postprocess/boundary_strain_rate_residual_statistics.cc.bak
@@ -0,0 +1,332 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/postprocess/boundary_strain_rate_residual_statistics.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    void
+    BoundaryStrainRateResidualStatistics<dim>::initialize ()
+    {
+      strain_rate_data_lookup = std::make_unique<Utilities::StructuredDataLookup<dim>>(1, scale_factor);
+      strain_rate_data_lookup->load_file(data_directory + data_file_name, this->get_mpi_communicator());
+    }
+
+
+
+    template <int dim>
+    double
+    BoundaryStrainRateResidualStatistics<dim>::get_data_surface_strain_rate (const Point<dim> &p) const
+    {
+      Point<dim> internal_position = p;
+
+      if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical)
+        {
+          const std::array<double,dim> spherical_position = this->get_geometry_model().
+                                                            cartesian_to_natural_coordinates(p);
+
+          for (unsigned int d = 0; d < dim; ++d)
+            internal_position[d] = spherical_position[d];
+        }
+
+      const double data_surface_strain_rate = strain_rate_data_lookup->get_data(internal_position, 0);
+
+      return data_surface_strain_rate;
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    BoundaryStrainRateResidualStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula for the velocity.
+      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.velocities;
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula,
+                                        update_gradients |
+                                        update_JxW_values |
+                                        update_quadrature_points);
+
+      // This variable stores the strain rates computed at the quadrature points.
+      std::vector<SymmetricTensor<2,dim>> strain_rate (fe_face_values.n_quadrature_points);
+
+      std::map<types::boundary_id, double> local_max_eii;
+      std::map<types::boundary_id, double> local_min_eii;
+      std::map<types::boundary_id, double> local_eii_square_integral;
+      std::map<types::boundary_id, double> local_boundary_area;
+
+      std::set<types::boundary_id> boundary_indicators;
+      boundary_indicators.insert(this->get_geometry_model().translate_symbolic_boundary_name_to_id("top"));
+
+      AssertThrow (boundary_indicators.size() == 1,
+                   ExcMessage("The <boundary strain rate residual statistics> plugin is only tested "
+                              "to work correctly for a single boundary indicator, "
+                              "but more than one was specified."));
+
+      for (const auto boundary_id : boundary_indicators)
+        {
+          local_max_eii[boundary_id] = std::numeric_limits<double>::lowest();
+          local_min_eii[boundary_id] = std::numeric_limits<double>::max();
+        }
+
+      // for every face that is part of the selected geometry boundary
+      // and that is owned by this processor,
+      // compute the maximum, minimum, and squared*area strain rate invariant residual
+      // magnitude, and the face area.
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (const unsigned int f : cell->face_indices())
+            for (const auto current_boundary_id : boundary_indicators)
+              if (cell->face(f)->at_boundary() && cell->face(f)->boundary_id() == current_boundary_id)
+                {
+                  fe_face_values.reinit (cell, f);
+
+                  fe_face_values[this->introspection().extractors.velocities].get_function_symmetric_gradients
+                  (this->get_solution(), strain_rate);
+
+                  // determine the max, min, and area integral of squared strain rate residual on the face
+                  // also determine the face area
+                  double local_max = std::numeric_limits<double>::lowest();
+                  double local_min = std::numeric_limits<double>::max();
+                  double local_square_strain_rate = 0.0;
+                  double local_fe_face_area = 0.0;
+                  for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                    {
+                      const Point<dim> point_at_surface = fe_face_values.quadrature_point(q);
+
+                      // Extract the strain rate invariant output here.
+                      const double e_ii = std::sqrt(std::fabs(second_invariant(deviator(strain_rate[q]))));
+
+                      // Extract data strain rate invartiant.
+                      double e_ii_data = get_data_surface_strain_rate(point_at_surface);
+
+                      if (this->convert_output_to_years() == true)
+                        e_ii_data = e_ii_data/year_in_seconds;
+
+                      // The strain rate invariant residual is calculated here. Ignore the computation if we
+                      // encounter nan or 1e300 in the input data.
+                      double strain_invariant_residual = 0;
+                      if (e_ii_data < 1e300 || !std::isnan(e_ii_data))
+                        strain_invariant_residual = std::abs(e_ii_data - e_ii);
+                      else
+                        continue;
+
+                      local_max = std::max(strain_invariant_residual,
+                                           local_max);
+                      local_min = std::min(strain_invariant_residual,
+                                           local_min);
+                      local_square_strain_rate += ((strain_invariant_residual * strain_invariant_residual) * fe_face_values.JxW(q));
+                      local_fe_face_area += fe_face_values.JxW(q);
+                    }
+                  // then merge them with the min/max/squared strain rates
+                  // and face areas we found for other faces with the same boundary indicator
+                  local_max_eii[current_boundary_id] = std::max(local_max,
+                                                                local_max_eii[current_boundary_id]);
+                  local_min_eii[current_boundary_id] = std::min(local_min,
+                                                                local_min_eii[current_boundary_id]);
+                  local_eii_square_integral[current_boundary_id] += local_square_strain_rate;
+                  local_boundary_area[current_boundary_id] += local_fe_face_area;
+                }
+
+      // now communicate to get the global values
+      std::map<types::boundary_id, double> global_max_eii;
+      std::map<types::boundary_id, double> global_min_eii;
+      std::map<types::boundary_id, double> global_rms_eii;
+      {
+        // first collect local values in the same order in which they are listed
+        // in the set of boundary indicators
+        std::vector<double> local_max_values;
+        std::vector<double> local_min_values;
+        std::vector<double> local_eii_square_integral_values;
+        std::vector<double> local_boundary_area_values;
+
+        for (const auto p : boundary_indicators)
+          {
+            local_max_values.push_back (local_max_eii[p]);
+            local_min_values.push_back (local_min_eii[p]);
+
+            local_eii_square_integral_values.push_back (local_eii_square_integral[p]);
+            local_boundary_area_values.push_back (local_boundary_area[p]);
+          }
+
+        // then collect contributions from all processors
+        std::vector<double> global_max_values (local_max_values.size());
+        Utilities::MPI::max (local_max_values, this->get_mpi_communicator(), global_max_values);
+        std::vector<double> global_min_values (local_min_values.size());
+        Utilities::MPI::min (local_min_values, this->get_mpi_communicator(), global_min_values);
+
+        std::vector<double> global_eii_square_integral_values (local_eii_square_integral_values.size());
+        Utilities::MPI::sum(local_eii_square_integral_values,this->get_mpi_communicator(),global_eii_square_integral_values);
+        std::vector<double> global_boundary_area_values (local_boundary_area_values.size());
+        Utilities::MPI::sum(local_boundary_area_values,this->get_mpi_communicator(),global_boundary_area_values);
+
+        // and now take them apart into the global map again
+        // At the same time, calculate the rms strain rate invariant for each boundary
+        unsigned int index = 0;
+        for (const auto boundary_id: boundary_indicators)
+          {
+            global_max_eii[boundary_id] = global_max_values[index];
+            global_min_eii[boundary_id] = global_min_values[index];
+            global_rms_eii[boundary_id] = std::sqrt(global_eii_square_integral_values[index] / global_boundary_area_values[index]);
+            ++index;
+          }
+      }
+
+      // now add the computed max, min, and rms strain rates to the statistics object
+      // and create a single string that can be output to the screen
+      const std::string units = (this->convert_output_to_years() == true) ? "1/yr" : "1/s";
+      const double unit_scale_factor = (this->convert_output_to_years() == true) ? year_in_seconds : 1.0;
+      std::ostringstream screen_text;
+      unsigned int index = 0;
+
+      for (std::map<types::boundary_id, double>::const_iterator
+           max_eii = global_max_eii.begin(), min_eii = global_min_eii.begin(), rms = global_rms_eii.begin();
+           max_eii != global_max_eii.end() && min_eii != global_min_eii.end() && rms != global_rms_eii.end();
+           ++max_eii, ++min_eii, ++rms, ++index)
+        {
+          const std::string name_max = "Maximum strain rate invariant residual magnitude on boundary with indicator "
+                                       + Utilities::int_to_string(max_eii->first)
+                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                     .translate_id_to_symbol_name (max_eii->first))
+                                       + " (" + units + ")";
+          statistics.add_value (name_max, max_eii->second*unit_scale_factor);
+          const std::string name_min = "Minimum strain rate invariant residual magnitude on boundary with indicator "
+                                       + Utilities::int_to_string(min_eii->first)
+                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                     .translate_id_to_symbol_name (min_eii->first))
+                                       + " (" + units + ")";
+          statistics.add_value (name_min, min_eii->second*unit_scale_factor);
+          const std::string name_rms = "RMS strain rate invariant residual on boundary with indicator "
+                                       + Utilities::int_to_string(rms->first)
+                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                     .translate_id_to_symbol_name (rms->first))
+                                       + " (" + units + ")";
+          statistics.add_value (name_rms, rms->second*unit_scale_factor);
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (name_max, 8);
+          statistics.set_scientific (name_max, true);
+          statistics.set_precision (name_min, 8);
+          statistics.set_scientific (name_min, true);
+          statistics.set_precision (name_rms, 8);
+          statistics.set_scientific (name_rms, true);
+
+          screen_text << max_eii->second *unit_scale_factor << " " << units << ", "
+                      << min_eii->second *unit_scale_factor << " " << units << ", "
+                      << rms->second *unit_scale_factor << " " << units
+                      << (index == global_max_eii.size()-1 ? "" : ", ");
+
+        }
+
+      return std::pair<std::string, std::string> ("Max, min, and RMS residual strain rate invariant along boundary parts:",
+                                                  screen_text.str());
+    }
+
+
+
+    template <int dim>
+    void
+    BoundaryStrainRateResidualStatistics<dim>::declare_parameters (ParameterHandler  &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Boundary strain rate residual statistics");
+        {
+          prm.declare_entry ("Data directory",
+                             "$ASPECT_SOURCE_DIR/data/postprocess/boundary-strain-rate-residual/",
+                             Patterns::DirectoryName (),
+                             "The name of a directory that contains the ascii data. "
+                             "This path may either be absolute (if starting with a "
+                             "`/') or relative to the current directory. The path may also "
+                             "include the special text `$ASPECT_SOURCE_DIR' which will be "
+                             "interpreted as the path in which the ASPECT source files were "
+                             "located when ASPECT was compiled. This interpretation allows, "
+                             "for example, to reference files located in the `data/' subdirectory "
+                             "of ASPECT.");
+          prm.declare_entry ("Data file name", "box_3d_boundary_strain_rate.txt",
+                             Patterns::Anything (),
+                             "The file name of the input surface strain rate an ascii data. "
+                             "The file has one column in addition to the coordinate columns "
+                             "corresponding to the second invariant of strain rate. ");
+          prm.declare_entry ("Scale factor", "1.",
+                             Patterns::Double (),
+                             "Scalar factor, which is applied to the model data. "
+                             "You might want to use this to scale the input to a "
+                             "reference model.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    BoundaryStrainRateResidualStatistics<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Boundary strain rate residual statistics");
+        {
+          // Get the path to the data files. If it contains a reference
+          // to $ASPECT_SOURCE_DIR, replace it by what CMake has given us
+          // as a #define
+          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+          data_file_name    = prm.get ("Data file name");
+          scale_factor      = prm.get_double ("Scale factor");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(BoundaryStrainRateResidualStatistics,
+                                  "boundary strain rate residual statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the surface strain rate residual along the top boundary. The residual "
+                                  "is the difference between the second invariant of the model strain rate and "
+                                  "the second strain rate invariant read from the input data file. "
+                                  "Currently, the strain residual statistics, i.e., min, max and the rms magnitude, "
+                                  "are computed at the top surface.")
+  }
+}
diff --git a/source/postprocess/boundary_velocity_residual_statistics.cc.bak b/source/postprocess/boundary_velocity_residual_statistics.cc.bak
new file mode 100644
index 00000000000..2390c4e7be6
--- /dev/null
+++ b/source/postprocess/boundary_velocity_residual_statistics.cc.bak
@@ -0,0 +1,376 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/postprocess/boundary_velocity_residual_statistics.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    void
+    BoundaryVelocityResidualStatistics<dim>::initialize ()
+    {
+      if (use_ascii_data)
+        {
+          // The input ascii table contains dim data columns (velocity components) in addition to the coordinate columns.
+          data_lookup = std::make_unique<Utilities::StructuredDataLookup<dim>>(dim, scale_factor);
+          data_lookup->load_file(data_directory + data_file_name, this->get_mpi_communicator());
+        }
+      else
+        {
+          // The two points are used in GPlates to find the 2d plane in which
+          // the model lies.  These values are not used for 3d geometries and
+          // are thus set to the default.
+          Point<2> point_one(numbers::PI/2., 0.);
+          Point<2> point_two(numbers::PI/2., numbers::PI/2.);
+
+          gplates_lookup =  std::make_unique<BoundaryVelocity::internal::GPlatesLookup<dim>> (
+                              point_one, point_two);
+
+          gplates_lookup->load_file(data_directory + data_file_name, this->get_mpi_communicator());
+        }
+    }
+
+
+
+    template <int dim>
+    Tensor<1,dim>
+    BoundaryVelocityResidualStatistics<dim>::get_data_velocity (const Point<dim> &p) const
+    {
+      Tensor<1,dim> data_velocity;
+      if (use_ascii_data)
+        {
+          Point<dim> internal_position = p;
+
+          if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical)
+            {
+              const std::array<double,dim> spherical_position = this->get_geometry_model().
+                                                                cartesian_to_natural_coordinates(p);
+
+              for (unsigned int d = 0; d < dim; ++d)
+                internal_position[d] = spherical_position[d];
+            }
+
+          for (unsigned int d = 0; d < dim; ++d)
+            data_velocity[d] = data_lookup->get_data(internal_position, d);
+          if (use_spherical_unit_vectors == true)
+            data_velocity = Utilities::Coordinates::spherical_to_cartesian_vector(data_velocity, p);
+        }
+      else
+        {
+          data_velocity =  gplates_lookup->surface_velocity(p);
+        }
+
+      return data_velocity;
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    BoundaryVelocityResidualStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula for the velocity.
+      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.velocities;
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula,
+                                        update_values |
+                                        update_JxW_values |
+                                        update_quadrature_points);
+
+      std::vector<Tensor<1,dim>> velocities (fe_face_values.n_quadrature_points);
+
+      std::map<types::boundary_id, double> local_max_vel;
+      std::map<types::boundary_id, double> local_min_vel;
+      std::map<types::boundary_id, double> local_velocity_square_integral;
+      std::map<types::boundary_id, double> local_boundary_area;
+
+      std::set<types::boundary_id> boundary_indicators;
+      boundary_indicators.insert(this->get_geometry_model().translate_symbolic_boundary_name_to_id("top"));
+
+      AssertThrow (boundary_indicators.size() == 1,
+                   ExcMessage("The <boundary velocity residual statistics> plugin is only tested "
+                              "to work correctly for a single boundary indicator, "
+                              "but more than one was specified."));
+
+      for (const auto p : boundary_indicators)
+        {
+          local_max_vel[p] = std::numeric_limits<double>::lowest();
+          local_min_vel[p] = std::numeric_limits<double>::max();
+        }
+
+      // for every face that is part of the selected geometry boundary
+      // and that is owned by this processor,
+      // compute the maximum, minimum, and squared*area velocity residual
+      // magnitude and the face area.
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (const unsigned int f : cell->face_indices())
+            for (const auto current_boundary_id : boundary_indicators)
+              if (cell->face(f)->at_boundary() && cell->face(f)->boundary_id() == current_boundary_id)
+                {
+                  fe_face_values.reinit (cell, f);
+
+                  fe_face_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                      velocities);
+
+                  // determine the max, min, and squared velocity residual on the face
+                  // also determine the face area
+                  double local_max = std::numeric_limits<double>::lowest();
+                  double local_min = std::numeric_limits<double>::max();
+                  double local_sqvel = 0.0;
+                  double local_fe_face_area = 0.0;
+                  for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                    {
+                      const Point<dim> point_at_surface = fe_face_values.quadrature_point(q);
+                      // Extract data velocity.
+                      Tensor<1,dim> data_velocity = get_data_velocity(point_at_surface);
+
+                      if (this->convert_output_to_years() == true)
+                        data_velocity = data_velocity/year_in_seconds;
+
+                      // The velocity residual is calculated here.
+                      const double vel_residual_mag = (velocities[q] - data_velocity).norm();
+
+                      local_max = std::max(vel_residual_mag,
+                                           local_max);
+                      local_min = std::min(vel_residual_mag,
+                                           local_min);
+                      local_sqvel += ((vel_residual_mag * vel_residual_mag) * fe_face_values.JxW(q));
+                      local_fe_face_area += fe_face_values.JxW(q);
+                    }
+
+                  // then merge them with the min/max/squared velocities
+                  // and face areas we found for other faces with the same boundary indicator
+                  local_max_vel[current_boundary_id] = std::max(local_max,
+                                                                local_max_vel[current_boundary_id]);
+                  local_min_vel[current_boundary_id] = std::min(local_min,
+                                                                local_min_vel[current_boundary_id]);
+                  local_velocity_square_integral[current_boundary_id] += local_sqvel;
+                  local_boundary_area[current_boundary_id] += local_fe_face_area;
+                }
+
+      // now communicate to get the global values
+      std::map<types::boundary_id, double> global_max_vel;
+      std::map<types::boundary_id, double> global_min_vel;
+      std::map<types::boundary_id, double> global_rms_vel;
+      {
+        // first collect local values in the same order in which they are listed
+        // in the set of boundary indicators
+        std::vector<double> local_max_values;
+        std::vector<double> local_min_values;
+        std::vector<double> local_velocity_square_integral_values;
+        std::vector<double> local_boundary_area_values;
+
+        for (const auto p : boundary_indicators)
+          {
+            local_max_values.push_back (local_max_vel[p]);
+            local_min_values.push_back (local_min_vel[p]);
+
+            local_velocity_square_integral_values.push_back (local_velocity_square_integral[p]);
+            local_boundary_area_values.push_back (local_boundary_area[p]);
+          }
+
+        // then collect contributions from all processors
+        std::vector<double> global_max_values (local_max_values.size());
+        Utilities::MPI::max (local_max_values, this->get_mpi_communicator(), global_max_values);
+        std::vector<double> global_min_values (local_min_values.size());
+        Utilities::MPI::min (local_min_values, this->get_mpi_communicator(), global_min_values);
+
+        std::vector<double> global_velocity_square_integral_values (local_velocity_square_integral_values.size());
+        Utilities::MPI::sum(local_velocity_square_integral_values,this->get_mpi_communicator(),global_velocity_square_integral_values);
+        std::vector<double> global_boundary_area_values (local_boundary_area_values.size());
+        Utilities::MPI::sum(local_boundary_area_values,this->get_mpi_communicator(),global_boundary_area_values);
+
+        // and now take them apart into the global map again
+        // At the same time, calculate the rms velocity for each boundary
+        unsigned int index = 0;
+        for (const auto boundary_id: boundary_indicators)
+          {
+            global_max_vel[boundary_id] = global_max_values[index];
+            global_min_vel[boundary_id] = global_min_values[index];
+            global_rms_vel[boundary_id] = std::sqrt(global_velocity_square_integral_values[index] / global_boundary_area_values[index]);
+            ++index;
+          }
+      }
+
+      // now add the computed max, min, and rms velocities to the statistics object
+      // and create a single string that can be output to the screen
+      const std::string units = (this->convert_output_to_years() == true) ? "m/year" : "m/s";
+      const double unit_scale_factor = (this->convert_output_to_years() == true) ? year_in_seconds : 1.0;
+      std::ostringstream screen_text;
+      unsigned int index = 0;
+
+      for (std::map<types::boundary_id, double>::const_iterator
+           max_velocity = global_max_vel.begin(), min_velocity = global_min_vel.begin(), rms = global_rms_vel.begin();
+           max_velocity != global_max_vel.end() && min_velocity != global_min_vel.end() && rms != global_rms_vel.end();
+           ++max_velocity, ++min_velocity, ++rms, ++index)
+        {
+          const std::string name_max = "Maximum velocity residual magnitude on boundary with indicator "
+                                       + Utilities::int_to_string(max_velocity->first)
+                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                     .translate_id_to_symbol_name (max_velocity->first))
+                                       + " (" + units + ")";
+          statistics.add_value (name_max, max_velocity->second*unit_scale_factor);
+          const std::string name_min = "Minimum velocity residual magnitude on boundary with indicator "
+                                       + Utilities::int_to_string(min_velocity->first)
+                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                     .translate_id_to_symbol_name (min_velocity->first))
+                                       + " (" + units + ")";
+          statistics.add_value (name_min, min_velocity->second*unit_scale_factor);
+          const std::string name_rms = "RMS velocity residual on boundary with indicator "
+                                       + Utilities::int_to_string(rms->first)
+                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                     .translate_id_to_symbol_name (rms->first))
+                                       + " (" + units + ")";
+          statistics.add_value (name_rms, rms->second*unit_scale_factor);
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (name_max, 8);
+          statistics.set_scientific (name_max, true);
+          statistics.set_precision (name_min, 8);
+          statistics.set_scientific (name_min, true);
+          statistics.set_precision (name_rms, 8);
+          statistics.set_scientific (name_rms, true);
+
+          // finally have something for the screen
+          screen_text.precision(4);
+          screen_text << max_velocity->second *unit_scale_factor << ' ' << units << ", "
+                      << min_velocity->second *unit_scale_factor << ' ' << units << ", "
+                      << rms->second *unit_scale_factor << ' ' << units
+                      << (index == global_max_vel.size()-1 ? "" : ", ");
+        }
+
+      return std::pair<std::string, std::string> ("Max, min, and RMS residual velocity along boundary parts:",
+                                                  screen_text.str());
+    }
+
+
+
+    template <int dim>
+    void
+    BoundaryVelocityResidualStatistics<dim>::declare_parameters (ParameterHandler  &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Boundary velocity residual statistics");
+        {
+          prm.declare_entry ("Data directory",
+                             "$ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/",
+                             Patterns::DirectoryName (),
+                             "The name of a directory that contains the GPlates model or the "
+                             "ascii data. This path may either be absolute (if starting with a "
+                             "`/') or relative to the current directory. The path may also "
+                             "include the special text `$ASPECT_SOURCE_DIR' which will be "
+                             "interpreted as the path in which the ASPECT source files were "
+                             "located when ASPECT was compiled. This interpretation allows, "
+                             "for example, to reference files located in the `data/' subdirectory "
+                             "of ASPECT.");
+          prm.declare_entry ("Data file name", "current_day.gpml",
+                             Patterns::Anything (),
+                             "The file name of the input velocity as a GPlates model or an ascii data. "
+                             "For the GPlates model, provide file in the same format as described "
+                             "in the 'gplates' boundary velocity plugin. "
+                             "For the ascii data, provide file in the same format as described in "
+                             " 'ascii data' initial composition plugin." );
+          prm.declare_entry ("Scale factor", "1.",
+                             Patterns::Double (),
+                             "Scalar factor, which is applied to the model data. "
+                             "You might want to use this to scale the input to a "
+                             "reference model. Another way to use this factor is to "
+                             "convert units of the input files. For instance, if you "
+                             "provide velocities in cm/year set this factor to 0.01.");
+          prm.declare_entry ("Use spherical unit vectors", "false",
+                             Patterns::Bool (),
+                             "Specify velocity as r, phi, and theta components "
+                             "instead of x, y, and z. Positive velocities point up, east, "
+                             "and north (in 3d) or out and clockwise (in 2d). "
+                             "This setting only makes sense for spherical geometries."
+                             "GPlates data is always interpreted to be in east and north directions "
+                             "and is not affected by this parameter.");
+          prm.declare_entry ("Use ascii data", "false",
+                             Patterns::Bool (),
+                             "Use ascii data files (e.g., GPS) for computing residual velocities "
+                             "instead of GPlates data.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    BoundaryVelocityResidualStatistics<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Boundary velocity residual statistics");
+        {
+          // Get the path to the data files. If it contains a reference
+          // to $ASPECT_SOURCE_DIR, replace it by what CMake has given us
+          // as a #define
+          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+          data_file_name    = prm.get ("Data file name");
+          scale_factor      = prm.get_double ("Scale factor");
+
+          use_spherical_unit_vectors = prm.get_bool("Use spherical unit vectors");
+          use_ascii_data = prm.get_bool("Use ascii data");
+
+          if (use_spherical_unit_vectors)
+            AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
+                         ExcMessage ("Spherical unit vectors should not be used "
+                                     "when geometry model is not spherical."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(BoundaryVelocityResidualStatistics,
+                                  "boundary velocity residual statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the velocity residual along the top boundary. The velocity residual "
+                                  "is the difference between the model solution velocities and the input "
+                                  "velocities (GPlates model or ascii data). Currently, the velocity residual "
+                                  "statistics, i.e., min, max and the rms magnitude, is computed at the top "
+                                  "surface.")
+  }
+}
diff --git a/source/postprocess/command.cc.bak b/source/postprocess/command.cc.bak
new file mode 100644
index 00000000000..9160c73fea3
--- /dev/null
+++ b/source/postprocess/command.cc.bak
@@ -0,0 +1,131 @@
+/*
+  Copyright (C) 2016 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/postprocess/command.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    Command<dim>::execute (TableHandler &)
+    {
+      if (on_all_processes ||
+          (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0))
+        {
+
+          // Check if a command-processor is available by calling system() with a
+          // null pointer. System is guaranteed to return non-zero if it finds
+          // a terminal and zero if there is none (like on the compute nodes of
+          // some cluster architectures, e.g. IBM BlueGene/Q)
+          AssertThrow(system(nullptr) != 0,
+                      ExcMessage("The \"command\" postprocessor required a command-processor, "
+                                 "which appears to be unavailable on this system."));
+
+          const int error = system(command.c_str());
+
+          if (error != 0)
+            {
+              std::string err_str = (error<0 ? "-" : "") +
+                                    Utilities::int_to_string(std::abs(error));
+
+
+              if (terminate_on_failure)
+                {
+                  AssertThrow(false, ExcMessage("Command <" +
+                                                command +
+                                                "> failed with error code: " +
+                                                err_str +
+                                                ". Terminating process."));
+                }
+              else
+                {
+                  std::cerr << "*** WARNING: Command <" << command
+                            << "> failed with error code: "
+                            << err_str
+                            << ". Continuing anyway."
+                            << std::endl;
+                }
+            }
+        }
+
+      return std::make_pair (std::string("Running command:"),
+                             command);
+    }
+
+    template <int dim>
+    void
+    Command<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Command");
+        {
+          prm.declare_entry ("Terminate on failure", "false",
+                             Patterns::Bool(),
+                             "Select whether \\aspect{} should terminate if the "
+                             "command returns a non-zero exit status.");
+
+          prm.declare_entry ("Run on all processes", "false",
+                             Patterns::Bool(),
+                             "Whether to run command from all processes (true), "
+                             "or only on process 0 (false).");
+
+          prm.declare_entry ("Command", "",
+                             Patterns::Anything(),
+                             "Command to execute.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    Command<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Command");
+        {
+          terminate_on_failure = prm.get_bool ("Terminate on failure");
+          on_all_processes = prm.get_bool ("Run on all processes");
+          command = prm.get ("Command");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(Command,
+                                  "command",
+                                  "A postprocessor that executes a command line "
+                                  "process.")
+  }
+}
diff --git a/source/postprocess/composition_statistics.cc.bak b/source/postprocess/composition_statistics.cc.bak
new file mode 100644
index 00000000000..d0073fcf11c
--- /dev/null
+++ b/source/postprocess/composition_statistics.cc.bak
@@ -0,0 +1,168 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/composition_statistics.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    CompositionStatistics<dim>::execute (TableHandler &statistics)
+    {
+      if (this->n_compositional_fields() == 0)
+        return {"", ""};
+
+      // create a quadrature formula based on the compositional element alone.
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.compositional_fields;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      std::vector<double> compositional_values(n_q_points);
+
+      std::vector<double> local_compositional_integrals (this->n_compositional_fields());
+
+      // compute the integral quantities by quadrature
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+
+            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+              {
+                fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values (this->get_solution(),
+                    compositional_values);
+                for (unsigned int q=0; q<n_q_points; ++q)
+                  local_compositional_integrals[c] += compositional_values[q]*fe_values.JxW(q);
+              }
+          }
+      // compute the sum over all processors
+      std::vector<double> global_compositional_integrals (local_compositional_integrals.size());
+      Utilities::MPI::sum (local_compositional_integrals,
+                           this->get_mpi_communicator(),
+                           global_compositional_integrals);
+
+      // compute min/max by simply
+      // looping over the elements of the
+      // solution vector.
+      std::vector<double> local_min_compositions (this->n_compositional_fields(),
+                                                  std::numeric_limits<double>::max());
+      std::vector<double> local_max_compositions (this->n_compositional_fields(),
+                                                  std::numeric_limits<double>::lowest());
+
+      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+        {
+          IndexSet range = this->get_solution().block(this->introspection().block_indices.compositional_fields[c]).locally_owned_elements();
+          for (unsigned int i=0; i<range.n_elements(); ++i)
+            {
+              const unsigned int idx = range.nth_index_in_set(i);
+              const double val =  this->get_solution().block(this->introspection().block_indices.compositional_fields[c])(idx);
+
+              local_min_compositions[c] = std::min<double> (local_min_compositions[c], val);
+              local_max_compositions[c] = std::max<double> (local_max_compositions[c], val);
+            }
+
+        }
+
+      // now do the reductions over all processors
+      std::vector<double> global_min_compositions (this->n_compositional_fields(),
+                                                   std::numeric_limits<double>::max());
+      std::vector<double> global_max_compositions (this->n_compositional_fields(),
+                                                   std::numeric_limits<double>::lowest());
+      {
+        Utilities::MPI::min (local_min_compositions,
+                             this->get_mpi_communicator(),
+                             global_min_compositions);
+        Utilities::MPI::max (local_max_compositions,
+                             this->get_mpi_communicator(),
+                             global_max_compositions);
+      }
+
+      // finally produce something for the statistics file
+      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+        {
+          statistics.add_value ("Minimal value for composition " + this->introspection().name_for_compositional_index(c),
+                                global_min_compositions[c]);
+          statistics.add_value ("Maximal value for composition " + this->introspection().name_for_compositional_index(c),
+                                global_max_compositions[c]);
+          statistics.add_value ("Global mass for composition " + this->introspection().name_for_compositional_index(c),
+                                global_compositional_integrals[c]);
+        }
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+        {
+          const std::string columns[] = { "Minimal value for composition " + this->introspection().name_for_compositional_index(c),
+                                          "Maximal value for composition " + this->introspection().name_for_compositional_index(c),
+                                          "Global mass for composition " + this->introspection().name_for_compositional_index(c)
+                                        };
+          for (const auto &col : columns)
+            {
+              statistics.set_precision (col, 8);
+              statistics.set_scientific (col, true);
+            }
+        }
+
+      std::ostringstream output;
+      output.precision(4);
+      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+        {
+          output << global_min_compositions[c] << '/'
+                 << global_max_compositions[c] << '/'
+                 << global_compositional_integrals[c];
+          if (c+1 != this->n_compositional_fields())
+            output << " // ";
+        }
+
+      return std::pair<std::string, std::string> ("Compositions min/max/mass:",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(CompositionStatistics,
+                                  "composition statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the compositional fields, if present in this simulation. "
+                                  "In particular, it computes maximal and minimal values of "
+                                  "each field, as well as the total mass contained in this "
+                                  "field as defined by the integral "
+                                  "$m_i(t) = \\int_\\Omega c_i(\\mathbf x,t) \\; \\text{d}x$.")
+  }
+}
diff --git a/source/postprocess/composition_velocity_statistics.cc.bak b/source/postprocess/composition_velocity_statistics.cc.bak
new file mode 100644
index 00000000000..ce2244a748c
--- /dev/null
+++ b/source/postprocess/composition_velocity_statistics.cc.bak
@@ -0,0 +1,205 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/composition_velocity_statistics.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    CompositionVelocityStatistics<dim>::execute (TableHandler &statistics)
+    {
+      const QGauss<dim> quadrature_formula (this->get_fe()
+                                            .base_element(this->introspection().base_elements.velocities).degree+1);
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
+      std::vector<double> compositional_values(n_q_points);
+
+      std::vector<double> local_velocity_square_integral(this->n_compositional_fields());
+      std::vector<double> local_area_integral(this->n_compositional_fields());
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                                                                                        velocity_values);
+
+            for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+              {
+                fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
+                    compositional_values);
+
+                for (unsigned int q = 0; q < n_q_points; ++q)
+                  {
+                    if (compositional_values[q] >= 0.5)
+                      {
+                        local_velocity_square_integral[c] += ((velocity_values[q] * velocity_values[q]) *
+                                                              fe_values.JxW(q));
+                        local_area_integral[c] += fe_values.JxW(q);
+                      }
+                  }
+              }
+          }
+
+      std::vector<double> global_velocity_square_integral(local_velocity_square_integral.size());
+      Utilities::MPI::sum(local_velocity_square_integral, this->get_mpi_communicator(), global_velocity_square_integral);
+      std::vector<double> global_area_integral(local_area_integral.size());
+      Utilities::MPI::sum(local_area_integral, this->get_mpi_communicator(), global_area_integral);
+
+      // compute the RMS velocity for each compositional field and for the selected compositonal fields combined
+      std::vector<double> vrms_per_composition(local_area_integral.size());
+      double velocity_square_integral_selected_fields = 0., area_integral_selected_fields = 0.;
+      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+        {
+          vrms_per_composition[c] = std::sqrt(global_velocity_square_integral[c]) /
+                                    std::sqrt(global_area_integral[c]);
+
+          const std::vector<std::string>::iterator selected_field_it = std::find(selected_fields.begin(), selected_fields.end(), this->introspection().name_for_compositional_index(c));
+          if (selected_field_it != selected_fields.end())
+            {
+              velocity_square_integral_selected_fields += global_velocity_square_integral[c];
+              area_integral_selected_fields += global_area_integral[c];
+            }
+        }
+
+      const double vrms_selected_fields = std::sqrt(velocity_square_integral_selected_fields) / std::sqrt(area_integral_selected_fields);
+
+      const std::string unit = (this->convert_output_to_years()) ? "m/year" : "m/s";
+      const double time_scaling = (this->convert_output_to_years()) ? year_in_seconds : 1.0;
+
+      // finally produce something for the statistics file
+      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+        {
+          statistics.add_value("RMS velocity (" + unit + ") for composition " + this->introspection().name_for_compositional_index(c),
+                               time_scaling * vrms_per_composition[c]);
+
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          const std::string columns[] = {"RMS velocity (" + unit + ") for composition " +
+                                         this->introspection().name_for_compositional_index(c)
+                                        };
+
+          for (const auto &column : columns)
+            {
+              statistics.set_precision(column, 8);
+              statistics.set_scientific(column, true);
+            }
+        }
+
+      // Also output the selected fields vrms
+      statistics.add_value("RMS velocity (" + unit + ") for the selected field ",
+                           time_scaling * vrms_selected_fields);
+
+      const std::string column = {"RMS velocity (" + unit + ") for the selected field "};
+
+      statistics.set_precision(column, 8);
+      statistics.set_scientific(column, true);
+
+      std::ostringstream output;
+      output.precision(4);
+
+      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+        {
+          output << time_scaling *vrms_per_composition[c]
+                 << " " << unit;
+          output << " // ";
+        }
+      output << time_scaling *vrms_selected_fields;
+
+      return std::pair<std::string, std::string>("RMS velocity for compositions and combined selected fields:",
+                                                 output.str());
+    }
+
+
+
+    template <int dim>
+    void
+    CompositionVelocityStatistics<dim>::declare_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Composition velocity statistics");
+        {
+          prm.declare_entry("Names of selected compositional fields", "",
+                            Patterns::List(Patterns::Anything()),
+                            "A list of names for each of the compositional fields that "
+                            "you want to compute the combined RMS velocity for.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    CompositionVelocityStatistics<dim>::parse_parameters(ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Composition velocity statistics");
+        {
+          selected_fields = Utilities::split_string_list(prm.get("Names of selected compositional fields"));
+
+          AssertThrow((selected_fields.size() > 0) &&
+                      (selected_fields.size() <= this->n_compositional_fields()),
+                      ExcMessage("The length of the list of names for the compositional "
+                                 "fields for which the RMS velocity is to be summed must be larger than zero "
+                                 "and smaller or equal to the number of compositional fields."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(CompositionVelocityStatistics,
+                                  "composition velocity statistics",
+                                  "A postprocessor that computes the root mean square velocity "
+                                  "over the area spanned by each compositional field (i.e. where "
+                                  "the field values are larger or equal to 0.5.")
+  }
+}
diff --git a/source/postprocess/core_statistics.cc.bak b/source/postprocess/core_statistics.cc.bak
new file mode 100644
index 00000000000..1179c83a4ff
--- /dev/null
+++ b/source/postprocess/core_statistics.cc.bak
@@ -0,0 +1,236 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/core_statistics.h>
+#include <aspect/simulator_access.h>
+#include <aspect/boundary_temperature/dynamic_core.h>
+#include <aspect/geometry_model/spherical_shell.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    CoreStatistics<dim>::CoreStatistics()
+    {
+      core_data.is_initialized = false;
+    }
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    CoreStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // now add all of the computed heat fluxes to the statistics object
+      // and create a single string that can be output to the screen
+      std::ostringstream screen_text;
+
+      const BoundaryTemperature::DynamicCore<dim> &dynamic_core =
+        this->get_boundary_temperature_manager().template get_matching_boundary_temperature_model<BoundaryTemperature::DynamicCore<dim>>();
+
+      core_data = dynamic_core.get_core_data();
+
+      // now add core mantle boundary heat flux to the statistics object
+      // and create a single string that can be output to the screen
+      const std::string name = "CMB heat flux out of the core (TW)";
+      statistics.add_value (name, -core_data.Q/1e12);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      statistics.set_precision (name, 3);
+      statistics.set_scientific (name, true);
+
+      // finally have something for the screen
+      screen_text.precision(3);
+      screen_text << -core_data.Q/1e12 << " TW,";
+
+
+      const std::string name1 = "CMB Temperature (K)";
+      statistics.add_value (name1, core_data.Ti);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      statistics.set_precision (name1, 2);
+      statistics.set_scientific (name1, false);
+
+      const std::string name2 = "Inner core radius (km)";
+      statistics.add_value (name2, core_data.Ri*1e-3);
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      statistics.set_precision (name2, 2);
+      statistics.set_scientific (name2, false);
+
+      const std::string name3 = "Light element concentration (%)";
+      statistics.add_value (name3, core_data.Xi*100);
+      statistics.set_precision (name3, 4);
+      statistics.set_scientific (name3, false);
+
+      if (excess_entropy_only)
+        {
+          const std::string name4 = "Excess entropy (W/K)";
+          const double delta_E = core_data.Es*core_data.dT_dt
+                                 + core_data.Er
+                                 + core_data.Eh*core_data.dR_dt
+                                 + core_data.El*core_data.dR_dt
+                                 + core_data.Eg*core_data.dR_dt
+                                 - core_data.Ek;
+          statistics.add_value (name4, delta_E);
+          statistics.set_precision (name4, 3);
+          statistics.set_scientific (name4, true);
+        }
+      else
+        {
+          const std::string name5 = "Es (W/K)";
+          statistics.add_value (name5, core_data.Es*core_data.dT_dt);
+          statistics.set_precision (name5, 3);
+          statistics.set_scientific (name5, true);
+
+          const std::string name6 = "Er (W/K)";
+          statistics.add_value (name6, core_data.Er);
+          statistics.set_precision (name6, 3);
+          statistics.set_scientific (name6, true);
+
+          const std::string name7 = "Eh (W/K)";
+          statistics.add_value (name7, core_data.Eh*core_data.dR_dt);
+          statistics.set_precision (name7, 3);
+          statistics.set_scientific (name7, true);
+
+          const std::string name8 = "El (W/K)";
+          statistics.add_value (name8, core_data.El*core_data.dR_dt);
+          statistics.set_precision (name8, 3);
+          statistics.set_scientific (name8, true);
+
+          const std::string name9 = "Eg (W/K)";
+          statistics.add_value (name9, core_data.Eg*core_data.dR_dt);
+          statistics.set_precision (name9, 3);
+          statistics.set_scientific (name9, true);
+
+          const std::string name10 = "Ek (W/K)";
+          statistics.add_value (name10, core_data.Ek);
+          statistics.set_precision (name10, 3);
+          statistics.set_scientific (name10, true);
+        }
+
+      if (dynamic_core.is_OES_used())
+        {
+          const std::string name11 = "Other energy source (W)";
+          statistics.add_value (name11, core_data.Q_OES);
+          statistics.set_precision (name11, 3);
+          statistics.set_scientific (name11, true);
+        }
+
+      return std::pair<std::string, std::string> ("CMB heat flux out of the core",
+                                                  screen_text.str());
+    }
+
+    template <int dim>
+    void
+    CoreStatistics<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Dynamic core statistics");
+        {
+          prm.declare_entry("Excess entropy only","false",
+                            Patterns::Bool(),
+                            "Output the excess entropy only instead the each entropy terms.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    CoreStatistics<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Dynamic core statistics");
+        {
+          excess_entropy_only = prm.get_bool("Excess entropy only");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    const BoundaryTemperature::internal::CoreData &
+    CoreStatistics<dim>::get_core_data() const
+    {
+      return core_data;
+    }
+
+    template <int dim>
+    template <class Archive>
+    void CoreStatistics<dim>::serialize (Archive &ar, const unsigned int)
+    {
+      ar &(core_data.Ti);
+      ar &(core_data.Ri);
+      ar &(core_data.Xi);
+      ar &(core_data.Q);
+      ar &(core_data.dR_dt);
+      ar &(core_data.dT_dt);
+      ar &(core_data.dX_dt);
+      ar &(core_data.is_initialized);
+    }
+
+    template <int dim>
+    void CoreStatistics<dim>::save (std::map<std::string, std::string> &status_strings) const
+    {
+      std::ostringstream os;
+      aspect::oarchive oa (os);
+      oa << (*this);
+
+      status_strings["CoreStatistics"] = os.str();
+    }
+
+    template <int dim>
+    void CoreStatistics<dim>::load (const std::map<std::string, std::string> &status_strings)
+    {
+      // see if something was saved
+      if (status_strings.find("CoreStatistics") != status_strings.end())
+        {
+          std::istringstream is (status_strings.find("CoreStatistics")->second);
+          aspect::iarchive ia (is);
+          ia >> (*this);
+        }
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(CoreStatistics,
+                                  "core statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the core evolution. (Working only with dynamic core boundary temperature plugin)")
+  }
+}
diff --git a/source/postprocess/crystal_preferred_orientation.cc.bak b/source/postprocess/crystal_preferred_orientation.cc.bak
new file mode 100644
index 00000000000..974ffa07e79
--- /dev/null
+++ b/source/postprocess/crystal_preferred_orientation.cc.bak
@@ -0,0 +1,870 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+ This file is part of ASPECT.
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/global.h>
+#include <aspect/postprocess/crystal_preferred_orientation.h>
+#include <aspect/particle/property/crystal_preferred_orientation.h>
+#include <aspect/utilities.h>
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+
+#include <boost/iostreams/filtering_streambuf.hpp>
+#include <boost/iostreams/copy.hpp>
+#include <boost/iostreams/filter/gzip.hpp>
+
+#include <cstdio>
+#include <unistd.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    CrystalPreferredOrientation<dim>::CrystalPreferredOrientation ()
+      :
+      // the following value is later read from the input file
+      output_interval (0),
+      // initialize this to a nonsensical value; set it to the actual time
+      // the first time around we get to check it
+      last_output_time (std::numeric_limits<double>::quiet_NaN()),
+      output_file_number (numbers::invalid_unsigned_int),
+      group_files(0),
+      write_in_background_thread(false)
+    {}
+
+
+
+    template <int dim>
+    CrystalPreferredOrientation<dim>::~CrystalPreferredOrientation ()
+    {
+      // make sure a thread that may still be running in the background,
+      // writing data, finishes
+      if (background_thread_main.joinable())
+        background_thread_main.join ();
+
+      if (background_thread_content_raw.joinable())
+        background_thread_content_raw.join ();
+
+      if (background_thread_content_draw_volume_weighting.joinable())
+        background_thread_content_draw_volume_weighting.join ();
+    }
+
+
+
+    template <int dim>
+    void
+    CrystalPreferredOrientation<dim>::initialize ()
+    {
+      const unsigned int my_rank = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
+      this->random_number_generator.seed(random_number_seed+my_rank);
+    }
+
+
+
+    template <int dim>
+    std::list<std::string>
+    CrystalPreferredOrientation<dim>::required_other_postprocessors () const
+    {
+      return {"particles"};
+    }
+
+
+
+    template <int dim>
+    // We need to pass the arguments by value, as this function can be called on a separate thread:
+    void CrystalPreferredOrientation<dim>::writer (const std::string &filename,
+                                                   const std::string &temporary_output_location,
+                                                   const std::string &file_contents,
+                                                   const bool compress_contents)
+    {
+      std::string tmp_filename = filename;
+      if (temporary_output_location != "")
+        {
+          tmp_filename = temporary_output_location + "/aspect.tmp.XXXXXX";
+
+          // Create the temporary file; get at the actual filename
+          // by using a C-style string that mkstemp will then overwrite
+          std::vector<char> tmp_filename_x (tmp_filename.size()+1);
+          std::strcpy(tmp_filename_x.data(), tmp_filename.c_str());
+          const int tmp_file_desc = mkstemp(tmp_filename_x.data());
+          tmp_filename = tmp_filename_x.data();
+
+          // If we failed to create the temp file, just write directly to the target file.
+          // We also provide a warning about this fact. There are places where
+          // this fails *on every node*, so we will get a lot of warning messages
+          // into the output; in these cases, just writing multiple pieces to
+          // std::cerr will produce an unreadable mass of text; rather, first
+          // assemble the error message completely, and then output it atomically
+          if (tmp_file_desc == -1)
+            {
+              const std::string x = ("***** WARNING: could not create temporary file <"
+                                     +
+                                     tmp_filename
+                                     +
+                                     ">, will output directly to final location. This may negatively "
+                                     "affect performance. (On processor "
+                                     + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD))
+                                     + ".)\n");
+
+              std::cerr << x << std::flush;
+
+              tmp_filename = filename;
+            }
+          else
+            close(tmp_file_desc);
+        }
+
+      std::ofstream out(tmp_filename.c_str(), std::ofstream::binary);
+
+      AssertThrow (out, ExcMessage(std::string("Trying to write to file <") +
+                                   filename +
+                                   ">, but the file can't be opened!"));
+
+      // now write and then move the tmp file to its final destination
+      // if necessary
+      if (compress_contents)
+        {
+          namespace bio = boost::iostreams;
+
+          std::stringstream origin(file_contents);
+
+          bio::filtering_streambuf<bio::input> compress_out;
+          compress_out.push(bio::zlib_compressor());
+          compress_out.push(origin);
+          bio::copy(compress_out, out);
+        }
+      else
+        {
+          out << file_contents;
+        }
+
+      out.close ();
+
+      if (tmp_filename != filename)
+        {
+          std::string command = std::string("mv ") + tmp_filename + " " + filename;
+          int error = system(command.c_str());
+
+          AssertThrow(error == 0,
+                      ExcMessage("Could not move " + tmp_filename + " to "
+                                 + filename + ". On processor "
+                                 + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD)) + "."));
+        }
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    CrystalPreferredOrientation<dim>::execute (TableHandler &statistics)
+    {
+
+      const Particle::Property::Manager<dim> &manager = this->get_particle_world(0).get_property_manager();
+      const Particle::Property::ParticleHandler<dim> &particle_handler = this->get_particle_world(0).get_particle_handler();
+
+      const bool cpo_elastic_decomposition_plugin_exists = manager.plugin_name_exists("elastic tensor decomposition");
+
+      // Get a reference to the CPO particle property.
+      const Particle::Property::CrystalPreferredOrientation<dim> &cpo_particle_property =
+        manager.template get_matching_property<Particle::Property::CrystalPreferredOrientation<dim>>();
+
+      const unsigned int n_grains = cpo_particle_property.get_number_of_grains();
+      const unsigned int n_minerals = cpo_particle_property.get_number_of_minerals();
+
+      // if this is the first time we get here, set the last output time
+      // to the current time - output_interval. this makes sure we
+      // always produce data during the first time step
+      if (std::isnan(last_output_time))
+        last_output_time = this->get_time() - output_interval;
+
+      // If it's not time to generate an output file or we do not write output
+      // return early.
+      if (this->get_time() < last_output_time + output_interval && this->get_time() != end_time)
+        return std::make_pair("","");
+
+      if (output_file_number == numbers::invalid_unsigned_int)
+        output_file_number = 0;
+      else
+        ++output_file_number;
+
+      // Now prepare everything for writing the output
+      std::string particle_file_prefix_main = this->get_output_directory() +  "particles_cpo/particles-" + Utilities::int_to_string (output_file_number, 5);
+      std::string particle_file_prefix_content_raw = this->get_output_directory() +  "particles_cpo/CPO-" + Utilities::int_to_string (output_file_number, 5);
+      std::string particle_file_prefix_content_draw_volume_weighting = this->get_output_directory() +  "particles_cpo/weighted_CPO-" + Utilities::int_to_string (output_file_number, 5);
+
+      std::stringstream string_stream_main;
+      std::stringstream string_stream_content_raw;
+      std::stringstream string_stream_content_draw_volume_weighting;
+
+      string_stream_main << "id x y" << (dim == 3 ? " z" : "") << " olivine_deformation_type"
+                         << (cpo_elastic_decomposition_plugin_exists ? (std::string(" full_norm_square ")
+                                                                        + "triclinic_norm_square_p1 triclinic_norm_square_p2 triclinic_norm_square_p3 "
+                                                                        + "monoclinic_norm_square_p1 monoclinic_norm_square_p2 monoclinic_norm_square_p3 "
+                                                                        + "orthohombic_norm_square_p1 orthohombic_norm_square_p2 orthohombic_norm_square_p3 "
+                                                                        + "tetragonal_norm_square_p1 tetragonal_norm_square_p2 tetragonal_norm_square_p3 "
+                                                                        + "hexagonal_norm_square_p1 hexagonal_norm_square_p2 hexagonal_norm_square_p3 "
+                                                                        + "isotropic_norm_square") : "") << std::endl;
+
+      // get particle data
+      const Particle::Property::ParticlePropertyInformation &property_information = this->get_particle_world(0).get_property_manager().get_data_info();
+
+      AssertThrow(property_information.fieldname_exists("cpo mineral 0 type") ,
+                  ExcMessage("No CPO particle properties found. Make sure that the CPO particle property plugin is selected."));
+
+
+
+      const unsigned int cpo_data_position = property_information.n_fields() == 0
+                                             ?
+                                             0
+                                             :
+                                             property_information.get_position_by_field_name("cpo mineral 0 type");
+
+      std::vector<std::vector<Tensor<2,3>>> rotation_matrices (n_minerals, {n_grains,Tensor<2,3>()});
+      std::vector<std::vector<std::array<double,3>>> euler_angles(n_minerals, {n_grains,{{0}}});
+
+      // write unweighted header
+      if (write_raw_cpo.size() != 0)
+        {
+          string_stream_content_raw << "id" << " " << std::setprecision(12);
+          for (unsigned int property_i = 0; property_i < write_raw_cpo.size(); ++property_i)
+            {
+              switch (write_raw_cpo[property_i].second)
+                {
+                  case Output::VolumeFraction:
+                    string_stream_content_raw << "mineral_" << write_raw_cpo[property_i].first << "_volume_fraction" << " ";
+                    break;
+
+                  case Output::RotationMatrix:
+                    string_stream_content_raw << "mineral_" << write_raw_cpo[property_i].first << "_RM_0" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_1" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_2" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_3" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_4" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_5" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_6" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_7" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_8" << " ";
+                    break;
+
+                  case Output::EulerAngles:
+                    string_stream_content_raw << "mineral_" << write_raw_cpo[property_i].first << "_EA_phi" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_EA_theta" << " "
+                                              << "mineral_" << write_raw_cpo[property_i].first << "_EA_z" << " ";
+                    break;
+                  default:
+                    Assert(false, ExcMessage("Internal error: raw CPO postprocess case not found."));
+                    break;
+                }
+            }
+          string_stream_content_raw << std::endl;
+        }
+
+
+      // write weighted header
+      if (write_draw_volume_weighted_cpo.size() != 0)
+        {
+          string_stream_content_draw_volume_weighting << "id" << " ";
+          for (unsigned int property_i = 0; property_i < write_draw_volume_weighted_cpo.size(); ++property_i)
+            {
+              switch (write_draw_volume_weighted_cpo[property_i].second)
+                {
+                  case Output::VolumeFraction:
+                    string_stream_content_draw_volume_weighting << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_volume_fraction" << " ";
+                    break;
+
+                  case Output::RotationMatrix:
+                    string_stream_content_draw_volume_weighting << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_0" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_1" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_2" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_3" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_4" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_5" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_6" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_7" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_8" << " ";
+                    break;
+
+                  case Output::EulerAngles:
+                    string_stream_content_draw_volume_weighting << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_EA_phi" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_EA_theta" << " "
+                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_EA_z" << " ";
+                    break;
+                  default:
+                    Assert(false, ExcMessage("Internal error: raw CPO postprocess case not found."));
+                    break;
+                }
+            }
+          string_stream_content_draw_volume_weighting << std::endl;
+
+        }
+
+      for (const auto &particle: particle_handler)
+        {
+          AssertThrow(particle.has_properties(),
+                      ExcMessage("No particle properties found. Make sure that the CPO particle property plugin is selected."));
+
+          const unsigned int id = particle.get_id();
+          const ArrayView<const double> properties = particle.get_properties();
+
+          const Point<dim> position = particle.get_location();
+
+          // always make a vector of rotation matrices
+          for (unsigned int mineral = 0; mineral < n_minerals; ++mineral)
+            {
+              rotation_matrices[mineral].resize(n_grains);
+              for (unsigned int i_grain = 0; i_grain < n_grains; ++i_grain)
+                {
+                  rotation_matrices[mineral][i_grain] = cpo_particle_property.get_rotation_matrix_grains(
+                                                          cpo_data_position,
+                                                          properties,
+                                                          mineral,
+                                                          i_grain);
+                }
+            }
+
+          const unsigned int lpo_hex_data_position = property_information.n_fields() == 0 || cpo_elastic_decomposition_plugin_exists == false
+                                                     ?
+                                                     0
+                                                     :
+                                                     property_information.get_position_by_field_name("cpo elastic axis e1");
+
+          // write main file
+          string_stream_main << id << " " << position << " " << properties[cpo_data_position];
+
+          if (cpo_elastic_decomposition_plugin_exists == true)
+            {
+              string_stream_main << " " << properties[lpo_hex_data_position+12] << " " << properties[lpo_hex_data_position+13]
+                                 << " " << properties[lpo_hex_data_position+14] << " " << properties[lpo_hex_data_position+15]
+                                 << " " << properties[lpo_hex_data_position+16] << " " << properties[lpo_hex_data_position+17]
+                                 << " " << properties[lpo_hex_data_position+18] << " " << properties[lpo_hex_data_position+19]
+                                 << " " << properties[lpo_hex_data_position+20] << " " << properties[lpo_hex_data_position+21]
+                                 << " " << properties[lpo_hex_data_position+22] << " " << properties[lpo_hex_data_position+23]
+                                 << " " << properties[lpo_hex_data_position+24] << " " << properties[lpo_hex_data_position+25]
+                                 << " " << properties[lpo_hex_data_position+26] << " " << properties[lpo_hex_data_position+27]
+                                 << " " << properties[lpo_hex_data_position+28];
+            }
+          string_stream_main << std::endl;
+
+          // write content file
+          if (compute_raw_euler_angles == true)
+            {
+              euler_angles.resize(n_minerals);
+              for (unsigned int mineral = 0; mineral < n_minerals; ++mineral)
+                {
+                  euler_angles[mineral].resize(n_grains);
+                  for (unsigned int i_grain = 0; i_grain < n_grains; ++i_grain)
+                    {
+                      euler_angles[mineral][i_grain] = Utilities::zxz_euler_angles_from_rotation_matrix(
+                                                         rotation_matrices[mineral][i_grain]);
+                    }
+                }
+            }
+
+          if (write_raw_cpo.size() != 0)
+            {
+              // write unweighted data
+              for (unsigned int grain = 0; grain < n_grains; ++grain)
+                {
+                  string_stream_content_raw << id << " ";
+                  for (unsigned int property_i = 0; property_i < write_raw_cpo.size(); ++property_i)
+                    {
+                      switch (write_raw_cpo[property_i].second)
+                        {
+                          case Output::VolumeFraction:
+                            string_stream_content_raw << cpo_particle_property.get_volume_fractions_grains(
+                                                        cpo_data_position,
+                                                        properties,
+                                                        write_raw_cpo[property_i].first,
+                                                        grain) << " ";
+                            break;
+
+                          case Output::RotationMatrix:
+                            string_stream_content_raw << rotation_matrices[write_raw_cpo[property_i].first][grain]<< " ";
+                            break;
+
+                          case Output::EulerAngles:
+                            Assert(compute_raw_euler_angles == true,
+                                   ExcMessage("Internal error: writing out raw Euler angles, without them being computed."));
+                            string_stream_content_raw << euler_angles[write_raw_cpo[property_i].first][grain][0] << " "
+                                                      <<  euler_angles[write_raw_cpo[property_i].first][grain][1] << " "
+                                                      <<  euler_angles[write_raw_cpo[property_i].first][grain][2] << " ";
+                            break;
+                          default:
+                            Assert(false, ExcMessage("Internal error: raw CPO postprocess case not found."));
+                            break;
+                        }
+                    }
+                  string_stream_content_raw << std::endl;
+                }
+
+            }
+
+          if (write_draw_volume_weighted_cpo.size() != 0)
+            {
+              std::vector<std::vector<dealii::Tensor<2,3>>> weighted_rotation_matrices;
+              std::vector<std::vector<std::array<double,3>>> weighted_euler_angles;
+
+              weighted_euler_angles.resize(n_minerals);
+              weighted_rotation_matrices.resize(n_minerals);
+              std::vector<std::vector<double>> volume_fractions_grains(n_minerals,std::vector<double>(n_grains,-1.));
+              for (unsigned int mineral = 0; mineral < n_minerals; ++mineral)
+                {
+                  for (unsigned int i_grain = 0; i_grain < n_grains; ++i_grain)
+                    {
+                      weighted_euler_angles[mineral].resize(n_grains);
+                      weighted_rotation_matrices[mineral].resize(n_grains);
+                      volume_fractions_grains[mineral][i_grain] = cpo_particle_property.get_volume_fractions_grains(
+                                                                    cpo_data_position,
+                                                                    properties,
+                                                                    mineral,
+                                                                    i_grain);
+                    }
+                  weighted_rotation_matrices[mineral] = Utilities::rotation_matrices_random_draw_volume_weighting(volume_fractions_grains[mineral], rotation_matrices[mineral], n_grains, this->random_number_generator);
+
+                  Assert(weighted_rotation_matrices[mineral].size() == euler_angles[mineral].size(),
+                         ExcMessage("Weighted rotation matrices vector (size = " + std::to_string(weighted_rotation_matrices[mineral].size()) +
+                                    ") has different size from input angles (size = " + std::to_string(euler_angles[mineral].size()) + ")."));
+
+                  for (unsigned int i_grain = 0; i_grain < n_grains; ++i_grain)
+                    {
+                      weighted_euler_angles[mineral][i_grain] = Utilities::zxz_euler_angles_from_rotation_matrix(
+                                                                  weighted_rotation_matrices[mineral][i_grain]);
+                    }
+                }
+              string_stream_content_draw_volume_weighting << std::endl;
+
+              // write data
+              for (unsigned int grain = 0; grain < n_grains; ++grain)
+                {
+                  string_stream_content_draw_volume_weighting << id << " ";
+                  for (unsigned int property_i = 0; property_i < write_draw_volume_weighted_cpo.size(); ++property_i)
+                    {
+                      switch (write_draw_volume_weighted_cpo[property_i].second)
+                        {
+                          case Output::VolumeFraction:
+                            string_stream_content_draw_volume_weighting << volume_fractions_grains[write_draw_volume_weighted_cpo[property_i].first][grain] << " ";
+                            break;
+
+                          case Output::RotationMatrix:
+                            string_stream_content_draw_volume_weighting << weighted_rotation_matrices[write_draw_volume_weighted_cpo[property_i].first][grain] << " ";
+                            break;
+
+                          case Output::EulerAngles:
+                            Assert(compute_raw_euler_angles == true,
+                                   ExcMessage("Internal error: writing out raw Euler angles, without them being computed."));
+                            string_stream_content_draw_volume_weighting << weighted_euler_angles[write_draw_volume_weighted_cpo[property_i].first][grain][0] << " "
+                                                                        <<  weighted_euler_angles[write_draw_volume_weighted_cpo[property_i].first][grain][1] << " "
+                                                                        <<  weighted_euler_angles[write_draw_volume_weighted_cpo[property_i].first][grain][2] << " ";
+                            break;
+
+                          default:
+                            Assert(false, ExcMessage("Internal error: raw CPO postprocess case not found."));
+                            break;
+                        }
+                    }
+                  string_stream_content_draw_volume_weighting << std::endl;
+                }
+            }
+        }
+
+      std::string filename_main = particle_file_prefix_main + "." + Utilities::int_to_string(dealii::Utilities::MPI::this_mpi_process (this->get_mpi_communicator()),4) + ".dat";
+      std::string filename_raw = particle_file_prefix_content_raw + "." + Utilities::int_to_string(dealii::Utilities::MPI::this_mpi_process (this->get_mpi_communicator()),4) + ".dat";
+      std::string filename_draw_volume_weighting = particle_file_prefix_content_draw_volume_weighting + "." + Utilities::int_to_string(dealii::Utilities::MPI::this_mpi_process (this->get_mpi_communicator()),4) + ".dat";
+
+      std::unique_ptr<std::string> file_contents_main = std::make_unique<std::string>(string_stream_main.str());
+      std::unique_ptr<std::string> file_contents_raw = std::make_unique<std::string>(string_stream_content_raw.str());
+      std::unique_ptr<std::string> file_contents_draw_volume_weighting = std::make_unique<std::string>(string_stream_content_draw_volume_weighting.str());
+
+      if (write_in_background_thread)
+        {
+          // Wait for all previous write operations to finish, should
+          // any be still active,
+          if (background_thread_main.joinable())
+            background_thread_main.join ();
+
+          // then continue with writing the main file
+          background_thread_main
+            = std::thread([ my_filename = std::move(filename_main),
+                            my_temporary_output_location = temporary_output_location,
+                            my_file_contents = std::move(file_contents_main)]()
+          {
+            writer (my_filename, my_temporary_output_location, *my_file_contents, false);
+          });
+
+          if (write_raw_cpo.size() != 0)
+            {
+              // Wait for all previous write operations to finish, should
+              // any be still active,
+              if (background_thread_content_raw.joinable())
+                background_thread_content_raw.join ();
+
+              // then continue with writing our own data.
+              background_thread_content_raw
+                = std::thread([ my_filename = std::move(filename_raw),
+                                my_temporary_output_location = temporary_output_location,
+                                my_file_contents = std::move(file_contents_raw),
+                                my_compress_cpo_data_files = compress_cpo_data_files]()
+              {
+                writer (my_filename, my_temporary_output_location, *my_file_contents, my_compress_cpo_data_files);
+              });
+            }
+
+          if (write_draw_volume_weighted_cpo.size() != 0)
+            {
+              // Wait for all previous write operations to finish, should
+              // any be still active,
+              if (background_thread_content_draw_volume_weighting.joinable())
+                background_thread_content_draw_volume_weighting.join ();
+
+              // then continue with writing our own data.
+              background_thread_content_draw_volume_weighting
+                = std::thread([ my_filename = std::move(filename_draw_volume_weighting),
+                                my_temporary_output_location = temporary_output_location,
+                                my_file_contents = std::move(file_contents_draw_volume_weighting),
+                                my_compress_cpo_data_files = compress_cpo_data_files]()
+              {
+                writer (my_filename, my_temporary_output_location, *my_file_contents, my_compress_cpo_data_files);
+              });
+            }
+        }
+      else
+        {
+          writer(filename_main,temporary_output_location,*file_contents_main, false);
+          if (write_raw_cpo.size() != 0)
+            writer(filename_raw,temporary_output_location,*file_contents_raw, compress_cpo_data_files);
+          if (write_draw_volume_weighted_cpo.size() != 0)
+            writer(filename_draw_volume_weighting,temporary_output_location,*file_contents_draw_volume_weighting, compress_cpo_data_files);
+        }
+
+
+      // up the next time we need output
+      set_last_output_time (this->get_time());
+
+      const std::string &particles_cpo_output = particle_file_prefix_content_raw;
+
+      // record the file base file name in the output file
+      statistics.add_value ("Particle CPO file name", particles_cpo_output);
+      return std::make_pair("Writing particle cpo output:", particles_cpo_output);
+    }
+
+
+
+    template <int dim>
+    void
+    CrystalPreferredOrientation<dim>::set_last_output_time (const double current_time)
+    {
+      // if output_interval is positive, then update the last supposed output
+      // time
+      if (output_interval > 0)
+        {
+          // We need to find the last time output was supposed to be written.
+          // this is the last_output_time plus the largest positive multiple
+          // of output_intervals that passed since then. We need to handle the
+          // edge case where last_output_time+output_interval==current_time,
+          // we did an output and std::floor sadly rounds to zero. This is done
+          // by forcing std::floor to round 1.0-eps to 1.0.
+          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
+        }
+    }
+
+
+
+    template <int dim>
+    typename CrystalPreferredOrientation<dim>::Output
+    CrystalPreferredOrientation<dim>::string_to_output_enum(const std::string &string)
+    {
+      // olivine volume fraction, olivine rotation matrix, olivine Euler angles, enstatite volume fraction, enstatite rotation matrix, enstatite Euler angles
+      if (string == "volume fraction")
+        return Output::VolumeFraction;
+      if (string == "rotation matrix")
+        return Output::RotationMatrix;
+      if (string == "Euler angles")
+        return Output::EulerAngles;
+      return Output::not_found;
+    }
+
+
+
+    template <int dim>
+    void
+    CrystalPreferredOrientation<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Crystal Preferred Orientation");
+        {
+          prm.declare_entry ("Time between data output", "1e8",
+                             Patterns::Double (0),
+                             "The time interval between each generation of "
+                             "output files. A value of zero indicates that "
+                             "output should be generated every time step.\n\n"
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+
+          prm.declare_entry ("Random number seed", "1",
+                             Patterns::Integer (0),
+                             "The seed used to generate random numbers. This will make sure that "
+                             "results are reproducible as long as the problem is run with the "
+                             "same amount of MPI processes. It is implemented as final seed = "
+                             "random number seed + MPI Rank. ");
+
+          prm.declare_entry ("Write in background thread", "false",
+                             Patterns::Bool(),
+                             "File operations can potentially take a long time, blocking the "
+                             "progress of the rest of the model run. Setting this variable to "
+                             "`true' moves this process into background threads, while the "
+                             "rest of the model continues.");
+
+          prm.declare_entry ("Temporary output location", "",
+                             Patterns::Anything(),
+                             "On large clusters it can be advantageous to first write the "
+                             "output to a temporary file on a local file system and later "
+                             "move this file to a network file system. If this variable is "
+                             "set to a non-empty string it will be interpreted as a "
+                             "temporary storage location.");
+
+          prm.declare_entry ("Write out raw cpo data",
+                             "olivine volume fraction,olivine Euler angles,enstatite volume fraction,enstatite Euler angles",
+                             Patterns::List(Patterns::Anything()),
+                             "A list containing what particle cpo data needs "
+                             "to be written out after the particle id. This writes out the raw "
+                             "cpo data files for each MPI process. It can write out the following data: "
+                             "olivine volume fraction, olivine rotation matrix, olivine Euler angles, "
+                             "enstatite volume fraction, enstatite rotation matrix, enstatite Euler angles. \n"
+                             "Note that the rotation matrix and Euler angles both contain the same "
+                             "information, but in a different format. Euler angles are recommended "
+                             "over the rotation matrix since they only require to write 3 values instead "
+                             "of 9. If the list is empty, this file will not be written."
+                             "Furthermore, the entries will be written out in the order given, "
+                             "and if entries are entered multiple times, they will be written "
+                             "out multiple times.");
+
+          prm.declare_entry ("Write out draw volume weighted cpo data",
+                             "olivine Euler angles,enstatite Euler angles",
+                             Patterns::List(Patterns::Anything()),
+                             "A list containing the what part of the random draw volume "
+                             "weighted particle cpo data needs to be written out after "
+                             "the particle id. after using a random draw volume weighting. "
+                             "The random draw volume weigthing uses a uniform random distribution "
+                             "This writes out the raw cpo data files for "
+                             "each MPI process. It can write out the following data: "
+                             "olivine volume fraction, olivine rotation matrix, olivine Euler angles, "
+                             "enstatite volume fraction, enstatite rotation matrix, enstatite Euler angles. \n"
+                             "Note that the rotation matrix and Euler angles both contain the same "
+                             "information, but in a different format. Euler angles are recommended "
+                             "over the rotation matrix since they only require to write 3 values instead "
+                             "of 9. If the list is empty, this file will not be written. "
+                             "Furthermore, the entries will be written out in the order given, "
+                             "and if entries are entered multiple times, they will be written "
+                             "out multiple times.");
+          prm.declare_entry ("Compress cpo data files", "true",
+                             Patterns::Bool(),
+                             "Whether to compress the raw and weighted cpo data output files with zlib.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+    }
+
+
+
+    template <int dim>
+    void
+    CrystalPreferredOrientation<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      end_time = prm.get_double ("End time");
+      if (this->convert_output_to_years())
+        end_time *= year_in_seconds;
+
+      unsigned int n_minerals;
+
+      prm.enter_subsection("Particles");
+      {
+        prm.enter_subsection("Crystal Preferred Orientation");
+        {
+          prm.enter_subsection("Initial grains");
+          {
+            // Static variable of CPO has not been initialize yet, so we need to get it directly.
+            n_minerals = dealii::Utilities::split_string_list(prm.get("Minerals")).size();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Crystal Preferred Orientation");
+        {
+          output_interval = prm.get_double ("Time between data output");
+          if (this->convert_output_to_years())
+            output_interval *= year_in_seconds;
+
+          random_number_seed = prm.get_integer ("Random number seed");
+
+          AssertThrow(this->get_parameters().run_postprocessors_on_nonlinear_iterations == false,
+                      ExcMessage("Postprocessing nonlinear iterations in models with "
+                                 "particles is currently not supported."));
+
+          aspect::Utilities::create_directory (this->get_output_directory() + "particles_cpo/",
+                                               this->get_mpi_communicator(),
+                                               true);
+
+          write_in_background_thread = prm.get_bool("Write in background thread");
+          temporary_output_location = prm.get("Temporary output location");
+
+          if (temporary_output_location != "")
+            {
+              // Check if a command-processor is available by calling system() with a
+              // null pointer. System is guaranteed to return non-zero if it finds
+              // a terminal and zero if there is none (like on the compute nodes of
+              // some cluster architectures, e.g. IBM BlueGene/Q)
+              AssertThrow(system((char *)nullptr) != 0,
+                          ExcMessage("Usage of a temporary storage location is only supported if "
+                                     "there is a terminal available to move the files to their final location "
+                                     "after writing. The system() command did not succeed in finding such a terminal."));
+            }
+
+          std::vector<std::string> write_raw_cpo_list = Utilities::split_string_list(prm.get("Write out raw cpo data"));
+          write_raw_cpo.resize(write_raw_cpo_list.size());
+          bool found_euler_angles = false;
+          for (unsigned int i = 0; i < write_raw_cpo_list.size(); ++i)
+            {
+              std::vector<std::string> split_raw_cpo_instructions = Utilities::split_string_list(write_raw_cpo_list[i],':');
+
+              AssertThrow(split_raw_cpo_instructions.size() == 2,
+                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
+                                     + "because it should contain a mineral identification and a output specifier separated by a colon (:). This entry "
+                                     + "does not follow those rules."));
+
+              // get mineral number
+              std::vector<std::string> mineral_instructions = Utilities::split_string_list(split_raw_cpo_instructions[0],' ');
+              AssertThrow(mineral_instructions.size() == 2,
+                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
+                                     + "because the mineral identification part should contain two elements, the word mineral and a number."));
+
+              AssertThrow(mineral_instructions[0] == "mineral",
+                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
+                                     + "because the mineral identification part should start with the word mineral and it starts with \""
+                                     + mineral_instructions[0] + "\"."));
+
+              int mineral_number = Utilities::string_to_int(mineral_instructions[1]);
+              Assert(mineral_number >= 0, ExcMessage("Internal error: mineral_number is negative: " + std::to_string(mineral_number) + "."));
+
+              AssertThrow((unsigned int) mineral_number < n_minerals,
+                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
+                                     + "because the mineral number (" + std::to_string(mineral_number) + ") is larger than the number of minerals "
+                                     + "provided in the CPO subsection (" + std::to_string(n_minerals) + ")."));
+
+              // get mineral fabric/deformation type
+              Output cpo_fabric_instruction = string_to_output_enum(split_raw_cpo_instructions[1]);
+
+              AssertThrow(cpo_fabric_instruction != Output::not_found,
+                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option."));
+
+              if (cpo_fabric_instruction == Output::EulerAngles)
+                found_euler_angles = true;
+
+              write_raw_cpo[i] = std::make_pair(mineral_number,cpo_fabric_instruction);
+            }
+
+          std::vector<std::string> write_draw_volume_weighted_cpo_list = Utilities::split_string_list(prm.get("Write out draw volume weighted cpo data"));
+          write_draw_volume_weighted_cpo.resize(write_draw_volume_weighted_cpo_list.size());
+          bool found_rotation_matrix = false;
+          for (unsigned int i = 0; i < write_draw_volume_weighted_cpo_list.size(); ++i)
+            {
+              std::vector<std::string> split_draw_volume_weighted_cpo_instructions = Utilities::split_string_list(write_draw_volume_weighted_cpo_list[i],':');
+
+              AssertThrow(split_draw_volume_weighted_cpo_instructions.size() == 2,
+                          ExcMessage("Value \""+ write_draw_volume_weighted_cpo_list[i] +"\", set in \"Write out draw volume weighted cpo data\", is not a correct option "
+                                     + "because it should contain a mineral identification and a output specifier separated by a colon (:). This entry "
+                                     + "does not follow those rules."));
+
+              // get mineral number
+              std::vector<std::string> mineral_instructions = Utilities::split_string_list(split_draw_volume_weighted_cpo_instructions[0],' ');
+              AssertThrow(mineral_instructions.size() == 2,
+                          ExcMessage("Value \""+ write_draw_volume_weighted_cpo_list[i] +"\", set in \"Write out draw volume weighted cpo data\", is not a correct option "
+                                     + "because the mineral identification part should contain two elements, the word mineral and a number."));
+
+              AssertThrow(mineral_instructions[0] == "mineral",
+                          ExcMessage("Value \""+ write_draw_volume_weighted_cpo_list[i] +"\", set in \"Write out draw volume weighted cpo data\", is not a correct option "
+                                     + "because the mineral identification part should start with the word mineral and it starts with \""
+                                     + mineral_instructions[0] + "\"."));
+
+              int mineral_number = Utilities::string_to_int(mineral_instructions[1]);
+              Assert(mineral_number >= 0, ExcMessage("Internal error: mineral_number is negative: " + std::to_string(mineral_number) + "."));
+
+              AssertThrow((unsigned int) mineral_number < n_minerals,
+                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
+                                     + "because the mineral number (" + std::to_string(mineral_number) + ") is larger than the number of minerals "
+                                     + "provided in the CPO subsection (" + std::to_string(n_minerals) + ")."));
+
+              // get mineral fabric/deformation type
+              Output cpo_fabric_instruction = string_to_output_enum(split_draw_volume_weighted_cpo_instructions[1]);
+
+              AssertThrow(cpo_fabric_instruction != Output::not_found,
+                          ExcMessage("Value \""+ write_draw_volume_weighted_cpo_list[i] +"\", set in \"Write out draw volume weighted cpo data\", is not a correct option."));
+
+              if (cpo_fabric_instruction == Output::RotationMatrix)
+                found_rotation_matrix = true;
+
+              write_draw_volume_weighted_cpo[i] = std::make_pair(mineral_number,cpo_fabric_instruction);
+            }
+
+          if (write_draw_volume_weighted_cpo_list.size() != 0 || found_euler_angles == true)
+            compute_raw_euler_angles = true;
+          else
+            compute_raw_euler_angles = false;
+
+          if (write_draw_volume_weighted_cpo_list.size() != 0 && found_rotation_matrix == true)
+            compute_weighted_rotation_matrix = true;
+          else
+            compute_weighted_rotation_matrix = false;
+
+          compress_cpo_data_files = prm.get_bool("Compress cpo data files");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(CrystalPreferredOrientation,
+                                  "crystal preferred orientation",
+                                  "A Postprocessor that writes out CPO specific particle data."
+                                  "It can write out the CPO data as it is stored (raw) and/or as a"
+                                  "random draw volume weighted representation. The latter one"
+                                  "is recommended for plotting against real data. For both representations"
+                                  "the specific output fields and their order can be set."
+                                  "The work of this postprocessor should better be done by the main particles "
+                                  "postprocessor, however we need to be able to process the data before outputting it, "
+                                  "which does not work with that postprocessor. If this is added to the other "
+                                  "postprocessor in the future this one becomes obsolete.")
+  }
+}
diff --git a/source/postprocess/depth_average.cc.bak b/source/postprocess/depth_average.cc.bak
new file mode 100644
index 00000000000..c753fef2467
--- /dev/null
+++ b/source/postprocess/depth_average.cc.bak
@@ -0,0 +1,517 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/depth_average.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/lateral_averaging.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/utilities.h>
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/tria.h>
+#include <deal.II/fe/fe_dgq.h>
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/numerics/data_out_stack.h>
+
+
+#include <cmath>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    template <class Archive>
+    void DepthAverage<dim>::DataPoint::serialize (Archive &ar,
+                                                  const unsigned int)
+    {
+      ar &time &values;
+    }
+
+
+    template <int dim>
+    DepthAverage<dim>::DepthAverage ()
+      :
+      // the following value is later read from the input file
+      output_interval (0),
+      // initialize this to a nonsensical value; set it to the actual time
+      // the first time around we get to check it
+      last_output_time (std::numeric_limits<double>::quiet_NaN()),
+      n_depth_zones (numbers::invalid_unsigned_int)
+    {}
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    DepthAverage<dim>::execute (TableHandler &)
+    {
+      // if this is the first time we get here, set the next output time
+      // to the current time. this makes sure we always produce data during
+      // the first time step
+      if (std::isnan(last_output_time))
+        last_output_time = this->get_time() - output_interval;
+
+      // see if output is requested at this time
+      if (this->get_time() < last_output_time + output_interval)
+        return {"", ""};
+
+      DataPoint data_point;
+      data_point.time       = this->get_time();
+
+      // Add all the requested fields
+      data_point.values = this->get_lateral_averaging().compute_lateral_averages(depth_bounds,variables);
+      entries.push_back (data_point);
+
+      // On the root process, write out the file. do this using the DataOutStack
+      // class on a piece-wise constant finite element space on
+      // a 1d mesh with the correct subdivisions
+      const std::string filename_prefix (this->get_output_directory() + "depth_average");
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          Triangulation<1> mesh;
+          const Point<1> p(depth_bounds[0]);
+          std::vector<std::vector<double>> spacing(1,std::vector<double>(depth_bounds.size()-1,0.0));
+          for (unsigned int i=0; i<spacing[0].size(); ++i)
+            spacing[0][i]=depth_bounds[i+1]-depth_bounds[i];
+
+          Table<1, types::material_id> material_id(spacing[0].size());
+
+          GridGenerator::subdivided_hyper_rectangle(mesh, spacing, p, material_id);
+
+          FE_DGQ<1> fe(0);
+          DoFHandler<1> dof_handler (mesh);
+          dof_handler.distribute_dofs(fe);
+          Assert (dof_handler.n_dofs() == n_depth_zones, ExcInternalError());
+
+          DataOutStack<1> data_out_stack;
+
+          for (const auto &output_format_string: output_formats)
+            {
+              if (output_format_string != "txt")
+                {
+                  for (const auto &variable : variables)
+                    data_out_stack.declare_data_vector (variable,
+                                                        DataOutStack<1>::cell_vector);
+
+                  for (unsigned int i=0; i<entries.size(); ++i)
+                    {
+                      data_out_stack.new_parameter_value ((this->convert_output_to_years()
+                                                           ?
+                                                           entries[i].time / year_in_seconds
+                                                           :
+                                                           entries[i].time),
+                                                          // declare the time step, which here is the difference
+                                                          // between successive output times. we don't have anything
+                                                          // for the first time step, however. we could do a zero
+                                                          // delta, but that leads to invisible output. rather, we
+                                                          // use an artificial value of one tenth of the first interval,
+                                                          // if available
+                                                          (i == 0 ?
+                                                           (entries.size() > 1 ? (entries[1].time - entries[0].time)/10 : 0) :
+                                                           entries[i].time - entries[i-1].time) /
+                                                          (this->convert_output_to_years()
+                                                           ?
+                                                           year_in_seconds
+                                                           :
+                                                           1));
+
+                      data_out_stack.attach_dof_handler (dof_handler);
+
+                      Vector<double> tmp(n_depth_zones);
+                      for (unsigned int j=0; j<variables.size(); ++j)
+                        {
+                          std::copy (entries[i].values[j].begin(),
+                                     entries[i].values[j].end(),
+                                     tmp.begin());
+                          data_out_stack.add_data_vector (tmp,
+                                                          variables[j]);
+                        }
+                      data_out_stack.build_patches ();
+                      data_out_stack.finish_parameter_value ();
+                    }
+
+                  const DataOutBase::OutputFormat output_format = DataOutBase::parse_output_format(output_format_string);
+
+                  const std::string filename = (filename_prefix +
+                                                DataOutBase::default_suffix(output_format));
+                  std::ofstream f (filename);
+
+
+                  if (output_format == DataOutBase::gnuplot)
+                    {
+                      DataOutBase::GnuplotFlags gnuplot_flags;
+                      gnuplot_flags.space_dimension_labels.resize(2);
+                      gnuplot_flags.space_dimension_labels[0] = "depth";
+                      gnuplot_flags.space_dimension_labels[1] = "time";
+                      data_out_stack.set_flags(gnuplot_flags);
+                    }
+                  data_out_stack.write (f, output_format);
+
+                  AssertThrow (f, ExcMessage("Writing data to <" + filename +
+                                             "> did not succeed in the `point values' "
+                                             "postprocessor."));
+                }
+              else
+                {
+                  const std::string filename (this->get_output_directory() + "depth_average.txt");
+                  std::ofstream f(filename, std::ofstream::out);
+
+                  // Write the header
+                  f << "#       time" << "        depth";
+                  for (const auto &variable : variables)
+                    f << ' ' << variable;
+                  f << std::endl;
+
+                  // Output each data point in the entries object
+                  for (const auto &point : entries)
+                    {
+                      for (unsigned int d = 0; d < point.values[0].size(); ++d)
+                        {
+                          const double depth = (depth_bounds[d] + depth_bounds[d+1]) / 2.0;
+                          f << std::setw(12)
+                            << (this->convert_output_to_years() ? point.time/year_in_seconds : point.time)
+                            << ' ' << std::setw(12) << depth;
+                          for ( unsigned int i = 0; i < variables.size(); ++i )
+                            f << ' ' << std::setw(12) << point.values[i][d];
+                          f << std::endl;
+                        }
+                    }
+
+                  AssertThrow (f, ExcMessage("Writing data to <" + filename +
+                                             "> did not succeed in the `point values' "
+                                             "postprocessor."));
+                }
+            }
+        }
+
+      set_last_output_time (this->get_time());
+
+      // return what should be printed to the screen. note that we had
+      // just incremented the number, so use the previous value
+      return std::make_pair (std::string ("Writing depth average:"),
+                             filename_prefix);
+    }
+
+
+    template <int dim>
+    void
+    DepthAverage<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Depth average");
+        {
+          prm.declare_entry ("Time between graphical output", "1e8",
+                             Patterns::Double (0.),
+                             "The time interval between each generation of "
+                             "graphical output files. A value of zero indicates "
+                             "that output should be generated in each time step. "
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+          prm.declare_entry ("Number of zones", "10",
+                             Patterns::Integer (1),
+                             "The number of zones in depth direction within which we "
+                             "are to compute averages. By default, we subdivide the entire "
+                             "domain into 10 depth zones and compute temperature and other "
+                             "averages within each of these zones. However, if you have a "
+                             "very coarse mesh, it may not make much sense to subdivide "
+                             "the domain into so many zones and you may wish to choose "
+                             "less than this default. It may also make computations slightly "
+                             "faster. On the other hand, if you have an extremely highly "
+                             "resolved mesh, choosing more zones might also make sense.");
+          prm.declare_entry ("Depth boundaries of zones", "",
+                             Patterns::List (Patterns::Double()),
+                             "The depth boundaries of zones within which we "
+                             "are to compute averages. By default this list is empty "
+                             "and we subdivide the entire "
+                             "domain into equidistant depth zones and compute "
+                             "averages within each of these zones. If this list is not "
+                             "empty it has to contain one more entry "
+                             "than the 'Number of zones' parameter, representing the upper "
+                             "and lower depth boundary of each zone. It is not necessary to "
+                             "cover the whole depth-range (i.e. you can select to only average in "
+                             "a single layer by choosing 2 arbitrary depths as the boundaries "
+                             "of that layer).");
+          prm.declare_entry ("Output format", "gnuplot, txt",
+                             Patterns::MultipleSelection(DataOutBase::get_output_format_names().append("|txt")),
+                             "A list of formats in which the output shall be produced. The "
+                             "format in which the output is generated also determines "
+                             "the extension of the file into which data is written. "
+                             "The list of possible output formats that can be given "
+                             "here is documented in the appendix of the manual where "
+                             "the current parameter is described. By default the output "
+                             "is written as gnuplot file (for plotting), and as a simple "
+                             "text file.");
+          const std::string variables =
+            "all|temperature|composition|"
+            "adiabatic temperature|adiabatic pressure|adiabatic density|adiabatic density derivative|"
+            "velocity magnitude|sinking velocity|rising velocity|Vs|Vp|log viscosity|"
+            "viscosity|vertical heat flux|vertical mass flux|composition mass";
+          prm.declare_entry("List of output variables", "all",
+                            Patterns::MultipleSelection(variables),
+                            "A comma separated list which specifies which quantities to "
+                            "average in each depth slice. It defaults to averaging all "
+                            "available quantities, but this can be an expensive operation, "
+                            "so you may want to select only a few.\n\n"
+                            "Specifically, the sinking velocity is defined as the scalar "
+                            "product of the velocity and a unit vector in the direction of "
+                            "gravity, if positive (being zero if this product is negative, "
+                            "which would correspond to an upward velocity). "
+                            "The rising velocity is the opposite: the scalar product of "
+                            "the velocity and a unit vector in the direction opposite of "
+                            "gravity, if positive (being zero for downward velocities). "
+                            "\n\n"
+                            "List of options:\n"
+                            +variables);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    DepthAverage<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Depth average");
+        {
+          n_depth_zones = prm.get_integer ("Number of zones");
+          depth_bounds = Utilities::string_to_double(Utilities::split_string_list(
+                                                       prm.get("Depth boundaries of zones")));
+
+          AssertThrow(depth_bounds.size() == 0 || depth_bounds.size() == n_depth_zones + 1,
+                      ExcMessage("The parameter 'Depth boundaries of zones' has to be either empty, or have exactly "
+                                 "one more entry than the 'Number of zones' parameter."));
+
+          if (depth_bounds.size() == 0)
+            {
+              const double maximal_depth = this->get_geometry_model().maximal_depth();
+              depth_bounds.resize(n_depth_zones+1);
+
+              // Leave index 0 at 0.0, and generate an increasing range of equidistant depth bounds
+              for (unsigned int i=1; i<depth_bounds.size(); ++i)
+                depth_bounds[i] = depth_bounds[i-1] + maximal_depth / n_depth_zones;
+            }
+          else
+            for (unsigned int i=1; i<depth_bounds.size(); ++i)
+              {
+                AssertThrow(depth_bounds[i]>depth_bounds[i-1],
+                            ExcMessage("The entries in the parameter 'Depth boundaries of zones' have "
+                                       "to be sorted in increasing order."));
+              }
+
+          output_interval = prm.get_double ("Time between graphical output");
+          if (this->convert_output_to_years())
+            output_interval *= year_in_seconds;
+
+          if (output_interval > 0.0)
+            {
+              // since we increase the time indicating when to write the next graphical output
+              // every time we execute the depth average postprocessor, there is no good way to
+              // figure out when to write graphical output for the nonlinear iterations if we do
+              // not want to output every time step
+              AssertThrow(this->get_parameters().run_postprocessors_on_nonlinear_iterations == false,
+                          ExcMessage("Postprocessing nonlinear iterations is only supported if every time "
+                                     "step is visualized, or in other words, if the 'Time between graphical "
+                                     "output' in the Depth average postprocessor is set to zero."));
+            }
+
+          std::vector<std::string> output_variables = Utilities::split_string_list(prm.get("List of output variables"));
+          AssertThrow(Utilities::has_unique_entries(output_variables),
+                      ExcMessage("The list of strings for the parameter "
+                                 "'Postprocess/Depth average/List of output variables' contains entries more than once. "
+                                 "This is not allowed. Please check your parameter file."));
+
+          bool output_all_variables = false;
+          if ( std::find( output_variables.begin(), output_variables.end(), "all") != output_variables.end())
+            output_all_variables = true;
+
+          // we have to parse the list in this order to match the output columns
+          {
+            if (output_all_variables || std::find( output_variables.begin(), output_variables.end(), "temperature") != output_variables.end() )
+              variables.emplace_back("temperature");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "composition") != output_variables.end() )
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                variables.emplace_back(this->introspection().name_for_compositional_index(c));
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "adiabatic temperature") != output_variables.end() )
+              variables.emplace_back("adiabatic_temperature");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "adiabatic pressure") != output_variables.end() )
+              variables.emplace_back("adiabatic_pressure");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "adiabatic density") != output_variables.end() )
+              variables.emplace_back("adiabatic_density");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "adiabatic density derivative") != output_variables.end() )
+              variables.emplace_back("adiabatic_density_derivative");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "velocity magnitude") != output_variables.end() )
+              variables.emplace_back("velocity_magnitude");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "sinking velocity") != output_variables.end() )
+              variables.emplace_back("sinking_velocity");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "rising velocity") != output_variables.end() )
+              variables.emplace_back("rising_velocity");
+
+            // handle seismic velocities, because they may, or may not be provided by the material model
+            {
+              MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
+              this->get_material_model().create_additional_named_outputs(out);
+
+              const bool material_model_provides_seismic_output =
+                (out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>() != nullptr);
+
+              const bool output_vs = std::find( output_variables.begin(), output_variables.end(), "Vs") != output_variables.end();
+              const bool output_vp = std::find( output_variables.begin(), output_variables.end(), "Vp") != output_variables.end();
+
+              if (output_vs || output_vp)
+                AssertThrow(material_model_provides_seismic_output,
+                            ExcMessage("You requested seismic velocities from the 'Depth average' postprocessor, "
+                                       "but the material model does not provide seismic velocities. Either remove 'Vs' and "
+                                       "'Vp' from the 'List of output variables' parameter, or use a material model that "
+                                       "provides these velocities."));
+
+              if (output_all_variables && material_model_provides_seismic_output)
+                {
+                  variables.emplace_back("Vs");
+                  variables.emplace_back("Vp");
+                }
+
+              if (output_vs)
+                variables.emplace_back("Vs");
+
+              if (output_vp)
+                variables.emplace_back("Vp");
+            }
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "viscosity") != output_variables.end() )
+              variables.emplace_back("viscosity");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "log viscosity") != output_variables.end() )
+              variables.emplace_back("log_viscosity");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "vertical heat flux") != output_variables.end() )
+              variables.emplace_back("vertical_heat_flux");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "vertical mass flux") != output_variables.end() )
+              variables.emplace_back("vertical_mass_flux");
+
+            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "composition mass") != output_variables.end() )
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                variables.emplace_back(this->introspection().name_for_compositional_index(c) + std::string("_mass"));
+          }
+
+          output_formats = Utilities::split_string_list(prm.get("Output format"));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    template <class Archive>
+    void DepthAverage<dim>::serialize (Archive &ar, const unsigned int)
+    {
+      ar &last_output_time
+      & entries;
+    }
+
+
+    template <int dim>
+    void
+    DepthAverage<dim>::save (std::map<std::string, std::string> &status_strings) const
+    {
+      std::ostringstream os;
+      aspect::oarchive oa (os);
+      oa << (*this);
+
+      status_strings["DepthAverage"] = os.str();
+    }
+
+
+    template <int dim>
+    void
+    DepthAverage<dim>::load (const std::map<std::string, std::string> &status_strings)
+    {
+      // see if something was saved
+      if (status_strings.find("DepthAverage") != status_strings.end())
+        {
+          std::istringstream is (status_strings.find("DepthAverage")->second);
+          aspect::iarchive ia (is);
+          ia >> (*this);
+        }
+    }
+
+
+    template <int dim>
+    void
+    DepthAverage<dim>::set_last_output_time (const double current_time)
+    {
+      // if output_interval is positive, then set the next output interval to
+      // a positive multiple.
+      if (output_interval > 0)
+        {
+          // We need to find the last time output was supposed to be written.
+          // this is the last_output_time plus the largest positive multiple
+          // of output_intervals that passed since then. We need to handle the
+          // edge case where last_output_time+output_interval==current_time,
+          // we did an output and std::floor sadly rounds to zero. This is done
+          // by forcing std::floor to round 1.0-eps to 1.0.
+          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
+        }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(DepthAverage,
+                                  "depth average",
+                                  "A postprocessor that computes depth averaged "
+                                  "quantities and writes them into a file <depth_average.ext> "
+                                  "in the output directory, where the extension of the file "
+                                  "is determined by the output format you select. In addition "
+                                  "to the output format, a number of other parameters also influence "
+                                  "this postprocessor, and they can be set in the section "
+                                  "\\texttt{Postprocess/Depth average} in the input file."
+                                  "\n\n"
+                                  "In the output files, the $x$-value of each data point corresponds "
+                                  "to the depth, whereas the $y$-value corresponds to the "
+                                  "simulation time. The time is provided in seconds or, if the "
+                                  "global ``Use years in output instead of seconds'' parameter is "
+                                  "set, in years.")
+  }
+}
diff --git a/source/postprocess/domain_volume_statistics.cc.bak b/source/postprocess/domain_volume_statistics.cc.bak
new file mode 100644
index 00000000000..c6220190fd3
--- /dev/null
+++ b/source/postprocess/domain_volume_statistics.cc.bak
@@ -0,0 +1,69 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/domain_volume_statistics.h>
+
+#include <deal.II/grid/grid_tools.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    DomainVolume<dim>::execute (TableHandler &statistics)
+    {
+      // Retrieve the current domain volume
+      const double global_volume = this->get_volume();
+
+      // add the volume to the statistics object
+      const std::string unit = (dim == 2) ? "m^2" : "m^3";
+      const std::string name = "Model domain volume (" + unit + ")";
+      statistics.add_value (name, global_volume);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      statistics.set_precision (name, 8);
+      statistics.set_scientific (name, true);
+
+      // create a single string to output to the screen
+      std::ostringstream screen_text;
+      screen_text.precision(4);
+      screen_text << global_volume << " " << unit;
+
+      return std::pair<std::string, std::string> ("Model domain volume:",
+                                                  screen_text.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(DomainVolume,
+                                  "domain volume statistics",
+                                  "A postprocessor that computes the total area (in 2d) "
+                                  "or volume (in 3d) of the computational domain. ")
+  }
+}
diff --git a/source/postprocess/dynamic_topography.cc.bak b/source/postprocess/dynamic_topography.cc.bak
new file mode 100644
index 00000000000..8751c8f9463
--- /dev/null
+++ b/source/postprocess/dynamic_topography.cc.bak
@@ -0,0 +1,548 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/postprocess/dynamic_topography.h>
+
+#include <aspect/postprocess/boundary_pressures.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    DynamicTopography<dim>::execute (TableHandler &)
+    {
+      const Postprocess::BoundaryPressures<dim> &boundary_pressures =
+        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::BoundaryPressures<dim>>();
+
+      // Get the average pressure at the top and bottom boundaries.
+      // This will be used to compute the dynamic pressure at the boundaries.
+      const double surface_pressure = boundary_pressures.pressure_at_top();
+      const double bottom_pressure = boundary_pressures.pressure_at_bottom();
+
+      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+      const types::boundary_id bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
+
+      // If the gravity vector is pointed *up*, as determined by representative points
+      // at the surface and at depth, then we are running backwards advection, and need
+      // to reverse the dynamic topography values.
+      const bool backward_advection = (this->get_gravity_model().gravity_vector(this->get_geometry_model().representative_point(0.)) *
+                                       (this->get_geometry_model().representative_point(0.) -
+                                        this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth()))) >= 0.;
+
+      const unsigned int quadrature_degree = this->get_fe().base_element(this->introspection().base_elements.velocities).degree+1;
+      // Gauss quadrature in the interior for best accuracy.
+      const QGauss<dim> quadrature_formula(quadrature_degree);
+      // GLL quadrature on the surface to get a diagonal mass matrix.
+      const QGaussLobatto<dim-1> quadrature_formula_face(quadrature_degree);
+
+      const unsigned int dofs_per_cell = this->get_fe().dofs_per_cell;
+      const unsigned int dofs_per_face = this->get_fe().dofs_per_face;
+      const unsigned int n_q_points = quadrature_formula.size();
+      const unsigned int n_face_q_points = quadrature_formula_face.size();
+
+      // The CBF method involves both boundary and volume integrals on the
+      // cells at the boundary. Construct FEValues objects for each of these integrations.
+      FEValues<dim> fe_volume_values (this->get_mapping(),
+                                      this->get_fe(),
+                                      quadrature_formula,
+                                      update_values |
+                                      update_gradients |
+                                      update_quadrature_points |
+                                      update_JxW_values);
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula_face,
+                                        update_JxW_values |
+                                        update_values |
+                                        update_gradients |
+                                        update_quadrature_points);
+
+      // Storage for shape function values for the current solution.
+      // Used for constructing the known side of the CBF system.
+      std::vector<Tensor<1,dim>> phi_u (dofs_per_cell);
+      std::vector<SymmetricTensor<2,dim>> epsilon_phi_u (dofs_per_cell);
+      std::vector<double> div_phi_u (dofs_per_cell);
+      std::vector<double> div_solution(n_q_points);
+
+      // Vectors for solving CBF system.
+      Vector<double> local_vector(dofs_per_cell);
+      Vector<double> local_mass_matrix(dofs_per_cell);
+
+      LinearAlgebra::BlockVector rhs_vector(this->introspection().index_sets.system_partitioning, this->get_mpi_communicator());
+      // The mass matrix may be stored in a vector as it is a
+      // diagonal matrix.
+      LinearAlgebra::BlockVector mass_matrix(this->introspection().index_sets.system_partitioning, this->get_mpi_communicator());
+
+      LinearAlgebra::BlockVector distributed_topo_vector(this->introspection().index_sets.system_partitioning, this->get_mpi_communicator());
+
+      topo_vector.reinit(this->introspection().index_sets.system_partitioning,
+                         this->introspection().index_sets.system_relevant_partitioning,
+                         this->get_mpi_communicator());
+      distributed_topo_vector = 0.;
+      topo_vector = 0.;
+
+      // Possibly keep track of the dynamic topography values for
+      // later surface output.
+      std::vector<std::pair<Point<dim>, double>> stored_values_surface;
+      std::vector<std::pair<Point<dim>, double>> stored_values_bottom;
+      visualization_values.reinit(this->get_triangulation().n_active_cells());
+      visualization_values = 0.;
+
+      // Loop over all of the surface cells and if one less than h/3 away from
+      // one of the top or bottom boundaries, assemble CBF system for it.
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          {
+            // see if the cell is at the *top* or *bottom* boundary, not just any boundary
+            unsigned int face_idx = numbers::invalid_unsigned_int;
+            for (const unsigned int f : cell->face_indices())
+              {
+                if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
+                  {
+                    // If the cell is at the top boundary, assign face_idx.
+                    face_idx = f;
+                    break;
+                  }
+                else if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
+                  {
+                    // If the cell is at the bottom boundary, assign face_idx.
+                    face_idx = f;
+                    break;
+                  }
+              }
+            // If the cell is not at the boundary, jump to the next cell.
+            if (face_idx == numbers::invalid_unsigned_int)
+              continue;
+
+            fe_volume_values.reinit (cell);
+            fe_face_values.reinit (cell, face_idx);
+
+            local_vector = 0.;
+            local_mass_matrix = 0.;
+
+            // Evaluate the material model in the cell volume.
+            MaterialModel::MaterialModelInputs<dim> in_volume(fe_volume_values, cell, this->introspection(), this->get_solution());
+            MaterialModel::MaterialModelOutputs<dim> out_volume(fe_volume_values.n_quadrature_points, this->n_compositional_fields());
+            in_volume.requested_properties = MaterialModel::MaterialProperties::density | MaterialModel::MaterialProperties::viscosity;
+            this->get_material_model().evaluate(in_volume, out_volume);
+
+            // Get solution values for the divergence of the velocity, which is not
+            // computed by the material model.
+            fe_volume_values[this->introspection().extractors.velocities].get_function_divergences (this->get_solution(), div_solution);
+
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                const double eta = out_volume.viscosities[q];
+                const double density = out_volume.densities[q];
+                const bool is_compressible = this->get_material_model().is_compressible();
+                const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(in_volume.position[q]);
+
+                // Set up shape function values
+                for (unsigned int k=0; k<dofs_per_cell; ++k)
+                  {
+                    phi_u[k] = fe_volume_values[this->introspection().extractors.velocities].value(k,q);
+                    epsilon_phi_u[k] = fe_volume_values[this->introspection().extractors.velocities].symmetric_gradient(k,q);
+                    div_phi_u[k] = fe_volume_values[this->introspection().extractors.velocities].divergence (k, q);
+                  }
+
+                for (unsigned int i = 0; i<dofs_per_cell; ++i)
+                  {
+                    // Viscous stress part
+                    local_vector(i) += 2.0 * eta * ( epsilon_phi_u[i] * in_volume.strain_rate[q]
+                                                     - (is_compressible ? 1./3. * div_phi_u[i] * div_solution[q] : 0.0) ) * fe_volume_values.JxW(q);
+                    // Pressure and compressibility parts
+                    local_vector(i) -= div_phi_u[i] * in_volume.pressure[q] * fe_volume_values.JxW(q);
+                    // Force part
+                    local_vector(i) -= density * gravity * phi_u[i] * fe_volume_values.JxW(q);
+                  }
+              }
+            // Assemble the mass matrix for cell face. Since we are using GLL
+            // quadrature, the mass matrix will be diagonal, and we can just assemble it into a vector.
+            for (unsigned int q=0; q < n_face_q_points; ++q)
+              for (unsigned int i=0; i<dofs_per_cell; ++i)
+                local_mass_matrix(i) += fe_face_values[this->introspection().extractors.velocities].value(i,q) *
+                                        fe_face_values[this->introspection().extractors.velocities].value(i,q) *
+                                        fe_face_values.JxW(q);
+
+            cell->distribute_local_to_global(local_vector, rhs_vector);
+            cell->distribute_local_to_global(local_mass_matrix, mass_matrix);
+          }
+
+      rhs_vector.compress(VectorOperation::add);
+      mass_matrix.compress(VectorOperation::add);
+
+      // Since the mass matrix is diagonal, we can just solve for the stress vector by dividing.
+      const IndexSet local_elements = mass_matrix.locally_owned_elements();
+      for (unsigned int k=0; k<local_elements.n_elements(); ++k)
+        {
+          const unsigned int global_index = local_elements.nth_index_in_set(k);
+          if (mass_matrix[global_index] > 1.e-15)
+            distributed_topo_vector[global_index] = rhs_vector[global_index]/mass_matrix[global_index];
+        }
+      distributed_topo_vector.compress(VectorOperation::insert);
+      topo_vector = distributed_topo_vector;
+
+      // Now loop over the cells again and solve for the dynamic topography.
+      // We solve for it on the support points of the system, since it can be
+      // directly put into a system vector of the right size.
+      std::vector<Point<dim-1>> face_support_points = this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_face_support_points();
+      Quadrature<dim-1> support_quadrature(face_support_points);
+      FEFaceValues<dim> fe_support_values (this->get_mapping(),
+                                           this->get_fe(),
+                                           support_quadrature,
+                                           update_values | update_normal_vectors
+                                           | update_gradients | update_quadrature_points);
+
+      std::vector<Tensor<1,dim>> stress_support_values( support_quadrature.size() );
+      std::vector<double> topo_values( support_quadrature.size() );
+      std::vector<types::global_dof_index> face_dof_indices (dofs_per_face);
+
+      // Also construct data structures for getting the dynamic topography at the cell face
+      // midpoints. This is a more practical thing for text output and visualization.
+      const QGauss<dim-1> output_quadrature(quadrature_degree);
+      FEFaceValues<dim> fe_output_values (this->get_mapping(),
+                                          this->get_fe(),
+                                          output_quadrature,
+                                          update_values | update_normal_vectors | update_gradients |
+                                          update_quadrature_points | update_JxW_values);
+      std::vector<Tensor<1,dim>> stress_output_values( output_quadrature.size() );
+
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          {
+            // see if the cell is at the *top* boundary, not just any boundary
+            unsigned int face_idx = numbers::invalid_unsigned_int;
+            // if the face is at the upper surface 'at_upper_surface' will be true, if
+            // it is at the lower surface 'at_upper_surface' will be false. The default
+            // is true and will be changed to false if it's at the lower boundary. If the
+            // cell is at neither boundary the loop will continue to the next cell.
+            bool at_upper_surface = true;
+            for (const unsigned int f : cell->face_indices())
+              {
+                if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
+                  {
+                    // If the cell is at the top boundary, assign face_idx.
+                    face_idx = f;
+                    at_upper_surface = true;
+                    break;
+                  }
+                else if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
+                  {
+                    // If the cell is at the bottom boundary, assign face_idx.
+                    face_idx = f;
+                    at_upper_surface = false;
+                    break;
+                  }
+              }
+            // If the cell is not at the boundary, jump to the next cell.
+            if (face_idx == numbers::invalid_unsigned_int)
+              continue;
+
+            fe_support_values.reinit (cell, face_idx);
+
+            // Evaluate the material model on the cell face.
+            MaterialModel::MaterialModelInputs<dim> in_support(fe_support_values, cell, this->introspection(), this->get_solution());
+            MaterialModel::MaterialModelOutputs<dim> out_support(fe_support_values.n_quadrature_points, this->n_compositional_fields());
+            in_support.requested_properties = MaterialModel::MaterialProperties::density;
+            this->get_material_model().evaluate(in_support, out_support);
+
+            fe_support_values[this->introspection().extractors.velocities].get_function_values(topo_vector, stress_support_values);
+            cell->face(face_idx)->get_dof_indices (face_dof_indices);
+            for (unsigned int i = 0; i < face_dof_indices.size(); ++i)
+              {
+                // Given the face dof, we get the component and overall cell dof index.
+                const std::pair<unsigned int, unsigned int> component_index = this->get_fe().face_system_to_component_index(i);
+                const unsigned int component = component_index.first;
+                const unsigned int support_index = component_index.second;
+                // Dynamic topography is stored in the temperature component.
+                if (component == this->introspection().component_indices.temperature)
+                  {
+                    // Compute the local gravity at the support point.
+                    const Point<dim> point = fe_support_values.quadrature_point(support_index);
+                    const double gravity_norm = this->get_gravity_model().gravity_vector(point).norm();
+                    const Tensor<1,dim> normal = fe_support_values.normal_vector(support_index);
+
+                    // Compute the dynamic topography, formulae are slightly different
+                    // for upper and lower boundaries.
+                    double dynamic_topography;
+                    if (at_upper_surface)
+                      {
+                        const double delta_rho = out_support.densities[support_index] - density_above;
+                        AssertThrow(std::abs(delta_rho) > std::numeric_limits<double>::min(),
+                                    ExcMessage("delta_rho is close or equal to zero at the surface."));
+                        dynamic_topography = (-stress_support_values[support_index]*normal - surface_pressure)
+                                             / delta_rho / gravity_norm;
+                      }
+                    else
+                      {
+                        const double delta_rho = out_support.densities[support_index] - density_below;
+                        AssertThrow(std::abs(delta_rho) > std::numeric_limits<double>::min(),
+                                    ExcMessage("delta_rho is close or equal to zero at the bottom."));
+                        dynamic_topography = (-stress_support_values[support_index]*normal - bottom_pressure)
+                                             / delta_rho / gravity_norm;
+                      }
+                    distributed_topo_vector[face_dof_indices[i]] = dynamic_topography * (backward_advection ? -1. : 1.);
+                  }
+              }
+
+            // Also evaluate the dynamic topography on the cell faces. This is more convenient
+            // for ASCII output, as well as for use with the visualization postprocessor.
+            fe_output_values.reinit(cell, face_idx);
+
+            // Evaluate the material model on the cell face.
+            MaterialModel::MaterialModelInputs<dim> in_output(fe_output_values, cell, this->introspection(), this->get_solution());
+            MaterialModel::MaterialModelOutputs<dim> out_output(fe_output_values.n_quadrature_points, this->n_compositional_fields());
+            in_output.requested_properties = MaterialModel::MaterialProperties::density;
+            this->get_material_model().evaluate(in_output, out_output);
+
+            fe_output_values[this->introspection().extractors.velocities].get_function_values(topo_vector, stress_output_values);
+
+            // Compute the average dynamic topography at the cell face.
+            double face_area = 0.;
+            double dynamic_topography = 0.;
+            for (unsigned int q=0; q < output_quadrature.size(); ++q)
+              {
+                const Point<dim> point = fe_output_values.quadrature_point(q);
+                const Tensor<1,dim> normal = fe_output_values.normal_vector(q);
+                const double gravity_norm = this->get_gravity_model().gravity_vector(point).norm();
+
+                if (at_upper_surface)
+                  {
+                    const double delta_rho = out_output.densities[q] - density_above;
+                    dynamic_topography += (-stress_output_values[q]*normal - surface_pressure)
+                                          / delta_rho / gravity_norm * fe_output_values.JxW(q);
+                  }
+                else
+                  {
+                    const double delta_rho = out_output.densities[q] - density_below;
+
+                    dynamic_topography += (-stress_output_values[q]*normal - bottom_pressure)
+                                          / delta_rho / gravity_norm * fe_output_values.JxW(q);
+                  }
+                face_area += fe_output_values.JxW(q);
+              }
+            // Get the average dynamic topography for the cell
+            dynamic_topography = dynamic_topography * (backward_advection ? -1. : 1.) / face_area;
+
+            // Maybe keep track of surface output vector.
+            const bool respect_manifold = true;
+            if (output_surface && at_upper_surface)
+              stored_values_surface.push_back(std::make_pair(cell->face(face_idx)->center(respect_manifold), dynamic_topography));
+            // Maybe keep track of bottom output vector.
+            if (output_bottom && !at_upper_surface)
+              stored_values_bottom.push_back(std::make_pair(cell->face(face_idx)->center(respect_manifold), dynamic_topography));
+
+            // Add the value to the vector for the visualization postprocessor.
+            visualization_values(cell->active_cell_index()) = dynamic_topography;
+          }
+      distributed_topo_vector.compress(VectorOperation::insert);
+      topo_vector = distributed_topo_vector;
+
+      // Possibly output the result to file.
+      if (output_surface)
+        output_to_file(top_boundary_id, stored_values_surface);
+      if (output_bottom)
+        output_to_file(bottom_boundary_id, stored_values_bottom);
+
+      return std::pair<std::string,std::string>("Computing dynamic topography", "");
+    }
+
+    /**
+     * Return the topography vector as calculated by CBF formulation
+     */
+    template <int dim>
+    const LinearAlgebra::BlockVector &
+    DynamicTopography<dim>::
+    topography_vector() const
+    {
+      return topo_vector;
+    }
+
+    /**
+     * Return the cellwise topography vector as calculated by CBF formulation
+     */
+    template <int dim>
+    const Vector<float> &
+    DynamicTopography<dim>::
+    cellwise_topography() const
+    {
+      return visualization_values;
+    }
+
+    /**
+     * Register the other postprocessor that we need: BoundaryPressures
+     */
+    template <int dim>
+    std::list<std::string>
+    DynamicTopography<dim>::required_other_postprocessors() const
+    {
+      return {"boundary pressures"};
+    }
+
+
+    /**
+     * Output the dynamic topography solution to
+     * a file.
+     */
+    template <int dim>
+    void
+    DynamicTopography<dim>::output_to_file(const types::boundary_id boundary_id,
+                                           const std::vector<std::pair<Point<dim>,double>> &position_and_topography)
+    {
+      // get boundary name and avoid spaces for file output
+      std::string boundary_name = this->get_geometry_model().translate_id_to_symbol_name(boundary_id);
+      std::replace(boundary_name.begin(), boundary_name.end(), ' ', '_');
+
+      std::ostringstream output;
+
+      // On processor 0, write header lines
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          output << "# "
+                 << ((dim==2)? "x y " : "x y z ")
+                 << "dynamic_topography_" << boundary_name << std::endl;
+        }
+
+      for (unsigned int i = 0; i < position_and_topography.size(); ++i)
+        {
+          output << std::setprecision(10)
+                 << position_and_topography[i].first
+                 << ' '
+                 << std::setprecision(10)
+                 << position_and_topography[i].second
+                 << std::endl;
+        }
+
+      std::string filename = this->get_output_directory() +
+                             "dynamic_topography_" + boundary_name + "." +
+                             Utilities::int_to_string(this->get_timestep_number(), 5);
+      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
+        filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
+
+      Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
+    }
+
+
+    /**
+     * Declare the parameters for the postprocessor.
+     */
+    template <int dim>
+    void
+    DynamicTopography<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Dynamic topography");
+        {
+          prm.declare_entry ("Density above","0.",
+                             Patterns::Double (0.),
+                             "Dynamic topography is calculated as the excess or lack of mass that is supported by mantle flow. "
+                             "This value depends on the density of material that is moved up or down, i.e. crustal rock, and the "
+                             "density of the material that is displaced (generally water or air). While the density of crustal rock "
+                             "is part of the material model, this parameter `Density above' allows the user to specify the density "
+                             "value of material that is displaced above the solid surface. By default this material is assumed to "
+                             "be air, with a density of 0. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Density below","9900.",
+                             Patterns::Double (0.),
+                             "Dynamic topography is calculated as the excess or lack of mass that is supported by mantle flow. "
+                             "This value depends on the density of material that is moved up or down, i.e. mantle above CMB, and the "
+                             "density of the material that is displaced (generally outer core material). While the density of mantle rock "
+                             "is part of the material model, this parameter `Density below' allows the user to specify the density "
+                             "value of material that is displaced below the solid surface. By default this material is assumed to "
+                             "be outer core material with a density of 9900. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Output surface", "true",
+                             Patterns::Bool(),
+                             "Whether to output a file containing the surface dynamic topography.");
+          prm.declare_entry ("Output bottom", "true",
+                             Patterns::Bool(),
+                             "Whether to output a file containing the bottom (i.e., CMB) dynamic topography.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    /**
+     * Declare the parameters for the postprocessor.
+     */
+    template <int dim>
+    void
+    DynamicTopography<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Dynamic topography");
+        {
+          density_above = prm.get_double ("Density above");
+          density_below = prm.get_double ("Density below");
+          output_surface = prm.get_bool ("Output surface");
+          output_bottom = prm.get_bool ("Output bottom");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(DynamicTopography,
+                                  "dynamic topography",
+                                  "A postprocessor that computes a measure of dynamic topography "
+                                  "based on the stress at the boundary. The data is written into text "
+                                  "files named `dynamic\\_topography_\\X.NNNNN' in the output directory, "
+                                  "where X is the name of the boundary and NNNNN is the number of the time step."
+                                  "\n\n"
+                                  "The exact approach works as follows: At each selected boundary, we compute "
+                                  "the traction that acts normal to the boundary faces using the "
+                                  "consistent boundary flux method as described in "
+                                  "``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
+                                  "The consistent Galerkin FEM for computing derived boundary "
+                                  "quantities in thermal and or fluids problems. International "
+                                  "Journal for Numerical Methods in Fluids, 7(4), 371-394.'' "
+                                  "From this traction, the dynamic topography is computed using the formula "
+                                  "$h=\\frac{\\sigma_{n}}{g \\rho}$ where $g$ is the norm of the gravity and $\\rho$ "
+                                  "is the density. For the bottom surface we chose the convention "
+                                  "that positive values are up and negative values are down, analogous to "
+                                  "the deformation of the upper surface. Note that this implementation takes "
+                                  "the direction of gravity into account, which means that reversing the flow "
+                                  "in backward advection calculations will not reverse the instantaneous topography "
+                                  "because the reverse flow will be divided by the reverse surface gravity.  "
+                                  "\n"
+                                  "The file format then consists of lines with Euclidean coordinates "
+                                  "followed by the corresponding topography value.")
+  }
+}
diff --git a/source/postprocess/entropy_viscosity_statistics.cc.bak b/source/postprocess/entropy_viscosity_statistics.cc.bak
new file mode 100644
index 00000000000..0df4a943994
--- /dev/null
+++ b/source/postprocess/entropy_viscosity_statistics.cc.bak
@@ -0,0 +1,118 @@
+/*
+  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/entropy_viscosity_statistics.h>
+#include <aspect/global.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    EntropyViscosityStatistics<dim>::execute (TableHandler &statistics)
+    {
+      Vector<float> entropy_viscosity(this->get_triangulation().n_active_cells());
+      this->get_artificial_viscosity(entropy_viscosity);
+
+      // The entropy viscosity is cell-wise constant, so a simple midpoint quadrature
+      // will be sufficient to integrate the value over cells.
+      const QMidpoint<dim> quadrature_formula;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_JxW_values);
+
+      double local_maximum_viscosity = 0.0;
+      double local_integrated_viscosity = 0.0;
+      double local_volume = 0.0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                const double entropy_viscosity_cell = entropy_viscosity[cell->active_cell_index()];
+                local_maximum_viscosity = std::max(local_maximum_viscosity,entropy_viscosity_cell);
+                local_volume += fe_values.JxW(q);
+                local_integrated_viscosity += entropy_viscosity_cell * fe_values.JxW(q);
+              }
+          }
+
+      const double global_integrated_viscosity
+        = Utilities::MPI::sum (local_integrated_viscosity, this->get_mpi_communicator());
+      const double global_integrated_volume
+        = Utilities::MPI::sum (local_volume, this->get_mpi_communicator());
+      const double global_maximum_viscosity
+        = Utilities::MPI::max (local_maximum_viscosity, this->get_mpi_communicator());
+
+      const double average_viscosity = global_integrated_viscosity / global_integrated_volume;
+
+      statistics.add_value ("Max entropy viscosity (W/(m*K))",
+                            global_maximum_viscosity);
+      statistics.add_value ("Average entropy viscosity (W/(m*K))",
+                            average_viscosity);
+
+      // also make sure that the columns filled by this plugin
+      // show up with sufficient accuracy and in scientific notation
+      const char *columns[] = { "Max entropy viscosity (W/(m*K))",
+                                "Average entropy viscosity (W/(m*K))"
+                              };
+      for (auto &column : columns)
+        {
+          statistics.set_precision (column, 8);
+          statistics.set_scientific (column, true);
+        }
+
+      std::ostringstream output;
+      output.precision(3);
+      output << global_maximum_viscosity
+             << " W/(m*K), "
+             << average_viscosity
+             << " W/(m*K)";
+
+
+      return std::pair<std::string, std::string> ("Max / average entropy viscosity:",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(EntropyViscosityStatistics,
+                                  "entropy viscosity statistics",
+                                  "A postprocessor that computes the maximum and volume averaged"
+                                  "entropy viscosity stabilization for the temperature field.")
+  }
+}
diff --git a/source/postprocess/geoid.cc.bak b/source/postprocess/geoid.cc.bak
new file mode 100644
index 00000000000..96789262ce4
--- /dev/null
+++ b/source/postprocess/geoid.cc.bak
@@ -0,0 +1,1060 @@
+/*
+ Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/simulator.h>
+#include <aspect/mesh_deformation/free_surface.h>
+#include <aspect/utilities.h>
+#include <aspect/postprocess/geoid.h>
+#include <aspect/postprocess/dynamic_topography.h>
+#include <aspect/postprocess/boundary_densities.h>
+#include <aspect/geometry_model/spherical_shell.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <aspect/citation_info.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::vector<double>,std::vector<double>>
+    Geoid<dim>::to_spherical_harmonic_coefficients(const std::vector<std::vector<double>> &spherical_function) const
+    {
+      std::vector<double> cosi(spherical_function.size(),0);
+      std::vector<double> sini(spherical_function.size(),0);
+      std::vector<double> coecos;
+      std::vector<double> coesin;
+
+      for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+        {
+          for (unsigned int iord = 0; iord < ideg+1; ++iord)
+            {
+              // Do the spherical harmonic expansion.
+              for (unsigned int ds_num = 0; ds_num < spherical_function.size(); ++ds_num)
+                {
+                  // Normalization after Dahlen and Tromp (1986) Appendix B.6.
+                  const std::pair<double,double> sph_harm_vals = aspect::Utilities::real_spherical_harmonic(ideg,iord,spherical_function.at(ds_num).at(0),spherical_function.at(ds_num).at(1));
+                  const double cos_component = sph_harm_vals.first; // real / cos part
+                  const double sin_component = sph_harm_vals.second; // imaginary / sin part
+
+                  cosi.at(ds_num) = (spherical_function.at(ds_num).at(3) * cos_component);
+                  sini.at(ds_num) = (spherical_function.at(ds_num).at(3) * sin_component);
+                }
+              // Integrate the contribution of each spherical infinitesimal.
+              double cosii = 0;
+              double sinii = 0;
+              for (unsigned int ds_num = 0; ds_num < spherical_function.size(); ++ds_num)
+                {
+                  cosii += cosi.at(ds_num) * spherical_function.at(ds_num).at(2);
+                  sinii += sini.at(ds_num) * spherical_function.at(ds_num).at(2);
+                }
+              coecos.push_back(cosii);
+              coesin.push_back(sinii);
+            }
+        }
+      // Sum over each processor.
+      dealii::Utilities::MPI::sum (coecos,this->get_mpi_communicator(),coecos);
+      dealii::Utilities::MPI::sum (coesin,this->get_mpi_communicator(),coesin);
+
+      return std::make_pair(coecos,coesin);
+    }
+
+    template <int dim>
+    std::pair<std::vector<double>,std::vector<double>>
+    Geoid<dim>::density_contribution (const double &/*outer_radius*/) const
+    {
+      Assert(false, ExcNotImplemented());
+      return std::make_pair(std::vector<double>(), std::vector<double>());
+
+    }
+
+    template <>
+    std::pair<std::vector<double>,std::vector<double>>
+    Geoid<3>::density_contribution (const double &outer_radius) const
+    {
+      const unsigned int quadrature_degree = this->introspection().polynomial_degree.temperature;
+
+      // Need to evaluate density contribution of each volume quadrature point.
+      const QGauss<3> quadrature_formula(quadrature_degree);
+
+      FEValues<3> fe_values (this->get_mapping(),
+                             this->get_fe(),
+                             quadrature_formula,
+                             update_values |
+                             update_quadrature_points |
+                             update_JxW_values |
+                             update_gradients);
+
+      MaterialModel::MaterialModelInputs<3> in(fe_values.n_quadrature_points, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<3> out(fe_values.n_quadrature_points, this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::density;
+
+      std::vector<std::vector<double>>
+      composition_values(this->n_compositional_fields(), std::vector<double>(quadrature_formula.size()));
+
+      // Directly do the global 3d integral over each quadrature point of every cell (different from traditional way to do layer integral).
+      // This is necessary because of ASPECT's adaptive mesh refinement feature.
+      std::vector<double> SH_density_coecos;
+      std::vector<double> SH_density_coesin;
+      for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+        {
+          for (unsigned int iord = 0; iord < ideg+1; ++iord)
+            {
+              // Initialization of the density contribution integral per degree, order.
+              double integrated_density_cos_component = 0;
+              double integrated_density_sin_component = 0;
+
+              // Loop over all of the cells.
+              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+                if (cell->is_locally_owned())
+                  {
+                    fe_values.reinit (cell);
+                    // Set use_strain_rates to false since we don't need viscosity.
+                    in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+                    this->get_material_model().evaluate(in, out);
+
+                    // Compute the integral of the density function
+                    // over the cell, by looping over all quadrature points.
+                    for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+                      {
+                        // Convert coordinates from [x,y,z] to [r, phi, theta].
+                        const std::array<double,3> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(in.position[q]);
+
+                        // Normalization after Dahlen and Tromp (1986) Appendix B.6.
+                        const std::pair<double,double> sph_harm_vals = aspect::Utilities::real_spherical_harmonic(ideg,iord,scoord[2],scoord[1]);
+                        const double cos_component = sph_harm_vals.first; // real / cos part
+                        const double sin_component = sph_harm_vals.second; // imaginary / sin part
+
+                        const double density = out.densities[q];
+                        const double r_q = in.position[q].norm();
+
+                        integrated_density_cos_component += density * (1./r_q) * std::pow(r_q/outer_radius,ideg+1) * cos_component * fe_values.JxW(q);
+                        integrated_density_sin_component += density * (1./r_q) * std::pow(r_q/outer_radius,ideg+1) * sin_component * fe_values.JxW(q);
+                      }
+                  }
+              SH_density_coecos.push_back(integrated_density_cos_component);
+              SH_density_coesin.push_back(integrated_density_sin_component);
+            }
+        }
+      // Sum over each processor.
+      dealii::Utilities::MPI::sum (SH_density_coecos,this->get_mpi_communicator(),SH_density_coecos);
+      dealii::Utilities::MPI::sum (SH_density_coesin,this->get_mpi_communicator(),SH_density_coesin);
+
+      return std::make_pair(SH_density_coecos,SH_density_coesin);
+    }
+
+    template <int dim>
+    std::pair<std::pair<double, std::pair<std::vector<double>,std::vector<double>>>, std::pair<double, std::pair<std::vector<double>,std::vector<double>>>>
+    Geoid<dim>::topography_contribution(const double &/*outer_radius*/,
+                                        const double &/*inner_radius*/) const
+    {
+      Assert(false, ExcNotImplemented());
+      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> temp;
+      return std::make_pair(temp, temp);
+    }
+
+    template <>
+    std::pair<std::pair<double, std::pair<std::vector<double>,std::vector<double>>>, std::pair<double, std::pair<std::vector<double>,std::vector<double>>>>
+    Geoid<3>::topography_contribution(const double &outer_radius,
+                                      const double &inner_radius) const
+    {
+      // Get a pointer to the boundary densities postprocessor.
+      const Postprocess::BoundaryDensities<3> &boundary_densities =
+        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::BoundaryDensities<3>>();
+
+      const double top_layer_average_density = boundary_densities.density_at_top();
+      const double bottom_layer_average_density = boundary_densities.density_at_bottom();
+
+      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+      const types::boundary_id bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
+
+      const unsigned int quadrature_degree = this->introspection().polynomial_degree.temperature;
+      const QGauss<2> quadrature_formula_face(quadrature_degree);
+
+      FEFaceValues<3> fe_face_values (this->get_mapping(),
+                                      this->get_fe(),
+                                      quadrature_formula_face,
+                                      update_values |
+                                      update_quadrature_points |
+                                      update_JxW_values);
+
+      // Vectors to store the location, infinitesimal area, and topography associated with each quadrature point of each surface and bottom cell respectively.
+      std::vector<std::pair<Point<3>,std::pair<double,double>>> surface_stored_values;
+      std::vector<std::pair<Point<3>,std::pair<double,double>>> CMB_stored_values;
+
+      // Loop over all of the boundary cells and if one is at
+      // surface or CMB, evaluate the topography vector there.
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          {
+            unsigned int face_idx = numbers::invalid_unsigned_int;
+            bool at_upper_surface = false;
+            {
+              for (const unsigned int f : cell->face_indices())
+                {
+                  if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
+                    {
+                      // If the cell is at the top boundary, assign face_idx.
+                      face_idx = f;
+                      at_upper_surface = true;
+                      break;
+                    }
+                  else if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
+                    {
+                      // If the cell is at the bottom boundary, assign face_idx.
+                      face_idx = f;
+                      at_upper_surface = false;
+                      break;
+                    }
+                }
+              // If the cell is not at the boundary, jump to the next cell.
+              if (face_idx == numbers::invalid_unsigned_int)
+                continue;
+            }
+
+            // Focus on the boundary cell's upper face if on the top boundary and lower face if on the bottom boundary.
+            fe_face_values.reinit(cell, face_idx);
+
+            // Topography is evaluated at each quadrature
+            // point on every top/bottom cell's boundary face. The
+            // reason to do this -- as opposed to using a single
+            // value per boundary face -- is that later in the
+            // spherical harmonic expansion, we will calculate
+            // sin(theta)*d_theta*d_phi by
+            // infinitesimal_area/radius^2. The accuracy of this
+            // transfer gets better as infinitesimal_area gets
+            // closer to zero, so using every boundary quadrature
+            // point's associated area (in the form of
+            // FEFaceValues::JxW) will lead to better accuracy in
+            // spherical harmonic expansion compared to using just
+            // one average value per face, especially in the coarse
+            // meshes.
+
+            // If the cell is at the top boundary, add its contributions to the topography surface storage vector.
+            if (at_upper_surface)
+              {
+                if (include_surface_topo_contribution == true)
+                  {
+                    if (use_free_surface_topography == true)
+                      {
+                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                          {
+                            const Point<3> current_position = fe_face_values.quadrature_point(q);
+                            const double topography = this->get_geometry_model().height_above_reference_surface(current_position);
+                            surface_stored_values.emplace_back (current_position, std::make_pair(fe_face_values.JxW(q), topography));
+                          }
+                      }
+                    else
+                      {
+                        // Get a reference to the dynamic topography postprocessor.
+                        const Postprocess::DynamicTopography<3> &dynamic_topography =
+                          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<3>>();
+
+                        // Get the already-computed dynamic topography solution.
+                        const LinearAlgebra::BlockVector &topo_vector = dynamic_topography.topography_vector();
+
+                        std::vector<double> topo_values(quadrature_formula_face.size());
+
+                        fe_face_values[this->introspection().extractors.temperature].get_function_values(topo_vector, topo_values);
+
+                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                          {
+                            surface_stored_values.emplace_back (fe_face_values.quadrature_point(q), std::make_pair(fe_face_values.JxW(q), topo_values[q]));
+                          }
+                      }
+                  }
+                else
+                  {
+                    // If the cell is at the top boundary, but you do not include the surface topography in the geoid computation,
+                    // add its zero contributions to the topography surface storage vector.
+                    if (at_upper_surface)
+                      {
+                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                          {
+                            surface_stored_values.emplace_back (fe_face_values.quadrature_point(q), std::make_pair(fe_face_values.JxW(q), 0.0));
+                          }
+                      }
+                  }
+              }
+
+            // If the cell is at the bottom boundary, add its contributions to the topography CMB storage vector.
+            if (at_upper_surface == false)
+              {
+                if (include_CMB_topo_contribution == true)
+                  {
+                    if (use_free_CMB_topography == true)
+                      {
+                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                          {
+                            const Point<3> current_position = fe_face_values.quadrature_point(q);
+                            const double topography = this->get_geometry_model().height_above_reference_surface(current_position) + (outer_radius - inner_radius);
+                            CMB_stored_values.emplace_back (current_position, std::make_pair(fe_face_values.JxW(q), topography));
+                          }
+                      }
+                    else
+                      {
+                        // Get a reference to the dynamic topography postprocessor.
+                        const Postprocess::DynamicTopography<3> &dynamic_topography =
+                          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<3>>();
+
+                        // Get the already-computed dynamic topography solution.
+                        const LinearAlgebra::BlockVector &topo_vector = dynamic_topography.topography_vector();
+
+                        std::vector<double> topo_values(quadrature_formula_face.size());
+
+                        fe_face_values[this->introspection().extractors.temperature].get_function_values(topo_vector, topo_values);
+
+                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                          {
+                            CMB_stored_values.emplace_back (fe_face_values.quadrature_point(q), std::make_pair(fe_face_values.JxW(q), topo_values[q]));
+                          }
+                      }
+                  }
+                else
+                  {
+                    // If the cell is at the bottom boundary, but you do not include the CMB topography in the geoid computation,
+                    // add its zero contributions to the topography CMB storage vector.
+                    if (at_upper_surface == false)
+                      {
+                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                          {
+                            CMB_stored_values.emplace_back (fe_face_values.quadrature_point(q), std::make_pair(fe_face_values.JxW(q), 0.0));
+                          }
+                      }
+                  }
+              }
+          }
+
+      std::vector<std::vector<double>> surface_topo_spherical_function;
+      std::vector<std::vector<double>> CMB_topo_spherical_function;
+
+      for (const auto &surface_stored_value : surface_stored_values)
+        {
+          const std::array<double,3> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(surface_stored_value.first);
+
+          // Calculate spherical infinitesimal sin(theta)*d_theta*d_phi by infinitesimal_area/radius^2
+          const double infinitesimal = surface_stored_value.second.first/(outer_radius*outer_radius);
+
+          // Theta, phi, spherical infinitesimal, and surface topography
+          surface_topo_spherical_function.emplace_back(std::vector<double> {scoord[2],
+                                                                            scoord[1],
+                                                                            infinitesimal,
+                                                                            surface_stored_value.second.second
+                                                                           });
+        }
+
+      for (const auto &CMB_stored_value : CMB_stored_values)
+        {
+          const std::array<double,3> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(CMB_stored_value.first);
+
+          // Calculate spherical infinitesimal sin(theta)*d_theta*d_phi by infinitesimal_area/radius^2
+          const double infinitesimal = CMB_stored_value.second.first/(inner_radius*inner_radius);
+
+          // Theta, phi, spherical infinitesimal, and CMB dynamic topography
+          CMB_topo_spherical_function.emplace_back(std::vector<double> {scoord[2],
+                                                                        scoord[1],
+                                                                        infinitesimal,
+                                                                        CMB_stored_value.second.second
+                                                                       });
+        }
+
+      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> SH_surface_topo_coes
+        = std::make_pair(top_layer_average_density,to_spherical_harmonic_coefficients(surface_topo_spherical_function));
+      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> SH_CMB_topo_coes
+        = std::make_pair(bottom_layer_average_density,to_spherical_harmonic_coefficients(CMB_topo_spherical_function));
+      return std::make_pair(SH_surface_topo_coes,SH_CMB_topo_coes);
+    }
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    Geoid<dim>::execute (TableHandler &)
+    {
+      // Current geoid code only works for spherical shell geometry.
+      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model())
+                   &&
+                   dim == 3,
+                   ExcMessage("The geoid postprocessor is currently only implemented for the 3d spherical shell geometry model."));
+
+      const GeometryModel::SphericalShell<dim> &geometry_model =
+        Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
+
+      // Get the value of the outer radius and inner radius.
+      const double outer_radius = geometry_model.outer_radius();
+      const double inner_radius = geometry_model.inner_radius();
+
+      const types::boundary_id top_boundary_id = geometry_model.translate_symbolic_boundary_name_to_id("top");
+
+      // Get the value of the surface gravity acceleration from the gravity model.
+      Point<dim> surface_point;
+      surface_point[0] = outer_radius;
+      const double surface_gravity = this->get_gravity_model().gravity_vector(surface_point).norm();
+
+      // Get the value of the universal gravitational constant.
+      const double G = aspect::constants::big_g;
+
+      // Get the spherical harmonic coefficients of the density contribution.
+      std::pair<std::vector<double>,std::vector<double>> SH_density_coes = density_contribution(outer_radius);
+      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> SH_surface_topo_coes;
+      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> SH_CMB_topo_coes;
+
+      // Initialize the surface and CMB density contrasts with NaNs because they may be unused in case of no topography contribution.
+      double surface_delta_rho = numbers::signaling_nan<double>();
+      double CMB_delta_rho = numbers::signaling_nan<double>();
+
+      // Get the spherical harmonic coefficients of the surface and CMB topography.
+      std::pair<std::pair<double, std::pair<std::vector<double>,std::vector<double>>>, std::pair<double, std::pair<std::vector<double>,std::vector<double>>>> SH_topo_coes;
+      SH_topo_coes = topography_contribution(outer_radius,inner_radius);
+      SH_surface_topo_coes = SH_topo_coes.first;
+      SH_CMB_topo_coes = SH_topo_coes.second;
+
+      // Get the density contrast at the surface and CMB to replace the initialized NaN values.
+      // The surface and CMB density contrasts will be used later to calculate geoid,
+      // and the spherical harmonic output of the surface and CMB topography contribution to geoid.
+      surface_delta_rho =  SH_surface_topo_coes.first - density_above;
+      CMB_delta_rho = density_below - SH_CMB_topo_coes.first;
+
+      // Compute the spherical harmonic coefficients of geoid anomaly.
+      std::vector<double> density_anomaly_contribution_coecos;
+      std::vector<double> density_anomaly_contribution_coesin;
+      std::vector<double> surface_topo_contribution_coecos;
+      std::vector<double> surface_topo_contribution_coesin;
+      std::vector<double> CMB_topo_contribution_coecos;
+      std::vector<double> CMB_topo_contribution_coesin;
+      geoid_coecos.clear();
+      geoid_coesin.clear();
+
+      // First compute the spherical harmonic contributions from density anomaly, surface topography and CMB topography.
+      int ind = 0; // coefficients index
+      for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+        {
+          for (unsigned int iord = 0; iord < ideg+1; ++iord)
+            {
+              double coecos_density_anomaly = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1))) * SH_density_coes.first.at(ind);
+              double coesin_density_anomaly = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1))) * SH_density_coes.second.at(ind);
+              density_anomaly_contribution_coecos.push_back(coecos_density_anomaly);
+              density_anomaly_contribution_coesin.push_back(coesin_density_anomaly);
+
+              if (include_surface_topo_contribution == true || include_CMB_topo_contribution == true)
+                {
+                  const double coecos_surface_topo = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1)))
+                                                     * surface_delta_rho*SH_surface_topo_coes.second.first.at(ind)*outer_radius;
+                  const double coesin_surface_topo = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1)))
+                                                     * surface_delta_rho*SH_surface_topo_coes.second.second.at(ind)*outer_radius;
+                  surface_topo_contribution_coecos.push_back(coecos_surface_topo);
+                  surface_topo_contribution_coesin.push_back(coesin_surface_topo);
+
+                  const double coecos_CMB_topo = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1)))
+                                                 * CMB_delta_rho*SH_CMB_topo_coes.second.first.at(ind)*inner_radius*std::pow(inner_radius/outer_radius,ideg+1);
+                  const double coesin_CMB_topo = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1)))
+                                                 * CMB_delta_rho*SH_CMB_topo_coes.second.second.at(ind)*inner_radius*std::pow(inner_radius/outer_radius,ideg+1);
+                  CMB_topo_contribution_coecos.push_back(coecos_CMB_topo);
+                  CMB_topo_contribution_coesin.push_back(coesin_CMB_topo);
+
+                }
+
+              ++ind;
+            }
+        }
+
+      // Then sum the three contributions together to get the spherical harmonic coefficients of geoid anomaly.
+      ind = 0; // coefficients index
+      for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+        {
+          for (unsigned int iord = 0; iord < ideg+1; ++iord)
+            {
+              if (include_surface_topo_contribution == true || include_CMB_topo_contribution == true)
+                {
+                  geoid_coecos.push_back(density_anomaly_contribution_coecos.at(ind)+surface_topo_contribution_coecos.at(ind)+CMB_topo_contribution_coecos.at(ind));
+                  geoid_coesin.push_back(density_anomaly_contribution_coesin.at(ind)+surface_topo_contribution_coesin.at(ind)+CMB_topo_contribution_coesin.at(ind));
+                }
+              else
+                {
+                  geoid_coecos.push_back(density_anomaly_contribution_coecos.at(ind));
+                  geoid_coesin.push_back(density_anomaly_contribution_coesin.at(ind));
+                }
+
+              ind += 1;
+            }
+        }
+
+      const QMidpoint<dim-1> quadrature_formula_face_center;
+      Assert(quadrature_formula_face_center.size() == 1, ExcInternalError());
+      FEFaceValues<dim> fe_face_center_values (this->get_mapping(),
+                                               this->get_fe(),
+                                               quadrature_formula_face_center,
+                                               update_values |
+                                               update_quadrature_points|
+                                               update_JxW_values);
+
+      // Define a vector to store the location of the cells along the surface.
+      std::vector<Point<dim>> surface_cell_locations;
+
+      // Loop over all the cells to get the locations of the surface cells to prepare for the geoid computation.
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          {
+            // If the cell is at the top boundary, store the cell's upper face midpoint location.
+            for (const unsigned int f : cell->face_indices())
+              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
+                {
+                  fe_face_center_values.reinit(cell,f);
+                  const Point<dim> midpoint_at_top_face = fe_face_center_values.get_quadrature_points().at(0);
+                  surface_cell_locations.push_back(midpoint_at_top_face);
+                  break;
+                }
+          }
+
+      // Transfer the geocentric coordinates of the surface cells to the surface spherical coordinates (theta,phi)
+      std::vector<std::pair<double,double>> surface_cell_spherical_coordinates;
+      for (unsigned int i=0; i<surface_cell_locations.size(); ++i)
+        {
+          const std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(surface_cell_locations.at(i));
+          const double phi = scoord[1];
+          const double theta = scoord[2];
+          surface_cell_spherical_coordinates.emplace_back(theta,phi);
+        }
+
+      // Compute the grid geoid anomaly based on spherical harmonics.
+      std::vector<double> geoid_anomaly;
+      for (const auto &surface_cell_spherical_coordinate : surface_cell_spherical_coordinates)
+        {
+          int ind = 0;
+          double geoid_value = 0;
+          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+            {
+              for (unsigned int iord = 0; iord < ideg+1; ++iord)
+                {
+                  // Normalization after Dahlen and Tromp (1986) Appendix B.6.
+                  const std::pair<double,double> sph_harm_vals = aspect::Utilities::real_spherical_harmonic(ideg,iord,surface_cell_spherical_coordinate.first,surface_cell_spherical_coordinate.second);
+                  const double cos_component = sph_harm_vals.first; // real / cos part
+                  const double sin_component = sph_harm_vals.second; // imaginary / sin part
+
+                  geoid_value += geoid_coecos.at(ind)*cos_component+geoid_coesin.at(ind)*sin_component;
+                  ++ind;
+                }
+            }
+          geoid_anomaly.push_back(geoid_value);
+        }
+
+      // The user can get the spherical harmonic coefficients of the density anomaly contribution if needed
+      if (output_density_anomaly_contribution_SH_coes == true)
+        {
+          // Have a stream into which we write the SH coefficients data from density anomaly contribution.
+          // The text stream is then later sent to processor 0.
+          std::ostringstream output_density_anomaly_contribution_SH_coes;
+
+          // Prepare the output SH coefficients data from density anomaly contribution.
+          unsigned int SH_coes_ind = 0;
+          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+            {
+              for (unsigned int iord = 0; iord < ideg+1; ++iord)
+                {
+                  output_density_anomaly_contribution_SH_coes << ideg
+                                                              << ' '
+                                                              << iord
+                                                              << ' '
+                                                              << density_anomaly_contribution_coecos.at(SH_coes_ind)
+                                                              << ' '
+                                                              << density_anomaly_contribution_coesin.at(SH_coes_ind)
+                                                              << std::endl;
+                  ++SH_coes_ind;
+                }
+            }
+
+          const std::string density_anomaly_contribution_SH_coes_filename = this->get_output_directory() +
+                                                                            "density_anomaly_contribution_SH_coefficients." +
+                                                                            dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
+
+          // Because each processor already held all the SH coefficients from density anomaly contribution, we only need to stop by the processor 0 to get the data.
+          // On processor 0, collect all the data and put them into the output density anomaly contribution SH coefficients file.
+          if (dealii::Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+            {
+              std::ofstream density_anomaly_contribution_SH_coes_file (density_anomaly_contribution_SH_coes_filename);
+              density_anomaly_contribution_SH_coes_file << "# "
+                                                        << "degree order cosine_coefficient sine_coefficient"
+                                                        << std::endl;
+
+              // Write out the data on processor 0.
+              density_anomaly_contribution_SH_coes_file << output_density_anomaly_contribution_SH_coes.str();
+            }
+        }
+
+      // The user can get the spherical harmonic coefficients of the surface topography contribution if needed
+      if (output_surface_topo_contribution_SH_coes == true)
+        {
+          // Have a stream into which we write the SH coefficients data from surface topography contribution.
+          // The text stream is then later sent to processor 0.
+          std::ostringstream output_surface_topo_contribution_SH_coes;
+
+          // Prepare the output SH coefficients data from surface topography contribution.
+          unsigned int SH_coes_ind = 0;
+          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+            {
+              for (unsigned int iord = 0; iord < ideg+1; ++iord)
+                {
+                  output_surface_topo_contribution_SH_coes << ideg
+                                                           << ' '
+                                                           << iord
+                                                           << ' '
+                                                           << surface_topo_contribution_coecos.at(SH_coes_ind)
+                                                           << ' '
+                                                           << surface_topo_contribution_coesin.at(SH_coes_ind)
+                                                           << std::endl;
+                  ++SH_coes_ind;
+                }
+            }
+
+          const std::string surface_topo_contribution_SH_coes_filename = this->get_output_directory() +
+                                                                         "surface_topography_contribution_SH_coefficients." +
+                                                                         dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
+
+          // Because each processor already held all the SH coefficients from surface topography contribution,
+          // we only need to stop by the processor 0 to get the data. On processor 0, collect all the data
+          // and put them into the output surface topography contribution SH coefficients file.
+          if (dealii::Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+            {
+              std::ofstream surface_topo_contribution_SH_coes_file (surface_topo_contribution_SH_coes_filename);
+              surface_topo_contribution_SH_coes_file << "# "
+                                                     << "degree order cosine_coefficient sine_coefficient"
+                                                     << std::endl;
+              std::ostringstream output_surface_delta_rho;
+              output_surface_delta_rho << surface_delta_rho;
+              surface_topo_contribution_SH_coes_file << "surface density contrast(kg/m^3): "
+                                                     << output_surface_delta_rho.str()
+                                                     << std::endl;
+              // Write out the data on processor 0
+              surface_topo_contribution_SH_coes_file << output_surface_topo_contribution_SH_coes.str();
+            }
+        }
+
+      // The user can get the spherical harmonic coefficients of the CMB topography contribution if needed.
+      if (output_CMB_topo_contribution_SH_coes == true)
+        {
+          // Have a stream into which we write the SH coefficients data from CMB topography contribution.
+          // The text stream is then later sent to processor 0.
+          std::ostringstream output_CMB_topo_contribution_SH_coes;
+
+          // Prepare the output SH coefficients data from CMB topography contribution.
+          unsigned int SH_coes_ind = 0;
+          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+            {
+              for (unsigned int iord = 0; iord < ideg+1; ++iord)
+                {
+                  output_CMB_topo_contribution_SH_coes << ideg
+                                                       << ' '
+                                                       << iord
+                                                       << ' '
+                                                       << CMB_topo_contribution_coecos.at(SH_coes_ind)
+                                                       << ' '
+                                                       << CMB_topo_contribution_coesin.at(SH_coes_ind)
+                                                       << std::endl;
+                  ++SH_coes_ind;
+                }
+            }
+
+          const std::string CMB_topo_contribution_SH_coes_filename = this->get_output_directory() +
+                                                                     "CMB_topography_contribution_SH_coefficients." +
+                                                                     dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
+
+          // Because each processor already held all the SH coefficients from CMB topography contribution, we only need to stop by the processor 0
+          // to get the data. On processor 0, collect all the data and put them into the output CMB topography contribution SH coefficients file.
+          if (dealii::Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+            {
+              std::ofstream CMB_topo_contribution_SH_coes_file (CMB_topo_contribution_SH_coes_filename);
+              CMB_topo_contribution_SH_coes_file << "# "
+                                                 << "degree order cosine_coefficient sine_coefficient"
+                                                 << std::endl;
+              std::ostringstream output_CMB_delta_rho;
+              output_CMB_delta_rho << CMB_delta_rho;
+              CMB_topo_contribution_SH_coes_file << "CMB density contrast(kg/m^3): "
+                                                 << output_CMB_delta_rho.str()
+                                                 << std::endl;
+              // Write out the data on processor 0
+              CMB_topo_contribution_SH_coes_file << output_CMB_topo_contribution_SH_coes.str();
+            }
+        }
+
+      // The user can get the spherical harmonic coefficients of the geoid anomaly if needed.
+      if (output_geoid_anomaly_SH_coes == true)
+        {
+          // Have a stream into which we write the geoid anomaly SH coefficients data.
+          // The text stream is then later sent to processor 0.
+          std::ostringstream output_geoid_anomaly_SH_coes;
+
+          // Prepare the output geoid anomaly SH coefficients data.
+          unsigned int SH_coes_ind = 0;
+          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+            {
+              for (unsigned int iord = 0; iord < ideg+1; ++iord)
+                {
+                  output_geoid_anomaly_SH_coes << ideg
+                                               << ' '
+                                               << iord
+                                               << ' '
+                                               << geoid_coecos.at(SH_coes_ind)
+                                               << ' '
+                                               << geoid_coesin.at(SH_coes_ind)
+                                               << std::endl;
+                  ++SH_coes_ind;
+                }
+            }
+
+          const std::string geoid_anomaly_SH_coes_filename = this->get_output_directory() +
+                                                             "geoid_anomaly_SH_coefficients." +
+                                                             dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
+
+          // Because each processor already held all the geoid anomaly SH coefficients, we only need to stop by the processor 0 to get the data.
+          // On processor 0, collect all the data and put them into the output geoid anomaly SH coefficients file.
+          if (dealii::Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+            {
+              std::ofstream geoid_anomaly_SH_coes_file (geoid_anomaly_SH_coes_filename);
+              geoid_anomaly_SH_coes_file << "# "
+                                         << "degree order cosine_coefficient sine_coefficient"
+                                         << std::endl;
+
+              // Write out the data on processor 0.
+              geoid_anomaly_SH_coes_file << output_geoid_anomaly_SH_coes.str();
+            }
+        }
+
+      // Have a stream into which we write the geoid height data. the text stream is then
+      // later sent to processor 0.
+      std::ostringstream output;
+
+      // On processor 0, write the header lines
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          output << "# "
+                 << ((output_in_lat_lon == true)? "longitude latitude" : "x y z")
+                 << " geoid_anomaly" << std::endl;
+        }
+
+      // Prepare the output data.
+      if (output_in_lat_lon == true)
+        {
+          double lon, lat;
+          for (unsigned int i=0; i<surface_cell_spherical_coordinates.size(); ++i)
+            {
+              // Transfer the spherical coordinates to geographical coordinates.
+              lat = 90. - surface_cell_spherical_coordinates.at(i).first * constants::radians_to_degree;
+              lon = (surface_cell_spherical_coordinates.at(i).second <= numbers::PI
+                     ?
+                     surface_cell_spherical_coordinates.at(i).second * constants::radians_to_degree
+                     :
+                     surface_cell_spherical_coordinates.at(i).second * constants::radians_to_degree - 360.);
+
+              // Write the solution to the stream output.
+              output << lon
+                     << ' '
+                     << lat
+                     << ' '
+                     << geoid_anomaly.at(i)
+                     << std::endl;
+            }
+        }
+      else
+        {
+          for (unsigned int i=0; i<surface_cell_locations.size(); ++i)
+            {
+              // Write the solution to the stream output.
+              output << surface_cell_locations.at(i)
+                     << ' '
+                     << geoid_anomaly.at(i)
+                     << std::endl;
+            }
+        }
+
+      const std::string filename = this->get_output_directory() +
+                                   "geoid_anomaly." +
+                                   dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
+
+      Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
+
+      // Prepare the free-air gravity anomaly output.
+      if (output_gravity_anomaly == true)
+        {
+          // Have a stream into which we write the gravity anomaly data. the text stream is then
+          // later sent to processor 0.
+          std::ostringstream output_gravity_anomaly;
+
+          // On processor 0, write the header lines:
+          if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+            {
+              output_gravity_anomaly << "# "
+                                     << ((output_in_lat_lon == true)? "longitude latitude" : "x y z")
+                                     << " gravity_anomaly" << std::endl;
+            }
+
+          // Compute the grid gravity anomaly based on spherical harmonics.
+          std::vector<double> gravity_anomaly;
+          gravity_anomaly.reserve(surface_cell_spherical_coordinates.size());
+
+          for (const auto &surface_cell_spherical_coordinate : surface_cell_spherical_coordinates)
+            {
+              int ind = 0;
+              double gravity_value = 0;
+              for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
+                {
+                  for (unsigned int iord = 0; iord < ideg+1; ++iord)
+                    {
+                      // Normalization after Dahlen and Tromp (1986) Appendix B.6.
+                      const std::pair<double,double> sph_harm_vals = aspect::Utilities::real_spherical_harmonic(ideg,iord,surface_cell_spherical_coordinate.first,surface_cell_spherical_coordinate.second);
+                      const double cos_component = sph_harm_vals.first; // real / cos part
+                      const double sin_component = sph_harm_vals.second; // imaginary / sin part
+
+                      // The conversion from geoid to gravity anomaly is given by gravity_anomaly = (l-1)*g/R_surface * geoid_anomaly
+                      // based on Forte (2007) equation [97].
+                      gravity_value += (geoid_coecos.at(ind)*cos_component+geoid_coesin.at(ind)*sin_component) * (ideg - 1) * surface_gravity / outer_radius;
+                      ++ind;
+                    }
+                }
+              gravity_anomaly.push_back(gravity_value);
+            }
+
+          // Prepare the output data.
+          if (output_in_lat_lon == true)
+            {
+              double lon, lat;
+              for (unsigned int i=0; i<surface_cell_spherical_coordinates.size(); ++i)
+                {
+                  // Transfer the spherical coordinates to geographical coordinates.
+                  lat = 90. - surface_cell_spherical_coordinates.at(i).first * constants::radians_to_degree;
+                  lon = (surface_cell_spherical_coordinates.at(i).second <= numbers::PI
+                         ?
+                         surface_cell_spherical_coordinates.at(i).second * constants::radians_to_degree
+                         :
+                         surface_cell_spherical_coordinates.at(i).second * constants::radians_to_degree - 360.);
+
+                  // Write the solution to the stream output.
+                  output_gravity_anomaly << lon
+                                         << ' '
+                                         << lat
+                                         << ' '
+                                         << gravity_anomaly.at(i)
+                                         << std::endl;
+                }
+            }
+          else
+            {
+              for (unsigned int i=0; i<surface_cell_locations.size(); ++i)
+                {
+                  // Write the solution to the stream output.
+                  output_gravity_anomaly << surface_cell_locations.at(i)
+                                         << ' '
+                                         << gravity_anomaly.at(i)
+                                         << std::endl;
+                }
+            }
+
+          const std::string filename = this->get_output_directory() +
+                                       "gravity_anomaly." +
+                                       dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
+
+          Utilities::collect_and_write_file_content(filename, output_gravity_anomaly.str(), this->get_mpi_communicator());
+        }
+
+      return std::pair<std::string,std::string>("Writing geoid anomaly:",
+                                                filename);
+    }
+
+    template <int dim>
+    std::list<std::string>
+    Geoid<dim>::required_other_postprocessors() const
+    {
+      std::list<std::string> deps;
+
+      if ( (include_surface_topo_contribution == true && use_free_surface_topography == false) || (include_CMB_topo_contribution == true && use_free_CMB_topography == false) )
+        deps.emplace_back("dynamic topography");
+
+      deps.emplace_back("boundary densities");
+
+      return deps;
+    }
+
+    template <int dim>
+    double
+    Geoid<dim>::evaluate (const Point<dim> &/*p*/) const
+    {
+      Assert(false, ExcNotImplemented());
+      return 0;
+    }
+
+    template <>
+    double
+    Geoid<3>::evaluate (const Point<3> &p) const
+    {
+      const std::array<double,3> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(p);
+      const double theta = scoord[2];
+      const double phi = scoord[1];
+      double value = 0.;
+
+      for (unsigned int ideg=min_degree, k=0; ideg < max_degree+1; ++ideg)
+        for (unsigned int iord = 0; iord < ideg+1; ++iord, ++k)
+          {
+            std::pair<double,double> val = aspect::Utilities::real_spherical_harmonic( ideg, iord, theta, phi );
+
+            value += geoid_coecos[k] * val.first +
+                     geoid_coesin[k] * val.second;
+
+          }
+      return value;
+    }
+
+    template <int dim>
+    void
+    Geoid<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Geoid");
+        {
+          prm.declare_entry("Include surface topography contribution", "true",
+                            Patterns::Bool(),
+                            "Option to include the contribution from surface topography on geoid. The default is true.");
+          prm.declare_entry("Include CMB topography contribution", "true",
+                            Patterns::Bool(),
+                            "Option to include the contribution from CMB topography on geoid. The default is true.");
+          prm.declare_entry("Maximum degree","20",
+                            Patterns::Integer (0),
+                            "This parameter can be a random positive integer. However, the value normally should not exceed the maximum "
+                            "degree of the initial perturbed temperature field. For example, if the initial temperature uses S40RTS, the "
+                            "maximum degree should not be larger than 40.");
+          prm.declare_entry("Minimum degree","2",
+                            Patterns::Integer (0),
+                            "This parameter normally is set to 2 since the perturbed gravitational potential at degree 1 always vanishes "
+                            "in a reference frame with the planetary center of mass same as the center of figure.");
+          prm.declare_entry("Output data in geographical coordinates", "false",
+                            Patterns::Bool(),
+                            "Option to output the geoid anomaly in geographical coordinates (latitude and longitude). "
+                            "The default is false, so the postprocessor will output the data in geocentric coordinates (x,y,z) as normally.");
+          prm.declare_entry("Density above","0.",
+                            Patterns::Double (0.),
+                            "The density value above the surface boundary.");
+          prm.declare_entry("Density below","9900.",
+                            Patterns::Double (0.),
+                            "The density value below the CMB boundary.");
+          prm.declare_entry("Output geoid anomaly coefficients", "false",
+                            Patterns::Bool(),
+                            "Option to output the spherical harmonic coefficients of the geoid anomaly up to the maximum degree. "
+                            "The default is false, so the postprocessor will only output the geoid anomaly in grid format. ");
+          prm.declare_entry("Output surface topography contribution coefficients", "false",
+                            Patterns::Bool(),
+                            "Option to output the spherical harmonic coefficients of the surface topography contribution "
+                            "to the maximum degree. The default is false. ");
+          prm.declare_entry("Output CMB topography contribution coefficients", "false",
+                            Patterns::Bool(),
+                            "Option to output the spherical harmonic coefficients of the CMB topography contribution "
+                            "to the maximum degree. The default is false. ");
+          prm.declare_entry("Output density anomaly contribution coefficients", "false",
+                            Patterns::Bool(),
+                            "Option to output the spherical harmonic coefficients of the density anomaly contribution to the "
+                            "maximum degree. The default is false. ");
+          prm.declare_entry("Output gravity anomaly", "false",
+                            Patterns::Bool(),
+                            "Option to output the free-air gravity anomaly up to the maximum degree. "
+                            "The unit of the output is in SI, hence $m/s^2$ ($1mgal = 10^-5 m/s^2$). The default is false. ");
+
+          prm.declare_alias("Output geoid anomaly coefficients","Also output the spherical harmonic coefficients of geoid anomaly");
+          prm.declare_alias("Output surface topography contribution coefficients","Also output the spherical harmonic coefficients of surface dynamic topography contribution");
+          prm.declare_alias("Output CMB topography contribution coefficients","Also output the spherical harmonic coefficients of CMB dynamic topography contribution");
+          prm.declare_alias("Output density anomaly contribution coefficients","Also output the spherical harmonic coefficients of density anomaly contribution");
+          prm.declare_alias("Output gravity anomaly","Also output the gravity anomaly");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+    template <int dim>
+    void
+    Geoid<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      CitationInfo::add("geoid");
+
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Geoid");
+        {
+          include_surface_topo_contribution = prm.get_bool ("Include surface topography contribution");
+          include_CMB_topo_contribution = prm.get_bool ("Include CMB topography contribution");
+          max_degree = prm.get_integer ("Maximum degree");
+          min_degree = prm.get_integer ("Minimum degree");
+          output_in_lat_lon = prm.get_bool ("Output data in geographical coordinates");
+          density_above = prm.get_double ("Density above");
+          density_below = prm.get_double ("Density below");
+          output_geoid_anomaly_SH_coes = prm.get_bool ("Output geoid anomaly coefficients");
+          output_surface_topo_contribution_SH_coes = prm.get_bool ("Output surface topography contribution coefficients");
+          output_CMB_topo_contribution_SH_coes = prm.get_bool ("Output CMB topography contribution coefficients");
+          output_density_anomaly_contribution_SH_coes = prm.get_bool ("Output density anomaly contribution coefficients");
+          output_gravity_anomaly = prm.get_bool ("Output gravity anomaly");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+    template <int dim>
+    void
+    Geoid<dim>::initialize ()
+    {
+      // Find if the included boundaries are active free surfaces
+      if (include_surface_topo_contribution == true || include_CMB_topo_contribution == true)
+        {
+          if (this->get_parameters().mesh_deformation_enabled == true)
+            {
+              const  types::boundary_id surface_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+              const  types::boundary_id bottom_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
+
+              const std::set<types::boundary_id> mesh_deformation_boundaries = this->get_mesh_deformation_handler().get_active_mesh_deformation_boundary_indicators();
+
+              use_free_surface_topography = mesh_deformation_boundaries.find(surface_id) != mesh_deformation_boundaries.end();
+              use_free_CMB_topography = mesh_deformation_boundaries.find(bottom_id) != mesh_deformation_boundaries.end();
+            }
+        }
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(Geoid,
+                                  "geoid",
+                                  "A postprocessor that computes a representation of "
+                                  "the geoid based on the density structure in the mantle, "
+                                  "as well as the topography at the surface and "
+                                  "core mantle boundary (CMB) if desired. The topography is based on the "
+                                  "dynamic topography postprocessor in case of no free surface, "
+                                  "and based on the real surface from the geometry model in case "
+                                  "of a free surface. The geoid is computed "
+                                  "from a spherical harmonic expansion, so the geometry "
+                                  "of the domain must be a 3d spherical shell.")
+  }
+}
diff --git a/source/postprocess/global_statistics.cc.bak b/source/postprocess/global_statistics.cc.bak
new file mode 100644
index 00000000000..aae8dd2e811
--- /dev/null
+++ b/source/postprocess/global_statistics.cc.bak
@@ -0,0 +1,324 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/global_statistics.h>
+#include <aspect/simulator.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    void
+    GlobalStatistics<dim>::initialize()
+    {
+      this->get_signals().post_stokes_solver.connect(
+        [&](const SimulatorAccess<dim> &/*simulator_access*/,
+            const unsigned int number_S_iterations,
+            const unsigned int number_A_iterations,
+            const SolverControl &solver_control_cheap,
+            const SolverControl &solver_control_expensive)
+      {
+        this->store_stokes_solver_history(number_S_iterations,
+                                          number_A_iterations,
+                                          solver_control_cheap,
+                                          solver_control_expensive);
+      });
+
+      this->get_signals().post_advection_solver.connect(
+        [&](const SimulatorAccess<dim> &/*simulator_access*/,
+            const bool solved_temperature_field,
+            const unsigned int compositional_index,
+            const SolverControl &solver_control)
+      {
+        this->store_advection_solver_history(solved_temperature_field,
+                                             compositional_index,
+                                             solver_control);
+      });
+
+      // delete the data after the initial refinement steps, to not mix it up
+      // with the first time step
+      if (!this->get_parameters().run_postprocessors_on_initial_refinement)
+        this->get_signals().post_set_initial_state.connect(
+          [&] (const SimulatorAccess<dim> &)
+        {
+          this->clear_data();
+        });
+    }
+
+
+
+    template <int dim>
+    void
+    GlobalStatistics<dim>::clear_data()
+    {
+      list_of_S_iterations.clear();
+      list_of_A_iterations.clear();
+      stokes_iterations_cheap.clear();
+      stokes_iterations_expensive.clear();
+      advection_iterations.clear();
+    }
+
+
+
+    template <int dim>
+    void
+    GlobalStatistics<dim>::store_stokes_solver_history(const unsigned int number_S_iterations,
+                                                       const unsigned int number_A_iterations,
+                                                       const SolverControl &solver_control_cheap,
+                                                       const SolverControl &solver_control_expensive)
+    {
+      list_of_S_iterations.push_back(number_S_iterations);
+      list_of_A_iterations.push_back(number_A_iterations);
+      stokes_iterations_cheap.push_back(solver_control_cheap.last_step());
+      stokes_iterations_expensive.push_back(solver_control_expensive.last_step());
+    }
+
+
+
+    template <int dim>
+    void
+    GlobalStatistics<dim>::store_advection_solver_history(const bool solved_temperature_field,
+                                                          const unsigned int compositional_index,
+                                                          const SolverControl &solver_control)
+    {
+      const std::string column_name = (solved_temperature_field) ?
+                                      "Iterations for temperature solver"
+                                      :
+                                      "Iterations for composition solver " + Utilities::int_to_string(compositional_index+1);
+
+      unsigned int column_position = numbers::invalid_unsigned_int;
+
+      for (unsigned int i=0; i<advection_iterations.size(); ++i)
+        if (column_name == advection_iterations[i].first)
+          column_position = i;
+
+      if (column_position == numbers::invalid_unsigned_int)
+        advection_iterations.emplace_back(column_name,std::vector<unsigned int>(1,solver_control.last_step()));
+      else
+        advection_iterations[column_position].second.push_back(solver_control.last_step());
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    GlobalStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // We would like to know how many nonlinear iterations were performed since
+      // the last call to execute(). Unfortunately some solver schemes iterate only the
+      // Stokes equation, some Stokes and advection, and some do not even call the
+      // Stokes or advection solver. Therefore, the best estimate for the number
+      // of nonlinear iterations since the last call is the maximum size of the
+      // vectors in which we store our data.
+      unsigned int nonlinear_iterations = stokes_iterations_cheap.size();
+
+      for (const auto &advection_iteration : advection_iterations)
+        nonlinear_iterations = std::max(nonlinear_iterations, static_cast<unsigned int> (advection_iteration.second.size()));
+
+      if (one_line_per_iteration)
+        for (unsigned int iteration = 0; iteration < nonlinear_iterations; ++iteration)
+          {
+            generate_global_statistics(statistics);
+
+            statistics.add_value("Nonlinear iteration number",
+                                 iteration);
+
+            for (const auto &advection_iteration : advection_iterations)
+              if (iteration < advection_iteration.second.size())
+                statistics.add_value(advection_iteration.first,
+                                     advection_iteration.second[iteration]);
+
+            if (iteration < stokes_iterations_cheap.size())
+              {
+                statistics.add_value("Iterations for Stokes solver",
+                                     stokes_iterations_cheap[iteration] + stokes_iterations_expensive[iteration]);
+                statistics.add_value("Velocity iterations in Stokes preconditioner",
+                                     list_of_A_iterations[iteration]);
+                statistics.add_value("Schur complement iterations in Stokes preconditioner",
+                                     list_of_S_iterations[iteration]);
+              }
+
+          }
+      else
+        {
+          generate_global_statistics(statistics);
+
+          unsigned int A_iterations = 0;
+          unsigned int S_iterations = 0;
+          unsigned int Stokes_outer_iterations = 0;
+          std::vector<unsigned int> advection_outer_iterations(advection_iterations.size(),0);
+
+          for (unsigned int iteration = 0; iteration < nonlinear_iterations; ++iteration)
+            {
+              for (unsigned int column=0; column<advection_iterations.size(); ++column)
+                if (iteration < advection_iterations[column].second.size())
+                  advection_outer_iterations[column] += advection_iterations[column].second[iteration];
+
+              if (iteration < stokes_iterations_cheap.size())
+                {
+                  A_iterations += list_of_A_iterations[iteration];
+                  S_iterations += list_of_S_iterations[iteration];
+                  Stokes_outer_iterations += stokes_iterations_cheap[iteration] +
+                                             stokes_iterations_expensive[iteration];
+                }
+            }
+
+          // only output the number of nonlinear iterations if we actually
+          // use a nonlinear solver scheme
+          if (!(this->get_parameters().nonlinear_solver == Parameters<dim>::NonlinearSolver::single_Advection_single_Stokes
+                || this->get_parameters().nonlinear_solver == Parameters<dim>::NonlinearSolver::single_Advection_no_Stokes))
+            statistics.add_value("Number of nonlinear iterations",
+                                 nonlinear_iterations);
+
+          // Only output statistics columns if the solver actually signaled at least one
+          // successful solve. Some solver schemes might need no advection or Stokes solver
+          for (unsigned int column=0; column<advection_iterations.size(); ++column)
+            statistics.add_value(advection_iterations[column].first,
+                                 advection_outer_iterations[column]);
+
+          // Note that even if no cheap solver iterations were done, the solver control
+          // object is still stored, so this line works in that case as well.
+          if (stokes_iterations_cheap.size() > 0)
+            {
+              statistics.add_value("Iterations for Stokes solver",
+                                   Stokes_outer_iterations);
+              statistics.add_value("Velocity iterations in Stokes preconditioner",
+                                   A_iterations);
+              statistics.add_value("Schur complement iterations in Stokes preconditioner",
+                                   S_iterations);
+            }
+        }
+
+      clear_data();
+
+      return std::make_pair (std::string(),std::string());
+    }
+
+
+
+    template <int dim>
+    void
+    GlobalStatistics<dim>::generate_global_statistics(TableHandler &statistics)
+    {
+      // set global statistics about this time step
+      statistics.add_value("Time step number", this->get_timestep_number());
+
+      if (this->convert_output_to_years() == true)
+        {
+          statistics.add_value("Time (years)", this->get_time() / year_in_seconds);
+          statistics.set_precision("Time (years)", 12);
+          statistics.set_scientific("Time (years)", true);
+
+          statistics.add_value("Time step size (years)", this->get_timestep() / year_in_seconds);
+          statistics.set_precision("Time step size (years)", 12);
+          statistics.set_scientific("Time step size (years)", true);
+        }
+      else
+        {
+          statistics.add_value("Time (seconds)", this->get_time());
+          statistics.set_precision("Time (seconds)", 12);
+          statistics.set_scientific("Time (seconds)", true);
+
+          statistics.add_value("Time step size (seconds)", this->get_timestep());
+          statistics.set_precision("Time step size (seconds)", 12);
+          statistics.set_scientific("Time step size (seconds)", true);
+        }
+
+      // set global statistics about the mesh and problem size
+      statistics.add_value("Number of mesh cells",
+                           this->get_triangulation().n_global_active_cells());
+
+      types::global_dof_index n_stokes_dofs = this->introspection().system_dofs_per_block[0];
+      if (this->introspection().block_indices.velocities != this->introspection().block_indices.pressure)
+        n_stokes_dofs += this->introspection().system_dofs_per_block[this->introspection().block_indices.pressure];
+
+      statistics.add_value("Number of Stokes degrees of freedom", n_stokes_dofs);
+      statistics.add_value("Number of temperature degrees of freedom",
+                           this->introspection().system_dofs_per_block[this->introspection().block_indices.temperature]);
+      if (this->n_compositional_fields() > 0)
+        statistics.add_value("Number of degrees of freedom for all compositions",
+                             static_cast<types::global_dof_index>(this->n_compositional_fields())
+                             * this->introspection().system_dofs_per_block[this->introspection().block_indices.compositional_fields[0]]);
+    }
+
+
+
+    template <int dim>
+    void
+    GlobalStatistics<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Global statistics");
+        {
+          prm.declare_entry ("Write statistics for each nonlinear iteration", "false",
+                             Patterns::Bool (),
+                             "Whether to put every nonlinear iteration into a separate "
+                             "line in the statistics file (if true), or to output only "
+                             "one line per time step that contains the total number of "
+                             "iterations of the Stokes and advection linear system solver.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    GlobalStatistics<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Global statistics");
+        {
+          one_line_per_iteration = prm.get_bool("Write statistics for each nonlinear iteration");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(GlobalStatistics,
+                                  "global statistics",
+                                  "A postprocessor that outputs all the global statistics "
+                                  "information, e.g. the time of the simulation, the timestep "
+                                  "number, number of degrees of freedom and solver iterations "
+                                  "for each timestep. The postprocessor can output different "
+                                  "formats, the first printing one line in the statistics file "
+                                  "per nonlinear solver iteration (if a nonlinear solver scheme "
+                                  "is selected). The second prints one line per timestep, "
+                                  "summing the information about all nonlinear iterations in "
+                                  "this line. Note that this postprocessor is always active "
+                                  "independent on whether or not it is selected in the "
+                                  "parameter file.")
+  }
+}
diff --git a/source/postprocess/gravity_point_values.cc.bak b/source/postprocess/gravity_point_values.cc.bak
new file mode 100644
index 00000000000..4371292ea51
--- /dev/null
+++ b/source/postprocess/gravity_point_values.cc.bak
@@ -0,0 +1,850 @@
+/*
+  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/postprocess/gravity_point_values.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/termination_criteria/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/mpi.templates.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/lexical_cast.hpp>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    template <int dim>
+    GravityPointValues<dim>::GravityPointValues ()
+      :
+      // the following value is later read from the input file
+      output_interval (0),
+      // initialize this to a nonsensical value; set it to the actual time
+      // the first time around we get to check it
+      last_output_time (std::numeric_limits<double>::quiet_NaN()),
+      maximum_timesteps_between_outputs (std::numeric_limits<int>::max()),
+      last_output_timestep (numbers::invalid_unsigned_int),
+      output_file_number (numbers::invalid_unsigned_int)
+    {}
+
+
+
+    template <int dim>
+    void
+    GravityPointValues<dim>::initialize ()
+    {
+      // Get the value of the outer radius and inner radius:
+      if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()))
+        {
+          model_outer_radius = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
+                               (this->get_geometry_model()).outer_radius();
+          model_inner_radius = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
+                               (this->get_geometry_model()).inner_radius();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
+        {
+          model_outer_radius = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
+                               (this->get_geometry_model()).outer_radius();
+          model_inner_radius = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
+                               (this->get_geometry_model()).inner_radius();
+        }
+      else if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()))
+        {
+          model_outer_radius = Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>>
+                               (this->get_geometry_model()).radius();
+          model_inner_radius = 0;
+        }
+      else
+        {
+          model_outer_radius = 1;
+          model_inner_radius = 0;
+        }
+
+
+      // *** First calculate the number of satellites according to the sampling scheme:
+      unsigned int n_satellites;
+      if (sampling_scheme == fibonacci_spiral)
+        n_satellites = n_points_spiral * n_points_radius;
+      else if (sampling_scheme == map)
+        n_satellites = n_points_radius * n_points_longitude * n_points_latitude;
+      else if (sampling_scheme == list_of_points)
+        n_satellites = longitude_list.size();
+      else n_satellites = 1;
+
+      // *** Second assign the coordinates of all satellites:
+      satellite_positions_spherical.resize(n_satellites);
+      if (sampling_scheme == map)
+        {
+          unsigned int p = 0;
+          for (unsigned int h=0; h < n_points_radius; ++h)
+            {
+              for (unsigned int i=0; i < n_points_longitude; ++i)
+                {
+                  for (unsigned int j=0; j < n_points_latitude; ++j)
+                    {
+                      if (n_points_radius > 1)
+                        satellite_positions_spherical[p][0] = minimum_radius + ((maximum_radius - minimum_radius) / (n_points_radius - 1)) * h;
+                      else
+                        satellite_positions_spherical[p][0] = minimum_radius;
+                      if (n_points_longitude > 1)
+                        satellite_positions_spherical[p][1] = (minimum_colongitude + ((maximum_colongitude - minimum_colongitude) /
+                                                                                      (n_points_longitude - 1)) * i) * constants::degree_to_radians;
+                      else
+                        satellite_positions_spherical[p][1] = minimum_colongitude * constants::degree_to_radians;
+                      if (n_points_latitude > 1)
+                        satellite_positions_spherical[p][2] = (minimum_colatitude + ((maximum_colatitude - minimum_colatitude) /
+                                                                                     (n_points_latitude - 1)) * j) * constants::degree_to_radians;
+                      else
+                        satellite_positions_spherical[p][2] = minimum_colatitude * constants::degree_to_radians;
+                      ++p;
+                    }
+                }
+            }
+        }
+      if (sampling_scheme == fibonacci_spiral)
+        {
+          const double golden_ratio = (1. + std::sqrt(5.))/2.;
+          const double golden_angle = 2. * numbers::PI * (1. - 1./golden_ratio);
+          unsigned int p = 0;
+          for (unsigned int h=0; h < n_points_radius; ++h)
+            {
+              for (unsigned int s=0; s < n_points_spiral; ++s)
+                {
+                  if (n_points_radius > 1)
+                    satellite_positions_spherical[p][0] = minimum_radius + ((maximum_radius - minimum_radius) / (n_points_radius - 1)) * h;
+                  else
+                    satellite_positions_spherical[p][0] = minimum_radius;
+                  satellite_positions_spherical[p][2] = std::acos(1. - 2. * s / (n_points_spiral - 1.));
+                  satellite_positions_spherical[p][1] = std::fmod((s*golden_angle), 2.*numbers::PI);
+                  ++p;
+                }
+            }
+        }
+      if (sampling_scheme == list_of_points)
+        {
+          for (unsigned int p=0; p < n_satellites; ++p)
+            {
+              if (radius_list.size() == 1)
+                satellite_positions_spherical[p][0] = radius_list[0];
+              else
+                satellite_positions_spherical[p][0] = radius_list[p];
+              if (longitude_list[p] < 0)
+                satellite_positions_spherical[p][1] = (360 + longitude_list[p]) * constants::degree_to_radians;
+              else
+                satellite_positions_spherical[p][1] = (longitude_list[p]) * constants::degree_to_radians;
+              satellite_positions_spherical[p][2] = (90 - latitude_list[p]) * constants::degree_to_radians;
+            }
+        }
+
+      // The spherical coordinates are shifted into cartesian to allow simplification
+      // in the mathematical equation.
+      satellite_positions_cartesian.resize (n_satellites);
+      for (unsigned int p=0; p<n_satellites; ++p)
+        satellite_positions_cartesian[p]
+          = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(satellite_positions_spherical[p]);
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    GravityPointValues<dim>::execute (TableHandler &)
+    {
+      AssertThrow(false, ExcNotImplemented());
+      return {"", ""};
+    }
+
+
+
+    template <>
+    std::pair<std::string,std::string>
+    GravityPointValues<3>::execute (TableHandler &statistics)
+    {
+      const int dim = 3;
+
+      // Check time to see if we output gravity
+      if (std::isnan(last_output_time))
+        {
+          last_output_time = this->get_time() - output_interval;
+          last_output_timestep = this->get_timestep_number();
+        }
+      if ((this->get_time() < last_output_time + output_interval)
+          && (this->get_timestep_number() < last_output_timestep + maximum_timesteps_between_outputs)
+          && (this->get_timestep_number() != 0))
+        return {};
+
+      // Up the counter of the number of the file by one, but not in
+      // the very first output step. if we run postprocessors on all
+      // iterations, only increase file number in the first nonlinear iteration
+      const bool increase_file_number = (this->get_nonlinear_iteration() == 0) ||
+                                        (!this->get_parameters().run_postprocessors_on_nonlinear_iterations);
+      if (output_file_number == numbers::invalid_unsigned_int)
+        output_file_number = 0;
+      else if (increase_file_number)
+        ++output_file_number;
+
+      const std::string file_prefix = "gravity-" + Utilities::int_to_string (output_file_number, 5);
+      const std::string filename = (this->get_output_directory()
+                                    + "output_gravity/"
+                                    + file_prefix);
+
+      // Get quadrature formula and increase the degree of quadrature over the velocity
+      // element degree.
+      const unsigned int degree = this->get_fe().base_element(this->introspection()
+                                                              .base_elements.velocities).degree
+                                  + quadrature_degree_increase;
+      const QGauss<dim> quadrature_formula (degree);
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_gradients |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+
+      // Get the value of the universal gravitational constant:
+      const double G = aspect::constants::big_g;
+
+      const unsigned int n_quadrature_points_per_cell = quadrature_formula.size();
+
+      const unsigned int n_satellites = satellite_positions_spherical.size();
+
+
+      // This is the main loop which computes gravity acceleration, potential and
+      // gradients at a point located at the spherical coordinate [r, phi, theta].
+      // This loop corresponds to the 3 integrals of Newton law:
+      std::vector<double>                 local_g_potential (n_satellites);
+      std::vector<Tensor<1,dim>>          local_g (n_satellites);
+      std::vector<Tensor<1,dim>>          local_g_anomaly (n_satellites);
+      std::vector<SymmetricTensor<2,dim>> local_g_gradient (n_satellites);
+
+      std::vector<double> G_times_density_times_JxW (n_quadrature_points_per_cell);
+      std::vector<double> G_times_density_anomaly_times_JxW (n_quadrature_points_per_cell);
+
+      MaterialModel::MaterialModelInputs<dim> in(quadrature_formula.size(),
+                                                 this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(quadrature_formula.size(),
+                                                   this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::density;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            // Evaluate the solution at the quadrature points of this cell
+            fe_values.reinit (cell);
+
+            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+            this->get_material_model().evaluate(in, out);
+
+            // Pull some computations that are independent of the
+            // satellite position out of the following loop. This is
+            // because we may have a very large number of satellites,
+            // so even just one multiplication that is unnecessarily
+            // repeated can be expensive.
+            for (unsigned int q = 0; q < n_quadrature_points_per_cell; ++q)
+              {
+                G_times_density_times_JxW[q]         = G * out.densities[q] *
+                                                       fe_values.JxW(q);
+                G_times_density_anomaly_times_JxW[q] = G * (out.densities[q]-reference_density) *
+                                                       fe_values.JxW(q);
+              }
+
+
+            for (unsigned int p=0; p < n_satellites; ++p)
+              {
+                const Point<dim> satellite_position = satellite_positions_cartesian[p];
+
+                for (unsigned int q = 0; q < n_quadrature_points_per_cell; ++q)
+                  {
+                    const Tensor<1,dim> r_vector = satellite_position - fe_values.quadrature_point(q);
+
+                    const double r_squared = r_vector.norm_square();
+                    const double r = std::sqrt(r_squared);
+                    const double r_cubed = r * r_squared;
+                    const double one_over_r_cubed = 1. / r_cubed;
+                    const double r_to_the_5 = r_squared * r_cubed;
+
+                    const double G_density_JxW = G_times_density_times_JxW[q];
+
+                    // For gravity acceleration:
+                    const double KK = - G_density_JxW * one_over_r_cubed;
+                    local_g[p] += KK * r_vector;
+
+                    // For gravity anomalies:
+                    const double KK_anomalies = - G_times_density_anomaly_times_JxW[q] * one_over_r_cubed;
+                    local_g_anomaly[p] += KK_anomalies * r_vector;
+
+                    // For gravity potential:
+                    local_g_potential[p] -= G_density_JxW / r;
+
+                    // For gravity gradient:
+                    const double grad_KK = G_density_JxW / r_to_the_5;
+                    for (unsigned int e=0; e<dim; ++e)
+                      for (unsigned int f=e; f<dim; ++f)
+                        local_g_gradient[p][e][f] += grad_KK * (3.0
+                                                                * r_vector[e] * r_vector[f]
+                                                                - (e==f ? r_squared : 0));
+                  }
+              }
+          }
+
+      // Sum local gravity components over global domain and compute
+      // some max and mins. We can directly call Utilities::MPI::sum()
+      // for a vector of doubles, but for the other data types we have
+      // to be more creative:
+      std::vector<double> g_potential(n_satellites);
+      Utilities::MPI::sum (make_const_array_view(local_g_potential),
+                           this->get_mpi_communicator(),
+                           make_array_view(g_potential));
+
+      const auto tensor_sum
+        = [] (const auto &v1, const auto &v2)
+      {
+        AssertDimension (v1.size(), v2.size());
+
+        using element_type = typename std::remove_reference<decltype(v1)>::type::value_type;
+
+        std::vector<element_type> result (v1.size());
+        for (unsigned int i=0; i<result.size(); ++i)
+          result[i] = v1[i] + v2[i];
+        return result;
+      };
+
+      const std::vector<Tensor<1,dim>>
+      g = Utilities::MPI::all_reduce<decltype(local_g)>
+          (local_g,
+           this->get_mpi_communicator(),
+           tensor_sum);
+
+      const std::vector<Tensor<1,dim>>
+      g_anomaly = Utilities::MPI::all_reduce<decltype(local_g_anomaly)>
+                  (local_g_anomaly,
+                   this->get_mpi_communicator(),
+                   tensor_sum);
+
+      const std::vector<SymmetricTensor<2,dim>>
+      g_gradient = Utilities::MPI::all_reduce<decltype(local_g_gradient)>
+                   (local_g_gradient,
+                    this->get_mpi_communicator(),
+                    tensor_sum);
+
+      double sum_g = 0;
+      double min_g = std::numeric_limits<double>::max();
+      double max_g = std::numeric_limits<double>::lowest();
+      double sum_g_potential = 0;
+      double min_g_potential = std::numeric_limits<double>::max();
+      double max_g_potential = std::numeric_limits<double>::lowest();
+
+      for (unsigned int p=0; p < n_satellites; ++p)
+        {
+          // sum gravity components for all n_satellites:
+          sum_g += g[p].norm();
+          sum_g_potential += g_potential[p];
+          max_g = std::max(g[p].norm(), max_g);
+          min_g = std::min(g[p].norm(), min_g);
+          max_g_potential = std::max(g_potential[p], max_g_potential);
+          min_g_potential = std::min(g_potential[p], min_g_potential);
+        }
+
+
+      // Now also compute theoretical values. These are output only
+      // on process zero and, for now, also only computed on process zero.
+      std::vector<double> g_theory(n_satellites);
+      std::vector<double> g_potential_theory(n_satellites);
+      std::vector<SymmetricTensor<2,dim>> g_gradient_theory(n_satellites);
+
+      const unsigned int my_rank
+        = Utilities::MPI::this_mpi_process(this->get_mpi_communicator());
+      const unsigned int n_ranks
+        = Utilities::MPI::n_mpi_processes(this->get_mpi_communicator());
+
+      for (unsigned int p=0; p < n_satellites; ++p)
+        if (p % n_ranks == my_rank)
+          {
+            const Point<dim> satellite_position = satellite_positions_cartesian[p];
+
+            // analytical solution to calculate the theoretical gravity and its derivatives
+            // from a uniform density model. Can only be used if concentric density profile.
+            if (satellite_positions_spherical[p][0] <= model_inner_radius)
+              {
+                // We are inside the inner radius
+                g_theory[p] = 0;
+                g_potential_theory[p] = 2.0 * G * numbers::PI * reference_density *
+                                        ((model_inner_radius * model_inner_radius) - (model_outer_radius * model_outer_radius));
+              }
+            else if ((satellite_positions_spherical[p][0] > model_inner_radius)
+                     && (satellite_positions_spherical[p][0] < model_outer_radius))
+              {
+                // We are in the spherical shell
+                g_theory[p] = G * numbers::PI * 4./3. * reference_density *
+                              (satellite_positions_spherical[p][0] -
+                               ((model_inner_radius * model_inner_radius * model_inner_radius)
+                                /  (satellite_positions_spherical[p][0] * satellite_positions_spherical[p][0])));
+                g_potential_theory[p] = G * numbers::PI * 4./3. * reference_density *
+                                        (((satellite_positions_spherical[p][0] * satellite_positions_spherical[p][0])/2.0) +
+                                         ((model_inner_radius * model_inner_radius * model_inner_radius) / satellite_positions_spherical[p][0]))
+                                        -
+                                        G * numbers::PI * 2.0 * reference_density *
+                                        (model_outer_radius * model_outer_radius);
+              }
+            else
+              {
+                const double common_factor = G * numbers::PI * 4./3. * reference_density
+                                             * ((model_outer_radius * model_outer_radius * model_outer_radius) - (model_inner_radius * model_inner_radius * model_inner_radius));
+                const double r = satellite_positions_spherical[p][0];
+
+                g_theory[p] = common_factor / (r * r);
+                g_potential_theory[p] = - common_factor / r;
+
+                // For the gradient of g, start with the common part of
+                // the diagonal elements:
+                g_gradient_theory[p][0][0] =
+                  g_gradient_theory[p][1][1] =
+                    g_gradient_theory[p][2][2] = -1./(r * r * r);
+
+                // Then do the off-diagonal elements:
+                for (unsigned int e=0; e<dim; ++e)
+                  for (unsigned int f=e; f<dim; ++f)
+                    g_gradient_theory[p][e][f] += -(- 3.0 * satellite_position[e] * satellite_position[f])
+                                                  /  std::pow(r,5);
+                g_gradient_theory[p] *= common_factor;
+              }
+          }
+
+      g_theory = Utilities::MPI::all_reduce<decltype(g_theory)>
+                 (g_theory,
+                  this->get_mpi_communicator(),
+                  tensor_sum);
+
+      g_potential_theory = Utilities::MPI::all_reduce<decltype(g_potential_theory)>
+                           (g_potential_theory,
+                            this->get_mpi_communicator(),
+                            tensor_sum);
+
+      g_gradient_theory = Utilities::MPI::all_reduce<decltype(g_gradient_theory)>
+                          (g_gradient_theory,
+                           this->get_mpi_communicator(),
+                           tensor_sum);
+
+      // open the file on rank 0 and write the headers
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          // First put all of our output into a string buffer:
+          std::ostringstream output;
+          output << "# 1: position_satellite_r" << '\n'
+                 << "# 2: position_satellite_phi" << '\n'
+                 << "# 3: position_satellite_theta" << '\n'
+                 << "# 4: position_satellite_x" << '\n'
+                 << "# 5: position_satellite_y" << '\n'
+                 << "# 6: position_satellite_z" << '\n'
+                 << "# 7: gravity_x" << '\n'
+                 << "# 8: gravity_y" << '\n'
+                 << "# 9: gravity_z" << '\n'
+                 << "# 10: gravity_norm" << '\n'
+                 << "# 11: gravity_theory" << '\n'
+                 << "# 12: gravity_potential" << '\n'
+                 << "# 13: gravity_potential_theory" << '\n'
+                 << "# 14: gravity_anomaly_x" << '\n'
+                 << "# 15: gravity_anomaly_y" << '\n'
+                 << "# 16: gravity_anomaly_z" << '\n'
+                 << "# 17: gravity_anomaly_norm" << '\n'
+                 << "# 18: gravity_gradient_xx" << '\n'
+                 << "# 19: gravity_gradient_yy" << '\n'
+                 << "# 20: gravity_gradient_zz" << '\n'
+                 << "# 21: gravity_gradient_xy" << '\n'
+                 << "# 22: gravity_gradient_xz" << '\n'
+                 << "# 23: gravity_gradient_yz" << '\n'
+                 << "# 24: gravity_gradient_theory_xx" << '\n'
+                 << "# 25: gravity_gradient_theory_yy" << '\n'
+                 << "# 26: gravity_gradient_theory_zz" << '\n'
+                 << "# 27: gravity_gradient_theory_xy" << '\n'
+                 << "# 28: gravity_gradient_theory_xz" << '\n'
+                 << "# 29: gravity_gradient_theory_yz" << '\n'
+                 << '\n';
+
+          for (unsigned int p=0; p < n_satellites; ++p)
+            {
+              const Point<dim> satellite_position = satellite_positions_cartesian[p];
+
+              // write output.
+              // g_gradient is here given in eotvos E (1E = 1e-9 per square seconds):
+              output << satellite_positions_spherical[p][0] << ' '
+                     << satellite_positions_spherical[p][1] * constants::radians_to_degree << ' '
+                     << satellite_positions_spherical[p][2] * constants::radians_to_degree << ' '
+                     << satellite_position[0] << ' '
+                     << satellite_position[1] << ' '
+                     << satellite_position[2] << ' '
+                     << std::setprecision(precision)
+                     << g[p] << ' '
+                     << g[p].norm() << ' '
+                     << g_theory[p] << ' '
+                     << g_potential[p] << ' '
+                     << g_potential_theory[p] << ' '
+                     << g_anomaly[p] << ' '
+                     << g_anomaly[p].norm() << ' '
+                     << g_gradient[p][0][0] *1e9 << ' '
+                     << g_gradient[p][1][1] *1e9 << ' '
+                     << g_gradient[p][2][2] *1e9 << ' '
+                     << g_gradient[p][0][1] *1e9 << ' '
+                     << g_gradient[p][0][2] *1e9 << ' '
+                     << g_gradient[p][1][2] *1e9 << ' '
+                     << g_gradient_theory[p][0][0] *1e9 << ' '
+                     << g_gradient_theory[p][1][1] *1e9 << ' '
+                     << g_gradient_theory[p][2][2] *1e9 << ' '
+                     << g_gradient_theory[p][0][1] *1e9 << ' '
+                     << g_gradient_theory[p][0][2] *1e9 << ' '
+                     << g_gradient_theory[p][1][2] *1e9 << ' '
+                     << '\n';
+            }
+
+          // Now push the entire buffer into the output file in one swoop fell:
+          std::ofstream output_file(filename);
+          AssertThrow(output_file,
+                      ExcMessage("Unable to open file for writing: " + filename +"."));
+          output_file << output.str();
+        }
+
+      // write quantities in the statistic file
+      const std::string name2("Average gravity acceleration (m/s^2)");
+      statistics.add_value (name2, sum_g/n_satellites);
+      statistics.set_precision (name2, precision);
+      statistics.set_scientific (name2, true);
+
+      const std::string name3("Minimum gravity acceleration (m/s^2)");
+      statistics.add_value (name3, min_g);
+      statistics.set_precision (name3, precision);
+      statistics.set_scientific (name3, true);
+
+      const std::string name4("Maximum gravity acceleration (m/s^2)");
+      statistics.add_value (name4, max_g);
+      statistics.set_precision (name4, precision);
+      statistics.set_scientific (name4, true);
+
+      const std::string name5("Average gravity potential (m^2/s^2)");
+      statistics.add_value (name5, sum_g_potential/n_satellites);
+      statistics.set_precision (name5, precision);
+      statistics.set_scientific (name5, true);
+
+      const std::string name6("Minimum gravity potential (m^2/s^2)");
+      statistics.add_value (name6, min_g_potential);
+      statistics.set_precision (name6, precision);
+      statistics.set_scientific (name6, true);
+
+      const std::string name7("Maximum gravity potential (m^2/s^2)");
+      statistics.add_value (name7, max_g_potential);
+      statistics.set_precision (name7, precision);
+      statistics.set_scientific (name7, true);
+
+      // up the next time we need output:
+      set_last_output_time (this->get_time());
+      last_output_timestep = this->get_timestep_number();
+      return std::pair<std::string, std::string> ("Writing gravity output:", filename);
+    }
+
+
+
+    template <int dim>
+    void
+    GravityPointValues<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Postprocess");
+      {
+        prm.enter_subsection ("Gravity calculation");
+        {
+          prm.declare_entry ("Sampling scheme", "map",
+                             Patterns::Selection ("map|list|list of points|fibonacci spiral"),
+                             "Choose the sampling scheme. By default, the map produces a "
+                             "grid of equally angled points between a minimum and maximum "
+                             "radius, longitude, and latitude. A list of points contains "
+                             "the specific coordinates of the satellites. The fibonacci "
+                             "spiral sampling scheme produces a uniformly distributed map "
+                             "on the surface of sphere defined by a minimum and/or "
+                             "maximum radius.");
+          prm.declare_entry ("Number points fibonacci spiral", "200",
+                             Patterns::Integer (0),
+                             "Parameter for the fibonacci spiral sampling scheme: "
+                             "This specifies the desired number of satellites per radius "
+                             "layer. The default value is 200. Note that sampling "
+                             "becomes more uniform with increasing number of satellites");
+          prm.declare_entry ("Quadrature degree increase", "0",
+                             Patterns::Integer (-1),
+                             "Quadrature degree increase over the velocity element "
+                             "degree may be required when gravity is calculated near "
+                             "the surface or inside the model. An increase in the "
+                             "quadrature element adds accuracy to the gravity "
+                             "solution from noise due to the model grid.");
+          prm.declare_entry ("Number points radius", "1",
+                             Patterns::Integer (0),
+                             "Parameter for the map sampling scheme: "
+                             "This specifies the number of points along "
+                             "the radius (e.g. depth profile) between a minimum and "
+                             "maximum radius.");
+          prm.declare_entry ("Number points longitude", "1",
+                             Patterns::Integer (0),
+                             "Parameter for the map sampling scheme: "
+                             "This specifies the number of points along "
+                             "the longitude (e.g. gravity map) between a minimum and "
+                             "maximum longitude.");
+          prm.declare_entry ("Number points latitude", "1",
+                             Patterns::Integer (0),
+                             "Parameter for the map sampling scheme: "
+                             "This specifies the number of points along "
+                             "the latitude (e.g. gravity map) between a minimum and "
+                             "maximum latitude.");
+          prm.declare_entry ("Minimum radius", "0.",
+                             Patterns::Double (0.0),
+                             "Parameter for the map sampling scheme: "
+                             "Minimum radius may be defined in or outside the model. "
+                             "Prescribe a minimum radius for a sampling coverage at a "
+                             "specific height.");
+          prm.declare_entry ("Maximum radius", "0.",
+                             Patterns::Double (0.0),
+                             "Parameter for the map sampling scheme: "
+                             "Maximum radius can be defined in or outside the model.");
+          prm.declare_entry ("Minimum longitude", "-180.",
+                             Patterns::Double (-180.0, 180.0),
+                             "Parameter for the uniform distribution sampling scheme: "
+                             "Gravity may be calculated for a sets of points along "
+                             "the longitude between a minimum and maximum longitude.");
+          prm.declare_entry ("Minimum latitude", "-90.",
+                             Patterns::Double (-90.0, 90.0),
+                             "Parameter for the uniform distribution sampling scheme: "
+                             "Gravity may be calculated for a sets of points along "
+                             "the latitude between a minimum and maximum latitude.");
+          prm.declare_entry ("Maximum longitude", "180.",
+                             Patterns::Double (-180.0, 180.0),
+                             "Parameter for the uniform distribution sampling scheme: "
+                             "Gravity may be calculated for a sets of points along "
+                             "the longitude between a minimum and maximum longitude.");
+          prm.declare_entry ("Maximum latitude", "90",
+                             Patterns::Double (-90.0, 90.0),
+                             "Parameter for the uniform distribution sampling scheme: "
+                             "Gravity may be calculated for a sets of points along "
+                             "the latitude between a minimum and maximum latitude.");
+          prm.declare_entry ("Reference density", "3300.",
+                             Patterns::Double (0.0),
+                             "Gravity anomalies may be computed using density "
+                             "anomalies relative to a reference density.");
+          prm.declare_entry ("Precision in gravity output", "12",
+                             Patterns::Integer (1),
+                             "Set the precision of gravity acceleration, potential "
+                             "and gradients in the gravity output and statistics file.");
+          prm.declare_entry ("List of radius", "",
+                             Patterns::List (Patterns::Double (0.)),
+                             "Parameter for the list of points sampling scheme: "
+                             "List of satellite radius coordinates. Just specify one "
+                             "radius if all points values have the same radius. If "
+                             "not, make sure there are as many radius as longitude "
+                             "and latitude");
+          prm.declare_entry ("List of longitude", "",
+                             Patterns::List (Patterns::Double(-180.0, 180.0)),
+                             "Parameter for the list of points sampling scheme: "
+                             "List of satellite longitude coordinates.");
+          prm.declare_entry ("List of latitude", "",
+                             Patterns::List (Patterns::Double(-90.0, 90.0)),
+                             "Parameter for the list of points sampling scheme: "
+                             "List of satellite latitude coordinates.");
+          prm.declare_entry ("Time between gravity output", "1e8",
+                             Patterns::Double(0.0),
+                             "The time interval between each generation of "
+                             "gravity output files. A value of 0 indicates "
+                             "that output should be generated in each time step. "
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+          prm.declare_entry ("Time steps between gravity output", boost::lexical_cast<std::string>(std::numeric_limits<int>::max()),
+                             Patterns::Integer(0,std::numeric_limits<int>::max()),
+                             "The maximum number of time steps between each generation of "
+                             "gravity output files.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    GravityPointValues<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      std::string gravity_subdirectory = this->get_output_directory() + "output_gravity/";
+      Utilities::create_directory (gravity_subdirectory,
+                                   this->get_mpi_communicator(),
+                                   true);
+
+      end_time = prm.get_double ("End time");
+      if (this->convert_output_to_years())
+        end_time *= year_in_seconds;
+
+      prm.enter_subsection ("Postprocess");
+      {
+        prm.enter_subsection ("Gravity calculation");
+        {
+          if ( (prm.get ("Sampling scheme") == "uniform distribution") || (prm.get ("Sampling scheme") == "map") )
+            sampling_scheme = map;
+          else if ( (prm.get ("Sampling scheme") == "list of points") || (prm.get ("Sampling scheme") == "list") )
+            sampling_scheme = list_of_points;
+          else if (prm.get ("Sampling scheme") == "fibonacci spiral")
+            sampling_scheme = fibonacci_spiral;
+          else
+            AssertThrow (false, ExcMessage ("Not a valid sampling scheme."));
+          quadrature_degree_increase = prm.get_integer ("Quadrature degree increase");
+          n_points_spiral     = prm.get_integer("Number points fibonacci spiral");
+          n_points_radius     = prm.get_integer("Number points radius");
+          n_points_longitude  = prm.get_integer("Number points longitude");
+          n_points_latitude   = prm.get_integer("Number points latitude");
+          minimum_radius      = prm.get_double ("Minimum radius");
+          maximum_radius      = prm.get_double ("Maximum radius");
+          minimum_colongitude = prm.get_double ("Minimum longitude") + 180.;
+          maximum_colongitude = prm.get_double ("Maximum longitude") + 180.;
+          minimum_colatitude  = prm.get_double ("Minimum latitude") + 90.;
+          maximum_colatitude  = prm.get_double ("Maximum latitude") + 90.;
+          reference_density   = prm.get_double ("Reference density");
+          precision = prm.get_integer ("Precision in gravity output");
+          radius_list    = Utilities::string_to_double(Utilities::split_string_list(prm.get("List of radius")));
+          longitude_list = Utilities::string_to_double(Utilities::split_string_list(prm.get("List of longitude")));
+          latitude_list  = Utilities::string_to_double(Utilities::split_string_list(prm.get("List of latitude")));
+          AssertThrow (longitude_list.size() == latitude_list.size(),
+                       ExcMessage ("Make sure you have the same number of point coordinates in the list sampling scheme."));
+          AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()) ||
+                       Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()) ||
+                       Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()),
+                       ExcMessage ("This postprocessor can only be used if the geometry is a sphere, spherical shell or spherical chunk."));
+          AssertThrow (! this->get_material_model().is_compressible(),
+                       ExcMessage("This postprocessor was only tested for incompressible models so far."));
+          AssertThrow (dim==3,
+                       ExcMessage("This postprocessor was only tested for 3d models."));
+          output_interval = prm.get_double ("Time between gravity output");
+          if (this->convert_output_to_years())
+            output_interval *= year_in_seconds;
+          maximum_timesteps_between_outputs = prm.get_integer("Time steps between gravity output");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    template <class Archive>
+    void GravityPointValues<dim>::serialize (Archive &ar, const unsigned int)
+    {
+      // This deals with having the correct behavior during checkpoint/restart cycles:
+      ar &last_output_time
+      & last_output_timestep
+      & output_file_number
+      ;
+    }
+
+
+
+    template <int dim>
+    void
+    GravityPointValues<dim>::set_last_output_time (const double current_time)
+    {
+      // if output_interval is positive, then update the last supposed output time:
+      if (output_interval > 0)
+        {
+          // We need to find the last time output was supposed to be written.
+          // this is the last_output_time plus the largest positive multiple
+          // of output_intervals that passed since then. We need to handle the
+          // edge case where last_output_time+output_interval==current_time,
+          // we did an output and std::floor sadly rounds to zero. This is done
+          // by forcing std::floor to round 1.0-eps to 1.0.
+          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    GravityPointValues<dim>::save (std::map<std::string, std::string> &status_strings) const
+    {
+      std::ostringstream os;
+      aspect::oarchive oa (os);
+      oa << (*this);
+
+      status_strings["GravityPointValues"] = os.str();
+    }
+
+
+
+    template <int dim>
+    void
+    GravityPointValues<dim>::load (const std::map<std::string, std::string> &status_strings)
+    {
+      // see if something was saved
+      if (status_strings.find("GravityPointValues") != status_strings.end())
+        {
+          std::istringstream is (status_strings.find("GravityPointValues")->second);
+          aspect::iarchive ia (is);
+          ia >> (*this);
+        }
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(GravityPointValues,
+                                  "gravity calculation",
+                                  "A postprocessor that computes gravity, gravity anomalies, gravity "
+                                  "potential and gravity gradients for a set of points (e.g. satellites) "
+                                  "in or above the model surface for either a user-defined range of "
+                                  "latitudes, longitudes and radius or a list of point coordinates."
+                                  "Spherical coordinates in the output file are radius, colatitude "
+                                  "and colongitude. Gravity is here based on the density distribution "
+                                  "from the material model (and non adiabatic). This means that the "
+                                  "density may come directly from an ascii file. This postprocessor also "
+                                  "computes theoretical gravity and its derivatives, which corresponds to "
+                                  "the analytical solution of gravity in the same geometry but filled "
+                                  "with a reference density. The reference density is also used to "
+                                  "determine density anomalies for computing gravity anomalies. Thus "
+                                  "one must carefully evaluate the meaning of the gravity anomaly output, "
+                                  "because the solution may not reflect the actual gravity anomaly (due to "
+                                  "differences in the assumed reference density). On way to guarantee correct "
+                                  "gravity anomalies is to subtract gravity of a certain point from the average "
+                                  "gravity on the map. Another way is to directly use density anomalies for this "
+                                  "postprocessor."
+                                  "The average- minimum- and maximum gravity acceleration and potential are "
+                                  "written into the statistics file.")
+  }
+}
diff --git a/source/postprocess/heat_flux_densities.cc.bak b/source/postprocess/heat_flux_densities.cc.bak
new file mode 100644
index 00000000000..d4c715f8716
--- /dev/null
+++ b/source/postprocess/heat_flux_densities.cc.bak
@@ -0,0 +1,157 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/heat_flux_densities.h>
+#include <aspect/postprocess/heat_flux_map.h>
+
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    HeatFluxDensities<dim>::execute (TableHandler &statistics)
+    {
+      const char *unit = (dim==2)? "W/m" : "W/m^2";
+
+      std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area =
+        internal::compute_heat_flux_through_boundary_faces (*this);
+
+      std::map<types::boundary_id, double> local_boundary_fluxes;
+      std::map<types::boundary_id, double> local_areas;
+
+      // Compute the area and heat flux of each boundary that lives on this processor.
+      // Finally, sum over the processors and compute the ratio between the
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (const unsigned int f : cell->face_indices())
+            if (cell->at_boundary(f))
+              {
+                const types::boundary_id boundary_indicator
+                  = cell->face(f)->boundary_id();
+                local_boundary_fluxes[boundary_indicator] += heat_flux_and_area[cell->active_cell_index()][f].first;
+                local_areas[boundary_indicator] += heat_flux_and_area[cell->active_cell_index()][f].second;
+              }
+
+      // now communicate to get the global values
+      std::map<types::boundary_id, double> global_boundary_flux_densities;
+      {
+        // first collect local values in the same order in which they are listed
+        // in the set of boundary indicators
+        const std::set<types::boundary_id>
+        boundary_indicators
+          = this->get_geometry_model().get_used_boundary_indicators ();
+        std::vector<double> local_boundary_fluxes_vector;
+        std::vector<double> local_areas_vector;
+        for (const auto id : boundary_indicators)
+          {
+            local_boundary_fluxes_vector.push_back (local_boundary_fluxes[id]);
+            local_areas_vector.push_back (local_areas[id]);
+          }
+
+        // then collect contributions from all processors
+        std::vector<double> global_values (local_boundary_fluxes_vector.size());
+        std::vector<double> global_areas (local_areas_vector.size());
+        Utilities::MPI::sum (local_boundary_fluxes_vector, this->get_mpi_communicator(), global_values);
+        Utilities::MPI::sum (local_areas_vector, this->get_mpi_communicator(), global_areas);
+
+        // and now take them apart into the global map again and compute ratios
+        unsigned int index = 0;
+        for (const auto id : boundary_indicators)
+          {
+            global_boundary_flux_densities[id] = global_values[index]/global_areas[index];
+            ++index;
+          }
+      }
+
+      // now add all of the computed heat fluxes to the statistics object
+      // and create a single string that can be output to the screen
+      std::ostringstream screen_text;
+      unsigned int index = 0;
+      for (std::map<types::boundary_id, double>::const_iterator
+           p = global_boundary_flux_densities.begin();
+           p != global_boundary_flux_densities.end(); ++p, ++index)
+        {
+          const std::string name = "Outward heat flux density for boundary with id "
+                                   + Utilities::int_to_string(p->first)
+                                   + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                 .translate_id_to_symbol_name (p->first))
+                                   + " (" + unit +")";
+          statistics.add_value (name, p->second);
+
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (name, 8);
+          statistics.set_scientific (name, true);
+
+          // finally have something for the screen
+          screen_text.precision(4);
+          screen_text << p->second << ' ' << unit
+                      << (index == global_boundary_flux_densities.size()-1 ? "" : ", ");
+        }
+
+      return std::pair<std::string, std::string> ("Heat flux densities for boundaries:",
+                                                  screen_text.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(HeatFluxDensities,
+                                  "heat flux densities",
+                                  "A postprocessor that computes some statistics "
+                                  "about the heat flux density for each boundary id. "
+                                  "The heat flux density across each boundary "
+                                  "is computed in outward "
+                                  "direction, i.e., from the domain to the "
+                                  "outside. The heat flux is computed as sum "
+                                  "of advective heat flux and conductive heat "
+                                  "flux through Neumann boundaries, both "
+                                  "computed as integral over the boundary area, "
+                                  "and conductive heat flux through Dirichlet "
+                                  "boundaries, which is computed using the "
+                                  "consistent boundary flux method as described "
+                                  "in ``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
+                                  "The consistent Galerkin FEM for computing "
+                                  "derived boundary quantities in thermal and or "
+                                  "fluids problems. International Journal for "
+                                  "Numerical Methods in Fluids, 7(4), 371-394.''"
+                                  "\n\n"
+                                  "Note that the ``heat flux statistics'' "
+                                  "postprocessor computes the same quantity as "
+                                  "the one here, but not divided by the area of "
+                                  "the surface. In other words, it computes the "
+                                  "\\textit{total} heat flux through each boundary."
+                                 )
+  }
+}
diff --git a/source/postprocess/heat_flux_map.cc.bak b/source/postprocess/heat_flux_map.cc.bak
new file mode 100644
index 00000000000..c565d3cdcad
--- /dev/null
+++ b/source/postprocess/heat_flux_map.cc.bak
@@ -0,0 +1,565 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/heat_flux_map.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/boundary_heat_flux/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace internal
+    {
+      template <int dim>
+      LinearAlgebra::BlockVector
+      compute_dirichlet_boundary_heat_flux_solution_vector (const SimulatorAccess<dim> &simulator_access)
+      {
+        // Quadrature degree for assembling the consistent boundary flux equation, see Simulator::assemble_advection_system()
+        // for a justification of the chosen quadrature degree.
+        const unsigned int quadrature_degree = simulator_access.get_parameters().temperature_degree
+                                               +
+                                               (simulator_access.get_parameters().stokes_velocity_degree+1)/2;
+
+        // Gauss quadrature in the interior for best accuracy.
+        const QGauss<dim> quadrature_formula(quadrature_degree);
+        // GLL quadrature on the faces to get a diagonal mass matrix.
+        const QGaussLobatto<dim-1> quadrature_formula_face(quadrature_degree);
+
+        // The CBF method involves both boundary and volume integrals on the
+        // cells at the boundary. Construct FEValues objects for each of these integrations.
+        FEValues<dim> fe_volume_values (simulator_access.get_mapping(),
+                                        simulator_access.get_fe(),
+                                        quadrature_formula,
+                                        update_values |
+                                        update_gradients |
+                                        update_quadrature_points |
+                                        update_JxW_values);
+
+        FEFaceValues<dim> fe_face_values (simulator_access.get_mapping(),
+                                          simulator_access.get_fe(),
+                                          quadrature_formula_face,
+                                          update_JxW_values |
+                                          update_values |
+                                          update_gradients |
+                                          update_normal_vectors |
+                                          update_quadrature_points);
+
+        const unsigned int dofs_per_cell = simulator_access.get_fe().dofs_per_cell;
+        const unsigned int n_q_points = quadrature_formula.size();
+        const unsigned int n_face_q_points = quadrature_formula_face.size();
+
+        // Vectors for solving CBF system. Since we are using GLL
+        // quadrature, the mass matrix will be diagonal, and we can just assemble it into a vector.
+        Vector<double> local_rhs(dofs_per_cell);
+        Vector<double> local_mass_matrix(dofs_per_cell);
+
+        // The mass matrix may be stored in a vector as it is a diagonal matrix:
+        // it is computed based on quadrature over faces, and we use a node-location
+        // based quadrature formula above, so phi_i(x_q)=delta_{iq} where the
+        // x_q are the node points of the finite element shape functions on the face.
+        LinearAlgebra::BlockVector mass_matrix(simulator_access.introspection().index_sets.system_partitioning,
+                                               simulator_access.get_mpi_communicator());
+        LinearAlgebra::BlockVector distributed_heat_flux_vector(simulator_access.introspection().index_sets.system_partitioning,
+                                                                simulator_access.get_mpi_communicator());
+        LinearAlgebra::BlockVector heat_flux_vector(simulator_access.introspection().index_sets.system_partitioning,
+                                                    simulator_access.introspection().index_sets.system_relevant_partitioning,
+                                                    simulator_access.get_mpi_communicator());
+        LinearAlgebra::BlockVector rhs_vector(simulator_access.introspection().index_sets.system_partitioning,
+                                              simulator_access.get_mpi_communicator());
+
+        distributed_heat_flux_vector = 0.;
+        heat_flux_vector = 0.;
+
+        typename MaterialModel::Interface<dim>::MaterialModelInputs
+        in(fe_volume_values.n_quadrature_points, simulator_access.n_compositional_fields());
+        typename MaterialModel::Interface<dim>::MaterialModelOutputs
+        out(fe_volume_values.n_quadrature_points, simulator_access.n_compositional_fields());
+
+        HeatingModel::HeatingModelOutputs
+        heating_out(fe_volume_values.n_quadrature_points, simulator_access.n_compositional_fields());
+
+        typename MaterialModel::Interface<dim>::MaterialModelInputs
+        face_in(fe_face_values.n_quadrature_points, simulator_access.n_compositional_fields());
+        typename MaterialModel::Interface<dim>::MaterialModelOutputs
+        face_out(fe_face_values.n_quadrature_points, simulator_access.n_compositional_fields());
+
+        std::vector<double> old_temperatures (n_q_points);
+        std::vector<double> old_old_temperatures (n_q_points);
+        std::vector<Tensor<1,dim>> temperature_gradients (n_q_points);
+
+        const double time_step = simulator_access.get_timestep();
+        const double old_time_step = simulator_access.get_old_timestep();
+
+        const std::set<types::boundary_id> &fixed_temperature_boundaries =
+          simulator_access.get_boundary_temperature_manager().get_fixed_temperature_boundary_indicators();
+
+        const std::set<types::boundary_id> &fixed_heat_flux_boundaries =
+          simulator_access.get_parameters().fixed_heat_flux_boundary_indicators;
+
+        Vector<float> artificial_viscosity(simulator_access.get_triangulation().n_active_cells());
+        simulator_access.get_artificial_viscosity(artificial_viscosity, true);
+
+        // loop over all of the surface cells and evaluate the heat flux
+        for (const auto &cell : simulator_access.get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned() && cell->at_boundary())
+            {
+              fe_volume_values.reinit (cell);
+              in.reinit(fe_volume_values, cell, simulator_access.introspection(), simulator_access.get_solution());
+              simulator_access.get_material_model().evaluate(in, out);
+
+              if (simulator_access.get_parameters().formulation_temperature_equation ==
+                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+                {
+                  for (unsigned int q=0; q<n_q_points; ++q)
+                    {
+                      out.densities[q] = simulator_access.get_adiabatic_conditions().density(in.position[q]);
+                    }
+                }
+
+              MaterialModel::MaterialAveraging::average (simulator_access.get_parameters().material_averaging,
+                                                         cell,
+                                                         fe_volume_values.get_quadrature(),
+                                                         fe_volume_values.get_mapping(),
+                                                         in.requested_properties,
+                                                         out);
+
+              simulator_access.get_heating_model_manager().evaluate(in, out, heating_out);
+
+              local_rhs = 0.;
+              local_mass_matrix = 0.;
+
+              fe_volume_values[simulator_access.introspection().extractors.temperature].get_function_gradients (simulator_access.get_solution(), temperature_gradients);
+              fe_volume_values[simulator_access.introspection().extractors.temperature].get_function_values (simulator_access.get_old_solution(), old_temperatures);
+              fe_volume_values[simulator_access.introspection().extractors.temperature].get_function_values (simulator_access.get_old_old_solution(), old_old_temperatures);
+
+              // Compute volume integrals on RHS of the CBF system
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  double temperature_time_derivative;
+
+                  if (simulator_access.get_timestep_number() > 1)
+                    {
+                      Assert(time_step > 0.0 && old_time_step > 0.0,
+                             ExcMessage("The heat flux postprocessor found a time step length of 0. "
+                                        "This is not supported, because it needs to compute the time derivative of the "
+                                        "temperature. Either use a positive timestep, or modify the postprocessor to "
+                                        "ignore the time derivative."));
+
+                      temperature_time_derivative = (1.0/time_step) *
+                                                    (in.temperature[q] *
+                                                     (2*time_step + old_time_step) / (time_step + old_time_step)
+                                                     -
+                                                     old_temperatures[q] *
+                                                     (1 + time_step/old_time_step)
+                                                     +
+                                                     old_old_temperatures[q] *
+                                                     (time_step * time_step) / (old_time_step * (time_step + old_time_step)));
+                    }
+                  else if (simulator_access.get_timestep_number() == 1)
+                    {
+                      Assert(time_step > 0.0,
+                             ExcMessage("The heat flux postprocessor found a time step length of 0. "
+                                        "This is not supported, because it needs to compute the time derivative of the "
+                                        "temperature. Either use a positive timestep, or modify the postprocessor to "
+                                        "ignore the time derivative."));
+
+                      temperature_time_derivative =
+                        (in.temperature[q] - old_temperatures[q]) / time_step;
+                    }
+                  else
+                    temperature_time_derivative = 0.0;
+
+                  const double JxW = fe_volume_values.JxW(q);
+
+                  const double density_c_P = out.densities[q] * out.specific_heat[q];
+                  const double latent_heat_LHS = heating_out.lhs_latent_heat_terms[q];
+                  const double material_prefactor = density_c_P + latent_heat_LHS;
+
+                  const double artificial_viscosity_cell = static_cast<double>(artificial_viscosity(cell->active_cell_index()));
+
+                  // The SUPG parameter tau does not have the physical dimensions of a thermal conductivity and as such should not be included in heat flux calculations
+                  // By default, ASPECT includes the artificial viscosity in the thermal conductivity when calculating boundary heat flux.
+                  const double diffusion_constant = (simulator_access.get_parameters().advection_stabilization_method ==
+                                                     Parameters<dim>::AdvectionStabilizationMethod::supg) ?
+                                                    out.thermal_conductivities[q]
+                                                    :
+                                                    std::max(out.thermal_conductivities[q],
+                                                             artificial_viscosity_cell);
+
+                  for (unsigned int i = 0; i<dofs_per_cell; ++i)
+                    {
+                      local_rhs(i) +=
+                        // conduction term (term 2 in equation (30) of Gresho et al.)
+                        (-diffusion_constant * temperature_gradients[q] *
+                         fe_volume_values[simulator_access.introspection().extractors.temperature].gradient(i,q)
+                         +
+                         // advection term and time derivative (term 1 in equation (30) of Gresho et al.)
+                         (- material_prefactor * (temperature_gradients[q] * in.velocity[q] + temperature_time_derivative)
+                          // source terms (term 4 in equation (30) of Gresho et al.)
+                          + heating_out.heating_source_terms[q])
+                         * fe_volume_values[simulator_access.introspection().extractors.temperature].value(i,q))
+                        * JxW;
+                    }
+                }
+
+              for (const unsigned int f : cell->face_indices())
+                {
+                  if (!cell->at_boundary(f))
+                    continue;
+
+                  fe_face_values.reinit (cell, f);
+
+                  const unsigned int boundary_id = cell->face(f)->boundary_id();
+
+                  // Compute heat flux through Dirichlet boundary using CBF method
+                  if (fixed_temperature_boundaries.find(boundary_id) != fixed_temperature_boundaries.end())
+                    {
+                      // Assemble the mass matrix for cell face. Because the quadrature
+                      // formula is chosen as co-located with the nodes of shape functions,
+                      // the resulting matrix is diagonal.
+                      for (unsigned int q=0; q<n_face_q_points; ++q)
+                        for (unsigned int i=0; i<dofs_per_cell; ++i)
+                          local_mass_matrix(i) += fe_face_values[simulator_access.introspection().extractors.temperature].value(i,q) *
+                                                  fe_face_values[simulator_access.introspection().extractors.temperature].value(i,q) *
+                                                  fe_face_values.JxW(q);
+                    }
+                  // Compute heat flux through Neumann boundary by integrating the heat flux
+                  else if (fixed_heat_flux_boundaries.find(boundary_id) != fixed_heat_flux_boundaries.end())
+                    {
+                      face_in.reinit(fe_face_values, cell, simulator_access.introspection(), simulator_access.get_solution());
+                      simulator_access.get_material_model().evaluate(face_in, face_out);
+
+                      if (simulator_access.get_parameters().formulation_temperature_equation ==
+                          Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+                        {
+                          for (unsigned int q=0; q<n_face_q_points; ++q)
+                            {
+                              face_out.densities[q] = simulator_access.get_adiabatic_conditions().density(face_in.position[q]);
+                            }
+                        }
+
+                      std::vector<Tensor<1,dim>> heat_flux(n_face_q_points);
+                      heat_flux = simulator_access.get_boundary_heat_flux().heat_flux(
+                                    boundary_id,
+                                    face_in,
+                                    face_out,
+                                    fe_face_values.get_normal_vectors()
+                                  );
+
+                      // For inhomogeneous Neumann boundaries we know the heat flux across the boundary at each point,
+                      // and can thus simply integrate it for each cell. However, we still need to assemble the
+                      // boundary terms for the CBF method, because there could be Dirichlet boundaries on the
+                      // same cell (e.g. a different face in a corner). Therefore, do the integration into
+                      // heat_flux_and_area, and assemble the CBF term into local_rhs.
+                      for (unsigned int q=0; q < n_face_q_points; ++q)
+                        {
+                          for (unsigned int i = 0; i<dofs_per_cell; ++i)
+                            {
+                              // Neumann boundary condition term (term 3 in equation (30) of Gresho et al.)
+                              local_rhs(i) += - fe_face_values[simulator_access.introspection().extractors.temperature].value(i,q) *
+                                              heat_flux[q] * fe_face_values.normal_vector(q) * fe_face_values.JxW(q);
+                            }
+                        }
+                    }
+                }
+
+              cell->distribute_local_to_global(local_mass_matrix, mass_matrix);
+              cell->distribute_local_to_global(local_rhs, rhs_vector);
+            }
+
+        mass_matrix.compress(VectorOperation::add);
+        rhs_vector.compress(VectorOperation::add);
+
+        const IndexSet local_elements = mass_matrix.locally_owned_elements();
+        for (unsigned int k=0; k<local_elements.n_elements(); ++k)
+          {
+            const unsigned int global_index = local_elements.nth_index_in_set(k);
+
+            // Since the mass matrix is diagonal, we can just solve for the heat flux vector by dividing the
+            // right-hand side by the mass matrix entry
+            if (mass_matrix[global_index] > 1.e-15)
+              distributed_heat_flux_vector[global_index] = rhs_vector[global_index] / mass_matrix[global_index];
+          }
+
+        distributed_heat_flux_vector.compress(VectorOperation::insert);
+        heat_flux_vector = distributed_heat_flux_vector;
+
+        return heat_flux_vector;
+      }
+
+
+
+      template <int dim>
+      std::vector<std::vector<std::pair<double, double>>>
+      compute_heat_flux_through_boundary_faces (const SimulatorAccess<dim> &simulator_access)
+      {
+        std::vector<std::vector<std::pair<double, double>>>
+        heat_flux_and_area(simulator_access.get_triangulation().n_active_cells());
+
+        // Quadrature degree for assembling the consistent boundary flux equation, see Simulator::assemble_advection_system()
+        // for a justification of the chosen quadrature degree.
+        const unsigned int quadrature_degree = simulator_access.get_parameters().temperature_degree
+                                               +
+                                               (simulator_access.get_parameters().stokes_velocity_degree+1)/2;
+
+        // GLL quadrature on the faces to get a diagonal mass matrix.
+        const QGaussLobatto<dim-1> quadrature_formula_face(quadrature_degree);
+
+        FEFaceValues<dim> fe_face_values (simulator_access.get_mapping(),
+                                          simulator_access.get_fe(),
+                                          quadrature_formula_face,
+                                          update_JxW_values |
+                                          update_values |
+                                          update_gradients |
+                                          update_normal_vectors |
+                                          update_quadrature_points);
+
+        const unsigned int n_face_q_points = quadrature_formula_face.size();
+
+        typename MaterialModel::Interface<dim>::MaterialModelInputs face_in(fe_face_values.n_quadrature_points, simulator_access.n_compositional_fields());
+        typename MaterialModel::Interface<dim>::MaterialModelOutputs face_out(fe_face_values.n_quadrature_points, simulator_access.n_compositional_fields());
+
+        const std::set<types::boundary_id> &fixed_temperature_boundaries =
+          simulator_access.get_boundary_temperature_manager().get_fixed_temperature_boundary_indicators();
+
+        const std::set<types::boundary_id> &fixed_heat_flux_boundaries =
+          simulator_access.get_parameters().fixed_heat_flux_boundary_indicators;
+
+        const std::set<types::boundary_id> &tangential_velocity_boundaries =
+          simulator_access.get_boundary_velocity_manager().get_tangential_boundary_velocity_indicators();
+
+        const std::set<types::boundary_id> &zero_velocity_boundaries =
+          simulator_access.get_boundary_velocity_manager().get_zero_boundary_velocity_indicators();
+
+        const LinearAlgebra::BlockVector heat_flux_vector = compute_dirichlet_boundary_heat_flux_solution_vector(simulator_access);
+        std::vector<double> heat_flux_values(n_face_q_points);
+
+        // loop over all of the surface cells and evaluate the heat flux
+        for (const auto &cell : simulator_access.get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned() && cell->at_boundary())
+            {
+              for (const unsigned int f : cell->face_indices())
+                if (cell->at_boundary(f))
+                  {
+                    // See if this is the first face on this cell we visit, and if
+                    // so resize the output array.
+                    if (heat_flux_and_area[cell->active_cell_index()].size() == 0)
+                      heat_flux_and_area[cell->active_cell_index()]
+                      .resize (cell->n_faces(), std::pair<double,double>(0.0,0.0));
+                    else
+                      Assert (heat_flux_and_area[cell->active_cell_index()].size() == cell->n_faces(),
+                              ExcInternalError());
+
+                    // Determine the type of boundary
+                    const unsigned int boundary_id = cell->face(f)->boundary_id();
+                    const bool prescribed_temperature = fixed_temperature_boundaries.find(boundary_id) != fixed_temperature_boundaries.end();
+                    const bool prescribed_heat_flux = fixed_heat_flux_boundaries.find(boundary_id) != fixed_heat_flux_boundaries.end();
+                    const bool non_tangential_velocity =
+                      tangential_velocity_boundaries.find(boundary_id) == tangential_velocity_boundaries.end() &&
+                      zero_velocity_boundaries.find(boundary_id) == zero_velocity_boundaries.end();
+
+                    fe_face_values.reinit (cell, f);
+
+                    // Integrate the face area
+                    for (unsigned int q=0; q<n_face_q_points; ++q)
+                      heat_flux_and_area[cell->active_cell_index()][f].second += fe_face_values.JxW(q);
+
+                    // Compute heat flux through Dirichlet boundaries by integrating the CBF solution vector
+                    if (prescribed_temperature)
+                      {
+                        fe_face_values[simulator_access.introspection().extractors.temperature].get_function_values(heat_flux_vector, heat_flux_values);
+
+                        for (unsigned int q=0; q<n_face_q_points; ++q)
+                          heat_flux_and_area[cell->active_cell_index()][f].first += heat_flux_values[q] *
+                                                                                    fe_face_values.JxW(q);
+                      }
+
+                    // if necessary, compute material properties for this face
+                    if (prescribed_heat_flux || non_tangential_velocity)
+                      {
+                        face_in.reinit(fe_face_values, cell, simulator_access.introspection(), simulator_access.get_solution());
+                        simulator_access.get_material_model().evaluate(face_in, face_out);
+
+                        if (simulator_access.get_parameters().formulation_temperature_equation ==
+                            Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+                          {
+                            for (unsigned int q=0; q<n_face_q_points; ++q)
+                              {
+                                face_out.densities[q] = simulator_access.get_adiabatic_conditions().density(face_in.position[q]);
+                              }
+                          }
+                      }
+
+                    // Compute heat flux through Neumann boundary by integrating the heat flux
+                    if (prescribed_heat_flux)
+                      {
+                        std::vector<Tensor<1,dim>> heat_flux(n_face_q_points);
+                        heat_flux = simulator_access.get_boundary_heat_flux().heat_flux(
+                                      boundary_id,
+                                      face_in,
+                                      face_out,
+                                      fe_face_values.get_normal_vectors()
+                                    );
+
+                        for (unsigned int q=0; q < n_face_q_points; ++q)
+                          {
+                            const double normal_heat_flux = heat_flux[q] * fe_face_values.normal_vector(q);
+                            const double JxW = fe_face_values.JxW(q);
+                            heat_flux_and_area[cell->active_cell_index()][f].first += normal_heat_flux * JxW;
+                          }
+                      }
+
+                    // Compute advective heat flux
+                    if (non_tangential_velocity)
+                      {
+                        for (unsigned int q=0; q<n_face_q_points; ++q)
+                          {
+                            heat_flux_and_area[cell->active_cell_index()][f].first += face_out.densities[q] *
+                                                                                      face_out.specific_heat[q] * face_in.temperature[q] *
+                                                                                      face_in.velocity[q] * fe_face_values.normal_vector(q) *
+                                                                                      fe_face_values.JxW(q);
+                          }
+                      }
+                  }
+            }
+        return heat_flux_and_area;
+      }
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    HeatFluxMap<dim>::execute (TableHandler &)
+    {
+      std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area =
+        internal::compute_heat_flux_through_boundary_faces (*this);
+
+      const auto boundary_ids = this->get_geometry_model().get_used_boundary_indicators();
+      for (const auto &boundary_id: boundary_ids)
+        if (this->get_geometry_model().translate_id_to_symbol_name(boundary_id) == "top" ||
+            this->get_geometry_model().translate_id_to_symbol_name(boundary_id) == "bottom")
+          output_to_file(boundary_id, heat_flux_and_area);
+
+      std::string placeholder_name = this->get_output_directory() + "heat_flux." + Utilities::int_to_string(this->get_timestep_number(), 5);
+      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
+        placeholder_name.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
+
+      return std::pair<std::string,std::string>("Writing heat flux map",
+                                                placeholder_name);
+    }
+
+
+
+    template <int dim>
+    void
+    HeatFluxMap<dim>::output_to_file(const types::boundary_id boundary_id,
+                                     const std::vector<std::vector<std::pair<double, double>>> &heat_flux_and_area)
+    {
+      // get boundary name and avoid spaces for file output
+      std::string boundary_name = this->get_geometry_model().translate_id_to_symbol_name(boundary_id);
+      std::replace(boundary_name.begin(), boundary_name.end(), ' ', '_');
+
+      std::ostringstream output;
+
+      // write the file header. note that we only do so on processor 0
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          output << "# "
+                 << ((dim==2)? "x y" : "x y z")
+                 << " heat_flux_" << boundary_name << std::endl;
+        }
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (const unsigned int f: cell->face_indices())
+            if (cell->at_boundary(f) &&
+                (cell->face(f)->boundary_id() == boundary_id))
+              {
+                // evaluate position of heat flow to write into output file
+                const bool respect_manifold = true;
+                const Point<dim> midpoint_at_surface = cell->face(f)->center(respect_manifold);
+
+                const double flux_density = heat_flux_and_area[cell->active_cell_index()][f].first /
+                                            heat_flux_and_area[cell->active_cell_index()][f].second;
+
+                output << std::setprecision(10)
+                       << midpoint_at_surface
+                       << ' '
+                       << std::setprecision(10)
+                       << flux_density
+                       << std::endl;
+              }
+
+      std::string filename = this->get_output_directory() +
+                             "heat_flux_" + boundary_name + "." +
+                             Utilities::int_to_string(this->get_timestep_number(), 5);
+      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
+        filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
+
+      Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace internal
+    {
+#define INSTANTIATE(dim) \
+  template LinearAlgebra::BlockVector compute_dirichlet_boundary_heat_flux_solution_vector (const SimulatorAccess<dim> &simulator_access);
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+
+    ASPECT_REGISTER_POSTPROCESSOR(HeatFluxMap,
+                                  "heat flux map",
+                                  "A postprocessor that computes the heat flux "
+                                  "density across each boundary in outward "
+                                  "direction, i.e., from the domain to the "
+                                  "outside. The heat flux is computed as sum "
+                                  "of advective heat flux and conductive heat "
+                                  "flux through Neumann boundaries, both "
+                                  "computed as integral over the boundary area, "
+                                  "and conductive heat flux through Dirichlet "
+                                  "boundaries, which is computed using the "
+                                  "consistent boundary flux method as described "
+                                  "in ``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
+                                  "The consistent Galerkin FEM for computing "
+                                  "derived boundary quantities in thermal and or "
+                                  "fluids problems. International Journal for "
+                                  "Numerical Methods in Fluids, 7(4), 371-394.''")
+  }
+}
diff --git a/source/postprocess/heat_flux_statistics.cc.bak b/source/postprocess/heat_flux_statistics.cc.bak
new file mode 100644
index 00000000000..e1c4110c748
--- /dev/null
+++ b/source/postprocess/heat_flux_statistics.cc.bak
@@ -0,0 +1,160 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/heat_flux_statistics.h>
+#include <aspect/postprocess/heat_flux_map.h>
+
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    HeatFluxStatistics<dim>::execute (TableHandler &statistics)
+    {
+      std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area =
+        internal::compute_heat_flux_through_boundary_faces (*this);
+
+      std::map<types::boundary_id, double> local_boundary_fluxes;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (const unsigned int f : cell->face_indices())
+            if (cell->at_boundary(f))
+              {
+                const types::boundary_id boundary_indicator
+                  = cell->face(f)->boundary_id();
+                local_boundary_fluxes[boundary_indicator] += heat_flux_and_area[cell->active_cell_index()][f].first;
+              }
+
+      // now communicate to get the global values
+      std::map<types::boundary_id, double> global_boundary_fluxes;
+      {
+        // first collect local values in the same order in which they are listed
+        // in the set of boundary indicators
+        const std::set<types::boundary_id>
+        boundary_indicators
+          = this->get_geometry_model().get_used_boundary_indicators ();
+        std::vector<double> local_values;
+        local_values.reserve(boundary_indicators.size());
+        for (const auto p : boundary_indicators)
+          local_values.emplace_back (local_boundary_fluxes[p]);
+
+        // then collect contributions from all processors
+        std::vector<double> global_values (local_values.size());
+        Utilities::MPI::sum (local_values, this->get_mpi_communicator(), global_values);
+
+        // and now take them apart into the global map again
+        unsigned int index = 0;
+        for (std::set<types::boundary_id>::const_iterator
+             p = boundary_indicators.begin();
+             p != boundary_indicators.end(); ++p, ++index)
+          global_boundary_fluxes[*p] = global_values[index];
+      }
+
+      // now add all of the computed heat fluxes to the statistics object
+      // and create a single string that can be output to the screen
+      std::ostringstream screen_text;
+      unsigned int index = 0;
+      for (std::map<types::boundary_id, double>::const_iterator
+           p = global_boundary_fluxes.begin();
+           p != global_boundary_fluxes.end(); ++p, ++index)
+        {
+          const std::string name = "Outward heat flux through boundary with indicator "
+                                   + Utilities::int_to_string(p->first)
+                                   + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                 .translate_id_to_symbol_name (p->first))
+                                   + " (W)";
+          statistics.add_value (name, p->second);
+
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (name, 8);
+          statistics.set_scientific (name, true);
+
+          // finally have something for the screen
+          screen_text.precision(4);
+          screen_text << p->second << " W"
+                      << (index == global_boundary_fluxes.size()-1 ? "" : ", ");
+        }
+
+      return std::pair<std::string, std::string> ("Heat fluxes through boundary parts:",
+                                                  screen_text.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(HeatFluxStatistics,
+                                  "heat flux statistics",
+                                  "A postprocessor that computes some "
+                                  "statistics about the heat flux "
+                                  "density across each boundary in outward "
+                                  "direction, i.e., from the domain to the "
+                                  "outside. The heat flux is computed as sum "
+                                  "of advective heat flux and conductive heat "
+                                  "flux through Neumann boundaries, both "
+                                  "computed as integral over the boundary area, "
+                                  "and conductive heat flux through Dirichlet "
+                                  "boundaries, which is computed using the "
+                                  "consistent boundary flux method as described "
+                                  "in ``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
+                                  "The consistent Galerkin FEM for computing "
+                                  "derived boundary quantities in thermal and or "
+                                  "fluids problems. International Journal for "
+                                  "Numerical Methods in Fluids, 7(4), 371-394.''"
+                                  "The point-wise heat flux can be obtained from the heat flux map postprocessor, "
+                                  "which outputs the heat flux to a file, or the heat flux map "
+                                  "visualization postprocessor, which outputs the heat flux for "
+                                  "visualization. "
+                                  "\n\n"
+                                  "As stated, this postprocessor computes the \\textit{outbound} heat "
+                                  "flux. If you "
+                                  "are interested in the opposite direction, for example from "
+                                  "the core into the mantle when the domain describes the "
+                                  "mantle, then you need to multiply the result by -1."
+                                  "\n\n"
+                                  ":::{note}\n"
+                                  "In geodynamics, the term ``heat flux'' is often understood "
+                                  "to be the quantity $- k \\nabla T$, which is really a heat "
+                                  "flux \\textit{density}, i.e., a vector-valued field. In contrast "
+                                  "to this, the current postprocessor only computes the integrated "
+                                  "flux over each part of the boundary. Consequently, the units of "
+                                  "the quantity computed here are $W=\\frac{J}{s}$.\n"
+                                  ":::"
+                                  "\n\n"
+                                  "The ``heat flux densities'' postprocessor computes the same "
+                                  "quantity as the one here, but divided by the area of "
+                                  "the surface.")
+  }
+}
diff --git a/source/postprocess/heating_statistics.cc.bak b/source/postprocess/heating_statistics.cc.bak
new file mode 100644
index 00000000000..92d4e91a3a5
--- /dev/null
+++ b/source/postprocess/heating_statistics.cc.bak
@@ -0,0 +1,166 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/postprocess/heating_statistics.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    HeatingStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the temperature element alone.
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_gradients |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, this->n_compositional_fields());
+      this->get_heating_model_manager().create_additional_material_model_inputs_and_outputs(in, out);
+
+      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+
+      const auto &heating_model_objects = this->get_heating_model_manager().get_active_heating_models();
+      const std::vector<std::string> &heating_model_names = this->get_heating_model_manager().get_active_heating_model_names();
+
+      HeatingModel::HeatingModelOutputs heating_model_outputs(n_q_points, this->n_compositional_fields());
+
+      std::ostringstream output;
+      output.precision(4);
+
+      double average_heating_integral = 0.0;
+      double total_heating_integral = 0.0;
+
+      std::vector<double> local_heating_integrals (heating_model_objects.size());
+      double local_mass = 0.0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+            this->get_material_model().fill_additional_material_model_inputs(in, this->get_solution(), fe_values, this->introspection());
+            this->get_material_model().evaluate(in, out);
+
+            if (this->get_parameters().formulation_temperature_equation
+                == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+              {
+                // Overwrite the density by the reference density coming from the
+                // adiabatic conditions as required by the formulation
+                for (unsigned int q=0; q<n_q_points; ++q)
+                  out.densities[q] = this->get_adiabatic_conditions().density(in.position[q]);
+              }
+            else if (this->get_parameters().formulation_temperature_equation
+                     == Parameters<dim>::Formulation::TemperatureEquation::real_density)
+              {
+                // use real density
+              }
+            else
+              AssertThrow(false, ExcNotImplemented());
+
+            for (unsigned int q=0; q<n_q_points; ++q)
+              local_mass += out.densities[q] * fe_values.JxW(q);
+
+            unsigned int index = 0;
+            for (typename std::list<std::unique_ptr<HeatingModel::Interface<dim>>>::const_iterator
+                 heating_model = heating_model_objects.begin();
+                 heating_model != heating_model_objects.end(); ++heating_model, ++index)
+              {
+                (*heating_model)->evaluate(in, out, heating_model_outputs);
+
+                for (unsigned int q=0; q<n_q_points; ++q)
+                  local_heating_integrals[index] += heating_model_outputs.heating_source_terms[q]
+                                                    * fe_values.JxW(q);
+              }
+          }
+
+      std::vector<double> global_heating_integrals (heating_model_objects.size());
+      double global_mass = 0.0;
+
+      // compute the sum over all processors
+      Utilities::MPI::sum (local_heating_integrals,
+                           this->get_mpi_communicator(),
+                           global_heating_integrals);
+      global_mass = Utilities::MPI::sum (local_mass, this->get_mpi_communicator());
+
+      unsigned int index = 0;
+      for (typename std::list<std::unique_ptr<HeatingModel::Interface<dim>>>::const_iterator
+           heating_model = heating_model_objects.begin();
+           heating_model != heating_model_objects.end(); ++heating_model, ++index)
+        {
+          // finally produce something for the statistics file
+          const std::string name1("Average " + heating_model_names[index] + " rate (W/kg)");
+          statistics.add_value (name1, global_heating_integrals[index]/global_mass);
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (name1, 8);
+          statistics.set_scientific (name1, true);
+
+          const std::string name2("Total " + heating_model_names[index] + " rate (W)");
+          statistics.add_value (name2, global_heating_integrals[index]);
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (name2, 8);
+          statistics.set_scientific (name2, true);
+
+          total_heating_integral += global_heating_integrals[index];
+        }
+
+      average_heating_integral = total_heating_integral/global_mass;
+
+      output << average_heating_integral << " W/kg, "
+             << total_heating_integral << " W";
+
+      return std::pair<std::string, std::string> ("Heating rate (average/total): ",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(HeatingStatistics,
+                                  "heating statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "heating, averaged by volume. ")
+  }
+}
diff --git a/source/postprocess/interface.cc.bak b/source/postprocess/interface.cc.bak
new file mode 100644
index 00000000000..40ae8ab7c28
--- /dev/null
+++ b/source/postprocess/interface.cc.bak
@@ -0,0 +1,414 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/utilities.h>
+
+#include <typeinfo>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+// ------------------------------ Interface -----------------------------
+
+    template <int dim>
+    std::list<std::string>
+    Interface<dim>::required_other_postprocessors() const
+    {
+      return {};
+    }
+
+
+
+    template <int dim>
+    void
+    Interface<dim>::save (std::map<std::string,std::string> &) const
+    {}
+
+
+
+    template <int dim>
+    void
+    Interface<dim>::load (const std::map<std::string,std::string> &)
+    {}
+
+
+
+// ------------------------------ Manager -----------------------------
+
+
+    template <int dim>
+    std::list<std::pair<std::string,std::string>>
+    Manager<dim>::execute (TableHandler &statistics)
+    {
+      // call the execute() functions of all postprocessor objects we have
+      // here in turns
+      std::list<std::pair<std::string,std::string>> output_list;
+      for (const auto &p : this->plugin_objects)
+        {
+          try
+            {
+              // first call the update() function.
+              p->update();
+
+              // call the execute() function. if it produces any output
+              // then add it to the list
+              std::pair<std::string,std::string> output
+                = p->execute (statistics);
+
+              if (output.first.size() + output.second.size() > 0)
+                output_list.push_back (output);
+            }
+          // postprocessors that throw exceptions usually do not result in
+          // anything good because they result in an unwinding of the stack
+          // and, if only one processor triggers an exception, the
+          // destruction of objects often causes a deadlock. thus, if
+          // an exception is generated, catch it, print an error message,
+          // and abort the program
+          catch (std::exception &exc)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running postprocessor <"
+                        << typeid(*p).name()
+                        << ">: " << std::endl
+                        << exc.what() << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+          catch (...)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running postprocessor <"
+                        << typeid(*p).name()
+                        << ">: " << std::endl;
+              std::cerr << "Unknown exception!" << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+        }
+
+      return  output_list;
+    }
+
+
+// -------------------------------- Deal with registering postprocessors and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // first declare the postprocessors we know about to
+      // choose from
+      prm.enter_subsection("Postprocess");
+      {
+        // construct a string for Patterns::MultipleSelection that
+        // contains the names of all registered postprocessors
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+        prm.declare_entry("List of postprocessors",
+                          "",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma separated list of postprocessor objects that should be run "
+                          "at the end of each time step. Some of these postprocessors will "
+                          "declare their own parameters which may, for example, include that "
+                          "they will actually do something only every so many time steps or "
+                          "years. Alternatively, the text `all' indicates that all available "
+                          "postprocessors should be run after each time step.\n\n"
+                          "The following postprocessors are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+      }
+      prm.leave_subsection();
+
+      // now declare the parameters of each of the registered
+      // postprocessors in turn
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      Assert (std::get<dim>(registered_plugins).plugins != nullptr,
+              ExcMessage ("No postprocessors registered!?"));
+
+      // first find out which postprocessors are requested
+      std::vector<std::string> postprocessor_names;
+      prm.enter_subsection("Postprocess");
+      {
+        postprocessor_names
+          = Utilities::split_string_list(prm.get("List of postprocessors"));
+        AssertThrow(Utilities::has_unique_entries(postprocessor_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Postprocess/List of postprocessors' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+      }
+      prm.leave_subsection();
+
+      // see if 'all' was selected (or is part of the list). if so
+      // simply replace the list with one that contains all names
+      if (std::find (postprocessor_names.begin(),
+                     postprocessor_names.end(),
+                     "all") != postprocessor_names.end())
+        {
+          postprocessor_names.clear();
+          for (typename std::list<typename aspect::internal::Plugins::PluginList<Interface<dim>>::PluginInfo>::const_iterator
+               p = std::get<dim>(registered_plugins).plugins->begin();
+               p != std::get<dim>(registered_plugins).plugins->end(); ++p)
+            postprocessor_names.push_back (std::get<0>(*p));
+        }
+
+      // see if the user specified "global statistics" somewhere; if so, remove
+      // it from the list because we will *always* want to have it and so
+      // whether or not it has been explicitly provided by the user makes no
+      // difference.
+      std::vector<std::string>::iterator new_end
+        = std::remove (postprocessor_names.begin(),
+                       postprocessor_names.end(),
+                       "global statistics");
+      if (new_end != postprocessor_names.end())
+        postprocessor_names.erase (new_end, postprocessor_names.end());
+
+      // in any case, put the global statistics postprocessor at the front:
+      postprocessor_names.insert(postprocessor_names.begin(), "global statistics");
+
+      // then go through the list, create objects and let them parse
+      // their own parameters
+      for (unsigned int name=0; name<postprocessor_names.size(); ++name)
+        {
+          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
+                                          (std::get<dim>(registered_plugins)
+                                           .create_plugin (postprocessor_names[name],
+                                                           "Postprocessor plugins")));
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
+            sim->initialize_simulator (this->get_simulator());
+
+          this->plugin_objects.back()->parse_parameters (prm);
+          this->plugin_objects.back()->initialize ();
+
+          // now see if the newly created postprocessor relies on others. if so,
+          // go through the list of the ones we already have and if the required
+          // ones are new, add them to the end of the list we work through
+          const std::list<std::string> additional_postprocessors
+            = this->plugin_objects.back()->required_other_postprocessors ();
+
+          for (const auto &p : additional_postprocessors)
+            {
+              AssertThrow (Patterns::Selection(std::get<dim>(registered_plugins).get_pattern_of_names ())
+                           .match (p) == true,
+                           ExcMessage ("Postprocessor <" + postprocessor_names[name] +
+                                       "> states that it depends on another postprocessor, <"
+                                       + p +
+                                       ">, but the latter is not a valid name."));
+
+              bool already_present = false;
+              for (const auto &postprocessor_name : postprocessor_names)
+                if (postprocessor_name == p)
+                  {
+                    already_present = true;
+                    break;
+                  }
+
+              if (already_present == false)
+                postprocessor_names.push_back (p);
+            }
+        }
+      Assert (postprocessor_names.size() == this->plugin_objects.size(),
+              ExcInternalError());
+
+      // we now have matching lists 'this->plugin_objects' and 'postprocessor_names'
+      // that define which postprocessors we have. we just need to bring them
+      // into an order so that dependencies run first, and dependents after
+      // them. the algorithm for creating a sorted list for this works as follows:
+      //
+      // while there are postprocessors not yet added to the sorted list:
+      // - go through the list
+      // - if we encounter a postprocessor that has not yet been added yet:
+      //   . if all of its dependencies are in the list, add it to the end
+      //   . if at least one of its dependencies are not yet in the list,
+      //     skip it
+      //
+      // if we go through a loop where we do not add a postprocessor to the list
+      // but there are still ones that haven't been added to the list, then we
+      // have found a cycle in the dependencies and that is clearly a problem
+      std::vector<bool> already_assigned (this->plugin_objects.size(), false);
+      std::vector<std::string> sorted_names;
+      std::list<std::unique_ptr<Interface<dim>>> sorted_postprocessors;
+      while (sorted_names.size() < this->plugin_objects.size())
+        {
+          bool at_least_one_element_added = false;
+
+          {
+            typename std::list<std::unique_ptr<Interface<dim>>>::iterator
+            pp = this->plugin_objects.begin();
+            for (unsigned int i=0; i<postprocessor_names.size(); ++i, ++pp)
+              if (already_assigned[i] == false)
+                {
+                  // for this postprocessor, check if all of its dependencies
+                  // are already in the list
+                  const std::list<std::string> deps = (*pp)->required_other_postprocessors();
+                  bool unmet_dependencies = false;
+                  for (const auto &p : deps)
+                    if (std::find (sorted_names.begin(),
+                                   sorted_names.end(),
+                                   p) == sorted_names.end())
+                      {
+                        unmet_dependencies = true;
+                        break;
+                      }
+
+                  // if we have unmet dependencies, there is nothing we can do
+                  // right now for this postprocessor (but we will come back for it)
+                  //
+                  // if there are none, add this postprocessor. using move semantics
+                  // removes the postprocessor from the 'this->plugin_objects' array,
+                  // which is ok since we will swap the two arrays at the end of the
+                  // function.
+                  if (unmet_dependencies == false)
+                    {
+                      sorted_names.push_back (postprocessor_names[i]);
+                      sorted_postprocessors.emplace_back (std::move(*pp));
+                      already_assigned[i] = true;
+                      at_least_one_element_added = true;
+                    }
+                }
+          }
+
+          // check that we have added at least one element; if not, there is a cycle
+          if (at_least_one_element_added == false)
+            {
+              std::ostringstream out;
+              out << "While sorting postprocessors by their dependencies, "
+                  "ASPECT encountered a cycle in dependencies. The following "
+                  "postprocessors are involved:\n";
+              typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
+              pp = this->plugin_objects.begin();
+              for (unsigned int i=0; i<postprocessor_names.size(); ++i, ++pp)
+                if (already_assigned[i] == false)
+                  {
+                    out << "  " << postprocessor_names[i] << " -> ";
+                    const std::list<std::string> deps = (*pp)->required_other_postprocessors();
+                    for (const auto &p : deps)
+                      out << "'" << p << "' ";
+                    out << std::endl;
+                  }
+              AssertThrow (false, ExcMessage(out.str()));
+            }
+        }
+      Assert (postprocessor_names.size() == sorted_names.size(),
+              ExcInternalError());
+      Assert (sorted_postprocessors.size() == sorted_names.size(),
+              ExcInternalError());
+      Assert (std::find (already_assigned.begin(), already_assigned.end(), false) == already_assigned.end(),
+              ExcInternalError());
+
+      // finally swap the unsorted list with the sorted list and only
+      // keep the latter
+      this->plugin_objects.swap (sorted_postprocessors);
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_postprocessor (const std::string &name,
+                                          const std::string &description,
+                                          void (*declare_parameters_function) (ParameterHandler &),
+                                          std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Postprocessor interface",
+                                                            out);
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<Postprocess::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<Postprocess::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<Postprocess::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<Postprocess::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace Postprocess
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/postprocess/load_balance_statistics.cc.bak b/source/postprocess/load_balance_statistics.cc.bak
new file mode 100644
index 00000000000..2749d974c50
--- /dev/null
+++ b/source/postprocess/load_balance_statistics.cc.bak
@@ -0,0 +1,111 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/load_balance_statistics.h>
+
+#include <aspect/particle/world.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    LoadBalanceStatistics<dim>::execute (TableHandler &statistics)
+    {
+      const unsigned int locally_owned_active_cells = this->get_triangulation().n_locally_owned_active_cells();
+      const dealii::Utilities::MPI::MinMaxAvg cell_distribution
+        = dealii::Utilities::MPI::min_max_avg(locally_owned_active_cells,
+                                              this->get_mpi_communicator());
+
+      statistics.add_value ("Minimal cells per process",
+                            static_cast<unsigned int>(cell_distribution.min));
+      statistics.add_value ("Maximal cells per process",
+                            static_cast<unsigned int>(cell_distribution.max));
+      statistics.add_value ("Average cells per process",
+                            cell_distribution.avg);
+
+      if (this->n_particle_worlds() > 0)
+        {
+          const unsigned int locally_owned_particles = this->get_particle_world(0).
+                                                       get_particle_handler().n_locally_owned_particles();
+          const dealii::Utilities::MPI::MinMaxAvg particles_per_process =
+            dealii::Utilities::MPI::min_max_avg(locally_owned_particles,this->get_mpi_communicator());
+
+          statistics.add_value ("Minimal particles per process",
+                                static_cast<unsigned int>(particles_per_process.min));
+          statistics.add_value ("Maximal particles per process",
+                                static_cast<unsigned int>(particles_per_process.max));
+          statistics.add_value ("Average particles per process",
+                                particles_per_process.avg);
+
+          const double local_ratio = (locally_owned_active_cells != 0)
+                                     ?
+                                     static_cast<double>(locally_owned_particles)
+                                     / static_cast<double>(locally_owned_active_cells)
+                                     :
+                                     0.0;
+
+          const dealii::Utilities::MPI::MinMaxAvg particle_to_cell_ratio
+            = dealii::Utilities::MPI::min_max_avg(local_ratio,
+                                                  this->get_mpi_communicator());
+
+          statistics.add_value ("Minimal local particle to cell ratio", particle_to_cell_ratio.min);
+          statistics.add_value ("Maximal local particle to cell ratio", particle_to_cell_ratio.max);
+          statistics.add_value ("Average local particle to cell ratio", particle_to_cell_ratio.avg);
+        }
+
+      std::ostringstream output;
+      output.precision(4);
+      output << cell_distribution.min << '/'
+             << cell_distribution.max << '/'
+             << cell_distribution.avg;
+
+      return std::pair<std::string, std::string> ("Cells per process min/max/avg:",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(LoadBalanceStatistics,
+                                  "load balance statistics",
+                                  "A postprocessor that computes statistics about "
+                                  "the distribution of cells, and if present particles "
+                                  "across subdomains. "
+                                  "In particular, it computes maximal, average and "
+                                  "minimal number of cells across all ranks. "
+                                  "If there are particles it also computes the "
+                                  "maximal, average, and minimum number of particles across "
+                                  "all ranks, and maximal, average, and minimal ratio "
+                                  "between local number of particles and local number "
+                                  "of cells across all processes. All of these numbers "
+                                  "can be useful to assess the load balance between "
+                                  "different MPI ranks, as the difference between the "
+                                  "minimal and maximal load should be as small as "
+                                  "possible.")
+  }
+}
diff --git a/source/postprocess/mass_flux_statistics.cc.bak b/source/postprocess/mass_flux_statistics.cc.bak
new file mode 100644
index 00000000000..55f09956ba6
--- /dev/null
+++ b/source/postprocess/mass_flux_statistics.cc.bak
@@ -0,0 +1,188 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/mass_flux_statistics.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    MassFluxStatistics<dim>::execute (TableHandler &statistics)
+    {
+      const std::string unit = (this->convert_output_to_years())
+                               ?
+                               "kg/yr"
+                               :
+                               "kg/s";
+      const double in_years = (this->convert_output_to_years())
+                              ?
+                              year_in_seconds
+                              :
+                              1.0;
+
+      // create a quadrature formula based on the temperature element alone.
+      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.velocities;
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula,
+                                        update_values            | update_gradients |
+                                        update_normal_vectors    |
+                                        update_quadrature_points | update_JxW_values);
+
+      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+
+      std::map<types::boundary_id, double> local_boundary_fluxes;
+
+      MaterialModel::MaterialModelInputs<dim> in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::density;
+
+      // for every surface face on which it makes sense to compute a
+      // mass flux and that is owned by this processor,
+      // integrate the normal mass flux given by the formula
+      //   j =  \rho * v * n
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (const unsigned int f : cell->face_indices())
+            if (cell->at_boundary(f))
+              {
+                fe_face_values.reinit (cell, f);
+                // Set use_strain_rates to false since we don't need viscosity
+                in.reinit(fe_face_values, cell, this->introspection(), this->get_solution());
+
+                this->get_material_model().evaluate(in, out);
+
+
+                double local_normal_flux = 0;
+                for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                  {
+                    local_normal_flux
+                    +=
+                      out.densities[q]
+                      * (in.velocity[q] * fe_face_values.normal_vector(q))
+                      * fe_face_values.JxW(q);
+                  }
+
+                const types::boundary_id boundary_indicator
+                  = cell->face(f)->boundary_id();
+                local_boundary_fluxes[boundary_indicator] += local_normal_flux * in_years;
+              }
+
+      // now communicate to get the global values
+      std::map<types::boundary_id, double> global_boundary_fluxes;
+      {
+        // first collect local values in the same order in which they are listed
+        // in the set of boundary indicators
+        const std::set<types::boundary_id>
+        boundary_indicators
+          = this->get_geometry_model().get_used_boundary_indicators ();
+        std::vector<double> local_values;
+        local_values.reserve(boundary_indicators.size());
+        for (const auto p : boundary_indicators)
+          local_values.push_back (local_boundary_fluxes[p]);
+
+        // then collect contributions from all processors
+        std::vector<double> global_values (local_values.size());
+        Utilities::MPI::sum (local_values, this->get_mpi_communicator(), global_values);
+
+        // and now take them apart into the global map again
+        unsigned int index = 0;
+        for (std::set<types::boundary_id>::const_iterator
+             p = boundary_indicators.begin();
+             p != boundary_indicators.end(); ++p, ++index)
+          global_boundary_fluxes[*p] = global_values[index];
+      }
+
+      // now add all of the computed mass fluxes to the statistics object
+      // and create a single string that can be output to the screen
+      std::ostringstream screen_text;
+      unsigned int index = 0;
+      for (std::map<types::boundary_id, double>::const_iterator
+           p = global_boundary_fluxes.begin();
+           p != global_boundary_fluxes.end(); ++p, ++index)
+        {
+          const std::string name = "Outward mass flux through boundary with indicator "
+                                   + Utilities::int_to_string(p->first)
+                                   + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                 .translate_id_to_symbol_name (p->first))
+                                   + " (" + unit + ")";
+          statistics.add_value (name, p->second);
+
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (name, 8);
+          statistics.set_scientific (name, true);
+
+          // finally have something for the screen
+          screen_text.precision(4);
+          screen_text << p->second << ' ' << unit
+                      << (index == global_boundary_fluxes.size()-1 ? "" : ", ");
+        }
+
+      return std::pair<std::string, std::string> ("Mass fluxes through boundary parts:",
+                                                  screen_text.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(MassFluxStatistics,
+                                  "mass flux statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the mass flux across boundaries. For each boundary "
+                                  "indicator (see your geometry description for which boundary "
+                                  "indicators are used), the mass flux is computed in outward "
+                                  "direction, i.e., from the domain to the outside, using the "
+                                  "formula $\\int_{\\Gamma_i} \\rho \\mathbf v \\cdot \\mathbf n$ "
+                                  "where $\\Gamma_i$ is the part of the boundary with indicator $i$, "
+                                  "$\\rho$ is the density as reported by the material model, "
+                                  "$\\mathbf v$ is the velocity, and $\\mathbf n$ is the outward normal. "
+                                  "\n\n"
+                                  "As stated, this postprocessor computes the \\textit{outbound} mass "
+                                  "flux. If you "
+                                  "are interested in the opposite direction, for example from "
+                                  "the core into the mantle when the domain describes the "
+                                  "mantle, then you need to multiply the result by -1."
+                                  "\n\n"
+                                  ":::{note}\n"
+                                  "In geodynamics, the term ``mass flux'' is often understood "
+                                  "to be the quantity $\\rho \\mathbf v$, which is really a mass "
+                                  "flux \\textit{density}, i.e., a vector-valued field. In contrast "
+                                  "to this, the current postprocessor only computes the integrated "
+                                  "flux over each part of the boundary. Consequently, the units of "
+                                  "the quantity computed here are $\\frac{kg}{s}$.\n"
+                                  ":::")
+  }
+}
diff --git a/source/postprocess/material_statistics.cc.bak b/source/postprocess/material_statistics.cc.bak
new file mode 100644
index 00000000000..9c7f6157417
--- /dev/null
+++ b/source/postprocess/material_statistics.cc.bak
@@ -0,0 +1,128 @@
+/*
+  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/material_statistics.h>
+#include <aspect/material_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    MaterialStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the temperature element alone.
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_gradients |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::density | MaterialModel::MaterialProperties::viscosity;
+
+      double local_volume = 0.0;
+      double local_mass = 0.0;
+      double local_viscosity = 0.0;
+
+      // compute the integral quantities by quadrature
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+            this->get_material_model().fill_additional_material_model_inputs(in, this->get_solution(), fe_values, this->introspection());
+            this->get_material_model().evaluate(in, out);
+
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                local_mass += out.densities[q] * fe_values.JxW(q);
+                local_viscosity += out.viscosities[q] * fe_values.JxW(q);
+                local_volume += fe_values.JxW(q);
+              }
+          }
+
+      // compute the sum over all processors
+      const double global_mass = Utilities::MPI::sum (local_mass, this->get_mpi_communicator());
+      const double global_viscosity = Utilities::MPI::sum (local_viscosity, this->get_mpi_communicator());
+      const double global_volume = Utilities::MPI::sum (local_volume, this->get_mpi_communicator());
+      const double average_density = global_mass / global_volume;
+      const double average_viscosity = global_viscosity / global_volume;
+
+      const std::string name1("Average density (kg/m^3)");
+      statistics.add_value (name1, average_density);
+      statistics.set_precision (name1, 8);
+      statistics.set_scientific (name1, true);
+
+      const std::string name2("Average viscosity (Pa s)");
+      statistics.add_value (name2, average_viscosity);
+      statistics.set_precision (name2, 8);
+      statistics.set_scientific (name2, true);
+
+      const std::string name3("Total mass (kg)");
+      statistics.add_value (name3, global_mass);
+      statistics.set_precision (name3, 8);
+      statistics.set_scientific (name3, true);
+
+      std::ostringstream output;
+      output.precision(4);
+
+      output << average_density << " kg/m^3, "
+             << average_viscosity << " Pa s, "
+             << global_mass << " kg";
+
+      return std::pair<std::string, std::string> ("Average density / Average viscosity / Total mass: ",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(MaterialStatistics,
+                                  "material statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the material properties. In particular, it computes the "
+                                  "volume-averages of the density and viscosity, and the "
+                                  "total mass in the model. Specifically, it implements "
+                                  "the following formulas in each time step: "
+                                  "$\\left<\\rho\\right> = \\frac{1}{|\\Omega|} \\int_\\Omega \\rho(\\mathbf x) \\, \\text{d}x$, "
+                                  "$\\left<\\eta\\right> = \\frac{1}{|\\Omega|} \\int_\\Omega \\eta(\\mathbf x) \\, \\text{d}x$, "
+                                  "$M = \\int_\\Omega \\rho(\\mathbf x) \\, \\text{d}x$, "
+                                  "where $|\\Omega|$ is the volume of the domain.")
+  }
+}
diff --git a/source/postprocess/matrix_statistics.cc.bak b/source/postprocess/matrix_statistics.cc.bak
new file mode 100644
index 00000000000..89409b70b32
--- /dev/null
+++ b/source/postprocess/matrix_statistics.cc.bak
@@ -0,0 +1,119 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/matrix_statistics.h>
+
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+
+
+namespace
+{
+  const std::string
+  get_stats(const aspect::LinearAlgebra::BlockSparseMatrix &matrix,
+            const std::string &matrix_name,
+            const MPI_Comm comm)
+  {
+    std::ostringstream output;
+
+    // convert from bytes into Mb
+    const double mb = 1024*1024;
+    // sum up local matrix memory usage
+    double global_matrix_memory_consumption = dealii::Utilities::MPI::sum(matrix.memory_consumption(),
+                                                                          comm);
+    output << "\nTotal " << matrix_name << " memory consumption: "
+           << std::fixed << std::setprecision(2) << global_matrix_memory_consumption/mb
+           << " MB." << std::endl;
+
+    // output number of nonzero elements in matrix. Do so with 1000s separator
+    // since they are frequently large; this was previously done by using the empty
+    // string locale, but creating std::locale with an empty string caused problems
+    // on some platforms, so the functionality to catch the exception and ignore
+    // is kept here, even though explicitly setting a facet should always work.
+    try
+      {
+        // Imbue the stream with a locale that does the right thing. The
+        // locale is responsible for later deleting the object pointed
+        // to by the last argument (the "facet"), see
+        // https://en.cppreference.com/w/cpp/locale/locale/locale
+        output.imbue(std::locale(std::locale(),
+                                 new aspect::Utilities::ThousandSep));
+      }
+    catch (const std::runtime_error &e)
+      {
+        // If the locale doesn't work, just give up
+      }
+
+
+    output << "Total " << matrix_name << " nnz: "
+           << matrix.n_nonzero_elements() << std::endl;
+
+    // output number of nonzero elements in each matrix block
+    output << matrix_name << " nnz by block: " << std::endl;
+    for (unsigned int i=0; i<matrix.n_block_rows(); ++i)
+      {
+        for (unsigned int j=0; j<matrix.n_block_rows(); ++j)
+          output << std::setw(12) << matrix.block(i,j).n_nonzero_elements();
+        output << std::endl;
+      }
+
+    return output.str();
+  }
+}
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    MatrixStatistics<dim>::execute (TableHandler &)
+    {
+      std::ostringstream output;
+      output << get_stats(this->get_system_matrix(),
+                          "system matrix",
+                          this->get_mpi_communicator());
+      output << get_stats(this->get_system_preconditioner_matrix(),
+                          "system preconditioner matrix",
+                          this->get_mpi_communicator());
+
+      return std::pair<std::string, std::string> ("",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(MatrixStatistics,
+                                  "matrix statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the matrices. "
+                                  "In particular, it outputs total memory consumption, "
+                                  "total non-zero elements, and non-zero elements per "
+                                  "block, for system matrix and system preconditioner matrix.")
+  }
+}
diff --git a/source/postprocess/max_depth_field.cc.bak b/source/postprocess/max_depth_field.cc.bak
new file mode 100644
index 00000000000..d0cba1d2a56
--- /dev/null
+++ b/source/postprocess/max_depth_field.cc.bak
@@ -0,0 +1,131 @@
+/*
+  Copyright (C) 2021 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/max_depth_field.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    MaxDepthField<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the compositional element alone.
+      // be defensive about determining that a compositional field actually exists
+      AssertThrow(this->n_compositional_fields() > 0,
+                  ExcMessage("This postprocessor cannot be used without compositional fields."));
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.compositional_fields;
+
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points);
+
+      std::vector<double> compositional_values(n_q_points);
+      std::vector<Point<dim>> position_values(n_q_points);
+
+      std::vector<double> local_max_depth(this->n_compositional_fields(), std::numeric_limits<double>::lowest());
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+
+            position_values = fe_values.get_quadrature_points();
+
+            for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+              {
+                fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(), compositional_values);
+
+                for (unsigned int q = 0; q < n_q_points; ++q)
+                  {
+                    const double depth = this->get_geometry_model().depth(position_values[q]);
+                    if (compositional_values[q] >= 0.5 && depth > local_max_depth[c])
+                      local_max_depth[c] = depth;
+                  }
+              }
+          }
+
+      // compute the max over all processors
+      std::vector<double> global_max_depth(this->n_compositional_fields());
+      Utilities::MPI::max (local_max_depth,
+                           this->get_mpi_communicator(),
+                           global_max_depth);
+
+      // finally produce something for the statistics file
+      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+        {
+          statistics.add_value("Max depth [m] for composition " + this->introspection().name_for_compositional_index(c),
+                               global_max_depth[c]);
+        }
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+        {
+          const std::string columns[] = {"Max depth [m] for composition " + this->introspection().name_for_compositional_index(c)};
+          for (const auto &col: columns)
+            {
+              statistics.set_precision(col, 8);
+              statistics.set_scientific(col, true);
+            }
+        }
+
+      std::ostringstream output;
+      output.precision(4);
+      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
+        {
+          output << global_max_depth[c];
+          if (c + 1 != this->n_compositional_fields())
+            output << " // ";
+        }
+      return std::pair<std::string, std::string>("Compositions max depth [m]:",
+                                                 output.str());
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(MaxDepthField,
+                                  "maximum depth of field",
+                                  "A postprocessor that for each compositional field "
+                                  "outputs the largest depth at which "
+                                  "a quadrature point is found where the field "
+                                  "has a value of 0.5 or larger. For fields that do not "
+                                  "represent materials, but for example track a certain quantity "
+                                  "like strain, this value of 0.5 does not necessarily make sense. ")
+  }
+}
diff --git a/source/postprocess/melt_statistics.cc.bak b/source/postprocess/melt_statistics.cc.bak
new file mode 100644
index 00000000000..22bb2ce3829
--- /dev/null
+++ b/source/postprocess/melt_statistics.cc.bak
@@ -0,0 +1,152 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/postprocess/melt_statistics.h>
+#include <aspect/melt.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    MeltStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the temperature element alone.
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
+      const unsigned int n_q_points = quadrature_formula.size();
+      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),
+                                                            std::vector<double> (n_q_points));
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_gradients |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
+
+      std::ostringstream output;
+      output.precision(4);
+
+      double local_melt_integral = 0.0;
+      double local_min_melt = std::numeric_limits<double>::max();
+      double local_max_melt = std::numeric_limits<double>::lowest();
+
+      // compute the integral quantities by quadrature
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            // fill material model inputs
+            fe_values.reinit (cell);
+            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+            // we can only postprocess melt fractions if the material model that is used
+            // in the simulation has implemented them
+            // otherwise, set them to zero
+            std::vector<double> melt_fractions(n_q_points, 0.0);
+            if (MaterialModel::MeltFractionModel<dim>::is_melt_fraction_model(this->get_material_model()))
+              MaterialModel::MeltFractionModel<dim>::as_melt_fraction_model(this->get_material_model())
+              .melt_fractions(in, melt_fractions);
+
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                local_melt_integral += melt_fractions[q] * fe_values.JxW(q);
+                local_min_melt       = std::min(local_min_melt, melt_fractions[q]);
+                local_max_melt       = std::max(local_max_melt, melt_fractions[q]);
+              }
+
+          }
+
+      const double global_melt_integral
+        = Utilities::MPI::sum (local_melt_integral, this->get_mpi_communicator());
+      double global_min_melt = 0;
+      double global_max_melt = 0;
+
+      // now do the reductions that are
+      // min/max operations. do them in
+      // one communication by multiplying
+      // one value by -1
+      {
+        double local_values[2] = { -local_min_melt, local_max_melt };
+        double global_values[2];
+
+        Utilities::MPI::max (local_values, this->get_mpi_communicator(), global_values);
+
+        global_min_melt = -global_values[0];
+        global_max_melt = global_values[1];
+      }
+
+
+      // finally produce something for the statistics file
+      statistics.add_value ("Minimal melt fraction",
+                            global_min_melt);
+      statistics.add_value ("Total melt volume",
+                            global_melt_integral);
+      statistics.add_value ("Maximal melt fraction",
+                            global_max_melt);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      {
+        const char *columns[] = { "Minimal melt fraction",
+                                  "Total melt volume",
+                                  "Maximal melt fraction"
+                                };
+        for (auto &column : columns)
+          {
+            statistics.set_precision (column, 8);
+            statistics.set_scientific (column, true);
+          }
+      }
+
+      output << global_min_melt << ", "
+             << global_melt_integral << ", "
+             << global_max_melt;
+
+      return std::pair<std::string, std::string> ("Melt fraction min/total/max:",
+                                                  output.str());
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(MeltStatistics,
+                                  "melt statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the melt (volume) fraction. If the material model "
+                                  "does not implement a melt fraction function, the output is "
+                                  "set to zero.")
+  }
+}
diff --git a/source/postprocess/memory_statistics.cc.bak b/source/postprocess/memory_statistics.cc.bak
new file mode 100644
index 00000000000..4bab32297b7
--- /dev/null
+++ b/source/postprocess/memory_statistics.cc.bak
@@ -0,0 +1,141 @@
+/*
+ Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/postprocess/memory_statistics.h>
+#include <aspect/simulator.h>
+#include <aspect/stokes_matrix_free.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    MemoryStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // memory consumption:
+      const double mb = 1024*1024; // convert from bytes into mb
+
+      statistics.add_value ("System matrix memory consumption (MB) ", this->get_system_matrix().memory_consumption()/mb);
+      statistics.add_value ("Triangulation memory consumption (MB) ", this->get_triangulation().memory_consumption()/mb);
+      statistics.add_value ("p4est memory consumption (MB) ", this->get_triangulation().memory_consumption_p4est()/mb);
+
+      double dof_handler_mem = this->get_dof_handler().memory_consumption();
+      double constraints_mem = this->get_current_constraints().memory_consumption();
+      if (this->is_stokes_matrix_free())
+        {
+          dof_handler_mem += this->get_stokes_matrix_free().get_dof_handler_v().memory_consumption()
+                             + this->get_stokes_matrix_free().get_dof_handler_p().memory_consumption();
+
+          dof_handler_mem  += this->get_stokes_matrix_free().get_dof_handler_projection().memory_consumption();
+
+          constraints_mem += this->get_stokes_matrix_free().get_constraints_v().memory_consumption()
+                             + this->get_stokes_matrix_free().get_constraints_p().memory_consumption();
+        }
+      statistics.add_value ("DoFHandler memory consumption (MB) ", dof_handler_mem/mb);
+      statistics.add_value ("AffineConstraints<double> memory consumption (MB) ", constraints_mem/mb);
+
+      statistics.add_value ("Solution vector memory consumption (MB) ", this->get_solution().memory_consumption()/mb);
+
+      if (this->is_stokes_matrix_free())
+        {
+          const double mg_transfer_mem = this->get_stokes_matrix_free().get_mg_transfer_A().memory_consumption()
+                                         + this->get_stokes_matrix_free().get_mg_transfer_S().memory_consumption();
+          statistics.add_value ("MGTransfer memory consumption (MB) ", mg_transfer_mem/mb);
+
+          const double cell_data_mem = this->get_stokes_matrix_free().get_cell_data_memory_consumption();
+          statistics.add_value ("Matrix-free cell data memory consumption (MB) ", cell_data_mem/mb);
+        }
+
+      if (output_vmpeak)
+        {
+          // allow disabling of the output because this is not stable in automated tests:
+          dealii::Utilities::System::MemoryStats stats;
+          dealii::Utilities::System::get_memory_stats(stats);
+          const double max_vmpeak = dealii::Utilities::MPI::max(stats.VmPeak/1024.0, this->get_mpi_communicator());
+          statistics.add_value ("Peak virtual memory usage (VmPeak) (MB) ", max_vmpeak);
+        }
+
+      std::ostringstream output;
+      output << std::fixed << std::setprecision(2) << this->get_system_matrix().memory_consumption()/mb << " MB";
+
+      return std::pair<std::string, std::string> ("System matrix memory consumption: ",
+                                                  output.str());
+
+    }
+
+
+
+
+    template <int dim>
+    void
+    MemoryStatistics<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Memory statistics");
+        {
+          prm.declare_entry ("Output peak virtual memory (VmPeak)", "true",
+                             Patterns::Bool(),
+                             "If set to 'true', also output the peak virtual memory "
+                             "usage (computed as the maximum over all processors).");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    MemoryStatistics<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Memory statistics");
+        {
+          output_vmpeak = prm.get_bool ("Output peak virtual memory (VmPeak)");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(MemoryStatistics,
+                                  "memory statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the memory consumption. "
+                                  "In particular, it computes the memory usage of the "
+                                  "system matrix, triangulation, p4est, "
+                                  "DoFHandler, current constraints, solution vector, "
+                                  "and peak virtual memory usage, all in MB. "
+                                  "It also outputs the memory usage of the system "
+                                  "matrix to the screen.")
+  }
+}
diff --git a/source/postprocess/mobility_statistics.cc.bak b/source/postprocess/mobility_statistics.cc.bak
new file mode 100644
index 00000000000..f403f11a98c
--- /dev/null
+++ b/source/postprocess/mobility_statistics.cc.bak
@@ -0,0 +1,156 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/postprocess/mobility_statistics.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/geometry_model/spherical_shell.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    MobilityStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula for the velocity for the volume of cells
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
+
+      // create a quadrature formula for the velocity for the surface of cells
+      const Quadrature<dim-1> &quadrature_formula_face
+        = this->introspection().face_quadratures.velocities;
+      const unsigned int n_q_points_face = quadrature_formula_face.size();
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula_face,
+                                        update_values |
+                                        update_JxW_values |
+                                        update_quadrature_points);
+
+      std::vector<Tensor<1,dim>> surface_velocity_values (n_q_points_face);
+
+      double local_velocity_square_integral = 0;
+      double local_velocity_square_integral_top_boundary = 0;
+      double local_top_boundary_area = 0;
+
+      const std::set<types::boundary_id>
+      boundary_indicators
+        = this->get_geometry_model().get_used_boundary_indicators ();
+      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            // extract velocities
+            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                                                                                        velocity_values);
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                local_velocity_square_integral += velocity_values[q].norm_square() *
+                                                  fe_values.JxW(q);
+              }
+
+            // now for the surface cells only
+            for (const unsigned int f : cell->face_indices())
+              if (cell->face(f)->boundary_id() == top_boundary_id)
+                {
+                  fe_face_values.reinit (cell, f);
+                  // extract velocities
+                  fe_face_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                      surface_velocity_values);
+
+                  // determine the squared velocity on the face
+                  for (unsigned int q = 0; q < n_q_points_face; ++q)
+                    {
+                      const double JxW = fe_face_values.JxW(q);
+                      local_velocity_square_integral_top_boundary += surface_velocity_values[q].norm_square() * JxW;
+                      local_top_boundary_area += JxW;
+                    }
+                }
+          }
+
+      // now communicate to get the global values and convert to rms
+      const double global_velocity_square_integral
+        = Utilities::MPI::sum (local_velocity_square_integral, this->get_mpi_communicator());
+
+      const double global_rms_vel = std::sqrt(global_velocity_square_integral) /
+                                    std::sqrt(this->get_volume());
+
+      const double global_top_velocity_square_integral = Utilities::MPI::sum(local_velocity_square_integral_top_boundary, this->get_mpi_communicator());
+      const double global_top_boundary_area_integral = Utilities::MPI::sum(local_top_boundary_area, this->get_mpi_communicator());
+
+      const double global_top_rms_vel = std::sqrt(global_top_velocity_square_integral) /
+                                        std::sqrt(global_top_boundary_area_integral);
+
+      // now add the computed rms velocities to the statistics object
+      // and create a single string that can be output to the screen
+      const double mobility  = global_top_rms_vel / global_rms_vel;
+      const std::string name_mobility = "Mobility";
+
+      statistics.add_value (name_mobility,
+                            mobility);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      statistics.set_precision (name_mobility, 8);
+      statistics.set_scientific (name_mobility, true);
+
+      std::ostringstream output;
+      output.precision(3);
+      output << mobility;
+
+      return std::pair<std::string, std::string> ("Mobility:",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(MobilityStatistics,
+                                  "mobility statistics",
+                                  "A postprocessor that computes some statistics about mobility "
+                                  "following Tackley (2000) and Lourenco et al. (2020).")
+  }
+}
diff --git a/source/postprocess/particle_count_statistics.cc.bak b/source/postprocess/particle_count_statistics.cc.bak
new file mode 100644
index 00000000000..8b2ca0c952b
--- /dev/null
+++ b/source/postprocess/particle_count_statistics.cc.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/particle_count_statistics.h>
+#include <aspect/particle/world.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    ParticleCountStatistics<dim>::execute (TableHandler &statistics)
+    {
+      const Particle::ParticleHandler<dim> &particle_handler =
+        this->get_particle_world(0).get_particle_handler();
+
+      unsigned int local_min_particles = std::numeric_limits<unsigned int>::max();
+      unsigned int local_max_particles = 0;
+      const Particle::types::particle_index global_particles = this->get_particle_world(0).n_global_particles();
+
+      // compute local min/max
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            const unsigned int particles_in_cell = particle_handler.n_particles_in_cell(cell);
+            local_min_particles = std::min(local_min_particles,particles_in_cell);
+            local_max_particles = std::max(local_max_particles,particles_in_cell);
+          }
+
+      // now do the reductions over all processors
+      const unsigned int global_min_particles = Utilities::MPI::min (local_min_particles,
+                                                                     this->get_mpi_communicator());
+      const unsigned int global_max_particles = Utilities::MPI::max (local_max_particles,
+                                                                     this->get_mpi_communicator());
+
+      // finally produce something for the statistics file
+      statistics.add_value ("Minimal particles per cell: ", global_min_particles);
+      statistics.add_value ("Average particles per cell: ", global_particles / this->get_triangulation().n_global_active_cells());
+      statistics.add_value ("Maximal particles per cell: ", global_max_particles);
+
+      std::ostringstream output;
+      output << global_min_particles << ", "
+             << global_particles / this->get_triangulation().n_global_active_cells() << ", "
+             << global_max_particles;
+
+      return std::pair<std::string, std::string> ("Particle count per cell min/avg/max:",
+                                                  output.str());
+    }
+
+
+
+    template <int dim>
+    std::list<std::string>
+    ParticleCountStatistics<dim>::required_other_postprocessors() const
+    {
+      return {"particles"};
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(ParticleCountStatistics,
+                                  "particle count statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the particle distribution, if present in this simulation. "
+                                  "In particular, it computes minimal, average and maximal "
+                                  "values of particles per cell in the global domain.")
+  }
+}
diff --git a/source/postprocess/particles.cc.bak b/source/postprocess/particles.cc.bak
new file mode 100644
index 00000000000..126f6a1f607
--- /dev/null
+++ b/source/postprocess/particles.cc.bak
@@ -0,0 +1,758 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file LICENSE.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/global.h>
+#include <aspect/postprocess/particles.h>
+#include <aspect/particle/world.h>
+#include <aspect/utilities.h>
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+
+#include <cstdio>
+#include <unistd.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace internal
+    {
+      template <int dim>
+      void
+      ParticleOutput<dim>::build_patches(const dealii::Particles::ParticleHandler<dim> &particle_handler,
+                                         const aspect::Particle::Property::ParticlePropertyInformation &property_information,
+                                         const std::vector<std::string> &exclude_output_properties,
+                                         const bool only_group_3d_vectors)
+      {
+        // First store the names of the data fields that should be written
+        dataset_names.reserve(property_information.n_components()+1);
+        dataset_names.emplace_back("id");
+
+        // This is a map from an index for the particle property vector to an index in the output
+        // vector. Values equal 0 indicate a property will not be written, values bigger 0
+        // indicate into which output entry the property value should be written.
+        std::vector<unsigned int> property_index_to_output_index(property_information.n_components(),0);
+
+        if (std::find(exclude_output_properties.begin(),
+                      exclude_output_properties.end(),
+                      "all")
+            == exclude_output_properties.end())
+          {
+            // Start the output index from 1, because 0 is occupied by the "id"
+            unsigned int output_index = 1;
+            for (unsigned int field_index = 0; field_index < property_information.n_fields(); ++field_index)
+              {
+                // Determine some info about the field.
+                const unsigned n_components = property_information.get_components_by_field_index(field_index);
+                const std::string field_name = property_information.get_field_name_by_index(field_index);
+                const unsigned int field_position = property_information.n_fields() == 0
+                                                    ?
+                                                    0
+                                                    :
+                                                    property_information.get_position_by_field_index(field_index);
+
+                // HDF5 only supports 3d vector output, therefore only treat output fields as vector if we
+                // have a dimension of 3 and 3 components.
+                const bool field_is_vector = (only_group_3d_vectors == false
+                                              ?
+                                              n_components == dim
+                                              :
+                                              dim == 3 && n_components == 3);
+
+                // Determine if this field should be excluded, if so, skip it
+                bool exclude_property = false;
+                for (const auto &property : exclude_output_properties)
+                  if (field_name.find(property) != std::string::npos)
+                    {
+                      exclude_property = true;
+                      break;
+                    }
+
+                if (exclude_property == false)
+                  {
+                    // For each component record its name and position in output vector
+                    for (unsigned int component_index=0; component_index<n_components; ++component_index)
+                      {
+                        // If it is a 1D element, or a vector, print just the name, otherwise append the index after an underscore
+                        if ((n_components == 1) || field_is_vector)
+                          dataset_names.push_back(field_name);
+                        else
+                          dataset_names.push_back(field_name + "_" + Utilities::to_string(component_index));
+
+                        property_index_to_output_index[field_position + component_index] = output_index;
+                        ++output_index;
+                      }
+
+                    // If the property has dim components, we treat it as vector
+                    if (n_components == dim)
+                      {
+                        vector_datasets.emplace_back(property_index_to_output_index[field_position],
+                                                     property_index_to_output_index[field_position]+n_components-1,
+                                                     field_name,
+                                                     DataComponentInterpretation::component_is_part_of_vector);
+                      }
+                  }
+              }
+          }
+
+        // Now build the actual patch data
+        patches.resize(particle_handler.n_locally_owned_particles());
+        typename dealii::Particles::ParticleHandler<dim>::particle_iterator particle = particle_handler.begin();
+
+        for (unsigned int i=0; particle != particle_handler.end(); ++particle, ++i)
+          {
+            patches[i].vertices[0] = particle->get_location();
+            patches[i].patch_index = i;
+
+            patches[i].data.reinit(dataset_names.size(),1);
+
+            patches[i].data(0,0) = particle->get_id();
+
+            if (particle->has_properties())
+              {
+                const ArrayView<const double> properties = particle->get_properties();
+
+                for (unsigned int property_index = 0; property_index < properties.size(); ++property_index)
+                  {
+                    if (property_index_to_output_index[property_index] > 0)
+                      patches[i].data(property_index_to_output_index[property_index],0) = properties[property_index];
+                  }
+              }
+          }
+      }
+
+      template <int dim>
+      const std::vector<DataOutBase::Patch<0,dim>> &
+      ParticleOutput<dim>::get_patches () const
+      {
+        return patches;
+      }
+
+      template <int dim>
+      std::vector<std::string>
+      ParticleOutput<dim>::get_dataset_names () const
+      {
+        return dataset_names;
+      }
+
+      template <int dim>
+      std::vector<
+      std::tuple<unsigned int,
+          unsigned int, std::string,
+          DataComponentInterpretation::DataComponentInterpretation>>
+          ParticleOutput<dim>::get_nonscalar_data_ranges () const
+      {
+        return vector_datasets;
+      }
+    }
+
+    template <int dim>
+    Particles<dim>::Particles ()
+      :
+      // the following value is later read from the input file
+      output_interval (0),
+      // initialize this to a nonsensical value; set it to the actual time
+      // the first time around we get to check it
+      last_output_time (std::numeric_limits<double>::quiet_NaN())
+      ,output_file_number (numbers::invalid_unsigned_int),
+      group_files(0),
+      write_in_background_thread(false)
+    {}
+
+
+
+    template <int dim>
+    Particles<dim>::~Particles ()
+    {
+      // make sure a thread that may still be running in the background,
+      // writing data, finishes
+      if (background_thread.joinable())
+        background_thread.join ();
+    }
+
+
+
+    template <int dim>
+    // We need to pass the arguments by value, as this function can be called on a separate thread:
+    void Particles<dim>::writer (const std::string &filename, //NOLINT(performance-unnecessary-value-param)
+                                 const std::string &temporary_output_location, //NOLINT(performance-unnecessary-value-param)
+                                 const std::string &file_contents)
+    {
+      std::string tmp_filename = filename;
+      if (temporary_output_location != "")
+        {
+          tmp_filename = temporary_output_location + "/aspect.tmp.XXXXXX";
+
+          // Create the temporary file; get at the actual filename
+          // by using a C-style string that mkstemp will then overwrite
+          std::vector<char> tmp_filename_x (tmp_filename.size()+1);
+          std::strcpy(tmp_filename_x.data(), tmp_filename.c_str());
+          const int tmp_file_desc = mkstemp(tmp_filename_x.data());
+          tmp_filename = tmp_filename_x.data();
+
+          // If we failed to create the temp file, just write directly to the target file.
+          // We also provide a warning about this fact. There are places where
+          // this fails *on every node*, so we will get a lot of warning messages
+          // into the output; in these cases, just writing multiple pieces to
+          // std::cerr will produce an unreadable mass of text; rather, first
+          // assemble the error message completely, and then output it atomically
+          if (tmp_file_desc == -1)
+            {
+              const std::string x = ("***** WARNING: could not create temporary file <"
+                                     +
+                                     tmp_filename
+                                     +
+                                     ">, will output directly to final location. This may negatively "
+                                     "affect performance. (On processor "
+                                     + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD))
+                                     + ".)\n");
+
+              std::cerr << x << std::flush;
+
+              tmp_filename = filename;
+            }
+          else
+            close(tmp_file_desc);
+        }
+
+      std::ofstream out(tmp_filename);
+
+      AssertThrow (out, ExcMessage(std::string("Trying to write to file <") +
+                                   filename +
+                                   ">, but the file can't be opened!"));
+
+      // now write and then move the tmp file to its final destination
+      // if necessary
+      out << file_contents;
+      out.close ();
+
+      if (tmp_filename != filename)
+        {
+          std::string command = std::string("mv ") + tmp_filename + " " + filename;
+          int error = system(command.c_str());
+
+          AssertThrow(error == 0,
+                      ExcMessage("Could not move " + tmp_filename + " to "
+                                 + filename + ". On processor "
+                                 + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD)) + "."));
+        }
+    }
+
+    template <int dim>
+    void
+    Particles<dim>::write_description_files (const internal::ParticleOutput<dim> &data_out,
+                                             const std::string &solution_file_prefix,
+                                             const std::vector<std::string> &filenames)
+    {
+      const double time_in_years_or_seconds = (this->convert_output_to_years() ?
+                                               this->get_time() / year_in_seconds :
+                                               this->get_time());
+      const std::string pvtu_filename = (solution_file_prefix +
+                                         ".pvtu");
+      std::ofstream pvtu_file (this->get_output_directory() + "particles/" +
+                               pvtu_filename);
+      data_out.write_pvtu_record (pvtu_file, filenames);
+
+      // now also generate a .pvd file that matches simulation
+      // time and corresponding .pvtu record
+      times_and_pvtu_file_names.emplace_back(time_in_years_or_seconds, "particles/"+pvtu_filename);
+
+      const std::string pvd_filename = (this->get_output_directory() + "particles.pvd");
+      std::ofstream pvd_file (pvd_filename);
+
+      DataOutBase::write_pvd_record (pvd_file, times_and_pvtu_file_names);
+
+      // finally, do the same for VisIt via the .visit file for this
+      // time step, as well as for all time steps together
+      const std::string visit_filename = (this->get_output_directory()
+                                          + "particles/"
+                                          + solution_file_prefix
+                                          + ".visit");
+      std::ofstream visit_file (visit_filename);
+
+      DataOutBase::write_visit_record (visit_file, filenames);
+
+      {
+        // the global .visit file needs the relative path because it sits a
+        // directory above
+        std::vector<std::string> filenames_with_path;
+        filenames_with_path.reserve(filenames.size());
+        for (const auto &filename : filenames)
+          {
+            filenames_with_path.push_back("particles/" + filename);
+          }
+
+        output_file_names_by_timestep.push_back (filenames_with_path);
+      }
+
+      std::ofstream global_visit_file (this->get_output_directory() +
+                                       "particles.visit");
+
+      std::vector<std::pair<double, std::vector<std::string>>> times_and_output_file_names;
+      for (unsigned int timestep=0; timestep<times_and_pvtu_file_names.size(); ++timestep)
+        times_and_output_file_names.emplace_back(times_and_pvtu_file_names[timestep].first,
+                                                 output_file_names_by_timestep[timestep]);
+      DataOutBase::write_visit_record (global_visit_file, times_and_output_file_names);
+    }
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    Particles<dim>::execute (TableHandler &statistics)
+    {
+      // if this is the first time we get here, set the last output time
+      // to the current time - output_interval. this makes sure we
+      // always produce data during the first time step
+      if (std::isnan(last_output_time))
+        last_output_time = this->get_time() - output_interval;
+
+      const Particle::World<dim> &world = this->get_particle_world(0);
+
+      statistics.add_value("Number of advected particles",world.n_global_particles());
+
+      // If it's not time to generate an output file
+      // return early with the number of particles that were advected
+      if (this->get_time() < last_output_time + output_interval)
+        return std::make_pair("Number of advected particles:",
+                              Utilities::int_to_string(world.n_global_particles()));
+
+      // If we do not write output
+      // return early with the number of particles that were advected
+      if (output_formats.size() == 0 || output_formats[0] == "none")
+        {
+          // Up the next time we need output. This is relevant to correctly
+          // write output after a restart if the format is changed.
+          set_last_output_time (this->get_time());
+
+          return std::make_pair("Number of advected particles:",
+                                Utilities::int_to_string(world.n_global_particles()));
+        }
+
+      if (output_file_number == numbers::invalid_unsigned_int)
+        output_file_number = 0;
+      else
+        ++output_file_number;
+
+      // Create the particle output
+      const bool output_hdf5 = std::find(output_formats.begin(), output_formats.end(),"hdf5") != output_formats.end();
+      internal::ParticleOutput<dim> data_out;
+      data_out.build_patches(world.get_particle_handler(),
+                             world.get_property_manager().get_data_info(),
+                             exclude_output_properties,
+                             output_hdf5);
+
+      // Now prepare everything for writing the output and choose output format
+      std::string particle_file_prefix = "particles-" + Utilities::int_to_string (output_file_number, 5);
+
+      const double time_in_years_or_seconds = (this->convert_output_to_years() ?
+                                               this->get_time() / year_in_seconds :
+                                               this->get_time());
+
+      for (const auto &output_format : output_formats)
+        {
+          // this case was handled above
+          Assert(output_format != "none", ExcInternalError());
+
+          if (output_format == "hdf5")
+            {
+              const std::string particle_file_name = "particles/" + particle_file_prefix + ".h5";
+              const std::string xdmf_filename = "particles.xdmf";
+
+              // Do not filter redundant values, there are no duplicate particles
+              DataOutBase::DataOutFilter data_filter(DataOutBase::DataOutFilterFlags(false, true));
+
+              data_out.write_filtered_data(data_filter);
+              data_out.write_hdf5_parallel(data_filter,
+                                           this->get_output_directory()+particle_file_name,
+                                           this->get_mpi_communicator());
+
+              const XDMFEntry new_xdmf_entry = data_out.create_xdmf_entry(data_filter,
+                                                                          particle_file_name,
+                                                                          time_in_years_or_seconds,
+                                                                          this->get_mpi_communicator());
+              xdmf_entries.push_back(new_xdmf_entry);
+              data_out.write_xdmf_file(xdmf_entries, this->get_output_directory() + xdmf_filename,
+                                       this->get_mpi_communicator());
+            }
+          else if (output_format == "vtu")
+            {
+              // Write descriptive files (.pvtu,.pvd,.visit) on the root process
+              const int my_id = Utilities::MPI::this_mpi_process(this->get_mpi_communicator());
+
+              if (my_id == 0)
+                {
+                  std::vector<std::string> filenames;
+                  const unsigned int n_processes = Utilities::MPI::n_mpi_processes(this->get_mpi_communicator());
+                  const unsigned int n_files = (group_files == 0) ? n_processes : std::min(group_files,n_processes);
+                  for (unsigned int i=0; i<n_files; ++i)
+                    filenames.push_back (particle_file_prefix
+                                         + "." + Utilities::int_to_string(i, 4)
+                                         + ".vtu");
+                  write_description_files (data_out, particle_file_prefix, filenames);
+                }
+
+              const unsigned int n_processes = Utilities::MPI::n_mpi_processes(this->get_mpi_communicator());
+
+              const unsigned int my_file_id = (group_files == 0
+                                               ?
+                                               my_id
+                                               :
+                                               my_id % group_files);
+              const std::string filename = this->get_output_directory()
+                                           + "particles/"
+                                           + particle_file_prefix
+                                           + "."
+                                           + Utilities::int_to_string (my_file_id, 4)
+                                           + ".vtu";
+
+              // pass time step number and time as metadata into the output file
+              DataOutBase::VtkFlags vtk_flags;
+              vtk_flags.cycle = this->get_timestep_number();
+              vtk_flags.time = time_in_years_or_seconds;
+
+              data_out.set_flags (vtk_flags);
+
+              // Write as many files as processes. For this case we support writing in a
+              // background thread and to a temporary location, so we first write everything
+              // into a string that is written to disk in a writer function
+              if ((group_files == 0) || (group_files >= n_processes))
+                {
+                  // Put the content we want to write into a string object that
+                  // we can then write in the background
+                  std::unique_ptr<std::string> file_contents;
+                  {
+                    std::ostringstream tmp;
+
+                    data_out.write (tmp, DataOutBase::parse_output_format(output_format));
+                    file_contents = std::make_unique<std::string>(tmp.str());
+                  }
+
+                  if (write_in_background_thread)
+                    {
+                      // Wait for all previous write operations to finish, should
+                      // any be still active, ...
+                      if (background_thread.joinable())
+                        background_thread.join ();
+
+                      // ...then continue with writing our own data.
+                      background_thread
+                        = std::thread([ my_filename = filename, // filename is const, so we can not move from it
+                                        my_temporary_output_location = temporary_output_location,
+                                        my_file_contents = std::move(file_contents)]()
+                      {
+                        writer (my_filename, my_temporary_output_location, *my_file_contents);
+                      });
+                    }
+                  else
+                    writer(filename,temporary_output_location,*file_contents);
+                }
+              // Just write one data file in parallel
+              else if (group_files == 1)
+                {
+                  data_out.write_vtu_in_parallel(filename,
+                                                 this->get_mpi_communicator());
+                }
+              // Write as many output files as 'group_files' groups
+              else
+                {
+                  int color = my_id % group_files;
+
+                  MPI_Comm comm;
+                  int ierr = MPI_Comm_split(this->get_mpi_communicator(), color, my_id, &comm);
+                  AssertThrowMPI(ierr);
+
+                  data_out.write_vtu_in_parallel(filename, comm);
+                  ierr = MPI_Comm_free(&comm);
+                  AssertThrowMPI(ierr);
+                }
+            }
+          // Write in a different format than hdf5 or vtu. This case is supported, but is not
+          // optimized for parallel output in that every process will write one file directly
+          // into the output directory. This may or may not affect performance depending on
+          // the model setup and the network file system type.
+          else
+            {
+              const unsigned int myid = Utilities::MPI::this_mpi_process(this->get_mpi_communicator());
+
+              const std::string filename = this->get_output_directory()
+                                           + "particles/"
+                                           + particle_file_prefix
+                                           + "."
+                                           +  Utilities::int_to_string (myid, 4)
+                                           + DataOutBase::default_suffix
+                                           (DataOutBase::parse_output_format(output_format));
+
+              std::ofstream out (filename);
+
+              AssertThrow(out,
+                          ExcMessage("Unable to open file for writing: " + filename +"."));
+
+              data_out.write (out, DataOutBase::parse_output_format(output_format));
+            }
+        }
+
+
+      // up the next time we need output
+      set_last_output_time (this->get_time());
+
+      const std::string particle_output = this->get_output_directory() + "particles/" + particle_file_prefix;
+
+      // record the file base file name in the output file
+      statistics.add_value ("Particle file name",
+                            particle_output);
+      return std::make_pair("Writing particle output:", particle_output);
+    }
+
+
+
+    template <int dim>
+    void
+    Particles<dim>::set_last_output_time (const double current_time)
+    {
+      // if output_interval is positive, then update the last supposed output
+      // time
+      if (output_interval > 0)
+        {
+          // We need to find the last time output was supposed to be written.
+          // this is the last_output_time plus the largest positive multiple
+          // of output_intervals that passed since then. We need to handle the
+          // edge case where last_output_time+output_interval==current_time,
+          // we did an output and std::floor sadly rounds to zero. This is done
+          // by forcing std::floor to round 1.0-eps to 1.0.
+          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
+        }
+    }
+
+
+    template <int dim>
+    template <class Archive>
+    void Particles<dim>::serialize (Archive &ar, const unsigned int)
+    {
+      ar &last_output_time
+      & output_file_number
+      & times_and_pvtu_file_names
+      & output_file_names_by_timestep
+      & xdmf_entries
+      ;
+    }
+
+
+    template <int dim>
+    void
+    Particles<dim>::save (std::map<std::string, std::string> &status_strings) const
+    {
+      std::ostringstream os;
+      aspect::oarchive oa (os);
+
+      this->get_particle_world(0).save(os);
+      oa << (*this);
+
+      status_strings["Particles"] = os.str();
+    }
+
+
+    template <int dim>
+    void
+    Particles<dim>::load (const std::map<std::string, std::string> &status_strings)
+    {
+      // see if something was saved
+      if (status_strings.find("Particles") != status_strings.end())
+        {
+          std::istringstream is (status_strings.find("Particles")->second);
+          aspect::iarchive ia (is);
+
+          // Load the particle world
+          this->get_particle_world(0).load(is);
+
+          ia >> (*this);
+        }
+    }
+
+
+    template <int dim>
+    void
+    Particles<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Particles");
+        {
+          prm.declare_entry ("Time between data output", "1e8",
+                             Patterns::Double (0.),
+                             "The time interval between each generation of "
+                             "output files. A value of zero indicates that "
+                             "output should be generated every time step.\n\n"
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+
+          // now also see about the file format we're supposed to write in
+          // Note: "ascii" is a legacy format used by ASPECT before particle output
+          // in deal.II was implemented. It is nearly identical to the gnuplot format, thus
+          // we now simply replace "ascii" by "gnuplot" should it be selected.
+          prm.declare_entry ("Data output format", "vtu",
+                             Patterns::MultipleSelection (DataOutBase::get_output_format_names ()+"|ascii"),
+                             "A comma separated list of file formats to be used for graphical "
+                             "output. The list of possible output formats that can be given "
+                             "here is documented in the appendix of the manual where the current "
+                             "parameter is described.");
+
+          prm.declare_entry ("Number of grouped files", "16",
+                             Patterns::Integer(0),
+                             "VTU file output supports grouping files from several CPUs "
+                             "into a given number of files using MPI I/O when writing on a parallel "
+                             "filesystem. Select 0 for no grouping. This will disable "
+                             "parallel file output and instead write one file per processor. "
+                             "A value of 1 will generate one big file containing the whole "
+                             "solution, while a larger value will create that many files "
+                             "(at most as many as there are MPI ranks).");
+
+          prm.declare_entry ("Write in background thread", "false",
+                             Patterns::Bool(),
+                             "File operations can potentially take a long time, blocking the "
+                             "progress of the rest of the model run. Setting this variable to "
+                             "`true' moves this process into a background thread, while the "
+                             "rest of the model continues.");
+
+          prm.declare_entry ("Temporary output location", "",
+                             Patterns::Anything(),
+                             "On large clusters it can be advantageous to first write the "
+                             "output to a temporary file on a local file system and later "
+                             "move this file to a network file system. If this variable is "
+                             "set to a non-empty string it will be interpreted as a "
+                             "temporary storage location.");
+
+          prm.declare_entry ("Exclude output properties", "",
+                             Patterns::Anything(),
+                             "A comma separated list of particle properties that should "
+                             "\\textit{not} be output. If this list contains the "
+                             "entry `all', only the id of particles will be provided in "
+                             "graphical output files.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      Particle::World<dim>::declare_parameters(prm);
+    }
+
+
+    template <int dim>
+    void
+    Particles<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Particles");
+        {
+          output_interval = prm.get_double ("Time between data output");
+          if (this->convert_output_to_years())
+            output_interval *= year_in_seconds;
+
+          AssertThrow(this->get_parameters().run_postprocessors_on_nonlinear_iterations == false,
+                      ExcMessage("Postprocessing nonlinear iterations in models with "
+                                 "particles is currently not supported."));
+
+          output_formats   = Utilities::split_string_list(prm.get ("Data output format"));
+          AssertThrow(Utilities::has_unique_entries(output_formats),
+                      ExcMessage("The list of strings for the parameter "
+                                 "'Postprocess/Particles/Data output format' contains entries more than once. "
+                                 "This is not allowed. Please check your parameter file."));
+
+          AssertThrow ((std::find (output_formats.begin(),
+                                   output_formats.end(),
+                                   "none") == output_formats.end())
+                       ||
+                       (output_formats.size() == 1),
+                       ExcMessage ("If you specify 'none' for the parameter \"Data output format\", "
+                                   "then this needs to be the only value given."));
+
+          if (std::find (output_formats.begin(),
+                         output_formats.end(),
+                         "none") == output_formats.end())
+            aspect::Utilities::create_directory (this->get_output_directory() + "particles/",
+                                                 this->get_mpi_communicator(),
+                                                 true);
+
+          // Note: "ascii" is a legacy format used by ASPECT before particle output
+          // in deal.II was implemented. It is nearly identical to the gnuplot format, thus
+          // we simply replace "ascii" by "gnuplot" should it be selected.
+          std::vector<std::string>::iterator output_format =  std::find (output_formats.begin(),
+                                                                         output_formats.end(),
+                                                                         "ascii");
+          if (output_format != output_formats.end())
+            *output_format = "gnuplot";
+
+          group_files     = prm.get_integer("Number of grouped files");
+          write_in_background_thread = prm.get_bool("Write in background thread");
+          temporary_output_location = prm.get("Temporary output location");
+
+          if (temporary_output_location != "")
+            {
+              // Check if a command-processor is available by calling system() with a
+              // null pointer. System is guaranteed to return non-zero if it finds
+              // a terminal and zero if there is none (like on the compute nodes of
+              // some cluster architectures, e.g. IBM BlueGene/Q)
+              AssertThrow(system((char *)nullptr) != 0,
+                          ExcMessage("Usage of a temporary storage location is only supported if "
+                                     "there is a terminal available to move the files to their final location "
+                                     "after writing. The system() command did not succeed in finding such a terminal."));
+            }
+
+          exclude_output_properties = Utilities::split_string_list(prm.get("Exclude output properties"));
+
+          // Never output the integrator properties that are for internal use only
+          exclude_output_properties.emplace_back("internal: integrator properties");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace internal
+    {
+#define INSTANTIATE(dim) \
+  template class ParticleOutput<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+
+    ASPECT_REGISTER_POSTPROCESSOR(Particles,
+                                  "particles",
+                                  "A Postprocessor that creates particles that follow the "
+                                  "velocity field of the simulation. The particles can be generated "
+                                  "and propagated in various ways and they can carry a number of "
+                                  "constant or time-varying properties. The postprocessor can write "
+                                  "output positions and properties of all particles at chosen intervals, "
+                                  "although this is not mandatory. It also allows other parts of the "
+                                  "code to query the particles for information.")
+  }
+}
diff --git a/source/postprocess/point_values.cc.bak b/source/postprocess/point_values.cc.bak
new file mode 100644
index 00000000000..9b3d7401b72
--- /dev/null
+++ b/source/postprocess/point_values.cc.bak
@@ -0,0 +1,369 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/point_values.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/global.h>
+#include <deal.II/numerics/vector_tools.h>
+
+#include <cmath>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    PointValues<dim>::PointValues ()
+      :
+      // the following value is later read from the input file
+      output_interval (0),
+      // initialize this to a nonsensical value; set it to the actual time
+      // the first time around we get to check it
+      last_output_time (std::numeric_limits<double>::quiet_NaN()),
+      evaluation_points_cartesian (std::vector<Point<dim>>() ),
+      point_values (std::vector<std::pair<double, std::vector<Vector<double>>>>() ),
+      use_natural_coordinates (false)
+    {}
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    PointValues<dim>::execute (TableHandler &)
+    {
+      // if this is the first time we get here, set the next output time
+      // to the current time. this makes sure we always produce data during
+      // the first time step
+      if (std::isnan(last_output_time))
+        last_output_time = this->get_time() - output_interval;
+
+      // see if output is requested at this time
+      if (this->get_time() < last_output_time + output_interval)
+        return {"", ""};
+
+      // evaluate the solution at all of our evaluation points
+      std::vector<Vector<double>>
+      current_point_values (evaluation_points_cartesian.size(),
+                            Vector<double> (this->introspection().n_components));
+
+      for (unsigned int p=0; p<evaluation_points_cartesian.size(); ++p)
+        {
+          // try to evaluate the solution at this point. in parallel, the point
+          // will be on only one processor's owned cells, so the others are
+          // going to throw an exception. make sure at least one processor
+          // finds the given point
+          bool point_found = false;
+
+          try
+            {
+              VectorTools::point_value(this->get_mapping(),
+                                       this->get_dof_handler(),
+                                       this->get_solution(),
+                                       evaluation_points_cartesian[p],
+                                       current_point_values[p]);
+              point_found = true;
+            }
+          catch (const VectorTools::ExcPointNotAvailableHere &)
+            {
+              // ignore
+            }
+
+          // ensure that at least one processor found things
+          const int n_procs = Utilities::MPI::sum (point_found ? 1 : 0, this->get_mpi_communicator());
+          AssertThrow (n_procs > 0,
+                       ExcMessage ("While trying to evaluate the solution at point " +
+                                   Utilities::to_string(evaluation_points_cartesian[p][0]) + ", " +
+                                   Utilities::to_string(evaluation_points_cartesian[p][1]) +
+                                   (dim == 3
+                                    ?
+                                    ", " + Utilities::to_string(evaluation_points_cartesian[p][2])
+                                    :
+                                    "") + "), " +
+                                   "no processors reported that the point lies inside the " +
+                                   "set of cells they own. Are you trying to evaluate the " +
+                                   "solution at a point that lies outside of the domain?"
+                                  ));
+
+          // Reduce all collected values into local Vector
+          Utilities::MPI::sum (current_point_values[p], this->get_mpi_communicator(),
+                               current_point_values[p]);
+
+          // Normalize in cases where points are claimed by multiple processors
+          if (n_procs > 1)
+            current_point_values[p] /= n_procs;
+        }
+
+      // finally push these point values all onto the list we keep
+      point_values.emplace_back (this->get_time(), current_point_values);
+
+      // now write all of the data to the file of choice. start with a pre-amble that
+      // explains the meaning of the various fields
+      const std::string filename = (this->get_output_directory() +
+                                    "point_values.txt");
+
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+
+          std::ofstream f (filename);
+          f << ("# <time> "
+                "<evaluation_point_x> "
+                "<evaluation_point_y> ")
+            << (dim == 3 ? "<evaluation_point_z> " : "")
+            << ("<velocity_x> "
+                "<velocity_y> ")
+            << (dim == 3 ? "<velocity_z> " : "")
+            << "<pressure> <temperature>";
+          for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+            f << " <" << this->introspection().name_for_compositional_index(c) << '>';
+          f << '\n';
+
+          for (const auto &time_point : point_values)
+            {
+              Assert (time_point.second.size() == evaluation_points_cartesian.size(),
+                      ExcInternalError());
+              for (unsigned int i=0; i<evaluation_points_cartesian.size(); ++i)
+                {
+                  f << /* time = */ time_point.first / (this->convert_output_to_years() ? year_in_seconds : 1.)
+                    << ' '
+                    << /* location = */ evaluation_points_cartesian[i] << ' ';
+
+                  for (unsigned int c=0; c<time_point.second[i].size(); ++c)
+                    {
+                      // output a data element. internally, we store all point
+                      // values in the same format in which they were computed,
+                      // but we convert velocities to meters per year if so
+                      // requested
+                      if ((this->introspection().component_masks.velocities[c] == false)
+                          ||
+                          (this->convert_output_to_years() == false))
+                        f << time_point.second[i][c];
+                      else
+                        f << time_point.second[i][c] * year_in_seconds;
+
+                      f << (c != time_point.second[i].size()-1 ? ' ' : '\n');
+                    }
+                }
+
+              // have an empty line between time steps
+              f << '\n';
+            }
+
+          AssertThrow (f, ExcMessage("Writing data to <" + filename +
+                                     "> did not succeed in the `point values' "
+                                     "postprocessor."));
+        }
+
+
+      // Update time
+      set_last_output_time (this->get_time());
+
+      // return what should be printed to the screen. note that we had
+      // just incremented the number, so use the previous value
+      return std::make_pair (std::string ("Writing point values:"),
+                             filename);
+    }
+
+
+    template <int dim>
+    void
+    PointValues<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Point values");
+        {
+          prm.declare_entry ("Time between point values output", "0.",
+                             Patterns::Double (0.),
+                             "The time interval between each generation of "
+                             "point values output. A value of zero indicates "
+                             "that output should be generated in each time step. "
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+          prm.declare_entry("Evaluation points", "",
+                            // a list of points, separated by semicolons; each point has
+                            // exactly 'dim' components/coordinates, separated by commas
+                            Patterns::List (Patterns::List (Patterns::Double(), dim, dim, ","),
+                                            0, Patterns::List::max_int_value, ";"),
+                            "The list of points at which the solution should be evaluated. "
+                            "Points need to be separated by semicolons, and coordinates of "
+                            "each point need to be separated by commas.");
+          prm.declare_entry("Use natural coordinates", "false",
+                            Patterns::Bool (),
+                            "Whether or not the Evaluation points are specified in "
+                            "the natural coordinates of the geometry model, e.g. "
+                            "radius, lon, lat for the chunk model. "
+                            "Currently, natural coordinates for the spherical shell "
+                            "and sphere geometries are not supported. ");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    PointValues<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Point values");
+        {
+          output_interval = prm.get_double ("Time between point values output");
+          if (this->convert_output_to_years())
+            output_interval *= year_in_seconds;
+
+          const std::vector<std::string> point_list
+            = Utilities::split_string_list(prm.get("Evaluation points"), ';');
+
+          std::vector<std::array<double,dim>> evaluation_points;
+
+          for (const auto &p : point_list)
+            {
+              const std::vector<std::string> coordinates
+                = Utilities::split_string_list(p, ',');
+              AssertThrow (coordinates.size() == dim,
+                           ExcMessage ("In setting up the list of evaluation points for the <Point values> "
+                                       "postprocessor, one of the evaluation points reads <"
+                                       + p +
+                                       ">, but this does not correspond to a list of numbers with "
+                                       "as many coordinates as you run your simulation in."));
+
+              std::array<double,dim> point;
+              for (unsigned int d=0; d<dim; ++d)
+                point[d] = Utilities::string_to_double (coordinates[d]);
+              evaluation_points.push_back (point);
+            }
+
+          use_natural_coordinates = prm.get_bool("Use natural coordinates");
+
+          // Convert the vector of coordinate arrays in Cartesian or natural
+          // coordinates to a vector of Point<dim> of Cartesian coordinates.
+          evaluation_points_cartesian.resize(evaluation_points.size());
+          for (unsigned int p=0; p<evaluation_points.size(); ++p)
+            {
+              if (use_natural_coordinates)
+                evaluation_points_cartesian[p] = this->get_geometry_model().natural_to_cartesian_coordinates(evaluation_points[p]);
+              else
+                for (unsigned int i = 0; i < dim; ++i)
+                  evaluation_points_cartesian[p][i] = evaluation_points[p][i];
+            }
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    template <class Archive>
+    void PointValues<dim>::serialize (Archive &ar, const unsigned int)
+    {
+      ar &evaluation_points_cartesian
+      & point_values
+      & last_output_time;
+    }
+
+
+    template <int dim>
+    void
+    PointValues<dim>::save (std::map<std::string, std::string> &status_strings) const
+    {
+      std::ostringstream os;
+      aspect::oarchive oa (os);
+      oa << (*this);
+
+      status_strings["PointValues"] = os.str();
+    }
+
+
+    template <int dim>
+    void
+    PointValues<dim>::load (const std::map<std::string, std::string> &status_strings)
+    {
+      // see if something was saved
+      if (status_strings.find("PointValues") != status_strings.end())
+        {
+          std::istringstream is (status_strings.find("PointValues")->second);
+          aspect::iarchive ia (is);
+          ia >> (*this);
+        }
+    }
+
+
+    template <int dim>
+    void
+    PointValues<dim>::set_last_output_time (const double current_time)
+    {
+      // if output_interval is positive, then set the next output interval to
+      // a positive multiple.
+      if (output_interval > 0)
+        {
+          // We need to find the last time output was supposed to be written.
+          // this is the last_output_time plus the largest positive multiple
+          // of output_intervals that passed since then. We need to handle the
+          // edge case where last_output_time+output_interval==current_time,
+          // we did an output and std::floor sadly rounds to zero. This is done
+          // by forcing std::floor to round 1.0-eps to 1.0.
+          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
+        }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(PointValues,
+                                  "point values",
+                                  "A postprocessor that evaluates the solution (i.e., velocity, pressure, "
+                                  "temperature, and compositional fields along with other fields that "
+                                  "are treated as primary variables) at the end of every time step or "
+                                  "after a user-specified time interval "
+                                  "at a given set of points and then writes this data into the file "
+                                  "<point\\_values.txt> in the output directory. The points at which "
+                                  "the solution should be evaluated are specified in the section "
+                                  "\\texttt{Postprocess/Point values} in the input file."
+                                  "\n\n"
+                                  "In the output file, data is organized as (i) time, (ii) the 2 or 3 "
+                                  "coordinates of the evaluation points, and (iii) followed by the "
+                                  "values of the solution vector at this point. The time is provided "
+                                  "in seconds or, if the "
+                                  "global ``Use years in output instead of seconds'' parameter is "
+                                  "set, in years. In the latter case, the velocity is also converted "
+                                  "to meters/year, instead of meters/second."
+                                  "\n\n"
+                                  ":::{note}\n"
+                                  "Evaluating the solution of a finite element field at "
+                                  "arbitrarily chosen points is an expensive process. Using this "
+                                  "postprocessor will only be efficient if the number of evaluation "
+                                  "points or output times is relatively small. If you need a very large number of "
+                                  "evaluation points, you should consider extracting this "
+                                  "information from the visualization program you use to display "
+                                  "the output of the `visualization' postprocessor.\n"
+                                  ":::")
+  }
+}
diff --git a/source/postprocess/pressure_statistics.cc.bak b/source/postprocess/pressure_statistics.cc.bak
new file mode 100644
index 00000000000..df28ec25616
--- /dev/null
+++ b/source/postprocess/pressure_statistics.cc.bak
@@ -0,0 +1,144 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/pressure_statistics.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    PressureStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the pressure element alone.
+      // we need to compute max and min of the pressure as well, which
+      // may be on the boundary of the cell, so we use an iterated
+      // trapezoidal rule instead of the usual Gauss rule
+      //
+      // iterate it 'degree' times to make sure our evaluation points are
+      // in fact the support points.
+      const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
+                                               this->get_fe().base_element(this->introspection().base_elements.pressure).degree);
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      std::vector<double> pressure_values(n_q_points);
+
+      double local_pressure_integral = 0;
+      double local_min_pressure      = std::numeric_limits<double>::max();
+      double local_max_pressure      = std::numeric_limits<double>::lowest();
+
+      // compute the integral quantities by quadrature. note that compared to
+      // the temperature statistics postprocessor, we can not just loop over
+      // the pressure DoFs because they may be intermingled with the
+      // velocity DoFs if we use a direct solver
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
+                                                                                      pressure_values);
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                const double value = pressure_values[q];
+
+                local_pressure_integral += value*fe_values.JxW(q);
+                local_min_pressure = std::min (local_min_pressure, value);
+                local_max_pressure = std::max (local_max_pressure, value);
+              }
+          }
+
+      const double global_pressure_integral
+        = Utilities::MPI::sum (local_pressure_integral, this->get_mpi_communicator());
+
+      // now do the reductions that are
+      // min/max operations. do them in
+      // one communication by multiplying
+      // one value by -1
+      double global_min_pressure = 0;
+      double global_max_pressure = 0;
+      {
+        double local_values[2] = { -local_min_pressure, local_max_pressure };
+        double global_values[2];
+
+        Utilities::MPI::max (local_values, this->get_mpi_communicator(), global_values);
+
+        global_min_pressure = -global_values[0];
+        global_max_pressure = global_values[1];
+      }
+
+      double global_mean_pressure = global_pressure_integral / this->get_volume();
+      statistics.add_value ("Minimal pressure (Pa)",
+                            global_min_pressure);
+      statistics.add_value ("Average pressure (Pa)",
+                            global_mean_pressure);
+      statistics.add_value ("Maximal pressure (Pa)",
+                            global_max_pressure);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      {
+        const char *columns[] = { "Minimal pressure (Pa)",
+                                  "Average pressure (Pa)",
+                                  "Maximal pressure (Pa)"
+                                };
+        for (auto &column : columns)
+          {
+            statistics.set_precision (column, 8);
+            statistics.set_scientific (column, true);
+          }
+      }
+
+      std::ostringstream output;
+      output.precision(4);
+      output << global_min_pressure << " Pa, "
+             << global_pressure_integral / this->get_volume() << " Pa, "
+             << global_max_pressure << " Pa";
+
+      return std::pair<std::string, std::string> ("Pressure min/avg/max:",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(PressureStatistics,
+                                  "pressure statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the pressure field.")
+  }
+}
diff --git a/source/postprocess/rotation_statistics.cc.bak b/source/postprocess/rotation_statistics.cc.bak
new file mode 100644
index 00000000000..d430833fa02
--- /dev/null
+++ b/source/postprocess/rotation_statistics.cc.bak
@@ -0,0 +1,202 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/rotation_statistics.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/global.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace
+    {
+      void add_scientific_column(const std::string &name,
+                                 const double value,
+                                 TableHandler &statistics)
+      {
+        statistics.add_value(name,value);
+        statistics.set_precision (name, 8);
+        statistics.set_scientific (name, true);
+      }
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    RotationStatistics<dim>::execute (TableHandler &statistics)
+    {
+      RotationProperties<dim> rotation = this->compute_net_angular_momentum(use_constant_density,
+                                                                            this->get_solution(),
+                                                                            false);
+
+      RotationProperties<dim> surface_rotation = this->compute_net_angular_momentum(true,
+                                                                                    this->get_solution(),
+                                                                                    true);
+
+      const std::vector<std::string> names = {"Angular momentum", "Moment of inertia", "Angular velocity", "Surface angular velocity"};
+      std::vector<std::string> units;
+
+      if (this->convert_output_to_years() == true)
+        {
+          units = {"kg*m^2/year", "kg*m^2", "1/year", "1/year"};
+
+          if (dim == 2)
+            {
+              rotation.scalar_angular_momentum *= year_in_seconds;
+              rotation.scalar_rotation *= year_in_seconds;
+              surface_rotation.scalar_rotation *= year_in_seconds;
+            }
+          else if (dim == 3)
+            {
+              rotation.tensor_angular_momentum *= year_in_seconds;
+              rotation.tensor_rotation *= year_in_seconds;
+              surface_rotation.tensor_rotation *= year_in_seconds;
+            }
+        }
+      else
+        {
+          units = {"kg*m^2/s", "kg*m^2", "1/s", "1/s"};
+        }
+
+      std::ostringstream output;
+      output.precision(3);
+
+      if (dim == 2)
+        {
+          add_scientific_column(names[0] + " (" + units[0] +")", rotation.scalar_angular_momentum, statistics);
+          add_scientific_column(names[1] + " (" + units[1] +")", rotation.scalar_moment_of_inertia, statistics);
+          add_scientific_column(names[2] + " (" + units[2] +")", rotation.scalar_rotation, statistics);
+          add_scientific_column(names[3] + " (" + units[3] +")", surface_rotation.scalar_rotation, statistics);
+
+          output << rotation.scalar_angular_momentum << ' ' << units[0] << ", "
+                 << rotation.scalar_moment_of_inertia << ' ' << units[1] << ", "
+                 << rotation.scalar_rotation << ' ' << units[2] << ", "
+                 << surface_rotation.scalar_rotation << ' ' << units[3];
+        }
+      else if (dim == 3)
+        {
+          add_scientific_column(names[0] + " (" + units[0] +")", rotation.tensor_angular_momentum.norm(), statistics);
+
+          const double scalar_moment_of_inertia = (rotation.tensor_moment_of_inertia * rotation.tensor_rotation / rotation.tensor_rotation.norm()).norm();
+
+          if (output_full_tensor == false)
+            {
+              add_scientific_column(names[1] + " (" + units[1] +")", scalar_moment_of_inertia, statistics);
+            }
+          else
+            {
+              add_scientific_column(names[1] + "_xx (" + units[1] +")", rotation.tensor_moment_of_inertia[0][0], statistics);
+              add_scientific_column(names[1] + "_yy (" + units[1] +")", rotation.tensor_moment_of_inertia[1][1], statistics);
+              add_scientific_column(names[1] + "_zz (" + units[1] +")", rotation.tensor_moment_of_inertia[2][2], statistics);
+              add_scientific_column(names[1] + "_xy (" + units[1] +")", rotation.tensor_moment_of_inertia[0][1], statistics);
+              add_scientific_column(names[1] + "_xz (" + units[1] +")", rotation.tensor_moment_of_inertia[0][2], statistics);
+              add_scientific_column(names[1] + "_yz (" + units[1] +")", rotation.tensor_moment_of_inertia[1][2], statistics);
+            }
+
+          add_scientific_column(names[2] + " (" + units[2] +")", rotation.tensor_rotation.norm(), statistics);
+          add_scientific_column(names[3] + " (" + units[3] +")", surface_rotation.tensor_rotation.norm(), statistics);
+
+          output << rotation.tensor_angular_momentum.norm() << ' ' << units[0] << ", "
+                 << scalar_moment_of_inertia << ' ' << units[1] << ", "
+                 << rotation.tensor_rotation.norm() << ' ' << units[2] << ", "
+                 << surface_rotation.tensor_rotation.norm() << ' ' << units[3];
+        }
+
+      return std::pair<std::string, std::string> (names[0]+ ", " + names[1] + ", " + names[2] + ", " + names[3] + ":",
+                                                  output.str());
+    }
+
+
+
+    template <int dim>
+    void
+    RotationStatistics<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Rotation statistics");
+        {
+          prm.declare_entry("Use constant density of one","false",
+                            Patterns::Bool(),
+                            "Whether to use a constant density of one for the computation of the "
+                            "angular momentum and moment of inertia. This is an approximation "
+                            "that assumes that the 'volumetric' rotation is equal to the 'mass' "
+                            "rotation. If this parameter is true this postprocessor computes "
+                            "'net rotation' instead of 'angular momentum'.");
+          prm.declare_entry("Output full moment of inertia tensor","false",
+                            Patterns::Bool(),
+                            "Whether to write the full moment of inertia tensor into the "
+                            "statistics output instead of its norm for the current rotation "
+                            "axis. This is a second-order symmetric tensor with "
+                            "6 components in 3d. In 2d this option has no effect, because "
+                            "the rotation axis is fixed and thus the moment of inertia "
+                            "is always a scalar.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    RotationStatistics<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Rotation statistics");
+        {
+          use_constant_density = prm.get_bool("Use constant density of one");
+          output_full_tensor = prm.get_bool("Output full moment of inertia tensor");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(RotationStatistics,
+                                  "rotation statistics",
+                                  "A postprocessor that computes some statistics about the "
+                                  "rotational velocity of the model (i.e. integrated "
+                                  "net rotation and angular momentum). In 2d we assume the "
+                                  "model to be a cross-section through an infinite domain in "
+                                  "z direction, with a zero z-velocity. Thus, the z-axis is "
+                                  "the only possible rotation axis and both moment of inertia "
+                                  "and angular momentum are scalar instead of tensor "
+                                  "quantities.")
+  }
+}
diff --git a/source/postprocess/sea_level.cc.bak b/source/postprocess/sea_level.cc.bak
new file mode 100644
index 00000000000..4f95c70f2a2
--- /dev/null
+++ b/source/postprocess/sea_level.cc.bak
@@ -0,0 +1,618 @@
+/*
+  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+#include <aspect/mesh_deformation/free_surface.h>
+#include <aspect/utilities.h>
+#include <aspect/structured_data.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/postprocess/sea_level.h>
+#include <aspect/postprocess/geoid.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <cmath>
+#include <limits>
+
+// TODO:
+// Include geoid anomaly of surface load.
+// Compute new surface gravity per location, dependent on surface topography and Earth model instead of outer_radius of geometry model.
+// Include option for time-changing ocean geometry, now it is a fixed ocean geometry.
+// The ice height data is now only loaded once from the first time step. It is not constant over time. Implement an option to load data for current timestep (as in boundary traction).
+// Implement iterative structure with solvers.
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    void
+    SeaLevel<dim>::initialize()
+    {
+      Assert(false, ExcNotImplemented(""));
+    }
+
+    template <>
+    void
+    SeaLevel<3>::initialize()
+    {
+      const int dim = 3;
+
+      topography_lookup = std::make_unique<Utilities::StructuredDataLookup<dim-1>>(/* n_components = */1,
+                          /* scale = */1.0);
+      topography_lookup->load_file(data_directory_topography+data_file_name_topography,this->get_mpi_communicator());
+
+      ice_height_lookup = std::make_unique<Utilities::StructuredDataLookup<dim-1>>(/* n_components = */1,
+                          /* scale = */1.0);
+      ice_height_lookup->load_file(data_directory_ice_height+data_file_name_ice_height,this->get_mpi_communicator());
+    }
+
+
+
+    template <int dim>
+    double
+    SeaLevel<dim>::compute_nonuniform_sea_level_change(const Point<dim> &/*position*/) const
+    {
+      Assert(false, ExcNotImplemented());
+      return 0;
+    }
+
+    template <>
+    double
+    SeaLevel<3>::compute_nonuniform_sea_level_change(const Point<3> &position) const
+    {
+      const int dim = 3;
+
+      const Postprocess::Geoid<dim> &geoid =
+        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Geoid<dim>>();
+
+      const double geoid_displacement = geoid.evaluate(position); // TODO: check sign of geoid_displacement
+      const double topography = this->get_geometry_model().height_above_reference_surface(position);
+
+      Point<dim-1> long_colat;
+      const std::array<double,dim> spherical_position = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
+      for (unsigned int d = 1; d < dim; ++d)
+        long_colat[d-1] = spherical_position[d];
+
+      const double topography_init = topography_lookup->get_data(long_colat,0);
+      int ocean_mask = 0;
+      if (topography_init < 0.0)
+        ocean_mask = 1;
+      else
+        ocean_mask = 0;
+
+      const double nonuniform_sea_level_change = (geoid_displacement-topography)*ocean_mask;
+
+      return nonuniform_sea_level_change;
+    }
+
+
+
+    template <int dim>
+    double
+    SeaLevel<dim>::compute_sea_level_offset()
+    {
+      Assert(false, ExcNotImplemented());
+      return 0;
+    }
+
+    template <>
+    double
+    SeaLevel<3>::compute_sea_level_offset()
+    {
+      const int dim = 3;
+
+      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+      const Postprocess::Geoid<dim> &geoid =
+        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Geoid<dim>>();
+
+      const unsigned int quadrature_degree = this->introspection().polynomial_degree.temperature;
+      const QGauss<dim-1> quadrature_formula_face(quadrature_degree);
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula_face,
+                                        update_values |
+                                        update_quadrature_points |
+                                        update_JxW_values);
+
+      double integral_ocean_mask = 0;
+      double integral_ice_height = 0;
+      double integral_topo_geoid = 0;
+
+      // Loop over all of the boundary cells and if one is at the
+      // surface, evaluate the topography/geoid displacement/ocean mask/ice height there.
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          {
+            unsigned int face_idx = numbers::invalid_unsigned_int;
+            bool at_upper_surface = false;
+            {
+              for (const unsigned int f : cell->face_indices())
+                {
+                  if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
+                    {
+                      face_idx = f;
+                      at_upper_surface = true;
+                      break;
+                    }
+                }
+
+              // If the cell is not at the top boundary, jump to the next cell.
+              if (at_upper_surface == false)
+                continue;
+            }
+
+            // Focus on the boundary cell's upper face if on the top boundary.
+            fe_face_values.reinit(cell,face_idx);
+
+            // If the cell is at the top boundary, add its contributions to the topography/geoid displacement/ocean mask/ice height storage vectors.
+            for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+              {
+                const Point<dim> current_position = fe_face_values.quadrature_point(q);
+                const double topography = this->get_geometry_model().height_above_reference_surface(current_position);
+
+                const double geoid_displacement = geoid.evaluate(current_position);
+
+                Point<dim-1> long_colat;
+                const std::array<double,dim> spherical_position = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(current_position);
+                for (unsigned int d = 1; d < dim; ++d)
+                  long_colat[d-1] = spherical_position[d];
+
+                const double topography_init = topography_lookup->get_data(long_colat,0);
+                int ocean_mask = 0;
+                if (topography_init < 0.0)
+                  ocean_mask = 1;
+                else
+                  ocean_mask = 0;
+
+                const double ice_height = ice_height_lookup->get_data(long_colat,0);
+
+                // Compute required integrals for the sea level offset.
+                integral_ocean_mask += ocean_mask*fe_face_values.JxW(q);
+                integral_ice_height += ice_height*density_ice*(1-ocean_mask)*fe_face_values.JxW(q);
+                integral_topo_geoid += (geoid_displacement-topography)*ocean_mask*fe_face_values.JxW(q);
+              }
+          }
+
+      integral_ocean_mask = Utilities::MPI::sum (integral_ocean_mask, this->get_mpi_communicator());
+      integral_ice_height = Utilities::MPI::sum (integral_ice_height, this->get_mpi_communicator());
+      integral_topo_geoid = Utilities::MPI::sum (integral_topo_geoid, this->get_mpi_communicator());
+
+      const double sea_level_offset = -1./integral_ocean_mask*(1./density_water*integral_ice_height+integral_topo_geoid);
+
+      return sea_level_offset;
+    }
+
+
+
+    template <int dim>
+    double
+    SeaLevel<dim>::compute_total_surface_pressure(const Point<dim> &/*position*/) const
+    {
+      Assert(false, ExcNotImplemented());
+      return 0;
+    }
+
+    template <>
+    double
+    SeaLevel<3>::compute_total_surface_pressure(const Point<3> &position) const
+    {
+      // This function should be called from the boundary traction.
+      const int dim = 3;
+
+      const double nonuniform_sea_level_change = compute_nonuniform_sea_level_change(position);
+
+      Point<dim-1> long_colat;
+      const std::array<double,dim> spherical_position = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
+      for (unsigned int d = 1; d < dim; ++d)
+        long_colat[d-1] = spherical_position[d];
+      const double ice_height = ice_height_lookup->get_data(long_colat,0);
+
+      const GeometryModel::SphericalShell<dim> &geometry_model = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
+
+      // TODO: instead of outer_radius use free surface topography to get different gravity per surface point
+      const double outer_radius = geometry_model.outer_radius();
+      Point<dim> surface_point;
+      surface_point[0] = outer_radius;
+      const double surface_gravity = this->get_gravity_model().gravity_vector(surface_point).norm();
+
+      const double total_surface_pressure = surface_gravity*((nonuniform_sea_level_change+sea_level_offset)*density_water+ice_height*density_ice);
+
+      return total_surface_pressure;
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    SeaLevel<dim>::execute (TableHandler &/*statistics*/)
+    {
+      Assert(false, ExcNotImplemented());
+      return {{""},{""}};
+    }
+
+    template <>
+    std::pair<std::string,std::string>
+    SeaLevel<3>::execute (TableHandler &statistics)
+    {
+      const int dim = 3;
+
+      // Disallow use of the plugin for any other than a 3D spherical shell geometry.
+      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) && dim == 3,
+                   ExcMessage("The geoid postprocessor is currently only implemented for the 3D spherical shell geometry model."));
+
+      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
+
+      const Postprocess::Geoid<dim> &geoid =
+        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Geoid<dim>>();
+
+      // Get the sea level offset (constant for every location).
+      sea_level_offset = compute_sea_level_offset();
+
+      // Define a quadrature rule that has points only on the vertices of
+      // a face, so that we can evaluate the solution at the surface
+      // nodes.
+      const QTrapezoid<dim-1> face_corners;
+
+      FEFaceValues<dim> face_vals (this->get_mapping(), this->get_fe(), face_corners, update_quadrature_points);
+
+      // Have a stream into which we write the data. The text stream is then later sent to processor 0.
+      std::ostringstream output_stats;
+      std::ostringstream output_file;
+
+      // Choose stupidly large values for initialization.
+      double local_max_height = -std::numeric_limits<double>::max();
+      double local_min_height = std::numeric_limits<double>::max();
+
+      // Loop over all of the surface cells and save the desired data to the output file.
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          for (const unsigned int face_no : cell->face_indices())
+            if (cell->face(face_no)->at_boundary())
+              {
+                if (cell->face(face_no)->boundary_id() != top_boundary_id)
+                  continue;
+
+                face_vals.reinit(cell, face_no);
+
+                for (unsigned int corner = 0; corner < face_corners.size(); ++corner)
+                  {
+                    const Point<dim> vertex = face_vals.quadrature_point(corner);
+                    const double nonuniform_sea_level_change = compute_nonuniform_sea_level_change(vertex);
+                    const double geoid_displacement = geoid.evaluate(vertex); // TODO: check sign of geoid_displacement
+                    const double topography = this->get_geometry_model().height_above_reference_surface(vertex);
+
+                    Point<dim-1> long_colat;
+                    const std::array<double,dim> spherical_position = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(vertex);
+                    for (unsigned int d = 1; d < dim; ++d)
+                      long_colat[d-1] = spherical_position[d];
+
+                    const double ice_height = ice_height_lookup->get_data(long_colat,0);
+                    const double topography_init = topography_lookup->get_data(long_colat,0);
+                    int ocean_mask = 0;
+                    if (topography_init < 0.0)
+                      ocean_mask = 1;
+                    else
+                      ocean_mask = 0;
+
+                    if (write_to_file)
+                      {
+                        const std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(vertex);
+                        output_file << scoord[0] << ' ' << scoord[1] << ' ' << scoord[2] << ' ' << nonuniform_sea_level_change << ' ' << sea_level_offset << ' ' << geoid_displacement << ' ' << topography << ' ' << ice_height << ' ' << ocean_mask << std::endl;
+                      }
+                    if (nonuniform_sea_level_change > local_max_height)
+                      local_max_height = nonuniform_sea_level_change;
+                    if (nonuniform_sea_level_change < local_min_height)
+                      local_min_height = nonuniform_sea_level_change;
+                  }
+              }
+
+      // Calculate min/max non uniform sea_level change across all processes.
+      const double max_nonuniform_sea_level_change = Utilities::MPI::max(local_max_height, this->get_mpi_communicator());
+      const double min_nonuniform_sea_level_change = Utilities::MPI::min(local_min_height, this->get_mpi_communicator());
+
+      // Write results to statistics file.
+      statistics.add_value ("Minimum non-uniform sea_level change (m)",
+                            min_nonuniform_sea_level_change);
+      statistics.add_value ("Maximum non-uniform sea_level change (m)",
+                            max_nonuniform_sea_level_change);
+      const char *columns[] = { "Minimum non-uniform sea_level change (m)",
+                                "Maximum non-uniform sea_level change (m)"
+                              };
+      for (const auto &column : columns)
+        {
+          statistics.set_precision (column, 8);
+          statistics.set_scientific (column, true);
+        }
+
+      output_stats.precision(4);
+      output_stats << min_nonuniform_sea_level_change << " m, "
+                   << max_nonuniform_sea_level_change << " m";
+
+      // Write the solution to file.
+
+      // If this is the first time we get here, set the last output time
+      // to the current time - output_interval. This makes sure we
+      // always produce data during the first time step.
+      if (std::isnan(last_output_time))
+        {
+          last_output_time = this->get_time() - output_interval;
+        }
+
+      // Just return stats if text output is not required at all or not needed at this time.
+      if (!write_to_file || ((this->get_time() < last_output_time + output_interval)
+                             && (this->get_timestep_number() != 0)))
+        return {"Non-uniform sea level change min/max:", output_stats.str()};
+
+      const unsigned int max_data_length = Utilities::MPI::max (output_file.str().size()+1,
+                                                                this->get_mpi_communicator());
+
+      const unsigned int mpi_tag = 777;
+
+      // On processor 0, collect all of the data the individual processors sent
+      // and concatenate them into one file.
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          std::string filename = this->get_output_directory() +
+                                 "nonuniform_sea_level_change." +
+                                 Utilities::int_to_string(this->get_timestep_number(), 5);
+          if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
+            filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
+
+          std::ofstream file (filename);
+
+          file << "# "
+               << "R phi theta"
+               << " nonuniform_sea_level_change"
+               << " sea_level_offset"
+               << " geoid_displacement"
+               << " topography"
+               << " ice_height"
+               << " ocean_mask" << std::endl;
+
+          // First write out the data we have created locally.
+          file << output_file.str();
+
+          std::string tmp;
+          tmp.resize (max_data_length, '\0');
+
+          // Then loop through all of the other processors and collect
+          // data, then write it to the file.
+          for (unsigned int p=1; p<Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()); ++p)
+            {
+              MPI_Status status;
+              // Get the data. Note that MPI says that an MPI_Recv may receive
+              // less data than the length specified here. Since we have already
+              // determined the maximal message length, we use this feature here
+              // rather than trying to find out the exact message length with
+              // a call to MPI_Probe.
+              const int ierr = MPI_Recv (&tmp[0], max_data_length, MPI_CHAR, p, mpi_tag,
+                                         this->get_mpi_communicator(), &status);
+              AssertThrowMPI(ierr);
+
+              // Output the string. Note that 'tmp' has length max_data_length,
+              // but we only wrote a certain piece of it in the MPI_Recv, ended
+              // by a \0 character. Write only this part by outputting it as a
+              // C string object, rather than as a std::string.
+              file << tmp.c_str();
+            }
+        }
+      else
+        // On other processors, send the data to processor zero. include the \0
+        // character at the end of the string.
+        {
+          output_file << "\0";
+          const int ierr = MPI_Send (&output_file.str()[0], output_file.str().size()+1, MPI_CHAR, 0, mpi_tag,
+                                     this->get_mpi_communicator());
+          AssertThrowMPI(ierr);
+        }
+
+      // if output_interval is positive, then update the last supposed output time
+      if (output_interval > 0)
+        {
+          // We need to find the last time output was supposed to be written.
+          // This is the last_output_time plus the largest positive multiple
+          // of output_intervals that passed since then. We need to handle the
+          // edge case where last_output_time+output_interval==current_time,
+          // we did an output and std::floor sadly rounds to zero. This is done
+          // by forcing std::floor to round 1.0-eps to 1.0.
+          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+          last_output_time = last_output_time + std::floor((this->get_time()-last_output_time)/output_interval*magic) * output_interval/magic;
+        }
+
+      return {"Non-uniform sea level change min/max:", output_stats.str()};
+    }
+
+
+
+    template <int dim>
+    std::list<std::string>
+    SeaLevel<dim>::required_other_postprocessors() const
+    {
+      return {"geoid"};
+    }
+
+
+
+    template <int dim>
+    void
+    SeaLevel<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Sea level");
+        {
+          prm.declare_entry ("Ice density", "931",
+                             Patterns::Double(0.),
+                             "The density of ice [kg/m3]");
+          prm.declare_entry ("Water density", "1000",
+                             Patterns::Double(0.),
+                             "The density of water [kg/m3]");
+
+          prm.declare_entry ("Data directory topography",
+                             "$ASPECT_SOURCE_DIR/data/postprocess/sea-level/",
+                             Patterns::DirectoryName (),
+                             "The name of a directory that contains the topography "
+                             "ascii data. This path may either be absolute (if starting with a "
+                             "`/') or relative to the current directory. The path may also "
+                             "include the special text `$ASPECT_SOURCE_DIR' which will be "
+                             "interpreted as the path in which the ASPECT source files were "
+                             "located when ASPECT was compiled. This interpretation allows, "
+                             "for example, to reference files located in the `data/' subdirectory "
+                             "of ASPECT.");
+          prm.declare_entry ("Data file name topography", "shell_3d_topo_top.0.txt",
+                             Patterns::Anything (),
+                             "The file name of the topography ascii data. For the ascii data, "
+                             "provide file in the same format as described in "
+                             "'ascii data' initial composition plugin." );
+
+          prm.declare_entry ("Data directory ice height",
+                             "$ASPECT_SOURCE_DIR/data/postprocess/sea-level/",
+                             Patterns::DirectoryName (),
+                             "The name of a directory that contains the ice height [m] "
+                             "ascii data. This path may either be absolute (if starting with a "
+                             "`/') or relative to the current directory. The path may also "
+                             "include the special text `$ASPECT_SOURCE_DIR' which will be "
+                             "interpreted as the path in which the ASPECT source files were "
+                             "located when ASPECT was compiled. This interpretation allows, "
+                             "for example, to reference files located in the `data/' subdirectory "
+                             "of ASPECT.");
+          prm.declare_entry ("Data file name ice height", "shell_3d_ice_top.0.txt",
+                             Patterns::Anything (),
+                             "The file name of the ice height ascii data. For the ascii data, "
+                             "provide file in the same format as described in "
+                             "'ascii data' initial composition plugin." );
+
+          prm.declare_entry ("Output to file", "false",
+                             Patterns::List(Patterns::Bool()),
+                             "Whether or not to write sea level to a text file named named "
+                             "'sea_level.NNNNN' in the output directory");
+          prm.declare_entry ("Time between text output", "0.",
+                             Patterns::Double (0.),
+                             "The time interval between each generation of "
+                             "text output files. A value of zero indicates "
+                             "that output should be generated in each time step. "
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    SeaLevel<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Sea level");
+        {
+          density_ice = prm.get_double ("Ice density");
+          density_water = prm.get_double ("Water density");
+          data_directory_topography = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory topography"));
+          data_file_name_topography = prm.get ("Data file name topography");
+          data_directory_ice_height = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory ice height"));
+          data_file_name_ice_height = prm.get ("Data file name ice height");
+          write_to_file = prm.get_bool ("Output to file");
+          output_interval = prm.get_double ("Time between text output");
+          if (this->convert_output_to_years())
+            output_interval *= year_in_seconds;
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    template <class Archive>
+    void SeaLevel<dim>::serialize (Archive &ar, const unsigned int)
+    {
+      ar &last_output_time
+      & sea_level_offset;
+    }
+
+
+    template <int dim>
+    void
+    SeaLevel<dim>::save (std::map<std::string, std::string> &status_strings) const
+    {
+      std::ostringstream os;
+      aspect::oarchive oa (os);
+      oa << (*this);
+
+      status_strings["SeaLevel"] = os.str();
+    }
+
+
+    template <int dim>
+    void
+    SeaLevel<dim>::load (const std::map<std::string, std::string> &status_strings)
+    {
+      // see if something was saved
+      if (status_strings.find("SeaLevel") != status_strings.end())
+        {
+          std::istringstream is (status_strings.find("SeaLevel")->second);
+          aspect::iarchive ia (is);
+          ia >> (*this);
+        }
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(SeaLevel,
+                                  "sea level",
+                                  "A postprocessor that computes the sea level for glacial isostatic adjustment"
+                                  "modeling. When ice melts and enters the ocean, the ocean water needs to be"
+                                  "redistributed in a gravitationally consistent way. With the updated surface"
+                                  "loading (ocean and ice) the free surface deformation needs to be computed"
+                                  "iteratively before moving to the next time step. "
+                                  "A postprocessor intended for use with a deforming top surface. After every step "
+                                  "it computes the sea level based on the topography, ocean basin, ice melt, "
+                                  "perturbed gravitational potential of the Earth model and gravitational potential "
+                                  "of the ice load, relative to a reference datum (initial "
+                                  "radius for a spherical shell geometry model). "
+                                  "The sea level computation is based on \\cite{Martinec2018}. "
+                                  "If 'SeaLevel.Output to file' is set to true, also outputs sea level "
+                                  "into text files named `sea_level.NNNNN' in the output directory, "
+                                  "where NNNNN is the number of the time step. "
+                                  "\n\n"
+                                  "The file format then consists of lines with Euclidean coordinates "
+                                  "followed by the corresponding sea level value. "
+                                  "Sea level is printed/written in meters. ")
+  }
+}
diff --git a/source/postprocess/spherical_velocity_statistics.cc.bak b/source/postprocess/spherical_velocity_statistics.cc.bak
new file mode 100644
index 00000000000..e3f6eff709e
--- /dev/null
+++ b/source/postprocess/spherical_velocity_statistics.cc.bak
@@ -0,0 +1,170 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/postprocess/spherical_velocity_statistics.h>
+#include <aspect/geometry_model/two_merged_chunks.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/global.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    SphericalVelocityStatistics<dim>::execute (TableHandler &statistics)
+    {
+      Assert (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()) ||
+              Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()) ||
+              Plugins::plugin_type_matches<const GeometryModel::TwoMergedChunks<dim>> (this->get_geometry_model()) ||
+              Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()),
+              ExcMessage ("This postprocessor can only be used if the geometry "
+                          "is a sphere, spherical shell or chunk."));
+
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
+
+      double local_rad_velocity_square_integral = 0;
+      double local_tan_velocity_square_integral = 0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                                                                                        velocity_values);
+            const std::vector<Point<dim>> &position_point = fe_values.get_quadrature_points();
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                // create unit vector in radial direction
+                const Tensor<1,dim> radial_unit_vector = position_point[q] / position_point[q].norm();
+
+                // compute the radial velocity by multiplying with the radial unit vector
+                const double radial_vel = (velocity_values[q] * radial_unit_vector);
+                local_rad_velocity_square_integral += (radial_vel * radial_vel) *
+                                                      fe_values.JxW(q);
+                // compute the tangential velocity by subtracting the radial velocity from the velocity
+                const Tensor<1,dim> tangential_vel = velocity_values[q] -  radial_vel * radial_unit_vector;
+                local_tan_velocity_square_integral += (tangential_vel * tangential_vel) *
+                                                      fe_values.JxW(q);
+              }
+          }
+      // compute the global sums
+      const double global_rad_velocity_square_integral
+        = Utilities::MPI::sum (local_rad_velocity_square_integral, this->get_mpi_communicator());
+      const double global_tan_velocity_square_integral
+        = Utilities::MPI::sum (local_tan_velocity_square_integral, this->get_mpi_communicator());
+
+      // compute the final output by dividing by the volume over which
+      // we integrated and taking the sqrt
+      const double rad_vrms = std::sqrt(global_rad_velocity_square_integral / this->get_volume());
+      const double tan_vrms = std::sqrt(global_tan_velocity_square_integral / this->get_volume());
+      const double vrms = std::sqrt(rad_vrms*rad_vrms + tan_vrms*tan_vrms);
+
+      if (this->convert_output_to_years() == true)
+        {
+          // make sure that the columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          const char *columns[] = { "Radial RMS velocity (m/yr)",
+                                    "Tangential RMS velocity (m/yr)",
+                                    "Total RMS velocity (m/yr)"
+                                  };
+          statistics.add_value (columns[0],
+                                rad_vrms * year_in_seconds);
+          statistics.add_value (columns[1],
+                                tan_vrms * year_in_seconds);
+          statistics.add_value (columns[2],
+                                vrms * year_in_seconds);
+          for (auto &column : columns)
+            {
+              statistics.set_precision (column, 8);
+              statistics.set_scientific (column, true);
+            }
+        }
+      else
+        {
+          // make sure that the columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          const char *columns[] = { "Radial RMS velocity (m/s)",
+                                    "Tangential RMS velocity (m/s)",
+                                    "Total RMS velocity (m/s)"
+                                  };
+          statistics.add_value (columns[0], rad_vrms);
+          statistics.add_value (columns[1], tan_vrms);
+          statistics.add_value (columns[2], vrms);
+          for (auto &column : columns)
+            {
+              statistics.set_precision (column, 8);
+              statistics.set_scientific (column, true);
+            }
+        }
+
+      std::ostringstream output;
+      output.precision(3);
+      if (this->convert_output_to_years() == true)
+        output << rad_vrms *year_in_seconds
+               << " m/yr, "
+               << tan_vrms *year_in_seconds
+               << " m/yr, "
+               << vrms *year_in_seconds
+               << " m/yr";
+      else
+        output << rad_vrms
+               << " m/s, "
+               << tan_vrms
+               << " m/s, "
+               << vrms
+               << " m/s";
+
+      return std::pair<std::string, std::string> ("Radial RMS, tangential RMS, total RMS velocity:",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(SphericalVelocityStatistics,
+                                  "spherical velocity statistics",
+                                  "A postprocessor that computes radial, tangential and total RMS "
+                                  "velocity.")
+  }
+}
diff --git a/source/postprocess/stokes_residual.cc.bak b/source/postprocess/stokes_residual.cc.bak
new file mode 100644
index 00000000000..c3eb41da105
--- /dev/null
+++ b/source/postprocess/stokes_residual.cc.bak
@@ -0,0 +1,179 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/stokes_residual.h>
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/tria.h>
+#include <deal.II/fe/fe_dgq.h>
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/numerics/data_out_stack.h>
+
+
+#include <cmath>
+#include <vector>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    template <class Archive>
+    void StokesResidual<dim>::DataPoint::serialize (Archive &ar,
+                                                    const unsigned int)
+    {
+      ar &time &solve_index &values;
+    }
+
+
+    template <int dim>
+    StokesResidual<dim>::StokesResidual ()
+      = default;
+
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    StokesResidual<dim>::execute (TableHandler &)
+    {
+      // On the root process, write out the file.
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          std::ofstream f(this->get_output_directory() +
+                          "stokes_residuals.txt");
+          f << "# time solveidx residual\n";
+          for (unsigned int i=0; i<entries.size(); ++i)
+            {
+              for (unsigned int j=0; j<entries[i].values.size(); ++j)
+                f << entries[i].time << ' '
+                  << entries[i].solve_index << ' '
+                  << entries[i].values[j] << '\n';
+
+              f << '\n';
+            }
+          f.close();
+        }
+
+      return std::make_pair (std::string ("Writing stokes residuals"),
+                             this->get_output_directory() +
+                             "stokes_residuals.txt");
+    }
+
+    template <int dim>
+    void StokesResidual<dim>::stokes_solver_callback (const SolverControl &solver_control_cheap,
+                                                      const SolverControl &solver_control_expensive)
+    {
+      unsigned int current_solve_index = 0;
+      if (entries.size()>0 && entries.back().time == this->get_time())
+        current_solve_index = entries.back().solve_index+1;
+
+      DataPoint data_point;
+      data_point.time = this->get_time();
+      data_point.solve_index = current_solve_index;
+
+      // If there were cheap iterations add them.
+      if (solver_control_cheap.last_step() != numbers::invalid_unsigned_int)
+        {
+          data_point.values = solver_control_cheap.get_history_data();
+        }
+
+      // If there were expensive iterations add them.
+      if (solver_control_expensive.last_step() != numbers::invalid_unsigned_int)
+        {
+          // If there were cheap iterations add the expensive iterations after a signalling -1.
+          if (data_point.values.size() > 0)
+            data_point.values.push_back(-1.0);
+
+          data_point.values.insert(data_point.values.end(),
+                                   solver_control_expensive.get_history_data().begin(),
+                                   solver_control_expensive.get_history_data().end());
+        }
+
+
+      entries.push_back(data_point);
+    }
+
+    template <int dim>
+    void
+    StokesResidual<dim>::initialize ()
+    {
+      this->get_signals().post_stokes_solver.connect(
+        [&](const SimulatorAccess<dim> &,
+            const unsigned int /*number_S_iterations*/,
+            const unsigned int /*number_A_iterations*/,
+            const SolverControl &solver_control_cheap,
+            const SolverControl &solver_control_expensive)
+      {
+        this->stokes_solver_callback(solver_control_cheap,solver_control_expensive);
+      });
+    }
+
+    template <int dim>
+    template <class Archive>
+    void StokesResidual<dim>::serialize (Archive &ar, const unsigned int)
+    {
+      ar &entries;
+    }
+
+
+    template <int dim>
+    void
+    StokesResidual<dim>::save (std::map<std::string, std::string> &status_strings) const
+    {
+      std::ostringstream os;
+      aspect::oarchive oa (os);
+      oa << (*this);
+
+      status_strings["StokesResidual"] = os.str();
+    }
+
+
+    template <int dim>
+    void
+    StokesResidual<dim>::load (const std::map<std::string, std::string> &status_strings)
+    {
+      // see if something was saved
+      if (status_strings.find("StokesResidual") != status_strings.end())
+        {
+          std::istringstream is (status_strings.find("StokesResidual")->second);
+          aspect::iarchive ia (is);
+          ia >> (*this);
+        }
+    }
+
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(StokesResidual,
+                                  "Stokes residual",
+                                  "A postprocessor that outputs the Stokes residuals during the iterative solver algorithm into a file stokes_residuals.txt in the output directory.")
+  }
+}
diff --git a/source/postprocess/temperature_statistics.cc.bak b/source/postprocess/temperature_statistics.cc.bak
new file mode 100644
index 00000000000..ed9f178853b
--- /dev/null
+++ b/source/postprocess/temperature_statistics.cc.bak
@@ -0,0 +1,172 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/temperature_statistics.h>
+#include <aspect/boundary_temperature/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    TemperatureStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula based on the temperature element alone.
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      std::vector<double> temperature_values(n_q_points);
+
+      double local_temperature_integral = 0;
+
+      // compute the integral quantities by quadrature
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
+                                                                                         temperature_values);
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                local_temperature_integral += temperature_values[q]*fe_values.JxW(q);
+              }
+          }
+
+      // compute min/max by simply
+      // looping over the elements of the
+      // solution vector. the reason is
+      // that minimum and maximum are
+      // usually attained at the
+      // boundary, and so taking their
+      // values at Gauss quadrature
+      // points gives an inaccurate
+      // picture of their true values
+      double local_min_temperature = std::numeric_limits<double>::max();
+      double local_max_temperature = std::numeric_limits<double>::lowest();
+      const unsigned int temperature_block = this->introspection().block_indices.temperature;
+      IndexSet range = this->get_solution().block(temperature_block).locally_owned_elements();
+      for (unsigned int i=0; i<range.n_elements(); ++i)
+        {
+          const unsigned int idx = range.nth_index_in_set(i);
+          const double val =  this->get_solution().block(temperature_block)(idx);
+
+          local_min_temperature = std::min<double> (local_min_temperature, val);
+          local_max_temperature = std::max<double> (local_max_temperature, val);
+        }
+
+      const double global_temperature_integral
+        = Utilities::MPI::sum (local_temperature_integral, this->get_mpi_communicator());
+      double global_min_temperature = 0;
+      double global_max_temperature = 0;
+
+      // now do the reductions that are
+      // min/max operations. do them in
+      // one communication by multiplying
+      // one value by -1
+      {
+        double local_values[2] = { -local_min_temperature, local_max_temperature };
+        double global_values[2];
+
+        Utilities::MPI::max (local_values, this->get_mpi_communicator(), global_values);
+
+        global_min_temperature = -global_values[0];
+        global_max_temperature = global_values[1];
+      }
+
+      double global_mean_temperature = global_temperature_integral / this->get_volume();
+      statistics.add_value ("Minimal temperature (K)",
+                            global_min_temperature);
+      statistics.add_value ("Average temperature (K)",
+                            global_mean_temperature);
+      statistics.add_value ("Maximal temperature (K)",
+                            global_max_temperature);
+      if ((this->get_fixed_temperature_boundary_indicators().size() > 0)
+          &&
+          (this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators())
+           !=
+           this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators())))
+        statistics.add_value ("Average nondimensional temperature (K)",
+                              (global_mean_temperature - global_min_temperature) /
+                              (this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators())
+                               -
+                               this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators())));
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      {
+        const char *columns[] = { "Minimal temperature (K)",
+                                  "Average temperature (K)",
+                                  "Maximal temperature (K)"
+                                };
+        for (auto &column : columns)
+          {
+            statistics.set_precision (column, 8);
+            statistics.set_scientific (column, true);
+          }
+
+        if ((this->get_fixed_temperature_boundary_indicators().size() > 0)
+            &&
+            (this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators())
+             !=
+             this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators())))
+          {
+            statistics.set_precision ("Average nondimensional temperature (K)", 8);
+            statistics.set_scientific ("Average nondimensional temperature (K)", true);
+          }
+      }
+
+      std::ostringstream output;
+      output.precision(4);
+      output << global_min_temperature << " K, "
+             << global_temperature_integral / this->get_volume() << " K, "
+             << global_max_temperature << " K";
+
+      return std::pair<std::string, std::string> ("Temperature min/avg/max:",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(TemperatureStatistics,
+                                  "temperature statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the temperature field.")
+  }
+}
diff --git a/source/postprocess/topography.cc.bak b/source/postprocess/topography.cc.bak
new file mode 100644
index 00000000000..3fe13e569f9
--- /dev/null
+++ b/source/postprocess/topography.cc.bak
@@ -0,0 +1,250 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/topography.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <cmath>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    Topography<dim>::execute (TableHandler &statistics)
+    {
+      //Disallow use of the plugin with sphere geometry model
+      AssertThrow(!Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()),
+                  ExcMessage("Topography postprocessor is not yet implemented "
+                             "for the sphere geometry model. "
+                             "Consider using a box, spherical shell, or chunk.") );
+
+      const types::boundary_id relevant_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id ("top");
+
+      // Define a quadrature rule that has points only on the vertices of
+      // a face, so that we can evaluate the solution at the surface
+      // nodes.
+      const QTrapezoid<dim-1> face_corners;
+      FEFaceValues<dim> face_vals (this->get_mapping(), this->get_fe(), face_corners, update_quadrature_points);
+
+      // have a stream into which we write the data. the text stream is then
+      // later sent to processor 0
+      std::ostringstream output_stats;
+      std::ostringstream output_file;
+
+      // On processor 0, write the file header
+      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+        {
+          output_file << "# "
+                      << ((dim==2)? "x y" : "x y z")
+                      << " topography" << std::endl;
+        }
+
+      // Choose stupidly large values for initialization
+      double local_max_height = std::numeric_limits<double>::lowest();
+      double local_min_height = std::numeric_limits<double>::max();
+
+      // loop over all of the surface cells and save the elevation to stored_value
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned() && cell->at_boundary())
+          for (const unsigned int face_no : cell->face_indices())
+            if (cell->face(face_no)->at_boundary())
+              {
+                if ( cell->face(face_no)->boundary_id() != relevant_boundary)
+                  continue;
+
+                face_vals.reinit( cell, face_no);
+
+                for (unsigned int corner = 0; corner < face_corners.size(); ++corner)
+                  {
+                    const Point<dim> vertex = face_vals.quadrature_point(corner);
+                    const double elevation = this->get_geometry_model().height_above_reference_surface(vertex);
+                    if (write_to_file)
+                      output_file << vertex << ' '<< elevation << std::endl;
+                    if ( elevation > local_max_height)
+                      local_max_height = elevation;
+                    if ( elevation < local_min_height)
+                      local_min_height = elevation;
+                  }
+              }
+
+      //Calculate min/max topography across all processes
+      const double max_topography = Utilities::MPI::max(local_max_height, this->get_mpi_communicator());
+      const double min_topography = Utilities::MPI::min(local_min_height, this->get_mpi_communicator());
+
+      //Write results to statistics file
+      statistics.add_value ("Minimum topography (m)",
+                            min_topography);
+      statistics.add_value ("Maximum topography (m)",
+                            max_topography);
+      const char *columns[] = { "Minimum topography (m)",
+                                "Maximum topography (m)"
+                              };
+      for (auto &column : columns)
+        {
+          statistics.set_precision (column, 8);
+          statistics.set_scientific (column, true);
+        }
+
+      output_stats.precision(4);
+      output_stats << min_topography << " m, "
+                   << max_topography << " m";
+
+      // Write the solution to file
+
+      // if this is the first time we get here, set the last output time
+      // to the current time - output_interval. this makes sure we
+      // always produce data during the first time step
+      if (std::isnan(last_output_time))
+        {
+          last_output_time = this->get_time() - output_interval;
+        }
+
+      // Just return stats if text output is not required at all or not needed at this time
+      if (!write_to_file || ((this->get_time() < last_output_time + output_interval)
+                             && (this->get_timestep_number() != 0)))
+        return std::pair<std::string, std::string> ("Topography min/max:",
+                                                    output_stats.str());
+
+      std::string filename = this->get_output_directory() +
+                             "topography." +
+                             Utilities::int_to_string(this->get_timestep_number(), 5);
+      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
+        filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
+
+      Utilities::collect_and_write_file_content(filename,
+                                                output_file.str(),
+                                                this->get_mpi_communicator());
+
+      // if output_interval is positive, then update the last supposed output
+      // time
+      if (output_interval > 0)
+        {
+          // We need to find the last time output was supposed to be written.
+          // this is the last_output_time plus the largest positive multiple
+          // of output_intervals that passed since then. We need to handle the
+          // edge case where last_output_time+output_interval==current_time,
+          // we did an output and std::floor sadly rounds to zero. This is done
+          // by forcing std::floor to round 1.0-eps to 1.0.
+          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+          last_output_time = last_output_time + std::floor((this->get_time()-last_output_time)/output_interval*magic) * output_interval/magic;
+        }
+
+      return std::pair<std::string, std::string> ("Topography min/max:",
+                                                  output_stats.str());
+    }
+
+    template <int dim>
+    void
+    Topography<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Topography");
+        {
+          prm.declare_entry ("Output to file", "false",
+                             Patterns::Bool(),
+                             "Whether or not to write topography to a text file named named "
+                             "'topography.NNNNN' in the output directory");
+
+          prm.declare_entry ("Time between text output", "0.",
+                             Patterns::Double (0.),
+                             "The time interval between each generation of "
+                             "text output files. A value of zero indicates "
+                             "that output should be generated in each time step. "
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Topography<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Topography");
+        {
+          write_to_file        = prm.get_bool ("Output to file");
+          output_interval = prm.get_double ("Time between text output");
+          if (this->convert_output_to_years())
+            output_interval *= year_in_seconds;
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(Topography,
+                                  "topography",
+                                  "A postprocessor intended for use with a deforming top surface.  After every step "
+                                  "it loops over all the vertices on the top surface and determines the "
+                                  "maximum and minimum topography relative to a reference datum (initial "
+                                  "box height for a box geometry model or initial radius for a "
+                                  "sphere/spherical shell geometry model). "
+                                  "If 'Topography.Output to file' is set to true, also outputs topography "
+                                  "into text files named `topography.NNNNN' in the output directory, "
+                                  "where NNNNN is the number of the time step.\n"
+                                  "The file format then consists of lines with Euclidean coordinates "
+                                  "followed by the corresponding topography value."
+                                  "Topography is printed/written in meters."
+                                  "\n\n"
+                                  "It is worth comparing this postprocessor with the "
+                                  "visualization postprocessor called ``surface elevation''. The latter is "
+                                  "used to *visualize* the surface elevation in graphical form, by "
+                                  "outputting it into the same files that the solution and other "
+                                  "postprocessed variables are written, to then be used for "
+                                  "visualization using programs such as VisIt or Paraview. In "
+                                  "contrast, the current postprocessor generates the same *kind* "
+                                  "of information, but instead writes it as a point cloud that "
+                                  "can then more easily be processed using tools other "
+                                  "than visualization programs.")
+  }
+}
diff --git a/source/postprocess/velocity_boundary_statistics.cc.bak b/source/postprocess/velocity_boundary_statistics.cc.bak
new file mode 100644
index 00000000000..aa68fce50ee
--- /dev/null
+++ b/source/postprocess/velocity_boundary_statistics.cc.bak
@@ -0,0 +1,217 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/postprocess/velocity_boundary_statistics.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    VelocityBoundaryStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // create a quadrature formula for the velocity.
+      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.velocities;
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula,
+                                        update_values |
+                                        update_JxW_values |
+                                        update_quadrature_points);
+
+      std::vector<Tensor<1,dim>> velocities (fe_face_values.n_quadrature_points);
+
+      std::map<types::boundary_id, double> local_max_vel;
+      std::map<types::boundary_id, double> local_min_vel;
+      std::map<types::boundary_id, double> local_velocity_square_integral;
+      std::map<types::boundary_id, double> local_boundary_area;
+
+      const std::set<types::boundary_id>
+      boundary_indicators
+        = this->get_geometry_model().get_used_boundary_indicators ();
+      for (const auto p : boundary_indicators)
+        {
+          local_max_vel[p] = std::numeric_limits<double>::lowest();
+          local_min_vel[p] = std::numeric_limits<double>::max();
+        }
+
+      // for every surface face that is part of a geometry boundary
+      // and that is owned by this processor,
+      // compute the maximum, minimum, and squared*area velocity magnitude,
+      // and the face area.
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (const unsigned int f : cell->face_indices())
+            if (cell->face(f)->at_boundary())
+              {
+                fe_face_values.reinit (cell, f);
+                // extract velocities
+                fe_face_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                    velocities);
+                // determine the max, min, and squared velocity on the face
+                // also determine the face area
+                double local_max = std::numeric_limits<double>::lowest();
+                double local_min = std::numeric_limits<double>::max();
+                double local_sqvel = 0.0;
+                double local_fe_face_area = 0.0;
+                for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                  {
+                    const double vel_mag = velocities[q].norm();
+                    local_max = std::max(vel_mag,
+                                         local_max);
+                    local_min = std::min(vel_mag,
+                                         local_min);
+                    local_sqvel += ((vel_mag * vel_mag) * fe_face_values.JxW(q));
+                    local_fe_face_area += fe_face_values.JxW(q);
+                  }
+
+                // then merge them with the min/max/squared velocities
+                // and face areas we found for other faces with the same boundary indicator
+                const types::boundary_id boundary_indicator
+                  = cell->face(f)->boundary_id();
+
+                local_max_vel[boundary_indicator] = std::max(local_max,
+                                                             local_max_vel[boundary_indicator]);
+                local_min_vel[boundary_indicator] = std::min(local_min,
+                                                             local_min_vel[boundary_indicator]);
+                local_velocity_square_integral[boundary_indicator] += local_sqvel;
+                local_boundary_area[boundary_indicator] += local_fe_face_area;
+              }
+
+      // now communicate to get the global values
+      std::map<types::boundary_id, double> global_max_vel;
+      std::map<types::boundary_id, double> global_min_vel;
+      std::map<types::boundary_id, double> global_rms_vel;
+      {
+        // first collect local values in the same order in which they are listed
+        // in the set of boundary indicators
+        std::vector<double> local_max_values;
+        std::vector<double> local_min_values;
+        std::vector<double> local_velocity_square_integral_values;
+        std::vector<double> local_boundary_area_values;
+
+        for (const auto boundary_id : boundary_indicators)
+          {
+            local_max_values.push_back (local_max_vel[boundary_id]);
+            local_min_values.push_back (local_min_vel[boundary_id]);
+
+            local_velocity_square_integral_values.push_back (local_velocity_square_integral[boundary_id]);
+            local_boundary_area_values.push_back (local_boundary_area[boundary_id]);
+          }
+        // then collect contributions from all processors
+        std::vector<double> global_max_values (local_max_values.size());
+        Utilities::MPI::max (local_max_values, this->get_mpi_communicator(), global_max_values);
+        std::vector<double> global_min_values (local_min_values.size());
+        Utilities::MPI::min (local_min_values, this->get_mpi_communicator(), global_min_values);
+
+        std::vector<double> global_velocity_square_integral_values (local_velocity_square_integral_values.size());
+        Utilities::MPI::sum(local_velocity_square_integral_values,this->get_mpi_communicator(),global_velocity_square_integral_values);
+        std::vector<double> global_boundary_area_values (local_boundary_area_values.size());
+        Utilities::MPI::sum(local_boundary_area_values,this->get_mpi_communicator(),global_boundary_area_values);
+
+        // and now take them apart into the global map again
+        // At the same time, calculate the rms velocity for each boundary
+        unsigned int index = 0;
+        for (const auto boundary_id: boundary_indicators)
+          {
+            global_max_vel[boundary_id] = global_max_values[index];
+            global_min_vel[boundary_id] = global_min_values[index];
+            global_rms_vel[boundary_id] = std::sqrt(global_velocity_square_integral_values[index] / global_boundary_area_values[index]);
+            ++index;
+          }
+      }
+
+      // now add the computed max, min, and rms velocities to the statistics object
+      // and create a single string that can be output to the screen
+      const std::string units = (this->convert_output_to_years() == true) ? "m/year" : "m/s";
+      const double unit_scale_factor = (this->convert_output_to_years() == true) ? year_in_seconds : 1.0;
+      std::ostringstream screen_text;
+      unsigned int index = 0;
+
+      for (std::map<types::boundary_id, double>::const_iterator
+           max_velocity = global_max_vel.begin(), min_velocity = global_min_vel.begin(), rms = global_rms_vel.begin();
+           max_velocity != global_max_vel.end() && min_velocity != global_min_vel.end() && rms != global_rms_vel.end();
+           ++max_velocity, ++min_velocity, ++rms, ++index)
+        {
+          const std::string name_max = "Maximum velocity magnitude on boundary with indicator "
+                                       + Utilities::int_to_string(max_velocity->first)
+                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                     .translate_id_to_symbol_name (max_velocity->first))
+                                       + " (" + units + ")";
+          statistics.add_value (name_max, max_velocity->second*unit_scale_factor);
+          const std::string name_min = "Minimum velocity magnitude on boundary with indicator "
+                                       + Utilities::int_to_string(min_velocity->first)
+                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                     .translate_id_to_symbol_name (min_velocity->first))
+                                       + " (" + units + ")";
+          statistics.add_value (name_min, min_velocity->second*unit_scale_factor);
+          const std::string name_rms = "RMS velocity on boundary with indicator "
+                                       + Utilities::int_to_string(rms->first)
+                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
+                                                                                     .translate_id_to_symbol_name (rms->first))
+                                       + " (" + units + ")";
+          statistics.add_value (name_rms, rms->second*unit_scale_factor);
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (name_max, 8);
+          statistics.set_scientific (name_max, true);
+          statistics.set_precision (name_min, 8);
+          statistics.set_scientific (name_min, true);
+          statistics.set_precision (name_rms, 8);
+          statistics.set_scientific (name_rms, true);
+
+          // finally have something for the screen
+          screen_text.precision(4);
+          screen_text << max_velocity->second *unit_scale_factor << ' ' << units << ", "
+                      << min_velocity->second *unit_scale_factor << ' ' << units << ", "
+                      << rms->second *unit_scale_factor << ' ' << units
+                      << (index == global_max_vel.size()-1 ? "" : ", ");
+        }
+
+      return std::pair<std::string, std::string> ("Max, min, and rms velocity along boundary parts:",
+                                                  screen_text.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(VelocityBoundaryStatistics,
+                                  "velocity boundary statistics",
+                                  "A postprocessor that computes some statistics about "
+                                  "the velocity along the boundaries. For each boundary "
+                                  "indicator (see your geometry description for which boundary "
+                                  "indicators are used), the min and max velocity magnitude is computed.")
+  }
+}
diff --git a/source/postprocess/velocity_statistics.cc.bak b/source/postprocess/velocity_statistics.cc.bak
new file mode 100644
index 00000000000..0ff4d66c43d
--- /dev/null
+++ b/source/postprocess/velocity_statistics.cc.bak
@@ -0,0 +1,118 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/velocity_statistics.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/global.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    VelocityStatistics<dim>::execute (TableHandler &statistics)
+    {
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
+
+      double local_velocity_square_integral = 0;
+      double local_max_velocity = 0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                                                                                        velocity_values);
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                local_velocity_square_integral += ((velocity_values[q] * velocity_values[q]) *
+                                                   fe_values.JxW(q));
+                local_max_velocity = std::max (std::sqrt(velocity_values[q]*velocity_values[q]),
+                                               local_max_velocity);
+              }
+          }
+
+      const double global_velocity_square_integral
+        = Utilities::MPI::sum (local_velocity_square_integral, this->get_mpi_communicator());
+      const double global_max_velocity
+        = Utilities::MPI::max (local_max_velocity, this->get_mpi_communicator());
+
+      const double vrms = std::sqrt(global_velocity_square_integral) /
+                          std::sqrt(this->get_volume());
+
+      const std::string units = (this->convert_output_to_years() == true) ? "m/year" : "m/s";
+      const double unit_scale_factor = (this->convert_output_to_years() == true) ? year_in_seconds : 1.0;
+      const std::vector<std::string> column_names = {"RMS velocity (" + units + ")",
+                                                     "Max. velocity (" + units + ")"
+                                                    };
+
+      statistics.add_value (column_names[0],
+                            vrms * unit_scale_factor);
+      statistics.add_value (column_names[1],
+                            global_max_velocity * unit_scale_factor);
+
+      // also make sure that the other columns filled by this object
+      // all show up with sufficient accuracy and in scientific notation
+      for (auto &column : column_names)
+        {
+          statistics.set_precision (column, 8);
+          statistics.set_scientific (column, true);
+        }
+
+      std::ostringstream output;
+      output.precision(3);
+      output << vrms *unit_scale_factor
+             << ' ' << units << ", "
+             << global_max_velocity *unit_scale_factor
+             << ' ' << units;
+
+      return std::pair<std::string, std::string> ("RMS, max velocity:",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(VelocityStatistics,
+                                  "velocity statistics",
+                                  "A postprocessor that computes the root mean square and "
+                                  "maximum velocity in the computational domain.")
+  }
+}
diff --git a/source/postprocess/viscous_dissipation_statistics.cc.bak b/source/postprocess/viscous_dissipation_statistics.cc.bak
new file mode 100644
index 00000000000..d4f47a29f54
--- /dev/null
+++ b/source/postprocess/viscous_dissipation_statistics.cc.bak
@@ -0,0 +1,168 @@
+/*
+  Copyright (C) 2011 - 2023-2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/viscous_dissipation_statistics.h>
+#include <aspect/global.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    ViscousDissipationStatistics<dim>::execute (TableHandler &statistics)
+    {
+      // Create a quadrature formula based on the velocity element.
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
+
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_gradients |
+                               update_JxW_values);
+
+      // Vector to store the local dissipation for all the fields and
+      // for the whole domain.
+      const unsigned int n_compositional_fields = this->n_compositional_fields();
+
+      std::vector<double> local_dissipation_integral (n_compositional_fields+1);
+      std::vector<double> compositional_values(n_q_points);
+
+      typename MaterialModel::Interface<dim>::MaterialModelInputs in(n_q_points,
+                                                                     n_compositional_fields);
+      typename MaterialModel::Interface<dim>::MaterialModelOutputs out(n_q_points,
+                                                                       n_compositional_fields);
+      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+
+            in.reinit(fe_values,
+                      cell,
+                      this->introspection(),
+                      this->get_solution());
+
+            this->get_material_model().fill_additional_material_model_inputs(in,
+                                                                             this->get_solution(),
+                                                                             fe_values,
+                                                                             this->introspection());
+
+            this->get_material_model().evaluate(in, out);
+
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                // Viscous dissipation D in 3d:
+                // D = 1/2 * volume_integral(deviatoric_stress*deviatoric_strain_rate)
+                //   = 1/2 * volume_integral(2*eta*deviatoric_strain_rate*deviatoric_strain_rate)
+                //   = volume_integral(eta*deviatoric_strain_rate*deviatoric_strain_rate)
+                const SymmetricTensor<2, dim> deviatoric_strain_rate =
+                  (this->get_material_model().is_compressible()
+                   ? in.strain_rate[q] - 1. / 3. * trace(in.strain_rate[q]) * unit_symmetric_tensor<dim>()
+                   : in.strain_rate[q]);
+                const double local_dissipation = out.viscosities[q] * (deviatoric_strain_rate *
+                                                                       deviatoric_strain_rate) * fe_values.JxW(q);
+
+                // Dissipation over the whole domain
+                local_dissipation_integral[n_compositional_fields] += local_dissipation;
+
+                // Dissipation over each compositional field
+                for (unsigned int c = 0; c<n_compositional_fields; ++c)
+                  if (in.composition[q][c] >= 0.5)
+                    local_dissipation_integral[c] += local_dissipation;
+              }
+          }
+
+      std::vector<double> viscous_dissipation (local_dissipation_integral.size());
+      Utilities::MPI::sum (local_dissipation_integral, this->get_mpi_communicator(), viscous_dissipation);
+
+      const std::string unit = (dim == 3) ? "(W)" : "(W/m)";
+
+      // Add the dissipation per compositional fields to the statistics output
+      for (unsigned int c = 0; c < n_compositional_fields; ++c)
+        {
+          statistics.add_value ("Viscous dissipation " + unit + " for composition " + this->introspection().name_for_compositional_index(c),
+                                viscous_dissipation[c]);
+
+          // also make sure that the other columns filled by this object
+          // all show up with sufficient accuracy and in scientific notation
+          const std::string column = "Viscous dissipation " + unit + " for composition " + this->introspection().name_for_compositional_index(c);
+
+          statistics.set_precision (column, 8);
+          statistics.set_scientific (column, true);
+        }
+
+      // Add the dissipation over the whole domain to the statistics output
+      statistics.add_value ("Viscous dissipation " + unit,
+                            viscous_dissipation[n_compositional_fields]);
+
+      const std::string column = "Viscous dissipation " + unit;
+      statistics.set_precision (column, 8);
+      statistics.set_scientific (column, true);
+
+      std::ostringstream output;
+      output.precision(4);
+
+      for (unsigned int n = 0; n < n_compositional_fields + 1; ++n)
+        {
+          output << viscous_dissipation[n];
+
+          if (n + 1 != n_compositional_fields+1)
+            output << " // ";
+        }
+
+      return std::pair<std::string, std::string> ("Viscous dissipation per field and for whole domain " + unit + ":",
+                                                  output.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(ViscousDissipationStatistics,
+                                  "viscous dissipation statistics",
+                                  "A postprocessor that outputs the viscous rate of dissipation of "
+                                  "energy for each compositional field (where the field has a value "
+                                  "of 0.5 or more) as well as over the whole domain. "
+                                  "When all the fields represent lithologies and there is no background "
+                                  "field, the sum of the individual field's dissipation should equal "
+                                  "that over the whole domain. "
+                                  "The viscous dissipation is computed as: "
+                                  "$\\int_{V}\\left(\\sigma^\\prime \\dot{\\epsilon}^\\prime \\right)$, "
+                                  "where $\\sigma^\\prime$  is the deviatoric stress and $\\dot{\\epsilon}^\\prime$ "
+                                  "the deviatoric strain rate."
+                                  "Note then when shear heating is included in the temperature equation, "
+                                  "it is better to use the 'heating statistics' postprocessor.")
+  }
+}
diff --git a/source/postprocess/visualization.cc.bak b/source/postprocess/visualization.cc.bak
new file mode 100644
index 00000000000..61e3886af92
--- /dev/null
+++ b/source/postprocess/visualization.cc.bak
@@ -0,0 +1,1688 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+#include <aspect/simulator.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <deal.II/fe/mapping_q1_eulerian.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/numerics/data_out_faces.h>
+
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+
+#include <cmath>
+#include <cstdio>
+#include <unistd.h>
+
+#include <algorithm>
+#include <type_traits>
+
+#include <boost/lexical_cast.hpp>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace
+    {
+      /**
+       * This Postprocessor will generate the output variables of velocity,
+       * pressure, temperature, and compositional fields. They can not be added
+       * directly if the velocity needs to be converted from m/s to m/year, so
+       * this is what this class does.
+       */
+      template <int dim>
+      class BaseVariablePostprocessor: public DataPostprocessor<dim>, public SimulatorAccess<dim>
+      {
+        public:
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override
+          {
+            const double velocity_scaling_factor =
+              this->convert_output_to_years() ? year_in_seconds : 1.0;
+            const unsigned int n_q_points = input_data.solution_values.size();
+            for (unsigned int q=0; q<n_q_points; ++q)
+              for (unsigned int i=0; i<computed_quantities[q].size(); ++i)
+                {
+                  // scale velocities and fluid velocities by year_in_seconds if needed
+                  if (this->introspection().component_masks.velocities[i] ||
+                      (this->include_melt_transport()
+                       && this->introspection().variable("fluid velocity").component_mask[i]))
+                    computed_quantities[q][i] = input_data.solution_values[q][i] * velocity_scaling_factor;
+                  else
+                    computed_quantities[q][i] = input_data.solution_values[q][i];
+                }
+          }
+
+
+          std::vector<std::string>
+          get_names () const override
+          {
+            std::vector<std::string> solution_names (dim, "velocity");
+
+            if (this->include_melt_transport())
+              {
+                solution_names.emplace_back("p_f");
+                solution_names.emplace_back("p_c_bar");
+                for (unsigned int i=0; i<dim; ++i)
+                  solution_names.emplace_back("u_f");
+              }
+            solution_names.emplace_back("p");
+
+            solution_names.emplace_back("T");
+            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+              solution_names.push_back (this->introspection().name_for_compositional_index(c));
+
+            return solution_names;
+          }
+
+
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          get_data_component_interpretation () const override
+          {
+            std::vector<DataComponentInterpretation::DataComponentInterpretation>
+            interpretation (dim,
+                            DataComponentInterpretation::component_is_part_of_vector);
+            if (this->include_melt_transport())
+              {
+                interpretation.push_back (DataComponentInterpretation::component_is_scalar);
+                interpretation.push_back (DataComponentInterpretation::component_is_scalar);
+                for (unsigned int i=0; i<dim; ++i)
+                  interpretation.push_back (DataComponentInterpretation::component_is_part_of_vector);
+              }
+            interpretation.push_back (DataComponentInterpretation::component_is_scalar); // p
+            interpretation.push_back (DataComponentInterpretation::component_is_scalar); // T
+            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+              interpretation.push_back (DataComponentInterpretation::component_is_scalar);
+
+            return interpretation;
+          }
+
+
+          UpdateFlags
+          get_needed_update_flags () const override
+          {
+            return update_values;
+          }
+
+
+          std::vector<std::string>
+          get_physical_units () const
+          {
+            std::vector<std::string> solution_units;
+
+            if (this->convert_output_to_years())
+              for (unsigned int d=0; d<dim; ++d)
+                solution_units.emplace_back("m/year");
+            else
+              for (unsigned int d=0; d<dim; ++d)
+                solution_units.emplace_back("m/s");
+
+            if (this->include_melt_transport())
+              {
+                solution_units.emplace_back("Pa"); // fluid pressure
+                solution_units.emplace_back("Pa"); // scaled pressure
+                for (unsigned int i=0; i<dim; ++i)
+                  solution_units.emplace_back("m/s");
+              }
+            solution_units.emplace_back("Pa");
+
+            solution_units.emplace_back("K");
+            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+              solution_units.emplace_back(""); // we don't know here
+
+            return solution_units;
+          }
+      };
+
+      /**
+       * Adapt the previous class BaseVariablePostprocessor for the case of surface output,
+       * so output on the surface of the model domain. The only difference with the previous
+       * class is that each output variable name is prepended with the string 'surface_'.
+       */
+      template <int dim>
+      class SurfaceBaseVariablePostprocessor: public VisualizationPostprocessors::SurfaceOnlyVisualization<dim>, public BaseVariablePostprocessor<dim>
+      {
+        public:
+
+          std::vector<std::string> get_names () const override
+          {
+            std::vector<std::string> solution_names = BaseVariablePostprocessor<dim>::get_names();
+
+            for (std::string &name : solution_names)
+              name = "surface_" + name;
+
+            return solution_names;
+          }
+
+      };
+
+      /**
+       * This Postprocessor will generate the output variables of mesh velocity and
+       * mesh displacement for when a deforming mesh is used.
+       */
+      template <int dim>
+      class MeshDeformationPostprocessor: public DataPostprocessorVector<dim>, public SimulatorAccess<dim>
+      {
+        public:
+          MeshDeformationPostprocessor (const std::string &name,
+                                        bool is_velocity)
+            : DataPostprocessorVector<dim>(name,
+                                           update_values),
+            is_velocity(is_velocity)
+          {}
+
+
+          void
+          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                                std::vector<Vector<double>> &computed_quantities) const override
+          {
+            // check that the first quadrature point has dim components
+            Assert( computed_quantities[0].size() == dim,
+                    ExcMessage("Unexpected dimension in mesh velocity postprocessor"));
+            const double velocity_scaling_factor =
+              (is_velocity && this->convert_output_to_years()) ? year_in_seconds : 1.0;
+            const unsigned int n_q_points = input_data.solution_values.size();
+            for (unsigned int q=0; q<n_q_points; ++q)
+              for (unsigned int i=0; i<dim; ++i)
+                computed_quantities[q][i] = input_data.solution_values[q][i] * velocity_scaling_factor;
+          }
+
+
+          std::string
+          get_physical_units () const
+          {
+            if (is_velocity)
+              {
+                if (this->convert_output_to_years())
+                  return "m/year";
+                else
+                  return "m/s";
+              }
+            else
+              return "m";
+          }
+          bool is_velocity;
+      };
+    }
+
+
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      Interface<dim>::Interface (const std::string &physical_units)
+        :
+        physical_units (physical_units)
+      {}
+
+
+
+      template <int dim>
+      std::string
+      Interface<dim>::get_physical_units () const
+      {
+        return physical_units;
+      }
+
+
+
+      template <int dim>
+      std::list<std::string>
+      Interface<dim>::required_other_postprocessors () const
+      {
+        return {};
+      }
+
+
+
+      template <int dim>
+      void
+      Interface<dim>::save (std::map<std::string,std::string> &) const
+      {}
+
+
+      template <int dim>
+      void
+      Interface<dim>::load (const std::map<std::string,std::string> &)
+      {}
+
+
+
+      template <int dim>
+      CellDataVectorCreator<dim>::CellDataVectorCreator (const std::string &physical_units)
+        :
+        Interface<dim> (physical_units)
+      {}
+    }
+
+
+    template <int dim>
+    Visualization<dim>::OutputHistory::OutputHistory()
+      :
+      // Record that we have not yet written any meshes and so
+      // there are none we can reference from future output operations.
+      mesh_changed (true)
+    {}
+
+
+
+    template <int dim>
+    Visualization<dim>::OutputHistory::~OutputHistory()
+    {
+      // Make sure that any thread that may still be running in the background,
+      // writing data, finishes
+      if (background_thread.joinable())
+        background_thread.join ();
+    }
+
+
+
+    template <int dim>
+    template <class Archive>
+    void Visualization<dim>::OutputHistory::serialize (Archive &ar, const unsigned int)
+    {
+      ar
+      & last_mesh_file_name
+      & times_and_pvtu_names
+      & output_file_names_by_timestep
+      & xdmf_entries
+      ;
+
+      // We do not serialize mesh_changed but use the default (true) from our
+      // constructor. This will result in a new mesh file the first time we
+      // create visualization output after resuming from a snapshot. Otherwise
+      // we might get corrupted graphical output, because the ordering of
+      // vertices can be different after resuming. (This is because when
+      // deal.II builds a triangulation, it tears down and re-creates its mesh every time
+      // p4est changes the partitioning; this process introduces a history where
+      // cells and vertices may be numbered differently if the triangulation
+      // had previous content than when -- as is done after a restart -- the
+      // triangulation is empty.)
+    }
+
+
+
+    template <int dim>
+    Visualization<dim>::Visualization ()
+      :
+      // the following value is later read from the input file
+      output_interval (0),
+      // initialize this to a nonsensical value; set it to the actual time
+      // the first time around we get to check it
+      last_output_time (std::numeric_limits<double>::quiet_NaN()),
+      maximum_timesteps_between_outputs (std::numeric_limits<int>::max()),
+      last_output_timestep (numbers::invalid_unsigned_int),
+      output_file_number (numbers::invalid_unsigned_int)
+    {}
+
+
+
+    template <int dim>
+    void Visualization<dim>::mesh_changed_signal()
+    {
+      cell_output_history.mesh_changed = true;
+      face_output_history.mesh_changed = true;
+    }
+
+
+
+    template <int dim>
+    template <typename DataOutType>
+    void
+    Visualization<dim>::write_description_files (const DataOutType &data_out,
+                                                 const std::string &solution_file_prefix,
+                                                 const std::vector<std::string> &filenames,
+                                                 OutputHistory                  &output_history) const
+    {
+      static_assert (std::is_same<DataOutType,DataOut<dim>>::value ||
+                     std::is_same<DataOutType,DataOutFaces<dim>>::value,
+                     "The only allowed template types of this function are "
+                     "DataOut and DataOutFaces.");
+      const bool is_cell_data_output = std::is_same<DataOutType,DataOut<dim>>::value;
+
+      const double time_in_years_or_seconds = (this->convert_output_to_years() ?
+                                               this->get_time() / year_in_seconds :
+                                               this->get_time());
+      const std::string pvtu_filename = (solution_file_prefix +
+                                         ".pvtu");
+      std::ofstream pvtu_file (this->get_output_directory() + "solution/" +
+                               pvtu_filename);
+      data_out.write_pvtu_record (pvtu_file, filenames);
+
+      // now also generate a .pvd file that matches simulation
+      // time and corresponding .pvtu record
+      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
+        {
+          // in case we output all nonlinear iterations, we only want one
+          // entry per time step, so replace the last line with the current iteration
+          if (this->get_nonlinear_iteration() == 0)
+            output_history.times_and_pvtu_names.emplace_back(time_in_years_or_seconds, "solution/"+pvtu_filename);
+          else
+            output_history.times_and_pvtu_names.back() = (std::make_pair
+                                                          (time_in_years_or_seconds, "solution/"+pvtu_filename));
+        }
+      else
+        output_history.times_and_pvtu_names.emplace_back(time_in_years_or_seconds, "solution/"+pvtu_filename);
+
+      const std::string pvd_filename = (this->get_output_directory() +
+                                        (is_cell_data_output ? "solution.pvd" : "solution_surface.pvd"));
+      std::ofstream pvd_file (pvd_filename);
+
+      DataOutBase::write_pvd_record (pvd_file, output_history.times_and_pvtu_names);
+
+      // finally, do the same for VisIt via the .visit file for this
+      // time step, as well as for all time steps together
+      const std::string visit_filename = (this->get_output_directory()
+                                          + "solution/"
+                                          + solution_file_prefix
+                                          + ".visit");
+      std::ofstream visit_file (visit_filename);
+
+      DataOutBase::write_visit_record (visit_file, filenames);
+
+      {
+        // the global .visit file needs the relative path because it sits a
+        // directory above
+        std::vector<std::string> filenames_with_path;
+        filenames_with_path.reserve(filenames.size());
+        for (const auto &filename : filenames)
+          {
+            filenames_with_path.emplace_back("solution/" + filename);
+          }
+
+        if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
+          {
+            // in case we output all nonlinear iterations, we only want one
+            // entry per time step, so replace the last line with the current iteration
+            if (this->get_nonlinear_iteration() == 0)
+              output_history.output_file_names_by_timestep.push_back (filenames_with_path);
+            else
+              output_history.output_file_names_by_timestep.back() = filenames_with_path;
+          }
+        else
+          output_history.output_file_names_by_timestep.push_back (filenames_with_path);
+      }
+
+      std::ofstream global_visit_file (this->get_output_directory() +
+                                       (is_cell_data_output ? "solution.visit" : "solution_surface.visit"));
+
+      std::vector<std::pair<double, std::vector<std::string>>> times_and_output_file_names;
+      for (unsigned int timestep=0; timestep<output_history.times_and_pvtu_names.size(); ++timestep)
+        times_and_output_file_names.push_back(std::make_pair(output_history.times_and_pvtu_names[timestep].first,
+                                                             output_history.output_file_names_by_timestep[timestep]));
+      DataOutBase::write_visit_record (global_visit_file, times_and_output_file_names);
+    }
+
+
+
+    template <int dim>
+    void
+    Visualization<dim>::update ()
+    {
+      //Call the .update() method for each visualization postprocessor.
+      for (const auto &p : postprocessors)
+        p->update();
+    }
+
+
+
+    template <int dim>
+    template <typename DataOutType>
+    std::string
+    Visualization<dim>::write_data_out_data(DataOutType   &data_out,
+                                            OutputHistory &output_history,
+                                            const std::map<std::string,std::string> &visualization_field_names_and_units) const
+    {
+      static_assert (std::is_same<DataOutType,DataOut<dim>>::value ||
+                     std::is_same<DataOutType,DataOutFaces<dim>>::value,
+                     "The only allowed template types of this function are "
+                     "DataOut and DataOutFaces.");
+      const bool is_cell_data_output = std::is_same<DataOutType,DataOut<dim>>::value;
+
+      const double time_in_years_or_seconds = (this->convert_output_to_years() ?
+                                               this->get_time() / year_in_seconds :
+                                               this->get_time());
+
+      std::string solution_file_prefix =
+        (is_cell_data_output ? "solution-" : "solution_surface-")
+        + Utilities::int_to_string (output_file_number, 5);
+      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
+        solution_file_prefix.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
+
+      if (output_format == "hdf5")
+        {
+          XDMFEntry new_xdmf_entry;
+          const std::string h5_solution_file_name = "solution/"
+                                                    + solution_file_prefix + ".h5";
+          const std::string xdmf_filename = "solution.xdmf";
+          // Filter redundant values if requested in the input file
+          DataOutBase::DataOutFilter data_filter(
+            DataOutBase::DataOutFilterFlags(filter_output, true));
+          // If the mesh changed since the last output, make a new mesh file
+          const std::string mesh_file_prefix =
+            (is_cell_data_output ? "mesh-" : "mesh_surface-")
+            + Utilities::int_to_string(output_file_number, 5);
+          if (output_history.mesh_changed)
+            output_history.last_mesh_file_name = "solution/" + mesh_file_prefix + ".h5";
+
+          data_out.write_filtered_data(data_filter);
+          data_out.write_hdf5_parallel(data_filter,
+                                       output_history.mesh_changed,
+                                       this->get_output_directory() + output_history.last_mesh_file_name,
+                                       this->get_output_directory() + h5_solution_file_name,
+                                       this->get_mpi_communicator());
+          new_xdmf_entry = data_out.create_xdmf_entry(data_filter,
+                                                      output_history.last_mesh_file_name,
+                                                      h5_solution_file_name,
+                                                      time_in_years_or_seconds, this->get_mpi_communicator());
+          output_history.xdmf_entries.push_back(new_xdmf_entry);
+          data_out.write_xdmf_file(output_history.xdmf_entries,
+                                   this->get_output_directory() + xdmf_filename,
+                                   this->get_mpi_communicator());
+          output_history.mesh_changed = false;
+        }
+      else if (output_format == "vtu")
+        {
+          // Pass time step number and time as metadata into the output file
+          DataOutBase::VtkFlags vtk_flags;
+          vtk_flags.cycle = this->get_timestep_number();
+          vtk_flags.time = time_in_years_or_seconds;
+
+          // Also describe the physical units if we have them. Postprocessors do
+          // describe them, but it's a slight hassle to get at the information:
+          vtk_flags.physical_units = visualization_field_names_and_units;
+
+          // Finally, set or do not set whether we want to describe cells
+          // with curved edges and faces:
+#if DEAL_II_VERSION_GTE(9,6,0)
+          vtk_flags.write_higher_order_cells = write_higher_order_output;
+#else
+          // In versions of deal.II up to 9.5 (and perhaps later, see
+          // https://github.com/dealii/dealii/issues/17091), higher
+          // order output on lines fails with an
+          // ExcNotImplemented(). So just back down to regular linear
+          // interpolation if that is the case. This is only the case
+          // if we are in 2d and using surface output (DataOutFaces).
+          if (std::is_same<DataOutType,DataOutFaces<dim>>::value && (dim==2))
+            vtk_flags.write_higher_order_cells = false;
+          else
+            vtk_flags.write_higher_order_cells = write_higher_order_output;
+#endif
+
+          data_out.set_flags(vtk_flags);
+
+          // Write the description files (.pvtu,.pvd,.visit) on the root process
+          const int my_id = Utilities::MPI::this_mpi_process(
+                              this->get_mpi_communicator());
+          if (my_id == 0)
+            {
+              std::vector<std::string> filenames;
+              const unsigned int n_processes = Utilities::MPI::n_mpi_processes(
+                                                 this->get_mpi_communicator());
+              const unsigned int n_files =
+                (group_files == 0) ?
+                n_processes : std::min(group_files, n_processes);
+              for (unsigned int i = 0; i < n_files; ++i)
+                filenames.push_back(
+                  solution_file_prefix + "."
+                  + Utilities::int_to_string(i, 4) + ".vtu");
+              write_description_files(data_out, solution_file_prefix, filenames, output_history);
+            }
+          const unsigned int n_processes = Utilities::MPI::n_mpi_processes(
+                                             this->get_mpi_communicator());
+          const unsigned int my_file_id = (group_files == 0 ? my_id : my_id % group_files);
+          const std::string filename = this->get_output_directory() + "solution/"
+                                       + solution_file_prefix + "."
+                                       + Utilities::int_to_string(my_file_id, 4) + ".vtu";
+
+          // Write as many files as processes. For this case we support writing in a
+          // background thread and to a temporary location, so we first write everything
+          // into a string that is written to disk in a writer function
+          if ((group_files == 0) || (group_files >= n_processes))
+            {
+              // Put the content we want to write into a string object that
+              // we can then write in the background
+              std::unique_ptr<std::string> file_contents;
+              {
+                std::ostringstream tmp;
+                data_out.write(tmp,
+                               DataOutBase::parse_output_format(output_format));
+                file_contents = std::make_unique<std::string>(tmp.str());
+              }
+
+              if (write_in_background_thread)
+                {
+                  // Wait for all previous write operations to finish, should
+                  // any be still active, ...
+                  if (output_history.background_thread.joinable())
+                    output_history.background_thread.join();
+                  // ...then continue with writing our own data.
+                  output_history.background_thread
+                    = std::thread([ my_filename = std::move(filename),
+                                    my_temporary_output_location = temporary_output_location,
+                                    my_file_contents = std::move(file_contents)]()
+                  {
+                    writer (my_filename, my_temporary_output_location, *my_file_contents);
+                  });
+                }
+              else
+                writer(filename, temporary_output_location, *file_contents);
+            }
+          else
+            // Just write one data file in parallel
+            if (group_files == 1)
+              {
+                data_out.write_vtu_in_parallel(filename,
+                                               this->get_mpi_communicator());
+              }
+            else               // Write as many output files as 'group_files' groups
+              {
+                int color = my_id % group_files;
+                MPI_Comm comm;
+                int ierr = MPI_Comm_split(this->get_mpi_communicator(), color, my_id, &comm);
+                AssertThrowMPI(ierr);
+                data_out.write_vtu_in_parallel(filename, comm);
+                ierr = MPI_Comm_free(&comm);
+                AssertThrowMPI(ierr);
+              }
+        }
+      else if (output_format == "parallel deal.II intermediate")
+        {
+          const std::string filename = this->get_output_directory() + "solution/"
+                                       + solution_file_prefix + ".pd2";
+
+          data_out.write_deal_II_intermediate_in_parallel(filename,
+                                                          this->get_mpi_communicator(),
+                                                          DataOutBase::CompressionLevel::default_compression);
+        }
+      else   // Write in a different format than hdf5 or vtu. This case is supported, but is not
+        // optimized for parallel output in that every process will write one file directly
+        // into the output directory. This may or may not affect performance depending on
+        // the model setup and the network file system type.
+        {
+          const unsigned int myid = Utilities::MPI::this_mpi_process(
+                                      this->get_mpi_communicator());
+          const std::string filename = this->get_output_directory() + "solution/"
+                                       + solution_file_prefix + "." + Utilities::int_to_string(myid, 4)
+                                       + DataOutBase::default_suffix(
+                                         DataOutBase::parse_output_format(output_format));
+          std::ofstream out(filename);
+          AssertThrow(out,
+                      ExcMessage(
+                        "Unable to open file for writing: " + filename + "."));
+          data_out.write(out, DataOutBase::parse_output_format(output_format));
+        }
+
+      return solution_file_prefix;
+    }
+
+
+
+    namespace
+    {
+      /**
+       * Keep track of the names and physical units of output quantities. The
+       * number of entries in the two input arguments must be the same.
+       *
+       * This function also checks that output names are unique.
+       */
+      void
+      track_output_field_names_and_units(const std::vector<std::string> &output_data_names,
+                                         const std::vector<std::string> &output_units,
+                                         std::map<std::string,std::string> &output_data_names_and_units)
+      {
+        AssertDimension (output_data_names.size(), output_units.size());
+
+        // First check that none of the data names are already in the list:
+        for (const auto &name : output_data_names)
+          AssertThrow(output_data_names_and_units.find(name) == output_data_names_and_units.end(),
+                      ExcMessage("The output variable <" + name + "> already exists in the list of output "
+                                 "variables. Make sure there is no duplication in the names of visualization output "
+                                 "variables, otherwise output files may be corrupted."));
+
+        // Then insert the new names into the map. It is possible that
+        // some names appear multiple times (for vector-valued output)
+        // and in that case we need to make sure that the provided
+        // units are identical
+        for (unsigned int i=0; i<output_data_names.size(); ++i)
+          {
+            AssertThrow(
+              // either the name has not been added before...
+              (output_data_names_and_units.find(output_data_names[i])
+               == output_data_names_and_units.end())
+              ||
+              // or if it has, then the unit then added must match
+              // what we're about to add here
+              (output_data_names_and_units[output_data_names[i]]
+               == output_units[i]),
+              ExcMessage("The output variable <" + output_data_names[i]
+                         + "> had previously been added with physical units <"
+                         + output_data_names_and_units[output_data_names[i]]
+                         + "> but is now added again with units <"
+                         + output_units[i] + ">."));
+
+            // Now add the name/units. Don't worry about whether it previously
+            // had already been in the map -- if so, the assertion makes
+            // sure that we overwrite with the same value.
+            output_data_names_and_units[output_data_names[i]] = output_units[i];
+          }
+      }
+
+
+
+      /**
+       * Keep track of the names and physical units of output quantities. The
+       * number of entries in the two input arguments must be the same.
+       *
+       * This variant of the function expands the single 'output_units' variable into as
+       * many components as there are in 'output_data_names'. If the single string is
+       * provided as a comma-separated list, then split it and make sure that
+       * there are as many entries as there are in 'output_data_names'. If
+       * it is not a comma-separated list, then replicate it as many times
+       * as necessary. In either case, pass things on to the other function.
+       */
+      void
+      track_output_field_names_and_units(const std::vector<std::string> &output_data_names,
+                                         const std::string              &output_units,
+                                         std::map<std::string,std::string> &output_data_names_and_units)
+      {
+        if (output_units.find(',') != output_units.npos)
+          {
+            const std::vector<std::string> split_units = Utilities::split_string_list(output_units, ",");
+            Assert (split_units.size() == output_data_names.size(),
+                    ExcMessage("The number of provided units does not match the "
+                               "number of output variables."));
+            track_output_field_names_and_units(output_data_names, split_units,
+                                               output_data_names_and_units);
+          }
+        else
+          track_output_field_names_and_units(output_data_names,
+                                             std::vector<std::string> (output_data_names.size(), output_units),
+                                             output_data_names_and_units);
+      }
+    }
+
+
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    Visualization<dim>::execute (TableHandler &statistics)
+    {
+      // if this is the first time we get here, set the last output time
+      // to the current time - output_interval. this makes sure we
+      // always produce data during the first time step
+      if (std::isnan(last_output_time))
+        {
+          last_output_time = this->get_time() - output_interval;
+          last_output_timestep = this->get_timestep_number();
+        }
+
+      // Return if graphical output is not requested at this time. Do not
+      // return in the first timestep, or if the last output was more than
+      // output_interval in time ago, or maximum_timesteps_between_outputs in
+      // number of timesteps ago.
+      // The comparison in number of timesteps is safe from integer overflow for
+      // at most 2 billion timesteps , which is not likely to
+      // be ever reached (both values are unsigned int,
+      // and the default value of maximum_timesteps_between_outputs is
+      // set to numeric_limits<int>::max())
+      if ((this->get_time() < last_output_time + output_interval)
+          && (this->get_timestep_number() < last_output_timestep + maximum_timesteps_between_outputs)
+          && (this->get_timestep_number() != 0))
+        return {"", ""};
+
+      // up the counter of the number of the file by one, but not in
+      // the very first output step. if we run postprocessors on all
+      // iterations, only increase file number in the first nonlinear iteration
+      const bool increase_file_number = (this->get_nonlinear_iteration() == 0) || (!this->get_parameters().run_postprocessors_on_nonlinear_iterations);
+      if (output_file_number == numbers::invalid_unsigned_int)
+        output_file_number = 0;
+      else if (increase_file_number)
+        ++output_file_number;
+
+      BaseVariablePostprocessor<dim> base_variables;
+      base_variables.initialize_simulator (this->get_simulator());
+
+      // Keep a list of the names of all output variables
+      // (to ensure unique names), along with their respective
+      // physical units
+      std::map<std::string,std::string> visualization_field_names_and_units;
+
+      // Insert base variable names into set of all output field names
+      track_output_field_names_and_units(base_variables.get_names(),
+                                         base_variables.get_physical_units(),
+                                         visualization_field_names_and_units);
+
+      SurfaceBaseVariablePostprocessor<dim> surface_base_variables;
+      if (output_base_variables_on_mesh_surface)
+        {
+          surface_base_variables.initialize_simulator (this->get_simulator());
+
+          // Insert surface base variable names into set of all output field names
+          track_output_field_names_and_units(surface_base_variables.get_names(),
+                                             surface_base_variables.get_physical_units(),
+                                             visualization_field_names_and_units);
+        }
+
+      std::unique_ptr<MeshDeformationPostprocessor<dim>> mesh_deformation_velocity;
+      std::unique_ptr<MeshDeformationPostprocessor<dim>> mesh_deformation_displacement;
+
+      DataOut<dim> data_out;
+      data_out.attach_dof_handler (this->get_dof_handler());
+      data_out.add_data_vector (this->get_solution(),
+                                base_variables);
+
+      // Also create an object for outputting information that lives on
+      // the faces of the mesh.
+      DataOutFaces<dim> data_out_faces;
+      data_out_faces.attach_dof_handler (this->get_dof_handler());
+
+      if (output_base_variables_on_mesh_surface)
+        data_out_faces.add_data_vector (this->get_solution(),
+                                        surface_base_variables);
+
+      // If there is a deforming mesh, also attach the mesh velocity object
+      if ( this->get_parameters().mesh_deformation_enabled && output_mesh_velocity)
+        {
+          mesh_deformation_velocity = std::make_unique<MeshDeformationPostprocessor<dim>>("mesh_velocity", true);
+          mesh_deformation_velocity->initialize_simulator(this->get_simulator());
+
+          // Insert mesh deformation variable names into set of all output field names
+          track_output_field_names_and_units(mesh_deformation_velocity->get_names(),
+                                             mesh_deformation_velocity->get_physical_units(),
+                                             visualization_field_names_and_units);
+
+          data_out.add_data_vector (this->get_mesh_velocity(),
+                                    *mesh_deformation_velocity);
+        }
+
+      if ( this->get_parameters().mesh_deformation_enabled && output_mesh_displacement)
+        {
+          mesh_deformation_displacement = std::make_unique<MeshDeformationPostprocessor<dim>>("mesh_displacement", false);
+          mesh_deformation_displacement->initialize_simulator(this->get_simulator());
+
+          // Insert mesh deformation variable names into set of all output field names
+          track_output_field_names_and_units(mesh_deformation_displacement->get_names(),
+                                             mesh_deformation_displacement->get_physical_units(),
+                                             visualization_field_names_and_units);
+
+          data_out.add_data_vector (this->get_mesh_deformation_handler().get_mesh_deformation_dof_handler(),
+                                    this->get_mesh_deformation_handler().get_mesh_displacements(),
+                                    *mesh_deformation_displacement);
+        }
+
+      bool have_face_viz_postprocessors = false;
+
+      // then for each additional selected output variable
+      // add the computed quantity as well. keep a list of
+      // pointers to data vectors created by cell data visualization
+      // postprocessors that will later be deleted
+      std::list<std::unique_ptr<Vector<float>>> cell_data_vectors;
+      for (const auto &p : postprocessors)
+        {
+          try
+            {
+              // There are two ways of writing visualization postprocessors:
+              // - deriving from DataPostprocessor
+              // - deriving from DataVectorCreator
+              // treat them in turn. In both cases, the information can
+              // be output on all cells, or via the faces on the surface
+              // only (if the class in question is derived from
+              // SurfaceOnlyVisualization), so we will have to switch between
+              // the two ways when we send things to the data_out or
+              // data_out_faces objects.
+              if (const DataPostprocessor<dim> *viz_postprocessor
+                  = dynamic_cast<const DataPostprocessor<dim>*>(& *p))
+                {
+                  track_output_field_names_and_units(viz_postprocessor->get_names(),
+                                                     p->get_physical_units(),
+                                                     visualization_field_names_and_units);
+
+                  if (dynamic_cast<const VisualizationPostprocessors::SurfaceOnlyVisualization<dim>*>
+                      (& *p) == nullptr)
+                    data_out.add_data_vector (this->get_solution(),
+                                              *viz_postprocessor);
+                  else
+                    {
+                      data_out_faces.add_data_vector (this->get_solution(),
+                                                      *viz_postprocessor);
+                      // Apart from the base variables, other postprocessors
+                      // output on the mesh surface.
+                      have_face_viz_postprocessors = true;
+                    }
+                }
+              else if (const VisualizationPostprocessors::CellDataVectorCreator<dim> *
+                       cell_data_creator
+                       = dynamic_cast<const VisualizationPostprocessors::CellDataVectorCreator<dim>*>
+                         (& *p))
+                {
+                  // get the data produced here
+                  std::pair<std::string, std::unique_ptr<Vector<float>>>
+                  cell_data = cell_data_creator->execute();
+                  Assert (cell_data.second->size() ==
+                          this->get_triangulation().n_active_cells(),
+                          ExcMessage ("Cell data visualization postprocessors must generate "
+                                      "vectors that have as many entries as there are active cells "
+                                      "on the current processor."));
+
+                  track_output_field_names_and_units({cell_data.first},
+                                                     cell_data_creator->get_physical_units(),
+                                                     visualization_field_names_and_units);
+
+                  // store the pointer, then attach the vector to the DataOut object
+                  cell_data_vectors.push_back (std::move(cell_data.second));
+
+                  if (dynamic_cast<const VisualizationPostprocessors::SurfaceOnlyVisualization<dim>*>
+                      (& *p) == nullptr)
+                    data_out.add_data_vector (*cell_data_vectors.back(),
+                                              cell_data.first,
+                                              DataOut<dim>::type_cell_data);
+                  else
+                    {
+                      data_out_faces.add_data_vector(*cell_data_vectors.back(),
+                                                     cell_data.first,
+                                                     DataOutFaces<dim>::type_cell_data);
+                      // Apart from the base variables, other postprocessors
+                      // output on the mesh surface.
+                      have_face_viz_postprocessors = true;
+                    }
+                }
+              else
+                // A viz postprocessor not derived from either DataPostprocessor
+                // or CellDataVectorCreator? We don't know what to do with that!
+                Assert (false,
+                        ExcMessage("The visualization system found a visualization "
+                                   "postprocessor class that is not either derived from "
+                                   "DataPostprocessor or "
+                                   "VisualizationPostprocessors::CellDataVectorCreator. "
+                                   "ASPECT does not know what to do with these kinds of "
+                                   "classes."));
+            }
+          // viz postprocessors that throw exceptions usually do not result in
+          // anything good because they result in an unwinding of the stack
+          // and, if only one processor triggers an exception, the
+          // destruction of objects often causes a deadlock. thus, if
+          // an exception is generated, catch it, print an error message,
+          // and abort the program
+          catch (std::exception &exc)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "An exception happened on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running the visualization postprocessor <"
+                        << typeid(*p).name()
+                        << ">: " << std::endl
+                        << exc.what() << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+          catch (...)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "An exception happened on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running the visualization postprocessor <"
+                        << typeid(*p).name()
+                        << ">: " << std::endl;
+              std::cerr << "Unknown exception!" << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+
+        }
+
+      // Now build the patches. If selected, increase the output resolution.
+      // Giving the mapping ensures that the case with mesh deformation works correctly.
+      const unsigned int subdivisions = interpolate_output
+                                        ?
+                                        this->get_stokes_velocity_degree()
+                                        :
+                                        0;
+
+      // Use the normal mapping unless we use mesh deformation and
+      // the user requests an undeformed mesh. In that case, we use
+      // a Q1 mapping here.
+      const Mapping<dim> &linear_mapping = ReferenceCells::get_hypercube<dim>().template get_default_linear_mapping<dim>();
+      const Mapping<dim> &mapping =
+        (output_undeformed_mesh && dynamic_cast<const MappingQ1Eulerian<dim, LinearAlgebra::Vector>*>(&this->get_mapping())) ?
+        (linear_mapping) : (this->get_mapping());
+
+      this->get_signals().pre_data_out_build_patches (data_out);
+
+      // Now get everything written for the DataOut case, and record this
+      // in the statistics file
+      std::string solution_file_prefix;
+      {
+        data_out.build_patches (mapping,
+                                subdivisions,
+                                this->get_geometry_model().has_curved_elements()
+                                ?
+                                DataOut<dim>::curved_inner_cells
+                                :
+                                DataOut<dim>::no_curved_cells);
+
+        solution_file_prefix
+          = write_data_out_data(data_out, cell_output_history,
+                                visualization_field_names_and_units);
+        statistics.add_value ("Visualization file name",
+                              this->get_output_directory()
+                              + "solution/"
+                              + solution_file_prefix);
+      }
+
+      // Then do the same again for the face data case. We won't print the
+      // output file name to screen (too much clutter on the screen already)
+      // but still put it into the statistics file
+      if (output_base_variables_on_mesh_surface || have_face_viz_postprocessors)
+        {
+          data_out_faces.build_patches (mapping,
+                                        subdivisions);
+
+          const std::string face_solution_file_prefix
+            = write_data_out_data(data_out_faces, face_output_history,
+                                  visualization_field_names_and_units);
+          statistics.add_value ("Surface visualization file name",
+                                this->get_output_directory()
+                                + "solution_surface/"
+                                + face_solution_file_prefix);
+        }
+
+      // Increment the next time we need output:
+      set_last_output_time (this->get_time());
+      last_output_timestep = this->get_timestep_number();
+
+      // Return what should be printed to the screen. This is a bit
+      // late (the output has already been written, and this probably took
+      // a good long while), but it's still good to provide a status
+      // update.
+      return std::make_pair (std::string ("Writing graphical output:"),
+                             this->get_output_directory()
+                             + "solution/"
+                             + solution_file_prefix);
+    }
+
+
+    template <int dim>
+    void Visualization<dim>::writer (const std::string &filename,
+                                     const std::string &temporary_output_location,
+                                     const std::string &file_contents)
+    {
+      std::string tmp_filename = filename;
+      if (temporary_output_location != "")
+        {
+          tmp_filename = temporary_output_location + "/aspect.tmp.XXXXXX";
+
+          // Create the temporary file; get at the actual filename
+          // by using a C-style string that mkstemp will then overwrite
+          std::vector<char> tmp_filename_x (tmp_filename.size()+1);
+          std::strcpy(tmp_filename_x.data(), tmp_filename.c_str());
+          const int tmp_file_desc = mkstemp(tmp_filename_x.data());
+          tmp_filename = tmp_filename_x.data();
+
+          // If we failed to create the temp file, just write directly to the target file.
+          // We also provide a warning about this fact. There are places where
+          // this fails *on every node*, so we will get a lot of warning messages
+          // into the output; in these cases, just writing multiple pieces to
+          // std::cerr will produce an unreadable mass of text; rather, first
+          // assemble the error message completely, and then output it atomically
+          if (tmp_file_desc == -1)
+            {
+              const std::string x = ("***** WARNING: could not create temporary file <"
+                                     +
+                                     tmp_filename
+                                     +
+                                     ">, will output directly to final location. This may negatively "
+                                     "affect performance. (On processor "
+                                     + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD))
+                                     + ".)\n");
+
+              std::cerr << x << std::flush;
+
+              tmp_filename = filename;
+            }
+          else
+            close(tmp_file_desc);
+        }
+
+      std::ofstream out(tmp_filename);
+
+      AssertThrow (out, ExcMessage(std::string("Trying to write to file <") +
+                                   filename +
+                                   ">, but the file can't be opened!"));
+
+      // now write and then move the tmp file to its final destination
+      // if necessary
+      out.write (file_contents.data(), file_contents.size());
+      out.close ();
+
+      if (tmp_filename != filename)
+        {
+          std::string command = std::string("mv ") + tmp_filename + " " + filename;
+          int error = system(command.c_str());
+
+          AssertThrow(error == 0,
+                      ExcMessage("Could not move " + tmp_filename + " to "
+                                 + filename + ". On processor "
+                                 + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD)) + "."));
+        }
+    }
+
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<VisualizationPostprocessors::Interface<2>>,
+      aspect::internal::Plugins::PluginList<VisualizationPostprocessors::Interface<3>>> registered_visualization_plugins;
+    }
+
+
+    template <int dim>
+    void
+    Visualization<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Visualization");
+        {
+          prm.declare_entry ("Time between graphical output", "1e8",
+                             Patterns::Double (0.),
+                             "The time interval between each generation of "
+                             "graphical output files. A value of zero indicates "
+                             "that output should be generated in each time step. "
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+
+          prm.declare_entry ("Time steps between graphical output", boost::lexical_cast<std::string>(std::numeric_limits<int>::max()),
+                             Patterns::Integer(0),
+                             "The maximum number of time steps between each generation of "
+                             "graphical output files.");
+
+          // now also see about the file format we're supposed to write in
+          prm.declare_entry ("Output format", "vtu",
+                             Patterns::Selection (DataOutBase::get_output_format_names ()
+                                                  + "|parallel deal.II intermediate"),
+                             "The file format to be used for graphical output. The list "
+                             "of possible output formats that can be given here is documented "
+                             "in the appendix of the manual where the current parameter "
+                             "is described.");
+
+          prm.declare_entry ("Number of grouped files", "16",
+                             Patterns::Integer(0),
+                             "VTU file output supports grouping files from several CPUs "
+                             "into a given number of files using MPI I/O when writing on a parallel "
+                             "filesystem. Select 0 for no grouping. This will disable "
+                             "parallel file output and instead write one file per processor. "
+                             "A value of 1 will generate one big file containing the whole "
+                             "solution, while a larger value will create that many files "
+                             "(at most as many as there are MPI ranks).");
+
+          prm.declare_entry ("Write in background thread", "false",
+                             Patterns::Bool(),
+                             "File operations can potentially take a long time, blocking the "
+                             "progress of the rest of the model run. Setting this variable to "
+                             "`true' moves this process into a background thread, while the "
+                             "rest of the model continues.");
+
+          prm.declare_entry ("Temporary output location", "",
+                             Patterns::Anything(),
+                             "On large clusters it can be advantageous to first write the "
+                             "output to a temporary file on a local file system and later "
+                             "move this file to a network file system. If this variable is "
+                             "set to a non-empty string it will be interpreted as a "
+                             "temporary storage location.");
+
+          prm.declare_entry ("Interpolate output", "true",
+                             Patterns::Bool(),
+                             "deal.II offers the possibility to linearly interpolate "
+                             "output fields of higher order elements to a finer resolution. "
+                             "This somewhat compensates the fact that most visualization "
+                             "software only offers linear interpolation between grid points "
+                             "and therefore the output file is a very coarse representation "
+                             "of the actual solution field. Activating this option increases "
+                             "the spatial resolution in each dimension by a factor equal "
+                             "to the polynomial degree used for the velocity finite element "
+                             "(usually 2). In other words, instead of showing one quadrilateral "
+                             "or hexahedron in the visualization per cell on which \\aspect{} "
+                             "computes, it shows multiple (for quadratic elements, it will "
+                             "describe each cell of the mesh on which we compute as "
+                             "$2\\times 2$ or $2\\times 2\\times 2$ cells in 2d and 3d, "
+                             "respectively; correspondingly more subdivisions are used if "
+                             "you use cubic, quartic, or even higher order elements for the "
+                             "velocity)."
+                             "\n\n"
+                             "The effect of using this option can be seen in the following "
+                             "picture showing a variation of the output produced with the "
+                             "input files from Section~\\ref{sec:cookbooks:shell_simple_2d}:"
+                             "\n\n"
+                             "\\begin{center}"
+                             "  \\includegraphics[width=0.5\\textwidth]{viz/parameters/build-patches}"
+                             "\\end{center}"
+                             "Here, the left picture shows one visualization cell per "
+                             "computational cell (i.e., the option is switched off), "
+                             "and the right picture shows the same simulation with the "
+                             "option switched on (which is the default). The images "
+                             "show the same data, demonstrating "
+                             "that interpolating the solution onto bilinear shape functions as is "
+                             "commonly done in visualizing data loses information."
+                             "\n\n"
+                             "Of course, activating this option also greatly increases the amount of "
+                             "data \\aspect{} will write to disk: approximately by a factor of 4 in 2d, "
+                             "and a factor of 8 in 3d, when using quadratic elements for the velocity, "
+                             "and correspondingly more for even higher order elements.");
+
+          prm.declare_entry ("Point-wise stress and strain", "false",
+                             Patterns::Bool(),
+                             "If set to true, quantities related to stress and strain are computed "
+                             "in each vertex. Otherwise, an average per cell is computed.");
+
+          prm.declare_entry ("Write higher order output", "false",
+                             Patterns::Bool(),
+                             "deal.II offers the possibility to write vtu files with higher order "
+                             "representations of the output data. This means each cell will correctly "
+                             "show the higher order representation of the output data instead of the "
+                             "linear interpolation between vertices that ParaView and VisIt usually show. "
+                             "Note that activating this option is safe and recommended, but requires that "
+                             "(i) ``Output format'' is set to ``vtu'', (ii) ``Interpolate output'' is "
+                             "set to true, (iii) you use a sufficiently new version of Paraview "
+                             "or VisIt to read the files (Paraview version 5.5 or newer, and VisIt version "
+                             "to be determined), and (iv) you use deal.II version 9.1.0 or newer. "
+                             "\n"
+                             "The effect of using this option can be seen in the following "
+                             "picture:"
+                             "\n\n"
+                             "\\begin{center}"
+                             "  \\includegraphics[width=0.5\\textwidth]{viz/parameters/higher-order-output}"
+                             "\\end{center}"
+                             "The top figure shows the plain output without interpolation or higher "
+                             "order output. The middle figure shows output that was interpolated as "
+                             "discussed for the ``Interpolate output'' option. The bottom panel "
+                             "shows higher order output that achieves better accuracy than the "
+                             "interpolated output at a lower memory cost.");
+
+          prm.declare_entry ("Filter output", "false",
+                             Patterns::Bool(),
+                             "deal.II offers the possibility to filter duplicate vertices for HDF5 "
+                             "output files. This merges the vertices of adjacent cells and "
+                             "therefore saves disk space, but misrepresents discontinuous "
+                             "output properties. Activating this function reduces the disk space "
+                             "by about a factor of $2^{dim}$ for HDF5 output, and currently has no "
+                             "effect on other output formats. "
+                             ":::{warning}\n"
+                             "Setting this flag to true will result in "
+                             "visualization output that does not accurately represent discontinuous "
+                             "fields. This may be because you are using a discontinuous finite "
+                             "element for the pressure, temperature, or compositional variables, "
+                             "or because you use a visualization postprocessor that outputs "
+                             "quantities as discontinuous fields (e.g., the strain rate, viscosity, "
+                             "etc.). These will then all be visualized as \\textit{continuous} "
+                             "quantities even though, internally, \\aspect{} considers them as "
+                             "discontinuous fields.\n"
+                             ":::");
+
+          prm.declare_entry ("Output mesh velocity", "false",
+                             Patterns::Bool(),
+                             "For computations with deforming meshes, ASPECT uses an Arbitrary-Lagrangian-"
+                             "Eulerian formulation to handle deforming the domain, so the mesh "
+                             "has its own velocity field.  This may be written as an output field "
+                             "by setting this parameter to true.");
+
+          prm.declare_entry ("Output mesh displacement", "false",
+                             Patterns::Bool(),
+                             "For computations with deforming meshes, ASPECT uses an Arbitrary-Lagrangian-"
+                             "Eulerian formulation to handle deforming the domain. The displacement vector from "
+                             "the reference configuration may be written as an output field by setting this "
+                             "parameter to true.");
+
+          prm.declare_entry ("Output undeformed mesh", "false",
+                             Patterns::Bool(),
+                             "For computations with deforming meshes, ASPECT uses an Arbitrary-Lagrangian-"
+                             "Eulerian formulation to handle deforming the domain. By default, we output "
+                             "the deformed mesh. If this setting is set to true, the mesh will be written "
+                             "in the reference state without deformation instead. If you output the mesh "
+                             "displacement, you can obtain the deformed mesh by using the 'warp by vector' "
+                             "ParaView filter.");
+
+          prm.declare_entry("Output base variables on mesh surface", "false",
+                            Patterns::Bool(),
+                            "Whether or not to also output the base variables velocity, fluid pressure "
+                            "(when present), fluid velocity (when present), pressure, "
+                            "temperature and compositional fields (when present) on the surface "
+                            "of the mesh. The mesh surface includes not only the top boundary, "
+                            "but all boundaries of the domain. ");
+
+          // Finally also construct a string for Patterns::MultipleSelection that
+          // contains the names of all registered visualization postprocessors.
+          // Also add a number of removed plugins that are now combined in 'material properties'
+          // to keep compatibility with input files. These will be filtered out in parse_parameters().
+          const std::string pattern_of_names
+            = std::get<dim>(registered_visualization_plugins).get_pattern_of_names ()
+              + "|density|specific heat|thermal conductivity|thermal diffusivity|thermal expansivity|viscosity";
+          prm.declare_entry("List of output variables",
+                            "",
+                            Patterns::MultipleSelection(pattern_of_names),
+                            "A comma separated list of visualization objects that should be run "
+                            "whenever writing graphical output. By default, the graphical "
+                            "output files will always contain the primary variables velocity, "
+                            "pressure, and temperature. However, one frequently wants to also "
+                            "visualize derived quantities, such as the thermodynamic phase "
+                            "that corresponds to a given temperature-pressure value, or the "
+                            "corresponding seismic wave speeds. The visualization objects do "
+                            "exactly this: they compute such derived quantities and place them "
+                            "into the output file. The current parameter is the place where "
+                            "you decide which of these additional output variables you want "
+                            "to have in your output file.\n\n"
+                            "The following postprocessors are available:\n\n"
+                            +
+                            std::get<dim>(registered_visualization_plugins).get_description_string());
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // now declare the parameters of each of the registered
+      // visualization postprocessors in turn
+      std::get<dim>(registered_visualization_plugins).declare_parameters (prm);
+    }
+
+
+    template <int dim>
+    void
+    Visualization<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      Assert (std::get<dim>(registered_visualization_plugins).plugins != nullptr,
+              ExcMessage ("No postprocessors registered!?"));
+      std::vector<std::string> viz_names;
+
+      std::string visualization_subdirectory = this->get_output_directory() + "solution/";
+      Utilities::create_directory (visualization_subdirectory,
+                                   this->get_mpi_communicator(),
+                                   true);
+
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("Visualization");
+        {
+          output_interval = prm.get_double ("Time between graphical output");
+          if (this->convert_output_to_years())
+            output_interval *= year_in_seconds;
+
+          maximum_timesteps_between_outputs = prm.get_integer("Time steps between graphical output");
+
+          if (output_interval > 0.0)
+            {
+              // since we increase the time indicating when to write the next graphical output
+              // every time we execute the visualization postprocessor, there is no good way to
+              // figure out when to write graphical output for the nonlinear iterations if we do
+              // not want to output every time step
+              AssertThrow(this->get_parameters().run_postprocessors_on_nonlinear_iterations == false,
+                          ExcMessage("Postprocessing nonlinear iterations is only supported if every time "
+                                     "step is visualized, or in other words, if the 'Time between graphical "
+                                     "output' in the Visualization postprocessor is set to zero."));
+            }
+
+          output_format   = prm.get ("Output format");
+          group_files     = prm.get_integer("Number of grouped files");
+          write_in_background_thread = prm.get_bool("Write in background thread");
+          temporary_output_location = prm.get("Temporary output location");
+
+          if (temporary_output_location != "")
+            {
+              // Check if a command-processor is available by calling system() with a
+              // null pointer. System is guaranteed to return non-zero if it finds
+              // a terminal and zero if there is none (like on the compute nodes of
+              // some cluster architectures, e.g. IBM BlueGene/Q)
+              AssertThrow(system((char *)nullptr) != 0,
+                          ExcMessage("Usage of a temporary storage location is only supported if "
+                                     "there is a terminal available to move the files to their final location "
+                                     "after writing. The system() command did not succeed in finding such a terminal."));
+            }
+
+          interpolate_output = prm.get_bool("Interpolate output");
+          filter_output = prm.get_bool("Filter output");
+          pointwise_stress_and_strain = prm.get_bool("Point-wise stress and strain");
+          write_higher_order_output = prm.get_bool("Write higher order output");
+
+          if (write_higher_order_output == true)
+            {
+              AssertThrow(output_format == "vtu",
+                          ExcMessage("The option 'Postprocess/Visualization/Write higher order output' requires the "
+                                     "data output format to be set to 'vtu'."));
+              AssertThrow(interpolate_output == true,
+                          ExcMessage("The input parameter 'Postprocess/Visualization/Write higher order output' "
+                                     "requires the input parameter 'Interpolate output' to be set to 'true'."));
+            }
+
+          output_mesh_velocity = prm.get_bool("Output mesh velocity");
+          output_mesh_displacement = prm.get_bool("Output mesh displacement");
+          output_undeformed_mesh = prm.get_bool("Output undeformed mesh");
+
+          output_base_variables_on_mesh_surface = prm.get_bool("Output base variables on mesh surface");
+
+          // now also see which derived quantities we are to compute
+          viz_names = Utilities::split_string_list(prm.get("List of output variables"));
+          AssertThrow(Utilities::has_unique_entries(viz_names),
+                      ExcMessage("The list of strings for the parameter "
+                                 "'Postprocess/Visualization/List of output variables' contains entries more than once. "
+                                 "This is not allowed. Please check your parameter file."));
+
+          // see if 'all' was selected (or is part of the list). if so
+          // simply replace the list with one that contains all names
+          if (std::find (viz_names.begin(),
+                         viz_names.end(),
+                         "all") != viz_names.end())
+            {
+              viz_names.clear();
+              for (typename std::list<typename aspect::internal::Plugins::PluginList<VisualizationPostprocessors::Interface<dim>>::PluginInfo>::const_iterator
+                   p = std::get<dim>(registered_visualization_plugins).plugins->begin();
+                   p != std::get<dim>(registered_visualization_plugins).plugins->end(); ++p)
+                viz_names.push_back (std::get<0>(*p));
+            }
+
+          // Unify material property visualization plugins into the 'material properties'
+          // plugin to avoid duplicated code and multiple calls to the material model
+          prm.enter_subsection("Material properties");
+          {
+            bool material_properties_enabled = std::find(viz_names.begin(),
+                                                         viz_names.end(),
+                                                         "material properties") != viz_names.end() ;
+
+            std::set<std::string> deprecated_postprocessors = {"density",
+                                                               "specific heat",
+                                                               "thermal conductivity",
+                                                               "thermal diffusivity",
+                                                               "thermal expansivity",
+                                                               "viscosity"
+                                                              };
+
+            // For all selected visualization plugins
+            auto plugin_name = viz_names.begin();
+            while (plugin_name != viz_names.end())
+              {
+                // Check if the current name is in the set of the deprecated names
+                if (deprecated_postprocessors.count(*plugin_name) != 0)
+                  {
+                    // If there is no 'material properties' yet
+                    if (material_properties_enabled == false)
+                      {
+                        // Set the current property name as the parameter for 'material properties'
+                        prm.set("List of material properties",*plugin_name);
+                        // Then replace the currently selected plugin with 'material properties'
+                        *plugin_name = "material properties";
+                        material_properties_enabled = true;
+                        ++plugin_name;
+                      }
+                    else
+                      {
+                        // Add the current property name to the parameter of 'material properties'
+                        std::string new_property_names = prm.get("List of material properties") + ", " + *plugin_name;
+                        prm.set("List of material properties",new_property_names);
+                        // Then delete the current plugin
+                        plugin_name = viz_names.erase(plugin_name);
+                      }
+                  }
+                else
+                  ++plugin_name;
+              }
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // then go through the list, create objects and let them parse
+      // their own parameters
+      for (const auto &viz_name : viz_names)
+        {
+          std::unique_ptr<VisualizationPostprocessors::Interface<dim>>
+          viz_postprocessor = std::get<dim>(registered_visualization_plugins)
+                              .create_plugin (viz_name,
+                                              "Visualization plugins");
+
+          // make sure that the postprocessor is indeed of type
+          // dealii::DataPostprocessor or of type
+          // VisualizationPostprocessors::CellDataVectorCreator
+          Assert ((dynamic_cast<DataPostprocessor<dim>*>(viz_postprocessor.get())
+                   != nullptr)
+                  ||
+                  (dynamic_cast<VisualizationPostprocessors::CellDataVectorCreator<dim>*>(viz_postprocessor.get())
+                   != nullptr)
+                  ,
+                  ExcMessage ("Can't convert visualization postprocessor to type "
+                              "dealii::DataPostprocessor or "
+                              "VisualizationPostprocessors::CellDataVectorCreator!?"));
+
+          postprocessors.emplace_back (std::move(viz_postprocessor));
+
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(postprocessors.back().get()))
+            sim->initialize_simulator (this->get_simulator());
+
+          postprocessors.back()->parse_parameters (prm);
+          postprocessors.back()->initialize ();
+        }
+
+      // Finally also set up a listener to check when the mesh changes
+      cell_output_history.mesh_changed = true;
+      face_output_history.mesh_changed = true;
+      this->get_triangulation().signals.post_refinement.connect(
+        [&]()
+      {
+        this->mesh_changed_signal();
+      });
+    }
+
+
+
+    template <int dim>
+    template <class Archive>
+    void Visualization<dim>::serialize (Archive &ar, const unsigned int)
+    {
+      ar &last_output_time
+      & last_output_timestep
+      & output_file_number
+      & cell_output_history
+      & face_output_history
+      ;
+    }
+
+
+    template <int dim>
+    void
+    Visualization<dim>::save (std::map<std::string, std::string> &status_strings) const
+    {
+      std::ostringstream os;
+      aspect::oarchive oa (os);
+      oa << (*this);
+
+      status_strings["Visualization"] = os.str();
+
+//TODO: do something about the visualization postprocessor plugins
+    }
+
+
+    template <int dim>
+    void
+    Visualization<dim>::load (const std::map<std::string, std::string> &status_strings)
+    {
+      // see if something was saved
+      if (status_strings.find("Visualization") != status_strings.end())
+        {
+          std::istringstream is (status_strings.find("Visualization")->second);
+          aspect::iarchive ia (is);
+          ia >> (*this);
+        }
+
+//TODO: do something about the visualization postprocessor plugins
+    }
+
+
+    template <int dim>
+    void
+    Visualization<dim>::set_last_output_time (const double current_time)
+    {
+      // if output_interval is positive, then update the last supposed output
+      // time
+      if (output_interval > 0)
+        {
+          // We need to find the last time output was supposed to be written.
+          // this is the last_output_time plus the largest positive multiple
+          // of output_intervals that passed since then. We need to handle the
+          // edge case where last_output_time+output_interval==current_time,
+          // we did an output and std::floor sadly rounds to zero. This is done
+          // by forcing std::floor to round 1.0-eps to 1.0.
+          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
+          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    Visualization<dim>::
+    register_visualization_postprocessor (const std::string &name,
+                                          const std::string &description,
+                                          void (*declare_parameters_function) (ParameterHandler &),
+                                          std::unique_ptr<VisualizationPostprocessors::Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_visualization_plugins).register_plugin (name,
+                                                                       description,
+                                                                       declare_parameters_function,
+                                                                       factory_function);
+    }
+
+
+
+    template <int dim>
+    std::list<std::string>
+    Visualization<dim>::required_other_postprocessors () const
+    {
+      std::list<std::string> requirements;
+
+      // loop over all of the viz postprocessors and collect what
+      // they want. don't worry about duplicates, the postprocessor
+      // manager will filter them out
+      for (const auto &p : postprocessors)
+        {
+          const std::list<std::string> this_requirements = p->required_other_postprocessors();
+          requirements.insert (requirements.end(),
+                               this_requirements.begin(), this_requirements.end());
+        }
+
+      return requirements;
+    }
+
+
+
+    template <int dim>
+    bool
+    Visualization<dim>::output_pointwise_stress_and_strain () const
+    {
+      return pointwise_stress_and_strain;
+    }
+
+
+
+    template <int dim>
+    void
+    Visualization<dim>::write_plugin_graph (std::ostream &out)
+    {
+      // in contrast to all other plugins, the visualization
+      // postprocessors do not actually connect to the central
+      // Simulator class, but they are a sub-system of
+      // the Postprocessor plugin system. indicate this
+      // through the last argument of the function call
+      std::get<dim>(registered_visualization_plugins)
+      .write_plugin_graph ("Visualization postprocessor interface",
+                           out,
+                           typeid(Visualization<dim>).name());
+    }
+
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class CellDataVectorCreator<dim>;
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<Postprocess::VisualizationPostprocessors::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<Postprocess::VisualizationPostprocessors::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<Postprocess::VisualizationPostprocessors::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<Postprocess::VisualizationPostprocessors::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(Visualization,
+                                  "visualization",
+                                  "A postprocessor that takes the solution and writes "
+                                  "it into files that can be read by a graphical "
+                                  "visualization program. Additional run time parameters "
+                                  "are read from the parameter subsection 'Visualization'.")
+  }
+}
diff --git a/source/postprocess/visualization/ISA_rotation_timescale.cc.bak b/source/postprocess/visualization/ISA_rotation_timescale.cc.bak
new file mode 100644
index 00000000000..bb7a48614c7
--- /dev/null
+++ b/source/postprocess/visualization/ISA_rotation_timescale.cc.bak
@@ -0,0 +1,116 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/ISA_rotation_timescale.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/symmetric_tensor.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      ISARotationTimescale<dim>::
+      ISARotationTimescale ()
+        :
+        CellDataVectorCreator<dim>("s")
+      {}
+
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      ISARotationTimescale<dim>::execute() const
+      {
+        std::pair<std::string, std::unique_ptr<Vector<float>>> return_value("ISA_rotation_timescale",
+                                                                              std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+
+        const QMidpoint<dim> quadrature_formula;
+        const unsigned int n_q_points = quadrature_formula.size();
+
+        FEValues<dim> fe_values(this->get_mapping(), this->get_fe(),
+                                quadrature_formula,
+                                update_values | update_gradients | update_quadrature_points);
+
+        // Set up material models
+        MaterialModel::MaterialModelInputs<dim> in(n_q_points,
+                                                   this->n_compositional_fields());
+
+        // Loop over cells and calculate tauISA in each one
+        // Note that we start after timestep 0 because we need the strain rate,
+        // which doesn't exist during the initial step
+        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned() && this->get_timestep_number() > 0)
+            {
+
+              // Fill the material model objects for the cell (for strain rate)
+              fe_values.reinit(cell);
+              in.reinit(fe_values, cell, this->introspection(),
+                        this->get_solution());
+
+              // Calculate eigenvalues of strain rate and take maximum (absolute value)
+              // to get tauISA, the timescale for grain rotation toward the infinite strain axis
+              const SymmetricTensor<2, dim> strain_rate = in.strain_rate[0];
+              const std::array<double, dim> strain_rate_eigenvalues = eigenvalues(
+                                                                        strain_rate);
+              const double lambda1 = std::max(std::abs(strain_rate_eigenvalues[0]),
+                                              std::abs(strain_rate_eigenvalues[dim-1]));
+              const double tauISA = 1.0 / lambda1;
+
+              (*return_value.second)(cell->active_cell_index()) = tauISA;
+            }
+
+        return return_value;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ISARotationTimescale,
+                                                  "ISA rotation timescale",
+                                                  "A visualization output object that generates output "
+                                                  "showing the timescale for the rotation of grains "
+                                                  "toward the infinite strain axis. Kaminski and Ribe "
+                                                  "(see \\cite{Kaminski2002}) call this quantity "
+                                                  "$\\tau_\\text{ISA}$ and define it as "
+                                                  "$\\tau_\\text{ISA} \\approx \\frac{1}{\\dot{\\epsilon}}$ "
+                                                  "where $\\dot{\\epsilon}$ is the largest eigenvalue "
+                                                  "of the strain rate tensor. It can be used, "
+                                                  "along with the grain lag angle $\\Theta$, "
+                                                  "to calculate the grain orientation lag parameter."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\second}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/adiabat.cc.bak b/source/postprocess/visualization/adiabat.cc.bak
new file mode 100644
index 00000000000..5e399d6de6c
--- /dev/null
+++ b/source/postprocess/visualization/adiabat.cc.bak
@@ -0,0 +1,120 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/adiabat.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      Adiabat<dim>::
+      Adiabat ()
+        :
+        DataPostprocessor<dim> (),
+        Interface<dim>("K,Pa,kg/m/m/m,kg/m/m/m/m")
+      {}
+
+
+
+      template <int dim>
+      std::vector<std::string>
+      Adiabat<dim>::
+      get_names () const
+      {
+        std::vector<std::string> solution_names;
+        solution_names.emplace_back("adiabatic_temperature");
+        solution_names.emplace_back("adiabatic_pressure");
+        solution_names.emplace_back("adiabatic_density");
+        solution_names.emplace_back("adiabatic_density_derivative");
+        return solution_names;
+      }
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      Adiabat<dim>::
+      get_data_component_interpretation () const
+      {
+        std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretation(4,
+            DataComponentInterpretation::component_is_scalar);
+
+        return interpretation;
+      }
+
+
+      template <int dim>
+      UpdateFlags
+      Adiabat<dim>::
+      get_needed_update_flags () const
+      {
+        return update_quadrature_points;
+      }
+
+
+      template <int dim>
+      void
+      Adiabat<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == 4,                   ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            computed_quantities[q](0) = this->get_adiabatic_conditions().temperature(input_data.evaluation_points[q]);
+            computed_quantities[q](1) = this->get_adiabatic_conditions().pressure(input_data.evaluation_points[q]);
+            computed_quantities[q](2) = this->get_adiabatic_conditions().density(input_data.evaluation_points[q]);
+            computed_quantities[q](3) = this->get_adiabatic_conditions().density_derivative(input_data.evaluation_points[q]);
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Adiabat,
+                                                  "adiabat",
+                                                  "A visualization output "
+                                                  "object that generates "
+                                                  "adiabatic temperature, pressure, "
+                                                  "density, and density derivative (with regard to depth)"
+                                                  "as produced by the \\texttt{AdiabaticConditions} class."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\kelvin}, \\si{\\pascal}, "
+                                                  "\\si{\\kilo\\gram\\per\\meter\\cubed\\per\\meter}, "
+                                                  "respectively, for the four components.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/artificial_viscosity.cc.bak b/source/postprocess/visualization/artificial_viscosity.cc.bak
new file mode 100644
index 00000000000..002ec99d336
--- /dev/null
+++ b/source/postprocess/visualization/artificial_viscosity.cc.bak
@@ -0,0 +1,84 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/artificial_viscosity.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      ArtificialViscosity<dim>::
+      ArtificialViscosity ()
+        :
+        CellDataVectorCreator<dim>("W/m/K")
+      {}
+
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      ArtificialViscosity<dim>::execute() const
+      {
+        std::pair<std::string, std::unique_ptr<Vector<float>>>
+        return_value ("artificial_viscosity",
+                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+        this->get_artificial_viscosity(*return_value.second);
+
+        // The function we call above sets the artificial viscosity to
+        // signaling_nan on all artificial cells and, possibly, ghost cells.
+        // This runs into trouble in DataOut that wants to copy this vector
+        // from Vector<float> to Vector<double>, and the conversion trips
+        // up over the NaNs, causing a floating point exception.
+        //
+        // To avoid this, strip out the NaNs and instead set these values
+        // to zero -- we won't be outputting these values anyway.
+        for (const auto &cell : this->get_triangulation().active_cell_iterators())
+          if (cell->is_locally_owned() == false)
+            (*return_value.second)[cell->active_cell_index()] = 0;
+
+        return return_value;
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ArtificialViscosity,
+                                                  "artificial viscosity",
+                                                  "A visualization output object that generates output "
+                                                  "showing the value of the artificial viscosity on each "
+                                                  "cell."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\watt\\per\\meter\\per\\kelvin}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/artificial_viscosity_composition.cc.bak b/source/postprocess/visualization/artificial_viscosity_composition.cc.bak
new file mode 100644
index 00000000000..61ff63decb3
--- /dev/null
+++ b/source/postprocess/visualization/artificial_viscosity_composition.cc.bak
@@ -0,0 +1,135 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/artificial_viscosity_composition.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      ArtificialViscosityComposition<dim>::
+      ArtificialViscosityComposition ()
+        :
+        CellDataVectorCreator<dim>("m/s/s")
+      {}
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      ArtificialViscosityComposition<dim>::execute() const
+      {
+        Assert(this->n_compositional_fields()>0,
+               ExcMessage ("The artificial viscosity for compositional fields can "
+                           "only be calculated if compositional fields are used in the simulation."));
+
+        std::pair<std::string, std::unique_ptr<Vector<float>>>
+        return_value ("artificial_viscosity_composition",
+                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+        this->get_artificial_viscosity_composition(*return_value.second, compositional_field);
+
+        // The function we call above sets the artificial viscosity to
+        // signaling_nan on all artificial cells and, possibly, ghost cells.
+        // This runs into trouble in DataOut that wants to copy this vector
+        // from Vector<float> to Vector<double>, and the conversion trips
+        // up over the NaNs, causing a floating point exception.
+        //
+        // To avoid this, strip out the NaNs and instead set these values
+        // to zero -- we won't be outputting these values anyway.
+        for (const auto &cell : this->get_triangulation().active_cell_iterators())
+          if (cell->is_locally_owned() == false)
+            (*return_value.second)[cell->active_cell_index()] = 0;
+
+        return return_value;
+      }
+
+      template <int dim>
+      void
+      ArtificialViscosityComposition<dim>::
+      declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Artificial viscosity composition");
+            {
+              prm.declare_entry ("Name of compositional field", "",
+                                 Patterns::Anything(),
+                                 "The name of the compositional field whose output "
+                                 "should be visualized. ");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+      template <int dim>
+      void
+      ArtificialViscosityComposition<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Artificial viscosity composition");
+            {
+              const std::string field_name = prm.get("Name of compositional field");
+
+              AssertThrow(this->introspection().compositional_name_exists(field_name),
+                          ExcMessage("No compositional field with name <" +
+                                     field_name +
+                                     "> exists for which you want to visualize the artificial viscosity."));
+
+              compositional_field = this->introspection().compositional_index_for_name(field_name);
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ArtificialViscosityComposition,
+                                                  "artificial viscosity composition",
+                                                  "A visualization output object that generates output "
+                                                  "showing the value of the artificial viscosity for a "
+                                                  "compositional field on each cell."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\meter\\squared\\per\\second}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/boundary_indicator.cc.bak b/source/postprocess/visualization/boundary_indicator.cc.bak
new file mode 100644
index 00000000000..9df7639d16e
--- /dev/null
+++ b/source/postprocess/visualization/boundary_indicator.cc.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/boundary_indicator.h>
+#include <aspect/geometry_model/interface.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      BoundaryIndicator<dim>::
+      BoundaryIndicator ()
+        :
+        CellDataVectorCreator<dim>("") // no physical units
+      {}
+
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      BoundaryIndicator<dim>::execute() const
+      {
+        std::pair<std::string, std::unique_ptr<Vector<float>>>
+        return_value ("boundary_indicator",
+                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+
+        // retrieve the largest used boundary indicator and add one.
+        // this value will be set for internal cells
+        const types::boundary_id largest_boundary_id_plus_one =
+          *this->get_geometry_model().get_used_boundary_indicators().rbegin() + 1;
+
+        // loop over all of the surface cells and extract boundary indicators
+        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              if (cell->at_boundary())
+                {
+                  types::boundary_id boundary_id = largest_boundary_id_plus_one;
+                  for (const unsigned int f : cell->face_indices())
+                    {
+                      if (cell->face(f)->at_boundary())
+                        {
+                          boundary_id
+                            = cell->face(f)->boundary_id();
+                          break;
+                        }
+                    }
+                  (*return_value.second)(cell->active_cell_index()) = static_cast<float> (boundary_id);
+                }
+              // internal cells are all set to the same boundary indicator value
+              // of the largest boundary indicator used for the current geometry plus one.
+              else
+                {
+                  (*return_value.second)(cell->active_cell_index()) = largest_boundary_id_plus_one;
+                }
+            }
+
+        return return_value;
+      }
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(BoundaryIndicator,
+                                                  "boundary indicators",
+                                                  "A visualization output object that generates output "
+                                                  "about the used boundary indicators. In a loop over the active "
+                                                  "cells, if a cell lies at a domain boundary, the boundary indicator "
+                                                  "of the face along the boundary is requested. In case the cell "
+                                                  "does not lie along any domain boundary, the cell is assigned the "
+                                                  "value of the largest used boundary indicator plus one. "
+                                                  "When a cell is situated in one of the corners of the domain, "
+                                                  "multiple faces will have a boundary indicator. This postprocessor "
+                                                  "returns the value of the first face along a boundary that is encountered "
+                                                  "in a loop over all the faces."
+                                                  "\n\n"
+                                                  "Physical units: None.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/boundary_strain_rate_residual.cc.bak b/source/postprocess/visualization/boundary_strain_rate_residual.cc.bak
new file mode 100644
index 00000000000..657cd5d8ac1
--- /dev/null
+++ b/source/postprocess/visualization/boundary_strain_rate_residual.cc.bak
@@ -0,0 +1,148 @@
+/*
+  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/postprocess/visualization/boundary_strain_rate_residual.h>
+#include <aspect/postprocess/boundary_strain_rate_residual_statistics.h>
+#include <aspect/simulator.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      BoundaryStrainRateResidual<dim>::
+      BoundaryStrainRateResidual ()
+        :
+        DataPostprocessorScalar<dim> ("boundary_strain_rate_residual",
+                                      update_quadrature_points | update_gradients),
+        Interface<dim>()    // unknown units at construction time, will be filled by a separate function
+      {}
+
+
+
+      template <int dim>
+      std::string
+      BoundaryStrainRateResidual<dim>::
+      get_physical_units () const
+      {
+        if (this->convert_output_to_years())
+          return "1/year";
+        else
+          return "1/s";
+      }
+
+
+
+      template <int dim>
+      void
+      BoundaryStrainRateResidual<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        (void) n_quadrature_points;
+        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,               ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
+
+        auto cell = input_data.template get_cell<dim>();
+
+        for (auto &quantity : computed_quantities)
+          quantity(0)= std::numeric_limits<double>::quiet_NaN();
+
+        const double unit_scaling_factor = this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+        const Postprocess::BoundaryStrainRateResidualStatistics<dim> &boundary_strain_rate_residual_statistics =
+          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::BoundaryStrainRateResidualStatistics<dim>>();
+
+        // We only want the output at the top boundary, so only compute it if the current cell
+        // has a face at the top boundary.
+        bool cell_at_top_boundary = false;
+        for (const unsigned int f : cell->face_indices())
+          if (cell->at_boundary(f) &&
+              (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top"))
+            {
+              cell_at_top_boundary = true;
+              break;
+            }
+
+        if (cell_at_top_boundary)
+          for (unsigned int q=0; q<computed_quantities.size(); ++q)
+            {
+              Tensor<2,dim> grad_u;
+              for (unsigned int d=0; d<dim; ++d)
+                grad_u[d] = input_data.solution_gradients[q][d];
+              const SymmetricTensor<2,dim> strain_rate = symmetrize(grad_u);
+
+              const double data_surface_strain_rate =
+                boundary_strain_rate_residual_statistics.get_data_surface_strain_rate(input_data.evaluation_points[q]);
+
+              // Only compute residual for doubles. This condition checks for nan values
+              if (data_surface_strain_rate < 1e300 || !std::isnan(data_surface_strain_rate))
+                computed_quantities[q](0) = data_surface_strain_rate -
+                                            std::sqrt(std::fabs(second_invariant(deviator(strain_rate)))) * unit_scaling_factor;
+              else
+                continue;
+
+            }
+
+        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
+        if (!viz.output_pointwise_stress_and_strain())
+          average_quantities(computed_quantities);
+
+      }
+
+
+
+      template <int dim>
+      std::list<std::string>
+      BoundaryStrainRateResidual<dim>::required_other_postprocessors() const
+      {
+        return {"boundary strain rate residual statistics"};
+      }
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(BoundaryStrainRateResidual,
+                                                  "boundary strain rate residual",
+                                                  "A visualization output object that generates output for the strain rate "
+                                                  "residual at the top surface. The residual is computed at each point at the "
+                                                  "surface as the difference between the strain rate invariant in the model and the input data, "
+                                                  "where the invariant is computed like in the 'strain rate' postprocessor. The user chooses "
+                                                  "the input data as ascii data files with coordinate columns and column corresponding "
+                                                  "to the surface strain rate norm."
+                                                  "\n\n"
+                                                  "Physical units: $\\frac{1}{\\text{s}}$ or "
+                                                  "$\\frac{1}{\\text{year}}$, depending on settings in the input file.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/boundary_velocity_residual.cc.bak b/source/postprocess/visualization/boundary_velocity_residual.cc.bak
new file mode 100644
index 00000000000..65d3c194cbf
--- /dev/null
+++ b/source/postprocess/visualization/boundary_velocity_residual.cc.bak
@@ -0,0 +1,126 @@
+/*
+  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/postprocess/visualization/boundary_velocity_residual.h>
+#include <aspect/postprocess/boundary_velocity_residual_statistics.h>
+#include <aspect/simulator.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      BoundaryVelocityResidual<dim>::
+      BoundaryVelocityResidual ()
+        :
+        DataPostprocessorVector<dim> ("boundary_velocity_residual",
+                                      update_values | update_quadrature_points | update_gradients),
+        Interface<dim>()  // unknown units at construction time, will be filled by a separate function
+      {}
+
+
+
+      template <int dim>
+      std::string
+      BoundaryVelocityResidual<dim>::
+      get_physical_units () const
+      {
+        if (this->convert_output_to_years())
+          return "m/year";
+        else
+          return "m/s";
+      }
+
+
+
+      template <int dim>
+      void
+      BoundaryVelocityResidual<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        Assert ((computed_quantities[0].size() == dim), ExcInternalError());
+        for (auto &quantity : computed_quantities)
+          for (unsigned int d = 0; d < dim; ++d)
+            quantity(d)= 0.;
+
+        auto cell = input_data.template get_cell<dim>();
+        const double velocity_scaling_factor =
+          this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+        const Postprocess::BoundaryVelocityResidualStatistics<dim> &boundary_velocity_residual_statistics =
+          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::BoundaryVelocityResidualStatistics<dim>>();
+
+        // We only want the output at the top boundary, so only compute it if the current cell
+        // has a face at the top boundary.
+        bool cell_at_top_boundary = false;
+        for (const unsigned int f : cell->face_indices())
+          if (cell->at_boundary(f) &&
+              (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top"))
+            cell_at_top_boundary = true;
+
+        if (cell_at_top_boundary)
+          for (unsigned int q=0; q<computed_quantities.size(); ++q)
+            {
+              const Tensor<1,dim> data_velocity = boundary_velocity_residual_statistics.get_data_velocity(input_data.evaluation_points[q]);
+              for (unsigned int d = 0; d < dim; ++d)
+                computed_quantities[q](d) = data_velocity[d] - input_data.solution_values[q][d] * velocity_scaling_factor;
+            }
+
+      }
+
+
+
+      template <int dim>
+      std::list<std::string>
+      BoundaryVelocityResidual<dim>::required_other_postprocessors() const
+      {
+        return {"boundary velocity residual statistics"};
+      }
+
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(BoundaryVelocityResidual,
+                                                  "boundary velocity residual",
+                                                  "A visualization output object that generates output for the velocity "
+                                                  "residual at the top surface. The residual is computed at each point at the "
+                                                  "surface as the difference between the modeled velocities and the input "
+                                                  "data velocities for each vector component. The user has an option to choose "
+                                                  "the input data as ascii data files (e.g. GPS velocities) with columns "
+                                                  "in the same format as described for the 'ascii data' initial temperature plugin "
+                                                  "or a velocity field computed from the GPlates program as described in the gplates "
+                                                  "boundary velocity plugin."
+                                                  "\n\n"
+                                                  "Physical units: $\\frac{\\text{m}}{\\text{s}}$ or "
+                                                  "$\\frac{\\text{m}}{\\text{year}}$, depending on settings in the input file.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/compositional_vector.cc.bak b/source/postprocess/visualization/compositional_vector.cc.bak
new file mode 100644
index 00000000000..b9f31814dd6
--- /dev/null
+++ b/source/postprocess/visualization/compositional_vector.cc.bak
@@ -0,0 +1,196 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/postprocess/visualization/compositional_vector.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      CompositionalVector<dim>::
+      CompositionalVector ()
+        :
+        DataPostprocessor<dim> (),
+        Interface<dim>("")  // we don't associate these objects with physical units
+      {}
+
+
+
+      template <int dim>
+      std::vector<std::string>
+      CompositionalVector<dim>::
+      get_names () const
+      {
+        std::vector<std::string> solution_names;
+        for (const auto &vector_name : vector_names)
+          for (unsigned int j=0; j<dim; ++j)
+            solution_names.push_back(vector_name);
+        return solution_names;
+      }
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      CompositionalVector<dim>::
+      get_data_component_interpretation () const
+      {
+        return std::vector<DataComponentInterpretation::DataComponentInterpretation>
+               (vector_names.size()*dim,
+                DataComponentInterpretation::component_is_part_of_vector);
+      }
+
+
+      template <int dim>
+      UpdateFlags
+      CompositionalVector<dim>::
+      get_needed_update_flags () const
+      {
+        return update_values;
+      }
+
+
+      template <int dim>
+      void
+      CompositionalVector<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError ());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError ());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            for (unsigned int i=0; i<vector_names.size(); ++i)
+              for (unsigned int j=0; j<dim; ++j)
+                computed_quantities[q][i*dim+j] =
+                  input_data.solution_values[q][this->introspection().component_indices.compositional_fields[sets[i][j]]];
+          }
+      }
+
+
+      template <int dim>
+      void
+      CompositionalVector<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Compositional fields as vectors");
+            {
+              prm.declare_entry("Names of vectors", "",
+                                Patterns::List (Patterns::Anything()),
+                                "Names of vectors as they will appear in the output.");
+
+              prm.declare_entry("Names of fields", "",
+                                Patterns::Anything (),
+                                "A list of sets of compositional fields which should be output "
+                                "as vectors. Sets are separated from each other by semicolons "
+                                "and vector components within each set are separated by commas "
+                                "(e.g. $vec1_x$, $vec1_y$ ; $vec2_x$, $vec2_y$) where each name must be "
+                                "a defined named compositional field. If only one name is given "
+                                "in a set, it is interpreted as the first in a sequence of dim "
+                                "consecutive compositional fields.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      CompositionalVector<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Compositional fields as vectors");
+            {
+              vector_names = Utilities::split_string_list(prm.get("Names of vectors"), ',');
+
+              const std::vector<std::string> sets_list = Utilities::split_string_list(prm.get("Names of fields"), ';');
+              for (const auto &set_string : sets_list)
+                {
+                  const std::vector<std::string> set = Utilities::split_string_list(set_string, ',');
+                  AssertThrow((set.size() == dim || set.size() == 1),
+                              ExcMessage("Sets of compositional fields to be output as vectors must have dim components, "
+                                         "or one component (i.e. the first field in a sequence of dim consecutive fields)."));
+
+                  std::vector<unsigned int> set_idx;
+                  for (const auto &name : set)
+                    {
+                      AssertThrow(this->introspection().compositional_name_exists (name),
+                                  ExcMessage("All fields in compositional vector sets must match names of compositional "
+                                             "fields as assigned in the \"Compositional fields/Names of fields\" parameter."));
+                      set_idx.push_back(this->introspection().compositional_index_for_name(name));
+                    }
+
+                  while (set_idx.size() < dim)
+                    {
+                      AssertThrow(set_idx[0]+set_idx.size() < this->n_compositional_fields(),
+                                  ExcMessage(set[0] + " must be the first in a sequence of dim compositional fields to be "
+                                             "interpreted as a vector. You have too few compositional fields."));
+                      set_idx.push_back(set_idx[0]+set_idx.size());
+                    }
+                  sets.push_back(set_idx);
+                }
+
+              AssertThrow(vector_names.size() == sets.size(),
+                          ExcMessage("You must define names for each of the sets of compositional fields which will "
+                                     "be output as vectors, and the length of that list must match the number of vectors."));
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(CompositionalVector,
+                                                  "compositional vector",
+                                                  "A visualization output object that outputs vectors whose "
+                                                  "components are derived from compositional fields. Input "
+                                                  "parameters for this postprocessor are defined in section "
+                                                  "Postprocess/Visualization/Compositional fields as vectors."
+                                                  "\n\n"
+                                                  "Physical units: None.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/depth.cc.bak b/source/postprocess/visualization/depth.cc.bak
new file mode 100644
index 00000000000..8da0bf3f9ad
--- /dev/null
+++ b/source/postprocess/visualization/depth.cc.bak
@@ -0,0 +1,93 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/depth.h>
+#include <aspect/geometry_model/interface.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      Depth<dim>::
+      Depth ()
+        :
+        DataPostprocessorScalar<dim> ("depth",
+                                      update_quadrature_points),
+        Interface<dim>("m")
+      {}
+
+
+
+      template <int dim>
+      void
+      Depth<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            computed_quantities[q](0) = this->get_geometry_model().depth (input_data.evaluation_points[q]);
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Depth,
+                                                  "depth",
+                                                  "A visualization output postprocessor that outputs "
+                                                  "the depth for all points inside the domain, as "
+                                                  "determined by the geometry model."
+                                                  "\n\n"
+                                                  "It is worth comparing this visualization postprocessor with the "
+                                                  "one called ``surface elevation''. The current one is used to visualize a volume "
+                                                  "variable, whereas the latter only outputs information on "
+                                                  "the surface. Moreover ``depth'' is based on a member function of "
+                                                  "the geometry models that is documented as never returning a "
+                                                  "number less than zero -- in other words, it returns the depth "
+                                                  "of an evaluation point with regard to a reference surface that "
+                                                  "defines a zero depth, but for points that lie above this "
+                                                  "reference surface, it returns zero. As a consequence, it cannot "
+                                                  "be used to visualize positive elevations, whereas the the one "
+                                                  "called ``surface elevation'' can."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\meter}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/dynamic_topography.cc.bak b/source/postprocess/visualization/dynamic_topography.cc.bak
new file mode 100644
index 00000000000..01817ddd267
--- /dev/null
+++ b/source/postprocess/visualization/dynamic_topography.cc.bak
@@ -0,0 +1,142 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/postprocess/visualization/dynamic_topography.h>
+#include <aspect/postprocess/dynamic_topography.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      DynamicTopography<dim>::
+      DynamicTopography ()
+        :
+        DataPostprocessorScalar<dim> ("dynamic_topography",
+                                      update_quadrature_points),
+        Interface<dim>("m")
+      {}
+
+
+
+      template <int dim>
+      void
+      DynamicTopography<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        // Initialize everything to zero, so that we can ignore faces we are
+        // not interested in (namely, those not labeled as 'top' or 'bottom'
+        for (auto &quantity : computed_quantities)
+          quantity(0) = 0;
+
+        const Postprocess::DynamicTopography<dim> &dynamic_topography =
+          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<dim>>();
+
+        auto cell = input_data.template get_cell<dim>();
+
+        // We only want to output dynamic topography at the top and bottom
+        // boundary, so only compute it if the current cell has
+        // a face at the top or bottom boundary.
+        bool cell_at_top_or_bottom_boundary = false;
+        for (const unsigned int f : cell->face_indices())
+          if (cell->at_boundary(f) &&
+              (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top" ||
+               this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "bottom"))
+            cell_at_top_or_bottom_boundary = true;
+
+        if (cell_at_top_or_bottom_boundary)
+          {
+            std::vector<Point<dim>> quadrature_points(input_data.evaluation_points.size());
+            for (unsigned int i=0; i<input_data.evaluation_points.size(); ++i)
+              quadrature_points[i] = this->get_mapping().transform_real_to_unit_cell(cell,input_data.evaluation_points[i]);
+
+            const Quadrature<dim> quadrature_formula(quadrature_points);
+
+            FEValues<dim> fe_volume_values (this->get_mapping(),
+                                            this->get_fe(),
+                                            quadrature_formula,
+                                            update_values);
+
+            fe_volume_values.reinit(cell);
+
+            std::vector<double> dynamic_topography_values(quadrature_formula.size());
+
+            // It might seem unintuitive to use the extractor for the temperature block,
+            // but that is where dynamic_topography.topography_vector() stores the values.
+            // See the documentation of that function for more details.
+            fe_volume_values[this->introspection().extractors.temperature].get_function_values(dynamic_topography.topography_vector(),
+                dynamic_topography_values);
+
+            for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+              computed_quantities[q](0) = dynamic_topography_values[q];
+          }
+      }
+
+
+
+      /**
+       * Register the other postprocessor that we need: DynamicTopography
+       */
+      template <int dim>
+      std::list<std::string>
+      DynamicTopography<dim>::required_other_postprocessors() const
+      {
+        return {"dynamic topography"};
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(DynamicTopography,
+                                                  "dynamic topography",
+                                                  "A visualization output object that generates output "
+                                                  "for the dynamic topography at the top and bottom of the model space. "
+                                                  "The actual computation of this topography is handled inside the "
+                                                  "'dynamic topography' postprocessor, please check its documentation "
+                                                  "for details about the numerical methods."
+                                                  "\n\n"
+                                                  "Strictly speaking, the dynamic topography is of course a "
+                                                  "quantity that is only of interest at the surface. However, "
+                                                  "we compute it everywhere to make things fit into the framework "
+                                                  "within which we produce data for visualization. You probably "
+                                                  "only want to visualize whatever data this postprocessor generates "
+                                                  "at the surface of your domain and simply ignore the rest of the "
+                                                  "data generated."
+                                                  "\n\n"
+                                                  "Alternatively, consider using the "
+                                                  "\"surface dynamic topography\" visualization postprocessor "
+                                                  "to only output the dynamic topography at the boundary of "
+                                                  "the domain."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\meter}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/error_indicator.cc.bak b/source/postprocess/visualization/error_indicator.cc.bak
new file mode 100644
index 00000000000..fbbf5a7494e
--- /dev/null
+++ b/source/postprocess/visualization/error_indicator.cc.bak
@@ -0,0 +1,78 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/error_indicator.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      ErrorIndicator<dim>::
+      ErrorIndicator ()
+        :
+        CellDataVectorCreator<dim>("")
+      {}
+
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      ErrorIndicator<dim>::execute() const
+      {
+        std::pair<std::string, std::unique_ptr<Vector<float>>>
+        return_value ("error_indicator",
+                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+        this->get_refinement_criteria(*return_value.second);
+
+        return return_value;
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ErrorIndicator,
+                                                  "error indicator",
+                                                  "A visualization output object that generates output "
+                                                  "showing the estimated error or other mesh refinement "
+                                                  "indicator as a spatially variable function with one "
+                                                  "value per cell."
+                                                  "\n\n"
+                                                  "Physical units: None. (Strictly speaking, errors have "
+                                                  "physical units of course, but because error "
+                                                  "\\textit{indicators} can be computed from different "
+                                                  "solution components and other input, we consider "
+                                                  "error indicators unitless.)")
+
+    }
+  }
+}
diff --git a/source/postprocess/visualization/geoid.cc.bak b/source/postprocess/visualization/geoid.cc.bak
new file mode 100644
index 00000000000..d7af2b2fafc
--- /dev/null
+++ b/source/postprocess/visualization/geoid.cc.bak
@@ -0,0 +1,113 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/postprocess/visualization/geoid.h>
+#include <aspect/citation_info.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      Geoid<dim>::
+      Geoid ()
+        :
+        DataPostprocessorScalar<dim> ("geoid",
+                                      update_quadrature_points),
+        Interface<dim>("m")
+      {}
+
+
+
+      template <int dim>
+      void
+      Geoid<dim>::
+      initialize()
+      {
+        CitationInfo::add("geoid");
+      }
+
+
+
+      template <int dim>
+      void
+      Geoid<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()),
+                     ExcMessage("The geoid postprocessor is currently only implemented for "
+                                "the spherical shell geometry model."));
+
+        for (auto &quantity : computed_quantities)
+          quantity(0) = 0;
+
+        const Postprocess::Geoid<dim> &geoid =
+          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Geoid<dim>>();
+
+        auto cell = input_data.template get_cell<dim>();
+
+        bool cell_at_top_boundary = false;
+        for (const unsigned int f : cell->face_indices())
+          if (cell->at_boundary(f) &&
+              this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top")
+            cell_at_top_boundary = true;
+
+        if (cell_at_top_boundary)
+          for (unsigned int q=0; q<input_data.evaluation_points.size(); ++q)
+            computed_quantities[q](0) = geoid.evaluate(input_data.evaluation_points[q]);
+      }
+
+      template <int dim>
+      std::list<std::string>
+      Geoid<dim>::required_other_postprocessors() const
+      {
+        return {"geoid"};
+      }
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Geoid,
+                                                  "geoid",
+                                                  "Visualization for the geoid solution. The geoid is given "
+                                                  "by the equivalent water column height due to a gravity perturbation. "
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\meter}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/grain_lag_angle.cc.bak b/source/postprocess/visualization/grain_lag_angle.cc.bak
new file mode 100644
index 00000000000..e1983a603a5
--- /dev/null
+++ b/source/postprocess/visualization/grain_lag_angle.cc.bak
@@ -0,0 +1,180 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/grain_lag_angle.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/symmetric_tensor.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      GrainLagAngle<dim>::
+      GrainLagAngle ()
+        :
+        CellDataVectorCreator<dim>("radian")
+      {}
+
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      GrainLagAngle<dim>::execute() const
+      {
+        std::pair<std::string, std::unique_ptr<Vector<float>>> return_value("grain_lag_angle",
+                                                                              std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+
+        const QMidpoint<dim> quadrature_formula;
+        const unsigned int n_q_points = quadrature_formula.size(); // this is 1 for QMidpoint
+
+        FEValues<dim> fe_values(this->get_mapping(), this->get_fe(),
+                                quadrature_formula,
+                                update_values | update_gradients | update_quadrature_points);
+
+        // Set up material models
+        MaterialModel::MaterialModelInputs<dim> in(n_q_points,
+                                                   this->n_compositional_fields());
+
+        // Loop over cells and calculate theta in each one
+        // Note that we start after timestep 0 because we need the strain rate,
+        // which doesn't exist during the initial step
+        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned() && this->get_timestep_number() > 0)
+            {
+              // Fill the material model objects for the cell (for strain rate)
+              fe_values.reinit(cell);
+              in.reinit(fe_values, cell, this->introspection(),
+                        this->get_solution());
+              // Also get velocity gradients
+              std::vector<Tensor<2, dim>> velocity_gradient(n_q_points,
+                                                             Tensor<2, dim>());
+              fe_values[this->introspection().extractors.velocities].get_function_gradients(
+                this->get_solution(), velocity_gradient);
+
+              // Calculate eigenvalues of strain rate and take maximum (absolute value)
+              // to get tauISA, the timescale for grain rotation toward the infinite strain axis
+              const SymmetricTensor<2, dim> strain_rate = in.strain_rate[0];
+              const std::array<double, dim> strain_rate_eigenvalues = eigenvalues(
+                                                                        strain_rate);
+
+              const double lambda1 = std::max(std::abs(strain_rate_eigenvalues[0]),
+                                              std::abs(strain_rate_eigenvalues[dim-1]));
+              const double tauISA = 1.0 / lambda1;
+
+              // Next, we want the ~infinite strain axis, so we start by
+              // calculating the deformation gradient tensor in the limit of "infinite"
+              // time using the velocity gradient tensor. The deformation gradient tensor (F) obeys
+              // dF/dt = LF
+              // where L is the velocity gradient tensor, and F(t=0) = I. The solution to this is
+              // F = exp(Lt)
+              // which can be written as an infinite sum:
+              // F = I + Lt + L^2*t^2/2! + L^3*t^3/3! + ...
+              // and then the "left stretch" tensor is U = F * F^T
+              // We truncate the series sum at the L^4 term. Note that L is sometimes
+              // taken to be the strain rate tensor (ie the velocity gradient without
+              // the rotational component).
+              // The eigenvectors of U are the directions of the major axes of the finite
+              // strain ellipsoid, so for the *infinite* strain axis, we want the eigenvector
+              // corresponding to the largest eigenvalue of U in the limit as t->infinity.
+              // As per Kaminski and Ribe (2002), tmax = 75*tauISA is infinite enough for
+              // most applications.
+              const unsigned int maxorder = 4; // truncate at L^4
+              Tensor<2, dim> F = unit_symmetric_tensor<dim, double>(); // initialize as identity (first term of sum)
+              const double tmax = 75 * tauISA; // "infinite" time
+
+              for (unsigned int i = 1; i <= maxorder; ++i) // loop and calculate terms of sum
+                {
+                  Tensor<2, dim> multiplier = unit_symmetric_tensor<dim, double>();  // to collect powers of L
+                  double factor = 1.0;  // to collect powers of tmax and factorials
+                  for (unsigned int j = 0; j < i; ++j)
+                    {
+                      multiplier = multiplier
+                                   * Tensor<2, dim>(velocity_gradient[0]);
+                      factor *= tmax / (j + 1);
+                    }
+                  multiplier = factor * multiplier;
+                  F += multiplier;  // sum terms
+                }
+
+              // The "left stretch" tensor is computed from the deformation gradient tensor
+              // Note that Kaminski and Ribe incorrectly wrote U=Ft*F (typo, I guess).
+              const Tensor<2, dim> Ft = transpose(F);
+              const SymmetricTensor<2, dim> U = SymmetricTensor<2, dim>(F * Ft);
+              // The ~infinite strain axis is the first eigenvector of the "left stretch" tensor.
+              const Tensor<1, dim> ehat = eigenvectors(U)[0].second;
+              // Calculate theta by dotting the ISA (ehat) and the velocity (scaled to a unit vector)
+              // theta is limited to be less than pi/2 (stay in the first quadrant)
+              const double umag = in.velocity[0].norm();
+              double theta_val = 0;
+              if (umag > 100.0 * std::numeric_limits<double>::min())
+                {
+                  double dotprod = 0;
+                  for (unsigned int iq = 0; iq < dim; ++iq)
+                    {
+                      dotprod = dotprod + in.velocity[0][iq]*ehat[iq];
+                    }
+                  theta_val = std::acos(std::abs(dotprod / umag));
+                  if (theta_val > numbers::PI/2)
+                    theta_val = std::fmod(theta_val, numbers::PI/2);
+                }
+              (*return_value.second)(cell->active_cell_index()) = theta_val;
+            }
+
+        return return_value;
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(GrainLagAngle,
+                                                  "grain lag angle",
+                                                  "A visualization output object that generates output "
+                                                  "showing the angle between the ~infinite strain axis "
+                                                  "and the flow velocity. Kaminski and Ribe "
+                                                  "(see \\cite{Kaminski2002}) call this quantity $\\Theta$ and "
+                                                  "define it as "
+                                                  "$\\Theta = \\cos^{-1}(\\hat{u}\\cdot\\hat{e})$ "
+                                                  " where $\\hat{u}=\\vec{u}/|{u}|$, $\\vec{u}$ "
+                                                  "is the local flow velocity, and "
+                                                  "$\\hat{e}$ is the local infinite strain axis, "
+                                                  "which we calculate as the first eigenvector of "
+                                                  "the 'left stretch' tensor. "
+                                                  "$\\Theta$ can be used to calculate the grain "
+                                                  "orientation lag parameter."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\radian}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/gravity.cc.bak b/source/postprocess/visualization/gravity.cc.bak
new file mode 100644
index 00000000000..c353c53f67f
--- /dev/null
+++ b/source/postprocess/visualization/gravity.cc.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/gravity.h>
+#include <aspect/gravity_model/interface.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      Gravity<dim>::
+      Gravity ()
+        :
+        DataPostprocessorVector<dim> ("gravity",
+                                      update_quadrature_points),
+        Interface<dim>("m/s/s")
+      {}
+
+
+
+      template <int dim>
+      void
+      Gravity<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.evaluation_points.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == dim,    ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            const Tensor<1,dim> g = this->get_gravity_model().gravity_vector (input_data.evaluation_points[q]);
+            for (unsigned int k=0; k<dim; ++k)
+              computed_quantities[q](k) = g[k];
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Gravity,
+                                                  "gravity",
+                                                  "A visualization output object that outputs the gravity vector."
+                                                  "\n\n"
+                                                  "Physical units: \\si {\\meter\\per\\second\\squared} .")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/heat_flux_map.cc.bak b/source/postprocess/visualization/heat_flux_map.cc.bak
new file mode 100644
index 00000000000..3cb9a94d656
--- /dev/null
+++ b/source/postprocess/visualization/heat_flux_map.cc.bak
@@ -0,0 +1,208 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/heat_flux_map.h>
+#include <aspect/postprocess/heat_flux_map.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      HeatFluxMap<dim>::
+      HeatFluxMap ()
+        :
+        DataPostprocessorScalar<dim> ("heat_flux_map",
+                                      update_quadrature_points),
+        Interface<dim>("W/m/m")
+      {}
+
+
+
+      template <int dim>
+      void
+      HeatFluxMap<dim>::update ()
+      {
+        if (output_point_wise_heat_flux)
+          heat_flux_density_solution = Postprocess::internal::compute_dirichlet_boundary_heat_flux_solution_vector(*this);
+        else
+          heat_flux_and_area = internal::compute_heat_flux_through_boundary_faces (*this);
+      }
+
+
+
+      template <int dim>
+      void
+      HeatFluxMap<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        for (auto &quantity : computed_quantities)
+          quantity(0) = 0;
+
+        auto cell = input_data.template get_cell<dim>();
+
+        if (output_point_wise_heat_flux)
+          {
+            bool cell_at_top_or_bottom_boundary = false;
+            for (const unsigned int f : cell->face_indices())
+              if (cell->at_boundary(f) &&
+                  (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top" ||
+                   this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "bottom"))
+                cell_at_top_or_bottom_boundary = true;
+
+            if (cell_at_top_or_bottom_boundary)
+              {
+                std::vector<Point<dim>> quadrature_points(input_data.evaluation_points.size());
+                for (unsigned int i=0; i<input_data.evaluation_points.size(); ++i)
+                  quadrature_points[i] = this->get_mapping().transform_real_to_unit_cell(cell,input_data.evaluation_points[i]);
+
+                const Quadrature<dim> quadrature_formula(quadrature_points);
+
+                FEValues<dim> fe_volume_values (this->get_mapping(),
+                                                this->get_fe(),
+                                                quadrature_formula,
+                                                update_values);
+
+                fe_volume_values.reinit(cell);
+
+                std::vector<double> heat_flux_values(quadrature_formula.size());
+                fe_volume_values[this->introspection().extractors.temperature].get_function_values(heat_flux_density_solution, heat_flux_values);
+
+                for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+                  computed_quantities[q](0) = heat_flux_values[q];
+              }
+          }
+        else
+          {
+            double heat_flux = 0.0;
+
+            for (const unsigned int f : cell->face_indices())
+              if (cell->at_boundary(f) &&
+                  (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top" ||
+                   this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "bottom"))
+                {
+                  // add heatflow for this face
+                  heat_flux += heat_flux_and_area[cell->active_cell_index()][f].first /
+                               heat_flux_and_area[cell->active_cell_index()][f].second;
+                }
+
+            for (auto &quantity : computed_quantities)
+              quantity(0) = heat_flux;
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      HeatFluxMap<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Heat flux map");
+            {
+              prm.declare_entry("Output point wise heat flux",
+                                "false",
+                                Patterns::Bool(),
+                                "A boolean flag that controls whether to output the "
+                                "heat flux map as a point wise value, or as a cell-wise "
+                                "averaged value. The point wise output is more "
+                                "accurate, but it currently omits prescribed heat "
+                                "flux values at boundaries and advective heat flux "
+                                "that is caused by velocities non-tangential to boundaries. "
+                                "If you do not use these two features it is recommended "
+                                "to switch this setting on to benefit from the increased "
+                                "output resolution.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+      template <int dim>
+      void
+      HeatFluxMap<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Heat flux map");
+            {
+              output_point_wise_heat_flux = prm.get_bool("Output point wise heat flux");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(HeatFluxMap,
+                                                  "heat flux map",
+                                                  "A visualization output object that generates output for "
+                                                  "the heat flux density across the top and bottom boundary "
+                                                  "in outward direction. "
+                                                  "The heat flux is computed as sum "
+                                                  "of advective heat flux and conductive heat "
+                                                  "flux through Neumann boundaries, both "
+                                                  "computed as integral over the boundary area, "
+                                                  "and conductive heat flux through Dirichlet "
+                                                  "boundaries, which is computed using the "
+                                                  "consistent boundary flux method as described "
+                                                  "in ``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
+                                                  "The consistent Galerkin FEM for computing "
+                                                  "derived boundary quantities in thermal and or "
+                                                  "fluids problems. International Journal for "
+                                                  "Numerical Methods in Fluids, 7(4), 371-394.'' "
+                                                  "If only conductive heat flux through Dirichlet "
+                                                  "boundaries is of interest, the "
+                                                  "postprocessor can produce output of higher resolution "
+                                                  "by evaluating the CBF solution vector point-wise "
+                                                  "instead of computing cell-wise averaged values."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\watt\\per\\meter\\squared}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/heating.cc.bak b/source/postprocess/visualization/heating.cc.bak
new file mode 100644
index 00000000000..20c9c92530b
--- /dev/null
+++ b/source/postprocess/visualization/heating.cc.bak
@@ -0,0 +1,188 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/heating.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <deal.II/base/utilities.h>
+#include <deal.II/grid/grid_tools.h>
+
+#include <algorithm>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      Heating<dim>::
+      Heating ()
+        :
+        DataPostprocessor<dim> (),
+        Interface<dim>("W/m/m/m")
+      {}
+
+
+
+      template <int dim>
+      std::vector<std::string>
+      Heating<dim>::
+      get_names () const
+      {
+        std::vector<std::string> names = this->get_heating_model_manager().get_active_heating_model_names();
+
+        // make the names valid names for output variables via DataOut
+        for (auto &name : names)
+          std::replace(name.begin(), name.end(), ' ', '_');
+
+        return names;
+      }
+
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      Heating<dim>::
+      get_data_component_interpretation () const
+      {
+        return std::vector<DataComponentInterpretation::DataComponentInterpretation>
+               (this->get_heating_model_manager().get_active_heating_model_names().size(),
+                DataComponentInterpretation::component_is_scalar);
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      Heating<dim>::
+      get_needed_update_flags () const
+      {
+        return update_gradients | update_values  | update_quadrature_points | update_JxW_values;
+      }
+
+
+
+      template <int dim>
+      void
+      Heating<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        const auto &heating_model_objects = this->get_heating_model_manager().get_active_heating_models();
+
+        // we do not want to write any output if there are no heating models
+        // used in the computation
+        if (heating_model_objects.size() == 0)
+          return;
+
+        Assert (computed_quantities.size() == n_quadrature_points,
+                ExcMessage("The length of the vector of quantities that are computed in the "
+                           "postprocessor (" + dealii::Utilities::int_to_string(computed_quantities.size()) + ") has to match the "
+                           "number of quadrature points (" + dealii::Utilities::int_to_string(n_quadrature_points) + ")!"));
+        Assert (computed_quantities[0].size() == heating_model_objects.size(), ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError());
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data, this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points, this->n_compositional_fields());
+
+        std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (n_quadrature_points));
+
+        this->get_heating_model_manager().create_additional_material_model_inputs_and_outputs(in, out);
+        HeatingModel::HeatingModelOutputs heating_model_outputs(n_quadrature_points, this->n_compositional_fields());
+
+        // we need the cell as input for the material model because some heating models
+        // want to access the solution vector.
+        in.current_cell = input_data.template get_cell<dim>();
+
+        // we need an fevalues object to get the melt velocities
+        std::vector<Point<dim>> quadrature_points(n_quadrature_points);
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          quadrature_points[q] = this->get_mapping().transform_real_to_unit_cell(in.current_cell,input_data.evaluation_points[q]);
+
+        const Quadrature<dim> quadrature_formula (quadrature_points);
+        FEValues<dim> fe_values (this->get_mapping(),
+                                 this->get_fe(),
+                                 quadrature_formula,
+                                 update_values   |
+                                 update_gradients |
+                                 update_quadrature_points |
+                                 update_JxW_values);
+
+        fe_values.reinit(in.current_cell);
+        this->get_material_model().fill_additional_material_model_inputs(in,
+                                                                         this->get_solution(),
+                                                                         fe_values,
+                                                                         this->introspection());
+        this->get_material_model().evaluate(in, out);
+
+        if (this->get_parameters().formulation_temperature_equation
+            == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+          {
+            // Overwrite the density by the reference density coming from the
+            // adiabatic conditions as required by the formulation
+            for (unsigned int q=0; q<n_quadrature_points; ++q)
+              out.densities[q] = this->get_adiabatic_conditions().density(in.position[q]);
+          }
+        else if (this->get_parameters().formulation_temperature_equation
+                 == Parameters<dim>::Formulation::TemperatureEquation::real_density)
+          {
+            // use real density
+          }
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        unsigned int index = 0;
+        for (typename std::list<std::unique_ptr<HeatingModel::Interface<dim>>>::const_iterator
+             heating_model = heating_model_objects.begin();
+             heating_model != heating_model_objects.end(); ++heating_model, ++index)
+          {
+            (*heating_model)->evaluate(in, out, heating_model_outputs);
+
+            for (unsigned int q=0; q<n_quadrature_points; ++q)
+              computed_quantities[q][index] = heating_model_outputs.heating_source_terms[q];
+          }
+
+      }
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Heating,
+                                                  "heating",
+                                                  "A visualization output object that generates output "
+                                                  "for all the heating terms used in the energy equation."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\watt\\per\\cubic\\meter}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/kxrcf_indicator.cc.bak b/source/postprocess/visualization/kxrcf_indicator.cc.bak
new file mode 100644
index 00000000000..b932f96d09f
--- /dev/null
+++ b/source/postprocess/visualization/kxrcf_indicator.cc.bak
@@ -0,0 +1,135 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/kxrcf_indicator.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      KXRCFIndicator<dim>::KXRCFIndicator()
+        :
+        CellDataVectorCreator<dim>("")
+      {}
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      KXRCFIndicator<dim>::execute() const
+      {
+        std::pair<std::string, std::unique_ptr<Vector<float>>>
+        return_value ("KXRCF_indicator",
+                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+        this->compute_KXRCF_indicators(*return_value.second, field_index);
+        return return_value;
+      }
+
+
+      template <int dim>
+      void
+      KXRCFIndicator<dim>::declare_parameters(ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("KXRCF indicator");
+            {
+              prm.declare_entry ("Name of advection field", "",
+                                 Patterns::Anything(),
+                                 "The name of the advection field whose output "
+                                 "should be visualized. ");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+      template <int dim>
+      void
+      KXRCFIndicator<dim>::parse_parameters(ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("KXRCF indicator");
+            {
+              const std::string field_name = prm.get("Name of advection field");
+
+              if (field_name == "temperature")
+                field_index = 0;
+              else
+                {
+                  AssertThrow(this->introspection().compositional_name_exists(field_name),
+                              ExcMessage("No compositional field with name <" +
+                                         field_name +
+                                         "> exists for which you want to visualize the KXRCF indicator."));
+
+                  field_index = this->introspection().compositional_index_for_name(field_name) + 1;
+                }
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(KXRCFIndicator,
+                                                  "kxrcf indicator",
+                                                  "A visualization output object that generates output "
+                                                  "showing the value of the KXRCF indicator for a given "
+                                                  "advection field (either temperature or compositional "
+                                                  "field) on each cell. The KXRCF indicator is a metric "
+                                                  "of discontinuity for hyperbolic conservation laws. "
+                                                  "If the KXRCF value of a cell is higher than the value of "
+                                                  "``Temperature/Composition KXRCF indicator threshold'' "
+                                                  "of the corresponding field in the input parameter file, "
+                                                  "the cell will be identified as a ``troubled-cell'' that "
+                                                  "should be smoothed by the WENO limiter. For details, see "
+                                                  "\\cite{Krivodonova:etal:2004}."
+                                                  "\n\n"
+                                                  "This postprocessor should only be used for discontinuous "
+                                                  "advection fields. Otherwise, the postprocessor will produce "
+                                                  "a meaningless visualization output."
+                                                  "\n\n"
+                                                  "Physical units: none.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/material_properties.cc.bak b/source/postprocess/visualization/material_properties.cc.bak
new file mode 100644
index 00000000000..76e6a5eedfd
--- /dev/null
+++ b/source/postprocess/visualization/material_properties.cc.bak
@@ -0,0 +1,306 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/material_properties.h>
+#include <aspect/utilities.h>
+#include <aspect/melt.h>
+
+#include <algorithm>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      MaterialProperties<dim>::
+      MaterialProperties ()
+        :
+        DataPostprocessor<dim> (),
+        // What quantities are output depends on parameters, and so do the physical units.
+        // There is nothing useful we can provide here at this point.
+        Interface<dim>("")
+      {}
+
+
+
+      template <int dim>
+      std::vector<std::string>
+      MaterialProperties<dim>::
+      get_names () const
+      {
+        std::vector<std::string> solution_names;
+
+        for (const auto &property_name : property_names)
+          if (property_name == "reaction terms")
+            {
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                solution_names.push_back (this->introspection().name_for_compositional_index(c) + "_change");
+            }
+          else
+            {
+              solution_names.push_back(property_name);
+              std::replace(solution_names.back().begin(),solution_names.back().end(),' ', '_');
+            }
+
+        return solution_names;
+      }
+
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      MaterialProperties<dim>::
+      get_data_component_interpretation () const
+      {
+        std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretation;
+        for (const auto &property_name : property_names)
+          {
+            if (property_name == "reaction terms")
+              {
+                for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                  interpretation.push_back (DataComponentInterpretation::component_is_scalar);
+              }
+            else
+              interpretation.push_back (DataComponentInterpretation::component_is_scalar);
+          }
+
+        return interpretation;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      MaterialProperties<dim>::
+      get_needed_update_flags () const
+      {
+        return update_gradients | update_values  | update_quadrature_points;
+      }
+
+
+
+      template <int dim>
+      void
+      MaterialProperties<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,
+                ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,
+                ExcInternalError());
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+
+        this->get_material_model().evaluate(in, out);
+
+        // We want to output material properties as they are used in the
+        // program during assembly. To do so, some of the material averaging
+        // modes require a quadrature object -- but we do not have this,
+        // all we have is the mapped quadrature points. As a consequence,
+        // only do the averaging for those modes that do not require a
+        // functional quadrature object. This means that we only
+        // do the wrong thing for the Q1 averaging where the difference
+        // between input and output of the averaging operation is generally
+        // small and probably not visible anyway.
+        //
+        // The average() function checks whether any quadrature object
+        // it uses has the correct size. So passing an invalid object
+        // in the following code carries little risk if the list of
+        // averaging modes that require a quadrature object expands:
+        // Every time we generate graphical output for a model that
+        // uses this kind of averaging, we will trigger an exception.
+        if (this->get_parameters().material_averaging != MaterialModel::MaterialAveraging::AveragingOperation::project_to_Q1
+            &&
+            this->get_parameters().material_averaging != MaterialModel::MaterialAveraging::AveragingOperation::project_to_Q1_only_viscosity)
+          MaterialModel::MaterialAveraging::average (this->get_parameters().material_averaging,
+                                                     input_data.template get_cell<dim>(),
+                                                     Quadrature<dim>(),
+                                                     this->get_mapping(),
+                                                     in.requested_properties,
+                                                     out);
+
+        std::vector<double> melt_fractions(n_quadrature_points);
+        if (std::find(property_names.begin(), property_names.end(), "melt fraction") != property_names.end())
+          {
+            AssertThrow(MaterialModel::MeltFractionModel<dim>::is_melt_fraction_model(this->get_material_model()),
+                        ExcMessage("You are trying to visualize the melt fraction, but the material"
+                                   "model you use does not actually compute a melt fraction."));
+            MaterialModel::MeltFractionModel<dim>::as_melt_fraction_model(this->get_material_model())
+            .melt_fractions(in, melt_fractions);
+          }
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            unsigned output_index = 0;
+            for (unsigned int i=0; i<property_names.size(); ++i, ++output_index)
+              {
+                if (property_names[i] == "viscosity")
+                  computed_quantities[q][output_index] = out.viscosities[q];
+
+                else if (property_names[i] == "density")
+                  computed_quantities[q][output_index] = out.densities[q];
+
+                else if (property_names[i] == "thermal expansivity")
+                  computed_quantities[q][output_index] = out.thermal_expansion_coefficients[q];
+
+                else if (property_names[i] == "specific heat")
+                  computed_quantities[q][output_index] = out.specific_heat[q];
+
+                else if (property_names[i] == "thermal conductivity")
+                  computed_quantities[q][output_index] = out.thermal_conductivities[q];
+
+                else if (property_names[i] == "thermal diffusivity")
+                  computed_quantities[q][output_index] = out.thermal_conductivities[q]/(out.densities[q]*out.specific_heat[q]);
+
+                else if (property_names[i] == "compressibility")
+                  computed_quantities[q][output_index] = out.compressibilities[q];
+
+                else if (property_names[i] == "entropy derivative pressure")
+                  computed_quantities[q][output_index] = out.entropy_derivative_pressure[q];
+
+                else if (property_names[i] == "entropy derivative temperature")
+                  computed_quantities[q][output_index] = out.entropy_derivative_temperature[q];
+
+                else if (property_names[i] == "reaction terms")
+                  {
+                    for (unsigned int k=0; k<this->n_compositional_fields(); ++k, ++output_index)
+                      {
+                        computed_quantities[q][output_index] = out.reaction_terms[q][k];
+                      }
+                    --output_index;
+                  }
+                else if (property_names[i] == "melt fraction")
+                  computed_quantities[q][output_index] = melt_fractions[q];
+                else
+                  AssertThrow(false,
+                              ExcMessage("Material property not implemented for this postprocessor."));
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      MaterialProperties<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Material properties");
+            {
+              const std::string pattern_of_names
+                = "viscosity|density|thermal expansivity|specific heat|"
+                  "thermal conductivity|thermal diffusivity|compressibility|"
+                  "entropy derivative temperature|entropy derivative pressure|reaction terms|"
+                  "melt fraction";
+
+              prm.declare_entry("List of material properties",
+                                "density,thermal expansivity,specific heat,viscosity",
+                                Patterns::MultipleSelection(pattern_of_names),
+                                "A comma separated list of material properties that should be "
+                                "written whenever writing graphical output. By default, the "
+                                "material properties will always contain the density, thermal "
+                                "expansivity, specific heat and viscosity. "
+                                "The following material properties are available:\n\n"
+                                +
+                                pattern_of_names);
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      MaterialProperties<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Material properties");
+            {
+              // Get property names and compare against variable names
+              property_names = Utilities::split_string_list(prm.get ("List of material properties"));
+              AssertThrow(Utilities::has_unique_entries(property_names),
+                          ExcMessage("The list of strings for the parameter "
+                                     "'Postprocess/Visualization/Material properties/List of material properties' "
+                                     "contains entries more than once. This is not allowed. "
+                                     "Please check your parameter file."));
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MaterialProperties,
+                                                  "material properties",
+                                                  "A visualization output object that generates output "
+                                                  "for the material properties given by the material model. "
+                                                  "The current postprocessor allows to output a (potentially "
+                                                  "large) subset of all of the information provided by "
+                                                  "material models at once, with just a single material model "
+                                                  "evaluation per output point. "
+                                                  "Although individual properties can still be listed in the "
+                                                  "``List of output variables'', this visualization plugin "
+                                                  "is called internally to avoid duplicated evaluations of "
+                                                  "the material model. "
+                                                  "\n\n"
+                                                  "In almost all places inside \\aspect{}, the program "
+                                                  "can use ``averaged'' material properties, for example for "
+                                                  "the assembly of matrices and right hand side vectors. To "
+                                                  "accurately reflect the material parameters used internally, "
+                                                  "this visualization postprocessor averages in the same way "
+                                                  "as is used to do the assembly, and consequently the "
+                                                  "graphical output will reflect not pointwise properties, "
+                                                  "but averaged properties."
+                                                  "\n\n"
+                                                  "Physical units: Various.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/maximum_horizontal_compressive_stress.cc.bak b/source/postprocess/visualization/maximum_horizontal_compressive_stress.cc.bak
new file mode 100644
index 00000000000..54144cfdf80
--- /dev/null
+++ b/source/postprocess/visualization/maximum_horizontal_compressive_stress.cc.bak
@@ -0,0 +1,366 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      MaximumHorizontalCompressiveStress<dim>::
+      MaximumHorizontalCompressiveStress ()
+        :
+        Interface<dim>("Pa")
+      {}
+
+
+
+      template <int dim>
+      void
+      MaximumHorizontalCompressiveStress<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert ((computed_quantities[0].size() == dim),
+                ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+
+        // We do not need to compute anything but the viscosity
+        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+        // Compute the viscosity...
+        this->get_material_model().evaluate(in, out);
+
+        // ...and use it to compute the stresses and from that the
+        // maximum compressive stress direction
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            const SymmetricTensor<2,dim> strain_rate = in.strain_rate[q];
+            const SymmetricTensor<2,dim> deviatoric_strain_rate
+              = (this->get_material_model().is_compressible()
+                 ?
+                 strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
+                 :
+                 strain_rate);
+
+            const double eta = out.viscosities[q];
+
+            // first compute the stress tensor, ignoring the pressure
+            // for the moment (the pressure has no effect on the
+            // direction since it just adds a multiple of the identity
+            // matrix to the stress, but because it is large, it may
+            // lead to numerical instabilities)
+            //
+            // note that the *compressive* stress is simply the
+            // negative stress
+            const SymmetricTensor<2,dim> compressive_stress = -2*eta*deviatoric_strain_rate;
+
+            // then find a set of (dim-1) horizontal, unit-length, mutually orthogonal vectors
+            const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector (in.position[q]);
+            const Tensor<1,dim> vertical_direction = gravity/gravity.norm();
+            std::array<Tensor<1,dim>,dim-1 > orthogonal_directions
+              = Utilities::orthogonal_vectors(vertical_direction);
+            for (unsigned int i=0; i<orthogonal_directions.size(); ++i)
+              orthogonal_directions[i] /= orthogonal_directions[i].norm();
+
+            Tensor<1,dim> maximum_horizontal_compressive_stress;
+            switch (dim)
+              {
+                // in 2d, there is only one horizontal direction, and
+                // we have already computed it above. give it the
+                // length of the compressive_stress (now taking into account the
+                // pressure) in this direction
+                case 2:
+                {
+                  maximum_horizontal_compressive_stress = orthogonal_directions[0] *
+                                                          (orthogonal_directions[0] *
+                                                           ((compressive_stress
+                                                             -
+                                                             in.pressure[q] * unit_symmetric_tensor<dim>()) *
+                                                            orthogonal_directions[0]));
+                  break;
+                }
+
+                // in 3d, use the formulas discussed in the
+                // documentation of the plugin below
+                case 3:
+                {
+                  const double a = orthogonal_directions[0] *
+                                   (compressive_stress *
+                                    orthogonal_directions[0]);
+                  const double b = orthogonal_directions[1] *
+                                   (compressive_stress *
+                                    orthogonal_directions[1]);
+                  const double c = 2.0*orthogonal_directions[0] *
+                                   (compressive_stress *
+                                    orthogonal_directions[1]);
+
+                  // compute the two stationary points of f(alpha)
+                  const double alpha_1 = 1./2 * std::atan2 (c, a-b);
+                  const double alpha_2 = alpha_1 + numbers::PI/2;
+
+                  // then check the sign of f''(alpha) to determine
+                  // which of the two stationary points is the maximum
+                  const double f_double_prime_1 = 2*(b-a)*std::cos(2*alpha_1)
+                                                  - 2*c*sin(2*alpha_1);
+                  double alpha;
+                  if (f_double_prime_1 < 0)
+                    alpha = alpha_1;
+                  else
+                    {
+                      Assert (/* f_double_prime_2 = */
+                        2*(b-a)*std::cos(2*alpha_2) - 2*c*sin(2*alpha_2) <= 0,
+                        ExcInternalError());
+                      alpha = alpha_2;
+                    }
+
+                  // then re-assemble the maximum horizontal compressive_stress
+                  // direction from alpha and the two horizontal
+                  // directions
+                  const Tensor<1,dim> n = std::cos(alpha) * orthogonal_directions[0] +
+                                          std::sin(alpha) * orthogonal_directions[1];
+
+                  // finally compute the actual direction * magnitude,
+                  // now taking into account the pressure (with the
+                  // correct sign in front of the pressure for the
+                  // *compressive* stress)
+                  //
+                  // the magnitude is computed as discussed in the
+                  // description of the plugin below
+                  const double maximum_horizontal_compressive_stress_magnitude
+                    = (n * ((compressive_stress
+                             -
+                             in.pressure[q] * unit_symmetric_tensor<dim>()) * n));
+                  const Tensor<1,dim> n_perp = std::sin(alpha) * orthogonal_directions[0] -
+                                               std::cos(alpha) * orthogonal_directions[1];
+
+                  const double minimum_horizontal_compressive_stress_magnitude
+                    = (n_perp * ((compressive_stress
+                                  -
+                                  in.pressure[q] * unit_symmetric_tensor<dim>()) * n_perp));
+
+                  maximum_horizontal_compressive_stress
+                    = n * (maximum_horizontal_compressive_stress_magnitude -
+                           minimum_horizontal_compressive_stress_magnitude);
+
+                  break;
+                }
+
+                default:
+                  Assert (false, ExcNotImplemented());
+              }
+
+            for (unsigned int i=0; i<dim; ++i)
+              computed_quantities[q](i) = maximum_horizontal_compressive_stress[i];
+          }
+      }
+
+
+      template <int dim>
+      std::vector<std::string>
+      MaximumHorizontalCompressiveStress<dim>::get_names () const
+      {
+        return std::vector<std::string> (dim, "maximum_horizontal_compressive_stress");
+      }
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      MaximumHorizontalCompressiveStress<dim>::get_data_component_interpretation () const
+      {
+        return
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          (dim,
+           DataComponentInterpretation::component_is_part_of_vector);
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      MaximumHorizontalCompressiveStress<dim>::get_needed_update_flags () const
+      {
+        return update_gradients | update_values | update_quadrature_points;
+      }
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MaximumHorizontalCompressiveStress,
+                                                  "maximum horizontal compressive stress",
+                                                  "A plugin that computes the direction and magnitude of the "
+                                                  "maximum horizontal component of the compressive stress as a vector "
+                                                  "field. The direction of this vector can often be used to "
+                                                  "visualize the principal mode of deformation (e.g., at "
+                                                  "normal faults or extensional margins) and can be "
+                                                  "correlated with seismic anisotropy. Recall that the "
+                                                  "\\textit{compressive} stress is simply the negative stress, "
+                                                  "$\\sigma_c=-\\sigma=-\\left["
+                                                  "     2\\eta (\\varepsilon(\\mathbf u)"
+                                                  "             - \\frac 13 (\\nabla \\cdot \\mathbf u) I)"
+                                                  "     + pI\\right]$."
+                                                  "\n\n"
+                                                  "Following \\cite{LundTownend07}, we define the maximum horizontal "
+                                                  "stress direction as that \\textit{horizontal} direction "
+                                                  "$\\mathbf n$ that maximizes $\\mathbf n^T \\sigma_c \\mathbf n$. We "
+                                                  "call a vector \\textit{horizontal} if it is perpendicular to the "
+                                                  "gravity vector $\\mathbf g$."
+                                                  "\n\n"
+                                                  "In two space dimensions, $\\mathbf n$ is simply a vector that "
+                                                  "is horizontal (we choose one of the two possible choices). "
+                                                  "This direction is then scaled by the size of the horizontal stress "
+                                                  "in this direction, i.e., the plugin outputs the vector "
+                                                  "$\\mathbf w = (\\mathbf n^T \\sigma_c \\mathbf n) \\; \\mathbf n$."
+                                                  "\n\n"
+                                                  "In three space dimensions, given two horizontal, perpendicular, "
+                                                  "unit length, but otherwise arbitrarily chosen vectors "
+                                                  "$\\mathbf u,\\mathbf v$, we can express "
+                                                  "$\\mathbf n = (\\cos \\alpha)\\mathbf u + (\\sin\\alpha)\\mathbf v$ "
+                                                  "where $\\alpha$ maximizes the expression "
+                                                  "\\begin{align*}"
+                                                  "  f(\\alpha) = \\mathbf n^T \\sigma_c \\mathbf n"
+                                                  "  = (\\mathbf u^T \\sigma_c \\mathbf u)(\\cos\\alpha)^2"
+                                                  "    +2(\\mathbf u^T \\sigma_c \\mathbf v)(\\cos\\alpha)(\\sin\\alpha)"
+                                                  "    +(\\mathbf v^T \\sigma_c \\mathbf v)(\\sin\\alpha)^2."
+                                                  "\\end{align*}"
+                                                  "\n\n"
+                                                  "The maximum of $f(\\alpha)$ is attained where $f^\\prime(\\alpha)=0$. "
+                                                  "Evaluating the derivative and using trigonometric identities, "
+                                                  "one finds that $\\alpha$ has to satisfy the equation "
+                                                  "\\begin{align*}"
+                                                  "  \\tan(2\\alpha) = \\frac{2.0\\mathbf u^T \\sigma_c \\mathbf v}"
+                                                  "                          {\\mathbf u^T \\sigma_c \\mathbf u "
+                                                  "                           - \\mathbf v^T \\sigma_c \\mathbf v}."
+                                                  "\\end{align*}"
+                                                  "Since the transform $\\alpha\\mapsto\\alpha+\\pi$ flips the "
+                                                  "direction of $\\mathbf n$, we only need to seek a solution "
+                                                  "to this equation in the interval $\\alpha\\in[0,\\pi)$. "
+                                                  "These are given by "
+                                                  "$\\alpha_1=\\frac 12 \\arctan \\frac{\\mathbf u^T \\sigma_c "
+                                                  "\\mathbf v}{\\mathbf u^T \\sigma_c \\mathbf u - "
+                                                  "\\mathbf v^T \\sigma_c \\mathbf v}$ and "
+                                                  "$\\alpha_2=\\alpha_1+\\frac{\\pi}{2}$, one of which will "
+                                                  "correspond to a minimum and the other to a maximum of "
+                                                  "$f(\\alpha)$. One checks the sign of "
+                                                  "$f^{\\prime\\prime}(\\alpha)=-2(\\mathbf u^T \\sigma_c \\mathbf u - "
+                                                  "\\mathbf v^T \\sigma_c \\mathbf v)\\cos(2\\alpha) "
+                                                  "- 2 (\\mathbf u^T \\sigma_c \\mathbf v) \\sin(2\\alpha)$ for "
+                                                  "each of these to determine the $\\alpha$ that maximizes "
+                                                  "$f(\\alpha)$, and from this immediately arrives at the correct "
+                                                  "form for the maximum horizontal stress $\\mathbf n$."
+                                                  "\n\n"
+                                                  "The description above computes a 3d \\textit{direction} vector "
+                                                  "$\\mathbf n$. If one were to scale this vector the same way "
+                                                  "as done in 2d, i.e., with the magnitude of the stress in "
+                                                  "this direction, one will typically get vectors whose length "
+                                                  "is principally determined by the hydrostatic pressure at "
+                                                  "a given location simply because the hydrostatic pressure "
+                                                  "is the largest component of the overall stress. On the other "
+                                                  "hand, the hydrostatic pressure does not determine any "
+                                                  "principal direction because it is an isotropic, anti-compressive "
+                                                  "force. As a consequence, there are often points in simulations "
+                                                  "(e.g., at the center of convection rolls) where the stress has "
+                                                  "no dominant horizontal direction, and the algorithm above will "
+                                                  "then in essence choose a random direction because the stress "
+                                                  "is approximately equal in all horizontal directions. If one "
+                                                  "scaled the output by the magnitude of the stress in this "
+                                                  "direction (i.e., approximately equal to the hydrostatic "
+                                                  "pressure at this point), one would get randomly oriented vectors "
+                                                  "at these locations with significant lengths."
+                                                  "\n\n"
+                                                  "To avoid this problem, we scale the maximal horizontal "
+                                                  "compressive stress direction $\\mathbf n$ by the \\textit{difference} "
+                                                  "between the stress in the maximal and minimal horizontal stress "
+                                                  "directions. In other words, let "
+                                                  "$\\mathbf n_\\perp=(\\sin \\alpha)\\mathbf u - (\\cos\\alpha)\\mathbf v$ "
+                                                  "be the horizontal direction perpendicular to "
+                                                  "$\\mathbf n$, then this plugin outputs the vector quantity "
+                                                  "$\\mathbf w = (\\mathbf n^T \\sigma_c \\mathbf n "
+                                                  "               -\\mathbf n^T_\\perp \\sigma_c \\mathbf n_\\perp) "
+                                                  "              \\; \\mathbf n$. "
+                                                  "In other words, the length of the vector produced indicates "
+                                                  "\\textit{how dominant} the direction of maximal horizontal "
+                                                  "compressive strength is."
+                                                  "\n\n"
+                                                  "Fig.~\\ref{fig:max-horizontal-compressive-stress} shows a "
+                                                  "simple example for this kind of visualization in 3d."
+                                                  "\n\n"
+                                                  "\\begin{figure}"
+                                                  "  \\includegraphics[width=0.3\\textwidth]"
+                                                  "    {viz/plugins/maximum_horizontal_compressive_stress/temperature.png}"
+                                                  "  \\hfill"
+                                                  "  \\includegraphics[width=0.3\\textwidth]"
+                                                  "    {viz/plugins/maximum_horizontal_compressive_stress/velocity.png}"
+                                                  "  \\hfill"
+                                                  "  \\includegraphics[width=0.3\\textwidth]"
+                                                  "    {viz/plugins/maximum_horizontal_compressive_stress/horizontal-stress.png}"
+                                                  "  \\caption{\\it Illustration of the `maximum horizontal "
+                                                  "    compressive stress' visualization plugin. The left "
+                                                  "    figure shows a ridge-like temperature anomaly. Together "
+                                                  "    with no-slip boundary along all six boundaries, this "
+                                                  "    results in two convection rolls (center). The maximal "
+                                                  "    horizontal compressive strength at the bottom center "
+                                                  "    of the domain is perpendicular to the ridge because "
+                                                  "    the flow comes together there from the left and right, "
+                                                  "    yielding a compressive force in left-right direction. "
+                                                  "    At the top of the model, the flow separates outward, "
+                                                  "    leading to a \\textit{negative} compressive stress "
+                                                  "    in left-right direction; because there is no flow "
+                                                  "    in front-back direction, the compressive strength "
+                                                  "    in front-back direction is zero, making the along-ridge "
+                                                  "    direction the dominant one. At the center of the "
+                                                  "    convection rolls, both horizontal directions yield "
+                                                  "    the same stress; the plugin therefore chooses an "
+                                                  "    essentially arbitrary horizontal vector, but then "
+                                                  "    uses a zero magnitude given that the difference "
+                                                  "    between the maximal and minimal horizontal stress "
+                                                  "    is zero at these points.}"
+                                                  "  \\label{fig:max-horizontal-compressive-stress}"
+                                                  "\\end{figure}"
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\pascal}."
+                                                 )
+    }
+  }
+}
diff --git a/source/postprocess/visualization/melt.cc.bak b/source/postprocess/visualization/melt.cc.bak
new file mode 100644
index 00000000000..ca291391f0d
--- /dev/null
+++ b/source/postprocess/visualization/melt.cc.bak
@@ -0,0 +1,278 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/melt.h>
+#include <aspect/melt.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator.h>
+#include <aspect/material_model/interface.h>
+
+#include <deal.II/numerics/data_out.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+
+      template <int dim>
+      MeltMaterialProperties<dim>::
+      MeltMaterialProperties ()
+        :
+        DataPostprocessor<dim> (),
+        // What is being output depends on run-time parameters. We can not
+        // describe physical units to the base class at this point.
+        Interface<dim>("")
+      {}
+
+
+
+      template <int dim>
+      std::vector<std::string>
+      MeltMaterialProperties<dim>::
+      get_names () const
+      {
+        std::vector<std::string> solution_names;
+
+        for (const auto &property_name : property_names)
+          if (property_name == "fluid density gradient")
+            for (unsigned int i=0; i<dim; ++i)
+              solution_names.emplace_back("fluid_density_gradient");
+          else if (property_name == "compaction pressure")
+            {
+              solution_names.emplace_back("p_c");
+            }
+          else
+            {
+              solution_names.push_back(property_name);
+              std::replace(solution_names.back().begin(),solution_names.back().end(),' ', '_');
+            }
+
+        return solution_names;
+      }
+
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      MeltMaterialProperties<dim>::
+      get_data_component_interpretation () const
+      {
+        std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretation;
+        for (const auto &property_name : property_names)
+          {
+            if (property_name == "fluid density gradient")
+              {
+                for (unsigned int c=0; c<dim; ++c)
+                  interpretation.push_back (DataComponentInterpretation::component_is_part_of_vector);
+              }
+            else
+              interpretation.push_back (DataComponentInterpretation::component_is_scalar);
+          }
+
+        return interpretation;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      MeltMaterialProperties<dim>::
+      get_needed_update_flags () const
+      {
+        return update_gradients | update_values  | update_quadrature_points;
+      }
+
+
+
+      template <int dim>
+      void
+      MeltMaterialProperties<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        AssertThrow(this->include_melt_transport()==true,
+                    ExcMessage("'Include melt transport' has to be on when using melt transport postprocessors."));
+
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
+
+        // Set use_strain_rates to true since the compaction viscosity might also depend on the strain rate.
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points, this->n_compositional_fields());
+        MeltHandler<dim>::create_material_model_outputs(out);
+
+        this->get_material_model().evaluate(in, out);
+        MaterialModel::MeltOutputs<dim> *melt_outputs = out.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+        AssertThrow(melt_outputs != nullptr,
+                    ExcMessage("Need MeltOutputs from the material model for computing the melt properties."));
+
+        const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(this->get_material_model()).p_c_scale(in,
+                                 out,
+                                 this->get_melt_handler(),
+                                 true);
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            unsigned output_index = 0;
+            for (unsigned int i=0; i<property_names.size(); ++i, ++output_index)
+              {
+                if (property_names[i] == "compaction viscosity")
+                  computed_quantities[q][output_index] = melt_outputs->compaction_viscosities[q];
+                else if (property_names[i] == "fluid viscosity")
+                  computed_quantities[q][output_index] = melt_outputs->fluid_viscosities[q];
+                else if (property_names[i] == "permeability")
+                  computed_quantities[q][output_index] = melt_outputs->permeabilities[q];
+                else if (property_names[i] == "fluid density")
+                  computed_quantities[q][output_index] = melt_outputs->fluid_densities[q];
+                else if (property_names[i] == "fluid density gradient")
+                  {
+                    for (unsigned int k=0; k<dim; ++k, ++output_index)
+                      {
+                        computed_quantities[q][output_index] = melt_outputs->fluid_density_gradients[q][k];
+                      }
+                    --output_index;
+                  }
+                else if (property_names[i] == "compaction pressure")
+                  {
+                    const unsigned int pc_comp_idx = this->introspection().variable("compaction pressure").first_component_index;
+                    const double p_c_bar = input_data.solution_values[q][pc_comp_idx];
+
+                    computed_quantities[q][output_index] = p_c_scale * p_c_bar;
+                  }
+                else if (property_names[i] == "darcy coefficient")
+                  {
+                    const double K_D = this->get_melt_handler().limited_darcy_coefficient(melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q], p_c_scale > 0);
+                    computed_quantities[q][output_index] = K_D;
+                  }
+                else if (property_names[i] == "darcy coefficient no cutoff")
+                  {
+                    const double K_D_no_cut = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q];
+                    computed_quantities[q][output_index] = K_D_no_cut;
+                  }
+                else if (property_names[i] == "is melt cell")
+                  {
+                    computed_quantities[q][output_index] = this->get_melt_handler().is_melt_cell(in.current_cell)? 1.0 : 0.0;
+                  }
+                else if (property_names[i] == "compaction length")
+                  {
+                    const double compaction_length = std::sqrt((out.viscosities[q] + 4./3. * melt_outputs->compaction_viscosities[q])
+                                                               * melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q]);
+                    computed_quantities[q][output_index] = compaction_length;
+                  }
+                else
+                  AssertThrow(false, ExcNotImplemented());
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      MeltMaterialProperties<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Melt material properties");
+            {
+              const std::string pattern_of_names
+                = "compaction viscosity|fluid viscosity|permeability|"
+                  "fluid density|fluid density gradient|is melt cell|"
+                  "darcy coefficient|darcy coefficient no cutoff|"
+                  "compaction length";
+
+              prm.declare_entry("List of properties",
+                                "compaction viscosity,permeability",
+                                Patterns::MultipleSelection(pattern_of_names),
+                                "A comma separated list of melt properties that should be "
+                                "written whenever writing graphical output. "
+                                "The following material properties are available:\n\n"
+                                +
+                                pattern_of_names);
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      MeltMaterialProperties<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Melt material properties");
+            {
+              property_names = Utilities::split_string_list(prm.get ("List of properties"));
+              AssertThrow(Utilities::has_unique_entries(property_names),
+                          ExcMessage("The list of strings for the parameter "
+                                     "'Postprocess/Visualization/Melt material properties/List of properties' contains entries more than once. "
+                                     "This is not allowed. Please check your parameter file."));
+
+              // Always output compaction pressure
+              property_names.insert(property_names.begin(),"compaction pressure");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MeltMaterialProperties,
+                                                  "melt material properties",
+                                                  "A visualization output object that generates output "
+                                                  "for melt related properties of the material model. Note "
+                                                  "that this postprocessor always outputs the compaction pressure, "
+                                                  "but can output a large range of additional properties, as "
+                                                  "selected in the ``List of properties'' parameter."
+                                                  "\n\n"
+                                                  "Physical units: Various, depending on what is being output.")
+
+    }
+  }
+}
diff --git a/source/postprocess/visualization/melt_fraction.cc.bak b/source/postprocess/visualization/melt_fraction.cc.bak
new file mode 100644
index 00000000000..688d99a177e
--- /dev/null
+++ b/source/postprocess/visualization/melt_fraction.cc.bak
@@ -0,0 +1,354 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/melt_fraction.h>
+#include <aspect/melt.h>
+
+#include <deal.II/base/parameter_handler.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      MeltFraction<dim>::
+      MeltFraction ()
+        :
+        DataPostprocessorScalar<dim> ("melt_fraction",
+                                      update_values | update_quadrature_points),
+        Interface<dim>("")  // a fraction, so physical units "1"
+      {}
+
+
+
+      template <int dim>
+      void
+      MeltFraction<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
+
+        // in case the material model computes the melt fraction itself, we use that output
+        if (MaterialModel::MeltFractionModel<dim>::is_melt_fraction_model(this->get_material_model()))
+          {
+            MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                       this->introspection());
+            MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                         this->n_compositional_fields());
+
+            // Compute the melt fraction...
+            this->get_material_model().evaluate(in, out);
+
+            std::vector<double> melt_fractions(n_quadrature_points);
+            MaterialModel::MeltFractionModel<dim>::as_melt_fraction_model(this->get_material_model())
+            .melt_fractions(in, melt_fractions);
+
+            for (unsigned int q=0; q<n_quadrature_points; ++q)
+              computed_quantities[q](0) = melt_fractions[q];
+          }
+        else
+          for (unsigned int q=0; q<n_quadrature_points; ++q)
+            {
+              const double pressure    = input_data.solution_values[q][this->introspection().component_indices.pressure];
+              const double temperature = input_data.solution_values[q][this->introspection().component_indices.temperature];
+              std::vector<double> composition(this->n_compositional_fields());
+
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                composition[c] = input_data.solution_values[q][this->introspection().component_indices.compositional_fields[c]];
+
+              // anhydrous melting of peridotite after Katz, 2003
+              const double T_solidus  = A1 + 273.15
+                                        + A2 * pressure
+                                        + A3 * pressure * pressure;
+              const double T_lherz_liquidus = B1 + 273.15
+                                              + B2 * pressure
+                                              + B3 * pressure * pressure;
+              const double T_liquidus = C1 + 273.15
+                                        + C2 * pressure
+                                        + C3 * pressure * pressure;
+
+              // melt fraction for peridotite with clinopyroxene
+              double peridotite_melt_fraction;
+              if (temperature < T_solidus || pressure > 1.3e10)
+                peridotite_melt_fraction = 0.0;
+              else if (temperature > T_lherz_liquidus)
+                peridotite_melt_fraction = 1.0;
+              else
+                peridotite_melt_fraction = std::pow((temperature - T_solidus) / (T_lherz_liquidus - T_solidus),beta);
+
+              // melt fraction after melting of all clinopyroxene
+              const double R_cpx = r1 + r2 * std::max(0.0, pressure);
+              const double F_max = M_cpx / R_cpx;
+
+              if (peridotite_melt_fraction > F_max && temperature < T_liquidus)
+                {
+                  const double T_max = std::pow(F_max,1/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
+                  peridotite_melt_fraction = F_max + (1 - F_max) * pow((temperature - T_max) / (T_liquidus - T_max),beta);
+                }
+
+              // melting of pyroxenite after Sobolev et al., 2011
+              const double T_melting = D1 + 273.15
+                                       + D2 * pressure
+                                       + D3 * pressure * pressure;
+
+              const double discriminant = E1*E1/(E2*E2*4) + (temperature-T_melting)/E2;
+
+              double pyroxenite_melt_fraction;
+              if (temperature < T_melting || pressure > 1.3e10)
+                pyroxenite_melt_fraction = 0.0;
+              else if (discriminant < 0)
+                pyroxenite_melt_fraction = 0.5429;
+              else
+                pyroxenite_melt_fraction = -E1/(2*E2) - std::sqrt(discriminant);
+
+              double melt_fraction;
+              if (this->introspection().compositional_name_exists("pyroxenite"))
+                {
+                  const unsigned int pyroxenite_index = this->introspection().compositional_index_for_name("pyroxenite");
+                  melt_fraction = composition[pyroxenite_index] * pyroxenite_melt_fraction +
+                                  (1-composition[pyroxenite_index]) * peridotite_melt_fraction;
+                }
+              else
+                melt_fraction = peridotite_melt_fraction;
+
+              computed_quantities[q](0) = melt_fraction;
+            }
+      }
+
+
+
+      template <int dim>
+      void
+      MeltFraction<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Melt fraction");
+            {
+              prm.declare_entry ("A1", "1085.7",
+                                 Patterns::Double (),
+                                 "Constant parameter in the quadratic "
+                                 "function that approximates the solidus "
+                                 "of peridotite. "
+                                 "Units: \\si{\\degreeCelsius}.");
+              prm.declare_entry ("A2", "1.329e-7",
+                                 Patterns::Double (),
+                                 "Prefactor of the linear pressure term "
+                                 "in the quadratic function that approximates "
+                                 "the solidus of peridotite. "
+                                 "\\si{\\degreeCelsius\\per\\pascal}.");
+              prm.declare_entry ("A3", "-5.1e-18",
+                                 Patterns::Double (),
+                                 "Prefactor of the quadratic pressure term "
+                                 "in the quadratic function that approximates "
+                                 "the solidus of peridotite. "
+                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
+              prm.declare_entry ("B1", "1475.0",
+                                 Patterns::Double (),
+                                 "Constant parameter in the quadratic "
+                                 "function that approximates the lherzolite "
+                                 "liquidus used for calculating the fraction "
+                                 "of peridotite-derived melt. "
+                                 "Units: \\si{\\degreeCelsius}.");
+              prm.declare_entry ("B2", "8.0e-8",
+                                 Patterns::Double (),
+                                 "Prefactor of the linear pressure term "
+                                 "in the quadratic function that approximates "
+                                 "the  lherzolite liquidus used for "
+                                 "calculating the fraction of peridotite-"
+                                 "derived melt. "
+                                 "\\si{\\degreeCelsius\\per\\pascal}.");
+              prm.declare_entry ("B3", "-3.2e-18",
+                                 Patterns::Double (),
+                                 "Prefactor of the quadratic pressure term "
+                                 "in the quadratic function that approximates "
+                                 "the  lherzolite liquidus used for "
+                                 "calculating the fraction of peridotite-"
+                                 "derived melt. "
+                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
+              prm.declare_entry ("C1", "1780.0",
+                                 Patterns::Double (),
+                                 "Constant parameter in the quadratic "
+                                 "function that approximates the liquidus "
+                                 "of peridotite. "
+                                 "Units: \\si{\\degreeCelsius}.");
+              prm.declare_entry ("C2", "4.50e-8",
+                                 Patterns::Double (),
+                                 "Prefactor of the linear pressure term "
+                                 "in the quadratic function that approximates "
+                                 "the liquidus of peridotite. "
+                                 "\\si{\\degreeCelsius\\per\\pascal}.");
+              prm.declare_entry ("C3", "-2.0e-18",
+                                 Patterns::Double (),
+                                 "Prefactor of the quadratic pressure term "
+                                 "in the quadratic function that approximates "
+                                 "the liquidus of peridotite. "
+                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
+              prm.declare_entry ("r1", "0.5",
+                                 Patterns::Double (),
+                                 "Constant in the linear function that "
+                                 "approximates the clinopyroxene reaction "
+                                 "coefficient. "
+                                 "Units: non-dimensional.");
+              prm.declare_entry ("r2", "8e-11",
+                                 Patterns::Double (),
+                                 "Prefactor of the linear pressure term "
+                                 "in the linear function that approximates "
+                                 "the clinopyroxene reaction coefficient. "
+                                 "Units: \\si{\\per\\pascal}.");
+              prm.declare_entry ("beta", "1.5",
+                                 Patterns::Double (),
+                                 "Exponent of the melting temperature in "
+                                 "the melt fraction calculation. "
+                                 "Units: non-dimensional.");
+              prm.declare_entry ("Mass fraction cpx", "0.15",
+                                 Patterns::Double (),
+                                 "Mass fraction of clinopyroxene in the "
+                                 "peridotite to be molten. "
+                                 "Units: non-dimensional.");
+              prm.declare_entry ("D1", "976.0",
+                                 Patterns::Double (),
+                                 "Constant parameter in the quadratic "
+                                 "function that approximates the solidus "
+                                 "of pyroxenite. "
+                                 "Units: \\si{\\degreeCelsius}.");
+              prm.declare_entry ("D2", "1.329e-7",
+                                 Patterns::Double (),
+                                 "Prefactor of the linear pressure term "
+                                 "in the quadratic function that approximates "
+                                 "the solidus of pyroxenite. "
+                                 "Note that this factor is different from the "
+                                 "value given in Sobolev, 2011, because they use "
+                                 "the potential temperature whereas we use the "
+                                 "absolute temperature. "
+                                 "\\si{\\degreeCelsius\\per\\pascal}.");
+              prm.declare_entry ("D3", "-5.1e-18",
+                                 Patterns::Double (),
+                                 "Prefactor of the quadratic pressure term "
+                                 "in the quadratic function that approximates "
+                                 "the solidus of pyroxenite. "
+                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
+              prm.declare_entry ("E1", "663.8",
+                                 Patterns::Double (),
+                                 "Prefactor of the linear depletion term "
+                                 "in the quadratic function that approximates "
+                                 "the melt fraction of pyroxenite. "
+                                 "\\si{\\degreeCelsius\\per\\pascal}.");
+              prm.declare_entry ("E2", "-611.4",
+                                 Patterns::Double (),
+                                 "Prefactor of the quadratic depletion term "
+                                 "in the quadratic function that approximates "
+                                 "the melt fraction of pyroxenite. "
+                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+      template <int dim>
+      void
+      MeltFraction<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Melt fraction");
+            {
+              A1              = prm.get_double ("A1");
+              A2              = prm.get_double ("A2");
+              A3              = prm.get_double ("A3");
+              B1              = prm.get_double ("B1");
+              B2              = prm.get_double ("B2");
+              B3              = prm.get_double ("B3");
+              C1              = prm.get_double ("C1");
+              C2              = prm.get_double ("C2");
+              C3              = prm.get_double ("C3");
+              r1              = prm.get_double ("r1");
+              r2              = prm.get_double ("r2");
+              beta            = prm.get_double ("beta");
+              M_cpx           = prm.get_double ("Mass fraction cpx");
+              D1              = prm.get_double ("D1");
+              D2              = prm.get_double ("D2");
+              D3              = prm.get_double ("D3");
+              E1              = prm.get_double ("E1");
+              E2              = prm.get_double ("E2");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MeltFraction,
+                                                  "melt fraction", // TODO write down equations here
+                                                  "A visualization output object that generates output "
+                                                  "for the melt fraction at the temperature and "
+                                                  "pressure of the current point. If the material model computes "
+                                                  "a melt fraction, this is the quantity that will be visualized. "
+                                                  "Otherwise, a specific parametrization for batch melting "
+                                                  "(as described in the following) will be used. "
+                                                  "It does not take into account latent heat. "
+                                                  "If there are no compositional fields, or no fields called 'pyroxenite', "
+                                                  " this postprocessor will visualize the melt fraction of peridotite "
+                                                  "(calculated using the anhydrous model of Katz, 2003). "
+                                                  "If there is a compositional field called 'pyroxenite', the "
+                                                  "postprocessor assumes that this compositional "
+                                                  "field is the content of pyroxenite, and will visualize "
+                                                  "the melt fraction for a mixture of peridotite and pyroxenite "
+                                                  "(using the melting model of Sobolev, 2011 for pyroxenite). "
+                                                  "All the parameters that were used in these calculations "
+                                                  "can be changed in the input file, the most relevant maybe "
+                                                  "being the mass fraction of Cpx in peridotite in the Katz "
+                                                  "melting model (Mass fraction cpx), which right now has a "
+                                                  "default of 15\\%. "
+                                                  "The corresponding $p$-$T$-diagrams can be generated by running "
+                                                  "the tests melt\\_postprocessor\\_peridotite and "
+                                                  "melt\\_postprocessor\\_pyroxenite."
+                                                  "\n\n"
+                                                  "Physical units: None.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/named_additional_outputs.cc.bak b/source/postprocess/visualization/named_additional_outputs.cc.bak
new file mode 100644
index 00000000000..411406b5703
--- /dev/null
+++ b/source/postprocess/visualization/named_additional_outputs.cc.bak
@@ -0,0 +1,184 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/named_additional_outputs.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/utilities.h>
+
+#include <algorithm>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      NamedAdditionalOutputs<dim>::
+      NamedAdditionalOutputs ()
+        :
+        DataPostprocessor<dim> (),
+        Interface<dim>("")  // physical units depend on run-time parameters
+      {}
+
+
+
+      template <int dim>
+      void
+      NamedAdditionalOutputs<dim>::
+      initialize ()
+      {
+        MaterialModel::MaterialModelOutputs<dim> out(0,
+                                                     this->n_compositional_fields());
+        this->get_material_model().create_additional_named_outputs(out);
+
+        AssertThrow(out.additional_outputs.size() > 0,
+                    ExcMessage("You activated the postprocessor <named additional outputs>, but there are no additional outputs "
+                               "provided by the material model. Either remove the postprocessor, or check why no output is provided."));
+
+        for (unsigned int k=0; k<out.additional_outputs.size(); ++k)
+          {
+            const MaterialModel::NamedAdditionalMaterialOutputs<dim> *result
+              = dynamic_cast<const MaterialModel::NamedAdditionalMaterialOutputs<dim> *> (out.additional_outputs[k].get());
+
+            if (result)
+              {
+                std::vector<std::string> names = result->get_names();
+
+                for (const auto &name : names)
+                  property_names.push_back(name);
+              }
+          }
+
+        AssertThrow(property_names.size() > 0,
+                    ExcMessage("You activated the postprocessor <named additional outputs>, but none of the additional outputs "
+                               "provided by the material model are named outputs. Either remove the postprocessor, or check why no "
+                               "named output is provided."));
+
+        for (auto &property_name : property_names)
+          std::replace(property_name.begin(),property_name.end(),' ', '_');
+      }
+
+
+
+      template <int dim>
+      std::vector<std::string>
+      NamedAdditionalOutputs<dim>::
+      get_names () const
+      {
+        return property_names;
+      }
+
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      NamedAdditionalOutputs<dim>::
+      get_data_component_interpretation () const
+      {
+        return std::vector<DataComponentInterpretation::DataComponentInterpretation> (get_names().size(),
+                                                                                      DataComponentInterpretation::component_is_scalar);
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      NamedAdditionalOutputs<dim>::
+      get_needed_update_flags () const
+      {
+        return update_gradients | update_values  | update_quadrature_points;
+      }
+
+
+
+      template <int dim>
+      void
+      NamedAdditionalOutputs<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,
+                ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,
+                ExcInternalError());
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+
+        this->get_material_model().create_additional_named_outputs(out);
+        this->get_material_model().evaluate(in, out);
+
+        unsigned int field_index = 0;
+        for (unsigned int k=0; k<out.additional_outputs.size(); ++k)
+          {
+            const MaterialModel::NamedAdditionalMaterialOutputs<dim> *result
+              = dynamic_cast<const MaterialModel::NamedAdditionalMaterialOutputs<dim> *> (out.additional_outputs[k].get());
+
+            if (result)
+              {
+                std::vector<double> outputs(n_quadrature_points);
+                for (unsigned int i=0; i<result->get_names().size(); ++i, ++field_index)
+                  {
+                    outputs = result->get_nth_output(i);
+
+                    for (unsigned int q=0; q<n_quadrature_points; ++q)
+                      computed_quantities[q][field_index] = outputs[q];
+                  }
+              }
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(NamedAdditionalOutputs,
+                                                  "named additional outputs",
+                                                  "Some material models can compute quantities other than those "
+                                                  "that typically appear in the equations that \\aspect{} solves "
+                                                  "(such as the viscosity, density, etc). Examples of quantities "
+                                                  "material models may be able to compute are seismic velocities, "
+                                                  "or other quantities that can be derived from the state variables "
+                                                  "and the material coefficients such as the stress or stress "
+                                                  "anisotropies. These quantities are generically referred to as "
+                                                  "`named outputs' because they are given an explicit name different "
+                                                  "from the usual outputs of material models.\n\n"
+                                                  "This visualization postprocessor outputs whatever quantities the "
+                                                  "material model can compute. What quantities these are is specific "
+                                                  "to the material model in use for a simulation, and for many models "
+                                                  "in fact does not contain any named outputs at all."
+                                                  "\n\n"
+                                                  "Physical units: Various, depending on what is being output.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/nonadiabatic_pressure.cc.bak b/source/postprocess/visualization/nonadiabatic_pressure.cc.bak
new file mode 100644
index 00000000000..2b1ddce0b3d
--- /dev/null
+++ b/source/postprocess/visualization/nonadiabatic_pressure.cc.bak
@@ -0,0 +1,91 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/nonadiabatic_pressure.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      NonadiabaticPressure<dim>::
+      NonadiabaticPressure ()
+        :
+        DataPostprocessorScalar<dim> ("nonadiabatic_pressure",
+                                      update_values | update_quadrature_points),
+        Interface<dim>("Pa")
+      {}
+
+
+
+      template <int dim>
+      void
+      NonadiabaticPressure<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            const double pressure    = input_data.solution_values[q][this->introspection().component_indices.pressure];
+
+            computed_quantities[q](0) = pressure - this->get_adiabatic_conditions().pressure(input_data.evaluation_points[q]);
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(NonadiabaticPressure,
+                                                  "nonadiabatic pressure",
+                                                  "A visualization output object that generates output "
+                                                  "for the non-adiabatic component of the pressure."
+                                                  "\n\n"
+                                                  "The variable that is outputted this way is computed by "
+                                                  "taking the pressure at each point and subtracting "
+                                                  "from it the adiabatic pressure computed at the beginning "
+                                                  "of the simulation. Because the adiabatic pressure is "
+                                                  "one way of defining a static pressure background field, "
+                                                  "what this visualization postprocessor therefore produces is "
+                                                  "\\textit{one} way to compute a \\textit{dynamic "
+                                                  "pressure}. There are, however, other ways as well, "
+                                                  "depending on the choice of the ``background pressure''."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\pascal}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/nonadiabatic_temperature.cc.bak b/source/postprocess/visualization/nonadiabatic_temperature.cc.bak
new file mode 100644
index 00000000000..5453645b5f2
--- /dev/null
+++ b/source/postprocess/visualization/nonadiabatic_temperature.cc.bak
@@ -0,0 +1,81 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/nonadiabatic_temperature.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      NonadiabaticTemperature<dim>::
+      NonadiabaticTemperature ()
+        :
+        DataPostprocessorScalar<dim> ("nonadiabatic_temperature",
+                                      update_values | update_quadrature_points),
+        Interface<dim>("K")
+      {}
+
+
+
+      template <int dim>
+      void
+      NonadiabaticTemperature<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            const double temperature = input_data.solution_values[q][this->introspection().component_indices.temperature];
+
+            computed_quantities[q](0) = temperature - this->get_adiabatic_conditions().temperature(input_data.evaluation_points[q]);
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(NonadiabaticTemperature,
+                                                  "nonadiabatic temperature",
+                                                  "A visualization output object that generates output "
+                                                  "for the non-adiabatic component of the temperature."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\kelvin}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/particle_count.cc.bak b/source/postprocess/visualization/particle_count.cc.bak
new file mode 100644
index 00000000000..f84d67b7386
--- /dev/null
+++ b/source/postprocess/visualization/particle_count.cc.bak
@@ -0,0 +1,90 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/particle_count.h>
+#include <aspect/particle/world.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      ParticleCount<dim>::
+      ParticleCount ()
+        :
+        CellDataVectorCreator<dim>("")  // no physical units
+      {}
+
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      ParticleCount<dim>::execute() const
+      {
+        const Particle::ParticleHandler<dim> &particle_handler =
+          this->get_particle_world(0).get_particle_handler();
+
+        std::pair<std::string, std::unique_ptr<Vector<float>>>
+        return_value ("particles_per_cell",
+                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+
+        // loop over all of the cells and count particles in them
+        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              (*return_value.second)(cell->active_cell_index()) = static_cast<float> (particle_handler.n_particles_in_cell(cell));
+            }
+
+        return return_value;
+      }
+
+
+
+      template <int dim>
+      std::list<std::string>
+      ParticleCount<dim>::required_other_postprocessors() const
+      {
+        return {"particles"};
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ParticleCount,
+                                                  "particle count",
+                                                  "A visualization output object that generates output "
+                                                  "about the number of particles per cell."
+                                                  "\n\n"
+                                                  "Physical units: None.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/partition.cc.bak b/source/postprocess/visualization/partition.cc.bak
new file mode 100644
index 00000000000..21986d38f4e
--- /dev/null
+++ b/source/postprocess/visualization/partition.cc.bak
@@ -0,0 +1,81 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/partition.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      Partition<dim>::
+      Partition ()
+        :
+        // we don't need to know about any of the solution values
+        // in order to determine the partition number. thus, no
+        // need to specify any update flags
+        DataPostprocessorScalar<dim> ("partition",
+                                      update_default),
+        Interface<dim>("")  // no physical units
+      {}
+
+
+
+      template <int dim>
+      void
+      Partition<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &/*input_data*/,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        Assert (computed_quantities[0].size() == 1, ExcInternalError());
+
+        for (auto &quantity : computed_quantities)
+          {
+            // simply get the partition number from the triangulation
+            quantity(0) = this->get_triangulation().locally_owned_subdomain();
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Partition,
+                                                  "partition",
+                                                  "A visualization output object that generates output "
+                                                  "for the parallel partition that every cell of the "
+                                                  "mesh is associated with."
+                                                  "\n\n"
+                                                  "Physical units: None.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/principal_stress.cc.bak b/source/postprocess/visualization/principal_stress.cc.bak
new file mode 100644
index 00000000000..9dcc46507c7
--- /dev/null
+++ b/source/postprocess/visualization/principal_stress.cc.bak
@@ -0,0 +1,242 @@
+/*
+  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/postprocess/visualization/principal_stress.h>
+
+#include <deal.II/base/symmetric_tensor.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      PrincipalStress<dim>::
+      PrincipalStress ()
+        :
+        DataPostprocessor<dim> (),
+        Interface<dim>("Pa")
+      {}
+
+
+
+      template <int dim>
+      std::vector<std::string>
+      PrincipalStress<dim>::
+      get_names () const
+      {
+        std::vector<std::string> solution_names;
+
+        // dim principal stress values
+        for (unsigned int i=0; i<dim; ++i)
+          solution_names.push_back("principal_stress_" + std::to_string(i+1));
+
+        // dim principal stress directions
+        for (unsigned int i=0; i<dim; ++i)
+          for (unsigned int j=0; j<dim; ++j)
+            solution_names.push_back("principal_stress_direction_" + std::to_string(i+1));
+
+        return solution_names;
+      }
+
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      PrincipalStress<dim>::
+      get_data_component_interpretation () const
+      {
+        std::vector<DataComponentInterpretation::DataComponentInterpretation> solution_components;
+
+        // dim principal stress values
+        for (unsigned int i=0; i<dim; ++i)
+          solution_components.push_back(DataComponentInterpretation::component_is_scalar);
+
+        // dim principal stress directions
+        for (unsigned int i=0; i<dim; ++i)
+          for (unsigned int j=0; j<dim; ++j)
+            solution_components.push_back(DataComponentInterpretation::component_is_part_of_vector);
+
+        return solution_components;
+      }
+
+
+
+      template <int dim>
+      UpdateFlags
+      PrincipalStress<dim>::
+      get_needed_update_flags () const
+      {
+        return update_values | update_gradients | update_quadrature_points;
+      }
+
+
+
+      template <int dim>
+      void
+      PrincipalStress<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError());
+        Assert (computed_quantities[0].size() == dim*dim + dim, ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+
+        // We do not need to compute anything but the viscosity
+        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+        // Compute the viscosity...
+        this->get_material_model().evaluate(in, out);
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            SymmetricTensor<2,dim> stress;
+
+            // Add elastic stresses if existent
+            if (this->get_parameters().enable_elasticity == false)
+              {
+                const SymmetricTensor<2,dim> deviatoric_strain_rate
+                  = (this->get_material_model().is_compressible()
+                     ?
+                     in.strain_rate[q] - 1./3. * trace(in.strain_rate[q]) * unit_symmetric_tensor<dim>()
+                     :
+                     in.strain_rate[q]);
+
+                // Compressive stress is positive in geoscience applications
+                stress = -2. * out.viscosities[q] * deviatoric_strain_rate;
+              }
+            else
+              {
+                // Compressive stress is positive in geoscience applications
+                stress[0][0] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
+                stress[1][1] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
+                stress[0][1] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
+
+                if (dim == 3)
+                  {
+                    stress[2][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
+                    stress[0][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
+                    stress[1][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
+                  }
+              }
+
+
+            if (use_deviatoric_stress == false)
+              stress += in.pressure[q] * unit_symmetric_tensor<dim>();
+
+            const std::array<std::pair<double, Tensor<1,dim>>, dim> principal_stresses_and_directions = eigenvectors(stress);
+
+            // dim principal stress values
+            for (unsigned int i=0; i<dim; ++i)
+              computed_quantities[q][i] = principal_stresses_and_directions[i].first;
+
+            // dim principal stress directions
+            for (unsigned int i=0; i<dim; ++i)
+              for (unsigned int j=0; j<dim; ++j)
+                computed_quantities[q][dim + i*dim + j] = principal_stresses_and_directions[i].second[j];
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      PrincipalStress<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Principal stress");
+            {
+              prm.declare_entry("Use deviatoric stress", "false",
+                                Patterns::Bool(),
+                                "Whether to use the deviatoric stress tensor "
+                                "instead of the full stress tensor to compute "
+                                "principal stress directions and values.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      PrincipalStress<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Principal stress");
+            {
+              use_deviatoric_stress = prm.get_bool("Use deviatoric stress");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(PrincipalStress,
+                                                  "principal stress",
+                                                  "A visualization output object that outputs the "
+                                                  "principal stresses and directions, i.e., the "
+                                                  "eigenvalues and eigenvectors of the stress tensor. "
+                                                  "Wikipedia defines principal stresses as follows: "
+                                                  "At every point in a stressed body there are at least "
+                                                  "three planes, called principal planes, with normal "
+                                                  "vectors, called principal directions, where the "
+                                                  "corresponding stress vector is perpendicular to the "
+                                                  "plane, and where there are no normal "
+                                                  "shear stresses. The three stresses normal to these "
+                                                  "principal planes are called principal stresses. "
+                                                  "This postprocessor can either operate on the full "
+                                                  "stress tensor or only on the deviatoric stress tensor, "
+                                                  "depending on what run-time parameters are set."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\pascal}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/seismic_anomalies.cc.bak b/source/postprocess/visualization/seismic_anomalies.cc.bak
new file mode 100644
index 00000000000..b60be579379
--- /dev/null
+++ b/source/postprocess/visualization/seismic_anomalies.cc.bak
@@ -0,0 +1,566 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/seismic_anomalies.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/lateral_averaging.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      SeismicVsAnomaly<dim>::
+      SeismicVsAnomaly ()
+        :
+        CellDataVectorCreator<dim>("")  // no physical units
+      {}
+
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      SeismicVsAnomaly<dim>::execute() const
+      {
+        std::pair<std::string, std::unique_ptr<Vector<float>>>
+        return_value ("Vs_anomaly",
+                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+
+        // Calculate the maximum depth of the domain
+        const double max_depth = this->get_geometry_model().maximal_depth();
+
+        // The following lines evaluate the Vs at a single point per cell
+        // and then compute the percentage deviation from the average in
+        // the slice within which the point lies
+        const QMidpoint<dim> quadrature_formula;
+        const unsigned int n_q_points = quadrature_formula.size();
+
+        FEValues<dim> fe_values (this->get_mapping(),
+                                 this->get_fe(),
+                                 quadrature_formula,
+                                 update_values   |
+                                 update_gradients |
+                                 update_quadrature_points );
+
+        MaterialModel::MaterialModelInputs<dim> in(n_q_points, this->n_compositional_fields());
+        MaterialModel::MaterialModelOutputs<dim> out(n_q_points, this->n_compositional_fields());
+        in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
+
+        std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+
+        switch (average_velocity_scheme)
+          {
+            case reference_profile:
+            {
+              MaterialModel::MaterialModelOutputs<dim> adiabatic_out(n_q_points, this->n_compositional_fields());
+
+              // Loop over the cells
+              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+                if (cell->is_locally_owned())
+                  {
+                    // Get the pressure, temperature and composition in the cell
+                    fe_values.reinit (cell);
+
+                    in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+                    out.additional_outputs.push_back(
+                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
+                    this->get_material_model().evaluate(in, out);
+
+
+
+                    // Substitute the adiabatic reference state for temperature and pressure,
+                    // then reevaluate the material model.
+                    in.temperature[0]=this->get_adiabatic_conditions().temperature(in.position[0]);
+                    in.pressure[0]=this->get_adiabatic_conditions().pressure(in.position[0]);
+
+                    adiabatic_out.additional_outputs.push_back(
+                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
+                    this->get_material_model().evaluate(in, adiabatic_out);
+
+
+
+                    MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
+                      = out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
+                    const double Vs = seismic_outputs->vs[0];
+
+                    MaterialModel::SeismicAdditionalOutputs<dim> *adiabatic_seismic_outputs
+                      = adiabatic_out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
+                    const double adiabatic_Vs = adiabatic_seismic_outputs->vs[0];
+
+                    // Compute the percentage deviation from the average
+                    (*return_value.second)(cell->active_cell_index()) = (Vs - adiabatic_Vs)/adiabatic_Vs*1e2;
+                  }
+              break;
+            }
+
+            case lateral_average:
+            {
+              // Calculate the Vs averages within n slices
+              std::vector<double> Vs_depth_average(n_slices);
+              this->get_lateral_averaging().get_Vs_averages(Vs_depth_average);
+
+              // Estimates of the lateral Vs average at each depth are required
+              // for all cell depths, including those
+              // shallower than the midpoint of the first slice or
+              // deeper than the midpoint of the last slice.
+              // For this reason, the vector of Vs averages need to be padded by
+              // one element before the first element and after the last element.
+              // Mirror padding is chosen as it provides the least biased estimator
+              // (in the absence of further information).
+              std::vector<double> padded_Vs_depth_average(n_slices+2);
+              padded_Vs_depth_average[0] = 2.*Vs_depth_average[0] - Vs_depth_average[1];
+              padded_Vs_depth_average[n_slices+1] = 2.*Vs_depth_average[n_slices-1] - Vs_depth_average[n_slices-2];
+              std::copy ( Vs_depth_average.begin(), Vs_depth_average.end(), padded_Vs_depth_average.begin() + 1 );
+
+              // Loop over the cells
+              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+                if (cell->is_locally_owned())
+                  {
+                    // Get the pressure, temperature and composition in the cell
+                    fe_values.reinit (cell);
+
+                    in.reinit (fe_values, cell, this->introspection(), this->get_solution());
+
+                    out.additional_outputs.push_back(
+                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
+                    this->get_material_model().evaluate(in, out);
+
+                    MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
+                      = out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
+                    const double Vs = seismic_outputs->vs[0];
+
+                    // Find the depth of the zeroth quadrature point in the cell and work out
+                    // the depth slice which has its center just above that point
+                    const double depth = this->get_geometry_model().depth(fe_values.quadrature_point(0));
+
+                    // Please note: static_cast<int> always truncates the double (i.e. 1.9 -> 1)
+                    // Here we subtract 0.5 to find the first slice with its center shallower than the cell,
+                    // and add 1 to take padding into account (-0.5 + 1.0 = +0.5)
+                    const double slice_depth = (depth*n_slices)/max_depth + 0.5;
+                    const unsigned int idx = static_cast<unsigned int>(slice_depth);
+                    const double fractional_slice = slice_depth - static_cast<double>(idx);
+                    Assert(idx<n_slices+1, ExcInternalError());
+
+                    // Compute the percentage deviation from the average
+                    const double Vs_average = (1. - fractional_slice)*padded_Vs_depth_average[idx] + fractional_slice*padded_Vs_depth_average[idx+1];
+                    (*return_value.second)(cell->active_cell_index()) = (Vs - Vs_average)/Vs_average * 100 /* per cent */;
+                  }
+              break;
+            }
+          }
+        return return_value;
+      }
+
+
+      template <int dim>
+      SeismicVpAnomaly<dim>::
+      SeismicVpAnomaly ()
+        :
+        CellDataVectorCreator<dim>("")   // no physical units
+      {}
+
+
+
+      template <int dim>
+      std::pair<std::string, std::unique_ptr<Vector<float>>>
+      SeismicVpAnomaly<dim>::execute() const
+      {
+        std::pair<std::string, std::unique_ptr<Vector<float>>>
+        return_value ("Vp_anomaly",
+                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
+
+        // Calculate the maximum depth of the domain
+        const double max_depth = this->get_geometry_model().maximal_depth();
+
+        // The following lines evaluate the Vp at a single point per cell
+        // and then compute the percentage deviation from the average in
+        // the slice within which the point lies
+        const QMidpoint<dim> quadrature_formula;
+        const unsigned int n_q_points = quadrature_formula.size();
+
+        FEValues<dim> fe_values (this->get_mapping(),
+                                 this->get_fe(),
+                                 quadrature_formula,
+                                 update_values   |
+                                 update_gradients |
+                                 update_quadrature_points );
+
+        MaterialModel::MaterialModelInputs<dim> in(n_q_points, this->n_compositional_fields());
+        MaterialModel::MaterialModelOutputs<dim> out(n_q_points, this->n_compositional_fields());
+        in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
+
+        std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+
+        switch (average_velocity_scheme)
+          {
+            case reference_profile:
+            {
+              MaterialModel::MaterialModelOutputs<dim> adiabatic_out(n_q_points, this->n_compositional_fields());
+
+              // Loop over the cells
+              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+                if (cell->is_locally_owned())
+                  {
+                    // Get the pressure, temperature and composition in the cell
+                    fe_values.reinit (cell);
+
+                    in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+                    out.additional_outputs.push_back(
+                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>>(n_q_points));
+                    this->get_material_model().evaluate(in, out);
+
+                    // Substitute the adiabatic reference state for temperature and pressure,
+                    // then reevaluate the material model.
+                    in.temperature[0]=this->get_adiabatic_conditions().temperature(in.position[0]);
+                    in.pressure[0]=this->get_adiabatic_conditions().pressure(in.position[0]);
+
+                    adiabatic_out.additional_outputs.push_back(
+                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
+                    this->get_material_model().evaluate(in, adiabatic_out);
+
+
+
+                    MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
+                      = out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
+                    const double Vp = seismic_outputs->vp[0];
+
+                    MaterialModel::SeismicAdditionalOutputs<dim> *adiabatic_seismic_outputs
+                      = adiabatic_out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
+                    const double adiabatic_Vp = adiabatic_seismic_outputs->vp[0];
+
+                    // Compute the percentage deviation from the average
+                    (*return_value.second)(cell->active_cell_index()) = (Vp - adiabatic_Vp)/adiabatic_Vp * 100 /* per cent */;
+                  }
+              break;
+            }
+
+            case lateral_average:
+            {
+              // Calculate the Vp averages within n slices
+              std::vector<double> Vp_depth_average(n_slices);
+              this->get_lateral_averaging().get_Vp_averages(Vp_depth_average);
+
+              // Estimates of the lateral Vp average at each depth are required
+              // for all cell depths, including those
+              // shallower than the midpoint of the first slice or
+              // deeper than the midpoint of the last slice.
+              // For this reason, the vector of Vp averages need to be padded by
+              // one element before the first element and after the last element.
+              // Mirror padding is chosen as it provides the least biased estimator
+              // (in the absence of further information).
+              std::vector<double> padded_Vp_depth_average(n_slices+2);
+              padded_Vp_depth_average[0] = 2.*Vp_depth_average[0] - Vp_depth_average[1];
+              padded_Vp_depth_average[n_slices+1] = 2.*Vp_depth_average[n_slices-1] - Vp_depth_average[n_slices-2];
+              std::copy ( Vp_depth_average.begin(), Vp_depth_average.end(), padded_Vp_depth_average.begin() + 1 );
+
+
+              // Loop over the cells
+              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+                if (cell->is_locally_owned())
+                  {
+                    // Get the pressure, temperature and composition in the cell
+                    fe_values.reinit (cell);
+
+                    // get the various components of the solution, then
+                    // evaluate the material properties there
+                    fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
+                                                                                                 in.temperature);
+                    fe_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
+                                                                                              in.pressure);
+                    fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                                                                                                in.velocity);
+                    fe_values[this->introspection().extractors.pressure].get_function_gradients (this->get_solution(),
+                                                                                                 in.pressure_gradient);
+                    in.position = fe_values.get_quadrature_points();
+
+                    // Loop over compositional fields to get composition values
+                    for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                      fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
+                          composition_values[c]);
+                    for (unsigned int i=0; i<fe_values.n_quadrature_points; ++i)
+                      {
+                        for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                          in.composition[i][c] = composition_values[c][i];
+                      }
+                    in.current_cell = cell;
+
+                    out.additional_outputs.push_back(
+                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
+                    this->get_material_model().evaluate(in, out);
+
+                    MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
+                      = out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
+                    const double Vp = seismic_outputs->vs[0];
+
+                    // Find the depth of the zeroth quadrature point in the cell and work out
+                    // the depth slice which has its center just above that point
+                    const double depth = this->get_geometry_model().depth(fe_values.quadrature_point(0));
+
+                    // Please note: static_cast<int> always truncates the double (i.e. 1.9 -> 1)
+                    // Here we subtract 0.5 to find the first slice with its center shallower than the cell,
+                    // and add 1 to take padding into account (-0.5 + 1.0 = +0.5)
+                    const double slice_depth = (depth*n_slices)/max_depth + 0.5;
+                    const unsigned int idx = static_cast<unsigned int>(slice_depth);
+                    const double fractional_slice = slice_depth - static_cast<double>(idx);
+                    Assert(idx<n_slices+1, ExcInternalError());
+
+                    // Compute the percentage deviation from the average
+                    const double Vp_average = (1. - fractional_slice)*padded_Vp_depth_average[idx] + fractional_slice*padded_Vp_depth_average[idx+1];
+                    (*return_value.second)(cell->active_cell_index()) = (Vp - Vp_average)/Vp_average*1e2;
+                  }
+              break;
+            }
+          }
+
+        return return_value;
+      }
+
+
+
+      template <int dim>
+      void
+      SeismicVsAnomaly<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Vs anomaly");
+            {
+
+              prm.declare_entry ("Average velocity scheme", "reference profile",
+                                 Patterns::Selection("reference profile|lateral average"),
+                                 "Scheme to compute the average velocity-depth "
+                                 "profile. The reference profile option evaluates "
+                                 "the conditions along the reference adiabat "
+                                 "according to the material model. "
+                                 "The lateral average option instead calculates "
+                                 "a lateral average from subdivision of the mesh. "
+                                 "The lateral average option may produce spurious "
+                                 "results where there are sharp velocity changes.");
+
+              prm.declare_entry ("Number of depth slices", "50",
+                                 Patterns::Integer (1),
+                                 "Number of depth slices used to define "
+                                 "average seismic shear wave velocities "
+                                 "from which anomalies are calculated. "
+                                 "Units: non-dimensional.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      SeismicVsAnomaly<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        // First make sure the material model actually provides seismic velocities
+        MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
+        this->get_material_model().create_additional_named_outputs(out);
+
+        const bool material_model_provides_seismic_output =
+          (out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>() != nullptr);
+
+        AssertThrow(material_model_provides_seismic_output,
+                    ExcMessage("You requested the 'Vs anomaly' postprocessor, "
+                               "but the material model does not provide seismic velocities. Either remove 'Vs anomaly', "
+                               "or use a material model that provides these velocities."));
+
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Vs anomaly");
+            {
+              // Average velocity scheme
+              if (prm.get ("Average velocity scheme") == "reference profile")
+                average_velocity_scheme = reference_profile;
+              else if (prm.get ("Average velocity scheme") == "lateral average")
+                average_velocity_scheme = lateral_average;
+              else
+                AssertThrow(false, ExcMessage("Not a valid average velocity scheme."));
+
+              n_slices = prm.get_integer ("Number of depth slices");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      SeismicVpAnomaly<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Vp anomaly");
+            {
+
+              prm.declare_entry ("Average velocity scheme", "reference profile",
+                                 Patterns::Selection("reference profile|lateral average"),
+                                 "Scheme to compute the average velocity-depth "
+                                 "profile. The reference profile option evaluates "
+                                 "the conditions along the reference adiabat "
+                                 "according to the material model. "
+                                 "The lateral average option instead calculates "
+                                 "a lateral average from subdivision of the mesh. "
+                                 "The lateral average option may produce spurious "
+                                 "results where there are sharp velocity changes.");
+
+              prm.declare_entry ("Number of depth slices", "50",
+                                 Patterns::Integer (1),
+                                 "Number of depth slices used to define "
+                                 "average seismic compressional wave velocities "
+                                 "from which anomalies are calculated. "
+                                 "Units: non-dimensional.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      SeismicVpAnomaly<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        // First make sure the material model actually provides seismic velocities
+        MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
+        this->get_material_model().create_additional_named_outputs(out);
+
+        const bool material_model_provides_seismic_output =
+          (out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>() != nullptr);
+
+        AssertThrow(material_model_provides_seismic_output,
+                    ExcMessage("You requested the 'Vp anomaly' postprocessor, "
+                               "but the material model does not provide seismic velocities. Either remove 'Vp anomaly', "
+                               "or use a material model that provides these velocities."));
+
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Vp anomaly");
+            {
+              // Average velocity scheme
+              if (prm.get ("Average velocity scheme") == "reference profile")
+                average_velocity_scheme = reference_profile;
+              else if (prm.get ("Average velocity scheme") == "lateral average")
+                average_velocity_scheme = lateral_average;
+              else
+                AssertThrow(false, ExcMessage("Not a valid average velocity scheme."));
+
+              n_slices = prm.get_integer ("Number of depth slices");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SeismicVsAnomaly,
+                                                  "Vs anomaly",
+                                                  "A visualization output object that generates output "
+                                                  "showing the percentage anomaly in the seismic "
+                                                  "shear wave speed $V_s$ as a spatially variable "
+                                                  "function with one value per cell. This anomaly is either "
+                                                  "shown as a percentage anomaly relative to the reference "
+                                                  "profile given by adiabatic conditions (with the "
+                                                  "compositions given by the current composition, such that "
+                                                  "the reference could potentially change through time), or "
+                                                  "as a percentage change relative to the laterally averaged "
+                                                  "velocity at the depth of the cell. This velocity is "
+                                                  "calculated by linear interpolation between average values "
+                                                  "calculated within equally thick depth slices. The "
+                                                  "number of depth slices in the domain is user-defined. "
+                                                  "Typically, the best results will be obtained if the number "
+                                                  "of depth slices is balanced between being large enough to "
+                                                  "capture step changes in velocities, but small enough to "
+                                                  "maintain a reasonable number of evaluation points per slice. "
+                                                  "Bear in mind that lateral averaging subsamples the "
+                                                  "finite element mesh. Note that this plugin requires a "
+                                                  "material model that provides seismic velocities."
+                                                  "\n\n"
+                                                  "Physical units: None, the quantity being output is a "
+                                                  "fractional change provided as a percentage.")
+
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SeismicVpAnomaly,
+                                                  "Vp anomaly",
+                                                  "A visualization output object that generates output "
+                                                  "showing the percentage anomaly in the seismic "
+                                                  "compressional wave speed $V_p$ as a spatially variable "
+                                                  "function with one value per cell. This anomaly is either "
+                                                  "shown as a percentage anomaly relative to the reference "
+                                                  "profile given by adiabatic conditions (with the "
+                                                  "compositions given by the current composition, such that "
+                                                  "the reference could potentially change through time), or "
+                                                  "as a percentage change relative to the laterally averaged "
+                                                  "velocity at the depth of the cell. This velocity is "
+                                                  "calculated by linear interpolation between average values "
+                                                  "calculated within equally thick depth slices. The "
+                                                  "number of depth slices in the domain is user-defined. "
+                                                  "Typically, the best results will be obtained if the number "
+                                                  "of depth slices is balanced between being large enough to "
+                                                  "capture step changes in velocities, but small enough to "
+                                                  "maintain a reasonable number of evaluation points per slice. "
+                                                  "Bear in mind that lateral averaging subsamples the "
+                                                  "finite element mesh. Note that this plugin requires a "
+                                                  "material model that provides seismic velocities."
+                                                  "\n\n"
+                                                  "Physical units: None, the quantity being output is a "
+                                                  "fractional change provided as a percentage.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/shear_stress.cc.bak b/source/postprocess/visualization/shear_stress.cc.bak
new file mode 100644
index 00000000000..49f0f54ce42
--- /dev/null
+++ b/source/postprocess/visualization/shear_stress.cc.bak
@@ -0,0 +1,148 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/shear_stress.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      ShearStress<dim>::
+      ShearStress ()
+        :
+        DataPostprocessorTensor<dim> ("shear_stress",
+                                      update_values | update_gradients | update_quadrature_points),
+        Interface<dim>("Pa")
+      {}
+
+
+
+      template <int dim>
+      void
+      ShearStress<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
+                ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+
+        // We do not need to compute anything but the viscosity
+        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+        // Compute the viscosity...
+        this->get_material_model().evaluate(in, out);
+
+        // ...and use it to compute the stresses
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            // Compressive stress is negative by the sign convention
+            // used by the engineering community, and as input and used
+            // internally by ASPECT.
+            // Here, we change the sign of the stress to match the
+            // sign convention used by the geoscience community.
+            SymmetricTensor<2,dim> shear_stress;
+
+            // If elasticity is enabled, the deviatoric stress is stored
+            // in compositional fields, otherwise the deviatoric stress
+            // can be obtained from the viscosity and strain rate.
+            if (this->get_parameters().enable_elasticity == true)
+              {
+                shear_stress[0][0] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
+                shear_stress[1][1] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
+                shear_stress[0][1] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
+
+                if (dim == 3)
+                  {
+                    shear_stress[2][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
+                    shear_stress[0][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
+                    shear_stress[1][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
+                  }
+              }
+            else
+              {
+                const SymmetricTensor<2,dim> strain_rate = in.strain_rate[q];
+                const SymmetricTensor<2,dim> deviatoric_strain_rate
+                  = (this->get_material_model().is_compressible()
+                     ?
+                     strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
+                     :
+                     strain_rate);
+
+                const double eta = out.viscosities[q];
+                shear_stress = -2. * eta * deviatoric_strain_rate;
+              }
+
+            for (unsigned int d=0; d<dim; ++d)
+              for (unsigned int e=0; e<dim; ++e)
+                computed_quantities[q][Tensor<2,dim>::component_to_unrolled_index(TableIndices<2>(d,e))]
+                  = shear_stress[d][e];
+          }
+
+        // average the values if requested
+        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
+        if (!viz.output_pointwise_stress_and_strain())
+          average_quantities(computed_quantities);
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ShearStress,
+                                                  "shear stress",
+                                                  "A visualization output object that generates output "
+                                                  "for the 3 (in 2d) or 6 (in 3d) components of the shear stress "
+                                                  "tensor, i.e., for the components of the tensor "
+                                                  "$-2\\eta\\varepsilon(\\mathbf u)$ "
+                                                  "in the incompressible case and "
+                                                  "$-2\\eta\\left[\\varepsilon(\\mathbf u)-"
+                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I\\right]$ "
+                                                  "in the compressible case. If elasticity is used, the "
+                                                  "elastic contribution is being accounted for. The shear "
+                                                  "stress differs from the full stress tensor "
+                                                  "by the absence of the pressure. Note that the convention "
+                                                  "of positive compressive stress is followed."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\pascal}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/spd_factor.cc.bak b/source/postprocess/visualization/spd_factor.cc.bak
new file mode 100644
index 00000000000..85a153d00af
--- /dev/null
+++ b/source/postprocess/visualization/spd_factor.cc.bak
@@ -0,0 +1,109 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/spd_factor.h>
+#include <aspect/newton.h>
+#include <aspect/utilities.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      SPD_Factor<dim>::
+      SPD_Factor ()
+        :
+        DataPostprocessorScalar<dim> ("spd_factor",
+                                      update_values | update_gradients | update_quadrature_points),
+        Interface<dim>("")  // no physical units
+      {}
+
+
+
+      template <int dim>
+      void
+      SPD_Factor<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,                             ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,                                            ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,    ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+        in.requested_properties = MaterialModel::MaterialProperties::viscosity | MaterialModel::MaterialProperties::additional_outputs;
+
+        out.additional_outputs.push_back(
+          std::make_unique<MaterialModel::MaterialModelDerivatives<dim>> (n_quadrature_points));
+
+        this->get_material_model().evaluate(in, out);
+
+        const MaterialModel::MaterialModelDerivatives<dim> *derivatives = out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            computed_quantities[q](0) = Utilities::compute_spd_factor<dim>(out.viscosities[q],
+                                                                           in.strain_rate[q],
+                                                                           derivatives->viscosity_derivative_wrt_strain_rate[q],
+                                                                           this->get_newton_handler().parameters.SPD_safety_factor);
+          }
+      }
+
+      template <int dim>
+      void
+      SPD_Factor<dim>::parse_parameters (ParameterHandler &/*prm*/)
+      {
+        AssertThrow(Parameters<dim>::is_defect_correction(this->get_parameters().nonlinear_solver),
+                    ExcMessage("The SPD factor plugin can only be used with defect correction type Stokes or Newton Stokes "
+                               "solvers."));
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SPD_Factor,
+                                                  "spd factor",
+                                                  "A visualization output object that generates output "
+                                                  "for the spd factor. The spd factor is a factor which "
+                                                  "scales a part of the Jacobian used for the Newton solver "
+                                                  "to make sure that the Jacobian remains positive definite."
+                                                  "\n\n"
+                                                  "Physical units: None.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/spherical_velocity_components.cc.bak b/source/postprocess/visualization/spherical_velocity_components.cc.bak
new file mode 100644
index 00000000000..8ab0c707a44
--- /dev/null
+++ b/source/postprocess/visualization/spherical_velocity_components.cc.bak
@@ -0,0 +1,145 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/spherical_velocity_components.h>
+#include <aspect/utilities.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      SphericalVelocityComponents<dim>::
+      SphericalVelocityComponents ()
+        :
+        DataPostprocessorVector<dim> ("spherical_velocity_components",
+                                      update_values | update_quadrature_points),
+        Interface<dim>()    // unknown units at construction time, will be filled by a separate function
+      {}
+
+
+
+      template <int dim>
+      std::string
+      SphericalVelocityComponents<dim>::
+      get_physical_units () const
+      {
+        if (this->convert_output_to_years())
+          return "m/year";
+        else
+          return "m/s";
+      }
+
+
+
+      template <int dim>
+      void
+      SphericalVelocityComponents<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.evaluation_points.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == dim,    ExcInternalError());
+
+        const double velocity_scaling_factor =
+          this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+        Tensor<1,dim> velocity;
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            for (unsigned int d = 0; d < dim; ++d)
+              {
+                velocity[d] = input_data.solution_values[q][this->introspection().component_indices.velocities[d]] * velocity_scaling_factor;
+              }
+
+            std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(input_data.evaluation_points[q]);
+
+            if (dim==2)
+              {
+                computed_quantities[q](0) =  std::cos(scoord[1])*velocity[0]+std::sin(scoord[1])*velocity[1]; // v_r
+                computed_quantities[q](1) = -std::sin(scoord[1])*velocity[0]+std::cos(scoord[1])*velocity[1]; // v_scoord[1]
+              }
+
+            if (dim==3)
+              {
+                computed_quantities[q](0) = velocity[0]*(std::sin(scoord[2])*std::cos(scoord[1]))
+                                            + velocity[1]*(std::sin(scoord[2])*std::sin(scoord[1]))
+                                            + velocity[2]*(std::cos(scoord[2]));                // v_r
+                computed_quantities[q](1) = velocity[0]*(-std::sin(scoord[1]))
+                                            + velocity[1]*(std::cos(scoord[1]));                // v_phi
+                computed_quantities[q](2) = velocity[0]*(std::cos(scoord[2])*std::cos(scoord[1]))
+                                            + velocity[1]*(std::cos(scoord[2])*std::sin(scoord[1]))
+                                            + velocity[2]*(-std::sin(scoord[2]));               // v_theta
+              }
+          }
+      }
+
+
+      template <int dim>
+      std::vector<std::string>
+      SphericalVelocityComponents<dim>::get_names () const
+      {
+        std::vector<std::string> names;
+        names.emplace_back("v_r");
+        names.emplace_back("v_phi");
+        if (dim==3)
+          names.emplace_back("v_theta");
+        return names;
+      }
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      SphericalVelocityComponents<dim>::get_data_component_interpretation () const
+      {
+        return
+          std::vector<DataComponentInterpretation::DataComponentInterpretation>
+          (dim,DataComponentInterpretation::component_is_scalar);
+      }
+
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SphericalVelocityComponents,
+                                                  "spherical velocity components",
+                                                  "A visualization output object that outputs the polar coordinates "
+                                                  "components $v_r$ and $v_\\phi$ of the velocity field in 2d and the "
+                                                  "spherical coordinates components $v_r$, $v_{\\phi}$ and $v_{\\theta}$ "
+                                                  "of the velocity field in 3d."
+                                                  "\n\n"
+                                                  "Physical units: $\\frac{\\text{m}}{\\text{s}}$ or "
+                                                  "$\\frac{\\text{m}}{\\text{year}}$, depending on settings in the input file.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/strain_rate.cc.bak b/source/postprocess/visualization/strain_rate.cc.bak
new file mode 100644
index 00000000000..a50e49e8c1c
--- /dev/null
+++ b/source/postprocess/visualization/strain_rate.cc.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/strain_rate.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      StrainRate<dim>::
+      StrainRate ()
+        :
+        DataPostprocessorScalar<dim> ("strain_rate",
+                                      update_gradients | update_quadrature_points),
+        Interface<dim>("1/s")
+      {}
+
+
+
+      template <int dim>
+      void
+      StrainRate<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,
+                ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,
+                ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            Tensor<2,dim> grad_u;
+            for (unsigned int d=0; d<dim; ++d)
+              grad_u[d] = input_data.solution_gradients[q][d];
+
+            const SymmetricTensor<2,dim> strain_rate = symmetrize (grad_u);
+            computed_quantities[q](0) = std::sqrt(std::max(-second_invariant(deviator(strain_rate)), 0.));
+          }
+
+        // average the values if requested
+        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
+        if (!viz.output_pointwise_stress_and_strain())
+          average_quantities(computed_quantities);
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(StrainRate,
+                                                  "strain rate",
+                                                  "A visualization output object that generates output "
+                                                  "for the norm of the strain rate, i.e., for the quantity "
+                                                  "$\\sqrt{\\varepsilon(\\mathbf u):\\varepsilon(\\mathbf u)}$ "
+                                                  "in the incompressible case and "
+                                                  "$\\sqrt{[\\varepsilon(\\mathbf u)-\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I]:"
+                                                  "[\\varepsilon(\\mathbf u)-\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I]}$ "
+                                                  "in the compressible case."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\per\\second}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/strain_rate_tensor.cc.bak b/source/postprocess/visualization/strain_rate_tensor.cc.bak
new file mode 100644
index 00000000000..a68de211733
--- /dev/null
+++ b/source/postprocess/visualization/strain_rate_tensor.cc.bak
@@ -0,0 +1,105 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/strain_rate_tensor.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      StrainRateTensor<dim>::
+      StrainRateTensor ()
+        :
+        DataPostprocessorTensor<dim> ("strain_rate_tensor",
+                                      update_gradients | update_quadrature_points),
+        Interface<dim>("1/s")
+      {}
+
+
+
+      template <int dim>
+      void
+      StrainRateTensor<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError());
+        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
+                ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            Tensor<2,dim> grad_u;
+            for (unsigned int d=0; d<dim; ++d)
+              grad_u[d] = input_data.solution_gradients[q][d];
+
+            const SymmetricTensor<2,dim> strain_rate = symmetrize(grad_u);
+            const Tensor<2,dim> deviatoric_strain_rate
+              = (this->get_material_model().is_compressible()
+                 ?
+                 strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
+                 :
+                 strain_rate);
+
+            for (unsigned int d=0; d<dim; ++d)
+              for (unsigned int e=0; e<dim; ++e)
+                computed_quantities[q][Tensor<2,dim>::component_to_unrolled_index(TableIndices<2>(d,e))]
+                  = deviatoric_strain_rate[d][e];
+          }
+
+        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
+        if (!viz.output_pointwise_stress_and_strain())
+          average_quantities(computed_quantities);
+
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(StrainRateTensor,
+                                                  "strain rate tensor",
+                                                  "A visualization output object that generates output "
+                                                  "for the 4 (in 2d) or 9 (in 3d) components of the strain rate "
+                                                  "tensor, i.e., for the components of the tensor "
+                                                  "$\\varepsilon(\\mathbf u)$ "
+                                                  "in the incompressible case and "
+                                                  "$\\varepsilon(\\mathbf u)-"
+                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I$ "
+                                                  "in the compressible case."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\per\\second}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/stress.cc.bak b/source/postprocess/visualization/stress.cc.bak
new file mode 100644
index 00000000000..d4016b866d3
--- /dev/null
+++ b/source/postprocess/visualization/stress.cc.bak
@@ -0,0 +1,147 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/stress.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      Stress<dim>::
+      Stress ()
+        :
+        DataPostprocessorTensor<dim> ("stress",
+                                      update_values | update_gradients | update_quadrature_points),
+        Interface<dim>("Pa")
+      {}
+
+
+
+      template <int dim>
+      void
+      Stress<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
+                ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+
+        // We do not need to compute anything but the viscosity
+        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+        // Compute the viscosity...
+        this->get_material_model().evaluate(in, out);
+
+        // ...and use it to compute the stresses
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            // Compressive stress is negative by the sign convention
+            // used by the engineering community, and as input and used
+            // internally by ASPECT.
+            // Here, we change the sign of the stress to match the
+            // sign convention used by the geoscience community.
+            SymmetricTensor<2,dim> stress = in.pressure[q] * unit_symmetric_tensor<dim>();
+
+            // If elasticity is enabled, the deviatoric stress is stored
+            // in compositional fields, otherwise the deviatoric stress
+            // can be obtained from the viscosity and strain rate.
+            if (this->get_parameters().enable_elasticity)
+              {
+                stress[0][0] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
+                stress[1][1] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
+                stress[0][1] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
+
+                if (dim == 3)
+                  {
+                    stress[2][2] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
+                    stress[0][2] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
+                    stress[1][2] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
+                  }
+              }
+            else
+              {
+                const SymmetricTensor<2,dim> strain_rate = in.strain_rate[q];
+                const SymmetricTensor<2,dim> deviatoric_strain_rate
+                  = (this->get_material_model().is_compressible()
+                     ?
+                     strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
+                     :
+                     strain_rate);
+
+                const double eta = out.viscosities[q];
+                stress -= 2. * eta * deviatoric_strain_rate;
+              }
+
+            for (unsigned int d=0; d<dim; ++d)
+              for (unsigned int e=0; e<dim; ++e)
+                computed_quantities[q][Tensor<2,dim>::component_to_unrolled_index(TableIndices<2>(d,e))]
+                  = stress[d][e];
+          }
+
+        // average the values if requested
+        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
+        if (!viz.output_pointwise_stress_and_strain())
+          average_quantities(computed_quantities);
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Stress,
+                                                  "stress",
+                                                  "A visualization output object that generates output "
+                                                  "for the 3 (in 2d) or 6 (in 3d) components of the stress "
+                                                  "tensor, i.e., for the components of the tensor "
+                                                  "$-2\\eta\\varepsilon(\\mathbf u)+pI$ "
+                                                  "in the incompressible case and "
+                                                  "$-2\\eta\\left[\\varepsilon(\\mathbf u)-"
+                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I\\right]+pI$ "
+                                                  "in the compressible case. If elasticity is used, the "
+                                                  "elastic contribution is being accounted for. "
+                                                  "Note that the convention of positive "
+                                                  "compressive stress is followed."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\pascal}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/stress_second_invariant.cc.bak b/source/postprocess/visualization/stress_second_invariant.cc.bak
new file mode 100644
index 00000000000..1b2f4c87b6f
--- /dev/null
+++ b/source/postprocess/visualization/stress_second_invariant.cc.bak
@@ -0,0 +1,137 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/postprocess/visualization/stress_second_invariant.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      StressSecondInvariant<dim>::
+      StressSecondInvariant ()
+        :
+        DataPostprocessorScalar<dim> ("stress_second_invariant",
+                                      update_values | update_gradients | update_quadrature_points),
+        Interface<dim>("Pa")
+      {}
+
+
+
+      template <int dim>
+      void
+      StressSecondInvariant<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert(computed_quantities.size() == n_quadrature_points, ExcInternalError());
+        Assert(computed_quantities[0].size() == 1, ExcInternalError());
+        Assert(input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError());
+        Assert(input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
+
+        // Create the material model inputs and outputs to
+        // retrieve the current viscosity.
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+
+        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+
+        this->get_material_model().evaluate(in, out);
+
+        for (unsigned int q = 0; q < n_quadrature_points; ++q)
+          {
+            // Compressive stress is positive in geoscience applications.
+            SymmetricTensor<2, dim> stress = in.pressure[q] * unit_symmetric_tensor<dim>();
+
+            // Add elastic stresses if existent.
+            if (this->get_parameters().enable_elasticity == true)
+              {
+                stress[0][0] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
+                stress[1][1] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
+                stress[0][1] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
+
+                if (dim == 3)
+                  {
+                    stress[2][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
+                    stress[0][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
+                    stress[1][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
+                  }
+              }
+            else
+              {
+                const SymmetricTensor<2, dim> strain_rate = in.strain_rate[q];
+                const SymmetricTensor<2, dim> deviatoric_strain_rate = (this->get_material_model().is_compressible()
+                                                                        ? strain_rate - 1. / 3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
+                                                                        : strain_rate);
+
+                const double eta = out.viscosities[q];
+
+                stress += -2. * eta * deviatoric_strain_rate;
+              }
+
+            // Compute the deviatoric stress tensor after elastic stresses were added.
+            const SymmetricTensor<2, dim> deviatoric_stress = deviator(stress);
+
+            // Compute the second moment invariant of the deviatoric stress
+            // in the same way as the second moment invariant of the deviatoric
+            // strain rate is computed in the viscoplastic material model.
+            // TODO check that this is valid for the compressible case.
+            const double stress_invariant = std::sqrt(std::max(-second_invariant(deviatoric_stress), 0.));
+
+            computed_quantities[q](0) = stress_invariant;
+          }
+
+        // average the values if requested
+        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
+        if (!viz.output_pointwise_stress_and_strain())
+          average_quantities(computed_quantities);
+      }
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(StressSecondInvariant,
+                                                  "stress second invariant",
+                                                  "A visualization output object that outputs "
+                                                  "the second moment invariant of the deviatoric stress tensor."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\pascal}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/surface_dynamic_topography.cc.bak b/source/postprocess/visualization/surface_dynamic_topography.cc.bak
new file mode 100644
index 00000000000..8b18c62e0ad
--- /dev/null
+++ b/source/postprocess/visualization/surface_dynamic_topography.cc.bak
@@ -0,0 +1,135 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/postprocess/visualization/surface_dynamic_topography.h>
+#include <aspect/postprocess/dynamic_topography.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      SurfaceDynamicTopography<dim>::
+      SurfaceDynamicTopography ()
+        :
+        DataPostprocessorScalar<dim> ("surface_dynamic_topography",
+                                      update_quadrature_points),
+        Interface<dim>("m")
+      {}
+
+
+
+      template <int dim>
+      void
+      SurfaceDynamicTopography<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        // Initialize everything to zero, so that we can ignore faces we are
+        // not interested in (namely, those not labeled as 'top' or 'bottom')
+        for (auto &quantity : computed_quantities)
+          quantity(0) = 0;
+
+        const Postprocess::DynamicTopography<dim> &dynamic_topography =
+          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<dim>>();
+
+        auto cell = input_data.template get_cell<dim>();
+
+        // We only want to output dynamic topography at the top and bottom
+        // boundary, so only compute it if the current cell has
+        // a face at the top or bottom boundary.
+        bool cell_at_top_or_bottom_boundary = false;
+        for (const unsigned int f : cell->face_indices())
+          if (cell->at_boundary(f) &&
+              (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top" ||
+               this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "bottom"))
+            cell_at_top_or_bottom_boundary = true;
+
+        if (cell_at_top_or_bottom_boundary)
+          {
+            std::vector<Point<dim>> quadrature_points(input_data.evaluation_points.size());
+            for (unsigned int i=0; i<input_data.evaluation_points.size(); ++i)
+              quadrature_points[i] = this->get_mapping().transform_real_to_unit_cell(cell,input_data.evaluation_points[i]);
+
+            const Quadrature<dim> quadrature_formula(quadrature_points);
+
+            FEValues<dim> fe_volume_values (this->get_mapping(),
+                                            this->get_fe(),
+                                            quadrature_formula,
+                                            update_values);
+
+            fe_volume_values.reinit(cell);
+
+            std::vector<double> dynamic_topography_values(quadrature_formula.size());
+
+            // It might seem unintuitive to use the extractor for the temperature block,
+            // but that is where dynamic_topography.topography_vector() stores the values.
+            // See the documentation of that function for more details.
+            fe_volume_values[this->introspection().extractors.temperature].get_function_values(dynamic_topography.topography_vector(),
+                dynamic_topography_values);
+
+            for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+              computed_quantities[q](0) = dynamic_topography_values[q];
+          }
+      }
+
+
+
+      /**
+       * Register the other postprocessor that we need: DynamicTopography
+       */
+      template <int dim>
+      std::list<std::string>
+      SurfaceDynamicTopography<dim>::required_other_postprocessors() const
+      {
+        return {"dynamic topography"};
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SurfaceDynamicTopography,
+                                                  "surface dynamic topography",
+                                                  "A visualization output object that generates output "
+                                                  "for the dynamic topography at the top and bottom of the model space. "
+                                                  "The actual computation of this topography is handled inside the "
+                                                  "'dynamic topography' postprocessor, please check its documentation "
+                                                  "for details about the numerical methods."
+                                                  "\n\n"
+                                                  "In contrast to the `dynamic topography' visualization postprocessor, this "
+                                                  "plugin really only evaluates the dynamic topography at faces of cells "
+                                                  "that are adjacent to `bottom' and `top' boundaries, and only outputs "
+                                                  "information on the surface of the domain, rather than padding the "
+                                                  "information with zeros in the interior of the domain."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\meter}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/surface_elevation.cc.bak b/source/postprocess/visualization/surface_elevation.cc.bak
new file mode 100644
index 00000000000..a73286d9270
--- /dev/null
+++ b/source/postprocess/visualization/surface_elevation.cc.bak
@@ -0,0 +1,110 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/simulator.h>
+#include <aspect/postprocess/visualization/surface_elevation.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      SurfaceElevation<dim>::
+      SurfaceElevation ()
+        :
+        DataPostprocessorScalar<dim> ("surface_elevation",
+                                      update_quadrature_points),
+        Interface<dim>("m")
+      {}
+
+
+
+      template <int dim>
+      void
+      SurfaceElevation<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        // Initialize everything to zero, so that we can ignore faces we are
+        // not interested in (namely, those not labeled as 'top' or 'bottom')
+        for (auto &quantity : computed_quantities)
+          quantity(0) = 0;
+
+        // We only want to output dynamic topography at the top
+        // boundary. We know that this class will only be called on faces
+        // (because it is derived from SurfaceOnlyVisualization), so it is safe
+        // to query both cell and face associated with the DataPostprocessorInputs
+        // object.
+        const types::boundary_id boundary_id
+          = input_data.template get_cell<dim>()->face(input_data.get_face_number())->boundary_id();
+        if (this->get_geometry_model().translate_id_to_symbol_name (boundary_id) == "top")
+          for (unsigned int q=0; q<input_data.evaluation_points.size(); ++q)
+            computed_quantities[q](0)
+              = this->get_geometry_model().height_above_reference_surface(input_data.evaluation_points[q]);
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SurfaceElevation,
+                                                  "surface elevation",
+                                                  "This postprocessor is used to visualize the elevation of points "
+                                                  "on the surface of the geometry relative to a ``reference "
+                                                  "elevation'' defined by an undeformed geometry. It can be used, "
+                                                  "for example, to visualize an initial topography field, as well "
+                                                  "as the result of dynamic surface deformation due to a free "
+                                                  "surface."
+                                                  "\n\n"
+                                                  "The surface elevation is computed only for those parts of the "
+                                                  "boundary that the geometry description marks as ``top''. "
+                                                  "On all other parts of the boundary, the class outputs a zero "
+                                                  "elevation."
+                                                  "\n\n"
+                                                  "It is worth comparing this visualization postprocessor with the "
+                                                  "one called ``depth''. The latter is used to visualize a volume "
+                                                  "variable, whereas the current one only outputs information on "
+                                                  "the surface. Moreover ``depth'' is based on a member function of "
+                                                  "the geometry models that is documented as never returning a "
+                                                  "number less than zero -- in other words, it returns the depth "
+                                                  "of an evaluation point with regard to a reference surface that "
+                                                  "defines a zero depth, but for points that lie above this "
+                                                  "reference surface, it returns zero. As a consequence, it cannot "
+                                                  "be used to visualize positive elevations, whereas the current "
+                                                  "visualization postprocessor can."
+                                                  "\n\n"
+                                                  "Finally, it is worth pointing out the ``topography'' "
+                                                  "postprocessor (not a visualization postprocessor) that returns "
+                                                  "the surface elevation as a point cloud into a text file. The "
+                                                  "information is comparable to what the current object creates, "
+                                                  "but it is not as easily used to visualize information."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\meter}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/surface_strain_rate_tensor.cc.bak b/source/postprocess/visualization/surface_strain_rate_tensor.cc.bak
new file mode 100644
index 00000000000..6dd8b5c02ef
--- /dev/null
+++ b/source/postprocess/visualization/surface_strain_rate_tensor.cc.bak
@@ -0,0 +1,109 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/surface_strain_rate_tensor.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      SurfaceStrainRateTensor<dim>::
+      SurfaceStrainRateTensor()
+        : DataPostprocessorTensor<dim>("surface_strain_rate_tensor",
+                                       update_gradients | update_quadrature_points),
+        Interface<dim>("1/s")
+      {}
+
+
+
+      template <int dim>
+      void
+      SurfaceStrainRateTensor<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError());
+        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
+                ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            Tensor<2,dim> grad_u;
+            for (unsigned int d=0; d<dim; ++d)
+              grad_u[d] = input_data.solution_gradients[q][d];
+
+            const SymmetricTensor<2,dim> strain_rate = symmetrize(grad_u);
+            const Tensor<2,dim> deviatoric_strain_rate
+              = (this->get_material_model().is_compressible()
+                 ?
+                 strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
+                 :
+                 strain_rate);
+
+            for (unsigned int d = 0; d < dim; ++d)
+              for (unsigned int e = 0; e < dim; ++e)
+                computed_quantities[q][Tensor<2, dim>::component_to_unrolled_index(TableIndices<2>(d, e))]
+                  = deviatoric_strain_rate[d][e];
+          }
+
+        // average the values if requested
+        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
+        if (!viz.output_pointwise_stress_and_strain())
+          average_quantities(computed_quantities);
+
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SurfaceStrainRateTensor,
+                                                  "surface strain rate tensor",
+                                                  "A visualization output object that generates output "
+                                                  "on the surface of the domain "
+                                                  "for the 4 (in 2d) or 9 (in 3d) components of the strain rate "
+                                                  "tensor, i.e., for the components of the tensor "
+                                                  "$\\varepsilon(\\mathbf u)$ "
+                                                  "in the incompressible case and "
+                                                  "$\\varepsilon(\\mathbf u)-"
+                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I$ "
+                                                  "in the compressible case."
+                                                  "Note that both in 2d and in 3d the output tensor will have 9 "
+                                                  "elements, but that in 2d, only 4 are filled. "
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\per\\second}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/surface_stress.cc.bak b/source/postprocess/visualization/surface_stress.cc.bak
new file mode 100644
index 00000000000..f1dea24cc0f
--- /dev/null
+++ b/source/postprocess/visualization/surface_stress.cc.bak
@@ -0,0 +1,143 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/surface_stress.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      SurfaceStress<dim>::
+      SurfaceStress ()
+        :
+        DataPostprocessorTensor<dim> ("surface_stress",
+                                      update_values | update_gradients | update_quadrature_points),
+        Interface<dim>("Pa")
+      {}
+
+
+
+      template <int dim>
+      void
+      SurfaceStress<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
+                ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+
+        // We do not need to compute anything but the viscosity
+        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+        // Compute the viscosity...
+        this->get_material_model().evaluate(in, out);
+
+        // ...and use it to compute the stresses
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            const SymmetricTensor<2,dim> strain_rate = in.strain_rate[q];
+            const SymmetricTensor<2,dim> deviatoric_strain_rate
+              = (this->get_material_model().is_compressible()
+                 ?
+                 strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
+                 :
+                 strain_rate);
+
+            const double eta = out.viscosities[q];
+
+            // Compressive stress is positive in geoscience applications
+            SymmetricTensor<2,dim> stress = -2.*eta*deviatoric_strain_rate +
+                                            in.pressure[q] * unit_symmetric_tensor<dim>();
+
+            // Add elastic stresses if existent
+            if (this->get_parameters().enable_elasticity == true)
+              {
+                stress[0][0] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
+                stress[1][1] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
+                stress[0][1] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
+
+                if (dim == 3)
+                  {
+                    stress[2][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
+                    stress[0][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
+                    stress[1][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
+                  }
+              }
+
+            for (unsigned int d=0; d<dim; ++d)
+              for (unsigned int e=0; e<dim; ++e)
+                computed_quantities[q][Tensor<2,dim>::component_to_unrolled_index(TableIndices<2>(d,e))]
+                  = stress[d][e];
+          }
+
+        // average the values if requested
+        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
+        if (!viz.output_pointwise_stress_and_strain())
+          average_quantities(computed_quantities);
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SurfaceStress,
+                                                  "surface stress",
+                                                  "A visualization output object that generates output "
+                                                  "on the surface of the domain "
+                                                  "for the 3 (in 2d) or 6 (in 3d) components of the stress "
+                                                  "tensor, i.e., for the components of the tensor "
+                                                  "$-2\\eta\\varepsilon(\\mathbf u)+pI$ "
+                                                  "in the incompressible case and "
+                                                  "$-2\\eta\\left[\\varepsilon(\\mathbf u)-"
+                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I\\right]+pI$ "
+                                                  "in the compressible case. If elasticity is included, "
+                                                  "its contribution is accounted for. Note that the convention of positive "
+                                                  "compressive stress is followed."
+                                                  "The stress outputted on the surface of the domain will equal "
+                                                  "the stress on the surface of the volume output if the parameter "
+                                                  "'Point-wise stress and strain' in the Visualization subsection "
+                                                  "is set to true. "
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\pascal}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/temperature_anomaly.cc.bak b/source/postprocess/visualization/temperature_anomaly.cc.bak
new file mode 100644
index 00000000000..61ea2516197
--- /dev/null
+++ b/source/postprocess/visualization/temperature_anomaly.cc.bak
@@ -0,0 +1,190 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/temperature_anomaly.h>
+#include <aspect/boundary_temperature/constant.h>
+#include <aspect/lateral_averaging.h>
+#include <aspect/geometry_model/interface.h>
+
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      TemperatureAnomaly<dim>::
+      TemperatureAnomaly ()
+        :
+        DataPostprocessorScalar<dim> ("temperature_anomaly",
+                                      update_values | update_quadrature_points ),
+        Interface<dim>("K")
+      {}
+
+
+
+      template <int dim>
+      void
+      TemperatureAnomaly<dim>::
+      update ()
+      {
+        std::vector<double> temperature_depth_average(n_slices);
+        this->get_lateral_averaging().get_temperature_averages(temperature_depth_average);
+
+        // Estimates of the lateral temperature average at each depth are required
+        // for all cell depths, including those
+        // shallower than the midpoint of the first slice or
+        // deeper than the midpoint of the last slice.
+
+        padded_temperature_depth_average.resize(n_slices+2);
+
+        if ( extrapolate_surface )
+          {
+            padded_temperature_depth_average[0] = 2.*temperature_depth_average[0] - temperature_depth_average[1];
+          }
+        else
+          {
+            Assert( this->has_boundary_temperature(),ExcInternalError());
+            // retrieve the minimum temperature from the fixed temperature boundary indicators
+            const double surface_temperature = this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators());
+            padded_temperature_depth_average[0] = 2.*surface_temperature - temperature_depth_average[0];
+          }
+        if ( extrapolate_bottom )
+          {
+            padded_temperature_depth_average[n_slices+1] = 2.*temperature_depth_average[n_slices-1] - temperature_depth_average[n_slices-2];
+          }
+        else
+          {
+            const double bottom_temperature = this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators());
+            padded_temperature_depth_average[n_slices+1] = 2.*bottom_temperature - temperature_depth_average[n_slices-1];
+          }
+        std::copy ( temperature_depth_average.begin(), temperature_depth_average.end(), padded_temperature_depth_average.begin() + 1 );
+
+      }
+
+
+
+      template <int dim>
+      void
+      TemperatureAnomaly<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const double max_depth = this->get_geometry_model().maximal_depth();
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            const double temperature = input_data.solution_values[q][this->introspection().component_indices.temperature];
+            const double depth = this->get_geometry_model().depth (input_data.evaluation_points[q]);
+            // calculate the depth-average cell containing this point. Note that cell centers are offset +0.5 cells in depth.
+            const double slice_depth = (depth*n_slices)/max_depth + 0.5;
+            const unsigned int idx = static_cast<unsigned int>(slice_depth);
+            const double fractional_slice = slice_depth - static_cast<double>(idx);
+            Assert(idx<n_slices+1, ExcInternalError());
+            const double depth_average_temperature= (1. - fractional_slice)*padded_temperature_depth_average[idx] + fractional_slice*padded_temperature_depth_average[idx+1];
+            computed_quantities[q](0) = temperature - depth_average_temperature;
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      TemperatureAnomaly<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Temperature anomaly");
+            {
+              prm.declare_entry ("Number of depth slices","20",
+                                 Patterns::Integer (1),
+                                 "Number of depth slices used to define "
+                                 "average temperature.");
+              prm.declare_entry ("Use maximal temperature for bottom","true",
+                                 Patterns::Bool(),
+                                 "If true, use the specified boundary temperatures as average temperatures at the surface. "
+                                 "If false, extrapolate the temperature gradient between the first and second cells to the surface. "
+                                 "This option will only work for models with a fixed surface temperature. ");
+              prm.declare_entry ("Use minimal temperature for surface","true",
+                                 Patterns::Bool(),
+                                 "Whether to use the minimal specified boundary temperature as the bottom boundary temperature. "
+                                 "This option will only work for models with a fixed bottom boundary temperature. ");
+
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      TemperatureAnomaly<dim>::parse_parameters(ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Temperature anomaly");
+            {
+              n_slices = prm.get_integer("Number of depth slices");
+              extrapolate_surface = !prm.get_bool("Use minimal temperature for surface");
+              extrapolate_bottom = !prm.get_bool("Use maximal temperature for bottom");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(TemperatureAnomaly,
+                                                  "temperature anomaly",
+                                                  "A visualization output postprocessor that outputs the temperature minus the depth-average of the temperature."
+                                                  "The average temperature is calculated using the lateral averaging function from the ``depth average'' "
+                                                  "postprocessor and interpolated linearly between the layers specified through ``Number of depth slices''."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\kelvin}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/vertical_heat_flux.cc.bak b/source/postprocess/visualization/vertical_heat_flux.cc.bak
new file mode 100644
index 00000000000..78a49f73c5b
--- /dev/null
+++ b/source/postprocess/visualization/vertical_heat_flux.cc.bak
@@ -0,0 +1,106 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/vertical_heat_flux.h>
+#include <aspect/gravity_model/interface.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      VerticalHeatFlux<dim>::
+      VerticalHeatFlux ()
+        :
+        DataPostprocessorScalar<dim> ("vertical_heat_flux",
+                                      update_values | update_quadrature_points | update_gradients),
+        Interface<dim>("W/m/m")
+      {}
+
+
+
+      template <int dim>
+      void
+      VerticalHeatFlux<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
+
+        //Create vector for the temperature gradients.  All the other things
+        //we need are in MaterialModelInputs/Outputs
+        std::vector<Tensor<1,dim>> temperature_gradient(n_quadrature_points);
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          for (unsigned int d = 0; d < dim; ++d)
+            temperature_gradient[q][d] = input_data.solution_gradients[q][this->introspection().component_indices.temperature][d];
+
+
+        MaterialModel::MaterialModelInputs<dim> in(input_data,
+                                                   this->introspection());
+        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
+                                                     this->n_compositional_fields());
+        in.requested_properties = MaterialModel::MaterialProperties::density |
+                                  MaterialModel::MaterialProperties::specific_heat |
+                                  MaterialModel::MaterialProperties::thermal_conductivity;
+
+        this->get_material_model().evaluate(in, out);
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(in.position[q]);
+            const Tensor<1,dim> vertical = -gravity/( gravity.norm() != 0.0 ?
+                                                      gravity.norm() : 1.0 );
+            const double advective_flux = (in.velocity[q] * vertical) * in.temperature[q] *
+                                          out.densities[q]*out.specific_heat[q];
+            const double conductive_flux = -(temperature_gradient[q]*vertical) *
+                                           out.thermal_conductivities[q];
+            computed_quantities[q](0) = advective_flux + conductive_flux;
+          }
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(VerticalHeatFlux,
+                                                  "vertical heat flux",
+                                                  "A visualization output object that generates output "
+                                                  "for the heat flux in the vertical direction, which is "
+                                                  "the sum of the advective and the conductive heat flux, "
+                                                  "with the sign convention of positive flux upwards."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\watt\\per\\square\\meter}.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/volume_of_fluid_values.cc.bak b/source/postprocess/visualization/volume_of_fluid_values.cc.bak
new file mode 100644
index 00000000000..5dc24913cbc
--- /dev/null
+++ b/source/postprocess/visualization/volume_of_fluid_values.cc.bak
@@ -0,0 +1,209 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/postprocess/visualization/volume_of_fluid_values.h>
+#include <aspect/volume_of_fluid/handler.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      VolumeOfFluidValues<dim>::
+      VolumeOfFluidValues ()
+        :
+        DataPostprocessor<dim> (),
+        Interface<dim>("")  // physical units of a fractional volume, so units of "1"
+      {}
+
+
+      template <int dim>
+      std::vector<std::string>
+      VolumeOfFluidValues<dim>::
+      get_names () const
+      {
+        return volume_of_fluid_names;
+      }
+
+
+      template <int dim>
+      std::vector<DataComponentInterpretation::DataComponentInterpretation>
+      VolumeOfFluidValues<dim>::
+      get_data_component_interpretation () const
+      {
+        return interpretations;
+      }
+
+
+      template <int dim>
+      UpdateFlags
+      VolumeOfFluidValues<dim>::
+      get_needed_update_flags () const
+      {
+        return update_values;
+      }
+
+
+      template <int dim>
+      void
+      VolumeOfFluidValues<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError ());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError ());
+
+        unsigned int out_per_field=1;
+        if (include_contour)
+          out_per_field += 1;
+        if (include_normal)
+          out_per_field += dim;
+
+        for (unsigned int f=0; f<this->get_volume_of_fluid_handler().get_n_fields(); ++f)
+          {
+            const VolumeOfFluidField<dim> &field = this->get_volume_of_fluid_handler().field_struct_for_field_index(f);
+
+            const FEVariable<dim> &volume_of_fluid_var = field.volume_fraction;
+            const unsigned int volume_of_fluid_ind = volume_of_fluid_var.first_component_index;
+            const FEVariable<dim> &volume_of_fluidLS_var = field.level_set;
+            const unsigned int volume_of_fluidLS_ind = volume_of_fluidLS_var.first_component_index;
+
+            for (unsigned int q=0; q<n_quadrature_points; ++q)
+              {
+                unsigned int out_ind = f*out_per_field;
+                computed_quantities[q][out_ind] = input_data.solution_values[q][volume_of_fluid_ind];
+                ++out_ind;
+                if (include_contour)
+                  {
+                    computed_quantities[q][out_ind] = input_data.solution_values[q][volume_of_fluidLS_ind];
+                    ++out_ind;
+                  }
+
+                // TODO: Adjust this so the output will match the "physical" space rather than unit cell space.
+                // Some rescaling may be desirable to keep $\|n\|_2=1$ in cases with an interface
+                if (include_normal)
+                  {
+                    Tensor<1, dim, double> normal = -input_data.solution_gradients[q][volume_of_fluidLS_ind];
+                    for (unsigned int i = 0; i<dim; ++i)
+                      {
+                        computed_quantities[q][out_ind] = normal[i];
+                        ++out_ind;
+                      }
+                  }
+              }
+          }
+      }
+
+
+
+      template <int dim>
+      void
+      VolumeOfFluidValues<dim>::declare_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Volume of Fluid");
+            {
+              prm.declare_entry("Output interface reconstruction contour", "false",
+                                Patterns::Bool (),
+                                "Include fields defined such that the 0 contour is the fluid interface.");
+
+              // TODO: Fix this for curved geometries
+              prm.declare_entry("Output interface normals", "false",
+                                Patterns::Bool (),
+                                "Include the internal data for the interface normal on the unit cells.");
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+
+
+
+      template <int dim>
+      void
+      VolumeOfFluidValues<dim>::parse_parameters (ParameterHandler &prm)
+      {
+        prm.enter_subsection("Postprocess");
+        {
+          prm.enter_subsection("Visualization");
+          {
+            prm.enter_subsection("Volume of Fluid");
+            {
+              include_contour = prm.get_bool("Output interface reconstruction contour");
+              include_normal = prm.get_bool("Output interface normals");
+
+              for (unsigned int f=0; f<this->get_volume_of_fluid_handler().get_n_fields(); ++f)
+                {
+                  std::string field_name = this->get_volume_of_fluid_handler().name_for_field_index(f);
+                  volume_of_fluid_names.push_back("volume_fraction_"+field_name);
+                  interpretations.push_back(DataComponentInterpretation::component_is_scalar);
+
+                  if (include_contour)
+                    {
+                      volume_of_fluid_names.push_back("volume_of_fluid_contour_"+field_name);
+                      interpretations.push_back(DataComponentInterpretation::component_is_scalar);
+                    }
+
+                  if (include_normal)
+                    {
+                      for (unsigned int i=0; i<dim; ++i)
+                        {
+                          volume_of_fluid_names.push_back("volume_of_fluid_interface_normal_"+field_name);
+                          interpretations.push_back(DataComponentInterpretation::component_is_part_of_vector);
+                        }
+                    }
+                }
+            }
+            prm.leave_subsection();
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(VolumeOfFluidValues,
+                                                  "volume of fluid values",
+                                                  "A visualization output object that outputs the volume fraction "
+                                                  "and optionally a level set field and the interface normal "
+                                                  "vectors of volume of fluid fields."
+                                                  "\n\n"
+                                                  "Physical units: None.")
+    }
+  }
+}
diff --git a/source/postprocess/visualization/volumetric_strain_rate.cc.bak b/source/postprocess/visualization/volumetric_strain_rate.cc.bak
new file mode 100644
index 00000000000..3c5c6273238
--- /dev/null
+++ b/source/postprocess/visualization/volumetric_strain_rate.cc.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/visualization/volumetric_strain_rate.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      VolumetricStrainRate<dim>::
+      VolumetricStrainRate ()
+        :
+        DataPostprocessorScalar<dim> ("volumetric_strain_rate",
+                                      update_gradients | update_quadrature_points),
+        Interface<dim>("1/s")
+      {}
+
+
+
+      template <int dim>
+      void
+      VolumetricStrainRate<dim>::
+      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
+                            std::vector<Vector<double>> &computed_quantities) const
+      {
+        const unsigned int n_quadrature_points = input_data.solution_values.size();
+        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
+        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
+        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
+        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,          ExcInternalError());
+
+        for (unsigned int q=0; q<n_quadrature_points; ++q)
+          {
+            // extract the velocity gradients
+            Tensor<2,dim> grad_u;
+            for (unsigned int d=0; d<dim; ++d)
+              grad_u[d] = input_data.solution_gradients[q][d];
+
+            const double div_u = trace(grad_u);
+            computed_quantities[q](0) = div_u;
+          }
+
+        // average the values if requested
+        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
+        if (!viz.output_pointwise_stress_and_strain())
+          average_quantities(computed_quantities);
+      }
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(VolumetricStrainRate,
+                                                  "volumetric strain rate",
+                                                  "A visualization output object that generates output "
+                                                  "for the volumetric strain rate, i.e., for the quantity "
+                                                  "$\\nabla\\cdot\\mathbf u = \\textrm{div}\\; \\mathbf u = "
+                                                  "\\textrm{trace}\\; \\varepsilon(\\mathbf u)$. "
+                                                  "This should be zero (in some average sense) in incompressible "
+                                                  "convection models, but can be non-zero in compressible models and "
+                                                  "models with melt transport."
+                                                  "\n\n"
+                                                  "Physical units: \\si{\\per\\second}.")
+    }
+  }
+}
diff --git a/source/postprocess/volume_of_fluid_statistics.cc.bak b/source/postprocess/volume_of_fluid_statistics.cc.bak
new file mode 100644
index 00000000000..e6d6cbef61b
--- /dev/null
+++ b/source/postprocess/volume_of_fluid_statistics.cc.bak
@@ -0,0 +1,117 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/postprocess/volume_of_fluid_statistics.h>
+#include <aspect/volume_of_fluid/handler.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    VolumeOfFluidStatistics<dim>::execute (TableHandler &statistics)
+    {
+      AssertThrow(this->get_volume_of_fluid_handler().get_n_fields()!=numbers::invalid_unsigned_int,
+                  ExcMessage("This postprocessor cannot be used without VolumeOfFluid fields"));
+      const QGauss<dim> quadrature_formula (1);
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      const unsigned int n_volume_of_fluid_fields
+        = this->get_volume_of_fluid_handler().get_n_fields();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+      std::vector<double> volume_of_fluid_values(n_q_points);
+
+      std::vector<double> local_volume_of_fluid_vol_sums(n_volume_of_fluid_fields);
+
+      for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
+        {
+          const FEValuesExtractors::Scalar
+          volume_of_fluid (this->get_volume_of_fluid_handler().field_struct_for_field_index(f)
+                           .volume_fraction.extractor_scalar());
+          double volume_of_fluid_vol_sum=0.0;
+
+          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+            if (cell->is_locally_owned())
+              {
+                fe_values.reinit (cell);
+                fe_values[volume_of_fluid].get_function_values (this->get_solution(),
+                                                                volume_of_fluid_values);
+                for (unsigned int q = 0; q < n_q_points; ++q)
+                  {
+                    volume_of_fluid_vol_sum += volume_of_fluid_values[q] * fe_values.JxW(q);
+                  }
+              }
+          local_volume_of_fluid_vol_sums[f] = volume_of_fluid_vol_sum;
+        }
+
+      std::vector<double> global_volume_of_fluid_vol_sums(n_volume_of_fluid_fields);
+
+      Utilities::MPI::sum (local_volume_of_fluid_vol_sums, this->get_mpi_communicator(),
+                           global_volume_of_fluid_vol_sums);
+
+      std::ostringstream output;
+      output.precision(3);
+
+      for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
+        {
+          const std::string col_name = "Global volume of fluid volumes for " +
+                                       this->get_volume_of_fluid_handler().name_for_field_index(f);
+          statistics.add_value (col_name, global_volume_of_fluid_vol_sums[f]);
+
+          output << global_volume_of_fluid_vol_sums[f];
+
+          if (f+1 < n_volume_of_fluid_fields)
+            output << '/';
+
+          // also make sure that the columns filled by this object
+          // show up with sufficient accuracy and in scientific notation
+          statistics.set_precision (col_name, 8);
+          statistics.set_scientific (col_name, true);
+        }
+
+      return {"Global volume of fluid volumes (m^3):", output.str()};
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(VolumeOfFluidStatistics,
+                                  "volume of fluid statistics",
+                                  "A postprocessor that computes some statistics about the "
+                                  "volume-of-fluid fields.")
+  }
+}
diff --git a/source/prescribed_stokes_solution/ascii_data.cc.bak b/source/prescribed_stokes_solution/ascii_data.cc.bak
new file mode 100644
index 00000000000..7e7aa4af79b
--- /dev/null
+++ b/source/prescribed_stokes_solution/ascii_data.cc.bak
@@ -0,0 +1,121 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/global.h>
+#include <aspect/prescribed_stokes_solution/ascii_data.h>
+
+
+
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    template <int dim>
+    AsciiData<dim>::AsciiData ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::initialize ()
+    {
+      Utilities::AsciiDataInitial<dim>::initialize(dim);
+
+      AssertThrow(!this->get_parameters().include_melt_transport,
+                  ExcMessage("Using the ascii data plugin for the prescribed Stokes solution "
+                             "is not supported in models with melt transport."));
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::
+    stokes_solution (const Point<dim> &position, Vector<double> &value) const
+    {
+      value(0) = Utilities::AsciiDataInitial<dim>::get_data_component(position,0);
+      value(1) = Utilities::AsciiDataInitial<dim>::get_data_component(position,1);
+      if (dim == 3)
+        value(2) = Utilities::AsciiDataInitial<dim>::get_data_component(position,2);
+      value(dim) = 0;  // makes pressure 0, must set pressure
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Prescribed Stokes solution");
+      {
+        Utilities::AsciiDataInitial<dim>::declare_parameters(prm,
+                                                             "$ASPECT_SOURCE_DIR/data/prescribed-stokes-solution/",
+                                                             "box_2d.txt");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Prescribed Stokes solution");
+      {
+        Utilities::AsciiDataInitial<dim>::parse_parameters(prm);
+      }
+      prm.leave_subsection();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(AsciiData,
+                                               "ascii data",
+                                               "Implementation of a model in which the velocity "
+                                               "is derived from files containing data "
+                                               "in ascii format. Note the required format of the "
+                                               "input data: The first lines may contain any number of comments "
+                                               "if they begin with `#', but one of these lines needs to "
+                                               "contain the number of grid points in each dimension as "
+                                               "for example `# POINTS: 3 3'. "
+                                               "The order of the data columns "
+                                               "has to be `x', `y', `v${}_x$' , `v${}_y$' in a 2d model and "
+                                               " `x', `y', `z', `v${}_x$' , `v${}_y$' , `v${}_z$' in a 3d model. "
+                                               "Note that the data in the input "
+                                               "files need to be sorted in a specific order: "
+                                               "the first coordinate needs to ascend first, "
+                                               "followed by the second and the third at last in order to "
+                                               "assign the correct data to the prescribed coordinates. "
+                                               "If you use a spherical model, "
+                                               "then the data will still be handled as Cartesian, "
+                                               "however the assumed grid changes. `x' will be replaced by "
+                                               "the radial distance of the point to the bottom of the model, "
+                                               "`y' by the azimuth angle and `z' by the polar angle measured "
+                                               "positive from the north pole. The grid will be assumed to be "
+                                               "a latitude-longitude grid. Note that the order "
+                                               "of spherical coordinates is `r', `phi', `theta' "
+                                               "and not `r', `theta', `phi', since this allows "
+                                               "for dimension independent expressions.")
+  }
+}
diff --git a/source/prescribed_stokes_solution/circle.cc.bak b/source/prescribed_stokes_solution/circle.cc.bak
new file mode 100644
index 00000000000..dfa6a8a589b
--- /dev/null
+++ b/source/prescribed_stokes_solution/circle.cc.bak
@@ -0,0 +1,70 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/prescribed_stokes_solution/circle.h>
+
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    template <int dim>
+    void Circle<dim>::stokes_solution (const Point<dim> &p, Vector<double> &value) const
+    {
+      value(0) = -p(1);
+      value(1) = p(0);
+      if (dim == 3)
+        value(2) = 0;
+
+      if (this->get_parameters().include_melt_transport)
+        {
+          value(dim) = 0;       // fluid pressure
+          value(dim+1) = 0;     // compaction pressure
+
+          value(dim+2) = -p(1); // fluid velocity x
+          value(dim+3) = p(0);  // fluid velocity y
+          if (dim == 3)
+            value(dim+4) = 0;
+
+          value(2*dim+2) = 0;   // pressure
+        }
+      else
+        {
+          value(dim) = 0;       // pressure
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(Circle,
+                                               "circle",
+                                               "This value describes a vector field that rotates "
+                                               "around the z-axis with constant angular velocity "
+                                               "(i.e., with a velocity that increases with "
+                                               "distance from the axis). The pressure is set "
+                                               "to zero.")
+  }
+}
diff --git a/source/prescribed_stokes_solution/function.cc.bak b/source/prescribed_stokes_solution/function.cc.bak
new file mode 100644
index 00000000000..6ea86197904
--- /dev/null
+++ b/source/prescribed_stokes_solution/function.cc.bak
@@ -0,0 +1,246 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/prescribed_stokes_solution/function.h>
+
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    template <int dim>
+    Function<dim>::Function ()
+      :
+      prescribed_velocity_function (dim),
+      prescribed_pressure_function (1),
+      prescribed_fluid_pressure_function (1),
+      prescribed_compaction_pressure_function (1),
+      prescribed_fluid_velocity_function (dim)
+    {}
+
+    template <int dim>
+    void
+    Function<dim>::stokes_solution (const Point<dim> &position, Vector<double> &value) const
+    {
+      // velocity
+      for (unsigned int d=0; d<dim; ++d)
+        {
+          value[d] = prescribed_velocity_function.value(position,d);
+
+          if (this->convert_output_to_years())
+            value[d] /= year_in_seconds;
+        }
+
+      if (this->get_parameters().include_melt_transport)
+        {
+          // fluid pressure
+          value(dim) = prescribed_fluid_pressure_function.value(position);
+
+          // compaction pressure
+          value(dim+1) = prescribed_compaction_pressure_function.value(position);
+
+          // fluid velocity
+          for (unsigned int d=0; d<dim; ++d)
+            {
+              value[dim+2+d] = prescribed_fluid_velocity_function.value(position,d);
+
+              if (this->convert_output_to_years())
+                value[dim+2+d] /= year_in_seconds;
+            }
+
+          // pressure
+          value(2*dim+2) = prescribed_pressure_function.value(position);
+        }
+      else
+        {
+          // pressure
+          value(dim) = prescribed_pressure_function.value(position);
+        }
+    }
+
+    template <int dim>
+    void
+    Function<dim>::update()
+    {
+      // we get time passed as seconds (always) but may want
+      // to reinterpret it in years
+      if (this->convert_output_to_years())
+        {
+          prescribed_velocity_function.set_time (this->get_time() / year_in_seconds);
+          prescribed_pressure_function.set_time (this->get_time() / year_in_seconds);
+          prescribed_fluid_pressure_function.set_time (this->get_time() / year_in_seconds);
+          prescribed_compaction_pressure_function.set_time (this->get_time() / year_in_seconds);
+          prescribed_fluid_velocity_function.set_time (this->get_time() / year_in_seconds);
+        }
+      else
+        {
+          prescribed_velocity_function.set_time (this->get_time());
+          prescribed_pressure_function.set_time (this->get_time());
+          prescribed_fluid_pressure_function.set_time (this->get_time());
+          prescribed_compaction_pressure_function.set_time (this->get_time());
+          prescribed_fluid_velocity_function.set_time (this->get_time());
+        }
+    }
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Prescribed Stokes solution");
+      {
+        prm.enter_subsection("Velocity function");
+        {
+          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
+        }
+        prm.leave_subsection();
+        prm.enter_subsection("Pressure function");
+        {
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+        prm.enter_subsection("Fluid pressure function");
+        {
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+        prm.enter_subsection("Compaction pressure function");
+        {
+          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+        }
+        prm.leave_subsection();
+        prm.enter_subsection("Fluid velocity function");
+        {
+          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Prescribed Stokes solution");
+      {
+        prm.enter_subsection("Velocity function");
+        try
+          {
+            prescribed_velocity_function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Prescribed Stokes solution.Function.Velocity function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+        prm.enter_subsection("Pressure function");
+        try
+          {
+            prescribed_pressure_function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Prescribed Stokes solution.Function.Pressure function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+        prm.enter_subsection("Fluid pressure function");
+        try
+          {
+            prescribed_fluid_pressure_function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Initial conditions.Function.Fluid pressure function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+        prm.enter_subsection("Compaction pressure function");
+        try
+          {
+            prescribed_compaction_pressure_function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Initial conditions.Function.Compaction pressure function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+        prm.enter_subsection("Fluid velocity function");
+        try
+          {
+            prescribed_fluid_velocity_function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Initial conditions.Function.Fluid velocity function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+    ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(Function,
+                                               "function",
+                                               "This plugin allows to prescribe the Stokes solution "
+                                               "for the velocity and pressure field in terms of an "
+                                               "explicit formula. The format of these "
+                                               "functions follows the syntax understood by the "
+                                               "muparser library, see "
+                                               "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
+  }
+}
diff --git a/source/prescribed_stokes_solution/interface.cc.bak b/source/prescribed_stokes_solution/interface.cc.bak
new file mode 100644
index 00000000000..244e91a4fab
--- /dev/null
+++ b/source/prescribed_stokes_solution/interface.cc.bak
@@ -0,0 +1,156 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/prescribed_stokes_solution/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace PrescribedStokesSolution
+  {
+// -------------------------------- Deal with registering prescribed_stokes_solution models and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    register_prescribed_stokes_solution_model (const std::string &name,
+                                               const std::string &description,
+                                               void (*declare_parameters_function) (ParameterHandler &),
+                                               std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+    template <int dim>
+    std::unique_ptr<Interface<dim>>
+    create_prescribed_stokes_solution (ParameterHandler &prm)
+    {
+      std::string model_name;
+      prm.enter_subsection ("Prescribed Stokes solution");
+      {
+        model_name = prm.get ("Model name");
+      }
+      prm.leave_subsection ();
+
+      if (model_name == "unspecified")
+        return nullptr;
+
+      std::unique_ptr<Interface<dim>>plugin = std::get<dim>(registered_plugins).create_plugin (model_name,
+                                               "Prescribed Stokes solution::Model name");
+      return plugin;
+    }
+
+
+
+    template <int dim>
+    void
+    declare_parameters (ParameterHandler &prm)
+    {
+      // declare the entry in the parameter file
+      prm.enter_subsection ("Prescribed Stokes solution");
+      {
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+        prm.declare_entry ("Model name", "unspecified",
+                           Patterns::Selection (pattern_of_names+"|unspecified"),
+                           "Select one of the following models:\n\n"
+                           +
+                           std::get<dim>(registered_plugins).get_description_string());
+      }
+      prm.leave_subsection ();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Prescribed Stokes solution interface",
+                                                            out);
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<PrescribedStokesSolution::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<PrescribedStokesSolution::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<PrescribedStokesSolution::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<PrescribedStokesSolution::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace PrescribedStokesSolution
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  \
+  template \
+  void \
+  register_prescribed_stokes_solution_model<dim> (const std::string &, \
+                                                  const std::string &, \
+                                                  void ( *) (ParameterHandler &), \
+                                                  std::unique_ptr<Interface<dim>>( *) ()); \
+  \
+  template  \
+  void \
+  declare_parameters<dim> (ParameterHandler &); \
+  \
+  template \
+  void \
+  write_plugin_graph<dim> (std::ostream &); \
+  \
+  template \
+  std::unique_ptr<Interface<dim>> \
+  create_prescribed_stokes_solution<dim> (ParameterHandler &prm);
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/simulator/assemblers/advection.cc.bak b/source/simulator/assemblers/advection.cc.bak
new file mode 100644
index 00000000000..4143e08e62e
--- /dev/null
+++ b/source/simulator/assemblers/advection.cc.bak
@@ -0,0 +1,1634 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator/assemblers/advection.h>
+
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    namespace
+    {
+      /* These functions implement a reduced form of the code from deal.II's TriaAccessor::measure().
+       * In the 3d dG case, a call to face->measure() is not implemented for non-planar faces.
+       * Since we only care about the scaling here, it is enough to have an approximation instead.
+       * The 2d case remains unchanged.
+       */
+      double
+      approximate_face_measure(const DoFHandler<2>::face_iterator &face)
+      {
+        return (face->vertex(0)-face->vertex(1)).norm();
+      }
+
+      double
+      approximate_face_measure(const DoFHandler<3>::face_iterator &face)
+      {
+        const Tensor<1,3> v03 = face->vertex(3) - face->vertex(0);
+        const Tensor<1,3> v12 = face->vertex(2) - face->vertex(1);
+        const Tensor<1,3> twice_area = cross_product_3d(v03, v12);
+        return 0.5 * twice_area.norm();
+      }
+    }
+
+    template <int dim>
+    void
+    AdvectionSystem<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                                   internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
+
+      const bool use_supg = (this->get_parameters().advection_stabilization_method
+                             == Parameters<dim>::AdvectionStabilizationMethod::supg);
+      const bool   use_bdf2_scheme = (this->get_timestep_number() > 1);
+      const double time_step = this->get_timestep();
+      const double old_time_step = this->get_old_timestep();
+      const double bdf2_factor = (use_bdf2_scheme)? ((2*time_step + old_time_step) /
+                                                     (time_step + old_time_step)) : 1.0;
+
+      const bool advection_field_is_temperature = advection_field.is_temperature();
+      const unsigned int solution_component = advection_field.component_index(introspection);
+
+      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
+
+      Assert(advection_field.advection_method(introspection)
+             == Parameters<dim>::AdvectionFieldMethod::fem_field,
+             ExcMessage("The 'AdvectionSystem' assembler can only be executed for fields "
+                        "that use the advection method 'field'."));
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          // precompute the values of shape functions and their gradients.
+          // We only need to look up values of shape functions if they
+          // belong to 'our' component. They are zero otherwise anyway.
+          // Note that we later only look at the values that we do set here.
+          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
+            {
+              if (fe.system_to_component_index(i).first == solution_component)
+                {
+                  if (use_supg)
+                    scratch.laplacian_phi_field[i_advection] = trace(scratch.finite_element_values[solution_field].hessian (i,q));
+
+                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
+                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
+                  ++i_advection;
+                }
+              ++i;
+            }
+
+          const double density_c_P              =
+            ((advection_field_is_temperature)
+             ?
+             scratch.material_model_outputs.densities[q] *
+             scratch.material_model_outputs.specific_heat[q]
+             :
+             1.0);
+
+          AssertThrow (density_c_P >= 0,
+                       ExcMessage ("The product of density and c_P needs to be a "
+                                   "non-negative quantity."));
+
+          const double latent_heat_LHS =
+            ((advection_field_is_temperature)
+             ?
+             scratch.heating_model_outputs.lhs_latent_heat_terms[q]
+             :
+             0.0);
+          AssertThrow (density_c_P + latent_heat_LHS >= 0,
+                       ExcMessage ("The sum of density times c_P and the latent heat contribution "
+                                   "to the left hand side needs to be a non-negative quantity."));
+
+          const double gamma =
+            ((advection_field_is_temperature)
+             ?
+             scratch.heating_model_outputs.heating_source_terms[q]
+             :
+             0.0);
+
+          const double reaction_term =
+            ((advection_field_is_temperature)
+             ?
+             0.0
+             :
+             scratch.material_model_outputs.reaction_terms[q][advection_field.compositional_variable]);
+
+          const double field_term_for_rhs
+            = (use_bdf2_scheme ?
+               (scratch.old_field_values[q] *
+                (1 + time_step/old_time_step)
+                -
+                scratch.old_old_field_values[q] *
+                (time_step * time_step) /
+                (old_time_step * (time_step + old_time_step)))
+               :
+               scratch.old_field_values[q])
+              *
+              (density_c_P + latent_heat_LHS);
+
+          Tensor<1,dim> current_u = scratch.current_velocity_values[q];
+          // Subtract off the mesh velocity for ALE corrections if necessary
+          if (this->get_parameters().mesh_deformation_enabled)
+            current_u -= scratch.mesh_velocity_values[q];
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          // For the diffusion constant, use the larger of the physical
+          // and the artificial viscosity/conductivity/diffusion constant.
+          // One could also choose the sum of the two, but if the
+          // physical diffusion is larger than the artificial one,
+          // then (because the latter is chosen sufficiently large to
+          // make the problem stable) one may as well stick with the
+          // physical one. And if the physical diffusion is too small to
+          // make the problem stable, then we ought to choose the smallest
+          // diffusivity value that makes the problem stable -- which is
+          // exactly the artificial viscosity.
+          const double conductivity = (advection_field_is_temperature
+                                       ?
+                                       scratch.material_model_outputs.thermal_conductivities[q]
+                                       :
+                                       0.0);
+
+          const double diffusion_constant = (use_supg)
+                                            ?
+                                            conductivity
+                                            :
+                                            std::max (conductivity, scratch.artificial_viscosity);
+
+          const double tau = (use_supg) ? scratch.artificial_viscosity : 0.0;
+
+          // do the actual assembly. note that we only need to loop over the advection
+          // shape functions because these are the only contributions we compute here
+          for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i)
+              += (field_term_for_rhs * scratch.phi_field[i]
+                  + time_step *
+                  scratch.phi_field[i]
+                  * gamma
+                  + scratch.phi_field[i]
+                  * reaction_term)
+                 *
+                 JxW;
+
+              if (use_supg)
+                data.local_rhs(i)
+                += tau *
+                   (
+                     (current_u * (density_c_P + latent_heat_LHS)) *
+                     scratch.grad_phi_field[i] *
+                     (
+                       field_term_for_rhs
+                       +
+                       time_step * gamma
+                       +
+                       reaction_term
+                     )
+                   ) * JxW;
+
+
+              for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                {
+                  data.local_matrix(i,j)
+                  += (
+                       (time_step * diffusion_constant
+                        * (scratch.grad_phi_field[i] * scratch.grad_phi_field[j]))
+                       + ((time_step * (scratch.phi_field[i] * (current_u * scratch.grad_phi_field[j])))
+                          + (bdf2_factor * scratch.phi_field[i] * scratch.phi_field[j])) *
+                       (density_c_P + latent_heat_LHS)
+                     )
+                     * JxW;
+                }
+
+              if (use_supg)
+                {
+                  for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                    {
+                      // Note that we assume that the conductivity is constant, otherwise we would need to
+                      // compute div (kappa grad T), which we don't have access to.
+                      data.local_matrix(i,j)
+                      += tau *
+                         (
+                           (current_u * (density_c_P + latent_heat_LHS)) *
+                           scratch.grad_phi_field[i] *
+                           (
+                             -time_step * conductivity * scratch.laplacian_phi_field[j]
+                             +
+                             (
+                               (time_step * current_u * scratch.grad_phi_field[j])
+                               +
+                               (bdf2_factor * scratch.phi_field[j])
+                             ) *
+                             (density_c_P + latent_heat_LHS)
+                           )
+                         ) * JxW;
+                    }
+                }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    AdvectionSystem<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      std::vector<double> residuals(n_q_points);
+
+      if (advection_field.is_temperature())
+        this->get_heating_model_manager().evaluate(scratch.material_model_inputs,
+                                                   scratch.material_model_outputs,
+                                                   scratch.heating_model_outputs);
+
+      for (unsigned int q=0; q < n_q_points; ++q)
+        {
+          const Tensor<1,dim> u = (scratch.old_velocity_values[q] +
+                                   scratch.old_old_velocity_values[q]) / 2;
+
+          const double dField_dt = (this->get_old_timestep() == 0.0) ? 0.0 :
+                                   (
+                                     ((scratch.old_field_values)[q] - (scratch.old_old_field_values)[q])
+                                     / this->get_old_timestep());
+          const double u_grad_field = u * (scratch.old_field_grads[q] +
+                                           scratch.old_old_field_grads[q]) / 2;
+
+          if (advection_field.is_temperature())
+            {
+              const double density       = scratch.material_model_outputs.densities[q];
+              const double conductivity  = scratch.material_model_outputs.thermal_conductivities[q];
+              const double c_P           = scratch.material_model_outputs.specific_heat[q];
+              // Note that we assume that the conductivity is constant, otherwise we would need to
+              // compute div (kappa grad T), which we don't have access to.
+              const double k_Delta_field = conductivity * (scratch.old_field_laplacians[q] +
+                                                           scratch.old_old_field_laplacians[q]) / 2;
+
+              const double gamma           = scratch.heating_model_outputs.heating_source_terms[q];
+              const double latent_heat_LHS = scratch.heating_model_outputs.lhs_latent_heat_terms[q];
+
+              residuals[q]
+                = std::abs((density * c_P + latent_heat_LHS) * (dField_dt + u_grad_field) - k_Delta_field - gamma);
+            }
+          else
+            {
+              const double dreaction_term_dt = (this->get_old_timestep() == 0) ? 0.0 :
+                                               scratch.material_model_outputs.reaction_terms[q][advection_field.compositional_variable]
+                                               / this->get_old_timestep();
+
+              residuals[q] = std::abs(dField_dt + u_grad_field - dreaction_term_dt);
+            }
+        }
+      return residuals;
+    }
+
+
+
+    template <int dim>
+    void
+    DiffusionSystem<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                                   internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
+
+      const Parameters<dim> &parameters = this->get_parameters();
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+
+      Assert(advection_field.advection_method(introspection)
+             == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion,
+             ExcMessage("The 'DiffusionSystem' assembler can only be executed for fields "
+                        "that use the advection method 'prescribed field with diffusion'."));
+
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
+
+      const unsigned int solution_component = advection_field.component_index(introspection);
+      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          // precompute the values of shape functions and their gradients.
+          // We only need to look up values of shape functions if they
+          // belong to 'our' component. They are zero otherwise anyway.
+          // Note that we later only look at the values that we do set here.
+          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
+            {
+              if (fe.system_to_component_index(i).first == solution_component)
+                {
+                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
+                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
+                  ++i_advection;
+                }
+              ++i;
+            }
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          // do the actual assembly. note that we only need to loop over the advection
+          // shape functions because these are the only contributions we compute here
+          for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i)
+              += scratch.old_field_values[q] * scratch.phi_field[i]
+                 *
+                 JxW;
+
+              for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                {
+                  data.local_matrix(i,j)
+                  += (parameters.diffusion_length_scale * parameters.diffusion_length_scale *
+                      (scratch.grad_phi_field[i] * scratch.grad_phi_field[j])
+                      + (scratch.phi_field[i] * scratch.phi_field[j])
+                     )
+                     * JxW;
+                }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    DiffusionSystem<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+      std::vector<double> residuals(scratch.finite_element_values.n_quadrature_points, 0.0);
+
+      return residuals;
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    DiffusionSystem<dim>::advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+      return std::vector<double> (scratch.material_model_inputs.n_evaluation_points(), 0.0);
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    DiffusionSystem<dim>::diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+
+      const double prefactor = this->get_timestep() > 0
+                               ?
+                               this->get_parameters().diffusion_length_scale
+                               * this->get_parameters().diffusion_length_scale
+                               / this->get_timestep()
+                               :
+                               0.0;
+
+      return std::vector<double> (scratch.material_model_inputs.n_evaluation_points(), prefactor);
+    }
+
+
+
+    template <int dim>
+    void
+    AdvectionSystemBoundaryHeatFlux<dim>::execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                                                  internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+
+      if (!advection_field.is_temperature())
+        return;
+
+      const unsigned int face_no = scratch.face_number;
+      const typename DoFHandler<dim>::face_iterator face = scratch.cell->face(face_no);
+
+      const unsigned int n_face_q_points    = scratch.face_finite_element_values->n_quadrature_points;
+      const double time_step = this->get_timestep();
+
+      // also have the number of dofs that correspond just to the element for
+      // the system we are currently trying to assemble
+      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
+
+      Assert (advection_dofs_per_cell < scratch.face_finite_element_values->get_fe().dofs_per_cell, ExcInternalError());
+      Assert (scratch.face_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
+
+      const unsigned int solution_component = advection_field.component_index(introspection);
+      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
+
+      if (this->get_fixed_heat_flux_boundary_indicators().find(face->boundary_id())
+          != this->get_fixed_heat_flux_boundary_indicators().end())
+        {
+          // We are in the case of a Neumann temperature boundary.
+          // Impose the Neumann value weakly using a RHS term.
+
+          std::vector<Tensor<1,dim>> heat_flux(n_face_q_points);
+          heat_flux = this->get_boundary_heat_flux().heat_flux(
+                        face->boundary_id(),
+                        scratch.face_material_model_inputs,
+                        scratch.face_material_model_outputs,
+                        scratch.face_finite_element_values->get_normal_vectors()
+                      );
+
+          for (unsigned int q=0; q<n_face_q_points; ++q)
+            {
+              // precompute the values of shape functions.
+              // We only need to look up values of shape functions if they
+              // belong to 'our' component. They are zero otherwise anyway.
+              // Note that we later only look at the values that we do set here.
+              for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
+                {
+                  if (fe.system_to_component_index(i).first == solution_component)
+                    {
+                      scratch.face_phi_field[i_advection]      = (*scratch.face_finite_element_values)[solution_field].value (i, q);
+                      ++i_advection;
+                    }
+                  ++i;
+                }
+
+              for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+                {
+                  data.local_rhs(i)
+                  -= time_step * scratch.face_phi_field[i] *
+                     (heat_flux[q] * scratch.face_finite_element_values->normal_vector(q))
+                     *
+                     scratch.face_finite_element_values->JxW(q);
+                }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    DarcySystem<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      MeltHandler<dim>::create_material_model_outputs(outputs);
+    }
+
+    template <int dim>
+    void
+    DarcySystem<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                               internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>& > (scratch_base);
+      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>& > (data_base);
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+
+      Assert(advection_field.advection_method(introspection)
+             == Parameters<dim>::AdvectionFieldMethod::fem_darcy_field,
+             ExcMessage("The 'DarcySystem' assembler can only be executed for fields "
+                        "that use the advection method 'darcy field'."));
+
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
+
+      const bool use_supg = (this->get_parameters().advection_stabilization_method
+                             == Parameters<dim>::AdvectionStabilizationMethod::supg);
+      AssertThrow(use_supg == false,
+                  ExcMessage("The Darcy field advection method does not support the use of SUPG"));
+
+      const bool   use_bdf2_scheme = (this->get_timestep_number() > 1);
+      const double time_step = this->get_timestep();
+      const double old_time_step = this->get_old_timestep();
+
+      const double bdf2_factor = (use_bdf2_scheme)? ((2*time_step + old_time_step) /
+                                                     (time_step + old_time_step)) : 1.0;
+      const unsigned int solution_component = advection_field.component_index(introspection);
+      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
+      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          // precompute the values of shape functions and their gradients.
+          // We only need to look up values of shape functions if they
+          // belong to 'our' component. They are zero otherwise anyway.
+          // Note that we later only look at the values that we do set here.
+          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
+            {
+              if (fe.system_to_component_index(i).first == solution_component)
+                {
+                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
+                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
+                  ++i_advection;
+                }
+              ++i;
+            }
+
+          const double reaction_term = scratch.material_model_outputs.reaction_terms[q][advection_field.compositional_variable];
+
+          const double field_term_for_rhs
+            = (use_bdf2_scheme ?
+               (scratch.old_field_values[q] *
+                (1 + time_step/old_time_step)
+                -
+                scratch.old_old_field_values[q] *
+                (time_step * time_step) /
+                (old_time_step * (time_step + old_time_step)))
+               :
+               scratch.old_field_values[q]);
+
+
+          // We calculate the fluid velocity current_u_f using an approximation of Darcy's Law:
+          // u_f = u_s - K_D / phi * (rho_s * g - rho_f * g)
+          // u_f = fluid velocity
+          // u_s = solid velocity
+          // K_D = Darcy Coefficient
+          // phi = porosity
+          // rho_f = fluid density
+          // rhos_s = solid density
+          // g = gravity
+          // The second term on the rhs of Darcy's Law only contributes to the component of the
+          // fluid velocity parallel to the gravity vector, which is proportional to the
+          // buoyancy of the fluid phase.
+          const double rho_s = scratch.material_model_outputs.densities[q];
+          const double rho_f = melt_outputs->fluid_densities[q];
+          const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+          const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
+          const double porosity         = std::max(scratch.material_model_inputs.composition[q][porosity_index],1e-10);
+          const double K_D = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q] / porosity;
+          const Tensor<1,dim> current_u = scratch.current_velocity_values[q];
+          Tensor<1,dim> current_u_f = current_u - K_D * (rho_s - rho_f) * gravity;
+
+          // Subtract off the mesh velocity for ALE corrections if necessary
+          if (this->get_parameters().mesh_deformation_enabled)
+            current_u_f -= scratch.mesh_velocity_values[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          // do the actual assembly. note that we only need to loop over the advection
+          // shape functions because these are the only contributions we compute here
+          for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i)
+              += (field_term_for_rhs * scratch.phi_field[i]
+                  + scratch.phi_field[i]
+                  * reaction_term)
+                 * JxW;
+
+              for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                {
+                  data.local_matrix(i,j)
+                  += (
+                       (time_step * scratch.artificial_viscosity
+                        * (scratch.grad_phi_field[i] * scratch.grad_phi_field[j]))
+                       + ((time_step * (scratch.phi_field[i] * (current_u_f * scratch.grad_phi_field[j])))
+                          + (bdf2_factor * scratch.phi_field[i] * scratch.phi_field[j]))
+                     )
+                     * JxW;
+                }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    DarcySystem<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>& > (scratch_base);
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      const Introspection<dim> &introspection = this->introspection();
+      std::vector<double> residuals(n_q_points);
+      if (advection_field.is_temperature())
+        {
+          return residuals;
+        }
+
+
+      const MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+      for (unsigned int q=0; q < n_q_points; ++q)
+        {
+
+          const double K_D = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q];
+          const double rho_s = scratch.material_model_outputs.densities[q];
+          const double rho_f = melt_outputs->fluid_densities[q];
+          const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
+          const double porosity         = std::max(scratch.material_model_inputs.composition[q][porosity_index], 1e-10);
+          const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+
+          const Tensor<1,dim> u = (scratch.old_velocity_values[q] +
+                                   scratch.old_old_velocity_values[q]) / 2
+                                  - K_D*(rho_s - rho_f)*gravity/porosity;
+
+          const double dField_dt = (this->get_old_timestep() == 0.0) ? 0.0 :
+                                   (
+                                     ((scratch.old_field_values)[q] - (scratch.old_old_field_values)[q])
+                                     / this->get_old_timestep());
+          const double u_grad_field = u * (scratch.old_field_grads[q] +
+                                           scratch.old_old_field_grads[q]) / 2;
+
+          const double dreaction_term_dt = (this->get_old_timestep() == 0) ? 0.0 :
+                                           scratch.material_model_outputs.reaction_terms[q][advection_field.compositional_variable]
+                                           / this->get_old_timestep();
+
+          residuals[q] = std::abs(dField_dt + u_grad_field - dreaction_term_dt);
+        }
+      return residuals;
+    }
+
+
+
+    template <int dim>
+    void
+    AdvectionSystemBoundaryFace<dim>::execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                                              internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
+
+      const Parameters<dim> &parameters = this->get_parameters();
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+
+      const unsigned int face_no = scratch.face_number;
+      const typename DoFHandler<dim>::face_iterator face = scratch.cell->face(face_no);
+
+      const unsigned int n_q_points    = scratch.face_finite_element_values->n_quadrature_points;
+
+      const double time_step = this->get_timestep();
+
+      Assert(advection_field.is_discontinuous(introspection)
+             && advection_field.advection_method(introspection)
+             == Parameters<dim>::AdvectionFieldMethod::fem_field,
+             ExcMessage("The 'AdvectionSystemBoundaryFace' assembler can only be executed for fields "
+                        "that use the advection method 'field' and a discontinuous discretization."));
+
+      // also have the number of dofs that correspond just to the element for
+      // the system we are currently trying to assemble
+      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
+
+      Assert (advection_dofs_per_cell < scratch.face_finite_element_values->get_fe().dofs_per_cell, ExcInternalError());
+      Assert (scratch.face_grad_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
+      Assert (scratch.face_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
+
+      const unsigned int solution_component = advection_field.component_index(introspection);
+
+      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
+
+
+      if (((this->get_fixed_temperature_boundary_indicators().find(
+              face->boundary_id()
+            )
+            != this->get_fixed_temperature_boundary_indicators().end())
+           && (advection_field.is_temperature()))
+          ||
+          (( this->get_fixed_composition_boundary_indicators().find(
+               face->boundary_id()
+             )
+             != this->get_fixed_composition_boundary_indicators().end())
+           && (!advection_field.is_temperature())))
+        {
+          /*
+           * We are in the case of a Dirichlet temperature or composition boundary.
+           * In the temperature case, impose the Dirichlet value weakly using a matrix term
+           * and RHS term. In the composition case, Dirichlet conditions can only be imposed
+           * on inflow boundaries, and we only have the flow-dependent terms, so we only
+           * assemble the corresponding flow-dependent and matrix and RHS terms
+           * if we are on an inflow boundary.
+           */
+
+          for (unsigned int q=0; q<n_q_points; ++q)
+            {
+              // precompute the values of shape functions and their gradients.
+              // We only need to look up values of shape functions if they
+              // belong to 'our' component. They are zero otherwise anyway.
+              // Note that we later only look at the values that we do set here.
+              for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
+                {
+                  if (fe.system_to_component_index(i).first == solution_component)
+                    {
+                      scratch.face_grad_phi_field[i_advection] = (*scratch.face_finite_element_values)[solution_field].gradient (i, q);
+                      scratch.face_phi_field[i_advection]      = (*scratch.face_finite_element_values)[solution_field].value (i, q);
+                      ++i_advection;
+                    }
+                  ++i;
+                }
+
+              const double density_c_P              =
+                ((advection_field.is_temperature())
+                 ?
+                 scratch.face_material_model_outputs.densities[q] *
+                 scratch.face_material_model_outputs.specific_heat[q]
+                 :
+                 1.0);
+
+              AssertThrow (density_c_P >= 0,
+                           ExcMessage ("The product of density and c_P needs to be a "
+                                       "non-negative quantity."));
+
+              const double conductivity =
+                ((advection_field.is_temperature())
+                 ?
+                 scratch.face_material_model_outputs.thermal_conductivities[q]
+                 :
+                 0.0);
+              const double latent_heat_LHS =
+                ((advection_field.is_temperature())
+                 ?
+                 scratch.face_heating_model_outputs.lhs_latent_heat_terms[q]
+                 :
+                 0.0);
+              AssertThrow (density_c_P + latent_heat_LHS >= 0,
+                           ExcMessage ("The sum of density times c_P and the latent heat contribution "
+                                       "to the left hand side needs to be a non-negative quantity."));
+
+              const double penalty = (advection_field.is_temperature()
+                                      ?
+                                      parameters.discontinuous_penalty
+                                      * parameters.temperature_degree
+                                      * parameters.temperature_degree
+                                      / approximate_face_measure(face)
+                                      * conductivity
+                                      / (density_c_P + latent_heat_LHS)
+                                      :
+                                      0.0);
+
+              const double dirichlet_value = (advection_field.is_temperature()
+                                              ?
+                                              this->get_boundary_temperature_manager().boundary_temperature(
+                                                face->boundary_id(),
+                                                scratch.face_finite_element_values->quadrature_point(q))
+                                              :
+                                              this->get_boundary_composition_manager().boundary_composition(
+                                                face->boundary_id(),
+                                                scratch.face_finite_element_values->quadrature_point(q),
+                                                advection_field.compositional_variable));
+
+              Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
+              // Subtract off the mesh velocity for ALE corrections if necessary
+              if (parameters.mesh_deformation_enabled)
+                current_u -= scratch.face_mesh_velocity_values[q];
+
+              /**
+               * The discontinuous Galerkin method uses 2 types of jumps over edges:
+               * undirected and directed jumps. Undirected jumps are dependent only
+               * on the order of the numbering of cells. Directed jumps are dependent
+               * on the direction of the flow. Thus the flow-dependent terms below are
+               * only calculated if the edge is an inflow edge.
+               */
+              const bool inflow = ((current_u * scratch.face_finite_element_values->normal_vector(q)) < 0.);
+
+              for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+                {
+                  data.local_rhs(i)
+                  += (- time_step *  conductivity
+                      * scratch.face_grad_phi_field[i]
+                      * scratch.face_finite_element_values->normal_vector(q)
+                      * dirichlet_value
+
+                      + time_step
+                      * (density_c_P + latent_heat_LHS)
+                      * penalty
+                      * scratch.face_phi_field[i]
+                      * dirichlet_value
+
+                      + (inflow
+                         ?
+                         - (density_c_P + latent_heat_LHS)
+                         * time_step
+                         * (current_u
+                            * scratch.face_finite_element_values->normal_vector(q))
+                         * dirichlet_value
+                         * scratch.face_phi_field[i]
+                         :
+                         0.)
+                     )
+                     *
+                     scratch.face_finite_element_values->JxW(q);
+
+                  // local_matrix terms
+                  for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                    {
+                      data.local_matrix(i,j)
+                      += (- time_step *  conductivity
+                          * scratch.face_grad_phi_field[i]
+                          * scratch.face_finite_element_values->normal_vector(q)
+                          * scratch.face_phi_field[j]
+
+                          - time_step *  conductivity
+                          * scratch.face_grad_phi_field[j]
+                          * scratch.face_finite_element_values->normal_vector(q)
+                          * scratch.face_phi_field[i]
+
+                          + time_step
+                          * (density_c_P + latent_heat_LHS)
+                          * penalty
+                          * scratch.face_phi_field[i]
+                          * scratch.face_phi_field[j]
+
+                          + (inflow
+                             ?
+                             - (density_c_P + latent_heat_LHS)
+                             * time_step
+                             * (current_u
+                                * scratch.face_finite_element_values->normal_vector(q))
+                             * scratch.face_phi_field[i]
+                             * scratch.face_phi_field[j]
+                             :
+                             0.)
+                         )
+                         * scratch.face_finite_element_values->JxW(q);
+                    }
+                }
+            }
+        }
+      else
+        {
+          // Neumann temperature term - no non-zero contribution as only homogeneous Neumann boundary conditions are implemented elsewhere for temperature
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    AdvectionSystemInteriorFace<dim>::execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                                              internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
+
+      const Parameters<dim> &parameters = this->get_parameters();
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const typename DoFHandler<dim>::active_cell_iterator cell = scratch.cell;
+      const unsigned int face_no = scratch.face_number;
+      const typename DoFHandler<dim>::face_iterator face = cell->face(face_no);
+
+      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
+
+      const unsigned int n_q_points    = scratch.face_finite_element_values->n_quadrature_points;
+
+      const double time_step = this->get_timestep();
+
+      if (!advection_field.is_discontinuous(introspection))
+        return;
+
+      // also have the number of dofs that correspond just to the element for
+      // the system we are currently trying to assemble
+      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int dofs_per_cell = fe.dofs_per_cell;
+
+      Assert (advection_dofs_per_cell < scratch.face_finite_element_values->get_fe().dofs_per_cell, ExcInternalError());
+      Assert (scratch.face_grad_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
+      Assert (scratch.face_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
+      Assert (n_q_points == scratch.subface_finite_element_values->n_quadrature_points, ExcInternalError());
+      Assert (n_q_points == scratch.neighbor_face_finite_element_values->n_quadrature_points, ExcInternalError());
+
+      const unsigned int solution_component = advection_field.component_index(introspection);
+
+      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
+
+      // interior face or periodic face - no contribution on RHS
+
+      const typename DoFHandler<dim>::cell_iterator
+      neighbor = cell->neighbor_or_periodic_neighbor (face_no);
+      // note: "neighbor" defined above is NOT active_cell_iterator, so this includes cells that are refined
+      // for example: cell with periodic boundary.
+      Assert (neighbor.state() == IteratorState::valid,
+              ExcInternalError());
+      const bool cell_has_periodic_neighbor = cell->has_periodic_neighbor (face_no);
+
+      if (!neighbor->has_children())
+        {
+          if (neighbor->level () == cell->level () &&
+              neighbor->is_active() &&
+              (((neighbor->is_locally_owned()) && (cell->index() < neighbor->index()))
+               ||
+               ((!neighbor->is_locally_owned()) && (cell->subdomain_id() < neighbor->subdomain_id()))))
+            {
+              Assert (cell->is_locally_owned(), ExcInternalError());
+              // cell and neighbor are equal-sized, and cell has been chosen to assemble this face, so calculate from cell
+
+              const unsigned int neighbor2 =
+                (cell->has_periodic_neighbor(face_no)
+                 ?
+                 // how does the periodic neighbor talk about this cell?
+                 cell->periodic_neighbor_of_periodic_neighbor( face_no )
+                 :
+                 // how does the neighbor talk about this cell?
+                 cell->neighbor_of_neighbor(face_no));
+
+              // set up neighbor values
+              scratch.neighbor_face_finite_element_values->reinit (neighbor, neighbor2);
+
+              scratch.neighbor_face_material_model_inputs.reinit  (*scratch.neighbor_face_finite_element_values,
+                                                                   neighbor,
+                                                                   this->introspection(),
+                                                                   this->get_current_linearization_point());
+
+              this->create_additional_material_model_outputs(scratch.neighbor_face_material_model_outputs);
+              this->get_heating_model_manager().create_additional_material_model_inputs_and_outputs(scratch.neighbor_face_material_model_inputs,
+                  scratch.neighbor_face_material_model_outputs);
+
+              this->get_material_model().fill_additional_material_model_inputs(scratch.neighbor_face_material_model_inputs,
+                                                                               this->get_current_linearization_point(),
+                                                                               *scratch.neighbor_face_finite_element_values,
+                                                                               this->introspection());
+
+              this->get_material_model().evaluate(scratch.neighbor_face_material_model_inputs,
+                                                  scratch.neighbor_face_material_model_outputs);
+
+              if (parameters.formulation_temperature_equation ==
+                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+                {
+                  for (unsigned int q=0; q<n_q_points; ++q)
+                    {
+                      scratch.neighbor_face_material_model_outputs.densities[q] = this->get_adiabatic_conditions().density(scratch.neighbor_face_material_model_inputs.position[q]);
+                    }
+                }
+
+              this->get_heating_model_manager().evaluate(scratch.neighbor_face_material_model_inputs,
+                                                         scratch.neighbor_face_material_model_outputs,
+                                                         scratch.neighbor_face_heating_model_outputs);
+
+              std::vector<types::global_dof_index> neighbor_dof_indices (dofs_per_cell);
+              // get all dof indices on the neighbor, then extract those
+              // that correspond to the solution_field we are interested in
+              neighbor->get_dof_indices (neighbor_dof_indices);
+              for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
+                {
+                  if (fe.system_to_component_index(i).first == solution_component)
+                    {
+                      data.neighbor_dof_indices[nth_interface_matrix(fe.reference_cell(), face_no)][i_advection] = neighbor_dof_indices[i];
+                      ++i_advection;
+                    }
+                  ++i;
+                }
+              data.assembled_matrices[nth_interface_matrix(fe.reference_cell(), face_no)] = true;
+
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  // precompute the values of shape functions and their gradients.
+                  // We only need to look up values of shape functions if they
+                  // belong to 'our' component. They are zero otherwise anyway.
+                  // Note that we later only look at the values that we do set here.
+                  for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
+                    {
+                      if (fe.system_to_component_index(i).first == solution_component)
+                        {
+                          scratch.face_grad_phi_field[i_advection]          = (*scratch.face_finite_element_values)[solution_field].gradient (i, q);
+                          scratch.face_phi_field[i_advection]               = (*scratch.face_finite_element_values)[solution_field].value (i, q);
+                          scratch.neighbor_face_grad_phi_field[i_advection] = (*scratch.neighbor_face_finite_element_values)[solution_field].gradient (i, q);
+                          scratch.neighbor_face_phi_field[i_advection]      = (*scratch.neighbor_face_finite_element_values)[solution_field].value (i, q);
+                          ++i_advection;
+                        }
+                      ++i;
+                    }
+
+                  const double density_c_P              =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.face_material_model_outputs.densities[q] *
+                     scratch.face_material_model_outputs.specific_heat[q]
+                     :
+                     1.0);
+
+                  AssertThrow (density_c_P >= 0,
+                               ExcMessage ("The product of density and c_P needs to be a "
+                                           "non-negative quantity."));
+
+                  const double conductivity =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.face_material_model_outputs.thermal_conductivities[q]
+                     :
+                     0.0);
+                  const double latent_heat_LHS =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.face_heating_model_outputs.lhs_latent_heat_terms[q]
+                     :
+                     0.0);
+                  AssertThrow (density_c_P + latent_heat_LHS >= 0,
+                               ExcMessage ("The sum of density times c_P and the latent heat contribution "
+                                           "to the left hand side needs to be a non-negative quantity."));
+
+                  const double penalty = (advection_field.is_temperature()
+                                          ?
+                                          parameters.discontinuous_penalty
+                                          * parameters.temperature_degree
+                                          * parameters.temperature_degree
+                                          / approximate_face_measure(face)
+                                          * conductivity
+                                          / (density_c_P + latent_heat_LHS)
+                                          :
+                                          0.0);
+
+                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
+                  // Subtract off the mesh velocity for ALE corrections if necessary
+                  if (parameters.mesh_deformation_enabled)
+                    current_u -= scratch.face_mesh_velocity_values[q];
+
+                  const double neighbor_density_c_P              =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.neighbor_face_material_model_outputs.densities[q] *
+                     scratch.neighbor_face_material_model_outputs.specific_heat[q]
+                     :
+                     1.0);
+
+                  AssertThrow (neighbor_density_c_P >= 0,
+                               ExcMessage ("The product of density and c_P on the neighbor needs to be a "
+                                           "non-negative quantity."));
+
+                  const double neighbor_conductivity =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.neighbor_face_material_model_outputs.thermal_conductivities[q]
+                     :
+                     0.0);
+                  const double neighbor_latent_heat_LHS =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.neighbor_face_heating_model_outputs.lhs_latent_heat_terms[q]
+                     :
+                     0.0);
+                  AssertThrow (neighbor_density_c_P + neighbor_latent_heat_LHS >= 0,
+                               ExcMessage ("The sum of density times c_P and the latent heat contribution "
+                                           "to the left hand side on the neighbor needs to be a non-negative quantity."));
+
+                  const double neighbor_penalty = (advection_field.is_temperature()
+                                                   ?
+                                                   parameters.discontinuous_penalty
+                                                   * parameters.temperature_degree
+                                                   * parameters.temperature_degree
+                                                   / approximate_face_measure(neighbor->face(neighbor2))
+                                                   * neighbor_conductivity
+                                                   / (neighbor_density_c_P + neighbor_latent_heat_LHS)
+                                                   :
+                                                   0.0);
+
+                  const double max_penalty = std::max(penalty, neighbor_penalty);
+
+                  const double max_density_c_P_and_latent_heat =
+                    std::max(density_c_P + latent_heat_LHS,
+                             neighbor_density_c_P + neighbor_latent_heat_LHS);
+
+                  AssertThrow (numbers::is_finite(max_density_c_P_and_latent_heat),
+                               ExcMessage ("The maximum product of density and c_P plus latent heat LHS on the neighbor needs to be a finite quantity."));
+                  AssertThrow (max_density_c_P_and_latent_heat >= 0,
+                               ExcMessage ("The maximum product of density and c_P plus latent heat LHS on the neighbor needs to be a "
+                                           "non-negative quantity."));
+
+                  /**
+                   * The discontinuous Galerkin method uses 2 types of jumps over edges:
+                   * undirected and directed jumps. Undirected jumps are dependent only
+                   * on the order of the numbering of cells. Directed jumps are dependent
+                   * on the direction of the flow. Thus the flow-dependent terms below are
+                   * only calculated if the edge is an inflow edge.
+                   */
+                  const bool inflow = ((current_u * scratch.face_finite_element_values->normal_vector(q)) < 0.);
+
+                  for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+                    {
+                      for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                        {
+                          data.local_matrix(i,j)
+                          += (- 0.5 * time_step * conductivity
+                              * scratch.face_grad_phi_field[i]
+                              * scratch.face_finite_element_values->normal_vector(q)
+                              * scratch.face_phi_field[j]
+
+                              - 0.5 * time_step * conductivity
+                              * scratch.face_grad_phi_field[j]
+                              * scratch.face_finite_element_values->normal_vector(q)
+                              * scratch.face_phi_field[i]
+
+                              + time_step
+                              * max_density_c_P_and_latent_heat
+                              * max_penalty
+                              * scratch.face_phi_field[i]
+                              * scratch.face_phi_field[j]
+
+                              - (inflow
+                                 ?
+                                 (density_c_P + latent_heat_LHS)
+                                 * time_step
+                                 * (current_u
+                                    * scratch.face_finite_element_values->normal_vector(q))
+                                 * scratch.face_phi_field[i]
+                                 * scratch.face_phi_field[j]
+                                 :
+                                 0.)
+                             )
+                             * scratch.face_finite_element_values->JxW(q);
+
+                          data.local_matrices_int_ext[nth_interface_matrix(fe.reference_cell(), face_no)](i,j)
+                          += (- 0.5 * time_step * neighbor_conductivity
+                              * scratch.neighbor_face_grad_phi_field[j]
+                              * scratch.face_finite_element_values->normal_vector(q)
+                              * scratch.face_phi_field[i]
+
+                              + 0.5 * time_step * conductivity
+                              * scratch.face_grad_phi_field[i]
+                              * scratch.face_finite_element_values->normal_vector(q)
+                              * scratch.neighbor_face_phi_field[j]
+
+                              - time_step
+                              * max_density_c_P_and_latent_heat
+                              * max_penalty
+                              * scratch.neighbor_face_phi_field[j]
+                              * scratch.face_phi_field[i]
+
+                              + (inflow
+                                 ?
+                                 (density_c_P + latent_heat_LHS)
+                                 * time_step
+                                 * (current_u
+                                    * scratch.face_finite_element_values->normal_vector(q))
+                                 * scratch.face_phi_field[i]
+                                 * scratch.neighbor_face_phi_field[j]
+                                 :
+                                 0.)
+                             )
+                             * scratch.face_finite_element_values->JxW(q);
+
+                          data.local_matrices_ext_int[nth_interface_matrix(fe.reference_cell(), face_no)](i,j)
+                          += (+ 0.5 * time_step * conductivity
+                              * scratch.face_grad_phi_field[j]
+                              * scratch.face_finite_element_values->normal_vector(q)
+                              * scratch.neighbor_face_phi_field[i]
+
+                              - 0.5 * time_step * neighbor_conductivity
+                              * scratch.neighbor_face_grad_phi_field[i]
+                              * scratch.face_finite_element_values->normal_vector(q)
+                              * scratch.face_phi_field[j]
+
+                              - time_step
+                              * max_density_c_P_and_latent_heat
+                              * max_penalty
+                              * scratch.face_phi_field[j]
+                              * scratch.neighbor_face_phi_field[i]
+
+                              - (!inflow
+                                 ?
+                                 (neighbor_density_c_P + neighbor_latent_heat_LHS)
+                                 * time_step
+                                 * (current_u
+                                    * scratch.face_finite_element_values->normal_vector(q))
+                                 * scratch.neighbor_face_phi_field[i]
+                                 * scratch.face_phi_field[j]
+                                 :
+                                 0.)
+                             )
+                             * scratch.face_finite_element_values->JxW(q);
+
+                          data.local_matrices_ext_ext[nth_interface_matrix(fe.reference_cell(), face_no)](i,j)
+                          += (+ 0.5 * time_step * neighbor_conductivity
+                              * scratch.neighbor_face_grad_phi_field[i]
+                              * scratch.face_finite_element_values->normal_vector(q)
+                              * scratch.neighbor_face_phi_field[j]
+
+                              + 0.5 * time_step * neighbor_conductivity
+                              * scratch.neighbor_face_grad_phi_field[j]
+                              * scratch.face_finite_element_values->normal_vector(q)
+                              * scratch.neighbor_face_phi_field[i]
+
+                              + time_step
+                              * max_density_c_P_and_latent_heat
+                              * max_penalty
+                              * scratch.neighbor_face_phi_field[i]
+                              * scratch.neighbor_face_phi_field[j]
+
+                              + (!inflow
+                                 ?
+                                 (neighbor_density_c_P + neighbor_latent_heat_LHS)
+                                 * time_step
+                                 * (current_u
+                                    * scratch.face_finite_element_values->normal_vector(q))
+                                 * scratch.neighbor_face_phi_field[i]
+                                 * scratch.neighbor_face_phi_field[j]
+                                 :
+                                 0.)
+                             )
+                             * scratch.face_finite_element_values->JxW(q);
+                        }
+                    }
+                }
+            }
+          else
+            {
+              /* neighbor is taking responsibility for assembly of this face, because
+               * either (1) neighbor is coarser, or
+               *        (2) neighbor is equally-sized and
+               *           (a) neighbor is on a different subdomain, with lower subdmain_id(), or
+               *           (b) neighbor is on the same subdomain and has lower index().
+              */
+            }
+        }
+      // neighbor has children, so always assemble from here.
+      else
+        {
+          const unsigned int neighbor2 =
+            (cell_has_periodic_neighbor
+             ?
+             cell->periodic_neighbor_face_no(face_no)
+             :
+             cell->neighbor_face_no(face_no));
+
+          // Loop over subfaces. We know that the neighbor is finer, so we could loop over the subfaces of the current
+          // face. but if we are at a periodic boundary, then the face of the current cell has no children, so instead use
+          // the children of the periodic neighbor's corresponding face since we know that the letter does indeed have
+          // children (because we know that the neighbor is refined).
+          typename DoFHandler<dim>::face_iterator neighbor_face=neighbor->face(neighbor2);
+          for (unsigned int subface_no=0; subface_no<neighbor_face->n_children(); ++subface_no)
+            {
+              const typename DoFHandler<dim>::active_cell_iterator neighbor_child
+                = ( cell_has_periodic_neighbor
+                    ?
+                    cell->periodic_neighbor_child_on_subface(face_no,subface_no)
+                    :
+                    cell->neighbor_child_on_subface (face_no, subface_no));
+
+              // set up subface values
+              scratch.subface_finite_element_values->reinit (cell, face_no, subface_no);
+
+              // subface->face
+              (*scratch.subface_finite_element_values)[introspection.extractors.velocities].get_function_values(this->get_current_linearization_point(),
+                  scratch.face_current_velocity_values);
+
+              // get the mesh velocity, as we need to subtract it off of the advection systems
+              if (parameters.mesh_deformation_enabled)
+                (*scratch.subface_finite_element_values)[introspection.extractors.velocities].get_function_values(this->get_mesh_velocity(),
+                    scratch.face_mesh_velocity_values);
+
+              scratch.face_material_model_inputs.reinit  (*scratch.subface_finite_element_values,
+                                                          cell,
+                                                          this->introspection(),
+                                                          this->get_current_linearization_point());
+              this->get_material_model().evaluate(scratch.face_material_model_inputs,
+                                                  scratch.face_material_model_outputs);
+
+              if (parameters.formulation_temperature_equation ==
+                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+                {
+                  for (unsigned int q=0; q<n_q_points; ++q)
+                    {
+                      scratch.face_material_model_outputs.densities[q] = this->get_adiabatic_conditions().density(scratch.face_material_model_inputs.position[q]);
+                    }
+                }
+
+              this->get_heating_model_manager().evaluate(scratch.face_material_model_inputs,
+                                                         scratch.face_material_model_outputs,
+                                                         scratch.face_heating_model_outputs);
+
+              // set up neighbor values
+              scratch.neighbor_face_finite_element_values->reinit (neighbor_child, neighbor2);
+
+              scratch.neighbor_face_material_model_inputs.reinit  (*scratch.neighbor_face_finite_element_values,
+                                                                   neighbor_child,
+                                                                   this->introspection(),
+                                                                   this->get_current_linearization_point());
+              this->get_material_model().evaluate(scratch.neighbor_face_material_model_inputs,
+                                                  scratch.neighbor_face_material_model_outputs);
+
+              if (parameters.formulation_temperature_equation ==
+                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+                {
+                  for (unsigned int q=0; q<n_q_points; ++q)
+                    {
+                      scratch.neighbor_face_material_model_outputs.densities[q] = this->get_adiabatic_conditions().density(scratch.neighbor_face_material_model_inputs.position[q]);
+                    }
+                }
+
+              this->get_heating_model_manager().evaluate(scratch.neighbor_face_material_model_inputs,
+                                                         scratch.neighbor_face_material_model_outputs,
+                                                         scratch.neighbor_face_heating_model_outputs);
+
+              std::vector<types::global_dof_index> neighbor_dof_indices (fe.dofs_per_cell);
+              // get all dof indices on the neighbor, then extract those
+              // that correspond to the solution_field we are interested in
+              neighbor_child->get_dof_indices (neighbor_dof_indices);
+              for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
+                {
+                  if (fe.system_to_component_index(i).first == solution_component)
+                    {
+                      data.neighbor_dof_indices[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)][i_advection] = neighbor_dof_indices[i];
+                      ++i_advection;
+                    }
+                  ++i;
+                }
+              data.assembled_matrices[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)] = true;
+
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  // precompute the values of shape functions and their gradients.
+                  // We only need to look up values of shape functions if they
+                  // belong to 'our' component. They are zero otherwise anyway.
+                  // Note that we later only look at the values that we do set here.
+                  for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
+                    {
+                      if (fe.system_to_component_index(i).first == solution_component)
+                        {
+                          scratch.face_grad_phi_field[i_advection]          = (*scratch.subface_finite_element_values)[solution_field].gradient (i, q);
+                          scratch.face_phi_field[i_advection]               = (*scratch.subface_finite_element_values)[solution_field].value (i, q);
+                          scratch.neighbor_face_grad_phi_field[i_advection] = (*scratch.neighbor_face_finite_element_values)[solution_field].gradient (i, q);
+                          scratch.neighbor_face_phi_field[i_advection]      = (*scratch.neighbor_face_finite_element_values)[solution_field].value (i, q);
+                          ++i_advection;
+                        }
+                      ++i;
+                    }
+
+                  const double density_c_P              =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.face_material_model_outputs.densities[q] *
+                     scratch.face_material_model_outputs.specific_heat[q]
+                     :
+                     1.0);
+
+                  AssertThrow (density_c_P >= 0,
+                               ExcMessage ("The product of density and c_P needs to be a "
+                                           "non-negative quantity."));
+
+                  const double conductivity =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.face_material_model_outputs.thermal_conductivities[q]
+                     :
+                     0.0);
+                  const double latent_heat_LHS =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.face_heating_model_outputs.lhs_latent_heat_terms[q]
+                     :
+                     0.0);
+                  AssertThrow (density_c_P + latent_heat_LHS >= 0,
+                               ExcMessage ("The sum of density times c_P and the latent heat contribution "
+                                           "to the left hand side needs to be a non-negative quantity."));
+
+                  const double penalty = (advection_field.is_temperature()
+                                          ?
+                                          parameters.discontinuous_penalty
+                                          * parameters.temperature_degree
+                                          * parameters.temperature_degree
+                                          / approximate_face_measure(face)
+                                          * conductivity
+                                          / (density_c_P + latent_heat_LHS)
+                                          :
+                                          0.0);
+
+                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
+                  // Subtract off the mesh velocity for ALE corrections if necessary
+                  if (parameters.mesh_deformation_enabled)
+                    current_u -= scratch.face_mesh_velocity_values[q];
+
+                  const double neighbor_density_c_P              =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.neighbor_face_material_model_outputs.densities[q] *
+                     scratch.neighbor_face_material_model_outputs.specific_heat[q]
+                     :
+                     1.0);
+
+                  AssertThrow (neighbor_density_c_P >= 0,
+                               ExcMessage ("The product of density and c_P on the neighbor needs to be a "
+                                           "non-negative quantity."));
+
+                  const double neighbor_conductivity =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.neighbor_face_material_model_outputs.thermal_conductivities[q]
+                     :
+                     0.0);
+                  const double neighbor_latent_heat_LHS =
+                    ((advection_field.is_temperature())
+                     ?
+                     scratch.neighbor_face_heating_model_outputs.lhs_latent_heat_terms[q]
+                     :
+                     0.0);
+                  AssertThrow (neighbor_density_c_P + neighbor_latent_heat_LHS >= 0,
+                               ExcMessage ("The sum of density times c_P and the latent heat contribution "
+                                           "to the left hand side on the neighbor needs to be a non-negative quantity."));
+
+                  const double neighbor_penalty = (advection_field.is_temperature()
+                                                   ?
+                                                   parameters.discontinuous_penalty
+                                                   * parameters.temperature_degree
+                                                   * parameters.temperature_degree
+                                                   / approximate_face_measure(neighbor_child->face(neighbor2))
+                                                   * neighbor_conductivity
+                                                   / (neighbor_density_c_P + neighbor_latent_heat_LHS)
+                                                   :
+                                                   0.0);
+
+                  const double max_penalty = std::max(penalty, neighbor_penalty);
+
+                  const double max_density_c_P_and_latent_heat =
+                    std::max(density_c_P + latent_heat_LHS,
+                             neighbor_density_c_P + neighbor_latent_heat_LHS);
+
+                  AssertThrow (numbers::is_finite(max_density_c_P_and_latent_heat),
+                               ExcMessage ("The maximum product of density and c_P plus latent heat LHS on the neighbor needs to be a finite quantity."));
+                  AssertThrow (max_density_c_P_and_latent_heat >= 0,
+                               ExcMessage ("The maximum product of density and c_P plus latent heat LHS on the neighbor needs to be a "
+                                           "non-negative quantity."));
+
+                  /**
+                   * The discontinuous Galerkin method uses 2 types of jumps over edges:
+                   * undirected and directed jumps. Undirected jumps are dependent only
+                   * on the order of the numbering of cells. Directed jumps are dependent
+                   * on the direction of the flow. Thus the flow-dependent terms below are
+                   * only calculated if the edge is an inflow edge.
+                   */
+                  const bool inflow = ((current_u * scratch.subface_finite_element_values->normal_vector(q)) < 0.);
+
+                  for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+                    {
+                      for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                        {
+                          data.local_matrix(i,j)
+                          += (- 0.5 * time_step * conductivity
+                              * scratch.face_grad_phi_field[i]
+                              * scratch.subface_finite_element_values->normal_vector(q)
+                              * scratch.face_phi_field[j]
+
+                              - 0.5 * time_step * conductivity
+                              * scratch.face_grad_phi_field[j]
+                              * scratch.subface_finite_element_values->normal_vector(q)
+                              * scratch.face_phi_field[i]
+
+                              + time_step
+                              * max_density_c_P_and_latent_heat
+                              * max_penalty
+                              * scratch.face_phi_field[i]
+                              * scratch.face_phi_field[j]
+
+                              - (inflow
+                                 ?
+                                 (density_c_P + latent_heat_LHS)
+                                 * time_step
+                                 * (current_u
+                                    * scratch.subface_finite_element_values->normal_vector(q))
+                                 * scratch.face_phi_field[i]
+                                 * scratch.face_phi_field[j]
+                                 :
+                                 0.)
+                             )
+                             * scratch.subface_finite_element_values->JxW(q);
+
+                          data.local_matrices_int_ext[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)](i,j)
+                          += (- 0.5 * time_step * neighbor_conductivity
+                              * scratch.neighbor_face_grad_phi_field[j]
+                              * scratch.subface_finite_element_values->normal_vector(q)
+                              * scratch.face_phi_field[i]
+
+                              + 0.5 * time_step * conductivity
+                              * scratch.face_grad_phi_field[i]
+                              * scratch.subface_finite_element_values->normal_vector(q)
+                              * scratch.neighbor_face_phi_field[j]
+
+                              - time_step
+                              * max_density_c_P_and_latent_heat
+                              * max_penalty
+                              * scratch.neighbor_face_phi_field[j]
+                              * scratch.face_phi_field[i]
+
+                              + (inflow
+                                 ?
+                                 (density_c_P + latent_heat_LHS)
+                                 * time_step
+                                 * (current_u
+                                    * scratch.subface_finite_element_values->normal_vector(q))
+                                 * scratch.face_phi_field[i]
+                                 * scratch.neighbor_face_phi_field[j]
+                                 :
+                                 0.)
+                             )
+                             * scratch.subface_finite_element_values->JxW(q);
+
+                          data.local_matrices_ext_int[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)](i,j)
+                          += (+ 0.5 * time_step * conductivity
+                              * scratch.face_grad_phi_field[j]
+                              * scratch.subface_finite_element_values->normal_vector(q)
+                              * scratch.neighbor_face_phi_field[i]
+
+                              - 0.5 * time_step * neighbor_conductivity
+                              * scratch.neighbor_face_grad_phi_field[i]
+                              * scratch.subface_finite_element_values->normal_vector(q)
+                              * scratch.face_phi_field[j]
+
+                              - time_step
+                              * max_density_c_P_and_latent_heat
+                              * max_penalty
+                              * scratch.face_phi_field[j]
+                              * scratch.neighbor_face_phi_field[i]
+
+                              - (!inflow
+                                 ?
+                                 (neighbor_density_c_P + neighbor_latent_heat_LHS)
+                                 * time_step
+                                 * (current_u
+                                    * scratch.subface_finite_element_values->normal_vector(q))
+                                 * scratch.neighbor_face_phi_field[i]
+                                 * scratch.face_phi_field[j]
+                                 :
+                                 0.)
+                             )
+                             * scratch.subface_finite_element_values->JxW(q);
+
+                          data.local_matrices_ext_ext[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)](i,j)
+                          += (+ 0.5 * time_step * neighbor_conductivity
+                              * scratch.neighbor_face_grad_phi_field[i]
+                              * scratch.subface_finite_element_values->normal_vector(q)
+                              * scratch.neighbor_face_phi_field[j]
+
+                              + 0.5 * time_step * neighbor_conductivity
+                              * scratch.neighbor_face_grad_phi_field[j]
+                              * scratch.subface_finite_element_values->normal_vector(q)
+                              * scratch.neighbor_face_phi_field[i]
+
+                              + time_step
+                              * max_density_c_P_and_latent_heat
+                              * max_penalty
+                              * scratch.neighbor_face_phi_field[i]
+                              * scratch.neighbor_face_phi_field[j]
+
+                              + (!inflow
+                                 ?
+                                 (neighbor_density_c_P + neighbor_latent_heat_LHS)
+                                 * time_step
+                                 * (current_u
+                                    * scratch.subface_finite_element_values->normal_vector(q))
+                                 * scratch.neighbor_face_phi_field[i]
+                                 * scratch.neighbor_face_phi_field[j]
+                                 :
+                                 0.)
+                             )
+                             * scratch.subface_finite_element_values->JxW(q);
+                        }
+                    }
+                }
+            }
+        }
+    }
+  }
+} // namespace aspect
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace Assemblers
+  {
+#define INSTANTIATE(dim) \
+  template class AdvectionSystem<dim>; \
+  template class DiffusionSystem<dim>; \
+  template class DarcySystem<dim>; \
+  template class AdvectionSystemBoundaryFace<dim>; \
+  template class AdvectionSystemInteriorFace<dim>; \
+  template class AdvectionSystemBoundaryHeatFlux<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/simulator/assemblers/interface.cc.bak b/source/simulator/assemblers/interface.cc.bak
new file mode 100644
index 00000000000..b824393e2c3
--- /dev/null
+++ b/source/simulator/assemblers/interface.cc.bak
@@ -0,0 +1,656 @@
+/*
+  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator/assemblers/interface.h>
+
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Assembly
+    {
+      namespace Scratch
+      {
+        template <int dim>
+        StokesPreconditioner<dim>::
+        StokesPreconditioner (const FiniteElement<dim> &finite_element,
+                              const Quadrature<dim>    &quadrature,
+                              const Mapping<dim>       &mapping,
+                              const UpdateFlags         update_flags,
+                              const unsigned int        n_compositional_fields,
+                              const unsigned int        stokes_dofs_per_cell,
+                              const bool                add_compaction_pressure,
+                              const bool                rebuild_matrix,
+                              const bool                use_bfbt)
+          :
+          ScratchBase<dim>(),
+
+          finite_element_values (mapping, finite_element, quadrature,
+                                 update_flags),
+          local_dof_indices (finite_element.dofs_per_cell),
+          dof_component_indices(stokes_dofs_per_cell),
+          grads_phi_u (stokes_dofs_per_cell, numbers::signaling_nan<SymmetricTensor<2,dim>>()),
+          div_phi_u (stokes_dofs_per_cell, numbers::signaling_nan<double>()),
+          phi_p (stokes_dofs_per_cell, numbers::signaling_nan<double>()),
+          phi_u (stokes_dofs_per_cell,numbers::signaling_nan<Tensor<1,dim>>()),
+          phi_p_c (add_compaction_pressure ? stokes_dofs_per_cell : 0, numbers::signaling_nan<double>()),
+          grad_phi_p ((add_compaction_pressure || use_bfbt) ? stokes_dofs_per_cell : 0, numbers::signaling_nan<Tensor<1,dim>>()),
+          material_model_inputs(quadrature.size(), n_compositional_fields),
+          material_model_outputs(quadrature.size(), n_compositional_fields),
+          rebuild_stokes_matrix(rebuild_matrix)
+        {}
+
+
+
+        template <int dim>
+        StokesPreconditioner<dim>::
+        StokesPreconditioner (const StokesPreconditioner &scratch)
+          :
+          ScratchBase<dim>(scratch),
+
+          finite_element_values (scratch.finite_element_values.get_mapping(),
+                                 scratch.finite_element_values.get_fe(),
+                                 scratch.finite_element_values.get_quadrature(),
+                                 scratch.finite_element_values.get_update_flags()),
+
+          local_dof_indices (scratch.local_dof_indices),
+          dof_component_indices( scratch.dof_component_indices),
+          grads_phi_u (scratch.grads_phi_u),
+          div_phi_u (scratch.div_phi_u),
+          phi_p (scratch.phi_p),
+          phi_u (scratch.phi_u),
+          phi_p_c (scratch.phi_p_c),
+          grad_phi_p(scratch.grad_phi_p),
+          material_model_inputs(scratch.material_model_inputs),
+          material_model_outputs(scratch.material_model_outputs),
+          rebuild_stokes_matrix(scratch.rebuild_stokes_matrix)
+        {}
+
+
+        template <int dim>
+        StokesPreconditioner<dim>::
+        ~StokesPreconditioner ()
+          = default;
+
+
+        template <int dim>
+        void
+        StokesPreconditioner<dim>::
+        reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref)
+        {
+          this->cell = cell_ref;
+          this->face_number = numbers::invalid_unsigned_int;
+          finite_element_values.reinit (cell_ref);
+        }
+
+
+        template <int dim>
+        StokesSystem<dim>::
+        StokesSystem (const FiniteElement<dim> &finite_element,
+                      const Mapping<dim>       &mapping,
+                      const Quadrature<dim>    &quadrature,
+                      const Quadrature<dim-1>  &face_quadrature,
+                      const UpdateFlags         update_flags,
+                      const UpdateFlags         face_update_flags,
+                      const unsigned int        n_compositional_fields,
+                      const unsigned int        stokes_dofs_per_cell,
+                      const bool                add_compaction_pressure,
+                      const bool                use_reference_density_profile,
+                      const bool                rebuild_stokes_matrix,
+                      const bool                rebuild_newton_stokes_matrix,
+                      const bool                use_bfbt)
+          :
+          StokesPreconditioner<dim> (finite_element, quadrature,
+                                     mapping,
+                                     update_flags,
+                                     n_compositional_fields,
+                                     stokes_dofs_per_cell,
+                                     add_compaction_pressure,
+                                     rebuild_stokes_matrix,
+                                     use_bfbt),
+
+          face_finite_element_values (mapping,
+                                      finite_element,
+                                      face_quadrature,
+                                      face_update_flags),
+
+          phi_u (stokes_dofs_per_cell, numbers::signaling_nan<Tensor<1,dim>>()),
+          velocity_values (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          velocity_divergence(quadrature.size(), numbers::signaling_nan<double>()),
+          temperature_gradients (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          face_material_model_inputs(face_quadrature.size(), n_compositional_fields),
+          face_material_model_outputs(face_quadrature.size(), n_compositional_fields),
+          reference_densities(use_reference_density_profile ? quadrature.size() : 0, numbers::signaling_nan<double>()),
+          reference_densities_depth_derivative(use_reference_density_profile ? quadrature.size() : 0, numbers::signaling_nan<double>()),
+          rebuild_newton_stokes_matrix(rebuild_newton_stokes_matrix)
+        {}
+
+
+
+        template <int dim>
+        StokesSystem<dim>::
+        StokesSystem (const StokesSystem<dim> &scratch)
+          :
+          StokesPreconditioner<dim> (scratch),
+
+          face_finite_element_values (scratch.face_finite_element_values.get_mapping(),
+                                      scratch.face_finite_element_values.get_fe(),
+                                      scratch.face_finite_element_values.get_quadrature(),
+                                      scratch.face_finite_element_values.get_update_flags()),
+
+          phi_u (scratch.phi_u),
+          velocity_values (scratch.velocity_values),
+          velocity_divergence (scratch.velocity_divergence),
+          temperature_gradients (scratch.temperature_gradients),
+          face_material_model_inputs(scratch.face_material_model_inputs),
+          face_material_model_outputs(scratch.face_material_model_outputs),
+          reference_densities(scratch.reference_densities),
+          reference_densities_depth_derivative(scratch.reference_densities_depth_derivative),
+          rebuild_newton_stokes_matrix(scratch.rebuild_newton_stokes_matrix)
+        {}
+
+        template <int dim>
+        void
+        StokesSystem<dim>::
+        reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref,
+                const unsigned face_number_ref)
+        {
+          this->cell = cell_ref;
+          this->face_number = face_number_ref;
+          face_finite_element_values.reinit(cell_ref, face_number_ref);
+        }
+
+
+
+        template <int dim>
+        AdvectionSystem<dim>::
+        AdvectionSystem (const FiniteElement<dim> &finite_element,
+                         const FiniteElement<dim> &advection_element,
+                         const Mapping<dim>       &mapping,
+                         const Quadrature<dim>    &quadrature,
+                         const Quadrature<dim-1>  &face_quadrature,
+                         const UpdateFlags         update_flags,
+                         const UpdateFlags         face_update_flags,
+                         const unsigned int        n_compositional_fields,
+                         const typename Simulator<dim>::AdvectionField &field)
+          :
+          ScratchBase<dim>(),
+
+          finite_element_values (mapping,
+                                 finite_element, quadrature,
+                                 update_flags),
+          face_finite_element_values (face_quadrature.size() > 0
+                                      ?
+                                      std::make_unique<FEFaceValues<dim>> (mapping,
+                                                                            finite_element, face_quadrature,
+                                                                            face_update_flags)
+                                      :
+                                      nullptr),
+          neighbor_face_finite_element_values (face_quadrature.size() > 0
+                                               ?
+                                               std::make_unique<FEFaceValues<dim>> (mapping,
+                                                                                     finite_element, face_quadrature,
+                                                                                     face_update_flags)
+                                               :
+                                               nullptr),
+          subface_finite_element_values (face_quadrature.size() > 0
+                                         ?
+                                         std::make_unique<FESubfaceValues<dim>> (mapping,
+                                                                                  finite_element, face_quadrature,
+                                                                                  face_update_flags)
+                                         :
+                                         nullptr),
+          local_dof_indices (finite_element.dofs_per_cell),
+
+          phi_field (advection_element.dofs_per_cell, numbers::signaling_nan<double>()),
+          grad_phi_field (advection_element.dofs_per_cell, numbers::signaling_nan<Tensor<1,dim>>()),
+          laplacian_phi_field (advection_element.dofs_per_cell, numbers::signaling_nan<double>()),
+          face_phi_field ((face_quadrature.size() > 0 ? advection_element.dofs_per_cell : 0),
+                          numbers::signaling_nan<double>()),
+          face_grad_phi_field ((face_quadrature.size() > 0 ? advection_element.dofs_per_cell : 0),
+                               numbers::signaling_nan<Tensor<1,dim>>()),
+          neighbor_face_phi_field ((face_quadrature.size() > 0 ? advection_element.dofs_per_cell : 0),
+                                   numbers::signaling_nan<double>()),
+          neighbor_face_grad_phi_field ((face_quadrature.size() > 0 ? advection_element.dofs_per_cell : 0),
+                                        numbers::signaling_nan<Tensor<1,dim>>()),
+          old_velocity_values (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          old_old_velocity_values (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          old_pressure (quadrature.size(), numbers::signaling_nan<double>()),
+          old_old_pressure (quadrature.size(), numbers::signaling_nan<double>()),
+          old_pressure_gradients (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          old_old_pressure_gradients (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          old_strain_rates (quadrature.size(), numbers::signaling_nan<SymmetricTensor<2,dim>>()),
+          old_old_strain_rates (quadrature.size(), numbers::signaling_nan<SymmetricTensor<2,dim>>()),
+          old_temperature_values (quadrature.size(), numbers::signaling_nan<double>()),
+          old_old_temperature_values(quadrature.size(), numbers::signaling_nan<double>()),
+          old_field_values (quadrature.size(), numbers::signaling_nan<double>()),
+          old_old_field_values(quadrature.size(), numbers::signaling_nan<double>()),
+          old_field_grads(quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          old_old_field_grads(quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          old_field_laplacians(quadrature.size(), numbers::signaling_nan<double>()),
+          old_old_field_laplacians(quadrature.size(), numbers::signaling_nan<double>()),
+          old_composition_values(n_compositional_fields,
+                                 std::vector<double>(quadrature.size(), numbers::signaling_nan<double>())),
+          old_old_composition_values(n_compositional_fields,
+                                     std::vector<double>(quadrature.size(), numbers::signaling_nan<double>())),
+          current_temperature_values(quadrature.size(), numbers::signaling_nan<double>()),
+          current_velocity_values(quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          face_current_velocity_values(face_quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          mesh_velocity_values(quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          face_mesh_velocity_values(face_quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
+          current_strain_rates(quadrature.size(), numbers::signaling_nan<SymmetricTensor<2,dim>>()),
+          current_composition_values(n_compositional_fields,
+                                     std::vector<double>(quadrature.size(), numbers::signaling_nan<double>())),
+          current_velocity_divergences(quadrature.size(), numbers::signaling_nan<double>()),
+          material_model_inputs(quadrature.size(), n_compositional_fields),
+          material_model_outputs(quadrature.size(), n_compositional_fields),
+          face_material_model_inputs(face_quadrature.size(), n_compositional_fields),
+          face_material_model_outputs(face_quadrature.size(), n_compositional_fields),
+          neighbor_face_material_model_inputs(face_quadrature.size(), n_compositional_fields),
+          neighbor_face_material_model_outputs(face_quadrature.size(), n_compositional_fields),
+          heating_model_outputs(quadrature.size(), n_compositional_fields),
+          face_heating_model_outputs(face_quadrature.size(), n_compositional_fields),
+          neighbor_face_heating_model_outputs(face_quadrature.size(), n_compositional_fields),
+          advection_field(&field),
+          artificial_viscosity(numbers::signaling_nan<double>())
+        {}
+
+
+
+        template <int dim>
+        AdvectionSystem<dim>::
+        AdvectionSystem (const AdvectionSystem &scratch)
+          :
+          ScratchBase<dim>(scratch),
+
+          finite_element_values (scratch.finite_element_values.get_mapping(),
+                                 scratch.finite_element_values.get_fe(),
+                                 scratch.finite_element_values.get_quadrature(),
+                                 scratch.finite_element_values.get_update_flags()),
+          face_finite_element_values (scratch.face_finite_element_values.get()
+                                      ?
+                                      std::make_unique<FEFaceValues<dim>> (scratch.face_finite_element_values->get_mapping(),
+                                                                            scratch.face_finite_element_values->get_fe(),
+                                                                            scratch.face_finite_element_values->get_quadrature(),
+                                                                            scratch.face_finite_element_values->get_update_flags())
+                                      :
+                                      nullptr),
+          neighbor_face_finite_element_values (scratch.neighbor_face_finite_element_values.get()
+                                               ?
+                                               std::make_unique<FEFaceValues<dim>> (scratch.neighbor_face_finite_element_values->get_mapping(),
+                                                                                     scratch.neighbor_face_finite_element_values->get_fe(),
+                                                                                     scratch.neighbor_face_finite_element_values->get_quadrature(),
+                                                                                     scratch.neighbor_face_finite_element_values->get_update_flags())
+                                               :
+                                               nullptr),
+          subface_finite_element_values (scratch.subface_finite_element_values.get()
+                                         ?
+                                         std::make_unique<FESubfaceValues<dim>> (scratch.subface_finite_element_values->get_mapping(),
+                                                                                  scratch.subface_finite_element_values->get_fe(),
+                                                                                  scratch.subface_finite_element_values->get_quadrature(),
+                                                                                  scratch.subface_finite_element_values->get_update_flags())
+                                         :
+                                         nullptr),
+          local_dof_indices (scratch.finite_element_values.get_fe().dofs_per_cell),
+
+          phi_field (scratch.phi_field),
+          grad_phi_field (scratch.grad_phi_field),
+          laplacian_phi_field (scratch.laplacian_phi_field),
+          face_phi_field (scratch.face_phi_field),
+          face_grad_phi_field (scratch.face_grad_phi_field),
+          neighbor_face_phi_field (scratch.neighbor_face_phi_field),
+          neighbor_face_grad_phi_field (scratch.neighbor_face_grad_phi_field),
+          old_velocity_values (scratch.old_velocity_values),
+          old_old_velocity_values (scratch.old_old_velocity_values),
+          old_pressure (scratch.old_pressure),
+          old_old_pressure (scratch.old_old_pressure),
+          old_pressure_gradients (scratch.old_pressure_gradients),
+          old_old_pressure_gradients (scratch.old_old_pressure_gradients),
+          old_strain_rates (scratch.old_strain_rates),
+          old_old_strain_rates (scratch.old_old_strain_rates),
+          old_temperature_values (scratch.old_temperature_values),
+          old_old_temperature_values (scratch.old_old_temperature_values),
+          old_field_values (scratch.old_field_values),
+          old_old_field_values(scratch.old_old_field_values),
+          old_field_grads (scratch.old_field_grads),
+          old_old_field_grads (scratch.old_old_field_grads),
+          old_field_laplacians (scratch.old_field_laplacians),
+          old_old_field_laplacians (scratch.old_old_field_laplacians),
+          old_composition_values(scratch.old_composition_values),
+          old_old_composition_values(scratch.old_old_composition_values),
+          current_temperature_values(scratch.current_temperature_values),
+          current_velocity_values(scratch.current_velocity_values),
+          face_current_velocity_values(scratch.face_current_velocity_values),
+          mesh_velocity_values(scratch.mesh_velocity_values),
+          face_mesh_velocity_values(scratch.face_mesh_velocity_values),
+          current_strain_rates(scratch.current_strain_rates),
+          current_composition_values(scratch.current_composition_values),
+          current_velocity_divergences(scratch.current_velocity_divergences),
+          material_model_inputs(scratch.material_model_inputs),
+          material_model_outputs(scratch.material_model_outputs),
+          face_material_model_inputs(scratch.face_material_model_inputs),
+          face_material_model_outputs(scratch.face_material_model_outputs),
+          neighbor_face_material_model_inputs(scratch.neighbor_face_material_model_inputs),
+          neighbor_face_material_model_outputs(scratch.neighbor_face_material_model_outputs),
+          heating_model_outputs(scratch.heating_model_outputs),
+          face_heating_model_outputs(scratch.face_heating_model_outputs),
+          neighbor_face_heating_model_outputs(scratch.neighbor_face_heating_model_outputs),
+          advection_field(scratch.advection_field),
+          artificial_viscosity(scratch.artificial_viscosity)
+        {}
+
+
+        template <int dim>
+        void
+        AdvectionSystem<dim>::
+        reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref)
+        {
+          this->cell = cell_ref;
+          this->face_number = numbers::invalid_unsigned_int;
+          finite_element_values.reinit (cell_ref);
+        }
+
+      }
+
+
+      namespace CopyData
+      {
+
+        template <int dim>
+        StokesPreconditioner<dim>::
+        StokesPreconditioner (const unsigned int stokes_dofs_per_cell)
+          :
+          local_matrix (stokes_dofs_per_cell,
+                        stokes_dofs_per_cell),
+          local_inverse_lumped_mass_matrix (stokes_dofs_per_cell),
+          local_dof_indices (stokes_dofs_per_cell)
+        {}
+
+
+
+        template <int dim>
+        StokesPreconditioner<dim>::
+        StokesPreconditioner (const StokesPreconditioner &data)
+          :
+          local_matrix (data.local_matrix),
+          local_inverse_lumped_mass_matrix (data.local_inverse_lumped_mass_matrix),
+          local_dof_indices (data.local_dof_indices)
+        {}
+
+
+        template <int dim>
+        void StokesPreconditioner<dim>::
+        extract_stokes_dof_indices(const std::vector<types::global_dof_index> &all_dof_indices,
+                                   const Introspection<dim>                   &introspection,
+                                   const FiniteElement<dim>           &finite_element)
+        {
+          const unsigned int dofs_per_cell = finite_element.dofs_per_cell;
+
+          for (unsigned int i=0, i_stokes=0; i<dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(finite_element.system_to_component_index(i).first))
+                {
+                  this->local_dof_indices[i_stokes] = all_dof_indices[i];
+                  ++i_stokes;
+                }
+              ++i;
+            }
+        }
+
+
+
+        template <int dim>
+        StokesSystem<dim>::
+        StokesSystem (const unsigned int        stokes_dofs_per_cell,
+                      const bool                do_pressure_rhs_compatibility_modification)
+          :
+          StokesPreconditioner<dim> (stokes_dofs_per_cell),
+          local_rhs (stokes_dofs_per_cell),
+          local_pressure_shape_function_integrals (do_pressure_rhs_compatibility_modification ?
+                                                   stokes_dofs_per_cell
+                                                   :
+                                                   0)
+        {}
+
+
+
+        template <int dim>
+        StokesSystem<dim>::
+        StokesSystem (const StokesSystem<dim> &data)
+          :
+          StokesPreconditioner<dim> (data),
+          local_rhs (data.local_rhs),
+          local_pressure_shape_function_integrals (data.local_pressure_shape_function_integrals.size())
+        {}
+
+
+
+
+        template <int dim>
+        AdvectionSystem<dim>::
+        AdvectionSystem (const FiniteElement<dim> &finite_element,
+                         const bool                field_is_discontinuous)
+          :
+          local_matrix (finite_element.dofs_per_cell,
+                        finite_element.dofs_per_cell),
+          local_matrices_int_ext ((field_is_discontinuous
+                                   ?
+                                   Assemblers::n_interface_matrices(finite_element.reference_cell())
+                                   :
+                                   0),
+                                  FullMatrix<double>(finite_element.dofs_per_cell,
+                                                     finite_element.dofs_per_cell)),
+          local_matrices_ext_int ((field_is_discontinuous
+                                   ?
+                                   Assemblers::n_interface_matrices(finite_element.reference_cell())
+                                   :
+                                   0),
+                                  FullMatrix<double>(finite_element.dofs_per_cell,
+                                                     finite_element.dofs_per_cell)),
+          local_matrices_ext_ext ((field_is_discontinuous
+                                   ?
+                                   Assemblers::n_interface_matrices(finite_element.reference_cell())
+                                   :
+                                   0),
+                                  FullMatrix<double>(finite_element.dofs_per_cell,
+                                                     finite_element.dofs_per_cell)),
+          local_rhs (finite_element.dofs_per_cell),
+
+          assembled_matrices ((field_is_discontinuous
+                               ?
+                               Assemblers::n_interface_matrices(finite_element.reference_cell())
+                               :
+                               0), false),
+
+          local_dof_indices (finite_element.dofs_per_cell),
+          neighbor_dof_indices ((field_is_discontinuous
+                                 ?
+                                 Assemblers::n_interface_matrices(finite_element.reference_cell())
+                                 :
+                                 0),
+                                std::vector<types::global_dof_index>(finite_element.dofs_per_cell))
+        {}
+
+      }
+    }
+  }
+
+
+
+  namespace Assemblers
+  {
+    unsigned int
+    n_interface_matrices (const ReferenceCell &reference_cell)
+    {
+      // The current implementation assumes that all faces are
+      // the same; so no wedges or pyramids please.
+      Assert ((reference_cell == ReferenceCells::Triangle)
+              ||
+              (reference_cell == ReferenceCells::Quadrilateral)
+              ||
+              (reference_cell == ReferenceCells::Tetrahedron)
+              ||
+              (reference_cell == ReferenceCells::Hexahedron),
+              ExcNotImplemented());
+      return (reference_cell.n_faces() *
+              reference_cell.face_reference_cell(0).n_isotropic_children());
+    }
+
+
+
+    unsigned int
+    nth_interface_matrix (const ReferenceCell &reference_cell,
+                          const unsigned int face)
+    {
+      AssertIndexRange (face, reference_cell.n_faces());
+      return (face *
+              reference_cell.face_reference_cell(0).n_isotropic_children());
+    }
+
+
+
+    unsigned int
+    nth_interface_matrix (const ReferenceCell &reference_cell,
+                          const unsigned int face,
+                          const unsigned int sub_face)
+    {
+      AssertIndexRange (face, reference_cell.n_faces());
+      AssertIndexRange (sub_face,
+                        reference_cell.face_reference_cell(0).n_isotropic_children());
+      return (face *
+              reference_cell.face_reference_cell(0).n_isotropic_children()
+              + sub_face);
+    }
+
+
+
+    template <int dim>
+    void
+    Interface<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &) const
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    Interface<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &) const
+    {
+      AssertThrow(false,
+                  ExcMessage("If this is an assembler that has to compute a residual"
+                             "then this function should be implemented. "
+                             "If this is an assembler that does not have to compute a residual, it should not be called."));
+
+      return {};
+    }
+
+
+
+    template <int dim>
+    AdvectionStabilizationInterface<dim>::~AdvectionStabilizationInterface()
+      = default;
+
+
+
+    template <int dim>
+    std::vector<double>
+    AdvectionStabilizationInterface<dim>::advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+
+      std::vector<double> prefactors(scratch.material_model_inputs.n_evaluation_points(), 1.0);
+
+      if (scratch.advection_field->is_temperature())
+        for (unsigned int i=0; i<prefactors.size(); ++i)
+          prefactors[i] = scratch.material_model_outputs.densities[i] * scratch.material_model_outputs.specific_heat[i];
+
+      return prefactors;
+    }
+
+
+
+    template <int dim>
+    std::vector<double>
+    AdvectionStabilizationInterface<dim>::diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+
+      if (scratch.advection_field->is_temperature())
+        return scratch.material_model_outputs.thermal_conductivities;
+
+      return std::vector<double> (scratch.material_model_inputs.n_evaluation_points(), 0.0);
+    }
+
+
+
+    template <int dim>
+    void Manager<dim>::reset ()
+    {
+      stokes_preconditioner.clear();
+      stokes_system.clear();
+      stokes_system_on_boundary_face.clear();
+      advection_system.clear();
+      advection_system_on_boundary_face.clear();
+      advection_system_on_interior_face.clear();
+    }
+
+    template <int dim>
+    Manager<dim>::Properties::Properties ()
+      :
+      need_face_material_model_data (false),
+      need_face_finite_element_evaluation(false),
+      need_viscosity(false),
+      needed_update_flags ()
+    {}
+  }
+} // namespace aspect
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+
+#define INSTANTIATE(dim) \
+  namespace internal { \
+    namespace Assembly { \
+      namespace Scratch { \
+        template struct StokesPreconditioner<dim>; \
+        template struct StokesSystem<dim>; \
+        template struct AdvectionSystem<dim>; \
+      } \
+      namespace CopyData { \
+        template struct StokesPreconditioner<dim>; \
+        template struct StokesSystem<dim>; \
+        template struct AdvectionSystem<dim>; \
+      } \
+    } \
+  } \
+  namespace Assemblers { \
+    template class Interface<dim>; \
+    template class AdvectionStabilizationInterface<dim>; \
+    template class Manager<dim>; \
+  }
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/assemblers/newton_stokes.cc.bak b/source/simulator/assemblers/newton_stokes.cc.bak
new file mode 100644
index 00000000000..174bab9cbc2
--- /dev/null
+++ b/source/simulator/assemblers/newton_stokes.cc.bak
@@ -0,0 +1,972 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/newton.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+#include <aspect/material_model/rheology/elasticity.h>
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    template <int dim>
+    void
+    NewtonInterface<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      if (this->get_newton_handler().parameters.newton_derivative_scaling_factor == 0)
+        return;
+
+      NewtonHandler<dim>::create_material_model_outputs(outputs);
+    }
+
+
+
+    template <int dim>
+    void
+    NewtonStokesPreconditioner<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
+      const double derivative_scaling_factor = this->get_newton_handler().parameters.newton_derivative_scaling_factor;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      const MaterialModel::MaterialAveraging::AveragingOperation
+      material_averaging = this->get_parameters().material_averaging;
+
+      // If elasticity is enabled, then we need ElasticOutputs to get the viscoelastic
+      // strain rate.
+      const MaterialModel::ElasticOutputs<dim> *elastic_out =
+        scratch.material_model_outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
+      if (this->get_parameters().enable_elasticity)
+        AssertThrow(elastic_out != nullptr,
+                    ExcMessage("Error: The Newton method requires ElasticOutputs when elasticity is enabled."));
+
+      // First loop over all dofs and find those that are in the Stokes system
+      // save the component (pressure and dim velocities) each belongs to.
+      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+        {
+          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+            {
+              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
+              ++i_stokes;
+            }
+          ++i;
+        }
+
+      const MaterialModel::MaterialModelDerivatives<dim> *derivatives
+        = scratch.material_model_outputs.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
+
+      std::vector<double> deta_deps_times_grads_phi_u(stokes_dofs_per_cell);
+      std::vector<double> eps_times_grads_phi_u(stokes_dofs_per_cell);
+
+      // Calculate the weighted average of viscosity derivatives if
+      // material averaging is applied.
+      if (derivative_scaling_factor > 0 &&
+          material_averaging != MaterialModel::MaterialAveraging::none)
+        {
+          AssertThrow(derivatives != nullptr,
+                      ExcMessage ("Error: The newton method requires derivatives from the material model."));
+
+          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  double avg = 0;
+                  for (unsigned int q = 0; q < n_q_points; ++q)
+                    avg += derivatives->viscosity_derivative_averaging_weights[q] *
+                           (derivatives->viscosity_derivative_wrt_strain_rate[q] *
+                            scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i, q));
+
+                  deta_deps_times_grads_phi_u[i_stokes] = avg;
+
+                  ++i_stokes;
+                }
+              ++i;
+            }
+        }
+
+      // Loop over all quadrature points and assemble their contributions to
+      // the preconditioner matrix
+      for (unsigned int q = 0; q < n_q_points; ++q)
+        {
+          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.grads_phi_u[i_stokes] =
+                    scratch.finite_element_values[introspection.extractors
+                                                  .velocities].symmetric_gradient(i, q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection
+                                                                          .extractors.pressure].value(i, q);
+
+#if DEBUG
+                  // This is needed to test the velocity part of the matrix for
+                  // being symmetric positive-definite.
+                  scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
+#endif
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const double eta = scratch.material_model_outputs.viscosities[q];
+          const double one_over_eta = 1. / eta;
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          // TODO: Find out why in this version of ASPECT adding the derivative to the preconditioning
+          // is way worse than the normal preconditioning
+          if (derivative_scaling_factor == 0)
+            {
+              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+                for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
+                  if (scratch.dof_component_indices[i] ==
+                      scratch.dof_component_indices[j])
+                    data.local_matrix(i, j) += (
+                                                 // top left block: for the current case with
+                                                 // derivative_scaling_factor==0 the top left block
+                                                 // of the system matrix only contains the usual
+                                                 // Stokes term. So approximate this block in the
+                                                 // same way as we do in the preconditioner when
+                                                 // we solve the regular Stokes problem, i.e.,
+                                                 // by replacing the symmetric gradient by the
+                                                 // regular gradient to make the block more sparse
+                                                 (2.0 * eta * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
+                                                 +
+                                                 // bottom right block: approximate the pressure
+                                                 // Schur complement by the pressure mass matrix.
+                                                 // if the derivative scaling factor is zero,
+                                                 // then we only use the viscosity in the top
+                                                 // left block, and so clearly the mass matrix
+                                                 // approximation in the bottom right needs to
+                                                 // only be scaled by 1/eta, without considering
+                                                 // the derivatives
+                                                 one_over_eta
+                                                 * pressure_scaling
+                                                 * pressure_scaling
+                                                 * (scratch.phi_p[i] * scratch.phi_p[j]))
+                                               * JxW;
+            }
+          else
+            {
+              const SymmetricTensor<2,dim> viscosity_derivative_wrt_strain_rate = derivatives->viscosity_derivative_wrt_strain_rate[q];
+              const SymmetricTensor<2,dim> effective_strain_rate =
+                elastic_out == nullptr ? deviator(scratch.material_model_inputs.strain_rate[q]) : elastic_out->viscoelastic_strain_rate[q];
+
+              const typename Newton::Parameters::Stabilization
+              preconditioner_stabilization = this->get_newton_handler().parameters.preconditioner_stabilization;
+
+              // use the spd factor when the stabilization is PD or SPD
+              const double alpha = (preconditioner_stabilization & Newton::Parameters::Stabilization::PD) != Newton::Parameters::Stabilization::none ?
+                                   Utilities::compute_spd_factor<dim>(eta, effective_strain_rate, viscosity_derivative_wrt_strain_rate,
+                                                                      this->get_newton_handler().parameters.SPD_safety_factor)
+                                   :
+                                   1;
+
+              // pre-compute the tensor contractions
+              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+                {
+                  eps_times_grads_phi_u[i] = effective_strain_rate * scratch.grads_phi_u[i];
+                  if (material_averaging == MaterialModel::MaterialAveraging::none)
+                    deta_deps_times_grads_phi_u[i] = viscosity_derivative_wrt_strain_rate * scratch.grads_phi_u[i];
+                }
+
+              // symmetrize when the stabilization is symmetric or SPD
+              const bool symmetrize = ((preconditioner_stabilization & Newton::Parameters::Stabilization::symmetric)
+                                       != Newton::Parameters::Stabilization::none);
+
+              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+                for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
+                  if (scratch.dof_component_indices[i] ==
+                      scratch.dof_component_indices[j])
+                    {
+                      data.local_matrix(i, j)
+                      += (
+                           // top left block: approximate J^{uu}
+                           (2.0 * eta * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
+                           +
+                           derivative_scaling_factor * alpha *
+                           ( symmetrize ?
+                             (eps_times_grads_phi_u[i] * deta_deps_times_grads_phi_u[j] +
+                              eps_times_grads_phi_u[j] * deta_deps_times_grads_phi_u[i] ) :
+                             2.0 * eps_times_grads_phi_u[i] * deta_deps_times_grads_phi_u[j] )
+                           +
+                           // bottom right block: approximate the
+                           // pressure Schur complement by the
+                           // pressure mass matrix.  strictly
+                           // speaking, we probably ought to also
+                           // consider the derivatives deta/deps
+                           // here, but we leave this as a TODO
+                           one_over_eta
+                           * pressure_scaling
+                           * pressure_scaling
+                           * (scratch.phi_p[i] * scratch.phi_p[j])
+                         )
+                         * JxW;
+                    }
+            }
+        }
+#if DEBUG
+      {
+        if (this->get_newton_handler().parameters.preconditioner_stabilization == Newton::Parameters::Stabilization::SPD)
+          {
+            // regardless of whether we do or do not add the Newton
+            // linearization terms, we ought to test whether the top-left
+            // block of the matrix is Symmetric Positive Definite (SPD).
+            //
+            // the reason why this is not entirely obvious is described in
+            // the paper that discusses the Newton implementation
+            Vector<double> tmp (stokes_dofs_per_cell);
+            for (unsigned int sample = 0; sample < 100; ++sample)
+              {
+                // fill a vector with random numbers for the Stokes DoFs
+                for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+                  if (scratch.dof_component_indices[i] < dim)
+                    tmp[i] = Utilities::generate_normal_random_number (0, 1);
+                  else
+                    tmp[i] = 0;
+
+                // then verify that the product tmp*(A*tmp) -- which by construction
+                // of the vector tmp only covers the top-left block of the matrix A
+                // -- is indeed positive (or nearly so)
+                Assert (data.local_matrix.matrix_norm_square(tmp)/(tmp*tmp)
+                        >=
+                        -1e-12*data.local_matrix.frobenius_norm(),
+                        ExcMessage ("The top left block of the local Newton-Stokes "
+                                    "matrix is not positive definite but has an "
+                                    "eigenvalue less than "
+                                    + Utilities::to_string (data.local_matrix.matrix_norm_square(tmp)/(tmp*tmp))
+                                    + " < 0. This should not happen."));
+              }
+          }
+      }
+#endif
+    }
+
+
+    template <int dim>
+    void
+    NewtonStokesPreconditioner<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      if (this->get_parameters().enable_elasticity &&
+          outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ElasticOutputs<dim>> (outputs.n_evaluation_points()));
+        }
+
+      if (this->get_newton_handler().parameters.newton_derivative_scaling_factor != 0)
+        NewtonHandler<dim>::create_material_model_outputs(outputs);
+    }
+
+
+    template <int dim>
+    void
+    NewtonStokesIncompressibleTerms<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double derivative_scaling_factor = this->get_newton_handler().parameters.newton_derivative_scaling_factor;
+
+      const MaterialModel::MaterialAveraging::AveragingOperation
+      material_averaging = this->get_parameters().material_averaging;
+
+      const bool enable_additional_stokes_rhs = this->get_parameters().enable_additional_stokes_rhs;
+
+      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim> *force = enable_additional_stokes_rhs ?
+                                                                            scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()
+                                                                            : nullptr;
+
+      // If elasticity is enabled, then we need ElasticOutputs to get the viscoelastic
+      // strain rate and the elastic force.
+      const bool enable_elasticity = this->get_parameters().enable_elasticity;
+      const MaterialModel::ElasticOutputs<dim> *elastic_out =
+        scratch.material_model_outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
+      if (enable_elasticity)
+        AssertThrow(elastic_out != nullptr,
+                    ExcMessage("Error: The Newton method requires ElasticOutputs when elasticity is enabled."));
+
+      const bool enable_prescribed_dilation = this->get_parameters().enable_prescribed_dilation;
+
+      const MaterialModel::PrescribedPlasticDilation<dim>
+      *prescribed_dilation = enable_prescribed_dilation ?
+                             scratch.material_model_outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>()
+                             : nullptr;
+
+      const bool material_model_is_compressible = (this->get_material_model().is_compressible());
+
+      const MaterialModel::MaterialModelDerivatives<dim> *derivatives
+        = scratch.material_model_outputs.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
+
+
+
+      std::vector<double> deta_deps_times_grads_phi_u(stokes_dofs_per_cell);
+      std::vector<double> deta_dp_times_phi_p(stokes_dofs_per_cell);
+      std::vector<double> eps_times_grads_phi_u(stokes_dofs_per_cell);
+
+      // Calculate the weighted average of viscosity derivatives if
+      // material averaging is applied.
+      if (derivative_scaling_factor > 0 &&
+          material_averaging != MaterialModel::MaterialAveraging::none)
+        {
+          // This one is only available in debug mode, because normally
+          // the AssertThrow in the preconditioner should already have
+          // caught the problem.
+          Assert(derivatives != nullptr,
+                 ExcMessage ("Error: The Newton method requires the material model to "
+                             "compute derivatives."));
+
+          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  double avg_wrt_eps = 0, avg_wrt_p = 0;
+                  for (unsigned int q = 0; q < n_q_points; ++q)
+                    {
+                      avg_wrt_eps += derivatives->viscosity_derivative_averaging_weights[q] *
+                                     (derivatives->viscosity_derivative_wrt_strain_rate[q] *
+                                      scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i, q));
+                      avg_wrt_p   += derivatives->viscosity_derivative_averaging_weights[q] *
+                                     (derivatives->viscosity_derivative_wrt_pressure[q] *
+                                      scratch.finite_element_values[introspection.extractors.pressure].value(i, q));
+                    }
+
+                  deta_deps_times_grads_phi_u[i_stokes] = avg_wrt_eps;
+                  deta_dp_times_phi_p[i_stokes] = avg_wrt_p;
+
+                  ++i_stokes;
+                }
+              ++i;
+            }
+        }
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+
+#if DEBUG
+                  // This is needed to test the velocity part of the matrix for
+                  // being symmetric positive-definite.
+                  scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
+#endif
+
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          // Viscosity scalar
+          const double eta = scratch.material_model_outputs.viscosities[q];
+          const double pressure = scratch.material_model_inputs.pressure[q];
+          const double velocity_divergence = scratch.velocity_divergence[q];
+
+          const SymmetricTensor<2,dim> effective_strain_rate =
+            elastic_out == nullptr ? deviator(scratch.material_model_inputs.strain_rate[q]) : elastic_out->viscoelastic_strain_rate[q];
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+
+          const double density = scratch.material_model_outputs.densities[q];
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+          const double pressure_scaling = this->get_pressure_scaling();
+
+          // first assemble the rhs
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i) -= (eta * 2.0 * (scratch.grads_phi_u[i] *
+                                                 scratch.material_model_inputs.strain_rate[q])
+                                    - (scratch.div_phi_u[i] * pressure)
+                                    - (pressure_scaling * scratch.phi_p[i] * velocity_divergence)
+                                    -(density * gravity * scratch.phi_u[i]))
+                                   * JxW;
+
+              if (enable_elasticity)
+                data.local_rhs(i) += ( deviator(elastic_out->elastic_force[q])
+                                       * scratch.grads_phi_u[i]
+                                     ) * JxW;
+
+              if (enable_additional_stokes_rhs)
+                data.local_rhs(i) += (force->rhs_u[q] * scratch.phi_u[i]
+                                      + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i])
+                                     * JxW;
+
+              if (enable_prescribed_dilation)
+                data.local_rhs(i) += (
+                                       // RHS of - (div u,q) = - (R,q)
+                                       - pressure_scaling
+                                       * prescribed_dilation->dilation[q]
+                                       * scratch.phi_p[i]
+                                     ) * JxW;
+
+              // Only assemble this term if we are running incompressible, otherwise this term
+              // is already included on the LHS of the equation.
+              if (enable_prescribed_dilation && !material_model_is_compressible)
+                data.local_rhs(i) += (
+                                       // RHS of momentum eqn: - \int 2/3 eta R, div v
+                                       - 2.0 / 3.0 * eta
+                                       * prescribed_dilation->dilation[q]
+                                       * scratch.div_phi_u[i]
+                                     ) * JxW;
+            }
+
+          // and then the matrix, if necessary
+          if (scratch.rebuild_newton_stokes_matrix)
+            {
+              // always compute the common terms in the Newton matrix
+              for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                  {
+                    data.local_matrix(i,j) += (
+                                                eta * 2.0 * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j])
+                                                // assemble \nabla p as -(p, div v):
+                                                - (pressure_scaling *
+                                                   (scratch.div_phi_u[i] * scratch.phi_p[j]))
+                                                // assemble the term -div(u) as -(div u, q).
+                                                // Note the negative sign to make this
+                                                // operator adjoint to the grad p term:
+                                                - (pressure_scaling *
+                                                   (scratch.phi_p[i] * scratch.div_phi_u[j])))
+                                              * JxW;
+                  }
+
+              // then also see whether we have to add terms due to the
+              // Newton linearization
+              if (derivative_scaling_factor != 0)
+                {
+                  const SymmetricTensor<2,dim> viscosity_derivative_wrt_strain_rate = derivatives->viscosity_derivative_wrt_strain_rate[q];
+                  const double viscosity_derivative_wrt_pressure = derivatives->viscosity_derivative_wrt_pressure[q];
+                  const Newton::Parameters::Stabilization velocity_block_stabilization
+                    = this->get_newton_handler().parameters.velocity_block_stabilization;
+
+                  // use the spd factor when the stabilization is PD or SPD
+                  const double alpha =  (velocity_block_stabilization & Newton::Parameters::Stabilization::PD)
+                                        != Newton::Parameters::Stabilization::none
+                                        ?
+                                        Utilities::compute_spd_factor<dim>(eta, effective_strain_rate, viscosity_derivative_wrt_strain_rate,
+                                                                           this->get_newton_handler().parameters.SPD_safety_factor)
+                                        :
+                                        1;
+
+                  // pre-compute the tensor contractions
+                  for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+                    {
+                      eps_times_grads_phi_u[i] = effective_strain_rate * scratch.grads_phi_u[i];
+                      if (material_averaging == MaterialModel::MaterialAveraging::none)
+                        {
+                          deta_deps_times_grads_phi_u[i] = viscosity_derivative_wrt_strain_rate * scratch.grads_phi_u[i];
+                          deta_dp_times_phi_p[i]         = viscosity_derivative_wrt_pressure * scratch.phi_p[i];
+                        }
+                    }
+
+                  // symmetrize when the stabilization is symmetric or SPD
+                  const bool symmetrize = ((velocity_block_stabilization & Newton::Parameters::Stabilization::symmetric)
+                                           != Newton::Parameters::Stabilization::none);
+
+                  for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+                    {
+                      for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                        {
+                          data.local_matrix(i,j) += ( alpha *
+                                                      ( symmetrize ?
+                                                        ( eps_times_grads_phi_u[i] * deta_deps_times_grads_phi_u[j] +
+                                                          eps_times_grads_phi_u[j] * deta_deps_times_grads_phi_u[i] ) :
+                                                        2.0 * eps_times_grads_phi_u[i] * deta_deps_times_grads_phi_u[j]
+                                                      )
+                                                      + pressure_scaling * 2.0 * eps_times_grads_phi_u[i] * deta_dp_times_phi_p[j]
+                                                    )
+                                                    * derivative_scaling_factor
+                                                    * JxW;
+
+                          Assert(dealii::numbers::is_finite(data.local_matrix(i,j)),
+                                 ExcMessage ("Error: Assembly matrix is not finite." +
+                                             Utilities::to_string(data.local_matrix(i,j)) +
+                                             " = " + Utilities::to_string(eta)));
+                        }
+                    }
+                }
+            }
+        }
+
+#if DEBUG
+      if (scratch.rebuild_newton_stokes_matrix)
+        {
+          if (this->get_newton_handler().parameters.velocity_block_stabilization
+              == Newton::Parameters::Stabilization::SPD)
+            {
+              // regardless of whether we do or do not add the Newton
+              // linearization terms, we ought to test whether the top-left
+              // block of the matrix is Symmetric Positive Definite (SPD).
+              //
+              // the reason why this is not entirely obvious is described in
+              // the paper that discusses the Newton implementation
+              Vector<double> tmp (stokes_dofs_per_cell);
+              for (unsigned int sample = 0; sample < 100; ++sample)
+                {
+                  // fill a vector with random numbers for the Stokes DoFs
+                  for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+                    if (scratch.dof_component_indices[i] < dim)
+                      tmp[i] = Utilities::generate_normal_random_number (0, 1);
+                    else
+                      tmp[i] = 0;
+
+                  // then verify that the product tmp*(A*tmp) -- which by construction
+                  // of the vector tmp only covers the top-left block of the matrix A
+                  // -- is indeed positive (or nearly so)
+                  Assert (data.local_matrix.matrix_norm_square(tmp)/(tmp*tmp)
+                          >=
+                          -1e-12*data.local_matrix.frobenius_norm(),
+                          ExcMessage ("The top left block of the local Newton-Stokes "
+                                      "matrix is not positive definite but has an "
+                                      "eigenvalue less than "
+                                      + Utilities::to_string (data.local_matrix.matrix_norm_square(tmp)/(tmp*tmp))
+                                      + " < 0. This should not happen."));
+                }
+            }
+        }
+#endif
+    }
+
+    template <int dim>
+    void
+    NewtonStokesIncompressibleTerms<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      const unsigned int n_points = outputs.n_evaluation_points();
+
+      if (this->get_parameters().enable_additional_stokes_rhs
+          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>> (n_points));
+        }
+
+      Assert(!this->get_parameters().enable_additional_stokes_rhs
+             ||
+             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
+             == n_points, ExcInternalError());
+
+      if ((this->get_parameters().enable_elasticity) &&
+          outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ElasticOutputs<dim>> (n_points));
+        }
+
+      Assert(!this->get_parameters().enable_elasticity
+             ||
+             outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>()->elastic_force.size()
+             == n_points, ExcInternalError());
+
+      // prescribed dilation:
+      if (this->get_parameters().enable_prescribed_dilation
+          && outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedPlasticDilation<dim>> (n_points));
+        }
+
+      Assert(!this->get_parameters().enable_prescribed_dilation
+             ||
+             outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>()->dilation.size()
+             == n_points, ExcInternalError());
+
+      if (this->get_newton_handler().parameters.newton_derivative_scaling_factor != 0)
+        NewtonHandler<dim>::create_material_model_outputs(outputs);
+    }
+
+
+    template <int dim>
+    void
+    NewtonStokesCompressibleStrainRateViscosityTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      const double derivative_scaling_factor = this->get_newton_handler().parameters.newton_derivative_scaling_factor;
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          // Viscosity scalar
+          const double two_thirds = 2.0 / 3.0;
+          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * two_thirds;
+          const double velocity_divergence = scratch.velocity_divergence[q];
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i) -= (- eta_two_thirds * (scratch.div_phi_u[i]*velocity_divergence)) * JxW;
+            }
+
+          if (scratch.rebuild_stokes_matrix)
+            {
+              if (derivative_scaling_factor == 0)
+                {
+                  if (scratch.rebuild_newton_stokes_matrix)
+                    for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+                      for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                        {
+                          data.local_matrix(i,j) += (- eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])) * JxW;
+                        }
+                }
+              else
+                {
+                  const MaterialModel::MaterialModelDerivatives<dim> *derivatives = scratch.material_model_outputs.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
+
+                  // This one is only available in debug mode, because normally
+                  // the AssertThrow in the preconditioner should already have
+                  // caught the problem.
+                  Assert(derivatives != nullptr, ExcMessage ("Error: The newton method requires the derivatives"));
+
+                  const SymmetricTensor<2,dim> viscosity_derivative_wrt_strain_rate = derivatives->viscosity_derivative_wrt_strain_rate[q];
+                  const double viscosity_derivative_wrt_pressure = derivatives->viscosity_derivative_wrt_pressure[q];
+
+                  for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+                    for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                      {
+                        data.local_matrix(i,j) += (-eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
+                                                   - derivative_scaling_factor * two_thirds * scratch.div_phi_u[i] * ( (viscosity_derivative_wrt_strain_rate * scratch.grads_phi_u[j]) * velocity_divergence)
+                                                   - derivative_scaling_factor * two_thirds * (scratch.div_phi_u[i] * viscosity_derivative_wrt_pressure * scratch.phi_p[j]) * velocity_divergence
+                                                  )
+                                                  * JxW;
+                      }
+                }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    NewtonStokesReferenceDensityCompressibilityTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      // assemble RHS of:
+      //  - div u = 1/rho * drho/dz g/||g||* u
+      Assert(this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::reference_density_profile,
+             ExcInternalError());
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+          const double drho_dz_u = scratch.reference_densities_depth_derivative[q]
+                                   * (gravity * scratch.velocity_values[q]) / gravity.norm();
+          const double one_over_rho = 1.0/scratch.reference_densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            data.local_rhs(i) += (pressure_scaling *
+                                  one_over_rho * drho_dz_u * scratch.phi_p[i])
+                                 * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    NewtonStokesImplicitReferenceDensityCompressibilityTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      // assemble compressibility term of:
+      //  - div u - 1/rho * drho/dz g/||g||* u = 0
+      Assert(this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile,
+             ExcInternalError());
+
+      if (!scratch.rebuild_stokes_matrix)
+        return;
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i,q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+          const Tensor<1,dim> drho_dz = scratch.reference_densities_depth_derivative[q]
+                                        * gravity / gravity.norm();
+          const double one_over_rho = 1.0/scratch.reference_densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+              data.local_matrix(i,j) += (pressure_scaling *
+                                         one_over_rho * drho_dz * scratch.phi_u[j] * scratch.phi_p[i])
+                                        * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    NewtonStokesIsentropicCompressionTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      // assemble RHS of:
+      //  - div u = 1/rho * drho/dp rho * g * u
+      Assert(this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::isentropic_compression,
+             ExcInternalError());
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+
+          const double compressibility
+            = scratch.material_model_outputs.compressibilities[q];
+
+          const double density = scratch.material_model_outputs.densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            data.local_rhs(i) += (
+                                   // add the term that results from the compressibility. compared
+                                   // to the manual, this term seems to have the wrong sign, but this
+                                   // is because we negate the entire equation to make sure we get
+                                   // -div(u) as the adjoint operator of grad(p)
+                                   (pressure_scaling *
+                                    compressibility * density *
+                                    (scratch.velocity_values[q] * gravity) *
+                                    scratch.phi_p[i])
+                                 )
+                                 * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    NewtonStokesProjectedDensityFieldTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      // assemble RHS of:
+      // $ - \nabla \cdot \mathbf{u} = \frac{1}{\rho} \frac{\partial \rho}{\partial t} + \frac{1}{\rho} \nabla \rho \cdot \mathbf{u}$
+
+      // Compared to the manual, this term seems to have the wrong sign, but
+      // this is because we negate the entire equation to make sure we get
+      // -div(u) as the adjoint operator of grad(p)
+
+      Assert(this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::projected_density_field,
+             ExcInternalError());
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+      const unsigned int density_idx = this->introspection().find_composition_type(CompositionalFieldDescription::density);
+
+      const double time_step = this->get_timestep();
+      const double old_time_step = this->get_old_timestep();
+
+      std::vector<Tensor<1,dim>> density_gradients(n_q_points);
+      std::vector<double> density(n_q_points);
+      std::vector<double> density_old(n_q_points);
+      std::vector<double> density_old_old(n_q_points);
+
+      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_gradients (this->get_current_linearization_point(),
+          density_gradients);
+      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_current_linearization_point(),
+          density);
+      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_old_solution(),
+          density_old);
+      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_old_old_solution(),
+          density_old_old);
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          double drho_dt;
+
+          if (this->get_timestep_number() > 1)
+            drho_dt = (1.0/time_step) *
+                      (density[q] *
+                       (2*time_step + old_time_step) / (time_step + old_time_step)
+                       -
+                       density_old[q] *
+                       (1 + time_step/old_time_step)
+                       +
+                       density_old_old[q] *
+                       (time_step * time_step) / (old_time_step * (time_step + old_time_step)));
+          else if (this->get_timestep_number() == 1)
+            drho_dt =
+              (density[q] - density_old[q]) / time_step;
+          else
+            drho_dt = 0.0;
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            data.local_rhs(i) += (
+                                   (pressure_scaling *
+                                    (1.0 / density[q]) *
+                                    (density_gradients[q] *
+                                     scratch.velocity_values[q]) *
+                                    scratch.phi_p[i])
+                                   + pressure_scaling * (1.0 / density[q]) * drho_dt * scratch.phi_p[i]
+                                 )
+                                 * JxW;
+        }
+    }
+  }
+} // namespace aspect
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace Assemblers
+  {
+#define INSTANTIATE(dim) \
+  template class NewtonInterface<dim>; \
+  template class NewtonStokesPreconditioner<dim>; \
+  template class NewtonStokesIncompressibleTerms<dim>; \
+  template class NewtonStokesCompressibleStrainRateViscosityTerm<dim>; \
+  template class NewtonStokesReferenceDensityCompressibilityTerm<dim>; \
+  template class NewtonStokesImplicitReferenceDensityCompressibilityTerm<dim>; \
+  template class NewtonStokesIsentropicCompressionTerm<dim>; \
+  template class NewtonStokesProjectedDensityFieldTerm<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/simulator/assemblers/stokes.cc.bak b/source/simulator/assemblers/stokes.cc.bak
new file mode 100644
index 00000000000..164a7a7913e
--- /dev/null
+++ b/source/simulator/assemblers/stokes.cc.bak
@@ -0,0 +1,994 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator/assemblers/stokes.h>
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    template <int dim>
+    void
+    StokesPreconditioner<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      // First loop over all dofs and find those that are in the Stokes system
+      // save the component (pressure and dim velocities) each belongs to.
+      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+        {
+          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+            {
+              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
+              ++i_stokes;
+            }
+          ++i;
+        }
+
+      // When using the Q1-Q1 equal order element, we need to compute the
+      // projection of the Q1 pressure shape functions onto the constants
+      // and use this projection in the computation of matrix terms.
+      // Do this here by computing the integral of the shape functions
+      // over the cell and then dividing by the area of the cell.
+      std::vector<double> average_pressure_shape_function (this->get_parameters().use_equal_order_interpolation_for_stokes
+                                                           ?
+                                                           stokes_dofs_per_cell
+                                                           :
+                                                           0,
+                                                           numbers::signaling_nan<double>());
+      if (this->get_parameters().use_equal_order_interpolation_for_stokes)
+        {
+          // Check that we are really only using a Q1-Q1 element and
+          // not a Q2-Q2 element. This is because in the latter case, the
+          // projection isn't just on the piecewise constants, but onto
+          // the piecewise (bi,tri)linears, and this is going to be a bit
+          // more involved than just computing a single number per shape
+          // function.
+          Assert (this->get_parameters().stokes_velocity_degree==1,
+                  ExcNotImplemented());
+
+          double area       = 0;
+          for (unsigned int q=0; q<n_q_points; ++q)
+            area += scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  double int_over_p = 0;
+
+                  for (unsigned int q=0; q<n_q_points; ++q)
+                    {
+                      int_over_p += scratch.finite_element_values[introspection.extractors.pressure].value(i,q)
+                                    *
+                                    scratch.finite_element_values.JxW(q);
+                    }
+
+                  average_pressure_shape_function[i_stokes] = int_over_p/area;
+                  ++i_stokes;
+                }
+              ++i;
+            }
+        }
+
+      // Loop over all quadrature points and assemble their contributions to
+      // the preconditioner matrix
+      for (unsigned int q = 0; q < n_q_points; ++q)
+        {
+          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  if (this->get_parameters().use_full_A_block_preconditioner == false)
+                    scratch.grads_phi_u[i_stokes] =
+                      scratch.finite_element_values[introspection.extractors
+                                                    .velocities].symmetric_gradient(i, q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection
+                                                                          .extractors.pressure].value(i, q);
+                  if (this->get_parameters().use_bfbt == true)
+                    {
+                      scratch.grad_phi_p[i_stokes]=scratch.finite_element_values[introspection.extractors.pressure].gradient(i,q);
+                      scratch.phi_u[i_stokes]=scratch.finite_element_values[introspection.extractors.velocities].value(i,q);
+                    }
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const double eta = scratch.material_model_outputs.viscosities[q];
+          const double one_over_eta = 1. / eta;
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          if (this->get_parameters().use_full_A_block_preconditioner == false)
+            {
+              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+                for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
+                  if (scratch.dof_component_indices[i] ==
+                      scratch.dof_component_indices[j])
+                    {
+                      data.local_matrix(i, j) += ((2.0 * eta * (scratch.grads_phi_u[i]
+                                                                * scratch.grads_phi_u[j]))
+                                                 )
+                                                 * JxW;
+                    }
+
+
+            }
+          if (this->get_parameters().use_bfbt == true)
+            {
+              const double sqrt_eta = sqrt(eta);
+              const unsigned int pressure_component_index = this->introspection().component_indices.pressure;
+
+              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+                {
+                  for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
+                    {
+
+
+                      // i and j are not pressures
+                      if (scratch.dof_component_indices[i] != pressure_component_index && scratch.dof_component_indices[j] != pressure_component_index)
+                        data.local_inverse_lumped_mass_matrix[i] += sqrt_eta*scalar_product(scratch.phi_u[i],scratch.phi_u[j])*JxW;
+
+
+                      // i and j are pressures
+                      if (scratch.dof_component_indices[i] == pressure_component_index && scratch.dof_component_indices[j] == pressure_component_index)
+                        data.local_matrix(i, j) += (
+                                                     1.0/sqrt_eta * pressure_scaling
+                                                     * pressure_scaling
+                                                     * (scratch.grad_phi_p[i]
+                                                        * scratch.grad_phi_p[j] + 1e-6*scratch.phi_p[i]*scratch.phi_p[j] ))
+                                                   * JxW;
+                    }
+                }
+            }
+          else
+            {
+              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+                for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
+                  if (scratch.dof_component_indices[i] ==
+                      scratch.dof_component_indices[j])
+                    {
+                      data.local_matrix(i, j) += (
+                                                   one_over_eta * pressure_scaling
+                                                   * pressure_scaling
+                                                   * (scratch.phi_p[i]
+                                                      * scratch.phi_p[j]))
+                                                 * JxW;
+                    }
+            }
+
+          // If we are using the equal order Q1-Q1 element, then we also need
+          // to add the stabilization term to the (P,P) block of the matrix.
+          // Note the change in sign from the one in the assembly of the
+          // system matrix, which is due to the fact that the Schur complement
+          // of the matrix
+          //    [ A   B ]
+          //    [ B^T C ]
+          // is actually
+          //    S  =  B^T A^{-1} B - C
+          // with the minus sign in front of C. Because C is defined in the
+          // method of Dohrmann and Bochev as a *negative* definite operator,
+          // we here need to add the *positive* operator.
+          if (this->get_parameters().use_equal_order_interpolation_for_stokes)
+            {
+              for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                  {
+                    data.local_matrix(i,j) += ( one_over_eta * pressure_scaling * pressure_scaling *
+                                                (scratch.phi_p[i] - average_pressure_shape_function[i]) *
+                                                (scratch.phi_p[j] - average_pressure_shape_function[j]))
+                                              * JxW;
+                  }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesCompressiblePreconditioner<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      Assert (this->get_parameters().use_equal_order_interpolation_for_stokes == false,
+              ExcNotImplemented());
+
+      Assert (this->get_parameters().use_full_A_block_preconditioner == false,
+              ExcMessage("This assembler should only be called if the simplified A block "
+                         "preconditioner is used."));
+
+      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
+
+      // First loop over all dofs and find those that are in the Stokes system
+      // save the component (pressure and dim velocities) each belongs to.
+      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+        {
+          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+            {
+              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
+              ++i_stokes;
+            }
+          ++i;
+        }
+
+      // Loop over all quadrature points and assemble their contributions to
+      // the preconditioner matrix
+      for (unsigned int q = 0; q < n_q_points; ++q)
+        {
+          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0;
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+            for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
+              if (scratch.dof_component_indices[i] ==
+                  scratch.dof_component_indices[j])
+                data.local_matrix(i, j) += (- eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
+                                           )
+                                           * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesIncompressibleTerms<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
+      *force = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
+
+      const MaterialModel::ElasticOutputs<dim>
+      *elastic_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
+
+      const MaterialModel::PrescribedPlasticDilation<dim>
+      *prescribed_dilation =
+        (this->get_parameters().enable_prescribed_dilation)
+        ? scratch.material_model_outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>()
+        : nullptr;
+
+      const bool material_model_is_compressible = (this->get_material_model().is_compressible());
+
+      // When using the Q1-Q1 equal order element, we need to compute the
+      // projection of the Q1 pressure shape functions onto the constants
+      // and use this projection in the computation of matrix terms.
+      // Do this here by computing the integral of the shape functions
+      // over the cell and then dividing by the area of the cell.
+      std::vector<double> average_pressure_shape_function (this->get_parameters().use_equal_order_interpolation_for_stokes
+                                                           ?
+                                                           stokes_dofs_per_cell
+                                                           :
+                                                           0,
+                                                           numbers::signaling_nan<double>());
+      if (this->get_parameters().use_equal_order_interpolation_for_stokes)
+        {
+          // Check that we are really only using a Q1-Q1 element and
+          // not a Q2-Q2 element. This is because in the latter case, the
+          // projection isn't just on the piecewise constants, but onto
+          // the piecewise (bi,tri)linears, and this is going to be a bit
+          // more involved than just computing a single number per shape
+          // function.
+          Assert (this->get_parameters().stokes_velocity_degree==1,
+                  ExcNotImplemented());
+
+          double area       = 0;
+          for (unsigned int q=0; q<n_q_points; ++q)
+            area += scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  double int_over_p = 0;
+
+                  for (unsigned int q=0; q<n_q_points; ++q)
+                    {
+                      int_over_p += scratch.finite_element_values[introspection.extractors.pressure].value(i,q)
+                                    *
+                                    scratch.finite_element_values.JxW(q);
+                    }
+
+                  average_pressure_shape_function[i_stokes] = int_over_p/area;
+                  ++i_stokes;
+                }
+              ++i;
+            }
+        }
+
+      // Next, do the integration of matrix and right hand side terms.
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  if (scratch.rebuild_stokes_matrix)
+                    {
+                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+                    }
+                  else if (this->get_parameters().enable_elasticity)
+                    {
+                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                    }
+                  else if (prescribed_dilation && !material_model_is_compressible)
+                    {
+                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+                    }
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+
+          // Viscosity scalar
+          const double eta = ((scratch.rebuild_stokes_matrix || prescribed_dilation)
+                              ?
+                              scratch.material_model_outputs.viscosities[q]
+                              :
+                              numbers::signaling_nan<double>());
+          const double one_over_eta = (scratch.rebuild_stokes_matrix
+                                       &&
+                                       this->get_parameters().use_equal_order_interpolation_for_stokes
+                                       ?
+                                       1./eta
+                                       :
+                                       numbers::signaling_nan<double>());
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+
+          const double density = scratch.material_model_outputs.densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i) += (density * gravity * scratch.phi_u[i])
+                                   * JxW;
+
+              if (force != nullptr && this->get_parameters().enable_additional_stokes_rhs)
+                data.local_rhs(i) += (force->rhs_u[q] * scratch.phi_u[i]
+                                      + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i])
+                                     * JxW;
+
+              if (elastic_outputs != nullptr && this->get_parameters().enable_elasticity)
+                data.local_rhs(i) += (scalar_product(elastic_outputs->elastic_force[q],Tensor<2,dim>(scratch.grads_phi_u[i])))
+                                     * JxW;
+
+              if (prescribed_dilation != nullptr)
+                data.local_rhs(i) += (
+                                       // RHS of - (div u,q) = - (R,q)
+                                       - pressure_scaling
+                                       * prescribed_dilation->dilation[q]
+                                       * scratch.phi_p[i]
+                                     ) * JxW;
+
+              // Only assemble this term if we are running incompressible, otherwise this term
+              // is already included on the LHS of the equation.
+              if (prescribed_dilation != nullptr && !material_model_is_compressible)
+                data.local_rhs(i) += (
+                                       // RHS of momentum eqn: - \int 2/3 eta R, div v
+                                       - 2.0 / 3.0 * eta
+                                       * prescribed_dilation->dilation[q]
+                                       * scratch.div_phi_u[i]
+                                     ) * JxW;
+
+              if (scratch.rebuild_stokes_matrix)
+                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                  {
+                    data.local_matrix(i,j) += ( (eta * 2.0 * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
+                                                // assemble \nabla p as -(p, div v):
+                                                - (pressure_scaling *
+                                                   scratch.div_phi_u[i] * scratch.phi_p[j])
+                                                // assemble the term -div(u) as -(div u, q).
+                                                // Note the negative sign to make this
+                                                // operator adjoint to the grad p term:
+                                                - (pressure_scaling *
+                                                   scratch.phi_p[i] * scratch.div_phi_u[j]))
+                                              * JxW;
+                  }
+            }
+
+          // If we are using the equal order Q1-Q1 element, then we also need
+          // to put the stabilization term into the (P,P) block of the matrix:
+          if (scratch.rebuild_stokes_matrix
+              &&
+              this->get_parameters().use_equal_order_interpolation_for_stokes)
+            {
+              for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                  {
+                    data.local_matrix(i,j) += ( - (one_over_eta * pressure_scaling * pressure_scaling *
+                                                   (scratch.phi_p[i] - average_pressure_shape_function[i]) *
+                                                   (scratch.phi_p[j] - average_pressure_shape_function[j])))
+                                              * JxW;
+                  }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesIncompressibleTerms<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      const unsigned int n_points = outputs.n_evaluation_points();
+
+      // Stokes RHS:
+      if (this->get_parameters().enable_additional_stokes_rhs
+          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>> (n_points));
+        }
+
+      Assert(!this->get_parameters().enable_additional_stokes_rhs
+             ||
+             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
+             == n_points, ExcInternalError());
+
+      // prescribed dilation:
+      if (this->get_parameters().enable_prescribed_dilation
+          && outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedPlasticDilation<dim>> (n_points));
+        }
+
+      Assert(!this->get_parameters().enable_prescribed_dilation
+             ||
+             outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>()->dilation.size()
+             == n_points, ExcInternalError());
+
+      // Elasticity:
+      if ((this->get_parameters().enable_elasticity) &&
+          outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::ElasticOutputs<dim>> (n_points));
+        }
+
+      Assert(!this->get_parameters().enable_elasticity
+             ||
+             outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>()->elastic_force.size()
+             == n_points, ExcInternalError());
+    }
+
+
+
+    template <int dim>
+    void
+    StokesCompressibleStrainRateViscosityTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      if (!scratch.rebuild_stokes_matrix)
+        return;
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          // Viscosity scalar
+          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0;
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+              {
+                data.local_matrix(i,j) += (- (eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
+                                             ))
+                                          * JxW;
+              }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesReferenceDensityCompressibilityTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      // assemble RHS of:
+      //  - div u = 1/rho * drho/dz g/||g||* u
+      Assert(this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::reference_density_profile,
+             ExcInternalError());
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+          const double drho_dz_u = scratch.reference_densities_depth_derivative[q]
+                                   * (gravity * scratch.velocity_values[q]) / gravity.norm();
+          const double one_over_rho = 1.0/scratch.reference_densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            data.local_rhs(i) += (pressure_scaling *
+                                  one_over_rho * drho_dz_u * scratch.phi_p[i])
+                                 * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesImplicitReferenceDensityCompressibilityTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      // assemble compressibility term of:
+      //  - div u - 1/rho * drho/dz g/||g||* u = 0
+      Assert(this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile,
+             ExcInternalError());
+
+      if (!scratch.rebuild_stokes_matrix)
+        return;
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i,q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+          const Tensor<1,dim> drho_dz = scratch.reference_densities_depth_derivative[q]
+                                        * gravity / gravity.norm();
+          const double one_over_rho = 1.0/scratch.reference_densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+              data.local_matrix(i,j) += -(pressure_scaling *
+                                          one_over_rho * drho_dz * scratch.phi_u[j] * scratch.phi_p[i])
+                                        * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesIsentropicCompressionTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      // assemble RHS of:
+      //  - div \mathbf{u} = \frac{1}{\rho} \frac{\partial rho}{\partial p} \rho \mathbf{g} \cdot \mathbf{u}
+
+      // Compared to the manual, this term seems to have the wrong sign, but
+      // this is because we negate the entire equation to make sure we get
+      // -div(u) as the adjoint operator of grad(p)
+
+      Assert(this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::isentropic_compression,
+             ExcInternalError());
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+
+          const double compressibility
+            = scratch.material_model_outputs.compressibilities[q];
+
+          const double density = scratch.material_model_outputs.densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            data.local_rhs(i) += (
+                                   (pressure_scaling *
+                                    compressibility * density *
+                                    (scratch.velocity_values[q] * gravity) *
+                                    scratch.phi_p[i])
+                                 )
+                                 * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesProjectedDensityFieldTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      // assemble RHS of:
+      // $ - \nabla \cdot \mathbf{u} = \frac{1}{\rho} \frac{\partial \rho}{\partial t} + \frac{1}{\rho} \nabla \rho \cdot \mathbf{u}$
+
+      // Compared to the manual, this term seems to have the wrong sign, but
+      // this is because we negate the entire equation to make sure we get
+      // -div(u) as the adjoint operator of grad(p)
+
+      Assert(this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::projected_density_field,
+             ExcInternalError());
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+      const unsigned int density_idx = this->introspection().find_composition_type(CompositionalFieldDescription::density);
+
+      const double time_step = this->get_timestep();
+      const double old_time_step = this->get_old_timestep();
+
+      std::vector<Tensor<1,dim>> density_gradients(n_q_points);
+      std::vector<double> density(n_q_points);
+      std::vector<double> density_old(n_q_points);
+      std::vector<double> density_old_old(n_q_points);
+
+      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_gradients (this->get_current_linearization_point(),
+          density_gradients);
+      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_current_linearization_point(),
+          density);
+      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_old_solution(),
+          density_old);
+      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_old_old_solution(),
+          density_old_old);
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          double drho_dt;
+
+          if (this->get_timestep_number() > 1)
+            drho_dt = (1.0/time_step) *
+                      (density[q] *
+                       (2*time_step + old_time_step) / (time_step + old_time_step)
+                       -
+                       density_old[q] *
+                       (1 + time_step/old_time_step)
+                       +
+                       density_old_old[q] *
+                       (time_step * time_step) / (old_time_step * (time_step + old_time_step)));
+          else if (this->get_timestep_number() == 1)
+            drho_dt =
+              (density[q] - density_old[q]) / time_step;
+          else
+            drho_dt = 0.0;
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            data.local_rhs(i) += (
+                                   (pressure_scaling *
+                                    (1.0 / density[q]) *
+                                    (density_gradients[q] *
+                                     scratch.velocity_values[q]) *
+                                    scratch.phi_p[i])
+                                   + pressure_scaling * (1.0 / density[q]) * drho_dt * scratch.phi_p[i]
+                                 )
+                                 * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesHydrostaticCompressionTerm<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      // assemble RHS of:
+      // $ -\nabla \cdot \mathbf{u} = \left( \kappa \rho \textbf{g} - \alpha \nabla T \right) \cdot \textbf{u}$
+      //
+      // where $\frac{1}{\rho} \frac{\partial \rho}{\partial p} = \kappa$ is the compressibility,
+      // $- \frac{1}{\rho}\frac{\partial \rho}{\partial T} = \alpha$ is the thermal expansion coefficient,
+      // and both are defined in the material model.
+
+      // Compared to the manual, this term seems to have the wrong sign, but
+      // this is because we negate the entire equation to make sure we get
+      // -div(u) as the adjoint operator of grad(p)
+
+      Assert(this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::hydrostatic_compression,
+             ExcInternalError());
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+
+          const double compressibility
+            = scratch.material_model_outputs.compressibilities[q];
+
+          const double thermal_alpha
+            = scratch.material_model_outputs.thermal_expansion_coefficients[q];
+
+          const double density = scratch.material_model_outputs.densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            data.local_rhs(i) += (
+                                   (pressure_scaling *
+                                    (
+                                      // pressure part:
+                                      compressibility * density *
+                                      (scratch.velocity_values[q] * gravity)
+                                      // temperature part:
+                                      - thermal_alpha *
+                                      (scratch.velocity_values[q] * scratch.temperature_gradients[q])
+                                    ) * scratch.phi_p[i])
+                                 )
+                                 * JxW;
+
+        }
+    }
+
+
+    template <int dim>
+    void
+    StokesPressureRHSCompatibilityModification<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                                                              internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = scratch.finite_element_values.get_fe();
+
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+          {
+            if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+              {
+                scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                data.local_pressure_shape_function_integrals(i_stokes) += scratch.phi_p[i_stokes] * scratch.finite_element_values.JxW(q);
+                ++i_stokes;
+              }
+            ++i;
+          }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesBoundaryTraction<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+                                          internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = scratch.finite_element_values.get_fe();
+
+      // see if any of the faces are traction boundaries for which
+      // we need to assemble force terms for the right hand side
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+
+      const typename DoFHandler<dim>::face_iterator face = scratch.cell->face(scratch.face_number);
+
+      if (this->get_boundary_traction_manager().get_active_boundary_traction_names().find (face->boundary_id())
+          !=
+          this->get_boundary_traction_manager().get_active_boundary_traction_names().end())
+        {
+          for (unsigned int q=0; q<scratch.face_finite_element_values.n_quadrature_points; ++q)
+            {
+              const Tensor<1,dim> traction
+                = this->get_boundary_traction_manager().
+                  boundary_traction (face->boundary_id(),
+                                     scratch.face_finite_element_values.quadrature_point(q),
+                                     scratch.face_finite_element_values.normal_vector(q));
+
+              for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+                {
+                  if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                    {
+                      data.local_rhs(i_stokes) += scratch.face_finite_element_values[introspection.extractors.velocities].value(i,q) *
+                                                  traction *
+                                                  scratch.face_finite_element_values.JxW(q);
+                      ++i_stokes;
+                    }
+                  ++i;
+                }
+            }
+        }
+    }
+  }
+} // namespace aspect
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace Assemblers
+  {
+#define INSTANTIATE(dim) \
+  template class StokesPreconditioner<dim>; \
+  template class StokesCompressiblePreconditioner<dim>; \
+  template class StokesIncompressibleTerms<dim>; \
+  template class StokesCompressibleStrainRateViscosityTerm<dim>; \
+  template class StokesReferenceDensityCompressibilityTerm<dim>; \
+  template class StokesImplicitReferenceDensityCompressibilityTerm<dim>; \
+  template class StokesIsentropicCompressionTerm<dim>; \
+  template class StokesHydrostaticCompressionTerm<dim>; \
+  template class StokesProjectedDensityFieldTerm<dim>; \
+  template class StokesPressureRHSCompatibilityModification<dim>; \
+  template class StokesBoundaryTraction<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/simulator/assembly.cc.bak b/source/simulator/assembly.cc.bak
new file mode 100644
index 00000000000..5142237c083
--- /dev/null
+++ b/source/simulator/assembly.cc.bak
@@ -0,0 +1,1301 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+#include <aspect/compat.h>
+#include <aspect/simulator_access.h>
+#include <aspect/citation_info.h>
+
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/melt.h>
+#include <aspect/newton.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/simulator/assemblers/stokes.h>
+#include <aspect/simulator/assemblers/advection.h>
+
+#include <aspect/stokes_matrix_free.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/work_stream.h>
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/lac/full_matrix.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/grid/filtered_iterator.h>
+#include <deal.II/dofs/dof_accessor.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/fe/fe_values.h>
+
+
+
+namespace aspect
+{
+  namespace
+  {
+    // This function initializes the simulator access for all assemblers
+    // inside of the assemblers parameter. This is just a shortcut to save some
+    // lines in set_assemblers(), where this operation appears multiple times.
+    template <int dim, class AssemblerType>
+    void
+    initialize_simulator(const Simulator<dim> &simulator,
+                         std::vector<std::unique_ptr<AssemblerType>> &assemblers)
+    {
+      for (unsigned int i=0; i<assemblers.size(); ++i)
+        if (SimulatorAccess<dim> *p = dynamic_cast<SimulatorAccess<dim>*>(assemblers[i].get()))
+          p->initialize_simulator(simulator);
+    }
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  set_stokes_assemblers()
+  {
+    assemblers->stokes_preconditioner.push_back(std::make_unique<aspect::Assemblers::StokesPreconditioner<dim>>());
+    assemblers->stokes_system.push_back(std::make_unique<aspect::Assemblers::StokesIncompressibleTerms<dim>>());
+
+    if (material_model->is_compressible())
+      {
+        // The compressible part of the preconditioner is only necessary if we use the simplified A block
+        if (parameters.use_full_A_block_preconditioner == false)
+          assemblers->stokes_preconditioner.push_back(
+            std::make_unique<aspect::Assemblers::StokesCompressiblePreconditioner<dim>>());
+
+        assemblers->stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::StokesCompressibleStrainRateViscosityTerm<dim>>());
+      }
+
+    if (parameters.formulation_mass_conservation ==
+        Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile)
+      {
+        assemblers->stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::StokesImplicitReferenceDensityCompressibilityTerm<dim>>());
+      }
+    else if (parameters.formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::reference_density_profile)
+      {
+        assemblers->stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::StokesReferenceDensityCompressibilityTerm<dim>>());
+      }
+    else if (parameters.formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::incompressible)
+      {
+        // do nothing, because we assembled div u =0 above already
+      }
+    else if (parameters.formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::isentropic_compression)
+      {
+        assemblers->stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::StokesIsentropicCompressionTerm<dim>>());
+      }
+    else if (parameters.formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::hydrostatic_compression)
+      {
+        assemblers->stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::StokesHydrostaticCompressionTerm<dim>>());
+      }
+    else if (parameters.formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::projected_density_field)
+      {
+        CitationInfo::add("pda");
+        assemblers->stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::StokesProjectedDensityFieldTerm<dim>>());
+      }
+    else
+      AssertThrow(false,
+                  ExcMessage("Unknown mass conservation equation approximation. There is no assembler"
+                             " defined that handles this formulation."));
+
+    // add the terms for traction boundary conditions
+    if (!boundary_traction_manager.get_active_boundary_traction_names().empty())
+      {
+        assemblers->stokes_system_on_boundary_face.push_back(
+          std::make_unique<aspect::Assemblers::StokesBoundaryTraction<dim>>());
+      }
+
+    // add the terms necessary to normalize the pressure
+    if (do_pressure_rhs_compatibility_modification)
+      assemblers->stokes_system.push_back(
+        std::make_unique<aspect::Assemblers::StokesPressureRHSCompatibilityModification<dim>>());
+
+  }
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  set_advection_assemblers()
+  {
+    // Loop over all advection fields and add the assemblers that each field uses. i=0 is the temperature.
+    for (unsigned int i=0; i<1+introspection.n_compositional_fields; ++i)
+      {
+        if ((i==0 && parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::fem_field)
+            ||
+            (i>0 && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_field))
+          assemblers->advection_system[i].push_back(
+            std::make_unique<aspect::Assemblers::AdvectionSystem<dim>>());
+
+        // Only add the diffusion assembler if advection field i uses the prescribed_field_with_diffusion method.
+        if ((i==0 && parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion)
+            ||
+            (i>0 && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion))
+          assemblers->advection_system[i].push_back(
+            std::make_unique<aspect::Assemblers::DiffusionSystem<dim>>());
+
+        // Add the darcy assemblers if we have fields that use this method
+        if (i>0 && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_darcy_field)
+          assemblers->advection_system[i].push_back(
+            std::make_unique<aspect::Assemblers::DarcySystem<dim>>());
+
+        if ((i==0 && parameters.use_discontinuous_temperature_discretization
+             && parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::fem_field)
+            ||
+            (i>0 && parameters.use_discontinuous_composition_discretization[i-1]
+             && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_field))
+          {
+            assemblers->advection_system_on_boundary_face[i].push_back(
+              std::make_unique<aspect::Assemblers::AdvectionSystemBoundaryFace<dim>>());
+
+            assemblers->advection_system_on_interior_face[i].push_back(
+              std::make_unique<aspect::Assemblers::AdvectionSystemInteriorFace<dim>>());
+          }
+
+        if (i==0 && parameters.fixed_heat_flux_boundary_indicators.size() != 0)
+          {
+            assemblers->advection_system_on_boundary_face[i].push_back(
+              std::make_unique<aspect::Assemblers::AdvectionSystemBoundaryHeatFlux<dim>>());
+          }
+
+        if (parameters.use_discontinuous_temperature_discretization
+            || parameters.fixed_heat_flux_boundary_indicators.size() != 0)
+          {
+            assemblers->advection_system_assembler_on_face_properties[0].need_face_material_model_data = true;
+            assemblers->advection_system_assembler_on_face_properties[0].need_face_finite_element_evaluation = true;
+          }
+
+        if (i > 0 && parameters.use_discontinuous_composition_discretization[i-1]
+            && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_field)
+          {
+            assemblers->advection_system_assembler_on_face_properties[i].need_face_material_model_data = true;
+            assemblers->advection_system_assembler_on_face_properties[i].need_face_finite_element_evaluation = true;
+          }
+      }
+
+    if (parameters.use_discontinuous_temperature_discretization ||
+        parameters.have_discontinuous_composition_discretization)
+      {
+        const bool dc_temperature = parameters.use_discontinuous_temperature_discretization && parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::fem_field;
+        bool dc_composition = false;
+
+        for (unsigned int c=0; c<parameters.n_compositional_fields; ++c)
+          {
+            if (parameters.use_discontinuous_composition_discretization[c]
+                && parameters.compositional_field_methods[c] == Parameters<dim>::AdvectionFieldMethod::fem_field)
+              {
+                dc_composition = true;
+                break;
+              }
+          }
+
+        const bool no_dc_field_method = !dc_temperature && !dc_composition;
+
+        // TODO: This currently does not work in parallel, because the sparsity
+        // pattern of the matrix does not seem to know about flux terms
+        // across periodic faces of different levels. Fix this.
+        AssertThrow(geometry_model->get_periodic_boundary_pairs().size() == 0 ||
+                    Utilities::MPI::n_mpi_processes(mpi_communicator) == 1 ||
+                    no_dc_field_method ||
+                    (parameters.initial_adaptive_refinement == 0 &&
+                     parameters.adaptive_refinement_interval == 0),
+                    ExcMessage("Combining discontinuous elements with periodic boundaries and "
+                               "adaptive mesh refinement in parallel models is currently not supported. "
+                               "Please switch off any of those options or run on a single process."));
+      }
+  }
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  set_assemblers ()
+  {
+    // first let the manager delete all existing assemblers:
+    assemblers->reset();
+
+    assemblers->advection_system.resize(1+introspection.n_compositional_fields);
+    assemblers->advection_system_on_boundary_face.resize(1+introspection.n_compositional_fields);
+    assemblers->advection_system_on_interior_face.resize(1+introspection.n_compositional_fields);
+    assemblers->advection_system_assembler_properties.resize(1+introspection.n_compositional_fields);
+    assemblers->advection_system_assembler_on_face_properties.resize(1+introspection.n_compositional_fields);
+
+    // Set up the set of assemblers depending on the mode of equations
+    if (!parameters.include_melt_transport
+        && !assemble_newton_stokes_system)
+      {
+        set_advection_assemblers();
+        set_stokes_assemblers();
+      }
+    else if (parameters.include_melt_transport
+             && !assemble_newton_stokes_system)
+      {
+        melt_handler->set_assemblers(*assemblers);
+      }
+    else if (!parameters.include_melt_transport
+             && assemble_newton_stokes_system)
+      {
+        set_advection_assemblers();
+        newton_handler->set_assemblers(*assemblers);
+      }
+    else if (parameters.include_melt_transport
+             && assemble_newton_stokes_system)
+      {
+        AssertThrow (false,
+                     ExcMessage("The melt implementation does not support the Newton solver at the moment."));
+      }
+    else
+      AssertThrow(false,ExcInternalError());
+
+    // allow other assemblers to add themselves or modify the existing ones by firing the signal
+    this->signals.set_assemblers(*this, *assemblers);
+
+    // ensure that all assembler objects have access to the SimulatorAccess
+    // base class
+    initialize_simulator(*this,assemblers->stokes_preconditioner);
+    initialize_simulator(*this,assemblers->stokes_system);
+    initialize_simulator(*this,assemblers->stokes_system_on_boundary_face);
+
+    for (unsigned int i=0; i<1+introspection.n_compositional_fields; ++i)
+      {
+        initialize_simulator(*this,assemblers->advection_system[i]);
+        initialize_simulator(*this,assemblers->advection_system_on_boundary_face[i]);
+        initialize_simulator(*this,assemblers->advection_system_on_interior_face[i]);
+      }
+  }
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  local_assemble_stokes_preconditioner (const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                        internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch,
+                                        internal::Assembly::CopyData::StokesPreconditioner<dim> &data)
+  {
+    // First get all dof indices of the current cell, then extract those
+    // that correspond to the Stokes system we are interested in.
+    // Note that assemblers below can modify this list of dofs, if they in fact
+    // assemble a different system than the standard Stokes system (e.g. in
+    // models with melt transport).
+
+    cell->get_dof_indices (scratch.local_dof_indices);
+    data.extract_stokes_dof_indices(scratch.local_dof_indices, introspection, finite_element);
+
+    // Prepare the data structures for assembly
+    scratch.reinit(cell);
+    data.local_matrix = 0;
+    data.local_inverse_lumped_mass_matrix = 0;
+
+    scratch.material_model_inputs.reinit  (scratch.finite_element_values,
+                                           cell,
+                                           this->introspection,
+                                           current_linearization_point);
+
+    for (unsigned int i=0; i<assemblers->stokes_preconditioner.size(); ++i)
+      assemblers->stokes_preconditioner[i]->create_additional_material_model_outputs(scratch.material_model_outputs);
+
+    material_model->evaluate(scratch.material_model_inputs,
+                             scratch.material_model_outputs);
+    MaterialModel::MaterialAveraging::average (parameters.material_averaging,
+                                               cell,
+                                               scratch.finite_element_values.get_quadrature(),
+                                               scratch.finite_element_values.get_mapping(),
+                                               scratch.material_model_inputs.requested_properties,
+                                               scratch.material_model_outputs);
+
+    for (unsigned int i=0; i<assemblers->stokes_preconditioner.size(); ++i)
+      assemblers->stokes_preconditioner[i]->execute(scratch,data);
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  copy_local_to_global_stokes_preconditioner (const internal::Assembly::CopyData::StokesPreconditioner<dim> &data)
+  {
+    current_constraints.distribute_local_to_global (data.local_matrix,
+                                                    data.local_dof_indices,
+                                                    system_preconditioner_matrix);
+    if (parameters.use_bfbt)
+      current_constraints.distribute_local_to_global(data.local_inverse_lumped_mass_matrix,data.local_dof_indices,inverse_lumped_mass_matrix);
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::assemble_stokes_preconditioner ()
+  {
+    if (stokes_matrix_free)
+      return;
+
+    system_preconditioner_matrix = 0;
+
+    const Quadrature<dim> &quadrature_formula = introspection.quadratures.velocities;
+
+    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
+
+    // determine which update flags to use for the cell integrals
+    const UpdateFlags cell_update_flags
+      = ((update_JxW_values |
+          update_values |
+          update_gradients |
+          update_quadrature_points)
+         |
+         assemblers->stokes_preconditioner_assembler_properties.needed_update_flags);
+
+    unsigned int stokes_dofs_per_cell = dim * finite_element.base_element(introspection.base_elements.velocities).dofs_per_cell
+                                        + finite_element.base_element(introspection.base_elements.pressure).dofs_per_cell;
+
+    if (parameters.include_melt_transport)
+      stokes_dofs_per_cell += finite_element.base_element(introspection.variable("compaction pressure").base_index).dofs_per_cell;
+
+    auto worker = [&](const typename DoFHandler<dim>::active_cell_iterator &cell,
+                      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch,
+                      internal::Assembly::CopyData::StokesPreconditioner<dim> &data)
+    {
+      this->local_assemble_stokes_preconditioner(cell, scratch, data);
+    };
+
+    auto copier = [&](const internal::Assembly::CopyData::StokesPreconditioner<dim> &data)
+    {
+      this->copy_local_to_global_stokes_preconditioner(data);
+    };
+
+    WorkStream::
+    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     dof_handler.begin_active()),
+         CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     dof_handler.end()),
+         worker,
+         copier,
+         internal::Assembly::Scratch::
+         StokesPreconditioner<dim> (finite_element, quadrature_formula,
+                                    *mapping,
+                                    cell_update_flags,
+                                    introspection.n_compositional_fields,
+                                    stokes_dofs_per_cell,
+                                    parameters.include_melt_transport,
+                                    rebuild_stokes_matrix,
+                                    parameters.use_bfbt),
+         internal::Assembly::CopyData::
+         StokesPreconditioner<dim> (stokes_dofs_per_cell));
+
+    system_preconditioner_matrix.compress(VectorOperation::add);
+    if (parameters.use_bfbt)
+      {
+        inverse_lumped_mass_matrix.compress(VectorOperation::add);
+        IndexSet local_indices = inverse_lumped_mass_matrix.block(0).locally_owned_elements();
+        for (auto i: local_indices)
+          {
+            if (current_constraints.is_constrained(i))
+              {
+                inverse_lumped_mass_matrix.block(0)[i] = 1.0;
+              }
+            else
+              {
+                inverse_lumped_mass_matrix.block(0)[i] = 1.0/inverse_lumped_mass_matrix.block(0)[i];
+              }
+          }
+        inverse_lumped_mass_matrix.block(0).compress(VectorOperation::insert);
+      }
+
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::build_stokes_preconditioner ()
+  {
+    if (rebuild_stokes_preconditioner == false)
+      return;
+
+    if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
+      return;
+    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_amg)
+      {
+        // continue below
+      }
+    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::direct_solver)
+      return;
+    else
+      AssertThrow(false, ExcNotImplemented());
+
+    TimerOutput::Scope timer (computing_timer, "Build Stokes preconditioner");
+    pcout << "   Rebuilding Stokes preconditioner..." << std::flush;
+
+    // first assemble the raw matrices necessary for the preconditioner
+    assemble_stokes_preconditioner ();
+
+    // then extract the other information necessary to build the
+    // AMG preconditioners for the A and M blocks
+    std::vector<std::vector<bool>> constant_modes;
+    DoFTools::extract_constant_modes (dof_handler,
+                                      introspection.component_masks.velocities,
+                                      constant_modes);
+
+    // When we solve with melt migration, the pressure block contains
+    // both pressures and contains an elliptic operator, so it makes
+    // sense to use AMG instead of ILU:
+    if (parameters.include_melt_transport)
+      Mp_preconditioner = std::make_unique<LinearAlgebra::PreconditionAMG>();
+    else
+      Mp_preconditioner = std::make_unique<LinearAlgebra::PreconditionILU>();
+
+    Amg_preconditioner = std::make_unique<LinearAlgebra::PreconditionAMG>();
+
+    LinearAlgebra::PreconditionAMG::AdditionalData Amg_data;
+    Amg_data.constant_modes = constant_modes;
+    Amg_data.elliptic = true;
+    Amg_data.higher_order_elements = true;
+
+    // set the AMG parameters in a way that minimizes the run
+    // time. compared to some of the deal.II tutorial programs, we
+    // found that it pays off to set the aggregation threshold to
+    // zero, especially for ill-conditioned problems with large
+    // variations in the viscosity
+    //
+    // for extensive benchmarking of various settings of these
+    // parameters and others, see
+    // https://github.com/geodynamics/aspect/pull/234
+    Amg_data.smoother_type = parameters.AMG_smoother_type.c_str();
+    Amg_data.smoother_sweeps = parameters.AMG_smoother_sweeps;
+    Amg_data.aggregation_threshold = parameters.AMG_aggregation_threshold;
+    Amg_data.output_details = parameters.AMG_output_details;
+
+    /*  The stabilization term for the free surface (Kaus et. al., 2010)
+     *  makes changes to the system matrix which are of the same form as
+     *  boundary stresses. If these stresses are not also added to the
+     *  system_preconditioner_matrix, then it fails to be very good as a
+     *  preconditioner. Instead, we just pass the system_matrix to the
+     *  AMG precondition initialization so that it builds the preconditioner
+     *  directly from that. However, we still need the mass matrix for the
+     *  pressure block which is assembled in the preconditioner matrix.
+     *  So rather than build a different preconditioner matrix which only
+     *  does the mass matrix, we just reuse the same system_preconditioner_matrix
+     *  for the Mp_preconditioner block.  Maybe a bit messy*/
+
+    if (parameters.include_melt_transport == false)
+      {
+        LinearAlgebra::PreconditionILU *Mp_preconditioner_ILU
+          = dynamic_cast<LinearAlgebra::PreconditionILU *> (Mp_preconditioner.get());
+        Mp_preconditioner_ILU->initialize (system_preconditioner_matrix.block(1,1));
+      }
+    else
+      {
+        // in the case of melt transport we have an AMG preconditioner for the lower right block.
+        LinearAlgebra::PreconditionAMG::AdditionalData Amg_data;
+        std::vector<std::vector<bool>> constant_modes;
+        dealii::ComponentMask cm_pressure = introspection.component_masks.pressure;
+        if (parameters.include_melt_transport)
+          cm_pressure = cm_pressure | introspection.variable("compaction pressure").component_mask;
+        DoFTools::extract_constant_modes (dof_handler,
+                                          cm_pressure,
+                                          constant_modes);
+
+        Amg_data.elliptic = true;
+        Amg_data.higher_order_elements = false;
+
+        Amg_data.smoother_sweeps = 2;
+        Amg_data.coarse_type = "symmetric Gauss-Seidel";
+
+        LinearAlgebra::PreconditionAMG *Mp_preconditioner_AMG
+          = dynamic_cast<LinearAlgebra::PreconditionAMG *> (Mp_preconditioner.get());
+        Mp_preconditioner_AMG->initialize (system_preconditioner_matrix.block(1,1), Amg_data);
+      }
+
+    if (parameters.use_full_A_block_preconditioner)
+      Amg_preconditioner->initialize (system_matrix.block(0,0),
+                                      Amg_data);
+    else
+      Amg_preconditioner->initialize (system_preconditioner_matrix.block(0,0),
+                                      Amg_data);
+
+    rebuild_stokes_preconditioner = false;
+
+    pcout << std::endl;
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  local_assemble_stokes_system (const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                internal::Assembly::Scratch::StokesSystem<dim> &scratch,
+                                internal::Assembly::CopyData::StokesSystem<dim> &data)
+  {
+    // First get all dof indices of the current cell, then extract those
+    // that correspond to the Stokes system we are interested in.
+    // Note that assemblers below can modify this list of dofs, if they in fact
+    // assemble a different system than the standard Stokes system (e.g. in
+    // models with melt transport).
+    cell->get_dof_indices (scratch.local_dof_indices);
+
+    data.extract_stokes_dof_indices (scratch.local_dof_indices, introspection, finite_element);
+
+    // Prepare the data structures for assembly
+    scratch.reinit(cell);
+
+    if (rebuild_stokes_matrix)
+      data.local_matrix = 0;
+    data.local_rhs = 0;
+    if (do_pressure_rhs_compatibility_modification)
+      data.local_pressure_shape_function_integrals = 0;
+
+    // initialize the material model data on the cell
+    const bool need_viscosity =
+      assemble_newton_stokes_system || this->parameters.enable_prescribed_dilation || rebuild_stokes_matrix;
+
+    scratch.material_model_inputs.reinit  (scratch.finite_element_values,
+                                           cell,
+                                           this->introspection,
+                                           current_linearization_point);
+
+    scratch.material_model_inputs.requested_properties
+      =
+        MaterialModel::MaterialProperties::equation_of_state_properties |
+        MaterialModel::MaterialProperties::additional_outputs
+        |
+        (need_viscosity ? MaterialModel::MaterialProperties::viscosity : MaterialModel::MaterialProperties::uninitialized);
+
+    for (unsigned int i=0; i<assemblers->stokes_system.size(); ++i)
+      assemblers->stokes_system[i]->create_additional_material_model_outputs(scratch.material_model_outputs);
+
+    material_model->evaluate(scratch.material_model_inputs,
+                             scratch.material_model_outputs);
+    MaterialModel::MaterialAveraging::average (parameters.material_averaging,
+                                               cell,
+                                               scratch.finite_element_values.get_quadrature(),
+                                               scratch.finite_element_values.get_mapping(),
+                                               scratch.material_model_inputs.requested_properties,
+                                               scratch.material_model_outputs);
+
+    scratch.finite_element_values[introspection.extractors.velocities].get_function_values(current_linearization_point,
+        scratch.velocity_values);
+    if (assemble_newton_stokes_system)
+      scratch.finite_element_values[introspection.extractors.velocities].get_function_divergences(current_linearization_point,scratch.velocity_divergence);
+    if (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::hydrostatic_compression)
+      scratch.finite_element_values[introspection.extractors.temperature].get_function_gradients(current_linearization_point,
+          scratch.temperature_gradients);
+
+
+    const bool use_reference_density_profile = (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::reference_density_profile)
+                                               || (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile);
+    if (use_reference_density_profile)
+      {
+        for (unsigned int q=0; q<scratch.finite_element_values.n_quadrature_points; ++q)
+          {
+            scratch.reference_densities[q] = adiabatic_conditions->density(scratch.material_model_inputs.position[q]);
+            scratch.reference_densities_depth_derivative[q] = adiabatic_conditions->density_derivative(scratch.material_model_inputs.position[q]);
+          }
+      }
+
+
+    // trigger the invocation of the various functions that actually do
+    // all of the assembling
+    for (unsigned int i=0; i<assemblers->stokes_system.size(); ++i)
+      assemblers->stokes_system[i]->execute(scratch,data);
+
+    if (!assemblers->stokes_system_on_boundary_face.empty())
+      {
+        // then also work on possible face terms. if necessary, initialize
+        // the material model data on faces
+        for (const unsigned int face_number : cell->face_indices())
+          if (cell->at_boundary(face_number) && !cell->has_periodic_neighbor(face_number))
+            {
+              scratch.reinit(cell, face_number);
+              if (assemblers->stokes_system_assembler_on_boundary_face_properties.need_face_material_model_data)
+                {
+                  const bool need_viscosity = rebuild_stokes_matrix |
+                                              assemblers->stokes_system_assembler_on_boundary_face_properties.need_viscosity;
+
+                  scratch.face_material_model_inputs.reinit  (scratch.face_finite_element_values,
+                                                              cell,
+                                                              this->introspection,
+                                                              current_linearization_point);
+
+                  for (unsigned int i=0; i<assemblers->stokes_system_on_boundary_face.size(); ++i)
+                    assemblers->stokes_system_on_boundary_face[i]->create_additional_material_model_outputs(scratch.face_material_model_outputs);
+
+                  scratch.face_material_model_inputs.requested_properties
+                    = (MaterialModel::MaterialProperties::equation_of_state_properties |
+                       MaterialModel::MaterialProperties::additional_outputs |
+                       (need_viscosity ? MaterialModel::MaterialProperties::viscosity : MaterialModel::MaterialProperties::uninitialized));
+
+
+                  material_model->evaluate(scratch.face_material_model_inputs,
+                                           scratch.face_material_model_outputs);
+
+                  // TODO: Currently we do not supply reference density values to Stokes face assemblers.
+                  // This seems acceptable for now, since the only face assemblers are the ones for the melt
+                  // assembly where one would not want to use the reference density anyway. In case the reference
+                  // density is ever needed, those assemblers can also query the adiabatic conditions for the
+                  // reference density.
+
+                  // TODO: the following doesn't currently compile because the get_quadrature() call returns
+                  //  a dim-1 dimensional quadrature
+                  // MaterialModel::MaterialAveraging::average (parameters.material_averaging,
+                  //                                            cell,
+                  //                                            compressibility * density *
+                  //                                            scratch.face_finite_element_values.get_mapping(),
+                  //                                            scratch.face_material_model_outputs);
+                }
+
+              for (unsigned int i=0; i<assemblers->stokes_system_on_boundary_face.size(); ++i)
+                assemblers->stokes_system_on_boundary_face[i]->execute(scratch,data);
+            }
+      }
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  copy_local_to_global_stokes_system (const internal::Assembly::CopyData::StokesSystem<dim> &data)
+  {
+    if (rebuild_stokes_matrix == true)
+      current_constraints.distribute_local_to_global (data.local_matrix,
+                                                      data.local_rhs,
+                                                      data.local_dof_indices,
+                                                      system_matrix,
+                                                      system_rhs);
+    else
+      current_constraints.distribute_local_to_global (data.local_rhs,
+                                                      data.local_dof_indices,
+                                                      system_rhs);
+
+    if (do_pressure_rhs_compatibility_modification)
+      current_constraints.distribute_local_to_global (data.local_pressure_shape_function_integrals,
+                                                      data.local_dof_indices,
+                                                      pressure_shape_function_integrals);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::assemble_stokes_system ()
+  {
+    std::string timer_section_name = "Assemble Stokes system";
+
+    if (assemble_newton_stokes_system)
+      {
+        if (!assemble_newton_stokes_matrix && !stokes_matrix_free)
+          timer_section_name += " rhs";
+        else if (assemble_newton_stokes_matrix && newton_handler->parameters.newton_derivative_scaling_factor == 0)
+          timer_section_name += " Picard";
+        else if (assemble_newton_stokes_matrix && newton_handler->parameters.newton_derivative_scaling_factor != 0)
+          timer_section_name += " Newton";
+      }
+
+    if (stokes_matrix_free)
+      {
+        rebuild_stokes_matrix = false;
+        assemble_newton_stokes_matrix = false;
+        timer_section_name += " rhs";
+      }
+
+    TimerOutput::Scope timer (computing_timer,
+                              timer_section_name);
+
+    // Re-compute the pressure scaling factor.
+    pressure_scaling = compute_pressure_scaling_factor();
+
+    if (rebuild_stokes_matrix == true)
+      system_matrix = 0;
+
+    // We are using constraints.distribute_local_to_global() without a matrix
+    // if we do not rebuild the Stokes matrix. This produces incorrect results
+    // when having inhomogeneous constraints. Make sure that we can not have
+    // this situation (no active boundary conditions means that only
+    // no-slip/free slip are used). This should not happen as we set this up
+    // correctly before calling this function.
+    // Note that for Dirichlet boundary conditions in matrix-free computations,
+    // we will update the right-hand side with boundary information in
+    // StokesMatrixFreeHandler::correct_stokes_rhs().
+    if (!stokes_matrix_free)
+      Assert(rebuild_stokes_matrix || boundary_velocity_manager.get_active_boundary_velocity_conditions().size()==0,
+             ExcInternalError("If we have inhomogeneous constraints, we must re-assemble the system matrix."));
+
+    system_rhs = 0;
+    if (do_pressure_rhs_compatibility_modification)
+      pressure_shape_function_integrals = 0;
+
+    const Quadrature<dim>   &quadrature_formula = introspection.quadratures.velocities;
+    const Quadrature<dim-1> &face_quadrature_formula = introspection.face_quadratures.velocities;
+
+    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
+
+    // determine which updates flags we need on cells and faces
+    const UpdateFlags cell_update_flags
+      = (update_values    |
+         update_gradients |
+         update_quadrature_points  |
+         update_JxW_values)
+        |
+        assemblers->stokes_system_assembler_properties.needed_update_flags;
+    const UpdateFlags face_update_flags
+      = (
+          // see if we need to assemble traction boundary conditions.
+          // only if so do we actually need to have an FEFaceValues object
+          boundary_traction_manager.get_active_boundary_traction_names ().size() > 0
+          ?
+          update_values |
+          update_quadrature_points |
+          update_normal_vectors |
+          update_JxW_values
+          :
+          update_default)
+        |
+        (assemblers->stokes_system_assembler_on_boundary_face_properties.need_face_material_model_data
+         ?
+         // if we need a material model input on the faces, we need to
+         // also be able to compute the strain rate
+         update_gradients
+         :
+         update_default)
+        |
+        assemblers->stokes_system_assembler_on_boundary_face_properties.needed_update_flags;
+
+    unsigned int stokes_dofs_per_cell = dim * finite_element.base_element(introspection.base_elements.velocities).dofs_per_cell
+                                        + finite_element.base_element(introspection.base_elements.pressure).dofs_per_cell;
+
+    if (parameters.include_melt_transport)
+      stokes_dofs_per_cell += finite_element.base_element(introspection.variable("compaction pressure").base_index).dofs_per_cell;
+
+    const bool use_reference_density_profile = (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::reference_density_profile)
+                                               || (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile);
+
+    auto worker = [&](const typename DoFHandler<dim>::active_cell_iterator &cell,
+                      internal::Assembly::Scratch::StokesSystem<dim> &scratch,
+                      internal::Assembly::CopyData::StokesSystem<dim> &data)
+    {
+      this->local_assemble_stokes_system(cell, scratch, data);
+    };
+
+    auto copier = [&](const internal::Assembly::CopyData::StokesSystem<dim> &data)
+    {
+      this->copy_local_to_global_stokes_system(data);
+    };
+
+    WorkStream::
+    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     dof_handler.begin_active()),
+         CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     dof_handler.end()),
+         worker,
+         copier,
+         internal::Assembly::Scratch::
+         StokesSystem<dim> (finite_element, *mapping, quadrature_formula,
+                            face_quadrature_formula,
+                            cell_update_flags,
+                            face_update_flags,
+                            introspection.n_compositional_fields,
+                            stokes_dofs_per_cell,
+                            parameters.include_melt_transport,
+                            use_reference_density_profile,
+                            rebuild_stokes_matrix,
+                            assemble_newton_stokes_matrix,
+                            parameters.use_bfbt),
+         internal::Assembly::CopyData::
+         StokesSystem<dim> (stokes_dofs_per_cell,
+                            do_pressure_rhs_compatibility_modification));
+
+    system_matrix.compress(VectorOperation::add);
+    system_rhs.compress(VectorOperation::add);
+
+    // If we change the system_rhs, matrix-free Stokes must update
+    if (stokes_matrix_free)
+      stokes_matrix_free->assemble();
+
+    // if the model is compressible then we need to adjust the right hand
+    // side of the equation to make it compatible with the matrix on the
+    // left
+    if (do_pressure_rhs_compatibility_modification)
+      {
+        pressure_shape_function_integrals.compress(VectorOperation::add);
+        make_pressure_rhs_compatible(system_rhs);
+      }
+
+    // record that we have just rebuilt the matrix
+    rebuild_stokes_matrix = false;
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::build_advection_preconditioner(const AdvectionField &advection_field,
+                                                 LinearAlgebra::PreconditionILU &preconditioner,
+                                                 const double diagonal_strengthening)
+  {
+    TimerOutput::Scope timer (computing_timer, (advection_field.is_temperature() ?
+                                                "Build temperature preconditioner" :
+                                                "Build composition preconditioner"));
+
+    const unsigned int block_idx = advection_field.block_index(introspection);
+
+
+    LinearAlgebra::PreconditionILU::AdditionalData data;
+    data.ilu_atol = diagonal_strengthening;
+
+    preconditioner.initialize (system_matrix.block(block_idx, block_idx), data);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::
+  local_assemble_advection_system (const AdvectionField     &advection_field,
+                                   const Vector<double>           &viscosity_per_cell,
+                                   const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                   internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
+                                   internal::Assembly::CopyData::AdvectionSystem<dim> &data)
+  {
+    // also have the number of dofs that correspond just to the element for
+    // the system we are currently trying to assemble
+    const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
+
+    Assert (advection_dofs_per_cell < scratch.finite_element_values.get_fe().dofs_per_cell, ExcInternalError());
+    Assert (scratch.grad_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
+    Assert (scratch.phi_field.size() == advection_dofs_per_cell, ExcInternalError());
+
+    const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
+
+    const unsigned int solution_component = advection_field.component_index(introspection);
+
+    scratch.reinit(cell);
+
+    // get all dof indices on the current cell, then extract those
+    // that correspond to the solution_field we are interested in
+    cell->get_dof_indices (scratch.local_dof_indices);
+    for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
+      {
+        if (finite_element.system_to_component_index(i).first == solution_component)
+          {
+            data.local_dof_indices[i_advection] = scratch.local_dof_indices[i];
+            ++i_advection;
+          }
+        ++i;
+      }
+
+    data.local_matrix = 0;
+    data.local_rhs = 0;
+
+    scratch.finite_element_values[solution_field].get_function_values (old_solution,
+                                                                       scratch.old_field_values);
+    scratch.finite_element_values[solution_field].get_function_values (old_old_solution,
+                                                                       scratch.old_old_field_values);
+
+
+    scratch.finite_element_values[introspection.extractors.velocities].get_function_values(current_linearization_point,
+        scratch.current_velocity_values);
+
+    if (parameters.include_melt_transport)
+      scratch.finite_element_values[introspection.extractors.velocities].get_function_divergences(current_linearization_point,
+          scratch.current_velocity_divergences);
+
+    // get the mesh velocity, as we need to subtract it off of the advection systems
+    if (parameters.mesh_deformation_enabled)
+      scratch.finite_element_values[introspection.extractors.velocities].get_function_values(mesh_deformation->mesh_velocity,
+          scratch.mesh_velocity_values);
+
+    // compute material properties and heating terms
+    scratch.material_model_inputs.reinit  (scratch.finite_element_values,
+                                           cell,
+                                           this->introspection,
+                                           current_linearization_point);
+
+    for (unsigned int i=0; i<1+introspection.n_compositional_fields; ++i)
+      for (unsigned int j=0; j<assemblers->advection_system[i].size(); ++j)
+        assemblers->advection_system[i][j]->create_additional_material_model_outputs(scratch.material_model_outputs);
+
+    heating_model_manager.create_additional_material_model_inputs_and_outputs(scratch.material_model_inputs,
+                                                                              scratch.material_model_outputs);
+    material_model->fill_additional_material_model_inputs(scratch.material_model_inputs,
+                                                          current_linearization_point,
+                                                          scratch.finite_element_values,
+                                                          introspection);
+
+    material_model->evaluate(scratch.material_model_inputs,
+                             scratch.material_model_outputs);
+    if (parameters.formulation_temperature_equation ==
+        Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+      {
+        const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+        for (unsigned int q=0; q<n_q_points; ++q)
+          {
+            scratch.material_model_outputs.densities[q] = adiabatic_conditions->density(scratch.material_model_inputs.position[q]);
+          }
+      }
+
+#ifdef DEBUG
+    // make sure that if the model does not use operator splitting,
+    // the material model outputs do not fill the reaction_rates (because the reaction_terms are used instead)
+    if (!parameters.use_operator_splitting)
+      {
+        material_model->create_additional_named_outputs(scratch.material_model_outputs);
+        MaterialModel::ReactionRateOutputs<dim> *reaction_rate_outputs
+          = scratch.material_model_outputs.template get_additional_output<MaterialModel::ReactionRateOutputs<dim>>();
+
+        Assert(reaction_rate_outputs == nullptr,
+               ExcMessage("You are using a material model where the reaction rate outputs "
+                          "are created even though the operator splitting solver option is "
+                          "not used in the model, this is not supported! "
+                          "If operator splitting is disabled, the reaction_rates should not "
+                          "be created at all. If you want to run a model where reactions are "
+                          "much faster than the advection, which is what the reaction rate "
+                          "outputs are designed for, you should enable operator splitting."));
+      }
+#endif
+
+    MaterialModel::MaterialAveraging::average (parameters.material_averaging,
+                                               cell,
+                                               scratch.finite_element_values.get_quadrature(),
+                                               scratch.finite_element_values.get_mapping(),
+                                               scratch.material_model_inputs.requested_properties,
+                                               scratch.material_model_outputs);
+
+    heating_model_manager.evaluate(scratch.material_model_inputs,
+                                   scratch.material_model_outputs,
+                                   scratch.heating_model_outputs);
+
+    // TODO: Compute artificial viscosity once per timestep instead of each time
+    // temperature system is assembled (as this might happen more than once per
+    // timestep for iterative solvers)
+    scratch.artificial_viscosity = viscosity_per_cell[cell->active_cell_index()];
+    Assert (scratch.artificial_viscosity >= 0, ExcMessage ("The artificial viscosity needs to be a non-negative quantity."));
+
+    // trigger the invocation of the various functions that actually do
+    // all of the assembling
+    for (unsigned int i=0; i<assemblers->advection_system[advection_field.field_index()].size(); ++i)
+      assemblers->advection_system[advection_field.field_index()][i]->execute(scratch,data);
+
+    // then also work on possible face terms. if necessary, initialize
+    // the material model data on faces
+    const bool has_boundary_face_assemblers = !assemblers->advection_system_on_boundary_face[advection_field.field_index()].empty()
+                                              && assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation;
+    const bool has_interior_face_assemblers = !assemblers->advection_system_on_interior_face[advection_field.field_index()].empty()
+                                              && assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation;
+
+    // skip the remainder if no work needs to be done on faces
+    if (!has_boundary_face_assemblers && !has_interior_face_assemblers)
+      return;
+
+    if (has_interior_face_assemblers)
+      {
+        // For interior face contributions loop over all possible
+        // subfaces of the cell, and reset their matrices.
+        for (auto &m : data.local_matrices_ext_int)
+          m = 0;
+        for (auto &m : data.local_matrices_int_ext)
+          m = 0;
+        for (auto &m : data.local_matrices_ext_ext)
+          m = 0;
+        // Mark the arrays initialized to zero above as currently all unused
+        std::fill (data.assembled_matrices.begin(), data.assembled_matrices.end(),
+                   false);
+      }
+
+    for (scratch.face_number=0; scratch.face_number<cell->n_faces(); ++scratch.face_number)
+      {
+        const typename DoFHandler<dim>::face_iterator face = cell->face (scratch.face_number);
+
+        if ((has_boundary_face_assemblers && face->at_boundary()) ||
+            (has_interior_face_assemblers && !face->at_boundary()))
+          {
+            (*scratch.face_finite_element_values).reinit (cell, scratch.face_number);
+
+            (*scratch.face_finite_element_values)[introspection.extractors.velocities].get_function_values(current_linearization_point,
+                scratch.face_current_velocity_values);
+
+            // get the mesh velocity, as we need to subtract it off of the advection systems
+            if (parameters.mesh_deformation_enabled)
+              (*scratch.face_finite_element_values)[introspection.extractors.velocities].get_function_values(mesh_deformation->mesh_velocity,
+                  scratch.face_mesh_velocity_values);
+
+            if (assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_material_model_data)
+              {
+                scratch.face_material_model_inputs.reinit  (*scratch.face_finite_element_values,
+                                                            cell,
+                                                            this->introspection,
+                                                            current_linearization_point);
+
+                for (unsigned int i=0; i<assemblers->advection_system_on_boundary_face[advection_field.field_index()].size(); ++i)
+                  assemblers->advection_system_on_boundary_face[advection_field.field_index()][i]->create_additional_material_model_outputs(scratch.face_material_model_outputs);
+
+                for (unsigned int i=0; i<assemblers->advection_system_on_interior_face[advection_field.field_index()].size(); ++i)
+                  assemblers->advection_system_on_interior_face[advection_field.field_index()][i]->create_additional_material_model_outputs(scratch.face_material_model_outputs);
+
+                heating_model_manager.create_additional_material_model_inputs_and_outputs(scratch.face_material_model_inputs,
+                                                                                          scratch.face_material_model_outputs);
+                material_model->fill_additional_material_model_inputs(scratch.face_material_model_inputs,
+                                                                      current_linearization_point,
+                                                                      *scratch.face_finite_element_values,
+                                                                      introspection);
+
+                material_model->evaluate(scratch.face_material_model_inputs,
+                                         scratch.face_material_model_outputs);
+
+                if (parameters.formulation_temperature_equation ==
+                    Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+                  {
+                    const unsigned int n_q_points = scratch.face_finite_element_values->n_quadrature_points;
+                    for (unsigned int q=0; q<n_q_points; ++q)
+                      {
+                        scratch.face_material_model_outputs.densities[q] = adiabatic_conditions->density(scratch.face_material_model_inputs.position[q]);
+                      }
+                  }
+
+                heating_model_manager.evaluate(scratch.face_material_model_inputs,
+                                               scratch.face_material_model_outputs,
+                                               scratch.face_heating_model_outputs);
+                // TODO: the following doesn't currently compile because the get_quadrature() call returns
+                //  a dim-1 dimensional quadrature
+                // MaterialModel::MaterialAveraging::average (parameters.material_averaging,
+                //                                            cell,
+                //                                            scratch.face_finite_element_values.get_quadrature(),
+                //                                            scratch.face_finite_element_values.get_mapping(),
+                //                                            scratch.face_material_model_outputs);
+              }
+
+            // handle faces at periodic boundaries like interior faces
+            if (face->at_boundary() && !cell->has_periodic_neighbor (scratch.face_number))
+              for (unsigned int i=0; i<assemblers->advection_system_on_boundary_face[advection_field.field_index()].size(); ++i)
+                assemblers->advection_system_on_boundary_face[advection_field.field_index()][i]->execute(scratch,data);
+            else
+              for (unsigned int i=0; i<assemblers->advection_system_on_interior_face[advection_field.field_index()].size(); ++i)
+                assemblers->advection_system_on_interior_face[advection_field.field_index()][i]->execute(scratch,data);
+          }
+      }
+  }
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  copy_local_to_global_advection_system (const AdvectionField &advection_field,
+                                         const internal::Assembly::CopyData::AdvectionSystem<dim> &data)
+  {
+    // copy entries into the global matrix. note that these local contributions
+    // only correspond to the advection dofs, as assembled above
+    current_constraints.distribute_local_to_global (data.local_matrix,
+                                                    data.local_rhs,
+                                                    data.local_dof_indices,
+                                                    system_matrix,
+                                                    system_rhs);
+
+    // In the following, we copy DG contributions entry by entry. This
+    // is allowed since there are no constraints imposed on discontinuous fields.
+    if (!assemblers->advection_system_on_interior_face.empty() &&
+        assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation)
+      {
+        for (unsigned int f=0; f<data.assembled_matrices.size(); ++f)
+          if (data.assembled_matrices[f])
+            {
+              for (unsigned int i=0; i<data.local_dof_indices.size(); ++i)
+                for (unsigned int j=0; j<data.neighbor_dof_indices[f].size(); ++j)
+                  {
+                    system_matrix.add (data.local_dof_indices[i],
+                                       data.neighbor_dof_indices[f][j],
+                                       data.local_matrices_int_ext[f](i,j));
+                    system_matrix.add (data.neighbor_dof_indices[f][j],
+                                       data.local_dof_indices[i],
+                                       data.local_matrices_ext_int[f](j,i));
+                  }
+
+              for (unsigned int i=0; i<data.neighbor_dof_indices[f].size(); ++i)
+                for (unsigned int j=0; j<data.neighbor_dof_indices[f].size(); ++j)
+                  system_matrix.add (data.neighbor_dof_indices[f][i],
+                                     data.neighbor_dof_indices[f][j],
+                                     data.local_matrices_ext_ext[f](i,j));
+            }
+      }
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::assemble_advection_system (const AdvectionField &advection_field)
+  {
+    TimerOutput::Scope timer (computing_timer, (advection_field.is_temperature() ?
+                                                "Assemble temperature system" :
+                                                "Assemble composition system"));
+
+    const unsigned int block_idx = advection_field.block_index(introspection);
+    const unsigned int sparsity_block_idx = advection_field.sparsity_pattern_block_index(introspection);
+
+    if (!advection_field.is_temperature() && sparsity_block_idx != block_idx)
+      {
+        // We need to allocate our matrix in block block_idx with the sparsity
+        // pattern stored in block sparsity_block_idx and we will free the memory
+        // again after solving. This way we can reuse the sparsity pattern and
+        // save memory by only having 1 compositional matrix allocated at a time.
+        // If all compositional fields are the same, only composition 0 is non-empty
+        // at this time.
+        system_matrix.block(block_idx, block_idx).reinit(system_matrix.block(sparsity_block_idx, sparsity_block_idx));
+      }
+
+    system_matrix.block(block_idx, block_idx) = 0;
+    system_rhs.block(block_idx) = 0;
+
+
+    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
+
+    Vector<double> viscosity_per_cell;
+    viscosity_per_cell.reinit(triangulation.n_active_cells());
+    get_artificial_viscosity(viscosity_per_cell, advection_field);
+
+    // We have to assemble the term u.grad phi_i * phi_j, which is
+    // of total polynomial degree
+    //   stokes_deg + 2*temp_deg -1
+    // (or similar for comp_deg). This suggests using a Gauss
+    // quadrature formula of order
+    //   temp_deg + stokes_deg/2
+    // rounded up (note that x/2 rounded up
+    // equals (x+1)/2 using integer division.)
+    //
+    // (Note: All compositional fields have the same base element and therefore
+    // the same composition_degree. Thus, we do not need to find out the degree
+    // of the current field, but use the global instead)
+    const unsigned int advection_quadrature_degree = advection_field.polynomial_degree(introspection)
+                                                     +
+                                                     (parameters.stokes_velocity_degree+1)/2;
+
+    const bool allocate_face_quadrature = (!assemblers->advection_system_on_boundary_face.empty() ||
+                                           !assemblers->advection_system_on_interior_face.empty()) &&
+                                          assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation;
+    const bool allocate_neighbor_contributions = !assemblers->advection_system_on_interior_face.empty() &&
+                                                 assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation;
+
+    const bool use_supg = (parameters.advection_stabilization_method
+                           == Parameters<dim>::AdvectionStabilizationMethod::supg);
+
+    // When using SUPG, we need to compute hessians to be able to compute the residual:
+    const UpdateFlags update_flags = update_values |
+                                     update_gradients |
+                                     update_quadrature_points |
+                                     update_JxW_values |
+                                     ((use_supg) ? update_hessians : UpdateFlags(0));
+
+    const UpdateFlags face_update_flags = (allocate_face_quadrature ?
+                                           update_values |
+                                           update_gradients |
+                                           update_quadrature_points |
+                                           update_normal_vectors |
+                                           update_JxW_values
+                                           :
+                                           update_default);
+
+    auto worker = [&](const typename DoFHandler<dim>::active_cell_iterator &cell,
+                      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
+                      internal::Assembly::CopyData::AdvectionSystem<dim> &data)
+    {
+      this->local_assemble_advection_system(advection_field, viscosity_per_cell, cell, scratch, data);
+    };
+
+    auto copier = [&](const internal::Assembly::CopyData::AdvectionSystem<dim> &data)
+    {
+      this->copy_local_to_global_advection_system(advection_field, data);
+    };
+
+    WorkStream::
+    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     dof_handler.begin_active()),
+         CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     dof_handler.end()),
+         worker,
+         copier,
+         internal::Assembly::Scratch::
+         AdvectionSystem<dim> (finite_element,
+                               finite_element.base_element(advection_field.base_element(introspection)),
+                               *mapping,
+                               QGauss<dim>(advection_quadrature_degree),
+                               /* Only generate a valid face quadrature if necessary.
+                                * Otherwise, generate invalid face quadrature rule.
+                                */
+                               (allocate_face_quadrature ?
+                                QGauss<dim-1>(advection_quadrature_degree) :
+                                Quadrature<dim-1> ()),
+                               update_flags,
+                               face_update_flags,
+                               introspection.n_compositional_fields,
+                               advection_field),
+         internal::Assembly::CopyData::
+         AdvectionSystem<dim> (finite_element.base_element(advection_field.base_element(introspection)),
+                               allocate_neighbor_contributions));
+
+    system_matrix.compress(VectorOperation::add);
+    system_rhs.compress(VectorOperation::add);
+  }
+}
+
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template void Simulator<dim>::set_assemblers (); \
+  template void Simulator<dim>::local_assemble_stokes_preconditioner ( \
+                                                                       const DoFHandler<dim>::active_cell_iterator &cell, \
+                                                                       internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch, \
+                                                                       internal::Assembly::CopyData::StokesPreconditioner<dim> &data); \
+  template void Simulator<dim>::copy_local_to_global_stokes_preconditioner ( \
+                                                                             const internal::Assembly::CopyData::StokesPreconditioner<dim> &data); \
+  template void Simulator<dim>::assemble_stokes_preconditioner (); \
+  template void Simulator<dim>::build_stokes_preconditioner (); \
+  template void Simulator<dim>::local_assemble_stokes_system ( \
+                                                               const DoFHandler<dim>::active_cell_iterator &cell, \
+                                                               internal::Assembly::Scratch::StokesSystem<dim>  &scratch, \
+                                                               internal::Assembly::CopyData::StokesSystem<dim> &data); \
+  template void Simulator<dim>::copy_local_to_global_stokes_system ( \
+                                                                     const internal::Assembly::CopyData::StokesSystem<dim> &data); \
+  template void Simulator<dim>::assemble_stokes_system (); \
+  template void Simulator<dim>::build_advection_preconditioner (const AdvectionField &, \
+                                                                aspect::LinearAlgebra::PreconditionILU &preconditioner, \
+                                                                const double diagonal_strengthening); \
+  template void Simulator<dim>::local_assemble_advection_system ( \
+                                                                  const AdvectionField          &advection_field, \
+                                                                  const Vector<double>           &viscosity_per_cell, \
+                                                                  const DoFHandler<dim>::active_cell_iterator &cell, \
+                                                                  internal::Assembly::Scratch::AdvectionSystem<dim>  &scratch, \
+                                                                  internal::Assembly::CopyData::AdvectionSystem<dim> &data); \
+  template void Simulator<dim>::copy_local_to_global_advection_system ( \
+                                                                        const AdvectionField          &advection_field, \
+                                                                        const internal::Assembly::CopyData::AdvectionSystem<dim> &data); \
+  template void Simulator<dim>::assemble_advection_system (const AdvectionField     &advection_field);
+
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/checkpoint_restart.cc.bak b/source/simulator/checkpoint_restart.cc.bak
new file mode 100644
index 00000000000..935afb8cb7e
--- /dev/null
+++ b/source/simulator/checkpoint_restart.cc.bak
@@ -0,0 +1,650 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/melt.h>
+
+#include <deal.II/base/mpi.h>
+#include <deal.II/grid/grid_tools.h>
+#include <deal.II/distributed/solution_transfer.h>
+#include <deal.II/fe/mapping_q_cache.h>
+
+#ifdef DEAL_II_WITH_ZLIB
+#  include <zlib.h>
+#endif
+
+namespace aspect
+{
+  namespace
+  {
+    /**
+     * Move/rename a file from the given old to the given new name.
+     */
+    void move_file (const std::string &old_name,
+                    const std::string &new_name)
+    {
+      int error = system (("mv " + old_name + " " + new_name).c_str());
+
+      // If the above call failed, e.g. because there is no command-line
+      // available, try with internal functions.
+      if (error != 0)
+        {
+          if (Utilities::fexists(new_name))
+            {
+              error = remove(new_name.c_str());
+              AssertThrow (error == 0, ExcMessage(std::string ("Unable to remove file: "
+                                                               + new_name
+                                                               + ", although it seems to exist. "
+                                                               + "The error code is "
+                                                               + Utilities::to_string(error) + ".")));
+            }
+
+          error = rename(old_name.c_str(),new_name.c_str());
+          AssertThrow (error == 0, ExcMessage(std::string ("Unable to rename files: ")
+                                              +
+                                              old_name + " -> " + new_name
+                                              + ". The error code is "
+                                              + Utilities::to_string(error) + "."));
+        }
+    }
+  }
+
+
+  namespace
+  {
+    /**
+     * Save a few of the critical parameters of the current run in the
+     * checkpoint file. We will load them again later during
+     * restart to verify that they are the same as the ones set
+     * in the input file active during restart.
+     */
+    template <int dim>
+    void save_critical_parameters (const Parameters<dim> &parameters,
+                                   aspect::oarchive &oa)
+    {
+      oa << parameters.convert_to_years;
+      oa << parameters.surface_pressure;
+      oa << parameters.use_operator_splitting;
+      oa << parameters.include_melt_transport;
+      oa << parameters.stokes_velocity_degree;
+      oa << parameters.use_locally_conservative_discretization;
+      oa << parameters.use_discontinuous_temperature_discretization;
+      oa << parameters.use_discontinuous_composition_discretization;
+      oa << parameters.temperature_degree;
+      oa << parameters.composition_degree;
+      oa << parameters.pressure_normalization;
+      oa << parameters.n_compositional_fields;
+      oa << parameters.names_of_compositional_fields;
+      oa << parameters.normalized_fields;
+      oa << parameters.mesh_deformation_enabled;
+    }
+
+
+
+    /**
+     * Load a few of the critical parameters from a checkpoint file during
+     * restart to verify that they are the same as the ones currently set
+     * in the input file active during restart.
+     */
+    template <int dim>
+    void load_and_check_critical_parameters (const Parameters<dim> &parameters,
+                                             aspect::iarchive &ia)
+    {
+      bool convert_to_years;
+      ia >> convert_to_years;
+      AssertThrow (convert_to_years == parameters.convert_to_years,
+                   ExcMessage ("The value provided for `Use years in output instead of seconds' that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      double surface_pressure;
+      ia >> surface_pressure;
+      AssertThrow (surface_pressure == parameters.surface_pressure,
+                   ExcMessage ("The value of surface pressure that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      bool use_operator_splitting;
+      ia >> use_operator_splitting;
+      AssertThrow (use_operator_splitting == parameters.use_operator_splitting,
+                   ExcMessage ("The operator splitting mode that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      bool include_melt_transport;
+      ia >> include_melt_transport;
+      AssertThrow (include_melt_transport == parameters.include_melt_transport,
+                   ExcMessage ("The melt transport mode that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      unsigned int stokes_velocity_degree;
+      ia >> stokes_velocity_degree;
+      AssertThrow (stokes_velocity_degree == parameters.stokes_velocity_degree,
+                   ExcMessage ("The polynomial degree used for the Stokes "
+                               "finite element that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+
+      // It is conceivable that one could change this setting from one time
+      // step to another, but it is, at best, not tested. So disallow it for
+      // now, until someone tests it.
+      bool use_locally_conservative_discretization;
+      ia >> use_locally_conservative_discretization;
+      AssertThrow (use_locally_conservative_discretization == parameters.use_locally_conservative_discretization,
+                   ExcMessage ("The value provided for `Use locally conservative discretization' that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      bool use_discontinuous_temperature_discretization;
+      ia >> use_discontinuous_temperature_discretization;
+      AssertThrow (use_discontinuous_temperature_discretization == parameters.use_discontinuous_temperature_discretization,
+                   ExcMessage ("The value provided for `Use discontinuous temperature discretization' that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      std::vector<bool> use_discontinuous_composition_discretization;
+      ia >> use_discontinuous_composition_discretization;
+      AssertThrow (use_discontinuous_composition_discretization == parameters.use_discontinuous_composition_discretization,
+                   ExcMessage ("The value provided for `Use discontinuous composition discretization' that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      unsigned int temperature_degree;
+      ia >> temperature_degree;
+      AssertThrow (temperature_degree == parameters.temperature_degree,
+                   ExcMessage ("The temperature polynomial degree that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      unsigned int composition_degree;
+      ia >> composition_degree;
+      AssertThrow (composition_degree == parameters.composition_degree,
+                   ExcMessage ("The composition polynomial degree that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      // One could allow changing the pressure normalization between runs, but
+      // the change would then lead to a jump in pressure from one time step
+      // to the next when we, for example, change from requiring the *surface*
+      // average to be zero, to requiring the *domain* average to be zero.
+      // That's unlikely what the user really wanted. However, we do allow
+      // disabling the pressure normalization in case the user wants to enable
+      // a free surface boundary.
+      std::string pressure_normalization;
+      ia >> pressure_normalization;
+      AssertThrow (pressure_normalization == parameters.pressure_normalization ||
+                   parameters.pressure_normalization == "no",
+                   ExcMessage ("The pressure normalization method that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file and your new "
+                               "pressure normalization method is not 'no'. "
+                               "The only allowed change for the pressure "
+                               "normalization method during a restart is to "
+                               "disable normalization."));
+
+      unsigned int n_compositional_fields;
+      ia >> n_compositional_fields;
+      AssertThrow (n_compositional_fields == parameters.n_compositional_fields,
+                   ExcMessage ("The number of compositional fields that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      std::vector<std::string> names_of_compositional_fields;
+      ia >> names_of_compositional_fields;
+      AssertThrow (names_of_compositional_fields == parameters.names_of_compositional_fields,
+                   ExcMessage ("The names of compositional fields that were stored "
+                               "in the checkpoint file are not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      std::vector<unsigned int> normalized_fields;
+      ia >> normalized_fields;
+      AssertThrow (normalized_fields == parameters.normalized_fields,
+                   ExcMessage ("The list of normalized fields that was stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+      bool mesh_deformation_enabled;
+      ia >> mesh_deformation_enabled;
+      AssertThrow (mesh_deformation_enabled == parameters.mesh_deformation_enabled,
+                   ExcMessage ("The enable mesh deformation settings that were stored "
+                               "in the checkpoint file is not the same as the one "
+                               "you currently set in your input file. "
+                               "These need to be the same during restarting "
+                               "from a checkpoint."));
+
+    }
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::create_snapshot()
+  {
+    TimerOutput::Scope timer (computing_timer, "Create snapshot");
+
+    // Take elapsed time from timer so that we can serialize it:
+    total_walltime_until_last_snapshot += wall_timer.wall_time();
+    wall_timer.restart();
+
+    const unsigned int my_id = Utilities::MPI::this_mpi_process (mpi_communicator);
+
+    // save Triangulation and Solution vectors:
+    {
+      std::vector<const LinearAlgebra::BlockVector *> x_system
+        = { &solution, &old_solution, &old_old_solution };
+
+      // If we are using a deforming mesh, include the mesh velocity, which uses the system dof handler
+      if (parameters.mesh_deformation_enabled)
+        x_system.push_back( &mesh_deformation->mesh_velocity );
+
+      parallel::distributed::SolutionTransfer<dim, LinearAlgebra::BlockVector>
+      system_trans (dof_handler);
+
+      system_trans.prepare_for_serialization (x_system);
+
+
+      // If we are deforming the mesh, also serialize the mesh vertices vector, which
+      // uses its own dof handler
+      std::vector<const LinearAlgebra::Vector *> x_fs_system;
+      std::unique_ptr<parallel::distributed::SolutionTransfer<dim,LinearAlgebra::Vector>> mesh_deformation_trans;
+      if (parameters.mesh_deformation_enabled)
+        {
+          x_fs_system.push_back (&mesh_deformation->mesh_displacements);
+          x_fs_system.push_back (&mesh_deformation->initial_topography);
+
+          mesh_deformation_trans
+            = std::make_unique<parallel::distributed::SolutionTransfer<dim,LinearAlgebra::Vector>>
+              (mesh_deformation->mesh_deformation_dof_handler);
+
+          mesh_deformation_trans->prepare_for_serialization(x_fs_system);
+        }
+
+      signals.pre_checkpoint_store_user_data(triangulation);
+
+      triangulation.save (parameters.output_directory + "restart.mesh.new");
+    }
+
+    // save general information This calls the serialization functions on all
+    // processes (so that they can take additional action, if necessary, see
+    // the manual) but only writes to the restart file on process 0
+    {
+      std::ostringstream oss;
+
+      // serialize into a stringstream
+      aspect::oarchive oa (oss);
+      save_critical_parameters (this->parameters, oa);
+      oa << (*this);
+
+      // compress with zlib and write to file on the root processor
+#ifdef DEAL_II_WITH_ZLIB
+      if (my_id == 0)
+        {
+          uLongf compressed_data_length = compressBound (oss.str().length());
+          std::vector<char *> compressed_data (compressed_data_length);
+          int err = compress2 (reinterpret_cast<Bytef *>(&compressed_data[0]),
+                               &compressed_data_length,
+                               reinterpret_cast<const Bytef *>(oss.str().data()),
+                               oss.str().length(),
+                               Z_BEST_COMPRESSION);
+          (void)err;
+          Assert (err == Z_OK, ExcInternalError());
+
+          // build compression header
+          const uint32_t compression_header[4]
+            = { 1,                                   /* number of blocks */
+                static_cast<uint32_t>(oss.str().length()), /* size of block */
+                static_cast<uint32_t>(oss.str().length()), /* size of last block */
+                static_cast<uint32_t>(compressed_data_length)
+              }; /* list of compressed sizes of blocks */
+
+          std::ofstream f ((parameters.output_directory + "restart.resume.z.new"));
+          f.write(reinterpret_cast<const char *>(compression_header), 4 * sizeof(compression_header[0]));
+          f.write(reinterpret_cast<char *>(&compressed_data[0]), compressed_data_length);
+          f.close();
+
+          // We check the fail state of the stream _after_ closing the file to
+          // make sure the writes were completed correctly. This also catches
+          // the cases where the file could not be opened in the first place
+          // or one of the write() commands fails, as the fail state is
+          // "sticky".
+          if (!f)
+            AssertThrow(false, ExcMessage ("Writing of the checkpoint file '" + parameters.output_directory
+                                           + "restart.resume.z.new' with size "
+                                           + Utilities::to_string(4 * sizeof(compression_header[0])+compressed_data_length)
+                                           + " failed on processor 0."));
+        }
+#else
+      AssertThrow (false,
+                   ExcMessage ("You need to have deal.II configured with the `libz' "
+                               "option to support checkpoint/restart, but deal.II "
+                               "did not detect its presence when you called `cmake'."));
+#endif
+
+    }
+
+    // Wait for everyone to finish writing
+    const int ierr = MPI_Barrier(mpi_communicator);
+    AssertThrowMPI(ierr);
+
+    // Now rename the snapshots to put the new one in place of the old one.
+    // Do this after writing the new one, because writing large checkpoints
+    // can be slow, and the model might be cancelled during writing.
+    // This way restart remains usable even if restart.new is not completely
+    // written.
+    if (my_id == 0)
+      {
+        // if we have previously written a snapshot, then keep the last
+        // snapshot in case this one fails to save. Note: static variables
+        // will only be initialized once per model run.
+        static bool previous_snapshot_exists = (parameters.resume_computation == true);
+
+        if (previous_snapshot_exists == true)
+          {
+            move_file (parameters.output_directory + "restart.mesh",
+                       parameters.output_directory + "restart.mesh.old");
+            move_file (parameters.output_directory + "restart.mesh.info",
+                       parameters.output_directory + "restart.mesh.info.old");
+            move_file (parameters.output_directory + "restart.resume.z",
+                       parameters.output_directory + "restart.resume.z.old");
+
+            move_file (parameters.output_directory + "restart.mesh_fixed.data",
+                       parameters.output_directory + "restart.mesh_fixed.data.old");
+
+            if (Utilities::fexists(parameters.output_directory + "restart.mesh_variable.data"))
+              {
+                move_file (parameters.output_directory + "restart.mesh_variable.data",
+                           parameters.output_directory + "restart.mesh_variable.data.old");
+              }
+
+          }
+
+        move_file (parameters.output_directory + "restart.mesh.new",
+                   parameters.output_directory + "restart.mesh");
+        move_file (parameters.output_directory + "restart.mesh.new.info",
+                   parameters.output_directory + "restart.mesh.info");
+        move_file (parameters.output_directory + "restart.resume.z.new",
+                   parameters.output_directory + "restart.resume.z");
+
+        move_file (parameters.output_directory + "restart.mesh.new_fixed.data",
+                   parameters.output_directory + "restart.mesh_fixed.data");
+
+        if (Utilities::fexists(parameters.output_directory + "restart.mesh.new_variable.data"))
+          {
+            move_file (parameters.output_directory + "restart.mesh.new_variable.data",
+                       parameters.output_directory + "restart.mesh_variable.data");
+          }
+
+
+        // from now on, we know that if we get into this
+        // function again that a snapshot has previously
+        // been written
+        previous_snapshot_exists = true;
+      }
+
+    pcout << "*** Snapshot created!" << std::endl << std::endl;
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::resume_from_snapshot()
+  {
+    // By definition, a checkpoint is past the first time step. As a consequence,
+    // the Simulator object will not need the initial conditions objects, and
+    // we can release the pointers to these objects that we have created in
+    // the constructor of this class. If some of the other plugins created there
+    // still need access to these initial conditions, they will have created
+    // their own shared pointers.
+    initial_temperature_manager.reset();
+    initial_composition_manager.reset();
+#ifdef ASPECT_WITH_WORLD_BUILDER
+    // The same applies to the world builder object:
+    world_builder.reset();
+#endif
+
+    // Then start with the actual deserialization.
+    // First check existence of the two restart files
+    AssertThrow (Utilities::fexists(parameters.output_directory + "restart.mesh", mpi_communicator),
+                 ExcMessage ("You are trying to restart a previous computation, "
+                             "but the restart file <"
+                             +
+                             parameters.output_directory + "restart.mesh"
+                             +
+                             "> does not appear to exist!"));
+
+    AssertThrow (Utilities::fexists(parameters.output_directory + "restart.resume.z", mpi_communicator),
+                 ExcMessage ("You are trying to restart a previous computation, "
+                             "but the restart file <"
+                             +
+                             parameters.output_directory + "restart.resume.z"
+                             +
+                             "> does not appear to exist!"));
+
+    pcout << "*** Resuming from snapshot!" << std::endl << std::endl;
+
+    // Read resume.z to set up the state of the model
+    try
+      {
+#ifdef DEAL_II_WITH_ZLIB
+        const std::string restart_data
+          = Utilities::read_and_distribute_file_content (parameters.output_directory + "restart.resume.z",
+                                                         mpi_communicator);
+
+        std::istringstream ifs (restart_data);
+
+        uint32_t compression_header[4];
+        ifs.read(reinterpret_cast<char *>(compression_header), 4 * sizeof(compression_header[0]));
+        Assert(compression_header[0]==1, ExcInternalError());
+
+        std::vector<char> compressed(compression_header[3]);
+        std::vector<char> uncompressed(compression_header[1]);
+        ifs.read(&compressed[0],compression_header[3]);
+        uLongf uncompressed_size = compression_header[1];
+
+        const int err = uncompress(reinterpret_cast<Bytef *>(&uncompressed[0]), &uncompressed_size,
+                                   reinterpret_cast<Bytef *>(&compressed[0]), compression_header[3]);
+        AssertThrow (err == Z_OK,
+                     ExcMessage (std::string("Uncompressing the data buffer resulted in an error with code <")
+                                 +
+                                 Utilities::int_to_string(err)));
+
+        {
+          std::istringstream ss;
+          ss.str(std::string (&uncompressed[0], uncompressed_size));
+
+          aspect::iarchive ia (ss);
+          load_and_check_critical_parameters(this->parameters, ia);
+          ia >> (*this);
+        }
+#else
+        AssertThrow (false,
+                     ExcMessage ("You need to have deal.II configured with the `libz' "
+                                 "option to support checkpoint/restart, but deal.II "
+                                 "did not detect its presence when you called `cmake'."));
+#endif
+      }
+    catch (std::exception &e)
+      {
+        AssertThrow (false,
+                     ExcMessage (std::string("Cannot seem to deserialize the data previously stored!\n")
+                                 +
+                                 "Some part of the machinery generated an exception that says:\n"
+                                 +
+                                 e.what()));
+      }
+
+    // now that we have resumed from the snapshot load the mesh and solution vectors
+    try
+      {
+        triangulation.load (parameters.output_directory + "restart.mesh");
+      }
+    catch (...)
+      {
+        AssertThrow(false, ExcMessage("Cannot open snapshot mesh file or read the triangulation stored there."));
+      }
+
+    // if using a cached mapping, update the cache with the new triangulation
+    if (MappingQCache<dim> *map = dynamic_cast<MappingQCache<dim>*>(&(*mapping)))
+      map->initialize(MappingQGeneric<dim>(4), triangulation);
+
+    setup_dofs();
+    global_volume = GridTools::volume (triangulation, *mapping);
+
+    LinearAlgebra::BlockVector distributed_system (system_rhs);
+    LinearAlgebra::BlockVector old_distributed_system (system_rhs);
+    LinearAlgebra::BlockVector old_old_distributed_system (system_rhs);
+    LinearAlgebra::BlockVector distributed_mesh_velocity (system_rhs);
+
+    std::vector<LinearAlgebra::BlockVector *> x_system
+      = { &distributed_system, &old_distributed_system, &old_old_distributed_system };
+
+    // If necessary, also include the mesh velocity for deserialization
+    // with the system dof handler
+    if (parameters.mesh_deformation_enabled)
+      x_system.push_back(&distributed_mesh_velocity);
+
+    parallel::distributed::SolutionTransfer<dim, LinearAlgebra::BlockVector>
+    system_trans (dof_handler);
+
+    system_trans.deserialize (x_system);
+
+    solution = distributed_system;
+    old_solution = old_distributed_system;
+    old_old_solution = old_old_distributed_system;
+
+    if (parameters.mesh_deformation_enabled)
+      {
+        // copy the mesh velocity which uses the system dof handler
+        mesh_deformation->mesh_velocity = distributed_mesh_velocity;
+
+        // deserialize and copy the vectors using the mesh deformation dof handler
+        parallel::distributed::SolutionTransfer<dim, LinearAlgebra::Vector> mesh_deformation_trans( mesh_deformation->mesh_deformation_dof_handler );
+        LinearAlgebra::Vector distributed_mesh_displacements( mesh_deformation->mesh_locally_owned,
+                                                              mpi_communicator );
+        LinearAlgebra::Vector distributed_initial_topography( mesh_deformation->mesh_locally_owned,
+                                                              mpi_communicator );
+        std::vector<LinearAlgebra::Vector *> fs_system
+        = { &distributed_mesh_displacements,
+            &distributed_initial_topography
+          };
+
+        mesh_deformation_trans.deserialize (fs_system);
+        mesh_deformation->mesh_displacements = distributed_mesh_displacements;
+        mesh_deformation->initial_topography = distributed_initial_topography;
+      }
+
+    signals.post_resume_load_user_data(triangulation);
+
+    // Overwrite the existing statistics file with the one that would have
+    // been current at the time of the snapshot we just read back in. We
+    // do this because the simulation that created the snapshot may have
+    // continued for a few more time steps. The operation here then
+    // effectively truncates the 'statistics' file to the position from
+    // which the current simulation is going to continue.
+    output_statistics();
+
+    // We have to compute the constraints here because the vector that tells
+    // us if a cell is a melt cell is not saved between restarts.
+    if (parameters.include_melt_transport)
+      {
+        initialize_current_linearization_point();
+        compute_current_constraints ();
+      }
+  }
+
+}
+
+//why do we need this?!
+BOOST_CLASS_TRACKING (aspect::Simulator<2>, boost::serialization::track_never)
+BOOST_CLASS_TRACKING (aspect::Simulator<3>, boost::serialization::track_never)
+
+
+namespace aspect
+{
+
+  template <int dim>
+  template <class Archive>
+  void Simulator<dim>::serialize (Archive &ar, const unsigned int)
+  {
+    ar &time;
+    ar &time_step;
+    ar &old_time_step;
+    ar &timestep_number;
+    ar &pre_refinement_step;
+    ar &last_pressure_normalization_adjustment;
+    ar &total_walltime_until_last_snapshot;
+
+    ar &postprocess_manager;
+
+    ar &statistics;
+
+    // We do not serialize the statistics_last_write_size and
+    // statistics_last_hash variables on purpose. This way, upon
+    // restart, they are left at the values initialized by the
+    // Simulator::Simulator() constructor, and this causes the
+    // Simulator::output_statistics() function to write the
+    // whole statistics file anew at the end of the first time
+    // step after restart. See there why this is the
+    // correct behavior after restart.
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template void Simulator<dim>::create_snapshot(); \
+  template void Simulator<dim>::resume_from_snapshot();
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/core.cc b/source/simulator/core.cc
index 76cac919a8f..9b1f7b535fb 100644
--- a/source/simulator/core.cc
+++ b/source/simulator/core.cc
@@ -2051,7 +2051,7 @@ namespace aspect
         timestep_number           = 0;
         time_step = old_time_step = 0;
 
-        if (! parameters.skip_setup_initial_conditions_on_initial_refinement
+        if (! parameters.skip_setup_initial_temperature_on_initial_refinement
             ||
             ! (pre_refinement_step < parameters.initial_adaptive_refinement))
           {
diff --git a/source/simulator/core.cc.bak b/source/simulator/core.cc.bak
new file mode 100644
index 00000000000..76cac919a8f
--- /dev/null
+++ b/source/simulator/core.cc.bak
@@ -0,0 +1,2199 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/melt.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/newton.h>
+#include <aspect/stokes_matrix_free.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/citation_info.h>
+#include <aspect/postprocess/particles.h>
+
+#ifdef ASPECT_WITH_WORLD_BUILDER
+#include <world_builder/world.h>
+#endif
+
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+#include <aspect/material_model/rheology/elasticity.h>
+
+#include <deal.II/base/index_set.h>
+#include <deal.II/base/conditional_ostream.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/lac/block_sparsity_pattern.h>
+#include <deal.II/lac/sparsity_tools.h>
+#include <deal.II/grid/grid_tools.h>
+
+#include <deal.II/dofs/dof_renumbering.h>
+#include <deal.II/dofs/dof_accessor.h>
+#include <deal.II/dofs/dof_tools.h>
+
+#include <deal.II/fe/mapping_q.h>
+#include <deal.II/fe/mapping_cartesian.h>
+#include <deal.II/fe/mapping_q_cache.h>
+
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/derivative_approximation.h>
+#include <deal.II/numerics/vector_tools.h>
+
+#include <deal.II/distributed/solution_transfer.h>
+#include <deal.II/distributed/grid_refinement.h>
+
+#include <fstream>
+#include <iostream>
+#include <locale>
+#include <string>
+
+
+
+
+namespace aspect
+{
+  namespace
+  {
+    /**
+     * Helper function to construct the final std::vector of FEVariable before
+     * it is used to construct the Introspection object. Create the default
+     * setup based on parameters followed by a signal to allow modifications.
+     */
+    template <int dim>
+    std::vector<VariableDeclaration<dim>> construct_variables(const Parameters<dim> &parameters,
+                                                               SimulatorSignals<dim> &signals,
+                                                               std::unique_ptr<MeltHandler<dim>> &melt_handler)
+    {
+      std::vector<VariableDeclaration<dim>> variables
+        = construct_default_variables (parameters);
+      if (melt_handler)
+        melt_handler->edit_finite_element_variables (parameters, variables);
+
+      signals.edit_finite_element_variables(variables);
+      return variables;
+    }
+
+    /**
+     * Helper function to construct mapping for the model.
+     * The mapping is given by a degree four MappingQ for the case
+     * of a curved mesh, and a cartesian mapping for a rectangular mesh that is
+     * not deformed. Use a MappingQ1 if the initial mesh is deformed.
+     * If mesh deformation is enabled, each mapping is later swapped out for a
+     * MappingQ1Eulerian, which allows for mesh deformation during the
+     * computation.
+     */
+    template <int dim>
+    std::unique_ptr<Mapping<dim>>
+    construct_mapping(const GeometryModel::Interface<dim> &geometry_model,
+                      const InitialTopographyModel::Interface<dim> &initial_topography_model)
+    {
+      if (geometry_model.has_curved_elements())
+        return std::make_unique<MappingQCache<dim>>(4);
+
+      if (Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(initial_topography_model))
+        return std::make_unique<MappingCartesian<dim>>();
+
+      return std::make_unique<MappingQ1<dim>>();
+    }
+  }
+
+
+  /**
+   * Constructor of the IntermediaryConstructorAction class. Since the
+   * class has no members, there is nothing to initialize -- all we
+   * need to do is execute the 'action' argument.
+   */
+  template <int dim>
+  Simulator<dim>::IntermediaryConstructorAction::
+  IntermediaryConstructorAction (const std::function<void ()> &action)
+  {
+    action();
+  }
+
+
+
+  /**
+   * Constructor. Initialize all member variables.
+   **/
+  template <int dim>
+  Simulator<dim>::Simulator (const MPI_Comm mpi_communicator_,
+                             ParameterHandler &prm)
+    :
+    simulator_is_past_initialization (false),
+    assemblers (std::make_unique<Assemblers::Manager<dim>>()),
+    parameters (prm, mpi_communicator_),
+    melt_handler (parameters.include_melt_transport ?
+                  std::make_unique<MeltHandler<dim>>(prm) :
+                  nullptr),
+    newton_handler (Parameters<dim>::is_defect_correction(parameters.nonlinear_solver) ?
+                    std::make_unique<NewtonHandler<dim>>() :
+                    nullptr),
+    post_signal_creation(
+      std::bind (&internals::SimulatorSignals::call_connector_functions<dim>,
+                 std::ref(signals))),
+    volume_of_fluid_handler (parameters.volume_of_fluid_tracking_enabled ?
+                             std::make_unique<VolumeOfFluidHandler<dim>> (*this, prm) :
+                             nullptr),
+    introspection (construct_variables<dim>(parameters, signals, melt_handler), parameters),
+    mpi_communicator (Utilities::MPI::duplicate_communicator (mpi_communicator_)),
+    iostream_tee_device(std::cout, log_file_stream),
+    iostream_tee_stream(iostream_tee_device),
+    pcout (iostream_tee_stream,
+           (Utilities::MPI::
+            this_mpi_process(mpi_communicator)
+            == 0)),
+
+    statistics_last_write_size (0),
+    statistics_last_hash (0),
+
+    computing_timer (mpi_communicator,
+                     pcout,
+                     TimerOutput::never,
+                     TimerOutput::wall_times),
+    total_walltime_until_last_snapshot(0.),
+    initial_topography_model(InitialTopographyModel::create_initial_topography_model<dim>(prm)),
+    geometry_model (GeometryModel::create_geometry_model<dim>(prm)),
+    // make sure the parameters object gets a chance to
+    // parse those parameters that depend on symbolic names
+    // for boundary components
+    post_geometry_model_creation_action (std::bind (&Parameters<dim>::parse_geometry_dependent_parameters,
+                                                    std::ref(parameters),
+                                                    std::ref(prm),
+                                                    std::cref(*geometry_model))),
+    material_model (MaterialModel::create_material_model<dim>(prm)),
+    gravity_model (GravityModel::create_gravity_model<dim>(prm)),
+    prescribed_stokes_solution (PrescribedStokesSolution::create_prescribed_stokes_solution<dim>(prm)),
+    adiabatic_conditions (AdiabaticConditions::create_adiabatic_conditions<dim>(prm)),
+#ifdef ASPECT_WITH_WORLD_BUILDER
+    world_builder (parameters.world_builder_file != "" ?
+                   std::make_shared<WorldBuilder::World>(parameters.world_builder_file) :
+                   nullptr),
+#endif
+    boundary_heat_flux (BoundaryHeatFlux::create_boundary_heat_flux<dim>(prm)),
+    particle_worlds(),
+    time (numbers::signaling_nan<double>()),
+    time_step (numbers::signaling_nan<double>()),
+    old_time_step (numbers::signaling_nan<double>()),
+    timestep_number (numbers::invalid_unsigned_int),
+    nonlinear_iteration (numbers::invalid_unsigned_int),
+
+    // We need to disable eliminate_refined_boundary_islands as this leads to
+    // a deadlock for deal.II <= 9.2.0 as described in
+    // https://github.com/geodynamics/aspect/issues/3604 when an
+    // refined_island is at a periodic boundary. This flag is not too
+    // important as it does not improve accuracy. Otherwise, these flags
+    // correspond to smoothing_on_refinement|smoothing_on_coarsening.
+    triangulation (mpi_communicator,
+                   static_cast<typename Triangulation<dim>::MeshSmoothing>
+                   (
+                     Triangulation<dim>::limit_level_difference_at_vertices |
+                     (Triangulation<dim>::eliminate_unrefined_islands |
+                      Triangulation<dim>::eliminate_refined_inner_islands |
+                      // Triangulation<dim>::eliminate_refined_boundary_islands |
+                      Triangulation<dim>::do_not_produce_unrefined_islands)
+                   )
+                   ,
+                   (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg ||
+                    parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::default_solver
+                    ?
+                    static_cast<typename parallel::distributed::Triangulation<dim>::Settings>
+                    (parallel::distributed::Triangulation<dim>::mesh_reconstruction_after_repartitioning |
+                     parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy)
+                    :
+                    parallel::distributed::Triangulation<dim>::mesh_reconstruction_after_repartitioning)),
+
+    mapping(construct_mapping<dim>(*geometry_model,*initial_topography_model)),
+
+    // define the finite element
+    finite_element(introspection.get_fes(), introspection.get_multiplicities()),
+
+    dof_handler (triangulation),
+
+    last_pressure_normalization_adjustment (numbers::signaling_nan<double>()),
+    pressure_scaling (numbers::signaling_nan<double>()),
+
+    rebuild_stokes_matrix (true),
+    assemble_newton_stokes_matrix (true),
+    assemble_newton_stokes_system (Parameters<dim>::is_defect_correction(parameters.nonlinear_solver)
+                                   ?
+                                   true
+                                   :
+                                   false),
+    rebuild_stokes_preconditioner (true)
+  {
+    wall_timer.start();
+
+    if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+      {
+        // only open the log file on processor 0, the other processors won't be
+        // writing into the stream anyway
+        log_file_stream.open(parameters.output_directory + "log.txt",
+                             parameters.resume_computation ? std::ios_base::app : std::ios_base::out);
+
+        // we already printed the header to the screen, so here we just dump it
+        // into the log file.
+        print_aspect_header(log_file_stream);
+      }
+
+    // now that we have output set up, we can start timer sections
+    TimerOutput::Scope timer (computing_timer, "Initialization");
+
+
+    // if any plugin wants access to the Simulator by deriving from SimulatorAccess, initialize it and
+    // call the initialize() functions immediately after.
+    //
+    // up front, we can not know whether a plugin derives from
+    // SimulatorAccess. all we have is a pointer to the base class of
+    // each plugin type (the 'Interface' class in the namespace
+    // corresponding to each plugin type), but this base class is not
+    // derived from SimulatorAccess. in order to find out whether a
+    // concrete plugin derives from this base (interface) class AND
+    // the SimulatorAccess class via multiple inheritance, we need to
+    // do a sideways dynamic_cast to this putative sibling of the
+    // interface class, and investigate if the dynamic_cast
+    // succeeds. if it succeeds, the dynamic_cast returns a non-nullptr
+    // result, and we can test this in an if-statement. there is a nice
+    // idiom whereby we can write
+    //    if (SiblingClass *ptr = dynamic_cast<SiblingClass*>(ptr_to_base))
+    //      ptr->do_something()
+    // where we declare a variable *inside* the 'if' condition, and only
+    // enter the code block guarded by the 'if' in case the so-declared
+    // variable evaluates to something non-zero, which here means that
+    // the dynamic_cast succeeded and returned the address of the sibling
+    // object.
+    //
+    // we also need to let all models parse their parameters. this is done *after* setting
+    // up their SimulatorAccess base class so that they can query, for example, the
+    // geometry model's description of symbolic names for boundary parts. note that
+    // the geometry model is the only model whose run time parameters are already read
+    // at the time it is created
+    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(initial_topography_model.get()))
+      sim->initialize_simulator (*this);
+    initial_topography_model->initialize ();
+
+    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(geometry_model.get()))
+      sim->initialize_simulator (*this);
+    geometry_model->initialize ();
+
+    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(material_model.get()))
+      sim->initialize_simulator (*this);
+    material_model->parse_parameters (prm);
+    material_model->initialize ();
+
+    // Make sure that the material model supports elasticity when it is requested,
+    // by checking that the material model creates the necessary material model
+    // outputs.
+    if (parameters.enable_elasticity)
+      {
+        // Set up outputs for one point
+        MaterialModel::MaterialModelOutputs<dim> out(1,
+                                                     introspection.n_compositional_fields);
+
+        material_model->create_additional_named_outputs(out);
+
+        MaterialModel::ElasticAdditionalOutputs<dim> *elastic_outputs = out.template get_additional_output<MaterialModel::ElasticAdditionalOutputs<dim>>();
+
+        // Throw if the elastic_outputs do not exist
+        AssertThrow(elastic_outputs != nullptr,
+                    ExcMessage("Elasticity is enabled, but not supported by the material model."));
+      }
+
+    heating_model_manager.initialize_simulator(*this);
+    heating_model_manager.parse_parameters (prm);
+
+    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(gravity_model.get()))
+      sim->initialize_simulator (*this);
+    gravity_model->parse_parameters (prm);
+    gravity_model->initialize ();
+
+    // Create the initial temperature and condition plugins, and then
+    // initialize them. Some of these objects store std::shared_ptrs
+    // to the initial temperature and composition objects, so it is
+    // important that we have the pointers of the current class
+    // already set by the time we call the initialize() functions.
+    initial_temperature_manager
+      = std::make_shared<InitialTemperature::Manager<dim>>();
+    initial_composition_manager
+      = std::make_shared<InitialComposition::Manager<dim>>();
+
+    initial_temperature_manager->initialize_simulator(*this);
+    initial_temperature_manager->parse_parameters (prm);
+
+    initial_composition_manager->initialize_simulator(*this);
+    initial_composition_manager->parse_parameters (prm);
+
+    // Create a boundary temperature manager
+    boundary_temperature_manager.initialize_simulator (*this);
+    boundary_temperature_manager.parse_parameters (prm);
+
+    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(boundary_heat_flux.get()))
+      sim->initialize_simulator (*this);
+    boundary_heat_flux->parse_parameters (prm);
+    boundary_heat_flux->initialize ();
+
+    // Create a boundary composition manager
+    boundary_composition_manager.initialize_simulator (*this);
+    boundary_composition_manager.parse_parameters (prm);
+
+    boundary_velocity_manager.initialize_simulator (*this);
+    boundary_velocity_manager.parse_parameters (prm);
+
+    // Make sure we only have a prescribed Stokes plugin if needed
+    if (parameters.nonlinear_solver == NonlinearSolver::single_Advection_no_Stokes)
+      {
+        AssertThrow(prescribed_stokes_solution.get()!=nullptr,
+                    ExcMessage("For the 'single Advection, no Stokes' solver scheme you need to provide a Stokes plugin!")
+                   );
+      }
+    else
+      {
+        AssertThrow(prescribed_stokes_solution.get()==nullptr,
+                    ExcMessage("The prescribed stokes plugin you selected only works with the solver "
+                               "scheme 'single Advection, no Stokes'.")
+                   );
+      }
+
+    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(prescribed_stokes_solution.get()))
+      sim->initialize_simulator (*this);
+    if (prescribed_stokes_solution.get())
+      {
+        prescribed_stokes_solution->parse_parameters (prm);
+        prescribed_stokes_solution->initialize ();
+      }
+
+
+    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(adiabatic_conditions.get()))
+      sim->initialize_simulator (*this);
+    adiabatic_conditions->parse_parameters (prm);
+    adiabatic_conditions->initialize ();
+
+    // Create a boundary traction manager
+    boundary_traction_manager.initialize_simulator (*this);
+    boundary_traction_manager.parse_parameters (prm);
+
+    // Initialize the mesh deformation handler
+    if (parameters.mesh_deformation_enabled)
+      {
+        // Models with deformed boundaries require
+        // the full A block to converge consistently
+        parameters.use_full_A_block_preconditioner = true;
+
+        // Allocate the MeshDeformationHandler object
+        mesh_deformation = std::make_unique<MeshDeformation::MeshDeformationHandler<dim>>(*this);
+        mesh_deformation->initialize_simulator(*this);
+        mesh_deformation->parse_parameters(prm);
+        mesh_deformation->initialize();
+      }
+
+    // Initialize the melt handler
+    if (parameters.include_melt_transport)
+      {
+        // Models with melt transport require
+        // the full A block to converge consistently
+        parameters.use_full_A_block_preconditioner = true;
+
+        melt_handler->initialize_simulator (*this);
+        melt_handler->initialize();
+      }
+
+    // If the solver type is a Newton or defect correction type of solver, we need to set make sure
+    // assemble_newton_stokes_system set to true.
+    if (Parameters<dim>::is_defect_correction(parameters.nonlinear_solver))
+      {
+        assemble_newton_stokes_system = true;
+        newton_handler->initialize_simulator(*this);
+        newton_handler->parameters.parse_parameters(prm);
+      }
+
+    // choose the default solver and averaging scheme
+    select_default_solver_and_averaging();
+
+    if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
+      {
+        switch (parameters.stokes_velocity_degree)
+          {
+            case 2:
+              stokes_matrix_free = std::make_unique<StokesMatrixFreeHandlerImplementation<dim,2>>(*this, prm);
+              break;
+            case 3:
+              stokes_matrix_free = std::make_unique<StokesMatrixFreeHandlerImplementation<dim,3>>(*this, prm);
+              break;
+            default:
+              AssertThrow(false, ExcMessage("The finite element degree for the Stokes system you selected is not supported yet."));
+          }
+
+      }
+
+    postprocess_manager.initialize_simulator (*this);
+    postprocess_manager.parse_parameters (prm);
+
+    if (postprocess_manager.template has_matching_postprocessor<Postprocess::Particles<dim>>())
+      {
+        particle_worlds.emplace_back(std::move(std::make_unique<Particle::World<dim>>()));
+        for (unsigned int particle_world_index = 0 ; particle_world_index < particle_worlds.size(); ++particle_world_index)
+          {
+            if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(particle_worlds[particle_world_index].get()))
+              sim->initialize_simulator (*this);
+
+            particle_worlds.back()->parse_parameters(prm,particle_world_index);
+            particle_worlds.back()->initialize();
+
+          }
+      }
+
+    mesh_refinement_manager.initialize_simulator (*this);
+    mesh_refinement_manager.parse_parameters (prm);
+
+    // VoF Must be initialized after mesh_refinement_manager, due to needing to check
+    // for a mesh refinement strategy
+    if (parameters.volume_of_fluid_tracking_enabled)
+      {
+        volume_of_fluid_handler->initialize (prm);
+      }
+
+    time_stepping_manager.initialize_simulator (*this);
+    time_stepping_manager.parse_parameters (prm);
+
+    lateral_averaging.initialize_simulator (*this);
+
+    geometry_model->create_coarse_mesh (triangulation);
+    Assert (triangulation.all_reference_cells_are_hyper_cube(),
+            ExcMessage ("ASPECT only supports meshes that are composed of quadrilateral "
+                        "or hexahedral cells."));
+    global_Omega_diameter = GridTools::diameter (triangulation);
+
+    // After creating the coarse mesh, initialize mapping cache if one is used
+    if (MappingQCache<dim> *map = dynamic_cast<MappingQCache<dim>*>(&(*mapping)))
+      map->initialize(MappingQGeneric<dim>(4), triangulation);
+
+    bool bp_limiter_enabled = (parameters.limiter_for_discontinuous_temperature_solution
+                               == Parameters<dim>::DGLimiterType::bound_preserving);
+    for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+      bp_limiter_enabled = bp_limiter_enabled || (parameters.limiter_for_discontinuous_composition_solution[c]
+                                                  == Parameters<dim>::DGLimiterType::bound_preserving);
+
+    // Check that BP limiters are only used with cartesian mapping
+    if (bp_limiter_enabled)
+      AssertThrow(geometry_model->natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian,
+                  ExcMessage("The bound preserving limiter for the discontinuous temperature and composition solutions "
+                             "has not been tested in non-Cartesian geometries and currently requires "
+                             "the use of a Cartesian geometry model."));
+
+    std::set<types::boundary_id> open_velocity_boundary_indicators
+      = geometry_model->get_used_boundary_indicators();
+    for (const auto &p : boundary_velocity_manager.get_active_boundary_velocity_names())
+      open_velocity_boundary_indicators.erase (p.first);
+    for (const auto p : boundary_velocity_manager.get_zero_boundary_velocity_indicators())
+      open_velocity_boundary_indicators.erase (p);
+    for (const auto p : boundary_velocity_manager.get_tangential_boundary_velocity_indicators())
+      open_velocity_boundary_indicators.erase (p);
+
+    // Make sure that we do the pressure right-hand side modification correctly for periodic boundaries
+    using periodic_boundary_set
+      = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
+    periodic_boundary_set pbs = geometry_model->get_periodic_boundary_pairs();
+    for (const auto &pb : pbs)
+      {
+        open_velocity_boundary_indicators.erase (pb.first.first);
+        open_velocity_boundary_indicators.erase (pb.first.second);
+      }
+
+    // We need to do the RHS compatibility modification, if the model is
+    // compressible or compatible (in the case of melt transport), and
+    // there is no open boundary to balance the pressure.
+    do_pressure_rhs_compatibility_modification = ((material_model->is_compressible() && !parameters.include_melt_transport)
+                                                  ||
+                                                  (parameters.include_melt_transport && !material_model->is_compressible())
+                                                  || parameters.enable_prescribed_dilation)
+                                                 &&
+                                                 (open_velocity_boundary_indicators.size() == 0);
+
+    // make sure that we don't have to fill every column of the statistics
+    // object in each time step.
+    statistics.set_auto_fill_mode(true);
+
+    // finally produce a record of the run-time parameters by writing
+    // the currently used values into a file
+    // Only write the parameter files on the root node to avoid file system conflicts
+    if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+      {
+        std::ofstream prm_out ((parameters.output_directory + "parameters.prm"));
+        AssertThrow (prm_out,
+                     ExcMessage (std::string("Could not open file <") +
+                                 parameters.output_directory + "parameters.prm>."));
+        prm.print_parameters(prm_out, ParameterHandler::Text);
+
+        std::ofstream json_out ((parameters.output_directory + "parameters.json"));
+        AssertThrow (json_out,
+                     ExcMessage (std::string("Could not open file <") +
+                                 parameters.output_directory + "parameters.json>."));
+        prm.print_parameters(json_out, ParameterHandler::JSON);
+      }
+
+    // check that the boundary condition selection is consistent
+    check_consistency_of_boundary_conditions();
+
+    // check that the setup of equations, material models, and heating terms is consistent
+    check_consistency_of_formulation();
+
+    if (parameters.use_discontinuous_temperature_discretization || parameters.have_discontinuous_composition_discretization)
+      CitationInfo::add("dg");
+
+    // now that all member variables have been set up, also
+    // connect the functions that will actually do the assembly
+    set_assemblers();
+  }
+
+
+  /**
+   * Destructor.
+   */
+  template <int dim>
+  Simulator<dim>::~Simulator ()
+  {
+    // The particle_world object is declared before the triangulation, and so
+    // is destroyed after the latter. But it stores a pointer to the
+    // triangulation and uses it during destruction. This results in
+    // trouble. So destroy it first.
+
+    for (auto &particle_world : particle_worlds)
+      particle_world.reset();
+
+    // wait if there is a thread that's still writing the statistics
+    // object (set from the output_statistics() function)
+    if (output_statistics_thread.joinable())
+      output_statistics_thread.join();
+
+    // If an exception is being thrown (for example due to AssertThrow()), we
+    // might end up here with currently active timing sections. The destructor
+    // of TimerOutput does MPI communication, which can lead to deadlocks,
+    // hangs, or confusing MPI error messages. To avoid this, we can call
+    // reset() to remove all open sections. In a normal run, we won't have any
+    // active sessions, so this won't hurt to do:
+    computing_timer.reset();
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  start_timestep ()
+  {
+    // first produce some output for the screen to show where we are
+    {
+      const char *unit = (parameters.convert_to_years ? "years" : "seconds");
+      const double multiplier = (parameters.convert_to_years ? 1./year_in_seconds : 1.0);
+
+      pcout << "*** Timestep " << timestep_number
+            << ":  t=" << (time * multiplier) << ' ' << unit
+            << ", dt=" << (time_step * multiplier) << ' ' << unit
+            << std::endl;
+    }
+
+    nonlinear_iteration = 0;
+
+    signals.start_timestep(*this);
+
+    // Copy particle handler to restore particle location and properties
+    // before repeating a timestep
+    for (auto &particle_world : particle_worlds)
+      particle_world->backup_particles();
+
+
+    // then interpolate the current boundary velocities. copy constraints
+    // into current_constraints and then add to current_constraints
+    compute_current_constraints ();
+
+    // If needed, construct sparsity patterns and matrices with the current
+    // constraints. Of course we need to force assembly too.
+    if (rebuild_sparsity_and_matrices)
+      {
+        TimerOutput::Scope timer (computing_timer, "Setup matrices");
+
+        rebuild_sparsity_and_matrices = false;
+        setup_system_matrix (introspection.index_sets.system_partitioning);
+        setup_system_preconditioner (introspection.index_sets.system_partitioning);
+        rebuild_stokes_matrix = rebuild_stokes_preconditioner = true;
+      }
+
+    // notify different system components that we started the next time step
+    // TODO: implement this for all plugins that might need it at one place.
+    // Temperature BC are currently updated in compute_current_constraints
+    geometry_model->update();
+    material_model->update();
+    gravity_model->update();
+    heating_model_manager.update();
+    adiabatic_conditions->update();
+    mesh_refinement_manager.update();
+    if (parameters.mesh_deformation_enabled)
+      mesh_deformation->update();
+
+    if (prescribed_stokes_solution.get())
+      prescribed_stokes_solution->update();
+
+    for (auto &particle_world : particle_worlds)
+      particle_world->update();
+
+    // do the same for the traction boundary conditions and other things
+    // that end up in the bilinear form. we update those that end up in
+    // the constraints object when calling compute_current_constraints()
+    // above
+    boundary_traction_manager.update();
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  compute_current_constraints ()
+  {
+    // We put the constraints we compute into a separate AffineConstraints<double> so we can check
+    // if the set of constraints has changed. If it did, we need to update the sparsity patterns.
+    AffineConstraints<double> new_current_constraints(
+#if DEAL_II_VERSION_GTE(9,6,0)
+      dof_handler.locally_owned_dofs(),
+#endif
+      introspection.index_sets.system_relevant_set
+    );
+    new_current_constraints.merge (constraints);
+    compute_current_velocity_boundary_constraints(new_current_constraints);
+
+    // If there is a fixed boundary temperature or heat flux,
+    // update the temperature boundary condition.
+    boundary_temperature_manager.update();
+    boundary_heat_flux->update();
+
+    // If we do not want to prescribe Dirichlet boundary conditions on outflow boundaries,
+    // we update the boundary indicators of all faces that belong to outflow boundaries
+    // so that they are not in the list of fixed temperature boundary indicators any more.
+    // We will undo this change in a later step, after the constraints have been set.
+    // As long as we allow deal.II 8.5, we can not have boundary ids of more than 256,
+    // so we want to offset them by 128 and not allow more than 128 boundary ids.
+    const unsigned int boundary_id_offset = 128;
+    if (!boundary_temperature_manager.allows_fixed_temperature_on_outflow_boundaries())
+      replace_outflow_boundary_ids(boundary_id_offset);
+
+    // if using continuous temperature FE, do the same for the temperature variable:
+    // evaluate the current boundary temperature and add these constraints as well
+    if (!parameters.use_discontinuous_temperature_discretization)
+      {
+        // obtain the boundary indicators that belong to Dirichlet-type
+        // temperature boundary conditions and interpolate the temperature
+        // there
+        for (const auto p : boundary_temperature_manager.get_fixed_temperature_boundary_indicators())
+          {
+            VectorFunctionFromScalarFunctionObject<dim> vector_function_object(
+              [&] (const dealii::Point<dim> &x) -> double
+            {
+              return boundary_temperature_manager.boundary_temperature(p, x);
+            },
+            introspection.component_masks.temperature.first_selected_component(),
+            introspection.n_components);
+
+            VectorTools::interpolate_boundary_values (*mapping,
+                                                      dof_handler,
+                                                      p,
+                                                      vector_function_object,
+                                                      new_current_constraints,
+                                                      introspection.component_masks.temperature);
+          }
+      }
+
+    if (!boundary_temperature_manager.allows_fixed_temperature_on_outflow_boundaries())
+      restore_outflow_boundary_ids(boundary_id_offset);
+
+    // If there are fixed boundary compositions,
+    // update the composition boundary condition.
+    boundary_composition_manager.update();
+
+    // If we do not want to prescribe Dirichlet boundary conditions on outflow boundaries,
+    // use the same trick for marking up outflow boundary conditions for compositional fields
+    // as we did above already for the temperature.
+    if (!boundary_composition_manager.allows_fixed_composition_on_outflow_boundaries())
+      replace_outflow_boundary_ids(boundary_id_offset);
+
+    // now do the same for the composition variables:
+    {
+      // obtain the boundary indicators that belong to Dirichlet-type
+      // composition boundary conditions and interpolate the composition
+      // there
+      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+        if (parameters.use_discontinuous_composition_discretization[c] == false)
+          for (const auto p : boundary_composition_manager.get_fixed_composition_boundary_indicators())
+            {
+              VectorFunctionFromScalarFunctionObject<dim> vector_function_object(
+                [&] (const Point<dim> &x) -> double
+              {
+                return boundary_composition_manager.boundary_composition(p, x, c);
+              },
+              introspection.component_masks.compositional_fields[c].first_selected_component(),
+              introspection.n_components);
+
+              VectorTools::interpolate_boundary_values (*mapping,
+                                                        dof_handler,
+                                                        p,
+                                                        vector_function_object,
+                                                        new_current_constraints,
+                                                        introspection.component_masks.compositional_fields[c]);
+            }
+    }
+
+    if (!boundary_composition_manager.allows_fixed_composition_on_outflow_boundaries())
+      restore_outflow_boundary_ids(boundary_id_offset);
+
+    if (parameters.include_melt_transport)
+      melt_handler->add_current_constraints (new_current_constraints);
+
+    // let plugins add more constraints if they so choose, then close the
+    // constraints object
+    signals.post_constraints_creation(*this, new_current_constraints);
+
+    new_current_constraints.close();
+
+    // Now check if the current_constraints we just computed changed from before. Do this before the melt handler
+    // adds constraints for the melt cells, because they are allowed to change (and often do) without us having
+    // to reinit the sparsity pattern.
+    // If the mesh got refined and the size of the linear system changed, the old and new constraint
+    // matrices will have different entries, and we can not easily compare them.
+    // Note that we can have a situation where mesh_has_changed==true on only some of the machines,
+    // so we need to do the MPI::sum below in all cases to avoid a deadlock.
+    const bool mesh_has_changed = (current_constraints.get_local_lines().size()
+                                   != new_current_constraints.get_local_lines().size())
+                                  ||
+                                  (current_constraints.get_local_lines()
+                                   != new_current_constraints.get_local_lines());
+    // Figure out if any entry that was constrained before is now no longer constrained:
+    bool constraints_changed = false;
+
+    if (mesh_has_changed)
+      {
+        // The mesh changed, so we know we need to update the constraints:
+        constraints_changed = true;
+      }
+    else
+      {
+        // the mesh has not changed on our machine, so compare the constraints:
+        for (auto &row: current_constraints.get_lines())
+          {
+            if (!new_current_constraints.is_constrained(row.index))
+              {
+                constraints_changed = true;
+                break;
+              }
+          }
+      }
+
+    // If at least one processor has different constraints, force rebuilding the matrices:
+    const bool any_constrained_dofs_set_changed = (Utilities::MPI::sum(constraints_changed ? 1 : 0,
+                                                                       mpi_communicator)
+                                                   > 0);
+    if (any_constrained_dofs_set_changed)
+      rebuild_sparsity_and_matrices = true;
+
+#if DEAL_II_VERSION_GTE(9,6,0)
+    current_constraints = std::move(new_current_constraints);
+#else
+    current_constraints.reinit (introspection.index_sets.system_relevant_set);
+    current_constraints.copy_from(new_current_constraints);
+#endif
+    current_constraints.close();
+
+    // TODO: We should use current_constraints.is_consistent_in_parallel()
+    // here to assert that our constraints are consistent between
+    // processors. This got removed in
+    // https://github.com/geodynamics/aspect/pull/3282 because it triggered in
+    // normal computations due to small floating point differences. See
+    // https://github.com/geodynamics/aspect/issues/3248 for the discussion.
+  }
+
+
+
+  namespace
+  {
+    template <int dim>
+    bool solver_scheme_solves_advection_equations(const Parameters<dim> &parameters)
+    {
+      // Check if we use a solver scheme that solves the advection equations
+      switch (parameters.nonlinear_solver)
+        {
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_single_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_defect_correction_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_defect_correction_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_defect_correction_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Newton_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Newton_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_no_Stokes:
+            return true;
+
+          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_single_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::first_timestep_only_single_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_no_Stokes:
+            return false;
+        }
+      Assert(false, ExcNotImplemented());
+      return false;
+    }
+
+
+
+    template <int dim>
+    bool solver_scheme_solves_stokes_equations(const Parameters<dim> &parameters)
+    {
+      // Check if we use a solver scheme that solves the Stokes equations
+      switch (parameters.nonlinear_solver)
+        {
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_single_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_single_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_defect_correction_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_defect_correction_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_defect_correction_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Newton_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Newton_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::first_timestep_only_single_Stokes:
+            return true;
+
+          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_no_Stokes:
+          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_no_Stokes:
+            return false;
+        }
+      Assert(false, ExcNotImplemented());
+      return false;
+    }
+
+
+
+    template <int dim>
+    bool compositional_field_needs_matrix_block(const Introspection<dim> &introspection, const unsigned int composition_index)
+    {
+      const typename Simulator<dim>::AdvectionField adv_field (Simulator<dim>::AdvectionField::composition(composition_index));
+      switch (adv_field.advection_method(introspection))
+        {
+          case Parameters<dim>::AdvectionFieldMethod::fem_field:
+          case Parameters<dim>::AdvectionFieldMethod::fem_melt_field:
+          case Parameters<dim>::AdvectionFieldMethod::fem_darcy_field:
+          case Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion:
+            return true;
+          case Parameters<dim>::AdvectionFieldMethod::particles:
+          case Parameters<dim>::AdvectionFieldMethod::volume_of_fluid:
+          case Parameters<dim>::AdvectionFieldMethod::static_field:
+          case Parameters<dim>::AdvectionFieldMethod::prescribed_field:
+            break;
+          default:
+            Assert (false, ExcNotImplemented());
+        }
+      return false;
+    }
+
+
+
+    template <int dim>
+    bool compositional_fields_need_matrix_block(const Introspection<dim> &introspection)
+    {
+      // Check if any compositional field method actually requires a matrix block
+      // (as opposed to all are advected by other means or prescribed fields)
+      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+        {
+          if (compositional_field_needs_matrix_block(introspection, c))
+            return true;
+        }
+      return false;
+    }
+  }
+
+
+
+  template <int dim>
+  Table<2,DoFTools::Coupling>
+  Simulator<dim>::
+  setup_system_matrix_coupling () const
+  {
+    Table<2,DoFTools::Coupling> coupling(introspection.n_components,
+                                         introspection.n_components);
+
+    // Start by assuming nothing couples
+    coupling.fill (DoFTools::none);
+
+    const typename Introspection<dim>::ComponentIndices &x
+      = introspection.component_indices;
+
+    // Determine which blocks in the Stokes blocks
+    // of the matrix are in use. At the moment this distinguishes
+    // 3 solvers: melt transport, matrix-free multigrid, and the default
+    // matrix based algebraic multigrid.
+    if (solver_scheme_solves_stokes_equations(parameters))
+      {
+        // The matrix-free solver does not work with melt transport
+        Assert(!(parameters.include_melt_transport && stokes_matrix_free),
+               ExcNotImplemented());
+
+        if (stokes_matrix_free)
+          {
+            // nothing couples in the matrix free solver
+          }
+        else if (parameters.include_melt_transport)
+          {
+            // For the melt transport solver all velocities and pressures couple with themselves.
+            // Additionally solid velocities couple with all pressures, and all pressures
+            // couple with solid velocities.
+
+            const unsigned int first_fluid_c_i = introspection.variable("fluid velocity").first_component_index;
+
+            for (unsigned int d=0; d<dim; ++d)
+              {
+                for (unsigned int c=0; c<dim; ++c)
+                  {
+                    coupling[x.velocities[c]][x.velocities[d]] = DoFTools::always;
+                    coupling[first_fluid_c_i+c][first_fluid_c_i+d] = DoFTools::always;
+                  }
+
+                coupling[x.velocities[d]][
+                  introspection.variable("compaction pressure").first_component_index] = DoFTools::always;
+                coupling[introspection.variable("compaction pressure").first_component_index]
+                [x.velocities[d]]
+                  = DoFTools::always;
+                coupling[x.velocities[d]]
+                [introspection.variable("fluid pressure").first_component_index]
+                  = DoFTools::always;
+                coupling[introspection.variable("fluid pressure").first_component_index]
+                [x.velocities[d]]
+                  = DoFTools::always;
+              }
+
+            coupling[introspection.variable("fluid pressure").first_component_index]
+            [introspection.variable("fluid pressure").first_component_index]
+              = DoFTools::always;
+            coupling[introspection.variable("compaction pressure").first_component_index]
+            [introspection.variable("compaction pressure").first_component_index]
+              = DoFTools::always;
+          }
+        else
+          {
+            // The AMG matrix based solver: all velocities couple with all velocities,
+            // pressure couples with all velocities and the other way around,
+            // and pressures only couple with themselves for equal order elements
+            for (unsigned int c=0; c<dim; ++c)
+              for (unsigned int d=0; d<dim; ++d)
+                coupling[x.velocities[c]][x.velocities[d]] = DoFTools::always;
+
+            for (unsigned int d=0; d<dim; ++d)
+              {
+                coupling[x.velocities[d]][x.pressure] = DoFTools::always;
+                coupling[x.pressure][x.velocities[d]] = DoFTools::always;
+              }
+
+            // For equal-order interpolation, we need a stabilization term
+            // in the bottom right of Stokes matrix. Make sure we have the
+            // necessary entries.
+            if (parameters.use_equal_order_interpolation_for_stokes == true)
+              coupling[x.pressure][x.pressure] = DoFTools::always;
+          }
+      }
+
+    // Only enable temperature coupling if temperature block is needed
+    if (solver_scheme_solves_advection_equations(parameters)
+        &&
+        parameters.temperature_method != Parameters<dim>::AdvectionFieldMethod::prescribed_field
+        &&
+        parameters.temperature_method != Parameters<dim>::AdvectionFieldMethod::static_field)
+      coupling[x.temperature][x.temperature] = DoFTools::always;
+
+    // Only enable composition coupling if a composition block is needed
+    if (solver_scheme_solves_advection_equations(parameters)
+        &&
+        compositional_fields_need_matrix_block(introspection))
+      {
+        // We reuse matrix blocks for compositional fields, but we need different blocks for each base_element.
+        // All other matrix blocks are left empty to save memory.
+        for (const unsigned int base_element_index : introspection.get_composition_base_element_indices())
+          {
+            bool block_needed = false;
+            for (const unsigned int c : introspection.get_compositional_field_indices_with_base_element(base_element_index))
+              if (compositional_field_needs_matrix_block(introspection, c))
+                block_needed = true;
+
+            if (block_needed)
+              {
+                const unsigned int first_c = introspection.get_compositional_field_indices_with_base_element(base_element_index).front();
+                coupling[x.compositional_fields[first_c]][x.compositional_fields[first_c]] = DoFTools::always;
+              }
+          }
+      }
+
+    // If we are using volume of fluid interface tracking, create a matrix block in the
+    // field corresponding to the volume fraction.
+    if (parameters.volume_of_fluid_tracking_enabled)
+      {
+        const unsigned int volume_of_fluid_block = volume_of_fluid_handler->field_struct_for_field_index(0)
+                                                   .volume_fraction.first_component_index;
+        coupling[volume_of_fluid_block][volume_of_fluid_block] = DoFTools::always;
+      }
+
+    return coupling;
+  }
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  setup_system_matrix (const std::vector<IndexSet> &system_partitioning)
+  {
+    system_matrix.clear ();
+
+    const Table<2,DoFTools::Coupling> coupling = setup_system_matrix_coupling();
+    LinearAlgebra::BlockDynamicSparsityPattern sp;
+
+    sp.reinit (system_partitioning,
+               system_partitioning,
+               introspection.index_sets.system_relevant_partitioning,
+               mpi_communicator);
+
+
+    if ((parameters.use_discontinuous_temperature_discretization) ||
+        (parameters.have_discontinuous_composition_discretization) ||
+        (parameters.volume_of_fluid_tracking_enabled))
+      {
+        Table<2,DoFTools::Coupling> face_coupling (introspection.n_components,
+                                                   introspection.n_components);
+        face_coupling.fill (DoFTools::none);
+
+        const typename Introspection<dim>::ComponentIndices &x
+          = introspection.component_indices;
+        if (parameters.use_discontinuous_temperature_discretization &&
+            solver_scheme_solves_advection_equations(parameters) &&
+            parameters.temperature_method != Parameters<dim>::AdvectionFieldMethod::prescribed_field &&
+            parameters.temperature_method != Parameters<dim>::AdvectionFieldMethod::static_field)
+          face_coupling[x.temperature][x.temperature] = DoFTools::always;
+
+        for (const unsigned int base_element_index : introspection.get_composition_base_element_indices())
+          {
+            bool block_needed = false;
+            for (const unsigned int c : introspection.get_compositional_field_indices_with_base_element(base_element_index))
+              if (compositional_field_needs_matrix_block(introspection, c))
+                block_needed = true;
+
+            const unsigned int first_c = introspection.get_compositional_field_indices_with_base_element(base_element_index).front();
+
+            if (parameters.use_discontinuous_composition_discretization[first_c]
+                && solver_scheme_solves_advection_equations(parameters)
+                && block_needed)
+              face_coupling[x.compositional_fields[first_c]][x.compositional_fields[first_c]] = DoFTools::always;
+          }
+
+        if (parameters.volume_of_fluid_tracking_enabled)
+          {
+            const unsigned int volume_of_fluid_block = volume_of_fluid_handler->field_struct_for_field_index(0)
+                                                       .volume_fraction.first_component_index;
+            face_coupling[volume_of_fluid_block][volume_of_fluid_block] = DoFTools::always;
+          }
+
+        DoFTools::make_flux_sparsity_pattern (dof_handler,
+                                              sp,
+                                              current_constraints, false,
+                                              coupling,
+                                              face_coupling,
+                                              Utilities::MPI::
+                                              this_mpi_process(mpi_communicator));
+
+        if (solver_scheme_solves_advection_equations(parameters))
+          {
+            // If we solve for more than one compositional field make sure we keep constrained entries
+            // to allow different boundary conditions for different fields. In order to keep constrained
+            // entries we need to repeat the call to DoFTools::make_flux_sparsity_pattern above,
+            // but with 'true' as 4th argument, and only for the composition block.
+            Table<2,DoFTools::Coupling> composition_coupling(introspection.n_components,
+                                                             introspection.n_components);
+            composition_coupling.fill (DoFTools::none);
+
+            for (const unsigned int base_element_index : introspection.get_composition_base_element_indices())
+              {
+                const unsigned int first_c = introspection.get_compositional_field_indices_with_base_element(base_element_index).front();
+                const unsigned int component = x.compositional_fields[first_c];
+                composition_coupling[component][component] = coupling[component][component];
+
+                const unsigned int block = introspection.block_indices.compositional_field_sparsity_pattern[first_c];
+                sp.block(block,block).reinit(sp.block(block,block).locally_owned_range_indices(),
+                                             sp.block(block,block).locally_owned_domain_indices());
+
+                DoFTools::make_flux_sparsity_pattern (dof_handler,
+                                                      sp,
+                                                      current_constraints, true,
+                                                      composition_coupling,
+                                                      face_coupling,
+                                                      Utilities::MPI::
+                                                      this_mpi_process(mpi_communicator));
+              }
+          }
+      }
+    else
+      {
+        DoFTools::make_sparsity_pattern (dof_handler,
+                                         coupling, sp,
+                                         current_constraints, false,
+                                         Utilities::MPI::
+                                         this_mpi_process(mpi_communicator));
+
+        // If we solve for more than one compositional field make sure we keep constrained entries
+        // to allow different boundary conditions for different fields. In order to keep constrained
+        // entries we need to repeat the call to DoFTools::make_sparsity_pattern above,
+        // but with 'true' as 4th argument, and only for the composition block.
+        if (solver_scheme_solves_advection_equations(parameters)
+            &&
+            compositional_fields_need_matrix_block(introspection))
+          {
+            Table<2,DoFTools::Coupling> composition_coupling(introspection.n_components,
+                                                             introspection.n_components);
+            composition_coupling.fill (DoFTools::none);
+
+            const unsigned int component = introspection.component_indices.compositional_fields[0];
+            composition_coupling[component][component] = coupling[component][component];
+
+            const unsigned int block = introspection.get_components_to_blocks()[component];
+            sp.block(block,block).reinit(sp.block(block,block).locally_owned_range_indices(),
+                                         sp.block(block,block).locally_owned_domain_indices());
+
+            DoFTools::make_sparsity_pattern (dof_handler,
+                                             composition_coupling, sp,
+                                             current_constraints, true,
+                                             Utilities::MPI::
+                                             this_mpi_process(mpi_communicator));
+          }
+      }
+
+    sp.compress();
+
+    // We may only allocate some of the matrix blocks, but the sparsity pattern
+    // will still create entries for hanging nodes and boundary conditions.
+    // These are unnecessary and are removed here.
+    for (unsigned int i=0; i<introspection.n_components; ++i)
+      {
+        if (coupling[i][i] == DoFTools::none)
+          {
+            // The pressure is special, because it does not couple with itself,
+            // but if the velocity block is assembled we also need to keep pressure
+            // hanging node constraints. Thus skip clearing the
+            // sparsity pattern in that case.
+            if ((i == introspection.component_indices.pressure) &&
+                coupling[introspection.component_indices.velocities[0]][introspection.component_indices.velocities[0]] != DoFTools::none)
+              continue;
+
+            const unsigned int block = introspection.get_components_to_blocks()[i];
+
+            // TODO: using clear() would be nice here but clear() also resets the
+            // size, so just reinit():
+            sp.block(block,block).reinit(sp.block(block,block).locally_owned_range_indices(),
+                                         sp.block(block,block).locally_owned_domain_indices());
+            sp.block(block,block).compress();
+          }
+      }
+
+    system_matrix.reinit (sp);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::
+  setup_system_preconditioner (const std::vector<IndexSet> &system_partitioning)
+  {
+    Amg_preconditioner.reset ();
+    Mp_preconditioner.reset ();
+    system_preconditioner_matrix.clear ();
+
+    // The preconditioner matrix is only used for the Stokes block (velocity and Schur complement)
+    // and only needed if we actually solve iteratively and matrix-based
+    if (solver_scheme_solves_stokes_equations(parameters) == false)
+      return;
+    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
+      return;
+    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_amg)
+      {
+        // continue below
+      }
+    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::direct_solver)
+      return;
+    else
+      AssertThrow(false, ExcNotImplemented());
+
+    Table<2,DoFTools::Coupling> coupling (introspection.n_components,
+                                          introspection.n_components);
+    coupling.fill (DoFTools::none);
+
+    const typename Introspection<dim>::ComponentIndices &x
+      = introspection.component_indices;
+
+    // velocity-velocity block (only block diagonal) is only
+    // needed if we use the simplified A block preconditioner
+    if (parameters.use_full_A_block_preconditioner == false)
+      for (unsigned int d=0; d<dim; ++d)
+        coupling[x.velocities[d]][x.velocities[d]] = DoFTools::always;
+
+    // TODO: The newton handler always assembles the preconditioner matrix
+    // even if it is not used. Fix that by modifying the newton assemblers.
+    if (newton_handler.get() != nullptr)
+      for (unsigned int d=0; d<dim; ++d)
+        coupling[x.velocities[d]][x.velocities[d]] = DoFTools::always;
+
+    // Schur complement block (pressure - pressure):
+    if (parameters.include_melt_transport)
+      {
+        coupling[introspection.variable("fluid pressure").first_component_index]
+        [introspection.variable("fluid pressure").first_component_index] = DoFTools::always;
+        coupling[introspection.variable("compaction pressure").first_component_index]
+        [introspection.variable("compaction pressure").first_component_index] = DoFTools::always;
+        coupling[introspection.variable("compaction pressure").first_component_index]
+        [introspection.variable("fluid pressure").first_component_index] = DoFTools::always;
+        coupling[introspection.variable("fluid pressure").first_component_index]
+        [introspection.variable("compaction pressure").first_component_index] = DoFTools::always;
+      }
+    else
+      coupling[x.pressure][x.pressure] = DoFTools::always;
+    // the system_preconditioner matrix is only used for the Stokes
+    // system as there we use a separate matrix for preconditioning
+    // than the system_matrix object). for temperature and
+    // compositional fields, we precondition with the respective block
+    // of system_matrix. consequently, there is no need to allocate
+    // memory for these blocks in the system_preconditioner matrix and
+    // its sparsity pattern here -- the corresponding entries of
+    // 'coupling' simply remain at DoFTools::none
+
+    LinearAlgebra::BlockDynamicSparsityPattern sp;
+
+    sp.reinit (system_partitioning,
+               system_partitioning,
+               introspection.index_sets.system_relevant_partitioning,
+               mpi_communicator);
+
+    DoFTools::make_sparsity_pattern (dof_handler,
+                                     coupling, sp,
+                                     current_constraints, false,
+                                     Utilities::MPI::
+                                     this_mpi_process(mpi_communicator));
+
+
+    sp.compress();
+
+    // We are not interested in temperature and composition matrices for the
+    // preconditioner matrix. But even though we specify a coupling of
+    // DoFTools::none, entries for constrained entries for boundary conditions
+    // and hanging nodes are being created by make_sparsity_pattern. These are
+    // unnecessary, so we remove those entries here.
+    {
+      // temperature:
+      const unsigned int block_idx = introspection.block_indices.temperature;
+      // TODO: using clear() would be nice here but clear() also resets the
+      // size, so just reinit():
+      sp.block(block_idx, block_idx).reinit(sp.block(block_idx, block_idx).locally_owned_range_indices(),
+                                            sp.block(block_idx, block_idx).locally_owned_domain_indices());
+      sp.block(block_idx, block_idx).compress();
+    }
+    // compositions:
+    for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+      {
+        const unsigned int block_idx = introspection.block_indices.compositional_fields[c];
+        // TODO: using clear() would be nice here but clear() also resets the
+        // size, so just reinit():
+        sp.block(block_idx, block_idx).reinit(sp.block(block_idx, block_idx).locally_owned_range_indices(),
+                                              sp.block(block_idx, block_idx).locally_owned_domain_indices());
+        sp.block(block_idx, block_idx).compress();
+      }
+
+    system_preconditioner_matrix.reinit (sp);
+    if (parameters.use_bfbt)
+      inverse_lumped_mass_matrix.reinit(introspection.index_sets.stokes_partitioning);
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::compute_initial_velocity_boundary_constraints (AffineConstraints<double> &constraints)
+  {
+
+    // This needs to happen after the periodic constraints are added:
+    setup_nullspace_constraints(constraints);
+
+    // then compute constraints for the velocity. the constraints we compute
+    // here are the ones that are the same for all following time steps. in
+    // addition, we may be computing constraints from boundary values for the
+    // velocity that are different between time steps. these are then put
+    // into current_constraints in start_timestep().
+    signals.pre_compute_no_normal_flux_constraints(triangulation);
+    {
+      // do the interpolation for zero velocity
+      for (const auto p : boundary_velocity_manager.get_zero_boundary_velocity_indicators())
+        VectorTools::interpolate_boundary_values (*mapping,
+                                                  dof_handler,
+                                                  p,
+                                                  Functions::ZeroFunction<dim>(introspection.n_components),
+                                                  constraints,
+                                                  introspection.component_masks.velocities);
+
+
+      // do the same for no-normal-flux boundaries
+      VectorTools::compute_no_normal_flux_constraints (dof_handler,
+                                                       /* first_vector_component= */
+                                                       introspection.component_indices.velocities[0],
+                                                       boundary_velocity_manager.get_tangential_boundary_velocity_indicators(),
+                                                       constraints,
+                                                       *mapping);
+    }
+
+
+  }
+
+  template <int dim>
+  void Simulator<dim>::compute_current_velocity_boundary_constraints (AffineConstraints<double> &constraints)
+  {
+    // set the current time and do the interpolation
+    // for the prescribed velocity fields
+    boundary_velocity_manager.update();
+    for (const auto &p : boundary_velocity_manager.get_active_boundary_velocity_names())
+      {
+        Utilities::VectorFunctionFromVelocityFunctionObject<dim> vel
+        (introspection.n_components,
+         [&] (const dealii::Point<dim> &x) -> Tensor<1,dim>
+        {
+          return boundary_velocity_manager.boundary_velocity(p.first, x);
+        });
+
+        // here we create a mask for interpolate_boundary_values out of the 'selector'
+        std::vector<bool> mask(introspection.component_masks.velocities.size(), false);
+        const std::string &comp = p.second.first;
+
+        if (comp.length()>0)
+          {
+            for (const char direction : comp)
+              {
+                switch (direction)
+                  {
+                    case 'x':
+                      mask[introspection.component_indices.velocities[0]] = true;
+                      break;
+                    case 'y':
+                      mask[introspection.component_indices.velocities[1]] = true;
+                      break;
+                    case 'z':
+                      // we must be in 3d, or 'z' should never have gotten through
+                      Assert (dim==3, ExcInternalError());
+                      if (dim==3)
+                        mask[introspection.component_indices.velocities[dim-1]] = true;
+                      break;
+                    default:
+                      Assert (false, ExcInternalError());
+                  }
+              }
+          }
+        else
+          {
+            // no mask given -- take all velocities
+            for (unsigned int i=0; i<introspection.component_masks.velocities.size(); ++i)
+              mask[i]=introspection.component_masks.velocities[i];
+          }
+
+        if (!assemble_newton_stokes_system || (assemble_newton_stokes_system && nonlinear_iteration == 0))
+          {
+            VectorTools::interpolate_boundary_values (*mapping,
+                                                      dof_handler,
+                                                      p.first,
+                                                      vel,
+                                                      constraints,
+                                                      ComponentMask(mask));
+          }
+        else
+          {
+            VectorTools::interpolate_boundary_values (*mapping,
+                                                      dof_handler,
+                                                      p.first,
+                                                      Functions::ZeroFunction<dim>(introspection.n_components),
+                                                      constraints,
+                                                      ComponentMask(mask));
+          }
+      }
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::setup_dofs ()
+  {
+    signals.edit_parameters_pre_setup_dofs(*this, parameters);
+
+    TimerOutput::Scope timer (computing_timer, "Setup dof systems");
+
+    dof_handler.distribute_dofs(finite_element);
+
+    // Renumber the DoFs hierarchical so that we get the
+    // same numbering if we resume the computation. This
+    // is because the numbering depends on the order the
+    // cells are created.
+    DoFRenumbering::hierarchical (dof_handler);
+    DoFRenumbering::component_wise (dof_handler,
+                                    introspection.get_components_to_blocks());
+
+    // set up the introspection object that stores all sorts of
+    // information about components of the finite element, component
+    // masks, etc
+    setup_introspection();
+
+    // print dof numbers. Do so with 1000s separator since they are frequently
+    // large
+    {
+      std::locale s = pcout.get_stream().getloc();
+      // Creating std::locale with an empty string previously caused problems
+      // on some platforms, so the functionality to catch the exception and ignore
+      // is kept here, even though explicitly setting a facet should always work.
+      try
+        {
+          // Imbue the stream with a locale that does the right thing. The
+          // locale is responsible for later deleting the object pointed
+          // to by the last argument (the "facet"), see
+          // https://en.cppreference.com/w/cpp/locale/locale/locale
+          pcout.get_stream().imbue(std::locale(std::locale(),
+                                               new aspect::Utilities::ThousandSep));
+        }
+      catch (const std::runtime_error &e)
+        {
+          // If the locale doesn't work, just give up
+        }
+
+      pcout << "Number of active cells: "
+            << triangulation.n_global_active_cells()
+            << " (on "
+            << triangulation.n_global_levels()
+            << " levels)"
+            << std::endl
+            << "Number of degrees of freedom: "
+            << dof_handler.n_dofs()
+            << " ("
+            << introspection.system_dofs_per_block[0];
+      for (unsigned int b=1; b<introspection.system_dofs_per_block.size(); ++b)
+        pcout << '+' << introspection.system_dofs_per_block[b];
+      pcout <<')'
+            << std::endl
+            << std::endl;
+
+      pcout.get_stream().imbue(s);
+    }
+
+    // We need to set up the mesh deformation degrees of freedom first if mesh deformation
+    // is active, since the mapping must be in place before applying boundary
+    // conditions that rely on it (such as no flux BCs).
+    if (parameters.mesh_deformation_enabled)
+      mesh_deformation->setup_dofs();
+
+
+    // Reconstruct the constraint-matrix:
+#if DEAL_II_VERSION_GTE(9,6,0)
+    constraints.reinit (dof_handler.locally_owned_dofs(), introspection.index_sets.system_relevant_set);
+#else
+    constraints.reinit(introspection.index_sets.system_relevant_set);
+#endif
+
+    // Set up the constraints for periodic boundary conditions:
+
+    // Note: this has to happen _before_ we do hanging node constraints,
+    // because inconsistent constraints could be generated in parallel otherwise.
+    geometry_model->make_periodicity_constraints(dof_handler,
+                                                 constraints);
+
+    //  Make hanging node constraints:
+    DoFTools::make_hanging_node_constraints (dof_handler,
+                                             constraints);
+
+
+    compute_initial_velocity_boundary_constraints(constraints);
+    constraints.close();
+    signals.post_compute_no_normal_flux_constraints(triangulation);
+
+    // Finally initialize vectors. We delay construction of the sparsity
+    // patterns and matrices until we have current_constraints.
+    rebuild_sparsity_and_matrices = true;
+
+    system_rhs.reinit(introspection.index_sets.system_partitioning, mpi_communicator);
+    solution.reinit(introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
+    old_solution.reinit(introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
+    old_old_solution.reinit(introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
+    current_linearization_point.reinit (introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
+
+    if (parameters.use_operator_splitting)
+      operator_split_reaction_vector.reinit (introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
+
+    if (do_pressure_rhs_compatibility_modification)
+      pressure_shape_function_integrals.reinit (introspection.index_sets.system_partitioning, mpi_communicator);
+
+    rebuild_stokes_matrix         = true;
+    rebuild_stokes_preconditioner = true;
+
+    // Setup matrix-free dofs
+    if (stokes_matrix_free)
+      stokes_matrix_free->setup_dofs();
+  }
+
+
+
+
+
+  template <int dim>
+  void Simulator<dim>::setup_introspection ()
+  {
+    // compute the various partitionings between processors and blocks
+    // of vectors and matrices
+    introspection.system_dofs_per_block = DoFTools::count_dofs_per_fe_block (dof_handler,
+                                                                             introspection.get_components_to_blocks());
+
+    {
+      IndexSet system_index_set = dof_handler.locally_owned_dofs();
+      introspection.index_sets.system_partitioning = system_index_set.split_by_block(introspection.system_dofs_per_block);
+
+      DoFTools::extract_locally_relevant_dofs (dof_handler,
+                                               introspection.index_sets.system_relevant_set);
+      introspection.index_sets.system_relevant_partitioning =
+        introspection.index_sets.system_relevant_set.split_by_block(introspection.system_dofs_per_block);
+
+      if (!parameters.include_melt_transport)
+        {
+          if (parameters.use_direct_stokes_solver)
+            introspection.index_sets.locally_owned_pressure_dofs = system_index_set & Utilities::extract_locally_active_dofs_with_component(dof_handler, introspection.component_masks.pressure);
+          else
+            introspection.index_sets.locally_owned_pressure_dofs = introspection.index_sets.system_partitioning[introspection.block_indices.pressure];
+        }
+
+      if (parameters.include_melt_transport)
+        {
+          introspection.index_sets.locally_owned_melt_pressure_dofs = system_index_set & Utilities::extract_locally_active_dofs_with_component(dof_handler,
+                                                                      introspection.variable("fluid pressure").component_mask|
+                                                                      introspection.variable("compaction pressure").component_mask);
+          introspection.index_sets.locally_owned_fluid_pressure_dofs = system_index_set & Utilities::extract_locally_active_dofs_with_component(dof_handler,
+                                                                       introspection.variable("fluid pressure").component_mask);
+        }
+
+
+
+      introspection.index_sets.stokes_partitioning.clear ();
+      introspection.index_sets.stokes_partitioning.push_back(introspection.index_sets.system_partitioning[introspection.block_indices.velocities]);
+      if (!parameters.use_direct_stokes_solver)
+        {
+          if (parameters.include_melt_transport)
+            // p_f and p_c are in the same block
+            introspection.index_sets.stokes_partitioning.push_back(introspection.index_sets.system_partitioning[introspection.variable("fluid pressure").block_index]);
+          else
+            introspection.index_sets.stokes_partitioning.push_back(introspection.index_sets.system_partitioning[introspection.block_indices.pressure]);
+        }
+
+      Assert(!parameters.use_direct_stokes_solver ||
+             parameters.include_melt_transport ||
+             (introspection.block_indices.velocities == introspection.block_indices.pressure),
+             ExcInternalError());
+    }
+
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::postprocess ()
+  {
+    TimerOutput::Scope timer (computing_timer, "Postprocessing");
+    pcout << "   Postprocessing:" << std::endl;
+
+    // run all the postprocessing routines and then write
+    // the current state of the statistics table to a file
+    std::list<std::pair<std::string,std::string>>
+    output_list = postprocess_manager.execute (statistics);
+
+    // if we are on processor zero, print to screen
+    // whatever the postprocessors have generated
+    if (Utilities::MPI::this_mpi_process(mpi_communicator)==0)
+      {
+        // determine the width of the first column of text so that
+        // everything gets nicely aligned; then output everything
+        {
+          unsigned int width = 0;
+          for (const auto &p : output_list)
+            width = std::max<unsigned int> (width, p.first.size());
+
+          for (const auto &p : output_list)
+            pcout << "     "
+                  << std::left
+                  << std::setw(width)
+                  << p.first
+                  << ' '
+                  << p.second
+                  << std::endl;
+        }
+
+        pcout << std::endl;
+      }
+
+    // finally, write the entire set of current results to disk
+    output_statistics();
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::refine_mesh (const unsigned int max_grid_level)
+  {
+    parallel::distributed::SolutionTransfer<dim,LinearAlgebra::BlockVector>
+    system_trans(dof_handler);
+
+    std::unique_ptr<parallel::distributed::SolutionTransfer<dim,LinearAlgebra::Vector>>
+    mesh_deformation_trans;
+
+    {
+      TimerOutput::Scope timer (computing_timer, "Refine mesh structure, part 1");
+
+      Vector<float> estimated_error_per_cell (triangulation.n_active_cells());
+      mesh_refinement_manager.execute (estimated_error_per_cell);
+
+      if (parameters.adapt_by_fraction_of_cells)
+        parallel::distributed::GridRefinement::
+        refine_and_coarsen_fixed_number   (triangulation,
+                                           estimated_error_per_cell,
+                                           parameters.refinement_fraction,
+                                           parameters.coarsening_fraction);
+      else
+        parallel::distributed::GridRefinement::
+        refine_and_coarsen_fixed_fraction (triangulation,
+                                           estimated_error_per_cell,
+                                           parameters.refinement_fraction,
+                                           parameters.coarsening_fraction);
+
+      mesh_refinement_manager.tag_additional_cells ();
+
+
+      // clear refinement flags if parameter.refinement_fraction=0.0
+      if (parameters.refinement_fraction==0.0)
+        {
+          for (const auto &cell : triangulation.active_cell_iterators())
+            cell->clear_refine_flag ();
+        }
+      else
+        {
+          // limit maximum refinement level
+          if (triangulation.n_levels() > max_grid_level)
+            for (typename Triangulation<dim>::active_cell_iterator
+                 cell = triangulation.begin_active(max_grid_level);
+                 cell != triangulation.end(); ++cell)
+              cell->clear_refine_flag ();
+        }
+
+      // clear coarsening flags if parameter.coarsening_fraction=0.0
+      if (parameters.coarsening_fraction==0.0)
+        {
+          for (const auto &cell : triangulation.active_cell_iterators())
+            cell->clear_coarsen_flag ();
+        }
+      else
+        {
+          // limit minimum refinement level
+          for (typename Triangulation<dim>::active_cell_iterator
+               cell = triangulation.begin_active(0);
+               cell != triangulation.end_active(parameters.min_grid_level); ++cell)
+            cell->clear_coarsen_flag ();
+        }
+
+
+      // Next set up whatever is necessary to transfer the solution from old
+      // to new mesh:
+      std::vector<const LinearAlgebra::BlockVector *> x_system
+        = { &solution, &old_solution };
+
+      if (parameters.mesh_deformation_enabled)
+        x_system.push_back(&mesh_deformation->mesh_velocity);
+
+      std::vector<const LinearAlgebra::Vector *> x_fs_system;
+      if (parameters.mesh_deformation_enabled)
+        {
+          x_fs_system.push_back (&mesh_deformation->mesh_displacements);
+          x_fs_system.push_back (&mesh_deformation->old_mesh_displacements);
+          x_fs_system.push_back (&mesh_deformation->initial_topography);
+          mesh_deformation_trans
+            = std::make_unique<parallel::distributed::SolutionTransfer<dim,LinearAlgebra::Vector>>
+              (mesh_deformation->mesh_deformation_dof_handler);
+        }
+
+
+      // Possibly store data of plugins associated with cells
+      signals.pre_refinement_store_user_data(triangulation);
+
+      exchange_refinement_flags();
+
+      triangulation.prepare_coarsening_and_refinement();
+      bool any_flags_set = false;
+      {
+        for (const auto &cell:dof_handler.active_cell_iterators())
+          {
+            if (cell->refine_flag_set() || cell->coarsen_flag_set())
+              {
+                any_flags_set = true;
+                break;
+              }
+          }
+      }
+      const bool mesh_changed = Utilities::MPI::max(any_flags_set?1:0,mpi_communicator) == 1 ? true : false;
+      if (!mesh_changed)
+        {
+          pcout << "Skipping mesh refinement, because the mesh did not change.\n" << std::endl;
+          return;
+        }
+
+      system_trans.prepare_for_coarsening_and_refinement(x_system);
+
+      if (parameters.mesh_deformation_enabled)
+        mesh_deformation_trans->prepare_for_coarsening_and_refinement(x_fs_system);
+
+      triangulation.execute_coarsening_and_refinement ();
+      if (MappingQCache<dim> *map = dynamic_cast<MappingQCache<dim>*>(&(*mapping)))
+        map->initialize(MappingQGeneric<dim>(4), triangulation);
+    } // leave the timed section
+
+    setup_dofs ();
+
+    {
+      TimerOutput::Scope timer (computing_timer, "Refine mesh structure, part 2");
+
+      LinearAlgebra::BlockVector distributed_system;
+      LinearAlgebra::BlockVector old_distributed_system;
+      LinearAlgebra::BlockVector distributed_mesh_velocity;
+
+      distributed_system.reinit(introspection.index_sets.system_partitioning, mpi_communicator);
+      old_distributed_system.reinit(introspection.index_sets.system_partitioning, mpi_communicator);
+      if (parameters.mesh_deformation_enabled)
+        distributed_mesh_velocity.reinit(introspection.index_sets.system_partitioning, mpi_communicator);
+
+      std::vector<LinearAlgebra::BlockVector *> system_tmp
+        = { &distributed_system, &old_distributed_system};
+
+      if (parameters.mesh_deformation_enabled)
+        system_tmp.push_back(&distributed_mesh_velocity);
+
+      // transfer the data previously stored into the vectors indexed by
+      // system_tmp. then ensure that the interpolated solution satisfies
+      // hanging node constraints
+      //
+      // note that the 'constraints' variable contains hanging node constraints
+      // and constraints from periodic boundary conditions (as well as from
+      // zero and tangential velocity boundary conditions), but not from
+      // non-homogeneous boundary conditions. the latter are added not in setup_dofs(),
+      // which we call above, but added to 'current_constraints' in start_timestep(),
+      // which we do not want to call here.
+      //
+      // however, what we have should be sufficient: we have everything that
+      // is necessary to make the solution vectors *conforming* on the current
+      // mesh.
+      system_trans.interpolate (system_tmp);
+
+      constraints.distribute (distributed_system);
+      solution     = distributed_system;
+
+      constraints.distribute (old_distributed_system);
+      old_solution = old_distributed_system;
+
+      // We need the current linearization point at the start of the new time step
+      // when we set the boundary conditions for advected fields (to determine parts
+      // of the boundary with outflow). Therefore, we here set it to the solution
+      // vector, but it will be reinitialized the next time the equations are solved.
+      current_linearization_point = distributed_system;
+
+      // do the same as above, but for the mesh deformation solution
+      if (parameters.mesh_deformation_enabled)
+        {
+          constraints.distribute (distributed_mesh_velocity);
+          mesh_deformation->mesh_velocity = distributed_mesh_velocity;
+
+          LinearAlgebra::Vector distributed_mesh_displacements,
+                        distributed_old_mesh_displacements,
+                        distributed_initial_topography;
+
+          distributed_mesh_displacements.reinit(mesh_deformation->mesh_locally_owned,
+                                                mpi_communicator);
+          distributed_old_mesh_displacements.reinit(mesh_deformation->mesh_locally_owned,
+                                                    mpi_communicator);
+          distributed_initial_topography.reinit(mesh_deformation->mesh_locally_owned,
+                                                mpi_communicator);
+
+          std::vector<LinearAlgebra::Vector *> system_tmp
+          = { &distributed_mesh_displacements,
+              &distributed_old_mesh_displacements,
+              &distributed_initial_topography
+            };
+
+          mesh_deformation_trans->interpolate (system_tmp);
+
+          mesh_deformation->mesh_vertex_constraints.distribute (distributed_mesh_displacements);
+          mesh_deformation->mesh_displacements = distributed_mesh_displacements;
+
+          mesh_deformation->mesh_vertex_constraints.distribute (distributed_old_mesh_displacements);
+          mesh_deformation->old_mesh_displacements = distributed_old_mesh_displacements;
+
+          mesh_deformation->mesh_vertex_constraints.distribute (distributed_initial_topography);
+          mesh_deformation->initial_topography = distributed_initial_topography;
+        }
+
+      // Possibly load data of plugins associated with cells
+      signals.post_refinement_load_user_data(triangulation);
+
+      // calculate global volume after refining mesh
+      global_volume = GridTools::volume (triangulation, *mapping);
+    }
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  solve_timestep ()
+  {
+    // start any scheme with an extrapolated value from the previous
+    // two time steps if those are available
+    initialize_current_linearization_point();
+
+    // The mesh deformation scheme is currently not built to work inside a nonlinear solver.
+    // We do the mesh deformation execution at the beginning of the timestep for a specific reason.
+    // The time step size is calculated AFTER the whole solve_timestep() function.  If we call
+    // mesh_deformation_execute() after the Stokes solve, it will be before we know what the appropriate
+    // time step to take is, and we will timestep the boundary incorrectly.
+    if (parameters.mesh_deformation_enabled)
+      {
+        mesh_deformation->execute ();
+
+        // calculate global volume after deforming mesh
+        global_volume = GridTools::volume (triangulation, *mapping);
+        signals.post_mesh_deformation(*this);
+      }
+
+    // Compute the reactions of compositional fields and temperature in case of operator splitting.
+    if (parameters.use_operator_splitting)
+      compute_reactions ();
+
+    switch (parameters.nonlinear_solver)
+      {
+        case NonlinearSolver::single_Advection_single_Stokes:
+        {
+          solve_single_advection_single_stokes();
+          break;
+        }
+
+        case NonlinearSolver::no_Advection_iterated_Stokes:
+        {
+          solve_no_advection_iterated_stokes();
+          break;
+        }
+
+        case NonlinearSolver::no_Advection_single_Stokes:
+        {
+          solve_no_advection_single_stokes();
+          break;
+        }
+
+        case NonlinearSolver::iterated_Advection_and_Stokes:
+        {
+          solve_iterated_advection_and_stokes();
+          break;
+        }
+
+        case NonlinearSolver::single_Advection_iterated_Stokes:
+        {
+          solve_single_advection_iterated_stokes();
+          break;
+        }
+
+        case NonlinearSolver::no_Advection_iterated_defect_correction_Stokes:
+        {
+          solve_no_advection_iterated_defect_correction_stokes();
+          break;
+        }
+
+        case NonlinearSolver::single_Advection_iterated_defect_correction_Stokes:
+        {
+          solve_single_advection_iterated_defect_correction_stokes();
+          break;
+        }
+
+        case NonlinearSolver::iterated_Advection_and_defect_correction_Stokes:
+        {
+          solve_iterated_advection_and_defect_correction_stokes();
+          break;
+        }
+
+        case NonlinearSolver::iterated_Advection_and_Newton_Stokes:
+        {
+          solve_iterated_advection_and_newton_stokes(/*use_newton_iterations =*/ true);
+          break;
+        }
+
+        case NonlinearSolver::single_Advection_iterated_Newton_Stokes:
+        {
+          solve_single_advection_and_iterated_newton_stokes(/*use_newton_iterations =*/ true);
+          break;
+        }
+
+        case NonlinearSolver::single_Advection_no_Stokes:
+        {
+          solve_single_advection_no_stokes();
+          break;
+        }
+
+        case NonlinearSolver::first_timestep_only_single_Stokes:
+        {
+          solve_first_timestep_only_single_stokes();
+          break;
+        }
+
+        case NonlinearSolver::no_Advection_no_Stokes:
+        {
+          solve_no_advection_no_stokes();
+          break;
+        }
+
+        default:
+          Assert (false, ExcNotImplemented());
+      }
+
+    pcout << std::endl;
+  }
+
+
+  /**
+   * This is the main function of the program, containing the overall
+   * logic which function is called when.
+   */
+  template <int dim>
+  void Simulator<dim>::run ()
+  {
+    CitationInfo::print_info_block(pcout);
+
+    unsigned int max_refinement_level = parameters.initial_global_refinement +
+                                        parameters.initial_adaptive_refinement;
+    pre_refinement_step = 0;
+
+    // if we want to resume a computation from an earlier point
+    // then reload it from a snapshot. otherwise do the basic
+    // start-up
+    if (parameters.resume_computation == true)
+      {
+        resume_from_snapshot();
+        // we need to remove additional_refinement_times that are in the past
+        // and adjust max_refinement_level which is not written to file
+        while ((parameters.additional_refinement_times.size() > 0)
+               &&
+               (parameters.additional_refinement_times.front () < time+time_step))
+          {
+            ++max_refinement_level;
+            parameters.additional_refinement_times
+            .erase (parameters.additional_refinement_times.begin());
+          }
+      }
+    else
+      {
+        time = parameters.start_time;
+
+        // Instead of calling global_refine(n) we flag all cells for
+        // refinement and then allow the mesh refinement plugins to unflag
+        // the cells if desired. This procedure is repeated n times. If there
+        // is no plugin that modifies the flags, it is equivalent to
+        // refine_global(n).
+        for (unsigned int n=0; n<parameters.initial_global_refinement; ++n)
+          {
+            for (const auto &cell : triangulation.active_cell_iterators())
+              if (cell->is_locally_owned())
+                cell->set_refine_flag ();
+
+            mesh_refinement_manager.tag_additional_cells ();
+
+            exchange_refinement_flags();
+
+            triangulation.execute_coarsening_and_refinement();
+            if (MappingQCache<dim> *map = dynamic_cast<MappingQCache<dim>*>(&(*mapping)))
+              map->initialize(MappingQGeneric<dim>(4), triangulation);
+          }
+
+        setup_dofs();
+
+        // calculate global volume after refining mesh
+        global_volume = GridTools::volume (triangulation, *mapping);
+      }
+
+    // start the timer for periodic checkpoints after the setup above
+    time_t last_checkpoint_time = std::time(nullptr);
+
+  start_time_iteration:
+
+    if (parameters.resume_computation == false)
+      {
+        TimerOutput::Scope timer (computing_timer, "Setup initial conditions");
+
+        timestep_number           = 0;
+        time_step = old_time_step = 0;
+
+        if (! parameters.skip_setup_initial_conditions_on_initial_refinement
+            ||
+            ! (pre_refinement_step < parameters.initial_adaptive_refinement))
+          {
+            // Add topography to box models after all initial refinement
+            // is completed.
+            if (pre_refinement_step == parameters.initial_adaptive_refinement)
+              signals.pre_set_initial_state (triangulation);
+
+            set_initial_temperature_and_compositional_fields ();
+            compute_initial_pressure_field ();
+
+            signals.post_set_initial_state (*this);
+          }
+      }
+
+    // Start the principal loop over time steps. At this point, everything
+    // is completely initialized, so set that status as well
+    simulator_is_past_initialization = true;
+    do
+      {
+        // Only solve if we are not in pre-refinement, or we do not want to skip
+        // solving in pre-refinement.
+        if (! (parameters.skip_solvers_on_initial_refinement
+               && pre_refinement_step < parameters.initial_adaptive_refinement))
+          {
+            start_timestep ();
+
+            // then do the core work: assemble systems and solve
+            solve_timestep ();
+          }
+
+        // See if we have to start over with a new adaptive refinement cycle
+        // at the beginning of the simulation. If so, set the
+        // simulator_is_past_initialization variable back to false because we will
+        // have to re-initialize some variables such as the size of vectors,
+        // the initial state, etc.
+        if (timestep_number == 0)
+          {
+            const bool initial_refinement_done = maybe_do_initial_refinement(max_refinement_level);
+            if (initial_refinement_done)
+              {
+                simulator_is_past_initialization = false;
+                goto start_time_iteration;
+              }
+          }
+
+        // We're now definitely past the point where we need the initial
+        // conditions objects, and we can release the pointers to these objects
+        // that we have created in the constructor of this class. If some of the
+        // other plugins created there still need access to these initial
+        // conditions, they will have created their own shared pointers.
+        initial_temperature_manager.reset();
+        initial_composition_manager.reset();
+#ifdef ASPECT_WITH_WORLD_BUILDER
+        // The same applies to the world builder object:
+        world_builder.reset();
+#endif
+        // Prepare the next time step:
+        time_stepping_manager.update();
+
+        const double new_time_step_size = time_stepping_manager.get_next_time_step_size();
+
+        // if we postprocess nonlinear iterations, this function is called within
+        // solve_timestep () in the individual solver schemes
+        if (!time_stepping_manager.should_repeat_time_step()
+            && !parameters.run_postprocessors_on_nonlinear_iterations)
+          postprocess ();
+
+        if (time_stepping_manager.should_refine_mesh())
+          {
+            pcout << "Refining the mesh based on the time stepping manager ...\n" << std::endl;
+            refine_mesh(max_refinement_level);
+          }
+        else
+          maybe_refine_mesh(new_time_step_size, max_refinement_level);
+
+        if (time_stepping_manager.should_repeat_time_step())
+          {
+            pcout << "Repeating the current time step based on the time stepping manager ..." << std::endl;
+
+            if (mesh_deformation)
+              mesh_deformation->mesh_displacements = mesh_deformation->old_mesh_displacements;
+
+            // adjust time and time_step size:
+            time = time - time_step + new_time_step_size;
+            time_step = new_time_step_size;
+
+            // Restore particles through stored copy of particle handler,
+            // created in start_timestep(),
+            // but only if this timestep is to be repeated.
+            for (auto &particle_world : particle_worlds)
+              particle_world->restore_particles();
+
+            continue; // repeat time step loop
+          }
+
+        // see if we want to write a timing summary
+        maybe_write_timing_output();
+
+        // update values for timestep, increment time step by one.
+        advance_time(new_time_step_size);
+
+        // Check whether to terminate the simulation:
+        const bool should_terminate = time_stepping_manager.should_simulation_terminate_now();
+
+        const bool write_checkpoint_due_to_termination
+          = should_terminate && time_stepping_manager.need_checkpoint_on_terminate();
+
+        const bool checkpoint_written = maybe_write_checkpoint(last_checkpoint_time,
+                                                               write_checkpoint_due_to_termination);
+
+        if (checkpoint_written)
+          last_checkpoint_time = std::time(nullptr);
+
+        if (should_terminate)
+          break;
+      }
+    while (true);
+
+    // we disable automatic summary printing so that it won't happen when
+    // throwing an exception. Therefore, we have to do this manually here:
+    computing_timer.print_summary ();
+
+    pcout << "-- Total wallclock time elapsed including restarts: "
+          << round(wall_timer.wall_time()+total_walltime_until_last_snapshot)
+          << 's' << std::endl;
+
+    CitationInfo::print_info_block (pcout);
+
+    stokes_matrix_free.reset();
+  }
+}
+
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template class Simulator<dim>;
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/entropy_viscosity.cc.bak b/source/simulator/entropy_viscosity.cc.bak
new file mode 100644
index 00000000000..9ddae9f4ff6
--- /dev/null
+++ b/source/simulator/entropy_viscosity.cc.bak
@@ -0,0 +1,710 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/melt.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  /**
+   * Compute the variation in the entropy needed in the definition of the
+   * artificial viscosity used to stabilize the composition/temperature equation.
+   */
+  template <int dim>
+  double
+  Simulator<dim>::get_entropy_variation (const double average_field,
+                                         const AdvectionField &advection_field) const
+  {
+    // only do this if we really need entropy
+    // variation. otherwise return something that's obviously
+    // nonsensical
+    if (parameters.stabilization_alpha != 2)
+      return numbers::signaling_nan<double>();
+
+    // record maximal entropy on Gauss quadrature points
+    const Quadrature<dim> &quadrature_formula
+      = (advection_field.is_temperature() ?
+         introspection.quadratures.temperature :
+         introspection.quadratures.compositional_fields);
+    const unsigned int n_q_points = quadrature_formula.size();
+
+    const FEValuesExtractors::Scalar field = advection_field.scalar_extractor(introspection);
+
+    FEValues<dim> fe_values (finite_element, quadrature_formula,
+                             update_values | update_JxW_values);
+    std::vector<double> old_field_values(n_q_points);
+    std::vector<double> old_old_field_values(n_q_points);
+
+    double min_entropy = std::numeric_limits<double>::max(),
+           max_entropy = std::numeric_limits<double>::lowest(),
+           area = 0,
+           entropy_integrated = 0;
+
+    // loop over all locally owned cells and evaluate the entropy
+    // at all quadrature points. keep a running tally of the
+    // integral over the entropy as well as the area and the
+    // maximal and minimal entropy
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          fe_values[field].get_function_values (old_solution,
+                                                old_field_values);
+          fe_values[field].get_function_values (old_old_solution,
+                                                old_old_field_values);
+          for (unsigned int q=0; q<n_q_points; ++q)
+            {
+              const double field_value = (old_field_values[q] +
+                                          old_old_field_values[q]) / 2;
+              const double entropy = ((field_value-average_field) *
+                                      (field_value-average_field));
+
+              min_entropy = std::min (min_entropy, entropy);
+              max_entropy = std::max (max_entropy, entropy);
+
+              area += fe_values.JxW(q);
+              entropy_integrated += fe_values.JxW(q) * entropy;
+            }
+        }
+
+    // do MPI data exchange: we need to sum over
+    // the two integrals (area,
+    // entropy_integrated), and get the extrema
+    // for maximum and minimum. combine
+    // MPI_Allreduce for two values since that is
+    // an expensive operation
+    const double local_for_sum[2] = { entropy_integrated, area },
+                                    local_for_max[2] = { -min_entropy, max_entropy };
+    double global_for_sum[2], global_for_max[2];
+
+    dealii::Utilities::MPI::sum (local_for_sum, mpi_communicator, global_for_sum);
+    dealii::Utilities::MPI::max (local_for_max, mpi_communicator, global_for_max);
+
+    const double average_entropy = global_for_sum[0] / global_for_sum[1];
+
+    // return the maximal deviation of the entropy everywhere from the
+    // average value
+    return std::max(global_for_max[1] - average_entropy,
+                    average_entropy - (-global_for_max[0]));
+  }
+
+
+
+  template <int dim>
+  double
+  Simulator<dim>::
+  compute_viscosity (internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
+                     const double                        global_u_infty,
+                     const double                        global_field_variation,
+                     const double                        average_field,
+                     const double                        global_entropy_variation,
+                     const double                        cell_diameter,
+                     const AdvectionField               &advection_field) const
+  {
+    // discontinuous Galerkin doesn't require an artificial viscosity
+    if (advection_field.is_discontinuous(introspection))
+      return 0.;
+
+    double max_residual = 0.0;
+    double max_velocity = 0.0;
+    double max_advection_prefactor = 0.0;
+    double max_conductivity = 0.0;
+
+    std::vector<double> residual (scratch.finite_element_values.n_quadrature_points,0.0);
+
+    for (unsigned int i=0; i<assemblers->advection_system[advection_field.field_index()].size(); ++i)
+      {
+        const std::vector<double> new_residual = assemblers->advection_system[advection_field.field_index()][i]->compute_residual(scratch);
+        for (unsigned int j=0; j<residual.size(); ++j)
+          residual[j] += new_residual[j];
+
+        auto *stabilization_assembler =
+          dynamic_cast<Assemblers::AdvectionStabilizationInterface<dim>*> ((assemblers->advection_system[advection_field.field_index()][i]).get());
+
+        Assert (stabilization_assembler != nullptr,
+                ExcMessage("Entropy viscosity can only be computed for assemblers that "
+                           "are derived from the advection stabilization assembler interface."));
+
+        // Ensure no other assembler has set max_advection_prefactor or max_conductivity before,
+        // otherwise we dont know which one to use.
+        Assert (max_advection_prefactor == 0.0 && max_conductivity == 0.0,
+                ExcMessage("More than one assembler has provided scaling factors for the entropy "
+                           "viscosity stabilization, which is not supported. Make sure only one active advection "
+                           "assembler is derived from the class AdvectionStabilizationInterface."));
+
+        const std::vector<double> advection_prefactors = stabilization_assembler->advection_prefactors(scratch);
+        const std::vector<double> conductivities = stabilization_assembler->diffusion_prefactors(scratch);
+
+        max_advection_prefactor = *std::max_element(advection_prefactors.begin(),advection_prefactors.end());
+        max_conductivity = *std::max_element(conductivities.begin(),conductivities.end());
+      }
+
+    std::vector<Tensor<1,dim>> old_fluid_velocity_values(scratch.finite_element_values.n_quadrature_points);
+    std::vector<Tensor<1,dim>> old_old_fluid_velocity_values(scratch.finite_element_values.n_quadrature_points);
+    if (parameters.include_melt_transport)
+      {
+        const FEValuesExtractors::Vector ex_u_f = introspection.variable("fluid velocity").extractor_vector();
+        scratch.finite_element_values[ex_u_f].get_function_values (old_solution,old_fluid_velocity_values);
+        scratch.finite_element_values[ex_u_f].get_function_values (old_old_solution,old_old_fluid_velocity_values);
+      }
+
+    for (unsigned int q=0; q < scratch.finite_element_values.n_quadrature_points; ++q)
+      {
+        const Tensor<1,dim> velocity = (scratch.old_velocity_values[q] +
+                                        scratch.old_old_velocity_values[q]) / 2;
+        double velocity_norm = velocity.norm();
+
+        if (parameters.include_melt_transport)
+          {
+            const Tensor<1,dim> fluid_velocity = (old_fluid_velocity_values[q] +
+                                                  old_old_fluid_velocity_values[q]) / 2;
+            velocity_norm = std::max (fluid_velocity.norm(), velocity_norm);
+          }
+
+        const double strain_rate = ((scratch.old_strain_rates[q]
+                                     + scratch.old_old_strain_rates[q]) / 2).norm();
+
+        if (parameters.stabilization_alpha == 2)
+          {
+            const double field = (scratch.old_field_values[q] + scratch.old_old_field_values[q]) / 2;
+            residual[q] *= std::abs(field - average_field);
+          }
+
+        max_residual = std::max (residual[q],     max_residual);
+        max_velocity = std::max (velocity_norm
+                                 + parameters.stabilization_gamma * strain_rate * cell_diameter,
+                                 max_velocity);
+      }
+
+    // If the velocity is 0 we have to assume a sensible velocity to calculate
+    // an artificial diffusion. We choose similar to nondimensional
+    // formulations: v ~ thermal_diffusivity / length_scale, which cancels
+    // the density and specific heat from the entropy formulation. It seems
+    // surprising at first that only the conductivity remains, but remember
+    // that this actually *is* an additional artificial diffusion.
+    if (std::abs(global_u_infty) < 1e-50)
+      return parameters.stabilization_beta[advection_field.field_index()] *
+             max_conductivity / geometry_model->length_scale() *
+             cell_diameter;
+
+    const double maximum_viscosity = parameters.stabilization_beta[advection_field.field_index()] *
+                                     max_advection_prefactor *
+                                     max_velocity * cell_diameter;
+
+    if (timestep_number <= 1
+        || std::abs(global_entropy_variation) < 1e-50
+        || std::abs(global_field_variation) < 1e-50)
+      // we don't have sensible time-steps during the first two iterations
+      // and we can not divide by the entropy_variation if it is zero
+      return maximum_viscosity;
+    else
+      {
+        Assert (old_time_step > 0, ExcInternalError());
+
+        double entropy_viscosity;
+        if (parameters.stabilization_alpha == 2)
+          entropy_viscosity = (parameters.stabilization_c_R[advection_field.field_index()] *
+                               cell_diameter * cell_diameter *
+                               max_residual /
+                               global_entropy_variation);
+        else
+          entropy_viscosity = (parameters.stabilization_c_R[advection_field.field_index()] *
+                               cell_diameter * global_Omega_diameter *
+                               max_velocity * max_residual /
+                               (global_u_infty * global_field_variation));
+
+
+        return std::min (maximum_viscosity, entropy_viscosity);
+      }
+  }
+
+
+
+  template <int dim>
+  template <typename T>
+  void
+  Simulator<dim>::
+  get_artificial_viscosity (Vector<T> &viscosity_per_cell,
+                            const AdvectionField &advection_field,
+                            const bool skip_interior_cells) const
+  {
+    Assert(viscosity_per_cell.size()==triangulation.n_active_cells(), ExcInternalError());
+
+    if (advection_field.field_type == AdvectionField::compositional_field)
+      Assert(introspection.n_compositional_fields > advection_field.compositional_variable, ExcInternalError());
+
+    viscosity_per_cell = 0.0;
+
+    // discontinuous Galerkin doesn't require an artificial viscosity
+    if (advection_field.is_discontinuous(introspection))
+      return;
+
+    bool skip_EV_dirichlet_boundary_cells = false;
+
+    if (advection_field.is_temperature())
+      skip_EV_dirichlet_boundary_cells = true;
+    else
+      {
+        const std::string field_name = introspection.name_for_compositional_index(advection_field.compositional_variable);
+        if (std::find(parameters.compositional_fields_with_disabled_boundary_entropy_viscosity.begin(),
+                      parameters.compositional_fields_with_disabled_boundary_entropy_viscosity.end(),
+                      field_name)
+            !=
+            parameters.compositional_fields_with_disabled_boundary_entropy_viscosity.end())
+          skip_EV_dirichlet_boundary_cells = true;
+      }
+
+    const std::pair<double,double>
+    global_field_range = get_extrapolated_advection_field_range (advection_field);
+    const double global_entropy_variation = get_entropy_variation ((global_field_range.first +
+                                                                    global_field_range.second) / 2,
+                                                                   advection_field);
+    const double global_max_velocity = get_maximal_velocity(old_solution);
+
+    UpdateFlags update_flags = update_values |
+                               update_gradients |
+                               update_quadrature_points |
+                               update_JxW_values;
+
+    if (advection_field.is_temperature())
+      update_flags = update_flags | update_hessians;
+
+    for (unsigned int i = 0; i < assemblers->advection_system_assembler_properties.size(); ++i)
+      update_flags = update_flags | assemblers->advection_system_assembler_properties[i].needed_update_flags;
+
+    // We need the face integrals to determine if a Dirichlet boundary
+    // is conduction dominated in which case we disable stabilization
+    // to get the most accurate heat flux, or still advection
+    // dominated (e.g. a boundary with normal flow) in which case we
+    // still need stabilization.
+    const UpdateFlags face_update_flags = update_values |
+                                          update_quadrature_points |
+                                          update_normal_vectors |
+                                          update_JxW_values;
+
+    internal::Assembly::Scratch::
+    AdvectionSystem<dim> scratch (finite_element,
+                                  finite_element.base_element(advection_field.base_element(introspection)),
+                                  *mapping,
+                                  QGauss<dim>(advection_field.polynomial_degree(introspection)
+                                              +
+                                              (parameters.stokes_velocity_degree+1)/2),
+                                  QTrapezoid<dim-1> (),
+                                  update_flags,
+                                  face_update_flags,
+                                  introspection.n_compositional_fields,
+                                  advection_field);
+
+    std::vector<Tensor<1,dim>> face_old_velocity_values (scratch.face_finite_element_values->n_quadrature_points);
+    std::vector<Tensor<1,dim>> face_old_old_velocity_values (scratch.face_finite_element_values->n_quadrature_points);
+
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      {
+        // Skip cells for which we can not/do not need to compute the
+        // stabilization. We need to compute the artificial viscosity
+        // on all locally owned cells, but if we want to
+        // smooth/average it over a neighborhood of a locally owned
+        // cell, then we also need it on ghost cells; we could get it
+        // there through parallel communication, but the easier way is
+        // to simply compute it there as well
+        if (cell->is_artificial()
+            ||
+            (cell->is_ghost() &&
+             parameters.use_artificial_viscosity_smoothing == false))
+          {
+            viscosity_per_cell[cell->active_cell_index()] = numbers::signaling_nan<T>();
+            continue;
+          }
+        // Also skip all interior cells if we are asked to do so. Do not
+        // skip neighbor cells of boundary cells if smoothing is on, because
+        // the smoothing uses both the boundary cell and its neighbor.
+        else if (skip_interior_cells && !cell->at_boundary())
+          {
+            bool neighbor_at_boundary = false;
+            for (const unsigned int face_no : cell->face_indices())
+              if (cell->neighbor(face_no)->at_boundary() == true)
+                neighbor_at_boundary = true;
+
+            if (parameters.use_artificial_viscosity_smoothing == false ||
+                neighbor_at_boundary == false)
+              {
+                viscosity_per_cell[cell->active_cell_index()] = numbers::signaling_nan<T>();
+                continue;
+              }
+          }
+
+        // For fields that have physical diffusion (e.g. temperature),
+        // we can disable artificial viscosity stabilization at
+        // Dirichlet boundaries, because the boundary is conduction
+        // dominated anyway. Moreover, the residual we would compute
+        // would be erroneously large, because it does not take into
+        // account the boundary constraints. This would lead to
+        // unnecessary large diffusion in the cells that matter most
+        // for the overall energy balance of the system. However, we
+        // sometimes have Dirichlet temperature boundary conditions
+        // with prescribed non-tangential velocities, in these cases
+        // we need the stabilization, because the boundary cells can
+        // be advection dominated. Hence, only disable artificial
+        // viscosity if flow through the boundary is slow, or
+        // tangential. Also disable artificial viscosity for compositions
+        // for which this is requested (e.g. compositions with
+        // physical diffusion).
+        if (parameters.advection_stabilization_method
+            == Parameters<dim>::AdvectionStabilizationMethod::entropy_viscosity
+            && skip_EV_dirichlet_boundary_cells == true)
+          {
+            const std::set<types::boundary_id> &dirichlet_boundaries =
+              (advection_field.is_temperature() == true)
+              ?
+              boundary_temperature_manager.get_fixed_temperature_boundary_indicators()
+              :
+              boundary_composition_manager.get_fixed_composition_boundary_indicators();
+            const std::set<types::boundary_id> &tangential_velocity_boundaries =
+              boundary_velocity_manager.get_tangential_boundary_velocity_indicators();
+            const std::set<types::boundary_id> &zero_velocity_boundaries =
+              boundary_velocity_manager.get_zero_boundary_velocity_indicators();
+
+            bool cell_at_conduction_dominated_dirichlet_boundary = false;
+            for (const unsigned int face_no : cell->face_indices())
+              if (cell->at_boundary(face_no) == true &&
+                  dirichlet_boundaries.find(cell->face(face_no)->boundary_id()) != dirichlet_boundaries.end())
+                {
+                  // If the velocity is tangential or zero we can always disable stabilization, except if there is another
+                  // face at a different boundary. Therefore continue with the next face rather than break the loop.
+                  if ((tangential_velocity_boundaries.find(cell->face(face_no)->boundary_id())
+                       != tangential_velocity_boundaries.end())
+                      ||
+                      (zero_velocity_boundaries.find(cell->face(face_no)->boundary_id())
+                       != zero_velocity_boundaries.end()))
+                    {
+                      cell_at_conduction_dominated_dirichlet_boundary = true;
+                      continue;   // test next face
+                    }
+
+                  scratch.face_finite_element_values->reinit (cell, face_no);
+                  (*scratch.face_finite_element_values)[introspection.extractors.velocities].get_function_values(old_solution,
+                      face_old_velocity_values);
+                  (*scratch.face_finite_element_values)[introspection.extractors.velocities].get_function_values(old_old_solution,
+                      face_old_old_velocity_values);
+
+                  // ... check if the face is a boundary with normal flow by integrating the normal velocities
+                  // (flux through the boundary) as: int u*n ds = Sum_q u(x_q)*n(x_q) JxW(x_q)...
+                  double normal_flow = 0.0;
+                  double flow = 0.0;
+                  double area = 0.0;
+                  for (unsigned int q=0; q<scratch.face_finite_element_values->n_quadrature_points; ++q)
+                    {
+                      normal_flow += ((face_old_velocity_values[q]+face_old_old_velocity_values[q])/2.0 *
+                                      scratch.face_finite_element_values->normal_vector(q)) *
+                                     scratch.face_finite_element_values->JxW(q);
+                      flow += ((face_old_velocity_values[q]+face_old_old_velocity_values[q])/2.0).norm() *
+                              scratch.face_finite_element_values->JxW(q);
+                      area += scratch.face_finite_element_values->JxW(q);
+                    }
+
+                  // Disable stabilization for boundaries with slow flow, or tangential flow.
+                  // Break the loop in case a face is at multiple boundaries, some with flow, some without.
+                  // In those cases we can not disable stabilization.
+                  if ((std::abs(flow/area) * time_step
+                       < std::sqrt(std::numeric_limits<double>::epsilon()) * cell->diameter())
+                      ||
+                      (std::abs(normal_flow)
+                       < std::sqrt(std::numeric_limits<double>::epsilon()) * std::abs(flow)))
+                    {
+                      cell_at_conduction_dominated_dirichlet_boundary = true;
+                    }
+                  else
+                    {
+                      cell_at_conduction_dominated_dirichlet_boundary = false;
+                      break; // no need to check any other face
+                    }
+                }
+
+            if (cell_at_conduction_dominated_dirichlet_boundary)
+              {
+                // If we set the viscosity to zero, we don't need any further computation on this cell
+                viscosity_per_cell[cell->active_cell_index()] = 0.0;
+                continue;   // next cell
+              }
+          }
+
+        const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+
+        // also have the number of dofs that correspond just to the element for
+        // the system we are currently trying to assemble
+        const unsigned int advection_dofs_per_cell = scratch.phi_field.size();
+        (void)advection_dofs_per_cell;
+        Assert (advection_dofs_per_cell < scratch.finite_element_values.get_fe().dofs_per_cell, ExcInternalError());
+        Assert (scratch.grad_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
+        Assert (scratch.phi_field.size() == advection_dofs_per_cell, ExcInternalError());
+
+        const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
+
+        scratch.finite_element_values.reinit (cell);
+
+        // get all dof indices on the current cell, then extract those
+        // that correspond to the solution_field we are interested in
+        cell->get_dof_indices (scratch.local_dof_indices);
+
+        // initialize all of the scratch fields for further down
+        scratch.finite_element_values[introspection.extractors.temperature].get_function_values (old_solution,
+            scratch.old_temperature_values);
+        scratch.finite_element_values[introspection.extractors.temperature].get_function_values (old_old_solution,
+            scratch.old_old_temperature_values);
+
+        scratch.finite_element_values[introspection.extractors.velocities].get_function_symmetric_gradients (old_solution,
+            scratch.old_strain_rates);
+        scratch.finite_element_values[introspection.extractors.velocities].get_function_symmetric_gradients (old_old_solution,
+            scratch.old_old_strain_rates);
+
+        scratch.finite_element_values[introspection.extractors.pressure].get_function_values (old_solution,
+            scratch.old_pressure);
+        scratch.finite_element_values[introspection.extractors.pressure].get_function_values (old_old_solution,
+            scratch.old_old_pressure);
+
+        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+          {
+            scratch.finite_element_values[introspection.extractors.compositional_fields[c]].get_function_values(old_solution,
+                scratch.old_composition_values[c]);
+            scratch.finite_element_values[introspection.extractors.compositional_fields[c]].get_function_values(old_old_solution,
+                scratch.old_old_composition_values[c]);
+          }
+
+        scratch.finite_element_values[introspection.extractors.velocities].get_function_values (old_solution,
+            scratch.old_velocity_values);
+        scratch.finite_element_values[introspection.extractors.velocities].get_function_values (old_old_solution,
+            scratch.old_old_velocity_values);
+        scratch.finite_element_values[introspection.extractors.velocities].get_function_values(current_linearization_point,
+            scratch.current_velocity_values);
+
+        scratch.finite_element_values[introspection.extractors.pressure].get_function_gradients (old_solution,
+            scratch.old_pressure_gradients);
+        scratch.finite_element_values[introspection.extractors.pressure].get_function_gradients (old_old_solution,
+            scratch.old_old_pressure_gradients);
+
+
+        scratch.old_field_values = (advection_field.is_temperature()
+                                    ?
+                                    scratch.old_temperature_values
+                                    :
+                                    scratch.old_composition_values[advection_field.compositional_variable]);
+        scratch.old_old_field_values = (advection_field.is_temperature()
+                                        ?
+                                        scratch.old_old_temperature_values
+                                        :
+                                        scratch.old_old_composition_values[advection_field.compositional_variable]);
+
+        scratch.finite_element_values[solution_field].get_function_gradients (old_solution,
+                                                                              scratch.old_field_grads);
+        scratch.finite_element_values[solution_field].get_function_gradients (old_old_solution,
+                                                                              scratch.old_old_field_grads);
+
+        if (update_flags & update_hessians)
+          {
+            scratch.finite_element_values[solution_field].get_function_laplacians (old_solution,
+                                                                                   scratch.old_field_laplacians);
+            scratch.finite_element_values[solution_field].get_function_laplacians (old_old_solution,
+                                                                                   scratch.old_old_field_laplacians);
+          }
+
+        if (parameters.include_melt_transport && melt_handler->is_porosity(advection_field))
+          {
+            scratch.finite_element_values[introspection.extractors.velocities].get_function_divergences (current_linearization_point,
+                scratch.current_velocity_divergences);
+          }
+
+        /**
+         * Explicit material model inputs and outputs.
+         */
+        for (unsigned int q=0; q<n_q_points; ++q)
+          {
+            scratch.material_model_inputs.temperature[q] = (scratch.old_temperature_values[q] + scratch.old_old_temperature_values[q]) / 2;
+            scratch.material_model_inputs.position[q] = scratch.finite_element_values.quadrature_point(q);
+            scratch.material_model_inputs.pressure[q] = (scratch.old_pressure[q] + scratch.old_old_pressure[q]) / 2;
+            scratch.material_model_inputs.velocity[q] = (scratch.old_velocity_values[q] + scratch.old_old_velocity_values[q]) / 2;
+            scratch.material_model_inputs.pressure_gradient[q] = (scratch.old_pressure_gradients[q] + scratch.old_old_pressure_gradients[q]) / 2;
+
+            for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+              scratch.material_model_inputs.composition[q][c] = (scratch.old_composition_values[c][q] + scratch.old_old_composition_values[c][q]) / 2;
+            scratch.material_model_inputs.strain_rate[q] = (scratch.old_strain_rates[q] + scratch.old_old_strain_rates[q]) / 2;
+          }
+        scratch.material_model_inputs.current_cell = cell;
+
+        for (unsigned int i=0; i<assemblers->advection_system[advection_field.field_index()].size(); ++i)
+          assemblers->advection_system[advection_field.field_index()][i]->create_additional_material_model_outputs(scratch.material_model_outputs);
+        heating_model_manager.create_additional_material_model_inputs_and_outputs(scratch.material_model_inputs,
+                                                                                  scratch.material_model_outputs);
+
+        material_model->fill_additional_material_model_inputs(scratch.material_model_inputs,
+                                                              solution,
+                                                              scratch.finite_element_values,
+                                                              introspection);
+        material_model->evaluate(scratch.material_model_inputs,scratch.material_model_outputs);
+        heating_model_manager.evaluate(scratch.material_model_inputs,scratch.material_model_outputs,scratch.heating_model_outputs);
+
+        if (parameters.formulation_temperature_equation
+            == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+          {
+            // Overwrite the density by the reference density coming from the
+            // adiabatic conditions as required by the formulation
+            for (unsigned int q=0; q<n_q_points; ++q)
+              scratch.material_model_outputs.densities[q] = adiabatic_conditions->density(scratch.material_model_inputs.position[q]);
+          }
+        else if (parameters.formulation_temperature_equation
+                 == Parameters<dim>::Formulation::TemperatureEquation::real_density)
+          {
+            // use real density
+          }
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        MaterialModel::MaterialAveraging::average (parameters.material_averaging,
+                                                   cell,
+                                                   scratch.finite_element_values.get_quadrature(),
+                                                   scratch.finite_element_values.get_mapping(),
+                                                   scratch.material_model_inputs.requested_properties,
+                                                   scratch.material_model_outputs);
+
+        if (parameters.advection_stabilization_method == Parameters<dim>::AdvectionStabilizationMethod::entropy_viscosity)
+          {
+            viscosity_per_cell[cell->active_cell_index()] = compute_viscosity(scratch,
+                                                                              global_max_velocity,
+                                                                              global_field_range.second - global_field_range.first,
+                                                                              0.5 * (global_field_range.second + global_field_range.first),
+                                                                              global_entropy_variation,
+                                                                              cell->diameter(),
+                                                                              advection_field);
+          }
+        else if (parameters.advection_stabilization_method == Parameters<dim>::AdvectionStabilizationMethod::supg)
+          {
+            double norm_of_advection_term = 0.0;
+            double max_conductivity_on_cell = 0.0;
+
+            {
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  if (advection_field.is_temperature())
+                    {
+                      norm_of_advection_term =
+                        std::max(scratch.current_velocity_values[q].norm()*
+                                 (scratch.material_model_outputs.densities[q] *
+                                  scratch.material_model_outputs.specific_heat[q] +
+                                  scratch.heating_model_outputs.lhs_latent_heat_terms[q]),
+                                 norm_of_advection_term);
+
+                      max_conductivity_on_cell =
+                        std::max(scratch.material_model_outputs.thermal_conductivities[q],max_conductivity_on_cell);
+                    }
+                  else
+                    {
+                      norm_of_advection_term =
+                        std::max(scratch.current_velocity_values[q].norm(),norm_of_advection_term);
+
+                      max_conductivity_on_cell = 0.0;
+                    }
+                }
+            }
+
+            const double fe_order = advection_field.polynomial_degree(introspection);
+            const double h = cell->diameter();
+            const double eps = max_conductivity_on_cell;
+
+            // SUPG parameter design from "On Discontinuity-Capturing Methods
+            // for Convection-Diffusion Equations" by Volker John and Petr
+            // Knobloch. Also see deal.II step-63:
+            // delta_k = h / (2 \|u\| k) * (coth(Pe) - 1/Pe)
+            // Pe = \| u \| h/(2 p eps)
+            const double peclet_times_eps = norm_of_advection_term * h / (2.0 * fe_order);
+
+            // Instead of Pe < 1, we check Pe*eps < eps as eps can be ==0:
+            if (peclet_times_eps==0.0 || peclet_times_eps < eps)
+              {
+                // Diffusion dominant case, no stabilization needed:
+                viscosity_per_cell[cell->active_cell_index()] = 0.0;
+              }
+            else
+              {
+                // To avoid a division by zero, increase eps slightly. The actual value is not
+                // important, as long as the result is still a valid number. Note that this
+                // is only important if \|u\| and eps are zero.
+                const double peclet = peclet_times_eps / (eps + 1e-100);
+                const double coth_of_peclet = (1.0 + exp(-2.0*peclet)) / (1.0 - exp(-2.0*peclet));
+                const double delta = h/(2.0*norm_of_advection_term*fe_order) * (coth_of_peclet - 1.0/peclet);
+                viscosity_per_cell[cell->active_cell_index()] = delta;
+              }
+            Assert (viscosity_per_cell[cell->active_cell_index()] >= 0, ExcMessage ("tau for SUPG needs to be a nonnegative constant."));
+          }
+        else
+          AssertThrow(false, ExcNotImplemented());
+      }
+
+    // if set to true, the maximum of the artificial viscosity in the cell as well
+    // as the neighbors of the cell is computed and used instead
+    if (parameters.use_artificial_viscosity_smoothing  == true)
+      {
+        Vector<T> viscosity_per_cell_temp;
+        viscosity_per_cell_temp.reinit(triangulation.n_active_cells());
+
+        viscosity_per_cell_temp = viscosity_per_cell;
+        for (const auto &cell : dof_handler.active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              if (skip_interior_cells && !cell->at_boundary())
+                continue;
+
+              for (const unsigned int face_no : cell->face_indices())
+                if (cell->at_boundary(face_no) == false)
+                  {
+                    if (cell->neighbor(face_no)->is_active())
+                      viscosity_per_cell[cell->active_cell_index()] = std::max(viscosity_per_cell[cell->active_cell_index()],
+                                                                               viscosity_per_cell_temp[cell->neighbor(face_no)->active_cell_index()]);
+                    else
+                      for (unsigned int l=0; l<cell->neighbor(face_no)->n_children(); ++l)
+                        if (cell->neighbor(face_no)->child(l)->is_active())
+                          viscosity_per_cell[cell->active_cell_index()] = std::max(viscosity_per_cell[cell->active_cell_index()],
+                                                                                   viscosity_per_cell_temp[cell->neighbor(face_no)->child(l)->active_cell_index()]);
+                  }
+            }
+      }
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template void Simulator<dim>::get_artificial_viscosity (Vector<double> &viscosity_per_cell,  \
+                                                          const AdvectionField &advection_field, \
+                                                          const bool skip_interior_cells) const; \
+  template void Simulator<dim>::get_artificial_viscosity (Vector<float> &viscosity_per_cell,  \
+                                                          const AdvectionField &advection_field, \
+                                                          const bool skip_interior_cells) const;
+
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/helper_functions.cc.bak b/source/simulator/helper_functions.cc.bak
new file mode 100644
index 00000000000..bd84cabf160
--- /dev/null
+++ b/source/simulator/helper_functions.cc.bak
@@ -0,0 +1,2521 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/melt.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/newton.h>
+#include <aspect/global.h>
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/heating_model/adiabatic_heating.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/particle/generator/interface.h>
+#include <aspect/particle/integrator/interface.h>
+#include <aspect/particle/interpolator/interface.h>
+#include <aspect/particle/property/interface.h>
+#include <aspect/postprocess/visualization.h>
+
+#include <deal.II/base/index_set.h>
+#include <deal.II/base/conditional_ostream.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/lac/block_sparsity_pattern.h>
+#include <deal.II/grid/grid_tools.h>
+
+#include <deal.II/dofs/dof_renumbering.h>
+#include <deal.II/dofs/dof_accessor.h>
+#include <deal.II/dofs/dof_tools.h>
+
+#include <deal.II/fe/fe_q.h>
+#include <deal.II/fe/fe_dgq.h>
+#include <deal.II/fe/fe_dgp.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <deal.II/sundials/arkode.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+
+namespace aspect
+{
+
+  template <int dim>
+  Simulator<dim>::AdvectionField::
+  AdvectionField (const FieldType field_type,
+                  const unsigned int compositional_variable)
+    :
+    field_type (field_type),
+    compositional_variable (compositional_variable)
+  {
+    if (field_type == temperature_field)
+      Assert (compositional_variable == numbers::invalid_unsigned_int,
+              ExcMessage ("You can't specify a compositional variable if you "
+                          "have in fact selected the temperature."));
+  }
+
+
+
+  template <int dim>
+  typename Simulator<dim>::AdvectionField
+  Simulator<dim>::AdvectionField::temperature ()
+  {
+    return AdvectionField(temperature_field);
+  }
+
+
+
+  template <int dim>
+  typename Simulator<dim>::AdvectionField
+  Simulator<dim>::AdvectionField::composition (const unsigned int compositional_variable)
+  {
+    return AdvectionField(compositional_field,
+                          compositional_variable);
+  }
+
+
+  template <int dim>
+  bool
+  Simulator<dim>::AdvectionField::is_temperature() const
+  {
+    return (field_type == temperature_field);
+  }
+
+  template <int dim>
+  bool
+  Simulator<dim>::AdvectionField::is_discontinuous(const Introspection<dim> &introspection) const
+  {
+    if (field_type == temperature_field)
+      return introspection.use_discontinuous_temperature_discretization;
+    else if (field_type == compositional_field)
+      return introspection.use_discontinuous_composition_discretization[compositional_variable];
+
+    Assert (false, ExcInternalError());
+    return false;
+  }
+
+  template <int dim>
+  typename Parameters<dim>::AdvectionFieldMethod::Kind
+  Simulator<dim>::AdvectionField::advection_method(const Introspection<dim> &introspection) const
+  {
+    if (field_type == temperature_field)
+      return introspection.temperature_method;
+    else if (field_type == compositional_field)
+      return introspection.compositional_field_methods[compositional_variable];
+
+    Assert (false, ExcInternalError());
+    return Parameters<dim>::AdvectionFieldMethod::fem_field;
+  }
+
+  template <int dim>
+  unsigned int
+  Simulator<dim>::AdvectionField::block_index(const Introspection<dim> &introspection) const
+  {
+    if (this->is_temperature())
+      return introspection.block_indices.temperature;
+    else
+      return introspection.block_indices.compositional_fields[compositional_variable];
+  }
+
+  template <int dim>
+  unsigned int
+  Simulator<dim>::AdvectionField::sparsity_pattern_block_index(const Introspection<dim> &introspection) const
+  {
+    if (this->is_temperature())
+      return introspection.block_indices.temperature;
+    else
+      return introspection.block_indices.compositional_field_sparsity_pattern[compositional_variable];
+  }
+
+  template <int dim>
+  unsigned int
+  Simulator<dim>::AdvectionField::component_index(const Introspection<dim> &introspection) const
+  {
+    if (this->is_temperature())
+      return introspection.component_indices.temperature;
+    else
+      return introspection.component_indices.compositional_fields[compositional_variable];
+  }
+
+  template <int dim>
+  unsigned int
+  Simulator<dim>::AdvectionField::field_index() const
+  {
+    if (this->is_temperature())
+      return 0;
+    else
+      return compositional_variable + 1;
+  }
+
+  template <int dim>
+  unsigned int
+  Simulator<dim>::AdvectionField::base_element(const Introspection<dim> &introspection) const
+  {
+    if (this->is_temperature())
+      return introspection.base_elements.temperature;
+    else
+      return introspection.base_elements.compositional_fields[compositional_variable];
+  }
+
+  template <int dim>
+  FEValuesExtractors::Scalar
+  Simulator<dim>::AdvectionField::scalar_extractor(const Introspection<dim> &introspection) const
+  {
+    if (this->is_temperature())
+      return introspection.extractors.temperature;
+    else
+      {
+        Assert(compositional_variable < introspection.n_compositional_fields,
+               ExcMessage("Invalid AdvectionField."));
+        return introspection.extractors.compositional_fields[compositional_variable];
+      }
+  }
+
+  template <int dim>
+  unsigned int
+  Simulator<dim>::AdvectionField::polynomial_degree(const Introspection<dim> &introspection) const
+  {
+    if (this->is_temperature())
+      return introspection.polynomial_degree.temperature;
+    else
+      return introspection.polynomial_degree.compositional_fields;
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::write_plugin_graph (std::ostream &out) const
+  {
+    // write the preamble
+    out << "digraph Plugins\n"
+        "{\n"
+        "  splines=line;\n"
+        "  splines=true;\n"
+        "  overlap=false;\n"
+        "  edge [fontname=\"FreeSans\",\n"
+        "        fontsize=\"10\",\n"
+        "        labelfontname=\"FreeSans\",\n"
+        "        labelfontsize=\"10\",\n"
+        "        color=\"black\",\n"
+        "        style=\"solid\"];\n"
+        "  node [fontname=\"FreeSans\",\n"
+        "        fontsize=\"10\",\n"
+        "        shape=\"rectangle\",\n"
+        "        height=0.2,\n"
+        "        width=0.4,\n"
+        "        color=\"black\",\n"
+        "        fillcolor=\"white\",\n"
+        "        style=\"filled\"];\n"
+        "  layout=neato;\n"
+        "\n";
+
+    // then also write nodes for the Simulator and SimulatorAccess classes,
+    // and an arrow from the former to the latter to indicate flow of
+    // information
+    out << "  Simulator [height=1.5,width=2,shape=\"octagon\",fillcolor=\"yellow\"];\n";
+    out << "  SimulatorAccess [height=1.2,width=1.2,shape=\"rect\",fillcolor=\"yellow\"];\n";
+    out << "  Simulator -> SimulatorAccess [len=1, weight=100];\n";
+
+    // then go through all plugin systems and output everything we have
+    AdiabaticConditions::write_plugin_graph<dim>(out);
+    BoundaryComposition::Manager<dim>::write_plugin_graph(out);
+    BoundaryFluidPressure::write_plugin_graph<dim>(out);
+    BoundaryTemperature::Manager<dim>::write_plugin_graph(out);
+    BoundaryTraction::Manager<dim>::write_plugin_graph(out);
+    BoundaryVelocity::Manager<dim>::write_plugin_graph(out);
+    InitialTopographyModel::write_plugin_graph<dim>(out);
+    GeometryModel::write_plugin_graph<dim>(out);
+    GravityModel::write_plugin_graph<dim>(out);
+    HeatingModel::Manager<dim>::write_plugin_graph(out);
+    InitialComposition::Manager<dim>::write_plugin_graph(out);
+    InitialTemperature::Manager<dim>::write_plugin_graph(out);
+    MaterialModel::write_plugin_graph<dim>(out);
+    MeshRefinement::Manager<dim>::write_plugin_graph(out);
+    Particle::Generator::write_plugin_graph<dim>(out);
+    Particle::Integrator::write_plugin_graph<dim>(out);
+    Particle::Interpolator::write_plugin_graph<dim>(out);
+    Particle::Property::Manager<dim>::write_plugin_graph(out);
+    Postprocess::Manager<dim>::write_plugin_graph(out);
+    Postprocess::Visualization<dim>::write_plugin_graph(out);
+    PrescribedStokesSolution::write_plugin_graph<dim>(out);
+    TerminationCriteria::Manager<dim>::write_plugin_graph(out);
+
+    // end the graph
+    out << '}'
+        << std::endl;
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::output_statistics()
+  {
+    // Only write the statistics file from processor zero
+    if (Utilities::MPI::this_mpi_process(mpi_communicator)!=0)
+      return;
+
+    // Formatting the table we're about to output and writing the
+    // actual file may take some time, so do it on a separate
+    // thread. We do this using a lambda function that takes
+    // a copy of the statistics object to make sure that whatever
+    // we do to the 'real' statistics object at the time of
+    // writing data doesn't affect what we write.
+    //
+    // Before we can start working on a new thread, we need to
+    // make sure that the previous thread is done or they'll
+    // step on each other's feet.
+    if (output_statistics_thread.joinable())
+      output_statistics_thread.join();
+
+    // Write data in the background through a lambda function.
+    // This happening in the background means that we have
+    // to create a copy of the statistics table, since whatever is
+    // running in the foreground may continue to add entries to the
+    // statistics table at the same time.
+    output_statistics_thread = std::thread (
+                                 [statistics_copy_ptr = std::make_unique<TableHandler>(statistics),this]()
+    {
+      // First write everything into a string in memory
+      std::ostringstream stream;
+      statistics_copy_ptr->write_text (stream,
+                                       TableHandler::table_with_separate_column_description);
+      stream.flush();
+
+      const std::string statistics_contents = stream.str();
+
+      // Next find out whether we need to write everything into
+      // the statistics file, or whether it is enough to just write
+      // the last few bytes that were added since we wrote to that
+      // file again. The way we do that is by checking whether the
+      // first few bytes of the string we just created match what we
+      // had previously written. One might think that they always should,
+      // but the statistics object automatically sizes the column widths
+      // of its output to match what is being written, and so if a later
+      // entry requires more width, then even the first columns are
+      // changed -- in that case, we will have to write everything,
+      // not just append one line.
+      const bool write_everything
+        = ( // We may have never written anything. More precisely, this
+            // case happens if the statistics_last_write_size is at the
+            // value initialized by the Simulator::Simulator()
+            // constructor, and this can happen in two situations:
+            // (i) At the end of the first time step; and (ii) upon restart
+            // since the variable we query here is not serialized. It is clear
+            // that in both situations, we want to write the
+            // entire contents of the statistics object. For the second
+            // case, this is also appropriate since someone may have
+            // previously restarted from a checkpoint, run a couple of
+            // time steps that have added to the statistics file, but then
+            // aborted the run again; a later restart from the same
+            // checkpoint then requires overwriting the statistics file
+            // on disk with what we have when this function is called for
+            // the first time after the restart. The same situation
+            // happens if the simulation kept running for some time after
+            // a checkpoint, but is resumed from that checkpoint (i.e.,
+            // at an earlier time step than when the statistics file was
+            // written to last). In these situations, we effectively want
+            // to "truncate" the file to the state stored in the checkpoint,
+            // and we do that by just overwriting the entire file.
+            (statistics_last_write_size == 0)
+            ||
+            // Or the size of the statistics file may have
+            // shrunk mysteriously -- this shouldn't happen
+            // but if it did we'd get into trouble with the
+            // .substr() call in the next check.
+            (statistics_last_write_size > statistics_contents.size())
+            ||
+            // Or the hash of what we wrote last time doesn't match
+            // the hash of the first part of what we want to write
+            (statistics_last_hash
+             !=
+             std::hash<std::string>()(statistics_contents.substr(0, statistics_last_write_size))) );
+
+      const std::string stat_file_name = parameters.output_directory + "statistics";
+      if (write_everything)
+        {
+          // Write what we have into a tmp file, then move that into
+          // place
+          const std::string tmp_file_name = stat_file_name + ".tmp";
+          {
+            std::ofstream tmp_file (tmp_file_name);
+            tmp_file << statistics_contents;
+          }
+          std::rename(tmp_file_name.c_str(), stat_file_name.c_str());
+        }
+      else
+        {
+          // If we don't have to write everything, then the first part of what
+          // we want to write matches what's already on disk. In that case,
+          // we just have to append what's new.
+          std::ofstream stat_file (stat_file_name, std::ios::app);
+          stat_file << statistics_contents.substr(statistics_last_write_size, std::string::npos);
+        }
+
+      // Now update the size and hash of what we just wrote so that
+      // we can compare against it next time we get here. Note that we do
+      // not need to guard access to these variables with a mutex because
+      // this is the only function that touches the variables, and
+      // this function runs only once at a time (on a different
+      // thread, but it's not started a second time while the previous
+      // run hasn't finished).
+      statistics_last_write_size = statistics_contents.size();
+      statistics_last_hash       = std::hash<std::string>()(statistics_contents);
+    });
+  }
+
+
+
+  template <int dim>
+  double
+  Simulator<dim>::
+  compute_pressure_scaling_factor() const
+  {
+    // Determine how to treat the pressure. We have to scale it for the solver
+    // to make velocities and pressures of roughly the same (numerical) size,
+    // and we may have to fix up the right hand side vector before solving for
+    // compressible models if there are no in-/outflow boundaries
+    //
+    // We do this by scaling the divergence equation by a constant factor that
+    // is equal to a reference viscosity divided by a length scale.
+    // We get the latter from the geometry model, and the former
+    // by looping over all cells and averaging the "order of magnitude"
+    // of the viscosity. The order of magnitude is the logarithm of
+    // the viscosity, so
+    //
+    //   \eta_{ref} = exp ( 1/N * (log(eta_1) + log(eta_2) + ... + log(eta_N))
+    //
+    // where the \eta_i are typical viscosities on the cells of the mesh.
+    // For this, we just take the viscosity at the cell center.
+    //
+    // The formula above computes the exponential of the average of the
+    // logarithms. It is easy to verify that this is equivalent to
+    // computing the *geometric* mean of the viscosities, but the
+    // formula above is numerically stable.
+
+    // Do return NaN if we do not solve the Stokes equation. Technically, there is
+    // no harm in computing the factor anyway, but the viscosity has to be positive
+    // for this function to work, and some models may set viscosity to 0 if not solving
+    // the Stokes equation. Returning NaN guarantees this value cannot be used.
+    if (parameters.nonlinear_solver == NonlinearSolver::no_Advection_no_Stokes ||
+        parameters.nonlinear_solver == NonlinearSolver::single_Advection_no_Stokes)
+      return numbers::signaling_nan<double>();
+
+    const QMidpoint<dim> quadrature_formula;
+
+    FEValues<dim> fe_values (*mapping,
+                             finite_element,
+                             quadrature_formula,
+                             update_values |
+                             update_gradients |
+                             update_quadrature_points |
+                             update_JxW_values);
+
+    const unsigned int n_q_points = quadrature_formula.size();
+
+    double local_integrated_viscosity_logarithm = 0.;
+    double local_volume = 0.;
+
+    MaterialModel::MaterialModelInputs<dim> in(n_q_points,
+                                               introspection.n_compositional_fields);
+    MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
+                                                 introspection.n_compositional_fields);
+
+    // We do not need to compute anything but the viscosity
+    in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          in.reinit(fe_values,
+                    cell,
+                    introspection,
+                    solution);
+
+          // We do not call the cell-wise average function of the
+          // material model, because we average globally below
+          material_model->evaluate(in, out);
+
+          // Evaluate viscosity at the mid-point of each cell and
+          // calculate the volume weighted harmonic average of all cells
+          for (unsigned int q=0; q<n_q_points; ++q)
+            {
+              Assert(out.viscosities[q] > 0,
+                     ExcMessage ("The viscosity needs to be a "
+                                 "positive quantity."));
+
+              const double JxW = fe_values.JxW(q);
+              local_integrated_viscosity_logarithm += std::log(out.viscosities[q]) * JxW;
+              local_volume += JxW;
+            }
+        }
+
+    // vector for packing local values before MPI summing them
+    double values[2] = {local_integrated_viscosity_logarithm, local_volume};
+
+    Utilities::MPI::sum(values, mpi_communicator, values);
+
+    const double reference_viscosity = std::exp(values[0]/values[1]);
+    const double length_scale = geometry_model->length_scale();
+
+    // Allow the user to inspect and/or overwrite our result:
+    const double result = reference_viscosity / length_scale;
+    if (boost::optional<double> value = signals.modify_pressure_scaling(result, reference_viscosity, length_scale))
+      return *value;
+    else
+      return result;
+  }
+
+
+
+  template <int dim>
+  double
+  Simulator<dim>::
+  get_maximal_velocity (const LinearAlgebra::BlockVector &solution) const
+  {
+    // use a quadrature formula that has one point at
+    // the location of each degree of freedom in the
+    // velocity element
+    const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
+                                             parameters.stokes_velocity_degree);
+    const unsigned int n_q_points = quadrature_formula.size();
+
+
+    FEValues<dim> fe_values (*mapping, finite_element, quadrature_formula, update_values);
+    std::vector<Tensor<1,dim>> velocity_values(n_q_points);
+
+    double max_local_velocity = 0;
+
+    // loop over all locally owned cells and evaluate the velocities at each
+    // quadrature point (i.e. each node). keep a running tally of the largest
+    // such velocity
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          fe_values[introspection.extractors.velocities].get_function_values (solution,
+                                                                              velocity_values);
+
+          for (unsigned int q=0; q<n_q_points; ++q)
+            max_local_velocity = std::max (max_local_velocity,
+                                           velocity_values[q].norm());
+        }
+
+    // return the largest value over all processors
+    return Utilities::MPI::max (max_local_velocity, mpi_communicator);
+  }
+
+
+
+  template <int dim>
+  bool Simulator<dim>::maybe_do_initial_refinement (const unsigned int max_refinement_level)
+  {
+    if (pre_refinement_step < parameters.initial_adaptive_refinement)
+      {
+        if (parameters.timing_output_frequency == 0)
+          {
+            computing_timer.print_summary ();
+            pcout << "-- Total wallclock time elapsed including restarts: "
+                  << round(wall_timer.wall_time()+total_walltime_until_last_snapshot)
+                  << 's' << std::endl;
+          }
+
+        output_statistics();
+
+        // we only want to do the postprocessing here if it is not already done in
+        // the nonlinear iteration scheme, which is the case if we run postprocessors
+        // on all nonlinear iterations
+        if (parameters.run_postprocessors_on_initial_refinement && (!parameters.run_postprocessors_on_nonlinear_iterations))
+          postprocess ();
+
+        refine_mesh (max_refinement_level);
+        ++pre_refinement_step;
+        return true;
+      }
+    else
+      {
+        // invalidate the value of pre_refinement_step since it will no longer be used from here on
+        pre_refinement_step = std::numeric_limits<unsigned int>::max();
+        return false;
+      }
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::exchange_refinement_flags ()
+  {
+    // Communicate refinement flags on ghost cells from the owner of the
+    // cell. This is necessary to get consistent refinement, as mesh
+    // smoothing would undo some of the requested coarsening/refinement.
+
+    auto pack
+    = [] (const typename DoFHandler<dim>::active_cell_iterator &cell) -> std::uint8_t
+    {
+      if (cell->refine_flag_set())
+        return 1;
+      if (cell->coarsen_flag_set())
+        return 2;
+      return 0;
+    };
+    auto unpack
+    = [] (const typename DoFHandler<dim>::active_cell_iterator &cell, const std::uint8_t &flag) -> void
+    {
+      cell->clear_coarsen_flag();
+      cell->clear_refine_flag();
+      if (flag==1)
+        cell->set_refine_flag();
+      else if (flag==2)
+        cell->set_coarsen_flag();
+    };
+
+    GridTools::exchange_cell_data_to_ghosts<std::uint8_t, DoFHandler<dim>>
+    (dof_handler, pack, unpack);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::maybe_refine_mesh (const double new_time_step,
+                                          unsigned int &max_refinement_level)
+  {
+    /*
+     * see if this is an additional refinement cycle. An additional refinement
+     * cycle differs from a regular, because the maximal refinement level allowed
+     * is increased by one from this time on.
+     */
+    if ((parameters.additional_refinement_times.size() > 0)
+        &&
+        (parameters.additional_refinement_times.front () < time+new_time_step))
+      {
+        // loop over as many times as this is necessary
+        while ((parameters.additional_refinement_times.size() > 0)
+               &&
+               (parameters.additional_refinement_times.front () < time+new_time_step))
+          {
+            ++max_refinement_level;
+            refine_mesh (max_refinement_level);
+
+            parameters.additional_refinement_times
+            .erase (parameters.additional_refinement_times.begin());
+          }
+      }
+    // see if this is a time step where regular refinement is requested
+    else if ((timestep_number > 0
+              &&
+              parameters.adaptive_refinement_interval > 0
+              &&
+              timestep_number % parameters.adaptive_refinement_interval == 0)
+             ||
+             (timestep_number == 0 && parameters.adaptive_refinement_interval == 1)
+            )
+      {
+        refine_mesh (max_refinement_level);
+      }
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::maybe_write_timing_output () const
+  {
+    bool write_timing_output = false;
+    if (parameters.timing_output_frequency <= 1)
+      write_timing_output = true;
+    else if ((timestep_number > 0) &&
+             (timestep_number % parameters.timing_output_frequency == 0))
+      write_timing_output = true;
+
+    // if requested output a summary of the current timing information
+    if (write_timing_output)
+      {
+        computing_timer.print_summary ();
+        pcout << "-- Total wallclock time elapsed including restarts: "
+              << round(wall_timer.wall_time()+total_walltime_until_last_snapshot)
+              << 's' << std::endl;
+      }
+  }
+
+
+
+  template <int dim>
+  bool Simulator<dim>::maybe_write_checkpoint (const time_t last_checkpoint_time,
+                                               const bool force_writing_checkpoint)
+  {
+    // Do a checkpoint if this is the end of simulation,
+    // and the termination criteria say to checkpoint at the end.
+    bool write_checkpoint = force_writing_checkpoint;
+
+    // If we base checkpoint frequency on timing, measure the time at process 0
+    // This prevents race conditions where some processes will checkpoint and others won't
+    if (!write_checkpoint && parameters.checkpoint_time_secs > 0)
+      {
+        int global_do_checkpoint = ((std::time(nullptr)-last_checkpoint_time) >=
+                                    parameters.checkpoint_time_secs);
+        const int ierr = MPI_Bcast(&global_do_checkpoint, 1, MPI_INT, 0, mpi_communicator);
+        AssertThrowMPI(ierr);
+
+        if (global_do_checkpoint == 1)
+          write_checkpoint = true;
+      }
+
+    // If we base checkpoint frequency on steps, see if it's time for another checkpoint
+    if (!write_checkpoint &&
+        (parameters.checkpoint_time_secs == 0) &&
+        (parameters.checkpoint_steps > 0) &&
+        (timestep_number % parameters.checkpoint_steps == 0))
+      write_checkpoint = true;
+
+    // Do a checkpoint if indicated by checkpoint parameters
+    if (write_checkpoint)
+      {
+        create_snapshot();
+        // matrices will be regenerated after a resume, so do that here too
+        // to be consistent. otherwise we would get different results
+        // for a restarted computation than for one that ran straight
+        // through
+        rebuild_stokes_matrix =
+          rebuild_stokes_preconditioner = true;
+      }
+    return write_checkpoint;
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::advance_time (const double step_size)
+  {
+    old_time_step = time_step;
+    time_step = step_size;
+    time += time_step;
+    ++timestep_number;
+
+    // prepare for the next time step by shifting solution vectors
+    // by one time step. In timestep 0 (just increased in the
+    // line above) initialize both old_solution
+    // and old_old_solution with the currently computed solution.
+    if (timestep_number == 1)
+      {
+        old_old_solution      = solution;
+        old_solution          = solution;
+      }
+    else
+      {
+        old_old_solution      = old_solution;
+        old_solution          = solution;
+      }
+  }
+
+
+
+  template <int dim>
+  std::pair<double,double>
+  Simulator<dim>::
+  get_extrapolated_advection_field_range (const AdvectionField &advection_field) const
+  {
+    const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
+                                             advection_field.polynomial_degree(introspection));
+
+    const unsigned int n_q_points = quadrature_formula.size();
+
+    const FEValuesExtractors::Scalar field = advection_field.scalar_extractor(introspection);
+
+    FEValues<dim> fe_values (*mapping, finite_element, quadrature_formula,
+                             update_values);
+    std::vector<double> old_field_values(n_q_points);
+    std::vector<double> old_old_field_values(n_q_points);
+
+    // This presets the minimum with a bigger
+    // and the maximum with a smaller number
+    // than one that is going to appear. Will
+    // be overwritten in the cell loop or in
+    // the communication step at the
+    // latest.
+    double min_local_field = std::numeric_limits<double>::max(),
+           max_local_field = std::numeric_limits<double>::lowest();
+
+    if (timestep_number > 1)
+      {
+        for (const auto &cell : dof_handler.active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              fe_values.reinit (cell);
+              fe_values[field].get_function_values (old_solution,
+                                                    old_field_values);
+              fe_values[field].get_function_values (old_old_solution,
+                                                    old_old_field_values);
+
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  const double extrapolated_field =
+                    (1. + time_step/old_time_step) * old_field_values[q]-
+                    time_step/old_time_step * old_old_field_values[q];
+
+                  min_local_field = std::min (min_local_field,
+                                              extrapolated_field);
+                  max_local_field = std::max (max_local_field,
+                                              extrapolated_field);
+                }
+            }
+      }
+    else
+      {
+        for (const auto &cell : dof_handler.active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              fe_values.reinit (cell);
+              fe_values[field].get_function_values (old_solution,
+                                                    old_field_values);
+
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  const double extrapolated_field = old_field_values[q];
+
+                  min_local_field = std::min (min_local_field,
+                                              extrapolated_field);
+                  max_local_field = std::max (max_local_field,
+                                              extrapolated_field);
+                }
+            }
+      }
+
+    return std::make_pair(Utilities::MPI::min (min_local_field,
+                                               mpi_communicator),
+                          Utilities::MPI::max (max_local_field,
+                                               mpi_communicator));
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::interpolate_onto_velocity_system(const TensorFunction<1,dim> &func,
+                                                        LinearAlgebra::Vector &vec)
+  {
+    Assert(introspection.block_indices.velocities == 0, ExcNotImplemented());
+
+    const std::vector<Point<dim>> mesh_support_points = finite_element.base_element(introspection.base_elements.velocities).get_unit_support_points();
+    const unsigned int n_velocity_dofs_per_cell = finite_element.base_element(introspection.base_elements.velocities).dofs_per_cell;
+
+    FEValues<dim> mesh_points (*mapping, finite_element, mesh_support_points, update_quadrature_points);
+    std::vector<types::global_dof_index> cell_dof_indices (finite_element.dofs_per_cell);
+
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          mesh_points.reinit(cell);
+          cell->get_dof_indices (cell_dof_indices);
+          for (unsigned int j=0; j<n_velocity_dofs_per_cell; ++j)
+            for (unsigned int dir=0; dir<dim; ++dir)
+              {
+                const unsigned int support_point_index
+                  = finite_element.component_to_system_index(/*velocity component=*/ introspection.component_indices.velocities[dir],
+                                                                                     /*dof index within component=*/ j);
+                vec[cell_dof_indices[support_point_index]] = func.value(mesh_points.quadrature_point(j))[dir];
+              }
+        }
+
+    vec.compress(VectorOperation::insert);
+
+    AffineConstraints<double> hanging_node_constraints(introspection.index_sets.system_relevant_set);
+    DoFTools::make_hanging_node_constraints(dof_handler, hanging_node_constraints);
+    hanging_node_constraints.close();
+
+    // Create a view of all constraints that only pertains to the
+    // Stokes subset of degrees of freedom. We can then use this later
+    // to call constraints.distribute(), constraints.set_zero(), etc.,
+    // on those block vectors that only have the Stokes components in
+    // them.
+    //
+    // For the moment, assume that the Stokes degrees are first in the
+    // overall vector, so that they form a contiguous range starting
+    // at zero. The assertion checks this, but this could easily be
+    // generalized if the Stokes block were not starting at zero.
+#if DEAL_II_VERSION_GTE(9,6,0)
+    Assert (introspection.block_indices.velocities == 0,
+            ExcNotImplemented());
+    if (parameters.use_direct_stokes_solver == false)
+      Assert (introspection.block_indices.pressure == 1,
+              ExcNotImplemented());
+
+    IndexSet stokes_dofs (dof_handler.n_dofs());
+    stokes_dofs.add_range (0, vec.size());
+    const AffineConstraints<double> stokes_hanging_node_constraints
+      = hanging_node_constraints.get_view (stokes_dofs);
+#else
+    const AffineConstraints<double> &stokes_hanging_node_constraints = hanging_node_constraints;
+#endif
+
+    stokes_hanging_node_constraints.distribute(vec);
+  }
+
+
+
+  template <int dim>
+  double Simulator<dim>::normalize_pressure (LinearAlgebra::BlockVector &vector) const
+  {
+    if (parameters.pressure_normalization == "no")
+      return 0;
+
+    const FEValuesExtractors::Scalar &extractor_pressure =
+      (parameters.include_melt_transport ?
+       introspection.variable("fluid pressure").extractor_scalar()
+       : introspection.extractors.pressure);
+
+    double my_pressure = 0.0;
+    double my_area = 0.0;
+    if (parameters.pressure_normalization == "surface")
+      {
+        const types::boundary_id top_boundary_id = geometry_model->translate_symbolic_boundary_name_to_id("top");
+
+        const Quadrature<dim-1> &quadrature = this->introspection.face_quadratures.pressure;
+        const unsigned int n_q_points = quadrature.size();
+
+        FEFaceValues<dim> fe_face_values (*mapping, finite_element,  quadrature,
+                                          update_JxW_values | update_values);
+
+        std::vector<double> pressure_values(n_q_points);
+
+        for (const auto &cell : dof_handler.active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              for (const unsigned int face_no : cell->face_indices())
+                {
+                  const typename DoFHandler<dim>::face_iterator face = cell->face (face_no);
+                  if (face->at_boundary() && face->boundary_id() == top_boundary_id)
+                    {
+                      fe_face_values.reinit (cell, face_no);
+                      fe_face_values[extractor_pressure].get_function_values(vector,
+                                                                             pressure_values);
+
+                      for (unsigned int q = 0; q < n_q_points; ++q)
+                        {
+                          const double JxW = fe_face_values.JxW(q);
+                          my_pressure += pressure_values[q]
+                                         * JxW;
+                          my_area += JxW;
+                        }
+                    }
+                }
+            }
+      }
+    else if (parameters.pressure_normalization == "volume")
+      {
+        const Quadrature<dim> &quadrature = this->introspection.quadratures.pressure;
+        const unsigned int n_q_points = quadrature.size();
+
+        FEValues<dim> fe_values (*mapping, finite_element,  quadrature,
+                                 update_JxW_values | update_values);
+
+        std::vector<double> pressure_values(n_q_points);
+
+        for (const auto &cell : dof_handler.active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              fe_values.reinit (cell);
+              fe_values[extractor_pressure].get_function_values(vector,
+                                                                pressure_values);
+
+              for (unsigned int q = 0; q < n_q_points; ++q)
+                {
+                  my_pressure += pressure_values[q]
+                                 * fe_values.JxW (q);
+                  my_area += fe_values.JxW (q);
+                }
+            }
+      }
+    else
+      AssertThrow (false, ExcMessage("Invalid pressure normalization method: " +
+                                     parameters.pressure_normalization));
+
+    // sum up the integrals from each processor and compute the result we care about
+    double pressure_adjustment = numbers::signaling_nan<double>();
+    {
+      const double my_temp[2] = {my_pressure, my_area};
+      double temp[2];
+      Utilities::MPI::sum (my_temp, mpi_communicator, temp);
+      const double pressure = temp[0];
+      const double area = temp[1];
+
+      Assert (area > 0,
+              ExcMessage("While computing the average pressure, the area/volume "
+                         "to integrate over was found to be zero or negative. This "
+                         "indicates that no appropriate surface faces were found, "
+                         "which is typically the case if the geometry model is not "
+                         "set up correctly."));
+
+      if (parameters.pressure_normalization == "surface")
+        pressure_adjustment = -pressure/area + parameters.surface_pressure;
+      else if (parameters.pressure_normalization == "volume")
+        pressure_adjustment = -pressure/area;
+      else
+        AssertThrow(false, ExcNotImplemented());
+    }
+
+    // A complication is that we can't modify individual
+    // elements of the solution vector since that one has ghost element.
+    // rather, we first need to localize it and then distribute back
+    LinearAlgebra::BlockVector distributed_vector (introspection.index_sets.system_partitioning,
+                                                   mpi_communicator);
+    distributed_vector = vector;
+
+    if (parameters.use_locally_conservative_discretization == false)
+      {
+        if (introspection.block_indices.velocities != introspection.block_indices.pressure
+            && !parameters.include_melt_transport)
+          distributed_vector.block(introspection.block_indices.pressure).add(pressure_adjustment);
+        else
+          {
+            // pressure is not in a separate block, so we have to modify the values manually
+            const unsigned int pressure_component = (parameters.include_melt_transport ?
+                                                     introspection.variable("fluid pressure").first_component_index
+                                                     : introspection.component_indices.pressure);
+            const unsigned int n_local_pressure_dofs = (parameters.include_melt_transport ?
+                                                        finite_element.base_element(introspection.variable("fluid pressure").base_index).dofs_per_cell
+                                                        : finite_element.base_element(introspection.base_elements.pressure).dofs_per_cell);
+            std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+            for (const auto &cell : dof_handler.active_cell_iterators())
+              if (cell->is_locally_owned())
+                {
+                  cell->get_dof_indices (local_dof_indices);
+                  for (unsigned int j=0; j<n_local_pressure_dofs; ++j)
+                    {
+                      unsigned int support_point_index
+                        = finite_element.component_to_system_index(pressure_component,
+                                                                   /*dof index within component=*/ j);
+
+                      // then adjust its value. Note that because we end up touching
+                      // entries more than once, we are not simply incrementing
+                      // distributed_vector but copy from the unchanged vector.
+                      distributed_vector(local_dof_indices[support_point_index]) = vector(local_dof_indices[support_point_index]) + pressure_adjustment;
+                    }
+                }
+            distributed_vector.compress(VectorOperation::insert);
+          }
+      }
+    else
+      {
+        // this case is a bit more complicated: if the condition above is false
+        // then we use the FE_DGP element for which the shape functions do not
+        // add up to one; consequently, adding a constant to all degrees of
+        // freedom does not alter the overall function by that constant, but
+        // by something different
+        //
+        // we can work around this by using the documented property of the
+        // FE_DGP element that the first shape function is constant.
+        // consequently, adding the adjustment to the global function is
+        // achieved by adding the adjustment to the first pressure degree
+        // of freedom on each cell.
+        Assert (dynamic_cast<const FE_DGP<dim>*>(&finite_element.base_element(introspection.base_elements.pressure)) != nullptr,
+                ExcInternalError());
+        const unsigned int pressure_component = (parameters.include_melt_transport ?
+                                                 introspection.variable("fluid pressure").first_component_index
+                                                 : introspection.component_indices.pressure);
+        std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+
+        for (const auto &cell : dof_handler.active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              // identify the first pressure dof
+              cell->get_dof_indices (local_dof_indices);
+              const unsigned int first_pressure_dof
+                = finite_element.component_to_system_index (pressure_component, 0);
+
+              // make sure that this DoF is really owned by the current processor
+              // and that it is in fact a pressure dof
+              Assert (dof_handler.locally_owned_dofs().is_element(local_dof_indices[first_pressure_dof]),
+                      ExcInternalError());
+
+              // then adjust its value
+              distributed_vector(local_dof_indices[first_pressure_dof]) = vector(local_dof_indices[first_pressure_dof])
+                                                                          + pressure_adjustment;
+            }
+        distributed_vector.compress(VectorOperation::insert);
+      }
+
+    // now get back to the original vector and return the adjustment used
+    // in the computations above
+    vector = distributed_vector;
+
+    return pressure_adjustment;
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::
+  denormalize_pressure (const double                      pressure_adjustment,
+                        LinearAlgebra::BlockVector       &vector,
+                        const LinearAlgebra::BlockVector &relevant_vector) const
+  {
+    if (parameters.pressure_normalization == "no")
+      return;
+
+    if (parameters.use_locally_conservative_discretization == false)
+      {
+        if ((introspection.block_indices.velocities != introspection.block_indices.pressure)
+            && !parameters.include_melt_transport)
+          vector.block(introspection.block_indices.pressure).add(-1.0 * pressure_adjustment);
+        else
+          {
+            // pressure is not in a separate block so we have to modify the values manually
+            const unsigned int pressure_component = (parameters.include_melt_transport ?
+                                                     introspection.variable("fluid pressure").first_component_index
+                                                     : introspection.component_indices.pressure);
+            const unsigned int n_local_pressure_dofs = (parameters.include_melt_transport ?
+                                                        finite_element.base_element(introspection.variable("fluid pressure").base_index).dofs_per_cell
+                                                        : finite_element.base_element(introspection.base_elements.pressure).dofs_per_cell);
+
+            std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+            for (const auto &cell : dof_handler.active_cell_iterators())
+              if (cell->is_locally_owned())
+                {
+                  cell->get_dof_indices (local_dof_indices);
+                  for (unsigned int j=0; j<n_local_pressure_dofs; ++j)
+                    {
+                      const unsigned int local_dof_index
+                        = finite_element.component_to_system_index(pressure_component,
+                                                                   /*dof index within component=*/ j);
+
+                      // then adjust its value. Note that because we end up touching
+                      // entries more than once, we are not simply incrementing
+                      // distributed_vector but copy from the unchanged vector.
+                      vector(local_dof_indices[local_dof_index])
+                        = relevant_vector(local_dof_indices[local_dof_index]) - pressure_adjustment;
+                    }
+                }
+            vector.compress(VectorOperation::insert);
+          }
+      }
+    else
+      {
+        // this case is a bit more complicated: if the condition above is false
+        // then we use the FE_DGP element for which the shape functions do not
+        // add up to one; consequently, adding a constant to all degrees of
+        // freedom does not alter the overall function by that constant, but
+        // by something different
+        //
+        // we can work around this by using the documented property of the
+        // FE_DGP element that the first shape function is constant.
+        // consequently, adding the adjustment to the global function is
+        // achieved by adding the adjustment to the first pressure degree
+        // of freedom on each cell.
+        Assert (dynamic_cast<const FE_DGP<dim>*>(&finite_element.base_element(introspection.base_elements.pressure)) != nullptr,
+                ExcInternalError());
+        Assert(!parameters.include_melt_transport, ExcNotImplemented());
+        const unsigned int pressure_component = introspection.component_indices.pressure;
+        std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+        for (const auto &cell : dof_handler.active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              // identify the first pressure dof
+              cell->get_dof_indices (local_dof_indices);
+              const unsigned int first_pressure_dof
+                = finite_element.component_to_system_index (pressure_component, 0);
+
+              // make sure that this DoF is really owned by the current processor
+              // and that it is in fact a pressure dof
+              Assert (dof_handler.locally_owned_dofs().is_element(local_dof_indices[first_pressure_dof]),
+                      ExcInternalError());
+
+              // then adjust its value
+              vector (local_dof_indices[first_pressure_dof]) = relevant_vector(local_dof_indices[first_pressure_dof])
+                                                               - pressure_adjustment;
+            }
+
+        vector.compress(VectorOperation::insert);
+      }
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::make_pressure_rhs_compatible(LinearAlgebra::BlockVector &vector)
+  {
+    // If the mass conservation is written as
+    //   div u = f
+    // make sure this is solvable by modifying f to ensure that
+    // int_\Omega f = int_\Omega div u = 0
+    //
+    // We have to deal with several complications:
+    // - we can have an FE_Q or an FE_DGP for the pressure
+    // - we might use a direct solver, so pressure and velocity are in the same block
+    // - we might have melt transport, where we need to operate only on p_f
+    //
+    // We ensure int_\Omega f = 0 by computing a correction factor
+    //   c = \int f
+    // and adjust pressure RHS to be
+    //  fnew = f - c/|\Omega|
+    // such that
+    //   \int fnew = \int f - c/|\Omega| = -c + \int f = 0.
+    //
+    // We can compute
+    //   c = \int f = (f, 1) = (f, \sum_i \phi_i) = \sum_i (f, \phi_i) = \sum_i F_i
+    // which is just the sum over the RHS vector for FE_Q. For FE_DGP
+    // we need to restrict to 0th shape functions on each cell,
+    // because this is the shape function that is constant 1. (The
+    // other shape functions have mean value zero.)
+    //
+    // To make the adjustment fnew = f - c/|\Omega|
+    // note that
+    // fnew_i = f_i - c/|\Omega| * (1, \phi_i)
+    // and the same logic for FE_DGP applies
+
+
+    if ((!parameters.use_locally_conservative_discretization)
+        &&
+        (!parameters.include_melt_transport)
+        &&
+        (introspection.block_indices.velocities != introspection.block_indices.pressure))
+      {
+        // Easy Case. We have an FE_Q in a separate block, so we can use
+        // mean_value() and vector.block(p) += correction:
+        const double mean = vector.block(introspection.block_indices.pressure).mean_value();
+        Assert(std::isfinite(mean), ExcInternalError());
+        const double int_rhs = mean * vector.block(introspection.block_indices.pressure).size();
+        const double correction = -int_rhs / global_volume;
+        Assert(global_volume > 0.0, ExcInternalError());
+
+        vector.block(introspection.block_indices.pressure).add(correction, pressure_shape_function_integrals.block(introspection.block_indices.pressure));
+      }
+    else if (!parameters.use_locally_conservative_discretization)
+      {
+        // FE_Q but we can not access the pressure block separately (either
+        // a direct solver or we have melt with p_f and p_c in the same block).
+        // Luckily we don't need to go over DoFs on each cell, because we
+        // have IndexSets to help us:
+
+        // we need to operate only on p_f not on p_c
+        const IndexSet &idxset = parameters.include_melt_transport ?
+                                 introspection.index_sets.locally_owned_fluid_pressure_dofs
+                                 :
+                                 introspection.index_sets.locally_owned_pressure_dofs;
+        double int_rhs = 0.0;
+
+        for (unsigned int i=0; i < idxset.n_elements(); ++i)
+          {
+            types::global_dof_index idx = idxset.nth_index_in_set(i);
+            int_rhs += vector(idx);
+          }
+
+        // We do not have to integrate over the normal velocity at the
+        // boundaries with a prescribed velocity because the constraints
+        // are already distributed to the right hand side in
+        // current_constraints.distribute.
+        const double global_int_rhs = Utilities::MPI::sum(int_rhs, mpi_communicator);
+        const double correction = - global_int_rhs / global_volume;
+
+        for (unsigned int i=0; i < idxset.n_elements(); ++i)
+          {
+            types::global_dof_index idx = idxset.nth_index_in_set(i);
+            vector(idx) += correction * pressure_shape_function_integrals(idx);
+          }
+
+        vector.compress(VectorOperation::add);
+      }
+    else
+      {
+        // Locally conservative with or without direct solver and with or
+        // without melt: grab a pickaxe and do everything by hand!
+        AssertThrow(parameters.use_locally_conservative_discretization,
+                    ExcInternalError());
+
+        double int_rhs = 0.0;
+        const unsigned int pressure_component = (parameters.include_melt_transport ?
+                                                 introspection.variable("fluid pressure").first_component_index
+                                                 : introspection.component_indices.pressure);
+        std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+        for (const auto &cell : dof_handler.active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              // identify the first pressure dof
+              cell->get_dof_indices (local_dof_indices);
+              const unsigned int first_pressure_dof
+                = finite_element.component_to_system_index (pressure_component, 0);
+
+              // make sure that this DoF is really owned by the current processor
+              // and that it is in fact a pressure dof
+              Assert (dof_handler.locally_owned_dofs().is_element(local_dof_indices[first_pressure_dof]),
+                      ExcInternalError());
+
+              // compute integral:
+              int_rhs += vector(local_dof_indices[first_pressure_dof]);
+            }
+
+        const double global_int_rhs = Utilities::MPI::sum(int_rhs, mpi_communicator);
+        const double correction = - global_int_rhs / global_volume;
+
+        // Now modify our RHS with the correction factor:
+        for (const auto &cell : dof_handler.active_cell_iterators())
+          if (cell->is_locally_owned())
+            {
+              // identify the first pressure dof
+              cell->get_dof_indices (local_dof_indices);
+              const unsigned int first_pressure_dof
+                = finite_element.component_to_system_index (pressure_component, 0);
+
+              // make sure that this DoF is really owned by the current processor
+              // and that it is in fact a pressure dof
+              Assert (dof_handler.locally_owned_dofs().is_element(local_dof_indices[first_pressure_dof]),
+                      ExcInternalError());
+
+              // correct:
+              types::global_dof_index idx = local_dof_indices[first_pressure_dof];
+              vector(idx) += correction * pressure_shape_function_integrals(idx);
+            }
+
+        vector.compress(VectorOperation::add);
+      }
+  }
+
+
+  template <int dim>
+  double
+  Simulator<dim>::compute_initial_stokes_residual()
+  {
+    LinearAlgebra::BlockVector linearized_stokes_variables (introspection.index_sets.stokes_partitioning, mpi_communicator);
+    LinearAlgebra::BlockVector residual (introspection.index_sets.stokes_partitioning, mpi_communicator);
+    const unsigned int block_p =
+      parameters.include_melt_transport ?
+      introspection.variable("fluid pressure").block_index
+      :
+      introspection.block_indices.pressure;
+
+    // if velocity and pressure are in the same block, we have to copy the
+    // pressure to the solution and RHS vector with a zero velocity
+    if (block_p == introspection.block_indices.velocities)
+      {
+        const IndexSet &idxset = (parameters.include_melt_transport) ?
+                                 introspection.index_sets.locally_owned_fluid_pressure_dofs
+                                 :
+                                 introspection.index_sets.locally_owned_pressure_dofs;
+
+        for (unsigned int i=0; i < idxset.n_elements(); ++i)
+          {
+            types::global_dof_index idx = idxset.nth_index_in_set(i);
+            linearized_stokes_variables(idx)        = current_linearization_point(idx);
+          }
+        linearized_stokes_variables.block(block_p).compress(VectorOperation::insert);
+      }
+    else
+      linearized_stokes_variables.block (block_p) = current_linearization_point.block (block_p);
+
+    // TODO: we don't have .stokes_relevant_partitioning so I am creating a much
+    // bigger vector here, oh well.
+    LinearAlgebra::BlockVector ghosted (introspection.index_sets.system_partitioning,
+                                        introspection.index_sets.system_relevant_partitioning,
+                                        mpi_communicator);
+    // TODO for Timo: can we create the ghost vector inside of denormalize_pressure
+    // (only in cases where we need it)
+    ghosted.block(block_p) = linearized_stokes_variables.block(block_p);
+    denormalize_pressure (this->last_pressure_normalization_adjustment, linearized_stokes_variables, ghosted);
+    current_constraints.set_zero (linearized_stokes_variables);
+
+    linearized_stokes_variables.block (block_p) /= pressure_scaling;
+
+    // we calculate the velocity residual with a zero velocity,
+    // computing only the part of the RHS not balanced by the static pressure
+    if (block_p == introspection.block_indices.velocities)
+      {
+        // we can use the whole block here because we set the velocity to zero above
+        return system_matrix.block(0,0).residual (residual.block(0),
+                                                  linearized_stokes_variables.block(0),
+                                                  system_rhs.block(0));
+      }
+    else
+      {
+        const double residual_u = system_matrix.block(0,1).residual (residual.block(0),
+                                                                     linearized_stokes_variables.block(1),
+                                                                     system_rhs.block(0));
+        const double residual_p = system_rhs.block(block_p).l2_norm();
+        return std::sqrt(residual_u*residual_u+residual_p*residual_p);
+      }
+  }
+
+
+
+  template <int dim>
+  bool
+  Simulator<dim>::stokes_matrix_depends_on_solution() const
+  {
+    // Currently, the only coefficient that really appears on the
+    // left hand side of the Stokes equation is the viscosity and possibly
+    // the density in the case of the implicit reference density profile
+    // approximation.
+    // If melt transport is included in the simulation, we have an
+    // additional equation with more coefficients on the left hand
+    // side.
+
+    return (material_model->get_model_dependence().viscosity != MaterialModel::NonlinearDependence::none)
+           || (parameters.formulation_mass_conservation ==
+               Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile)
+           || parameters.include_melt_transport;
+  }
+
+
+
+  template <int dim>
+  bool
+  Simulator<dim>::stokes_A_block_is_symmetric() const
+  {
+    // The A block should be symmetric, unless there are free surface stabilization terms, or
+    // the user has forced the use of a different solver.
+    if (mesh_deformation && mesh_deformation->get_boundary_indicators_requiring_stabilization().empty() == false)
+      return false;
+    else if (parameters.force_nonsymmetric_A_block_solver)
+      return false;
+    else
+      return true;
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::update_solution_vectors_with_reaction_results (const unsigned int block_index,
+                                                                      const LinearAlgebra::BlockVector &distributed_vector,
+                                                                      const LinearAlgebra::BlockVector &distributed_reaction_vector)
+  {
+    solution.block(block_index) = distributed_vector.block(block_index);
+
+    // we have to update the old solution with our reaction update too
+    // so that the advection scheme will have the correct time stepping in the next step
+    LinearAlgebra::BlockVector tmp;
+    tmp.reinit(distributed_vector, false);
+
+    // What we really want to do is
+    //     old_solution.block(block_index) += distributed_reaction_vector.block(block_index);
+    // but because 'old_solution' is a ghosted vector, we can't write into it directly. Rather,
+    // we have to go around with a completely distributed vector.
+    tmp.block(block_index) = old_solution.block(block_index);
+    tmp.block(block_index) +=  distributed_reaction_vector.block(block_index);
+    old_solution.block(block_index) = tmp.block(block_index);
+
+    // Same here with going through a distributed vector.
+    tmp.block(block_index) = old_old_solution.block(block_index);
+    tmp.block(block_index) +=  distributed_reaction_vector.block(block_index);
+    old_old_solution.block(block_index) = tmp.block(block_index);
+
+    operator_split_reaction_vector.block(block_index) = distributed_reaction_vector.block(block_index);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::compute_reactions ()
+  {
+    // if the time step has a length of zero, there are no reactions
+    if (time_step == 0)
+      return;
+
+    TimerOutput::Scope timer (computing_timer, "Solve composition reactions");
+
+    // we need some temporary vectors to store our updates to composition and temperature in
+    // while we do the time stepping, before we copy them over to the solution vector in the end
+    LinearAlgebra::BlockVector distributed_vector (introspection.index_sets.system_partitioning,
+                                                   mpi_communicator);
+
+    LinearAlgebra::BlockVector distributed_reaction_vector (introspection.index_sets.system_partitioning,
+                                                            mpi_communicator);
+
+    // we use a different (potentially smaller) time step than in the advection scheme.
+    // and for the fixed step scheme, we want all of our reaction time steps (within one advection step) to have the same size
+    const unsigned int number_of_reaction_steps = std::max(static_cast<unsigned int>(time_step / parameters.reaction_time_step),
+                                                           std::max(parameters.reaction_steps_per_advection_step,1U));
+
+    const double reaction_time_step_size = time_step / static_cast<double>(number_of_reaction_steps);
+
+    if (parameters.reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
+      Assert (reaction_time_step_size > 0,
+              ExcMessage("Reaction time step must be greater than 0."));
+
+    pcout << "   Solving composition reactions... " << std::flush;
+
+
+    // We want to compute reactions in each support point for all fields (compositional fields and temperature). The reaction
+    // rate for an individual field depends on the values of all other fields, so we have to step them forward in time together.
+    // The rates comes from the material and heating model, otherwise we have a simple ODE in each point on each cell to solve.
+    //
+    // So far so good. Except that fields can have different Finite Element discretizations (degree, continuous/discontinuous)
+    // and will have different support points. We solve this by computing the union of all support points and evaluating all fields
+    // in these points for every cell (if necessary by interpolation). Then we solve the ODEs on each cell together and
+    // write back all values that correspond to support points of that particular field. Field values we computed that are
+    // not actually support points, we just throw away.
+
+    // First compute the union of all support points (temperature and compositions):
+    std::vector<Point<dim>> unique_support_points;
+    // For each field (T or composition) store where each support point is found in the list of indices of support points
+    // unique_support_points. This means index=support_point_index_by_field[0][3] is the index of the third support point
+    // of the temperature field and unique_support_points[index] is its location.
+    const unsigned int n_fields = 1 + introspection.n_compositional_fields;
+    std::vector<std::vector<unsigned int>> support_point_index_by_field(n_fields);
+
+    // Fill in the support_point_index_by_field data structure. This is a bit complicated...
+    {
+      // first fill in temperature:
+      unique_support_points = dof_handler.get_fe().base_element(introspection.base_elements.temperature).get_unit_support_points();
+      for (unsigned int i=0; i<unique_support_points.size(); ++i)
+        support_point_index_by_field[0].push_back(i);
+
+      // Naive n^2 algorithm to merge all compositional fields into the data structure.
+      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+        {
+          const auto composition = Simulator<dim>::AdvectionField::composition(c);
+          const std::vector<Point<dim>> &points = dof_handler.get_fe().base_element(composition.base_element(introspection)).get_unit_support_points();
+
+          for (unsigned int i=0; i<points.size(); ++i)
+            {
+              const auto it = std::find(unique_support_points.begin(), unique_support_points.end(), points[i]);
+              if (it != unique_support_points.end())
+                {
+                  // We already have this support point, record its number:
+                  support_point_index_by_field[1+c].push_back(std::distance(unique_support_points.begin(), it));
+                }
+              else
+                {
+                  // This is a new point that needs to be added:
+                  unique_support_points.push_back(points[i]);
+                  support_point_index_by_field[1+c].push_back(unique_support_points.size()-1);
+                }
+            }
+        }
+    }
+
+    const Quadrature<dim> combined_support_points(unique_support_points);
+    FEValues<dim> fe_values (*mapping,
+                             dof_handler.get_fe(),
+                             combined_support_points,
+                             update_quadrature_points | update_values | update_gradients);
+
+    const unsigned int n_q_points = combined_support_points.size();
+    std::vector<types::global_dof_index> local_dof_indices (dof_handler.get_fe().dofs_per_cell);
+    MaterialModel::MaterialModelInputs<dim> in(n_q_points, introspection.n_compositional_fields);
+    MaterialModel::MaterialModelOutputs<dim> out(n_q_points, introspection.n_compositional_fields);
+    HeatingModel::HeatingModelOutputs heating_model_outputs(n_q_points, introspection.n_compositional_fields);
+
+    // add reaction rate outputs
+    material_model->create_additional_named_outputs(out);
+
+    MaterialModel::ReactionRateOutputs<dim> *reaction_rate_outputs
+      = out.template get_additional_output<MaterialModel::ReactionRateOutputs<dim>>();
+
+    AssertThrow(reaction_rate_outputs != nullptr,
+                ExcMessage("You are trying to use the operator splitting solver scheme, "
+                           "but the material model you use does not support operator splitting "
+                           "(it does not create ReactionRateOutputs, which are required for this "
+                           "solver scheme)."));
+
+    // some heating models require the additional outputs
+    heating_model_manager.create_additional_material_model_inputs_and_outputs(in, out);
+
+    // We use SUNDIALs ARKode to compute the reactions. Set up the required parameters.
+    // TODO: Should we change some of these based on the Reaction time step input parameter?
+    using VectorType = Vector<double>;
+    SUNDIALS::ARKode<VectorType>::AdditionalData data;
+    data.initial_time = time;
+    data.final_time = time + time_step;
+    data.initial_step_size = 0.001 * time_step;
+    data.output_period = time_step;
+    data.minimum_step_size = 1.e-6 * time_step;
+
+    // Both tolerances are added, but the composition might become 0.
+    // We therefore set the absolute tolerance to a very small value.
+    data.relative_tolerance = 1e-6;
+    data.absolute_tolerance = 1e-10;
+
+    SUNDIALS::ARKode<VectorType> ode(data);
+
+    std::vector<std::vector<double>> initial_values_C (n_q_points, std::vector<double> (introspection.n_compositional_fields));
+    std::vector<double> initial_values_T (n_q_points);
+
+    // We have to store all values of the temperature and composition fields in one long vector.
+    // Create the vector and functions for transferring values between this vector and the material model inputs object.
+    VectorType fields (n_q_points * n_fields);
+
+    auto copy_fields_into_one_vector = [n_q_points,n_fields](const MaterialModel::MaterialModelInputs<dim> &in,
+                                                             VectorType &fields)
+    {
+      for (unsigned int j=0; j<n_q_points; ++j)
+        for (unsigned int f=0; f<n_fields; ++f)
+          if (f==0)
+            fields[j*n_fields+f] = in.temperature[j];
+          else
+            fields[j*n_fields+f] = in.composition[j][f-1];
+      return;
+    };
+
+    auto copy_fields_into_material_model_inputs = [n_q_points,n_fields](const VectorType &fields,
+                                                                        MaterialModel::MaterialModelInputs<dim> &in)
+    {
+      for (unsigned int j=0; j<n_q_points; ++j)
+        for (unsigned int f=0; f<n_fields; ++f)
+          if (f==0)
+            in.temperature[j]      = fields[j*n_fields+f];
+          else
+            in.composition[j][f-1] = fields[j*n_fields+f];
+      return;
+    };
+
+    auto copy_rates_into_one_vector = [n_q_points,n_fields](const MaterialModel::ReactionRateOutputs<dim> *reaction_out,
+                                                            const HeatingModel::HeatingModelOutputs &heating_out,
+                                                            VectorType &rates)
+    {
+      for (unsigned int j=0; j<n_q_points; ++j)
+        for (unsigned int f=0; f<n_fields; ++f)
+          if (f==0)
+            rates[j*n_fields+f] = heating_out.rates_of_temperature_change[j];
+          else
+            rates[j*n_fields+f] = reaction_out->reaction_rates[j][f-1];
+      return;
+    };
+
+    unsigned int total_iteration_count = 0;
+    unsigned int number_of_solves = 0;
+
+    // Make a loop first over all cells, than over all reaction time steps, and then over
+    // all degrees of freedom in each element to compute the reactions. This is possible
+    // because the reactions only depend on the temperature and composition values at a given
+    // degree of freedom (and are independent of the solution in other points).
+
+    // Note that the values for some degrees of freedom are set more than once in the loop
+    // below where we assign the new values to distributed_vector (if they are located on the
+    // interface between cells), as we loop over all cells, and then over all degrees of freedom
+    // on each cell. Although this means we do some additional work, the results are still
+    // correct, as we never read from distributed_vector inside the loop over all cells.
+    // We initialize the material model inputs object in using the solution vector
+    // on every cell, compute the update, and then on every cell put the result into the
+    // distributed_vector vector. Only after the loop over all cells do we copy distributed_vector
+    // back onto the solution vector.
+    // So even though we touch some DoF more than once, we always start from the same value, compute the
+    // same value, and then overwrite the same value in distributed_vector.
+    // TODO: make this even more efficient.
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          in.reinit(fe_values, cell, introspection, solution);
+
+          std::vector<std::vector<double>> accumulated_reactions_C (n_q_points, std::vector<double> (introspection.n_compositional_fields));
+          std::vector<double> accumulated_reactions_T (n_q_points);
+
+          copy_fields_into_one_vector (in, fields);
+
+          initial_values_C = in.composition;
+          initial_values_T = in.temperature;
+
+          if (parameters.reaction_solver_type == Parameters<dim>::ReactionSolverType::ARKode)
+            {
+
+              ode.explicit_function = [&] (const double /*time*/,
+                                           const VectorType &y,
+                                           VectorType &ydot)
+              {
+                copy_fields_into_material_model_inputs (y, in);
+                material_model->fill_additional_material_model_inputs(in, solution, fe_values, introspection);
+                material_model->evaluate(in, out);
+                heating_model_manager.evaluate(in, out, heating_model_outputs);
+                copy_rates_into_one_vector (reaction_rate_outputs, heating_model_outputs, ydot);
+              };
+
+              // Make the reaction time steps: We have to update the values of compositional fields and the temperature.
+              // We can reuse the same material model inputs and outputs structure for each reaction time step.
+              // We store the computed updates to temperature and composition in a separate (accumulated_reactions) vector,
+              // so that we can later copy it over to the solution vector.
+              const unsigned int iteration_count = ode.solve_ode(fields);
+
+              total_iteration_count += iteration_count;
+              number_of_solves += 1;
+
+              for (unsigned int j=0; j<n_q_points; ++j)
+                for (unsigned int f=0; f<n_fields; ++f)
+                  {
+                    if (f==0)
+                      {
+                        in.temperature[j]          = fields[j*n_fields+f];
+                        accumulated_reactions_T[j] = in.temperature[j] - initial_values_T[j];
+                      }
+                    else
+                      {
+                        in.composition[j][f-1]          = fields[j*n_fields+f];
+                        accumulated_reactions_C[j][f-1] = in.composition[j][f-1] - initial_values_C[j][f-1];
+                      }
+                  }
+            }
+
+          else if (parameters.reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
+            {
+              for (unsigned int i=0; i<number_of_reaction_steps; ++i)
+                {
+                  // Loop over composition element
+                  material_model->fill_additional_material_model_inputs(in, solution, fe_values, introspection);
+
+                  material_model->evaluate(in, out);
+                  heating_model_manager.evaluate(in, out, heating_model_outputs);
+
+                  for (unsigned int j=0; j<n_q_points; ++j)
+                    {
+                      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+                        {
+                          // simple forward euler
+                          in.composition[j][c] = in.composition[j][c]
+                                                 + reaction_time_step_size * reaction_rate_outputs->reaction_rates[j][c];
+                          accumulated_reactions_C[j][c] += reaction_time_step_size * reaction_rate_outputs->reaction_rates[j][c];
+                        }
+                      in.temperature[j] = in.temperature[j]
+                                          + reaction_time_step_size * heating_model_outputs.rates_of_temperature_change[j];
+                      accumulated_reactions_T[j] += reaction_time_step_size * heating_model_outputs.rates_of_temperature_change[j];
+                    }
+                }
+            }
+
+          cell->get_dof_indices (local_dof_indices);
+          const unsigned int component_idx_T = introspection.component_indices.temperature;
+
+          for (unsigned int dof_idx = 0; dof_idx < local_dof_indices.size(); ++dof_idx)
+            {
+              const auto comp_pair = dof_handler.get_fe().system_to_component_index(dof_idx);
+              const unsigned int component_idx = comp_pair.first;
+              if (component_idx>=component_idx_T) // ignore velocity, pressure, etc.
+                {
+                  // We found a DoF that belongs to component component_idx, which is a temperature or compositional
+                  // field. That means we want to find where this DoF in the computed reactions above to copy it
+                  // back into the global solution vector.
+
+                  // These two variables tell us the how-manyth shape function of which field (and therefore
+                  // field) this DoF is:
+                  const unsigned int index_within = comp_pair.second;
+                  const unsigned int field_index = component_idx-component_idx_T;
+                  // Now we can look up in the support_point_index_by_field data structure where this support
+                  // point is in the list of unique_support_points (and in the Quadrature):
+                  const unsigned int point_idx = support_point_index_by_field[field_index][index_within];
+
+                  // The final step is grabbing the value from the reaction computation and write it into
+                  // the global vector (if we own it, of course):
+                  if (dof_handler.locally_owned_dofs().is_element(local_dof_indices[dof_idx]))
+                    {
+                      // temperatures and compositions are stored differently:
+                      if (component_idx == component_idx_T)
+                        {
+                          distributed_vector(local_dof_indices[dof_idx]) = in.temperature[point_idx];
+                          distributed_reaction_vector(local_dof_indices[dof_idx]) = accumulated_reactions_T[point_idx];
+                        }
+                      else
+                        {
+                          const unsigned int composition = field_index-1; // 0 is temperature...
+                          distributed_vector(local_dof_indices[dof_idx]) = in.composition[point_idx][composition];
+                          distributed_reaction_vector(local_dof_indices[dof_idx]) = accumulated_reactions_C[point_idx][composition];
+                        }
+                    }
+                }
+            }
+        }
+
+    distributed_vector.compress(VectorOperation::insert);
+    distributed_reaction_vector.compress(VectorOperation::insert);
+
+    // put the final values into the solution vector
+    for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+      update_solution_vectors_with_reaction_results(introspection.block_indices.compositional_fields[c],
+                                                    distributed_vector,
+                                                    distributed_reaction_vector);
+
+    update_solution_vectors_with_reaction_results(introspection.block_indices.temperature,
+                                                  distributed_vector,
+                                                  distributed_reaction_vector);
+
+    initialize_current_linearization_point();
+
+    double average_iteration_count = number_of_reaction_steps;
+    if (parameters.reaction_solver_type == Parameters<dim>::ReactionSolverType::ARKode)
+      {
+        if (number_of_solves > 0)
+          average_iteration_count = total_iteration_count / number_of_solves;
+        else
+          average_iteration_count = total_iteration_count;
+      }
+
+    pcout << "in "
+          << average_iteration_count
+          << " substep(s)."
+          << std::endl;
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::initialize_current_linearization_point ()
+  {
+    // Start with a simple copy of the last timestep
+    current_linearization_point = old_solution;
+
+    // If possible use an extrapolated solution from last and
+    // previous to last timestep.
+    if (timestep_number > 1)
+      {
+        // TODO: Trilinos sadd does not like ghost vectors even as input. Copy
+        // into distributed vectors for now:
+        LinearAlgebra::BlockVector distr_solution (system_rhs);
+        distr_solution = old_solution;
+        LinearAlgebra::BlockVector distr_old_solution (system_rhs);
+        distr_old_solution = old_old_solution;
+        distr_solution.sadd ((1 + time_step/old_time_step),
+                             -time_step/old_time_step,
+                             distr_old_solution);
+        current_linearization_point = distr_solution;
+      }
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::interpolate_material_output_into_advection_field (const AdvectionField &adv_field)
+  {
+    // we need some temporary vectors to store our updates to composition in
+    // before we copy them over to the solution vector in the end
+    LinearAlgebra::BlockVector distributed_vector (introspection.index_sets.system_partitioning,
+                                                   mpi_communicator);
+
+    if (adv_field.is_temperature())
+      pcout << "   Copying properties into prescribed temperature field... "
+            << std::flush;
+    else
+      {
+        const std::string name_of_field = introspection.name_for_compositional_index(adv_field.compositional_variable);
+
+        pcout << "   Copying properties into prescribed compositional field " + name_of_field + "... "
+              << std::flush;
+      }
+
+    // Create an FEValues object that allows us to interpolate onto the solution
+    // vector. To make this happen, we need to have a quadrature formula that
+    // consists of the support points of the advection field finite element
+    const Quadrature<dim> quadrature(dof_handler.get_fe().base_element(adv_field.base_element(introspection))
+                                     .get_unit_support_points());
+
+    FEValues<dim> fe_values (*mapping,
+                             dof_handler.get_fe(),
+                             quadrature,
+                             update_quadrature_points | update_values | update_gradients);
+
+    std::vector<types::global_dof_index> local_dof_indices (dof_handler.get_fe().dofs_per_cell);
+    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), introspection.n_compositional_fields);
+    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), introspection.n_compositional_fields);
+
+    // add the prescribed field outputs that will be used for interpolating
+    material_model->create_additional_named_outputs(out);
+
+    MaterialModel::PrescribedFieldOutputs<dim> *prescribed_field_out
+      = out.template get_additional_output<MaterialModel::PrescribedFieldOutputs<dim>>();
+    MaterialModel::PrescribedTemperatureOutputs<dim> *prescribed_temperature_out
+      = out.template get_additional_output<MaterialModel::PrescribedTemperatureOutputs<dim>>();
+
+    // check if the material model computes the correct prescribed field outputs
+    if (adv_field.is_temperature())
+      {
+        AssertThrow(prescribed_temperature_out != nullptr,
+                    ExcMessage("You are trying to use a prescribed temperature field, "
+                               "but the material model you use does not support interpolating properties "
+                               "(it does not create PrescribedTemperatureOutputs, which is required for this "
+                               "temperature field type)."));
+      }
+    else
+      {
+        AssertThrow(prescribed_field_out != nullptr,
+                    ExcMessage("You are trying to use a prescribed advection field, "
+                               "but the material model you use does not support interpolating properties "
+                               "(it does not create PrescribedFieldOutputs, which is required for this "
+                               "advection field type)."));
+      }
+
+    // Make a loop first over all cells, and then over all degrees of freedom in each element
+    // to interpolate material properties onto a solution vector.
+
+    // Note that the values for some degrees of freedom are set more than once in the loop
+    // below where we assign the new values to distributed_vector (if they are located on the
+    // interface between cells), as we loop over all cells, and then over all degrees of freedom
+    // on each cell. But even though we touch some DoF more than once, we always compute the same value,
+    // and then overwrite the same value in distributed_vector.
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          cell->get_dof_indices (local_dof_indices);
+          in.reinit(fe_values, cell, introspection, solution);
+
+          material_model->evaluate(in, out);
+
+          // Interpolate material properties onto the advection fields
+          const unsigned int advection_dofs_per_cell =
+            dof_handler.get_fe().base_element(adv_field.base_element(introspection)).dofs_per_cell;
+
+          for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+            {
+              const unsigned int dof_idx
+                = dof_handler.get_fe().component_to_system_index(adv_field.component_index(introspection),
+                                                                 /*dof index within component=*/ j);
+
+              // Skip degrees of freedom that are not locally owned. These
+              // will eventually be handled by one of the other processors.
+              if (dof_handler.locally_owned_dofs().is_element(local_dof_indices[dof_idx]))
+                {
+                  if (adv_field.is_temperature())
+                    {
+                      Assert(numbers::is_finite(prescribed_temperature_out->prescribed_temperature_outputs[j]),
+                             ExcMessage("You are trying to use a prescribed advection field, "
+                                        "but the material model you use does not fill the PrescribedFieldOutputs "
+                                        "for your prescribed field, which is required for this method."));
+
+                      distributed_vector(local_dof_indices[dof_idx])
+                        = prescribed_temperature_out->prescribed_temperature_outputs[j];
+                    }
+                  else
+                    {
+                      Assert(numbers::is_finite(prescribed_field_out->prescribed_field_outputs[j][adv_field.compositional_variable]),
+                             ExcMessage("You are trying to use a prescribed advection field, "
+                                        "but the material model you use does not fill the PrescribedFieldOutputs "
+                                        "for your prescribed field, which is required for this method."));
+
+                      distributed_vector(local_dof_indices[dof_idx])
+                        = prescribed_field_out->prescribed_field_outputs[j][adv_field.compositional_variable];
+                    }
+                }
+            }
+        }
+
+    // Put the final values into the solution vector, also
+    // updating the ghost elements of the 'solution' vector.
+    const unsigned int advection_block = adv_field.block_index(introspection);
+    distributed_vector.block(advection_block).compress(VectorOperation::insert);
+
+    if (adv_field.is_temperature() ||
+        adv_field.compositional_variable != introspection.find_composition_type(CompositionalFieldDescription::density))
+      current_constraints.distribute (distributed_vector);
+
+    solution.block(advection_block) = distributed_vector.block(advection_block);
+
+    pcout << "done." << std::endl;
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::check_consistency_of_formulation()
+  {
+    // Replace Formulation::MassConservation::ask_material_model by the respective terms to avoid
+    // complicated checks later on
+    if (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::ask_material_model)
+      {
+        if (material_model->is_compressible() == true)
+          parameters.formulation_mass_conservation = Parameters<dim>::Formulation::MassConservation::isentropic_compression;
+        else
+          parameters.formulation_mass_conservation = Parameters<dim>::Formulation::MassConservation::incompressible;
+      }
+
+    // Ensure the material model supports the selected formulation of the mass conservation equation
+    if (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::incompressible)
+      {
+        AssertThrow(material_model->is_compressible() == false,
+                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
+                               "The mass conservation equation was selected to be incompressible, "
+                               "but the provided material model reports that it is compressible. "
+                               "Please check the consistency of your material model and selected formulation."));
+      }
+    else if (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::isentropic_compression
+             || parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::reference_density_profile
+             || parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile
+             || parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::projected_density_field)
+      {
+        AssertThrow(material_model->is_compressible() == true,
+                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
+                               "The mass conservation equation was selected to be compressible, "
+                               "but the provided material model reports that it is incompressible. "
+                               "Please check the consistency of your material model and selected formulation."));
+      }
+
+    // Ensure that the correct heating terms have been selected for the chosen combined formulation
+    // Note that if the combined formulation is 'custom' there is no check
+    // (useful e.g. for smaller scale lithospheric models with shear heating but without adiabatic heating)
+    if (parameters.formulation == Parameters<dim>::Formulation::isentropic_compression)
+      {
+        AssertThrow(heating_model_manager.adiabatic_heating_enabled(),
+                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
+                               "The `isentropic compression' formulation expects adiabatic heating to be enabled, "
+                               "but the `adiabatic heating' plugin has not been selected in the input file. "
+                               "Please check the consistency of your input file."));
+
+        AssertThrow(heating_model_manager.shear_heating_enabled(),
+                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
+                               "The `isentropic compression' formulation expects shear heating to be enabled, "
+                               "but the `shear heating' plugin has not been selected in the input file. "
+                               "Please check the consistency of your input file."));
+      }
+    else if (parameters.formulation == Parameters<dim>::Formulation::boussinesq_approximation)
+      {
+        AssertThrow(!heating_model_manager.adiabatic_heating_enabled(),
+                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
+                               "The 'Boussinesq approximation' formulation expects adiabatic heating to be disabled, "
+                               "but the `adiabatic heating' plugin has been selected in the input file. "
+                               "Please check the consistency of your input file."));
+
+        AssertThrow(!heating_model_manager.shear_heating_enabled(),
+                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
+                               "The 'Boussinesq approximation' formulation expects shear heating to be disabled, "
+                               "but the `shear heating' plugin has been selected in the input file. "
+                               "Please check the consistency of your input file."));
+      }
+    else if (parameters.formulation == Parameters<dim>::Formulation::anelastic_liquid_approximation)
+      {
+        AssertThrow(heating_model_manager.adiabatic_heating_enabled(),
+                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
+                               "The `anelastic liquid approximation' formulation expects adiabatic heating to be enabled, "
+                               "but the `adiabatic heating' plugin has not been selected in the input file. "
+                               "Please check the consistency of your input file."));
+
+        AssertThrow(heating_model_manager.shear_heating_enabled(),
+                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
+                               "The `anelastic liquid approximation' formulation expects shear heating to be enabled, "
+                               "but the `shear heating' plugin has not been selected in the input file. "
+                               "Please check the consistency of your input file."));
+
+        const bool use_simplified_adiabatic_heating =
+          heating_model_manager.template get_matching_heating_model<HeatingModel::AdiabaticHeating<dim>>()
+          .use_simplified_adiabatic_heating();
+
+        AssertThrow(use_simplified_adiabatic_heating == true,
+                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
+                               "The `anelastic liquid approximation' formulation expects adiabatic heating to use "
+                               "a simplified heating term that neglects dynamic pressure influences, "
+                               "but the adiabatic heating plugin does not report to simplify this term. "
+                               "Please check the consistency of your input file."));
+      }
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::replace_outflow_boundary_ids(const unsigned int offset)
+  {
+    const Quadrature<dim-1> &quadrature_formula = introspection.face_quadratures.temperature;
+
+    FEFaceValues<dim> fe_face_values (*mapping,
+                                      finite_element,
+                                      quadrature_formula,
+                                      update_values   | update_normal_vectors |
+                                      update_quadrature_points | update_JxW_values);
+
+    std::vector<Tensor<1,dim>> face_current_velocity_values (fe_face_values.n_quadrature_points);
+
+    const auto &tangential_velocity_boundaries =
+      boundary_velocity_manager.get_tangential_boundary_velocity_indicators();
+
+    const auto &zero_velocity_boundaries =
+      boundary_velocity_manager.get_zero_boundary_velocity_indicators();
+
+    const auto &prescribed_velocity_boundaries =
+      boundary_velocity_manager.get_active_boundary_velocity_conditions();
+
+    // Loop over all of the boundary faces, ...
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (!cell->is_artificial())
+        for (const unsigned int face_number : cell->face_indices())
+          {
+            const typename DoFHandler<dim>::face_iterator face = cell->face(face_number);
+
+            // If the face is at a boundary where we may want to replace its id
+            if (face->at_boundary() &&
+                tangential_velocity_boundaries.find(face->boundary_id()) == tangential_velocity_boundaries.end() &&
+                zero_velocity_boundaries.find(face->boundary_id()) == zero_velocity_boundaries.end())
+              {
+                Assert(face->boundary_id() <= offset,
+                       ExcMessage("If you do not 'Allow fixed temperature/composition on outflow boundaries', "
+                                  "you are only allowed to use boundary ids between 0 and 128."));
+
+                fe_face_values.reinit (cell, face_number);
+                fe_face_values[introspection.extractors.velocities].get_function_values(current_linearization_point,
+                                                                                        face_current_velocity_values);
+
+                // ... check if the face is an outflow boundary by integrating the normal velocities
+                // (flux through the boundary) as: int u*n ds = Sum_q u(x_q)*n(x_q) JxW(x_q)...
+                double integrated_flow = 0;
+
+                for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                  {
+                    Tensor<1,dim> boundary_velocity;
+                    if (prescribed_velocity_boundaries.find(face->boundary_id()) == prescribed_velocity_boundaries.end())
+                      boundary_velocity = face_current_velocity_values[q];
+                    else
+                      boundary_velocity = boundary_velocity_manager.boundary_velocity(face->boundary_id(),
+                                                                                      fe_face_values.quadrature_point(q));
+
+                    integrated_flow += (boundary_velocity * fe_face_values.normal_vector(q)) *
+                                       fe_face_values.JxW(q);
+                  }
+
+                // ... and change the boundary id of any outflow boundary faces.
+                if (integrated_flow > 0)
+                  face->set_boundary_id(face->boundary_id() + offset);
+              }
+          }
+  }
+
+
+  template <int dim>
+  void
+  Simulator<dim>::restore_outflow_boundary_ids(const unsigned int offset)
+  {
+    // Loop over all of the boundary faces...
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (!cell->is_artificial())
+        for (const unsigned int face_number : cell->face_indices())
+          {
+            const typename DoFHandler<dim>::face_iterator face = cell->face(face_number);
+            if (face->at_boundary())
+              {
+                // ... and reset all of the boundary ids we changed in replace_outflow_boundary_ids above.
+                if (face->boundary_id() >= offset)
+                  face->set_boundary_id(face->boundary_id() - offset);
+              }
+          }
+  }
+
+
+  namespace
+  {
+    /**
+     * Return whether t is an element of the given container object.
+     */
+    template <typename Container>
+    bool is_element (const typename Container::value_type &t,
+                     const Container                      &container)
+    {
+      for (const auto &p : container)
+        if (p == t)
+          return true;
+
+      return false;
+    }
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::check_consistency_of_boundary_conditions() const
+  {
+    // make sure velocity and traction boundary indicators don't appear in multiple lists
+    std::set<types::boundary_id> boundary_indicator_lists[6]
+      = { boundary_velocity_manager.get_zero_boundary_velocity_indicators(),
+          boundary_velocity_manager.get_tangential_boundary_velocity_indicators(),
+          std::set<types::boundary_id>()   // to be prescribed velocity and traction boundary indicators
+        };
+
+    // sets of the boundary indicators only (no selectors and values)
+    std::set<types::boundary_id> velocity_bi;
+    std::set<types::boundary_id> traction_bi;
+
+    for (const auto &p : boundary_velocity_manager.get_active_boundary_velocity_names())
+      velocity_bi.insert(p.first);
+
+    for (const auto &r : parameters.prescribed_traction_boundary_indicators)
+      traction_bi.insert(r.first);
+
+    // are there any indicators that occur in both the prescribed velocity and traction list?
+    std::set<types::boundary_id> intersection;
+    std::set_intersection (velocity_bi.begin(),
+                           velocity_bi.end(),
+                           traction_bi.begin(),
+                           traction_bi.end(),
+                           std::inserter(intersection, intersection.end()));
+
+    // if so, do they have different selectors?
+    if (!intersection.empty())
+      {
+        for (const auto it : intersection)
+          {
+            const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>>::const_iterator
+            boundary_velocity_names = boundary_velocity_manager.get_active_boundary_velocity_names().find(it);
+            Assert(boundary_velocity_names != boundary_velocity_manager.get_active_boundary_velocity_names().end(),
+                   ExcInternalError());
+
+            std::set<char> velocity_selector;
+            std::set<char> traction_selector;
+
+            for (const auto it_selector : boundary_velocity_names->second.first)
+              velocity_selector.insert(it_selector);
+
+            for (std::string::const_iterator
+                 it_selector  = parameters.prescribed_traction_boundary_indicators.find(it)->second.first.begin();
+                 it_selector != parameters.prescribed_traction_boundary_indicators.find(it)->second.first.end();
+                 ++it_selector)
+              traction_selector.insert(*it_selector);
+
+            // if there are no selectors specified, throw exception
+            AssertThrow(!velocity_selector.empty() || !traction_selector.empty(),
+                        ExcMessage ("Boundary indicator <"
+                                    +
+                                    Utilities::int_to_string(it)
+                                    +
+                                    "> with symbolic name <"
+                                    +
+                                    geometry_model->translate_id_to_symbol_name (it)
+                                    +
+                                    "> is listed as having both "
+                                    "velocity and traction boundary conditions in the input file."));
+
+            std::set<char> intersection_selector;
+            std::set_intersection (velocity_selector.begin(),
+                                   velocity_selector.end(),
+                                   traction_selector.begin(),
+                                   traction_selector.end(),
+                                   std::inserter(intersection_selector, intersection_selector.end()));
+
+            // if the same selectors are specified, throw exception
+            AssertThrow(intersection_selector.empty(),
+                        ExcMessage ("Selectors of boundary indicator <"
+                                    +
+                                    Utilities::int_to_string(it)
+                                    +
+                                    "> with symbolic name <"
+                                    +
+                                    geometry_model->translate_id_to_symbol_name (it)
+                                    +
+                                    "> are listed as having both "
+                                    "velocity and traction boundary conditions in the input file."));
+          }
+      }
+
+    // remove correct boundary indicators that occur in both the velocity and the traction set
+    // but have different selectors
+    std::set<types::boundary_id> union_set;
+    std::set_union (velocity_bi.begin(),
+                    velocity_bi.end(),
+                    traction_bi.begin(),
+                    traction_bi.end(),
+                    std::inserter(union_set, union_set.end()));
+
+    // assign the prescribed boundary indicator list to the boundary_indicator_lists
+    boundary_indicator_lists[3] = union_set;
+
+    // for each combination of boundary indicator lists, make sure that the
+    // intersection is empty
+    for (unsigned int i=0; i<sizeof(boundary_indicator_lists)/sizeof(boundary_indicator_lists[0]); ++i)
+      for (unsigned int j=i+1; j<sizeof(boundary_indicator_lists)/sizeof(boundary_indicator_lists[0]); ++j)
+        {
+          std::set<types::boundary_id> intersection;
+          std::set_intersection (boundary_indicator_lists[i].begin(),
+                                 boundary_indicator_lists[i].end(),
+                                 boundary_indicator_lists[j].begin(),
+                                 boundary_indicator_lists[j].end(),
+                                 std::inserter(intersection, intersection.end()));
+
+          // if the same indicators are specified for different boundary conditions, throw exception
+          AssertThrow (intersection.empty(),
+                       ExcMessage ("Boundary indicator <"
+                                   +
+                                   Utilities::int_to_string(*intersection.begin())
+                                   +
+                                   "> with symbolic name <"
+                                   +
+                                   geometry_model->translate_id_to_symbol_name (*intersection.begin())
+                                   +
+                                   "> is listed as having more "
+                                   "than one type of velocity or traction boundary condition in the input file."));
+        }
+
+    // make sure temperature and heat flux boundary indicators don't appear in multiple lists
+    // this is easier than for the velocity/traction, as there are no selectors
+    std::set<types::boundary_id> temperature_bi = boundary_temperature_manager.get_fixed_temperature_boundary_indicators();
+    std::set<types::boundary_id> heat_flux_bi = parameters.fixed_heat_flux_boundary_indicators;
+
+    // are there any indicators that occur in both the prescribed temperature and heat flux list?
+    std::set<types::boundary_id> T_intersection;
+    std::set_intersection (temperature_bi.begin(),
+                           temperature_bi.end(),
+                           heat_flux_bi.begin(),
+                           heat_flux_bi.end(),
+                           std::inserter(T_intersection, T_intersection.end()));
+
+    AssertThrow(T_intersection.empty(),
+                ExcMessage ("There is a boundary indicator listed as having both "
+                            "temperature and heat flux boundary conditions in the input file."));
+
+    // Check that the periodic boundaries do not have other boundary conditions set
+    using periodic_boundary_set
+      = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
+
+    periodic_boundary_set pbs = geometry_model->get_periodic_boundary_pairs();
+
+    for (const auto &pb : pbs)
+      {
+        // Throw error if we are trying to use the same boundary for more than one boundary condition
+        AssertThrow( is_element( pb.first.first, boundary_temperature_manager.get_fixed_temperature_boundary_indicators() ) == false &&
+                     is_element( pb.first.second, boundary_temperature_manager.get_fixed_temperature_boundary_indicators() ) == false &&
+                     is_element( pb.first.first, boundary_composition_manager.get_fixed_composition_boundary_indicators() ) == false &&
+                     is_element( pb.first.second, boundary_composition_manager.get_fixed_composition_boundary_indicators() ) == false &&
+                     is_element( pb.first.first, boundary_indicator_lists[0] ) == false && // zero velocity
+                     is_element( pb.first.second, boundary_indicator_lists[0] ) == false && // zero velocity
+                     is_element( pb.first.first, boundary_indicator_lists[1] ) == false && // tangential velocity
+                     is_element( pb.first.second, boundary_indicator_lists[1] ) == false && // tangential velocity
+                     is_element( pb.first.first, boundary_indicator_lists[3] ) == false && // prescribed traction or velocity
+                     is_element( pb.first.second, boundary_indicator_lists[3] ) == false,  // prescribed traction or velocity
+                     ExcMessage("Periodic boundaries must not have boundary conditions set."));
+      }
+
+    const std::set<types::boundary_id> all_boundary_indicators
+      = geometry_model->get_used_boundary_indicators();
+    if (parameters.nonlinear_solver != NonlinearSolver::single_Advection_no_Stokes)
+      {
+        // next make sure that all listed indicators are actually used by
+        // this geometry
+        for (const auto &list : boundary_indicator_lists)
+          for (const auto &p : list)
+            AssertThrow (all_boundary_indicators.find (p)
+                         != all_boundary_indicators.end(),
+                         ExcMessage ("One of the boundary indicators listed in the input file "
+                                     "is not used by the geometry model."));
+      }
+    else
+      {
+        // next make sure that there are no listed indicators
+        for (const auto &list : boundary_indicator_lists)
+          AssertThrow (list.empty(),
+                       ExcMessage ("With the solver scheme `single Advection, no Stokes', "
+                                   "one cannot set boundary conditions for velocity."));
+      }
+
+
+    // now do the same for the fixed temperature indicators and the
+    // compositional indicators
+    for (const auto p : boundary_temperature_manager.get_fixed_temperature_boundary_indicators())
+      AssertThrow (all_boundary_indicators.find (p)
+                   != all_boundary_indicators.end(),
+                   ExcMessage ("One of the fixed boundary temperature indicators listed in the input file "
+                               "is not used by the geometry model."));
+    for (const auto p : boundary_composition_manager.get_fixed_composition_boundary_indicators())
+      AssertThrow (all_boundary_indicators.find (p)
+                   != all_boundary_indicators.end(),
+                   ExcMessage ("One of the fixed boundary composition indicators listed in the input file "
+                               "is not used by the geometry model."));
+  }
+
+
+
+  template <int dim>
+  double
+  Simulator<dim>::compute_initial_newton_residual(const LinearAlgebra::BlockVector &linearized_stokes_initial_guess)
+  {
+    // Store the values of the current_linearization_point and linearized_stokes_initial_guess so we can reset them again.
+    LinearAlgebra::BlockVector temp_linearization_point = current_linearization_point;
+    LinearAlgebra::BlockVector temp_linearized_stokes_initial_guess = linearized_stokes_initial_guess;
+    const unsigned int block_vel = introspection.block_indices.velocities;
+
+    // Set the velocity initial guess to zero, but we use the initial guess for the pressure.
+    current_linearization_point.block(introspection.block_indices.velocities) = 0;
+    temp_linearized_stokes_initial_guess.block (block_vel) = 0;
+
+    denormalize_pressure (last_pressure_normalization_adjustment,
+                          temp_linearized_stokes_initial_guess,
+                          current_linearization_point);
+
+    // rebuild the whole system to compute the rhs.
+    assemble_newton_stokes_system = true;
+    rebuild_stokes_preconditioner = false;
+    rebuild_stokes_matrix = boundary_velocity_manager.get_active_boundary_velocity_conditions().size()!=0;
+    assemble_newton_stokes_matrix = boundary_velocity_manager.get_active_boundary_velocity_conditions().size()!=0;
+
+    compute_current_constraints ();
+
+    assemble_stokes_system();
+
+    last_pressure_normalization_adjustment = normalize_pressure(current_linearization_point);
+
+    const double initial_newton_residual_vel = system_rhs.block(introspection.block_indices.velocities).l2_norm();
+    const double initial_newton_residual_p = system_rhs.block(introspection.block_indices.pressure).l2_norm();
+    const double initial_newton_residual = std::sqrt(initial_newton_residual_vel * initial_newton_residual_vel + initial_newton_residual_p * initial_newton_residual_p);
+
+    current_linearization_point = temp_linearization_point;
+
+    pcout << "   Initial Newton Stokes residual = " << initial_newton_residual << ", v = " << initial_newton_residual_vel << ", p = " << initial_newton_residual_p << std::endl << std::endl;
+    return initial_newton_residual;
+  }
+
+
+
+  template <int dim>
+  double
+  Simulator<dim>::compute_Eisenstat_Walker_linear_tolerance(const bool EisenstatWalkerChoiceOne,
+                                                            const double maximum_linear_stokes_solver_tolerance,
+                                                            const double linear_stokes_solver_tolerance,
+                                                            const double stokes_residual,
+                                                            const double newton_residual,
+                                                            const double newton_residual_old)
+  {
+    /**
+       * The Eisenstat and Walker (1996) method is used for determining the linear tolerance of
+       * the iteration after the first iteration. The paper gives two preferred choices of computing
+       * this tolerance. Both choices are implemented here with the suggested parameter values and
+       * safeguards.
+     */
+    double new_linear_stokes_solver_tolerance = linear_stokes_solver_tolerance;
+    if (EisenstatWalkerChoiceOne)
+      {
+        // This is the preferred value for this parameter in the paper.
+        // A value of 2 for the power-term might also work fine.
+        const double powerterm = (1+std::sqrt(5))*0.5;
+        if (std::pow(linear_stokes_solver_tolerance,powerterm) <= 0.1)
+          {
+            new_linear_stokes_solver_tolerance = std::min(maximum_linear_stokes_solver_tolerance,
+                                                          std::fabs(newton_residual-stokes_residual)/(newton_residual_old));
+          }
+        else
+          {
+            new_linear_stokes_solver_tolerance = std::min(maximum_linear_stokes_solver_tolerance,
+                                                          std::max(std::fabs(newton_residual-stokes_residual)/newton_residual_old,
+                                                                   std::pow(linear_stokes_solver_tolerance,powerterm)));
+          }
+      }
+    else
+      {
+        if (0.9*linear_stokes_solver_tolerance * linear_stokes_solver_tolerance <= 0.1)
+          {
+            new_linear_stokes_solver_tolerance =  std::min(maximum_linear_stokes_solver_tolerance,
+                                                           0.9 * std::fabs(newton_residual * newton_residual) /
+                                                           (newton_residual_old * newton_residual_old));
+          }
+        else
+          {
+            new_linear_stokes_solver_tolerance = std::min(newton_handler->parameters.maximum_linear_stokes_solver_tolerance,
+                                                          std::max(0.9 * std::fabs(newton_residual*newton_residual)
+                                                                   /
+                                                                   (newton_residual_old*newton_residual_old),
+                                                                   0.9*linear_stokes_solver_tolerance*linear_stokes_solver_tolerance));
+          }
+      }
+    return new_linear_stokes_solver_tolerance;
+  }
+
+
+
+  template <int dim>
+  void
+  Simulator<dim>::select_default_solver_and_averaging()
+  {
+    if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::default_solver)
+      {
+        // Catch all situations that are not supported by the GMG solver:
+        //   - Melt transport
+        //   - Ellipsoidal geometry
+        //   - Locally conservative discretization
+        //   - Implicit reference density profile
+        //   - Periodic boundaries
+        //   - Stokes velocity degree not 2 or 3
+        //   - Material averaging explicitly disabled
+        if (parameters.include_melt_transport == true ||
+            dynamic_cast<const GeometryModel::EllipsoidalChunk<dim>*>(geometry_model.get()) != nullptr ||
+            parameters.use_locally_conservative_discretization == true ||
+            (material_model->is_compressible() == true && parameters.formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile) ||
+            (geometry_model->get_periodic_boundary_pairs().size()) > 0 ||
+            (parameters.stokes_velocity_degree < 2 || parameters.stokes_velocity_degree > 3) ||
+            parameters.material_averaging == MaterialModel::MaterialAveraging::none)
+          {
+            // GMG is not supported (yet), by default fall back to AMG.
+            parameters.stokes_solver_type = Parameters<dim>::StokesSolverType::block_amg;
+          }
+        else
+          {
+            // GMG is supported for all other cases
+            parameters.stokes_solver_type = Parameters<dim>::StokesSolverType::block_gmg;
+          }
+      }
+
+    // Now pick an appropriate material averaging for the chosen solver
+    if (parameters.material_averaging == MaterialModel::MaterialAveraging::default_averaging)
+      {
+        if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
+          {
+            // project to Q1 is more accurate, but not supported if:
+            //   - elasticity is enabled
+            //   - the Newton solver is enabled
+            if (parameters.enable_elasticity == true ||
+                parameters.nonlinear_solver == NonlinearSolver::iterated_Advection_and_Newton_Stokes ||
+                parameters.nonlinear_solver == NonlinearSolver::single_Advection_iterated_Newton_Stokes)
+              parameters.material_averaging = MaterialModel::MaterialAveraging::harmonic_average_only_viscosity;
+            else
+              parameters.material_averaging = MaterialModel::MaterialAveraging::project_to_Q1_only_viscosity;
+          }
+        else
+          parameters.material_averaging = MaterialModel::MaterialAveraging::none;
+      }
+  }
+}
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template struct Simulator<dim>::AdvectionField; \
+  template double Simulator<dim>::normalize_pressure(LinearAlgebra::BlockVector &vector) const; \
+  template void Simulator<dim>::denormalize_pressure(const double pressure_adjustment, \
+                                                     LinearAlgebra::BlockVector &vector, \
+                                                     const LinearAlgebra::BlockVector &relevant_vector) const; \
+  template double Simulator<dim>::compute_pressure_scaling_factor () const; \
+  template double Simulator<dim>::get_maximal_velocity (const LinearAlgebra::BlockVector &solution) const; \
+  template std::pair<double,double> Simulator<dim>::get_extrapolated_advection_field_range (const AdvectionField &advection_field) const; \
+  template void Simulator<dim>::maybe_write_timing_output () const; \
+  template bool Simulator<dim>::maybe_write_checkpoint (const time_t, const bool); \
+  template bool Simulator<dim>::maybe_do_initial_refinement (const unsigned int max_refinement_level); \
+  template void Simulator<dim>::exchange_refinement_flags (); \
+  template void Simulator<dim>::maybe_refine_mesh (const double new_time_step, unsigned int &max_refinement_level); \
+  template void Simulator<dim>::advance_time (const double step_size); \
+  template void Simulator<dim>::make_pressure_rhs_compatible(LinearAlgebra::BlockVector &vector); \
+  template void Simulator<dim>::output_statistics(); \
+  template void Simulator<dim>::write_plugin_graph(std::ostream &) const; \
+  template double Simulator<dim>::compute_initial_stokes_residual(); \
+  template bool Simulator<dim>::stokes_matrix_depends_on_solution() const; \
+  template bool Simulator<dim>::stokes_A_block_is_symmetric() const; \
+  template void Simulator<dim>::interpolate_onto_velocity_system(const TensorFunction<1,dim> &func, LinearAlgebra::Vector &vec);\
+  template void Simulator<dim>::compute_reactions(); \
+  template void Simulator<dim>::initialize_current_linearization_point (); \
+  template void Simulator<dim>::interpolate_material_output_into_advection_field(const AdvectionField &adv_field); \
+  template void Simulator<dim>::check_consistency_of_formulation(); \
+  template void Simulator<dim>::replace_outflow_boundary_ids(const unsigned int boundary_id_offset); \
+  template void Simulator<dim>::restore_outflow_boundary_ids(const unsigned int boundary_id_offset); \
+  template void Simulator<dim>::check_consistency_of_boundary_conditions() const; \
+  template double Simulator<dim>::compute_initial_newton_residual(const LinearAlgebra::BlockVector &linearized_stokes_initial_guess); \
+  template double Simulator<dim>::compute_Eisenstat_Walker_linear_tolerance(const bool EisenstatWalkerChoiceOne, \
+                                                                            const double maximum_linear_stokes_solver_tolerance, \
+                                                                            const double linear_stokes_solver_tolerance, \
+                                                                            const double stokes_residual, \
+                                                                            const double newton_residual, \
+                                                                            const double newton_residual_old); \
+  template void Simulator<dim>::select_default_solver_and_averaging();
+
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/initial_conditions.cc.bak b/source/simulator/initial_conditions.cc.bak
new file mode 100644
index 00000000000..836a95c0f66
--- /dev/null
+++ b/source/simulator/initial_conditions.cc.bak
@@ -0,0 +1,545 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/initial_composition/interface.h>
+#include <aspect/postprocess/particles.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function.h>
+
+#include <deal.II/lac/full_matrix.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/dofs/dof_accessor.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+namespace aspect
+{
+
+  template <int dim>
+  void Simulator<dim>::set_initial_temperature_and_compositional_fields ()
+  {
+    // create a fully distributed vector since we
+    // need to write into it and we can not
+    // write into vectors with ghost elements
+    LinearAlgebra::BlockVector initial_solution;
+    double max_sum_comp = 0.0;
+
+    // we need to track whether we need to normalize the totality of fields
+    bool normalize_composition = false;
+
+    initial_solution.reinit(system_rhs, false);
+
+    // below, we would want to call VectorTools::interpolate on the
+    // entire FESystem. there currently is no way to restrict the
+    // interpolation operations to only a subset of vector
+    // components (oversight in deal.II?), specifically to the
+    // temperature component. this causes more work than necessary
+    // but worse yet, it doesn't work for the DGP(q) pressure element
+    // if we use a locally conservative formulation since there the
+    // pressure element is non-interpolating (we get an exception
+    // even though we are, strictly speaking, not interested in
+    // interpolating the pressure; but, as mentioned, there is no way
+    // to tell VectorTools::interpolate that)
+    //
+    // to work around this problem, the following code is essentially
+    // a (simplified) copy of the code in VectorTools::interpolate
+    // that only works on the temperature component
+    //
+    // TODO: it would be great if we had a cleaner way than iterating to 1+n_fields.
+    // Additionally, the n==1 logic for normalization at the bottom is not pretty.
+    for (unsigned int n=0; n<1+introspection.n_compositional_fields; ++n)
+      {
+        const AdvectionField advf = ((n == 0) ? AdvectionField::temperature()
+                                     : AdvectionField::composition(n-1));
+
+        const unsigned int base_element = advf.base_element(introspection);
+
+        // get the temperature/composition support points
+        const std::vector<Point<dim>> support_points
+          = finite_element.base_element(base_element).get_unit_support_points();
+        Assert (support_points.size() != 0,
+                ExcInternalError());
+
+        // create an FEValues object with just the temperature/composition element
+        FEValues<dim> fe_values (*mapping, finite_element,
+                                 support_points,
+                                 update_quadrature_points);
+
+        std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+
+        const VectorFunctionFromScalarFunctionObject<dim, double> &advf_init_function
+          =
+            (advf.is_temperature()
+             ?
+             VectorFunctionFromScalarFunctionObject<dim, double>(
+               [&](const Point<dim> &p) -> double
+        {
+          return initial_temperature_manager->initial_temperature(p);
+        },
+        introspection.component_indices.temperature,
+        introspection.n_components)
+        :
+        VectorFunctionFromScalarFunctionObject<dim, double>(
+          [&](const Point<dim> &p) -> double
+        {
+          return initial_composition_manager->initial_composition(p, n-1);
+        },
+        introspection.component_indices.compositional_fields[n-1],
+        introspection.n_components));
+
+        const ComponentMask advf_mask =
+          (advf.is_temperature()
+           ?
+           introspection.component_masks.temperature
+           :
+           introspection.component_masks.compositional_fields[n-1]);
+
+        try
+          {
+            VectorTools::interpolate(*mapping,
+                                     dof_handler,
+                                     advf_init_function,
+                                     initial_solution,
+                                     advf_mask);
+          }
+        // initial conditions that throw exceptions usually do not result in
+        // anything good because they result in an unwinding of the stack
+        // and, if only one processor triggers an exception, the
+        // destruction of objects often causes a deadlock. thus, if
+        // an exception is generated, catch it, print an error message,
+        // and abort the program
+        catch (std::exception &exc)
+          {
+            const std::string field_name = (advf.is_temperature()
+                                            ?
+                                            "temperature"
+                                            :
+                                            introspection.name_for_compositional_index(n-1));
+
+            std::cerr << std::endl << std::endl
+                      << "----------------------------------------------------"
+                      << std::endl;
+            std::cerr << "Exception on MPI process <"
+                      << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                      << "> while setting the initial condition for field <"
+                      << field_name
+                      << ">: " << std::endl
+                      << exc.what() << std::endl
+                      << "Aborting!" << std::endl
+                      << "----------------------------------------------------"
+                      << std::endl;
+
+            // terminate the program!
+            MPI_Abort (MPI_COMM_WORLD, 1);
+          }
+        catch (...)
+          {
+            const std::string field_name = (advf.is_temperature()
+                                            ?
+                                            "temperature"
+                                            :
+                                            introspection.name_for_compositional_index(n-1));
+
+            std::cerr << std::endl << std::endl
+                      << "----------------------------------------------------"
+                      << std::endl;
+            std::cerr << "Exception on MPI process <"
+                      << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                      << "> while setting the initial condition for field <"
+                      << field_name
+                      << ">: " << std::endl;
+            std::cerr << "Unknown exception!" << std::endl
+                      << "Aborting!" << std::endl
+                      << "----------------------------------------------------"
+                      << std::endl;
+
+            // terminate the program!
+            MPI_Abort (MPI_COMM_WORLD, 1);
+          }
+
+        if (parameters.normalized_fields.size()>0 && n==1)
+          for (const auto &cell : dof_handler.active_cell_iterators())
+            if (cell->is_locally_owned())
+              {
+                fe_values.reinit (cell);
+
+                // Go through the support points for each dof
+                for (unsigned int i=0; i<finite_element.base_element(base_element).dofs_per_cell; ++i)
+                  {
+                    // if it is specified in the parameter file that the sum of all compositional fields
+                    // must not exceed one, this should be checked
+                    double sum = 0;
+                    for (unsigned int m=0; m<parameters.normalized_fields.size(); ++m)
+                      sum += initial_composition_manager->initial_composition(fe_values.quadrature_point(i),
+                                                                              parameters.normalized_fields[m]);
+
+                    if (std::abs(sum) > 1.0+std::numeric_limits<double>::epsilon())
+                      {
+                        max_sum_comp = std::max(sum, max_sum_comp);
+                        normalize_composition = true;
+                      }
+                  }
+              }
+
+        initial_solution.compress(VectorOperation::insert);
+
+        // if at least one processor decides that it needs
+        // to normalize, do the same on all processors.
+        if (Utilities::MPI::max (normalize_composition ? 1 : 0,
+                                 mpi_communicator)
+            == 1)
+          {
+            const double global_max
+              = Utilities::MPI::max (max_sum_comp, mpi_communicator);
+
+            if (n==1)
+              pcout << "Sum of compositional fields is not one, fields will be normalized"
+                    << std::endl;
+
+            for (unsigned int m=0; m<parameters.normalized_fields.size(); ++m)
+              if (n-1==parameters.normalized_fields[m])
+                initial_solution.block(introspection.block_indices.compositional_fields[n-1]) /= global_max;
+          }
+      }
+
+    // then apply constraints and copy the
+    // result into vectors with ghost elements. to do so,
+    // we need the current constraints to be correct for
+    // the current time
+    compute_current_constraints ();
+    current_constraints.distribute(initial_solution);
+
+    // Now copy the temperature and initial composition blocks into the solution variables
+
+    for (unsigned int n=0; n<1+introspection.n_compositional_fields; ++n)
+      {
+        AdvectionField advf = ((n == 0) ? AdvectionField::temperature()
+                               : AdvectionField::composition(n-1));
+
+        const unsigned int blockidx = advf.block_index(introspection);
+
+        solution.block(blockidx) = initial_solution.block(blockidx);
+        old_solution.block(blockidx) = initial_solution.block(blockidx);
+        old_old_solution.block(blockidx) = initial_solution.block(blockidx);
+        current_linearization_point.block(blockidx) = initial_solution.block(blockidx);
+      }
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::interpolate_particle_properties (const AdvectionField &advection_field)
+  {
+    std::vector<AdvectionField> advection_fields(1,advection_field);
+    interpolate_particle_properties(advection_fields);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::interpolate_particle_properties (const std::vector<AdvectionField> &advection_fields)
+  {
+    TimerOutput::Scope timer (computing_timer, "Particles: Interpolate");
+
+    // below, we would want to call VectorTools::interpolate on the
+    // entire FESystem. there currently is no way to restrict the
+    // interpolation operations to only a subset of vector
+    // components (oversight in deal.II?), specifically to the
+    // temperature component. this causes more work than necessary
+    // but worse yet, it doesn't work for the DGP(q) pressure element
+    // if we use a locally conservative formulation since there the
+    // pressure element is non-interpolating (we get an exception
+    // even though we are, strictly speaking, not interested in
+    // interpolating the pressure; but, as mentioned, there is no way
+    // to tell VectorTools::interpolate that)
+    //
+    // to work around this problem, the following code is essentially
+    // a (simplified) copy of the code in VectorTools::interpolate
+    // that only works on the given component
+
+    // create a fully distributed vector since we
+    // need to write into it and we can not
+    // write into vectors with ghost elements
+
+    const Particle::Interpolator::Interface<dim> &particle_interpolator = particle_worlds[0]->get_interpolator();
+    const Particle::Property::Manager<dim> &particle_property_manager = particle_worlds[0]->get_property_manager();
+
+    std::vector<unsigned int> particle_property_indices;
+    ComponentMask property_mask  (particle_property_manager.get_data_info().n_components(),false);
+
+    for (const auto &advection_field: advection_fields)
+      {
+        if (parameters.mapped_particle_properties.size() != 0)
+          {
+            const std::pair<std::string,unsigned int> particle_property_and_component = parameters.mapped_particle_properties.find(advection_field.compositional_variable)->second;
+
+            const unsigned int particle_property_index = particle_property_manager.get_data_info().get_position_by_field_name(particle_property_and_component.first)
+                                                         + particle_property_and_component.second;
+
+            particle_property_indices.push_back(particle_property_index);
+
+            property_mask.set(particle_property_index,true);
+          }
+        else
+          {
+            const unsigned int particle_property_index = std::count(introspection.compositional_field_methods.begin(),
+                                                                    introspection.compositional_field_methods.begin() + advection_field.compositional_variable,
+                                                                    Parameters<dim>::AdvectionFieldMethod::particles);
+            AssertThrow(particle_property_index <= particle_property_manager.get_data_info().n_components(),
+                        ExcMessage("Can not automatically match particle properties to fields, because there are"
+                                   "more fields that are marked as particle advected than particle properties"));
+
+            particle_property_indices.push_back(particle_property_index);
+            property_mask.set(particle_property_index,true);
+          }
+      }
+
+    LinearAlgebra::BlockVector particle_solution;
+
+    particle_solution.reinit(system_rhs, false);
+
+    const unsigned int base_element_index = advection_fields[0].base_element(introspection);
+
+    // We can only combine the interpolation of properties into fields
+    // that share the same base element. Otherwise the element support points
+    // are not guaranteed to be identical.
+    for (const auto &advection_field: advection_fields)
+      {
+        (void) advection_field;
+        Assert (advection_field.base_element(introspection) == base_element_index, ExcInternalError());
+      }
+
+    // get the temperature/composition support points
+    const std::vector<Point<dim>> support_points
+      = finite_element.base_element(base_element_index).get_unit_support_points();
+    Assert (support_points.size() != 0,
+            ExcInternalError());
+
+    // create an FEValues object with just the temperature/composition element
+    FEValues<dim> fe_values (*mapping, finite_element,
+                             support_points,
+                             update_quadrature_points);
+
+    std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          const std::vector<Point<dim>> quadrature_points = fe_values.get_quadrature_points();
+
+          std::vector<std::vector<double>> particle_properties;
+
+          try
+            {
+              particle_properties =
+                particle_interpolator.properties_at_points(particle_worlds[0]->get_particle_handler(),
+                                                           quadrature_points,
+                                                           property_mask,
+                                                           cell);
+            }
+          // interpolators that throw exceptions usually do not result in
+          // anything good, because they result in an unwinding of the stack
+          // and, if only one processor triggers an exception, the
+          // destruction of objects often causes a deadlock or completely
+          // unrelated MPI error messages. Thus, if an exception is
+          // generated, catch it, print an error message, and abort the program.
+          catch (std::exception &exc)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while interpolating particle properties: "
+                        << std::endl
+                        << exc.what() << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+
+          // go through the composition dofs and set their global values
+          // to the particle field interpolated at these points
+          cell->get_dof_indices (local_dof_indices);
+          const unsigned int n_dofs_per_cell = finite_element.base_element(base_element_index).dofs_per_cell;
+          for (unsigned int j=0; j<advection_fields.size(); ++j)
+            for (unsigned int i=0; i<n_dofs_per_cell; ++i)
+              {
+                const unsigned int system_local_dof
+                  = finite_element.component_to_system_index(advection_fields[j].component_index(introspection),
+                                                             /*dof index within component=*/i);
+
+                particle_solution(local_dof_indices[system_local_dof]) = particle_properties[i][particle_property_indices[j]];
+              }
+        }
+
+    particle_solution.compress(VectorOperation::insert);
+
+    // overwrite the relevant composition blocks only
+    std::vector<bool> particle_blocks (introspection.n_blocks,false);
+    for (const auto &advection_field: advection_fields)
+      {
+        const unsigned int blockidx = advection_field.block_index(introspection);
+        particle_blocks[blockidx] = true;
+        solution.block(blockidx) = particle_solution.block(blockidx);
+
+        // In the first timestep, and for iterative Advection schemes only
+        // in the first nonlinear iteration, initialize all solution vectors with the initial
+        // particle solution, identical to the end of the
+        // Simulator<dim>::set_initial_temperature_and_compositional_fields ()
+        // function.
+        if (timestep_number == 0 && nonlinear_iteration == 0)
+          {
+            old_solution.block(blockidx) = particle_solution.block(blockidx);
+            old_old_solution.block(blockidx) = particle_solution.block(blockidx);
+          }
+      }
+
+    // we should not have written at all into any of the blocks
+    // that are not interpolated from particles
+    for (unsigned int b=0; b<introspection.n_blocks; ++b)
+      if (particle_blocks[b] == false)
+        Assert (particle_solution.block(b).l2_norm() == 0,
+                ExcInternalError());
+
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::compute_initial_pressure_field ()
+  {
+    // Note that this code will overwrite the velocity solution with 0 if
+    // velocity and pressure are in the same block (i.e., direct solver is
+    // used). As the velocity is all zero anyway, this is currently not a
+    // problem.
+
+    // we'd like to interpolate the initial pressure onto the pressure
+    // variable but that's a bit involved because the pressure may either
+    // be an FE_Q (for which we can interpolate) or an FE_DGP (for which
+    // we can't since the element has no nodal basis.
+    //
+    // fortunately, in the latter case, the element is discontinuous and
+    // we can compute a local projection onto the pressure space
+    if (parameters.use_locally_conservative_discretization == false)
+      {
+        // allocate a vector that is distributed but doesn't have
+        // ghost elements (vectors with ghost elements are not
+        // writable); the stokes_rhs vector is a valid template for
+        // this kind of thing. interpolate into it and later copy it into the
+        // solution vector that does have the necessary ghost elements
+        LinearAlgebra::BlockVector system_tmp;
+        system_tmp.reinit (system_rhs);
+
+        // First grab the correct pressure to work on:
+        const FEVariable<dim> &pressure_variable
+          = parameters.include_melt_transport ?
+            introspection.variable("fluid pressure")
+            : introspection.variable("pressure");
+        const unsigned int pressure_comp = pressure_variable.first_component_index;
+        const ComponentMask pressure_component_mask = pressure_variable.component_mask;
+
+        // interpolate the pressure given by the adiabatic conditions
+        // object onto the solution space. note that interpolate
+        // wants a function that represents all components of the
+        // solution vector, so create such a function object
+        // that is simply zero for all velocity components
+        VectorFunctionFromScalarFunctionObject<dim> vector_function_object(
+          [&](const Point<dim> &p) -> double
+        {
+          return adiabatic_conditions->pressure(p);
+        },
+        pressure_comp,
+        introspection.n_components);
+
+        VectorTools::interpolate (*mapping, dof_handler,
+                                  vector_function_object,
+                                  system_tmp,
+                                  pressure_component_mask);
+
+        // we may have hanging nodes, so apply constraints
+        constraints.distribute (system_tmp);
+
+        const unsigned int pressure_block = pressure_variable.block_index;
+        old_solution.block(pressure_block) = system_tmp.block(pressure_block);
+      }
+    else
+      {
+        // Find the local projection for the discontinuous pressure
+        // element. This is only going to work if, indeed, the element
+        // is discontinuous.
+        Assert (finite_element.base_element(introspection.base_elements.pressure).dofs_per_face == 0,
+                ExcNotImplemented());
+
+        LinearAlgebra::BlockVector system_tmp;
+        system_tmp.reinit (system_rhs);
+
+        const Quadrature<dim> &quadrature = introspection.quadratures.velocities;
+        Utilities::project_cellwise<dim,LinearAlgebra::BlockVector>(*mapping,
+                                                                    dof_handler,
+                                                                    introspection.component_indices.pressure,
+                                                                    quadrature,
+                                                                    [&](const typename DoFHandler<dim>::active_cell_iterator & /*cell*/,
+                                                                        const std::vector<Point<dim>> &q_points,
+                                                                        std::vector<double> &values) -> void
+        {
+          for (unsigned int i=0; i<values.size(); ++i)
+            values[i] = adiabatic_conditions->pressure(q_points[i]);
+          return;
+        },
+        system_tmp);
+
+        old_solution.block(introspection.block_indices.pressure) = system_tmp.block(introspection.block_indices.pressure);
+      }
+
+    // normalize the pressure in such a way that the surface pressure
+    // equals a known and desired value
+    this->last_pressure_normalization_adjustment = normalize_pressure(old_solution);
+
+    // set all solution vectors to the same value as the previous solution
+    solution = old_solution;
+    old_old_solution = old_solution;
+  }
+}
+
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template void Simulator<dim>::set_initial_temperature_and_compositional_fields(); \
+  template void Simulator<dim>::compute_initial_pressure_field(); \
+  template void Simulator<dim>::interpolate_particle_properties(const AdvectionField &);
+
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/introspection.cc.bak b/source/simulator/introspection.cc.bak
new file mode 100644
index 00000000000..c52c4e91181
--- /dev/null
+++ b/source/simulator/introspection.cc.bak
@@ -0,0 +1,615 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/introspection.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/fe/fe_q.h>
+#include <deal.II/fe/fe_dgq.h>
+#include <deal.II/fe/fe_dgp.h>
+
+namespace aspect
+{
+  namespace internal
+  {
+    /**
+     * Return a filled ComponentIndices structure.
+     */
+    template <int dim>
+    typename Introspection<dim>::ComponentIndices
+    setup_component_indices (FEVariableCollection<dim> &fevs)
+    {
+      typename Introspection<dim>::ComponentIndices ci;
+      for (unsigned int i=0; i<dim; ++i)
+        ci.velocities[i] = fevs.variable("velocity").first_component_index+i;
+
+      ci.pressure = fevs.variable("pressure").first_component_index;
+      ci.temperature = fevs.variable("temperature").first_component_index;
+
+      {
+        const auto composition_variables = fevs.variables_with_name("compositions");
+        for (const auto &fe : composition_variables)
+          {
+            for (unsigned int i=0; i<fe->multiplicity; ++i)
+              {
+                ci.compositional_fields.push_back(fe->first_component_index+i);
+              }
+          }
+      }
+
+      return ci;
+    }
+
+    /**
+     * return filled BlockIndices structure.
+     */
+    template <int dim>
+    typename Introspection<dim>::BlockIndices
+    setup_blocks (FEVariableCollection<dim> &fevs)
+    {
+      typename Introspection<dim>::BlockIndices b;
+      b.velocities = fevs.variable("velocity").block_index;
+      b.pressure = fevs.variable("pressure").block_index;
+      b.temperature = fevs.variable("temperature").block_index;
+
+      {
+        const auto variables = fevs.variables_with_name("compositions");
+        for (const auto &fe : variables)
+          {
+            for (unsigned int i=0; i<fe->multiplicity; ++i)
+              {
+                b.compositional_fields.push_back(fe->block_index + i);
+                b.compositional_field_sparsity_pattern.push_back(fe->block_index);
+              }
+          }
+      }
+      return b;
+    }
+
+
+
+    template <int dim>
+    typename Introspection<dim>::BaseElements
+    setup_base_elements (FEVariableCollection<dim> &fevs)
+    {
+      typename Introspection<dim>::BaseElements base_elements;
+
+      base_elements.velocities = fevs.variable("velocity").base_index;
+      base_elements.pressure = fevs.variable("pressure").base_index;
+      base_elements.temperature = fevs.variable("temperature").base_index;
+
+      {
+        // TODO: We would ideally reuse base elements also when they are
+        // not consecutively encountered. For now, just ignore that fact.
+        const auto variables = fevs.variables_with_name("compositions");
+        for (const auto &fe : variables)
+          {
+            for (unsigned int i=0; i<fe->multiplicity; ++i)
+              base_elements.compositional_fields.push_back(fe->base_index);
+          }
+      }
+
+
+
+
+      return base_elements;
+    }
+
+
+
+    template <int dim>
+    typename Introspection<dim>::PolynomialDegree
+    setup_polynomial_degree (const Parameters<dim> &parameters)
+    {
+      typename Introspection<dim>::PolynomialDegree polynomial_degree;
+
+      polynomial_degree.velocities = parameters.stokes_velocity_degree;
+      polynomial_degree.temperature = parameters.temperature_degree;
+      polynomial_degree.compositional_fields = parameters.composition_degree;
+
+      return polynomial_degree;
+    }
+
+
+
+    template <int dim>
+    typename Introspection<dim>::Quadratures
+    setup_quadratures (const Parameters<dim> &parameters,
+                       const ReferenceCell reference_cell)
+    {
+      typename Introspection<dim>::Quadratures quadratures;
+
+      quadratures.velocities = reference_cell.get_gauss_type_quadrature<dim>(parameters.stokes_velocity_degree+1);
+      quadratures.pressure = reference_cell.get_gauss_type_quadrature<dim>(parameters.use_equal_order_interpolation_for_stokes
+                                                                           ?
+                                                                           parameters.stokes_velocity_degree+1
+                                                                           :
+                                                                           parameters.stokes_velocity_degree);
+      quadratures.temperature = reference_cell.get_gauss_type_quadrature<dim>(parameters.temperature_degree+1);
+      quadratures.compositional_fields = reference_cell.get_gauss_type_quadrature<dim>(parameters.composition_degree+1);
+      quadratures.system = reference_cell.get_gauss_type_quadrature<dim>(std::max({parameters.stokes_velocity_degree,
+                                                                                   parameters.temperature_degree,
+                                                                                   parameters.composition_degree
+                                                                                  }) + 1);
+
+      return quadratures;
+    }
+
+
+
+    template <int dim>
+    typename Introspection<dim>::FaceQuadratures
+    setup_face_quadratures (const Parameters<dim> &parameters,
+                            const ReferenceCell reference_cell)
+    {
+      typename Introspection<dim>::FaceQuadratures quadratures;
+
+      quadratures.velocities = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(parameters.stokes_velocity_degree+1);
+      quadratures.pressure = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(parameters.use_equal_order_interpolation_for_stokes
+                             ?
+                             parameters.stokes_velocity_degree+1
+                             :
+                             parameters.stokes_velocity_degree);
+      quadratures.temperature = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(parameters.temperature_degree+1);
+      quadratures.compositional_fields = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(parameters.composition_degree+1);
+      quadratures.system = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(std::max({parameters.stokes_velocity_degree,
+                           parameters.temperature_degree,
+                           parameters.composition_degree
+                                                                                                           }) + 1);
+
+      return quadratures;
+    }
+
+
+
+    template <int dim>
+    std::shared_ptr<FiniteElement<dim>>
+    new_FE_Q_or_DGP(const bool discontinuous,
+                    const unsigned int degree)
+    {
+      if (discontinuous)
+        return std::make_shared<FE_DGP<dim>>(degree);
+      else
+        return std::make_shared<FE_Q<dim>>(degree);
+    }
+
+
+
+    template <int dim>
+    std::shared_ptr<FiniteElement<dim>>
+    new_FE_Q_or_DGQ(const bool discontinuous,
+                    const unsigned int degree)
+    {
+      if (discontinuous)
+        return std::make_shared<FE_DGQ<dim>>(degree);
+      else
+        return std::make_shared<FE_Q<dim>>(degree);
+    }
+  }
+
+
+
+
+  template <int dim>
+  std::vector<VariableDeclaration<dim>>
+  construct_default_variables (const Parameters<dim> &parameters)
+  {
+    std::vector<VariableDeclaration<dim>> variables;
+
+    const unsigned int n_velocity_blocks = parameters.use_direct_stokes_solver ? 0 : 1;
+    variables.push_back(
+      VariableDeclaration<dim>("velocity",
+                               std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree),
+                               dim,
+                               n_velocity_blocks));
+
+    if (parameters.use_equal_order_interpolation_for_stokes == false)
+      variables.push_back(
+        VariableDeclaration<dim>(
+          "pressure",
+          internal::new_FE_Q_or_DGP<dim>(parameters.use_locally_conservative_discretization,
+                                         parameters.stokes_velocity_degree-1),
+          1,
+          1));
+    else
+      variables.push_back(
+        VariableDeclaration<dim>(
+          "pressure",
+          std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree),
+          1,
+          1));
+
+
+    variables.push_back(
+      VariableDeclaration<dim>(
+        "temperature",
+        internal::new_FE_Q_or_DGQ<dim>(parameters.use_discontinuous_temperature_discretization,
+                                       parameters.temperature_degree),
+        1,
+        1));
+
+    // We can not create a single composition with multiplicity n (this assumes all have the same FiniteElement) and
+    // we also don't want to create n different compositional fields for performance reasons. Instead, we combine
+    // consecutive compositions of the same type into the same base element. For example, if the user requests
+    // "Q2,Q2,DGQ1,Q2", we actually create "Q2^2, DGQ1, Q2":
+    for (unsigned int c=0; c<parameters.n_compositional_fields; ++c)
+      {
+        if (c>0 && parameters.use_discontinuous_composition_discretization[c] == parameters.use_discontinuous_composition_discretization[c-1])
+          {
+            // reuse last one because it is the same
+            variables.back().multiplicity += 1;
+            variables.back().n_blocks += 1;
+          }
+        else
+          {
+            std::shared_ptr<FiniteElement<dim>> fe = internal::new_FE_Q_or_DGQ<dim>(parameters.use_discontinuous_composition_discretization[c],
+                                                                                     parameters.composition_degree);
+            variables.push_back(VariableDeclaration<dim>("compositions", fe, 1, 1));
+          }
+      }
+
+    return variables;
+  }
+
+
+  template <int dim>
+  Introspection<dim>::Introspection(const std::vector<VariableDeclaration<dim>> &variable_definition,
+                                    const Parameters<dim> &parameters
+                                   )
+    :
+    FEVariableCollection<dim>(variable_definition),
+    n_components (FEVariableCollection<dim>::n_components()),
+    n_compositional_fields (parameters.n_compositional_fields),
+    use_discontinuous_temperature_discretization (parameters.use_discontinuous_temperature_discretization),
+    use_discontinuous_composition_discretization (parameters.use_discontinuous_composition_discretization),
+    component_indices (internal::setup_component_indices<dim>(*this)),
+    n_blocks (FEVariableCollection<dim>::n_blocks()),
+    block_indices (internal::setup_blocks<dim>(*this)),
+    extractors (component_indices),
+    base_elements (internal::setup_base_elements<dim>(*this)),
+    polynomial_degree (internal::setup_polynomial_degree<dim>(parameters)),
+    quadratures (internal::setup_quadratures<dim>(parameters, ReferenceCells::get_hypercube<dim>())),
+    face_quadratures (internal::setup_face_quadratures<dim>(parameters, ReferenceCells::get_hypercube<dim>())),
+    component_masks (*this, component_indices),
+    system_dofs_per_block (n_blocks),
+    temperature_method(parameters.temperature_method),
+    compositional_field_methods(parameters.compositional_field_methods),
+    composition_names(parameters.names_of_compositional_fields),
+    composition_descriptions(parameters.composition_descriptions),
+    composition_names_for_type(CompositionalFieldDescription::n_types),
+    composition_indices_for_type(CompositionalFieldDescription::n_types)
+  {
+    // Set up the indices for the different types of compositional fields
+    for (unsigned int c=0; c<composition_descriptions.size(); ++c)
+      {
+        composition_indices_for_type[composition_descriptions[c].type].push_back(c);
+        composition_names_for_type[composition_descriptions[c].type].push_back(composition_names[c]);
+      }
+
+    // Fill composition_base_element_indices
+    {
+      if (this->n_compositional_fields > 0)
+        {
+          // We are assigning base elements in order, so the first compositional field
+          // gives us the first base element index. Then we find the largest index
+          // in the vector. This is necessary, because the fields could have type A,B,A.
+          const unsigned int first = this->base_elements.compositional_fields[0];
+          const unsigned int last = *std::max_element(this->base_elements.compositional_fields.begin(),
+                                                      this->base_elements.compositional_fields.end());
+
+          composition_base_element_indices.resize(last-first+1);
+          std::iota(composition_base_element_indices.begin(), composition_base_element_indices.end(), first);
+        }
+    }
+
+// Fill compositional_field_indices_with_base_element
+    {
+      for (const auto base_element_index : composition_base_element_indices)
+        {
+          std::vector<unsigned int> result;
+
+          unsigned int idx = 0;
+          for (const auto base_idx : this->base_elements.compositional_fields)
+            {
+              if (base_idx == base_element_index)
+                result.emplace_back(idx);
+              ++idx;
+            }
+
+          Assert(result.size() > 0, ExcInternalError("There should be at least one compositional field for a valid base element."));
+          compositional_field_indices_with_base_element[base_element_index] = result;
+        }
+    }
+
+  }
+
+
+
+  template <int dim>
+  Introspection<dim>::~Introspection ()
+    = default;
+
+
+
+  namespace
+  {
+    std::vector<FEValuesExtractors::Scalar>
+    make_extractor_sequence (const std::vector<unsigned int> &compositional_fields)
+    {
+      std::vector<FEValuesExtractors::Scalar> x;
+      x.reserve(compositional_fields.size());
+      for (const unsigned int compositional_field : compositional_fields)
+        x.emplace_back(compositional_field);
+      return x;
+    }
+  }
+
+
+
+  template <int dim>
+  Introspection<dim>::Extractors::Extractors (const Introspection<dim>::ComponentIndices &component_indices)
+    :
+    velocities (component_indices.velocities[0]),
+    pressure (component_indices.pressure),
+    temperature (component_indices.temperature),
+    compositional_fields (make_extractor_sequence (component_indices.compositional_fields))
+  {}
+
+
+
+  namespace
+  {
+    template <int dim>
+    std::vector<ComponentMask>
+    make_composition_component_mask_sequence (const FEVariableCollection<dim> &fevs, const typename Introspection<dim>::ComponentIndices &indices)
+    {
+      std::vector<ComponentMask> result;
+      for (const unsigned int idx : indices.compositional_fields)
+        {
+          result.push_back(ComponentMask(fevs.n_components(), false));
+          result.back().set(idx, true);
+        }
+      return result;
+    }
+  }
+
+
+
+  template <int dim>
+  Introspection<dim>::ComponentMasks::ComponentMasks (const FEVariableCollection<dim> &fevs, const Introspection<dim>::ComponentIndices &indices)
+    :
+    velocities (fevs.variable("velocity").component_mask),
+    pressure (fevs.variable("pressure").component_mask),
+    temperature (fevs.variable("temperature").component_mask),
+    compositional_fields (make_composition_component_mask_sequence (fevs, indices))
+  {}
+
+
+
+  template <int dim>
+  const std::vector<unsigned int> &
+  Introspection<dim>::get_composition_base_element_indices() const
+  {
+    return composition_base_element_indices;
+  }
+
+
+
+  template <int dim>
+  const std::vector<unsigned int> &
+  Introspection<dim>::get_compositional_field_indices_with_base_element(const unsigned int base_element_index) const
+  {
+    Assert(compositional_field_indices_with_base_element.find(base_element_index)
+           != compositional_field_indices_with_base_element.end(),
+           ExcMessage("Invalid base_element_index specified."));
+    return compositional_field_indices_with_base_element.find(base_element_index)->second;
+  }
+
+
+
+  template <int dim>
+  unsigned int
+  Introspection<dim>::compositional_index_for_name (const std::string &name) const
+  {
+    const std::vector<std::string>::const_iterator
+    it = std::find(composition_names.begin(), composition_names.end(), name);
+    AssertThrow (it != composition_names.end(),
+                 ExcMessage ("The compositional field " + name +
+                             " you asked for is not used in the simulation."));
+
+    return (it - composition_names.begin());
+  }
+
+
+
+  template <int dim>
+  std::string
+  Introspection<dim>::name_for_compositional_index (const unsigned int index) const
+  {
+    // make sure that what we get here is really an index of one of the compositional fields
+    AssertIndexRange(index,composition_names.size());
+    return composition_names[index];
+  }
+
+
+
+  template <int dim>
+  const std::vector<std::string> &
+  Introspection<dim>::get_composition_names () const
+  {
+    // Simply return the full list of composition names
+    return composition_names;
+  }
+
+
+
+  template <int dim>
+  const std::vector<CompositionalFieldDescription> &
+  Introspection<dim>::get_composition_descriptions () const
+  {
+    return composition_descriptions;
+  }
+
+
+
+  template <int dim>
+  const std::vector<std::string> &
+  Introspection<dim>::chemical_composition_field_names () const
+  {
+    return get_names_for_fields_of_type(CompositionalFieldDescription::chemical_composition);
+  }
+
+
+
+  template <int dim>
+  const std::vector<unsigned int> &
+  Introspection<dim>::chemical_composition_field_indices () const
+  {
+    return get_indices_for_fields_of_type(CompositionalFieldDescription::chemical_composition);
+  }
+
+
+
+  template <int dim>
+  unsigned int
+  Introspection<dim>::n_chemical_composition_fields () const
+  {
+    return get_number_of_fields_of_type(CompositionalFieldDescription::Type::chemical_composition);
+  }
+
+
+
+  template <int dim>
+  bool
+  Introspection<dim>::composition_type_exists (const CompositionalFieldDescription::Type &type) const
+  {
+    Assert(type < composition_indices_for_type.size(), ExcInternalError());
+
+    return composition_indices_for_type[type].size() > 0;
+  }
+
+
+
+  template <int dim>
+  unsigned int
+  Introspection<dim>::find_composition_type (const typename CompositionalFieldDescription::Type &type) const
+  {
+    Assert(type < composition_indices_for_type.size(), ExcInternalError());
+
+    if (composition_indices_for_type[type].size() > 0)
+      return composition_indices_for_type[type][0];
+
+    return composition_descriptions.size();
+  }
+
+
+
+  template <int dim>
+  bool
+  Introspection<dim>::compositional_name_exists (const std::string &name) const
+  {
+    return (std::find(composition_names.begin(), composition_names.end(), name) != composition_names.end()
+            ?
+            true
+            :
+            false);
+  }
+
+
+
+  template <int dim>
+  const std::vector<unsigned int> &
+  Introspection<dim>::get_indices_for_fields_of_type (const CompositionalFieldDescription::Type &type) const
+  {
+    Assert(type < composition_indices_for_type.size(), ExcInternalError());
+    return composition_indices_for_type[type];
+  }
+
+
+
+  template <int dim>
+  const std::vector<std::string> &
+  Introspection<dim>::get_names_for_fields_of_type (const CompositionalFieldDescription::Type &type) const
+  {
+    Assert(type < composition_names_for_type.size(), ExcInternalError());
+    return composition_names_for_type[type];
+  }
+
+
+
+  template <int dim>
+  unsigned int
+  Introspection<dim>::get_number_of_fields_of_type (const CompositionalFieldDescription::Type &type) const
+  {
+    Assert(type < composition_indices_for_type.size(), ExcInternalError());
+    return composition_indices_for_type[type].size();
+  }
+
+
+
+  template <int dim>
+  bool
+  Introspection<dim>::is_stokes_component (const unsigned int component_index) const
+  {
+    if (component_index == component_indices.pressure)
+      return true;
+
+    for (unsigned int i=0; i<dim; ++i)
+      if (component_index == component_indices.velocities[i])
+        return true;
+
+    return false;
+  }
+
+
+
+  template <int dim>
+  bool
+  Introspection<dim>::is_composition_component (const unsigned int component_index) const
+  {
+    // All compositions live at the end. Just to be sure, there are no other components
+    // in our system after compositional fields, right?
+    Assert(component_indices.compositional_fields[0] > component_indices.temperature
+           && component_indices.compositional_fields.back() == n_components-1, ExcInternalError());
+
+    if (component_index >= component_indices.compositional_fields[0])
+      return true;
+    else
+      return false;
+  }
+
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template struct Introspection<dim>; \
+  template \
+  std::vector<VariableDeclaration<dim>> \
+  construct_default_variables (const Parameters<dim> &parameters);
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/lateral_averaging.cc.bak b/source/simulator/lateral_averaging.cc.bak
new file mode 100644
index 00000000000..3b1218c80ec
--- /dev/null
+++ b/source/simulator/lateral_averaging.cc.bak
@@ -0,0 +1,972 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/lateral_averaging.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/quadrature_lib.h>
+
+
+
+namespace aspect
+{
+  /**
+   * This namespace contains all the implemented functors. They are used to
+   * compute various properties of the solution that will be laterally averaged.
+   */
+  namespace
+  {
+    template <int dim>
+    class FunctorDepthAverageField: public internal::FunctorBase<dim>
+    {
+      public:
+        FunctorDepthAverageField(const FEValuesExtractors::Scalar &field)
+          : field_(field)
+        {}
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
+                        const MaterialModel::MaterialModelOutputs<dim> &,
+                        const FEValues<dim> &fe_values,
+                        const LinearAlgebra::BlockVector &solution,
+                        std::vector<double> &output) override
+        {
+          fe_values[field_].get_function_values (solution, output);
+        }
+
+        const FEValuesExtractors::Scalar field_;
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageAdiabat: public internal::FunctorBase<dim>
+    {
+      public:
+        enum Property
+        {
+          temperature,
+          pressure,
+          density,
+          density_derivative
+        } property;
+
+
+
+        FunctorDepthAverageAdiabat(const Property &property,
+                                   const AdiabaticConditions::Interface<dim> &adiabat)
+          : property(property),
+            adiabat(adiabat)
+        {}
+
+
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
+                        const MaterialModel::MaterialModelOutputs<dim> &,
+                        const FEValues<dim> &fe_values,
+                        const LinearAlgebra::BlockVector &,
+                        std::vector<double> &output) override
+        {
+          const unsigned int n_quadrature_points = output.size();
+          for (unsigned int i=0; i<n_quadrature_points; ++i)
+            {
+              if (property == Property::temperature)
+                output[i] = adiabat.temperature(fe_values.quadrature_point(i));
+              else if (property == Property::pressure)
+                output[i] = adiabat.pressure(fe_values.quadrature_point(i));
+              else if (property == Property::density)
+                output[i] = adiabat.density(fe_values.quadrature_point(i));
+              else if (property == Property::density_derivative)
+                output[i] = adiabat.density_derivative(fe_values.quadrature_point(i));
+              else
+                AssertThrow(false, ExcNotImplemented());
+            }
+        }
+
+        const AdiabaticConditions::Interface<dim> &adiabat;
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageViscosity: public internal::FunctorBase<dim>
+    {
+      public:
+        bool need_material_properties() const override
+        {
+          return true;
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
+                        const MaterialModel::MaterialModelOutputs<dim> &out,
+                        const FEValues<dim> &,
+                        const LinearAlgebra::BlockVector &,
+                        std::vector<double> &output) override
+        {
+          output = out.viscosities;
+        }
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageLogViscosity: public internal::FunctorBase<dim>
+    {
+      public:
+        bool need_material_properties() const override
+        {
+          return true;
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
+                        const MaterialModel::MaterialModelOutputs<dim> &out,
+                        const FEValues<dim> &,
+                        const LinearAlgebra::BlockVector &,
+                        std::vector<double> &output) override
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          for (unsigned i = 0; i < n_points; ++i)
+            output[i] = std::log10 (out.viscosities[i]);
+        }
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageVelocityMagnitude: public internal::FunctorBase<dim>
+    {
+      public:
+        FunctorDepthAverageVelocityMagnitude(const FEValuesExtractors::Vector &field,
+                                             bool convert_to_years)
+          : field_(field), convert_to_years_(convert_to_years)
+        {}
+
+        void setup(const unsigned int q_points) override
+        {
+          velocity_values.resize(q_points);
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
+                        const MaterialModel::MaterialModelOutputs<dim> &,
+                        const FEValues<dim> &fe_values,
+                        const LinearAlgebra::BlockVector &solution,
+                        std::vector<double> &output) override
+        {
+          fe_values[field_].get_function_values (solution, velocity_values);
+          for (unsigned int q=0; q<output.size(); ++q)
+            output[q] = std::sqrt( velocity_values[q] * velocity_values[q] ) *
+                        (convert_to_years_ ? year_in_seconds : 1.0);
+        }
+
+        std::vector<Tensor<1,dim>> velocity_values;
+        const FEValuesExtractors::Vector field_;
+        const bool convert_to_years_;
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageSinkingVelocity: public internal::FunctorBase<dim>
+    {
+      public:
+        FunctorDepthAverageSinkingVelocity(const FEValuesExtractors::Vector &field,
+                                           const GravityModel::Interface<dim> *gravity,
+                                           bool convert_to_years)
+          : field_(field),
+            gravity_(gravity),
+            convert_to_years_(convert_to_years)
+        {}
+
+        bool need_material_properties() const override
+        {
+          // this is needed because we want to access in.position in operator()
+          return true;
+        }
+
+        void setup(const unsigned int q_points) override
+        {
+          velocity_values.resize(q_points);
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &in,
+                        const MaterialModel::MaterialModelOutputs<dim> &,
+                        const FEValues<dim> &fe_values,
+                        const LinearAlgebra::BlockVector &solution,
+                        std::vector<double> &output) override
+        {
+          fe_values[field_].get_function_values (solution, velocity_values);
+          for (unsigned int q=0; q<output.size(); ++q)
+            {
+              const Tensor<1,dim> g = gravity_->gravity_vector(in.position[q]);
+              const Tensor<1,dim> vertically_down = (g.norm() > 0 ? g/g.norm() : Tensor<1,dim>());
+
+              output[q] = std::max(0.0, velocity_values[q] * vertically_down)
+                          * (convert_to_years_ ? year_in_seconds : 1.0);
+            }
+        }
+
+        std::vector<Tensor<1,dim>> velocity_values;
+        const FEValuesExtractors::Vector field_;
+        const GravityModel::Interface<dim> *gravity_;
+        const bool convert_to_years_;
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageRisingVelocity: public internal::FunctorBase<dim>
+    {
+      public:
+        FunctorDepthAverageRisingVelocity(const FEValuesExtractors::Vector &field,
+                                          const GravityModel::Interface<dim> *gravity,
+                                          bool convert_to_years)
+          : field_(field),
+            gravity_(gravity),
+            convert_to_years_(convert_to_years)
+        {}
+
+        bool need_material_properties() const override
+        {
+          // this is needed because we want to access in.position in operator()
+          return true;
+        }
+
+        void setup(const unsigned int q_points) override
+        {
+          velocity_values.resize(q_points);
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &in,
+                        const MaterialModel::MaterialModelOutputs<dim> &,
+                        const FEValues<dim> &fe_values,
+                        const LinearAlgebra::BlockVector &solution,
+                        std::vector<double> &output) override
+        {
+          fe_values[field_].get_function_values (solution, velocity_values);
+          for (unsigned int q=0; q<output.size(); ++q)
+            {
+              const Tensor<1,dim> g = gravity_->gravity_vector(in.position[q]);
+              const Tensor<1,dim> vertically_up = (g.norm() > 0 ? -g/g.norm() : Tensor<1,dim>());
+
+              output[q] = std::max(0.0, velocity_values[q] * vertically_up)
+                          * (convert_to_years_ ? year_in_seconds : 1.0);
+            }
+        }
+
+        std::vector<Tensor<1,dim>> velocity_values;
+        const FEValuesExtractors::Vector field_;
+        const GravityModel::Interface<dim> *gravity_;
+        const bool convert_to_years_;
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageVsVp: public internal::FunctorBase<dim>
+    {
+      public:
+        FunctorDepthAverageVsVp(bool vs)
+          : vs_(vs)
+        {}
+
+        bool need_material_properties() const override
+        {
+          return true;
+        }
+
+        void
+        create_additional_material_model_outputs (const unsigned int n_points,
+                                                  MaterialModel::MaterialModelOutputs<dim> &outputs) const override
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
+                        const MaterialModel::MaterialModelOutputs<dim> &out,
+                        const FEValues<dim> &,
+                        const LinearAlgebra::BlockVector &,
+                        std::vector<double> &output) override
+        {
+          const MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
+            = out.template get_additional_output<const MaterialModel::SeismicAdditionalOutputs<dim>>();
+
+          Assert(seismic_outputs != nullptr,ExcInternalError());
+
+          if (vs_)
+            for (unsigned int q=0; q<output.size(); ++q)
+              output[q] = seismic_outputs->vs[q];
+          else
+            for (unsigned int q=0; q<output.size(); ++q)
+              output[q] = seismic_outputs->vp[q];
+        }
+
+        bool vs_;
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageVerticalHeatFlux: public internal::FunctorBase<dim>
+    {
+      public:
+        FunctorDepthAverageVerticalHeatFlux(const FEValuesExtractors::Vector &velocity_field,
+                                            const FEValuesExtractors::Scalar &temperature_field,
+                                            const GravityModel::Interface<dim> *gm)
+          : velocity_field_(velocity_field),
+            temperature_field_(temperature_field),
+            gravity_model(gm)
+        {}
+
+        bool need_material_properties() const override
+        {
+          return true;
+        }
+
+        void setup(const unsigned int q_points) override
+        {
+          velocity_values.resize(q_points);
+          temperature_values.resize(q_points);
+          temperature_gradients.resize(q_points);
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &in,
+                        const MaterialModel::MaterialModelOutputs<dim> &out,
+                        const FEValues<dim> &fe_values,
+                        const LinearAlgebra::BlockVector &solution,
+                        std::vector<double> &output) override
+        {
+          fe_values[velocity_field_].get_function_values (solution, velocity_values);
+          fe_values[temperature_field_].get_function_values (solution, temperature_values);
+          fe_values[temperature_field_].get_function_gradients (solution, temperature_gradients);
+
+          for (unsigned int q=0; q<output.size(); ++q)
+            {
+              const Tensor<1,dim> gravity = gravity_model->gravity_vector(in.position[q]);
+              const Tensor<1,dim> vertical = -gravity/( gravity.norm() != 0.0 ?
+                                                        gravity.norm() : 1.0 );
+              const double advective_flux = (velocity_values[q] * vertical) * in.temperature[q] *
+                                            out.densities[q]*out.specific_heat[q];
+              const double conductive_flux = -(temperature_gradients[q]*vertical) *
+                                             out.thermal_conductivities[q];
+              output[q] = advective_flux + conductive_flux;
+            }
+        }
+
+        const FEValuesExtractors::Vector velocity_field_;
+        const FEValuesExtractors::Scalar temperature_field_;
+        const GravityModel::Interface<dim> *gravity_model;
+        std::vector<Tensor<1,dim>> velocity_values;
+        std::vector<Tensor<1,dim>> temperature_gradients;
+        std::vector<double> temperature_values;
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageVerticalMassFlux: public internal::FunctorBase<dim>
+    {
+      public:
+        FunctorDepthAverageVerticalMassFlux(const FEValuesExtractors::Vector &velocity_field,
+                                            const GravityModel::Interface<dim> *gm)
+          : velocity_field_(velocity_field),
+            gravity_model(gm)
+        {}
+
+        bool need_material_properties() const override
+        {
+          return true;
+        }
+
+        void setup(const unsigned int q_points) override
+        {
+          velocity_values.resize(q_points);
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &in,
+                        const MaterialModel::MaterialModelOutputs<dim> &out,
+                        const FEValues<dim> &fe_values,
+                        const LinearAlgebra::BlockVector &solution,
+                        std::vector<double> &output) override
+        {
+          fe_values[velocity_field_].get_function_values (solution, velocity_values);
+
+          for (unsigned int q=0; q<output.size(); ++q)
+            {
+              const Tensor<1,dim> gravity = gravity_model->gravity_vector(in.position[q]);
+              const Tensor<1,dim> vertical = -gravity/( gravity.norm() != 0.0 ?
+                                                        gravity.norm() : 1.0 );
+
+              output[q] = std::fabs(velocity_values[q] * vertical) * out.densities[q];
+            }
+        }
+
+        const FEValuesExtractors::Vector velocity_field_;
+        const GravityModel::Interface<dim> *gravity_model;
+        std::vector<Tensor<1,dim>> velocity_values;
+    };
+
+
+
+    template <int dim>
+    class FunctorDepthAverageFieldMass: public internal::FunctorBase<dim>
+    {
+      public:
+        FunctorDepthAverageFieldMass(const FEValuesExtractors::Scalar &field)
+          : field_(field)
+        {}
+
+        bool need_material_properties() const override
+        {
+          return true;
+        }
+
+        void setup(const unsigned int q_points) override
+        {
+          field_values.resize(q_points);
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
+                        const MaterialModel::MaterialModelOutputs<dim> &out,
+                        const FEValues<dim> &fe_values,
+                        const LinearAlgebra::BlockVector &solution,
+                        std::vector<double> &output) override
+        {
+          fe_values[field_].get_function_values (solution, field_values);
+
+          for (unsigned int q=0; q<output.size(); ++q)
+            output[q] = field_values[q] * out.densities[q];
+        }
+
+        const FEValuesExtractors::Scalar field_;
+        std::vector<double> field_values;
+    };
+  }
+
+  namespace internal
+  {
+    template <int dim>
+    bool
+    FunctorBase<dim>::need_material_properties() const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    FunctorBase<dim>::~FunctorBase()
+      = default;
+
+
+
+    template <int dim>
+    void
+    FunctorBase<dim>::create_additional_material_model_outputs (const unsigned int /*n_points*/,
+                                                                MaterialModel::MaterialModelOutputs<dim> &/*outputs*/) const
+    {}
+
+
+
+    template <int dim>
+    void
+    FunctorBase<dim>::setup(const unsigned int /*q_points*/)
+    {}
+
+    template <int dim>
+    QAnisotropic<dim>
+    get_quadrature_formula(const unsigned int lateral_quadrature_degree,
+                           const unsigned int depth_dimension);
+
+    template <>
+    QAnisotropic<3>
+    get_quadrature_formula(const unsigned int lateral_quadrature_degree,
+                           const unsigned int depth_dimension)
+    {
+      const unsigned int dim = 3;
+
+      if (depth_dimension == dim)
+        return QAnisotropic<dim> (QGauss<1>(lateral_quadrature_degree),
+                                  QGauss<1>(lateral_quadrature_degree),
+                                  QIterated<1>(QMidpoint<1>(),10));
+      else if (depth_dimension == 1)
+        return QAnisotropic<dim> (QIterated<1>(QMidpoint<1>(),10),
+                                  QGauss<1>(lateral_quadrature_degree),
+                                  QGauss<1>(lateral_quadrature_degree));
+
+      return QAnisotropic<dim>(QGauss<1>(lateral_quadrature_degree),
+                               QGauss<1>(lateral_quadrature_degree),
+                               QIterated<1>(QMidpoint<1>(),10));
+    }
+
+    template <>
+    QAnisotropic<2>
+    get_quadrature_formula(const unsigned int lateral_quadrature_degree,
+                           const unsigned int depth_dimension)
+    {
+      const unsigned int dim = 2;
+
+      if (depth_dimension == dim)
+        return QAnisotropic<dim> (QGauss<1>(lateral_quadrature_degree),
+                                  QIterated<1>(QMidpoint<1>(),10));
+      else if (depth_dimension == 1)
+        return QAnisotropic<dim> (QIterated<1>(QMidpoint<1>(),10),
+                                  QGauss<1>(lateral_quadrature_degree));
+
+      return QAnisotropic<dim>(QGauss<1>(lateral_quadrature_degree),
+                               QIterated<1>(QMidpoint<1>(),10));
+    }
+  }
+
+
+
+  template <int dim>
+  std::vector<std::vector<double>>
+  LateralAveraging<dim>::compute_lateral_averages(const std::vector<double> &depth_bounds,
+                                                  std::vector<std::unique_ptr<internal::FunctorBase<dim>>> &functors) const
+  {
+    Assert (functors.size() > 0,
+            ExcMessage ("To call this function, you need to request a positive "
+                        "number of properties to compute."));
+    Assert (depth_bounds.size() > 1,
+            ExcMessage ("To call this function, you need to request at least two "
+                        "depth boundaries."));
+    Assert(std::is_sorted(depth_bounds.begin(),depth_bounds.end()),
+           ExcMessage ("To call this function the depth boundaries need to be ordered "
+                       "with increasing depth."));
+
+    const unsigned int n_properties = functors.size();
+    const unsigned int n_slices = depth_bounds.size()-1;
+
+    std::vector<std::vector<double>> values(n_properties,
+                                             std::vector<double>(n_slices,0.0));
+    std::vector<double> volume(n_slices,0.0);
+
+    // We would like to use a quadrature formula that is appropriately accurate laterally,
+    // but has a higher resolution in depth (to have values for all depth slices, even if there
+    // are adaptively coarsened cells that are much bigger than individual slices).
+    // For that we need to know the depth direction in the unit cell coordinate system, which
+    // is only unique (= the same for all cells) in some geometries. In these geometries we
+    // can optimize the quadrature, otherwise we need to use a high-resolution quadrature in
+    // all directions, which is more expensive.
+    // The Chunk geometry model has depth as first dimension (radius, lon, lat),
+    // all others with unique direction have it last; however, the Chunk and
+    // EllipsoidalChunk geometry have not been successfully tested with
+    // the lower quadrature, so we leave it at the conservative quadrature for now.
+
+    unsigned int geometry_unique_depth_direction;
+    if (Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
+        Plugins::plugin_type_matches<GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) ||
+        Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()))
+      geometry_unique_depth_direction = dim;
+    else if (Plugins::plugin_type_matches<GeometryModel::Chunk<dim>>(this->get_geometry_model()) ||
+             Plugins::plugin_type_matches<GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()))
+      geometry_unique_depth_direction = numbers::invalid_unsigned_int;
+    else
+      geometry_unique_depth_direction = numbers::invalid_unsigned_int;
+
+    const unsigned int max_fe_degree = std::max(this->introspection().polynomial_degree.velocities,
+                                                std::max(this->introspection().polynomial_degree.temperature,
+                                                         this->introspection().polynomial_degree.compositional_fields));
+
+    // We want to integrate over a polynomial of degree p = max_fe_degree, for which we
+    // need a quadrature of at least q, with p <= 2q-1 --> q >= (p+1)/2
+    const unsigned int lateral_quadrature_degree = static_cast<unsigned int>(std::ceil((max_fe_degree+1.0)/2.0));
+
+    std::unique_ptr<Quadrature<dim>> quadrature_formula;
+    if (geometry_unique_depth_direction != numbers::invalid_unsigned_int)
+      quadrature_formula = std::make_unique<Quadrature<dim>>(internal::get_quadrature_formula<dim>(lateral_quadrature_degree,
+                                                              geometry_unique_depth_direction));
+    else
+      quadrature_formula = std::make_unique<Quadrature<dim>>(QIterated<dim>(QMidpoint<1>(),10));
+
+    const unsigned int n_q_points = quadrature_formula->size();
+
+    FEValues<dim> fe_values (this->get_mapping(),
+                             this->get_fe(),
+                             *quadrature_formula,
+                             update_values | update_gradients | update_quadrature_points | update_JxW_values);
+
+    std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),
+                                                          std::vector<double> (n_q_points));
+    std::vector<std::vector<double>> output_values(n_properties,
+                                                    std::vector<double>(n_q_points));
+
+    MaterialModel::MaterialModelInputs<dim> in(n_q_points,
+                                               this->n_compositional_fields());
+    MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
+                                                 this->n_compositional_fields());
+
+    bool functors_need_material_output = false;
+    for (unsigned int i=0; i<n_properties; ++i)
+      {
+        functors[i]->setup(n_q_points);
+        if (functors[i]->need_material_properties())
+          functors_need_material_output = true;
+
+        functors[i]->create_additional_material_model_outputs(n_q_points,out);
+      }
+
+    for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+
+          if (functors_need_material_output)
+            {
+              // get the material properties at each quadrature point if necessary
+              in.reinit(fe_values,
+                        cell,
+                        this->introspection(),
+                        this->get_solution());
+              this->get_material_model().evaluate(in, out);
+            }
+
+          for (unsigned int i = 0; i < n_properties; ++i)
+            (*functors[i])(in, out, fe_values, this->get_solution(), output_values[i]);
+
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            {
+              const double depth = this->get_geometry_model().depth(fe_values.quadrature_point(q));
+
+              if (depth < depth_bounds.front() || depth > depth_bounds.back())
+                continue;
+
+              // This makes sure depth == front() and depth == back() are handled correctly.
+              // lower_bound returns the first layer boundary larger than depth, the correct
+              // layer index is then one less than this (except for depth == depth_bounds[0],
+              // in which case the depth_bounds index is also the layer_index, namely 0).
+              unsigned int layer_index = std::distance(depth_bounds.begin(),
+                                                       std::lower_bound(depth_bounds.begin(),depth_bounds.end(),depth));
+              if (layer_index > 0)
+                layer_index -= 1;
+
+              Assert(layer_index<n_slices, ExcInternalError());
+
+              for (unsigned int i = 0; i < n_properties; ++i)
+                values[i][layer_index] += output_values[i][q] * fe_values.JxW(q);
+
+              volume[layer_index] += fe_values.JxW(q);
+            }
+        }
+
+    std::vector<double> volume_all(n_slices);
+    Utilities::MPI::sum(volume, this->get_mpi_communicator(), volume_all);
+
+    bool print_under_res_warning=false;
+    for (unsigned int property=0; property<n_properties; ++property)
+      {
+        std::vector<double> values_all(n_slices);
+        Utilities::MPI::sum(values[property], this->get_mpi_communicator(), values_all);
+
+        for (unsigned int i=0; i<n_slices; ++i)
+          {
+            if (volume_all[i] > 0.0)
+              {
+                values[property][i] = values_all[i] / (static_cast<double>(volume_all[i]));
+              }
+            else
+              {
+                print_under_res_warning = true;
+                // Output nan if no quadrature points in depth block
+                values[property][i] = std::numeric_limits<double>::quiet_NaN();
+              }
+          }
+      }
+
+    if (print_under_res_warning)
+      {
+        this->get_pcout() << std::endl
+                          << "**** Warning: When computing depth averages, there is at least one depth band"
+                          << std::endl
+                          << "     that does not have any quadrature points in it."
+                          << std::endl
+                          << "     Consider reducing the number of depth layers for averaging."
+                          << std::endl << std::endl;
+      }
+
+    return values;
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_temperature_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"temperature"))[0];
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_composition_averages(const unsigned int c,
+                                                       std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"C_" + Utilities::int_to_string(c)))[0];
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_viscosity_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"viscosity"))[0];
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_log_viscosity_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"log_viscosity"))[0];
+  }
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_velocity_magnitude_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"velocity_magnitude"))[0];
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_sinking_velocity_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"sinking_velocity"))[0];
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_rising_velocity_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"rising_velocity"))[0];
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_Vs_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"Vs"))[0];
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_Vp_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"Vp"))[0];
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_vertical_heat_flux_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"vertical_heat_flux"))[0];
+  }
+
+
+
+  template <int dim>
+  void LateralAveraging<dim>::get_vertical_mass_flux_averages(std::vector<double> &values) const
+  {
+    values = compute_lateral_averages(values.size(),
+                                      std::vector<std::string>(1,"vertical_mass_flux"))[0];
+  }
+
+
+
+  template <int dim>
+  std::vector<std::vector<double>>
+  LateralAveraging<dim>::get_averages(const unsigned int n_slices,
+                                      const std::vector<std::string> &property_names) const
+  {
+    return compute_lateral_averages(n_slices, property_names);
+  }
+
+
+
+  template <int dim>
+  std::vector<std::vector<double>>
+  LateralAveraging<dim>::compute_lateral_averages(const unsigned int n_slices,
+                                                  const std::vector<std::string> &property_names) const
+  {
+    const double maximal_depth = this->get_geometry_model().maximal_depth();
+    std::vector<double> depth_bounds(n_slices+1, 0.0);
+
+    // Leave index 0 at 0.0, and generate an increasing range of equidistant depth bounds
+    for (unsigned int i=1; i<depth_bounds.size(); ++i)
+      depth_bounds[i] = depth_bounds[i-1] + maximal_depth / n_slices;
+
+    return compute_lateral_averages(depth_bounds, property_names);
+  }
+
+
+
+  template <int dim>
+  std::vector<std::vector<double>>
+  LateralAveraging<dim>::compute_lateral_averages(const std::vector<double> &depth_thresholds,
+                                                  const std::vector<std::string> &property_names) const
+  {
+    std::vector<std::unique_ptr<internal::FunctorBase<dim>>> functors;
+    for (const auto &property_name : property_names)
+      {
+        if (property_name == "temperature")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageField<dim>>
+                               (this->introspection().extractors.temperature));
+          }
+        else if (this->introspection().compositional_name_exists(property_name))
+          {
+            const unsigned int c =
+              this->introspection().compositional_index_for_name(property_name);
+
+            functors.push_back(std::make_unique<FunctorDepthAverageField<dim>> (
+                                 this->introspection().extractors.compositional_fields[c]));
+          }
+        else if (property_name == "velocity_magnitude")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageVelocityMagnitude<dim>>
+                               (this->introspection().extractors.velocities,
+                                this->convert_output_to_years()));
+          }
+        else if (property_name == "sinking_velocity")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageSinkingVelocity<dim>>
+                               (this->introspection().extractors.velocities,
+                                &this->get_gravity_model(),
+                                this->convert_output_to_years()));
+          }
+        else if (property_name == "rising_velocity")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageRisingVelocity<dim>>
+                               (this->introspection().extractors.velocities,
+                                &this->get_gravity_model(),
+                                this->convert_output_to_years()));
+          }
+        else if (property_name == "Vs")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageVsVp<dim>> (true /* Vs */));
+          }
+        else if (property_name == "Vp")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageVsVp<dim>> (false /* Vp */));
+          }
+        else if (property_name == "viscosity")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageViscosity<dim>>());
+          }
+        else if (property_name == "log_viscosity")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageLogViscosity<dim>>());
+          }
+        else if (property_name == "vertical_heat_flux")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageVerticalHeatFlux<dim>>
+                               (this->introspection().extractors.velocities,
+                                this->introspection().extractors.temperature,
+                                &this->get_gravity_model()));
+          }
+        else if (property_name == "vertical_mass_flux")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageVerticalMassFlux<dim>>
+                               (this->introspection().extractors.velocities,
+                                &this->get_gravity_model()));
+          }
+        else if (this->introspection().compositional_name_exists(property_name.substr(0, property_name.size()-5)) &&
+                 property_name.substr(property_name.size()-5) == "_mass")
+          {
+            const unsigned int c =
+              this->introspection().compositional_index_for_name(property_name.substr(0, property_name.size()-5));
+
+            functors.push_back(std::make_unique<FunctorDepthAverageFieldMass<dim>> (
+                                 this->introspection().extractors.compositional_fields[c]));
+          }
+        else if (property_name == "adiabatic_temperature")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageAdiabat<dim>>
+                               (FunctorDepthAverageAdiabat<dim>::temperature,
+                                this->get_adiabatic_conditions()));
+          }
+        else if (property_name == "adiabatic_pressure")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageAdiabat<dim>>
+                               (FunctorDepthAverageAdiabat<dim>::pressure,
+                                this->get_adiabatic_conditions()));
+          }
+        else if (property_name == "adiabatic_density")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageAdiabat<dim>>
+                               (FunctorDepthAverageAdiabat<dim>::density,
+                                this->get_adiabatic_conditions()));
+          }
+        else if (property_name == "adiabatic_density_derivative")
+          {
+            functors.push_back(std::make_unique<FunctorDepthAverageAdiabat<dim>>
+                               (FunctorDepthAverageAdiabat<dim>::density_derivative,
+                                this->get_adiabatic_conditions()));
+          }
+        else
+          {
+            AssertThrow(false,
+                        ExcMessage("The lateral averaging scheme was asked to average the property "
+                                   "named <" + property_name + ">, but it does not know how "
+                                   "to do that. There is no functor implemented that computes this property."));
+          }
+      }
+
+    // Now compute values for all selected properties.
+    return compute_lateral_averages(depth_thresholds, functors);
+  }
+}
+
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template class LateralAveraging<dim>; \
+  namespace internal \
+  { \
+    template class FunctorBase<dim>; \
+  }
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/limiters.cc.bak b/source/simulator/limiters.cc.bak
new file mode 100644
index 00000000000..bce8fba5b4a
--- /dev/null
+++ b/source/simulator/limiters.cc.bak
@@ -0,0 +1,876 @@
+#include <aspect/simulator.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/mesh_deformation/interface.h>
+
+namespace aspect
+{
+  template <int dim>
+  void
+  Simulator<dim>::apply_BP_limiter_to_dg_solutions(const AdvectionField &advection_field)
+  {
+    // TODO: Modify to more robust method
+    // Skip if this composition field is being set from the volume_of_fluid handler
+    if (!advection_field.is_temperature() &&
+        parameters.volume_of_fluid_tracking_enabled)
+      if (volume_of_fluid_handler->field_index_for_name(introspection.name_for_compositional_index(advection_field.compositional_variable))
+          != volume_of_fluid_handler->get_n_fields())
+        return;
+
+    /*
+     * First setup the quadrature points which are used to find the maximum and minimum solution values at those points.
+     * A quadrature formula that combines all quadrature points constructed as all tensor products of
+     * 1) one dimensional Gauss points; 2) one dimensional Gauss-Lobatto points.
+     * We require that the Gauss-Lobatto points (2) appear in only one direction.
+     * Therefore, possible combination
+     * in 2d: the combinations are 21, 12
+     * in 3d: the combinations are 211, 121, 112
+     */
+    const QGauss<1> quadrature_formula_1 (advection_field.polynomial_degree(introspection)+1);
+    const QGaussLobatto<1> quadrature_formula_2 (advection_field.polynomial_degree(introspection)+1);
+
+    const unsigned int n_q_points_1 = quadrature_formula_1.size();
+    const unsigned int n_q_points_2 = quadrature_formula_2.size();
+    const unsigned int n_q_points   = dim * n_q_points_2 * static_cast<unsigned int>(std::pow(n_q_points_1, dim-1));
+
+    std::vector<Point <dim>> quadrature_points;
+    quadrature_points.reserve(n_q_points);
+
+    switch (dim)
+      {
+        case 2:
+        {
+          // append quadrature points combination 12
+          for (unsigned int i=0; i < n_q_points_1 ; ++i)
+            {
+              const double  x = quadrature_formula_1.point(i)(0);
+              for (unsigned int j=0; j < n_q_points_2 ; ++j)
+                {
+                  const double y = quadrature_formula_2.point(j)(0);
+                  quadrature_points.push_back(Point<dim>(x,y));
+                }
+            }
+          // append quadrature points combination 21
+          for (unsigned int i=0; i < n_q_points_2 ; ++i)
+            {
+              const double  x = quadrature_formula_2.point(i)(0);
+              for (unsigned int j=0; j < n_q_points_1 ; ++j)
+                {
+                  const double y = quadrature_formula_1.point(j)(0);
+                  quadrature_points.push_back(Point<dim>(x,y));
+                }
+            }
+          break;
+        }
+
+        case 3:
+        {
+          // append quadrature points combination 121
+          for ( unsigned int i=0; i < n_q_points_1 ; ++i)
+            {
+              const double x = quadrature_formula_1.point(i)(0);
+              for ( unsigned int j=0; j < n_q_points_2 ; ++j)
+                {
+                  const double y = quadrature_formula_2.point(j)(0);
+                  for ( unsigned int k=0; k < n_q_points_1 ; ++k)
+                    {
+                      const double z = quadrature_formula_1.point(k)(0);
+                      quadrature_points.push_back(Point<dim>(x,y,z));
+                    }
+                }
+            }
+          // append quadrature points combination 112
+          for (unsigned int i=0; i < n_q_points_1 ; ++i)
+            {
+              const double x = quadrature_formula_1.point(i)(0);
+              for (unsigned int j=0; j < n_q_points_1 ; ++j)
+                {
+                  const double y = quadrature_formula_1.point(j)(0);
+                  for (unsigned int k=0; k < n_q_points_2 ; ++k)
+                    {
+                      const double z = quadrature_formula_2.point(k)(0);
+                      quadrature_points.push_back(Point<dim>(x,y,z));
+                    }
+                }
+            }
+          // append quadrature points combination 211
+          for (unsigned int i=0; i < n_q_points_2 ; ++i)
+            {
+              const double x = quadrature_formula_2.point(i)(0);
+              for ( unsigned int j=0; j < n_q_points_1 ; ++j)
+                {
+                  const double y = quadrature_formula_1.point(j)(0);
+                  for ( unsigned int k=0; k < n_q_points_1 ; ++k)
+                    {
+                      const double z = quadrature_formula_1.point(k)(0);
+                      quadrature_points.push_back(Point<dim>(x,y,z));
+                    }
+                }
+            }
+          break;
+        }
+
+        default:
+          Assert (false, ExcNotImplemented());
+      }
+
+    Assert (quadrature_points.size() == n_q_points, ExcInternalError());
+    const Quadrature<dim> quadrature_formula(quadrature_points);
+
+    // Quadrature rules only used for the numerical integration for better accuracy
+    const Quadrature<dim> &quadrature_formula_0
+      = (advection_field.is_temperature() ?
+         introspection.quadratures.temperature :
+         introspection.quadratures.compositional_fields);
+    const unsigned int n_q_points_0 = quadrature_formula_0.size();
+
+    // fe values for points evaluation
+    FEValues<dim> fe_values (*mapping,
+                             finite_element,
+                             quadrature_formula,
+                             update_values   |
+                             update_quadrature_points);
+    std::vector<double> values (n_q_points);
+    // fe values for numerical integration, with a number of quadrature points
+    // that is equal to 1/dim times the number of total points above
+    FEValues<dim> fe_values_0 (*mapping,
+                               finite_element,
+                               quadrature_formula_0,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+    std::vector<double> values_0 (n_q_points_0);
+
+    const FEValuesExtractors::Scalar field
+      = (advection_field.is_temperature()
+         ?
+         introspection.extractors.temperature
+         :
+         introspection.extractors.compositional_fields[advection_field.compositional_variable]
+        );
+
+    const double max_solution_exact_global = (advection_field.is_temperature()
+                                              ?
+                                              parameters.global_temperature_max_preset
+                                              :
+                                              parameters.global_composition_max_preset[advection_field.compositional_variable]
+                                             );
+    const double min_solution_exact_global = (advection_field.is_temperature()
+                                              ?
+                                              parameters.global_temperature_min_preset
+                                              :
+                                              parameters.global_composition_min_preset[advection_field.compositional_variable]
+                                             );
+
+    LinearAlgebra::BlockVector distributed_solution (introspection.index_sets.system_partitioning,
+                                                     mpi_communicator);
+    const unsigned int block_idx = advection_field.block_index(introspection);
+    distributed_solution.block(block_idx) = solution.block(block_idx);
+
+    std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          cell->get_dof_indices (local_dof_indices);
+          // used to find the maximum, minimum
+          fe_values.reinit (cell);
+          fe_values[field].get_function_values(solution, values);
+          // used for the numerical integration
+          fe_values_0.reinit (cell);
+          fe_values_0[field].get_function_values(solution, values_0);
+
+          // Find the local max and local min
+          const double min_solution_local = *std::min_element (values.begin(), values.end());
+          const double max_solution_local = *std::max_element (values.begin(), values.end());
+          // Find the trouble cell
+          if (min_solution_local < min_solution_exact_global
+              || max_solution_local > max_solution_exact_global)
+            {
+              // Compute the cell area and cell solution average
+              double local_area = 0.0;
+              double local_solution_average = 0.0;
+              for (unsigned int q = 0; q < n_q_points_0; ++q)
+                {
+                  local_area += fe_values_0.JxW(q);
+                  local_solution_average += values_0[q]*fe_values_0.JxW(q);
+                }
+              local_solution_average /= local_area;
+
+              /*
+               * Define theta: a scaling constant used to correct the old solution by the formula
+               *   new_value = theta * (old_value-old_solution_cell_average)+old_solution_cell_average
+               * where theta \in [0,1] defined as below.
+               * After the correction, the new solution does not exceed the user-given
+               * exact global maximum/minimum values. Meanwhile, the new solution's cell average
+               * equals to the old solution's cell average.
+               */
+              double theta = 1.0;
+              if (std::abs(max_solution_local-local_solution_average) > std::numeric_limits<double>::min())
+                {
+                  theta = std::min(theta, std::abs((max_solution_exact_global-local_solution_average)
+                                                   / (max_solution_local-local_solution_average)));
+                }
+              if (std::abs(min_solution_local-local_solution_average) > std::numeric_limits<double>::min())
+                {
+                  theta = std::min(theta, std::abs((min_solution_exact_global-local_solution_average)
+                                                   / (min_solution_local-local_solution_average)));
+                }
+
+              /* Modify the advection degrees of freedom of the numerical solution.
+               * Note that we are using DG elements, so every DoF on a locally owned cell is locally owned;
+               * this means that we do not need to check whether the 'distributed_solution' vector actually
+               * stores the element we read from/write to here.
+               */
+              for (unsigned int j = 0;
+                   j < finite_element.base_element(advection_field.base_element(introspection)).dofs_per_cell;
+                   ++j)
+                {
+                  const unsigned int support_point_index = finite_element.component_to_system_index(
+                                                             (advection_field.is_temperature()
+                                                              ?
+                                                              introspection.component_indices.temperature
+                                                              :
+                                                              introspection.component_indices.compositional_fields[advection_field.compositional_variable]
+                                                             ),
+                                                             /*dof index within component=*/ j);
+                  const double solution_value = solution(local_dof_indices[support_point_index]);
+                  const double limited_solution_value = theta * (solution_value-local_solution_average) + local_solution_average;
+                  distributed_solution(local_dof_indices[support_point_index]) = limited_solution_value;
+                }
+            }
+        }
+
+    distributed_solution.compress(VectorOperation::insert);
+    // now get back to the original vector
+    solution.block(block_idx) = distributed_solution.block(block_idx);
+  }
+
+
+
+  namespace internal
+  {
+    struct KXRCFCellData
+    {
+      double cell_norm;
+      double inflow_face_jump;
+      double inflow_face_area;
+
+      KXRCFCellData()
+        : cell_norm(0.0)
+        , inflow_face_jump(0.0)
+        , inflow_face_area(0.0)
+      {}
+    };
+  }
+
+
+  template <int dim>
+  template <typename T>
+  void
+  Simulator<dim>::compute_KXRCF_indicators(Vector<T>            &KXRCF_indicators,
+                                           const AdvectionField &advection_field) const
+  {
+    // stuff for computing the integrals in cells and cell faces
+    QGauss<dim>   quadrature(2);
+    QGauss<dim-1> face_quadrature(2);
+
+    FEValues<dim> fe_values(*mapping,
+                            finite_element,
+                            quadrature,
+                            update_values);
+
+    FEFaceValues<dim> fe_face_values(*mapping,
+                                     finite_element,
+                                     face_quadrature,
+                                     update_values |
+                                     update_normal_vectors |
+                                     update_JxW_values);
+
+    FESubfaceValues<dim> fe_subface_values(*mapping,
+                                           finite_element,
+                                           face_quadrature,
+                                           update_values |
+                                           update_normal_vectors |
+                                           update_JxW_values);
+
+    FEFaceValues<dim> neighbor_fe_face_values(*mapping,
+                                              finite_element,
+                                              face_quadrature,
+                                              update_values |
+                                              update_JxW_values);
+
+    const FEValuesExtractors::Scalar &field_extractor = advection_field.scalar_extractor(introspection);
+
+    const unsigned int n_q_points      = fe_values.n_quadrature_points;
+    const unsigned int n_face_q_points = fe_face_values.n_quadrature_points;
+
+    std::vector<double> field_values(n_q_points);
+    std::vector<double> face_field_values(n_face_q_points);
+    std::vector<double> neighbor_face_field_values(n_face_q_points);
+
+    std::vector<Tensor<1,dim>> face_velocity_values(n_face_q_points);
+    std::vector<Tensor<1,dim>> face_mesh_velocity_values(n_face_q_points);
+
+    // KXRCF indicator requires the computation of (1) cell maximum norm;
+    // (2) integration of the jump over inflow faces of each field. To
+    // avoid doing integration twice on each cell face, we set up a map
+    // to store the cell data and then loop over the cells using the same
+    // strategy as in Assemblers::AdvectionSystemInteriorFace::execute().
+    std::map<unsigned int, internal::KXRCFCellData> data;
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        data.insert(std::make_pair(cell->active_cell_index(),
+                                   internal::KXRCFCellData()));
+
+    // Now loop over locally owned cells and compute the maximum norm
+    // and the jump over inflow faces.
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          auto cell_data = data.find(cell->active_cell_index());
+
+          // Compute the maximum norm of field values in this cell.
+          fe_values.reinit(cell);
+          fe_values[field_extractor].get_function_values(solution, field_values);
+
+          double cell_norm = 0.0;
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            cell_norm = std::max(cell_norm, std::abs(field_values[q]));
+
+          cell_data->second.cell_norm = cell_norm;
+
+          // Compute the jump of field values over inflow faces.
+          for (const unsigned int face_no : cell->face_indices())
+            {
+              if (!cell->at_boundary(face_no) || cell->has_periodic_neighbor(face_no))
+                {
+                  const typename DoFHandler<dim>::cell_iterator
+                  neighbor = cell->neighbor_or_periodic_neighbor(face_no);
+
+                  const bool cell_has_periodic_neighbor = cell->has_periodic_neighbor(face_no);
+
+                  // 'neighbor' defined above is NOT active_cell_iterator, this includes cells
+                  // that are refined
+                  if (!neighbor->has_children())
+                    {
+                      if (neighbor->level() == cell->level() &&
+                          neighbor->is_active() &&
+                          (((neighbor->is_locally_owned()) && (cell->index() < neighbor->index()))
+                           ||
+                           ((!neighbor->is_locally_owned()) && (cell->subdomain_id() < neighbor->subdomain_id()))))
+                        {
+                          // cell and neighbor are equal-sized, and cell has been chosen to
+                          // assemble this face, so calculate from cell
+                          const unsigned int neighbor2 =
+                            (cell_has_periodic_neighbor
+                             ?
+                             cell->periodic_neighbor_of_periodic_neighbor(face_no)
+                             :
+                             cell->neighbor_of_neighbor(face_no));
+
+                          auto neighbor_data = data.find(neighbor->active_cell_index());
+
+                          // Set up face values.
+                          fe_face_values.reinit(cell, face_no);
+                          fe_face_values[field_extractor].get_function_values(solution, face_field_values);
+
+                          fe_face_values[introspection.extractors.velocities].get_function_values(
+                            solution, face_velocity_values);
+                          if (parameters.mesh_deformation_enabled)
+                            fe_face_values[introspection.extractors.velocities].get_function_values(
+                              mesh_deformation->mesh_velocity, face_mesh_velocity_values);
+
+                          // Set up neighbor face values.
+                          neighbor_fe_face_values.reinit(neighbor, neighbor2);
+                          neighbor_fe_face_values[field_extractor].get_function_values(solution, neighbor_face_field_values);
+
+                          const double face_area = cell->face(face_no)->measure();
+
+                          double v_n = 0.0;
+                          double face_jump = 0.0;
+                          for (unsigned int q = 0; q < n_face_q_points; ++q)
+                            {
+                              Tensor<1,dim> current_u = face_velocity_values[q];
+                              if (parameters.mesh_deformation_enabled)
+                                current_u -= face_mesh_velocity_values[q];
+
+                              v_n += (current_u * fe_face_values.normal_vector(q)) * fe_face_values.JxW(q);
+
+                              face_jump += (face_field_values[q] - neighbor_face_field_values[q]) * fe_face_values.JxW(q);
+                            }
+
+                          if (v_n < 0.0) // inflow
+                            {
+                              cell_data->second.inflow_face_jump += face_jump;
+                              cell_data->second.inflow_face_area += face_area;
+                            }
+                          else // outflow
+                            {
+                              if (neighbor_data != data.end())
+                                {
+                                  neighbor_data->second.inflow_face_jump -= face_jump;
+                                  neighbor_data->second.inflow_face_area += face_area;
+                                }
+                            }
+
+                        }
+                      else
+                        {
+                          // Neighbor is taking responsibility for assembly of this face, because
+                          // either (1) neighbor is coarser, or
+                          //        (2) neighbor is equally-sized and
+                          //           (a) neighbor is on a different subdomain, with lower subdomain_id(), or
+                          //           (b) neighbor is on the same subdomain and has lower index().
+                        }
+                    }
+                  else
+                    {
+                      // Neighbor has children, so always assemble from here.
+                      const unsigned int neighbor2 =
+                        (cell_has_periodic_neighbor
+                         ?
+                         cell->periodic_neighbor_face_no(face_no)
+                         :
+                         cell->neighbor_face_no(face_no));
+
+                      // Loop over subfaces. We know that the neighbor is finer, so we could loop over the subfaces of the current
+                      // face. but if we are at a periodic boundary, then the face of the current cell has no children, so instead use
+                      // the children of the periodic neighbor's corresponding face since we know that the letter does indeed have
+                      // children (because we know that the neighbor is refined).
+                      typename DoFHandler<dim>::face_iterator neighbor_face = neighbor->face(neighbor2);
+                      for (unsigned int subface_no = 0; subface_no < neighbor_face->n_children(); ++subface_no)
+                        {
+                          const typename DoFHandler<dim>::active_cell_iterator neighbor_child =
+                            (cell_has_periodic_neighbor
+                             ?
+                             cell->periodic_neighbor_child_on_subface(face_no, subface_no)
+                             :
+                             cell->neighbor_child_on_subface(face_no, subface_no));
+
+                          auto neighbor_data = data.find(neighbor_child->active_cell_index());
+
+                          // Set up subface values.
+                          fe_subface_values.reinit(cell, face_no, subface_no);
+                          fe_subface_values[field_extractor].get_function_values(solution, face_field_values);
+
+                          fe_subface_values[introspection.extractors.velocities].get_function_values(
+                            solution, face_velocity_values);
+                          if (parameters.mesh_deformation_enabled)
+                            fe_subface_values[introspection.extractors.velocities].get_function_values(
+                              mesh_deformation->mesh_velocity, face_mesh_velocity_values);
+
+                          neighbor_fe_face_values.reinit(neighbor_child, neighbor2);
+                          neighbor_fe_face_values[field_extractor].get_function_values(solution, neighbor_face_field_values);
+
+                          const double face_area = neighbor_child->face(neighbor2)->measure();
+
+                          double v_n = 0.0;
+                          double face_jump = 0.0;
+                          for (unsigned int q = 0; q < n_face_q_points; ++q)
+                            {
+                              Tensor<1,dim> current_u = face_velocity_values[q];
+                              if (parameters.mesh_deformation_enabled)
+                                current_u -= face_mesh_velocity_values[q];
+
+                              v_n += (current_u * fe_subface_values.normal_vector(q)) * fe_subface_values.JxW(q);
+
+                              face_jump += (face_field_values[q] - neighbor_face_field_values[q]) * fe_subface_values.JxW(q);
+                            }
+
+                          if (v_n < 0.0) // inflow
+                            {
+                              cell_data->second.inflow_face_jump += face_jump;
+                              cell_data->second.inflow_face_area += face_area;
+                            }
+                          else // outflow
+                            {
+                              if (neighbor_data != data.end())
+                                {
+                                  neighbor_data->second.inflow_face_jump -= face_jump;
+                                  neighbor_data->second.inflow_face_area += face_area;
+                                }
+                            }
+                        }
+                    }
+                }
+              else
+                {
+                  // The current face is a boundary face.
+                }
+            }
+        }
+
+    // Finally, compute the KXRCF indicator and pick the largest one as
+    // troubled cell indicator.
+    const unsigned int degree = advection_field.polynomial_degree(introspection);
+    const double power = (degree + 1.0) / 2.0;
+    const double scaling_factor = 1. / global_Omega_diameter;
+
+    const unsigned int block_idx = advection_field.block_index(introspection);
+    const double epsilon = std::max(1e-20,
+                                    1e-3 * (solution.block(block_idx).max() - solution.block(block_idx).min()));
+
+    KXRCF_indicators.reinit(triangulation.n_active_cells());
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          // The characteristic mesh spacing is calculated by d/D, where
+          // d and D are the diameters of the present cell and the geometry
+          // model, respectively.
+          const double h_pow = std::pow(cell->diameter() * scaling_factor, power);
+          const auto cell_data = data.find(cell->active_cell_index());
+          if (cell_data->second.inflow_face_area == 0.0)
+            KXRCF_indicators[cell->active_cell_index()] = 0.0;
+          else
+            KXRCF_indicators[cell->active_cell_index()] =
+              std::abs(cell_data->second.inflow_face_jump) /
+              (h_pow * cell_data->second.inflow_face_area * (cell_data->second.cell_norm + epsilon));
+        }
+  }
+
+
+  template <int dim>
+  void
+  Simulator<dim>::apply_WENO_limiter_to_dg_solutions(const AdvectionField &advection_field)
+  {
+    // Skip if this composition field is being set from the volume_of_fluid handler
+    if (!advection_field.is_temperature() &&
+        parameters.volume_of_fluid_tracking_enabled)
+      if (volume_of_fluid_handler->field_index_for_name(introspection.name_for_compositional_index(advection_field.compositional_variable))
+          != volume_of_fluid_handler->get_n_fields())
+        return;
+
+    const unsigned int degree = advection_field.polynomial_degree(introspection);
+    AssertThrow(degree < 3,
+                ExcMessage("Currently, WENO limiter has only been implemented for "
+                           "advection fields with polynomial degree 1 or 2."));
+
+    // We need two objects of FEValues in the following computation:
+    // fe_values: computes the cell average and smoothness indicator of the target cell,
+    //   and provides the coordinates and JxWs of the quadrature points of the target
+    //   cell when computing the smoothness indicators of neighbor cells;
+    // neighbor_fe_values: computes the cell averages and field derivatives of
+    //   neighbor cells at quadrature points of the target cell. With the derivatives
+    //   at hand, we can use the JxWs provided by fe_values to compute the smoothness
+    //   indicators of neighbor cells.
+    // The coordinates of quadrature points of neighbor_fe_values change from cell to
+    // cell since the mesh may not be Cartesian, hence neighbor_fe_values has to be
+    // reconstructed in each cell.
+    Quadrature<dim> quadrature(advection_field.is_temperature() ?
+                               introspection.quadratures.temperature :
+                               introspection.quadratures.compositional_fields);
+
+    UpdateFlags update_flags = update_values | update_gradients |
+                               update_quadrature_points | update_JxW_values |
+                               (degree > 1 ? update_hessians : update_default);
+
+    UpdateFlags neighbor_update_flags = update_values | update_gradients |
+                                        (degree > 1 ? update_hessians : update_default);
+
+    FEValues<dim> fe_values(*mapping, finite_element, quadrature, update_flags);
+
+    const unsigned int n_q_points          = fe_values.n_quadrature_points;
+    const unsigned int field_dofs_per_cell = finite_element.base_element(advection_field.base_element(introspection)).dofs_per_cell;
+    const unsigned int field_component     = advection_field.component_index(introspection);
+
+    const FEValuesExtractors::Scalar &field_extractor = advection_field.scalar_extractor(introspection);
+
+    std::vector<double>        field_values(n_q_points);
+    std::vector<Tensor<1,dim>> field_gradients(n_q_points);
+    std::vector<Tensor<2,dim>> field_hessians(n_q_points);
+
+    std::vector<Point<dim>> neighbor_quadrature_points(n_q_points);
+
+    std::vector<double> reconstructed_values(n_q_points);
+
+    std::vector<double> cell_averages;
+    std::vector<double> smoothness_indicators;
+    std::vector<double> linear_weights;
+    std::vector<double> nonlinear_weights;
+    std::vector<std::vector<double>> field_values_in_target_cell;
+
+    // stuff for projecting the reconstructed polynomial onto grid nodes
+    FullMatrix<double> cell_matrix(field_dofs_per_cell, field_dofs_per_cell);
+    Vector<double> cell_rhs(field_dofs_per_cell);
+    Vector<double> cell_solution(field_dofs_per_cell);
+    std::vector<double> phi_field(field_dofs_per_cell);
+    std::vector<types::global_dof_index> cell_dof_indices(finite_element.dofs_per_cell);
+
+    // Detect troubled cells with KXRCF indicator.
+    Vector<double> KXRCF_indicators;
+    compute_KXRCF_indicators(KXRCF_indicators, advection_field);
+
+    TrilinosWrappers::MPI::BlockVector distributed_solution(introspection.index_sets.system_partitioning,
+                                                            mpi_communicator);
+
+    const unsigned int block_idx = advection_field.block_index(introspection);
+    distributed_solution.block(block_idx) = solution.block(block_idx);
+
+    const double KXRCF_indicator_threshold = (advection_field.is_temperature() ?
+                                              parameters.temperature_KXRCF_indicator_threshold :
+                                              parameters.composition_KXRCF_indicator_threshold[advection_field.compositional_variable]);
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          // If the KXRCF indicator of the present cell is lower than the threshold,
+          // then we do not have to do WENO reconstruction for the cell.
+          if (KXRCF_indicators[cell->active_cell_index()] < KXRCF_indicator_threshold)
+            continue;
+
+          cell_averages.clear();
+          smoothness_indicators.clear();
+          field_values_in_target_cell.clear();
+          linear_weights.clear();
+
+          // Compute the field values and derivatives at quadrature points.
+          fe_values.reinit(cell);
+          fe_values[field_extractor].get_function_values(solution, field_values);
+          fe_values[field_extractor].get_function_gradients(solution, field_gradients);
+          if (degree > 1)
+            fe_values[field_extractor].get_function_hessians(solution, field_hessians);
+
+          // Compute the cell average and the smoothness indicator.
+          double cell_measure                   = 0.0;
+          double field_integral                 = 0.0;
+          double field_gradient_square_integral = 0.0;
+          double field_hessian_square_integral  = 0.0;
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            {
+              cell_measure += fe_values.JxW(q);
+              field_integral += field_values[q] * fe_values.JxW(q);
+
+              field_gradient_square_integral += field_gradients[q].norm_square() * fe_values.JxW(q);
+              if (degree > 1)
+                field_hessian_square_integral += field_hessians[q].norm_square() * fe_values.JxW(q);
+            }
+
+          double beta = field_gradient_square_integral;
+          if (degree > 1)
+            beta += field_hessian_square_integral * cell_measure;
+
+          cell_averages.push_back(field_integral / cell_measure);
+          smoothness_indicators.push_back(beta);
+          field_values_in_target_cell.push_back(field_values);
+          // Linear weight of the target cell cannot be determined at present time
+          // (because we don't know how many neighbors the target cell has). Fill in
+          // the position with an invalid value.
+          linear_weights.push_back(numbers::signaling_nan<double>());
+
+          // Loop over the neighbor cells.
+          for (const unsigned int face_no : cell->face_indices())
+            {
+              if (cell->face(face_no)->at_boundary())
+                continue;
+
+              const typename DoFHandler<dim>::cell_iterator
+              neighbor = cell->neighbor_or_periodic_neighbor(face_no);
+
+              // 'neighbor' defined above is NOT active_cell_iterator, this includes cells
+              // that are refined
+              if (!neighbor->has_children())
+                {
+                  // Compute the field values at quadrature points of the neighbor.
+
+                  // Compute the field derivatives at quadrature points of the target cell.
+                  // To do so, we need to transform the quadrature points of the target cell
+                  // to the 'unit cell' defined by the neighbor.
+                  mapping->transform_points_real_to_unit_cell(neighbor,
+                                                              fe_values.get_quadrature_points(),
+                                                              neighbor_quadrature_points);
+
+                  Quadrature<dim> neighbor_quadrature(neighbor_quadrature_points,
+                                                      quadrature.get_weights());
+
+                  FEValues<dim> neighbor_fe_values(*mapping,
+                                                   finite_element,
+                                                   neighbor_quadrature,
+                                                   neighbor_update_flags);
+
+                  neighbor_fe_values.reinit(neighbor);
+                  neighbor_fe_values[field_extractor].get_function_values(solution, field_values);
+                  neighbor_fe_values[field_extractor].get_function_gradients(solution, field_gradients);
+                  if (degree > 1)
+                    neighbor_fe_values[field_extractor].get_function_hessians(solution, field_hessians);
+
+                  // Compute the cell average and the smoothness indicator.
+                  double field_integral                 = 0.0;
+                  double field_gradient_square_integral = 0.0;
+                  double field_hessian_square_integral  = 0.0;
+                  for (unsigned int q = 0; q < n_q_points; ++q)
+                    {
+                      field_integral += field_values[q] * fe_values.JxW(q);
+                      field_gradient_square_integral += field_gradients[q].norm_square() * fe_values.JxW(q);
+                      if (degree > 1)
+                        field_hessian_square_integral += field_hessians[q].norm_square() * fe_values.JxW(q);
+                    }
+
+                  double beta = field_gradient_square_integral;
+                  if (degree > 1)
+                    beta += field_hessian_square_integral * cell_measure;
+
+                  cell_averages.push_back(field_integral / cell_measure);
+                  smoothness_indicators.push_back(beta);
+                  field_values_in_target_cell.push_back(field_values);
+                  linear_weights.push_back(parameters.WENO_linear_weight);
+                }
+              else
+                {
+                  // Neighbor has children. We use a half of the children that are adjacent to
+                  // the target cell (i.e., children that share a face with the target cell) to
+                  // compute the cell average and smoothness indicator.
+                  const unsigned int neighbor_face_no =
+                    (cell->has_periodic_neighbor(face_no)
+                     ?
+                     cell->periodic_neighbor_face_no(face_no)
+                     :
+                     cell->neighbor_face_no(face_no));
+
+                  typename DoFHandler<dim>::face_iterator neighbor_face = neighbor->face(neighbor_face_no);
+                  for (unsigned int subface_no = 0; subface_no < neighbor_face->n_children(); ++subface_no)
+                    {
+                      const unsigned int child_no =
+                        GeometryInfo<dim>::child_cell_on_face(RefinementCase<dim>::isotropic_refinement,
+                                                              neighbor_face_no,
+                                                              subface_no,
+                                                              neighbor->face_orientation(face_no),
+                                                              neighbor->face_flip(face_no),
+                                                              neighbor->face_rotation(face_no));
+
+                      typename DoFHandler<dim>::active_cell_iterator
+                      neighbor_child = neighbor->child(child_no);
+
+                      // Compute the field derivatives at quadrature points of the target cell.
+                      // To do so, we need to transform the quadrature points of the target cell
+                      // to the 'unit cell' defined by the neighbor.
+                      mapping->transform_points_real_to_unit_cell(neighbor_child,
+                                                                  fe_values.get_quadrature_points(),
+                                                                  neighbor_quadrature_points);
+
+                      Quadrature<dim> neighbor_quadrature(neighbor_quadrature_points,
+                                                          quadrature.get_weights());
+
+                      FEValues<dim> neighbor_fe_values(*mapping,
+                                                       finite_element,
+                                                       neighbor_quadrature,
+                                                       neighbor_update_flags);
+
+                      neighbor_fe_values.reinit(neighbor_child);
+                      neighbor_fe_values[field_extractor].get_function_values(solution, field_values);
+                      neighbor_fe_values[field_extractor].get_function_gradients(solution, field_gradients);
+                      if (degree > 1)
+                        neighbor_fe_values[field_extractor].get_function_hessians(solution, field_hessians);
+
+                      // Compute the cell average and the smoothness indicator.
+                      double field_integral                 = 0.0;
+                      double field_gradient_square_integral = 0.0;
+                      double field_hessian_square_integral  = 0.0;
+                      for (unsigned int q = 0; q < n_q_points; ++q)
+                        {
+                          field_integral += field_values[q] * fe_values.JxW(q);
+                          field_gradient_square_integral += field_gradients[q].norm_square() * fe_values.JxW(q);
+                          if (degree > 1)
+                            field_hessian_square_integral += field_hessians[q].norm_square() * fe_values.JxW(q);
+                        }
+
+                      double beta = field_gradient_square_integral;
+                      if (degree > 1)
+                        beta += field_hessian_square_integral * cell_measure;
+
+                      cell_averages.push_back(field_integral / cell_measure);
+                      smoothness_indicators.push_back(beta);
+                      field_values_in_target_cell.push_back(field_values);
+                      linear_weights.push_back(parameters.WENO_linear_weight / neighbor_face->n_children());
+                    }
+                }
+            }
+
+          // Compute the linear weights of the target cell.
+          linear_weights[0] = 1.0;
+          for (unsigned int i = 1; i < linear_weights.size(); ++i)
+            linear_weights[0] -= linear_weights[i];
+
+          // Compute the nonlinear weights.
+          const double epsilon = 1e-6 * std::accumulate(smoothness_indicators.begin(),
+                                                        smoothness_indicators.end(),
+                                                        0.0);
+          nonlinear_weights.clear();
+          for (unsigned int i = 0; i < linear_weights.size(); ++i)
+            nonlinear_weights.push_back(linear_weights[i] /
+                                        Utilities::fixed_power<2,double>(smoothness_indicators[i] + epsilon));
+
+          // Normalize the nonlinear weights.
+          const double sum = std::accumulate(nonlinear_weights.begin(),
+                                             nonlinear_weights.end(),
+                                             0.0);
+
+          for (unsigned int i = 0; i < nonlinear_weights.size(); ++i)
+            nonlinear_weights[i] /= sum;
+
+          // Compute the values of the reconstructed polynomial at quadrature points.
+          std::fill(reconstructed_values.begin(), reconstructed_values.end(), 0.0);
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            for (unsigned int i = 0; i < nonlinear_weights.size(); ++i)
+              reconstructed_values[q] += (field_values_in_target_cell[i][q] - cell_averages[i] + cell_averages[0]) * nonlinear_weights[i];
+
+          // Project the reconstructed polynomial onto grid nodes.
+          cell_matrix = 0;
+          cell_rhs = 0;
+          for (unsigned int q = 0; q < n_q_points; ++q)
+            {
+              for (unsigned int i = 0, i_field = 0; i_field < field_dofs_per_cell; /*increment at end of loop*/)
+                {
+                  if (finite_element.system_to_component_index(i).first == field_component)
+                    {
+                      phi_field[i_field] = fe_values[field_extractor].value(i, q);
+                      ++i_field;
+                    }
+                  ++i;
+                }
+
+              for (unsigned int i = 0; i < field_dofs_per_cell; ++i)
+                {
+                  cell_rhs(i) += phi_field[i] * reconstructed_values[q] * fe_values.JxW(q);
+
+                  for (unsigned int j = 0; j < field_dofs_per_cell; ++j)
+                    cell_matrix(i, j) += phi_field[i] * phi_field[j] * fe_values.JxW(q);
+                }
+            }
+
+          cell_matrix.gauss_jordan();
+          cell_matrix.vmult(cell_solution, cell_rhs);
+
+          // Copy the results to the distributed solution vector.
+          cell->get_dof_indices(cell_dof_indices);
+          for (unsigned int i = 0, i_field = 0; i_field < field_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (finite_element.system_to_component_index(i).first == field_component)
+                {
+                  distributed_solution[cell_dof_indices[i]] = cell_solution(i_field);
+                  ++i_field;
+                }
+              ++i;
+            }
+        }
+
+    // Update the solution vector.
+    distributed_solution.compress(VectorOperation::insert);
+    solution.block(block_idx) = distributed_solution.block(block_idx);
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+
+#define INSTANTIATE(dim) \
+  template void Simulator<dim>::apply_BP_limiter_to_dg_solutions(const AdvectionField &advection_field); \
+  template void Simulator<dim>::compute_KXRCF_indicators(Vector<double> &, \
+                                                         const AdvectionField &) const; \
+  template void Simulator<dim>::compute_KXRCF_indicators(Vector<float> &, \
+                                                         const AdvectionField &) const; \
+  template void Simulator<dim>::apply_WENO_limiter_to_dg_solutions(const AdvectionField &advection_field);
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/melt.cc.bak b/source/simulator/melt.cc.bak
new file mode 100644
index 00000000000..eef4deeb9c7
--- /dev/null
+++ b/source/simulator/melt.cc.bak
@@ -0,0 +1,1960 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+#include <aspect/citation_info.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/simulator/assemblers/advection.h>
+#include <deal.II/base/signaling_nan.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/lac/sparsity_tools.h>
+
+#include <deal.II/fe/fe_q.h>
+#include <deal.II/fe/fe_dgp.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/work_stream.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/grid/filtered_iterator.h>
+#include <deal.II/grid/grid_tools.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    MeltInputs<dim>::MeltInputs (const unsigned int n_points)
+      :
+      compaction_pressures(n_points, numbers::signaling_nan<double>()),
+      fluid_velocities(n_points, numbers::signaling_nan<Tensor<1,dim>>())
+    {}
+
+
+
+    template <int dim>
+    void MeltInputs<dim>::fill (const LinearAlgebra::BlockVector &solution,
+                                const FEValuesBase<dim>          &fe_values,
+                                const Introspection<dim>         &introspection)
+    {
+      compaction_pressures.resize(fe_values.n_quadrature_points);
+      fluid_velocities.resize(fe_values.n_quadrature_points, Tensor<1,dim>());
+
+      const FEValuesExtractors::Vector ex_u_f = introspection.variable("fluid velocity").extractor_vector();
+      fe_values[ex_u_f].get_function_values (solution, fluid_velocities);
+
+      const FEValuesExtractors::Scalar ex_p_c = introspection.variable("compaction pressure").extractor_scalar();
+      fe_values[ex_p_c].get_function_values (solution, compaction_pressures);
+    }
+
+
+
+    template <int dim>
+    void MeltOutputs<dim>::average (const MaterialAveraging::AveragingOperation operation,
+                                    const FullMatrix<double>  &projection_matrix,
+                                    const FullMatrix<double>  &expansion_matrix)
+    {
+      average_property (operation, projection_matrix, expansion_matrix,
+                        compaction_viscosities);
+      average_property (operation, projection_matrix, expansion_matrix,
+                        fluid_viscosities);
+      average_property (operation, projection_matrix, expansion_matrix,
+                        permeabilities);
+      average_property (operation, projection_matrix, expansion_matrix,
+                        fluid_densities);
+
+      // The fluid density gradients are unfortunately stored in reverse
+      // indexing and averaging is not implemented for tensors (only for
+      // doubles). It's also not quite clear whether these should
+      // really be averaged, so avoid this for now
+    }
+
+
+
+    template <int dim>
+    double
+    MeltInterface<dim>::p_c_scale (const MaterialModel::MaterialModelInputs<dim> &inputs,
+                                   const MaterialModel::MaterialModelOutputs<dim> &outputs,
+                                   const MeltHandler<dim> &melt_handler,
+                                   const bool consider_is_melt_cell) const
+    {
+      Assert(inputs.current_cell.state() == IteratorState::valid,
+             ExcMessage("You are trying to access the property of a cell (if it is "
+                        "a melt cell or not), but the cell iterator in the provided material "
+                        "model inputs does not point to a cell."));
+
+      if (consider_is_melt_cell && !melt_handler.is_melt_cell(inputs.current_cell))
+        return 0.0;
+
+      const MaterialModel::MeltOutputs<dim> *melt_outputs = outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+      const double ref_K_D = this->reference_darcy_coefficient();
+
+      double K_D = 0.0;
+      double max_K_D = 0.0;
+      const unsigned int N = melt_outputs->permeabilities.size();
+      for (unsigned int q=0; q<N; ++q)
+        {
+          K_D += std::max(melt_outputs->permeabilities[q], 0.0) / (melt_outputs->fluid_viscosities[q] * N);
+          max_K_D = std::max(max_K_D, melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q]);
+        }
+
+      // For melt cells, we return the average Darcy coefficient of the cell,
+      // but always a value larger than a threshold depending on the reference Darcy coefficient,
+      // so that K_D can never be zero (or close to zero) in melt cells.
+      // The same threshold is used when computing which cells are melt cells (the else branch),
+      // with the difference that we return a p_c_scale of zero to indicate that the cell is not
+      // a melt cell if the maximum Darcy coefficient of the cell is below the threshold.
+      const double K_D_threshold = melt_handler.melt_parameters.melt_scaling_factor_threshold;
+      if (consider_is_melt_cell)
+        K_D = std::max(K_D, K_D_threshold * ref_K_D);
+      else
+        K_D = (max_K_D < K_D_threshold * ref_K_D) ? 0.0 : K_D;
+
+      // If the reference permeability is set to zero, there is no melt transport in the whole model and we return zero.
+      return (ref_K_D > 0 ? std::sqrt(K_D / ref_K_D) : 0.0);
+    }
+  }
+
+
+
+  namespace Assemblers
+  {
+    namespace
+    {
+      template <int dim>
+      bool
+      is_velocity_or_pressures (const Introspection<dim> &introspection,
+                                const unsigned int p_c_component_index,
+                                const unsigned int p_f_component_index,
+                                const unsigned int component_index)
+      {
+        if (component_index == p_c_component_index)
+          return true;
+
+        if (component_index == p_f_component_index)
+          return true;
+
+        for (unsigned int i=0; i<dim; ++i)
+          if (component_index == introspection.component_indices.velocities[i])
+            return true;
+
+        return false;
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    MeltInterface<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      MeltHandler<dim>::create_material_model_outputs(outputs);
+
+      if (this->get_parameters().enable_additional_stokes_rhs
+          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>(outputs.n_evaluation_points()));
+        }
+
+      Assert(!this->get_parameters().enable_additional_stokes_rhs
+             ||
+             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
+             == outputs.n_evaluation_points(), ExcInternalError());
+    }
+
+
+
+    template <int dim>
+    void
+    MeltStokesPreconditioner<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int   stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int   n_q_points      = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      Assert(Plugins::plugin_type_matches<const MaterialModel::MeltInterface<dim>>(this->get_material_model()),
+             ExcMessage("Error: The current material model needs to be derived from MeltInterface to use melt transport."));
+
+      const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(
+                                 this->get_material_model()).p_c_scale(scratch.material_model_inputs,
+                                                                       scratch.material_model_outputs,
+                                                                       this->get_melt_handler(),
+                                                                       true);
+
+      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+
+      const FEValuesExtractors::Scalar ex_p_f = introspection.variable("fluid pressure").extractor_scalar();
+      const FEValuesExtractors::Scalar ex_p_c = introspection.variable("compaction pressure").extractor_scalar();
+
+      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
+      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
+
+      for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+        {
+          const unsigned int component_index_i = fe.system_to_component_index(i).first;
+
+          if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
+            {
+              data.local_dof_indices[i_stokes] = scratch.local_dof_indices[i];
+              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
+              ++i_stokes;
+            }
+          ++i;
+        }
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              const unsigned int component_index_i = fe.system_to_component_index(i).first;
+
+              if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
+                {
+                  scratch.phi_p[i_stokes]       = scratch.finite_element_values[ex_p_f].value (i, q);
+                  scratch.phi_p_c[i_stokes]     = scratch.finite_element_values[ex_p_c].value (i, q);
+                  scratch.grad_phi_p[i_stokes]  = scratch.finite_element_values[ex_p_f].gradient (i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const double eta = scratch.material_model_outputs.viscosities[q];
+          const double one_over_eta = 1. / eta;
+          const double K_D = this->get_melt_handler().limited_darcy_coefficient(melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q],
+                                                                                p_c_scale > 0);
+
+          /*
+            - R = 1/eta M_p + K_D L_p for p
+            S = - (1/eta + 1/viscosity_c)  M_p  for p_c
+          */
+          const double viscosity_c = melt_outputs->compaction_viscosities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+              {
+                if (scratch.dof_component_indices[i] == scratch.dof_component_indices[j])
+                  data.local_matrix(i,j) += ((one_over_eta *
+                                              pressure_scaling *
+                                              pressure_scaling)
+                                             * scratch.phi_p[i] * scratch.phi_p[j]
+                                             +
+                                             (K_D *
+                                              pressure_scaling *
+                                              pressure_scaling) *
+                                             scratch.grad_phi_p[i] *
+                                             scratch.grad_phi_p[j]
+                                             +
+                                             (1./eta + 1./viscosity_c) * p_c_scale * p_c_scale *
+                                             pressure_scaling *
+                                             pressure_scaling *
+                                             (scratch.phi_p_c[i] * scratch.phi_p_c[j])
+                                            )
+                                            * JxW;
+
+                // add S between p_c and p_f
+                data.local_matrix(i,j) +=
+                  (
+                    (p_c_scale * one_over_eta *
+                     pressure_scaling *
+                     pressure_scaling)
+                    * scratch.phi_p[i] * scratch.phi_p_c[j]
+                    +
+                    (p_c_scale * one_over_eta *
+                     pressure_scaling *
+                     pressure_scaling)
+                    * scratch.phi_p_c[i] * scratch.phi_p[j]
+                  )
+                  * JxW;
+              }
+        }
+    }
+
+    namespace
+    {
+      /**
+       * Compute the right-hand side of the fluid pressure equation of the Stokes
+       * system in case the simulation uses melt transport. This includes a term
+       * derived from Darcy's law, a term including the melting rate and a term dependent
+       * on the densities and velocities of fluid and solid.
+       */
+      template <int dim>
+      double
+      compute_fluid_pressure_rhs(const SimulatorAccess<dim> *simulator_access,
+                                 const internal::Assembly::Scratch::StokesSystem<dim> &scratch,
+                                 const unsigned int q_point,
+                                 const double K_D,
+                                 const double operator_split_reaction)
+      {
+        if (!simulator_access->get_parameters().include_melt_transport)
+          return 0.0;
+
+        const Introspection<dim> &introspection = simulator_access->introspection();
+        const MaterialModel::MeltOutputs<dim> *melt_out = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+
+        Assert(melt_out != nullptr, ExcInternalError());
+
+        const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
+        const unsigned int is_compressible = simulator_access->get_material_model().is_compressible();
+
+        const double solid_density    = scratch.material_model_outputs.densities[q_point];
+        const double fluid_density    = melt_out->fluid_densities[q_point];
+        double melting_rate           = scratch.material_model_outputs.reaction_terms[q_point][porosity_index];
+
+        if (simulator_access->get_parameters().use_operator_splitting)
+          melting_rate = (simulator_access->get_timestep() > 0
+                          ?
+                          operator_split_reaction * solid_density / simulator_access->get_timestep()
+                          :
+                          0.0);
+
+        const double solid_compressibility = scratch.material_model_outputs.compressibilities[q_point];
+        const Tensor<1,dim> fluid_density_gradient = melt_out->fluid_density_gradients[q_point];
+        const Tensor<1,dim> current_u = scratch.velocity_values[q_point];
+        const double porosity         = std::max(scratch.material_model_inputs.composition[q_point][porosity_index],0.0);
+
+        const Tensor<1,dim>
+        gravity = simulator_access->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q_point));
+
+        double fluid_pressure_RHS = 0.0;
+
+        // melting term
+        fluid_pressure_RHS -= melting_rate * (1.0/fluid_density - 1.0/solid_density);
+
+        // compression term
+        // The whole expression for the first term on the RHS would be
+        // (u_s \cdot g) (\phi \rho_f \kappa_f + (1 - \phi) \rho_s \kappa_s).
+        // However, we already have the term (u_s \cdot g) \rho_s \kappa_s in the
+        // assembly of the Stokes system without melt. Because of that, we only
+        // need to have -\phi \rho_s \kappa_s here.
+        fluid_pressure_RHS += is_compressible
+                              ?
+                              (current_u * fluid_density_gradient) * porosity / fluid_density
+                              - (current_u * gravity) * porosity * solid_density * solid_compressibility
+                              + K_D * (fluid_density_gradient * gravity)
+                              :
+                              0.0;
+
+        return fluid_pressure_RHS;
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    MeltStokesSystem<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+
+      Assert(Plugins::plugin_type_matches<const MaterialModel::MeltInterface<dim>>(this->get_material_model()),
+             ExcMessage("Error: The current material model needs to be derived from MeltInterface to use melt transport."));
+
+      const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>
+                               (this->get_material_model()).p_c_scale(scratch.material_model_inputs,
+                                                                      scratch.material_model_outputs,
+                                                                      this->get_melt_handler(),
+                                                                      true);
+
+      const FEValuesExtractors::Scalar extractor_pressure = introspection.variable("fluid pressure").extractor_scalar();
+      const FEValuesExtractors::Scalar ex_p_c = introspection.variable("compaction pressure").extractor_scalar();
+
+      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
+      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
+
+      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
+      *force = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
+
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      std::vector<double> reactions(n_q_points, numbers::signaling_nan<double>());
+      const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
+      if (this->get_parameters().use_operator_splitting)
+        scratch.finite_element_values[introspection.extractors.compositional_fields[porosity_index]].get_function_values(this->get_reaction_vector(),
+            reactions);
+
+      for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+        {
+          const unsigned int component_index_i = fe.system_to_component_index(i).first;
+
+          if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
+            {
+              data.local_dof_indices[i_stokes] = scratch.local_dof_indices[i];
+              ++i_stokes;
+            }
+          ++i;
+        }
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              const unsigned int component_index_i = fe.system_to_component_index(i).first;
+
+              if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
+                {
+                  scratch.phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
+                  scratch.phi_p[i_stokes]   = scratch.finite_element_values[extractor_pressure].value (i, q);
+                  scratch.phi_p_c[i_stokes] = scratch.finite_element_values[ex_p_c].value (i, q);
+                  scratch.grad_phi_p[i_stokes] = scratch.finite_element_values[extractor_pressure].gradient (i, q);
+
+                  if (scratch.rebuild_stokes_matrix)
+                    {
+                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+                    }
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          // Viscosity scalar
+          const double eta = (scratch.rebuild_stokes_matrix
+                              ?
+                              scratch.material_model_outputs.viscosities[q]
+                              :
+                              numbers::signaling_nan<double>());
+          const double eta_two_thirds = (scratch.rebuild_stokes_matrix
+                                         ?
+                                         scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0
+                                         :
+                                         numbers::signaling_nan<double>());
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+
+          const double compressibility
+            = (this->get_material_model().is_compressible()
+               ?
+               scratch.material_model_outputs.compressibilities[q]
+               :
+               numbers::signaling_nan<double>() );
+
+          const double density_s = scratch.material_model_outputs.densities[q]; // density of the solid
+
+          const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
+          const double porosity = std::max(scratch.material_model_inputs.composition[q][porosity_index],0.000);
+
+          const double K_D = this->get_melt_handler().limited_darcy_coefficient(melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q],
+                                                                                p_c_scale > 0);
+          const double viscosity_c = melt_outputs->compaction_viscosities[q];
+          const Tensor<1,dim> density_gradient_f = melt_outputs->fluid_density_gradients[q];
+          const double density_f = melt_outputs->fluid_densities[q];
+          const double p_f_RHS = compute_fluid_pressure_rhs(this,
+                                                            scratch,
+                                                            q,
+                                                            K_D,
+                                                            reactions[q]);
+          const double bulk_density = (1.0 - porosity) * density_s + porosity * density_f;
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i) += (
+                                     (bulk_density * gravity * scratch.phi_u[i])
+                                     +
+                                     // add a force to the RHS if present
+                                     (force!=nullptr ?
+                                      (force->rhs_u[q] * scratch.phi_u[i]
+                                       + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i]
+                                       + pressure_scaling * force->rhs_melt_pc[q] * p_c_scale * scratch.phi_p_c[i])
+                                      : 0.0)
+                                     +
+                                     // add the term that results from the compressibility. compared
+                                     // to the manual, this term seems to have the wrong sign, but this
+                                     // is because we negate the entire equation to make sure we get
+                                     // -div(u) as the adjoint operator of grad(p) (see above where
+                                     // we assemble the matrix)
+                                     (this->get_material_model().is_compressible()
+                                      ?
+                                      (pressure_scaling *
+                                       compressibility * density_s *
+                                       (scratch.velocity_values[q] * gravity) *
+                                       scratch.phi_p[i])
+                                      :
+                                      0)
+                                     + pressure_scaling *
+                                     p_f_RHS * scratch.phi_p[i]
+                                     - pressure_scaling *
+                                     K_D * density_f *
+                                     (scratch.grad_phi_p[i] * gravity)
+                                   )
+                                   * JxW;
+
+              if (scratch.rebuild_stokes_matrix)
+                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                  {
+                    data.local_matrix(i,j) += ( (eta * 2.0 * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
+                                                - (eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
+                                                  )
+                                                - (pressure_scaling *
+                                                   scratch.div_phi_u[i] * scratch.phi_p[j])
+                                                // finally the term -div(u). note the negative sign to make this
+                                                // operator adjoint to the grad(p) term
+                                                - (pressure_scaling *
+                                                   scratch.phi_p[i] * scratch.div_phi_u[j])
+                                                +
+                                                (- pressure_scaling * pressure_scaling / viscosity_c * p_c_scale * p_c_scale
+                                                 * scratch.phi_p_c[i] * scratch.phi_p_c[j])
+                                                - pressure_scaling * scratch.div_phi_u[i] * scratch.phi_p_c[j] * p_c_scale
+                                                - pressure_scaling * scratch.phi_p_c[i] * scratch.div_phi_u[j] * p_c_scale
+                                                - K_D * pressure_scaling * pressure_scaling *
+                                                (scratch.grad_phi_p[i] * scratch.grad_phi_p[j])
+                                                + (this->get_material_model().is_compressible()
+                                                   ?
+                                                   K_D * pressure_scaling * pressure_scaling / density_f
+                                                   * scratch.phi_p[i] * (scratch.grad_phi_p[j] * density_gradient_f)
+                                                   :
+                                                   0.0))
+                                              * JxW;
+                  }
+            }
+        }
+
+    }
+
+
+
+    template <int dim>
+    void
+    MeltStokesSystemBoundary<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const unsigned int n_face_q_points = scratch.face_finite_element_values.n_quadrature_points;
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const FEValuesExtractors::Scalar ex_p_f = introspection.variable("fluid pressure").extractor_scalar();
+      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
+      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
+      const bool is_melt_cell = this->get_melt_handler().is_melt_cell(scratch.material_model_inputs.current_cell);
+
+      const typename DoFHandler<dim>::face_iterator face = scratch.face_material_model_inputs.current_cell->face(scratch.face_number);
+
+      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.face_material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+
+      std::vector<double> grad_p_f(n_face_q_points);
+      this->get_melt_handler().get_boundary_fluid_pressure().fluid_pressure_gradient(
+        face->boundary_id(),
+        scratch.face_material_model_inputs,
+        scratch.face_material_model_outputs,
+        scratch.face_finite_element_values.get_normal_vectors(),
+        grad_p_f);
+
+      for (unsigned int q=0; q<n_face_q_points; ++q)
+        {
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.face_finite_element_values.quadrature_point(q));
+          const double density_f = melt_outputs->fluid_densities[q];
+          const double K_D = this->get_melt_handler().limited_darcy_coefficient(melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q],
+                                                                                is_melt_cell);
+
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              const unsigned int component_index_i = fe.system_to_component_index(i).first;
+
+              if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
+                {
+                  // apply the fluid pressure boundary condition
+                  data.local_rhs(i_stokes) += (scratch.face_finite_element_values[ex_p_f].value(i, q)
+                                               * this->get_pressure_scaling() * K_D *
+                                               (density_f
+                                                * (scratch.face_finite_element_values.normal_vector(q) * gravity)
+                                                - grad_p_f[q])
+                                               * scratch.face_finite_element_values.JxW(q));
+                  ++i_stokes;
+                }
+              ++i;
+            }
+        }
+    }
+
+    namespace
+    {
+      /**
+       * Compute the right-hand side for the porosity system.
+       * It includes the melting rate and a term dependent
+       * on the density and velocity.
+       *
+       * This function is implemented in
+       * <code>source/simulator/melt.cc</code>.
+       */
+      template <int dim>
+      double
+      compute_melting_RHS(const SimulatorAccess<dim> *simulator_access,
+                          const internal::Assembly::Scratch::AdvectionSystem<dim>  &scratch,
+                          const unsigned int q_point,
+                          const double divergence_u)
+      {
+        Assert (scratch.material_model_outputs.densities[q_point] > 0,
+                ExcMessage ("The density needs to be a positive quantity "
+                            "when melt transport is included in the simulation."));
+
+        const double melting_rate         = scratch.material_model_outputs.reaction_terms[q_point][scratch.advection_field->compositional_variable];
+        const double density              = scratch.material_model_outputs.densities[q_point];
+
+        const double compressibility      = (simulator_access->get_material_model().is_compressible()
+                                             ?
+                                             scratch.material_model_outputs.compressibilities[q_point]
+                                             :
+                                             0.0);
+        const Tensor<1,dim> current_u     = scratch.current_velocity_values[q_point];
+        const Tensor<1,dim>
+        gravity = simulator_access->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q_point));
+
+        // Note that the full advection term would be (1 - phi) * (div u + kappa rho u g),
+        // but we expanded the term and move the part (- phi) * (div u + kappa rho u g) over to the LHS.
+        double melt_transport_RHS = melting_rate / density
+                                    + divergence_u + compressibility * density * (current_u * gravity);
+
+        if (!simulator_access->get_melt_handler().is_melt_cell(scratch.material_model_inputs.current_cell))
+          melt_transport_RHS = melting_rate / density;
+
+        return melt_transport_RHS;
+      }
+    }
+
+
+    template <int dim>
+    void
+    MeltAdvectionSystem<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      const bool use_bdf2_scheme = (this->get_timestep_number() > 1);
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
+
+      const double time_step = this->get_timestep();
+      const double old_time_step = this->get_old_timestep();
+
+      const unsigned int solution_component = scratch.advection_field->component_index(introspection);
+
+      const FEValuesExtractors::Scalar solution_field = scratch.advection_field->scalar_extractor(introspection);
+
+      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+
+      Assert(melt_outputs->compaction_viscosities[0] > 0.0,
+             ExcMessage ("MeltOutputs have to be filled for models with melt transport. "
+                         "At the moment, these outputs are not filled, or they do not have "
+                         "reasonable values."));
+
+      std::vector<Tensor<1,dim>> fluid_velocity_values(n_q_points);
+      const FEValuesExtractors::Vector ex_u_f = introspection.variable("fluid velocity").extractor_vector();
+      scratch.finite_element_values[ex_u_f].get_function_values (this->get_solution(),fluid_velocity_values);
+
+      // average divergence u over the cell (needed for porosity advection)
+      double divergence_u = 0.0;
+      if (this->get_melt_handler().is_porosity(*scratch.advection_field))
+        for (unsigned int q=0; q<n_q_points; ++q)
+          divergence_u += scratch.current_velocity_divergences[q] * 1./n_q_points;
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          // precompute the values of shape functions and their gradients.
+          // We only need to look up values of shape functions if they
+          // belong to 'our' component. They are zero otherwise anyway.
+          // Note that we later only look at the values that we do set here.
+          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (fe.system_to_component_index(i).first == solution_component)
+                {
+                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
+                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
+                  ++i_advection;
+                }
+              ++i;
+            }
+
+          const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
+          const double porosity = std::max(scratch.material_model_inputs.composition[q][porosity_index],0.0);
+          const double bulk_density = (1.0 - porosity) * scratch.material_model_outputs.densities[q] + porosity * melt_outputs->fluid_densities[q];
+
+          const double density_c_P =
+            ((scratch.advection_field->is_temperature())
+             ?
+             bulk_density *
+             scratch.material_model_outputs.specific_heat[q]
+             :
+             1.0);
+
+          Assert (density_c_P >= 0,
+                  ExcMessage ("The product of density and c_P needs to be a "
+                              "non-negative quantity."));
+
+          const double conductivity =
+            (scratch.advection_field->is_temperature()
+             ?
+             scratch.material_model_outputs.thermal_conductivities[q]
+             :
+             0.0);
+          const double latent_heat_LHS =
+            ((scratch.advection_field->is_temperature())
+             ?
+             scratch.heating_model_outputs.lhs_latent_heat_terms[q]
+             :
+             0.0);
+          Assert (density_c_P + latent_heat_LHS >= 0,
+                  ExcMessage ("The sum of density times c_P and the latent heat contribution "
+                              "to the left hand side needs to be a non-negative quantity."));
+
+          const double gamma =
+            ((scratch.advection_field->is_temperature())
+             ?
+             scratch.heating_model_outputs.heating_source_terms[q]
+             :
+             0.0);
+
+          const double reaction_term =
+            ((scratch.advection_field->is_temperature() || this->get_melt_handler().is_porosity(*scratch.advection_field))
+             ?
+             0.0
+             :
+             scratch.material_model_outputs.reaction_terms[q][scratch.advection_field->compositional_variable]);
+
+          const double melt_transport_RHS = (this->get_melt_handler().is_porosity(*scratch.advection_field) ?
+                                             compute_melting_RHS (this,
+                                                                  scratch,
+                                                                  q,
+                                                                  divergence_u)
+                                             :
+                                             0.0);
+
+          const double field_term_for_rhs
+            = (use_bdf2_scheme ?
+               ((scratch.old_field_values)[q] *
+                (1 + time_step/old_time_step)
+                -
+                (scratch.old_old_field_values)[q] *
+                (time_step * time_step) /
+                (old_time_step * (time_step + old_time_step)))
+               :
+               (scratch.old_field_values)[q])
+              *
+              (density_c_P + latent_heat_LHS);
+
+          Tensor<1,dim> current_u = scratch.current_velocity_values[q];
+          // Subtract off the mesh velocity for ALE corrections if necessary
+          if (this->get_parameters().mesh_deformation_enabled)
+            current_u -= scratch.mesh_velocity_values[q];
+
+          const double melt_transport_LHS =
+            (this->get_melt_handler().is_porosity(*scratch.advection_field)
+             && this->get_melt_handler().is_melt_cell(scratch.material_model_inputs.current_cell)
+             ?
+             divergence_u
+             + (this->get_material_model().is_compressible()
+                ?
+                scratch.material_model_outputs.compressibilities[q]
+                * scratch.material_model_outputs.densities[q]
+                * current_u
+                * this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q))
+                :
+                0.0)
+             :
+             0.0);
+
+          const double factor = (use_bdf2_scheme)? ((2*time_step + old_time_step) /
+                                                    (time_step + old_time_step)) : 1.0;
+
+          // for advective transport of heat by melt, or advecting compositional fields
+          // with the melt velocity, we have to consider melt velocities
+          const Tensor<1,dim> current_u_f = fluid_velocity_values[q];
+          double density_c_P_solid = density_c_P;
+          double density_c_P_melt = 0.0;
+
+          if (scratch.advection_field->is_temperature() && this->get_melt_handler().is_melt_cell(scratch.cell)
+              && this->get_melt_handler().melt_parameters.heat_advection_by_melt)
+            {
+              density_c_P_solid = (1.0 - porosity) * scratch.material_model_outputs.densities[q] * scratch.material_model_outputs.specific_heat[q];
+              density_c_P_melt = porosity * melt_outputs->fluid_densities[q] * scratch.material_model_outputs.specific_heat[q];
+            }
+          else if (!scratch.advection_field->is_temperature()
+                   && !this->get_melt_handler().is_porosity(*scratch.advection_field)
+                   && scratch.advection_field->advection_method(this->introspection()) == Parameters<dim>::AdvectionFieldMethod::fem_melt_field)
+            {
+              // if the field is advected with the fem_melt_field method,
+              // we want to use the melt (fluid) velocity instead of the solid velocity for advecting it
+              density_c_P_solid = 0.0;
+              density_c_P_melt = 1.0;
+            }
+
+          // do the actual assembly. note that we only need to loop over the advection
+          // shape functions because these are the only contributions we compute here
+          for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i)
+              += (field_term_for_rhs * scratch.phi_field[i]
+                  + time_step *
+                  scratch.phi_field[i]
+                  * (gamma + melt_transport_RHS)
+                  + scratch.phi_field[i]
+                  * reaction_term)
+                 *
+                 scratch.finite_element_values.JxW(q);
+
+              for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
+                {
+                  data.local_matrix(i,j)
+                  += (
+                       (time_step * (conductivity + scratch.artificial_viscosity)
+                        * (scratch.grad_phi_field[i] * scratch.grad_phi_field[j]))
+                       + ((time_step * (scratch.phi_field[i] * (current_u * scratch.grad_phi_field[j])))
+                          + (factor * scratch.phi_field[i] * scratch.phi_field[j])) *
+                       (density_c_P_solid + latent_heat_LHS)
+                       + ((time_step * (scratch.phi_field[i] * (current_u_f * scratch.grad_phi_field[j])))
+                          + (factor * scratch.phi_field[i] * scratch.phi_field[j])) *
+                       (density_c_P_melt)
+                       + time_step * scratch.phi_field[i] * scratch.phi_field[j] * melt_transport_LHS
+                     )
+                     * scratch.finite_element_values.JxW(q);
+                }
+            }
+        }
+    }
+
+    template <int dim>
+    std::vector<double>
+    MeltAdvectionSystem<dim>::
+    compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
+    {
+      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch =
+        dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
+
+      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
+      std::vector<double> residuals(n_q_points);
+
+      this->get_heating_model_manager().evaluate(scratch.material_model_inputs,
+                                                 scratch.material_model_outputs,
+                                                 scratch.heating_model_outputs);
+
+      // average divergence u over the cell (needed for porosity advection)
+      double divergence_u = 0.0;
+      if (this->get_melt_handler().is_porosity(*scratch.advection_field))
+        for (unsigned int q=0; q<n_q_points; ++q)
+          divergence_u += scratch.current_velocity_divergences[q] * 1./n_q_points;
+
+      for (unsigned int q=0; q < n_q_points; ++q)
+        {
+          const Tensor<1,dim> u = (scratch.old_velocity_values[q] +
+                                   scratch.old_old_velocity_values[q]) / 2;
+
+          const double dField_dt = (this->get_old_timestep() == 0.0) ? 0.0 :
+                                   (
+                                     ((scratch.old_field_values)[q] - (scratch.old_old_field_values)[q])
+                                     / this->get_old_timestep());
+          const double u_grad_field = u * (scratch.old_field_grads[q] +
+                                           scratch.old_old_field_grads[q]) / 2;
+
+          if (scratch.advection_field->is_temperature())
+            {
+              const double density       = scratch.material_model_outputs.densities[q];
+              const double conductivity  = scratch.material_model_outputs.thermal_conductivities[q];
+              const double c_P           = scratch.material_model_outputs.specific_heat[q];
+              const double k_Delta_field = conductivity * (scratch.old_field_laplacians[q] +
+                                                           scratch.old_old_field_laplacians[q]) / 2;
+
+              const double gamma           = scratch.heating_model_outputs.heating_source_terms[q];
+              const double latent_heat_LHS = scratch.heating_model_outputs.lhs_latent_heat_terms[q];
+
+              residuals[q]
+                = std::abs((density * c_P + latent_heat_LHS) * (dField_dt + u_grad_field) - k_Delta_field - gamma);
+            }
+          else
+            {
+              const double field = ((scratch.old_field_values)[q] + (scratch.old_old_field_values)[q]) / 2;
+
+              const double dreaction_term_dt =
+                (this->get_old_timestep() == 0 || this->get_melt_handler().is_porosity(*scratch.advection_field))
+                ?
+                0.0
+                :
+                (scratch.material_model_outputs.reaction_terms[q][scratch.advection_field->compositional_variable]
+                 / this->get_old_timestep());
+
+
+              const double melt_transport_RHS = (this->get_melt_handler().is_porosity(*scratch.advection_field) ?
+                                                 compute_melting_RHS (this,
+                                                                      scratch,
+                                                                      q,
+                                                                      divergence_u)
+                                                 :
+                                                 0.0);
+
+              const double melt_transport_LHS =
+                (this->get_melt_handler().is_porosity(*scratch.advection_field)
+                 ?
+                 scratch.current_velocity_divergences[q]
+                 + (this->get_material_model().is_compressible()
+                    ?
+                    scratch.material_model_outputs.compressibilities[q]
+                    * scratch.material_model_outputs.densities[q]
+                    * u
+                    * this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q))
+                    :
+                    0.0)
+                 :
+                 0.0);
+
+              residuals[q]
+                = std::abs(dField_dt + u_grad_field + melt_transport_LHS * field
+                           - melt_transport_RHS - dreaction_term_dt);
+            }
+        }
+      return residuals;
+    }
+
+
+
+    template <int dim>
+    void
+    MeltPressureRHSCompatibilityModification<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = scratch.finite_element_values.get_fe();
+
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
+      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
+
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+
+      const FEValuesExtractors::Scalar ex_p_f = introspection.variable("fluid pressure").extractor_scalar();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+          {
+            const unsigned int component_index_i = fe.system_to_component_index(i).first;
+
+            if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
+              {
+                scratch.phi_p[i_stokes] = scratch.finite_element_values[ex_p_f].value (i, q);
+                data.local_pressure_shape_function_integrals(i_stokes) += scratch.phi_p[i_stokes] * scratch.finite_element_values.JxW(q);
+                ++i_stokes;
+              }
+            ++i;
+          }
+    }
+
+    template <int dim>
+    void
+    MeltBoundaryTraction<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      // see if any of the faces are traction boundaries for which
+      // we need to assemble force terms for the right hand side
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
+      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
+
+      const typename DoFHandler<dim>::active_cell_iterator cell (&this->get_triangulation(),
+                                                                 scratch.face_finite_element_values.get_cell()->level(),
+                                                                 scratch.face_finite_element_values.get_cell()->index(),
+                                                                 &this->get_dof_handler());
+
+      unsigned int face_no = numbers::invalid_unsigned_int;
+      for (face_no=0; face_no<cell->n_faces(); ++face_no)
+        if (scratch.face_finite_element_values.get_face_index() == cell->face_index(face_no))
+          break;
+      Assert(face_no != numbers::invalid_unsigned_int,ExcInternalError());
+
+      const typename DoFHandler<dim>::face_iterator face = cell->face(face_no);
+
+      if (this->get_boundary_traction_manager().get_active_boundary_traction_names()
+          .find (face->boundary_id())
+          !=
+          this->get_boundary_traction_manager().get_active_boundary_traction_names().end())
+        {
+          scratch.face_finite_element_values.reinit (cell, face_no);
+
+          for (unsigned int q=0; q<scratch.face_finite_element_values.n_quadrature_points; ++q)
+            {
+              const Tensor<1,dim> traction
+                = this->get_boundary_traction_manager().
+                  boundary_traction (face->boundary_id(),
+                                     scratch.face_finite_element_values.quadrature_point(q),
+                                     scratch.face_finite_element_values.normal_vector(q));
+
+              for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+                {
+                  const unsigned int component_index_i = fe.system_to_component_index(i).first;
+
+                  if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
+                    {
+                      data.local_rhs(i_stokes) += scratch.face_finite_element_values[introspection.extractors.velocities].value(i,q) *
+                                                  traction *
+                                                  scratch.face_finite_element_values.JxW(q);
+                      ++i_stokes;
+                    }
+                  ++i;
+                }
+            }
+        }
+    }
+  }
+
+
+  template <int dim>
+  void
+  MeltHandler<dim>::
+  compute_melt_variables(LinearAlgebra::BlockSparseMatrix &system_matrix,
+                         LinearAlgebra::BlockVector &solution,
+                         LinearAlgebra::BlockVector &system_rhs)
+  {
+    if (!this->include_melt_transport())
+      return;
+
+    Assert (this->include_melt_transport(), ExcMessage ("'Include melt transport' has to be on to "
+                                                        "compute melt variables"));
+
+    LinearAlgebra::BlockVector distributed_solution (this->introspection().index_sets.system_partitioning,
+                                                     this->get_mpi_communicator());
+
+    const unsigned int por_idx = this->introspection().compositional_index_for_name("porosity");
+
+    {
+      // compute fluid_velocity
+      // u_f =  u_s - K_D (nabla p_f - rho_f g) / phi  or = 0
+      // by solving a mass matrix problem
+
+      const unsigned int block_idx = this->introspection().variable("fluid velocity").block_index;
+      system_matrix.block(block_idx, block_idx) = 0;
+      system_rhs.block(block_idx) = 0;
+
+      const Quadrature<dim> &quadrature = this->introspection().quadratures.velocities;
+      const FiniteElement<dim> &fe = this->get_fe();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               fe,
+                               quadrature,
+                               update_quadrature_points | update_values | update_gradients | update_JxW_values);
+
+      const unsigned int dofs_per_cell = fe_values.dofs_per_cell,
+                         n_q_points    = fe_values.n_quadrature_points;
+
+      const FEVariable<dim> &u_f_variable = this->introspection().variable("fluid velocity");
+      const unsigned int fluid_velocity_dofs_per_cell = fe.element_multiplicity(u_f_variable.base_index) *
+                                                        fe.base_element(u_f_variable.base_index).dofs_per_cell;
+
+      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
+      std::vector<types::global_dof_index> cell_u_f_dof_indices (fluid_velocity_dofs_per_cell);
+
+      Vector<double> cell_vector (fluid_velocity_dofs_per_cell);
+      FullMatrix<double> cell_matrix (fluid_velocity_dofs_per_cell, fluid_velocity_dofs_per_cell);
+
+      std::vector<double> porosity_values(quadrature.size());
+      std::vector<Tensor<1,dim>> grad_p_f_values(quadrature.size());
+      std::vector<Tensor<1,dim>> u_s_values(quadrature.size());
+
+      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
+
+      create_material_model_outputs(out);
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            cell_vector = 0;
+            cell_matrix = 0;
+            fe_values.reinit (cell);
+
+            cell->get_dof_indices (cell_dof_indices);
+
+            // Extract the dofs of this cell that are actually fluid velocity dofs
+            for (unsigned int i=0, i_u_f=0; i_u_f<fluid_velocity_dofs_per_cell; /*increment at end of loop*/)
+              {
+                if (u_f_variable.component_mask[fe.system_to_component_index(i).first])
+                  {
+                    cell_u_f_dof_indices[i_u_f] = cell_dof_indices[i];
+                    ++i_u_f;
+                  }
+                ++i;
+              }
+
+            fe_values[this->introspection().extractors.compositional_fields[por_idx]].get_function_values (
+              solution, porosity_values);
+            fe_values[this->introspection().extractors.velocities].get_function_values (
+              solution, u_s_values);
+
+            fe_values[this->introspection().variable("fluid pressure").extractor_scalar()].get_function_gradients (
+              solution, grad_p_f_values);
+
+
+            in.reinit(fe_values,
+                      cell,
+                      this->introspection(),
+                      this->get_solution());
+
+            this->get_material_model().evaluate(in, out);
+
+            const bool is_melt_cell = this->get_melt_handler().is_melt_cell(in.current_cell);
+
+            MaterialModel::MeltOutputs<dim> *melt_outputs = out.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+            Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for computing the melt variables."));
+            const FEValuesExtractors::Vector fluid_velocity_extractor = this->introspection().variable("fluid velocity").extractor_vector();
+
+            std::vector<Tensor<1,dim>> phi_u_f(fluid_velocity_dofs_per_cell);
+
+            double K_D_over_phi = 1.0;
+
+            if (melt_parameters.average_melt_velocity)
+              {
+                // average the K_D and the porosity cell-wise (geometric mean)
+                for (unsigned int q=0; q<n_q_points; ++q)
+                  {
+                    const double K_D = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q];
+                    const double K_D_over_phi_q_point = (porosity_values[q] > 0 ? K_D / porosity_values[q] : 0.0);
+                    K_D_over_phi *= std::pow(K_D_over_phi_q_point, 1.0/n_q_points);
+                  }
+              }
+
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                for (unsigned int i = 0, i_u_f = 0; i_u_f < fluid_velocity_dofs_per_cell; /*increment at end of loop*/)
+                  {
+                    if (u_f_variable.component_mask[fe.system_to_component_index(i).first])
+                      {
+                        phi_u_f[i_u_f] = fe_values[fluid_velocity_extractor].value(i,q);
+                        ++i_u_f;
+                      }
+                    ++i;
+                  }
+
+                const double JxW = fe_values.JxW(q);
+
+                for (unsigned int i=0; i<fluid_velocity_dofs_per_cell; ++i)
+                  for (unsigned int j=0; j<fluid_velocity_dofs_per_cell; ++j)
+                    cell_matrix(i,j) += phi_u_f[j] * phi_u_f[i] * JxW;
+
+                if (!melt_parameters.average_melt_velocity)
+                  {
+                    // use K_D without cutoff to compute u_f
+                    const double phi = std::max(0.0, porosity_values[q]);
+                    const double K_D = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q];
+
+                    K_D_over_phi = (phi > 0 ? K_D / phi : 0.0);
+                  }
+
+                // u_f =  u_s - K_D (nabla p_f - rho_f g) / phi  or = 0
+                if (is_melt_cell)
+                  {
+                    const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(in.position[q]);
+
+
+                    for (unsigned int i=0; i<fluid_velocity_dofs_per_cell; ++i)
+                      cell_vector(i) += (u_s_values[q] - K_D_over_phi * (grad_p_f_values[q] - melt_outputs->fluid_densities[q]*gravity))
+                                        * phi_u_f[i]
+                                        * JxW;
+                  }
+                else
+                  for (unsigned int i=0; i<fluid_velocity_dofs_per_cell; ++i)
+                    cell_vector(i) += (u_s_values[q])
+                                      * phi_u_f[i]
+                                      * JxW;
+
+              }
+
+            this->get_current_constraints().distribute_local_to_global (cell_matrix, cell_vector,
+                                                                        cell_u_f_dof_indices, system_matrix,
+                                                                        system_rhs, false);
+          }
+
+      system_rhs.compress (VectorOperation::add);
+      system_matrix.compress (VectorOperation::add);
+
+      LinearAlgebra::PreconditionAMG preconditioner;
+      LinearAlgebra::PreconditionAMG::AdditionalData Amg_data;
+
+      // Amg_data.constant_modes = constant_modes;
+      Amg_data.elliptic = true;
+      Amg_data.higher_order_elements = false;
+      Amg_data.smoother_sweeps = 2;
+      Amg_data.aggregation_threshold = 0.02;
+      preconditioner.initialize(system_matrix.block(block_idx, block_idx));
+
+      SolverControl solver_control(system_rhs.block(block_idx).size(),
+                                   1e-8*system_rhs.block(block_idx).l2_norm());
+      SolverCG<LinearAlgebra::Vector> cg(solver_control);
+
+      this->get_pcout() << "   Solving fluid velocity system... " << std::flush;
+
+      cg.solve (system_matrix.block(block_idx, block_idx),
+                distributed_solution.block(block_idx),
+                system_rhs.block(block_idx),
+                preconditioner);
+
+      this->get_pcout() << solver_control.last_step() <<" iterations."<< std::endl;
+
+      this->get_current_constraints().distribute (distributed_solution);
+      solution.block(block_idx) = distributed_solution.block(block_idx);
+    }
+
+    // compute solid pressure as
+    // p_s = (p_c+ (1-phi)p_f) / (1-phi)
+    // p_s = p_c / (1-phi) + p_f
+    {
+      const unsigned int block_p = this->introspection().block_indices.pressure;
+
+      // Think what we need to do if the pressure is not an FE_Q...
+      Assert(this->get_parameters().use_locally_conservative_discretization == false, ExcNotImplemented());
+
+      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.pressure).get_unit_support_points());
+      std::vector<double> porosity_values(quadrature.size());
+      std::vector<double> p_c_values(quadrature.size());
+      std::vector<double> p_f_values(quadrature.size());
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature,
+                               update_quadrature_points | update_gradients | update_values);
+
+      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
+      // We only need access to the MeltOutputs in p_c_scale().
+      in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
+
+      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
+      create_material_model_outputs(out);
+
+      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit(cell);
+            cell->get_dof_indices (local_dof_indices);
+            fe_values[this->introspection().extractors.compositional_fields[por_idx]].get_function_values (
+              solution, porosity_values);
+            fe_values[this->introspection().variable("compaction pressure").extractor_scalar()].get_function_values (
+              solution, p_c_values);
+            fe_values[this->introspection().variable("fluid pressure").extractor_scalar()].get_function_values (
+              solution, p_f_values);
+            in.reinit(fe_values,
+                      cell,
+                      this->introspection(),
+                      solution);
+
+            this->get_material_model().evaluate(in, out);
+
+            const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(
+                                       this->get_material_model()).p_c_scale(in,
+                                                                             out,
+                                                                             this->get_melt_handler(),
+                                                                             true);
+
+            for (unsigned int j=0; j<this->get_fe().base_element(this->introspection().base_elements.pressure).dofs_per_cell; ++j)
+              {
+                const unsigned int pressure_idx
+                  = this->get_fe().component_to_system_index(this->introspection().component_indices.pressure,
+                                                             /*dof index within component=*/ j);
+
+                // skip entries that are not locally owned:
+                if (!this->get_dof_handler().locally_owned_dofs().is_element(local_dof_indices[pressure_idx]))
+                  continue;
+
+                const double phi = std::max(0.0, porosity_values[j]);
+
+                double p = p_f_values[j];
+                if (p_c_scale > 0 && (1.0-phi) > std::numeric_limits<double>::min())
+                  p = (p_c_scale*p_c_values[j] - (phi-1.0) * p_f_values[j]) / (1.0-phi);
+
+                distributed_solution(local_dof_indices[pressure_idx]) = p;
+              }
+          }
+
+      distributed_solution.block(block_p).compress(VectorOperation::insert);
+      solution.block(block_p) = distributed_solution.block(block_p);
+    }
+  }
+
+
+
+  template <int dim>
+  bool
+  MeltHandler<dim>::
+  is_porosity(const typename Simulator<dim>::AdvectionField &advection_field) const
+  {
+    if (advection_field.field_type != Simulator<dim>::AdvectionField::compositional_field)
+      return false;
+    else
+      return (this->introspection().name_for_compositional_index(advection_field.compositional_variable) == "porosity");
+  }
+
+
+
+  namespace internal
+  {
+    // This is a scratch object for the setting the compaction pressure constraints
+    // in cells without melt (where we do not solve the melt transport equations,
+    // so we set the compaction pressure to zero).
+    template <int dim>
+    struct PcConstraintsAssembleData
+    {
+      // Standard constructor
+      PcConstraintsAssembleData (const FiniteElement<dim> &finite_element,
+                                 const Quadrature<dim>    &quadrature,
+                                 const Mapping<dim>       &mapping,
+                                 const UpdateFlags         update_flags,
+                                 const unsigned int        n_compositional_fields,
+                                 const unsigned int        stokes_dofs_per_cell)
+        :
+        finite_element_values (mapping, finite_element, quadrature,
+                               update_flags),
+        local_dof_indices (finite_element.dofs_per_cell),
+        dof_component_indices(stokes_dofs_per_cell),
+        material_model_inputs(quadrature.size(), n_compositional_fields),
+        material_model_outputs(quadrature.size(), n_compositional_fields)
+      {}
+
+
+      // Copy constructor
+      PcConstraintsAssembleData (const PcConstraintsAssembleData &scratch)
+        :
+        finite_element_values (scratch.finite_element_values.get_mapping(),
+                               scratch.finite_element_values.get_fe(),
+                               scratch.finite_element_values.get_quadrature(),
+                               scratch.finite_element_values.get_update_flags()),
+        local_dof_indices (scratch.local_dof_indices),
+        dof_component_indices( scratch.dof_component_indices),
+        material_model_inputs(scratch.material_model_inputs),
+        material_model_outputs(scratch.material_model_outputs)
+      {}
+
+      virtual ~PcConstraintsAssembleData () = default;
+
+      FEValues<dim>                            finite_element_values;
+
+      std::vector<types::global_dof_index>     local_dof_indices;
+      std::vector<unsigned int>                dof_component_indices;
+
+      MaterialModel::MaterialModelInputs<dim>  material_model_inputs;
+      MaterialModel::MaterialModelOutputs<dim> material_model_outputs;
+
+    };
+
+    template <int dim>
+    struct PcConstraintsCopyData
+    {
+      explicit PcConstraintsCopyData (const unsigned int stokes_dofs_per_cell)
+      {
+        nonzero_dof_indices.reserve(stokes_dofs_per_cell);
+      }
+
+      std::vector<types::global_dof_index>   nonzero_dof_indices;
+    };
+
+
+    // Assembler for setting the compaction pressure constraints in cells without melt.
+    // Note that the assembler does not actually assemble anything, it just uses the
+    // structure of an assembler to loop over all compaction pressure dofs and to insert
+    // the ones that are in melt cells into an IndexSet (nonzero_dof_indices) that is
+    // later needed for setting the constraints.
+    template <int dim>
+    class PcNonZeroDofsAssembler : public SimulatorAccess<dim>
+    {
+      public:
+        PcNonZeroDofsAssembler(const std::vector<bool> &is_melt_cell,
+                               IndexSet &nonzero_entries)
+          : is_melt_cell (is_melt_cell),
+            nonzero_entries (nonzero_entries)
+        {}
+
+
+        void
+        local_save_nonzero_pc_dofs (const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                    PcConstraintsAssembleData<dim> &scratch,
+                                    PcConstraintsCopyData<dim> &data)
+        {
+          data.nonzero_dof_indices.clear();
+          cell->get_dof_indices (scratch.local_dof_indices);
+
+          const unsigned int pc_component_index = this->introspection().variable("compaction pressure").first_component_index;
+          const unsigned int pc_base_index = this->introspection().variable("compaction pressure").base_index;
+
+          Assert(cell.state() == IteratorState::valid,
+                 ExcMessage("You are trying to access the property of a cell (if it is "
+                            "a melt cell or not), but the cell iterator provided does not "
+                            "point to a cell."));
+          const bool is_melt_cell = this->get_melt_handler().is_melt_cell(cell);
+
+          if (is_melt_cell)
+            {
+              data.nonzero_dof_indices.resize(this->get_fe().base_element(pc_base_index).dofs_per_cell);
+              for (unsigned int j=0; j<this->get_fe().base_element(pc_base_index).dofs_per_cell; ++j)
+                {
+                  const unsigned int pressure_idx
+                    = this->get_fe().component_to_system_index(pc_component_index,
+                                                               /*dof index within component=*/ j);
+
+                  data.nonzero_dof_indices[j] = scratch.local_dof_indices[pressure_idx];
+                }
+            }
+        }
+
+        void
+        copy_local_to_global (const PcConstraintsCopyData<dim> &data)
+        {
+          nonzero_entries.add_indices(data.nonzero_dof_indices.begin(),
+                                      data.nonzero_dof_indices.end());
+        }
+
+      private:
+        const std::vector<bool> &is_melt_cell;
+        IndexSet &nonzero_entries;
+
+    };
+
+  }
+
+
+
+  template <int dim>
+  void
+  MeltHandler<dim>::
+  add_current_constraints(AffineConstraints<double> &constraints)
+  {
+    IndexSet nonzero_pc_dofs(this->introspection().index_sets.system_relevant_set.size());
+
+    const QTrapezoid<dim> quadrature_formula;
+    const UpdateFlags cell_update_flags = update_quadrature_points | update_values | update_gradients;
+    const FiniteElement<dim> &fe = this->get_fe();
+
+    is_melt_cell_vector.resize(this->get_dof_handler().get_triangulation().n_active_cells());
+
+    {
+      // find the "melt cells" by looking at p_c_scale
+
+      const unsigned int n_compositional_fields = this->introspection().n_compositional_fields;
+      FEValues<dim> finite_element_values(this->get_mapping(), fe, quadrature_formula, cell_update_flags);
+
+      MaterialModel::MaterialModelInputs<dim> material_model_inputs(quadrature_formula.size(), n_compositional_fields);
+      MaterialModel::MaterialModelOutputs<dim> material_model_outputs(quadrature_formula.size(), n_compositional_fields);
+
+      MeltHandler<dim>::create_material_model_outputs(material_model_outputs);
+      Assert(Plugins::plugin_type_matches<const MaterialModel::MeltInterface<dim>>(this->get_material_model()),
+             ExcMessage("Your material model does not derive from MaterialModel::MeltInterface, which is required."));
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            finite_element_values.reinit (cell);
+
+            material_model_inputs.reinit(finite_element_values,
+                                         cell,
+                                         this->introspection(),
+                                         this->get_current_linearization_point());
+
+            // We only need access to the MeltOutputs in p_c_scale().
+            material_model_inputs.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
+
+            this->get_material_model().evaluate(material_model_inputs,
+                                                material_model_outputs);
+
+            const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(
+                                       this->get_material_model()).p_c_scale(material_model_inputs,
+                                                                             material_model_outputs,
+                                                                             this->get_melt_handler(),
+                                                                             false /*=consider_is_melt_cell*/);
+            const bool is_melt_cell = (p_c_scale > 0.0);
+            is_melt_cell_vector[cell->active_cell_index()] = is_melt_cell;
+          }
+    }
+
+
+    internal::PcNonZeroDofsAssembler<dim> assembler(is_melt_cell_vector, nonzero_pc_dofs);
+    assembler.initialize_simulator(this->get_simulator());
+
+    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
+
+    const unsigned int stokes_dofs_per_cell = dim * fe.base_element(this->introspection().base_elements.velocities).dofs_per_cell
+                                              + fe.base_element(this->introspection().base_elements.pressure).dofs_per_cell
+                                              + fe.base_element(this->introspection().base_elements.pressure).dofs_per_cell;
+
+    auto worker = [&](const typename DoFHandler<dim>::active_cell_iterator &cell,
+                      internal::PcConstraintsAssembleData<dim> &scratch,
+                      internal::PcConstraintsCopyData<dim> &data)
+    {
+      assembler.local_save_nonzero_pc_dofs(cell, scratch, data);
+    };
+
+    auto copier = [&](const internal::PcConstraintsCopyData<dim> &data)
+    {
+      assembler.copy_local_to_global(data);
+    };
+
+    // Here we call the assembler in order to save all compaction pressure dofs
+    // that are in melt cells (and are nonzero) in the nonzero_pc_dofs index set.
+    WorkStream::
+    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     this->get_dof_handler().begin_active()),
+         CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     this->get_dof_handler().end()),
+         worker,
+         copier,
+         internal::PcConstraintsAssembleData<dim> (
+           fe,
+           quadrature_formula,
+           this->get_mapping(),
+           cell_update_flags,
+           this->introspection().n_compositional_fields,
+           stokes_dofs_per_cell),
+         internal::PcConstraintsCopyData<dim> (stokes_dofs_per_cell));
+
+    // For the constraints, first pick all relevant p_c dofs:
+    IndexSet for_constraints = this->introspection().index_sets.system_relevant_set
+                               & Utilities::extract_locally_active_dofs_with_component<dim>(this->get_dof_handler(),
+                                   this->introspection().variable("compaction pressure").component_mask);
+
+    // now subtract the ones that are nonzero as computed above:
+    for_constraints.subtract_set(nonzero_pc_dofs);
+
+    // and constrain the remaining dofs (that are not in melt cells).
+#if DEAL_II_VERSION_GTE(9,6,0)
+    for (const auto index : for_constraints)
+      constraints.constrain_dof_to_zero(index);
+#else
+    constraints.add_lines(for_constraints);
+#endif
+  }
+
+
+
+  template <int dim>
+  bool
+  MeltHandler<dim>::
+  is_melt_cell(const typename DoFHandler<dim>::active_cell_iterator &cell) const
+  {
+    return is_melt_cell_vector[cell->active_cell_index()];
+  }
+
+
+
+  template <int dim>
+  double
+  MeltHandler<dim>::
+  limited_darcy_coefficient(const double K_D,
+                            const bool is_melt_cell) const
+  {
+    const double ref_K_D = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(this->get_material_model()).reference_darcy_coefficient();
+    return is_melt_cell ? std::max(K_D, melt_parameters.melt_scaling_factor_threshold*ref_K_D) : 0;
+  }
+
+
+
+  template <int dim>
+  const BoundaryFluidPressure::Interface<dim> &
+  MeltHandler<dim>::
+  get_boundary_fluid_pressure () const
+  {
+    return *boundary_fluid_pressure.get();
+  }
+
+
+
+  template <int dim>
+  void
+  MeltHandler<dim>::
+  edit_finite_element_variables(const Parameters<dim> &parameters,
+                                std::vector<VariableDeclaration<dim>> &variables)
+  {
+
+    if (!parameters.include_melt_transport)
+      return;
+
+    variables.insert(variables.begin()+1,
+                     VariableDeclaration<dim>(
+                       "fluid pressure",
+                       std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree-1),
+                       1,
+                       0)); // same block as p_c even without a direct solver!
+
+    variables.insert(variables.begin()+2,
+                     VariableDeclaration<dim>(
+                       "compaction pressure",
+                       melt_parameters.use_discontinuous_p_c
+                       ?
+                       std::shared_ptr<FiniteElement<dim>>(
+                         std::make_shared<FE_DGP<dim>>(parameters.stokes_velocity_degree-1))
+                       :
+                       std::shared_ptr<FiniteElement<dim>>(
+                         std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree-1)),
+                       1,
+                       1));
+
+    variables.insert(variables.begin()+3,
+                     VariableDeclaration<dim>("fluid velocity",
+                                              std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree),
+                                              dim,
+                                              1));
+
+  }
+
+
+
+  template <int dim>
+  void
+  MeltHandler<dim>::
+  set_assemblers (Assemblers::Manager<dim> &assemblers) const
+  {
+    assemblers.stokes_preconditioner.push_back(std::make_unique<Assemblers::MeltStokesPreconditioner<dim>> ());
+    assemblers.stokes_system.push_back(std::make_unique<Assemblers::MeltStokesSystem<dim>> ());
+
+    AssertThrow((this->get_parameters().formulation_mass_conservation ==
+                 Parameters<dim>::Formulation::MassConservation::isentropic_compression) ||
+                (this->get_parameters().formulation_mass_conservation ==
+                 Parameters<dim>::Formulation::MassConservation::incompressible),
+                ExcMessage("The melt implementation currently only supports the isentropic compression "
+                           "approximation or the incompressible formulation of the mass conservation equation."));
+
+    // add the boundary integral for melt migration
+    assemblers.stokes_system_assembler_on_boundary_face_properties.need_face_material_model_data = true;
+    assemblers.stokes_system_assembler_on_boundary_face_properties.needed_update_flags = (update_values  | update_quadrature_points |
+        update_normal_vectors | update_gradients |
+        update_JxW_values);
+
+
+    assemblers.stokes_system_on_boundary_face.push_back(
+      std::make_unique<aspect::Assemblers::MeltStokesSystemBoundary<dim>>());
+
+    // add the terms for traction boundary conditions
+    if (!this->get_boundary_traction_manager().get_active_boundary_traction_names().empty())
+      {
+        assemblers.stokes_system_on_boundary_face.push_back(
+          std::make_unique<Assemblers::MeltBoundaryTraction<dim>> ());
+      }
+
+    // add the terms necessary to normalize the pressure
+    if (this->pressure_rhs_needs_compatibility_modification())
+      {
+        assemblers.stokes_system.push_back(
+          std::make_unique<Assemblers::MeltPressureRHSCompatibilityModification<dim>> ());
+      }
+
+    for (unsigned int i=0; i<1+this->introspection().n_compositional_fields; ++i)
+      {
+        if ((i==0 && this->get_parameters().temperature_method == Parameters<dim>::AdvectionFieldMethod::fem_field)
+            ||
+            (i>0 && this->get_parameters().compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_field)
+            ||
+            (i>0 && this->get_parameters().compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_melt_field))
+          assemblers.advection_system[i].push_back(
+            std::make_unique<Assemblers::MeltAdvectionSystem<dim>> ());
+
+        if (this->get_parameters().fixed_heat_flux_boundary_indicators.size() != 0)
+          {
+            assemblers.advection_system_on_boundary_face[i].push_back(
+              std::make_unique<aspect::Assemblers::AdvectionSystemBoundaryHeatFlux<dim>>());
+            assemblers.advection_system_assembler_on_face_properties[0].need_face_material_model_data = true;
+            assemblers.advection_system_assembler_on_face_properties[0].need_face_finite_element_evaluation = true;
+          }
+      }
+  }
+
+
+  namespace Melt
+  {
+    template <int dim>
+    void
+    Parameters<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Melt settings");
+      {
+        prm.declare_entry ("Melt scaling factor threshold", "1e-7",
+                           Patterns::Double (),
+                           "The factor by how much the Darcy coefficient K\\_D in a cell can be smaller than "
+                           "the reference Darcy coefficient for this cell still to be considered a melt cell "
+                           "(for which the melt transport equations are solved). For smaller Darcy coefficients, "
+                           "the Stokes equations (without melt) are solved instead. Only used if "
+                           "``Include melt transport'' is true. ");
+        prm.declare_entry ("Heat advection by melt", "false",
+                           Patterns::Bool (),
+                           "Whether to use a porosity weighted average of the melt and solid velocity "
+                           "to advect heat in the temperature equation or not. If this is set to true, "
+                           "additional terms are assembled on the left-hand side of the temperature "
+                           "advection equation. Only used if Include melt transport is true. "
+                           "If this is set to false, only the solid velocity is used (as in models "
+                           "without melt migration).");
+        prm.declare_entry ("Use discontinuous compaction pressure", "true",
+                           Patterns::Bool (),
+                           "Whether to use a discontinuous element for the compaction pressure or not. "
+                           "From our preliminary tests, continuous elements seem to work better in models "
+                           "where the porosity is > 0 everywhere in the domain, and discontinuous elements "
+                           "work better in models where in parts of the domain the porosity = 0.");
+        prm.declare_entry ("Average melt velocity", "true",
+                           Patterns::Bool (),
+                           "Whether to cell-wise average the material properties that are used to "
+                           "compute the melt velocity or not. The melt velocity is computed as the "
+                           "sum of the solid velocity and the phase separation flux "
+                           "$ - K_D / \\phi (\\nabla p_f - \\rho_f \\mathbf g)$. "
+                           "If this parameter is set to true, $K_D$ and $\\phi$ will be averaged "
+                           "cell-wise in the computation of the phase separation flux. "
+                           "This is useful because in some models the melt velocity can have spikes "
+                           "close to the interface between regions of melt and no melt, as both $K_D$ "
+                           "and $\\phi$ go to zero for vanishing melt fraction. As the melt velocity is "
+                           "used for computing the time step size, and in models that use heat "
+                           "transport by melt or shear heating of melt, setting this parameter to true "
+                           "can speed up the model and make it mode stable. In computations where "
+                           "accuracy and convergence behavior of the melt velocity is important "
+                           "(like in benchmark cases with an analytical solution), this parameter "
+                           "should probably be set to 'false'.");
+      }
+      prm.leave_subsection();
+
+      BoundaryFluidPressure::declare_parameters<dim> (prm);
+    }
+
+    template <int dim>
+    void
+    Parameters<dim>::
+    parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Melt settings");
+      {
+        melt_scaling_factor_threshold = prm.get_double("Melt scaling factor threshold");
+        heat_advection_by_melt = prm.get_bool("Heat advection by melt");
+        use_discontinuous_p_c = prm.get_bool("Use discontinuous compaction pressure");
+        average_melt_velocity = prm.get_bool("Average melt velocity");
+      }
+      prm.leave_subsection();
+    }
+  }
+
+  template <int dim>
+  MeltHandler<dim>::MeltHandler (ParameterHandler &prm)
+    :
+    boundary_fluid_pressure(BoundaryFluidPressure::create_boundary_fluid_pressure<dim>(prm))
+  {
+    CitationInfo::add("melt");
+    melt_parameters.parse_parameters(prm);
+    boundary_fluid_pressure->parse_parameters(prm);
+  }
+
+
+  template <int dim>
+  void
+  MeltHandler<dim>::initialize () const
+  {
+    // The additional terms in the temperature systems have not been ported
+    // to the DG formulation:
+    AssertThrow(!this->get_parameters().use_discontinuous_temperature_discretization &&
+                !this->get_parameters().have_discontinuous_composition_discretization,
+                ExcMessage("Using discontinuous elements for temperature "
+                           "or composition in models with melt transport is currently not implemented.") );
+    if (melt_parameters.use_discontinuous_p_c)
+      AssertThrow(!this->model_has_prescribed_stokes_solution(),
+                  ExcMessage("You can not use a discontinuous p_c in a model "
+                             "with a prescribed Stokes solution."));
+    // We can not have a DG p_f.
+    AssertThrow(!this->get_parameters().use_locally_conservative_discretization,
+                ExcMessage ("Discontinuous elements for the fluid pressure "
+                            "are not supported in models with melt transport."));
+  }
+
+
+  template <int dim>
+  void
+  MeltHandler<dim>::initialize_simulator (const Simulator<dim> &simulator_object)
+  {
+    this->SimulatorAccess<dim>::initialize_simulator(simulator_object);
+    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(boundary_fluid_pressure.get()))
+      sim->initialize_simulator (simulator_object);
+    boundary_fluid_pressure->initialize ();
+  }
+
+
+  template <int dim>
+  void
+  MeltHandler<dim>::
+  create_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output)
+  {
+    if (output.template get_additional_output<MaterialModel::MeltOutputs<dim>>() != nullptr)
+      return;
+
+    const unsigned int n_comp = output.reaction_terms[0].size();
+    output.additional_outputs.push_back(
+      std::make_unique<MaterialModel::MeltOutputs<dim>> (output.n_evaluation_points(), n_comp));
+  }
+
+
+  template <int dim>
+  void
+  MeltHandler<dim>::
+  apply_free_surface_stabilization_with_melt (const double free_surface_theta,
+                                              const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                              internal::Assembly::Scratch::StokesSystem<dim>       &scratch,
+                                              internal::Assembly::CopyData::StokesSystem<dim>      &data) const
+  {
+    const std::set<types::boundary_id> tmp_boundary_indicators_requiring_stabilization = this->get_mesh_deformation_handler().get_boundary_indicators_requiring_stabilization();
+    if (tmp_boundary_indicators_requiring_stabilization.empty())
+      return;
+
+    const unsigned int n_face_q_points = scratch.face_finite_element_values.n_quadrature_points;
+    const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+
+    // only apply on mesh deformation surfaces that require stabilization
+    if (cell->at_boundary() && cell->is_locally_owned())
+      for (const unsigned int face_no : cell->face_indices())
+        if (cell->face(face_no)->at_boundary())
+          {
+            const types::boundary_id boundary_indicator
+              = cell->face(face_no)->boundary_id();
+
+            if (tmp_boundary_indicators_requiring_stabilization.find(boundary_indicator) == tmp_boundary_indicators_requiring_stabilization.end())
+              continue;
+
+            scratch.face_finite_element_values.reinit(cell, face_no);
+
+            scratch.face_material_model_inputs.reinit  (scratch.face_finite_element_values,
+                                                        cell,
+                                                        this->introspection(),
+                                                        this->get_solution());
+
+            this->get_material_model().evaluate(scratch.face_material_model_inputs, scratch.face_material_model_outputs);
+
+            const unsigned int p_f_component_index = this->introspection().variable("fluid pressure").first_component_index;
+            const unsigned int p_c_component_index = this->introspection().variable("compaction pressure").first_component_index;
+
+            for (unsigned int q_point = 0; q_point < n_face_q_points; ++q_point)
+              {
+                for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+                  {
+                    const unsigned int component_index_i = this->get_fe().system_to_component_index(i).first;
+
+                    if (Assemblers::is_velocity_or_pressures(this->introspection(),p_c_component_index,p_f_component_index,component_index_i))
+                      {
+                        scratch.phi_u[i_stokes] = scratch.face_finite_element_values[this->introspection().extractors.velocities].value(i, q_point);
+                        ++i_stokes;
+                      }
+                    ++i;
+                  }
+
+                const Tensor<1,dim>
+                gravity = this->get_gravity_model().gravity_vector(scratch.face_finite_element_values.quadrature_point(q_point));
+                const double g_norm = gravity.norm();
+
+                // construct the relevant vectors
+                const Tensor<1,dim> n_hat = scratch.face_finite_element_values.normal_vector(q_point);
+                const Tensor<1,dim> g_hat = (g_norm == 0.0 ? Tensor<1,dim>() : gravity/g_norm);
+
+                const double pressure_perturbation = scratch.face_material_model_outputs.densities[q_point] *
+                                                     this->get_timestep() * free_surface_theta * g_norm;
+
+                // see Kaus et al 2010 for details of the stabilization term
+                for (unsigned int i=0; i< stokes_dofs_per_cell; ++i)
+                  for (unsigned int j=0; j< stokes_dofs_per_cell; ++j)
+                    {
+                      // The fictive stabilization stress is (phi_u[i].g)*(phi_u[j].n)
+                      const double stress_value = - pressure_perturbation
+                                                  * (scratch.phi_u[i] * g_hat) * (scratch.phi_u[j] * n_hat)
+                                                  * scratch.face_finite_element_values.JxW(q_point);
+
+                      data.local_matrix(i,j) += stress_value;
+                    }
+              }
+          }
+
+
+  }
+}
+
+
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+
+#define INSTANTIATE(dim) \
+  \
+  template \
+  class \
+  MeltHandler<dim>; \
+  \
+  namespace MaterialModel \
+  { \
+    template \
+    class \
+    MeltInputs<dim>; \
+  } \
+  \
+  namespace Melt \
+  { \
+    template struct Parameters<dim>; \
+  } \
+  namespace Assemblers \
+  { \
+    template class MeltInterface<dim>; \
+    template class MeltStokesPreconditioner<dim>; \
+    template class MeltStokesSystem<dim>; \
+    template class MeltStokesSystemBoundary<dim>; \
+    template class MeltAdvectionSystem<dim>; \
+    template class MeltPressureRHSCompatibilityModification<dim>; \
+    template class MeltBoundaryTraction<dim>; \
+  }
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+
+}
diff --git a/source/simulator/newton.cc.bak b/source/simulator/newton.cc.bak
new file mode 100644
index 00000000000..9297ebd3c15
--- /dev/null
+++ b/source/simulator/newton.cc.bak
@@ -0,0 +1,318 @@
+/*
+  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/newton.h>
+#include <aspect/simulator/assemblers/advection.h>
+#include <aspect/simulator/assemblers/stokes.h>
+
+#include <aspect/simulator.h>
+#include <aspect/citation_info.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    MaterialModelDerivatives<dim>::
+    MaterialModelDerivatives (const unsigned int n_points)
+      : viscosity_derivative_wrt_pressure(n_points, numbers::signaling_nan<double>())
+      , viscosity_derivative_wrt_strain_rate(n_points, numbers::signaling_nan<SymmetricTensor<2,dim>>())
+      , viscosity_derivative_averaging_weights(n_points, numbers::signaling_nan<double>())
+    {}
+  }
+
+
+
+  template <int dim>
+  void
+  NewtonHandler<dim>::
+  set_assemblers (Assemblers::Manager<dim> &assemblers) const
+  {
+    assemblers.stokes_preconditioner.push_back(std::make_unique<aspect::Assemblers::NewtonStokesPreconditioner<dim>>());
+    assemblers.stokes_system.push_back(std::make_unique<aspect::Assemblers::NewtonStokesIncompressibleTerms<dim>>());
+
+    if (this->get_material_model().is_compressible())
+      {
+        // The compressible part of the preconditioner is only necessary if we use the simplified A block
+        if (this->get_parameters().use_full_A_block_preconditioner == false)
+          assemblers.stokes_preconditioner.push_back(
+            std::make_unique<aspect::Assemblers::StokesCompressiblePreconditioner<dim>>());
+
+        assemblers.stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::NewtonStokesCompressibleStrainRateViscosityTerm<dim>>());
+      }
+
+    if (this->get_parameters().formulation_mass_conservation ==
+        Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile)
+      {
+        assemblers.stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::NewtonStokesImplicitReferenceDensityCompressibilityTerm<dim>>());
+      }
+    else if (this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::reference_density_profile)
+      {
+        assemblers.stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::NewtonStokesReferenceDensityCompressibilityTerm<dim>>());
+      }
+    else if (this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::incompressible)
+      {
+        // do nothing, because we assembled div u =0 above already
+      }
+    else if (this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::isentropic_compression)
+      {
+        assemblers.stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::NewtonStokesIsentropicCompressionTerm<dim>>());
+      }
+    else if (this->get_parameters().formulation_mass_conservation ==
+             Parameters<dim>::Formulation::MassConservation::projected_density_field)
+      {
+        CitationInfo::add("pda");
+        assemblers.stokes_system.push_back(
+          std::make_unique<aspect::Assemblers::NewtonStokesProjectedDensityFieldTerm<dim>>());
+      }
+    else
+      AssertThrow(false,
+                  ExcMessage("Unknown mass conservation equation approximation. There is no assembler"
+                             " defined that handles this formulation."));
+
+    // add the terms for traction boundary conditions
+    if (!this->get_boundary_traction_manager().get_active_boundary_traction_names().empty())
+      {
+        assemblers.stokes_system_on_boundary_face.push_back(
+          std::make_unique<aspect::Assemblers::StokesBoundaryTraction<dim>>());
+      }
+
+    // add the terms necessary to normalize the pressure
+    if (this->pressure_rhs_needs_compatibility_modification())
+      assemblers.stokes_system.push_back(
+        std::make_unique<aspect::Assemblers::StokesPressureRHSCompatibilityModification<dim>>());
+  }
+
+
+
+  template <int dim>
+  void
+  NewtonHandler<dim>::
+  create_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output)
+  {
+    if (output.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>() != nullptr)
+      return;
+
+    output.additional_outputs.push_back(
+      std::make_unique<MaterialModel::MaterialModelDerivatives<dim>>(output.n_evaluation_points()));
+  }
+
+
+
+  namespace Newton
+  {
+    std::string
+    to_string(const Newton::Parameters::Stabilization preconditioner_stabilization)
+    {
+      switch (preconditioner_stabilization)
+        {
+          case Newton::Parameters::Stabilization::SPD:
+            return "SPD";
+          case Newton::Parameters::Stabilization::PD:
+            return "PD";
+          case Newton::Parameters::Stabilization::symmetric:
+            return "symmetric";
+          case Newton::Parameters::Stabilization::none:
+            return "none";
+          default:
+            Assert(false,ExcNotImplemented());
+            return "";
+        }
+    }
+
+
+
+    void
+    Parameters::
+    declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Solver parameters");
+      {
+        prm.enter_subsection ("Newton solver parameters");
+        {
+          prm.declare_entry ("Nonlinear Newton solver switch tolerance", "1e-5",
+                             Patterns::Double(0., 1.),
+                             "A relative tolerance with respect to the residual of the first "
+                             "iteration, up to which the nonlinear Picard solver will iterate, "
+                             "before changing to the Newton solver.");
+
+          prm.declare_entry ("Max pre-Newton nonlinear iterations", "10",
+                             Patterns::Integer (0),
+                             "If the 'Nonlinear Newton solver switch tolerance' is reached before the "
+                             "maximal number of Picard iterations, then the solver switches to Newton "
+                             "solves anyway.");
+
+          prm.declare_entry ("Max Newton line search iterations", "5",
+                             Patterns::Integer (0),
+                             "The maximum number of line search iterations allowed. If the "
+                             "criterion is not reached after this number of iterations, we apply "
+                             "the scaled increment even though it does not satisfy the necessary "
+                             "criteria and simply continue with the next Newton iteration.");
+
+          prm.declare_entry ("Use Newton residual scaling method", "false",
+                             Patterns::Bool (),
+                             "This method allows to slowly introduce the derivatives based on the improvement "
+                             "of the residual. If set to false, the scaling factor for the Newton derivatives "
+                             "is set to one immediately when switching on the Newton solver. When this is set to "
+                             "true, the derivatives are slowly introduced by the following equation: $\\max(0.0, "
+                             "(1.0-(residual/switch\\_initial\\_residual)))$, where switch\\_initial\\_residual is the "
+                             "residual at the time when the Newton solver is switched on.");
+
+          prm.declare_entry ("Maximum linear Stokes solver tolerance", "1e-2",
+                             Patterns::Double (0., 1.),
+                             "The linear Stokes solver tolerance is dynamically chosen for the Newton solver, based "
+                             "on the Eisenstat Walker (1994) paper (https://doi.org/10.1137/0917003), equation 2.2. "
+                             "Because this value can become larger than one, we limit this value by this parameter.");
+
+          prm.declare_entry ("Stabilization preconditioner", "SPD",
+                             Patterns::Selection ("SPD|PD|symmetric|none"),
+                             "This parameters allows for the stabilization of the preconditioner. If one derives the Newton "
+                             "method without any modifications, the matrix created for the preconditioning is not necessarily "
+                             "Symmetric Positive Definite. This is problematic (see \\cite{fraters:etal:2019}). When `none' is chosen, "
+                             "the preconditioner is not stabilized. The `symmetric' parameters symmetrizes the matrix, and `PD' makes "
+                             "the matrix Positive Definite. `SPD' is the full stabilization, where the matrix is guaranteed Symmetric "
+                             "Positive Definite.");
+
+          prm.declare_entry ("Stabilization velocity block", "SPD",
+                             Patterns::Selection ("SPD|PD|symmetric|none"),
+                             "This parameters allows for the stabilization of the velocity block. If one derives the Newton "
+                             "method without any modifications, the matrix created for the velocity block is not necessarily "
+                             "Symmetric Positive Definite. This is problematic (see \\cite{fraters:etal:2019}). When `none' is chosen, "
+                             "the velocity block is not stabilized. The `symmetric' parameters symmetrizes the matrix, and `PD' makes "
+                             "the matrix Positive Definite. `SPD' is the full stabilization, where the matrix is guaranteed Symmetric "
+                             "Positive Definite.");
+
+          prm.declare_entry ("Use Newton failsafe", "false",
+                             Patterns::Bool (),
+                             "When this parameter is true and the linear solver fails, we try again, but now with SPD stabilization "
+                             "for both the preconditioner and the velocity block. The SPD stabilization will remain active until "
+                             "the next timestep, when the default values are restored.");
+
+
+          prm.declare_entry ("SPD safety factor", "0.9",
+                             Patterns::Double (0., 1.),
+                             "When stabilizing the Newton matrix, we can encounter situations where the coefficient inside the elliptic (top-left) "
+                             "block becomes negative or zero. This coefficient has the form $1+x$ where $x$ can sometimes be smaller than $-1$. In "
+                             "this case, the top-left block of the matrix is no longer positive definite, and both preconditioners and iterative "
+                             "solvers may fail. To prevent this, the stabilization computes an $\\alpha$ so that $1+\\alpha x$ is never negative "
+                             "and so that always "
+                             "$0\\le \\alpha \\le 1$.  On the other hand, we also want to stay away from $1+\\alpha x=0$, and so modify the choice of "
+                             "$\\alpha$ by a factor $c$ between zero and one so that if $c<1$, we are "
+                             "assured that $1+\\alpha x>0$, i.e., bounded away from zero. If $c=1$, we allow $1+\\alpha x=0$, i.e., an "
+                             "unsafe situation. If $c=0$, then $\\alpha$ is always set to zero which guarantees the desired property that "
+                             "$1+\\alpha x=1>0$, but at the cost of a diminished convergence rate of the Newton method.");
+
+          prm.declare_entry ("Use Eisenstat Walker method for Picard iterations", "false",
+                             Patterns::Bool(),
+                             "If set to true, the Picard iteration uses the Eisenstat Walker method to determine how accurately linear systems need "
+                             "to be solved. The Picard iteration is used, for example, in the first few iterations of the Newton method before the "
+                             "matrix is built including derivatives of the model, since the Picard iteration generally converges even from points "
+                             "where Newton's method does not. "
+                             "\n\n"
+                             "Once derivatives are used in a Newton method, \\aspect{} always uses the Eisenstat Walker method.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+
+    void
+    Parameters::
+    parse_parameters (ParameterHandler &prm)
+    {
+      CitationInfo::add("NewtonSolver");
+      prm.enter_subsection ("Solver parameters");
+      {
+        prm.enter_subsection ("Newton solver parameters");
+        {
+          nonlinear_switch_tolerance = prm.get_double("Nonlinear Newton solver switch tolerance");
+          max_pre_newton_nonlinear_iterations = prm.get_integer ("Max pre-Newton nonlinear iterations");
+          max_newton_line_search_iterations = prm.get_integer ("Max Newton line search iterations");
+          use_newton_residual_scaling_method = prm.get_bool("Use Newton residual scaling method");
+          maximum_linear_stokes_solver_tolerance = prm.get_double("Maximum linear Stokes solver tolerance");
+          std::string preconditioner_stabilization_string = prm.get("Stabilization preconditioner");
+          if (preconditioner_stabilization_string == "SPD")
+            preconditioner_stabilization = Stabilization::SPD;
+          else if (preconditioner_stabilization_string == "PD")
+            preconditioner_stabilization = Stabilization::PD;
+          else if (preconditioner_stabilization_string == "symmetric")
+            preconditioner_stabilization = Stabilization::symmetric;
+          else if (preconditioner_stabilization_string == "none")
+            preconditioner_stabilization = Stabilization::none;
+
+          std::string velocity_block_stabilization_string = prm.get("Stabilization velocity block");
+          if (velocity_block_stabilization_string == "SPD")
+            velocity_block_stabilization = Stabilization::SPD;
+          else if (velocity_block_stabilization_string == "PD")
+            velocity_block_stabilization = Stabilization::PD;
+          else if (velocity_block_stabilization_string == "symmetric")
+            velocity_block_stabilization = Stabilization::symmetric;
+          else if (velocity_block_stabilization_string == "none")
+            velocity_block_stabilization = Stabilization::none;
+
+          use_Newton_failsafe = prm.get_bool("Use Newton failsafe");
+          SPD_safety_factor = prm.get_double("SPD safety factor");
+          use_Eisenstat_Walker_method_for_Picard_iterations = prm.get_bool("Use Eisenstat Walker method for Picard iterations");
+
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+    }
+  }
+}
+
+
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+
+#define INSTANTIATE(dim) \
+  \
+  template \
+  class \
+  NewtonHandler<dim>; \
+  \
+  namespace MaterialModel \
+  { \
+    template \
+    class \
+    MaterialModelDerivatives<dim>; \
+  }
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+
+}
diff --git a/source/simulator/nullspace.cc.bak b/source/simulator/nullspace.cc.bak
new file mode 100644
index 00000000000..ad692cf6185
--- /dev/null
+++ b/source/simulator/nullspace.cc.bak
@@ -0,0 +1,522 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+
+#include <deal.II/base/tensor_function.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace internal
+  {
+
+    /**
+     * A class we use when setting up the data structures for nullspace removal
+     * of the rotations in spherical or annular shells.
+     */
+    template <int dim>
+    class Rotation : public TensorFunction<1,dim>
+    {
+      private:
+        const Tensor<1,dim> axis;
+
+      public:
+        // Constructor for TensorFunction that takes cartesian direction (1,2, or 3)
+        // and creates a solid body rotation around that axis.
+        Rotation(const unsigned int a)
+          :
+          axis(Tensor<1,dim>(Point<dim>::unit_vector(a)))
+        {}
+
+        // Constructor for TensorFunction that takes an axis
+        // and creates a solid body rotation around that axis.
+        Rotation(const Tensor<1,dim> &rotation_axis)
+          :
+          axis(rotation_axis)
+        {}
+
+        Tensor<1,dim> value (const Point<dim> &p) const override
+        {
+          if ( dim == 2)
+            return cross_product_2d(p);
+          else
+            return cross_product_3d(axis, p);
+        }
+    };
+
+
+    /**
+     * A class we use when setting up the data structures for nullspace removal
+     * of the translations in box-like geometries.
+     */
+    template <int dim>
+    class Translation : public TensorFunction<1,dim>
+    {
+      private:
+        const Tensor<1,dim> translation;
+
+      public:
+        // Constructor for TensorFunction that takes a Cartesian direction (1,2, or 3)
+        // and creates a translation along that axis
+        Translation(const unsigned int d)
+          :
+          translation( Point<dim>::unit_vector(d) )
+        {}
+
+        // Constructor for TensorFunction that takes a vector
+        // and creates a translation along that vector
+        Translation(const Tensor<1,dim> &t)
+          :
+          translation(t)
+        {}
+
+        Tensor<1,dim> value(const Point<dim> &) const override
+        {
+          return translation;
+        }
+    };
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::setup_nullspace_constraints(AffineConstraints<double> &constraints)
+  {
+    if (parameters.nullspace_removal & NullspaceRemoval::any_translation)
+      {
+        // Note: We want to add a single Dirichlet zero constraint for each
+        // translation direction. This is complicated by the fact that we need to
+        // find a DoF that is not already constrained. In parallel the constraint
+        // needs to be added on all processors where it is locally_relevant and
+        // all processors need to agree on the index.
+
+        // First find candidates for DoF indices to constrain for each velocity component.
+        std::array<types::global_dof_index,dim> vel_idx;
+        {
+          for (types::global_dof_index &idx : vel_idx)
+            idx = numbers::invalid_dof_index;
+
+          unsigned int n_left_to_find = dim;
+
+          std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
+          typename DoFHandler<dim>::active_cell_iterator cell;
+          for (const auto &cell : dof_handler.active_cell_iterators())
+            if (cell->is_locally_owned())
+              {
+                cell->get_dof_indices (local_dof_indices);
+
+                for (unsigned int i=0; i<finite_element.dofs_per_cell; ++i)
+                  {
+                    const unsigned int component = finite_element.system_to_component_index(i).first;
+
+                    if (component < introspection.component_indices.velocities[0]
+                        || component > introspection.component_indices.velocities[dim-1])
+                      continue; // only look at velocity
+
+                    const unsigned int velocity_component = component - introspection.component_indices.velocities[0];
+
+                    if (vel_idx[velocity_component] != numbers::invalid_dof_index)
+                      continue; // already found one
+
+                    const types::global_dof_index idx = local_dof_indices[i];
+
+                    if (constraints.can_store_line(idx) && !constraints.is_constrained(idx))
+                      {
+                        vel_idx[velocity_component] = idx;
+                        --n_left_to_find;
+                      }
+
+                    // are we done searching?
+                    if (n_left_to_find == 0)
+                      goto after_cell_loop; // exit both nested loops at the same time
+                  }
+              }
+
+        after_cell_loop:
+          ;
+        }
+
+
+        const unsigned int flags[] = {(NullspaceRemoval::linear_momentum_x
+                                       |NullspaceRemoval::net_translation_x),
+                                      (NullspaceRemoval::linear_momentum_y
+                                       |NullspaceRemoval::net_translation_y),
+                                      (NullspaceRemoval::linear_momentum_z
+                                       |NullspaceRemoval::net_translation_z)
+                                     };
+
+        for (unsigned int d=0; d<dim; ++d)
+          if (parameters.nullspace_removal & flags[d])
+            {
+              // Make a reduction to find the smallest index (processors that
+              // found a larger candidate just happened to not be able to store
+              // that index with the minimum value). Note that it is possible that
+              // some processors might not be able to find a potential DoF, for
+              // example because they don't own any DoFs. On those processors we
+              // will use dof_handler.n_dofs() when building the minimum (larger
+              // than any valid DoF index).
+              const types::global_dof_index global_idx = dealii::Utilities::MPI::min(
+                                                           (vel_idx[d] != numbers::invalid_dof_index)
+                                                           ?
+                                                           vel_idx[d]
+                                                           :
+                                                           dof_handler.n_dofs(),
+                                                           mpi_communicator);
+
+              Assert(global_idx < dof_handler.n_dofs(),
+                     ExcMessage("Error, couldn't find a velocity DoF to constrain."));
+
+              // Finally set this DoF to zero (if the current MPI process
+              // cares about it):
+              if (constraints.can_store_line(global_idx))
+                {
+                  Assert(!constraints.is_constrained((global_idx)),
+                         ExcInternalError());
+#if DEAL_II_VERSION_GTE(9,6,0)
+                  constraints.constrain_dof_to_zero(global_idx);
+#else
+                  constraints.add_line(global_idx);
+#endif
+                }
+            }
+      }
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::remove_nullspace(LinearAlgebra::BlockVector &relevant_dst,
+                                        LinearAlgebra::BlockVector &tmp_distributed_stokes)
+  {
+    if (parameters.nullspace_removal & NullspaceRemoval::angular_momentum)
+      {
+        remove_net_angular_momentum( /* use_constant_density = */ false, // remove net momentum
+                                                                  relevant_dst,
+                                                                  tmp_distributed_stokes);
+      }
+    if (parameters.nullspace_removal & NullspaceRemoval::net_rotation)
+      {
+        remove_net_angular_momentum( /* use_constant_density = */ true, // remove net rotation
+                                                                  relevant_dst,
+                                                                  tmp_distributed_stokes);
+      }
+    if (parameters.nullspace_removal & NullspaceRemoval::net_surface_rotation)
+      {
+        remove_net_angular_momentum( /* use_constant_density = */ true, // remove net rotation
+                                                                  relevant_dst,
+                                                                  tmp_distributed_stokes,
+                                                                  /* limit_to_top_faces = */ true);
+      }
+
+    if (parameters.nullspace_removal & NullspaceRemoval::linear_momentum)
+      {
+        remove_net_linear_momentum( /* use_constant_density = */ false, // remove net momentum
+                                                                 relevant_dst,
+                                                                 tmp_distributed_stokes);
+      }
+    if (parameters.nullspace_removal & NullspaceRemoval::net_translation)
+      {
+        remove_net_linear_momentum( /* use_constant_density = */ true, // remove net translation
+                                                                 relevant_dst,
+                                                                 tmp_distributed_stokes);
+      }
+  }
+
+  template <int dim>
+  void Simulator<dim>::remove_net_linear_momentum( const bool use_constant_density,
+                                                   LinearAlgebra::BlockVector &relevant_dst,
+                                                   LinearAlgebra::BlockVector &tmp_distributed_stokes )
+  {
+    Assert(introspection.block_indices.velocities != introspection.block_indices.pressure,
+           ExcNotImplemented());
+
+    // compute and remove net linear momentum from velocity field, by computing
+    // \int \rho (v + v_const) = 0
+    const Quadrature<dim> &quadrature = introspection.quadratures.velocities;
+    const unsigned int n_q_points = quadrature.size();
+    FEValues<dim> fe(*mapping, finite_element, quadrature,
+                     UpdateFlags(update_quadrature_points | update_JxW_values | update_values | update_gradients));
+
+    Tensor<1,dim> local_momentum;
+    double local_mass = 0.0;
+
+    // loop over all local cells
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          fe.reinit (cell);
+
+          // get the density at each quadrature point if necessary
+          MaterialModel::MaterialModelInputs<dim> in(n_q_points,
+                                                     introspection.n_compositional_fields);
+          MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
+                                                       introspection.n_compositional_fields);
+
+          if (use_constant_density)
+            {
+              // get only the velocity at each quadrature point
+              fe[introspection.extractors.velocities].get_function_values (relevant_dst, in.velocity);
+            }
+          else
+            {
+              // get all material inputs including velocity and evaluate for density
+              in.reinit(fe,cell,introspection,relevant_dst);
+              in.requested_properties = MaterialModel::MaterialProperties::density;
+              material_model->evaluate(in, out);
+            }
+
+          // actually compute the momentum and mass
+          for (unsigned int k=0; k<n_q_points; ++k)
+            {
+              // get the density at this quadrature point
+              const double rho = (use_constant_density ? 1.0 : out.densities[k]);
+              const double JxW = fe.JxW(k);
+
+              local_momentum += in.velocity[k] * rho * JxW;
+              local_mass += rho * JxW;
+            }
+        }
+
+    // Calculate the total mass and velocity correction
+    const double mass = Utilities::MPI::sum(local_mass, mpi_communicator);
+    Tensor<1,dim> velocity_correction = Utilities::MPI::sum(local_momentum, mpi_communicator) / mass;
+
+    // We may only want to remove the nullspace for a single component, so zero out
+    // the velocity correction if it is not selected by the NullspaceRemoval flag
+    if (use_constant_density) // disable translation correction
+      {
+        if ( !(parameters.nullspace_removal & NullspaceRemoval::net_translation_x) )
+          velocity_correction[0] = 0.0;  // don't correct x translation
+        if ( !(parameters.nullspace_removal & NullspaceRemoval::net_translation_y) )
+          velocity_correction[1] = 0.0;  // don't correct y translation
+        if ( !(parameters.nullspace_removal & NullspaceRemoval::net_translation_z) && dim == 3 )
+          velocity_correction[2] = 0.0;  // don't correct z translation
+      }
+    else // disable momentum correction
+      {
+        if ( !(parameters.nullspace_removal & NullspaceRemoval::linear_momentum_x) )
+          velocity_correction[0] = 0.0;  // don't correct x translation
+        if ( !(parameters.nullspace_removal & NullspaceRemoval::linear_momentum_y) )
+          velocity_correction[1] = 0.0;  // don't correct y translation
+        if ( !(parameters.nullspace_removal & NullspaceRemoval::linear_momentum_z) && dim == 3 )
+          velocity_correction[2] = 0.0;  // don't correct z translation
+      }
+
+    // vector for storing the correction to the velocity field
+    LinearAlgebra::Vector correction(tmp_distributed_stokes.block(introspection.block_indices.velocities));
+
+    // Now construct a translation vector with the desired rate and subtract it from our vector
+    internal::Translation<dim> translation( velocity_correction );
+    interpolate_onto_velocity_system(translation, correction);
+    tmp_distributed_stokes.block(introspection.block_indices.velocities).add(-1.0,correction);
+
+    // copy into the locally relevant vector
+    relevant_dst.block(introspection.block_indices.velocities) =
+      tmp_distributed_stokes.block(introspection.block_indices.velocities);
+  }
+
+
+
+  template <int dim>
+  RotationProperties<dim>
+  Simulator<dim>::compute_net_angular_momentum(const bool use_constant_density,
+                                               const LinearAlgebra::BlockVector &solution,
+                                               const bool limit_to_top_faces) const
+  {
+    // compute the momentum from velocity field, by computing
+    // \int \rho u \cdot r_orth = \omega  * \int \rho x^2    ( 2 dimensions)
+    // \int \rho r \times u =  I \cdot \omega  (3 dimensions)
+
+    const Quadrature<dim> &quadrature = introspection.quadratures.velocities;
+    const Quadrature<dim-1> &surface_quadrature = introspection.face_quadratures.velocities;
+
+    const unsigned int n_q_points = (limit_to_top_faces == false) ? quadrature.size() : surface_quadrature.size();
+    UpdateFlags flags = update_quadrature_points | update_JxW_values | update_values | update_gradients;
+
+    FEValues<dim> fe_values (*mapping, finite_element, quadrature, flags);
+    FEFaceValues<dim> fe_face_values (*mapping, finite_element, surface_quadrature, flags);
+    FEValuesBase<dim> &fe((limit_to_top_faces == false)
+                          ?
+                          dynamic_cast<FEValuesBase<dim> &>(fe_values)
+                          :
+                          dynamic_cast<FEValuesBase<dim> &>(fe_face_values));
+
+    // moment of inertia and angular momentum for 3d
+    SymmetricTensor<2,dim> local_moment_of_inertia;
+    Tensor<1,dim> local_angular_momentum;
+
+    // analogues to the moment of inertia and angular momentum for 2d
+    double local_scalar_moment_of_inertia = 0.0;
+    double local_scalar_angular_momentum = 0.0;
+
+    // Structures for evaluating the velocities and the material model
+    MaterialModel::MaterialModelInputs<dim> in(n_q_points,
+                                               introspection.n_compositional_fields);
+    MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
+                                                 introspection.n_compositional_fields);
+    in.requested_properties = MaterialModel::MaterialProperties::density;
+
+    // loop over all local cells
+    for (const auto &cell : dof_handler.active_cell_iterators())
+      if (cell->is_locally_owned())
+        {
+          if (limit_to_top_faces == false)
+            fe_values.reinit(cell);
+          else
+            {
+              // We only want the output at the top boundary, so only compute it if the current cell
+              // has a face at the top boundary.
+              bool cell_at_top_boundary = false;
+              for (const unsigned int f : cell->face_indices())
+                if (cell->at_boundary(f) &&
+                    (geometry_model->translate_id_to_symbol_name(cell->face(f)->boundary_id()) == "top"))
+                  {
+                    Assert(cell_at_top_boundary == false,
+                           ExcInternalError("Error, more than one top surface found in a cell."));
+
+                    cell_at_top_boundary = true;
+                    fe_face_values.reinit(cell, f);
+                  }
+
+              if (cell_at_top_boundary == false)
+                continue;
+            }
+
+          const std::vector<Point<dim>> &q_points = fe.get_quadrature_points();
+
+          if (use_constant_density == false)
+            {
+              // Set use_strain_rates to false since we don't need viscosity
+              in.reinit(fe, cell, introspection, solution);
+              material_model->evaluate(in, out);
+            }
+          else
+            {
+              // Get the velocity at each quadrature point
+              fe[introspection.extractors.velocities].get_function_values(solution, in.velocity);
+            }
+
+          // actually compute the moment of inertia and angular momentum
+          for (unsigned int k = 0; k < n_q_points; ++k)
+            {
+              // get the position and density at this quadrature point
+              const Point<dim> r_vec = q_points[k];
+              const double rho = (use_constant_density ? 1.0 : out.densities[k]);
+              const double JxW = fe.JxW(k);
+
+              if (dim == 2)
+                {
+                  // Get the velocity perpendicular to the position vector
+                  const Tensor<1, dim> r_perp = cross_product_2d(r_vec);
+
+                  local_scalar_angular_momentum += in.velocity[k] * r_perp * rho * JxW;
+                  local_scalar_moment_of_inertia += r_vec.norm_square() * rho * JxW;
+                }
+              else
+                {
+                  const Tensor<1, dim> r_cross_v = cross_product_3d(r_vec, in.velocity[k]);
+
+                  local_angular_momentum += r_cross_v * rho * JxW;
+                  local_moment_of_inertia += (r_vec.norm_square() * unit_symmetric_tensor<dim>() - symmetrize(outer_product(r_vec, r_vec))) * rho * JxW;
+                }
+            }
+        }
+
+    RotationProperties<dim> properties;
+
+    // Sum up the local contributions and solve for the overall rotation
+    if (dim == 2)
+      {
+        properties.scalar_moment_of_inertia = Utilities::MPI::sum(local_scalar_moment_of_inertia, mpi_communicator);
+        properties.scalar_angular_momentum = Utilities::MPI::sum(local_scalar_angular_momentum, mpi_communicator);
+        properties.scalar_rotation = properties.scalar_angular_momentum / properties.scalar_moment_of_inertia;
+      }
+    else
+      {
+        properties.tensor_moment_of_inertia = Utilities::MPI::sum(local_moment_of_inertia,
+                                                                  mpi_communicator);
+        properties.tensor_angular_momentum = Utilities::MPI::sum(local_angular_momentum, mpi_communicator );
+        const SymmetricTensor<2,dim> inverse_moment (invert(Tensor<2,dim>(properties.tensor_moment_of_inertia)));
+        properties.tensor_rotation = - inverse_moment * properties.tensor_angular_momentum;
+      }
+
+    return properties;
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::remove_net_angular_momentum( const bool use_constant_density,
+                                                    LinearAlgebra::BlockVector &relevant_dst,
+                                                    LinearAlgebra::BlockVector &tmp_distributed_stokes,
+                                                    const bool limit_to_top_faces)
+  {
+    Assert(introspection.block_indices.velocities != introspection.block_indices.pressure,
+           ExcNotImplemented());
+
+    RotationProperties<dim> rotation_properties = compute_net_angular_momentum(use_constant_density,
+                                                                               relevant_dst,
+                                                                               limit_to_top_faces);
+
+    // vector for storing the correction to the velocity field
+    LinearAlgebra::Vector correction(tmp_distributed_stokes.block(introspection.block_indices.velocities));
+
+    if (dim == 2)
+      {
+        // Now construct a rotation vector with the desired rate and subtract it from our vector
+        const internal::Rotation<dim> rot(0);
+        interpolate_onto_velocity_system(rot, correction);
+        tmp_distributed_stokes.block(introspection.block_indices.velocities).add(-1.0*rotation_properties.scalar_rotation,correction);
+      }
+    else
+      {
+        // Remove that rotation from the solution vector
+        const internal::Rotation<dim> rot(rotation_properties.tensor_rotation);
+        interpolate_onto_velocity_system(rot, correction);
+        tmp_distributed_stokes.block(introspection.block_indices.velocities).add(1.0,correction);
+      }
+
+    // copy into the locally relevant vector
+    relevant_dst.block(introspection.block_indices.velocities) =
+      tmp_distributed_stokes.block(introspection.block_indices.velocities);
+  }
+
+}
+
+
+
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template struct RotationProperties<dim>; \
+  template void Simulator<dim>::remove_nullspace (LinearAlgebra::BlockVector &,LinearAlgebra::BlockVector &vector); \
+  template void Simulator<dim>::setup_nullspace_constraints (AffineConstraints<double> &);
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/parameters.cc b/source/simulator/parameters.cc
index 9738cb515aa..3fd32e22c08 100644
--- a/source/simulator/parameters.cc
+++ b/source/simulator/parameters.cc
@@ -1640,15 +1640,15 @@ namespace aspect
           additional_refinement_time *= year_in_seconds;
 
       skip_solvers_on_initial_refinement = prm.get_bool("Skip solvers on initial refinement");
-      skip_setup_initial_conditions_on_initial_refinement = prm.get_bool("Skip setup initial conditions on initial refinement");
+      skip_setup_initial_temperature_on_initial_refinement = prm.get_bool("Skip setup initial conditions on initial refinement");
 
-      if (skip_setup_initial_conditions_on_initial_refinement == true && skip_solvers_on_initial_refinement == false)
+      if (skip_setup_initial_temperature_on_initial_refinement == true && skip_solvers_on_initial_refinement == false)
         AssertThrow(false, ExcMessage("Cannot execute solvers if no initial conditions are set up. "
                                       "You must set skip_solvers_on_initial_refinement to true."));
 
       run_postprocessors_on_initial_refinement = prm.get_bool("Run postprocessors on initial refinement");
 
-      if (skip_setup_initial_conditions_on_initial_refinement == true && run_postprocessors_on_initial_refinement == true)
+      if (skip_setup_initial_temperature_on_initial_refinement == true && run_postprocessors_on_initial_refinement == true)
         AssertThrow(false, ExcMessage("Cannot run postprocessors if no initial conditions are set up. "
                                       "You must set run_postprocessors_on_initial_refinement to false."));
     }
diff --git a/source/simulator/parameters.cc.bak b/source/simulator/parameters.cc.bak
new file mode 100644
index 00000000000..9738cb515aa
--- /dev/null
+++ b/source/simulator/parameters.cc.bak
@@ -0,0 +1,2329 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/melt.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/stokes_matrix_free.h>
+#include <aspect/newton.h>
+#include <aspect/mesh_deformation/free_surface.h>
+
+#include <deal.II/base/parameter_handler.h>
+
+#include <boost/lexical_cast.hpp>
+#include <cstdlib>
+#include <regex>
+#include <sys/stat.h>
+
+namespace aspect
+{
+  template <int dim>
+  Parameters<dim>::Parameters (ParameterHandler &prm,
+                               const MPI_Comm mpi_communicator)
+  {
+    parse_parameters (prm, mpi_communicator);
+  }
+
+
+  template <int dim>
+  void
+  Parameters<dim>::
+  declare_parameters (ParameterHandler &prm)
+  {
+    prm.declare_entry ("Dimension", "2",
+                       Patterns::Integer (2,3),
+                       "The number of space dimensions you want to run this program in. "
+                       "ASPECT can run in 2 and 3 space dimensions.");
+    prm.declare_entry ("Additional shared libraries", "",
+                       Patterns::List (Patterns::FileName()),
+                       "A list of names of additional shared libraries that should be loaded "
+                       "upon starting up the program. The names of these files can contain absolute "
+                       "or relative paths (relative to the directory in which you call ASPECT). "
+                       "In fact, file names that do not contain any directory "
+                       "information (i.e., only the name of a file such as <libmyplugin.so> "
+                       "will not be found if they are not located in one of the directories "
+                       "listed in the \\texttt{LD_LIBRARY_PATH} environment variable. In order "
+                       "to load a library in the current directory, use <./libmyplugin.so> "
+                       "instead."
+                       "\n\n"
+                       "If you specify <./libmyplugin.so>, ASPECT will open either "
+                       "<./libmyplugin.debug.so> or <./libmyplugin.release.so> "
+                       "depending on the current ASPECT build type."
+                       "\n\n"
+                       "The typical use of this parameter is so that you can implement "
+                       "additional plugins in your own directories, rather than in the ASPECT "
+                       "source directories. You can then simply compile these plugins into a "
+                       "shared library without having to re-compile all of ASPECT. See the "
+                       "section of the manual discussing writing extensions for more "
+                       "information on how to compile additional files into a shared "
+                       "library.");
+
+    prm.declare_entry ("Resume computation", "false",
+                       Patterns::Selection ("true|false|auto"),
+                       "A flag indicating whether the computation should be resumed from "
+                       "a previously saved state (if true) or start from scratch (if false). "
+                       "If auto is selected, models will be resumed if there is an existing "
+                       "checkpoint file, otherwise started from scratch.");
+
+    prm.declare_entry ("Max nonlinear iterations", "10",
+                       Patterns::Integer (1),
+                       "The maximal number of nonlinear iterations to be performed.");
+
+    prm.declare_entry ("Max nonlinear iterations in pre-refinement", boost::lexical_cast<std::string>(std::numeric_limits<int>::max()),
+                       Patterns::Integer (0),
+                       "The maximal number of nonlinear iterations to be performed in the pre-refinement "
+                       "steps. This does not include the last refinement step before moving to timestep 1. "
+                       "When this parameter has a larger value than max nonlinear iterations, the latter is used.");
+
+    prm.declare_entry ("Start time", "0.",
+                       Patterns::Double (),
+                       "The start time of the simulation. Units: Years if the "
+                       "'Use years in output instead of seconds' parameter is set; "
+                       "seconds otherwise.");
+
+    prm.declare_entry ("Timing output frequency", "100",
+                       Patterns::Integer(0),
+                       "How frequently in timesteps to output timing information. This is "
+                       "generally adjusted only for debugging and timing purposes. If the "
+                       "value is set to zero it will also output timing information at the "
+                       "initiation timesteps.");
+
+    prm.declare_entry ("Use years in output instead of seconds", "true",
+                       Patterns::Bool (),
+                       "When computing results for mantle convection simulations, "
+                       "it is often difficult to judge the order of magnitude of results "
+                       "when they are stated in MKS units involving seconds. Rather, "
+                       "some kinds of results such as velocities are often stated in "
+                       "terms of meters per year (or, sometimes, centimeters per year). "
+                       "On the other hand, for non-dimensional computations, one wants "
+                       "results in their natural unit system as used inside the code. "
+                       "If this flag is set to `true' conversion to years happens; if "
+                       "it is `false', no such conversion happens."
+                       "\n\n"
+                       "Contrary to the word ``output'' in the name of this parameter, "
+                       "a number of plugins also use this parameter to determine "
+                       "how to interpret their \\textit{inputs}. For example, when `true', "
+                       "several of the boundary velocity models described in Section~"
+                       "\\ref{parameters:Boundary_20velocity_20model} interpret both "
+                       "specific times in years instead of seconds, and velocities in "
+                       "meters per year instead of meters per second.");
+
+    prm.declare_entry ("CFL number", "1.0",
+                       Patterns::Double (0.),
+                       "In computations, the time step $k$ is chosen according to "
+                       "$k = c \\min_K \\frac {h_K} {\\|u\\|_{\\infty,K} p_T}$ where $h_K$ is the "
+                       "diameter of cell $K$, and the denominator is the maximal magnitude "
+                       "of the velocity on cell $K$ times the polynomial degree $p_T$ of the "
+                       "temperature discretization. The dimensionless constant $c$ is called the "
+                       "CFL number in this program. For time discretizations that have explicit "
+                       "components, $c$ must be less than a constant that depends on the "
+                       "details of the time discretization and that is no larger than one. "
+                       "On the other hand, for implicit discretizations such as the one chosen "
+                       "here, one can choose the time step as large as one wants (in particular, "
+                       "one can choose $c>1$) though a CFL number significantly larger than "
+                       "one will yield rather diffusive solutions. Units: None.");
+
+    prm.declare_entry ("Maximum time step",
+                       /* boost::lexical_cast<std::string>(std::numeric_limits<double>::max() /
+                                                           year_in_seconds) = */ "5.69e+300",
+                       Patterns::Double (0.),
+                       "Set a maximum time step size for the solver to use. Generally the time step "
+                       "based on the CFL number should be sufficient, but for complicated models "
+                       "or benchmarking it may be useful to limit the time step to some value. "
+                       "The default value is a value so that when converted from years into seconds "
+                       "it equals the largest number representable by a floating "
+                       "point number, implying an unlimited time step."
+                       "Units: Years or seconds, depending on the ``Use years "
+                       "in output instead of seconds'' parameter.");
+
+    prm.declare_entry ("Maximum first time step",
+                       /* boost::lexical_cast<std::string>(std::numeric_limits<double>::max() /
+                                                           year_in_seconds) = */ "5.69e+300",
+                       Patterns::Double (0.),
+                       "Set a maximum time step size for only the first timestep. Generally the time step "
+                       "based on the CFL number should be sufficient, but for complicated models "
+                       "or benchmarking it may be useful to limit the first time step to some value, "
+                       "especially when using the free surface, which needs to settle to prevent "
+                       "instabilities. This should in that case be combined with a value set for "
+                       "``Maximum relative increase in time step''. "
+                       "The default value is a value so that when converted from years into seconds "
+                       "it equals the largest number representable by a floating "
+                       "point number, implying an unlimited time step. "
+                       "Units: Years or seconds, depending on the ``Use years "
+                       "in output instead of seconds'' parameter.");
+
+    prm.declare_entry ("Maximum relative increase in time step",
+                       "91.0",
+                       Patterns::Double (0.),
+                       "Set a percentage with which the length of the time step is limited to increase. Generally the "
+                       "time step based on the CFL number should be sufficient, but for complicated models "
+                       "which may suddenly drastically change behavior, it may be useful to limit the increase "
+                       "in the time step, without limiting the time step size of the whole simulation to a "
+                       "particular number. For example, if this parameter is set to $50$, then that means that "
+                       "the length of a time step can at most increase by 50\\% from one time step to the next, or by a "
+                       "factor of 1.5. "
+                       "\n\n"
+                       "Here, the default value is set to be 91\\% because the best available step-size ratio bound "
+                       "guaranteeing stability in the PDE context seems to be 1.91, see \\cite{Denner:2014}. "
+                       "In that thesis, the bound was proved in the context of semilinear parabolic problem, "
+                       "but it appears reasonable to also use this value as an upper bound in the current "
+                       "context."
+                       "\n\n"
+                       "Units: \\%.");
+
+    prm.declare_entry ("Use conduction timestep", "false",
+                       Patterns::Bool (),
+                       "Mantle convection simulations are often focused on convection "
+                       "dominated systems. However, these codes can also be used to "
+                       "investigate systems where heat conduction plays a dominant role. "
+                       "This parameter indicates whether the simulator should also use "
+                       "heat conduction in determining the length of each time step.");
+
+    const std::string allowed_solver_schemes = "single Advection, single Stokes|iterated Advection and Stokes|"
+                                               "single Advection, iterated Stokes|no Advection, iterated Stokes|"
+                                               "no Advection, single Stokes|"
+                                               "no Advection, iterated defect correction Stokes|"
+                                               "single Advection, iterated defect correction Stokes|"
+                                               "iterated Advection and defect correction Stokes|"
+                                               "iterated Advection and Newton Stokes|single Advection, iterated Newton Stokes|"
+                                               "single Advection, no Stokes|IMPES|iterated IMPES|"
+                                               "iterated Stokes|Newton Stokes|Stokes only|Advection only|"
+                                               "first timestep only, single Stokes|no Advection, no Stokes";
+
+    prm.declare_entry ("Nonlinear solver scheme", "single Advection, single Stokes",
+                       Patterns::Selection (allowed_solver_schemes),
+                       "The kind of scheme used to resolve the nonlinearity in the system. "
+                       "`single Advection, single Stokes' means that no nonlinear iterations are done, "
+                       "and the temperature, compositional fields and Stokes equations are solved exactly "
+                       "once per time step, one after the other. "
+                       "The `iterated Advection and Stokes' scheme iterates this decoupled approach "
+                       "by alternating the solution of the temperature, composition and Stokes systems. "
+                       "The `single Advection, iterated Stokes' scheme solves the temperature and composition "
+                       "equation once at the beginning of each time step and then iterates out the solution of "
+                       "the Stokes equation. "
+                       "The `no Advection, iterated Stokes' scheme only solves the Stokes system, iterating "
+                       "out the solution, and ignores compositions and the temperature equation (careful, "
+                       "the material model must not depend on the temperature or composition; this is mostly "
+                       "useful for Stokes benchmarks). "
+                       " The `no Advection, single Stokes' scheme only solves the Stokes system once per "
+                       "timestep. This is also mostly useful for Stokes benchmarks. "
+                       "The `single Advection, no Stokes' scheme only solves the temperature and other advection "
+                       "systems once, and instead of solving for the Stokes system, a prescribed velocity "
+                       "and pressure is used. "
+                       "The `iterated Advection and Newton Stokes' scheme iterates by alternating the solution "
+                       "of the temperature, composition and Stokes equations, using Picard iterations for the "
+                       "temperature and composition, and Newton iterations for the Stokes system. "
+                       "The `single Advection, iterated Newton Stokes' scheme solves "
+                       "the temperature and composition equations once at the beginning of each time step and "
+                       "then iterates out the solution of the Stokes equation, using Newton iterations for the "
+                       "Stokes system. "
+                       "The `iterated Advection and defect correction Stokes' scheme iterates by alternating the "
+                       "solution of the temperature, composition and Stokes equations, using Picard iterations for "
+                       "the temperature and composition, and defect correction Picard iterations for the Stokes system. "
+                       "The `single Advection, iterated defect correction Stokes' scheme solves "
+                       "the temperature and composition equations once at the beginning of each time step and "
+                       "then iterates out the solution of the Stokes equation, using defect correction Picard "
+                       "iterations for the Stokes system. "
+                       "The `no Advection, iterated defect correction Stokes' scheme solves "
+                       "the temperature and composition equations once at the beginning of each time step and "
+                       "then iterates out the solution of the Stokes equation, using defect correction Picard "
+                       "iterations for the Stokes system. "
+                       "The `first timestep only, single Stokes' scheme solves the Stokes equations exactly "
+                       "once, at the first time step. No nonlinear iterations are done, and the temperature and "
+                       "composition systems are not solved. "
+                       "\n\n"
+                       "The `IMPES' scheme is deprecated and only allowed for reasons of backwards "
+                       "compatibility. It is the same as `single Advection, single Stokes' ."
+                       "The `iterated IMPES' scheme is deprecated and only allowed for reasons of "
+                       "backwards compatibility. It is the same as `iterated Advection and Stokes'. "
+                       "The `iterated Stokes' scheme is deprecated and only allowed for reasons of "
+                       "backwards compatibility. It is the same as `single Advection, iterated Stokes'. "
+                       "The `Stokes only' scheme is deprecated and only allowed for reasons of "
+                       "backwards compatibility. It is the same as `no Advection, iterated Stokes'. "
+                       "The `Advection only' scheme is deprecated and only allowed for reasons of "
+                       "backwards compatibility. It is the same as `single Advection, no Stokes'. "
+                       "The `Newton Stokes' scheme is deprecated and only allowed for reasons of "
+                       "backwards compatibility. It is the same as `iterated Advection and Newton Stokes'.");
+
+    prm.declare_entry ("Nonlinear solver tolerance", "1e-5",
+                       Patterns::Double(0., 1.),
+                       "A relative tolerance up to which the nonlinear solver will iterate. "
+                       "This parameter is only relevant if the `Nonlinear solver scheme' does nonlinear "
+                       "iterations, in other words, if it is set to something other than "
+                       "`single Advection, single Stokes' or `single Advection, no Stokes'.");
+
+    prm.declare_entry ("Pressure normalization", "surface",
+                       Patterns::Selection ("surface|volume|no"),
+                       "If and how to normalize the pressure after the solution step. "
+                       "This is necessary because depending on boundary conditions, "
+                       "in many cases the pressure is only determined by the model "
+                       "up to a constant. On the other hand, we often would like to "
+                       "have a well-determined pressure, for example for "
+                       "table lookups of material properties in models "
+                       "or for comparing solutions. If the given value is `surface', then "
+                       "normalization at the end of each time steps adds a constant value "
+                       "to the pressure in such a way that the average pressure at the surface "
+                       "of the domain is what is set in the `Surface pressure' parameter; "
+                       "the surface of the domain is determined by asking "
+                       "the geometry model whether a particular face of the geometry has a zero "
+                       "or small `depth'. If the value of this parameter is `volume' then the "
+                       "pressure is normalized so that the domain average is zero. If `no' is "
+                       "given, the no pressure normalization is performed.");
+
+    prm.declare_entry ("Surface pressure", "0.",
+                       Patterns::Double(),
+                       "The value the pressure is normalized to in each time step when "
+                       "`Pressure normalization' is set to `surface' with default value 0. "
+                       "This setting is ignored in all other cases."
+                       "\n\n"
+                       "The mathematical equations that describe thermal convection "
+                       "only determine the pressure up to an arbitrary constant. On "
+                       "the other hand, for comparison and for looking up material "
+                       "parameters it is important that the pressure be normalized "
+                       "somehow. We do this by enforcing a particular average pressure "
+                       "value at the surface of the domain, where the geometry model "
+                       "determines where the surface is. This parameter describes what "
+                       "this average surface pressure value is supposed to be. By "
+                       "default, it is set to zero, but one may want to choose a "
+                       "different value for example for simulating only the volume "
+                       "of the mantle below the lithosphere, in which case the surface "
+                       "pressure should be the lithostatic pressure at the bottom "
+                       "of the lithosphere."
+                       "\n\n"
+                       "For more information, see the section in the manual that discusses "
+                       "the general mathematical model.");
+
+    prm.declare_entry ("Adiabatic surface temperature", "0.",
+                       Patterns::Double(),
+                       "In order to make the problem in the first time step easier to "
+                       "solve, we need a reasonable guess for the temperature and pressure. "
+                       "To obtain it, we use an adiabatic pressure and temperature field. "
+                       "This parameter describes what the `adiabatic' temperature would "
+                       "be at the surface of the domain (i.e. at depth zero). Note "
+                       "that this value need not coincide with the boundary condition "
+                       "posed at this point. Rather, the boundary condition may differ "
+                       "significantly from the adiabatic value, and then typically "
+                       "induce a thermal boundary layer."
+                       "\n\n"
+                       "For more information, see the section in the manual that discusses "
+                       "the general mathematical model.");
+
+    prm.declare_entry ("Output directory", "output",
+                       Patterns::DirectoryName(),
+                       "The name of the directory into which all output files should be "
+                       "placed. This may be an absolute or a relative path.");
+
+    prm.declare_entry ("Use operator splitting", "false",
+                       Patterns::Bool(),
+                       "If set to true, the advection and reactions of compositional fields and "
+                       "temperature are solved separately, and can use different time steps. Note that "
+                       "this will only work if the material/heating model fills the reaction\\_rates/"
+                       "heating\\_reaction\\_rates structures. Operator splitting can be used with any "
+                       "existing solver schemes that solve the temperature/composition equations.");
+
+    prm.declare_entry ("World builder file", "",
+                       Patterns::FileName(),
+                       "Name of the world builder file. If empty, the world builder is not initialized.");
+
+    prm.enter_subsection ("Solver parameters");
+    {
+      prm.declare_entry ("Temperature solver tolerance", "1e-12",
+                         Patterns::Double(0., 1.),
+                         "The relative tolerance up to which the linear system for "
+                         "the temperature system gets solved. See `Stokes solver "
+                         "parameters/Linear solver tolerance' for more details.");
+
+      prm.declare_entry ("Composition solver tolerance", "1e-12",
+                         Patterns::Double(0., 1.),
+                         "The relative tolerance up to which the linear system for "
+                         "the composition system gets solved. See `Stokes solver "
+                         "parameters/Linear solver tolerance' for more details.");
+
+      prm.enter_subsection ("Advection solver parameters");
+      {
+        prm.declare_entry ("GMRES solver restart length", "50",
+                           Patterns::Integer(1),
+                           "This is the number of iterations that define the "
+                           "GMRES solver restart length. Increasing this "
+                           "parameter makes the solver more robust and decreases "
+                           "the number of iterations. Be aware that "
+                           "increasing this number increases the memory usage "
+                           "of the advection solver, and makes individual "
+                           "iterations more expensive.");
+      }
+      prm.leave_subsection();
+
+
+      prm.enter_subsection ("Stokes solver parameters");
+      {
+        prm.declare_entry ("Stokes solver type", "default solver",
+                           Patterns::Selection(StokesSolverType::pattern()),
+                           "This is the type of solver used on the Stokes system. The block geometric "
+                           "multigrid solver currently has a limited implementation and therefore "
+                           "may trigger Asserts in the code when used. If this is the case, "
+                           "please switch to 'block AMG'. Additionally, the block GMG solver requires "
+                           "using material model averaging. The 'default solver' chooses "
+                           "the geometric multigrid solver if supported, otherwise the AMG solver.");
+
+        prm.declare_entry ("Use direct solver for Stokes system", "false",
+                           Patterns::Bool(),
+                           "If set to true the linear system for the Stokes equation will "
+                           "be solved using Trilinos klu, otherwise an iterative Schur "
+                           "complement solver is used. The direct solver is only efficient "
+                           "for small problems.");
+
+        prm.declare_entry ("Use weighted BFBT for Schur complement", "false",
+                           Patterns::Bool(),
+                           "If set to true, the Schur complement approximation in the Block preconditioner "
+                           "uses the weighted BFBT preconditioner, otherwise a weighted mass matrix will "
+                           "be used. The BFBT preconditioner is more expensive, but works better for large "
+                           "viscosity variations.");
+
+        prm.declare_entry ("Krylov method for cheap solver steps", "GMRES",
+                           Patterns::Selection(StokesKrylovType::pattern()),
+                           "This is the Krylov method used to solve the Stokes system. Both options, GMRES "
+                           "and IDR(s), solve non-symmetric, indefinite systems. GMRES "
+                           "guarantees the residual will be reduced in each iteration while IDR(s) has "
+                           "no such property. On the other hand, the vector storage requirement for GMRES is "
+                           "dependent on the restart length and can be quite restrictive (since, for "
+                           "the matrix-free GMG solver, memory is dominated by these vectors) whereas "
+                           "IDR(s) has a short term recurrence. "
+                           "Note that the IDR(s) Krylov method is not available for the AMG solver since "
+                           "it is not a flexible method, i.e., it cannot handle a preconditioner which "
+                           "may change in each iteration (the AMG-based preconditioner contains a CG solve "
+                           "in the pressure space which may have different number of iterations each step).");
+
+        prm.declare_entry ("IDR(s) parameter", "2",
+                           Patterns::Integer(1),
+                           "This is the sole parameter for the IDR(s) Krylov solver and will dictate the "
+                           "number of matrix-vector products and preconditioner applications per iteration (s+1) "
+                           "and the total number of temporary vectors required (5+3*s). For s=1, this method is "
+                           "analogous to BiCGStab. As s is increased this method is expected to converge to "
+                           "GMRES in terms of matrix-vector/preconditioner applications to solution.");
+
+        prm.declare_entry ("Linear solver tolerance", "1e-7",
+                           Patterns::Double(0., 1.),
+                           "A relative tolerance up to which the linear Stokes systems in each "
+                           "time or nonlinear step should be solved. The absolute tolerance will "
+                           "then be $\\| M x_0 - F \\| \\cdot \\text{tol}$, where $x_0 = (0,p_0)$ "
+                           "is the initial guess of the pressure, $M$ is the system matrix, "
+                           "$F$ is the right-hand side, and tol is the parameter specified here. "
+                           "We include the initial guess of the pressure "
+                           "to remove the dependency of the tolerance on the static pressure. "
+                           "A given tolerance value of 1 would "
+                           "mean that a zero solution vector is an acceptable solution "
+                           "since in that case the norm of the residual of the linear "
+                           "system equals the norm of the right hand side. A given "
+                           "tolerance of 0 would mean that the linear system has to be "
+                           "solved exactly, since this is the only way to obtain "
+                           "a zero residual."
+                           "\n\n"
+                           "In practice, you should choose the value of this parameter "
+                           "to be so that if you make it smaller the results of your "
+                           "simulation do not change any more (qualitatively) whereas "
+                           "if you make it larger, they do. For most cases, the default "
+                           "value should be sufficient. In fact, a tolerance of 1e-4 "
+                           "might be accurate enough.");
+
+        prm.declare_entry ("Number of cheap Stokes solver steps", "1000",
+                           Patterns::Integer(0),
+                           "As explained in the paper that describes ASPECT (Kronbichler, Heister, and Bangerth, "
+                           "2012, see \\cite{kronbichler:etal:2012}) we first try to solve the Stokes system in every "
+                           "time step using a GMRES iteration with a poor but cheap "
+                           "preconditioner. By default, we try whether we can converge the GMRES "
+                           "solver in 200 such iterations before deciding that we need a better "
+                           "preconditioner. This is sufficient for simple problems with variable "
+                           "viscosity and we never need the second phase with the more expensive "
+                           "preconditioner. On the other hand, for more complex problems, and in "
+                           "particular for problems with strongly nonlinear viscosity, the 200 "
+                           "cheap iterations don't actually do very much good and one might skip "
+                           "this part right away. In that case, this parameter can be set to "
+                           "zero, i.e., we immediately start with the better but more expensive "
+                           "preconditioner.");
+
+        prm.declare_entry ("Maximum number of expensive Stokes solver steps", "1000",
+                           Patterns::Integer(0),
+                           "This sets the maximum number of iterations used in the expensive Stokes solver. "
+                           "If this value is set too low for the size of the problem, the Stokes solver will "
+                           "not converge and return an error message pointing out that the user didn't allow "
+                           "a sufficiently large number of iterations for the iterative solver to converge.");
+
+        prm.declare_entry ("GMRES solver restart length", "100",
+                           Patterns::Integer(1),
+                           "This is the number of iterations that define the GMRES solver restart length. "
+                           "Increasing this parameter helps with convergence issues arising from high localized "
+                           "viscosity jumps in the domain. Be aware that increasing this number increases the "
+                           "memory usage of the Stokes solver, and makes individual Stokes iterations more "
+                           "expensive.");
+
+        prm.declare_entry ("Linear solver A block tolerance", "1e-2",
+                           Patterns::Double(0., 1.),
+                           "A relative tolerance up to which the approximate inverse of the $A$ block "
+                           "of the Stokes system is computed. This approximate $A$ is used in the "
+                           "preconditioning used in the GMRES solver. The exact definition of this "
+                           "block preconditioner for the Stokes equation can be found in "
+                           "\\cite{kronbichler:etal:2012}.");
+
+        prm.declare_entry ("Use full A block as preconditioner", "false",
+                           Patterns::Bool(),
+                           "This parameter determines whether we use an simplified approximation of the "
+                           "$A$ block as preconditioner for the Stokes solver, or the full $A$ block. The "
+                           "simplified approximation only contains the terms that describe the coupling of "
+                           "identical components (plus boundary conditions) as described in "
+                           "\\cite{kronbichler:etal:2012}. The full block is closer to the description in "
+                           "\\cite{rudi2017weighted}."
+                           "\n\n"
+                           "There is no clear way to determine which preconditioner "
+                           "performs better. The default value (simplified approximation) requires "
+                           "more outer GMRES iterations, but is faster to apply in each iteration. The full block "
+                           "needs less assembly time (because the block is "
+                           "available anyway), converges in less GMRES iterations, but requires more time per "
+                           "iteration. There are also differences in the amount of memory consumption between "
+                           "the two approaches."
+                           "\n\n"
+                           "The default value should be good for relatively simple models, but in "
+                           "particular for very strong viscosity contrasts the full $A$ block can be "
+                           "advantageous. This parameter is always set to true when using the GMG solver.");
+
+        prm.declare_entry ("Force nonsymmetric A block solver", "false",
+                           Patterns::Bool(),
+                           "This parameter determines whether to enforce a solver that supports nonsymmetric "
+                           "matrices when solving the inner $A$ block of the Stokes system. "
+                           "By default ASPECT recognizes cases where the A block is nonsymmetric "
+                           "automatically, and chooses an appropriate solver. However, if the "
+                           "inner A block solver does not converge, this parameter can be set to 'true' "
+                           "to force the use of a solver that can handle nonsymmetric matrices.");
+
+        prm.declare_entry ("Linear solver S block tolerance", "1e-6",
+                           Patterns::Double(0., 1.),
+                           "A relative tolerance up to which the approximate inverse of the $S$ block "
+                           "(i.e., the Schur complement matrix $S = BA^{-1}B^{T}$) of the Stokes "
+                           "system is computed. This approximate inverse of the $S$ block is used "
+                           "in the preconditioning used in the GMRES solver. The exact definition of "
+                           "this block preconditioner for the Stokes equation can be found in "
+                           "\\cite{kronbichler:etal:2012}.");
+      }
+      prm.leave_subsection ();
+
+      prm.enter_subsection ("AMG parameters");
+      {
+        prm.declare_entry ("AMG smoother type", "Chebyshev",
+                           Patterns::Selection ("Chebyshev|symmetric Gauss-Seidel"),
+                           "This parameter sets the type of smoother for the AMG. "
+                           "The default is strongly recommended for any normal runs "
+                           "with ASPECT. There are some indications that the symmetric "
+                           "Gauss-Seidel might be better and more stable for the Newton "
+                           "solver. For extensive benchmarking of various settings of the "
+                           "AMG parameters in this section for the Stokes problem and others, "
+                           "see https://github.com/geodynamics/aspect/pull/234.");
+
+        prm.declare_entry ("AMG smoother sweeps", "2",
+                           Patterns::Integer(0),
+                           "Determines how many sweeps of the smoother should be performed. When the flag elliptic "
+                           "is set to true, (which is true for ASPECT), the polynomial degree of "
+                           "the Chebyshev smoother is set to this value. The term sweeps refers to the number of "
+                           "matrix-vector products performed in the Chebyshev case. In the non-elliptic case, "
+                           "this parameter sets the number of SSOR relaxation sweeps for post-smoothing to be performed. "
+                           "The default is strongly recommended. There are indications that for the Newton solver a different "
+                           "value might be better. For extensive benchmarking of various settings of the "
+                           "AMG parameters in this section for the Stokes problem and others, "
+                           "see https://github.com/geodynamics/aspect/pull/234.");
+
+        prm.declare_entry ("AMG aggregation threshold", "0.001",
+                           Patterns::Double(0., 1.),
+                           "This threshold tells the AMG setup how the coarsening should be performed. "
+                           "In the AMG used by ML, all points that strongly couple with the tentative coarse-level "
+                           "point form one aggregate. The term strong coupling is controlled by the variable "
+                           "aggregation\\_threshold, meaning that all elements that are not smaller than "
+                           "aggregation\\_threshold times the diagonal element do couple strongly. "
+                           "The default is strongly recommended. There are indications that for the Newton solver a different "
+                           "value might be better. For extensive benchmarking of various settings of the "
+                           "AMG parameters in this section for the Stokes problem and others, "
+                           "see https://github.com/geodynamics/aspect/pull/234.");
+
+        prm.declare_entry ("AMG output details", "false",
+                           Patterns::Bool(),
+                           "Turns on extra information on the AMG solver. Note that this will generate much more output.");
+      }
+      prm.leave_subsection ();
+      prm.enter_subsection ("Operator splitting parameters");
+      {
+        prm.declare_entry ("Reaction solver type", "ARKode",
+                           Patterns::Selection ("ARKode|fixed step"),
+                           "This parameter determines what solver will be used when the reactions "
+                           "are computed within the operator splitting scheme. For reactions where "
+                           "the reaction rate is a known, finite quantity, the appropriate choice "
+                           "is `ARKode', which uses an ODE solver from SUNDIALs ARKode (adaptive-step "
+                           "additive Runge Kutta ODE solver methods) to compute the solution. ARKode "
+                           "will pick a reasonable step size based on the reaction rate and the given "
+                           "`Reaction solver relative tolerance'. "
+                           "However, in some cases we have instantaneous reactions, where we know the "
+                           "new value of a compositional field (and the reaction rate would be "
+                           "infinite), or reaction where we need to know or be able to control the step "
+                           "size we use to compute the reactions. In theses cases, it is appropriate "
+                           "to use the `fixed step' scheme, a method that a forward Euler scheme and a "
+                           "fixed number of steps given by the `Reaction time step' and "
+                           "`Reaction time steps per advection step' parameters. ");
+
+        prm.declare_entry ("Reaction solver relative tolerance", "1e-6",
+                           Patterns::Double (0.),
+                           "The relative solver tolerance used in the ARKode reaction solver. "
+                           "This tolerance is used to adaptively determine the reaction step size. "
+                           "For more details, see the ARKode documentation. This parameter is only used "
+                           "if the `ARKode' reaction solver type is used. "
+                           "Units: none.");
+
+        prm.declare_entry ("Reaction time step", "1000.0",
+                           Patterns::Double (0.),
+                           "Set a time step size for computing reactions of compositional fields and the "
+                           "temperature field in case operator splitting is used. This is only used "
+                           "when the parameter ``Use operator splitting'' is set to true and when the "
+                           "`fixed step' reaction solver type is used. "
+                           "The reaction time step must be greater than 0. "
+                           "If you want to prescribe the reaction time step only as a relative value "
+                           "compared to the advection time step as opposed to as an absolute value, you "
+                           "should use the parameter ``Reaction time steps per advection step'' and set "
+                           "this parameter to the same (or larger) value as the ``Maximum time step'' "
+                           "(which is 5.69e+300 by default). "
+                           "Units: Years or seconds, depending on the ``Use years "
+                           "in output instead of seconds'' parameter.");
+
+        prm.declare_entry ("Reaction time steps per advection step", "0",
+                           Patterns::Integer (0),
+                           "The number of reaction time steps done within one advection time step "
+                           "in case operator splitting is used. This is only used if the parameter "
+                           "``Use operator splitting'' is set to true and when the `fixed step' "
+                           "reaction solver type is used. If set to zero, this parameter is ignored. "
+                           "Otherwise, the reaction time step size is chosen according to "
+                           "this criterion and the ``Reaction time step'', whichever yields the "
+                           "smaller time step. "
+                           "Units: none.");
+      }
+      prm.leave_subsection ();
+      prm.enter_subsection ("Diffusion solver parameters");
+      {
+        prm.declare_entry ("Diffusion length scale", "1.e4",
+                           Patterns::Double (0.),
+                           "Set a length scale for the diffusion of advection fields if the "
+                           "``prescribed field with diffusion'' method is selected for a field. "
+                           "More precisely, this length scale represents the square root of the "
+                           "product of diffusivity and time in the diffusion equation, and controls "
+                           "the distance over which features are diffused. "
+                           "Units: \\si{\\meter}.");
+      }
+      prm.leave_subsection ();
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection("Formulation");
+    {
+      prm.declare_entry ("Formulation", "custom",
+                         Patterns::Selection ("isentropic compression|custom|anelastic liquid approximation|Boussinesq approximation"),
+                         "Select a formulation for the basic equations. Different "
+                         "published formulations are available in ASPECT (see the list of "
+                         "possible values for this parameter in the manual for available options). "
+                         "Two ASPECT specific options are\n"
+                         "  * `isentropic compression': ASPECT's original "
+                         "formulation, using the explicit compressible mass equation, "
+                         "and the full density for the temperature equation.\n"
+                         "  * `custom': A custom selection of `Mass conservation' and "
+                         "`Temperature equation'.\n"
+                         ":::{warning}\n"
+                         "The `custom' option is "
+                         "implemented for advanced users that want full control over the "
+                         "equations solved. It is possible to choose inconsistent formulations "
+                         "and no error checking is performed on the consistency of the resulting "
+                         "equations.\n"
+                         ":::\n\n"
+                         ":::{note}\n"
+                         "The `anelastic liquid approximation' option here can also be "
+                         "used to set up the `truncated anelastic liquid approximation' as long as "
+                         "this option is chosen together with a material model that defines a "
+                         "density that depends on temperature and depth and not on the pressure.\n"
+                         ":::");
+
+      prm.declare_entry ("Mass conservation", "ask material model",
+                         Patterns::Selection ("incompressible|isentropic compression|hydrostatic compression|"
+                                              "reference density profile|implicit reference density profile|"
+                                              "projected density field|"
+                                              "ask material model"),
+                         "Possible approximations for the density derivatives in the mass "
+                         "conservation equation. Note that this parameter is only evaluated "
+                         "if `Formulation' is set to `custom'. Other formulations ignore "
+                         "the value of this parameter.");
+      prm.declare_entry ("Temperature equation", "real density",
+                         Patterns::Selection ("real density|reference density profile"),
+                         "Possible approximations for the density in the temperature equation. "
+                         "Possible approximations are `real density' and `reference density profile'. "
+                         "Note that this parameter is only evaluated "
+                         "if `Formulation' is set to `custom'. Other formulations ignore "
+                         "the value of this parameter.");
+      prm.declare_entry ("Enable additional Stokes RHS", "false",
+                         Patterns::Bool (),
+                         "Whether to ask the material model for additional terms for the right-hand side "
+                         "of the Stokes equation. This feature is likely only used when implementing force "
+                         "vectors for manufactured solution problems and requires filling additional outputs "
+                         "of type AdditionalMaterialOutputsStokesRHS.");
+      prm.declare_entry ("Enable elasticity", "false",
+                         Patterns::Bool (),
+                         "Whether to include the additional elastic terms on the right-hand side of "
+                         "the Stokes equation.");
+      prm.declare_entry ("Enable prescribed dilation", "false",
+                         Patterns::Bool (),
+                         "Whether to include additional terms on the right-hand side of "
+                         "the Stokes equation to set a given compression term specified in the "
+                         "MaterialModel output PrescribedPlasticDilation.");
+    }
+    prm.leave_subsection();
+
+    // next declare parameters that pertain to the equations to be
+    // solved, along with boundary conditions etc. note that at this
+    // point we do not know yet which geometry model we will use, so
+    // we do not know which symbolic names will be valid to address individual
+    // parts of the boundary. we can only work around this by allowing any string
+    // to indicate a boundary
+    prm.enter_subsection ("Melt settings");
+    {
+      prm.declare_entry ("Include melt transport", "false",
+                         Patterns::Bool (),
+                         "Whether to include the transport of melt into the model or not. If this "
+                         "is set to true, two additional pressures (the fluid pressure and the "
+                         "compaction pressure) will be added to the finite element. "
+                         "Including melt transport in the simulation also requires that there is "
+                         "one compositional field that has the name `porosity'. This field will "
+                         "be used for computing the additional pressures and the melt velocity, "
+                         "and has a different advection equation than other compositional fields, "
+                         "as it is effectively advected with the melt velocity.");
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Mesh deformation");
+    {
+      prm.declare_entry ("Mesh deformation boundary indicators", "",
+                         Patterns::List (Patterns::Anything()),
+                         "A comma separated list of names denoting those boundaries "
+                         "where there is some type of mesh deformation. Set to nothing to disable all "
+                         "deformation computations."
+                         "\n\n"
+                         "The names of the boundaries listed here can either by "
+                         "numbers (in which case they correspond to the numerical "
+                         "boundary indicators assigned by the geometry object), or they "
+                         "can correspond to any of the symbolic names the geometry object "
+                         "may have provided for each part of the boundary. You may want "
+                         "to compare this with the documentation of the geometry model you "
+                         "use in your model.");
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Boundary heat flux model");
+    {
+      prm.declare_entry ("Fixed heat flux boundary indicators", "",
+                         Patterns::List (Patterns::Anything()),
+                         "A comma separated list of names denoting those boundaries "
+                         "on which the heat flux is fixed and described by the "
+                         "boundary heat flux object selected in the 'Model name' parameter. "
+                         "All boundary indicators used by the geometry but not explicitly "
+                         "listed here or in the list of 'Fixed temperature boundary indicators' "
+                         "in the 'Boundary temperature model' will end up with no-flux "
+                         "(insulating) boundary conditions."
+                         "\n\n"
+                         "The names of the boundaries listed here can either be "
+                         "numbers (in which case they correspond to the numerical "
+                         "boundary indicators assigned by the geometry object), or they "
+                         "can correspond to any of the symbolic names the geometry object "
+                         "may have provided for each part of the boundary. You may want "
+                         "to compare this with the documentation of the geometry model you "
+                         "use in your model."
+                         "\n\n"
+                         "This parameter only describes which boundaries have a fixed "
+                         "heat flux, but not what heat flux should hold on these "
+                         "boundaries. The latter piece of information needs to be "
+                         "implemented in a plugin in the BoundaryHeatFlux "
+                         "group, unless an existing implementation in this group "
+                         "already provides what you want.");
+    }
+    prm.leave_subsection();
+
+
+    prm.enter_subsection ("Nullspace removal");
+    {
+      prm.declare_entry ("Remove nullspace", "",
+                         Patterns::MultipleSelection("net rotation|angular momentum|"
+                                                     "net surface rotation|"
+                                                     "net translation|linear momentum|"
+                                                     "net x translation|net y translation|net z translation|"
+                                                     "linear x momentum|linear y momentum|linear z momentum"),
+                         "Choose none, one or several from "
+                         "\n\n"
+                         "\\begin{itemize} \\item net rotation \\item angular momentum \\item net translation "
+                         "\\item net surface rotation"
+                         "\\item linear momentum \\item net x translation \\item net y translation "
+                         "\\item net z translation \\item linear x momentum \\item linear y momentum "
+                         "\\item linear z momentum \\end{itemize}"
+                         "\n\n"
+                         "These are a selection of operations to remove certain parts of the nullspace from "
+                         "the velocity after solving. For some geometries and certain boundary conditions "
+                         "the velocity field is not uniquely determined but contains free translations "
+                         "and/or rotations. Depending on what you specify here, these non-determined "
+                         "modes will be removed from the velocity field at the end of the Stokes solve step.\n"
+                         "\n\n"
+                         "The ``angular momentum'' option removes a rotation such that the net angular momentum "
+                         "is zero. The ``linear * momentum'' options remove translations such that the net "
+                         "momentum in the relevant direction is zero.  The ``net rotation'' option removes the "
+                         "net rotation of the whole domain, the ``net surface rotation'' option removes the net "
+                         "rotation of the top surface, and the ``net * translation'' options remove the "
+                         "net translations in the relevant directions.  For most problems there should not be a "
+                         "significant difference between the momentum and rotation/translation versions of "
+                         "nullspace removal, although the momentum versions are more physically motivated. "
+                         "They are equivalent for constant density simulations, and approximately equivalent "
+                         "when the density variations are small."
+                         "\n\n"
+                         "Note that while more than one operation can be selected it only makes sense to "
+                         "pick one rotational and one translational operation.");
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Mesh refinement");
+    {
+      prm.declare_entry ("Initial global refinement", "2",
+                         Patterns::Integer (0),
+                         "The number of global refinement steps performed on "
+                         "the initial coarse mesh, before the problem is first "
+                         "solved there."
+                         "\n\n"
+                         "Note that it is possible to supply conflicting refinement "
+                         "and coarsening settings, such as an 'Initial global refinement' "
+                         "of 4 and a 'Maximum refinement function' strategy that limits "
+                         "the refinement locally to 2. In this case, the tagging strategies "
+                         "such as the 'Maximum refinement function' will remove refinement "
+                         "flags in each initial global refinement step, such that the "
+                         "resulting mesh is not necessarily uniform or of the level "
+                         "given by the 'Initial global refinement' parameter.");
+      prm.declare_entry ("Initial adaptive refinement", "0",
+                         Patterns::Integer (0),
+                         "The number of adaptive refinement steps performed after "
+                         "initial global refinement but while still within the first "
+                         "time step. These refinement steps (n) are added to the value "
+                         "for initial global refinement (m) so that the final mesh has "
+                         "cells that are at most on refinement level $n+m$.");
+      prm.declare_entry ("Time steps between mesh refinement", "10",
+                         Patterns::Integer (0),
+                         "The number of time steps after which the mesh is to be "
+                         "adapted again based on computed error indicators. If 0 "
+                         "then the mesh will never be changed.");
+      prm.declare_entry ("Refinement fraction", "0.3",
+                         Patterns::Double(0., 1.),
+                         "Cells are sorted from largest to smallest by their total error "
+                         "(determined by the Strategy). Then the cells with the largest "
+                         "error (top of this sorted list) that account for given fraction "
+                         "of the error are refined.");
+      prm.declare_entry ("Coarsening fraction", "0.05",
+                         Patterns::Double(0., 1.),
+                         "Cells are sorted from largest to smallest by their total error "
+                         "(determined by the Strategy). Then the cells with the smallest "
+                         "error (bottom of this sorted list) that account for the given fraction "
+                         "of the error are coarsened.");
+      prm.declare_entry ("Adapt by fraction of cells", "false",
+                         Patterns::Bool(),
+                         "Use fraction of the total number of cells instead of "
+                         "fraction of the total error as the limit for refinement "
+                         "and coarsening.");
+      prm.declare_entry ("Minimum refinement level", "0",
+                         Patterns::Integer (0),
+                         "The minimum refinement level each cell should have, "
+                         "and that can not be exceeded by coarsening. "
+                         "Should not be higher than the 'Initial global refinement' "
+                         "parameter.");
+      prm.declare_entry ("Additional refinement times", "",
+                         Patterns::List (Patterns::Double (0.)),
+                         "A list of times so that if the end time of a time step "
+                         "is beyond this time, an additional round of mesh refinement "
+                         "is triggered. This is mostly useful to make sure we "
+                         "can get through the initial transient phase of a simulation "
+                         "on a relatively coarse mesh, and then refine again when we "
+                         "are in a time range that we are interested in and where "
+                         "we would like to use a finer mesh. Units: Each element of the "
+                         "list has units years if the "
+                         "'Use years in output instead of seconds' parameter is set; "
+                         "seconds otherwise.");
+      prm.declare_entry ("Run postprocessors on initial refinement", "false",
+                         Patterns::Bool (),
+                         "Whether or not the postprocessors should be executed after "
+                         "each of the initial adaptive refinement cycles that are run at "
+                         "the start of the simulation. This is useful for "
+                         "plotting/analyzing how the mesh refinement parameters are "
+                         "working for a particular model.");
+      prm.declare_entry ("Skip solvers on initial refinement", "false",
+                         Patterns::Bool (),
+                         "Whether or not solvers should be executed during the initial "
+                         "adaptive refinement cycles that are run at the start of the "
+                         "simulation.");
+      prm.declare_entry ("Skip setup initial conditions on initial refinement", "false",
+                         Patterns::Bool (),
+                         "Whether or not the initial conditions should be set up during the "
+                         "adaptive refinement cycles that are run at the start of the "
+                         "simulation.");
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Postprocess");
+    {
+      prm.declare_entry ("Run postprocessors on nonlinear iterations", "false",
+                         Patterns::Bool (),
+                         "Whether or not the postprocessors should be executed after "
+                         "each of the nonlinear iterations done within one time step. "
+                         "As this is mainly an option for the purposes of debugging, "
+                         "it is not supported when the 'Time between graphical output' "
+                         "is larger than zero, or when the postprocessor is not intended "
+                         "to be run more than once per timestep.");
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Checkpointing");
+    {
+      prm.declare_entry ("Time between checkpoint", "0",
+                         Patterns::Integer (0),
+                         "The wall time between performing checkpoints. "
+                         "If 0, will use the checkpoint step frequency instead. "
+                         "Units: Seconds.");
+      prm.declare_entry ("Steps between checkpoint", "0",
+                         Patterns::Integer (0),
+                         "The number of timesteps between performing checkpoints. "
+                         "If 0 and time between checkpoint is not specified, "
+                         "checkpointing will not be performed. "
+                         "Units: None.");
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection ("Discretization");
+    {
+      prm.declare_entry ("Stokes velocity polynomial degree", "2",
+                         Patterns::Integer (1),
+                         "The polynomial degree to use for the velocity variables "
+                         "in the Stokes system. The polynomial degree for the pressure "
+                         "variable will then be one less in order to make the velocity/pressure "
+                         "pair conform with the usual LBB (Babu{\\v s}ka-Brezzi) condition. In "
+                         "other words, we are using a Taylor-Hood element for the Stokes "
+                         "equations and this parameter indicates the polynomial degree of it. "
+                         "As an example, a value of 2 for this parameter will yield the "
+                         "element $Q_2^d \\times Q_1$ for the $d$ velocity components and the "
+                         "pressure, respectively (unless the `Use locally conservative "
+                         "discretization' parameter is set, which modifies the pressure "
+                         "element). "
+                         "\n\n"
+                         "Be careful if you choose 1 as the degree. The resulting element "
+                         "is not stable and it may lead to artifacts in the solution. "
+                         "Units: None.");
+      prm.declare_entry ("Temperature polynomial degree", "2",
+                         Patterns::Integer (1),
+                         "The polynomial degree to use for the temperature variable. "
+                         "As an example, a value of 2 for this parameter will yield "
+                         "either the element $Q_2$ or $DGQ_2$ for the temperature "
+                         "field, depending on whether we use a continuous or "
+                         "discontinuous field. "
+                         "Units: None.");
+      prm.declare_entry ("Composition polynomial degree", "2",
+                         Patterns::Integer (0),
+                         "The polynomial degree to use for the composition variable(s). "
+                         "As an example, a value of 2 for this parameter will yield "
+                         "either the element $Q_2$ or $DGQ_2$ for the compositional "
+                         "field(s), depending on whether we use continuous or "
+                         "discontinuous field(s). "
+                         "\n\n"
+                         "For continuous elements, the value needs to be 1 or larger "
+                         "as $Q_1$ is the lowest order element, while $DGQ_0$ is a "
+                         "valid choice. "
+                         "Units: None.");
+      prm.declare_entry ("Use locally conservative discretization", "false",
+                         Patterns::Bool (),
+                         "Whether to use a Stokes discretization that is locally "
+                         "conservative at the expense of a larger number of degrees "
+                         "of freedom (true), or to go with a cheaper discretization "
+                         "that does not locally conserve mass, although it is "
+                         "globally conservative (false)."
+                         "\n\n"
+                         "When using a locally "
+                         "conservative discretization, the finite element space for "
+                         "the pressure is discontinuous between cells and is the "
+                         "polynomial space $P_{-(k-1)}$ of polynomials of degree $k-1$ in "
+                         "each variable separately. Here, $k$ is the value "
+                         "given in the parameter ``Stokes velocity polynomial degree'', and "
+                         "consequently the polynomial degree for the pressure, $k-1$, is one "
+                         "lower than that for the velocity."
+                         "\n\n"
+                         "As a consequence of choosing this element for the pressure rather "
+                         "than the more commonly used $Q_{k-1}$ element that is continuous, "
+                         "it can be shown that if the medium is considered incompressible "
+                         "then the computed discrete velocity "
+                         "field $\\mathbf u_h$ satisfies the property $\\int_ {\\partial K} \\mathbf u_h "
+                         "\\cdot \\mathbf n = 0$ for every cell $K$, i.e., for each cell inflow and "
+                         "outflow exactly balance each other as one would expect for an "
+                         "incompressible medium. In other words, the velocity field is "
+                         "\\textit{locally conservative}."
+                         "\n\n"
+                         "On the other hand, if this parameter is set to ``false''"
+                         "(the default), then the finite element space is chosen as $Q_{k-1}$. "
+                         "This choice does not yield the local conservation property but "
+                         "has the advantage of requiring fewer degrees of freedom. Furthermore, "
+                         "the error is generally smaller with this choice."
+                         "\n\n"
+                         "For an in-depth discussion of these issues and a quantitative evaluation "
+                         "of the different choices, see \\cite{kronbichler:etal:2012}.");
+      prm.declare_entry ("Use equal order interpolation for Stokes", "false",
+                         Patterns::Bool(),
+                         "By default (i.e., when this parameter is set to its default value "
+                         "`false') \\aspect{} uses finite element combinations in which the "
+                         "pressure shape functions are polynomials one degree lower than "
+                         "the shape functions for the velocity. An example is the "
+                         "Taylor-Hood element that uses $Q_k$ elements for the velocity "
+                         "and $Q_{k-1}$ for the pressure. This is because using the "
+                         "\\textit{same} polynomial degree for both the velocity and the "
+                         "pressure turns out to violate some mathematical properties "
+                         "necessary to make the problem solvable. (In particular, the"
+                         "condition in question goes by the name ``inf-sup'' or "
+                         "Babu{\\v s}ka-Brezzi or LBB condition.) A consequence of "
+                         "violating this condition is that the pressure may show "
+                         "oscillations and not converge to the correct pressure."
+                         "\n\n"
+                         "That said, people have often used $Q_1$ elements for both the "
+                         "velocity and pressure anyway. This is commonly referred to as "
+                         "using the $Q_1-Q_1$ method. It is, by default, not stable as "
+                         "mentioned above, but it can be made stable by adding a small "
+                         "amount of compressibility to the model. There are numerous "
+                         "ways to do that. Today, the way that is generally considered "
+                         "to be the best approach is the one by Dohrmann and Bochev "
+                         "\\cite{DohrmannBochev2004}."
+                         "\n\n"
+                         "When this parameter is set to ``true'', then \\aspect{} "
+                         "will use this method by using $Q_k\\times Q_k$ elements for "
+                         "velocity and pressure, respectively, where $k$ is the value "
+                         "provided for the parameter ``Stokes velocity polynomial "
+                         "degree''."
+                         "\n\n"
+                         ":::{note}\n"
+                         "While \\aspect{} \\textit{allows} you to use this "
+                         "method, it is generally understood that this is not a "
+                         "great idea as it leads to rather low accuracy in "
+                         "general as documented in \\cite{thba22}. "
+                         "It also leads to substantial problems when "
+                         "using free surfaces. As a consequence, the presence "
+                         "of this parameter should not be seen as an "
+                         "endorsement of the method, or a suggestion to "
+                         "actually use it. It simply makes the method available.\n"
+                         ":::");
+      prm.declare_entry ("Use discontinuous temperature discretization", "false",
+                         Patterns::Bool (),
+                         "Whether to use a temperature discretization that is discontinuous "
+                         "as opposed to continuous. This then requires the assembly of face terms "
+                         "between cells, and weak imposition of boundary terms for the temperature "
+                         "field via the interior-penalty discontinuous Galerkin method.");
+      prm.declare_entry ("Use discontinuous composition discretization", "false",
+                         Patterns::List(Patterns::Bool ()),
+                         "Whether to use a composition discretization that is discontinuous "
+                         "as opposed to continuous. This then requires the assembly of face terms "
+                         "between cells, and weak imposition of boundary terms for the composition "
+                         "field via the discontinuous Galerkin method.");
+
+      prm.enter_subsection ("Stabilization parameters");
+      {
+        prm.declare_entry ("Stabilization method", "entropy viscosity",
+                           Patterns::Selection("entropy viscosity|SUPG"),
+                           "Select the method for stabilizing the advection equation. The original "
+                           "method implemented is 'entropy viscosity' as described in \\cite {kronbichler:etal:2012}. "
+                           "SUPG is currently experimental.");
+
+        prm.declare_entry ("List of compositional fields with disabled boundary entropy viscosity", "",
+                           Patterns::List(Patterns::Anything()),
+                           "Select for which compositional fields to skip the entropy viscosity "
+                           "stabilization at dirichlet boundaries. This is "
+                           "only advisable for compositional fields"
+                           "that have intrinsic physical diffusion terms, otherwise "
+                           "oscillations may develop. The parameter should contain a list of "
+                           "compositional field names.");
+
+        prm.declare_entry ("Use artificial viscosity smoothing", "false",
+                           Patterns::Bool (),
+                           "If set to false, the artificial viscosity of a cell is computed and "
+                           "is computed on every cell separately as discussed in \\cite{kronbichler:etal:2012}. "
+                           "If set to true, the maximum of the artificial viscosity in "
+                           "the cell as well as the neighbors of the cell is computed and used "
+                           "instead.");
+
+        prm.declare_entry ("alpha", "2",
+                           Patterns::Integer (1, 2),
+                           "The exponent $\\alpha$ in the entropy viscosity stabilization. Valid "
+                           "options are 1 or 2. The recommended setting is 2. (This parameter does "
+                           "not correspond to any variable in the 2012 paper by Kronbichler, "
+                           "Heister and Bangerth that describes ASPECT, see \\cite{kronbichler:etal:2012}. "
+                           "Rather, the paper always uses 2 as the exponent in the definition "
+                           "of the entropy, following equation (15) of the paper. The full "
+                           "approach is discussed in \\cite{guermond:etal:2011}.) Note that this is not the "
+                           "thermal expansion coefficient, also commonly referred to as $\\alpha$."
+                           "Units: None.");
+        prm.declare_entry ("cR", "0.11",
+                           Patterns::List(Patterns::Double (0.)),
+                           "The $c_R$ factor in the entropy viscosity "
+                           "stabilization. This parameter controls the part of the entropy viscosity "
+                           "that depends on the solution field itself and its residual in addition "
+                           "to the cell diameter and the maximum velocity in the cell. "
+                           "This parameter can be given as a single value or as a list with as "
+                           "many entries as one plus the number of compositional fields. In the "
+                           "former case all advection fields use the same stabilization parameters, "
+                           "in the latter case each field (temperature first, then all compositions) "
+                           "use individual parameters. This can be useful to reduce the stabilization "
+                           "for the temperature, which already has some physical diffusion. "
+                           "(For historical reasons, the name used here is different "
+                           "from the one used in the 2012 paper by Kronbichler, "
+                           "Heister and Bangerth that describes ASPECT, see \\cite{kronbichler:etal:2012}. "
+                           "This parameter corresponds "
+                           "to the factor $\\alpha_E$ in the formulas following equation (15) of "
+                           "the paper.) Units: None.");
+        prm.declare_entry ("beta", "0.052",
+                           Patterns::List(Patterns::Double (0.)),
+                           "The $\\beta$ factor in the artificial viscosity "
+                           "stabilization. This parameter controls the maximum dissipation of the "
+                           "entropy viscosity, which is the part that only scales with the cell diameter "
+                           "and the maximum velocity in the cell, but does not depend on the solution "
+                           "field itself or its residual. An appropriate value for 2d is 0.052 and "
+                           "0.78 for 3d. (For historical reasons, the name used here is different "
+                           "from the one used in the 2012 paper by Kronbichler, "
+                           "Heister and Bangerth that describes ASPECT, see \\cite{kronbichler:etal:2012}. "
+                           "This parameter can be given as a single value or as a list with as "
+                           "many entries as one plus the number of compositional fields. In the "
+                           "former case all advection fields use the same stabilization parameters, "
+                           "in the latter case each field (temperature first, then all compositions) "
+                           "use individual parameters. This can be useful to reduce the stabilization "
+                           "for the temperature, which already has some physical diffusion. "
+                           "This parameter corresponds "
+                           "to the factor $\\alpha_{\\text{max}}$ in the formulas following equation (15) of "
+                           "the paper.) Units: None.");
+        prm.declare_entry ("gamma", "0.0",
+                           Patterns::Double (0.),
+                           "The strain rate scaling factor in the artificial viscosity "
+                           "stabilization. This parameter determines how much the strain rate (in addition "
+                           "to the velocity) should influence the stabilization. (This parameter does "
+                           "not correspond to any variable in the 2012 paper by Kronbichler, "
+                           "Heister and Bangerth that describes ASPECT, see \\cite{kronbichler:etal:2012}. "
+                           "Rather, the paper always uses "
+                           "0, i.e. they specify the maximum dissipation $\\nu_h^\\text{max}$ as "
+                           "$\\nu_h^\\text{max}\\vert_K = \\alpha_{\\text{max}} h_K \\|\\mathbf u\\|_{\\infty,K}$. "
+                           "Here, we use "
+                           "$\\|\\lvert\\mathbf u\\rvert + \\gamma h_K \\lvert\\varepsilon (\\mathbf u)\\rvert\\|_{\\infty,K}$ "
+                           "instead of $\\|\\mathbf u\\|_{\\infty,K}$. "
+                           "Units: None.");
+        prm.declare_entry ("Discontinuous penalty", "10.",
+                           Patterns::Double (0.),
+                           "The value used to penalize discontinuities in the discontinuous Galerkin "
+                           "method. This is used only for the temperature field, and not for the composition "
+                           "field, as pure advection does not use the interior penalty method. This "
+                           "is largely empirically decided -- it must be large enough to ensure "
+                           "the bilinear form is coercive, but not so large as to penalize "
+                           "discontinuity at all costs.");
+        prm.declare_entry ("Limiter for discontinuous temperature solution", "none",
+                           Patterns::Selection(DGLimiterType::pattern()),
+                           "The type of limiter to apply to the discontinuous temperature solution. "
+                           "Available options are:\n"
+                           "  * `bound preserving': a limiter that keeps the discontinuous solution "
+                           "in the range given by `Global temperature maximum' and `Global temperature "
+                           "minimum'.\n"
+                           "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
+                           "a polynomial function in places where shocks are detected, as described in "
+                           "\\cite{zhong:etal:2013}.\n"
+                           "  * `none`: if chosen, no limiter is applied to the discontinuous solution.\n"
+                           "Note that if this entry is not set to `none', then the limiter will modify "
+                           "the solution, so the nonlinear residual for this field is meaningless, and "
+                           "in nonlinear solvers we will ignore the residual for this field to evaluate "
+                           "if the nonlinear solver has converged.");
+        prm.declare_entry ("Limiter for discontinuous composition solution", "none",
+                           Patterns::List(Patterns::Selection(DGLimiterType::pattern())),
+                           "The type of limiter to apply to the discontinuous composition solution. The "
+                           "number of the input values separated by ',' has to be one or the same as the "
+                           "number of the compositional fields. When only one value is supplied, this "
+                           "same value is assumed for all compositional fields.\n"
+                           "Available options are:\n"
+                           "  * `bound preserving': a limiter that keeps the discontinuous solution "
+                           "in the range given by `Global temperature maximum' and `Global temperature "
+                           "minimum'.\n"
+                           "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
+                           "a polynomial function in places where shocks are detected, as described in "
+                           "\\cite{zhong:etal:2013}.\n"
+                           "  * `none`: if chosen, no limiter is applied to the discontinuous solution.\n"
+                           "Note that if this entry is not set to `none', then the limiter will modify "
+                           "the solution, so the nonlinear residual for this field is meaning less, and "
+                           "in nonlinear solvers we will ignore the residual for this field to evaluate "
+                           "if the nonlinear solver has converged.");
+        prm.declare_entry ("Global temperature maximum",
+                           boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
+                           Patterns::Double (),
+                           "The maximum global temperature value that will be used in the bound preserving "
+                           "limiter for the discontinuous solutions from temperature advection fields. "
+                           "The input value is active only when `Limiter for discontinuous temperature "
+                           "solution' is set to `bound preserving'.");
+        prm.declare_entry ("Global temperature minimum",
+                           boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
+                           Patterns::Double (),
+                           "The minimum global temperature value that will be used in the bound preserving "
+                           "limiter for the discontinuous solutions from temperature advection fields."
+                           "The input value is active only when `Limiter for discontinuous temperature "
+                           "solution' is set to `bound preserving'.");
+        prm.declare_entry ("Global composition maximum",
+                           boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
+                           Patterns::List(Patterns::Double ()),
+                           "The maximum global composition values that will be used in the bound preserving "
+                           "limiter for the discontinuous solutions from composition advection fields. "
+                           "The number of the input 'Global composition maximum' values separated by ',' has to be "
+                           "one or the same as the number of the compositional fields. When only one value "
+                           "is supplied, this same value is assumed for all compositional fields. "
+                           "The input value is active only when `Limiter for discontinuous composition "
+                           "solution' is set to `bound preserving'.");
+        prm.declare_entry ("Global composition minimum",
+                           boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
+                           Patterns::List(Patterns::Double ()),
+                           "The minimum global composition value that will be used in the bound preserving "
+                           "limiter for the discontinuous solutions from composition advection fields. "
+                           "The number of the input 'Global composition minimum' values separated by ',' has to be "
+                           "one or the same as the number of the compositional fields. When only one value "
+                           "is supplied, this same value is assumed for all compositional fields.\n"
+                           "The input value is active only when `Limiter for discontinuous composition "
+                           "solution' is set to `bound preserving'.");
+        prm.declare_entry ("Temperature KXRCF indicator threshold", "1.0",
+                           Patterns::Double(0.0),
+                           "The threshold of KXRCF indicator for the temperature field, as described in "
+                           "\\cite{Krivodonova:etal:2004}. If the KXRCF indicator of a cell is greater than "
+                           "the threshold, then the cell is marked as 'troubled' and will be smoothed by "
+                           "the WENO limiter.\n"
+                           "The input value is active only when `Limiter for discontinuous temperature "
+                           "solution' is set to `WENO'.");
+        prm.declare_entry ("Composition KXRCF indicator threshold", "1.0",
+                           Patterns::List(Double(0.0)),
+                           "The threshold of KXRCF indicator for the temperature field, as described in "
+                           "\\cite{Krivodonova:etal:2004}. If the KXRCF indicator of a cell is greater than "
+                           "the threshold, then the cell is marked as 'troubled' and will be smoothed by "
+                           "the WENO limiter. The number of the input values separated by ',' has to be one "
+                           "or the same as the number of the compositional fields. When only one value is "
+                           "supplied, this same value is assumed for all compositional fields.\n"
+                           "The input value is active only when `Limiter for discontinuous composition "
+                           "solution' is set to `WENO'.");
+        prm.declare_entry ("WENO linear weight of neighbor cells", "0.001",
+                           Patterns::Double(0.0, 1.0),
+                           "The linear weight of neighbor cells in WENO scheme. The larger this value is, "
+                           "the more weight is given to information from neighbor cells when reconstructing the polynomial "
+                           "reconstruction. See \\cite{zhong:etal:2013} for detail.");
+      }
+      prm.leave_subsection ();
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection ("Temperature field");
+    {
+      prm.declare_entry ("Temperature method", "field",
+                         Patterns::Selection("field|prescribed field|prescribed field with diffusion|static"),
+                         "A comma separated list denoting the solution method of the "
+                         "temperature field. Each entry of the list must be "
+                         "one of the currently implemented field types."
+                         "\n\n"
+                         "These choices correspond to the following methods by which "
+                         "the temperature field gains its values:"
+                         "\\begin{itemize}"
+                         "\\item ``field'': If the temperature is marked with this "
+                         "method, then its values are computed in each time step by "
+                         "solving the temperature advection-diffusion equation. In other words, "
+                         "this corresponds to the usual notion of a temperature. "
+                         "\n"
+                         "\\item ``prescribed field'': The value of the temperature is determined "
+                         "in each time step from the material model. If a compositional field is "
+                         "marked with this method, then the value of a specific additional material "
+                         "model output, called the `PrescribedTemperatureOutputs' is interpolated "
+                         "onto the temperature. This field does not change otherwise, it is not "
+                         "advected with the flow. "
+                         "\n"
+                         "\\item ``prescribed field with diffusion'': If the temperature field is "
+                         "marked this way, the value of a specific additional material model output, "
+                         "called the `PrescribedTemperatureOutputs' is interpolated onto the field, as in "
+                         "the ``prescribed field'' method. Afterwards, the field is diffused based on "
+                         "a solver parameter, the diffusion length scale, smoothing the field. "
+                         "Specifically, the field is updated by solving the equation "
+                         "$(I-l^2 \\Delta) T_\\text{smoothed} = T_\\text{prescribed}$, "
+                         "where $l$ is the diffusion length scale. Note that this means that the amount "
+                         "of diffusion is independent of the time step size, and that the field is not "
+                         "advected with the flow."
+                         "\n"
+                         "\\item ``static'': If a temperature field is marked "
+                         "this way, then it does not evolve at all. Its values are "
+                         "simply set to the initial conditions, and will then "
+                         "never change."
+                         "\\end{itemize}");
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Compositional fields");
+    {
+      prm.declare_entry ("Number of fields", "0",
+                         Patterns::Integer (0),
+                         "The number of fields that will be advected along with the flow field, excluding "
+                         "velocity, pressure and temperature.");
+      prm.declare_entry ("Names of fields", "",
+                         Patterns::List(Patterns::Anything()),
+                         "A user-defined name for each of the compositional fields requested.");
+      prm.declare_entry ("Types of fields", "unspecified",
+                         Patterns::List (Patterns::Selection("chemical composition|stress|strain|grain size|porosity|density|entropy|generic|unspecified")),
+                         "A type for each of the compositional fields requested. "
+                         "Each entry of the list must be "
+                         "one of several recognized types: chemical composition, "
+                         "stress, strain, grain size, porosity, density, entropy, "
+                         "general and unspecified. "
+                         "The generic type is intended to be a placeholder type "
+                         "that has no effect on the running of any material model, "
+                         "while the unspecified type is intended to tell ASPECT "
+                         "that the user has not explicitly indicated the type of "
+                         "field (facilitating parameter file checking). "
+                         "Plugins such as material models can use these types "
+                         "to affect how that plugin functions.");
+      prm.declare_entry ("Compositional field methods", "",
+                         Patterns::List (Patterns::Selection("field|particles|volume of fluid|static|melt field|darcy field|prescribed field|prescribed field with diffusion")),
+                         "A comma separated list denoting the solution method of each "
+                         "compositional field. Each entry of the list must be "
+                         "one of the currently implemented field methods."
+                         "\n\n"
+                         "These choices correspond to the following methods by which "
+                         "compositional fields gain their values:"
+                         "\\begin{itemize}"
+                         "\\item ``field'': If a compositional field is marked with this "
+                         "method, then its values are computed in each time step by "
+                         "advecting along the values of the previous time step using the "
+                         "velocity field, and applying reaction rates to it. In other words, "
+                         "this corresponds to the usual notion of a composition field as "
+                         "mentioned in Section~\\ref{sec:methods:compositional-fields}. "
+                         "\n"
+                         "\\item ``particles'': If a compositional field is marked with "
+                         "this method, then its values are obtained in each time step "
+                         "by interpolating the corresponding properties from the "
+                         "particles located on each cell. The time evolution therefore "
+                         "happens because particles move along with the velocity field, "
+                         "and particle properties can react with each other as well. "
+                         "See Section~\\ref{sec:methods:particles} for more information about "
+                         "how particles behave."
+                         "\n"
+                         "\\item ``volume of fluid``: If a compositional field "
+                         "is marked with this method, then its values are "
+                         "obtained in each timestep by reconstructing a "
+                         "polynomial finite element approximation on each cell "
+                         "from a volume of fluid interface tracking method, "
+                         "which is used to compute the advection updates."
+                         "\n"
+                         "\\item ``static'': If a compositional field is marked "
+                         "this way, then it does not evolve at all. Its values are "
+                         "simply set to the initial conditions, and will then "
+                         "never change."
+                         "\n"
+                         "\\item ``melt field'': If a compositional field is marked with this "
+                         "method, then its values are computed in each time step by "
+                         "advecting along the values of the previous time step using the "
+                         "melt velocity, and applying reaction rates to it. In other words, "
+                         "this corresponds to the usual notion of a composition field as "
+                         "mentioned in Section~\\ref{sec:methods:compositional-fields}, except that it is "
+                         "advected with the melt velocity instead of the solid velocity. "
+                         "This method can only be chosen if melt transport is active in the "
+                         "model."
+                         "\n"
+                         "\\item ``darcy field'': If a compositional field is marked with this "
+                         "method, then its values are computed in each time step by "
+                         "advecting along the values of the previous time step using the "
+                         "fluid velocity prescribed by Darcy's Law, and applying reaction rates "
+                         "to it. In other words this corresponds to the usual notion of a composition "
+                         "field as mentioned in Section~\\ref{sec:methods:compositional-fields}, except that it is "
+                         "advected with the Darcy velocity instead of the solid velocity. This method "
+                         "requires there to be a compositional field named porosity that is advected "
+                         "the darcy field method. We calculate the fluid velocity $u_f$ using an "
+                         "approximation of Darcy's Law: $u_f = u_s - K_D / \\phi * (rho_s * g - rho_f * g)$."
+                         "\n"
+                         "\\item ``prescribed field'': The value of these fields is determined "
+                         "in each time step from the material model. If a compositional field is "
+                         "marked with this method, then the value of a specific additional material "
+                         "model output, called the `PrescribedFieldOutputs' is interpolated "
+                         "onto the field. This field does not change otherwise, it is not "
+                         "advected with the flow."
+                         "\n"
+                         "\\item ``prescribed field with diffusion'': If a compositional field is "
+                         "marked this way, the value of a specific additional material model output, "
+                         "called the `PrescribedFieldOutputs' is interpolated onto the field, as in "
+                         "the ``prescribed field'' method. Afterwards, the field is diffused based on "
+                         "a solver parameter, the diffusion length scale, smoothing the field. "
+                         "Specifically, the field is updated by solving the equation "
+                         "$(I-l^2 \\Delta) C_\\text{smoothed} = C_\\text{prescribed}$, "
+                         "where $l$ is the diffusion length scale. Note that this means that the amount "
+                         "of diffusion is independent of the time step size, and that the field is not "
+                         "advected with the flow."
+                         "\\end{itemize}");
+      prm.declare_entry ("Mapped particle properties", "",
+                         Patterns::Map (Patterns::Anything(),
+                                        Patterns::Anything()),
+                         "A comma separated list denoting the particle properties "
+                         "that will be projected to those compositional fields that "
+                         "are of the ``particles'' field type."
+                         "\n\n"
+                         "The format of valid entries for this parameter is that of a map "
+                         "given as ``key1: value1, key2: value2 [component2], key3: value3 [component4], "
+                         "...'' where each key must be a valid field name of the "
+                         "``particles'' type, and each value must be one of the currently "
+                         "selected particle properties. Component is a component index of "
+                         "the particle property that is 0 by default, but can be set up to "
+                         "n-1, where n is the number of vector components of this particle "
+                         "property. The component indicator only needs to be "
+                         "set if not the first component of the particle property should be "
+                         "mapped (e.g. the $y$-component of the velocity at the particle positions).");
+      prm.declare_entry ("List of normalized fields", "",
+                         Patterns::List (Patterns::Integer(0)),
+                         "A list of integers smaller than or equal to the number of "
+                         "compositional fields. All compositional fields in this "
+                         "list will be normalized before the first timestep. "
+                         "The normalization is implemented in the following way: "
+                         "First, the sum of the fields to be normalized is calculated "
+                         "at every point and the global maximum is determined. "
+                         "Second, the compositional fields to be normalized are "
+                         "divided by this maximum.");
+    }
+    prm.leave_subsection ();
+
+    // Finally declare a couple of parameters related how we should
+    // evaluate the material models when assembling the matrix and
+    // preconditioner
+    prm.enter_subsection ("Material model");
+    {
+      prm.declare_entry ("Material averaging", "default averaging",
+                         Patterns::Selection(MaterialModel::MaterialAveraging::
+                                             get_averaging_operation_names()),
+                         "Whether or not (and in the first case, how) to do any averaging of "
+                         "material model output data when constructing the linear systems "
+                         "for velocity/pressure, temperature, and compositions in each "
+                         "time step, as well as their corresponding preconditioners. "
+                         "The default value 'default averaging' will choose the averaging "
+                         "option based on the Stokes solver type."
+                         "\n\n"
+                         "Possible choices: " + MaterialModel::MaterialAveraging::
+                         get_averaging_operation_names()
+                         +
+                         "\n\n"
+                         "The process of averaging, and where it may be used, is "
+                         "discussed in more detail in "
+                         "Section~\\ref{sec:cookbooks:sinker-with-averaging}."
+                         "\n\n"
+                         "More averaging schemes are available in the averaging material "
+                         "model. This material model is a ``compositing material model'' "
+                         "which can be used in combination with other material models.");
+    }
+    prm.leave_subsection ();
+
+    VolumeOfFluidHandler<dim>::declare_parameters(prm);
+
+    // then, finally, let user additions that do not go through the usual
+    // plugin mechanism, declare their parameters if they have subscribed
+    // to the relevant signals
+    SimulatorSignals<dim>::declare_additional_parameters (dim, prm);
+  }
+
+
+
+  template <int dim>
+  void
+  Parameters<dim>::
+  parse_parameters (ParameterHandler &prm,
+                    const MPI_Comm mpi_communicator)
+  {
+    // first, make sure that the ParameterHandler parser agrees
+    // with the code in main() about the meaning of the "Dimension"
+    // parameter
+    AssertThrow (prm.get_integer("Dimension") == dim,
+                 ExcInternalError());
+
+    CFL_number              = prm.get_double ("CFL number");
+    use_conduction_timestep = prm.get_bool ("Use conduction timestep");
+    convert_to_years        = prm.get_bool ("Use years in output instead of seconds");
+    timing_output_frequency = prm.get_integer ("Timing output frequency");
+    world_builder_file      = prm.get("World builder file");
+
+    maximum_time_step       = prm.get_double("Maximum time step");
+    if (convert_to_years == true)
+      maximum_time_step *= year_in_seconds;
+
+    maximum_relative_increase_time_step = prm.get_double("Maximum relative increase in time step") * 0.01;
+    maximum_first_time_step = prm.get_double("Maximum first time step");
+    if (convert_to_years == true)
+      maximum_first_time_step *= year_in_seconds;
+
+    {
+      const std::string solver_scheme = prm.get ("Nonlinear solver scheme");
+      if (solver_scheme == "single Advection, single Stokes" || solver_scheme == "IMPES")
+        nonlinear_solver = NonlinearSolver::single_Advection_single_Stokes;
+      else if (solver_scheme == "iterated Advection and Stokes" || solver_scheme == "iterated IMPES")
+        nonlinear_solver = NonlinearSolver::iterated_Advection_and_Stokes;
+      else if (solver_scheme == "single Advection, iterated Stokes" || solver_scheme == "iterated Stokes")
+        nonlinear_solver = NonlinearSolver::single_Advection_iterated_Stokes;
+      else if (solver_scheme == "no Advection, iterated Stokes" || solver_scheme == "Stokes only")
+        nonlinear_solver = NonlinearSolver::no_Advection_iterated_Stokes;
+      else if (solver_scheme == "no Advection, single Stokes")
+        nonlinear_solver = NonlinearSolver::no_Advection_single_Stokes;
+      else if (solver_scheme == "no Advection, iterated defect correction Stokes")
+        nonlinear_solver = NonlinearSolver::no_Advection_iterated_defect_correction_Stokes;
+      else if (solver_scheme == "single Advection, iterated defect correction Stokes")
+        nonlinear_solver = NonlinearSolver::single_Advection_iterated_defect_correction_Stokes;
+      else if (solver_scheme == "iterated Advection and defect correction Stokes")
+        nonlinear_solver = NonlinearSolver::iterated_Advection_and_defect_correction_Stokes;
+      else if (solver_scheme == "iterated Advection and Newton Stokes" || solver_scheme == "Newton Stokes")
+        nonlinear_solver = NonlinearSolver::iterated_Advection_and_Newton_Stokes;
+      else if (solver_scheme == "single Advection, iterated Newton Stokes")
+        nonlinear_solver = NonlinearSolver::single_Advection_iterated_Newton_Stokes;
+      else if (solver_scheme == "single Advection, no Stokes" || solver_scheme == "Advection only")
+        nonlinear_solver = NonlinearSolver::single_Advection_no_Stokes;
+      else if (solver_scheme == "first timestep only, single Stokes")
+        nonlinear_solver = NonlinearSolver::first_timestep_only_single_Stokes;
+      else if (solver_scheme == "no Advection, no Stokes")
+        nonlinear_solver = NonlinearSolver::no_Advection_no_Stokes;
+      else
+        AssertThrow (false, ExcNotImplemented());
+    }
+
+    prm.enter_subsection ("Solver parameters");
+    {
+      temperature_solver_tolerance    = prm.get_double ("Temperature solver tolerance");
+      composition_solver_tolerance    = prm.get_double ("Composition solver tolerance");
+
+      prm.enter_subsection ("Advection solver parameters");
+      {
+        advection_gmres_restart_length     = prm.get_integer("GMRES solver restart length");
+      }
+      prm.leave_subsection ();
+
+      prm.enter_subsection ("Stokes solver parameters");
+      {
+        stokes_solver_type = StokesSolverType::parse(prm.get("Stokes solver type"));
+        if (prm.get_bool("Use direct solver for Stokes system"))
+          stokes_solver_type = StokesSolverType::direct_solver;
+        use_bfbt = prm.get_bool("Use weighted BFBT for Schur complement");
+        use_direct_stokes_solver        = stokes_solver_type==StokesSolverType::direct_solver;
+        stokes_krylov_type = StokesKrylovType::parse(prm.get("Krylov method for cheap solver steps"));
+        idr_s_parameter    = prm.get_integer("IDR(s) parameter");
+
+        linear_stokes_solver_tolerance  = prm.get_double ("Linear solver tolerance");
+        n_cheap_stokes_solver_steps     = prm.get_integer ("Number of cheap Stokes solver steps");
+        n_expensive_stokes_solver_steps = prm.get_integer ("Maximum number of expensive Stokes solver steps");
+        linear_solver_A_block_tolerance = prm.get_double ("Linear solver A block tolerance");
+        use_full_A_block_preconditioner = prm.get_bool ("Use full A block as preconditioner");
+        force_nonsymmetric_A_block_solver = prm.get_bool("Force nonsymmetric A block solver");
+        linear_solver_S_block_tolerance = prm.get_double ("Linear solver S block tolerance");
+        stokes_gmres_restart_length     = prm.get_integer("GMRES solver restart length");
+      }
+      prm.leave_subsection ();
+
+      prm.enter_subsection ("AMG parameters");
+      {
+        AMG_smoother_type                      = prm.get ("AMG smoother type");
+        AMG_smoother_sweeps                    = prm.get_integer ("AMG smoother sweeps");
+        AMG_aggregation_threshold              = prm.get_double ("AMG aggregation threshold");
+        AMG_output_details                     = prm.get_bool ("AMG output details");
+      }
+      prm.leave_subsection ();
+      prm.enter_subsection ("Operator splitting parameters");
+      {
+        reaction_solver_type                   = ReactionSolverType::parse(prm.get("Reaction solver type"));
+        ARKode_relative_tolerance              = prm.get_double("Reaction solver relative tolerance");
+        reaction_time_step       = prm.get_double("Reaction time step");
+        AssertThrow (reaction_time_step > 0,
+                     ExcMessage("Reaction time step must be greater than 0."));
+        if (convert_to_years == true)
+          reaction_time_step *= year_in_seconds;
+        reaction_steps_per_advection_step = prm.get_integer ("Reaction time steps per advection step");
+      }
+      prm.leave_subsection ();
+      prm.enter_subsection ("Diffusion solver parameters");
+      {
+        diffusion_length_scale = prm.get_double("Diffusion length scale");
+      }
+      prm.leave_subsection ();
+    }
+    prm.leave_subsection ();
+
+    nonlinear_tolerance = prm.get_double("Nonlinear solver tolerance");
+
+    max_nonlinear_iterations = prm.get_integer ("Max nonlinear iterations");
+    max_nonlinear_iterations_in_prerefinement = prm.get_integer ("Max nonlinear iterations in pre-refinement");
+
+    start_time              = prm.get_double ("Start time");
+    if (convert_to_years == true)
+      start_time *= year_in_seconds;
+
+    end_time = prm.get_double ("End time");
+    if (convert_to_years == true)
+      end_time *= year_in_seconds;
+
+    output_directory        = prm.get ("Output directory");
+    if (output_directory.size() == 0)
+      output_directory = "./";
+    else if (output_directory[output_directory.size()-1] != '/')
+      output_directory += "/";
+
+    Utilities::create_directory (output_directory,
+                                 mpi_communicator,
+                                 false);
+
+    if (prm.get ("Resume computation") == "true")
+      resume_computation = true;
+    else if (prm.get ("Resume computation") == "false")
+      resume_computation = false;
+    else if (prm.get ("Resume computation") == "auto")
+      {
+        resume_computation = Utilities::fexists(output_directory+"restart.mesh", mpi_communicator);
+      }
+    else
+      AssertThrow (false, ExcMessage ("Resume computation parameter must be either `true', `false', or `auto'."));
+#ifndef DEAL_II_WITH_ZLIB
+    AssertThrow (resume_computation == false,
+                 ExcMessage ("You need to have deal.II configured with the `libz' "
+                             "option if you want to resume a computation from a checkpoint, but deal.II "
+                             "did not detect its presence when you called `cmake'."));
+#endif
+
+    surface_pressure                = prm.get_double ("Surface pressure");
+    adiabatic_surface_temperature   = prm.get_double ("Adiabatic surface temperature");
+    pressure_normalization          = prm.get("Pressure normalization");
+
+    use_operator_splitting          = prm.get_bool("Use operator splitting");
+
+    prm.enter_subsection ("Mesh refinement");
+    {
+      initial_global_refinement    = prm.get_integer ("Initial global refinement");
+      initial_adaptive_refinement  = prm.get_integer ("Initial adaptive refinement");
+
+      adaptive_refinement_interval = prm.get_integer ("Time steps between mesh refinement");
+      refinement_fraction          = prm.get_double ("Refinement fraction");
+      coarsening_fraction          = prm.get_double ("Coarsening fraction");
+      adapt_by_fraction_of_cells   = prm.get_bool ("Adapt by fraction of cells");
+      min_grid_level               = prm.get_integer ("Minimum refinement level");
+
+      AssertThrow(refinement_fraction >= 0 && coarsening_fraction >= 0,
+                  ExcMessage("Refinement/coarsening fractions must be positive."));
+      AssertThrow(refinement_fraction+coarsening_fraction <= 1,
+                  ExcMessage("Refinement and coarsening fractions must be <= 1."));
+      AssertThrow(min_grid_level <= initial_global_refinement,
+                  ExcMessage("Minimum refinement level must not be larger than "
+                             "Initial global refinement."));
+
+      // extract the list of times at which additional refinement is requested
+      // then sort it and convert it to seconds
+      additional_refinement_times
+        = Utilities::string_to_double
+          (Utilities::split_string_list(prm.get ("Additional refinement times")));
+      std::sort (additional_refinement_times.begin(),
+                 additional_refinement_times.end());
+      if (convert_to_years == true)
+        for (double &additional_refinement_time : additional_refinement_times)
+          additional_refinement_time *= year_in_seconds;
+
+      skip_solvers_on_initial_refinement = prm.get_bool("Skip solvers on initial refinement");
+      skip_setup_initial_conditions_on_initial_refinement = prm.get_bool("Skip setup initial conditions on initial refinement");
+
+      if (skip_setup_initial_conditions_on_initial_refinement == true && skip_solvers_on_initial_refinement == false)
+        AssertThrow(false, ExcMessage("Cannot execute solvers if no initial conditions are set up. "
+                                      "You must set skip_solvers_on_initial_refinement to true."));
+
+      run_postprocessors_on_initial_refinement = prm.get_bool("Run postprocessors on initial refinement");
+
+      if (skip_setup_initial_conditions_on_initial_refinement == true && run_postprocessors_on_initial_refinement == true)
+        AssertThrow(false, ExcMessage("Cannot run postprocessors if no initial conditions are set up. "
+                                      "You must set run_postprocessors_on_initial_refinement to false."));
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection ("Postprocess");
+    {
+      run_postprocessors_on_nonlinear_iterations = prm.get_bool("Run postprocessors on nonlinear iterations");
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection ("Formulation");
+    {
+      // The following options each have a set of conditions to be met in order
+      // for the formulation to be consistent, however, most of
+      // the information is not available at this point. Therefore, the error checking is done
+      // in Simulator<dim>::check_consistency_of_formulation() after the initialization of
+      // material models, heating plugins, and adiabatic conditions.
+      formulation = Formulation::parse(prm.get("Formulation"));
+      if (formulation == Formulation::isentropic_compression)
+        {
+          formulation_mass_conservation = Formulation::MassConservation::isentropic_compression;
+          formulation_temperature_equation = Formulation::TemperatureEquation::real_density;
+        }
+      else if (formulation == Formulation::boussinesq_approximation)
+        {
+          formulation_mass_conservation = Formulation::MassConservation::incompressible;
+          formulation_temperature_equation = Formulation::TemperatureEquation::reference_density_profile;
+        }
+      else if (formulation == Formulation::anelastic_liquid_approximation)
+        {
+          // equally possible: implicit_reference_profile
+          formulation_mass_conservation = Formulation::MassConservation::reference_density_profile;
+          formulation_temperature_equation = Formulation::TemperatureEquation::reference_density_profile;
+        }
+      else if (formulation == Formulation::custom)
+        {
+          formulation_mass_conservation = Formulation::MassConservation::parse(prm.get("Mass conservation"));
+          formulation_temperature_equation = Formulation::TemperatureEquation::parse(prm.get("Temperature equation"));
+        }
+      else AssertThrow(false, ExcNotImplemented());
+
+      enable_additional_stokes_rhs = prm.get_bool ("Enable additional Stokes RHS");
+      enable_elasticity = prm.get_bool("Enable elasticity");
+      enable_prescribed_dilation = prm.get_bool("Enable prescribed dilation");
+    }
+    prm.leave_subsection ();
+
+
+    prm.enter_subsection ("Melt settings");
+    {
+      include_melt_transport = prm.get_bool ("Include melt transport");
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Nullspace removal");
+    {
+      nullspace_removal = NullspaceRemoval::none;
+      std::vector<std::string> nullspace_names =
+        Utilities::split_string_list(prm.get("Remove nullspace"));
+      AssertThrow(Utilities::has_unique_entries(nullspace_names),
+                  ExcMessage("The list of strings for the parameter "
+                             "'Nullspace removal/Remove nullspace' contains entries more than once. "
+                             "This is not allowed. Please check your parameter file."));
+
+      for (const auto &nullspace_name : nullspace_names)
+        {
+          if (nullspace_name=="net rotation")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::net_rotation);
+          else if (nullspace_name=="net surface rotation")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::net_surface_rotation);
+          else if (nullspace_name=="angular momentum")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::angular_momentum);
+          else if (nullspace_name=="net translation")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::net_translation_x |
+                                  NullspaceRemoval::net_translation_y | ( dim == 3 ?
+                                                                          NullspaceRemoval::net_translation_z : 0) );
+          else if (nullspace_name=="net x translation")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::net_translation_x);
+          else if (nullspace_name=="net y translation")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::net_translation_y);
+          else if (nullspace_name=="net z translation")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::net_translation_z);
+          else if (nullspace_name=="linear x momentum")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::linear_momentum_x);
+          else if (nullspace_name=="linear y momentum")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::linear_momentum_y);
+          else if (nullspace_name=="linear z momentum")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::linear_momentum_z);
+          else if (nullspace_name=="linear momentum")
+            nullspace_removal = typename NullspaceRemoval::Kind(
+                                  nullspace_removal | NullspaceRemoval::linear_momentum_x |
+                                  NullspaceRemoval::linear_momentum_y | ( dim == 3 ?
+                                                                          NullspaceRemoval::linear_momentum_z : 0) );
+          else
+            AssertThrow(false, ExcInternalError());
+        }
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection ("Checkpointing");
+    {
+      checkpoint_time_secs = prm.get_integer ("Time between checkpoint");
+      checkpoint_steps     = prm.get_integer ("Steps between checkpoint");
+
+#ifndef DEAL_II_WITH_ZLIB
+      AssertThrow ((checkpoint_time_secs == 0)
+                   &&
+                   (checkpoint_steps == 0),
+                   ExcMessage ("You need to have deal.II configured with the `libz' "
+                               "option if you want to generate checkpoints, but deal.II "
+                               "did not detect its presence when you called `cmake'."));
+#endif
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection ("Compositional fields");
+    {
+      n_compositional_fields = prm.get_integer ("Number of fields");
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Discretization");
+    {
+      stokes_velocity_degree = prm.get_integer ("Stokes velocity polynomial degree");
+      temperature_degree     = prm.get_integer ("Temperature polynomial degree");
+      composition_degree     = prm.get_integer ("Composition polynomial degree");
+      use_locally_conservative_discretization
+        = prm.get_bool ("Use locally conservative discretization");
+      use_equal_order_interpolation_for_stokes
+        = prm.get_bool ("Use equal order interpolation for Stokes");
+      use_discontinuous_temperature_discretization
+        = prm.get_bool("Use discontinuous temperature discretization");
+      use_discontinuous_composition_discretization
+        = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_bool(Utilities::split_string_list(prm.get("Use discontinuous composition discretization"))),
+                                                  n_compositional_fields,
+                                                  "Use discontinuous composition discretization");
+      have_discontinuous_composition_discretization =
+        (std::find(use_discontinuous_composition_discretization.begin(), use_discontinuous_composition_discretization.end(), true)
+         != use_discontinuous_composition_discretization.end());
+
+      // TODO: this needs to be modified once we lift the restriction that all compositions have the same degree.
+      AssertThrow(have_discontinuous_composition_discretization == true || composition_degree > 0,
+                  ExcMessage("Using a composition polynomial degree of 0 (cell-wise constant composition) "
+                             "is only supported if a discontinuous composition discretization is selected."));
+
+      prm.enter_subsection ("Stabilization parameters");
+      {
+        advection_stabilization_method = AdvectionStabilizationMethod::parse(prm.get("Stabilization method"));
+        use_artificial_viscosity_smoothing  = prm.get_bool ("Use artificial viscosity smoothing");
+        stabilization_alpha                 = prm.get_integer ("alpha");
+
+        stabilization_c_R                   = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("cR"))),
+                                                                                      n_compositional_fields+1,
+                                                                                      "cR");
+        stabilization_beta                  = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("beta"))),
+                                                                                      n_compositional_fields+1,
+                                                                                      "beta");
+
+        stabilization_gamma                 = prm.get_double ("gamma");
+        discontinuous_penalty               = prm.get_double ("Discontinuous penalty");
+
+        limiter_for_discontinuous_temperature_solution = DGLimiterType::parse(prm.get("Limiter for discontinuous temperature solution"));
+        std::vector<std::string> x_limiter_for_discontinuous_composition_solution =
+          Utilities::possibly_extend_from_1_to_N(Utilities::split_string_list(prm.get("Limiter for discontinuous composition solution")),
+                                                 n_compositional_fields,
+                                                 "Limiter for discontinuous composition solution");
+        limiter_for_discontinuous_composition_solution.resize(n_compositional_fields);
+        for (unsigned int c = 0; c < n_compositional_fields; ++c)
+          limiter_for_discontinuous_composition_solution[c] = DGLimiterType::parse(x_limiter_for_discontinuous_composition_solution[c]);
+
+        global_temperature_max_preset       = prm.get_double ("Global temperature maximum");
+        global_temperature_min_preset       = prm.get_double ("Global temperature minimum");
+        global_composition_max_preset       = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double
+                                                                                      (Utilities::split_string_list(prm.get ("Global composition maximum"))),
+                                                                                      n_compositional_fields,
+                                                                                      "Global composition maximum");
+        global_composition_min_preset       = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double
+                                                                                      (Utilities::split_string_list(prm.get ("Global composition minimum"))),
+                                                                                      n_compositional_fields,
+                                                                                      "Global composition minimum");
+
+        temperature_KXRCF_indicator_threshold = prm.get_double ("Temperature KXRCF indicator threshold");
+        composition_KXRCF_indicator_threshold = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double
+                                                                                        (Utilities::split_string_list(prm.get("Composition KXRCF indicator threshold"))),
+                                                                                        n_compositional_fields,
+                                                                                        "Composition KXRCF indicator threshold");
+        WENO_linear_weight = prm.get_double("WENO linear weight of neighbor cells");
+
+        compositional_fields_with_disabled_boundary_entropy_viscosity =
+          Utilities::split_string_list(prm.get("List of compositional fields with disabled boundary entropy viscosity"));
+
+      }
+      prm.leave_subsection ();
+
+      AssertThrow ((use_locally_conservative_discretization ||
+                    use_equal_order_interpolation_for_stokes)
+                   ||
+                   (stokes_velocity_degree > 1),
+                   ExcMessage ("The polynomial degree for the velocity field "
+                               "specified in the 'Stokes velocity polynomial degree' "
+                               "parameter must be at least 2, unless you are using "
+                               "the 'Use equal order interpolation for Stokes' parameter, "
+                               "or if you are using "
+                               "a locally conservative discretization as specified by the "
+                               "'Use locally conservative discretization' parameter. "
+                               "In both of these cases, the polynomial degree used for the "
+                               "velocity may be equal to one."
+                               "\n\n"
+                               "The restriction exists because by default, the pressure element "
+                               "is of one degree lower and continuous, and if you selected "
+                               "a linear element for the velocity, you'd need a continuous "
+                               "element of degree zero for the pressure, which does not exist. "
+                               "On the other hand, if using equal-order interpolation, "
+                               "choosing the polynomial degree as one yields a Q1-Q1 "
+                               "element; using a locally conservative discretization "
+                               "with polynomial degree of one yields a Q1-P0 "
+                               "element."));
+
+      AssertThrow (! (use_locally_conservative_discretization &&
+                      use_equal_order_interpolation_for_stokes),
+                   ExcMessage ("You have tried to use both the 'Use locally "
+                               "conservative discretization' and 'Use equal order "
+                               "interpolation for Stokes' parameters in the input "
+                               "file. However, their use is incompatible: you "
+                               "can only select one of the two."));
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection ("Temperature field");
+    {
+      std::string x_temperature_method
+        = prm.get ("Temperature method");
+
+      if (x_temperature_method == "field")
+        temperature_method = AdvectionFieldMethod::fem_field;
+      else if (x_temperature_method == "prescribed field")
+        temperature_method = AdvectionFieldMethod::prescribed_field;
+      else if (x_temperature_method == "prescribed field with diffusion")
+        temperature_method = AdvectionFieldMethod::prescribed_field_with_diffusion;
+      else if (x_temperature_method == "static")
+        temperature_method = AdvectionFieldMethod::static_field;
+      else
+        AssertThrow(false,ExcNotImplemented());
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Compositional fields");
+    {
+      if (include_melt_transport && (n_compositional_fields == 0))
+        {
+          AssertThrow (false,
+                       ExcMessage ("If melt transport is included in the model, "
+                                   "there has to be at least one compositional field."));
+        }
+
+      names_of_compositional_fields = Utilities::split_string_list (prm.get("Names of fields"));
+      AssertThrow ((names_of_compositional_fields.size() == 0) ||
+                   (names_of_compositional_fields.size() == n_compositional_fields),
+                   ExcMessage ("The length of the list of names for the compositional "
+                               "fields needs to either be empty or have length equal to "
+                               "the number of compositional fields."));
+
+      // check that the names use only allowed characters, are not empty strings and are unique
+      for (unsigned int i=0; i<names_of_compositional_fields.size(); ++i)
+        {
+          AssertThrow (names_of_compositional_fields[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
+                                                                          "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                                                          "0123456789_") == std::string::npos,
+                       ExcMessage("Invalid character in field " + names_of_compositional_fields[i] + ". "
+                                  "Names of compositional fields should consist of a "
+                                  "combination of letters, numbers and underscores."));
+          AssertThrow (names_of_compositional_fields[i].size() > 0,
+                       ExcMessage("Invalid name of field " + names_of_compositional_fields[i] + ". "
+                                  "Names of compositional fields need to be non-empty."));
+          for (unsigned int j=0; j<i; ++j)
+            AssertThrow (names_of_compositional_fields[i] != names_of_compositional_fields[j],
+                         ExcMessage("Names of compositional fields have to be unique! " + names_of_compositional_fields[i] +
+                                    " is used more than once."));
+        }
+
+      // default names if list is empty
+      if (names_of_compositional_fields.size() == 0)
+        for (unsigned int i=0; i<n_compositional_fields; ++i)
+          names_of_compositional_fields.push_back("C_" + Utilities::int_to_string(i+1));
+
+      // if we want to solve the melt transport equations, check that one of the fields
+      // has the name porosity
+      if (include_melt_transport && std::find(names_of_compositional_fields.begin(),
+                                              names_of_compositional_fields.end(), "porosity")
+          == names_of_compositional_fields.end())
+        {
+          AssertThrow (false, ExcMessage ("If melt transport is included in the model, "
+                                          "there has to be at least one compositional field "
+                                          "with the name `porosity'."));
+        }
+
+      const std::vector<int> n_normalized_fields = Utilities::string_to_int
+                                                   (Utilities::split_string_list(prm.get ("List of normalized fields")));
+      normalized_fields = std::vector<unsigned int> (n_normalized_fields.begin(),
+                                                     n_normalized_fields.end());
+
+      AssertThrow (normalized_fields.size() <= n_compositional_fields,
+                   ExcMessage("Invalid input parameter file: Too many entries in List of normalized fields"));
+
+      // Process the compositional field types
+      // There are three valid cases:
+      // 1) The user doesn't specify types of fields. This choice should
+      // result in the default type being used for all fields.
+      // The default type is "unspecified".
+      // 2) The user specifies just one type of field. In this case, ASPECT
+      // should automatically assume that all fields have the same type.
+      // 3) The user specifies types for every compositional field.
+      std::vector<std::string> x_compositional_field_types
+        = Utilities::split_string_list
+          (prm.get ("Types of fields"));
+
+      AssertThrow ((x_compositional_field_types.size() == 1) ||
+                   (x_compositional_field_types.size() == n_compositional_fields),
+                   ExcMessage ("The length of the list of names for the field types of compositional "
+                               "fields needs to either have one entry or have a length equal to "
+                               "the number of compositional fields."));
+
+      // If only one method is specified apply this to all fields
+      if (x_compositional_field_types.size() == 1)
+        x_compositional_field_types = std::vector<std::string> (n_compositional_fields, x_compositional_field_types[0]);
+
+      for (unsigned int i=0; i<n_compositional_fields; ++i)
+        if (x_compositional_field_types[i] == "unspecified")
+          {
+            // Loop over various possibilities before
+            // choosing "chemical composition" as the standard field name
+            // stress, strain, grain_size, porosity, density
+            if (names_of_compositional_fields[i].find("stress") != std::string::npos)
+              {
+                x_compositional_field_types[i] = "stress";
+                // Fields that are of stress type will not be taken into
+                // account by the viscoplastic and viscoelastic material model
+                // when material properties are computed. Force the user to set a field type
+                // for fields with 'stress' in their name if elasticity is not enabled.
+                AssertThrow(enable_elasticity,
+                            ExcMessage("Even though elasticity is not enabled, ASPECT deduced a stress field type from the name of a compositional field. "
+                                       "Please specify the compositional field types explicitly. "
+                                       "At the moment the type of field " + names_of_compositional_fields[i] + " is unspecified."));
+              }
+            else if ((names_of_compositional_fields[i].find("strain") != std::string::npos)
+                     || (std::regex_match(names_of_compositional_fields[i],std::regex("s[1-3][1-3]"))))
+              x_compositional_field_types[i] = "strain";
+            else if (names_of_compositional_fields[i].find("grain_size") != std::string::npos)
+              x_compositional_field_types[i] = "grain size";
+            else if (names_of_compositional_fields[i].find("entropy") != std::string::npos)
+              x_compositional_field_types[i] = "entropy";
+            else if (names_of_compositional_fields[i] == "porosity")
+              x_compositional_field_types[i] = "porosity";
+            else if (names_of_compositional_fields[i] == "density_field")
+              x_compositional_field_types[i] = "density";
+            else
+              x_compositional_field_types[i] = "chemical composition";
+          }
+
+      // If only one method is specified apply this to all fields
+      if (x_compositional_field_types.size() == 1)
+        x_compositional_field_types = std::vector<std::string> (n_compositional_fields, x_compositional_field_types[0]);
+
+      AssertThrow (std::count(x_compositional_field_types.begin(), x_compositional_field_types.end(), "density") < 2,
+                   ExcMessage("There can only be one field of type 'density' in a simulation!"));
+
+      composition_descriptions.resize(n_compositional_fields);
+
+      for (unsigned int i=0; i<n_compositional_fields; ++i)
+        composition_descriptions[i].type = aspect::CompositionalFieldDescription::parse_type(x_compositional_field_types[i]);
+
+      std::vector<std::string> x_compositional_field_methods
+        = Utilities::split_string_list
+          (prm.get ("Compositional field methods"));
+
+      AssertThrow ((x_compositional_field_methods.size() == 0) ||
+                   (x_compositional_field_methods.size() == 1) ||
+                   (x_compositional_field_methods.size() == n_compositional_fields),
+                   ExcMessage ("The length of the list of names for the field method of compositional "
+                               "fields needs to be empty, or have one entry, or have a length equal to "
+                               "the number of compositional fields."));
+
+      // If no method is specified set the default, which is solve every composition
+      // by a continuous field method
+      if (x_compositional_field_methods.size() == 0)
+        x_compositional_field_methods = std::vector<std::string> (n_compositional_fields,"field");
+      // If only one method is specified assume all fields are solved by this method
+      else if (x_compositional_field_methods.size() == 1)
+        x_compositional_field_methods = std::vector<std::string> (n_compositional_fields,x_compositional_field_methods[0]);
+
+
+      // Parse all field methods and store them, the vector should be empty
+      // since nobody should have written into it yet.
+      Assert(compositional_field_methods.size() == 0,
+             ExcInternalError());
+      compositional_field_methods.resize(n_compositional_fields);
+      for (unsigned int i = 0; i < n_compositional_fields; ++i)
+        {
+          if (x_compositional_field_methods[i] == "field")
+            compositional_field_methods[i] = AdvectionFieldMethod::fem_field;
+          else if (x_compositional_field_methods[i] == "particles")
+            compositional_field_methods[i] = AdvectionFieldMethod::particles;
+          else if (x_compositional_field_methods[i] == "volume of fluid")
+            {
+              AssertThrow (dim==2,
+                           ExcMessage ("The 'volume of fluid' method is currently "
+                                       "only implemented for two-dimensional "
+                                       "computations."));
+              compositional_field_methods[i] = AdvectionFieldMethod::volume_of_fluid;
+            }
+          else if (x_compositional_field_methods[i] == "static")
+            compositional_field_methods[i] = AdvectionFieldMethod::static_field;
+          else if (x_compositional_field_methods[i] == "melt field")
+            compositional_field_methods[i] = AdvectionFieldMethod::fem_melt_field;
+          else if (x_compositional_field_methods[i] == "darcy field")
+            compositional_field_methods[i] = AdvectionFieldMethod::fem_darcy_field;
+          else if (x_compositional_field_methods[i] == "prescribed field")
+            compositional_field_methods[i] = AdvectionFieldMethod::prescribed_field;
+          else if (x_compositional_field_methods[i] == "prescribed field with diffusion")
+            compositional_field_methods[i] = AdvectionFieldMethod::prescribed_field_with_diffusion;
+          else
+            AssertThrow(false,ExcNotImplemented());
+        }
+
+      // Enable Volume of Fluid field tracking if any compositional_field_methods are volume_of_fluid
+      volume_of_fluid_tracking_enabled =
+        (std::count(compositional_field_methods.begin(),compositional_field_methods.end(),AdvectionFieldMethod::volume_of_fluid)
+         > 0);
+
+      if (std::find(compositional_field_methods.begin(), compositional_field_methods.end(), AdvectionFieldMethod::fem_melt_field)
+          != compositional_field_methods.end())
+        AssertThrow (this->include_melt_transport,
+                     ExcMessage ("The advection method 'melt field' can only be selected if melt "
+                                 "transport is used in the simulation."));
+
+      const std::vector<std::string> x_mapped_particle_properties
+        = Utilities::split_string_list
+          (prm.get ("Mapped particle properties"));
+
+      const unsigned int number_of_particle_fields =
+        std::count(compositional_field_methods.begin(),compositional_field_methods.end(),AdvectionFieldMethod::particles);
+
+      AssertThrow ((x_mapped_particle_properties.size() == number_of_particle_fields)
+                   || (x_mapped_particle_properties.size() == 0),
+                   ExcMessage ("The list of names for the mapped particle property fields needs to either be empty or have a length equal to "
+                               "the number of compositional fields that are interpolated from particle properties."));
+
+      if (std::find(compositional_field_methods.begin(), compositional_field_methods.end(), AdvectionFieldMethod::fem_darcy_field)
+          != compositional_field_methods.end())
+        {
+          const unsigned int porosity_idx = std::find(names_of_compositional_fields.begin(), names_of_compositional_fields.end(), "porosity")
+                                            - names_of_compositional_fields.begin();
+          AssertThrow (porosity_idx != n_compositional_fields,
+                       ExcMessage ("The Darcy advection field method only works if there is a compositional field named 'porosity'"));
+          AssertThrow (compositional_field_methods[porosity_idx] == AdvectionFieldMethod::fem_darcy_field,
+                       ExcMessage ("When using the Darcy advection field method, the porosity field must be advected with the darcy method."));
+        }
+
+      for (const auto &p : x_mapped_particle_properties)
+        {
+          // each entry has the format (white space is optional):
+          // <name> : <value (might have spaces)> [component]
+          //
+          // first tease apart the two halves
+          const std::vector<std::string> split_parts = Utilities::split_string_list (p, ':');
+          AssertThrow (split_parts.size() == 2,
+                       ExcMessage ("The format for mapped particle properties  "
+                                   "requires that each entry has the form `"
+                                   "<name of field> : <particle property> [component]', "
+                                   "but there does not appear to be a colon in the entry <"
+                                   + p
+                                   + ">."));
+
+          // the easy part: get the name of the compositional field
+          const std::string &key = split_parts[0];
+
+          // check that the names used are actually names of fields,
+          // are solved by particles, and are unique in this list
+          std::vector<std::string>::iterator field_name_iterator = std::find(names_of_compositional_fields.begin(),
+                                                                             names_of_compositional_fields.end(), key);
+          AssertThrow (field_name_iterator
+                       != names_of_compositional_fields.end(),
+                       ExcMessage ("Name of field <" + key +
+                                   "> appears in the parameter "
+                                   "<Compositional fields/Mapped particle properties>, but "
+                                   "there is no field with this name."));
+
+          const unsigned int compositional_field_index = std::distance(names_of_compositional_fields.begin(),
+                                                                       field_name_iterator);
+
+          AssertThrow (compositional_field_methods[compositional_field_index]
+                       == AdvectionFieldMethod::particles,
+                       ExcMessage ("The field <" + key +
+                                   "> appears in the parameter <Compositional fields/Mapped particle properties>, but "
+                                   "is not advected by a particle method."));
+
+          AssertThrow (std::count(names_of_compositional_fields.begin(),
+                                  names_of_compositional_fields.end(), key) == 1,
+                       ExcMessage ("Name of field <" + key +
+                                   "> appears more than once in the parameter "
+                                   "<Compositional fields/Mapped particle properties>."));
+
+          // now for the rest. since we don't know whether there is a
+          // component selector, start reading at the end and subtract
+          // a number that might be a component selector
+          std::string particle_property = split_parts[1];
+          std::string component;
+          if ((particle_property.size()>3) &&
+              (particle_property[particle_property.size()-1] == ']'))
+            {
+              particle_property.erase (--particle_property.end());
+
+              // this handles the (rare) case of multi digit components
+              while ((particle_property[particle_property.size()-1] >= '0') &&
+                     (particle_property[particle_property.size()-1] <= '9'))
+                {
+                  component.insert(component.begin(),particle_property[particle_property.size()-1]);
+                  particle_property.erase (--particle_property.end());
+                }
+
+              AssertThrow (particle_property[particle_property.size()-1] == '[',
+                           ExcMessage("Problem in parsing a component selector from the string <"
+                                      + split_parts[1] + ">. A component selector has to be of the "
+                                      "form [x], where x must be an unsigned integer between 0 "
+                                      "and the maximum number of components of this particle property."));
+
+              particle_property.erase (--particle_property.end());
+            }
+
+          // we've stopped reading component selectors now.
+          // eat spaces that may be at the end of particle_property to get key
+          while ((particle_property.size()>0) && (particle_property[particle_property.size()-1] == ' '))
+            particle_property.erase (--particle_property.end());
+
+          // finally, put it into the list
+          mapped_particle_properties.insert(std::make_pair(compositional_field_index,
+                                                           std::make_pair(particle_property,atoi(component.c_str()))));
+        }
+
+      // Check that the names inside compositional_fields_with_disabled_boundary_entropy_viscosity
+      // are actually fields. We parse and store this value above, but only here do we know the
+      // names of the present fields.
+      for (const std::string &field_name: compositional_fields_with_disabled_boundary_entropy_viscosity)
+        {
+          AssertThrow(std::find(names_of_compositional_fields.begin(),
+                                names_of_compositional_fields.end(),
+                                field_name)
+                      != names_of_compositional_fields.end(),
+                      ExcMessage("The entry '" + field_name + "' in the parameter "
+                                 "<List of compositional fields with disabled boundary entropy viscosity> "
+                                 "is not a valid name of a compositional field "
+                                 "as specified in the <Compositional fields/Names of fields> parameter."));
+        }
+    }
+    prm.leave_subsection ();
+
+
+    // now also get the parameter related to material model averaging
+    prm.enter_subsection ("Material model");
+    {
+      material_averaging
+        = MaterialModel::MaterialAveraging::parse_averaging_operation_name
+          (prm.get ("Material averaging"));
+    }
+    prm.leave_subsection ();
+
+    // then, finally, let user additions that do not go through the usual
+    // plugin mechanism, declare their parameters if they have subscribed
+    // to the relevant signals
+    SimulatorSignals<dim>::parse_additional_parameters (*this, prm);
+
+    AssertThrow((!use_direct_stokes_solver) || (nullspace_removal == NullspaceRemoval::none),
+                ExcMessage("Because of the difference in system partitioning, nullspace removal is "
+                           "currently not compatible with the direct solver. "
+                           "Please turn off one or both of the options 'Nullspace removal/Remove nullspace', "
+                           "or 'Use direct solver for Stokes system', or contribute code to enable "
+                           "this feature combination."));
+  }
+
+
+
+  template <int dim>
+  void
+  Parameters<dim>::
+  parse_geometry_dependent_parameters(ParameterHandler &prm,
+                                      const GeometryModel::Interface<dim> &geometry_model)
+  {
+    prm.enter_subsection ("Mesh deformation");
+    {
+      // Test here for whether there are any boundary indicators active
+      // for which mesh deformation objects are to be set.
+      const std::vector<std::string> x_mesh_deformation_boundary_indicators
+        = Utilities::split_string_list(prm.get("Mesh deformation boundary indicators"),";");
+      mesh_deformation_enabled = !x_mesh_deformation_boundary_indicators.empty();
+    }
+    prm.leave_subsection();
+
+    prm.enter_subsection ("Boundary heat flux model");
+    {
+      try
+        {
+          const std::vector<types::boundary_id> x_fixed_heat_flux_boundary_indicators
+            = geometry_model.translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
+                                                                      (prm.get ("Fixed heat flux boundary indicators")));
+          fixed_heat_flux_boundary_indicators
+            = std::set<types::boundary_id> (x_fixed_heat_flux_boundary_indicators.begin(),
+                                            x_fixed_heat_flux_boundary_indicators.end());
+        }
+      catch (const std::string &error)
+        {
+          AssertThrow (false, ExcMessage ("While parsing the entry <Boundary heat flux model/Fixed heat flux "
+                                          "boundary indicators>, there was an error. Specifically, "
+                                          "the conversion function complained as follows:\n\n"
+                                          + error));
+        }
+    }
+    prm.leave_subsection ();
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::declare_parameters (ParameterHandler &prm)
+  {
+    Parameters<dim>::declare_parameters (prm);
+    Melt::Parameters<dim>::declare_parameters (prm);
+    Newton::Parameters::declare_parameters (prm);
+    StokesMatrixFreeHandler<dim>::declare_parameters (prm);
+    MeshDeformation::MeshDeformationHandler<dim>::declare_parameters (prm);
+    Postprocess::Manager<dim>::declare_parameters (prm);
+    MeshRefinement::Manager<dim>::declare_parameters (prm);
+    TimeStepping::Manager<dim>::declare_parameters (prm);
+    MaterialModel::declare_parameters<dim> (prm);
+    HeatingModel::Manager<dim>::declare_parameters (prm);
+    GeometryModel::declare_parameters <dim>(prm);
+    InitialTopographyModel::declare_parameters <dim>(prm);
+    GravityModel::declare_parameters<dim> (prm);
+    InitialTemperature::Manager<dim>::declare_parameters (prm);
+    InitialComposition::Manager<dim>::declare_parameters (prm);
+    PrescribedStokesSolution::declare_parameters<dim> (prm);
+    BoundaryTemperature::Manager<dim>::declare_parameters (prm);
+    BoundaryComposition::Manager<dim>::declare_parameters (prm);
+    AdiabaticConditions::declare_parameters<dim> (prm);
+    BoundaryVelocity::Manager<dim>::declare_parameters (prm);
+    BoundaryTraction::Manager<dim>::declare_parameters (prm);
+    BoundaryHeatFlux::declare_parameters<dim> (prm);
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template Parameters<dim>::Parameters (ParameterHandler &prm, \
+                                        const MPI_Comm mpi_communicator); \
+  template void Parameters<dim>::declare_parameters (ParameterHandler &prm); \
+  template void Parameters<dim>::parse_parameters(ParameterHandler &prm, \
+                                                  const MPI_Comm mpi_communicator); \
+  template void Parameters<dim>::parse_geometry_dependent_parameters(ParameterHandler &prm, \
+                                                                     const GeometryModel::Interface<dim> &geometry_model); \
+  template void Simulator<dim>::declare_parameters (ParameterHandler &prm);
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/simulator_access.cc.bak b/source/simulator/simulator_access.cc.bak
new file mode 100644
index 00000000000..12b4a3affeb
--- /dev/null
+++ b/source/simulator/simulator_access.cc.bak
@@ -0,0 +1,901 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/mesh_deformation/free_surface.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/particle/world.h>
+
+namespace aspect
+{
+  template <int dim>
+  SimulatorAccess<dim>::SimulatorAccess ()
+    :
+    simulator (nullptr)
+  {}
+
+
+
+  template <int dim>
+  SimulatorAccess<dim>::SimulatorAccess (const Simulator<dim> &simulator_object)
+    :
+    simulator (&simulator_object)
+  {}
+
+
+
+  template <int dim>
+  void
+  SimulatorAccess<dim>::initialize_simulator (const Simulator<dim> &simulator_object)
+  {
+    simulator = &simulator_object;
+  }
+
+
+
+  template <int dim>
+  const Simulator<dim> &
+  SimulatorAccess<dim>::get_simulator() const
+  {
+    return *simulator;
+  }
+
+
+  template <int dim>
+  const Parameters<dim> &
+  SimulatorAccess<dim>::get_parameters() const
+  {
+    return simulator->parameters;
+  }
+
+
+
+  template <int dim>
+  SimulatorSignals<dim> &
+  SimulatorAccess<dim>::get_signals() const
+  {
+    // Our reference to the Simulator is const, but we need to
+    // be able to connect to the signals so a cast is required.
+    return const_cast<SimulatorSignals<dim>&>(simulator->signals);
+  }
+
+
+
+  template <int dim>
+  const Introspection<dim> &
+  SimulatorAccess<dim>::introspection () const
+  {
+    return simulator->introspection;
+  }
+
+
+
+  template <int dim>
+  MPI_Comm
+  SimulatorAccess<dim>::get_mpi_communicator () const
+  {
+    return simulator->mpi_communicator;
+  }
+
+
+
+  template <int dim>
+  TimerOutput &
+  SimulatorAccess<dim>::get_computing_timer () const
+  {
+    return simulator->computing_timer;
+  }
+
+
+
+  template <int dim>
+  const ConditionalOStream &
+  SimulatorAccess<dim>::get_pcout () const
+  {
+    return simulator->pcout;
+  }
+
+
+
+  template <int dim>
+  double SimulatorAccess<dim>::get_time () const
+  {
+    return simulator->time;
+  }
+
+
+
+  template <int dim>
+  double SimulatorAccess<dim>::get_timestep () const
+  {
+    return simulator->time_step;
+  }
+
+
+
+  template <int dim>
+  double SimulatorAccess<dim>::get_old_timestep () const
+  {
+    return simulator->old_time_step;
+  }
+
+
+
+  template <int dim>
+  unsigned int SimulatorAccess<dim>::get_timestep_number () const
+  {
+    return simulator->timestep_number;
+  }
+
+
+
+  template <int dim>
+  const TimeStepping::Manager<dim> &
+  SimulatorAccess<dim>::get_timestepping_manager() const
+  {
+    return simulator->time_stepping_manager;
+  }
+
+
+
+  template <int dim>
+  unsigned int SimulatorAccess<dim>::get_nonlinear_iteration () const
+  {
+    return simulator->nonlinear_iteration;
+  }
+
+
+
+  template <int dim>
+  const parallel::distributed::Triangulation<dim> &
+  SimulatorAccess<dim>::get_triangulation () const
+  {
+    return simulator->triangulation;
+  }
+
+
+
+  template <int dim>
+  double
+  SimulatorAccess<dim>::get_volume () const
+  {
+    return simulator->global_volume;
+  }
+
+
+
+  template <int dim>
+  const Mapping<dim> &
+  SimulatorAccess<dim>::get_mapping () const
+  {
+    return *(simulator->mapping);
+  }
+
+
+
+  template <int dim>
+  std::string
+  SimulatorAccess<dim>::get_output_directory () const
+  {
+    return simulator->parameters.output_directory;
+  }
+
+
+
+  template <int dim>
+  bool
+  SimulatorAccess<dim>::convert_output_to_years () const
+  {
+    return simulator->parameters.convert_to_years;
+  }
+
+
+
+  template <int dim>
+  double
+  SimulatorAccess<dim>::get_end_time () const
+  {
+    return simulator->parameters.end_time;
+  }
+
+
+  template <int dim>
+  unsigned int
+  SimulatorAccess<dim>::get_pre_refinement_step () const
+  {
+    return simulator->pre_refinement_step;
+  }
+
+
+
+  template <int dim>
+  unsigned int
+  SimulatorAccess<dim>::n_compositional_fields () const
+  {
+    return simulator->introspection.n_compositional_fields;
+  }
+
+
+
+  template <int dim>
+  bool
+  SimulatorAccess<dim>::include_adiabatic_heating () const
+  {
+    return simulator->heating_model_manager.adiabatic_heating_enabled();
+  }
+
+
+
+  template <int dim>
+  bool
+  SimulatorAccess<dim>::include_latent_heat () const
+  {
+    const std::vector<std::string> &heating_models = simulator->heating_model_manager.get_active_heating_model_names();
+    return (std::find(heating_models.begin(), heating_models.end(), "latent heat") != heating_models.end());
+  }
+
+
+
+  template <int dim>
+  bool
+  SimulatorAccess<dim>::include_melt_transport () const
+  {
+    return simulator->parameters.include_melt_transport;
+  }
+
+
+
+  template <int dim>
+  int
+  SimulatorAccess<dim>::get_stokes_velocity_degree () const
+  {
+    return simulator->parameters.stokes_velocity_degree;
+  }
+
+
+
+  template <int dim>
+  double
+  SimulatorAccess<dim>::get_adiabatic_surface_temperature () const
+  {
+    return simulator->parameters.adiabatic_surface_temperature;
+  }
+
+
+
+  template <int dim>
+  double
+  SimulatorAccess<dim>::get_surface_pressure () const
+  {
+    return simulator->parameters.surface_pressure;
+  }
+
+
+
+  template <int dim>
+  void
+  SimulatorAccess<dim>::get_refinement_criteria (Vector<float> &estimated_error_per_cell) const
+  {
+    simulator->mesh_refinement_manager.execute (estimated_error_per_cell);
+  }
+
+
+
+  template <int dim>
+  void
+  SimulatorAccess<dim>::get_artificial_viscosity (Vector<float> &viscosity_per_cell,
+                                                  const bool skip_interior_cells) const
+  {
+    const typename Simulator<dim>::AdvectionField advection_field = Simulator<dim>::AdvectionField::temperature();
+    simulator->get_artificial_viscosity(viscosity_per_cell, advection_field, skip_interior_cells);
+  }
+
+
+
+  template <int dim>
+  void
+  SimulatorAccess<dim>::get_artificial_viscosity_composition (Vector<float> &viscosity_per_cell,
+                                                              const unsigned int compositional_variable) const
+  {
+    const typename Simulator<dim>::AdvectionField advection_field = Simulator<dim>::AdvectionField::composition(compositional_variable);
+    simulator->get_artificial_viscosity(viscosity_per_cell, advection_field);
+  }
+
+
+
+  template <int dim>
+  void
+  SimulatorAccess<dim>::compute_KXRCF_indicators(Vector<float> &KXRCF_indicators,
+                                                 const unsigned int field_index) const
+  {
+    const typename Simulator<dim>::AdvectionField advection_field =
+      (field_index == 0 ? Simulator<dim>::AdvectionField::temperature()
+       : Simulator<dim>::AdvectionField::composition(field_index-1));
+    simulator->compute_KXRCF_indicators(KXRCF_indicators, advection_field);
+  }
+
+
+
+  template <int dim>
+  const LinearAlgebra::BlockVector &
+  SimulatorAccess<dim>::get_current_linearization_point () const
+  {
+    return simulator->current_linearization_point;
+  }
+
+
+
+  template <int dim>
+  const LinearAlgebra::BlockVector &
+  SimulatorAccess<dim>::get_solution () const
+  {
+    return simulator->solution;
+  }
+
+
+
+  template <int dim>
+  const LinearAlgebra::BlockVector &
+  SimulatorAccess<dim>::get_old_solution () const
+  {
+    return simulator->old_solution;
+  }
+
+
+
+  template <int dim>
+  const LinearAlgebra::BlockVector &
+  SimulatorAccess<dim>::get_old_old_solution () const
+  {
+    return simulator->old_old_solution;
+  }
+
+
+
+  template <int dim>
+  const LinearAlgebra::BlockVector &
+  SimulatorAccess<dim>::get_reaction_vector () const
+  {
+    return simulator->operator_split_reaction_vector;
+  }
+
+
+
+  template <int dim>
+  const LinearAlgebra::BlockVector &
+  SimulatorAccess<dim>::get_mesh_velocity () const
+  {
+    Assert( simulator->parameters.mesh_deformation_enabled,
+            ExcMessage("You cannot get the mesh velocity if mesh deformation is not enabled."));
+    return simulator->mesh_deformation->mesh_velocity;
+  }
+
+
+
+  template <int dim>
+  const DoFHandler<dim> &
+  SimulatorAccess<dim>::get_dof_handler () const
+  {
+    return simulator->dof_handler;
+  }
+
+
+
+  template <int dim>
+  const FiniteElement<dim> &
+  SimulatorAccess<dim>::get_fe () const
+  {
+    return simulator->finite_element;
+  }
+
+
+
+  template <int dim>
+  const LinearAlgebra::BlockSparseMatrix &
+  SimulatorAccess<dim>::get_system_matrix () const
+  {
+    return simulator->system_matrix;
+  }
+
+
+
+  template <int dim>
+  const LinearAlgebra::BlockSparseMatrix &
+  SimulatorAccess<dim>::get_system_preconditioner_matrix () const
+  {
+    return simulator->system_preconditioner_matrix;
+  }
+
+
+
+  template <int dim>
+  const MaterialModel::Interface<dim> &
+  SimulatorAccess<dim>::get_material_model () const
+  {
+    Assert (simulator->material_model.get() != nullptr,
+            ExcMessage("You can not call this function if no such model is actually available."));
+    return *simulator->material_model.get();
+  }
+
+
+
+  template <int dim>
+  const BoundaryTraction::Manager<dim> &
+  SimulatorAccess<dim>::get_boundary_traction_manager () const
+  {
+    return simulator->boundary_traction_manager;
+  }
+
+
+
+  template <int dim>
+  bool
+  SimulatorAccess<dim>::has_boundary_temperature () const
+  {
+    return (get_boundary_temperature_manager().get_fixed_temperature_boundary_indicators().size() > 0);
+  }
+
+
+
+  template <int dim>
+  const BoundaryTemperature::Manager<dim> &
+  SimulatorAccess<dim>::get_boundary_temperature_manager () const
+  {
+    return simulator->boundary_temperature_manager;
+  }
+
+
+
+  template <int dim>
+  const BoundaryHeatFlux::Interface<dim> &
+  SimulatorAccess<dim>::get_boundary_heat_flux () const
+  {
+    Assert (simulator->boundary_heat_flux.get() != nullptr,
+            ExcMessage("You can not call this function if no such model is actually available."));
+    return *simulator->boundary_heat_flux.get();
+  }
+
+
+
+  template <int dim>
+  bool
+  SimulatorAccess<dim>::has_boundary_composition () const
+  {
+    return (get_boundary_composition_manager().get_fixed_composition_boundary_indicators().size() > 0);
+  }
+
+
+
+  template <int dim>
+  const BoundaryComposition::Manager<dim> &
+  SimulatorAccess<dim>::get_boundary_composition_manager () const
+  {
+    return simulator->boundary_composition_manager;
+  }
+
+
+
+  template <int dim>
+  const std::set<types::boundary_id> &
+  SimulatorAccess<dim>::get_fixed_temperature_boundary_indicators () const
+  {
+    return get_boundary_temperature_manager().get_fixed_temperature_boundary_indicators();
+  }
+
+
+
+  template <int dim>
+  const std::set<types::boundary_id> &
+  SimulatorAccess<dim>::get_fixed_heat_flux_boundary_indicators () const
+  {
+    return simulator->parameters.fixed_heat_flux_boundary_indicators;
+  }
+
+
+
+  template <int dim>
+  const std::set<types::boundary_id> &
+  SimulatorAccess<dim>::get_fixed_composition_boundary_indicators () const
+  {
+    return get_boundary_composition_manager().get_fixed_composition_boundary_indicators();
+  }
+
+
+  template <int dim>
+  const std::set<types::boundary_id> &
+  SimulatorAccess<dim>::get_mesh_deformation_boundary_indicators () const
+  {
+    Assert( simulator->parameters.mesh_deformation_enabled,
+            ExcMessage("You cannot get the mesh deformation boundary indicators if mesh deformation is not enabled."));
+    return simulator->mesh_deformation->get_active_mesh_deformation_boundary_indicators();
+  }
+
+
+
+  template <int dim>
+  const BoundaryVelocity::Manager<dim> &
+  SimulatorAccess<dim>::get_boundary_velocity_manager () const
+  {
+    return simulator->boundary_velocity_manager;
+  }
+
+
+  template <int dim>
+  const InitialTopographyModel::Interface<dim> &
+  SimulatorAccess<dim>::get_initial_topography_model () const
+  {
+    Assert (simulator->initial_topography_model.get() != nullptr,
+            ExcMessage("You can not call this function if no such model is actually available."));
+    return *simulator->initial_topography_model.get();
+  }
+
+
+  template <int dim>
+  const GeometryModel::Interface<dim> &
+  SimulatorAccess<dim>::get_geometry_model () const
+  {
+    Assert (simulator->geometry_model.get() != nullptr,
+            ExcMessage("You can not call this function if no such model is actually available."));
+    return *simulator->geometry_model.get();
+  }
+
+  template <int dim>
+  const GravityModel::Interface<dim> &
+  SimulatorAccess<dim>::get_gravity_model () const
+  {
+    Assert (simulator->gravity_model.get() != nullptr,
+            ExcMessage("You can not call this function if no such model is actually available."));
+    return *simulator->gravity_model.get();
+  }
+
+
+  template <int dim>
+  const AdiabaticConditions::Interface<dim> &
+  SimulatorAccess<dim>::get_adiabatic_conditions () const
+  {
+    Assert (simulator->adiabatic_conditions.get() != nullptr,
+            ExcMessage("You can not call this function if no such model is actually available."));
+    return *simulator->adiabatic_conditions.get();
+  }
+
+
+
+  template <int dim>
+  std::shared_ptr<const InitialTemperature::Manager<dim>>
+  SimulatorAccess<dim>::get_initial_temperature_manager_pointer () const
+  {
+    Assert (simulator->initial_temperature_manager,
+            ExcMessage ("You are trying to access the initial temperature manager "
+                        "object, but the Simulator object is no longer keeping "
+                        "track of it because the initial time has passed. If "
+                        "you need to access this object after the first time "
+                        "step, you need to copy the object returned by "
+                        "this function before or during the first time step "
+                        "into a std::shared_ptr that lives long enough to "
+                        "extend the lifetime of the object pointed to "
+                        "beyond the time frame that the Simulator object "
+                        "keeps track of it."));
+    return simulator->initial_temperature_manager;
+  }
+
+
+
+  template <int dim>
+  const InitialTemperature::Manager<dim> &
+  SimulatorAccess<dim>::get_initial_temperature_manager () const
+  {
+    Assert (simulator->initial_temperature_manager,
+            ExcMessage ("You are trying to access the initial temperature manager "
+                        "object, but the Simulator object is no longer keeping "
+                        "track of it because the initial time has passed. If "
+                        "you need to access this object after the first time "
+                        "step, you need to copy the object returned by "
+                        "this function before or during the first time step "
+                        "into a std::shared_ptr that lives long enough to "
+                        "extend the lifetime of the object pointed to "
+                        "beyond the time frame that the Simulator object "
+                        "keeps track of it."));
+    return *simulator->initial_temperature_manager;
+  }
+
+
+
+  template <int dim>
+  std::shared_ptr<const InitialComposition::Manager<dim>>
+  SimulatorAccess<dim>::get_initial_composition_manager_pointer () const
+  {
+    Assert (simulator->initial_composition_manager,
+            ExcMessage ("You are trying to access the initial composition manager "
+                        "object, but the Simulator object is no longer keeping "
+                        "track of it because the initial time has passed. If "
+                        "you need to access to this object after the first time "
+                        "step, you need to copy the object returned by "
+                        "this function before or during the first time step "
+                        "into a std::shared_ptr that lives long enough to "
+                        "extend the lifetime of the object pointed to "
+                        "beyond the timeframe that the Simulator object "
+                        "keeps track of it."));
+    return simulator->initial_composition_manager;
+  }
+
+
+
+  template <int dim>
+  const InitialComposition::Manager<dim> &
+  SimulatorAccess<dim>::get_initial_composition_manager () const
+  {
+    Assert (simulator->initial_composition_manager,
+            ExcMessage ("You are trying to access the initial composition manager "
+                        "object, but the Simulator object is no longer keeping "
+                        "track of it because the initial time has passed. If "
+                        "you need access to this object after the first time "
+                        "step, you need to copy the object returned by "
+                        "this function before or during the first time step "
+                        "into a std::shared_ptr that lives long enough to "
+                        "extend the lifetime of the object pointed to "
+                        "beyond the timeframe that the Simulator object "
+                        "keeps track of it."));
+    return *simulator->initial_composition_manager;
+  }
+
+
+
+  template <int dim>
+  const HeatingModel::Manager<dim> &
+  SimulatorAccess<dim>::get_heating_model_manager () const
+  {
+    return simulator->heating_model_manager;
+  }
+
+  template <int dim>
+  const MeshRefinement::Manager<dim> &
+  SimulatorAccess<dim>::get_mesh_refinement_manager () const
+  {
+    return simulator->mesh_refinement_manager;
+  }
+
+  template <int dim>
+  const MeltHandler<dim> &
+  SimulatorAccess<dim>::get_melt_handler () const
+  {
+    Assert (simulator->melt_handler.get() != nullptr,
+            ExcMessage("You can not call this function if melt transport is not enabled."));
+    return *(simulator->melt_handler);
+  }
+
+  template <int dim>
+  const VolumeOfFluidHandler<dim> &
+  SimulatorAccess<dim>::get_volume_of_fluid_handler () const
+  {
+    Assert (simulator->volume_of_fluid_handler.get() != nullptr,
+            ExcMessage("You can not call this function if volume of fluid interface tracking is not enabled."));
+    return *(simulator->volume_of_fluid_handler);
+  }
+
+  template <int dim>
+  const NewtonHandler<dim> &
+  SimulatorAccess<dim>::get_newton_handler () const
+  {
+    Assert (simulator->newton_handler.get() != nullptr,
+            ExcMessage("You can not call this function if the Newton solver is not enabled."));
+    return *(simulator->newton_handler);
+  }
+
+
+#ifdef ASPECT_WITH_WORLD_BUILDER
+  template <int dim>
+  const WorldBuilder::World &
+  SimulatorAccess<dim>::get_world_builder () const
+  {
+    Assert (simulator->world_builder.get() != nullptr,
+            ExcMessage ("You are trying to access the WorldBuilder "
+                        "object, but the Simulator object is not currently storing "
+                        "a valid pointer to such an object. This is likely "
+                        "because the Simulator object is no longer keeping "
+                        "track of wht WorldBuilder object because "
+                        "the initial time has passed. If "
+                        "you need to access this object after the first time "
+                        "step, you need to copy the object returned by "
+                        "this function before or during the first time step "
+                        "into a std::shared_ptr that lives long enough to "
+                        "extend the lifetime of the object pointed to "
+                        "beyond the time frame that the Simulator object "
+                        "keeps track of it."));
+    return *simulator->world_builder;
+  }
+
+
+  template <int dim>
+  std::shared_ptr<const WorldBuilder::World>
+  SimulatorAccess<dim>::get_world_builder_pointer () const
+  {
+    Assert (simulator->world_builder.get() != nullptr,
+            ExcMessage ("You are trying to access the WorldBuilder "
+                        "object, but the Simulator object is not currently storing "
+                        "a valid pointer to such an object. This is likely "
+                        "because the Simulator object is no longer keeping "
+                        "track of wht WorldBuilder object because "
+                        "the initial time has passed. If "
+                        "you need to access this object after the first time "
+                        "step, you need to copy the object returned by "
+                        "this function before or during the first time step "
+                        "into a std::shared_ptr that lives long enough to "
+                        "extend the lifetime of the object pointed to "
+                        "beyond the time frame that the Simulator object "
+                        "keeps track of it."));
+    return simulator->world_builder;
+  }
+#endif
+
+
+  template <int dim>
+  const MeshDeformation::MeshDeformationHandler<dim> &
+  SimulatorAccess<dim>::get_mesh_deformation_handler () const
+  {
+    Assert (simulator->mesh_deformation.get() != nullptr,
+            ExcMessage("You cannot call this function if mesh deformation is not enabled."));
+
+    return *(simulator->mesh_deformation);
+  }
+
+  template <int dim>
+  void
+  SimulatorAccess<dim>::get_composition_values_at_q_point (const std::vector<std::vector<double>> &composition_values,
+                                                           const unsigned int                      q,
+                                                           std::vector<double>                    &composition_values_at_q_point)
+  {
+    for (unsigned int k=0; k < composition_values_at_q_point.size(); ++k)
+      composition_values_at_q_point[k] = composition_values[k][q];
+  }
+
+
+  template <int dim>
+  TableHandler &
+  SimulatorAccess<dim>::get_statistics_object () const
+  {
+    return const_cast<TableHandler &>(simulator->statistics);
+  }
+
+  template <int dim>
+  const LateralAveraging<dim> &
+  SimulatorAccess<dim>::get_lateral_averaging() const
+  {
+    return simulator->lateral_averaging;
+  }
+
+  template <int dim>
+  const AffineConstraints<double> &
+  SimulatorAccess<dim>::get_current_constraints() const
+  {
+    return simulator->current_constraints;
+  }
+
+
+
+  template <int dim>
+  bool
+  SimulatorAccess<dim>::simulator_is_past_initialization () const
+  {
+    return ((simulator != nullptr)
+            &&
+            (simulator->simulator_is_past_initialization == true));
+  }
+
+
+  template <int dim>
+  double
+  SimulatorAccess<dim>::get_pressure_scaling () const
+  {
+    return (simulator->pressure_scaling);
+  }
+
+  template <int dim>
+  bool
+  SimulatorAccess<dim>::pressure_rhs_needs_compatibility_modification () const
+  {
+    return simulator->do_pressure_rhs_compatibility_modification;
+  }
+
+  template <int dim>
+  bool
+  SimulatorAccess<dim>::model_has_prescribed_stokes_solution () const
+  {
+    return (simulator->prescribed_stokes_solution.get() != nullptr);
+  }
+
+  template <int dim>
+  const Postprocess::Manager<dim> &
+  SimulatorAccess<dim>::get_postprocess_manager() const
+  {
+    return simulator->postprocess_manager;
+  }
+
+
+
+  template <int dim>
+  unsigned int
+  SimulatorAccess<dim>::n_particle_worlds() const
+  {
+    return simulator->particle_worlds.size();
+  }
+
+
+
+  template <int dim>
+  const Particle::World<dim> &
+  SimulatorAccess<dim>::get_particle_world(unsigned int particle_world_index) const
+  {
+    AssertThrow (particle_world_index < simulator->particle_worlds.size(), ExcInternalError());
+    return *simulator->particle_worlds[particle_world_index].get();
+  }
+
+
+
+  template <int dim>
+  Particle::World<dim> &
+  SimulatorAccess<dim>::get_particle_world(unsigned int particle_world_index)
+  {
+    AssertThrow (particle_world_index < simulator->particle_worlds.size(), ExcInternalError());
+    return *simulator->particle_worlds[particle_world_index].get();
+  }
+
+
+
+  template <int dim>
+  bool SimulatorAccess<dim>::is_stokes_matrix_free()
+  {
+    return (simulator->stokes_matrix_free ? true : false);
+  }
+
+
+
+  template <int dim>
+  const StokesMatrixFreeHandler<dim> &
+  SimulatorAccess<dim>::get_stokes_matrix_free () const
+  {
+    Assert (simulator->stokes_matrix_free.get() != nullptr,
+            ExcMessage("You can not call this function if the matrix-free Stokes solver is not used."));
+    return *(simulator->stokes_matrix_free);
+  }
+
+
+
+  template <int dim>
+  RotationProperties<dim>
+  SimulatorAccess<dim>::compute_net_angular_momentum(const bool use_constant_density,
+                                                     const LinearAlgebra::BlockVector &solution,
+                                                     const bool limit_to_top_faces) const
+  {
+    return simulator->compute_net_angular_momentum(use_constant_density, solution, limit_to_top_faces);
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template class SimulatorAccess<dim>;
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/simulator_signals.cc.bak b/source/simulator/simulator_signals.cc.bak
new file mode 100644
index 00000000000..67a77f953c7
--- /dev/null
+++ b/source/simulator/simulator_signals.cc.bak
@@ -0,0 +1,102 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator_signals.h>
+
+#include <list>
+
+
+namespace aspect
+{
+  // provide locations for the static variables of this class
+  template <int dim>
+  boost::signals2::signal<void (const unsigned int,
+                                ParameterHandler &)>  SimulatorSignals<dim>::declare_additional_parameters;
+
+  template <int dim>
+  boost::signals2::signal<void (const Parameters<dim> &,
+                                ParameterHandler &)>  SimulatorSignals<dim>::parse_additional_parameters;
+
+
+  namespace internals
+  {
+    namespace SimulatorSignals
+    {
+      std::list<std::function<void (aspect::SimulatorSignals<2> &)>> connector_functions_2d;
+      std::list<std::function<void (aspect::SimulatorSignals<3> &)>> connector_functions_3d;
+
+      static bool connector_functions_have_been_called = false;
+
+      // add a user-provided connector to the list of connectors we keep
+      void register_connector_function_2d (const std::function<void (aspect::SimulatorSignals<2> &)> &connector)
+      {
+        Assert(!connector_functions_have_been_called,
+               ExcMessage("Registration of signal connector happened after connection has already been called!"));
+        connector_functions_2d.push_back (connector);
+      }
+
+      void register_connector_function_3d (const std::function<void (aspect::SimulatorSignals<3> &)> &connector)
+      {
+        Assert(!connector_functions_have_been_called,
+               ExcMessage("Registration of signal connector happened after connection has already been called!"));
+        connector_functions_3d.push_back (connector);
+      }
+
+
+      // call connectors to ensure that plugins get a change to register their slots
+      template <>
+      void call_connector_functions (aspect::SimulatorSignals<2> &signals)
+      {
+        Assert(!connector_functions_have_been_called,
+               ExcInternalError());
+
+        for (const auto &p : connector_functions_2d)
+          p(signals);
+
+        connector_functions_have_been_called = true;
+      }
+
+      template <>
+      void call_connector_functions (aspect::SimulatorSignals<3> &signals)
+      {
+        Assert(!connector_functions_have_been_called,
+               ExcInternalError());
+
+        for (const auto &p : connector_functions_3d)
+          p(signals);
+
+        connector_functions_have_been_called = true;
+      }
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template struct SimulatorSignals<dim>;
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/solver.cc.bak b/source/simulator/solver.cc.bak
new file mode 100644
index 00000000000..c91409716bb
--- /dev/null
+++ b/source/simulator/solver.cc.bak
@@ -0,0 +1,1270 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+#include <aspect/stokes_matrix_free.h>
+#include <aspect/mesh_deformation/interface.h>
+
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/lac/solver_gmres.h>
+#include <deal.II/lac/solver_bicgstab.h>
+#include <deal.II/lac/solver_cg.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace internal
+  {
+    /**
+     * Implement multiplication with Stokes part of system matrix. In essence, this
+     * object represents a 2x2 block matrix that corresponds to the top left
+     * sub-blocks of the entire system matrix (i.e., the Stokes part)
+     */
+    class StokesBlock
+    {
+      public:
+        /**
+         * @brief Constructor
+         *
+         * @param S The entire system matrix
+         */
+        StokesBlock (const LinearAlgebra::BlockSparseMatrix  &S)
+          : system_matrix(S) {}
+
+        /**
+         * Matrix vector product with Stokes block.
+         */
+        void vmult (LinearAlgebra::BlockVector       &dst,
+                    const LinearAlgebra::BlockVector &src) const;
+
+        void Tvmult (LinearAlgebra::BlockVector       &dst,
+                     const LinearAlgebra::BlockVector &src) const;
+
+        void vmult_add (LinearAlgebra::BlockVector       &dst,
+                        const LinearAlgebra::BlockVector &src) const;
+
+        void Tvmult_add (LinearAlgebra::BlockVector       &dst,
+                         const LinearAlgebra::BlockVector &src) const;
+
+        /**
+         * Compute the residual with the Stokes block. In a departure from
+         * the other functions, the #b variable may actually have more than
+         * two blocks so that we can put it a global system_rhs vector. The
+         * other vectors need to have 2 blocks only.
+         */
+        double residual (LinearAlgebra::BlockVector       &dst,
+                         const LinearAlgebra::BlockVector &x,
+                         const LinearAlgebra::BlockVector &b) const;
+
+
+      private:
+
+        /**
+         * Reference to the system matrix object.
+         */
+        const LinearAlgebra::BlockSparseMatrix &system_matrix;
+    };
+
+
+
+    void StokesBlock::vmult (LinearAlgebra::BlockVector       &dst,
+                             const LinearAlgebra::BlockVector &src) const
+    {
+      Assert (src.n_blocks() == 2, ExcInternalError());
+      Assert (dst.n_blocks() == 2, ExcInternalError());
+
+      system_matrix.block(0,0).vmult(dst.block(0), src.block(0));
+      system_matrix.block(0,1).vmult_add(dst.block(0), src.block(1));
+
+      system_matrix.block(1,0).vmult(dst.block(1), src.block(0));
+      system_matrix.block(1,1).vmult_add(dst.block(1), src.block(1));
+    }
+
+
+    void StokesBlock::Tvmult (LinearAlgebra::BlockVector       &dst,
+                              const LinearAlgebra::BlockVector &src) const
+    {
+      Assert (src.n_blocks() == 2, ExcInternalError());
+      Assert (dst.n_blocks() == 2, ExcInternalError());
+
+      system_matrix.block(0,0).Tvmult(dst.block(0), src.block(0));
+      system_matrix.block(1,0).Tvmult_add(dst.block(0), src.block(1));
+
+      system_matrix.block(0,1).Tvmult(dst.block(1), src.block(0));
+      system_matrix.block(1,1).Tvmult_add(dst.block(1), src.block(1));
+    }
+
+
+    void StokesBlock::vmult_add (LinearAlgebra::BlockVector       &dst,
+                                 const LinearAlgebra::BlockVector &src) const
+    {
+      Assert (src.n_blocks() == 2, ExcInternalError());
+      Assert (dst.n_blocks() == 2, ExcInternalError());
+
+      system_matrix.block(0,0).vmult_add(dst.block(0), src.block(0));
+      system_matrix.block(0,1).vmult_add(dst.block(0), src.block(1));
+
+      system_matrix.block(1,0).vmult_add(dst.block(1), src.block(0));
+      system_matrix.block(1,1).vmult_add(dst.block(1), src.block(1));
+    }
+
+
+    void StokesBlock::Tvmult_add (LinearAlgebra::BlockVector       &dst,
+                                  const LinearAlgebra::BlockVector &src) const
+    {
+      Assert (src.n_blocks() == 2, ExcInternalError());
+      Assert (dst.n_blocks() == 2, ExcInternalError());
+
+      system_matrix.block(0,0).Tvmult_add(dst.block(0), src.block(0));
+      system_matrix.block(1,0).Tvmult_add(dst.block(0), src.block(1));
+
+      system_matrix.block(0,1).Tvmult_add(dst.block(1), src.block(0));
+      system_matrix.block(1,1).Tvmult_add(dst.block(1), src.block(1));
+    }
+
+
+
+    double StokesBlock::residual (LinearAlgebra::BlockVector       &dst,
+                                  const LinearAlgebra::BlockVector &x,
+                                  const LinearAlgebra::BlockVector &b) const
+    {
+      Assert (x.n_blocks() == 2, ExcInternalError());
+      Assert (dst.n_blocks() == 2, ExcInternalError());
+
+      // compute b-Ax where A is only the top left 2x2 block
+      this->vmult (dst, x);
+      dst.block(0).sadd (-1, 1, b.block(0));
+      dst.block(1).sadd (-1, 1, b.block(1));
+
+      // clear blocks we didn't want to fill
+      for (unsigned int block=2; block<dst.n_blocks(); ++block)
+        dst.block(block) = 0;
+
+      return dst.l2_norm();
+    }
+
+
+    /**
+     * Implement the block Schur preconditioner for the Stokes system.
+     */
+    template <class AInvOperator, class SInvOperator>
+    class BlockSchurPreconditioner : public Subscriptor
+    {
+      public:
+        /**
+         * @brief Constructor
+         *
+         * @param S The entire Stokes matrix
+         * @param Spre The matrix whose blocks are used in the definition of
+         *     the preconditioning of the Stokes matrix, i.e. containing approximations
+         *     of the A and S blocks.
+         * @param S_inverse_operator Approximation for the inverse Schur complement,
+         * can be chosen as the mass matrix.
+         * @param A_inv_operator Preconditioner object for the matrix A.
+         **/
+        BlockSchurPreconditioner (const LinearAlgebra::BlockSparseMatrix     &S,
+                                  const LinearAlgebra::BlockSparseMatrix     &Spre,
+                                  const SInvOperator                         &S_inverse_operator,
+                                  const AInvOperator                         &A_inv_operator);
+
+        /**
+         * Matrix vector product with this preconditioner object.
+         */
+        void vmult (LinearAlgebra::BlockVector       &dst,
+                    const LinearAlgebra::BlockVector &src) const;
+
+      private:
+        /**
+         * References to the various matrix object this preconditioner works on.
+         */
+        const LinearAlgebra::BlockSparseMatrix &stokes_matrix;
+        const LinearAlgebra::BlockSparseMatrix &stokes_preconditioner_matrix;
+        const SInvOperator                     &S_inv_operator;
+        const AInvOperator                     &A_inv_operator;
+    };
+
+
+    template <class AInvOperator, class SInvOperator>
+    BlockSchurPreconditioner<AInvOperator, SInvOperator>::
+    BlockSchurPreconditioner (const LinearAlgebra::BlockSparseMatrix     &S,
+                              const LinearAlgebra::BlockSparseMatrix     &Spre,
+                              const SInvOperator                         &S_inv_operator,
+                              const AInvOperator                         &A_inv_operator)
+      :
+      stokes_matrix (S),
+      stokes_preconditioner_matrix (Spre),
+      S_inv_operator (S_inv_operator),
+      A_inv_operator (A_inv_operator)
+    {}
+
+
+
+    template <class AInvOperator, class SInvOperator>
+    void
+    BlockSchurPreconditioner<AInvOperator, SInvOperator>::
+    vmult (LinearAlgebra::BlockVector       &dst,
+           const LinearAlgebra::BlockVector &src) const
+    {
+      LinearAlgebra::Vector utmp(src.block(0));
+
+      // first solve with the bottom right block, which we have built
+      // as a mass matrix with the inverse of the viscosity
+      {
+        S_inv_operator.vmult(dst.block(1),src.block(1));
+        dst.block(1) *= -1.0;
+      }
+
+      // apply the top right block
+      {
+        stokes_matrix.block(0,1).vmult(utmp, dst.block(1)); // B^T or J^{up}
+        utmp *= -1.0;
+        utmp += src.block(0);
+      }
+
+      A_inv_operator.vmult(dst.block(0), utmp);
+    }
+
+
+    /**
+      * This class is used in the implementation of the right preconditioner
+      * as an approximation for the inverse of the velocity (A) block.
+      * This operator can either just apply the preconditioner (AMG)
+      * or perform an inner CG solve with the same preconditioner.
+      */
+    template <class PreconditionerA>
+    class InverseVelocityBlock
+    {
+      public:
+        /**
+         * Constructor.
+         * @param matrix The matrix that contains A (from the system matrix)
+         * @param preconditioner The preconditioner to be used
+         * @param do_solve_A A flag indicating whether we should actually solve with
+         *     the matrix $A$, or only apply one preconditioner step with it.
+         * @param A_block_is_symmetric A flag indicating whether the matrix $A$ is symmetric.
+         * @param A_block_tolerance The tolerance for the CG solver which computes
+         *     the inverse of the A block.
+        */
+        InverseVelocityBlock(const TrilinosWrappers::SparseMatrix &matrix,
+                             const PreconditionerA &preconditioner,
+                             const bool do_solve_A,
+                             const bool A_block_is_symmetric,
+                             const double solver_tolerance);
+
+        void vmult(TrilinosWrappers::MPI::Vector &dst,
+                   const TrilinosWrappers::MPI::Vector &src) const;
+
+        unsigned int n_iterations() const;
+
+      private:
+        mutable unsigned int n_iterations_;
+        const TrilinosWrappers::SparseMatrix &matrix;
+        const PreconditionerA &preconditioner;
+        const bool do_solve_A;
+        const bool A_block_is_symmetric;
+        const double solver_tolerance;
+    };
+
+
+
+    template <class PreconditionerA>
+    InverseVelocityBlock<PreconditionerA>::InverseVelocityBlock(
+      const TrilinosWrappers::SparseMatrix &matrix,
+      const PreconditionerA &preconditioner,
+      const bool do_solve_A,
+      const bool A_block_is_symmetric,
+      const double solver_tolerance)
+      : n_iterations_ (0),
+        matrix (matrix),
+        preconditioner (preconditioner),
+        do_solve_A (do_solve_A),
+        A_block_is_symmetric (A_block_is_symmetric),
+        solver_tolerance (solver_tolerance)
+    {}
+
+
+
+    template <class PreconditionerA>
+    void InverseVelocityBlock<PreconditionerA>::vmult(TrilinosWrappers::MPI::Vector &dst,
+                                                      const TrilinosWrappers::MPI::Vector &src) const
+    {
+      // Either solve with the top left block
+      // or just apply one preconditioner sweep (for the first few
+      // iterations of our two-stage outer GMRES iteration)
+      if (do_solve_A == true)
+        {
+          SolverControl solver_control(10000, src.l2_norm() * solver_tolerance);
+          PrimitiveVectorMemory<LinearAlgebra::Vector> mem;
+
+          try
+            {
+              dst = 0.0;
+
+              if (A_block_is_symmetric)
+                {
+                  SolverCG<LinearAlgebra::Vector> solver(solver_control, mem);
+                  solver.solve(matrix, dst, src, preconditioner);
+                }
+              else
+                {
+                  // Use BiCGStab for non-symmetric matrices.
+                  // BiCGStab can also solve indefinite systems if necessary.
+                  // Do not compute the exact residual, as this
+                  // is more expensive, and we only need an approximate solution.
+                  SolverBicgstab<LinearAlgebra::Vector>
+                  solver(solver_control,
+                         mem,
+                         SolverBicgstab<LinearAlgebra::Vector>::AdditionalData(/*exact_residual=*/ false));
+                  solver.solve(matrix, dst, src, preconditioner);
+                }
+              n_iterations_ += solver_control.last_step();
+            }
+          catch (const std::exception &exc)
+            {
+              // if the solver fails, report the error from processor 0 with some additional
+              // information about its location, and throw a quiet exception on all other
+              // processors
+              Utilities::throw_linear_solver_failure_exception("iterative (top left) solver",
+                                                               "BlockSchurPreconditioner::vmult",
+                                                               std::vector<SolverControl> {solver_control},
+                                                               exc,
+                                                               src.get_mpi_communicator());
+            }
+        }
+      else
+        {
+          preconditioner.vmult (dst, src);
+          n_iterations_ += 1;
+        }
+    }
+
+
+
+    template <class PreconditionerA>
+    unsigned int InverseVelocityBlock<PreconditionerA>::n_iterations() const
+    {
+      return n_iterations_;
+    }
+
+    /**
+     * Base class for Schur Complement operators.
+    */
+    class SchurComplementOperator
+    {
+      public:
+        virtual void vmult(TrilinosWrappers::MPI::Vector &dst,
+                           const TrilinosWrappers::MPI::Vector &src) const=0;
+        virtual unsigned int n_iterations() const=0;
+
+    };
+
+    /**
+     * This class approximates the Schur Complement inverse operator
+     * by S^{-1} = (BC^{-1}B^T)^{-1}(BC^{-1}AD^{-1}B^T)(BD^{-1}B^T)^{-1},
+     * which is known as the weighted BFBT method. Here,
+     * C^{-1} and D^{-1} are chosen to be the inverse weighted lumped
+     * velocity mass matrix.
+    */
+    template <class PreconditionerMp>
+    class WeightedBFBT: public SchurComplementOperator
+    {
+      public:
+        /**
+         * Constructor.
+         * @param mp_matrix Matrix approximating S to be used in the inner solve
+         * @param mp_preconditioner The preconditioner for @p mp_matrix
+         * @param solver_tolerance The relative solver tolerance for the inner solve
+         * @param inverse_lumped_mass_matrix Lumped mass matrix associated with the velocity block
+         * @param system_matrix Sparse block matrix storing the Stokes system of the form
+         * [A B^T
+         *  B 0].
+         */
+        WeightedBFBT(const TrilinosWrappers::SparseMatrix &mp_matrix,
+                     const PreconditionerMp &mp_preconditioner,
+                     const double solver_tolerance,
+                     const TrilinosWrappers::MPI::Vector &inverse_lumped_mass_matrix,
+                     const TrilinosWrappers::BlockSparseMatrix &system_matrix);
+
+        void vmult(TrilinosWrappers::MPI::Vector &dst,
+                   const TrilinosWrappers::MPI::Vector &src) const override;
+
+        unsigned int n_iterations() const override;
+
+      private:
+        mutable unsigned int n_iterations_;
+        const TrilinosWrappers::SparseMatrix &mp_matrix;
+        const PreconditionerMp &mp_preconditioner;
+        const double solver_tolerance;
+        const TrilinosWrappers::MPI::Vector  &inverse_lumped_mass_matrix;
+        const TrilinosWrappers::BlockSparseMatrix &system_matrix;
+    };
+
+    template <class PreconditionerMp>
+    WeightedBFBT<PreconditionerMp>::WeightedBFBT(
+      const TrilinosWrappers::SparseMatrix &mp_matrix,
+      const PreconditionerMp &mp_preconditioner,
+      const double solver_tolerance,
+      const TrilinosWrappers::MPI::Vector &inverse_lumped_mass_matrix,
+      const TrilinosWrappers::BlockSparseMatrix &system_matrix)
+      : n_iterations_ (0),
+        mp_matrix (mp_matrix),
+        mp_preconditioner (mp_preconditioner),
+        solver_tolerance (solver_tolerance),
+        inverse_lumped_mass_matrix(inverse_lumped_mass_matrix),
+        system_matrix (system_matrix)
+    {}
+
+
+    template <class PreconditionerMp>
+    void WeightedBFBT<PreconditionerMp>::vmult(TrilinosWrappers::MPI::Vector &dst,
+                                               const TrilinosWrappers::MPI::Vector &src) const
+    {
+      SolverControl solver_control(1000, src.l2_norm() * solver_tolerance);
+      PrimitiveVectorMemory<LinearAlgebra::Vector> mem;
+      SolverCG<LinearAlgebra::Vector> solver(solver_control, mem);
+
+      try
+        {
+          TrilinosWrappers::MPI::Vector utmp;
+          utmp.reinit(inverse_lumped_mass_matrix);
+          TrilinosWrappers::MPI::Vector ptmp;
+          ptmp.reinit(src);
+          TrilinosWrappers::MPI::Vector wtmp;
+          wtmp.reinit(inverse_lumped_mass_matrix);
+          {
+            SolverControl solver_control(5000, 1e-6 * src.l2_norm(), false, true);
+            SolverCG<TrilinosWrappers::MPI::Vector> solver(solver_control);
+            //Solve with Schur Complement approximation
+            solver.solve(mp_matrix,
+                         ptmp,
+                         src,
+                         mp_preconditioner);
+            n_iterations_ += solver_control.last_step();
+            system_matrix.block(0,1).vmult(utmp,ptmp);
+
+            utmp.scale(inverse_lumped_mass_matrix);
+            system_matrix.block(0,0).vmult(wtmp,utmp);
+            wtmp.scale(inverse_lumped_mass_matrix);
+            system_matrix.block(1,0).vmult(ptmp,wtmp);
+
+            dst=0;
+            solver.solve(mp_matrix,
+                         dst,
+                         ptmp,
+                         mp_preconditioner);
+            n_iterations_ += solver_control.last_step();
+          }
+        }
+      // if the solver fails, report the error from processor 0 with some additional
+      // information about its location, and throw a quiet exception on all other
+      // processors
+      catch (const std::exception &exc)
+        {
+          Utilities::throw_linear_solver_failure_exception("iterative (bottom right) solver",
+                                                           "BlockSchurPreconditioner::vmult",
+                                                           std::vector<SolverControl> {solver_control},
+                                                           exc,
+                                                           src.get_mpi_communicator());
+        }
+    }
+
+
+
+    template <class PreconditionerMp>
+    unsigned int WeightedBFBT<PreconditionerMp>::n_iterations() const
+    {
+      return n_iterations_;
+    }
+
+
+
+    /**
+      * This class is used in the implementation of the right preconditioner.
+      * Here, the Schur complement is approximated by
+      * the pressure mass matrix weighted by the inverse of viscosity and
+      * the inverse is computed with a CG solve preconditioned by
+      * PreconditionerMp passed to the constructor.
+      */
+    template <class PreconditionerMp>
+    class InverseWeightedMassMatrix: public SchurComplementOperator
+    {
+      public:
+        /**
+         * Constructor.
+         * @param mp_matrix Matrix approximating S to be used in the inner solve
+         * @param mp_preconditioner The preconditioner for @p mp_matrix
+         * @param solver_tolerance The relative solver tolerance for the inner solve
+         */
+        InverseWeightedMassMatrix(const TrilinosWrappers::SparseMatrix &mp_matrix,
+                                  const PreconditionerMp &mp_preconditioner,
+                                  const double solver_tolerance);
+
+        void vmult(TrilinosWrappers::MPI::Vector &dst,
+                   const TrilinosWrappers::MPI::Vector &src) const override;
+
+        unsigned int n_iterations() const override;
+
+      private:
+        mutable unsigned int n_iterations_;
+        const TrilinosWrappers::SparseMatrix &mp_matrix;
+        const PreconditionerMp &mp_preconditioner;
+        const double solver_tolerance;
+    };
+
+
+
+    template <class PreconditionerMp>
+    InverseWeightedMassMatrix<PreconditionerMp>::InverseWeightedMassMatrix(
+      const TrilinosWrappers::SparseMatrix &mp_matrix,
+      const PreconditionerMp &mp_preconditioner,
+      const double solver_tolerance)
+      : n_iterations_ (0),
+        mp_matrix (mp_matrix),
+        mp_preconditioner (mp_preconditioner),
+        solver_tolerance (solver_tolerance)
+    {}
+
+
+
+    template <class PreconditionerMp>
+    void InverseWeightedMassMatrix<PreconditionerMp>::vmult(TrilinosWrappers::MPI::Vector &dst,
+                                                            const TrilinosWrappers::MPI::Vector &src) const
+    {
+      // Trilinos reports a breakdown in case src=dst=0, even though it should return
+      // convergence without iterating. We simply skip solving in this case.
+      if (src.l2_norm() > 1e-50)
+        {
+          SolverControl solver_control(1000, src.l2_norm() * solver_tolerance);
+          PrimitiveVectorMemory<LinearAlgebra::Vector> mem;
+          SolverCG<LinearAlgebra::Vector> solver(solver_control, mem);
+          try
+            {
+              dst = 0.0;
+              solver.solve(mp_matrix,
+                           dst,
+                           src,
+                           mp_preconditioner);
+              n_iterations_ += solver_control.last_step();
+            }
+          // if the solver fails, report the error from processor 0 with some additional
+          // information about its location, and throw a quiet exception on all other
+          // processors
+          catch (const std::exception &exc)
+            {
+              Utilities::throw_linear_solver_failure_exception("iterative (bottom right) solver",
+                                                               "BlockSchurPreconditioner::vmult",
+                                                               std::vector<SolverControl> {solver_control},
+                                                               exc,
+                                                               src.get_mpi_communicator());
+            }
+        }
+    }
+
+
+
+    template <class PreconditionerMp>
+    unsigned int InverseWeightedMassMatrix<PreconditionerMp>::n_iterations() const
+    {
+      return n_iterations_;
+    }
+
+  }
+
+
+
+  template <int dim>
+  double Simulator<dim>::solve_advection (const AdvectionField &advection_field)
+  {
+    const unsigned int block_idx = advection_field.block_index(introspection);
+
+    std::string field_name = (advection_field.is_temperature()
+                              ?
+                              "temperature"
+                              :
+                              introspection.name_for_compositional_index(advection_field.compositional_variable) + " composition");
+
+    const double advection_solver_tolerance = (advection_field.is_temperature()) ? (parameters.temperature_solver_tolerance) : (parameters.composition_solver_tolerance);
+
+    const double tolerance = std::max(1e-50,
+                                      advection_solver_tolerance*system_rhs.block(block_idx).l2_norm());
+
+    SolverControl solver_control (1000, tolerance);
+
+    solver_control.enable_history_data();
+
+    SolverGMRES<LinearAlgebra::Vector>   solver (solver_control,
+                                                 SolverGMRES<LinearAlgebra::Vector>::AdditionalData(parameters.advection_gmres_restart_length,true));
+
+    // check if matrix and/or RHS are zero
+    // note: to avoid a warning, we compare against numeric_limits<double>::min() instead of 0 here
+    if (system_rhs.block(block_idx).l2_norm() <= std::numeric_limits<double>::min())
+      {
+        pcout << "   Skipping " + field_name + " solve because RHS is zero." << std::endl;
+        solution.block(block_idx) = 0;
+
+        // signal successful solver and signal residual of zero
+        solver_control.check(0, 0.0);
+        signals.post_advection_solver(*this,
+                                      advection_field.is_temperature(),
+                                      advection_field.compositional_variable,
+                                      solver_control);
+
+        return 0;
+      }
+
+    AssertThrow(system_matrix.block(block_idx,
+                                    block_idx).linfty_norm() > std::numeric_limits<double>::min(),
+                ExcMessage ("The " + field_name + " equation can not be solved, because the matrix is zero, "
+                            "but the right-hand side is nonzero."));
+
+    LinearAlgebra::PreconditionILU preconditioner;
+    // first build without diagonal strengthening:
+    build_advection_preconditioner(advection_field, preconditioner, 0.);
+
+    TimerOutput::Scope timer (computing_timer, (advection_field.is_temperature() ?
+                                                "Solve temperature system" :
+                                                "Solve composition system"));
+    if (advection_field.is_temperature())
+      {
+        pcout << "   Solving temperature system... " << std::flush;
+      }
+    else
+      {
+        pcout << "   Solving "
+              << introspection.name_for_compositional_index(advection_field.compositional_variable)
+              << " system "
+              << "... " << std::flush;
+      }
+
+    // Create distributed vector (we need all blocks here even though we only
+    // solve for the current block) because only have a AffineConstraints<double>
+    // for the whole system, current_linearization_point contains our initial guess.
+    LinearAlgebra::BlockVector distributed_solution (
+      introspection.index_sets.system_partitioning,
+      mpi_communicator);
+    distributed_solution.block(block_idx) = current_linearization_point.block (block_idx);
+
+    // Temporary vector to hold the residual, we don't need a BlockVector here.
+    LinearAlgebra::Vector temp (
+      introspection.index_sets.system_partitioning[block_idx],
+      mpi_communicator);
+
+    current_constraints.set_zero(distributed_solution);
+
+    // Compute the residual before we solve and return this at the end.
+    // This is used in the nonlinear solver.
+    const double initial_residual = system_matrix.block(block_idx,block_idx).residual
+                                    (temp,
+                                     distributed_solution.block(block_idx),
+                                     system_rhs.block(block_idx));
+
+    // solve the linear system:
+    try
+      {
+        try
+          {
+            solver.solve (system_matrix.block(block_idx,block_idx),
+                          distributed_solution.block(block_idx),
+                          system_rhs.block(block_idx),
+                          preconditioner);
+          }
+        catch (const std::exception &exc)
+          {
+            // Try rebuilding the preconditioner with diagonal strengthening. In general,
+            // this increases the number of iterations needed, but helps in rare situations,
+            // especially when SUPG is used.
+            pcout << "retrying linear solve with different preconditioner..." << std::endl;
+            build_advection_preconditioner(advection_field, preconditioner, 1e-5);
+            solver.solve (system_matrix.block(block_idx,block_idx),
+                          distributed_solution.block(block_idx),
+                          system_rhs.block(block_idx),
+                          preconditioner);
+          }
+
+      }
+    // if the solver fails, report the error from processor 0 with some additional
+    // information about its location, and throw a quiet exception on all other
+    // processors
+    catch (const std::exception &exc)
+      {
+        // signal unsuccessful solver
+        signals.post_advection_solver(*this,
+                                      advection_field.is_temperature(),
+                                      advection_field.compositional_variable,
+                                      solver_control);
+
+
+        Utilities::throw_linear_solver_failure_exception("iterative advection solver",
+                                                         "Simulator::solve_advection",
+                                                         std::vector<SolverControl> {solver_control},
+                                                         exc,
+                                                         mpi_communicator,
+                                                         parameters.output_directory+"solver_history.txt");
+      }
+
+    // signal successful solver
+    signals.post_advection_solver(*this,
+                                  advection_field.is_temperature(),
+                                  advection_field.compositional_variable,
+                                  solver_control);
+
+    current_constraints.distribute (distributed_solution);
+    solution.block(block_idx) = distributed_solution.block(block_idx);
+
+    // print number of iterations and also record it in the
+    // statistics file
+    pcout << solver_control.last_step()
+          << " iterations." << std::endl;
+
+    if (advection_field.is_discontinuous(introspection))
+      {
+        const typename Parameters<dim>::DGLimiterType::Kind
+        limiter = (advection_field.is_temperature() ?
+                   parameters.limiter_for_discontinuous_temperature_solution :
+                   parameters.limiter_for_discontinuous_composition_solution[advection_field.compositional_variable]);
+
+        switch (limiter)
+          {
+            case Parameters<dim>::DGLimiterType::bound_preserving:
+              apply_BP_limiter_to_dg_solutions(advection_field);
+              break;
+            case Parameters<dim>::DGLimiterType::WENO:
+              apply_WENO_limiter_to_dg_solutions(advection_field);
+              break;
+            case Parameters<dim>::DGLimiterType::none:
+              break;
+            default:
+              AssertThrow(false, ExcNotImplemented());
+          }
+
+        if (limiter != Parameters<dim>::DGLimiterType::none)
+          // by applying the limiter we have modified the solution to no longer
+          // satisfy the equation. Therefore the residual is meaningless and cannot
+          // converge to zero in nonlinear iterations. Disable residual computation
+          // for this field.
+          return 0.0;
+        else
+          return initial_residual;
+      }
+
+    return initial_residual;
+  }
+
+
+
+  template <int dim>
+  std::pair<double,double>
+  Simulator<dim>::solve_stokes ()
+  {
+    TimerOutput::Scope timer (computing_timer, "Solve Stokes system");
+    pcout << "   Solving Stokes system... " << std::flush;
+
+    if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
+      {
+        return stokes_matrix_free->solve();
+      }
+
+    // In the following, we will operate on a vector that contains only
+    // the velocity and pressure DoFs, rather than on the full
+    // system. Set such a reduced vector up, without any ghost elements.
+    // (Worth noting: for direct solvers, this vector has one block,
+    // whereas for the iterative solvers, the result has two blocks.)
+    LinearAlgebra::BlockVector distributed_stokes_solution (introspection.index_sets.stokes_partitioning,
+                                                            mpi_communicator);
+
+    // Create a view of all constraints that only pertains to the
+    // Stokes subset of degrees of freedom. We can then use this later
+    // to call constraints.distribute(), constraints.set_zero(), etc.,
+    // on those block vectors that only have the Stokes components in
+    // them.
+    //
+    // For the moment, assume that the Stokes degrees are first in the
+    // overall vector, so that they form a contiguous range starting
+    // at zero. The assertion checks this, but this could easily be
+    // generalized if the Stokes block were not starting at zero.
+#if DEAL_II_VERSION_GTE(9,6,0)
+    {
+      const unsigned int block_vel = introspection.block_indices.velocities;
+      (void) block_vel;
+
+      Assert (block_vel == 0, ExcNotImplemented());
+      if (parameters.use_direct_stokes_solver == false)
+        {
+          const unsigned int block_p = (parameters.include_melt_transport) ?
+                                       introspection.variable("fluid pressure").block_index
+                                       : introspection.block_indices.pressure;
+          (void) block_p;
+          Assert (block_p == 1, ExcNotImplemented());
+        }
+    }
+
+    IndexSet stokes_dofs (dof_handler.n_dofs());
+    stokes_dofs.add_range (0, distributed_stokes_solution.size());
+    const AffineConstraints<double> current_stokes_constraints
+      = current_constraints.get_view (stokes_dofs);
+#else
+    const AffineConstraints<double> &current_stokes_constraints = current_constraints;
+#endif
+
+    double initial_nonlinear_residual = numbers::signaling_nan<double>();
+    double final_linear_residual      = numbers::signaling_nan<double>();
+
+    if (parameters.use_direct_stokes_solver)
+      {
+        Assert (distributed_stokes_solution.n_blocks() == 1, ExcInternalError());
+
+        // Many parts of the solver depend on the block layout (typically,
+        // velocity = 0, pressure = 1, but differently for direct solver
+        // setups -- see the comment above).
+        const unsigned int block_vel_and_pres = introspection.block_indices.velocities;
+        Assert(block_vel_and_pres == 0, ExcNotImplemented());
+
+        // We hard-code the blocks down below, so make sure block 0 is indeed
+        // the block containing velocity and pressure:
+        Assert(introspection.block_indices.velocities == 0, ExcNotImplemented());
+        Assert(introspection.block_indices.pressure == 0
+               ||
+               (parameters.include_melt_transport
+                && introspection.variable("fluid pressure").block_index == 0
+                && introspection.variable("compaction pressure").block_index == 0),
+               ExcNotImplemented());
+
+        // Start with a reasonable guess.
+        //
+        // While we don't need to set up the initial guess for the direct solver
+        // (it will be ignored by the solver anyway), we need this if we are
+        // using a nonlinear scheme, because we use this to compute the current
+        // nonlinear residual (see initial_residual below).
+        solution.block(block_vel_and_pres) = current_linearization_point.block(block_vel_and_pres);
+
+        // TODO: if there was an easy way to know if the caller needs the
+        // initial residual we could skip all of this stuff.
+        distributed_stokes_solution.block(0) = solution.block(block_vel_and_pres);
+        denormalize_pressure (this->last_pressure_normalization_adjustment,
+                              distributed_stokes_solution,
+                              solution);
+        current_stokes_constraints.set_zero (distributed_stokes_solution);
+
+        // Undo the pressure scaling:
+        IndexSet &pressure_idxset = parameters.include_melt_transport ?
+                                    introspection.index_sets.locally_owned_melt_pressure_dofs
+                                    : introspection.index_sets.locally_owned_pressure_dofs;
+
+        for (unsigned int i=0; i< pressure_idxset.n_elements(); ++i)
+          {
+            types::global_dof_index idx = pressure_idxset.nth_index_in_set(i);
+
+            distributed_stokes_solution(idx) /= pressure_scaling;
+          }
+        distributed_stokes_solution.compress(VectorOperation::insert);
+
+        // we need a temporary vector for the residual (even if we don't care about it)
+        LinearAlgebra::Vector residual (introspection.index_sets.stokes_partitioning[0], mpi_communicator);
+
+        initial_nonlinear_residual = system_matrix.block(block_vel_and_pres,block_vel_and_pres).residual(
+                                       residual,
+                                       distributed_stokes_solution.block(0),
+                                       system_rhs.block(block_vel_and_pres));
+
+        SolverControl cn;
+        // TODO: can we re-use the direct solver?
+        TrilinosWrappers::SolverDirect solver(cn);
+        try
+          {
+            solver.solve(system_matrix.block(block_vel_and_pres,block_vel_and_pres),
+                         distributed_stokes_solution.block(0),
+                         system_rhs.block(block_vel_and_pres));
+
+            // if we got here, we have successfully solved the linear system
+            // with a direct solver, and the final linear residual should
+            // be approximately zero. we could compute it exactly, but
+            // this is probably not necessary
+            final_linear_residual = 0;
+          }
+        // if the solver fails, report the error from processor 0 with some additional
+        // information about its location, and throw a quiet exception on all other
+        // processors
+        catch (const std::exception &exc)
+          {
+            if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+              {
+                AssertThrow (false,
+                             ExcMessage (std::string("The direct Stokes solver "
+                                                     "did not succeed. It reported the following error:\n\n")
+                                         +
+                                         exc.what()));
+              }
+            else
+              throw QuietException();
+          }
+
+
+        current_stokes_constraints.distribute (distributed_stokes_solution);
+
+        // Now rescale the pressure back to real physical units. Note that we are
+        // working on a vector in which all velocities and pressures are in one
+        // block (that's the design for block layout in case we're using a direct
+        // solver), and so unlike in the "common" case, we can't just scale a
+        // whole vector block -- we have to do it element by element.
+        {
+          const IndexSet &pressure_idxset
+            = (parameters.include_melt_transport ?
+               introspection.index_sets.locally_owned_melt_pressure_dofs
+               : introspection.index_sets.locally_owned_pressure_dofs);
+          for (const types::global_dof_index i : pressure_idxset)
+            distributed_stokes_solution(i) *= pressure_scaling;
+
+          distributed_stokes_solution.block(0).compress(VectorOperation::insert);
+        }
+
+        // Then copy back the solution from the temporary (non-ghosted) vector
+        // into the ghosted one with all solution components. Note that
+        // for a direct solver, we have only one block for velocity+pressure,
+        // and so only one block needs to be copied.
+        solution.block(block_vel_and_pres) = distributed_stokes_solution.block(0);
+
+        pcout << "done." << std::endl;
+      }
+    else // use iterative solver
+      {
+        Assert (distributed_stokes_solution.n_blocks() == 2, ExcInternalError());
+        Assert(!parameters.include_melt_transport
+               || introspection.variable("compaction pressure").block_index == 1,
+               ExcNotImplemented());
+
+        // Many parts of the solver depend on the block layout (velocity = 0,
+        // pressure = 1). For example the linearized_stokes_initial_guess vector or the StokesBlock matrix
+        // wrapper. Let us make sure that this holds (and shorten their names):
+        const unsigned int block_vel = introspection.block_indices.velocities;
+        const unsigned int block_p = (parameters.include_melt_transport) ?
+                                     introspection.variable("fluid pressure").block_index
+                                     : introspection.block_indices.pressure;
+        Assert(block_vel == 0, ExcNotImplemented());
+        Assert(block_p == 1, ExcNotImplemented());
+        Assert(!parameters.include_melt_transport
+               || introspection.variable("compaction pressure").block_index == 1,
+               ExcNotImplemented());
+
+        const internal::StokesBlock stokes_block(system_matrix);
+
+        // create a completely distributed vector that will be used for
+        // the scaled and denormalized solution and later used as a
+        // starting guess for the linear solver
+        LinearAlgebra::BlockVector linearized_stokes_initial_guess (introspection.index_sets.stokes_partitioning, mpi_communicator);
+
+        // copy the velocity and pressure from current_linearization_point into
+        // the vector linearized_stokes_initial_guess. We need to do the copy because
+        // linearized_stokes_variables has a different
+        // layout than current_linearization_point, which also contains all the
+        // other solution variables.
+        if (assemble_newton_stokes_system == false)
+          {
+            linearized_stokes_initial_guess.block (block_vel) = current_linearization_point.block (block_vel);
+            linearized_stokes_initial_guess.block (block_p) = current_linearization_point.block (block_p);
+
+            denormalize_pressure (this->last_pressure_normalization_adjustment,
+                                  linearized_stokes_initial_guess,
+                                  current_linearization_point);
+          }
+        else
+          {
+            // The Newton solver solves for updates to variables, for which our best guess is zero when
+            // it isn't the first nonlinear iteration. When it is the first nonlinear iteration, we
+            // have to assemble the full (non-defect correction) Picard, to get the boundary conditions
+            // right in combination with being able to use the initial guess optimally. So we should never
+            // end up here when it is the first nonlinear iteration.
+            Assert(nonlinear_iteration != 0,
+                   ExcMessage ("The Newton solver should not be active in the first nonlinear iteration."));
+
+            linearized_stokes_initial_guess.block (block_vel) = 0;
+            linearized_stokes_initial_guess.block (block_p) = 0;
+          }
+
+        current_stokes_constraints.set_zero (linearized_stokes_initial_guess);
+        linearized_stokes_initial_guess.block (block_p) /= pressure_scaling;
+
+        double solver_tolerance = 0;
+        if (assemble_newton_stokes_system == false)
+          {
+            // (ab)use the distributed solution vector to temporarily put a residual in
+            // (we don't care about the residual vector -- all we care about is the
+            // value (number) of the initial residual). The initial residual is returned
+            // to the caller (for nonlinear computations). This value is computed before
+            // the solve because we want to compute || A^{k+1} U^k - F^{k+1} ||, which is
+            // the nonlinear residual. Because the place where the nonlinear residual is
+            // checked against the nonlinear tolerance comes after the solve, the system
+            // is solved one time too many in the case of a nonlinear Picard solver.
+            initial_nonlinear_residual = stokes_block.residual (distributed_stokes_solution,
+                                                                linearized_stokes_initial_guess,
+                                                                system_rhs);
+
+            // Note: the residual is computed with a zero velocity, effectively computing
+            // || B^T p - g ||, which we are going to use for our solver tolerance.
+            // We do not use the current velocity for the initial residual because
+            // this would not decrease the number of iterations if we had a better
+            // initial guess (say using a smaller timestep). But we need to use
+            // the pressure instead of only using the norm of the rhs, because we
+            // are only interested in the part of the rhs not balanced by the static
+            // pressure (the current pressure is a good approximation for the static
+            // pressure).
+            const double residual_u = system_matrix.block(0,1).residual (distributed_stokes_solution.block(0),
+                                                                         linearized_stokes_initial_guess.block(1),
+                                                                         system_rhs.block(0));
+            const double residual_p = system_rhs.block(1).l2_norm();
+
+            solver_tolerance = parameters.linear_stokes_solver_tolerance *
+                               std::sqrt(residual_u*residual_u+residual_p*residual_p);
+          }
+        else
+          {
+            // if we are solving for the Newton update, then the initial guess of the solution
+            // vector is the zero vector, and the starting (nonlinear) residual is simply
+            // the norm of the (Newton) right hand side vector
+            const double residual_u = system_rhs.block(0).l2_norm();
+            const double residual_p = system_rhs.block(1).l2_norm();
+            solver_tolerance = parameters.linear_stokes_solver_tolerance *
+                               std::sqrt(residual_u*residual_u+residual_p*residual_p);
+
+            // as described in the documentation of the function, the initial
+            // nonlinear residual for the Newton method is computed by just
+            // taking the norm of the right hand side
+            initial_nonlinear_residual = std::sqrt(residual_u*residual_u+residual_p*residual_p);
+          }
+        // Now overwrite the solution vector again with the current best guess
+        // to solve the linear system
+        distributed_stokes_solution = linearized_stokes_initial_guess;
+
+        // extract Stokes parts of rhs vector
+        LinearAlgebra::BlockVector distributed_stokes_rhs(introspection.index_sets.stokes_partitioning);
+
+        distributed_stokes_rhs.block(block_vel) = system_rhs.block(block_vel);
+        distributed_stokes_rhs.block(block_p) = system_rhs.block(block_p);
+
+        PrimitiveVectorMemory<LinearAlgebra::BlockVector> mem;
+
+        // create Solver controls for the cheap and expensive solver phase
+        SolverControl solver_control_cheap (parameters.n_cheap_stokes_solver_steps,
+                                            solver_tolerance);
+
+        SolverControl solver_control_expensive (parameters.n_expensive_stokes_solver_steps,
+                                                solver_tolerance);
+
+        solver_control_cheap.enable_history_data();
+        solver_control_expensive.enable_history_data();
+
+        std::unique_ptr<internal::SchurComplementOperator> schur;
+        if (parameters.use_bfbt)
+          {
+            schur = std::make_unique<internal::WeightedBFBT<TrilinosWrappers::PreconditionBase>>(
+                      system_preconditioner_matrix.block(1,1),
+                      *Mp_preconditioner,
+                      parameters.linear_solver_S_block_tolerance,
+                      inverse_lumped_mass_matrix.block(0),
+                      system_matrix);
+          }
+        else
+          {
+            schur = std::make_unique<internal::InverseWeightedMassMatrix<TrilinosWrappers::PreconditionBase>>(
+                      system_preconditioner_matrix.block(1,1),
+                      *Mp_preconditioner,
+                      parameters.linear_solver_S_block_tolerance);
+
+          }
+
+        // create a cheap preconditioner that consists of only a single V-cycle
+        internal::InverseVelocityBlock<LinearAlgebra::PreconditionAMG> inverse_velocity_block_cheap(
+          system_matrix.block(0,0),
+          *Amg_preconditioner,
+          /* do_solve_A = */ false,
+          stokes_A_block_is_symmetric(),
+          parameters.linear_solver_A_block_tolerance);
+        const internal::BlockSchurPreconditioner<internal::InverseVelocityBlock<LinearAlgebra::PreconditionAMG>,
+              internal::SchurComplementOperator>
+              preconditioner_cheap (system_matrix,
+                                    system_preconditioner_matrix,
+                                    *schur,
+                                    inverse_velocity_block_cheap);
+
+        // create an expensive preconditioner that solves for the A block with CG
+        internal::InverseVelocityBlock<LinearAlgebra::PreconditionAMG> inverse_velocity_block_expensive(
+          system_matrix.block(0,0),
+          *Amg_preconditioner,
+          /* do_solve_A = */ true,
+          stokes_A_block_is_symmetric(),
+          parameters.linear_solver_A_block_tolerance);
+        const internal::BlockSchurPreconditioner<internal::InverseVelocityBlock<LinearAlgebra::PreconditionAMG>,
+              internal::SchurComplementOperator>
+              preconditioner_expensive (system_matrix,
+                                        system_preconditioner_matrix,
+                                        *schur,
+                                        inverse_velocity_block_expensive);
+        // step 1a: try if the simple and fast solver
+        // succeeds in n_cheap_stokes_solver_steps steps or less.
+        try
+          {
+            // if this cheaper solver is not desired, then simply
+            // short-cut the attempt at solving with the cheaper
+            // preconditioner by throwing an exception right away,
+            // which is equivalent to a 'goto' statement to the top of
+            // the 'catch' block below
+            if (parameters.n_cheap_stokes_solver_steps == 0)
+              throw SolverControl::NoConvergence(0,0);
+
+            SolverFGMRES<LinearAlgebra::BlockVector>
+            solver(solver_control_cheap, mem,
+                   SolverFGMRES<LinearAlgebra::BlockVector>::
+                   AdditionalData(parameters.stokes_gmres_restart_length));
+
+            solver.solve (stokes_block,
+                          distributed_stokes_solution,
+                          distributed_stokes_rhs,
+                          preconditioner_cheap);
+
+            // Success. Print all iterations to screen (0 expensive iterations).
+            pcout << (solver_control_cheap.last_step() != numbers::invalid_unsigned_int ?
+                      solver_control_cheap.last_step():
+                      0)
+                  << "+0"
+                  << " iterations." << std::endl;
+
+            final_linear_residual = solver_control_cheap.last_value();
+          }
+
+        // step 1b: take the stronger solver in case
+        // the simple solver failed and attempt solving
+        // it in n_expensive_stokes_solver_steps steps or less.
+        catch (const SolverControl::NoConvergence &exc)
+          {
+            // The cheap solver failed or never ran.
+            // Print the number of cheap iterations to screen to indicate we
+            // try the expensive solver next.
+            pcout << (solver_control_cheap.last_step() != numbers::invalid_unsigned_int ?
+                      solver_control_cheap.last_step():
+                      0) << '+' << std::flush;
+
+            // use the value defined by the user
+            // OR
+            // at least a restart length of 100 for melt models
+            const unsigned int number_of_temporary_vectors = (parameters.include_melt_transport == false ?
+                                                              parameters.stokes_gmres_restart_length :
+                                                              std::max(parameters.stokes_gmres_restart_length, 100U));
+
+            try
+              {
+                // if no expensive steps allowed, we have failed, rethrow exception
+                if (parameters.n_expensive_stokes_solver_steps == 0)
+                  {
+                    pcout << "0 iterations." << std::endl;
+                    throw exc;
+                  }
+
+                SolverFGMRES<LinearAlgebra::BlockVector>
+                solver(solver_control_expensive, mem,
+                       SolverFGMRES<LinearAlgebra::BlockVector>::
+                       AdditionalData(number_of_temporary_vectors));
+
+                solver.solve (stokes_block,
+                              distributed_stokes_solution,
+                              distributed_stokes_rhs,
+                              preconditioner_expensive);
+                // Success. Print expensive iterations to screen.
+                pcout << solver_control_expensive.last_step()
+                      << " iterations." << std::endl;
+
+                final_linear_residual = solver_control_expensive.last_value();
+              }
+            // if the solver fails, report the error from processor 0 with some additional
+            // information about its location, and throw a quiet exception on all other
+            // processors
+            catch (const std::exception &exc)
+              {
+                signals.post_stokes_solver(*this,
+                                           schur->n_iterations(),
+                                           inverse_velocity_block_cheap.n_iterations()+inverse_velocity_block_expensive.n_iterations(),
+                                           solver_control_cheap,
+                                           solver_control_expensive);
+
+                std::vector<SolverControl> solver_controls;
+                if (parameters.n_cheap_stokes_solver_steps > 0)
+                  solver_controls.push_back(solver_control_cheap);
+
+                if (parameters.n_expensive_stokes_solver_steps > 0)
+                  solver_controls.push_back(solver_control_expensive);
+
+                // Exit with an exception that describes the underlying cause:
+                Utilities::throw_linear_solver_failure_exception("iterative Stokes solver",
+                                                                 "Simulator::solve_stokes",
+                                                                 solver_controls,
+                                                                 exc,
+                                                                 mpi_communicator,
+                                                                 parameters.output_directory+"solver_history.txt");
+              }
+          }
+
+        // distribute hanging node and other constraints
+        current_stokes_constraints.distribute (distributed_stokes_solution);
+
+        // now rescale the pressure back to real physical units
+        distributed_stokes_solution.block(block_p) *= pressure_scaling;
+
+        // then copy back the solution from the temporary (non-ghosted) vector
+        // into the ghosted one with all solution components
+        solution.block(block_vel) = distributed_stokes_solution.block(0);
+        solution.block(block_p) = distributed_stokes_solution.block(1);
+
+        // signal successful solver
+        signals.post_stokes_solver(*this,
+                                   schur->n_iterations(),
+                                   inverse_velocity_block_cheap.n_iterations()+inverse_velocity_block_expensive.n_iterations(),
+                                   solver_control_cheap,
+                                   solver_control_expensive);
+      }
+
+    // do some cleanup now that we have the solution
+    remove_nullspace(solution, distributed_stokes_solution);
+    if (assemble_newton_stokes_system == false)
+      this->last_pressure_normalization_adjustment = normalize_pressure(solution);
+
+    // convert melt pressures:
+    if (parameters.include_melt_transport)
+      melt_handler->compute_melt_variables(system_matrix,solution,system_rhs);
+
+    return std::pair<double,double>(initial_nonlinear_residual,
+                                    final_linear_residual);
+  }
+
+}
+
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template double Simulator<dim>::solve_advection (const AdvectionField &); \
+  template std::pair<double,double> Simulator<dim>::solve_stokes ();
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/solver_schemes.cc.bak b/source/simulator/solver_schemes.cc.bak
new file mode 100644
index 00000000000..ec59003c77c
--- /dev/null
+++ b/source/simulator/solver_schemes.cc.bak
@@ -0,0 +1,1411 @@
+/*
+  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/simulator.h>
+#include <aspect/global.h>
+#include <aspect/mesh_deformation/free_surface.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/newton.h>
+#include <aspect/melt.h>
+
+#include <deal.II/numerics/vector_tools.h>
+
+#include <aspect/stokes_matrix_free.h>
+
+
+namespace aspect
+{
+
+  namespace
+  {
+    /**
+     * Converts a function with a certain number of components into a Function@<dim@>
+     * with optionally having additional zero components.
+     **/
+    template <int dim>
+    class VectorFunctionFromVectorFunctionObject : public Function<dim>
+    {
+      public:
+        /**
+         * Converts a function with @p n_object_components components into a Function@dim@
+         * while optionally providing additional components that are set to zero.
+         *
+         * @param function_object The function that will form the components
+         *     of the resulting Function object.
+         * @param first_component The first component that should be
+         *     filled.
+         * @param n_object_components The number of components that should be
+         *     filled from the first.
+         * @param n_total_components The total number of vector components of the
+         *     resulting Function object.
+         **/
+
+        VectorFunctionFromVectorFunctionObject (const std::function<void (const Point<dim> &,Vector<double> &)> &function_object,
+                                                const unsigned int first_component,
+                                                const unsigned int n_object_components,
+                                                const unsigned int n_total_components)
+          :
+          Function<dim>(n_total_components),
+          function_object (function_object),
+          first_component (first_component),
+          n_object_components (n_object_components)
+        {
+          Assert ((n_object_components > 0
+                   &&
+                   first_component+n_object_components <= n_total_components),
+                  ExcMessage ("Number of objects components needs to be less than number of total components"));
+        }
+
+
+
+        double
+        value (const Point<dim> &p,
+               const unsigned int component) const override
+        {
+          Assert (component < this->n_components,
+                  ExcIndexRange (component, 0, this->n_components));
+
+          if (component < first_component)
+            return 0;
+          else if (component >= first_component + n_object_components)
+            return 0;
+          else
+            {
+              Vector<double> temp(n_object_components);
+              function_object (p, temp);
+              return temp(component - first_component);
+            }
+        }
+
+
+
+        void
+        vector_value (const Point<dim>   &p,
+                      Vector<double>     &values) const override
+        {
+          AssertDimension(values.size(), this->n_components);
+
+          // set everything to zero, and then the right components to their correct values
+          values = 0;
+          Vector<double> temp(n_object_components);
+          function_object (p, temp);
+          for (unsigned int i = 0; i < n_object_components; ++i)
+            {
+              values(first_component + i) = temp(i);
+            }
+        }
+
+
+
+      private:
+        /**
+         * The function object which we call when this class's solution() function is called.
+         **/
+        const std::function<void (const Point<dim> &,Vector<double> &)> function_object;
+
+        /**
+         * The first vector component whose value is to be filled by the given
+         * function.
+         */
+        const unsigned int first_component;
+        /**
+         * The number of vector components whose values are to be filled by the given
+         * function.
+         */
+        const unsigned int n_object_components;
+
+    };
+
+  }
+
+
+
+  template <int dim>
+  double Simulator<dim>::assemble_and_solve_temperature (const double &initial_residual,
+                                                         double *residual)
+  {
+    double current_residual = 0.0;
+
+    switch (parameters.temperature_method)
+      {
+        case Parameters<dim>::AdvectionFieldMethod::fem_field:
+        case Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion:
+        {
+          const AdvectionField adv_field (AdvectionField::temperature());
+
+          // if this is a prescribed field with diffusion, we first have to copy the material model
+          // outputs into the prescribed field before we assemble and solve the equation
+          if (parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion)
+            {
+              TimerOutput::Scope timer (computing_timer, "Interpolate prescribed temperature");
+
+              interpolate_material_output_into_advection_field(adv_field);
+
+              // Also set the old_solution block to the prescribed field. The old
+              // solution is the one that is used to assemble the diffusion system in
+              // assemble_advection_system() for this solver scheme.
+              old_solution.block(adv_field.block_index(introspection)) = solution.block(adv_field.block_index(introspection));
+            }
+
+          assemble_advection_system (adv_field);
+
+          if (residual)
+            *residual = system_rhs.block(introspection.block_indices.temperature).l2_norm();
+
+          current_residual = solve_advection(adv_field);
+          break;
+        }
+
+        case Parameters<dim>::AdvectionFieldMethod::prescribed_field:
+        {
+          const AdvectionField adv_field (AdvectionField::temperature());
+
+          TimerOutput::Scope timer (computing_timer, "Interpolate prescribed temperature");
+
+          interpolate_material_output_into_advection_field(adv_field);
+
+          // Call the signal in case the user wants to do something with the variable:
+          SolverControl dummy;
+          signals.post_advection_solver(*this,
+                                        adv_field.is_temperature(),
+                                        adv_field.compositional_variable,
+                                        dummy);
+          break;
+        }
+
+        case Parameters<dim>::AdvectionFieldMethod::static_field:
+        {
+          const AdvectionField adv_field (AdvectionField::temperature());
+          // Do nothing here, but at least call the signal in case the
+          // user wants to do something with the variable:
+          SolverControl dummy;
+          signals.post_advection_solver(*this,
+                                        adv_field.is_temperature(),
+                                        adv_field.compositional_variable,
+                                        dummy);
+          break;
+        }
+
+        default:
+          AssertThrow(false,ExcNotImplemented());
+      }
+
+    current_linearization_point.block(introspection.block_indices.temperature)
+      = solution.block(introspection.block_indices.temperature);
+
+    if (initial_residual > 0)
+      return current_residual / initial_residual;
+
+    return 0.0;
+  }
+
+
+
+  template <int dim>
+  std::vector<double>
+  Simulator<dim>::assemble_and_solve_composition (const std::vector<double> &initial_residual,
+                                                  std::vector<double> *residual)
+  {
+    // Advect the particles before they are potentially used to
+    // set up the compositional fields.
+    for (auto &particle_world : particle_worlds)
+      {
+        // Do not advect the particles in the initial refinement stage
+        const bool in_initial_refinement = (timestep_number == 0)
+                                           && (pre_refinement_step < parameters.initial_adaptive_refinement);
+        if (!in_initial_refinement)
+          // Advance the particles in the world to the current time
+          particle_world->advance_timestep();
+
+        if (particle_world->get_property_manager().need_update() == Particle::Property::update_output_step)
+          particle_world->update_particles();
+      }
+
+    std::vector<double> current_residual(introspection.n_compositional_fields,0.0);
+
+    if (residual)
+      Assert(residual->size() == introspection.n_compositional_fields, ExcInternalError());
+
+    std::vector<AdvectionField> fields_advected_by_particles;
+
+    for (unsigned int c=0; c < introspection.n_compositional_fields; ++c)
+      {
+        const AdvectionField adv_field (AdvectionField::composition(c));
+        const typename Parameters<dim>::AdvectionFieldMethod::Kind method = adv_field.advection_method(introspection);
+        switch (method)
+          {
+            case Parameters<dim>::AdvectionFieldMethod::fem_field:
+            case Parameters<dim>::AdvectionFieldMethod::fem_melt_field:
+            case Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion:
+            case Parameters<dim>::AdvectionFieldMethod::fem_darcy_field:
+            {
+              // if this is a prescribed field with diffusion, we first have to copy the material model
+              // outputs into the prescribed field before we assemble and solve the equation
+              if (method == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion)
+                {
+                  TimerOutput::Scope timer (computing_timer, "Interpolate prescribed composition");
+
+                  interpolate_material_output_into_advection_field(adv_field);
+
+                  // Also set the old_solution block to the prescribed field. The old
+                  // solution is the one that is used to assemble the diffusion system in
+                  // assemble_advection_system() for this solver scheme.
+                  old_solution.block(adv_field.block_index(introspection)) = solution.block(adv_field.block_index(introspection));
+                }
+
+              assemble_advection_system (adv_field);
+
+              if (residual)
+                (*residual)[c] = system_rhs.block(introspection.block_indices.compositional_fields[c]).l2_norm();
+
+              current_residual[c] = solve_advection(adv_field);
+
+              // Release the contents of the matrix block we used again:
+              const unsigned int block_idx = adv_field.block_index(introspection);
+              if (adv_field.sparsity_pattern_block_index(introspection)!=block_idx)
+                system_matrix.block(block_idx, block_idx).clear();
+
+              // No need to call the post_advection_solver signal here: It is
+              // automatically called from solve_advection() above.
+
+              break;
+            }
+
+            case Parameters<dim>::AdvectionFieldMethod::particles:
+            {
+              // handle all particle fields together to increase efficiency
+              fields_advected_by_particles.push_back(adv_field);
+              break;
+            }
+
+            case Parameters<dim>::AdvectionFieldMethod::prescribed_field:
+            {
+              TimerOutput::Scope timer (computing_timer, "Interpolate prescribed composition");
+
+              interpolate_material_output_into_advection_field(adv_field);
+
+              // Call the signal in case the user wants to do something with the variable:
+              SolverControl dummy;
+              signals.post_advection_solver(*this,
+                                            adv_field.is_temperature(),
+                                            adv_field.compositional_variable,
+                                            dummy);
+              break;
+            }
+
+            case Parameters<dim>::AdvectionFieldMethod::volume_of_fluid:
+            {
+              volume_of_fluid_handler->do_volume_of_fluid_update(adv_field);
+              break;
+            }
+
+            case Parameters<dim>::AdvectionFieldMethod::static_field:
+            {
+              // Do nothing here, but at least call the signal in case the
+              // user wants to do something with the variable:
+              SolverControl dummy;
+              signals.post_advection_solver(*this,
+                                            adv_field.is_temperature(),
+                                            adv_field.compositional_variable,
+                                            dummy);
+              break;
+            }
+
+            default:
+              AssertThrow(false,ExcNotImplemented());
+          }
+      }
+
+    if (fields_advected_by_particles.size() > 0)
+      interpolate_particle_properties(fields_advected_by_particles);
+
+
+    // for consistency we update the current linearization point only after we have solved
+    // all fields, so that we use the same point in time for every field when solving
+    for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+      {
+        current_linearization_point.block(introspection.block_indices.compositional_fields[c])
+          = solution.block(introspection.block_indices.compositional_fields[c]);
+
+        if ((initial_residual.size() > 0) && (initial_residual[c] > 0))
+          current_residual[c] /= initial_residual[c];
+        else
+          current_residual[c] = 0.0;
+      }
+
+    return current_residual;
+  }
+
+
+
+  template <int dim>
+  double
+  Simulator<dim>::assemble_and_solve_stokes (const double &initial_nonlinear_residual,
+                                             double *nonlinear_residual)
+  {
+    // If the Stokes matrix depends on the solution, or we have active
+    // velocity boundary conditions, we need to re-assemble the system matrix
+    // (and preconditioner) every time. If we have active boundary conditions,
+    // they could a) depend on the solution, or b) be inhomogeneous. In both
+    // cases, just assembling the RHS will be incorrect.  If no active
+    // boundaries exist, we only have no-slip or free slip conditions, so we
+    // don't need to force assembly of the matrix.
+    if (stokes_matrix_depends_on_solution()
+        ||
+        (boundary_velocity_manager.get_active_boundary_velocity_conditions().size() > 0)
+        || parameters.mesh_deformation_enabled
+       )
+      rebuild_stokes_matrix = rebuild_stokes_preconditioner = true;
+
+    // set constraints for p_c if porosity is below a threshold
+    if (nonlinear_iteration == 0 && parameters.include_melt_transport)
+      {
+        compute_current_constraints();
+        if (rebuild_sparsity_and_matrices)
+          {
+            setup_system_matrix (introspection.index_sets.system_partitioning);
+            setup_system_preconditioner (introspection.index_sets.system_partitioning);
+
+            rebuild_stokes_matrix = rebuild_stokes_preconditioner = true;
+          }
+      }
+
+    assemble_stokes_system ();
+
+    // build the preconditioner
+    if (stokes_matrix_free)
+      stokes_matrix_free->build_preconditioner();
+    else
+      build_stokes_preconditioner();
+
+    if (nonlinear_residual)
+      *nonlinear_residual = compute_initial_stokes_residual();
+
+    const double current_nonlinear_residual = solve_stokes().first;
+
+    current_linearization_point.block(introspection.block_indices.velocities)
+      = solution.block(introspection.block_indices.velocities);
+
+    if (introspection.block_indices.velocities != introspection.block_indices.pressure)
+      current_linearization_point.block(introspection.block_indices.pressure)
+        = solution.block(introspection.block_indices.pressure);
+
+    if (parameters.include_melt_transport)
+      {
+        // Note that the compaction pressure is in the fluid pressure block
+        // and will therefore be updated as well.
+        const unsigned int fluid_velocity_block = introspection.variable("fluid velocity").block_index;
+        const unsigned int fluid_pressure_block = introspection.variable("fluid pressure").block_index;
+        current_linearization_point.block(fluid_velocity_block) = solution.block(fluid_velocity_block);
+        current_linearization_point.block(fluid_pressure_block) = solution.block(fluid_pressure_block);
+      }
+
+    if (initial_nonlinear_residual > 0)
+      return current_nonlinear_residual / initial_nonlinear_residual;
+    else
+      return 0.0;
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::do_one_defect_correction_Stokes_step(DefectCorrectionResiduals &dcr,
+                                                            const bool use_picard)
+  {
+    /**
+     * copied from solver.cc
+     */
+
+    // Many parts of the solver depend on the block layout (velocity = 0,
+    // pressure = 1). For example the linearized_stokes_initial_guess vector or the StokesBlock matrix
+    // wrapper. Let us make sure that this holds (and shorten their names):
+    const unsigned int block_vel = introspection.block_indices.velocities;
+    const unsigned int block_p = (parameters.include_melt_transport) ?
+                                 introspection.variable("fluid pressure").block_index
+                                 : introspection.block_indices.pressure;
+    Assert(block_vel == 0, ExcNotImplemented());
+    Assert(block_p == 1, ExcNotImplemented());
+    Assert(!parameters.include_melt_transport
+           || introspection.variable("compaction pressure").block_index == 1, ExcNotImplemented());
+
+    // create a completely distributed vector that will be used for
+    // the scaled and denormalized solution and later used as a
+    // starting guess for the linear solver
+    LinearAlgebra::BlockVector linearized_stokes_initial_guess(introspection.index_sets.stokes_partitioning, mpi_communicator);
+    linearized_stokes_initial_guess.block(block_vel) = current_linearization_point.block(block_vel);
+    linearized_stokes_initial_guess.block(block_p) = current_linearization_point.block(block_p);
+
+    if (nonlinear_iteration == 0)
+      {
+        dcr.initial_residual = compute_initial_newton_residual(linearized_stokes_initial_guess);
+        dcr.switch_initial_residual = dcr.initial_residual;
+        dcr.residual_old = dcr.initial_residual;
+        dcr.residual = dcr.initial_residual;
+      }
+
+    assemble_newton_stokes_system = assemble_newton_stokes_matrix = true;
+
+    if (nonlinear_iteration == 0)
+      {
+        assemble_newton_stokes_system = assemble_newton_stokes_matrix = false;
+      }
+    else
+      {
+        denormalize_pressure (last_pressure_normalization_adjustment,
+                              linearized_stokes_initial_guess,
+                              current_linearization_point);
+      }
+
+    if (nonlinear_iteration <= 1)
+      {
+        set_assemblers();
+        compute_current_constraints ();
+      }
+
+    // If the Stokes matrix depends on the solution, or we have active
+    // velocity boundary conditions, we need to re-assemble the system matrix
+    // (and preconditioner) every time. If we have active boundary conditions,
+    // they could a) depend on the solution, or b) be inhomogeneous. In both
+    // cases, just assembling the RHS will be incorrect.  If no active
+    // boundaries exist, we only have no-slip or free slip conditions, so we
+    // don't need to force assembly of the matrix.
+    if (stokes_matrix_depends_on_solution()
+        ||
+        nonlinear_iteration == 0)
+      rebuild_stokes_matrix = rebuild_stokes_preconditioner = assemble_newton_stokes_matrix = true;
+    else if (parameters.enable_prescribed_dilation)
+      // The dilation requires the Stokes matrix (which is on the rhs
+      // in the Newton solver) to be updated.
+      rebuild_stokes_matrix = true;
+
+    assemble_stokes_system();
+
+    // recompute rhs
+    dcr.velocity_residual = system_rhs.block(introspection.block_indices.velocities).l2_norm();
+    dcr.pressure_residual = system_rhs.block(introspection.block_indices.pressure).l2_norm();
+    dcr.residual = std::sqrt(dcr.velocity_residual * dcr.velocity_residual + dcr.pressure_residual * dcr.pressure_residual);
+
+    // Test whether the rhs has dropped so much that we can assume that the iteration is done.
+    if (dcr.residual < dcr.residual_old * 1e-8)
+      {
+        pcout << "   Nonlinear residual reduction has been very large ("
+              << dcr.residual/dcr.residual_old << "); skipping Stokes solve"
+              << std::endl;
+        return;
+      }
+
+    /**
+     * Eisenstat Walker method for determining the tolerance
+     */
+    if (nonlinear_iteration > 1)
+      {
+        if (!use_picard || newton_handler->parameters.use_Eisenstat_Walker_method_for_Picard_iterations)
+          {
+            const bool EisenstatWalkerChoiceOne = true;
+            parameters.linear_stokes_solver_tolerance = compute_Eisenstat_Walker_linear_tolerance(EisenstatWalkerChoiceOne,
+                                                        newton_handler->parameters.maximum_linear_stokes_solver_tolerance,
+                                                        parameters.linear_stokes_solver_tolerance,
+                                                        dcr.stokes_residuals.second,
+                                                        dcr.residual,
+                                                        dcr.residual_old);
+
+            pcout << "   The linear solver tolerance is set to "
+                  << parameters.linear_stokes_solver_tolerance
+                  << ". ";
+            if (!use_picard)
+              {
+                pcout << "Stabilization Preconditioner is "
+                      << Newton::to_string(newton_handler->parameters.preconditioner_stabilization)
+                      << " and A block is "
+                      << Newton::to_string(newton_handler->parameters.velocity_block_stabilization)
+                      << '.';
+              }
+            pcout << std::endl;
+          }
+      }
+
+    if (stokes_matrix_free)
+      stokes_matrix_free->build_preconditioner();
+    else
+      build_stokes_preconditioner();
+
+    if (newton_handler->parameters.use_Newton_failsafe == false)
+      {
+        dcr.stokes_residuals = solve_stokes();
+      }
+    else
+      {
+        try
+          {
+            dcr.stokes_residuals = solve_stokes();
+          }
+        catch (const std::exception &exc)
+          {
+            // Test that the exception we got is one of the two documented by
+            // throw_linear_solver_failure_exception(). If not, we have a genuine
+            // problem here, and will need to get outta here right away:
+            if ((dynamic_cast<const ExcMessage *>(&exc)==nullptr) &&
+                (dynamic_cast<const QuietException *>(&exc)==nullptr))
+              throw;
+
+            // start the solve over again and try with a stabilized version
+            pcout << "failed, trying again with stabilization" << std::endl;
+            newton_handler->parameters.preconditioner_stabilization = Newton::Parameters::Stabilization::SPD;
+            newton_handler->parameters.velocity_block_stabilization = Newton::Parameters::Stabilization::SPD;
+
+            // If the Stokes matrix depends on the solution, or we have active
+            // velocity boundary conditions, we need to re-assemble the system matrix
+            // (and preconditioner) every time. If we have active boundary conditions,
+            // they could a) depend on the solution, or b) be inhomogeneous. In both
+            // cases, just assembling the RHS will be incorrect.  If no active
+            // boundaries exist, we only have no-slip or free slip conditions, so we
+            // don't need to force assembly of the matrix.
+            if (stokes_matrix_depends_on_solution()
+                ||
+                (nonlinear_iteration == 0 && boundary_velocity_manager.get_active_boundary_velocity_conditions().size() > 0))
+              rebuild_stokes_matrix = rebuild_stokes_preconditioner = assemble_newton_stokes_matrix = true;
+            else if (parameters.enable_prescribed_dilation)
+              // The dilation requires the Stokes matrix (which is on the rhs
+              // in the Newton solver) to be updated.
+              rebuild_stokes_matrix = true;
+
+            assemble_stokes_system();
+
+            /**
+             * Eisenstat Walker method for determining the tolerance
+             */
+            if (nonlinear_iteration > 1)
+              {
+                dcr.residual_old = dcr.residual;
+                dcr.velocity_residual = system_rhs.block(introspection.block_indices.velocities).l2_norm();
+                dcr.pressure_residual = system_rhs.block(introspection.block_indices.pressure).l2_norm();
+                dcr.residual = std::sqrt(dcr.velocity_residual * dcr.velocity_residual + dcr.pressure_residual * dcr.pressure_residual);
+
+                if (!use_picard)
+                  {
+                    const bool EisenstatWalkerChoiceOne = true;
+                    parameters.linear_stokes_solver_tolerance = compute_Eisenstat_Walker_linear_tolerance(EisenstatWalkerChoiceOne,
+                                                                newton_handler->parameters.maximum_linear_stokes_solver_tolerance,
+                                                                parameters.linear_stokes_solver_tolerance,
+                                                                dcr.stokes_residuals.second,
+                                                                dcr.residual,
+                                                                dcr.residual_old);
+
+                    pcout << "   The linear solver tolerance is set to " << parameters.linear_stokes_solver_tolerance << std::endl;
+                  }
+              }
+
+            if (stokes_matrix_free)
+              stokes_matrix_free->build_preconditioner();
+            else
+              build_stokes_preconditioner();
+
+            // Give this another try:
+            dcr.stokes_residuals = solve_stokes();
+          }
+      }
+
+    dcr.velocity_residual = system_rhs.block(introspection.block_indices.velocities).l2_norm();
+    dcr.pressure_residual = system_rhs.block(introspection.block_indices.pressure).l2_norm();
+    dcr.residual = std::sqrt(dcr.velocity_residual * dcr.velocity_residual + dcr.pressure_residual * dcr.pressure_residual);
+
+    double test_residual = dcr.residual;
+    if (nonlinear_iteration == 0)
+      {
+        /**
+         * The first nonlinear iteration we are computing the whole system in a non-defect corrected Picard way,
+         * to make sure that the boundary conditions are correct in combination with correct initial guesses.
+         */
+        current_linearization_point.block(introspection.block_indices.velocities) = solution.block(introspection.block_indices.velocities);
+        current_linearization_point.block(introspection.block_indices.pressure) = solution.block(introspection.block_indices.pressure);
+
+        dcr.residual = dcr.stokes_residuals.first;
+
+        pcout << "      Newton system information: Norm of the rhs: " << dcr.stokes_residuals.first << std::endl;
+      }
+    else
+      {
+        /**
+         * We may need to do a line search if the solution update doesn't decrease the norm of the rhs enough.
+         * This is done by adding the solution update to the current linearization point and then assembling
+         * the Newton right hand side. If the Newton residual has decreased enough by using this update,
+         * then we continue, otherwise we reset the current linearization point with the help of the backup and
+         * add each iteration an increasingly smaller solution update until the decreasing residual condition
+         * is met, or the line search iteration limit is reached.
+         */
+        LinearAlgebra::BlockVector backup_linearization_point(introspection.index_sets.stokes_partitioning, mpi_communicator);
+        backup_linearization_point.block(introspection.block_indices.pressure) = current_linearization_point.block(introspection.block_indices.pressure);
+        backup_linearization_point.block(introspection.block_indices.velocities) = current_linearization_point.block(introspection.block_indices.velocities);
+
+
+        double test_velocity_residual = 0;
+        double test_pressure_residual = 0;
+        double step_length_factor = 1;
+        double alpha = 1e-4;
+        unsigned int line_search_iteration = 0;
+
+
+        /**
+         * Do the loop for the line search. Even when we
+         * don't do a line search we go into this loop
+         */
+        do
+          {
+            // Reset the current linearization point and the search direction
+            current_linearization_point.block(introspection.block_indices.pressure) = backup_linearization_point.block(introspection.block_indices.pressure);
+            current_linearization_point.block(introspection.block_indices.velocities) = backup_linearization_point.block(introspection.block_indices.velocities);
+
+            LinearAlgebra::BlockVector search_direction = solution;
+            search_direction *= step_length_factor;
+
+            current_linearization_point.block(introspection.block_indices.pressure) += search_direction.block(introspection.block_indices.pressure);
+            current_linearization_point.block(introspection.block_indices.velocities) += search_direction.block(introspection.block_indices.velocities);
+
+            // Rebuild the rhs to determine the new residual.
+            assemble_newton_stokes_matrix = rebuild_stokes_preconditioner = false;
+            rebuild_stokes_matrix = (boundary_velocity_manager.get_active_boundary_velocity_conditions().empty()
+                                     == false);
+
+            assemble_stokes_system();
+
+            test_velocity_residual = system_rhs.block(introspection.block_indices.velocities).l2_norm();
+            test_pressure_residual = system_rhs.block(introspection.block_indices.pressure).l2_norm();
+            test_residual = std::sqrt(test_velocity_residual * test_velocity_residual
+                                      + test_pressure_residual * test_pressure_residual);
+
+            // Determine if the decrease is sufficient.
+            if (test_residual < (1.0 - alpha * step_length_factor) * dcr.residual
+                ||
+                line_search_iteration >= newton_handler->parameters.max_newton_line_search_iterations
+                ||
+                use_picard)
+              {
+                pcout << "      Newton system information: Norm of the rhs: " << test_residual
+                      << ", Derivative scaling factor: " << newton_handler->parameters.newton_derivative_scaling_factor << std::endl;
+                dcr.residual = test_residual;
+                break;
+              }
+            else
+              {
+
+                pcout << "   Line search iteration " << line_search_iteration << ", with norm of the rhs "
+                      << test_residual << " and going to " << (1.0 - alpha * step_length_factor) * dcr.residual
+                      << ", relative residual: " << test_residual/dcr.initial_residual << std::endl;
+
+                /**
+                 * The line search step was not sufficient to decrease the residual
+                 * enough, so we take a smaller step to see if it improves the residual.
+                 */
+                step_length_factor *= (2.0/3.0);// TODO: make a parameter out of this.
+              }
+
+            ++line_search_iteration;
+            Assert(line_search_iteration <= newton_handler->parameters.max_newton_line_search_iterations,
+                   ExcMessage ("This tests the while condition. This condition should "
+                               "actually never be false, because the break statement "
+                               "above should have caught it."));
+          }
+        while (true);
+      }
+
+
+    if (use_picard == true)
+      {
+        // When we are using (defect corrected) Picard, keep the
+        // newton_derivative_scaling_factor at zero. The newton_derivative_scaling_factor
+        // is calculated above as std::max(0.0, (1.0-(
+        // newton_residual_for_derivative_scaling_factor/switch_initial_residual)))
+        dcr.switch_initial_residual = dcr.residual;
+        dcr.newton_residual_for_derivative_scaling_factor = dcr.residual;
+      }
+    else
+      {
+        /**
+         * This method allows to slowly introduce the derivatives based
+         * on the improvement of the residual. This method was suggested
+         * by Raid Hassani.
+         */
+        if (newton_handler->parameters.use_newton_residual_scaling_method)
+          dcr.newton_residual_for_derivative_scaling_factor = test_residual;
+        else
+          dcr.newton_residual_for_derivative_scaling_factor = 0;
+      }
+
+    dcr.residual_old = dcr.residual;
+
+    if (nonlinear_iteration != 0)
+      last_pressure_normalization_adjustment = normalize_pressure(current_linearization_point);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_single_advection_single_stokes ()
+  {
+    assemble_and_solve_temperature();
+    assemble_and_solve_composition();
+    assemble_and_solve_stokes();
+
+    if (parameters.run_postprocessors_on_nonlinear_iterations)
+      postprocess ();
+
+    // Setup a nonlinear solver control that only allows a single iteration
+    SolverControl nonlinear_solver_control(1,1.0);
+    // Announce that we did a single iteration, and assume we have converged
+    nonlinear_solver_control.check(1,0.0);
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_no_advection_iterated_stokes ()
+  {
+    double initial_stokes_residual = 0.0;
+
+    const unsigned int max_nonlinear_iterations =
+      (pre_refinement_step < parameters.initial_adaptive_refinement)
+      ?
+      std::min(parameters.max_nonlinear_iterations,
+               parameters.max_nonlinear_iterations_in_prerefinement)
+      :
+      parameters.max_nonlinear_iterations;
+
+    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
+                                           parameters.nonlinear_tolerance);
+
+    double relative_residual = std::numeric_limits<double>::max();
+    nonlinear_iteration = 0;
+    do
+      {
+        relative_residual =
+          assemble_and_solve_stokes(initial_stokes_residual,
+                                    nonlinear_iteration == 0 ? &initial_stokes_residual : nullptr);
+
+        pcout << "      Relative nonlinear residual (Stokes system) after nonlinear iteration " << nonlinear_iteration+1
+              << ": " << relative_residual
+              << std::endl
+              << std::endl;
+
+        if (parameters.run_postprocessors_on_nonlinear_iterations)
+          postprocess ();
+
+        ++nonlinear_iteration;
+      }
+    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
+
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_no_advection_iterated_defect_correction_stokes ()
+  {
+    // Now store the linear_tolerance we started out with, because we might change
+    // it within this timestep.
+    const double begin_linear_tolerance = parameters.linear_stokes_solver_tolerance;
+
+    DefectCorrectionResiduals dcr;
+    dcr.initial_residual = 1;
+
+    dcr.velocity_residual = 0;
+    dcr.pressure_residual = 0;
+    dcr.residual = 1;
+    dcr.residual_old = 1;
+
+    dcr.switch_initial_residual = 1;
+    dcr.newton_residual_for_derivative_scaling_factor = 1;
+
+    const unsigned int max_nonlinear_iterations =
+      (pre_refinement_step < parameters.initial_adaptive_refinement)
+      ?
+      std::min(parameters.max_nonlinear_iterations,
+               parameters.max_nonlinear_iterations_in_prerefinement)
+      :
+      parameters.max_nonlinear_iterations;
+
+    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
+                                           parameters.nonlinear_tolerance);
+
+    // Now iterate out the nonlinearities.
+    dcr.stokes_residuals = std::pair<double,double>  (numbers::signaling_nan<double>(),
+                                                      numbers::signaling_nan<double>());
+
+    double relative_residual = std::numeric_limits<double>::max();
+    nonlinear_iteration = 0;
+    do
+      {
+        do_one_defect_correction_Stokes_step(dcr, /* use_picard= */true);
+
+        relative_residual = dcr.residual/dcr.initial_residual;
+
+        pcout << "      Relative nonlinear residual (Stokes system) after nonlinear iteration " << nonlinear_iteration+1
+              << ": " << relative_residual
+              << std::endl
+              << std::endl;
+
+        if (parameters.run_postprocessors_on_nonlinear_iterations)
+          {
+            // Before postprocessing, we need to copy the actual solution into the solution vector
+            // (which is used for postprocessing)
+            solution = current_linearization_point;
+            postprocess ();
+          }
+
+        ++nonlinear_iteration;
+      }
+    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
+
+    // Reset the linear tolerance to what it was at the beginning of the time step.
+    parameters.linear_stokes_solver_tolerance = begin_linear_tolerance;
+
+    // When we are finished iterating, we need to set the final solution to the current linearization point,
+    // because the solution vector is used in the postprocess.
+    solution = current_linearization_point;
+
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_single_advection_iterated_defect_correction_stokes ()
+  {
+    // The defect correction solver is just the Newton solver without derivatives.
+    solve_single_advection_and_iterated_newton_stokes(/*use_newton_iterations = */ false);
+  }
+
+  template <int dim>
+  void Simulator<dim>::solve_iterated_advection_and_defect_correction_stokes ()
+  {
+    // The defect correction solver is just the Newton solver without derivatives.
+    solve_iterated_advection_and_newton_stokes(/*use_newton_iterations = */ false);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_no_advection_single_stokes ()
+  {
+    assemble_and_solve_stokes();
+
+    if (parameters.run_postprocessors_on_nonlinear_iterations)
+      postprocess ();
+
+    // Setup a nonlinear solver control that only allows a single iteration
+    SolverControl nonlinear_solver_control(1,1.0);
+    // Announce that we did a single iteration, and assume we have converged
+    nonlinear_solver_control.check(1,0.0);
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+  template <int dim>
+  void Simulator<dim>::solve_first_timestep_only_single_stokes ()
+  {
+    if (timestep_number == 0)
+      assemble_and_solve_stokes();
+
+    // Setup a nonlinear solver control that only allows a single iteration
+    SolverControl nonlinear_solver_control(1,1.0);
+    // Announce that we did a single iteration, and assume we have converged
+    nonlinear_solver_control.check(1,0.0);
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_iterated_advection_and_stokes ()
+  {
+    double initial_temperature_residual = 0;
+    double initial_stokes_residual      = 0;
+    std::vector<double> initial_composition_residual (introspection.n_compositional_fields,0);
+
+    const unsigned int max_nonlinear_iterations =
+      (pre_refinement_step < parameters.initial_adaptive_refinement)
+      ?
+      std::min(parameters.max_nonlinear_iterations,
+               parameters.max_nonlinear_iterations_in_prerefinement)
+      :
+      parameters.max_nonlinear_iterations;
+
+    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
+                                           parameters.nonlinear_tolerance);
+
+    double relative_residual = std::numeric_limits<double>::max();
+    nonlinear_iteration = 0;
+
+    do
+      {
+        // Restore particles through stored copy of particle handler,
+        // but only if they have already been displaced in a nonlinear
+        // iteration (in the assemble_and_solve_composition call).
+
+        if (nonlinear_iteration > 0)
+          for (auto &particle_world : particle_worlds)
+            particle_world->restore_particles();
+
+        const double relative_temperature_residual =
+          assemble_and_solve_temperature(initial_temperature_residual,
+                                         nonlinear_iteration == 0 ? &initial_temperature_residual : nullptr);
+
+        const std::vector<double>  relative_composition_residual =
+          assemble_and_solve_composition(initial_composition_residual,
+                                         nonlinear_iteration == 0 ? &initial_composition_residual : nullptr);
+
+        const double relative_nonlinear_stokes_residual =
+          assemble_and_solve_stokes(initial_stokes_residual,
+                                    nonlinear_iteration == 0 ? &initial_stokes_residual : nullptr);
+
+        // write the residual output in the same order as the solutions
+        pcout << "      Relative nonlinear residuals (temperature"
+              << (introspection.n_compositional_fields > 0 ? ", compositional fields" : "")
+              << ", Stokes system): " << relative_temperature_residual;
+        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+          pcout << ", " << relative_composition_residual[c];
+        pcout << ", " << relative_nonlinear_stokes_residual;
+        pcout << std::endl;
+
+        // Find the maximum residual of the individual equations
+        relative_residual = relative_temperature_residual;
+        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+          {
+            // in models with melt migration the melt advection equation includes the divergence of the velocity
+            // and can not be expected to converge to a smaller value than the residual of the Stokes equation.
+            // thus, we set a threshold for the initial composition residual.
+            // this only plays a role if the right-hand side of the advection equation is very small.
+            const double threshold = (parameters.include_melt_transport && c == introspection.compositional_index_for_name("porosity")
+                                      ?
+                                      parameters.linear_stokes_solver_tolerance * time_step
+                                      :
+                                      0.0);
+            if (initial_composition_residual[c]>threshold)
+              relative_residual = std::max(relative_composition_residual[c],relative_residual);
+          }
+        relative_residual = std::max(relative_nonlinear_stokes_residual, relative_residual);
+
+        pcout << "      Relative nonlinear residual (total system) after nonlinear iteration " << nonlinear_iteration+1
+              << ": " << relative_residual
+              << std::endl
+              << std::endl;
+
+        if (parameters.run_postprocessors_on_nonlinear_iterations)
+          postprocess ();
+
+        ++nonlinear_iteration;
+      }
+    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
+
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_single_advection_iterated_stokes ()
+  {
+    // solve the temperature and composition systems once...
+    assemble_and_solve_temperature();
+
+    assemble_and_solve_composition();
+
+    // ...and then iterate the solution of the Stokes system
+    double initial_stokes_residual = 0;
+
+    const unsigned int max_nonlinear_iterations =
+      (pre_refinement_step < parameters.initial_adaptive_refinement)
+      ?
+      std::min(parameters.max_nonlinear_iterations,
+               parameters.max_nonlinear_iterations_in_prerefinement)
+      :
+      parameters.max_nonlinear_iterations;
+
+    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
+                                           parameters.nonlinear_tolerance);
+
+    double relative_residual = std::numeric_limits<double>::max();
+    nonlinear_iteration = 0;
+    do
+      {
+        relative_residual =
+          assemble_and_solve_stokes(initial_stokes_residual,
+                                    nonlinear_iteration == 0 ? &initial_stokes_residual : nullptr);
+
+        pcout << "      Relative nonlinear residual (Stokes system) after nonlinear iteration " << nonlinear_iteration+1
+              << ": " << relative_residual
+              << std::endl
+              << std::endl;
+
+        if (parameters.run_postprocessors_on_nonlinear_iterations)
+          postprocess ();
+
+        ++nonlinear_iteration;
+      }
+    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
+
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_iterated_advection_and_newton_stokes (bool use_newton_iterations)
+  {
+    // Now store the linear_tolerance we started out with, because we might change
+    // it within this timestep.
+    const double begin_linear_tolerance = parameters.linear_stokes_solver_tolerance;
+    double initial_temperature_residual = 0;
+    std::vector<double> initial_composition_residual (parameters.n_compositional_fields,0);
+
+    DefectCorrectionResiduals dcr;
+    dcr.initial_residual = 1;
+
+    dcr.velocity_residual = 0;
+    dcr.pressure_residual = 0;
+    dcr.residual = 1;
+    dcr.residual_old = 1;
+
+    dcr.switch_initial_residual = 1;
+    dcr.newton_residual_for_derivative_scaling_factor = 1;
+
+    bool use_picard = true;
+
+    const Newton::Parameters::Stabilization starting_preconditioner_stabilization = newton_handler->parameters.preconditioner_stabilization;
+    const Newton::Parameters::Stabilization starting_velocity_block_stabilization = newton_handler->parameters.velocity_block_stabilization;
+
+    const unsigned int max_nonlinear_iterations =
+      (pre_refinement_step < parameters.initial_adaptive_refinement)
+      ?
+      std::min(parameters.max_nonlinear_iterations,
+               parameters.max_nonlinear_iterations_in_prerefinement)
+      :
+      parameters.max_nonlinear_iterations;
+
+    // Now iterate out the nonlinearities.
+    dcr.stokes_residuals = std::pair<double,double>  (numbers::signaling_nan<double>(),
+                                                      numbers::signaling_nan<double>());
+
+    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
+                                           parameters.nonlinear_tolerance);
+
+    SolverControl nonlinear_solver_control_picard(newton_handler->parameters.max_pre_newton_nonlinear_iterations,
+                                                  newton_handler->parameters.nonlinear_switch_tolerance);
+
+    double relative_residual = std::numeric_limits<double>::max();
+    nonlinear_iteration = 0;
+
+    do
+      {
+        // Restore particles through stored copy of particle handler,
+        // but only if they have already been displaced in a nonlinear
+        // iteration (in the assemble_and_solve_composition call).
+
+        if (nonlinear_iteration > 0)
+          for (auto &particle_world : particle_worlds)
+            particle_world->restore_particles();
+
+        const double relative_temperature_residual =
+          assemble_and_solve_temperature(initial_temperature_residual,
+                                         nonlinear_iteration == 0 ? &initial_temperature_residual : nullptr);
+
+        const std::vector<double>  relative_composition_residual =
+          assemble_and_solve_composition(initial_composition_residual,
+                                         nonlinear_iteration == 0 ? &initial_composition_residual : nullptr);
+
+        if (use_newton_iterations && use_picard &&
+            nonlinear_solver_control_picard.check(nonlinear_iteration, relative_residual) != SolverControl::iterate)
+          {
+            use_picard = false;
+            pcout << "   Switching from defect correction form of Picard to the Newton solver scheme." << std::endl;
+
+            /**
+             * This method allows to slowly introduce the derivatives based
+             * on the improvement of the residual. If we do not use it, we
+             * just set it so the newton_derivative_scaling_factor goes from
+             * zero to one when switching on the Newton solver.
+             */
+            if (!newton_handler->parameters.use_newton_residual_scaling_method)
+              dcr.newton_residual_for_derivative_scaling_factor = 0;
+          }
+
+        newton_handler->parameters.newton_derivative_scaling_factor
+          = (std::max(0.0,
+                      (1.0-(dcr.newton_residual_for_derivative_scaling_factor/dcr.switch_initial_residual))));
+
+        do_one_defect_correction_Stokes_step(dcr, use_picard);
+
+        double max_residual = relative_temperature_residual;
+        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+          {
+            // in models with melt migration the melt advection equation includes the divergence of the velocity
+            // and can not be expected to converge to a smaller value than the residual of the Stokes equation.
+            // thus, we set a threshold for the initial composition residual.
+            // this only plays a role if the right-hand side of the advection equation is very small.
+            const double threshold = (parameters.include_melt_transport && c == introspection.compositional_index_for_name("porosity")
+                                      ?
+                                      parameters.linear_stokes_solver_tolerance * time_step
+                                      :
+                                      0.0);
+            if (initial_composition_residual[c]>threshold)
+              max_residual = std::max(relative_composition_residual[c],max_residual);
+          }
+
+        // write the residual output in the same order as the solutions
+        pcout << "      Relative nonlinear residuals (temperature"
+              << (introspection.n_compositional_fields > 0 ? ", compositional fields" : "")
+              << ", Stokes system): " << relative_temperature_residual;
+        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
+          pcout << ", " << relative_composition_residual[c];
+        pcout << ", " << dcr.residual/dcr.initial_residual << std::endl;
+
+        relative_residual = std::max(dcr.residual/dcr.initial_residual, max_residual);
+        pcout << "      Relative nonlinear residual (total system) after nonlinear iteration " << nonlinear_iteration+1
+              << ": " << relative_residual
+              << std::endl
+              << std::endl;
+
+        if (parameters.run_postprocessors_on_nonlinear_iterations)
+          {
+            // Before postprocessing, we need to copy the actual solution into the solution vector
+            // (which is used for postprocessing)
+            solution = current_linearization_point;
+            postprocess ();
+          }
+
+        ++nonlinear_iteration;
+      }
+    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
+
+    // Reset the Newton stabilization at the end of the timestep.
+    newton_handler->parameters.preconditioner_stabilization = starting_preconditioner_stabilization;
+    newton_handler->parameters.velocity_block_stabilization = starting_velocity_block_stabilization;
+
+    // Reset the linear tolerance to what it was at the beginning of the time step.
+    parameters.linear_stokes_solver_tolerance = begin_linear_tolerance;
+
+    // When we are finished iterating, we need to set the final solution to the current linearization point,
+    // because the solution vector is used in the postprocess.
+    solution = current_linearization_point;
+
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+
+  template <int dim>
+  void Simulator<dim>::solve_single_advection_and_iterated_newton_stokes (bool use_newton_iterations)
+  {
+    // First assemble and solve the temperature and compositional fields
+    assemble_and_solve_temperature();
+    assemble_and_solve_composition();
+
+    // Now store the linear_tolerance we started out with, because we might change
+    // it within this timestep.
+    double begin_linear_tolerance = parameters.linear_stokes_solver_tolerance;
+
+    std::vector<double> initial_composition_residual (parameters.n_compositional_fields,0);
+
+    DefectCorrectionResiduals dcr;
+    dcr.initial_residual = 1;
+
+    dcr.velocity_residual = 0;
+    dcr.pressure_residual = 0;
+    dcr.residual = 1;
+    dcr.residual_old = 1;
+
+    dcr.switch_initial_residual = 1;
+    dcr.newton_residual_for_derivative_scaling_factor = 1;
+
+    bool use_picard = true;
+
+    const Newton::Parameters::Stabilization starting_preconditioner_stabilization = newton_handler->parameters.preconditioner_stabilization;
+    const Newton::Parameters::Stabilization starting_velocity_block_stabilization = newton_handler->parameters.velocity_block_stabilization;
+
+    const unsigned int max_nonlinear_iterations =
+      (pre_refinement_step < parameters.initial_adaptive_refinement)
+      ?
+      std::min(parameters.max_nonlinear_iterations,
+               parameters.max_nonlinear_iterations_in_prerefinement)
+      :
+      parameters.max_nonlinear_iterations;
+
+    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
+                                           parameters.nonlinear_tolerance);
+
+    SolverControl nonlinear_solver_control_picard(newton_handler->parameters.max_pre_newton_nonlinear_iterations,
+                                                  newton_handler->parameters.nonlinear_switch_tolerance);
+
+    // Now iterate out the nonlinearities.
+    dcr.stokes_residuals = {numbers::signaling_nan<double>(), numbers::signaling_nan<double>()};
+
+    double relative_residual = std::numeric_limits<double>::max();
+    nonlinear_iteration = 0;
+    do
+      {
+        // If we are in the Picard phase, check if we can switch to Newton
+        if (use_newton_iterations && use_picard &&
+            nonlinear_solver_control_picard.check(nonlinear_iteration, relative_residual) != SolverControl::iterate)
+          {
+            use_picard = false;
+            pcout << "   Switching from defect correction form of Picard to the Newton solver scheme." << std::endl;
+
+            /**
+             * This method allows to slowly introduce the derivatives based
+             * on the improvement of the residual. If we do not use it, we
+             * just set it so the newton_derivative_scaling_factor goes from
+             * zero to one when switching on the Newton solver.
+             */
+            if (!newton_handler->parameters.use_newton_residual_scaling_method)
+              dcr.newton_residual_for_derivative_scaling_factor = 0;
+          }
+
+        newton_handler->parameters.newton_derivative_scaling_factor
+          = (std::max(0.0,
+                      (1.0-(dcr.newton_residual_for_derivative_scaling_factor/dcr.switch_initial_residual))));
+
+        do_one_defect_correction_Stokes_step(dcr, use_picard);
+
+        relative_residual = dcr.residual/dcr.initial_residual;
+
+        pcout << "      Relative nonlinear residual (Stokes system) after nonlinear iteration " << nonlinear_iteration+1
+              << ": " << relative_residual
+              << std::endl
+              << std::endl;
+
+        if (parameters.run_postprocessors_on_nonlinear_iterations)
+          {
+            // Before postprocessing, we need to copy the actual solution into the solution vector
+            // (which is used for postprocessing)
+            solution = current_linearization_point;
+            postprocess ();
+          }
+
+        ++nonlinear_iteration;
+      }
+    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
+
+    // Reset the Newton stabilization at the end of the timestep.
+    newton_handler->parameters.preconditioner_stabilization = starting_preconditioner_stabilization;
+    newton_handler->parameters.velocity_block_stabilization = starting_velocity_block_stabilization;
+
+    // Reset the linear tolerance to what it was at the beginning of the time step.
+    parameters.linear_stokes_solver_tolerance = begin_linear_tolerance;
+
+    // When we are finished iterating, we need to set the final solution to the current linearization point,
+    // because the solution vector is used in the postprocess.
+    solution = current_linearization_point;
+
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_single_advection_no_stokes ()
+  {
+    assemble_and_solve_temperature();
+    assemble_and_solve_composition();
+
+    {
+      TimerOutput::Scope timer (computing_timer, "Interpolate Stokes solution");
+
+      // Assign Stokes solution
+      LinearAlgebra::BlockVector distributed_stokes_solution (introspection.index_sets.system_partitioning, mpi_communicator);
+
+      VectorFunctionFromVectorFunctionObject<dim> func(
+        [&](const Point<dim> &p, Vector<double> &result)
+      {
+        prescribed_stokes_solution->stokes_solution(p, result);
+      },
+      0,
+      parameters.include_melt_transport ? 2*dim+3 : dim+1, // velocity and pressure
+      introspection.n_components);
+
+      VectorTools::interpolate (*mapping, dof_handler, func, distributed_stokes_solution);
+
+      // distribute hanging node and other constraints
+      current_constraints.distribute (distributed_stokes_solution);
+
+      solution.block(introspection.block_indices.velocities) =
+        distributed_stokes_solution.block(introspection.block_indices.velocities);
+      solution.block(introspection.block_indices.pressure) =
+        distributed_stokes_solution.block(introspection.block_indices.pressure);
+
+      if (parameters.include_melt_transport)
+        {
+          const unsigned int block_u_f = introspection.variable("fluid velocity").block_index;
+          const unsigned int block_p_f = introspection.variable("fluid pressure").block_index;
+          solution.block(block_u_f) = distributed_stokes_solution.block(block_u_f);
+          solution.block(block_p_f) = distributed_stokes_solution.block(block_p_f);
+        }
+
+    }
+
+    if (parameters.run_postprocessors_on_nonlinear_iterations)
+      postprocess ();
+
+    // Setup a nonlinear solver control that only allows a single iteration
+    SolverControl nonlinear_solver_control(1,1.0);
+    // Announce that we did a single iteration, and assume we have converged
+    nonlinear_solver_control.check(1,0.0);
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+
+
+
+  template <int dim>
+  void Simulator<dim>::solve_no_advection_no_stokes ()
+  {
+    if (parameters.run_postprocessors_on_nonlinear_iterations)
+      postprocess ();
+
+    // Setup a nonlinear solver control that only allows a single iteration
+    SolverControl nonlinear_solver_control(1,1.0);
+    // Announce that we did a single iteration, and assume we have converged
+    nonlinear_solver_control.check(1,0.0);
+    signals.post_nonlinear_solver(nonlinear_solver_control);
+  }
+}
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template double Simulator<dim>::assemble_and_solve_temperature(const double &, double*); \
+  template std::vector<double> Simulator<dim>::assemble_and_solve_composition(const std::vector<double> &, std::vector<double> *); \
+  template double Simulator<dim>::assemble_and_solve_stokes(const double &, double*); \
+  template void Simulator<dim>::solve_single_advection_single_stokes(); \
+  template void Simulator<dim>::solve_no_advection_iterated_stokes(); \
+  template void Simulator<dim>::solve_no_advection_single_stokes(); \
+  template void Simulator<dim>::solve_iterated_advection_and_stokes(); \
+  template void Simulator<dim>::solve_single_advection_iterated_stokes(); \
+  template void Simulator<dim>::solve_no_advection_iterated_defect_correction_stokes(); \
+  template void Simulator<dim>::solve_single_advection_iterated_defect_correction_stokes(); \
+  template void Simulator<dim>::solve_iterated_advection_and_defect_correction_stokes(); \
+  template void Simulator<dim>::solve_iterated_advection_and_newton_stokes(bool); \
+  template void Simulator<dim>::solve_single_advection_and_iterated_newton_stokes(bool); \
+  template void Simulator<dim>::solve_single_advection_no_stokes(); \
+  template void Simulator<dim>::solve_first_timestep_only_single_stokes(); \
+  template void Simulator<dim>::solve_no_advection_no_stokes();
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/simulator/stokes_matrix_free.cc.bak b/source/simulator/stokes_matrix_free.cc.bak
new file mode 100644
index 00000000000..646e3d8437b
--- /dev/null
+++ b/source/simulator/stokes_matrix_free.cc.bak
@@ -0,0 +1,2798 @@
+/*
+  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/stokes_matrix_free.h>
+#include <aspect/citation_info.h>
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/mesh_deformation/free_surface.h>
+#include <aspect/melt.h>
+#include <aspect/newton.h>
+
+#include <deal.II/base/signaling_nan.h>
+
+#include <deal.II/dofs/dof_renumbering.h>
+#include <deal.II/dofs/dof_accessor.h>
+#include <deal.II/dofs/dof_tools.h>
+
+#include <deal.II/numerics/vector_tools.h>
+
+#include <deal.II/fe/fe_q.h>
+#include <deal.II/fe/fe_dgq.h>
+#include <deal.II/fe/fe_values.h>
+
+#include <deal.II/lac/solver_gmres.h>
+#include <deal.II/lac/read_write_vector.templates.h>
+#include <deal.II/lac/solver_idr.h>
+#include <deal.II/lac/solver_cg.h>
+#include <deal.II/lac/solver_bicgstab.h>
+
+#include <deal.II/grid/manifold.h>
+
+#include <deal.II/matrix_free/tools.h>
+
+namespace aspect
+{
+  namespace internal
+  {
+    /**
+     * Matrix-free operators must use deal.II defined vectors, while the rest of the ASPECT
+     * software is based on Trilinos vectors. Here we define functions which copy between the
+     * vector types.
+     */
+    namespace ChangeVectorTypes
+    {
+      void copy(TrilinosWrappers::MPI::Vector &out,
+                const dealii::LinearAlgebra::distributed::Vector<double> &in)
+      {
+        dealii::LinearAlgebra::ReadWriteVector<double> rwv(out.locally_owned_elements());
+        rwv.import_elements(in, VectorOperation::insert);
+        out.import_elements(rwv,VectorOperation::insert);
+      }
+
+      void copy(dealii::LinearAlgebra::distributed::Vector<double> &out,
+                const TrilinosWrappers::MPI::Vector &in)
+      {
+        dealii::LinearAlgebra::ReadWriteVector<double> rwv;
+        rwv.reinit(in);
+        out.import(rwv, VectorOperation::insert);
+      }
+
+      void copy(TrilinosWrappers::MPI::BlockVector &out,
+                const dealii::LinearAlgebra::distributed::BlockVector<double> &in)
+      {
+        const unsigned int n_blocks = in.n_blocks();
+        for (unsigned int b=0; b<n_blocks; ++b)
+          copy(out.block(b),in.block(b));
+      }
+
+      void copy(dealii::LinearAlgebra::distributed::BlockVector<double> &out,
+                const TrilinosWrappers::MPI::BlockVector &in)
+      {
+        const unsigned int n_blocks = in.n_blocks();
+        for (unsigned int b=0; b<n_blocks; ++b)
+          copy(out.block(b),in.block(b));
+      }
+    }
+
+
+    /**
+     * Implement the block Schur preconditioner for the Stokes system.
+     */
+    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
+              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
+    class BlockSchurGMGPreconditioner : public Subscriptor
+    {
+      public:
+        /**
+         * @brief Constructor
+         *
+         * @param Stokes_matrix The entire Stokes matrix
+         * @param A_block The A block of the Stokes matrix
+         * @param Schur_complement_block The matrix which describes the Schur complement approximation
+         * @param A_block_preconditioner Preconditioner object for the matrix A.
+         * @param Schur_complement_preconditioner Preconditioner object for the Schur complement.
+         * @param do_solve_A A flag indicating whether we should actually solve with
+         *     the matrix $A_block$, or only apply one preconditioner step with it.
+         * @param do_solve_Schur_complement A flag indicating whether we should actually solve with
+         *     the matrix $Schur_complement_block$, or only apply one preconditioner step with it.
+         * @param A_block_is_symmetric A flag indicating whether the A block is symmetric.
+         * @param A_block_tolerance The tolerance for the CG solver which computes
+         *     the inverse of the A block.
+         * @param Schur_complement_tolerance The tolerance for the CG solver which computes
+         *     the inverse of the Schur complement block (Schur complement approximation matrix).
+         */
+        BlockSchurGMGPreconditioner (const StokesMatrixType                  &Stokes_matrix,
+                                     const ABlockMatrixType                  &A_block,
+                                     const SchurComplementMatrixType         &Schur_complement_block,
+                                     const ABlockPreconditionerType          &A_block_preconditioner,
+                                     const SchurComplementPreconditionerType &Schur_complement_preconditioner,
+                                     const bool                               do_solve_A,
+                                     const bool                               do_solve_Schur_complement,
+                                     const bool                               A_block_is_symmetric,
+                                     const double                             A_block_tolerance,
+                                     const double                             Schur_complement_tolerance);
+
+        /**
+         * Matrix vector product with this preconditioner object.
+         */
+        void vmult (dealii::LinearAlgebra::distributed::BlockVector<double>       &dst,
+                    const dealii::LinearAlgebra::distributed::BlockVector<double> &src) const;
+
+        unsigned int n_iterations_A_block() const;
+        unsigned int n_iterations_Schur_complement() const;
+
+
+      private:
+        /**
+         * References to the various matrix object this preconditioner works on.
+         */
+        const StokesMatrixType                  &stokes_matrix;
+        const ABlockMatrixType                  &A_block;
+        const SchurComplementMatrixType         &Schur_complement_block;
+        const ABlockPreconditionerType          &A_block_preconditioner;
+        const SchurComplementPreconditionerType &Schur_complement_preconditioner;
+
+        /**
+         * Whether to actually invert the $\tilde M$ or $\tilde A$ of the preconditioner matrix
+         * or to just apply a single preconditioner step with it.
+         */
+        const bool                                                      do_solve_A;
+        const bool                                                      do_solve_Schur_complement;
+        const bool                                                      A_block_is_symmetric;
+        mutable unsigned int                                            n_iterations_A_;
+        mutable unsigned int                                            n_iterations_Schur_complement_;
+        const double                                                    A_block_tolerance;
+        const double                                                    Schur_complement_tolerance;
+        mutable dealii::LinearAlgebra::distributed::BlockVector<double> utmp;
+    };
+
+    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
+              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
+    BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType,
+                                ABlockPreconditionerType, SchurComplementPreconditionerType>::
+                                BlockSchurGMGPreconditioner (const StokesMatrixType                  &Stokes_matrix,
+                                                             const ABlockMatrixType                  &A_block,
+                                                             const SchurComplementMatrixType         &Schur_complement_block,
+                                                             const ABlockPreconditionerType          &A_block_preconditioner,
+                                                             const SchurComplementPreconditionerType &Schur_complement_preconditioner,
+                                                             const bool                               do_solve_A,
+                                                             const bool                               do_solve_Schur_complement,
+                                                             const bool                               A_block_symmetric,
+                                                             const double                             A_block_tolerance,
+                                                             const double                             Schur_complement_tolerance)
+                                  :
+                                  stokes_matrix                   (Stokes_matrix),
+                                  A_block                         (A_block),
+                                  Schur_complement_block          (Schur_complement_block),
+                                  A_block_preconditioner          (A_block_preconditioner),
+                                  Schur_complement_preconditioner (Schur_complement_preconditioner),
+                                  do_solve_A                      (do_solve_A),
+                                  do_solve_Schur_complement       (do_solve_Schur_complement),
+                                  A_block_is_symmetric            (A_block_symmetric),
+                                  n_iterations_A_                 (0),
+                                  n_iterations_Schur_complement_  (0),
+                                  A_block_tolerance               (A_block_tolerance),
+                                  Schur_complement_tolerance      (Schur_complement_tolerance)
+    {}
+
+    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
+              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
+    unsigned int
+    BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType,
+                                ABlockPreconditionerType, SchurComplementPreconditionerType>::
+                                n_iterations_A_block() const
+    {
+      return n_iterations_A_;
+    }
+
+    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
+              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
+    unsigned int
+    BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType,
+                                ABlockPreconditionerType, SchurComplementPreconditionerType>::
+                                n_iterations_Schur_complement() const
+    {
+      return n_iterations_Schur_complement_;
+    }
+
+    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
+              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
+    void
+    BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType,
+                                ABlockPreconditionerType, SchurComplementPreconditionerType>::
+                                vmult (dealii::LinearAlgebra::distributed::BlockVector<double>       &dst,
+                                       const dealii::LinearAlgebra::distributed::BlockVector<double>  &src) const
+    {
+      if (utmp.size()==0)
+        utmp.reinit(src);
+
+      // This needs to be done explicitly, as GMRES does not
+      // initialize the data of the vector dst before calling
+      // us. Otherwise we might use random data as our initial guess.
+      dst = 0.0;
+
+      // either solve with the Schur complement matrix (if do_solve_Schur_complement==true)
+      // or just apply one preconditioner sweep (for the first few
+      // iterations of our two-stage outer GMRES iteration)
+      if (do_solve_Schur_complement)
+        {
+          // first solve with the bottom right block, which we have built
+          // as a mass matrix with the inverse of the viscosity
+          SolverControl solver_control(100, src.block(1).l2_norm() * Schur_complement_tolerance,true);
+
+          SolverCG<dealii::LinearAlgebra::distributed::Vector<double>> solver(solver_control);
+          // Trilinos reports a breakdown
+          // in case src=dst=0, even
+          // though it should return
+          // convergence without
+          // iterating. We simply skip
+          // solving in this case.
+          if (src.block(1).l2_norm() > 1e-50)
+            {
+              try
+                {
+                  solver.solve(Schur_complement_block,
+                               dst.block(1), src.block(1),
+                               Schur_complement_preconditioner);
+                  n_iterations_Schur_complement_ += solver_control.last_step();
+                }
+              // if the solver fails, report the error from processor 0 with some additional
+              // information about its location, and throw a quiet exception on all other
+              // processors
+              catch (const std::exception &exc)
+                {
+                  Utilities::throw_linear_solver_failure_exception("iterative (bottom right) solver",
+                                                                   "BlockSchurGMGPreconditioner::vmult",
+                                                                   std::vector<SolverControl> {solver_control},
+                                                                   exc,
+                                                                   src.block(0).get_mpi_communicator());
+                }
+            }
+        }
+      else
+        {
+          Schur_complement_preconditioner.vmult(dst.block(1),src.block(1));
+          n_iterations_Schur_complement_ += 1;
+        }
+
+      dst.block(1) *= -1.0;
+
+      {
+        // the u-block of dst only contains zeros
+        stokes_matrix.vmult(utmp, dst); // B^T
+        utmp.block(0) *= -1.0;
+        utmp.block(0) += src.block(0);
+      }
+
+      // now either solve with the top left block (if do_solve_A==true)
+      // or just apply one preconditioner sweep (for the first few
+      // iterations of our two-stage outer GMRES iteration)
+      if (do_solve_A == true)
+        {
+          SolverControl solver_control(1000, utmp.block(0).l2_norm() * A_block_tolerance);
+          PrimitiveVectorMemory<dealii::LinearAlgebra::distributed::Vector<double>> mem;
+
+          try
+            {
+              if (A_block_is_symmetric)
+                {
+                  SolverCG<dealii::LinearAlgebra::distributed::Vector<double>> solver(solver_control,mem);
+                  solver.solve(A_block, dst.block(0), utmp.block(0),
+                               A_block_preconditioner);
+                }
+              else
+                {
+                  // Use BiCGStab for non-symmetric matrices.
+                  // BiCGStab can also solve indefinite systems if necessary.
+                  // Do not compute the exact residual, as this
+                  // is more expensive, and we only need an approximate solution.
+                  SolverBicgstab<dealii::LinearAlgebra::distributed::Vector<double>>
+                  solver(solver_control,
+                         mem,
+                         SolverBicgstab<dealii::LinearAlgebra::distributed::Vector<double>>::AdditionalData(/*exact_residual=*/ false));
+                  solver.solve(A_block, dst.block(0), utmp.block(0),
+                               A_block_preconditioner);
+                }
+
+              n_iterations_A_ += solver_control.last_step();
+            }
+          // if the solver fails, report the error from processor 0 with some additional
+          // information about its location, and throw a quiet exception on all other
+          // processors
+          catch (const std::exception &exc)
+            {
+              Utilities::throw_linear_solver_failure_exception("iterative (top left) solver",
+                                                               "BlockSchurGMGPreconditioner::vmult",
+                                                               std::vector<SolverControl> {solver_control},
+                                                               exc,
+                                                               src.block(0).get_mpi_communicator());
+            }
+        }
+      else
+        {
+          A_block_preconditioner.vmult (dst.block(0), utmp.block(0));
+          n_iterations_A_ += 1;
+        }
+    }
+  }
+
+
+  namespace MatrixFreeStokesOperators
+  {
+    template <int dim, typename number>
+    inline std::size_t
+    OperatorCellData<dim,number>::memory_consumption() const
+    {
+      return viscosity.memory_consumption()
+             + newton_factor_wrt_pressure_table.memory_consumption()
+             + strain_rate_table.memory_consumption()
+             + newton_factor_wrt_strain_rate_table.memory_consumption();
+    }
+
+
+
+    template <int dim, typename number>
+    void
+    OperatorCellData<dim,number>::clear()
+    {
+      enable_newton_derivatives = false;
+      viscosity.clear();
+      newton_factor_wrt_pressure_table.clear();
+      strain_rate_table.clear();
+      newton_factor_wrt_strain_rate_table.clear();
+    }
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>::StokesOperator ()
+    :
+    MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::BlockVector<number>>()
+  {}
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>::clear ()
+  {
+    this->cell_data = nullptr;
+    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::BlockVector<number>>::clear();
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>::
+  set_cell_data (const OperatorCellData<dim,number> &data)
+  {
+    this->cell_data = &data;
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>
+  ::compute_diagonal ()
+  {
+    // There is currently no need in the code for the diagonal of the entire Stokes
+    // block. If needed, one could easily construct based on the diagonal of the A
+    // block and append zeros to the end for the number of pressure DoFs.
+    Assert(false, ExcNotImplemented());
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>
+  ::local_apply (const dealii::MatrixFree<dim, number>                         &data,
+                 dealii::LinearAlgebra::distributed::BlockVector<number>       &dst,
+                 const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
+                 const std::pair<unsigned int, unsigned int>                   &cell_range) const
+  {
+    FEEvaluation<dim,degree_v,degree_v+1,dim,number> u_eval(data, 0);
+    FEEvaluation<dim,degree_v-1,degree_v+1,1,number> p_eval(data, /*dofh*/1);
+
+    const bool use_viscosity_at_quadrature_points
+      = (cell_data->viscosity.size(1) == u_eval.n_q_points);
+
+    for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
+      {
+        VectorizedArray<number> viscosity_x_2 = 2. * cell_data->viscosity(cell,0);
+
+        u_eval.reinit(cell);
+        u_eval.gather_evaluate(src.block(0), EvaluationFlags::gradients);
+
+        p_eval.reinit(cell);
+        p_eval.gather_evaluate(src.block(1), EvaluationFlags::values);
+
+        // Store the symmetric gradients of the velocity field and the
+        // values of the pressure field
+        AlignedVector<SymmetricTensor<2,dim,VectorizedArray<number>>> sym_grad_u;
+        AlignedVector<VectorizedArray<number>> val_p;
+        if (cell_data->enable_newton_derivatives)
+          {
+            sym_grad_u.resize(u_eval.n_q_points);
+            val_p.resize(u_eval.n_q_points);
+            for (const unsigned int r : u_eval.quadrature_point_indices())
+              {
+                sym_grad_u[r] = u_eval.get_symmetric_gradient(r);
+                val_p[r]      = p_eval.get_value(r);
+              }
+          }
+
+        for (const unsigned int q : u_eval.quadrature_point_indices())
+          {
+            // Only update the viscosity if a Q1 projection is used.
+            if (use_viscosity_at_quadrature_points)
+              viscosity_x_2 = 2. * cell_data->viscosity(cell,q);
+
+            const SymmetricTensor<2,dim,VectorizedArray<number>>
+            sym_grad_u_q = u_eval.get_symmetric_gradient(q);
+            const VectorizedArray<number> div_u_q = trace(sym_grad_u_q);
+            const VectorizedArray<number> val_p_q = p_eval.get_value(q);
+
+            // Terms to be tested by phi_p:
+            const VectorizedArray<number> pressure_terms =
+              -cell_data->pressure_scaling * div_u_q;
+
+            // Terms to be tested by the symmetric gradients of phi_u:
+            SymmetricTensor<2,dim,VectorizedArray<number>>
+            velocity_terms = viscosity_x_2 * sym_grad_u_q;
+
+            for (unsigned int d=0; d<dim; ++d)
+              velocity_terms[d][d] -= cell_data->pressure_scaling * val_p_q;
+
+            if (cell_data->is_compressible)
+              for (unsigned int d=0; d<dim; ++d)
+                velocity_terms[d][d] -= viscosity_x_2 / 3. * div_u_q;
+
+            // Add the Newton derivatives if required.
+            if (cell_data->enable_newton_derivatives)
+              {
+                VectorizedArray<number> deta_deps_times_sym_grad_u(0.);
+                VectorizedArray<number> eps_times_sym_grad_u(0.);
+                VectorizedArray<number> deta_dp_times_p(0.);
+                for (const unsigned int r : u_eval.quadrature_point_indices())
+                  {
+                    deta_deps_times_sym_grad_u += cell_data->newton_factor_wrt_strain_rate_table(cell,r)
+                                                  * sym_grad_u[r];
+                    deta_dp_times_p += cell_data->newton_factor_wrt_pressure_table(cell,r) * val_p[r];
+                    if (cell_data->symmetrize_newton_system)
+                      eps_times_sym_grad_u += cell_data->strain_rate_table(cell,r) * sym_grad_u[r];
+                  }
+
+                velocity_terms +=
+                  ( cell_data->symmetrize_newton_system ?
+                    ( cell_data->strain_rate_table(cell,q) * deta_deps_times_sym_grad_u +
+                      cell_data->newton_factor_wrt_strain_rate_table(cell,q) * eps_times_sym_grad_u ) :
+                    2. * cell_data->strain_rate_table(cell,q) * deta_deps_times_sym_grad_u )
+                  +
+                  2. * cell_data->strain_rate_table(cell,q) * deta_dp_times_p;
+              }
+
+            u_eval.submit_symmetric_gradient(velocity_terms, q);
+            p_eval.submit_value(pressure_terms, q);
+          }
+
+        u_eval.integrate_scatter(EvaluationFlags::gradients, dst.block(0));
+        p_eval.integrate_scatter(EvaluationFlags::values, dst.block(1));
+      }
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::StokesOperator<dim, degree_v, number>
+  ::local_apply_face(const dealii::MatrixFree<dim, number> &,
+                     dealii::LinearAlgebra::distributed::BlockVector<number> &,
+                     const dealii::LinearAlgebra::distributed::BlockVector<number> &,
+                     const std::pair<unsigned int, unsigned int> &) const
+  {
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::StokesOperator<dim, degree_v, number>
+  ::local_apply_boundary_face(const dealii::MatrixFree<dim, number> &data,
+                              dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
+                              const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
+                              const std::pair<unsigned int, unsigned int> &face_range) const
+  {
+    // Assemble the fictive stabilization stress (phi_u[i].g)*(phi_u[j].n)
+    // g=pressure_perturbation * g_hat is stored in free_surface_stabilization_term_table
+    //  n is the normal vector
+    FEFaceEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(data);
+    const unsigned int n_faces_interior = data.n_inner_face_batches();
+
+    for (unsigned int face = face_range.first; face < face_range.second; ++face)
+      {
+        const auto boundary_id = data.get_boundary_id(face);
+        if (cell_data->free_surface_boundary_indicators.find(boundary_id)
+            == cell_data->free_surface_boundary_indicators.end())
+          continue;
+
+        velocity.reinit(face);
+        velocity.gather_evaluate (src.block(0), EvaluationFlags::values);
+
+        for (const unsigned int q : velocity.quadrature_point_indices())
+          {
+            const Tensor<1, dim, VectorizedArray<number>> phi_u_i = velocity.get_value(q);
+            const auto &normal_vector = velocity.get_normal_vector(q);
+            const auto stabilization_tensor = cell_data->free_surface_stabilization_term_table(face - n_faces_interior, q);
+            const auto value_submit = -(stabilization_tensor * phi_u_i) * normal_vector;
+
+            velocity.submit_value(value_submit, q);
+          }
+        velocity.integrate_scatter(EvaluationFlags::values, dst.block(0));
+      }
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>
+  ::apply_add (dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
+               const dealii::LinearAlgebra::distributed::BlockVector<number> &src) const
+  {
+    if (cell_data->apply_stabilization_free_surface_faces)
+      MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::BlockVector<number>>::
+      data->loop(&StokesOperator::local_apply,
+                 &StokesOperator::local_apply_face,
+                 &StokesOperator::local_apply_boundary_face,
+                 this,
+                 dst,
+                 src,
+                 false, /*zero_dst_vector*/
+                 MatrixFree<dim, number>::DataAccessOnFaces::values,
+                 MatrixFree<dim, number>::DataAccessOnFaces::values);
+
+    else
+      MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::BlockVector<number>>::
+      data->cell_loop(&StokesOperator::local_apply, this, dst, src);
+  }
+
+  /**
+   * Mass matrix operator on pressure
+   */
+  template <int dim, int degree_p, typename number>
+  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>::MassMatrixOperator ()
+    :
+    MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::Vector<number>>()
+  {}
+
+
+
+  template <int dim, int degree_p, typename number>
+  void
+  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>::clear ()
+  {
+    this->cell_data = nullptr;
+    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::Vector<number>>::clear();
+  }
+
+
+
+  template <int dim, int degree_p, typename number>
+  void
+  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>::
+  set_cell_data (const OperatorCellData<dim,number> &data)
+  {
+    this->cell_data = &data;
+  }
+
+
+
+  template <int dim, int degree_p, typename number>
+  void
+  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>
+  ::local_apply (const dealii::MatrixFree<dim, number>                 &data,
+                 dealii::LinearAlgebra::distributed::Vector<number>       &dst,
+                 const dealii::LinearAlgebra::distributed::Vector<number> &src,
+                 const std::pair<unsigned int, unsigned int>           &cell_range) const
+  {
+    FEEvaluation<dim,degree_p,degree_p+2,1,number> pressure (data, /*dofh*/1);
+
+    const bool use_viscosity_at_quadrature_points
+      = (cell_data->viscosity.size(1) == pressure.n_q_points);
+
+    for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
+      {
+        VectorizedArray<number> one_over_viscosity = cell_data->viscosity(cell, 0);
+
+        const unsigned int n_components_filled = this->get_matrix_free()->n_active_entries_per_cell_batch(cell);
+
+        // The /= operator for VectorizedArray results in a floating point operation
+        // (divide by 0) since the (*viscosity)(cell) array is not completely filled.
+        // Therefore, we need to divide each entry manually.
+        for (unsigned int c=0; c<n_components_filled; ++c)
+          one_over_viscosity[c] = cell_data->pressure_scaling*cell_data->pressure_scaling/one_over_viscosity[c];
+
+        pressure.reinit (cell);
+        pressure.gather_evaluate (src, EvaluationFlags::values);
+
+        for (const unsigned int q : pressure.quadrature_point_indices())
+          {
+            // Only update the viscosity if a Q1 projection is used.
+            if (use_viscosity_at_quadrature_points)
+              {
+                one_over_viscosity = cell_data->viscosity(cell, q);
+
+                const unsigned int n_components_filled = this->get_matrix_free()->n_active_entries_per_cell_batch(cell);
+
+                for (unsigned int c=0; c<n_components_filled; ++c)
+                  one_over_viscosity[c] = cell_data->pressure_scaling*cell_data->pressure_scaling/one_over_viscosity[c];
+              }
+
+            pressure.submit_value(one_over_viscosity*
+                                  pressure.get_value(q),q);
+          }
+
+        pressure.integrate_scatter (EvaluationFlags::values, dst);
+      }
+  }
+
+
+
+  template <int dim, int degree_p, typename number>
+  void
+  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>
+  ::apply_add (dealii::LinearAlgebra::distributed::Vector<number> &dst,
+               const dealii::LinearAlgebra::distributed::Vector<number> &src) const
+  {
+    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::Vector<number>>::
+    data->cell_loop(&MassMatrixOperator::local_apply, this, dst, src);
+  }
+
+
+
+  template <int dim, int degree_p, typename number>
+  void
+  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>
+  ::compute_diagonal ()
+  {
+    this->inverse_diagonal_entries =
+      std::make_shared<DiagonalMatrix<dealii::LinearAlgebra::distributed::Vector<number>>>();
+    this->diagonal_entries =
+      std::make_shared<DiagonalMatrix<dealii::LinearAlgebra::distributed::Vector<number>>>();
+
+    dealii::LinearAlgebra::distributed::Vector<number> &inverse_diagonal =
+      this->inverse_diagonal_entries->get_vector();
+    dealii::LinearAlgebra::distributed::Vector<number> &diagonal =
+      this->diagonal_entries->get_vector();
+
+    unsigned int dummy = 0;
+    this->data->initialize_dof_vector(inverse_diagonal, /*dofh*/1);
+    this->data->initialize_dof_vector(diagonal, /*dofh*/1);
+
+    this->data->cell_loop (&MassMatrixOperator::local_compute_diagonal, this,
+                           diagonal, dummy);
+
+    this->set_constrained_entries_to_one(diagonal);
+    inverse_diagonal = diagonal;
+
+    // Finally loop over all of the computed diagonal elements and invert them.
+    // The following loop relies on the fact that inverse_diagonal.begin()/end()
+    // iterates only over the *locally owned* elements of the vector in which
+    // we store inverse_diagonal.
+    for (auto &local_element : inverse_diagonal)
+      {
+        Assert(local_element > 0.,
+               ExcMessage("No diagonal entry in a positive definite operator "
+                          "should be zero or negative."));
+        local_element = 1./local_element;
+      }
+  }
+
+
+
+  template <int dim, int degree_p, typename number>
+  void
+  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>
+  ::local_compute_diagonal (const MatrixFree<dim,number>                     &data,
+                            dealii::LinearAlgebra::distributed::Vector<number>  &dst,
+                            const unsigned int &,
+                            const std::pair<unsigned int,unsigned int>       &cell_range) const
+  {
+    FEEvaluation<dim,degree_p,degree_p+2,1,number> pressure (data, 1);
+
+    AlignedVector<VectorizedArray<number>> diagonal(pressure.dofs_per_cell);
+
+    const bool use_viscosity_at_quadrature_points
+      = (cell_data->viscosity.size(1) == pressure.n_q_points);
+
+    for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
+      {
+        VectorizedArray<number> one_over_viscosity = cell_data->viscosity(cell, 0);
+
+        const unsigned int n_components_filled = this->get_matrix_free()->n_active_entries_per_cell_batch(cell);
+
+        // The /= operator for VectorizedArray results in a floating point operation
+        // (divide by 0) since the (*viscosity)(cell) array is not completely filled.
+        // Therefore, we need to divide each entry manually.
+        for (unsigned int c=0; c<n_components_filled; ++c)
+          one_over_viscosity[c] = cell_data->pressure_scaling*cell_data->pressure_scaling/one_over_viscosity[c];
+
+        pressure.reinit (cell);
+        for (unsigned int i=0; i<pressure.dofs_per_cell; ++i)
+          {
+            for (unsigned int j=0; j<pressure.dofs_per_cell; ++j)
+              pressure.begin_dof_values()[j] = VectorizedArray<number>();
+            pressure.begin_dof_values()[i] = make_vectorized_array<number> (1.);
+
+            pressure.evaluate (EvaluationFlags::values);
+
+            for (const unsigned int q : pressure.quadrature_point_indices())
+              {
+                // Only update the viscosity if a Q1 projection is used.
+                if (use_viscosity_at_quadrature_points)
+                  {
+                    one_over_viscosity = cell_data->viscosity(cell, q);
+
+                    const unsigned int n_components_filled = this->get_matrix_free()->n_active_entries_per_cell_batch(cell);
+
+                    for (unsigned int c=0; c<n_components_filled; ++c)
+                      one_over_viscosity[c] = cell_data->pressure_scaling*cell_data->pressure_scaling/one_over_viscosity[c];
+                  }
+
+                pressure.submit_value(one_over_viscosity*
+                                      pressure.get_value(q),q);
+              }
+
+            pressure.integrate (EvaluationFlags::values);
+
+            diagonal[i] = pressure.begin_dof_values()[i];
+          }
+
+        for (unsigned int i=0; i<pressure.dofs_per_cell; ++i)
+          pressure.begin_dof_values()[i] = diagonal[i];
+        pressure.distribute_local_to_global (dst);
+      }
+  }
+
+
+
+  /**
+   * Velocity block operator
+   */
+  template <int dim, int degree_v, typename number>
+  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>::ABlockOperator ()
+    :
+    MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::Vector<number>>()
+  {}
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>::clear ()
+  {
+    this->cell_data = nullptr;
+    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::Vector<number>>::clear();
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>::
+  set_cell_data (const OperatorCellData<dim,number> &data)
+  {
+    this->cell_data = &data;
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
+  ::inner_cell_operation(FEEvaluation<dim,
+                         degree_v,
+                         degree_v+1,
+                         dim,
+                         number> &velocity) const
+  {
+    const bool use_viscosity_at_quadrature_points
+      = (cell_data->viscosity.size(1) == velocity.n_q_points);
+
+    const unsigned int cell = velocity.get_current_cell_index();
+    VectorizedArray<number> viscosity_x_2 = 2.0*cell_data->viscosity(cell, 0);
+
+    for (const unsigned int q : velocity.quadrature_point_indices())
+      {
+        // Only update the viscosity if a Q1 projection is used.
+        if (use_viscosity_at_quadrature_points)
+          viscosity_x_2 = 2.0*cell_data->viscosity(cell, q);
+
+        SymmetricTensor<2,dim,VectorizedArray<number>> sym_grad_u =
+          velocity.get_symmetric_gradient (q);
+        sym_grad_u *= viscosity_x_2;
+
+        if (cell_data->is_compressible)
+          {
+            const VectorizedArray<number> div = trace(sym_grad_u);
+            for (unsigned int d=0; d<dim; ++d)
+              sym_grad_u[d][d] -= 1.0/3.0*div;
+          }
+
+        velocity.submit_symmetric_gradient(sym_grad_u, q);
+      }
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
+  ::cell_operation(FEEvaluation<dim,
+                   degree_v,
+                   degree_v+1,
+                   dim,
+                   number> &velocity) const
+  {
+    velocity.evaluate (EvaluationFlags::gradients);
+    this->inner_cell_operation(velocity);
+    velocity.integrate(EvaluationFlags::gradients);
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
+  ::local_apply (const dealii::MatrixFree<dim, number>                 &data,
+                 dealii::LinearAlgebra::distributed::Vector<number>       &dst,
+                 const dealii::LinearAlgebra::distributed::Vector<number> &src,
+                 const std::pair<unsigned int, unsigned int>           &cell_range) const
+  {
+    FEEvaluation<dim,degree_v,degree_v+1,dim,number> velocity (data,0);
+
+    for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
+      {
+        velocity.reinit (cell);
+
+        // Instead of calling
+        //   velocity.read_dof_values (src);
+        //   velocity.evaluate (EvaluationFlags::gradients);
+        // (the latter by calling cell_operation()), we use the more efficient
+        // combined gather_evaluate() and use inner_cell_operation().
+        velocity.gather_evaluate (src, EvaluationFlags::gradients);
+        this->inner_cell_operation(velocity);
+        velocity.integrate_scatter (EvaluationFlags::gradients, dst);
+      }
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
+  ::apply_add (dealii::LinearAlgebra::distributed::Vector<number> &dst,
+               const dealii::LinearAlgebra::distributed::Vector<number> &src) const
+  {
+    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::Vector<number>>::
+    data->cell_loop(&ABlockOperator::local_apply, this, dst, src);
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
+  ::compute_diagonal ()
+  {
+    this->inverse_diagonal_entries =
+      std::make_shared<DiagonalMatrix<dealii::LinearAlgebra::distributed::Vector<number>>>();
+    dealii::LinearAlgebra::distributed::Vector<number> &inverse_diagonal =
+      this->inverse_diagonal_entries->get_vector();
+    this->data->initialize_dof_vector(inverse_diagonal);
+
+    MatrixFreeTools::compute_diagonal(
+      *(this->get_matrix_free()),
+      inverse_diagonal,
+      &MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>::cell_operation,
+      this);
+
+    this->set_constrained_entries_to_one(inverse_diagonal);
+
+    // Finally loop over all of the computed diagonal elements and invert them.
+    // The following loop relies on the fact that inverse_diagonal.begin()/end()
+    // iterates only over the *locally owned* elements of the vector in which
+    // we store inverse_diagonal.
+    for (auto &local_element : inverse_diagonal)
+      {
+        Assert(local_element > 0.,
+               ExcMessage("No diagonal entry in a positive definite operator "
+                          "should be zero or negative."));
+        local_element = 1./local_element;
+      }
+  }
+
+
+
+  template <int dim, int degree_v, typename number>
+  void
+  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
+  ::set_diagonal (const dealii::LinearAlgebra::distributed::Vector<number> &diag)
+  {
+    this->inverse_diagonal_entries =
+      std::make_shared<DiagonalMatrix<dealii::LinearAlgebra::distributed::Vector<number>>>();
+    dealii::LinearAlgebra::distributed::Vector<number> &inverse_diagonal =
+      this->inverse_diagonal_entries->get_vector();
+    this->data->initialize_dof_vector(inverse_diagonal);
+
+    inverse_diagonal = diag;
+
+    this->set_constrained_entries_to_one(inverse_diagonal);
+
+    // Finally loop over all of the computed diagonal elements and invert them.
+    // The following loop relies on the fact that inverse_diagonal.begin()/end()
+    // iterates only over the *locally owned* elements of the vector in which
+    // we store inverse_diagonal.
+    for (auto &local_element : inverse_diagonal)
+      {
+        Assert(local_element > 0.,
+               ExcMessage("No diagonal entry in a positive definite operator "
+                          "should be zero or negative."));
+        local_element = 1./local_element;
+      }
+  }
+
+
+
+  template <int dim>
+  void StokesMatrixFreeHandler<dim>::declare_parameters(ParameterHandler &prm)
+  {
+    StokesMatrixFreeHandlerImplementation<dim,2>::declare_parameters(prm);
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  void
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::declare_parameters(ParameterHandler &prm)
+  {
+    prm.enter_subsection ("Solver parameters");
+    prm.enter_subsection ("Matrix Free");
+    {
+      prm.declare_entry ("Output details", "false",
+                         Patterns::Bool(),
+                         "Turns on extra information for the matrix free GMG solver to be printed.");
+      prm.declare_entry ("Execute solver timings", "false",
+                         Patterns::Bool(),
+                         "Executes different parts of the Stokes solver repeatedly and print timing information. "
+                         "This is for internal benchmarking purposes: It is useful if you want to see how the solver "
+                         "performs. Otherwise, you don't want to enable this, since it adds additional computational cost "
+                         "to get the timing information.");
+    }
+    prm.leave_subsection ();
+    prm.leave_subsection ();
+
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  void StokesMatrixFreeHandlerImplementation<dim,velocity_degree>::parse_parameters(ParameterHandler &prm)
+  {
+    prm.enter_subsection ("Solver parameters");
+    prm.enter_subsection ("Matrix Free");
+    {
+      print_details = prm.get_bool ("Output details");
+      do_timings = prm.get_bool ("Execute solver timings");
+    }
+    prm.leave_subsection ();
+    prm.leave_subsection ();
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::StokesMatrixFreeHandlerImplementation (Simulator<dim> &simulator,
+      ParameterHandler &prm)
+    : sim(simulator),
+
+      dof_handler_v(simulator.triangulation),
+      dof_handler_p(simulator.triangulation),
+      dof_handler_projection(simulator.triangulation),
+
+      fe_v (FE_Q<dim>(sim.parameters.stokes_velocity_degree), dim),
+      fe_p (FE_Q<dim>(sim.parameters.stokes_velocity_degree-1),1),
+
+      // The finite element used to describe the viscosity on the active level
+      // and to project the viscosity to GMG levels needs to be DGQ1 if we are
+      // using a degree 1 representation of viscosity, and DGQ0 if we are using
+      // a cellwise constant average.
+      fe_projection(FE_DGQ<dim>(sim.parameters.material_averaging
+                                ==
+                                MaterialModel::MaterialAveraging::AveragingOperation::project_to_Q1
+                                ||
+                                sim.parameters.material_averaging
+                                ==
+                                MaterialModel::MaterialAveraging::AveragingOperation::project_to_Q1_only_viscosity
+                                ? 1 : 0), 1)
+  {
+    parse_parameters(prm);
+    CitationInfo::add("mf");
+
+    // Sorry, not any time soon:
+    AssertThrow(!sim.parameters.include_melt_transport, ExcNotImplemented());
+    // Not very difficult to do, but will require a different mass matrix
+    // operator:
+    AssertThrow(!sim.parameters.use_locally_conservative_discretization, ExcNotImplemented());
+
+    // sanity check:
+    Assert(sim.introspection.variable("velocity").block_index==0, ExcNotImplemented());
+    Assert(sim.introspection.variable("pressure").block_index==1, ExcNotImplemented());
+
+    // We currently only support averaging of the viscosity to a constant or Q1:
+    using avg = MaterialModel::MaterialAveraging::AveragingOperation;
+    AssertThrow((sim.parameters.material_averaging &
+                 (avg::arithmetic_average | avg::harmonic_average | avg::geometric_average
+                  | avg::pick_largest | avg::project_to_Q1 | avg::log_average
+                  | avg::harmonic_average_only_viscosity | avg::geometric_average_only_viscosity
+                  | avg::project_to_Q1_only_viscosity)) != 0,
+                ExcMessage("The matrix-free Stokes solver currently only works if material model averaging "
+                           "is enabled. If no averaging is desired, consider using ``project to Q1 only "
+                           "viscosity''."));
+
+    // Currently cannot solve compressible flow with implicit reference density
+    if (sim.material_model->is_compressible() == true)
+      AssertThrow(sim.parameters.formulation_mass_conservation !=
+                  Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile,
+                  ExcNotImplemented());
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::assemble ()
+  {
+    if (sim.mesh_deformation)
+      {
+        // Update the geometry information stored in the MatrixFree
+        // objects from the mapping.  Grab the mapping stored in the
+        // object and do not replace with sim.mapping as we have
+        // different mappings per level.
+        for (auto &obj : matrix_free_objects)
+          obj->update_mapping(*obj->get_mapping_info().mapping);
+      }
+
+    evaluate_material_model();
+
+    correct_stokes_rhs();
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::evaluate_material_model ()
+  {
+    dealii::LinearAlgebra::distributed::Vector<double> active_viscosity_vector(dof_handler_projection.locally_owned_dofs(),
+                                                                               sim.triangulation.get_communicator());
+
+    const Quadrature<dim> &quadrature_formula = sim.introspection.quadratures.velocities;
+
+    double minimum_viscosity_local = std::numeric_limits<double>::max();
+    double maximum_viscosity_local = std::numeric_limits<double>::lowest();
+
+    // Fill the DGQ0 or DGQ1 vector of viscosity values on the active mesh
+    {
+      FEValues<dim> fe_values (*sim.mapping,
+                               sim.finite_element,
+                               quadrature_formula,
+                               update_values   |
+                               update_gradients |
+                               update_quadrature_points |
+                               update_JxW_values);
+
+      MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, sim.introspection.n_compositional_fields);
+      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+      MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, sim.introspection.n_compositional_fields);
+
+      // This function call computes a cellwise projection of data defined at quadrature points to
+      // a vector defined by the projection DoFHandler. As an input, we must define a lambda which returns
+      // a viscosity value for each quadrature point of the given cell. The projection is then stored in
+      // the active level viscosity vector provided.
+      Utilities::project_cellwise<dim, dealii::LinearAlgebra::distributed::Vector<double>>(*(sim.mapping),
+          dof_handler_projection,
+          0,
+          quadrature_formula,
+          [&](const typename DoFHandler<dim>::active_cell_iterator & cell,
+              const std::vector<Point<dim>> & /*q_points*/,
+              std::vector<double> &values) -> void
+      {
+        typename DoFHandler<dim>::active_cell_iterator FEQ_cell(&sim.triangulation,
+        cell->level(),
+        cell->index(),
+        &(sim.dof_handler));
+
+        fe_values.reinit (FEQ_cell);
+        in.reinit(fe_values, FEQ_cell, sim.introspection, sim.current_linearization_point);
+
+        // Query the material model for the active level viscosities
+        sim.material_model->fill_additional_material_model_inputs(in, sim.current_linearization_point, fe_values, sim.introspection);
+        sim.material_model->evaluate(in, out);
+
+        // If using a cellwise average for viscosity, average the values here.
+        // When the projection is computed, this will set the viscosity exactly
+        // to this averaged value.
+        if (dof_handler_projection.get_fe().degree == 0)
+          MaterialModel::MaterialAveraging::average (sim.parameters.material_averaging,
+          FEQ_cell,
+          quadrature_formula,
+          *sim.mapping,
+          in.requested_properties,
+          out);
+
+        for (unsigned int i=0; i<values.size(); ++i)
+          {
+            // Find the local max/min of the evaluated viscosities.
+            minimum_viscosity_local = std::min(minimum_viscosity_local, out.viscosities[i]);
+            maximum_viscosity_local = std::max(maximum_viscosity_local, out.viscosities[i]);
+
+            values[i] = out.viscosities[i];
+          }
+        return;
+      },
+      active_viscosity_vector);
+
+      active_viscosity_vector.compress(VectorOperation::insert);
+    }
+
+    minimum_viscosity = dealii::Utilities::MPI::min(minimum_viscosity_local, sim.triangulation.get_communicator());
+    maximum_viscosity = dealii::Utilities::MPI::max(maximum_viscosity_local, sim.triangulation.get_communicator());
+
+    FEValues<dim> fe_values_projection (*(sim.mapping),
+                                        fe_projection,
+                                        quadrature_formula,
+                                        update_values);
+
+    // Create active mesh viscosity table.
+    {
+
+      const unsigned int n_cells = stokes_matrix.get_matrix_free()->n_cell_batches();
+
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      std::vector<double> values_on_quad;
+
+      // One value per cell is required for DGQ0 projection and n_q_points
+      // values per cell for DGQ1.
+      if (dof_handler_projection.get_fe().degree == 0)
+        active_cell_data.viscosity.reinit(TableIndices<2>(n_cells, 1));
+      else if (dof_handler_projection.get_fe().degree == 1)
+        {
+          values_on_quad.resize(n_q_points);
+          active_cell_data.viscosity.reinit(TableIndices<2>(n_cells, n_q_points));
+        }
+      else
+        Assert(false, ExcInternalError());
+
+      std::vector<types::global_dof_index> local_dof_indices(fe_projection.dofs_per_cell);
+      for (unsigned int cell=0; cell<n_cells; ++cell)
+        {
+          const unsigned int n_components_filled = stokes_matrix.get_matrix_free()->n_active_entries_per_cell_batch(cell);
+
+          for (unsigned int i=0; i<n_components_filled; ++i)
+            {
+              typename DoFHandler<dim>::active_cell_iterator FEQ_cell =
+                stokes_matrix.get_matrix_free()->get_cell_iterator(cell,i);
+              typename DoFHandler<dim>::active_cell_iterator DG_cell(&(sim.triangulation),
+                                                                     FEQ_cell->level(),
+                                                                     FEQ_cell->index(),
+                                                                     &dof_handler_projection);
+              DG_cell->get_active_or_mg_dof_indices(local_dof_indices);
+
+#ifdef DEBUG
+              {
+                // Verify that all MatrixFree objects iterate over cells in the same way:
+                typename DoFHandler<dim>::active_cell_iterator s_cell =
+                  Schur_complement_block_matrix.get_matrix_free()->get_cell_iterator(cell,i,1);
+                double distance_s = s_cell->center().distance(FEQ_cell->center());
+                Assert(distance_s < 1e-10, ExcInternalError());
+
+                typename DoFHandler<dim>::active_cell_iterator A_cell =
+                  A_block_matrix.get_matrix_free()->get_cell_iterator(cell,i);
+                double distance_A = A_cell->center().distance(FEQ_cell->center());
+                Assert(distance_A < 1e-10, ExcInternalError());
+              }
+#endif
+
+              // For DGQ0, we simply use the viscosity at the single
+              // support point of the element. For DGQ1, we must project
+              // back to quadrature point values.
+              if (dof_handler_projection.get_fe().degree == 0)
+                active_cell_data.viscosity(cell, 0)[i] = active_viscosity_vector(local_dof_indices[0]);
+              else
+                {
+                  fe_values_projection.reinit(DG_cell);
+                  fe_values_projection.get_function_values(active_viscosity_vector,
+                                                           local_dof_indices,
+                                                           values_on_quad);
+
+                  // Do not allow viscosity to be greater than or less than the limits
+                  // of the evaluated viscosity on the active level.
+                  for (unsigned int q=0; q<n_q_points; ++q)
+                    active_cell_data.viscosity(cell, q)[i]
+                      = std::min(std::max(values_on_quad[q], minimum_viscosity), maximum_viscosity);
+                }
+            }
+        }
+    }
+
+    active_cell_data.is_compressible = sim.material_model->is_compressible();
+    active_cell_data.pressure_scaling = sim.pressure_scaling;
+
+    // Store viscosity tables and other data into the active level matrix-free objects.
+    stokes_matrix.set_cell_data(active_cell_data);
+
+    if (sim.parameters.n_expensive_stokes_solver_steps > 0)
+      {
+        A_block_matrix.set_cell_data(active_cell_data);
+        Schur_complement_block_matrix.set_cell_data(active_cell_data);
+      }
+
+    const unsigned int n_levels = sim.triangulation.n_global_levels();
+    level_cell_data.resize(0,n_levels-1);
+
+    MGLevelObject<dealii::LinearAlgebra::distributed::Vector<GMGNumberType>> level_viscosity_vector;
+    level_viscosity_vector.resize(0,n_levels-1);
+
+    // Project the active level viscosity vector to multilevel vector representations
+    // using MG transfer objects. This transfer is based on the same linear operator used to
+    // transfer data inside a v-cycle.
+    MGTransferMF<dim,GMGNumberType> transfer;
+
+    transfer.build(dof_handler_projection);
+
+    transfer.interpolate_to_mg(dof_handler_projection,
+                               level_viscosity_vector,
+                               active_viscosity_vector);
+
+    for (unsigned int level=0; level<n_levels; ++level)
+      {
+        level_cell_data[level].is_compressible = sim.material_model->is_compressible();
+        level_cell_data[level].pressure_scaling = sim.pressure_scaling;
+
+        // Create viscosity tables on each level.
+        const unsigned int n_cells = mg_matrices_A_block[level].get_matrix_free()->n_cell_batches();
+
+        const unsigned int n_q_points = quadrature_formula.size();
+
+        std::vector<GMGNumberType> values_on_quad;
+
+        // One value per cell is required for DGQ0 projection and n_q_points
+        // values per cell for DGQ1.
+        if (dof_handler_projection.get_fe().degree == 0)
+          level_cell_data[level].viscosity.reinit(TableIndices<2>(n_cells, 1));
+        else
+          {
+            values_on_quad.resize(n_q_points);
+            level_cell_data[level].viscosity.reinit(TableIndices<2>(n_cells, n_q_points));
+          }
+
+        std::vector<types::global_dof_index> local_dof_indices(fe_projection.dofs_per_cell);
+        for (unsigned int cell=0; cell<n_cells; ++cell)
+          {
+            const unsigned int n_components_filled = mg_matrices_A_block[level].get_matrix_free()->n_active_entries_per_cell_batch(cell);
+
+            for (unsigned int i=0; i<n_components_filled; ++i)
+              {
+                typename DoFHandler<dim>::level_cell_iterator FEQ_cell =
+                  mg_matrices_A_block[level].get_matrix_free()->get_cell_iterator(cell,i);
+                typename DoFHandler<dim>::level_cell_iterator DG_cell(&(sim.triangulation),
+                                                                      FEQ_cell->level(),
+                                                                      FEQ_cell->index(),
+                                                                      &dof_handler_projection);
+                DG_cell->get_active_or_mg_dof_indices(local_dof_indices);
+
+                // For DGQ0, we simply use the viscosity at the single
+                // support point of the element. For DGQ1, we must project
+                // back to quadrature point values.
+                if (dof_handler_projection.get_fe().degree == 0)
+                  level_cell_data[level].viscosity(cell, 0)[i] = level_viscosity_vector[level](local_dof_indices[0]);
+                else
+                  {
+                    fe_values_projection.reinit(DG_cell);
+                    fe_values_projection.get_function_values(level_viscosity_vector[level],
+                                                             local_dof_indices,
+                                                             values_on_quad);
+
+                    // Do not allow viscosity to be greater than or less than the limits
+                    // of the evaluated viscosity on the active level.
+                    for (unsigned int q=0; q<n_q_points; ++q)
+                      level_cell_data[level].viscosity(cell,q)[i]
+                        = std::min(std::max(values_on_quad[q], static_cast<GMGNumberType>(minimum_viscosity)),
+                                   static_cast<GMGNumberType>(maximum_viscosity));
+                  }
+              }
+          }
+
+        // Store viscosity tables and other data into the multigrid level matrix-free objects.
+        mg_matrices_A_block[level].set_cell_data (level_cell_data[level]);
+        mg_matrices_Schur_complement[level].set_cell_data (level_cell_data[level]);
+      }
+
+    {
+      // create active mesh tables for derivatives needed in Newton method
+      // and the strain rate.
+      if (sim.newton_handler != nullptr
+          && sim.newton_handler->parameters.newton_derivative_scaling_factor != 0)
+        {
+          const double newton_derivative_scaling_factor =
+            sim.newton_handler->parameters.newton_derivative_scaling_factor;
+
+          active_cell_data.enable_newton_derivatives = true;
+
+          // TODO: these are not implemented yet
+          for (unsigned int level=0; level<n_levels; ++level)
+            level_cell_data[level].enable_newton_derivatives = false;
+
+
+          FEValues<dim> fe_values (*sim.mapping,
+                                   sim.finite_element,
+                                   quadrature_formula,
+                                   update_values   |
+                                   update_gradients |
+                                   update_quadrature_points |
+                                   update_JxW_values);
+
+          MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, sim.introspection.n_compositional_fields);
+          MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, sim.introspection.n_compositional_fields);
+          sim.newton_handler->create_material_model_outputs(out);
+          if (sim.parameters.enable_elasticity &&
+              out.template get_additional_output<MaterialModel::ElasticOutputs<dim>>() == nullptr)
+            out.additional_outputs.push_back(std::make_unique<MaterialModel::ElasticOutputs<dim>>(out.n_evaluation_points()));
+
+          const unsigned int n_cells = stokes_matrix.get_matrix_free()->n_cell_batches();
+          const unsigned int n_q_points = quadrature_formula.size();
+
+          active_cell_data.strain_rate_table.reinit(TableIndices<2>(n_cells, n_q_points));
+          active_cell_data.newton_factor_wrt_pressure_table.reinit(TableIndices<2>(n_cells, n_q_points));
+          active_cell_data.newton_factor_wrt_strain_rate_table.reinit(TableIndices<2>(n_cells, n_q_points));
+
+          for (unsigned int cell=0; cell<n_cells; ++cell)
+            {
+              const unsigned int n_components_filled = stokes_matrix.get_matrix_free()->n_active_entries_per_cell_batch(cell);
+
+              for (unsigned int i=0; i<n_components_filled; ++i)
+                {
+                  typename DoFHandler<dim>::active_cell_iterator matrix_free_cell =
+                    stokes_matrix.get_matrix_free()->get_cell_iterator(cell,i);
+                  typename DoFHandler<dim>::active_cell_iterator simulator_cell(&(sim.triangulation),
+                                                                                matrix_free_cell->level(),
+                                                                                matrix_free_cell->index(),
+                                                                                &(sim.dof_handler));
+
+                  fe_values.reinit(simulator_cell);
+                  in.reinit(fe_values, simulator_cell, sim.introspection, sim.current_linearization_point);
+
+                  sim.material_model->fill_additional_material_model_inputs(in, sim.current_linearization_point, fe_values, sim.introspection);
+                  sim.material_model->evaluate(in, out);
+
+                  MaterialModel::MaterialAveraging::average(sim.parameters.material_averaging,
+                                                            in.current_cell,
+                                                            fe_values.get_quadrature(),
+                                                            *sim.mapping,
+                                                            in.requested_properties,
+                                                            out);
+
+                  Assert(std::isfinite(in.strain_rate[0].norm()),
+                         ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                                    "not filled by the caller."));
+
+                  const MaterialModel::MaterialModelDerivatives<dim> *derivatives
+                    = out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
+
+                  Assert(derivatives != nullptr,
+                         ExcMessage ("Error: The Newton method requires the material to "
+                                     "compute derivatives."));
+
+                  const MaterialModel::ElasticOutputs<dim> *elastic_out
+                    = out.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
+
+                  for (unsigned int q=0; q<n_q_points; ++q)
+                    {
+                      const SymmetricTensor<2,dim> effective_strain_rate =
+                        elastic_out == nullptr ? deviator(in.strain_rate[q]) : elastic_out->viscoelastic_strain_rate[q];
+
+                      // use the spd factor when the stabilization is PD or SPD.
+                      const double alpha =  (sim.newton_handler->parameters.velocity_block_stabilization
+                                             & Newton::Parameters::Stabilization::PD)
+                                            != Newton::Parameters::Stabilization::none
+                                            ?
+                                            Utilities::compute_spd_factor<dim>(out.viscosities[q],
+                                                                               effective_strain_rate,
+                                                                               derivatives->viscosity_derivative_wrt_strain_rate[q],
+                                                                               sim.newton_handler->parameters.SPD_safety_factor)
+                                            :
+                                            1.0;
+
+                      active_cell_data.newton_factor_wrt_pressure_table(cell,q)[i]
+                        = derivatives->viscosity_derivative_wrt_pressure[q] *
+                          derivatives->viscosity_derivative_averaging_weights[q] *
+                          newton_derivative_scaling_factor;
+                      Assert(std::isfinite(active_cell_data.newton_factor_wrt_pressure_table(cell,q)[i]),
+                             ExcMessage("active_cell_data.newton_factor_wrt_pressure_table is not finite: " + std::to_string(active_cell_data.newton_factor_wrt_pressure_table(cell,q)[i]) +
+                                        ". Relevant variables are derivatives->viscosity_derivative_wrt_pressure[q] = " + std::to_string(derivatives->viscosity_derivative_wrt_pressure[q]) +
+                                        ", derivatives->viscosity_derivative_averaging_weights[q] = " + std::to_string(derivatives->viscosity_derivative_averaging_weights[q]) +
+                                        ", and newton_derivative_scaling_factor = " + std::to_string(newton_derivative_scaling_factor)));
+
+                      for (unsigned int m=0; m<dim; ++m)
+                        for (unsigned int n=0; n<dim; ++n)
+                          {
+                            active_cell_data.strain_rate_table(cell, q)[m][n][i]
+                              = effective_strain_rate[m][n];
+
+                            active_cell_data.newton_factor_wrt_strain_rate_table(cell, q)[m][n][i]
+                              = derivatives->viscosity_derivative_wrt_strain_rate[q][m][n] *
+                                derivatives->viscosity_derivative_averaging_weights[q] *
+                                newton_derivative_scaling_factor * alpha;
+
+                            Assert(std::isfinite(active_cell_data.strain_rate_table(cell, q)[m][n][i]),
+                                   ExcMessage("active_cell_data.strain_rate_table has an element which is not finite: " + std::to_string(active_cell_data.strain_rate_table(cell, q)[m][n][i])));
+                            Assert(std::isfinite(active_cell_data.newton_factor_wrt_strain_rate_table(cell, q)[m][n][i]),
+                                   ExcMessage("active_cell_data.newton_factor_wrt_strain_rate_table has an element which is not finite: " + std::to_string(active_cell_data.newton_factor_wrt_strain_rate_table(cell, q)[m][n][i])));
+                          }
+                    }
+                }
+            }
+
+          // symmetrize the Newton_system when the stabilization is symmetric or SPD
+          const bool symmetrize_newton_system =
+            (sim.newton_handler->parameters.velocity_block_stabilization & Newton::Parameters::Stabilization::symmetric)
+            != Newton::Parameters::Stabilization::none;
+          active_cell_data.symmetrize_newton_system = symmetrize_newton_system;
+        }
+      else
+        {
+          // delete data used for Newton derivatives if necessary
+          // TODO: use Table::clear() once implemented in 10.0.pre
+          active_cell_data.enable_newton_derivatives = false;
+          active_cell_data.newton_factor_wrt_pressure_table.reinit(TableIndices<2>(0,0));
+          active_cell_data.strain_rate_table.reinit(TableIndices<2>(0,0));
+          active_cell_data.newton_factor_wrt_strain_rate_table.reinit(TableIndices<2>(0,0));
+
+          for (unsigned int level=0; level<n_levels; ++level)
+            level_cell_data[level].enable_newton_derivatives = false;
+        }
+    }
+
+    {
+      // Create active mesh tables to store the product of the pressure perturbation and
+      // the normalized gravity used in the free surface stabilization.
+      // Currently, mutilevel is not implemented yet, it may slow down the convergence.
+
+      // TODO: implement multilevel surface terms for the free surface stabilization.
+
+      active_cell_data.apply_stabilization_free_surface_faces = sim.mesh_deformation
+                                                                && !sim.mesh_deformation->get_free_surface_boundary_indicators().empty();
+      if (active_cell_data.apply_stabilization_free_surface_faces == true)
+        {
+          const double free_surface_theta = sim.mesh_deformation->get_free_surface_theta();
+
+          const Quadrature<dim-1> &face_quadrature_formula = sim.introspection.face_quadratures.velocities;
+
+          const unsigned int n_face_q_points = face_quadrature_formula.size();
+
+          // We need the gradients for the material model inputs.
+          FEFaceValues<dim> fe_face_values (*sim.mapping,
+                                            sim.finite_element,
+                                            face_quadrature_formula,
+                                            update_values   |
+                                            update_gradients |
+                                            update_quadrature_points |
+                                            update_JxW_values);
+
+          const unsigned int n_faces_boundary = stokes_matrix.get_matrix_free()->n_boundary_face_batches();
+          const unsigned int n_faces_interior = stokes_matrix.get_matrix_free()->n_inner_face_batches();
+
+          active_cell_data.free_surface_boundary_indicators =
+            sim.mesh_deformation->get_free_surface_boundary_indicators();
+
+          MaterialModel::MaterialModelInputs<dim> face_material_inputs(n_face_q_points, sim.introspection.n_compositional_fields);
+          face_material_inputs.requested_properties = MaterialModel::MaterialProperties::density;
+          MaterialModel::MaterialModelOutputs<dim> face_material_outputs(n_face_q_points, sim.introspection.n_compositional_fields);
+
+          active_cell_data.free_surface_stabilization_term_table.reinit(n_faces_boundary, n_face_q_points);
+
+          for (unsigned int face=n_faces_interior; face<n_faces_boundary + n_faces_interior; ++face)
+            {
+              const unsigned int n_components_filled = stokes_matrix.get_matrix_free()->n_active_entries_per_face_batch(face);
+
+              for (unsigned int i=0; i<n_components_filled; ++i)
+                {
+                  // The first element of the pair is the active cell iterator
+                  // the second element of the pair is the face number
+                  const auto cell_face_pair = stokes_matrix.get_matrix_free()->get_face_iterator(face, i, true);
+
+                  typename DoFHandler<dim>::active_cell_iterator matrix_free_cell =
+                    cell_face_pair.first;
+                  typename DoFHandler<dim>::active_cell_iterator simulator_cell(&(sim.triangulation),
+                                                                                matrix_free_cell->level(),
+                                                                                matrix_free_cell->index(),
+                                                                                &(sim.dof_handler));
+
+                  const types::boundary_id boundary_indicator = stokes_matrix.get_matrix_free()->get_boundary_id(face);
+                  Assert(boundary_indicator == simulator_cell->face(cell_face_pair.second)->boundary_id(), ExcInternalError());
+
+                  // only apply on free surface faces
+                  if (active_cell_data.free_surface_boundary_indicators.find(boundary_indicator)
+                      == active_cell_data.free_surface_boundary_indicators.end())
+                    continue;
+
+                  fe_face_values.reinit(simulator_cell, cell_face_pair.second);
+
+                  face_material_inputs.reinit  (fe_face_values,
+                                                simulator_cell,
+                                                sim.introspection,
+                                                sim.solution);
+                  face_material_inputs.requested_properties = MaterialModel::MaterialProperties::density;
+                  sim.material_model->evaluate(face_material_inputs, face_material_outputs);
+
+                  for (unsigned int q = 0; q < n_face_q_points; ++q)
+                    {
+                      const Tensor<1,dim>
+                      gravity = sim.gravity_model->gravity_vector(fe_face_values.quadrature_point(q));
+                      const double g_norm = gravity.norm();
+
+                      const Tensor<1,dim> g_hat = (g_norm == 0.0 ? Tensor<1,dim>() : gravity/g_norm);
+
+                      const double pressure_perturbation = face_material_outputs.densities[q] *
+                                                           sim.time_step *
+                                                           free_surface_theta *
+                                                           g_norm;
+                      for (unsigned int d = 0; d < dim; ++d)
+                        active_cell_data.free_surface_stabilization_term_table(face - n_faces_interior, q)[d][i]
+                          = pressure_perturbation * g_hat[d];
+                    }
+                }
+            }
+        }
+    }
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::correct_stokes_rhs()
+  {
+    // We never include Newton terms in step 0 and after that we solve with zero boundary conditions.
+    // Therefore, we don't need to include Newton terms here.
+
+    const bool is_compressible = sim.material_model->is_compressible();
+
+    dealii::LinearAlgebra::distributed::BlockVector<double> rhs_correction(2);
+    dealii::LinearAlgebra::distributed::BlockVector<double> u0(2);
+
+    stokes_matrix.initialize_dof_vector(rhs_correction);
+    stokes_matrix.initialize_dof_vector(u0);
+
+    // The vector u0 is a zero vector, but we need to ensure that it
+    // has the correct boundary values:
+    u0 = 0;
+
+#if DEAL_II_VERSION_GTE(9,6,0)
+    IndexSet stokes_dofs (sim.dof_handler.n_dofs());
+    stokes_dofs.add_range (0, u0.size());
+    const AffineConstraints<double> current_stokes_constraints
+      = sim.current_constraints.get_view (stokes_dofs);
+    current_stokes_constraints.distribute(u0);
+#else
+    sim.current_constraints.distribute(u0);
+#endif
+
+    u0.update_ghost_values();
+
+    rhs_correction = 0;
+
+    FEEvaluation<dim,velocity_degree,velocity_degree+1,dim,double>
+    velocity (*stokes_matrix.get_matrix_free(), 0);
+    FEEvaluation<dim,velocity_degree-1,velocity_degree+1,1,double>
+    pressure (*stokes_matrix.get_matrix_free(), 1);
+
+    const bool use_viscosity_at_quadrature_points
+      = (active_cell_data.viscosity.size(1) == velocity.n_q_points);
+
+    const unsigned int n_cells = stokes_matrix.get_matrix_free()->n_cell_batches();
+
+    // Much like the matrix-free apply_add() functions compute a matrix-vector
+    // product by looping over cells and applying local matrix operations,
+    // here we apply the negative of the stokes_matrix operator to u0.
+    for (unsigned int cell=0; cell<n_cells; ++cell)
+      {
+        VectorizedArray<double> viscosity_x_2 = 2.0*active_cell_data.viscosity(cell, 0);
+
+        // We must use read_dof_values_plain() as to not overwrite boundary information
+        // with the zero boundary used by the stokes_matrix operator.
+        velocity.reinit (cell);
+        velocity.read_dof_values_plain (u0.block(0));
+        velocity.evaluate (EvaluationFlags::gradients);
+
+        pressure.reinit (cell);
+        pressure.read_dof_values_plain (u0.block(1));
+        pressure.evaluate (EvaluationFlags::values);
+
+        for (const unsigned int q : velocity.quadrature_point_indices())
+          {
+            // Only update the viscosity if a Q1 projection is used.
+            if (use_viscosity_at_quadrature_points)
+              viscosity_x_2 = 2.0*active_cell_data.viscosity(cell, q);
+
+            SymmetricTensor<2,dim,VectorizedArray<double>> sym_grad_u =
+              velocity.get_symmetric_gradient (q);
+            const VectorizedArray<double> pres = pressure.get_value(q);
+            const VectorizedArray<double> div = trace(sym_grad_u);
+            pressure.submit_value(sim.pressure_scaling*div, q);
+
+            sym_grad_u *= viscosity_x_2;
+
+            for (unsigned int d=0; d<dim; ++d)
+              sym_grad_u[d][d] -= sim.pressure_scaling*pres;
+
+            if (is_compressible)
+              for (unsigned int d=0; d<dim; ++d)
+                sym_grad_u[d][d] -= viscosity_x_2/3.0*div;
+
+            velocity.submit_symmetric_gradient(-1.0*sym_grad_u, q);
+          }
+
+
+        velocity.integrate_scatter (EvaluationFlags::gradients,
+                                    rhs_correction.block(0));
+
+        pressure.integrate_scatter (EvaluationFlags::values,
+                                    rhs_correction.block(1));
+      }
+
+    if (active_cell_data.apply_stabilization_free_surface_faces)
+      {
+        const unsigned int n_faces_boundary = stokes_matrix.get_matrix_free()->n_boundary_face_batches();
+        const unsigned int n_faces_interior = stokes_matrix.get_matrix_free()->n_inner_face_batches();
+
+        FEFaceEvaluation<dim,velocity_degree,velocity_degree+1,dim,double>
+        velocity_boundary(*stokes_matrix.get_matrix_free());
+
+        for (unsigned int face=n_faces_interior; face<n_faces_boundary + n_faces_interior; ++face)
+          {
+            const auto boundary_id = stokes_matrix.get_matrix_free()->get_boundary_id(face);
+            if (active_cell_data.free_surface_boundary_indicators.find(boundary_id)
+                == active_cell_data.free_surface_boundary_indicators.end())
+              continue;
+
+            velocity_boundary.reinit(face);
+            velocity_boundary.read_dof_values_plain (u0.block(0));
+            velocity_boundary.evaluate (EvaluationFlags::values);
+
+            for (const unsigned int q : velocity_boundary.quadrature_point_indices())
+              {
+                const Tensor<1, dim, VectorizedArray<double>> phi_u_i = velocity_boundary.get_value(q);
+                const auto &normal_vector = velocity_boundary.get_normal_vector(q);
+                const auto stabilization_tensor = active_cell_data.free_surface_stabilization_term_table(face - n_faces_interior, q);
+                const auto value_submit = (stabilization_tensor * phi_u_i) * normal_vector;
+                velocity_boundary.submit_value(value_submit, q);
+
+              }
+            velocity_boundary.integrate_scatter(EvaluationFlags::values,
+                                                rhs_correction.block(0));
+          }
+      }
+
+    rhs_correction.compress(VectorOperation::add);
+
+    // Copy to the correct vector type and add the correction to the system rhs.
+    LinearAlgebra::BlockVector stokes_rhs_correction (sim.introspection.index_sets.stokes_partitioning, sim.mpi_communicator);
+    internal::ChangeVectorTypes::copy(stokes_rhs_correction,rhs_correction);
+
+    sim.system_rhs.block(0) += stokes_rhs_correction.block(0);
+    sim.system_rhs.block(1) += stokes_rhs_correction.block(1);
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  std::pair<double,double> StokesMatrixFreeHandlerImplementation<dim,velocity_degree>::solve()
+  {
+    double initial_nonlinear_residual = numbers::signaling_nan<double>();
+    double final_linear_residual      = numbers::signaling_nan<double>();
+
+    // Below we define all the objects needed to build the GMG preconditioner:
+    using VectorType = dealii::LinearAlgebra::distributed::Vector<GMGNumberType>;
+
+    // ABlock GMG Smoother: Chebyshev, degree 4. Parameter values were chosen
+    // by trial and error. We use a more powerful version of the smoother on the
+    // coarsest level than on the other levels.
+    using ASmootherType = PreconditionChebyshev<GMGABlockMatrixType,VectorType>;
+    mg::SmootherRelaxation<ASmootherType, VectorType>
+    mg_smoother_A;
+    {
+      MGLevelObject<typename ASmootherType::AdditionalData> smoother_data_A;
+      smoother_data_A.resize(0, sim.triangulation.n_global_levels()-1);
+      for (unsigned int level = 0; level<sim.triangulation.n_global_levels(); ++level)
+        {
+          if (level > 0)
+            {
+              smoother_data_A[level].smoothing_range = 15.;
+              smoother_data_A[level].degree = 4;
+              smoother_data_A[level].eig_cg_n_iterations = 10;
+            }
+          else
+            {
+              smoother_data_A[0].smoothing_range = 1e-3;
+              smoother_data_A[0].degree = 8;
+              smoother_data_A[0].eig_cg_n_iterations = 100;
+            }
+          smoother_data_A[level].preconditioner = mg_matrices_A_block[level].get_matrix_diagonal_inverse();
+        }
+      mg_smoother_A.initialize(mg_matrices_A_block, smoother_data_A);
+    }
+
+    // Schur complement matrix GMG Smoother: Chebyshev, degree 4. Parameter values
+    // were chosen by trial and error. We use a more powerful version of the smoother
+    // on the coarsest level than on the other levels.
+    using MSmootherType = PreconditionChebyshev<GMGSchurComplementMatrixType,VectorType>;
+    mg::SmootherRelaxation<MSmootherType, VectorType>
+    mg_smoother_Schur(4);
+    {
+      MGLevelObject<typename MSmootherType::AdditionalData> smoother_data_Schur;
+      smoother_data_Schur.resize(0, sim.triangulation.n_global_levels()-1);
+      for (unsigned int level = 0; level<sim.triangulation.n_global_levels(); ++level)
+        {
+          if (level > 0)
+            {
+              smoother_data_Schur[level].smoothing_range = 15.;
+              smoother_data_Schur[level].degree = 4;
+              smoother_data_Schur[level].eig_cg_n_iterations = 10;
+            }
+          else
+            {
+              smoother_data_Schur[0].smoothing_range = 1e-3;
+              smoother_data_Schur[0].degree = 8;
+              smoother_data_Schur[0].eig_cg_n_iterations = 100;
+            }
+          smoother_data_Schur[level].preconditioner = mg_matrices_Schur_complement[level].get_matrix_diagonal_inverse();
+        }
+      mg_smoother_Schur.initialize(mg_matrices_Schur_complement, smoother_data_Schur);
+    }
+
+    // Estimate the eigenvalues for the Chebyshev smoothers.
+
+    types::global_dof_index coarse_A_size = numbers::invalid_dof_index, coarse_S_size = numbers::invalid_dof_index;
+
+    //TODO: The setup for the smoother (as well as the entire GMG setup) should
+    //       be moved to an assembly timing block instead of the Stokes solve
+    //       timing block (as is currently the case).
+    for (unsigned int level = 0; level<sim.triangulation.n_global_levels(); ++level)
+      {
+        VectorType temp_velocity;
+        VectorType temp_pressure;
+        mg_matrices_A_block[level].initialize_dof_vector(temp_velocity);
+        mg_matrices_Schur_complement[level].initialize_dof_vector(temp_pressure);
+
+        mg_smoother_A[level].estimate_eigenvalues(temp_velocity);
+        mg_smoother_Schur[level].estimate_eigenvalues(temp_pressure);
+
+        if (level==0)
+          {
+            coarse_A_size = temp_velocity.size();
+            coarse_S_size = temp_pressure.size();
+          }
+      }
+
+
+    // Coarse Solver is just an application of the Chebyshev smoother setup
+    // in such a way to be a solver
+    //ABlock GMG
+    MGCoarseGridApplySmoother<VectorType> mg_coarse_A;
+    mg_coarse_A.initialize(mg_smoother_A);
+
+    //Schur complement matrix GMG
+    MGCoarseGridApplySmoother<VectorType> mg_coarse_Schur;
+    mg_coarse_Schur.initialize(mg_smoother_Schur);
+
+
+    if (print_details)
+      {
+        sim.pcout << std::endl
+                  << "    GMG coarse size A: " << coarse_A_size << ", coarse size S: " << coarse_S_size << std::endl
+                  << "    GMG n_levels: " << sim.triangulation.n_global_levels() << std::endl
+                  << "    Viscosity range: " << minimum_viscosity << " - " << maximum_viscosity << std::endl;
+
+        const double imbalance = MGTools::workload_imbalance(sim.triangulation);
+        sim.pcout << "    GMG workload imbalance: " << imbalance << std::endl
+                  << "    Stokes solver: " << std::flush;
+      }
+
+    // Interface matrices
+    // Ablock GMG
+    MGLevelObject<MatrixFreeOperators::MGInterfaceOperator<GMGABlockMatrixType>> mg_interface_matrices_A;
+    mg_interface_matrices_A.resize(0, sim.triangulation.n_global_levels()-1);
+    for (unsigned int level=0; level<sim.triangulation.n_global_levels(); ++level)
+      mg_interface_matrices_A[level].initialize(mg_matrices_A_block[level]);
+    mg::Matrix<VectorType> mg_interface_A(mg_interface_matrices_A);
+
+    // Schur complement matrix GMG
+    MGLevelObject<MatrixFreeOperators::MGInterfaceOperator<GMGSchurComplementMatrixType>> mg_interface_matrices_Schur;
+    mg_interface_matrices_Schur.resize(0, sim.triangulation.n_global_levels()-1);
+    for (unsigned int level=0; level<sim.triangulation.n_global_levels(); ++level)
+      mg_interface_matrices_Schur[level].initialize(mg_matrices_Schur_complement[level]);
+    mg::Matrix<VectorType> mg_interface_Schur(mg_interface_matrices_Schur);
+
+    // MG Matrix
+    mg::Matrix<VectorType> mg_matrix_A(mg_matrices_A_block);
+    mg::Matrix<VectorType> mg_matrix_Schur(mg_matrices_Schur_complement);
+
+    // MG object
+    // ABlock GMG
+    Multigrid<VectorType> mg_A(mg_matrix_A,
+                               mg_coarse_A,
+                               mg_transfer_A_block,
+                               mg_smoother_A,
+                               mg_smoother_A);
+    mg_A.set_edge_matrices(mg_interface_A, mg_interface_A);
+
+    // Schur complement matrix GMG
+    Multigrid<VectorType> mg_Schur(mg_matrix_Schur,
+                                   mg_coarse_Schur,
+                                   mg_transfer_Schur_complement,
+                                   mg_smoother_Schur,
+                                   mg_smoother_Schur);
+    mg_Schur.set_edge_matrices(mg_interface_Schur, mg_interface_Schur);
+
+    // GMG Preconditioner for ABlock and Schur complement
+    using GMGPreconditioner = PreconditionMG<dim, VectorType, MGTransferMF<dim,GMGNumberType>>;
+    GMGPreconditioner prec_A(dof_handler_v, mg_A, mg_transfer_A_block);
+    GMGPreconditioner prec_Schur(dof_handler_p, mg_Schur, mg_transfer_Schur_complement);
+
+
+    // Many parts of the solver depend on the block layout (velocity = 0,
+    // pressure = 1). For example the linearized_stokes_initial_guess vector or the StokesBlock matrix
+    // wrapper. Let us make sure that this holds (and shorten their names):
+    const unsigned int block_vel = sim.introspection.block_indices.velocities;
+    const unsigned int block_p = (sim.parameters.include_melt_transport) ?
+                                 sim.introspection.variable("fluid pressure").block_index
+                                 : sim.introspection.block_indices.pressure;
+
+    LinearAlgebra::BlockVector distributed_stokes_solution (sim.introspection.index_sets.stokes_partitioning,
+                                                            sim.mpi_communicator);
+    // extract Stokes parts of rhs vector
+    LinearAlgebra::BlockVector distributed_stokes_rhs(sim.introspection.index_sets.stokes_partitioning,
+                                                      sim.mpi_communicator);
+
+    distributed_stokes_rhs.block(block_vel) = sim.system_rhs.block(block_vel);
+    distributed_stokes_rhs.block(block_p) = sim.system_rhs.block(block_p);
+
+    Assert(block_vel == 0, ExcNotImplemented());
+    Assert(block_p == 1, ExcNotImplemented());
+    Assert(!sim.parameters.include_melt_transport
+           || sim.introspection.variable("compaction pressure").block_index == 1, ExcNotImplemented());
+
+    // create a completely distributed vector that will be used for
+    // the scaled and denormalized solution and later used as a
+    // starting guess for the linear solver
+    LinearAlgebra::BlockVector linearized_stokes_initial_guess (sim.introspection.index_sets.stokes_partitioning,
+                                                                sim.mpi_communicator);
+
+    // copy the velocity and pressure from current_linearization_point into
+    // the vector linearized_stokes_initial_guess. We need to do the copy because
+    // linearized_stokes_variables has a different
+    // layout than current_linearization_point, which also contains all the
+    // other solution variables.
+    if (sim.assemble_newton_stokes_system == false)
+      {
+        linearized_stokes_initial_guess.block (block_vel) = sim.current_linearization_point.block (block_vel);
+        linearized_stokes_initial_guess.block (block_p) = sim.current_linearization_point.block (block_p);
+
+        sim.denormalize_pressure (sim.last_pressure_normalization_adjustment,
+                                  linearized_stokes_initial_guess,
+                                  sim.current_linearization_point);
+      }
+    else
+      {
+        // The Newton solver solves for updates to variables, for which our best guess is zero when
+        // the it isn't the first nonlinear iteration. When it is the first nonlinear iteration, we
+        // have to assemble the full (non-defect correction) Picard, to get the boundary conditions
+        // right in combination with being able to use the initial guess optimally. So we may never
+        // end up here when it is the first nonlinear iteration.
+        Assert(sim.nonlinear_iteration != 0,
+               ExcMessage ("The Newton solver may not be active in the first nonlinear iteration"));
+
+        linearized_stokes_initial_guess.block (block_vel) = 0;
+        linearized_stokes_initial_guess.block (block_p) = 0;
+      }
+
+    sim.current_constraints.set_zero (linearized_stokes_initial_guess);
+    linearized_stokes_initial_guess.block (block_p) /= sim.pressure_scaling;
+
+    double solver_tolerance = 0;
+    if (sim.assemble_newton_stokes_system == false)
+      {
+        // (ab)use the distributed solution vector to temporarily put a residual in
+        // (we don't care about the residual vector -- all we care about is the
+        // value (number) of the initial residual). The initial residual is returned
+        // to the caller (for nonlinear computations). This value is computed before
+        // the solve because we want to compute || A^{k+1} U^k - F^{k+1} ||, which is
+        // the nonlinear residual. Because the place where the nonlinear residual is
+        // checked against the nonlinear tolerance comes after the solve, the system
+        // is solved one time too many in the case of a nonlinear Picard solver.
+
+        // We must copy between Trilinos/dealii vector types
+        dealii::LinearAlgebra::distributed::BlockVector<double> solution_copy(2);
+        dealii::LinearAlgebra::distributed::BlockVector<double> initial_copy(2);
+        dealii::LinearAlgebra::distributed::BlockVector<double> rhs_copy(2);
+
+        stokes_matrix.initialize_dof_vector(solution_copy);
+        stokes_matrix.initialize_dof_vector(initial_copy);
+        stokes_matrix.initialize_dof_vector(rhs_copy);
+
+        internal::ChangeVectorTypes::copy(solution_copy,distributed_stokes_solution);
+        internal::ChangeVectorTypes::copy(initial_copy,linearized_stokes_initial_guess);
+        internal::ChangeVectorTypes::copy(rhs_copy,distributed_stokes_rhs);
+
+        // Compute residual l2_norm
+        stokes_matrix.vmult(solution_copy,initial_copy);
+        solution_copy.sadd(-1,1,rhs_copy);
+        initial_nonlinear_residual = solution_copy.l2_norm();
+
+        // Note: the residual is computed with a zero velocity, effectively computing
+        // || B^T p - g ||, which we are going to use for our solver tolerance.
+        // We do not use the current velocity for the initial residual because
+        // this would not decrease the number of iterations if we had a better
+        // initial guess (say using a smaller timestep). But we need to use
+        // the pressure instead of only using the norm of the rhs, because we
+        // are only interested in the part of the rhs not balanced by the static
+        // pressure (the current pressure is a good approximation for the static
+        // pressure).
+        initial_copy.block(0) = 0.;
+        stokes_matrix.vmult(solution_copy,initial_copy);
+        solution_copy.block(0).sadd(-1,1,rhs_copy.block(0));
+
+        const double residual_u = solution_copy.block(0).l2_norm();
+
+        const double residual_p = rhs_copy.block(1).l2_norm();
+
+        solver_tolerance = sim.parameters.linear_stokes_solver_tolerance *
+                           std::sqrt(residual_u*residual_u+residual_p*residual_p);
+      }
+    else
+      {
+        // if we are solving for the Newton update, then the initial guess of the solution
+        // vector is the zero vector, and the starting (nonlinear) residual is simply
+        // the norm of the (Newton) right hand side vector
+        const double residual_u = distributed_stokes_rhs.block(0).l2_norm();
+        const double residual_p = distributed_stokes_rhs.block(1).l2_norm();
+        solver_tolerance = sim.parameters.linear_stokes_solver_tolerance *
+                           std::sqrt(residual_u*residual_u+residual_p*residual_p);
+
+        // as described in the documentation of the function, the initial
+        // nonlinear residual for the Newton method is computed by just
+        // taking the norm of the right hand side
+        initial_nonlinear_residual = std::sqrt(residual_u*residual_u+residual_p*residual_p);
+      }
+
+    // Now overwrite the solution vector again with the current best guess
+    // to solve the linear system
+    distributed_stokes_solution = linearized_stokes_initial_guess;
+
+    // Again, copy solution and rhs vectors to solve with matrix-free operators
+    dealii::LinearAlgebra::distributed::BlockVector<double> solution_copy(2);
+    dealii::LinearAlgebra::distributed::BlockVector<double> rhs_copy(2);
+
+    stokes_matrix.initialize_dof_vector(solution_copy);
+    stokes_matrix.initialize_dof_vector(rhs_copy);
+
+    internal::ChangeVectorTypes::copy(solution_copy,distributed_stokes_solution);
+    internal::ChangeVectorTypes::copy(rhs_copy,distributed_stokes_rhs);
+
+    // create Solver controls for the cheap and expensive solver phase
+    SolverControl solver_control_cheap (sim.parameters.n_cheap_stokes_solver_steps,
+                                        solver_tolerance, true);
+    SolverControl solver_control_expensive (sim.parameters.n_expensive_stokes_solver_steps,
+                                            solver_tolerance);
+
+    solver_control_cheap.enable_history_data();
+    solver_control_expensive.enable_history_data();
+
+    // create a cheap preconditioner that consists of only a single V-cycle
+    const internal::BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType, GMGPreconditioner, GMGPreconditioner>
+    preconditioner_cheap (stokes_matrix, A_block_matrix, Schur_complement_block_matrix,
+                          prec_A, prec_Schur,
+                          /*do_solve_A*/false,
+                          /*do_solve_Schur*/false,
+                          sim.stokes_A_block_is_symmetric(),
+                          sim.parameters.linear_solver_A_block_tolerance,
+                          sim.parameters.linear_solver_S_block_tolerance);
+
+    // create an expensive preconditioner that solves for the A block with CG
+    const internal::BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType, GMGPreconditioner, GMGPreconditioner>
+    preconditioner_expensive (stokes_matrix, A_block_matrix, Schur_complement_block_matrix,
+                              prec_A, prec_Schur,
+                              /*do_solve_A*/true,
+                              /*do_solve_Schur*/true,
+                              sim.stokes_A_block_is_symmetric(),
+                              sim.parameters.linear_solver_A_block_tolerance,
+                              sim.parameters.linear_solver_S_block_tolerance);
+
+    PrimitiveVectorMemory<dealii::LinearAlgebra::distributed::BlockVector<double>> mem;
+
+    // Time vmult of different matrix-free operators, solver IDR with the cheap preconditioner, and
+    // solver GMRES with the cheap preconditioner. Each timing is repeated 10 times, and the
+    // function may be called a couple of times within each timing, depending on the argument repeats.
+    if (do_timings)
+      {
+        const int n_timings = 10;
+        Timer timer(sim.mpi_communicator);
+
+        auto time_this = [&](const char *name, int repeats, const std::function<void()> &body, const std::function<void()> &prepare)
+        {
+          sim.pcout << "Timing " << name << ' ' << n_timings << " time(s) and repeat "
+                    << repeats << " time(s) within each timing:" << std::endl;
+
+          body(); // warm up
+
+          double average_time = 0.;
+
+          for (int i=0; i<n_timings; ++i)
+            {
+              prepare();
+              sim.pcout << "\t... " << std::flush;
+              timer.restart();
+
+              for (int r=0; r<repeats; ++r)
+                body();
+
+              timer.stop();
+              double time = timer.wall_time();
+              const double average_time_per_timing = time/repeats;
+              sim.pcout << average_time_per_timing << std::endl;
+              average_time += average_time_per_timing;
+            }
+
+          sim.pcout << "\taverage wall time of all: "<< average_time/n_timings << " seconds" << std::endl;
+
+        };
+
+        // stokes vmult
+        {
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
+          time_this("stokes_vmult", 10,
+                    [&] ()
+          {
+            stokes_matrix.vmult(tmp_dst, tmp_src);
+          },
+          [&] ()
+          {
+            tmp_src = tmp_dst;
+          }
+                   );
+        }
+
+        // stokes preconditioner
+        {
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
+          time_this("stokes_preconditioner", 1,
+                    [&] ()
+          {
+            preconditioner_cheap.vmult(tmp_dst, tmp_src);
+          },
+          [&] ()
+          {
+            tmp_src = tmp_dst;
+          }
+                   );
+        }
+        // A preconditioner
+        {
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
+          time_this("A_preconditioner", 1,
+                    [&] ()
+          {
+            prec_A.vmult(tmp_dst.block(0), tmp_src.block(0));
+          },
+          [&] ()
+          {
+            tmp_src = tmp_dst;
+          }
+                   );
+        }
+        // S preconditioner
+        {
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
+          time_this("S_preconditioner", 5,
+                    [&] ()
+          {
+            prec_Schur.vmult(tmp_dst.block(1), tmp_src.block(1));
+          },
+          [&] ()
+          {
+            tmp_src = tmp_dst;
+          }
+                   );
+        }
+        // Solve
+        {
+          // hard-code the number of iterations here to always do cheap iterations
+          SolverControl solver_control_cheap (1000, solver_tolerance, true);
+
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
+          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
+          time_this("Stokes_solve_cheap_idr", 1,
+                    [&]
+          {
+            SolverIDR<dealii::LinearAlgebra::distributed::BlockVector<double>>
+            solver(solver_control_cheap, mem,
+            SolverIDR<dealii::LinearAlgebra::distributed::BlockVector<double>>::
+            AdditionalData(sim.parameters.idr_s_parameter));
+
+            solver.solve (stokes_matrix,
+            tmp_dst,
+            tmp_src,
+            preconditioner_cheap);
+          },
+          [&] ()
+          {
+            tmp_dst = solution_copy;
+          }
+                   );
+
+          time_this("Stokes_solve_cheap_gmres", 1,
+                    [&]
+          {
+            SolverGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>
+            solver(solver_control_cheap, mem,
+            SolverGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>::
+            AdditionalData(sim.parameters.stokes_gmres_restart_length+2,
+            true));
+
+            solver.solve (stokes_matrix,
+            tmp_dst,
+            tmp_src,
+            preconditioner_cheap);
+          },
+          [&] ()
+          {
+            tmp_dst = solution_copy;
+          }
+                   );
+        }
+      }
+
+    // step 1a: try if the simple and fast solver
+    // succeeds in n_cheap_stokes_solver_steps steps or less.
+    try
+      {
+        // if this cheaper solver is not desired, then simply short-cut
+        // the attempt at solving with the cheaper preconditioner
+        if (sim.parameters.n_cheap_stokes_solver_steps == 0)
+          throw SolverControl::NoConvergence(0,0);
+
+        // Unlike with the expensive preconditioner which uses CG solves on both the
+        // velocity and pressure space, the cheap preconditioner only contains matrix-vector
+        // products and GMG v-cycle where the smoothers, transfer operators, and coarse
+        // solvers are all defined to be linear operators which do not change from iteration
+        // to iteration. Therefore we can use non-flexible Krylov methods like GMRES or IDR(s),
+        // instead of requiring FGMRES, greatly lowing the memory requirement of the solver.
+        if (sim.parameters.stokes_krylov_type == Parameters<dim>::StokesKrylovType::gmres)
+          {
+            SolverGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>
+            solver(solver_control_cheap, mem,
+                   SolverGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>::
+                   AdditionalData(sim.parameters.stokes_gmres_restart_length+2,
+                                  true));
+
+            solver.solve (stokes_matrix,
+                          solution_copy,
+                          rhs_copy,
+                          preconditioner_cheap);
+          }
+        else if (sim.parameters.stokes_krylov_type == Parameters<dim>::StokesKrylovType::idr_s)
+          {
+            SolverIDR<dealii::LinearAlgebra::distributed::BlockVector<double>>
+            solver(solver_control_cheap, mem,
+                   SolverIDR<dealii::LinearAlgebra::distributed::BlockVector<double>>::
+                   AdditionalData(sim.parameters.idr_s_parameter));
+
+            solver.solve (stokes_matrix,
+                          solution_copy,
+                          rhs_copy,
+                          preconditioner_cheap);
+          }
+        else
+          Assert(false,ExcNotImplemented());
+
+        // Success. Print all iterations to screen (0 expensive iterations).
+        sim.pcout << (solver_control_cheap.last_step() != numbers::invalid_unsigned_int ?
+                      solver_control_cheap.last_step():
+                      0)
+                  << "+0"
+                  << " iterations." << std::endl;
+
+        final_linear_residual = solver_control_cheap.last_value();
+      }
+    // step 1b: take the stronger solver in case
+    // the simple solver failed and attempt solving
+    // it in n_expensive_stokes_solver_steps steps or less.
+    catch (const SolverControl::NoConvergence &exc)
+      {
+        // The cheap solver failed or never ran.
+        // Print the number of cheap iterations to screen to indicate we
+        // try the expensive solver next.
+        sim.pcout << (solver_control_cheap.last_step() != numbers::invalid_unsigned_int ?
+                      solver_control_cheap.last_step():
+                      0) << '+' << std::flush;
+
+        // use the value defined by the user
+        // OR
+        // at least a restart length of 100 for melt models
+        const unsigned int number_of_temporary_vectors = (sim.parameters.include_melt_transport == false ?
+                                                          sim.parameters.stokes_gmres_restart_length :
+                                                          std::max(sim.parameters.stokes_gmres_restart_length, 100U));
+
+        SolverFGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>
+        solver(solver_control_expensive, mem,
+               SolverFGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>::
+               AdditionalData(number_of_temporary_vectors));
+
+        try
+          {
+            // if no expensive steps allowed, we have failed
+            if (sim.parameters.n_expensive_stokes_solver_steps == 0)
+              {
+                sim.pcout << "0 iterations." << std::endl;
+                throw exc;
+              }
+
+            solver.solve(stokes_matrix,
+                         solution_copy,
+                         rhs_copy,
+                         preconditioner_expensive);
+
+            // Success. Print expensive iterations to screen.
+            sim.pcout << solver_control_expensive.last_step()
+                      << " iterations." << std::endl;
+
+            final_linear_residual = solver_control_expensive.last_value();
+          }
+        // if the solver fails trigger the post stokes solver signal and throw an exception
+        catch (const std::exception &exc)
+          {
+            sim.signals.post_stokes_solver(sim,
+                                           preconditioner_cheap.n_iterations_Schur_complement() + preconditioner_expensive.n_iterations_Schur_complement(),
+                                           preconditioner_cheap.n_iterations_A_block() + preconditioner_expensive.n_iterations_A_block(),
+                                           solver_control_cheap,
+                                           solver_control_expensive);
+
+            std::vector<SolverControl> solver_controls;
+            if (sim.parameters.n_cheap_stokes_solver_steps > 0)
+              solver_controls.push_back(solver_control_cheap);
+            if (sim.parameters.n_expensive_stokes_solver_steps > 0)
+              solver_controls.push_back(solver_control_expensive);
+
+            Utilities::throw_linear_solver_failure_exception("iterative Stokes solver",
+                                                             "StokesMatrixFreeHandlerImplementation::solve",
+                                                             solver_controls,
+                                                             exc,
+                                                             sim.mpi_communicator,
+                                                             sim.parameters.output_directory+"solver_history.txt");
+          }
+      }
+
+    //signal successful solver
+    sim.signals.post_stokes_solver(sim,
+                                   preconditioner_cheap.n_iterations_Schur_complement() + preconditioner_expensive.n_iterations_Schur_complement(),
+                                   preconditioner_cheap.n_iterations_A_block() + preconditioner_expensive.n_iterations_A_block(),
+                                   solver_control_cheap,
+                                   solver_control_expensive);
+
+    // distribute hanging node and other constraints
+    solution_copy.update_ghost_values();
+    internal::ChangeVectorTypes::copy(distributed_stokes_solution,solution_copy);
+
+#if DEAL_II_VERSION_GTE(9,6,0)
+    IndexSet stokes_dofs (sim.dof_handler.n_dofs());
+    stokes_dofs.add_range (0, distributed_stokes_solution.size());
+    const AffineConstraints<double> current_stokes_constraints
+      = sim.current_constraints.get_view (stokes_dofs);
+    current_stokes_constraints.distribute(distributed_stokes_solution);
+#else
+    sim.current_constraints.distribute(distributed_stokes_solution);
+#endif
+
+    // now rescale the pressure back to real physical units
+    distributed_stokes_solution.block(block_p) *= sim.pressure_scaling;
+
+    // then copy back the solution from the temporary (non-ghosted) vector
+    // into the ghosted one with all solution components
+    sim.solution.block(block_vel) = distributed_stokes_solution.block(block_vel);
+    sim.solution.block(block_p) = distributed_stokes_solution.block(block_p);
+
+    if (print_details)
+      {
+        sim.pcout << "    Schur complement preconditioner: " << preconditioner_cheap.n_iterations_Schur_complement()
+                  << '+'
+                  << preconditioner_expensive.n_iterations_Schur_complement()
+                  << " iterations." << std::endl;
+        sim.pcout << "    A block preconditioner: " << preconditioner_cheap.n_iterations_A_block()
+                  << '+'
+                  << preconditioner_expensive.n_iterations_A_block()
+                  << " iterations." << std::endl;
+      }
+
+    // do some cleanup now that we have the solution
+    sim.remove_nullspace(sim.solution, distributed_stokes_solution);
+    if (sim.assemble_newton_stokes_system == false)
+      sim.last_pressure_normalization_adjustment = sim.normalize_pressure(sim.solution);
+
+
+    // convert melt pressures
+    // TODO: We assert in the StokesMatrixFreeHandler constructor that we
+    //       are not including melt transport.
+    if (sim.parameters.include_melt_transport)
+      sim.melt_handler->compute_melt_variables(sim.system_matrix,sim.solution,sim.system_rhs);
+
+
+    return std::pair<double,double>(initial_nonlinear_residual,
+                                    final_linear_residual);
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::setup_dofs()
+  {
+    // Periodic boundary conditions with hanging nodes on the boundary currently
+    // cause the GMG not to converge. We catch this case early to provide the
+    // user with a reasonable error message:
+    {
+      bool have_periodic_hanging_nodes = false;
+      for (const auto &cell : sim.triangulation.active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (const auto f : cell->face_indices())
+            {
+              if (cell->has_periodic_neighbor(f))
+                {
+                  const auto &neighbor = cell->periodic_neighbor(f);
+                  // This way, we can only detect the case where the neighbor is coarser,
+                  // but this is fine as the other owner covers that situation:
+                  if (neighbor->level()<cell->level())
+                    have_periodic_hanging_nodes = true;
+                }
+            }
+
+      have_periodic_hanging_nodes = (dealii::Utilities::MPI::max(have_periodic_hanging_nodes ? 1 : 0, sim.triangulation.get_communicator())) == 1;
+      AssertThrow(have_periodic_hanging_nodes==false, ExcNotImplemented());
+    }
+
+    // This vector will be refilled with the new MatrixFree objects below:
+    matrix_free_objects.clear();
+
+    // Velocity DoFHandler
+    {
+      dof_handler_v.clear();
+      dof_handler_v.distribute_dofs(fe_v);
+
+      DoFRenumbering::hierarchical(dof_handler_v);
+
+      IndexSet locally_relevant_dofs;
+      DoFTools::extract_locally_relevant_dofs (dof_handler_v,
+                                               locally_relevant_dofs);
+#if DEAL_II_VERSION_GTE(9,6,0)
+      constraints_v.reinit(dof_handler_v.locally_owned_dofs(), locally_relevant_dofs);
+#else
+      constraints_v.reinit(locally_relevant_dofs);
+#endif
+
+      {
+        const auto &pbs = sim.geometry_model->get_periodic_boundary_pairs();
+
+        for (const auto &p: pbs)
+          {
+            DoFTools::make_periodicity_constraints(dof_handler_v,
+                                                   p.first.first,  // first boundary id
+                                                   p.first.second, // second boundary id
+                                                   p.second,       // cartesian direction for translational symmetry
+                                                   constraints_v);
+          }
+      }
+      DoFTools::make_hanging_node_constraints (dof_handler_v, constraints_v);
+      sim.compute_initial_velocity_boundary_constraints(constraints_v);
+      sim.compute_current_velocity_boundary_constraints(constraints_v);
+
+
+      VectorTools::compute_no_normal_flux_constraints (dof_handler_v,
+                                                       /* first_vector_component= */
+                                                       0,
+                                                       sim.boundary_velocity_manager.get_tangential_boundary_velocity_indicators(),
+                                                       constraints_v,
+                                                       *sim.mapping);
+      constraints_v.close ();
+    }
+
+    // Pressure DoFHandler
+    {
+      dof_handler_p.clear();
+      dof_handler_p.distribute_dofs(fe_p);
+
+      DoFRenumbering::hierarchical(dof_handler_p);
+
+      IndexSet locally_relevant_dofs;
+      DoFTools::extract_locally_relevant_dofs (dof_handler_p,
+                                               locally_relevant_dofs);
+      constraints_p.reinit(
+#if DEAL_II_VERSION_GTE(9,6,0)
+        dof_handler_p.locally_owned_dofs(),
+#endif
+        locally_relevant_dofs);
+      {
+        const auto &pbs = sim.geometry_model->get_periodic_boundary_pairs();
+
+        for (const auto &p: pbs)
+          {
+            DoFTools::make_periodicity_constraints(dof_handler_p,
+                                                   p.first.first,  // first boundary id
+                                                   p.first.second, // second boundary id
+                                                   p.second,       // cartesian direction for translational symmetry
+                                                   constraints_p);
+          }
+      }
+      DoFTools::make_hanging_node_constraints (dof_handler_p, constraints_p);
+      constraints_p.close();
+    }
+
+    // Coefficient transfer objects
+    {
+      dof_handler_projection.clear();
+      dof_handler_projection.distribute_dofs(fe_projection);
+
+      DoFRenumbering::hierarchical(dof_handler_projection);
+    }
+
+    // Multigrid DoF setup
+    {
+      //Ablock GMG
+      dof_handler_v.distribute_mg_dofs();
+
+      mg_constrained_dofs_A_block.clear();
+      mg_constrained_dofs_A_block.initialize(dof_handler_v);
+
+      std::set<types::boundary_id> dirichlet_boundary = sim.boundary_velocity_manager.get_zero_boundary_velocity_indicators();
+      for (const auto &it: sim.boundary_velocity_manager.get_active_boundary_velocity_names())
+        {
+          const types::boundary_id bdryid = it.first;
+          const std::string component=it.second.first;
+
+          if (component.length()>0)
+            {
+              std::vector<bool> mask(fe_v.n_components(), false);
+              for (const auto &direction : component)
+                {
+                  switch (direction)
+                    {
+                      case 'x':
+                        mask[0] = true;
+                        break;
+                      case 'y':
+                        mask[1] = true;
+                        break;
+                      case 'z':
+                        // we must be in 3d, or 'z' should never have gotten through
+                        Assert (dim==3, ExcInternalError());
+                        if (dim==3)
+                          mask[2] = true;
+                        break;
+                      default:
+                        Assert (false, ExcInternalError());
+                    }
+                }
+              mg_constrained_dofs_A_block.make_zero_boundary_constraints(dof_handler_v, {bdryid}, ComponentMask(mask));
+            }
+          else
+            {
+              // no mask given: add at the end
+              dirichlet_boundary.insert(bdryid);
+            }
+        }
+
+      // Unconditionally call this function, even if the set is empty. Otherwise, the data structure
+      // for boundary indices will not be created (if mesh has no Dirichlet conditions).
+      mg_constrained_dofs_A_block.make_zero_boundary_constraints(dof_handler_v, dirichlet_boundary);
+
+      //Schur complement matrix GMG
+      dof_handler_p.distribute_mg_dofs();
+
+      mg_constrained_dofs_Schur_complement.clear();
+      mg_constrained_dofs_Schur_complement.initialize(dof_handler_p);
+
+      dof_handler_projection.distribute_mg_dofs();
+    }
+
+    // Setup the matrix-free operators
+    std::shared_ptr<MatrixFree<dim,double>> matrix_free = std::make_shared<MatrixFree<dim,double>>();
+    matrix_free_objects.push_back(matrix_free);
+
+    // Matrixfree object
+    {
+      typename MatrixFree<dim,double>::AdditionalData additional_data;
+      additional_data.tasks_parallel_scheme = MatrixFree<dim,double>::AdditionalData::none;
+      additional_data.mapping_update_flags = (update_gradients | update_JxW_values);
+
+      if (sim.mesh_deformation
+          && !sim.mesh_deformation->get_free_surface_boundary_indicators().empty())
+        additional_data.mapping_update_flags_boundary_faces =
+          (update_values  |
+           update_quadrature_points |
+           update_normal_vectors |
+           update_JxW_values);
+
+      std::vector<const DoFHandler<dim>*> stokes_dofs {&dof_handler_v, &dof_handler_p};
+      std::vector<const AffineConstraints<double> *> stokes_constraints {&constraints_v, &constraints_p};
+
+      matrix_free->reinit(*sim.mapping, stokes_dofs, stokes_constraints,
+                          QGauss<1>(sim.parameters.stokes_velocity_degree+1), additional_data);
+    }
+
+    // Stokes matrix
+    {
+      stokes_matrix.clear();
+      stokes_matrix.initialize(matrix_free);
+    }
+
+    // ABlock matrix
+    {
+      A_block_matrix.clear();
+      std::vector<unsigned int> selected = {0}; // select velocity DoFHandler
+      A_block_matrix.initialize(matrix_free, selected);
+    }
+
+    // Schur complement block matrix
+    {
+      Schur_complement_block_matrix.clear();
+      std::vector< unsigned int > selected = {1}; // select pressure DoFHandler
+      Schur_complement_block_matrix.initialize(matrix_free, selected , selected);
+    }
+
+    // GMG matrices
+    {
+      const unsigned int n_levels = sim.triangulation.n_global_levels();
+
+      mg_matrices_Schur_complement.clear_elements();
+      mg_matrices_Schur_complement.resize(0, n_levels-1);
+      mg_matrices_A_block.clear_elements();
+      mg_matrices_A_block.resize(0, n_levels-1);
+
+      for (unsigned int level=0; level<n_levels; ++level)
+        {
+          AffineConstraints<double> level_constraints_v;
+          AffineConstraints<double> level_constraints_p;
+          const Mapping<dim> &mapping =
+            (sim.mesh_deformation) ? sim.mesh_deformation->get_level_mapping(level) : *sim.mapping;
+
+          {
+            IndexSet relevant_dofs;
+            DoFTools::extract_locally_relevant_level_dofs(dof_handler_v, level, relevant_dofs);
+#if DEAL_II_VERSION_GTE(9,6,0)
+            level_constraints_v.reinit(dof_handler_v.locally_owned_mg_dofs(level), relevant_dofs);
+            for (const auto index : mg_constrained_dofs_A_block.get_boundary_indices(level))
+              level_constraints_v.constrain_dof_to_zero(index);
+#else
+            level_constraints_v.reinit(relevant_dofs);
+            level_constraints_v.add_lines(mg_constrained_dofs_A_block.get_boundary_indices(level));
+#endif
+            level_constraints_v.close();
+
+            std::set<types::boundary_id> no_flux_boundary
+              = sim.boundary_velocity_manager.get_tangential_boundary_velocity_indicators();
+            if (!no_flux_boundary.empty())
+              {
+                AffineConstraints<double> user_level_constraints;
+#if DEAL_II_VERSION_GTE(9,6,0)
+                user_level_constraints.reinit(dof_handler_v.locally_owned_mg_dofs(level), relevant_dofs);
+#else
+                user_level_constraints.reinit(relevant_dofs);
+#endif
+                const IndexSet &refinement_edge_indices =
+                  mg_constrained_dofs_A_block.get_refinement_edge_indices(level);
+                dealii::VectorTools::compute_no_normal_flux_constraints_on_level(
+                  dof_handler_v,
+                  0,
+                  no_flux_boundary,
+                  user_level_constraints,
+                  mapping,
+                  refinement_edge_indices,
+                  level);
+
+                user_level_constraints.close();
+                mg_constrained_dofs_A_block.add_user_constraints(level,user_level_constraints);
+
+                // let Dirichlet values win over no normal flux:
+                level_constraints_v.merge(user_level_constraints, AffineConstraints<double>::left_object_wins);
+                level_constraints_v.close();
+              }
+          }
+          {
+            IndexSet relevant_dofs;
+            DoFTools::extract_locally_relevant_level_dofs(dof_handler_p, level, relevant_dofs);
+
+#if DEAL_II_VERSION_GTE(9,6,0)
+            level_constraints_p.reinit(dof_handler_p.locally_owned_mg_dofs(level), relevant_dofs);
+#else
+            level_constraints_p.reinit(relevant_dofs);
+#endif
+
+            level_constraints_p.close();
+          }
+
+          std::shared_ptr<MatrixFree<dim,GMGNumberType>> matrix_free_level = std::make_shared<MatrixFree<dim,GMGNumberType>>();
+          matrix_free_objects.push_back(matrix_free_level);
+
+          {
+            typename MatrixFree<dim,GMGNumberType>::AdditionalData additional_data;
+            additional_data.tasks_parallel_scheme = MatrixFree<dim,GMGNumberType>::AdditionalData::none;
+            additional_data.mapping_update_flags = (update_gradients | update_JxW_values);
+            additional_data.mg_level = level;
+
+            std::vector<const DoFHandler<dim>*> stokes_dofs {&dof_handler_v, &dof_handler_p};
+            std::vector<const AffineConstraints<double> *> stokes_constraints {&level_constraints_v,&level_constraints_p};
+
+            matrix_free_level->reinit(mapping,
+                                      stokes_dofs, stokes_constraints,
+                                      QGauss<1>(sim.parameters.stokes_velocity_degree+1),
+                                      additional_data);
+          }
+          {
+            mg_matrices_A_block[level].clear();
+            std::vector<unsigned int> selected = {0}; // select velocity DoFHandler
+            mg_matrices_A_block[level].initialize(matrix_free_level, mg_constrained_dofs_A_block, level, selected);
+          }
+          {
+            mg_matrices_Schur_complement[level].clear();
+            std::vector<unsigned int> selected = {1}; // select pressure DoFHandler
+            mg_matrices_Schur_complement[level].initialize(matrix_free_level, mg_constrained_dofs_Schur_complement, level, selected);
+          }
+        }
+    }
+
+    // Build MG transfer
+    mg_transfer_A_block.clear();
+    mg_transfer_A_block.initialize_constraints(mg_constrained_dofs_A_block);
+    mg_transfer_A_block.build(dof_handler_v);
+
+    mg_transfer_Schur_complement.clear();
+    mg_transfer_Schur_complement.initialize_constraints(mg_constrained_dofs_Schur_complement);
+    mg_transfer_Schur_complement.build(dof_handler_p);
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::build_preconditioner()
+  {
+    TimerOutput::Scope timer (this->sim.computing_timer, "Build Stokes preconditioner");
+
+    for (unsigned int level=0; level < sim.triangulation.n_global_levels(); ++level)
+      {
+        mg_matrices_Schur_complement[level].compute_diagonal();
+        mg_matrices_A_block[level].compute_diagonal();
+      }
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  const DoFHandler<dim> &
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_dof_handler_v () const
+  {
+    return dof_handler_v;
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  const DoFHandler<dim> &
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_dof_handler_p () const
+  {
+    return dof_handler_p;
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  const DoFHandler<dim> &
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_dof_handler_projection () const
+  {
+    return dof_handler_projection;
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  const AffineConstraints<double> &
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_constraints_v() const
+  {
+    return constraints_v;
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  const AffineConstraints<double> &
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_constraints_p() const
+  {
+    return constraints_p;
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  const MGTransferMF<dim,GMGNumberType> &
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_mg_transfer_A() const
+  {
+    return mg_transfer_A_block;
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  const MGTransferMF<dim,GMGNumberType> &
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_mg_transfer_S() const
+  {
+    return mg_transfer_Schur_complement;
+  }
+
+
+
+  template <int dim, int velocity_degree>
+  std::size_t
+  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>:: get_cell_data_memory_consumption() const
+  {
+    std::size_t total = active_cell_data.memory_consumption();
+
+    for (unsigned int level=0; level<level_cell_data.max_level(); ++level)
+      total += level_cell_data[level].memory_consumption();
+
+    return total;
+  }
+
+
+
+// explicit instantiation of the functions we implement in this file
+#define INSTANTIATE(dim) \
+  template class StokesMatrixFreeHandler<dim>; \
+  template class StokesMatrixFreeHandlerImplementation<dim,2>; \
+  template class StokesMatrixFreeHandlerImplementation<dim,3>;
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/structured_data.cc.bak b/source/structured_data.cc.bak
new file mode 100644
index 00000000000..62da14cd9b8
--- /dev/null
+++ b/source/structured_data.cc.bak
@@ -0,0 +1,1952 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/global.h>
+#include <aspect/structured_data.h>
+
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/geometry_model/sphere.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/two_merged_chunks.h>
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+#include <aspect/geometry_model/initial_topography_model/ascii_data.h>
+#include <aspect/geometry_model/two_merged_chunks.h>
+
+#include <deal.II/base/exceptions.h>
+
+#include <boost/lexical_cast.hpp>
+#include <regex>
+
+#ifdef ASPECT_WITH_NETCDF
+
+#include <netcdf.h>
+#define AssertThrowNetCDF(error_code) \
+  AssertThrow(error_code == NC_NOERR, dealii::ExcMessage("A NetCDF Error with code " + std::to_string(error_code) + " occurred."))
+
+#else
+
+#define AssertThrowNetCDF(error_code) \
+  AssertThrow(false, ExcInternalError())
+
+#endif
+
+
+
+namespace aspect
+{
+  namespace Utilities
+  {
+
+    template <int dim>
+    StructuredDataLookup<dim>::StructuredDataLookup(const unsigned int n_components,
+                                                    const double scale_factor)
+      :
+      n_components(n_components),
+      data(n_components),
+      maximum_component_value(n_components),
+      scale_factor(scale_factor),
+      coordinate_values_are_equidistant(false)
+    {}
+
+
+
+    template <int dim>
+    StructuredDataLookup<dim>::StructuredDataLookup(const double scale_factor)
+      :
+      n_components(numbers::invalid_unsigned_int),
+      data(),
+      maximum_component_value(),
+      scale_factor(scale_factor),
+      coordinate_values_are_equidistant(false)
+    {}
+
+
+
+    template <int dim>
+    std::vector<std::string>
+    StructuredDataLookup<dim>::get_column_names() const
+    {
+      return data_component_names;
+    }
+
+
+
+    template <int dim>
+    bool
+    StructuredDataLookup<dim>::has_equidistant_coordinates() const
+    {
+      return coordinate_values_are_equidistant;
+    }
+
+
+
+    template <int dim>
+    const std::vector<double> &
+    StructuredDataLookup<dim>::get_interpolation_point_coordinates(const unsigned int dimension) const
+    {
+      AssertThrow(dimension < dim,
+                  ExcMessage("There is no spatial dimension number " + std::to_string(dimension)
+                             + " in the current data file."));
+
+      return coordinate_values[dimension];
+    }
+
+
+
+    template <int dim>
+    unsigned int
+    StructuredDataLookup<dim>::get_column_index_from_name(const std::string &column_name) const
+    {
+      const std::vector<std::string>::const_iterator column_position =
+        std::find(data_component_names.begin(),data_component_names.end(),column_name);
+
+      AssertThrow(column_position != data_component_names.end(),
+                  ExcMessage("There is no data column named " + column_name
+                             + " in the current data file. Please check the name and the "
+                             "first line not starting with '#' of your data file."));
+
+      return std::distance(data_component_names.begin(),column_position);
+    }
+
+    template <int dim>
+    std::string
+    StructuredDataLookup<dim>::get_column_name_from_index(const unsigned int column_index) const
+    {
+      AssertThrow(data_component_names.size() > column_index,
+                  ExcMessage("There is no data column number " + Utilities::to_string(column_index)
+                             + " in the current data file. The data file only contains "
+                             + Utilities::to_string(data_component_names.size()) + " named columns."));
+
+      return data_component_names[column_index];
+    }
+
+    template <int dim>
+    double
+    StructuredDataLookup<dim>::get_maximum_component_value(const unsigned int component) const
+    {
+      return maximum_component_value[component];
+    }
+
+
+
+    namespace
+    {
+      /**
+       * Return whether a set of coordinate points in dim space dimensions
+       * are all equidistantly spaced within some small tolerance.
+       */
+      template <int dim>
+      bool data_is_equidistant (const std::array<std::vector<double>,dim> &coordinate_values)
+      {
+        bool coordinate_values_are_equidistant = true;
+
+        for (unsigned int d=0; d<dim; ++d)
+          {
+            const double grid_spacing = coordinate_values[d][1] - coordinate_values[d][0];
+
+            for (unsigned int n = 1; n < coordinate_values[d].size(); ++n)
+              {
+                const double current_grid_spacing = coordinate_values[d][n] - coordinate_values[d][n-1];
+
+                AssertThrow(current_grid_spacing > 0.0,
+                            ExcMessage ("Coordinates in dimension "
+                                        + Utilities::int_to_string(d)
+                                        + " are not strictly ascending."));
+
+                // If spacing between coordinates changed (with a relative
+                // tolerance), keep track of that information.  Note that we do
+                // not break out of this loop in this case but run through the
+                // whole array, so that the AssertThrow above is executed for
+                // each entry to ensure increasing coordinate values.
+                if (std::abs(current_grid_spacing - grid_spacing) > 0.005*(current_grid_spacing+grid_spacing))
+                  coordinate_values_are_equidistant = false;
+              }
+          }
+
+        return coordinate_values_are_equidistant;
+      }
+    }
+
+
+    template <int dim>
+    void
+    StructuredDataLookup<dim>::reinit(const std::vector<std::string> &column_names,
+                                      std::vector<std::vector<double>> &&coordinate_values_,
+                                      std::vector<Table<dim,double>> &&data_table,
+                                      const MPI_Comm mpi_communicator,
+                                      const unsigned int root_process)
+    {
+      // If this is the root process, or if the user did not request
+      // sharing, set up the various member variables we need to compute
+      // from the input data:
+      if ((root_process == numbers::invalid_unsigned_int)
+          ||
+          ((root_process != numbers::invalid_unsigned_int)
+           &&
+           (Utilities::MPI::this_mpi_process(mpi_communicator) == root_process)))
+        {
+          Assert(coordinate_values_.size()==dim, ExcMessage("Invalid size of coordinate_values."));
+          for (unsigned int d=0; d<dim; ++d)
+            {
+              this->coordinate_values[d] = std::move(coordinate_values_[d]);
+              AssertThrow(this->coordinate_values[d].size()>1,
+                          ExcMessage("Error: At least 2 entries per coordinate direction are required."));
+              table_points[d] = this->coordinate_values[d].size();
+            }
+
+          n_components = column_names.size();
+          data_component_names = column_names;
+          Assert(data_table.size() == n_components,
+                 ExcMessage("Error: Incorrect number of columns specified."));
+          for (unsigned int c=0; c<n_components; ++c)
+            Assert(data_table[c].size() == table_points,
+                   ExcMessage("Error: One of the data tables has an incorrect size."));
+
+          // compute maximum_component_value for each component:
+          maximum_component_value = std::vector<double>(n_components,-std::numeric_limits<double>::max());
+          for (unsigned int c=0; c<n_components; ++c)
+            {
+              const std::size_t n_elements = data_table[c].n_elements();
+              for (std::size_t idx=0; idx<n_elements; ++idx)
+                maximum_component_value[c] = std::max(maximum_component_value[c], data_table[c](
+                                                        compute_table_indices(table_points, idx)));
+            }
+
+          // In case the data is specified on a grid that is equidistant
+          // in each coordinate direction, we only need to store
+          // (besides the data) the number of intervals in each direction and
+          // the begin- and end-points of the coordinates.
+          // In case the grid is not equidistant, we need to keep
+          // all the coordinates in each direction, which is more costly.
+          coordinate_values_are_equidistant = data_is_equidistant<dim> (coordinate_values);
+        }
+
+      // If the caller of this function requested it, then we have
+      // set up member variables on the root process, but not on any of
+      // the other processes. Broadcast the data to the remaining
+      // processes
+      if (root_process != numbers::invalid_unsigned_int)
+        {
+          coordinate_values                 = Utilities::MPI::broadcast (mpi_communicator,
+                                                                         coordinate_values,
+                                                                         root_process);
+          n_components                        = Utilities::MPI::broadcast (mpi_communicator,
+                                                                           n_components,
+                                                                           root_process);
+          data_component_names              = Utilities::MPI::broadcast (mpi_communicator,
+                                                                         data_component_names,
+                                                                         root_process);
+          maximum_component_value           = Utilities::MPI::broadcast (mpi_communicator,
+                                                                         maximum_component_value,
+                                                                         root_process);
+          coordinate_values_are_equidistant = Utilities::MPI::broadcast (mpi_communicator,
+                                                                         coordinate_values_are_equidistant,
+                                                                         root_process);
+          table_points                      = Utilities::MPI::broadcast (mpi_communicator,
+                                                                         table_points,
+                                                                         root_process);
+
+          // We can then also prepare the data tables for sharing between
+          // processes
+          for (unsigned int c = 0; c < n_components; ++c)
+            data_table[c].replicate_across_communicator (mpi_communicator,
+                                                         root_process);
+        }
+
+      Assert(data_table.size() == n_components,
+             ExcMessage("Error: Incorrect number of columns specified."));
+      for (unsigned int c=0; c<n_components; ++c)
+        Assert(data_table[c].size() == table_points,
+               ExcMessage("Error: One of the data tables has an incorrect size."));
+
+
+      // For each data component, set up a GridData,
+      // its type depending on the read-in grid.
+      data.resize(n_components);
+      for (unsigned int c = 0; c < n_components; ++c)
+        {
+          if (coordinate_values_are_equidistant)
+            {
+              std::array<unsigned int,dim> table_intervals;
+              for (unsigned int d=0; d<dim; ++d)
+                table_intervals[d] = table_points[d]-1;
+
+              // The min and max of the coordinates in the data file.
+              std::array<std::pair<double,double>,dim> grid_extent;
+              for (unsigned int d=0; d<dim; ++d)
+                {
+                  grid_extent[d].first = coordinate_values[d][0];
+                  grid_extent[d].second = coordinate_values[d][table_points[d]-1];
+
+                  Assert(table_intervals[d] >= 1,
+                         ExcMessage("There needs to be at least one subinterval in each "
+                                    "coordinate direction."));
+                  Assert(grid_extent[d].first <
+                         grid_extent[d].second,
+                         ExcMessage("The interval in each coordinate direction needs "
+                                    "to have positive size"));
+                }
+
+              data[c]
+                = std::make_unique<Functions::InterpolatedUniformGridData<dim>> (std::move(grid_extent),
+                                                                                  std::move(table_intervals),
+                                                                                  std::move(data_table[c]));
+            }
+          else
+            // Create the object and move the big objects. Due to an old design flaw,
+            // the current class stores a copy of the 'coordinate_values' and some
+            // plugins actually use it too, i.e., we can't move the data out of
+            // this object. In another design flaw, the deal.II classes
+            // do not make the coordinate values accessible, so we have to continue
+            // storing a copy. In other words, we can't just move stuff --
+            // we have to make a copy of 'coordinate_values' and then move
+            // that copy.
+            //
+            // (The call to std::move on the first argument is unnecessary: We
+            // create a temporary object, and that's an rvalue that the constructor
+            // we call would bind to. But never a bad idea to be explicit.)
+            data[c]
+              = std::make_unique<Functions::InterpolatedTensorProductGridData<dim>>
+                (std::move(std::array<std::vector<double>,dim>(this->coordinate_values)),
+                 std::move(data_table[c]));
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StructuredDataLookup<dim>::load_ascii(const std::string &filename,
+                                          const MPI_Comm comm)
+    {
+      const unsigned int root_process = 0;
+
+      std::vector<std::string> column_names;
+      std::vector<Table<dim,double>> data_tables;
+      std::vector<std::vector<double>> coordinate_values(dim);
+
+      // If this is the root process, set up the various member variables we need to compute
+      // from the input data
+      if (Utilities::MPI::this_mpi_process(comm) == root_process)
+        {
+          // Grab the values already stored in this class (if they exist), this way we can
+          // check if somebody changes the size of the table over time and error out (see below)
+          TableIndices<dim> new_table_points = this->table_points;
+
+          // We do not need to distribute the contents as we are using shared data
+          // to place it later. Therefore, just pass MPI_COMM_SELF (i.e.,
+          // a communicator with just a single MPI process) and no distribution
+          // will happen.
+          std::stringstream in(read_and_distribute_file_content(filename,
+                                                                MPI_COMM_SELF));
+
+          // Read header lines and table size
+          while (in.peek() == '#')
+            {
+              std::string line;
+              std::getline(in,line);
+              std::stringstream linestream(line);
+              std::string word;
+              while (linestream >> word)
+                if (word == "POINTS:")
+                  for (unsigned int i = 0; i < dim; ++i)
+                    {
+                      unsigned int temp_index;
+                      linestream >> temp_index;
+
+                      if (new_table_points[i] == 0)
+                        new_table_points[i] = temp_index;
+                      else
+                        AssertThrow (new_table_points[i] == temp_index,
+                                     ExcMessage("The file grid must not change over model runtime. "
+                                                "Either you prescribed a conflicting number of points in "
+                                                "the input file, or the POINTS comment in your data files "
+                                                "is changing between following files."));
+                    }
+            }
+
+          for (unsigned int i = 0; i < dim; ++i)
+            {
+              AssertThrow(new_table_points[i] != 0,
+                          ExcMessage("Could not successfully read in the file header of the "
+                                     "ascii data file <" + filename + ">. One header line has to "
+                                     "be of the format: '#POINTS: N1 [N2] [N3]', where N1 and "
+                                     "potentially N2 and N3 have to be the number of data points "
+                                     "in their respective dimension. Check for typos in this line "
+                                     "(e.g. a missing space character)."));
+            }
+
+          // Read column lines if present
+          unsigned int name_column_index = 0;
+          double temp_data;
+
+          while (true)
+            {
+              AssertThrow (name_column_index < 100,
+                           ExcMessage("The program found more than 100 columns in the first line of the data file. "
+                                      "This is unlikely intentional. Check your data file and make sure the data can be "
+                                      "interpreted as floating point numbers. If you do want to read a data file with more "
+                                      "than 100 columns, please remove this assertion."));
+
+              std::string column_name_or_data;
+              in >> column_name_or_data;
+              try
+                {
+                  // If the data field contains a name this will throw an exception
+                  temp_data = boost::lexical_cast<double>(column_name_or_data);
+
+                  // If there was no exception we have left the line containing names
+                  // and have read the first data field. Save number of n_components, and
+                  // make sure there is no contradiction if the n_components were already given to
+                  // the constructor of this class.
+                  if (n_components == numbers::invalid_unsigned_int)
+                    n_components = name_column_index - dim;
+                  else if (name_column_index != 0)
+                    AssertThrow (n_components+dim == name_column_index,
+                                 ExcMessage("The number of expected data columns and the "
+                                            "list of column names at the beginning of the data file "
+                                            + filename + " do not match. The file should contain "
+                                            + Utilities::int_to_string(name_column_index) + " column "
+                                            "names (one for each dimension and one per data column), "
+                                            "but it only has " + Utilities::int_to_string(n_components+dim) +
+                                            " column names."));
+                  break;
+                }
+              catch (const boost::bad_lexical_cast &e)
+                {
+                  // The first dim columns are coordinates and contain no data
+                  if (name_column_index >= dim)
+                    {
+                      // Transform name to lower case to prevent confusion with capital letters
+                      // Note: only ASCII characters allowed
+                      std::transform(column_name_or_data.begin(), column_name_or_data.end(), column_name_or_data.begin(), ::tolower);
+
+                      AssertThrow(std::find(column_names.begin(),column_names.end(),column_name_or_data)
+                                  == column_names.end(),
+                                  ExcMessage("There are multiple fields named " + column_name_or_data +
+                                             " in the data file " + filename + ". Please remove duplication to "
+                                             "allow for unique association between column and name."));
+
+                      column_names.push_back(column_name_or_data);
+                    }
+                  ++name_column_index;
+                }
+            }
+
+          // Create table for the data. This peculiar reinit is necessary, because
+          // there is no constructor for Table, which takes TableIndices as
+          // argument.
+          Table<dim,double> data_table;
+          data_table.TableBase<dim,double>::reinit(new_table_points);
+          AssertThrow (n_components != numbers::invalid_unsigned_int,
+                       ExcMessage("ERROR: number of n_components in " + filename + " could not be "
+                                  "determined automatically. Either add a header with column "
+                                  "names or pass the number of columns in the StructuredData "
+                                  "constructor."));
+          data_tables.resize(n_components, data_table);
+
+          for (unsigned int d=0; d<dim; ++d)
+            coordinate_values[d].resize(new_table_points[d]);
+
+          if (column_names.size()==0)
+            {
+              // set default column names:
+              for (unsigned int c=0; c<n_components; ++c)
+                column_names.push_back("column " + Utilities::int_to_string(c,2));
+            }
+
+          // Make sure the data file actually has as many columns as we think it has
+          // (either based on the header, or based on what was passed to the constructor).
+          const std::streampos position = in.tellg();
+          std::string first_data_row;
+          std::getline(in, first_data_row);
+          std::stringstream linestream(first_data_row);
+          std::string column_entry;
+
+          // We have already read in the first data entry above in the try/catch block,
+          // so there's one more column in the file than in the line we just read in.
+          unsigned int number_of_entries = 1;
+          while (linestream >> column_entry)
+            number_of_entries += 1;
+
+          AssertThrow ((number_of_entries) == column_names.size()+dim,
+                       ExcMessage("ERROR: The number of columns in the data file " + filename +
+                                  " is incorrect. It needs to have " + Utilities::int_to_string(column_names.size()+dim) +
+                                  " columns, but the first row has " + Utilities::int_to_string(number_of_entries) +
+                                  " columns."));
+
+          // Go back to the position in the file where we started the check for the column numbers.
+          in.seekg (position);
+
+          // Finally read data lines:
+          std::size_t read_data_entries = 0;
+          do
+            {
+              // what row and column of the file are we in?
+              const std::size_t column_num = read_data_entries%(n_components+dim);
+              const std::size_t row_num = read_data_entries/(n_components+dim);
+              const TableIndices<dim> idx = compute_table_indices(new_table_points, row_num);
+
+              if (column_num < dim)
+                {
+                  // This is a coordinate. Store (and check that they are consistent)
+                  const double old_value = coordinate_values[column_num][idx[column_num]];
+
+                  AssertThrow(old_value == 0. ||
+                              (std::abs(old_value-temp_data) < 1e-8*std::abs(old_value)),
+                              ExcMessage("Invalid coordinate in column "
+                                         + Utilities::int_to_string(column_num) + " in row "
+                                         + Utilities::int_to_string(row_num)
+                                         + " in file " + filename +
+                                         "\nThis class expects the coordinates to be structured, meaning "
+                                         "the coordinate values in each coordinate direction repeat exactly "
+                                         "each time. This also means each row in the data file has to have "
+                                         "the same number of columns as the first row containing data."));
+
+                  coordinate_values[column_num][idx[column_num]] = temp_data;
+                }
+              else
+                {
+                  // This is a data value, so scale and store:
+                  const unsigned int component = column_num - dim;
+                  data_tables[component](idx) = temp_data * scale_factor;
+                }
+
+              ++read_data_entries;
+            }
+          while (in >> temp_data);
+
+          AssertThrow(in.eof(),
+                      ExcMessage ("While reading the data file '" + filename + "' the ascii data "
+                                  "plugin has encountered an error before the end of the file. "
+                                  "Please check for malformed data values (e.g. NaN) or superfluous "
+                                  "lines at the end of the data file."));
+
+          const std::size_t n_expected_data_entries = (n_components + dim) * data_table.n_elements();
+          AssertThrow(read_data_entries == n_expected_data_entries,
+                      ExcMessage ("While reading the data file '" + filename + "' the ascii data "
+                                  "plugin has reached the end of the file, but has not found the "
+                                  "expected number of data values considering the spatial dimension, "
+                                  "data columns, and number of lines prescribed by the POINTS header "
+                                  "of the file. Please check the number of data "
+                                  "lines against the POINTS header in the file."));
+        }
+
+      // deal.II supports sharing data (since 9.4), so we have to
+      // set up member variables on the root process, but not on any of
+      // the other processes. So broadcast the data to the remaining
+      // processes -- the code above really only wrote into one
+      // member variable ('n_components'), so that is the only one we
+      // have to broadcast.
+      //
+      // The first three arguments to the call to reinit() below will
+      // only be read on the root process, and so it is totally ok
+      // that we are passing empty tables on all other processes. In
+      // the case of 'data_table', we do have to make sure that it is
+      // an array of the right size, though, even though the array
+      // contains only empty tables.
+      {
+        n_components = Utilities::MPI::broadcast (comm,
+                                                  n_components,
+                                                  root_process);
+        coordinate_values = Utilities::MPI::broadcast (comm,
+                                                       coordinate_values,
+                                                       root_process);
+        column_names = Utilities::MPI::broadcast (comm,
+                                                  column_names,
+                                                  root_process);
+
+        if (Utilities::MPI::this_mpi_process(comm) != root_process)
+          data_tables.resize (n_components);
+      }
+
+      // Finally create the data. We want to call the move-version of reinit() so
+      // that the data doesn't have to be copied, so use std::move on all big
+      // objects.
+      this->reinit(column_names,
+                   std::move(coordinate_values),
+                   std::move(data_tables),
+                   comm,
+                   root_process);
+    }
+
+
+
+    template <int dim>
+    void
+    StructuredDataLookup<dim>::load_netcdf(const std::string &filename, const std::vector<std::string> &data_column_names_)
+    {
+#ifndef ASPECT_WITH_NETCDF
+      (void)filename;
+      (void)data_column_names_;
+      AssertThrow(false, ExcMessage("Loading NetCDF files is only supported if ASPECT is configured with the NetCDF library!"));
+#else
+      TableIndices<dim> new_table_points;
+      std::vector<std::string> coordinate_column_names(dim);
+      std::vector<Table<dim,double>> data_tables;
+      std::vector<std::string> data_column_names = data_column_names_;
+      std::vector<std::vector<double>> coordinate_values(dim);
+
+      int ncid;
+      int status;
+
+      status = nc_open(filename.c_str(), NC_NOWRITE, &ncid);
+      AssertThrowNetCDF(status);
+
+      int ndims, nvars, ngatts, unlimdimid;
+      status = nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid);
+      AssertThrowNetCDF(status);
+
+      // The number of dimensions ndims in the netcdf file can be
+      // different than dim. In fact, each variable (data column in
+      // our notation) has a subset of those dimensions associated
+      // with it. That also means that variables can have a different
+      // number of dimensions and/or a different subset. We can only
+      // use variables with dim dimensions (our template argument) and
+      // only those that all use the same dimids inside the netcdf
+      // file.
+      int dimids_to_use[dim] = {}; // dimids of the coordinate columns to use
+      std::vector<int> varids_to_use; // all netCDF varids of the data columns
+
+      if (data_column_names.empty())
+        {
+          // The user did not ask for a specific list of data
+          // columns. Let's find all columns we can possible load. We
+          // find the first data column with the correct number of
+          // dims. This one will determine the dimids of the
+          // coordinates to use. Following that, we pick all other
+          // data columns with the same coordinates.
+
+          for (int varid=0; varid<nvars; ++varid)
+            {
+              // Each netCDF dimension also has an associated variable that stores the
+              // coordinate data. We are looking for data columns, so skip them:
+              if (varid < ndims)
+                continue;
+
+              char  var_name[NC_MAX_NAME];
+              nc_type xtype;
+              int var_ndims;
+              int var_dimids[NC_MAX_VAR_DIMS];
+              int var_natts;
+
+              status = nc_inq_var (ncid, varid, var_name, &xtype, &var_ndims, var_dimids,
+                                   &var_natts);
+              AssertThrowNetCDF(status);
+
+              // only consider data that has dim variables:
+              if (var_ndims == dim)
+                {
+                  bool use = true;
+                  if (varids_to_use.size()>0)
+                    {
+                      // This is not the first data column, so we can only use it if
+                      // it uses the same dim variables as the first data column we
+                      // found.
+                      for (int i=0; i<dim; ++i)
+                        if (dimids_to_use[i]!=var_dimids[i])
+                          {
+                            use=false;
+                            break;
+                          }
+                    }
+                  else
+                    {
+                      // This is the first data column we found, so grab the ids of
+                      // the dimensions to use and store in dimids_to_use:
+                      for (int i=0; i<dim; ++i)
+                        {
+                          size_t length;
+                          status = nc_inq_dim(ncid, var_dimids[i], nullptr, &length);
+                          dimids_to_use[i] = var_dimids[i];
+                          // dimensions are specified in reverse order in the nc file:
+                          new_table_points[dim-1-i] = length;
+                        }
+                    }
+
+                  if (use)
+                    {
+                      varids_to_use.push_back(varid);
+                      data_column_names.push_back(var_name);
+                    }
+                }
+            }
+
+        }
+      else
+        {
+          // The user wants a specific list of columns, so lets find them.
+
+          for (const auto &cur_name: data_column_names)
+            {
+              bool found = false;
+
+              for (int varid=0; varid<nvars; ++varid)
+                {
+                  // Each netCDF dimension also has an associated variable that stores the
+                  // coordinate data. We are looking for data columns, so skip them:
+                  if (varid < ndims)
+                    continue;
+
+                  char  var_name[NC_MAX_NAME];
+                  nc_type xtype;
+                  int var_ndims;
+                  int var_dimids[NC_MAX_VAR_DIMS];
+                  int var_natts;
+
+                  status = nc_inq_var (ncid, varid, var_name, &xtype, &var_ndims, var_dimids,
+                                       &var_natts);
+                  AssertThrowNetCDF(status);
+                  if (cur_name != var_name)
+                    continue;
+
+                  found = true;
+
+                  if (var_ndims == dim)
+                    {
+                      bool use = true;
+                      if (varids_to_use.size()>0)
+                        {
+                          for (int i=0; i<dim; ++i)
+                            if (dimids_to_use[i]!=var_dimids[i])
+                              {
+                                use=false;
+                                break;
+                              }
+                        }
+                      else
+                        {
+                          for (int i=0; i<dim; ++i)
+                            {
+                              size_t length;
+                              status = nc_inq_dim(ncid, var_dimids[i], nullptr, &length);
+                              dimids_to_use[i] = var_dimids[i];
+                              // dimensions are specified in reverse order in the nc file:
+                              new_table_points[dim-1-i] = length;
+                            }
+                        }
+
+                      AssertThrow(use, ExcMessage(
+                                    "You asked to include column '" + cur_name + "', but it unfortunately has different dimensions than the first column you chose."
+                                  ));
+
+
+                      varids_to_use.push_back(varid);
+                    }
+                  else
+                    AssertThrow(false, ExcMessage(
+                                  "You asked to include column '" + cur_name + "', but it unfortunately has an incorrect number of dimensions."
+                                ));
+
+                }
+              AssertThrow(found, ExcMessage(
+                            "You asked to include column '" + cur_name + "', but it was not found!"
+                          ));
+
+            }
+        }
+
+
+      // Extract names of the coordinates
+      for (int idx=0; idx<dim; ++idx)
+        {
+          char  name[NC_MAX_NAME];
+          size_t length;
+          status = nc_inq_dim(ncid, dimids_to_use[idx], name, &length);
+          AssertThrowNetCDF(status);
+          coordinate_column_names[idx] = name;
+        }
+
+      {
+        // Now load coordinate data
+
+        for (int d=0; d<dim; ++d)
+          {
+            // dimensions are specified in reverse order in the nc file:
+            int varid = dimids_to_use[dim-1-d];
+
+            nc_type xtype;
+            int ndims;
+            int dimids[NC_MAX_VAR_DIMS];
+            char  name[NC_MAX_NAME];
+            int natts;
+
+            status = nc_inq_var (ncid, varid, name, &xtype, &ndims, dimids,
+                                 &natts);
+            AssertThrow(ndims == 1, ExcMessage("A variable of a dimension should have only one dimension."));
+
+            AssertThrow(xtype == NC_DOUBLE || xtype == NC_FLOAT, ExcMessage("We only support float or double data."));
+
+            coordinate_values[d].resize(new_table_points[d]);
+            status = nc_get_var_double(ncid, varid, coordinate_values[d].data());
+            AssertThrowNetCDF(status);
+          }
+      }
+
+      {
+        // Finally load the data for each column
+        data_tables.resize(varids_to_use.size());
+        std::vector<double> raw_data;
+
+        for (unsigned int var = 0; var<varids_to_use.size(); ++var)
+          {
+            // Allocate space
+            data_tables[var].TableBase<dim,double>::reinit(new_table_points);
+            const std::size_t n_elements = data_tables[var].n_elements();
+            raw_data.resize(n_elements);
+
+            // Load the data
+            status = nc_get_var_double(ncid, varids_to_use[var], raw_data.data());
+            AssertThrowNetCDF(status);
+
+            // .. and copy it over:
+            for (std::size_t n = 0; n < n_elements; ++n)
+              {
+                TableIndices<dim> ind = compute_table_indices(new_table_points, n);
+                TableIndices<dim> ind_to_use;
+                for (int i=0; i<dim; ++i)
+                  ind_to_use[i] = ind[dimids_to_use[i]];
+
+                data_tables[var](ind) = scale_factor * raw_data[n];
+              }
+          }
+
+      }
+
+
+      status = nc_close(ncid);
+      AssertThrowNetCDF(status);
+
+      // ready to go:
+      this->reinit(data_column_names, std::move(coordinate_values),std::move(data_tables));
+#endif
+    }
+
+    template <int dim>
+    void
+    StructuredDataLookup<dim>::load_file(const std::string &filename,
+                                         const MPI_Comm communicator)
+    {
+      const bool is_netcdf_filename = std::regex_search(filename, std::regex("\\.(nc|NC)$"));
+      if (is_netcdf_filename)
+        load_netcdf(filename);
+      else
+        load_ascii(filename, communicator);
+    }
+
+    template <int dim>
+    double
+    StructuredDataLookup<dim>::get_data(const Point<dim> &position,
+                                        const unsigned int component) const
+    {
+      Assert(component<n_components, ExcMessage("Invalid component index"));
+      return data[component]->value(position);
+    }
+
+    template <int dim>
+    Tensor<1,dim>
+    StructuredDataLookup<dim>::get_gradients(const Point<dim> &position,
+                                             const unsigned int component)
+    {
+      return data[component]->gradient(position,0);
+    }
+
+
+    template <int dim>
+    TableIndices<dim>
+    StructuredDataLookup<dim>::compute_table_indices(const TableIndices<dim> &sizes, const std::size_t idx) const
+    {
+      TableIndices<dim> result;
+      result[0] = idx % sizes[0];
+      if (dim >= 2)
+        result[1] = (idx / sizes[0]) % sizes[1];
+      if (dim == 3)
+        result[2] = idx / (sizes[0] * sizes[1]);
+
+      return result;
+    }
+
+
+
+    template <int dim>
+    AsciiDataBase<dim>::AsciiDataBase ()
+      = default;
+
+
+    template <int dim>
+    void
+    AsciiDataBase<dim>::declare_parameters (ParameterHandler  &prm,
+                                            const std::string &default_directory,
+                                            const std::string &default_filename,
+                                            const std::string &subsection_name)
+    {
+      prm.enter_subsection (subsection_name);
+      {
+        prm.declare_entry ("Data directory",
+                           default_directory,
+                           Patterns::DirectoryName (),
+                           "The name of a directory that contains the model data. This path "
+                           "may either be absolute (if starting with a `/') or relative to "
+                           "the current directory. The path may also include the special "
+                           "text `$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                           "in which the ASPECT source files were located when ASPECT was "
+                           "compiled. This interpretation allows, for example, to reference "
+                           "files located in the `data/' subdirectory of ASPECT.");
+        prm.declare_entry ("Data file name",
+                           default_filename,
+                           Patterns::Anything (),
+                           "The file name of the model data.");
+        prm.declare_entry ("Scale factor", "1.",
+                           Patterns::Double (),
+                           "Scalar factor, which is applied to the model data. "
+                           "You might want to use this to scale the input to a "
+                           "reference model. Another way to use this factor is to "
+                           "convert units of the input files. For instance, if you "
+                           "provide velocities in cm/yr set this factor to 0.01.");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataBase<dim>::parse_parameters (ParameterHandler &prm,
+                                          const std::string &subsection_name)
+    {
+      prm.enter_subsection (subsection_name);
+      {
+        // Get the path to the data files. If it contains a reference
+        // to $ASPECT_SOURCE_DIR, replace it by what CMake has given us
+        // as a #define
+        data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+        data_file_name    = prm.get ("Data file name");
+        scale_factor      = prm.get_double ("Scale factor");
+      }
+      prm.leave_subsection();
+    }
+
+    namespace
+    {
+      template <int dim>
+      void
+      check_supported_geometry_models(const GeometryModel::Interface<dim> &geometry_model)
+      {
+        AssertThrow ((Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (geometry_model))
+                     || (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (geometry_model))
+                     || (Plugins::plugin_type_matches<const GeometryModel::TwoMergedChunks<dim>> (geometry_model))
+                     || (Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>> (geometry_model))
+                     || (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (geometry_model))
+                     || (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (geometry_model))
+                     || (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (geometry_model)),
+                     ExcMessage ("This ascii data plugin can only be used with supported "
+                                 "geometry models."));
+      }
+    }
+
+
+
+    template <int dim>
+    AsciiDataBoundary<dim>::AsciiDataBoundary ()
+      :
+      current_file_number(numbers::invalid_unsigned_int),
+      first_data_file_number(numbers::invalid_unsigned_int),
+      decreasing_file_order(false),
+      data_file_time_step(numbers::signaling_nan<double>()),
+      time_weight(numbers::signaling_nan<double>()),
+      time_dependent(false),
+      lookups(),
+      old_lookups()
+    {}
+
+
+
+    template <int dim>
+    void
+    AsciiDataBoundary<dim>::initialize(const std::set<types::boundary_id> &boundary_ids,
+                                       const unsigned int n_components)
+    {
+      check_supported_geometry_models(this->get_geometry_model());
+
+      for (const auto &boundary_id : boundary_ids)
+        {
+          lookups.insert(std::make_pair(boundary_id,
+                                        std::make_unique<Utilities::StructuredDataLookup<dim-1>>
+                                        (n_components,
+                                         this->scale_factor)));
+
+          // Set the first file number and load the first files
+          current_file_number = first_data_file_number;
+
+          const std::string filename (create_filename (current_file_number, boundary_id));
+
+          this->get_pcout() << std::endl << "   Loading Ascii data boundary file "
+                            << filename << '.' << std::endl << std::endl;
+
+
+          AssertThrow(Utilities::fexists(filename, this->get_mpi_communicator()) || filename_is_url(filename),
+                      ExcMessage (std::string("Ascii data file <")
+                                  +
+                                  filename
+                                  +
+                                  "> not found!"));
+          lookups.find(boundary_id)->second->load_file(filename,this->get_mpi_communicator());
+
+          if (time_dependent == true)
+            {
+              old_lookups.insert(std::make_pair(boundary_id,
+                                                std::make_unique<Utilities::StructuredDataLookup<dim-1>>
+                                                (n_components,
+                                                 this->scale_factor)));
+
+              const int next_file_number =
+                (decreasing_file_order) ?
+                current_file_number - 1
+                :
+                current_file_number + 1;
+
+              const std::string filename (create_filename (next_file_number, boundary_id));
+              if (Utilities::fexists(filename, this->get_mpi_communicator()))
+                {
+                  this->get_pcout() << std::endl << "   Also loading next Ascii data boundary file "
+                                    << filename << '.' << std::endl << std::endl;
+                  lookups.find(boundary_id)->second.swap(old_lookups.find(boundary_id)->second);
+                  lookups.find(boundary_id)->second->load_file(filename, this->get_mpi_communicator());
+                }
+              else
+                {
+                  // next file not found, issue warning and end looking for new files
+                  end_time_dependence ();
+                }
+            }
+        }
+    }
+
+
+
+    namespace
+    {
+      /**
+       * Given a string @p filename_and_path that contains exactly one
+       * <code>%s</code> and one <code>%d</code> code (possibly modified
+       * by flag, field, and length modifiers as discussed in the man
+       * pages of the <code>printf()</code> family of functions),
+       * return the expanded string where the <code>%s</code> code is
+       * replaced by @p boundary_name, and <code>%d</code> is replaced
+       * by @p filenumber. Options: (1) specify both boundary_name and
+       * filenumber placeholders (%s and %d), (2) do not specify any
+       * boundary_name and filenumber placeholders, (3) only specify
+       * boundary_name placeholder (%s). Do not only specify filenumber
+       * placeholder (%d). Placeholders order is first boundary_name
+       * (%s), then filenumber (%d).
+       */
+      std::string replace_placeholders(const std::string &filename_and_path,
+                                       const std::string &boundary_name,
+                                       const int filenumber)
+      {
+        const int maxsize = filename_and_path.length() + 256;
+        char *filename = static_cast<char *>(malloc (maxsize * sizeof(char)));
+        int ret = snprintf (filename,
+                            maxsize,
+                            filename_and_path.c_str(),
+                            boundary_name.c_str(),
+                            filenumber);
+
+        AssertThrow(ret >= 0, ExcMessage("Invalid string placeholder in filename detected."));
+        AssertThrow(ret< maxsize, ExcInternalError("snprintf string overflow detected."));
+        const std::string str_result (filename);
+        free (filename);
+        return str_result;
+      }
+
+    }
+
+    template <int dim>
+    std::string
+    AsciiDataBoundary<dim>::create_filename (const int filenumber,
+                                             const types::boundary_id boundary_id) const
+    {
+      std::string templ = this->data_directory + this->data_file_name;
+
+      const std::string boundary_name = this->get_geometry_model().translate_id_to_symbol_name(boundary_id);
+
+      const std::string result = replace_placeholders(templ, boundary_name, filenumber);
+      if (fexists(result, this->get_mpi_communicator()))
+        return result;
+
+      // Backwards compatibility check: people might still be using the old
+      // names of the top/bottom boundary. If they do, print a warning but
+      // accept those files.
+      std::string compatible_result;
+      if (boundary_name == "top")
+        {
+          compatible_result = replace_placeholders(templ, "surface", filenumber);
+          if (!fexists(compatible_result, this->get_mpi_communicator()))
+            compatible_result = replace_placeholders(templ, "outer", filenumber);
+        }
+      else if (boundary_name == "bottom")
+        compatible_result = replace_placeholders(templ, "inner", filenumber);
+
+      if (!fexists(result, this->get_mpi_communicator()) && fexists(compatible_result, this->get_mpi_communicator()))
+        {
+          this->get_pcout() << "WARNING: Filename convention concerning geometry boundary "
+                            "names changed. Please rename '" << compatible_result << "'"
+                            << " to '" << result << "'"
+                            << std::endl;
+          return compatible_result;
+        }
+
+      return result;
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataBoundary<dim>::update ()
+    {
+      if (time_dependent == true)
+        {
+          // always initialize with the start time during model setup, even
+          // when restarting (to have identical setup in both cases)
+          double model_time = this->get_parameters().start_time;
+
+          // if we are past initialization use the current time instead
+          if (this->simulator_is_past_initialization())
+            model_time = this->get_time();
+
+          const double time_steps_since_start = model_time / data_file_time_step;
+          // whether we need to update our data files. This looks so complicated
+          // because we need to catch increasing and decreasing file orders and all
+          // possible first_data_file_numbers.
+          const bool need_update =
+            static_cast<int> (time_steps_since_start)
+            > std::abs(current_file_number - first_data_file_number);
+
+          if (need_update)
+            {
+              // The last file, which was tried to be loaded was
+              // number current_file_number +/- 1, because current_file_number
+              // is the file older than the current model time
+              const int old_file_number =
+                (decreasing_file_order) ?
+                current_file_number - 1
+                :
+                current_file_number + 1;
+
+              // Calculate new file_number
+              current_file_number =
+                (decreasing_file_order) ?
+                first_data_file_number
+                - static_cast<unsigned int> (time_steps_since_start)
+                :
+                first_data_file_number
+                + static_cast<unsigned int> (time_steps_since_start);
+
+              const bool load_both_files = std::abs(current_file_number - old_file_number) >= 1;
+
+              for (const auto &boundary_id : lookups)
+                update_data(boundary_id.first, load_both_files);
+            }
+
+          time_weight = time_steps_since_start
+                        - std::abs(current_file_number - first_data_file_number);
+
+          Assert ((0 <= time_weight) && (time_weight <= 1),
+                  ExcMessage (
+                    "Error in set_current_time. Time_weight has to be in [0,1]"));
+        }
+    }
+
+    template <int dim>
+    void
+    AsciiDataBoundary<dim>::update_data (const types::boundary_id boundary_id,
+                                         const bool load_both_files)
+    {
+      // If the time step was large enough to move forward more
+      // then one data file we need to load both current files
+      // to stay accurate in interpolation
+      if (load_both_files)
+        {
+          const std::string filename (create_filename (current_file_number,boundary_id));
+          this->get_pcout() << std::endl << "   Loading Ascii data boundary file "
+                            << filename << '.' << std::endl << std::endl;
+          if (Utilities::fexists(filename, this->get_mpi_communicator()))
+            {
+              lookups.find(boundary_id)->second.swap(old_lookups.find(boundary_id)->second);
+              lookups.find(boundary_id)->second->load_file(filename,this->get_mpi_communicator());
+            }
+
+          // If loading current_time_step failed, end time dependent part with old_file_number.
+          else
+            end_time_dependence ();
+        }
+
+      // Now load the next data file. This part is the main purpose of this function.
+      const int next_file_number =
+        (decreasing_file_order) ?
+        current_file_number - 1
+        :
+        current_file_number + 1;
+
+      const std::string filename (create_filename (next_file_number,boundary_id));
+      this->get_pcout() << std::endl << "   Loading Ascii data boundary file "
+                        << filename << '.' << std::endl << std::endl;
+      if (Utilities::fexists(filename, this->get_mpi_communicator()))
+        {
+          lookups.find(boundary_id)->second.swap(old_lookups.find(boundary_id)->second);
+          lookups.find(boundary_id)->second->load_file(filename,this->get_mpi_communicator());
+        }
+
+      // If next file does not exist, end time dependent part with current_time_step and issue warning.
+      else
+        end_time_dependence ();
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiDataBoundary<dim>::end_time_dependence ()
+    {
+      // no longer consider the problem time dependent from here on out
+      // this cancels all attempts to read files at the next time steps
+      time_dependent = false;
+
+      // Give warning if first processor
+      this->get_pcout() << std::endl
+                        << "   From this timestep onwards, ASPECT will not attempt to load new Ascii data files." << std::endl
+                        << "   This is either because ASPECT has already read all the files necessary to impose" << std::endl
+                        << "   the requested boundary condition, or that the last available file has been read." << std::endl
+                        << "   If the Ascii data represented a time-dependent boundary condition," << std::endl
+                        << "   that time-dependence ends at this timestep  (i.e. the boundary condition" << std::endl
+                        << "   will continue unchanged from the last known state into the future)." << std::endl << std::endl;
+    }
+
+
+
+    namespace
+    {
+      /**
+       * Determines which of the dimensions of a position are aligned with
+       * a certain @p boundary_id. E.g. the left boundary of a box
+       * model extents in the y and z direction (position[1] and
+       * position[2]), therefore the function would return [1,2] for dim==3
+       * or [1] for dim==2. We are lucky that these indices are identical
+       * for all existing geometries (if we use natural coordinates),
+       * therefore we do not need to distinguish between them. If we
+       * introduce a geometry model for which boundaries are not aligned
+       * with natural coordinates this needs to become a function in
+       * the interface of the geometry model and needs to be specialized
+       * for distinct geometry models.
+       */
+      template <int dim>
+      std::array<unsigned int,dim-1>
+      get_boundary_dimensions (const types::boundary_id boundary_id)
+      {
+        std::array<unsigned int,dim-1> boundary_dimensions;
+        boundary_dimensions.fill(numbers::invalid_unsigned_int);
+
+        switch (dim)
+          {
+            case 2:
+              if ((boundary_id == 2) || (boundary_id == 3) || (boundary_id == 4) || (boundary_id == 5))
+                {
+                  boundary_dimensions[0] = 0;
+                }
+              else if ((boundary_id == 0) || (boundary_id == 1))
+                {
+                  boundary_dimensions[0] = 1;
+                }
+              else
+                {
+                  AssertThrow(false,ExcNotImplemented());
+                }
+              break;
+
+            case 3:
+              if ((boundary_id == 4) || (boundary_id == 5) || (boundary_id == 8) || (boundary_id == 9))
+                {
+                  boundary_dimensions[0] = 0;
+                  boundary_dimensions[1] = 1;
+                }
+              else if ((boundary_id == 0) || (boundary_id == 1))
+                {
+                  boundary_dimensions[0] = 1;
+                  boundary_dimensions[1] = 2;
+                }
+              else if ((boundary_id == 2) || (boundary_id == 3) || (boundary_id == 6) || (boundary_id == 7))
+                {
+                  boundary_dimensions[0] = 0;
+                  boundary_dimensions[1] = 2;
+                }
+              else
+                {
+                  AssertThrow(false,ExcNotImplemented());
+                }
+
+              break;
+
+            default:
+              AssertThrow(false,ExcNotImplemented());
+          }
+        return boundary_dimensions;
+      }
+
+
+
+      /**
+       * Convert a point @p position in cartesian coordinates into the set of coordinates
+       * used in the structured data input files, i.e. coordinates in the
+       * natural coordinate system of the given @p geometry_model.
+       */
+      template <int dim>
+      Point<dim>
+      data_coordinates_from_position (const Point<dim> &position,
+                                      const aspect::GeometryModel::Interface<dim> &geometry_model)
+      {
+        const std::array<double,dim> natural_position = geometry_model.cartesian_to_natural_coordinates(position);
+        Point<dim> data_coordinates = Utilities::convert_array_to_point<dim>(natural_position);
+
+        // The chunk model has latitude as natural coordinate. We need to convert this to colatitude
+        // to allow for consistent data files between chunk geometries and spherical geometries.
+        if (dim == 3 &&
+            (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (geometry_model) ||
+             Plugins::plugin_type_matches<const GeometryModel::TwoMergedChunks<dim>> (geometry_model) ||
+             Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>> (geometry_model)))
+          {
+            data_coordinates[2] = numbers::PI/2. - data_coordinates[2];
+          }
+
+        return data_coordinates;
+      }
+
+
+
+      /**
+       * Convert a point @p data_coordinates using coordinates appropriate for
+       * volumetric structured data input files (e.g. produced by the
+       * data_coordinates_from_position() function above) into appropriate
+       * coordinates on the boundary given by @p boundary_indicator.
+       * Because all existing geometry models use boundaries that are aligned
+       * with natural coordinate directions this means finding the correct n_components
+       * of the input coordinates and returning a point with one dimension less
+       * than the input point that is determined by these coordinates.
+       */
+      template <int dim>
+      Point<dim-1>
+      boundary_coordinates_from_data_coordinates (const Point<dim> &data_coordinates,
+                                                  const types::boundary_id boundary_indicator)
+      {
+        const std::array<unsigned int,dim-1> boundary_dimensions =
+          get_boundary_dimensions<dim>(boundary_indicator);
+
+        Point<dim-1> boundary_coordinates;
+        for (unsigned int i = 0; i < dim-1; ++i)
+          boundary_coordinates[i] = data_coordinates[boundary_dimensions[i]];
+
+        return boundary_coordinates;
+      }
+    }
+
+
+
+    template <int dim>
+    double
+    AsciiDataBoundary<dim>::
+    get_data_component (const types::boundary_id             boundary_indicator,
+                        const Point<dim>                    &position,
+                        const unsigned int                   component) const
+    {
+      const Point<dim> data_coordinates = data_coordinates_from_position(position, this->get_geometry_model());
+      const Point<dim-1> boundary_coordinates = boundary_coordinates_from_data_coordinates(data_coordinates, boundary_indicator);
+
+      Assert (lookups.find(boundary_indicator) != lookups.end(),
+              ExcInternalError());
+      const double data = lookups.find(boundary_indicator)->second->get_data(boundary_coordinates,component);
+
+      if (!time_dependent)
+        return data;
+
+      const double old_data = old_lookups.find(boundary_indicator)->second->get_data(boundary_coordinates,component);
+
+      return time_weight * data + (1 - time_weight) * old_data;
+    }
+
+
+    template <int dim>
+    Tensor<1,dim-1>
+    AsciiDataBoundary<dim>::vector_gradient (const types::boundary_id             boundary_indicator,
+                                             const Point<dim>                    &position,
+                                             const unsigned int                   component) const
+    {
+      const Point<dim> data_coordinates = data_coordinates_from_position(position, this->get_geometry_model());
+      const Point<dim-1> boundary_coordinates = boundary_coordinates_from_data_coordinates(data_coordinates, boundary_indicator);
+
+      const Tensor<1,dim-1>  gradients = lookups.find(boundary_indicator)->second->get_gradients(boundary_coordinates,component);
+
+      if (!time_dependent)
+        return gradients;
+
+      const Tensor<1,dim-1> old_gradients = old_lookups.find(boundary_indicator)->second->get_gradients(boundary_coordinates,component);
+
+      return time_weight * gradients + (1 - time_weight) * old_gradients;
+    }
+
+
+    template <int dim>
+    double
+    AsciiDataBoundary<dim>::get_maximum_component_value (const types::boundary_id boundary_indicator, const unsigned int component) const
+    {
+      return lookups.find(boundary_indicator)->second->get_maximum_component_value(component);
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataBoundary<dim>::declare_parameters (ParameterHandler  &prm,
+                                                const std::string &default_directory,
+                                                const std::string &default_filename,
+                                                const std::string &subsection_name,
+                                                const bool declare_time_dependent_parameters)
+    {
+      Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                        default_directory,
+                                                        default_filename,
+                                                        subsection_name);
+
+      prm.enter_subsection (subsection_name);
+      {
+        if (declare_time_dependent_parameters == true)
+          {
+            prm.declare_entry ("Data file name",
+                               default_filename,
+                               Patterns::Anything (),
+                               "The file name of the model data. Provide file in format: "
+                               "(File name).\\%s\\%d, where \\%s is a string specifying "
+                               "the boundary of the model according to the names of the boundary "
+                               "indicators (of the chosen geometry model), and \\%d is any sprintf "
+                               "integer qualifier specifying the format of the current file number.");
+            prm.declare_entry ("Data file time step", "1e6",
+                               Patterns::Double (0.),
+                               "Time step between following data files. "
+                               "Depending on the setting of the global `Use years in output instead of seconds' flag "
+                               "in the input file, this number is either interpreted as seconds or as years. "
+                               "The default is one million, i.e., either one million seconds or one million years.");
+            prm.declare_entry ("First data file model time", "0",
+                               Patterns::Double (0.),
+                               "The `First data file model time' parameter "
+                               "has been deactivated and will be removed in a future release. "
+                               "Do not use this parameter and instead provide data files "
+                               "starting from the model start time.");
+            prm.declare_entry ("First data file number", "0",
+                               Patterns::Integer (),
+                               "Number of the first velocity file to be loaded when the model time "
+                               "is larger than `First velocity file model time'.");
+            prm.declare_entry ("Decreasing file order", "false",
+                               Patterns::Bool (),
+                               "In some cases the boundary files are not numbered in increasing "
+                               "but in decreasing order (e.g. `Ma BP'). If this flag is set to "
+                               "`True' the plugin will first load the file with the number "
+                               "`First data file number' and decrease the file number during "
+                               "the model run.");
+          }
+        else
+          {
+            prm.declare_entry ("Data file name",
+                               default_filename,
+                               Patterns::Anything (),
+                               "The file name of the model data. Provide file in format: "
+                               "(File name).\\%s, where \\%s is a string specifying "
+                               "the boundary of the model according to the names of the boundary "
+                               "indicators (of the chosen geometry model).");
+          }
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataBoundary<dim>::parse_parameters (ParameterHandler &prm,
+                                              const std::string &subsection_name,
+                                              const bool parse_time_dependent_parameters)
+    {
+      Utilities::AsciiDataBase<dim>::parse_parameters(prm,
+                                                      subsection_name);
+
+      prm.enter_subsection(subsection_name);
+      {
+        if (parse_time_dependent_parameters == true)
+          {
+            data_file_time_step             = prm.get_double ("Data file time step");
+            const double first_data_file_model_time      = prm.get_double ("First data file model time");
+
+            AssertThrow (first_data_file_model_time == 0.0,
+                         ExcMessage("The `First data file model time' parameter "
+                                    "has been deactivated and will be removed in a future release. "
+                                    "Do not use this parameter and instead provide data files "
+                                    "starting from the model start time."));
+
+            first_data_file_number          = prm.get_integer("First data file number");
+            decreasing_file_order           = prm.get_bool   ("Decreasing file order");
+
+            if (this->convert_output_to_years() == true)
+              {
+                data_file_time_step        *= year_in_seconds;
+              }
+          }
+        else
+          {
+            AssertThrow (create_filename (0, 0) == create_filename (1, 0),
+                         ExcMessage("A boundary data file name was used that contained a placeholder for "
+                                    "the current file number, but this AsciiDataBoundary object does not support "
+                                    "time dependent information. Please remove the file number placeholder."));
+          }
+
+        // if filename does not contain a placeholder for timestep, no time dependence
+        // do not issue a warning, the parameter file is specifying exactly one file.
+        if (create_filename (0, 0) == create_filename (1, 0))
+          time_dependent = false;
+        else
+          time_dependent = true;
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    AsciiDataLayered<dim>::AsciiDataLayered ()
+      = default;
+
+
+
+    template <int dim>
+    void
+    AsciiDataLayered<dim>::initialize(const unsigned int n_components)
+    {
+      check_supported_geometry_models(this->get_geometry_model());
+
+      // Create the lookups for each file
+      number_of_layer_boundaries = data_file_names.size();
+      for (unsigned int i=0; i<number_of_layer_boundaries; ++i)
+        {
+          const std::string filename = data_directory + data_file_names[i];
+          AssertThrow(Utilities::fexists(filename, this->get_mpi_communicator()) || filename_is_url(filename),
+                      ExcMessage (std::string("Ascii data file <")
+                                  +
+                                  filename
+                                  +
+                                  "> not found!"));
+
+          lookups.push_back(std::make_unique<Utilities::StructuredDataLookup<dim-1>> (n_components,
+                                                                                       this->scale_factor));
+          lookups[i]->load_file(filename,this->get_mpi_communicator());
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    AsciiDataLayered<dim>::
+    get_data_component (const Point<dim> &position,
+                        const unsigned int component) const
+    {
+      const Point<dim> data_coordinates = data_coordinates_from_position(position, this->get_geometry_model());
+
+      double vertical_position;
+      Point<dim-1> horizontal_position;
+      if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian)
+        {
+          // in cartesian coordinates, the vertical component comes last
+          vertical_position = data_coordinates[dim-1];
+          for (unsigned int i = 0; i < dim-1; ++i)
+            horizontal_position[i] = data_coordinates[i];
+        }
+      else
+        {
+          // in spherical coordinates, the vertical component comes first
+          vertical_position = data_coordinates[0];
+          for (unsigned int i = 0; i < dim-1; ++i)
+            horizontal_position[i] = data_coordinates[i+1];
+        }
+
+      // Find which layer we're in
+      unsigned int layer_boundary_index=0;
+      // if position < position of the first boundary layer, stop
+      double old_difference_in_vertical_position = vertical_position - lookups[layer_boundary_index]->get_data(horizontal_position,0);
+      double difference_in_vertical_position = old_difference_in_vertical_position;
+      while (difference_in_vertical_position > 0. && layer_boundary_index < number_of_layer_boundaries-1)
+        {
+          ++layer_boundary_index;
+          old_difference_in_vertical_position = difference_in_vertical_position;
+          difference_in_vertical_position = vertical_position - lookups[layer_boundary_index]->get_data(horizontal_position,0);
+        }
+
+      if (interpolation_scheme == "piecewise constant")
+        {
+          return lookups[layer_boundary_index]->get_data(horizontal_position,component); // takes value from layer above
+        }
+      else if (interpolation_scheme == "linear")
+        {
+          if (difference_in_vertical_position > 0 || layer_boundary_index == 0) // if the point is above the first layer or below the last
+            {
+              return lookups[layer_boundary_index]->get_data(horizontal_position,component);
+            }
+          else
+            {
+              const double f = difference_in_vertical_position/(difference_in_vertical_position-old_difference_in_vertical_position);
+              return ((1.-f)*lookups[layer_boundary_index]->get_data(horizontal_position,component) +
+                      f*lookups[layer_boundary_index-1]->get_data(horizontal_position,component));
+            }
+        }
+      return 0;
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataLayered<dim>::declare_parameters (ParameterHandler  &prm,
+                                               const std::string &default_directory,
+                                               const std::string &default_filename,
+                                               const std::string &subsection_name)
+    {
+      Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                        default_directory,
+                                                        default_filename,
+                                                        subsection_name);
+
+      prm.enter_subsection (subsection_name);
+      {
+        prm.declare_entry ("Data directory",
+                           default_directory,
+                           Patterns::DirectoryName (),
+                           "The name of a directory that contains the model data. This path "
+                           "may either be absolute (if starting with a `/') or relative to "
+                           "the current directory. The path may also include the special "
+                           "text `$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                           "in which the ASPECT source files were located when ASPECT was "
+                           "compiled. This interpretation allows, for example, to reference "
+                           "files located in the `data/' subdirectory of ASPECT. ");
+
+        prm.declare_entry ("Data file names",
+                           default_filename,
+                           Patterns::List (Patterns::Anything()),
+                           "The file names of the model data (comma separated). ");
+
+        prm.declare_entry ("Interpolation scheme", "linear",
+                           Patterns::Selection("piecewise constant|linear"),
+                           "Method to interpolate between layer boundaries. Select from "
+                           "piecewise constant or linear. Piecewise constant takes the "
+                           "value from the nearest layer boundary above the data point. "
+                           "The linear option interpolates linearly between layer boundaries. "
+                           "Above and below the domain given by the layer boundaries, the values are"
+                           "given by the top and bottom layer boundary.");
+
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    AsciiDataLayered<dim>::parse_parameters (ParameterHandler &prm,
+                                             const std::string &subsection_name)
+    {
+      Utilities::AsciiDataBase<dim>::parse_parameters(prm, subsection_name);
+
+      prm.enter_subsection(subsection_name);
+      {
+        data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
+        data_file_names = Utilities::split_string_list(prm.get ("Data file names"), ',');
+        interpolation_scheme = prm.get("Interpolation scheme");
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    AsciiDataInitial<dim>::AsciiDataInitial ()
+      : slice_data(false),
+        rotation_matrix()
+    {}
+
+
+
+    template <int dim>
+    void
+    AsciiDataInitial<dim>::initialize (const unsigned int n_components)
+    {
+      const std::string filename = this->data_directory + this->data_file_name;
+
+      this->get_pcout() << std::endl << "   Loading Ascii data initial file "
+                        << filename << '.' << std::endl << std::endl;
+
+
+      AssertThrow(Utilities::fexists(filename, this->get_mpi_communicator()) || filename_is_url(filename),
+                  ExcMessage (std::string("Ascii data file <")
+                              +
+                              filename
+                              +
+                              "> not found!"));
+
+      if (slice_data == true)
+        {
+          slice_lookup = std::make_unique<Utilities::StructuredDataLookup<3>> (n_components,
+                                                                                this->scale_factor);
+          slice_lookup->load_file(filename, this->get_mpi_communicator());
+        }
+      else
+        {
+          lookup = std::make_unique<Utilities::StructuredDataLookup<dim>> (n_components,
+                                                                            this->scale_factor);
+          lookup->load_file(filename, this->get_mpi_communicator());
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    AsciiDataInitial<dim>::
+    get_data_component (const Point<dim> &position,
+                        const unsigned int component) const
+    {
+      // Handle the special case of slicing through data first
+      if (slice_data == true)
+        {
+          // This implies a SphericalShell, a 2d model, and a 3d dataset as asserted
+          // in the parse_parameters function below.
+
+          // Compute the coordinates of a 3d point based on the 2d position.
+          const Tensor<1,3> position_tensor({position[0], position[1], 0.0});
+          const Point<3> rotated_position (rotation_matrix * position_tensor);
+
+          const std::array<double,3> spherical_position =
+            Utilities::Coordinates::cartesian_to_spherical_coordinates(rotated_position);
+
+          return slice_lookup->get_data(Point<3>(Tensor<1,3>(ArrayView<const double>(spherical_position))),component);
+        }
+
+      // else slice_data == false: model and dataset have the same dimension
+      const Point<dim> data_coordinates = data_coordinates_from_position(position, this->get_geometry_model());
+
+      return lookup->get_data(data_coordinates,component);
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiDataInitial<dim>::declare_parameters (ParameterHandler  &prm,
+                                               const std::string &default_directory,
+                                               const std::string &default_filename,
+                                               const std::string &subsection_name)
+    {
+      Utilities::AsciiDataBase<dim>::declare_parameters(prm,
+                                                        default_directory,
+                                                        default_filename,
+                                                        subsection_name);
+
+      prm.enter_subsection (subsection_name);
+      {
+        prm.declare_entry("Slice dataset in 2D plane", "false",
+                          Patterns::Bool (),
+                          "Whether to use a 2d data slice of a 3d data file "
+                          "or the entire data file. Slicing a 3d dataset is "
+                          "only supported for 2d models.");
+        prm.declare_entry ("First point on slice", "0.0,1.0,0.0",
+                           Patterns::Anything (),
+                           "Point that determines the plane in which the 2d slice lies in. "
+                           "This variable is only used if 'Slice dataset in 2d plane' is true. "
+                           "The slice will go through this point, the point defined by the "
+                           "parameter 'Second point on slice', and the center of the model "
+                           "domain. After the rotation, this first point will lie along the "
+                           "(0,1,0) axis of the coordinate system. The coordinates of the "
+                           "point have to be given in Cartesian coordinates.");
+        prm.declare_entry ("Second point on slice", "1.0,0.0,0.0",
+                           Patterns::Anything (),
+                           "Second point that determines the plane in which the 2d slice lies in. "
+                           "This variable is only used if 'Slice dataset in 2d plane' is true. "
+                           "The slice will go through this point, the point defined by the "
+                           "parameter 'First point on slice', and the center of the model "
+                           "domain. The coordinates of the point have to be given in Cartesian "
+                           "coordinates.");
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    AsciiDataInitial<dim>::parse_parameters (ParameterHandler &prm,
+                                             const std::string &subsection_name)
+    {
+      Utilities::AsciiDataBase<dim>::parse_parameters(prm,
+                                                      subsection_name);
+
+      prm.enter_subsection(subsection_name);
+      {
+        slice_data = prm.get_bool ("Slice dataset in 2D plane");
+        if (slice_data == true)
+          {
+            AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()),
+                         ExcMessage ("Slicing an ascii dataset is only supported when using "
+                                     "a spherical shell geometry."));
+
+            AssertThrow(dim == 2,
+                        ExcMessage("The AsciiDataInitial class can only slice data in 2d models."));
+
+            std::vector<double> point_one = Utilities::string_to_double(Utilities::split_string_list(prm.get("First point on slice")));
+            std::vector<double> point_two = Utilities::string_to_double(Utilities::split_string_list(prm.get("Second point on slice")));
+
+            AssertThrow(point_one.size() == 3 && point_two.size() == 3,
+                        ExcMessage("The points on the slice in the Ascii data model need "
+                                   "to be given in three dimensions; in other words, as three "
+                                   "numbers, separated by commas."));
+
+            Point<3> first_point_on_slice;
+            Point<3> second_point_on_slice;
+
+            for (unsigned int d=0; d<3; ++d)
+              first_point_on_slice[d] = point_one[d];
+
+            for (unsigned int d=0; d<3; ++d)
+              second_point_on_slice[d] = point_two[d];
+
+            rotation_matrix = Utilities::compute_rotation_matrix_for_slice(first_point_on_slice, second_point_on_slice);
+          }
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    AsciiDataProfile<dim>::AsciiDataProfile ()
+      = default;
+
+
+
+    template <int dim>
+    void
+    AsciiDataProfile<dim>::initialize (const MPI_Comm communicator)
+    {
+      lookup = std::make_unique<Utilities::StructuredDataLookup<1>> (this->scale_factor);
+
+      const std::string filename = this->data_directory + this->data_file_name;
+
+      AssertThrow(Utilities::fexists(filename, communicator) || filename_is_url(filename),
+                  ExcMessage (std::string("Ascii data file <")
+                              +
+                              filename
+                              +
+                              "> not found!"));
+      lookup->load_file(filename,communicator);
+    }
+
+
+
+    template <int dim>
+    std::vector<std::string>
+    AsciiDataProfile<dim>::get_column_names() const
+    {
+      return lookup->get_column_names();
+    }
+
+
+
+    template <int dim>
+    unsigned int
+    AsciiDataProfile<dim>::get_column_index_from_name(const std::string &column_name) const
+    {
+      return lookup->get_column_index_from_name(column_name);
+    }
+
+
+
+    template <int dim>
+    unsigned int
+    AsciiDataProfile<dim>::maybe_get_column_index_from_name(const std::string &column_name) const
+    {
+      try
+        {
+          // read the entries in if they exist
+          return lookup->get_column_index_from_name(column_name);
+        }
+      catch (...)
+        {
+          // return an invalid unsigned int entry if the column does not exist
+          return numbers::invalid_unsigned_int;
+        }
+    }
+
+
+
+    template <int dim>
+    std::string
+    AsciiDataProfile<dim>::get_column_name_from_index(const unsigned int column_index) const
+    {
+      return lookup->get_column_name_from_index(column_index);
+    }
+
+
+
+    template <int dim>
+    double
+    AsciiDataProfile<dim>::
+    get_data_component (const Point<1>                      &position,
+                        const unsigned int                   component) const
+    {
+      return lookup->get_data(position,component);
+    }
+
+
+
+    template <int dim>
+    const std::vector<double> &
+    AsciiDataProfile<dim>::get_interpolation_point_coordinates() const
+    {
+      return lookup->get_interpolation_point_coordinates(0);
+    }
+
+
+
+// Explicit instantiations
+
+    template class StructuredDataLookup<1>;
+    template class StructuredDataLookup<2>;
+    template class StructuredDataLookup<3>;
+    template class AsciiDataBase<2>;
+    template class AsciiDataBase<3>;
+    template class AsciiDataBoundary<2>;
+    template class AsciiDataBoundary<3>;
+    template class AsciiDataLayered<2>;
+    template class AsciiDataLayered<3>;
+    template class AsciiDataInitial<2>;
+    template class AsciiDataInitial<3>;
+    template class AsciiDataProfile<1>;
+    template class AsciiDataProfile<2>;
+    template class AsciiDataProfile<3>;
+  }
+}
diff --git a/source/termination_criteria/end_step.cc.bak b/source/termination_criteria/end_step.cc.bak
new file mode 100644
index 00000000000..ebec3937242
--- /dev/null
+++ b/source/termination_criteria/end_step.cc.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/termination_criteria/end_step.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    template <int dim>
+    bool
+    EndStep<dim>::execute()
+    {
+      return (this->get_timestep_number () > end_step);
+    }
+
+    template <int dim>
+    void
+    EndStep<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.declare_entry ("End step", "100",
+                           Patterns::Integer (0),
+                           "Terminate the simulation once the specified timestep has been reached.");
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    EndStep<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        end_step = prm.get_integer ("End step");
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    ASPECT_REGISTER_TERMINATION_CRITERION(EndStep,
+                                          "end step",
+                                          "Terminate the simulation once the specified timestep "
+                                          "has been reached. ")
+  }
+}
diff --git a/source/termination_criteria/end_time.cc.bak b/source/termination_criteria/end_time.cc.bak
new file mode 100644
index 00000000000..c4d4bc5125a
--- /dev/null
+++ b/source/termination_criteria/end_time.cc.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/termination_criteria/end_time.h>
+
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    template <int dim>
+    bool
+    EndTime<dim>::execute()
+    {
+      return (this->get_time() > end_time);
+    }
+
+    template <int dim>
+    double EndTime<dim>::check_for_last_time_step (const double time_step) const
+    {
+      if ((this->get_time()<end_time)
+          &&
+          (this->get_time()+time_step > end_time))
+        return end_time - this->get_time();
+      else
+        return time_step;
+    }
+
+    template <int dim>
+    void
+    EndTime<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.declare_entry ("End time",
+                         /* boost::lexical_cast<std::string>(std::numeric_limits<double>::max() /
+                                              year_in_seconds) = */ "5.69e+300",
+                         Patterns::Double (),
+                         "The end time of the simulation. The default value is a number "
+                         "so that when converted from years to seconds it is approximately "
+                         "equal to the largest number representable in floating point "
+                         "arithmetic. For all practical purposes, this equals infinity. "
+                         "Units: Years if the "
+                         "'Use years in output instead of seconds' parameter is set; "
+                         "seconds otherwise.");
+    }
+
+
+    template <int dim>
+    void
+    EndTime<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      // read end time from parameter file. if it is to be interpreted
+      // in years rather than seconds, then do the conversion
+      end_time = prm.get_double ("End time");
+      if (prm.get_bool ("Use years in output instead of seconds") == true)
+        end_time *= year_in_seconds;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    ASPECT_REGISTER_TERMINATION_CRITERION(EndTime,
+                                          "end time",
+                                          "Terminate the simulation once the end time "
+                                          "specified in the input file has been reached. "
+                                          "Unlike all other termination criteria, this "
+                                          "criterion is \\textit{always} active, whether it "
+                                          "has been explicitly selected or not in the input file "
+                                          "(this is done to preserve historical behavior of "
+                                          "\\aspect{}, but it also likely does not inconvenience "
+                                          "anyone since it is what would be selected in most "
+                                          "cases anyway).")
+  }
+}
diff --git a/source/termination_criteria/end_walltime.cc.bak b/source/termination_criteria/end_walltime.cc.bak
new file mode 100644
index 00000000000..2a1810196ac
--- /dev/null
+++ b/source/termination_criteria/end_walltime.cc.bak
@@ -0,0 +1,80 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/termination_criteria/end_walltime.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    // The start_walltime is made as static and initialized here to
+    // make sure it is initialized when the program starts.
+    template <int dim>
+    std::time_t
+    EndWalltime<dim>::start_walltime = std::time(nullptr);
+
+    template <int dim>
+    bool
+    EndWalltime<dim>::execute()
+    {
+      return std::difftime(std::time(nullptr),start_walltime) >= walltime_duration;
+    }
+
+
+    template <int dim>
+    void
+    EndWalltime<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.declare_entry ("Wall time",
+                           "24.",
+                           Patterns::Double (0.),
+                           "The wall time of the simulation. Unit: hours.");
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    EndWalltime<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        // Change from hours to seconds:
+        walltime_duration = static_cast<unsigned int>(prm.get_double ("Wall time") * 3600.);
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    ASPECT_REGISTER_TERMINATION_CRITERION(EndWalltime,
+                                          "wall time",
+                                          "Terminate the simulation once the wall time limit has reached.")
+  }
+}
diff --git a/source/termination_criteria/interface.cc.bak b/source/termination_criteria/interface.cc.bak
new file mode 100644
index 00000000000..3f6e7998cc5
--- /dev/null
+++ b/source/termination_criteria/interface.cc.bak
@@ -0,0 +1,284 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/termination_criteria/interface.h>
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+
+#include <typeinfo>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+// ------------------------------ Interface -----------------------------
+
+    template <int dim>
+    double Interface<dim>::check_for_last_time_step (const double time_step) const
+    {
+      return time_step;
+    }
+
+
+
+// ------------------------------ Manager -----------------------------
+
+    template <int dim>
+    double Manager<dim>::check_for_last_time_step (const double time_step) const
+    {
+      double new_time_step = time_step;
+      for (const auto &p : this->plugin_objects)
+        {
+          double current_time_step = p->check_for_last_time_step (new_time_step);
+
+          AssertThrow (current_time_step > 0,
+                       ExcMessage("Time step must be greater than 0."));
+          AssertThrow (current_time_step <= new_time_step,
+                       ExcMessage("Current time step must be less than or equal to time step entered into function."));
+
+          new_time_step = std::min(current_time_step, new_time_step);
+        }
+      return new_time_step;
+    }
+
+    template <int dim>
+    bool
+    Manager<dim>::execute () const
+    {
+      bool terminate_simulation = false;
+
+
+      // call the execute() functions of all plugins we have
+      // here in turns.
+      std::list<std::string>::const_iterator  itn = termination_obj_names.begin();
+      for (typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
+           p = this->plugin_objects.begin();
+           p != this->plugin_objects.end(); ++p,++itn)
+        {
+          try
+            {
+              const bool terminate = (*p)->execute ();
+
+              // do the reduction: does any one of the processors
+              // think that we should terminate? (do the reduction in
+              // data type int since there is currently no function
+              // Utilities::MPI::CollectiveOr or similar)
+              const bool all_terminate = (Utilities::MPI::max ((terminate ? 1 : 0),
+                                                               this->get_mpi_communicator())
+                                          == 1);
+              terminate_simulation |= all_terminate;
+
+              // Let the user know which criterion caused the termination
+              if (all_terminate == true)
+                this->get_pcout() << "Termination requested by criterion: "
+                                  << *itn
+                                  << std::endl;
+            }
+          // plugins that throw exceptions usually do not result in
+          // anything good because they result in an unwinding of the stack
+          // and, if only one processor triggers an exception, the
+          // destruction of objects often causes a deadlock. thus, if
+          // an exception is generated, catch it, print an error message,
+          // and abort the program
+          catch (std::exception &exc)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running termination criterion plugin <"
+                        << typeid(**p).name()
+                        << ">: " << std::endl
+                        << exc.what() << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+          catch (...)
+            {
+              std::cerr << std::endl << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+              std::cerr << "Exception on MPI process <"
+                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
+                        << "> while running termination criterion plugin <"
+                        << typeid(**p).name()
+                        << ">: " << std::endl;
+              std::cerr << "Unknown exception!" << std::endl
+                        << "Aborting!" << std::endl
+                        << "----------------------------------------------------"
+                        << std::endl;
+
+              // terminate the program!
+              MPI_Abort (MPI_COMM_WORLD, 1);
+            }
+        }
+
+      return terminate_simulation;
+    }
+
+
+// -------------------------------- Deal with registering plugins and automating
+// -------------------------------- their setup and selection at run time
+
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // first declare the postprocessors we know about to
+      // choose from
+      prm.enter_subsection("Termination criteria");
+      {
+        // construct a string for Patterns::MultipleSelection that
+        // contains the names of all registered termination criteria
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+        prm.declare_entry("Termination criteria",
+                          "end time",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma separated list of termination criteria that will "
+                          "determine when the simulation should end. "
+                          "Whether explicitly stated or not, the ``end time'' "
+                          "termination criterion will always be used."
+                          "The following termination criteria are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+      }
+      prm.leave_subsection();
+
+      // now declare the parameters of each of the registered
+      // plugins in turn
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      Assert (std::get<dim>(registered_plugins).plugins != nullptr,
+              ExcMessage ("No termination criteria plugins registered!?"));
+
+      // first find out which plugins are requested
+      std::vector<std::string> plugin_names;
+      prm.enter_subsection("Termination criteria");
+      {
+        plugin_names = Utilities::split_string_list(prm.get("Termination criteria"));
+        AssertThrow(Utilities::has_unique_entries(plugin_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Termination criteria/Termination criteria' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+
+        // as described, the end time plugin is always active
+        if (std::find (plugin_names.begin(), plugin_names.end(), "end time")
+            == plugin_names.end())
+          plugin_names.emplace_back("end time");
+      }
+      prm.leave_subsection();
+
+      // go through the list, create objects, initialize them, and let them parse
+      // their own parameters
+      for (const auto &plugin_name : plugin_names)
+        {
+          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
+                                          (std::get<dim>(registered_plugins)
+                                           .create_plugin (plugin_name,
+                                                           "Termination criteria::Termination criteria")));
+          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
+            sim->initialize_simulator (this->get_simulator());
+          this->plugin_objects.back()->parse_parameters (prm);
+          this->plugin_objects.back()->initialize ();
+
+          termination_obj_names.push_back(plugin_name);
+        }
+    }
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_termination_criterion (const std::string &name,
+                                                  const std::string &description,
+                                                  void (*declare_parameters_function) (ParameterHandler &),
+                                                  std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Termination criteria interface",
+                                                            out);
+    }
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<TerminationCriteria::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<TerminationCriteria::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<TerminationCriteria::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<TerminationCriteria::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace TerminationCriteria
+  {
+#define INSTANTIATE(dim) \
+  template class Interface<dim>; \
+  template class Manager<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/termination_criteria/steady_heat_flux.cc.bak b/source/termination_criteria/steady_heat_flux.cc.bak
new file mode 100644
index 00000000000..cc1530914be
--- /dev/null
+++ b/source/termination_criteria/steady_heat_flux.cc.bak
@@ -0,0 +1,233 @@
+/*
+  Copyright (C) 2021 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/termination_criteria/steady_heat_flux.h>
+#include <aspect/postprocess/heat_flux_map.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    namespace
+    {
+      /**
+       * A function that trims the handed over list and removes all entries from the front that are
+       * further back in time measured from the last entry than given by the first argument.
+       * Additionally it makes sure to always keep two entries in the list, if the list had
+       * two or more entries. Otherwise the function does not change the list.
+       */
+      void trim_time_heat_flux_list (const double necessary_time_in_steady_state,
+                                     std::list<std::pair<double, double>> &time_heat_flux_list)
+      {
+        // Remove old times until we're at the correct time period
+        // but ensure at least two entries remain in the list (one old, one current timestep)
+        auto it = time_heat_flux_list.begin();
+        while (time_heat_flux_list.back().first - (*it).first > necessary_time_in_steady_state &&
+               std::distance(it,time_heat_flux_list.end()) > 2)
+          ++it;
+
+        time_heat_flux_list.erase(time_heat_flux_list.begin(), it);
+      }
+    }
+
+
+
+    template <int dim>
+    bool
+    SteadyHeatFlux<dim>::execute()
+    {
+      const std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area =
+        Postprocess::internal::compute_heat_flux_through_boundary_faces (*this);
+
+      double local_boundary_fluxes = 0.0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          for (const unsigned int f : cell->face_indices())
+            if (cell->at_boundary(f))
+              {
+                const types::boundary_id boundary_indicator
+                  = cell->face(f)->boundary_id();
+                if (boundary_indicators.find(boundary_indicator) != boundary_indicators.end())
+                  local_boundary_fluxes += heat_flux_and_area[cell->active_cell_index()][f].first;
+              }
+
+      const double global_heat_flux_integral
+        = Utilities::MPI::sum (local_boundary_fluxes, this->get_mpi_communicator());
+
+      // Keep a list of times and heat fluxes at those times
+      time_heat_flux.emplace_back(this->get_time(), global_heat_flux_integral);
+
+      // If the length of the simulation time covered in the list is shorter than the
+      // specified parameter, we must continue the simulation
+      if ((time_heat_flux.size() <= 2)
+          ||
+          (time_heat_flux.back().first - time_heat_flux.front().first < necessary_time_in_steady_state))
+        return false;
+
+      // Remove old entries outside of current time window
+      trim_time_heat_flux_list(necessary_time_in_steady_state,time_heat_flux);
+
+      // Scan through the list and calculate the min, mean and max heat flux
+      // We assume a linear change of heat flux between times
+      double flux_min, flux_max, flux_prev, time_prev, flux_sum=0, flux_mean, deviation_max;
+      flux_min = flux_max = flux_prev = time_heat_flux.front().second;
+      time_prev = time_heat_flux.front().first;
+      for (const auto &it : time_heat_flux)
+        {
+          flux_min = std::min(flux_min, it.second);
+          flux_max = std::max(flux_max, it.second);
+          flux_sum += ((it.second + flux_prev)/2.0)*(it.first-time_prev);
+          time_prev = it.first;
+          flux_prev = it.second;
+        }
+
+      flux_mean = flux_sum/(time_heat_flux.back().first-time_heat_flux.front().first);
+
+      // If the min and max are within the acceptable deviation of the mean,
+      // we are in steady state and return true, otherwise return false
+      deviation_max = std::max(flux_mean - flux_min, flux_max - flux_mean);
+
+      AssertThrow(std::abs(flux_mean) > std::numeric_limits<double>::min(),
+                  ExcMessage("The average heat flux is close to 0.0. The "
+                             "'steady state heat flux' plugin can not compute a "
+                             "relative deviation of heat flux in this case."));
+
+      if (deviation_max/flux_mean > allowed_relative_deviation)
+        return false;
+
+      return true;
+    }
+
+
+    template <int dim>
+    void
+    SteadyHeatFlux<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.enter_subsection("Steady state heat flux");
+        {
+          prm.declare_entry ("Maximum relative deviation", "0.05",
+                             Patterns::Double (0.),
+                             "The maximum relative deviation of the heat flux in recent "
+                             "simulation time for the system to be considered in "
+                             "steady state. If the actual deviation is smaller "
+                             "than this number, then the simulation will be terminated.");
+          prm.declare_entry ("Time in steady state", "1e7",
+                             Patterns::Double (0.),
+                             "The minimum length of simulation time that the system "
+                             "should be in steady state before termination. "
+                             "Note that if the time step size is similar to or larger than "
+                             "this value, the termination criterion will only have very few "
+                             "(in the most extreme case, just two) heat flux values to check. "
+                             "To ensure that a larger number of time steps are included in "
+                             "the check for steady state, this value should be much larger "
+                             "than the time step size. "
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+          prm.declare_entry ("Boundary indicators", "",
+                             Patterns::List (Patterns::Anything()),
+                             "A comma separated list of names denoting those boundaries "
+                             "that should be taken into account for integrating the heat "
+                             "flux. Note that the plugin will compute the integrated heat "
+                             "flux over these boundaries (instead of taking them into "
+                             "account individually)."
+                             "\n\n"
+                             "The names of the boundaries listed here can either be "
+                             "numbers (in which case they correspond to the numerical "
+                             "boundary indicators assigned by the geometry object), or they "
+                             "can correspond to any of the symbolic names the geometry object "
+                             "may have provided for each part of the boundary. You may want "
+                             "to compare this with the documentation of the geometry model you "
+                             "use in your model.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    SteadyHeatFlux<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.enter_subsection("Steady state heat flux");
+        {
+          allowed_relative_deviation = prm.get_double ("Maximum relative deviation");
+          necessary_time_in_steady_state = prm.get_double ("Time in steady state");
+          necessary_time_in_steady_state *= this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+          try
+            {
+              const std::vector<types::boundary_id> x_boundary_indicators
+                = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
+                                                                                      (prm.get ("Boundary indicators")));
+              boundary_indicators
+                = std::set<types::boundary_id> (x_boundary_indicators.begin(),
+                                                x_boundary_indicators.end());
+
+              AssertThrow (boundary_indicators.size() != 0,
+                           ExcMessage ("You have specified the steady state heat flux as one of "
+                                       "the termination criteria, but the list of boundary indicators "
+                                       "that should be used for computing the heat flux is empty."));
+            }
+          catch (const std::string &error)
+            {
+              AssertThrow (false, ExcMessage ("While parsing the entry <Termination criteria/Steady "
+                                              "state heat flux>, there was an error. Specifically, "
+                                              "the conversion function complained as follows: "
+                                              + error));
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+
+      AssertThrow (allowed_relative_deviation >= 0,
+                   ExcMessage("Relative deviation must be greater than or equal to 0."));
+      AssertThrow (necessary_time_in_steady_state > 0,
+                   ExcMessage("Steady state minimum time period must be greater than 0."));
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    ASPECT_REGISTER_TERMINATION_CRITERION(SteadyHeatFlux,
+                                          "steady state heat flux",
+                                          "A criterion that terminates the simulation when the integrated "
+                                          "heat flux over a given list of boundaries stays within a certain "
+                                          "range for a specified period of time."
+                                          "\n\n"
+                                          "The criterion considers the total heat flux over all boundaries "
+                                          "listed by their boundary indicators, rather than each boundary "
+                                          "separately. As a consequence, if the \\textit{sum} of heat fluxes "
+                                          "over individual parts of the boundary no longer changes, then this "
+                                          "criterion recommends termination, even if the heat flux over "
+                                          "individual parts of the boundary continues to change.")
+  }
+}
diff --git a/source/termination_criteria/steady_rms_velocity.cc.bak b/source/termination_criteria/steady_rms_velocity.cc.bak
new file mode 100644
index 00000000000..3aa2ccd0782
--- /dev/null
+++ b/source/termination_criteria/steady_rms_velocity.cc.bak
@@ -0,0 +1,172 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/termination_criteria/steady_rms_velocity.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    template <int dim>
+    bool
+    SteadyRMSVelocity<dim>::execute()
+    {
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
+
+      double local_velocity_square_integral = 0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                                                                                        velocity_values);
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                local_velocity_square_integral += ((velocity_values[q] * velocity_values[q]) *
+                                                   fe_values.JxW(q));
+              }
+          }
+
+      const double global_velocity_square_integral
+        = Utilities::MPI::sum (local_velocity_square_integral, this->get_mpi_communicator());
+
+      // Calculate the global root mean square velocity
+      const double vrms = std::sqrt(global_velocity_square_integral) / std::sqrt(this->get_volume());
+
+      // Keep a list of times and RMS velocities at those times
+      time_rmsvel.emplace_back(this->get_time(), vrms);
+
+      // If the length of the simulation time covered in the list is shorter than the
+      // specified parameter, we must continue the simulation
+      const double adjusted_time
+        = time_length * (this->convert_output_to_years() ? year_in_seconds : 1);
+      if ((time_rmsvel.size() == 0)
+          ||
+          (time_rmsvel.back().first - time_rmsvel.front().first < adjusted_time))
+        return false;
+
+      // Remove old times until we're at the correct time period
+      std::list<std::pair<double, double>>::iterator it = time_rmsvel.begin();
+      while (time_rmsvel.back().first - (*it).first > adjusted_time)
+        ++it;
+      time_rmsvel.erase(time_rmsvel.begin(), it);
+
+      // Scan through the list and calculate the min, mean and max of the RMS velocities
+      // We assume a linear change of RMS velocity between times
+      double      rms_min, rms_max, rms_prev, time_prev, rms_sum=0, rms_mean, deviation_max;
+      rms_min = rms_max = rms_prev = time_rmsvel.front().second;
+      time_prev = time_rmsvel.front().first;
+      for (it=time_rmsvel.begin(); it!=time_rmsvel.end(); ++it)
+        {
+          rms_min = std::min(rms_min, (*it).second);
+          rms_max = std::max(rms_max, (*it).second);
+          rms_sum += (((*it).second + rms_prev)/2.0)*((*it).first-time_prev);
+          time_prev = (*it).first;
+          rms_prev = (*it).second;
+        }
+      rms_mean = rms_sum/(time_rmsvel.back().first-time_rmsvel.front().first);
+
+      // If the min and max are within the acceptable deviation of the mean,
+      // we are in steady state and return true, otherwise return false
+      deviation_max = std::max(rms_mean - rms_min, rms_max - rms_mean);
+
+      if (deviation_max/rms_mean > relative_deviation)
+        return false;
+
+      return true;
+    }
+
+
+    template <int dim>
+    void
+    SteadyRMSVelocity<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.enter_subsection("Steady state velocity");
+        {
+          prm.declare_entry ("Maximum relative deviation", "0.05",
+                             Patterns::Double (0.),
+                             "The maximum relative deviation of the RMS in recent "
+                             "simulation time for the system to be considered in "
+                             "steady state. If the actual deviation is smaller "
+                             "than this number, then the simulation will be terminated.");
+          prm.declare_entry ("Time in steady state", "1e7",
+                             Patterns::Double (0.),
+                             "The minimum length of simulation time that the system "
+                             "should be in steady state before termination."
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    SteadyRMSVelocity<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.enter_subsection("Steady state velocity");
+        {
+          relative_deviation = prm.get_double ("Maximum relative deviation");
+          time_length = prm.get_double ("Time in steady state");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+      AssertThrow (relative_deviation >= 0,
+                   ExcMessage("Relative deviation must be greater than or equal to 0."));
+      AssertThrow (time_length > 0,
+                   ExcMessage("Steady state minimum time period must be greater than 0."));
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    ASPECT_REGISTER_TERMINATION_CRITERION(SteadyRMSVelocity,
+                                          "steady state velocity",
+                                          "A criterion that terminates the simulation when the RMS "
+                                          "of the velocity field stays within a certain range for a "
+                                          "specified period of time.")
+  }
+}
diff --git a/source/termination_criteria/steady_temperature.cc.bak b/source/termination_criteria/steady_temperature.cc.bak
new file mode 100644
index 00000000000..6a0c69da92c
--- /dev/null
+++ b/source/termination_criteria/steady_temperature.cc.bak
@@ -0,0 +1,199 @@
+/*
+  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/termination_criteria/steady_temperature.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    namespace
+    {
+      /**
+       * A function that trims the handed over list and removes all entries from the front that are
+       * further back in time measured from the last entry than given by the first argument.
+       * Additionally it makes sure to always keep two entries in the list, if the list had
+       * two or more entries. Otherwise the function does not change the list.
+       */
+      void trim_time_temperature_list (const double necessary_time_in_steady_state,
+                                       std::list<std::pair<double, double>> &time_temperature_list)
+      {
+        // Remove old times until we're at the correct time period
+        // but ensure at least two entries remain in the list (one old, one current timestep)
+        auto it = time_temperature_list.begin();
+        while (time_temperature_list.back().first - (*it).first > necessary_time_in_steady_state &&
+               std::distance(it,time_temperature_list.end()) > 2)
+          ++it;
+
+        time_temperature_list.erase(time_temperature_list.begin(), it);
+      }
+    }
+
+
+
+    template <int dim>
+    bool
+    SteadyTemperature<dim>::execute()
+    {
+      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values   |
+                               update_quadrature_points |
+                               update_JxW_values);
+      std::vector<double> temperature_values(n_q_points);
+
+      double local_temperature_integral = 0;
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell = this->get_dof_handler().begin_active(),
+      endc = this->get_dof_handler().end();
+      for (; cell!=endc; ++cell)
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
+                                                                                         temperature_values);
+            for (unsigned int q = 0; q < n_q_points; ++q)
+              {
+                local_temperature_integral += (temperature_values[q] * fe_values.JxW(q));
+              }
+          }
+
+      const double global_temperature_integral
+        = Utilities::MPI::sum (local_temperature_integral, this->get_mpi_communicator());
+
+      // Calculate the average global temperature
+      const double average_temperature = global_temperature_integral / this->get_volume();
+
+      // Keep a list of times and temperatures at those times
+      time_temperature.emplace_back(this->get_time(), average_temperature);
+
+      // If the length of the simulation time covered in the list is shorter than the
+      // specified parameter, we must continue the simulation
+      if ((time_temperature.size() <= 2)
+          ||
+          (time_temperature.back().first - time_temperature.front().first < necessary_time_in_steady_state))
+        return false;
+
+      // Remove old entries outside of current time window
+      trim_time_temperature_list(necessary_time_in_steady_state,time_temperature);
+
+      // Scan through the list and calculate the min, mean and max temperature
+      // We assume a linear change of temperatures between times
+      double T_min, T_max, T_prev, time_prev, T_sum=0, T_mean, deviation_max;
+      T_min = T_max = T_prev = time_temperature.front().second;
+      time_prev = time_temperature.front().first;
+      for (const auto &it : time_temperature)
+        {
+          T_min = std::min(T_min, it.second);
+          T_max = std::max(T_max, it.second);
+          T_sum += ((it.second + T_prev)/2.0)*(it.first-time_prev);
+          time_prev = it.first;
+          T_prev = it.second;
+        }
+
+      T_mean = T_sum/(time_temperature.back().first-time_temperature.front().first);
+
+      // If the min and max are within the acceptable deviation of the mean,
+      // we are in steady state and return true, otherwise return false
+      deviation_max = std::max(T_mean - T_min, T_max - T_mean);
+
+      AssertThrow(std::abs(T_mean) > std::numeric_limits<double>::min(),
+                  ExcMessage("The average temperature is close to 0.0. The "
+                             "'steady state temperature' plugin can not compute a "
+                             "relative deviation of temperature in this case."));
+
+      if (deviation_max/T_mean > allowed_relative_deviation)
+        return false;
+
+      return true;
+    }
+
+
+    template <int dim>
+    void
+    SteadyTemperature<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.enter_subsection("Steady state temperature");
+        {
+          prm.declare_entry ("Maximum relative deviation", "0.05",
+                             Patterns::Double (0.),
+                             "The maximum relative deviation of the temperature in recent "
+                             "simulation time for the system to be considered in "
+                             "steady state. If the actual deviation is smaller "
+                             "than this number, then the simulation will be terminated.");
+          prm.declare_entry ("Time in steady state", "1e7",
+                             Patterns::Double (0.),
+                             "The minimum length of simulation time that the system "
+                             "should be in steady state before termination."
+                             "Units: years if the "
+                             "'Use years in output instead of seconds' parameter is set; "
+                             "seconds otherwise.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    SteadyTemperature<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.enter_subsection("Steady state temperature");
+        {
+          allowed_relative_deviation = prm.get_double ("Maximum relative deviation");
+          necessary_time_in_steady_state = prm.get_double ("Time in steady state");
+          necessary_time_in_steady_state *= this->convert_output_to_years() ? year_in_seconds : 1.0;
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+      AssertThrow (allowed_relative_deviation >= 0,
+                   ExcMessage("Relative deviation must be greater than or equal to 0."));
+      AssertThrow (necessary_time_in_steady_state > 0,
+                   ExcMessage("Steady state minimum time period must be greater than 0."));
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    ASPECT_REGISTER_TERMINATION_CRITERION(SteadyTemperature,
+                                          "steady state temperature",
+                                          "A criterion that terminates the simulation when the global integral "
+                                          "of the temperature field stays within a certain range for a "
+                                          "specified period of time.")
+  }
+}
diff --git a/source/termination_criteria/user_request.cc.bak b/source/termination_criteria/user_request.cc.bak
new file mode 100644
index 00000000000..1ff543616d9
--- /dev/null
+++ b/source/termination_criteria/user_request.cc.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/termination_criteria/user_request.h>
+#include <aspect/utilities.h>
+
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    template <int dim>
+    bool
+    UserRequest<dim>::execute()
+    {
+      return Utilities::fexists(this->get_output_directory()+filename_to_test, this->get_mpi_communicator());
+    }
+
+    template <int dim>
+    void
+    UserRequest<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.enter_subsection("User request");
+        {
+          prm.declare_entry ("File name", "terminate-aspect",
+                             Patterns::FileName(Patterns::FileName::input),
+                             "The name of a file that, if it exists in the output "
+                             "directory (whose name is also specified in the input file) "
+                             "will lead to termination of the simulation. "
+                             "The file's location is chosen to be in the output directory, "
+                             "rather than in a generic location such as the ASPECT directory, "
+                             "so that one can run multiple simulations at the same time (which "
+                             "presumably write to different output directories) and can "
+                             "selectively terminate a particular one.");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    UserRequest<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.enter_subsection("User request");
+        {
+          filename_to_test = prm.get ("File name");
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TerminationCriteria
+  {
+    ASPECT_REGISTER_TERMINATION_CRITERION(UserRequest,
+                                          "user request",
+                                          "Terminate the simulation gracefully when a file with a specified "
+                                          "name appears in the output directory. This allows the user to "
+                                          "gracefully exit the simulation at any time by simply creating "
+                                          "such a file using, for example, \\texttt{touch output/terminate}. "
+                                          "The file's location is chosen to be in the output directory, "
+                                          "rather than in a generic location such as the ASPECT directory, "
+                                          "so that one can run multiple simulations at the same time (which "
+                                          "presumably write to different output directories) and can "
+                                          "selectively terminate a particular one.")
+  }
+}
diff --git a/source/time_stepping/conduction_time_step.cc.bak b/source/time_stepping/conduction_time_step.cc.bak
new file mode 100644
index 00000000000..7df04c5fa67
--- /dev/null
+++ b/source/time_stepping/conduction_time_step.cc.bak
@@ -0,0 +1,131 @@
+/*
+  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/time_stepping/conduction_time_step.h>
+#include <aspect/adiabatic_conditions/interface.h>
+
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    template <int dim>
+    double
+    ConductionTimeStep<dim>::execute()
+    {
+      double min_local_conduction_timestep = std::numeric_limits<double>::max();
+
+      const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
+                                               this->get_parameters().stokes_velocity_degree);
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values |
+                               update_gradients |
+                               update_quadrature_points);
+
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      MaterialModel::MaterialModelInputs<dim> in(n_q_points,
+                                                 this->introspection().n_compositional_fields);
+      MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
+                                                   this->introspection().n_compositional_fields);
+      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties |
+                                MaterialModel::MaterialProperties::thermal_conductivity;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            in.reinit(fe_values,
+                      cell,
+                      this->introspection(),
+                      this->get_solution());
+
+            this->get_material_model().evaluate(in, out);
+
+            if (this->get_parameters().formulation_temperature_equation
+                == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
+              {
+                // Overwrite the density by the reference density coming from the
+                // adiabatic conditions as required by the formulation
+                for (unsigned int q=0; q<n_q_points; ++q)
+                  out.densities[q] = this->get_adiabatic_conditions().density(in.position[q]);
+              }
+            else if (this->get_parameters().formulation_temperature_equation
+                     == Parameters<dim>::Formulation::TemperatureEquation::real_density)
+              {
+                // use real density
+              }
+            else
+              AssertThrow(false, ExcNotImplemented());
+
+            // Evaluate thermal diffusivity at each quadrature point and
+            // calculate the corresponding conduction timestep, if applicable
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                const double k = out.thermal_conductivities[q];
+                const double rho = out.densities[q];
+                const double c_p = out.specific_heat[q];
+
+                Assert(rho * c_p > 0,
+                       ExcMessage ("The product of density and c_P needs to be a "
+                                   "non-negative quantity."));
+
+                const double thermal_diffusivity = k/(rho*c_p);
+
+                if (thermal_diffusivity > 0)
+                  {
+                    min_local_conduction_timestep = std::min(min_local_conduction_timestep,
+                                                             this->get_parameters().CFL_number*pow(cell->minimum_vertex_distance(),2.)
+                                                             / thermal_diffusivity);
+                  }
+              }
+          }
+
+      const double min_conduction_timestep = Utilities::MPI::min (min_local_conduction_timestep, this->get_mpi_communicator());
+
+      AssertThrow (min_conduction_timestep > 0,
+                   ExcMessage("The time step length for the each time step needs to be positive, "
+                              "but the computed step length was: " + std::to_string(min_conduction_timestep) + ". "
+                              "Please check for non-positive material properties."));
+
+      return min_conduction_timestep;
+    }
+
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    ASPECT_REGISTER_TIME_STEPPING_MODEL(ConductionTimeStep,
+                                        "conduction time step",
+                                        "This model computes the conduction time step as the minimum "
+                                        "over all cells of $ CFL h^2 \\cdot \\rho C_p / k$, "
+                                        "where k is the thermal conductivity. This plugin will always "
+                                        "request advancing to the next time step.")
+  }
+}
diff --git a/source/time_stepping/convection_time_step.cc.bak b/source/time_stepping/convection_time_step.cc.bak
new file mode 100644
index 00000000000..9460a30d9b3
--- /dev/null
+++ b/source/time_stepping/convection_time_step.cc.bak
@@ -0,0 +1,109 @@
+/*
+  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/time_stepping/convection_time_step.h>
+
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    template <int dim>
+    double
+    ConvectionTimeStep<dim>::execute()
+    {
+      const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
+                                               this->get_parameters().stokes_velocity_degree);
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_values);
+
+      const unsigned int n_q_points = quadrature_formula.size();
+
+      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
+      std::vector<Tensor<1,dim>> fluid_velocity_values(n_q_points);
+
+      double max_local_speed_over_meshsize = 0;
+
+      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                                                                                        velocity_values);
+
+            double max_local_velocity = 0;
+            for (unsigned int q=0; q<n_q_points; ++q)
+              max_local_velocity = std::max (max_local_velocity,
+                                             velocity_values[q].norm());
+
+            if (this->get_parameters().include_melt_transport)
+              {
+                const FEValuesExtractors::Vector ex_u_f = this->introspection().variable("fluid velocity").extractor_vector();
+                fe_values[ex_u_f].get_function_values (this->get_solution(), fluid_velocity_values);
+
+                for (unsigned int q=0; q<n_q_points; ++q)
+                  max_local_velocity = std::max (max_local_velocity,
+                                                 fluid_velocity_values[q].norm());
+              }
+
+            max_local_speed_over_meshsize = std::max(max_local_speed_over_meshsize,
+                                                     max_local_velocity
+                                                     /
+                                                     cell->minimum_vertex_distance());
+
+          }
+
+      const double max_global_speed_over_meshsize
+        = Utilities::MPI::max (max_local_speed_over_meshsize, this->get_mpi_communicator());
+
+      double min_convection_timestep = std::numeric_limits<double>::max();
+
+      if (max_global_speed_over_meshsize != 0.0)
+        min_convection_timestep = this->get_parameters().CFL_number / (this->get_parameters().temperature_degree * max_global_speed_over_meshsize);
+
+      AssertThrow (min_convection_timestep > 0,
+                   ExcMessage("The time step length for the each time step needs to be positive, "
+                              "but the computed step length was: " + std::to_string(min_convection_timestep) + ". "
+                              "Please check for non-positive material properties."));
+
+      return min_convection_timestep;
+    }
+
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    ASPECT_REGISTER_TIME_STEPPING_MODEL(ConvectionTimeStep,
+                                        "convection time step",
+                                        "This model computes the convection time step as "
+                                        "$ CFL / \\max \\| u \\| / h$ over all cells, "
+                                        "where $u$ is the velocity and $h$ is the product of mesh size "
+                                        "and temperature polynomial degree.")
+  }
+}
diff --git a/source/time_stepping/function.cc.bak b/source/time_stepping/function.cc.bak
new file mode 100644
index 00000000000..01c554214ba
--- /dev/null
+++ b/source/time_stepping/function.cc.bak
@@ -0,0 +1,106 @@
+/*
+  Copyright (C) 2018 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/time_stepping/function.h>
+
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    template <int dim>
+    double
+    Function<dim>::execute()
+    {
+      double new_time_step = function.value(Point<1>(this->get_time()));
+
+      AssertThrow (new_time_step > 0,
+                   ExcMessage("The time step length for the each time step needs to be positive, "
+                              "but the computed step length of the \"function\" plugin was: " +
+                              std::to_string(new_time_step) + "."));
+
+      return new_time_step;
+    }
+
+
+
+    template <int dim>
+    void
+    Function<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Time stepping");
+      {
+        prm.enter_subsection("Function");
+        Functions::ParsedFunction<1>::declare_parameters (prm, 1);
+        prm.declare_entry("Function expression", "1.0",
+                          Patterns::Anything(),
+                          "Expression for the time step size as a function of 'time'.");
+        prm.declare_entry("Variable names", "time",
+                          Patterns::Anything(),
+                          "Name for the variable representing the current time.");
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    Function<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Time stepping");
+      {
+        prm.enter_subsection("Function");
+        try
+          {
+            function.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Timestepping.Function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'"
+                      << "More information about the cause of the parse error \n"
+                      << "is shown below.\n";
+            throw;
+          }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    ASPECT_REGISTER_TIME_STEPPING_MODEL(Function,
+                                        "function",
+                                        "This model uses a time step specified in the parameter "
+                                        "file specified as a function of time. This plugin will always "
+                                        "request advancing to the next time step.")
+  }
+}
diff --git a/source/time_stepping/interface.cc.bak b/source/time_stepping/interface.cc.bak
new file mode 100644
index 00000000000..584da9baedd
--- /dev/null
+++ b/source/time_stepping/interface.cc.bak
@@ -0,0 +1,380 @@
+/*
+  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <aspect/time_stepping/interface.h>
+#include <aspect/simulator.h>
+
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    namespace
+    {
+      std::tuple
+      <void *,
+      void *,
+      aspect::internal::Plugins::PluginList<Interface<2>>,
+      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
+    }
+
+
+
+    template <int dim>
+    std::pair<Reaction, double>
+    Interface<dim>::
+    determine_reaction (const TimeStepInfo & /*info*/)
+    {
+      return std::make_pair<Reaction, double>(Reaction::advance, std::numeric_limits<double>::max());
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::
+    update()
+    {
+      double new_time_step = std::numeric_limits<double>::max();
+
+      for (const auto &plugin : this->plugin_objects)
+        {
+          const double this_time_step = plugin->execute();
+          new_time_step = std::min(new_time_step, this_time_step);
+        }
+
+      new_time_step = Utilities::MPI::min(new_time_step, this->get_mpi_communicator());
+
+      // Do not go below a minimum time step size as given by the user. Note that
+      // we first apply the minimum and then apply further restrictions that might
+      // lower this value. Hitting the end time is more important than a minimum
+      // time step size, for example.
+      new_time_step = std::max(minimum_time_step_size, new_time_step);
+
+      // Make sure we do not exceed the maximum time step length. This can happen
+      // if velocities get too small or even zero in models that are stably stratified
+      // or use prescribed velocities.
+      new_time_step = std::min(new_time_step, this->get_parameters().maximum_time_step);
+
+      // Make sure that the time step doesn't increase too fast
+      if (this->get_timestep() != 0)
+        new_time_step = std::min(new_time_step, this->get_timestep() + this->get_timestep() * this->get_parameters().maximum_relative_increase_time_step);
+
+      // Make sure we do not exceed the maximum length for the first time step
+      if (this->get_timestep_number() == 0)
+        new_time_step = std::min(new_time_step, this->get_parameters().maximum_first_time_step);
+
+      // Make sure we reduce the time step length appropriately if we terminate after this step
+      TimeStepInfo info;
+      info.reduced_by_termination_plugin = false;
+      {
+        const double reduced_time_step = termination_manager.check_for_last_time_step(new_time_step);
+        if (reduced_time_step < new_time_step)
+          {
+            new_time_step = reduced_time_step;
+            info.reduced_by_termination_plugin = true;
+          }
+      }
+      info.next_time_step_size = new_time_step;
+
+      AssertThrow (new_time_step > 0,
+                   ExcMessage("The time step length for the each time step needs to be positive, "
+                              "but the computed step length was: " + std::to_string(new_time_step) + ". "
+                              "Please check the time stepping plugins in use."));
+
+      Reaction reaction = Reaction::advance;
+      double repeat_step_size = std::numeric_limits<double>::max();
+
+      for (const auto &plugin : this->plugin_objects)
+        {
+          const std::pair<Reaction, double> answer = plugin->determine_reaction(info);
+          reaction = static_cast<Reaction>(std::min(reaction, answer.first));
+          repeat_step_size = std::min(repeat_step_size, answer.second);
+        }
+
+      reaction = static_cast<Reaction>(Utilities::MPI::min(static_cast<int>(reaction), this->get_mpi_communicator()));
+      repeat_step_size = Utilities::MPI::min(repeat_step_size, this->get_mpi_communicator());
+
+      current_reaction = reaction;
+      if (should_repeat_time_step())
+        next_time_step_size = repeat_step_size;
+      else
+        next_time_step_size = new_time_step;
+    }
+
+
+
+    template <int dim>
+    double
+    Manager<dim>::get_next_time_step_size() const
+    {
+      return next_time_step_size;
+    }
+
+
+
+    template <int dim>
+    bool
+    Manager<dim>::should_repeat_time_step() const
+    {
+      switch (current_reaction)
+        {
+          case Reaction::refine_and_repeat_step:
+            return true;
+          case Reaction::repeat_step:
+            return true;
+          case Reaction::refine_and_advance:
+            return false;
+          case Reaction::advance:
+            return false;
+
+          default:
+            AssertThrow(false, ExcNotImplemented());
+            return false;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    Manager<dim>::should_refine_mesh() const
+    {
+      switch (current_reaction)
+        {
+          case Reaction::refine_and_repeat_step:
+            return true;
+          case Reaction::repeat_step:
+            return false;
+          case Reaction::refine_and_advance:
+            return true;
+          case Reaction::advance:
+            return false;
+
+          default:
+            AssertThrow(false, ExcNotImplemented());
+            return false;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    Manager<dim>::
+    need_checkpoint_on_terminate() const
+    {
+      return do_checkpoint_on_terminate;
+    }
+
+
+
+    template <int dim>
+    bool
+    Manager<dim>::should_simulation_terminate_now() const
+    {
+      return termination_manager.execute();
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::initialize_simulator (const Simulator<dim> &simulator_object)
+    {
+      SimulatorAccess<dim>::initialize_simulator(simulator_object);
+      termination_manager.initialize_simulator(simulator_object);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::register_time_stepping_model(const std::string &name,
+                                               const std::string &description,
+                                               void (*declare_parameters_function) (ParameterHandler &),
+                                               std::unique_ptr<Interface<dim>> (*factory_function) ())
+    {
+      std::get<dim>(registered_plugins).register_plugin (name,
+                                                         description,
+                                                         declare_parameters_function,
+                                                         factory_function);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>:: declare_parameters (ParameterHandler &prm)
+    {
+      TerminationCriteria::Manager<dim>::declare_parameters(prm);
+      prm.enter_subsection("Termination criteria");
+      {
+        prm.declare_entry("Checkpoint on termination", "false",
+                          Patterns::Bool (),
+                          "Whether to checkpoint the simulation right before termination.");
+      }
+      prm.leave_subsection();
+
+
+      prm.enter_subsection("Time stepping");
+      {
+        prm.declare_entry("Minimum time step size", "0.",
+                          Patterns::Double (0.),
+                          "Specify a minimum time step size (or 0 to disable).");
+
+        const std::string pattern_of_names
+          = std::get<dim>(registered_plugins).get_pattern_of_names ();
+
+        prm.declare_entry("List of model names",
+                          "",
+                          Patterns::MultipleSelection(pattern_of_names),
+                          "A comma separated list of time stepping plugins that "
+                          "will be used to calculate the time step size. The minimum of the "
+                          " result of each plugin will be used.\n\n"
+                          "The following plugins are available:\n\n"
+                          +
+                          std::get<dim>(registered_plugins).get_description_string());
+
+      }
+      prm.leave_subsection();
+
+      std::get<dim>(registered_plugins).declare_parameters (prm);
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      termination_manager.parse_parameters(prm);
+      prm.enter_subsection("Termination criteria");
+      {
+        do_checkpoint_on_terminate = prm.get_bool("Checkpoint on termination");
+      }
+      prm.leave_subsection();
+
+      {
+        prm.enter_subsection("Time stepping");
+
+        minimum_time_step_size = prm.get_double("Minimum time step size")
+                                 * (this->convert_output_to_years() ? year_in_seconds : 1.0);
+
+        std::vector<std::string>
+        model_names
+          = Utilities::split_string_list(prm.get("List of model names"));
+
+        AssertThrow(Utilities::has_unique_entries(model_names),
+                    ExcMessage("The list of strings for the parameter "
+                               "'Time stepping/List of model names' contains entries more than once. "
+                               "This is not allowed. Please check your parameter file."));
+
+        if (model_names.size()==0)
+          {
+            // handle the default case, where the user has not chosen any time stepping scheme explicitly:
+
+            model_names.emplace_back("convection time step");
+
+            if (this->get_parameters().use_conduction_timestep)
+              model_names.emplace_back("conduction time step");
+          }
+        else
+          {
+            AssertThrow(this->get_parameters().use_conduction_timestep == false,
+                        ExcMessage("When you are using Time stepping:: List of model names, do can not "
+                                   "set \"Use conduction timestep\" to true. Use the \"conduction time step\" "
+                                   "instead"));
+          }
+
+        prm.leave_subsection();
+
+        for (const auto &model_name : model_names)
+          {
+            this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
+                                            (std::get<dim>(registered_plugins)
+                                             .create_plugin (model_name,
+                                                             "Time stepping::Model names")));
+
+            if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
+              sim->initialize_simulator (this->get_simulator());
+
+            this->plugin_objects.back()->parse_parameters (prm);
+            this->plugin_objects.back()->initialize ();
+          }
+      }
+    }
+
+
+
+    template <int dim>
+    void
+    Manager<dim>::write_plugin_graph (std::ostream &out)
+    {
+      std::get<dim>(registered_plugins).write_plugin_graph ("Time stepping interface",
+                                                            out);
+    }
+
+
+    template <int dim>
+    std::string
+    get_valid_model_names_pattern ()
+    {
+      return std::get<dim>(registered_plugins).get_pattern_of_names ();
+    }
+
+  }
+}
+
+
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+
+  namespace internal
+  {
+    namespace Plugins
+    {
+      template <>
+      std::list<internal::Plugins::PluginList<TimeStepping::Interface<2>>::PluginInfo> *
+      internal::Plugins::PluginList<TimeStepping::Interface<2>>::plugins = nullptr;
+      template <>
+      std::list<internal::Plugins::PluginList<TimeStepping::Interface<3>>::PluginInfo> *
+      internal::Plugins::PluginList<TimeStepping::Interface<3>>::plugins = nullptr;
+    }
+  }
+
+  namespace TimeStepping
+  {
+#define INSTANTIATE(dim) \
+  \
+  template class Interface<dim>; \
+  template class Manager<dim>; \
+  template \
+  std::string \
+  get_valid_model_names_pattern<dim> ();
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+  }
+}
diff --git a/source/time_stepping/repeat_on_cutback.cc.bak b/source/time_stepping/repeat_on_cutback.cc.bak
new file mode 100644
index 00000000000..2191a36daa4
--- /dev/null
+++ b/source/time_stepping/repeat_on_cutback.cc.bak
@@ -0,0 +1,115 @@
+/*
+  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/time_stepping/repeat_on_cutback.h>
+
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    template <int dim>
+    double
+    RepeatOnCutback<dim>::execute()
+    {
+      return std::numeric_limits<double>::max();
+    }
+
+
+
+    template <int dim>
+    std::pair<Reaction, double>
+    RepeatOnCutback<dim>::determine_reaction (const TimeStepInfo &info)
+    {
+      if (info.next_time_step_size < this->get_timestep()*this->repeat_threshold
+          && !info.reduced_by_termination_plugin)
+        return
+          std::make_pair<Reaction, double>(Reaction::repeat_step,
+                                           this->get_timestep()*this->cut_back_amount);
+      else
+        return
+          std::make_pair<Reaction, double>(Reaction::advance,
+                                           std::numeric_limits<double>::max());
+    }
+
+
+
+    template <int dim>
+    void
+    RepeatOnCutback<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Time stepping");
+      {
+        prm.enter_subsection("Repeat on cutback");
+
+        prm.declare_entry("Relative repeat threshold", "0.2",
+                          Patterns::Double (0.),
+                          "A factor that controls when a step is going to be repeated. If "
+                          "the newly computed step size is smaller than the last step size "
+                          "multiplied by this factor, the step is repeated.");
+
+        prm.declare_entry("Cut back amount", "0.5",
+                          Patterns::Double (0.),
+                          "A factor that controls the size of the time step when repeating. The "
+                          "default of 0.5 corresponds to 50\\% of the original step taken.");
+
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    RepeatOnCutback<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Time stepping");
+      {
+        prm.enter_subsection("Repeat on cutback");
+
+        repeat_threshold = prm.get_double("Relative repeat threshold");
+        cut_back_amount = prm.get_double("Cut back amount");
+
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace TimeStepping
+  {
+    ASPECT_REGISTER_TIME_STEPPING_MODEL(RepeatOnCutback,
+                                        "repeat on cutback",
+                                        "This time stepping plugin will detect a situation where the computed time step "
+                                        "shrinks by more than a user-controlled factor. In that situation, the previous "
+                                        "time step will be repeated with a smaller step size.\n"
+                                        "A large reduction in time step size typically happens when velocities change "
+                                        "abruptly. Repeating the time step ensure properly resolving this event. It is "
+                                        "useful to consider setting the \"Maximum relative increase in time step\" option "
+                                        "to avoid repeatedly repeating every other time step.")
+  }
+}
diff --git a/source/utilities.cc.bak b/source/utilities.cc.bak
new file mode 100644
index 00000000000..b4f6876cd61
--- /dev/null
+++ b/source/utilities.cc.bak
@@ -0,0 +1,3601 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_access.h>
+#include <aspect/geometry_model/interface.h>
+
+#ifdef ASPECT_WITH_LIBDAP
+#include <D4Connect.h>
+#include <Connect.h>
+#include <Response.h>
+#include <Array.h>
+#endif
+
+#include <array>
+#include <deal.II/base/point.h>
+
+#include <deal.II/base/mpi.h>
+#include <deal.II/base/table.h>
+#include <deal.II/base/table_indices.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/base/exceptions.h>
+#include <deal.II/base/signaling_nan.h>
+#include <deal.II/base/patterns.h>
+#include <deal.II/grid/grid_tools.h>
+
+#include <cerrno>
+#include <dirent.h>
+#include <fstream>
+#include <string>
+#include <sys/stat.h>
+#include <iostream>
+#include <regex>
+
+#include <boost/math/special_functions/spherical_harmonic.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/iostreams/filtering_stream.hpp>
+#include <boost/iostreams/filter/gzip.hpp>
+#include <boost/iostreams/copy.hpp>
+
+namespace aspect
+{
+  /**
+   * A namespace for utility functions that might be used in many different
+   * places to prevent code duplication.
+   */
+  namespace Utilities
+  {
+    namespace internal
+    {
+      namespace MPI
+      {
+        // --------------------------------------------------------------------
+        // The following is copied from deal.II's mpi.templates.h file.
+        // We should instead import it from deal.II's header files directly
+        // if that information is made available via one of the existing .h
+        // files.
+        // --------------------------------------------------------------------
+#ifdef DEAL_II_WITH_MPI
+        /**
+         * Return the corresponding MPI data type id for the argument given.
+         */
+        inline MPI_Datatype
+        mpi_type_id(const bool *)
+        {
+          return MPI_CXX_BOOL;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const char *)
+        {
+          return MPI_CHAR;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const signed char *)
+        {
+          return MPI_SIGNED_CHAR;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const short *)
+        {
+          return MPI_SHORT;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const int *)
+        {
+          return MPI_INT;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const long int *)
+        {
+          return MPI_LONG;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const unsigned char *)
+        {
+          return MPI_UNSIGNED_CHAR;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const unsigned short *)
+        {
+          return MPI_UNSIGNED_SHORT;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const unsigned int *)
+        {
+          return MPI_UNSIGNED;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const unsigned long int *)
+        {
+          return MPI_UNSIGNED_LONG;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const unsigned long long int *)
+        {
+          return MPI_UNSIGNED_LONG_LONG;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const float *)
+        {
+          return MPI_FLOAT;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const double *)
+        {
+          return MPI_DOUBLE;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const long double *)
+        {
+          return MPI_LONG_DOUBLE;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const std::complex<float> *)
+        {
+          return MPI_COMPLEX;
+        }
+
+
+
+        inline MPI_Datatype
+        mpi_type_id(const std::complex<double> *)
+        {
+          return MPI_DOUBLE_COMPLEX;
+        }
+#endif
+      }
+    }
+
+
+
+
+
+
+    template <typename T>
+    Table<2,T>
+    parse_input_table (const std::string &input_string,
+                       const unsigned int n_rows,
+                       const unsigned int n_columns,
+                       const std::string &property_name)
+    {
+      Table<2,T> input_table(n_rows,n_columns);
+
+      const std::vector<std::string> rows = Utilities::possibly_extend_from_1_to_N(Utilities::split_string_list(input_string,';'),
+                                                                                   n_rows,
+                                                                                   property_name);
+
+      for (unsigned int i=0; i<rows.size(); ++i)
+        {
+          std::vector<std::string> current_columns = Utilities::possibly_extend_from_1_to_N(Utilities::split_string_list(rows[i]),
+                                                     n_columns,
+                                                     property_name);
+
+          for (unsigned int j=0; j<current_columns.size(); ++j)
+            {
+              // get rid of surrounding whitespace
+              trim(current_columns[j]);
+
+              input_table[i][j] = boost::lexical_cast<T>(current_columns[j]);
+            }
+        }
+
+      return input_table;
+    }
+
+
+
+    namespace MapParsing
+    {
+      namespace
+      {
+        // This is a helper function used in parse_map_to_double_array below.
+        // It takes an input_string that is expected to follow the input format
+        // explained in the documentation of the parse_map_to_double_array function
+        // and parses it into a multimap, only performing rudimentary error checking
+        // for correct formatting.
+        std::multimap<std::string, double>
+        parse_string_to_map (const std::string &input_string,
+                             const Options &options)
+        {
+          std::multimap<std::string, double> parsed_map;
+
+          // Parse the input string, if it follows the structure of
+          // 'key1:value1, key2:value2', or 'key1:value1|value2, ...'.
+          if (Patterns::Map(Patterns::Anything(),
+                            Patterns::List(Patterns::Double(),
+                                           0,
+                                           std::numeric_limits<unsigned int>::max(),
+                                           "|")).match(input_string))
+            {
+              // Split the list by comma delimited components.
+              const std::vector<std::string> field_entries = dealii::Utilities::split_string_list(input_string, ',');
+              for (const auto &field_entry : field_entries)
+                {
+                  // Split each entry into string and value ( <id> : <value>)
+                  std::vector<std::string> key_and_value = Utilities::split_string_list (field_entry, ':');
+
+                  // Ensure that each entry has the correct form.
+                  AssertThrow (key_and_value.size() == 2,
+                               ExcMessage ("The format for mapped "
+                                           + options.property_name
+                                           + "requires that each entry has the "
+                                           "form `<key> : <value>' "
+                                           ", but the entry <"
+                                           + field_entry
+                                           + "> does not appear to follow this pattern."));
+
+                  // Handle special key "all", which must be the only entry if found
+                  if (key_and_value[0] == "all")
+                    {
+                      AssertThrow (field_entries.size() == 1,
+                                   ExcMessage ("The keyword `all' in the property "
+                                               + options.property_name
+                                               + " is only allowed if there is no other "
+                                               "keyword."));
+
+                      const std::vector<std::string> values = dealii::Utilities::split_string_list(key_and_value[1], '|');
+
+                      // Assign all the values to all fields
+                      for (const std::string &key: options.list_of_required_keys)
+                        for (const std::string &value : values)
+                          {
+                            parsed_map.emplace(key, Utilities::string_to_double(value));
+                          }
+                    }
+                  // Handle lists of multiple unique entries
+                  else
+                    {
+                      AssertThrow (parsed_map.find(key_and_value[0]) == parsed_map.end(),
+                                   ExcMessage ("The keyword <"
+                                               + key_and_value[0]
+                                               + "> in "
+                                               + options.property_name
+                                               + " is listed multiple times. "
+                                               "Check that you have only one value for "
+                                               "each field id in your list."));
+
+                      const std::vector<std::string> values = dealii::Utilities::split_string_list(key_and_value[1], '|');
+
+                      for (const auto &value : values)
+                        parsed_map.emplace(key_and_value[0],Utilities::string_to_double(value));
+                    }
+                }
+            }
+          // Parse the input string, if it follows the structure of
+          // 'value1, value2, value3' with as many entries as allowed keys.
+          else if (Patterns::List(Patterns::Double(),options.list_of_allowed_keys.size(),options.list_of_allowed_keys.size()).match(input_string))
+            {
+              const std::vector<double> values = possibly_extend_from_1_to_N(dealii::Utilities::string_to_double(dealii::Utilities::split_string_list(input_string)),
+                                                                             options.list_of_allowed_keys.size(),
+                                                                             options.property_name);
+
+              for (unsigned int i=0; i<values.size(); ++i)
+                {
+                  // list_of_keys and values have the same length, which is guaranteed by the
+                  // call to possibly_extend_from_1_to_N() above
+                  parsed_map.emplace(options.list_of_allowed_keys[i],values[i]);
+                }
+            }
+          // Parse the input string, if it follows the structure of
+          // 'value1, value2, value3' with one entry or as many entries as required keys.
+          else if (Patterns::List(Patterns::Double(),1,options.list_of_required_keys.size()).match(input_string))
+            {
+              const std::vector<double> values = possibly_extend_from_1_to_N (dealii::Utilities::string_to_double(dealii::Utilities::split_string_list(input_string)),
+                                                                              options.list_of_required_keys.size(),
+                                                                              options.property_name);
+
+              for (unsigned int i=0; i<values.size(); ++i)
+                {
+                  // list_of_keys and values have the same length, which is guaranteed by the
+                  // call to possibly_extend_from_1_to_N() above
+                  parsed_map.emplace(options.list_of_required_keys[i],values[i]);
+                }
+            }
+          else
+            {
+              // No Patterns matches were found!
+              AssertThrow (false,
+                           ExcMessage ("The string for property <"
+                                       + options.property_name
+                                       + "> does not have the expected format. "
+                                       + "Check that the string is either a "
+                                       + "comma separated list of `<double>' or "
+                                       + "`<key1> : <double>|<double>|..., "
+                                       + "<key2> : <double>|... , ... '. "
+                                       + "If the string looks correct, "
+                                       + "it is likely that the length of the "
+                                       + "list of keys passed to "
+                                       + "parse_map_to_double_array does not "
+                                       + "match the length of the "
+                                       + "comma separated property list."));
+            }
+
+          // Now remove all allowed but not requested keys from the map
+          // If no keys are specifically requested, do not delete any.
+          if (options.list_of_allowed_keys.size() > options.list_of_required_keys.size())
+            {
+              for (const auto &allowed_key: options.list_of_allowed_keys)
+                if (std::find(options.list_of_required_keys.begin(),
+                              options.list_of_required_keys.end(),
+                              allowed_key) == options.list_of_required_keys.end())
+                  parsed_map.erase(allowed_key);
+            }
+
+          return parsed_map;
+        }
+
+        // This is a helper function used in parse_map_to_double_array below.
+        // It takes an input multimap for example generated by parse_string_to_map
+        // above and flattens it into a
+        // vector of plain doubles (in the order of the given keys).
+        std::vector<double>
+        flatten_map_to_vector (const std::multimap<std::string, double> &map,
+                               const std::vector<std::string> &keys)
+        {
+          std::vector<double> values;
+          values.reserve(map.size());
+
+          for (const std::string &field_name: keys)
+            {
+              const std::pair<std::multimap<std::string, double>::const_iterator,
+                    std::multimap<std::string, double>::const_iterator> entry_range = map.equal_range(field_name);
+
+              for (auto entry = entry_range.first; entry != entry_range.second; ++entry)
+                values.push_back(entry->second);
+            }
+          return values;
+        }
+
+        void
+        read_or_check_map_structure (std::multimap<std::string, double> &map,
+                                     Options &options)
+        {
+          const unsigned int n_fields = options.list_of_required_keys.size();
+
+          std::vector<unsigned int> values_per_key(n_fields, 0);
+
+          if (options.check_values_per_key)
+            AssertThrow(options.n_values_per_key.size() == n_fields,
+                        ExcMessage("When providing an expected structure for input parameter " + options.property_name + " you need to provide "
+                                   + "as many entries in the structure vector as there are input field names (+1 if there is a background field). "
+                                   + "The current structure vector has " + std::to_string(options.n_values_per_key.size()) + " entries, but there are "
+                                   + std::to_string(n_fields) + " field names." ));
+
+          for (const std::pair<const std::string, double> &key_and_value: map)
+            {
+              const std::vector<std::string>::const_iterator field_name =
+                std::find(options.list_of_required_keys.begin(),
+                          options.list_of_required_keys.end(),
+                          key_and_value.first);
+
+              // Ensure that each key is in the list of field names
+              AssertThrow (field_name != options.list_of_required_keys.end(),
+                           ExcMessage ("The keyword <" + key_and_value.first + "> in "
+                                       + options.property_name + " does not match any entries "
+                                       "from the list of requested field names."
+                                       "Check that you only use valid names.\n\n"
+                                       "One example of where to check this is if "
+                                       "Compositional fields are used, "
+                                       "then check the id list "
+                                       "from `set Names of fields' in the "
+                                       "Compositional fields subsection. "
+                                       "Alternatively, if `set Names of fields' "
+                                       "is not set, the default names are "
+                                       "C_1, C_2, ..., C_n."));
+
+              const unsigned int field_index = std::distance(options.list_of_required_keys.cbegin(), field_name);
+              values_per_key[field_index] += 1;
+            }
+
+          if (options.store_values_per_key)
+            options.n_values_per_key = values_per_key;
+
+          unsigned int field_index = 0;
+          for (const unsigned int &n_values: values_per_key)
+            {
+              if (options.allow_multiple_values_per_key == false)
+                AssertThrow (n_values <= 1,
+                             ExcMessage ("The keyword <"
+                                         + options.list_of_required_keys[field_index]
+                                         + "> in "
+                                         + options.property_name
+                                         + " has multiple values, which is unexpected. "
+                                         "Check that you have only one value for "
+                                         "each field id in your list."));
+
+              if (options.allow_missing_keys == false)
+                AssertThrow (n_values > 0,
+                             ExcMessage ("The keyword <"
+                                         + options.list_of_required_keys[field_index]
+                                         + "> in "
+                                         + options.property_name
+                                         + " is not listed, although it is expected. "
+                                         "Check that you have at least one value for "
+                                         "each field id in your list (possibly plus "
+                                         "`background` if a background field is expected "
+                                         "for this property)."));
+
+              if (options.check_values_per_key)
+                {
+                  const unsigned int n_expected_values = options.n_values_per_key[field_index];
+                  const std::string field_name = options.list_of_required_keys[field_index];
+
+                  AssertThrow((n_expected_values == n_values || n_values == 1),
+                              ExcMessage("The key <" + field_name + "> in <"+ options.property_name + "> does not have "
+                                         + "the expected number of values. It expects " + std::to_string(n_expected_values)
+                                         + " or 1 values, but we found " + std::to_string(n_values) + " values."));
+
+                  // If we expect multiple values for a key, but found exactly one: assume
+                  // the one value stands for every expected value. This allows
+                  // for short and simpler input if all values for a key are the same.
+                  if (n_values == 1)
+                    {
+                      const double field_value = map.find(field_name)->second;
+                      for (unsigned int i=1; i<n_expected_values; ++i)
+                        map.emplace(field_name, field_value);
+                    }
+                }
+
+              ++field_index;
+            }
+        }
+      }
+
+      std::vector<double>
+      parse_map_to_double_array(const std::string &input_string,
+                                Options &options)
+      {
+        // Check options for consistency
+        AssertThrow (options.property_name != "",
+                     ExcMessage("parse_map_to_double_array needs a property name to be able to properly report parsing errors."));
+        AssertThrow (options.list_of_required_keys.size() != 0,
+                     ExcMessage("parse_map_to_double_array needs at least one required key name for property "
+                                + options.property_name
+                                + "."));
+        AssertThrow (options.check_values_per_key == false ||
+                     options.store_values_per_key == false,
+                     ExcMessage("parse_map_to_double_array can not simultaneously store the structure "
+                                "of the parsed map for "
+                                + options.property_name
+                                + " and check that structure against a given structure."));
+        AssertThrow (options.check_values_per_key == false ||
+                     options.n_values_per_key.size() == options.list_of_required_keys.size(),
+                     ExcMessage("parse_map_to_double_array can only check the structure "
+                                "of the parsed map for "
+                                + options.property_name
+                                + " if an expected number of values for each key is given."));
+
+        // First: parse the string into a map depending on what Pattern we are dealing with
+        std::multimap<std::string, double> parsed_map = parse_string_to_map(input_string,
+                                                                            options);
+
+        // Second: Now check that the structure of the map is as expected
+        read_or_check_map_structure(parsed_map,
+                                    options);
+
+        // Finally: Convert the map into a vector of doubles, sorted in the order
+        // of the list_of_required_keys option
+        return flatten_map_to_vector(parsed_map, options.list_of_required_keys);
+      }
+    }
+
+
+
+    std::vector<double>
+    parse_map_to_double_array (const std::string &input_string,
+                               const std::vector<std::string> &list_of_keys,
+                               const bool expects_background_field,
+                               const std::string &property_name,
+                               const bool allow_multiple_values_per_key,
+                               const std::unique_ptr<std::vector<unsigned int>> &n_values_per_key,
+                               const bool allow_missing_keys)
+    {
+      std::vector<std::string> input_field_names = list_of_keys;
+
+      if (expects_background_field)
+        input_field_names.insert(input_field_names.begin(),"background");
+
+      MapParsing::Options options(input_field_names, property_name);
+      options.allow_multiple_values_per_key = allow_multiple_values_per_key;
+      options.allow_missing_keys = allow_missing_keys;
+
+      if (n_values_per_key)
+        {
+          options.n_values_per_key = *n_values_per_key;
+          options.check_values_per_key = (n_values_per_key->size() != 0);
+          options.store_values_per_key = (n_values_per_key->size() == 0);
+        }
+
+      const auto parsed_map = MapParsing::parse_map_to_double_array(input_string, options);
+
+      if (n_values_per_key)
+        *n_values_per_key = options.n_values_per_key;
+
+      return parsed_map;
+    }
+
+
+
+    template <int dim>
+    std::vector<std::string>
+    expand_dimensional_variable_names (const std::vector<std::string> &var_declarations)
+    {
+      std::string dim_names[3] = {"x", "y", "z"};
+      char fn_split = '(', fn_end = ')';
+      std::vector<std::string> var_name_list;
+
+      for (const auto &var_decl : var_declarations)
+        {
+          if (var_decl.find(fn_split) != std::string::npos && var_decl[var_decl.length()-1]==fn_end)
+            {
+              const std::string fn_name = var_decl.substr(0, var_decl.find(fn_split));
+
+              // Cannot be const because will be manipulated to strip whitespace
+              std::string var_name = var_decl.substr(var_decl.find(fn_split)+1, var_decl.length()-2-var_decl.find(fn_split));
+              while ((var_name.length() != 0) && (var_name[0] == ' '))
+                var_name.erase(0, 1);
+              while ((var_name.length() != 0) && (var_name[var_name.length()-1] == ' '))
+                var_name.erase(var_name.length()-1, 1);
+              if (fn_name == "vector")
+                {
+                  for (int i=0; i<dim; ++i)
+                    var_name_list.push_back(var_name+"_"+dim_names[i]);
+                }
+              else if (fn_name == "tensor")
+                {
+                  for (int i=0; i<dim; ++i)
+                    for (int j=0; j< dim; ++j)
+                      var_name_list.push_back(var_name+"_"+dim_names[i]+dim_names[j]);
+                }
+              else
+                {
+                  var_name_list.push_back(var_decl);
+                }
+            }
+          else
+            {
+              var_name_list.push_back(var_decl);
+            }
+        }
+      return var_name_list;
+    }
+
+
+
+    /**
+    * This is an internal deal.II function stolen from dof_tools.cc
+    *
+    * Return an array that for each dof on the reference cell lists the
+    * corresponding vector component.
+    */
+    template <int dim, int spacedim>
+    std::vector<unsigned char>
+    get_local_component_association (const FiniteElement<dim,spacedim>  &fe,
+                                     const ComponentMask        & /*component_mask*/)
+    {
+      const unsigned char invalid = static_cast<unsigned char>(-1);
+      std::vector<unsigned char> local_component_association (fe.dofs_per_cell, invalid);
+
+      // compute the component each local dof belongs to.
+      // if the shape function is primitive, then this
+      // is simple and we can just associate it with
+      // what system_to_component_index gives us
+      for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
+        {
+          // see the deal.II version if we ever need non-primitive FEs.
+          Assert (fe.is_primitive(i), ExcNotImplemented());
+          local_component_association[i] =
+            fe.system_to_component_index(i).first;
+        }
+
+      Assert (std::find (local_component_association.begin(),
+                         local_component_association.end(),
+                         invalid)
+              ==
+              local_component_association.end(),
+              ExcInternalError());
+
+      return local_component_association;
+    }
+
+
+
+    template <int dim>
+    IndexSet extract_locally_active_dofs_with_component(const DoFHandler<dim> &dof_handler,
+                                                        const ComponentMask &component_mask)
+    {
+      std::vector<unsigned char> local_asoc =
+        get_local_component_association (dof_handler.get_fe(),
+                                         ComponentMask(dof_handler.get_fe().n_components(), true));
+
+      IndexSet ret(dof_handler.n_dofs());
+
+      unsigned int dofs_per_cell = dof_handler.get_fe().dofs_per_cell;
+      std::vector<types::global_dof_index> indices(dofs_per_cell);
+      for (const auto &cell : dof_handler.active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            cell->get_dof_indices(indices);
+            for (unsigned int i=0; i<dofs_per_cell; ++i)
+              if (component_mask[local_asoc[i]])
+                ret.add_index(indices[i]);
+          }
+
+      return ret;
+    }
+
+
+
+    template <int dim>
+    std::vector<Point<dim>> get_unit_support_points(const SimulatorAccess<dim> &simulator_access)
+    {
+      if ( !simulator_access.get_parameters().use_locally_conservative_discretization )
+        {
+          return simulator_access.get_fe().get_unit_support_points();
+        }
+      else
+        {
+          //special case for discontinuous pressure elements, which lack unit support points
+          const unsigned int dofs_per_cell = simulator_access.get_fe().dofs_per_cell;
+          std::vector<Point<dim>> unit_support_points;
+          unit_support_points.reserve(dofs_per_cell);
+
+          for (unsigned int dof=0; dof < dofs_per_cell; ++dof)
+            {
+              // base will hold element, base_index holds node/shape function within that element
+              const unsigned int base       = simulator_access.get_fe().system_to_base_index(dof).first.first;
+              const unsigned int base_index = simulator_access.get_fe().system_to_base_index(dof).second;
+              // get the unit support points for the relevant element
+              const std::vector<Point<dim>> &my_support_points = simulator_access.get_fe().base_element(base).get_unit_support_points();
+              if ( my_support_points.size() == 0 )
+                {
+                  //manufacture a support point, arbitrarily at cell center
+                  if (dim==2)
+                    unit_support_points.push_back(Point<dim> (0.5,0.5));
+                  if (dim==3)
+                    unit_support_points.push_back(Point<dim> (0.5,0.5,0.5));
+                }
+              else
+                {
+                  unit_support_points.push_back(my_support_points[base_index]);
+                }
+            }
+          return unit_support_points;
+        }
+    }
+
+
+
+    template <int dim>
+    bool
+    point_is_in_triangulation(const Mapping<dim> &mapping,
+                              const parallel::distributed::Triangulation<dim> &triangulation,
+                              const Point<dim> &point,
+                              const MPI_Comm mpi_communicator)
+    {
+      // Try to find the cell around the given point.
+      bool cell_found = false;
+      std::pair<const typename parallel::distributed::Triangulation<dim>::active_cell_iterator,
+          Point<dim>> it =
+            GridTools::find_active_cell_around_point<>(mapping, triangulation, point);
+
+      // If we found the correct cell on this MPI process, we have found the right cell.
+      if (it.first.state() == IteratorState::valid && it.first->is_locally_owned())
+        cell_found = true;
+
+      // Compute how many processes found the cell.
+      const int n_procs_cell_found = Utilities::MPI::sum(cell_found ? 1 : 0, mpi_communicator);
+      // If at least one process found the cell, the point is in the triangulation.
+      if (n_procs_cell_found > 0)
+        return true;
+      else
+        return false;
+    }
+
+
+
+    namespace Coordinates
+    {
+
+      template <int dim>
+      std::array<double,dim>
+      WGS84_coordinates(const Point<dim> &position)
+      {
+        Assert (dim==3, ExcNotImplemented());
+
+        std::array<double,dim> ecoord;
+
+        // Define WGS84 ellipsoid constants.
+        const double radius = 6378137.;
+        const double ellipticity = 8.1819190842622e-2;
+        const double b = std::sqrt(radius * radius
+                                   * (1 - ellipticity * ellipticity));
+        const double ep = std::sqrt((radius * radius - b * b) / (b * b));
+        const double p = std::sqrt(position(0) * position(0) + position(1) * position(1));
+        const double th = std::atan2(radius * position(2), b * p);
+        ecoord[2] = std::atan2((position(2) + ep * ep * b * std::sin(th)
+                                * std::sin(th) * std::sin(th)),
+                               (p - (ellipticity * ellipticity * radius * (std::cos(th)
+                                                                           * std::cos(th) * std::cos(th)))))
+                    * constants::radians_to_degree;
+
+        ecoord[1] = std::atan2(position(1), position(0))
+                    * constants::radians_to_degree;
+
+        // Set all longitudes between [0,360]:
+        if (ecoord[1] < 0.)
+          ecoord[1] += 360.;
+        else if (ecoord[1] > 360.)
+          ecoord[1] -= 360.;
+
+
+        ecoord[0] = radius/std::sqrt(1- ellipticity * ellipticity
+                                     * std::sin(constants::degree_to_radians * ecoord[2])
+                                     * std::sin(constants::degree_to_radians * ecoord[2]));
+        return ecoord;
+      }
+
+
+
+      template <int dim>
+      std::array<double,dim>
+      cartesian_to_spherical_coordinates(const Point<dim> &position)
+      {
+        std::array<double,dim> scoord;
+
+        scoord[0] = position.norm(); // R
+
+        // Compute the longitude phi. Note that atan2 is documented to return
+        // its result as a value between -pi and +pi, whereas we use the
+        // convention that we consider eastern longitude between 0 and 2pi.
+        // As a consequence, we correct where necessary.
+        scoord[1] = std::atan2(position(1),position(0));
+        if (scoord[1] < 0.0)
+          scoord[1] += 2.0*numbers::PI; // correct phi to [0,2*pi]
+
+        // In 3d also compute the polar angle (=colatitude)
+        if (dim==3)
+          {
+            if (/* R= */scoord[0] > std::numeric_limits<double>::min())
+              scoord[2] = std::acos(position(2)/scoord[0]);
+            else
+              scoord[2] = 0.0;
+          }
+        return scoord;
+      }
+
+
+
+      template <int dim>
+      Point<dim>
+      spherical_to_cartesian_coordinates(const std::array<double,dim> &scoord)
+      {
+        Point<dim> ccoord;
+
+        switch (dim)
+          {
+            case 2:
+            {
+              ccoord[0] = scoord[0] * std::cos(scoord[1]); // X
+              ccoord[1] = scoord[0] * std::sin(scoord[1]); // Y
+              break;
+            }
+            case 3:
+            {
+              ccoord[0] = scoord[0] * std::sin(scoord[2]) * std::cos(scoord[1]); // X
+              ccoord[1] = scoord[0] * std::sin(scoord[2]) * std::sin(scoord[1]); // Y
+              ccoord[2] = scoord[0] * std::cos(scoord[2]); // Z
+              break;
+            }
+            default:
+              Assert (false, ExcNotImplemented());
+              break;
+          }
+
+        return ccoord;
+      }
+
+
+
+      template <int dim>
+      std::array<double,3>
+      cartesian_to_ellipsoidal_coordinates(const Point<3> &x,
+                                           const double semi_major_axis_a,
+                                           const double eccentricity)
+      {
+        const double R    = semi_major_axis_a;
+        const double b      = std::sqrt(R * R * (1 - eccentricity * eccentricity));
+        const double ep     = std::sqrt((R * R - b * b) / (b * b));
+        const double p      = std::sqrt(x(0) * x(0) + x(1) * x(1));
+        const double th     = std::atan2(R * x(2), b * p);
+        const double phi    = std::atan2(x(1), x(0));
+        const double theta  = std::atan2(x(2) + ep * ep * b * std::pow(std::sin(th),3),
+                                         (p - (eccentricity * eccentricity * R  * std::pow(std::cos(th),3))));
+        const double R_bar = R / (std::sqrt(1 - eccentricity * eccentricity * std::sin(theta) * std::sin(theta)));
+        const double R_plus_d = p / std::cos(theta);
+
+        std::array<double,3> phi_theta_d;
+        phi_theta_d[0] = phi;
+
+        phi_theta_d[1] = theta;
+        phi_theta_d[2] = R_plus_d - R_bar;
+        return phi_theta_d;
+      }
+
+
+
+      template <int dim>
+      Point<3>
+      ellipsoidal_to_cartesian_coordinates(const std::array<double,3> &phi_theta_d,
+                                           const double semi_major_axis_a,
+                                           const double eccentricity)
+      {
+        const double phi   = phi_theta_d[0];
+        const double theta = phi_theta_d[1];
+        const double d     = phi_theta_d[2];
+
+        const double R_bar = semi_major_axis_a / std::sqrt(1 - (eccentricity * eccentricity *
+                                                                std::sin(theta) * std::sin(theta)));
+
+        return Point<3> ((R_bar + d) * std::cos(phi) * std::cos(theta),
+                         (R_bar + d) * std::sin(phi) * std::cos(theta),
+                         ((1 - eccentricity * eccentricity) * R_bar + d) * std::sin(theta));
+
+      }
+
+
+
+      template <int dim>
+      Tensor<1, dim>
+      spherical_to_cartesian_vector(const Tensor<1, dim> &spherical_vector,
+                                    const Point<dim> &position)
+      {
+        Tensor<1, dim> cartesian_vector;
+
+        const std::array<double, dim> r_phi_theta = cartesian_to_spherical_coordinates(position);
+
+        switch (dim)
+          {
+            case 2:
+            {
+              const double phi = r_phi_theta[1];
+
+              const double u_r   = spherical_vector[0];
+              const double u_phi = spherical_vector[1];
+
+              cartesian_vector[0] = std::cos(phi)*u_r
+                                    - std::sin(phi)*u_phi; // X
+              cartesian_vector[1] = std::sin(phi)*u_r
+                                    + std::cos(phi)*u_phi; // Y
+
+              break;
+            }
+            case 3:
+            {
+              const double phi   = r_phi_theta[1];
+              const double theta = r_phi_theta[2];
+
+              const double u_r     = spherical_vector[0];
+              const double u_phi   = spherical_vector[1];
+              const double u_theta = spherical_vector[2];
+
+              cartesian_vector[0] = std::cos(phi)*std::sin(theta)*u_r
+                                    - std::sin(phi)*u_phi
+                                    + std::cos(phi)*std::cos(theta)*u_theta; // X
+              cartesian_vector[1] = std::sin(phi)*std::sin(theta)*u_r
+                                    + std::cos(phi)*u_phi
+                                    + std::sin(phi)*std::cos(theta)*u_theta; // Y
+              cartesian_vector[2] = std::cos(theta)*u_r
+                                    - std::sin(theta)*u_theta; // Z
+              break;
+            }
+
+            default:
+              Assert (false, ExcNotImplemented());
+              break;
+          }
+
+        return cartesian_vector;
+      }
+
+
+
+      CoordinateSystem
+      string_to_coordinate_system(const std::string &coordinate_system)
+      {
+        if (coordinate_system == "cartesian")
+          return cartesian;
+        else if (coordinate_system == "spherical")
+          return spherical;
+        else if (coordinate_system == "depth")
+          return Coordinates::depth;
+        else
+          AssertThrow(false, ExcNotImplemented());
+
+        return Coordinates::invalid;
+      }
+    }
+
+
+
+    template <int dim>
+    bool
+    polygon_contains_point(const std::vector<Point<2>> &point_list,
+                           const dealii::Point<2> &point)
+    {
+      /**
+       * This code has been based on http://geomalgorithms.com/a03-_inclusion.html,
+       * and therefore requires the following copyright notice:
+       *
+       * Copyright 2000 softSurfer, 2012 Dan Sunday
+       * This code may be freely used and modified for any purpose
+       * providing that this copyright notice is included with it.
+       * SoftSurfer makes no warranty for this code, and cannot be held
+       * liable for any real or imagined damage resulting from its use.
+       * Users of this code must verify correctness for their application.
+       *
+       * The main functional difference between the original code and this
+       * code is that all the boundaries are considered to be inside the
+       * polygon. One should of course realize that with floating point
+       * arithmetic no guarantees can be made for the borders, but for
+       * exact arithmetic this algorithm would work (also see polygon
+       * in point test).
+       */
+      int pointNo = point_list.size();
+      int    wn = 0;    // the  winding number counter
+      int   j=pointNo-1;
+
+      // loop through all edges of the polygon
+      for (int i=0; i<pointNo; ++i)
+        {
+          // edge from V[i] to  V[i+1]
+          if (point_list[j][1] <= point[1])
+            {
+              // start y <= P.y
+              if (point_list[i][1] >= point[1])      // an upward crossing
+                {
+                  const double is_left = (point_list[i][0] - point_list[j][0]) * (point[1] - point_list[j][1])
+                                         - (point[0] -  point_list[j][0]) * (point_list[i][1] - point_list[j][1]);
+
+                  if ( is_left > 0 && point_list[i][1] > point[1])
+                    {
+                      // P left of  edge
+                      ++wn;            // have  a valid up intersect
+                    }
+                  else if ( is_left == 0)
+                    {
+                      // The point is exactly on the infinite line.
+                      // determine if it is on the segment
+                      const double dot_product = (point - point_list[j])*(point_list[i] - point_list[j]);
+
+                      if (dot_product >= 0)
+                        {
+                          const double squaredlength = (point_list[i] - point_list[j]).norm_square();
+
+                          if (dot_product <= squaredlength)
+                            {
+                              return true;
+                            }
+                        }
+                    }
+                }
+            }
+          else
+            {
+              // start y > P.y (no test needed)
+              if (point_list[i][1]  <= point[1])     // a downward crossing
+                {
+                  const double is_left = (point_list[i][0] - point_list[j][0]) * (point[1] - point_list[j][1])
+                                         - (point[0] -  point_list[j][0]) * (point_list[i][1] - point_list[j][1]);
+
+                  if ( is_left < 0)
+                    {
+                      // P right of  edge
+                      --wn;            // have  a valid down intersect
+                    }
+                  else if ( is_left == 0)
+                    {
+                      // This code is to make sure that the boundaries are included in the polygon.
+                      // The point is exactly on the infinite line.
+                      // determine if it is on the segment
+                      const double dot_product = (point - point_list[j])*(point_list[i] - point_list[j]);
+
+                      if (dot_product >= 0)
+                        {
+                          const double squaredlength = (point_list[i] - point_list[j]).norm_square();
+
+                          if (dot_product <= squaredlength)
+                            {
+                              return true;
+                            }
+                        }
+                    }
+                }
+            }
+          j=i;
+        }
+
+      return (wn != 0);
+    }
+
+
+
+    template <int dim>
+    double
+    signed_distance_to_polygon(const std::vector<Point<2>> &point_list,
+                               const dealii::Point<2> &point)
+    {
+      // If the point lies outside polygon, we give it a negative sign,
+      // inside a positive sign.
+      const double sign = polygon_contains_point<dim>(point_list, point) ? 1.0 : -1.0;
+
+      /**
+       * This code is based on http://geomalgorithms.com/a02-_lines.html#Distance-to-Infinite-Line,
+       * and therefore requires the following copyright notice:
+       *
+       * Copyright 2000 softSurfer, 2012 Dan Sunday
+       * This code may be freely used and modified for any purpose
+       * providing that this copyright notice is included with it.
+       * SoftSurfer makes no warranty for this code, and cannot be held
+       * liable for any real or imagined damage resulting from its use.
+       * Users of this code must verify correctness for their application.
+       *
+       */
+
+      const unsigned int n_poly_points = point_list.size();
+      AssertThrow(n_poly_points >= 3, ExcMessage("Not enough polygon points were specified."));
+
+      // Initialize a vector of distances for each point of the polygon with a very large distance
+      std::vector<double> distances(n_poly_points, 1e23);
+
+      // Create another polygon but with all points shifted 1 position to the right
+      std::vector<Point<2>> shifted_point_list(n_poly_points);
+      shifted_point_list[0] = point_list[n_poly_points-1];
+
+      for (unsigned int i = 0; i < n_poly_points-1; ++i)
+        shifted_point_list[i+1] = point_list[i];
+
+      for (unsigned int i = 0; i < n_poly_points; ++i)
+        {
+          const std::array<Point<2>,2> list = {{point_list[i], shifted_point_list[i]}};
+          distances[i] = distance_to_line(list, point);
+        }
+
+      // Return the minimum of the distances of the point to all polygon segments
+      return *std::min_element(distances.begin(),distances.end()) * sign;
+    }
+
+
+
+    double
+    distance_to_line(const std::array<dealii::Point<2>,2> &point_list,
+                     const dealii::Point<2> &point)
+    {
+
+      /**
+       * This code is based on http://geomalgorithms.com/a02-_lines.html#Distance-to-Infinite-Line,
+       * and therefore requires the following copyright notice:
+       *
+       * Copyright 2000 softSurfer, 2012 Dan Sunday
+       * This code may be freely used and modified for any purpose
+       * providing that this copyright notice is included with it.
+       * SoftSurfer makes no warranty for this code, and cannot be held
+       * liable for any real or imagined damage resulting from its use.
+       * Users of this code must verify correctness for their application.
+       *
+       */
+
+      const unsigned int n_poly_points = point_list.size();
+      AssertThrow(n_poly_points == 2, ExcMessage("A list of points for a line segment should consist of 2 points."));
+
+      // Create vector along the polygon line segment P0 to P1
+      const Tensor<1,2> vector_segment = point_list[1] - point_list[0];
+      // Create vector from point P to the second segment point
+      const Tensor<1,2> vector_point_segment = point - point_list[0];
+
+      // Compute dot products to get angles
+      const double c1 = vector_point_segment * vector_segment;
+
+      // Point P's perpendicular base line lies outside segment, before P0.
+      // Return distance between points P and P0.
+      if (c1 <= 0.0)
+        return (Tensor<1,2> (point_list[0] - point)).norm();
+
+      const double c2 = vector_segment * vector_segment;
+
+      // Point P's perpendicular base line lies outside segment, after P1.
+      // Return distance between points P and P1.
+      if (c2 <= c1)
+        return (Tensor<1,2> (point_list[1] - point)).norm();
+
+      // Point P's perpendicular base line lies on the line segment.
+      // Return distance between point P and the base point.
+      const Point<2> point_on_segment = point_list[0] + (c1/c2) * vector_segment;
+      return (Tensor<1,2> (point - point_on_segment)).norm();
+    }
+
+
+
+    template <int dim>
+    std::array<Tensor<1,dim>,dim-1>
+    orthogonal_vectors (const Tensor<1,dim> &v)
+    {
+      Assert (v.norm() > 0,
+              ExcMessage ("This function can not be called with a zero "
+                          "input vector."));
+
+      std::array<Tensor<1,dim>,dim-1> return_value;
+      switch (dim)
+        {
+          case 2:
+          {
+            // create a direction by swapping the two coordinates and
+            // flipping one sign; this is orthogonal to 'v' and has
+            // the same length already
+            return_value[0][0] = v[1];
+            return_value[0][1] = -v[0];
+            break;
+          }
+
+          case 3:
+          {
+            // In 3d, we can get two other vectors in a 3-step procedure:
+            // - compute a 'w' that is definitely not collinear with 'v'
+            // - compute the first direction as u[1] = v \times w,
+            //   normalize it
+            // - compute the second direction as u[2] = v \times u[1],
+            //   normalize it
+            //
+            // For the first step, use a procedure suggested by Luca Heltai:
+            // Set d to the index of the largest component of v. Make a vector
+            // with this component equal to zero, and with the other two
+            // equal to the norm of the point. Call this 'w'.
+            unsigned int max_component = 0;
+            for (unsigned int d=1; d<dim; ++d)
+              if (std::fabs(v[d]) > std::fabs(v[max_component]))
+                max_component = d;
+            Tensor<1,dim> w = v;
+            w[max_component] = 0;
+            for (unsigned int d=1; d<dim; ++d)
+              if (d != max_component)
+                w[d] = v.norm();
+
+            return_value[0] = cross_product_3d(v, w);
+            return_value[0] *= v.norm() / return_value[0].norm();
+
+            return_value[1] = cross_product_3d(v, return_value[0]);
+            return_value[1] *= v.norm() / return_value[1].norm();
+
+            break;
+          }
+
+          default:
+            Assert (false, ExcNotImplemented());
+        }
+
+      return return_value;
+    }
+
+
+
+    Tensor<2,3>
+    rotation_matrix_from_axis (const Tensor<1,3> &rotation_axis,
+                               const double rotation_angle)
+    {
+      Tensor<2,3> rotation_matrix;
+      rotation_matrix[0][0] = (1-std::cos(rotation_angle)) * rotation_axis[0]*rotation_axis[0] + std::cos(rotation_angle);
+      rotation_matrix[0][1] = (1-std::cos(rotation_angle)) * rotation_axis[0]*rotation_axis[1] - rotation_axis[2] * std::sin(rotation_angle);
+      rotation_matrix[0][2] = (1-std::cos(rotation_angle)) * rotation_axis[0]*rotation_axis[2] + rotation_axis[1] * std::sin(rotation_angle);
+      rotation_matrix[1][0] = (1-std::cos(rotation_angle)) * rotation_axis[1]*rotation_axis[0] + rotation_axis[2] * std::sin(rotation_angle);
+      rotation_matrix[1][1] = (1-std::cos(rotation_angle)) * rotation_axis[1]*rotation_axis[1] + std::cos(rotation_angle);
+      rotation_matrix[1][2] = (1-std::cos(rotation_angle)) * rotation_axis[1]*rotation_axis[2] - rotation_axis[0] * std::sin(rotation_angle);
+      rotation_matrix[2][0] = (1-std::cos(rotation_angle)) * rotation_axis[2]*rotation_axis[0] - rotation_axis[1] * std::sin(rotation_angle);
+      rotation_matrix[2][1] = (1-std::cos(rotation_angle)) * rotation_axis[2]*rotation_axis[1] + rotation_axis[0] * std::sin(rotation_angle);
+      rotation_matrix[2][2] = (1-std::cos(rotation_angle)) * rotation_axis[2]*rotation_axis[2] + std::cos(rotation_angle);
+      return rotation_matrix;
+    }
+
+
+
+    Tensor<2,3>
+    compute_rotation_matrix_for_slice (const Tensor<1,3> &point_one,
+                                       const Tensor<1,3> &point_two)
+    {
+      AssertThrow(point_one.norm() > std::numeric_limits<double>::min()
+                  && point_two.norm() > std::numeric_limits<double>::min(),
+                  ExcMessage("The points that are used to define the slice that "
+                             "should be rotated onto the x-y-plane can not lie "
+                             "at the origin of the coordinate system."));
+
+      // Set up the normal vector of an unrotated 2d spherical shell
+      // that by default lies in the x-y plane.
+      const Tensor<1,3> unrotated_normal_vector ({0.0,0.0,1.0});
+
+      // Compute the normal vector of the plane that contains
+      // the origin and the two points specified as the function arguments.
+      Tensor<1,3> rotated_normal_vector = cross_product_3d(point_one, point_two);
+
+      AssertThrow(rotated_normal_vector.norm() > std::numeric_limits<double>::min(),
+                  ExcMessage("The points that are used to define the slice that "
+                             "should be rotated onto the x-y-plane can not lie "
+                             "along the line that also goes through the origin "
+                             "of the coordinate system."));
+
+      rotated_normal_vector /= rotated_normal_vector.norm();
+
+      Tensor<2,3> rotation_matrix ({{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}});
+
+      // Calculate the crossing line of the two normals,
+      // which will be the rotation axis to transform the one
+      // normal into the other
+      Tensor<1,3> rotation_axis = cross_product_3d(unrotated_normal_vector, rotated_normal_vector);
+
+      // If the normal vector of the slice already points in z-direction, we do not have to
+      // apply the first rotation.
+      if (rotation_axis.norm() > std::numeric_limits<double>::min())
+        {
+          rotation_axis /= rotation_axis.norm();
+
+          // Calculate the rotation angle from the inner product rule
+          const double rotation_angle = std::acos(rotated_normal_vector * unrotated_normal_vector);
+          rotation_matrix = rotation_matrix_from_axis(rotation_axis, rotation_angle);
+        }
+
+      // Now apply the rotation that will project point_one onto the known point
+      // (0,1,0).
+      const Tensor<1,3> normalized_point_one = point_one / point_one.norm();
+      const Tensor<1,3> rotated_point_one = transpose(rotation_matrix) * normalized_point_one;
+      const Tensor<1,3> final_point_one ({0.0,1.0,0.0});
+
+      const double second_rotation_angle = std::acos(rotated_point_one * final_point_one);
+      Tensor<1,3> second_rotation_axis = cross_product_3d(final_point_one, rotated_point_one);
+
+      // If point 1 is already located at (0,1,0) after the first rotation, we do not
+      // have to apply the second rotation.
+      if (second_rotation_axis.norm() > std::numeric_limits<double>::min())
+        {
+          second_rotation_axis /= second_rotation_axis.norm();
+          const Tensor<2,3> second_rotation_matrix = rotation_matrix_from_axis(second_rotation_axis, second_rotation_angle);
+
+          // The final rotation used for the model will be the combined
+          // rotation of the two operations above. This is achieved by a
+          // matrix multiplication of the rotation matrices.
+          // This concatenation of rotations is the reason for using a
+          // rotation matrix instead of a combined rotation_axis + angle.
+          rotation_matrix = rotation_matrix * second_rotation_matrix;
+        }
+      return rotation_matrix;
+    }
+
+
+
+    std::pair<double,double> real_spherical_harmonic( const unsigned int l,
+                                                      const unsigned int m,
+                                                      const double theta,
+                                                      const double phi)
+    {
+      Assert (l<65, ExcMessage("ASPECT uses the implementation of spherical harmonics provided by the "
+                               "BOOST library, which is only accurate up a limited degree (see "
+                               "https://www.boost.org/doc/libs/1_62_0/libs/math/doc/html/math_toolkit/sf_poly/sph_harm.html#math_toolkit.sf_poly.sph_harm.accuracy). "
+                               "The function Utilities::real_spherical_harmonic was asked for a higher degree of "
+                               + std::to_string(l) + ", which is not guaranteed to produce a correct value. "
+                               "If you absolutely need to use higher degrees, uncomment this assertion on "
+                               "your own risk and benchmark your results before using them."));
+
+      const double sqrt_2 = numbers::SQRT2;
+      const std::complex<double> sph_harm_val = boost::math::spherical_harmonic( l, m, theta, phi );
+      if ( m == 0 )
+        return std::make_pair( sph_harm_val.real(), 0.0 );
+      else
+        return std::make_pair( sqrt_2 * sph_harm_val.real(), sqrt_2 * sph_harm_val.imag() );
+    }
+
+
+
+    bool
+    fexists(const std::string &filename)
+    {
+      std::ifstream ifile(filename);
+
+      // return whether construction of the input file has succeeded;
+      // success requires the file to exist and to be readable
+      return static_cast<bool>(ifile);
+    }
+
+
+
+    bool
+    fexists(const std::string &filename, const MPI_Comm comm)
+    {
+      bool file_exists = false;
+      if (Utilities::MPI::this_mpi_process(comm) == 0)
+        {
+          std::ifstream ifile(filename);
+
+          // return whether construction of the input file has succeeded;
+          // success requires the file to exist and to be readable
+          file_exists = static_cast<bool>(ifile);
+        }
+      return Utilities::MPI::broadcast(comm, file_exists);
+    }
+
+
+
+    bool
+    filename_is_url(const std::string &filename)
+    {
+      if (filename.find("http://") == 0 || filename.find("https://") == 0 || filename.find("file://") == 0)
+        return true;
+      else
+        return false;
+    }
+
+
+
+    std::string
+    read_and_distribute_file_content(const std::string &filename,
+                                     const MPI_Comm comm)
+    {
+      std::string data_string;
+
+      if (Utilities::MPI::this_mpi_process(comm) == 0)
+        {
+          std::size_t filesize;
+
+          // Check to see if the prm file will be reading data from disk or
+          // from a provided URL
+          if (filename_is_url(filename))
+            {
+#ifdef ASPECT_WITH_LIBDAP
+              std::unique_ptr<libdap::Connect> url
+                = std::make_unique<libdap::Connect>(filename);
+              libdap::BaseTypeFactory factory;
+              libdap::DataDDS dds(&factory);
+              libdap::DAS das;
+
+              url->request_data(dds, "");
+              url->request_das(das);
+
+
+              // Temporary vector that will hold the different arrays stored in urlArray
+              std::vector<libdap::dods_float32> tmp;
+              // Vector that will hold the arrays (columns) and the values within those arrays
+              std::vector<std::vector<libdap::dods_float32>> columns;
+
+              // Check dds values to make sure the arrays are of the same length and of type string
+              for (libdap::DDS::Vars_iter i = dds.var_begin(); i != dds.var_end(); ++i)
+                {
+                  libdap::BaseType *btp = *i;
+                  if ((*i)->type() == libdap::dods_array_c)
+                    {
+                      // Array to store the url data
+                      libdap::Array *urlArray;
+                      urlArray = static_cast <libdap::Array *>(btp);
+                      if (urlArray->var() != nullptr && urlArray->var()->type() == libdap::dods_float32_c)
+                        {
+                          tmp.resize(urlArray->length());
+
+                          // The url Array contains a separate array for each column of data.
+                          // This will put each of these individual arrays into its own vector.
+                          urlArray->value(&tmp[0]);
+                          columns.push_back(tmp);
+                        }
+                      else
+                        {
+                          AssertThrow (false,
+                                       ExcMessage (std::string("Error when reading from url: ") + filename +
+                                                   " Check your connection to the server and make sure the server "
+                                                   "delivers correct data."));
+                        }
+
+                    }
+                  else
+                    {
+                      AssertThrow (false,
+                                   ExcMessage (std::string("Error when reading from url: ") + filename +
+                                               " Check your connection to the server and make sure the server "
+                                               "delivers correct data."));
+                    }
+                }
+
+              // Add the POINTS data that is required and found at the top of the data file.
+              // The POINTS values are set as attributes inside a table.
+              // Loop through the Attribute table to locate the points values within
+              std::vector<std::string> points;
+              for (libdap::AttrTable::Attr_iter i = das.var_begin(); i != das.var_end(); ++i)
+                {
+                  libdap::AttrTable *table = das.get_table(i);
+                  if (table->get_attr("POINTS") != "")
+                    points.push_back(table->get_attr("POINTS"));
+                  if (table->get_attr("points") != "")
+                    points.push_back(table->get_attr("points"));
+                }
+
+              std::stringstream urlString;
+
+              // Append the gathered POINTS in the proper format:
+              // "# POINTS: <val1> <val2> <val3>"
+              urlString << "# POINTS:";
+              for (unsigned int i = 0; i < points.size(); ++i)
+                {
+                  urlString << ' ' << points[i];
+                }
+              urlString << "\n";
+
+              // Add the values from the arrays into the stringstream. The values are passed in
+              // per row with a character return added at the end of each row.
+              // TODO: Add a check to make sure that each column is the same size before writing
+              //     to the stringstream
+              for (unsigned int i = 0; i < tmp.size(); ++i)
+                {
+                  for (unsigned int j = 0; j < columns.size(); ++j)
+                    {
+                      urlString << columns[j][i];
+                      urlString << ' ';
+                    }
+                  urlString << "\n";
+                }
+
+              data_string = urlString.str();
+              filesize = data_string.size();
+
+#else // ASPECT_WITH_LIBDAP
+
+              // Broadcast failure state, then throw. We signal the failure by
+              // setting the file size to an invalid size, then trigger an assert.
+              {
+                std::size_t invalid_filesize = numbers::invalid_size_type;
+                const int ierr = MPI_Bcast(&invalid_filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
+                AssertThrowMPI(ierr);
+              }
+              AssertThrow(false,
+                          ExcMessage(std::string("Reading of file ") + filename + " failed. " +
+                                     "Make sure you have the dependencies for reading a url " +
+                                     "(run cmake with -DASPECT_WITH_LIBDAP=ON)"));
+
+#endif // ASPECT_WITH_LIBDAP
+            }
+          else
+            {
+              std::ifstream filestream;
+              const bool filename_ends_in_gz = std::regex_search(filename, std::regex("\\.gz$"));
+              if (filename_ends_in_gz == true)
+                filestream.open(filename, std::ios_base::in | std::ios_base::binary);
+              else
+                filestream.open(filename);
+
+              if (!filestream)
+                {
+                  // broadcast failure state, then throw
+                  std::size_t invalid_filesize = numbers::invalid_size_type;
+                  const int ierr = MPI_Bcast(&invalid_filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
+                  AssertThrowMPI(ierr);
+                  AssertThrow (false,
+                               ExcMessage (std::string("Could not open file <") + filename + ">."));
+                }
+
+              // Read data from disk
+              std::stringstream datastream;
+
+              try
+                {
+                  boost::iostreams::filtering_istreambuf in;
+                  if (filename_ends_in_gz == true)
+                    in.push(boost::iostreams::gzip_decompressor());
+
+                  in.push(filestream);
+                  boost::iostreams::copy(in, datastream);
+                }
+              catch (const std::ios::failure &)
+                {
+                  // broadcast failure state, then throw
+                  std::size_t invalid_filesize = numbers::invalid_size_type;
+                  const int ierr = MPI_Bcast(&invalid_filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
+                  AssertThrowMPI(ierr);
+                  AssertThrow (false,
+                               ExcMessage (std::string("Could not read file content from <") + filename + ">."));
+                }
+
+              data_string = datastream.str();
+              filesize = data_string.size();
+            }
+
+          // Distribute data_size and data across processes
+          int ierr = MPI_Bcast(&filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
+          AssertThrowMPI(ierr);
+
+          big_mpi::broadcast(&data_string[0], filesize, 0, comm);
+        }
+      else
+        {
+          // Prepare for receiving data
+          std::size_t filesize;
+          int ierr = MPI_Bcast(&filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
+          AssertThrowMPI(ierr);
+          if (filesize == numbers::invalid_size_type)
+            throw QuietException();
+
+          data_string.resize(filesize);
+
+          // Receive and store data
+          big_mpi::broadcast(&data_string[0], filesize, 0, comm);
+        }
+
+      return data_string;
+    }
+
+
+
+    void
+    collect_and_write_file_content(const std::string &filename,
+                                   const std::string &file_content,
+                                   const MPI_Comm comm)
+    {
+      const std::vector<std::string> collected_content = Utilities::MPI::gather(comm, file_content);
+
+      if (Utilities::MPI::this_mpi_process(comm) == 0)
+        {
+          std::ofstream filestream(filename);
+
+          AssertThrow (filestream.good(),
+                       ExcMessage (std::string("Could not open file <") + filename + ">."));
+
+          try
+            {
+              for (const auto &content : collected_content)
+                filestream << content;
+
+              bool success = filestream.good();
+              const int ierr = MPI_Bcast(&success, 1, Utilities::internal::MPI::mpi_type_id(&success), 0, comm);
+              AssertThrowMPI(ierr);
+            }
+          catch (const std::ios::failure &)
+            {
+              // broadcast failure state, then throw
+              bool success = false;
+              const int ierr = MPI_Bcast(&success, 1, Utilities::internal::MPI::mpi_type_id(&success), 0, comm);
+              AssertThrowMPI(ierr);
+              AssertThrow (false,
+                           ExcMessage (std::string("Could not write content to file <") + filename + ">."));
+            }
+
+          filestream.close();
+        }
+      else
+        {
+          // Check that the file was written successfully
+          bool success;
+          int ierr = MPI_Bcast(&success, 1, Utilities::internal::MPI::mpi_type_id(&success), 0, comm);
+          AssertThrowMPI(ierr);
+          if (success == false)
+            throw QuietException();
+        }
+    }
+
+
+
+    int
+    mkdirp(std::string pathname,const mode_t mode)
+    {
+      // force trailing / so we can handle everything in loop
+      if (pathname[pathname.size()-1] != '/')
+        {
+          pathname += '/';
+        }
+
+      size_t pre = 0;
+      size_t pos;
+
+      while ((pos = pathname.find_first_of('/',pre)) != std::string::npos)
+        {
+          const std::string subdir = pathname.substr(0,++pos);
+          pre = pos;
+
+          // if leading '/', first string is 0 length
+          if (subdir.size() == 0)
+            continue;
+
+          int mkdir_return_value;
+          if ((mkdir_return_value = mkdir(subdir.c_str(),mode)) && (errno != EEXIST))
+            return mkdir_return_value;
+
+        }
+
+      return 0;
+    }
+
+
+
+    void create_directory(const std::string &pathname,
+                          const MPI_Comm comm,
+                          bool silent)
+    {
+      // verify that the output directory actually exists. if it doesn't, create
+      // it on processor zero
+      int error;
+
+      if ((Utilities::MPI::this_mpi_process(comm) == 0))
+        {
+          DIR *output_directory = opendir(pathname.c_str());
+          if (output_directory == nullptr)
+            {
+              if (!silent)
+                std::cout << "\n"
+                          << "-----------------------------------------------------------------------------\n"
+                          << "The output directory <" << pathname
+                          << "> provided in the input file appears not to exist.\n"
+                          << "ASPECT will create it for you.\n"
+                          << "-----------------------------------------------------------------------------\n\n"
+                          << std::endl;
+
+              error = Utilities::mkdirp(pathname, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+
+            }
+          else
+            {
+              error = closedir(output_directory);
+            }
+          // Broadcast error code
+          const int ierr = MPI_Bcast (&error, 1, MPI_INT, 0, comm);
+          AssertThrowMPI(ierr);
+          AssertThrow (error == 0,
+                       ExcMessage (std::string("Can't create the output directory at <") + pathname + ">"));
+        }
+      else
+        {
+          // Wait to receive error code, and throw QuietException if directory
+          // creation has failed
+          const int ierr = MPI_Bcast (&error, 1, MPI_INT, 0, comm);
+          AssertThrowMPI(ierr);
+          if (error!=0)
+            throw aspect::QuietException();
+        }
+    }
+
+
+
+// tk does the cubic spline interpolation that can be used between different spherical layers in the mantle.
+// This interpolation is based on the script spline.h, which was downloaded from
+// http://kluge.in-chemnitz.de/opensource/spline/spline.h   //
+// copyright (C) 2011, 2014 Tino Kluge (ttk448 at gmail.com)
+    namespace tk
+    {
+      /**
+       * Band matrix solver for a banded, square matrix of size @p dim. Used
+       * by spline interpolation in tk::spline.
+       */
+      class band_matrix
+      {
+        public:
+          /**
+           * Constructor, see resize()
+           */
+          band_matrix(int dim, int n_u, int n_l);
+
+
+
+          /**
+           * Resize to a @p dim by @dim matrix with given number
+           * of off-diagonals.
+           */
+          void resize(int dim, int n_u, int n_l);
+
+
+
+          /**
+           * Return the dimension of the matrix
+           */
+          int dim() const;
+
+
+
+          /**
+           * Number of off-diagonals above.
+           */
+          int num_upper() const
+          {
+            return m_upper.size()-1;
+          }
+
+
+
+          /**
+           * Number of off-diagonals below.
+           */
+          int num_lower() const
+          {
+            return m_lower.size()-1;
+          }
+
+
+
+          /**
+           * Writeable access to element A(i,j), indices going from
+           * i=0,...,dim()-1
+           */
+          double &operator () (int i, int j);
+
+
+
+          /**
+           * Read-only access
+           */
+          double operator () (int i, int j) const;
+
+
+
+          /**
+           * second diagonal (used in LU decomposition), saved in m_lower[0]
+           */
+          double &saved_diag(int i);
+
+
+
+          /**
+           * second diagonal (used in LU decomposition), saved in m_lower[0]
+           */
+          double saved_diag(int i) const;
+
+
+
+          /**
+           * LU-Decomposition of a band matrix
+           */
+          void lu_decompose();
+
+
+
+          /**
+           * solves Ux=y
+           */
+          std::vector<double> r_solve(const std::vector<double> &b) const;
+
+
+
+          /**
+           * solves Ly=b
+           */
+          std::vector<double> l_solve(const std::vector<double> &b) const;
+
+
+
+          /**
+           * Solve Ax=b and builds LU decomposition using lu_decompose()
+           * if @p is_lu_decomposed is false.
+           */
+          std::vector<double> lu_solve(const std::vector<double> &b,
+                                       bool is_lu_decomposed=false);
+
+
+
+        private:
+          /**
+           * diagonal and off-diagonals above
+           */
+          std::vector<std::vector<double>> m_upper;
+
+          /**
+           * diagonals below the diagonal
+           */
+          std::vector<std::vector<double>> m_lower;
+      };
+
+
+
+      band_matrix::band_matrix(int dim, int n_u, int n_l)
+      {
+        resize(dim, n_u, n_l);
+      }
+
+
+
+      void band_matrix::resize(int dim, int n_u, int n_l)
+      {
+        assert(dim > 0);
+        assert(n_u >= 0);
+        assert(n_l >= 0);
+        m_upper.resize(n_u+1);
+        m_lower.resize(n_l+1);
+        for (auto &x : m_upper)
+          x.resize(dim);
+        for (auto &x : m_lower)
+          x.resize(dim);
+      }
+
+
+
+      int band_matrix::dim() const
+      {
+        if (m_upper.size()>0)
+          {
+            return m_upper[0].size();
+          }
+        else
+          {
+            return 0;
+          }
+      }
+
+
+
+      double &band_matrix::operator () (int i, int j)
+      {
+        int k = j - i;       // what band is the entry
+        assert( (i >= 0) && (i<dim()) && (j >= 0) && (j < dim()) );
+        assert( (-num_lower() <= k) && (k <= num_upper()) );
+        // k=0 -> diagonal, k<0 lower left part, k>0 upper right part
+        if (k >= 0)
+          return m_upper[k][i];
+        else
+          return m_lower[-k][i];
+      }
+
+
+
+      double band_matrix::operator () (int i, int j) const
+      {
+        int k=j-i;       // what band is the entry
+        assert( (i >= 0) && (i < dim()) && (j >= 0) && (j < dim()) );
+        assert( (-num_lower() <= k) && (k <= num_upper()) );
+        // k=0 -> diagonal, k<0 lower left part, k>0 upper right part
+        if (k >= 0)
+          return m_upper[k][i];
+        else
+          return m_lower[-k][i];
+      }
+
+
+
+      double band_matrix::saved_diag(int i) const
+      {
+        assert( (i >= 0) && (i < dim()) );
+        return m_lower[0][i];
+      }
+
+
+
+      double &band_matrix::saved_diag(int i)
+      {
+        assert( (i >= 0) && (i < dim()) );
+        return m_lower[0][i];
+      }
+
+
+
+      void band_matrix::lu_decompose()
+      {
+        int i_max,j_max;
+        int j_min;
+        double x;
+
+        // preconditioning
+        // normalize column i so that a_ii=1
+        for (int i = 0; i < this->dim(); ++i)
+          {
+            assert(this->operator()(i,i) != 0.0);
+            this->saved_diag(i) = 1.0/this->operator()(i,i);
+            j_min = std::max(0,i-this->num_lower());
+            j_max = std::min(this->dim()-1,i+this->num_upper());
+            for (int j = j_min; j <= j_max; ++j)
+              {
+                this->operator()(i,j) *= this->saved_diag(i);
+              }
+            this->operator()(i,i) = 1.0;          // prevents rounding errors
+          }
+
+        // Gauss LR-Decomposition
+        for (int k = 0; k < this->dim(); ++k)
+          {
+            i_max = std::min(this->dim()-1,k+this->num_lower());  // num_lower not a mistake!
+            for (int i = k+1; i <= i_max; ++i)
+              {
+                assert(this->operator()(k,k) != 0.0);
+                x = -this->operator()(i,k)/this->operator()(k,k);
+                this->operator()(i,k) = -x;                         // assembly part of L
+                j_max = std::min(this->dim()-1, k + this->num_upper());
+                for (int j = k+1; j <= j_max; ++j)
+                  {
+                    // assembly part of R
+                    this->operator()(i,j) = this->operator()(i,j)+x*this->operator()(k,j);
+                  }
+              }
+          }
+      }
+
+
+
+      std::vector<double> band_matrix::l_solve(const std::vector<double> &b) const
+      {
+        assert( this->dim() == static_cast<int>(b.size()) );
+        std::vector<double> x(this->dim());
+        int j_start;
+        double sum;
+        for (int i = 0; i < this->dim(); ++i)
+          {
+            sum = 0;
+            j_start = std::max(0,i-this->num_lower());
+            for (int j = j_start; j < i; ++j) sum += this->operator()(i,j)*x[j];
+            x[i] = (b[i]*this->saved_diag(i)) - sum;
+          }
+        return x;
+      }
+
+
+
+      std::vector<double> band_matrix::r_solve(const std::vector<double> &b) const
+      {
+        assert( this->dim() == static_cast<int>(b.size()) );
+        std::vector<double> x(this->dim());
+        int j_stop;
+        double sum;
+        for (int i = this->dim()-1; i >= 0; i--)
+          {
+            sum = 0;
+            j_stop = std::min(this->dim()-1, i + this->num_upper());
+            for (int j = i+1; j <= j_stop; ++j) sum += this->operator()(i,j)*x[j];
+            x[i] = (b[i] - sum) / this->operator()(i,i);
+          }
+        return x;
+      }
+
+
+
+      std::vector<double> band_matrix::lu_solve(const std::vector<double> &b,
+                                                bool is_lu_decomposed)
+      {
+        assert( this->dim() == static_cast<int>(b.size()) );
+        std::vector<double>  x,y;
+        // TODO: this is completely unsafe because you rely on the user
+        // if the function is called more than once.
+        if (is_lu_decomposed == false)
+          {
+            this->lu_decompose();
+          }
+        y = this->l_solve(b);
+        x = this->r_solve(y);
+        return x;
+      }
+
+
+
+      void spline::set_points(const std::vector<double> &x,
+                              const std::vector<double> &y,
+                              bool cubic_spline,
+                              bool monotone_spline)
+      {
+        assert(x.size() == y.size());
+        m_x = x;
+        m_y = y;
+        const unsigned int n = x.size();
+        for (unsigned int i = 0; i < n-1; ++i)
+          {
+            assert(m_x[i] < m_x[i+1]);
+          }
+
+        if (cubic_spline == true)  // cubic spline interpolation
+          {
+            if (monotone_spline == true)
+              {
+                /**
+                 * This monotone spline algorithm is based on the javascript version
+                 * at https://en.wikipedia.org/wiki/Monotone_cubic_interpolation. The
+                 * parameters from this algorithm prevent overshooting in the
+                 * interpolation spline.
+                 */
+                std::vector<double> dys(n-1), dxs(n-1), ms(n-1);
+                for (unsigned int i=0; i < n-1; ++i)
+                  {
+                    dxs[i] = x[i+1]-x[i];
+                    dys[i] = y[i+1]-y[i];
+                    ms[i] = dys[i]/dxs[i];
+                  }
+
+                // get m_a parameter
+                m_c.resize(n);
+                m_c[0] = 0;
+
+                for (unsigned int i = 0; i < n-2; ++i)
+                  {
+                    const double m0 = ms[i];
+                    const double m1 = ms[i+1];
+
+                    if (m0 * m1 <= 0)
+                      {
+                        m_c[i+1] = 0;
+                      }
+                    else
+                      {
+                        const double dx0 = dxs[i];
+                        const double dx1 = dxs[i+1];
+                        const double common = dx0 + dx1;
+                        m_c[i+1] = 3*common/((common + dx0)/m0 + (common + dx1)/m1);
+                      }
+                  }
+                m_c[n-1] = ms[n-2];
+
+                // Get b and c coefficients
+                m_a.resize(n);
+                m_b.resize(n);
+                for (unsigned int i = 0; i < m_c.size()-1; ++i)
+                  {
+                    const double c1 = m_c[i];
+                    const double m0 = ms[i];
+
+                    const double invDx = 1/dxs[i];
+                    const double common0 = c1 + m_c[i+1] - m0 - m0;
+                    m_b[i] = (m0 - c1 - common0) * invDx;
+                    m_a[i] = common0 * invDx * invDx;
+                  }
+              }
+            else
+              {
+                // setting up the matrix and right hand side of the equation system
+                // for the parameters b[]
+                band_matrix A(n,1,1);
+                std::vector<double>  rhs(n);
+                for (unsigned int i = 1; i<n-1; ++i)
+                  {
+                    A(i,i-1) = 1.0/3.0*(x[i]-x[i-1]);
+                    A(i,i) = 2.0/3.0*(x[i+1]-x[i-1]);
+                    A(i,i+1) = 1.0/3.0*(x[i+1]-x[i]);
+                    rhs[i] = (y[i+1]-y[i])/(x[i+1]-x[i]) - (y[i]-y[i-1])/(x[i]-x[i-1]);
+                  }
+                // boundary conditions, zero curvature b[0]=b[n-1]=0
+                A(0,0) = 2.0;
+                A(0,1) = 0.0;
+                rhs[0] = 0.0;
+                A(n-1,n-1) = 2.0;
+                A(n-1,n-2) = 0.0;
+                rhs[n-1] = 0.0;
+
+                // solve the equation system to obtain the parameters b[]
+                m_b = A.lu_solve(rhs);
+
+                // calculate parameters a[] and c[] based on b[]
+                m_a.resize(n);
+                m_c.resize(n);
+                for (unsigned int i = 0; i<n-1; ++i)
+                  {
+                    m_a[i] = 1.0/3.0*(m_b[i+1]-m_b[i])/(x[i+1]-x[i]);
+                    m_c[i] = (y[i+1]-y[i])/(x[i+1]-x[i])
+                             - 1.0/3.0*(2.0*m_b[i]+m_b[i+1])*(x[i+1]-x[i]);
+                  }
+              }
+          }
+        else     // linear interpolation
+          {
+            m_a.resize(n);
+            m_b.resize(n);
+            m_c.resize(n);
+            for (unsigned int i = 0; i<n-1; ++i)
+              {
+                m_a[i] = 0.0;
+                m_b[i] = 0.0;
+                m_c[i] = (m_y[i+1]-m_y[i])/(m_x[i+1]-m_x[i]);
+              }
+          }
+
+        // for the right boundary we define
+        // f_{n-1}(x) = b*(x-x_{n-1})^2 + c*(x-x_{n-1}) + y_{n-1}
+        double h = x[n-1]-x[n-2];
+        // m_b[n-1] is determined by the boundary condition
+        if (!monotone_spline)
+          {
+            m_a[n-1] = 0.0;
+            m_c[n-1] = 3.0*m_a[n-2]*h*h+2.0*m_b[n-2]*h+m_c[n-2];   // = f'_{n-2}(x_{n-1})
+          }
+      }
+
+
+
+      double spline::operator() (double x) const
+      {
+        size_t n = m_x.size();
+        // find the closest point m_x[idx] < x, idx=0 even if x<m_x[0]
+        std::vector<double>::const_iterator it;
+        it = std::lower_bound(m_x.begin(),m_x.end(),x);
+        const int idx = std::max( static_cast<int>(it-m_x.begin())-1, 0);
+
+        double h = x-m_x[idx];
+        double interpol;
+        if (x<m_x[0])
+          {
+            // extrapolation to the left
+            interpol = ((m_b[0])*h + m_c[0])*h + m_y[0];
+          }
+        else if (x>m_x[n-1])
+          {
+            // extrapolation to the right
+            interpol = ((m_b[n-1])*h + m_c[n-1])*h + m_y[n-1];
+          }
+        else
+          {
+            // interpolation
+            interpol = ((m_a[idx]*h + m_b[idx])*h + m_c[idx])*h + m_y[idx];
+          }
+        return interpol;
+      }
+    } // namespace tk
+
+
+
+    std::string
+    expand_ASPECT_SOURCE_DIR (const std::string &location)
+    {
+      // Check for environment variable override to ASPECT_SOURCE_DIR
+      char const *ASPECT_SOURCE_DIR_env = getenv("ASPECT_SOURCE_DIR");
+      if (ASPECT_SOURCE_DIR_env != nullptr)
+        {
+          return Utilities::replace_in_string(location,
+                                              "$ASPECT_SOURCE_DIR",
+                                              ASPECT_SOURCE_DIR_env);
+        }
+
+      // Otherwise, use the default define from config.h
+      return Utilities::replace_in_string(location,
+                                          "$ASPECT_SOURCE_DIR",
+                                          ASPECT_SOURCE_DIR);
+    }
+
+
+
+    std::string parenthesize_if_nonempty (const std::string &s)
+    {
+      if (s.size() > 0)
+        return " (\"" + s + "\")";
+      else
+        return "";
+    }
+
+
+
+    bool
+    string_to_bool(const std::string &s)
+    {
+      return (s == "true" || s == "yes");
+    }
+
+
+
+    std::vector<bool>
+    string_to_bool(const std::vector<std::string> &s)
+    {
+      std::vector<bool> result;
+      result.reserve(s.size());
+
+      for (auto &i : s)
+        result.push_back(string_to_bool(i));
+
+      return result;
+    }
+
+
+
+    unsigned int
+    string_to_unsigned_int(const std::string &s)
+    {
+      const int value = dealii::Utilities::string_to_int(s);
+      AssertThrow (value >= 0, ExcMessage("Negative number in string_to_unsigned_int() detected."));
+      return static_cast<unsigned int>(value);
+    }
+
+
+
+    std::vector<unsigned int>
+    string_to_unsigned_int(const std::vector<std::string> &s)
+    {
+      std::vector<unsigned int> result;
+      result.reserve(s.size());
+
+      for (auto &str : s)
+        result.emplace_back(string_to_unsigned_int(str));
+
+      return result;
+    }
+
+
+
+    bool
+    has_unique_entries (const std::vector<std::string> &strings)
+    {
+      const std::set<std::string> set_of_strings(strings.begin(),strings.end());
+      return (set_of_strings.size() == strings.size());
+    }
+
+
+
+    double
+    weighted_p_norm_average ( const std::vector<double> &weights,
+                              const std::vector<double> &values,
+                              const double p)
+    {
+      // TODO: prevent division by zero for all
+      double averaged_parameter = 0.0;
+
+      // first look at the special cases which can be done faster
+      if (p <= -1000)
+        {
+          // Minimum
+          double min_value = 0;
+          unsigned int first_element_with_nonzero_weight = 0;
+          for (; first_element_with_nonzero_weight < weights.size(); ++first_element_with_nonzero_weight)
+            if (weights[first_element_with_nonzero_weight] > 0)
+              {
+                min_value = values[first_element_with_nonzero_weight];
+                break;
+              }
+          Assert (first_element_with_nonzero_weight < weights.size(),
+                  ExcMessage ("There are only zero (or smaller) weights in the weights vector."));
+
+          for (unsigned int i=first_element_with_nonzero_weight+1; i < weights.size(); ++i)
+            if (weights[i] != 0)
+              if (values[i] < min_value)
+                min_value = values[i];
+
+          return min_value;
+        }
+      else if (p == -1)
+        {
+          // Harmonic average
+          for (unsigned int i=0; i< weights.size(); ++i)
+            {
+              /**
+               * if the value is zero, we get a division by zero. To prevent this
+               * we look at what should happen in this case. When a value is zero,
+               * and the correspondent weight is non-zero, this corresponds to no
+               * resistance in a parallel system. This means that this will dominate,
+               * and we should return zero. If the value is zero and the weight is
+               * zero, we just ignore it.
+               */
+              if (values[i] == 0 && weights[i] > 0)
+                return 0;
+              else if (values[i] != 0)
+                averaged_parameter += weights[i]/values[i];
+            }
+
+          Assert (averaged_parameter > 0, ExcMessage ("The sum of the weights/values may not be smaller or equal to zero."));
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+          return sum_of_weights/averaged_parameter;
+        }
+      else if (p == 0)
+        {
+          // Geometric average
+          for (unsigned int i=0; i < weights.size(); ++i)
+            averaged_parameter += weights[i]*std::log(values[i]);
+
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+          Assert (sum_of_weights != 0,
+                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
+          return std::exp(averaged_parameter/sum_of_weights);
+        }
+      else if (p == 1)
+        {
+          // Arithmetic average
+          for (unsigned int i=0; i< weights.size(); ++i)
+            averaged_parameter += weights[i]*values[i];
+
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+          Assert (sum_of_weights != 0,
+                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
+          return averaged_parameter/sum_of_weights;
+        }
+      else if (p == 2)
+        {
+          // Quadratic average (RMS)
+          for (unsigned int i=0; i< weights.size(); ++i)
+            averaged_parameter += weights[i]*values[i]*values[i];
+
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+          Assert (sum_of_weights != 0,
+                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
+          Assert (averaged_parameter/sum_of_weights > 0, ExcMessage ("The sum of the weights is smaller or equal to zero."));
+          return std::sqrt(averaged_parameter/sum_of_weights);
+        }
+      else if (p == 3)
+        {
+          // Cubic average
+          for (unsigned int i=0; i< weights.size(); ++i)
+            averaged_parameter += weights[i]*values[i]*values[i]*values[i];
+
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+          Assert (sum_of_weights != 0,
+                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
+          return cbrt(averaged_parameter/sum_of_weights);
+        }
+      else if (p >= 1000)
+        {
+          // Maximum
+          double max_value = 0;
+          unsigned int first_element_with_nonzero_weight = 0;
+          for (; first_element_with_nonzero_weight < weights.size(); ++first_element_with_nonzero_weight)
+            if (weights[first_element_with_nonzero_weight] > 0)
+              {
+                max_value = values[first_element_with_nonzero_weight];
+                break;
+              }
+          Assert (first_element_with_nonzero_weight < weights.size(),
+                  ExcMessage ("There are only zero (or smaller) weights in the weights vector."));
+
+          for (unsigned int i=first_element_with_nonzero_weight+1; i < weights.size(); ++i)
+            if (weights[i] != 0)
+              if (values[i] > max_value)
+                max_value = values[i];
+
+          return max_value;
+        }
+      else
+        {
+          for (unsigned int i=0; i< weights.size(); ++i)
+            {
+              /**
+               * When a value is zero or smaller, the exponent is smaller then one and the
+               * correspondent  weight is non-zero, this corresponds to no resistance in a
+               * parallel system.  This means that this 'path' will be followed, and we
+               * return zero.
+               */
+              if (values[i] <= 0 && p < 0)
+                return 0;
+              averaged_parameter += weights[i] * std::pow(values[i],p);
+            }
+
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+
+          Assert (sum_of_weights > 0, ExcMessage ("The sum of the weights may not be smaller or equal to zero."));
+          Assert (averaged_parameter > 0,
+                  ExcMessage ("The sum of the weights times the values to the power p may not be smaller or equal to zero."));
+          return std::pow(averaged_parameter/sum_of_weights, 1/p);
+        }
+    }
+
+
+
+    template <typename T>
+    T
+    derivative_of_weighted_p_norm_average (const double /*averaged_parameter*/,
+                                           const std::vector<double> &weights,
+                                           const std::vector<double> &values,
+                                           const std::vector<T> &derivatives,
+                                           const double p)
+    {
+      // TODO: use averaged_parameter to speed up computation?
+      // TODO: add special cases p = 2 and p = 3
+      double averaged_parameter_derivative_part_1 = 0.0;
+      T averaged_parameter_derivative_part_2 = T();
+
+      // first look at the special cases which can be done faster
+      if (p <= -1000)
+        {
+          // Minimum
+          double min_value = 0;
+          unsigned int element_with_minimum_value = 0;
+          unsigned int first_element_with_nonzero_weight = 0;
+          for (; first_element_with_nonzero_weight < weights.size(); ++first_element_with_nonzero_weight)
+            if (weights[first_element_with_nonzero_weight] > 0)
+              {
+                min_value = values[first_element_with_nonzero_weight];
+                element_with_minimum_value = first_element_with_nonzero_weight;
+                break;
+              }
+          Assert (first_element_with_nonzero_weight < weights.size(),
+                  ExcMessage ("There are only zero (or smaller) weights in the weights vector."));
+
+          for (unsigned int i=first_element_with_nonzero_weight+1; i < weights.size(); ++i)
+            if (weights[i] != 0)
+              if (values[i] < min_value)
+                {
+                  min_value = values[i];
+                  element_with_minimum_value = i;
+                }
+          return derivatives[element_with_minimum_value];
+        }
+      else if (p == -1)
+        {
+          // Harmonic average
+          for (unsigned int i=0; i< weights.size(); ++i)
+            {
+              /**
+               * if the value is zero, we get a division by zero. To prevent this
+               * we look at what should happen in this case. When a value is zero,
+               * and the correspondent weight is non-zero, this corresponds to no
+               * resistance in a parallel system. This means that this will dominate,
+               * and we should return this derivative. If the value is zero and the
+               * weight is zero, we just ignore it.
+               */
+              if (values[i] == 0 && weights[i] > 0)
+                return derivatives[i];
+              else if (values[i] != 0)
+                {
+                  averaged_parameter_derivative_part_1 += weights[i] / values[i];
+                  averaged_parameter_derivative_part_2 += weights[i] * (1/(values[i] * values[i])) * derivatives[i];
+                }
+            }
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+          Assert (sum_of_weights > 0, ExcMessage ("The sum of the weights may not be smaller or equal to zero."));
+          return std::pow(averaged_parameter_derivative_part_1/sum_of_weights,-2) * averaged_parameter_derivative_part_2/sum_of_weights;
+        }
+      else if (p == 0)
+        {
+          // Geometric average
+          for (unsigned int i=0; i < weights.size(); ++i)
+            {
+              averaged_parameter_derivative_part_1 += weights[i]*std::log(values[i]);
+              averaged_parameter_derivative_part_2 += weights[i]*(1/values[i])*derivatives[i];
+            }
+
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+          Assert (sum_of_weights != 0,
+                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
+          return std::exp(averaged_parameter_derivative_part_1/sum_of_weights) * averaged_parameter_derivative_part_2/sum_of_weights;
+        }
+      else if (p == 1)
+        {
+          // Arithmetic average
+          for (unsigned int i=0; i< weights.size(); ++i)
+            averaged_parameter_derivative_part_2 += weights[i]*derivatives[i];
+
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+          Assert (sum_of_weights != 0,
+                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
+          return averaged_parameter_derivative_part_2/sum_of_weights;
+        }
+      else if (p >= 1000)
+        {
+          // Maximum
+          double max_value = 0;
+          unsigned int element_with_maximum_value = 0;
+          unsigned int first_element_with_nonzero_weight = 0;
+          for (; first_element_with_nonzero_weight < weights.size(); ++first_element_with_nonzero_weight)
+            if (weights[first_element_with_nonzero_weight] > 0)
+              {
+                max_value = values[first_element_with_nonzero_weight];
+                element_with_maximum_value = first_element_with_nonzero_weight;
+                break;
+              }
+          Assert (first_element_with_nonzero_weight < weights.size(),
+                  ExcMessage ("There are only zero (or smaller) weights in the weights vector."));
+
+          for (unsigned int i=first_element_with_nonzero_weight+1; i < weights.size(); ++i)
+            if (weights[i] != 0)
+              if (values[i] > max_value)
+                {
+                  max_value = values[i];
+                  element_with_maximum_value = i;
+                }
+
+          return derivatives[element_with_maximum_value];
+        }
+      else
+        {
+          // The general case: We can simplify the equation by stating that (1/p) * p = 1
+          // TODO: This can probably be optimized by using:
+          // averaged_parameter_derivative_part_2 += weights[i]*values_p[i]*(1/values[i])*derivatives[i]; and
+          // averaged_parameter_derivative = averaged_parameter * (1/averaged_parameter_derivative_part_1) * averaged_parameter_derivative_part_2;
+          for (unsigned int i=0; i< weights.size(); ++i)
+            {
+              /**
+               * When a value is zero or smaller, the exponent is smaller then one and the
+               * correspondent  weight is non-zero, this corresponds to no resistance in a
+               * parallel system. This means that this 'path' will be followed, and we
+               * return that derivative.
+               */
+              if (values[i] <= 0 && p < 0)
+                return derivatives[i];
+              averaged_parameter_derivative_part_1 += weights[i] * std::pow(values[i],p);
+              averaged_parameter_derivative_part_2 += weights[i] * std::pow(values[i],p-1) * derivatives[i];
+            }
+          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
+          Assert (sum_of_weights > 0, ExcMessage ("The sum of the weights may not be smaller or equal to zero."));
+          Assert (averaged_parameter_derivative_part_1/sum_of_weights > 0,
+                  ExcMessage ("The sum of the weights times the values to the power p may not be smaller or equal to zero."));
+          return std::pow(averaged_parameter_derivative_part_1/sum_of_weights,(1/p)-1) * averaged_parameter_derivative_part_2/sum_of_weights;
+          // TODO: find a way to check if value is finite for any type? Or just leave this kind of checking up to the user?
+        }
+    }
+
+
+
+    template <int dim>
+    double compute_spd_factor(const double eta,
+                              const SymmetricTensor<2,dim> &strain_rate,
+                              const SymmetricTensor<2,dim> &dviscosities_dstrain_rate,
+                              const double SPD_safety_factor)
+    {
+      // if the strain rate is zero, or the derivative is zero, then
+      // the exact choice of alpha factor does not matter because the
+      // factor that it multiplies is zero -- so return the best value
+      // (i.e., one)
+      if ((strain_rate.norm() == 0) || (dviscosities_dstrain_rate.norm() == 0))
+        return 1;
+
+
+      // The factor in the Newton matrix is going to be of the form
+      //   2*eta I + (a \otimes b + b \otimes a)
+      // where a=strain_rate and b=dviscosities_dstrain_rate.
+      //
+      // If a,b are parallel, this simplifies to
+      //   [2*eta + 2 a:b] I =  2 [eta + a:b] I
+      // and we need to make sure that
+      //   [eta + alpha a:b] > (1-safety_factor)*eta
+      // by choosing alpha appropriately.
+
+      // So, first check: If
+      //   [eta + a:b] > (1-safety_factor)*eta
+      // is already satisfied, then we can choose alpha=1
+      const double a_colon_b = strain_rate * dviscosities_dstrain_rate;
+      if (eta + a_colon_b > eta * (1. - SPD_safety_factor))
+        return 1.0;
+      else
+        {
+          // Otherwise solve the equation above for alpha, which yields
+          //   a:b = -safety_factor*eta / a:b
+          // This can only ever happen if a:b < 0, so we get
+          //   a:b = safety_factor * abs(eta / a:b)
+          Assert (a_colon_b < 0, ExcInternalError());
+          return SPD_safety_factor * std::abs(eta / a_colon_b);
+        }
+    }
+
+
+
+    template <int dim>
+    Point<dim> convert_array_to_point(const std::array<double,dim> &array)
+    {
+      Point<dim> point;
+      for (unsigned int i = 0; i < dim; ++i)
+        point[i] = array[i];
+
+      return point;
+    }
+
+
+
+    template <int dim>
+    std::array<double,dim> convert_point_to_array(const Point<dim> &point)
+    {
+      std::array<double,dim> array;
+      for (unsigned int i = 0; i < dim; ++i)
+        array[i] = point[i];
+
+      return array;
+    }
+
+
+
+    Operator::Operator()
+      :
+      op(uninitialized)
+    {}
+
+
+
+    Operator::Operator(const operation _op)
+      :
+      op(_op)
+    {}
+
+
+
+    double
+    Operator::operator() (const double x, const double y) const
+    {
+      switch (op)
+        {
+          case Utilities::Operator::add:
+          {
+            return x + y;
+          }
+          case Utilities::Operator::subtract:
+          {
+            return x - y;
+          }
+          case Utilities::Operator::minimum:
+          {
+            return std::min(x,y);
+          }
+          case Utilities::Operator::maximum:
+          {
+            return std::max(x,y);
+          }
+          case Utilities::Operator::replace_if_valid:
+          {
+            if (std::isnan(y))
+              return x;
+            else
+              return y;
+          }
+          default:
+          {
+            Assert (false, ExcInternalError());
+          }
+        }
+      return numbers::signaling_nan<double>();
+    }
+
+
+
+    bool
+    Operator::operator== (const operation other_op) const
+    {
+      return other_op == op;
+    }
+
+
+
+    std::vector<Operator> create_model_operator_list(const std::vector<std::string> &operator_names)
+    {
+      std::vector<Operator> operator_list(operator_names.size());
+      for (unsigned int i=0; i<operator_names.size(); ++i)
+        {
+          // create operator list
+          if (operator_names[i] == "add")
+            operator_list[i] = Operator(Operator::add);
+          else if (operator_names[i] == "subtract")
+            operator_list[i] = Operator(Operator::subtract);
+          else if (operator_names[i] == "minimum")
+            operator_list[i] = Operator(Operator::minimum);
+          else if (operator_names[i] == "maximum")
+            operator_list[i] = Operator(Operator::maximum);
+          else if (operator_names[i] == "replace if valid")
+            operator_list[i] = Operator(Operator::replace_if_valid);
+          else
+            AssertThrow(false,
+                        ExcMessage ("ASPECT only accepts the following operators: "
+                                    "add, subtract, minimum, maximum, and replace if valid. But your parameter file "
+                                    "contains: " + operator_names[i] + ". Please check your parameter file.") );
+        }
+
+      return operator_list;
+    }
+
+
+
+    const std::string get_model_operator_options()
+    {
+      return "add|subtract|minimum|maximum|replace if valid";
+    }
+
+
+
+    template <int dim>
+    SymmetricTensor<2,dim>
+    nth_basis_for_symmetric_tensors (const unsigned int k)
+    {
+      Assert((k < SymmetricTensor<2,dim>::n_independent_components),
+             ExcMessage("The component is larger then the amount of independent components in the matrix.") );
+
+      const TableIndices<2> indices_ij = SymmetricTensor<2,dim>::unrolled_to_component_indices (k);
+
+      Tensor<2,dim> result;
+      result[indices_ij] = 1;
+
+      return symmetrize(result);
+    }
+
+
+
+    template <int dim>
+    NaturalCoordinate<dim>::NaturalCoordinate(Point<dim> &position,
+                                              const GeometryModel::Interface<dim> &geometry_model)
+    {
+      coordinate_system = geometry_model.natural_coordinate_system();
+      coordinates = geometry_model.cartesian_to_natural_coordinates(position);
+    }
+
+
+
+    template <int dim>
+    NaturalCoordinate<dim>::NaturalCoordinate(const std::array<double, dim> &coord,
+                                              const Utilities::Coordinates::CoordinateSystem &coord_system) :
+      coordinate_system (coord_system), coordinates (coord)
+    {}
+
+
+
+    template <int dim>
+    std::array<double,dim> &NaturalCoordinate<dim>::get_coordinates()
+    {
+      return coordinates;
+    }
+
+
+
+    template <int dim>
+    const std::array<double,dim> &NaturalCoordinate<dim>::get_coordinates() const
+    {
+      return coordinates;
+    }
+
+
+
+    template <>
+    std::array<double,1> NaturalCoordinate<2>::get_surface_coordinates() const
+    {
+      std::array<double,1> coordinate;
+
+      switch (coordinate_system)
+        {
+          case Coordinates::CoordinateSystem::cartesian:
+            coordinate[0] = coordinates[0];
+            break;
+
+          case Coordinates::CoordinateSystem::spherical:
+            coordinate[0] = coordinates[1];
+            break;
+
+          case Coordinates::CoordinateSystem::ellipsoidal:
+            coordinate[0] = coordinates[1];
+            break;
+
+          default:
+            coordinate[0] = 0;
+            Assert (false, ExcNotImplemented());
+            break;
+        }
+
+      return coordinate;
+    }
+
+
+
+    template <>
+    std::array<double,2> NaturalCoordinate<3>::get_surface_coordinates() const
+    {
+      std::array<double,2> coordinate;
+
+      switch (coordinate_system)
+        {
+          case Coordinates::CoordinateSystem::cartesian:
+            coordinate[0] = coordinates[0];
+            coordinate[1] = coordinates[1];
+            break;
+
+          case Coordinates::CoordinateSystem::spherical:
+            coordinate[0] = coordinates[1];
+            coordinate[1] = coordinates[2];
+            break;
+
+          case Coordinates::CoordinateSystem::ellipsoidal:
+            coordinate[0] = coordinates[1];
+            coordinate[1] = coordinates[2];
+            break;
+
+          default:
+            Assert (false, ExcNotImplemented());
+        }
+
+      return coordinate;
+    }
+
+
+
+    template <int dim>
+    double NaturalCoordinate<dim>::get_depth_coordinate() const
+    {
+      switch (coordinate_system)
+        {
+          case Coordinates::CoordinateSystem::cartesian:
+            return coordinates[dim-1];
+
+          case Coordinates::CoordinateSystem::spherical:
+            return coordinates[0];
+
+          case Coordinates::CoordinateSystem::ellipsoidal:
+            return coordinates[0];
+
+          default:
+            Assert (false, ExcNotImplemented());
+        }
+
+      return 0;
+    }
+
+
+
+    template <int dim, typename VectorType>
+    void
+    project_cellwise(const Mapping<dim>                                        &mapping,
+                     const DoFHandler<dim>                                     &dof_handler,
+                     const unsigned int                                         component_index,
+                     const Quadrature<dim>                                     &quadrature,
+                     const std::function<void(
+                       const typename DoFHandler<dim>::active_cell_iterator &,
+                       const std::vector<Point<dim>> &,
+                       std::vector<double> &)>                                 &function,
+                     VectorType                                                &vec_result)
+    {
+      const FEValuesExtractors::Scalar extractor(component_index);
+
+      UpdateFlags update_flags = UpdateFlags(update_values   |
+                                             update_quadrature_points |
+                                             update_JxW_values);
+
+      FEValues<dim> fe_values (mapping, dof_handler.get_fe(), quadrature, update_flags);
+
+      const unsigned int
+      dofs_per_cell = fe_values.dofs_per_cell,
+      n_q_points    = fe_values.n_quadrature_points;
+
+      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
+      Vector<double> cell_vector (dofs_per_cell);
+      Vector<double> local_projection (dofs_per_cell);
+      FullMatrix<double> local_mass_matrix (dofs_per_cell, dofs_per_cell);
+
+      std::vector<double> rhs_values(n_q_points);
+
+      for (const auto &cell : dof_handler.active_cell_iterators())
+        if (cell->is_locally_owned())
+          {
+            // For each cell, create a local mass matrix and rhs.
+            cell->get_dof_indices (local_dof_indices);
+            fe_values.reinit(cell);
+
+            function(cell, fe_values.get_quadrature_points(), rhs_values);
+
+            cell_vector = 0;
+            local_mass_matrix = 0;
+            for (unsigned int point=0; point<n_q_points; ++point)
+              for (unsigned int i=0; i<dofs_per_cell; ++i)
+                {
+                  if (dof_handler.get_fe().system_to_component_index(i).first == component_index)
+                    cell_vector(i) +=
+                      rhs_values[point] *
+                      fe_values[extractor].value(i,point) *
+                      fe_values.JxW(point);
+
+                  for (unsigned int j=0; j<dofs_per_cell; ++j)
+                    if ((dof_handler.get_fe().system_to_component_index(i).first ==
+                         component_index)
+                        &&
+                        (dof_handler.get_fe().system_to_component_index(j).first ==
+                         component_index))
+                      local_mass_matrix(j,i) += (fe_values[extractor].value(i,point) * fe_values[extractor].value(j,point) *
+                                                 fe_values.JxW(point));
+                    else if (i == j)
+                      local_mass_matrix(i,j) = 1.;
+                }
+
+            // now invert the local mass matrix and multiply it with the rhs
+            local_mass_matrix.gauss_jordan();
+            local_mass_matrix.vmult (local_projection, cell_vector);
+
+            // then set the global solution vector to the values just computed
+            cell->set_dof_values (local_projection, vec_result);
+          }
+    }
+
+
+
+    template <int dim>
+    VectorFunctionFromVelocityFunctionObject<dim>::
+    VectorFunctionFromVelocityFunctionObject
+    (const unsigned int n_components,
+     const std::function<Tensor<1,dim> (const Point<dim> &)> &function_object)
+      :
+      Function<dim>(n_components),
+      function_object (function_object)
+    {
+    }
+
+
+
+    template <int dim>
+    double
+    VectorFunctionFromVelocityFunctionObject<dim>::value (const Point<dim> &p,
+                                                          const unsigned int component) const
+    {
+      Assert (component < this->n_components,
+              ExcIndexRange (component, 0, this->n_components));
+
+      if (component < dim)
+        {
+          const Tensor<1,dim> v = function_object(p);
+          return v[component];
+        }
+      else
+        return 0;
+    }
+
+
+
+    template <int dim>
+    void
+    VectorFunctionFromVelocityFunctionObject<dim>::
+    vector_value (const Point<dim>   &p,
+                  Vector<double>     &values) const
+    {
+      AssertDimension(values.size(), this->n_components);
+
+      // set everything to zero, and then the right components to their correct values
+      values = 0;
+
+      const Tensor<1,dim> v = function_object(p);
+      for (unsigned int d=0; d<dim; ++d)
+        values(d) = v[d];
+    }
+
+
+
+    void throw_linear_solver_failure_exception(const std::string &solver_name,
+                                               const std::string &function_name,
+                                               const std::vector<SolverControl> &solver_controls,
+                                               const std::exception &exc,
+                                               const MPI_Comm mpi_communicator,
+                                               const std::string &output_filename)
+    {
+      if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
+        {
+          std::ostringstream exception_message;
+          exception_message << std::scientific
+                            << "The " + solver_name
+                            << " in " + function_name
+                            << " did not converge. " << std::endl << std::endl;
+
+          if (solver_controls.front().last_step() != numbers::invalid_unsigned_int)
+            exception_message << "The initial residual was: "
+                              << solver_controls.front().initial_value() << std::endl;
+
+          if (solver_controls.back().last_step() != numbers::invalid_unsigned_int)
+            exception_message << "The final residual is: "
+                              << solver_controls.back().last_value() << std::endl;
+
+          exception_message << "The required residual for convergence is: "
+                            << solver_controls.front().tolerance() << std::endl;
+
+          if (output_filename != "")
+            {
+              // output solver history
+              std::ofstream f((output_filename));
+
+              for (const auto &solver_control: solver_controls)
+                {
+                  // Skip the output if no iterations were run for this solver
+                  if (solver_control.last_step() == numbers::invalid_unsigned_int)
+                    continue;
+
+                  // Add an empty line between solvers
+                  if (&solver_control != &(solver_controls.front()))
+                    f << std::endl;
+
+                  unsigned int j=0;
+                  for (const auto &residual: solver_control.get_history_data())
+                    f << j++ << ' ' << residual << std::endl;
+                }
+
+              f.close();
+
+              exception_message << "See " << output_filename
+                                << " for the full convergence history." << std::endl;
+            }
+
+          exception_message << std::endl
+                            << "The solver reported the following error:"
+                            << std::endl;
+          exception_message << exc.what();
+
+          AssertThrow (false,
+                       ExcMessage (exception_message.str()));
+        }
+      else
+        throw QuietException();
+    }
+
+
+
+    std::vector<Tensor<2,3>>
+    rotation_matrices_random_draw_volume_weighting(const std::vector<double> &volume_fraction,
+                                                   const std::vector<Tensor<2,3>> &rotation_matrices,
+                                                   const unsigned int n_output_matrices,
+                                                   std::mt19937 &random_number_generator)
+    {
+      const unsigned int n_grains = volume_fraction.size();
+
+      // Get volume weighted euler angles, using random draws to convert odf
+      // to a discrete number of orientations, weighted by volume
+      // 1a. Sort the volume fractions and matrices based on the volume fractions size
+      const auto p = compute_sorting_permutation(volume_fraction);
+
+      const std::vector<double> fv_sorted = apply_permutation(volume_fraction, p);
+      const std::vector<Tensor<2,3>> matrices_sorted = apply_permutation(rotation_matrices, p);
+
+      // 2. Get cumulative weight for volume fraction
+      std::vector<double> cum_weight(n_grains);
+      std::partial_sum(fv_sorted.begin(),fv_sorted.end(),cum_weight.begin());
+
+      // 3. Generate random indices
+      std::uniform_real_distribution<> dist(0, cum_weight[n_grains-1]);
+      std::vector<double> idxgrain(n_output_matrices);
+      for (unsigned int grain_i = 0; grain_i < n_output_matrices; ++grain_i)
+        {
+          idxgrain[grain_i] = dist(random_number_generator);
+        }
+
+      // 4. Find the maximum cum_weight that is less than the random value.
+      // the euler angle index is +1. For example, if the idxGrain(g) < cumWeight(1),
+      // the index should be 1 not zero)
+      std::vector<Tensor<2,3>> matrices_out(n_output_matrices);
+      for (unsigned int grain_i = 0; grain_i < n_output_matrices; ++grain_i)
+        {
+          const std::vector<double>::iterator selected_matrix =
+            std::lower_bound(cum_weight.begin(),
+                             cum_weight.end(),
+                             idxgrain[grain_i]);
+
+          const unsigned int matrix_index =
+            std::distance(cum_weight.begin(), selected_matrix);
+
+          matrices_out[grain_i] = matrices_sorted[matrix_index];
+        }
+      return matrices_out;
+    }
+
+
+
+    double
+    wrap_angle(const double angle)
+    {
+      return angle - 360.0*std::floor(angle/360.0);
+    }
+
+
+
+    std::array<double,3>
+    zxz_euler_angles_from_rotation_matrix(const Tensor<2,3> &rotation_matrix)
+    {
+      // ZXZ Euler angles
+      std::array<double,3> euler_angles;
+      for (size_t i = 0; i < 3; ++i)
+        for (size_t j = 0; j < 3; ++j)
+          Assert(abs(rotation_matrix[i][j]) <= 1.0,
+                 ExcMessage("rotation_matrix[" + std::to_string(i) + "][" + std::to_string(j) +
+                            "] is larger than one: " + std::to_string(rotation_matrix[i][j]) + " (" + std::to_string(rotation_matrix[i][j]-1.0) + "). rotation_matrix = \n"
+                            + std::to_string(rotation_matrix[0][0]) + " " + std::to_string(rotation_matrix[0][1]) + " " + std::to_string(rotation_matrix[0][2]) + "\n"
+                            + std::to_string(rotation_matrix[1][0]) + " " + std::to_string(rotation_matrix[1][1]) + " " + std::to_string(rotation_matrix[1][2]) + "\n"
+                            + std::to_string(rotation_matrix[2][0]) + " " + std::to_string(rotation_matrix[2][1]) + " " + std::to_string(rotation_matrix[2][2])));
+
+
+      AssertThrow(rotation_matrix[2][2] <= 1.0, ExcMessage("rot_matrix[2][2] > 1.0"));
+
+      const double theta = std::acos(rotation_matrix[2][2]);
+      double phi1 = 0.0;
+      double phi2 = 0.0;
+
+      if (theta != 0.0 && theta != dealii::numbers::PI)
+        {
+          //
+          phi1  = std::atan2(rotation_matrix[2][0]/-std::sin(theta),rotation_matrix[2][1]/-std::sin(theta));
+          phi2  = std::atan2(rotation_matrix[0][2]/-std::sin(theta),rotation_matrix[1][2]/std::sin(theta));
+        }
+
+      // note that in the case theta is 0 or phi a dimension is lost
+      // see: https://en.wikipedia.org/wiki/Gimbal_lock. We set phi1
+      // to 0 and compute the corresponding phi2. The resulting direction
+      // (cosine matrix) should be the same.
+      else if (theta == 0.0)
+        {
+          phi2 = - phi1 - std::atan2(rotation_matrix[0][1],rotation_matrix[0][0]);
+        }
+      else
+        {
+          phi2 = phi1 + std::atan2(rotation_matrix[0][1],rotation_matrix[0][0]);
+        }
+
+
+      AssertThrow(!std::isnan(phi1), ExcMessage("phi1 is not a number. theta = " + std::to_string(theta) + ", rotation_matrix[2][2]= " + std::to_string(rotation_matrix[2][2])
+                                                + ", acos(rotation_matrix[2][2]) = " + std::to_string(std::acos(rotation_matrix[2][2])) + ", acos(1.0) = " + std::to_string(std::acos(1.0))));
+      AssertThrow(!std::isnan(theta), ExcMessage("theta is not a number."));
+      AssertThrow(!std::isnan(phi2), ExcMessage("phi2 is not a number."));
+
+      euler_angles[0] = wrap_angle(phi1 * constants::radians_to_degree);
+      euler_angles[1] = wrap_angle(theta * constants::radians_to_degree);
+      euler_angles[2] = wrap_angle(phi2 * constants::radians_to_degree);
+
+
+      AssertThrow(!std::isnan(euler_angles[0]), ExcMessage(" euler_angles[0] is not a number."));
+      AssertThrow(!std::isnan(euler_angles[1]), ExcMessage(" euler_angles[1] is not a number."));
+      AssertThrow(!std::isnan(euler_angles[2]), ExcMessage(" euler_angles[2] is not a number."));
+
+      return euler_angles;
+    }
+
+
+
+    Tensor<2,3>
+    zxz_euler_angles_to_rotation_matrix(const double phi1_degrees, const double theta_degrees, const double phi2_degrees)
+    {
+      // ZXZ Euler angles
+      const double phi1 = phi1_degrees * constants::degree_to_radians;
+      const double theta = theta_degrees * constants::degree_to_radians;
+      const double phi2 = phi2_degrees * constants::degree_to_radians;
+      Tensor<2,3> rot_matrix;
+
+      rot_matrix[0][0] = std::cos(phi2)*std::cos(phi1) - std::cos(theta)*std::sin(phi1)*std::sin(phi2);
+      rot_matrix[0][1] = -std::cos(phi2)*std::sin(phi1) - std::cos(theta)*std::cos(phi1)*std::sin(phi2);
+      rot_matrix[0][2] = -std::sin(phi2)*std::sin(theta);
+
+      rot_matrix[1][0] = std::sin(phi2)*std::cos(phi1) + std::cos(theta)*std::sin(phi1)*std::cos(phi2);
+      rot_matrix[1][1] = -std::sin(phi2)*std::sin(phi1) + std::cos(theta)*std::cos(phi1)*std::cos(phi2);
+      rot_matrix[1][2] = std::cos(phi2)*std::sin(theta);
+
+      rot_matrix[2][0] = -std::sin(theta)*std::sin(phi1);
+      rot_matrix[2][1] = -std::sin(theta)*std::cos(phi1);
+      rot_matrix[2][2] = std::cos(theta);
+      AssertThrow(rot_matrix[2][2] <= 1.0, ExcMessage("rot_matrix[2][2] > 1.0"));
+
+      return rot_matrix;
+    }
+
+
+
+    namespace Tensors
+    {
+      SymmetricTensor<4,3>
+      rotate_full_stiffness_tensor(const Tensor<2,3> &rotation_tensor, const SymmetricTensor<4,3> &input_tensor)
+      {
+        SymmetricTensor<4,3> output;
+
+        // Dealii symmetric tensor is C_{ijkl} == C_{jikl} == C_{ijlk}, but not C_{klij}.
+        // So we make sure that those entries are not added twice in this loop by having
+        // the second and 4th loop starting with the first and third index respectively.
+        for (unsigned short int i1 = 0; i1 < 3; ++i1)
+          {
+            for (unsigned short int i2 = i1; i2 < 3; ++i2)
+              {
+                for (unsigned short int i3 = 0; i3 < 3; ++i3)
+                  {
+                    for (unsigned short int i4 = i3; i4 < 3; ++i4)
+                      {
+                        for (unsigned short int j1 = 0; j1 < 3; ++j1)
+                          {
+                            for (unsigned short int j2 = 0; j2 < 3; ++j2)
+                              {
+                                for (unsigned short int j3 = 0; j3 < 3; ++j3)
+                                  {
+                                    for (unsigned short int j4 = 0; j4 < 3; ++j4)
+                                      {
+                                        output[i1][i2][i3][i4] += rotation_tensor[i1][j1]*rotation_tensor[i2][j2]*rotation_tensor[i3][j3]*rotation_tensor[i4][j4]*input_tensor[j1][j2][j3][j4];
+                                      }
+                                  }
+                              }
+                          }
+                      }
+                  }
+              }
+          }
+
+        return output;
+      }
+
+
+
+      SymmetricTensor<2,6>
+      rotate_voigt_stiffness_matrix(const Tensor<2,3> &rotation_tensor, const SymmetricTensor<2,6> &input_tensor)
+      {
+        // we can represent the rotation of the 4th order tensor as a rotation in the Voigt
+        // notation by computing $C'=MCM^{-1}$. Because M is orthogonal we can replace $M^{-1}$
+        // with $M^T$ resulting in $C'=MCM^{T}$ (Carcione, J. M. (2007). Wave Fields in Real Media:
+        // Wave Propagation in Anisotropic, Anelastic, Porous and Electromagnetic Media. Netherlands:
+        // Elsevier Science. Pages 8-9).
+        Tensor<2,6> rotation_matrix;
+        // top left block
+        rotation_matrix[0][0] = rotation_tensor[0][0] * rotation_tensor[0][0];
+        rotation_matrix[1][0] = rotation_tensor[1][0] * rotation_tensor[1][0];
+        rotation_matrix[2][0] = rotation_tensor[2][0] * rotation_tensor[2][0];
+        rotation_matrix[0][1] = rotation_tensor[0][1] * rotation_tensor[0][1];
+        rotation_matrix[1][1] = rotation_tensor[1][1] * rotation_tensor[1][1];
+        rotation_matrix[2][1] = rotation_tensor[2][1] * rotation_tensor[2][1];
+        rotation_matrix[0][2] = rotation_tensor[0][2] * rotation_tensor[0][2];
+        rotation_matrix[1][2] = rotation_tensor[1][2] * rotation_tensor[1][2];
+        rotation_matrix[2][2] = rotation_tensor[2][2] * rotation_tensor[2][2];
+
+        // top right block
+        rotation_matrix[0][3] = 2.0 * rotation_tensor[0][1] * rotation_tensor[0][2];
+        rotation_matrix[1][3] = 2.0 * rotation_tensor[1][1] * rotation_tensor[1][2];
+        rotation_matrix[2][3] = 2.0 * rotation_tensor[2][1] * rotation_tensor[2][2];
+        rotation_matrix[0][4] = 2.0 * rotation_tensor[0][2] * rotation_tensor[0][0];
+        rotation_matrix[1][4] = 2.0 * rotation_tensor[1][2] * rotation_tensor[1][0];
+        rotation_matrix[2][4] = 2.0 * rotation_tensor[2][2] * rotation_tensor[2][0];
+        rotation_matrix[0][5] = 2.0 * rotation_tensor[0][0] * rotation_tensor[0][1];
+        rotation_matrix[1][5] = 2.0 * rotation_tensor[1][0] * rotation_tensor[1][1];
+        rotation_matrix[2][5] = 2.0 * rotation_tensor[2][0] * rotation_tensor[2][1];
+
+        // bottom left block
+        rotation_matrix[3][0] = rotation_tensor[1][0] * rotation_tensor[2][0];
+        rotation_matrix[4][0] = rotation_tensor[2][0] * rotation_tensor[0][0];
+        rotation_matrix[5][0] = rotation_tensor[0][0] * rotation_tensor[1][0];
+        rotation_matrix[3][1] = rotation_tensor[1][1] * rotation_tensor[2][1];
+        rotation_matrix[4][1] = rotation_tensor[2][1] * rotation_tensor[0][1];
+        rotation_matrix[5][1] = rotation_tensor[0][1] * rotation_tensor[1][1];
+        rotation_matrix[3][2] = rotation_tensor[1][2] * rotation_tensor[2][2];
+        rotation_matrix[4][2] = rotation_tensor[2][2] * rotation_tensor[0][2];
+        rotation_matrix[5][2] = rotation_tensor[0][2] * rotation_tensor[1][2];
+
+        // bottom right block
+        rotation_matrix[3][3] = rotation_tensor[1][1] * rotation_tensor[2][2] + rotation_tensor[1][2] * rotation_tensor[2][1];
+        rotation_matrix[4][3] = rotation_tensor[0][1] * rotation_tensor[2][2] + rotation_tensor[0][2] * rotation_tensor[2][1];
+        rotation_matrix[5][3] = rotation_tensor[0][1] * rotation_tensor[1][2] + rotation_tensor[0][2] * rotation_tensor[1][1];
+        rotation_matrix[3][4] = rotation_tensor[1][0] * rotation_tensor[2][2] + rotation_tensor[1][2] * rotation_tensor[2][0];
+        rotation_matrix[4][4] = rotation_tensor[0][2] * rotation_tensor[2][0] + rotation_tensor[0][0] * rotation_tensor[2][2];
+        rotation_matrix[5][4] = rotation_tensor[0][2] * rotation_tensor[1][0] + rotation_tensor[0][0] * rotation_tensor[1][2];
+        rotation_matrix[3][5] = rotation_tensor[1][1] * rotation_tensor[2][0] + rotation_tensor[1][0] * rotation_tensor[2][1];
+        rotation_matrix[4][5] = rotation_tensor[0][0] * rotation_tensor[2][1] + rotation_tensor[0][1] * rotation_tensor[2][0];
+        rotation_matrix[5][5] = rotation_tensor[0][0] * rotation_tensor[1][1] + rotation_tensor[0][1] * rotation_tensor[1][0];
+
+        const Tensor<2,6> rotation_matrix_transposed = transpose(rotation_matrix);
+
+        return symmetrize((rotation_matrix*input_tensor)*rotation_matrix_transposed);
+      }
+
+
+
+      SymmetricTensor<2,6>
+      to_voigt_stiffness_matrix(const SymmetricTensor<4,3> &input_tensor)
+      {
+        SymmetricTensor<2,6> output;
+
+        for (unsigned short int i = 0; i < 3; i++)
+          {
+            output[i][i] = input_tensor[i][i][i][i];
+          }
+
+        for (unsigned short int i = 1; i < 3; i++)
+          {
+            output[0][i] = 0.5*(input_tensor[0][0][i][i] + input_tensor[i][i][0][0]);
+            //symmetry: output[0][i] = output[i][0];
+          }
+        output[1][2]=0.5*(input_tensor[1][1][2][2]+input_tensor[2][2][1][1]);
+        //symmetry: output[2][1]=output[1][2];
+
+        for (unsigned short int i = 0; i < 3; i++)
+          {
+            output[i][3]=0.25*(input_tensor[i][i][1][2]+input_tensor[i][i][2][1]+ input_tensor[1][2][i][i]+input_tensor[2][1][i][i]);
+            //symmetry: output[3][i]=output[i][3];
+          }
+
+        for (unsigned short int i = 0; i < 3; i++)
+          {
+            output[i][4]=0.25*(input_tensor[i][i][0][2]+input_tensor[i][i][2][0]+ input_tensor[0][2][i][i]+input_tensor[2][0][i][i]);
+            //symmetry: output[4][i]=output[i][4];
+          }
+
+        for (unsigned short int i = 0; i < 3; i++)
+          {
+            output[i][5]=0.25*(input_tensor[i][i][0][1]+input_tensor[i][i][1][0]+input_tensor[0][1][i][i]+input_tensor[1][0][i][i]);
+            //symmetry: output[5][i]=output[i][5];
+          }
+
+        output[3][3]=0.25*(input_tensor[1][2][1][2]+input_tensor[1][2][2][1]+input_tensor[2][1][1][2]+input_tensor[2][1][2][1]);
+        output[4][4]=0.25*(input_tensor[0][2][0][2]+input_tensor[0][2][2][0]+input_tensor[2][0][0][2]+input_tensor[2][0][2][0]);
+        output[5][5]=0.25*(input_tensor[1][0][1][0]+input_tensor[1][0][0][1]+input_tensor[0][1][1][0]+input_tensor[0][1][0][1]);
+
+        output[3][4]=0.125*(input_tensor[1][2][0][2]+input_tensor[1][2][2][0]+input_tensor[2][1][0][2]+input_tensor[2][1][2][0]+input_tensor[0][2][1][2]+input_tensor[0][2][2][1]+input_tensor[2][0][1][2]+input_tensor[2][0][2][1]);
+        //symmetry: output[4][3]=output[3][4];
+        output[3][5]=0.125*(input_tensor[1][2][0][1]+input_tensor[1][2][1][0]+input_tensor[2][1][0][1]+input_tensor[2][1][1][0]+input_tensor[0][1][1][2]+input_tensor[0][1][2][1]+input_tensor[1][0][1][2]+input_tensor[1][0][2][1]);
+        //symmetry: output[5][3]=output[3][5];
+        output[4][5]=0.125*(input_tensor[0][2][0][1]+input_tensor[0][2][1][0]+input_tensor[2][0][0][1]+input_tensor[2][0][1][0]+input_tensor[0][1][0][2]+input_tensor[0][1][2][0]+input_tensor[1][0][0][2]+input_tensor[1][0][2][0]);
+        //symmetry: output[5][4]=output[4][5];
+
+        return output;
+      }
+
+
+
+      SymmetricTensor<4,3>
+      to_full_stiffness_tensor(const SymmetricTensor<2,6> &input_tensor)
+      {
+        SymmetricTensor<4,3> output;
+
+        for (unsigned short int i = 0; i < 3; i++)
+          for (unsigned short int j = 0; j < 3; j++)
+            for (unsigned short int k = 0; k < 3; k++)
+              for (unsigned short int l = 0; l < 3; l++)
+                {
+                  // The first part of the inline if statement gets the diagonal.
+                  // The second part is never higher than 5 (which is the limit of the tensor index)
+                  // because to reach this part the variables need to be different, which results in
+                  // at least a minus 1.
+                  const unsigned short int p = (i == j ? i : 6 - i - j);
+                  const unsigned short int q = (k == l ? k : 6 - k - l);
+                  output[i][j][k][l] = input_tensor[p][q];
+                }
+        return output;
+      }
+
+
+
+      Tensor<1,21>
+      to_voigt_stiffness_vector(const SymmetricTensor<2,6> &input)
+      {
+        return Tensor<1,21,double> (
+        {
+          input[0][0],           // 0  // 1
+          input[1][1],           // 1  // 2
+          input[2][2],           // 2  // 3
+          numbers::SQRT2 *input[1][2],  // 3  // 4
+          numbers::SQRT2 *input[0][2],  // 4  // 5
+          numbers::SQRT2 *input[0][1],  // 5  // 6
+          2*input[3][3],         // 6  // 7
+          2*input[4][4],         // 7  // 8
+          2*input[5][5],         // 8  // 9
+          2*input[0][3],         // 9  // 10
+          2*input[1][4],         // 10 // 11
+          2*input[2][5],         // 11 // 12
+          2*input[2][3],         // 12 // 13
+          2*input[0][4],         // 13 // 14
+          2*input[1][5],         // 14 // 15
+          2*input[1][3],         // 15 // 16
+          2*input[2][4],         // 16 // 17
+          2*input[0][5],         // 17 // 18
+          2*numbers::SQRT2 *input[4][5], // 18 // 19
+          2*numbers::SQRT2 *input[3][5], // 19 // 20
+          2*numbers::SQRT2 *input[3][4] // 20 // 21
+        });
+
+      }
+
+
+
+      SymmetricTensor<2,6>
+      to_voigt_stiffness_matrix(const Tensor<1,21> &input)
+      {
+        SymmetricTensor<2,6> result;
+
+        const double sqrt_2_inv = 1/numbers::SQRT2;
+
+        result[0][0] = input[0];
+        result[1][1] = input[1];
+        result[2][2] = input[2];
+        result[1][2] = sqrt_2_inv * input[3];
+        result[0][2] = sqrt_2_inv * input[4];
+        result[0][1] = sqrt_2_inv * input[5];
+        result[3][3] = 0.5 * input[6];
+        result[4][4] = 0.5 * input[7];
+        result[5][5] = 0.5 * input[8];
+        result[0][3] = 0.5 * input[9];
+        result[1][4] = 0.5 * input[10];
+        result[2][5] = 0.5 * input[11];
+        result[2][3] = 0.5 * input[12];
+        result[0][4] = 0.5 * input[13];
+        result[1][5] = 0.5 * input[14];
+        result[1][3] = 0.5 * input[15];
+        result[2][4] = 0.5 * input[16];
+        result[0][5] = 0.5 * input[17];
+        result[4][5] = 0.5 * sqrt_2_inv * input[18];
+        result[3][5] = 0.5 * sqrt_2_inv * input[19];
+        result[3][4] = 0.5 * sqrt_2_inv * input[20];
+
+        return result;
+
+      }
+
+
+
+      Tensor<1,21>
+      to_voigt_stiffness_vector(const SymmetricTensor<4,3> &input_tensor)
+      {
+        return Tensor<1,21,double> (
+        {
+          input_tensor[0][0][0][0],           // 0  // 1
+          input_tensor[1][1][1][1],           // 1  // 2
+          input_tensor[2][2][2][2],           // 2  // 3
+          numbers::SQRT2*0.5*(input_tensor[1][1][2][2] + input_tensor[2][2][1][1]),   // 3  // 4
+          numbers::SQRT2*0.5*(input_tensor[0][0][2][2] + input_tensor[2][2][0][0]),   // 4  // 5
+          numbers::SQRT2*0.5*(input_tensor[0][0][1][1] + input_tensor[1][1][0][0]),   // 5  // 6
+          0.5*(input_tensor[1][2][1][2]+input_tensor[1][2][2][1]+input_tensor[2][1][1][2]+input_tensor[2][1][2][1]),         // 6  // 7
+          0.5*(input_tensor[0][2][0][2]+input_tensor[0][2][2][0]+input_tensor[2][0][0][2]+input_tensor[2][0][2][0]),         // 7  // 8
+          0.5*(input_tensor[1][0][1][0]+input_tensor[1][0][0][1]+input_tensor[0][1][1][0]+input_tensor[0][1][0][1]),         // 8  // 9
+          0.5*(input_tensor[0][0][1][2]+input_tensor[0][0][2][1]+input_tensor[1][2][0][0]+input_tensor[2][1][0][0]),         // 9  // 10
+          0.5*(input_tensor[1][1][0][2]+input_tensor[1][1][2][0]+input_tensor[0][2][1][1]+input_tensor[2][0][1][1]),         // 10 // 11
+          0.5*(input_tensor[2][2][0][1]+input_tensor[2][2][1][0]+input_tensor[0][1][2][2]+input_tensor[1][0][2][2]),         // 11 // 12
+          0.5*(input_tensor[2][2][1][2]+input_tensor[2][2][2][1]+input_tensor[1][2][2][2]+input_tensor[2][1][2][2]),         // 12 // 13
+          0.5*(input_tensor[0][0][0][2]+input_tensor[0][0][2][0]+input_tensor[0][2][0][0]+input_tensor[2][0][0][0]),         // 13 // 14
+          0.5*(input_tensor[1][1][0][1]+input_tensor[1][1][1][0]+input_tensor[0][1][1][1]+input_tensor[1][0][1][1]),         // 14 // 15
+          0.5*(input_tensor[1][1][1][2]+input_tensor[1][1][2][1]+input_tensor[1][2][1][1]+input_tensor[2][1][1][1]),         // 15 // 16
+          0.5*(input_tensor[2][2][0][2]+input_tensor[2][2][2][0]+input_tensor[0][2][2][2]+input_tensor[2][0][2][2]),         // 16 // 17
+          0.5*(input_tensor[0][0][0][1]+input_tensor[0][0][1][0]+input_tensor[0][1][0][0]+input_tensor[1][0][0][0]),         // 17 // 18
+          numbers::SQRT2*0.25*(input_tensor[0][2][0][1]+input_tensor[0][2][1][0]+input_tensor[2][0][0][1]+input_tensor[2][0][1][0]+input_tensor[0][1][0][2]+input_tensor[0][1][2][0]+input_tensor[1][0][0][2]+input_tensor[1][0][2][0]), // 18 // 19
+          numbers::SQRT2*0.25*(input_tensor[1][2][0][1]+input_tensor[1][2][1][0]+input_tensor[2][1][0][1]+input_tensor[2][1][1][0]+input_tensor[0][1][1][2]+input_tensor[0][1][2][1]+input_tensor[1][0][1][2]+input_tensor[1][0][2][1]), // 19 // 20
+          numbers::SQRT2*0.25*(input_tensor[1][2][0][2]+input_tensor[1][2][2][0]+input_tensor[2][1][0][2]+input_tensor[2][1][2][0]+input_tensor[0][2][1][2]+input_tensor[0][2][2][1]+input_tensor[2][0][1][2]+input_tensor[2][0][2][1])  // 20 // 21
+        });
+
+      }
+
+
+      template <>
+      const Tensor<3,3> &levi_civita<3>()
+      {
+        static const Tensor<3,3> t =
+          []()
+        {
+          Tensor<3,3> permutation_operator_3d;
+
+          permutation_operator_3d[0][1][2]  = 1;
+          permutation_operator_3d[1][2][0]  = 1;
+          permutation_operator_3d[2][0][1]  = 1;
+          permutation_operator_3d[0][2][1]  = -1;
+          permutation_operator_3d[1][0][2]  = -1;
+          permutation_operator_3d[2][1][0]  = -1;
+          return permutation_operator_3d;
+        }();
+
+        return t;
+      }
+    }
+
+
+// Explicit instantiations
+
+#define INSTANTIATE(dim) \
+  template \
+  IndexSet extract_locally_active_dofs_with_component(const DoFHandler<dim> &, \
+                                                      const ComponentMask &); \
+  \
+  template \
+  std::vector<Point<dim>> \
+  get_unit_support_points(const SimulatorAccess<dim> &simulator_access); \
+  \
+  template \
+  std::vector<std::string> \
+  expand_dimensional_variable_names<dim> (const std::vector<std::string> &var_declarations); \
+  \
+  template \
+  class VectorFunctionFromVelocityFunctionObject<dim>; \
+  \
+  template \
+  Point<dim> Coordinates::spherical_to_cartesian_coordinates<dim>(const std::array<double,dim> &scoord); \
+  \
+  template \
+  std::array<double,dim> Coordinates::cartesian_to_spherical_coordinates<dim>(const Point<dim> &position); \
+  \
+  template \
+  Tensor<1,dim> Coordinates::spherical_to_cartesian_vector<dim>(const Tensor<1,dim> &spherical_vector, \
+                                                                const Point<dim> &position); \
+  \
+  template \
+  bool polygon_contains_point<dim>(const std::vector<Point<2>> &pointList, \
+                                   const dealii::Point<2> &point); \
+  \
+  template \
+  bool point_is_in_triangulation<dim>(const Mapping<dim> &mapping, \
+                                      const parallel::distributed::Triangulation<dim> &triangulation, \
+                                      const Point<dim> &point, \
+                                      const MPI_Comm mpi_communicator); \
+  \
+  template \
+  double signed_distance_to_polygon<dim>(const std::vector<Point<2>> &pointList, \
+                                         const dealii::Point<2> &point); \
+  \
+  template \
+  std::array<Tensor<1,dim>,dim-1> orthogonal_vectors (const Tensor<1,dim> &v); \
+  \
+  template \
+  dealii::SymmetricTensor<2, dim, double> \
+  derivative_of_weighted_p_norm_average (const double averaged_parameter, \
+                                         const std::vector<double> &weights, \
+                                         const std::vector<double> &values, \
+                                         const std::vector<dealii::SymmetricTensor<2, dim, double>> &derivatives, \
+                                         const double p); \
+  \
+  template \
+  double compute_spd_factor(const double eta, \
+                            const SymmetricTensor<2,dim> &strain_rate, \
+                            const SymmetricTensor<2,dim> &dviscosities_dstrain_rate, \
+                            const double safety_factor); \
+  \
+  template \
+  Point<dim> convert_array_to_point<dim>(const std::array<double,dim> &array); \
+  \
+  template \
+  std::array<double,dim> convert_point_to_array<dim>(const Point<dim> &point); \
+  \
+  template \
+  SymmetricTensor<2,dim> nth_basis_for_symmetric_tensors (const unsigned int k); \
+  \
+  template \
+  class NaturalCoordinate<dim>; \
+  \
+  template \
+  void \
+  project_cellwise(const Mapping<dim> &mapping, \
+                   const DoFHandler<dim> &dof_handler, \
+                   const unsigned int component_index, \
+                   const Quadrature<dim> &quadrature, \
+                   const std::function<void( \
+                                             const DoFHandler<dim>::active_cell_iterator &, \
+                                             const std::vector<Point<dim>> &, \
+                                             std::vector<double> &)> &function, \
+                   dealii::LinearAlgebra::distributed::Vector<double> &vec_result); \
+  \
+  template \
+  void \
+  project_cellwise(const Mapping<dim> &mapping, \
+                   const DoFHandler<dim> &dof_handler, \
+                   const unsigned int component_index, \
+                   const Quadrature<dim> &quadrature, \
+                   const std::function<void( \
+                                             const DoFHandler<dim>::active_cell_iterator &, \
+                                             const std::vector<Point<dim>> &, \
+                                             std::vector<double> &)> &function, \
+                   LinearAlgebra::BlockVector &vec_result);
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+
+    // only instantiate for dim=3:
+    template                \
+    std::array<double,3> Coordinates::WGS84_coordinates<3>(const Point<3> &position);
+
+
+    template double
+    derivative_of_weighted_p_norm_average (const double averaged_parameter,
+                                           const std::vector<double> &weights,
+                                           const std::vector<double> &values,
+                                           const std::vector<double> &derivatives,
+                                           const double p);
+
+    template Table<2,double> parse_input_table(const std::string &input_string,
+                                               const unsigned int n_rows,
+                                               const unsigned int n_columns,
+                                               const std::string &property_name);
+  }
+}
diff --git a/source/volume_of_fluid/assembler.cc b/source/volume_of_fluid/assembler.cc
index 1d92fb49bfc..a8b734510b2 100644
--- a/source/volume_of_fluid/assembler.cc
+++ b/source/volume_of_fluid/assembler.cc
@@ -24,7 +24,7 @@
 #include <aspect/volume_of_fluid/utilities.h>
 #include <aspect/volume_of_fluid/handler.h>
 #include <aspect/volume_of_fluid/field.h>
-#include <aspect/volume_of_fluid/assembly.h>
+#include <aspect/volume_of_fluid/simulator/assemblers/interface.h>
 
 
 namespace aspect
diff --git a/source/volume_of_fluid/assembler.cc.bak b/source/volume_of_fluid/assembler.cc.bak
new file mode 100644
index 00000000000..1d92fb49bfc
--- /dev/null
+++ b/source/volume_of_fluid/assembler.cc.bak
@@ -0,0 +1,650 @@
+/*
+ Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file doc/COPYING.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/volume_of_fluid/utilities.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/volume_of_fluid/field.h>
+#include <aspect/volume_of_fluid/assembly.h>
+
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+    template <int dim>
+    void VolumeOfFluidAssembler<dim>::local_assemble_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
+                                                                             const unsigned int calc_dir,
+                                                                             const bool update_from_old,
+                                                                             const typename DoFHandler<dim>::active_cell_iterator &cell,
+                                                                             internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
+                                                                             internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const
+    {
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+
+      // also have the number of dofs that correspond just to the element for
+      // the system we are currently trying to assemble
+      const unsigned int volume_of_fluid_dofs_per_cell = data.local_dof_indices.size();
+
+      Assert (volume_of_fluid_dofs_per_cell < scratch.finite_element_values.get_fe().dofs_per_cell, ExcInternalError());
+      Assert (volume_of_fluid_dofs_per_cell < scratch.face_finite_element_values.get_fe().dofs_per_cell, ExcInternalError());
+      Assert (scratch.phi_field.size() == volume_of_fluid_dofs_per_cell, ExcInternalError());
+
+      const FiniteElement<dim> &main_fe = scratch.finite_element_values.get_fe();
+
+      const unsigned int volume_of_fluidN_component = field.reconstruction.first_component_index;
+      const FEValuesExtractors::Vector volume_of_fluidN_n = FEValuesExtractors::Vector(volume_of_fluidN_component);
+      const FEValuesExtractors::Scalar volume_of_fluidN_d = FEValuesExtractors::Scalar(volume_of_fluidN_component+dim);
+
+      const unsigned int solution_component = field.volume_fraction.first_component_index;
+      const FEValuesExtractors::Scalar solution_field = field.volume_fraction.extractor_scalar();
+
+      const LinearAlgebra::BlockVector &vof_solution_vector = (update_from_old)
+                                                              ?
+                                                              this->get_old_solution()
+                                                              :
+                                                              this->get_solution();
+
+      scratch.finite_element_values.reinit (cell);
+
+      cell->get_dof_indices (scratch.local_dof_indices);
+      for (unsigned int i=0; i<volume_of_fluid_dofs_per_cell; ++i)
+        data.local_dof_indices[i] = scratch.local_dof_indices[main_fe.component_to_system_index(solution_component, i)];
+
+      data.local_matrix = 0;
+      data.local_rhs = 0;
+
+      // For interior face contributions loop over all possible
+      // subfaces of the cell, and reset their matrices.
+      for (auto &m : data.local_face_rhs)
+        m = 0;
+      for (auto &m : data.local_face_matrices_ext_ext)
+        m = 0;
+
+      // Mark the arrays initialized to zero above as currently all unused
+      std::fill (data.face_contributions_mask.begin(), data.face_contributions_mask.end(),
+                 false);
+
+      scratch.finite_element_values[solution_field].get_function_values (vof_solution_vector,
+                                                                         scratch.old_field_values);
+
+      scratch.finite_element_values[volume_of_fluidN_n].get_function_values (vof_solution_vector,
+                                                                             scratch.cell_i_n_values);
+
+      scratch.finite_element_values[volume_of_fluidN_d].get_function_values (vof_solution_vector,
+                                                                             scratch.cell_i_d_values);
+
+      scratch.volume = 0.0;
+
+      for (unsigned int q = 0; q< n_q_points; ++q)
+        {
+          // Init FE field vals
+          for (unsigned int k=0; k<volume_of_fluid_dofs_per_cell; ++k)
+            scratch.phi_field[k] = scratch.finite_element_values[solution_field].value(main_fe.component_to_system_index(solution_component, k), q);
+
+          for (unsigned int i = 0; i<volume_of_fluid_dofs_per_cell; ++i)
+            {
+              data.local_rhs[i] += scratch.old_field_values[q] *
+                                   scratch.finite_element_values.JxW(q);
+              for (unsigned int j=0; j<volume_of_fluid_dofs_per_cell; ++j)
+                data.local_matrix (i, j) += scratch.phi_field[i] *
+                                            scratch.phi_field[j] *
+                                            scratch.finite_element_values.JxW(q);
+            }
+          scratch.volume += scratch.finite_element_values.JxW(q);
+        }
+
+      for (const unsigned int face_no : cell->face_indices())
+        {
+          // Obtain the normal direction for the face in question
+          // Deal.II orders faces as dim*2+(face_direction_is_positive?1:0)
+          const unsigned int face_normal_direction = face_no/2;
+
+          if (face_normal_direction != calc_dir)
+            continue;
+
+          const typename DoFHandler<dim>::face_iterator face = cell->face (face_no);
+
+          if (!face->at_boundary())
+            this->local_assemble_internal_face_volume_of_fluid_system (field, update_from_old, cell, face_no, scratch, data);
+          else
+            this->local_assemble_boundary_face_volume_of_fluid_system (field, update_from_old, cell, face_no, scratch, data);
+        }
+    }
+
+
+
+    template <int dim>
+    void VolumeOfFluidAssembler<dim>::local_assemble_boundary_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
+        const bool update_from_old,
+        const typename DoFHandler<dim>::active_cell_iterator &cell,
+        const unsigned int face_no,
+        internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
+        internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const
+    {
+      const double volume_fraction_threshold = this->get_volume_of_fluid_handler().get_volume_fraction_threshold();
+
+      const bool old_velocity_available = (this->get_timestep_number() > 0);
+
+      const typename DoFHandler<dim>::face_iterator face = cell->face(face_no);
+
+      const unsigned int f_dim = face_no/2; // Obtain dimension
+      const bool face_normal_is_positive = (face_no%2==1);
+
+      const unsigned int n_f_q_points    = scratch.face_finite_element_values.n_quadrature_points;
+
+      // Currently assuming cartesian mapping, so cell->measure()
+      // works, and the neighbor volume cannot be computed easily using
+      // a sum in this call.
+      const double cell_volume = scratch.volume;
+
+      // volume fraction and interface values are constants, so can set from first value
+      const double cell_volume_of_fluid = scratch.old_field_values[0];
+      const Tensor<1, dim> cell_i_normal = scratch.cell_i_n_values[0];
+      const double cell_i_d = scratch.cell_i_d_values[0];
+
+      scratch.face_finite_element_values.reinit (cell, face_no);
+
+      scratch.face_finite_element_values[this->introspection().extractors.velocities]
+      .get_function_values (this->get_current_linearization_point(),
+                            scratch.face_current_velocity_values);
+
+      scratch.face_finite_element_values[this->introspection().extractors.velocities]
+      .get_function_values (this->get_old_solution(),
+                            scratch.face_old_velocity_values);
+
+      if (cell->has_periodic_neighbor (face_no))
+        {
+          // Periodic temperature/composition term: consider the corresponding periodic faces as the case of interior faces
+          this->local_assemble_internal_face_volume_of_fluid_system(field, update_from_old, cell, face_no, scratch, data);
+        }
+      else
+        {
+          // Boundary is not periodic
+
+          double face_flux = 0;
+
+          // Variables for holding values that indicate the "level set" (not
+          // signed distance) on the cell face aperture for calculating the
+          // volume fluxed through this cell face.
+          double face_level_set_d = 0;
+          double face_level_set_time_grad = 0;
+          double boundary_fluid_flux = 0;
+
+          // Using VolumeOfFluid so need to accumulate flux through face
+          if ( this->get_fixed_composition_boundary_indicators().find(
+                 face->boundary_id()
+               )
+               != this->get_fixed_composition_boundary_indicators().end())
+            {
+              // We are in the case of a Dirichlet BC, so calculate the fluid flux if the boundary is upwind.
+              for (unsigned int q=0; q<n_f_q_points; ++q)
+                {
+
+                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
+
+                  //If old velocity available average to half timestep
+                  if (old_velocity_available)
+                    current_u += 0.5*(scratch.face_old_velocity_values[q] -
+                                      scratch.face_current_velocity_values[q]);
+
+
+                  face_flux += this->get_timestep() *
+                               current_u *
+                               scratch.face_finite_element_values.normal_vector(q) *
+                               scratch.face_finite_element_values.JxW(q);
+
+                  boundary_fluid_flux += this->get_boundary_composition_manager().boundary_composition(
+                                           face->boundary_id(),
+                                           scratch.face_finite_element_values.quadrature_point(q),
+                                           field.composition_index) *
+                                         this->get_timestep() *
+                                         current_u *
+                                         scratch.face_finite_element_values.normal_vector(q) *
+                                         scratch.face_finite_element_values.JxW(q);
+
+                }
+            }
+          else
+            {
+              // We are in the case of a Neumann boundary, so only accumulate
+              // the volume flux through the boundary for the correction term
+              for (unsigned int q=0; q<n_f_q_points; ++q)
+                {
+
+                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
+
+                  //If old velocity available average to half timestep
+                  if (old_velocity_available)
+                    current_u += 0.5*(scratch.face_old_velocity_values[q] -
+                                      scratch.face_current_velocity_values[q]);
+
+                  face_flux += this->get_timestep() *
+                               current_u *
+                               scratch.face_finite_element_values.normal_vector(q) *
+                               scratch.face_finite_element_values.JxW(q);
+
+                }
+            }
+
+          // Need to explicitly calculated the values of the "level set"
+          // function on the unit cell on the cell interface being assembled
+          if (face_normal_is_positive)
+            {
+              face_level_set_d = cell_i_d - 0.5*cell_i_normal[f_dim];
+              face_level_set_time_grad = (face_flux/cell_volume)*cell_i_normal[f_dim];
+            }
+          else
+            {
+              face_level_set_d = cell_i_d + 0.5*cell_i_normal[f_dim];
+              face_level_set_time_grad = -(face_flux/cell_volume)*cell_i_normal[f_dim];
+            }
+
+          // Calculate outward flux
+          double flux_volume_of_fluid;
+          if (std::abs(face_flux) < volume_fraction_threshold*cell_volume)
+            {
+              // Volume flux through face is too small for accurate evaluation,
+              // so set the fluxed volume fraction to the raw volume fraction
+              // of the cell for reasonable assembly
+              flux_volume_of_fluid = cell_volume_of_fluid;
+            }
+          else if (face_flux < 0.0) // edge is upwind (inflow boundary), so use the volume fraction implied by the boundary condition
+            {
+              flux_volume_of_fluid = boundary_fluid_flux/face_flux;
+            }
+          else // Cell is upwind of boundary, so compute the volume fraction on the advected volume
+            {
+              flux_volume_of_fluid = VolumeOfFluid::Utilities::calculate_volume_flux<dim> (f_dim,
+                                                                                           face_level_set_time_grad,
+                                                                                           cell_i_normal,
+                                                                                           face_level_set_d);
+            }
+
+          // Add fluxes to RHS
+          if (update_from_old)
+            {
+              // First part of dimensional split update, so use an implicit correction term (adjust matrix)
+              data.local_matrix(0, 0) -= face_flux;
+              data.local_rhs[0] -= (flux_volume_of_fluid) * face_flux;
+            }
+          else
+            {
+              // Later part of dimensional split update, so use an explicit correction term
+              // Matrix term was assembled in the cell portion of the assembler, so no update needed
+              data.local_rhs[0] -= (flux_volume_of_fluid-cell_volume_of_fluid) * face_flux;
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void VolumeOfFluidAssembler<dim>::local_assemble_internal_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
+        const bool update_from_old,
+        const typename DoFHandler<dim>::active_cell_iterator &cell,
+        const unsigned int face_no,
+        internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
+        internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const
+    {
+      const double volume_fraction_threshold = this->get_volume_of_fluid_handler().get_volume_fraction_threshold();
+      const bool old_velocity_available = (this->get_timestep_number() > 0);
+
+      const unsigned int f_dim = face_no/2; // Obtain dimension
+      const bool face_normal_is_positive = (face_no%2==1); // identify direction of face normal
+
+      const unsigned int n_f_q_points    = scratch.face_finite_element_values.n_quadrature_points;
+
+      // Currently assuming cartesian mapping, so cell->measure() works, we
+      // also will need neighbor volume, which cannot be computed easily using
+      // a sum in this call.
+      const double cell_volume = scratch.volume;
+
+      // Volume fraction and interface values are cell-wise constants, so we
+      // can set them from the first solution entry
+      const double cell_volume_of_fluid = scratch.old_field_values[0];
+      const Tensor<1, dim, double> cell_i_normal = scratch.cell_i_n_values[0];
+      const double cell_i_d = scratch.cell_i_d_values[0];
+
+      const FiniteElement<dim> &main_fe = scratch.finite_element_values.get_fe();
+
+      // also have the number of dofs that correspond just to the element for
+      // the system we are currently trying to assemble
+      const unsigned int volume_of_fluid_dofs_per_cell = data.local_dof_indices.size();
+
+      const unsigned int solution_component = field.volume_fraction.first_component_index;
+      const FEValuesExtractors::Scalar solution_field = field.volume_fraction.extractor_scalar();
+
+      const unsigned int volume_of_fluidN_component = field.reconstruction.first_component_index;
+      const FEValuesExtractors::Vector volume_of_fluidN_n = FEValuesExtractors::Vector(volume_of_fluidN_component);
+      const FEValuesExtractors::Scalar volume_of_fluidN_d = FEValuesExtractors::Scalar(volume_of_fluidN_component+dim);
+
+      const typename DoFHandler<dim>::face_iterator face = cell->face (face_no);
+
+      scratch.face_finite_element_values.reinit (cell, face_no);
+
+      const LinearAlgebra::BlockVector &vof_solution_vector = (update_from_old)
+                                                              ?
+                                                              this->get_old_solution()
+                                                              :
+                                                              this->get_solution();
+
+      scratch.face_finite_element_values[this->introspection().extractors.velocities]
+      .get_function_values (this->get_current_linearization_point(),
+                            scratch.face_current_velocity_values);
+
+      scratch.face_finite_element_values[this->introspection().extractors.velocities]
+      .get_function_values (this->get_old_solution(),
+                            scratch.face_old_velocity_values);
+
+      const typename DoFHandler<dim>::cell_iterator
+      neighbor = cell->neighbor_or_periodic_neighbor (face_no);
+      // note: "neighbor" defined above is NOT active_cell_iterator, so this includes cells that are refined
+      // for example: cell with periodic boundary.
+      Assert (neighbor.state() == IteratorState::valid,
+              ExcInternalError());
+      const bool cell_has_periodic_neighbor = cell->has_periodic_neighbor (face_no);
+      const unsigned int neighbor_face_no = (cell_has_periodic_neighbor
+                                             ?
+                                             cell->periodic_neighbor_face_no(face_no)
+                                             :
+                                             cell->neighbor_face_no(face_no));
+
+      const unsigned int n_f_dim = neighbor_face_no/2;
+      const bool n_face_normal_is_positive = (neighbor_face_no%2==1);
+
+      if ((!face->at_boundary() && !face->has_children())
+          || (face->at_boundary() && neighbor->is_active()))
+        {
+          if (neighbor->level () == cell->level () &&
+              neighbor->is_active() &&
+              (((neighbor->is_locally_owned()) && (cell->index() < neighbor->index()))
+               ||
+               ((!neighbor->is_locally_owned()) && (cell->subdomain_id() < neighbor->subdomain_id()))))
+            {
+              /* This cell is taking responsibility for assembly of this face, because
+               *  this cell is equally-sized and
+               *    (a) this cell is on a different subdomain, with lower subdmain_id(), or
+               *    (b) this cell is on the same subdomain and has lower index().
+               */
+              Assert (cell->is_locally_owned(), ExcInternalError());
+
+              Assert (neighbor.state() == IteratorState::valid,
+                      ExcInternalError());
+
+              // Neighbor cell values
+
+              scratch.neighbor_finite_element_values.reinit(neighbor);
+
+              scratch.neighbor_finite_element_values[solution_field]
+              .get_function_values(vof_solution_vector,
+                                   scratch.neighbor_old_values);
+              scratch.neighbor_finite_element_values[volume_of_fluidN_n]
+              .get_function_values(vof_solution_vector,
+                                   scratch.neighbor_i_n_values);
+              scratch.neighbor_finite_element_values[volume_of_fluidN_d]
+              .get_function_values(vof_solution_vector,
+                                   scratch.neighbor_i_d_values);
+
+              // Currently assuming cartesian mapping, so cell->measure()
+              // works, and the neighbor volume cannot be computed easily using
+              // a sum in this call.
+              const double neighbor_volume = neighbor->measure();
+              const double neighbor_volume_of_fluid = scratch.neighbor_old_values[0];
+              const Tensor<1, dim, double> neighbor_i_normal = scratch.neighbor_i_n_values[0];
+              const double neighbor_i_d = scratch.neighbor_i_d_values[0];
+
+              double face_flux = 0;
+              // Variables for holding values that indicate the "level set"
+              // (not signed distance) on the cell face aperture (face x time)
+              // for calculating the volume fluxed through this cell face.
+              double face_level_set_d = 0;
+              double face_level_set_time_grad = 0;
+              double n_face_level_set_d = 0;
+              double n_face_level_set_time_grad =0;
+
+              // Using VolumeOfFluid so need to accumulate flux through face
+              for (unsigned int q=0; q<n_f_q_points; ++q)
+                {
+
+                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
+
+                  //If old velocity available average to half timestep
+                  if (old_velocity_available)
+                    current_u += 0.5*(scratch.face_old_velocity_values[q] -
+                                      scratch.face_current_velocity_values[q]);
+
+                  face_flux += this->get_timestep() *
+                               current_u *
+                               scratch.face_finite_element_values.normal_vector(q) *
+                               scratch.face_finite_element_values.JxW(q);
+
+                }
+
+              // Because the level set data is stored implicitly as a set of
+              // cell-wise constants, the calculation for the relevant normal
+              // time gradient and value of d at the face center must be
+              // computed here
+              if (face_normal_is_positive)
+                {
+                  face_level_set_d = cell_i_d - 0.5*cell_i_normal[f_dim];
+                  face_level_set_time_grad = (face_flux/cell_volume)*cell_i_normal[f_dim];
+                }
+              else
+                {
+                  face_level_set_d = cell_i_d + 0.5*cell_i_normal[f_dim];
+                  face_level_set_time_grad = -(face_flux/cell_volume)*cell_i_normal[f_dim];
+                }
+
+              if (n_face_normal_is_positive)
+                {
+                  n_face_level_set_d = neighbor_i_d - 0.5*neighbor_i_normal[n_f_dim];
+                  n_face_level_set_time_grad = -(face_flux/neighbor_volume)*neighbor_i_normal[n_f_dim];
+                }
+              else
+                {
+                  n_face_level_set_d = neighbor_i_d + 0.5*neighbor_i_normal[n_f_dim];
+                  n_face_level_set_time_grad = (face_flux/neighbor_volume)*neighbor_i_normal[n_f_dim];
+                }
+
+              // Calculate outward flux
+              double flux_volume_of_fluid;
+              if (std::abs(face_flux) < 0.5*volume_fraction_threshold*(cell_volume+neighbor_volume))
+                {
+                  flux_volume_of_fluid = 0.5*(cell_volume_of_fluid+neighbor_volume_of_fluid);
+                }
+              else if (face_flux < 0.0) // Neighbor is upwind
+                {
+                  flux_volume_of_fluid = VolumeOfFluid::Utilities::calculate_volume_flux<dim> (n_f_dim,
+                                                                                               n_face_level_set_time_grad,
+                                                                                               neighbor_i_normal,
+                                                                                               n_face_level_set_d);
+                }
+              else // This cell is upwind
+                {
+                  flux_volume_of_fluid = VolumeOfFluid::Utilities::calculate_volume_flux<dim> (f_dim,
+                                                                                               face_level_set_time_grad,
+                                                                                               cell_i_normal,
+                                                                                               face_level_set_d);
+                }
+
+              std::vector<types::global_dof_index> neighbor_dof_indices (main_fe.dofs_per_cell);
+              // get all dof indices on the neighbor, then extract those
+              // that correspond to the solution_field we are interested in
+              neighbor->get_dof_indices (neighbor_dof_indices);
+
+              const unsigned int f_rhs_ind = Assemblers::nth_interface_matrix(cell->reference_cell(), face_no);
+
+              for (unsigned int i=0; i<volume_of_fluid_dofs_per_cell; ++i)
+                data.neighbor_dof_indices[f_rhs_ind][i]
+                  = neighbor_dof_indices[main_fe.component_to_system_index(solution_component, i)];
+
+              data.face_contributions_mask[f_rhs_ind] = true;
+
+              // fluxes to RHS
+              if (update_from_old)
+                {
+                  data.local_matrix(0, 0) -= face_flux;
+                  data.local_face_matrices_ext_ext[f_rhs_ind](0, 0) += face_flux;
+                  data.local_rhs [0] -= (flux_volume_of_fluid) * face_flux;
+                  data.local_face_rhs[f_rhs_ind][0] += (flux_volume_of_fluid) * face_flux;
+                }
+              else
+                {
+                  data.local_rhs [0] -= (flux_volume_of_fluid-cell_volume_of_fluid) * face_flux;
+                  data.local_face_rhs[f_rhs_ind][0] += (flux_volume_of_fluid-neighbor_volume_of_fluid) * face_flux;
+                }
+            }
+          else
+            {
+              /* neighbor is taking responsibility for assembly of this face, because
+               * either (1) neighbor is coarser, or
+               *        (2) neighbor is equally-sized and
+               *           (a) neighbor is on a different subdomain, with lower subdmain_id(), or
+               *           (b) neighbor is on the same subdomain and has lower index().
+              */
+            }
+        }
+      else // face->has_children() so always assemble from here
+        {
+          for (unsigned int subface_no=0; subface_no< face->n_children(); ++subface_no)
+            {
+              const typename DoFHandler<dim>::active_cell_iterator neighbor_child
+                = ( cell_has_periodic_neighbor
+                    ?
+                    cell->periodic_neighbor_child_on_subface(face_no, subface_no)
+                    :
+                    cell->neighbor_child_on_subface (face_no, subface_no));
+
+              // Neighbor cell values
+
+              scratch.neighbor_finite_element_values.reinit(neighbor_child);
+
+              scratch.neighbor_finite_element_values[solution_field]
+              .get_function_values(vof_solution_vector,
+                                   scratch.neighbor_old_values);
+              scratch.neighbor_finite_element_values[volume_of_fluidN_n]
+              .get_function_values(vof_solution_vector,
+                                   scratch.neighbor_i_n_values);
+              scratch.neighbor_finite_element_values[volume_of_fluidN_d]
+              .get_function_values(vof_solution_vector,
+                                   scratch.neighbor_i_d_values);
+
+              // Currently assuming cartesian mapping, so cell->measure()
+              // works, and the neighbor volume cannot be computed easily using
+              // a sum in this call.
+              const double neighbor_volume = neighbor->measure();
+              const double neighbor_volume_of_fluid = scratch.neighbor_old_values[0];
+
+              scratch.subface_finite_element_values.reinit (cell, face_no, subface_no);
+
+              scratch.subface_finite_element_values[this->introspection().extractors.velocities]
+              .get_function_values (this->get_current_linearization_point(),
+                                    scratch.face_current_velocity_values);
+
+              scratch.subface_finite_element_values[this->introspection().extractors.velocities]
+              .get_function_values (this->get_old_solution(),
+                                    scratch.face_old_velocity_values);
+
+              double face_flux = 0;
+
+              // Using VolumeOfFluid so need to accumulate flux through face
+              for (unsigned int q=0; q<n_f_q_points; ++q)
+                {
+
+                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
+
+                  //If old velocity available average to half timestep
+                  if (old_velocity_available)
+                    current_u += 0.5*(scratch.face_old_velocity_values[q] -
+                                      scratch.face_current_velocity_values[q]);
+
+                  face_flux += this->get_timestep() *
+                               current_u *
+                               scratch.subface_finite_element_values.normal_vector(q) *
+                               scratch.subface_finite_element_values.JxW(q);
+
+                }
+
+              std::vector<types::global_dof_index> neighbor_dof_indices (scratch.subface_finite_element_values.get_fe().dofs_per_cell);
+              neighbor_child->get_dof_indices (neighbor_dof_indices);
+
+              const unsigned int f_rhs_ind = Assemblers::nth_interface_matrix(cell->reference_cell(), face_no, subface_no);
+
+              for (unsigned int i=0; i<volume_of_fluid_dofs_per_cell; ++i)
+                data.neighbor_dof_indices[f_rhs_ind][i]
+                  = neighbor_dof_indices[main_fe.component_to_system_index(solution_component, i)];
+
+              data.face_contributions_mask[f_rhs_ind] = true;
+
+              // fluxes to RHS
+              double flux_volume_of_fluid = face_flux>0.0?cell_volume_of_fluid:neighbor_volume_of_fluid;
+              if (std::abs(face_flux) < 0.5*volume_fraction_threshold*(cell_volume+neighbor_volume))
+                {
+                  flux_volume_of_fluid = 0.5*(cell_volume_of_fluid+neighbor_volume_of_fluid);
+                }
+              if (flux_volume_of_fluid < 0.0)
+                flux_volume_of_fluid = 0.0;
+              if (flux_volume_of_fluid > 1.0)
+                flux_volume_of_fluid = 1.0;
+
+              if (update_from_old)
+                {
+                  data.local_matrix(0, 0) -= face_flux;
+                  data.local_face_matrices_ext_ext[f_rhs_ind](0, 0) += face_flux;
+                  data.local_rhs [0] -= (flux_volume_of_fluid) * face_flux;
+                  data.local_face_rhs[f_rhs_ind][0] += (flux_volume_of_fluid) * face_flux;
+                }
+              else
+                {
+                  data.local_rhs [0] -= (flux_volume_of_fluid-cell_volume_of_fluid) * face_flux;
+                  data.local_face_rhs[f_rhs_ind][0] += (flux_volume_of_fluid-neighbor_volume_of_fluid) * face_flux;
+                }
+
+              // We are currently assembling for a case where the AMR refinement level differs.
+              // If the volume fraction of the fluid flux is not 0 or 1 (to
+              // within tolerance), we are at a VoF fluid interface but have
+              // not correctly computed the advection flux
+              AssertThrow(flux_volume_of_fluid < volume_fraction_threshold || flux_volume_of_fluid>1.0-volume_fraction_threshold,
+                          ExcMessage("Volume of Fluid interface coincides with variation in AMR refinement levels. "
+                                     "This case is not handled by the current Volume of Fluid assembler."));
+            }
+        }
+    }
+  }
+}
+
+
+
+namespace aspect
+{
+  namespace Assemblers
+  {
+#define INSTANTIATE(dim) \
+  template class VolumeOfFluidAssembler<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+
+  }
+}
diff --git a/source/volume_of_fluid/handler.cc.bak b/source/volume_of_fluid/handler.cc.bak
new file mode 100644
index 00000000000..42f4b1698d4
--- /dev/null
+++ b/source/volume_of_fluid/handler.cc.bak
@@ -0,0 +1,647 @@
+/*
+  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/global.h>
+#include <aspect/parameters.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/mesh_refinement/volume_of_fluid_interface.h>
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+
+#include <deal.II/base/work_stream.h>
+#include <deal.II/grid/filtered_iterator.h>
+#include <deal.II/fe/fe_dgq.h>
+#include <deal.II/fe/mapping_cartesian.h>
+
+using namespace dealii;
+
+namespace aspect
+{
+  namespace internal
+  {
+    namespace Assembly
+    {
+      namespace Scratch
+      {
+        template <int dim>
+        VolumeOfFluidSystem<dim>::VolumeOfFluidSystem (const FiniteElement<dim> &finite_element,
+                                                       const FiniteElement<dim> &volume_of_fluid_element,
+                                                       const Mapping<dim>       &mapping,
+                                                       const Quadrature<dim>    &quadrature,
+                                                       const Quadrature<dim-1>  &face_quadrature)
+          :
+          finite_element_values (mapping,
+                                 finite_element, quadrature,
+                                 update_values |
+                                 update_gradients |
+                                 update_JxW_values),
+          neighbor_finite_element_values (mapping,
+                                          finite_element, quadrature,
+                                          update_values |
+                                          update_gradients |
+                                          update_JxW_values),
+          face_finite_element_values (mapping,
+                                      finite_element, face_quadrature,
+                                      update_values |
+                                      update_quadrature_points |
+                                      update_gradients |
+                                      update_normal_vectors |
+                                      update_JxW_values),
+          neighbor_face_finite_element_values (mapping,
+                                               finite_element, face_quadrature,
+                                               update_values |
+                                               update_gradients |
+                                               update_normal_vectors |
+                                               update_JxW_values),
+          subface_finite_element_values (mapping,
+                                         finite_element, face_quadrature,
+                                         update_values |
+                                         update_gradients |
+                                         update_normal_vectors |
+                                         update_JxW_values),
+          local_dof_indices(finite_element.dofs_per_cell),
+          phi_field (volume_of_fluid_element.dofs_per_cell, numbers::signaling_nan<double>()),
+          old_field_values (quadrature.size(), numbers::signaling_nan<double>()),
+          cell_i_n_values (quadrature.size(), numbers::signaling_nan<Tensor<1, dim>> ()),
+          cell_i_d_values (quadrature.size(), numbers::signaling_nan<double> ()),
+          face_current_velocity_values (face_quadrature.size(), numbers::signaling_nan<Tensor<1, dim>>()),
+          face_old_velocity_values (face_quadrature.size(), numbers::signaling_nan<Tensor<1, dim>>()),
+          face_old_old_velocity_values (face_quadrature.size(), numbers::signaling_nan<Tensor<1, dim>>()),
+          neighbor_old_values (face_quadrature.size(), numbers::signaling_nan<double>()),
+          neighbor_i_n_values (face_quadrature.size(), numbers::signaling_nan<Tensor<1, dim>>()),
+          neighbor_i_d_values (face_quadrature.size(), numbers::signaling_nan<double>())
+        {}
+
+
+
+        template <int dim>
+        VolumeOfFluidSystem<dim>::VolumeOfFluidSystem (const VolumeOfFluidSystem &scratch)
+          :
+          finite_element_values (scratch.finite_element_values.get_mapping(),
+                                 scratch.finite_element_values.get_fe(),
+                                 scratch.finite_element_values.get_quadrature(),
+                                 scratch.finite_element_values.get_update_flags()),
+          neighbor_finite_element_values (scratch.neighbor_finite_element_values.get_mapping(),
+                                          scratch.neighbor_finite_element_values.get_fe(),
+                                          scratch.neighbor_finite_element_values.get_quadrature(),
+                                          scratch.neighbor_finite_element_values.get_update_flags()),
+          face_finite_element_values (scratch.face_finite_element_values.get_mapping(),
+                                      scratch.face_finite_element_values.get_fe(),
+                                      scratch.face_finite_element_values.get_quadrature(),
+                                      scratch.face_finite_element_values.get_update_flags()),
+          neighbor_face_finite_element_values (scratch.neighbor_face_finite_element_values.get_mapping(),
+                                               scratch.neighbor_face_finite_element_values.get_fe(),
+                                               scratch.neighbor_face_finite_element_values.get_quadrature(),
+                                               scratch.neighbor_face_finite_element_values.get_update_flags()),
+          subface_finite_element_values (scratch.subface_finite_element_values.get_mapping(),
+                                         scratch.subface_finite_element_values.get_fe(),
+                                         scratch.subface_finite_element_values.get_quadrature(),
+                                         scratch.subface_finite_element_values.get_update_flags()),
+          local_dof_indices (scratch.finite_element_values.get_fe().dofs_per_cell),
+          phi_field (scratch.phi_field),
+          old_field_values (scratch.old_field_values),
+          cell_i_n_values (scratch.cell_i_n_values),
+          cell_i_d_values (scratch.cell_i_d_values),
+          face_current_velocity_values (scratch.face_current_velocity_values),
+          face_old_velocity_values (scratch.face_old_velocity_values),
+          face_old_old_velocity_values (scratch.face_old_old_velocity_values),
+          neighbor_old_values (scratch.neighbor_old_values),
+          neighbor_i_n_values (scratch.neighbor_i_n_values),
+          neighbor_i_d_values (scratch.neighbor_i_d_values)
+        {}
+      }
+
+
+
+      namespace CopyData
+      {
+        template <int dim>
+        VolumeOfFluidSystem<dim>::VolumeOfFluidSystem(const FiniteElement<dim> &finite_element)
+          :
+          local_matrix (finite_element.dofs_per_cell,
+                        finite_element.dofs_per_cell),
+          local_rhs (finite_element.dofs_per_cell),
+          local_face_rhs (Assemblers::n_interface_matrices(finite_element.reference_cell()),
+                          Vector<double>(finite_element.dofs_per_cell)),
+          local_face_matrices_ext_ext(Assemblers::n_interface_matrices(finite_element.reference_cell()),
+                                      FullMatrix<double>(finite_element.dofs_per_cell,
+                                                         finite_element.dofs_per_cell)),
+          face_contributions_mask(Assemblers::n_interface_matrices(finite_element.reference_cell()),
+                                  false),
+
+          local_dof_indices (finite_element.dofs_per_cell),
+          neighbor_dof_indices(Assemblers::n_interface_matrices(finite_element.reference_cell()),
+                               std::vector<types::global_dof_index>(finite_element.dofs_per_cell))
+        {}
+
+
+
+        template <int dim>
+        VolumeOfFluidSystem<dim>::VolumeOfFluidSystem(const VolumeOfFluidSystem &data)
+          :
+          local_matrix (data.local_matrix),
+          local_rhs (data.local_rhs),
+          local_face_rhs (data.local_face_rhs),
+          local_face_matrices_ext_ext (data.local_face_matrices_ext_ext),
+          // clear the flag that indicates that we have valid data in any
+          // of the matrices:
+          face_contributions_mask(data.face_contributions_mask.size(), false),
+          local_dof_indices (data.local_dof_indices),
+          neighbor_dof_indices (data.neighbor_dof_indices)
+        {}
+      }
+    }
+  }
+
+
+
+  template <int dim>
+  VolumeOfFluidField<dim>::VolumeOfFluidField(const FEVariable<dim> &volume_fraction,
+                                              const FEVariable<dim> &reconstruction,
+                                              const FEVariable<dim> &level_set,
+                                              const unsigned int composition_index)
+    : volume_fraction (volume_fraction),
+      reconstruction (reconstruction),
+      level_set (level_set),
+      composition_index(composition_index)
+  {}
+
+
+
+  template <int dim>
+  VolumeOfFluidHandler<dim>::VolumeOfFluidHandler (Simulator<dim> &simulator,
+                                                   ParameterHandler &prm)
+    : sim (simulator),
+      assembler ()
+  {
+    this->initialize_simulator(sim);
+    assembler.initialize_simulator(sim);
+    parse_parameters (prm);
+
+    this->get_signals().edit_finite_element_variables.connect(
+      [&](std::vector<VariableDeclaration<dim>> &vars)
+    {
+      this->edit_finite_element_variables(vars);
+    });
+
+    this->get_signals().post_set_initial_state.connect(
+      [&](const SimulatorAccess<dim> &)
+    {
+      this->set_initial_volume_fractions();
+    });
+  }
+
+
+
+  template <int dim>
+  void
+  VolumeOfFluidHandler<dim>::edit_finite_element_variables (std::vector<VariableDeclaration<dim>> &vars)
+  {
+    for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
+      {
+        // Add declaration for volume fraction field
+        vars.push_back(VariableDeclaration<dim>("volume_fraction_"+volume_of_fluid_field_names[f],
+                                                std::make_unique<FE_DGQ<dim>>(0),
+                                                1,
+                                                1));
+
+        // Add declaration for reconstructed interface cache
+        vars.push_back(VariableDeclaration<dim>("volume_of_fluid_interface_reconstruction_"+volume_of_fluid_field_names[f],
+                                                std::make_unique<FE_DGQ<dim>>(0),
+                                                dim+1,
+                                                1));
+
+        vars.push_back(VariableDeclaration<dim>("volume_of_fluid_contour_"+volume_of_fluid_field_names[f],
+                                                std::make_unique<FE_DGQ<dim>>(1),
+                                                1,
+                                                1));
+      }
+  }
+
+
+
+  template <int dim>
+  void
+  VolumeOfFluidHandler<dim>::declare_parameters (ParameterHandler &prm)
+  {
+    prm.enter_subsection ("Volume of Fluid");
+    {
+      prm.declare_entry ("Volume fraction threshold", "1e-6",
+                         Patterns::Double (0., 1.),
+                         "Minimum significant volume. Fluid fractions below this value are considered to be zero.");
+
+      prm.declare_entry ("Volume of Fluid solver tolerance", "1e-12",
+                         Patterns::Double(0., 1.),
+                         "The relative tolerance up to which the linear system "
+                         "for the Volume of Fluid system gets solved. See "
+                         "'Solver parameters/Composition solver tolerance' "
+                         "for more details.");
+
+      prm.declare_entry ("Number initialization samples", "3",
+                         Patterns::Integer (1),
+                         "Number of divisions per dimension when computing the initial volume fractions."
+                         "If set to the default of 3 for a 2d model, then initialization will be based on "
+                         "the initialization criterion at $3^2=9$ points within each cell. If the initialization "
+                         "based on a composition style initial condition, a larger value may be desired for better "
+                         "approximation of the initial fluid fractions. Smaller values will suffice in the case of "
+                         "level set initializations due to the presence of more information to better approximate "
+                         "the initial fluid fractions.");
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection("Initial composition model");
+    {
+      prm.declare_entry("Volume of fluid initialization type", "",
+                        Patterns::Map (Patterns::Anything(),
+                                       Patterns::Selection("composition|level set")),
+                        "A comma separated list denoting the method to be used to "
+                        "initialize a composition field specified to be advected using "
+                        "the volume of fluid method.\n\n"
+                        "The format of valid entries for this parameter is that "
+                        "of a map given as ``key1:value1, key2:value2`` where "
+                        "each key must be the name of a compositional field "
+                        "using the volume of fluid advection method, and the "
+                        "value is one of ``composition`` or ``level "
+                        "set``. ``composition`` is the default\n\n"
+                        "When ``composition is specified, the initial model is "
+                        "treated as a standard composition field with bounds "
+                        "between 0 and 1 assumed, The initial fluid fractions "
+                        "are then based on an iterated midpoint quadrature. "
+                        "Resultant volume fractions outside of the bounds will be "
+                        "coerced to the nearest valid value (ie 0 or 1). "
+                        "If ``level set`` is specified, the initial data will be assumed to "
+                        "be in the form of a signed distance level set function "
+                        "(i.e. a function which is positive when in the "
+                        "fluid, negative outside, and zero on the interface "
+                        "and the magnitude is always the distance to the "
+                        "interface so the gradient is one everywhere).");
+    }
+    prm.leave_subsection();
+  }
+
+
+
+  template <int dim>
+  void
+  VolumeOfFluidHandler<dim>::parse_parameters (ParameterHandler &prm)
+  {
+    // Get parameter data
+    n_volume_of_fluid_fields = 0;
+    std::vector<std::string> names_of_compositional_fields = this->get_parameters().names_of_compositional_fields;
+    std::vector<typename Parameters<dim>::AdvectionFieldMethod::Kind> compositional_field_methods = this->get_parameters().compositional_field_methods;
+
+    for (unsigned int i=0; i<names_of_compositional_fields.size(); ++i)
+      {
+        if (compositional_field_methods[i] == Parameters<dim>::AdvectionFieldMethod::volume_of_fluid)
+          {
+            // Add this field as the next volume of fluid field
+            volume_of_fluid_field_names.push_back(names_of_compositional_fields[i]);
+            // Note that compositional field indices include temperature as field 0, so increase index by 1
+            volume_of_fluid_composition_map_index[i+1] = n_volume_of_fluid_fields;
+            ++n_volume_of_fluid_fields;
+          }
+      }
+
+    prm.enter_subsection ("Volume of Fluid");
+    {
+      volume_fraction_threshold = prm.get_double("Volume fraction threshold");
+
+      volume_of_fluid_solver_tolerance = prm.get_double("Volume of Fluid solver tolerance");
+
+      n_init_samples = prm.get_integer ("Number initialization samples");
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection("Initial composition model");
+    {
+      const std::vector<std::string> x_initialization_type = Utilities::split_string_list(prm.get("Volume of fluid initialization type"));
+
+      initialization_data_type = std::vector<VolumeOfFluid::VolumeOfFluidInputType::Kind> (n_volume_of_fluid_fields,
+                                 VolumeOfFluid::VolumeOfFluidInputType::composition);
+
+      for (const auto &p : x_initialization_type)
+        {
+          // each entry has the format (white space is optional):
+          // <name> : <value (might have spaces)>
+          //
+          // first tease apart the two halves
+          const std::vector<std::string> split_parts = Utilities::split_string_list (p, ':');
+          AssertThrow (split_parts.size() == 2,
+                       ExcMessage ("The format for "
+                                   "<Initial composition model/Volume of fluid initialization method> "
+                                   "volume of fluid initialization met "
+                                   "requires that each entry " "has the form "
+                                   "`<name of field> : <method>', but this "
+                                   "does not match the number of colons in the "
+                                   "entry <" + p + ">."));
+
+          // get the name of the compositional field
+          const std::string &key = split_parts[0];
+
+          // check that the names used are actually names of fields,
+          // are solved by volume of fluid fields, and are unique in this list
+          std::vector<std::string>::iterator field_name_iterator = std::find(names_of_compositional_fields.begin(),
+                                                                             names_of_compositional_fields.end(), key);
+          AssertThrow (field_name_iterator
+                       != names_of_compositional_fields.end(),
+                       ExcMessage ("Name of field <" + key +
+                                   "> appears in the parameter "
+                                   "<Initial composition model/Volume of fluid initialization method>, but "
+                                   "there is no field with this name."));
+
+          const unsigned int compositional_field_index = std::distance(names_of_compositional_fields.begin(),
+                                                                       field_name_iterator);
+
+          AssertThrow (compositional_field_methods[compositional_field_index]
+                       == Parameters<dim>::AdvectionFieldMethod::volume_of_fluid,
+                       ExcMessage ("The field <" + key + "> appears in the parameter "
+                                   "<Initial composition model/Volume of fluid initialization method>, "
+                                   "but is not advected by a particle method."));
+
+          AssertThrow (std::count(names_of_compositional_fields.begin(),
+                                  names_of_compositional_fields.end(), key) == 1,
+                       ExcMessage ("Name of field <" + key + "> appears more "
+                                   "than once in the parameter "
+                                   "<Initial composition model/Volume of fluid initialization type>."));
+
+          // Get specification for how to treat initializing data
+          const std::string &value = split_parts[1];
+
+          if (value == "composition")
+            initialization_data_type[volume_of_fluid_composition_map_index[compositional_field_index+1]]
+              = VolumeOfFluid::VolumeOfFluidInputType::composition;
+          else if (value == "level set")
+            initialization_data_type[volume_of_fluid_composition_map_index[compositional_field_index+1]]
+              = VolumeOfFluid::VolumeOfFluidInputType::level_set;
+          else
+            AssertThrow(false,ExcNotImplemented());
+        }
+    }
+    prm.leave_subsection();
+  }
+
+
+
+  template <int dim>
+  void
+  VolumeOfFluidHandler<dim>::initialize (ParameterHandler &/*prm*/)
+  {
+    // Do checks on required assumptions
+    AssertThrow(dim==2,
+                ExcMessage("Volume of Fluid Interface Tracking is currently only functional for dim=2."));
+
+    AssertThrow(this->get_parameters().CFL_number < 1.0,
+                ExcMessage("Volume of Fluid Interface Tracking requires CFL < 1."));
+
+    AssertThrow(!this->get_material_model().is_compressible(),
+                ExcMessage("Volume of Fluid Interface Tracking currently assumes incompressibility."));
+
+    AssertThrow(Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()) ||
+                Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()),
+                ExcMessage("Volume of Fluid Interface Tracking currently requires a box geometry."));
+
+    AssertThrow(!this->get_parameters().mesh_deformation_enabled,
+                ExcMessage("Volume of Fluid Interface Tracking is currently incompatible with the Free Surface implementation."));
+
+    AssertThrow(!this->get_parameters().include_melt_transport,
+                ExcMessage("Volume of Fluid Interface Tracking has not been tested with melt transport yet, so inclusion of both is currently disabled."));
+
+    if ( this->get_parameters().initial_adaptive_refinement > 0 ||
+         this->get_parameters().adaptive_refinement_interval > 0 )
+      {
+        AssertThrow(this->get_mesh_refinement_manager().template has_matching_mesh_refinement_strategy<MeshRefinement::VolumeOfFluidInterface<dim>>(),
+                    ExcMessage("Volume of Fluid Interface Tracking requires that the 'volume of fluid interface' strategy be used for AMR"));
+
+        AssertThrow(this->get_parameters().adaptive_refinement_interval <(1/this->get_parameters().CFL_number),
+                    ExcMessage("Currently, the Volume of Fluid Interface Tracking requires that the AMR interval be less than "
+                               "1.0/CFL_number to preserve the intended accuracy. Circumventing this limitation requires "
+                               "additional care in the reconstruction algorithm."));
+      }
+
+    // Gather the created volume fraction data into a structure for easier programmatic referencing
+
+    for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
+      {
+        data.push_back(VolumeOfFluidField<dim>(this->introspection().variable("volume_fraction_"+volume_of_fluid_field_names[f]),
+                                               this->introspection().variable("volume_of_fluid_interface_reconstruction_"+volume_of_fluid_field_names[f]),
+                                               this->introspection().variable("volume_of_fluid_contour_"+volume_of_fluid_field_names[f]),
+                                               this->introspection().compositional_index_for_name(volume_of_fluid_field_names[f])));
+      }
+  }
+
+
+
+  template <int dim>
+  unsigned int VolumeOfFluidHandler<dim>::get_n_fields() const
+  {
+    return n_volume_of_fluid_fields;
+  }
+
+
+
+  template <int dim>
+  const std::string VolumeOfFluidHandler<dim>::name_for_field_index(unsigned int field) const
+  {
+    Assert(field < n_volume_of_fluid_fields,
+           ExcMessage("Invalid field index"));
+    return volume_of_fluid_field_names[field];
+  }
+
+
+
+  template <int dim>
+  double VolumeOfFluidHandler<dim>::get_volume_fraction_threshold() const
+  {
+    return volume_fraction_threshold;
+  }
+
+
+
+  template <int dim>
+  const VolumeOfFluidField<dim> &VolumeOfFluidHandler<dim>::field_struct_for_field_index(unsigned int field) const
+  {
+    Assert(field < n_volume_of_fluid_fields,
+           ExcMessage("Invalid field index"));
+    return data[field];
+  }
+
+
+
+  template <int dim>
+  unsigned int VolumeOfFluidHandler<dim>::field_index_for_name(const std::string &composition_fieldname) const
+  {
+    const unsigned int composition_index = this->introspection().compositional_index_for_name(composition_fieldname);
+    if (volume_of_fluid_composition_map_index.count(composition_index) ==0)
+      return n_volume_of_fluid_fields;
+    return volume_of_fluid_composition_map_index.at(composition_index);
+  }
+
+
+
+  template <int dim>
+  void VolumeOfFluidHandler<dim>::do_volume_of_fluid_update (const typename Simulator<dim>::AdvectionField &advection_field)
+  {
+    const bool direction_order_descending = (this->get_timestep_number() % 2) == 1;
+    const VolumeOfFluidField<dim> volume_of_fluid_field = data[volume_of_fluid_composition_map_index[advection_field.field_index()]];
+
+    const unsigned int volume_of_fluid_block_idx = volume_of_fluid_field.volume_fraction.block_index;
+    const unsigned int volume_of_fluidN_block_idx = volume_of_fluid_field.reconstruction.block_index;
+
+    // Due to dimensionally split formulation, use Strang (second-order dimensional) splitting
+    for (unsigned int direction = 0; direction < dim; ++direction)
+      {
+        // Only reference old_solution for data from prior substep if this is the first
+        // substep for dimensional splitting
+        bool update_from_old = (direction == 0);
+        // Update base to intermediate solution
+        if (!direction_order_descending)
+          {
+            assemble_volume_of_fluid_system(volume_of_fluid_field, direction, update_from_old);
+          }
+        else
+          {
+            assemble_volume_of_fluid_system(volume_of_fluid_field, dim-direction-1, update_from_old);
+          }
+        solve_volume_of_fluid_system (volume_of_fluid_field);
+        // Copy current candidate normals.
+        // primarily useful for exact linear translation
+        sim.solution.block(volume_of_fluidN_block_idx) = sim.old_solution.block(volume_of_fluidN_block_idx);
+        update_volume_of_fluid_normals (volume_of_fluid_field, sim.solution);
+
+        sim.current_linearization_point.block(volume_of_fluid_block_idx) = sim.solution.block(volume_of_fluid_block_idx);
+        sim.current_linearization_point.block(volume_of_fluidN_block_idx) = sim.solution.block(volume_of_fluidN_block_idx);
+      }
+    update_volume_of_fluid_composition(advection_field, volume_of_fluid_field, sim.solution);
+  }
+
+
+
+  template <int dim>
+  void VolumeOfFluidHandler<dim>::assemble_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
+                                                                   const unsigned int dir,
+                                                                   const bool update_from_old)
+  {
+    TimerOutput::Scope timer (sim.computing_timer, "Assemble volume of fluid system");
+
+    const unsigned int block0_idx = field_struct_for_field_index(0).volume_fraction.block_index;
+    const unsigned int block_idx = field.volume_fraction.block_index;
+
+    if (block0_idx!=block_idx)
+      {
+        // Allocate the system matrix for the current VoF field by
+        // reusing the Trilinos sparsity pattern from the matrix stored for
+        // composition 0 (this is the place we allocate the matrix at).
+        sim.system_matrix.block(block_idx, block_idx).reinit(sim.system_matrix.block(block0_idx, block0_idx));
+      }
+
+    sim.system_matrix.block(block_idx, block_idx) = 0;
+    sim.system_rhs = 0;
+
+    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
+
+    const FiniteElement<dim> &volume_of_fluid_fe = (*field.volume_fraction.fe);
+
+    // we have to assemble the term u.grad phi_i * phi_j, which is
+    // of total polynomial degree
+    //   stokes_deg - 1
+    // (or similar for comp_deg). this suggests using a Gauss
+    // quadrature formula of order
+    //   stokes_deg/2
+    // rounded up. do so. (note that x/2 rounded up
+    // equals (x+1)/2 using integer division.)
+    const unsigned int vof_quadrature_degree = (this->get_parameters().stokes_velocity_degree+1)/2;
+
+    WorkStream::
+    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     this->get_dof_handler().begin_active()),
+         CellFilter (IteratorFilters::LocallyOwnedCell(),
+                     this->get_dof_handler().end()),
+         std::bind (&Assemblers::VolumeOfFluidAssembler<dim>::
+                    local_assemble_volume_of_fluid_system,
+                    assembler,
+                    field,
+                    dir,
+                    update_from_old,
+                    std::placeholders::_1,
+                    std::placeholders::_2,
+                    std::placeholders::_3),
+         std::bind (&VolumeOfFluidHandler<dim>::
+                    copy_local_to_global_volume_of_fluid_system,
+                    this,
+                    std::placeholders::_1),
+         internal::Assembly::Scratch::
+         VolumeOfFluidSystem<dim> (this->get_fe(),
+                                   volume_of_fluid_fe,
+                                   this->get_mapping(),
+                                   QGauss<dim>(vof_quadrature_degree),
+                                   QGauss<dim-1>(vof_quadrature_degree)),
+         internal::Assembly::CopyData::
+         VolumeOfFluidSystem<dim> (volume_of_fluid_fe));
+
+    sim.system_matrix.compress(VectorOperation::add);
+    sim.system_rhs.compress(VectorOperation::add);
+  }
+
+
+
+  template <int dim>
+  void VolumeOfFluidHandler<dim>::copy_local_to_global_volume_of_fluid_system (const internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data)
+  {
+    // copy entries into the global matrix. note that these local contributions
+    // only correspond to the advection dofs, as assembled above
+    sim.current_constraints.distribute_local_to_global (data.local_matrix,
+                                                        data.local_rhs,
+                                                        data.local_dof_indices,
+                                                        sim.system_matrix,
+                                                        sim.system_rhs);
+
+    // In the following, we copy DG contributions entry by entry. This
+    // is allowed since there are no constraints imposed on discontinuous fields.
+    for (unsigned int f=0; f<data.face_contributions_mask.size(); ++f)
+      {
+        if (data.face_contributions_mask[f])
+          {
+            for (unsigned int i=0; i<data.neighbor_dof_indices[f].size(); ++i)
+              {
+                sim.system_rhs(data.neighbor_dof_indices[f][i]) += data.local_face_rhs[f][i];
+                for (unsigned int j=0; j< data.neighbor_dof_indices[f].size(); ++j)
+                  {
+                    sim.system_matrix.add(data.neighbor_dof_indices[f][i],
+                                          data.neighbor_dof_indices[f][j],
+                                          data.local_face_matrices_ext_ext[f](i,j));
+                  }
+              }
+          }
+      }
+  }
+}
+
+
+
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template class VolumeOfFluidHandler<dim>;
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/volume_of_fluid/reconstruct.cc.bak b/source/volume_of_fluid/reconstruct.cc.bak
new file mode 100644
index 00000000000..4ad97a38dfa
--- /dev/null
+++ b/source/volume_of_fluid/reconstruct.cc.bak
@@ -0,0 +1,519 @@
+/*
+ Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file doc/COPYING.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/global.h>
+#include <aspect/simulator.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/volume_of_fluid/utilities.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <>
+  void VolumeOfFluidHandler<2>::update_volume_of_fluid_normals (const VolumeOfFluidField<2> &field,
+                                                                LinearAlgebra::BlockVector &solution)
+  {
+    const unsigned int dim = 2;
+    const unsigned int max_degree = 1;
+
+    LinearAlgebra::BlockVector initial_solution;
+
+    TimerOutput::Scope timer (sim.computing_timer, "Reconstruct VolumeOfFluid interfaces");
+
+    initial_solution.reinit(sim.system_rhs, false);
+
+    // Boundary reference
+    typename DoFHandler<dim>::active_cell_iterator endc =
+      this->get_dof_handler().end ();
+
+    // Number of cells in the local reconstruction stencil
+    const unsigned int n_cells_local_stencil = 9;
+
+    Vector<double> local_volume_of_fluids (n_cells_local_stencil);
+    std::vector<Point<dim>> stencil_unit_cell_centers (n_cells_local_stencil);
+    std::vector<typename DoFHandler<dim>::active_cell_iterator> neighbor_cells(n_cells_local_stencil);
+
+    const unsigned int n_candidate_normals_per_dim = 3; // Named variable for number of candidate sums for each dimension
+    std::vector<double> strip_sums (dim * n_candidate_normals_per_dim);
+
+    // Named variable for number of candidate interface normal vectors for the reconstruction
+    const unsigned int n_candidate_normals = dim*n_candidate_normals_per_dim+1;
+    std::vector<Tensor<1, dim, double>> normals (n_candidate_normals);
+    std::vector<double> d_vals (n_candidate_normals);
+    std::vector<double> errs (n_candidate_normals);
+
+    // Variables to do volume calculations
+
+    const QGauss<dim> quadrature(max_degree);
+
+    std::vector<double> xFEM_values(quadrature.size());
+
+    const FiniteElement<dim> &system_fe = this->get_fe();
+
+    FEValues<dim> fevalues(this->get_mapping(), system_fe, quadrature,
+                           update_JxW_values);
+
+    // Normal holding vars
+    Point<dim> reconstruction_stencil_unit_cell_center;
+    Tensor<1, dim, double> normal;
+    double d;
+
+    for (unsigned int i=0; i<dim; ++i)
+      reconstruction_stencil_unit_cell_center[i] = 0.5;
+
+    std::vector<types::global_dof_index> cell_dof_indices (system_fe.dofs_per_cell);
+    std::vector<types::global_dof_index> local_dof_indices (system_fe.dofs_per_cell);
+
+    const FEVariable<dim> &volume_of_fluid_var = field.volume_fraction;
+    const unsigned int volume_of_fluid_c_index = volume_of_fluid_var.first_component_index;
+    const unsigned int volume_of_fluid_ind
+      = this->get_fe().component_to_system_index(volume_of_fluid_c_index, 0);
+
+    const FEVariable<dim> &volume_of_fluidN_var = field.reconstruction;
+    const unsigned int volume_of_fluidN_c_index = volume_of_fluidN_var.first_component_index;
+    const unsigned int volume_of_fluidN_blockidx = volume_of_fluidN_var.block_index;
+
+    const FEVariable<dim> &volume_of_fluidLS_var = field.level_set;
+    const unsigned int volume_of_fluidLS_c_index = volume_of_fluidLS_var.first_component_index;
+    const unsigned int n_volume_of_fluidLS_dofs = volume_of_fluidLS_var.fe->dofs_per_cell;
+    const unsigned int volume_of_fluidLS_blockidx = volume_of_fluidLS_var.block_index;
+
+    //Iterate over cells
+    for (auto cell : this->get_dof_handler().active_cell_iterators ())
+      {
+        if (!cell->is_locally_owned ())
+          continue;
+
+        // Obtain data for this cell and neighbors
+        cell->get_dof_indices (local_dof_indices);
+        const double cell_volume_of_fluid = solution(local_dof_indices[volume_of_fluid_ind]);
+
+        normal[0] = 0.0;
+        normal[1] = 0.0;
+        d = -1.0;
+
+        if (cell_volume_of_fluid > 1.0 - volume_fraction_threshold)
+          {
+            d = 1.0;
+            initial_solution(local_dof_indices[volume_of_fluid_ind]) = 1.0;
+          }
+        else if (cell_volume_of_fluid < volume_fraction_threshold)
+          {
+            d = -1.0;
+            initial_solution(local_dof_indices[volume_of_fluid_ind]) = 0.0;
+          }
+        else
+          {
+            initial_solution(local_dof_indices[volume_of_fluid_ind]) = cell_volume_of_fluid;
+
+            // Get references to neighboring cells to build stencil references
+            //
+            // Due to mesh structure, we need to obtain the cells by
+            // considering the pattern of neighboring cells
+            //
+            // Indices used for the stencil references follow the
+            // pattern
+            //
+            // 6 7 8
+            // 3 4 5
+            // 0 1 2
+            const unsigned int stencil_side_cell_count = 3;
+            for (unsigned int i = 0; i < stencil_side_cell_count; ++i)
+              {
+                typename DoFHandler<dim>::active_cell_iterator cen; // holding variable for cell at column center
+                if (i == 0 || i == 2)
+                  {
+                    // Not on center column, so obtain the center cell of the appropriate row
+                    const unsigned int neighbor_no = (i/2);
+                    const typename DoFHandler<dim>::face_iterator face = cell->face (neighbor_no);
+                    if ((face->at_boundary() && !cell->has_periodic_neighbor(neighbor_no)) ||
+                        face->has_children())
+                      cen = endc;
+                    else
+                      {
+                        const typename DoFHandler<dim>::cell_iterator neighbor =
+                          cell->neighbor_or_periodic_neighbor(neighbor_no);
+                        if (neighbor->level() == cell->level() &&
+                            neighbor->is_active())
+                          cen = neighbor;
+                        else
+                          cen = endc;
+                      }
+                  }
+                else
+                  {
+                    // On center column, so current cell is center of column
+                    cen = cell;
+                  }
+
+                for (unsigned int j = 0; j < stencil_side_cell_count; ++j)
+                  {
+                    typename DoFHandler<dim>::active_cell_iterator curr; // Variable for cell at current stencil location
+                    if (cen == endc)
+                      {
+                        // Current column center is not in mesh, so assume that
+                        // the desired piece of the stencil is also outside.
+                        curr = endc;
+                      }
+                    else
+                      {
+                        // Current column center exists, so obtain correct cell reference
+                        if (j == 0 || j == 2)
+                          {
+                            //
+                            const unsigned int neighbor_no = 2+(j/2);
+                            const typename DoFHandler<dim>::face_iterator face = cen->face (neighbor_no);
+                            if ((face->at_boundary() && !cen->has_periodic_neighbor(neighbor_no)) ||
+                                face->has_children())
+                              curr = endc;
+                            else
+                              {
+                                const typename DoFHandler<dim>::cell_iterator neighbor =
+                                  cen->neighbor_or_periodic_neighbor(neighbor_no);
+                                if (neighbor->level() == cell->level() &&
+                                    neighbor->is_active())
+                                  curr = neighbor;
+                                else
+                                  curr = endc;
+                              }
+                          }
+                        else
+                          {
+                            // Current stencil reference is column center column center
+                            curr = cen;
+                          }
+                      }
+                    if (curr != endc)
+                      {
+                        // Cell reference is valid, so get data
+                        curr->get_dof_indices (cell_dof_indices);
+                        stencil_unit_cell_centers[3 * j + i] = Point<dim> (-1.0 + i,
+                                                                           -1.0 + j);
+                      }
+                    else
+                      {
+                        // Cell reference is invalid, so replace with current
+                        // cell to reduce branching complexity in the later
+                        // algorithm
+                        cell->get_dof_indices (cell_dof_indices);
+                        stencil_unit_cell_centers[3 * j + i] = Point<dim> (0.0,
+                                                                           0.0);
+                      }
+                    local_volume_of_fluids (3 * j + i) = solution (cell_dof_indices[volume_of_fluid_ind]);
+                    neighbor_cells[3 * j + i] = curr;
+                  }
+              }
+
+            // Gather cell strip sums
+            //
+            // Sums are indexed as
+            // [n_sums_per_dim * parallel_dim + ind]
+            const unsigned int n_sums_per_dim = 3;
+            for (unsigned int i = 0; i < dim * n_candidate_normals_per_dim; ++i)
+              strip_sums[i] = 0.0;
+
+            for (unsigned int i = 0; i < stencil_side_cell_count; ++i)
+              {
+                for (unsigned int j = 0; j < stencil_side_cell_count; ++j)
+                  {
+                    strip_sums[n_sums_per_dim * 0 + i] += local_volume_of_fluids (stencil_side_cell_count * j + i);
+                    strip_sums[n_sums_per_dim * 1 + j] += local_volume_of_fluids (stencil_side_cell_count * j + i);
+                  }
+              }
+
+            // Calculate normal vectors for the 6 candidates from the efficient
+            // least squares approach
+            //
+            // Labeling the sums of the perpendicular strips as
+            // 0 1 2
+            // L C R
+            //
+            // For each dimension consider the interface normals implied by the
+            // 3 divided differences
+            //
+            // L-C/1
+            // C-R/2
+            // L-R/1
+            //
+            for (unsigned int di = 0; di < dim; ++di)
+              {
+                // Get index other dimension
+                unsigned int di2 = (di == 0) ? 1 : 0;
+                for (unsigned int i = 0; i < 3; ++i)
+                  {
+                    normals[n_candidate_normals_per_dim * di + i][di] = 0.0;
+                    normals[n_candidate_normals_per_dim * di + i][di2] = 0.0;
+                    if (i==0 || i == 2)
+                      {
+                        // Positive sum in difference is L
+                        normals[n_candidate_normals_per_dim * di + i][di] += strip_sums[n_sums_per_dim * di + 0];
+                        normals[3 * di + i][di2] += 1.0;
+                      }
+                    else
+                      {
+                        // Positive sum in difference is C
+                        normals[3 * di + i][di] += strip_sums[3 * di + 1];
+                        normals[3 * di + i][di2] += 0.0;
+                      }
+                    if (i == 0)
+                      {
+                        // Negative sum in difference is C
+                        normals[3 * di + i][di] -= strip_sums[3 * di + 1];
+                        normals[3 * di + i][di2] += 0.0;
+                      }
+                    else
+                      {
+                        // Negative sum in difference is R
+                        normals[3 * di + i][di] -= strip_sums[3 * di + 2];
+                        normals[3 * di + i][di2] += 1.0;
+                      }
+
+                    if (strip_sums[3 * di2 + 2] > strip_sums[3 * di2 + 0])
+                      {
+                        // There is more fluid in in area above the interface on the stencil,
+                        // so flip normal direction
+                        normals[3 * di + i][di2] *= -1.0;
+                      }
+                  }
+              }
+
+            // Add time extrapolated local normal as candidate
+            // this is not expected to be the best candidate in general, but
+            // should result in exact reconstruction for linear interface
+            // translations
+            // Inclusion of this candidate will not reduce accuracy due to it
+            // only being selected if it produces a better interface
+            // approximation than the ELS candidates. Note that this will
+            // render linear translation problems less dependent on the
+            // interface reconstruction, so other tests will also be necessary.
+            for (unsigned int i=0; i<dim; ++i)
+              normals[6][i] = solution(local_dof_indices[system_fe
+                                                         .component_to_system_index(volume_of_fluidN_c_index+i, 0)]);
+
+            // If candidate normal too small, remove from consideration
+            if (normals[6]*normals[6]< volume_fraction_threshold)
+              {
+                normals[6][0] = 0;
+                normals[6][1] = 0;
+              }
+
+            unsigned int index_of_best_normal = 0;
+            {
+              fevalues.reinit(cell);
+              const std::vector<double> weights = fevalues.get_JxW_values();
+
+              double cell_vol = 0.0;
+              for (const double weight : weights)
+                {
+                  cell_vol+=weight;
+                }
+              for (unsigned int nind = 0; nind < n_candidate_normals; ++nind)
+                {
+                  errs[nind] = 0.0;
+                  const double normal_norm = normals[nind].norm_square();
+
+                  if (normal_norm > volume_fraction_threshold) // If candidate normal too small set error to maximum
+                    {
+                      d_vals[nind] = VolumeOfFluid::Utilities::compute_interface_location_newton<dim> (
+                                       max_degree,
+                                       normals[nind],
+                                       cell_volume_of_fluid,
+                                       cell_vol,
+                                       volume_of_fluid_reconstruct_epsilon,
+                                       quadrature.get_points(), weights);
+                    }
+                  else
+                    {
+                      errs[nind] = 9.0;
+                    }
+                }
+            }
+
+            for (unsigned int i = 0; i < n_cells_local_stencil; ++i)
+              {
+                if (neighbor_cells[i] == endc)
+                  {
+                    continue;
+                  }
+
+                fevalues.reinit(neighbor_cells[i]);
+
+                const std::vector<double> weights = fevalues.get_JxW_values();
+
+                double cell_vol = 0.0;
+                for (const double weight : weights)
+                  {
+                    cell_vol+=weight;
+                  }
+
+                for (unsigned int nind = 0; nind < n_candidate_normals; ++nind)
+                  {
+                    const double normal_norm = normals[nind]*normals[nind];
+
+                    if (normal_norm > volume_fraction_threshold) // If candidate normal too small skip as set to max already
+                      {
+                        double dot = 0.0;
+                        for (unsigned int di = 0; di < dim; ++di)
+                          dot += normals[nind][di] * stencil_unit_cell_centers[i][di];
+                        const double n_volume_of_fluid = VolumeOfFluid::Utilities::compute_fluid_volume<dim> (max_degree, normals[nind], d_vals[nind]-dot,
+                                                         quadrature.get_points(), weights)/cell_vol;
+                        const double cell_err = local_volume_of_fluids (i) - n_volume_of_fluid;
+                        errs[nind] += cell_err * cell_err;
+                      }
+                  }
+              }
+
+            for (unsigned int nind = 0; nind < n_candidate_normals; ++nind)
+              {
+                if (errs[index_of_best_normal] >= errs[nind])
+                  index_of_best_normal = nind;
+              }
+
+            normal = normals[index_of_best_normal];
+            d = d_vals[index_of_best_normal];
+          }
+
+        for (unsigned int i=0; i<dim; ++i)
+          initial_solution (local_dof_indices[system_fe
+                                              .component_to_system_index(volume_of_fluidN_c_index+i, 0)]) = normal[i];
+
+        initial_solution (local_dof_indices[system_fe
+                                            .component_to_system_index(volume_of_fluidN_c_index+dim, 0)]) = d;
+
+        for (unsigned int i=0; i<n_volume_of_fluidLS_dofs; ++i)
+          {
+            // Recenter unit cell on origin
+            Tensor<1, dim, double> recentered_support_point = volume_of_fluidLS_var.fe->unit_support_point(i)-reconstruction_stencil_unit_cell_center;
+            initial_solution (local_dof_indices[system_fe
+                                                .component_to_system_index(volume_of_fluidLS_c_index, i)])
+              = d-recentered_support_point*normal;
+          }
+      }
+
+    initial_solution.compress(VectorOperation::insert);
+
+    sim.compute_current_constraints();
+    sim.current_constraints.distribute(initial_solution);
+
+    solution.block(volume_of_fluidN_blockidx) = initial_solution.block(volume_of_fluidN_blockidx);
+    solution.block(volume_of_fluidLS_blockidx) = initial_solution.block(volume_of_fluidLS_blockidx);
+  }
+
+
+  template <>
+  void VolumeOfFluidHandler<3>::update_volume_of_fluid_normals (const VolumeOfFluidField<3> &/*field*/,
+                                                                LinearAlgebra::BlockVector &/*solution*/)
+  {
+    Assert(false, ExcNotImplemented());
+  }
+
+  template <>
+  void VolumeOfFluidHandler<2>::update_volume_of_fluid_composition (const typename Simulator<2>::AdvectionField &composition_field,
+                                                                    const VolumeOfFluidField<2> &volume_of_fluid_field,
+                                                                    LinearAlgebra::BlockVector &solution)
+  {
+    const unsigned int dim = 2;
+
+    LinearAlgebra::BlockVector initial_solution;
+
+    TimerOutput::Scope timer (sim.computing_timer, "Compute VolumeOfFluid compositions");
+
+    initial_solution.reinit(sim.system_rhs, false);
+
+    // Normal holding vars
+    Point<dim> reconstruction_stencil_unit_cell_center;
+
+    for (unsigned int i=0; i<dim; ++i)
+      reconstruction_stencil_unit_cell_center[i] = 0.5;
+
+    const FiniteElement<dim> &system_fe = this->get_fe();
+
+    std::vector<types::global_dof_index> local_dof_indices (system_fe.dofs_per_cell);
+
+    const FEVariable<dim> &volume_of_fluid_var = volume_of_fluid_field.volume_fraction;
+    const unsigned int volume_of_fluid_c_index = volume_of_fluid_var.first_component_index;
+    const unsigned int volume_of_fluid_ind
+      = system_fe.component_to_system_index(volume_of_fluid_c_index, 0);
+
+    const FEVariable<dim> &volume_of_fluidN_var = volume_of_fluid_field.reconstruction;
+    const unsigned int volume_of_fluidN_c_index = volume_of_fluidN_var.first_component_index;
+
+    const unsigned int base_element = composition_field.base_element(this->introspection());
+    const std::vector<Point<dim>> support_points = system_fe.base_element(base_element).get_unit_support_points();
+
+    for (auto cell : this->get_dof_handler().active_cell_iterators ())
+      {
+        if (!cell->is_locally_owned())
+          continue;
+
+        cell->get_dof_indices (local_dof_indices);
+        const double cell_volume_of_fluid = solution(local_dof_indices[volume_of_fluid_ind]);
+
+        Tensor<1, dim, double> normal;
+
+        for (unsigned int i=0; i<dim; ++i)
+          normal[i] = solution(local_dof_indices[system_fe
+                                                 .component_to_system_index(volume_of_fluidN_c_index+i, 0)]);
+
+        // Compute L1 normalized normal vector
+        // (Use of L1 normalization makes calculating the correct correction
+        // factor much simpler to retain $0\leq C\leq 1$ bound much simpler)
+        double normal_l1_norm = 0.0;
+        for (unsigned int i=0; i<dim; ++i)
+          {
+            normal_l1_norm += std::abs(normal[i]);
+          }
+        //Calculate correct factor to retain vol frac and [0,1] bound
+        double correction_factor = (normal_l1_norm<volume_fraction_threshold)
+                                   ?
+                                   0.0
+                                   :
+                                   2.0*(0.5-abs(cell_volume_of_fluid-0.5))/normal_l1_norm;
+        for (unsigned int i=0; i<system_fe.base_element(base_element).dofs_per_cell; ++i)
+          {
+            const unsigned int system_local_dof
+              = system_fe.component_to_system_index(composition_field.component_index(sim.introspection),
+                                                    /*dof index within component*/i);
+
+            Tensor<1, dim, double> recentered_support_point = support_points[i]-reconstruction_stencil_unit_cell_center;
+
+            const double value = cell_volume_of_fluid - correction_factor*(recentered_support_point*normal);
+
+            initial_solution(local_dof_indices[system_local_dof]) = value;
+          }
+
+      }
+
+
+    const unsigned int blockidx = composition_field.block_index(this->introspection());
+    solution.block(blockidx) = initial_solution.block(blockidx);
+  }
+
+
+
+  template <>
+  void VolumeOfFluidHandler<3>::update_volume_of_fluid_composition (const Simulator<3>::AdvectionField &/*composition_field*/,
+                                                                    const VolumeOfFluidField<3> &/*volume_of_fluid_field*/,
+                                                                    LinearAlgebra::BlockVector &/*solution*/)
+  {
+    Assert(false, ExcNotImplemented());
+  }
+}
diff --git a/source/volume_of_fluid/setup_initial_conditions.cc.bak b/source/volume_of_fluid/setup_initial_conditions.cc.bak
new file mode 100644
index 00000000000..41209956832
--- /dev/null
+++ b/source/volume_of_fluid/setup_initial_conditions.cc.bak
@@ -0,0 +1,245 @@
+/*
+ Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file doc/COPYING.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/global.h>
+#include <aspect/simulator.h>
+#include <aspect/volume_of_fluid/handler.h>
+#include <aspect/volume_of_fluid/utilities.h>
+
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim>
+  void VolumeOfFluidHandler<dim>::set_initial_volume_fractions ()
+  {
+    for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
+      {
+
+        switch (initialization_data_type[f])
+          {
+            case VolumeOfFluid::VolumeOfFluidInputType::composition:
+              initialize_from_composition_field (data[f]);
+              break;
+            case VolumeOfFluid::VolumeOfFluidInputType::level_set:
+              initialize_from_level_set (data[f]);
+              break;
+            default:
+              Assert(false, ExcNotImplemented ());
+          }
+
+        const unsigned int volume_of_fluidN_blockidx = data[f].reconstruction.block_index;
+        const unsigned int volume_of_fluidLS_blockidx = data[f].level_set.block_index;
+        update_volume_of_fluid_normals (data[f], sim.solution);
+        sim.old_solution.block(volume_of_fluidN_blockidx) = sim.solution.block(volume_of_fluidN_blockidx);
+        sim.old_old_solution.block(volume_of_fluidN_blockidx) = sim.solution.block(volume_of_fluidN_blockidx);
+        sim.old_solution.block(volume_of_fluidLS_blockidx) = sim.solution.block(volume_of_fluidLS_blockidx);
+        sim.old_old_solution.block(volume_of_fluidLS_blockidx) = sim.solution.block(volume_of_fluidLS_blockidx);
+
+        // Update associated composition field
+        const typename Simulator<dim>::AdvectionField composition_field = Simulator<dim>::AdvectionField::composition(data[f].composition_index);
+        update_volume_of_fluid_composition (composition_field, data[f], sim.solution);
+        const unsigned int volume_of_fluid_C_blockidx = composition_field.block_index(this->introspection());
+        sim.old_solution.block(volume_of_fluid_C_blockidx) = sim.solution.block(volume_of_fluid_C_blockidx);
+        sim.old_old_solution.block(volume_of_fluid_C_blockidx) = sim.solution.block(volume_of_fluid_C_blockidx);
+      }
+  }
+
+  template <int dim>
+  void VolumeOfFluidHandler<dim>::initialize_from_composition_field (
+    const VolumeOfFluidField<dim> &field)
+  {
+    LinearAlgebra::BlockVector initial_solution;
+
+    initial_solution.reinit(sim.system_rhs, false);
+
+    const QIterated<dim> quadrature (QMidpoint<1>(), n_init_samples);
+    FEValues<dim, dim> fe_init (this->get_mapping(), this->get_fe(), quadrature,
+                                update_JxW_values | update_quadrature_points);
+
+    std::vector<types::global_dof_index>
+    local_dof_indices (this->get_fe().dofs_per_cell);
+
+    const FEVariable<dim> &volume_of_fluid_var = field.volume_fraction;
+    const unsigned int component_index = volume_of_fluid_var.first_component_index;
+    const unsigned int blockidx = volume_of_fluid_var.block_index;
+    const unsigned int volume_of_fluid_ind
+      = this->get_fe().component_to_system_index(component_index, 0);
+
+    // Initialize state based on provided function
+    for (auto cell : this->get_dof_handler().active_cell_iterators ())
+      {
+        if (!cell->is_locally_owned ())
+          continue;
+
+        // Calculate approximation for volume
+        cell->get_dof_indices (local_dof_indices);
+
+        fe_init.reinit (cell);
+
+        double volume_of_fluid_val = 0.0;
+        double cell_vol = 0.0;
+
+        for (unsigned int i = 0; i < fe_init.n_quadrature_points; ++i)
+          {
+            const double fraction_at_point = this->get_initial_composition_manager().initial_composition(fe_init.quadrature_point(i),
+                                             field.composition_index);
+            volume_of_fluid_val += fraction_at_point * fe_init.JxW (i);
+            cell_vol += fe_init.JxW(i);
+          }
+
+        volume_of_fluid_val /= cell_vol;
+
+        volume_of_fluid_val = std::min(volume_of_fluid_val, 1.0);
+        volume_of_fluid_val = std::max(volume_of_fluid_val, 0.0);
+
+        initial_solution (local_dof_indices[volume_of_fluid_ind]) = volume_of_fluid_val;
+      }
+
+    initial_solution.compress(VectorOperation::insert);
+
+    // Apply constraints and update solution blocks. This is duplicated from
+    // Simulator<dim>::set_initial_temperature_and_compositional_fields()
+    // in order to separate the volume of fluid algorithm as much as possible from
+    // the rest of the code.
+    sim.compute_current_constraints();
+    sim.current_constraints.distribute(initial_solution);
+
+    sim.solution.block(blockidx) = initial_solution.block(blockidx);
+    sim.old_solution.block(blockidx) = initial_solution.block(blockidx);
+    sim.old_old_solution.block(blockidx) = initial_solution.block(blockidx);
+  }
+
+  template <int dim>
+  void VolumeOfFluidHandler<dim>::initialize_from_level_set (
+    const VolumeOfFluidField<dim> &field)
+  {
+    LinearAlgebra::BlockVector initial_solution;
+
+    initial_solution.reinit(sim.system_rhs, false);
+
+    const QIterated<dim> quadrature (QMidpoint<1>(), n_init_samples);
+    FEValues<dim, dim> fe_init (this->get_mapping(),
+                                this->get_fe(),
+                                quadrature,
+                                update_JxW_values | update_quadrature_points);
+
+    const double h = 1.0/n_init_samples;
+
+    std::vector<types::global_dof_index>
+    local_dof_indices (this->get_fe().dofs_per_cell);
+
+    const FEVariable<dim> &volume_of_fluid_var = field.volume_fraction;
+    const unsigned int component_index = volume_of_fluid_var.first_component_index;
+    const unsigned int blockidx = volume_of_fluid_var.block_index;
+    const unsigned int volume_of_fluid_ind
+      = this->get_fe().component_to_system_index(component_index, 0);
+
+    // Initialize state based on provided function
+    for (auto cell : this->get_dof_handler().active_cell_iterators ())
+      {
+        if (!cell->is_locally_owned ())
+          continue;
+
+        // Calculate approximation for volume
+        cell->get_dof_indices (local_dof_indices);
+
+        const double cell_diam = cell->diameter();
+        const double d_func = this->get_initial_composition_manager().initial_composition(cell->barycenter(),
+                              field.composition_index);
+        fe_init.reinit (cell);
+
+        double volume_of_fluid_val = 0.0;
+        double cell_vol = 0.0;
+
+        if (d_func <=-0.5*cell_diam)
+          {
+            volume_of_fluid_val = 0.0;
+          }
+        else if (d_func >= 0.5*cell_diam)
+          {
+            volume_of_fluid_val = 1.0;
+          }
+        else
+          {
+
+            // For each quadrature point compute an approximation to the fluid fraction in the surrounding region
+            for (unsigned int i = 0; i < fe_init.n_quadrature_points; ++i)
+              {
+                double d = 0.0;
+                Tensor<1, dim, double> grad;
+                Point<dim> xU = quadrature.point (i);
+
+                // Get an approximation to local normal at the closest interface (level set gradient)
+                // and the distance to the closest interface (value of level set function)
+                for (unsigned int di = 0; di < dim; ++di)
+                  {
+                    Point<dim> xH, xL;
+                    xH = xU;
+                    xL = xU;
+                    xH[di] += 0.5*h;
+                    xL[di] -= 0.5*h;
+                    const double dH = this->get_initial_composition_manager().initial_composition(cell->intermediate_point(xH),
+                                                                                                  field.composition_index);
+                    const double dL = this->get_initial_composition_manager().initial_composition(cell->intermediate_point(xL),
+                                                                                                  field.composition_index);
+                    grad[di] = (dL-dH);
+                    d += (0.5/dim)*(dH+dL);
+                  }
+                // Use the basic fluid fraction formula to compute an approximation to the fluid fraction
+                const double fraction_at_point = VolumeOfFluid::Utilities::compute_fluid_fraction (grad, d);
+                volume_of_fluid_val += fraction_at_point * fe_init.JxW (i);
+                cell_vol += fe_init.JxW (i);
+              }
+            volume_of_fluid_val /= cell_vol;
+          }
+
+        initial_solution (local_dof_indices[volume_of_fluid_ind]) = volume_of_fluid_val;
+      }
+
+    initial_solution.compress(VectorOperation::insert);
+
+    // Apply constraints and update solution blocks. This is duplicated from
+    // Simulator<dim>::set_initial_temperature_and_compositional_fields()
+    // in order to separate the volume of fluid algorithm as much as possible from
+    // the rest of the code.
+    sim.compute_current_constraints();
+    sim.current_constraints.distribute(initial_solution);
+
+    sim.solution.block(blockidx) = initial_solution.block(blockidx);
+    sim.old_solution.block(blockidx) = initial_solution.block(blockidx);
+    sim.old_old_solution.block(blockidx) = initial_solution.block(blockidx);
+  }
+}
+
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template void VolumeOfFluidHandler<dim>::set_initial_volume_fractions ();\
+  template void VolumeOfFluidHandler<dim>::initialize_from_composition_field (const VolumeOfFluidField<dim> &field); \
+  template void VolumeOfFluidHandler<dim>::initialize_from_level_set (const VolumeOfFluidField<dim> &field);
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/volume_of_fluid/solver.cc.bak b/source/volume_of_fluid/solver.cc.bak
new file mode 100644
index 00000000000..283ce0d526f
--- /dev/null
+++ b/source/volume_of_fluid/solver.cc.bak
@@ -0,0 +1,106 @@
+/*
+ Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file doc/COPYING.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/global.h>
+#include <aspect/volume_of_fluid/handler.h>
+
+#include <deal.II/lac/affine_constraints.h>
+#include <deal.II/lac/trilinos_solver.h>
+
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  template <int dim>
+  void VolumeOfFluidHandler<dim>::solve_volume_of_fluid_system (const VolumeOfFluidField<dim> &field)
+  {
+    const unsigned int block_idx = field.volume_fraction.block_index;
+
+    TimerOutput::Scope timer (sim.computing_timer, "Solve volume of fluid system");
+    this->get_pcout() << "   Solving volume of fluid system... " << std::flush;
+
+    const double tolerance = std::max(1e-50,
+                                      volume_of_fluid_solver_tolerance*sim.system_rhs.block(block_idx).l2_norm());
+
+    SolverControl solver_control (1000, tolerance);
+
+    TrilinosWrappers::SolverCG solver(solver_control);
+    TrilinosWrappers::PreconditionJacobi precondition;
+    precondition.initialize(sim.system_matrix.block(block_idx, block_idx));
+
+    // Create distributed vector (we need all blocks here even though we only
+    // solve for the current block) because only have a AffineConstraints<double>
+    // for the whole system, current_linearization_point contains our initial guess.
+    LinearAlgebra::BlockVector distributed_solution (
+      this->introspection().index_sets.system_partitioning,
+      this->get_mpi_communicator());
+    distributed_solution.block(block_idx) = sim.current_linearization_point.block (block_idx);
+
+    sim.current_constraints.set_zero(distributed_solution);
+
+    // solve the linear system:
+    try
+      {
+        solver.solve (sim.system_matrix.block(block_idx,block_idx),
+                      distributed_solution.block(block_idx),
+                      sim.system_rhs.block(block_idx),
+                      precondition);
+      }
+    // if the solver fails, report the error from processor 0 with some additional
+    // information about its location, and throw a quiet exception on all other
+    // processors
+    catch (const std::exception &exc)
+      {
+        if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
+          {
+            AssertThrow (false,
+                         ExcMessage (std::string("The iterative advection solver "
+                                                 "did not converge. It reported the following error:\n\n")
+                                     +
+                                     exc.what()));
+          }
+        else
+          throw QuietException();
+      }
+
+    sim.current_constraints.distribute (distributed_solution);
+    sim.solution.block(block_idx) = distributed_solution.block(block_idx);
+
+    // print number of iterations and also record it in the
+    // statistics file
+    this->get_pcout() << solver_control.last_step()
+                      << " iterations." << std::endl;
+
+    // Do not add VolumeOfFluid solver iterations to statistics, duplication due to
+    // dimensional splitting results in incorrect line formatting (lines of
+    // data split inconsistently with missing values)
+  }
+}
+
+namespace aspect
+{
+#define INSTANTIATE(dim) \
+  template void VolumeOfFluidHandler<dim>::solve_volume_of_fluid_system (const VolumeOfFluidField<dim> &field);
+
+
+  ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+}
diff --git a/source/volume_of_fluid/utilities.cc.bak b/source/volume_of_fluid/utilities.cc.bak
new file mode 100644
index 00000000000..fe9cacefc70
--- /dev/null
+++ b/source/volume_of_fluid/utilities.cc.bak
@@ -0,0 +1,694 @@
+/*
+ Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
+
+ This file is part of ASPECT.
+
+ ASPECT is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ ASPECT is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with ASPECT; see the file doc/COPYING.  If not see
+ <http://www.gnu.org/licenses/>.
+ */
+
+#include <aspect/volume_of_fluid/utilities.h>
+
+namespace aspect
+{
+  namespace VolumeOfFluid
+  {
+    namespace Utilities
+    {
+      using namespace dealii;
+
+
+      double compute_fluid_fraction (const Tensor<1, 2> normal,
+                                     const double d)
+      {
+        const int dim = 2;
+
+        //Get 1-Norm
+        double norm1 = 0.0;
+        double max = 0.0;
+        for (unsigned int i = 0; i < dim; ++i)
+          {
+            const double normal_component = std::abs (normal[i]);
+            norm1 += normal_component;
+            max = (max < normal_component) ? normal_component : max;
+          }
+
+        //Obtain volume
+        if (d <= -0.5*norm1)
+          {
+            return 0.0;
+          }
+        if (d >= 0.5*norm1)
+          {
+            return 1.0;
+          }
+        const double dtest = d / norm1; // Threshold value for changes in computation behavior
+        // Normalized parameter indicating the "slope" (positive and finite)
+        // Chosen due to resulting in simple formulas
+        // Equal to the absolute value of the smaller vector entry in the 1-norm normalized normal vector
+        const double mpos = 1.0 - max/norm1;
+        if (dtest < mpos - 0.5)
+          {
+            return (dtest + 0.5) * (dtest + 0.5) / (2.0*mpos * (1.0 - mpos));
+          }
+        if (dtest > 0.5 - mpos)
+          {
+            return 1.0 - (dtest - 0.5) * (dtest - 0.5) / (2.0*mpos * (1.0 - mpos));
+          }
+        return 0.5 + dtest / (1.0 - mpos);
+      }
+
+
+
+      double compute_interface_location (const Tensor<1, 2> normal,
+                                         const double vol)
+      {
+        const int dim = 2;
+
+        //Get 1-Norm
+        double norm1 = 0.0;
+        double max = 0.0;
+        for (unsigned int i = 0; i < dim; ++i)
+          {
+            double normal_component = std::abs (normal[i]);
+            norm1 += normal_component;
+            max = (max < normal_component) ? normal_component : max;
+          }
+
+        // Normalized parameter indicating the "slope" (positive and finite)
+        // Chosen due to resulting in simple formulas
+        // Equal to the absolute value of the smaller vector entry in the 1-norm normalized normal vector
+        const double mpos = (norm1==0.0)?0.0:(1.0-max/norm1);
+        norm1 = (norm1==0.0)? 1.0:norm1;
+
+        // Obtain correct RHS term for interface position
+        if (vol <= 0.0)
+          {
+            return -0.5 * norm1;
+          }
+        else if (vol >= 1.0)
+          {
+            return 0.5 * norm1;
+          }
+        else if (vol < 0.5 * mpos / (1 - mpos))
+          {
+            return norm1 * (-0.5 + sqrt (2.0*vol * mpos * (1 - mpos)));
+          }
+        else if (vol > 1.0 - 0.5 * mpos / (1 - mpos))
+          {
+            return norm1 * (0.5 - sqrt (2.0*(1.0 - vol) * mpos * (1 - mpos)));
+          }
+        else
+          {
+            return norm1 * (1 - mpos) * (vol - 0.5);
+          }
+      }
+
+
+
+      double compute_fluid_fraction (const Tensor<1, 3> normal,
+                                     const double d)
+      {
+        // Calculations done by Scardovelli and Zaleski in
+        // doi:10.1006/jcph.2000.6567,
+        // modified to fit chosen convention on normal interface
+        const int dim = 3;
+
+        Tensor<1, 3> nnormal;
+        //Simplify calculation by reducing to case of d<=0
+        if (d>0.0)
+          {
+            return 1.0-compute_fluid_fraction(-normal, -d);
+          }
+
+        //Get 1-Norm
+        double norm1 = 0.0;
+        for (unsigned int i = 0; i < dim; ++i)
+          {
+            double term = std::abs(normal[i]);
+            norm1 += term;
+          }
+
+        //Return volume in simple cases
+        if (d <= -0.5*norm1)
+          {
+            return 0.0;
+          }
+        if (norm1 == 0.0)
+          {
+            // Case should never occur, return reasonable output for edge circumstance
+            return 0.5;
+          }
+        const double dtest = d / norm1;
+
+        // sort normalized values for normal into nnormal in ascending order of absolute value
+        double mprod = 1.0;
+        for (unsigned int i = 0; i < dim; ++i)
+          {
+            nnormal[i]=std::abs(normal[i])/norm1;
+            mprod *= nnormal[i];
+          }
+        for (unsigned int i =0; i < dim; ++i)
+          {
+            for (unsigned int j=i+1; j < dim; ++j)
+              {
+                if (nnormal[j]<nnormal[i])
+                  {
+                    //Swap
+                    const double tmp = nnormal[j];
+                    nnormal[j] = nnormal[i];
+                    nnormal[i] = tmp;
+                  }
+              }
+          }
+        const double m12 = nnormal[0]+nnormal[1];
+        const double mmin = (m12<nnormal[2])?m12:nnormal[2];
+        const double eps = 1e-10;
+        const double v1= (6.0*nnormal[1]*nnormal[2]>eps)
+                         ?
+                         nnormal[0]*nnormal[0]/(eps)
+                         :
+                         nnormal[0]*nnormal[0]/(6*nnormal[1]*nnormal[2]);
+
+        // do computation for standard cases
+        // Case 1 of Scardovelli and Zaleski (Tetrahedron)
+        if (dtest<nnormal[0]-0.5)
+          {
+            return (dtest+0.5)*(dtest+0.5)*(dtest+0.5)/(6*mprod);
+          }
+        // Case 2 of Scardovelli and Zaleski ("Triangular prism-like")
+        else if (dtest<nnormal[1]-0.5)
+          {
+            return (dtest+0.5)*(dtest+0.5-nnormal[0])/(2*nnormal[1]*nnormal[2])+v1;
+          }
+        // Case 3 of Scardovelli and Zaleski
+        else if (dtest<mmin-0.5)
+          {
+            return (dtest+0.5)*(dtest+0.5)*(3*m12-dtest-0.5)/(6*mprod) +
+                   nnormal[0]*nnormal[0]*(nnormal[0]-3*dtest-1.5)/(6*mprod) +
+                   nnormal[1]*nnormal[1]*(nnormal[1]-3*dtest-1.5)/(6*mprod);
+          }
+        // Case 4 of Scardovelli and Zaleski
+        else if ( nnormal[2]<m12)
+          {
+            return (dtest+0.5)*(dtest+0.5)*(3-2*dtest-1.0)/(6*mprod) +
+                   nnormal[0]*nnormal[0]*(nnormal[0]-3*dtest-1.5)/(6*mprod) +
+                   nnormal[1]*nnormal[1]*(nnormal[1]-3*dtest-1.5)/(6*mprod) +
+                   nnormal[2]*nnormal[2]*(nnormal[2]-3*dtest-1.5)/(6*mprod);
+          }
+
+        // Case 5 of Scardovelli and Zaleski
+        return 0.5*(2.0*dtest+1.0-m12)/nnormal[2];
+      }
+
+
+
+      double compute_interface_location (const Tensor<1, 3, double> normal,
+                                         const double vol)
+      {
+        // Calculations done by Scardovelli and Zaleski in
+        // doi:10.1006/jcph.2000.6567,
+        // modified to fit chosen convention on normal interface
+        const int dim = 3;
+        // Simplify to vol<0.5 case
+        if (vol>0.5)
+          {
+            return -compute_interface_location(-normal, 1.0-vol);
+          }
+
+        //Get 1-Norm
+        double norm1 = 0.0;
+        for (unsigned int i = 0; i < dim; ++i)
+          {
+            double term = std::abs(normal[i]);
+            norm1 += term;
+          }
+        const double eps = 1e-10;
+        double mprod = 1.0;
+        Tensor<1, 3> nnormal;
+        if (norm1<eps)
+          {
+            nnormal[0] = 0.0;
+            nnormal[1] = 0.0;
+            nnormal[2] = 1.0;
+            norm1 = 1.0;
+            mprod =0.0;
+          }
+        else
+          {
+            // sort normalized values for normal into nnormal in ascending order of absolute value
+            for (unsigned int i = 0; i < dim; ++i)
+              {
+                nnormal[i]=std::abs(normal[i])/norm1;
+                mprod *= nnormal[i];
+              }
+            for (unsigned int i =0; i < dim; ++i)
+              {
+                for (unsigned int j=i+1; j < dim; ++j)
+                  {
+                    if (nnormal[j]<nnormal[i])
+                      {
+                        //Swap
+                        const double tmp = nnormal[j];
+                        nnormal[j] = nnormal[i];
+                        nnormal[i] = tmp;
+                      }
+                  }
+              }
+          }
+        //Simple cases
+        if (vol<=0.0)
+          {
+            return -0.5*norm1;
+          }
+
+        const double m1 = nnormal[0];
+        const double m2 = nnormal[1];
+        const double m3 = nnormal[2];
+        const double m12 = m1+m2;
+
+        // Case 1 of Scardovelli and Zaleski
+        const double v1=(6.0*m2*m3>eps)
+                        ?
+                        m1*m1/(eps)
+                        :
+                        m1*m1/(6*m2*m3);
+
+        if (vol<v1)
+          {
+            return -0.5+std::pow(6*mprod*vol, 1./3.);
+          }
+
+        // Case 2 of Scardovelli and Zaleski
+        const double v2 = v1 + 0.5*(m2-m1)/m3;
+        if (vol<v2)
+          {
+            return 0.5*(-1+m1+sqrt(m1*m1+8*m2*m3*(vol-v1)));
+          }
+
+        // Case 3 of Scardovelli and Zaleski
+        double v3 = (m12<m3)
+                    ?
+                    m3*m3*(3*m12-m3)/(6.0*mprod)
+                    + m1*m1*(m1-3*m3)/(6*mprod)
+                    + m2*m2*(m2-3*m3)/(6*mprod)
+                    :
+                    0.5*m12/m3;
+
+        if (vol<v3)
+          {
+            // Solve appropriate cubic
+            const double a2 = -3.0*m12;
+            const double a1 = 3.0*(m1*m1+m2*m2);
+            const double a0 = 6*mprod*vol-m1*m1*m1-m2*m2*m2;
+            const double np0 = a2*a2/9.0-a1/3.0;
+            const double q0 = (a1*a2-3.0*a0)/6.0-a2*a2*a2/27.0;
+            const double theta = acos(q0/sqrt(np0*np0*np0))/3.0;
+            return sqrt(np0)*(sqrt(3.0)*sin(theta)-cos(theta))-a2/3.0;
+          }
+
+        // Case 4
+        if (m3<m12)
+          {
+            // Solve appropriate cubic
+            double a2 = -1.5;
+            double a1 = 1.5*(m1*m1+m2*m2+m3*m3);
+            double a0 = 6*mprod*vol-m1*m1*m1-m2*m2*m2-m3*m3*m3;
+            double np0 = a2*a2/9.0-a1/3.0;
+            double q0 = (a1*a2-3.0*a0)/6.0-a2*a2*a2/27.0;
+            double theta = acos(q0/sqrt(np0*np0*np0))/3.0;
+            return sqrt(np0)*(sqrt(3.0)*sin(theta)-cos(theta))-a2/3.0;
+          }
+
+        return -0.5+m1*vol+0.5*m12;
+      }
+
+
+
+      void xFEM_Heaviside(const unsigned int degree,
+                          const Tensor<1, 2> normal,
+                          const double d,
+                          const std::vector<Point<2>> &points,
+                          std::vector<double> &values)
+      {
+        const int basis_count=4;
+        std::vector<double> coeffs(basis_count);
+
+        const double n_xp = fabs(normal[0]), n_yp = fabs(normal[1]);
+        const double sign_n_x = (((normal[0]) > 0) - ((normal[0]) < 0)),
+                     sign_n_y = (((normal[1]) > 0) - ((normal[1]) < 0));
+
+        const double norm1 = n_xp + n_yp;
+        const double triangle_break = 0.5*fabs(n_xp-n_yp);
+
+        const unsigned int max_degree = 1;
+
+        AssertThrow(degree<=max_degree,
+                    ExcMessage("Cannot generate xFEM polynomials. Only implemented for degrees<2."));
+
+        // The formulas below calculate the correct coefficients for a given
+        // basis in order to form a polynomial $f$ which will satisfy $\int
+        // fpdx=\int pH(d-n\cdot x)dx$ for all polynomials $p$ less than or
+        // equal to the given degree
+        //
+        // The functions for the correct values were calculated and exported using sympy
+        if (d<-0.5*norm1)
+          {
+            for (unsigned int i =0; i < basis_count; ++i)
+              coeffs[i] = 0.0;
+          }
+        else if (d>0.5*norm1)
+          {
+            // Full cell
+            coeffs[0] = 1.0;
+            for (unsigned int i =1; i < basis_count; ++i)
+              coeffs[i] = 0.0;
+          }
+        else if (norm1< 1e-7)
+          {
+            coeffs[0] = 0.5;
+            for (unsigned int i =1; i < basis_count; ++i)
+              coeffs[i] = 0.0;
+          }
+        else if (d<=-triangle_break)
+          {
+            //Triangle
+            const double d_n = d + 0.5*norm1;
+            coeffs[0]=0.5*d_n*d_n/(n_xp*n_yp); // 1
+            coeffs[1]=d_n*d_n*(d_n - 1.5*n_yp)/(n_xp*n_yp*n_yp)*sign_n_y; // 2*y - 1
+            coeffs[2]=d_n*d_n*(d_n - 1.5*n_xp)/(n_xp*n_xp*n_yp)*sign_n_x; // 2*x - 1
+            coeffs[3]=1.5*d_n*d_n*(d_n*d_n - 2.0*d_n*n_xp - 2.0*d_n*n_yp + 3.0*n_xp*n_yp)/
+                      (n_xp*n_xp*n_yp*n_yp)*sign_n_x*sign_n_y; // (2*x - 1)*(2*y - 1)
+          }
+        else if (d<triangle_break && n_xp<n_yp)
+          {
+            //Trapezoid X
+            coeffs[0]=(d + 0.5*n_yp)/n_yp; // 1
+            coeffs[1]=0.25*(12.0*d*d + n_xp*n_xp - 3.0*n_yp*n_yp)/(n_yp*n_yp)*sign_n_y; // 2*y - 1
+            coeffs[2]=-0.5*n_xp/n_yp*sign_n_x; // 2*x - 1
+            coeffs[3]=-3.0*d*n_xp/(n_yp*n_yp)*sign_n_x*sign_n_y; // (2*x - 1)*(2*y - 1)
+          }
+        else if (d<triangle_break && n_yp<n_xp)
+          {
+            //Trapezoid Y
+            coeffs[0]=(d + 0.5*n_xp)/n_xp; // 1
+            coeffs[1]=-0.5*n_yp/n_xp*sign_n_y; // 2*y - 1
+            coeffs[2]=0.25*(12.0*pow(d, 2) - 3.0*n_xp*n_xp + n_yp*n_yp)/(n_xp*n_xp)*sign_n_x; // 2*x - 1
+            coeffs[3]=-3.0*d*n_yp/(n_xp*n_xp)*sign_n_x*sign_n_y; // (2*x - 1)*(2*y - 1)
+          }
+        else
+          {
+            //ITriangle
+            const double d_nn = 0.5*norm1-d;
+            coeffs[0]=1.0L-0.5L*d_nn*d_nn/(n_xp*n_yp); // 1
+            coeffs[1]=0.5L*(d_nn*d_nn)*sign_n_y*(2*d_nn - 3*n_yp)/(n_xp*(n_yp*n_yp)); // 2*y - 1
+            coeffs[2]=0.5L*(d_nn*d_nn)*sign_n_x*(2*d_nn - 3*n_xp)/((n_xp*n_xp)*n_yp); // 2*x - 1
+            coeffs[3]=1.5L*(d_nn*d_nn)*sign_n_x*sign_n_y*(-(d_nn*d_nn) + 2*d_nn*n_xp + 2*d_nn*n_yp - 3*n_xp*n_yp)/((n_xp*n_xp)*(n_yp*n_yp)); // (2*x - 1)*(2*y - 1)
+          }
+
+        // Calculate the correct values at the provided quadrature points by
+        // multiplying coefficients by the basis polynomials.
+        for (unsigned int i = 0; i<points.size(); ++i)
+          {
+            const Point<2> point = points[i];
+            const double x = point[0], y = point[1];
+            values[i] = coeffs[0];
+            if (degree>=1)
+              {
+                values[i] += coeffs[1]*(2.0*y-1.0) +
+                             coeffs[2]*(2.0*x-1.0) +
+                             coeffs[3]*(2.0*x - 1)*(2.0*y - 1.0);
+              }
+          }
+      }
+
+
+
+      void xFEM_Heaviside(const unsigned int /*degree*/,
+                          const Tensor<1, 3> /*normal*/,
+                          const double /*d*/,
+                          const std::vector<Point<3>> &/*points*/,
+                          std::vector<double> &/*values*/)
+      {
+        AssertThrow(false, ExcNotImplemented());
+      }
+
+
+
+      void xFEM_Heaviside_derivative_d(const unsigned int degree,
+                                       const Tensor<1, 2> normal,
+                                       const double d,
+                                       const std::vector<Point<2>> &points,
+                                       std::vector<double> &values)
+      {
+        const int basis_count=4;
+        std::vector<double> coeffs(basis_count);
+
+        const double n_xp = fabs(normal[0]), n_yp = fabs(normal[1]);
+        const double sign_n_x = (((normal[0]) > 0) - ((normal[0]) < 0)),
+                     sign_n_y = (((normal[1]) > 0) - ((normal[1]) < 0));
+
+        const double norm1 = n_xp + n_yp;
+        const double triangle_break = 0.5L*fabs(n_xp-n_yp);
+
+        const int max_degree = 1;
+
+        AssertThrow(degree<=max_degree,
+                    ExcMessage("Cannot generate xFEM polynomials are only functional for degrees<2."));
+
+
+        // The formulas below calculate the correct coefficients for a given
+        // basis in order to form a polynomial $f$ which will satisfy $\int
+        // fpdx=\int pH(d-n\cdot x)dx$ for all polynomials $p$ less than or
+        // equal to the given degree
+        //
+        // The functions for the correct values were calculated and exported using sympy
+        if (d<-0.5*norm1)
+          {
+            for (int i =0; i < basis_count; ++i)
+              coeffs[i] = 0.0;
+          }
+        else if (d>0.5*norm1)
+          {
+            // Full cell
+            for (int i =0; i < basis_count; ++i)
+              coeffs[i] = 0.0;
+          }
+        else if (norm1<1e-7)
+          {
+            for (int i =0; i < basis_count; ++i)
+              coeffs[i] = 0.0;
+          }
+        else if (d<=-triangle_break)
+          {
+            //D Triangle
+            const double d_n = d + 0.5*norm1;
+            coeffs[0]=d_n/(n_xp*n_yp); // 1
+            coeffs[1]=3*d_n*sign_n_y*(d_n - n_yp)/(n_xp*(n_yp*n_yp)); // 2*y - 1
+            coeffs[2]=3*d_n*sign_n_x*(d_n - n_xp)/((n_xp*n_xp)*n_yp); // 2*x - 1
+            coeffs[3]=3*d_n*sign_n_x*sign_n_y*(2*(d_n*d_n) - 3*d_n*n_xp - 3*d_n*n_yp + 3*n_xp*n_yp)/((n_xp*n_xp)*(n_yp*n_yp)); // (2*x - 1)*(2*y - 1)
+          }
+        else if (d<triangle_break && n_xp<n_yp)
+          {
+            //D Trapezoid X
+            coeffs[0]=1.0/n_yp; // 1
+            coeffs[1]=6*d*sign_n_y/(n_yp*n_yp); // 2*y - 1
+            coeffs[2]=0; // 2*x - 1
+            coeffs[3]=-3*n_xp*sign_n_x*sign_n_y/(n_yp*n_yp); // (2*x - 1)*(2*y - 1)
+          }
+        else if (d<triangle_break && n_yp<n_xp)
+          {
+            //D Trapezoid Y
+            coeffs[0]=1.0/n_xp; // 1
+            coeffs[1]=0; // 2*y - 1
+            coeffs[2]=6*d*sign_n_x/(n_xp*n_xp); // 2*x - 1
+            coeffs[3]=-3*n_yp*sign_n_x*sign_n_y/(n_xp*n_xp); // (2*x - 1)*(2*y - 1)
+          }
+        else
+          {
+            //D ITriangle
+            const double d_nn = 0.5*norm1-d;
+            coeffs[0]=d_nn/(n_xp*n_yp); // 1
+            coeffs[1]=3*d_nn*sign_n_y*(-d_nn + n_yp)/(n_xp*(n_yp*n_yp)); // 2*y - 1
+            coeffs[2]=3*d_nn*sign_n_x*(-d_nn + n_xp)/((n_xp*n_xp)*n_yp); // 2*x - 1
+            coeffs[3]=3*d_nn*sign_n_x*sign_n_y*(2*(d_nn*d_nn) - 3*d_nn*n_xp - 3*d_nn*n_yp + 3*n_xp*n_yp)/((n_xp*n_xp)*(n_yp*n_yp)); // (2*x - 1)*(2*y - 1)
+          }
+
+
+        // Calculate the correct values at the provided quadrature points by
+        // multiplying coefficients by the basis polynomials.
+        for (unsigned int i = 0; i<points.size(); ++i)
+          {
+            const Point<2> point = points[i];
+            const double x = point[0], y = point[1];
+            values[i] = coeffs[0];
+            if (degree>=1)
+              {
+                values[i] += coeffs[1]*(2*y-1.0) +
+                             coeffs[2]*(2*x-1.0) +
+                             coeffs[3]*(2*x - 1)*(2*y - 1);
+              }
+          }
+      }
+
+
+
+      void xFEM_Heaviside_derivative_d(const unsigned int /*degree*/,
+                                       const Tensor<1, 3> /*normal*/,
+                                       const double /*d*/,
+                                       const std::vector<Point<3>> &/*points*/,
+                                       std::vector<double> &/*values*/)
+      {
+        AssertThrow(false, ExcNotImplemented());
+      }
+
+
+
+      template <int dim>
+      double compute_interface_location_newton(const unsigned int degree,
+                                               const Tensor<1, dim> normal,
+                                               const double volume_fraction,
+                                               const double vol,
+                                               const double epsilon,
+                                               const std::vector<Point<dim>> &points,
+                                               const std::vector<double> &weights)
+      {
+        double norm1=0.0;
+        for (int i=0; i<dim; ++i)
+          norm1+=fabs(normal[i]);
+        double d_l=-0.5L*norm1, d_h=0.5L*norm1;
+        double f_l=0.0, f_h=1.0;
+        double d_guess= d_l + (volume_fraction-f_l)*(d_h-d_l)/(f_h-f_l);
+
+        std::vector<double> f_values(points.size());
+        std::vector<double> df_values(points.size());
+
+        for (int iter=0; iter<40; ++iter)
+          {
+            xFEM_Heaviside(degree, normal, d_guess, points, f_values);
+            xFEM_Heaviside_derivative_d(degree, normal, d_guess, points, df_values);
+
+            double f_guess=0.0;
+            double df_guess=0.0;
+            for (unsigned int i=0; i<points.size(); ++i)
+              {
+                const double factor = weights[i]/vol;
+                f_guess  += f_values[i]*factor;
+                df_guess += df_values[i]*factor;
+              }
+
+            // Break if within tolerance
+            if (fabs(f_guess-volume_fraction)<epsilon)
+              {
+                break;
+              }
+
+            if (volume_fraction<f_guess)
+              {
+                d_h = d_guess;
+                f_h = f_guess;
+              }
+            else
+              {
+                d_l = d_guess;
+                f_l = f_guess;
+              }
+
+            if (fabs(df_guess)<epsilon)
+              {
+                d_guess = (volume_fraction-f_l)/(f_h-f_l)*(d_h-d_l);
+              }
+            else
+              {
+                d_guess += (volume_fraction-f_guess)/(df_guess);
+
+                if (d_guess < d_l || d_guess > d_h)
+                  {
+                    d_guess = d_l + (volume_fraction-f_l)*(d_h-d_l)/(f_h-f_l);
+                  }
+              }
+          }
+
+        return d_guess;
+      }
+
+      template <int dim>
+      double compute_fluid_volume(const unsigned int degree,
+                                  const Tensor<1, dim> normal,
+                                  const double d,
+                                  const std::vector<Point<dim>> &points,
+                                  const std::vector<double> &weights)
+      {
+        std::vector<double> f_values(points.size());
+
+        xFEM_Heaviside(degree, normal, d, points, f_values);
+
+        double fluid_volume=0.0;
+        for (unsigned int i=0; i<points.size(); ++i)
+          fluid_volume += f_values[i]*weights[i];
+
+        return fluid_volume;
+      }
+
+      template <int dim>
+      double calculate_volume_flux(const unsigned int dir,
+                                   const double time_direction_derivative,
+                                   const Tensor<1, dim> normal,
+                                   const double d_face)
+      {
+        Tensor<1, dim> i_normal;
+        double i_d;
+
+        // Get d value at center of "aperture" (cell face cross timestep)
+        i_d = d_face+0.5*time_direction_derivative;
+        // Get normal vector on "aperture" by replacing the appropriate component with the time_direction_derivative
+        i_normal = normal;
+        i_normal[dir] = time_direction_derivative;
+
+        return compute_fluid_fraction (i_normal, i_d);
+      }
+    }
+  }
+}
+
+namespace aspect
+{
+  namespace VolumeOfFluid
+  {
+    namespace Utilities
+    {
+#define INSTANTIATE(dim) \
+  template double calculate_volume_flux<dim>(const unsigned int dir, \
+                                             const double time_direction_derivative, \
+                                             const Tensor<1, dim> normal, \
+                                             const double d); \
+  template double compute_interface_location_newton<dim>(const unsigned int degree, \
+                                                         const Tensor<1, dim> normal, \
+                                                         const double volume_fraction, \
+                                                         const double vol, \
+                                                         const double epsilon, \
+                                                         const std::vector<Point<dim>> &points, \
+                                                         const std::vector<double> &weights); \
+  template double compute_fluid_volume<dim>(const unsigned int degree, \
+                                            const Tensor<1, dim> normal,\
+                                            const double d,\
+                                            const std::vector<Point<dim>> &points,\
+                                            const std::vector<double> &weights);
+
+      ASPECT_INSTANTIATE(INSTANTIATE)
+
+#undef INSTANTIATE
+    }
+  }
+}
diff --git a/tests/2d_annulus_pyvista_cookbook.prm.bak b/tests/2d_annulus_pyvista_cookbook.prm.bak
new file mode 100644
index 00000000000..973d6157e82
--- /dev/null
+++ b/tests/2d_annulus_pyvista_cookbook.prm.bak
@@ -0,0 +1,90 @@
+# This setup is a copy of
+# cookbook/onset-of-convection/onset-of-convection.prm
+# with the difference that the geometry is a 2D cylindrical
+# annulus and the initial and boundary temperatures
+# are reduced to generate a lower Rayleigh number system.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Output directory                       = 2d_annulus_pyvista_cookbook
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use conduction timestep                = true
+
+subsection Termination criteria
+  set Termination criteria                 = end step
+  set End step                             = 0
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Outer radius = 6371000
+    set Inner radius = 3481000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r,phi
+    set Function expression = 1600 + 10*sin(2*phi)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2000
+    set Outer temperature = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 4000
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity                     = 1e23
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set Time steps between graphical output = 5
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/ISA_rotation_timescale.prm.bak b/tests/ISA_rotation_timescale.prm.bak
new file mode 100644
index 00000000000..6fa1a19b239
--- /dev/null
+++ b/tests/ISA_rotation_timescale.prm.bak
@@ -0,0 +1,102 @@
+# 2D model for half of a mid-ocean ridge
+# for testing the ISA rotation timescale postprocessor
+# based on the mid-ocean ridge cookbook, with a few simplifications
+
+set Dimension = 2
+set End time = 5e5
+set Adiabatic surface temperature = 1570
+
+# geometry
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 105000
+    set Y extent  = 70000
+    set X repetitions  = 3
+    set Y repetitions  = 2
+  end
+end
+
+# gravity
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# boundary velocity
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function
+  set Tangential velocity boundary indicators = left
+
+  subsection Function
+    set Function constants  = u0=0.05, x0=10000, xc=52500
+    set Variable names  = x,z
+    set Function expression  = if(x<x0,(1-(x/x0-1)*(x/x0-1))*u0,u0); 0
+  end
+end
+
+# boundary traction
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Representative point  = 105000, 7000
+  end
+end
+
+# initial temperature
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer  = 1e8
+    set Age bottom boundary layer  = 1e5
+    set Amplitude      = 0
+  end
+end
+
+# boundary temperature
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 293
+    set Bottom temperature = 1570
+  end
+end
+
+# material
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 4.7
+    set Reference density = 3400
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity = 5e21
+    set Thermal viscosity exponent = 7
+    set Reference temperature = 1570
+  end
+end
+
+# mesh refinement
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# postprocessing
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables = ISA rotation timescale
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/Picard_compressible.prm.bak b/tests/Picard_compressible.prm.bak
new file mode 100644
index 00000000000..cdd244f61ea
--- /dev/null
+++ b/tests/Picard_compressible.prm.bak
@@ -0,0 +1,249 @@
+#### This is a compressible whole Earth model solved by the
+#### single Advection, iterated Stokes. This represent a coarse
+#### version of a production type setup.
+#### Global parameters
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 150
+set Max nonlinear iterations in pre-refinement = 0
+set Pressure normalization                 = surface
+set Maximum time step                      = 1e6
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 0.5
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set GMRES solver restart length = 250
+    set Linear solver tolerance             = 1e-5
+    set Maximum number of expensive Stokes solver steps = 1000
+    set Number of cheap Stokes solver steps    = 200
+  end
+end
+
+#### Model Geometry
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3485e3
+    set Outer radius  = 6371e3 #5961e3
+    set Opening angle = 360
+  end
+end
+
+#### Mesh refinement
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Variable names      = depth,t
+    set Coordinate system = depth
+    set Function expression = if(depth<=200e3, 5,if(depth<=620e3, 5,if(depth<=680e3,5,if(depth>=2586e3,5,5))))
+
+    #if(depth<560e3,0,if(depth>760e3,0,6))
+    #        if(depth<560e3,5,if(depth>760e3,5,6))
+  end
+end
+
+##### Set temperature Model
+subsection Boundary temperature model
+  #set Allow fixed temperature on outflow boundaries = true  # default
+  set Fixed temperature boundary indicators         = bottom, top
+
+  #  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 273 #273 for surface ############
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators       = inner, outer
+
+  # set Zero velocity boundary indicators             = outer
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+# Number and names of compositional fields
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = plastic_strain #add strain field
+end
+
+#### Temperature model
+subsection Initial temperature model
+  #set Model name = adiabatic
+  set List of model names =  adiabatic, function
+  set List of model operators = add
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 100.e6
+    set Age top boundary layer = 100.e6
+    set Radius = 0
+    set Amplitude = 0
+    set Position = center
+    set Subadiabaticity = 0
+  end
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names      = x,y,z
+    set Function constants  = R=6371.e3
+    set Function expression = \
+                               if(sqrt(x*x+y*y)<=R<100e3, rand_seed(1) * 100 -50 , 0)
+  end
+end
+
+subsection Adiabatic conditions model # need to initialize for initial adiabatic temp.
+  #send
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_isentrope.txt
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating, radioactive decay
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+
+  subsection Radioactive decay
+    set Crust defined by composition = false
+    set Crust depth = 10e3
+    set Half decay times = 4.468e9, 0.704e9, 14e9, 1.248e9
+    set Heating rates = 9.4946e-5, 5.68e-4, 2.6368e-5, 2.8761e-5
+    set Initial concentrations crust = 0.0, 0.0, 0.0, 0.0
+    set Initial concentrations mantle = 0.0082, 0.000059, 0.024, 0.013
+    set Number of elements = 4
+  end
+
+  #set List of model names = compositional heating
+end
+
+############################ MATERIAL MODEL ######################################################################
+
+subsection Material model
+  set Model name = compositing #visco plastic #melt simple
+  set Material averaging = harmonic average
+
+  ############################ MATERIAL MODEL ######################################################################
+  subsection Compositing
+    set Viscosity = visco plastic
+    set Density = ascii reference profile
+    set Thermal expansion coefficient = ascii reference profile
+    set Specific heat = ascii reference profile
+    set Thermal conductivity = visco plastic
+    set Compressibility = ascii reference profile
+    set Entropy derivative pressure = ascii reference profile
+    set Entropy derivative temperature = ascii reference profile
+    set Reaction terms = visco plastic
+  end
+
+  subsection Ascii reference profile
+    set Thermal conductivity =  3.0
+
+    subsection Ascii data model
+      set Data file name = example_isentrope.txt
+      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    end
+  end
+
+  subsection Visco Plastic
+    set Define transition by depth instead of pressure  = true
+    set Phase transition Clapeyron slopes = background: 3.0e6|-2.5e6|9.e6
+    set Phase transition depths           = background: 410e3|660e3|2740e3
+    set Phase transition widths           = background: 12e3|23e3|11e3
+    set Phase transition temperatures     = background: 1770|1852|2591
+
+    # Reference temperature and viscosity
+    set Reference temperature = 293
+
+    # The minimum strain-rate helps limit large viscosities values that arise
+    # as the strain-rate approaches zero.
+    # The reference strain-rate is used on the first non-linear iteration
+    # of the first time step when the velocity has not been determined yet.
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+
+    # Limit the viscosity with minimum and maximum values
+    set Minimum viscosity = 1e20
+    set Maximum viscosity = 1e26
+
+    # Harmonic viscosity averaging
+    set Viscosity averaging scheme = harmonic
+
+    # Choose to have the viscosity (pre-yield) follow a dislocation
+    # diffusion or composite flow law.  Here, dislocation is selected
+    # so no need to specify diffusion creep parameters below, which are
+    # only used if "diffusion" or "composite" option is selected.
+    set Viscous flow law = diffusion
+
+    #  from cizkov
+    #     order:                           background    ,        mantle_low        ,        mantle_up
+    #    set Thermal diffusivities =   8.384146341463415e-07,     8.384146341463415e-07   , 7.309941520467837e-07
+
+    set Thermal diffusivities = 1.e-6
+    set Thermal expansivities = background: 3.e-5|2.e-5|2.e-5|2.e-5, plastic_strain: 3.e-5
+    set Heat capacities       =        1250     # specific heat
+    set Densities             = background: 3416|3800|4750|4750, plastic_strain: 3416
+    set Prefactors for dislocation creep          = background: 1e-22|1e-22|1e-30|1e-30, plastic_strain:1e-22
+    set Stress exponents for dislocation creep    = 3.5
+    set Activation energies for dislocation creep = background: 4.8e5|4.8e5|4.8e5|4.8e5, plastic_strain:4.8e5
+    set Activation volumes for dislocation creep  = background: 11.e-6|11.e-6|11.e-6|11.e-6, plastic_strain: 11.e-6
+    set Prefactors for diffusion creep            = background: 1.e-9|1.e-9|1.0e-16|1.0e-16, plastic_strain: 1.e-9
+    set Stress exponents for diffusion creep      = 1.0                                                  #### doesnt exist anymore??? ####
+    set Activation energies for diffusion creep   = background: 3.35e5|3.35e5|2.e5|2.e5, plastic_strain: 3.35e5
+    set Activation volumes for diffusion creep    = background: 4.8e-6|4.8e-6|1.1e-6|1.1e-6, plastic_strain: 4.8e-6
+    set Grain size                                = 1 #1e-3
+    set Grain size exponents for diffusion creep  = 0   #default
+
+    ###    # Plasticity parameters
+    set Angles of internal friction = background: 0|0|0|0, plastic_strain:0            # Angle Mohr
+    set Cohesions                   = background: 40e6|1e20|1e20|1e20, plastic_strain:40e6
+    set Strain weakening mechanism = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals = 1.e30
+    set Cohesion strain weakening factors = 1
+    set Friction strain weakening factors = 1
+    set End plasticity strain weakening intervals = 2.e30
+  end
+end
+
+#######################
+# Gravity model
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
+
+#######################
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, \
+                               composition statistics, depth average, heat flux statistics
+
+  subsection Depth average
+    set Number of zones = 3
+    set Output format = txt
+    set Time between graphical output = 1e7
+    set Depth boundaries of zones = 0, 10000,150000,2900000
+  end
+end
diff --git a/tests/additional_outputs_02.cc.bak b/tests/additional_outputs_02.cc.bak
new file mode 100644
index 00000000000..8323fb2e583
--- /dev/null
+++ b/tests/additional_outputs_02.cc.bak
@@ -0,0 +1,171 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+#include <aspect/simulator/assemblers/interface.h>
+
+#include <iostream>
+
+unsigned int counter_without = 0, counter_with = 0;
+bool quiet = true;
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+    template <int dim>
+    class AdditionalOutputs1 : public AdditionalMaterialOutputs<dim>
+    {
+      public:
+        AdditionalOutputs1 (const unsigned int n_points)
+        {
+          additional_material_output1.resize(n_points);
+        }
+
+        std::vector<double> additional_material_output1;
+    };
+
+
+    template <int dim>
+    class Material1 : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const
+        {
+          MaterialModel::Simple<dim>::evaluate(in, out);
+
+          AdditionalOutputs1<dim> *additional;
+
+          additional = out.template get_additional_output<AdditionalOutputs1<dim>>();
+          if (additional)
+            ++counter_with;
+          else
+            ++counter_without;
+
+          if (additional)
+            additional->additional_material_output1[0] = 42.0;
+
+          if (quiet)
+            return;
+
+          if (additional)
+            std::cout << "* evaluate called with additional outputs!" << std::endl;
+          else
+            std::cout << "* evaluate called without additional outputs!" << std::endl;
+
+        }
+
+
+    };
+
+  }
+
+
+  template <int dim>
+  class TestAssembler :
+    public aspect::Assemblers::Interface<dim>
+  {
+    public:
+
+      virtual void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+        std::cout << "* create_additional_material_model_outputs() called" << std::endl;
+
+        if (out.template get_additional_output<MaterialModel::AdditionalOutputs1<dim>>() != nullptr)
+          return;
+
+        std::cout << "   creating additional output!" << std::endl;
+        out.additional_outputs.push_back(std::make_unique<MaterialModel::AdditionalOutputs1<dim>> (1));
+
+      }
+
+      virtual void execute(internal::Assembly::Scratch::ScratchBase<dim>        &scratch_base,
+                           internal::Assembly::CopyData::CopyDataBase<dim>       &/*data_base*/) const
+      {
+        internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+
+        MaterialModel::AdditionalOutputs1<dim> *additional
+          = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalOutputs1<dim>>();
+
+        std::cout << "* local_assemble_stokes call, have additional? " << (additional!=nullptr) << std::endl;
+        if (additional!=nullptr)
+          std::cout << "   value = " << additional->additional_material_output1[0] << std::endl;
+
+
+      }
+
+
+  };
+
+
+  template <int dim>
+  void set_assemblers1(const SimulatorAccess<dim> &,
+                       Assemblers::Manager<dim> &assemblers)
+  {
+    std::cout << "* set_assemblers()" << std::endl;
+
+    std::cout << "called without: " << counter_without << " with: " << counter_with << std::endl;
+    counter_without = 0;
+    counter_with = 0;
+    quiet = false;
+
+    TestAssembler<dim> *test_assembler = new TestAssembler<dim>();
+    assemblers.stokes_system.push_back(std::unique_ptr<Assemblers::Interface<dim>>(test_assembler));
+  }
+}
+
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  std::cout << "* Connecting signals" << std::endl;
+  signals.set_assemblers.connect (&aspect::set_assemblers1<dim>);
+
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
+
+
+class f
+{
+  public:
+    ~f()
+    {
+      std::cout << "called without: " << counter_without << " with: " << counter_with << std::endl;
+    }
+} instance;
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Material1,
+                                   "Material1",
+                                   "")
+  }
+}
diff --git a/tests/additional_outputs_02.prm.bak b/tests/additional_outputs_02.prm.bak
new file mode 100644
index 00000000000..f8723b5d3ef
--- /dev/null
+++ b/tests/additional_outputs_02.prm.bak
@@ -0,0 +1,77 @@
+# A test that adds an assembler that tests if we can create additional
+# material model outputs
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = Material1
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set List of output variables      = viscosity
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/additional_outputs_03.cc.bak b/tests/additional_outputs_03.cc.bak
new file mode 100644
index 00000000000..871eaa60c29
--- /dev/null
+++ b/tests/additional_outputs_03.cc.bak
@@ -0,0 +1,185 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+#include <aspect/simulator/assemblers/interface.h>
+
+#include <iostream>
+
+unsigned int counter_without = 0, counter_with = 0;
+bool quiet = true;
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+    template <int dim>
+    class AdditionalOutputs1 : public AdditionalMaterialOutputs<dim>
+    {
+      public:
+        AdditionalOutputs1 (const unsigned int n_points)
+        {
+          additional_material_output1.resize(n_points);
+        }
+        virtual void average (const MaterialAveraging::AveragingOperation operation,
+                              const FullMatrix<double>  &projection_matrix,
+                              const FullMatrix<double>  &expansion_matrix)
+        {
+          std::cout << "averaging!" << std::endl;
+          average_property (operation, projection_matrix, expansion_matrix,
+                            additional_material_output1);
+        }
+
+
+
+        std::vector<double> additional_material_output1;
+    };
+
+
+    template <int dim>
+    class Material1 : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const
+        {
+          MaterialModel::Simple<dim>::evaluate(in, out);
+
+          AdditionalOutputs1<dim> *additional;
+
+          additional = out.template get_additional_output<AdditionalOutputs1<dim>>();
+          if (additional)
+            ++counter_with;
+          else
+            ++counter_without;
+
+          if (additional)
+            {
+              additional->additional_material_output1[0] = 42.0;
+              additional->additional_material_output1[1] = 0.0;
+            }
+
+
+          if (quiet)
+            return;
+
+          if (additional)
+            std::cout << "* evaluate called with additional outputs!" << std::endl;
+          else
+            std::cout << "* evaluate called without additional outputs!" << std::endl;
+
+        }
+
+
+    };
+
+  }
+
+
+  template <int dim>
+  class TestAssembler :
+    public aspect::Assemblers::Interface<dim>
+  {
+    public:
+
+      virtual void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &out) const
+      {
+        std::cout << "* create_additional_material_model_outputs() called" << std::endl;
+
+        if (out.template get_additional_output<MaterialModel::AdditionalOutputs1<dim>>() != nullptr)
+          return;
+
+        std::cout << "   creating additional output!" << std::endl;
+        out.additional_outputs.push_back(std::make_unique<MaterialModel::AdditionalOutputs1<dim>> (2));
+
+      }
+
+      virtual void execute(internal::Assembly::Scratch::ScratchBase<dim>        &scratch_base,
+                           internal::Assembly::CopyData::CopyDataBase<dim>       &/*data_base*/) const
+      {
+        internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+
+        MaterialModel::AdditionalOutputs1<dim> *additional
+          = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalOutputs1<dim>>();
+
+        std::cout << "* local_assemble_stokes call, have additional? " << (additional!=nullptr) << std::endl;
+        if (additional!=nullptr)
+          std::cout << "   value = " << additional->additional_material_output1[0]
+                    << ' ' << additional->additional_material_output1[1] << std::endl;
+
+
+      }
+
+
+  };
+
+
+  template <int dim>
+  void set_assemblers1(const SimulatorAccess<dim> &,
+                       Assemblers::Manager<dim> &assemblers)
+  {
+    std::cout << "* set_assemblers()" << std::endl;
+    std::cout << "called without: " << counter_without << " with: " << counter_with << std::endl;
+    counter_without = 0;
+    counter_with = 0;
+    quiet = false;
+
+    TestAssembler<dim> *test_assembler = new TestAssembler<dim>();
+    assemblers.stokes_system.push_back(std::unique_ptr<Assemblers::Interface<dim>>(test_assembler));
+  }
+}
+
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  std::cout << "* Connecting signals" << std::endl;
+  signals.set_assemblers.connect (&aspect::set_assemblers1<dim>);
+
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
+
+
+class f
+{
+  public:
+    ~f()
+    {
+      std::cout << "called without: " << counter_without << " with: " << counter_with << std::endl;
+    }
+} instance;
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Material1,
+                                   "Material1",
+                                   "")
+  }
+}
diff --git a/tests/additional_outputs_03.prm.bak b/tests/additional_outputs_03.prm.bak
new file mode 100644
index 00000000000..a657bae3ad4
--- /dev/null
+++ b/tests/additional_outputs_03.prm.bak
@@ -0,0 +1,78 @@
+# A test that adds an assembler that tests if we can create additional
+# material model outputs
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = Material1
+  set Material averaging = arithmetic average
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set List of output variables      = viscosity
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/adiabatic_boundary.prm.bak b/tests/adiabatic_boundary.prm.bak
new file mode 100644
index 00000000000..94096d1c1f6
--- /dev/null
+++ b/tests/adiabatic_boundary.prm.bak
@@ -0,0 +1,66 @@
+# This test was created by Tahiry Rajaonarison, Emmanuel Njinju, and D. Sarah Stamps
+# for the adiabatic boundary initial conditions plugin.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-4
+set Max nonlinear iterations               = 10
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 35
+    set Chunk maximum longitude = 55
+    set Chunk minimum latitude = -28
+    set Chunk maximum latitude = -8
+    set Chunk inner radius = 5878137
+    set Chunk outer radius = 6378137
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic boundary
+
+  subsection Ascii data model
+    set Data file name = adiabatic_boundary.txt
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Initial temperature
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, outer, west, east, south, north
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/adiabatic_conditions.prm.bak b/tests/adiabatic_conditions.prm.bak
new file mode 100644
index 00000000000..6288c0e397d
--- /dev/null
+++ b/tests/adiabatic_conditions.prm.bak
@@ -0,0 +1,75 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, depth average
+
+  subsection Depth average
+    set Number of zones = 10
+  end
+end
diff --git a/tests/adiabatic_conditions_composition_function.prm.bak b/tests/adiabatic_conditions_composition_function.prm.bak
new file mode 100644
index 00000000000..b153af3f295
--- /dev/null
+++ b/tests/adiabatic_conditions_composition_function.prm.bak
@@ -0,0 +1,83 @@
+# This test uses an analytical function to compute the
+# adiabatic initial profile. This is useful if the
+# initial composition plugin depends on the adiabatic
+# condition, and can therefore not be used to compute it.
+
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature = 1613
+set End time = 0
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Function expression = if(x > 1500000,1.0,0.0)
+    set Composition reference profile = function
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = 0, 1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Outer temperature = 1613
+    set Inner temperature = 1613
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = 1
+  set Tangential velocity boundary indicators = 0, 2, 3
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 5
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = adiabat
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference temperature = 1613
+    set Viscosity = 1e21
+    set Thermal conductivity = 1e-06
+    set Density differential for compositional field 1 = 500
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function
+end
diff --git a/tests/adiabatic_conditions_function.prm.bak b/tests/adiabatic_conditions_function.prm.bak
new file mode 100644
index 00000000000..9374f7d3cea
--- /dev/null
+++ b/tests/adiabatic_conditions_function.prm.bak
@@ -0,0 +1,83 @@
+# Test AdiabaticCondition::Function
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = sin(depth); depth; 5.0+depth*depth
+    set Variable names      = depth
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent                = 1
+    set Y extent                = 6.2
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = adiabat
+  end
+end
diff --git a/tests/adiabatic_conditions_time_change.prm.bak b/tests/adiabatic_conditions_time_change.prm.bak
new file mode 100644
index 00000000000..4f1f487fc8b
--- /dev/null
+++ b/tests/adiabatic_conditions_time_change.prm.bak
@@ -0,0 +1,88 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e-5
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Use surface condition function = true
+
+    subsection Surface condition function
+      set Function expression = 1e12*t; 1613.0+1e6*t
+    end
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1e-5
+    set List of output variables = adiabat
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/adiabatic_heating.prm.bak b/tests/adiabatic_heating.prm.bak
new file mode 100644
index 00000000000..272d403f20b
--- /dev/null
+++ b/tests/adiabatic_heating.prm.bak
@@ -0,0 +1,124 @@
+# This test is used to check if the adiabatic heating
+# is calculated correctly.
+# The material is upwelling with a constant velocity
+# and without conduction of heat, so that the steady state
+# of the model is an adiabatic temperature profile, and
+# the temperature should not change over time.
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 2.5e13
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9177
+    set Y extent = 183540      # maximum pressure 6 GPa
+    set Y repetitions = 20
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    set Function expression = 0;1e-10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density        = 3300
+    set Reference specific heat  = 1000
+    set Reference temperature    = 1600
+    set Thermal conductivity     = 0.0
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature
+  end
+end
diff --git a/tests/adiabatic_heating_simplified.prm.bak b/tests/adiabatic_heating_simplified.prm.bak
new file mode 100644
index 00000000000..d7a2ce2e002
--- /dev/null
+++ b/tests/adiabatic_heating_simplified.prm.bak
@@ -0,0 +1,130 @@
+# This test is used to check if the adiabatic heating
+# is calculated correctly. It is based on the test
+# adiabatic_heating, but uses the simplified adiabatic
+# heating model instead.
+# The material is upwelling with a constant velocity
+# and without conduction of heat, so that the steady state
+# of the model is an adiabatic temperature profile, and
+# the temperature should not change over time.
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 2.5e13
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9177
+    set Y extent = 183540      # maximum pressure 6 GPa
+    set Y repetitions = 20
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    set Function expression = 0;1e-10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density        = 3300
+    set Reference specific heat  = 1000
+    set Reference temperature    = 1600
+    set Thermal conductivity     = 0.0
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature
+  end
+end
diff --git a/tests/adiabatic_heating_with_melt.prm.bak b/tests/adiabatic_heating_with_melt.prm.bak
new file mode 100644
index 00000000000..c23b6cf5d00
--- /dev/null
+++ b/tests/adiabatic_heating_with_melt.prm.bak
@@ -0,0 +1,146 @@
+# This test is used to check if the adiabatic heating
+# of melt is calculated correctly.
+# The material is upwelling with a constant velocity
+# and without conduction of heat, so that the steady state
+# of the model is an adiabatic temperature profile, and
+# the temperature should not change over time.
+#
+# The testcase is very similar to the adiabatic_heating
+# test, but melt transport and the adiabatic heat of melt
+# heating model are enabled. There is 100% melt in the model,
+# and melt has a different density than the solid (so that
+# melt an solid velocities are different). However, the melt
+# should still upwell adiabatically, so temperature should
+# not change.
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 2.5e13
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9177
+    set Y extent = 183540      # maximum pressure 6 GPa
+    set Y repetitions = 20
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    subsection Function
+      set Function expression       = 1.0;0.0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0; 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 3:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    set Function expression = 0;1e-10
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, adiabatic heating of melt
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Reference solid density  = 3300
+    set Reference melt density   = 3000
+    set Reference specific heat  = 1000
+    set Reference temperature    = 1600
+    set Thermal conductivity     = 0.0
+    set Surface solidus          = 10000.0
+    set Include melting and freezing = false
+    set Reference permeability   = 1.2345679e-10
+    set Exponential melt weakening factor = 0.
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
diff --git a/tests/adiabatic_initial_conditions.prm.bak b/tests/adiabatic_initial_conditions.prm.bak
new file mode 100644
index 00000000000..9c5173dbd10
--- /dev/null
+++ b/tests/adiabatic_initial_conditions.prm.bak
@@ -0,0 +1,99 @@
+# In ASPECT 0.2, we managed to get the adiabatic initial conditions
+# wrong. This was fixed in r1678 by Juliane Dannberg
+#
+# The computation was only wrong if one specified boundary layers. This
+# test verifies this.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature = 1200
+
+############ These parameters are of interest for this test: #########
+
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 3000.0
+    set Outer temperature = 300.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 3.16e15
+    set Age bottom boundary layer = 3.16e15
+    set Subadiabaticity = 0
+  end
+end
+
+########################################################################
+
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 4.125
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = adiabat
+  end
+
+  subsection Depth average
+    set Number of zones = 10
+  end
+end
diff --git a/tests/adiabatic_initial_conditions_chunk.prm.bak b/tests/adiabatic_initial_conditions_chunk.prm.bak
new file mode 100644
index 00000000000..a0a2c1b9ae2
--- /dev/null
+++ b/tests/adiabatic_initial_conditions_chunk.prm.bak
@@ -0,0 +1,94 @@
+# This parameter file tests the adiabatic initial conditions
+# implemented for the chunk geometry.
+# The 2D chunk geometry has a 60 degree opening angle.
+# A 100 K spherical perturbation of radius 400 km is applied
+# in the middle of the inner boundary.
+#
+# This test is based on adiabatic_initial_conditions.prm
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature = 1200
+
+############ These parameters are of interest for this test: #########
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 15
+    set Chunk maximum longitude = 75
+    set Longitude repetitions = 10
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Radius          = 400000.0
+    set Amplitude       = 100
+    set Subadiabaticity = 0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = inner, outer
+end
+
+########################################################################
+
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 4.125
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 3
+  set Strategy                           = temperature
+  set Refinement fraction                = 0.95
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, west, east
+  set Zero velocity boundary indicators       = outer
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Number of zones = 10
+  end
+end
diff --git a/tests/adiabatic_initial_conditions_chunk_3d.prm.bak b/tests/adiabatic_initial_conditions_chunk_3d.prm.bak
new file mode 100644
index 00000000000..857e02bd8a1
--- /dev/null
+++ b/tests/adiabatic_initial_conditions_chunk_3d.prm.bak
@@ -0,0 +1,98 @@
+# This parameter file tests the adiabatic initial conditions
+# implemented for the chunk geometry.
+# The 3D chunk geometry has a 30/30 degree opening angle in
+# longitude/latitude.
+# A 50 K spherical perturbation of radius 500 km is applied
+# in the middle of the inner boundary.
+#
+# This test is based on adiabatic_initial_conditions.prm
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature = 1200
+
+############ These parameters are of interest for this test: #########
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 30
+    set Chunk maximum longitude = 60
+    set Longitude repetitions = 4
+    set Chunk minimum latitude = 0
+    set Chunk maximum latitude = 30
+    set Latitude repetitions = 4
+    set Chunk inner radius = 5000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 4
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Radius          = 500000.0
+    set Amplitude       = 50
+    set Subadiabaticity = 0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = inner, outer
+end
+
+########################################################################
+
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 4.125
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Refinement fraction                = 0.95
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, west, east, south, north
+  set Zero velocity boundary indicators       = outer
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Number of zones = 4
+  end
+end
diff --git a/tests/adiabatic_initial_conditions_compressible.prm.bak b/tests/adiabatic_initial_conditions_compressible.prm.bak
new file mode 100644
index 00000000000..0bfd591263e
--- /dev/null
+++ b/tests/adiabatic_initial_conditions_compressible.prm.bak
@@ -0,0 +1,95 @@
+# like adiabatic_initial_conditions.prm but with a compressible problem
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature = 1200
+
+############ These parameters are of interest for this test: #########
+
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 3000.0
+    set Outer temperature = 300.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 3.16e15
+    set Age bottom boundary layer = 3.16e15
+    set Subadiabaticity = 0
+  end
+end
+
+########################################################################
+
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference compressibility = 4e-12
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Thermal conductivity          = 4.125
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = adiabat
+  end
+
+  subsection Depth average
+    set Number of zones = 10
+  end
+end
diff --git a/tests/adiabatic_initial_conditions_constant.prm.bak b/tests/adiabatic_initial_conditions_constant.prm.bak
new file mode 100644
index 00000000000..e8ad4e62ac9
--- /dev/null
+++ b/tests/adiabatic_initial_conditions_constant.prm.bak
@@ -0,0 +1,89 @@
+# The adiabatic initial conditions are intended to work
+# as well for models without adiabatic heating, by using
+# the adiabatic surface temperature.
+# This test ensures that boundary layers are handled
+# correctly in this case.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature = 1600
+
+############ These parameters are of interest for this test: #########
+
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 3000.0
+    set Outer temperature = 300.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 3.16e15
+    set Age bottom boundary layer = 3.16e15
+    set Subadiabaticity = 200
+  end
+end
+
+########################################################################
+
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 4.125
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, depth average
+
+  subsection Depth average
+    set Number of zones = 10
+  end
+end
diff --git a/tests/adiabatic_initial_conditions_points.prm.bak b/tests/adiabatic_initial_conditions_points.prm.bak
new file mode 100644
index 00000000000..71d48862b10
--- /dev/null
+++ b/tests/adiabatic_initial_conditions_points.prm.bak
@@ -0,0 +1,105 @@
+# Here we verify that the adiabatic conditions plugin can use
+# a variable number of points. We only use 5 points, so that the
+# profile should have distinct kinks.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature = 1200
+
+############ These parameters are of interest for this test: #########
+
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 3000.0
+    set Outer temperature = 300.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 0
+    set Age bottom boundary layer = 0
+    set Subadiabaticity = 0
+  end
+end
+
+subsection Adiabatic conditions model
+  set Model name = compute profile
+
+  subsection Compute profile
+    set Number of points = 5
+  end
+end
+
+########################################################################
+
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Thermal conductivity          = 4.125
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+    set Reference compressibility     = 1e-11
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = adiabat
+  end
+
+  subsection Depth average
+    set Number of zones = 10
+  end
+end
diff --git a/tests/adiabatic_initial_conditions_subadiabaticity.prm.bak b/tests/adiabatic_initial_conditions_subadiabaticity.prm.bak
new file mode 100644
index 00000000000..8569e698aeb
--- /dev/null
+++ b/tests/adiabatic_initial_conditions_subadiabaticity.prm.bak
@@ -0,0 +1,93 @@
+# In ASPECT 0.2, we managed to get the adiabatic initial conditions
+# wrong. This was fixed in r1678 by Juliane Dannberg
+#
+# The computation was only wrong if one specified boundary layers. Compared
+# to adiabatic_initial_conditions.prm, we here also specify a subadiabaticity
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature = 1200
+
+############ These parameters are of interest for this test: #########
+
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 3000.0
+    set Outer temperature = 300.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 3.16e15
+    set Age bottom boundary layer = 3.16e15
+    set Subadiabaticity = 300
+  end
+end
+
+########################################################################
+
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 4.125
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, depth average
+
+  subsection Depth average
+    set Number of zones = 10
+  end
+end
diff --git a/tests/adiabatic_initial_conditions_without_boundary.prm.bak b/tests/adiabatic_initial_conditions_without_boundary.prm.bak
new file mode 100644
index 00000000000..9001c1871f2
--- /dev/null
+++ b/tests/adiabatic_initial_conditions_without_boundary.prm.bak
@@ -0,0 +1,66 @@
+# In ASPECT 1.2, we managed to get the adiabatic initial conditions
+# wrong in the rare case of no prescribed boundary temperature and a
+# prescribed bottom thermal boundary layer age. This case makes no sense,
+# but it might occur by accident. The expected result is no boundary layer,
+# however previously we computed a boundary layer against the adiabatic
+# surface temperature. This test verifies the solution of this bug.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+
+############ These parameters are of interest for this test: #########
+
+set Adiabatic surface temperature = 1200
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 1e8
+    set Age bottom boundary layer = 1e8
+  end
+end
+
+########################################################################
+
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
diff --git a/tests/adiabatic_plate_cooling.prm.bak b/tests/adiabatic_plate_cooling.prm.bak
new file mode 100644
index 00000000000..546c10fdc1c
--- /dev/null
+++ b/tests/adiabatic_plate_cooling.prm.bak
@@ -0,0 +1,81 @@
+# This test is used to check if the plate cooling model with seafloor ages
+# defined in an ASCII data file is calculated correctly.
+
+set Dimension                              = 2
+set Output directory                       = adiabatic_plate_cooling
+set Use years in output instead of seconds = true
+set End time                               = 1.
+set Pressure normalization                 = no
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1623   # Set to the mantle temperature
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 150e3
+    set Y extent = 150e3
+    set X repetitions = 10
+    set Y repetitions = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Top boundary layer age model = ascii data
+    set Cooling model = plate cooling
+    set Lithosphere thickness = 125e3
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators = top, bottom
+
+  subsection Box
+    set Bottom temperature = 1623
+    set Top temperature = 293
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density        = 3300
+    set Reference specific heat  = 1000
+    set Reference temperature    = 1600
+    set Thermal conductivity     = 4.7
+    set Thermal expansion coefficient = 0.
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature
+  end
+end
diff --git a/tests/adiabatic_plate_function.prm.bak b/tests/adiabatic_plate_function.prm.bak
new file mode 100644
index 00000000000..a2611a29b43
--- /dev/null
+++ b/tests/adiabatic_plate_function.prm.bak
@@ -0,0 +1,86 @@
+# This test is used to check if the half-space cooling model with seafloor ages
+# defined in an analytic function is calculated correctly. It is similar to
+# the adiabatic_plate_cooling test.
+
+set Dimension                              = 2
+set Output directory                       = adiabatic_plate_cooling
+set Use years in output instead of seconds = true
+set End time                               = 1.
+set Pressure normalization                 = no
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1623   # Set to the mantle temperature
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 150e3
+    set Y extent = 150e3
+    set X repetitions = 20
+    set Y repetitions = 20
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Top boundary layer age model = function
+    set Cooling model = half-space cooling
+
+    subsection Age function
+      set Function constants = cm=0.01, year=1
+      set Function expression = x / (1 * cm / year)
+    end
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators = top, bottom
+
+  subsection Box
+    set Bottom temperature = 1623
+    set Top temperature = 293
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density        = 3300
+    set Reference specific heat  = 1000
+    set Reference temperature    = 1600
+    set Thermal conductivity     = 4.7
+    set Thermal expansion coefficient = 0.
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature
+  end
+end
diff --git a/tests/advect_field_with_melt_velocity.cc.bak b/tests/advect_field_with_melt_velocity.cc.bak
new file mode 100644
index 00000000000..41a9c23ffdf
--- /dev/null
+++ b/tests/advect_field_with_melt_velocity.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "rising_melt_blob.cc"
diff --git a/tests/advect_field_with_melt_velocity.prm.bak b/tests/advect_field_with_melt_velocity.prm.bak
new file mode 100644
index 00000000000..58d97f1b99b
--- /dev/null
+++ b/tests/advect_field_with_melt_velocity.prm.bak
@@ -0,0 +1,142 @@
+#########################################################
+# This is a test for the advection scheme that transports
+# compositional fields with the melt velocity. The material
+# properties are set in such a way that the melt velocity
+# is 1 m/yr and the solid velocity is 0.
+# There are two compositional fields, one is transported
+# with the solid velocity (the peridotite field), and one is
+# transported with the melt velocity (the melt composition
+# field).
+# While the mass of the peridotite field should be conserved,
+# the mass of the melt_composition field should decrease over
+# time with a rate of 1/yr.
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.1
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 50
+set CFL number                             = 1
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+############### Parameters describing the model
+# Let us here choose again a box domain
+# where we fix the temperature at the bottom and top,
+# allow free slip along the boundaries
+# and include melt migration.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2
+  set List of model names = initial temperature
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = 2
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+
+  #  set Prescribed velocity boundary indicators = 2:function
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
+    set Function expression = 0;0.01
+  end
+end
+
+subsection Melt settings
+  set Include melt transport = true
+end
+
+############### Compositional fields
+# We want to use two compositional fields, the porosity and
+# an additional field, to check if the melting rate functionality
+# has the same effect as the reaction term for the other
+# compositional fields. As the porosity field is advected by
+# a different mechanism, slight differences between the fields
+# are expected.
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = porosity, peridotite, melt_composition
+  set Compositional field methods = field, field, melt field
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
+    set Function expression = 293
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=50000,y0=0.5,c=10000
+    set Function expression = 0.0872158; if(y>y0,1,0); if(y>y0,1,0)
+  end
+end
+
+subsection Material model
+  set Model name = melting rate
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/advect_mesh_vertically.prm.bak b/tests/advect_mesh_vertically.prm.bak
new file mode 100644
index 00000000000..379d775d456
--- /dev/null
+++ b/tests/advect_mesh_vertically.prm.bak
@@ -0,0 +1,128 @@
+# Test projecting onto gravity direction for free surface computations
+# with a sinking blob.
+
+set Dimension = 2
+set CFL number                             = 0.1
+set End time                               = 1e8
+set Output directory                       = output
+set Pressure normalization                 = no
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = left, right, bottom, top
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities             = 2970., 3800.
+    set Viscosities                     = 1.e20, 1.e24
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = composition, boundary
+  set Time steps between mesh refinement = 5
+  set Refinement criteria merge operation         = plus
+  set Refinement criteria scaling factors         = 2, 1
+
+  subsection Boundary
+    set Boundary refinement indicators = top
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+    set Surface velocity projection = vertical
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 20
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( sqrt( (x-250.e3)^2 + (y-160.e3)^2 ) < 25.e3, 1.0, 0.0)
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 400
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,topography,velocity statistics,
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format = gnuplot
+    set Time between graphical output = 1.e4
+  end
+end
diff --git a/tests/advection_reaction.cc.bak b/tests/advection_reaction.cc.bak
new file mode 100644
index 00000000000..346c5ac73ce
--- /dev/null
+++ b/tests/advection_reaction.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/operator_splitting/advection_reaction/advection_reaction.cc"
diff --git a/tests/advection_reaction.prm.bak b/tests/advection_reaction.prm.bak
new file mode 100644
index 00000000000..6a87e4fbeba
--- /dev/null
+++ b/tests/advection_reaction.prm.bak
@@ -0,0 +1,152 @@
+#########################################################
+# This is a benchmark case that tests the operator split
+# solver scheme, which can use a different time step to
+# compute reactions between compositional fields than
+# the time step used for advection.
+# In comparison to the example 'exponential_decay', the
+# initial composition depends on x, and there is a constant
+# horizontal velocity. The composition decays over time,
+# following the equations for exponential decay with a decay
+# rate that depends on y.
+
+set Additional shared libraries = ./libadvection_reaction.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+# We use a new solver scheme that enables the operator split.
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Use operator splitting                 = true
+set Maximum time step                      = 1
+
+# As we split the time-stepping of advection and reactions,
+# there are now two different time steps in the model:
+# We control the advection time step using the 'Maximum time step'
+# parameter (for easy comparison with the exponential decay test
+# case), and the reaction time step is controlled internally
+# through the ODE solver scheme. Instead of changing the step
+# for the ODE solver, we can make the solution more accurate by
+# modifying the Reaction solver relative tolerance.
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction solver relative tolerance = 1e-6
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.0
+    set cR = 0.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0
+  set List of model names = ExponentialDecayBoundary
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = 0
+  set List of model names = ExponentialDecayBoundary
+end
+
+# The velocity on all boundaries is prescribed to a constant
+# value, leading to horizontal flow from left to right.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  =
+    set Function expression = 0.01;0.0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+# For this model, we choose a sinusoidal initial temperature
+# and composition, so that we can see how the field changes
+# over time as it is advected and decays over time.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = sin(2*pi*x)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = sin(2*pi*x)
+  end
+end
+
+# We choose material and heating models that let temperature
+# and composition decay over time, and that is implemented in
+# a plugin.
+subsection Heating model
+  set List of model names = exponential decay heating
+
+  subsection Exponential decay heating
+    set Half life = 10
+  end
+end
+
+subsection Material model
+  set Model name = exponential decay
+
+  subsection Exponential decay
+    set Half life = 10
+  end
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1e5
+    set Density differential for compositional field 1 = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization, ExponentialDecayPostprocessor
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/advection_solver_fail.prm.bak b/tests/advection_solver_fail.prm.bak
new file mode 100644
index 00000000000..395d67fc8ae
--- /dev/null
+++ b/tests/advection_solver_fail.prm.bak
@@ -0,0 +1,12 @@
+# This is a copy of simple_incompressible.prm that decreases solver
+# tolerance to provoke a crash and check the error message and
+# solver history output.
+
+# EXPECT FAILURE
+
+include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
+
+
+subsection Solver parameters
+  set Temperature solver tolerance = 0
+end
diff --git a/tests/airy_isostasy.prm.bak b/tests/airy_isostasy.prm.bak
new file mode 100644
index 00000000000..378198354a7
--- /dev/null
+++ b/tests/airy_isostasy.prm.bak
@@ -0,0 +1,140 @@
+# We setup three columns, of which the middle column has a higher density
+# and viscosity. By choosing a free surface in combination with a
+# prescribed lithostatic pressure calculated in the left column,
+# we see the middle column sink until isostasy is reached (if end time is increased)
+
+set Dimension = 2
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Pressure normalization                 = no
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# A simple one by one box
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# Temperature is zero everywhere
+# In/outflow through the bottom in the vertical direction only
+# The lithostatic pressure is prescribed for the normal traction
+# component of the bottom boundary.
+# We choose to set zero velocity boundary conditions on the
+# vertical boundaries through Prescribed velocity boundary indicators
+# because then we can specify that the mesh along these boundaries
+# is allowed to move according to the free surface displacement
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+# The composition field has a higher density and viscosity
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities                  = 1,1.05
+    set Reference temperature      = 0
+    set Specific heats             = 1.
+    set Thermal conductivities     = 0.
+    set Thermal expansivities      = 0.
+    set Viscosities                = 1,1e4
+    set Viscosity averaging scheme = geometric
+  end
+end
+
+# We refine at the surface along the compositional field
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 5
+  set Strategy                           = minimum refinement function
+  set Refinement fraction                = 0.7
+  set Time steps between mesh refinement       = 3
+  set Minimum refinement level           = 3
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names = x, z
+    set Function expression = if(x>0.2&x<0.8&z>0.9, 7,5)
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = 2 #,3
+  set List of model names = initial composition
+end
+
+# The representative point determines where the pressure
+# profile is calculated, this can be anywhere in the two
+# outer columns
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 2 y: initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Number of integration points = 260
+    set Representative point         = 0.1,1
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2 x: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = 0;0
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = 3: free surface
+  set Additional tangential mesh velocity boundary indicators = 0,1
+
+  # On the vertical boundaries we allow the mesh to move tangentially
+  # We only displace the surface in the vertical direction
+  subsection Free surface
+    set Surface velocity projection                             = vertical
+  end
+end
+
+# One compositional field in the middle of the domain
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z
+    set Function constants = r=0.3333,p=0.6666
+    set Function expression = if(x>=r&x<p,1,0)
+  end
+end
+
+# In the end, the middle column should have sunk by ~0.048
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, topography
+end
diff --git a/tests/airy_isostasy_initial_topo.cc.bak b/tests/airy_isostasy_initial_topo.cc.bak
new file mode 100644
index 00000000000..6576120d3b1
--- /dev/null
+++ b/tests/airy_isostasy_initial_topo.cc.bak
@@ -0,0 +1,77 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/geometry_model/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    class PointIsInDomain : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        virtual
+        std::pair<std::string,std::string>
+        execute (TableHandler &);
+    };
+  }
+}
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    PointIsInDomain<dim>::execute(TableHandler &)
+    {
+      // The airy isostasy box domain is 1x1 with max 0.05 topography.
+      const Point<dim> point_in_domain(0.1, 0.1);
+      const Point<dim> point_not_in_domain(0.1, 2.0);
+      const Point<dim> point_not_in_domain_2(2.0, 0.01);
+
+      std::ostringstream screen_text;
+      screen_text << std::boolalpha << this->get_geometry_model().point_is_in_domain(point_in_domain) << " ";
+      screen_text << std::boolalpha << this->get_geometry_model().point_is_in_domain(point_not_in_domain) << " ";
+      screen_text << std::boolalpha << this->get_geometry_model().point_is_in_domain(point_not_in_domain_2);
+
+      return std::pair<std::string, std::string> ("Points lie in domain: ",
+                                                  screen_text.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(PointIsInDomain,
+                                  "point is in domain",
+                                  "A postprocessor that tests whether certain points "
+                                  "lie within the domain.")
+  }
+}
diff --git a/tests/airy_isostasy_initial_topo.prm.bak b/tests/airy_isostasy_initial_topo.prm.bak
new file mode 100644
index 00000000000..867ab8cb2e1
--- /dev/null
+++ b/tests/airy_isostasy_initial_topo.prm.bak
@@ -0,0 +1,37 @@
+# We setup three columns, of which the middle column has a higher density
+# and viscosity. By choosing a free surface in combination with a
+# prescribed lithostatic pressure,
+# we see the middle column sink until isostasy is reached (if end time is increased)
+# Compared to airy_isostasy.prm, we start off with a nonzero initial topography.
+
+include $ASPECT_SOURCE_DIR/tests/airy_isostasy.prm
+
+set Dimension = 2
+set End time                               = 3.5e-9
+
+subsection Geometry model
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function constants = L=1, R=0.05, C=0.5
+      set Function expression = R * cos(pi*(x-C)/(L))
+      set Maximum topography value = 0.05
+    end
+  end
+end
+
+# The lithostatic pressure at the bottom of the domain
+# is rho * g * h = 1 * 10 * 1 = 10.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 2 y: function
+
+  subsection Function
+    set Function expression = 0;10
+  end
+end
+
+# Also test the point_is_in_domain function of the geometry model.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, topography, point is in domain
+end
diff --git a/tests/airy_isostasy_initial_topo_lithostatic_pressure.prm.bak b/tests/airy_isostasy_initial_topo_lithostatic_pressure.prm.bak
new file mode 100644
index 00000000000..05787fc3a72
--- /dev/null
+++ b/tests/airy_isostasy_initial_topo_lithostatic_pressure.prm.bak
@@ -0,0 +1,41 @@
+# We setup three columns, of which the middle column has a higher density
+# and viscosity. By choosing a free surface in combination with a
+# prescribed lithostatic pressure,
+# we see the middle column sink until isostasy is reached (if end time is increased)
+# Compared to airy_isostasy.prm, we start off with a nonzero initial topography.
+# This test in particular tests the point_is_in_domain function of the geometry
+# model. It should take into account the initial topography and find that the
+# Representative point lies within the domain. At x = 0.2, the initial topography
+# is namely 0.02948.
+
+include $ASPECT_SOURCE_DIR/tests/airy_isostasy.prm
+
+set Dimension = 2
+
+# The point_is_in_domain function is only called in
+# timestep 0, so we do not need to run the test further.
+set End time                               = 0
+
+subsection Geometry model
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function constants = L=1, R=0.05, C=0.5
+      set Function expression = R * cos(pi*(x-C)/(L))
+      set Maximum topography value = 0.05
+    end
+  end
+end
+
+# The representative point determines where the pressure
+# profile is calculated. We pick a point in the left
+# column which has some initial topography prescribed.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 2 y: initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Number of integration points = 260
+    set Representative point         = 0.2,1.02
+  end
+end
diff --git a/tests/always_refine.prm.bak b/tests/always_refine.prm.bak
new file mode 100644
index 00000000000..eb8443f434f
--- /dev/null
+++ b/tests/always_refine.prm.bak
@@ -0,0 +1,107 @@
+#########################################################
+# Refine in every time step and see what happens.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.5
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/tests/analytic_artificial_viscosity_0.prm.bak b/tests/analytic_artificial_viscosity_0.prm.bak
new file mode 100644
index 00000000000..b7ecb7c7512
--- /dev/null
+++ b/tests/analytic_artificial_viscosity_0.prm.bak
@@ -0,0 +1,93 @@
+# This is a test for the entropy viscosity.
+# In particular, it checks that the value for the maximum viscosity is computed
+# as described in the ASPECT publication.
+
+set Adiabatic surface temperature          = 1600
+set Dimension                              = 2
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 2
+end
+
+# The settings below will cause the residual based entropy viscosity to always
+# be higher than the maximum viscosity. Since the minimum of both is chosen as
+# the applied stabilization, the output will be equal to the latter. For a
+# uniform box, and all material parameters and velocity chosen as one, the
+# maximum viscosity should be equal to the cell diameter (i.e. sqrt(1+1)),
+# which was verified for this test.
+subsection Discretization
+  subsection Stabilization parameters
+    set cR  = 1e100
+    set beta  = 1.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function, bottom:function, left:function, right:function
+
+  subsection Function
+    set Function expression = 1.0;0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (x<0.5) ? 0.0 : 1.0
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density = 1.0
+    set Reference specific heat = 1.0
+    set Thermal expansion coefficient = 0.0
+    set Thermal conductivity          = 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, entropy viscosity statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set Interpolate output = true
+    set List of output variables = material properties, thermal conductivity, artificial viscosity
+  end
+end
diff --git a/tests/anisotropic_viscosity.cc.bak b/tests/anisotropic_viscosity.cc.bak
new file mode 100644
index 00000000000..b41d1e35892
--- /dev/null
+++ b/tests/anisotropic_viscosity.cc.bak
@@ -0,0 +1,830 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_access.h>
+
+#include <aspect/material_model/simple.h>
+#include <aspect/heating_model/shear_heating.h>
+#include <aspect/heating_model/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator/assemblers/stokes.h>
+#include <aspect/simulator_signals.h>
+
+#include <deal.II/base/symmetric_tensor.h>
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    /**
+      * Additional output fields for anisotropic viscosities to be added to
+      * the MaterialModel::MaterialModelOutputs structure and filled in the
+      * MaterialModel::Interface::evaluate() function.
+      */
+    template <int dim>
+    class AnisotropicViscosity : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        AnisotropicViscosity(const unsigned int n_points);
+
+        virtual std::vector<double> get_nth_output(const unsigned int idx) const;
+
+        /**
+         * Stress-strain "director" tensors at the given positions. This
+         * variable is used to implement anisotropic viscosity.
+         *
+         * @note The strain rate term in equation (1) of the manual will be
+         * multiplied by this tensor *and* the viscosity scalar ($\eta$), as
+         * described in the manual section titled "Constitutive laws". This
+         * variable is assigned the rank-four identity tensor by default.
+         * This leaves the isotropic constitutive law unchanged if the material
+         * model does not explicitly assign a value.
+         */
+        std::vector<SymmetricTensor<4,dim>> stress_strain_directors;
+    };
+
+    template <int dim>
+    AnisotropicViscosity<dim>::AnisotropicViscosity (const unsigned int n_points)
+      :
+      NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1,"anisotropic_viscosity")),
+      stress_strain_directors(n_points, dealii::identity_tensor<dim> ())
+    {}
+
+
+
+    template <int dim>
+    std::vector<double>
+    AnisotropicViscosity<dim>::get_nth_output(const unsigned int /*idx*/) const
+    {
+      return std::vector<double>();
+    }
+  }
+
+  namespace Assemblers
+  {
+    /**
+     * A class containing the functions to assemble the Stokes preconditioner.
+     */
+    template <int dim>
+    class StokesPreconditionerAnisotropicViscosity : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        virtual
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const;
+
+        /**
+         * Create AnisotropicViscosities.
+         */
+        virtual void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const;
+    };
+
+    /**
+     * A class containing the functions to assemble the compressible adjustment
+     * to the Stokes preconditioner.
+     */
+    template <int dim>
+    class StokesCompressiblePreconditionerAnisotropicViscosity : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        virtual
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const;
+    };
+
+    /**
+     * This class assembles the terms for the matrix and right-hand-side of the incompressible
+     * Stokes equation for the current cell.
+     */
+    template <int dim>
+    class StokesIncompressibleTermsAnisotropicViscosity : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        virtual
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const;
+
+        /**
+         * Create AdditionalMaterialOutputsStokesRHS if we need to do so.
+         */
+        virtual void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const;
+    };
+
+    /**
+     * This class assembles the term that arises in the viscosity term of Stokes matrix for
+     * compressible models, because the divergence of the velocity is not longer zero.
+     */
+    template <int dim>
+    class StokesCompressibleStrainRateViscosityTermAnisotropicViscosity : public Assemblers::Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        virtual
+        void
+        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
+                internal::Assembly::CopyData::CopyDataBase<dim> &data) const;
+    };
+
+    template <int dim>
+    void
+    StokesPreconditionerAnisotropicViscosity<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
+
+      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      // First loop over all dofs and find those that are in the Stokes system
+      // save the component (pressure and dim velocities) each belongs to.
+      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+        {
+          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+            {
+              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
+              ++i_stokes;
+            }
+          ++i;
+        }
+
+      // Loop over all quadrature points and assemble their contributions to
+      // the preconditioner matrix
+      for (unsigned int q = 0; q < n_q_points; ++q)
+        {
+          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.grads_phi_u[i_stokes] =
+                    scratch.finite_element_values[introspection.extractors
+                                                  .velocities].symmetric_gradient(i, q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection
+                                                                          .extractors.pressure].value(i, q);
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const double eta = scratch.material_model_outputs.viscosities[q];
+          const double one_over_eta = 1. / eta;
+
+          const bool use_tensor = (anisotropic_viscosity != nullptr);
+
+          const SymmetricTensor<4, dim> &stress_strain_director = (use_tensor)
+                                                                  ?
+                                                                  anisotropic_viscosity->stress_strain_directors[q]
+                                                                  :
+                                                                  dealii::identity_tensor<dim>();
+
+
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+            for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
+              if (scratch.dof_component_indices[i] ==
+                  scratch.dof_component_indices[j])
+                data.local_matrix(i, j) += ((
+                                              use_tensor ?
+                                              2.0 * eta * (scratch.grads_phi_u[i]
+                                                           * stress_strain_director
+                                                           * scratch.grads_phi_u[j]) :
+                                              2.0 * eta * (scratch.grads_phi_u[i]
+                                                           * scratch.grads_phi_u[j]))
+                                            + one_over_eta * pressure_scaling
+                                            * pressure_scaling
+                                            * (scratch.phi_p[i]
+                                               * scratch.phi_p[j]))
+                                           * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesPreconditionerAnisotropicViscosity<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      const unsigned int n_points = outputs.viscosities.size();
+
+      if (outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesCompressiblePreconditionerAnisotropicViscosity<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
+
+      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
+
+      // First loop over all dofs and find those that are in the Stokes system
+      // save the component (pressure and dim velocities) each belongs to.
+      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+        {
+          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+            {
+              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
+              ++i_stokes;
+            }
+          ++i;
+        }
+
+      // Loop over all quadrature points and assemble their contributions to
+      // the preconditioner matrix
+      for (unsigned int q = 0; q < n_q_points; ++q)
+        {
+          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0;
+
+          const bool use_tensor = (anisotropic_viscosity != nullptr);
+
+          const SymmetricTensor<4, dim> &stress_strain_director = (use_tensor)
+                                                                  ?
+                                                                  anisotropic_viscosity->stress_strain_directors[q]
+                                                                  :
+                                                                  dealii::identity_tensor<dim>();
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
+            for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
+              if (scratch.dof_component_indices[i] ==
+                  scratch.dof_component_indices[j])
+                data.local_matrix(i, j) += (- (use_tensor ?
+                                               eta_two_thirds * (scratch.div_phi_u[i] * trace(stress_strain_director * scratch.grads_phi_u[j]))
+                                               :
+                                               eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
+                                              ))
+                                           * JxW;
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesIncompressibleTermsAnisotropicViscosity<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+      const double pressure_scaling = this->get_pressure_scaling();
+
+      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
+      *force = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
+                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+                  if (scratch.rebuild_stokes_matrix)
+                    {
+                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+                    }
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+
+          // Viscosity scalar
+          const double eta = (scratch.rebuild_stokes_matrix
+                              ?
+                              scratch.material_model_outputs.viscosities[q]
+                              :
+                              numbers::signaling_nan<double>());
+
+          const bool use_tensor = (anisotropic_viscosity != nullptr);
+
+          const SymmetricTensor<4, dim> &stress_strain_director = (use_tensor)
+                                                                  ?
+                                                                  anisotropic_viscosity->stress_strain_directors[q]
+                                                                  :
+                                                                  dealii::identity_tensor<dim>();
+
+          const Tensor<1,dim>
+          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
+
+          const double density = scratch.material_model_outputs.densities[q];
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            {
+              data.local_rhs(i) += (density * gravity * scratch.phi_u[i])
+                                   * JxW;
+
+              if (force != nullptr)
+                data.local_rhs(i) += (force->rhs_u[q] * scratch.phi_u[i]
+                                      + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i])
+                                     * JxW;
+
+              if (scratch.rebuild_stokes_matrix)
+                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+                  {
+                    data.local_matrix(i,j) += ( (use_tensor ?
+                                                 eta * 2.0 * (scratch.grads_phi_u[i] * stress_strain_director * scratch.grads_phi_u[j])
+                                                 :
+                                                 eta * 2.0 * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
+                                                // assemble \nabla p as -(p, div v):
+                                                - (pressure_scaling *
+                                                   scratch.div_phi_u[i] * scratch.phi_p[j])
+                                                // assemble the term -div(u) as -(div u, q).
+                                                // Note the negative sign to make this
+                                                // operator adjoint to the grad p term:
+                                                - (pressure_scaling *
+                                                   scratch.phi_p[i] * scratch.div_phi_u[j]))
+                                              * JxW;
+                  }
+            }
+        }
+    }
+
+
+
+    template <int dim>
+    void
+    StokesIncompressibleTermsAnisotropicViscosity<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
+    {
+      const unsigned int n_points = outputs.viscosities.size();
+
+      if (outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
+        }
+
+      if (this->get_parameters().enable_additional_stokes_rhs
+          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
+        {
+          outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>> (n_points));
+        }
+      Assert(!this->get_parameters().enable_additional_stokes_rhs
+             ||
+             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
+             == n_points, ExcInternalError());
+    }
+
+
+
+    template <int dim>
+    void
+    StokesCompressibleStrainRateViscosityTermAnisotropicViscosity<dim>::
+    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+    {
+      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+      if (!scratch.rebuild_stokes_matrix)
+        return;
+
+      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      const Introspection<dim> &introspection = this->introspection();
+      const FiniteElement<dim> &fe = this->get_fe();
+      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+
+      for (unsigned int q=0; q<n_q_points; ++q)
+        {
+          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+            {
+              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
+                {
+                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
+                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
+
+                  ++i_stokes;
+                }
+              ++i;
+            }
+
+          // Viscosity scalar
+          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0;
+
+          const bool use_tensor = (anisotropic_viscosity != nullptr);
+
+          const SymmetricTensor<4, dim> &stress_strain_director = (use_tensor)
+                                                                  ?
+                                                                  anisotropic_viscosity->stress_strain_directors[q]
+                                                                  :
+                                                                  dealii::identity_tensor<dim>();
+
+          const double JxW = scratch.finite_element_values.JxW(q);
+
+          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
+              {
+                data.local_matrix(i,j) += (- (use_tensor ?
+                                              eta_two_thirds * (scratch.div_phi_u[i] * trace(stress_strain_director * scratch.grads_phi_u[j]))
+                                              :
+                                              eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
+                                             ))
+                                          * JxW;
+              }
+        }
+    }
+  }
+
+
+  namespace HeatingModel
+  {
+    template <int dim>
+    class ShearHeatingAnisotropicViscosity : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Compute the heating model outputs for this class.
+         */
+        virtual
+        void
+        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const;
+
+        /**
+         * Allow the heating model to attach additional material model outputs.
+         */
+        virtual
+        void
+        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const;
+    };
+
+    template <int dim>
+    void
+    ShearHeatingAnisotropicViscosity<dim>::
+    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
+    {
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.position.size(),
+             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
+
+      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.strain_rate.size(),
+             ExcMessage ("The shear heating plugin needs the strain rate!"));
+
+      // Some material models provide dislocation viscosities and boundary area work fractions
+      // as additional material outputs. If they are attached, use them.
+      const ShearHeatingOutputs<dim> *shear_heating_out =
+        material_model_outputs.template get_additional_output<ShearHeatingOutputs<dim>>();
+
+      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
+        {
+          // If there is an anisotropic viscosity, use it to compute the correct stress
+          const SymmetricTensor<2,dim> &directed_strain_rate = ((anisotropic_viscosity != nullptr)
+                                                                ?
+                                                                anisotropic_viscosity->stress_strain_directors[q]
+                                                                * material_model_inputs.strain_rate[q]
+                                                                :
+                                                                material_model_inputs.strain_rate[q]);
+
+          const SymmetricTensor<2,dim> stress =
+            2 * material_model_outputs.viscosities[q] *
+            (this->get_material_model().is_compressible()
+             ?
+             directed_strain_rate - 1./3. * trace(directed_strain_rate) * unit_symmetric_tensor<dim>()
+             :
+             directed_strain_rate);
+
+          const SymmetricTensor<2,dim> deviatoric_strain_rate =
+            (this->get_material_model().is_compressible()
+             ?
+             material_model_inputs.strain_rate[q]
+             - 1./3. * trace(material_model_inputs.strain_rate[q]) * unit_symmetric_tensor<dim>()
+             :
+             material_model_inputs.strain_rate[q]);
+
+          heating_model_outputs.heating_source_terms[q] = stress * deviatoric_strain_rate;
+
+          // If shear heating work fractions are provided, reduce the
+          // overall heating by this amount (which is assumed to be converted into other forms of energy)
+          if (shear_heating_out != nullptr)
+            heating_model_outputs.heating_source_terms[q] *= shear_heating_out->shear_heating_work_fractions[q];
+
+          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
+        }
+    }
+
+    template <int dim>
+    void
+    ShearHeatingAnisotropicViscosity<dim>::
+    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const
+    {
+      const unsigned int n_points = material_model_outputs.viscosities.size();
+
+      if (material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
+        {
+          material_model_outputs.additional_outputs.push_back(
+            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
+        }
+
+      this->get_material_model().create_additional_named_outputs(material_model_outputs);
+    }
+  }
+
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class Anisotropic : public MaterialModel::Simple<dim>
+    {
+      public:
+        virtual void initialize();
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+        static void declare_parameters(ParameterHandler &prm);
+        virtual void parse_parameters(ParameterHandler &prm);
+
+        /**
+          * Return true if the compressibility() function returns something that
+          * is not zero.
+          */
+        virtual bool
+        is_compressible () const;
+
+      private:
+        void set_assemblers(const SimulatorAccess<dim> &,
+                            Assemblers::Manager<dim> &assemblers) const;
+
+        // Constitutive tensor
+        SymmetricTensor<4,dim> C;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    template <int dim>
+    void
+    Anisotropic<dim>::set_assemblers(const SimulatorAccess<dim> &,
+                                     Assemblers::Manager<dim> &assemblers) const
+    {
+      for (unsigned int i=0; i<assemblers.stokes_preconditioner.size(); ++i)
+        {
+          if (dynamic_cast<Assemblers::StokesPreconditioner<dim> *>(assemblers.stokes_preconditioner[i].get()) != nullptr)
+            assemblers.stokes_preconditioner[i] = std::make_unique<Assemblers::StokesPreconditionerAnisotropicViscosity<dim>> ();
+          if (dynamic_cast<Assemblers::StokesCompressiblePreconditioner<dim> *>(assemblers.stokes_preconditioner[i].get()) != nullptr)
+            assemblers.stokes_preconditioner[i] = std::make_unique<Assemblers::StokesCompressiblePreconditionerAnisotropicViscosity<dim>> ();
+        }
+
+      for (unsigned int i=0; i<assemblers.stokes_system.size(); ++i)
+        {
+          if (dynamic_cast<Assemblers::StokesIncompressibleTerms<dim> *>(assemblers.stokes_system[i].get()) != nullptr)
+            assemblers.stokes_system[i] = std::make_unique<Assemblers::StokesIncompressibleTermsAnisotropicViscosity<dim>> ();
+          if (dynamic_cast<Assemblers::StokesCompressibleStrainRateViscosityTerm<dim> *>(assemblers.stokes_system[i].get()) != nullptr)
+            assemblers.stokes_system[i] = std::make_unique<Assemblers::StokesCompressibleStrainRateViscosityTermAnisotropicViscosity<dim>> ();
+        }
+    }
+
+    template <int dim>
+    void
+    Anisotropic<dim>::
+    initialize()
+    {
+      this->get_signals().set_assemblers.connect (std::bind(&Anisotropic<dim>::set_assemblers,
+                                                            std::cref(*this),
+                                                            std::placeholders::_1,
+                                                            std::placeholders::_2));
+    }
+
+    template <int dim>
+    void
+    Anisotropic<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
+        out.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
+
+      Simple<dim>::evaluate(in, out);
+      Point<dim> center;
+      center[0] = 0.5;
+      center[1] = 0.5;
+      if (dim == 3)
+        center[2] = 0.5;
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double pressure = in.pressure[i];
+          out.densities[i] = 1.0 + pressure;
+          out.compressibilities[i] = 1.0 / (1. + pressure);
+          if ((in.position[i]-center).norm() < 0.25)
+            {
+              if (anisotropic_viscosity != nullptr)
+                anisotropic_viscosity->stress_strain_directors[i] = C;
+            }
+        }
+    }
+
+    template <int dim>
+    bool
+    Anisotropic<dim>::
+    is_compressible () const
+    {
+      return true;
+    }
+
+    template <int dim>
+    void
+    Anisotropic<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      Simple<dim>::declare_parameters (prm);
+      prm.enter_subsection ("Material model");
+      {
+        prm.enter_subsection ("Anisotropic");
+        {
+          if (dim == 2)
+            prm.declare_entry ("Viscosity tensor",
+                               "1, 0, 0,"
+                               "0, 1, 0,"
+                               "0, 0,.5",
+                               Patterns::List(Patterns::Double()),
+                               "Viscosity-scaling tensor in Voigt notation.");
+          else
+            prm.declare_entry ("Viscosity tensor",
+                               "1, 0, 0, 0, 0, 0,"
+                               "0, 1, 0, 0, 0, 0,"
+                               "0, 0, 1, 0, 0, 0,"
+                               "0, 0, 0,.5, 0, 0,"
+                               "0, 0, 0, 0,.5, 0,"
+                               "0, 0, 0, 0, 0,.5",
+                               Patterns::List(Patterns::Double()),
+                               "Viscosity-scaling tensor in Voigt notation.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    Anisotropic<dim>::
+    parse_parameters (ParameterHandler &prm)
+    {
+      Simple<dim>::parse_parameters (prm);
+      prm.enter_subsection ("Material model");
+      {
+        prm.enter_subsection ("Anisotropic");
+        {
+          const int size_voigt = (dim == 3 ? 6 : 3);
+          const std::vector<double> tmp_tensor =
+            Utilities::string_to_double(Utilities::split_string_list(prm.get ("Viscosity tensor")));
+          Assert(tmp_tensor.size() == size_voigt*size_voigt,
+                 ExcMessage("Constitutive voigt matrix must have 9 components in 2D, or 36 components in 3d"));
+
+          std::vector<std::vector<double>> voigt_visc_tensor (size_voigt);
+          for (unsigned int i=0; i<size_voigt; ++i)
+            {
+              voigt_visc_tensor[i].resize(size_voigt);
+              for (unsigned int j=0; j<size_voigt; ++j)
+                voigt_visc_tensor[i][j] = tmp_tensor[i*size_voigt+j];
+            }
+
+          // Voigt indices (For mapping back to real tensor)
+          const unsigned int vi3d0[] = {0, 1, 2, 1, 0, 0};
+          const unsigned int vi3d1[] = {0, 1, 2, 2, 2, 1};
+          const unsigned int vi2d0[] = {0, 1, 0};
+          const unsigned int vi2d1[] = {0, 1, 1};
+
+          // Fill the constitutive tensor with values from the Voigt tensor
+          for (unsigned int i=0; i<size_voigt; ++i)
+            for (unsigned int j=0; j<size_voigt; ++j)
+              if (dim == 2)
+                C[vi2d0[i]][vi2d1[i]][vi2d0[j]][vi2d1[j]] = voigt_visc_tensor[i][j];
+              else
+                C[vi3d0[i]][vi3d1[i]][vi3d0[j]][vi3d1[j]] = voigt_visc_tensor[i][j];
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Assemblers
+  {
+#define INSTANTIATE(dim) \
+  template class StokesPreconditioner<dim>; \
+  template class StokesCompressiblePreconditioner<dim>; \
+  template class StokesIncompressibleTerms<dim>; \
+  template class StokesCompressibleStrainRateViscosityTerm<dim>; \
+  template class StokesReferenceDensityCompressibilityTerm<dim>; \
+  template class StokesImplicitReferenceDensityCompressibilityTerm<dim>; \
+  template class StokesIsentropicCompressionTerm<dim>; \
+  template class StokesHydrostaticCompressionTerm<dim>; \
+  template class StokesPressureRHSCompatibilityModification<dim>; \
+  template class StokesBoundaryTraction<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+  }
+
+  namespace HeatingModel
+  {
+    ASPECT_REGISTER_HEATING_MODEL(ShearHeatingAnisotropicViscosity,
+                                  "anisotropic shear heating",
+                                  "Implementation of a standard model for shear heating. "
+                                  "Adds the term: "
+                                  "$  2 \\eta \\left( \\varepsilon - \\frac{1}{3} \\text{tr} "
+                                  "\\varepsilon \\mathbf 1 \\right) : \\left( \\varepsilon - \\frac{1}{3} "
+                                  "\\text{tr} \\varepsilon \\mathbf 1 \\right)$ to the "
+                                  "right-hand side of the temperature equation.")
+  }
+
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Anisotropic,
+                                   "anisotropic",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but has a non-zero compressibility "
+                                   "and always has a blob of anisotropic material in "
+                                   "the center.")
+  }
+}
diff --git a/tests/anisotropic_viscosity.prm.bak b/tests/anisotropic_viscosity.prm.bak
new file mode 100644
index 00000000000..83e848af2b4
--- /dev/null
+++ b/tests/anisotropic_viscosity.prm.bak
@@ -0,0 +1,91 @@
+# This tests an implementation of anisotropic viscosity terms in the Stokes
+# equation. In this test we create new assembler
+# classes in anisotropic_viscosity.cc that extend the standard assemblers
+# with a fourth order viscosity tensor. The chosen material model 'anisotropic'
+# then replaces the standard assemblers with the custom ones during the call
+# to the set_assemblers signal, and during every call to evaluate()
+# fills the AdditionalMaterialOutputs object of type AnisotropicViscosity with
+# the chosen viscosity tensor that is selected in this input file.
+# This way the solved equations are changed without modifying the main code
+# base.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = anisotropic
+
+  subsection Anisotropic
+    # n = (1,1); eta_s/eta_n = 0.001
+    set Viscosity tensor = 0.501, 0.499, 0.0, \
+                           0.499, 0.501, 0.0, \
+                           0.0,   0.0,   0.5
+  end
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Heating model
+  set List of model names = anisotropic shear heating
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 1;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = heating statistics, velocity statistics
+end
diff --git a/tests/annulus.cc.bak b/tests/annulus.cc.bak
new file mode 100644
index 00000000000..061436b9fcc
--- /dev/null
+++ b/tests/annulus.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/annulus/plugin/annulus.cc"
diff --git a/tests/annulus.prm.bak b/tests/annulus.prm.bak
new file mode 100644
index 00000000000..10d628a02d9
--- /dev/null
+++ b/tests/annulus.prm.bak
@@ -0,0 +1,10 @@
+# A test for the instantaneous 2D annulus benchmark.
+
+include $ASPECT_SOURCE_DIR/benchmarks/annulus/instantaneous/annulus.prm
+
+set Additional shared libraries            = ./libannulus.so
+set Dimension                              = 2
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+end
diff --git a/tests/annulus_transient.cc.bak b/tests/annulus_transient.cc.bak
new file mode 100644
index 00000000000..061436b9fcc
--- /dev/null
+++ b/tests/annulus_transient.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/annulus/plugin/annulus.cc"
diff --git a/tests/annulus_transient.prm.bak b/tests/annulus_transient.prm.bak
new file mode 100644
index 00000000000..9fd7494a90a
--- /dev/null
+++ b/tests/annulus_transient.prm.bak
@@ -0,0 +1,96 @@
+# A test for the transient 2D annulus benchmark.
+# We would like to include the actual benchmark parameter file,
+# but it contains an $ASPECT_SOURCE_DIR statement that cannot
+# be expanded when included from another file. Therefore this is
+# a slightly modified copy of
+# benchmarks/annulus/transient/transient_annulus.prm.
+
+# The 2D Stokes in an annulus benchmark, for which an
+# analytical solution is available. This is the rotating
+# version of the benchmark described in Gassmoeller et al. 2023.
+#
+# See the doc/ directory or manual for more information.
+
+# Most parameters are identical to the instantaneous version
+# of the benchmark. Refer to that parameter file for most settings.
+include $ASPECT_SOURCE_DIR/benchmarks/annulus/instantaneous/annulus.prm
+
+
+# Only list parameters that are specific for the transient benchmark
+set Additional shared libraries            = ../plugin/libannulus.so
+set Dimension                              = 2
+
+# for benchmark: t = log(1 + 4 pi)
+set End time                                = 0.05
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = density_field
+end
+
+subsection Initial composition model
+  set List of model names = initial density
+end
+
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+end
+
+subsection Annulus benchmark
+  set Use analytical density  = false
+  set Use transient solution  = true
+  set k                       = 4
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, AnnulusPostprocessor, rotation statistics
+
+  subsection Dynamic topography
+    set Density above = 0
+    set Density below = 0
+  end
+
+  subsection Visualization
+    set List of output variables = density, gravity, AnnulusVisualizationPostprocessor
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 2.6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 200
+    set Stokes solver type = block GMG
+    set Krylov method for cheap solver steps = IDR(s)
+    set IDR(s) parameter = 4
+  end
+end
+
+subsection Particles
+  set Integration scheme = rk2
+  set Interpolation scheme = bilinear least squares
+  set List of particle properties = particle density
+  set Update ghost particles = true
+  set Particle generator name = random uniform
+  set Load balancing strategy = add particles
+  set Minimum particles per cell = 12
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 49152
+    end
+  end
+end
diff --git a/tests/artificial_postprocess.cc.bak b/tests/artificial_postprocess.cc.bak
new file mode 100644
index 00000000000..39c36b68121
--- /dev/null
+++ b/tests/artificial_postprocess.cc.bak
@@ -0,0 +1,83 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim>
+  class EVPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Generate graphical output from the current solution.
+       */
+      virtual
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics);
+  };
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  EVPostprocessor<dim>::execute (TableHandler &statistics)
+  {
+    std::ostringstream os;
+    Vector<float> ev(this->get_triangulation().n_active_cells());
+    this->get_artificial_viscosity(ev);
+    std::cout << "EV temperature: " << std::endl;
+    ev.print(std::cout);
+    os << ev.l2_norm() << ' ';
+
+    for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+      {
+        ev = 0.0;
+        this->get_artificial_viscosity_composition(ev, c);
+        std::cout << "EV composition " << c << ": " << std::endl;
+        ev.print(std::cout, 10);
+        os << ev.l2_norm() << ' ';
+      }
+    return std::make_pair("EV norms:", os.str());
+  }
+
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_POSTPROCESSOR(EVPostprocessor,
+                                "EVPostprocessor",
+                                "")
+}
diff --git a/tests/artificial_postprocess.prm.bak b/tests/artificial_postprocess.prm.bak
new file mode 100644
index 00000000000..ce9334bb753
--- /dev/null
+++ b/tests/artificial_postprocess.prm.bak
@@ -0,0 +1,112 @@
+# check SimulatorAccess::get_artificial_viscosity_composition
+# this test crashes on mainline with:
+# An error occurred in line <2922> of file </scratch/deal-git/source/fe/fe_system.cc> in function
+#     const dealii::FiniteElement<dim, spacedim>& dealii::FESystem<dim, spacedim>::base_element(unsigned int) const [with int dim = 2; int spacedim = 2]
+# The violated condition was:
+#     index < base_elements.size()
+# The name and call sequence of the exception was:
+#     ExcIndexRange(index, 0, base_elements.size())
+# Additional Information:
+# Index 4 is not in [0,4[
+#
+#
+# test modified from composition_names.prm
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 1e11
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = comp1, comp2
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;if (x<250000, 100, 50)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient                  = 1e-5
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, EVPostprocessor
+end
diff --git a/tests/artificial_viscosity.prm.bak b/tests/artificial_viscosity.prm.bak
new file mode 100644
index 00000000000..b25810caef5
--- /dev/null
+++ b/tests/artificial_viscosity.prm.bak
@@ -0,0 +1,124 @@
+# This is a test for the artificial viscosity.
+# In particular, it checks that the results for
+# temperature and compositional fields are the same.
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 0.1
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Dimension                              = 2
+set End time                               = 0.005
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.078
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# we apply simple shear here, so that the top and bottom boundaries
+# move with the same speed u0, but in opposite directions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+
+  subsection Function
+    set Function constants = u0=0.01,ymid=0.5
+    set Function expression = 1.0;0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set X periodic = true
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=64000
+    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=64000
+    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Thermal conductivity          = 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = artificial viscosity, artificial viscosity composition
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0.004
+
+    subsection Artificial viscosity composition
+      set Name of compositional field = porosity
+    end
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-8
+  set Composition solver tolerance = 1e-8
+
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/artificial_viscosity_dirichlet_boundaries.prm.bak b/tests/artificial_viscosity_dirichlet_boundaries.prm.bak
new file mode 100644
index 00000000000..09fa24626c4
--- /dev/null
+++ b/tests/artificial_viscosity_dirichlet_boundaries.prm.bak
@@ -0,0 +1,110 @@
+# This is a test for the artificial viscosity.
+# In particular, it checks that the entropy viscosity
+# for the composition at dirichlet boundaries can be set
+# to 0 if requested.
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 0.1
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Dimension                              = 2
+set End time                               = 0.01
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set List of compositional fields with disabled boundary entropy viscosity = porosity
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = initial temperature
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = top, bottom
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+
+  subsection Function
+    set Function constants = u0=0.01,ymid=0.5
+    set Function expression = 1.0;0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set X periodic = true
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=64000
+    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=64000
+    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Thermal conductivity          = 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 3
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, visualization, entropy viscosity statistics
+
+  subsection Visualization
+    set Interpolate output            = false
+    set List of output variables      = artificial viscosity, artificial viscosity composition
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+
+    subsection Artificial viscosity composition
+      set Name of compositional field = porosity
+    end
+  end
+end
diff --git a/tests/artificial_viscosity_list.prm.bak b/tests/artificial_viscosity_list.prm.bak
new file mode 100644
index 00000000000..f85b5b0a842
--- /dev/null
+++ b/tests/artificial_viscosity_list.prm.bak
@@ -0,0 +1,93 @@
+# A simple setup for convection in a 3d shell. See the
+# manual for more information.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1973
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.473e3
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = (x>0) ? 1.0 : 0.0
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta = 1e-5,0.078
+    set cR = 1e-5,0.11
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = artificial viscosity, artificial viscosity composition
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+
+    subsection Artificial viscosity composition
+      set Name of compositional field = C_1
+    end
+  end
+end
diff --git a/tests/ascii_boundary_member.cc.bak b/tests/ascii_boundary_member.cc.bak
new file mode 100644
index 00000000000..16b580f44c3
--- /dev/null
+++ b/tests/ascii_boundary_member.cc.bak
@@ -0,0 +1,212 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+#include <aspect/global.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+
+namespace aspect
+{
+  using namespace dealii;
+  /**
+   * A boundary velocity plugin that uses an AsciiDataBoundary object as member
+   */
+  template <int dim>
+  class AsciiBoundaryMember : public BoundaryVelocity::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Empty Constructor.
+       */
+      AsciiBoundaryMember ();
+
+      /**
+       * Initialization function. This function is called once at the
+       * beginning of the program. Checks preconditions.
+       */
+      void
+      initialize ();
+
+      /**
+       * A function that is called at the beginning of each time step. For
+       * the current plugin, this function loads the next data files if
+       * necessary and outputs a warning if the end of the set of data files
+       * is reached.
+       */
+      void
+      update ();
+
+      /**
+       * Return the boundary velocity as a function of position. For the
+       * current class, this function returns value from the text files.
+       */
+      Tensor<1,dim>
+      boundary_velocity (const types::boundary_id boundary_indicator,
+                         const Point<dim> &position) const;
+
+      /**
+       * Declare the parameters this class takes through input files.
+       */
+      static
+      void
+      declare_parameters (ParameterHandler &prm);
+
+      /**
+       * Read the parameters this class declares from the parameter file.
+       */
+      void
+      parse_parameters (ParameterHandler &prm);
+
+      std::unique_ptr<Utilities::AsciiDataBoundary<dim>> member;
+
+      std::set<types::boundary_id> boundary_ids;
+  };
+
+  template <int dim>
+  AsciiBoundaryMember<dim>::AsciiBoundaryMember ()
+  {}
+
+
+  template <int dim>
+  void
+  AsciiBoundaryMember<dim>::initialize ()
+  {
+    const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>> &
+    bvs = this->get_boundary_velocity_manager().get_active_boundary_velocity_conditions();
+    for (const auto &boundary : bvs)
+      for (const auto &p : boundary.second)
+        {
+          if (p.get() == this)
+            boundary_ids.insert(boundary.first);
+        }
+    AssertThrow(*(boundary_ids.begin()) != numbers::invalid_boundary_id,
+                ExcMessage("Did not find the boundary indicator for the prescribed data plugin."));
+
+    member->initialize(boundary_ids,
+                       dim);
+  }
+
+  template <int dim>
+  void
+  AsciiBoundaryMember<dim>::update ()
+  {
+    member->update();
+  }
+
+
+  template <int dim>
+  Tensor<1,dim>
+  AsciiBoundaryMember<dim>::
+  boundary_velocity (const types::boundary_id ,
+                     const Point<dim> &position) const
+  {
+    Tensor<1,dim> velocity;
+    for (unsigned int i = 0; i < dim; i++)
+      velocity[i] = member->get_data_component(*(boundary_ids.begin()),
+                                               position,
+                                               i);
+    return velocity;
+  }
+
+
+  template <int dim>
+  void
+  AsciiBoundaryMember<dim>::declare_parameters (ParameterHandler &prm)
+  {
+    prm.enter_subsection("Boundary velocity model");
+    {
+      Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
+                                                            "$ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/",
+                                                            "box_2d_%s.%d.txt");
+    }
+    prm.leave_subsection();
+  }
+
+
+  template <int dim>
+  void
+  AsciiBoundaryMember<dim>::parse_parameters (ParameterHandler &prm)
+  {
+    prm.enter_subsection("Boundary velocity model");
+    {
+      member = std::make_unique<Utilities::AsciiDataBoundary<dim>>();
+      member->initialize_simulator(this->get_simulator());
+
+      member->parse_parameters(prm);
+
+      if (this->convert_output_to_years() == true)
+        {
+          member->scale_factor               /= year_in_seconds;
+        }
+
+    }
+    prm.leave_subsection();
+  }
+
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(AsciiBoundaryMember,
+                                          "ascii boundary member",
+                                          "Implementation of a model in which the boundary "
+                                          "velocity is derived from files containing data "
+                                          "in ascii format. Note the required format of the "
+                                          "input data: The first lines may contain any number of comments "
+                                          "if they begin with '#', but one of these lines needs to "
+                                          "contain the number of grid points in each dimension as "
+                                          "for example '# POINTS: 3 3'. "
+                                          "The order of the data columns "
+                                          "has to be 'x', 'velocity_x', 'velocity_y' in a 2d model "
+                                          "or 'x', 'y', 'velocity_x', 'velocity_y', "
+                                          "'velocity_z' in a 3d model. "
+                                          "Note that the data in the input "
+                                          "files need to be sorted in a specific order: "
+                                          "the first coordinate needs to ascend first, "
+                                          "followed by the second in order to "
+                                          "assign the correct data to the prescribed coordinates."
+                                          "If you use a spherical model, "
+                                          "then the velocities will still be handled as Cartesian, "
+                                          "however the assumed grid changes. 'x' will be replaced by "
+                                          "the radial distance of the point to the bottom of the model, "
+                                          "'y' by the azimuth angle and 'z' by the polar angle measured "
+                                          "positive from the north pole. The grid will be assumed to be "
+                                          "a latitude-longitude grid. Note that the order "
+                                          "of spherical coordinates is 'r', 'phi', 'theta' "
+                                          "and not 'r', 'theta', 'phi', since this allows "
+                                          "for dimension independent expressions. "
+                                          "No matter which geometry model is chosen, "
+                                          "the unit of the velocities is assumed to be "
+                                          "m/s or m/yr depending on the 'Use years in output "
+                                          "instead of seconds' flag.")
+}
diff --git a/tests/ascii_boundary_member.prm.bak b/tests/ascii_boundary_member.prm.bak
new file mode 100644
index 00000000000..cfb5d0a8cd2
--- /dev/null
+++ b/tests/ascii_boundary_member.prm.bak
@@ -0,0 +1,67 @@
+##### simple test for ascii data
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:ascii boundary member,left: ascii boundary member,right: ascii boundary member,top: ascii boundary member
+
+  subsection Ascii data model
+    set Data file name       = box_2d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_adiabatic_conditions.prm.bak b/tests/ascii_data_adiabatic_conditions.prm.bak
new file mode 100644
index 00000000000..1f15c36ba47
--- /dev/null
+++ b/tests/ascii_data_adiabatic_conditions.prm.bak
@@ -0,0 +1,78 @@
+##### simple test for ascii data adiabatic conditions
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Adiabatic conditions model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name       = simple_test.txt
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = top, bottom
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = top : 3.0, bottom : 4.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2890000
+    set Y extent = 2890000
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = adiabat
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/ascii_data_boundary_composition_2d_box_time.prm.bak b/tests/ascii_data_boundary_composition_2d_box_time.prm.bak
new file mode 100644
index 00000000000..679c6d4ab18
--- /dev/null
+++ b/tests/ascii_data_boundary_composition_2d_box_time.prm.bak
@@ -0,0 +1,89 @@
+# simple test for ascii data composition
+# This test is particularly designed to test the time dependent behavior with
+# a set of files labeled with increasing file order.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 6e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1e-8*x
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Boundary composition model
+  set List of model names = ascii data
+  set Fixed composition boundary indicators   = left
+
+  subsection Ascii data model
+    set Data file name       = box_2d_%s.%d.txt
+    set Data file time step = 2e5
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top: function, bottom: function, left:function, right:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
+end
diff --git a/tests/ascii_data_boundary_composition_3d_box.prm.bak b/tests/ascii_data_boundary_composition_3d_box.prm.bak
new file mode 100644
index 00000000000..42d8d11c6d2
--- /dev/null
+++ b/tests/ascii_data_boundary_composition_3d_box.prm.bak
@@ -0,0 +1,78 @@
+##### simple test for ascii data composition
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e4
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set Z extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Boundary composition model
+  set List of model names = ascii data
+  set Fixed composition boundary indicators   = bottom,left,top,front,back
+
+  subsection Ascii data model
+    set Data file name       = box_3d_%s.0.txt
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function,front:function,back:function
+
+  subsection Function
+    set Function expression = 1;0;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
+end
diff --git a/tests/ascii_data_boundary_temperature_2d_box_time.prm.bak b/tests/ascii_data_boundary_temperature_2d_box_time.prm.bak
new file mode 100644
index 00000000000..6f0b5e41de4
--- /dev/null
+++ b/tests/ascii_data_boundary_temperature_2d_box_time.prm.bak
@@ -0,0 +1,71 @@
+##### simple test for ascii data temperature
+# This test is particularly designed to test the time dependent behavior with
+# a set of files labeled with increasing file order.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 6e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = ascii data
+  set Fixed temperature boundary indicators   = left
+
+  subsection Ascii data model
+    set Data file name       = box_2d_%s.%d.txt
+    set Data file time step = 2e5
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top: function, bottom: function, left:function, right:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_temperature_3d_box.prm.bak b/tests/ascii_data_boundary_temperature_3d_box.prm.bak
new file mode 100644
index 00000000000..d3cda5614e0
--- /dev/null
+++ b/tests/ascii_data_boundary_temperature_3d_box.prm.bak
@@ -0,0 +1,68 @@
+##### simple test for ascii data temperature
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set Z extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = ascii data
+  set Fixed temperature boundary indicators   = bottom,left,top,front,back, right
+
+  subsection Ascii data model
+    set Data file name       = box_3d_%s.0.txt
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function,front:function,back:function
+
+  subsection Function
+    set Function expression = 1;0;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_2d_box.prm.bak b/tests/ascii_data_boundary_velocity_2d_box.prm.bak
new file mode 100644
index 00000000000..e5236ee28a1
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_2d_box.prm.bak
@@ -0,0 +1,67 @@
+##### simple test for ascii data
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:ascii data,left: ascii data,right: ascii data,top: ascii data
+
+  subsection Ascii data model
+    set Data file name       = box_2d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_2d_box_list.prm.bak b/tests/ascii_data_boundary_velocity_2d_box_list.prm.bak
new file mode 100644
index 00000000000..ae78b57bd97
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_2d_box_list.prm.bak
@@ -0,0 +1,73 @@
+# test for the boundary velocity plugins, in particular for
+# summing several plugins and prescribing components on certain boundaries.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: ascii data,right: ascii data, left x: function, right: function
+  set Tangential velocity boundary indicators = top, bottom
+
+  subsection Ascii data model
+    set Data file name       = box_2d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 0.01
+  end
+
+  subsection Function
+    set Function expression = 0.01;0.0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_2d_box_time.prm.bak b/tests/ascii_data_boundary_velocity_2d_box_time.prm.bak
new file mode 100644
index 00000000000..ef4599b670f
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_2d_box_time.prm.bak
@@ -0,0 +1,74 @@
+##### simple test for ascii data
+# This test is particularly designed to test the time dependent behavior with
+# a set of files labeled with increasing file order.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 6e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top: ascii data, bottom: function, left:ascii data, right:ascii data
+
+  subsection Ascii data model
+    set Data file name       = box_2d_%s.%d.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Data file time step = 2e5
+    set Scale factor = 1
+  end
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_2d_box_time_backward.prm.bak b/tests/ascii_data_boundary_velocity_2d_box_time_backward.prm.bak
new file mode 100644
index 00000000000..9d19316854a
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_2d_box_time_backward.prm.bak
@@ -0,0 +1,77 @@
+##### simple test for ascii data
+# This test is particularly designed to test the time dependent behavior with
+# a set of files labeled with decreasing file order.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 6e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top: ascii data, bottom: function
+  set Tangential velocity boundary indicators = left,right
+
+  subsection Ascii data model
+    set Data file name       = box_2d_%s.%d.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set First data file number = 2
+    set Data file time step = 2e5
+    set Decreasing file order = true
+    set Scale factor = 1
+  end
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_2d_box_time_non_equidistant.prm.bak b/tests/ascii_data_boundary_velocity_2d_box_time_non_equidistant.prm.bak
new file mode 100644
index 00000000000..6073be5c8aa
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_2d_box_time_non_equidistant.prm.bak
@@ -0,0 +1,73 @@
+# This test is a copy of ascii_data_boundary_velocity_2d_box_time and
+# uses non equidistant data files instead.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 6e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top: ascii data, bottom: function, left:function, right:function
+
+  subsection Ascii data model
+    set Data file name       = box_2d_%s_non_equidistant.%d.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Data file time step = 2e5
+    set Scale factor = 1
+  end
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_2d_chunk.prm.bak b/tests/ascii_data_boundary_velocity_2d_chunk.prm.bak
new file mode 100644
index 00000000000..a63e6bd2799
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_2d_chunk.prm.bak
@@ -0,0 +1,72 @@
+##### simple test for ascii data
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Chunk inner radius = 3481000
+    set Chunk outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = west: ascii data,east:ascii data, inner: ascii data, outer: ascii data
+
+  subsection Ascii data model
+    set Data file name       = chunk_2d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_2d_shell.prm.bak b/tests/ascii_data_boundary_velocity_2d_shell.prm.bak
new file mode 100644
index 00000000000..fed563c6f05
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_2d_shell.prm.bak
@@ -0,0 +1,72 @@
+##### simple test for ascii data
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 3
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left: ascii data,right:ascii data, inner: ascii data, outer: ascii data
+
+  subsection Ascii data model
+    set Data file name       = shell_2d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_2d_shell_spherical.prm.bak b/tests/ascii_data_boundary_velocity_2d_shell_spherical.prm.bak
new file mode 100644
index 00000000000..97952a5cdc5
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_2d_shell_spherical.prm.bak
@@ -0,0 +1,73 @@
+##### simple test for ascii data using spherical unit vectors
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 3
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left: ascii data,right:ascii data, inner: ascii data, outer: ascii data
+
+  subsection Ascii data model
+    set Data file name       = shell_2d_%s_spherical.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 1
+    set Use spherical unit vectors = true
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_3d_box.prm.bak b/tests/ascii_data_boundary_velocity_3d_box.prm.bak
new file mode 100644
index 00000000000..c05bea3cb18
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_3d_box.prm.bak
@@ -0,0 +1,74 @@
+##### simple test for ascii data
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 3300000
+    set Z extent = 660000
+    set X repetitions = 5
+    set Y repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+
+  subsection Box
+    set Bottom temperature = 1613
+    set Top temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:ascii data,left:ascii data,right:ascii data,top:ascii data,front:ascii data,back:ascii data
+
+  subsection Ascii data model
+    set Data file name       = box_3d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_3d_chunk.prm.bak b/tests/ascii_data_boundary_velocity_3d_chunk.prm.bak
new file mode 100644
index 00000000000..f327968b210
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_3d_chunk.prm.bak
@@ -0,0 +1,75 @@
+##### simple test for ascii data
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e3
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Chunk minimum latitude = 0
+    set Chunk maximum latitude = 80
+    set Chunk inner radius = 3481000
+    set Chunk outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = west:ascii data, east:ascii data
+  set Tangential velocity boundary indicators = north, south, inner, outer
+
+  subsection Ascii data model
+    set Data file name       = chunk_3d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_3d_shell.prm.bak b/tests/ascii_data_boundary_velocity_3d_shell.prm.bak
new file mode 100644
index 00000000000..db0af6d2d5e
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_3d_shell.prm.bak
@@ -0,0 +1,72 @@
+##### simple test for ascii data
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e3
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 30
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = west:ascii data, east:ascii data, south:ascii data, inner:ascii data, outer: ascii data
+
+  subsection Ascii data model
+    set Data file name       = shell_3d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_3d_shell_spherical.prm.bak b/tests/ascii_data_boundary_velocity_3d_shell_spherical.prm.bak
new file mode 100644
index 00000000000..371d49b144e
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_3d_shell_spherical.prm.bak
@@ -0,0 +1,73 @@
+##### simple test for ascii data using spherical unit vectors
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e3
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 30
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = west:ascii data, east:ascii data, south:ascii data, inner:ascii data, outer: ascii data
+
+  subsection Ascii data model
+    set Data file name       = shell_3d_%s_spherical.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 10
+    set Use spherical unit vectors = true
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_boundary_velocity_3d_sphere.prm.bak b/tests/ascii_data_boundary_velocity_3d_sphere.prm.bak
new file mode 100644
index 00000000000..8cecf533c3d
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_3d_sphere.prm.bak
@@ -0,0 +1,70 @@
+# simple test for ascii data in a 3d sphere
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e3
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = sphere
+
+  subsection Sphere
+    set Radius = 6371000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = outer: ascii data
+
+  subsection Ascii data model
+    set Data file name       = shell_3d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Output format = vtu
+    set Interpolate output = true
+  end
+end
diff --git a/tests/ascii_data_boundary_velocity_residual_shell.prm.bak b/tests/ascii_data_boundary_velocity_residual_shell.prm.bak
new file mode 100644
index 00000000000..6717c4df7b6
--- /dev/null
+++ b/tests/ascii_data_boundary_velocity_residual_shell.prm.bak
@@ -0,0 +1,84 @@
+##### simple test for boundary velocity residual visualization object in postprocessing
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set Output directory                       = ascii_data_boundary_velocity_residual_shell
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 30
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = west:ascii data, east:ascii data, south:ascii data, inner:ascii data, outer: ascii data
+
+  subsection Ascii data model
+    set Data file name       = shell_3d_%s.0.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, boundary velocity residual statistics
+
+  subsection Visualization
+    set Output format                 = gnuplot
+    set List of output variables      = boundary velocity residual
+  end
+
+  subsection Boundary velocity residual statistics
+    set Use ascii data = true
+    set Data file name       = shell_3d_boundary_velocity.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/postprocess/boundary-velocity-residual/
+  end
+end
diff --git a/tests/ascii_data_fail_1.prm.bak b/tests/ascii_data_fail_1.prm.bak
new file mode 100644
index 00000000000..d35cc749d0f
--- /dev/null
+++ b/tests/ascii_data_fail_1.prm.bak
@@ -0,0 +1,71 @@
+# Failing test for ascii data that checks the error message
+# for bad data values.
+#
+# EXPECT FAILURE
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+  set Prescribed velocity boundary indicators = top: ascii data
+
+  subsection Ascii data model
+    set Data file name       = fail_1.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_fail_2.prm.bak b/tests/ascii_data_fail_2.prm.bak
new file mode 100644
index 00000000000..f7d6a6aec08
--- /dev/null
+++ b/tests/ascii_data_fail_2.prm.bak
@@ -0,0 +1,71 @@
+# Failing test for ascii data that checks the error message
+# for too many data values.
+#
+# EXPECT FAILURE
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+  set Prescribed velocity boundary indicators = top: ascii data
+
+  subsection Ascii data model
+    set Data file name       = fail_2.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_fail_3.prm.bak b/tests/ascii_data_fail_3.prm.bak
new file mode 100644
index 00000000000..4378da850c8
--- /dev/null
+++ b/tests/ascii_data_fail_3.prm.bak
@@ -0,0 +1,71 @@
+# Failing test for ascii data that checks the error message
+# for too few data values.
+#
+# EXPECT FAILURE
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+  set Prescribed velocity boundary indicators = top: ascii data
+
+  subsection Ascii data model
+    set Data file name       = fail_3.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_fail_4.prm.bak b/tests/ascii_data_fail_4.prm.bak
new file mode 100644
index 00000000000..e617815b2e0
--- /dev/null
+++ b/tests/ascii_data_fail_4.prm.bak
@@ -0,0 +1,71 @@
+# Failing test for ascii data that checks the error message
+# for a missing data file.
+#
+# EXPECT FAILURE
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+  set Prescribed velocity boundary indicators = top: ascii data
+
+  subsection Ascii data model
+    set Data file name       = fail_4.txt
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
+    set Scale factor = 0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_gravity.prm.bak b/tests/ascii_data_gravity.prm.bak
new file mode 100644
index 00000000000..cf738f86d25
--- /dev/null
+++ b/tests/ascii_data_gravity.prm.bak
@@ -0,0 +1,79 @@
+##### simple test for ascii data gravity profile
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Adiabatic conditions model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name       = simple_test.txt
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = top, bottom
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = top : 3.0, bottom : 4.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2890000
+    set Y extent = 2890000
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right, top
+end
+
+subsection Gravity model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name       = simple_test.txt
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = gravity
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/ascii_data_initial_composition_2d_box.prm.bak b/tests/ascii_data_initial_composition_2d_box.prm.bak
new file mode 100644
index 00000000000..b2728e7624b
--- /dev/null
+++ b/tests/ascii_data_initial_composition_2d_box.prm.bak
@@ -0,0 +1,77 @@
+##### simple test for ascii data initial composition
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
+end
diff --git a/tests/ascii_data_initial_composition_2d_box_gz.prm.bak b/tests/ascii_data_initial_composition_2d_box_gz.prm.bak
new file mode 100644
index 00000000000..cb144c82a2e
--- /dev/null
+++ b/tests/ascii_data_initial_composition_2d_box_gz.prm.bak
@@ -0,0 +1,79 @@
+# Simple test for ascii data initial composition. Like
+# ascii_data_initial_composition_2d_box, but reads in
+# a gzip compressed data file.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = box_2d.txt.gz
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
+end
diff --git a/tests/ascii_data_initial_composition_3d_chunk.prm.bak b/tests/ascii_data_initial_composition_3d_chunk.prm.bak
new file mode 100644
index 00000000000..5b942b8d0e9
--- /dev/null
+++ b/tests/ascii_data_initial_composition_3d_chunk.prm.bak
@@ -0,0 +1,85 @@
+##### simple test for ascii data initial composition
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Chunk minimum latitude = 0
+    set Chunk maximum latitude = 80
+    set Chunk inner radius = 3481000
+    set Chunk outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = north, south, east, west, inner, outer
+
+  subsection Function
+    set Function expression = 1;0;0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = shell_3d.txt
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
diff --git a/tests/ascii_data_initial_composition_3d_shell.prm.bak b/tests/ascii_data_initial_composition_3d_shell.prm.bak
new file mode 100644
index 00000000000..71e9ea174b6
--- /dev/null
+++ b/tests/ascii_data_initial_composition_3d_shell.prm.bak
@@ -0,0 +1,83 @@
+##### simple test for ascii data initial composition
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 30
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = west:function, east:function, south:function, inner:function, outer:function
+
+  subsection Function
+    set Function expression = 1;0;0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = shell_3d.txt
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_initial_temperature_2d_box.prm.bak b/tests/ascii_data_initial_temperature_2d_box.prm.bak
new file mode 100644
index 00000000000..4b7695ec194
--- /dev/null
+++ b/tests/ascii_data_initial_temperature_2d_box.prm.bak
@@ -0,0 +1,59 @@
+##### simple test for ascii data initial temperature
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_initial_temperature_3d_chunk.prm.bak b/tests/ascii_data_initial_temperature_3d_chunk.prm.bak
new file mode 100644
index 00000000000..b37f309db55
--- /dev/null
+++ b/tests/ascii_data_initial_temperature_3d_chunk.prm.bak
@@ -0,0 +1,63 @@
+##### simple test for ascii data initial temperature
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Chunk minimum latitude = 0
+    set Chunk maximum latitude = 80
+    set Chunk inner radius = 3481000
+    set Chunk outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = shell_3d.txt
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = west:function, east:function, south:function, north:function, inner:function, outer:function
+
+  subsection Function
+    set Function expression = 1;0;0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_initial_temperature_3d_ellipsoidal_chunk.prm.bak b/tests/ascii_data_initial_temperature_3d_ellipsoidal_chunk.prm.bak
new file mode 100644
index 00000000000..c98ab1e461e
--- /dev/null
+++ b/tests/ascii_data_initial_temperature_3d_ellipsoidal_chunk.prm.bak
@@ -0,0 +1,62 @@
+##### simple test for ascii data initial temperature
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = ellipsoidal chunk
+
+  subsection Ellipsoidal chunk
+    set NE corner = 90:80
+    set NW corner = 0:80
+    set SW corner = 0:0
+    set Depth = 2855000
+    set Semi-major axis = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = shell_3d.txt
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = west:function, east:function, south:function, north:function, bottom:function, top:function
+
+  subsection Function
+    set Function expression = 1;0;0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_initial_temperature_3d_shell.prm.bak b/tests/ascii_data_initial_temperature_3d_shell.prm.bak
new file mode 100644
index 00000000000..31545cb752d
--- /dev/null
+++ b/tests/ascii_data_initial_temperature_3d_shell.prm.bak
@@ -0,0 +1,60 @@
+##### simple test for ascii data initial temperature
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = shell_3d.txt
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = west:function, east:function, south:function, inner:function, outer:function
+
+  subsection Function
+    set Function expression = 1;0;0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_initial_temperature_3d_two_chunks.prm.bak b/tests/ascii_data_initial_temperature_3d_two_chunks.prm.bak
new file mode 100644
index 00000000000..fd9231419df
--- /dev/null
+++ b/tests/ascii_data_initial_temperature_3d_two_chunks.prm.bak
@@ -0,0 +1,66 @@
+##### simple test for ascii data initial temperature
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = chunk with lithosphere boundary indicators
+
+  subsection Chunk with lithosphere boundary indicators
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Chunk minimum latitude = 0
+    set Chunk maximum latitude = 80
+    set Chunk inner radius = 3481000
+    set Chunk outer radius = 6336000
+    set Chunk middle boundary radius = 4908500
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = shell_3d.txt
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = lowerwest:function, lowereast:function, upperwest:function, uppereast:function, \
+                                                lowersouth:function, lowernorth:function, uppersouth:function, uppernorth:function, \
+                                                bottom:function, top:function
+
+  subsection Function
+    set Function expression = 1;0;0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_layered_initial_composition_2d_box.prm.bak b/tests/ascii_data_layered_initial_composition_2d_box.prm.bak
new file mode 100644
index 00000000000..5004e2cc17f
--- /dev/null
+++ b/tests/ascii_data_layered_initial_composition_2d_box.prm.bak
@@ -0,0 +1,77 @@
+# This test is to check that the layered ascii data initial composition
+# plugin works in a 2D box with composition defined as piecewise constant
+# between layers.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100e3
+    set Y extent = 100e3
+    set X repetitions = 3
+    set Y repetitions = 3
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = ascii data layered
+
+  subsection Ascii data model
+    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file names       = initial_composition_top_mantle_box_2d.txt, initial_composition_top_crust_box_2d.txt
+    set Interpolation scheme  = piecewise constant
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, depth average, composition statistics
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/ascii_data_layered_initial_temperature_2d_box.prm.bak b/tests/ascii_data_layered_initial_temperature_2d_box.prm.bak
new file mode 100644
index 00000000000..11497fb0eae
--- /dev/null
+++ b/tests/ascii_data_layered_initial_temperature_2d_box.prm.bak
@@ -0,0 +1,65 @@
+# This test is to check that the layered ascii data initial temperature
+# plugin works in a 2D box with temperature defined as linear
+# between isotherms and constant below and above the
+# first and last isotherm (with a value taken from that isotherm).
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 600e3
+    set Y extent = 660e3
+    set X repetitions = 3
+    set Y repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data layered
+
+  subsection Ascii data model
+    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file names       = initial_isotherm_1000K_box_2d.txt, initial_isotherm_500K_box_2d.txt
+    set Interpolation scheme  = linear
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/ascii_data_layered_initial_temperature_2d_chunk.prm.bak b/tests/ascii_data_layered_initial_temperature_2d_chunk.prm.bak
new file mode 100644
index 00000000000..717aeda093d
--- /dev/null
+++ b/tests/ascii_data_layered_initial_temperature_2d_chunk.prm.bak
@@ -0,0 +1,67 @@
+# This test is to check that the layered ascii data initial temperature
+# plugin works in a 2D chunk with temperature defined as linear
+# between isotherms and constant below and above the
+# first and last isotherm (with a value taken from that isotherm).
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Longitude repetitions = 3
+    set Chunk inner radius = 5740e3
+    set Chunk outer radius = 6400e3
+    set Radius repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data layered
+
+  subsection Ascii data model
+    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file names       = initial_isotherm_1000K_chunk_2d.txt, initial_isotherm_500K_chunk_2d.txt
+    set Interpolation scheme  = linear
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = east, west, top, bottom
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/ascii_data_layered_initial_temperature_3d_box.prm.bak b/tests/ascii_data_layered_initial_temperature_3d_box.prm.bak
new file mode 100644
index 00000000000..8961cc862f8
--- /dev/null
+++ b/tests/ascii_data_layered_initial_temperature_3d_box.prm.bak
@@ -0,0 +1,67 @@
+# This test is to check that the layered ascii data initial temperature
+# plugin works in a 3D box with temperature defined as linear
+# between isotherms and constant below and above the
+# first and last isotherm (with a value taken from that isotherm).
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 600e3
+    set Y extent = 600e3
+    set Z extent = 660e3
+    set X repetitions = 3
+    set Y repetitions = 3
+    set Z repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data layered
+
+  subsection Ascii data model
+    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file names       = initial_isotherm_1000K_box_3d.txt, initial_isotherm_500K_box_3d.txt
+    set Interpolation scheme  = linear
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, front, back, top, bottom
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/ascii_data_layered_initial_temperature_3d_chunk.prm.bak b/tests/ascii_data_layered_initial_temperature_3d_chunk.prm.bak
new file mode 100644
index 00000000000..fdd417b8673
--- /dev/null
+++ b/tests/ascii_data_layered_initial_temperature_3d_chunk.prm.bak
@@ -0,0 +1,74 @@
+# This test is to check that the layered ascii data initial temperature
+# plugin works in a 3D chunk with temperature defined as linear
+# between isotherms and constant below and above the
+# first and last isotherm (with a value taken from that isotherm).
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Longitude repetitions = 9
+    set Chunk minimum latitude = 0
+    set Chunk maximum latitude = 80
+    set Latitude repetitions = 9
+    set Chunk inner radius = 5740000
+    set Chunk outer radius = 6400000
+    set Radius repetitions = 6
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data layered
+
+  subsection Ascii data model
+    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file names       = initial_isotherm_1000K_chunk_3d.txt, initial_isotherm_500K_chunk_3d.txt
+    set Interpolation scheme  = linear
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, outer, west, east, south, north
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Refinement fraction                = 0.95
+  set Initial global refinement          = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/ascii_data_layered_initial_temperature_piecewise_constant_3d_box.prm.bak b/tests/ascii_data_layered_initial_temperature_piecewise_constant_3d_box.prm.bak
new file mode 100644
index 00000000000..cf06ed2e041
--- /dev/null
+++ b/tests/ascii_data_layered_initial_temperature_piecewise_constant_3d_box.prm.bak
@@ -0,0 +1,66 @@
+# This test is to check that the layered ascii data initial temperature
+# plugin works in a 3D box with temperature defined as piecewise constant
+# between isotherms (with temperature taken from the overlying isotherm).
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 600e3
+    set Y extent = 600e3
+    set Z extent = 660e3
+    set X repetitions = 3
+    set Y repetitions = 3
+    set Z repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data layered
+
+  subsection Ascii data model
+    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file names       = initial_isotherm_1000K_box_3d.txt, initial_isotherm_500K_box_3d.txt
+    set Interpolation scheme  = piecewise constant
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, front, back, top, bottom
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/ascii_data_nonuniform_initial_composition_2d_box.prm.bak b/tests/ascii_data_nonuniform_initial_composition_2d_box.prm.bak
new file mode 100644
index 00000000000..6c8f58e87e4
--- /dev/null
+++ b/tests/ascii_data_nonuniform_initial_composition_2d_box.prm.bak
@@ -0,0 +1,87 @@
+##### simple test for ascii data initial composition
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = box_2d_nonuniform.txt
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = top,bottom,left
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = left
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/ascii_data_prescribed_stokes_2d_box.prm.bak b/tests/ascii_data_prescribed_stokes_2d_box.prm.bak
new file mode 100644
index 00000000000..4437e0e8a47
--- /dev/null
+++ b/tests/ascii_data_prescribed_stokes_2d_box.prm.bak
@@ -0,0 +1,73 @@
+# A test for velocity ascii files
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.005
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+# to turn stokes off and prescribe velocity
+subsection Prescribed Stokes solution
+  set Model name = ascii data
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/ascii_data_slice.prm.bak b/tests/ascii_data_slice.prm.bak
new file mode 100644
index 00000000000..2da2715dbda
--- /dev/null
+++ b/tests/ascii_data_slice.prm.bak
@@ -0,0 +1,111 @@
+# This is a test that makes sure that the ascii data slice model
+# reads in 3d files for the initial composition correctly, and
+# and then rotates them to the correct 2d plane.
+# The output was verified with a 3d version of the model, using
+# the same data file.
+
+set Dimension = 2
+set Use years in output instead of seconds = true
+set Output directory                       = ascii-data-slice
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Start time                             = 0
+set End time                               = 0
+set Adiabatic surface temperature          = 1600.0
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                         = 1e-4
+    set Stokes solver type                              = block GMG
+    set Number of cheap Stokes solver steps             = 5000
+    set GMRES solver restart length                     = 1000
+    set Maximum number of expensive Stokes solver steps = 0
+    set Use full A block as preconditioner              = true
+    set Linear solver A block tolerance                 = 1e-2
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 3
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = composition_1
+  set Compositional field methods = static
+end
+
+subsection Initial composition model
+  set List of model names = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name = shell_3d_2.txt
+    set Slice dataset in 2D plane = true
+    set First point on slice  = 0.3, -1, 0
+    set Second point on slice = 0.4, 1, -1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net surface rotation
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3700
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer    = 1e8
+    set Age bottom boundary layer = 1e8
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Material model
+  set Model name         = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Viscosity = 1e22
+    set Thermal viscosity exponent = 10.0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors         = velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables      = adiabat, material properties, gravity, nonadiabatic temperature, nonadiabatic pressure
+    set Output format  = gnuplot
+  end
+end
diff --git a/tests/ascii_data_slice_temperature.prm.bak b/tests/ascii_data_slice_temperature.prm.bak
new file mode 100644
index 00000000000..7cace560005
--- /dev/null
+++ b/tests/ascii_data_slice_temperature.prm.bak
@@ -0,0 +1,64 @@
+# This is a test that makes sure that the ascii data slice model
+# reads in 3d files for the initial temperature correctly, and
+# and then rotates them to the correct 2d plane.
+# The output was verified against the output of the ascii_data_slice
+# test.
+
+set Dimension = 2
+set Use years in output instead of seconds = true
+set Output directory                       = ascii-data-slice-temperature
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Start time                             = 0
+set End time                               = 0
+set Adiabatic surface temperature          = 1600.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top,
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net surface rotation
+end
+
+subsection Initial temperature model
+  set List of model names = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name = shell_3d_2.txt
+    set Slice dataset in 2D plane = true
+    set First point on slice  = 0.3, -1, 0
+    set Second point on slice = 0.4, 1, -1
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Material model
+  set Model name         = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Viscosity = 1e22
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors         = velocity statistics, temperature statistics
+end
diff --git a/tests/average_arithmetic.prm.bak b/tests/average_arithmetic.prm.bak
new file mode 100644
index 00000000000..31edde1d041
--- /dev/null
+++ b/tests/average_arithmetic.prm.bak
@@ -0,0 +1,95 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = arithmetic average
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/average_density_boundary_fluid_pressure.prm.bak b/tests/average_density_boundary_fluid_pressure.prm.bak
new file mode 100644
index 00000000000..4bcc12e59af
--- /dev/null
+++ b/tests/average_density_boundary_fluid_pressure.prm.bak
@@ -0,0 +1,280 @@
+# This is a variation of the melt and traction test, with the only
+# difference that it uses the product of the average (solid and melt)
+# density as the boundary fluid pressure, and that the domain is only
+# half as large in y direction so that there is melt present at the
+# lower boundary.
+
+# This is a test to see if traction boundary conditions work in models
+# with melt migration.
+# At the right and bottom boundary, the lithostatic pressure is applied,
+# so both the solid and the melt velocity should be approximately zero.
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 1600
+set Maximum time step                      = 1e6
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 20
+set Nonlinear solver tolerance             = 1e-7
+
+# In addition, melting and freezing normally happens on a much faster
+# time scale than the flow of melt, so we want to decouple the advection
+# of melt (and temperature) and the melting process itself. To do that,
+# we use the operator splitting scheme.
+set Use operator splitting                     = true
+
+# The end time of the simulation. We only do one time step.
+set End time                               = 1e5
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 100
+  end
+end
+
+# We apply the lithostatic pressure at the bottom and the right side.
+
+##################### Boundary conditions ########################
+
+# As boundary conditions for the temperature, we just use the
+# initial conditions again. This temperature is applied as a prescribed
+# temperature at the top and bottom boundary, as specified above.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3700
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function
+  set Tangential velocity boundary indicators = left
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0; 0
+  end
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom y:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Number of integration points = 10000
+    set Representative point         = 300000,150000
+  end
+end
+
+subsection Melt settings
+  # In addition, we now also specify in the model settings that we want to
+  # run a model with melt transport.
+  set Include melt transport                  = true
+end
+
+##################### Settings for melt transport ########################
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.5
+    set cR    = 1
+  end
+end
+
+##################### Initial temperature model ########################
+
+# We choose an adiabatic temperature profile as initial condition.
+subsection Initial temperature model
+  set List of model names = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 0
+    set Age top boundary layer    = 5e7
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+end
+
+# Now that our model uses compositional fields, we also need initial
+# conditions for the composition.
+# We use the function plugin to set both fields to zero at the beginning
+# of the model run.
+subsection Initial composition model
+  set List of model names = function, porosity
+
+  subsection Function
+    set Function expression = 0; 0
+    set Variable names      = x,y
+  end
+end
+
+# We again choose the initial composition as boundary condition
+# for all compositional fields.
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Models with melt transport also need an additional boundary condition.
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = average density
+  end
+end
+
+##################### Model geometry ########################
+
+# The model geometry is a square with a dimension of 300 km.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 300000
+    set Y extent = 150000
+    set X repetitions = 2
+  end
+end
+
+################ Gravity and material properties ##################
+
+# The model has a constant gravity.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We use the melt global material model, which is one of the
+# material models that works with melt transport, as it also
+# specifies the material properties needed for melt migration,
+# such as the permeability, the melt density and the melt
+# viscosity.
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    # First we describe the parameters for the solid, in the same way
+    # we did in the model without melt transport
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Thermal expansion coefficient     = 2e-5
+    set Reference shear viscosity         = 5e21
+    set Thermal viscosity exponent        = 7
+    set Reference temperature             = 1600
+
+    # The melt usually has a different (lower) density than the solid.
+    set Reference melt density            = 3400
+
+    # The permeability describes how well the pores of a porous material
+    # are connected (and hence how fast melt can flow through the rock).
+    # It is computed as the product of the reference value given here
+    # and the porosity cubed. This means that the lower the porosity is
+    # the more difficult it is for the melt to flow.
+    set Reference permeability            = 1e-8
+
+    # The bulk viscosity describes the resistance of the rock to dilation
+    # and compaction. Melt can only flow into a region that had no melt
+    # before if the matrix of the solid rock expands, so this parameter
+    # also limits how fast melt can flow upwards.
+    # The bulk viscosity is computed as the reference value given here times
+    # a term that scales with one over the porosity. This means that for zero
+    # porosity, the rock can not dilate/compact any more, which is the same
+    # behavior that we have for solid mantle convection.
+    set Reference bulk viscosity          = 1e19
+
+    # In dependence of how much melt is present, we also weaken the shear
+    # viscosity: The more melt is present, the weaker the rock gets.
+    # This scaling is exponential, following the relation
+    # viscosity ~ exp(-alpha * phi),
+    # where alpha is the parameter given here, and phi is the porosity.
+    set Exponential melt weakening factor = 10
+
+    # In the same way the shear viscosity is reduced with increasing temperature,
+    # we also prescribe the temperature-dependence of the bulk viscosity.
+    set Thermal bulk viscosity exponent   = 7
+
+    # Finally, we prescribe the viscosity of the melt, which is used in Darcy's
+    # law. The lower this viscosity, the faster melt can flow.
+    set Reference melt viscosity          = 1
+
+    # change the density contrast of depleted material (in kg/m^3)
+    set Depletion density change          = -200.0
+
+    # How much melt has been generated and subsequently extracted from a particular
+    # volume of rock (how 'depleted' that volume of rock is) usually changes the
+    # solidus. The more the material has been molten already, the less melt will be
+    # generated afterwards for the same pressure and temperature conditions. We
+    # model this using a simplified, linear relationship, saying that to melt 100%
+    # of the rock the temperature has to be 200 K higher than to melt it initially.
+    set Depletion solidus change          = 200
+    set Melting time scale for operator splitting = 1e100
+    set Include melting and freezing      = false
+  end
+end
+
+##################### Mesh refinement #########################
+
+# For the model with melt migration, we use adaptive refinement.
+# We make use of two different refinement criteria: we set a minimum of 4 global
+# refinements everywhere in the model (which is the same resolution as for the
+# model without melt), and we refine in regions where melt is present, to be
+# precise, everywhere where the porosity is bigger than 1e-4.
+# We adapt the mesh every 5 time steps.
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Time steps between mesh refinement       = 0
+end
+
+# As the model is compressible and has an adiabatic temperature profile, we include
+# adiabatic heating in the list of heating models.
+# To make this model as simple as possible, we do not include shear heating (although
+# usually, adiabatic heating and shear heating should always be used together).
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+##################### Postprocessing ########################
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, mass flux statistics
+  set Run postprocessors on nonlinear iterations = true
+
+  # For the model with melt migration, also add a visualization
+  # postprocessor that computes the material properties relevant
+  # to migration (permeability, viscosity of the melt, etc.).
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt material properties, nonadiabatic pressure
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Interpolate output            = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
diff --git a/tests/average_geometric.prm.bak b/tests/average_geometric.prm.bak
new file mode 100644
index 00000000000..d6180a92947
--- /dev/null
+++ b/tests/average_geometric.prm.bak
@@ -0,0 +1,95 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = geometric average
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/average_harmonic.prm.bak b/tests/average_harmonic.prm.bak
new file mode 100644
index 00000000000..274123e9149
--- /dev/null
+++ b/tests/average_harmonic.prm.bak
@@ -0,0 +1,95 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0.0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/average_log.prm.bak b/tests/average_log.prm.bak
new file mode 100644
index 00000000000..dc68193c475
--- /dev/null
+++ b/tests/average_log.prm.bak
@@ -0,0 +1,95 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = log average
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/average_none.prm.bak b/tests/average_none.prm.bak
new file mode 100644
index 00000000000..98a00d4c28b
--- /dev/null
+++ b/tests/average_none.prm.bak
@@ -0,0 +1,96 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = none
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set Stokes solver type = block AMG
+  end
+end
diff --git a/tests/average_nwd_arithmetic.prm.bak b/tests/average_nwd_arithmetic.prm.bak
new file mode 100644
index 00000000000..f0051d92b35
--- /dev/null
+++ b/tests/average_nwd_arithmetic.prm.bak
@@ -0,0 +1,100 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = averaging
+
+  subsection Averaging
+    set Base model = simple
+    set Averaging operation =  nwd arithmetic average
+    set Bell shape limit = 0.75
+  end
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/average_nwd_geometric.prm.bak b/tests/average_nwd_geometric.prm.bak
new file mode 100644
index 00000000000..2659f74c1c8
--- /dev/null
+++ b/tests/average_nwd_geometric.prm.bak
@@ -0,0 +1,100 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = averaging
+
+  subsection Averaging
+    set Base model = simple
+    set Averaging operation =  nwd geometric average
+    set Bell shape limit = 0.75
+  end
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/average_nwd_harmonic.prm.bak b/tests/average_nwd_harmonic.prm.bak
new file mode 100644
index 00000000000..80b00d47730
--- /dev/null
+++ b/tests/average_nwd_harmonic.prm.bak
@@ -0,0 +1,100 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = averaging
+
+  subsection Averaging
+    set Base model = simple
+    set Averaging operation =  nwd harmonic average
+    set Bell shape limit = 0.75
+  end
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/average_pick_largest.prm.bak b/tests/average_pick_largest.prm.bak
new file mode 100644
index 00000000000..edf84cd415f
--- /dev/null
+++ b/tests/average_pick_largest.prm.bak
@@ -0,0 +1,95 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = pick largest
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/average_project_to_q1.prm.bak b/tests/average_project_to_q1.prm.bak
new file mode 100644
index 00000000000..67878e1e410
--- /dev/null
+++ b/tests/average_project_to_q1.prm.bak
@@ -0,0 +1,96 @@
+# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for the different kinds of averaging operations
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = project to Q1
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set Number of cheap Stokes solver steps = 1000
+  end
+end
diff --git a/tests/background_output_writer.prm.bak b/tests/background_output_writer.prm.bak
new file mode 100644
index 00000000000..08cd6fd00f9
--- /dev/null
+++ b/tests/background_output_writer.prm.bak
@@ -0,0 +1,14 @@
+# This is a copy of the maximum_refinement_function_spherical test,
+# but the real purpose of the test is to check that writing data in
+# the background actually works.
+
+# MPI: 2
+
+include $ASPECT_SOURCE_DIR/tests/maximum_refinement_function_spherical.prm
+
+
+subsection Postprocess
+  subsection Visualization
+    set Write in background thread = true
+  end
+end
diff --git a/tests/backward_advection.prm.bak b/tests/backward_advection.prm.bak
new file mode 100644
index 00000000000..7901867684d
--- /dev/null
+++ b/tests/backward_advection.prm.bak
@@ -0,0 +1,84 @@
+# Test the spherical hexagonal perturbation initial temperature model
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = -9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 360
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          =  0 #1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Additional refinement times              =
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = basic statistics, visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/benchmark_layeredflow.cc.bak b/tests/benchmark_layeredflow.cc.bak
new file mode 100644
index 00000000000..12e621ee1e6
--- /dev/null
+++ b/tests/benchmark_layeredflow.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/layeredflow/layeredflow.cc"
diff --git a/tests/benchmark_layeredflow.prm.bak b/tests/benchmark_layeredflow.prm.bak
new file mode 100644
index 00000000000..3f44415ac8b
--- /dev/null
+++ b/tests/benchmark_layeredflow.prm.bak
@@ -0,0 +1,13 @@
+# test for benchmarks/layeredflow/
+
+include $ASPECT_SOURCE_DIR/benchmarks/layeredflow/layeredflow.prm
+
+set Dimension                              = 2
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, LayeredFlowPostprocessor
+end
diff --git a/tests/benchmark_particle_integration_scheme.prm.bak b/tests/benchmark_particle_integration_scheme.prm.bak
new file mode 100644
index 00000000000..dbff68e5758
--- /dev/null
+++ b/tests/benchmark_particle_integration_scheme.prm.bak
@@ -0,0 +1,7 @@
+# A benchmark of particle integration schemes in Gassmoller 2018
+#  See the benchmark folder for more information.
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/particle_integration_scheme/circle.prm
+
+set End time = 0.1
diff --git a/tests/blankenbach.prm.bak b/tests/blankenbach.prm.bak
new file mode 100644
index 00000000000..099d601074a
--- /dev/null
+++ b/tests/blankenbach.prm.bak
@@ -0,0 +1,80 @@
+# Listing of Parameters
+# ---------------------
+# This case is identical to case 1a from the Blankenbach Benchmark
+# (Blankenbach 1989). Cases b and c can be run by changing the
+# Viscosity to 1e-5 and 1e-6, respectively, which leads to the
+# corresponding change of the Rayleigh number from 1e4 to 1e5 and
+# 1e6. This test essentially resembles the convection-box cookbook
+# and reproduces its results very closely (a slight difference results
+# from the different refinement levels).
+# The relevant output is the vrms velocity and the heat flux through
+# the top boundary, which in this setup is identical to the Nu number.
+
+set End time                               = 0.002 # 1.0 for full benchmark
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e3
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-3
+    set Viscosity                     = 1e-4
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/blankenbach_approximation.prm.bak b/tests/blankenbach_approximation.prm.bak
new file mode 100644
index 00000000000..c4ff6f6b5f1
--- /dev/null
+++ b/tests/blankenbach_approximation.prm.bak
@@ -0,0 +1,93 @@
+# Like blankenbach.prm but with the BA approximation, so we can rescale
+# parameters however we want.
+
+set End time                               = 0.002 # 1.0 for full benchmark
+set Use years in output instead of seconds = false
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0; 0; 1
+    set Variable names      = depth
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e4
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation # this overwrites the parameters below
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1e-10
+    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
+  end
+end
diff --git a/tests/blankenbach_case1a.cc.bak b/tests/blankenbach_case1a.cc.bak
new file mode 100644
index 00000000000..db7193d6fc8
--- /dev/null
+++ b/tests/blankenbach_case1a.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/blankenbach/plugin/code.cc"
+#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case1a.prm.bak b/tests/blankenbach_case1a.prm.bak
new file mode 100644
index 00000000000..5ad4ad90282
--- /dev/null
+++ b/tests/blankenbach_case1a.prm.bak
@@ -0,0 +1,20 @@
+# blankenbach case 1a as described in benchmarks/blankenbach/README.md
+
+include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case1a.prm
+
+set End time                               = 0.02
+set CFL number = 5.0
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
+end
diff --git a/tests/blankenbach_case1b.cc.bak b/tests/blankenbach_case1b.cc.bak
new file mode 100644
index 00000000000..db7193d6fc8
--- /dev/null
+++ b/tests/blankenbach_case1b.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/blankenbach/plugin/code.cc"
+#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case1b.prm.bak b/tests/blankenbach_case1b.prm.bak
new file mode 100644
index 00000000000..6ba5a0311c3
--- /dev/null
+++ b/tests/blankenbach_case1b.prm.bak
@@ -0,0 +1,26 @@
+# blankenbach case 1b as described in benchmarks/blankenbach/README.md
+
+include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case1a.prm
+
+set End time                               = 0.02
+set CFL number = 5.0
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  subsection Nondimensional model
+    set Ra                      = 1e5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
+end
diff --git a/tests/blankenbach_case1c.cc.bak b/tests/blankenbach_case1c.cc.bak
new file mode 100644
index 00000000000..db7193d6fc8
--- /dev/null
+++ b/tests/blankenbach_case1c.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/blankenbach/plugin/code.cc"
+#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case1c.prm.bak b/tests/blankenbach_case1c.prm.bak
new file mode 100644
index 00000000000..b44962394c5
--- /dev/null
+++ b/tests/blankenbach_case1c.prm.bak
@@ -0,0 +1,26 @@
+# blankenbach case 1c as described in benchmarks/blankenbach/README.md
+
+include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case1a.prm
+
+set End time                               = 0.02
+set CFL number = 5.0
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  subsection Nondimensional model
+    set Ra                      = 1e6
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
+end
diff --git a/tests/blankenbach_case2a.cc.bak b/tests/blankenbach_case2a.cc.bak
new file mode 100644
index 00000000000..db7193d6fc8
--- /dev/null
+++ b/tests/blankenbach_case2a.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/blankenbach/plugin/code.cc"
+#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case2a.prm.bak b/tests/blankenbach_case2a.prm.bak
new file mode 100644
index 00000000000..f60a83a88dc
--- /dev/null
+++ b/tests/blankenbach_case2a.prm.bak
@@ -0,0 +1,20 @@
+# blankenbach case 2a as described in benchmarks/blankenbach/README.md
+
+include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case2a.prm
+
+set End time                               = 0.02
+set CFL number = 5.0
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
+end
diff --git a/tests/blankenbach_case2b.cc.bak b/tests/blankenbach_case2b.cc.bak
new file mode 100644
index 00000000000..db7193d6fc8
--- /dev/null
+++ b/tests/blankenbach_case2b.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/blankenbach/plugin/code.cc"
+#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case2b.prm.bak b/tests/blankenbach_case2b.prm.bak
new file mode 100644
index 00000000000..3326d8e2b55
--- /dev/null
+++ b/tests/blankenbach_case2b.prm.bak
@@ -0,0 +1,20 @@
+# blankenbach case 2b as described in benchmarks/blankenbach/README.md
+
+include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case2b.prm
+
+set End time                               = 0.006
+set CFL number = 5.0
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1, ratio=2.5
+    set Function expression = 1* ((1.0-z/L) + p*cos(k*pi*x/L/ratio)*sin(pi*z/L))
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
+end
diff --git a/tests/boukare_bulk_composition.prm b/tests/boukare_bulk_composition.prm
index f27f707aa8c..1bf3548a74f 100644
--- a/tests/boukare_bulk_composition.prm
+++ b/tests/boukare_bulk_composition.prm
@@ -13,7 +13,7 @@ set CFL number                             = 1.0
 set Use years in output instead of seconds = true
 set End time                               = 6e5
 set Output directory                       = output_bulk_3
-set Nonlinear solver scheme                = iterated IMPES
+set Nonlinear solver scheme                = iterated Advection and Stokes
 set Max nonlinear iterations               = 10
 set Nonlinear solver tolerance             = 1e-4
 set Pressure normalization                 = surface
@@ -114,7 +114,7 @@ end
 subsection Boundary composition model
   set Allow fixed composition on outflow boundaries = false
   set Fixed composition boundary indicators   = top
-  set Model name = initial composition
+  set List of model names = initial composition
 end
 
 subsection Heating model
diff --git a/tests/boukare_bulk_composition.prm.bak b/tests/boukare_bulk_composition.prm.bak
new file mode 100644
index 00000000000..f27f707aa8c
--- /dev/null
+++ b/tests/boukare_bulk_composition.prm.bak
@@ -0,0 +1,211 @@
+# Simplified setup of convection in the lowermost mantle
+# on a small scale, but melt is not allowed to move.
+# That means that the bulk composition should be conserved
+# everywhere in the domain at 0.07
+# (except maybe at the inflow boundary).
+
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set CFL number                             = 1.0
+set Use years in output instead of seconds = true
+set End time                               = 6e5
+set Output directory                       = output_bulk_3
+set Nonlinear solver scheme                = iterated IMPES
+set Max nonlinear iterations               = 10
+set Nonlinear solver tolerance             = 1e-4
+set Pressure normalization                 = surface
+set Surface pressure                       = 1.34888e+11
+set Adiabatic surface temperature          = 2510
+set Use conduction timestep                = true
+set Use operator splitting                 = true
+
+#set Maximum time step                      = 2e5
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
+end
+
+subsection Melt settings
+  set Include melt transport               = true
+  set Melt scaling factor threshold        = 1e20 #1e-8
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set GMRES solver restart length = 200
+  end
+
+  subsection Operator splitting parameters
+    set Reaction time step                     = 5e3
+    set Reaction solver type                   = fixed step
+  end
+end
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 40000
+    set Y extent = 20000
+    set X periodic = false
+    set X repetitions = 2
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 1e8
+
+    subsection Function
+      set Function expression = 0; 0.07; 0.49
+    end
+  end
+
+  subsection Function
+    set Function constants  = amplitude=500, width=50000, b=100000, x0=0 #25000
+    set Function expression = 10 * exp(-((x-x0)*(x-x0)/(2*5000*5000)+y*y/(2*5000*5000)))
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function #, porosity
+
+  subsection Function
+    set Function expression = 0; 0.07; 0.49
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       =
+  set Prescribed velocity boundary indicators = bottom:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Function constants  = amplitude=500, width=50000, b=100000, x0=0 #25000
+    set Function expression = if(y>10000,0.001*sin(3.1416*x/40000),-0.001*sin(3.1416*x/40000));0
+  end
+end
+
+subsection Boundary temperature model
+  set Allow fixed temperature on outflow boundaries = false
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Maximal temperature = 4000
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+  set Fixed composition boundary indicators   = top
+  set Model name = initial composition
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating, latent heat melt
+
+  subsection Latent heat melt
+    set Melting entropy change = 0
+    set Retrieve entropy change from material model = true
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Material model
+  set Model name = melt boukare
+
+  subsection Melt boukare
+    set Thermal conductivity          = 8.5
+    set Reference shear viscosity     = 5e22
+    set Reference bulk viscosity      = 5e22
+    set Thermal viscosity exponent    = 10
+    set Thermal bulk viscosity exponent    = 10
+    set Exponential melt weakening factor    = 15
+    set Melting time scale for operator splitting = 5e4 #5e3
+    set Fe mantle melting temperature = 2824.5 #default: 3424.5
+    set Mg mantle melting temperature = 4221.2 #default: 4821.2
+    set Reference permeability        = 5e-13
+    set Include melting and freezing  = true
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 1  # maybe start with 5+2, and then change to 5+4 for the restart
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = minimum refinement function
+  set Minimum refinement level                 = 3
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Function expression = if(y<4000,4,3)
+  end
+
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-5, 1, 1
+  end
+end
+
+subsection Boundary fluid pressure model
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 6e5
+    set List of output variables = material properties, nonadiabatic temperature, melt fraction, melt material properties, named additional outputs
+    set Output format = gnuplot
+    set Interpolate output = false
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
+    end
+
+    subsection Melt material properties
+      set List of properties = compaction viscosity, permeability, fluid density
+    end
+  end
+end
diff --git a/tests/boukare_conserve_mass.prm b/tests/boukare_conserve_mass.prm
index 992bdf8b545..51fe5e3a3de 100644
--- a/tests/boukare_conserve_mass.prm
+++ b/tests/boukare_conserve_mass.prm
@@ -12,7 +12,7 @@ set Dimension                              = 2
 set CFL number                             = 1.0
 set Use years in output instead of seconds = true
 set End time                               = 1e5
-set Nonlinear solver scheme                = iterated IMPES
+set Nonlinear solver scheme                = iterated Advection and Stokes
 set Max nonlinear iterations               = 20
 set Nonlinear solver tolerance             = 1e-4
 set Pressure normalization                 = surface
@@ -87,7 +87,7 @@ end
 subsection Boundary composition model
   set Allow fixed composition on outflow boundaries = false
   set Fixed composition boundary indicators   = top
-  set Model name = initial composition
+  set List of model names = initial composition
 end
 
 subsection Heating model
diff --git a/tests/boukare_conserve_mass.prm.bak b/tests/boukare_conserve_mass.prm.bak
new file mode 100644
index 00000000000..992bdf8b545
--- /dev/null
+++ b/tests/boukare_conserve_mass.prm.bak
@@ -0,0 +1,159 @@
+# This setup checks that mass is conserved when reactions occur.
+# The model starts with a Gaussian porosity distributon that
+# solidifies over time, decreasing the density in the model.
+# According to this change in mass, material flows out of the box
+# at the top. At refinement 5, the outflow should be about
+# 2336 kg/yr in the first time step and 819 kg/yr in the second
+# time step (they should equal the product of the change in mass
+# of the porosity field and the density difference between melt
+# and solid of 72.3 kg/m^3, divided by the time step size).
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set Use years in output instead of seconds = true
+set End time                               = 1e5
+set Nonlinear solver scheme                = iterated IMPES
+set Max nonlinear iterations               = 20
+set Nonlinear solver tolerance             = 1e-4
+set Pressure normalization                 = surface
+set Surface pressure                       = 1.35e+11
+set Adiabatic surface temperature          = 2510
+set Use operator splitting                 = true
+set Maximum time step                      = 5e4
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
+end
+
+subsection Melt settings
+  set Include melt transport               = true
+  set Melt scaling factor threshold        = 1e-8
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set GMRES solver restart length = 200
+    set Linear solver S block tolerance = 1e-5
+  end
+
+  subsection Operator splitting parameters
+    set Reaction time step                     = 5e2
+    set Reaction solver type                   = fixed step
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 20000
+    set Y extent = 20000
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 0
+
+    subsection Function
+      set Function expression = 0; 0.07; 0.49
+    end
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = width=2000, x0=10000
+    set Function expression = 0.1 * exp(-((x-x0)*(x-x0)/(2*width*width)+(y-x0)*(y-x0)/(2*width*width))); 0.07; 0.07
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+end
+
+subsection Boundary temperature model
+  set Allow fixed temperature on outflow boundaries = false
+  set Fixed temperature boundary indicators   = top
+  set List of model names = initial temperature
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+  set Fixed composition boundary indicators   = top
+  set Model name = initial composition
+end
+
+subsection Heating model
+  set List of model names =
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = melt boukare
+
+  subsection Melt boukare
+    set Thermal conductivity          = 8.5
+    set Reference shear viscosity     = 1e19
+    set Reference bulk viscosity      = 1e19
+    set Reference volumes             = 2.534e-05, 2.445e-05, 1.206e-05, 1.125e-05, 1.3e-5, 1.218e-05, 1.218e-05
+    set Thermal viscosity exponent    = 0
+    set Thermal bulk viscosity exponent = 0
+    set Exponential melt weakening factor = 0
+    set Melting time scale for operator splitting = 5e4
+    set Fe mantle melting temperature = 2824.5 #default: 3424.5
+    set Mg mantle melting temperature = 4221.2 #default: 4821.2
+    set Reference permeability        = 5e-13
+    set Include melting and freezing  = true
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Function expression = if(y<4000,4,3)
+  end
+end
+
+subsection Boundary fluid pressure model
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, composition statistics, mass flux statistics
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set List of output variables = material properties, nonadiabatic temperature, melt fraction, melt material properties, named additional outputs
+
+    #    set Output format = gnuplot
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
+    end
+
+    subsection Melt material properties
+      set List of properties = compaction viscosity, permeability, fluid density
+    end
+  end
+end
diff --git a/tests/boukare_latent_heat.prm b/tests/boukare_latent_heat.prm
index ce06e480c7f..9d758dca743 100644
--- a/tests/boukare_latent_heat.prm
+++ b/tests/boukare_latent_heat.prm
@@ -105,7 +105,7 @@ end
 
 subsection Boundary composition model
   set Allow fixed composition on outflow boundaries = false
-  set Model name = initial composition
+  set List of model names = initial composition
 end
 
 subsection Heating model
diff --git a/tests/boukare_latent_heat.prm.bak b/tests/boukare_latent_heat.prm.bak
new file mode 100644
index 00000000000..ce06e480c7f
--- /dev/null
+++ b/tests/boukare_latent_heat.prm.bak
@@ -0,0 +1,166 @@
+# This is a test for the latent heat release and consumption
+# in the melt boukare material model. The initial temperature
+# is set to a value that is out of equilibrium with the initial
+# porosity in the model, specifically, it is set so high that
+# the energy released by reducing the temperature to the solidus
+# allows for melting of approximately 10% of the material. This
+# means that the steady-state melt fraction at the end of the
+# model run should be 0.1.
+# The test also outputs the bulk composition to make sure it is
+# conserved (it should be 0.001).
+
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 15
+set Maximum time step                      = 0.1
+set Output directory                       = output_latent_heat
+set Nonlinear solver scheme                = single Advection, no Stokes
+set Max nonlinear iterations               = 3
+set Pressure normalization                 = surface
+set Surface pressure                       = 120.e9
+set Adiabatic surface temperature          = 4817.17773612
+set Use operator splitting = true
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Function expression = 0;0
+  end
+
+  subsection Pressure function
+    set Function expression = 120.e9
+  end
+
+  subsection Fluid pressure function
+    set Function expression = 120.e9
+  end
+
+  subsection Compaction pressure function
+    set Function expression = 0
+  end
+
+  subsection Fluid velocity function
+    set Function expression = 0;0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
+end
+
+subsection Melt settings
+  set Include melt transport               = true
+  set Melt scaling factor threshold        = 1e-8
+  set Use discontinuous compaction pressure = false
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+
+  subsection Operator splitting parameters
+    set Reaction time step                     = 0.1
+    set Reaction solver type                   = fixed step
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 5096.848501701
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 0; 0.001; 0.001
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       =
+  set Prescribed velocity boundary indicators =
+
+  #  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+  set Model name = initial composition
+end
+
+subsection Heating model
+  set List of model names = latent heat melt
+
+  subsection Latent heat melt
+    set Melting entropy change = 0
+    set Retrieve entropy change from material model = true
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = melt boukare
+
+  subsection Melt boukare
+    set Thermal conductivity          = 0
+    set Reference shear viscosity     = 5e22
+    set Thermal viscosity exponent    = 0
+    set Exponential melt weakening factor    = 0
+    set Include melting and freezing  = true
+    set Melting time scale for operator splitting = 50
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Minimum refinement level                 = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, composition statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set Output format = gnuplot
+    set List of output variables = material properties, nonadiabatic temperature, melt fraction, named additional outputs
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
+    end
+  end
+end
diff --git a/tests/boukare_melting_diagram.prm.bak b/tests/boukare_melting_diagram.prm.bak
new file mode 100644
index 00000000000..4d8d19d7544
--- /dev/null
+++ b/tests/boukare_melting_diagram.prm.bak
@@ -0,0 +1,162 @@
+# This is a test for the melt fraction computation.
+# The gnuplot output of time step zero should show the binary loop
+# melting model, with a zero melt fraction below the solidus,
+# and a melt fraction of 1 above the solidus.
+
+# To plot the output:
+# gnuplot
+# set view map
+# splot "solution-00000.0000.gnuplot" using 1:2:20 palette
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Maximum time step                      = 1e3
+set Output directory                       = output_melting_diagram2
+set Nonlinear solver scheme                = first timestep only, single Stokes
+set Max nonlinear iterations               = 3
+set Pressure normalization                 = surface
+set Surface pressure                       = 120.e9
+set Adiabatic surface temperature          = 5000
+set Use conduction timestep                = true
+set Use operator splitting = true
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
+end
+
+subsection Melt settings
+  set Include melt transport               = true
+  set Melt scaling factor threshold        = 1e6
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+
+  subsection Operator splitting parameters
+    set Reaction time step                     = 100000.0
+    set Reaction solver type                   = fixed step
+  end
+end
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 0.9999998
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = amplitude=500, width=50000, b=100000
+    set Function expression = 3400 + 1600 * y
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 0; x+1e-7; x+1e-7
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       =
+  set Prescribed velocity boundary indicators =
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Heating model
+  set List of model names =
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = melt boukare
+
+  subsection Melt boukare
+    set Thermal conductivity          = 8.5
+    set Reference shear viscosity     = 5e22
+    set Thermal viscosity exponent    = 10
+    set Exponential melt weakening factor    = 0
+    set Include melting and freezing  = false #true
+    set Melting time scale for operator splitting = 1e15
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = composition threshold
+  set Minimum refinement level                 = 0
+
+  subsection Composition threshold
+    set Compositional field thresholds = 0.01,1,1
+  end
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set List of output variables = material properties, nonadiabatic temperature, melt fraction
+    set Output format = gnuplot
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
+    end
+  end
+end
+
+subsection Checkpointing
+  # The wall time between performing checkpoints. If 0, will use the
+  # checkpoint step frequency instead. Units: Seconds.
+  set Time between checkpoint  = 900
+end
diff --git a/tests/boundary_composition_list.prm.bak b/tests/boundary_composition_list.prm.bak
new file mode 100644
index 00000000000..2086b70a2fa
--- /dev/null
+++ b/tests/boundary_composition_list.prm.bak
@@ -0,0 +1,103 @@
+# simple test for using multiple boundary temperature plugins
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Boundary composition model
+  set List of model names = box, function, initial composition
+  set List of model operators = maximum, subtract, add
+  set Fixed composition boundary indicators   = top,left,bottom,right
+
+  subsection Box
+    set Left composition = 15
+    set Right composition = 0
+    set Top composition = 0
+    set Bottom composition = 7
+  end
+
+  subsection Function
+    set Function expression = if (x>500000,3,0)
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-1,1.5)
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-1,1.5)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box, constant, function, initial temperature
+  set List of model operators = maximum, add, subtract, add
+  set Fixed temperature boundary indicators   = top,left,bottom,right
+
+  subsection Box
+    set Left temperature = 15
+  end
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = bottom:7, left:0, top:0, right:0
+  end
+
+  subsection Function
+    set Function expression = if (x>500000,3,0)
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
diff --git a/tests/boundary_composition_passive_cartesian.prm.bak b/tests/boundary_composition_passive_cartesian.prm.bak
new file mode 100644
index 00000000000..9180c917cd3
--- /dev/null
+++ b/tests/boundary_composition_passive_cartesian.prm.bak
@@ -0,0 +1,102 @@
+#########################################################
+# This is a variation of the platelike-boundary.prm file.
+# All settings are exactly the same with the exception
+# of the ones that pertain to compositional fields.
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = top, bottom, left, right
+  set List of model names = function
+
+  subsection Function
+    set Variable names      = x, y
+    set Coordinate system   = cartesian
+    set Function expression = if(y<0.2, 1,  0) ; if(y>0.5, 1, 0)
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
diff --git a/tests/boundary_composition_passive_depth.prm.bak b/tests/boundary_composition_passive_depth.prm.bak
new file mode 100644
index 00000000000..012399661e8
--- /dev/null
+++ b/tests/boundary_composition_passive_depth.prm.bak
@@ -0,0 +1,102 @@
+#########################################################
+# This is a variation of the platelike-boundary.prm file.
+# All settings are exactly the same with the exception
+# of the ones that pertain to compositional fields.
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = top, bottom, left, right
+  set List of model names = function
+
+  subsection Function
+    set Variable names      = depth,y
+    set Coordinate system   = depth
+    set Function expression = if(depth>0.8, 1,  0) ; if(depth<0.5, 1, 0)
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
diff --git a/tests/boundary_composition_passive_sphere.prm.bak b/tests/boundary_composition_passive_sphere.prm.bak
new file mode 100644
index 00000000000..5abbacf021b
--- /dev/null
+++ b/tests/boundary_composition_passive_sphere.prm.bak
@@ -0,0 +1,102 @@
+#########################################################
+# This is a variation of the platelike-boundary.prm file.
+# All settings are exactly the same with the exception
+# of the ones that pertain to compositional fields.
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = .45
+    set Outer radius  = 1
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer, left, right
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = inner, outer, left, right
+  set List of model names = function
+
+  subsection Function
+    set Variable names      = r, theta
+    set Coordinate system   = spherical
+    set Function expression = if(r<0.5, 1,  0) ; if(theta>0.8, 1, 0)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system   = spherical
+    set Variable names      = r,phi
+    set Function expression = (1-r)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
diff --git a/tests/boundary_heatflux.prm.bak b/tests/boundary_heatflux.prm.bak
new file mode 100644
index 00000000000..a9f866495c6
--- /dev/null
+++ b/tests/boundary_heatflux.prm.bak
@@ -0,0 +1,124 @@
+# This test is used to check if the heat flux boundary conditions
+# work correctly. It prescribes a zero heat flux at the sides, a
+# basal heat flow of 4 mW/m^2 and a surface temperature of 90 K.
+# Presently, we use a conductivity of
+# 2.38 (the conductivity of ice at 273 K). This test should yield a
+# temperature of approximately 420 K at the base of the model.
+
+#           Ts = 90 K
+#      ------------------
+#      |                |
+#      |                |   flux = 0 at sides
+#      |                |
+#      ------------------
+#        q = 4 mW / m^2
+#
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 2.5e14
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 90  # -183°C adiabat
+set Use conduction timestep                = true
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 20000
+  end
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.42
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
+
+  subsection Function
+    set Function expression = 0;0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top
+  set List of model names = initial temperature
+end
+
+subsection Boundary heat flux model
+  set Fixed heat flux boundary indicators = bottom
+  set Model name = function
+
+  subsection Function
+    set Function expression = -0.04
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density        = 950
+    set Reference specific heat  = 1000
+    set Reference temperature    = 273
+    set Thermal conductivity     = 2.38
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization.
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =  heat flux map
+  end
+end
diff --git a/tests/boundary_heatflux_update.cc.bak b/tests/boundary_heatflux_update.cc.bak
new file mode 100644
index 00000000000..662e4cbcc07
--- /dev/null
+++ b/tests/boundary_heatflux_update.cc.bak
@@ -0,0 +1,108 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/boundary_heat_flux/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/base/parsed_function.h>
+#include <aspect/global.h>
+#include <deal.II/base/signaling_nan.h>
+
+namespace aspect
+{
+  namespace BoundaryHeatFlux
+  {
+    using namespace dealii;
+
+    /**
+     * A class that implements heat flux boundary conditions based on a
+     * functional description provided in the input file.
+     *
+     * @ingroup BoundaryHeatFlux
+     */
+    template <int dim>
+    class Update : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Return the boundary heat flux as a function of position.
+         */
+        virtual
+        std::vector<Tensor<1,dim>>
+        heat_flux (const types::boundary_id /*boundary_indicator*/,
+                   const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+                   const MaterialModel::MaterialModelOutputs<dim> &/*material_model_outputs*/,
+                   const std::vector<Tensor<1,dim>> &normal_vectors) const
+        {
+          std::vector<Tensor<1,dim>> heat_flux(normal_vectors);
+          const unsigned int n_evaluation_points = material_model_inputs.position.size();
+          for (unsigned int i=0; i<n_evaluation_points; ++i)
+            heat_flux[i] *= timestep * (-1.e-4);
+          return heat_flux;
+        }
+
+        /**
+         * Initialization function. This function is called once at the
+         * beginning of the program after parse_parameters is run and after the
+         * SimulatorAccess (if applicable) is initialized.
+         */
+        virtual
+        void
+        initialize ()
+        {
+          std::cout << "Initializing boundary heat flux!" << std::endl;
+          timestep = 0;
+        };
+
+        /**
+         * A function that is called at the beginning of each time step to
+         * indicate what the model time is for which the boundary values will
+         * next be evaluated. For the current class, the function passes to
+         * the parsed function what the current time is.
+         */
+        virtual
+        void
+        update ()
+        {
+          timestep = this->get_timestep_number();
+          std::cout << "Updating boundary heat flux to time step "
+                    << timestep
+                    << '!'
+                    << std::endl;
+        }
+
+      private:
+        unsigned int timestep;
+    };
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryHeatFlux
+  {
+    ASPECT_REGISTER_BOUNDARY_HEAT_FLUX_MODEL(Update,
+                                             "heatflux update",
+                                             "Heat flux boundary to test the update and initialize functions.")
+  }
+}
diff --git a/tests/boundary_heatflux_update.prm.bak b/tests/boundary_heatflux_update.prm.bak
new file mode 100644
index 00000000000..73170a83e72
--- /dev/null
+++ b/tests/boundary_heatflux_update.prm.bak
@@ -0,0 +1,102 @@
+# This test is used to check if the heat flux boundary conditions
+# work correctly, in particular if the initialize and update functions work.
+# Otherwise, it is a copy of the boundary_heatflux test.
+set Use years in output instead of seconds = false
+set End time                               = 2e12
+set Maximum time step                      = 1e12
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 90
+set Use conduction timestep                = true
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+  end
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.42
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
+
+  subsection Function
+    set Function expression = 0;0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top
+  set List of model names = initial temperature
+end
+
+subsection Boundary heat flux model
+  set Fixed heat flux boundary indicators = bottom
+  set Model name = heatflux update
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density        = 950
+    set Reference specific heat  = 1000
+    set Reference temperature    = 273
+    set Thermal conductivity     = 2.38
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization.
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =  heat flux map
+  end
+end
diff --git a/tests/boundary_temperature_function.prm.bak b/tests/boundary_temperature_function.prm.bak
new file mode 100644
index 00000000000..05f63c796b4
--- /dev/null
+++ b/tests/boundary_temperature_function.prm.bak
@@ -0,0 +1,70 @@
+# Copy of the simpler box test with a function
+# object describing the gravity
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+
+  subsection Function
+    set Function expression = x * 1600
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density
+  end
+end
diff --git a/tests/boundary_temperature_list.prm.bak b/tests/boundary_temperature_list.prm.bak
new file mode 100644
index 00000000000..0d6263a05d2
--- /dev/null
+++ b/tests/boundary_temperature_list.prm.bak
@@ -0,0 +1,74 @@
+# simple test for using multiple boundary temperature plugins
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-1,1.5)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box, constant, function, initial temperature
+  set List of model operators = maximum, add, subtract, add
+  set Fixed temperature boundary indicators   = top,left,bottom,right
+
+  subsection Box
+    set Left temperature = 15
+  end
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = bottom:7, left:0, top:0, right:0
+  end
+
+  subsection Function
+    set Function expression = if (x>500000,3,0)
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
diff --git a/tests/boundary_traction_function_cartesian_free_surface.prm.bak b/tests/boundary_traction_function_cartesian_free_surface.prm.bak
new file mode 100644
index 00000000000..bb1f55c6f78
--- /dev/null
+++ b/tests/boundary_traction_function_cartesian_free_surface.prm.bak
@@ -0,0 +1,143 @@
+##### test for boundary traction function using cartesian coordinates
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 5
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set CFL number                             = 0.5
+set Maximum time step                      = 2.5
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 5871.e3
+    set Chunk outer radius = 6371.e3
+    set Chunk minimum longitude = 35.0
+    set Chunk maximum longitude = 55.0
+    set Longitude repetitions = 60
+    set Radius repetitions = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 2
+  set Time steps between mesh refinement = 0
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system   = spherical
+    set Variable names      = r,phi
+    set Function expression = r>=6169.e3 ? 2 : 0
+  end
+end
+
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Mesh deformation
+  set Additional tangential mesh velocity boundary indicators = east, west
+  set Mesh deformation boundary indicators = outer: free surface
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, east, west
+end
+
+subsection Nullspace removal
+  set Remove nullspace = angular momentum
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = outer: function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x,y,t
+    set Function constants  = alpha1=0.767945, alpha2=0.802851, tend=100., Re=6371.e3, F=10000000
+    set Function expression = x>=Re*cos(alpha2) && x<=Re*cos(alpha1) ? -F*t/tend*cos(atan(y/x)) : 0; x>=Re*cos(alpha2) && x<=Re*cos(alpha1) ? -F*t/tend*sin(atan(y/x)) : 0;
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = ve_stress_xx, ve_stress_yy, ve_stress_xy
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0;
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = true
+  set List of model names = initial composition
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = inner, outer, east, west
+  set List of model names = initial temperature
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 4450
+    set Viscosities                 = 5.0e20
+    set Elastic shear moduli        = 175.e9
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 2.5
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.8
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics
+
+  subsection Topography
+    set Output to file = true
+    set Time between text output = 0
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/tests/boundary_traction_function_spherical_free_surface.prm.bak b/tests/boundary_traction_function_spherical_free_surface.prm.bak
new file mode 100644
index 00000000000..c45db3508a8
--- /dev/null
+++ b/tests/boundary_traction_function_spherical_free_surface.prm.bak
@@ -0,0 +1,144 @@
+##### test for boundary traction function using spherical coordinates
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 5
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set CFL number                             = 0.5
+set Maximum time step                      = 2.5
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 5871.e3
+    set Chunk outer radius = 6371.e3
+    set Chunk minimum longitude = 35.0
+    set Chunk maximum longitude = 55.0
+    set Longitude repetitions = 60
+    set Radius repetitions = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 2
+  set Time steps between mesh refinement = 0
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system   = spherical
+    set Variable names      = r,phi
+    set Function expression = r>=6169.e3 ? 2 : 0
+  end
+end
+
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Mesh deformation
+  set Additional tangential mesh velocity boundary indicators = east, west
+  set Mesh deformation boundary indicators = outer: free surface
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, east, west
+end
+
+subsection Nullspace removal
+  set Remove nullspace = angular momentum
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = outer: function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Use spherical unit vectors = true
+    set Variable names = r,phi,t
+    set Function constants  = alpha1=0.767945, alpha2=0.802851, tend=100., Re=6371.e3, F=10000000
+    set Function expression = phi>=alpha1 && phi<=alpha2 ? -F*t/tend: 0; 0;
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = ve_stress_xx, ve_stress_yy, ve_stress_xy
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0;
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = true
+  set List of model names = initial composition
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = inner, outer, east, west
+  set List of model names = initial temperature
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 4450
+    set Viscosities                 = 5.0e20
+    set Elastic shear moduli        = 175.e9
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 2.5
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.8
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics
+
+  subsection Topography
+    set Output to file = true
+    set Time between text output = 0
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/tests/boundary_velocity_function_spherical.prm.bak b/tests/boundary_velocity_function_spherical.prm.bak
new file mode 100644
index 00000000000..8b0a3239b9a
--- /dev/null
+++ b/tests/boundary_velocity_function_spherical.prm.bak
@@ -0,0 +1,74 @@
+##### test for boundary velocity function using spherical coordinates
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 3
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, inner
+  set Prescribed velocity boundary indicators = outer: function
+
+  subsection Function
+    set Coordinate system   = spherical
+    set Variable names      = r, phi
+    set Function expression = sin(4*phi);sin(2*phi)
+    set Use spherical unit vectors = true
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/box_end_time_1e7_terminate.prm.bak b/tests/box_end_time_1e7_terminate.prm.bak
new file mode 100644
index 00000000000..1a108186aae
--- /dev/null
+++ b/tests/box_end_time_1e7_terminate.prm.bak
@@ -0,0 +1,67 @@
+# a test that verifies that setting an end time earlier than when
+# we achieve steady state still terminates the program at the right
+# time
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = steady state velocity
+
+  subsection Steady state velocity
+    set Maximum relative deviation = 0.05
+    set Time in steady state       = 5e6
+  end
+end
diff --git a/tests/box_first_time_step.prm.bak b/tests/box_first_time_step.prm.bak
new file mode 100644
index 00000000000..6dd31b16557
--- /dev/null
+++ b/tests/box_first_time_step.prm.bak
@@ -0,0 +1,58 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+end
diff --git a/tests/box_first_time_step_alternate_bc.prm.bak b/tests/box_first_time_step_alternate_bc.prm.bak
new file mode 100644
index 00000000000..b66028b539e
--- /dev/null
+++ b/tests/box_first_time_step_alternate_bc.prm.bak
@@ -0,0 +1,64 @@
+# This is a copy of the box_first_time_step.prm. The difference is this: One
+# can mark boundaries as having zero velocity, or one can mark them as having
+# Dirichlet velocity boundary conditions and then select that the boundary
+# function should in fact be zero. The result should of course be the
+# same. This test verifies that this is indeed so.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: zero velocity, 2: zero velocity, 3: zero velocity
+  set Tangential velocity boundary indicators = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+end
diff --git a/tests/box_initial_mesh_deformation.cc.bak b/tests/box_initial_mesh_deformation.cc.bak
new file mode 100644
index 00000000000..56b3edfdad0
--- /dev/null
+++ b/tests/box_initial_mesh_deformation.cc.bak
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/mesh_deformation/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace MeshDeformation
+  {
+    template <int dim>
+    class PrescribedDeformation : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        PrescribedDeformation()
+        {}
+
+        Tensor<1,dim>
+        compute_initial_deformation_on_boundary(const types::boundary_id /*boundary_indicator*/,
+                                                const Point<dim> &position) const
+        {
+          const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(position);
+          Tensor<1,dim> topography_direction;
+          if (gravity.norm() > 0.0)
+            topography_direction = -gravity / gravity.norm();
+
+          const double topography_amplitude = 20000. * std::cos(2.*numbers::PI*position[0]/(660000.));
+          return topography_amplitude * topography_direction;
+        }
+    };
+  }
+}
+
+
+// explicit instantiation of the functions we implement in this file
+namespace aspect
+{
+  namespace MeshDeformation
+  {
+    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(PrescribedDeformation,
+                                           "prescribed deformation",
+                                           "A test plugin for initial mesh deformation.")
+  }
+}
diff --git a/tests/box_initial_mesh_deformation.prm.bak b/tests/box_initial_mesh_deformation.prm.bak
new file mode 100644
index 00000000000..126460dc9a7
--- /dev/null
+++ b/tests/box_initial_mesh_deformation.prm.bak
@@ -0,0 +1,81 @@
+# This input file tests the box geometry in
+# combination with an initial prescribed
+# mesh deformation.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: prescribed deformation
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Strategy                           = minimum refinement function
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, top, bottom
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables =
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/box_initial_mesh_deformation_ascii_data.prm.bak b/tests/box_initial_mesh_deformation_ascii_data.prm.bak
new file mode 100644
index 00000000000..d0ca2dad273
--- /dev/null
+++ b/tests/box_initial_mesh_deformation_ascii_data.prm.bak
@@ -0,0 +1,102 @@
+# This input file tests the box geometry in
+# combination with the ascii data initial
+# mesh deformation model.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# We take a box geometry and increase the repetitions
+# of the coarse mesh to capture the initial topography.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set Z extent = 660000
+    set X repetitions = 1
+    set Y repetitions = 1
+    set Z repetitions = 1
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: ascii data
+
+  # This specifies parameters for initial topography from ascii data
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+    set Data file name = box_3d_top.0.txt
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = 5
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Function expression             = if(x<200000, 2,1)
+  end
+end
+
+# Unlike in the geometry_model/initial_topography_model test
+# we must use free-slip boundaries, otherwise the mesh will not
+# deform at the boundaries of the box
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators       = 0,1,2,3,4
+end
+
+# The maximum topography in the ascii file is 350 km and the minimum is 20 km.
+# The topography statistics should not exceed these bounds.
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = boundary indicators, depth
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/box_initial_mesh_deformation_periodic.cc.bak b/tests/box_initial_mesh_deformation_periodic.cc.bak
new file mode 100644
index 00000000000..a05d9059016
--- /dev/null
+++ b/tests/box_initial_mesh_deformation_periodic.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "box_initial_mesh_deformation.cc"
diff --git a/tests/box_initial_mesh_deformation_periodic.prm.bak b/tests/box_initial_mesh_deformation_periodic.prm.bak
new file mode 100644
index 00000000000..ad8539d8f0e
--- /dev/null
+++ b/tests/box_initial_mesh_deformation_periodic.prm.bak
@@ -0,0 +1,25 @@
+# Like box_initial_mesh_deformation.prm, but test
+# that periodic boundaries are correctly interpreted as
+# tangential mesh movement boundaries.
+
+include $ASPECT_SOURCE_DIR/tests/box_initial_mesh_deformation.prm
+
+set Dimension                              = 2
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set X periodic = true
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: prescribed deformation
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = top, bottom
+end
diff --git a/tests/box_initial_topography_ascii_data.prm.bak b/tests/box_initial_topography_ascii_data.prm.bak
new file mode 100644
index 00000000000..fe3f0b0e560
--- /dev/null
+++ b/tests/box_initial_topography_ascii_data.prm.bak
@@ -0,0 +1,99 @@
+# This input file tests the box geometry in
+# combination with the ascii data initial
+# topography model.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# We take a box geometry and increase the repetitions
+# of the coarse mesh to capture the initial topography.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set Z extent = 660000
+    set X repetitions = 1
+    set Y repetitions = 1
+    set Z repetitions = 1
+  end
+
+  # We specify the name and directory of the ascii data file
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+      set Data file name = box_3d_top.0.txt
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = 5
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Function expression             = if(x<220000, 2,1)
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0,1,2,3,4,5
+end
+
+# The maximum topography in the ascii file is 350 km and the minimum is 20 km.
+# The topography statistics should not exceed these bounds.
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = boundary indicators, depth
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/box_initial_topography_ascii_data_moved_origin.prm.bak b/tests/box_initial_topography_ascii_data_moved_origin.prm.bak
new file mode 100644
index 00000000000..ec31e30789f
--- /dev/null
+++ b/tests/box_initial_topography_ascii_data_moved_origin.prm.bak
@@ -0,0 +1,101 @@
+# This input is based on box_initial_topography_ascii_data
+# and tests the box geometry with a moved box origin in
+# combination with the ascii data initial
+# topography model.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# We take a box geometry and increase the repetitions
+# of the coarse mesh to capture the initial topography.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set Z extent = 660000
+    set Box origin Z coordinate = -655000
+    set X repetitions = 1
+    set Y repetitions = 1
+    set Z repetitions = 1
+  end
+
+  # We specify the name and directory of the ascii data file
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+      set Data file name = box_3d_top.0.txt
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = 5
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Function expression             = if(x<220000, 2,1)
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0,1,2,3,4,5
+end
+
+# The maximum topography in the ascii file is 350 km and the minimum is 20 km.
+# The topography statistics should not exceed these bounds.
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = boundary indicators, depth
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/box_initial_topography_function.prm.bak b/tests/box_initial_topography_function.prm.bak
new file mode 100644
index 00000000000..68225fe381f
--- /dev/null
+++ b/tests/box_initial_topography_function.prm.bak
@@ -0,0 +1,98 @@
+# This input file tests the box geometry in
+# combination with the function initial
+# topography model.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# We take a box geometry and increase the repetitions
+# of the coarse mesh to capture the initial topography.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set X repetitions = 1
+    set Y repetitions = 1
+  end
+
+  # We specify the topography with a cosine function
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function constants = L=660000, R=20000
+      set Function expression = R * cos(pi*x/(2*L))
+      set Maximum topography value = 20000
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = top
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Function expression             = if(x<300000, 2,1)
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, top, bottom
+end
+
+# The maximum topography of the function is 20 km and the minimum is 0 km.
+# The topography statistics should not exceed these bounds.
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = boundary indicators, depth
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/box_initial_topography_prm_polygon.prm.bak b/tests/box_initial_topography_prm_polygon.prm.bak
new file mode 100644
index 00000000000..c6444f7a7a9
--- /dev/null
+++ b/tests/box_initial_topography_prm_polygon.prm.bak
@@ -0,0 +1,91 @@
+# This input file tests the box geometry in
+# combination with the prm polygon initial
+# topography model.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# We take a box geometry and increase the repetitions
+# of the coarse mesh to capture the initial topography.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set Z extent = 660000
+    set X repetitions = 1
+    set Y repetitions = 1
+    set Z repetitions = 1
+  end
+
+  # We specify a triangular polygon where topography is 50 km.
+  subsection Initial topography model
+    set Model name = prm polygon
+
+    subsection Prm polygon
+      set Topography parameters = 50000 > 100000,0;550000,100000;550000,550000
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = 5
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0,1,2,3,4,5
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = boundary indicators, depth
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/box_lithostatic_pressure_2d.prm.bak b/tests/box_lithostatic_pressure_2d.prm.bak
new file mode 100644
index 00000000000..239c2b52320
--- /dev/null
+++ b/tests/box_lithostatic_pressure_2d.prm.bak
@@ -0,0 +1,142 @@
+# This is a version of the stokes' law input file
+# that demonstrates a lithostatic pressure boundary
+# - "open boundary" - for a sinking sphere.
+
+
+
+############### Global parameters
+# We use a 2d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Pressure normalization                 = surface
+
+############### Parameters describing the model
+# The setup is a 2d box with edge length 2890000 in which
+# all sides except the left have free slip boundary conditions. Because
+# the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2890000
+    set Y extent  = 2890000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1,2,3
+end
+
+#############
+# The lithostatic pressure profile is calculated
+# at x = 10000, over 1000 integration points
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 0: initial lithostatic pressure #, 1: lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Representative point = 10000,0
+  end
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = (289e4-z)*9.81*33e2;0
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = #linear x momentum
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Viscosity                     = 1e22
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# This, however, is the more important part: We need to describe
+# the compositional field and its influence on the density
+# function. The following blocks say that we want to
+# advect a single compositional field and that we give it an
+# initial value that is zero outside a sphere of radius
+# r=200000m and centered at the point (p,p) with
+# p=1445000 (which is half the diameter of the box) and one inside.
+# The last block re-opens the material model and sets the
+# density differential per unit change in compositional field to
+# 100.
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = r=2e5,p=1445e3
+    set Function expression = if(sqrt((x-p)*(x-p)+(z-p)*(z-p)) > r, 0, 1)
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = composition
+end
+
+############### Parameters describing the what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+# The lithostatic pressure at the bottom boundary should be
+# 2890000*9.81*3300 = 93557970000 (9.4e10).
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, velocity boundary statistics, boundary pressures
+end
diff --git a/tests/box_lithostatic_pressure_3d.prm.bak b/tests/box_lithostatic_pressure_3d.prm.bak
new file mode 100644
index 00000000000..9d310274bca
--- /dev/null
+++ b/tests/box_lithostatic_pressure_3d.prm.bak
@@ -0,0 +1,140 @@
+# This is a version of the stokes' law input file
+# that demonstrates a lithostatic pressure boundary
+# - "open boundary" - for a sinking sphere.
+
+
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Pressure normalization                 = surface
+
+############### Parameters describing the model
+# The setup is a 3d box with edge length 2890000 in which
+# all sides except the left have free slip boundary conditions. Because
+# the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2890000
+    set Y extent  = 2890000
+    set Z extent  = 2890000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1,2,3,4,5
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 0: initial lithostatic pressure #, 1: initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Representative point = 10000,10000,2890000
+  end
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = (289e4-z)*9.81*33e2;0
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = #linear x momentum
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Viscosity                     = 1e22
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# This, however, is the more important part: We need to describe
+# the compositional field and its influence on the density
+# function. The following blocks say that we want to
+# advect a single compositional field and that we give it an
+# initial value that is zero outside a sphere of radius
+# r=200000m and centered at the point (p,p,p) with
+# p=1445000 (which is half the diameter of the box) and one inside.
+# The last block re-opens the material model and sets the
+# density differential per unit change in compositional field to
+# 100.
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = r=2e5,p=1445e3
+    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = composition
+  set Run postprocessors on initial refinement = true
+  set Time steps between mesh refinement       = 0
+end
+
+############### Parameters describing the what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, velocity boundary statistics, boundary pressures
+end
diff --git a/tests/box_origin.prm.bak b/tests/box_origin.prm.bak
new file mode 100644
index 00000000000..84df87e1e37
--- /dev/null
+++ b/tests/box_origin.prm.bak
@@ -0,0 +1,68 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box # Test comment
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  #test comment3
+  set Model name = vertical#test comment2
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.3
+    set Y extent = 2.2
+    set Z extent = 1.1
+    set Box origin X coordinate = -1.9
+    set Box origin Y coordinate = 2.5
+    set Box origin Z coordinate = 3.1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/box_repetitions.prm.bak b/tests/box_repetitions.prm.bak
new file mode 100644
index 00000000000..4b2cb4e38be
--- /dev/null
+++ b/tests/box_repetitions.prm.bak
@@ -0,0 +1,65 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+    set X repetitions = 3
+    set Y repetitions = 7
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization#, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/box_simple_log_viscosity_depth_average.prm.bak b/tests/box_simple_log_viscosity_depth_average.prm.bak
new file mode 100644
index 00000000000..cca6fb00e9e
--- /dev/null
+++ b/tests/box_simple_log_viscosity_depth_average.prm.bak
@@ -0,0 +1,104 @@
+# Test geometric depth averaging of visocity using  material model in 2d box
+# using a file # to specify depth-dependence.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Geometry of the domain. In order to test the depth averaging,
+# we use the X and Y repetitions such that four equal depth
+# layers of visocisty are created in the depth-dependent material
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2e6
+    set Y extent = 2e6
+    set X repetitions = 24
+    set Y repetitions = 24
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 0
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
+    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 2773
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 273.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc).
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = depth dependent
+
+  subsection Depth dependent model
+    set Base model = simple
+    set Depth dependence method = List
+    set Depth list =  5e5, 1e6, 1.5e6, 2e6
+    set Viscosity list = 1e23, 1e21, 1e22, 1e21
+    set Reference viscosity = 1e21
+  end
+
+  subsection Simple model
+    set Reference density             = 3300.0
+    set Reference specific heat       = 1250.0
+    set Reference temperature         = 0
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1e24
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Depth average
+    set List of output variables = log viscosity, viscosity
+    set Time between graphical output = 0
+    set Number of zones = 2
+    set Depth boundaries of zones = 0, 1e6, 2e6
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/box_simple_surface_strain_rate_residual.prm b/tests/box_simple_surface_strain_rate_residual.prm
index 058a948ec39..6d44326dd22 100644
--- a/tests/box_simple_surface_strain_rate_residual.prm
+++ b/tests/box_simple_surface_strain_rate_residual.prm
@@ -23,7 +23,7 @@ end
 
 subsection Boundary temperature model
   set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,1,2,3        # default:
+  set Fixed temperature boundary indicators   = 0,1,2,3
 
   subsection Initial temperature
     set Maximal temperature = 101.0
@@ -36,7 +36,7 @@ subsection Boundary composition model
 end
 
 subsection Geometry model
-  set Model name = box # default:
+  set Model name = box
 
   subsection Box
     set X extent  = 100e3
@@ -64,7 +64,7 @@ subsection Boundary velocity model
 end
 
 subsection Initial temperature model
-  set Model name = function # default:
+  set Model name = function
 
   subsection Function
     set Function expression = 100.0
diff --git a/tests/box_simple_surface_strain_rate_residual.prm.bak b/tests/box_simple_surface_strain_rate_residual.prm.bak
new file mode 100644
index 00000000000..058a948ec39
--- /dev/null
+++ b/tests/box_simple_surface_strain_rate_residual.prm.bak
@@ -0,0 +1,99 @@
+##### simple test to check the boundary strain rate residual statistics and
+##### visualization postprocessor. The input data has zero strain rate so
+##### to check that the posprocessor is working : the output `strain rate`
+##### and `boundary strain rate residual` are equal in magnitude and opposite
+##### in signs.
+
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Nonlinear solver tolerance             = 1e-10
+set CFL number                             = 0.5
+set Pressure normalization                 = no
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Dimension                              = 3
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Refinement fraction                      = 0.0
+  set Coarsening fraction                      = 0.0
+  set Time steps between mesh refinement       = 0
+  set Initial adaptive refinement              = 0
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,1,2,3        # default:
+
+  subsection Initial temperature
+    set Maximal temperature = 101.0
+    set Minimal temperature = 99.0
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Geometry model
+  set Model name = box # default:
+
+  subsection Box
+    set X extent  = 100e3
+    set Y extent  = 100e3
+    set Z extent  = 100e3
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = top: free surface
+
+  subsection Free surface
+    set Surface velocity projection = vertical
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left:function, right:function
+
+  subsection Function
+    set Function constants = vel=0.1
+    set Function expression = if ( (x==0), vel, if ( (x==100e3), -vel, 0) ) ; 0; 0
+    set Variable names      = x,y,z
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function # default:
+
+  subsection Function
+    set Function expression = 100.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, boundary strain rate residual statistics
+
+  subsection Visualization
+    set Output format                 = gnuplot
+    set List of output variables      = strain rate, boundary strain rate residual
+    set Point-wise stress and strain  = true
+  end
+
+  subsection Boundary strain rate residual statistics
+    set Data file name                     = box_3d_boundary_strain_rate.txt
+    set Data directory                     = $ASPECT_SOURCE_DIR/data/postprocess/boundary-strain-rate-residual/
+  end
+end
diff --git a/tests/box_steady_state_terminate.prm.bak b/tests/box_steady_state_terminate.prm.bak
new file mode 100644
index 00000000000..8907b6b355a
--- /dev/null
+++ b/tests/box_steady_state_terminate.prm.bak
@@ -0,0 +1,63 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 5e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = steady state velocity
+
+  subsection Steady state velocity
+    set Maximum relative deviation = 0.05
+    set Time in steady state       = 5e6
+  end
+end
diff --git a/tests/box_steady_temperature_terminate.prm.bak b/tests/box_steady_temperature_terminate.prm.bak
new file mode 100644
index 00000000000..107285063ea
--- /dev/null
+++ b/tests/box_steady_temperature_terminate.prm.bak
@@ -0,0 +1,73 @@
+# A test for the 'steady state temperature' termination criterion
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 5e9
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Use conduction timestep = true
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (1-y)*x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0.1
+    set Viscosity                     = 1e-3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, velocity statistics
+
+  subsection Visualization
+    set List of output variables = material properties
+    set Time between graphical output = 0.1
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = steady state temperature
+
+  subsection Steady state temperature
+    set Maximum relative deviation = 1e-8
+    set Time in steady state       = 1
+  end
+end
diff --git a/tests/box_surface_base_variables.prm b/tests/box_surface_base_variables.prm
index ec646ea17f2..dfe51aa1cf9 100644
--- a/tests/box_surface_base_variables.prm
+++ b/tests/box_surface_base_variables.prm
@@ -53,10 +53,6 @@ subsection Initial temperature model
   end
 end
 
-# The parameters below this comment were created by the update script
-# as replacement for the old 'Model settings' subsection. They can be
-# safely merged with any existing subsections with the same name.
-
 subsection Boundary temperature model
   set List of model names = function
   set Fixed temperature boundary indicators   = 5
diff --git a/tests/box_surface_base_variables.prm.bak b/tests/box_surface_base_variables.prm.bak
new file mode 100644
index 00000000000..ec646ea17f2
--- /dev/null
+++ b/tests/box_surface_base_variables.prm.bak
@@ -0,0 +1,105 @@
+# This input file tests the box geometry in
+# combination with the ascii data initial
+# topography model and visualization output
+# on the mesh surface.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# We take a box geometry and increase the repetitions
+# of the coarse mesh to capture the initial topography.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set Z extent = 660000
+    set X repetitions = 1
+    set Y repetitions = 1
+    set Z repetitions = 1
+  end
+
+  # We specify the name and directory of the ascii data file
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+      set Data file name = box_3d_top.0.txt
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+# The parameters below this comment were created by the update script
+# as replacement for the old 'Model settings' subsection. They can be
+# safely merged with any existing subsections with the same name.
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = 5
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Function expression             = if(x<400000, 2,1)
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0,1,2,3,4,5
+end
+
+# The maximum topography in the ascii file is 350 km and the minimum is 20 km.
+# The topography statistics should not exceed these bounds.
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = boundary indicators, depth
+    set Output base variables on mesh surface = true
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/bunge_cookbook.prm.bak b/tests/bunge_cookbook.prm.bak
new file mode 100644
index 00000000000..01ce4d3693a
--- /dev/null
+++ b/tests/bunge_cookbook.prm.bak
@@ -0,0 +1,17 @@
+# Test cookbooks/cookbooks/bunge_et_al_mantle_convection/
+
+
+include $ASPECT_SOURCE_DIR/cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm
+
+set End time                               = 1e2
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Time steps between mesh refinement = 0
+end
+
+# Post processing
+subsection Postprocess
+  #  set List of postprocessors = temperature statistics
+end
diff --git a/tests/burnman_seismic_test.prm.bak b/tests/burnman_seismic_test.prm.bak
new file mode 100644
index 00000000000..8091d8e93ed
--- /dev/null
+++ b/tests/burnman_seismic_test.prm.bak
@@ -0,0 +1,151 @@
+# A cookbook based on the burnman_test cookbook, but modified testing
+# the output of seismic velocity data generated by burnman and reading
+# them in through an ascii data file.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+subsection Material model
+  set Model name = ascii reference profile
+  set Material averaging = harmonic average
+
+  subsection Ascii reference profile
+    set Thermal viscosity exponent = 10.0
+    set Viscosity prefactors = 1.0, 0.1, 1.0, 10.0
+
+    subsection Ascii data model
+      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+      set Data file name = example_seismic_velocities.txt
+    end
+  end
+end
+
+# The geometry is a spherical shell with the inner and
+# outer radius of the Earth's mantle.
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Adiabatic conditions model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_seismic_velocities.txt
+  end
+end
+
+# The gravity model reads an ascii data file that contains a gravity
+# profile consistent with the material properties computed using the
+# Birch-Murnaghan equation of state. It automatically uses the same file
+# specified in the adiabatic conditions model.
+subsection Gravity model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_seismic_velocities.txt
+  end
+end
+
+# The model uses the anelastic liquid approximation.
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
+
+# The present-day plate velocities are imposed on the upper model
+# boundary.
+
+
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = outer:gplates
+  set Tangential velocity boundary indicators = inner
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 273
+  end
+end
+
+# The initial temperature is an adiabatic profile, which is
+# taken from the adiabatic conditions model. In this case, this is
+# is the ascii data model that loads a file containing profiles
+# corresponding to the Birch-Murnaghan equation of state.
+# In addition to the adiabatic profile, there are thermal boundary
+# layers at the surface and the core-mantle boundary.
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = if(sqrt(x*x+(z-4500000)*(z-4500000))<1000000,800,0)
+  end
+end
+
+subsection Mesh refinement
+  set Refinement fraction                = 0.4
+  set Coarsening fraction                = 0.05
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 5
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set Number of grouped files       = 0
+    set List of output variables      = named additional outputs
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint  = 1800
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+  end
+end
diff --git a/tests/burnman_test.prm.bak b/tests/burnman_test.prm.bak
new file mode 100644
index 00000000000..51922959030
--- /dev/null
+++ b/tests/burnman_test.prm.bak
@@ -0,0 +1,128 @@
+# A test using adiabatic conditions and a gravity
+# profile generated by a mineral physics toolkit and read in
+# through an ascii data file. In this example, material properties
+# are based on a Birch-Murnaghan equation of state.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+
+subsection Material model
+  set Model name = ascii reference profile
+  set Material averaging = harmonic average
+
+  subsection Ascii reference profile
+    set Thermal viscosity exponent = 0
+    set Viscosity prefactors = 1.0, 1.0, 1.0, 1.0
+
+    subsection Ascii data model
+      set Data file name = example_isentrope.txt
+      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    end
+  end
+end
+
+# The geometry is a spherical shell with the inner and
+# outer radius of the Earth's mantle.
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Adiabatic conditions model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_isentrope.txt
+  end
+end
+
+# The gravity model reads an ascii data file that contains a gravity
+# profile consistent with the material properties computed using the
+# Birch-Murnaghan equation of state. It automatically uses the same file
+# specified in the adiabatic conditions model.
+subsection Gravity model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_isentrope.txt
+  end
+end
+
+# The model uses the anelastic liquid approximation.
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
+
+# The present-day plate velocities are imposed on the upper model
+# boundary.
+
+
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = outer:gplates
+  set Tangential velocity boundary indicators = inner
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 273
+  end
+end
+
+# The initial temperature is an adiabatic profile, which is
+# taken from the adiabatic conditions model. In this case, this is
+# is the ascii data model that loads a file containing profiles
+# corresponding to the Birch-Murnaghan equation of state.
+# In addition to the adiabatic profile, there are thermal boundary
+# layers at the surface and the core-mantle boundary.
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Mesh refinement
+  set Refinement fraction                = 0.4
+  set Coarsening fraction                = 0.05
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 2
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 5
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/tests/burstedde.cc.bak b/tests/burstedde.cc.bak
new file mode 100644
index 00000000000..f43d3026353
--- /dev/null
+++ b/tests/burstedde.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/burstedde/burstedde.cc"
diff --git a/tests/burstedde.prm.bak b/tests/burstedde.prm.bak
new file mode 100644
index 00000000000..ab2535036b3
--- /dev/null
+++ b/tests/burstedde.prm.bak
@@ -0,0 +1,94 @@
+# The 3D polynomial Stokes (burstedde) benchmark, for which an
+# analytical solution is available.
+#
+# See the manual for more information.
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+set Additional shared libraries            = ./libburstedde.so
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+# The setup is a 3d unit cube.
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+    set Z extent  = 1
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:BursteddeBoundary, 1: BursteddeBoundary, 2: BursteddeBoundary, 3: BursteddeBoundary, 4: BursteddeBoundary, 5: BursteddeBoundary
+end
+
+subsection Material model
+  set Model name = BursteddeMaterial
+end
+
+subsection Gravity model
+  set Model name = BursteddeGravity
+end
+
+subsection Burstedde benchmark
+  #Viscosity parameter is beta
+  set Viscosity parameter             = 20
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, BursteddePostprocessor
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/burstedde_stokes_rhs.cc.bak b/tests/burstedde_stokes_rhs.cc.bak
new file mode 100644
index 00000000000..43fcbf64f93
--- /dev/null
+++ b/tests/burstedde_stokes_rhs.cc.bak
@@ -0,0 +1,472 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  /**
+   * This is the "Burstedde" benchmark defined in the following paper:
+   * @code
+   *  @Article{busa13,
+   *    author =       {Burstedde, Carsten and Stadler, Georg and Alisic, Laura and Wilcox, Lucas C and Tan, Eh and Gurnis, Michael and Ghattas, Omar},
+   *    title =        {Large-scale adaptive mantle convection simulation},
+   *    journal =      {Geophysical Journal International},
+   *    year =         2013,
+   *    volume =       192,
+   *    number =       {3},
+   *    publisher =    {Oxford University Press},
+   *    pages =        {889--906}}
+   * @endcode
+   *
+   */
+  namespace BursteddeBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+      Tensor<1,3>
+      burstedde_velocity (const Point<3> &pos,
+                          const double eta)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const double z = pos[2];
+
+        // create a Point<3> (because it has a constructor that takes
+        // three doubles) and return it (it automatically converts to
+        // the necessary Tensor<1,3>).
+        return Point<3> (x+x*x+x*y+x*x*x*y,
+                         y+x*y+y*y+x*x*y*y,
+                         -2.*z-3.*x*z-3.*y*z-5.*x*x*y*z);
+      }
+
+      double
+      burstedde_pressure (const Point<3> &pos,
+                          const double eta)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const double z = pos[2];
+
+        const double min_eta = 1.0;
+        const double max_eta = eta;
+        const double A(min_eta*(max_eta-min_eta)/(max_eta+min_eta));
+
+        return x*y*z+x*x*x*y*y*y*z-5./32.;
+      }
+
+
+      /**
+       * The exact solution for the Burstedde benchmark.
+       */
+      template <int dim>
+      class FunctionBurstedde : public Function<dim>
+      {
+        public:
+          FunctionBurstedde (const double beta)
+            :
+            Function<dim>(dim+2),
+            beta_(beta)
+          {}
+
+          virtual void vector_value (const Point<dim>   &pos,
+                                     Vector<double>   &values) const
+          {
+            Assert (dim == 3, ExcNotImplemented());
+            Assert (values.size() >= 4, ExcInternalError());
+
+            const Point<3> p (pos[0], pos[1], pos[2]);
+
+            const Tensor<1,3> v = AnalyticSolutions::burstedde_velocity (p, beta_);
+            values[0] = v[0];
+            values[1] = v[1];
+            values[2] = v[2];
+
+            values[3] = AnalyticSolutions::burstedde_pressure (p, beta_);
+          }
+
+        private:
+          const double beta_;
+      };
+    }
+
+
+
+    template <int dim>
+    class BursteddeBoundary : public BoundaryVelocity::Interface<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        BursteddeBoundary();
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        virtual
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position) const;
+
+      private:
+        const double beta;
+    };
+
+    template <int dim>
+    BursteddeBoundary<dim>::BursteddeBoundary ()
+      :
+      beta (0)
+    {}
+
+
+
+    template <>
+    Tensor<1,2>
+    BursteddeBoundary<2>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<2> &p) const
+    {
+      Assert (false, ExcNotImplemented());
+      return Tensor<1,2>();
+    }
+
+
+
+    template <>
+    Tensor<1,3>
+    BursteddeBoundary<3>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<3> &p) const
+    {
+      return AnalyticSolutions::burstedde_velocity (p, beta);
+    }
+
+
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class BursteddeMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const
+        {
+
+          MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
+          *force = out.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> &p = in.position[i];
+
+              const double x=p[0];
+              const double y=p[1];
+              const double z=p[2];
+              const double mu=exp(1. - beta * (x*(1.-x)+y*(1.-y) + z*(1.-z)));
+
+              out.viscosities[i] = mu;
+              out.thermal_conductivities[i] = 0.0;
+              out.densities[i] = 1.0;
+
+              out.thermal_expansion_coefficients[i] = 0.0;
+              out.compressibilities[i] = 0.0;
+
+              out.specific_heat[i] = 0.0;
+
+              // Pressure derivative of entropy at the given positions.
+              out.entropy_derivative_pressure[i] = 0.0;
+              // Temperature derivative of entropy at the given positions.
+              out.entropy_derivative_temperature[i] = 0.0;
+              // Change in composition due to chemical reactions at the
+              // given positions. The term reaction_terms[i][c] is the
+              // change in compositional field c at point i.
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                out.reaction_terms[i][c] = 0.0;
+
+              if (force)
+                {
+                  const double dmudx=-beta*(1.-2.*x)*mu;
+                  const double dmudy=-beta*(1.-2.*y)*mu;
+                  const double dmudz=-beta*(1.-2.*z)*mu;
+
+
+
+                  force->rhs_u[i][0] = ((y*z+3.*std::pow(x,2)*std::pow(y,3)*z)- mu*(2.+6.*x*y))
+                                       -dmudx*(2.+4.*x+2.*y+6.*std::pow(x,2)*y)
+                                       -dmudy*(x+std::pow(x,3)+y+2.*x*std::pow(y,2))
+                                       -dmudz*(-3.*z-10.*x*y*z);
+
+                  force->rhs_u[i][1] = ((x*z+3.*std::pow(x,3)*std::pow(y,2)*z)- mu*(2.+2.*std::pow(x,2)+2.*std::pow(y,2)))
+                                       -dmudx*(x+std::pow(x,3)+y+2.*x*std::pow(y,2))
+                                       -dmudy*(2.+2.*x+4.*y+4.*std::pow(x,2)*y)
+                                       -dmudz*(-3.*z-5.*std::pow(x,2)*z);
+
+                  force->rhs_u[i][2] = ((x*y+std::pow(x,3)*std::pow(y,3)) - mu*(-10.*y*z))
+                                       -dmudx*(-3.*z-10.*x*y*z)
+                                       -dmudy*(-3.*z-5.*std::pow(x,2)*z)
+                                       -dmudz*(-4.-6.*x-6.*y-10.*std::pow(x,2)*y);
+                }
+
+            }
+
+        }
+
+
+
+
+
+
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        virtual bool is_compressible () const;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+
+        /**
+         * Returns the viscosity value in the inclusion
+         */
+        double get_beta() const;
+
+        /**
+         * viscosity value in the inclusion
+         */
+        double beta;
+    };
+
+
+
+    template <int dim>
+    bool
+    BursteddeMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    BursteddeMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // create a global section in the parameter file for parameters
+      // that describe this benchmark. note that we declare them here
+      // in the material model, but other kinds of plugins (e.g., the gravity
+      // model below) may also read these parameters even though they do not
+      // declare them
+      prm.enter_subsection("Burstedde benchmark");
+      {
+        prm.declare_entry("Viscosity parameter", "20",
+                          Patterns::Double (0),
+                          "Viscosity in the Burstedde benchmark.");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    BursteddeMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Burstedde benchmark");
+      {
+        beta = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+
+    template <int dim>
+    double
+    BursteddeMaterial<dim>::get_beta() const
+    {
+      return beta;
+    }
+
+
+
+
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the paper Duretz et al. reference above.
+      */
+    template <int dim>
+    class BursteddePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        virtual
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics);
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    BursteddePostprocessor<dim>::execute (TableHandler &statistics)
+    {
+      std::unique_ptr<Function<dim>> ref_func;
+      {
+        const BursteddeMaterial<dim> *
+        material_model
+          = dynamic_cast<const BursteddeMaterial<dim> *>(&this->get_material_model());
+
+        ref_func = std::make_unique<AnalyticSolutions::FunctionBurstedde<dim>>(material_model->get_beta());
+      }
+
+      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                          dim+2);
+      ComponentSelectFunction<dim> comp_p(dim, dim+2);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_u,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_p,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_p);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_ul2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_pl2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+      std::ostringstream os;
+      os << std::scientific <<  u_l1
+         << ", " << p_l1
+         << ", " << u_l2
+         << ", " << p_l2;
+
+      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
+    }
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BursteddeBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(BursteddeMaterial,
+                                   "BursteddeMaterial",
+                                   "A material model that corresponds to the `Burstedde' benchmark. "
+                                   "See the manual for more information.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(BursteddeBoundary,
+                                            "BursteddeBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "`Burstedde' benchmark. See the manual for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(BursteddePostprocessor,
+                                  "BursteddePostprocessor",
+                                  "A postprocessor that compares the solution of the `Burstedde' benchmark "
+                                  "with the one computed by ASPECT "
+                                  "and reports the error. See the manual for more information.")
+  }
+}
diff --git a/tests/burstedde_stokes_rhs.prm.bak b/tests/burstedde_stokes_rhs.prm.bak
new file mode 100644
index 00000000000..2ee28267d1e
--- /dev/null
+++ b/tests/burstedde_stokes_rhs.prm.bak
@@ -0,0 +1,99 @@
+# like burstedde, but using a Stokes RHS instead of BursteddeGravity
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+set Additional shared libraries            = ./libburstedde.so
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+# The setup is a 3d unit cube.
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+    set Z extent  = 1
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:BursteddeBoundary, 1: BursteddeBoundary, 2: BursteddeBoundary, 3: BursteddeBoundary, 4: BursteddeBoundary, 5: BursteddeBoundary
+end
+
+subsection Formulation
+  set Enable additional Stokes RHS            = true
+end
+
+subsection Material model
+  set Model name = BursteddeMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Burstedde benchmark
+  #Viscosity parameter is beta
+  set Viscosity parameter             = 20
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, BursteddePostprocessor
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/cell_reference.cc.bak b/tests/cell_reference.cc.bak
new file mode 100644
index 00000000000..cafb6a6f936
--- /dev/null
+++ b/tests/cell_reference.cc.bak
@@ -0,0 +1,61 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/material_model/simpler.h>
+
+using namespace dealii;
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    class CellMaterial :
+      public aspect::MaterialModel::Simpler<dim>, aspect::SimulatorAccess<dim>
+    {
+      public:
+        void
+        evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                 MaterialModel::MaterialModelOutputs<dim> &out) const
+        {
+          Simpler<dim>::evaluate(in,out);
+
+          if (in.current_cell.state() == IteratorState::valid)
+            {
+              std::cout << "Level: " << in.current_cell->level() << " Index: " << in.current_cell->index() << std::endl;
+            }
+        }
+    };
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(CellMaterial,
+                                   "cell",
+                                   "")
+  }
+}
diff --git a/tests/cell_reference.prm.bak b/tests/cell_reference.prm.bak
new file mode 100644
index 00000000000..9a531fe3e64
--- /dev/null
+++ b/tests/cell_reference.prm.bak
@@ -0,0 +1,68 @@
+# This is a copy of simpler_box.prm test,
+# with a slightly modified material model that outputs the
+# cell level and index to check that the cell reference is working
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = cell
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/cells_in_circumference.prm.bak b/tests/cells_in_circumference.prm.bak
new file mode 100644
index 00000000000..8746bc59842
--- /dev/null
+++ b/tests/cells_in_circumference.prm.bak
@@ -0,0 +1,91 @@
+# Use a mesh with a different number of cells in the circumferential direction.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 5000000
+    set Outer radius = 6371000
+    set Opening angle = 360
+    set Cells along circumference = 20
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Additional refinement times              = 0,0
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/check_compositional_field_functions.cc.bak b/tests/check_compositional_field_functions.cc.bak
new file mode 100644
index 00000000000..1f66d188d94
--- /dev/null
+++ b/tests/check_compositional_field_functions.cc.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/parameters.h>
+#include <aspect/material_model/utilities.h>
+
+template <int dim>
+void f(const aspect::SimulatorAccess<dim> &simulator_access,
+       aspect::Assemblers::Manager<dim> &)
+{
+  // This function tests whether the compositional field types are correctly
+  // processed.
+
+  using namespace aspect::MaterialModel;
+
+  aspect::ParameterHandler prm;
+
+  // Fields 0 and 4 are chemical compositions
+  // These are called Field 1 and Field 5
+  const std::vector<unsigned int> indices = simulator_access.introspection().get_indices_for_fields_of_type(aspect::Parameters<dim>::CompositionalFieldDescription::chemical_composition);
+  const std::vector<std::string> names = simulator_access.introspection().get_names_for_fields_of_type(aspect::Parameters<dim>::CompositionalFieldDescription::chemical_composition);
+
+  const std::vector<double> field_values { 0.1, 0.3, 0.3, 0.3, 0.2, 0.3, 0.3};
+  const std::vector<double> compositional_field_fractions = MaterialUtilities::compute_only_composition_fractions(field_values, indices);
+
+  std::cout << "Chemical composition field #0 (the background field) has value " << compositional_field_fractions[0] << "." << std::endl;
+
+  for (unsigned int i=0; i<3; ++i)
+    std::cout << "Chemical composition field #" << i+1 << " is called " << names[i] << ", is in position "  << indices[i] << ", and has value " << compositional_field_fractions[i+1] << "." << std::endl;
+
+  exit(0);
+
+}
+
+template <>
+void f(const aspect::SimulatorAccess<2> &,
+       aspect::Assemblers::Manager<2> &)
+{
+  AssertThrow(false,dealii::ExcInternalError());
+}
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  using namespace dealii;
+  std::cout << "* Connecting signals" << std::endl;
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2));
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/check_compositional_field_functions.prm.bak b/tests/check_compositional_field_functions.prm.bak
new file mode 100644
index 00000000000..afe59fe951c
--- /dev/null
+++ b/tests/check_compositional_field_functions.prm.bak
@@ -0,0 +1,13 @@
+# This test checks whether the compositional field functions are implemented correctly.
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/tests/composite_viscous_outputs.prm
+
+set Additional shared libraries = tests/libcheck_compositional_field_functions.so
+
+subsection Compositional fields
+  set Number of fields = 7
+  set Names of fields =  Field_1, Field_2, Field_3, Field_4, Field_5, Field_6, Field_7
+  set Types of fields =  chemical composition, stress, grain size, porosity, chemical composition, generic, unspecified
+end
diff --git a/tests/check_compositional_field_names.cc.bak b/tests/check_compositional_field_names.cc.bak
new file mode 100644
index 00000000000..4b126e9d0d9
--- /dev/null
+++ b/tests/check_compositional_field_names.cc.bak
@@ -0,0 +1,76 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/parameters.h>
+
+template <int dim>
+void f(const aspect::SimulatorAccess<dim> &simulator_access,
+       aspect::Assemblers::Manager<dim> &)
+{
+  // This function tests whether the compositional field types are correctly
+  // processed.
+
+  using namespace aspect::MaterialModel;
+
+  aspect::ParameterHandler prm;
+
+  const std::vector<std::string> c_names = simulator_access.introspection().get_composition_names();
+  const std::vector<typename aspect::Parameters<dim>::CompositionalFieldDescription> descriptions = simulator_access.introspection().get_composition_descriptions();
+
+  for (unsigned int i=0; i<simulator_access.introspection().n_compositional_fields; ++i)
+    {
+      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::chemical_composition)
+        std::cout << c_names[i] << " is of type chemical composition" << std::endl;
+      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::grain_size)
+        std::cout << c_names[i] << " is of type grain size" << std::endl;
+      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::porosity)
+        std::cout << c_names[i] << " is of type porosity" << std::endl;
+      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::generic)
+        std::cout << c_names[i] << " is of type generic" << std::endl;
+      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::stress)
+        std::cout << c_names[i] << " is of type stress" << std::endl;
+      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::unspecified)
+        std::cout << c_names[i] << " is of type unspecified" << std::endl;
+    }
+
+  exit(0);
+
+}
+
+template <>
+void f(const aspect::SimulatorAccess<2> &,
+       aspect::Assemblers::Manager<2> &)
+{
+  AssertThrow(false,dealii::ExcInternalError());
+}
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  using namespace dealii;
+  std::cout << "* Connecting signals" << std::endl;
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2));
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/check_compositional_field_names.prm.bak b/tests/check_compositional_field_names.prm.bak
new file mode 100644
index 00000000000..0fbe38e00bd
--- /dev/null
+++ b/tests/check_compositional_field_names.prm.bak
@@ -0,0 +1,14 @@
+# This test checks whether the compositional field names are
+# processed correctly.
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/tests/composite_viscous_outputs.prm
+
+set Additional shared libraries = tests/libcheck_compositional_field_names.so
+
+subsection Compositional fields
+  set Number of fields = 7
+  set Names of fields =  Field_1, Field_2, Field_3, Field_4, Field_5, Field_6, Field_7
+  set Types of fields =  chemical composition, stress, grain size, porosity, chemical composition, generic, unspecified
+end
diff --git a/tests/checkpoint_01.cc.bak b/tests/checkpoint_01.cc.bak
new file mode 100644
index 00000000000..020cad8f414
--- /dev/null
+++ b/tests/checkpoint_01.cc.bak
@@ -0,0 +1,100 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Launch ASPECT
+ * twice to test checkpoint/resume and then terminate the outer ASPECT run.
+ */
+int f()
+{
+  std::cout << "* starting from beginning:" << std::endl;
+
+  // call ASPECT with "--" and pipe an existing input file into it.
+  int ret;
+  std::string command;
+
+  command = ("cd output-checkpoint_01 ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_01.prm "
+             " ; "
+             " echo 'set Output directory = output1.tmp' "
+             " ; "
+             " rm -rf output1.tmp ; mkdir output1.tmp "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  command = ("cd output-checkpoint_01 ; "
+             " rm -rf output2.tmp ; mkdir output2.tmp ; "
+             " cp output1.tmp/restart* output2.tmp/");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now resuming:" << std::endl;
+  command = ("cd output-checkpoint_01 ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_01.prm "
+             " ; "
+             " echo 'set Output directory = output2.tmp' "
+             " ; "
+             " echo 'set Resume computation = true' "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  std::cout << "* now comparing:" << std::endl;
+
+  ret = system ("cd output-checkpoint_01 ; "
+                "cp output1.tmp/depth_average.gnuplot depth_average.gnuplot1;"
+                "cp output2.tmp/depth_average.gnuplot depth_average.gnuplot2;"
+                "cp output1.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot1;"
+                "cp output2.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot2;"
+                "cp output1.tmp/log.txt log.txt1;"
+                "cp output2.tmp/log.txt log.txt2;"
+                "cp output1.tmp/statistics statistics1;"
+                "cp output2.tmp/statistics statistics2;"
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // terminate current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/checkpoint_01.prm.bak b/tests/checkpoint_01.prm.bak
new file mode 100644
index 00000000000..512d44620af
--- /dev/null
+++ b/tests/checkpoint_01.prm.bak
@@ -0,0 +1,87 @@
+# test checkpoint/resume.
+
+# This test is controlled via the plugin in checkpoint_01.cc. The plugin will
+# first execute ASPECT with this .prm and write the output into
+# output1.tmp/. This will generate a snapshot that is then resumed from. The
+# output for this second run will be written into output2.tmp/. Finally,
+# output files will be copied into the main output folder for comparison.
+
+# based on box_end_time_1e7_terminate.prm
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Checkpointing
+  set Steps between checkpoint = 4
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average, visualization, composition statistics, temperature statistics, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = false
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/checkpoint_01_check_parameters.cc.bak b/tests/checkpoint_01_check_parameters.cc.bak
new file mode 100644
index 00000000000..7ee437f4cb0
--- /dev/null
+++ b/tests/checkpoint_01_check_parameters.cc.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Launch ASPECT
+ * twice to test checkpoint/resume and then terminate the outer ASPECT run.
+ */
+int f()
+{
+  std::cout << "* starting from beginning:" << std::endl;
+
+  // call ASPECT with "--" and pipe an existing input file into it.
+  int ret;
+  std::string command;
+
+  command = ("cd output-checkpoint_01_check_parameters ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_01_check_parameters.prm "
+             " ; "
+             " echo 'set Output directory = output1.tmp' "
+             " ; "
+             " rm -rf output1.tmp ; mkdir output1.tmp "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  command = ("cd output-checkpoint_01_check_parameters ; "
+             " rm -rf output2.tmp ; mkdir output2.tmp ; "
+             " cp output1.tmp/restart* output2.tmp/");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now resuming:" << std::endl;
+  command = ("cd output-checkpoint_01_check_parameters ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_01_check_parameters.prm "
+             " ; "
+             " echo 'set Output directory = output2.tmp' "
+             " ; "
+             " echo 'set Resume computation = true' "
+             " ; "
+             //
+             // now also prescribe an incompatible number of compositional fields
+             //
+             " echo 'subsection Compositional fields' "
+             " ; "
+             " echo '  set Number of fields = 3' "
+             " ; "
+             " echo 'end' "
+             " ; "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+
+  // now run ASPECT on this (invalid) input file and output
+  // the expected error code
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now comparing:" << std::endl;
+
+  command = ("cd output-checkpoint_01_check_parameters ; "
+             "cp output1.tmp/log.txt log.txt1;"
+             "cp output1.tmp/statistics statistics1;");
+  ret = system (command.c_str());
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // terminate current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/checkpoint_01_check_parameters.prm.bak b/tests/checkpoint_01_check_parameters.prm.bak
new file mode 100644
index 00000000000..58d08e2eb80
--- /dev/null
+++ b/tests/checkpoint_01_check_parameters.prm.bak
@@ -0,0 +1,85 @@
+# like the checkpoint_01 test, but try to restart with an incompatible
+# number of compositional fields
+#
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Checkpointing
+  set Steps between checkpoint = 4
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average, visualization, composition statistics, temperature statistics, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = false
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
diff --git a/tests/checkpoint_02.cc.bak b/tests/checkpoint_02.cc.bak
new file mode 100644
index 00000000000..755887dbcb6
--- /dev/null
+++ b/tests/checkpoint_02.cc.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+
+/*
+ * Launch the following function when this plugin is created. Launch ASPECT
+ * twice to test checkpoint/resume and then terminate the outer ASPECT run.
+ */
+int f()
+{
+  std::cout << "* starting from beginning:" << std::endl;
+
+  // call ASPECT with "--" and pipe an existing input file into it.
+  int ret;
+
+  ret = system ("cd output-checkpoint_02 ; "
+                "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_02.prm "
+                " ; "
+                " echo 'set Output directory = output1.tmp' "
+                " ; "
+                " rm -rf output1.tmp ; mkdir output1.tmp "
+                ") "
+                "| ../../aspect -- >/dev/null ");
+
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  ret = system ("cd output-checkpoint_02 ; "
+                " rm -rf output2.tmp ; cp -r output1.tmp output2.tmp ;"
+                " rm -f output1.tmp/log.txt; "
+                " cp output1.tmp/restart.mesh.old output1.tmp/restart.mesh;"
+                " cp output1.tmp/restart.mesh.info.old output1.tmp/restart.mesh.info;"
+                " cp output1.tmp/restart.resume.z.old output1.tmp/restart.resume.z;");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now resuming:" << std::endl;
+  ret = system ("cd output-checkpoint_02 ; "
+                "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_02.prm "
+                " ; "
+                " echo 'set Output directory = output1.tmp' "
+                " ; "
+                " echo 'set Resume computation = true' "
+                ") "
+                "| ../../aspect -- >/dev/null");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  std::cout << "* now comparing:" << std::endl;
+
+  ret = system ("cd output-checkpoint_02 ; "
+                "cp output1.tmp/depth_average.gnuplot depth_average.gnuplot1;"
+                "cp output2.tmp/depth_average.gnuplot depth_average.gnuplot2;"
+                "cp output1.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot1;"
+                "cp output2.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot2;"
+                "cp output1.tmp/log.txt log.txt1;"
+                "cp output2.tmp/log.txt log.txt2;"
+                "cp output1.tmp/statistics statistics1;"
+                "cp output2.tmp/statistics statistics2;"
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  ret = system ("cd output-checkpoint_02 ; "
+                "diff -c output?.tmp/restart.resume.z;"
+                "diff -c output?.tmp/restart.mesh;"
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // terminate current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/checkpoint_02.prm.bak b/tests/checkpoint_02.prm.bak
new file mode 100644
index 00000000000..a45dcd124c7
--- /dev/null
+++ b/tests/checkpoint_02.prm.bak
@@ -0,0 +1,86 @@
+# test checkpoint/resume.
+
+# Like checkpoint_01, but we resume from the first of two snapshots. That way
+# we can actually compare if the checkpoint data of the second checkpoint is
+# identical.
+
+# Note: this requires a patch to Trilinos' ML (at least version 12.2.1 and
+# older) because the preconditioner is not deterministic.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.4e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Checkpointing
+  set Steps between checkpoint = 5
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average, visualization, composition statistics, temperature statistics, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = false
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/checkpoint_02_direct.cc.bak b/tests/checkpoint_02_direct.cc.bak
new file mode 100644
index 00000000000..6c1439f300d
--- /dev/null
+++ b/tests/checkpoint_02_direct.cc.bak
@@ -0,0 +1,97 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+
+/*
+ * Launch the following function when this plugin is created. Launch ASPECT
+ * twice to test checkpoint/resume and then terminate the outer ASPECT run.
+ */
+int f()
+{
+  std::cout << "* starting from beginning:" << std::endl;
+
+  // call ASPECT with "--" and pipe an existing input file into it.
+  int ret;
+
+  ret = system ("cd output-checkpoint_02_direct ; "
+                "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_02_direct.prm "
+                " ; "
+                " echo 'set Output directory = output1.tmp' "
+                " ; "
+                " rm -rf output1.tmp ; mkdir output1.tmp "
+                ") "
+                "| ../../aspect -- >/dev/null ");
+
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  ret = system ("cd output-checkpoint_02_direct ; "
+                " rm -rf output2.tmp ; cp -r output1.tmp output2.tmp ;"
+                " rm -f output1.tmp/log.txt; "
+                " cp output1.tmp/restart.mesh.old output1.tmp/restart.mesh;"
+                " cp output1.tmp/restart.mesh.info.old output1.tmp/restart.mesh.info;"
+                " cp output1.tmp/restart.resume.z.old output1.tmp/restart.resume.z;");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now resuming:" << std::endl;
+  ret = system ("cd output-checkpoint_02_direct ; "
+                "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_02_direct.prm "
+                " ; "
+                " echo 'set Output directory = output1.tmp' "
+                " ; "
+                " echo 'set Resume computation = true' "
+                ") "
+                "| ../../aspect -- >/dev/null");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  std::cout << "* now comparing:" << std::endl;
+
+  ret = system ("cd output-checkpoint_02_direct ; "
+                "cp output1.tmp/depth_average.gnuplot depth_average.gnuplot1;"
+                "cp output2.tmp/depth_average.gnuplot depth_average.gnuplot2;"
+                "cp output1.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot1;"
+                "cp output2.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot2;"
+                "cp output1.tmp/log.txt log.txt1;"
+                "cp output2.tmp/log.txt log.txt2;"
+                "cp output1.tmp/statistics statistics1;"
+                "cp output2.tmp/statistics statistics2;"
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  ret = system ("cd output-checkpoint_02_direct ; "
+                "diff -c output?.tmp/restart.resume.z;"
+                "diff -c output?.tmp/restart.mesh;"
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // terminate current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/checkpoint_02_direct.prm.bak b/tests/checkpoint_02_direct.prm.bak
new file mode 100644
index 00000000000..95b54e0ef4e
--- /dev/null
+++ b/tests/checkpoint_02_direct.prm.bak
@@ -0,0 +1,81 @@
+# test checkpoint/resume.
+
+# Like checkpoint-02, but using a direct solver.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.4e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Checkpointing
+  set Steps between checkpoint = 5
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average, visualization, composition statistics, temperature statistics, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = false
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/checkpoint_03_particles.cc.bak b/tests/checkpoint_03_particles.cc.bak
new file mode 100644
index 00000000000..754142c6d3e
--- /dev/null
+++ b/tests/checkpoint_03_particles.cc.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Launch ASPECT
+ * twice to test checkpoint/resume and then terminate the outer ASPECT run.
+ */
+int f()
+{
+  std::cout << "* starting from beginning:" << std::endl;
+
+  // call ASPECT with "--" and pipe an existing input file into it.
+  int ret;
+  std::string command;
+
+  command = ("cd output-checkpoint_03_particles ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_03_particles.prm "
+             " ; "
+             " echo 'set Output directory = output1.tmp' "
+             " ; "
+             " rm -rf output1.tmp ; mkdir output1.tmp "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  command = ("cd output-checkpoint_03_particles ; "
+             " rm -rf output2.tmp ; mkdir output2.tmp ; "
+             " cp output1.tmp/restart* output2.tmp/");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now resuming:" << std::endl;
+  command = ("cd output-checkpoint_03_particles ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_03_particles.prm "
+             " ; "
+             " echo 'set Output directory = output2.tmp' "
+             " ; "
+             " echo 'set Resume computation = true' "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  std::cout << "* now comparing:" << std::endl;
+
+  ret = system ("cd output-checkpoint_03_particles ; "
+                "cp output1.tmp/particles/particles-00009.0000.gnuplot particles-00009.0000.gnuplot1;"
+                "cp output2.tmp/particles/particles-00009.0000.gnuplot particles-00009.0000.gnuplot2;"
+                "cp output1.tmp/log.txt log.txt1;"
+                "cp output2.tmp/log.txt log.txt2;"
+                "cp output1.tmp/statistics statistics1;"
+                "cp output2.tmp/statistics statistics2;"
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // terminate current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/checkpoint_03_particles.prm.bak b/tests/checkpoint_03_particles.prm.bak
new file mode 100644
index 00000000000..483a6f84e35
--- /dev/null
+++ b/tests/checkpoint_03_particles.prm.bak
@@ -0,0 +1,97 @@
+# test checkpoint/resume.
+
+# This test is controlled via the plugin in checkpoint_03.cc. The plugin will
+# first execute ASPECT with this .prm and write the output into
+# output1.tmp/. This will generate a snapshot that is then resumed from. The
+# output for this second run will be written into output2.tmp/. Finally,
+# output files will be copied into the main output folder for comparison.
+
+# based on checkpoint_01.prm, but extended by particle serialization
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Checkpointing
+  set Steps between checkpoint = 4
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = false
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial position, position, velocity
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1000
+    end
+  end
+end
diff --git a/tests/checkpoint_04_particles_no_output.cc.bak b/tests/checkpoint_04_particles_no_output.cc.bak
new file mode 100644
index 00000000000..b8b4db22980
--- /dev/null
+++ b/tests/checkpoint_04_particles_no_output.cc.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Launch ASPECT
+ * twice to test checkpoint/resume and then terminate the outer ASPECT run.
+ */
+int f()
+{
+  std::cout << "* starting from beginning:" << std::endl;
+
+  // call ASPECT with "--" and pipe an existing input file into it.
+  int ret;
+  std::string command;
+
+  command = ("cd output-checkpoint_04_particles_no_output ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_04_particles_no_output.prm "
+             " ; "
+             " echo 'set Output directory = output1.tmp' "
+             " ; "
+             " rm -rf output1.tmp ; mkdir output1.tmp "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  command = ("cd output-checkpoint_04_particles_no_output ; "
+             " rm -rf output2.tmp ; mkdir output2.tmp ; "
+             " cp output1.tmp/restart* output2.tmp/");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now resuming:" << std::endl;
+  command = ("cd output-checkpoint_04_particles_no_output ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_04_particles_no_output.prm "
+             " ; "
+             " echo 'set Output directory = output2.tmp' "
+             " ; "
+             " echo 'set Resume computation = true' "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  std::cout << "* now comparing:" << std::endl;
+
+  ret = system ("cd output-checkpoint_04_particles_no_output ; "
+                "cp output1.tmp/log.txt log.txt1;"
+                "cp output2.tmp/log.txt log.txt2;"
+                "cp output1.tmp/statistics statistics1;"
+                "cp output2.tmp/statistics statistics2;"
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // terminate current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/checkpoint_04_particles_no_output.prm.bak b/tests/checkpoint_04_particles_no_output.prm.bak
new file mode 100644
index 00000000000..1994ec4bb68
--- /dev/null
+++ b/tests/checkpoint_04_particles_no_output.prm.bak
@@ -0,0 +1,97 @@
+# test checkpoint/resume.
+
+# This test is controlled via the plugin in checkpoint_03.cc. The plugin will
+# first execute ASPECT with this .prm and write the output into
+# output1.tmp/. This will generate a snapshot that is then resumed from. The
+# output for this second run will be written into output2.tmp/. Finally,
+# output files will be copied into the main output folder for comparison.
+
+# based on checkpoint_01.prm, but extended by particle serialization
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Checkpointing
+  set Steps between checkpoint = 4
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = false
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial position, position, velocity
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1000
+    end
+  end
+end
diff --git a/tests/checkpoint_05_mpi_create.prm.bak b/tests/checkpoint_05_mpi_create.prm.bak
new file mode 100644
index 00000000000..df3ba5115c1
--- /dev/null
+++ b/tests/checkpoint_05_mpi_create.prm.bak
@@ -0,0 +1,5 @@
+# Like checkpoint_01, but in parallel.
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/checkpoint_01.prm
diff --git a/tests/checkpoint_05_mpi_resume.cc.bak b/tests/checkpoint_05_mpi_resume.cc.bak
new file mode 100644
index 00000000000..f9a0881b0f8
--- /dev/null
+++ b/tests/checkpoint_05_mpi_resume.cc.bak
@@ -0,0 +1,55 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Copy checkpoint
+ * files into the correct place to resume model.
+ */
+int f()
+{
+  if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) != 0)
+    return 42;
+
+  std::cout << "* Copying checkpoint files." << std::endl;
+
+  std::string command;
+
+  command = ("mkdir -p output-checkpoint_05_mpi_resume; "
+             "cp -r output-checkpoint_05_mpi_create/restart* output-checkpoint_05_mpi_resume/");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  const int ret = system (command.c_str());
+  if (ret!=0)
+    {
+      std::cout << "system() returned error " << ret << std::endl;
+      exit(1);
+    }
+
+  std::cout << "* Finished copying files. Now resuming model." << std::endl;
+
+  return 42;
+}
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/checkpoint_05_mpi_resume.prm.bak b/tests/checkpoint_05_mpi_resume.prm.bak
new file mode 100644
index 00000000000..d66f1288f6f
--- /dev/null
+++ b/tests/checkpoint_05_mpi_resume.prm.bak
@@ -0,0 +1,12 @@
+# Like checkpoint_01, but in parallel. This test resumes from the checkpoint
+# written by checkpoint_05_mpi_write.  In order for this to work, this test
+# loads a shared library that copies the necessary checkpoint files into the
+# output directory of this test before starting the run.
+#
+# MPI: 2
+# DEPENDS-ON: checkpoint_05_mpi_create
+
+set Dimension = 2
+set Resume computation = true
+
+include $ASPECT_SOURCE_DIR/tests/checkpoint_01.prm
diff --git a/tests/checkpoint_06_spherical_shell.cc.bak b/tests/checkpoint_06_spherical_shell.cc.bak
new file mode 100644
index 00000000000..71991ccfb6e
--- /dev/null
+++ b/tests/checkpoint_06_spherical_shell.cc.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Launch ASPECT
+ * twice to test checkpoint/resume and then terminate the outer ASPECT run.
+ */
+int f()
+{
+  std::cout << "* starting from beginning:" << std::endl;
+
+  // call ASPECT with "--" and pipe an existing input file into it.
+  int ret;
+  std::string command;
+
+  command = ("cd output-checkpoint_06_spherical_shell ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_06_spherical_shell.prm "
+             " ; "
+             " echo 'set Output directory = output1.tmp' "
+             " ; "
+             " rm -rf output1.tmp ; mkdir output1.tmp "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  command = ("cd output-checkpoint_06_spherical_shell ; "
+             " rm -rf output2.tmp ; mkdir output2.tmp ; "
+             " cp output1.tmp/restart* output2.tmp/");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now resuming:" << std::endl;
+  command = ("cd output-checkpoint_06_spherical_shell ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_06_spherical_shell.prm "
+             " ; "
+             " echo 'set Output directory = output2.tmp' "
+             " ; "
+             " echo 'set Resume computation = true' "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  std::cout << "* now comparing:" << std::endl;
+
+  ret = system ("cd output-checkpoint_06_spherical_shell ; "
+                "cp output1.tmp/solution/solution-00005.0000.gnuplot solution-00005.0000.gnuplot1;"
+                "cp output2.tmp/solution/solution-00005.0000.gnuplot solution-00005.0000.gnuplot2;"
+                "cp output1.tmp/log.txt log.txt1;"
+                "cp output2.tmp/log.txt log.txt2;"
+                "cp output1.tmp/statistics statistics1;"
+                "cp output2.tmp/statistics statistics2;"
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // terminate current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/checkpoint_06_spherical_shell.prm.bak b/tests/checkpoint_06_spherical_shell.prm.bak
new file mode 100644
index 00000000000..458aa3bebb1
--- /dev/null
+++ b/tests/checkpoint_06_spherical_shell.prm.bak
@@ -0,0 +1,66 @@
+# test checkpoint/resume.
+
+# This test is controlled via the plugin in checkpoint_06_spherical_shell.cc. The plugin will
+# first execute ASPECT with this .prm and write the output into
+# output1.tmp/. This will generate a snapshot that is then resumed from. The
+# output for this second run will be written into output2.tmp/. Finally,
+# output files will be copied into the main output folder for comparison.
+
+# based on checkpoint_01, but for the spherical shell geometry, and therefore
+# a different mapping.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 3e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Checkpointing
+  set Steps between checkpoint = 4
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e20
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = surface
+  set Zero velocity boundary indicators       = bottom
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, temperature statistics, velocity statistics
+
+  subsection Visualization
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = false
+end
diff --git a/tests/checkpoint_07_enable_free_surface_create.prm.bak b/tests/checkpoint_07_enable_free_surface_create.prm.bak
new file mode 100644
index 00000000000..9588a7d1288
--- /dev/null
+++ b/tests/checkpoint_07_enable_free_surface_create.prm.bak
@@ -0,0 +1,74 @@
+# Test to start a model without free surface but with a zero mesh deformation
+# enabled and write a checkpoint (this test).
+# Another test (checkpoint_07_enable_free_surface_resume) will then test to
+# resume from this checkpoint and enable a free surface.
+
+# based on checkpoint_06_free_surface
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 3e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Pressure normalization                 = surface
+
+subsection Checkpointing
+  set Steps between checkpoint = 4
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = none
+
+  subsection Simple model
+    set Viscosity = 1e20
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: boundary function
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top
+  set Zero velocity boundary indicators       = bottom
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, temperature statistics, velocity statistics
+
+  subsection Visualization
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type =  block AMG
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = false
+end
diff --git a/tests/checkpoint_07_enable_free_surface_resume.cc.bak b/tests/checkpoint_07_enable_free_surface_resume.cc.bak
new file mode 100644
index 00000000000..0a67adf5e32
--- /dev/null
+++ b/tests/checkpoint_07_enable_free_surface_resume.cc.bak
@@ -0,0 +1,55 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Copy checkpoint
+ * files into the correct place to resume model.
+ */
+int f()
+{
+  if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) != 0)
+    return 42;
+
+  std::cout << "* Copying checkpoint files." << std::endl;
+
+  std::string command;
+
+  command = ("mkdir -p output-checkpoint_07_enable_free_surface_resume; "
+             "cp -r output-checkpoint_07_enable_free_surface_create/restart* output-checkpoint_07_enable_free_surface_resume/");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  const int ret = system (command.c_str());
+  if (ret!=0)
+    {
+      std::cout << "system() returned error " << ret << std::endl;
+      exit(1);
+    }
+
+  std::cout << "* Finished copying files. Now resuming model." << std::endl;
+
+  return 42;
+}
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/checkpoint_07_enable_free_surface_resume.prm.bak b/tests/checkpoint_07_enable_free_surface_resume.prm.bak
new file mode 100644
index 00000000000..442dbe7d106
--- /dev/null
+++ b/tests/checkpoint_07_enable_free_surface_resume.prm.bak
@@ -0,0 +1,31 @@
+# Test to start a model without free surface but with a zero mesh deformation
+# enabled and write a checkpoint (this test).
+# Another test (checkpoint_07_enable_free_surface_resume) will then test to
+# resume from this checkpoint and enable a free surface.
+
+# based on checkpoint_06_free_surface
+
+# DEPENDS-ON: checkpoint_07_enable_free_surface_create
+
+include $ASPECT_SOURCE_DIR/tests/checkpoint_07_enable_free_surface_create.prm
+
+set Dimension = 2
+set Resume computation = true
+set Pressure normalization = no
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators =
+end
+
+# Enabling the free surface during the model run can throw off
+# the solver. Loosen the tolerance of the A block preconditioner
+# to allow for solver convergence.
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver A block tolerance = 1e-1
+  end
+end
diff --git a/tests/chunk_ascii_initial_temperature.prm.bak b/tests/chunk_ascii_initial_temperature.prm.bak
new file mode 100644
index 00000000000..b3b6212acf0
--- /dev/null
+++ b/tests/chunk_ascii_initial_temperature.prm.bak
@@ -0,0 +1,75 @@
+# A simple test that checks the temperature initialization
+# via ascii file in a 2D chunk geometry.
+# Sets a harmonic perturbation to the temperature field,
+# and lower and upper temperature boundary conditions.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Longitude repetitions = 1
+    set Chunk inner radius = 3481000
+    set Chunk outer radius = 6336000
+    set Radius repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = shell_2d.txt
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 0
+    set Outer temperature = 0
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer
+  set Zero velocity boundary indicators       = inner
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+end
diff --git a/tests/chunk_conditions.prm.bak b/tests/chunk_conditions.prm.bak
new file mode 100644
index 00000000000..118a4dd36b8
--- /dev/null
+++ b/tests/chunk_conditions.prm.bak
@@ -0,0 +1,77 @@
+# A simple test that checks the temperature initialization
+# in a 2D chunk geometry. Sets a harmonic perturbation to
+# the temperature field, and lower and upper temperature
+# boundary conditions.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 60
+    set Chunk maximum longitude = 120
+    set Longitude repetitions = 1
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 1800
+    set Outer temperature = 273
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer
+  set Zero velocity boundary indicators       = inner
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+end
diff --git a/tests/chunk_cross_hemisphere.prm.bak b/tests/chunk_cross_hemisphere.prm.bak
new file mode 100644
index 00000000000..903fb07eac8
--- /dev/null
+++ b/tests/chunk_cross_hemisphere.prm.bak
@@ -0,0 +1,74 @@
+# An input script to test the chunk geometry model
+# where the domain crosses both hemispheres.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = -10
+    set Chunk maximum longitude = 220
+    set Longitude repetitions = 2
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer, east, west
+  set Zero velocity boundary indicators       = inner
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics
+end
diff --git a/tests/chunk_first_time_step_2d.prm.bak b/tests/chunk_first_time_step_2d.prm.bak
new file mode 100644
index 00000000000..9c34b84f55f
--- /dev/null
+++ b/tests/chunk_first_time_step_2d.prm.bak
@@ -0,0 +1,74 @@
+# An input script to test the chunk geometry model
+# Designed to check the mesh set-up in 2D
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 30
+    set Longitude repetitions = 1
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer
+  set Zero velocity boundary indicators       = inner
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics
+end
diff --git a/tests/chunk_first_time_step_3d.prm.bak b/tests/chunk_first_time_step_3d.prm.bak
new file mode 100644
index 00000000000..a512ae929d6
--- /dev/null
+++ b/tests/chunk_first_time_step_3d.prm.bak
@@ -0,0 +1,74 @@
+# An input script to test the chunk geometry model
+# Designed to check the mesh set-up in 3D
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = -20
+    set Chunk maximum longitude = 20
+    set Longitude repetitions = 1
+    set Chunk minimum latitude = -10
+    set Chunk maximum latitude = 10
+    set Latitude repetitions = 1
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer
+  set Zero velocity boundary indicators       = inner, west, east
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics
+end
diff --git a/tests/chunk_initial_topography_ascii_data.prm.bak b/tests/chunk_initial_topography_ascii_data.prm.bak
new file mode 100644
index 00000000000..0401f46466b
--- /dev/null
+++ b/tests/chunk_initial_topography_ascii_data.prm.bak
@@ -0,0 +1,83 @@
+# An input script to test the chunk geometry model
+# with additional initial topography.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Longitude repetitions = 1
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+      set Data file name       = shell_2d_outer.0.txt
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer, east, west
+  set Zero velocity boundary indicators       = inner
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, topography
+end
diff --git a/tests/chunk_initial_topography_ascii_data_3d.prm.bak b/tests/chunk_initial_topography_ascii_data_3d.prm.bak
new file mode 100644
index 00000000000..95d540c3b4c
--- /dev/null
+++ b/tests/chunk_initial_topography_ascii_data_3d.prm.bak
@@ -0,0 +1,88 @@
+# An input script to test the chunk geometry model
+# with additional initial topography.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = -20
+    set Chunk maximum longitude = 20
+    set Longitude repetitions = 1
+    set Chunk minimum latitude = -20
+    set Chunk maximum latitude = 20
+    set Latitude repetitions = 1
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+      set Data file name       = shell_3d_outer.0.txt
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer, east, west, north, south
+  set Zero velocity boundary indicators       = inner
+end
+
+# The ascii data file prescribes a topography between -2000 m and
+# +9000 m. The topography postprocessor output should match with this.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, topography
+end
diff --git a/tests/chunk_initial_topography_ascii_data_3d_colatitude.prm.bak b/tests/chunk_initial_topography_ascii_data_3d_colatitude.prm.bak
new file mode 100644
index 00000000000..7f074c69fb7
--- /dev/null
+++ b/tests/chunk_initial_topography_ascii_data_3d_colatitude.prm.bak
@@ -0,0 +1,19 @@
+# An input script to test the chunk geometry model
+# with additional initial topography with a gradient
+# in the latitudinal direction.
+include $ASPECT_SOURCE_DIR/tests/chunk_initial_topography_ascii_data_3d.prm
+
+set Dimension                       = 3
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+      set Data file name       = shell_3d_outer_2.0.txt
+    end
+  end
+end
diff --git a/tests/chunk_lithostatic_pressure_2d.prm.bak b/tests/chunk_lithostatic_pressure_2d.prm.bak
new file mode 100644
index 00000000000..b2714dd2e9d
--- /dev/null
+++ b/tests/chunk_lithostatic_pressure_2d.prm.bak
@@ -0,0 +1,132 @@
+# In this test we prescribe a lithostatic pressure
+# for the traction on the eastern boundary of the
+# chunk geometry. This boundary condition is known
+# as "open". However, there are no lateral variations
+# in density, so with increasing resolution,
+# velocity should go to zero.
+
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600
+set Surface pressure                       = 0
+set Pressure normalization                 = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+# Because the eastern boundary is open and material might
+# move through it,
+# we set fixed temperature and composition boundary conditions.
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = inner, outer, east
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = inner, outer, east
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3471000
+    set Chunk outer radius = 6371000
+    set Chunk minimum longitude = 10
+    set Chunk maximum longitude = 50
+    set Chunk minimum latitude = 0
+    set Chunk maximum latitude = 40
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.600e3
+  end
+end
+
+# We prescribe one compositional field
+# to represent the lithosphere
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities                  = 3300,3250
+    set Reference temperature      = 293
+    set Specific heats             = 1250
+    set Thermal conductivities     = 4.7
+    set Thermal expansivities      = 2e-5
+    set Viscosities                = 1e21,1e24
+    set Viscosity averaging scheme = harmonic
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system = spherical
+    set Function expression = if (y > 45.0*pi/180.0, 4, 3)
+  end
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = east: initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Representative point =  6371000, 50, 40
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, outer, west, north, south
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = lith_depth=8e4, model_height=6e5
+    set Function expression = if(z>=(model_height-lith_depth),-1,0);0
+  end
+end
+
+# The lithosphere is represented by a lower density,
+# higher viscosity compositional field.
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y,z
+    set Function constants = lith_depth=100e3, model_height=6e5
+    set Function expression = if(sqrt(x*x+y*y+z*z)<(6.371e6-lith_depth),0,1)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, visualization
+
+  subsection Visualization
+    set Point-wise stress and strain = true
+    set Interpolate output = false
+    set Output format = gnuplot
+    set List of output variables = stress, strain rate, nonadiabatic pressure
+  end
+end
diff --git a/tests/chunk_lithostatic_pressure_2d_initial_topography.prm.bak b/tests/chunk_lithostatic_pressure_2d_initial_topography.prm.bak
new file mode 100644
index 00000000000..8f7243b24fb
--- /dev/null
+++ b/tests/chunk_lithostatic_pressure_2d_initial_topography.prm.bak
@@ -0,0 +1,46 @@
+# In this variation on chunk_lithostatic_pressure_2d.prm
+# we test whether the point_is_in_domain function
+# handles the initial topography correctly. We therefore
+# add an initial topography and pick a representative point
+# for the initial lithostatic pressure that lies above
+# the unperturbed surface but below the surface plus
+# initial topography.
+
+include $ASPECT_SOURCE_DIR/tests/chunk_lithostatic_pressure_2d.prm
+
+set Dimension = 2
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3471000
+    set Chunk outer radius = 6371000
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 50
+  end
+
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+      set Data file name       = shell_2d_outer.0.txt
+    end
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, outer, west
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = east: initial lithostatic pressure
+
+  # Set a radius between 6371 and 6461 km (surface radius
+  # without and with 90 km initial topography at 0 degrees longitude.
+  subsection Initial lithostatic pressure
+    set Representative point =  6394000, 0.1
+  end
+end
diff --git a/tests/chunk_tangential_velocity.prm.bak b/tests/chunk_tangential_velocity.prm.bak
new file mode 100644
index 00000000000..49b03af1694
--- /dev/null
+++ b/tests/chunk_tangential_velocity.prm.bak
@@ -0,0 +1,92 @@
+# This test makes sure the issue discussed in
+# https://github.com/geodynamics/aspect/issues/3359
+# has been fixed (accurate tangential velocity
+# boundary conditions for models with chunk
+# geometry and a free surface boundary).
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 273
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Pressure normalization                 = no
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 8.e18
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Chunk inner radius = 5620.e3
+    set Chunk outer radius = 6370.e3
+    set Longitude repetitions = 13
+    set Radius repetitions = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.8
+  end
+end
+
+subsection Mesh deformation
+  set Additional tangential mesh velocity boundary indicators = east,west
+  set Mesh deformation boundary indicators = outer:free surface
+
+  subsection Free surface
+    set Surface velocity projection      = normal
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, west, east
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = outer: function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r,theta,t
+    set Function expression = 0;0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Outer temperature = 273
+    set Inner temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = minimum refinement function
+end
+
+subsection Postprocess
+  set List of postprocessors = topography, velocity statistics, heat flux statistics
+end
diff --git a/tests/chunk_topography_postprocessor.prm.bak b/tests/chunk_topography_postprocessor.prm.bak
new file mode 100644
index 00000000000..1c2e3d6187a
--- /dev/null
+++ b/tests/chunk_topography_postprocessor.prm.bak
@@ -0,0 +1,115 @@
+# This test computes min/max topography
+# for a chunk with a free surface.
+
+set Dimension = 2
+set CFL number                             = 0.1
+set End time                               = 1e9
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = inner:0,outer:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+    set Longitude repetitions = 2
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-3000.e3)^2 + (y-3000.e3)^2 ) < 500.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner, east, west
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = outer: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/command_postprocessor.prm.bak b/tests/command_postprocessor.prm.bak
new file mode 100644
index 00000000000..ddafc95f81a
--- /dev/null
+++ b/tests/command_postprocessor.prm.bak
@@ -0,0 +1,40 @@
+# Test that ASPECT executes a shell command using the
+# command postprocessor.
+
+set Dimension = 2
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = box
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = command
+
+  subsection Command
+    set Command = /bin/bash -c "echo 'Hello, world'"
+    set Run on all processes = false
+    set Terminate on failure = false
+  end
+end
diff --git a/tests/compaction_length_refinement.prm.bak b/tests/compaction_length_refinement.prm.bak
new file mode 100644
index 00000000000..6ec413f239a
--- /dev/null
+++ b/tests/compaction_length_refinement.prm.bak
@@ -0,0 +1,128 @@
+# Test the compaction length refinement criterion.
+# The compaction length is 1 at the lower left boundary,
+# and two magnitudes smaller at the top right boundary,
+# and we specify two cells per compaction length.
+# Hence, the finest cells should be on refinement level 8,
+# and in the top right corner.
+# The permeability changes along the x axis, the viscosity
+# along the y axis.
+
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 20
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 1 + 4.605170186 * y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5 - 0.4286 * x; 0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Thermal conductivity              = 0
+    set Reference solid density           = 1
+    set Reference melt density            = 1
+    set Thermal expansion coefficient     = 0
+    set Reference permeability            = 32 #permeability of 1 for phi=0.5
+    set Reference shear viscosity         = 0.5
+    set Reference bulk viscosity          = 0.375
+    set Exponential melt weakening factor = 0
+    set Thermal viscosity exponent        = 1
+    set Thermal bulk viscosity exponent   = 1
+    set Reference temperature             = 1
+    set Solid compressibility             = 0
+    set Melt compressibility              = 0
+    set Reference melt viscosity          = 1
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.5
+  set Refinement fraction                      = 0.5
+  set Initial adaptive refinement              = 5
+  set Initial global refinement                = 5
+  set Strategy                                 = compaction length
+  set Time steps between mesh refinement       = 0
+
+  subsection Compaction length
+    set Mesh cells per compaction length       = 2
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
diff --git a/tests/compaction_length_visualization.prm.bak b/tests/compaction_length_visualization.prm.bak
new file mode 100644
index 00000000000..9129c4af5d3
--- /dev/null
+++ b/tests/compaction_length_visualization.prm.bak
@@ -0,0 +1,123 @@
+# Tests the compaction length visualization plugin.
+# Based on compaction_length_refinement.prm
+
+
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 20
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 1 + 4.605170186 * y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5 - 0.4286 * x; 0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Thermal conductivity              = 0
+    set Reference solid density           = 1
+    set Reference melt density            = 1
+    set Thermal expansion coefficient     = 0
+    set Reference permeability            = 32 #permeability of 1 for phi=0.5
+    set Reference shear viscosity         = 0.5
+    set Reference bulk viscosity          = 0.375
+    set Exponential melt weakening factor = 0
+    set Thermal viscosity exponent        = 1
+    set Thermal bulk viscosity exponent   = 1
+    set Reference temperature             = 1
+    set Solid compressibility             = 0
+    set Melt compressibility              = 0
+    set Reference melt viscosity          = 1
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.5
+  set Refinement fraction                      = 0.5
+  set Initial adaptive refinement              = 5
+  set Initial global refinement                = 5
+  set Strategy                                 = compaction length
+  set Time steps between mesh refinement       = 0
+
+  subsection Compaction length
+    set Mesh cells per compaction length       = 2
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity, compaction length, is melt cell
+    end
+  end
+end
diff --git a/tests/composite_viscous_outputs.cc.bak b/tests/composite_viscous_outputs.cc.bak
new file mode 100644
index 00000000000..d06d7d4917c
--- /dev/null
+++ b/tests/composite_viscous_outputs.cc.bak
@@ -0,0 +1,208 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/material_model/rheology/composite_visco_plastic.h>
+
+template <int dim>
+void f(const aspect::SimulatorAccess<dim> &simulator_access,
+       aspect::Assemblers::Manager<dim> &)
+{
+  // This function tests whether the composite creep rheology is producing
+  // the correct composite viscosity and partial strain rates corresponding to
+  // the different creep mechanisms incorporated into the rheology.
+  // It is assumed that each individual creep mechanism has already been tested.
+
+  using namespace aspect::MaterialModel;
+
+  // First, we set up a few objects which are used by the rheology model.
+  aspect::ParameterHandler prm;
+  const std::vector<std::string> list_of_composition_names = simulator_access.introspection().get_composition_names();
+  auto n_phases = std::make_unique<std::vector<unsigned int>>(1); // 1 phase per composition
+  const unsigned int composition = 0;
+  const std::vector<double> volume_fractions = {1.};
+  const std::vector<double> phase_function_values = std::vector<double>();
+  const std::vector<unsigned int> n_phase_transitions_per_composition = std::vector<unsigned int>(1);
+
+  // Next, we initialise instances of the composite rheology and
+  // individual creep mechanisms.
+  std::unique_ptr<Rheology::CompositeViscoPlastic<dim>> composite_creep;
+  composite_creep = std::make_unique<Rheology::CompositeViscoPlastic<dim>>();
+  composite_creep->initialize_simulator (simulator_access.get_simulator());
+  composite_creep->declare_parameters(prm);
+  prm.set("Use plastic damper", "true");
+  prm.set("Plastic damper viscosity", "1.e17");
+  prm.set("Maximum yield stress", "5e8");
+  composite_creep->parse_parameters(prm, n_phases);
+
+  std::unique_ptr<Rheology::DiffusionCreep<dim>> diffusion_creep;
+  diffusion_creep = std::make_unique<Rheology::DiffusionCreep<dim>>();
+  diffusion_creep->initialize_simulator (simulator_access.get_simulator());
+  diffusion_creep->declare_parameters(prm);
+  diffusion_creep->parse_parameters(prm, n_phases);
+
+  std::unique_ptr<Rheology::DislocationCreep<dim>> dislocation_creep;
+  dislocation_creep = std::make_unique<Rheology::DislocationCreep<dim>>();
+  dislocation_creep->initialize_simulator (simulator_access.get_simulator());
+  dislocation_creep->declare_parameters(prm);
+  dislocation_creep->parse_parameters(prm, n_phases);
+
+  std::unique_ptr<Rheology::PeierlsCreep<dim>> peierls_creep;
+  peierls_creep = std::make_unique<Rheology::PeierlsCreep<dim>>();
+  peierls_creep->initialize_simulator (simulator_access.get_simulator());
+  peierls_creep->declare_parameters(prm);
+  peierls_creep->parse_parameters(prm, n_phases);
+
+  std::unique_ptr<Rheology::DruckerPrager<dim>> drucker_prager;
+  drucker_prager = std::make_unique<Rheology::DruckerPrager<dim>>();
+  drucker_prager->initialize_simulator (simulator_access.get_simulator());
+  drucker_prager->declare_parameters(prm);
+  prm.set("Use plastic damper", "true");
+  prm.set("Plastic damper viscosity", "1.e17");
+  prm.set("Maximum yield stress", "5e8");
+  drucker_prager->parse_parameters(prm, n_phases);
+  Rheology::DruckerPragerParameters p = drucker_prager->compute_drucker_prager_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
+
+  // The creep components are arranged in series with each other.
+  // This package of components is then arranged in parallel with
+  // a strain rate limiter with a constant viscosity lim_visc.
+  // The whole system is then arranged in series with a viscosity limiter with
+  // viscosity max_visc.
+  // lim_visc is equal to (min_visc*max_visc)/(max_visc - min_visc)
+  double min_visc = prm.get_double("Minimum viscosity");
+  double max_visc = prm.get_double("Maximum viscosity");
+  double lim_visc = (min_visc*max_visc)/(max_visc - min_visc);
+
+  // Assign values to the variables which will be passed to compute_viscosity
+  // The test involves pure shear calculations at 1 GPa and variable temperature
+  double temperature;
+  const double pressure = 1.e9;
+  SymmetricTensor<2,dim> strain_rate;
+  strain_rate[0][0] = -1e-11;
+  strain_rate[0][1] = 0.;
+  strain_rate[1][1] = 1e-11;
+  strain_rate[2][0] = 0.;
+  strain_rate[2][1] = 0.;
+  strain_rate[2][2] = 0.;
+
+  std::cout << "temperature (K)   eta (Pas)   creep stress (Pa)   edot_ii (/s)   edot_ii fractions (diff, disl, prls, drpr, max)" << std::endl;
+
+  // Loop through strain rates, tracking whether there is a discrepancy in
+  // the decomposed strain rates.
+  bool error = false;
+  double viscosity;
+  double total_strain_rate;
+  double creep_strain_rate;
+  double creep_stress;
+  double diff_stress;
+  double disl_stress;
+  double prls_stress;
+  double drpr_stress;
+  std::vector<double> partial_strain_rates(5, 0.);
+
+  for (unsigned int i=0; i <= 10; i++)
+    {
+      temperature = 1000. + i*100.;
+
+      // Compute the viscosity
+      viscosity = composite_creep->compute_composition_viscosity(pressure, temperature, composition, strain_rate, partial_strain_rates);
+      total_strain_rate = std::accumulate(partial_strain_rates.begin(), partial_strain_rates.end(), 0.);
+
+      // The creep strain rate is calculated by subtracting the strain rate
+      // of the max viscosity dashpot from the total strain rate
+      // The creep stress is then calculated by subtracting the stress running
+      // through the strain rate limiter from the total stress
+      creep_strain_rate = total_strain_rate - partial_strain_rates[4];
+      creep_stress = 2.*(viscosity*total_strain_rate - lim_visc*creep_strain_rate);
+
+      // Print the output
+      std::cout << temperature << ' ' << viscosity << ' ' << creep_stress << ' ' << total_strain_rate;
+      for (unsigned int i=0; i < partial_strain_rates.size(); ++i)
+        {
+          std::cout << ' ' << partial_strain_rates[i]/total_strain_rate;
+        }
+      std::cout << std::endl;
+
+      // The following lines test that each individual creep mechanism
+      // experiences the same creep stress
+
+      // Each creep mechanism should experience the same stress
+      diff_stress = 2.*partial_strain_rates[0]*diffusion_creep->compute_viscosity(pressure, temperature, composition);
+      disl_stress = 2.*partial_strain_rates[1]*dislocation_creep->compute_viscosity(partial_strain_rates[1], pressure, temperature, composition);
+      prls_stress = 2.*partial_strain_rates[2]*peierls_creep->compute_viscosity(partial_strain_rates[2], pressure, temperature, composition);
+      if (partial_strain_rates[3] > 0.)
+        {
+          drpr_stress = 2.*partial_strain_rates[3]*drucker_prager->compute_viscosity(p.cohesion,
+                                                                                     p.angle_internal_friction,
+                                                                                     pressure,
+                                                                                     partial_strain_rates[3],
+                                                                                     p.max_yield_stress,
+                                                                                     std::numeric_limits<double>::infinity());
+        }
+      else
+        {
+          drpr_stress = creep_stress;
+        }
+
+      if ((std::fabs((diff_stress - creep_stress)/creep_stress) > 1e-6)
+          || (std::fabs((disl_stress - creep_stress)/creep_stress) > 1e-6)
+          || (std::fabs((prls_stress - creep_stress)/creep_stress) > 1e-6)
+          || (std::fabs((drpr_stress - creep_stress)/creep_stress) > 1e-6))
+        {
+          error = true;
+          std::cout << "   creep stress: " << creep_stress;
+          std::cout << " diffusion stress: " << diff_stress;
+          std::cout << " dislocation stress: " << disl_stress;
+          std::cout << " peierls stress: " << prls_stress;
+          std::cout << " drucker prager stress: " << drpr_stress << std::endl;
+        }
+    }
+
+  if (error)
+    {
+      std::cout << "   Error: The individual creep stresses differ by more than the required tolerance." << std::endl;
+      std::cout << "Some parts of the test were not successful." << std::endl;
+    }
+  else
+    {
+      std::cout << "OK" << std::endl;
+    }
+
+}
+
+template <>
+void f(const aspect::SimulatorAccess<2> &,
+       aspect::Assemblers::Manager<2> &)
+{
+  AssertThrow(false,dealii::ExcInternalError());
+}
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  using namespace dealii;
+  std::cout << "* Connecting signals" << std::endl;
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2));
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/composite_viscous_outputs.prm.bak b/tests/composite_viscous_outputs.prm.bak
new file mode 100644
index 00000000000..2b8963c6d83
--- /dev/null
+++ b/tests/composite_viscous_outputs.prm.bak
@@ -0,0 +1,80 @@
+# This test checks whether the composite viscous rheology
+# plugin produces the correct composite viscosity and
+# decomposed strain rates.
+
+set Additional shared libraries = tests/libcomposite_viscous_outputs.so
+set Dimension                              = 3
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Angles of internal friction = 30.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
diff --git a/tests/compositing_02.prm.bak b/tests/compositing_02.prm.bak
new file mode 100644
index 00000000000..72b2e636831
--- /dev/null
+++ b/tests/compositing_02.prm.bak
@@ -0,0 +1,119 @@
+# Test compositing material model with Steinberger
+#
+# copy of steinberger_seismic_velocities.prm
+#
+# This was broken because a call to initialize() to the models was missing in
+# the compositing model/
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = compositing
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names              = pyr-ringwood88.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+  end
+
+  subsection Compositing
+    set Viscosity = simple
+    set Density = Steinberger
+    set Thermal expansion coefficient = Steinberger
+    set Specific heat = Steinberger
+    set Thermal conductivity = Steinberger
+    set Compressibility = Steinberger
+    set Entropy derivative pressure = Steinberger
+    set Entropy derivative temperature = Steinberger
+    set Reaction terms = Steinberger
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = named additional outputs, Vs anomaly, Vp anomaly
+    set Time between graphical output = 0
+
+    subsection Vp anomaly
+      set Number of depth slices = 96
+    end
+
+    subsection Vs anomaly
+      set Number of depth slices = 96
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/compositing_named_outputs.prm.bak b/tests/compositing_named_outputs.prm.bak
new file mode 100644
index 00000000000..3e212dce3cf
--- /dev/null
+++ b/tests/compositing_named_outputs.prm.bak
@@ -0,0 +1,92 @@
+# Compositing material model with named outputs
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = compositing
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+
+  subsection Compositing
+    set Viscosity = simple
+    set Density = visco plastic
+    set Thermal expansion coefficient = simple
+    set Specific heat = simple
+    set Thermal conductivity = simple
+    set Compressibility = simple
+    set Entropy derivative pressure = simple
+    set Entropy derivative temperature = simple
+    set Reaction terms = simple
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density, named additional outputs
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/composition_active.prm.bak b/tests/composition_active.prm.bak
new file mode 100644
index 00000000000..caed2044777
--- /dev/null
+++ b/tests/composition_active.prm.bak
@@ -0,0 +1,107 @@
+#########################################################
+# This is a variation of the platelike_boundary.prm file.
+# All settings are exactly the same with the exception
+# of the ones that pertain to compositional fields.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 4
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/tests/composition_active_nans.prm.bak b/tests/composition_active_nans.prm.bak
new file mode 100644
index 00000000000..8bc5ff24ceb
--- /dev/null
+++ b/tests/composition_active_nans.prm.bak
@@ -0,0 +1,21 @@
+# When using the 'artificial viscosity' viz postprocessor in parallel,
+# we used to put NaNs into the output vector (for ghost and artificial
+# cells) that then triggered floating point exceptions. Check that
+# this no longer happens. For this, all we need to do is get past the
+# first time we create graphical output.
+
+# MPI: 2
+
+include $ASPECT_SOURCE_DIR/tests/composition_active.prm
+
+set End time                               = 0.1
+
+subsection Postprocess
+  subsection Visualization
+    set List of output variables = density, artificial viscosity, artificial viscosity composition
+
+    subsection Artificial viscosity composition
+      set Name of compositional field = C_1
+    end
+  end
+end
diff --git a/tests/composition_active_with_melt.cc.bak b/tests/composition_active_with_melt.cc.bak
new file mode 100644
index 00000000000..9e99dfd3ab8
--- /dev/null
+++ b/tests/composition_active_with_melt.cc.bak
@@ -0,0 +1,158 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/melt.h>
+#include <deal.II/base/parameter_handler.h>
+
+/**
+ * This material model extends the simple material model
+ * to include melt transport.
+ */
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim>
+  class SimpleWithMelt:
+    public MaterialModel::MeltInterface<dim>
+  {
+    public:
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        return 1.0;
+      }
+
+
+      /**
+       * Declare the parameters this class takes through input files.
+       */
+      static
+      void
+      declare_parameters (ParameterHandler &prm);
+
+      /**
+       * Read the parameters this class declares from the parameter file.
+       */
+      virtual
+      void
+      parse_parameters (ParameterHandler &prm);
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            out.viscosities[i] = 1.0;
+            out.thermal_expansion_coefficients[i] = 0.01;
+            out.specific_heat[i] = 1250.0;
+            out.thermal_conductivities[i] = 1e-6;
+            out.compressibilities[i] = 0.0;
+            out.densities[i] = 1.0 * (1 - out.thermal_expansion_coefficients[i] * in.temperature[i])
+                               + compositional_delta_rho*std::max(in.composition[i][0],0.0);
+
+            // Pressure derivative of entropy at the given positions.
+            out.entropy_derivative_pressure[i] = 0.0;
+            // Temperature derivative of entropy at the given positions.
+            out.entropy_derivative_temperature[i] = 0.0;
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                melt_out->compaction_viscosities[i] = 1.0;
+                melt_out->fluid_viscosities[i] = 1.0;
+                melt_out->permeabilities[i] = 0.0; //1e-30*porosity * porosity;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+                melt_out->fluid_densities[i] = 1.0;
+              }
+          }
+      }
+
+    private:
+      double compositional_delta_rho;
+
+  };
+
+  template <int dim>
+  void
+  SimpleWithMelt<dim>::declare_parameters (ParameterHandler &prm)
+  {
+    prm.enter_subsection("Material model");
+    {
+      prm.enter_subsection("Simple with melt");
+      {
+        prm.declare_entry ("Density differential for compositional field 1", "100.0",
+                           Patterns::Double(),
+                           "If compositional fields are used, then one would frequently want "
+                           "to make the density depend on these fields. In this simple material "
+                           "model, we make the following assumptions: if no compositional fields "
+                           "are used in the current simulation, then the density is simply the usual "
+                           "one with its linear dependence on the temperature. If there are compositional "
+                           "fields, then the density only depends on the first one in such a way that "
+                           "the density has an additional term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
+                           "This parameter describes the value of $\\Delta \\rho$. "
+                           "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection();
+  }
+
+
+
+  template <int dim>
+  void
+  SimpleWithMelt<dim>::parse_parameters (ParameterHandler &prm)
+  {
+    prm.enter_subsection("Material model");
+    {
+      prm.enter_subsection("Simple with melt");
+      {
+        compositional_delta_rho    = prm.get_double ("Density differential for compositional field 1");
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection();
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_MATERIAL_MODEL(SimpleWithMelt,
+                                 "simple with melt",
+                                 "A simple material model that is like the "
+                                 "'simple' model, but with melt migration.")
+}
diff --git a/tests/composition_active_with_melt.prm.bak b/tests/composition_active_with_melt.prm.bak
new file mode 100644
index 00000000000..641bcbcb0b5
--- /dev/null
+++ b/tests/composition_active_with_melt.prm.bak
@@ -0,0 +1,106 @@
+#########################################################
+# This is a variation of the platelike-boundary.prm file.
+# It is identical to the composition-active test, except
+# for the second compositional field, which is called
+# porosity and set to zero, and Include melt transport is
+# set to true. Result can be compared to the test
+# composition-active-without-melt.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+  set Use discontinuous compaction pressure   = false
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple with melt
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, composition statistics
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = C_1, porosity
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ;  0.0
+  end
+end
diff --git a/tests/composition_active_without_melt.cc.bak b/tests/composition_active_without_melt.cc.bak
new file mode 100644
index 00000000000..7fdcf9950f6
--- /dev/null
+++ b/tests/composition_active_without_melt.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "composition_active_with_melt.cc"
diff --git a/tests/composition_active_without_melt.prm.bak b/tests/composition_active_without_melt.prm.bak
new file mode 100644
index 00000000000..66b93bad723
--- /dev/null
+++ b/tests/composition_active_without_melt.prm.bak
@@ -0,0 +1,100 @@
+#########################################################
+# This is a variation of the platelike-boundary.prm file.
+# It is identical to the composition-active test, except
+# for the second compositional field, which is called
+# porosity and set to zero. This is for comparison to
+# models with melt migration.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple with melt
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, composition statistics
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = C_1, porosity
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ;  0.0
+  end
+end
diff --git a/tests/composition_cg_dg_fem.prm.bak b/tests/composition_cg_dg_fem.prm.bak
new file mode 100644
index 00000000000..4959bbadef3
--- /dev/null
+++ b/tests/composition_cg_dg_fem.prm.bak
@@ -0,0 +1,96 @@
+#
+#
+# copied from discontinuous_composition_1.prm
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 2
+end
+
+subsection Discretization
+  set Use discontinuous temperature discretization = false
+  set Use discontinuous composition discretization = true,false
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, composition statistics
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/tests/composition_names.prm.bak b/tests/composition_names.prm.bak
new file mode 100644
index 00000000000..5245dffc549
--- /dev/null
+++ b/tests/composition_names.prm.bak
@@ -0,0 +1,117 @@
+# test composition names
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = peridotite, eclogite
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/composition_names_duplicates.prm.bak b/tests/composition_names_duplicates.prm.bak
new file mode 100644
index 00000000000..1058f9c3eb7
--- /dev/null
+++ b/tests/composition_names_duplicates.prm.bak
@@ -0,0 +1,95 @@
+# A test to ensure the naming of compositional fields works as expected.
+
+# EXPECT FAILURE
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Dimension                              = 2
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = peridotite, density
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,3
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Maximal temperature = 3773
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = material properties
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/composition_passive_discontinuous_constant.prm.bak b/tests/composition_passive_discontinuous_constant.prm.bak
new file mode 100644
index 00000000000..cf39800564f
--- /dev/null
+++ b/tests/composition_passive_discontinuous_constant.prm.bak
@@ -0,0 +1,99 @@
+# This is a variation of the composition_passive_passive.prm
+# test that uses a DGQ0 (cell-wise constant) composition element.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Discretization
+  set Composition polynomial degree = 0
+  set Use discontinuous composition discretization = true
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average only viscosity
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.1
+    set Output format                 = gnuplot
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields with same initial condition
+# and only the first one will be advected along.
+subsection Compositional fields
+  set Number of fields = 1
+  set Compositional field methods = field
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0)
+  end
+end
diff --git a/tests/composition_passive_particles.prm.bak b/tests/composition_passive_particles.prm.bak
new file mode 100644
index 00000000000..6c54199b045
--- /dev/null
+++ b/tests/composition_passive_particles.prm.bak
@@ -0,0 +1,111 @@
+#########################################################
+# This is a variation of the composition_passive.prm
+# parameter file, with the exception that we also
+# advect along a set of particles and that we do not longer
+# compute temperature statistics and composition statistics
+# as part of postprocessing
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format = vtu
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
+
+subsection Particles
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/composition_passive_quarter_shell_cartesian.prm.bak b/tests/composition_passive_quarter_shell_cartesian.prm.bak
new file mode 100644
index 00000000000..11e38f25dce
--- /dev/null
+++ b/tests/composition_passive_quarter_shell_cartesian.prm.bak
@@ -0,0 +1,108 @@
+#########################################################
+# This is a variation of the platelike-boundary.prm file.
+# All settings are exactly the same with the exception
+# of the ones that pertain to compositional fields.
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+set Output directory                       = output_composition-passive_quarter-shell-cartesian
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = .45
+    set Outer radius  = 1
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, inner, outer
+  set Prescribed velocity boundary indicators =   #outer: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system   = spherical
+    set Variable names      = r, phi
+    set Function expression = (1-r)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Coordinate system   = cartesian
+    set Function expression = if ((x > 0.6 && x < 0.8 && y > 0.1 && y < 0.5), 1, 0) ; if ((x > 0.5 && x < 0.6 && y > 0.1 && y < 0.5), 1, 0)
+  end
+end
diff --git a/tests/composition_passive_quarter_shell_depth.prm.bak b/tests/composition_passive_quarter_shell_depth.prm.bak
new file mode 100644
index 00000000000..1d19d63ef70
--- /dev/null
+++ b/tests/composition_passive_quarter_shell_depth.prm.bak
@@ -0,0 +1,108 @@
+#########################################################
+# This is a variation of the platelike-boundary.prm file.
+# All settings are exactly the same with the exception
+# of the ones that pertain to compositional fields.
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+set Output directory                       = output_composition-passive_quarter-shell-depth
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = .45
+    set Outer radius  = 1
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, inner, outer
+  set Prescribed velocity boundary indicators =   #outer: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system   = spherical
+    set Variable names      = r, phi
+    set Function expression = (1-r)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = d,na
+    set Coordinate system   = depth
+    set Function expression = if (d > 0.1 && d < 0.2 , 1, 0) ; if (d < 0.4 && d > 0.3, 1, 0)
+  end
+end
diff --git a/tests/composition_passive_quarter_shell_spherical.prm.bak b/tests/composition_passive_quarter_shell_spherical.prm.bak
new file mode 100644
index 00000000000..cfadb1c1b53
--- /dev/null
+++ b/tests/composition_passive_quarter_shell_spherical.prm.bak
@@ -0,0 +1,108 @@
+#########################################################
+# This is a variation of the platelike-boundary.prm file.
+# All settings are exactly the same with the exception
+# of the ones that pertain to compositional fields.
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20
+set Use years in output instead of seconds = false
+set Output directory                       = output_composition-passive_quarter-shell-spherical
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = .45
+    set Outer radius  = 1
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, inner, outer
+  set Prescribed velocity boundary indicators =   #outer: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system   = spherical
+    set Variable names      = r, phi
+    set Function expression = (1-r)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = r,phi
+    set Coordinate system   = spherical
+    set Function expression = if((r > 0.5 && r < 0.6), 1, 0) ; if((r > 0.8 && r < 0.95), 1, 0)
+  end
+end
diff --git a/tests/composition_passive_static.prm.bak b/tests/composition_passive_static.prm.bak
new file mode 100644
index 00000000000..b9c92cbfdff
--- /dev/null
+++ b/tests/composition_passive_static.prm.bak
@@ -0,0 +1,95 @@
+#########################################################
+# This is a variation of the composition_passive.prm
+# parameter file with a field of type "static". Check
+# that we don't advect the solution.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.1
+    set Output format                 = gnuplot
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields with same initial condition
+# and only the first one will be advected along.
+subsection Compositional fields
+  set Number of fields = 2
+  set Compositional field methods = field,static
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y<0.2, 1, 0)
+  end
+end
diff --git a/tests/composition_reaction.prm.bak b/tests/composition_reaction.prm.bak
new file mode 100644
index 00000000000..0178cc598bd
--- /dev/null
+++ b/tests/composition_reaction.prm.bak
@@ -0,0 +1,110 @@
+#########################################################
+# This is a variation of the composition_active.prm
+# parameter file, with the exception that we use the
+# material model composition reaction that accounts for
+# reactions between the two compositional fields.
+
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.3
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+# Let us here choose again a box domain of size 2x1
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+# We then set the temperature to one at the bottom and zero
+# at the top:
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0
+  end
+end
+
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+    set Density differential for compositional field 1 = -5
+    set Density differential for compositional field 2 = 5
+    set Reaction depth                = 0.2
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
diff --git a/tests/composition_reaction_iterated_IMPES.cc.bak b/tests/composition_reaction_iterated_IMPES.cc.bak
new file mode 100644
index 00000000000..43866fd7ba5
--- /dev/null
+++ b/tests/composition_reaction_iterated_IMPES.cc.bak
@@ -0,0 +1,91 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/composition_reaction.h>
+#include <aspect/geometry_model/interface.h>
+
+/**
+ * This material model assumes three compositional fields
+ * where the reaction rate of the first and the third one
+ * depend on the second one. Thus, an iterated scheme is
+ * required to compute the correct solution.
+ */
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class IteratedReaction : public MaterialModel::CompositionReaction<dim>
+    {
+      public:
+        virtual void evaluate(const MaterialModelInputs<dim> &in,
+                              MaterialModelOutputs<dim> &out) const
+        {
+          this->CompositionReaction<dim>::evaluate(in, out);
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const double depth = this->get_geometry_model().depth(in.position[i]);
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                {
+                  Assert(in.composition[i].size() > 1,
+                         ExcMessage ("Material model iterated reaction can only be used with "
+                                     "at least two compositial fields."));
+
+                  double delta_C = 0.0;
+                  switch (c)
+                    {
+                      case 0:
+                        delta_C = in.composition[i][1];
+                        break;
+                      case 1:
+                        delta_C = 1.0;
+                        break;
+                      case 2:
+                        delta_C = in.composition[i][1];
+                        break;
+                    }
+                  out.reaction_terms[i][c] = delta_C;
+                }
+            }
+
+        }
+
+    };
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(IteratedReaction,
+                                   "iterated reaction",
+                                   "A simple material model that is like the "
+                                   "'composition reaction' model, but requires an "
+                                   "iterated IMPES scheme to converge to the correct "
+                                   "solution.")
+  }
+}
diff --git a/tests/composition_reaction_iterated_IMPES.prm.bak b/tests/composition_reaction_iterated_IMPES.prm.bak
new file mode 100644
index 00000000000..33f017d866b
--- /dev/null
+++ b/tests/composition_reaction_iterated_IMPES.prm.bak
@@ -0,0 +1,121 @@
+#########################################################
+# This is a variation of the composition_reaction test,
+# with the exception that we use a reaction term that
+# requires the iterated Advection and Stokes solver scheme to reach the
+# correct reaction rate, which is one for the second
+# field and the value of the second field for the first
+# and the third field. Without iterating, the fields will
+# use the value from the previous time step. In addition,
+# this test checks if the results are the same for the
+# first and third field, independent of the order of
+# solving, and thus if our solver scheme is consistent.
+
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.01
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+
+############### Parameters describing the model
+# Let us here choose again a box domain of size 2x1
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+# We then set the temperature to one at the bottom and zero
+# at the top:
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.0;0.0;0.0
+  end
+end
+
+subsection Material model
+  set Model name = iterated reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+    set Density differential for compositional field 1 = -5
+    set Density differential for compositional field 2 = 5
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization
+end
diff --git a/tests/composition_stabilization.prm.bak b/tests/composition_stabilization.prm.bak
new file mode 100644
index 00000000000..721f44f0c1e
--- /dev/null
+++ b/tests/composition_stabilization.prm.bak
@@ -0,0 +1,113 @@
+#########################################################
+# This is a test for the stabilization of the advection
+# equation for compositional fields. The flow is
+# symmetric around the origin, and two fields that
+# each feature a circle of compositional distinct
+# material are advected with the flow. Rotating field C_2
+# by 180 degrees should yield the same result as C_1.
+# It is a variation of the platelike_boundary.prm file.
+# All settings are exactly the same with the exception
+# of the ones that pertain to compositional fields.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 4
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Prescribed velocity boundary indicators = top: function, bottom: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(z>0.5,sin(pi*x),-sin(pi*x)); 0
+  end
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(sqrt((x-0.25)*(x-0.25)+(y-0.5)*(y-0.5))<0.2, 1, 0); if(sqrt((x-0.75)*(x-0.75)+(y-0.5)*(y-0.5))<0.2, 1000, 10)
+  end
+end
diff --git a/tests/compositional_boundary_values.prm.bak b/tests/compositional_boundary_values.prm.bak
new file mode 100644
index 00000000000..895b7b0b48e
--- /dev/null
+++ b/tests/compositional_boundary_values.prm.bak
@@ -0,0 +1,101 @@
+# A testcase that evaluates inflow boundary conditions for compositional
+# fields. It solves the equations on a box with Dirichlet boundary conditions
+# equal to (z,0), which then is also the velocity everywhere.
+#
+# We prescribe boundary values for the compositional fields at the left
+# and see how it is transported towards the right.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = 0
+  set List of model names = box
+
+  subsection Box
+    set Left composition = 10, 10
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0 ; 1
+  end
+end
diff --git a/tests/compositional_boundary_values_02.prm.bak b/tests/compositional_boundary_values_02.prm.bak
new file mode 100644
index 00000000000..2c057bd1dd1
--- /dev/null
+++ b/tests/compositional_boundary_values_02.prm.bak
@@ -0,0 +1,102 @@
+# Like the 'compositional_boundary_values' test, but here we also prescribe
+# boundary values at the neutral bottom boundary where flow is
+# tangential. Because boundary values are prescribed strongly, this leads to a
+# boundary layer one cell wide.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = 0, 2
+  set List of model names = box
+
+  subsection Box
+    set Left composition = 10, 10
+    set Right composition = 20, 20
+    set Bottom composition = 30, 30
+    set Top composition = 40, 40
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0 ; 1
+  end
+end
diff --git a/tests/compositional_boundary_values_03.prm.bak b/tests/compositional_boundary_values_03.prm.bak
new file mode 100644
index 00000000000..d097d2b3fa3
--- /dev/null
+++ b/tests/compositional_boundary_values_03.prm.bak
@@ -0,0 +1,100 @@
+# Like the 'compositional_boundary_values_02' test, but use different
+# values for the boundary conditions of different compositional fields.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = 0, 2
+  set List of model names = box
+
+  subsection Box
+    set Left composition = 10, -10
+    set Right composition = 20, -20
+    set Bottom composition = 30, -30
+    set Top composition = 40, -40
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0 ; 1
+  end
+end
diff --git a/tests/compositional_heating.prm.bak b/tests/compositional_heating.prm.bak
new file mode 100644
index 00000000000..80feddba197
--- /dev/null
+++ b/tests/compositional_heating.prm.bak
@@ -0,0 +1,166 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1e9
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = compositional_heating
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1543
+    set Top temperature    =  273
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+# Initial temperature field
+# Typical continental geotherm based equations 4-6 from Chapman 1986 (Geol. Soc. Lon.):
+#   T(z) = Tt + (qt/k)*z - (A*z**2)/(2*k)    (eq 4)
+#   Tb = Tt + (qt/k)*dz - (A*dz**2)/(2*k)    (eq 5)
+#   qb = qt - A*dz                           (eq 6)
+#     T: Temperature, Ts: Layer surface temperature, Tb: layer basal temperature,
+#     qs: Layer surface heat flux, qb: Layer basal heat flux, A = heat production,
+#     dz: Layer thickness, k: thermal conductivity
+# The initial constraints are:
+#   Crust surface temperature (Tsc) = 273 K
+#   Crust surface heat flow   (qsc) = 0.07 W/m^2
+#   Crust heat production      (Ac) = 1.5e-6 W/m^3
+#   Crust thickness           (dzu) = 30.3 m
+#   Mantle heat production     (Am) = 0. W/m^3
+#   Mantle thickness          (dzm) = 70.e3
+#   Thermal conductivity        (K) = 2.5 W/(m K)
+# These constraints allow us to calculate the following values:
+#   qbc = qsc - A*dzc = 0.07 - 1.5e-6*30.e3 = 0.025
+#   Tbc = Tsc + (qsc/k)*dzc - (A*dzc**2)/(2*k) =
+#         273. + (0.07/2.5)*30.e3 - (1.5e-6 * 30.e3**2)/(2.*2.5) = 843
+#   qsm = qbc = 0.025
+#   Tsm = Tbc = 843
+#   qbm = qsm - A*dzm = 0.025 - 0.*70.e3 = 0.025
+#   Tbm = Tsm + (qts/k)*dzs - (A*dzm**2)/(2*k) =
+#         843. + (0.025/2.5)*30.e3 - (0. * 70.e3**2)/(2.*2.5) = 1543
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=100e3,tsc=273,tsm=843,qsc=0.07,qsm=0.025,k=2.5,A=1.5e-6
+    set Function expression = if( (h-y)<=30.e3, \
+                                  tsc + (qsc/k)*(h-y) - (A*(h-y)*(h-y))/(2.0*k), \
+                                  tsm + (qsm/k)*(h-y-30.e3))
+  end
+end
+
+# Internal heating (user specifies heat flux in W/m^3)
+# Values below are for the background (mantle) and crust.
+# If one wishes to track a property through compositional fields that should
+# not be used to determine the heat flux (e.g. finite strain), set the
+# "Use compositional field for heat flux averaging" value for that field to 0.
+# See Initial temperature model section for relationship between heat flux, production
+# and initial temperature profile representative of a continental geotherm.
+subsection Heating model
+  set List of model names = compositional heating
+
+  subsection Compositional heating
+    set Use compositional field for heat production averaging = 1, 1
+    set Compositional heating values = 0., 1.5e-6
+  end
+end
+
+# Compositional fields used to track upper and lower crust
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = upper
+end
+
+# Initial composition model
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y>=70.e3, 1, 0);
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material (mantle) and crust)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Reference values and viscosity averaging
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-16
+    set Minimum viscosity = 1e18
+    set Maximum viscosity = 1e28
+    set Viscosity averaging scheme = harmonic
+
+    # Thermodynamic properties
+    # Thermal diffusivity = thermal_conductivity/(density*heat_capacity)
+    set Thermal diffusivities = 1.010101e-6, 1.190476e-6
+    set Heat capacities = 750.
+    set Densities = 3300., 2800.
+    set Thermal expansivities = 0.
+
+    # Uniform viscosity
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Postprocessor
+subsection Postprocess
+  set List of postprocessors = heat flux statistics, temperature statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 200
+  end
+end
diff --git a/tests/compositional_heating_exclude_background.prm.bak b/tests/compositional_heating_exclude_background.prm.bak
new file mode 100644
index 00000000000..08ca20911b2
--- /dev/null
+++ b/tests/compositional_heating_exclude_background.prm.bak
@@ -0,0 +1,113 @@
+# A test to check that we can correctly exclude the background
+# field from the average heating calculation.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1e9
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = compositional_heating
+set Timing output frequency                = 1
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1543
+    set Top temperature    =  273
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=100e3,tsc=273,tsm=843,qsc=0.07,qsm=0.025,k=2.5,A=1.5e-6
+    set Function expression = if( (h-y)<=30.e3, \
+                                  tsc + (qsc/k)*(h-y) - (A*(h-y)*(h-y))/(2.0*k), \
+                                  tsm + (qsm/k)*(h-y-30.e3))
+  end
+end
+
+subsection Heating model
+  set List of model names = compositional heating
+
+  subsection Compositional heating
+    set Use compositional field for heat production averaging = 0, 1
+    set Compositional heating values = 1.5e-6, 1.5e-6
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = upper
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.5;
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-16
+    set Minimum viscosity = 1e18
+    set Maximum viscosity = 1e28
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 1.010101e-6, 1.190476e-6
+    set Heat capacities = 750.
+    set Densities = 3300., 3300.
+    set Thermal expansivities = 0.
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = heat flux statistics, temperature statistics, heating statistics
+end
diff --git a/tests/compositional_vectors.prm.bak b/tests/compositional_vectors.prm.bak
new file mode 100644
index 00000000000..178adc69bbe
--- /dev/null
+++ b/tests/compositional_vectors.prm.bak
@@ -0,0 +1,60 @@
+set Dimension                              = 2
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = box
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = compositional vector
+    set Output format = gnuplot
+
+    subsection Compositional fields as vectors
+      set Names of vectors = vector_field1, vector_field2
+      set Names of fields = vec1x, vec1y; vec2x, vec2y
+    end
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields = unrelated1, vec1x, vec1y, unrelated2, vec2x, vec2y
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1;1;.5;1;-1;-.5
+  end
+end
diff --git a/tests/compositional_vectors_3d.prm.bak b/tests/compositional_vectors_3d.prm.bak
new file mode 100644
index 00000000000..181aa62b254
--- /dev/null
+++ b/tests/compositional_vectors_3d.prm.bak
@@ -0,0 +1,60 @@
+set Dimension                              = 3
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = box
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = compositional vector
+    set Output format = gnuplot
+
+    subsection Compositional fields as vectors
+      set Names of vectors = vector_field
+      set Names of fields = vec_x, vec_y, vec_z
+    end
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 5
+  set Names of fields = unrelated1, vec_x, vec_y, vec_z, unrelated2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1;1;.5;1;0
+  end
+end
diff --git a/tests/compressibility.cc.bak b/tests/compressibility.cc.bak
new file mode 100644
index 00000000000..0f6cc9653d3
--- /dev/null
+++ b/tests/compressibility.cc.bak
@@ -0,0 +1,215 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class Compressibility : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+          * Return true if the compressibility() function returns something that
+          * is not zero.
+          */
+        bool
+        is_compressible () const override;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    Compressibility<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      Simple<dim>::evaluate(in, out);
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double pressure = in.pressure[i];
+          out.densities[i] = 1.0 + pressure;
+          out.compressibilities[i] = 1.0 / (1. + pressure);
+        }
+    }
+
+    template <int dim>
+    bool
+    Compressibility<dim>::
+    is_compressible () const
+    {
+      return true;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Compressibility,
+                                   "compressibility",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but has a non-zero compressibility.")
+  }
+}
+
+
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    class Compressibility : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics) override;
+    };
+  }
+}
+
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    Compressibility<dim>::execute (TableHandler &)
+    {
+      // create a quadrature formula based on the temperature element alone.
+      // be defensive about determining that what we think is the temperature
+      // element is indeed the temperature element
+      Assert (this->get_fe().n_base_elements() == 3+(this->n_compositional_fields()>0 ? 1 : 0),
+              ExcNotImplemented());
+      const QGauss<dim-1> quadrature_formula (this->get_fe().base_element(2).degree+1);
+
+      FEFaceValues<dim> fe_face_values (this->get_mapping(),
+                                        this->get_fe(),
+                                        quadrature_formula,
+                                        update_gradients         | update_values |
+                                        update_quadrature_points | update_JxW_values);
+
+      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+      std::vector<Tensor<1,dim>> velocity_values(quadrature_formula.size());
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell = this->get_dof_handler().begin_active(),
+      endc = this->get_dof_handler().end();
+
+      MaterialModel::MaterialModelInputs<dim> in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+      MaterialModel::MaterialModelOutputs<dim> out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::density;
+
+      // compute the integral of the viscosity. since we're on a unit box,
+      // this also is the average value
+      double bottom_flux_integral = 0;
+      double top_flux_integral = 0;
+      for (; cell!=endc; ++cell)
+        if (cell->is_locally_owned())
+          for (unsigned int f=0; f<2*dim; ++f)
+            if (cell->at_boundary(f)
+                &&
+                ((cell->face(f)->boundary_id() == 2)
+                 ||
+                 (cell->face(f)->boundary_id() == 3)))
+              {
+                fe_face_values.reinit (cell,f);
+                fe_face_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
+                    in.temperature);
+                fe_face_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
+                                                                                               in.pressure);
+                fe_face_values[this->introspection().extractors.velocities].get_function_symmetric_gradients (this->get_solution(),
+                    in.strain_rate);
+                for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                  fe_face_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
+                      composition_values[c]);
+                fe_face_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
+                    velocity_values);
+
+                in.position = fe_face_values.get_quadrature_points();
+                for (unsigned int i=0; i<fe_face_values.n_quadrature_points; ++i)
+                  {
+                    for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                      in.composition[i][c] = composition_values[c][i];
+                  }
+
+                this->get_material_model().evaluate(in, out);
+
+                if (cell->face(f)->boundary_id() == 2)
+                  for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                    bottom_flux_integral += out.densities[q] * velocity_values[q][1] * fe_face_values.JxW(q);
+                if (cell->face(f)->boundary_id() == 3)
+                  for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
+                    top_flux_integral += out.densities[q] * velocity_values[q][1] * fe_face_values.JxW(q);
+              }
+
+      std::ostringstream screen_text1;
+      std::ostringstream screen_text2;
+      screen_text1.precision(4);
+      screen_text2.precision(4);
+      screen_text1 << Utilities::MPI::sum(bottom_flux_integral, this->get_mpi_communicator());
+      screen_text2 << Utilities::MPI::sum(top_flux_integral, this->get_mpi_communicator());
+
+      return std::pair<std::string, std::string> ("Top/bottom flux:",
+                                                  screen_text2.str() + "/" + screen_text1.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(Compressibility,
+                                  "compressibility",
+                                  "A postprocessor that computes some statistics about "
+                                  "the mass fluxes.")
+  }
+}
diff --git a/tests/compressibility.prm.bak b/tests/compressibility.prm.bak
new file mode 100644
index 00000000000..7f89e9c6cc1
--- /dev/null
+++ b/tests/compressibility.prm.bak
@@ -0,0 +1,110 @@
+# A testcase that demonstrates compressibility. It solves the
+# equations on a box with Dirichlet boundary conditions equal to
+# (0,1) at the bottom boundary, a tangential velocity at the sides
+# and a free boundary at the top.
+#
+# We then choose a density rho=1+p and a compressibility that leads
+# to an exponential density profile rho=e^z, i.e.
+# compressibility=1/rho drho/dp=1/(1+p). The mass flux (product of density
+# and velocity) into the box and out of the box should be the same.
+#
+# We can only tell that the correct mass flux is computed in a
+# postprocessor, which we implement in the .cc file.
+#
+#
+# The correct solution has an exponentially increasing pressure and
+# density (top to bottom) where p(z)=e^(1-z)-1  (depth=1-z) and
+# rho(z)=e^(1-z). To conserve mass, this then requires a velocity
+# in z-direction equal to
+#    v(z) = e^(-(1-z))
+# However, this is the product of the equation
+#    div(rho u) = 0
+# which we instead solve in each iteration as
+#    div u = -1/rho drho/dp u^* . g
+# where u^* is a linearization point. In the first iteration, we start
+# with u^*=0, so we solve
+#    div u = 0
+# and the velocity field is of course completely wrong (it does not
+# accelerate towards the top as expected but is in fact constant).
+#
+# This testcase therefore verifies that we compute this wrong solution
+# in the first iteration. We use the no Advection, iterated Stokes/max_nonlinear_iterations=1
+# option for the solver scheme.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = compressibility
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = compressibility, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/compressibility_iterated_stokes.cc.bak b/tests/compressibility_iterated_stokes.cc.bak
new file mode 100644
index 00000000000..9c34031b4ed
--- /dev/null
+++ b/tests/compressibility_iterated_stokes.cc.bak
@@ -0,0 +1,89 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// use the same postprocessing facilities as for the 'compressibility'
+// testcase
+#include "compressibility.cc"
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class CompressibilityIteratedStokes : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+        /**
+          * Return true if the compressibility() function returns something that
+          * is not zero.
+          */
+        bool
+        is_compressible () const override;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    CompressibilityIteratedStokes<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      Simple<dim>::evaluate(in, out);
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          out.densities[i] = 10.0/11.0*exp(in.pressure[i]/100.0);
+          out.compressibilities[i] = 0.01;
+        }
+    }
+
+    template <int dim>
+    bool
+    CompressibilityIteratedStokes<dim>::
+    is_compressible () const
+    {
+      return true;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(CompressibilityIteratedStokes,
+                                   "compressibility iterated stokes",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but has a non-zero compressibility.")
+  }
+}
diff --git a/tests/compressibility_iterated_stokes.prm.bak b/tests/compressibility_iterated_stokes.prm.bak
new file mode 100644
index 00000000000..3c692bcdec7
--- /dev/null
+++ b/tests/compressibility_iterated_stokes.prm.bak
@@ -0,0 +1,99 @@
+# A variation on the 'compressibility' testcase. here, we compute not
+# only the first iteration of a nonlinear fixed point scheme, but in
+# fact the first several. This should iterate out the
+# continuity equation,
+#    div u = -1/rho drho/dp u^ . g
+# and so should lead to an upward expansion of the flux.
+#
+# with the original testcase, the iteration does not converge. rather,
+# we need a much smaller compressibility to make things converge. we
+# choose a velocity profile
+#   u_z = 1+z/100
+# with corresponding density profile
+#   rho = 1/(1+z/100)
+# so that the continuity equation is satisfied. From the density one
+# can compute a pressure profile (here, the pressure equals the hydrostatic
+# pressure because all second derivatives of the velocity vanish). This gives
+# p(z), which we can invert for z=z(p) and enter into the density equation
+# to get
+#   rho = 10.0/11.0*exp(pressure/100.0)
+# which corresponds to compressibility=0.01. This is implemented in
+# the .cc file corresponding to this testcase.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 5
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = compressibility iterated stokes
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = compressibility, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, volumetric strain rate
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/compressibility_iterated_stokes_direct_solver.cc.bak b/tests/compressibility_iterated_stokes_direct_solver.cc.bak
new file mode 100644
index 00000000000..a1d5f2ddde2
--- /dev/null
+++ b/tests/compressibility_iterated_stokes_direct_solver.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "compressibility_iterated_stokes.cc"
diff --git a/tests/compressibility_iterated_stokes_direct_solver.prm.bak b/tests/compressibility_iterated_stokes_direct_solver.prm.bak
new file mode 100644
index 00000000000..b3370598c77
--- /dev/null
+++ b/tests/compressibility_iterated_stokes_direct_solver.prm.bak
@@ -0,0 +1,86 @@
+# Copy of compressibility_iterated_stokes but using a direct solver. This is
+# to check that solve_stokes() returns the correct nonlinear residual.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 5
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = compressibility iterated stokes
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = compressibility
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/compressibility_lateral_pipe.cc.bak b/tests/compressibility_lateral_pipe.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_lateral_pipe.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe.prm.bak b/tests/compressibility_lateral_pipe.prm.bak
new file mode 100644
index 00000000000..70c96f03b91
--- /dev/null
+++ b/tests/compressibility_lateral_pipe.prm.bak
@@ -0,0 +1,5 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm
+
+set End time = 2e7
diff --git a/tests/compressibility_lateral_pipe_advect.cc.bak b/tests/compressibility_lateral_pipe_advect.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_advect.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_advect.prm.bak b/tests/compressibility_lateral_pipe_advect.prm.bak
new file mode 100644
index 00000000000..1acea3e0dc9
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_advect.prm.bak
@@ -0,0 +1,5 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm
+
+set End time = 2e6
diff --git a/tests/compressibility_lateral_pipe_advect_projected_density.cc.bak b/tests/compressibility_lateral_pipe_advect_projected_density.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_advect_projected_density.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_advect_projected_density.prm.bak b/tests/compressibility_lateral_pipe_advect_projected_density.prm.bak
new file mode 100644
index 00000000000..b7c398e1891
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_advect_projected_density.prm.bak
@@ -0,0 +1,8 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm
+
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm
+
+set End time = 2e6
diff --git a/tests/compressibility_lateral_pipe_increase_pressure.cc.bak b/tests/compressibility_lateral_pipe_increase_pressure.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_increase_pressure.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_increase_pressure.prm.bak b/tests/compressibility_lateral_pipe_increase_pressure.prm.bak
new file mode 100644
index 00000000000..a74f0d19c52
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_increase_pressure.prm.bak
@@ -0,0 +1,5 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm
+
+set End time = 1e12
diff --git a/tests/compressibility_lateral_pipe_increase_pressure_projected_density.cc.bak b/tests/compressibility_lateral_pipe_increase_pressure_projected_density.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_increase_pressure_projected_density.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_increase_pressure_projected_density.prm.bak b/tests/compressibility_lateral_pipe_increase_pressure_projected_density.prm.bak
new file mode 100644
index 00000000000..59c76e2dd43
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_increase_pressure_projected_density.prm.bak
@@ -0,0 +1,8 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm
+
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm
+
+set End time = 1e12
diff --git a/tests/compressibility_lateral_pipe_projected_density.cc.bak b/tests/compressibility_lateral_pipe_projected_density.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_projected_density.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_projected_density.prm.bak b/tests/compressibility_lateral_pipe_projected_density.prm.bak
new file mode 100644
index 00000000000..c8efc495810
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_projected_density.prm.bak
@@ -0,0 +1,8 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm
+
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm
+
+set End time = 2e7
diff --git a/tests/compressibility_lateral_pipe_transient.cc.bak b/tests/compressibility_lateral_pipe_transient.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_transient.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_transient.prm.bak b/tests/compressibility_lateral_pipe_transient.prm.bak
new file mode 100644
index 00000000000..47594f2f50a
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_transient.prm.bak
@@ -0,0 +1,5 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm
+
+set End time = 1e13
diff --git a/tests/compressibility_lateral_pipe_transient_projected_density.cc.bak b/tests/compressibility_lateral_pipe_transient_projected_density.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_transient_projected_density.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_transient_projected_density.prm.bak b/tests/compressibility_lateral_pipe_transient_projected_density.prm.bak
new file mode 100644
index 00000000000..50d8198c15f
--- /dev/null
+++ b/tests/compressibility_lateral_pipe_transient_projected_density.prm.bak
@@ -0,0 +1,8 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm
+
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm
+
+set End time = 1e13
diff --git a/tests/compressibility_vertical_pipe.cc.bak b/tests/compressibility_vertical_pipe.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_vertical_pipe.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_vertical_pipe.prm.bak b/tests/compressibility_vertical_pipe.prm.bak
new file mode 100644
index 00000000000..4be871494cb
--- /dev/null
+++ b/tests/compressibility_vertical_pipe.prm.bak
@@ -0,0 +1,5 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm
+
+set End time = 1e6
diff --git a/tests/compressibility_vertical_pipe_projected_density.cc.bak b/tests/compressibility_vertical_pipe_projected_density.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/compressibility_vertical_pipe_projected_density.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_vertical_pipe_projected_density.prm.bak b/tests/compressibility_vertical_pipe_projected_density.prm.bak
new file mode 100644
index 00000000000..c84510a654b
--- /dev/null
+++ b/tests/compressibility_vertical_pipe_projected_density.prm.bak
@@ -0,0 +1,8 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm
+
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm
+
+set End time = 1e6
diff --git a/tests/compressibility_volumetric_strain_rate.cc.bak b/tests/compressibility_volumetric_strain_rate.cc.bak
new file mode 100644
index 00000000000..a1d5f2ddde2
--- /dev/null
+++ b/tests/compressibility_volumetric_strain_rate.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "compressibility_iterated_stokes.cc"
diff --git a/tests/compressibility_volumetric_strain_rate.prm.bak b/tests/compressibility_volumetric_strain_rate.prm.bak
new file mode 100644
index 00000000000..f9a83c46a72
--- /dev/null
+++ b/tests/compressibility_volumetric_strain_rate.prm.bak
@@ -0,0 +1,87 @@
+# A variation on the 'compressibility_iterated_stokes' testcase.
+# We use it to test the volumetric strain rate visualization postprocessor.
+#
+# As the testcase has the analytical solution
+#   u_z = 1+z/10
+# with corresponding density profile
+#   rho = 1/(1+z/10),
+# the volumetric strain rate should be 0.1 throughout the whole domain.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 5
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = compressibility iterated stokes
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = compressibility, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Point-wise stress and strain = true
+    set List of output variables      = density, volumetric strain rate
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/compressible_forsterite_box.prm.bak b/tests/compressible_forsterite_box.prm.bak
new file mode 100644
index 00000000000..1e1004c6f07
--- /dev/null
+++ b/tests/compressible_forsterite_box.prm.bak
@@ -0,0 +1,87 @@
+# This test ensures that the multicomponent compressible
+# material model works with compositional fields
+# enabled
+
+set Dimension                              = 2
+set End time                               = 0
+
+subsection Compositional fields
+  set Number of fields          = 1
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent                = 400e3
+    set X repetitions           = 1
+    set Y extent                = 400e3
+    set Y repetitions           = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 1000 + y/400
+  end
+end
+
+# The following properties are for forsterite.
+# They are approximate values based on the dataset of Holland and Powell (2011).
+# Note that the heat capacity is the specific isochoric heat capacity (Cv [J/kg]).
+
+subsection Material model
+  set Model name         = multicomponent compressible
+
+  subsection Multicomponent compressible
+    set Reference temperatures = 298.15
+    set Reference densities = 3222.5
+    set Reference isothermal compressibilities = 7.8e-12
+    set Isothermal bulk modulus pressure derivatives = 3.84
+    set Reference thermal expansivities = 2.85e-5
+    set Isochoric specific heats = 1230.
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = material properties
+    set Time between graphical output = 0
+    set Number of grouped files       = 0
+
+    subsection Material properties
+      set List of material properties = density, thermal expansivity, compressibility, specific heat
+    end
+  end
+end
diff --git a/tests/compression_heating.cc.bak b/tests/compression_heating.cc.bak
new file mode 100644
index 00000000000..4eb0171708b
--- /dev/null
+++ b/tests/compression_heating.cc.bak
@@ -0,0 +1,69 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/melt_global.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class Compression : public MaterialModel::MeltGlobal<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+    };
+
+
+    template <int dim>
+    void
+    Compression<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      MeltGlobal<dim>::evaluate(in, out);
+      const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          out.reaction_terms[i][porosity_idx] = 0.2;
+        }
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Compression,
+                                   "melt global compression",
+                                   "A simple material model that is like the "
+                                   "'melt simple' model, but has a constant reaction term.")
+  }
+}
diff --git a/tests/compression_heating.prm.bak b/tests/compression_heating.prm.bak
new file mode 100644
index 00000000000..0ebf5cd02d1
--- /dev/null
+++ b/tests/compression_heating.prm.bak
@@ -0,0 +1,141 @@
+# This test is used to check if the shear heating
+# of melt, in particular the compression heating heating, is
+# calculated correctly.
+# There is no driving force in form of gravity in this model,
+# but material is melting homogeneously with a constant rate,
+# and the top boundary of the model is open, allowing material
+# to flow out (material expands upon melting).
+# There is no shear in the solid itself or shear between melt
+# and solid, but the velocity divergence is nonzero (it is 0.1),
+# so there is compression heating \xi (\nabla \cdot u_s).
+#
+# With the material properties in this benchmark, shear
+# heating of melt should have a value of 1.0 (for the
+# Total shear heating with melt rate).
+#
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 0.3
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 1600
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5; 0.0
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2
+
+  subsection Function
+    set Function expression = 0;0
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Heating model
+  set List of model names = shear heating, shear heating with melt
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = melt global compression
+
+  subsection Melt global
+    set Reference solid density    = 2
+    set Reference melt density     = 1
+    set Reference specific heat    = 1
+    set Reference temperature      = 1600
+    set Thermal conductivity       = 0.0
+    set Surface solidus            = 10000.0
+    set Include melting and freezing = false
+    set Reference permeability       = 1e-5
+    set Reference shear viscosity    = 1
+    set Reference bulk viscosity     = 100
+    set Reference melt viscosity     = 1
+    set Thermal viscosity exponent   = 0
+    set Exponential melt weakening factor = 0
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heating statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature, heating
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
diff --git a/tests/compute-no-normal-flux-constraints.prm.bak b/tests/compute-no-normal-flux-constraints.prm.bak
new file mode 100644
index 00000000000..7c63396787a
--- /dev/null
+++ b/tests/compute-no-normal-flux-constraints.prm.bak
@@ -0,0 +1,146 @@
+set Dimension = 2
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 10e2
+set Output directory = output-no-flux-constraints
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 273
+set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
+set Nonlinear solver tolerance             = 1e-4
+set Max nonlinear iterations               = 10
+set CFL number                             = 0.3
+set Timing output frequency                = 1
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+end
+
+# here are John's settings
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+
+  subsection Newton solver parameters
+    set Max Newton line search iterations        = 5
+    set Max pre-Newton nonlinear iterations      = 20
+    set Maximum linear Stokes solver tolerance   = 1e-1
+    set Nonlinear Newton solver switch tolerance = 1e-5
+    set SPD safety factor                        = 0.9
+    set Stabilization preconditioner             = SPD
+    set Stabilization velocity block             = SPD
+    set Use Newton failsafe                      = false
+    set Use Newton residual scaling method       = false
+    set Use Eisenstat Walker method for Picard iterations = true
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3.481e6
+    set Chunk outer radius = 6.371e6
+    set Chunk maximum longitude = 61.0
+    set Chunk minimum longitude = 0.0
+    set Longitude repetitions = 2
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = west, east, bottom, top
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1673
+    set Outer temperature = 273
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature  = 273
+
+    #    set Reference viscosity    = 1.e22
+
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0
+    set Heat capacities       = 750.
+    set Densities             = 3150
+    set Thermal expansivities = 0
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep          =  1e-21
+    set Stress exponents for dislocation creep    =   4
+    set Activation energies for dislocation creep =   0
+    set Activation volumes for dislocation creep  =   0
+
+    # cohesion set really high to generate very large plastic
+    # viscosities which will not be taken into account
+    # by the material model.
+    set Angles of internal friction = 0
+    set Cohesions                   = 1e15
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, depth average
+
+  subsection Depth average
+    set Number of zones = 50
+    set Output format = txt
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set List of output variables = density, viscosity, error indicator
+    set Output format = vtu
+    set Time between graphical output = 0.1e6
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set End step = 20
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 100
+end
diff --git a/tests/conservative_with_mpi.cc.bak b/tests/conservative_with_mpi.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/conservative_with_mpi.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/conservative_with_mpi.prm.bak b/tests/conservative_with_mpi.prm.bak
new file mode 100644
index 00000000000..add8f5f5e4e
--- /dev/null
+++ b/tests/conservative_with_mpi.prm.bak
@@ -0,0 +1,81 @@
+# when using the conservative element in a parallel program, we used to get an
+# assertion in normalize_pressure because we tried to modify an element of a
+# vector with ghost elements. there was also a second thinko in the same
+# function. verify that this doesn't happen any more.
+
+# MPI: 2
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = true
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/consistent_boundary_flux_adjacent_dirichlet.prm.bak b/tests/consistent_boundary_flux_adjacent_dirichlet.prm.bak
new file mode 100644
index 00000000000..727e25d3667
--- /dev/null
+++ b/tests/consistent_boundary_flux_adjacent_dirichlet.prm.bak
@@ -0,0 +1,90 @@
+# This test is based on boundary_heat_flux and checks that the consistent
+# boundary flux method in the heatflux statistics postprocessor computes
+# the correct boundary fluxes for models with Dirichlet temperature
+# boundary conditions on two adjacent faces of the same cell that belong
+# to different boundaries.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 2.5e11
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 90  # -183°C adiabat
+set Use conduction timestep                = true
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 20000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
+
+  subsection Function
+    set Function expression = 0;0
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta = 0.0
+    set cR = 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left,top
+  set List of model names = initial temperature
+end
+
+subsection Boundary heat flux model
+  set Fixed heat flux boundary indicators = bottom
+  set Model name = function
+
+  subsection Function
+    set Function expression = -0.04
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density        = 950
+    set Reference specific heat  = 1000
+    set Reference temperature    = 273
+    set Thermal conductivity     = 2.38
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =  heat flux map
+  end
+end
diff --git a/tests/consistent_boundary_flux_neumann.prm.bak b/tests/consistent_boundary_flux_neumann.prm.bak
new file mode 100644
index 00000000000..2d39ae7b4c6
--- /dev/null
+++ b/tests/consistent_boundary_flux_neumann.prm.bak
@@ -0,0 +1,84 @@
+# This test is based on boundary_heat_flux and checks that the consistent
+# boundary flux method in the heatflux statistics postprocessor computes
+# the correct boundary fluxes for models with adjacent Dirichlet and
+# Neumann temperature boundary conditions.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 2.5e16
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 90  # -183°C adiabat
+set Use conduction timestep                = true
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 20000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
+
+  subsection Function
+    set Function expression = 0;0
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta = 0.0
+    set cR = 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left
+  set List of model names = initial temperature
+end
+
+subsection Boundary heat flux model
+  set Fixed heat flux boundary indicators = bottom
+  set Model name = function
+
+  subsection Function
+    set Function expression = -0.04
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density        = 950
+    set Reference specific heat  = 1000
+    set Reference temperature    = 273
+    set Thermal conductivity     = 2.38
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heat flux statistics
+end
diff --git a/tests/consistent_boundary_flux_open_boundary.prm.bak b/tests/consistent_boundary_flux_open_boundary.prm.bak
new file mode 100644
index 00000000000..389ffb9fa28
--- /dev/null
+++ b/tests/consistent_boundary_flux_open_boundary.prm.bak
@@ -0,0 +1,88 @@
+# This test is based on boundary_heat_flux and checks that the consistent
+# boundary flux method in the heat flux statistics postprocessor computes
+# the correct boundary fluxes for models with Dirichlet temperature
+# boundary conditions on two adjacent faces of the same cell that belong
+# to different boundaries.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 1e13
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 90  # -183°C adiabat
+set Use conduction timestep                = true
+set Output directory = output-no-expansion
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 20000
+    set Y extent = 20000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
+
+  subsection Function
+    set Function constants = yr_in_s=31557600
+    set Function expression = 1/yr_in_s;0
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta = 0.0
+    set cR = 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, left
+  set List of model names = initial temperature
+end
+
+subsection Boundary heat flux model
+  set Fixed heat flux boundary indicators = bottom
+  set Model name = function
+
+  subsection Function
+    set Function expression = -0.04
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density        = 950
+    set Reference specific heat  = 1000
+    set Reference temperature    = 273
+    set Thermal conductivity     = 2.38
+    set Thermal expansion coefficient      = 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heat flux statistics
+end
diff --git a/tests/constant_composition_convergence.prm.bak b/tests/constant_composition_convergence.prm.bak
new file mode 100644
index 00000000000..18b01262cec
--- /dev/null
+++ b/tests/constant_composition_convergence.prm.bak
@@ -0,0 +1,77 @@
+# This test checks that the advection solver converges
+# in the first timestep even when solving for a constant
+# compositional field.
+
+set Dimension                              = 2
+set End time                               = 2e8
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 400000
+    set Y extent = 400000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2 ,3
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 1600 + 100*sin(x*pi/200000.0)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                = 3000
+    set Thermal conductivity             = 0
+    set Thermal expansion coefficient    = 4e-5
+    set Viscosity                        = 1e23
+    set Reference temperature            = 1600
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/constant_temperature_boundary_conditions.prm.bak b/tests/constant_temperature_boundary_conditions.prm.bak
new file mode 100644
index 00000000000..9e4673ee765
--- /dev/null
+++ b/tests/constant_temperature_boundary_conditions.prm.bak
@@ -0,0 +1,70 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 0 : 0.0, 1 : 1.0, 2:2.0, 3:3.0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/continental_extension.prm.bak b/tests/continental_extension.prm.bak
new file mode 100644
index 00000000000..81a0c2241f4
--- /dev/null
+++ b/tests/continental_extension.prm.bak
@@ -0,0 +1,51 @@
+####
+# This test is based on the Continental Extension Cookbook
+# There, the initial temperature is computed through a
+# somewhat cumbersome function specified in the input file.
+# With the continental geotherm plugin, one only has to
+# specify the boundary temperature constraints and layer
+# thicknesses of the upper crust, lower crust and mantle
+# lithosphere. Other parameters such as layer densities
+# are read from other sections in the input file, ensuring
+# consistency between the parameters set for the initial
+# temperature and those in the material model and compositional
+# heating plugins. Significantly, the continental geotherm
+# initial temperature plugin enforces that specific names are
+# used for crustal and mantle layers, which are specified
+# below in the Compositional fields subsection.
+
+include $ASPECT_SOURCE_DIR/cookbooks/continental_extension/continental_extension.prm
+
+set Timing output frequency                = 100
+set End time                               = 1e4
+set Max nonlinear iterations               = 1
+
+# Perform only one global refinement and no adaptive refinements
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Time steps between mesh refinement = 0
+end
+
+# Update the names of the compositional fields associated with the upper crust, lower crust,
+# and lithospheric mantle to be consistent with the naming scheme enforced by the continental
+# geothermal initial temperature plugin.
+subsection Compositional fields
+  set Names of fields = noninitial_plastic_strain, plastic_strain, upper_crust, lower_crust, lithospheric_mantle
+end
+
+# Initial temperature field
+subsection Initial temperature model
+  set Model name = continental geotherm
+
+  subsection Continental geotherm
+    set Lithosphere-Asthenosphere boundary isotherm = 1613.
+    set Surface temperature = 273.
+    set Layer thicknesses = 20000., 20000., 60000.
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
diff --git a/tests/convection_box_particles.prm.bak b/tests/convection_box_particles.prm.bak
new file mode 100644
index 00000000000..38a5d238970
--- /dev/null
+++ b/tests/convection_box_particles.prm.bak
@@ -0,0 +1,4 @@
+include $ASPECT_SOURCE_DIR/cookbooks/convection-box-particles/convection-box-particles.prm
+
+set Dimension = 2
+set End time = 0
diff --git a/tests/convection_box_phase_function.prm.bak b/tests/convection_box_phase_function.prm.bak
new file mode 100644
index 00000000000..37a099a5d7b
--- /dev/null
+++ b/tests/convection_box_phase_function.prm.bak
@@ -0,0 +1,143 @@
+# This is a setup for convection in a 2D box with a phase transition
+# in the center, similar to the setup of Christensen & Yuen 1985.
+# The test case is for the steady state heat flux plugin: the model
+# run should terminate once the heat flux does not change by more
+# than plus/minus 5% in a time frame of 2 Myr.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 2e8
+
+# This controls the solver accuracy
+set Nonlinear solver tolerance             = 1e-5
+set Maximum time step                      = 1e5
+set Adiabatic surface temperature          = 500
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+# This model assumes the Boussinesq approximation, so it is
+# incompressible and has a constant reference density.
+subsection Formulation
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1350000
+    set Y extent = 1350000
+  end
+end
+
+# For the Boussinesq approximation, all heating terms are switched off.
+subsection Heating model
+  set List of model names =
+end
+
+# Set the reference profile.
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants = density=1000
+    set Function expression = 500; density*10*depth; density
+    set Variable names = depth
+  end
+end
+
+# This temperature initial condition resembles the one in Christensen & Yuen, 1985.
+# It has conductive boundary layers at the top and bottom, and sinusoidal
+# temperature perturbations.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants = delta=0.1, A=10, h=1350000, pi=3.1416
+    set Variable names = x,z
+    set Function expression = 500 + 500*(erfc(z/(h*delta)) - erfc((1-z/h)/delta)) + A*cos(pi*x/h)*sin(pi*z/h) + A*cos(2*pi*x/h)*sin(pi*z/h) + A*cos(pi*x/h)*sin(2*pi*z/h) + A*cos(2*pi*x/h)*sin(2*pi*z/h)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom, left, right
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# This material model uses phase functions.
+# The model in Christensen & Yuen is nondimensional. To make this
+# easy, we here set all material
+# properties to multiples of 10, and then control the three important
+# model parameters by setting:
+#
+# k = 2.460375e7 / Ra,                                      to control the Rayleigh number,
+# deltarho = 2 alpha rho DeltaT = 200 kg/m3,                to achieve Rb = 2Ra, as in Christensen & Yuen,
+# gamma = P * Ra/Rb * rho g h / DeltaT = P/2 * 1.35e7 Pa/K, to set the phase buoyancy parameter.
+#
+subsection Material model
+  set Model name = latent heat
+  set Material averaging = harmonic average only viscosity
+
+  subsection Latent heat
+    set Reference density = 1000
+    set Reference temperature = 500
+    set Viscosity = 1e20
+    set Thermal viscosity exponent = 0.0
+    set Thermal conductivity = 246.03750
+    set Reference specific heat = 1000
+    set Thermal expansion coefficient = 1e-4
+    set Compressibility = 0
+    set Phase transition depths = 675000
+    set Phase transition widths = 54000
+    set Define transition by depth instead of pressure = true
+    set Phase transition temperatures = 500
+    set Phase transition Clapeyron slopes = -4050000
+    set Phase transition density jumps = 200
+    set Corresponding phase for density jump = 0
+    set Viscosity prefactors = 1,1
+    set Minimum viscosity = 1e20
+    set Maximum viscosity = 1e20
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = heat flux statistics
+end
+
+subsection Termination criteria
+  set Termination criteria = end time, steady state heat flux
+
+  subsection Steady state heat flux
+    set Maximum relative deviation = 0.05
+    set Time in steady state = 2e6
+    set Boundary indicators = top
+  end
+end
diff --git a/tests/cookbook_mantle_convection_annulus.prm.bak b/tests/cookbook_mantle_convection_annulus.prm.bak
new file mode 100644
index 00000000000..b23e7ed85da
--- /dev/null
+++ b/tests/cookbook_mantle_convection_annulus.prm.bak
@@ -0,0 +1,36 @@
+# input file for model R of van der wiel et al, 2024.
+
+include $ASPECT_SOURCE_DIR/cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm
+
+set World builder file                     = $ASPECT_SOURCE_DIR/cookbooks/mantle_convection_with_continents_in_annulus/world.wb
+set Output directory                       = cookbook_mantle_convection_annulus
+set End time                               = 0
+
+subsection Mesh refinement
+  set Initial global refinement       = 1
+  set Initial adaptive refinement     = 0
+  set Strategy                        = minimum refinement function, viscosity, velocity
+
+  subsection Minimum refinement function
+    set Coordinate system = spherical
+    set Function expression = if(r>6000e3, 6, if(r>5000e3,5,3))
+    set Variable names = r,phi,t
+  end
+end
+
+subsection Postprocess
+end
+
+subsection Particles
+  subsection Generator
+    subsection Uniform radial
+      set Minimum radius = 3580000
+      set Maximum radius = 6270000
+      set Radial layers  = 50
+    end
+
+    subsection Probability density function
+      set Number of particles           = 123
+    end
+  end
+end
diff --git a/tests/cookbook_simpler_with_crust.cc.bak b/tests/cookbook_simpler_with_crust.cc.bak
new file mode 100644
index 00000000000..da3179eff95
--- /dev/null
+++ b/tests/cookbook_simpler_with_crust.cc.bak
@@ -0,0 +1,208 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// copied from ../cookbooks/free-surface-with-crust/plugin/simpler-with-crust.cc
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+#include <cmath>
+
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model similar to the "simpler" material model, but where the
+     * viscosity has two different values dependent on whether we are above or
+     * below a line at a certain z-value, i.e., with a
+     * crust.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class SimplerWithCrust : public Interface<dim>
+    {
+      public:
+
+        virtual bool is_compressible () const;
+
+        virtual void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                              typename Interface<dim>::MaterialModelOutputs &out) const;
+
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+        /**
+         * @}
+         */
+
+      private:
+        double reference_rho;
+        double reference_T;
+        double eta_L;
+        double eta_U;
+        double jump_height;
+        double thermal_alpha;
+        double reference_specific_heat;
+        double k_value;
+    };
+
+
+    template <int dim>
+    bool
+    SimplerWithCrust<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+
+    template <int dim>
+    void
+    SimplerWithCrust<dim>::
+    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out ) const
+    {
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          const double z = in.position[i][1];
+          if (z>jump_height)
+            out.viscosities[i] = eta_U;
+          else
+            out.viscosities[i] = eta_L;
+
+          out.densities[i] = reference_rho * (1.0 - thermal_alpha * (in.temperature[i] - reference_T));
+          out.thermal_expansion_coefficients[i] = thermal_alpha;
+          out.specific_heat[i] = reference_specific_heat;
+          out.thermal_conductivities[i] = k_value;
+          out.compressibilities[i] = 0.0;
+        }
+    }
+
+
+    template <int dim>
+    void
+    SimplerWithCrust<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simpler with crust model");
+        {
+          prm.declare_entry ("Reference density", "3300",
+                             Patterns::Double (0),
+                             "Reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference temperature", "293",
+                             Patterns::Double (0),
+                             "The reference temperature $T_0$. The reference temperature is used "
+                             "in the density formula. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Lower viscosity", "5e24",
+                             Patterns::Double (0),
+                             "The value of the viscosity $\\eta$L. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Upper viscosity", "5e24",
+                             Patterns::Double (0),
+                             "The value of the viscosity in the top section $\\eta$U. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Jump height", "100000",
+                             Patterns::Double (0),
+                             "The height at which the viscosity changes. Units: \\si{\\meter}.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250",
+                             Patterns::Double (0),
+                             "The value of the specific heat $cp$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                             Patterns::Double (0),
+                             "The value of the thermal expansion coefficient $\\beta$. "
+                             "Units: \\si{\\per\\kelvin}.");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    SimplerWithCrust<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simpler with crust model");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          reference_T                = prm.get_double ("Reference temperature");
+          eta_L                      = prm.get_double ("Lower viscosity");
+          eta_U                      = prm.get_double ("Upper viscosity");
+          jump_height                = prm.get_double ("Jump height");
+          k_value                    = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.density = NonlinearDependence::none;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SimplerWithCrust,
+                                   "simpler with crust",
+                                   "A material model that is like the ``simpler'' model but "
+                                   "has a jump in the viscosity.")
+  }
+}
diff --git a/tests/coordinate_transformation.cc.bak b/tests/coordinate_transformation.cc.bak
new file mode 100644
index 00000000000..f3cd7d46339
--- /dev/null
+++ b/tests/coordinate_transformation.cc.bak
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// include utility functions
+#include <aspect/utilities.h>
+
+#include <iostream>
+
+using namespace dealii;
+using namespace aspect::Utilities;
+// Check various conversions between cartesian and spherical coordinates
+
+template <typename T, unsigned int dim>
+void check_point(T point1, T point2)
+{
+  std::cout << std::endl << "Point 1: ";
+  for (unsigned int i = 0; i < dim; ++i)
+    std::cout << point1[i] << ' ';
+
+  std::cout << std::endl << "Point 2: ";
+  for (unsigned int i = 0; i < dim; ++i)
+    std::cout << point2[i] << ' ';
+
+  std::cout << std::endl;
+}
+
+int f()
+{
+  const dealii::Point<2> origin2(0,0);
+  const dealii::Point<3> origin3(0,0,0);
+
+  const std::array<double,2> sorigin2 = {{0,0}};
+  const std::array<double,3> sorigin3 = {{0,0,0}};
+
+  const dealii::Point<2> one2(1,1);
+  const dealii::Point<3> one3(1,1,1);
+
+  const std::array<double,2> sone2 = {{sqrt(2),numbers::PI/4}};
+  const std::array<double,3> sone3 = {{sqrt(3),numbers::PI/4,std::acos(1/sqrt(3))}};
+
+  const dealii::Point<3> x(1,0,0);
+  const dealii::Point<3> y(0,1,0);
+  const dealii::Point<3> z(0,0,1);
+
+  const std::array<double,3> sx = {{1,0,numbers::PI/2}};
+  const std::array<double,3> sy = {{1,numbers::PI/2,numbers::PI/2}};
+  const std::array<double,3> sz = {{1,0,0}};
+
+  check_point<const std::array<double,2>,2>(Coordinates::cartesian_to_spherical_coordinates(origin2),sorigin2);
+  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(origin3),sorigin3);
+  check_point<const Point<2>,2>(origin2, Coordinates::spherical_to_cartesian_coordinates<2>(sorigin2));
+  check_point<const Point<3>,3>(origin3, Coordinates::spherical_to_cartesian_coordinates<3>(sorigin3));
+
+  check_point<const std::array<double,2>,2>(Coordinates::cartesian_to_spherical_coordinates(one2),sone2);
+  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(one3),sone3);
+  check_point<const Point<2>,2>(one2, Coordinates::spherical_to_cartesian_coordinates<2>(sone2));
+  check_point<const Point<3>,3>(one3, Coordinates::spherical_to_cartesian_coordinates<3>(sone3));
+
+  check_point<const Point<3>,3>(x, Coordinates::spherical_to_cartesian_coordinates<3>(sx));
+  check_point<const Point<3>,3>(y, Coordinates::spherical_to_cartesian_coordinates<3>(sy));
+  check_point<const Point<3>,3>(z, Coordinates::spherical_to_cartesian_coordinates<3>(sz));
+
+  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(x),sx);
+  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(y),sy);
+  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(z),sz);
+
+  const dealii::Point<3> dateline(0,-1,0);
+  const std::array<double,3> sdateline = {{1,3*numbers::PI/2,numbers::PI/2}};
+
+  check_point<const Point<3>,3>(dateline, Coordinates::spherical_to_cartesian_coordinates<3>(sdateline));
+  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(dateline),sdateline);
+
+
+  return 42;
+}
+
+int i = f();
diff --git a/tests/coordinate_transformation.prm.bak b/tests/coordinate_transformation.prm.bak
new file mode 100644
index 00000000000..319e7d0b857
--- /dev/null
+++ b/tests/coordinate_transformation.prm.bak
@@ -0,0 +1,80 @@
+# a test that simply verifies that the plugin described in
+# coordinate_transformation.cc is indeed run
+
+
+
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/coupled_two_phase_tian_parameterization_kinematic_slab.prm.bak b/tests/coupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
new file mode 100644
index 00000000000..1dbaee3a852
--- /dev/null
+++ b/tests/coupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
@@ -0,0 +1,59 @@
+# This test is for the fully coupled Simplified Subduction Model with Parameterized
+# Solid-Fluid Reactions cookbook. It also doubles as a test for the min/max
+# compaction viscosity.
+
+include $ASPECT_SOURCE_DIR/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm
+
+set Adiabatic surface temperature              = 1600
+set Nonlinear solver scheme                    = single Advection, single Stokes
+set End time                                   = 2000
+
+subsection Mesh refinement
+  set Initial global refinement = 1
+
+  subsection Minimum refinement function
+    set Function expression = 1
+  end
+end
+
+# Slightly change composition model to ensure that there is bound_fluid
+# and porosity at the end of the test.
+subsection Boundary composition model
+  set Fixed composition boundary indicators         = left
+  set List of model names                           = function
+
+  subsection Function
+    set Function constants  = initial_porosity=0, initial_bound_sed=0.03, initial_bound_MORB=0.02, initial_bound_gabbro=0.01, \
+                              sediment_min=0, sediment_max=5e3, MORB_min=5e3, MORB_max=12e3, gabbro_min=12e3, gabbro_max=20e3, \
+                              onset_time=0, slab_thickness=20e3
+    set Function expression = initial_porosity; \
+                              if( t<=onset_time, 0, \
+                              if( (y<=slab_thickness - sediment_min) & (y>slab_thickness - sediment_max), initial_bound_sed, \
+                              if( (y<=slab_thickness - MORB_min) & (y>slab_thickness - MORB_max), initial_bound_MORB, \
+                              if( (y<=slab_thickness - gabbro_min) & (y>slab_thickness - gabbro_max), initial_bound_gabbro, 0.0)))); \
+                              if(y>slab_thickness, 1, 0); \
+                              if(y<=8e3, 1, 0); \
+                              if(y>8e3 & y<=15e3, 1, 0); \
+                              if(y>15e3 & y<=slab_thickness, 1, 0)
+  end
+end
+
+subsection Material model
+  subsection Reactive Fluid Transport Model
+    set Minimum compaction viscosity = 1e18
+    set Maximum compaction viscosity = 1e21
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors          = composition statistics, visualization
+
+  subsection Visualization
+    set Output format                 = gnuplot
+    set Time between graphical output = 2000
+
+    subsection Melt material properties
+      set List of properties          = compaction viscosity
+    end
+  end
+end
diff --git a/tests/cpo_simple_shearbox.prm.bak b/tests/cpo_simple_shearbox.prm.bak
new file mode 100644
index 00000000000..a7d6fcd02ff
--- /dev/null
+++ b/tests/cpo_simple_shearbox.prm.bak
@@ -0,0 +1,154 @@
+set Timing output frequency  = 1000000
+set Dimension                = 3
+set Pressure normalization   = surface
+set Surface pressure         = 0
+set Nonlinear solver scheme  = single Advection, no Stokes
+set End time                 = 2e6
+set Use years in output instead of seconds = false
+set Maximum time step = 1e3
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = water
+  set Compositional field methods = static
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+    set Box origin X coordinate = -0.500
+    set Box origin Y coordinate = -0.500
+    set Box origin Z coordinate = -0.500
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1200 ## Annotation: Temperature function
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top, left, right, front, back
+
+  subsection Box
+    set Bottom temperature = 1200
+    set Left temperature   = 1200
+    set Right temperature  = 1200
+    set Top temperature    = 1200
+    set Front temperature  = 1200
+    set Back temperature   = 1200
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,z,t
+    set Function expression = z*1e-5;0;0 ## Annotation set velocity condition
+  end
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Minimum viscosity = 1e15
+    set Densities = 3300
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 10000
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles, crystal preferred orientation
+
+  subsection Visualization
+    set Time between graphical output = 1e6
+    set List of output variables = viscosity, strain rate, stress, density
+  end
+
+  subsection Crystal Preferred Orientation
+    set Time between data output = 1e6
+    set Write in background thread = true
+    set Compress cpo data files = false
+    set Write out raw cpo data = mineral 0: volume fraction, mineral 0: Euler angles, mineral 1: volume fraction, mineral 1: Euler angles
+    set Write out draw volume weighted cpo data = mineral 0: volume fraction, mineral 0: Euler angles, mineral 1: volume fraction, mineral 1: Euler angles
+  end
+
+  subsection Particles
+    set Time between data output = 1e6
+    set Data output format       = gnuplot
+    set Exclude output properties = a_cosine_matrix, volume fraction
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
+
+subsection Particles
+  set List of particle properties = integrated strain invariant, crystal preferred orientation, cpo bingham average, cpo elastic tensor, elastic tensor decomposition
+  set Particle generator name = ascii file
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = $ASPECT_SOURCE_DIR/data/particle/property/
+      set Data file name = particle_one.dat
+    end
+  end
+
+  subsection Crystal Preferred Orientation
+    set Random number seed = 301
+    set Number of grains per particle = 5
+    set Property advection method = Backward Euler ## Annotation Property advection method
+    set Property advection tolerance = 1e-15
+    set CPO derivatives algorithm = D-Rex 2004
+
+    subsection Initial grains
+      set Minerals = Olivine: A-fabric , Enstatite
+      set Volume fractions minerals = 1.0,0.0
+    end
+
+    subsection D-Rex 2004
+      set Mobility = 125
+      set Stress exponents = 3.5
+      set Exponents p = 1.5
+      set Nucleation efficiency = 5
+      set Threshold GBS = 0.3
+    end
+  end
+
+  subsection CPO Bingham Average
+    set Random number seed = 200
+  end
+end
diff --git a/tests/crameri_benchmark_1_gmg.cc.bak b/tests/crameri_benchmark_1_gmg.cc.bak
new file mode 100644
index 00000000000..6ca69dfb7eb
--- /dev/null
+++ b/tests/crameri_benchmark_1_gmg.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc"
diff --git a/tests/crameri_benchmark_1_gmg.prm.bak b/tests/crameri_benchmark_1_gmg.prm.bak
new file mode 100644
index 00000000000..8dcc9a0b9a5
--- /dev/null
+++ b/tests/crameri_benchmark_1_gmg.prm.bak
@@ -0,0 +1,52 @@
+# test gmg + free surface
+
+include $ASPECT_SOURCE_DIR/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm
+
+set Dimension = 2
+set End time = 90
+set Output directory = output-crameri-gmg
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Material model
+  set Material averaging =  harmonic average
+end
+
+subsection Postprocess
+  subsection Visualization
+    set Output mesh velocity = true
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = rebound box
+
+  subsection Rebound Box
+    set Order = 1
+    set Amplitude = 7.e3
+  end
+
+  subsection Box
+    set X extent = 28.e5
+    set Y extent = 7.e5
+    set X repetitions = 60
+    set Y repetitions = 15
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+end
diff --git a/tests/crustal_model_3D.prm.bak b/tests/crustal_model_3D.prm.bak
new file mode 100644
index 00000000000..254913117f2
--- /dev/null
+++ b/tests/crustal_model_3D.prm.bak
@@ -0,0 +1,124 @@
+############### Global parameters
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set CFL number                             = .5
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-9
+set Max nonlinear iterations               = 2
+set Pressure normalization                 = no
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 128e3
+    set Y extent  =  96e3
+    set Z extent  =  16e3
+    set X repetitions  = 8
+    set Y repetitions  = 3
+  end
+end
+
+# We prescribe a diverging velocity field on the left, right and bottom boundary
+# such that two crustal faults form with an offset between them.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = front, back
+  set Prescribed velocity boundary indicators = left: function, right:function, bottom:function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = cm=0.01, year=1
+    set Function expression = if (x<56e3 && y<=48e3 | x<72e3 && y>48e3, -1*cm/year, 1*cm/year) ; 0 ; 0
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = top: free surface
+
+  # Advecting the free surface vertically rather than
+  # in the surface normal direction can result in a
+  # more stable mesh when the deformation is large
+  subsection Free surface
+    set Surface velocity projection = vertical
+  end
+end
+
+subsection Material model
+  set Model name = drucker prager
+
+  subsection Drucker Prager
+    set Reference density = 2800
+
+    subsection Viscosity
+      set Minimum viscosity = 1e19
+      set Maximum viscosity = 1e25
+      set Reference strain rate = 1e-20
+      set Angle of internal friction = 30
+      set Cohesion = 20e6
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Refinement fraction                = 0.9
+  set Strategy                           = strain rate
+  set Coarsening fraction                = 0.05
+  set Minimum refinement level           = 1
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography, pressure statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density, viscosity, strain rate, error indicator
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-9
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/custom_spherical_shell_2d_list.prm.bak b/tests/custom_spherical_shell_2d_list.prm.bak
new file mode 100644
index 00000000000..243a9faba50
--- /dev/null
+++ b/tests/custom_spherical_shell_2d_list.prm.bak
@@ -0,0 +1,82 @@
+# Use a comma-separated list of radius values to extrude a custom mesh
+# as an extension of the default spherical shell geometry (2d case)
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 2000.0
+    set Outer temperature = 1000.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 5711000
+    set Outer radius = 6371000
+    set Opening angle = 360
+    set Custom mesh subdivision = list of radial values
+    set List of radial values = 5961000, 6151000  # depth values 220 km and 410 km
+    set Initial lateral refinement = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1500.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Output format       = gnuplot
+    set Interpolate output = false
+  end
+end
diff --git a/tests/custom_spherical_shell_2d_slices.prm.bak b/tests/custom_spherical_shell_2d_slices.prm.bak
new file mode 100644
index 00000000000..2830b0c6c92
--- /dev/null
+++ b/tests/custom_spherical_shell_2d_slices.prm.bak
@@ -0,0 +1,82 @@
+# This is a simple 2d setup for testing a custom spherical shell
+# using the number of slices subdivision scheme.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 2000.0
+    set Outer temperature = 1000.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Custom mesh subdivision = number of slices
+    set Number of slices = 2
+    set Inner radius = 5711000
+    set Outer radius = 6371000
+    set Initial lateral refinement = 1
+    set Opening angle = 360
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1500.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format      = gnuplot
+  end
+end
diff --git a/tests/custom_spherical_shell_3d_list.prm.bak b/tests/custom_spherical_shell_3d_list.prm.bak
new file mode 100644
index 00000000000..3c8a95c9c3f
--- /dev/null
+++ b/tests/custom_spherical_shell_3d_list.prm.bak
@@ -0,0 +1,82 @@
+# Use a comma-separated list of radius values to extrude a custom mesh
+# as an extension of the default spherical shell geometry (3d case)
+
+set Dimension                              = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 2000.0
+    set Outer temperature = 1000.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 5711000
+    set Outer radius = 6371000
+    set Opening angle = 360
+    set Custom mesh subdivision = list of radial values
+    set List of radial values = 5961000, 6151000  # depth values 220 km and 410 km
+    set Initial lateral refinement = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1500.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Output format      = gnuplot
+    set Interpolate output = false
+  end
+end
diff --git a/tests/custom_spherical_shell_3d_slices.prm.bak b/tests/custom_spherical_shell_3d_slices.prm.bak
new file mode 100644
index 00000000000..47df314ab6d
--- /dev/null
+++ b/tests/custom_spherical_shell_3d_slices.prm.bak
@@ -0,0 +1,82 @@
+# This is a simple 3d setup for testing a custom spherical shell
+# using the number of slices subdivision scheme.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 2000.0
+    set Outer temperature = 1000.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Custom mesh subdivision = number of slices
+    set Number of slices = 2
+    set Inner radius = 5711000
+    set Outer radius = 6371000
+    set Initial lateral refinement = 1
+    set Opening angle = 360
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1500.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format      = gnuplot
+  end
+end
diff --git a/tests/damped_viscoelastic_bending_beam.prm.bak b/tests/damped_viscoelastic_bending_beam.prm.bak
new file mode 100644
index 00000000000..51ff4a8c6cc
--- /dev/null
+++ b/tests/damped_viscoelastic_bending_beam.prm.bak
@@ -0,0 +1,49 @@
+# This test checks whether the viscoelastic bending beam benchmark
+# run successfully in combination with a viscous damper for the
+# elastic viscosity.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set End time  = 1e3
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 10
+  end
+end
+
+# Material model, adding viscous dampers to each material.
+# The material response is only significantly affected if
+# the damper viscosity is similar to or greater than
+# the product of the elastic timestep and the shear modulus.
+# A damper value of 0 Pas corresponds to purely elastic deformation.
+
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities            =  2800,  2800,  2800,  2800,  3300
+    set Viscosities          = 1.e18, 1.e18, 1.e18, 1.e18, 1.e24
+    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
+    set Fixed elastic time step     = 1e3
+    set Elastic damper viscosity    = 1e14
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = maximum composition
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/darcy_velocity.cc.bak b/tests/darcy_velocity.cc.bak
new file mode 100644
index 00000000000..41a9c23ffdf
--- /dev/null
+++ b/tests/darcy_velocity.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "rising_melt_blob.cc"
diff --git a/tests/darcy_velocity.prm.bak b/tests/darcy_velocity.prm.bak
new file mode 100644
index 00000000000..0036483f25a
--- /dev/null
+++ b/tests/darcy_velocity.prm.bak
@@ -0,0 +1,145 @@
+#########################################################
+# This is a test for the new advection method that advects a
+# compositional field with the fluid velocity prescribed by
+# Darcy's Law. Darcy's law is approximated here with:
+# u_f = u_s - K_D / phi * (rho_s * g - rho_f * g)
+# u_f = fluid velocity
+# u_s = solid velocity
+# K_D = Darcy Coefficient
+# phi = porosity
+# rho_f = fluid density
+# rhos_s = solid density
+# g = gravity
+# The second term on the rhs of Darcy's Law only contributes
+# to the component of the  fluid velocity parallel to the gravity
+# vector, which is proportional to the buoyancy of the fluid phase.
+
+# The initial porosity is uniform everywhere, and in the
+# center of the model is a blob of 'fluid' and 'solid'.
+# The solid has a prescribed x velocity, and so the fluid
+# blob should be advected horizontally with the solid velocity and
+# vertically as it rises up due to its buoyancy.
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 500
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 5
+set CFL number                             = 0.5
+set Output directory                       = darcy_velocity
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Maximum time step                      = 500
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 200000
+    set Y extent = 100000
+    set X repetitions = 2
+  end
+end
+
+# This model is only designed to predict fluid velocities arising from initial prescribed values in porosity.
+# As such, no variations in temperature are needed and both the boundary and initial temperatures are held constant.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 293
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top, bottom, left, right
+
+  subsection Box
+    set Bottom temperature = 293
+    set Top temperature    = 293
+    set Left temperature   = 293
+    set Right temperature  = 293
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x:function, right x:function
+  set Tangential velocity boundary indicators = top, bottom
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x,y,t
+    set Function expression = 1;0
+  end
+end
+
+############### Compositional fields
+# We want to use three compositional fields, the porosity and
+# and two additional fields. The solid field will be advected with
+# the solid speed prescribed above, and the fluid field will be advected
+# as the sum of the solid velocity and the vertical buoyancy the fluid has.
+# The porosity field is uniform to allow for a uniform fluid velocity. The
+# fluid field is a circle of radius 12.5km at the center of the model domain.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, fluid
+  set Compositional field methods = darcy field, darcy field
+  set Types of fields = porosity, generic
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=12500, A_f=0.2, A_s = 1.0
+    set Function expression = A_f; if((x - x0)*(x - x0) + (y - y0)*(y - y0) <= c*c, A_s, 0)
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators = bottom, top, left, right
+  set Allow fixed composition on outflow boundaries = true
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# The 'melting rate' material model from rising_melt_blob.cc is being
+# used since it provides terms for the fluid phase in this test. Melt
+# is not actually turned on, but the structure of the material model is
+# being used to fill fluid related parameters.
+subsection Material model
+  set Model name = melting rate
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, maximum depth of field
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/darcy_velocity_vertical.cc.bak b/tests/darcy_velocity_vertical.cc.bak
new file mode 100644
index 00000000000..41a9c23ffdf
--- /dev/null
+++ b/tests/darcy_velocity_vertical.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "rising_melt_blob.cc"
diff --git a/tests/darcy_velocity_vertical.prm.bak b/tests/darcy_velocity_vertical.prm.bak
new file mode 100644
index 00000000000..fb89d6ee3bc
--- /dev/null
+++ b/tests/darcy_velocity_vertical.prm.bak
@@ -0,0 +1,37 @@
+#########################################################
+# This is a test for the new advection method that advects a
+# compositional field with the fluid velocity prescribed by
+# Darcy's Law. Darcy's law is approximated here with:
+# u_f = u_s - K_D / phi * (rho_s * g - rho_f * g)
+# u_f = fluid velocity
+# u_s = solid velocity
+# K_D = Darcy Coefficient
+# phi = porosity
+# rho_f = fluid density
+# rhos_s = solid density
+# g = gravity
+# The second term on the rhs of Darcy's Law only contributes
+# to the component of the  fluid velocity parallel to the gravity
+# vector, which is proportional to the buoyancy of the fluid phase.
+
+# The initial porosity is uniform everywhere, and in the
+# center of the model is a blob of 'fluid' and 'solid'.
+# The solid has a prescribed y velocity that is exactly the opposite
+# of the Darcy velocity, and so the fluid blob should not move.
+
+############### Global parameters
+
+include $ASPECT_SOURCE_DIR/tests/darcy_velocity.prm
+
+set End time                               = 200
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top y:function, bottom y:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x,y,t
+    set Function expression = 0;-6.31152
+  end
+end
diff --git a/tests/dash_dash.cc.bak b/tests/dash_dash.cc.bak
new file mode 100644
index 00000000000..f3ae96f5b56
--- /dev/null
+++ b/tests/dash_dash.cc.bak
@@ -0,0 +1,50 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+
+// create a function that is run upon loading the plugin.  as discussed in the
+// corresponding .prm file, this function simply calls ASPECT again, and then
+// terminates the original instance of ASPECT
+int f()
+{
+  // call ASPECT with "--" and pipe an existing input file into it.
+  //
+  // notes:
+  // - the box_origin.prm file contains no explicit output directory
+  //   (nor would that be helpful here), so we also pipe the name
+  //   for a temporary output directory into ASPECT
+  // - if this directory does not exist, this would trigger
+  //   ASPECT's 'directory appears not to exist' warning.
+  //   consequently, remove the directory if it existed before
+  //   and re-create it as an empty directory
+  system ("cd output-dash_dash ; "
+          "(cat " ASPECT_SOURCE_DIR "/tests/box_origin.prm "
+          " ; "
+          " echo 'set Output directory = output.tmp' "
+          " ; "
+          " rm -rf output.tmp ; mkdir output.tmp "
+          ") "
+          "| ../../aspect -- ");
+  exit (0);
+}
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/dash_dash.prm.bak b/tests/dash_dash.prm.bak
new file mode 100644
index 00000000000..6926345742a
--- /dev/null
+++ b/tests/dash_dash.prm.bak
@@ -0,0 +1,8 @@
+# Test that we indeed read from stdin when the input file is given as "--"
+
+# This .prm file is really a sham. Its only purpose is to set up a test that
+# automatically loads a shared library that only starts aspect (again!) with
+# "--" as argument, and when that has finished running terminates the original
+# copy of aspect. In other words, the original aspect is only used to load a
+# shared library, nothing else, and so the contents of the current .prm file do
+# not matter.
diff --git a/tests/dc_Picard_compressible.prm b/tests/dc_Picard_compressible.prm
index d7cbe095d27..49e199d58ad 100644
--- a/tests/dc_Picard_compressible.prm
+++ b/tests/dc_Picard_compressible.prm
@@ -12,8 +12,6 @@ set Max nonlinear iterations               = 150
 set Max nonlinear iterations in pre-refinement = 0
 set Pressure normalization                 = surface
 set Maximum time step                      = 1e6
-
-#set Number of cheap Stokes solver steps    = 200  # aspect 2.2
 set Adiabatic surface temperature          = 1600
 set CFL number                             = 0.5
 
@@ -23,6 +21,8 @@ subsection Solver parameters
     set Linear solver tolerance             = 1e-2
     set Maximum number of expensive Stokes solver steps = 1000
     set Number of cheap Stokes solver steps    = 200
+
+    #    set Number of cheap Stokes solver steps = 200  # aspect 2.2
   end
 end
 
diff --git a/tests/dc_Picard_compressible.prm.bak b/tests/dc_Picard_compressible.prm.bak
new file mode 100644
index 00000000000..d7cbe095d27
--- /dev/null
+++ b/tests/dc_Picard_compressible.prm.bak
@@ -0,0 +1,263 @@
+#### This is a compressible whole Earth model solved by the
+#### single Advection, iterated dc Stokes. This represent a coarse
+#### version of a production type setup.
+#### Global parameters
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+set Nonlinear solver scheme                = single Advection, iterated defect correction Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 150
+set Max nonlinear iterations in pre-refinement = 0
+set Pressure normalization                 = surface
+set Maximum time step                      = 1e6
+
+#set Number of cheap Stokes solver steps    = 200  # aspect 2.2
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 0.5
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set GMRES solver restart length = 250
+    set Linear solver tolerance             = 1e-2
+    set Maximum number of expensive Stokes solver steps = 1000
+    set Number of cheap Stokes solver steps    = 200
+  end
+end
+
+#### Model Geometry
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3485e3
+    set Outer radius  = 6371e3 #5961e3
+    set Opening angle = 360
+  end
+end
+
+#### Mesh refinement
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Variable names      = depth,t
+    set Coordinate system = depth
+    set Function expression = if(depth<=200e3, 5,if(depth<=620e3, 5,if(depth<=680e3,5,if(depth>=2586e3,5,5))))
+
+    #if(depth<560e3,0,if(depth>760e3,0,6))
+    #        if(depth<560e3,5,if(depth>760e3,5,6))
+  end
+end
+
+##### Set temperature Model
+subsection Boundary temperature model
+  #set Allow fixed temperature on outflow boundaries = true  # default
+  set Fixed temperature boundary indicators         = bottom, top
+
+  #  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 273 #273 for surface ############
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators       = inner, outer
+
+  # set Zero velocity boundary indicators             = outer
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+# Number and names of compositional fields
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = plastic_strain #add strain field
+end
+
+#### Temperature model
+subsection Initial temperature model
+  #set Model name = adiabatic
+  set List of model names =  adiabatic, function
+  set List of model operators = add
+
+  #  set Model name = adiabatic
+  subsection Adiabatic
+    set Age bottom boundary layer = 100.e6
+    set Age top boundary layer = 100.e6
+    set Radius = 0
+    set Amplitude = 0
+    set Position = center
+    set Subadiabaticity = 0
+
+    #    subsection Function
+    #      set Variable names      = x,y
+    #      set Function constants  = R=6371.e3
+    #      set Function expression = #                                if(sqrt(x*x+y*y)<=R-660.e3, 1, 0); #                                if(sqrt(x*x+y*y)>R-660.e3, 1, 0)
+    #   end
+  end
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names      = x,y,z
+    set Function constants  = R=6371.e3
+    set Function expression = \
+                               if(sqrt(x*x+y*y)<=R<100e3, rand_seed(1) * 100 -50 , 0)
+  end
+end
+
+subsection Adiabatic conditions model # need to initialize for initial adiabatic temp.
+  #send
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_isentrope.txt
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating, radioactive decay
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+
+  subsection Radioactive decay
+    set Crust defined by composition = false
+    set Crust depth = 10e3
+    set Half decay times = 4.468e9, 0.704e9, 14e9, 1.248e9
+    set Heating rates = 9.4946e-5, 5.68e-4, 2.6368e-5, 2.8761e-5
+    set Initial concentrations crust = 0.0, 0.0, 0.0, 0.0
+    set Initial concentrations mantle = 0.0082, 0.000059, 0.024, 0.013
+    set Number of elements = 4
+  end
+
+  #set List of model names = compositional heating
+end
+
+############################ MATERIAL MODEL ######################################################################
+
+subsection Material model
+  set Model name = compositing #visco plastic #melt simple
+  set Material averaging = harmonic average
+
+  ############################ MATERIAL MODEL ######################################################################
+  subsection Compositing
+    set Viscosity = visco plastic
+    set Density = ascii reference profile
+    set Thermal expansion coefficient = ascii reference profile
+    set Specific heat = ascii reference profile
+    set Thermal conductivity = visco plastic
+    set Compressibility = ascii reference profile
+    set Entropy derivative pressure = ascii reference profile
+    set Entropy derivative temperature = ascii reference profile
+    set Reaction terms = visco plastic
+  end
+
+  subsection Ascii reference profile
+    set Thermal conductivity =  3.0
+
+    subsection Ascii data model
+      set Data file name = example_isentrope.txt
+      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    end
+  end
+
+  subsection Visco Plastic
+    set Define transition by depth instead of pressure  = true
+    set Phase transition Clapeyron slopes = background: 3.0e6|-2.5e6|9.e6
+    set Phase transition depths           = background: 410e3|660e3|2740e3
+    set Phase transition widths           = background: 12e3|23e3|11e3
+    set Phase transition temperatures     = background: 1770|1852|2591
+
+    # Reference temperature and viscosity
+    set Reference temperature = 293
+
+    # The minimum strain-rate helps limit large viscosities values that arise
+    # as the strain-rate approaches zero.
+    # The reference strain-rate is used on the first non-linear iteration
+    # of the first time step when the velocity has not been determined yet.
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+
+    # Limit the viscosity with minimum and maximum values
+    set Minimum viscosity = 1e20
+    set Maximum viscosity = 1e26
+
+    # Harmonic viscosity averaging
+    set Viscosity averaging scheme = harmonic
+
+    # Choose to have the viscosity (pre-yield) follow a dislocation
+    # diffusion or composite flow law.  Here, dislocation is selected
+    # so no need to specify diffusion creep parameters below, which are
+    # only used if "diffusion" or "composite" option is selected.
+    set Viscous flow law = diffusion
+
+    #  from cizkov
+    #     order:                           background    ,        mantle_low        ,        mantle_up
+    #    set Thermal diffusivities =   8.384146341463415e-07,     8.384146341463415e-07   , 7.309941520467837e-07
+
+    set Thermal diffusivities = 1.e-6
+    set Thermal expansivities = background: 3.e-5|2.e-5|2.e-5|2.e-5, plastic_strain: 3.e-5
+    set Heat capacities       =        1250     # specific heat
+    set Densities             = background: 3416|3800|4750|4750, plastic_strain: 3416
+
+    #    set Thermal expansivities =      3.0e-5  ,              3.0e-5,                     2.7e-5
+    #     Dislocation creep                                                 #(1/2)^3.5 * 1e-17
+    set Prefactors for dislocation creep          = background: 1e-22|1e-22|1e-30|1e-30, plastic_strain:1e-22
+    set Stress exponents for dislocation creep    = 3.5
+    set Activation energies for dislocation creep = background: 4.8e5|4.8e5|4.8e5|4.8e5, plastic_strain:4.8e5
+    set Activation volumes for dislocation creep  = background: 11.e-6|11.e-6|11.e-6|11.e-6, plastic_strain: 11.e-6
+
+    #     Diffusion creep
+    set Prefactors for diffusion creep            = background: 1.e-9|1.e-9|1.0e-16|1.0e-16, plastic_strain: 1.e-9
+    set Stress exponents for diffusion creep      = 1.0                                                  #### doesnt exist anymore??? ####
+    set Activation energies for diffusion creep   = background: 3.35e5|3.35e5|2.e5|2.e5, plastic_strain: 3.35e5
+    set Activation volumes for diffusion creep    = background: 4.8e-6|4.8e-6|1.1e-6|1.1e-6, plastic_strain: 4.8e-6
+    set Grain size                                = 1 #1e-3
+    set Grain size exponents for diffusion creep  = 0   #default
+
+    ###    # Plasticity parameters
+    set Angles of internal friction = background: 0|0|0|0, plastic_strain:0            # Angle Mohr
+    set Cohesions                   = background: 40e6|1e20|1e20|1e20, plastic_strain:40e6
+    set Strain weakening mechanism = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals = 1.e30
+    set Cohesion strain weakening factors = 1
+    set Friction strain weakening factors = 1
+    set End plasticity strain weakening intervals = 2.e30
+  end
+end
+
+#######################
+# Gravity model
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
+
+#######################
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, \
+                               composition statistics, depth average, heat flux statistics
+
+  subsection Depth average
+    set Number of zones = 3
+    set Output format = txt
+    set Time between graphical output = 1e7
+    set Depth boundaries of zones = 0, 10000,150000,2900000
+  end
+end
diff --git a/tests/density_boundary.prm.bak b/tests/density_boundary.prm.bak
new file mode 100644
index 00000000000..9f17af0f0e9
--- /dev/null
+++ b/tests/density_boundary.prm.bak
@@ -0,0 +1,95 @@
+# This is a relatively realistic compressible model setup.
+# There is no simple analytical solution to it, it is rather
+# intended to serve as a comparison for more complicated
+# material models, which should be able to reproduce it.
+# The material model used here is already tested by
+# simple_compressibility_iterated_stokes.
+# Currently there is the steinberger_compressible test
+# reproducing this test.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+    set Reference compressibility = 2.5e-12
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, boundary densities
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/depth_average_01.prm.bak b/tests/depth_average_01.prm.bak
new file mode 100644
index 00000000000..3ad349605ae
--- /dev/null
+++ b/tests/depth_average_01.prm.bak
@@ -0,0 +1,90 @@
+# Test the 'depth average' postprocessor on a coarse mesh version of
+# convection_box.prm. This test makes no sense since we average over 10 depth
+# intervals but we only compute on a 4x4 mesh -- This is sufficient to produce
+# reasonable data, but not enough for actual resolution.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Time between graphical output = 0.1
+    set Number of zones = 10
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-15
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-15
+  end
+end
diff --git a/tests/depth_average_02.prm.bak b/tests/depth_average_02.prm.bak
new file mode 100644
index 00000000000..8c5bb292eab
--- /dev/null
+++ b/tests/depth_average_02.prm.bak
@@ -0,0 +1,88 @@
+# Like the _01 test, but adjust the number of intervals we compute on
+# in such a way that it makes sense for the 4x4 mesh we have here
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Time between graphical output = 0.1
+    set Number of zones = 4
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-15
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-15
+  end
+end
diff --git a/tests/depth_average_03.prm.bak b/tests/depth_average_03.prm.bak
new file mode 100644
index 00000000000..b6f6ef0667a
--- /dev/null
+++ b/tests/depth_average_03.prm.bak
@@ -0,0 +1,93 @@
+# Like the _02 test, but create output in years. At one point I
+# believed that this was previously ignored (despite assurances in the
+# manual) but it turned out to work nevertheless. Anyway, it's good to
+# have a test.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 10 # but note the very low viscosity
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1e+9
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    # output every 5 years (noting that 'Use years in
+    # output instead of seconds' is set). For the current
+    # model, this means twice
+    set Time between graphical output = 5
+    set Number of zones = 4
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-15
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-15
+  end
+end
diff --git a/tests/depth_average_04.prm.bak b/tests/depth_average_04.prm.bak
new file mode 100644
index 00000000000..be78266ebea
--- /dev/null
+++ b/tests/depth_average_04.prm.bak
@@ -0,0 +1,91 @@
+# Like _03, but output stuff in a different format than gnuplot
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 10 # but note the very low viscosity
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1e+9
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    # output every 5 years (noting that 'Use years in
+    # output instead of seconds' is set). For the current
+    # model, this means twice
+    set Time between graphical output = 5
+    set Number of zones = 4
+    set Output format = vtk
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-15
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-15
+  end
+end
diff --git a/tests/depth_average_05.prm.bak b/tests/depth_average_05.prm.bak
new file mode 100644
index 00000000000..5d457e2820f
--- /dev/null
+++ b/tests/depth_average_05.prm.bak
@@ -0,0 +1,91 @@
+# Test outputting a subset of the available laterally-averaged
+# quantities in the DepthAverage postprocessor.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Time between graphical output = 0.1
+    set Number of zones = 10
+
+    # Test outputting a subset of the depth-averaged quantities
+    set List of output variables = velocity magnitude, temperature
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-15
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-15
+  end
+end
diff --git a/tests/depth_average_06.prm.bak b/tests/depth_average_06.prm.bak
new file mode 100644
index 00000000000..bc2b38c6e6b
--- /dev/null
+++ b/tests/depth_average_06.prm.bak
@@ -0,0 +1,79 @@
+# Test the 'depth average' postprocessor, specifically the
+# vertical mass flux value. In this model the mass flux
+# is upwards and varies linearly from 0.5 to 1.0 across
+# the model.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = y
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   =
+  set List of model names =
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Prescribed velocity boundary indicators = top: function, bottom: function
+
+  subsection Function
+    set Function expression = 0.0; 1.0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0.5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Time between graphical output = 0.1
+    set Number of zones = 10
+    set Output format = txt
+  end
+end
diff --git a/tests/depth_average_rounding_bug.prm.bak b/tests/depth_average_rounding_bug.prm.bak
new file mode 100644
index 00000000000..ab2c117db35
--- /dev/null
+++ b/tests/depth_average_rounding_bug.prm.bak
@@ -0,0 +1,85 @@
+# Test to verify the following rounding bug in depth-averaging is fixed:
+#
+# An error occurred in line <107> of file <source/simulator/lateral_averaging.cc> in function
+# The violated condition was:
+#     idx<num_slices
+
+set Dimension                              = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 30
+    set Chunk maximum longitude = 67
+    set Longitude repetitions = 1
+    set Chunk minimum latitude = 0
+    set Chunk maximum latitude = 41
+    set Latitude repetitions = 1
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer
+  set Zero velocity boundary indicators       = inner, west, east
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 1e3
+    set Output format                 = gnuplot
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 50
+end
diff --git a/tests/depth_average_txt_output.prm.bak b/tests/depth_average_txt_output.prm.bak
new file mode 100644
index 00000000000..00cabdc42bf
--- /dev/null
+++ b/tests/depth_average_txt_output.prm.bak
@@ -0,0 +1,90 @@
+# Test outputting laterally-averaged quantities from the
+# DepthAverage postprocessor in a plain ascii text table format.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Time between graphical output = 0.1
+    set Number of zones = 10
+    set List of output variables = velocity magnitude, temperature
+    set Output format = txt
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-15
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-15
+  end
+end
diff --git a/tests/depth_average_underres.prm.bak b/tests/depth_average_underres.prm.bak
new file mode 100644
index 00000000000..d1c61b2cd41
--- /dev/null
+++ b/tests/depth_average_underres.prm.bak
@@ -0,0 +1,92 @@
+# Duplicate of depth_average_01, with coarser mesh
+
+# Test the 'depth average' postprocessor on a coarse mesh version of
+# convection_box.prm. This test makes no sense since we average over 21 depth
+# intervals but we only compute on a 2x2 mesh -- one of the depth intervals
+# will receive no quadrature points
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Time between graphical output = 0.1
+    set Number of zones = 21
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-15
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-15
+  end
+end
diff --git a/tests/depth_dependent_3d_shell_list_simple.prm.bak b/tests/depth_dependent_3d_shell_list_simple.prm.bak
new file mode 100644
index 00000000000..c57582c0d7a
--- /dev/null
+++ b/tests/depth_dependent_3d_shell_list_simple.prm.bak
@@ -0,0 +1,83 @@
+# Test depth-dependent material model for a 3d spherical
+# shell geometry calculation using base model ''simple''
+# and depth dependence taken from list
+# A simple setup for convection in a 3d shell. See the
+# manual for more information.
+
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1.0e5
+set Output directory                       = output-depth-dependent-3d-shell-list-simple
+
+subsection Material model
+  set Model name = depth dependent
+
+  subsection Depth dependent model
+    set Base model = simple
+    set Depth dependence method = List
+    set Depth list = 6.7e5, 3.481e6
+    set Viscosity list = 1.0e21, 3.0e22
+    set Reference viscosity = 1e22
+  end
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1973
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1473
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 1.0e6
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 50
+end
diff --git a/tests/depth_dependent_additional_outputs.prm.bak b/tests/depth_dependent_additional_outputs.prm.bak
new file mode 100644
index 00000000000..5659a4b6534
--- /dev/null
+++ b/tests/depth_dependent_additional_outputs.prm.bak
@@ -0,0 +1,34 @@
+# Like grain_size_growth.prm, but check that additional
+# material model outputs can be postprocessed correctly
+# in the depth-dependent material model.
+
+############### Global parameters
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
+
+set End time = 0
+
+subsection Material model
+  set Model name = depth dependent
+
+  subsection Depth dependent model
+    set Base model = grain size
+    set Reference viscosity = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = named additional outputs
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/depth_dependent_box_file_simple.prm.bak b/tests/depth_dependent_box_file_simple.prm.bak
new file mode 100644
index 00000000000..a8be50f11da
--- /dev/null
+++ b/tests/depth_dependent_box_file_simple.prm.bak
@@ -0,0 +1,159 @@
+# Test depth-dependent material model in 2d box using a file
+# to specify depth-dependence. This test uses the default viscosity
+# structure, defined in the documentation.
+
+# A description of convection in a 2d box. See the manual for more information.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 1.0e8
+set Output directory                       = output-depth-dependent-box-file-simple
+
+# Then there are variables that describe the tolerance of
+# the linear solver as well as how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.0e6
+    set Y extent = 3.0e6
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
+    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above. (As will be seen
+# in the next section, the actual temperature prescribed here
+# at the left and right does not matter.)
+# We then also have to prescribe several other parts of the model such as
+# which boundaries actually carry a prescribed boundary temperature, whereas
+# all other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 2773
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 273.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = depth dependent
+
+  subsection Depth dependent model
+    set Base model = simple
+    set Depth dependence method = File
+    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/depth-dependent/
+    set Viscosity depth file = visc_depth.txt
+    set Reference viscosity = 1e25
+  end
+
+  subsection Simple model
+    set Reference density             = 3300.0
+    set Reference specific heat       = 1250.0
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e25
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/depth_dependent_box_function_simple.prm.bak b/tests/depth_dependent_box_function_simple.prm.bak
new file mode 100644
index 00000000000..c170cf1a926
--- /dev/null
+++ b/tests/depth_dependent_box_function_simple.prm.bak
@@ -0,0 +1,161 @@
+# Test depth-dependent material model using simple material model as
+# base model with depth-dependence specified by user-provided function
+
+# A description of convection in a 2d box. See the manual for more information.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 1.0e8
+set Output directory                       = output-depth-dependent-box-function-simple
+
+# Then there are variables that describe the tolerance of
+# the linear solver as well as how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.0e6
+    set Y extent = 3.0e6
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
+    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above. (As will be seen
+# in the next section, the actual temperature prescribed here
+# at the left and right does not matter.)
+# We then also have to prescribe several other parts of the model such as
+# which boundaries actually carry a prescribed boundary temperature, whereas
+# all other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 2773
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 273.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = depth dependent
+
+  subsection Depth dependent model
+    set Base model = simple
+    set Depth dependence method = Function
+    set Reference viscosity = 1e25
+
+    subsection Viscosity depth function
+      set Variable names = d
+      set Function expression = if(d>6.70e5,3.0e22,1.0e21);
+    end
+  end
+
+  subsection Simple model
+    set Reference density             = 3300.0
+    set Reference specific heat       = 1250.0
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e25
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics,  depth average
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/depth_dependent_box_function_time_dependent.prm.bak b/tests/depth_dependent_box_function_time_dependent.prm.bak
new file mode 100644
index 00000000000..984d2c0a8f9
--- /dev/null
+++ b/tests/depth_dependent_box_function_time_dependent.prm.bak
@@ -0,0 +1,164 @@
+# Test depth-dependent material model using simple material model as
+# base model with depth-dependence specified by user-provided function.
+# This is an extended copy from depth_dependent_box_function that
+# uses a time dependent function to prescribe depth dependent viscosity.
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 1.0e8
+set Output directory                       = output-depth-dependent-box-function-time-dependent
+
+# Then there are variables that describe the tolerance of
+# the linear solver as well as how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.0e6
+    set Y extent = 3.0e6
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
+    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above. (As will be seen
+# in the next section, the actual temperature prescribed here
+# at the left and right does not matter.)
+# We then also have to prescribe several other parts of the model such as
+# which boundaries actually carry a prescribed boundary temperature, whereas
+# all other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 2773
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 273.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = depth dependent
+
+  subsection Depth dependent model
+    set Base model = simple
+    set Depth dependence method = Function
+    set Reference viscosity = 1e25
+
+    subsection Viscosity depth function
+      set Variable names = d,t
+      set Function expression = if(d>6.70e5,3.0e22*(1.0+t/1e8),1.0e21*(1.0+t/1e8));
+    end
+  end
+
+  subsection Simple model
+    set Reference density             = 3300.0
+    set Reference specific heat       = 1250.0
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e25
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics,  depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/depth_dependent_box_none_simple.prm.bak b/tests/depth_dependent_box_none_simple.prm.bak
new file mode 100644
index 00000000000..171f1720630
--- /dev/null
+++ b/tests/depth_dependent_box_none_simple.prm.bak
@@ -0,0 +1,157 @@
+# Test depth-dependent material model in 2d box using simple material model as
+# base model with no depth-dependence
+
+# A description of convection in a 2d box. See the manual for more information.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 1.0e8
+
+#set Output directory                       = output
+
+# Then there are variables that describe the tolerance of
+# the linear solver as well as how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.0e6
+    set Y extent = 3.0e6
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
+    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above. (As will be seen
+# in the next section, the actual temperature prescribed here
+# at the left and right does not matter.)
+# We then also have to prescribe several other parts of the model such as
+# which boundaries actually carry a prescribed boundary temperature, whereas
+# all other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 2773
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 273.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = depth dependent
+
+  subsection Depth dependent model
+    set Base model = simple
+    set Depth dependence method = None
+    set Reference viscosity = 1e25
+  end
+
+  subsection Simple model
+    set Reference density             = 3300.0
+    set Reference specific heat       = 1250.0
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e25
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/depth_dependent_initialize_base_model.prm.bak b/tests/depth_dependent_initialize_base_model.prm.bak
new file mode 100644
index 00000000000..84a05525bde
--- /dev/null
+++ b/tests/depth_dependent_initialize_base_model.prm.bak
@@ -0,0 +1,133 @@
+# A test that makes sure that the depth dependent material model
+# correctly initializes its base model (if the base model needs
+# initialization).
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+
+subsection Material model
+  set Model name = depth dependent
+  set Material averaging = harmonic average
+
+  subsection Depth dependent model
+    set Base model = ascii reference profile
+    set Depth dependence method = None
+    set Reference viscosity = 1e21
+  end
+
+  subsection Ascii reference profile
+    set Thermal viscosity exponent = 0
+    set Viscosity prefactors = 1.0, 1.0, 1.0, 1.0
+
+    subsection Ascii data model
+      set Data file name = example_isentrope.txt
+      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    end
+  end
+end
+
+# The geometry is a spherical shell with the inner and
+# outer radius of the Earth's mantle.
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Adiabatic conditions model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_isentrope.txt
+  end
+end
+
+# The gravity model reads an ascii data file that contains a gravity
+# profile consistent with the material properties computed using the
+# Birch-Murnaghan equation of state. It automatically uses the same file
+# specified in the adiabatic conditions model.
+subsection Gravity model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
+    set Data file name = example_isentrope.txt
+  end
+end
+
+# The model uses the anelastic liquid approximation.
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
+
+# The present-day plate velocities are imposed on the upper model
+# boundary.
+
+
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = outer:gplates
+  set Tangential velocity boundary indicators = inner
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 273
+  end
+end
+
+# The initial temperature is an adiabatic profile, which is
+# taken from the adiabatic conditions model. In this case, this is
+# is the ascii data model that loads a file containing profiles
+# corresponding to the Birch-Murnaghan equation of state.
+# In addition to the adiabatic profile, there are thermal boundary
+# layers at the surface and the core-mantle boundary.
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Mesh refinement
+  set Refinement fraction                = 0.4
+  set Coarsening fraction                = 0.05
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 2
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 5
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/tests/depth_postprocessor_box.prm.bak b/tests/depth_postprocessor_box.prm.bak
new file mode 100644
index 00000000000..b8ad2c0b598
--- /dev/null
+++ b/tests/depth_postprocessor_box.prm.bak
@@ -0,0 +1,64 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = depth
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/depth_postprocessor_chunk.prm.bak b/tests/depth_postprocessor_chunk.prm.bak
new file mode 100644
index 00000000000..ec7cdd6eaa9
--- /dev/null
+++ b/tests/depth_postprocessor_chunk.prm.bak
@@ -0,0 +1,70 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 0.75
+    set Chunk maximum longitude = 10
+    set Chunk maximum latitude = 10
+    set Radius repetitions = 2
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy = temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = depth
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/depth_postprocessor_ellipsoidal_chunk.prm.bak b/tests/depth_postprocessor_ellipsoidal_chunk.prm.bak
new file mode 100644
index 00000000000..6a581bdad65
--- /dev/null
+++ b/tests/depth_postprocessor_ellipsoidal_chunk.prm.bak
@@ -0,0 +1,78 @@
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = east, west
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = west: 0, east: 1
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Geometry model
+  set Model name = ellipsoidal chunk
+
+  subsection Ellipsoidal chunk
+    set NE corner = 5:30
+    set NW corner = 0:0
+    set SE corner = 10:-10
+    set Depth = 3000000
+    set Eccentricity = 0.5
+    set East-West subdivisions = 2
+    set North-South subdivisions = 2
+    set Depth subdivisions = 2
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Strategy = temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = depth
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/depth_postprocessor_sphere.prm.bak b/tests/depth_postprocessor_sphere.prm.bak
new file mode 100644
index 00000000000..06072219de9
--- /dev/null
+++ b/tests/depth_postprocessor_sphere.prm.bak
@@ -0,0 +1,68 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 0
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = surface: 0.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial linear
+
+  subsection Radial linear
+    set Magnitude at bottom = 0.0
+  end
+end
+
+subsection Geometry model
+  set Model name = sphere
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1000
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e20
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy = temperature
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = depth
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/depth_postprocessor_spherical_shell.prm.bak b/tests/depth_postprocessor_spherical_shell.prm.bak
new file mode 100644
index 00000000000..32bbc7697ad
--- /dev/null
+++ b/tests/depth_postprocessor_spherical_shell.prm.bak
@@ -0,0 +1,67 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1000
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e20
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Strategy = temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = depth
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/depth_postprocessor_two_merged_boxes.prm.bak b/tests/depth_postprocessor_two_merged_boxes.prm.bak
new file mode 100644
index 00000000000..49a196df9bf
--- /dev/null
+++ b/tests/depth_postprocessor_two_merged_boxes.prm.bak
@@ -0,0 +1,68 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box with lithosphere boundary indicators
+
+  subsection Box with lithosphere boundary indicators
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = depth
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/derivative_of_weighted_p_norm_average.cc.bak b/tests/derivative_of_weighted_p_norm_average.cc.bak
new file mode 100644
index 00000000000..f020c66dc46
--- /dev/null
+++ b/tests/derivative_of_weighted_p_norm_average.cc.bak
@@ -0,0 +1,41 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/utilities.h>
+
+int f()
+{
+  using namespace aspect;
+
+  std::vector<double> weights = {1,2};
+  std::vector<double> values = {3,4};
+  std::vector<double> derivatives = {5,6};
+  std::vector<double> p_norms = {-1000,-2.5,-2,-1,0,1,2,2.5,3,4,1000};
+
+  for (unsigned int i = 0; i < p_norms.size(); i++)
+    {
+      std::cout << "p = " << p_norms[i] << ", average = " << aspect::Utilities::derivative_of_weighted_p_norm_average<double>(0,weights,values,derivatives,p_norms[i]) << std::endl;
+    }
+
+  exit(0);
+  return 42;
+}
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/derivative_of_weighted_p_norm_average.prm.bak b/tests/derivative_of_weighted_p_norm_average.prm.bak
new file mode 100644
index 00000000000..bcddea0d59b
--- /dev/null
+++ b/tests/derivative_of_weighted_p_norm_average.prm.bak
@@ -0,0 +1 @@
+set Additional shared libraries = tests/libderivative_of_weighted_p_norm_average.so
diff --git a/tests/diffusion.prm.bak b/tests/diffusion.prm.bak
new file mode 100644
index 00000000000..a83283bd668
--- /dev/null
+++ b/tests/diffusion.prm.bak
@@ -0,0 +1,304 @@
+# A test by Juliane Dannberg
+#
+# This test verifies whether physical diffusion works as expected.
+# It sets up a half-space heated from above and cooled from below
+# for which we know that (if infinite) the temperature should behave
+# as a time dependent function like
+#   T(z,t) = (T_halfspace - T_0) * erf(z / (2*sqrt(kappa * t))) + T_0
+# where
+#   T_0 = surface temperature (here =1)
+#   T_halfspace = temperature at infinity (here =0)
+#   kappa = thermal diffusivity (= k / (rho * c_p))
+#   z = distance to surface
+#   t = time
+#
+# The results produced by this test have been verified to be correct.
+
+##################################################################
+
+
+
+# Listing of Parameters
+# ---------------------
+
+# At the top, state that the program should be run for a two-dimensional
+# simulation
+set Dimension = 2
+
+# In computations, the time step $k$ is chosen according to $k = c \min_K
+# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
+# and the denominator is the maximal magnitude of the velocity on cell $K$
+# times the polynomial degree $p_T$ of the temperature discretization. The
+# dimensionless constant $c$ is called the CFL number in this program. For
+# time discretizations that have explicit components, $c$ must be less than a
+# constant that depends on the details of the time discretization and that is
+# no larger than one. On the other hand, for implicit discretizations such as
+# the one chosen here, one can choose the time step as large as one wants (in
+# particular, one can choose $c>1$) though a CFL number significantly larger
+# than one will yield rather diffusive solutions. Units: None.
+set CFL number                             = 0.01
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 4e7
+
+# The name of the directory into which all output files should be placed. This
+# may be an absolute or a relative path.
+
+# A flag indicating whether the computation should be resumed from a
+# previously saved state (if true) or start from scratch (if false).
+set Resume computation                     = false
+
+# The start time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set Start time                             = 0
+
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Adiabatic surface temperature          = 0
+
+# The mathematical equations that describe thermal convection only determine
+# the pressure up to an arbitrary constant. On the other hand, for comparison
+# and for looking up material parameters it is important that the pressure be
+# normalized somehow. We do this by enforcing a particular average pressure
+# value at the surface of the domain, where the geometry model determines
+# where the surface is. This parameter describes what this average surface
+# pressure value is supposed to be. By default, it is set to zero, but one may
+# want to choose a different value for example for simulating only the volume
+# of the mantle below the lithosphere, in which case the surface pressure
+# should be the lithostatic pressure at the bottom of the lithosphere.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Surface pressure                       = 0
+
+# When computing results for mantle convection simulations, it is often
+# difficult to judge the order of magnitude of results when they are stated in
+# MKS units involving seconds. Rather, some kinds of results such as
+# velocities are often stated in terms of meters per year (or, sometimes,
+# centimeters per year). On the other hand, for non-dimensional computations,
+# one wants results in their natural unit system as used inside the code. If
+# this flag is set to 'true' conversion to years happens; if it is 'false', no
+# such conversion happens.
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set List of model names = box
+
+  # A comma separated list of integers denoting those boundaries on which the
+  # temperature is fixed and described by the boundary temperature object
+  # selected in its own section of this input file. All boundary indicators
+  # used by the geometry but not explicitly listed here will end up with
+  # no-flux (insulating) boundary conditions.
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Bottom temperature = 0
+    set Top temperature    = 1
+  end
+end
+
+subsection Discretization
+  # The polynomial degree to use for the velocity variables in the Stokes
+  # system. Units: None.
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+
+  # Whether to use a Stokes discretization that is locally conservative at the
+  # expense of a larger number of degrees of freedom (true), or to go with a
+  # cheaper discretization that does not locally conserve mass, although it is
+  # globally conservative (false).
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    # Extent of the box in x-direction. Units: \\si{\\meter}.
+    set X extent = 1
+
+    # Extent of the box in y-direction. Units: \\si{\\meter}.
+    set Y extent = 1
+
+    # Extent of the box in z-direction. This value is ignored if the
+    # simulation is in 2d Units: \\si{\\meter}.
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
+    set Reference density             = 1
+
+    # The value of the specific heat $cp$. Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.
+    set Reference specific heat       = 1250
+
+    # The reference temperature $T_0$. Units: \\si{\\kelvin}.
+    set Reference temperature         = 0
+
+    # The value of the thermal conductivity $k$. Units: \\si{\\watt\\per\\meter\\per\\kelvin}.
+    set Thermal conductivity          = 1e-6
+
+    # The value of the thermal expansion coefficient $\beta$. Units: \\si{\\per\\kelvin}.
+    set Thermal expansion coefficient = 2e-5
+
+    # The value of the constant viscosity. Units: \\si{\\pascal\\second}.
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  # A list of times so that if the end time of a time step is beyond this
+  # time, an additional round of mesh refinement is triggered. This is mostly
+  # useful to make sure we can get through the initial transient phase of a
+  # simulation on a relatively coarse mesh, and then refine again when we are
+  # in a time range that we are interested in and where we would like to use a
+  # finer mesh. Units: each element of the list has units years if the 'Use
+  # years in output instead of seconds' parameter is set; seconds otherwise.
+  set Additional refinement times        =
+
+  # The number of adaptive refinement steps performed after initial global
+  # refinement but while still within the first time step.
+  set Initial adaptive refinement        = 0
+
+  # The number of global refinement steps performed on the initial coarse
+  # mesh, before the problem is first solved there.
+  set Initial global refinement          = 5
+
+  # The fraction of cells with the largest error that should be flagged for
+  # refinement.
+  set Refinement fraction                = 0.3
+
+  # The fraction of cells with the smallest error that should be flagged for
+  # coarsening.
+  set Coarsening fraction                = 0.05
+
+  # The method used to determine which cells to refine and which to coarsen.
+  set Strategy                           = thermal energy density
+
+  # The number of time steps after which the mesh is to be adapted again based
+  # on computed error indicators.
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  # A comma separated list of integers denoting those boundaries on which the
+  # velocity is tangential and unrestrained, i.e., where no external forces
+  # act to prescribe a particular tangential velocity (although there is a
+  # force that requires the flow to be tangential).
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Checkpointing
+  # The wall time between performing checkpoints. If 0, will use the
+  # checkpoint step frequency instead.
+  set Time between checkpoint                = 0
+
+  # The number of timesteps between performing checkpoints. If 0 and time
+  # between checkpoint is not specified, checkpointing will not be performed.
+  set Steps between checkpoint               = 50
+end
+
+subsection Postprocess
+  # A comma separated list of postprocessor objects that should be run at the
+  # end of each time step. Some of these postprocessors will declare their own
+  # parameters which may, for example, include that they will actually do
+  # something only every so many time steps or years. Alternatively, the text
+  # 'all' indicates that all available postprocessors should be run after each
+  # time step.
+  #
+  # The following postprocessors are available:
+  #
+  # `depth average': A postprocessor that computes depth averaged quantities
+  # and writes them out.
+  #
+  # `heat flux statistics': A postprocessor that computes some statistics
+  # about the heat flux across boundaries.
+  #
+  # `heat flux statistics for the table model': A postprocessor that computes
+  # some statistics about the heat flux across boundaries.
+  #
+  # `velocity statistics for the table model': A postprocessor that computes
+  # some statistics about the velocity field.
+  #
+  # `temperature statistics': A postprocessor that computes some statistics
+  # about the temperature field.
+  #
+  # `velocity statistics': A postprocessor that computes some statistics about
+  # the velocity field.
+  #
+  # `visualization': A postprocessor that takes the solution and writes it
+  # into files that can be read by a graphical visualization program.
+  # Additional run time parameters are read from the parameter subsection
+  # 'Visualization'.
+  set List of postprocessors = temperature statistics, heat flux statistics, depth average
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 1
+    set Number of zones = 10
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+    set List of output variables      = density,viscosity
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/diffusion_dislocation.prm.bak b/tests/diffusion_dislocation.prm.bak
new file mode 100644
index 00000000000..026576959c8
--- /dev/null
+++ b/tests/diffusion_dislocation.prm.bak
@@ -0,0 +1,122 @@
+# This somewhat specific test checks the diffusion dislocation
+# rheology model (with Hirth and Kohlstedt (2004) parameters
+# for dry olivine).
+# It sets up a 2D Cartesian box with two different materials
+# inside. Both materials are olivine, but the second has an
+# adjusted density. The starting temperature is a typical
+# geotherm. The top and bottom boundaries are held at fixed
+# temperature, and all boundaries have tangential velocity
+# boundary conditions.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent    = 3000e3
+    set Y extent    = 750e3
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields  = depleted_lithosphere
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = if(y>=650e3,1,0)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=750e3, w=3000e3
+    set Function expression = \
+      if( y < 100e3, \
+        (100e3-y)/100e3*100+1635, \
+        if(y>650e3, \
+          (h-y)/(100e3)*1342+293, \
+          1635))
+  end
+end
+
+subsection Material model
+  set Model name = diffusion dislocation
+
+  subsection Diffusion dislocation
+    set Reference temperature = 293
+    set Minimum strain rate = 5e-19
+    set Minimum viscosity = 1e1
+    set Maximum viscosity = 1e28
+    set Effective viscosity coefficient = 1.0
+    set Thermal diffusivity = 0.8e-6
+    set Heat capacity = 1.25e3
+    set Densities = 3330, 3300
+    set Thermal expansivities = 2e-5
+    set Viscosity averaging scheme = harmonic
+    set Grain size = 1e-3
+    set Prefactors for diffusion creep = 1.5e-15
+    set Stress exponents for diffusion creep = 1
+    set Grain size exponents for diffusion creep = 3
+    set Activation energies for diffusion creep = 3.75e5
+    set Activation volumes for diffusion creep = 6e-6
+    set Prefactors for dislocation creep = 1.1e-16
+    set Stress exponents for dislocation creep = 3.5
+    set Activation energies for dislocation creep = 5.3e5
+    set Activation volumes for dislocation creep = 1.4e-5
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                 = 3
+  set Initial adaptive refinement               = 0
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 0
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/diffusion_dislocation_fixed_strain_rate.prm.bak b/tests/diffusion_dislocation_fixed_strain_rate.prm.bak
new file mode 100644
index 00000000000..b4bb8eefd8a
--- /dev/null
+++ b/tests/diffusion_dislocation_fixed_strain_rate.prm.bak
@@ -0,0 +1,92 @@
+# This model has a box geometry where simple shear is induced by constant velocity
+# along the bottom and top boundaries. Diffusion dislocation creep laws corresponding
+# to the model of Hirth and Kohlstedt for dry olivine are used, and the viscosity is
+# calculated at the first time step for a constant temperature of 1600 K.
+# The analytical solution for the viscosity with the given parameters is 5.81735e17 Pas.
+# Note that the strain rate output by aspect is the *norm*, but the model itself uses
+# the square root of the second invariant. For reference, edot_norm = sqrt(2*edot_ii).
+# The depth average output contains viscosity output, and so provides the required test.
+
+
+set Dimension = 2
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic  = true
+    set X extent    = 500e3
+    set Y extent    = 500e3
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = if(y<250e3,1,-1); 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600
+  end
+end
+
+subsection Material model
+  set Model name = diffusion dislocation
+
+  subsection Diffusion dislocation
+    set Reference temperature = 293
+    set Minimum strain rate = 5e-19
+    set Minimum viscosity = 1e1
+    set Maximum viscosity = 1e28
+    set Effective viscosity coefficient = 1.0
+    set Thermal diffusivity = 0.8e-6
+    set Heat capacity = 1.25e3
+    set Densities = 3300
+    set Thermal expansivities = 2e-5
+    set Viscosity averaging scheme = harmonic
+    set Grain size = 1e-3
+    set Prefactors for diffusion creep = 1.5e-15
+    set Stress exponents for diffusion creep = 1
+    set Grain size exponents for diffusion creep = 3
+    set Activation energies for diffusion creep = 3.75e5
+    set Activation volumes for diffusion creep = 6e-6
+    set Prefactors for dislocation creep = 1.1e-16
+    set Stress exponents for dislocation creep = 3.5
+    set Activation energies for dislocation creep = 5.3e5
+    set Activation volumes for dislocation creep = 1.4e-5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                 = 5
+  set Initial adaptive refinement               = 0
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, depth average
+end
diff --git a/tests/diffusion_dislocation_fixed_strain_rate2.prm.bak b/tests/diffusion_dislocation_fixed_strain_rate2.prm.bak
new file mode 100644
index 00000000000..452b3237d84
--- /dev/null
+++ b/tests/diffusion_dislocation_fixed_strain_rate2.prm.bak
@@ -0,0 +1,88 @@
+# This is a modification of the diffusion_dislocation_fixed_strain_rate
+# test, where only the temperature and the strain rate are different.
+# It tests if the diffusion dislocation model also works correctly if
+# material model inputs are slightly outside the range of what is usually
+# encountered in the mantle.
+
+set Dimension = 2
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic  = true
+    set X extent    = 500e3
+    set Y extent    = 500e3
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = if(y<250e3,1,-1); 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 160
+  end
+end
+
+subsection Material model
+  set Model name = diffusion dislocation
+
+  subsection Diffusion dislocation
+    set Reference temperature = 293
+    set Minimum strain rate = 5e-19
+    set Minimum viscosity = 1e1
+    set Maximum viscosity = 1e28
+    set Effective viscosity coefficient = 1.0
+    set Thermal diffusivity = 0.8e-6
+    set Heat capacity = 1.25e3
+    set Densities = 3300
+    set Thermal expansivities = 2e-5
+    set Viscosity averaging scheme = harmonic
+    set Grain size = 1e-3
+    set Prefactors for diffusion creep = 1.5e-15
+    set Stress exponents for diffusion creep = 1
+    set Grain size exponents for diffusion creep = 3
+    set Activation energies for diffusion creep = 3.75e5
+    set Activation volumes for diffusion creep = 6e-6
+    set Prefactors for dislocation creep = 1.1e-16
+    set Stress exponents for dislocation creep = 3.5
+    set Activation energies for dislocation creep = 5.3e4
+    set Activation volumes for dislocation creep = 1.4e-5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                 = 5
+  set Initial adaptive refinement               = 0
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, depth average
+end
diff --git a/tests/diffusion_dislocation_reference_density_profile.prm.bak b/tests/diffusion_dislocation_reference_density_profile.prm.bak
new file mode 100644
index 00000000000..3a246ceda49
--- /dev/null
+++ b/tests/diffusion_dislocation_reference_density_profile.prm.bak
@@ -0,0 +1,124 @@
+# Identical to the test diffusion_dislocation, except the
+# reference density profile formulation is used for the
+# temperature equation.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = diffusion_dislocation_reference_density_profile
+
+# Use 'reference density profile' formulation for the temperature equation
+subsection Formulation
+  set Formulation          = custom
+  set Mass conservation    = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent    = 3000e3
+    set Y extent    = 750e3
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields  = depleted_lithosphere
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = if(y>=650e3,1,0)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=750e3, w=3000e3
+    set Function expression = \
+      if( y < 100e3, \
+        (100e3-y)/100e3*100+1635, \
+        if(y>650e3, \
+          (h-y)/(100e3)*1342+293, \
+          1635))
+  end
+end
+
+subsection Material model
+  set Model name = diffusion dislocation
+
+  subsection Diffusion dislocation
+    set Reference temperature = 293
+    set Minimum strain rate = 5e-19
+    set Minimum viscosity = 1e1
+    set Maximum viscosity = 1e28
+    set Effective viscosity coefficient = 1.0
+    set Thermal diffusivity = 0.8e-6
+    set Heat capacity = 1.25e3
+    set Densities = 3330, 3300
+    set Thermal expansivities = 2e-5
+    set Viscosity averaging scheme = harmonic
+    set Grain size = 1e-3
+    set Prefactors for diffusion creep = 1.5e-15
+    set Stress exponents for diffusion creep = 1
+    set Grain size exponents for diffusion creep = 3
+    set Activation energies for diffusion creep = 3.75e5
+    set Activation volumes for diffusion creep = 6e-6
+    set Prefactors for dislocation creep = 1.1e-16
+    set Stress exponents for dislocation creep = 3.5
+    set Activation energies for dislocation creep = 5.3e5
+    set Activation volumes for dislocation creep = 1.4e-5
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                 = 3
+  set Initial adaptive refinement               = 0
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 0
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/diffusion_velocity.prm.bak b/tests/diffusion_velocity.prm.bak
new file mode 100644
index 00000000000..9cb86c2f963
--- /dev/null
+++ b/tests/diffusion_velocity.prm.bak
@@ -0,0 +1,303 @@
+# A test by Juliane Dannberg
+#
+# This test verifies whether physical diffusion works as expected.
+# It sets up a half-space heated from above and cooled from below
+# for which we know that (if infinite) the temperature should behave
+# as a time dependent function like
+#   T(z,t) = (T_halfspace - T_0) * erf(z / (2*sqrt(kappa * t))) + T_0
+# where
+#   T_0 = surface temperature (here =1)
+#   T_halfspace = temperature at infinity (here =0)
+#   kappa = thermal diffusivity (= k / (rho * c_p))
+#   z = distance to surface
+#   t = time
+#
+# The results produced by this test have been verified to be correct.
+
+##################################################################
+
+
+
+# Listing of Parameters
+# ---------------------
+
+# At the top, state that the program should be run for a two-dimensional
+# simulation
+set Dimension = 2
+
+# In computations, the time step $k$ is chosen according to $k = c \min_K
+# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
+# and the denominator is the maximal magnitude of the velocity on cell $K$
+# times the polynomial degree $p_T$ of the temperature discretization. The
+# dimensionless constant $c$ is called the CFL number in this program. For
+# time discretizations that have explicit components, $c$ must be less than a
+# constant that depends on the details of the time discretization and that is
+# no larger than one. On the other hand, for implicit discretizations such as
+# the one chosen here, one can choose the time step as large as one wants (in
+# particular, one can choose $c>1$) though a CFL number significantly larger
+# than one will yield rather diffusive solutions. Units: None.
+set CFL number                             = 0.01
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 2e7
+
+# The name of the directory into which all output files should be placed. This
+# may be an absolute or a relative path.
+
+# A flag indicating whether the computation should be resumed from a
+# previously saved state (if true) or start from scratch (if false).
+set Resume computation                     = false
+
+# The start time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set Start time                             = 0
+
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Adiabatic surface temperature          = 0
+
+# The mathematical equations that describe thermal convection only determine
+# the pressure up to an arbitrary constant. On the other hand, for comparison
+# and for looking up material parameters it is important that the pressure be
+# normalized somehow. We do this by enforcing a particular average pressure
+# value at the surface of the domain, where the geometry model determines
+# where the surface is. This parameter describes what this average surface
+# pressure value is supposed to be. By default, it is set to zero, but one may
+# want to choose a different value for example for simulating only the volume
+# of the mantle below the lithosphere, in which case the surface pressure
+# should be the lithostatic pressure at the bottom of the lithosphere.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Surface pressure                       = 0
+
+# When computing results for mantle convection simulations, it is often
+# difficult to judge the order of magnitude of results when they are stated in
+# MKS units involving seconds. Rather, some kinds of results such as
+# velocities are often stated in terms of meters per year (or, sometimes,
+# centimeters per year). On the other hand, for non-dimensional computations,
+# one wants results in their natural unit system as used inside the code. If
+# this flag is set to 'true' conversion to years happens; if it is 'false', no
+# such conversion happens.
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set List of model names = box
+
+  # A comma separated list of integers denoting those boundaries on which the
+  # temperature is fixed and described by the boundary temperature object
+  # selected in its own section of this input file. All boundary indicators
+  # used by the geometry but not explicitly listed here will end up with
+  # no-flux (insulating) boundary conditions.
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Bottom temperature = 0
+    set Top temperature    = 1
+  end
+end
+
+subsection Discretization
+  # The polynomial degree to use for the velocity variables in the Stokes
+  # system. Units: None.
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+
+  # Whether to use a Stokes discretization that is locally conservative at the
+  # expense of a larger number of degrees of freedom (true), or to go with a
+  # cheaper discretization that does not locally conserve mass, although it is
+  # globally conservative (false).
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    # Extent of the box in x-direction. Units: \\si{\\meter}.
+    set X extent = 1
+
+    # Extent of the box in y-direction. Units: \\si{\\meter}.
+    set Y extent = 1
+
+    # Extent of the box in z-direction. This value is ignored if the
+    # simulation is in 2d Units: \\si{\\meter}.
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
+    set Reference density             = 1
+
+    # The value of the specific heat $cp$. Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.
+    set Reference specific heat       = 1250
+
+    # The reference temperature $T_0$. Units: \\si{\\kelvin}.
+    set Reference temperature         = 0
+
+    # The value of the thermal conductivity $k$. Units: \\si{\\watt\\per\\meter\\per\\kelvin}.
+    set Thermal conductivity          = 1e-6
+
+    # The value of the thermal expansion coefficient $\beta$. Units: \\si{\\per\\kelvin}.
+    set Thermal expansion coefficient = 2e-5
+
+    # The value of the constant viscosity. Units: \\si{\\pascal\\second}.
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  # A list of times so that if the end time of a time step is beyond this
+  # time, an additional round of mesh refinement is triggered. This is mostly
+  # useful to make sure we can get through the initial transient phase of a
+  # simulation on a relatively coarse mesh, and then refine again when we are
+  # in a time range that we are interested in and where we would like to use a
+  # finer mesh. Units: each element of the list has units years if the 'Use
+  # years in output instead of seconds' parameter is set; seconds otherwise.
+  set Additional refinement times        =
+
+  # The number of adaptive refinement steps performed after initial global
+  # refinement but while still within the first time step.
+  set Initial adaptive refinement        = 0
+
+  # The number of global refinement steps performed on the initial coarse
+  # mesh, before the problem is first solved there.
+  set Initial global refinement          = 5
+
+  # The fraction of cells with the largest error that should be flagged for
+  # refinement.
+  set Refinement fraction                = 0.3
+
+  # The fraction of cells with the smallest error that should be flagged for
+  # coarsening.
+  set Coarsening fraction                = 0.05
+
+  # The method used to determine which cells to refine and which to coarsen.
+  set Strategy                           = thermal energy density
+
+  # The number of time steps after which the mesh is to be adapted again based
+  # on computed error indicators.
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  # A comma separated list of integers denoting those boundaries on which the
+  # velocity is tangential and unrestrained, i.e., where no external forces
+  # act to prescribe a particular tangential velocity (although there is a
+  # force that requires the flow to be tangential).
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Checkpointing
+  # The wall time between performing checkpoints. If 0, will use the
+  # checkpoint step frequency instead.
+  set Time between checkpoint                = 0
+
+  # The number of timesteps between performing checkpoints. If 0 and time
+  # between checkpoint is not specified, checkpointing will not be performed.
+  set Steps between checkpoint               = 50
+end
+
+subsection Postprocess
+  # A comma separated list of postprocessor objects that should be run at the
+  # end of each time step. Some of these postprocessors will declare their own
+  # parameters which may, for example, include that they will actually do
+  # something only every so many time steps or years. Alternatively, the text
+  # 'all' indicates that all available postprocessors should be run after each
+  # time step.
+  #
+  # The following postprocessors are available:
+  #
+  # `depth average': A postprocessor that computes depth averaged quantities
+  # and writes them out.
+  #
+  # `heat flux statistics': A postprocessor that computes some statistics
+  # about the heat flux across boundaries.
+  #
+  # `heat flux statistics for the table model': A postprocessor that computes
+  # some statistics about the heat flux across boundaries.
+  #
+  # `velocity statistics for the table model': A postprocessor that computes
+  # some statistics about the velocity field.
+  #
+  # `temperature statistics': A postprocessor that computes some statistics
+  # about the temperature field.
+  #
+  # `velocity statistics': A postprocessor that computes some statistics about
+  # the velocity field.
+  #
+  # `visualization': A postprocessor that takes the solution and writes it
+  # into files that can be read by a graphical visualization program.
+  # Additional run time parameters are read from the parameter subsection
+  # 'Visualization'.
+  set List of postprocessors = temperature statistics, heat flux statistics, velocity statistics, basic statistics
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 1
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+    set List of output variables      = density,viscosity
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/direct_solver_1.prm.bak b/tests/direct_solver_1.prm.bak
new file mode 100644
index 00000000000..44ff9d82aff
--- /dev/null
+++ b/tests/direct_solver_1.prm.bak
@@ -0,0 +1,152 @@
+############### Global parameters
+# We use a 2d setup. Since it takes some time for
+# the model to reach a steady state we set the
+# end time to approximately 15 billion years.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 6e15
+set Use years in output instead of seconds = false
+set Output directory                       = output
+set Pressure normalization                 = surface
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = 3
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;-2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    # The change of density across the phase transition. Together with the
+    # Clapeyron slope, this is what determines the entropy change.
+    set Phase transition density jumps                 = 115.6
+    set Corresponding phase for density jump           = 0
+
+    # If the temperature is equal to the phase transition temperature, the
+    # phase transition will occur at the phase transition depth. However,
+    # if the temperature deviates from this value, the Clapeyron slope
+    # determines how much the pressure (and depth) of the phase boundary
+    # changes. Here, the phase transition will be in the middle of the box
+    # for T=T1.
+    set Phase transition depths                        = 500000
+    set Phase transition temperatures                  = 1000
+    set Phase transition Clapeyron slopes              = 1e7
+
+    # We set the width of the phase transition to 5 km. You may want to
+    # change this parameter to see how latent heating depends on the width
+    # of the phase transition.
+    set Phase transition widths                        = 5000
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 2.38
+
+    # We set the thermal expansion and the compressibility to zero, so that
+    # all temperature (and density) changes are caused by advection, diffusion
+    # and latent heating.
+    set Thermal expansion coefficient                  = 0.0
+    set Compressibility                                = 0.0
+
+    # Viscosity is constant.
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 8.44e21
+    set Viscosity prefactors                           = 1.0, 1.0
+    set Composition viscosity prefactor                = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 0
+    set List of output variables      = density
+  end
+end
+
+subsection Heating model
+  set List of model names =  latent heat
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/direct_solver_2.prm.bak b/tests/direct_solver_2.prm.bak
new file mode 100644
index 00000000000..f93040c970b
--- /dev/null
+++ b/tests/direct_solver_2.prm.bak
@@ -0,0 +1,150 @@
+# test that the direct solver works in parallel
+# MPI: 3
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 6e15
+set Use years in output instead of seconds = false
+set Output directory                       = output
+set Pressure normalization                 = surface
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = 3
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;-2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    # The change of density across the phase transition. Together with the
+    # Clapeyron slope, this is what determines the entropy change.
+    set Phase transition density jumps                 = 115.6
+    set Corresponding phase for density jump           = 0
+
+    # If the temperature is equal to the phase transition temperature, the
+    # phase transition will occur at the phase transition depth. However,
+    # if the temperature deviates from this value, the Clapeyron slope
+    # determines how much the pressure (and depth) of the phase boundary
+    # changes. Here, the phase transition will be in the middle of the box
+    # for T=T1.
+    set Phase transition depths                        = 500000
+    set Phase transition temperatures                  = 1000
+    set Phase transition Clapeyron slopes              = 1e7
+
+    # We set the width of the phase transition to 5 km. You may want to
+    # change this parameter to see how latent heating depends on the width
+    # of the phase transition.
+    set Phase transition widths                        = 5000
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 2.38
+
+    # We set the thermal expansion and the compressibility to zero, so that
+    # all temperature (and density) changes are caused by advection, diffusion
+    # and latent heating.
+    set Thermal expansion coefficient                  = 0.0
+    set Compressibility                                = 0.0
+
+    # Viscosity is constant.
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 8.44e21
+    set Viscosity prefactors                           = 1.0, 1.0
+    set Composition viscosity prefactor                = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+
+    # We are only interested in the last timestep (when the system hast reached
+    # a steady state). For following the development of the system or checking
+    # if the solution already reached steady state, this parameter can be set
+    # to a smaller value.
+    set Time between graphical output = 0
+    set List of output variables      = density
+  end
+end
+
+subsection Heating model
+  set List of model names =  latent heat
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/discontinuous_composition_1.prm.bak b/tests/discontinuous_composition_1.prm.bak
new file mode 100644
index 00000000000..c74771ce989
--- /dev/null
+++ b/tests/discontinuous_composition_1.prm.bak
@@ -0,0 +1,95 @@
+# A test to check discontinuous composition discretization.
+# Based on composition-passive.prm
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 2
+end
+
+subsection Discretization
+  set Use discontinuous temperature discretization = false
+  set Use discontinuous composition discretization = true
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, composition statistics
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter.prm b/tests/discontinuous_composition_bound_preserving_limiter.prm
index 916efe1e4a8..22c01ef8073 100644
--- a/tests/discontinuous_composition_bound_preserving_limiter.prm
+++ b/tests/discontinuous_composition_bound_preserving_limiter.prm
@@ -93,7 +93,6 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
     set Global composition maximum = 1.0, 2.0
     set Global composition minimum = 0.0, 0.0
   end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter.prm.bak b/tests/discontinuous_composition_bound_preserving_limiter.prm.bak
new file mode 100644
index 00000000000..916efe1e4a8
--- /dev/null
+++ b/tests/discontinuous_composition_bound_preserving_limiter.prm.bak
@@ -0,0 +1,100 @@
+# this test is specifically designed for the bound-preserving limiter
+# A description of the falling box benchmark see the reference:
+# Gerya, T. V., Yuen, D. A., 2003a. Characteristics-based marker-in-cell method
+# with conservative finite-differences schemes for modeling geological flows with
+# strongly variable transport properties
+# This test uses two falling boxes in order to use two different compositional fields
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1e6
+set Use years in output instead of seconds = true
+set CFL number                             = .5
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500e3
+    set Y extent  = 500e3
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# Thermal expansion coeff = 0 --> no temperature dependence
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3200
+    set Viscosity                     = 1e21
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = 100  # 3300 kg/m^3
+    set Composition viscosity prefactor = 1  # ONLY PARAMETER THAT CHANGES IN THESE TESTS
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(((x>187.5e3)&&(x<375e3)&&(z>312.5e3)&&(z<375e3)), 1, 0);if((x>125e3)&&(x<312.5e3)&&((z>312.5e3)&&(z<437.5e3)), 2, 0);
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 1
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
+    set Global composition maximum = 1.0, 2.0
+    set Global composition minimum = 0.0, 0.0
+  end
+end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter_3d.prm b/tests/discontinuous_composition_bound_preserving_limiter_3d.prm
index c381f0011ad..b46a3cc6d74 100644
--- a/tests/discontinuous_composition_bound_preserving_limiter_3d.prm
+++ b/tests/discontinuous_composition_bound_preserving_limiter_3d.prm
@@ -94,7 +94,6 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
     set Global composition maximum = 1.0
     set Global composition minimum = 0.0
   end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter_3d.prm.bak b/tests/discontinuous_composition_bound_preserving_limiter_3d.prm.bak
new file mode 100644
index 00000000000..c381f0011ad
--- /dev/null
+++ b/tests/discontinuous_composition_bound_preserving_limiter_3d.prm.bak
@@ -0,0 +1,101 @@
+# this test is specifically designed for the bound-preserving limiter
+# A description of the falling box benchmark see the reference:
+# Gerya, T. V., Yuen, D. A., 2003a. Characteristics-based marker-in-cell method
+# with conservative finite-differences schemes for modeling geological flows with
+# strongly variable transport properties
+# This test uses two falling boxes in order to use two different compositional fields
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 5e5
+set Use years in output instead of seconds = true
+set CFL number                             = .5
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500e3
+    set Y extent  = 500e3
+    set Z extent  = 500e3
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
+end
+
+# Thermal expansion coeff = 0 --> no temperature dependence
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3200
+    set Viscosity                     = 1e21
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = 100  # 3300 kg/m^3
+    set Composition viscosity prefactor = 1  # ONLY PARAMETER THAT CHANGES IN THESE TESTS
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = if(((x>125e3)&&(x<375e3)&&(y>125e3)&&(y<375e3)&&(z>125e3)&&(z<375e3)), 1, 0)
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 2
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
+    set Global composition maximum = 1.0
+    set Global composition minimum = 0.0
+  end
+end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm b/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm
index 5377bc15ed8..9c09a91d4d6 100644
--- a/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm
+++ b/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm
@@ -80,8 +80,6 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    # apply the limiter to the DG solution of field 1, but not field 2
-    set Use limiter for discontinuous composition solution = true, false
     set Global composition maximum = 1.0, 1.0
     set Global composition minimum = 0.0, 0.0
   end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm.bak b/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm.bak
new file mode 100644
index 00000000000..5377bc15ed8
--- /dev/null
+++ b/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm.bak
@@ -0,0 +1,88 @@
+# This test uses the bound-preserving limiter, but only for
+# one of the two existing fields. Because both fields are
+# set up identically, any difference in the output of the
+# two fields stems from the limiter algorithm.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 25000
+set Use years in output instead of seconds = true
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500e3
+    set Y extent  = 500e3
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3200
+    set Viscosity                     = 1e21
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = 100
+    set Composition viscosity prefactor = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x<251e3 ? 0 : 1; x<251e3 ? 0 : 1;
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 0
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    # apply the limiter to the DG solution of field 1, but not field 2
+    set Use limiter for discontinuous composition solution = true, false
+    set Global composition maximum = 1.0, 1.0
+    set Global composition minimum = 0.0, 0.0
+  end
+end
diff --git a/tests/discontinuous_composition_serial_periodic_amr.prm.bak b/tests/discontinuous_composition_serial_periodic_amr.prm.bak
new file mode 100644
index 00000000000..c52a3983fb3
--- /dev/null
+++ b/tests/discontinuous_composition_serial_periodic_amr.prm.bak
@@ -0,0 +1,80 @@
+# Test serial AMR with discontinuous composition elements
+# (in particular flux terms at periodic boundary faces where
+# neighbors are of different level).
+# This test in parallel currently fails (crashes), but we can
+# not test that, because expected test failures are only supported
+# in serial tests.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 4
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory = periodic_test
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Mesh refinement
+  set Minimum refinement level           = 2
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 1
+  set Strategy = composition gradient
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Y periodic = true
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
+    set Function expression = xv;yv
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function expression = if (y<0.65, if(y>0.35, 1.0, 0.0), 0.0)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.0
+  end
+end
diff --git a/tests/discontinuous_temperature.prm.bak b/tests/discontinuous_temperature.prm.bak
new file mode 100644
index 00000000000..c6abb8b6c91
--- /dev/null
+++ b/tests/discontinuous_temperature.prm.bak
@@ -0,0 +1,95 @@
+# A test to check discontinuous temperature discretization.
+# Based on composition-passive.prm
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 2
+end
+
+subsection Discretization
+  set Use discontinuous temperature discretization = true
+  set Use discontinuous composition discretization = false
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, composition statistics
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/tests/discontinuous_temperature_blankenbach.cc.bak b/tests/discontinuous_temperature_blankenbach.cc.bak
new file mode 100644
index 00000000000..b18d72104d5
--- /dev/null
+++ b/tests/discontinuous_temperature_blankenbach.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/blankenbach/plugin/code.cc"
diff --git a/tests/discontinuous_temperature_blankenbach.prm.bak b/tests/discontinuous_temperature_blankenbach.prm.bak
new file mode 100644
index 00000000000..dd6316264d5
--- /dev/null
+++ b/tests/discontinuous_temperature_blankenbach.prm.bak
@@ -0,0 +1,119 @@
+# This is case 1c from the Blankenbach Benchmark (Blankenbach 1989), but
+# computed with discontinuous temperature elements. There used to be a bug
+# in the computation of the face terms when combining DG elements with
+# Boussinesq approximation temperature equations. This test crashed due to
+# oscillations before the fix, but now gives accurate results.
+
+set End time                               = 0.002 # 1.0 for full benchmark
+set Use years in output instead of seconds = false
+set CFL number = 5.0
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0; 0; 1
+    set Variable names      = depth
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = ascii data
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/benchmarks/blankenbach/
+    set Data file name = initial_temperature_case1c.txt
+  end
+end
+
+subsection Material model
+  set Model name = nondimensional
+
+  subsection Nondimensional model
+    set Di                      = 0.0
+    set Ra                      = 1e6
+
+    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
+    set Reference density       = 1
+
+    # The value of the specific heat $cp$. Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.
+    set Reference specific heat = 1
+
+    # Whether to use the TALA instead of the ALA approximation.
+    set Use TALA                = false
+    set Viscosity temperature prefactor = 0.0
+    set Viscosity depth prefactor = 0.0
+    set gamma                   = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement= 3
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 1.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Formulation
+  set Formulation          = custom # with this selection equivalent to BA
+  set Mass conservation    = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
+end
+
+subsection Termination criteria
+  set Termination criteria      = steady state velocity
+
+  subsection Steady state velocity
+    set Maximum relative deviation = 1e-5
+    set Time in steady state       = 0.1
+  end
+end
+
+subsection Discretization
+  set Use discontinuous temperature discretization = true
+end
diff --git a/tests/discontinuous_temperature_spherical_shell_3d.prm.bak b/tests/discontinuous_temperature_spherical_shell_3d.prm.bak
new file mode 100644
index 00000000000..1e71a837f16
--- /dev/null
+++ b/tests/discontinuous_temperature_spherical_shell_3d.prm.bak
@@ -0,0 +1,94 @@
+# This is to ensure that face->measure() is not being
+# called in the dG method - that breaks in 3d, in the
+# case of non-planar faces.
+
+# Define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 3
+
+# Specify the time you want to let the model run for in
+# years and the output directory. Here we only calculate
+# the instantaneous solution.
+set End time                               = 0
+
+# Here we specify the geometry of the domain, which is
+# a spherical shell with inner radius of 3481km and
+# outer radius of 6371km
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6371000
+  end
+end
+
+# This section specifies the temperature at the boundary of
+# the domain. Here we set the temperature to be constant.
+# Alternatively it could be set to the initial condition.
+# We assume fixed temperatures and free slip at the inner and outer boundary
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 1600
+    set Outer temperature = 1600
+  end
+end
+
+# This section describes the gravity field, which is pointing
+# towards the Earth's center with the same magnitude of 10 m/s^2
+# everywhere
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+# This section prescribes the initial condition in the temperature
+# field, which is chosen as a scaled version of the S20RTS shear
+# wave velocity model (Ritsema et al., 2000). S20RTS is defined
+# by spherical harmonics up to degree 20 that are radially interpolated
+# with a cubic spline.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+# The material model is based on the simple material model, which assumes
+# a constant density, and other parameters as stated below.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                 = 3300
+    set Viscosity                         = 1e21
+    set Thermal expansion coefficient     = 3e-5
+    set Reference temperature             = 1600
+    set Thermal conductivity              = 4.125
+    set Reference specific heat           = 1250
+  end
+end
+
+# For this calculation we only do 2 global refinement steps. This resolution
+# is too low to fully resolve the mantle flow, however it does capture
+# the main features.
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+end
+
+subsection Discretization
+  set Use discontinuous temperature discretization = true
+end
diff --git a/tests/doneahuerta_3.cc.bak b/tests/doneahuerta_3.cc.bak
new file mode 100644
index 00000000000..e1dbd9428a3
--- /dev/null
+++ b/tests/doneahuerta_3.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/doneahuerta/doneahuerta.cc"
diff --git a/tests/doneahuerta_3.prm.bak b/tests/doneahuerta_3.prm.bak
new file mode 100644
index 00000000000..3dc8099cdfc
--- /dev/null
+++ b/tests/doneahuerta_3.prm.bak
@@ -0,0 +1,88 @@
+############### Global parameters
+# This is the manufactured solution of Donea & Huerta,
+# Finite element methods for flow problems,
+# Wiley, 2003. page 306
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0  : DoneaHuertaBoundary, \
+                                                1  : DoneaHuertaBoundary, \
+                                                2  : DoneaHuertaBoundary, \
+                                                3  : DoneaHuertaBoundary
+end
+
+subsection Material model
+  set Model name = DoneaHuertaMaterial
+end
+
+subsection Gravity model
+  set Model name = DoneaHuertaGravity
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, DoneaHuertaPostprocessor
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density, viscosity, strain rate, gravity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/drucker_prager_compression.prm.bak b/tests/drucker_prager_compression.prm.bak
new file mode 100644
index 00000000000..6bde6270eb8
--- /dev/null
+++ b/tests/drucker_prager_compression.prm.bak
@@ -0,0 +1,124 @@
+############### Global parameters
+# This model is based on the paper
+# Kaus, B. (2010), Tectonophysics 484, 36-47.
+# We iterate out the Stokes equation.
+# We use only the expensive Stokes solver.
+# 1 Timestep experiment.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver tolerance             = 1e-5
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 10 # to localize deformation, more iterations are needed
+
+############### Parameters describing the model
+# We consider a 2D box of 40x10 km of which the elements are of unit aspect ratio.
+# Temperature plays no role in this model.
+# We prescribe a horizontal velocity (compression) on the vertical
+# boundaries, but leave the vertical component free.
+# To the bottom boundary we prescribe the same horizontal velocity,
+# the vertical velocity component is set to zero. The top boundary is open.
+# We use a Drucker Prager failure criterion.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 40000
+    set Y extent  = 10000
+    set X repetitions = 4
+  end
+end
+
+############### We prescribe a velocity of W/2 * background strain rate invariant
+# where W is the width of the domain and the background strain rate 1e-15 1/s.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0 x:function,1 x:function, 2: function
+
+  subsection Function
+    set Function expression     =  if(x>=2e4,-2.e-11,2.e-11);0
+  end
+end
+
+subsection Material model
+  set Model name = drucker prager
+
+  subsection Drucker Prager
+    set Thermal conductivity          = 0.0
+    set Reference density             = 2700.0
+    set Reference temperature         = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Reference specific heat       = 1
+
+    subsection Viscosity
+      set Minimum viscosity           = 1e19
+      set Maximum viscosity           = 1e26
+      set Cohesion                    = 4e7
+      set Angle of internal friction  = 15
+      set Reference strain rate       = 1e-15
+    end
+  end
+end
+
+############## rho * g = 27000
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# We set the temperature to zero, as it is not important.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 1
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+# We select to compute some statistics about the
+# velocity field and the mass flux through the boundaries.
+# We prescribe an inflow of 2e-11 m/s on both vertical boundaries
+# which should be the value of the maximum velocity. The VRMS will
+# be a little lower, because the inflow will be balanced by an outflow
+# through the top boundary over a greater boundary length.
+# For the given density and inflow velocity, a boundary
+# mass flux of v * L * rho = 2e-11 * 10000 * 2700 = 5.4e-4 kg/s
+# is expected for each vertical boundary,
+# compensated by a influx of 1.08e-3 kg/s through the top.
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/drucker_prager_derivatives_2d.cc.bak b/tests/drucker_prager_derivatives_2d.cc.bak
new file mode 100644
index 00000000000..d6d713fb9fb
--- /dev/null
+++ b/tests/drucker_prager_derivatives_2d.cc.bak
@@ -0,0 +1,247 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/drucker_prager.h>
+#include <aspect/simulator_access.h>
+#include <aspect/newton.h>
+#include <aspect/utilities.h>
+#include <aspect/parameters.h>
+
+#include <deal.II/base/exceptions.h>
+#include <memory>
+#include <functional>
+
+#include <iostream>
+
+template <int dim>
+void f(const aspect::SimulatorAccess<dim> &simulator_access,
+       aspect::Assemblers::Manager<dim> &)
+{
+
+  std::cout << std::endl << "Testing DruckerPrager derivatives against finite difference derivatives " << std::endl;
+
+  using namespace aspect::MaterialModel;
+
+  // first set all material model values
+  MaterialModelInputs<dim> in_base(5,3);
+  in_base.composition[0][0] = 0;
+  in_base.composition[0][1] = 0;
+  in_base.composition[0][2] = 0;
+  in_base.composition[1][0] = 0.75;
+  in_base.composition[1][1] = 0.15;
+  in_base.composition[1][2] = 0.10;
+  in_base.composition[2][0] = 0;
+  in_base.composition[2][1] = 0.2;
+  in_base.composition[2][2] = 0.4;
+  in_base.composition[3][0] = 0;
+  in_base.composition[3][1] = 0.2;
+  in_base.composition[3][2] = 0.4;
+  in_base.composition[4][0] = 1;
+  in_base.composition[4][1] = 0;
+  in_base.composition[4][2] = 0;
+
+  in_base.temperature[0] = 293;
+  in_base.temperature[1] = 1600;
+  in_base.temperature[2] = 2000;
+  in_base.temperature[3] = 2100;
+  in_base.temperature[4] = 2200;
+
+  in_base.pressure[0] = 1e9;
+  in_base.pressure[1] = 5e9;
+  in_base.pressure[2] = 2e10;
+  in_base.pressure[3] = 2e11;
+  in_base.pressure[4] = 2e12;
+
+  /**
+   * We can't take to small strain-rates, because then the difference in the
+   * visocisty will be too small for the double accuracy which stores
+   * the visocity solutions and the finite difference solution.
+   */
+  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
+  in_base.strain_rate[0][0][0] = 1e-12;
+  in_base.strain_rate[0][0][1] = 1e-12;
+  in_base.strain_rate[0][1][1] = 1e-11;
+
+  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[1][0][0] = -1.71266e-13;
+  in_base.strain_rate[1][0][1] = -5.82647e-12;
+  in_base.strain_rate[1][1][1] = 4.21668e-14;
+
+  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[2][1][1] = 1e-13;
+  in_base.strain_rate[2][0][1] = 1e-11;
+  in_base.strain_rate[2][0][0] = -1e-12;
+
+  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[3][1][1] = 4.9e-21;
+  in_base.strain_rate[3][0][1] = 4.9e-21;
+  in_base.strain_rate[3][0][0] = 4.9e-21;
+
+  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[4][1][1] = 1e-11;
+  in_base.strain_rate[4][0][1] = 1e-11;
+  in_base.strain_rate[4][0][0] = 1e-11;
+
+  // initialize some variables we will need later.
+  const double finite_difference_accuracy = 1e-7;
+  const double finite_difference_factor = 1+finite_difference_accuracy;
+
+  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
+
+  MaterialModelOutputs<dim> out_base(5,3);
+  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
+  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
+
+  // initialize the material we want to test.
+  aspect::ParameterHandler prm;
+
+  const aspect::MaterialModel::DruckerPrager<dim> const_material_model = dynamic_cast<const aspect::MaterialModel::DruckerPrager<dim> &>(simulator_access.get_material_model());
+  aspect::MaterialModel::DruckerPrager<dim> material_model = const_cast<aspect::MaterialModel::DruckerPrager<dim> &>(const_material_model);
+
+  material_model.declare_parameters(prm);
+
+  prm.enter_subsection("Material model");
+  {
+    prm.enter_subsection ("Drucker Prager");
+    {
+      prm.enter_subsection ("Viscosity");
+      {
+        prm.set ("Reference strain rate", "1e-20");
+        prm.set ("Angle of internal friction", "30");
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection();
+  }
+  prm.leave_subsection();
+
+  const_cast<aspect::MaterialModel::Interface<dim> &>(simulator_access.get_material_model()).parse_parameters(prm);
+
+  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
+
+  simulator_access.get_material_model().evaluate(in_base, out_base);
+
+  // set up additional output for the derivatives
+  MaterialModelDerivatives<dim> *derivatives;
+  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
+  double temp;
+
+  // have a bool so we know whether the test has succeed or not.
+  bool Error = false;
+
+  // test the pressure derivative.
+  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
+  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
+
+  simulator_access.get_material_model().evaluate(in_dviscositydpressure, out_dviscositydpressure);
+
+  for (unsigned int i = 0; i < 5; i++)
+    {
+      // prevent division by zero. If it is zero, the test has passed, because or
+      // the finite difference and the analytical result match perfectly, or (more
+      // likely) the material model in independent of this variable.
+      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
+      if (in_base.pressure[i] != 0)
+        {
+          temp /= (in_base.pressure[i] * finite_difference_accuracy);
+        }
+      std::cout << "pressure: point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i]  << std::endl;
+      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
+        {
+          std::cout << "   Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
+          Error = true;
+        }
+
+    }
+
+  // test the strain-rate derivative.
+  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
+    {
+      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
+                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
+                                                    * finite_difference_accuracy
+                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
+        }
+
+
+      simulator_access.get_material_model().evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          // prevent division by zero. If it is zero, the test has passed, because or
+          // the finite difference and the analytical result match perfectly, or (more
+          // likely) the material model in independent of this variable.
+          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
+          if (temp != 0)
+            {
+              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
+            }
+          std::cout << "strain-rate: point = " << i << ", component = " << component << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
+          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
+            {
+              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
+              Error = true;
+            }
+
+        }
+
+    }
+
+  if (Error)
+    {
+      std::cout << "Some parts of the test were not successful." << std::endl;
+    }
+  else
+    {
+      std::cout << "OK" << std::endl;
+    }
+
+}
+
+template <>
+void f(const aspect::SimulatorAccess<3> &,
+       aspect::Assemblers::Manager<3> &)
+{
+  AssertThrow(false,dealii::ExcInternalError());
+}
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  using namespace dealii;
+  std::cout << "* Connecting signals" << std::endl;
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2));
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/drucker_prager_derivatives_2d.prm.bak b/tests/drucker_prager_derivatives_2d.prm.bak
new file mode 100644
index 00000000000..eecb827ba81
--- /dev/null
+++ b/tests/drucker_prager_derivatives_2d.prm.bak
@@ -0,0 +1,108 @@
+# This test checks whether the derivatives of the drucker prager
+# material model are the same as the finite difference derivatives
+# created by the drucker prager material model. Significantly, the
+# temperature, composition, pressure and strain rate values
+# evaluated by the material are all specified within
+# drucker_prager_derivatives_2d.cc and the model parameters defined
+# below are not used in the test.
+set Additional shared libraries = tests/libdrucker_prager_derivatives_2d.so
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 0
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = drucker prager
+
+  subsection Drucker Prager
+    subsection Viscosity
+      set Reference strain rate = 1e-20
+      set Angle of internal friction = 30.
+    end
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/drucker_prager_derivatives_3d.cc.bak b/tests/drucker_prager_derivatives_3d.cc.bak
new file mode 100644
index 00000000000..33aabf18543
--- /dev/null
+++ b/tests/drucker_prager_derivatives_3d.cc.bak
@@ -0,0 +1,262 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/drucker_prager.h>
+#include <aspect/simulator_access.h>
+#include <aspect/newton.h>
+#include <aspect/utilities.h>
+#include <aspect/parameters.h>
+
+#include <deal.II/base/exceptions.h>
+#include <memory>
+#include <functional>
+
+#include <iostream>
+
+template <int dim>
+void f(const aspect::SimulatorAccess<dim> &simulator_access,
+       aspect::Assemblers::Manager<dim> &)
+{
+
+  std::cout << std::endl << "Testing DruckerPrager derivatives against finite difference derivatives " << std::endl;
+
+  using namespace aspect::MaterialModel;
+
+  // first set all material model values
+  MaterialModelInputs<dim> in_base(5,3);
+  in_base.composition[0][0] = 0;
+  in_base.composition[0][1] = 0;
+  in_base.composition[0][2] = 0;
+  in_base.composition[1][0] = 0.75;
+  in_base.composition[1][1] = 0.15;
+  in_base.composition[1][2] = 0.10;
+  in_base.composition[2][0] = 0;
+  in_base.composition[2][1] = 0.2;
+  in_base.composition[2][2] = 0.4;
+  in_base.composition[3][0] = 0;
+  in_base.composition[3][1] = 0.2;
+  in_base.composition[3][2] = 0.4;
+  in_base.composition[4][0] = 1;
+  in_base.composition[4][1] = 0;
+  in_base.composition[4][2] = 0;
+
+  in_base.temperature[0] = 293;
+  in_base.temperature[1] = 1600;
+  in_base.temperature[2] = 2000;
+  in_base.temperature[3] = 2100;
+  in_base.temperature[4] = 2200;
+
+  in_base.pressure[0] = 1e9;
+  in_base.pressure[1] = 5e9;
+  in_base.pressure[2] = 2e10;
+  in_base.pressure[3] = 2e11;
+  in_base.pressure[4] = 2e12;
+
+  /**
+   * We can't take to small strain-rates, because then the difference in the
+   * visocisty will be too small for the double accuracy which stores
+   * the visocity solutions and the finite difference solution.
+   */
+  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
+  in_base.strain_rate[0][0][0] = 1e-12;
+  in_base.strain_rate[0][0][1] = 1e-12;
+  in_base.strain_rate[0][1][1] = 1e-11;
+  in_base.strain_rate[0][2][0] = 1e-12;
+  in_base.strain_rate[0][2][1] = 1e-12;
+  in_base.strain_rate[0][2][2] = 1e-11;
+
+  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[1][0][0] = -1.71266e-13;
+  in_base.strain_rate[1][0][1] = -5.82647e-12;
+  in_base.strain_rate[1][1][1] = 4.21668e-14;
+  in_base.strain_rate[1][2][0] = -5.42647e-12;
+  in_base.strain_rate[1][2][1] = -5.22647e-12;
+  in_base.strain_rate[1][2][2] = 4.21668e-14;
+
+  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[2][1][1] = 1e-13;
+  in_base.strain_rate[2][0][1] = 1e-11;
+  in_base.strain_rate[2][0][0] = -1e-12;
+  in_base.strain_rate[2][2][0] = 1e-11;
+  in_base.strain_rate[2][2][1] = 1e-11;
+  in_base.strain_rate[2][2][2] = -1e-12;
+
+  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[3][1][1] = 4.9e-21;
+  in_base.strain_rate[3][0][1] = 4.9e-21;
+  in_base.strain_rate[3][0][0] = 4.9e-21;
+  in_base.strain_rate[3][2][0] = 4.9e-21;
+  in_base.strain_rate[3][2][1] = 4.9e-21;
+  in_base.strain_rate[3][2][2] = 4.9e-21;
+
+  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[4][1][1] = 1e-11;
+  in_base.strain_rate[4][0][1] = 1e-11;
+  in_base.strain_rate[4][0][0] = 1e-11;
+  in_base.strain_rate[4][2][0] = 1e-11;
+  in_base.strain_rate[4][2][1] = 1e-11;
+  in_base.strain_rate[4][2][2] = 1e-11;
+
+  // initialize some variables we will need later.
+  const double finite_difference_accuracy = 1e-7;
+  const double finite_difference_factor = 1+finite_difference_accuracy;
+
+  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
+
+  MaterialModelOutputs<dim> out_base(5,3);
+  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
+  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
+
+  // initialize the material we want to test.
+  aspect::ParameterHandler prm;
+
+  const aspect::MaterialModel::DruckerPrager<dim> const_material_model = dynamic_cast<const aspect::MaterialModel::DruckerPrager<dim> &>(simulator_access.get_material_model());
+  aspect::MaterialModel::DruckerPrager<dim> material_model = const_cast<aspect::MaterialModel::DruckerPrager<dim> &>(const_material_model);
+
+  material_model.declare_parameters(prm);
+
+  prm.enter_subsection("Material model");
+  {
+    prm.enter_subsection ("Drucker Prager");
+    {
+      prm.enter_subsection ("Viscosity");
+      {
+        prm.set ("Reference strain rate", "1e-20");
+        prm.set ("Angle of internal friction", "30");
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection();
+  }
+  prm.leave_subsection();
+
+  const_cast<aspect::MaterialModel::Interface<dim> &>(simulator_access.get_material_model()).parse_parameters(prm);
+
+  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
+
+  simulator_access.get_material_model().evaluate(in_base, out_base);
+
+  // set up additional output for the derivatives
+  MaterialModelDerivatives<dim> *derivatives;
+  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
+  double temp;
+
+  // have a bool so we know whether the test has succeed or not.
+  bool Error = false;
+
+  // test the pressure derivative.
+  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
+  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
+
+  simulator_access.get_material_model().evaluate(in_dviscositydpressure, out_dviscositydpressure);
+
+  for (unsigned int i = 0; i < 5; i++)
+    {
+      // prevent division by zero. If it is zero, the test has passed, because or
+      // the finite difference and the analytical result match perfectly, or (more
+      // likely) the material model in independent of this variable.
+      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
+      if (in_base.pressure[i] != 0)
+        {
+          temp /= (in_base.pressure[i] * finite_difference_accuracy);
+        }
+      std::cout << "pressure: point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i]  << std::endl;
+      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
+        {
+          std::cout << "   Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
+          Error = true;
+        }
+
+    }
+
+  // test the strain-rate derivative.
+  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
+    {
+      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
+                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
+                                                    * finite_difference_accuracy
+                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
+        }
+
+
+      simulator_access.get_material_model().evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          // prevent division by zero. If it is zero, the test has passed, because or
+          // the finite difference and the analytical result match perfectly, or (more
+          // likely) the material model in independent of this variable.
+          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
+          if (temp != 0)
+            {
+              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
+            }
+          std::cout << "strain-rate: point = " << i << ", component = " << component << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
+          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
+            {
+              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
+              Error = true;
+            }
+
+        }
+
+    }
+
+  if (Error)
+    {
+      std::cout << "Some parts of the test were not successful." << std::endl;
+    }
+  else
+    {
+      std::cout << "OK" << std::endl;
+    }
+
+}
+
+template <>
+void f(const aspect::SimulatorAccess<2> &,
+       aspect::Assemblers::Manager<2> &)
+{
+  AssertThrow(false,dealii::ExcInternalError());
+}
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  using namespace dealii;
+  std::cout << "* Connecting signals" << std::endl;
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2));
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/drucker_prager_derivatives_3d.prm.bak b/tests/drucker_prager_derivatives_3d.prm.bak
new file mode 100644
index 00000000000..65fa5b2d2d2
--- /dev/null
+++ b/tests/drucker_prager_derivatives_3d.prm.bak
@@ -0,0 +1,108 @@
+# This test checks whether the derivatives of the drucker prager
+# material model are the same as the finite difference derivatives
+# created by the drucker prager material model. Significantly, the
+# temperature, composition, pressure and strain rate values
+# evaluated by the material are all specified within
+# drucker_prager_derivatives_3d.cc and the model parameters defined
+# below are not used in the test.
+set Additional shared libraries = tests/libdrucker_prager_derivatives_3d.so
+set Dimension                              = 3
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year); 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 0
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = drucker prager
+
+  subsection Drucker Prager
+    subsection Viscosity
+      set Reference strain rate = 1e-20
+      set Angle of internal friction = 30.
+    end
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/drucker_prager_extension.prm.bak b/tests/drucker_prager_extension.prm.bak
new file mode 100644
index 00000000000..3731bbbfcf0
--- /dev/null
+++ b/tests/drucker_prager_extension.prm.bak
@@ -0,0 +1,124 @@
+############### Global parameters
+# This model is based on the paper
+# Kaus, B. (2010), Tectonophysics 484, 36-47.
+# We iterate out the Stokes equation.
+# We use only the expensive Stokes solver.
+# 1 Timestep experiment.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver tolerance             = 1e-5
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 10 # to localize deformation, more iterations are needed
+
+############### Parameters describing the model
+# We consider a 2D box of 40x10 km of which the elements are of unit aspect ratio.
+# Temperature plays no role in this model.
+# We prescribe a horizontal velocity (extension) on the vertical
+# boundaries, but leave the vertical component free.
+# To the bottom boundary we prescribe the same horizontal velocity,
+# the vertical velocity component is set to zero. The top boundary is open.
+# We use a Drucker Prager failure criterion.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 40000
+    set Y extent  = 10000
+    set X repetitions = 4
+  end
+end
+
+############### We prescribe a velocity of W/2 * background strain rate invariant
+# where W is the width of the domain and the background strain rate 1e-15 1/s.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0 x:function,1 x:function, 2: function
+
+  subsection Function
+    set Function expression     =  if(x>=2e4,2.e-11,-2.e-11);0
+  end
+end
+
+subsection Material model
+  set Model name = drucker prager
+
+  subsection Drucker Prager
+    set Thermal conductivity          = 0.0
+    set Reference density             = 2700.0
+    set Reference temperature         = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Reference specific heat       = 1
+
+    subsection Viscosity
+      set Minimum viscosity           = 1e19
+      set Maximum viscosity           = 1e26
+      set Cohesion                    = 4e7
+      set Angle of internal friction  = 15
+      set Reference strain rate       = 1e-15
+    end
+  end
+end
+
+############## rho * g = 27000
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# We set the temperature to zero, as it is not important.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 1
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+# We select to compute some statistics about the
+# velocity field and the mass flux through the boundaries.
+# As we prescribe an outflow of 2e-11 m/s on both vertical boundaries
+# the VRMS should be on that order. The max velocity will be a little
+# higher, because the outflow will be balanced by an inflow
+# through the top boundary over a smaller boundary length.
+# For the given density and outflow velocity, a boundary
+# mass flux of v * L * rho = 2e-11  * 10000 * 2700 = 5.4e-4 kg/s
+# is expected for each vertical boundary,
+# compensated by a influx of 1.08e-3 kg/s through the top.
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/dynamic_core.prm.bak b/tests/dynamic_core.prm.bak
new file mode 100644
index 00000000000..8cf0b7a94d4
--- /dev/null
+++ b/tests/dynamic_core.prm.bak
@@ -0,0 +1,101 @@
+# A simple setup for Earth convection model in a 2d shell
+# with the core mantle boundary (CMB) temperature dynamically evolves through time.
+# The 'dynamic core' boundary temperature plugin and 'core statistics' postprocessor
+# are used to solving and tracing the core evolution.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Output directory                       = output
+
+#set Resume computation                     = true
+
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = dynamic core
+
+  subsection Dynamic core
+    set Inner temperature                 = 4100
+    set Outer temperature                 = 300
+    set Core density                      = 12.5e3
+    set Gravity acceleration              = 9.81    # For the core
+    set CMB pressure                      = 0.14e12
+    set Initial light composition         = 0.042   # wt% for light elements
+    set Max iteration                     = 30
+    set Core heat capacity                = 840
+    set K0                                = 4.111e11
+    set Alpha                             = 1.35e-5 # Thermal expansivity for the core
+    set Core conductivity                 = 50
+
+    subsection Geotherm parameters
+      set Tm0= 1695
+      set Tm1= 10.9e-12
+      set Tm2= -8.0e-24
+      set Theta= 0.11
+      set Composition dependency= false
+    end
+
+    subsection Radioactive heat source
+      #                                            100ppm K in core
+      set Number of radioactive heating elements = 1
+      set Heating rates                          = 2.92e-5
+      set Half life times                        = 1.25       #Unit: Gyr
+      set Initial concentrations                 = 0.1442962
+    end
+  end
+end
+
+subsection Heating model
+  set List of model names =  adiabatic heating
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 0 #4
+  set Time steps between mesh refinement = 0 #15
+end
+
+subsection Postprocess
+  set List of postprocessors = core statistics
+
+  subsection Dynamic core statistics
+    set Excess entropy only = true
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = user request
+end
diff --git a/tests/dynamic_friction.prm.bak b/tests/dynamic_friction.prm.bak
new file mode 100644
index 00000000000..b2f24056a7c
--- /dev/null
+++ b/tests/dynamic_friction.prm.bak
@@ -0,0 +1,141 @@
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 1
+set CFL number                             = 0.5
+set Output directory                       = dynamic_friction
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions  = 4
+    set X extent  = 80e3
+    set Y extent  = 20e3
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = top: free surface
+
+  # Advecting the free surface vertically rather than
+  # in the surface normal direction can result in a
+  # more stable mesh when the deformation is large
+  subsection Free surface
+    set Surface velocity projection = vertical
+  end
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Densities                  = 2800
+    set Thermal expansivities      = 4e-5
+    set Viscosity averaging scheme = harmonic
+    set Minimum viscosity          = 1e19
+    set Maximum viscosity          = 1e25
+    set Reference strain rate      = 1e-15
+    set Minimum strain rate        = 1.e-50
+    set Reference temperature      = 293
+
+    # Dislocation creep parameters for
+    set Prefactors for dislocation creep          =      5e-21, 5e-26
+    set Stress exponents for dislocation creep    =      1.0
+    set Activation energies for dislocation creep =      0.0
+    set Activation volumes for dislocation creep  =      0.0
+
+    # Plasticity parameters
+    set Friction mechanism                  = dynamic friction
+    set Dynamic characteristic strain rate  = 1e-15
+    set Angles of internal friction         = 29.0171320271063, 26.565051177078
+    set Dynamic angles of internal friction = 30.9637565320735, 26.565051177078
+    set Cohesions                           = 20e6
+    set Maximum yield stress                = 1e50
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( x > 40.e3 & x < 41.e3 & y < 0.4e3, 0, 1)
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left: function, right:function
+  set Tangential velocity boundary indicators = bottom
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = cm=0.01, year=1
+    set Function expression =  if (x==0 , 1*cm/year, if (x==80.e3, -1*cm/year, 0)) ; 0
+  end
+end
+
+############### Parameters describing the temperature field
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.95
+  set Strategy                           = strain rate
+  set Coarsening fraction                = 0.05
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-9
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/dynamic_topography.prm.bak b/tests/dynamic_topography.prm.bak
new file mode 100644
index 00000000000..17b761b0e60
--- /dev/null
+++ b/tests/dynamic_topography.prm.bak
@@ -0,0 +1,101 @@
+# A test that verifies that the dynamic topography is calculated correctly
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature  = 1600
+    set Left temperature    = 1600
+    set Right temperature   = 1600
+    set Top temperature     = 1600
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1800000
+    set Y extent = 700000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names     = x,y
+    set Function expression = if(sqrt((x-900000)*(x-900000) + (y-300000)*(y-300000))<50000,1700,1600)
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y < 600000, 0.0, 1.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1600
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 3e-4
+    set Viscosity                     = 1e21
+    set Composition viscosity prefactor = 100
+    set Thermal viscosity exponent    = 36.84136
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,3
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = dynamic topography, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+    set List of output variables = dynamic topography
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/dynamic_topography2.prm.bak b/tests/dynamic_topography2.prm.bak
new file mode 100644
index 00000000000..1bbd1a9e4b9
--- /dev/null
+++ b/tests/dynamic_topography2.prm.bak
@@ -0,0 +1,102 @@
+# A test that verifies that the dynamic topography is calculated correctly
+# when the cell sizes vary on the surface
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature  = 1600
+    set Left temperature    = 1600
+    set Right temperature   = 1600
+    set Top temperature     = 1600
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1800000
+    set Y extent = 700000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names     = x,y
+    set Function expression = if(sqrt((x-900000)*(x-900000) + (y-650000)*(y-650000))<50000,1700,1600)
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y < 600000, 0.0, 1.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1600
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 3e-4
+    set Viscosity                     = 1e21
+    set Composition viscosity prefactor = 100
+    set Thermal viscosity exponent    = 36.84136
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.5
+  set Coarsening fraction                = 0.00
+  set Strategy                           = thermal energy density
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,3
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = dynamic topography, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+    set List of output variables = dynamic topography
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/dynamic_topography3.prm.bak b/tests/dynamic_topography3.prm.bak
new file mode 100644
index 00000000000..17bc82f5427
--- /dev/null
+++ b/tests/dynamic_topography3.prm.bak
@@ -0,0 +1,79 @@
+# A test that verifies that the dynamic topography is calculated correctly
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 1600
+    set Outer temperature = 1600
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3480000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Vertical wave number = 2
+    set Lateral wave number one = 3
+    set Lateral wave number two = 2
+    set Magnitude = 100
+    set Reference temperature = 1600
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1600
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Strategy                           = temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner,outer
+end
+
+subsection Postprocess
+  set List of postprocessors = dynamic topography, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+    set List of output variables = dynamic topography
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/dynamic_topography_back.prm.bak b/tests/dynamic_topography_back.prm.bak
new file mode 100644
index 00000000000..49ad21f1bc9
--- /dev/null
+++ b/tests/dynamic_topography_back.prm.bak
@@ -0,0 +1,101 @@
+# A test that verifies that the dynamic topography is calculated correctly
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature  = 1600
+    set Left temperature    = 1600
+    set Right temperature   = 1600
+    set Top temperature     = 1600
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = -10
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1800000
+    set Y extent = 700000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names     = x,y
+    set Function expression = if(sqrt((x-900000)*(x-900000) + (y-300000)*(y-300000))<50000,1700,1600)
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y < 600000, 0.0, 1.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1600
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 3e-4
+    set Viscosity                     = 1e21
+    set Composition viscosity prefactor = 100
+    set Thermal viscosity exponent    = 36.84136
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,3
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = dynamic topography, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+    set List of output variables = dynamic topography
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/dynamic_topography_vs_surface_dynamic_topography.prm.bak b/tests/dynamic_topography_vs_surface_dynamic_topography.prm.bak
new file mode 100644
index 00000000000..975e90f33dc
--- /dev/null
+++ b/tests/dynamic_topography_vs_surface_dynamic_topography.prm.bak
@@ -0,0 +1,103 @@
+# Like the dynamic_topography test, but not only output the dynamic
+# topography using the 'dynamic topography' viz postprocessor, but
+# also using 'surface dynamic topography'.
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature  = 1600
+    set Left temperature    = 1600
+    set Right temperature   = 1600
+    set Top temperature     = 1600
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1800000
+    set Y extent = 700000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names     = x,y
+    set Function expression = if(sqrt((x-900000)*(x-900000) + (y-300000)*(y-300000))<50000,1700,1600)
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y < 600000, 0.0, 1.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1600
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 3e-4
+    set Viscosity                     = 1e21
+    set Composition viscosity prefactor = 100
+    set Thermal viscosity exponent    = 36.84136
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,3
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = dynamic topography, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+    set List of output variables = dynamic topography, surface dynamic topography
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/edit_parameters.cc.bak b/tests/edit_parameters.cc.bak
new file mode 100644
index 00000000000..695cb1501ab
--- /dev/null
+++ b/tests/edit_parameters.cc.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <deal.II/base/parameter_handler.h>
+#include <aspect/global.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/boundary_temperature/interface.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  // Global variables (to be set by parameters)
+  unsigned int switch_step;
+  bool switched;
+
+  /**
+   * Declare additional parameters.
+   */
+  void declare_parameters(const unsigned int,
+                          ParameterHandler &prm)
+  {
+    prm.declare_entry("Switch step", "0",
+                      Patterns::Integer(0),
+                      "Switch CFL at the timestep given.");
+  }
+
+  template <int dim>
+  void parse_parameters(const Parameters<dim>,
+                        ParameterHandler &prm)
+  {
+    switch_step = prm.get_integer("Switch step");
+    switched = false;
+  }
+
+  template <int dim>
+  void on_start_timestep (const SimulatorAccess<dim> &simulator_access)
+  {
+    simulator_access.get_pcout() << "Signal start_timestep triggered!" << std::endl;
+    if (simulator_access.get_timestep_number() != numbers::invalid_unsigned_int
+        &&
+        simulator_access.get_timestep_number() >= switch_step
+        &&
+        !switched )
+      {
+        simulator_access.get_pcout() << "Reducing CFL number!" << std::endl;
+        const_cast<Parameters<dim>&>(simulator_access.get_parameters()).CFL_number *= 0.5;
+
+        switched = true;
+      }
+  }
+
+
+  template <int dim>
+  void on_edit_parameters (const SimulatorAccess<dim> &simulator_access,
+                           Parameters<dim> &/*parameters*/)
+  {
+    simulator_access.get_pcout()<<"Signal edit_parameters triggered!"<<std::endl;
+  }
+
+  // Connect declare_parameters and parse_parameters to appropriate signals.
+  void parameter_connector ()
+  {
+    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
+    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
+
+    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
+    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
+  }
+
+  template <int dim>
+  void signal_connector (SimulatorSignals<dim> &signals)
+  {
+    signals.edit_parameters_pre_setup_dofs.connect (&on_edit_parameters<dim>);
+    signals.start_timestep.connect(&on_start_timestep<dim>);
+  }
+
+  // Tell ASPECT to send signals to the connector functions
+  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
+  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
+}
diff --git a/tests/edit_parameters.prm.bak b/tests/edit_parameters.prm.bak
new file mode 100644
index 00000000000..168d625fc7f
--- /dev/null
+++ b/tests/edit_parameters.prm.bak
@@ -0,0 +1,72 @@
+# Test runtime editing of parameters, in particular reducing
+# the CFL number by a factor of 2 after 5 timesteps.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.e9
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Switch step = 5
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 0:0,1:0,2:10,3:0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step                  = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, velocity statistics
+end
diff --git a/tests/elastic_stabilization_time_scale_factor.prm.bak b/tests/elastic_stabilization_time_scale_factor.prm.bak
new file mode 100644
index 00000000000..5c7ff722022
--- /dev/null
+++ b/tests/elastic_stabilization_time_scale_factor.prm.bak
@@ -0,0 +1,38 @@
+# This test checks whether the stabilization time scale factor works correctly
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm
+
+set End time                               = 5
+set Output directory                       = elastic_stabilization_time_scale_factor
+
+# Implement the new time scale factor
+subsection Material model
+  subsection Viscoelastic
+    set Stabilization time scale factor = 2
+  end
+end
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 7
+  end
+end
+
+# No global refinement
+subsection Mesh refinement
+  set Initial global refinement          = 0
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, material statistics, velocity statistics, topography
+
+  subsection Topography
+    set Output to file           = false
+    set Time between text output = 0
+  end
+end
diff --git a/tests/ellipsoidal_chunk_coordinate_parallel.prm.bak b/tests/ellipsoidal_chunk_coordinate_parallel.prm.bak
new file mode 100644
index 00000000000..e5d078d6cf3
--- /dev/null
+++ b/tests/ellipsoidal_chunk_coordinate_parallel.prm.bak
@@ -0,0 +1,86 @@
+# A simple setup for convection in a 3d ellipsoidal chunk. See the
+# manual for more information.
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# the shape of the grid, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+############### Parameters describing the model
+# We create a coordinate-parallel ellipsoidal chunk with
+# a large eccentricity (0.5).
+# The coordinate-parallel implementation takes two opposite
+# corners of the chunk as input.
+
+subsection Geometry model
+  set Model name = ellipsoidal chunk
+
+  subsection Ellipsoidal chunk
+    set NE corner = 7.5:30
+    set SW corner = -7.5:-10
+    set Depth = 3000000
+    set Eccentricity = 0.5
+    set East-West subdivisions = 1
+    set North-South subdivisions = 2
+    set Depth subdivisions = 3
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer,north,south,east,west
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer,north,south,east,west
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = west: 0, east: 1, south: 2, north: 3, inner: 4, outer:5
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.473e3
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+############### Parameters describing the discretization
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+############### Parameters describing what to do with the solution
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables          = density
+    set Output format                     = gnuplot
+  end
+end
diff --git a/tests/ellipsoidal_chunk_geometry.cc.bak b/tests/ellipsoidal_chunk_geometry.cc.bak
new file mode 100644
index 00000000000..fa6838e8c1e
--- /dev/null
+++ b/tests/ellipsoidal_chunk_geometry.cc.bak
@@ -0,0 +1,121 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+
+#include <deal.II/base/exceptions.h>
+
+#include <iostream>
+
+using namespace aspect;
+using namespace dealii;
+
+bool test_point(const GeometryModel::internal::EllipsoidalChunkGeometry<3> ellipsoidal_manifold,
+                const Point<3> &test_point)
+{
+  const Point<3> converted_point = ellipsoidal_manifold.pull_back(test_point);
+  const Point<3> twice_converted_point = ellipsoidal_manifold.push_forward(converted_point);
+
+  const Tensor<1,3> difference = twice_converted_point - test_point;
+  const double error = difference.norm() / test_point.norm();
+
+  std::cout << "Point: " << test_point
+            << " becomes: " << converted_point
+            << ". Back transformed: " << twice_converted_point
+            << ". Error: " << error << std::endl;
+
+  return true;
+}
+
+/*
+ * Launch the following function when this plugin is created.
+ */
+int f()
+{
+
+  const unsigned int dim=3;
+
+  std::vector<Point<2>> corners(2,Point<2>(-15.0,-15.0));
+  corners[1] *= -1.0;
+
+  std::vector<Point<3>> test_points;
+  test_points.push_back(Point<3> (6371000.0,0,0));
+  test_points.push_back(Point<3> (6171000.0,0,0));
+  test_points.push_back(Point<3> (3000000.0,3000000.0,0));
+  test_points.push_back(Point<3> (3000000.0,3000000.0,3000000.0));
+  test_points.push_back(Point<3> (3000000.0,-3000000.0,-3000000.0));
+  test_points.push_back(Point<3> (25000.0,25000.0,3481000.0));
+  test_points.push_back(Point<3> (25000.0,25000.0,1000000.0));
+  test_points.push_back(Point<3> (25000.0,25000.0,500000.0));
+  test_points.push_back(Point<3> (25000.0,25000.0,50000.0));
+
+
+  InitialTopographyModel::ZeroTopography<dim> topography;
+  {
+    std::cout << "Simple sphere test" << std::endl;
+    GeometryModel::internal::EllipsoidalChunkGeometry<dim> ellipsoidal_manifold(topography,
+                                                                                6371000.0,
+                                                                                0.0,
+                                                                                6371000.0,
+                                                                                2890000.0,
+                                                                                corners);
+
+    for (unsigned int i=0; i<test_points.size(); ++i)
+      test_point(ellipsoidal_manifold,test_points[i]);
+  }
+
+  const double semi_major_axis_a = 6378137.0;
+  const double eccentricity = 8.1819190842622e-2;
+  const double semi_minor = std::sqrt((1 - pow(eccentricity,2)) * pow(semi_major_axis_a,2));
+  {
+    std::cout << "WGS84 test" << std::endl;
+
+    GeometryModel::internal::EllipsoidalChunkGeometry<dim> ellipsoidal_manifold(topography,
+                                                                                semi_major_axis_a,
+                                                                                eccentricity,
+                                                                                semi_minor,
+                                                                                2890000.0,
+                                                                                corners);
+
+    for (unsigned int i=0; i<test_points.size(); ++i)
+      test_point(ellipsoidal_manifold,test_points[i]);
+  }
+
+  {
+    std::cout << "Test for points outside of the provided depth range" << std::endl;
+    GeometryModel::internal::EllipsoidalChunkGeometry<dim> ellipsoidal_manifold(topography,
+                                                                                semi_major_axis_a,
+                                                                                eccentricity,
+                                                                                semi_minor,
+                                                                                500000.0,
+                                                                                corners);
+
+    for (unsigned int i=0; i<test_points.size(); ++i)
+      test_point(ellipsoidal_manifold,test_points[i]);
+  }
+
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/ellipsoidal_chunk_geometry.prm.bak b/tests/ellipsoidal_chunk_geometry.prm.bak
new file mode 100644
index 00000000000..2ecefd5d850
--- /dev/null
+++ b/tests/ellipsoidal_chunk_geometry.prm.bak
@@ -0,0 +1,78 @@
+# This test checks the accuracy of the coordinate transformation
+# for the ellipsoidal chunk geometry model. Because the used
+# manifold includes an approximation for the conversion between
+# spherical and ellipsoidal coordinates the conversion is inaccurate
+# very close to the center of the domain. This test documents this
+# inaccuracy and shows that it is negligible for points at the
+# core-mantle boundary (5e-11 relative to center distance) and even for points
+# at the inner-core-boundary (1e-7).
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = ellipsoidal chunk
+
+  subsection Ellipsoidal chunk
+    set NE corner = 7.5:30
+    set SW corner = -7.5:-10
+    set Depth = 3000000
+    set Eccentricity = 0.5
+    set East-West subdivisions = 1
+    set North-South subdivisions = 2
+    set Depth subdivisions = 3
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer,north,south,east,west
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer,north,south,east,west
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = west: 0, east: 1, south: 2, north: 3, inner: 4, outer:5
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.473e3
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables          = density
+    set Output format                     = gnuplot
+  end
+end
diff --git a/tests/ellipsoidal_chunk_noncoordinate_parallel.prm.bak b/tests/ellipsoidal_chunk_noncoordinate_parallel.prm.bak
new file mode 100644
index 00000000000..c3323c27cc8
--- /dev/null
+++ b/tests/ellipsoidal_chunk_noncoordinate_parallel.prm.bak
@@ -0,0 +1,87 @@
+# A simple setup for convection in a 3d ellipsoidal chunk. See the
+# manual for more information.
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# the shape of the grid, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+############### Parameters describing the model
+# We create a non-coordinate-parallel ellipsoidal chunk with
+# a large eccentricity (0.5).
+# The non-coordinate-parallel implementation takes three
+# corners of the chunk as input.
+
+subsection Geometry model
+  set Model name = ellipsoidal chunk
+
+  subsection Ellipsoidal chunk
+    set NE corner = 5:30
+    set NW corner = 0:0
+    set SW corner = 10:-10
+    set Depth = 3000000
+    set Eccentricity = 0.5
+    set East-West subdivisions = 1
+    set North-South subdivisions = 2
+    set Depth subdivisions = 3
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer,north,south,east,west
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer, east, west, north, south
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = west: 0, east: 1, south: 2, north: 3, inner: 4, outer:5
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.473e3
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+############### Parameters describing the discretization
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+############### Parameters describing what to do with the solution
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, velocity statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables          = density
+    set Output format                     = gnuplot
+  end
+end
diff --git a/tests/ellipsoidal_chunk_topography.prm.bak b/tests/ellipsoidal_chunk_topography.prm.bak
new file mode 100644
index 00000000000..9735d656e86
--- /dev/null
+++ b/tests/ellipsoidal_chunk_topography.prm.bak
@@ -0,0 +1,93 @@
+# A simple setup for convection in a 3d ellipsoidal chunk with topography.
+# manual for more information.
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# the shape of the grid, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+
+############### Parameters describing the model
+# We create a coordinate parallel ellipsoidal chunk with
+# a large eccentricity (0.5).
+
+subsection Geometry model
+  set Model name = ellipsoidal chunk
+
+  subsection Ellipsoidal chunk
+    set NE corner = 7.5:30
+    set SW corner = -7.5:-10
+    set Depth = 3000000
+    set Eccentricity = 0.5
+    set East-West subdivisions = 1
+    set North-South subdivisions = 2
+    set Depth subdivisions = 3
+  end
+
+  subsection Initial topography model
+    set Model name = prm polygon
+
+    subsection Prm polygon
+      set Topography parameters = 200000  > 8,31;0,31;0,10;8,10 & \
+                                   -200000 > -8,-11;0,-11;0,10;-8,10
+    end
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer,north,south,east,west
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer,north,south,east,west
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = west: 0, east: 1, south: 2, north: 3, inner: 4, outer:5
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.473e3
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+############### Parameters describing the discretization
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+############### Parameters describing what to do with the solution
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables          = density
+    set Output format                     = gnuplot
+  end
+end
diff --git a/tests/entropy_adiabat.cc.bak b/tests/entropy_adiabat.cc.bak
new file mode 100644
index 00000000000..7ad48d87aef
--- /dev/null
+++ b/tests/entropy_adiabat.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_adiabat.prm.bak b/tests/entropy_adiabat.prm.bak
new file mode 100644
index 00000000000..59ea4c95b51
--- /dev/null
+++ b/tests/entropy_adiabat.prm.bak
@@ -0,0 +1,13 @@
+# Adiabatic downwelling that starts on one adiabat, with inflow on another adiabat
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/entropy_adiabat.prm
+
+set End time = 1e7
+
+subsection Geometry model
+  subsection Box
+    set Y repetitions = 10
+  end
+end
diff --git a/tests/entropy_conduction.cc.bak b/tests/entropy_conduction.cc.bak
new file mode 100644
index 00000000000..7ad48d87aef
--- /dev/null
+++ b/tests/entropy_conduction.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_conduction.prm.bak b/tests/entropy_conduction.prm.bak
new file mode 100644
index 00000000000..4b777c318a5
--- /dev/null
+++ b/tests/entropy_conduction.prm.bak
@@ -0,0 +1,7 @@
+# Conductive cooling starting form an adiabat.
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/entropy_conduction.prm
+
+set End time = 1e7
diff --git a/tests/entropy_half_space.cc.bak b/tests/entropy_half_space.cc.bak
new file mode 100644
index 00000000000..7ad48d87aef
--- /dev/null
+++ b/tests/entropy_half_space.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_half_space.prm.bak b/tests/entropy_half_space.prm.bak
new file mode 100644
index 00000000000..d6788546676
--- /dev/null
+++ b/tests/entropy_half_space.prm.bak
@@ -0,0 +1,13 @@
+# Conductive cooling of a half-space using the entropy method.
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/entropy_half_space.prm
+
+set End time = 1e7
+
+subsection Geometry model
+  subsection Box
+    set Y repetitions = 10
+  end
+end
diff --git a/tests/entropy_initial_lookup.cc.bak b/tests/entropy_initial_lookup.cc.bak
new file mode 100644
index 00000000000..7ad48d87aef
--- /dev/null
+++ b/tests/entropy_initial_lookup.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_initial_lookup.prm.bak b/tests/entropy_initial_lookup.prm.bak
new file mode 100644
index 00000000000..34f1f0b032d
--- /dev/null
+++ b/tests/entropy_initial_lookup.prm.bak
@@ -0,0 +1,136 @@
+# Entropy field initiated with a constant temperature and a table lookup of
+# (P, T) -> S.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600.0
+
+subsection Formulation
+  set Mass conservation = projected density field
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 13000
+    set Y extent = 1300000
+    set Y repetitions = 100
+  end
+end
+
+subsection Initial temperature model
+  # A constant initial temperature is assigned
+  # There is a decreasing in the entropy with increasing pressure.
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600.0
+  end
+end
+
+subsection Adiabatic conditions model
+  # The 'ascii data' option does not need the additional
+  # plugin, but is limited to the available adiabat data files.
+  # 'compute entropy profile' computes arbitrary adiabats
+  # internally, based on the data table.
+
+  set Model name = compute entropy profile
+
+  subsection Compute entropy profile
+    set Surface entropy = 2534  # equivalent to T=1600 K
+  end
+
+  subsection Ascii data model
+    set Data directory  = $ASPECT_SOURCE_DIR/data/material-model/
+    set Data file name  = entropy-table/opxtable/1600K_adiabat.txt
+  end
+end
+
+# We prescribe temperatures according to the data table.
+# This output is computed in the material model.
+subsection Temperature field
+  set Temperature method = prescribed field with diffusion
+end
+
+# We solve the entropy equation for the compositional field with name
+# 'entropy'. Temperature and density are then computed based on entropy and
+# pressure.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = entropy, density_field
+  set Types of fields = entropy, density
+  set Compositional field methods = field, prescribed field
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top
+  set List of model names = initial temperature
+end
+
+# Prescribing downward flow through a vertical pipe with
+# tangential side boundaries.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Function expression = 0; -0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We look up the values of entropies from another look-up table.
+# This table looks up the value of entropy from a pair of temperature and pressure.
+subsection Initial composition model
+  set List of model names = entropy table lookup
+
+  subsection Entropy table lookup
+    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/
+    set Material file name = material_table_temperature_pressure.txt
+  end
+end
+
+# We use a data table for orthopyroxene computed using the thermodynamic
+# modeling software Perple_X.
+subsection Material model
+  set Model name = entropy model
+
+  subsection Entropy model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/
+    set Material file name               = material_table_entropy_pressure.txt
+    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
+    set Thermal conductivity formulation = constant
+    set Thermal conductivity             = 0.1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e6
+    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
+    set Output format = gnuplot
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
+    end
+  end
+end
diff --git a/tests/entropy_initial_lookup_wb.cc.bak b/tests/entropy_initial_lookup_wb.cc.bak
new file mode 100644
index 00000000000..7ad48d87aef
--- /dev/null
+++ b/tests/entropy_initial_lookup_wb.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_initial_lookup_wb.prm.bak b/tests/entropy_initial_lookup_wb.prm.bak
new file mode 100644
index 00000000000..65333180d21
--- /dev/null
+++ b/tests/entropy_initial_lookup_wb.prm.bak
@@ -0,0 +1,141 @@
+# Entropy field initiated with a temperature field of a subduction slab
+# using the World Builder and a table lookup of (P, T) -> S.
+
+set Dimension = 2
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 0
+set Output directory = output_3
+set Timing output frequency = 10
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 1573.0
+set Resume computation = false
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set World builder file = $ASPECT_SOURCE_DIR/tests/entropy_initial_lookup_wb.wb
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+  set Use discontinuous composition discretization = false
+end
+
+subsection Formulation
+  set Mass conservation = projected density field
+end
+
+# Geometry:
+#   The mesh is a 2-D chunk that spans 171.5 degree in longitude
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3.481e6
+    set Chunk outer radius = 6.371e6
+    set Chunk maximum longitude = 1.7150e+02
+    set Chunk minimum longitude = 0.0
+    set Longitude repetitions = 6
+  end
+end
+
+# Mesh refinement:
+#   We combine the strategies of the isosurfaces with the viscosity.
+#   In this way, we can refine the level of the refinement in the
+#   slab core controlled by the colder temperature in the slab.
+subsection Mesh refinement
+  set Initial global refinement = 3
+  set Initial adaptive refinement = 3
+  set Minimum refinement level = 3
+  set Strategy = isosurfaces, minimum refinement function, viscosity
+  set Time steps between mesh refinement = 10
+  set Refinement fraction = 0.2
+  set Coarsening fraction = 0.2
+  set Run postprocessors on initial refinement = true
+  set Skip solvers on initial refinement = true
+
+  subsection Isosurfaces
+    set Isosurfaces = max, max, Temperature: 270.0 | 1173.0
+  end
+
+  subsection Minimum refinement function
+    set Coordinate system = spherical
+    set Variable names = r,phi,t
+    set Function constants = Ro=6.3710e+06, UM=670e3, DD=100e3
+    set Function expression = ((Ro-r<UM)? \
+                                   ((Ro-r<DD)? 5: 3): 0.0)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+# Initial temperature:
+# A slab structure is configured by the WorldBuilder
+subsection Initial temperature model
+  set List of model names = world builder
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 273
+  end
+end
+
+# We solve the entropy equation for the compositional field with name
+# 'entropy'. Temperature and density are then computed based on entropy and
+# pressure.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = entropy, density_field
+  set Types of fields = entropy, density
+  set Compositional field methods = field, prescribed field
+end
+
+# We look up the values of entropies from another look-up table.
+# This table looks up the value of entropy from a pair of temperature and pressure.
+subsection Initial composition model
+  set List of model names = entropy table lookup
+
+  subsection Entropy table lookup
+    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/
+    set Material file name = material_table_temperature_pressure.txt
+  end
+end
+
+# We use a data table for pyrolite computed using the thermodynamic
+# modeling software Perple_X.
+subsection Material model
+  set Model name = entropy model
+
+  subsection Entropy model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/
+    set Material file name               = material_table_entropy_pressure.txt
+    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
+    set Thermal conductivity formulation = constant
+    set Thermal conductivity             = 0.1
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e6
+    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
+    set Output format = gnuplot
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
+    end
+  end
+end
diff --git a/tests/entropy_plasticity.cc.bak b/tests/entropy_plasticity.cc.bak
new file mode 100644
index 00000000000..7ad48d87aef
--- /dev/null
+++ b/tests/entropy_plasticity.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_plasticity.prm.bak b/tests/entropy_plasticity.prm.bak
new file mode 100644
index 00000000000..f699984b4bb
--- /dev/null
+++ b/tests/entropy_plasticity.prm.bak
@@ -0,0 +1,152 @@
+# A 2-D annulus model for convection under early-Earth conditions, with plasticity,
+# reference viscosity profile, and p-T dependent conductivity
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 4e5
+set Output directory                       = output-entropy-plasticity
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+subsection Formulation
+  set Mass conservation = projected density field
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set List of compositional fields with disabled boundary entropy viscosity = entropy
+  end
+end
+
+# This material model reads in the Hefesto table
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+  set Model name = entropy model
+
+  subsection Entropy model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
+    set Material file name               = material_table.txt
+    set Lateral viscosity file name      = constant_lateral_vis_prefactor_50000.txt
+    set Thermal conductivity formulation = p-T-dependent
+    set Maximum viscosity                = 1e30
+    set Minimum viscosity                = 1e12
+    set Maximum lateral viscosity variation          = 2000
+    set Cohesion                         = 8e7
+    set Angle of internal friction       = 0.572957795130823 # = 0.01 radians
+  end
+
+  subsection Depth dependent viscosity
+    set Data directory                   = $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/data/
+    set Data file name                   = constant_viscosity.txt
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+  end
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+# Set the reference profiles, using a constant entropy
+subsection Adiabatic conditions model
+  set Model name = compute entropy profile
+
+  subsection Compute entropy profile
+    # This is specific entropy, equivalent to T=1600K according to the used table
+    set Surface entropy = 2535
+  end
+end
+
+subsection Initial temperature model
+  set Model name = prescribed temperature
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names =  initial temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+# The temperature field is computed from the entropy
+subsection Temperature field
+  set Temperature method = prescribed field with diffusion
+end
+
+# Density is computed from entropy
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = entropy, density_field
+  set Compositional field methods = field, prescribed field
+end
+
+# Set the initial temperature profile
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r,phi
+    set Function expression = 2535.08 + 10 * sin(2*phi)*sin(pi*(r-6371000)/2890000) - 1878.618 * erfc((6371000-r)/(2*sqrt(1.152e-6*5e7*31557600))) + \
+    486.368 * max(erfc((r-3481000)/(2*sqrt(1.152e-6*5e8*31557600))), exp(-((phi - 3/4*pi)^2)/(2*(1/35*pi)^2) - ((r-3481000)^2)/(2*400000^2))  );0
+
+    #set Function expression = 2687.748 + 10 * sin(2*phi)*sin(pi*(r-6371000)/2890000) - 2031.286 * erfc((6371000-r)/(2*sqrt(1.152e-6*5e7*31557600))) + 333.7 * erfc((r-3481000)/(2*sqrt(1.152e-6*5e8*31557600)));0
+  end
+end
+
+# Set the boundary entropy to values corresponding to
+# realistic temperature.
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = top, bottom
+  set List of model names = spherical constant
+  set Allow fixed composition on outflow boundaries = true
+
+  subsection Spherical constant
+    # Corresponding to T=300 K for p=0 GPa according to used table
+    set Outer composition = 600
+
+    # Corresponding to T=3400 K for p=140 GPa according to used table
+    set Inner composition = 2950
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Minimum refinement level                 = 2
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = composition threshold
+
+  subsection Composition threshold
+    set Compositional field thresholds = 2700, 1e6
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint = 600
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
+end
diff --git a/tests/entropy_read_multi_table.cc.bak b/tests/entropy_read_multi_table.cc.bak
new file mode 100644
index 00000000000..7ad48d87aef
--- /dev/null
+++ b/tests/entropy_read_multi_table.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_read_multi_table.prm.bak b/tests/entropy_read_multi_table.prm.bak
new file mode 100644
index 00000000000..c3b6c90b7f7
--- /dev/null
+++ b/tests/entropy_read_multi_table.prm.bak
@@ -0,0 +1,116 @@
+# A box model with two compositions. It reads in two look-up tables
+# and computes the initial property based on the chemical compositions.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Maximum time step                      = 1e6
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 50
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1560.29
+
+subsection Formulation
+  set Mass conservation = projected density field
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 13000
+    set Y extent = 13000
+    set Y repetitions = 1
+  end
+end
+
+subsection Adiabatic conditions model
+  # 'compute entropy profile' computes arbitrary adiabats
+  # internally, based on the data table.
+  set Model name = compute entropy profile
+
+  subsection Compute entropy profile
+    # Entropy equivalent to T=1560.29 K according to the used table
+    set Surface entropy = 2500
+  end
+end
+
+# We prescribe temperatures according to the data table.
+# This output is computed in the material model.
+subsection Temperature field
+  set Temperature method = prescribed field with diffusion
+end
+
+# We solve the entropy equation for the compositional field with type
+# 'entropy'. Temperature and density are then computed based on entropy and
+# pressure.
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = percent_bas, entropy_bas, entropy_haz, density_field
+  set Types of fields = chemical composition, entropy, entropy, density
+  set Compositional field methods = field, field, field, prescribed field
+end
+
+# Prescribing closed boundaries.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, left, right, bottom
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+# We start at the same entropy as the one used for the
+# adiabatic profile. The last compositional field gives
+# the analytical solution for the temperature at the
+# end of the model run based on the half-space cooling
+# model.
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    # Entropy equivalent to T=1560.29 K according to table
+    set Function expression = 0.2; 2500; 2500; 0.0
+  end
+end
+
+# We use a data table for orthopyroxene computed using the thermodynamic
+# modeling software HeFESTo.
+# We use a very large viscosity to make sure the material does not move.
+subsection Material model
+  set Model name = entropy model
+
+  subsection Entropy model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
+    set Material file name               = material_table.txt, multi_composition_test.txt
+    set Maximum viscosity                = 1e30
+    set Minimum viscosity                = 1e30
+    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
+    set Thermal conductivity formulation = constant
+    set Thermal conductivity             = 4.7
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 1e8
+    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
+    set Output format = gnuplot
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
+    end
+  end
+end
diff --git a/tests/entropy_viscosity_statistics.prm.bak b/tests/entropy_viscosity_statistics.prm.bak
new file mode 100644
index 00000000000..1af94eee676
--- /dev/null
+++ b/tests/entropy_viscosity_statistics.prm.bak
@@ -0,0 +1,11 @@
+# This is a copy of the artificial_viscosity test that
+# additionally checks the entropy viscosity statistics postprocessor.
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/artificial_viscosity.prm
+
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, entropy viscosity statistics
+end
diff --git a/tests/exponential_decay.cc.bak b/tests/exponential_decay.cc.bak
new file mode 100644
index 00000000000..5a10eab7c89
--- /dev/null
+++ b/tests/exponential_decay.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/operator_splitting/exponential_decay/exponential_decay.cc"
diff --git a/tests/exponential_decay.prm.bak b/tests/exponential_decay.prm.bak
new file mode 100644
index 00000000000..f1d306673e9
--- /dev/null
+++ b/tests/exponential_decay.prm.bak
@@ -0,0 +1,124 @@
+#########################################################
+# This is a benchmark case that tests the operator split
+# solver scheme, which can use a different time step to
+# compute reactions between compositional fields than
+# the time step used for advection.
+# In this test case, there is no advection, and we start
+# from a composition (and temperature) that is 1 everywhere
+# in the domain and then decays over time, following the
+# equations for exponential decay.
+
+# We use a plugin that implements the reactions for exponential
+# decay.
+set Additional shared libraries = ./libexponential_decay.so
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 100
+set Use years in output instead of seconds = false
+
+# We use a new solver scheme that enables the operator split.
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Use operator splitting                 = true
+set Maximum time step                      = 10
+
+# As we split the time-stepping of advection and reactions,
+# there are now two different time steps in the model:
+# We control the advection time step using the 'Maximum time step'
+# parameter (as this benchmark has no driving force, and hence very
+# low velocities, we can not use the CFL number), and the reaction
+# time step is controlled internally through the ODE solver scheme.
+# Instead of changing the step for the ODE solver, we can make the
+# solution more accurate by modifying the Reaction solver relative
+# tolerance.
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction solver relative tolerance = 1e-6
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+# Both initial temperature and composition are set to 1,
+# and will decay starting from this value.
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1.0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1.0
+  end
+end
+
+# We choose material and heating models that let temperature
+# and composition decay over time, and that is implemented in
+# a plugin.
+subsection Heating model
+  set List of model names = exponential decay heating
+
+  subsection Exponential decay heating
+    set Half life = 10
+  end
+end
+
+subsection Material model
+  set Model name = exponential decay
+
+  subsection Exponential decay
+    set Half life = 10
+  end
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1e5
+    set Density differential for compositional field 1 = 0
+  end
+end
+
+# As composition and temperature do not depend on x or y,
+# we can use a coarse resolution.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+# We output some statistics about the composition, and make
+# use of a postprocessor that computes errors compared to the
+# analytical solution for exponential decay.
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization, ExponentialDecayPostprocessor
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/fail.prm.bak b/tests/fail.prm.bak
new file mode 100644
index 00000000000..ed59e1c4984
--- /dev/null
+++ b/tests/fail.prm.bak
@@ -0,0 +1,5 @@
+# test that we can have tests where we expect failure triggered by the following line:
+#
+# EXPECT FAILURE
+
+set Dimension = 5
diff --git a/tests/find_boundary_composition_model.cc.bak b/tests/find_boundary_composition_model.cc.bak
new file mode 100644
index 00000000000..d427e640cc4
--- /dev/null
+++ b/tests/find_boundary_composition_model.cc.bak
@@ -0,0 +1,88 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/box.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/boundary_composition/initial_composition.h>
+#include <aspect/boundary_composition/box.h>
+#include <aspect/simulator.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    template <int dim>
+    class Box2 : public Box<dim>
+    {
+      public:
+        virtual void update();
+    };
+    template <int dim>
+    void Box2<dim>::update()
+    {
+      if (this->get_boundary_composition_manager().template has_matching_boundary_composition_model<BoundaryComposition::Box<dim>>())
+        std::cout << "Box is found!" << std::endl;
+      else
+        std::cout << "Box is not found!" << std::endl;
+
+      if (this->get_boundary_composition_manager().template has_matching_boundary_composition_model<BoundaryComposition::InitialComposition<dim>>())
+        std::cout << "InitialComposition is found!" << std::endl;
+      else
+        std::cout << "InitialComposition is not found!" << std::endl;
+
+      try
+        {
+          this->get_boundary_composition_manager().template get_matching_boundary_composition_model<BoundaryComposition::Box<dim>>();
+          std::cout << "Box is found!" << std::endl;
+        }
+      catch (...)
+        {
+          std::cout << "Box is not found!" << std::endl;
+        }
+
+      try
+        {
+          this->get_boundary_composition_manager().template get_matching_boundary_composition_model<BoundaryComposition::InitialComposition<dim>>();
+          std::cout << "InitialComposition is found!" << std::endl;
+        }
+      catch (...)
+        {
+          std::cout << "InitialComposition is not found!" << std::endl;
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
+                                               "box2",
+                                               "A model in which the temperature is chosen constant on "
+                                               "all the sides of a box. For test")
+  }
+}
diff --git a/tests/find_boundary_composition_model.prm.bak b/tests/find_boundary_composition_model.prm.bak
new file mode 100644
index 00000000000..2869b261323
--- /dev/null
+++ b/tests/find_boundary_composition_model.prm.bak
@@ -0,0 +1,75 @@
+# Based on find_post_process.prm.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = 0,1,2,3
+  set List of model names                   = initial composition
+end
+
+subsection Boundary temperature model
+  set List of model names = box2
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields  = field_a, field_b
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.5, 1, 0) ; if(y<0.5, 0, 1)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
diff --git a/tests/find_boundary_composition_model_fail_1.cc.bak b/tests/find_boundary_composition_model_fail_1.cc.bak
new file mode 100644
index 00000000000..9e21214fe56
--- /dev/null
+++ b/tests/find_boundary_composition_model_fail_1.cc.bak
@@ -0,0 +1,61 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/box.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/boundary_composition/initial_composition.h>
+#include <aspect/boundary_composition/box.h>
+#include <aspect/simulator.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    template <int dim>
+    class Box2 : public Box<dim>
+    {
+      public:
+        virtual void update();
+    };
+    template <int dim>
+    void Box2<dim>::update()
+    {
+      this->get_boundary_composition_manager().template get_matching_boundary_composition_model<BoundaryComposition::Box<dim>>();
+      std::cout << "Box is found!" << std::endl;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
+                                               "box2",
+                                               "A model in which the temperature is chosen constant on "
+                                               "all the sides of a box. For test")
+  }
+}
diff --git a/tests/find_boundary_composition_model_fail_1.prm.bak b/tests/find_boundary_composition_model_fail_1.prm.bak
new file mode 100644
index 00000000000..45afeed8f65
--- /dev/null
+++ b/tests/find_boundary_composition_model_fail_1.prm.bak
@@ -0,0 +1,81 @@
+# This test will request a non-activated boundary composition model and
+# will not catch the resulting exception to check if the
+# exception output works correctly.
+# Based on find_post_process_fail_1.prm.
+
+# EXPECT FAILURE
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = 0,1,2,3
+  set List of model names                   = initial composition
+end
+
+subsection Boundary temperature model
+  set List of model names = box2
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields  = field_a, field_b
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.5, 1, 0) ; if(y<0.5, 0, 1)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
diff --git a/tests/find_mesh_refinement.cc.bak b/tests/find_mesh_refinement.cc.bak
new file mode 100644
index 00000000000..7718c91d498
--- /dev/null
+++ b/tests/find_mesh_refinement.cc.bak
@@ -0,0 +1,88 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/box.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/mesh_refinement/density.h>
+#include <aspect/mesh_refinement/boundary.h>
+#include <aspect/simulator.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    template <int dim>
+    class Box2 : public Box<dim>
+    {
+      public:
+        virtual void update();
+    };
+    template <int dim>
+    void Box2<dim>::update()
+    {
+      if (this->get_mesh_refinement_manager().template has_matching_mesh_refinement_strategy<MeshRefinement::Density<dim>>())
+        std::cout << "Density is found!" << std::endl;
+      else
+        std::cout << "Density is not found!" << std::endl;
+
+      if (this->get_mesh_refinement_manager().template has_matching_mesh_refinement_strategy<MeshRefinement::Boundary<dim>>())
+        std::cout << "Boundary is found!" << std::endl;
+      else
+        std::cout << "Boundary is not found!" << std::endl;
+
+      try
+        {
+          this->get_mesh_refinement_manager().template get_matching_mesh_refinement_strategy<MeshRefinement::Density<dim>>();
+          std::cout << "Density is found!" << std::endl;
+        }
+      catch (...)
+        {
+          std::cout << "Density is not found!" << std::endl;
+        }
+
+      try
+        {
+          this->get_mesh_refinement_manager().template get_matching_mesh_refinement_strategy<MeshRefinement::Boundary<dim>>();
+          std::cout << "Boundary is found!" << std::endl;
+        }
+      catch (...)
+        {
+          std::cout << "Boundary is not found!" << std::endl;
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
+                                               "box2",
+                                               "A model in which the temperature is chosen constant on "
+                                               "all the sides of a box. For test")
+  }
+}
diff --git a/tests/find_mesh_refinement.prm.bak b/tests/find_mesh_refinement.prm.bak
new file mode 100644
index 00000000000..b1e278b2dc7
--- /dev/null
+++ b/tests/find_mesh_refinement.prm.bak
@@ -0,0 +1,61 @@
+# Test for looking for mesh refinement strategy plugins
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box2
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Strategy = density
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =  heat flux statistics
+end
diff --git a/tests/find_mesh_refinement_fail_1.cc.bak b/tests/find_mesh_refinement_fail_1.cc.bak
new file mode 100644
index 00000000000..92594ca2155
--- /dev/null
+++ b/tests/find_mesh_refinement_fail_1.cc.bak
@@ -0,0 +1,60 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/box.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/mesh_refinement/boundary.h>
+#include <aspect/simulator.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    template <int dim>
+    class Box2 : public Box<dim>
+    {
+      public:
+        virtual void update();
+    };
+    template <int dim>
+    void Box2<dim>::update()
+    {
+      this->get_mesh_refinement_manager().template get_matching_mesh_refinement_strategy<MeshRefinement::Boundary<dim>>();
+      std::cout << "Boundary is found!" << std::endl;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
+                                               "box2",
+                                               "A model in which the temperature is chosen constant on "
+                                               "all the sides of a box. For test")
+  }
+}
diff --git a/tests/find_mesh_refinement_fail_1.prm.bak b/tests/find_mesh_refinement_fail_1.prm.bak
new file mode 100644
index 00000000000..922a46b0730
--- /dev/null
+++ b/tests/find_mesh_refinement_fail_1.prm.bak
@@ -0,0 +1,65 @@
+# This test will request a non-activated mesh refinement strategy and
+# will not catch the resulting exception to check if the
+# exception output works correctly.
+
+# EXPECT FAILURE
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box2
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Strategy = density
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =  heat flux statistics
+end
diff --git a/tests/find_postprocess.cc.bak b/tests/find_postprocess.cc.bak
new file mode 100644
index 00000000000..9c81576c187
--- /dev/null
+++ b/tests/find_postprocess.cc.bak
@@ -0,0 +1,88 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/box.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/postprocess/heat_flux_statistics.h>
+#include <aspect/postprocess/pressure_statistics.h>
+#include <aspect/simulator.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    template <int dim>
+    class Box2 : public Box<dim>
+    {
+      public:
+        virtual void update();
+    };
+    template <int dim>
+    void Box2<dim>::update()
+    {
+      if (this->get_postprocess_manager().template has_matching_postprocessor<Postprocess::PressureStatistics<dim>>())
+        std::cout << "PressureStatistics is found!" << std::endl;
+      else
+        std::cout << "PressureStatistics is not found!" << std::endl;
+
+      if (this->get_postprocess_manager().template has_matching_postprocessor<Postprocess::HeatFluxStatistics<dim>>())
+        std::cout << "HeatFluxStatistics is found!" << std::endl;
+      else
+        std::cout << "HeatFluxStatistics is not found!" << std::endl;
+
+      try
+        {
+          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::PressureStatistics<dim>>();
+          std::cout << "PressureStatistics is found!" << std::endl;
+        }
+      catch (...)
+        {
+          std::cout << "PressureStatistics is not found!" << std::endl;
+        }
+
+      try
+        {
+          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::HeatFluxStatistics<dim>>();
+          std::cout << "HeatFluxStatistics is found!" << std::endl;
+        }
+      catch (...)
+        {
+          std::cout << "HeatFluxStatistics is not found!" << std::endl;
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
+                                               "box2",
+                                               "A model in which the temperature is chosen constant on "
+                                               "all the sides of a box. For test")
+  }
+}
diff --git a/tests/find_postprocess.prm.bak b/tests/find_postprocess.prm.bak
new file mode 100644
index 00000000000..5e3e4f3f0d7
--- /dev/null
+++ b/tests/find_postprocess.prm.bak
@@ -0,0 +1,58 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box2
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =  heat flux statistics
+end
diff --git a/tests/find_postprocess_fail_1.cc.bak b/tests/find_postprocess_fail_1.cc.bak
new file mode 100644
index 00000000000..f0ed09ec46c
--- /dev/null
+++ b/tests/find_postprocess_fail_1.cc.bak
@@ -0,0 +1,61 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/boundary_temperature/box.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/postprocess/heat_flux_statistics.h>
+#include <aspect/postprocess/pressure_statistics.h>
+#include <aspect/simulator.h>
+
+#include <utility>
+#include <limits>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    template <int dim>
+    class Box2 : public Box<dim>
+    {
+      public:
+        virtual void update();
+    };
+    template <int dim>
+    void Box2<dim>::update()
+    {
+      this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::PressureStatistics<dim>>();
+      std::cout << "PressureStatistics is found!" << std::endl;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
+                                               "box2",
+                                               "A model in which the temperature is chosen constant on "
+                                               "all the sides of a box. For test")
+  }
+}
diff --git a/tests/find_postprocess_fail_1.prm.bak b/tests/find_postprocess_fail_1.prm.bak
new file mode 100644
index 00000000000..4e80d4ab0fc
--- /dev/null
+++ b/tests/find_postprocess_fail_1.prm.bak
@@ -0,0 +1,64 @@
+# This test will request a non-activated postprocessor and
+# will not catch the resulting exception to check if the
+# exception output works correctly.
+
+# EXPECT FAILURE
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box2
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =  heat flux statistics
+end
diff --git a/tests/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg.prm.bak b/tests/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg.prm.bak
new file mode 100644
index 00000000000..908f301611a
--- /dev/null
+++ b/tests/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg.prm.bak
@@ -0,0 +1,33 @@
+# Same as free_surface_VE_cylinder_2D_loading.prm, but uses
+# a fixed elastic timestep in combination with stress averaging
+# to smooth out the elastic response to instantaneous stress changes
+# and use the GMG solver.
+# MPI: 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm
+
+
+#  Global parameters
+set Dimension                              = 2
+set Output directory                       = output_free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg
+set End time = 30
+
+# Material model
+
+subsection Material model
+  set Model name = viscoelastic
+  set Material averaging = harmonic average only viscosity
+
+  subsection Viscoelastic
+    set Use fixed elastic time step = true
+    set Fixed elastic time step     = 1e2
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 1000
+  end
+end
diff --git a/tests/free_surface_adaptive_blob.prm.bak b/tests/free_surface_adaptive_blob.prm.bak
new file mode 100644
index 00000000000..b858f092f3c
--- /dev/null
+++ b/tests/free_surface_adaptive_blob.prm.bak
@@ -0,0 +1,115 @@
+# like free_surface_blob.prm with adaptive refinement and in parallel
+# MPI: 3
+
+set Dimension = 2
+set CFL number                             = 0.5
+set End time                               = 1e9
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, basic statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/free_surface_blob.prm.bak b/tests/free_surface_blob.prm.bak
new file mode 100644
index 00000000000..a8933a148e3
--- /dev/null
+++ b/tests/free_surface_blob.prm.bak
@@ -0,0 +1,114 @@
+#Test for free surface topography due to a rising blob
+
+set Dimension = 2
+set CFL number                             = 0.5
+set End time                               = 1e9
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, basic statistics,
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/free_surface_blob_gmg.prm.bak b/tests/free_surface_blob_gmg.prm.bak
new file mode 100644
index 00000000000..e90258a7983
--- /dev/null
+++ b/tests/free_surface_blob_gmg.prm.bak
@@ -0,0 +1,17 @@
+# test gmg + free surface
+include $ASPECT_SOURCE_DIR/tests/free_surface_blob.prm
+
+set Dimension = 2
+set Output directory                       = output_free_surface_blob_gmg
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/tests/free_surface_blob_melt.cc.bak b/tests/free_surface_blob_melt.cc.bak
new file mode 100644
index 00000000000..17f4b7f2170
--- /dev/null
+++ b/tests/free_surface_blob_melt.cc.bak
@@ -0,0 +1,326 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/global.h>
+#include <aspect/melt.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class MeltFreeSurface : public MaterialModel::MeltFractionModel<dim>, public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+        virtual void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                                     std::vector<double> &melt_fractions) const;
+        virtual bool is_compressible () const;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Reference quantities
+         * @{
+         */
+        virtual double reference_darcy_coefficient () const;
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+        /**
+         * @}
+         */
+
+      private:
+        double reference_rho;
+        double reference_T;
+        double eta;
+        double composition_viscosity_prefactor;
+        double thermal_viscosity_exponent;
+        double maximum_thermal_prefactor;
+        double minimum_thermal_prefactor;
+        double thermal_alpha;
+        double reference_specific_heat;
+
+        /**
+         * The thermal conductivity.
+         */
+        double k_value;
+
+        double compositional_delta_rho;
+    };
+
+
+    template <int dim>
+    void
+    MeltFreeSurface<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double delta_temp = in.temperature[i]-reference_T;
+          const double temperature_dependence = (reference_T > 0
+                                                 ?
+                                                 std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/reference_T),
+                                                                   maximum_thermal_prefactor),
+                                                          minimum_thermal_prefactor)
+                                                 :
+                                                 1.0);
+
+          out.viscosities[i] = ((composition_viscosity_prefactor != 1.0) && (in.composition[i].size()>0))
+                               ?
+                               // Geometric interpolation
+                               pow(10.0, ((1-in.composition[i][0]) * log10(eta*temperature_dependence)
+                                          + in.composition[i][0] * log10(eta*composition_viscosity_prefactor*temperature_dependence)))
+                               :
+                               temperature_dependence * eta;
+
+          const double c = (in.composition[i].size()>0)
+                           ?
+                           std::max(0.0, in.composition[i][0])
+                           :
+                           0.0;
+
+          out.densities[i] = reference_rho * (1 - thermal_alpha * (in.temperature[i] - reference_T))
+                             + compositional_delta_rho * c;
+
+          out.thermal_expansion_coefficients[i] = thermal_alpha;
+          out.specific_heat[i] = reference_specific_heat;
+          out.thermal_conductivities[i] = k_value;
+          out.compressibilities[i] = 0.0;
+          // Pressure derivative of entropy at the given positions.
+          out.entropy_derivative_pressure[i] = 0.0;
+          // Temperature derivative of entropy at the given positions.
+          out.entropy_derivative_temperature[i] = 0.0;
+          // Change in composition due to chemical reactions at the
+          // given positions. The term reaction_terms[i][c] is the
+          // change in compositional field c at point i.
+          for (unsigned int c=0; c<in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+
+      // fill melt outputs if they exist
+      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
+
+      if (melt_out != nullptr)
+        {
+          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const double porosity = std::max(in.composition[i][porosity_idx],0.0);
+              melt_out->fluid_densities[i] = 300.;
+              melt_out->permeabilities[i] = 1e-8 * std::pow(porosity, 3);
+              melt_out->compaction_viscosities[i] = eta;
+              melt_out->fluid_viscosities[i] = 10.;
+              melt_out->fluid_density_gradients[i] = 0.0;
+            }
+        }
+    }
+
+    template <int dim>
+    void
+    MeltFreeSurface<dim>::
+    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                    std::vector<double> &melt_fractions) const
+    {
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
+        melt_fractions[q] = 0.0;
+      return;
+    }
+
+    template <int dim>
+    double
+    MeltFreeSurface<dim>::
+    reference_darcy_coefficient () const
+    {
+      return 1e-14;
+    }
+
+    template <int dim>
+    bool
+    MeltFreeSurface<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+
+
+    template <int dim>
+    void
+    MeltFreeSurface<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simple model");
+        {
+          prm.declare_entry ("Reference density", "3300",
+                             Patterns::Double (0),
+                             "Reference density $\\rho_0$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
+          prm.declare_entry ("Reference temperature", "293",
+                             Patterns::Double (0),
+                             "The reference temperature $T_0$. The reference temperature is used "
+                             "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Viscosity", "5e24",
+                             Patterns::Double (0),
+                             "The value of the constant viscosity $\\eta_0$. This viscosity may be "
+                             "modified by both temperature and compositional dependencies. "
+                             "Units: \\si{\\pascal\\second}.");
+          prm.declare_entry ("Composition viscosity prefactor", "1.0",
+                             Patterns::Double (0),
+                             "A linear dependency of viscosity on the first compositional field. "
+                             "Dimensionless prefactor. With a value of 1.0 (the default) the "
+                             "viscosity does not depend on the composition. See the general documentation "
+                             "of this model for a formula that states the dependence of the "
+                             "viscosity on this factor, which is called $\\xi$ there.");
+          prm.declare_entry ("Thermal viscosity exponent", "0.0",
+                             Patterns::Double (0),
+                             "The temperature dependence of viscosity. Dimensionless exponent. "
+                             "See the general documentation "
+                             "of this model for a formula that states the dependence of the "
+                             "viscosity on this factor, which is called $\\beta$ there.");
+          prm.declare_entry("Maximum thermal prefactor","1.0e2",
+                            Patterns::Double (0),
+                            "The maximum value of the viscosity prefactor associated with temperature "
+                            "dependence.");
+          prm.declare_entry("Minimum thermal prefactor","1.0e-2",
+                            Patterns::Double (0),
+                            "The minimum value of the viscosity prefactor associated with temperature "
+                            "dependence.");
+          prm.declare_entry ("Thermal conductivity", "4.7",
+                             Patterns::Double (0),
+                             "The value of the thermal conductivity $k$. "
+                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
+          prm.declare_entry ("Reference specific heat", "1250",
+                             Patterns::Double (0),
+                             "The value of the specific heat $C_p$. "
+                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
+          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
+                             Patterns::Double (0),
+                             "The value of the thermal expansion coefficient $\\alpha$. "
+                             "Units: \\si{\\per\\kelvin}.");
+          prm.declare_entry ("Density differential for compositional field 1", "0",
+                             Patterns::Double(),
+                             "If compositional fields are used, then one would frequently want "
+                             "to make the density depend on these fields. In this simple material "
+                             "model, we make the following assumptions: if no compositional fields "
+                             "are used in the current simulation, then the density is simply the usual "
+                             "one with its linear dependence on the temperature. If there are compositional "
+                             "fields, then the density only depends on the first one in such a way that "
+                             "the density has an additional term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
+                             "This parameter describes the value of $\\Delta \\rho$. "
+                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    MeltFreeSurface<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Simple model");
+        {
+          reference_rho              = prm.get_double ("Reference density");
+          reference_T                = prm.get_double ("Reference temperature");
+          eta                        = prm.get_double ("Viscosity");
+          composition_viscosity_prefactor = prm.get_double ("Composition viscosity prefactor");
+          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
+          maximum_thermal_prefactor       = prm.get_double ("Maximum thermal prefactor");
+          minimum_thermal_prefactor       = prm.get_double ("Minimum thermal prefactor");
+          if ( maximum_thermal_prefactor == 0.0 ) maximum_thermal_prefactor = std::numeric_limits<double>::max();
+          if ( minimum_thermal_prefactor == 0.0 ) minimum_thermal_prefactor = std::numeric_limits<double>::min();
+
+          k_value                    = prm.get_double ("Thermal conductivity");
+          reference_specific_heat    = prm.get_double ("Reference specific heat");
+          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
+          compositional_delta_rho    = prm.get_double ("Density differential for compositional field 1");
+
+          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
+            AssertThrow(false, ExcMessage("Error: Material model simple with Thermal viscosity exponent can not have reference_T=0."));
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
+      this->model_dependence.viscosity = NonlinearDependence::none;
+      this->model_dependence.density = NonlinearDependence::none;
+
+      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+
+      if (thermal_viscosity_exponent != 0)
+        this->model_dependence.viscosity |= NonlinearDependence::temperature;
+      if (composition_viscosity_prefactor != 1.0)
+        this->model_dependence.viscosity |= NonlinearDependence::compositional_fields;
+
+      if (thermal_alpha != 0)
+        this->model_dependence.density |=NonlinearDependence::temperature;
+      if (compositional_delta_rho != 0)
+        this->model_dependence.density |=NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(MeltFreeSurface,
+                                   "melt free surface",
+                                   "A simple material model that is like the "
+                                   "'simple' model, but has melt outputs.")
+  }
+}
diff --git a/tests/free_surface_blob_melt.prm.bak b/tests/free_surface_blob_melt.prm.bak
new file mode 100644
index 00000000000..ca63d832517
--- /dev/null
+++ b/tests/free_surface_blob_melt.prm.bak
@@ -0,0 +1,135 @@
+# Test for free surface topography due to a rising blob
+# with melt transport = on, but zero porosity.
+# This test is the same as free_surface_blob (except for
+# the melt transport) and tests that results are approximately
+# the same.
+
+set Dimension = 2
+set CFL number                             = 0.5
+set End time                               = 1e9
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = melt free surface
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, basic statistics,
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/free_surface_blob_nonzero_melt.cc.bak b/tests/free_surface_blob_nonzero_melt.cc.bak
new file mode 100644
index 00000000000..e127b3eaeac
--- /dev/null
+++ b/tests/free_surface_blob_nonzero_melt.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "free_surface_blob_melt.cc"
diff --git a/tests/free_surface_blob_nonzero_melt.prm.bak b/tests/free_surface_blob_nonzero_melt.prm.bak
new file mode 100644
index 00000000000..e7e9b841a68
--- /dev/null
+++ b/tests/free_surface_blob_nonzero_melt.prm.bak
@@ -0,0 +1,153 @@
+# Test for free surface topography due to a rising blob
+# with melt transport = on and nonzero porosity.
+# The test is the same as free_surface_blob_melt, except that melt
+# has a nonzero initial condition.
+# We test if the boundary conditions for melt are set correctly
+# (no melt flowing in/out at the free surface) by checking if the
+# mass of the porosity field is conserved.
+
+set Dimension = 2
+set CFL number                             = 0.5
+set End time                               = 1e4
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+set Maximum time step                      = 1e4
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = melt free surface
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = minimum refinement function
+  set Time steps between mesh refinement = 0
+
+  subsection Minimum refinement function
+    set Variable names      = depth, phi
+    set Function expression = if(depth<10000,5,3)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.02 * (sin (3.141*x/5.e5) * sin (2*3.141*y/5.e5)) * (sin (3.141*x/5.e5) * sin (2*3.141*y/5.e5))
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, visualization, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables =  melt material properties
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/free_surface_iterated_IMPES.prm.bak b/tests/free_surface_iterated_IMPES.prm.bak
new file mode 100644
index 00000000000..8bb9e64ff1e
--- /dev/null
+++ b/tests/free_surface_iterated_IMPES.prm.bak
@@ -0,0 +1,121 @@
+# This is a copy of the free_surface_iterated_stokes test,
+# the only difference being that it uses the iterated Advection and Stokes solver.
+
+set Dimension = 2
+set CFL number                             = 0.1
+set End time                               = 1e9
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/free_surface_iterated_stokes.prm.bak b/tests/free_surface_iterated_stokes.prm.bak
new file mode 100644
index 00000000000..7efea011e3f
--- /dev/null
+++ b/tests/free_surface_iterated_stokes.prm.bak
@@ -0,0 +1,120 @@
+#Test for running a free surface with the iterated stokes solver
+
+set Dimension = 2
+set CFL number                             = 0.1
+set End time                               = 1e9
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/free_surface_iterated_stokes_gmg.prm b/tests/free_surface_iterated_stokes_gmg.prm
index b8dd281ac99..26f1f1b6a62 100644
--- a/tests/free_surface_iterated_stokes_gmg.prm
+++ b/tests/free_surface_iterated_stokes_gmg.prm
@@ -5,7 +5,7 @@ set Dimension = 2
 set Output directory                       = output_free_surface_iterated_stokes_gmg
 
 subsection Mesh refinement
-  set Initial global refinement          = 3                      # default: 2
+  set Initial global refinement          = 3
 end
 
 subsection Solver parameters
diff --git a/tests/free_surface_iterated_stokes_gmg.prm.bak b/tests/free_surface_iterated_stokes_gmg.prm.bak
new file mode 100644
index 00000000000..b8dd281ac99
--- /dev/null
+++ b/tests/free_surface_iterated_stokes_gmg.prm.bak
@@ -0,0 +1,21 @@
+# test gmg + free surface
+include $ASPECT_SOURCE_DIR/tests/free_surface_iterated_stokes.prm
+
+set Dimension = 2
+set Output directory                       = output_free_surface_iterated_stokes_gmg
+
+subsection Mesh refinement
+  set Initial global refinement          = 3                      # default: 2
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type =  block GMG
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/tests/free_surface_relaxation.cc.bak b/tests/free_surface_relaxation.cc.bak
new file mode 100644
index 00000000000..5bca2e1708f
--- /dev/null
+++ b/tests/free_surface_relaxation.cc.bak
@@ -0,0 +1,178 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+#include <aspect/geometry_model/box.h>
+#include <deal.II/grid/grid_generator.h>
+#include <deal.II/grid/tria_iterator.h>
+#include <deal.II/grid/tria_accessor.h>
+#include <deal.II/grid/tria.h>
+#include <cmath>
+#include <vector>
+
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    /**
+     * A class deriving from Box<dim>, which changes the upper boundary
+       with a sinusoidal perturbation of a given order and amplitude
+     */
+    template <int dim>
+    class ReboundBox : public Box<dim>
+    {
+      public:
+        /**
+         * Generate a coarse mesh for the geometry described by this class.
+         * Makes perturbs the top boundary of the box with a function
+         * of the form z' = amplitude * cos(order * x )
+         */
+        virtual
+        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter
+         * file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+
+        /**
+         * Give the depth of a point.
+         */
+        virtual
+        double depth( const Point<dim> &position) const;
+
+        /**
+         * Give the maximal depth of a point.
+         */
+        virtual
+        double maximal_depth() const;
+
+      private:
+
+        unsigned int order;  // Order of the perturbation
+        double amplitude;  // amplitude of the perturbation
+
+    };
+
+    template <int dim>
+    void
+    ReboundBox<dim>::
+    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
+    {
+
+      // Call the normal Box mesh generator
+      Box<dim>::create_coarse_mesh( coarse_grid );
+
+      // move the vertices
+      std::vector<bool> vertex_touched (coarse_grid.n_vertices(), false);
+
+      typename parallel::distributed::Triangulation<dim>::active_cell_iterator cell;
+      for (cell = coarse_grid.begin_active();  cell != coarse_grid.end();  ++cell)
+        for (unsigned int v = 0; v < cell->n_vertices();  ++v)
+          if (vertex_touched[cell->vertex_index(v)] == false)
+            {
+              Point<dim> &vertex = cell->vertex(v);
+              vertex[dim-1] = vertex[dim-1] + std::cos(order*2.0*M_PI*vertex[0]/(this->get_extents()[0]))*
+                              amplitude*vertex[dim-1]/(this->get_extents()[dim-1]);
+              vertex_touched[cell->vertex_index(v)] = true;
+            }
+
+    }
+
+    template <int dim>
+    double
+    ReboundBox<dim>::maximal_depth() const
+    {
+      return Box<dim>::maximal_depth()+amplitude;
+    }
+
+    template <int dim>
+    double
+    ReboundBox<dim>::depth(const Point<dim> &position) const
+    {
+      double d = maximal_depth()-position(dim-1);
+      return d;
+    }
+
+    template <int dim>
+    void
+    ReboundBox<dim>::
+    declare_parameters (ParameterHandler &prm)
+    {
+      Box<dim>::declare_parameters(prm);
+
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Rebound Box");
+        {
+          prm.declare_entry ("Order", "1",
+                             Patterns::Double (0),
+                             "Order of the perturbation");
+          prm.declare_entry ("Amplitude", "0.1",
+                             Patterns::Double (0),
+                             "Scaled amplitude of the perturbation");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    ReboundBox<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      Box<dim>::parse_parameters(prm);
+
+      prm.enter_subsection("Geometry model");
+      {
+        prm.enter_subsection("Rebound Box");
+        {
+          order = prm.get_double ("Order");
+          amplitude = prm.get_double ("Amplitude");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace GeometryModel
+  {
+    ASPECT_REGISTER_GEOMETRY_MODEL(ReboundBox,
+                                   "rebound box",
+                                   "Geometry model for benchmarking relaxation of topography.")
+  }
+}
diff --git a/tests/free_surface_relaxation.prm.bak b/tests/free_surface_relaxation.prm.bak
new file mode 100644
index 00000000000..102ff80b7aa
--- /dev/null
+++ b/tests/free_surface_relaxation.prm.bak
@@ -0,0 +1,121 @@
+# Test for relaxing topography of the free surface after an
+# initial sinusoidal perturbation
+
+set Dimension = 2
+set CFL number                             = 0.01
+set End time                               = 1e5
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = rebound box
+
+  subsection Rebound Box
+    set Order = 3
+    set Amplitude = 1.5e4
+  end
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 50
+    set Y repetitions = 20
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  0.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+    set Density differential for compositional field 1 = 0.0
+    set Composition viscosity prefactor = 100.
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.00
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, basic statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/free_surface_tangential_mesh_velocity.prm.bak b/tests/free_surface_tangential_mesh_velocity.prm.bak
new file mode 100644
index 00000000000..2f26fb4b882
--- /dev/null
+++ b/tests/free_surface_tangential_mesh_velocity.prm.bak
@@ -0,0 +1,86 @@
+set Dimension                              = 2
+set End time                               = 1e6
+set Use years in output instead of seconds = true
+set Output directory                       = output
+set Adiabatic surface temperature          = 1613
+set CFL number                             = 1.0
+set Pressure normalization                 = no
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2e5
+    set X repetitions = 2
+    set Y extent = 1e5
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = function
+
+  # box prescribes a constant temp, function is for a function
+  subsection Function
+    set Function expression = if(y<5e4,1613,273)
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom
+  set Prescribed velocity boundary indicators = left x: function, right x: function
+
+  subsection Function
+    set Function expression = if(x>0, 1e-2 , -1e-2); 0
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = top: free surface
+  set Additional tangential mesh velocity boundary indicators = left,right
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.8
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density     = 3300
+    set Thermal conductivity  = 3.3
+    set Thermal expansion coefficient  = 3e-5
+    set Reference specific heat        = 1200
+    set Viscosity             = 1e21
+    set Reference temperature = 1600
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Strategy                           = strain rate, topography
+end
+
+# After 1 My, the model domain volume should have shrunk from 2e10 m2
+# to 1.8 m2 because of the prescribed outflow in combination
+# with a free surface.
+subsection Postprocess
+  set List of postprocessors = topography, domain volume statistics
+end
diff --git a/tests/free_surface_tangential_mesh_velocity_2.prm.bak b/tests/free_surface_tangential_mesh_velocity_2.prm.bak
new file mode 100644
index 00000000000..b8a59f51870
--- /dev/null
+++ b/tests/free_surface_tangential_mesh_velocity_2.prm.bak
@@ -0,0 +1,83 @@
+# A copy of free_surface_tangential_mesh_velocity that has tangential
+# mesh velocity constraints on the same boundary as prescribed constraints
+# (in this case a free surface).
+
+set Dimension                              = 2
+set End time                               = 1e6
+set Use years in output instead of seconds = true
+set Output directory                       = output
+set Adiabatic surface temperature          = 1613
+set CFL number                             = 1.0
+set Pressure normalization                 = no
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2e5
+    set X repetitions = 2
+    set Y extent = 1e5
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = top: free surface
+  set Additional tangential mesh velocity boundary indicators = left,right, top
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = function
+
+  subsection Function
+    set Function expression = if(y<5e4,1613,273)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+
+  subsection Function
+    set Function expression = if(x>0, 1e-2 , -1e-2); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.8
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density     = 3300
+    set Thermal conductivity  = 3.3
+    set Thermal expansion coefficient  = 3e-5
+    set Reference specific heat        = 1200
+    set Viscosity             = 1e21
+    set Reference temperature = 1600
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Strategy                           = strain rate, topography
+end
+
+subsection Postprocess
+  set List of postprocessors = topography
+end
diff --git a/tests/free_surface_timestep_repeat.prm.bak b/tests/free_surface_timestep_repeat.prm.bak
new file mode 100644
index 00000000000..c5a69ff7dfe
--- /dev/null
+++ b/tests/free_surface_timestep_repeat.prm.bak
@@ -0,0 +1,176 @@
+# This test is based on
+# /benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm
+# and checks that we can repeat time steps with mesh deformation enabled.
+
+#  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 2
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set CFL number                             = 0.001
+set Maximum time step                      = 1
+set Output directory                       = output_free_surface_VE_cylinder_2D_loading-repeat
+set Timing output frequency                = 10
+set Pressure normalization                 = no
+
+subsection Time stepping
+  set List of model names = convection time step, repeat on cutback
+  set Minimum time step size = 0.5
+
+  subsection Repeat on cutback
+    set Relative repeat threshold = 0.99
+  end
+end
+
+# Model geometry (500x500 km, 50 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 500e3
+    set Y extent      = 500e3
+  end
+end
+
+# Mesh refinement specifications
+# Mesh refinement does not seem to affect
+# deformation of free surface (at least in 2-D).
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Time steps between mesh refinement = 1
+  set Strategy         = strain rate
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Mesh deformation
+  set Additional tangential mesh velocity boundary indicators = left,right
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Surface velocity projection      = normal
+  end
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+end
+
+# Prescribe a fixed vertical traction on the top boundary
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = top y: function
+
+  subsection Function
+    set Variable names = x,y,t
+
+    #set Function expression = 0; 1.e9 + -20.e3*x
+    set Function constants  = r0=100.e3, H0=1.e3, t1=1.e3, rhoi=900, g=9.8, t0=1.e3
+
+    # r0 is load radius, H0 is load height, t1 is time load is fully removed,
+    # rhoi is density of ice/load
+    # option to linearly thin load beginning at time t0.
+    set Function expression = 0; if (x<r0 ,if(t<t0,-g*H0*rhoi,if(t<t1,-g*H0*rhoi*(1-(t-t0)/t1),0)), 0)
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0;
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = true
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# Temperature initial conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 3300
+    set Viscosities                 = 3.e20
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 3
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.8
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate
+    set Time between graphical output = 2
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+
+  subsection Topography
+    set Output to file = true
+    set Time between text output = 2
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/tests/function_mesh_deformation_tangential_mesh_velocity.prm.bak b/tests/function_mesh_deformation_tangential_mesh_velocity.prm.bak
new file mode 100644
index 00000000000..151ba67ed17
--- /dev/null
+++ b/tests/function_mesh_deformation_tangential_mesh_velocity.prm.bak
@@ -0,0 +1,86 @@
+# This test prescribes a surface motion going from
+# 1000 m per million year on the left to -1000 m
+# on the right, thus keeping the overall domain area
+# fixed.
+set Dimension                              = 2
+set End time                               = 5e5
+set Maximum time step                      = 1e4
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1613
+set CFL number                             = 1.0
+set Pressure normalization                 = surface
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2e5
+    set X repetitions = 2
+    set Y extent = 1e5
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = function
+
+  subsection Function
+    set Function expression = if(y<5e4,1613,273)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+  set Zero velocity boundary indicators       = left, right
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = top: boundary function
+
+  # The left and right boundary are allowed to move,
+  # even though the Stokes velocity is zero along these boundaries.
+  set Additional tangential mesh velocity boundary indicators = left,right
+
+  # Prescribe a boundary velocity in m/s equal to max 1000 m/My
+  subsection Boundary function
+    set Variable names      = x,y,t
+    set Function expression = 0;  -3.168808781e-16*(x-1e5)
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.8
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density     = 3300
+    set Thermal conductivity  = 3.3
+    set Thermal expansion coefficient  = 3e-5
+    set Reference specific heat        = 1200
+    set Viscosity             = 1e21
+    set Reference temperature = 1600
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Strategy                           = strain rate, topography
+end
+
+subsection Postprocess
+  # After 1 My, min/max topography should be -1000/1000 m.
+  set List of postprocessors = topography
+end
diff --git a/tests/gaussian_initial_temperature.prm.bak b/tests/gaussian_initial_temperature.prm.bak
new file mode 100644
index 00000000000..13a0d7dab7a
--- /dev/null
+++ b/tests/gaussian_initial_temperature.prm.bak
@@ -0,0 +1,81 @@
+# Test the spherical gaussian perturbation initial temperature model
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+
+  #  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 360
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Additional refinement times              =
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Initial temperature model
+  set Model name = spherical gaussian perturbation
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/geoid.prm.bak b/tests/geoid.prm.bak
new file mode 100644
index 00000000000..06cb3e1f802
--- /dev/null
+++ b/tests/geoid.prm.bak
@@ -0,0 +1,101 @@
+# A simple pure math setup to compute geoid in single degree 2 order 0 perturbation density field.
+# The perturbation is added to a constant density, i.e., degree 0 order 0 component.
+# The analytic solution of the density integral contribution of this case should be -0.53059320038
+# for (2,0) component and 14.1570019498 for degree 0 order 0, and the sum up of the spherical harmonics
+# of dynamic topography should be the same as the grid output in dynamic topography postprocessor.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+set Adiabatic surface temperature          = 0.0
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 0.1
+    set Viscosity                     = 1.0
+    set Thermal conductivity          = 1.0
+    set Reference temperature         = 0.0
+    set Reference density             = 1.0
+    set Reference specific heat       = 1.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 200000
+    set Outer radius  = 400000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner,outer
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = angular momentum
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Function constants = pi=3.1415926536
+    set Variable names = r,phi,theta,t
+    set Function expression = (5/2)*sqrt(5/pi)*(3*(cos(theta))^2-1)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.8
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 0
+  set Strategy                           = density
+end
+
+subsection Postprocess
+  set List of postprocessors = basic statistics, geoid, dynamic topography
+
+  subsection Dynamic topography
+    set Density above = 0.
+    set Density below = 2.0
+  end
+
+  subsection Geoid
+    set Maximum degree = 10
+    set Minimum degree = 0
+    set Output data in geographical coordinates = true
+    set Density above = 0
+    set Density below = 2.0
+    set Also output the spherical harmonic coefficients of geoid anomaly = true
+    set Also output the spherical harmonic coefficients of surface dynamic topography contribution = true
+    set Also output the spherical harmonic coefficients of CMB dynamic topography contribution = true
+    set Also output the spherical harmonic coefficients of density anomaly contribution = true
+    set Include surface topography contribution = true
+    set Include CMB topography contribution = true
+    set Also output the gravity anomaly  = true
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/geoid_freesurface.prm.bak b/tests/geoid_freesurface.prm.bak
new file mode 100644
index 00000000000..4b5452ae735
--- /dev/null
+++ b/tests/geoid_freesurface.prm.bak
@@ -0,0 +1,116 @@
+# A simple setup to compute geoid in single degree 2 order 0 perturbation density field.
+# The perturbation is added to a constant density, i.e., degree 0 order 0 component.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 1
+set Adiabatic surface temperature          = 0.0
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Pressure normalization                 = no
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 0.1
+    set Viscosity                     = 1.0
+    set Thermal conductivity          = 1.0
+    set Reference temperature         = 0.0
+    set Reference density             = 1.0
+    set Reference specific heat       = 1.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 200000
+    set Outer radius = 400000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner
+end
+
+subsection Nullspace removal
+  set Remove nullspace = angular momentum
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Function constants = pi=3.1415926536
+    set Variable names = r,phi,theta,t
+    set Function expression = (5/2)*sqrt(5/pi)*(3*(cos(theta))^2-1)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.8
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+  set Strategy                           = density
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = outer: free surface
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = basic statistics, geoid, dynamic topography, topography
+
+  subsection Topography
+    set Output to file = true
+  end
+
+  subsection Dynamic topography
+    set Density above = 0.
+    set Density below = 2.0
+  end
+
+  subsection Geoid
+    set Include surface topography contribution = true
+    set Include CMB topography contribution = true
+    set Maximum degree = 10
+    set Minimum degree = 0
+    set Output data in geographical coordinates = true
+    set Density above = 0
+    set Density below = 2.0
+    set Output geoid anomaly coefficients = true
+    set Output surface topography contribution coefficients = true
+    set Output CMB topography contribution coefficients = true
+    set Output density anomaly contribution coefficients = true
+    set Output gravity anomaly = true
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 1
+end
diff --git a/tests/geoid_no_topo.prm.bak b/tests/geoid_no_topo.prm.bak
new file mode 100644
index 00000000000..3eb6a7daca7
--- /dev/null
+++ b/tests/geoid_no_topo.prm.bak
@@ -0,0 +1,89 @@
+# A simple pure math setup to compute geoid in single degree 2 order 0 perturbation density field.
+# The perturbation is added to a constant density, i.e., degree 0 order 0 component.
+# The analytic solution of the density integral contribution of this case should be -0.53059320038
+# for (2,0) component and 14.1570019498 for degree 0 order 0.
+# The contribution from dynamic topography is not included.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+set Adiabatic surface temperature          = 0.0
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 0.1
+    set Reference temperature         = 0.0
+    set Reference density             = 1.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 200000
+    set Outer radius  = 400000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner,outer
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = angular momentum
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Function constants = pi=3.1415926536
+    set Variable names = r,phi,theta,t
+    set Function expression = (5/2)*sqrt(5/pi)*(3*(cos(theta))^2-1)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.8
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 0
+  set Strategy                           = density
+end
+
+subsection Postprocess
+  set List of postprocessors = geoid
+
+  subsection Geoid
+    set Maximum degree = 10
+    set Minimum degree = 0
+    set Output data in geographical coordinates = true
+    set Also output the spherical harmonic coefficients of geoid anomaly = true
+    set Also output the spherical harmonic coefficients of density anomaly contribution = true
+    set Include surface topography contribution = false
+    set Include CMB topography contribution = false
+    set Also output the gravity anomaly  = true
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/geoid_visualization.prm.bak b/tests/geoid_visualization.prm.bak
new file mode 100644
index 00000000000..25bea323052
--- /dev/null
+++ b/tests/geoid_visualization.prm.bak
@@ -0,0 +1,104 @@
+# A test for the geoid visualization postprocessor.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+set Adiabatic surface temperature          = 0.0
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 1.0e-1
+    set Viscosity                     = 1.0
+    set Thermal conductivity          = 1.0
+    set Reference temperature         = 0.0
+    set Reference density             = 1.0
+    set Reference specific heat       = 1.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 200000
+    set Outer radius  = 400000
+    set Cells along circumference = 12
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner,outer
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = angular momentum
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Function constants = pi=3.1415926536
+    set Variable names = r,phi,theta,t
+    set Function expression = (5/2)*sqrt(5/pi)*(3*(cos(theta))^2-1)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.8
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = geoid
+    set Output format = gnuplot
+  end
+
+  subsection Geoid
+    set Maximum degree = 10
+    set Minimum degree = 0
+    set Output data in geographical coordinates = true
+    set Density above = 0
+    set Density below = 2.0
+    set Also output the spherical harmonic coefficients of geoid anomaly = false
+    set Also output the spherical harmonic coefficients of surface dynamic topography contribution = false
+    set Also output the spherical harmonic coefficients of CMB dynamic topography contribution = false
+    set Also output the spherical harmonic coefficients of density anomaly contribution = false
+    set Include surface topography contribution = true
+    set Include CMB topography contribution = true
+  end
+
+  subsection Dynamic topography
+    set Density above = 0.
+    set Density below = 2.0
+    set Output surface = false
+    set Output bottom = false
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/geometric_average_crash.prm.bak b/tests/geometric_average_crash.prm.bak
new file mode 100644
index 00000000000..f61cdf27366
--- /dev/null
+++ b/tests/geometric_average_crash.prm.bak
@@ -0,0 +1,59 @@
+# document crash/FPE that happens when doing geometric averaging
+# with viscosities in 3d (due to an overflow)
+
+set Dimension                               = 3
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius      = 1
+    set Chunk outer radius      = 2
+    set Chunk minimum latitude  = 37
+    set Chunk maximum latitude  = 49
+    set Chunk minimum longitude = -132
+    set Chunk maximum longitude = -116
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names    = initial temperature
+  set Fixed temperature boundary indicators     = inner, outer
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators   = outer
+  set Zero velocity boundary indicators         = inner
+end
+
+subsection Material model
+  set Material averaging    = geometric average
+  set Model name            = simple
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 1e6
+    set Age top boundary layer = 5e6
+    set Amplitude = 100
+    set Position = center
+    set Radius = 100e3
+    set Subadiabaticity = 0
+  end
+end
+
+subsection Gravity model
+  set Model name    = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement             = 3
+  set Initial adaptive refinement           = 0
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 0
+end
diff --git a/tests/geometric_average_only_viscosity.prm.bak b/tests/geometric_average_only_viscosity.prm.bak
new file mode 100644
index 00000000000..86c74bbf8ec
--- /dev/null
+++ b/tests/geometric_average_only_viscosity.prm.bak
@@ -0,0 +1,80 @@
+# This is a setup to test geometric averaging of the viscosity
+# and that it works with the GMG.
+# The viscosity in the model decreases exponentially from left to
+# right from 1e14 Pa s to 1e10 Pa s. The model has two cells, so
+# using the geometric average only for the viscosity should lead
+# to a viscosity of 1e11 in the cells on the left and 1e13 in the
+# cells on the right.
+
+set Dimension                              = 2
+set End time                               = 0
+set Adiabatic surface temperature          = 100
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100
+    set Y extent = 100
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = 200 - x
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom, left, right
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = geometric average only viscosity
+
+  subsection Simple model
+    set Viscosity = 1e14
+    set Thermal viscosity exponent = 9.210340372 #ln(10000)
+    set Reference temperature = 100
+    set Minimum thermal prefactor = 1e-6
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables      = material properties
+    set Interpolate output            = false
+  end
+end
diff --git a/tests/global_latent_heat.prm.bak b/tests/global_latent_heat.prm.bak
new file mode 100644
index 00000000000..d2c348ce691
--- /dev/null
+++ b/tests/global_latent_heat.prm.bak
@@ -0,0 +1,159 @@
+# This is a test for the latent heat of melt heating model
+# and its interaction with other heating plugins.
+# A constant heating rate is described using the function
+# heating model, and this heating should lead to melting
+# of approximately 0.01/s (so that the maximum porosity at
+# the end of the model run (t=1s) should be approximately
+# 1%. In practice, this value is slightly lower because
+# some heat is also used to increase the temperature of
+# the material.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 1
+set Maximum time step                      = 0.01
+set Output directory                       = output_latent_heat
+set Nonlinear solver scheme                = single Advection, no Stokes
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1000
+set Use operator splitting = true
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Function expression = 0;0
+  end
+
+  subsection Pressure function
+    set Function expression = 0
+  end
+
+  subsection Fluid pressure function
+    set Function expression = 0
+  end
+
+  subsection Compaction pressure function
+    set Function expression = 0
+  end
+
+  subsection Fluid velocity function
+    set Function expression = 0;0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields  = porosity, peridotite
+end
+
+subsection Melt settings
+  set Include melt transport               = true
+  set Melt scaling factor threshold        = 1e-8
+  set Use discontinuous compaction pressure = false
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = amplitude=500, width=50000, b=100000
+    set Function expression = 1000
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 0; 0
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       =
+  set Prescribed velocity boundary indicators =
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+  set List of model names = initial composition
+end
+
+subsection Heating model
+  set List of model names = latent heat melt, function
+
+  subsection Latent heat melt
+    set Melting entropy change = -1000
+  end
+
+  subsection Function
+    set Function expression = 1e4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Thermal conductivity          = 0
+    set Reference shear viscosity     = 5e22
+    set Thermal viscosity exponent    = 0
+    set Exponential melt weakening factor    = 0
+    set Include melting and freezing  = true
+    set Melting time scale for operator splitting = 0.0005
+    set Thermal expansion coefficient = 0
+    set Reference specific heat       = 100
+    set Reference temperature         = 1000
+    set Reference solid density       = 1000
+    set Reference melt density        = 1000
+    set Depletion solidus change      = 0
+    set Pressure solidus change       = 0
+    set Surface solidus               = 1000
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Minimum refinement level                 = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, composition statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set List of output variables = material properties, nonadiabatic temperature, melt fraction
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity,reaction terms
+    end
+  end
+end
diff --git a/tests/global_melt.prm.bak b/tests/global_melt.prm.bak
new file mode 100644
index 00000000000..c6fc81f113e
--- /dev/null
+++ b/tests/global_melt.prm.bak
@@ -0,0 +1,216 @@
+# Listing of Parameters
+# ---------------------
+# Test for melt migration in a global-scale model
+
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 1.0
+set Maximum time step                      = 1e6
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = with_melt
+set Max nonlinear iterations               = 4
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 5e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.2
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3700
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = #2,3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+
+  subsection Function
+    set Function constants  = b=100000, c=20000
+    set Variable names      = x,y
+    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 8700000
+    set Y extent = 2900000
+
+    #    set X periodic = true
+    set X repetitions = 3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 5e8
+    set Age top boundary layer    = 3e8
+    set Amplitude                 = 50
+    set Position                  = center
+    set Radius                    = 350000
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+
+  subsection Harmonic perturbation
+    set Magnitude = 50
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,a = 0.0, b = 2500000, c = 100000, d=1450000
+    set Function expression = a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c)); a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Reference melt density            = 3000
+    set Thermal expansion coefficient     = 2e-5
+    set Reference permeability            = 1e-8
+    set Reference shear viscosity         = 5e21
+    set Reference bulk viscosity          = 1e19
+    set Exponential melt weakening factor = 10
+    set Thermal viscosity exponent        = 7
+    set Thermal bulk viscosity exponent   = 7
+    set Reference temperature             = 1600
+    set Solid compressibility             = 4.2e-12
+    set Melt compressibility              = 1.25e-11
+    set Reference melt viscosity          = 10
+    set Depletion density change          = -200.0 # -100.0 # 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 3
+  set Strategy                                 = composition threshold, minimum refinement function #, nonadiabatic temperature
+  set Time steps between mesh refinement       = 0
+
+  subsection Minimum refinement function
+    set Coordinate system   = depth
+    set Function expression = if (depth>1500000,5,4)
+    set Variable names      = depth,phi
+  end
+
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-4,1.0
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating #, latent heat melt, shear heating
+end
+
+subsection Nullspace removal
+  #  set Remove nullspace                        = net x translation
+
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Interpolate output            = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+
+  subsection Depth average
+    set Number of zones = 12
+    set Time between graphical output = 6e5
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint = 1700
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-14
+  set Temperature solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/global_melt_parallel.prm.bak b/tests/global_melt_parallel.prm.bak
new file mode 100644
index 00000000000..05319e19fd4
--- /dev/null
+++ b/tests/global_melt_parallel.prm.bak
@@ -0,0 +1,214 @@
+# Listing of Parameters
+# ---------------------
+# Test for melt migration in a global-scale model
+
+# MPI: 2
+
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 1.0
+set Maximum time step                      = 1e6
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = with_melt
+set Max nonlinear iterations               = 4
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 5e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.2
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3700
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = #2,3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+
+  subsection Function
+    set Function constants  = b=100000, c=20000
+    set Variable names      = x,y
+    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 8700000
+    set Y extent = 2900000
+
+    #    set X periodic = true
+    set X repetitions = 3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 5e8
+    set Age top boundary layer    = 3e8
+    set Amplitude                 = 50
+    set Position                  = center
+    set Radius                    = 350000
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+
+  subsection Harmonic perturbation
+    set Magnitude = 50
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,a = 0.0, b = 2500000, c = 100000, d=1450000
+    set Function expression = a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c)); a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Reference melt density            = 3000
+    set Thermal expansion coefficient     = 2e-5
+    set Reference permeability            = 1e-8
+    set Reference shear viscosity         = 5e21
+    set Reference bulk viscosity          = 1e19
+    set Exponential melt weakening factor = 10
+    set Thermal viscosity exponent        = 7
+    set Thermal bulk viscosity exponent   = 7
+    set Reference temperature             = 1600
+    set Solid compressibility             = 4.2e-12
+    set Melt compressibility              = 1.25e-11
+    set Reference melt viscosity          = 10
+    set Depletion density change          = -200.0 # -100.0 # 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 3
+  set Strategy                                 = composition threshold, minimum refinement function #, nonadiabatic temperature
+  set Time steps between mesh refinement       = 0
+
+  subsection Minimum refinement function
+    set Coordinate system   = depth
+    set Function expression = if (depth>1500000,5,4)
+    set Variable names      = depth,phi
+  end
+
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-4,1.0
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating #, latent heat melt, shear heating
+end
+
+subsection Nullspace removal
+  #  set Remove nullspace                        = net x translation
+
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Interpolate output            = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+
+  subsection Depth average
+    set Number of zones = 12
+    set Time between graphical output = 6e5
+  end
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-14
+  set Temperature solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/global_refine_amr.cc.bak b/tests/global_refine_amr.cc.bak
new file mode 100644
index 00000000000..a98892ff04a
--- /dev/null
+++ b/tests/global_refine_amr.cc.bak
@@ -0,0 +1,105 @@
+/*
+  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/simulator_access.h>
+#include <math.h>
+
+
+using namespace dealii;
+
+
+namespace aspect
+{
+  template <int dim>
+  class AMRLeft : public MeshRefinement::Interface<dim>,
+    public SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * After cells have been marked for coarsening/refinement, apply
+       * additional criteria independent of the error estimate.
+       *
+       */
+      virtual
+      void
+      tag_additional_cells () const;
+
+      /**
+       * Declare the parameters this class takes through input files.
+       */
+      static
+      void
+      declare_parameters (ParameterHandler &prm);
+
+      /**
+       * Read the parameters this class declares from the parameter
+       * file.
+       */
+      virtual
+      void
+      parse_parameters (ParameterHandler &prm);
+
+    private:
+  };
+
+
+  template <int dim>
+  void
+  AMRLeft<dim>::tag_additional_cells () const
+  {
+    std::cout << "plugin is called!" << std::endl;
+
+    for (typename Triangulation<dim>::active_cell_iterator
+         cell = this->get_triangulation().begin_active();
+         cell != this->get_triangulation().end(); ++cell)
+      {
+        if (cell->is_locally_owned() && cell->center(true)[0]<0.5)
+          cell->clear_refine_flag ();
+      }
+  }
+
+  template <int dim>
+  void
+  AMRLeft<dim>::
+  declare_parameters (ParameterHandler &prm)
+  {
+  }
+
+  template <int dim>
+  void
+  AMRLeft<dim>::parse_parameters (ParameterHandler &prm)
+  {
+  }
+
+}
+
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(AMRLeft,
+                                            "AMRLeft",
+                                            "TODO")
+}
diff --git a/tests/global_refine_amr.prm.bak b/tests/global_refine_amr.prm.bak
new file mode 100644
index 00000000000..6101973eb68
--- /dev/null
+++ b/tests/global_refine_amr.prm.bak
@@ -0,0 +1,59 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+  set Strategy = AMRLeft
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/global_refine_bug.prm.bak b/tests/global_refine_bug.prm.bak
new file mode 100644
index 00000000000..95e52be5227
--- /dev/null
+++ b/tests/global_refine_bug.prm.bak
@@ -0,0 +1,74 @@
+# Simple setup showing a bug with global refinement
+#
+# When running a model with many MPI ranks and very few cells on each
+# rank, mesh smoothing would stop us from refining all cells correctly.
+# Here, we would have 1,444 DoFs with < 8 ranks and 1,418 with 8 ranks.
+#
+# MPI: 8
+
+set Dimension                              = 2
+set End time                               = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 5
+    set Y repetitions = 5
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+  end
+end
diff --git a/tests/gmg_mesh_deform.prm.bak b/tests/gmg_mesh_deform.prm.bak
new file mode 100644
index 00000000000..5dadb762b3f
--- /dev/null
+++ b/tests/gmg_mesh_deform.prm.bak
@@ -0,0 +1,18 @@
+# Test GMG with initial mesh deformation
+#
+# This test is a copy of
+
+include $ASPECT_SOURCE_DIR/tests/box_initial_mesh_deformation_ascii_data.prm
+
+set Dimension = 3
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/tests/gmg_mesh_deform_adaptive.prm.bak b/tests/gmg_mesh_deform_adaptive.prm.bak
new file mode 100644
index 00000000000..92cf731c7b1
--- /dev/null
+++ b/tests/gmg_mesh_deform_adaptive.prm.bak
@@ -0,0 +1,21 @@
+# Test GMG with mesh deformation with adaptive mesh refinement
+#
+# This test is based on
+include $ASPECT_SOURCE_DIR/tests/function_mesh_deformation_tangential_mesh_velocity.prm
+
+set Dimension = 2
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
+
+subsection Mesh refinement
+  set Time steps between mesh refinement = 5
+end
diff --git a/tests/gmg_mesh_deform_adaptive_bug.prm.bak b/tests/gmg_mesh_deform_adaptive_bug.prm.bak
new file mode 100644
index 00000000000..61bf6e56e08
--- /dev/null
+++ b/tests/gmg_mesh_deform_adaptive_bug.prm.bak
@@ -0,0 +1,25 @@
+# Test GMG with mesh deformation with adaptive mesh refinement
+# MPI: 4
+#
+# This test fails with dealii::MGLevelGlobalTransfer Dimension 2 not equal to 0.
+
+
+# This test is based on
+include $ASPECT_SOURCE_DIR/tests/function_mesh_deformation_tangential_mesh_velocity.prm
+
+set Dimension = 2
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
+
+subsection Mesh refinement
+  set Time steps between mesh refinement = 5
+end
diff --git a/tests/gmg_mesh_deform_adaptive_bug2.prm.bak b/tests/gmg_mesh_deform_adaptive_bug2.prm.bak
new file mode 100644
index 00000000000..e4d449d3c57
--- /dev/null
+++ b/tests/gmg_mesh_deform_adaptive_bug2.prm.bak
@@ -0,0 +1,139 @@
+# This test is a simplified 2d crustal extension problem with
+# a free surface an adaptive refinement. It would trigger a bug
+# with negative cell diagonals in the GMG preconditioner.
+
+set Dimension                                       = 2
+set Start time                                      = 0
+set End time                                        = 600000
+set Use years in output instead of seconds          = true
+set Nonlinear solver scheme                         = single Advection, iterated Stokes
+
+# This model is very sensitive to the nonlinear solver tolerance,
+# results still change slightly down to a tolerance of 1e-8, but
+# require much more resources than reasonable for a cookbook.
+set Nonlinear solver tolerance                      = 2e-6
+set Max nonlinear iterations                        = 100
+set CFL number                                      = 0.5
+set Output directory                                = output-crustal_model_2D
+set Timing output frequency                         = 1
+set Pressure normalization                          = no
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions  = 5
+    set X extent  = 80e3
+    set Y extent  = 16e3
+  end
+end
+
+# Advecting the free surface vertically rather than
+# in the surface normal direction can result in a
+# more stable mesh when the deformation is large
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+
+  subsection Free surface
+    set Surface velocity projection = vertical
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Densities = 2800
+    set Minimum viscosity = 1e22
+    set Maximum viscosity = 1e22
+    set Reference strain rate = 1e-20
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5e-22
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Angles of internal friction = 0.
+    set Cohesions                   = 20.e6
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left: function, right:function, bottom:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = cm=0.01, year=1
+    set Function expression =  if (x<40e3 , 1*cm/year, -1*cm/year) ; 0
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.95
+  set Strategy                           = strain rate
+  set Coarsening fraction                = 0.05
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics, material statistics, topography
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, error indicator, heating, partition
+    set Time between graphical output = 0
+    set Output mesh velocity = true
+  end
+
+  subsection Topography
+    set Output to file = false
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1e-6
+    set Number of cheap Stokes solver steps = 2000
+  end
+end
diff --git a/tests/gmg_mesh_deform_function.prm.bak b/tests/gmg_mesh_deform_function.prm.bak
new file mode 100644
index 00000000000..b1f4c4523ac
--- /dev/null
+++ b/tests/gmg_mesh_deform_function.prm.bak
@@ -0,0 +1,17 @@
+# Test GMG with mesh deformation prescribed by a changing function
+#
+# This test is a copy of
+include $ASPECT_SOURCE_DIR/tests/function_mesh_deformation_tangential_mesh_velocity.prm
+
+set Dimension = 2
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/tests/gmg_mesh_deform_ghost_entries.prm.bak b/tests/gmg_mesh_deform_ghost_entries.prm.bak
new file mode 100644
index 00000000000..d7af0deb1f2
--- /dev/null
+++ b/tests/gmg_mesh_deform_ghost_entries.prm.bak
@@ -0,0 +1,38 @@
+# Based on viscoelastic free surface benchmark (with free surface
+# disabled) to show a bug, where we did not include the correct ghost
+# entries for the MappingQEulerian
+# MPI: 3
+
+include $ASPECT_SOURCE_DIR/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm
+
+set Dimension                              = 2
+set End time = 10
+
+subsection Material model
+  set Model name = viscoelastic
+  set Material averaging = harmonic average only viscosity
+
+  subsection Viscoelastic
+    set Use fixed elastic time step = true
+    set Fixed elastic time step     = 1e2
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Mesh deformation
+  set Additional tangential mesh velocity boundary indicators = left,right
+  set Mesh deformation boundary indicators = top: boundary function
+
+  subsection Boundary function
+    set Variable names      = x,y,t
+    set Function expression = 0;  -3.168808781e-16*(x-1e5)
+  end
+end
diff --git a/tests/gmg_mesh_deform_prescribed.cc.bak b/tests/gmg_mesh_deform_prescribed.cc.bak
new file mode 100644
index 00000000000..a05d9059016
--- /dev/null
+++ b/tests/gmg_mesh_deform_prescribed.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "box_initial_mesh_deformation.cc"
diff --git a/tests/gmg_mesh_deform_prescribed.prm.bak b/tests/gmg_mesh_deform_prescribed.prm.bak
new file mode 100644
index 00000000000..6b5f9a1c93f
--- /dev/null
+++ b/tests/gmg_mesh_deform_prescribed.prm.bak
@@ -0,0 +1,17 @@
+# Test GMG with mesh deformation prescribed by a prescribed function
+#
+# This test is a copy of
+include $ASPECT_SOURCE_DIR/tests/box_initial_mesh_deformation.prm
+
+set Dimension = 2
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/tests/gmg_mesh_deform_topo.prm.bak b/tests/gmg_mesh_deform_topo.prm.bak
new file mode 100644
index 00000000000..2948e31282d
--- /dev/null
+++ b/tests/gmg_mesh_deform_topo.prm.bak
@@ -0,0 +1,109 @@
+# A modified 2d convection box with a prescribed, moving surface. The
+# oscillating sin wavee on the surface pushes the rising plume up and
+# down. This test was used to verify that matrix-based and matrix-free
+# give the same solution in a moving domain with mesh deformation.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.0024
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+  set Zero velocity boundary indicators       = left, right
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = top: boundary function
+
+  # The left and right boundary are allowed to move,
+  # even though the Stokes velocity is zero along these boundaries.
+  set Additional tangential mesh velocity boundary indicators = left,right
+
+  subsection Boundary function
+    set Variable names      = x,y,t
+    set Function expression = 0;  if (x<0.5, 1e+2*sin(x*2*3.14159)*cos(t/0.001), 0)
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e5   # = Ra
+  end
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, topography
+
+  subsection Visualization
+    set Time between graphical output = 0.0001
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance                         = 1e-7
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 200
+  end
+end
diff --git a/tests/gmg_no_normal_flux_only.prm.bak b/tests/gmg_no_normal_flux_only.prm.bak
new file mode 100644
index 00000000000..fd862c3bd09
--- /dev/null
+++ b/tests/gmg_no_normal_flux_only.prm.bak
@@ -0,0 +1,87 @@
+# 3d shell with GMG, tangential velocity boundary only
+# based on shell_3d_gmg.prm
+# MPI: 2
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0.0
+set Output directory                       = output-shell_simple_3d
+set Nonlinear solver scheme                = no Advection, single Stokes
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average only viscosity
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1973
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.473e3
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 1
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1.5e6
+    set Output format                 = vtu
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 50
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1e-4
+  end
+end
diff --git a/tests/gmg_test_project_q1.prm.bak b/tests/gmg_test_project_q1.prm.bak
new file mode 100644
index 00000000000..462c8aba92c
--- /dev/null
+++ b/tests/gmg_test_project_q1.prm.bak
@@ -0,0 +1,102 @@
+# test gmg + project to Q1 only viscosity
+set Dimension                              = 2
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+set Output directory                       = test
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 360
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3700
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Function
+    set Coordinate system   = spherical
+    set Variable names      = r, phi
+    set Function constants  = r0 = 3481000, r1 = 6371000
+    set Function expression = 30 * sin((r-r0)/(r1-r0)*pi)*sin(16*phi) + 20 * sin(2*(r-r0)/(r1-r0)*pi)*sin(12*phi)
+  end
+
+  subsection Adiabatic
+    set Age top boundary layer = 7e7
+    set Age bottom boundary layer = 1e8
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+  set Material averaging = project to Q1 only viscosity
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names              = pyr-ringwood88.txt
+    set Radial viscosity file name       = radial-visc-simple.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Use lateral average temperature for viscosity  = false
+    set Maximum viscosity                = 1.5e23
+    set Minimum viscosity                = 5e19
+    set Maximum lateral viscosity variation = 1e4
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set GMRES solver restart length = 200
+    set Number of cheap Stokes solver steps = 500
+  end
+
+  subsection Matrix Free
+    set Output details = true
+  end
+end
diff --git a/tests/gmg_velocity_boundary_2d_box_no_flux.prm.bak b/tests/gmg_velocity_boundary_2d_box_no_flux.prm.bak
new file mode 100644
index 00000000000..00c197b51e0
--- /dev/null
+++ b/tests/gmg_velocity_boundary_2d_box_no_flux.prm.bak
@@ -0,0 +1,100 @@
+set Dimension = 2
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 0
+set Output directory = output
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 273
+set Nonlinear solver scheme = single Advection, single Stokes
+set CFL number = 0.3
+set Timing output frequency = 1
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 6.7830e+06
+    set Y extent = 2.8900e6
+    set X repetitions = 2
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 1
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1, 3
+  set Zero velocity boundary indicators = 0, 2
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = bottom: 1673, top: 273
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0
+    set Heat capacities = 750.
+    set Densities = 3150
+    set Thermal expansivities = 0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = 1e-21
+    set Activation energies for diffusion creep = 0
+    set Activation volumes for diffusion creep = 0
+    set Grain size exponents for diffusion creep = 0
+    set Angles of internal friction = 0
+    set Cohesions = 1e15
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/gmg_velocity_boundary_2d_box_no_normal_flux.prm.bak b/tests/gmg_velocity_boundary_2d_box_no_normal_flux.prm.bak
new file mode 100644
index 00000000000..67f988d104e
--- /dev/null
+++ b/tests/gmg_velocity_boundary_2d_box_no_normal_flux.prm.bak
@@ -0,0 +1,99 @@
+set Dimension = 2
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 0
+set Output directory = output
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 273
+set Nonlinear solver scheme = single Advection, single Stokes
+set CFL number = 0.3
+set Timing output frequency = 1
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 6.7830e+06
+    set Y extent = 2.8900e6
+    set X repetitions = 2
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 1
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = bottom: 1673, top: 273
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0
+    set Heat capacities = 750.
+    set Densities = 3150
+    set Thermal expansivities = 0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = 1e-21
+    set Activation energies for diffusion creep = 0
+    set Activation volumes for diffusion creep = 0
+    set Grain size exponents for diffusion creep = 0
+    set Angles of internal friction = 0
+    set Cohesions = 1e15
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/gmg_velocity_boundary_2d_chunk_no_flux.prm.bak b/tests/gmg_velocity_boundary_2d_chunk_no_flux.prm.bak
new file mode 100644
index 00000000000..9bbb4c8e048
--- /dev/null
+++ b/tests/gmg_velocity_boundary_2d_chunk_no_flux.prm.bak
@@ -0,0 +1,103 @@
+set Dimension = 2
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 0
+set Output directory = output
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 273
+set Nonlinear solver scheme = single Advection, single Stokes
+set CFL number = 0.3
+set Timing output frequency = 1
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3.481e6
+    set Chunk outer radius = 6.371e6
+    set Chunk maximum longitude = 61.0
+    set Chunk minimum longitude = 0.0
+    set Longitude repetitions = 2
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 1
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1, 3
+  set Zero velocity boundary indicators = 0, 2
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1673
+    set Outer temperature = 273
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0
+    set Heat capacities = 750.
+    set Densities = 3150
+    set Thermal expansivities = 0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = 1e-21
+    set Activation energies for diffusion creep = 0
+    set Activation volumes for diffusion creep = 0
+    set Grain size exponents for diffusion creep = 0
+    set Angles of internal friction = 0
+    set Cohesions = 1e15
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/gmg_velocity_boundary_2d_chunk_no_normal_flux.prm.bak b/tests/gmg_velocity_boundary_2d_chunk_no_normal_flux.prm.bak
new file mode 100644
index 00000000000..edcee92ae6a
--- /dev/null
+++ b/tests/gmg_velocity_boundary_2d_chunk_no_normal_flux.prm.bak
@@ -0,0 +1,102 @@
+set Dimension = 2
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 0
+set Output directory = output
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 273
+set Nonlinear solver scheme = single Advection, single Stokes
+set CFL number = 0.3
+set Timing output frequency = 1
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3.481e6
+    set Chunk outer radius = 6.371e6
+    set Chunk maximum longitude = 61.0
+    set Chunk minimum longitude = 0.0
+    set Longitude repetitions = 2
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 1
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1673
+    set Outer temperature = 273
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0
+    set Heat capacities = 750.
+    set Densities = 3150
+    set Thermal expansivities = 0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = 1e-21
+    set Activation energies for diffusion creep = 0
+    set Activation volumes for diffusion creep = 0
+    set Grain size exponents for diffusion creep = 0
+    set Angles of internal friction = 0
+    set Cohesions = 1e15
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/gmg_velocity_boundary_3d_box_no_flux.prm.bak b/tests/gmg_velocity_boundary_3d_box_no_flux.prm.bak
new file mode 100644
index 00000000000..98af1d7b8f2
--- /dev/null
+++ b/tests/gmg_velocity_boundary_3d_box_no_flux.prm.bak
@@ -0,0 +1,103 @@
+set Dimension = 3
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 0
+set Output directory = output
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 273
+set Nonlinear solver scheme = single Advection, single Stokes
+set CFL number = 0.3
+set Timing output frequency = 1
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 6.7830e+06
+    set Y extent = 2.8900e6
+    set Z extent = 1.5000e6
+    set X repetitions = 4
+    set Y repetitions = 2
+    set Z repetitions = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 1
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 4, 5
+  set Zero velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = bottom: 1673, top: 273
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0
+    set Heat capacities = 750.
+    set Densities = 3150
+    set Thermal expansivities = 0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = 1e-21
+    set Activation energies for diffusion creep = 0
+    set Activation volumes for diffusion creep = 0
+    set Grain size exponents for diffusion creep = 0
+    set Angles of internal friction = 0
+    set Cohesions = 1e15
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/gmg_velocity_boundary_3d_box_no_normal_flux.prm.bak b/tests/gmg_velocity_boundary_3d_box_no_normal_flux.prm.bak
new file mode 100644
index 00000000000..7de9f17a45f
--- /dev/null
+++ b/tests/gmg_velocity_boundary_3d_box_no_normal_flux.prm.bak
@@ -0,0 +1,102 @@
+set Dimension = 3
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 0
+set Output directory = output
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 273
+set Nonlinear solver scheme = single Advection, single Stokes
+set CFL number = 0.3
+set Timing output frequency = 1
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 6.7830e+06
+    set Y extent = 2.8900e6
+    set Z extent = 1.5000e6
+    set X repetitions = 4
+    set Y repetitions = 2
+    set Z repetitions = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 1
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3, 4, 5
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = constant
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = bottom: 1673, top: 273
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0
+    set Heat capacities = 750.
+    set Densities = 3150
+    set Thermal expansivities = 0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = 1e-21
+    set Activation energies for diffusion creep = 0
+    set Activation volumes for diffusion creep = 0
+    set Grain size exponents for diffusion creep = 0
+    set Angles of internal friction = 0
+    set Cohesions = 1e15
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/gmg_velocity_boundary_3d_chunk_no_flux.prm.bak b/tests/gmg_velocity_boundary_3d_chunk_no_flux.prm.bak
new file mode 100644
index 00000000000..74459ad909a
--- /dev/null
+++ b/tests/gmg_velocity_boundary_3d_chunk_no_flux.prm.bak
@@ -0,0 +1,106 @@
+set Dimension = 3
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 0
+set Output directory = output
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 273
+set Nonlinear solver scheme = single Advection, single Stokes
+set CFL number = 0.3
+set Timing output frequency = 1
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3.481e6
+    set Chunk outer radius = 6.371e6
+    set Chunk maximum longitude = 61.0
+    set Chunk minimum longitude = 0.0
+    set Chunk maximum latitude = 61.0
+    set Chunk minimum latitude = 0.0
+    set Longitude repetitions = 2
+    set Latitude repetitions = 2
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 1
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 4, 5
+  set Zero velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1673
+    set Outer temperature = 273
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0
+    set Heat capacities = 750.
+    set Densities = 3150
+    set Thermal expansivities = 0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = 1e-21
+    set Activation energies for diffusion creep = 0
+    set Activation volumes for diffusion creep = 0
+    set Grain size exponents for diffusion creep = 0
+    set Angles of internal friction = 0
+    set Cohesions = 1e15
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/gmg_velocity_boundary_3d_chunk_no_normal_flux.prm.bak b/tests/gmg_velocity_boundary_3d_chunk_no_normal_flux.prm.bak
new file mode 100644
index 00000000000..8cd2a715f2d
--- /dev/null
+++ b/tests/gmg_velocity_boundary_3d_chunk_no_normal_flux.prm.bak
@@ -0,0 +1,105 @@
+set Dimension = 3
+set Use years in output instead of seconds = true
+set Start time = 0
+set End time = 0
+set Output directory = output
+set Pressure normalization = surface
+set Surface pressure = 0
+set Adiabatic surface temperature = 273
+set Nonlinear solver scheme = single Advection, single Stokes
+set CFL number = 0.3
+set Timing output frequency = 1
+
+subsection Discretization
+  set Composition polynomial degree = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree = 2
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3.481e6
+    set Chunk outer radius = 6.371e6
+    set Chunk maximum longitude = 61.0
+    set Chunk minimum longitude = 0.0
+    set Chunk maximum latitude = 61.0
+    set Chunk minimum latitude = 0.0
+    set Longitude repetitions = 2
+    set Latitude repetitions = 2
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+  set Initial global refinement = 1
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3, 4, 5
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1673
+    set Outer temperature = 273
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-15
+    set Minimum viscosity = 1e21
+    set Maximum viscosity = 1e25
+    set Viscosity averaging scheme = harmonic
+    set Thermal diffusivities = 0
+    set Heat capacities = 750.
+    set Densities = 3150
+    set Thermal expansivities = 0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = 1e-21
+    set Activation energies for diffusion creep = 0
+    set Activation volumes for diffusion creep = 0
+    set Grain size exponents for diffusion creep = 0
+    set Angles of internal friction = 0
+    set Cohesions = 1e15
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/gmg_velocity_boundary_component.prm.bak b/tests/gmg_velocity_boundary_component.prm.bak
new file mode 100644
index 00000000000..7d42918f5c4
--- /dev/null
+++ b/tests/gmg_velocity_boundary_component.prm.bak
@@ -0,0 +1,20 @@
+# Test that GMG can deal with velocity boundary conditions of the form [xyz]:
+#
+# Test is identical to:
+include $ASPECT_SOURCE_DIR/tests/ascii_data_boundary_velocity_2d_box_list.prm
+
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: ascii data,right: ascii data, left x: function, right: function
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/tests/gplates_1_3.prm.bak b/tests/gplates_1_3.prm.bak
new file mode 100644
index 00000000000..09fcd75ee16
--- /dev/null
+++ b/tests/gplates_1_3.prm.bak
@@ -0,0 +1,78 @@
+# A simple setup for for using the GPlates interface in a 2d shell.
+# This test uses the grid produced by GPlates 1.3
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output
+set Adiabatic surface temperature          = 1600
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e22
+    set Thermal viscosity exponent    = 5.0
+    set Reference temperature         = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 1:gplates
+  set Tangential velocity boundary indicators = 0
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+    set Lithosphere thickness = 660000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/gplates_1_4.prm.bak b/tests/gplates_1_4.prm.bak
new file mode 100644
index 00000000000..0158a7e15f9
--- /dev/null
+++ b/tests/gplates_1_4.prm.bak
@@ -0,0 +1,81 @@
+# A simple setup for for using the GPlates interface in a 2d shell.
+# This test uses the grid produced by GPlates 1.4.
+# The result is identical to the GPlates 1.3 test, which ensures
+# that the correction for the mesh changes between these versions
+# does work properly.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output
+set Adiabatic surface temperature          = 1600
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e22
+    set Thermal viscosity exponent    = 5.0
+    set Reference temperature         = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 1:gplates
+  set Tangential velocity boundary indicators = 0
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day_1.4.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+    set Lithosphere thickness = 660000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/gplates_3d.prm.bak b/tests/gplates_3d.prm.bak
new file mode 100644
index 00000000000..db1f8299282
--- /dev/null
+++ b/tests/gplates_3d.prm.bak
@@ -0,0 +1,77 @@
+# A simple setup for for using the GPlates interface in a 3d shell.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output
+set Adiabatic surface temperature          = 1600
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e22
+    set Thermal viscosity exponent    = 5.0
+    set Reference temperature         = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 1:gplates
+  set Tangential velocity boundary indicators = 0
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day_1.4.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+    set Lithosphere thickness = 660000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, velocity boundary statistics
+end
diff --git a/tests/gplates_rotation.prm.bak b/tests/gplates_rotation.prm.bak
new file mode 100644
index 00000000000..98c8d6af4f2
--- /dev/null
+++ b/tests/gplates_rotation.prm.bak
@@ -0,0 +1,77 @@
+# A simple setup for for using the GPlates interface in a 2d shell.
+# This tests the rotation functionality of a 2D model.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output
+set Adiabatic surface temperature          = 1600
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e22
+    set Thermal viscosity exponent    = 5.0
+    set Reference temperature         = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 1:gplates
+  set Tangential velocity boundary indicators = 0
+
+  subsection GPlates model
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Point one = 1.0,1.87
+    set Point two = 2.0,5.24
+    set Lithosphere thickness = 660000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/gplates_scale_factor.prm.bak b/tests/gplates_scale_factor.prm.bak
new file mode 100644
index 00000000000..e9fbeca50af
--- /dev/null
+++ b/tests/gplates_scale_factor.prm.bak
@@ -0,0 +1,84 @@
+# A simple setup for for using the GPlates interface in a 2d shell.
+# This test is a copy of the gplates_1_4 test but uses a different
+# scaling factor to make sure that velocities are scaled correctly.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output
+set Adiabatic surface temperature          = 1600
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e22
+    set Thermal viscosity exponent    = 5.0
+    set Reference temperature         = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 1:gplates
+  set Tangential velocity boundary indicators = 0
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day_1.4.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+    set Lithosphere thickness = 660000
+    set Scale factor = 2
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/grain_lag_angle.prm.bak b/tests/grain_lag_angle.prm.bak
new file mode 100644
index 00000000000..777c3ce69aa
--- /dev/null
+++ b/tests/grain_lag_angle.prm.bak
@@ -0,0 +1,102 @@
+# 2D model for half of a mid-ocean ridge
+# for testing the grain lag angle postprocessor
+# based on the mid-ocean ridge cookbook, with a few simplifications
+
+set Dimension = 2
+set End time = 5e5
+set Adiabatic surface temperature = 1570
+
+# geometry
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 105000
+    set Y extent  = 70000
+    set X repetitions  = 3
+    set Y repetitions  = 2
+  end
+end
+
+# gravity
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# boundary velocity
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function
+  set Tangential velocity boundary indicators = left
+
+  subsection Function
+    set Function constants  = u0=0.05, x0=10000, xc=52500
+    set Variable names  = x,z
+    set Function expression  = if(x<x0,(1-(x/x0-1)*(x/x0-1))*u0,u0); 0
+  end
+end
+
+# boundary traction
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Representative point  = 105000, 7000
+  end
+end
+
+# initial temperature
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer  = 1e8
+    set Age bottom boundary layer  = 1e5
+    set Amplitude      = 0
+  end
+end
+
+# boundary temperature
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 293
+    set Bottom temperature = 1570
+  end
+end
+
+# material
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 4.7
+    set Reference density = 3400
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity = 5e21
+    set Thermal viscosity exponent = 7
+    set Reference temperature = 1570
+  end
+end
+
+# mesh refinement
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# postprocessing
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables = grain lag angle
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/grain_size_additional_outputs.prm.bak b/tests/grain_size_additional_outputs.prm.bak
new file mode 100644
index 00000000000..9dfa3a89581
--- /dev/null
+++ b/tests/grain_size_additional_outputs.prm.bak
@@ -0,0 +1,24 @@
+# Like grain_size_growth.prm, but check that additional
+# material model outputs can be postprocessed correctly.
+
+############### Global parameters
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
+
+set End time = 0
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = named additional outputs
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/grain_size_averaging.prm.bak b/tests/grain_size_averaging.prm.bak
new file mode 100644
index 00000000000..81ccaeb3b1c
--- /dev/null
+++ b/tests/grain_size_averaging.prm.bak
@@ -0,0 +1,16 @@
+# A test for the grain size material model with the GMG
+# solver. We want to make sure no floating point exceptions
+# are thrown when material properties are averaged.
+
+include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
+
+
+subsection Material model
+  set Material averaging = geometric average only viscosity
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/tests/grain_size_crossed_transition.prm.bak b/tests/grain_size_crossed_transition.prm.bak
new file mode 100644
index 00000000000..432e73f0346
--- /dev/null
+++ b/tests/grain_size_crossed_transition.prm.bak
@@ -0,0 +1,172 @@
+# A test for the grain size material model to see if the grain
+# size is reset correctly after crossing a phase transition.
+# The model contains a phase transition in the middle at 50 km depth
+# where the grain size is reset to 1 mm (from the initial value of
+# 2 mm). The vertical component of the velocity prescribed at the top
+# and bottom boundary is a sine wave, so that in the left half of
+# the model, grain size is reset above the transition, and in the
+# right half it is reset below the phase transition.
+
+set Dimension                              = 2
+set End time                               = 10000
+set Use years in output instead of seconds = true
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 300000
+    set Y extent = 100000
+    set X periodic = true
+    set X repetitions = 3
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top,bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 1600
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function, bottom:function
+
+  subsection Function
+    set Function expression = 0.1; sin(x/300000*2*pi)
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 0
+
+    subsection Function
+      set Function expression       = 0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  =
+    set Function expression = 2e-3
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+  set Compositional field methods = particles
+  set Types of fields = grain size
+  set Mapped particle properties = grain_size:grain_size
+end
+
+subsection Material model
+  set Model name = grain size
+  set Material averaging = none
+
+  subsection Grain size model
+    set Reference density                    = 3400
+    set Thermal conductivity                 = 0
+    set Thermal expansion coefficient        = 0
+    set Reference compressibility            = 0
+    set Viscosity                            = 1e19
+    set Minimum viscosity                    = 1e16
+    set Reference temperature                = 1600
+    set Grain growth activation energy       = 4e5, 4e5
+    set Grain growth activation volume       = 0, 0
+    set Grain growth rate constant           = 0, 0
+    set Grain growth exponent                = 3, 3
+    set Average specific grain boundary energy = 1, 1
+    set Work fraction for boundary area change = 0.1, 0.1
+    set Geometric constant                   = 3, 3
+    set Grain size evolution formulation     = paleowattmeter
+    set Reciprocal required strain           = 10
+    set Phase transition depths              = 50000
+    set Phase transition Clapeyron slopes    = 1e6
+    set Phase transition temperatures        = 1600
+    set Phase transition widths              = 0
+    set Recrystallized grain size            = 1e-3
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 3.0e-016, 3.0e-016 # s^-1 Pa^-1 m^p
+    set Diffusion creep exponent             = 1, 1 # 1 for diffusion creep
+    set Diffusion creep grain size exponent  = 3, 3
+    set Diffusion activation energy          = 3.75e5, 3.75e5 #J/mol
+    set Diffusion activation volume          = 0, 0 # m^3/mol (from Karato 2010)
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # No dislocation creep
+    set Dislocation creep prefactor          = 1e-200, 1e-200 # s^-1 Pa^-n
+    set Dislocation creep exponent           = 1, 1
+    set Dislocation activation energy        = 0, 0 # J/mol
+    set Dislocation activation volume        = 0, 0 # m^3/mol
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Variable names = depth, nothing
+    set Function expression = if(depth>40000 && depth <60000, 4, 2)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, particles
+
+  subsection Visualization
+    set List of output variables  = material properties
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Time between data output = 0
+  end
+end
+
+subsection Particles
+  set List of particle properties = grain size
+  set Particle generator name = probability density function
+
+  subsection Generator
+    subsection Probability density function
+      set Function expression = sin(y/100000*pi)
+      set Number of particles = 10000
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type =  block AMG
+  end
+end
diff --git a/tests/grain_size_friction_heating.prm.bak b/tests/grain_size_friction_heating.prm.bak
new file mode 100644
index 00000000000..f33a22c9e31
--- /dev/null
+++ b/tests/grain_size_friction_heating.prm.bak
@@ -0,0 +1,131 @@
+# A test for the grain size material model similar to
+# grain_size_strain.prm. The only difference is the activation of shear
+# heating. In the grain size model, a fraction of the energy dissipated by
+# dislocation creep increases the surface area of grains.
+
+set Dimension                              = 2
+set End time                               = 10000
+set Use years in output instead of seconds = true
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+    set X periodic    = true
+  end
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top,bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 1400
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function,bottom:function
+
+  subsection Function
+    set Function expression = 1.0*(y/100000);0
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 0
+
+    subsection Function
+      set Function expression       = 0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  =
+    set Function expression = if(z<50000,1e-3,1.0000001e-3)
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+end
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                = 3400
+    set Thermal conductivity             = 0
+    set Thermal expansion coefficient    = 0
+    set Reference compressibility        = 0
+    set Viscosity                        = 1e18
+    set Minimum viscosity                = 1e16
+    set Reference temperature            = 1600
+    set Recrystallized grain size        =
+    set Grain growth activation energy       = 4e5
+    set Grain growth activation volume       = 0.0
+    set Grain growth rate constant           = 1.92E-010
+    set Grain growth exponent                = 3
+    set Average specific grain boundary energy = 1.0
+    set Work fraction for boundary area change = 0.1
+    set Geometric constant                   = 3
+    set Grain size evolution formulation     = paleowattmeter
+    set Reciprocal required strain                  = 10
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 3.0e-015 # s^-1 Pa^-1 m^p
+    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 3.75e5 #J/mol
+    set Diffusion activation volume          = 6e-6 # m^3/mol (from Karato 2010)
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # Kawazoe et al. (2009)
+    # Dislocation creep
+    set Dislocation creep prefactor          = 1.244507e-15 # s^-1 Pa^-n
+    set Dislocation creep exponent           = 3.5
+    set Dislocation activation energy        = 530000 # J/mol
+    set Dislocation activation volume        = 1.40E-005 # m^3/mol
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, heating statistics
+end
diff --git a/tests/grain_size_growth.prm.bak b/tests/grain_size_growth.prm.bak
new file mode 100644
index 00000000000..fc49ee5b3ff
--- /dev/null
+++ b/tests/grain_size_growth.prm.bak
@@ -0,0 +1,159 @@
+# This is a very simple test case that checks
+# that the implementation of the grain growth
+# laws are correct. All parameters, including
+# temperature and pressure, are set to constant
+# values and no dynamic recrystallization is
+# included (the reciprocal required strain is
+# set to zero). Material flows in from the left
+# and flows out at the right boundary with a constant
+# velocity. The grain size
+# should then only depend on the x coordinate
+# following the relation
+#
+# d(x) = (d_0^p + A * x)^(1/p)
+#
+# with
+# d_0 = 8e-5 m              (initial grain size)
+# p   = 10                  (grain size exponent)
+# A   = 2.0294e-46 m^(p-1)  (grain growth rate constant * exp(-E/(RT)) / velocity)
+#
+# leading to a grain size of d=8.8957E-5 m at the
+# right boundary of the model if the end time is extended
+# to at least 1 Myr (the time it takes material to reach
+# the right model boundary).
+
+############### Global parameters
+
+set Dimension                              = 2
+set End time                               = 50000
+set Use years in output instead of seconds = true
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top,bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 1400
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = left
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom,top
+  set Prescribed velocity boundary indicators = left:function,right:function
+
+  subsection Function
+    set Function expression = 0.1;0
+  end
+end
+
+# Warning: Merge the parameter in the following subsection with any
+# other parameter of the same name, otherwise your model results might change
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 0
+
+    subsection Function
+      set Function expression       = 0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  =
+    set Function expression = if(z<50000,8e-5,8.00001e-5)
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+end
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                = 3400
+    set Thermal conductivity             = 0
+    set Thermal expansion coefficient    = 0
+    set Reference compressibility        = 0
+    set Viscosity                        = 1e18
+    set Reference temperature            = 1600
+    set Recrystallized grain size        =
+    set Grain growth activation energy       = 3e5
+    set Grain growth activation volume       = 0.0
+    set Grain growth rate constant           = 4E-045
+    set Grain growth exponent                = 10
+    set Grain size evolution formulation     = paleowattmeter
+    set Reciprocal required strain           = 0
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 1.5e-024 # s^-1 Pa^-1 m^p
+    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 3e5 #J/mol
+    set Diffusion activation volume          = 2e-6 # m^3/mol (from Karato 2010)
+
+    # Kawazoe et al. (2009)
+    # Dislocation creep
+    set Dislocation creep prefactor          = 1.1E-016 # s^-1 Pa^-n
+    set Dislocation creep exponent           = 3.5
+    set Dislocation activation energy        = 530000 # J/mol
+    set Dislocation activation volume        = 1.40E-005 # m^3/mol
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, ODE statistics
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-7
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/grain_size_growth_one_cell.prm.bak b/tests/grain_size_growth_one_cell.prm.bak
new file mode 100644
index 00000000000..831d1421eb9
--- /dev/null
+++ b/tests/grain_size_growth_one_cell.prm.bak
@@ -0,0 +1,144 @@
+# This is a very simple test case that checks
+# that the implementation of the grain growth
+# laws are correct. All parameters, including
+# temperature and pressure, are set to constant
+# values and no dynamic recrystallization is
+# included (the reciprocal required strain is
+# set to zero). The grain size should only
+# depend on time following the relation
+#
+# d(x) = (d_0^p + A * t)^(1/p)
+#
+# with
+# d_0 = 8e-5 m              (initial grain size)
+# p   = 10                  (grain size exponent)
+# A   = 2.0294e-45 m^(p-1)  (grain growth rate constant * exp(-E/(RT)))
+#
+# leading to a grain size of d=8.8957E-5 m at the
+# right boundary of the model at the end time of
+# 1 Myr.
+
+# This test is similar to grain size growth, but
+# computes the grain growth in just one mesh cell
+# rather than advecting the growing grains from
+# left to right.
+
+############### Global parameters
+
+set Dimension                              = 2
+set End time                               = 1e6
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top,bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 1400
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   =
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 0
+
+    subsection Function
+      set Function expression       = 0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  =
+    set Function expression = 8e-5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+end
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                = 3400
+    set Thermal conductivity             = 0
+    set Thermal expansion coefficient    = 0
+    set Reference compressibility        = 0
+    set Viscosity                        = 1e18
+    set Reference temperature            = 1600
+    set Recrystallized grain size        =
+    set Grain growth activation energy       = 3e5
+    set Grain growth activation volume       = 0.0
+    set Grain growth rate constant           = 4E-045
+    set Grain growth exponent                = 10
+    set Grain size evolution formulation     = paleowattmeter
+    set Reciprocal required strain           = 0
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 1.5e-024 # s^-1 Pa^-1 m^p
+    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 3e5 #J/mol
+    set Diffusion activation volume          = 2e-6 # m^3/mol (from Karato 2010)
+
+    # Kawazoe et al. (2009)
+    # Dislocation creep
+    set Dislocation creep prefactor          = 1.1E-016 # s^-1 Pa^-n
+    set Dislocation creep exponent           = 3.5
+    set Dislocation activation energy        = 530000 # J/mol
+    set Dislocation activation volume        = 1.40E-005 # m^3/mol
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, ODE statistics
+end
diff --git a/tests/grain_size_growth_one_cell_particles.prm.bak b/tests/grain_size_growth_one_cell_particles.prm.bak
new file mode 100644
index 00000000000..f0a496715ce
--- /dev/null
+++ b/tests/grain_size_growth_one_cell_particles.prm.bak
@@ -0,0 +1,43 @@
+# Like grain size growth one cell, but with particles.
+
+include $ASPECT_SOURCE_DIR/tests/grain_size_growth_one_cell.prm
+
+
+############### Global parameters
+
+set Dimension                              = 2
+set End time                               = 1e6
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+  set Compositional field methods = particles
+  set Mapped particle properties = grain_size:grain_size
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, velocity statistics, particles, ODE statistics
+
+  subsection Particles
+    set Time between data output = 1e6
+  end
+end
+
+# We use particles to advect the grain size.
+subsection Particles
+  set Interpolation scheme = cell average
+  set List of particle properties = grain size
+  set Load balancing strategy = none
+  set Integration scheme = rk2
+  set Update ghost particles = true
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 50000
+    end
+  end
+end
diff --git a/tests/grain_size_growth_particles.prm.bak b/tests/grain_size_growth_particles.prm.bak
new file mode 100644
index 00000000000..5a43e8a6d79
--- /dev/null
+++ b/tests/grain_size_growth_particles.prm.bak
@@ -0,0 +1,49 @@
+# This is a very simple test case that checks
+# that the implementation of the grain growth
+# laws are correct. All parameters, including
+# temperature and pressure, are set to constant
+# values and no dynamic recrystallization is
+# included (the reciprocal required strain is
+# set to zero). Material flows in from the left
+# and flows out at the right boundary with a constant
+# velocity. The grain size
+# should then only depend on the x coordinate
+# following the relation
+#
+# d(x) = (d_0 + A * x)^(1/p)
+#
+# with
+# d_0 = 8e-5 m         (initial grain size)
+# p   = 10             (grain size exponent)
+# A   = 2.0294e-46 1/m
+#
+# leading to a grain size of d=8.8957E-5 m at the
+# right boundary of the model.
+
+############### Global parameters
+
+set Dimension                              = 2
+set End time                               = 50000
+
+include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
+
+
+subsection Postprocess
+  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = gnuplot
+  end
+end
+
+subsection Particles
+  set List of particle properties = grain size
+  set Integration scheme = rk2
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/grain_size_growth_pinned.prm.bak b/tests/grain_size_growth_pinned.prm.bak
new file mode 100644
index 00000000000..67fc6740293
--- /dev/null
+++ b/tests/grain_size_growth_pinned.prm.bak
@@ -0,0 +1,34 @@
+# This is a very simple test case that checks
+# that the implementation of the grain growth
+# laws with the pinned grain damage formulation
+# (Mulyukova and Bercovici (2018) are correct.
+# All parameters, including temperature and pressure
+# are set to constant values.
+# Material flows in from the left
+# and flows out at the right boundary with a constant
+# velocity. The grain size
+# should then only depend on the x coordinate
+# following the relation
+#
+# d(x) = (d_0^p + A * x)^(1/p)
+#
+# with
+# d_0 = 8e-5 m                 (initial grain size)
+# p   = 10                     (grain size exponent)
+# A   = 1.334585e-44 1/m^(p-1) (grain growth rate constant * exp(-E/(RT)) / velocity)
+#
+# which means we expect a grain size of 1.296828e-4 m at x = 1e5 m.
+#
+# If this test runs for 2e6 it produces a grain size of
+# 1.29087e-04 m at x = 1e5 m, which is close enough.
+
+include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
+
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Grain size evolution formulation  = pinned grain damage
+  end
+end
diff --git a/tests/grain_size_latent_heat.cc.bak b/tests/grain_size_latent_heat.cc.bak
new file mode 100644
index 00000000000..8f972b15a8b
--- /dev/null
+++ b/tests/grain_size_latent_heat.cc.bak
@@ -0,0 +1,237 @@
+/*
+  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/grain_size.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/gravity_model/interface.h>
+
+#include <deal.II/base/parameter_handler.h>
+
+#include <iostream>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * A material model that consists of globally constant values for all
+     * material parameters except that the density decays linearly with the
+     * temperature and the viscosity, which depends on the temperature,
+     * pressure, strain rate and grain size.
+     *
+     * The grain size evolves in time, dependent on strain rate, temperature,
+     * creep regime, and phase transitions.
+     *
+     * The model is considered compressible.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class GrainSizeLatentHeat : public MaterialModel::GrainSize<dim>
+    {
+      public:
+        virtual bool is_compressible () const override
+        {
+          return false;
+        }
+
+        virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                              typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const override
+        {
+          double dHdT = 0.0;
+          double dHdp = 0.0;
+
+          if (in.current_cell.state() == IteratorState::valid)
+            {
+              const QTrapezoid<dim> quadrature_formula;
+              const unsigned int n_q_points = quadrature_formula.size();
+
+              FEValues<dim> fe_values (this->get_mapping(),
+                                       this->get_fe(),
+                                       quadrature_formula,
+                                       update_values);
+
+              std::vector<double> temperatures(n_q_points), pressures(n_q_points);
+              std::vector<std::vector<double>> compositions (quadrature_formula.size(),std::vector<double> (this->n_compositional_fields()));
+              std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+
+              fe_values.reinit (in.current_cell);
+
+              // get the various components of the solution, then
+              // evaluate the material properties there
+              fe_values[this->introspection().extractors.temperature]
+              .get_function_values (this->get_solution(), temperatures);
+              fe_values[this->introspection().extractors.pressure]
+              .get_function_values (this->get_solution(), pressures);
+
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                fe_values[this->introspection().extractors.compositional_fields[c]]
+                .get_function_values(this->get_solution(),
+                                     composition_values[c]);
+              for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
+                {
+                  for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                    compositions[q][c] = composition_values[c][q];
+                }
+
+              unsigned int T_points(0),p_points(0);
+
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  const double own_enthalpy = this->material_lookup[0]->enthalpy(temperatures[q],pressures[q]);
+                  for (unsigned int p=0; p<n_q_points; ++p)
+                    {
+                      double enthalpy_p,enthalpy_T;
+                      if (std::fabs(temperatures[q] - temperatures[p]) > 1e-12 * temperatures[q])
+                        {
+                          enthalpy_p = this->material_lookup[0]->enthalpy(temperatures[p],pressures[q]);
+                          const double point_contribution = (own_enthalpy-enthalpy_p)/(temperatures[q]-temperatures[p]);
+                          dHdT += point_contribution;
+                          T_points++;
+                        }
+                      if (std::fabs(pressures[q] - pressures[p]) > 1)
+                        {
+                          enthalpy_T = this->material_lookup[0]->enthalpy(temperatures[q],pressures[p]);
+                          dHdp += (own_enthalpy-enthalpy_T)/(pressures[q]-pressures[p]);
+                          p_points++;
+                        }
+                    }
+                }
+
+              if ((T_points > 0)
+                  && (p_points > 0))
+                {
+                  dHdT /= T_points;
+                  dHdp /= p_points;
+                }
+            }
+
+          std::vector<double> adiabatic_pressures (in.n_evaluation_points());
+          std::vector<unsigned int> phase_indices (in.n_evaluation_points());
+
+          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+            {
+              std::vector<double> composition (in.composition[i]);
+              for (unsigned int c=0; c<composition.size(); ++c)
+                composition[c] = std::max(this->min_grain_size,composition[c]);
+
+              const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[i]).norm();
+
+              out.densities[i] = this->density(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
+
+              // We do not fill the phase function index, because that will be done internally in the get_phase_index() function
+              adiabatic_pressures[i] = this->get_adiabatic_conditions().is_initialized()
+                                       ?
+                                       this->get_adiabatic_conditions().pressure(in.position[i])
+                                       :
+                                       in.pressure[i];
+              const double depth = this->get_geometry_model().depth(in.position[i]);
+              const double rho_g = out.densities[i] * gravity_norm;
+              MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature[i], adiabatic_pressures[i], depth, rho_g, numbers::invalid_unsigned_int);
+              phase_indices[i] = this->get_phase_index(phase_inputs);
+
+              if (in.requests_property(MaterialProperties::viscosity))
+                {
+                  double effective_viscosity;
+                  double disl_viscosity = std::numeric_limits<double>::max();
+                  Assert(std::isfinite(in.strain_rate[i].norm()),
+                         ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
+                                    "not filled by the caller."));
+                  const SymmetricTensor<2,dim> shear_strain_rate = in.strain_rate[i] - 1./dim * trace(in.strain_rate[i]) * unit_symmetric_tensor<dim>();
+                  const double second_strain_rate_invariant = std::sqrt(std::max(-second_invariant(shear_strain_rate), 0.));
+
+                  const double adiabatic_temperature = this->get_adiabatic_conditions().is_initialized()
+                                                       ?
+                                                       this->get_adiabatic_conditions().temperature(in.position[i])
+                                                       :
+                                                       in.temperature[i];
+
+                  const unsigned int grain_size_index = this->introspection().compositional_index_for_name("grain_size");
+
+                  const double diff_viscosity = this->diffusion_viscosity(in.temperature[i],
+                                                                          adiabatic_temperature,
+                                                                          adiabatic_pressures[i],
+                                                                          composition[grain_size_index],
+                                                                          second_strain_rate_invariant,
+                                                                          phase_indices[i]);
+
+                  if (std::abs(second_strain_rate_invariant) > 1e-30)
+                    {
+                      disl_viscosity = this->dislocation_viscosity(in.temperature[i], adiabatic_temperature, adiabatic_pressures[i], in.strain_rate[i], phase_indices[i], diff_viscosity);
+                      effective_viscosity = disl_viscosity * diff_viscosity / (disl_viscosity + diff_viscosity);
+                    }
+                  else
+                    effective_viscosity = diff_viscosity;
+
+                  out.viscosities[i] = std::min(std::max(this->min_eta,effective_viscosity),this->max_eta);
+                }
+
+              if (this->get_adiabatic_conditions().is_initialized())
+                {
+                  if ((in.current_cell.state() == IteratorState::valid)
+                      && (std::fabs(dHdp) > std::numeric_limits<double>::epsilon())
+                      && (std::fabs(dHdT) > std::numeric_limits<double>::epsilon()))
+                    {
+                      out.thermal_expansion_coefficients[i] = (1 - 3515.6 * dHdp) / in.temperature[i];
+                      out.specific_heat[i] = dHdT;
+                    }
+                  else
+                    {
+                      out.thermal_expansion_coefficients[i] = this->thermal_expansion_coefficient(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
+                      out.specific_heat[i] = this->specific_heat(in.temperature[i], in.pressure[i], composition, in.position[i]);
+                    }
+                }
+              else
+                {
+                  out.thermal_expansion_coefficients[i] = (1 - 3515.6 * this->material_lookup[0]->dHdp(in.temperature[i],in.pressure[i])) / in.temperature[i];
+                  out.specific_heat[i] = this->material_lookup[0]->dHdT(in.temperature[i],in.pressure[i]);
+                }
+
+              out.thermal_conductivities[i] = this->k_value;
+              out.compressibilities[i] = this->compressibility(in.temperature[i], in.pressure[i], composition, in.position[i]);
+            }
+          if (in.requests_property(MaterialProperties::reaction_terms))
+            out.reaction_terms = this->grain_size_change(in, adiabatic_pressures, phase_indices);
+        }
+    };
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(GrainSizeLatentHeat,
+                                   "grain size latent heat",
+                                   "A material model that behaves in the same way as "
+                                   "the grain size model, but is modified to "
+                                   "resemble the latent heat benchmark. Due to the "
+                                   "nature of the benchmark the model needs to be "
+                                   "incompressible despite a material table and "
+                                   "use a constant density for the calculation of "
+                                   "the latent heat.")
+  }
+}
diff --git a/tests/grain_size_latent_heat.prm.bak b/tests/grain_size_latent_heat.prm.bak
new file mode 100644
index 00000000000..947168e0ad7
--- /dev/null
+++ b/tests/grain_size_latent_heat.prm.bak
@@ -0,0 +1,131 @@
+# This is a model setup to test latent heat generation.
+# It is identical to the latent_heat_enthalpy test, but utilizes
+# the grain size material model to ensure a correct
+# implementation of the functionality. For details on the
+# test see the latent_heat_enthalpy test case.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 1e15
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature          = 1000
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 50000
+    set Y extent = 1000000
+    set Y repetitions = 20
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  =
+    set Function expression = 8e-5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+end
+
+# Warning: Merge the parameter in the following subsection with any
+# other parameter of the same name, otherwise your model results might change
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Function expression = 0;-2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0 + (y-1000000)/1000000
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = grain size latent heat
+
+  subsection Grain size model
+    set Reference density                = 3400
+    set Thermal conductivity             = 2.38
+    set Thermal expansion coefficient    = 0
+    set Minimum thermal expansivity      = 0
+    set Reference compressibility        = 0
+    set Viscosity                        = 8.44e21
+    set Minimum viscosity                = 8.44e21
+    set Maximum viscosity                = 8.44e21
+    set Reference temperature            = 1000
+    set Grain growth rate constant       = 0
+    set Recrystallized grain size        =
+    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/latent-heat-enthalpy-test/
+    set Material file names = testdata.txt
+    set Material file format = perplex
+    set Use table properties = true
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, composition statistics
+end
diff --git a/tests/grain_size_phase_function.prm.bak b/tests/grain_size_phase_function.prm.bak
new file mode 100644
index 00000000000..f3c5c4ff500
--- /dev/null
+++ b/tests/grain_size_phase_function.prm.bak
@@ -0,0 +1,149 @@
+# A test for the grain size material model to see if the
+# phase transitions work correctly. The test has three phase
+# transitions with different Clapeyron slopes that affect
+# the viscosity and the grain size growth.
+
+set Dimension                              = 2
+set End time                               = 10000
+set Use years in output instead of seconds = true
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top,bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 1600
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1400 + 0.004 * x
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  =
+    set Function expression = 1e-3
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+  set Compositional field methods = particles
+  set Types of fields = grain size
+  set Mapped particle properties = grain_size:grain_size
+end
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                    = 1000
+    set Thermal conductivity                 = 0
+    set Thermal expansion coefficient        = 0
+    set Reference compressibility            = 0
+    set Viscosity                            = 1e19
+    set Minimum viscosity                    = 1e16
+    set Reference temperature                = 1600
+    set Grain growth activation energy       = 0, 0, 0, 0
+    set Grain growth activation volume       = 0, 0, 0, 0
+    set Grain growth rate constant           = 0, 1e-20, 0, 5e-21
+    set Grain growth exponent                = 3, 3, 3, 3
+    set Average specific grain boundary energy = 1, 1, 1, 1
+    set Work fraction for boundary area change = 0.1, 0.1, 0.1, 0.1
+    set Geometric constant                   = 3, 3, 3, 3
+    set Grain size evolution formulation     = paleowattmeter
+    set Reciprocal required strain           = 10
+    set Phase transition depths              = background:20000|50000|65000
+    set Phase transition Clapeyron slopes    = background:1e6|-5e5|2.5e5
+    set Phase transition temperatures        = background:1600|1600|1600
+    set Phase transition widths              = background:0|0|0
+    set Recrystallized grain size            = 1e-3, 1e-3, 1e-3
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 3.0e-016, 3.0e-015, 3.0e-017, 3.0e-016
+    set Diffusion creep exponent             = 1, 1, 1, 1
+    set Diffusion creep grain size exponent  = 3, 3, 3, 3
+    set Diffusion activation energy          = 3.75e5, 3.75e5, 3.75e5, 3.75e5
+    set Diffusion activation volume          = 0, 0, 0, 0
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # No dislocation creep
+    set Dislocation creep prefactor          = 1e-200, 1e-200, 1e-200, 1e-200
+    set Dislocation creep exponent           = 1, 1, 1, 1
+    set Dislocation activation energy        = 0, 0, 0, 0
+    set Dislocation activation volume        = 0, 0, 0, 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, particles, material statistics, ODE statistics
+
+  subsection Visualization
+    set List of output variables  = material properties
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Time between data output = 0
+  end
+end
+
+subsection Particles
+  set List of particle properties = grain size
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10000
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set GMRES solver restart length = 200
+  end
+end
diff --git a/tests/grain_size_plunge.prm.bak b/tests/grain_size_plunge.prm.bak
new file mode 100644
index 00000000000..fc16242f83d
--- /dev/null
+++ b/tests/grain_size_plunge.prm.bak
@@ -0,0 +1,10 @@
+# A test for the grain size material model using the pinned state damage formulation.
+# This test is like grain_size_strain_pinned_state, but uses the parameters
+# from Mulyukova and Bercovici (2018) at constant
+# temperature and stress in their figure 4 to reproduce a grain size plunge.
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/grain_size_pinned_state/grain_size_plunge.prm
+
+set End time                               = 1e2
diff --git a/tests/grain_size_ridge.prm.bak b/tests/grain_size_ridge.prm.bak
new file mode 100644
index 00000000000..6ce36974883
--- /dev/null
+++ b/tests/grain_size_ridge.prm.bak
@@ -0,0 +1,23 @@
+# This is a test for the grain_size_ridge cookbook.
+# We loosen the solver tolerance to make it run faster.
+
+include $ASPECT_SOURCE_DIR/cookbooks/grain_size_ridge/grain_size_ridge.prm
+
+set End time                    = 500
+set Nonlinear solver tolerance  = 1e-4
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 5e-5
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 4
+  set Initial adaptive refinement = 0
+  set Minimum refinement level = 4
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics, mass flux statistics, particles, ODE statistics
+end
diff --git a/tests/grain_size_ridge_traction.prm.bak b/tests/grain_size_ridge_traction.prm.bak
new file mode 100644
index 00000000000..e8be1f3aa27
--- /dev/null
+++ b/tests/grain_size_ridge_traction.prm.bak
@@ -0,0 +1,112 @@
+# This is a test for the grain size evolutionn in a realistic
+# model setup, in this case, the grain_size_ridge cookbook.
+# However, we prescribe the traction rather than the velocity
+# at the boundaries. This way, we can make sure our boundary
+# conditions do not introduce any artificially high grain size
+# reduction.
+
+include $ASPECT_SOURCE_DIR/cookbooks/grain_size_ridge/grain_size_ridge.prm
+
+set End time                    = 100
+set Maximum time step           = 50
+
+# Refine the mesh within the lithosphere.
+subsection Mesh refinement
+  set Initial global refinement = 5
+  set Initial adaptive refinement = 0
+  set Minimum refinement level = 5
+  set Time steps between mesh refinement = 0
+end
+
+# Make the model domain smaller so we can resolve the
+# lithosphere well even in a small test case.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 410000
+    set Y extent  = 200000
+    set X repetitions = 2
+    set Y repetitions = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, top
+  set Prescribed velocity boundary indicators = bottom x: function, right y:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0; 0
+  end
+end
+
+# Prescribe traction instead of velocity to avoid sigularity
+# in the top left corner.
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right x:initial lithostatic pressure, bottom y:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Representative point         = 60000, 0
+    set Number of integration points = 10000
+  end
+end
+
+# Larger conductivity to make up for the smaller model domain.
+# Fast grain size change.
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+
+  subsection Grain size model
+    set Thermal conductivity  = 20
+    set Maximum viscosity     = 1e23
+    set Work fraction for boundary area change = 0.5
+  end
+end
+
+# Leave a gap of low viscosity in the corner to make the problem
+# more well-posed.
+subsection Initial temperature model
+  set List of model names = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer   = 0.0
+    set Top boundary layer age model = function
+
+    subsection Age function
+      set Function expression = max((x-10000) / 0.05, 0)
+    end
+  end
+end
+
+# Make the initial grain size constant everywhere.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 5e-3
+    set Variable names      = x,y
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, velocity statistics, mass flux statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = gnuplot
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell = 5
+  set Maximum particles per cell = 80
+  set Particle generator name = probability density function
+
+  subsection Generator
+    subsection Probability density function
+      set Function expression = 20000*20000+y*y
+      set Number of particles = 20000
+    end
+  end
+end
diff --git a/tests/grain_size_strain.prm.bak b/tests/grain_size_strain.prm.bak
new file mode 100644
index 00000000000..81a61961b4a
--- /dev/null
+++ b/tests/grain_size_strain.prm.bak
@@ -0,0 +1,130 @@
+# A test for the grain size material model. The test imposes simple shear
+# across a 100 km square domain with a rheology derived from experiments on
+# olivine. The model domain is isobaric and initially isothermal.
+# Over time the model maintains nearly constant temperatures, pressures and
+# strain rates. The grain size in the test approaches the equilibrium
+# grain size for t -> infinity. At 4 Myr the grain size is
+# 9.35850647e-04 m, which is close to the equilibrium value.
+
+set Dimension                              = 2
+set End time                               = 5000
+set Use years in output instead of seconds = true
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+    set X periodic    = true
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top,bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 1400
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function,bottom:function
+
+  subsection Function
+    set Function expression = 1.0*(y/100000);0
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 0
+
+    subsection Function
+      set Function expression       = 0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  =
+    set Function expression = if(z<50000,1e-3,1.0000001e-3)
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+end
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                = 3400
+    set Thermal conductivity             = 0
+    set Thermal expansion coefficient    = 0
+    set Reference compressibility        = 0
+    set Viscosity                        = 1e18
+    set Minimum viscosity                = 1e16
+    set Reference temperature            = 1600
+    set Recrystallized grain size        =
+    set Grain growth activation energy       = 4e5
+    set Grain growth activation volume       = 0.0
+    set Grain growth rate constant           = 1.92E-010
+    set Grain growth exponent                = 3
+    set Average specific grain boundary energy = 1.0
+    set Work fraction for boundary area change = 0.1
+    set Geometric constant                   = 3
+    set Grain size evolution formulation     = paleowattmeter
+    set Reciprocal required strain                  = 10
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 3.0e-015 # s^-1 Pa^-1 m^p
+    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 3.75e5 #J/mol
+    set Diffusion activation volume          = 6e-6 # m^3/mol (from Karato 2010)
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # Kawazoe et al. (2009)
+    # Dislocation creep
+    set Dislocation creep prefactor          = 1.244507e-15 # s^-1 Pa^-n
+    set Dislocation creep exponent           = 3.5
+    set Dislocation activation energy        = 530000 # J/mol
+    set Dislocation activation volume        = 1.40E-005 # m^3/mol
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, ODE statistics
+end
diff --git a/tests/grain_size_strain_pinned.prm.bak b/tests/grain_size_strain_pinned.prm.bak
new file mode 100644
index 00000000000..759f7419be8
--- /dev/null
+++ b/tests/grain_size_strain_pinned.prm.bak
@@ -0,0 +1,77 @@
+# A test for the grain size material model. The test imposes simple shear
+# across a 100 km square domain.
+# Over time the model maintains nearly constant temperatures, pressures and
+# strain rates.
+# The model change in grain size can be compared to the analytical
+# equations derived in Mulyukova & Bercovici 2018, which is done
+# in a python notebook stored in
+# $ASPECT_SOURCE_DIR/benchmarks/grain_size_pinned_state/dynamic_grain_size_pinned_state.ipynb
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/grain_size_strain.prm
+
+set End time = 1
+set Maximum time step = 1
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                = 3400
+    set Thermal conductivity             = 0
+    set Thermal expansion coefficient    = 0
+    set Reference compressibility        = 0
+    set Viscosity                        = 1e18
+    set Minimum viscosity                = 1e16
+    set Reference temperature            = 1600
+    set Recrystallized grain size        =
+    set Grain growth activation energy       = 4e5
+    set Grain growth activation volume       = 0.0
+    set Grain growth rate constant           = 1.92E-010
+    set Grain growth exponent                = 3
+    set Average specific grain boundary energy = 1.0
+    set Geometric constant                   = 3
+    set Grain size evolution formulation     = pinned grain damage
+    set Reciprocal required strain                  = 10
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 3.0e-015 # s^-1 Pa^-1 m^p
+    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 3.75e5 #J/mol
+    set Diffusion activation volume          = 6e-6 # m^3/mol (from Karato 2010)
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # Kawazoe et al. (2009)
+    # Dislocation creep
+    set Dislocation creep prefactor          = 1.244507e-15 # s^-1 Pa^-n
+    set Dislocation creep exponent           = 3.5
+    set Dislocation activation energy        = 530000 # J/mol
+    set Dislocation activation volume        = 1.40E-005 # m^3/mol
+
+    subsection Grain damage partitioning
+      set Minimum grain size reduction work fraction  = 1e-1
+    end
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, material statistics, visualization, ODE statistics
+
+  subsection Visualization
+    set Time between graphical output = 1
+    set List of output variables = material properties, named additional outputs, heating, strain rate, stress second invariant, stress
+    set Output format = gnuplot
+
+    subsection Material properties
+      set List of material properties = viscosity, density, reaction terms
+    end
+  end
+end
diff --git a/tests/grain_size_strain_pinned_state.prm.bak b/tests/grain_size_strain_pinned_state.prm.bak
new file mode 100644
index 00000000000..d43bf269650
--- /dev/null
+++ b/tests/grain_size_strain_pinned_state.prm.bak
@@ -0,0 +1,58 @@
+# A test for the grain size material model using the pinned state damage formulation.
+# Over time the model maintains nearly constant temperatures, pressures and
+# strain rates. The grain size in the test approaches the equilibrium
+# grain size for t -> infinity. At 400 Myr the equilibrium grain size should
+# be 0.015124 m.
+
+include $ASPECT_SOURCE_DIR/tests/grain_size_strain.prm
+
+set Output directory                       = output_grain_size_strain_pinned_state
+set End time = 1e6
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                = 3400
+    set Thermal conductivity             = 0
+    set Thermal expansion coefficient    = 0
+    set Reference compressibility        = 0
+    set Viscosity                        = 1e18
+    set Minimum viscosity                = 1e16
+    set Reference temperature            = 1600
+    set Recrystallized grain size        =
+    set Grain growth activation energy       = 39072
+    set Grain growth activation volume       = 0.0
+    set Grain growth rate constant           = 1.6E-022
+    set Grain growth exponent                = 4
+    set Average specific grain boundary energy = 1.0
+    set Geometric constant                   = 3
+    set Grain size evolution formulation     = pinned grain damage
+
+    # Mulyukova and Bercovici (2018)
+    # Diffusion creep
+    set Diffusion creep prefactor            = 1e-200 # s^-1 Pa^-1 m^p
+    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 3e5 #J/mol
+    set Diffusion activation volume          = 0 # m^3/mol
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # Kawazoe et al. (2009)
+    # Dislocation creep
+    set Dislocation creep prefactor          = 1e-13 # s^-1 Pa^-n
+    set Dislocation creep exponent           = 3
+    set Dislocation activation energy        = 390720 # J/mol
+    set Dislocation activation volume        = 0 # m^3/mol
+
+    subsection Grain damage partitioning
+      set Minimum grain size reduction work fraction = 1e-6
+    end
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
diff --git a/tests/grain_size_yield.prm.bak b/tests/grain_size_yield.prm.bak
new file mode 100644
index 00000000000..4a8e5c04db4
--- /dev/null
+++ b/tests/grain_size_yield.prm.bak
@@ -0,0 +1,55 @@
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield.prm
+
+
+# Global parameters
+set Dimension                              = 2
+set Adiabatic surface temperature          = 273
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                    = 3300
+    set Thermal conductivity                 = 3.3
+    set Thermal expansion coefficient        = 0.000035
+    set Reference compressibility            = 0
+    set Minimum viscosity                    = 1e17
+    set Maximum viscosity                    = 1e28
+    set Reference temperature                = 293
+    set Grain growth rate constant           = 0
+    set Work fraction for boundary area change = 0
+
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 1e-30
+    set Diffusion creep exponent             = 1
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 0
+    set Diffusion activation volume          = 0
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # No dislocation creep
+    set Dislocation creep prefactor          = 5.e-23
+    set Dislocation creep exponent           = 1
+    set Dislocation activation energy        = 0
+    set Dislocation activation volume        = 0
+    set Use Drucker-Prager rheology          = true
+    set Cohesions                            = 1e6
+    set Angles of internal friction          = 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+  set Types of fields = grain size
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
diff --git a/tests/graphical_output.cc.bak b/tests/graphical_output.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/graphical_output.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/graphical_output.prm.bak b/tests/graphical_output.prm.bak
new file mode 100644
index 00000000000..e869c091bdd
--- /dev/null
+++ b/tests/graphical_output.prm.bak
@@ -0,0 +1,74 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor, visualization
+
+  subsection Depth average
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = viscosity, nonadiabatic pressure
+  end
+end
diff --git a/tests/graphical_output_02.prm.bak b/tests/graphical_output_02.prm.bak
new file mode 100644
index 00000000000..d06b46e0868
--- /dev/null
+++ b/tests/graphical_output_02.prm.bak
@@ -0,0 +1,76 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields          = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/graphical_output_hdf5.cc.bak b/tests/graphical_output_hdf5.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/graphical_output_hdf5.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/graphical_output_hdf5.prm.bak b/tests/graphical_output_hdf5.prm.bak
new file mode 100644
index 00000000000..13f86c36a3c
--- /dev/null
+++ b/tests/graphical_output_hdf5.prm.bak
@@ -0,0 +1,78 @@
+# A copy of the graphical_output test designed to test the
+# hdf5 visualization output format.
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor, visualization
+
+  subsection Depth average
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = hdf5
+    set Time between graphical output = 0
+    set List of output variables = viscosity, nonadiabatic pressure
+  end
+end
diff --git a/tests/gravity_function.prm.bak b/tests/gravity_function.prm.bak
new file mode 100644
index 00000000000..796969a54ec
--- /dev/null
+++ b/tests/gravity_function.prm.bak
@@ -0,0 +1,71 @@
+# Copy of the simpler box test with a function
+# object describing the gravity
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;x
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = density, viscosity, gravity
+  end
+end
diff --git a/tests/gravity_function_time.prm.bak b/tests/gravity_function_time.prm.bak
new file mode 100644
index 00000000000..2e55282dace
--- /dev/null
+++ b/tests/gravity_function_time.prm.bak
@@ -0,0 +1,72 @@
+# Copy of the simpler box test with a function
+# object describing the gravity
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;if(t>0,x,0)
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = density, gravity
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/gravity_model_cartesian.prm.bak b/tests/gravity_model_cartesian.prm.bak
new file mode 100644
index 00000000000..f68e7ed13a7
--- /dev/null
+++ b/tests/gravity_model_cartesian.prm.bak
@@ -0,0 +1,99 @@
+# This is a test based on benchmarks/onset-of-convection/convection-box-base.prm.
+# It makes sure that the gravity plugin 'function' works correctly
+# for a Cartesian coordinate system.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use conduction timestep                = true
+
+subsection Termination criteria
+  set Termination criteria                 = end step
+  set End step                             = 0
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Outer radius = 6371000
+    set Inner radius = 3481000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r,phi
+    set Function expression = 2500 + 10*sin(10*phi)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+#subsection Gravity model
+#  set Model name = radial constant
+#
+#  subsection Radial constant
+#    set Magnitude = 10.0
+#  end
+#end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x,y
+    set Function expression = x;y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 4000
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity                     = 1e23
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set Time steps between graphical output = 5
+    set List of output variables = gravity
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/gravity_model_depth.prm.bak b/tests/gravity_model_depth.prm.bak
new file mode 100644
index 00000000000..92c43750fa7
--- /dev/null
+++ b/tests/gravity_model_depth.prm.bak
@@ -0,0 +1,89 @@
+#This is a test based on benchmarks/onset-of-convection/convection-box-base.prm. It makes sure that the gravity plugin 'function' works correctly for a  Cartesian coordinate system.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Output directory                       = output-gravity_model_depth
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use conduction timestep                = true
+
+subsection Termination criteria
+  set Termination criteria                 = end step
+  set End step                             = 0
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Outer radius = 6371000
+    set Inner radius = 3481000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r,phi
+    set Function expression = 2500 + 10*sin(10*phi)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = depth
+    set Variable names = z,x
+    set Function expression = z;0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 4000
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity                     = 1e23
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set Time steps between graphical output = 5
+    set List of output variables = gravity
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/gravity_model_spherical.prm.bak b/tests/gravity_model_spherical.prm.bak
new file mode 100644
index 00000000000..fb684336f2d
--- /dev/null
+++ b/tests/gravity_model_spherical.prm.bak
@@ -0,0 +1,99 @@
+# This is a test based on benchmarks/onset-of-convection/convection-box-base.prm.
+# It makes sure that the gravity plugin 'function' works correctly for a
+# Cartesian coordinate system.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use conduction timestep                = true
+
+subsection Termination criteria
+  set Termination criteria                 = end step
+  set End step                             = 0
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Outer radius = 6371000
+    set Inner radius = 3481000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r,phi
+    set Function expression = 2500 + 10*sin(10*phi)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3500
+    set Outer temperature = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+#subsection Gravity model
+#  set Model name = radial constant
+#
+#  subsection Radial constant
+#    set Magnitude = 10.0
+#  end
+#end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r,phi
+    set Function expression = r;phi
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 4000
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity                     = 1e23
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set Time steps between graphical output = 5
+    set List of output variables = gravity
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/gravity_point_values_list.prm.bak b/tests/gravity_point_values_list.prm.bak
new file mode 100644
index 00000000000..e9c3941449c
--- /dev/null
+++ b/tests/gravity_point_values_list.prm.bak
@@ -0,0 +1,69 @@
+# A simple setup for testing the gravity postprocessor using the
+# sample scheme 'list'.
+# See the corresponding section in the manual for more information.
+
+# General parameters
+set Dimension                              = 3
+set End time                               = 0
+set Output directory                       = output-gravity_point_values_list
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1
+    set Outer radius  = 2
+    set Cells along circumference = 12
+  end
+end
+
+# Model boundary velocity
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = top, bottom
+end
+
+# Material model
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                 = 1e6
+  end
+end
+
+# Model initial temperature
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Model gravity
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude  = 10
+  end
+end
+
+# Mesh refinement
+subsection Mesh refinement
+  set Initial global refinement          = 0
+end
+
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = gravity calculation
+
+  subsection Gravity calculation
+    set Sampling scheme           = list of points
+    set List of radius            = 4
+    set List of longitude         = 100
+    set List of latitude          = 35
+  end
+end
diff --git a/tests/gravity_point_values_map.prm.bak b/tests/gravity_point_values_map.prm.bak
new file mode 100644
index 00000000000..f124e0de566
--- /dev/null
+++ b/tests/gravity_point_values_map.prm.bak
@@ -0,0 +1,69 @@
+# A simple setup for testing the gravity postprocessor using the
+# sample scheme 'map'.
+# See the corresponding section in the manual for more information.
+
+# General parameters
+set Dimension                              = 3
+set End time                               = 0
+set Output directory                       = output-gravity_point_values_map
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1
+    set Outer radius  = 2
+    set Cells along circumference = 12
+  end
+end
+
+# Model boundary velocity
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = top, bottom
+end
+
+# Material model
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                 = 1e6
+  end
+end
+
+# Model initial temperature
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Model gravity
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude  = 10
+  end
+end
+
+# Mesh refinement
+subsection Mesh refinement
+  set Initial global refinement          = 0
+end
+
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = gravity calculation
+
+  subsection Gravity calculation
+    set Sampling scheme               = map
+    set Minimum radius                = 4
+    set Number points longitude       = 5
+    set Number points latitude        = 5
+  end
+end
diff --git a/tests/gravity_point_values_spiral.prm.bak b/tests/gravity_point_values_spiral.prm.bak
new file mode 100644
index 00000000000..52730c459db
--- /dev/null
+++ b/tests/gravity_point_values_spiral.prm.bak
@@ -0,0 +1,68 @@
+# A simple setup for testing the gravity postprocessor using the
+# sample scheme 'fibonacci spiral'.
+# See the corresponding section in the manual for more information.
+
+# General parameters
+set Dimension                              = 3
+set End time                               = 0
+set Output directory                       = output-gravity_point_values_spiral
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1
+    set Outer radius  = 2
+    set Cells along circumference = 12
+  end
+end
+
+# Model boundary velocity
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = top, bottom
+end
+
+# Material model
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                 = 1e6
+  end
+end
+
+# Model initial temperature
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Model gravity
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude  = 10
+  end
+end
+
+# Mesh refinement
+subsection Mesh refinement
+  set Initial global refinement          = 0
+end
+
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = gravity calculation
+
+  subsection Gravity calculation
+    set Sampling scheme                      = fibonacci spiral
+    set Number points fibonacci spiral       = 10
+    set Minimum radius                       = 4
+  end
+end
diff --git a/tests/gravity_point_values_spiral_parallel.prm.bak b/tests/gravity_point_values_spiral_parallel.prm.bak
new file mode 100644
index 00000000000..f8f7f1a2ccc
--- /dev/null
+++ b/tests/gravity_point_values_spiral_parallel.prm.bak
@@ -0,0 +1,9 @@
+# This is a copy of the gravity_point_values_spiral test,
+# but the real purpose of the test is to check that running
+# the postprocessor in parallel works.
+
+# MPI: 3
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/tests/gravity_point_values_spiral.prm
diff --git a/tests/gravity_prem.prm.bak b/tests/gravity_prem.prm.bak
new file mode 100644
index 00000000000..60961ef1251
--- /dev/null
+++ b/tests/gravity_prem.prm.bak
@@ -0,0 +1,72 @@
+# Copy of the simpler box test with a gravity
+# profile that follows PREM.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = ascii data
+
+  subsection Ascii data model
+    #    set Data directory = $ASPECT_SOURCE_DIR/data/gravity-model/
+    #    set Data file name = prem.txt
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 637100
+    set Y extent = 6371000
+    set Y repetitions = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1600
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 5e24
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = gravity
+  end
+end
diff --git a/tests/gravity_quadrature_degree_increase.prm.bak b/tests/gravity_quadrature_degree_increase.prm.bak
new file mode 100644
index 00000000000..d4544e3a5ba
--- /dev/null
+++ b/tests/gravity_quadrature_degree_increase.prm.bak
@@ -0,0 +1,70 @@
+# A simple setup for testing the gravity postprocessor using the
+# sample scheme 'list'.
+# See the corresponding section in the manual for more information.
+
+# General parameters
+set Dimension                              = 3
+set End time                               = 0
+set Output directory                       = output-gravity_quadrature_degree_increase.prm
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# Model geometry
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1
+    set Outer radius  = 2
+    set Cells along circumference = 12
+  end
+end
+
+# Model boundary velocity
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = top, bottom
+end
+
+# Material model
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                 = 1e6
+  end
+end
+
+# Model initial temperature
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Model gravity
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude  = 10
+  end
+end
+
+# Mesh refinement
+subsection Mesh refinement
+  set Initial global refinement          = 0
+end
+
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = gravity calculation
+
+  subsection Gravity calculation
+    set Sampling scheme           = list of points
+    set List of radius            = 4
+    set List of longitude         = 100
+    set List of latitude          = 35
+    set Quadrature degree increase = -1
+  end
+end
diff --git a/tests/gs_drucker_prager.prm.bak b/tests/gs_drucker_prager.prm.bak
new file mode 100644
index 00000000000..311c133c4d1
--- /dev/null
+++ b/tests/gs_drucker_prager.prm.bak
@@ -0,0 +1,131 @@
+# In this test, a velocity field is prescribed that represents
+# simple shear with respect to the model's y-axis. This setup generates
+# output that describes the material model's response to a range
+# of stress conditions.
+
+# The yield strength is
+# cohesion * cos(phi) + pressure * sin(phi) = 50 MPa + 0.5 * pressure
+# = 50 MPa + 0.5 * 1e6 * x
+
+# The (non-yield) stress in the model is
+# 2 * strain_rate * viscosity = 1e6 * y
+
+# This means the transition from yielding to non-yielding (expressed by
+# the plastic_yielding variable in the graphical output) should start
+# at x=0, y=50 and end at x=200, y=150.
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 293
+set Use years in output instead of seconds = false
+
+# Because this model aims to capture rheological behavior under a range
+# of deformation regimes, we prescribe a flow field in the section called
+# `Prescribed Stokes Solution` below.
+set Nonlinear solver scheme                = single Advection, no Stokes
+set End time                               = 0
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  # Strain rate = 1/2 du_x/dy = 1/2 * 1e6/1e22
+  subsection Velocity function
+    set Function expression = 1e6/(2*1e22)*y^2; 0
+  end
+
+  subsection Pressure function
+    set Function expression = 1e6*x
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent      = 200
+    set Y extent      = 150
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+  set Types of fields = grain size
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600
+  end
+end
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                    = 2700
+    set Thermal conductivity                 = 0
+    set Thermal expansion coefficient        = 0
+    set Reference compressibility            = 0
+    set Minimum viscosity                    = 10
+    set Maximum viscosity                    = 1e30
+    set Reference temperature                = 1600
+    set Grain growth rate constant           = 0
+    set Work fraction for boundary area change = 0
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 1e-22
+    set Diffusion creep exponent             = 1
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 0
+    set Diffusion activation volume          = 0
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # No dislocation creep
+    set Dislocation creep prefactor          = 1e-30
+    set Dislocation creep exponent           = 1
+    set Dislocation activation energy        = 0
+    set Dislocation activation volume        = 0
+    set Use Drucker-Prager rheology          = true
+    set Cohesions                            = 5.77350269e7
+    set Angles of internal friction          = 30
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, material statistics
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables  = material properties, named additional outputs, strain rate, shear stress
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/gs_drucker_prager_extension.prm.bak b/tests/gs_drucker_prager_extension.prm.bak
new file mode 100644
index 00000000000..5908d26fe51
--- /dev/null
+++ b/tests/gs_drucker_prager_extension.prm.bak
@@ -0,0 +1,93 @@
+# This test is similar to drucker_prager_extension, but uses
+# grain size material model. Because the implementation of
+# the min and max viscosity cutoff is different, the solution
+# is slightly different as well.
+
+include $ASPECT_SOURCE_DIR/tests/drucker_prager_extension.prm
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set Nonlinear solver tolerance             = 1e-7
+set Adiabatic surface temperature          = 1600
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+  set Compositional field methods = particles
+  set Types of fields = grain size
+  set Mapped particle properties = grain_size:grain_size
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600
+  end
+end
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                    = 2700
+    set Thermal conductivity                 = 0
+    set Thermal expansion coefficient        = 0
+    set Reference compressibility            = 0
+    set Minimum viscosity                    = 1e19
+    set Maximum viscosity                    = 1e26
+    set Reference temperature                = 1600
+    set Grain growth rate constant           = 0
+    set Work fraction for boundary area change = 0
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 1e-30
+    set Diffusion creep exponent             = 1
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 0
+    set Diffusion activation volume          = 0
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # No dislocation creep
+    set Dislocation creep prefactor          = 1e-30
+    set Dislocation creep exponent           = 1
+    set Dislocation activation energy        = 0
+    set Dislocation activation volume        = 0
+    set Use Drucker-Prager rheology          = true
+    set Cohesions                            = 4e7
+    set Angles of internal friction          = 15
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles, material statistics
+
+  subsection Visualization
+    set List of output variables  = material properties, named additional outputs, strain rate
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Time between data output = 0
+  end
+end
+
+subsection Particles
+  set List of particle properties = grain size
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10000
+    end
+  end
+end
diff --git a/tests/gs_drucker_prager_extension_adiabatic.prm.bak b/tests/gs_drucker_prager_extension_adiabatic.prm.bak
new file mode 100644
index 00000000000..5ab9011c1ca
--- /dev/null
+++ b/tests/gs_drucker_prager_extension_adiabatic.prm.bak
@@ -0,0 +1,92 @@
+# This test is like gs_drucker_prager_extension, but uses
+# the adiabatic pressure for yielding.
+
+include $ASPECT_SOURCE_DIR/tests/drucker_prager_extension.prm
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set Nonlinear solver tolerance             = 1e-7
+set Adiabatic surface temperature          = 1600
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+  set Compositional field methods = particles
+  set Types of fields = grain size
+  set Mapped particle properties = grain_size:grain_size
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600
+  end
+end
+
+subsection Material model
+  set Model name = grain size
+
+  subsection Grain size model
+    set Reference density                    = 2700
+    set Thermal conductivity                 = 0
+    set Thermal expansion coefficient        = 0
+    set Reference compressibility            = 0
+    set Minimum viscosity                    = 1e19
+    set Maximum viscosity                    = 1e26
+    set Reference temperature                = 1600
+    set Grain growth rate constant           = 0
+    set Work fraction for boundary area change = 0
+
+    # Faul and Jackson 2007
+    # Diffusion creep
+    # new scaled prefactors to match vertical viscosity profile
+    set Diffusion creep prefactor            = 1e-30
+    set Diffusion creep exponent             = 1
+    set Diffusion creep grain size exponent  = 3
+    set Diffusion activation energy          = 0
+    set Diffusion activation volume          = 0
+    set Dislocation viscosity iteration threshold = 1e-3
+
+    # No dislocation creep
+    set Dislocation creep prefactor          = 1e-30
+    set Dislocation creep exponent           = 1
+    set Dislocation activation energy        = 0
+    set Dislocation activation volume        = 0
+    set Use Drucker-Prager rheology          = true
+    set Cohesions                            = 4e7
+    set Angles of internal friction          = 15
+    set Use adiabatic pressure for yield stress = true
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles, material statistics
+
+  subsection Visualization
+    set List of output variables  = material properties, named additional outputs, strain rate
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Time between data output = 0
+  end
+end
+
+subsection Particles
+  set List of particle properties = grain size
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10000
+    end
+  end
+end
diff --git a/tests/heat_advection_by_melt.cc.bak b/tests/heat_advection_by_melt.cc.bak
new file mode 100644
index 00000000000..3e092d644a0
--- /dev/null
+++ b/tests/heat_advection_by_melt.cc.bak
@@ -0,0 +1,127 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/material_model/melt_global.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+
+namespace aspect
+{
+
+  template <int dim>
+  class PressureBdry:
+    public BoundaryFluidPressure::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id /*boundary_indicator*/,
+        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &fluid_pressure_gradient_outputs
+      ) const
+      {
+        const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+        Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for shear heating with melt."));
+
+        for (unsigned int q=0; q<fluid_pressure_gradient_outputs.size(); ++q)
+          {
+            const double density = material_model_outputs.densities[q];
+            const double melt_density = melt_outputs->fluid_densities[q];
+            const double porosity = material_model_inputs.composition[q][this->introspection().compositional_index_for_name("porosity")];
+
+            const double bulk_density = (porosity * melt_density + (1.0 - porosity) * density);
+            fluid_pressure_gradient_outputs[q] = this->get_gravity_model().gravity_vector(material_model_inputs.position[q]) * bulk_density * normal_vectors[q];
+          }
+      }
+
+  };
+
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class Advection : public MaterialModel::MeltGlobal<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+    };
+
+
+    template <int dim>
+    void
+    Advection<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      MeltGlobal<dim>::evaluate(in, out);
+
+      // fill melt outputs if they exist
+      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          out.densities[i] = 2.0;
+        }
+
+      if (melt_out != nullptr)
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              melt_out->fluid_densities[i] = 1.0;
+              melt_out->permeabilities[i] = 1.0;
+            }
+        }
+
+
+
+    }
+
+  }
+
+}
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(Advection,
+                                   "melt global advection",
+                                   "A simple material model that is like the "
+                                   "'melt simple' model, but has a constant reaction term.")
+  }
+}
diff --git a/tests/heat_advection_by_melt.prm.bak b/tests/heat_advection_by_melt.prm.bak
new file mode 100644
index 00000000000..e2ad0d10ee3
--- /dev/null
+++ b/tests/heat_advection_by_melt.prm.bak
@@ -0,0 +1,143 @@
+# This test is used to check if the shear heating
+# of melt, in particular advective transport of heat due
+# to melt migration, is calculated correctly.
+# There is no in- or outflux of solid material, but melt
+# is allowed to flow in freely, so that it moves upwards
+# with a constant velocity determined by its buoyancy.
+# Hence there is no shear of the solid material, but there
+# is dissipation due to the segregation of melt
+# \eta_f porosity^2 / permeability * (u_f - u_s)^2,
+# and heat is advected by melt migration:
+# porosity \rho_f C_p (u_f \cdot \nabla T).
+#
+# With the material properties in this benchmark, both heating
+# rates should be the same (0.1), and the temperature should stay
+# in equilibrium.
+#
+set Dimension                              = 2
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 0.03125
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 1 + y
+    set Variable names        = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.1; 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+
+  subsection Function
+    set Function expression = 0;0
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+  set Heat advection by melt = true
+end
+
+subsection Heating model
+  set List of model names = shear heating, shear heating with melt
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.1111111111111
+  end
+end
+
+subsection Material model
+  set Model name = melt global advection
+
+  subsection Melt global
+    set Reference solid density    = 2
+    set Reference melt density     = 1
+    set Reference specific heat    = 1
+    set Reference temperature      = 1600
+    set Thermal conductivity       = 0.0
+    set Surface solidus            = 10000.0
+    set Include melting and freezing = false
+    set Reference permeability       = 1
+    set Reference shear viscosity    = 1
+    set Reference bulk viscosity     = 1
+    set Reference melt viscosity     = 10
+    set Thermal viscosity exponent   = 0
+    set Exponential melt weakening factor = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heating statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature, heating
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
diff --git a/tests/heat_advection_by_melt_operator_splitting.cc.bak b/tests/heat_advection_by_melt_operator_splitting.cc.bak
new file mode 100644
index 00000000000..3cb698c7e1d
--- /dev/null
+++ b/tests/heat_advection_by_melt_operator_splitting.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "heat_advection_by_melt.cc"
diff --git a/tests/heat_advection_by_melt_operator_splitting.prm.bak b/tests/heat_advection_by_melt_operator_splitting.prm.bak
new file mode 100644
index 00000000000..4cc0b1f8b79
--- /dev/null
+++ b/tests/heat_advection_by_melt_operator_splitting.prm.bak
@@ -0,0 +1,134 @@
+# This test is a copy of the heat_advection_by_melt test,
+# even with the same results, the only difference is that
+# operator splitting is enabled.
+# It tests if melt heating models work also with operator
+# splitting.
+#
+set Dimension                              = 2
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Use operator splitting                 = true
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 0.1
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 1 + y
+    set Variable names        = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.1; 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+
+  subsection Function
+    set Function expression = 0;0
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+  set Heat advection by melt = true
+end
+
+subsection Heating model
+  set List of model names = shear heating, shear heating with melt
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.1111111111111
+  end
+end
+
+subsection Material model
+  set Model name = melt global advection
+
+  subsection Melt global
+    set Reference solid density    = 2
+    set Reference melt density     = 1
+    set Reference specific heat    = 1
+    set Reference temperature      = 1600
+    set Thermal conductivity       = 0.0
+    set Surface solidus            = 10000.0
+    set Include melting and freezing = false
+    set Reference permeability       = 1
+    set Reference shear viscosity    = 1
+    set Reference bulk viscosity     = 1
+    set Reference melt viscosity     = 10
+    set Thermal viscosity exponent   = 0
+    set Exponential melt weakening factor = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heating statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature, heating
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
diff --git a/tests/heat_flow.prm.bak b/tests/heat_flow.prm.bak
new file mode 100644
index 00000000000..85be7273ae2
--- /dev/null
+++ b/tests/heat_flow.prm.bak
@@ -0,0 +1,4 @@
+include $ASPECT_SOURCE_DIR/cookbooks/heat_flow/heat-flow.prm
+
+set Dimension = 2
+set End time = 0
diff --git a/tests/heat_flow_plume.prm.bak b/tests/heat_flow_plume.prm.bak
new file mode 100644
index 00000000000..3bcc168bd61
--- /dev/null
+++ b/tests/heat_flow_plume.prm.bak
@@ -0,0 +1,4 @@
+include $ASPECT_SOURCE_DIR/cookbooks/heat_flow/heat-flow-plume.prm
+
+set Dimension = 2
+set End time = 0
diff --git a/tests/heat_flux_densities.prm.bak b/tests/heat_flux_densities.prm.bak
new file mode 100644
index 00000000000..01f7650f661
--- /dev/null
+++ b/tests/heat_flux_densities.prm.bak
@@ -0,0 +1,110 @@
+# Compute heat flux densities, this is blankenbach case 2b
+
+set End time                               = 0.004
+set Use years in output instead of seconds = false
+set CFL number = 5.0
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0; 0; 1
+    set Variable names      = depth
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2.5
+    set Y extent = 1
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1, ratio=2.5
+    set Function expression = 1* ((1.0-z/L) + p*cos(k*pi*x/L/ratio)*sin(pi*z/L))
+  end
+end
+
+subsection Material model
+  set Model name = nondimensional
+
+  subsection Nondimensional model
+    set Di                      = 0.0
+    set Ra                      = 1e4
+
+    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
+    set Reference density       = 1
+
+    # The value of the specific heat $cp$. Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.
+    set Reference specific heat = 1
+
+    # Whether to use the TALA instead of the ALA approximation.
+    set Use TALA                = false
+    set Viscosity temperature prefactor = 9.70406052783923433184
+    set Viscosity depth prefactor       = 4.1588830833596718565
+    set gamma                   = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 1.0
+  set Additional refinement times              = 0.1, 0.2, 0.3
+end
+
+subsection Heating model
+  set List of model names = #  adiabatic heating, shear heating#, constant heating
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Formulation
+  set Formulation          = custom # with this selection equivalent to BA
+  set Mass conservation    = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heat flux densities, heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.002
+    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
+  end
+end
diff --git a/tests/heat_flux_map.prm.bak b/tests/heat_flux_map.prm.bak
new file mode 100644
index 00000000000..af5412b1a86
--- /dev/null
+++ b/tests/heat_flux_map.prm.bak
@@ -0,0 +1,72 @@
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.01
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = heat flux map, heat flux statistics
+end
diff --git a/tests/heat_flux_map_vis.prm.bak b/tests/heat_flux_map_vis.prm.bak
new file mode 100644
index 00000000000..53e39af5c80
--- /dev/null
+++ b/tests/heat_flux_map_vis.prm.bak
@@ -0,0 +1,79 @@
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.01
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = heat flux map
+    set Time between graphical output = 0.01
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/heat_flux_map_vis_point_wise.prm.bak b/tests/heat_flux_map_vis_point_wise.prm.bak
new file mode 100644
index 00000000000..6fd247ea814
--- /dev/null
+++ b/tests/heat_flux_map_vis_point_wise.prm.bak
@@ -0,0 +1,20 @@
+# This is a copy of the heat_flux_map_vis test that
+# uses the point-wise output of the heat_flux_map visualization postprocessor.
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/heat_flux_map_vis.prm
+
+
+subsection Postprocess
+  subsection Visualization
+    set Interpolate output = true
+
+    # We only have dirichlet boundaries with tangential velocities, so we can
+    # increase the output resolution as described in the documentation of the 'heat
+    # flux map' postprocessor.
+    subsection Heat flux map
+      set Output point wise heat flux = true
+    end
+  end
+end
diff --git a/tests/heating_function.prm.bak b/tests/heating_function.prm.bak
new file mode 100644
index 00000000000..a1307c698d5
--- /dev/null
+++ b/tests/heating_function.prm.bak
@@ -0,0 +1,67 @@
+# A test for the function heating plugin.
+# The heating function is given in cartesian coordinates.
+
+set Dimension                              = 2
+set End time                               = 0.0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 0.55
+    set Outer radius  = 1.0
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Heating model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = thermal energy density
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = heating statistics, visualization
+
+  subsection Visualization
+    set List of output variables = heating
+    set Output format = gnuplot
+    set Time between graphical output = 0.0
+  end
+end
diff --git a/tests/heating_function_depth.prm.bak b/tests/heating_function_depth.prm.bak
new file mode 100644
index 00000000000..cca71d2c751
--- /dev/null
+++ b/tests/heating_function_depth.prm.bak
@@ -0,0 +1,16 @@
+# A test for the function heating plugin.
+# The heating function is given in terms of depth.
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/heating_function.prm
+
+
+subsection Heating model
+  set List of model names = function
+
+  subsection Function
+    set Coordinate system = depth
+    set Function expression = x
+  end
+end
diff --git a/tests/heating_function_spherical.prm.bak b/tests/heating_function_spherical.prm.bak
new file mode 100644
index 00000000000..2376dfe12b7
--- /dev/null
+++ b/tests/heating_function_spherical.prm.bak
@@ -0,0 +1,17 @@
+# A test for the function heating plugin.
+# The heating function is given in spherical coordinates.
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/heating_function.prm
+
+
+subsection Heating model
+  set List of model names = function
+
+  subsection Function
+    set Coordinate system = spherical
+    set Variable names = r,phi
+    set Function expression = phi
+  end
+end
diff --git a/tests/hexagonal_initial_temperature.prm.bak b/tests/hexagonal_initial_temperature.prm.bak
new file mode 100644
index 00000000000..74f9fa5a6cd
--- /dev/null
+++ b/tests/hexagonal_initial_temperature.prm.bak
@@ -0,0 +1,84 @@
+# Test the spherical hexagonal perturbation initial temperature model
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 360
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Additional refinement times              =
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/hill_diffusion.prm.bak b/tests/hill_diffusion.prm.bak
new file mode 100644
index 00000000000..314114a2766
--- /dev/null
+++ b/tests/hill_diffusion.prm.bak
@@ -0,0 +1,115 @@
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.001
+set Maximum time step                      = 0.0005
+set Nonlinear solver scheme = no Advection, no Stokes
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# 1x1 box with an initial hill topography
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function constants = A=0.075, L=1.
+      set Function expression = \
+                                A * sin(x*pi)
+    end
+  end
+end
+
+# Temperature effects are ignored
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = initial temperature
+end
+
+# Free slip on all boundaries
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The mesh will be deformed according to the displacement
+# of the surface nodes due to diffusion of the topography.
+# The mesh is allowed to move vertical along the left and
+# right boundary.
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: diffusion
+  set Additional tangential mesh velocity boundary indicators = left, right
+
+  subsection Diffusion
+    # The diffusivity
+    set Hillslope transport coefficient = 0.25
+  end
+end
+
+# Vertical gravity
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+# One material with unity properties
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 6
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set Output mesh velocity = true
+    set Interpolate output = false
+    set Output format = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                         = 1e-7
+  end
+end
diff --git a/tests/hill_diffusion_3D.prm.bak b/tests/hill_diffusion_3D.prm.bak
new file mode 100644
index 00000000000..dea23489938
--- /dev/null
+++ b/tests/hill_diffusion_3D.prm.bak
@@ -0,0 +1,116 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set End time                               = 0.001
+set Maximum time step                      = 0.0005
+set Nonlinear solver scheme = no Advection, no Stokes
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# 1x1 box with an initial hill topography
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function constants = A=0.075, L=1.
+      set Function expression = \
+                                A * sin(x*pi)
+    end
+  end
+end
+
+# Temperature effects are ignored
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = initial temperature
+end
+
+# Free slip on all boundaries
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top, front, back
+end
+
+# The mesh will be deformed according to the displacement
+# of the surface nodes due to diffusion of the topography.
+# The mesh is allowed to move vertical along the left and
+# right boundary.
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: diffusion
+  set Additional tangential mesh velocity boundary indicators = left, right, front, back
+
+  subsection Diffusion
+    # The diffusivity
+    set Hillslope transport coefficient = 0.25
+  end
+end
+
+# Vertical gravity
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+# One material with unity properties
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set Output mesh velocity = true
+    set Interpolate output = false
+    set Output format = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                         = 1e-7
+  end
+end
diff --git a/tests/hk04_olivine_composite_hydration_prefactor.prm.bak b/tests/hk04_olivine_composite_hydration_prefactor.prm.bak
new file mode 100644
index 00000000000..e5c60de5094
--- /dev/null
+++ b/tests/hk04_olivine_composite_hydration_prefactor.prm.bak
@@ -0,0 +1,144 @@
+# A test case that checks the water fugacity viscous prefactor
+# multiplication scheme in combination with the visco plastic material model.
+# Following the flow law for wet olivine composite (diffusion and dislocation)
+# creep from Hirth & Kohlstaedt 2004 (10.1029/138GM06), the exact
+# viscosity is calculated in python through:
+# import numpy as np
+# R = 8.3144621
+# P = 1e9 Pa
+# T = 1173 K
+# edot_ii = 1e-17
+# n_disl = 3.5
+# E_disl = 520e3 J/mol
+# V_disl = 22e-6 m^3/mol
+# r_disl = 1.2
+# A_disl = 1600 / 1e6 / 1e6**n / 1e6**r 1/Pa^(4.7)/s
+#
+# n_diff = 1
+# E_diff = 375e3 J/mol
+# V_diff = 10e-6 m^3/mol
+# r_diff = 0.7
+# d = 1e-3 m
+# m = 3
+# A_diff = 2.5e7 / 1e6**n_diff / 1e6**m / 1e6**r_diff
+
+# A_H2O = 2.6e-5 1/Pa
+# activation_energy_H2O = 40e3 J/mol/K
+# activation_volume_H2O = 10e-6 m^3/mol
+#
+# M_H2O = 0.01801528 kg/mol
+# M_olivine = 0.1470027 kg/mol
+#
+# weight_fraction_h2o = 0.01
+# weight_fraction_olivine = 1 - weight_fraction_h2o
+# COH = (wt_fraction_h2o/M_H2O) / (weight_fraction_olivine/M_olivine) * 1e6
+#
+# fH2O = COH / A_H2O * np.exp((activation_energy_H2O + P*activation_volume_H2O)/(R * T))
+#
+# viscosity_disl = 0.5 * A_disl**(-1/n_disl) * edot_ii^((1-n_disl)/n_disl) * np.exp((E_disl + P*V_disl) / (n_disl*R*T)) * fH2O**(-r_disl/n_disl)
+# viscosity_diff = 0.5 * A_diff**(-1/n_diff) * d**m * np.exp((E_diff + P*V_diff) / (n_diff*R*T)) * fH2O**(-r_diff/n_diff)
+#
+# viscosity_comp = (viscosity_disl * viscosity_diff) / (viscosity_disl + viscosity_diff) = 2.62814004323392e20 Pa s
+# The viscosity should be equal to 2.6281e20 Pa s, and the material model should return this viscosity.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 1.e9
+
+subsection Compositional fields
+  set Names of fields  = bound_fluid
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.01
+  end
+end
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# No boundary-driven deformation, but the strain-rate used by the material
+# model is set in the material model section through the parameters
+# "Reference strain rate" and "Minimum strain rate".
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+# Initial temperature conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1173
+  end
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Dislocation creep parameters
+    # The water fugacity exponent is 1.2, but we need to divide by
+    # the stress exponent, so we input r/n=0.34285714285714286.
+    set Reference strain rate                          = 1e-17
+    set Minimum strain rate                            = 1e-17
+    set Viscous flow law                               = composite
+    set Prefactors for dislocation creep               = 1.0095317511683098e-25
+    set Stress exponents for dislocation creep         = 3.5
+    set Activation energies for dislocation creep      = 520e3
+    set Activation volumes for dislocation creep       = 22e-6
+    set Water fugacity exponents for dislocation creep = 0.34285714285714286
+    set Prefactors for diffusion creep                 = 1.5773933612004842e-21
+    set Stress exponents for diffusion creep           = 1.0
+    set Activation energies for diffusion creep        = 375e3
+    set Activation volumes for diffusion creep         = 10e-6
+    set Grain size                                     = 1e-3
+    set Water fugacity exponents for diffusion creep   = 0.7
+    set Viscosity prefactor scheme                     = HK04 olivine hydration
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = material statistics, visualization
+
+  subsection Visualization
+    set Interpolate output       = false
+    set List of output variables = material properties
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/hk04_olivine_composite_hydration_prefactor_cutoff.prm.bak b/tests/hk04_olivine_composite_hydration_prefactor_cutoff.prm.bak
new file mode 100644
index 00000000000..fac8db4be49
--- /dev/null
+++ b/tests/hk04_olivine_composite_hydration_prefactor_cutoff.prm.bak
@@ -0,0 +1,23 @@
+# A test case that checks the water fugacity viscous prefactor
+# multiplication scheme in combination with the visco plastic material model.
+# This test is almost identical to hk04_olivine_composite_hydration_prefactor.prm,
+# with the only difference being that the bound_fluid is 0. This test checks that
+# the HK04 olivine hydration viscosity prefactor scheme will not divide by 0, but
+# will instead use the user input value set using 'Minimum mass fraction bound
+# water content for fugacity'. The default value is 6.15e-6 (i.e. 6.15 ppm wt. H2O),
+# and so following the same calculation outlined in
+# hk04_olivine_composite_hydration_prefactor.prm, where T = 1173 K, P = 1 GPa, and
+# edot_ii = 1e-17 1/s, the material model should return 3.1724782150033374e22 Pa s
+# for the viscosity.
+
+include $ASPECT_SOURCE_DIR/tests/hk04_olivine_composite_hydration_prefactor.prm
+
+
+# Set the bound water everywhere in the model to be 0.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0
+  end
+end
diff --git a/tests/hk04_olivine_diffusion_hydration_prefactor.prm.bak b/tests/hk04_olivine_diffusion_hydration_prefactor.prm.bak
new file mode 100644
index 00000000000..5acaeb092e6
--- /dev/null
+++ b/tests/hk04_olivine_diffusion_hydration_prefactor.prm.bak
@@ -0,0 +1,131 @@
+# A test case that checks the water fugacity viscous prefactor
+# multiplication scheme in combination with the visco plastic material model.
+# Following the flow law for wet olivine diffusion creep from
+# Hirth & Kohlstaedt 2004 (10.1029/138GM06), the exact
+# viscosity is calculated in python through:
+# import numpy as np
+# m = 3
+# d = 1e-3 m
+# E = 375e3 J/mol
+# V = 15e-6 m^3/mol
+# R = 8.3144621
+# P = 10e9 Pa
+# r = 0.7
+# T = 1673 K
+# A_diff = 2.5e7 / 1e6 / 1e6**m / 1e6**r 1/Pa^2/m^3/s
+#
+# A_H2O = 26 / 1e6**r 1/Pa
+# activation_energy_H2O = 40e3 J/mol
+# activation_volume_H2O = 10e-6 m^3/mol
+#
+# M_H2O = 18.01528
+# M_olivine = 147.0027
+#
+# weight_fraction_h2o = 0.01
+# weight_fraction_olivine = 1 - weight_fraction_h2o
+# COH = (wt_fraction_h2o/M_H2O) / (weight_fraction_olivine/M_olivine) * 1e6
+#
+# fH2O = COH / A_H2O * np.exp((activation_energy_H2O + P*activation_volume_H2O)/(R * T))
+# viscosity_analytic = 0.5 * A_diff**(-1) * d**(m) * np.exp((E + P*V) / R / T) * fH2O**(-r)
+#
+# In the background composition, r=0.7 and the viscosity should be equal to 2.766e19.
+#
+# In the solid_2 composition, r=0.0 and the viscosity should be equal to 4.924e23.
+# Combined, this should result in an average model viscosity of 2.462e23.
+# The material model should return this viscosity.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 10.e9
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = solid_2, bound_fluid
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if(y<=50e3, 1.0, 0.0); 0.01
+  end
+end
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# No boundary-driven deformation, but the strain-rate used by the material
+# model is set in the material model section through the parameters
+# "Reference strain rate" and "Minimum strain rate".
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+# Initial temperature conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1673
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Diffusion creep parameters
+    # In the background, the water fugacity exponent = 0.7, and this requires
+    # a different prefactor due to the dependence of A_diff on the fugacity exponent r.
+    set Viscous flow law                             = diffusion
+    set Prefactors for diffusion creep               = 1.57739e-21, 2.5e-17, 2.5e-17
+    set Stress exponents for diffusion creep         = 1.0
+    set Activation energies for diffusion creep      = 375e3
+    set Activation volumes for diffusion creep       = 15e-6
+    set Grain size                                   = 1e-3
+    set Water fugacity exponents for diffusion creep = 0.7, 0.0, 0.0
+    set Viscosity prefactor scheme                   = HK04 olivine hydration
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = material statistics, visualization
+
+  subsection Visualization
+    set Interpolate output       = false
+    set List of output variables = material properties
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/hk04_olivine_dislocation_hydration_prefactor.prm.bak b/tests/hk04_olivine_dislocation_hydration_prefactor.prm.bak
new file mode 100644
index 00000000000..5d172398e94
--- /dev/null
+++ b/tests/hk04_olivine_dislocation_hydration_prefactor.prm.bak
@@ -0,0 +1,128 @@
+# A test case that checks the water fugacity viscous prefactor
+# multiplication scheme in combination with the visco plastic material model.
+# Following the flow law for wet olivine dislocation creep from
+# Hirth & Kohlstaedt 2004 (10.1029/138GM06), the exact
+# viscosity is calculated in python through:
+# import numpy as np
+# n = 3.5
+# E = 520e3 J/mol
+# V = 22e-6 m^3/mol
+# R = 8.3144621
+# P = 1e9 Pa
+# r = 1.2
+# edot_ii = 1e-13
+# T = 1173 K
+# A_disl = 1600 / 1e6 / 1e6**n / 1e6**r 1/Pa^(4.7)/s
+#
+# A_H2O = 2.6e-5 1/Pa
+# activation_energy_H2O = 40e3 J/mol/K
+# activation_volume_H2O = 10e-6 m^3/mol
+#
+# M_H2O = 0.01801528 kg/mol
+# M_olivine = 0.1470027 kg/mol
+#
+# weight_fraction_h2o = 0.01
+# weight_fraction_olivine = 1 - weight_fraction_h2o
+# COH = (wt_fraction_h2o/M_H2O) / (weight_fraction_olivine/M_olivine) * 1e6
+#
+# fH2O = COH / A_H2O * np.exp((activation_energy_H2O + P*activation_volume_H2O)/(R * T))
+# viscosity_analytic = 0.5 * A_disl**(-1/n) * edot_ii^((1-n)/n) * np.exp((E + P*V) / (n*R*T)) * fH2O**(-r/n)
+# The viscosity should be equal to 1.00291e19, and the material model should return this viscosity.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 1.e9
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = bound_fluid
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.01
+  end
+end
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# No boundary-driven deformation, but the strain-rate used by the material
+# model is set in the material model section through the parameters
+# "Reference strain rate" and "Minimum strain rate".
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+# Initial temperature conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1173
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Dislocation creep parameters
+    # The water fugacity exponent reported by Hirth & Kohlstaedt for dislocation
+    # creep is 1.2, but ASPECT requires that the water fugacity exponent is r/n,
+    # where n is the stress exponent and thus we input 1.2/3.5 = 0.34285714285714286
+    set Reference strain rate                          = 1e-13
+    set Minimum strain rate                            = 1e-13
+    set Viscous flow law                               = dislocation
+    set Prefactors for dislocation creep               = 1.0095317511683098e-25
+    set Stress exponents for dislocation creep         = 3.5
+    set Activation energies for dislocation creep      = 520e3
+    set Activation volumes for dislocation creep       = 22e-6
+    set Water fugacity exponents for dislocation creep = 0.34285714285714286
+    set Viscosity prefactor scheme                     = HK04 olivine hydration
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = material statistics, visualization
+
+  subsection Visualization
+    set Interpolate output       = false
+    set List of output variables = material properties
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/hollow_sphere.cc.bak b/tests/hollow_sphere.cc.bak
new file mode 100644
index 00000000000..abbd72c795b
--- /dev/null
+++ b/tests/hollow_sphere.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/hollow_sphere/hollow_sphere.cc"
diff --git a/tests/hollow_sphere.prm.bak b/tests/hollow_sphere.prm.bak
new file mode 100644
index 00000000000..b4bbc3647bb
--- /dev/null
+++ b/tests/hollow_sphere.prm.bak
@@ -0,0 +1,99 @@
+# The 3D HollowSphere benchmark, for which an
+# analytical solution is available (Thieulot, in prep).
+
+
+############### Global parameters
+
+set Additional shared libraries            = ./libhollow_sphere.so
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Output directory                       = output
+set Pressure normalization                 = surface
+
+############### Parameters describing the model
+# The setup is a 3D shell
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 0.5
+    set Outer radius = 1.0
+    set Cells along circumference = 12
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = inner : HollowSphereBoundary, \
+                                                outer : HollowSphereBoundary
+end
+
+subsection Material model
+  set Model name = HollowSphereMaterial
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 1.0
+  end
+end
+
+subsection HollowSphere benchmark
+  #Viscosity parameter is m
+  set Viscosity parameter             = -1
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, HollowSpherePostprocessor
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density, viscosity, strain rate
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/hollow_sphere_gmg.cc.bak b/tests/hollow_sphere_gmg.cc.bak
new file mode 100644
index 00000000000..abbd72c795b
--- /dev/null
+++ b/tests/hollow_sphere_gmg.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/hollow_sphere/hollow_sphere.cc"
diff --git a/tests/hollow_sphere_gmg.prm.bak b/tests/hollow_sphere_gmg.prm.bak
new file mode 100644
index 00000000000..160aadc597d
--- /dev/null
+++ b/tests/hollow_sphere_gmg.prm.bak
@@ -0,0 +1,101 @@
+# The 3D HollowSphere benchmark solved with the block
+# GMG preconditioner and harmonic averaging
+
+
+############### Global parameters
+
+set Additional shared libraries            = ./libhollow_sphere.so
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Output directory                       = output
+set Pressure normalization                 = surface
+
+############### Parameters describing the model
+# The setup is a 3D shell
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 0.5
+    set Outer radius = 1.0
+    set Cells along circumference = 12
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = inner : HollowSphereBoundary, \
+                                                outer : HollowSphereBoundary
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 1.0
+  end
+end
+
+subsection HollowSphere benchmark
+  #Viscosity parameter is m
+  set Viscosity parameter             = -1
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, HollowSpherePostprocessor
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density, viscosity, strain rate
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  set Model name = HollowSphereMaterial
+  set Material averaging = harmonic average
+end
diff --git a/tests/hollow_sphere_gmg_project_q1.cc.bak b/tests/hollow_sphere_gmg_project_q1.cc.bak
new file mode 100644
index 00000000000..abbd72c795b
--- /dev/null
+++ b/tests/hollow_sphere_gmg_project_q1.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/hollow_sphere/hollow_sphere.cc"
diff --git a/tests/hollow_sphere_gmg_project_q1.prm.bak b/tests/hollow_sphere_gmg_project_q1.prm.bak
new file mode 100644
index 00000000000..353b64698a8
--- /dev/null
+++ b/tests/hollow_sphere_gmg_project_q1.prm.bak
@@ -0,0 +1,29 @@
+# The 3D HollowSphere benchmark solved with the block
+# GMG preconditioner and project to Q1 only viscosity
+# averaging
+
+include $ASPECT_SOURCE_DIR/benchmarks/hollow_sphere/hollow_sphere.prm
+
+set Dimension = 3
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 100
+  end
+end
+
+subsection Material model
+  set Model name = HollowSphereMaterial
+  set Material averaging = project to Q1 only viscosity
+end
+
+subsection Postprocess
+  set List of postprocessors = HollowSpherePostprocessor
+end
diff --git a/tests/hollow_sphere_gmg_q3.cc.bak b/tests/hollow_sphere_gmg_q3.cc.bak
new file mode 100644
index 00000000000..abbd72c795b
--- /dev/null
+++ b/tests/hollow_sphere_gmg_q3.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/hollow_sphere/hollow_sphere.cc"
diff --git a/tests/hollow_sphere_gmg_q3.prm.bak b/tests/hollow_sphere_gmg_q3.prm.bak
new file mode 100644
index 00000000000..e7f12bdbb80
--- /dev/null
+++ b/tests/hollow_sphere_gmg_q3.prm.bak
@@ -0,0 +1,105 @@
+# Like hollow_sphere_gmg.prm but with Q3 elements
+
+
+############### Global parameters
+
+set Additional shared libraries            = ./libhollow_sphere.so
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Output directory                       = output
+set Pressure normalization                 = surface
+
+############### Parameters describing the model
+# The setup is a 3D shell
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 0.5
+    set Outer radius = 1.0
+    set Cells along circumference = 12
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = inner : HollowSphereBoundary, \
+                                                outer : HollowSphereBoundary
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 1.0
+  end
+end
+
+subsection HollowSphere benchmark
+  #Viscosity parameter is m
+  set Viscosity parameter             = -1
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Refinement fraction                = 0.1
+  set Strategy                           = velocity
+  set Run postprocessors on initial refinement            = true
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, HollowSpherePostprocessor
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density, viscosity, strain rate
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  set Model name = HollowSphereMaterial
+  set Material averaging = harmonic average
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree            = 3
+end
diff --git a/tests/hydrostatic_compression.cc.bak b/tests/hydrostatic_compression.cc.bak
new file mode 100644
index 00000000000..e558a39bdac
--- /dev/null
+++ b/tests/hydrostatic_compression.cc.bak
@@ -0,0 +1,313 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/simulator.h>
+#include <aspect/simulator/assemblers/interface.h>
+#include <aspect/gravity_model/interface.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  template <int dim>
+  class TestMaterial:
+    public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual bool is_compressible () const
+      {
+        return true;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        const double alpha = -0.2;     // T0 = 100
+
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            const double x = in.position[i](0);
+            const double z = in.position[i](1);
+            const double p = in.pressure[i];
+            const double T = in.temperature[i];
+            out.viscosities[i] = 1.0;
+            out.densities[i] = exp(alpha*T)*p;
+            out.thermal_expansion_coefficients[i] = -alpha;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 1.0/p;
+          }
+      }
+  };
+
+
+  template <int dim>
+  class Gravity : public aspect::GravityModel::Interface<dim>
+  {
+    public:
+      virtual Tensor<1,dim> gravity_vector (const Point<dim> &pos) const
+      {
+        const double x=pos[0];
+        const double z=pos[1];
+        const double pi = numbers::PI;
+
+        const double T0 = 100.0;
+        const double alpha = -0.2;
+
+        Tensor<1,dim> gravity;
+        gravity[0] = -(0.1e1 + 0.2e1 * alpha * (double) pi * cos((double) (2 * pi * x)) * cos((double) (pi * z))) / exp(alpha * (T0 + sin((double) (2 * pi * x)) * cos((double) (pi * z))));
+        gravity[1] = -(0.1e1 - alpha * sin((double) (2 * pi * x)) * (double) pi * sin((double) (pi * z))) / exp(alpha * (T0 + sin((double) (2 * pi * x)) * cos((double) (pi * z))));
+
+
+        return gravity;
+      }
+  };
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(dim+2) {}
+      virtual void vector_value (const Point<dim>   &p,
+                                 Vector<double>   &values) const
+      {
+        double x = p(0);
+        double z = p(1);
+        const double pi = numbers::PI;
+        const double u1 = 1.0;
+        const double w1 = 0.5;
+
+        values[0] = -2.0*u1*pi*sin((double) (2*pi*x)) + u1*cos((double) (2*pi*x)) - w1*(pi*pi+1.0)*cos((double) (pi*z));
+        values[1] = -w1*pi*sin(pi*z)+w1*cos(pi*z)-u1*(4*pi*pi+1)*cos(2*pi*x);
+        values[2] = 0.5-z;
+      }
+  };
+
+  /**
+    * A postprocessor that evaluates the accuracy of the solution
+    * by using the L2 norm.
+    */
+  template <int dim>
+  class ConvergencePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Generate graphical output from the current solution.
+       */
+      virtual
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics);
+
+  };
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  ConvergencePostprocessor<dim>::execute (TableHandler &statistics)
+  {
+    RefFunction<dim> ref_func;
+    const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.velocities).degree+2);
+
+    const unsigned int n_total_comp = this->introspection().n_components;
+
+    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+
+    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                        n_total_comp);
+    ComponentSelectFunction<dim> comp_p(dim, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p);
+
+    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
+    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
+
+    std::ostringstream os;
+    os << std::scientific
+       << "ndofs= " << this->get_solution().size()
+       << " u_L2= " << u_l2
+       << " p_L2= " << p_l2
+       ;
+
+    return std::make_pair("Errors", os.str());
+  }
+
+  template <int dim>
+  class ForceAssembler :
+    public aspect::Assemblers::Interface<dim>, public SimulatorAccess<dim>
+  {
+
+    public:
+
+      virtual
+      void
+      execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
+               internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
+      {
+        internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
+        internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
+
+        const Introspection<dim> &introspection = this->introspection();
+        const FiniteElement<dim> &fe = this->get_fe();
+        const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
+        const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
+        const double pressure_scaling = this->get_pressure_scaling();
+
+        for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+          {
+            const unsigned int component_index_i = fe.system_to_component_index(i).first;
+
+            if (component_index_i == introspection.component_indices.pressure
+                ||
+                (
+                  component_index_i >= introspection.component_indices.velocities[0]
+                  &&
+                  component_index_i <= introspection.component_indices.velocities[dim-1]
+                ))
+              {
+                data.local_dof_indices[i_stokes] = scratch.local_dof_indices[i];
+                ++i_stokes;
+              }
+            ++i;
+          }
+
+        for (unsigned int q=0; q<n_q_points; ++q)
+          {
+            const double x = scratch.finite_element_values.quadrature_point(q)[0];
+            const double z = scratch.finite_element_values.quadrature_point(q)[1];
+
+            const double pi = numbers::PI;
+            const double u1 = 1.0;
+            const double w1 = 0.5;
+            const double alpha = -0.2;
+
+            Tensor<1,dim> force_u;
+            const double force_p = 0.0;
+
+            force_u[0]= -0.32e2 / 0.3e1 * u1 * pow(pi, 0.3e1) * sin(0.2e1 * pi * x)
+                        + 0.16e2 / 0.3e1 * u1 * pi * pi * cos(0.2e1 * pi * x)
+                        - w1 * (pi * pi + 0.1e1) * pi * pi * cos(pi * z)
+                        + (0.5e0 - z) * (0.1e1 + 0.2e1 * alpha * pi * cos(0.2e1 * pi * x) * cos(pi * z));
+
+            force_u[1]= -0.4e1 / 0.3e1 * w1 * pow(pi, 0.3e1) * sin(pi * z)
+                        + 0.4e1 / 0.3e1 * w1 * pi * pi * cos(pi * z)
+                        - 0.4e1 * u1 * (0.4e1 * pi * pi + 0.1e1) * pi * pi * cos(0.2e1 * pi * x)
+                        - 0.1e1 + (0.5e0 - z) * (0.1e1 - alpha * sin(0.2e1 * pi * x) * pi * sin(pi * z));
+
+
+            for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
+              {
+                const unsigned int component_index_i = fe.system_to_component_index(i).first;
+
+                if (component_index_i == introspection.component_indices.pressure
+                    ||
+                    (
+                      component_index_i >= introspection.component_indices.velocities[0]
+                      &&
+                      component_index_i <= introspection.component_indices.velocities[dim-1]
+                    ))
+                  {
+                    scratch.phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
+                    scratch.phi_p[i_stokes]   = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
+
+                    ++i_stokes;
+                  }
+                ++i;
+              }
+
+            const double JxW = scratch.finite_element_values.JxW(q);
+
+            for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
+              {
+                data.local_rhs(i) += (
+                                       (force_u * scratch.phi_u[i]
+                                        + pressure_scaling * force_p * scratch.phi_p[i])
+                                     )
+                                     * JxW;
+              }
+          }
+      }
+
+  };
+
+
+  template <int dim>
+  void add_force_assembler(const SimulatorAccess<dim> &simulator_access,
+                           Assemblers::Manager<dim> &assemblers)
+  {
+
+    Assemblers::Interface<dim> *assembler = new ForceAssembler<dim>();
+    assemblers.stokes_system.push_back(std::unique_ptr<Assemblers::Interface<dim>>(assembler));
+  }
+}
+
+
+
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  signals.set_assemblers.connect (&aspect::add_force_assembler<dim>);
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
+
+
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_GRAVITY_MODEL(Gravity,
+                                "MyGravity",
+                                "")
+
+  ASPECT_REGISTER_MATERIAL_MODEL(TestMaterial,
+                                 "test material",
+                                 "")
+
+  ASPECT_REGISTER_POSTPROCESSOR(ConvergencePostprocessor,
+                                "error calculation",
+                                "")
+}
diff --git a/tests/hydrostatic_compression.prm.bak b/tests/hydrostatic_compression.prm.bak
new file mode 100644
index 00000000000..d502cb1c7aa
--- /dev/null
+++ b/tests/hydrostatic_compression.prm.bak
@@ -0,0 +1,113 @@
+# A testcase with manufactured solution that demonstrates that the mass
+# formulation "hydrostatic pressure" is correct and converges. The example is
+# constructed to have
+#
+# -\nabla \cdot \mathbf{u} = \left( \kappa \rho \textbf{g} - \alpha \nabla T \right) \cdot \textbf{u}
+#
+# using a specific gravity and a force vector is used to enforce the correct u
+# and p (by canceling out the gravity term). This means the test will only
+# work for this mass formulation.
+
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 50
+set Nonlinear solver tolerance             = 1e-10
+set Adiabatic surface temperature          = 100.0
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0.01
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Refinement fraction                      = 0.0
+  set Coarsening fraction                      = 0.0
+  set Time steps between mesh refinement       = 0
+  set Initial adaptive refinement              = 0
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation    = hydrostatic compression
+  set Temperature equation = real density
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,1,2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 101.0
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 99.0
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 0.99
+
+    #    set Box origin X coordinate = -1
+    set Box origin Y coordinate = -0.5
+  end
+end
+
+subsection Gravity model
+  set Model name = MyGravity
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+
+  subsection Function
+    set Function constants = u1=1,w1=0.5
+    set Function expression = -2*u1*pi*sin(2*pi*x)+u1*cos(2*pi*x)-w1*(pi*pi+1)*cos(pi*z);-w1*pi*sin(pi*z)+w1*cos(pi*z)-u1*(4*pi*pi+1)*cos(2*pi*x)
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 100.0 + sin(2*pi*x) * cos(pi*z)
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = test material
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, pressure statistics, velocity boundary statistics, error calculation
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = material properties, gravity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/inclusion_2.cc.bak b/tests/inclusion_2.cc.bak
new file mode 100644
index 00000000000..02f52b98641
--- /dev/null
+++ b/tests/inclusion_2.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/inclusion/inclusion.cc"
diff --git a/tests/inclusion_2.prm.bak b/tests/inclusion_2.prm.bak
new file mode 100644
index 00000000000..25b17b1fcf3
--- /dev/null
+++ b/tests/inclusion_2.prm.bak
@@ -0,0 +1,86 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 1
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = InclusionMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = thermal energy density
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, InclusionPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/inclusion_4.cc.bak b/tests/inclusion_4.cc.bak
new file mode 100644
index 00000000000..02f52b98641
--- /dev/null
+++ b/tests/inclusion_4.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/inclusion/inclusion.cc"
diff --git a/tests/inclusion_4.prm.bak b/tests/inclusion_4.prm.bak
new file mode 100644
index 00000000000..524af027cc1
--- /dev/null
+++ b/tests/inclusion_4.prm.bak
@@ -0,0 +1,86 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 1
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = InclusionMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = thermal energy density
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, InclusionPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/inclusion_adaptive.cc.bak b/tests/inclusion_adaptive.cc.bak
new file mode 100644
index 00000000000..02f52b98641
--- /dev/null
+++ b/tests/inclusion_adaptive.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/inclusion/inclusion.cc"
diff --git a/tests/inclusion_adaptive.prm.bak b/tests/inclusion_adaptive.prm.bak
new file mode 100644
index 00000000000..0f1ae0ff10e
--- /dev/null
+++ b/tests/inclusion_adaptive.prm.bak
@@ -0,0 +1,89 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 1
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = InclusionMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 5
+  set Initial global refinement          = 3
+  set Run postprocessors on initial refinement = true
+  set Refinement fraction                = 0.5#33333
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, InclusionPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/infill_density_flexure.cc.bak b/tests/infill_density_flexure.cc.bak
new file mode 100644
index 00000000000..31e53d711fa
--- /dev/null
+++ b/tests/infill_density_flexure.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/infill_density/infill_ascii_data.cc"
diff --git a/tests/infill_density_flexure.prm.bak b/tests/infill_density_flexure.prm.bak
new file mode 100644
index 00000000000..c315615328a
--- /dev/null
+++ b/tests/infill_density_flexure.prm.bak
@@ -0,0 +1,10 @@
+# Infill density benchmark test
+
+include $ASPECT_SOURCE_DIR/benchmarks/infill_density/infill_ascii.prm
+
+set End time = 0
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 2
+end
diff --git a/tests/initial_composition_list.prm.bak b/tests/initial_composition_list.prm.bak
new file mode 100644
index 00000000000..67c24fb5d05
--- /dev/null
+++ b/tests/initial_composition_list.prm.bak
@@ -0,0 +1,81 @@
+##### simple test for ascii data initial composition
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set List of model names = ascii data, function
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-0.5,0.1)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
+end
diff --git a/tests/initial_composition_list_using_maximum.prm.bak b/tests/initial_composition_list_using_maximum.prm.bak
new file mode 100644
index 00000000000..fbf3479dfd8
--- /dev/null
+++ b/tests/initial_composition_list_using_maximum.prm.bak
@@ -0,0 +1,82 @@
+##### simple test for ascii data initial composition
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set List of model names = ascii data, function
+  set List of model operators = add, maximum
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,0.5,0.1)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
+end
diff --git a/tests/initial_composition_list_using_minimum.prm.bak b/tests/initial_composition_list_using_minimum.prm.bak
new file mode 100644
index 00000000000..53cad23e421
--- /dev/null
+++ b/tests/initial_composition_list_using_minimum.prm.bak
@@ -0,0 +1,82 @@
+##### simple test for ascii data initial composition
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set List of model names = ascii data, function
+  set List of model operators = add, minimum
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,0.5,0.1)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
+end
diff --git a/tests/initial_composition_list_using_subtract.prm.bak b/tests/initial_composition_list_using_subtract.prm.bak
new file mode 100644
index 00000000000..49b6b71f971
--- /dev/null
+++ b/tests/initial_composition_list_using_subtract.prm.bak
@@ -0,0 +1,82 @@
+##### simple test for ascii data initial composition
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set List of model names = ascii data, function
+  set List of model operators = add, subtract
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,0.5,-0.1)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
+end
diff --git a/tests/initial_condition_S20RTS.prm.bak b/tests/initial_condition_S20RTS.prm.bak
new file mode 100644
index 00000000000..b4eec6b42a5
--- /dev/null
+++ b/tests/initial_condition_S20RTS.prm.bak
@@ -0,0 +1,70 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0
+  set Tangential velocity boundary indicators = 1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1600
+    set Outer temperature = 1600
+  end
+end
+
+subsection Initial temperature model
+  set Model name = S40RTS perturbation
+
+  subsection S40RTS perturbation
+    set Initial condition file name           = S20RTS.sph
+    set Vs to density scaling                 = 0.3
+    set Thermal expansion coefficient in initial temperature scaling = 4e-5
+    set Reference temperature                 = 1600
+    set Remove degree 0 from perturbation     = true
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/initial_condition_S20RTS_2D.prm.bak b/tests/initial_condition_S20RTS_2D.prm.bak
new file mode 100644
index 00000000000..eab87fddfd9
--- /dev/null
+++ b/tests/initial_condition_S20RTS_2D.prm.bak
@@ -0,0 +1,10 @@
+# This is a variation of the initial_condition_S20RTS.prm test
+# that tests the same plugin for 2D models.
+
+include $ASPECT_SOURCE_DIR/tests/initial_condition_S20RTS.prm
+
+set Dimension = 2
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+end
diff --git a/tests/initial_condition_S20RTS_dgp.prm.bak b/tests/initial_condition_S20RTS_dgp.prm.bak
new file mode 100644
index 00000000000..3136af608d8
--- /dev/null
+++ b/tests/initial_condition_S20RTS_dgp.prm.bak
@@ -0,0 +1,75 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree            = 1
+  set Use locally conservative discretization      = true
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0
+  set Tangential velocity boundary indicators = 1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1600
+    set Outer temperature = 1600
+  end
+end
+
+subsection Initial temperature model
+  set Model name = S40RTS perturbation
+
+  subsection S40RTS perturbation
+    set Initial condition file name           = S20RTS.sph
+    set Vs to density scaling                 = 0.3
+    set Thermal expansion coefficient in initial temperature scaling = 4e-5
+    set Reference temperature                 = 1600
+    set Remove degree 0 from perturbation     = true
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/initial_condition_S40RTS.prm.bak b/tests/initial_condition_S40RTS.prm.bak
new file mode 100644
index 00000000000..11434a11692
--- /dev/null
+++ b/tests/initial_condition_S40RTS.prm.bak
@@ -0,0 +1,71 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer,west,south,east
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner,outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1600
+    set Outer temperature = 1600
+  end
+end
+
+subsection Initial temperature model
+  set Model name = S40RTS perturbation
+
+  subsection S40RTS perturbation
+    set Initial condition file name           = S40RTS.sph
+    set Vs to density scaling                 = 0.3
+    set Thermal expansion coefficient in initial temperature scaling = 4e-5
+    set Reference temperature                 = 1600
+    set Remove degree 0 from perturbation     = true
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/initial_condition_SAVANI.prm.bak b/tests/initial_condition_SAVANI.prm.bak
new file mode 100644
index 00000000000..c191ebe67ad
--- /dev/null
+++ b/tests/initial_condition_SAVANI.prm.bak
@@ -0,0 +1,74 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+    set Reference temperature         = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer, west, south, east
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1600
+    set Outer temperature = 1600
+  end
+end
+
+subsection Initial temperature model
+  set Model name = SAVANI perturbation
+
+  subsection SAVANI perturbation
+    set Initial condition file name           = savani.dlnvs.60.m.ab
+    set Vs to density scaling                 = 0.3
+    set Thermal expansion coefficient in initial temperature scaling = 4e-5
+    set Reference temperature                 = 1600
+    set Remove degree 0 from perturbation     = true
+    set Specify a lower maximum degree        = true
+    set Maximum degree                        = 40
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/initial_condition_lithosphere_mask.prm.bak b/tests/initial_condition_lithosphere_mask.prm.bak
new file mode 100644
index 00000000000..293e8b9f42e
--- /dev/null
+++ b/tests/initial_condition_lithosphere_mask.prm.bak
@@ -0,0 +1,62 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Initial temperature model
+  set List of model names = function, lithosphere mask
+  set List of model operators = add, replace if valid
+
+  subsection Function
+    set Coordinate system = depth
+    set Function constants = temp=2500
+    set Function expression = temp
+  end
+
+  subsection Lithosphere Mask
+    set Depth specification method = File
+    set Lithosphere temperature = 1600
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/initial_condition_patch_on_S40RTS.prm.bak b/tests/initial_condition_patch_on_S40RTS.prm.bak
new file mode 100644
index 00000000000..44f254f0ecb
--- /dev/null
+++ b/tests/initial_condition_patch_on_S40RTS.prm.bak
@@ -0,0 +1,62 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Initial temperature model
+  set Model name = patch on S40RTS
+
+  subsection Patch on S40RTS
+    set Maximum grid depth = 700000
+  end
+
+  subsection S40RTS perturbation
+    set Initial condition file name           = S20RTS.sph
+    set Vs to density scaling method          = file
+    set Thermal expansion coefficient in initial temperature scaling = 4e-5
+    set Reference temperature                 = 1600
+    set Remove degree 0 from perturbation     = true
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/initial_condition_vs_to_density.prm.bak b/tests/initial_condition_vs_to_density.prm.bak
new file mode 100644
index 00000000000..fc125ace1a1
--- /dev/null
+++ b/tests/initial_condition_vs_to_density.prm.bak
@@ -0,0 +1,77 @@
+# This tests whether ASPECT reads in the
+# vs to density scaling form a file correctly
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0
+  set Tangential velocity boundary indicators = 1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1600
+    set Outer temperature = 1600
+  end
+end
+
+subsection Initial temperature model
+  set Model name = S40RTS perturbation
+
+  subsection S40RTS perturbation
+    set Initial condition file name           = S20RTS.sph
+    set Vs to density scaling                 = 0.3
+    set Thermal expansion coefficient in initial temperature scaling = 4e-5
+    set Reference temperature                 = 1600
+    set Remove degree 0 from perturbation     = true
+    set Vs to density scaling method          = file
+
+    subsection Ascii data vs to density model
+      set Data file name                      = vs_to_density_Steinberger.txt
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/initial_condition_vs_to_density_SAVANI.prm.bak b/tests/initial_condition_vs_to_density_SAVANI.prm.bak
new file mode 100644
index 00000000000..59086888f53
--- /dev/null
+++ b/tests/initial_condition_vs_to_density_SAVANI.prm.bak
@@ -0,0 +1,77 @@
+# This tests whether ASPECT reads in the
+# vs to density scaling form a file correctly
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0
+  set Tangential velocity boundary indicators = 1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1600
+    set Outer temperature = 1600
+  end
+end
+
+subsection Initial temperature model
+  set Model name = SAVANI perturbation
+
+  subsection SAVANI perturbation
+    set Initial condition file name           = savani.dlnvs.60.m.ab
+    set Vs to density scaling                 = 0.3
+    set Thermal expansion coefficient in initial temperature scaling = 4e-5
+    set Reference temperature                 = 1600
+    set Remove degree 0 from perturbation     = true
+    set Vs to density scaling method          = file
+
+    subsection Ascii data vs to density model
+      set Data file name                      = vs_to_density_Steinberger.txt
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/initial_global_refinement.prm.bak b/tests/initial_global_refinement.prm.bak
new file mode 100644
index 00000000000..ddd12757b9c
--- /dev/null
+++ b/tests/initial_global_refinement.prm.bak
@@ -0,0 +1,88 @@
+# This model tests if the maximum refinement function is
+# applied correctly in time step zero during global refinement.
+# The mesh should have the highest refinement level of 4 in the
+# upper quarter of the domain, the lowest refinement level of
+# 0 in the bottom quarter, and an intermediate level of 2 in
+# between.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = refine
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+    set X repetitions = 5
+    set Y repetitions = 5
+    set Z repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 4
+  set Initial adaptive refinement = 0
+  set Time steps between mesh refinement = 0
+  set Strategy = minimum refinement function, maximum refinement function
+  set Minimum refinement level = 0
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function expression = if( y>=0.751 , 4, if (y>=0.251, 2, 0))
+  end
+
+  subsection Maximum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function expression = if( y>=0.751, 4, if (y>=0.251, 2, 0))
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set List of output variables = partition
+  end
+end
diff --git a/tests/initial_porosity.prm.bak b/tests/initial_porosity.prm.bak
new file mode 100644
index 00000000000..7e5bc0abd6e
--- /dev/null
+++ b/tests/initial_porosity.prm.bak
@@ -0,0 +1,216 @@
+# A test that computes an initial porosity field based on the
+# equilibrium melt fraction for the given temperature field.
+
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 1.0
+set Maximum time step                      = 1e6
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = with_melt
+set Max nonlinear iterations               = 20
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Composition reference profile = function
+    set Function expression = 0.0;0.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.2
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3700
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = #2,3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+
+  subsection Function
+    set Function constants  = b=100000, c=20000
+    set Variable names      = x,y
+    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 8700000
+    set Y extent = 2900000
+
+    #    set X periodic = true
+    set X repetitions = 3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 5e8
+    set Age top boundary layer    = 3e8
+    set Amplitude                 = 0
+    set Position                  = center
+    set Radius                    = 350000
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+
+  subsection Function
+    set Function expression = if (x*x+y*y < 2700000*2700000,500,0)
+  end
+end
+
+subsection Initial composition model
+  set Model name = porosity
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Reference melt density            = 3000
+    set Thermal expansion coefficient     = 2e-5
+    set Reference permeability            = 1e-8
+    set Reference shear viscosity         = 5e21
+    set Reference bulk viscosity          = 1e19
+    set Exponential melt weakening factor = 10
+    set Thermal viscosity exponent        = 7
+    set Thermal bulk viscosity exponent   = 7
+    set Reference temperature             = 1600
+    set Solid compressibility             = 4.2e-12
+    set Melt compressibility              = 1.25e-11
+    set Reference melt viscosity          = 10
+    set Depletion density change          = -200.0 # -100.0 # 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 3
+  set Strategy                                 = composition threshold, minimum refinement function #, nonadiabatic temperature
+  set Time steps between mesh refinement       = 0
+
+  subsection Minimum refinement function
+    set Coordinate system   = depth
+    set Function expression = if (depth>1500000,5,4)
+    set Variable names      = depth,phi
+  end
+
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-4,1.0
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating #, latent heat melt, shear heating
+end
+
+subsection Nullspace removal
+  #  set Remove nullspace                        = net x translation
+
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Interpolate output            = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+
+  subsection Depth average
+    set Number of zones = 12
+    set Time between graphical output = 6e5
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint = 1700
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-14
+  set Temperature solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/initial_temperature_list.prm.bak b/tests/initial_temperature_list.prm.bak
new file mode 100644
index 00000000000..ee12f428b0d
--- /dev/null
+++ b/tests/initial_temperature_list.prm.bak
@@ -0,0 +1,63 @@
+##### simple test for using multiple initial temperature plugins
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = ascii data, function
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-50,10)
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/initial_temperature_list_using_maximum.prm.bak b/tests/initial_temperature_list_using_maximum.prm.bak
new file mode 100644
index 00000000000..d27d06fe9fa
--- /dev/null
+++ b/tests/initial_temperature_list_using_maximum.prm.bak
@@ -0,0 +1,64 @@
+##### simple test for using multiple initial temperature plugins
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = ascii data, function
+  set List of model operators = add, maximum
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,10,50)
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/initial_temperature_list_using_minimum.prm.bak b/tests/initial_temperature_list_using_minimum.prm.bak
new file mode 100644
index 00000000000..432135d0982
--- /dev/null
+++ b/tests/initial_temperature_list_using_minimum.prm.bak
@@ -0,0 +1,64 @@
+##### simple test for using multiple initial temperature plugins
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = ascii data, function
+  set List of model operators = add, minimum
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,10,50)
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/initial_temperature_list_using_subtract.prm.bak b/tests/initial_temperature_list_using_subtract.prm.bak
new file mode 100644
index 00000000000..04e5a0754df
--- /dev/null
+++ b/tests/initial_temperature_list_using_subtract.prm.bak
@@ -0,0 +1,64 @@
+##### simple test for using multiple initial temperature plugins
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = ascii data, function
+  set List of model operators = add, subtract
+
+  subsection Ascii data model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
+    set Data file name       = box_2d.txt
+  end
+
+  subsection Function
+    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,50,-10)
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/initial_temperature_profile.prm.bak b/tests/initial_temperature_profile.prm.bak
new file mode 100644
index 00000000000..b5dd0a90c34
--- /dev/null
+++ b/tests/initial_temperature_profile.prm.bak
@@ -0,0 +1,69 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer,west,south,east
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner,outer
+  set List of model names = initial temperature
+end
+
+subsection Initial temperature model
+  set List of model names = ascii profile, harmonic perturbation
+  set List of model operators = add
+
+  subsection Ascii profile
+    set Data directory = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-profile/tests/
+    set Data file name = simple_test.txt
+  end
+
+  subsection Harmonic perturbation
+    set Magnitude = 2.0
+    set Reference temperature = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/inner_core.cc.bak b/tests/inner_core.cc.bak
new file mode 100644
index 00000000000..ab683f33e71
--- /dev/null
+++ b/tests/inner_core.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../cookbooks/inner_core_convection/inner_core_assembly.cc"
diff --git a/tests/inner_core.prm.bak b/tests/inner_core.prm.bak
new file mode 100644
index 00000000000..578c894fa9c
--- /dev/null
+++ b/tests/inner_core.prm.bak
@@ -0,0 +1,142 @@
+# A simple setup for convection the inner core. See the
+# manual, Section Cookbooks/Geophysical setups/Inner core convection
+# for more information. Changing the Rayleigh number Ra
+# and the resistance to phase change P will change the mode
+# of inner core convection between translation, plume convection
+# or no convection.
+#
+# Setup and equations are given in: Deguen, Alboussiere,
+# and Cardin (2013), Thermal convection in Earth’s inner core
+# with phase change at its boundary. GJI, 194, 1310-133.
+
+# MPI: 2
+
+set Additional shared libraries            = ./libinner_core_convection.so
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set End time                               = 50
+set Output directory                       = output
+
+# The equations are non-dimensionalized, and all of the
+# material properties are constant and set to one, except
+# for the density, which scales with temperature.
+subsection Material model
+  set Model name = inner core material
+
+  subsection Simple model
+    set Reference density             = 0
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+
+  # The 'inner core material' model also contains a function that
+  # represents the resistance to melting/freezing at the inner core
+  # boundary.
+  # This phase boundary model combines a prescribed a normal
+  # velocity and normal stress. The relation between the two scales
+  # with the phase change number P, which is given in the 'Function
+  # expression'.
+  # For P-->infinity, the boundary is a free slip boundary, and for
+  # P-->0, the boundary is an open boundary (with zero normal stress).
+
+  # For time dependence, the variable names have to have dim+1 entries,
+  # and the last variable will be the time
+  subsection Inner core
+    subsection Phase change resistance function
+      set Variable names      = x,y,z
+      set Function expression = 1e-2     # <-- P
+    end
+  end
+end
+
+# The inner core is a sphere, and the non-dimensional radius
+# is 1.
+subsection Geometry model
+  set Model name = sphere
+
+  subsection Sphere
+    set Radius  = 1
+  end
+end
+
+# We use a new boundary condition at the surface, which takes
+# into account the effect of melting/freezing of material at
+# the boundary of inner and outer core, and which is implemented
+# in the shared library.
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = surface: zero traction
+end
+
+# The (potential) temperature is set to zero at the outer boundary.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = surface
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 0.8
+    set Outer temperature = 0
+  end
+end
+
+# We use a constant radiogenic heating rate.
+subsection Heating model
+  set List of model names = constant core heating
+
+  subsection Constant core heating
+    set Radiogenic heating rate = 6
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+# The gravity has its maximum value at the boundary of inner and
+# outer core, and decreases approximately linearly to zero towards
+# the center of the core.
+# The Rayleigh number used in the model is given by the magnitude
+# of the gravity at the inner core/outer core boundary.
+subsection Gravity model
+  set Model name = radial linear
+
+  subsection Radial linear
+    set Magnitude at bottom = 0.0
+    set Magnitude at surface = 2     # <-- Ra
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 0
+  set Strategy                           = minimum refinement function
+  set Time steps between mesh refinement = 0
+
+  subsection Minimum refinement function
+    set Variable names = depth, phi, theta
+    set Function expression = if(depth>0.1,if(depth>0.3,5,6),7)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Number of grouped files       = 0
+    set List of output variables      = strain rate, gravity, density, specific heat, heating
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net translation
+end
diff --git a/tests/internal_heating_statistics.prm.bak b/tests/internal_heating_statistics.prm.bak
new file mode 100644
index 00000000000..9f467d21e3a
--- /dev/null
+++ b/tests/internal_heating_statistics.prm.bak
@@ -0,0 +1,100 @@
+############### Global parameters
+# This is a test for the radiogenic heating and the internal
+# heating statistics postprocessor. Since density and radiogenic
+# heating are constant there is an analytical solution, which
+# is reproduced in this testcase.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 1000
+set Use years in output instead of seconds = false
+set Output directory = radiogenic_heating
+
+subsection Heating model
+  set List of model names = constant heating
+
+  subsection Constant heating
+    set Radiogenic heating rate = 1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = 3
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;-1
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 0.0
+    set Thermal expansion coefficient                  = 0.0
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = heating
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/interpolor_particles_harmonic_average.prm b/tests/interpolor_particles_harmonic_average.prm
index a2edd2fa67d..192e4b57515 100644
--- a/tests/interpolor_particles_harmonic_average.prm
+++ b/tests/interpolor_particles_harmonic_average.prm
@@ -15,7 +15,6 @@ subsection Compositional fields
   set Mapped particle properties  =
 end
 
-
 subsection Initial composition model
   set Model name = unspecified
 end
diff --git a/tests/interpolor_particles_harmonic_average.prm.bak b/tests/interpolor_particles_harmonic_average.prm.bak
new file mode 100644
index 00000000000..a2edd2fa67d
--- /dev/null
+++ b/tests/interpolor_particles_harmonic_average.prm.bak
@@ -0,0 +1,21 @@
+# Test whether the interpolator reads the input correctly.
+include $ASPECT_SOURCE_DIR/tests/time_stepping_repeat_particles.prm
+
+set End time                               = 0.0
+
+subsection Particles
+  set Interpolation scheme = harmonic average
+  set List of particle properties = initial position
+end
+
+subsection Compositional fields
+  set Number of fields = 0
+  set Names of fields =
+  set Compositional field methods =
+  set Mapped particle properties  =
+end
+
+
+subsection Initial composition model
+  set Model name = unspecified
+end
diff --git a/tests/interpolor_particles_nearest_neighbor.prm.bak b/tests/interpolor_particles_nearest_neighbor.prm.bak
new file mode 100644
index 00000000000..3938cab7dd8
--- /dev/null
+++ b/tests/interpolor_particles_nearest_neighbor.prm.bak
@@ -0,0 +1,8 @@
+# Test whether the interpolator reads the input correctly.
+include $ASPECT_SOURCE_DIR/tests/time_stepping_repeat_particles.prm
+
+set End time                               = 0.0
+
+subsection Particles
+  set Interpolation scheme = nearest neighbor
+end
diff --git a/tests/interpolor_particles_quadratic_least_squares.prm.bak b/tests/interpolor_particles_quadratic_least_squares.prm.bak
new file mode 100644
index 00000000000..96d437503aa
--- /dev/null
+++ b/tests/interpolor_particles_quadratic_least_squares.prm.bak
@@ -0,0 +1,8 @@
+# Test whether the interpolator reads the input correctly.
+include $ASPECT_SOURCE_DIR/tests/time_stepping_repeat_particles.prm
+
+set End time                               = 0.0
+
+subsection Particles
+  set Interpolation scheme = quadratic least squares
+end
diff --git a/tests/isosurfaces_simple_box_2D.prm.bak b/tests/isosurfaces_simple_box_2D.prm.bak
new file mode 100644
index 00000000000..1164df69fe1
--- /dev/null
+++ b/tests/isosurfaces_simple_box_2D.prm.bak
@@ -0,0 +1,96 @@
+# This input file tests the isosurface mesh refinement plugin
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set X repetitions = 1
+    set Y repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x, y
+    set Function expression = if(x < 500000,if(y< 330000,100+x/1000,100+x/250),0)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x, y
+    set Function expression = if(x < 500000,if(y < 330000,1,0),0);if(x < 500000,0,1);if(x < 500000,if(y < 330000,0,1),0)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 3
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 2
+  set Strategy = isosurfaces
+
+  subsection Isosurfaces
+    # Although the isosurface entry specifies min/max level 4, refinement level will
+    # not be more than 2 because initial global + initial adaptive = 2
+    set Isosurfaces = 4,    4,    Temperature: 0 | 600,   C_2 : 0.0 | 0.5 ;\
+                      0,    0,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/isosurfaces_simple_box_2D_custom_fieldnames.prm.bak b/tests/isosurfaces_simple_box_2D_custom_fieldnames.prm.bak
new file mode 100644
index 00000000000..971ab778bed
--- /dev/null
+++ b/tests/isosurfaces_simple_box_2D_custom_fieldnames.prm.bak
@@ -0,0 +1,21 @@
+# This input file tests the isosurface mesh refinement plugin
+include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
+
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = field1, FieldB, fIEld_C
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 2
+  set Strategy = isosurfaces
+
+  subsection Isosurfaces
+    # Although the isosurface entry specifies min/max level 4, refinement level will
+    # not be more than 2 because initial global + initial adaptive = 2
+    set Isosurfaces = 4,    4,    Temperature: 0 | 600,   FieldB : 0.0 | 0.5 ;\
+                   0,    0,    Temperature: 1600 | 3000,   FieldB : 0.0 | 0.5
+  end
+end
diff --git a/tests/isosurfaces_simple_box_2D_custom_fieldnames_fail.prm.bak b/tests/isosurfaces_simple_box_2D_custom_fieldnames_fail.prm.bak
new file mode 100644
index 00000000000..12234b85b88
--- /dev/null
+++ b/tests/isosurfaces_simple_box_2D_custom_fieldnames_fail.prm.bak
@@ -0,0 +1,21 @@
+# This input file tests the isosurface mesh refinement plugin
+include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
+
+
+# EXPECT FAILURE
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = field1, FieldB, fIEld_C
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 2
+  set Strategy = isosurfaces
+
+  subsection Isosurfaces
+    set Isosurfaces = 4,    4,    Temperature: 0 | 600,   C_2 : 0.0 | 0.5 ;\
+                      0,    0,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
+  end
+end
diff --git a/tests/isosurfaces_simple_box_2D_min_max_1.prm.bak b/tests/isosurfaces_simple_box_2D_min_max_1.prm.bak
new file mode 100644
index 00000000000..f049331fa69
--- /dev/null
+++ b/tests/isosurfaces_simple_box_2D_min_max_1.prm.bak
@@ -0,0 +1,14 @@
+# This input file tests the isosurface mesh refinement plugin
+include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
+
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 2
+  set Strategy = isosurfaces
+
+  subsection Isosurfaces
+    set Isosurfaces = max,    max,    Temperature: 0 | 600,   C_2 : 0.0 | 0.5 ;\
+                      min,    min,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
+  end
+end
diff --git a/tests/isosurfaces_simple_box_2D_min_max_2.prm.bak b/tests/isosurfaces_simple_box_2D_min_max_2.prm.bak
new file mode 100644
index 00000000000..38e3d5b1138
--- /dev/null
+++ b/tests/isosurfaces_simple_box_2D_min_max_2.prm.bak
@@ -0,0 +1,14 @@
+# This input file tests the isosurface mesh refinement plugin
+include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
+
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 2
+  set Strategy = isosurfaces, temperature
+
+  subsection Isosurfaces
+    set Isosurfaces = max-2,  max - 1,    Temperature: 0 | 600 ;\
+                      min + 1,min+2,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
+  end
+end
diff --git a/tests/isosurfaces_simple_box_3D.prm.bak b/tests/isosurfaces_simple_box_3D.prm.bak
new file mode 100644
index 00000000000..a9d746267a2
--- /dev/null
+++ b/tests/isosurfaces_simple_box_3D.prm.bak
@@ -0,0 +1,56 @@
+# This input file tests the isosurface mesh refinement plugin
+include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
+
+set Dimension = 3
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+    set Z extent = 660000
+    set X repetitions = 1
+    set Y repetitions = 1
+    set Z repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x, y, z
+    set Function expression = if(z < 500000,if(x < 330000 && y < 330000,100+z/1000,100+z/250),0)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x, y, z
+    set Function expression = if(z < 500000,if(x < 330000 && y < 330000,1,0),0);if(z < 500000,if(x < 330000 && y < 330000,0,0),1);if(z < 500000,if(x < 330000 && y < 330000,0,1),0)
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 2
+  set Strategy = isosurfaces
+
+  subsection Isosurfaces
+    # Although the isosurface entry specifies min/max level 4, refinement level will
+    # not be more than 2 because initial global + initial adaptive = 2
+    set Isosurfaces = 3,    3,    Temperature: 0 | 600,   C_2 : 0.0 | 0.5 ;\
+                      0,    0,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 5
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0,1,2,3,4,5
+end
diff --git a/tests/isosurfaces_slab_2D.prm.bak b/tests/isosurfaces_slab_2D.prm.bak
new file mode 100644
index 00000000000..cb1088f6339
--- /dev/null
+++ b/tests/isosurfaces_slab_2D.prm.bak
@@ -0,0 +1,102 @@
+# This input file tests the box geometry in
+# combination with the isosurfaces plugin to refine a 2D slab
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1673.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+# We take a box geometry and increase the repetitions
+# of the coarse mesh
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10
+    set Y extent = 10
+    set X repetitions = 10
+    set Y repetitions = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 2
+  set Strategy = isosurfaces
+
+  subsection Isosurfaces
+    set Isosurfaces = 2,    2,    C_1 : 0.5 | 1.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1673.0
+    set Top temperature    = 273.0
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0,1,2,3
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y
+    set Function constants = Xtr=5.0, Dsl=1.0, Ymax=10.0, D0=0.3, Xmax=10.0
+    set Function expression = (x > Xtr + D0) ? ((y + Dsl > Ymax + D0)? 273.0 : 1673.0):\
+                              (((y > x + Xmax - Xtr - Dsl) && (y < x + Xmax - Xtr))? 273.0 : 1673.0)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x, y
+    set Function constants = Xtr=5.0, Dsl=1.0, Ymax=10.0, D0=0.3, Xmax=10.0
+    set Function expression = (x > Xtr + D0) ? ((y + Dsl > Ymax + D0)? 1.0 : 0.0):\
+                              (((y > x + Xmax - Xtr - Dsl) && (y < x + Xmax - Xtr))? 1.0 : 0.0)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics
+
+  subsection Visualization
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/isosurfaces_slab_3D.prm.bak b/tests/isosurfaces_slab_3D.prm.bak
new file mode 100644
index 00000000000..0ef5b57fff9
--- /dev/null
+++ b/tests/isosurfaces_slab_3D.prm.bak
@@ -0,0 +1,67 @@
+# This input file tests the box geometry in
+# combination with the isosurfaces plugin to refine a 3D slab
+include $ASPECT_SOURCE_DIR/tests/isosurfaces_slab_2D.prm
+
+set Dimension = 3
+
+# We take a box geometry and increase the repetitions
+# of the coarse mesh
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 5
+    set Y extent = 1
+    set Z extent = 5
+    set X repetitions = 5
+    set Y repetitions = 1
+    set Z repetitions = 5
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 2
+  set Strategy = isosurfaces
+
+  subsection Isosurfaces
+    set Isosurfaces = 2,    2,    C_1 : 0.5 | 1.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1673.0
+    set Top temperature    = 273.0
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1, 2, 3, 4, 5
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y, z
+    set Function constants = Xtr=3.0, Dsl=1.0, Zmax=5.0, D0=0.3, Xmax=5.0
+    set Function expression = (x > Xtr + D0) ? ((z + Dsl > Zmax + D0)? 273.0 : 1673.0):\
+                              (((z > x + Xmax - Xtr - Dsl) && (z < x + Xmax - Xtr))? 273.0 : 1673.0)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x, y, z
+    set Function constants = Xtr=3.0, Dsl=1.0, Zmax=5.0, D0=0.3, Xmax=5.0
+    set Function expression = (x > Xtr + D0) ? ((z + Dsl > Zmax + D0)? 1.0 : 0.0):\
+                              (((z > x + Xmax - Xtr - Dsl) && (z < x + Xmax - Xtr))? 1.0 : 0.0)
+  end
+end
diff --git a/tests/iterated_advection_and_defect_correction_Stokes.prm.bak b/tests/iterated_advection_and_defect_correction_Stokes.prm.bak
new file mode 100644
index 00000000000..f7def287742
--- /dev/null
+++ b/tests/iterated_advection_and_defect_correction_Stokes.prm.bak
@@ -0,0 +1,127 @@
+#########################################################
+# This is a model setup to test the iterated Advection and Stokes solver.
+# Both the calculation of the residuum and the convergence
+# with prescribed boundary conditions are tested.
+
+set Adiabatic surface temperature          = 0
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and defect correction Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+
+  subsection Stabilization parameters
+    set beta  = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 150000
+    set Y extent  = 65000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 0
+    set Thermal expansion coefficient = 1
+    set Thermal viscosity exponent = 0.0
+    set Reference specific heat = 1.0
+    set Reference density = 1.0
+    set Reference temperature = 0
+    set Viscosity = 1e16
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-2
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/iterated_advection_and_stokes.prm.bak b/tests/iterated_advection_and_stokes.prm.bak
new file mode 100644
index 00000000000..d5913c7a8b5
--- /dev/null
+++ b/tests/iterated_advection_and_stokes.prm.bak
@@ -0,0 +1,127 @@
+#########################################################
+# This is a model setup to test the iterated Advection and Stokes solver.
+# Both the calculation of the residuum and the convergence
+# with prescribed boundary conditions are tested.
+
+set Adiabatic surface temperature          = 0
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+
+  subsection Stabilization parameters
+    set beta  = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 150000
+    set Y extent  = 65000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 0
+    set Thermal expansion coefficient = 1
+    set Thermal viscosity exponent = 0.0
+    set Reference specific heat = 1.0
+    set Reference density = 1.0
+    set Reference temperature = 0
+    set Viscosity = 1e16
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/iterated_advection_and_stokes_DG.prm b/tests/iterated_advection_and_stokes_DG.prm
index 656f6126b6b..42e04d3c81a 100644
--- a/tests/iterated_advection_and_stokes_DG.prm
+++ b/tests/iterated_advection_and_stokes_DG.prm
@@ -26,7 +26,6 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = false
     set beta  = 0.5
   end
 end
diff --git a/tests/iterated_advection_and_stokes_DG.prm.bak b/tests/iterated_advection_and_stokes_DG.prm.bak
new file mode 100644
index 00000000000..656f6126b6b
--- /dev/null
+++ b/tests/iterated_advection_and_stokes_DG.prm.bak
@@ -0,0 +1,128 @@
+#########################################################
+# This is a model setup to test the iterated Advection and Stokes solver
+# in combination with discontinuous discretization (DG) of the composition.
+
+set Adiabatic surface temperature          = 0
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = false
+    set beta  = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, test
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 150000
+    set Y extent  = 65000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c)); if(x<75e3,1,0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 0
+    set Thermal expansion coefficient = 1
+    set Thermal viscosity exponent = 0.0
+    set Reference specific heat = 1.0
+    set Reference density = 1.0
+    set Reference temperature = 0
+    set Viscosity = 1e16
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/iterated_advection_and_stokes_DG_limiter.prm b/tests/iterated_advection_and_stokes_DG_limiter.prm
index f07acf0e2d0..475859bf86b 100644
--- a/tests/iterated_advection_and_stokes_DG_limiter.prm
+++ b/tests/iterated_advection_and_stokes_DG_limiter.prm
@@ -28,13 +28,12 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-
     # porosity will not exceed 0.21 during set model time.
     # test will have to stay between 0 and 1.
     set Global composition maximum =  1.0, 1.0
     set Global composition minimum =  0.0, 0.0
     set beta  = 0.5
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/tests/iterated_advection_and_stokes_DG_limiter.prm.bak b/tests/iterated_advection_and_stokes_DG_limiter.prm.bak
new file mode 100644
index 00000000000..f07acf0e2d0
--- /dev/null
+++ b/tests/iterated_advection_and_stokes_DG_limiter.prm.bak
@@ -0,0 +1,135 @@
+#########################################################
+# This is a model setup to test the iterated Advection and Stokes solver
+# in combination with discontinuous discretization (DG) of the composition.
+# The DG method also applies global limits to each field on a cell-by-cell
+# basis.
+
+set Adiabatic surface temperature          = 0
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+
+    # porosity will not exceed 0.21 during set model time.
+    # test will have to stay between 0 and 1.
+    set Global composition maximum =  1.0, 1.0
+    set Global composition minimum =  0.0, 0.0
+    set beta  = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, test
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 150000
+    set Y extent  = 65000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c)); if(x<75e3,1,0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 0
+    set Thermal expansion coefficient = 1
+    set Thermal viscosity exponent = 0.0
+    set Reference specific heat = 1.0
+    set Reference density = 1.0
+    set Reference temperature = 0
+    set Viscosity = 1e16
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/iterated_advection_and_stokes_direct_solver.prm.bak b/tests/iterated_advection_and_stokes_direct_solver.prm.bak
new file mode 100644
index 00000000000..6105c34713e
--- /dev/null
+++ b/tests/iterated_advection_and_stokes_direct_solver.prm.bak
@@ -0,0 +1,130 @@
+#########################################################
+# This is a model setup to test the iterated Advection and Stokes
+# nonlinear solver scheme when using the direct solver.
+# Both the calculation of the residuum and the convergence
+# with prescribed boundary conditions are tested, as well
+# as agreement with the respective test for the iterative
+# solver (iterated_advection_and_stokes).
+
+set Adiabatic surface temperature          = 0
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+
+  subsection Stabilization parameters
+    set beta  = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 150000
+    set Y extent  = 65000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 0
+    set Thermal expansion coefficient = 1
+    set Thermal viscosity exponent = 0.0
+    set Reference specific heat = 1.0
+    set Reference density = 1.0
+    set Reference temperature = 0
+    set Viscosity = 1e16
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/iterated_advection_and_stokes_residual.prm.bak b/tests/iterated_advection_and_stokes_residual.prm.bak
new file mode 100644
index 00000000000..1f8f5b5adce
--- /dev/null
+++ b/tests/iterated_advection_and_stokes_residual.prm.bak
@@ -0,0 +1,127 @@
+#########################################################
+# This is a model setup to test the residual of the
+# iterated Advection and Stokes solver. Although the initial composition
+# residual is 0, the overall residual is finite.
+
+set Adiabatic surface temperature          = 0
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+
+  subsection Stabilization parameters
+    set beta  = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 150000
+    set Y extent  = 65000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = 0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 0
+    set Thermal expansion coefficient = 1
+    set Thermal viscosity exponent = 0.0
+    set Reference specific heat = 1.0
+    set Reference density = 1.0
+    set Reference temperature = 0
+    set Viscosity = 1e16
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/kaus_rayleigh_taylor_instability.prm.bak b/tests/kaus_rayleigh_taylor_instability.prm.bak
new file mode 100644
index 00000000000..ddd546f432c
--- /dev/null
+++ b/tests/kaus_rayleigh_taylor_instability.prm.bak
@@ -0,0 +1,41 @@
+# Test based on the 2D Rayleigh Taylor benchmark described
+# in Kaus et al. (2010, 10.1016/j.pepi.2010.04.007).
+# The benchmark considers a denser, more viscous layer
+# overlying lighter, less viscous mantle. The interface
+# between the layers is perturbed, leading to drips along
+# the vertical domain boundaries. A free surface allows
+# for the development of surface topography.
+include $ASPECT_SOURCE_DIR/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm
+
+
+############### Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 2500
+
+############### Mesh refinement
+# The Kaus paper considers a resolution of 50x50 elements.
+# We use 64x64 in the benchmark, but reduce it to 8x8 for this test.
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+# We monitor the topography over time.
+subsection Postprocess
+  set List of postprocessors = visualization, topography, composition statistics, maximum depth of field, velocity statistics
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set List of output variables      = viscosity, density
+    set Output mesh velocity          = true
+    set Output format = gnuplot
+  end
+
+  subsection Topography
+    set Output to file           = true
+    set Time between text output = 0
+  end
+end
diff --git a/tests/kinematically_driven_subduction_2d_case1.prm b/tests/kinematically_driven_subduction_2d_case1.prm
index 650c7bad14d..fbb9e7219e6 100644
--- a/tests/kinematically_driven_subduction_2d_case1.prm
+++ b/tests/kinematically_driven_subduction_2d_case1.prm
@@ -154,7 +154,7 @@ subsection Formulation
 end
 
 subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics
+  set List of postprocessors = visualization, velocity statistics, heating statistics
 
   subsection Visualization
     set List of output variables      = density, viscosity, strain rate, error indicator
diff --git a/tests/kinematically_driven_subduction_2d_case1.prm.bak b/tests/kinematically_driven_subduction_2d_case1.prm.bak
new file mode 100644
index 00000000000..650c7bad14d
--- /dev/null
+++ b/tests/kinematically_driven_subduction_2d_case1.prm.bak
@@ -0,0 +1,177 @@
+# This test is the same setup as the
+# cookbook kinematically_driven_subduction_2d
+# but with lower resolution. It models oceanic
+# subduction in a 2d box of 3000 x 670 km.
+# The subducting plate is driven by inflow boundary
+# conditions on the top part of the right boundary,
+# while a balancing outflow is prescribed underneath.
+# Only density and viscosity differ per composition.
+
+# 2D
+set Dimension                              = 2
+
+# Run for 0.1 My
+set Start time                             = 0
+set End time                               = 1.e5
+set CFL number                             = 0.5
+set Use years in output instead of seconds = true
+
+# Linear solver
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = output-Case1
+set Adiabatic surface temperature          = 0
+
+# We fix composition on the right boundary,
+# because we have inflow there.
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = right
+  set List of model names = initial composition
+end
+
+# We fix temperature on the top and bottom,
+# as well as on the right boundary because
+# we have inflow through the latter.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 0
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom, top
+  set Prescribed velocity boundary indicators = right x:function
+
+  subsection Function
+    set Function constants  = cm=100.0 #*3600.0*24.0*365.25
+    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
+                                 if(z>560000.0, -5.0/cm, \
+                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
+                              0
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature         = 0.0
+    set Viscosity averaging scheme    = maximum composition
+
+    # OP, ML SP, crust SP
+    set Viscosities                   = 1.e20, 1.e23, 1.e23, 1.e20
+    set Densities                     = 3200.0, 3250.0, 3250.0, 3250.0
+    set Thermal conductivities        = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = OP, ML_SP, crust_SP
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = Ax=1475600.0, Az=670000.0, \
+                              Bx=1500000.0, Bz=670000.0, \
+                              Cx=1358500.0, Cz=588000.0, \
+                              Dx=1382900.0, Dz=588000.0, \
+                              Ex=1530000.0, Ez=560000.0, \
+                              Fz=663000.0, Gz=662000.0, \
+                              Hz=631000.0, Iz=630000.0
+    set Function expression = \
+                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
+                              if((x>=Ex&z>=Ez&z<Gz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
+                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)|z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0)
+    set Variable names      = x,z
+  end
+end
+
+subsection Discretization
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent   = 3000e3
+    set Y extent   = 670e3
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We ignore any temperature effects
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0
+    set Variable names      = x,y,t
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 1
+  set Initial global refinement                = 4
+  set Minimum refinement level                 = 4
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = plus
+  set Coarsening fraction                      = 0.01
+  set Refinement fraction                      = 0.95
+  set Run postprocessors on initial refinement = false
+  set Skip solvers on initial refinement       = true
+  set Skip setup initial conditions on initial refinement = true
+  set Strategy                                 = minimum refinement function, viscosity
+  set Time steps between mesh refinement       = 16
+
+  subsection Minimum refinement function
+    set Coordinate system = depth
+    set Variable names = x,z,t
+    set Function constants = vel=150e3, L=100e3, crust=10e3
+    set Function expression = if(x<crust,8,if(x<L,7,if(x<vel,6,4)))
+  end
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, strain rate, error indicator
+    set Time between graphical output = 5e5
+  end
+
+  subsection Composition velocity statistics
+    set Names of selected compositional fields = ML_SP, crust_SP
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = end time
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+  end
+end
diff --git a/tests/kinematically_driven_subduction_2d_case2a.cc.bak b/tests/kinematically_driven_subduction_2d_case2a.cc.bak
new file mode 100644
index 00000000000..9caed44a250
--- /dev/null
+++ b/tests/kinematically_driven_subduction_2d_case2a.cc.bak
@@ -0,0 +1,4 @@
+#include "../cookbooks/kinematically_driven_subduction_2d/trench_location.cc"
+#include "../cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc"
+#include "../cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc"
+#include "../cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc"
diff --git a/tests/kinematically_driven_subduction_2d_case2a.prm b/tests/kinematically_driven_subduction_2d_case2a.prm
index bf65782432d..a8e878d1a1e 100644
--- a/tests/kinematically_driven_subduction_2d_case2a.prm
+++ b/tests/kinematically_driven_subduction_2d_case2a.prm
@@ -155,7 +155,7 @@ subsection Initial temperature model
 end
 
 subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
+  set List of postprocessors = visualization, velocity statistics, heating statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
 
   subsection Composition velocity statistics
     # Sum the velocities of the fields that make up the subducting plate.
diff --git a/tests/kinematically_driven_subduction_2d_case2a.prm.bak b/tests/kinematically_driven_subduction_2d_case2a.prm.bak
new file mode 100644
index 00000000000..bf65782432d
--- /dev/null
+++ b/tests/kinematically_driven_subduction_2d_case2a.prm.bak
@@ -0,0 +1,176 @@
+# Test based on the cookbook kinematically_driven_subduction_2d_case2a,
+# with lower resolution and only a few timesteps.
+
+set End time                               = 1.e5
+
+# Copy of the cookbooks instead of includes because we
+# cannot include a prm that includes another prm as
+# $ASPECT_SOURCE_DIR is not expanded the second time.
+set Start time                             = 0
+set CFL number                             = 0.5
+set Use years in output instead of seconds = true
+
+# Linear solver
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature          = 0
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 1
+  set Initial global refinement                = 4
+  set Minimum refinement level                 = 4
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = plus
+  set Coarsening fraction                      = 0.01
+  set Refinement fraction                      = 0.95
+  set Run postprocessors on initial refinement = false
+  set Skip solvers on initial refinement       = true
+  set Skip setup initial conditions on initial refinement = true
+  set Strategy                                 = minimum refinement function, viscosity
+  set Time steps between mesh refinement       = 16
+
+  subsection Minimum refinement function
+    set Coordinate system = depth
+    set Variable names = x,z,t
+    set Function constants = vel=150e3, L=100e3, crust=10e3
+    set Function expression = if(x<crust,8,if(x<L,7,if(x<vel,6,4)))
+  end
+end
+
+# We fix composition on the right boundary,
+# because we have inflow there.
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = right
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom, top
+  set Prescribed velocity boundary indicators = right x:function
+
+  subsection Function
+    set Function constants  = cm=100.0 #*3600.0*24.0*365.25
+    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
+                                 if(z>560000.0, -5.0/cm, \
+                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
+                              0
+    set Variable names      = x,z
+  end
+end
+
+subsection Discretization
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent   = 3000e3
+    set Y extent   = 670e3
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end time
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, right
+  set List of model names = initial temperature
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+    set Reference temperature         = 473.15
+    set Densities                     = 3200.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0
+    set Thermal expansivities         = 0
+    set Thermal conductivities        = 183.33,2.5,2.5,2.5,2.5,2.5,2.5,2.5
+    set Heat capacities               = 1250.0,750.0,750.0,750.0,750.0,1250.0,1250.0,750.0
+    set Viscosity averaging scheme    = maximum composition
+    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
+  end
+end
+
+# The overriding plate (OP) and subducting plate (SP)
+# are each divided into three different layers:
+# a layer of Bulk Oceanic Composition (BOC),
+# a layer of Serpentinized HarzBurgite (SHB),
+# and a "thermal layer".
+subsection Compositional fields
+  set Number of fields = 7
+  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = Ax=1475600.0, Az=670000.0, \
+                              Bx=1500000.0, Bz=670000.0, \
+                              Cx=1358500.0, Cz=588000.0, \
+                              Dx=1382900.0, Dz=588000.0, \
+                              Ex=1530000.0, Ez=560000.0, \
+                              Fz=663000.0, Gz=662000.0, \
+                              Hz=631000.0, Iz=630000.0
+    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
+                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
+                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
+                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
+                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
+                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
+                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
+    set Variable names      = x,z
+  end
+end
+
+# The initial temperature is prescribed through a plugin
+# and uses the plate cooling model for the temperature in both
+# plates (the plates have different ages) and an adiabatic
+# gradient of 0.25 degrees per km in the sublithospheric
+# mantle.
+subsection Initial temperature model
+  set List of model names = subduction plate cooling
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
+
+  subsection Composition velocity statistics
+    # Sum the velocities of the fields that make up the subducting plate.
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+
+  subsection Trench location
+    set Name of trench compositional field = BOC_OP
+  end
+
+  subsection Isotherm depth
+    set Isotherm value = 1073.15
+  end
+
+  subsection Composition RMS temperature statistics
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+end
diff --git a/tests/kinematically_driven_subduction_2d_case2b.cc.bak b/tests/kinematically_driven_subduction_2d_case2b.cc.bak
new file mode 100644
index 00000000000..9caed44a250
--- /dev/null
+++ b/tests/kinematically_driven_subduction_2d_case2b.cc.bak
@@ -0,0 +1,4 @@
+#include "../cookbooks/kinematically_driven_subduction_2d/trench_location.cc"
+#include "../cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc"
+#include "../cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc"
+#include "../cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc"
diff --git a/tests/kinematically_driven_subduction_2d_case2b.prm b/tests/kinematically_driven_subduction_2d_case2b.prm
index 17af696dd8c..75080d37cfc 100644
--- a/tests/kinematically_driven_subduction_2d_case2b.prm
+++ b/tests/kinematically_driven_subduction_2d_case2b.prm
@@ -142,7 +142,7 @@ subsection Initial temperature model
 end
 
 subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
+  set List of postprocessors = visualization, velocity statistics, heating statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
 
   subsection Composition velocity statistics
     # Sum the velocities of the fields that make up the subducting plate.
diff --git a/tests/kinematically_driven_subduction_2d_case2b.prm.bak b/tests/kinematically_driven_subduction_2d_case2b.prm.bak
new file mode 100644
index 00000000000..17af696dd8c
--- /dev/null
+++ b/tests/kinematically_driven_subduction_2d_case2b.prm.bak
@@ -0,0 +1,195 @@
+# Test based on the cookbook kinematically_driven_subduction_2d_case2b,
+# with lower resolution and only a few timesteps.
+
+# 2D
+set Dimension                              = 2
+set End time                               = 1.e5
+
+# Copy of the cookbooks instead of includes because we
+# cannot include a prm that includes another prm as
+# $ASPECT_SOURCE_DIR is not expanded the second time.
+set Start time                             = 0
+set CFL number                             = 0.5
+set Use years in output instead of seconds = true
+
+# Linear solver
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature          = 0
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 1
+  set Initial global refinement                = 4
+  set Minimum refinement level                 = 4
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = plus
+  set Coarsening fraction                      = 0.01
+  set Refinement fraction                      = 0.95
+  set Run postprocessors on initial refinement = false
+  set Skip solvers on initial refinement       = true
+  set Skip setup initial conditions on initial refinement = true
+  set Strategy                                 = minimum refinement function, viscosity
+  set Time steps between mesh refinement       = 16
+
+  subsection Minimum refinement function
+    set Coordinate system = depth
+    set Variable names = x,z,t
+    set Function constants = vel=150e3, L=100e3, crust=10e3
+    set Function expression = if(x<crust,8,if(x<L,7,if(x<vel,6,4)))
+  end
+end
+
+# We fix composition on the right boundary,
+# because we have inflow there.
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = right
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom, top
+  set Prescribed velocity boundary indicators = right x:function
+
+  subsection Function
+    set Function constants  = cm=100.0 #*3600.0*24.0*365.25
+    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
+                                 if(z>560000.0, -5.0/cm, \
+                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
+                              0
+    set Variable names      = x,z
+  end
+end
+
+subsection Discretization
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent   = 3000e3
+    set Y extent   = 670e3
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end time
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, right
+  set List of model names = initial temperature
+end
+
+# The overriding plate (OP) and subducting plate (SP)
+# are each divided into three different layers:
+# a layer of Bulk Oceanic Composition (BOC),
+# a layer of Serpentinized HarzBurgite (SHB),
+# and a "thermal layer".
+subsection Compositional fields
+  set Number of fields = 7
+  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = Ax=1475600.0, Az=670000.0, \
+                              Bx=1500000.0, Bz=670000.0, \
+                              Cx=1358500.0, Cz=588000.0, \
+                              Dx=1382900.0, Dz=588000.0, \
+                              Ex=1530000.0, Ez=560000.0, \
+                              Fz=663000.0, Gz=662000.0, \
+                              Hz=631000.0, Iz=630000.0
+    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
+                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
+                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
+                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
+                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
+                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
+                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
+    set Variable names      = x,z
+  end
+end
+
+# The initial temperature is prescribed through a plugin
+# and uses the plate cooling model for the temperature in both
+# plates (the plates have different ages) and an adiabatic
+# gradient of 0.25 degrees per km in the sublithospheric
+# mantle.
+subsection Initial temperature model
+  set List of model names = subduction plate cooling
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
+
+  subsection Composition velocity statistics
+    # Sum the velocities of the fields that make up the subducting plate.
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+
+  subsection Trench location
+    set Name of trench compositional field = BOC_OP
+  end
+
+  subsection Isotherm depth
+    set Isotherm value = 1073.15
+  end
+
+  subsection Composition RMS temperature statistics
+    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    # The benchmark uses two different reference temperatures for the compositions:
+    # 1573.15 K for the asthenosphere, thermal_OP and thermal_SP, and 473.15 K for
+    # the rest of the compositions.
+    # As ASPECT only allows for one reference temperature, we have instead adapted
+    # the reference density for the mantle compositions. To do this, we took the initial
+    # temperature and the midpoint depth of the layers and equated the density equation
+    # using the benchmark reference density rho_0_1 (3200 kg/m3) and temperature T_0_1 (1573.15 K), and
+    # the density equation using the 473.15 K reference temperature to obtain the new reference density rho_0_2.
+    # For the left thermal layer, the initial temperature at the midpoint is 1355 K, so
+    # new reference density can be derived as follows:
+    # rho_0_1 * (1 - alpha * (T - T_0_1)) = rho_0_2 * (1 - alpha * (T - T_0_2)),
+    # 3200 * (1 - 2.5e-5 * (1355 - 1573.15)) = rho_0_2 * (1 - 2.5e-5 * (1355 - 473.15))
+    # rho_0_2 = 3290.66.
+    set Reference temperature         = 473.15
+
+    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
+    set Densities                     = 3290.66,3000.0,3000.0,3250.0,3250.0,3290.66,3290.66,3200.0
+
+    # Compared to Case 2a, thermal expansivity is no longer zero and therefore temperature
+    # feeds into the density and therefore the Stokes equations
+    set Thermal expansivities         = 2.5e-5
+    set Thermal conductivities        = 183.33,2.5,2.5,2.5,2.5,2.5,2.5,2.5
+    set Heat capacities               = 1250.0,750.0,750.0,750.0,750.0,1250.0,1250.0,750.0
+    set Viscosity averaging scheme    = maximum composition
+    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
+  end
+end
diff --git a/tests/king_ala.cc.bak b/tests/king_ala.cc.bak
new file mode 100644
index 00000000000..1d456034870
--- /dev/null
+++ b/tests/king_ala.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/king2dcompressible/plugin/code.cc"
+#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/king_ala.prm.bak b/tests/king_ala.prm.bak
new file mode 100644
index 00000000000..e68485600c9
--- /dev/null
+++ b/tests/king_ala.prm.bak
@@ -0,0 +1,11 @@
+# King2010 ALA benchmark as described in benchmarks/kingd2dcompressible
+
+include $ASPECT_SOURCE_DIR/benchmarks/king2dcompressible/ala.prm
+
+set Dimension                              = 2
+set CFL number = 10.0
+set End time                               = 0.5
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average, heating statistics
+end
diff --git a/tests/king_ala_nondim.prm.bak b/tests/king_ala_nondim.prm.bak
new file mode 100644
index 00000000000..706dbb3ba12
--- /dev/null
+++ b/tests/king_ala_nondim.prm.bak
@@ -0,0 +1,163 @@
+# King2010 ALA benchmark
+# like king_ala.prm but using the nondimensional material model
+
+set Dimension                              = 2
+set CFL number                             = 10.0
+set Adiabatic surface temperature          = 0.091
+set Use years in output instead of seconds = false
+set End time                               = 0.15
+
+subsection Discretization
+  subsection Stabilization parameters
+    set alpha                                              = 2
+    set beta                                               = 0.005
+    set cR                                                 = 0.033
+  end
+end
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=0.25, gamma=1.0
+    set Function expression = 0.091*exp(depth*Di); gamma/Di*(exp(depth*Di/gamma)-1); exp(depth*Di/gamma)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression =  1* ((1.0-z/L) + p*cos(k*pi*x/L/1.0)*sin(pi*z/L)) +0.091
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above. (As will be seen
+# in the next section, the actual temperature prescribed here
+# at the left and right does not matter.)
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top, bottom
+
+  subsection Box
+    set Top temperature    = 0.091
+    set Bottom temperature = 1.091
+    set Left temperature   = 0
+    set Right temperature  = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    # A flag indicating whether the adiabatic heating should be simplified
+    # from $\alpha T (\mathbf u \cdot \nabla p)$
+    # to $ \alpha \rho T (\mathbf u \cdot \mathbf g) $. alpha=thermal exp
+
+    # have \alpha rho T w
+    # need: \alpha \rho T w Di
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Material model
+  set Model name = nondimensional
+
+  subsection Nondimensional model
+    set Di                      = 0.25
+    set Ra                      = 1e4
+    set Reference density       = 1
+    set Reference specific heat = 1
+    set Use TALA                = false
+    set gamma                   = 1.0
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 1.0
+  set Additional refinement times              = 0.35
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average, heating statistics
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/latent_heat.prm.bak b/tests/latent_heat.prm.bak
new file mode 100644
index 00000000000..47e2abb7c88
--- /dev/null
+++ b/tests/latent_heat.prm.bak
@@ -0,0 +1,132 @@
+#########################################################
+# This is a model setup to test the latent heat generation.
+# Material flows in from the top and crosses a phase
+# transition, where energy is released and the temperature
+# increases.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 1e15
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = 3
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;-2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    # The change of density across the phase transition. Together with the
+    # Clapeyron slope, this is what determines the entropy change.
+    set Phase transition density jumps                 = 115.6
+    set Corresponding phase for density jump           = 0
+
+    # If the temperature is equal to the phase transition temperature, the
+    # phase transition will occur at the phase transition depth. However,
+    # if the temperature deviates from this value, the Clapeyron slope
+    # determines how much the pressure (and depth) of the phase boundary
+    # changes. Here, the phase transition will be in the middle of the box
+    # for T=T1.
+    set Phase transition depths                        = 500000
+    set Phase transition temperatures                  = 1000
+    set Phase transition Clapeyron slopes              = 1e7
+
+    # We set the width of the phase transition to 5 km. You may want to
+    # change this parameter to see how latent heating depends on the width
+    # of the phase transition.
+    set Phase transition widths                        = 20000
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 2.38
+
+    # We set the thermal expansion and the compressibility to zero, so that
+    # all temperature (and density) changes are caused by advection, diffusion
+    # and latent heating.
+    set Thermal expansion coefficient                  = 0.0
+    set Compressibility                                = 0.0
+
+    # Viscosity is constant.
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 8.44e21
+    set Viscosity prefactors                           = 1.0, 1.0
+    set Composition viscosity prefactor                = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
+
+subsection Heating model
+  set List of model names =  latent heat
+end
diff --git a/tests/latent_heat_composition.prm.bak b/tests/latent_heat_composition.prm.bak
new file mode 100644
index 00000000000..ef3020c3831
--- /dev/null
+++ b/tests/latent_heat_composition.prm.bak
@@ -0,0 +1,164 @@
+#########################################################
+# This is a model setup to test the latent heat generation
+# with a single compositional field. The compositional field
+# is vertically stratified across the midpoint.
+# Material flows in from the top and crosses phases
+# transitions. In one of these transitions energy is released
+# and the temperature increases.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 1e15
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. Likewise, composition is only fixed along the upper boundary
+  # where there is inflow. To guarantee a steady downward flow, we fix the
+  # velocity at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = 3
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# Boundary composition derived from initial conditions
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = 3
+  set List of model names = initial composition
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;-2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y>=500000, 1, 0);
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    # The change of density across the phase transitions. Together with the
+    # Clapeyron slope, this is what determines the entropy change. Phase 0
+    # and 1 are reflective of the compositional field values, which are used
+    # to scale density jumps across each the phase transitions. Specifically,
+    # at each point "i" in the model the density jumps are scaled by
+    # (1-composition[i]) (phase 0) or composition[i] (phase 1).
+    set Phase transition density jumps                 = 115.6,115.6
+    set Corresponding phase for density jump           = 0,1
+
+    # No chemical (i.e. not phase transition-related) density change
+    # associated with compositional field
+    set Density differential for compositional field 1 = 0
+
+    # If the temperature is equal to the phase transition temperature, the
+    # phase transition will occur at the phase transition depth. However,
+    # if the temperature deviates from this value, the Clapeyron slope
+    # determines how much the pressure (and depth) of the phase boundary
+    # changes. Here, the phase transitions will be at 1/4 or 1/2 of the
+    # model depth and temperature T=T1. Given that the composition is 0
+    # above 50 km depth and the Clapeyron slope is 0, the first phase
+    # transition should not have any effect.
+    set Phase transition depths                        = 250000, 50000
+    set Phase transition temperatures                  = 1000, 1000
+    set Phase transition Clapeyron slopes              = 0, 1e7
+
+    # We set the width of the phase transition to 20 km. You may want to
+    # change this parameter to see how latent heating depends on the width
+    # of the phase transition.
+    set Phase transition widths                        = 20000, 20000
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 2.38
+
+    # We set the thermal expansion and the compressibility to zero, so that
+    # all temperature (and density) changes are caused by advection, diffusion
+    # and latent heating.
+    set Thermal expansion coefficient                  = 0.0
+    set Compressibility                                = 0.0
+
+    # Viscosity is constant.
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 8.44e21
+    set Viscosity prefactors                           = 1.0, 1.0, 1.0
+    set Composition viscosity prefactor                = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
+
+subsection Heating model
+  set List of model names =  latent heat
+end
diff --git a/tests/latent_heat_enthalpy.cc.bak b/tests/latent_heat_enthalpy.cc.bak
new file mode 100644
index 00000000000..fcf5b908d62
--- /dev/null
+++ b/tests/latent_heat_enthalpy.cc.bak
@@ -0,0 +1,188 @@
+/*
+  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/material_model/interface.h>
+#include <aspect/adiabatic_conditions/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <iostream>
+#include <deal.II/base/quadrature_lib.h>
+#include <memory>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class LatentHeatEnthalpy : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        void
+        initialize()
+        {
+          const std::string datadirectory = Utilities::expand_ASPECT_SOURCE_DIR("$ASPECT_SOURCE_DIR/data/material-model/latent-heat-enthalpy-test/");
+          const std::string material_file_names  = "testdata.txt";
+
+          material_lookup = std::make_unique<MaterialModel::MaterialUtilities::Lookup::PerplexReader>(datadirectory+material_file_names,
+                            true,
+                            this->get_mpi_communicator());
+        }
+
+        bool
+        is_compressible () const
+        {
+          return false;
+        }
+
+        void
+        evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
+        {
+          const double reference_rho              = 3400;
+          const double density_jump               = 115.6;
+          const double reference_T                = 1000;
+          const double eta                        = 8.44e21;
+          const double k_value                    = 2.38;
+          const double reference_specific_heat    = 1000;
+          const double thermal_alpha              = 0;
+
+          double dHdT = 0.0;
+          double dHdp = 0.0;
+
+          if (in.current_cell.state() == IteratorState::valid)
+            {
+              const QTrapezoid<dim> quadrature_formula;
+              const unsigned int n_q_points = quadrature_formula.size();
+
+              FEValues<dim> fe_values (this->get_mapping(),
+                                       this->get_fe(),
+                                       quadrature_formula,
+                                       update_values);
+
+              std::vector<double> temperatures(n_q_points), pressures(n_q_points);
+              std::vector<std::vector<double>> compositions (quadrature_formula.size(),std::vector<double> (this->n_compositional_fields()));
+              std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+
+              fe_values.reinit (in.current_cell);
+
+              // get the various components of the solution, then
+              // evaluate the material properties there
+              fe_values[this->introspection().extractors.temperature]
+              .get_function_values (this->get_solution(), temperatures);
+              fe_values[this->introspection().extractors.pressure]
+              .get_function_values (this->get_solution(), pressures);
+
+              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                fe_values[this->introspection().extractors.compositional_fields[c]]
+                .get_function_values(this->get_solution(),
+                                     composition_values[c]);
+              for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
+                {
+                  for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                    compositions[q][c] = composition_values[c][q];
+                }
+
+              unsigned int T_points(0),p_points(0);
+
+              for (unsigned int q=0; q<n_q_points; ++q)
+                {
+                  const double own_enthalpy = material_lookup->enthalpy(temperatures[q],pressures[q]);
+                  for (unsigned int p=0; p<n_q_points; ++p)
+                    {
+                      double enthalpy_p,enthalpy_T;
+                      if (std::fabs(temperatures[q] - temperatures[p]) > 100 * std::fabs(temperatures[q]) * std::numeric_limits<double>::epsilon())
+                        {
+                          enthalpy_p = material_lookup->enthalpy(temperatures[p],pressures[q]);
+                          const double point_contribution = (own_enthalpy-enthalpy_p)/(temperatures[q]-temperatures[p]);
+                          dHdT += point_contribution;
+                          T_points++;
+                        }
+                      if (std::fabs(pressures[q] - pressures[p]) > 100 * std::fabs(pressures[q]) * std::numeric_limits<double>::epsilon())
+                        {
+                          enthalpy_T = material_lookup->enthalpy(temperatures[q],pressures[p]);
+                          dHdp += (own_enthalpy-enthalpy_T)/(pressures[q]-pressures[p]);
+                          p_points++;
+                        }
+                    }
+                }
+
+              if ((T_points > 0)
+                  && (p_points > 0))
+                {
+                  dHdT /= T_points;
+                  dHdp /= p_points;
+                }
+            }
+
+          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+            {
+              if (in.requests_property(MaterialProperties::viscosity))
+                out.viscosities[i] = eta;
+
+              out.densities[i] = material_lookup->density(in.temperature[i],in.pressure[i]);
+
+              if (this->get_adiabatic_conditions().is_initialized())
+                {
+                  if ((in.current_cell.state() == IteratorState::valid)
+                      && (std::fabs(dHdp) > 100 * std::numeric_limits<double>::epsilon())
+                      && (std::fabs(dHdT) > 100 * std::numeric_limits<double>::epsilon()))
+                    {
+                      out.thermal_expansion_coefficients[i] = (1 - (reference_rho + density_jump) * dHdp) / in.temperature[i];
+                      out.specific_heat[i] = dHdT;
+                    }
+                  else
+                    {
+                      out.thermal_expansion_coefficients[i] = material_lookup->thermal_expansivity(in.temperature[i],in.pressure[i]);
+                      out.specific_heat[i] = material_lookup->specific_heat(in.temperature[i],in.pressure[i]);
+                    }
+                }
+              else
+                {
+                  out.thermal_expansion_coefficients[i] = (1 - (reference_rho + density_jump) * material_lookup->dHdp(in.temperature[i],in.pressure[i])) / in.temperature[i];
+                  out.specific_heat[i] = material_lookup->dHdT(in.temperature[i],in.pressure[i]);
+                }
+
+              out.thermal_conductivities[i] = k_value;
+            }
+        }
+
+      private:
+        std::unique_ptr<MaterialModel::MaterialUtilities::Lookup::MaterialLookup> material_lookup;
+    };
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(LatentHeatEnthalpy,
+                                   "latent heat enthalpy",
+                                   "A test model that implements a latent "
+                                   "heat formulation based on a lookup table "
+                                   "that is evaluated at the edges of the cell "
+                                   "rather than at the quadrature points.")
+  }
+}
diff --git a/tests/latent_heat_enthalpy.prm.bak b/tests/latent_heat_enthalpy.prm.bak
new file mode 100644
index 00000000000..8989962f2ed
--- /dev/null
+++ b/tests/latent_heat_enthalpy.prm.bak
@@ -0,0 +1,115 @@
+#########################################################
+# This is a model setup to test the latent heat generation,
+# similar to the test latent_heat.
+# Material flows in from the top and crosses a phase
+# transition, where energy is released and the temperature
+# increases. The energy release in this model is calculated
+# from a lookup table for enthalpy values and the enthalpy
+# is evaluated at the edges of each cell instead of the
+# quadrature point to catch even very sharp transitions.
+# The steady-state result is around 10 % off the original
+# test, because the data table was created as small as
+# possible.
+# A similar testcase is also described in the latent heat
+# cookbook, and the predicted temperature solution at the
+# bottom of the model is the same (T2 = 1107.39 K).
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 2.5e14
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature          = 1000.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10000
+    set Y extent = 1000000
+    set Y repetitions = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Warning: Merge the parameter in the following subsection with any
+# other parameter of the same name, otherwise your model results might change
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = 3
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;-2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    # In contrast to the other latent heat test we need a small temperature
+    # perturbation to be able to compute derivatives from the material table.
+    # This is because we compute derivatives from the differences between cell
+    # vertices, and if they have identical pressure-temperature conditions, we
+    # can not compute a reasonable derivative
+    set Function expression = 1000.0 + (y-1000000)/1000000
+    set Variable names      = x,y
+  end
+end
+
+# All of the material properties are taken from the table or hard coded
+# in the material model.
+subsection Material model
+  set Model name = latent heat enthalpy
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
diff --git a/tests/latent_heat_melt.prm.bak b/tests/latent_heat_melt.prm.bak
new file mode 100644
index 00000000000..78d88818449
--- /dev/null
+++ b/tests/latent_heat_melt.prm.bak
@@ -0,0 +1,145 @@
+#########################################################
+# This is a model setup to test the latent heat generation.
+# Melt flows in from the bottom and crosses a phase
+# transition, where it freezes and energy is released and
+# the temperature increases.
+# The crucial property of the test is the equilibrium
+# temperature at the top of the domain.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 4e16
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Max nonlinear iterations               = 20
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, field2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(z<500000.0,1,0);if(z>500000.,0,1)
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Heating model
+  set List of model names = latent heat melt
+
+  subsection Latent heat melt
+    set Melting entropy change = -300.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+    set Bottom temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Viscosity                     = 8.44e21
+    set Density differential for compositional field 1 = 0
+    set Density differential for compositional field 2 = 0
+    set Reaction depth                = 500000
+    set Reference specific heat       = 1000.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics #, visualization
+
+  subsection Visualization
+    set Interpolate output            = false
+    set List of output variables      = material properties, nonadiabatic temperature
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 2500
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms, specific heat
+    end
+  end
+end
diff --git a/tests/latent_heat_melt_operator_split.prm.bak b/tests/latent_heat_melt_operator_split.prm.bak
new file mode 100644
index 00000000000..6720afee75b
--- /dev/null
+++ b/tests/latent_heat_melt_operator_split.prm.bak
@@ -0,0 +1,172 @@
+# This is a model setup to test the latent heat generation.
+# Melt flows in from the bottom and crosses a phase
+# transition, where it freezes and energy is released and
+# the temperature increases.
+# The crucial property of the test is the equilibrium
+# temperature at the top of the domain. This test is the
+# same as the "latent heat melt" test, except that is uses
+# the operator split solver scheme.
+
+# The temperature should be
+# Tbottom + T * DS / C_p * DC
+# with
+# Tbottom = 1000 K (temperature at the bottom)
+# DS      = 300 K/kg (Melting entropy change)
+# C_p     = 1000 J/(kg K)
+# DC      = 1 (change in porosity)
+
+# Since the temperature T changes during the reaction,
+# but the change in porosity occurs instantaneously,
+# this is not a well-defined ODE and we do not use
+# our ODE solver to solve it. Even with the fixed step
+# operator splitting scheme, the solution depends on
+# the number of steps taken. Taking into account this
+# change in temperature, the temperature at the top
+# should be somewhere between 1300 and 1390 K. The more
+# steps we take, the closer it is to the upper value.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 4e16
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Use operator splitting                 = true
+
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction solver type               = fixed step
+    set Reaction time step                 = 4e16
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 20000
+    set Y extent = 1000000
+    set Y repetitions = 50
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, field2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(z<500000.0,1,0);if(z>500000.,0,1)
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Heating model
+  set List of model names = latent heat melt
+
+  subsection Latent heat melt
+    set Melting entropy change = -300.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+    set Bottom temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Viscosity                     = 8.44e21
+    set Density differential for compositional field 1 = 0
+    set Density differential for compositional field 2 = 0
+    set Reaction depth                = 500000
+    set Reference specific heat       = 1000.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+
+  subsection Visualization
+    set Interpolate output            = false
+    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 1e15
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms, specific heat
+    end
+  end
+end
diff --git a/tests/latent_heat_melt_statistics.prm.bak b/tests/latent_heat_melt_statistics.prm.bak
new file mode 100644
index 00000000000..6aa71c38e50
--- /dev/null
+++ b/tests/latent_heat_melt_statistics.prm.bak
@@ -0,0 +1,127 @@
+# This test checks if the postprocessor 'melt statistics' works as
+# intended. The statistics output is computed using
+# the melt fraction of peridotite in the melting model of
+# Katz et. al, 2003 (Geochem., Geophys., Geosyst. )
+# with the temperature ranging from 1000°C to 1900°C on the x axis
+# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
+
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9
+    set Y extent = 8
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1100+273.15+x*100
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
+  end
+end
+
+subsection Material model
+  set Model name = latent heat melt
+
+  subsection Latent heat melt
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+    set Mass fraction cpx             = 0.17
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 6
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = melt statistics
+end
diff --git a/tests/latent_heat_melt_transport.prm.bak b/tests/latent_heat_melt_transport.prm.bak
new file mode 100644
index 00000000000..ced00b8efe6
--- /dev/null
+++ b/tests/latent_heat_melt_transport.prm.bak
@@ -0,0 +1,162 @@
+#########################################################
+# This is a model setup to test the latent heat generation.
+# Melt flows in from the bottom and crosses a phase
+# transition, where it freezes and energy is released and
+# the temperature increases.
+# The crucial property of the test is the equilibrium
+# temperature at the top of the domain. This test is the
+# same as the "latent heat melt" test, except that is uses
+# the operator split solver scheme, and that active melt
+# transport is enabled.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 4e16
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Use operator splitting                     = true
+
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction time step                     = 4e14
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(z<500000.0,1,0);if(z>500000.,0,1)
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Heating model
+  set List of model names = latent heat melt
+
+  subsection Latent heat melt
+    set Melting entropy change = -300.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+    set Bottom temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Reference solid density       = 3300
+    set Reference melt density        = 3299.9
+    set Thermal conductivity          = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Reference shear viscosity     = 8.44e21
+    set Reference specific heat       = 1000.0
+    set Depletion solidus change      = 0.0
+    set Surface solidus               = 2500
+    set Pressure solidus change       = -1e-7
+    set Exponential melt weakening factor = 0.0
+    set Melting time scale for operator splitting = 2.400384061e15
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, visualization
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set Time between graphical output = 2500
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms, specific heat
+    end
+  end
+end
diff --git a/tests/latent_heat_pressure.prm.bak b/tests/latent_heat_pressure.prm.bak
new file mode 100644
index 00000000000..6464db86718
--- /dev/null
+++ b/tests/latent_heat_pressure.prm.bak
@@ -0,0 +1,126 @@
+# This is a copy of the latent_heat test that defines the
+# phase transition in terms of pressure instead of depth.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 1e15
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = 3
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;-2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    # The change of density across the phase transition. Together with the
+    # Clapeyron slope, this is what determines the entropy change.
+    set Phase transition density jumps                 = 115.6
+    set Corresponding phase for density jump           = 0
+
+    # If the temperature is equal to the phase transition temperature, the
+    # phase transition will occur at the phase transition depth. However,
+    # if the temperature deviates from this value, the Clapeyron slope
+    # determines how much the pressure (and depth) of the phase boundary
+    # changes. Here, the phase transition will be in the middle of the box
+    # for T=T1.
+    set Phase transition pressures                     = 1.7e10
+    set Phase transition pressure widths               = 6.8e8
+    set Define transition by depth instead of pressure = false
+    set Phase transition temperatures                  = 1000
+    set Phase transition Clapeyron slopes              = 1e7
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 2.38
+
+    # We set the thermal expansion and the compressibility to zero, so that
+    # all temperature (and density) changes are caused by advection, diffusion
+    # and latent heating.
+    set Thermal expansion coefficient                  = 0.0
+    set Compressibility                                = 0.0
+
+    # Viscosity is constant.
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 8.44e21
+    set Viscosity prefactors                           = 1.0, 1.0
+    set Composition viscosity prefactor                = 1.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
+
+subsection Heating model
+  set List of model names =  latent heat
+end
diff --git a/tests/latent_heat_viscosity.prm.bak b/tests/latent_heat_viscosity.prm.bak
new file mode 100644
index 00000000000..2253cc4b4ad
--- /dev/null
+++ b/tests/latent_heat_viscosity.prm.bak
@@ -0,0 +1,113 @@
+# A simple setup for for using the GPlates interface in a 2d shell
+# with the latent heat material model. It tests the feature of the
+# latent heat material model to use a layered viscosity profile.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 3e8
+set Output directory                       = output_energy_density
+set Adiabatic surface temperature          = 1600
+set Resume computation                     = false
+
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    set Viscosity                     = 1e21
+    set Thermal viscosity exponent    = 15.0
+    set Reference temperature         = 1600
+
+    # 'background' or 'all' are identical identifiers, because there is just
+    # background material
+    set Phase transition depths           = all:410000|660000
+    set Phase transition widths           = background:20000|20000
+    set Phase transition temperatures     = all:1600|1600
+    set Phase transition Clapeyron slopes = all:3e6|-2e6
+    set Phase transition density jumps    = 100, 200
+    set Corresponding phase for density jump = 0, 0
+    set Viscosity prefactors          = 1, 10, 100
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = outer:gplates
+  set Tangential velocity boundary indicators = inner
+
+  subsection GPlates model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
+    set Velocity file name = current_day.gpml
+    set Data file time step = 1e6
+    set Point one = 1.5708,4.87
+    set Point two = 1.5708,5.24
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 5e7
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Refinement fraction                = 0.8
+  set Coarsening fraction                = 0.05
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 5
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+    set List of output variables      = material properties
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint  = 1800
+end
+
+subsection Termination criteria
+  set End step = 1
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+end
diff --git a/tests/latent_heat_viscosity_adiabatic.prm.bak b/tests/latent_heat_viscosity_adiabatic.prm.bak
new file mode 100644
index 00000000000..7d99b8b9df5
--- /dev/null
+++ b/tests/latent_heat_viscosity_adiabatic.prm.bak
@@ -0,0 +1,102 @@
+# A modification of the latent heat viscosity test, but with adiabatic heating.
+# It tests that the viscosity of the different layers is constant.
+# The gnuplot output illustrates the viscosity increase at 410 and 660 km depth.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    set Viscosity                     = 1e21
+    set Thermal viscosity exponent    = 15.0
+    set Reference temperature         = 1600
+
+    # 'background' or 'all' are identical identifiers, because there is just
+    # background material
+    set Phase transition depths           = all:410000|660000
+    set Phase transition widths           = background:20000|20000
+    set Phase transition temperatures     = all:1600|1600
+    set Phase transition Clapeyron slopes = all:3e6|-2e6
+    set Phase transition density jumps    = 100, 200
+    set Corresponding phase for density jump = 0, 0
+    set Viscosity prefactors          = 1, 10, 100
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, outer, left, right
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer = 0
+    set Age bottom boundary layer = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+    set List of output variables      = material properties
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+    set Number of zones = 25
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint  = 1800
+end
diff --git a/tests/lithosphere_boundary_indicator.prm.bak b/tests/lithosphere_boundary_indicator.prm.bak
new file mode 100644
index 00000000000..0345ba01730
--- /dev/null
+++ b/tests/lithosphere_boundary_indicator.prm.bak
@@ -0,0 +1,130 @@
+# With this geometry model we add 2 additional boundary
+# indicators to the lithospheric part of the left and right
+# boundary.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+# We use a boundary temperature model
+# with additional boundary indicators
+# as prescribed by the geometry model
+# In 2D the additional boundary indicators have value 4 (left lithosphere)
+# and 5 (right lithosphere). Because we want flow through these boundaries
+# we set fixed temperature and composition boundary conditions.
+# For now we set the lower part of the vertical boundaries to
+# zero velocity, while prescribing a velocity function on boundary
+# 4 and 5. Note that this particular example can be accomplished
+# without additional boundary indicators and just prescribing a
+# velocity function on the whole vertical boundaries.
+# Along the top and the lithospheric part of the vertical boundaries
+# we prescribe a plate velocity of 1 cm/year.
+
+subsection Boundary temperature model
+  set List of model names = box with lithosphere boundary indicators
+  set Fixed temperature boundary indicators   = 0, 1, 4, 5
+
+  subsection Box with lithosphere boundary indicators
+    set Left temperature = 0
+  end
+end
+
+# We use the initial composition
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0, 1, 4, 5
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = box with lithosphere boundary indicators
+
+  subsection Box with lithosphere boundary indicators
+    set X extent = 1000000
+    set Y extent = 600000
+    set Lithospheric thickness = 80000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+# We prescribe one compositional field
+# to represent the lithosphere
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities                  = 3300,3250
+    set Reference temperature      = 293
+    set Specific heats             = 1250
+    set Thermal conductivities     = 0.
+    set Thermal expansivities      = 0.
+    set Viscosities                = 1e20,1e21
+    set Viscosity averaging scheme = harmonic
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function, 4: function, 5: function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = lith_depth=8e4, model_height=6e5
+    set Function expression = if(z>(model_height-lith_depth),0.01,0);0
+  end
+end
+
+# The lithosphere is represented by a lower density,
+# higher viscosity compositional field.
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z
+    set Function constants = lith_depth=8e4, model_height=6e5
+    set Function expression = if((model_height-z)<lith_depth,1,0)
+  end
+end
+
+# We look at the velocity and pressure statistics. Max velocity will be
+# the prescribed velocity of 1 cm/year. The boundary indicator
+# visualization shows us the indicators we set at the boundaries.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format            = gnuplot
+    set List of output variables = boundary indicators
+  end
+end
diff --git a/tests/lithosphere_boundary_indicator_3d.prm.bak b/tests/lithosphere_boundary_indicator_3d.prm.bak
new file mode 100644
index 00000000000..89a2e7aec72
--- /dev/null
+++ b/tests/lithosphere_boundary_indicator_3d.prm.bak
@@ -0,0 +1,133 @@
+# With this geometry model we add 4 additional boundary
+# indicators to the lithospheric part of the left, right,
+# front and back boundaries (i.e. all vertical boundaries).
+
+set Dimension                              = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+# We use a boundary temperature model
+# with additional boundary indicators
+# as prescribed by the geometry model
+# In 3D the additional boundary indicators have value 6 (left lithosphere),
+# 7 (right lithosphere), 8 (front lithosphere) and 9 (back lithosphere).
+# Because we want flow through these boundaries
+# we set fixed temperature and composition boundary conditions.
+# For now we set the lower part of the vertical boundaries to
+# zero velocity, while prescribing a velocity function on boundary
+# 6, 7, 8 and 9. Note that this particular example can be accomplished
+# without additional boundary indicators and just prescribing a
+# velocity function on the whole vertical boundaries.
+# Along the top boundary and the lithospheric part of the vertical
+# boundaries, we prescribe a plate velocity of 1 cm/year.
+
+subsection Boundary temperature model
+  set List of model names = box with lithosphere boundary indicators
+  set Fixed temperature boundary indicators   = 0, 1, 6, 7, 8, 9
+
+  subsection Box with lithosphere boundary indicators
+    set Left temperature = 0
+  end
+end
+
+# We use the initial composition
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0, 1, 6, 7, 8, 9
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = box with lithosphere boundary indicators
+
+  subsection Box with lithosphere boundary indicators
+    set X extent = 1000000
+    set Y extent = 600000
+    set Z extent = 600000
+    set Lithospheric thickness = 80000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+# We prescribe one compositional field
+# to represent the lithosphere
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities                  = 3300,3250
+    set Reference temperature      = 293
+    set Specific heats             = 1250
+    set Thermal conductivities     = 0.
+    set Thermal expansivities      = 0.
+    set Viscosities                = 1e20,1e21
+    set Viscosity averaging scheme = harmonic
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1, 4
+  set Tangential velocity boundary indicators = 2, 3
+  set Prescribed velocity boundary indicators = 5: function, 6: function, 7: function, 8:function, 9:function
+
+  subsection Function
+    set Variable names = x,y,z
+    set Function constants = lith_depth=8e4, model_height=6e5
+    set Function expression = if(z>(model_height-lith_depth),0.01,0);0;0
+  end
+end
+
+# The lithosphere is represented by a lower density,
+# higher viscosity compositional field.
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y,z
+    set Function constants = lith_depth=8e4, model_height=6e5
+    set Function expression = if((model_height-z)<lith_depth,1,0)
+  end
+end
+
+# We look at the velocity and pressure statistics. Max velocity will be
+# the prescribed velocity of 1 cm/year. The boundary indicator
+# visualization shows us the indicators we set at the boundaries.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format            = gnuplot
+    set List of output variables = boundary indicators
+  end
+end
diff --git a/tests/lithosphere_boundary_indicator_3d_one_grid.prm.bak b/tests/lithosphere_boundary_indicator_3d_one_grid.prm.bak
new file mode 100644
index 00000000000..94882566152
--- /dev/null
+++ b/tests/lithosphere_boundary_indicator_3d_one_grid.prm.bak
@@ -0,0 +1,13 @@
+# exactly the same as lithosphere_boundary_indicator_3d.prm but made with one grid
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/tests/lithosphere_boundary_indicator_3d.prm
+
+
+subsection Geometry model
+  subsection Box with lithosphere boundary indicators
+    set Use merged grids = false
+    set Z repetitions = 2
+  end
+end
diff --git a/tests/lithosphere_boundary_indicator_3d_periodic.prm.bak b/tests/lithosphere_boundary_indicator_3d_periodic.prm.bak
new file mode 100644
index 00000000000..863549dc665
--- /dev/null
+++ b/tests/lithosphere_boundary_indicator_3d_periodic.prm.bak
@@ -0,0 +1,152 @@
+# With this geometry model we add 4 additional boundary
+# indicators to the lithospheric part of the left, right,
+# front and back boundaries (i.e. all vertical boundaries).
+# This prm tests the periodic boundary condition for
+# the front and back additional boundaries.
+
+set Dimension                              = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+# We use a boundary temperature model
+# with additional boundary indicators
+# as prescribed by the geometry model.
+# Inflow occurs along the left top
+# boundary, so we prescribe temperature
+# there.
+# In 3D the additional boundary indicators have value 6 (left lithosphere),
+# 7 (right lithosphere), 8 (front lithosphere) and 9 (back lithosphere).
+# We prescribe a velocity field oblique to all vertical boundaries
+# (so in the X- and Y-direction) to the left and right lithosphere
+# and the top boundary.
+# Boundaries with inflow that are not periodic get a prescribed
+# temperature and composition.
+# The mantle velocity is restricted to tangential only.
+subsection Boundary temperature model
+  set List of model names = box with lithosphere boundary indicators
+  set Fixed temperature boundary indicators   = 6
+
+  subsection Box with lithosphere boundary indicators
+    set Left temperature lithosphere = 0
+    set Front temperature lithosphere = 0
+  end
+end
+
+# We use the initial composition as boundary
+# condition.
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 6
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+# We create a rectangular domain with additional
+# boundary indicators for the lithospheric part
+# of the vertical boundaries.
+# We use the repetitions to get the same resolution
+# in the lithosphere and mantle.
+# The lithospheric boundaries normal to the
+# Y-direction are periodic.
+subsection Geometry model
+  set Model name = box with lithosphere boundary indicators
+
+  subsection Box with lithosphere boundary indicators
+    set X extent = 600000
+    set Y extent = 1200000
+    set Z extent = 600000
+    set Lithospheric thickness = 100000
+    set X repetitions = 6
+    set Y repetitions = 12
+    set Z repetitions = 5
+    set Y periodic lithosphere = true
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+# We prescribe one compositional field
+# to represent the lithosphere as a
+# less dense, more viscous material.
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities                  = 3300,3250
+    set Reference temperature      = 293
+    set Specific heats             = 1250
+    set Thermal conductivities     = 0.
+    set Thermal expansivities      = 0.
+    set Viscosities                = 1e20,1e21
+    set Viscosity averaging scheme = harmonic
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3, 4
+  set Prescribed velocity boundary indicators = 5: function, 6:function, 7:function
+
+  # On the lithospheric part of the boundary,
+  # prescribe a velocity in the X- and Y-direction [m/yr].
+  subsection Function
+    set Variable names = x,y,z
+    set Function constants = lith_depth=100e3, model_height=600e3
+    set Function expression = if(z>(model_height-lith_depth),0.005,0); \
+                              if(z>(model_height-lith_depth),0.005,0); \
+                              0
+  end
+end
+
+# The lithosphere is represented by a lower density,
+# higher viscosity compositional field.
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+# The lithosphere is 100 km thick.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y,z
+    set Function constants = lith_depth=100e3, model_height=600e3
+    set Function expression = if((model_height-z)<lith_depth,1,0)
+  end
+end
+
+# We look at the velocity statistics. Max velocity will be
+# the prescribed velocity of 0.71 cm/year. The boundary indicator
+# visualization shows us the indicators we set at the boundaries.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format            = gnuplot
+    set List of output variables = boundary indicators
+  end
+end
diff --git a/tests/lithosphere_boundary_indicator_one_grid.prm.bak b/tests/lithosphere_boundary_indicator_one_grid.prm.bak
new file mode 100644
index 00000000000..8bec08e2ea2
--- /dev/null
+++ b/tests/lithosphere_boundary_indicator_one_grid.prm.bak
@@ -0,0 +1,13 @@
+# exactly the same as lithosphere_boundary_indicator.prm but made with one grid
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/lithosphere_boundary_indicator.prm
+
+
+subsection Geometry model
+  subsection Box with lithosphere boundary indicators
+    set Use merged grids = false
+    set Y repetitions = 2
+  end
+end
diff --git a/tests/lithosphere_boundary_indicator_origin.prm.bak b/tests/lithosphere_boundary_indicator_origin.prm.bak
new file mode 100644
index 00000000000..51ae8f6df9e
--- /dev/null
+++ b/tests/lithosphere_boundary_indicator_origin.prm.bak
@@ -0,0 +1,15 @@
+# With this geometry model we add 2 additional boundary
+# indicators to the lithospheric part of the left and right
+# boundary.
+# This test is for a nonzero box Y origin.
+
+include $ASPECT_SOURCE_DIR/tests/lithosphere_boundary_indicator.prm
+
+
+subsection Geometry model
+  set Model name = box with lithosphere boundary indicators
+
+  subsection Box with lithosphere boundary indicators
+    set Box origin Y coordinate = 300000
+  end
+end
diff --git a/tests/logo.prm.bak b/tests/logo.prm.bak
new file mode 100644
index 00000000000..da18e118eca
--- /dev/null
+++ b/tests/logo.prm.bak
@@ -0,0 +1,14 @@
+# A test for the model that produces the ASPECT logo.
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/doc/logo/logo.prm
+
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 1
+end
diff --git a/tests/magnetic_stripes.cc.bak b/tests/magnetic_stripes.cc.bak
new file mode 100644
index 00000000000..7f2aa2f7ae6
--- /dev/null
+++ b/tests/magnetic_stripes.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../cookbooks/magnetic_stripes/magnetic_stripes.cc"
diff --git a/tests/magnetic_stripes.prm.bak b/tests/magnetic_stripes.prm.bak
new file mode 100644
index 00000000000..0c769b454f5
--- /dev/null
+++ b/tests/magnetic_stripes.prm.bak
@@ -0,0 +1,8 @@
+include $ASPECT_SOURCE_DIR/cookbooks/magnetic_stripes/magnetic_stripes.prm
+
+set Dimension = 2
+set End time = 0
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 0
+end
diff --git a/tests/mass_flux_statistics.prm.bak b/tests/mass_flux_statistics.prm.bak
new file mode 100644
index 00000000000..0d62c7ea7bb
--- /dev/null
+++ b/tests/mass_flux_statistics.prm.bak
@@ -0,0 +1,44 @@
+# Test to check the status of the mass flux statistics postprocessor.
+# Simple model with prescribed flux through the boundaries.
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set End time                               = 0
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+end
+
+subsection Material model
+  set Model name = simpler
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left:function,right:function,top:function,bottom:function
+
+  subsection Function
+    set Function expression = 1;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics
+end
diff --git a/tests/mass_reaction_term.prm.bak b/tests/mass_reaction_term.prm.bak
new file mode 100644
index 00000000000..d8e75194e40
--- /dev/null
+++ b/tests/mass_reaction_term.prm.bak
@@ -0,0 +1,173 @@
+#########################################################
+# This is a model setup to test the term on the right-hand
+# side of the mass conservation in models with melt
+# transport that describes the change in volume associated
+# with melting and freezing reactions.
+# Melt flows in from the bottom and crosses a phase
+# transition, where it freezes and changes the velocity.
+# The crucial property of the test is the maximum velocity
+# (at the bottom of the domain), which should be close to
+# 2.4e-11 m/s.
+#
+# This is because upon melting, the density changes from
+# 3000 kg/m3 to 2500 kg/m3, so the velocity increases from
+# 2e-11 m/s to
+#
+# 2e-11 m/s * 3000/2500 = 2.4e-11 m/s.
+#
+# This test is similar to the
+# "latent heat melt transport" test, except that it has a
+# zero permeability and latent heat, and slightly different
+# material properties and geometry.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 2.6e16
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Use operator splitting                 = true
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 25000
+    set Y extent = 1000000
+    set Y repetitions = 40
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(z<500000.0,1,0);if(z>500000.,0,1)
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Heating model
+  set List of model names = latent heat melt
+
+  subsection Latent heat melt
+    set Melting entropy change = 0.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+    set Bottom temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;2.e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Reference solid density       = 3000
+    set Reference melt density        = 2500
+    set Thermal conductivity          = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Reference shear viscosity     = 8.44e28
+    set Reference specific heat       = 1000.0
+    set Depletion solidus change      = 0.0
+    set Surface solidus               = 2500
+    set Pressure solidus change       = -1e-7
+    set Exponential melt weakening factor = 0.0
+    set Melting time scale for operator splitting = 2.400384061e15
+    set Reference permeability        = 1e-25
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs, melt material properties
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set Time between graphical output = 2500
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms, specific heat
+    end
+
+    subsection Melt material properties
+      set List of properties = is melt cell
+    end
+  end
+end
diff --git a/tests/material_model_dependencies.cc.bak b/tests/material_model_dependencies.cc.bak
new file mode 100644
index 00000000000..964c157b518
--- /dev/null
+++ b/tests/material_model_dependencies.cc.bak
@@ -0,0 +1,132 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// A postprocessor that simply outputs which of the output variables
+// of the material model depends on the input variables
+
+#include <aspect/postprocess/interface.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    class MaterialModelDependencies : public Interface<dim>,
+      public SimulatorAccess<dim>
+    {
+      public:
+        virtual
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics)
+        {
+          using namespace MaterialModel;
+          using namespace NonlinearDependence;
+
+          const aspect::MaterialModel::Interface<dim> &model
+            = this->get_material_model();
+          std::cout << "viscosity depends on"
+                    << ((model.get_model_dependence().viscosity & MaterialModel::NonlinearDependence::pressure)
+                        ?
+                        " pressure" : "")
+                    << ((model.get_model_dependence().viscosity & MaterialModel::NonlinearDependence::temperature)
+                        ?
+                        " temperature" : "")
+                    << ((model.get_model_dependence().viscosity & MaterialModel::NonlinearDependence::strain_rate)
+                        ?
+                        " strainrate" : "")
+                    << ((model.get_model_dependence().viscosity & MaterialModel::NonlinearDependence::compositional_fields)
+                        ?
+                        " composition" : "")
+                    << std::endl;
+          std::cout << "density depends on"
+                    << ((model.get_model_dependence().density & MaterialModel::NonlinearDependence::pressure)
+                        ?
+                        " pressure" : "")
+                    << ((model.get_model_dependence().density & MaterialModel::NonlinearDependence::temperature)
+                        ?
+                        " temperature" : "")
+                    << ((model.get_model_dependence().density & MaterialModel::NonlinearDependence::strain_rate)
+                        ?
+                        " strainrate" : "")
+                    << ((model.get_model_dependence().density & MaterialModel::NonlinearDependence::compositional_fields)
+                        ?
+                        " composition" : "")
+                    << std::endl;
+          std::cout << "compressibility depends on"
+                    << ((model.get_model_dependence().compressibility & MaterialModel::NonlinearDependence::pressure)
+                        ?
+                        " pressure" : "")
+                    << ((model.get_model_dependence().compressibility & MaterialModel::NonlinearDependence::temperature)
+                        ?
+                        " temperature" : "")
+                    << ((model.get_model_dependence().compressibility & MaterialModel::NonlinearDependence::strain_rate)
+                        ?
+                        " strainrate" : "")
+                    << ((model.get_model_dependence().compressibility & MaterialModel::NonlinearDependence::compositional_fields)
+                        ?
+                        " composition" : "")
+                    << std::endl;
+          std::cout << "specific_heat depends on"
+                    << ((model.get_model_dependence().specific_heat & MaterialModel::NonlinearDependence::pressure)
+                        ?
+                        " pressure" : "")
+                    << ((model.get_model_dependence().specific_heat & MaterialModel::NonlinearDependence::temperature)
+                        ?
+                        " temperature" : "")
+                    << ((model.get_model_dependence().specific_heat & MaterialModel::NonlinearDependence::strain_rate)
+                        ?
+                        " strainrate" : "")
+                    << ((model.get_model_dependence().specific_heat & MaterialModel::NonlinearDependence::compositional_fields)
+                        ?
+                        " composition" : "")
+                    << std::endl;
+          std::cout << "thermal_conductivity depends on"
+                    << ((model.get_model_dependence().thermal_conductivity & MaterialModel::NonlinearDependence::pressure)
+                        ?
+                        " pressure" : "")
+                    << ((model.get_model_dependence().thermal_conductivity & MaterialModel::NonlinearDependence::temperature)
+                        ?
+                        " temperature" : "")
+                    << ((model.get_model_dependence().thermal_conductivity & MaterialModel::NonlinearDependence::strain_rate)
+                        ?
+                        " strainrate" : "")
+                    << ((model.get_model_dependence().thermal_conductivity & MaterialModel::NonlinearDependence::compositional_fields)
+                        ?
+                        " composition" : "")
+                    << std::endl;
+          std::cout << "model is "
+                    << (model.is_compressible() ? "compressible" : "incompressible")
+                    << std::endl;
+          return std::pair<std::string,std::string>();
+        }
+    };
+  }
+}
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(MaterialModelDependencies,
+                                  "material model dependencies",
+                                  ".")
+  }
+}
diff --git a/tests/material_model_dependencies_burstedde.cc.bak b/tests/material_model_dependencies_burstedde.cc.bak
new file mode 100644
index 00000000000..0ff8f448846
--- /dev/null
+++ b/tests/material_model_dependencies_burstedde.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
+#include "burstedde.cc"
diff --git a/tests/material_model_dependencies_burstedde.prm.bak b/tests/material_model_dependencies_burstedde.prm.bak
new file mode 100644
index 00000000000..2d755cdd7db
--- /dev/null
+++ b/tests/material_model_dependencies_burstedde.prm.bak
@@ -0,0 +1,86 @@
+#############################
+# Otherwise use the setup of burstedde
+
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+
+subsection Material model
+  set Model name = BursteddeMaterial
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+############### Parameters describing the model
+# The setup is a 3d unit cube.
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+    set Z extent  = 1
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:BursteddeBoundary, 1: BursteddeBoundary, 2: BursteddeBoundary, 3: BursteddeBoundary, 4: BursteddeBoundary, 5: BursteddeBoundary
+end
+
+subsection Gravity model
+  set Model name = BursteddeGravity
+end
+
+subsection Burstedde benchmark
+  #Viscosity parameter is beta
+  set Viscosity parameter             = 20
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/material_model_dependencies_composition_reaction.cc.bak b/tests/material_model_dependencies_composition_reaction.cc.bak
new file mode 100644
index 00000000000..d46e5b4ae6a
--- /dev/null
+++ b/tests/material_model_dependencies_composition_reaction.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_composition_reaction.prm.bak b/tests/material_model_dependencies_composition_reaction.prm.bak
new file mode 100644
index 00000000000..87b199c2e50
--- /dev/null
+++ b/tests/material_model_dependencies_composition_reaction.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = composition reaction
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_cookbooks_freesurface_with_crust.cc.bak b/tests/material_model_dependencies_cookbooks_freesurface_with_crust.cc.bak
new file mode 100644
index 00000000000..eb67e33f19f
--- /dev/null
+++ b/tests/material_model_dependencies_cookbooks_freesurface_with_crust.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
+#include "cookbook_simpler_with_crust.cc"
diff --git a/tests/material_model_dependencies_cookbooks_freesurface_with_crust.prm.bak b/tests/material_model_dependencies_cookbooks_freesurface_with_crust.prm.bak
new file mode 100644
index 00000000000..95a3a537270
--- /dev/null
+++ b/tests/material_model_dependencies_cookbooks_freesurface_with_crust.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = simpler with crust
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_diffusion_dislocation.cc.bak b/tests/material_model_dependencies_diffusion_dislocation.cc.bak
new file mode 100644
index 00000000000..d46e5b4ae6a
--- /dev/null
+++ b/tests/material_model_dependencies_diffusion_dislocation.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_diffusion_dislocation.prm.bak b/tests/material_model_dependencies_diffusion_dislocation.prm.bak
new file mode 100644
index 00000000000..167ab526e75
--- /dev/null
+++ b/tests/material_model_dependencies_diffusion_dislocation.prm.bak
@@ -0,0 +1,73 @@
+#############################
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 293
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+# This parameter file implements an initial temperature of 293 K + x,
+# where x is the fraction of the box width, in a 2D box of size 1x1.
+
+subsection Material model
+  set Model name = diffusion dislocation
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 293 + x
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_inclusion_2.cc.bak b/tests/material_model_dependencies_inclusion_2.cc.bak
new file mode 100644
index 00000000000..8f9cb601c42
--- /dev/null
+++ b/tests/material_model_dependencies_inclusion_2.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
+#include "../benchmarks/inclusion/inclusion.cc"
diff --git a/tests/material_model_dependencies_inclusion_2.prm.bak b/tests/material_model_dependencies_inclusion_2.prm.bak
new file mode 100644
index 00000000000..05684012fd3
--- /dev/null
+++ b/tests/material_model_dependencies_inclusion_2.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = InclusionMaterial
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_latent_heat.cc.bak b/tests/material_model_dependencies_latent_heat.cc.bak
new file mode 100644
index 00000000000..d46e5b4ae6a
--- /dev/null
+++ b/tests/material_model_dependencies_latent_heat.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_latent_heat.prm.bak b/tests/material_model_dependencies_latent_heat.prm.bak
new file mode 100644
index 00000000000..9a109540bf3
--- /dev/null
+++ b/tests/material_model_dependencies_latent_heat.prm.bak
@@ -0,0 +1,104 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = latent heat
+
+  subsection Latent heat
+    # The change of density across the phase transition. Together with the
+    # Clapeyron slope, this is what determines the entropy change.
+    set Phase transition density jumps                 = 115.6
+    set Corresponding phase for density jump           = 0
+
+    # If the temperature is equal to the phase transition temperature, the
+    # phase transition will occur at the phase transition depth. However,
+    # if the temperature deviates from this value, the Clapeyron slope
+    # determines how much the pressure (and depth) of the phase boundary
+    # changes. Here, the phase transition will be in the middle of the box
+    # for T=T1.
+    set Phase transition depths                        = 500000
+    set Phase transition temperatures                  = 1000
+    set Phase transition Clapeyron slopes              = 1e7
+
+    # We set the width of the phase transition to 5 km. You may want to
+    # change this parameter to see how latent heating depends on the width
+    # of the phase transition.
+    set Phase transition widths                        = 5000
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 2.38
+
+    # We set the thermal expansion and the compressibility to zero, so that
+    # all temperature (and density) changes are caused by advection, diffusion
+    # and latent heating.
+    set Thermal expansion coefficient                  = 0.0
+    set Compressibility                                = 0.0
+
+    # Viscosity is constant.
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 8.44e21
+    set Viscosity prefactors                           = 1.0, 1.0
+    set Composition viscosity prefactor                = 1.0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_latent_heat_melt.cc.bak b/tests/material_model_dependencies_latent_heat_melt.cc.bak
new file mode 100644
index 00000000000..d46e5b4ae6a
--- /dev/null
+++ b/tests/material_model_dependencies_latent_heat_melt.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_latent_heat_melt.prm.bak b/tests/material_model_dependencies_latent_heat_melt.prm.bak
new file mode 100644
index 00000000000..9be8b097444
--- /dev/null
+++ b/tests/material_model_dependencies_latent_heat_melt.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = latent heat melt
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_morency_doin.cc.bak b/tests/material_model_dependencies_morency_doin.cc.bak
new file mode 100644
index 00000000000..ed70eab2cff
--- /dev/null
+++ b/tests/material_model_dependencies_morency_doin.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
+#include "../cookbooks/morency_doin_2004/morency_doin.h"
+#include "../cookbooks/morency_doin_2004/morency_doin.cc"
diff --git a/tests/material_model_dependencies_morency_doin.prm.bak b/tests/material_model_dependencies_morency_doin.prm.bak
new file mode 100644
index 00000000000..d63aef97e65
--- /dev/null
+++ b/tests/material_model_dependencies_morency_doin.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = Morency and Doin
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_multicomponent.cc.bak b/tests/material_model_dependencies_multicomponent.cc.bak
new file mode 100644
index 00000000000..d46e5b4ae6a
--- /dev/null
+++ b/tests/material_model_dependencies_multicomponent.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_multicomponent.prm.bak b/tests/material_model_dependencies_multicomponent.prm.bak
new file mode 100644
index 00000000000..62c8f1eadeb
--- /dev/null
+++ b/tests/material_model_dependencies_multicomponent.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = multicomponent
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_shear_thinning.cc.bak b/tests/material_model_dependencies_shear_thinning.cc.bak
new file mode 100644
index 00000000000..2185180aca7
--- /dev/null
+++ b/tests/material_model_dependencies_shear_thinning.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
+#include "shear_thinning.cc"
diff --git a/tests/material_model_dependencies_shear_thinning.prm.bak b/tests/material_model_dependencies_shear_thinning.prm.bak
new file mode 100644
index 00000000000..4504e5cccac
--- /dev/null
+++ b/tests/material_model_dependencies_shear_thinning.prm.bak
@@ -0,0 +1,76 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = shear thinning
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_simple.cc.bak b/tests/material_model_dependencies_simple.cc.bak
new file mode 100644
index 00000000000..d46e5b4ae6a
--- /dev/null
+++ b/tests/material_model_dependencies_simple.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_simple.prm.bak b/tests/material_model_dependencies_simple.prm.bak
new file mode 100644
index 00000000000..435f180cf11
--- /dev/null
+++ b/tests/material_model_dependencies_simple.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_simple_compressible.cc.bak b/tests/material_model_dependencies_simple_compressible.cc.bak
new file mode 100644
index 00000000000..d46e5b4ae6a
--- /dev/null
+++ b/tests/material_model_dependencies_simple_compressible.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_simple_compressible.prm.bak b/tests/material_model_dependencies_simple_compressible.prm.bak
new file mode 100644
index 00000000000..4ce17012d8b
--- /dev/null
+++ b/tests/material_model_dependencies_simple_compressible.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = simple compressible
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_simpler.cc.bak b/tests/material_model_dependencies_simpler.cc.bak
new file mode 100644
index 00000000000..d46e5b4ae6a
--- /dev/null
+++ b/tests/material_model_dependencies_simpler.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_simpler.prm.bak b/tests/material_model_dependencies_simpler.prm.bak
new file mode 100644
index 00000000000..4de064b0472
--- /dev/null
+++ b/tests/material_model_dependencies_simpler.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = simpler
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_solcx.cc.bak b/tests/material_model_dependencies_solcx.cc.bak
new file mode 100644
index 00000000000..feab596941d
--- /dev/null
+++ b/tests/material_model_dependencies_solcx.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/material_model_dependencies_solcx.prm.bak b/tests/material_model_dependencies_solcx.prm.bak
new file mode 100644
index 00000000000..38790f176ce
--- /dev/null
+++ b/tests/material_model_dependencies_solcx.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_solkz.cc.bak b/tests/material_model_dependencies_solkz.cc.bak
new file mode 100644
index 00000000000..2bd3f8ef1f0
--- /dev/null
+++ b/tests/material_model_dependencies_solkz.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/material_model_dependencies_solkz.prm.bak b/tests/material_model_dependencies_solkz.prm.bak
new file mode 100644
index 00000000000..008105c3983
--- /dev/null
+++ b/tests/material_model_dependencies_solkz.prm.bak
@@ -0,0 +1,67 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_steinberger.cc.bak b/tests/material_model_dependencies_steinberger.cc.bak
new file mode 100644
index 00000000000..d46e5b4ae6a
--- /dev/null
+++ b/tests/material_model_dependencies_steinberger.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_steinberger.prm.bak b/tests/material_model_dependencies_steinberger.prm.bak
new file mode 100644
index 00000000000..dc1126d1a9b
--- /dev/null
+++ b/tests/material_model_dependencies_steinberger.prm.bak
@@ -0,0 +1,85 @@
+#############################
+# Otherwise use a mixture of the setup of SolCX and steinberger-viscosity
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = testdata.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_model_dependencies_tangurnis.cc.bak b/tests/material_model_dependencies_tangurnis.cc.bak
new file mode 100644
index 00000000000..0b2bc1198d0
--- /dev/null
+++ b/tests/material_model_dependencies_tangurnis.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "material_model_dependencies.cc"
+#include "tangurnis.cc"
diff --git a/tests/material_model_dependencies_tangurnis.prm.bak b/tests/material_model_dependencies_tangurnis.prm.bak
new file mode 100644
index 00000000000..b405aff9383
--- /dev/null
+++ b/tests/material_model_dependencies_tangurnis.prm.bak
@@ -0,0 +1,86 @@
+#############################
+# Otherwise use the setup of SolCX
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# Evaluate the nonlinear dependencies of the material model used here
+
+subsection Material model
+  set Model name = Tan Gurnis
+
+  subsection Tan Gurnis model
+    set Di                            = 0.5
+    set gamma                         = 1
+    set a                             = 0
+    set wavenumber                    = 1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = material model dependencies
+end
+
+subsection Formulation
+  set Formulation = anelastic liquid approximation
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Heating model
+  set List of model names = shear heating, adiabatic heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
diff --git a/tests/material_statistics.prm.bak b/tests/material_statistics.prm.bak
new file mode 100644
index 00000000000..171fbca9ab1
--- /dev/null
+++ b/tests/material_statistics.prm.bak
@@ -0,0 +1,80 @@
+# This is a benchmark to check that the 'Material statistics'
+# postprocessor works correctly. It creates a model with lateral
+# flow. The density in the model is constant and the volume is known,
+# so it is easy to compute the expected output. Over time material
+# with a different density flows in until it fills the whole domain.
+
+set Dimension = 2
+set End time                               = 1e8
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Y extent = 100000
+    set X extent = 100000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = left
+  set List of model names = function
+
+  subsection Function
+    set Function expression = (t<1e7) ? 1600 + (t / 1e7) * 1000 : 2600
+  end
+end
+
+# To guarantee a steady rightward flow, we fix the velocity
+# at the left and right, and set it to free slip on the top and bottom.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left:function, right:function
+  set Tangential velocity boundary indicators = bottom,top
+
+  subsection Function
+    set Function expression = 1e-2;0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3300
+    set Reference temperature = 1600
+    set Thermal expansion coefficient = 1e-4
+    set Thermal conductivity = 0.0
+    set Viscosity = 1e21
+
+    # This was computed to correspond to a viscosity decrease of one order
+    # of magnitude over a temperature increase of 1000 K for a reference
+    # viscosity of 1e21 Pas and a reference temperature of 1600 K.
+    set Thermal viscosity exponent = 3.684136149
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = material statistics
+end
diff --git a/tests/matrix_nonzeros_1.prm.bak b/tests/matrix_nonzeros_1.prm.bak
new file mode 100644
index 00000000000..3241fd0830a
--- /dev/null
+++ b/tests/matrix_nonzeros_1.prm.bak
@@ -0,0 +1,85 @@
+# Tests whether the 'matrix statistics' postprocessor outputs correctly on a
+# minimal problem with conforming Stokes and composition, and dG temperature FE
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.3
+    set Y extent = 2.2
+    set Z extent = 1.1
+    set Box origin X coordinate = -1.9
+    set Box origin Y coordinate = 2.5
+    set Box origin Z coordinate = 3.1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Discretization
+  set Use discontinuous temperature discretization = true
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = matrix statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/matrix_nonzeros_2.prm.bak b/tests/matrix_nonzeros_2.prm.bak
new file mode 100644
index 00000000000..8011414d377
--- /dev/null
+++ b/tests/matrix_nonzeros_2.prm.bak
@@ -0,0 +1,100 @@
+# Do matrix_nonzeros output for varying advection methods to ensure correct behavior
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.3
+    set Y extent = 2.2
+    set Z extent = 1.1
+    set Box origin X coordinate = -1.9
+    set Box origin Y coordinate = 2.5
+    set Box origin Z coordinate = 3.1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = adv_field, adv_particle
+  set Compositional field methods = field, particles
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0; 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = matrix statistics, particles
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+  set Interpolation scheme = cell average
+  set Update ghost particles = true
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 100
+    end
+  end
+end
diff --git a/tests/matrix_nonzeros_3.prm.bak b/tests/matrix_nonzeros_3.prm.bak
new file mode 100644
index 00000000000..92a56f04d8e
--- /dev/null
+++ b/tests/matrix_nonzeros_3.prm.bak
@@ -0,0 +1,106 @@
+# Do matrix_nonzeros output for varying advection methods assuming
+# discontinuous composition to ensure correct behavior
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.3
+    set Y extent = 2.2
+    set Z extent = 1.1
+    set Box origin X coordinate = -1.9
+    set Box origin Y coordinate = 2.5
+    set Box origin Z coordinate = 3.1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = adv_field, adv_particle
+  set Compositional field methods = field, particles
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0; 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Discretization
+  set Use discontinuous temperature discretization = false
+  set Use discontinuous composition discretization = true
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = matrix statistics, particles
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+  set Interpolation scheme = cell average
+  set Update ghost particles = true
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 100
+    end
+  end
+end
diff --git a/tests/matrix_nonzeros_4.prm.bak b/tests/matrix_nonzeros_4.prm.bak
new file mode 100644
index 00000000000..9f528be131b
--- /dev/null
+++ b/tests/matrix_nonzeros_4.prm.bak
@@ -0,0 +1,114 @@
+# Based on composition_reaction.prm with two compositional
+# fields to test re-use of the compositional matrix
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.3
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+# Let us here choose again a box domain of size 2x1
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+# We then set the temperature to one at the bottom and zero
+# at the top:
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0
+  end
+end
+
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+    set Density differential for compositional field 1 = -5
+    set Density differential for compositional field 2 = 5
+    set Reaction depth                = 0.2
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, memory statistics, matrix statistics
+
+  subsection Memory statistics
+    set Output peak virtual memory (VmPeak) = false
+  end
+end
diff --git a/tests/matrix_nonzeros_5.prm.bak b/tests/matrix_nonzeros_5.prm.bak
new file mode 100644
index 00000000000..b9d8d33eb9e
--- /dev/null
+++ b/tests/matrix_nonzeros_5.prm.bak
@@ -0,0 +1,110 @@
+# like matrix_nonzeros_4 but with different compositional field methods
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.3
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+# Let us here choose again a box domain of size 2x1
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+# We then set the temperature to one at the bottom and zero
+# at the top:
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Compositional field methods = static, field, field
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0;1
+  end
+end
+
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+    set Density differential for compositional field 1 = -5
+    set Density differential for compositional field 2 = 5
+    set Reaction depth                = 0.2
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, memory statistics, matrix statistics
+
+  subsection Memory statistics
+    set Output peak virtual memory (VmPeak) = false
+  end
+end
diff --git a/tests/matrix_nonzeros_6.prm.bak b/tests/matrix_nonzeros_6.prm.bak
new file mode 100644
index 00000000000..4b41fdd9712
--- /dev/null
+++ b/tests/matrix_nonzeros_6.prm.bak
@@ -0,0 +1,111 @@
+# like matrix_nonzeros_5 but with different solver schemes
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.3
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, single Stokes
+
+############### Parameters describing the model
+# Let us here choose again a box domain of size 2x1
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+# We then set the temperature to one at the bottom and zero
+# at the top:
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Compositional field methods = static, field, field
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0;1
+  end
+end
+
+subsection Material model
+  set Model name = composition reaction
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+    set Density differential for compositional field 1 = -5
+    set Density differential for compositional field 2 = 5
+    set Reaction depth                = 0.2
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, memory statistics, matrix statistics
+
+  subsection Memory statistics
+    set Output peak virtual memory (VmPeak) = false
+  end
+end
diff --git a/tests/matrix_nonzeros_7.prm.bak b/tests/matrix_nonzeros_7.prm.bak
new file mode 100644
index 00000000000..4eff50e42a9
--- /dev/null
+++ b/tests/matrix_nonzeros_7.prm.bak
@@ -0,0 +1,117 @@
+# like matrix_nonzeros_4 but with matrix free multigrid
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.3
+set Use years in output instead of seconds = false
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+############### Parameters describing the model
+# Let us here choose again a box domain of size 2x1
+# where we fix the temperature at the bottom and top,
+# allow free slip along the bottom, left and right,
+# and prescribe the velocity along the top using the
+# `function' description.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+# We then set the temperature to one at the bottom and zero
+# at the top:
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Compositional field methods = static, field, field
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient. The default
+# strength for gravity is one. The material model is the
+# same as before.
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0;1
+  end
+end
+
+subsection Material model
+  set Model name = composition reaction
+  set Material averaging = harmonic average
+
+  subsection Composition reaction model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+    set Density differential for compositional field 1 = -5
+    set Density differential for compositional field 2 = 5
+    set Reaction depth                = 0.2
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, memory statistics, matrix statistics
+
+  subsection Memory statistics
+    set Output peak virtual memory (VmPeak) = false
+  end
+end
diff --git a/tests/max_timesteps_btwn_output.prm.bak b/tests/max_timesteps_btwn_output.prm.bak
new file mode 100644
index 00000000000..c0da88af5db
--- /dev/null
+++ b/tests/max_timesteps_btwn_output.prm.bak
@@ -0,0 +1,168 @@
+# This is a test to check if output files are correctly written if the maximum number of steps
+# between outputs is smaller than the required one (while the dt between output files is large)
+# Based on the cookbook for convection in a 2d box.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 300.
+set Output directory                       = output
+
+# Then there are variables that describe the tolerance of
+# the linear solver as well as how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above. (As will be seen
+# in the next section, the actual temperature prescribed here
+# at the left and right does not matter.)
+# We then also have to prescribe several other parts of the model such as
+# which boundaries actually carry a prescribed boundary temperature, whereas
+# all other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.e5  # = Ra
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.1
+    set Time steps between graphical output = 5
+    set Number of grouped files = 1
+  end
+end
+
+subsection Termination criteria
+  set End step                  = 10
+  set Termination criteria      = end step
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/maximum_horizontal_compressive_stress_case_one.prm.bak b/tests/maximum_horizontal_compressive_stress_case_one.prm.bak
new file mode 100644
index 00000000000..e859badaf7f
--- /dev/null
+++ b/tests/maximum_horizontal_compressive_stress_case_one.prm.bak
@@ -0,0 +1,108 @@
+############### Global parameters
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set CFL number                             = .5
+set Output directory                       = output-shear_box_3D
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Pressure normalization                 = no
+set Timing output frequency                = 1
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  =  1
+    set Z extent  =  1
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density = 0
+    set Viscosity = 0.5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators =
+  set Prescribed velocity boundary indicators = front z:function, back z:function, left z:function, right z:function, top:function, bottom:function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = cm=0.01, year=1
+    set Function expression =  (0.5-z)*2 ; 0.5-z ; z
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.9
+  set Strategy                           = strain rate
+  set Coarsening fraction                = 0.05
+  set Minimum refinement level           = 2
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography, pressure statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, maximum horizontal compressive stress
+    set Time between graphical output = 0
+    set Interpolate output = true
+    set Output format = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-9
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/maximum_horizontal_compressive_stress_case_two.prm.bak b/tests/maximum_horizontal_compressive_stress_case_two.prm.bak
new file mode 100644
index 00000000000..21e9854f1a2
--- /dev/null
+++ b/tests/maximum_horizontal_compressive_stress_case_two.prm.bak
@@ -0,0 +1,110 @@
+############### Global parameters
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set CFL number                             = .5
+set Output directory                       = output-punch_box_3D
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Pressure normalization                 = no
+set Timing output frequency                = 1
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  =  1
+    set Z extent  =  1
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+# The velocity along the top boundary models a spreading
+# center that is moving left and right:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left,right
+  set Prescribed velocity boundary indicators = front x:function, back x:function, top z:function, bottom z:function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = cm=0.01, year=1
+    set Function expression =  if(y > 0.5,-1,1) ; 0 ; if(z<0.5,-1,1)
+  end
+end
+
+subsection Boundary traction model
+  #set Prescribed traction boundary indicators = front:initial lithostatic pressure, back:initial lithostatic pressure,left:initial lithostatic pressure, right:initial lithostatic pressure
+  subsection Initial lithostatic pressure
+    set Representative point = 0,0,0
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.9
+  set Strategy                           = strain rate
+  set Coarsening fraction                = 0.05
+  set Minimum refinement level           = 2
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography, pressure statistics
+
+  subsection Visualization
+    set List of output variables = density, viscosity, maximum horizontal compressive stress
+    set Time between graphical output = 0
+    set Interpolate output = true
+    set Output format = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-9
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/maximum_refinement_function.prm.bak b/tests/maximum_refinement_function.prm.bak
new file mode 100644
index 00000000000..0fbe53705d1
--- /dev/null
+++ b/tests/maximum_refinement_function.prm.bak
@@ -0,0 +1,154 @@
+# Listing of Parameters
+# ---------------------
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+
+# MPI: 2
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.33
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Additional refinement times              =
+  set Coarsening fraction                      = 0.2
+  set Refinement fraction                      = 0.5
+  set Initial adaptive refinement              = 5
+  set Initial global refinement                = 3
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = max
+  set Run postprocessors on initial refinement = true
+  set Strategy                                 = thermal energy density, maximum refinement function
+  set Time steps between mesh refinement       = 1
+
+  subsection Maximum refinement function
+    set Function constants  =
+
+    # This is in fact the default value
+    set Coordinate system = depth
+
+    # The following lines are equal to set the line:
+    # set Function expression = 4 + 2*sin(x*pi/250000)
+    # which implies:
+    # set Variable names = x,y
+    # because that is the default value for Variable names.
+    # To illustrate the possibility to rename function variables
+    # in your favourite naming scheme we use the following:
+    set Variable names = depth,not_used1
+    set Function expression = 6 + 2*sin(depth*2*pi/250000)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/maximum_refinement_function_cartesian.prm.bak b/tests/maximum_refinement_function_cartesian.prm.bak
new file mode 100644
index 00000000000..49f90a417b2
--- /dev/null
+++ b/tests/maximum_refinement_function_cartesian.prm.bak
@@ -0,0 +1,144 @@
+# Listing of Parameters
+# ---------------------
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+
+# MPI: 2
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.33
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Additional refinement times              =
+  set Coarsening fraction                      = 0.2
+  set Refinement fraction                      = 0.5
+  set Initial adaptive refinement              = 5
+  set Initial global refinement                = 3
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = max
+  set Run postprocessors on initial refinement = true
+  set Strategy                                 = thermal energy density, maximum refinement function
+  set Time steps between mesh refinement       = 1
+
+  subsection Maximum refinement function
+    set Coordinate system      = cartesian
+    set Function constants     =
+    set Function expression    = 6 + 2*sin(x*2*pi/250000)*sin(y*2*pi/250000)
+    set Variable names         = x,y
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/maximum_refinement_function_spherical.prm.bak b/tests/maximum_refinement_function_spherical.prm.bak
new file mode 100644
index 00000000000..8cacf09f1e8
--- /dev/null
+++ b/tests/maximum_refinement_function_spherical.prm.bak
@@ -0,0 +1,136 @@
+# Copy of the minimum_refinement_function_cartesian test, adjusted to
+# spherical geometry and refinement coordinates. The minimum refinement
+# formula in this test uses spherical coordinates and refines exactly
+# those regions of the model that are assigned the highest temperatures
+# by the initial condition 'harmonic perturbation'.
+
+# MPI: 2
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.33
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 250000
+    set Outer radius  = 500000
+    set Opening angle = 90
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Additional refinement times              =
+  set Coarsening fraction                      = 0.2
+  set Refinement fraction                      = 0.5
+  set Initial adaptive refinement              = 4
+  set Initial global refinement                = 3
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = max
+  set Run postprocessors on initial refinement = true
+  set Strategy                                 = thermal energy density, maximum refinement function
+  set Time steps between mesh refinement       = 1
+
+  subsection Maximum refinement function
+    set Coordinate system      = spherical
+    set Function constants     =
+    set Function expression    = 5 + 2*sin((r+250000)*2*pi/250000)*sin(12*phi)
+    set Variable names         = r,phi
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/maxtimestep.prm.bak b/tests/maxtimestep.prm.bak
new file mode 100644
index 00000000000..4678231d214
--- /dev/null
+++ b/tests/maxtimestep.prm.bak
@@ -0,0 +1,64 @@
+# a test that verifies that setting an end time earlier than when
+# we achieve steady state still terminates the program at the right
+# time
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Maximum time step                      = 42
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+  set End step                  = 5
+end
diff --git a/tests/melt_and_traction.prm.bak b/tests/melt_and_traction.prm.bak
new file mode 100644
index 00000000000..888f6cb53af
--- /dev/null
+++ b/tests/melt_and_traction.prm.bak
@@ -0,0 +1,276 @@
+# This is a test to see if traction boundary conditions work in models
+# with melt migration.
+# At the right and bottom boundary, the lithostatic pressure is applied,
+# so both the solid and the melt velocity should be approximately zero.
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 1600
+set Maximum time step                      = 1e6
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 20
+set Nonlinear solver tolerance             = 1e-7
+
+# In addition, melting and freezing normally happens on a much faster
+# time scale than the flow of melt, so we want to decouple the advection
+# of melt (and temperature) and the melting process itself. To do that,
+# we use the operator splitting scheme, and define that for every
+# advection time step, we want to do at least 50 reaction time step,
+# and in addition, we limit the maximum reaction time step size to
+# 500,000 years.
+set Use operator splitting                     = true
+
+# The end time of the simulation. We only do one time step.
+set End time                               = 1e5
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 100
+  end
+end
+
+# We apply the lithostatic pressure at the bottom and the right side.
+
+##################### Boundary conditions ########################
+
+# As boundary conditions for the temperature, we just use the
+# initial conditions again. This temperature is applied as a prescribed
+# temperature at the top and bottom boundary, as specified above.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3700
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function
+  set Tangential velocity boundary indicators = left
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0; 0
+  end
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom y:initial lithostatic pressure
+
+  subsection Initial lithostatic pressure
+    set Number of integration points = 10000
+    set Representative point         = 300000,300000
+  end
+end
+
+subsection Melt settings
+  # In addition, we now also specify in the model settings that we want to
+  # run a model with melt transport.
+  set Include melt transport                  = true
+end
+
+##################### Settings for melt transport ########################
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.5
+    set cR    = 1
+  end
+end
+
+##################### Initial temperature model ########################
+
+# We choose an adiabatic temperature profile as initial condition.
+subsection Initial temperature model
+  set List of model names = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 0
+    set Age top boundary layer    = 5e7
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+end
+
+# Now that our model uses compositional fields, we also need initial
+# conditions for the composition.
+# We use the function plugin to set both fields to zero at the beginning
+# of the model run.
+subsection Initial composition model
+  set List of model names = function, porosity
+
+  subsection Function
+    set Function expression = 0; 0
+    set Variable names      = x,y
+  end
+end
+
+# We again choose the initial composition as boundary condition
+# for all compositional fields.
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Models with melt transport also need an additional boundary condition.
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+##################### Model geometry ########################
+
+# The model geometry is a square with a dimension of 300 km.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 300000
+    set Y extent = 300000
+  end
+end
+
+################ Gravity and material properties ##################
+
+# The model has a constant gravity.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We use the melt global material model, which is one of the
+# material models that works with melt transport, as it also
+# specifies the material properties needed for melt migration,
+# such as the permeability, the melt density and the melt
+# viscosity.
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    # First we describe the parameters for the solid, in the same way
+    # we did in the model without melt transport
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Thermal expansion coefficient     = 2e-5
+    set Reference shear viscosity         = 5e21
+    set Thermal viscosity exponent        = 7
+    set Reference temperature             = 1600
+
+    # The melt usually has a different (lower) density than the solid.
+    set Reference melt density            = 3400
+
+    # The permeability describes how well the pores of a porous material
+    # are connected (and hence how fast melt can flow through the rock).
+    # It is computed as the product of the reference value given here
+    # and the porosity cubed. This means that the lower the porosity is
+    # the more difficult it is for the melt to flow.
+    set Reference permeability            = 1e-8
+
+    # The bulk viscosity describes the resistance of the rock to dilation
+    # and compaction. Melt can only flow into a region that had no melt
+    # before if the matrix of the solid rock expands, so this parameter
+    # also limits how fast melt can flow upwards.
+    # The bulk viscosity is computed as the reference value given here times
+    # a term that scales with one over the porosity. This means that for zero
+    # porosity, the rock can not dilate/compact any more, which is the same
+    # behavior that we have for solid mantle convection.
+    set Reference bulk viscosity          = 1e19
+
+    # In dependence of how much melt is present, we also weaken the shear
+    # viscosity: The more melt is present, the weaker the rock gets.
+    # This scaling is exponential, following the relation
+    # viscosity ~ exp(-alpha * phi),
+    # where alpha is the parameter given here, and phi is the porosity.
+    set Exponential melt weakening factor = 10
+
+    # In the same way the shear viscosity is reduced with increasing temperature,
+    # we also prescribe the temperature-dependence of the bulk viscosity.
+    set Thermal bulk viscosity exponent   = 7
+
+    # Finally, we prescribe the viscosity of the melt, which is used in Darcy's
+    # law. The lower this viscosity, the faster melt can flow.
+    set Reference melt viscosity          = 1
+
+    # change the density contrast of depleted material (in kg/m^3)
+    set Depletion density change          = -200.0
+
+    # How much melt has been generated and subsequently extracted from a particular
+    # volume of rock (how 'depleted' that volume of rock is) usually changes the
+    # solidus. The more the material has been molten already, the less melt will be
+    # generated afterwards for the same pressure and temperature conditions. We
+    # model this using a simplified, linear relationship, saying that to melt 100%
+    # of the rock the temperature has to be 200 K higher than to melt it initially.
+    set Depletion solidus change          = 200
+    set Melting time scale for operator splitting = 1e100
+    set Include melting and freezing      = false
+  end
+end
+
+##################### Mesh refinement #########################
+
+# For the model with melt migration, we use adaptive refinement.
+# We make use of two different refinement criteria: we set a minimum of 4 global
+# refinements everywhere in the model (which is the same resolution as for the
+# model without melt), and we refine in regions where melt is present, to be
+# precise, everywhere where the porosity is bigger than 1e-4.
+# We adapt the mesh every 5 time steps.
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Time steps between mesh refinement       = 0
+end
+
+# As the model is compressible and has an adiabatic temperature profile, we include
+# adiabatic heating in the list of heating models.
+# To make this model as simple as possible, we do not include shear heating (although
+# usually, adiabatic heating and shear heating should always be used together).
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+##################### Postprocessing ########################
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, mass flux statistics
+  set Run postprocessors on nonlinear iterations = true
+
+  # For the model with melt migration, also add a visualization
+  # postprocessor that computes the material properties relevant
+  # to migration (permeability, viscosity of the melt, etc.).
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt material properties, nonadiabatic pressure
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Interpolate output            = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
diff --git a/tests/melt_boukare_EOS.prm b/tests/melt_boukare_EOS.prm
index a66742a46dd..fc41a7d9818 100644
--- a/tests/melt_boukare_EOS.prm
+++ b/tests/melt_boukare_EOS.prm
@@ -89,7 +89,7 @@ end
 subsection Boundary composition model
   set Allow fixed composition on outflow boundaries = false
   set Fixed composition boundary indicators   = top
-  set Model name = initial composition
+  set List of model names = initial composition
 end
 
 subsection Heating model
diff --git a/tests/melt_boukare_EOS.prm.bak b/tests/melt_boukare_EOS.prm.bak
new file mode 100644
index 00000000000..a66742a46dd
--- /dev/null
+++ b/tests/melt_boukare_EOS.prm.bak
@@ -0,0 +1,157 @@
+# Test for the equation of state in the boukare material model.
+# The test has only 4 cells and a constant temperature and pressure.
+# It checks if the material properties are computed correctly for
+# the iron-bearing endmember of the melt composition.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Maximum time step                      = 1e7
+set Output directory                       = test
+set Nonlinear solver scheme                = first timestep only, single Stokes
+set Max nonlinear iterations               = 5
+set Pressure normalization                 = surface
+set Surface pressure                       = 110.e9
+set Adiabatic surface temperature          = 4000
+set Use conduction timestep                = true
+set Use operator splitting = true
+
+subsection Melt settings
+  set Include melt transport = true
+end
+
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction solver type                   = fixed step
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = molar_Fe_in_solid, molar_Fe_in_melt, porosity
+end
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500000
+    set Y extent = 500000
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 4000
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0; 1; 0.9999999 #fe_mantle_endmember
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, top, bottom
+  set Prescribed velocity boundary indicators =
+  set Tangential velocity boundary indicators =
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Maximal temperature = 3000
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+  set Fixed composition boundary indicators   = top
+  set Model name = initial composition
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = melt boukare
+
+  subsection Melt boukare
+    set Thermal conductivity          = 8.5
+    set Reference shear viscosity     = 5e22
+    set Thermal viscosity exponent    = 0
+    set Include melting and freezing  = false
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set List of output variables = material properties, melt material properties
+    set Output format = gnuplot
+    set Interpolate output = false
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,compressibility
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density
+    end
+  end
+end
diff --git a/tests/melt_boukare_averaging.prm b/tests/melt_boukare_averaging.prm
index 6f88da030c5..35b70658038 100644
--- a/tests/melt_boukare_averaging.prm
+++ b/tests/melt_boukare_averaging.prm
@@ -89,7 +89,7 @@ end
 subsection Boundary composition model
   set Allow fixed composition on outflow boundaries = false
   set Fixed composition boundary indicators   = top
-  set Model name = initial composition
+  set List of model names = initial composition
 end
 
 subsection Heating model
diff --git a/tests/melt_boukare_averaging.prm.bak b/tests/melt_boukare_averaging.prm.bak
new file mode 100644
index 00000000000..6f88da030c5
--- /dev/null
+++ b/tests/melt_boukare_averaging.prm.bak
@@ -0,0 +1,157 @@
+# Test for the equation of state in the boukare material model
+# The test has only 4 cells and a constant temperature and pressure.
+# It checks if the material properties are computed correctly for
+# a mixture of melt and solid with (20% porosity).
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Maximum time step                      = 1e7
+set Output directory                       = test
+set Nonlinear solver scheme                = first timestep only, single Stokes
+set Max nonlinear iterations               = 5
+set Pressure normalization                 = surface
+set Surface pressure                       = 100.e9
+set Adiabatic surface temperature          = 2000
+set Use conduction timestep                = true
+set Use operator splitting                 = true
+
+subsection Melt settings
+  set Include melt transport                 = true
+end
+
+subsection Solver parameters
+  subsection Operator splitting parameters
+    set Reaction solver type                   = fixed step
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = molar_Fe_in_solid, molar_Fe_in_melt, porosity
+end
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500000
+    set Y extent = 500000
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 2000
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.41; 0.43; 0.2
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, top, bottom
+  set Prescribed velocity boundary indicators =
+  set Tangential velocity boundary indicators =
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Maximal temperature = 2000
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+  set Fixed composition boundary indicators   = top
+  set Model name = initial composition
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = melt boukare
+
+  subsection Melt boukare
+    set Thermal conductivity          = 8.5
+    set Reference shear viscosity     = 5e22
+    set Thermal viscosity exponent    = 0
+    set Include melting and freezing  = false
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set List of output variables = material properties, melt material properties
+    set Output format = gnuplot
+    set Interpolate output = false
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,compressibility
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, fluid density gradient
+    end
+  end
+end
diff --git a/tests/melt_boundary_heat_flux.cc.bak b/tests/melt_boundary_heat_flux.cc.bak
new file mode 100644
index 00000000000..41a9c23ffdf
--- /dev/null
+++ b/tests/melt_boundary_heat_flux.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "rising_melt_blob.cc"
diff --git a/tests/melt_boundary_heat_flux.prm.bak b/tests/melt_boundary_heat_flux.prm.bak
new file mode 100644
index 00000000000..af1abb1c260
--- /dev/null
+++ b/tests/melt_boundary_heat_flux.prm.bak
@@ -0,0 +1,127 @@
+#########################################################
+# This is a test to see if the heat flux boundary
+# conditions work together with melt migration.
+
+############### Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 5000
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 50
+set CFL number                             = 0.2
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+############### Parameters describing the model
+# Let us here choose again a box domain
+# where we fix the temperature at the bottom and top,
+# allow free slip along the boundaries
+# and include melt migration.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 200000
+    set Y extent = 100000
+    set X repetitions = 2
+  end
+end
+
+subsection Boundary heat flux model
+  set Fixed heat flux boundary indicators   = 2, 3
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = if(z<50000, -1,1)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Melt settings
+  set Include melt transport = true
+end
+
+############### Compositional fields
+# We want to use two compositional fields, the porosity and
+# an additional field, to check if the melting rate functionality
+# has the same effect as the reaction term for the other
+# compositional fields. As the porosity field is advected by
+# a different mechanism, slight differences between the fields
+# are expected.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 1e6
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
+    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
+  end
+end
+
+subsection Material model
+  set Model name = melting rate
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/melt_compressible_advection.cc.bak b/tests/melt_compressible_advection.cc.bak
new file mode 100644
index 00000000000..d6c956a432f
--- /dev/null
+++ b/tests/melt_compressible_advection.cc.bak
@@ -0,0 +1,213 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+namespace aspect
+{
+
+  /**
+    * A material model with constant material properties except for the
+    * compaction viscosity, and non-zero melt and solid compressibilities.
+    */
+  template <int dim>
+  class CompressibleMeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual bool is_compressible () const
+      {
+        return true;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        return 1.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            out.viscosities[i] = 0.75;
+            out.thermal_expansion_coefficients[i] = 0.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 0.0;
+            out.compressibilities[i] = 1.0;
+            out.densities[i] = 1.0;
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                melt_out->compaction_viscosities[i] = 0.5 * (in.position[i][1]+0.1)*(in.position[i][1]+0.1);
+                melt_out->fluid_viscosities[i] = 1.0;
+                melt_out->permeabilities[i] = 1.0;
+                melt_out->fluid_density_gradients[i] = this->get_gravity_model().gravity_vector(in.position[i]);
+                melt_out->fluid_densities[i] = 1.0;
+              }
+          }
+      }
+  };
+
+
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(2*dim+5) {}
+      virtual void vector_value (const Point<dim>   &p,
+                                 Vector<double>   &values) const
+      {
+        double x = p(0);
+        double y = p(1);
+        double porosity = -0.1 * std::exp(-(y+0.1))/(y+0.1) + 1.0;
+
+        values[0]=0;       // x vel
+        values[1]=0;    // y vel
+        values[2]=0;  // p_f
+        values[3]=0;  // p_c
+        values[4]=0;       // x melt vel
+        values[5]=0;    // y melt vel
+        values[6]=0;  // p_s
+        values[7]=0; // T
+        values[8]=porosity; // porosity
+      }
+  };
+
+
+  /**
+    * A postprocessor that evaluates the accuracy of the solution
+    * by using the L2 norm.
+    */
+  template <int dim>
+  class CompressibleMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Generate graphical output from the current solution.
+       */
+      virtual
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics);
+  };
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  CompressibleMeltPostprocessor<dim>::execute (TableHandler &statistics)
+  {
+    RefFunction<dim> ref_func;
+    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
+
+    const unsigned int n_total_comp = this->introspection().n_components;
+    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
+    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_porosity,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_porosity);
+
+    const double poro_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
+
+    std::ostringstream os;
+    os << std::scientific << poro_l2;
+    return std::make_pair("Error porosity_L2:", os.str());
+  }
+
+  template <int dim>
+  class PressureBdry:
+
+    public BoundaryFluidPressure::Interface<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id boundary_indicator,
+        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &output
+      ) const
+      {
+        for (unsigned int q=0; q<output.size(); ++q)
+          {
+            const double y = material_model_inputs.position[q][1];
+            Tensor<1,dim> direction;
+            direction[dim-1] = 1.0;
+            output[q] = (1.1 + y)*direction * normal_vectors[q];
+          }
+      }
+
+
+
+  };
+
+}
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(CompressibleMeltMaterial,
+                                 "compressible melt material",
+                                 "")
+
+
+  ASPECT_REGISTER_POSTPROCESSOR(CompressibleMeltPostprocessor,
+                                "compressible melt error",
+                                "A postprocessor that compares the numerical solution to the analytical "
+                                "solution derived for compressible melt transport in a 2D box as described "
+                                "in the manuscript and reports the error.")
+
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+
+}
diff --git a/tests/melt_compressible_advection.prm.bak b/tests/melt_compressible_advection.prm.bak
new file mode 100644
index 00000000000..09031629585
--- /dev/null
+++ b/tests/melt_compressible_advection.prm.bak
@@ -0,0 +1,132 @@
+# A test for the correct advection of the porosity
+# field in compressible cases.
+# With a prescribed velocity of u = (0,z) and
+# density, gravity and compressibilities set to 1,
+# phi = A * exp(-z) / z + 1. The z coordinate is
+# shifted z --> z+0.1 to avoid dividing by 0.
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 5e-5
+set Max nonlinear iterations               = 15
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0.025
+set Pressure normalization                 = surface
+set Surface pressure                       = 2.0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta = 0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = true
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+  end
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;1.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = 0.0;y+0.1
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = -0.1/(exp(y+0.1) * (y+0.1)) + 1.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = compressible melt material
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, compressible melt error
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/melt_force_vector.cc.bak b/tests/melt_force_vector.cc.bak
new file mode 100644
index 00000000000..0d6b9d320d4
--- /dev/null
+++ b/tests/melt_force_vector.cc.bak
@@ -0,0 +1,338 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/melt.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+
+  template <int dim>
+  class TestMeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+
+      virtual double reference_darcy_coefficient () const
+      {
+        return 1.0;
+      }
+
+
+      virtual bool
+      viscosity_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
+      {
+        if ((dependence & MaterialModel::NonlinearDependence::compositional_fields) != MaterialModel::NonlinearDependence::none)
+          return true;
+        return false;
+      }
+
+      virtual bool
+      density_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
+      {
+        return false;
+      }
+
+
+      virtual bool
+      compressibility_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
+      {
+        return false;
+      }
+
+
+      virtual bool
+      specific_heat_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
+      {
+        return false;
+      }
+
+
+      virtual bool
+      thermal_conductivity_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
+      {
+        return false;
+      }
+
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_density () const
+      {
+        return 1.0;
+      }
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+        MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
+        *force = out.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
+
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            const double x = in.position[i](0);
+            const double z = in.position[i](1);
+            out.viscosities[i] = 1.0;
+            out.thermal_expansion_coefficients[i] = 0.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            out.densities[i] = 1.0;
+
+            out.reaction_terms[i][porosity_idx] = 0;
+//**********
+// copy and paste here
+            if (force)
+              {
+                force->rhs_u[i][0] = cos(z) - cos(x + z) + cos(x * z) * z;
+                force->rhs_u[i][1] = sin(x) - cos(x + z) + cos(x * z) * x;
+                force->rhs_p[i] = 0.4e1 * sin(x + z) - sin(x * z) * z * z - sin(x * z) * x * x;
+                force->rhs_melt_pc[i] = -0.10e2 * sin(x + z) / (0.1e1 + exp(-0.20e2 * x * x - 0.20e2 * z * z + 0.1e1));
+              }
+//***********
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+            {
+              double porosity = in.composition[i][porosity_idx];
+              // porosity = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1));
+              const double x = in.position[i](0);
+              const double z = in.position[i](1);
+              melt_out->compaction_viscosities[i] = 0.1e0 + 0.1e0 * exp(-0.20e2 * x * x - 0.20e2 * z * z + 0.1e1); // xi
+              melt_out->fluid_viscosities[i] = 1.0;
+              melt_out->permeabilities[i] = 1.0; // K_D
+              melt_out->fluid_density_gradients[i] = 0.0;
+              melt_out->fluid_densities[i] = 0.5;
+            }
+
+      }
+
+  };
+
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(2*dim+3+2) {}
+      virtual void vector_value (const Point<dim>   &p,
+                                 Vector<double>   &values) const
+      {
+        double x = p(0);
+        double z = p(1);
+//**********
+// copy and paste here (add "out.")
+        const double phi = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1));
+
+        values[0] = cos(z);                                                 //ux
+        values[1] = sin(x);                                                 //uz
+        values[2] = -0.2e1 * sin(x + z) + sin(x * z);                       //p_f
+        values[3] = sin(x + z);                                             //p_c
+        values[4] = values[0] - 1.0/phi * (-2.0 * cos(x+z) + cos(x*z)*z);   //u_f_x
+        values[5] = values[1] - 1.0/phi * (-2.0 * cos(x+z) + cos(x*z)*x);   //u_f_z
+        values[6] = values[2] + values[3] / (1.0 - phi);                    //p_s = p_f + p_c / (1-phi)
+        values[7] = 0;
+        values[8] = phi;                                                    //porosity
+//**********
+      }
+  };
+
+
+
+  /**
+    * A postprocessor that evaluates the accuracy of the solution
+    * by using the L2 norm.
+    */
+  template <int dim>
+  class ConvergenceMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Generate graphical output from the current solution.
+       */
+      virtual
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics);
+
+  };
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  ConvergenceMeltPostprocessor<dim>::execute (TableHandler &statistics)
+  {
+    RefFunction<dim> ref_func;
+    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
+
+    const unsigned int n_total_comp = this->introspection().n_components;
+
+    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
+
+    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                        n_total_comp);
+    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
+    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+
+                                                                                dim),
+                                          n_total_comp);
+    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_f);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_c,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_c);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_porosity,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_porosity);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u_f);
+
+    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
+    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
+    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
+    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
+    const double phi_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
+    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
+
+
+    std::ostringstream os;
+    os << std::scientific
+       << " h = " << this->get_triangulation().begin_active()->diameter()
+       << " ndofs= " << this->get_solution().size()
+       << " u_L2= " << u_l2
+       << " p_L2= "  << p_l2
+       << " p_f_L2= " << p_f_l2
+       << " p_c_L2= " << p_c_l2
+       << " phi_L2= " << phi_l2
+       << " u_f_L2= " << u_f_l2
+       ;
+
+    return std::make_pair("Errors", os.str());
+  }
+
+
+  template <int dim>
+  class PressureBdry:
+    public BoundaryFluidPressure::Interface<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const dealii::types::boundary_id,
+        const typename MaterialModel::Interface<dim>::MaterialModelInputs &material_model_inputs,
+        const typename MaterialModel::Interface<dim>::MaterialModelOutputs &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &output
+      ) const
+      {
+        for (unsigned int q=0; q<output.size(); ++q)
+          {
+            const double x = material_model_inputs.position[q][0];
+            const double z = material_model_inputs.position[q][1];
+            Tensor<1,dim> gradient;
+//**********
+// copy and paste here (add "out.")
+            gradient[0] = -0.2e1 * cos(x + z) + cos(x * z) * z;
+            gradient[1] = -0.2e1 * cos(x + z) + cos(x * z) * x;
+//**********
+            output[q] = gradient * normal_vectors[q];
+          }
+      }
+
+
+
+  };
+
+}
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_MATERIAL_MODEL(TestMeltMaterial,
+                                 "test melt material",
+                                 "")
+
+  ASPECT_REGISTER_POSTPROCESSOR(ConvergenceMeltPostprocessor,
+                                "melt error calculation",
+                                "A postprocessor that compares the numerical solution to the analytical solution")
+
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+
+}
diff --git a/tests/melt_force_vector.prm.bak b/tests/melt_force_vector.prm.bak
new file mode 100644
index 00000000000..ad69f066589
--- /dev/null
+++ b/tests/melt_force_vector.prm.bak
@@ -0,0 +1,160 @@
+# A simple reference solution with RHS force vector with incompressible
+# melt transport
+
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Max nonlinear iterations               = 50
+set Nonlinear solver tolerance             = 1e-10 #1e-10
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = volume
+set Surface pressure                       = 0#0.2746026940#3.992884522
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Refinement fraction                      = 1.0
+  set Coarsening fraction                      = 0.0
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 0
+  set Initial adaptive refinement              = 1
+  set Run postprocessors on initial refinement = true
+  set Normalize individual refinement criteria = false#true
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2
+    set Y extent  = 2
+    set Box origin X coordinate = -1
+    set Box origin Y coordinate = -1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = cos(z);sin(x)
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants = pi=3.14159265359
+
+    #    set Function expression = if(abs(x)==1 || abs(z)==1, 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * ((x + 0.20e1 * z)^ 0.2e1)), 0)
+    #    set Function expression = 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * ((x + 0.20e1 * z)^ 0.2e1))
+    set Function expression = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * ((x + 0.2e1 * z)^ 0.2e1))
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = test melt material
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Formulation
+  set Enable additional Stokes RHS            = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, pressure statistics, velocity boundary statistics, melt error calculation
+
+  subsection Visualization
+    set List of output variables      = #melt density, permeability, melt viscosity, compaction viscosity, gravity, material properties, nonadiabatic pressure
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+    set Interpolate output = true
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+
+    #    set List of output variables      = gravity, material properties, nonadiabatic pressure
+
+    subsection Material properties
+      set List of material properties   = density, viscosity, thermal expansivity, reaction terms
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Use direct solver for Stokes system = true
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/melt_fraction_postprocessor.prm.bak b/tests/melt_fraction_postprocessor.prm.bak
new file mode 100644
index 00000000000..4a4f16604bb
--- /dev/null
+++ b/tests/melt_fraction_postprocessor.prm.bak
@@ -0,0 +1,126 @@
+# This test checks if the postprocessor 'melt fraction' works as
+# intended. The visualization output is then a p-T-diagram of
+# the melt fraction (which, in this case, is a simple linear relation)
+# with the temperature ranging from 1000°C to 1900°C on the x axis
+# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
+
+# The data can be plotted in gnuplot using:
+# set view map
+# splot "file1" using 5:6:7 with points pointtype 5 pointsize 1 palette,
+#       "file2" using 5:6:7 with points pointtype 5 pointsize 1 palette
+
+# MPI: 2
+
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9
+    set Y extent = 8
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1100+273.15+x*100
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Reference solid density       = 1
+    set Reference melt density        = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1600
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0
+    set Reference shear viscosity     = 1
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 6
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format = gnuplot
+    set Time between graphical output = 0.01
+    set List of output variables = melt fraction
+
+    subsection Melt fraction
+      set Mass fraction cpx = 0.17
+    end
+  end
+end
diff --git a/tests/melt_introspection.cc.bak b/tests/melt_introspection.cc.bak
new file mode 100644
index 00000000000..1b1ae2fd77e
--- /dev/null
+++ b/tests/melt_introspection.cc.bak
@@ -0,0 +1,138 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+#include <aspect/melt.h>
+#include <aspect/simulator/assemblers/interface.h>
+
+#include <deal.II/fe/fe_dgq.h>
+#include <iostream>
+
+using namespace dealii;
+
+namespace aspect
+{
+
+  template <int dim>
+  void my_signal(std::vector<VariableDeclaration<dim>> &variables)
+  {
+    std::cout << "* signals.edit_finite_element_variables:" << std::endl;
+
+    VariableDeclaration<dim> dummy("dummy",
+                                   std::make_shared<FE_DGQ<dim>>(4),
+                                   1,
+                                   1);
+    variables.insert(variables.begin()+6, dummy);
+
+    for (unsigned int i=0; i<variables.size(); ++i)
+      {
+        std::cout << " name=" << variables[i].name
+                  << " fe=" << variables[i].fe->get_name()
+                  << " multiplicity=" << variables[i].multiplicity
+                  << " n_blocks=" << variables[i].n_blocks
+                  << " n_components=" << variables[i].n_components()
+                  << std::endl;
+      }
+
+    std::cout << std::endl;
+  }
+
+
+  template <int dim>
+  class MeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        const double porosity = 0.01;
+        const double permeability = 1.0 * std::pow(porosity, 3) * std::pow(1.0-porosity, 2);
+        return permeability / 0.1;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            out.viscosities[i] = 1.0;
+            out.densities[i] = 1.0 + (in.composition[i][0]);
+            out.thermal_expansion_coefficients[i] = 1.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                const double porosity = in.composition[i][porosity_idx];
+
+                melt_out->compaction_viscosities[i] = 100.0;
+                melt_out->fluid_viscosities[i]=0.1;
+                melt_out->permeabilities[i]=1.0 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+                melt_out->fluid_densities[i]=.1;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+              }
+          }
+      }
+
+  };
+
+
+}
+
+
+
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  std::cout << "* Connecting signals" << std::endl;
+  signals.edit_finite_element_variables.connect(&aspect::my_signal<dim>);
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
+
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
+                                 "MeltMaterial",
+                                 "")
+}
diff --git a/tests/melt_introspection.prm.bak b/tests/melt_introspection.prm.bak
new file mode 100644
index 00000000000..f95c0d0fcd2
--- /dev/null
+++ b/tests/melt_introspection.prm.bak
@@ -0,0 +1,95 @@
+# A test that adds an assembler that tests if we can create additional
+# material model outputs
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, B
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;0
+    set Variable names      = x,y
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = MeltMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set List of output variables      = viscosity
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/melt_material_1.cc.bak b/tests/melt_material_1.cc.bak
new file mode 100644
index 00000000000..52fa3c03ce4
--- /dev/null
+++ b/tests/melt_material_1.cc.bak
@@ -0,0 +1,102 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+namespace aspect
+{
+  template <int dim>
+  class MeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        const double porosity = 0.01;
+        const double permeability = 1.0 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+        return permeability / 0.1;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            out.viscosities[i] = 1.0;
+            out.densities[i] = 1.0 + (in.composition[i][0]);
+            out.thermal_expansion_coefficients[i] = 1.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                const double porosity = in.composition[i][porosity_idx];
+
+                melt_out->compaction_viscosities[i] = 100.0;
+                melt_out->fluid_viscosities[i]=0.1;
+                melt_out->permeabilities[i]=1.0 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+                melt_out->fluid_densities[i]=.1;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+              }
+          }
+      }
+
+  };
+
+
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
+                                 "MeltMaterial",
+                                 "")
+}
diff --git a/tests/melt_material_1.prm.bak b/tests/melt_material_1.prm.bak
new file mode 100644
index 00000000000..c0efd99e39c
--- /dev/null
+++ b/tests/melt_material_1.prm.bak
@@ -0,0 +1,109 @@
+# tests the new melt material interface
+
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 4e-09
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = peridotite, porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 1e-4
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if(y>250000*(1+0.5*sin(x*pi/250000)),0.3,0);if(x<200000,0.3,0.0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = MeltMaterial
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/melt_material_2.cc.bak b/tests/melt_material_2.cc.bak
new file mode 100644
index 00000000000..eb30240277f
--- /dev/null
+++ b/tests/melt_material_2.cc.bak
@@ -0,0 +1,129 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+namespace aspect
+{
+  template <int dim>
+  class MeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        const double permeability = 1.0 + std::pow(0.5, 2.0);
+        return permeability / 2.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            out.viscosities[i] = 3.0/4.0;
+            out.densities[i] = 3.0;
+            out.thermal_expansion_coefficients[i] = 1.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                melt_out->compaction_viscosities[i] = 1.0;
+                melt_out->fluid_viscosities[i]= 2.0;
+                melt_out->permeabilities[i]= 1.0 + std::pow(in.position[i][1],2);
+                melt_out->fluid_densities[i]= 1.0;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+              }
+          }
+      }
+
+  };
+
+  template <int dim>
+  class PressureBdry:
+
+    public BoundaryFluidPressure::Interface<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id boundary_indicator,
+        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &output
+      ) const
+      {
+        for (unsigned int q=0; q<output.size(); ++q)
+          {
+            Tensor<1,dim> gradient;
+            gradient[0] = 0.0;
+            gradient[1] = 0.0;
+            output[q] = gradient * normal_vectors[q];
+          }
+      }
+  };
+
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
+                                 "MeltMaterial2",
+                                 "")
+
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+}
diff --git a/tests/melt_material_2.prm.bak b/tests/melt_material_2.prm.bak
new file mode 100644
index 00000000000..85dce399eb7
--- /dev/null
+++ b/tests/melt_material_2.prm.bak
@@ -0,0 +1,132 @@
+# A testcase that demonstrates melt transport with a compactible matrix,
+# but incompressible matrix and fluid. It solves the equation on a box
+# with zero velocity boundary conditions at the bottom boundary,
+# tangential velocities at the sides and an open boundary at the top.
+#
+# We then choose a Darcy coefficient (= permeability divided by fluid
+# viscosity) of 0.5+y^2/2 and otherwise constant material parameters
+# so that the gradient of the fluid pressure vanishes. The velocity
+# should then be y^2/2, the compaction pressure -y and the fluid
+# pressure should be constant.
+#
+# We compute these material properties in a new material model, which
+# is implemented in the .cc file.
+#
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+# prescribe the fluid pressure as in the analytical solution
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = 0;0.5*y*y
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = MeltMaterial2
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/melt_material_3.cc.bak b/tests/melt_material_3.cc.bak
new file mode 100644
index 00000000000..8ca211248f5
--- /dev/null
+++ b/tests/melt_material_3.cc.bak
@@ -0,0 +1,129 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+namespace aspect
+{
+  template <int dim>
+  class MeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        const double permeability = 1.0 + std::pow(0.5, 2.0);
+        return permeability / 2.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            out.viscosities[i] = 3.0/4.0;
+            out.densities[i] = 4.0;
+            out.thermal_expansion_coefficients[i] = 1.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                melt_out->compaction_viscosities[i] = 1.0;
+                melt_out->fluid_viscosities[i]= 2.0;
+                melt_out->permeabilities[i]= 1.0 + std::pow(in.position[i][1],2);
+                melt_out->fluid_densities[i]= 2.0;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+              }
+          }
+      }
+
+  };
+
+  template <int dim>
+  class PressureBdry:
+
+    public BoundaryFluidPressure::Interface<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id boundary_indicator,
+        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &output
+      ) const
+      {
+        for (unsigned int q=0; q<output.size(); ++q)
+          {
+            Tensor<1,dim> gradient;
+            gradient[0] = 0.0;
+            gradient[1] = -1.0;
+            output[q] = gradient * normal_vectors[q];
+          }
+      }
+  };
+
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
+                                 "MeltMaterial3",
+                                 "")
+
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+}
diff --git a/tests/melt_material_3.prm.bak b/tests/melt_material_3.prm.bak
new file mode 100644
index 00000000000..8f23f9dbb7d
--- /dev/null
+++ b/tests/melt_material_3.prm.bak
@@ -0,0 +1,132 @@
+# A testcase that demonstrates melt transport with a compactible matrix,
+# but incompressible matrix and fluid. It solves the equation on a box
+# with zero velocity boundary conditions at the bottom boundary,
+# tangential velocities at the sides and an open boundary at the top.
+#
+# We the choose a Darcy coefficient (= permeability divided by fluid
+# viscosity) of (1+y^2)/2 and otherwise constant material parameters
+# so that the gradient of the fluid pressure is -1. The velocity
+# should then be y^2/2, the compaction pressure -y and the fluid
+# pressure should be linear.
+#
+# We compute these material properties in a new material model, which
+# is implemented in the .cc file.
+#
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+# prescribe the fluid pressure as in the analytical solution
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = 0;0.5*y*y
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = MeltMaterial3
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/melt_material_4.cc.bak b/tests/melt_material_4.cc.bak
new file mode 100644
index 00000000000..aee80fefcce
--- /dev/null
+++ b/tests/melt_material_4.cc.bak
@@ -0,0 +1,240 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+using namespace dealii;
+
+
+namespace aspect
+{
+  template <int dim>
+  class MeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        const double porosity = 0.01;
+        const double permeability = 1.0 + 0.001 / (1.0 - porosity);
+        return permeability / 2.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            const double y = in.position[i][dim-1] + 0.1;
+            out.viscosities[i] = 3.0/4.0;
+            out.densities[i] = 2 + std::pow(y,2)/0.001;
+            out.thermal_expansion_coefficients[i] = 1.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                double porosity = in.composition[i][porosity_idx];
+                melt_out->compaction_viscosities[i] = 1.0;
+                melt_out->fluid_viscosities[i]= 2.0;
+                melt_out->permeabilities[i]= 1.0 + 0.001 / (1.0 - porosity);
+                melt_out->fluid_densities[i]= 2.0;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+              }
+          }
+      }
+
+  };
+
+
+
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(9) {}
+      virtual void vector_value (const Point<dim>   &p,
+                                 Vector<double>   &values) const
+      {
+        double x = p(0);
+        double y = p(1);
+
+        const double porosity = 1.0 - 0.001/std::pow(y+0.1,2.0);
+        const double p_f = 1.0 - (y+0.1);
+        const double p_s = 0.0;
+
+        values[0]=0;  // x vel
+        values[1]=0.5 * std::pow(y+0.1, 2.0);  // y vel
+        values[2]=p_f;  // p_f
+        values[3]=(1.0-porosity)*(p_s-p_f); // p_c
+        values[4]=-1; // u_f_x
+        values[5]=-1; // u_f_y
+        values[6]=p_s;  // p_s
+        values[7]=0; // T
+        values[8]=porosity; // porosity
+      }
+  };
+
+
+
+  template <int dim>
+  class MMPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics);
+  };
+
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  MMPostprocessor<dim>::execute (TableHandler &statistics)
+  {
+    RefFunction<dim> ref_func;
+    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
+
+    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+
+    const unsigned int n_total_comp = this->introspection().n_components;
+    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                        n_total_comp);
+    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
+    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+dim),
+                                          n_total_comp);
+    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_f);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_porosity,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_porosity);
+
+    const double u_l2 = std::sqrt(Utilities::MPI::sum(cellwise_errors_u.norm_sqr(),this->get_mpi_communicator()));
+    const double p_l2 = std::sqrt(Utilities::MPI::sum(cellwise_errors_p.norm_sqr(),this->get_mpi_communicator()));
+    const double poro_l2 = std::sqrt(Utilities::MPI::sum(cellwise_errors_porosity.norm_sqr(),this->get_mpi_communicator()));
+
+    std::ostringstream os;
+    os << std::scientific << u_l2
+       << ", " << p_l2
+       << ", " << poro_l2;
+
+    return std::make_pair("Errors u_L2, p_f_L2, porosity_L2:", os.str());
+
+  }
+
+  template <int dim>
+  class PressureBdry:
+
+    public BoundaryFluidPressure::Interface<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id boundary_indicator,
+        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &output
+      ) const
+      {
+        for (unsigned int q=0; q<output.size(); ++q)
+          {
+            Tensor<1,dim> gradient;
+            gradient[0] = 0.0;
+            gradient[1] = -1.0;
+            output[q] = gradient * normal_vectors[q];
+          }
+      }
+  };
+
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
+                                 "MeltMaterial4",
+                                 "")
+
+  ASPECT_REGISTER_POSTPROCESSOR(MMPostprocessor,
+                                "MMPostprocessor",
+                                "")
+
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+
+}
diff --git a/tests/melt_material_4.prm.bak b/tests/melt_material_4.prm.bak
new file mode 100644
index 00000000000..ad8339a6168
--- /dev/null
+++ b/tests/melt_material_4.prm.bak
@@ -0,0 +1,143 @@
+# A testcase that demonstrates melt transport with a compactible matrix,
+# but incompressible matrix and fluid. It solves the equation on a box
+# with zero velocity boundary conditions at the bottom boundary,
+# tangential velocities at the sides and an open boundary at the top.
+# In addition, the advection of the porosity field is tested.
+#
+# This also checks the correct size of the time step, which depends
+# both on the melt and the solid velocity.
+#
+# We the choose a porosity phi = 1 - 0.001/y^2, a Darcy coefficient
+# (= permeability divided by fluid viscosity) of k_0 + 0.001/ (1 - phi),
+# a solid density of 2 + y^2/0.001  and otherwise constant material
+# parameters so that the gradient of the fluid pressure is -1.
+# The velocity should then be y^2/2, the compaction pressure -y and
+# the fluid pressure should be linear.
+# Note that we shift y --> y + 0.1, because we would have a negative
+# porosity otherwise.
+#
+# We compute these material properties in a new material model, which
+# is implemented in the .cc file.
+#
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+# prescribe the fluid pressure as in the analytical solution
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 0.9
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = 0;0.5*(y+0.1)*(y+0.1)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0 - 0.001/((y+0.1)*(y+0.1))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = MeltMaterial4
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, MMPostprocessor
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-18
+  set Temperature solver tolerance = 1e-18
+
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/melt_postprocessor_peridotite.prm.bak b/tests/melt_postprocessor_peridotite.prm.bak
new file mode 100644
index 00000000000..17cc6d2b59f
--- /dev/null
+++ b/tests/melt_postprocessor_peridotite.prm.bak
@@ -0,0 +1,121 @@
+# This test checks if the postprocessor 'melt fraction' works as
+# intended. The visualization output is then a p-T-diagram of
+# the melt fraction of peridotite using the melting model of
+# Katz et. al, 2003 (Geochem., Geophys., Geosyst. )
+# with the temperature ranging from 1000°C to 1900°C on the x axis
+# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
+
+# MPI: 2
+
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9
+    set Y extent = 8
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1100+273.15+x*100
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 6
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format = gnuplot
+    set Time between graphical output = 0.01
+    set List of output variables = melt fraction
+
+    subsection Melt fraction
+      set Mass fraction cpx = 0.17
+    end
+  end
+end
diff --git a/tests/melt_postprocessor_pyroxenite.prm.bak b/tests/melt_postprocessor_pyroxenite.prm.bak
new file mode 100644
index 00000000000..27da3361083
--- /dev/null
+++ b/tests/melt_postprocessor_pyroxenite.prm.bak
@@ -0,0 +1,140 @@
+# This test checks if the postprocessor 'melt fraction' works as
+# intended. The visualization output is then a p-T-diagram of
+# the melt fraction of pyroxenite using the melting model of
+# Sobolev et. al, 2010 (Nature)
+# with the temperature ranging from 1000°C to 1900°C on the x axis
+# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
+
+# The data can be plotted in gnuplot using:
+# set view map
+# splot "file1" using 5:6:8 with points pointtype 5 pointsize 1 palette,
+#       "file2" using 5:6:8 with points pointtype 5 pointsize 1 palette
+
+# MPI: 2
+
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9
+    set Y extent = 8
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = pyroxenite
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1100+273.15+x*100
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = box
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format = gnuplot
+    set Time between graphical output = 0.01
+    set List of output variables = melt fraction
+  end
+end
diff --git a/tests/melt_property_visualization.cc.bak b/tests/melt_property_visualization.cc.bak
new file mode 100644
index 00000000000..42941744080
--- /dev/null
+++ b/tests/melt_property_visualization.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "melt_transport_compressible.cc"
diff --git a/tests/melt_property_visualization.prm.bak b/tests/melt_property_visualization.prm.bak
new file mode 100644
index 00000000000..59a91210194
--- /dev/null
+++ b/tests/melt_property_visualization.prm.bak
@@ -0,0 +1,139 @@
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 1
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+# test if the melt material properties visulaization output works
+# (for both scalar and tensor output variables)
+#
+subsection Discretization
+  # The polynomial degree to use for the composition variable(s). Units:
+  # None.
+  set Composition polynomial degree           = 2
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;-exp(y)
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = 0.1*exp(y);-0.3/4.0*exp(y)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0 - 0.3 * exp(y)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = compressible melt material
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = melt material properties
+    set Output format                 = gnuplot
+
+    subsection Melt material properties
+      set List of properties = permeability, fluid density gradient
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/melt_restart.cc.bak b/tests/melt_restart.cc.bak
new file mode 100644
index 00000000000..e1bf07b7fef
--- /dev/null
+++ b/tests/melt_restart.cc.bak
@@ -0,0 +1,96 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Launch ASPECT
+ * twice to test checkpoint/resume and then terminate the outer ASPECT run.
+ */
+int f()
+{
+  std::cout << "* starting from beginning:" << std::endl;
+
+  // call ASPECT with "--" and pipe an existing input file into it.
+  int ret;
+  std::string command;
+
+  command = ("cd output-melt_restart ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/melt_restart.prm "
+             " ; "
+             " echo 'set Output directory = output1.tmp' "
+             " ; "
+             " rm -rf output1.tmp ; mkdir output1.tmp "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  command = ("cd output-melt_restart ; "
+             " rm -rf output2.tmp ; mkdir output2.tmp ; "
+             " cp output1.tmp/restart* output2.tmp/");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now resuming:" << std::endl;
+  command = ("cd output-melt_restart ; "
+             "(cat " ASPECT_SOURCE_DIR "/tests/melt_restart.prm "
+             " ; "
+             " echo 'set Output directory = output2.tmp' "
+             " ; "
+             " echo 'set Resume computation = true' "
+             ") "
+             "| ../../aspect -- > /dev/null");
+  std::cout << "Executing the following command:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  std::cout << "* now comparing:" << std::endl;
+
+  ret = system ("cd output-melt_restart ; "
+                "cp output1.tmp/log.txt log.txt1;"
+                "cp output2.tmp/log.txt log.txt2;"
+                "cp output1.tmp/statistics statistics1;"
+                "cp output2.tmp/statistics statistics2;"
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // terminate current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/melt_restart.prm.bak b/tests/melt_restart.prm.bak
new file mode 100644
index 00000000000..5ad3e65dd3c
--- /dev/null
+++ b/tests/melt_restart.prm.bak
@@ -0,0 +1,223 @@
+# test checkpoint/resume.
+
+# This test is controlled via the plugin in melt_restart.cc. The plugin will
+# first execute ASPECT with this .prm and write the output into
+# output1.tmp/. This will generate a snapshot that is then resumed from. The
+# output for this second run will be written into output2.tmp/. Finally,
+# output files will be copied into the main output folder for comparison.
+
+# based on global_melt.prm
+
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 1.0
+set Maximum time step                      = 1e6
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = melt_restart
+set Max nonlinear iterations               = 20
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e3
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.2
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3700
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = #2,3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+
+  subsection Function
+    set Function constants  = b=100000, c=20000
+    set Variable names      = x,y
+    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 8700000
+    set Y extent = 2900000
+
+    #    set X periodic = true
+    set X repetitions = 3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 5e8
+    set Age top boundary layer    = 3e8
+    set Amplitude                 = 50
+    set Position                  = center
+    set Radius                    = 350000
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+
+  subsection Harmonic perturbation
+    set Magnitude = 50
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,a = 0.0, b = 2500000, c = 100000, d=1450000
+    set Function expression = a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c)); a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Thermal conductivity              = 4.7
+    set Reference solid density           = 3400
+    set Reference melt density            = 3000
+    set Thermal expansion coefficient     = 2e-5
+    set Reference permeability            = 1e-8
+    set Reference shear viscosity         = 5e21
+    set Reference bulk viscosity          = 1e19
+    set Exponential melt weakening factor = 10
+    set Thermal viscosity exponent        = 7
+    set Thermal bulk viscosity exponent   = 7
+    set Reference temperature             = 1600
+    set Solid compressibility             = 4.2e-12
+    set Melt compressibility              = 1.25e-11
+    set Reference melt viscosity          = 10
+    set Depletion density change          = -200.0 # -100.0 # 0.0
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 3
+  set Strategy                                 = composition threshold, minimum refinement function #, nonadiabatic temperature
+  set Time steps between mesh refinement       = 0
+
+  subsection Minimum refinement function
+    set Coordinate system   = depth
+    set Function expression = if (depth>1500000,5,4)
+    set Variable names      = depth,phi
+  end
+
+  subsection Composition threshold
+    set Compositional field thresholds = 1e-4,1.0
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating #, latent heat melt, shear heating
+end
+
+subsection Nullspace removal
+  #  set Remove nullspace                        = net x translation
+
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Interpolate output            = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+
+  subsection Depth average
+    set Number of zones = 12
+    set Time between graphical output = 6e5
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint = 0
+  set Steps between checkpoint = 1
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-14
+  set Temperature solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/melt_statistics.prm.bak b/tests/melt_statistics.prm.bak
new file mode 100644
index 00000000000..5015b89b015
--- /dev/null
+++ b/tests/melt_statistics.prm.bak
@@ -0,0 +1,141 @@
+# This test checks if the postprocessor 'melt statistics' works as
+# intended. The statistics output is computed using
+# the melt fraction of peridotite in the melting model of
+# Katz et. al, 2003 (Geochem., Geophys., Geosyst. )
+# with the temperature ranging from 1000°C to 1900°C on the x axis
+# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
+
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9
+    set Y extent = 8
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 1100+273.15+x*100
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
+  end
+end
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Reference solid density       = 1
+    set Reference melt density        = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0
+    set Reference shear viscosity     = 1
+    set Reference bulk viscosity      = 1
+    set Mass fraction cpx             = 0.17
+    set Exponential melt weakening factor = 0.0
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 6
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = melt statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files = 1
+    set Time between graphical output = 0.01
+    set List of output variables = melt fraction
+
+    subsection Melt fraction
+      set Mass fraction cpx = 0.17
+    end
+  end
+end
diff --git a/tests/melt_track.cc.bak b/tests/melt_track.cc.bak
new file mode 100644
index 00000000000..069053c7cd3
--- /dev/null
+++ b/tests/melt_track.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solitary_wave/solitary_wave.cc"
diff --git a/tests/melt_track.prm.bak b/tests/melt_track.prm.bak
new file mode 100644
index 00000000000..2bb381b7fee
--- /dev/null
+++ b/tests/melt_track.prm.bak
@@ -0,0 +1,189 @@
+# Listing of Parameters
+# ---------------------
+# Uses the solitary wave benchmark to demonstrate the particle property melt particle,
+# which records the presence of melt over the melt transport threshold
+
+set Additional shared libraries            = ./libsolitary_wave.so
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = output_melt_track
+set Max nonlinear iterations               = 10
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.001
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+# we apply the phase speed of the wave here, so that it always stays in the same place in our model
+# the phase speed is c = 5.25e-11 m/s, but we have to convert it to m/years using the same conversion
+# that is used internally in ASPECT: year_in_seconds = 60*60*24*365.2425
+
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    #    set Function expression = 0;-8.2836999e-5
+    set Function expression = 0;-1.65673998e-4
+
+    #    set Function expression = 0;-3.31347996e-4
+    #    set Function expression = 0;-6.62695992e-4
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 10
+    set Y extent  = 400
+    set Y repetitions = 40
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Initial composition model
+  set Model name = Solitary wave initial condition
+
+  subsection Solitary wave initial condition
+    set Offset = 200
+    set Read solution from file = false
+    set Amplitude = 0.01
+    set Background porosity = 0.001
+  end
+end
+
+subsection Material model
+  set Model name = Solitary Wave
+
+  subsection Solitary wave
+    set Reference permeability = 5e-9
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 2
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = particles,visualization,composition statistics,velocity statistics,solitary wave statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 5e5
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+
+  subsection Particles
+    set Time between data output      = 0
+    set Data output format = gnuplot
+  end
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-14
+  set Temperature solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-10
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Particles
+  set Particle generator name       = ascii file
+  set List of particle properties   = melt particle
+
+  subsection Generator
+    subsection Ascii file
+      set Data file name            = melt_track.txt
+    end
+  end
+end
diff --git a/tests/melt_transport.prm.bak b/tests/melt_transport.prm.bak
new file mode 100644
index 00000000000..1f4fbed6a21
--- /dev/null
+++ b/tests/melt_transport.prm.bak
@@ -0,0 +1,151 @@
+# Listing of Parameters
+# ---------------------
+# This test checks if including melt transport in a simulation,
+# but setting the porosity to 0, gives the same results as running
+# the simulation without melt transport.
+#
+# Results are the same up to the first three digits of time step size
+# and min/max/mass of compositional fields.
+#
+# Differences can be checked by setting 'Include melt transport'
+# to false.
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 1.5e7
+set Pressure normalization                 = surface
+set Surface pressure                       = 5e9
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+set Use operator splitting                     = true
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = peridotite, porosity
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = 1600 + 100 * exp(-(x-l)*(x-l)/(0.04*l*l)-(y-l)*(y-l)/(0.04*l*l))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if(y>250000*(1+0.5*sin(x*pi/250000)),0.3,0);0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Reference shear viscosity = 1e21
+    set Reference solid density = 3300
+    set Reference melt density = 3200
+    set Melting time scale for operator splitting = 1e100
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/melt_transport_adaptive.cc.bak b/tests/melt_transport_adaptive.cc.bak
new file mode 100644
index 00000000000..f1ecf2bf351
--- /dev/null
+++ b/tests/melt_transport_adaptive.cc.bak
@@ -0,0 +1,518 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/mesh_refinement/interface.h>
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+#include <deal.II/fe/fe_values.h>
+#include <deal.II/numerics/derivative_approximation.h>
+
+
+namespace aspect
+{
+  template <int dim>
+  class MeltVelocityRefinement : public MeshRefinement::Interface<dim>,
+    public SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Execute this mesh refinement criterion.
+       *
+       * @param[out] error_indicators A vector that for every active cell of
+       * the current mesh (which may be a partition of a distributed mesh)
+       * provides an error indicator. This vector will already have the
+       * correct size when the function is called.
+       */
+      virtual
+      void
+      execute (Vector<float> &indicators) const
+      {
+        indicators = 0;
+
+        KellyErrorEstimator<dim>::estimate (this->get_mapping(),
+                                            this->get_dof_handler(),
+                                            QGauss<dim-1>(this->introspection().polynomial_degree.velocities +1),
+                                            std::map<types::boundary_id,const Function<dim>*>(),
+                                            this->get_solution(),
+                                            indicators,
+                                            this->introspection().variable("fluid velocity").component_mask,
+                                            0,
+                                            0,
+                                            this->get_triangulation().locally_owned_subdomain());
+      }
+
+  };
+
+  template <int dim>
+  class PCRefinement : public MeshRefinement::Interface<dim>,
+    public SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Execute this mesh refinement criterion.
+       *
+       * @param[out] error_indicators A vector that for every active cell of
+       * the current mesh (which may be a partition of a distributed mesh)
+       * provides an error indicator. This vector will already have the
+       * correct size when the function is called.
+       */
+      virtual
+      void
+      execute (Vector<float> &indicators) const
+      {
+        indicators = 0;
+
+        // create a vector in which we set the compaction pressure block
+        // (that contains the scaled compaction pressure p_c_bar) to
+        // be a finite element interpolation of the (real) compaction pressure.
+        // we do so by setting up a quadrature formula and looping over these
+        // points, rescaling the compaction pressure, and writing
+        // the result into the output vector. As the scaling factor between
+        // the pressures is cell-wise constant (and the error indicator is
+        // a cellwise quantity too), we use a quadrature formula with only
+        // one point.
+        LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
+                                                    this->get_mpi_communicator());
+
+        const unsigned int pc_component_index = this->introspection().variable("compaction pressure").first_component_index;
+        const unsigned int pc_base_index = this->introspection().variable("compaction pressure").base_index;
+
+        // Use a quadrature formula with only one point, as the scaling factor we need is cell-wise constant
+        const QMidpoint<dim> quadrature;
+
+        std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
+        FEValues<dim> fe_values (this->get_mapping(),
+                                 this->get_fe(),
+                                 quadrature,
+                                 update_quadrature_points | update_values | update_gradients);
+
+        MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
+        MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
+        MeltHandler<dim>::create_material_model_outputs(out);
+
+        typename DoFHandler<dim>::active_cell_iterator
+        cell = this->get_dof_handler().begin_active(),
+        endc = this->get_dof_handler().end();
+        for (; cell!=endc; ++cell)
+          if (cell->is_locally_owned())
+            {
+              fe_values.reinit(cell);
+              // Set use_strain_rates to false since we don't need viscosity
+              in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+              this->get_material_model().evaluate(in, out);
+
+              MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+              AssertThrow(melt_out != nullptr,
+                          ExcMessage("Need MeltOutputs from the material model for computing the melt properties."));
+
+              const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
+
+              cell->get_dof_indices (local_dof_indices);
+
+              // for each compaction pressure dof, write into the output
+              // vector the scaled compaction pressure. note that quadrature points and
+              // dofs are enumerated in the same order
+              for (unsigned int i=0; i<this->get_fe().base_element(pc_base_index).dofs_per_cell; ++i)
+                {
+                  const unsigned int system_local_dof
+                    = this->get_fe().component_to_system_index(pc_component_index,
+                                                               /*dof index within component=*/i);
+
+                  vec_distributed(local_dof_indices[system_local_dof])
+                    = p_c_scale * this->get_solution()[local_dof_indices[system_local_dof]];
+                }
+            }
+
+        vec_distributed.compress(VectorOperation::insert);
+
+        // now create a vector with the requisite ghost elements
+        // and use it for estimating the gradients
+        LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
+                                        this->introspection().index_sets.system_relevant_partitioning,
+                                        this->get_mpi_communicator());
+        vec = vec_distributed;
+
+        DerivativeApproximation::approximate_gradient  (this->get_mapping(),
+                                                        this->get_dof_handler(),
+                                                        vec,
+                                                        indicators,
+                                                        pc_component_index);
+
+        // Scale gradient in each cell with the correct power of h. Otherwise,
+        // error indicators do not reduce when refined if there is a density
+        // jump. We need at least order 1 for the error not to grow when
+        // refining, so anything >1 should work. (note that the gradient
+        // itself scales like 1/h, so multiplying it with any factor h^s, s>1
+        // will yield convergence of the error indicators to zero as h->0)
+        const double power = 1.0 + dim/2.0;
+        {
+          unsigned int i=0;
+          for (cell = this->get_dof_handler().begin_active(); cell!=endc; ++cell, ++i)
+            if (cell->is_locally_owned())
+              indicators(i) *= std::pow(cell->diameter(), power);
+        }
+
+      }
+
+  };
+
+
+
+
+
+  template <int dim>
+  class TestMeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public SimulatorAccess<dim>
+  {
+    public:
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        const double porosity = 0.01;
+        const double permeability = porosity;
+        return permeability / 1.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            const double x = in.position[i](0);
+            const double z = in.position[i](1);
+            out.viscosities[i] = 1.0;
+            out.thermal_expansion_coefficients[i] = 0.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            out.densities[i] = 1.0;
+            // This is the RHS we need to use for the manufactured solution.
+            // We calculated it by subtracting the first term of the RHS (\Nabla (K_D \rho_f g)) from the LHS
+            // we computed using our analytical solution.
+            double reactionterm;
+            reactionterm = (0.8544665250e4 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) - 0.4950000000e1 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) + 0.3245696667e4 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) - 0.4687000001e3 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) + 0.160e3 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) * x * x + 0.3992000000e3 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * z + 0.1600000000e1 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * x - 0.1399880000e4 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * x + 0.8826800400e5 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * x + 0.1765360080e6 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * z - 0.7840998000e5 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * x * x + 0.4943188800e6 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * z * z - 0.1925014410e6 * exp(-0.400e2 * pow(x + 0.2e1 * z, 0.2e1)) * z + 0.3698838000e5 * exp(-0.600e2 * pow(x + 0.2e1 * z, 0.2e1)) * x + 0.7397676000e5 * exp(-0.600e2 * pow(x + 0.2e1 * z, 0.2e1)) * z - 0.16e2 * exp(-0.1200e3 * pow(x + 0.2e1 * z, 0.2e1)) * x - 0.32e2 * exp(-0.1200e3 * pow(x + 0.2e1 * z, 0.2e1)) * z - 0.6688400000e4 * exp(-0.800e2 * pow(x + 0.2e1 * z, 0.2e1)) * x - 0.1337680000e5 * exp(-0.800e2 * pow(x + 0.2e1 * z, 0.2e1)) * z + 0.556e3 * exp(-0.1000e3 * pow(x + 0.2e1 * z, 0.2e1)) * x + 0.1112e4 * exp(-0.1000e3 * pow(x + 0.2e1 * z, 0.2e1)) * z - 0.9625072050e5 * exp(-0.400e2 * pow(x + 0.2e1 * z, 0.2e1)) * x + 0.8e1 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) * x - 0.5763380040e5 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * z + 0.1971823986e7 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * z * z - 0.1950349995e5 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * x + 0.7723580040e6 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * x * x - 0.552024e6 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * z * z - 0.138006e6 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * x * x + 0.39792e5 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * z * z + 0.9860004000e4 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * x + 0.3318598800e5 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * z + 0.8e1 * exp(-0.100e3 * x * x - 0.400e3 * x * z - 0.400e3 * z * z + z) * x + 0.16e2 * exp(-0.100e3 * x * x - 0.400e3 * x * z - 0.400e3 * z * z + z) * z + 0.1599287976e7 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * x * z - 0.3447976000e5 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * z + 0.1068266666e4 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * x - 0.320e3 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) * z * z + 0.4008e4 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * x * x + 0.1930895010e5 * z * z * exp(-0.20e2 * x * x - 0.20e2 * z * z + z + 0.1e1) + 0.1930895010e5 * x * x * exp(-0.20e2 * x * x - 0.20e2 * z * z + z + 0.1e1) - 0.9654475050e3 * z * exp(-0.20e2 * x * x - 0.20e2 * z * z + z + 0.1e1) + 0.9751995000e4 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * x * x + 0.3900798000e5 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * z * z + 0.3881097000e6 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * x * x + 0.1552438800e7 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * z * z + 0.1552438800e7 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * x * z + 0.3900798000e5 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * x * z - 0.9097753500e4 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) - 0.640e3 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) * x * z + 0.4200000000e1 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) - 0.9533794112e3 * exp(-0.20e2 * x * x - 0.20e2 * z * z + z + 0.1e1) - 0.1036095000e4 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) + 0.2253333334e2 * exp(-0.100e3 * x * x - 0.400e3 * x * z - 0.400e3 * z * z + z) + 0.1123231354e5 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) - 0.1863776536e5 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) - 0.3960040000e5 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * x * x - 0.3696256000e6 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * z * z + 0.7636384800e6 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * x * z - 0.4400336000e6 * x * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * z + 0.47840e5 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * x * z + 0.47840e5 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * z * z + 0.11960e5 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * x * x - 0.6320160000e4 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * z + 0.9509415350e5 * exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1)) * x + 0.1901883070e6 * exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1)) * z - 0.1191523129e5 * exp(z) - 0.552024e6 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * x * z + 0.47712e5 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * x * z - 0.1723988000e5 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * x - 0.1488766999e6 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * x - 0.2977534000e6 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * z + 0.2136533332e4 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * z) * pow(-0.4950000000e1 + exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1)), -0.3e1) * pow(-0.9950000000e1 + exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1)), -0.2e1);
+
+            out.reaction_terms[i][porosity_idx] = reactionterm;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                double porosity = in.composition[i][porosity_idx];
+
+                const double x = in.position[i](0);
+                const double z = in.position[i](1);
+                // porosity = 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * pow(x + 0.20e1 * z, 0.2e1));
+                // porosity = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1));
+                melt_out->compaction_viscosities[i] = 0.1e0 + 0.1e0 * exp(-0.20e2 * x * x - 0.20e2 * z * z + 0.1e1);
+                melt_out->fluid_viscosities[i] = 1.0;
+                melt_out->permeabilities[i] = porosity;// K_D
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+                melt_out->fluid_densities[i] = 0.5;
+              }
+          }
+      }
+
+  };
+
+
+  template <int dim>
+  class Gravity : public aspect::GravityModel::Interface<dim>
+  {
+    public:
+      virtual Tensor<1,dim> gravity_vector (const Point<dim> &pos) const
+      {
+        const double x=pos[0];
+        const double z=pos[1];
+        Tensor<1,dim> gravity;
+        gravity[0] = (0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.400e2 * x - 0.8000e2 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) + 0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z)) / (0.9950000000e0 - 0.1000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)));
+        gravity[1] = (-0.1333333333e1 * exp(z) + 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.8000e2 * x - 0.160000e3 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) - 0.1e1 + 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z)) / (0.9950000000e0 - 0.1000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)));
+
+
+        return gravity;
+      }
+
+
+  };
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(2*dim+3+2) {}
+      virtual void vector_value (const Point<dim>   &p,
+                                 Vector<double>   &values) const
+      {
+        double x = p(0);
+        double z = p(1);
+
+        values[0] = x;
+        values[1] = -z + exp(z);
+        values[2] = -(0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.1e1 - z;
+        values[3] = -(0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z);
+        values[4] = x - 0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.400e2 * x - 0.8000e2 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) + 0.5e0 * (0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.400e2 * x - 0.8000e2 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) + 0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z)) / (0.9950000000e0 - 0.1000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)));
+        values[5] = -z + exp(z) - 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.8000e2 * x - 0.160000e3 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) + 0.1e1 + 0.5e0 * (-0.1333333333e1 * exp(z) + 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.8000e2 * x - 0.160000e3 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) - 0.1e1 + 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z)) / (0.9950000000e0 - 0.1000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)));
+        values[6] = 0.1e1 - z;
+        values[7] = 0;
+        values[8] = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1));
+
+        // We have to scale the compaction pressure solution to p_c_bar using sqrt(K_D / ref_K_D).
+        // K_D is equal to the porosity (as defined in the material model).
+        const double K_D = values[8];
+        const double ref_K_D = 0.01;
+        const double p_c_scale = std::sqrt(K_D / ref_K_D);
+
+        if (p_c_scale > 0)
+          values[3] /= p_c_scale;
+      }
+  };
+
+
+
+  /**
+    * A postprocessor that evaluates the accuracy of the solution
+    * by using the L2 norm.
+    */
+  template <int dim>
+  class ConvergenceMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Generate graphical output from the current solution.
+       */
+      virtual
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics);
+
+  };
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  ConvergenceMeltPostprocessor<dim>::execute (TableHandler &statistics)
+  {
+    RefFunction<dim> ref_func;
+    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
+
+    const unsigned int n_total_comp = this->introspection().n_components;
+
+    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_c_bar (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
+
+    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                        n_total_comp);
+    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
+    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+
+                                                                                dim),
+                                          n_total_comp);
+    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_f);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_c_bar,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_c);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_porosity,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_porosity);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u_f);
+
+
+    // Loop over all cells to compute the error for p_c from p_c_bar
+    const QGauss<dim> quadrature(this->get_parameters().stokes_velocity_degree+1);
+    FEValues<dim> fe_values (this->get_mapping(),
+                             this->get_fe(),
+                             quadrature,
+                             update_quadrature_points | update_values | update_gradients | update_JxW_values);
+
+    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
+    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
+
+    MeltHandler<dim>::create_material_model_outputs(out);
+
+    typename DoFHandler<dim>::active_cell_iterator
+    cell = this->get_dof_handler().begin_active(),
+    endc = this->get_dof_handler().end();
+    for (; cell!=endc; ++cell)
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+          this->get_material_model().evaluate(in, out);
+
+          const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
+
+          const unsigned int i = cell->active_cell_index();
+          cellwise_errors_p_c[i] = cellwise_errors_p_c_bar[i] * p_c_scale;
+        }
+
+    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
+    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
+    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
+    const double p_c_bar_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c_bar, VectorTools::L2_norm);
+    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
+    const double phi_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
+    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
+
+    std::ostringstream os;
+    os << std::scientific
+       << "ndofs= " << this->get_solution().size()
+       << " u_L2= " << u_l2
+       << " p_L2= "  << p_l2
+       << " p_f_L2= " << p_f_l2
+       << " p_c_bar_L2= " << p_c_bar_l2
+       << " p_c_L2= " << p_c_l2
+       << " phi_L2= " << phi_l2
+       << " u_f_L2= " << u_f_l2
+       ;
+
+    return std::make_pair("Errors", os.str());
+  }
+
+
+  template <int dim>
+  class PressureBdry:
+
+    public BoundaryFluidPressure::Interface<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id boundary_indicator,
+        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &output
+      ) const
+      {
+        for (unsigned int q=0; q<output.size(); ++q)
+          {
+            const double x = material_model_inputs.position[q][0];
+            const double z = material_model_inputs.position[q][1];
+            Tensor<1,dim> gradient;
+            gradient[0] = 0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.400e2 * x - 0.8000e2 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1));
+            gradient[1] = 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.8000e2 * x - 0.160000e3 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) - 0.1e1;
+            output[q] = gradient * normal_vectors[q];
+          }
+      }
+
+
+
+  };
+
+}
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_GRAVITY_MODEL(Gravity,
+                                "MyGravity",
+                                "")
+
+  ASPECT_REGISTER_MATERIAL_MODEL(TestMeltMaterial,
+                                 "test melt material",
+                                 "")
+  ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(MeltVelocityRefinement,
+                                            "melt velocity",
+                                            "")
+  ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(PCRefinement,
+                                            "pc",
+                                            "")
+
+  ASPECT_REGISTER_POSTPROCESSOR(ConvergenceMeltPostprocessor,
+                                "melt error calculation",
+                                "A postprocessor that compares the numerical solution to the analytical "
+                                "solution derived for incompressible melt transport in a 2D box as described "
+                                "in the manuscript and reports the error.")
+
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+
+}
diff --git a/tests/melt_transport_adaptive.prm.bak b/tests/melt_transport_adaptive.prm.bak
new file mode 100644
index 00000000000..5318778af89
--- /dev/null
+++ b/tests/melt_transport_adaptive.prm.bak
@@ -0,0 +1,135 @@
+# A testcase that demonstrates melt transport with a compactible matrix,
+# and compressible matrix and fluid. Boundary conditions for the
+# velocity and fluid pressure as well as porosity initial conditions
+# are applied as described by the derived analytical solution,
+# which can be found in the manuscript on compressible melt transport
+# in ASPECT.
+# We compute these material properties in a new material model, which
+# is implemented in the .cc file, together with a postprocessor to calculate
+# the error and a new pressure boundary condition.
+#
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 50
+set Nonlinear solver tolerance             = 1e-10
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0.2746026940#3.992884522
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Refinement fraction                      = 0.3333
+  set Coarsening fraction                      = 0.0
+  set Strategy                                 = composition, pc
+
+  #melt velocity, composition#composition, velocity# gradient#,velocity#viscosity#composition
+
+  set Time steps between mesh refinement       = 0
+  set Initial adaptive refinement              = 2
+  set Run postprocessors on initial refinement = true
+  set Normalize individual refinement criteria = true
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2
+    set Y extent  = 2
+    set Box origin X coordinate = -1
+    set Box origin Y coordinate = -1
+  end
+end
+
+subsection Gravity model
+  set Model name = MyGravity
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = x;-z+exp(z)
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants = pi=3.14159265359
+
+    #    set Function expression = if(abs(x)==1 || abs(z)==1, 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * ((x + 0.20e1 * z)^ 0.2e1)), 0)
+    #    set Function expression = 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * ((x + 0.20e1 * z)^ 0.2e1))
+    set Function expression = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * ((x + 0.2e1 * z)^ 0.2e1))
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = test melt material
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, melt error calculation
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/melt_transport_compressible.cc.bak b/tests/melt_transport_compressible.cc.bak
new file mode 100644
index 00000000000..14ecd79b67c
--- /dev/null
+++ b/tests/melt_transport_compressible.cc.bak
@@ -0,0 +1,370 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+namespace aspect
+{
+  template <int dim>
+  class CompressibleMeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual bool is_compressible () const
+      {
+        return true;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        const double permeability = K_D_0 + 2.0 * B / E - rho_s_0 * B * D / E * (1.0/rho_s_0 - 1.0/rho_f_0) * std::exp(0.5);
+        return permeability / 1.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            out.viscosities[i] = 0.5 * std::exp(2.0 * in.position[i][0]);
+            out.thermal_expansion_coefficients[i] = 0.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 1.0 / (rho_s_0 * C);
+            out.densities[i] = rho_s_0 * std::exp(-in.position[i][1]);
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = - rho_s_0 * B * D * std::exp(in.position[i][1]);
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                melt_out->compaction_viscosities[i] = xi_1 * std::exp(-in.position[i][1]) + 2.0/3.0 * std::exp(2.0 * in.position[i][0]) + xi_0;
+                melt_out->fluid_viscosities[i] = 1.0;
+                melt_out->permeabilities[i] = K_D_0 + 2.0 * B / E - rho_s_0 * B * D / E * (1.0/rho_s_0 - 1.0/rho_f_0) * std::exp(in.position[i][1]);
+                const double fluid_compressibility = 1.0 / (rho_f_0 * C);
+                melt_out->fluid_densities[i] = rho_f_0 * std::exp(-in.position[i][1]);
+                melt_out->fluid_density_gradients[i] = melt_out->fluid_densities[i] * melt_out->fluid_densities[i]
+                                                       * fluid_compressibility
+                                                       * this->get_gravity_model().gravity_vector(in.position[i]);
+              }
+          }
+      }
+
+      virtual void initialize ()
+      {
+        rho_s_0 = 1.2;
+        rho_f_0 = 1.0;
+        xi_0 = 1.0;
+        xi_1 = 1.0;
+
+        // A, B and C are constants from the velocity boundary conditions and gravity model
+        // they have to be consistent!
+        A = 0.1;
+        B = -3.0/4.0 * A;
+        C = 1.0;
+        D = 0.3;
+        E = - 3.0/4.0 * xi_0 * A + C * D *(rho_f_0 - rho_s_0);
+
+        K_D_0 = 2.2;
+      }
+
+
+    private:
+      double rho_s_0;
+      double rho_f_0;
+      double xi_0;
+      double xi_1;
+      double K_D_0;
+      double A;
+      double B;
+      double C;
+      double D;
+      double E;
+
+
+  };
+
+
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(2*dim+5) {}
+      virtual void vector_value (const Point<dim>   &p,
+                                 Vector<double>   &values) const
+      {
+        const double x = p(0);
+        const double y = p(1);
+        const double porosity = 1.0 - 0.3 * std::exp(y);
+        const double K_D = 2.2 + 2.0 * 0.075/0.135 + (1.0 - 5.0/6.0) * 0.075 * 0.3 * 1.2 / 0.135 * std::exp(y);
+        const double ref_K_D = 2.2 + 2.0 * 0.075/0.135 + (1.0 - 5.0/6.0) * 0.075 * 0.3 * 1.2 / 0.135 * std::exp(0.5);
+
+        values[0]=0.1 * std::exp(y);       // x vel
+        values[1]=-0.075 * std::exp(y);    // y vel
+        values[2]=-0.135*(std::exp(y) - std::exp(1)) + 1.0 - y;  // p_f
+        values[3]=0.75 * (std::exp(-y) + 2.0/3.0 * std::exp(2.0*x) + 1.0) * 0.1 * std::exp(y);  // p_c_bar
+        values[4]=0.1 * std::exp(y);       // x melt vel
+        values[5]=-0.075 * std::exp(y) + 0.135 * std::exp(y) * K_D / porosity;    // y melt vel
+
+        values[6]=values[2] + values[3] / (1.0 - porosity);  // p_s
+        values[7]=0; // T
+        values[8]=porosity; // porosity
+
+        // We have to scale the compaction pressure solution to p_c_bar using sqrt(K_D / ref_K_D).
+        // K_D is equal to the porosity (as defined in the material model).
+        const double p_c_scale = std::sqrt(K_D / ref_K_D);
+        if (p_c_scale > 0)
+          values[3] /= p_c_scale;
+      }
+  };
+
+  /**
+    * A postprocessor that evaluates the accuracy of the solution
+    * by using the L2 norm.
+    */
+  template <int dim>
+  class CompressibleMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Generate graphical output from the current solution.
+       */
+      virtual
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics);
+
+
+    private:
+      double rho_s_0;
+      double rho_f_0;
+      double xi_0;
+      double xi_1;
+      double K_D_0;
+      double A;
+      double B;
+      double C;
+      double D;
+      double E;
+  };
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  CompressibleMeltPostprocessor<dim>::execute (TableHandler &)
+  {
+    RefFunction<dim> ref_func;
+    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
+
+    const unsigned int n_total_comp = this->introspection().n_components;
+
+    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_c_bar (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
+
+    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                        n_total_comp);
+    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
+    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+dim),
+                                          n_total_comp);
+    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_f);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_c_bar,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_c);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_porosity,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_porosity);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u_f);
+
+
+    // Loop over all cells to compute the error for p_c from p_c_bar
+    const QGauss<dim> quadrature(this->get_parameters().stokes_velocity_degree+1);
+    FEValues<dim> fe_values (this->get_mapping(),
+                             this->get_fe(),
+                             quadrature,
+                             update_quadrature_points | update_values | update_gradients | update_JxW_values);
+
+    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
+    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
+
+    MeltHandler<dim>::create_material_model_outputs(out);
+
+    typename DoFHandler<dim>::active_cell_iterator
+    cell = this->get_dof_handler().begin_active(),
+    endc = this->get_dof_handler().end();
+    for (; cell!=endc; ++cell)
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+          this->get_material_model().evaluate(in, out);
+
+          const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
+
+          const unsigned int i = cell->active_cell_index();
+          cellwise_errors_p_c[i] = cellwise_errors_p_c_bar[i] * p_c_scale;
+        }
+
+    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
+    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
+    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
+    const double p_c_bar_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c_bar, VectorTools::L2_norm);
+    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
+    const double phi_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
+    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
+
+    std::ostringstream os;
+    os << std::scientific << std::sqrt(Utilities::MPI::sum(cellwise_errors_u.norm_sqr(),MPI_COMM_WORLD))
+       << ", " << u_l2
+       << ", " << p_l2
+       << ", " << p_f_l2
+       << ", " << p_c_bar_l2
+       << ", " << p_c_l2
+       << ", " << phi_l2
+       << ", " << u_f_l2;
+
+    return std::make_pair("Errors u_L2, p_L2, p_f_L2, p_c_bar_L2, p_c_L2, porosity_L2, u_f_L2:", os.str());
+  }
+
+
+  template <int dim>
+  class PressureBdry:
+
+    public BoundaryFluidPressure::Interface<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id,
+        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const MaterialModel::MaterialModelOutputs<dim> &,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &output
+      ) const
+      {
+        for (unsigned int q=0; q<output.size(); ++q)
+          {
+            const double rho_s_0 = 1.2;
+            const double rho_f_0 = 1.0;
+            const double xi_0 = 1.0;
+            const double A = 0.1;
+            const double C = 1.0;
+            const double D = 0.3;
+            const double E = - 3.0/4.0 * xi_0 * A + C * D *(rho_f_0 - rho_s_0);
+            const double y = material_model_inputs.position[q][1];
+            Tensor<1,dim> gravity;
+            gravity[dim-1] = 1.0;
+            output[q] = (E * std::exp(y) - rho_f_0 * C) * gravity * normal_vectors[q];
+          }
+      }
+
+
+
+  };
+
+}
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(CompressibleMeltMaterial,
+                                 "compressible melt material",
+                                 "")
+
+
+  ASPECT_REGISTER_POSTPROCESSOR(CompressibleMeltPostprocessor,
+                                "compressible melt error",
+                                "A postprocessor that compares the numerical solution to the analytical "
+                                "solution derived for compressible melt transport in a 2D box as described "
+                                "in the manuscript and reports the error.")
+
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+
+}
diff --git a/tests/melt_transport_compressible.prm.bak b/tests/melt_transport_compressible.prm.bak
new file mode 100644
index 00000000000..039f2472f53
--- /dev/null
+++ b/tests/melt_transport_compressible.prm.bak
@@ -0,0 +1,142 @@
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 50
+
+# This model is very sensitive to nonlinear solver tolerance and sometimes does
+# not quite reach 1e-5, increase to 2e-5 to avoid non-convergence
+set Nonlinear solver tolerance             = 2e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+# A testcase that demonstrates melt transport with a compactible matrix,
+# and compressible matrix and fluid. Boundary conditions for the
+# velocity and fluid pressure as well as porosity initial conditions
+# are applied as described by the derived analytical solution,
+# which can be found in the manuscript on compressible melt transport
+# in ASPECT.
+# We compute these material properties in a new material model, which
+# is implemented in the .cc file, together with a postprocessor to calculate
+# the error and a new pressure boundary condition.
+#
+subsection Discretization
+  # The polynomial degree to use for the composition variable(s). Units:
+  # None.
+  set Composition polynomial degree           = 2
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;-exp(y)
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = 0.1*exp(y);-0.3/4.0*exp(y)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0 - 0.3 * exp(y)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = compressible melt material
+end
+
+subsection Melt settings
+  set Use discontinuous compaction pressure = false
+  set Average melt velocity                 = false
+  set Include melt transport                  = true
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 6
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, compressible melt error
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/melt_transport_compressible_iterative.cc.bak b/tests/melt_transport_compressible_iterative.cc.bak
new file mode 100644
index 00000000000..42941744080
--- /dev/null
+++ b/tests/melt_transport_compressible_iterative.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "melt_transport_compressible.cc"
diff --git a/tests/melt_transport_compressible_iterative.prm.bak b/tests/melt_transport_compressible_iterative.prm.bak
new file mode 100644
index 00000000000..7e95b7e74d5
--- /dev/null
+++ b/tests/melt_transport_compressible_iterative.prm.bak
@@ -0,0 +1,135 @@
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 5
+set Nonlinear solver tolerance             = 1e-6
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+# Identical to melt_transport_compressible.prm except using an iterative
+# solver. Note that because of the low resolution the linear and nonlinear
+# solver tolerance for this test is increased. Higher resolutions converge
+# correctly.
+
+subsection Discretization
+  # The polynomial degree to use for the composition variable(s). Units:
+  # None.
+  set Composition polynomial degree           = 2
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;-exp(y)
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = 0.1*exp(y);-0.3/4.0*exp(y)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0 - 0.3 * exp(y)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = compressible melt material
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 1.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+  set Run postprocessors on initial refinement = true
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, compressible melt error
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-5
+    set Use direct solver for Stokes system = false
+    set GMRES solver restart length = 200
+  end
+end
diff --git a/tests/melt_transport_convergence_simple.cc.bak b/tests/melt_transport_convergence_simple.cc.bak
new file mode 100644
index 00000000000..a96af49bcd7
--- /dev/null
+++ b/tests/melt_transport_convergence_simple.cc.bak
@@ -0,0 +1,326 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+const double c = 1.0;
+
+
+namespace aspect
+{
+  template <int dim>
+  class TestMeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        const double porosity = 0.01;
+        const double permeability = porosity * porosity;
+        return permeability / 1.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            const double porosity = in.composition[i][porosity_idx];
+            const double x = in.position[i](0);
+            const double z = in.position[i](1);
+            out.viscosities[i] = std::exp(c * porosity);
+            out.thermal_expansion_coefficients[i] = 0.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            out.densities[i] = 1.0;
+            // This is the RHS we need to use for the manufactured solution.
+            // We calculated it by subtracting the first term of the RHS (\Nabla (K_D \rho_f g)) from the LHS
+            // we computed using our analytical solution.
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                double porosity = in.composition[i][porosity_idx];
+                melt_out->compaction_viscosities[i] = std::exp(c * porosity);
+                melt_out->fluid_viscosities[i] = 1.0;
+                melt_out->permeabilities[i] = porosity * porosity;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+                melt_out->fluid_densities[i] = 1.0;
+              }
+          }
+      }
+  };
+
+
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(2*dim+5) {}
+      virtual void vector_value (const Point<dim>   &p,
+                                 Vector<double>   &values) const
+      {
+        double x = p(0);
+        double z = p(1);
+        const double porosity = 0.15 + 1.0/20.0 * (numbers::PI/2.0 + std::atan(x + 2*z));
+
+        values[0]= 1.0;       // x vel
+        values[1]= 1.0;    // z vel
+        values[2]= std::exp(z/10.0);  // p_f
+        values[3]= 0;  // p_c
+        values[4]= 1.0;       // x melt vel
+        values[5]= 1.0;    // y melt vel
+        values[6]= std::exp(z/10.0);  // p_s
+        values[7]= 0; // T
+        values[8]= porosity;
+
+        // We have to scale the compaction pressure solution to p_c_bar using sqrt(K_D / ref_K_D).
+        // K_D is equal to the porosity (as defined in the material model).
+        const double K_D = values[8] * values[8];
+        const double ref_K_D = 0.01 * 0.01;
+        const double p_c_scale = std::sqrt(K_D / ref_K_D);
+
+        if (p_c_scale > 0)
+          values[3] /= p_c_scale;
+      }
+  };
+
+  /**
+    * A postprocessor that evaluates the accuracy of the solution
+    * by using the L2 norm.
+    */
+  template <int dim>
+  class ConvergenceMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Generate graphical output from the current solution.
+       */
+      virtual
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics);
+
+  };
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  ConvergenceMeltPostprocessor<dim>::execute (TableHandler &statistics)
+  {
+    RefFunction<dim> ref_func;
+    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
+
+    const unsigned int n_total_comp = this->introspection().n_components;
+
+    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_c_bar (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
+
+    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                        n_total_comp);
+    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
+    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+dim),
+                                          n_total_comp);
+    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_f);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_c_bar,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_c);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_porosity,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_porosity);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u_f);
+
+
+    // Loop over all cells to compute the error for p_c from p_c_bar
+    const QGauss<dim> quadrature(this->get_parameters().stokes_velocity_degree+1);
+    FEValues<dim> fe_values (this->get_mapping(),
+                             this->get_fe(),
+                             quadrature,
+                             update_quadrature_points | update_values | update_gradients | update_JxW_values);
+
+    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
+    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
+
+    MeltHandler<dim>::create_material_model_outputs(out);
+
+    typename DoFHandler<dim>::active_cell_iterator
+    cell = this->get_dof_handler().begin_active(),
+    endc = this->get_dof_handler().end();
+    for (; cell!=endc; ++cell)
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+          this->get_material_model().evaluate(in, out);
+
+          const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
+
+          const unsigned int i = cell->active_cell_index();
+          cellwise_errors_p_c[i] = cellwise_errors_p_c_bar[i] * p_c_scale;
+        }
+
+    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
+    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
+    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
+    const double p_c_bar_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c_bar, VectorTools::L2_norm);
+    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
+    const double poro_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
+    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
+
+    std::ostringstream os;
+    os << std::scientific << u_l2
+       << ", " << p_l2
+       << ", " << p_f_l2
+       << ", " << p_c_bar_l2
+       << ", " << p_c_l2
+       << ", " << poro_l2
+       << ", " << u_f_l2;
+
+    return std::make_pair("Errors u_L2, p_L2, p_f_L2, p_c_bar_L2, p_c_L2, porosity_L2, u_f_L2:", os.str());
+  }
+
+
+  template <int dim>
+  class PressureBdry:
+
+    public BoundaryFluidPressure::Interface<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id boundary_indicator,
+        const typename MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const typename MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &output
+      ) const
+      {
+        for (unsigned int q=0; q<output.size(); ++q)
+          {
+            const double z = material_model_inputs.position[q][1];
+            Tensor<1,dim> gravity;
+            gravity[0] = 0.0;
+            gravity[dim-1] = 1.0;
+            output[q] = 0.1 * std::exp(z/10.0) * gravity * normal_vectors[q];
+          }
+      }
+
+
+
+  };
+
+}
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(TestMeltMaterial,
+                                 "test melt material",
+                                 "")
+
+
+  ASPECT_REGISTER_POSTPROCESSOR(ConvergenceMeltPostprocessor,
+                                "melt error calculation",
+                                "A postprocessor that compares the numerical solution to the analytical "
+                                "solution derived for incompressible melt transport in a 2D box as described "
+                                "in the manuscript and reports the error.")
+
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+
+}
diff --git a/tests/melt_transport_convergence_simple.prm.bak b/tests/melt_transport_convergence_simple.prm.bak
new file mode 100644
index 00000000000..f4e2a3b7a20
--- /dev/null
+++ b/tests/melt_transport_convergence_simple.prm.bak
@@ -0,0 +1,135 @@
+# A testcase that demonstrates melt transport with a compactible matrix,
+# and compressible matrix and fluid. Boundary conditions for the
+# velocity and fluid pressure as well as porosity initial conditions
+# are applied as described by the derived analytical solution,
+# which can be found in the manuscript on compressible melt transport
+# in ASPECT.
+# We compute these material properties in a new material model, which
+# is implemented in the .cc file, together with a postprocessor to calculate
+# the error and a new pressure boundary condition.
+#
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-6
+set Max nonlinear iterations               = 5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 2.718281828
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 20
+    set Y extent  = 20
+    set Box origin X coordinate = -10
+    set Box origin Y coordinate = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Function constants = c=1,pi=3.14159265359
+    set Function expression = 0.0;\
+                              0.1 * exp(z/10.0);
+    set Variable names      = x,z
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = 1.0;1.0
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants = pi=3.14159265359
+    set Function expression = 0.15+1.0/20.0*(pi/2+atan(x+2*z))
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = test melt material
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, melt error calculation
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-10
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/melt_transport_convergence_test.cc.bak b/tests/melt_transport_convergence_test.cc.bak
new file mode 100644
index 00000000000..c87649be7a1
--- /dev/null
+++ b/tests/melt_transport_convergence_test.cc.bak
@@ -0,0 +1,330 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+#include <aspect/simulator.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+namespace aspect
+{
+  template <int dim>
+  class TestMeltMaterial:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        const double porosity = 0.01;
+        const double permeability = porosity * porosity;
+        return permeability / 1.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+        double c = 1.0;
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            const double porosity = in.composition[i][porosity_idx];
+            const double x = in.position[i](0);
+            const double z = in.position[i](1);
+            out.viscosities[i] = exp(c*porosity);
+            out.thermal_expansion_coefficients[i] = 0.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            out.densities[i] = 1.0;
+            // This is the RHS we need to use for the manufactured solution.
+            // We calculated it by subtracting the first term of the RHS (\Nabla (K_D \rho_f g)) from the LHS
+            // we computed using our analytical solution.
+            out.reaction_terms[i][porosity_idx] =
+              0.1000000000e1 + 0.1000000000e0 * (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1))) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) - 0.1000000000e1 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.10e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.20e0 * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.25e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.50e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) - 0.50e-2 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.3e1) * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) - 0.10e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.20e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * pow(x + 0.20e1 * z, 0.3e1)) + 0.1000000000e0 * (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z)) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) - 0.1000000000e1 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.4000e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.400e0 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.25e-2 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.50e-2 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) - 0.50e-2 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.3e1) * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) - 0.4000e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.400e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * pow(x + 0.20e1 * z, 0.3e1) + 0.2500000000e-2 * exp(0.5000000000e-1 * z)) - 0.5000000000e-1 * (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.1166666666e0 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.100e1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1))) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e0 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.2333333332e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.4666666664e0 * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.5833333330e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.20000e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) - 0.2000e0 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) * pow(x + 0.20e1 * z, 0.3e1) - 0.2500e-2 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * (0.2e1 * x + 0.40e1 * z) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) - 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.10e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.20e0 * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.25e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.50e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) - 0.50e-2 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.3e1) * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) - 0.10e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.20e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * pow(x + 0.20e1 * z, 0.3e1)) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.1250000000e-1 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.1166666666e0 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.100e1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1))) * pow(0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) - 0.5000000000e-1 * (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.1666666667e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z)) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e0 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.1333333334e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.1333333334e0 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.8333333335e-3 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.20000e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) - 0.40000e0 * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) * pow(x + 0.20e1 * z, 0.3e1) - 0.2500e-2 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * (0.2e1 * x + 0.40e1 * z) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) - 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.4000e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.400e0 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.25e-2 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.50e-2 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) - 0.50e-2 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.3e1) * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) - 0.4000e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.400e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * pow(x + 0.20e1 * z, 0.3e1) + 0.2500000000e-2 * exp(0.5000000000e-1 * z)) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.1250000000e-1 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.1666666667e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z)) * pow(0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1));
+
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            double c = 1.0;
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                double porosity = in.composition[i][porosity_idx];
+                melt_out->compaction_viscosities[i] = exp(c*porosity);
+                melt_out->fluid_viscosities[i] = 1.0;
+                melt_out->permeabilities[i] = porosity * porosity;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+                melt_out->fluid_densities[i] = 0.5;
+              }
+          }
+      }
+
+  };
+
+
+
+
+  template <int dim>
+  class RefFunction : public Function<dim>
+  {
+    public:
+      RefFunction () : Function<dim>(2*dim+5) {}
+      virtual void vector_value (const Point<dim>   &p,
+                                 Vector<double>   &values) const
+      {
+        double x = p(0);
+        double z = p(1);
+
+        values[0] = x + sin(z);
+        values[1] = x;
+        values[2] = -exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + exp(0.5000000000e-1 * z);
+        values[3] = -exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)));
+        values[4] = x + sin(z) - (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) - 0.5e0 * (0.1166666666e0 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.100e1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1))) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))));
+        values[5] = x - (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z) - 0.5e0 * (0.1666666667e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z)) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))));
+        values[6] = exp(0.5000000000e-1 * z);
+        values[7] = 0;
+        values[8] = 0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1));
+
+        // We have to scale the compaction pressure solution to p_c_bar using sqrt(K_D / ref_K_D).
+        // K_D is equal to the porosity (as defined in the material model).
+        const double K_D = values[8] * values[8];
+        const double ref_K_D = 0.01 * 0.01;
+        const double p_c_scale = std::sqrt(K_D / ref_K_D);
+
+        if (p_c_scale > 0)
+          values[3] /= p_c_scale;
+      }
+  };
+
+
+
+  /**
+    * A postprocessor that evaluates the accuracy of the solution
+    * by using the L2 norm.
+    */
+  template <int dim>
+  class ConvergenceMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      /**
+       * Generate graphical output from the current solution.
+       */
+      virtual
+      std::pair<std::string,std::string>
+      execute (TableHandler &statistics);
+
+  };
+
+  template <int dim>
+  std::pair<std::string,std::string>
+  ConvergenceMeltPostprocessor<dim>::execute (TableHandler &statistics)
+  {
+    RefFunction<dim> ref_func;
+    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
+    const unsigned int n_total_comp = this->introspection().n_components;
+
+    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p_c_bar (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
+
+    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                        n_total_comp);
+    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
+    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+
+                                                                                dim),
+                                          n_total_comp);
+    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
+    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
+
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_f);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_p_c_bar,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_p_c);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_porosity,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_porosity);
+    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                       this->get_solution(),
+                                       ref_func,
+                                       cellwise_errors_u_f,
+                                       quadrature_formula,
+                                       VectorTools::L2_norm,
+                                       &comp_u_f);
+
+
+    // Loop over all cells to compute the error for p_c from p_c_bar
+    const QGauss<dim> quadrature(this->get_parameters().stokes_velocity_degree+1);
+    FEValues<dim> fe_values (this->get_mapping(),
+                             this->get_fe(),
+                             quadrature,
+                             update_quadrature_points | update_values | update_gradients | update_JxW_values);
+
+    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
+    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
+
+    MeltHandler<dim>::create_material_model_outputs(out);
+
+    typename DoFHandler<dim>::active_cell_iterator
+    cell = this->get_dof_handler().begin_active(),
+    endc = this->get_dof_handler().end();
+    for (; cell!=endc; ++cell)
+      if (cell->is_locally_owned())
+        {
+          fe_values.reinit (cell);
+          in.reinit(fe_values, cell, this->introspection(), this->get_solution());
+
+          this->get_material_model().evaluate(in, out);
+
+          const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
+
+          const unsigned int i = cell->active_cell_index();
+          cellwise_errors_p_c[i] = cellwise_errors_p_c_bar[i] * p_c_scale;
+        }
+
+    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
+    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
+    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
+    const double p_c_bar_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c_bar, VectorTools::L2_norm);
+    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
+    const double poro_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
+    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
+
+    std::ostringstream os;
+    os << std::scientific << u_l2
+       << ", " << p_l2
+       << ", " << p_f_l2
+       << ", " << p_c_bar_l2
+       << ", " << p_c_l2
+       << ", " << poro_l2
+       << ", " << u_f_l2;
+
+    return std::make_pair("Errors u_L2, p_L2, p_f_L2, p_c_bar_L2, p_c_L2, porosity_L2, u_f_L2:", os.str());
+  }
+
+
+  template <int dim>
+  class PressureBdry:
+
+    public BoundaryFluidPressure::Interface<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id boundary_indicator,
+        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &output
+      ) const
+      {
+        for (unsigned int q=0; q<output.size(); ++q)
+          {
+            const double x = material_model_inputs.position[q][0];
+            const double z = material_model_inputs.position[q][1];
+            Tensor<1,dim> gradient;
+            gradient[0] = 0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1));
+            gradient[1] = 0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z);
+            output[q] = gradient * normal_vectors[q];
+          }
+      }
+
+
+
+  };
+
+}
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(TestMeltMaterial,
+                                 "test melt material",
+                                 "")
+
+
+  ASPECT_REGISTER_POSTPROCESSOR(ConvergenceMeltPostprocessor,
+                                "melt error calculation",
+                                "A postprocessor that compares the numerical solution to the analytical "
+                                "solution derived for incompressible melt transport in a 2D box as described "
+                                "in the manuscript and reports the error.")
+
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+
+}
diff --git a/tests/melt_transport_convergence_test.prm.bak b/tests/melt_transport_convergence_test.prm.bak
new file mode 100644
index 00000000000..3a65be2ef38
--- /dev/null
+++ b/tests/melt_transport_convergence_test.prm.bak
@@ -0,0 +1,136 @@
+# A testcase that demonstrates melt transport with a compactible matrix,
+# and incompressible matrix and fluid. Boundary conditions for the
+# velocity and fluid pressure as well as porosity initial conditions
+# are applied as described by the derived analytical solution,
+# which can be found in the manuscript on compressible melt transport
+# in ASPECT.
+# We compute these material properties in a new material model, which
+# is implemented in the .cc file, together with a postprocessor to calculate
+# the error and a new pressure boundary condition.
+# An important feature of this setup is the high porosity vein that
+# runs through the model and we use it to demonstrate the effectiveness
+# of adaptive mesh refinement.
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 2.693171882
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = false
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 20
+    set Y extent  = 20
+    set Box origin X coordinate = -10
+    set Box origin Y coordinate = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = function
+
+  subsection Function
+    set Function constants = c=1,pi=3.14159265359
+    set Function expression = (.1166666666*(2*x+4.0*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))+.500e-1*(4.0*x+8.00*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))*(cos(z)+1)+1.00*exp(.1-.5e-1*atan((x+2.0*z)^2))*sin(z)+.5e-1*(2*x+4.0*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))/(-.9-.5e-1*atan((x+2.0*z)^2))-.5e-1*exp(.1-.5e-1*atan((x+2.0*z)^2))/(-.9-.5e-1*atan((x+2.0*z)^2))^2*(2*x+4.0*z)/(1+(x+2.0*z)^4))/(.95+.25e-1*atan((x+2.0*z)^2));\
+                              (.1666666667e-1*(4.0*x+8.00*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))+.500e-1*(2*x+4.0*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))*(cos(z)+1)+.5e-1*(4.0*x+8.00*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))/(-.9-.5e-1*atan((x+2.0*z)^2))-.5e-1*exp(.1-.5e-1*atan((x+2.0*z)^2))/(-.9-.5e-1*atan((x+2.0*z)^2))^2*(4.0*x+8.00*z)/(1+(x+2.0*z)^4)+.5000000000e-1*exp(.5000000000e-1*z))/(.95+.25e-1*atan((x+2.0*z)^2))
+    set Variable names      = x,z
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
+  set Zero velocity boundary indicators       =
+
+  subsection Function
+    set Function expression = x+sin(z);x
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants = pi=3.14159265359
+    set Function expression = 0.1-0.05*atan((x+2.0*z)*(x+2.0*z))
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = test melt material
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.95
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, melt error calculation
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/melt_velocity_boundary_conditions.cc.bak b/tests/melt_velocity_boundary_conditions.cc.bak
new file mode 100644
index 00000000000..e127b3eaeac
--- /dev/null
+++ b/tests/melt_velocity_boundary_conditions.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "free_surface_blob_melt.cc"
diff --git a/tests/melt_velocity_boundary_conditions.prm.bak b/tests/melt_velocity_boundary_conditions.prm.bak
new file mode 100644
index 00000000000..e841e5d409f
--- /dev/null
+++ b/tests/melt_velocity_boundary_conditions.prm.bak
@@ -0,0 +1,154 @@
+# Test for the boundary conditions for the melt velocity
+# (which can not be set explicitly, but are implied by the boundary
+# conditions for the fluid pressure gradient) with melt transport = on
+# and a constant nonzero porosity at the top boundary.
+# The boundary conditions are set in a way that no melt should flow in
+# or out.
+#
+# The test is similar to free_surface_blob_melt, except that melt
+# has a nonzero initial condition, and there is no free surface.
+# We test if the boundary conditions for melt are set correctly
+# (no melt flowing in/out at the top surface) by checking if the
+# velocity field at the upper boundary is small (it should converge to
+# zero with increasing resolution close to the upper surface).
+
+set Dimension = 2
+set CFL number                             = 0.5
+set End time                               = 0
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = surface
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+set Maximum time step                      = 1e4
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = melt free surface
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,3
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.02 * y/2.e5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, visualization, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables =  melt material properties, material properties
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/melt_visco_plastic.cc.bak b/tests/melt_visco_plastic.cc.bak
new file mode 100644
index 00000000000..aaa6ba28bdc
--- /dev/null
+++ b/tests/melt_visco_plastic.cc.bak
@@ -0,0 +1,1038 @@
+/*
+  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _aspect_material_model_melt_visco_plastic_h
+#define _aspect_material_model_melt_visco_plastic_h
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator.h>
+#include <aspect/simulator_access.h>
+#include <aspect/postprocess/melt_statistics.h>
+#include <aspect/melt.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/numerics/fe_field_function.h>
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/base/parsed_function.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * Additional output fields for the plastic parameters weakened (or hardened)
+     * by strain to be added to the MaterialModel::MaterialModelOutputs structure
+     * and filled in the MaterialModel::Interface::evaluate() function.
+     */
+    template <int dim>
+    class PlasticAdditionalOutputs2 : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        PlasticAdditionalOutputs2(const unsigned int n_points);
+
+        virtual std::vector<double> get_nth_output(const unsigned int idx) const;
+
+        /**
+         * Cohesions at the evaluation points passed to
+         * the instance of MaterialModel::Interface::evaluate() that fills
+         * the current object.
+         */
+        std::vector<double> cohesions;
+
+        /**
+         * Internal angles of friction at the evaluation points passed to
+         * the instance of MaterialModel::Interface::evaluate() that fills
+         * the current object.
+         */
+        std::vector<double> friction_angles;
+
+        /**
+         * The area where the viscous stress exceeds the plastic yield strength,
+         * and viscosity is rescaled back to the yield envelope.
+         */
+        std::vector<double> yielding;
+    };
+
+    /**
+     * A material model that implements a simple formulation of the
+     * material parameters required for the modeling of melt transport,
+     * including a source term for the porosity according to the melting
+     * model for dry peridotite of Katz, 2003. This also includes a
+     * computation of the latent heat of melting (if the latent heat
+     * heating model is active).
+     *
+     * Most of the material properties are constant, except for the shear,
+     * compaction and melt viscosities and the permeability, which depend on
+     * the porosity; and the solid and melt densities, which depend on
+     * temperature and pressure.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class MeltViscoPlastic : public MaterialModel::MeltFractionModel<dim>,
+      public MaterialModel::MeltInterface<dim>,
+      public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+
+        /**
+         * Return whether the model is compressible or not.
+         * In this case, Keller et al, 2003 assume the fluid and
+         * solid phases are each incompressible: "compressibility
+         * in the model is accounted for by changes in melt fraction."
+         * Thus, this function will always return false.
+         */
+        bool is_compressible () const override;
+
+        /**
+         * @name Reference quantities
+         * @{
+         */
+        double reference_darcy_coefficient () const override;
+
+        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
+                      typename Interface<dim>::MaterialModelOutputs &out) const override;
+
+        virtual void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                                     std::vector<double> &melt_fractions) const;
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Functions used in dealing with run-time parameters
+         * @{
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+        /**
+         * @}
+         */
+
+        virtual
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
+
+      private:
+
+        double ref_temperature;
+
+        std::vector<double> densities;
+        std::vector<double> thermal_expansivities;
+        std::vector<double> specific_heats;
+        std::vector<double> thermal_conductivities;
+
+        double min_strain_rate;
+        double ref_strain_rate;
+        double min_viscosity;
+        double max_viscosity;
+
+        double ref_viscosity;
+
+        /**
+         * Enumeration for selecting which viscosity averaging scheme to use.
+         */
+        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
+
+        std::vector<double> linear_viscosities;
+
+        std::vector<double> angles_internal_friction;
+        std::vector<double> cohesions;
+
+        double maximum_yield_stress;
+
+        std::vector<double> strength_reductions;
+
+        double melt_density_change;
+        double xi_0;
+        double eta_f;
+        double reference_permeability;
+        double alpha_phi;
+        double freezing_rate;
+        double melting_time_scale;
+
+        /**
+         * Parameters for anhydrous melting of peridotite after Katz, 2003
+         */
+
+        // for the solidus temperature
+        double A1;   // °C
+        double A2; // °C/Pa
+        double A3; // °C/(Pa^2)
+
+        // for the lherzolite liquidus temperature
+        double B1;   // °C
+        double B2;   // °C/Pa
+        double B3; // °C/(Pa^2)
+
+        // for the liquidus temperature
+        double C1;   // °C
+        double C2;  // °C/Pa
+        double C3; // °C/(Pa^2)
+
+        // for the reaction coefficient of pyroxene
+        double r1;     // cpx/melt
+        double r2;     // cpx/melt/GPa
+        double M_cpx;  // mass fraction of pyroxene
+
+        // melt fraction exponent
+        double beta;
+
+        /**
+         * Percentage of material that is molten for a given temperature and
+         * pressure (assuming equilibrium conditions). Melting model after Katz,
+         * 2003, for dry peridotite.
+         */
+        virtual
+        double
+        melt_fraction (const double temperature,
+                       const double pressure) const;
+
+        /**
+         * A function that fills the plastic additional output in the
+         * MaterialModelOutputs object that is handed over, if it exists.
+         * Does nothing otherwise.
+         */
+        void fill_plastic_outputs (const unsigned int point_index,
+                                   const std::vector<double> &volume_fractions,
+                                   const bool plastic_yielding,
+                                   const MaterialModel::MaterialModelInputs<dim> &in,
+                                   MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+        /**
+         * Whether to use a function defined as an input parameter for the melting rate
+         */
+        bool use_melting_rate_function;
+
+        /**
+         * A function object representing the melting rate.
+         */
+        Functions::ParsedFunction<dim> function;
+
+    };
+
+  }
+}
+
+#endif
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    using namespace dealii;
+
+    namespace
+    {
+      std::vector<std::string> make_plastic_additional_outputs_names()
+      {
+        std::vector<std::string> names;
+        names.emplace_back("current_cohesions");
+        names.emplace_back("current_friction_angles");
+        names.emplace_back("plastic_yielding");
+        return names;
+      }
+    }
+
+    template <int dim>
+    PlasticAdditionalOutputs2<dim>::PlasticAdditionalOutputs2 (const unsigned int n_points)
+      :
+      NamedAdditionalMaterialOutputs<dim>(make_plastic_additional_outputs_names()),
+      cohesions(n_points, numbers::signaling_nan<double>()),
+      friction_angles(n_points, numbers::signaling_nan<double>()),
+      yielding(n_points, numbers::signaling_nan<double>())
+    {}
+
+    template <int dim>
+    std::vector<double>
+    PlasticAdditionalOutputs2<dim>::get_nth_output(const unsigned int idx) const
+    {
+      AssertIndexRange (idx, 3);
+      switch (idx)
+        {
+          case 0:
+            return cohesions;
+
+          case 1:
+            return friction_angles;
+
+          case 2:
+            return yielding;
+
+          default:
+            AssertThrow(false, ExcInternalError());
+        }
+      // We will never get here, so just return something
+      return cohesions;
+    }
+
+    template <int dim>
+    double
+    MeltViscoPlastic<dim>::
+    reference_darcy_coefficient () const
+    {
+      // 0.01 = 1% melt
+      return reference_permeability * std::pow(0.01,3.0) / eta_f;
+    }
+
+    template <int dim>
+    bool
+    MeltViscoPlastic<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    double
+    MeltViscoPlastic<dim>::
+    melt_fraction (const double temperature,
+                   const double pressure) const
+    {
+      // anhydrous melting of peridotite after Katz, 2003
+      const double T_solidus  = A1 + 273.15
+                                + A2 * pressure
+                                + A3 * pressure * pressure;
+      const double T_lherz_liquidus = B1 + 273.15
+                                      + B2 * pressure
+                                      + B3 * pressure * pressure;
+      const double T_liquidus = C1 + 273.15
+                                + C2 * pressure
+                                + C3 * pressure * pressure;
+
+      // melt fraction for peridotite with clinopyroxene
+      double peridotite_melt_fraction;
+      if (temperature < T_solidus || pressure > 1.3e10)
+        peridotite_melt_fraction = 0.0;
+      else if (temperature > T_lherz_liquidus)
+        peridotite_melt_fraction = 1.0;
+      else
+        peridotite_melt_fraction = std::pow((temperature - T_solidus) / (T_lherz_liquidus - T_solidus),beta);
+
+      // melt fraction after melting of all clinopyroxene
+      const double R_cpx = r1 + r2 * std::max(0.0, pressure);
+      const double F_max = M_cpx / R_cpx;
+
+      if (peridotite_melt_fraction > F_max && temperature < T_liquidus)
+        {
+          const double T_max = std::pow(F_max,1/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
+          peridotite_melt_fraction = F_max + (1 - F_max) * pow((temperature - T_max) / (T_liquidus - T_max),beta);
+        }
+      return peridotite_melt_fraction;
+    }
+
+    template <int dim>
+    void
+    MeltViscoPlastic<dim>::
+    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
+                    std::vector<double> &melt_fractions) const
+    {
+      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
+        melt_fractions[q] = melt_fraction(in.temperature[q],
+                                          std::max(0.0, in.pressure[q]));
+      return;
+    }
+
+    template <int dim>
+    void
+    MeltViscoPlastic<dim>::
+    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
+    {
+      // 1) Initial viscosities and other material properties
+      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+        {
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
+          out.viscosities[i] = MaterialUtilities::average_value(volume_fractions, linear_viscosities, viscosity_averaging);
+
+          out.densities[i] = MaterialUtilities::average_value(volume_fractions, densities, MaterialUtilities::CompositionalAveragingOperation::arithmetic);
+          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value(volume_fractions, thermal_expansivities, MaterialUtilities::CompositionalAveragingOperation::arithmetic);
+          out.thermal_conductivities[i] = MaterialUtilities::average_value(volume_fractions, thermal_conductivities, MaterialUtilities::CompositionalAveragingOperation::arithmetic);
+          out.specific_heat[i] = MaterialUtilities::average_value(volume_fractions, specific_heats, MaterialUtilities::CompositionalAveragingOperation::arithmetic);
+
+          // TODO: compute the actual number
+          out.entropy_derivative_pressure[i]    = 0.0;
+          out.entropy_derivative_temperature[i] = 0.0;
+        }
+
+      // Store the intrinsic viscosities for computing the compaction viscosities later on
+      // (Keller et al. eq. 51).
+      const std::vector<double> intrinsic_viscosities = out.viscosities;
+
+      // 2) Retrieve fluid pressure and volumetric strain rate
+      std::vector<double> fluid_pressures(in.n_evaluation_points());
+      std::vector<double> volumetric_strain_rates(in.n_evaluation_points());
+      std::vector<double> volumetric_yield_strength(in.n_evaluation_points());
+
+      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
+
+      if (this->include_melt_transport() )
+        {
+          if (in.current_cell.state() == IteratorState::valid)
+            {
+              std::vector<Point<dim>> quadrature_positions(in.n_evaluation_points());
+
+              for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+                quadrature_positions[i] = this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]);
+
+              // FEValues requires a quadrature and we provide the default quadrature
+              // as we only need to evaluate the solution and gradients.
+              FEValues<dim> fe_values (this->get_mapping(),
+                                       this->get_fe(),
+                                       Quadrature<dim>(quadrature_positions),
+                                       update_values | update_gradients);
+
+              fe_values.reinit (in.current_cell);
+
+              // get fluid pressure from the current solution
+              const FEValuesExtractors::Scalar extractor_pressure = this->introspection().variable("fluid pressure").extractor_scalar();
+              fe_values[extractor_pressure].get_function_values (this->get_solution(),
+                                                                 fluid_pressures);
+
+              // get volumetric strain rate
+              // see Keller et al. eq. 11.
+              fe_values[this->introspection().extractors.velocities].get_function_divergences (this->get_solution(),
+                  volumetric_strain_rates);
+            }
+
+          const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
+
+          // 3) Get porosity, melt density and update melt reaction terms
+          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+            {
+              // get peridotite and porosity field indices
+              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+              const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
+
+              const double old_porosity = in.composition[i][porosity_idx];
+              const double maximum_melt_fraction = in.composition[i][peridotite_idx];
+
+              // calculate the melting rate as difference between the equilibrium melt fraction
+              // and the solution of the previous time step
+              double porosity_change = 0.0;
+
+              // batch melting
+              porosity_change = melt_fraction(in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]))
+                                - std::max(maximum_melt_fraction, 0.0);
+              porosity_change = std::max(porosity_change, 0.0);
+
+              // do not allow negative porosity
+              porosity_change = std::max(porosity_change, -old_porosity);
+
+              // because depletion is a volume-based, and not a mass-based property that is advected,
+              // additional scaling factors on the right hand side apply
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                {
+                  if (use_melting_rate_function == false)
+                    {
+                      // fill reaction rate outputs
+                      if (reaction_rate_out != nullptr)
+                        {
+                          if (c == peridotite_idx && this->get_timestep_number() > 0)
+                            reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale
+                                                                      * (1 - maximum_melt_fraction) / (1 - old_porosity);
+                          else if (c == porosity_idx && this->get_timestep_number() > 0)
+                            reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale;
+                          else
+                            reaction_rate_out->reaction_rates[i][c] = 0.0;
+                        }
+
+                      out.reaction_terms[i][c] = 0.0;
+                    }
+                  else
+                    {
+                      // Set reaction rates to 0
+                      if (reaction_rate_out != nullptr)
+                        reaction_rate_out->reaction_rates[i][c] = 0.;
+                      //
+                      if (c == porosity_idx)
+                        out.reaction_terms[i][c] = function.value(in.position[i]) / time_scale * out.densities[i];
+                      else if (c == peridotite_idx)
+                        out.reaction_terms[i][c] = 0.0;
+                    }
+                }
+
+              // 4) Reduce shear viscosity due to melt presence
+              const double porosity = std::min(1.0, std::max(in.composition[i][porosity_idx],0.0));
+              out.viscosities[i] *= exp(- alpha_phi * porosity);
+            }
+        }
+
+      if (in.requests_property(MaterialProperties::viscosity) )
+        {
+          // 5) Compute plastic weakening of the viscosity
+          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+            {
+              // Compute volume fractions
+              const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
+
+              // 4) Compute plastic weakening of visco(elastic) viscosity
+              double porosity = 0.0;
+
+              if (this->include_melt_transport() )
+                porosity = std::min(1.0, std::max(in.composition[i][this->introspection().compositional_index_for_name("porosity")],0.0));
+
+              // calculate deviatoric strain rate (Keller et al. eq. 13)
+              const double edot_ii = ( (this->get_timestep_number() == 0 && in.strain_rate[i].norm() <= std::numeric_limits<double>::min())
+                                       ?
+                                       ref_strain_rate
+                                       :
+                                       std::max(std::sqrt(std::fabs(second_invariant(deviator(in.strain_rate[i])))),
+                                                min_strain_rate) );
+
+              // compute viscous stress
+              const double viscous_stress = 2. * out.viscosities[i] * edot_ii * (1.0 - porosity);
+
+              // In case porosity lies above the melt transport threshold
+              // P_effective = P_bulk - P_f = (1-porosity) * P_s + porosity * P_f - P_f = (1-porosity) * (P_s - P_f)
+              // otherwise,
+              // P_effective = P_bulk, which equals P_solid (which is given by in.pressure[i])
+              const double effective_pressure = ((this->include_melt_transport() && this->get_melt_handler().is_melt_cell(in.current_cell))
+                                                 ?
+                                                 (1. - porosity) * (in.pressure[i] - fluid_pressures[i])
+                                                 :
+                                                 in.pressure[i]);
+
+              double yield_strength = 0.0;
+              double tensile_strength = 0.0;
+
+              for (unsigned int c=0; c< volume_fractions.size(); ++c)
+                {
+                  const double tensile_strength_c = cohesions[c]/strength_reductions[c];
+
+                  // Convert friction angle from degrees to radians
+                  double phi = angles_internal_friction[c] * constants::degree_to_radians;
+                  const double transition_pressure = (cohesions[c] * std::cos(phi) - tensile_strength_c) / (1.0 -  sin(phi));
+
+                  double yield_strength_c = 0.0;
+                  // In case we're not using the Keller et al. formulation,
+                  // or the effective pressure is bigger than the transition pressure, use
+                  // the normal yield strength formulation
+                  if (effective_pressure > transition_pressure || !this->include_melt_transport())
+                    yield_strength_c = ( (dim==3)
+                                         ?
+                                         ( 6.0 * cohesions[c] * std::cos(phi) + 2.0 * effective_pressure * std::sin(phi) )
+                                         / ( std::sqrt(3.0) * (3.0 + std::sin(phi) ) )
+                                         :
+                                         cohesions[c] * std::cos(phi) + effective_pressure * std::sin(phi) );
+                  else
+                    // Note typo in Keller et al. paper eq. (37) (minus sign)
+                    yield_strength_c = tensile_strength_c + effective_pressure;
+
+                  // TODO add different averagings?
+                  yield_strength += volume_fractions[c]*yield_strength_c;
+                  tensile_strength += volume_fractions[c]*tensile_strength_c;
+                }
+
+              bool plastic_yielding = false;
+
+              // If the viscous stress is greater than the yield strength, rescale the viscosity back to yield surface
+              // and reaction term for plastic finite strain
+              if (viscous_stress >= yield_strength)
+                {
+                  plastic_yielding = true;
+                  out.viscosities[i] = yield_strength / (2.0 * edot_ii);
+                }
+
+              // Calculate average internal friction angle and cohesion values
+              const double cohesion = MaterialUtilities::average_value(volume_fractions, cohesions, viscosity_averaging);
+              const double angle_internal_friction = MaterialUtilities::average_value(volume_fractions, angles_internal_friction, viscosity_averaging);
+
+              PlasticAdditionalOutputs2<dim> *plastic_out = out.template get_additional_output<PlasticAdditionalOutputs2<dim>>();
+              if (plastic_out != nullptr)
+                {
+                  plastic_out->cohesions[i] = cohesion;
+                  plastic_out->friction_angles[i] = angle_internal_friction;
+                  plastic_out->yielding[i] = plastic_yielding ? 1 : 0;
+                }
+
+              // Limit the viscosity with specified minimum and maximum bounds
+              out.viscosities[i] = std::min(std::max(out.viscosities[i], min_viscosity), max_viscosity);
+
+              // Compute the volumetric yield strength (Keller et al. eq (38))
+              volumetric_yield_strength[i] = viscous_stress - tensile_strength;
+            }
+        }
+
+      // fill melt outputs if they exist
+      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
+
+      if (melt_out != nullptr)
+        {
+          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+            {
+              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+              double porosity = std::min(1.0, std::max(in.composition[i][porosity_idx],0.0));
+              melt_out->fluid_viscosities[i] = eta_f;
+              melt_out->permeabilities[i] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+
+              melt_out->fluid_densities[i] = out.densities[i] + melt_density_change;
+              melt_out->fluid_density_gradients[i] = 0.0;
+
+              const double compaction_pressure = (1.0 - porosity) * (in.pressure[i] - fluid_pressures[i]);
+
+              const double phi_0 = 0.05;
+              porosity = std::max(std::min(porosity,0.995),1.e-8);
+              // compaction viscosities (Keller et al. eq (51)
+              melt_out->compaction_viscosities[i] = intrinsic_viscosities[i] * phi_0 / porosity;
+
+              // visco(elastic) compaction viscosity
+              // Keller et al. eq (36)
+              // TODO include elastic part
+              melt_out->compaction_viscosities[i] *= (1. - porosity);
+
+              // TODO compaction stress evolution parameter
+              // Keller et al. eq. (41) and (44)
+
+              // effective compaction viscosity (Keller et al. eq (43) )
+              // NB: I've added a minus sign as according to eq 43
+              if (in.strain_rate.size() && compaction_pressure < volumetric_yield_strength[i])
+                {
+                  // the volumetric strain rate might be negative, but will always have the same sign as the volumetric yield strength
+                  if (volumetric_strain_rates[i] >= 0)
+                    volumetric_strain_rates[i] = std::max(volumetric_strain_rates[i], min_strain_rate);
+                  else
+                    volumetric_strain_rates[i] = std::min(volumetric_strain_rates[i], -min_strain_rate);
+                  melt_out->compaction_viscosities[i] = - volumetric_yield_strength[i] / volumetric_strain_rates[i];
+                }
+
+              // Limit the viscosity with specified minimum and maximum bounds
+              melt_out->compaction_viscosities[i] = std::min(std::max(melt_out->compaction_viscosities[i], min_viscosity), max_viscosity);
+            }
+        }
+
+
+    }
+
+
+    template <int dim>
+    void
+    MeltViscoPlastic<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Melt visco plastic");
+        {
+
+          prm.declare_entry ("Reference temperature", "293", Patterns::Double(0),
+                             "For calculating density by thermal expansivity. Units: $K$");
+          prm.declare_entry ("Densities", "3300.",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of densities for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "If only one value is given, then all use the same value.  Units: $kg / m^3$");
+          prm.declare_entry ("Thermal expansivities", "4.e-5",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of thermal expansivities for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "If only one value is given, then all use the same value. Units: $1/K$");
+          prm.declare_entry ("Specific heats", "1250.",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of specific heats $C_p$ for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "If only one value is given, then all use the same value. Units: $J /kg /K$");
+          prm.declare_entry ("Thermal conductivities", "4.7",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of thermal conductivities for background mantle and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "If only one value is given, then all use the same value. Units: $W/m/K$ ");
+
+          prm.declare_entry ("Minimum strain rate", "1.0e-20", Patterns::Double(0),
+                             "Stabilizes strain dependent viscosity. Units: $1 / s$");
+          prm.declare_entry ("Reference strain rate","1.0e-15",Patterns::Double(0),
+                             "Reference strain rate for first time step. Units: $1 / s$");
+          prm.declare_entry ("Minimum viscosity", "1e17", Patterns::Double(0),
+                             "Lower cutoff for effective viscosity. Units: $Pa \\, s$");
+          prm.declare_entry ("Maximum viscosity", "1e28", Patterns::Double(0),
+                             "Upper cutoff for effective viscosity. Units: $Pa \\, s$");
+
+          prm.declare_entry ("Reference viscosity", "1e22", Patterns::Double(0),
+                             "Reference viscosity for nondimensionalization. "
+                             "To understand how pressure scaling works, take a look at "
+                             "\\cite{KHB12}. In particular, the value of this parameter "
+                             "would not affect the solution computed by \\aspect{} if "
+                             "we could do arithmetic exactly; however, computers do "
+                             "arithmetic in finite precision, and consequently we need to "
+                             "scale quantities in ways so that their magnitudes are "
+                             "roughly the same. As explained in \\cite{KHB12}, we scale "
+                             "the pressure during some computations (never visible by "
+                             "users) by a factor that involves a reference viscosity. This "
+                             "parameter describes this reference viscosity."
+                             "\n\n"
+                             "For problems with a constant viscosity, you will generally want "
+                             "to choose the reference viscosity equal to the actual viscosity. "
+                             "For problems with a variable viscosity, the reference viscosity "
+                             "should be a value that adequately represents the order of "
+                             "magnitude of the viscosities that appear, such as an average "
+                             "value or the value one would use to compute a Rayleigh number."
+                             "\n\n"
+                             "Units: $Pa \\, s$");
+
+          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
+                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition "),
+                             "When more than one compositional field is present at a point "
+                             "with different viscosities, we need to come up with an average "
+                             "viscosity at that point.  Select a weighted harmonic, arithmetic, "
+                             "geometric, or maximum composition.");
+
+          prm.declare_entry ("Linear viscosities", "1.e22",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of linear viscosities for background material and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "The values can be used instead of the viscosities derived from the "
+                             "base material model. Units: Pa s.");
+
+          prm.declare_entry ("Angles of internal friction", "0",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of angles of internal friction, $\\phi$, for background material and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "For a value of zero, in 2D the von Mises criterion is retrieved. "
+                             "Angles higher than 30 degrees are harder to solve numerically. Units: degrees.");
+          prm.declare_entry ("Cohesions", "1e20",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of cohesions, $C$, for background material and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "The extremely large default cohesion value (1e20 Pa) prevents the viscous stress from "
+                             "exceeding the yield stress. Units: $Pa$.");
+
+          prm.declare_entry ("Maximum yield stress", "1e12", Patterns::Double(0),
+                             "Limits the maximum value of the yield stress determined by the "
+                             "drucker-prager plasticity parameters. Default value is chosen so this "
+                             "is not automatically used. Values of 100e6--1000e6 $Pa$ have been used "
+                             "in previous models. Units: $Pa$");
+
+          prm.declare_entry ("Host rock strength reductions", "4",
+                             Patterns::List(Patterns::Double(0)),
+                             "List of reduction factors of strength of the host rock under tensile stress, $R$, "
+                             "for background material and compositional fields, "
+                             "for a total of N+1 values, where N is the number of compositional fields. "
+                             "Units: none.");
+
+          prm.declare_entry ("Melt density change", "-500",
+                             Patterns::Double (),
+                             "Difference between solid density $\\rho_{s}$ and melt/fluid$\\rho_{f}$. "
+                             "Units: $kg/m^3$.");
+          prm.declare_entry ("Reference bulk viscosity", "1e22",
+                             Patterns::Double (0),
+                             "The value of the constant bulk viscosity $\\xi_0$ of the solid matrix. "
+                             "This viscosity may be modified by both temperature and porosity "
+                             "dependencies. Units: $Pa s$.");
+          prm.declare_entry ("Reference melt viscosity", "10",
+                             Patterns::Double (0),
+                             "The value of the constant melt viscosity $\\eta_f$. Units: $Pa s$.");
+          prm.declare_entry ("Exponential melt weakening factor", "27",
+                             Patterns::Double (0),
+                             "The porosity dependence of the viscosity. Units: dimensionless.");
+          prm.declare_entry ("Reference permeability", "1e-8",
+                             Patterns::Double(),
+                             "Reference permeability of the solid host rock."
+                             "Units: $m^2$.");
+          prm.declare_entry ("Melting time scale for operator splitting", "1e3",
+                             Patterns::Double (0),
+                             "Because the operator splitting scheme is used, the porosity field can not "
+                             "be set to a new equilibrium melt fraction instantly, but the model has to "
+                             "provide a melting time scale instead. This time scale defines how fast melting "
+                             "happens, or more specifically, the parameter defines the time after which "
+                             "the deviation of the porosity from the equilibrium melt fraction will be "
+                             "reduced to a fraction of $1/e$. So if the melting time scale is small compared "
+                             "to the time step size, the reaction will be so fast that the porosity is very "
+                             "close to the equilibrium melt fraction after reactions are computed. Conversely, "
+                             "if the melting time scale is large compared to the time step size, almost no "
+                             "melting and freezing will occur."
+                             "\n\n"
+                             "Also note that the melting time scale has to be larger than or equal to the reaction "
+                             "time step used in the operator splitting scheme, otherwise reactions can not be "
+                             "computed. "
+                             "Units: yr or s, depending on the ``Use years in output instead of seconds'' parameter.");
+
+          prm.declare_entry ("A1", "1085.7",
+                             Patterns::Double (),
+                             "Constant parameter in the quadratic "
+                             "function that approximates the solidus "
+                             "of peridotite. "
+                             "Units: ${}^\\circ C$.");
+          prm.declare_entry ("A2", "1.329e-7",
+                             Patterns::Double (),
+                             "Prefactor of the linear pressure term "
+                             "in the quadratic function that approximates "
+                             "the solidus of peridotite. "
+                             "Units: ${}^\\circ C/Pa$.");
+          prm.declare_entry ("A3", "-5.1e-18",
+                             Patterns::Double (),
+                             "Prefactor of the quadratic pressure term "
+                             "in the quadratic function that approximates "
+                             "the solidus of peridotite. "
+                             "Units: ${}^\\circ C/(Pa^2)$.");
+          prm.declare_entry ("B1", "1475.0",
+                             Patterns::Double (),
+                             "Constant parameter in the quadratic "
+                             "function that approximates the lherzolite "
+                             "liquidus used for calculating the fraction "
+                             "of peridotite-derived melt. "
+                             "Units: ${}^\\circ C$.");
+          prm.declare_entry ("B2", "8.0e-8",
+                             Patterns::Double (),
+                             "Prefactor of the linear pressure term "
+                             "in the quadratic function that approximates "
+                             "the  lherzolite liquidus used for "
+                             "calculating the fraction of peridotite-"
+                             "derived melt. "
+                             "Units: ${}^\\circ C/Pa$.");
+          prm.declare_entry ("B3", "-3.2e-18",
+                             Patterns::Double (),
+                             "Prefactor of the quadratic pressure term "
+                             "in the quadratic function that approximates "
+                             "the  lherzolite liquidus used for "
+                             "calculating the fraction of peridotite-"
+                             "derived melt. "
+                             "Units: ${}^\\circ C/(Pa^2)$.");
+          prm.declare_entry ("C1", "1780.0",
+                             Patterns::Double (),
+                             "Constant parameter in the quadratic "
+                             "function that approximates the liquidus "
+                             "of peridotite. "
+                             "Units: ${}^\\circ C$.");
+          prm.declare_entry ("C2", "4.50e-8",
+                             Patterns::Double (),
+                             "Prefactor of the linear pressure term "
+                             "in the quadratic function that approximates "
+                             "the liquidus of peridotite. "
+                             "Units: ${}^\\circ C/Pa$.");
+          prm.declare_entry ("C3", "-2.0e-18",
+                             Patterns::Double (),
+                             "Prefactor of the quadratic pressure term "
+                             "in the quadratic function that approximates "
+                             "the liquidus of peridotite. "
+                             "Units: ${}^\\circ C/(Pa^2)$.");
+          prm.declare_entry ("r1", "0.5",
+                             Patterns::Double (),
+                             "Constant in the linear function that "
+                             "approximates the clinopyroxene reaction "
+                             "coefficient. "
+                             "Units: non-dimensional.");
+          prm.declare_entry ("r2", "8e-11",
+                             Patterns::Double (),
+                             "Prefactor of the linear pressure term "
+                             "in the linear function that approximates "
+                             "the clinopyroxene reaction coefficient. "
+                             "Units: $1/Pa$.");
+          prm.declare_entry ("beta", "1.5",
+                             Patterns::Double (),
+                             "Exponent of the melting temperature in "
+                             "the melt fraction calculation. "
+                             "Units: non-dimensional.");
+          prm.declare_entry ("Mass fraction cpx", "0.15",
+                             Patterns::Double (),
+                             "Mass fraction of clinopyroxene in the "
+                             "peridotite to be molten. "
+                             "Units: non-dimensional.");
+
+          prm.declare_entry ("Use melting rate function", "false",
+                             Patterns::Bool (),
+                             "Prescribe the melting rate through a function defined as an input parameter. "
+                             "Units: None");
+
+          prm.enter_subsection("Melting rate function");
+          {
+            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+          }
+          prm.leave_subsection();
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    MeltViscoPlastic<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      //increment by one for background:
+      const unsigned int n_fields = this->n_compositional_fields() + 1;
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Melt visco plastic");
+        {
+
+          ref_temperature = prm.get_double ("Reference temperature");
+          densities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Densities"))),
+                                                              n_fields,
+                                                              "Densities");
+          thermal_expansivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal expansivities"))),
+                                                                          n_fields,
+                                                                          "Thermal expansivities");
+          specific_heats = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Specific heats"))),
+                                                                   n_fields,
+                                                                   "Specific heats");
+          thermal_conductivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal conductivities"))),
+                                                                           n_fields,
+                                                                           "Thermal conductivities");
+
+          min_strain_rate = prm.get_double("Minimum strain rate");
+          ref_strain_rate = prm.get_double("Reference strain rate");
+          min_viscosity = prm.get_double ("Minimum viscosity");
+          max_viscosity = prm.get_double ("Maximum viscosity");
+
+          ref_viscosity = prm.get_double ("Reference viscosity");
+
+          viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
+                                prm);
+
+          linear_viscosities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Linear viscosities"))),
+                                                                       n_fields,
+                                                                       "Linear viscosities");
+
+          angles_internal_friction = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Angles of internal friction"))),
+                                                                             n_fields,
+                                                                             "Angles of internal friction");
+          cohesions = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Cohesions"))),
+                                                              n_fields,
+                                                              "Cohesions");
+
+          maximum_yield_stress = prm.get_double("Maximum yield stress");
+
+          strength_reductions = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Host rock strength reductions"))),
+                                                                        n_fields,
+                                                                        "Host rock strength reductions");
+
+          melt_density_change        = prm.get_double ("Melt density change");
+          xi_0                       = prm.get_double ("Reference bulk viscosity");
+          eta_f                      = prm.get_double ("Reference melt viscosity");
+          reference_permeability     = prm.get_double ("Reference permeability");
+          alpha_phi                  = prm.get_double ("Exponential melt weakening factor");
+          melting_time_scale         = prm.get_double ("Melting time scale for operator splitting");
+
+          A1              = prm.get_double ("A1");
+          A2              = prm.get_double ("A2");
+          A3              = prm.get_double ("A3");
+          B1              = prm.get_double ("B1");
+          B2              = prm.get_double ("B2");
+          B3              = prm.get_double ("B3");
+          C1              = prm.get_double ("C1");
+          C2              = prm.get_double ("C2");
+          C3              = prm.get_double ("C3");
+          r1              = prm.get_double ("r1");
+          r2              = prm.get_double ("r2");
+          beta            = prm.get_double ("beta");
+          M_cpx           = prm.get_double ("Mass fraction cpx");
+
+          use_melting_rate_function  = prm.get_bool ("Use melting rate function");
+
+          if (use_melting_rate_function)
+            {
+              prm.enter_subsection("Melting rate function");
+              try
+                {
+                  function.parse_parameters (prm);
+                }
+              catch (...)
+                {
+                  std::cerr << "ERROR: FunctionParser failed to parse\n"
+                            << "\t'Material model.Melting rate function.Function'\n"
+                            << "with expression\n"
+                            << "\t'" << prm.get("Function expression") << "'"
+                            << "More information about the cause of the parse error \n"
+                            << "is shown below.\n";
+                  throw;
+                }
+              prm.leave_subsection();
+            }
+
+          AssertThrow(this->introspection().compositional_name_exists("peridotite"),
+                      ExcMessage("Material model Melt visco plastic only works if there is a "
+                                 "compositional field called peridotite."));
+
+          if (this->convert_output_to_years() == true)
+            melting_time_scale *= year_in_seconds;
+
+          AssertThrow(melting_time_scale >= this->get_parameters().reaction_time_step,
+                      ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
+                                 + " in the operator splitting scheme is too large to compute melting rates! "
+                                 "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
+                                 "operator splitting' chosen in the material model, which is currently "
+                                 + Utilities::to_string(melting_time_scale) + "."));
+          AssertThrow(melting_time_scale > 0,
+                      ExcMessage("The Melting time scale for operator splitting must be larger than 0!"));
+
+          if (this->include_melt_transport())
+            {
+              AssertThrow(this->introspection().compositional_name_exists("porosity"),
+                          ExcMessage("Material model Melt visco plastic with melt transport only "
+                                     "works if there is a compositional field called porosity."));
+            }
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+    }
+
+    template <int dim>
+    void
+    MeltViscoPlastic<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<PlasticAdditionalOutputs2<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PlasticAdditionalOutputs2<dim>> (n_points));
+        }
+    }
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(MeltViscoPlastic,
+                                   "EXPERIMENTAL melt visco plastic",
+                                   "WARNING: This material model has not been thoroughly tested, "
+                                   "and it is not advised that it be used for any serious models "
+                                   "at this point.\n\n"
+                                   "This material model implements a simple formulation of the "
+                                   "material parameters required for the modeling of melt transport, "
+                                   "including a source term for the porosity according to the melting "
+                                   "model for dry peridotite of \\cite{KSL2003}. All other material "
+                                   "properties are taken from the visco-plastic model.")
+  }
+}
diff --git a/tests/melt_visco_plastic_mohr_circle_compaction.cc.bak b/tests/melt_visco_plastic_mohr_circle_compaction.cc.bak
new file mode 100644
index 00000000000..cacf2ceb305
--- /dev/null
+++ b/tests/melt_visco_plastic_mohr_circle_compaction.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "melt_visco_plastic.cc"
diff --git a/tests/melt_visco_plastic_mohr_circle_compaction.prm b/tests/melt_visco_plastic_mohr_circle_compaction.prm
index d8ed2f4bc8d..c2b990e5858 100644
--- a/tests/melt_visco_plastic_mohr_circle_compaction.prm
+++ b/tests/melt_visco_plastic_mohr_circle_compaction.prm
@@ -46,7 +46,6 @@ subsection Prescribed Stokes solution
   end
 end
 
-
 subsection Material model
   set Model name = EXPERIMENTAL melt visco plastic
 
diff --git a/tests/melt_visco_plastic_mohr_circle_compaction.prm.bak b/tests/melt_visco_plastic_mohr_circle_compaction.prm.bak
new file mode 100644
index 00000000000..d8ed2f4bc8d
--- /dev/null
+++ b/tests/melt_visco_plastic_mohr_circle_compaction.prm.bak
@@ -0,0 +1,163 @@
+# 2d model demonstrating implementation of the constitutive law
+# described by Keller et. al., 2013, including viscoplastic yielding
+# and melt migration.
+#
+# In this test, a velocity field is prescribed that represents
+# simple shear under uniaxial extension. This setup generates
+# output that describes the material model's response to a range
+# of stress conditions, both in resulting effective viscosity, and in
+# velocity of pore fluid flow.
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 293
+set Use years in output instead of seconds = false
+
+# Because this model aims to capture rheological behavior under a range
+# of deformation regimes, we prescribe a flow field in the section called
+# `Prescribed Stokes Solution` below.
+set Nonlinear solver scheme                = single Advection, no Stokes
+set End time                               = 0
+
+##################### Melting and freezing ########################
+
+set Use operator splitting                     = false
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Function expression = 1e6/(2*0.99*1e22)*y^2 + x/(5e22*.99)*(5e7-5e5*x); 0
+  end
+
+  subsection Fluid velocity function
+    set Function expression = 1e6/(2*0.99*1e22)*y^2; 0
+  end
+
+  subsection Pressure function
+    set Function expression = 0
+  end
+
+  subsection Fluid pressure function
+    set Function expression = (1e6*x-5e7)/(-.99)
+  end
+
+  subsection Compaction pressure function
+    set Function expression = max(1e6*x-5e7, 1e6*y-1e7)
+  end
+end
+
+
+subsection Material model
+  set Model name = EXPERIMENTAL melt visco plastic
+
+  subsection Melt visco plastic
+    set Exponential melt weakening factor = 0
+    set Cohesions                         = 4e7
+    set Angles of internal friction       = 30
+    set Minimum strain rate               = 1e-30
+    set Reference strain rate             = 1e-30
+    set Minimum viscosity                 = 10
+    set Maximum viscosity                 = 1e30
+  end
+end
+
+##################### Model geometry ########################
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent      = 250
+    set Y extent      = 160
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+##################### Temperature ########################
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 293
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators =
+end
+
+subsection Heating model
+  set List of model names =
+end
+
+subsection Melt settings
+  set Include melt transport = true
+  set Heat advection by melt = true
+  set Use discontinuous compaction pressure = false
+end
+
+##################### Composition ########################
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.01; 0.01
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   =
+  set List of model names = initial composition
+end
+
+##################### Mesh refinement #########################
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Time steps between mesh refinement       = 0
+end
+
+##################### Postprocessing ########################
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics
+
+  # We mainly want to look at material properties of the solid and the melt.
+  subsection Visualization
+    set List of output variables      = material properties, melt material properties, melt fraction, named additional outputs, stress, strain rate tensor
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+
+    # To see in which cells melt transport is modelled, it can be useful to look
+    # at the property 'is melt cell', so we include it in the output. In addition,
+    # we always visualize the compaction pressure 'p_c' if this postprocessor is
+    # used.
+    subsection Melt material properties
+      set List of properties = compaction viscosity, permeability, fluid density, is melt cell
+    end
+  end
+end
diff --git a/tests/melt_visco_plastic_mohr_circle_shear.cc.bak b/tests/melt_visco_plastic_mohr_circle_shear.cc.bak
new file mode 100644
index 00000000000..cacf2ceb305
--- /dev/null
+++ b/tests/melt_visco_plastic_mohr_circle_shear.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "melt_visco_plastic.cc"
diff --git a/tests/melt_visco_plastic_mohr_circle_shear.prm b/tests/melt_visco_plastic_mohr_circle_shear.prm
index 6a9a756ae1f..12010e10714 100644
--- a/tests/melt_visco_plastic_mohr_circle_shear.prm
+++ b/tests/melt_visco_plastic_mohr_circle_shear.prm
@@ -45,7 +45,6 @@ subsection Prescribed Stokes solution
   end
 end
 
-
 subsection Material model
   set Model name = EXPERIMENTAL melt visco plastic
 
diff --git a/tests/melt_visco_plastic_mohr_circle_shear.prm.bak b/tests/melt_visco_plastic_mohr_circle_shear.prm.bak
new file mode 100644
index 00000000000..6a9a756ae1f
--- /dev/null
+++ b/tests/melt_visco_plastic_mohr_circle_shear.prm.bak
@@ -0,0 +1,162 @@
+# 2d model demonstrating implementation of the constitutive law
+# described by Keller et. al., 2013, including viscoplastic yielding
+# and melt migration.
+#
+# In this test, a velocity field is prescribed that represents
+# simple shear with respect to the model's y-axis. This setup generates
+# output that describes the material model's response to a range
+# of stress conditions.
+
+set Dimension                              = 2
+set Adiabatic surface temperature          = 293
+set Use years in output instead of seconds = false
+
+# Because this model aims to capture rheological behavior under a range
+# of deformation regimes, we prescribe a flow field in the section called
+# `Prescribed Stokes Solution` below.
+set Nonlinear solver scheme                = single Advection, no Stokes
+set End time                               = 0
+
+##################### Melting and freezing ########################
+
+set Use operator splitting                     = false
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Function expression = 1e6/(2*0.99*1e22)*y^2; 0
+  end
+
+  subsection Fluid velocity function
+    set Function expression = 1e6/(2*0.99*1e22)*y^2; 0
+  end
+
+  subsection Pressure function
+    set Function expression = 0
+  end
+
+  subsection Fluid pressure function
+    set Function expression = (1e6*x-5e7)/(-.99)
+  end
+
+  subsection Compaction pressure function
+    set Function expression = 1e6*x-5e7
+  end
+end
+
+
+subsection Material model
+  set Model name = EXPERIMENTAL melt visco plastic
+
+  subsection Melt visco plastic
+    set Exponential melt weakening factor = 0
+    set Cohesions                         = 4e7
+    set Angles of internal friction       = 30
+    set Minimum strain rate               = 1e-30
+    set Reference strain rate             = 1e-30
+    set Minimum viscosity                 = 10
+    set Maximum viscosity                 = 1e30
+  end
+end
+
+##################### Model geometry ########################
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent      = 250
+    set Y extent      = 160
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+##################### Temperature ########################
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 293
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators =
+end
+
+subsection Heating model
+  set List of model names =
+end
+
+subsection Melt settings
+  set Include melt transport = true
+  set Heat advection by melt = true
+  set Use discontinuous compaction pressure = false
+end
+
+##################### Composition ########################
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.01; 0.01
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   =
+  set List of model names = initial composition
+end
+
+##################### Mesh refinement #########################
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Time steps between mesh refinement       = 0
+end
+
+##################### Postprocessing ########################
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics, velocity statistics
+
+  # We mainly want to look at material properties of the solid and the melt.
+  subsection Visualization
+    set List of output variables      = material properties, melt material properties, melt fraction, named additional outputs, stress, strain rate tensor
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+
+    # To see in which cells melt transport is modelled, it can be useful to look
+    # at the property 'is melt cell', so we include it in the output. In addition,
+    # we always visualize the compaction pressure 'p_c' if this postprocessor is
+    # used.
+    subsection Melt material properties
+      set List of properties = compaction viscosity, permeability, fluid density, is melt cell
+    end
+  end
+end
diff --git a/tests/melting_rate.cc.bak b/tests/melting_rate.cc.bak
new file mode 100644
index 00000000000..8133a73311f
--- /dev/null
+++ b/tests/melting_rate.cc.bak
@@ -0,0 +1,126 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/melt.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+using namespace dealii;
+
+
+namespace aspect
+{
+  template <int dim>
+  class MeltingRate:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        return 1e-8 * std::pow(0.01, 3.0) / 10.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+            const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
+
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              {
+                const double x = in.position[i][0] - 100000.0;
+                const double y = in.position[i][1] - 50000.0;
+                const double c0 = 10000.0;
+                const double deltaT = this->get_timestep();
+                if (c == peridotite_idx &&
+                    // check whether we are past the initialization
+                    // phase before the first time step
+                    this->get_timestep_number()!=numbers::invalid_unsigned_int &&
+                    deltaT>0.0)
+                  out.reaction_terms[i][c] = 0.0001 * std::exp(-(x*x+y*y)/(2*c0*c0));
+                else if (c == porosity_idx &&
+                         // check whether we are past the
+                         // initialization phase before the first time
+                         // step
+                         this->get_timestep_number()!=numbers::invalid_unsigned_int &&
+                         deltaT>0.0)
+                  out.reaction_terms[i][c] = 0.0001 * std::exp(-(x*x+y*y)/(2*c0*c0)) * 3000.0 / deltaT;
+                else
+                  out.reaction_terms[i][c] = 0.0;
+              }
+
+            out.viscosities[i] = 5e20;
+            out.densities[i] = 3000.0 * (1 - 2e-5 * (in.temperature[i] - 293.0));
+            out.thermal_expansion_coefficients[i] = 2e-5;
+            out.specific_heat[i] = 1250.0;
+            out.thermal_conductivities[i] = 4.7;
+            out.compressibilities[i] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                const double porosity = in.composition[i][porosity_idx];
+
+                melt_out->compaction_viscosities[i] = 5e20;
+                melt_out->fluid_viscosities[i]= 10.0;
+                melt_out->permeabilities[i]= 1e-8 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+                melt_out->fluid_densities[i]= 2500.0;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+              }
+          }
+      }
+
+  };
+
+
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(MeltingRate,
+                                 "melting rate",
+                                 "")
+}
diff --git a/tests/melting_rate.prm.bak b/tests/melting_rate.prm.bak
new file mode 100644
index 00000000000..1139fff7a9f
--- /dev/null
+++ b/tests/melting_rate.prm.bak
@@ -0,0 +1,138 @@
+#########################################################
+# This is a test for the melting rate functionality
+# It uses a new material model similar to the melt
+# simple model, but with a different melting rate.
+
+# The melting rate has the form of a Gaussian function
+# and every timestep a fixed amount of material is melting.
+
+# The amplitude of the Gaussian is 0.0001, so both the
+# porosity and the peridotite field should increase by
+# this amount (visible in the maximum value).
+
+# Note that the maximum porosity can deviate slightly,
+# as additional melt is created bx compaction.
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 200
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 3
+set CFL number                             = 0.01
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+############### Parameters describing the model
+# Let us here choose again a box domain
+# where we fix the temperature at the bottom and top,
+# allow free slip along the boundaries
+# and include melt migration.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 200000
+    set Y extent = 100000
+    set X repetitions = 2
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1600
+    set Top temperature    = 293
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Melt settings
+  set Include melt transport = true
+end
+
+############### Compositional fields
+# We want to use two compositional fields, the porosity and
+# an additional field, to check if the melting rate functionality
+# has the same effect as the reaction term for the other
+# compositional fields. As the porosity field is advected by
+# a different mechanism, slight differences between the fields
+# are expected.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 1e6
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
+    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
+  end
+end
+
+subsection Material model
+  set Model name = melting rate
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/melting_rate_operator_splitting.prm.bak b/tests/melting_rate_operator_splitting.prm.bak
new file mode 100644
index 00000000000..f6e752e52eb
--- /dev/null
+++ b/tests/melting_rate_operator_splitting.prm.bak
@@ -0,0 +1,154 @@
+#########################################################
+# This is a test for the melting rate functionality,
+# and it is similar to the melting_rate, but uses
+# operator splitting and latent heat of melting.
+
+# We set the temperature in such a way that the initial
+# equilibrium melt fraction would be 0.2, but due to
+# latent heat effects, the temperature gets reduced and
+# the final melt fraction should be 0.1.
+# Likewise, the temperature should be reduced from 1000.2
+# to 1000.1.
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 2e5
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1000.2
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 100
+set CFL number                             = 1.0
+set Maximum time step                      = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use operator splitting                     = true
+
+############### Parameters describing the model
+# Let us here choose again a box domain
+# where we fix the temperature at the bottom and top,
+# allow free slip along the boundaries
+# and include melt migration.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Melt settings
+  set Include melt transport = true
+end
+
+############### Compositional fields
+# We want to use two compositional fields, the porosity and
+# an additional field, to check if the melting rate functionality
+# has the same effect as the reaction term for the other
+# compositional fields. As the porosity field is advected by
+# a different mechanism, slight differences between the fields
+# are expected.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+# We don't need gravity.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 1000.2
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
+    set Function expression = 0.0; 0.0
+  end
+end
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Reference solid density       = 1000
+    set Reference melt density        = 1000
+    set Thermal conductivity          = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Reference shear viscosity     = 1e21
+    set Reference specific heat       = 1000.0
+    set Depletion solidus change      = 0.0
+    set Exponential melt weakening factor = 0.0
+    set Melt extraction depth         = 0.0
+    set Melting time scale for operator splitting = 1.111111111e3
+    set Freezing rate                 = 9e-4
+
+    # simplify the melting model so that porosity depends on temperature linearly
+    set A1 = 726.85   # this is in °C --> 1000 K
+    set A2 = 0
+    set A3 = 0
+    set B1 = 727.85   # this is in °C --> 1001 K
+    set B2 = 0
+    set B3 = 0
+    set C1 = 727.85   # this is in °C --> 1001 K
+    set C2 = 0
+    set C3 = 0
+    set Peridotite melting entropy change = -1.0
+    set Mass fraction cpx = 1.0
+    set r1 = 1.0
+    set r2 = 0.0
+    set beta = 1
+  end
+end
+
+subsection Heating model
+  set List of model names = latent heat melt
+
+  subsection Latent heat melt
+    set Melting entropy change = -1.0
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties, melt fraction
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
+    end
+  end
+end
diff --git a/tests/melting_rate_operator_splitting2.prm.bak b/tests/melting_rate_operator_splitting2.prm.bak
new file mode 100644
index 00000000000..9136beb2df1
--- /dev/null
+++ b/tests/melting_rate_operator_splitting2.prm.bak
@@ -0,0 +1,144 @@
+#########################################################
+# This is a test for the melting rate functionality,
+# and it is the same as the melting_rate_operator_splitting
+# test case, except that is uses the melt global instead
+# of the melt simple material model. This also means that
+# we have to change the absolute temperature values, as
+# this material model has a fixed temperature difference
+# of 500 K between solidus and liquidus.
+
+# We set the temperature in such a way that the initial
+# equilibrium melt fraction would be 2e-3, but due to
+# latent heat effects, the temperature gets reduced and
+# the final melt fraction should be 1e-3.
+# Likewise, the temperature should be reduced from 1001
+# to 1000.5.
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 2e5
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1001
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 100
+set CFL number                             = 1.0
+set Maximum time step                      = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use operator splitting                     = true
+
+############### Parameters describing the model
+# Let us here choose again a box domain
+# where we fix the temperature at the bottom and top,
+# allow free slip along the boundaries
+# and include melt migration.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Melt settings
+  set Include melt transport = true
+end
+
+############### Compositional fields
+# We want to use two compositional fields, the porosity and
+# an additional field, to check if the melting rate functionality
+# has the same effect as the reaction term for the other
+# compositional fields. As the porosity field is advected by
+# a different mechanism, slight differences between the fields
+# are expected.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+# We don't need gravity.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 1001
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
+    set Function expression = 0.0; 0.0
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Reference solid density       = 1000
+    set Reference melt density        = 1000
+    set Thermal conductivity          = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Reference shear viscosity     = 1e21
+    set Reference specific heat       = 1000.0
+    set Exponential melt weakening factor = 0.0
+    set Melting time scale for operator splitting = 1.111111111e3
+
+    # simplify the melting model so that porosity depends on temperature linearly
+    set Surface solidus               = 1000
+    set Pressure solidus change       = 0.0
+    set Depletion solidus change      = 0.0
+  end
+end
+
+subsection Heating model
+  set List of model names = latent heat melt
+
+  subsection Latent heat melt
+    set Melting entropy change = -500.0
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties, melt fraction
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
+    end
+  end
+end
diff --git a/tests/melting_rate_test.prm.bak b/tests/melting_rate_test.prm.bak
new file mode 100644
index 00000000000..6676a4bfd78
--- /dev/null
+++ b/tests/melting_rate_test.prm.bak
@@ -0,0 +1,156 @@
+# Fractionation example.
+# This test is similar to the boukare_melting_diagram,
+# but evolves over time. Consequently, the melt and solid
+# composition in the two-phase region should reflect the
+# melting diagram at the end of the model run.
+
+# To plot the output:
+# gnuplot
+# set view map
+# splot "solution-00000.0000.gnuplot" using 1:2:11 palette
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 2e6
+set Nonlinear solver scheme                = first timestep only, single Stokes
+set Max nonlinear iterations               = 3
+set Pressure normalization                 = surface
+set Surface pressure                       = 120.e9
+set Adiabatic surface temperature          = 5000
+set Use operator splitting = true
+set Maximum time step                      = 1e6
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
+end
+
+subsection Melt settings
+  set Include melt transport               = true
+  set Melt scaling factor threshold        = 1e6
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+
+  subsection Operator splitting parameters
+    set Reaction time step                     = 1e5
+    set Reaction solver type                   = fixed step
+  end
+end
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = amplitude=500, width=50000, b=100000
+    set Function expression = 3400 + 1600 * y
+  end
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 0; x; x
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       =
+  set Prescribed velocity boundary indicators =
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Heating model
+  set List of model names =
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = melt boukare
+
+  subsection Melt boukare
+    set Thermal conductivity          = 8.5
+    set Reference shear viscosity     = 5e22
+    set Thermal viscosity exponent    = 10
+    set Exponential melt weakening factor    = 0
+    set Include melting and freezing  = true
+    set Melting time scale for operator splitting = 1e5
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = composition threshold
+  set Minimum refinement level                 = 0
+
+  subsection Composition threshold
+    set Compositional field thresholds = 0.1,1,1
+  end
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set Output format = gnuplot
+    set List of output variables = material properties, nonadiabatic temperature, melt fraction
+
+    subsection Material properties
+      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
+    end
+  end
+end
diff --git a/tests/memory_statistics_1.prm.bak b/tests/memory_statistics_1.prm.bak
new file mode 100644
index 00000000000..5326b25d703
--- /dev/null
+++ b/tests/memory_statistics_1.prm.bak
@@ -0,0 +1,69 @@
+# Tests whether the 'memory statistics' postprocessor outputs correctly on a
+# minimal problem
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.3
+    set Y extent = 2.2
+    set Z extent = 1.1
+    set Box origin X coordinate = -1.9
+    set Box origin Y coordinate = 2.5
+    set Box origin Z coordinate = 3.1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = memory statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/merged_chunks_2D.prm.bak b/tests/merged_chunks_2D.prm.bak
new file mode 100644
index 00000000000..13b41080b21
--- /dev/null
+++ b/tests/merged_chunks_2D.prm.bak
@@ -0,0 +1,132 @@
+# With this geometry model we add 4 additional boundary
+# indicators to the lithospheric part of the radial
+# boundaries of a chunk.
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+# In 2D the radial boundary indicators are
+# upper|lower east|west.
+# Because we want flow through the upper part of the boundaries
+# we set fixed temperature and composition boundary conditions.
+# For now we set the lower part of the radial boundaries to
+# zero velocity, while prescribing a velocity function on the
+# upper boundaries. Note that this particular example can be accomplished
+# without additional boundary indicators and just prescribing a
+# velocity function on the whole radial boundaries.
+# Along the top and the lithospheric part of the vertical boundaries
+# we prescribe a plate velocity of 1 cm/year.
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = uppereast, upperwest, bottom, top
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = uppereast, upperwest
+end
+
+subsection Geometry model
+  set Model name = chunk with lithosphere boundary indicators
+
+  # We start the outer chunk at a depth of
+  # 150 km
+  subsection Chunk with lithosphere boundary indicators
+    set Chunk inner radius = 3471000
+    set Chunk outer radius = 6371000
+    set Chunk middle boundary radius = 6221000
+    set Inner chunk radius repetitions = 8
+    set Outer chunk radius repetitions = 1
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 40
+    set Longitude repetitions = 8
+    set Chunk minimum latitude = 0
+    set Chunk maximum latitude = 40
+    set Latitude repetitions = 8
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+# We prescribe one compositional field
+# to represent the lithosphere
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities                  = 3300,3250
+    set Reference temperature      = 293
+    set Specific heats             = 1250
+    set Thermal conductivities     = 0.
+    set Thermal expansivities      = 0.
+    set Viscosities                = 1e20,1e22
+    set Viscosity averaging scheme = harmonic
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = uppereast:function, upperwest:function, top:function
+  set Tangential velocity boundary indicators = bottom
+  set Zero velocity boundary indicators       = lowereast, lowerwest
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = vel_mag=0.01
+    set Function expression = -y/sqrt(y*y+x*x)*vel_mag; x/sqrt(y*y+x*x)*vel_mag
+  end
+end
+
+# The lithosphere is represented by a lower density,
+# higher viscosity compositional field.
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = lith_depth=125e3, model_radius=6371e3
+    set Function expression = if(sqrt(x*x+y*y)<(model_radius-lith_depth),0,1)
+  end
+end
+
+# We look at the velocity statistics; max velocity will be
+# the prescribed velocity of 1 cm/year. The boundary indicator
+# visualization shows us the indicators we set at the boundaries.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = boundary indicators
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/merged_chunks_2D_one_grid.prm.bak b/tests/merged_chunks_2D_one_grid.prm.bak
new file mode 100644
index 00000000000..92f6a66d36e
--- /dev/null
+++ b/tests/merged_chunks_2D_one_grid.prm.bak
@@ -0,0 +1,13 @@
+# exactly the same as merged_chunks_2D.prm but made with one grid
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/merged_chunks_2D.prm
+
+
+subsection Geometry model
+  subsection Chunk with lithosphere boundary indicators
+    set Use merged grids = false
+    set Inner chunk radius repetitions = 9
+  end
+end
diff --git a/tests/merged_chunks_3D.prm.bak b/tests/merged_chunks_3D.prm.bak
new file mode 100644
index 00000000000..939200acc4a
--- /dev/null
+++ b/tests/merged_chunks_3D.prm.bak
@@ -0,0 +1,140 @@
+# With this geometry model we add 4 additional boundary
+# indicators to the radial boundaries of a chunk.
+
+set Dimension                              = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600
+set Surface pressure                       = 0
+set Pressure normalization                 = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+# In 3D the radial boundary indicators are
+# upper|lower east|west|south|north.
+# Because we want flow through the upper part of the boundaries
+# we set fixed temperature and composition boundary conditions.
+# For now we set the lower part of the radial boundaries to
+# zero velocity, while prescribing a velocity function on the
+# upper boundaries. Note that this particular example can be accomplished
+# without additional boundary indicators and just prescribing a
+# velocity function on the whole radial boundaries.
+# Along the top and the lithospheric part of the vertical boundaries
+# we prescribe a plate velocity of 1 cm/year.
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = uppereast, upperwest, uppernorth, uppersouth, bottom, top
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = uppereast, upperwest, uppernorth, uppersouth, top
+end
+
+subsection Geometry model
+  set Model name = chunk with lithosphere boundary indicators
+
+  # We start the outer chunk at a depth of
+  # 150 km
+  subsection Chunk with lithosphere boundary indicators
+    set Chunk inner radius = 5771000
+    set Chunk outer radius = 6371000
+    set Chunk middle boundary radius = 6221000
+    set Inner chunk radius repetitions = 3
+    set Outer chunk radius repetitions = 1
+    set Chunk minimum longitude = -20
+    set Chunk maximum longitude = 20
+    set Longitude repetitions = 8
+    set Chunk minimum latitude = -20
+    set Chunk maximum latitude = 20
+    set Latitude repetitions = 8
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600
+  end
+end
+
+# We prescribe one compositional field
+# to represent the lithosphere
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities                  = 3300,3250
+    set Reference temperature      = 293
+    set Specific heats             = 1250
+    set Thermal conductivities     = 0.
+    set Thermal expansivities      = 0.
+    set Viscosities                = 1e20,1e21
+    set Viscosity averaging scheme = harmonic
+  end
+end
+
+# NB To see the additional boundary indicators,
+# add one level of adaptive refinement
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = uppernorth:function, uppersouth:function, uppereast:function, \
+                                                upperwest:function, outer:function
+  set Tangential velocity boundary indicators = bottom
+  set Zero velocity boundary indicators       = lowereast, lowerwest, lowernorth, lowersouth
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = vel_mag=0.01
+    set Function expression = -y/sqrt(z*z+y*y+x*x)*vel_mag; x/sqrt(z*z+y*y+x*x)*vel_mag; 0
+  end
+end
+
+# The lithosphere is represented by a lower density,
+# higher viscosity compositional field.
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = lith_depth=125e3, model_radius=6371e3
+    set Function expression = if(sqrt(x*x+y*y+z*z)<(model_radius-lith_depth),0,1)
+  end
+end
+
+# We look at the velocity statistics; max velocity will be
+# the prescribed velocity of 1 cm/year. The boundary indicator
+# visualization shows us the indicators we set at the boundaries.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = boundary indicators
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/merged_chunks_3D_one_grid.prm.bak b/tests/merged_chunks_3D_one_grid.prm.bak
new file mode 100644
index 00000000000..ffe825d540e
--- /dev/null
+++ b/tests/merged_chunks_3D_one_grid.prm.bak
@@ -0,0 +1,13 @@
+# exactly the same as merged_chunks_3D.prm but made with one grid
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/tests/merged_chunks_3D.prm
+
+
+subsection Geometry model
+  subsection Chunk with lithosphere boundary indicators
+    set Use merged grids = false
+    set Inner chunk radius repetitions = 4
+  end
+end
diff --git a/tests/mesh_deformation_gmg_2d_spherical_shell.prm.bak b/tests/mesh_deformation_gmg_2d_spherical_shell.prm.bak
new file mode 100644
index 00000000000..e6b32e89711
--- /dev/null
+++ b/tests/mesh_deformation_gmg_2d_spherical_shell.prm.bak
@@ -0,0 +1,96 @@
+# This input file tests gmg solver with
+# mesh deformation in a spherical shell geometry
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 1
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                         = 1e-1
+    set Stokes solver type                              = block GMG
+    set Number of cheap Stokes solver steps             = 5000
+    set GMRES solver restart length                     = 1000
+    set Maximum number of expensive Stokes solver steps = 0
+    set Use full A block as preconditioner              = true
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/mesh-deformation/ascii-data/
+    set Data file name = spherical_shell_2d.txt
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 3700
+    set Outer temperature = 273
+  end
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average only viscosity
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators       = bottom, top
+end
+
+# The minimum and maximum topography in the ascii file is 3km and 400 km, respectively.
+# The topography statistics should be within these bounds.
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, topography
+
+  subsection Topography
+    set Output to file = true
+    set Time between text output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = surface elevation
+    set Output format      = gnuplot
+  end
+end
diff --git a/tests/mesh_deformation_particles.cc.bak b/tests/mesh_deformation_particles.cc.bak
new file mode 100644
index 00000000000..9e7806dd0cd
--- /dev/null
+++ b/tests/mesh_deformation_particles.cc.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_signals.h>
+#include <aspect/simulator_access.h>
+#include <aspect/particle/world.h>
+#include <deal.II/particles/particle_handler.h>
+
+#include <iostream>
+
+using namespace aspect;
+
+
+template <int dim>
+void post_mesh_deformation (const SimulatorAccess<dim> &simulator_access)
+{
+  // Get the reference location of the one particle,
+  // and check that it has the correct value.
+  const Point<dim> predicted_particle_reference_location =
+    simulator_access.get_particle_world(0).get_particle_handler().begin()->get_reference_location();
+  // At timestep 0, the mesh is not deformed
+  // other than through the initial topography/
+  // initial mesh deformation plugins, which
+  // are not active in this test.
+  // At timestep 1, the surface of the mesh is
+  // upwardly displaced by dt*v_surf = 0.5*1.0 = 0.5.
+  // The new surface lies therefore at 1.5.
+  // Because the particle does not move (Stokes velocity
+  // is set to zero), the vertical coordinate of the particle
+  // reference location within the one cell of the mesh
+  // should be updated from 0.5/1.0 to 0.5/1.5 = 1/3.
+  Point<dim> correct_particle_reference_location;
+  correct_particle_reference_location[0] = 0.5;
+  if (simulator_access.get_timestep_number() == 0)
+    correct_particle_reference_location[dim-1] = 0.5;
+  else if (simulator_access.get_timestep_number() == 1)
+    correct_particle_reference_location[dim-1] = 1./3.;
+  else
+    Assert(false, ExcNotImplemented());
+
+  AssertThrow(predicted_particle_reference_location == correct_particle_reference_location,
+              ExcMessage("The particle reference location is not correct."));
+}
+
+
+template <int dim>
+void signal_connector (SimulatorSignals<dim> &signals)
+{
+  signals.post_mesh_deformation.connect (&post_mesh_deformation<dim>);
+}
+
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/mesh_deformation_particles.prm.bak b/tests/mesh_deformation_particles.prm.bak
new file mode 100644
index 00000000000..f25a8106bcd
--- /dev/null
+++ b/tests/mesh_deformation_particles.prm.bak
@@ -0,0 +1,85 @@
+# Benchmark for free surface with particles
+
+set Dimension = 2
+set End time                               = 0.5
+set Start time                             = 0
+set Nonlinear solver scheme                = single Advection, no Stokes
+set CFL number                             = 1.0
+set Maximum first time step                = 0.5
+set Pressure normalization                 = no
+set Use years in output instead of seconds = false
+set Output directory                       = mesh_def_particles
+
+subsection Prescribed Stokes solution
+  set Model name = function
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set X repetitions = 1
+    set Y repetitions = 1
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: boundary function
+  set Additional tangential mesh velocity boundary indicators = left, right
+
+  subsection Boundary function
+    set Function expression = 0;if(y<1,0,1)
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set List of output variables      =
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell = 1
+  set Maximum particles per cell = 1
+  set List of particle properties = initial position, position, reference position
+  set Particle generator name = uniform box
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.5
+      set Maximum x = 1
+      set Minimum y = 0.5
+      set Maximum y = 1
+      set Number of particles = 1
+    end
+  end
+end
diff --git a/tests/mesh_velocity_output.prm.bak b/tests/mesh_velocity_output.prm.bak
new file mode 100644
index 00000000000..3385beb467e
--- /dev/null
+++ b/tests/mesh_velocity_output.prm.bak
@@ -0,0 +1,121 @@
+# Test for outputting ALE mesh velocity with a free surface
+
+set Dimension = 2
+set CFL number                             = 0.5
+set End time                               = 1e9
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, basic statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output mesh velocity = true
+    set Output format = gnuplot
+    set Time between graphical output = 0.
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/mid_ocean_ridge.prm.bak b/tests/mid_ocean_ridge.prm.bak
new file mode 100644
index 00000000000..f43ca715461
--- /dev/null
+++ b/tests/mid_ocean_ridge.prm.bak
@@ -0,0 +1,26 @@
+# Copy of the mid-ocean ridge cookbook, with temperature dependent
+# compaction viscosity.
+
+include $ASPECT_SOURCE_DIR/cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm
+
+set End time = 1e4
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Thermal bulk viscosity exponent = 7
+  end
+end
+
+subsection Postprocess
+  subsection Visualization
+    set Interpolate output = false
+    set Output format      = gnuplot
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 3
+end
diff --git a/tests/minimum_refinement_function.prm.bak b/tests/minimum_refinement_function.prm.bak
new file mode 100644
index 00000000000..3703f21fc5a
--- /dev/null
+++ b/tests/minimum_refinement_function.prm.bak
@@ -0,0 +1,154 @@
+# Listing of Parameters
+# ---------------------
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+
+# MPI: 2
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.33
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Additional refinement times              =
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 3
+  set Initial global refinement                = 3
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = max
+  set Run postprocessors on initial refinement = true
+  set Strategy                                 = temperature, minimum refinement function
+  set Time steps between mesh refinement       = 1
+
+  subsection Minimum refinement function
+    set Function constants  =
+
+    # This is in fact the default value
+    set Coordinate system   = depth
+
+    # The following lines are equal to set the line:
+    # set Function expression = 4 + 2*sin(x*pi/250000)
+    # which implies:
+    # set Variable names    = x,y
+    # because that is the default value for Variable names.
+    # To illustrate the possibility to rename function variables
+    # in your favourite naming scheme we use the following:
+    set Variable names      = depth,not_used1
+    set Function expression = 4 + 2*sin(depth*pi/250000)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/minimum_refinement_function_cartesian.prm.bak b/tests/minimum_refinement_function_cartesian.prm.bak
new file mode 100644
index 00000000000..7490b1bda0b
--- /dev/null
+++ b/tests/minimum_refinement_function_cartesian.prm.bak
@@ -0,0 +1,144 @@
+# Listing of Parameters
+# ---------------------
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+
+# MPI: 2
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.33
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Additional refinement times              =
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 3
+  set Initial global refinement                = 3
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = max
+  set Run postprocessors on initial refinement = true
+  set Strategy                                 = temperature, minimum refinement function
+  set Time steps between mesh refinement       = 1
+
+  subsection Minimum refinement function
+    set Coordinate system      = cartesian
+    set Function constants     =
+    set Function expression    = 4 + 2*sin(x*pi/250000)*sin(y*pi/250000)
+    set Variable names         = x,y
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/minimum_refinement_function_spherical.prm.bak b/tests/minimum_refinement_function_spherical.prm.bak
new file mode 100644
index 00000000000..cff1ad1da42
--- /dev/null
+++ b/tests/minimum_refinement_function_spherical.prm.bak
@@ -0,0 +1,136 @@
+# Copy of the minimum_refinement_function_cartesian test, adjusted to
+# spherical geometry and refinement coordinates. The minimum refinement
+# formula in this test uses spherical coordinates and refines exactly
+# those regions of the model that are assigned the highest temperatures
+# by the initial condition 'harmonic perturbation'.
+
+# MPI: 2
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.33
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 250000
+    set Outer radius  = 500000
+    set Opening angle = 90
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Additional refinement times              =
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 3
+  set Initial global refinement                = 2
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = max
+  set Run postprocessors on initial refinement = true
+  set Strategy                                 = minimum refinement function
+  set Time steps between mesh refinement       = 1
+
+  subsection Minimum refinement function
+    set Coordinate system      = spherical
+    set Function constants     =
+    set Function expression    = 2 + 3*sin((r+250000)*pi/250000)*sin(6*phi)
+    set Variable names         = r,phi
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/minimum_refinement_function_time_dependent.prm.bak b/tests/minimum_refinement_function_time_dependent.prm.bak
new file mode 100644
index 00000000000..00172c2131d
--- /dev/null
+++ b/tests/minimum_refinement_function_time_dependent.prm.bak
@@ -0,0 +1,154 @@
+# Listing of Parameters
+# ---------------------
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+
+# MPI: 2
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 5e9
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.33
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Additional refinement times              =
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 3
+  set Initial global refinement                = 3
+  set Normalize individual refinement criteria = true
+  set Refinement criteria merge operation      = max
+  set Run postprocessors on initial refinement = true
+  set Strategy                                 = temperature, minimum refinement function
+  set Time steps between mesh refinement       = 1
+
+  subsection Minimum refinement function
+    set Function constants  =
+
+    # This is in fact the default value
+    set Coordinate system   = depth
+
+    # The following lines are equal to set the line:
+    # set Function expression = 4 + 2*sin(x*pi/250000-t/6e8)
+    # which implies:
+    # set Variable names    = x,y
+    # because that is the default value for Variable names.
+    # To illustrate the possibility to rename function variables
+    # in your favourite naming scheme we use the following:
+    set Variable names      = depth,not_used1,t
+    set Function expression = 4 + 2*sin(depth*pi/250000-t/6e8)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors = basic statistics
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      =
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/modified_tait_forsterite_box.prm.bak b/tests/modified_tait_forsterite_box.prm.bak
new file mode 100644
index 00000000000..62aa4ac9ccf
--- /dev/null
+++ b/tests/modified_tait_forsterite_box.prm.bak
@@ -0,0 +1,101 @@
+# This test ensures that the Modified Tait
+# material model works with compositional fields
+# enabled
+
+set Dimension                              = 2
+set End time                               = 0
+set Adiabatic surface temperature          = 1000
+
+subsection Compositional fields
+  set Number of fields          = 1
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent                = 400e3
+    set X repetitions           = 1
+    set Y extent                = 400e3
+    set Y repetitions           = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 1000 + y/400
+  end
+end
+
+# The following properties are for forsterite.
+# They are taken from Holland and Powell (2011).
+# Note that the heat capacity function had to be converted
+# from a molar basis to mass basis
+# (Cp(specific) = Cp(molar)/molar_mass)
+# The Einstein temperature is calculated empirically from the
+# expression in Holland and Powell
+# (Einstein temperature  = 10636 / (S/n + 6.44)), where
+# S is the standard state molar entropy and n is the number of atoms
+# per formula unit.
+
+subsection Material model
+  set Model name         = modified tait
+
+  subsection Modified Tait model
+    set Reference pressure = 1e5
+    set Reference temperature = 298.15
+    set Reference density = 3222.5
+    set Reference isothermal bulk modulus = 128.5e9
+    set Reference bulk modulus derivative = 3.84
+    set Reference thermal expansivity = 2.85e-5
+    set Einstein temperature = 531.117
+
+    subsection Reference heat capacity function
+      set Variable names = T
+      set Function expression = (233.3 + 0.001494*T - 603800.0/T/T - 1869.7/sqrt(T))/0.1406931
+    end
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = material properties
+    set Time between graphical output = 0
+    set Number of grouped files       = 0
+
+    subsection Material properties
+      set List of material properties = density, thermal expansivity, specific heat
+    end
+  end
+end
diff --git a/tests/morency_doin.cc.bak b/tests/morency_doin.cc.bak
new file mode 100644
index 00000000000..f97acda03ad
--- /dev/null
+++ b/tests/morency_doin.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../cookbooks/morency_doin_2004/morency_doin.h"
+#include "../cookbooks/morency_doin_2004/morency_doin.cc"
diff --git a/tests/morency_doin.prm.bak b/tests/morency_doin.prm.bak
new file mode 100644
index 00000000000..1d19ee59b5b
--- /dev/null
+++ b/tests/morency_doin.prm.bak
@@ -0,0 +1,100 @@
+set Dimension = 2
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent    = 3000e3
+    set Y extent    = 750e3
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields  = upper_crust, lower_crust
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = if(y>=725e3,1,0);if((y<725e3&y>700e3),1,0)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=750e3, w=3000e3
+    set Function expression = \
+      if( y < 100e3, \
+        (100e3-y)/100e3*100+1635, \
+        if(y>650e3, \
+          (h-y)/(100e3)*1342+293, \
+          1635))
+  end
+end
+
+subsection Material model
+  set Model name = Morency and Doin
+
+  subsection Morency and Doin
+    set Densities = 3300,2700,2700
+    set Activation energies = 500,320,320
+    set Coefficient of yield stress increase with depth = 0.25
+    set Thermal expansivities = 2e-5
+    set Stress exponents for viscous rheology = 3
+    set Stress exponents for plastic rheology = 30
+    set Thermal diffusivity = 0.8e-6
+    set Heat capacity = 1.25e3
+    set Activation volume = 6.4e-6
+    set Reference strain rate = 6.4e-16
+    set Preexponential constant for viscous rheology law = 7e11 ## Value used in paper is 1.24e14
+    set Cohesive strength of rocks at the surface = 117
+    set Reference temperature = 293
+    set Minimum strain rate = 5e-19                             ## Value used in paper is 1.4e-20
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                 = 5
+  set Initial adaptive refinement               = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = depth average
+
+  subsection Depth average
+    set Number of zones = 32
+    set Output format = gnuplot
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 0
+end
diff --git a/tests/multicomponent_arithmetic.prm.bak b/tests/multicomponent_arithmetic.prm.bak
new file mode 100644
index 00000000000..e99f3107107
--- /dev/null
+++ b/tests/multicomponent_arithmetic.prm.bak
@@ -0,0 +1,128 @@
+# Test the multicomponent material model using arithmetic
+# averaging for viscosity. Three blobs with different
+# densities and different viscosities move around...
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 2e7
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0.0
+    set Bottom temperature = 0.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 28.e5
+    set Y extent = 7.e5
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-5.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1, 0)
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature = 0.0
+    set Densities = 3300, 3200, 3600,3400
+    set Specific heats = 1250
+    set Thermal conductivities = 4.7
+    set Thermal expansivities = 4e-5
+    set Viscosities = 1.e21, 1.e20, 1.e23, 1.e22
+    set Viscosity averaging scheme = arithmetic
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = composition
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( sqrt((x-12.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1,0); if( sqrt((x-17.e5)^2 + (y-3.e5)^2) < 5.e4, 1, 0)
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step                  = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity,density
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/multicomponent_compressible_averaging.prm.bak b/tests/multicomponent_compressible_averaging.prm.bak
new file mode 100644
index 00000000000..f71093e38ba
--- /dev/null
+++ b/tests/multicomponent_compressible_averaging.prm.bak
@@ -0,0 +1,129 @@
+# This test checks that the correct averaging is done by the
+# multicomponent compressible material model. In this test,
+# two materials are chosen, with constant mass fractions of 0.5.
+# At the reference temperature (273 K) and at 0 GPa pressure,
+# materials 1 and 2 have densities of 2000 kg/m^3 and 3000 kg/m^3,
+# which equates to volume fractions of 0.6 and 0.4.
+#
+# The outputs for the properties at 0 GPa and 273 K are then:
+# Density: 2400 kg/m^3 (volume averaged, 0.6*2000 + 0.4*3000)
+# Thermal_expansivity: 2.4e-5 (volume averaged, 0.6*2e-5 + 0.4*3e-5)
+# Isochoric specific_heat: 1500 (mass averaged, 0.5*1000 + 0.5*2000)
+# Viscosity: 2.4e20 (arithmetically volume averaged, 0.6*2.e20 + 0.4*3.e20)
+# Thermal conductivity: 2.4 (volume averaged, 0.6*2 + 0.4*3)
+# Isobaric specific heat: 1527.3 (mass averaged, 0.5*1027.3 + 0.5*2027.3)
+# (because isobaric specific heat Cp = Cv + T*alpha^2/(rho*beta_T))
+#
+# At other pressure-temperature conditions, the volume
+# fractions change despite the mass fractions remaining constant.
+
+set CFL number                             = 1.0
+set End time                               = 0.
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name         = multicomponent compressible
+
+  subsection Multicomponent compressible
+    set Reference temperatures = 273.
+    set Reference densities = 2000., 3000.
+    set Reference isothermal compressibilities = 2e-12, 3e-12
+    set Isothermal bulk modulus pressure derivatives = 4, 4
+    set Reference thermal expansivities = 2.e-5, 3.e-5
+    set Isochoric specific heats = 1000., 2000.
+    set Thermal conductivities = 2., 3.
+    set Viscosities = 2.e20, 3.e20
+    set Viscosity averaging scheme = arithmetic
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, basic statistics, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = material properties, thermal conductivity
+    set Time between graphical output = 0
+
+    subsection Vp anomaly
+      set Number of depth slices = 12
+    end
+
+    subsection Vs anomaly
+      set Number of depth slices = 12
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/multicomponent_geometric.prm.bak b/tests/multicomponent_geometric.prm.bak
new file mode 100644
index 00000000000..2d5e80b85bc
--- /dev/null
+++ b/tests/multicomponent_geometric.prm.bak
@@ -0,0 +1,128 @@
+# Test the multicomponent material model using geometric
+# averaging for viscosity. Three blobs with different
+# densities and different viscosities move around...
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 2e7
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0.0
+    set Bottom temperature = 0.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 28.e5
+    set Y extent = 7.e5
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-5.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1, 0)
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature = 0.0
+    set Densities = 3300, 3200, 3600,3400
+    set Specific heats = 1250
+    set Thermal conductivities = 4.7
+    set Thermal expansivities = 4e-5
+    set Viscosities = 1.e21, 1.e20, 1.e23, 1.e22
+    set Viscosity averaging scheme = geometric
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = composition
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( sqrt((x-12.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1,0); if( sqrt((x-17.e5)^2 + (y-3.e5)^2) < 5.e4, 1, 0)
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step                  = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity,density
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/multicomponent_harmonic.prm.bak b/tests/multicomponent_harmonic.prm.bak
new file mode 100644
index 00000000000..50b8e9e15f2
--- /dev/null
+++ b/tests/multicomponent_harmonic.prm.bak
@@ -0,0 +1,128 @@
+# Test the multicomponent material model using harmonic
+# averaging for viscosity. Three blobs with different
+# densities and different viscosities move around...
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 2e7
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0.0
+    set Bottom temperature = 0.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 28.e5
+    set Y extent = 7.e5
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-5.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1, 0)
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature = 0.0
+    set Densities = 3300, 3200, 3600,3400
+    set Specific heats = 1250
+    set Thermal conductivities = 4.7
+    set Thermal expansivities = 4e-5
+    set Viscosities = 1.e21, 1.e20, 1.e23, 1.e22
+    set Viscosity averaging scheme = harmonic
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = composition
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( sqrt((x-12.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1,0); if( sqrt((x-17.e5)^2 + (y-3.e5)^2) < 5.e4, 1, 0)
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step                  = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity,density
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/multicomponent_max_composition.prm.bak b/tests/multicomponent_max_composition.prm.bak
new file mode 100644
index 00000000000..f7e6b3df599
--- /dev/null
+++ b/tests/multicomponent_max_composition.prm.bak
@@ -0,0 +1,128 @@
+# Test the multicomponent material model using maximum composition
+# averaging for viscosity. Three blobs with different
+# densities and different viscosities move around...
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 2e7
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0.0
+    set Bottom temperature = 0.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 28.e5
+    set Y extent = 7.e5
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-5.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1, 0)
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature = 0.0
+    set Densities = 3300, 3200, 3600,3400
+    set Specific heats = 1250
+    set Thermal conductivities = 4.7
+    set Thermal expansivities = 4e-5
+    set Viscosities = 1.e21, 1.e20, 1.e23, 1.e22
+    set Viscosity averaging scheme = maximum composition
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = composition
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( sqrt((x-12.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1,0); if( sqrt((x-17.e5)^2 + (y-3.e5)^2) < 5.e4, 1, 0)
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step                  = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity,density
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/multicomponent_steinberger.prm.bak b/tests/multicomponent_steinberger.prm.bak
new file mode 100644
index 00000000000..dff155ef20a
--- /dev/null
+++ b/tests/multicomponent_steinberger.prm.bak
@@ -0,0 +1,121 @@
+# Test the multicomponent steinberger material model. Three blobs with different viscosities move around.
+# The reference viscosity of background is from the radial viscosity profile of Steinberger & Calderwood 2006.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 60000
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 1600
+set Surface pressure                       = 0
+set Pressure normalization = surface
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators = top, bottom, left, right
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom, left, right
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2.e6
+    set Y extent = 2.e6
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 1600
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-5.e5)^2) < 2.e5 , 1,0); if( sqrt((x-10.e5)^2 + (y-15.e5)^2 ) < 2.e5, 1,0); if( sqrt((x-15.e5)^2 + (y-10.e5)^2) < 2.e5, 1, 0)
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Use lateral average temperature for viscosity = false
+    set Data directory                                = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Radial viscosity file name                    = radial-visc.txt
+    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
+    set Composition viscosity prefactors              = 1, 5, 0.1, 10
+    set Material file names                           = pyr-ringwood88.txt, pyr-ringwood88.txt, pyr-ringwood88.txt, pyr-ringwood88.txt
+    set Minimum viscosity                             = 1e19
+    set Maximum viscosity                             = 1e24
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = composition, viscosity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step                  = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity,density
+    set Output format                 = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/multiple_named_additional_outputs.cc.bak b/tests/multiple_named_additional_outputs.cc.bak
new file mode 100644
index 00000000000..8f019a5f76c
--- /dev/null
+++ b/tests/multiple_named_additional_outputs.cc.bak
@@ -0,0 +1,112 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class PrescribedFieldMaterial : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+        virtual
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    PrescribedFieldMaterial<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      Simple<dim>::evaluate(in, out);
+
+      // set up variable to interpolate prescribed field outputs onto compositional fields
+      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
+
+      if (prescribed_field_out != nullptr)
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          {
+            const double y = in.position[i](1);
+            prescribed_field_out->prescribed_field_outputs[i][1] = std::exp(-y*y/2.0);
+          }
+
+      SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>();
+
+      if (seismic_out != nullptr)
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          {
+            const double y = in.position[i](1);
+            seismic_out->vp[i] = std::exp(-y*y/3.0);
+            seismic_out->vs[i] = -std::exp(-y*y/3.0);
+          }
+    }
+
+
+    template <int dim>
+    void
+    PrescribedFieldMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points,this->n_compositional_fields()));
+        }
+
+      if (out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedFieldMaterial,
+                                   "prescribed field material",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but creates prescribed field outputs.")
+  }
+}
diff --git a/tests/multiple_named_additional_outputs.prm.bak b/tests/multiple_named_additional_outputs.prm.bak
new file mode 100644
index 00000000000..809d89ee914
--- /dev/null
+++ b/tests/multiple_named_additional_outputs.prm.bak
@@ -0,0 +1,99 @@
+# A testcase that demonstrates the named additional outputs postprocessor for multiple
+# named outputs. The test is based on prescribed_field_with_diffusion only
+# with more than one additional output.
+
+set Dimension = 2
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+
+subsection Solver parameters
+  subsection Diffusion solver parameters
+    set Diffusion length scale = 0.23241476
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 0.1
+    set Y extent = 10
+    set Y repetitions = 100
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields  = normal_field, diffused_field
+  set Compositional field methods = field, prescribed field with diffusion
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.1
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0; 0.0
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = top
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 0; 0
+  end
+end
+
+subsection Material model
+  set Model name = prescribed field material
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = named additional outputs
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/muparser-temperature-example.prm.bak b/tests/muparser-temperature-example.prm.bak
new file mode 100644
index 00000000000..5f785a7a607
--- /dev/null
+++ b/tests/muparser-temperature-example.prm.bak
@@ -0,0 +1,149 @@
+# Basic parameter file for using a function expression to define the
+# initial temperature structure using (? : ) syntax for if-else conditions.
+# 2D, Dimensional, Boussinesq, Simple Material Model
+
+# Dimension, end-time (years) and output directory
+# Only does zeroth time-step to show that initial condition works
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output-muparser-temperature-example
+
+# Parameters Related to the Solver and Pressure Normalization
+
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Even when using the Boussinesq approximation you need to set this parameter
+# because this will be the temperature used to calculate the reference density
+# used in the advection equation (even if a separate reference temperature is
+# specified by the material model)
+
+set Adiabatic surface temperature          = 273 # K
+
+# If you have a large model or a model with large viscosity variation and you
+# want to run the 0th timestep more quickly in order to just check in the initial
+# condition (IC), you can set these solver tolerance values to larger numbers, but
+# this means the solution will not be converged.
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance            = 1e-6 # can set to 1e-3 for checking IC
+  end
+end
+
+# The following is equivalent to the Boussinesq approximation
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation = incompressible
+  set Temperature equation = reference density profile
+end
+
+# Want a 2D box 5000 km wide by 1000 km deep (5e6 x 1e6 meters).
+# The variable repetitions divides the whole domain into 5 boxes (1000 x 1000 km)
+# as the 0th level mesh refinement: this is needed so elements are squares
+# and not elongated rectangles.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 5e6
+    set Y extent = 1e6
+    set X repetitions = 5
+    set Y repetitions = 1
+  end
+end
+
+# Refine the upper 150 km of the mesh so lithosphere structure is resolved.
+# Function expression asks if the depth is less than the lithosphere depth and
+# then refinement level = 5, else  refinement level = 0
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Minimum refinement level           = 1
+  set Initial adaptive refinement        = 2
+  set Time steps between mesh refinement = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function constants  = ymax=1e6,lith=1.5e5
+    set Function expression = ((ymax-y<=lith) ? 5 : 0)
+  end
+end
+
+# Half-space cooling model increasing with age from x>0 to xtr
+# For x>xtr, half-space cooling model with a fixed age.
+# Note, we use 1-erfc instead of erf because the muparser in dealii
+# only knows about erfc. Also, we need to use ymax-y since y=0 at the
+# bottom of the box
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = ymax=1.0e6, xtrm=2.200e6, vsub=7.927e-10, \
+                               ageop=9.46e14, Tm=1673, Ts=273, kappa=1e-6
+    set Function expression = (((x>0.0) && (x<=xtrm)) ? \
+                                 (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*(x/vsub)))))) : \
+                                 (x>xtrm) ? \
+                                  (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*ageop))))) :\
+                                  (Tm) )
+  end
+end
+
+# Set boundary types and values for temperature
+# Default is zero-flux (keep for sidewalls), so only need set top and bottom to fixed temperature
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1673
+    set Top temperature    = 273
+  end
+end
+
+# Free-slip on all sides (tangential velocity V-perp=0, dV/dn=0)
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300  # kg/m^3
+    set Reference specific heat       = 1250  # J/kg/K
+    set Reference temperature         = 273   # K
+    set Thermal conductivity          = 4.125 # W/m/K
+    set Thermal expansion coefficient = 2e-5  # 1/K
+    set Viscosity                     = 1e21  # Pa s
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics
+
+  subsection Visualization
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+end
diff --git a/tests/n_expensive_stokes_solver_steps.prm.bak b/tests/n_expensive_stokes_solver_steps.prm.bak
new file mode 100644
index 00000000000..f4173d0b6fe
--- /dev/null
+++ b/tests/n_expensive_stokes_solver_steps.prm.bak
@@ -0,0 +1,160 @@
+# Test depth-dependent material model in 2d box using simple material model as
+# base model with no depth-dependence
+
+# EXPECT FAILURE
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = true
+set End time                               = 1.0e8
+
+#set Output directory                       = output
+
+# Then there are variables that describe the tolerance of
+# the linear solver as well as how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+
+
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.0e6
+    set Y extent = 3.0e6
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
+    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above. (As will be seen
+# in the next section, the actual temperature prescribed here
+# at the left and right does not matter.)
+# We then also have to prescribe several other parts of the model such as
+# which boundaries actually carry a prescribed boundary temperature, whereas
+# all other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 2773
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 273.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = depth dependent
+
+  subsection Depth dependent model
+    set Base model = simple
+    set Depth dependence method = None
+    set Reference viscosity = 1e25
+  end
+
+  subsection Simple model
+    set Reference density             = 3300.0
+    set Reference specific heat       = 1250.0
+    set Reference temperature         = 0
+    set Thermal conductivity          = 4.0
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e25
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set Number of cheap Stokes solver steps = 0
+    set Maximum number of expensive Stokes solver steps = 5
+  end
+end
diff --git a/tests/natural_coordinates_conversion.cc.bak b/tests/natural_coordinates_conversion.cc.bak
new file mode 100644
index 00000000000..adc504dbe67
--- /dev/null
+++ b/tests/natural_coordinates_conversion.cc.bak
@@ -0,0 +1,217 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/geometry_model/box.h>
+#include <aspect/geometry_model/chunk.h>
+#include <aspect/geometry_model/ellipsoidal_chunk.h>
+#include <aspect/geometry_model/two_merged_boxes.h>
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
+#include <aspect/simulator_access.h>
+#include <limits>
+
+int f()
+{
+  using namespace aspect;
+  // test whether the functions return the inverse of each other.
+
+  // test point
+  Point<2> point_2d(25000,50000);
+  Point<3> point_3d(25000,25000,50000);
+
+  std::array<double,2> inter_point_2d;
+  std::array<double,3> inter_point_3d;
+  Point<2> new_point_2d = Point<2>();
+  Point<3> new_point_3d= Point<3>();
+  // get the supported geometries
+  std::cout << std::endl << "2D:" << std::endl;
+  // Box 2D
+  {
+    GeometryModel::Box<2> box;
+    ParameterHandler prm_box;
+    box.declare_parameters(prm_box);
+    prm_box.enter_subsection("Geometry model");
+    prm_box.enter_subsection("Box");
+    prm_box.set("X extent", "100e3");
+    prm_box.set("Y extent", "100e3");
+    prm_box.leave_subsection();
+    prm_box.leave_subsection();
+    box.parse_parameters(prm_box);
+
+    inter_point_2d = box.cartesian_to_natural_coordinates(point_2d);
+    new_point_2d = box.natural_to_cartesian_coordinates(inter_point_2d);
+
+    if (std::fabs(new_point_2d(0) - point_2d(0)) < 1e-8 &&
+        std::fabs(new_point_2d(1) - point_2d(1)) < 1e-8)
+      std::cout << "Box 2D ok:                   point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
+    else
+      std::cout << "Box 2D failed:               point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
+  }
+
+  // Two merged boxes 2d
+  {
+    GeometryModel::TwoMergedBoxes<2> two_merged_boxes;
+    ParameterHandler prm_two_merged_boxes;
+    two_merged_boxes.declare_parameters(prm_two_merged_boxes);
+    prm_two_merged_boxes.enter_subsection("Geometry model");
+    prm_two_merged_boxes.enter_subsection("Box with lithosphere boundary indicators");
+    prm_two_merged_boxes.set("X extent", "100e3");
+    prm_two_merged_boxes.set("Y extent", "100e3");
+    prm_two_merged_boxes.leave_subsection();
+    prm_two_merged_boxes.leave_subsection();
+    two_merged_boxes.parse_parameters(prm_two_merged_boxes);
+    inter_point_2d = two_merged_boxes.cartesian_to_natural_coordinates(point_2d);
+    new_point_2d = two_merged_boxes.natural_to_cartesian_coordinates(inter_point_2d);
+
+    if (std::fabs(new_point_2d(0) - point_2d(0)) < 1e-8 &&
+        std::fabs(new_point_2d(1) - point_2d(1)) < 1e-8)
+      std::cout << "Two merged boxes 2d ok:      point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
+    else
+      std::cout << "Two merged boxes 2d failed:  point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
+  }
+
+  // Chunk 2d
+  {
+    GeometryModel::Chunk<2> chunk;
+    ParameterHandler prm_chunk;
+    chunk.declare_parameters(prm_chunk);
+    prm_chunk.enter_subsection("Geometry model");
+    prm_chunk.enter_subsection("Chunk");
+    prm_chunk.set("Chunk inner radius", "6128137.0");
+    prm_chunk.set("Chunk outer radius", "6378137.0");
+    prm_chunk.leave_subsection();
+    prm_chunk.leave_subsection();
+    chunk.parse_parameters(prm_chunk);
+
+    inter_point_2d = chunk.cartesian_to_natural_coordinates(point_2d);
+    new_point_2d = chunk.natural_to_cartesian_coordinates(inter_point_2d);
+
+    if (std::fabs(new_point_2d(0) - point_2d(0)) < 1e-8 &&
+        std::fabs(new_point_2d(1) - point_2d(1)) < 1e-8)
+      std::cout << "Chunk 2D ok:                 point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
+    else
+      std::cout << "Chunk 2D failed:             point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
+
+  }
+  std::cout << std::endl << "3D:" << std::endl;
+  // Box 3D
+  {
+    GeometryModel::Box<3> box;
+    //box.initialize(topo);
+    ParameterHandler prm_box;
+    box.declare_parameters(prm_box);
+    prm_box.enter_subsection("Geometry model");
+    prm_box.enter_subsection("Box");
+    prm_box.set("X extent", "100e3");
+    prm_box.set("Y extent", "100e3");
+    prm_box.set("Z extent", "200e3");
+    prm_box.leave_subsection();
+    prm_box.leave_subsection();
+    box.parse_parameters(prm_box);
+
+    inter_point_3d = box.cartesian_to_natural_coordinates(point_3d);
+    new_point_3d = box.natural_to_cartesian_coordinates(inter_point_3d);
+
+    if (std::fabs(new_point_3d(0) - point_3d(0)) < 1e-8 &&
+        std::fabs(new_point_3d(1) - point_3d(1)) < 1e-8 &&
+        std::fabs(new_point_3d(2) - point_3d(2)) < 1e-8)
+      std::cout << "Box 3D ok:                   point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
+    else
+      std::cout << "Box 3D failed:               point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
+  }
+
+  // Two merged boxes 3d
+  {
+    GeometryModel::TwoMergedBoxes<3> two_merged_boxes;
+    ParameterHandler prm_two_merged_boxes;
+    two_merged_boxes.declare_parameters(prm_two_merged_boxes);
+    prm_two_merged_boxes.enter_subsection("Geometry model");
+    prm_two_merged_boxes.enter_subsection("Box with lithosphere boundary indicators");
+    prm_two_merged_boxes.set("X extent", "100e3");
+    prm_two_merged_boxes.set("Y extent", "100e3");
+    prm_two_merged_boxes.set("Z extent", "200e3");
+    prm_two_merged_boxes.leave_subsection();
+    prm_two_merged_boxes.leave_subsection();
+    two_merged_boxes.parse_parameters(prm_two_merged_boxes);
+    inter_point_3d = two_merged_boxes.cartesian_to_natural_coordinates(point_3d);
+    new_point_3d = two_merged_boxes.natural_to_cartesian_coordinates(inter_point_3d);
+
+    if (std::fabs(new_point_3d(0) - point_3d(0)) < 1e-8 &&
+        std::fabs(new_point_3d(1) - point_3d(1)) < 1e-8 &&
+        std::fabs(new_point_3d(2) - point_3d(2)) < 1e-8)
+      std::cout << "Two merged boxes 3d ok:      point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
+    else
+      std::cout << "Two merged boxes 3d failed:  point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
+  }
+
+  // Chunk 3d
+  {
+    GeometryModel::Chunk<3> chunk;
+    ParameterHandler prm_chunk;
+    chunk.declare_parameters(prm_chunk);
+    prm_chunk.enter_subsection("Geometry model");
+    prm_chunk.enter_subsection("Chunk");
+    prm_chunk.set("Chunk inner radius", "6128137.0");
+    prm_chunk.set("Chunk outer radius", "6378137.0");
+    prm_chunk.leave_subsection();
+    prm_chunk.leave_subsection();
+    chunk.parse_parameters(prm_chunk);
+
+    inter_point_3d = chunk.cartesian_to_natural_coordinates(point_3d);
+    new_point_3d = chunk.natural_to_cartesian_coordinates(inter_point_3d);
+
+    if (std::fabs(new_point_3d(0) - point_3d(0)) < 1e-8 &&
+        std::fabs(new_point_3d(1) - point_3d(1)) < 1e-8 &&
+        std::fabs(new_point_3d(2) - point_3d(2)) < 1e-8)
+      std::cout << "Chunk 3D ok:                 point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", new_point = " << new_point_3d << std::endl;
+    else
+      std::cout << "Chunk 3D failed:             point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", new_point = " << new_point_3d << std::endl;
+  }
+
+  // Ellipsoidal chunk 3d
+  {
+    GeometryModel::EllipsoidalChunk<3> ellipsoidal_chunk;
+    ParameterHandler prm_ellispoidal_chunk;
+    ellipsoidal_chunk.declare_parameters(prm_ellispoidal_chunk);
+    prm_ellispoidal_chunk.enter_subsection("Geometry model");
+    prm_ellispoidal_chunk.enter_subsection("Ellipsoidal chunk");
+    prm_ellispoidal_chunk.set("NE corner", "10:10");
+    prm_ellispoidal_chunk.set("SW corner", "0:0");
+    prm_ellispoidal_chunk.leave_subsection();
+    prm_ellispoidal_chunk.leave_subsection();
+    ellipsoidal_chunk.parse_parameters(prm_ellispoidal_chunk);
+    inter_point_3d = ellipsoidal_chunk.cartesian_to_natural_coordinates(point_3d);
+    new_point_3d = ellipsoidal_chunk.natural_to_cartesian_coordinates(inter_point_3d);
+
+    if (std::fabs(new_point_3d(0) - point_3d(0)) < 1e-8 &&
+        std::fabs(new_point_3d(1) - point_3d(1)) < 1e-8 &&
+        std::fabs(new_point_3d(2) - point_3d(2)) < 1e-8)
+      std::cout << "Ellipsoidal 3d chunk ok:     point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
+    else
+      std::cout << "Ellipsoidal 3d chunk failed: point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
+  }
+
+
+  exit(0);
+  return 42;
+}
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/natural_coordinates_conversion.prm.bak b/tests/natural_coordinates_conversion.prm.bak
new file mode 100644
index 00000000000..e7f90049811
--- /dev/null
+++ b/tests/natural_coordinates_conversion.prm.bak
@@ -0,0 +1 @@
+set Additional shared libraries = tests/libnatural_coordinates_conversion.so
diff --git a/tests/netcdf_boundary_velocity_2d_box.prm.bak b/tests/netcdf_boundary_velocity_2d_box.prm.bak
new file mode 100644
index 00000000000..65f0788c9a5
--- /dev/null
+++ b/tests/netcdf_boundary_velocity_2d_box.prm.bak
@@ -0,0 +1,71 @@
+# Test netcdf data loaded into StructuredData and used as a boundary velocity
+#
+# test copied from ascii_data_boundary_velocity_2d_box.prm and modified
+# box_2d_left.0.nc is converted from data/boundary-velocity/ascii-data/test/box_2d_left.0.txt
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0.01
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3300000
+    set Y extent = 660000
+    set X repetitions = 5
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Amplitude = 300
+    set Radius    = 250000
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top,bottom
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left: ascii data, right: ascii data
+  set Zero velocity boundary indicators = top,bottom
+
+  subsection Ascii data model
+    set Data file name       = box_2d_left.0.nc
+    set Data directory = $ASPECT_SOURCE_DIR/data/test/netcdf/
+    set Scale factor = 0.01
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/newton_postprocess_nonlinear.prm.bak b/tests/newton_postprocess_nonlinear.prm.bak
new file mode 100644
index 00000000000..b563800640c
--- /dev/null
+++ b/tests/newton_postprocess_nonlinear.prm.bak
@@ -0,0 +1,175 @@
+# This test makes sure that postprocessing nonlinear iterations works
+# with the Newton solver scheme.
+
+#  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
+set Nonlinear solver tolerance             = 1e-4
+set Max nonlinear iterations               = 5
+set CFL number                             = 0.5
+set Maximum time step                      = 5
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+
+# Solver parameters
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block AMG
+    set Linear solver tolerance = 1e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+
+  subsection Newton solver parameters
+    set Max Newton line search iterations        = 5
+    set Max pre-Newton nonlinear iterations      = 200
+    set Maximum linear Stokes solver tolerance   = 1e-1
+    set Nonlinear Newton solver switch tolerance = 1e-4
+    set SPD safety factor                        = 0.9
+    set Stabilization preconditioner             = SPD
+    set Stabilization velocity block             = SPD
+    set Use Newton failsafe                      = false
+    set Use Newton residual scaling method       = false
+    set Use Eisenstat Walker method for Picard iterations = true
+  end
+end
+
+# Model geometry (100x100 km, initial 50 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 2
+    set Y repetitions = 2
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Globally refine to 3.125 km grid spacing
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Velocity boundary conditions (5e-9 m/s on each boundary)
+# The imposed velocity produces a background strain-rate
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = left x: function, right x:function, top y: function, bottom y: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = vel=0.15778463
+    set Function expression = if (x<50e3 , vel, -vel); if (y<50e3, -vel, vel);
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, block,                air,                  inclusion
+  set Types of fields  = stress,       stress,       stress,       chemical composition, chemical composition, chemical composition
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; \
+                              if ( ( x<43.75e3 && y>25.e3 && y<75.e3) || (x>56.25e3 && y>25.e3 && y<75.e3) || (y>56.25e3 && y<75.e3 && x>=43.75e3 && x<=56.25e3) || (y<43.75e3 && y>25.e3 && x>=43.75e3 && x<=56.25e3), 1, 0); \
+                              if (y<=25.e3 || y>=75.e3, 1, 0); \
+                              if (y<=56.25e3 && y>=43.75e3 && x>=43.75e3 && x<=56.25e3, 1, 0);
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Fixed composition boundary indicators  =
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# Temperature initial conditions (isothermal)
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.
+  end
+end
+
+# Material model
+subsection Material model
+  set Material averaging = none
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Densities                   = 2700
+    set Reference strain rate       = 1.e-13
+    set Maximum viscosity           = 1.e23
+    set Minimum viscosity           = 1.e17
+    set Prefactors for dislocation creep          = 5e-24, 1e-50, 1e-50, 1e-50, 5e-24, 5.e-18, 5e-18
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 1e50
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 5e3
+    set Viscosity averaging scheme  = harmonic
+    set Angles of internal friction = 37., 0., 0., 0., 37., 0., 0.
+    set Cohesions                   = 100.e6, 1.e50, 1.e50, 1.e50, 100.e6, 10.e6, 10.e6
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, velocity statistics, visualization
+  set Run postprocessors on nonlinear iterations = true
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate, named additional outputs
+    set Time between graphical output = 0e3
+    set Interpolate output = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+end
+
+# Termination criteria
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/tests/no_Advection_iterated_defect_correction_Stokes.prm.bak b/tests/no_Advection_iterated_defect_correction_Stokes.prm.bak
new file mode 100644
index 00000000000..fa9414f79ba
--- /dev/null
+++ b/tests/no_Advection_iterated_defect_correction_Stokes.prm.bak
@@ -0,0 +1,127 @@
+#########################################################
+# This is a model setup to test the iterated Advection and Stokes solver.
+# Both the calculation of the residuum and the convergence
+# with prescribed boundary conditions are tested.
+
+set Adiabatic surface temperature          = 0
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = no Advection, iterated defect correction Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+
+  subsection Stabilization parameters
+    set beta  = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 150000
+    set Y extent  = 65000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 0
+    set Thermal expansion coefficient = 1
+    set Thermal viscosity exponent = 0.0
+    set Reference specific heat = 1.0
+    set Reference density = 1.0
+    set Reference temperature = 0
+    set Viscosity = 1e16
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-2
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/no_adiabatic_heating.cc.bak b/tests/no_adiabatic_heating.cc.bak
new file mode 100644
index 00000000000..439e10250a9
--- /dev/null
+++ b/tests/no_adiabatic_heating.cc.bak
@@ -0,0 +1,57 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// use the same postprocessing facilities as for the
+// 'compressibility_iterated_stokes' testcase
+#include "compressibility_iterated_stokes.cc"
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class NoAdiabaticHeating : public CompressibilityIteratedStokes<dim>
+    {
+      public:
+        virtual double thermal_expansion_coefficient (const double,
+                                                      const double,
+                                                      const std::vector<double> &,
+                                                      const Point<dim> &) const
+        {
+          return 0;
+        }
+    };
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(NoAdiabaticHeating,
+                                   "no adiabatic heating",
+                                   "As described in the .prm file.")
+  }
+}
diff --git a/tests/no_adiabatic_heating.prm.bak b/tests/no_adiabatic_heating.prm.bak
new file mode 100644
index 00000000000..79d44e0bf0b
--- /dev/null
+++ b/tests/no_adiabatic_heating.prm.bak
@@ -0,0 +1,82 @@
+# This is a follow-on on the 'compressibility_iterated_stokes' testcase
+# where we choose
+#   u_z = 1+z/100
+# If we switch off adiabatic heating and shear heating, then there
+# should be no effect on the temperature field from the velocity, and
+# no effect from the temperature onto the velocity either. Verify that
+# this is so
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 5
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = no adiabatic heating
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/tests/no_adiabatic_heating_02.cc.bak b/tests/no_adiabatic_heating_02.cc.bak
new file mode 100644
index 00000000000..1b5ed90f274
--- /dev/null
+++ b/tests/no_adiabatic_heating_02.cc.bak
@@ -0,0 +1,65 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// use the same postprocessing facilities as for the
+// 'compressibility_iterated_stokes' testcase
+#include "compressibility_iterated_stokes.cc"
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class NoAdiabaticHeating : public CompressibilityIteratedStokes<dim>
+    {
+      public:
+        virtual double thermal_expansion_coefficient (const double,
+                                                      const double,
+                                                      const std::vector<double> &,
+                                                      const Point<dim> &) const
+        {
+          return 0;
+        }
+
+        virtual double viscosity (const double,
+                                  const double,
+                                  const std::vector<double> &,
+                                  const Point<dim> &) const
+        {
+          return 0;
+        }
+    };
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(NoAdiabaticHeating,
+                                   "no adiabatic heating",
+                                   "As described in the .prm file.")
+  }
+}
diff --git a/tests/no_adiabatic_heating_02.prm.bak b/tests/no_adiabatic_heating_02.prm.bak
new file mode 100644
index 00000000000..19640fb0d82
--- /dev/null
+++ b/tests/no_adiabatic_heating_02.prm.bak
@@ -0,0 +1,82 @@
+# Like 'no_adiabatic_heating' but here we actually switch on friction
+# heating. We also set the viscosity to zero, so there should still
+# be no change in temperature
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 5
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = no adiabatic heating
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, velocity statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.1
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/tests/no_adiabatic_heating_03.cc.bak b/tests/no_adiabatic_heating_03.cc.bak
new file mode 100644
index 00000000000..439e10250a9
--- /dev/null
+++ b/tests/no_adiabatic_heating_03.cc.bak
@@ -0,0 +1,57 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// use the same postprocessing facilities as for the
+// 'compressibility_iterated_stokes' testcase
+#include "compressibility_iterated_stokes.cc"
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class NoAdiabaticHeating : public CompressibilityIteratedStokes<dim>
+    {
+      public:
+        virtual double thermal_expansion_coefficient (const double,
+                                                      const double,
+                                                      const std::vector<double> &,
+                                                      const Point<dim> &) const
+        {
+          return 0;
+        }
+    };
+
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(NoAdiabaticHeating,
+                                   "no adiabatic heating",
+                                   "As described in the .prm file.")
+  }
+}
diff --git a/tests/no_adiabatic_heating_03.prm.bak b/tests/no_adiabatic_heating_03.prm.bak
new file mode 100644
index 00000000000..8a85abf90d1
--- /dev/null
+++ b/tests/no_adiabatic_heating_03.prm.bak
@@ -0,0 +1,115 @@
+# Like 'no_adiabatic_heating_02' but here we actually switch on shear
+# heating and set the viscosity to a non-zero. In this testcase, we have
+#   u_z(z) = 1+z/10
+# so in 2d, we have
+#   eps(u) - 1/3 (div u) I = [[-1/30,0], [0,2/30]]
+# so the shear heating term is
+#   2*eta*5/9*(1/10)^2
+# From the velocity, we get
+#   z = t+t^2/20
+# Consequently, if we set the thermal diffusivity to zero and c_P=1, then from
+#   rho(t) DT/Dt = 2*eta*5/9*(1/10)^2
+# we get
+#   T(t)  = \int_0^t 2*eta*5/9*(1/10)^2 / rho(t) dt
+# Now,
+#   rho(t) = rho(z(t)) = rho(t+t^2/20) = 1/(1+u_z(z(t))
+#          = 1/(1+(t+t^2/20)/10)
+# so
+#   T(t)  = eta/90 * (t + t^2/20 + t^3/600)
+# We can reformulate this in terms of z as
+#   T(z)  = eta/1350 * [(z+20)*sqrt(25+5z) - 100]
+# Thus, the maximal temperature at the outlet should be
+#   T(1)  = 0.011*eta
+# To make all of this work, of course, we need that the density does
+# not depend on the temperature
+#
+# In this testcase, we choose eta=10, so this should lead to
+#   T(1)  = 0.1112
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = .1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 5
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2
+
+  subsection Box
+    set Bottom temperature = 0
+  end
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = no adiabatic heating
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, velocity statistics, basic statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.1
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/tests/no_cheap_gmg.cc.bak b/tests/no_cheap_gmg.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/no_cheap_gmg.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/no_cheap_gmg.prm.bak b/tests/no_cheap_gmg.prm.bak
new file mode 100644
index 00000000000..1c6367eee09
--- /dev/null
+++ b/tests/no_cheap_gmg.prm.bak
@@ -0,0 +1,83 @@
+# Like sol_cx_4_gmg but without cheap iterations.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+  set Material averaging = harmonic average
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/no_conduction_timestep.prm.bak b/tests/no_conduction_timestep.prm.bak
new file mode 100644
index 00000000000..2b9b9bf70e5
--- /dev/null
+++ b/tests/no_conduction_timestep.prm.bak
@@ -0,0 +1,80 @@
+# This test checks that we do not divide by zero when computing
+# the conduction timestep in a model, where the thermal conductivity is
+# set to zero. We simply use the convection timestep in this case
+# (or fall back to the original default, when the velocity is zero as well).
+# Otherwise this test is identical to constant_composition_convergence.prm
+
+set Dimension                              = 2
+set End time                               = 2e8
+set Use years in output instead of seconds = true
+set Use conduction timestep                = true
+set Adiabatic surface temperature          = 1600
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 400000
+    set Y extent = 400000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2 ,3
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 1600 + 100*sin(x*pi/200000.0)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                = 3000
+    set Thermal conductivity             = 0
+    set Thermal expansion coefficient    = 4e-5
+    set Viscosity                        = 1e23
+    set Reference temperature            = 1600
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics
+end
diff --git a/tests/no_dirichlet_on_outflow.prm.bak b/tests/no_dirichlet_on_outflow.prm.bak
new file mode 100644
index 00000000000..330aa2e63dd
--- /dev/null
+++ b/tests/no_dirichlet_on_outflow.prm.bak
@@ -0,0 +1,168 @@
+# This test checks if fixed temperature boundary conditions are only
+# prescribed on outflow boundaries (if this option is activated in
+# the input file), and in particular if this also works for time-
+# dependent in- and outflow.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above, whereas all other
+# parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry
+# boundaries).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set Allow fixed temperature on outflow boundaries = false
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+end
+
+# The next parameters then describe on which parts of the
+# boundary we prescribe a zero or nonzero velocity and
+# on which parts the flow is allowed to be tangential.
+# Here, all four sides of the box allow tangential
+# unrestricted flow but with a zero normal component:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top:function
+
+  subsection Function
+    set Variable names      = x,y,t
+    set Function expression = 0;(x-0.5)*sin(t*30)
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e4   # = Ra
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy = temperature
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/tests/no_dirichlet_on_outflow_C.prm.bak b/tests/no_dirichlet_on_outflow_C.prm.bak
new file mode 100644
index 00000000000..9b95f9948b2
--- /dev/null
+++ b/tests/no_dirichlet_on_outflow_C.prm.bak
@@ -0,0 +1,172 @@
+# This test checks if fixed composition boundary conditions are only
+# prescribed on outflow boundaries (if this option is activated in
+# the input file), and in particular if this also works for time-
+# dependent in- and outflow, and in a case where we prescribe the
+# temperature for both inflow and outflow.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 1.7
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set Allow fixed temperature on outflow boundaries = true
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = bottom, top
+  set Allow fixed composition on outflow boundaries = false
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Prescribed velocity boundary indicators = top:function, bottom:function
+
+  subsection Function
+    set Variable names      = x,y,t
+    set Function expression = 0;(x-0.5)*sin(t*3)
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e4   # = Ra
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 5
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy = temperature
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/tests/no_dirichlet_on_outflow_adaptive.prm.bak b/tests/no_dirichlet_on_outflow_adaptive.prm.bak
new file mode 100644
index 00000000000..62aa05c961c
--- /dev/null
+++ b/tests/no_dirichlet_on_outflow_adaptive.prm.bak
@@ -0,0 +1,172 @@
+# This test is a copy of the no_dirichlet_outflow_boundary test,
+# with the only difference that it runs in parallel and adaptive
+# mesh.
+# This test checks if fixed temperature boundary conditions are only
+# prescribed on outflow boundaries (if this option is activated in
+# the input file), and in particular if this also works for time-
+# dependent in- and outflow.
+
+# MPI: 2
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.1
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above, whereas all other
+# parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry
+# boundaries).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set Allow fixed temperature on outflow boundaries = false
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+end
+
+# The next parameters then describe on which parts of the
+# boundary we prescribe a zero or nonzero velocity and
+# on which parts the flow is allowed to be tangential.
+# Here, all four sides of the box allow tangential
+# unrestricted flow but with a zero normal component:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top:function
+
+  subsection Function
+    set Variable names      = x,y,t
+    set Function expression = 0;(x-0.5)*sin(t*30)
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e4   # = Ra
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 1
+  set Time steps between mesh refinement       = 0
+  set Strategy = temperature
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/tests/no_dirichlet_on_outflow_melt.cc.bak b/tests/no_dirichlet_on_outflow_melt.cc.bak
new file mode 100644
index 00000000000..41a9c23ffdf
--- /dev/null
+++ b/tests/no_dirichlet_on_outflow_melt.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "rising_melt_blob.cc"
diff --git a/tests/no_dirichlet_on_outflow_melt.prm.bak b/tests/no_dirichlet_on_outflow_melt.prm.bak
new file mode 100644
index 00000000000..ecef9e27d6a
--- /dev/null
+++ b/tests/no_dirichlet_on_outflow_melt.prm.bak
@@ -0,0 +1,144 @@
+# This test checks if fixed composition boundary conditions are only
+# prescribed on outflow boundaries (if this option is activated in
+# the input file), and in particular if this also works in a model
+# with melt transport.
+
+
+set Dimension                              = 2
+set End time                               = 500
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 50
+
+#set CFL number                             = 0.1
+
+subsection Melt settings
+  set Include melt transport = true
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=100000, pi=3.1415926536, k=1
+    set Function expression = 1600
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Material model
+  set Model name = melting rate
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=50000,y0=50000,c=10000
+    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set Allow fixed temperature on outflow boundaries = false
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1600
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = bottom, top
+  set Allow fixed composition on outflow boundaries = false
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Prescribed velocity boundary indicators = top:function, bottom:function
+
+  subsection Function
+    set Variable names      = x,y,t
+    set Function expression = 0;(x/10000-0.5)*sin(t/30)
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e4   # = Ra
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy = temperature
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/tests/no_dirichlet_on_outflow_only_new_constraints.prm.bak b/tests/no_dirichlet_on_outflow_only_new_constraints.prm.bak
new file mode 100644
index 00000000000..838fdf42f08
--- /dev/null
+++ b/tests/no_dirichlet_on_outflow_only_new_constraints.prm.bak
@@ -0,0 +1,168 @@
+# This test checks if fixed temperature boundary conditions are only
+# prescribed on outflow boundaries (if this option is activated in
+# the input file), and in particular if this also works for time-
+# dependent in- and outflow where only new constraints are added.
+
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+# Then follows a section that describes the boundary conditions
+# for the temperature. The model we choose is called 'box' and
+# allows to set a constant temperature on each of the four sides
+# of the box geometry. In our case, we choose something that is
+# heated from below and cooled from above, whereas all other
+# parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry
+# boundaries).
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top
+  set Allow fixed temperature on outflow boundaries = false
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = false
+end
+
+# The next parameters then describe on which parts of the
+# boundary we prescribe a zero or nonzero velocity and
+# on which parts the flow is allowed to be tangential.
+# Here, all four sides of the box allow tangential
+# unrestricted flow but with a zero normal component:
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Prescribed velocity boundary indicators = top:function
+
+  subsection Function
+    set Variable names      = x,y,t
+    set Function expression = 0;if(x>2*t,1,-1)
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e4   # = Ra
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy = temperature
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/tests/no_dirichlet_on_outflow_refine.prm b/tests/no_dirichlet_on_outflow_refine.prm
index 74cf957cc47..679c6360e4e 100644
--- a/tests/no_dirichlet_on_outflow_refine.prm
+++ b/tests/no_dirichlet_on_outflow_refine.prm
@@ -40,7 +40,7 @@ end
 subsection Boundary temperature model
   set Fixed temperature boundary indicators = bottom, top
   set Allow fixed temperature on outflow boundaries = false
-  set Model name = function
+  set List of model names = function
 
   subsection Function
     set Variable names      = x,y
diff --git a/tests/no_dirichlet_on_outflow_refine.prm.bak b/tests/no_dirichlet_on_outflow_refine.prm.bak
new file mode 100644
index 00000000000..74cf957cc47
--- /dev/null
+++ b/tests/no_dirichlet_on_outflow_refine.prm.bak
@@ -0,0 +1,123 @@
+# This test makes sure that the "Allow fixed temperature on outflow
+# boundaries = false" option also works in time steps where the mesh
+# is refined. Flow is prescribed to be vertically upwards and the
+# boundary temperature in the left half of the model is slightly
+# hotter than the initial condition. The mesh is refined in every
+# second step.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 2e6
+set Output directory                       = test
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose 5a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 800e3
+    set Y extent = 800e3
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 1500 + 250 * 0.5 * (1-tanh((x-450000)/40000))
+  end
+end
+
+# This is 10 K hotter than the initial condition within the plume
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set Allow fixed temperature on outflow boundaries = false
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 1500 + 260 * 0.5 * (1-tanh((x-450000)/40000))
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Prescribed velocity boundary indicators = top: function, bottom: function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 0; 0.1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Material model
+  set Model name = latent heat
+  set Material averaging = project to Q1 only viscosity
+
+  subsection Latent heat
+    set Minimum viscosity             = 1e17
+    set Viscosity                     = 7e21
+    set Reference density             = 3291.5
+    set Thermal conductivity          = 4
+    set Thermal expansion coefficient = 2.6e-5
+    set Reference specific heat       = 1000
+    set Reference temperature         = 1600
+    set Compressibility               = 0
+    set Thermal viscosity exponent    = 50.0
+    set Phase transition density jumps                 = 110
+    set Corresponding phase for density jump           = 0
+    set Phase transition depths                        = 300000
+    set Phase transition widths                        = 0
+    set Phase transition temperatures                  = 1600
+    set Phase transition Clapeyron slopes              = 0
+    set Viscosity prefactors                           = 1,1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on.
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Strategy                                 = minimum refinement function
+  set Time steps between mesh refinement       = 2
+
+  subsection Minimum refinement function
+    set Coordinate system = cartesian
+    set Function expression = 4
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set Output format                 = vtu
+    set List of output variables      = material properties
+  end
+end
diff --git a/tests/no_flow.prm.bak b/tests/no_flow.prm.bak
new file mode 100644
index 00000000000..bfdd9a468de
--- /dev/null
+++ b/tests/no_flow.prm.bak
@@ -0,0 +1,85 @@
+# A test that deals with the problem that if there is no flow then the
+# convection time step is infinite. in that case, we need to limit the
+# time step size to something related to the conduction time step
+#
+# We make sure that there is no flow in this particular situation by using
+# zero boundary conditions and a zero thermal expansion coefficient so
+# that the right hand side of the velocity is constant.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set Use conduction timestep       = true
+set End time                               = 1
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 0
+    set Reference specific heat = 1
+    set Thermal conductivity = 1
+    set Reference density = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/non_conservative_with_mpi.cc.bak b/tests/non_conservative_with_mpi.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/non_conservative_with_mpi.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/non_conservative_with_mpi.prm.bak b/tests/non_conservative_with_mpi.prm.bak
new file mode 100644
index 00000000000..c38ef837296
--- /dev/null
+++ b/tests/non_conservative_with_mpi.prm.bak
@@ -0,0 +1,79 @@
+# this is a variant of the conservative_with_mpi test that verifies that the
+# same as discussed there also works for the non-conservative element
+
+# MPI: 2
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm.bak
new file mode 100644
index 00000000000..3071bfcd224
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm.bak
@@ -0,0 +1,131 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set Maximum time step                      = 1
+set End time                               = 4
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = iterated Advection and Newton Stokes
+set Max nonlinear iterations = 45
+set Nonlinear solver tolerance = 5e-10
+set Additional shared libraries = ../benchmarks/nonlinear_channel_flow/libsimple_nonlinear.so
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 3
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 5
+    set Maximum linear Stokes solver tolerance = 1e-1
+  end
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Stokes solver type =  block AMG
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10e3
+    set Y extent = 8e3
+    set Y repetitions = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple nonlinear
+  set Material averaging = none
+
+  subsection Simple nonlinear
+    set Minimum viscosity = 1e19
+    set Maximum viscosity = 1e24
+    set Stress exponent = 3
+    set Viscosity averaging p = 10000
+    set Viscosity prefactor = 1e-37
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 2 y: function, 3 y: function # pressure bc: Prescribe a horizontal traction on the vertical boundaries
+
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 0;if(z>0,0,1e9)
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1
+  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
+
+  subsection Function
+    set Function constants = n = 3
+    set Variable names = x,z
+
+    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
+    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
+
+  subsection Depth average
+    set List of output variables = viscosity
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties,strain rate, spd factor
+    set Output format = gnuplot
+    set Time between graphical output = 2
+  end
+end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.prm.bak
new file mode 100644
index 00000000000..6c5d1c62389
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.prm.bak
@@ -0,0 +1,17 @@
+# Test Newton GMG solver based on
+# benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
+
+include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
+
+set Additional shared libraries = $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/libsimple_nonlinear.so
+set Max nonlinear iterations = 10
+
+subsection Material model
+  set Material averaging = harmonic average
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.prm.bak
new file mode 100644
index 00000000000..fd00966896d
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.prm.bak
@@ -0,0 +1,132 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set Maximum time step                      = 1
+set End time                               = 4
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = iterated Advection and Newton Stokes
+set Max nonlinear iterations = 45
+set Nonlinear solver tolerance = 5e-10
+set Additional shared libraries = ../benchmarks/nonlinear_channel_flow/libsimple_nonlinear.so
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 3
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 5
+    set Maximum linear Stokes solver tolerance = 1e-1
+  end
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Stokes solver type =  block AMG
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10e3
+    set Y extent = 8e3
+    set Y repetitions = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple nonlinear
+  set Material averaging = none
+
+  subsection Simple nonlinear
+    set Minimum viscosity = 1e19
+    set Maximum viscosity = 1e24
+    set Stress exponent = 3
+    set Viscosity averaging p = 10000
+    set Viscosity prefactor = 1e-37
+    set Use deviator of strain-rate = false
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 2 y: function, 3 y: function # pressure bc: Prescribe a horizontal traction on the vertical boundaries
+
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 0;if(z>0,0,1e9)
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1
+  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
+
+  subsection Function
+    set Function constants = n = 3
+    set Variable names = x,z
+
+    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
+    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
+
+  subsection Depth average
+    set List of output variables = viscosity
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties,strain rate, spd factor
+    set Output format = gnuplot
+    set Time between graphical output = 2
+  end
+end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.prm.bak
new file mode 100644
index 00000000000..604797f5fde
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.prm.bak
@@ -0,0 +1,8 @@
+include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm
+
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max Newton line search iterations = 0
+  end
+end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.prm.bak
new file mode 100644
index 00000000000..d5c54cc776c
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.prm.bak
@@ -0,0 +1,38 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark, but adds passive particles.
+
+include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm
+
+set Dimension = 2
+set Additional shared libraries = ./libsimple_nonlinear.so
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization, particles
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties,strain rate, spd factor
+    set Output format = gnuplot
+    set Time between graphical output = 2
+  end
+
+  subsection Particles
+    set Time between data output = 1
+    set Data output format = gnuplot
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial position, position
+  set Interpolation scheme = nearest neighbor
+  set Particle generator name = random uniform
+  set Minimum particles per cell = 2
+  set Maximum particles per cell = 2
+  set Load balancing strategy = remove and add particles
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 512
+    end
+  end
+end
diff --git a/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.cc.bak b/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.cc.bak
new file mode 100644
index 00000000000..b0c1b8e736e
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.cc.bak
@@ -0,0 +1 @@
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.prm.bak b/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.prm.bak
new file mode 100644
index 00000000000..3911c7d64fc
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.prm.bak
@@ -0,0 +1,17 @@
+#Test GMG  iterated defect correction Stokes solver based on
+# benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
+
+include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
+
+set Nonlinear solver scheme = single Advection, iterated defect correction Stokes
+set Max nonlinear iterations = 10
+
+subsection Material model
+  set Material averaging = harmonic average
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/tests/nonlinear_channel_flow_tractions_iterated_IMPES.cc.bak b/tests/nonlinear_channel_flow_tractions_iterated_IMPES.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_iterated_IMPES.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_iterated_IMPES.prm.bak b/tests/nonlinear_channel_flow_tractions_iterated_IMPES.prm.bak
new file mode 100644
index 00000000000..11466407119
--- /dev/null
+++ b/tests/nonlinear_channel_flow_tractions_iterated_IMPES.prm.bak
@@ -0,0 +1,129 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set Maximum time step                      = 1
+set End time                               = 2
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = iterated Advection and Stokes
+set Max nonlinear iterations = 100
+set Nonlinear solver tolerance = 1e-10
+set Additional shared libraries = ../benchmarks/nonlinear_channel_flow/libsimple_nonlinear.so
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 3
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 5
+    set Maximum linear Stokes solver tolerance = 1e-1
+  end
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-10
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10e3
+    set Y extent = 8e3
+    set Y repetitions = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple nonlinear
+
+  subsection Simple nonlinear
+    set Minimum viscosity = 1e19
+    set Maximum viscosity = 1e24
+    set Stress exponent = 3
+    set Viscosity averaging p = 10000
+    set Viscosity prefactor = 1e-37
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 2 y: function, 3 y: function # pressure bc: Prescribe a horizontal traction on the vertical boundaries
+
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 0;if(z>0,0,1e9)
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1
+  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
+
+  subsection Function
+    set Function constants = n = 3
+    set Variable names = x,z
+
+    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
+    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
+
+  subsection Depth average
+    set List of output variables = viscosity
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties,strain rate
+    set Output format = gnuplot
+    set Time between graphical output = 2
+  end
+end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm.bak
new file mode 100644
index 00000000000..1f2cea719ab
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm.bak
@@ -0,0 +1,134 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set Maximum time step                      = 1
+set End time                               = 4
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = iterated Advection and Newton Stokes
+set Max nonlinear iterations = 30
+set Nonlinear solver tolerance = 5e-12
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 3
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 5
+    set Maximum linear Stokes solver tolerance = 1e-1
+  end
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Stokes solver type =  block AMG
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10e3
+    set Y extent = 8e3
+    set Y repetitions = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple nonlinear
+  set Material averaging = none
+
+  subsection Simple nonlinear
+    # Instead of the default of 1.96e-40, set the minimum
+    # strain rate to something closer to, but below,
+    # the actual minimum strain rate.
+    set Minimum strain rate = 1e-16
+    set Minimum viscosity = 1e19
+    set Maximum viscosity = 1e24
+    set Stress exponent = 3
+    set Viscosity averaging p = 10000
+    set Viscosity prefactor = 1e-37
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1
+
+  #  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
+  set Prescribed velocity boundary indicators = 2: function, 3: function # velocity bc
+
+  subsection Function
+    set Function constants = n = 3
+    set Variable names = x,z
+
+    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
+    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
+  end
+end
+
+subsection Boundary traction model
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 0;if(z>0,0,1e9)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
+
+  subsection Depth average
+    set List of output variables = viscosity
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties,strain rate, spd factor
+    set Output format = gnuplot
+    set Time between graphical output = 2
+  end
+end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.prm.bak
new file mode 100644
index 00000000000..e82fa5e93a8
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.prm.bak
@@ -0,0 +1,23 @@
+include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
+
+set Nonlinear solver tolerance = 1e-11
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 31 #one more than max iterations
+    set Nonlinear Newton solver switch tolerance =  0
+  end
+
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1e-6
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
+end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.prm.bak
new file mode 100644
index 00000000000..b4dd337ec56
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.prm.bak
@@ -0,0 +1,21 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
+
+set End time                               = 2
+set Max nonlinear iterations = 100
+set Nonlinear solver tolerance = 1.5e-9
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 100
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 0
+    set Maximum linear Stokes solver tolerance = 1e-1
+    set Use Eisenstat Walker method for Picard iterations = false
+  end
+end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.prm.bak
new file mode 100644
index 00000000000..522f99740cf
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.prm.bak
@@ -0,0 +1,21 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
+
+set End time                               = 2
+set Max nonlinear iterations = 100
+set Nonlinear solver tolerance = 1e-9
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 100
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 0
+    set Maximum linear Stokes solver tolerance = 1e-1
+    set Use Eisenstat Walker method for Picard iterations = true
+  end
+end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.prm.bak
new file mode 100644
index 00000000000..34791b88253
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.prm.bak
@@ -0,0 +1,17 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
+
+set Nonlinear solver tolerance = 5e-12
+
+subsection Material model
+  set Model name = simple nonlinear
+
+  subsection Simple nonlinear
+    set Use deviator of strain-rate = false
+  end
+end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.prm.bak
new file mode 100644
index 00000000000..c4e4c683525
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.prm.bak
@@ -0,0 +1,8 @@
+include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
+
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max Newton line search iterations = 0
+  end
+end
diff --git a/tests/nonlinear_channel_flow_velocities_iterated_IMPES.cc.bak b/tests/nonlinear_channel_flow_velocities_iterated_IMPES.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_iterated_IMPES.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_iterated_IMPES.prm.bak b/tests/nonlinear_channel_flow_velocities_iterated_IMPES.prm.bak
new file mode 100644
index 00000000000..bc3c9910638
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_iterated_IMPES.prm.bak
@@ -0,0 +1,128 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set Maximum time step                      = 1
+set End time                               = 2
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = iterated Advection and Stokes
+set Max nonlinear iterations = 100
+set Nonlinear solver tolerance = 1e-10
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 3
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 5
+    set Maximum linear Stokes solver tolerance = 1e-1
+  end
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10e3
+    set Y extent = 8e3
+    set Y repetitions = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple nonlinear
+
+  subsection Simple nonlinear
+    set Minimum viscosity = 1e19
+    set Maximum viscosity = 1e24
+    set Stress exponent = 3
+    set Viscosity averaging p = 10000
+    set Viscosity prefactor = 1e-37
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1
+
+  #  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
+  set Prescribed velocity boundary indicators = 2: function, 3: function # velocity bc
+
+  subsection Function
+    set Function constants = n = 3
+    set Variable names = x,z
+
+    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
+    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
+  end
+end
+
+subsection Boundary traction model
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 0;if(z>0,0,1e9)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
+
+  subsection Depth average
+    set List of output variables = viscosity
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties,strain rate
+    set Output format = gnuplot
+    set Time between graphical output = 2
+  end
+end
diff --git a/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.cc.bak b/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.cc.bak
new file mode 100644
index 00000000000..63ec7ca86d1
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.prm.bak b/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.prm.bak
new file mode 100644
index 00000000000..fb7654faf27
--- /dev/null
+++ b/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.prm.bak
@@ -0,0 +1,9 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the solver scheme
+# 'single Advection, iterated Newton Stokes'
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
+
+set Nonlinear solver scheme = single Advection, iterated Newton Stokes
diff --git a/tests/nonlinear_convergence_for_small_composition.cc.bak b/tests/nonlinear_convergence_for_small_composition.cc.bak
new file mode 100644
index 00000000000..05ef86afa08
--- /dev/null
+++ b/tests/nonlinear_convergence_for_small_composition.cc.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  template <int dim>
+  class TestMaterial:
+    public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            out.viscosities[i] = 1e19;
+            out.thermal_expansion_coefficients[i] = 1e-5;
+            out.specific_heat[i] = 1000.0;
+            out.thermal_conductivities[i] = 1.0;
+            out.compressibilities[i] = 0.0;
+            out.densities[i] = 30000.0*(1.0-1.e-5*in.temperature[i]);
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              {
+                if (in.requests_property(MaterialModel::MaterialProperties::reaction_terms))
+                  out.reaction_terms[i][c] = trace(in.strain_rate[i]) * this->get_timestep();
+                else
+                  out.reaction_terms[i][c] = 0.0;
+              }
+            out.entropy_derivative_pressure[i]    = 0.0;
+            out.entropy_derivative_temperature[i] = 0.0;
+
+          }
+      }
+  };
+}
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(TestMaterial,
+                                 "test material",
+                                 "")
+
+}
diff --git a/tests/nonlinear_convergence_for_small_composition.prm.bak b/tests/nonlinear_convergence_for_small_composition.prm.bak
new file mode 100644
index 00000000000..3603032eb6d
--- /dev/null
+++ b/tests/nonlinear_convergence_for_small_composition.prm.bak
@@ -0,0 +1,162 @@
+# Listing of Parameters
+# ---------------------
+# This test demonstrates that the nonlinear solver can not converge
+# if the reaction term depends on the Stokes solution (in this case
+# the velocity divergence) and the right-hand side of the compositional
+# field advection equation is zero or very small otherwise, as long as
+# the Stokes solution still changes (the number of linear Stokes solver
+# iterations is not equal to zero).
+# As soon as the Stokes system is not solved any more, the nonlinear
+# residual drops to a very small number.
+
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 1.0
+set Maximum time step                      = 1e6
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 20
+set Nonlinear solver tolerance             = 5e-9
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Start time                             = 0
+set End time                               = 1e4
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.2
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 3700
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+
+  subsection Function
+    set Function constants  = b=100000, c=20000
+    set Variable names      = x,y
+    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2900000
+    set Y extent = 2900000
+    set X repetitions = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age bottom boundary layer = 5e8
+    set Age top boundary layer    = 3e8
+    set Amplitude                 = 50
+    set Position                  = center
+    set Radius                    = 500000
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+
+  subsection Harmonic perturbation
+    set Magnitude = 50
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,a = 0.0, b = 2500000, c = 100000, d=1450000
+    set Function expression = a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c)); a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = test material
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.8
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+
+  subsection Visualization
+    set List of output variables      = material properties
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+  end
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-14
+  set Temperature solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/nonlinear_solver_history.cc.bak b/tests/nonlinear_solver_history.cc.bak
new file mode 100644
index 00000000000..cdc772dd69d
--- /dev/null
+++ b/tests/nonlinear_solver_history.cc.bak
@@ -0,0 +1,46 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_signals.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+
+namespace aspect
+{
+  template <int dim>
+  void post_nonlinear_solver (const SolverControl &nonlinear_solver_control)
+  {
+    const bool success = nonlinear_solver_control.last_check() == SolverControl::success;
+    std::cout << "\nnumber of nonlinear iterations: " << nonlinear_solver_control.last_step() << ". State: " << success << ".\n";
+  }
+
+
+  template <int dim>
+  void signal_connector (SimulatorSignals<dim> &signals)
+  {
+    std::cout << "Connecting signals" << std::endl;
+    signals.post_nonlinear_solver.connect (&post_nonlinear_solver<dim>);
+  }
+
+
+  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                    signal_connector<3>)
+}
diff --git a/tests/nonlinear_solver_history.prm.bak b/tests/nonlinear_solver_history.prm.bak
new file mode 100644
index 00000000000..044b0c79458
--- /dev/null
+++ b/tests/nonlinear_solver_history.prm.bak
@@ -0,0 +1,69 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0.1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, Stokes residual
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/normalize_initial_composition.prm.bak b/tests/normalize_initial_composition.prm.bak
new file mode 100644
index 00000000000..35e375fe773
--- /dev/null
+++ b/tests/normalize_initial_composition.prm.bak
@@ -0,0 +1,62 @@
+# This test ensures that the Simpler material model works
+# with compositional fields enabled
+
+set Dimension                              = 2
+set End time                               = 0
+
+subsection Compositional fields
+  set Number of fields          = 2
+  set List of normalized fields   =  0,1
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 1;1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent                = 1
+    set X repetitions           = 2
+    set Y extent                = 1
+    set Y repetitions           = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Material model
+  set Model name         = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
diff --git a/tests/normalize_pressure_volume.prm.bak b/tests/normalize_pressure_volume.prm.bak
new file mode 100644
index 00000000000..26b67b24b54
--- /dev/null
+++ b/tests/normalize_pressure_volume.prm.bak
@@ -0,0 +1,70 @@
+# test that pressure "volume" normalization works correctly.
+# note that the solution is kind of non-sensical..
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Pressure normalization                 = volume
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 2
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 3: function
+  set Zero velocity boundary indicators       = 0, 1
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = 0;x*(1-x)*z
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, visualization
+end
diff --git a/tests/nsinker.cc.bak b/tests/nsinker.cc.bak
new file mode 100644
index 00000000000..3414e98ba87
--- /dev/null
+++ b/tests/nsinker.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/nsinker/nsinker.cc"
diff --git a/tests/nsinker.prm.bak b/tests/nsinker.prm.bak
new file mode 100644
index 00000000000..33822b2a947
--- /dev/null
+++ b/tests/nsinker.prm.bak
@@ -0,0 +1,9 @@
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/benchmarks/nsinker/nsinker.prm
+
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 1
+end
diff --git a/tests/nsinker_2d.cc.bak b/tests/nsinker_2d.cc.bak
new file mode 100644
index 00000000000..3414e98ba87
--- /dev/null
+++ b/tests/nsinker_2d.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/nsinker/nsinker.cc"
diff --git a/tests/nsinker_2d.prm.bak b/tests/nsinker_2d.prm.bak
new file mode 100644
index 00000000000..a0b79e17f9e
--- /dev/null
+++ b/tests/nsinker_2d.prm.bak
@@ -0,0 +1,8 @@
+include $ASPECT_SOURCE_DIR/benchmarks/nsinker/nsinker_2d.prm
+
+set Dimension = 2
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 1
+end
diff --git a/tests/nsinker_bfbt.cc.bak b/tests/nsinker_bfbt.cc.bak
new file mode 100644
index 00000000000..3414e98ba87
--- /dev/null
+++ b/tests/nsinker_bfbt.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/nsinker/nsinker.cc"
diff --git a/tests/nsinker_bfbt.prm.bak b/tests/nsinker_bfbt.prm.bak
new file mode 100644
index 00000000000..33822b2a947
--- /dev/null
+++ b/tests/nsinker_bfbt.prm.bak
@@ -0,0 +1,9 @@
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/benchmarks/nsinker/nsinker.prm
+
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 1
+end
diff --git a/tests/nsinker_gmg_idr.cc.bak b/tests/nsinker_gmg_idr.cc.bak
new file mode 100644
index 00000000000..3414e98ba87
--- /dev/null
+++ b/tests/nsinker_gmg_idr.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/nsinker/nsinker.cc"
diff --git a/tests/nsinker_gmg_idr.prm.bak b/tests/nsinker_gmg_idr.prm.bak
new file mode 100644
index 00000000000..5f90a8060ae
--- /dev/null
+++ b/tests/nsinker_gmg_idr.prm.bak
@@ -0,0 +1,24 @@
+# Nsinker benchmark using geometric multigrid preconditioner
+# with an IDR(2) solver
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/benchmarks/nsinker/nsinker_gmg.prm
+
+
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Krylov method for cheap solver steps = IDR(s)
+    set IDR(s) parameter = 2
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
diff --git a/tests/octagonal_initial_temperature.prm.bak b/tests/octagonal_initial_temperature.prm.bak
new file mode 100644
index 00000000000..75f770da3db
--- /dev/null
+++ b/tests/octagonal_initial_temperature.prm.bak
@@ -0,0 +1,90 @@
+# Test the spherical "hexagonal" perturbation initial temperature model with
+# an eight-fold symmetry
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = .5
+    set Outer radius = 1
+    set Opening angle = 360
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+
+  subsection Spherical hexagonal perturbation
+    set Angular mode = 8
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Additional refinement times              =
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/octagonal_initial_temperature_ellipsoidal_chunk.prm.bak b/tests/octagonal_initial_temperature_ellipsoidal_chunk.prm.bak
new file mode 100644
index 00000000000..c15a220c014
--- /dev/null
+++ b/tests/octagonal_initial_temperature_ellipsoidal_chunk.prm.bak
@@ -0,0 +1,94 @@
+# Test the spherical "hexagonal" perturbation initial temperature model with
+# an eight-fold symmetry
+
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 2
+    set Outer temperature = 0
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = ellipsoidal chunk
+
+  subsection Ellipsoidal chunk
+    set NE corner = 5:30
+    set NW corner = 0:0
+    set SW corner = 10:-10
+    set Depth = 3000000
+    set Eccentricity = 0.
+    set East-West subdivisions = 1
+    set North-South subdivisions = 1
+    set Depth subdivisions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+
+  subsection Spherical hexagonal perturbation
+    set Angular mode = 8
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner
+  set Zero velocity boundary indicators       = outer
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/octagonal_initial_temperature_rotated.prm.bak b/tests/octagonal_initial_temperature_rotated.prm.bak
new file mode 100644
index 00000000000..98b3678ed5a
--- /dev/null
+++ b/tests/octagonal_initial_temperature_rotated.prm.bak
@@ -0,0 +1,91 @@
+# Test the spherical "hexagonal" perturbation initial temperature model with
+# an eight-fold symmetry including a rotation angle
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1
+    set Outer temperature = 0
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = .5
+    set Outer radius = 1
+    set Opening angle = 360
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+
+  subsection Spherical hexagonal perturbation
+    set Angular mode = 8
+    set Rotation offset = -22.5
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Additional refinement times              =
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/onset_of_convection.prm.bak b/tests/onset_of_convection.prm.bak
new file mode 100644
index 00000000000..6ebdfb44c3a
--- /dev/null
+++ b/tests/onset_of_convection.prm.bak
@@ -0,0 +1,4 @@
+include $ASPECT_SOURCE_DIR/cookbooks/onset_of_convection/onset_of_convection.prm
+
+set Dimension = 2
+set End time = 0
diff --git a/tests/original_prm.prm.bak b/tests/original_prm.prm.bak
new file mode 100644
index 00000000000..a0fbb6f71be
--- /dev/null
+++ b/tests/original_prm.prm.bak
@@ -0,0 +1,10 @@
+# test that output/original.prm is written correctly
+
+# based on no_flow.prm:
+include $ASPECT_SOURCE_DIR/tests/no_flow.prm
+
+
+# Note: the line above also checks that ASPECT_SOURCE_DIR is not being replaced
+
+# The reference output will contain an additional line with the output
+# directory below this line:
diff --git a/tests/original_prm/original.prm b/tests/original_prm/original.prm
index 701798a8f69..ff3555b1b19 100644
--- a/tests/original_prm/original.prm
+++ b/tests/original_prm/original.prm
@@ -10,4 +10,3 @@ include $ASPECT_SOURCE_DIR/tests/no_flow.prm
 # directory below this line:
 
 set Output directory = output-original_prm
-
diff --git a/tests/original_prm/original.prm.bak b/tests/original_prm/original.prm.bak
new file mode 100644
index 00000000000..701798a8f69
--- /dev/null
+++ b/tests/original_prm/original.prm.bak
@@ -0,0 +1,13 @@
+# test that output/original.prm is written correctly
+
+# based on no_flow.prm:
+include $ASPECT_SOURCE_DIR/tests/no_flow.prm
+
+
+# Note: the line above also checks that ASPECT_SOURCE_DIR is not being replaced
+
+# The reference output will contain an additional line with the output
+# directory below this line:
+
+set Output directory = output-original_prm
+
diff --git a/tests/output_averaging_arithmetic.cc.bak b/tests/output_averaging_arithmetic.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/output_averaging_arithmetic.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/output_averaging_arithmetic.prm.bak b/tests/output_averaging_arithmetic.prm.bak
new file mode 100644
index 00000000000..e77b9085c63
--- /dev/null
+++ b/tests/output_averaging_arithmetic.prm.bak
@@ -0,0 +1,82 @@
+# Test that when we do material model averaging, that the material
+# model parameters such as the viscosity are also averaged when output
+# in graphical format. We want to do this because we want to visualize
+# what these parameters really are to the computational model, not
+# what they are in a pointwise sense before the computational model
+# gets to see them.
+#
+# This test uses the SolKz model, which has a viscosity that grows
+# exponentially in z-direction. The various output_averaging_*prm
+# files then simply apply different cellwise averaging options to
+# this viscosity.
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+  set Material averaging = arithmetic average
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format                 = gnuplot
+    set List of output variables      = viscosity
+    set Interpolate output            = false
+  end
+end
diff --git a/tests/output_averaging_harmonic.cc.bak b/tests/output_averaging_harmonic.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/output_averaging_harmonic.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/output_averaging_harmonic.prm.bak b/tests/output_averaging_harmonic.prm.bak
new file mode 100644
index 00000000000..2112ba4d0e8
--- /dev/null
+++ b/tests/output_averaging_harmonic.prm.bak
@@ -0,0 +1,82 @@
+# Test that when we do material model averaging, that the material
+# model parameters such as the viscosity are also averaged when output
+# in graphical format. We want to do this because we want to visualize
+# what these parameters really are to the computational model, not
+# what they are in a pointwise sense before the computational model
+# gets to see them.
+#
+# This test uses the SolKz model, which has a viscosity that grows
+# exponentially in z-direction. The various output_averaging_*prm
+# files then simply apply different cellwise averaging options to
+# this viscosity.
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+  set Material averaging = harmonic average
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format                 = gnuplot
+    set List of output variables      = viscosity
+    set Interpolate output            = false
+  end
+end
diff --git a/tests/own_gravity.cc.bak b/tests/own_gravity.cc.bak
new file mode 100644
index 00000000000..af3950f828b
--- /dev/null
+++ b/tests/own_gravity.cc.bak
@@ -0,0 +1,44 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+
+using namespace dealii;
+
+
+template <int dim>
+class MyGravity :
+  public aspect::GravityModel::Interface<dim>
+{
+  public:
+    virtual Tensor<1,dim> gravity_vector (const Point<dim> &position) const
+    {
+      Tensor<1,dim> ret;
+      ret[0] = position[1];
+      ret[1] = 42.0;
+      return ret;
+    }
+};
+
+
+// explicit instantiation
+ASPECT_REGISTER_GRAVITY_MODEL(MyGravity, "my gravity", "no description")
diff --git a/tests/own_gravity.prm.bak b/tests/own_gravity.prm.bak
new file mode 100644
index 00000000000..d0f833d0425
--- /dev/null
+++ b/tests/own_gravity.prm.bak
@@ -0,0 +1,77 @@
+# implement own gravity model, also test gravity visualization
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 2
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = my gravity
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Depth average
+    set Time between graphical output = 0
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+    set List of output variables = gravity
+  end
+end
diff --git a/tests/parallel_output_group_0.prm.bak b/tests/parallel_output_group_0.prm.bak
new file mode 100644
index 00000000000..c6037a74dcc
--- /dev/null
+++ b/tests/parallel_output_group_0.prm.bak
@@ -0,0 +1,76 @@
+# Test grouping of files in vtu output
+
+# MPI: 3
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1
+set Output directory                       = output
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer, left, right
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/tests/parallel_output_group_1.prm.bak b/tests/parallel_output_group_1.prm.bak
new file mode 100644
index 00000000000..01fe1ac72ad
--- /dev/null
+++ b/tests/parallel_output_group_1.prm.bak
@@ -0,0 +1,76 @@
+# Test grouping of files in vtu output
+
+# MPI: 3
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1
+set Output directory                       = output
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer, left, right
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Number of grouped files       = 1
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/tests/parallel_output_group_2.prm.bak b/tests/parallel_output_group_2.prm.bak
new file mode 100644
index 00000000000..59476211264
--- /dev/null
+++ b/tests/parallel_output_group_2.prm.bak
@@ -0,0 +1,76 @@
+# Test grouping of files in vtu output
+
+# MPI: 3
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1
+set Output directory                       = output
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer, left, right
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Number of grouped files       = 2
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/tests/parallel_refine_crash.prm.bak b/tests/parallel_refine_crash.prm.bak
new file mode 100644
index 00000000000..afb45a0e4ec
--- /dev/null
+++ b/tests/parallel_refine_crash.prm.bak
@@ -0,0 +1,112 @@
+# MPI: 4
+
+# Test case that showed two problems:
+#
+# 1. Parallel mesh smoothing would interfere with minimum refinement function
+# leading to missing refinement when run with few cells per processor.
+# 2. This leads to a crash with periodic constraints because of a hanging node.
+#
+# File shows the problem with 7 or more MPI ranks.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 1000
+set Maximum time step                      = 20000
+set Output directory                       = test_periodic
+set Pressure normalization                 = no #surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100e3
+    set Y extent = 150e3
+    set Z extent = 200e3
+    set X repetitions = 2
+    set Y repetitions = 3
+    set Z repetitions = 4
+    set Y periodic        = true
+  end
+end
+
+# We do not consider temperature in this setup
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = initial temperature
+end
+
+# X boundaries are periodic, and the rest are tangential.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0   # = Ra
+  end
+end
+
+# Dimensionless
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+# We also have to specify that we want to use the Boussinesq
+# approximation (assuming the density in the temperature
+# equation to be constant, and incompressibility).
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+# We set our global refinement at the resolution level we want at the surface. As of now,
+# FastScape initial resolution is determined based off this.
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 2
+  set Time steps between mesh refinement       = 0
+  set Refinement fraction = 0.5
+  set Strategy                                 =  minimum refinement function, maximum refinement function
+  set Run postprocessors on initial refinement            = true
+
+  subsection Maximum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y,z
+    set Function expression = if( z>=150.e3 , if( z>=160.e3, if( z>=170.e3, 4 , 3 ) , 2 ) , 1 )
+  end
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y,z
+    set Function expression = if( z>=150.e3 , if( z>=160.e3, if( z>=170.e3, 4 , 3 ) , 2 ) , 1 )
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set List of output variables      = strain rate, error indicator, partition
+    set Interpolate output = true
+  end
+end
diff --git a/tests/particle_count_statistics.cc.bak b/tests/particle_count_statistics.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/particle_count_statistics.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/particle_count_statistics.prm.bak b/tests/particle_count_statistics.prm.bak
new file mode 100644
index 00000000000..b4270531b50
--- /dev/null
+++ b/tests/particle_count_statistics.prm.bak
@@ -0,0 +1,91 @@
+# This test is based on sol_cx_particles and tests
+# the particle count statistics postprocessor that outputs
+# the minimum, average and maximum number of particles per cell
+# in the domain.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e2
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = particles, particle count statistics
+
+  subsection Depth average
+    set Time between graphical output = 100
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 100
+  end
+
+  subsection Particles
+    set Time between data output = 1
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1000
+    end
+  end
+end
diff --git a/tests/particle_exclude_all_properties.prm.bak b/tests/particle_exclude_all_properties.prm.bak
new file mode 100644
index 00000000000..bf9b2feb9e8
--- /dev/null
+++ b/tests/particle_exclude_all_properties.prm.bak
@@ -0,0 +1,117 @@
+#########################################################
+# This is a variation of the composition-passive.prm
+# parameter file, with the exception that we also
+# advect along a set of particles and that we do not longer
+# compute temperature statistics and composition statistics
+# as part of postprocessing
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0 #0.1
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-passive-particles-explicit2-output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format       = gnuplot
+    set Exclude output properties = initial C_9,all
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 10
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 100
+    end
+  end
+end
diff --git a/tests/particle_exclude_one_property.prm.bak b/tests/particle_exclude_one_property.prm.bak
new file mode 100644
index 00000000000..ce3ab8714ea
--- /dev/null
+++ b/tests/particle_exclude_one_property.prm.bak
@@ -0,0 +1,117 @@
+#########################################################
+# This is a variation of the composition-passive.prm
+# parameter file, with the exception that we also
+# advect along a set of particles and that we do not longer
+# compute temperature statistics and composition statistics
+# as part of postprocessing
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0 #0.1
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-passive-particles-explicit2-output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format       = gnuplot
+    set Exclude output properties = initial C_9
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 10
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 100
+    end
+  end
+end
diff --git a/tests/particle_exclude_one_property_vtu.prm.bak b/tests/particle_exclude_one_property_vtu.prm.bak
new file mode 100644
index 00000000000..89189f41500
--- /dev/null
+++ b/tests/particle_exclude_one_property_vtu.prm.bak
@@ -0,0 +1,117 @@
+#########################################################
+# This is a variation of the composition-passive.prm
+# parameter file, with the exception that we also
+# advect along a set of particles and that we do not longer
+# compute temperature statistics and composition statistics
+# as part of postprocessing
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0 #0.1
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-passive-particles-explicit2-output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format       = vtu
+    set Exclude output properties = initial C_9
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 10
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 100
+    end
+  end
+end
diff --git a/tests/particle_exclude_three_properties_vtu.prm.bak b/tests/particle_exclude_three_properties_vtu.prm.bak
new file mode 100644
index 00000000000..c144738f218
--- /dev/null
+++ b/tests/particle_exclude_three_properties_vtu.prm.bak
@@ -0,0 +1,117 @@
+#########################################################
+# This is a variation of the composition-passive.prm
+# parameter file, with the exception that we also
+# advect along a set of particles and that we do not longer
+# compute temperature statistics and composition statistics
+# as part of postprocessing
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0 #0.1
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-passive-particles-explicit2-output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format       = vtu
+    set Exclude output properties = initial C_2, initial C_4, initial C_9
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 10
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 100
+    end
+  end
+end
diff --git a/tests/particle_exclude_two_properties_vtu.prm.bak b/tests/particle_exclude_two_properties_vtu.prm.bak
new file mode 100644
index 00000000000..38373ef7bc2
--- /dev/null
+++ b/tests/particle_exclude_two_properties_vtu.prm.bak
@@ -0,0 +1,117 @@
+#########################################################
+# This is a variation of the composition-passive.prm
+# parameter file, with the exception that we also
+# advect along a set of particles and that we do not longer
+# compute temperature statistics and composition statistics
+# as part of postprocessing
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0 #0.1
+set Use years in output instead of seconds = false
+set Output directory                       = output-composition-passive-particles-explicit2-output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format       = vtu
+    set Exclude output properties = initial C_2, initial C_9
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 10
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 100
+    end
+  end
+end
diff --git a/tests/particle_fast_evaluate_many_compositions.prm.bak b/tests/particle_fast_evaluate_many_compositions.prm.bak
new file mode 100644
index 00000000000..3134e3b543e
--- /dev/null
+++ b/tests/particle_fast_evaluate_many_compositions.prm.bak
@@ -0,0 +1,116 @@
+# A test based on Issue 4356: https://github.com/geodynamics/aspect/issues/4356
+# It tests that in models with multiple compositions the compositions
+# are correctly evaluated at the particle locations, even when using the
+# deal.II class FEPointEvaluation.
+
+set Adiabatic surface temperature          = 1623
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Dimension                              = 2
+set End time                               = 0
+set Pressure normalization                 = no
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 21
+  set Compositional field methods = static
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Initial temperature
+    set Maximal temperature = 3773
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = bottom, top
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+
+  subsection Function
+    set Function expression = 0;-1.65673998e-4
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 10
+    set Y extent  = 400
+    set Y repetitions = 40
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 2;4;6;8;10;12;14;16;18;20;22;24;26;28;30;32;34;36;38;40;42
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 2
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+end
+
+subsection Postprocess
+  set List of postprocessors = particles,visualization,composition statistics,velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Time between graphical output = 5e5
+  end
+
+  subsection Particles
+    set Time between data output      = 0
+    set Data output format            = gnuplot
+  end
+end
+
+subsection Particles
+  set List of particle properties   = composition
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles           = 10
+    end
+  end
+end
diff --git a/tests/particle_fast_evaluate_multiple_compositions.prm.bak b/tests/particle_fast_evaluate_multiple_compositions.prm.bak
new file mode 100644
index 00000000000..6e445da7ecd
--- /dev/null
+++ b/tests/particle_fast_evaluate_multiple_compositions.prm.bak
@@ -0,0 +1,116 @@
+# A test based on Issue 4356: https://github.com/geodynamics/aspect/issues/4356
+# It tests that in models with multiple compositions the compositions
+# are correctly evaluated at the particle locations, even when using the
+# deal.II class FEPointEvaluation.
+
+set Adiabatic surface temperature          = 1623
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Dimension                              = 2
+set End time                               = 0
+set Pressure normalization                 = no
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = porosity,peridotite, 3
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Initial temperature
+    set Maximal temperature = 3773
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = bottom, top
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+
+  subsection Function
+    set Function expression = 0;-1.65673998e-4
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 10
+    set Y extent  = 400
+    set Y repetitions = 40
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 2;5;8
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 2
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+end
+
+subsection Postprocess
+  set List of postprocessors = particles,visualization,composition statistics,velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Time between graphical output = 5e5
+  end
+
+  subsection Particles
+    set Time between data output      = 0
+    set Data output format            = gnuplot
+  end
+end
+
+subsection Particles
+  set List of particle properties   = composition
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles           = 10
+    end
+  end
+end
diff --git a/tests/particle_free_surface.prm.bak b/tests/particle_free_surface.prm.bak
new file mode 100644
index 00000000000..589a9343780
--- /dev/null
+++ b/tests/particle_free_surface.prm.bak
@@ -0,0 +1,114 @@
+# A test that checks particles combined with a free surface.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+set Pressure normalization                 = no
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = uniform box
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.3
+      set Maximum x = 0.5
+      set Minimum y = 0.1
+      set Maximum y = 0.3
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_generator_ascii.prm.bak b/tests/particle_generator_ascii.prm.bak
new file mode 100644
index 00000000000..8ffb1d07070
--- /dev/null
+++ b/tests/particle_generator_ascii.prm.bak
@@ -0,0 +1,108 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and therefore
+# tests the behavior of the particles.
+
+# MPI: 4
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Particle generator name = ascii file
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+  end
+end
diff --git a/tests/particle_generator_box.prm.bak b/tests/particle_generator_box.prm.bak
new file mode 100644
index 00000000000..98dd82b843c
--- /dev/null
+++ b/tests/particle_generator_box.prm.bak
@@ -0,0 +1,113 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and therefore
+# tests the behavior of the particles.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = uniform box
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.3
+      set Maximum x = 0.5
+      set Minimum y = 0.1
+      set Maximum y = 0.3
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_generator_box_3d.prm.bak b/tests/particle_generator_box_3d.prm.bak
new file mode 100644
index 00000000000..5f301bfde21
--- /dev/null
+++ b/tests/particle_generator_box_3d.prm.bak
@@ -0,0 +1,118 @@
+# This is a modification of the van-keken-particle tests.
+# It tests the uniform box particle generator in 3d,
+# and the ascii particle output.
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 10
+set Use years in output instead of seconds = false
+set CFL number                             = 1.0
+set Timing output frequency                = 100
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set Z extent  = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, front, back
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Particle generator name = uniform box
+  set Integration scheme = euler
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.3
+      set Maximum x = 0.55
+      set Minimum y = 0.2
+      set Maximum y = 0.3
+      set Minimum z = 0.1
+      set Maximum z = 0.4
+      set Number of particles = 30
+    end
+  end
+end
diff --git a/tests/particle_generator_quadrature_points.prm.bak b/tests/particle_generator_quadrature_points.prm.bak
new file mode 100644
index 00000000000..d1b4a957c16
--- /dev/null
+++ b/tests/particle_generator_quadrature_points.prm.bak
@@ -0,0 +1,108 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and therefore
+# tests the behavior of the particles.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0
+  set Refinement fraction                = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = quadrature points
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+  end
+end
diff --git a/tests/particle_generator_radial.prm.bak b/tests/particle_generator_radial.prm.bak
new file mode 100644
index 00000000000..c5089440b1e
--- /dev/null
+++ b/tests/particle_generator_radial.prm.bak
@@ -0,0 +1,116 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and therefore
+# tests the behavior of the particles.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Particle generator name = uniform radial
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Uniform radial
+      set Minimum radius = 0.05
+      set Maximum radius = 0.15
+      set Minimum longitude = 0.0
+      set Maximum longitude = 270.0
+      set Center x = 0.4
+      set Center y = 0.2
+      set Radial layers = 2
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_generator_random_uniform.prm.bak b/tests/particle_generator_random_uniform.prm.bak
new file mode 100644
index 00000000000..7ad7b6f0f44
--- /dev/null
+++ b/tests/particle_generator_random_uniform.prm.bak
@@ -0,0 +1,109 @@
+# This test is a copy of particle_generator_reference_cell and tests
+# the same model for the random uniform particle generator.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0
+  set Refinement fraction                = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Random cell selection = true
+      set Number of particles = 256
+    end
+  end
+end
diff --git a/tests/particle_generator_random_uniform_3mpi_1particle.prm.bak b/tests/particle_generator_random_uniform_3mpi_1particle.prm.bak
new file mode 100644
index 00000000000..86364a4af97
--- /dev/null
+++ b/tests/particle_generator_random_uniform_3mpi_1particle.prm.bak
@@ -0,0 +1,109 @@
+# This test is a copy of particle_generator_reference_cell and tests
+# the same model for the random uniform particle generator.
+
+# MPI: 3
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0
+  set Refinement fraction                = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Random cell selection = true
+      set Number of particles = 1
+    end
+  end
+end
diff --git a/tests/particle_generator_random_uniform_3mpi_2particle.prm.bak b/tests/particle_generator_random_uniform_3mpi_2particle.prm.bak
new file mode 100644
index 00000000000..b8be7bde0ea
--- /dev/null
+++ b/tests/particle_generator_random_uniform_3mpi_2particle.prm.bak
@@ -0,0 +1,109 @@
+# This test is a copy of particle_generator_reference_cell and tests
+# the same model for the random uniform particle generator.
+
+# MPI: 3
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0
+  set Refinement fraction                = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Random cell selection = true
+      set Number of particles = 2
+    end
+  end
+end
diff --git a/tests/particle_generator_random_uniform_3mpi_3particle.prm.bak b/tests/particle_generator_random_uniform_3mpi_3particle.prm.bak
new file mode 100644
index 00000000000..79281a87281
--- /dev/null
+++ b/tests/particle_generator_random_uniform_3mpi_3particle.prm.bak
@@ -0,0 +1,109 @@
+# This test is a copy of particle_generator_reference_cell and tests
+# the same model for the random uniform particle generator.
+
+# MPI: 3
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0
+  set Refinement fraction                = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Random cell selection = true
+      set Number of particles = 3
+    end
+  end
+end
diff --git a/tests/particle_generator_random_uniform_3mpi_4particle.prm.bak b/tests/particle_generator_random_uniform_3mpi_4particle.prm.bak
new file mode 100644
index 00000000000..5895a8b5cd2
--- /dev/null
+++ b/tests/particle_generator_random_uniform_3mpi_4particle.prm.bak
@@ -0,0 +1,109 @@
+# This test is a copy of particle_generator_reference_cell and tests
+# the same model for the random uniform particle generator.
+
+# MPI: 3
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0
+  set Refinement fraction                = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Random cell selection = true
+      set Number of particles = 4
+    end
+  end
+end
diff --git a/tests/particle_generator_random_uniform_deterministic_cell.prm.bak b/tests/particle_generator_random_uniform_deterministic_cell.prm.bak
new file mode 100644
index 00000000000..9d7b0a27b85
--- /dev/null
+++ b/tests/particle_generator_random_uniform_deterministic_cell.prm.bak
@@ -0,0 +1,110 @@
+# This test is a copy of particle_generator_random_uniform and tests
+# the same model, but with the number of particles per cell chosen
+# deterministically according to their particle density.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0
+  set Refinement fraction                = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Random cell selection = false
+      set Number of particles = 256
+    end
+  end
+end
diff --git a/tests/particle_generator_random_uniform_empty_rank.prm.bak b/tests/particle_generator_random_uniform_empty_rank.prm.bak
new file mode 100644
index 00000000000..24f5c9372c3
--- /dev/null
+++ b/tests/particle_generator_random_uniform_empty_rank.prm.bak
@@ -0,0 +1,109 @@
+# This test tests the random uniform particle generator if one
+# MPI rank has no cells.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0
+  set Refinement fraction                = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Random cell selection = false
+      set Number of particles = 1
+    end
+  end
+end
diff --git a/tests/particle_generator_reference_cell.prm.bak b/tests/particle_generator_reference_cell.prm.bak
new file mode 100644
index 00000000000..20846eedcab
--- /dev/null
+++ b/tests/particle_generator_reference_cell.prm.bak
@@ -0,0 +1,111 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and therefore
+# tests the behavior of the particles.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0
+  set Refinement fraction                = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = reference cell
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 4
+    end
+  end
+end
diff --git a/tests/particle_handler_copy.cc.bak b/tests/particle_handler_copy.cc.bak
new file mode 100644
index 00000000000..86abc4a9c1b
--- /dev/null
+++ b/tests/particle_handler_copy.cc.bak
@@ -0,0 +1,83 @@
+/*
+  Copyright (C) 2020 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_signals.h>
+#include <aspect/particle/world.h>
+
+#include <deal.II/particles/particle_handler.h>
+
+#include <iostream>
+
+using namespace aspect;
+
+template <int dim>
+void duplicate_particle_handler(const SimulatorAccess<dim> &simulator_access,
+                                const bool,
+                                const unsigned int,
+                                const SolverControl &)
+{
+  const auto &particle_world = simulator_access.get_particle_world(0);
+  dealii::Particles::ParticleHandler<dim> particle_handler;
+  std::cout << "duplicating particle handler" << std::endl;
+
+  particle_world.copy_particle_handler(particle_world.get_particle_handler(),
+                                       particle_handler);
+
+  auto copied_particle = particle_handler.begin();
+  for (const auto &particle: particle_world.get_particle_handler())
+    {
+      std::cout << "Original position: " << particle.get_location()
+                << ". Copied position: " << copied_particle->get_location() << std::endl;
+      std::cout << "Original properties: " << particle.get_properties()[0]
+                << ". Copied properties: " << copied_particle->get_properties()[0] << std::endl;
+      ++copied_particle;
+    }
+
+  particle_handler.begin()->get_properties()[0] = 3.14;
+
+  std::cout << "resetting changed particle handler" << std::endl;
+
+  auto &non_const_particle_handler = const_cast<dealii::Particles::ParticleHandler<dim> &>(particle_world.get_particle_handler());
+
+  particle_world.copy_particle_handler(particle_handler,
+                                       non_const_particle_handler);
+
+  copied_particle = particle_handler.begin();
+  for (const auto &particle: particle_world.get_particle_handler())
+    {
+      std::cout << "Original position: " << particle.get_location()
+                << ". Copied position: " << copied_particle->get_location() << std::endl;
+      std::cout << "Original properties: " << particle.get_properties()[0]
+                << ". Copied properties: " << copied_particle->get_properties()[0] << std::endl;
+      ++copied_particle;
+    }
+}
+
+
+template <int dim>
+void signal_connector (SimulatorSignals<dim> &signals)
+{
+  std::cout << "Connecting signals" << std::endl;
+  signals.post_advection_solver.connect (&duplicate_particle_handler<dim>);
+}
+
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/particle_handler_copy.prm.bak b/tests/particle_handler_copy.prm.bak
new file mode 100644
index 00000000000..9f4a41f4754
--- /dev/null
+++ b/tests/particle_handler_copy.prm.bak
@@ -0,0 +1,96 @@
+# A test for the Particle::World::copy_particle_handler
+# function that copies the particle handler (and all contained
+# particles), modifies one of them, and then resets the
+# the particles every time the composition system is solved.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom, top
+  set Tangential velocity boundary indicators = left, right
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity
+  set Particle generator name = uniform box
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.3
+      set Maximum x = 0.5
+      set Minimum y = 0.1
+      set Maximum y = 0.3
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_initial_adaptive_output.prm.bak b/tests/particle_initial_adaptive_output.prm.bak
new file mode 100644
index 00000000000..befcbec15a6
--- /dev/null
+++ b/tests/particle_initial_adaptive_output.prm.bak
@@ -0,0 +1,107 @@
+# This tests the behavior of the particles postprocessor, when the
+# 'Run postprocessors on initial refinement option is set. We do not
+# want to advect the particles in this case, because we are solving the
+# first timestep multiple times.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Run postprocessors on initial refinement = true
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Particle generator name = uniform box
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.3
+      set Maximum x = 0.5
+      set Minimum y = 0.1
+      set Maximum y = 0.3
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_initial_adaptive_refinement.prm.bak b/tests/particle_initial_adaptive_refinement.prm.bak
new file mode 100644
index 00000000000..db6638ffa46
--- /dev/null
+++ b/tests/particle_initial_adaptive_refinement.prm.bak
@@ -0,0 +1,107 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and therefore
+# tests the behavior of the particles.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set Particle generator name = uniform box
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.3
+      set Maximum x = 0.5
+      set Minimum y = 0.1
+      set Maximum y = 0.3
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_integrator_euler.prm.bak b/tests/particle_integrator_euler.prm.bak
new file mode 100644
index 00000000000..c22c0388f19
--- /dev/null
+++ b/tests/particle_integrator_euler.prm.bak
@@ -0,0 +1,109 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and therefore
+# tests the behavior of the particles.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Integration scheme = euler
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_integrator_rk2_first_order_time.prm.bak b/tests/particle_integrator_rk2_first_order_time.prm.bak
new file mode 100644
index 00000000000..abadc067245
--- /dev/null
+++ b/tests/particle_integrator_rk2_first_order_time.prm.bak
@@ -0,0 +1,26 @@
+# This test is like particle_integrator_euler.prm, but
+# tests the behavior of the particles when integrated using the RK2
+# integrator, and only using one velocity field.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+include $ASPECT_SOURCE_DIR/tests/particle_integrator_euler.prm
+
+
+subsection Postprocess
+  subsection Particles
+    set Data output format = gnuplot
+  end
+end
+
+subsection Particles
+  set Integration scheme = rk2
+
+  subsection Integrator
+    subsection RK2
+      set Higher order accurate in time = false
+    end
+  end
+end
diff --git a/tests/particle_integrator_rk4.prm.bak b/tests/particle_integrator_rk4.prm.bak
new file mode 100644
index 00000000000..ae322391790
--- /dev/null
+++ b/tests/particle_integrator_rk4.prm.bak
@@ -0,0 +1,109 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and therefore
+# tests the behavior of the particles.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Integration scheme = rk4
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_interpolator_bilinear_3d.prm.bak b/tests/particle_interpolator_bilinear_3d.prm.bak
new file mode 100644
index 00000000000..304532508db
--- /dev/null
+++ b/tests/particle_interpolator_bilinear_3d.prm.bak
@@ -0,0 +1,118 @@
+# This is a variation of the particle_interpolator_cell_average_2
+# test that includes a time varying solution with active particles.
+# In particular this test was introduced to check for the accuracy
+# of the bilinear_least_squares interpolator in 3D
+
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = .1
+set Use years in output instead of seconds = false
+set Output directory = output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top, front, back
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 1
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Data output format       = none
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Compositional field methods = particles
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = if(y<0.2*x, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+  set Interpolation scheme = bilinear least squares
+  set Update ghost particles   = true
+  set Particle generator name = reference cell
+
+  subsection Interpolator
+    subsection Bilinear least squares
+      set Use linear least squares limiter = true
+    end
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 2
+    end
+  end
+end
diff --git a/tests/particle_interpolator_bilinear_3d_add_particles.prm.bak b/tests/particle_interpolator_bilinear_3d_add_particles.prm.bak
new file mode 100644
index 00000000000..1c299b419a3
--- /dev/null
+++ b/tests/particle_interpolator_bilinear_3d_add_particles.prm.bak
@@ -0,0 +1,113 @@
+# This is a variation of the particle_interpolator_bilinear_3d test that tests
+# that the bilinear least squares interpolator can fall back on a nearest
+# neighbor interpolator if there are too few particles in a cell.
+
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = .1
+set Use years in output instead of seconds = false
+set Output directory = output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top, front, back
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 1
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Data output format       = vtu #none
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Compositional field methods = particles
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = if(y<0.2*x, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+  set Interpolation scheme = bilinear least squares
+  set Update ghost particles   = true
+  set Load balancing strategy = add particles, repartition
+  set Minimum particles per cell = 4
+  set Particle generator name = reference cell
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 1
+    end
+  end
+end
diff --git a/tests/particle_interpolator_bilinear_add_particles.cc.bak b/tests/particle_interpolator_bilinear_add_particles.cc.bak
new file mode 100644
index 00000000000..003736a2955
--- /dev/null
+++ b/tests/particle_interpolator_bilinear_add_particles.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_bilinear_add_particles.prm.bak b/tests/particle_interpolator_bilinear_add_particles.prm.bak
new file mode 100644
index 00000000000..f127cb44a1a
--- /dev/null
+++ b/tests/particle_interpolator_bilinear_add_particles.prm.bak
@@ -0,0 +1,118 @@
+# A test based on the SolKz benchmark that ensures that additional particles
+# are added to the model during the computation with multiple properties on
+# the particles.
+
+set Additional shared libraries            = ./libsolkz_compositional_fields.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolKzCompositionalMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = density_comp, viscosity_comp
+  set Compositional field methods = particles, particles
+  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, SolKzPostprocessor
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = bilinear least squares
+  set Minimum particles per cell = 50
+  set Maximum particles per cell = 16384
+  set Load balancing strategy = remove and add particles
+  set Update ghost particles = true
+  set Particle generator name = reference cell
+
+  subsection Function
+    set Number of components = 2
+    set Variable names      = x, z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression =  -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 7
+    end
+  end
+
+  subsection Interpolator
+    subsection Bilinear least squares
+      set Use linear least squares limiter = true, true
+      set Use boundary extrapolation = true, true
+    end
+  end
+end
diff --git a/tests/particle_interpolator_bilinear_least_squares_solkz.cc.bak b/tests/particle_interpolator_bilinear_least_squares_solkz.cc.bak
new file mode 100644
index 00000000000..003736a2955
--- /dev/null
+++ b/tests/particle_interpolator_bilinear_least_squares_solkz.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_bilinear_least_squares_solkz.prm.bak b/tests/particle_interpolator_bilinear_least_squares_solkz.prm.bak
new file mode 100644
index 00000000000..691106d556b
--- /dev/null
+++ b/tests/particle_interpolator_bilinear_least_squares_solkz.prm.bak
@@ -0,0 +1,115 @@
+# A test based on the SolKz benchmark that performs bilinear
+# least squares interpolation from particle properties to
+# compositional fields that are flagged as 'particle' advected fields.
+
+set Additional shared libraries            = ./libparticle_interpolator_bilinear_least_squares_solkz.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolKzCompositionalMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = density_comp, viscosity_comp
+  set Compositional field methods = particles, particles
+  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, SolKzPostprocessor, composition statistics
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = bilinear least squares
+  set Maximum particles per cell = 16384
+  set Update ghost particles = true
+  set Particle generator name = reference cell
+
+  subsection Function
+    set Number of components = 2
+    set Variable names      = x, z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression =  -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 4
+    end
+  end
+
+  subsection Interpolator
+    subsection Bilinear least squares
+      set Use linear least squares limiter = true
+    end
+  end
+end
diff --git a/tests/particle_interpolator_bilinear_limiter.prm.bak b/tests/particle_interpolator_bilinear_limiter.prm.bak
new file mode 100644
index 00000000000..5f2e9f7acdc
--- /dev/null
+++ b/tests/particle_interpolator_bilinear_limiter.prm.bak
@@ -0,0 +1,120 @@
+#########################################################
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Output directory                       = output
+set CFL number                             = 0.25
+set Maximum time step                      = 0.25
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom,top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities = 1, 2, 0
+    set Viscosities = 1, 1000, 0.001
+    set Viscosity averaging scheme = geometric
+    set Thermal expansivities = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, composition statistics, pressure statistics, material statistics, global statistics, particles
+
+  subsection Visualization
+    set Output format = none
+  end
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+# Here, we track compositional fields via active particle particles.
+# The initial composition assigned to the particles is 'mapped'
+# to the particles at each time step.  This property is accessed in
+# the material model through a compositional field (standard method)
+# whose values are interpolated from the particles.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = sphere, air
+  set Compositional field methods = particles, particles
+  set Mapped particle properties = sphere:initial sphere, air: initial air
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = r=0.123456789, xc=0.5, yc=0.6
+    set Function expression = if(sqrt((x-xc)*(x-xc)+(y-yc)*(y-yc)) < r, 1, 0) ; if (y>0.75,1,0)
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity, initial composition, initial position #, integrated strain
+  set Interpolation scheme = bilinear least squares
+  set Update ghost particles = true
+  set Particle generator name = reference cell
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 3
+    end
+  end
+
+  subsection Interpolator
+    subsection Bilinear least squares
+      set Use linear least squares limiter = true
+    end
+  end
+end
diff --git a/tests/particle_interpolator_cell_average.prm.bak b/tests/particle_interpolator_cell_average.prm.bak
new file mode 100644
index 00000000000..113b72e48c7
--- /dev/null
+++ b/tests/particle_interpolator_cell_average.prm.bak
@@ -0,0 +1,125 @@
+# A test that performs interpolation from particle properties to
+# compositional fields that are flagged as 'particle' advected
+# fields.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = advection_field, advection_particle, advection_particle2
+  set Compositional field methods = field, particles, particles
+  set Mapped particle properties = advection_particle2:velocity [1], advection_particle:function
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02));0.0;0.0
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 70
+  end
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity, function, initial composition
+  set Interpolation scheme = cell average
+  set Update ghost particles = true
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Variable names      = x,z
+      set Function expression = x*x*z
+      set Number of particles = 100000
+    end
+  end
+end
diff --git a/tests/particle_interpolator_cell_average_2.prm.bak b/tests/particle_interpolator_cell_average_2.prm.bak
new file mode 100644
index 00000000000..20edea67973
--- /dev/null
+++ b/tests/particle_interpolator_cell_average_2.prm.bak
@@ -0,0 +1,119 @@
+#########################################################
+# This is a variation of the composition-passive.prm
+# parameter file, with the exception that we also
+# advect along a set of particles that
+#
+# See the manual for more information about this setup.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.03
+set Use years in output instead of seconds = false
+set Output directory                       = output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics
+
+  subsection Particles
+    set Time between data output = 0.03
+    set Data output format       = none
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+  set Compositional field methods = particles
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+  set Update ghost particles   = true
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 20000
+    end
+  end
+end
diff --git a/tests/particle_interpolator_empty_cells.prm.bak b/tests/particle_interpolator_empty_cells.prm.bak
new file mode 100644
index 00000000000..01749438db6
--- /dev/null
+++ b/tests/particle_interpolator_empty_cells.prm.bak
@@ -0,0 +1,100 @@
+# A test that makes sure the 'cell average' particle interpolator
+# does not crash when single cells do not contain particles.
+
+set Dimension                               = 2
+set End time                                = 7e9
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent    = 1000000.0
+    set Y extent    =  450000.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators     = top, bottom
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators         = left, right, bottom, top
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields  = c1
+  set Compositional field methods = particles
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = arithmetic average
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z,t
+    set Function expression = if(((450000-z)<=55e3),1,0)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z,t
+    set Function expression = min(1350/(85e3+15e3*sin(x/100e3))*(450000-z)+293,1350+293)
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                 = 5
+  set Initial adaptive refinement               = 3
+  set Run postprocessors on initial refinement  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = particles, particle count statistics
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 3
+end
+
+subsection Particles
+  set List of particle properties = initial composition, initial position
+  set Interpolation scheme = cell average
+  set Update ghost particles = true
+  set Particle generator name = random uniform
+  set Minimum particles per cell = 2
+  set Maximum particles per cell = 100
+  set Load balancing strategy = remove and add particles
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 2500
+    end
+  end
+end
diff --git a/tests/particle_interpolator_from_ghost_cells.prm.bak b/tests/particle_interpolator_from_ghost_cells.prm.bak
new file mode 100644
index 00000000000..ac709190437
--- /dev/null
+++ b/tests/particle_interpolator_from_ghost_cells.prm.bak
@@ -0,0 +1,102 @@
+# A test that makes sure the 'cell average' particle interpolator
+# also uses data from ghost particles to compute the averaged
+# properties in a cell without particles.
+
+# MPI: 2
+
+set Dimension                               = 2
+set End time                                = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent    = 1000000.0
+    set Y extent    =  450000.0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators     = top, bottom
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators         = left, right, bottom, top
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Compositional field methods = particles
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = arithmetic average
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z,t
+    set Function expression = if(((450000-z)<=225000),1,0)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z,t
+    set Function expression = 1613
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                 = 4
+  set Initial adaptive refinement               = 0
+  set Time steps between mesh refinement         = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = particles, particle count statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+    set List of output variables = particle count, partition
+  end
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+  set Particle generator name = random uniform
+  set Minimum particles per cell = 2
+  set Maximum particles per cell = 100
+  set Load balancing strategy = none
+  set Update ghost particles = true
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 400
+    end
+  end
+end
diff --git a/tests/particle_interpolator_harmonic_average_solkz.cc.bak b/tests/particle_interpolator_harmonic_average_solkz.cc.bak
new file mode 100644
index 00000000000..003736a2955
--- /dev/null
+++ b/tests/particle_interpolator_harmonic_average_solkz.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_harmonic_average_solkz.prm.bak b/tests/particle_interpolator_harmonic_average_solkz.prm.bak
new file mode 100644
index 00000000000..42e61829847
--- /dev/null
+++ b/tests/particle_interpolator_harmonic_average_solkz.prm.bak
@@ -0,0 +1,119 @@
+# A test based on the SolKz benchmark that performs a cellwise
+# average using harmonic averaging from particle properties to
+# compositional fields that are flagged as 'particle' advected fields.
+
+# Note that since the test performs harmonic averaging, the density
+# values being averaged all have to be positive, which required a
+# modification of the original density from the benchmark. Therefore,
+# the error in pressure is large (since the pressure no longer
+# corresponds to the analytical solution).
+
+set Additional shared libraries            = ./libparticle_interpolator_harmonic_average_solkz.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolKzCompositionalMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = density_comp, viscosity_comp
+  set Compositional field methods = particles, particles
+  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
+end
+
+# The initial condition is adapted from the original solkz benchmark by adding a constant
+# value of 1 to keep all properties positive (which is necessary for harmonic averaging)
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression = 1 - sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, SolKzPostprocessor
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = harmonic average
+  set Maximum particles per cell = 4096
+  set Update ghost particles = true
+  set Particle generator name = reference cell
+
+  # The initial condition is adapted from the original solkz benchmark by adding a constant
+  # value of 1 to keep all properties positive (which is necessary for harmonic averaging)
+  subsection Function
+    set Number of components = 2
+    set Variable names      = x, z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression = 1 - sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 4
+    end
+  end
+end
diff --git a/tests/particle_interpolator_nearest_neighbor.prm.bak b/tests/particle_interpolator_nearest_neighbor.prm.bak
new file mode 100644
index 00000000000..bc0116c4279
--- /dev/null
+++ b/tests/particle_interpolator_nearest_neighbor.prm.bak
@@ -0,0 +1,127 @@
+# A test that performs interpolation from particle properties to
+# compositional fields that are flagged as 'particle' advected
+# fields.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 30
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = advection_field, advection_particle, advection_particle2
+  set Compositional field methods = field, particles, particles
+  set Mapped particle properties = advection_particle:initial advection_particle, advection_particle2:initial advection_particle2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = if(z>(0.4+0.02*cos(pi*x/0.9142)),1,0);0.0;0.0
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Minimum refinement level           = 4
+  set Time steps between mesh refinement = 1
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.5
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1
+  end
+
+  subsection Particles
+    set Time between data output = 1
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+  set Interpolation scheme = nearest neighbor
+  set Update ghost particles = true
+  set Maximum particles per cell = 10
+  set Minimum particles per cell = 10
+  set Particle generator name = uniform box
+  set Load balancing strategy = add particles
+
+  subsection Generator
+    subsection Probability density function
+      set Variable names      = x,z
+      set Function expression = 1 #x*x*z
+    end
+
+    subsection Uniform box
+      set Number of particles = 1000
+    end
+  end
+end
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.cc.bak b/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.cc.bak
new file mode 100644
index 00000000000..003736a2955
--- /dev/null
+++ b/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm.bak b/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm.bak
new file mode 100644
index 00000000000..a9d6687352b
--- /dev/null
+++ b/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm.bak
@@ -0,0 +1,120 @@
+# A test based on the particle version of the SolKz benchmark that (1) tests to
+# ensure that additional particles are added to the model during the computation
+# with multiple properties on the particles and (2) tests to ensure that the
+# particle methodology when used with the Quadratic Least Squares Particle
+# Interpolation algorithm correctly computes the particle version of the Solkz
+# benchmark.
+
+set Additional shared libraries            = ./libparticle_interpolator_quadratic_add_particles.so
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = SolKzCompositionalMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+############### Parameters describing the temperature field
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+############### Parameters describing the discretization
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Use locally conservative discretization = false
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = density_comp, viscosity_comp
+  set Compositional field methods = particles, particles
+  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, SolKzPostprocessor
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = quadratic least squares
+  set Minimum particles per cell = 10
+  set Maximum particles per cell = 16384
+  set Load balancing strategy = remove and add particles
+  set Update ghost particles = false
+  set Particle generator name = reference cell
+
+  subsection Function
+    set Number of components = 2
+    set Variable names      = x, z
+    set Function constants  = pi=3.1415926, eta_b=1e6
+    set Function expression =  -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 3
+    end
+  end
+
+  subsection Interpolator
+    subsection Quadratic least squares
+      set Use quadratic least squares limiter = false
+    end
+  end
+end
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_limiter.cc.bak b/tests/particle_interpolator_quadratic_least_squares_2d_limiter.cc.bak
new file mode 100644
index 00000000000..003736a2955
--- /dev/null
+++ b/tests/particle_interpolator_quadratic_least_squares_2d_limiter.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_limiter.prm.bak b/tests/particle_interpolator_quadratic_least_squares_2d_limiter.prm.bak
new file mode 100644
index 00000000000..bba2dbce22c
--- /dev/null
+++ b/tests/particle_interpolator_quadratic_least_squares_2d_limiter.prm.bak
@@ -0,0 +1,28 @@
+# A test based on the 2d version of the SolKz benchmark that (1) tests to
+# ensure that the particle methodology when used with the Quadratic Least
+# Squares Particle Interpolation algorithm correctly computes the particle
+# version of the Solkz benchmark and (2) tests that the Quadratic Least
+# Squares limiter is properly limiting, without disproportionately
+# affecting the accuracy of the interpolation algorithm.
+
+include $ASPECT_SOURCE_DIR/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm
+
+set Additional shared libraries            = ./libparticle_interpolator_quadratic_least_squares_2d_limiter.so
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+end
+
+subsection Particles
+  set Update ghost particles = true
+  set Load balancing strategy = none
+  set Minimum particles per cell = 7
+
+  subsection Interpolator
+    subsection Quadratic least squares
+      set Use quadratic least squares limiter = true
+      set Use boundary extrapolation = true
+    end
+  end
+end
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_periodic.prm.bak b/tests/particle_interpolator_quadratic_least_squares_2d_periodic.prm.bak
new file mode 100644
index 00000000000..e04238d9dd2
--- /dev/null
+++ b/tests/particle_interpolator_quadratic_least_squares_2d_periodic.prm.bak
@@ -0,0 +1,41 @@
+# A test for quadratic least squares interpolation with periodic boundaries
+
+# MPI: 2
+
+include $ASPECT_SOURCE_DIR/tests/particle_periodic_boundaries.prm
+
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Compositional fields
+  set Compositional field methods = particles
+  set Mapped particle properties = C_1:initial C_1
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles, composition statistics
+end
+
+subsection Particles
+  set Interpolation scheme = quadratic least squares
+  set Update ghost particles = true
+
+  subsection Interpolator
+    subsection Quadratic least squares
+      set Use quadratic least squares limiter = true
+    end
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10000
+    end
+  end
+end
diff --git a/tests/particle_interpolator_quadratic_least_squares_3d.prm.bak b/tests/particle_interpolator_quadratic_least_squares_3d.prm.bak
new file mode 100644
index 00000000000..15ad8f14364
--- /dev/null
+++ b/tests/particle_interpolator_quadratic_least_squares_3d.prm.bak
@@ -0,0 +1,119 @@
+# This is a variation of the particle_interpolator_bilinear_3d
+# test that includes a time varying solution with active particles.
+# In particular this test was introduced to check for the accuracy
+# of the quadratic_least_squares interpolator in 3D
+
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = .1
+set Use years in output instead of seconds = false
+set Output directory = temp_output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top, front, back
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 1
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Data output format       = none
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Compositional field methods = particles
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = if(y<0.2*x, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+  set Interpolation scheme = quadratic least squares
+  set Update ghost particles   = true
+  set Particle generator name = reference cell
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 3
+    end
+  end
+
+  subsection Interpolator
+    subsection Quadratic least squares
+      set Use quadratic least squares limiter = true
+      set Use boundary extrapolation = false
+    end
+  end
+end
diff --git a/tests/particle_interpolator_time_dependence.prm.bak b/tests/particle_interpolator_time_dependence.prm.bak
new file mode 100644
index 00000000000..d95e697b862
--- /dev/null
+++ b/tests/particle_interpolator_time_dependence.prm.bak
@@ -0,0 +1,109 @@
+# This is a variation of the particle_interpolator_cell_average_2
+# test that includes a time varying solution with active particles.
+# In particular this test was introduced to check for the accuracy
+# of the interpolation in time-varying flow.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.015 # 1 for complete run
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties
+    set Time between graphical output = 0
+  end
+
+  subsection Particles
+    set Time between data output = 0.03
+    set Data output format       = none
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Compositional field methods = particles
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2*x, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+  set Update ghost particles   = true
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 20000
+    end
+  end
+end
diff --git a/tests/particle_linear_accelerated_flow_rk2.prm.bak b/tests/particle_linear_accelerated_flow_rk2.prm.bak
new file mode 100644
index 00000000000..120b1798cd4
--- /dev/null
+++ b/tests/particle_linear_accelerated_flow_rk2.prm.bak
@@ -0,0 +1,86 @@
+# This test prescribes a velocity field in x direction of the form:
+# vx = 0.1 + t, where t is time. Therefore the position of
+# the single particle in this test follows:
+# x(t) = 0.5*t^2 + 0.1 * t, which results to:
+# x(1) = 0.6, for a particle starting at x(0)=0
+# Because the position is a polynomial of second order, and we use
+# a second-order time-accurate integrator (rk2), the particle arrives
+# at the exact end position.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function expression = 0.1+t;0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 0
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, particles
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables      = partition
+  end
+
+  subsection Particles
+    set Time between data output = 1
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Particle generator name = uniform box
+  set Integration scheme = rk2
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.0
+      set Maximum x = 0.1
+      set Minimum y = 0.5
+      set Maximum y = 0.55
+      set Number of particles = 1
+    end
+  end
+end
diff --git a/tests/particle_load_balancing_none.prm.bak b/tests/particle_load_balancing_none.prm.bak
new file mode 100644
index 00000000000..42bd0ffcf35
--- /dev/null
+++ b/tests/particle_load_balancing_none.prm.bak
@@ -0,0 +1,106 @@
+# A test for the particle load balancing strategy 'none'.
+# No load balancing is performed and the resulting imbalance is
+# recorded by the 'load balance statistics' postprocessor.
+
+# MPI: 4
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 4
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 1
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+  set Run postprocessors on initial refinement = true
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, particle count statistics, load balance statistics
+
+  subsection Particles
+    set Time between data output = 100
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set Load balancing strategy = none
+  set Integration scheme = euler
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1000
+    end
+  end
+end
diff --git a/tests/particle_load_balancing_refinement.prm.bak b/tests/particle_load_balancing_refinement.prm.bak
new file mode 100644
index 00000000000..5ada582d81d
--- /dev/null
+++ b/tests/particle_load_balancing_refinement.prm.bak
@@ -0,0 +1,105 @@
+# A test for the 'particle distribution' refinement plugin.
+# The cell are refined based on the numbers of particles they
+# contain.
+
+set Dimension                              = 2
+set End time                               = 100
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = particle density
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 1
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 100
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Load balancing strategy = none
+  set Integration scheme = euler
+  set Particle generator name = probability density function
+
+  subsection Generator
+    subsection Probability density function
+      set Variable names      = x,z
+      set Function expression = x*x*z
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_load_balancing_refinement_02.prm.bak b/tests/particle_load_balancing_refinement_02.prm.bak
new file mode 100644
index 00000000000..19679d80e72
--- /dev/null
+++ b/tests/particle_load_balancing_refinement_02.prm.bak
@@ -0,0 +1,105 @@
+# A test for the 'particle distribution' refinement plugin.
+# The cell are refined based on the numbers of particles they
+# contain.
+
+set Dimension                              = 2
+set End time                               = 500
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = particle density
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 1
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 100
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Load balancing strategy = none
+  set Integration scheme = euler
+  set Particle generator name = probability density function
+
+  subsection Generator
+    subsection Probability density function
+      set Variable names      = x,z
+      set Function expression = x*x*z
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_load_balancing_removal.prm.bak b/tests/particle_load_balancing_removal.prm.bak
new file mode 100644
index 00000000000..0878376e9a9
--- /dev/null
+++ b/tests/particle_load_balancing_removal.prm.bak
@@ -0,0 +1,103 @@
+# A test for the particle load balancing strategy 'remove particles'.
+# As soon as too many particles live in a cell, a fraction of them
+# is discarded.
+
+set Dimension                              = 2
+set End time                               = 100
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 1
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 100
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Load balancing strategy = remove particles
+  set Maximum particles per cell = 10
+  set Integration scheme = euler
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 100
+    end
+  end
+end
diff --git a/tests/particle_load_balancing_removal_addition.prm.bak b/tests/particle_load_balancing_removal_addition.prm.bak
new file mode 100644
index 00000000000..3ce8355a91a
--- /dev/null
+++ b/tests/particle_load_balancing_removal_addition.prm.bak
@@ -0,0 +1,106 @@
+# A test for the particle load balancing strategy 'remove and add particles'.
+# As soon as too many particles live in a cell, a fraction of them
+# is discarded. If too few particles live in this cell a number of particles
+# is generated at random positions in this cell to reach a user-set minimum
+# number.
+
+set Dimension                              = 2
+set End time                               = 100
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 1
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 100
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Load balancing strategy = remove and add particles
+  set Maximum particles per cell = 10
+  set Minimum particles per cell = 5
+  set Integration scheme = euler
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 100
+    end
+  end
+end
diff --git a/tests/particle_load_balancing_removal_addition_properties.prm.bak b/tests/particle_load_balancing_removal_addition_properties.prm.bak
new file mode 100644
index 00000000000..84caf69fc9b
--- /dev/null
+++ b/tests/particle_load_balancing_removal_addition_properties.prm.bak
@@ -0,0 +1,107 @@
+# A test for the particle load balancing strategy 'remove and add particles'.
+# This test is a copy of particle_load_balancing_removal_addition, except
+# that it additionally tests the generation and interpolation of
+# the properties of the newly generated particles.
+
+set Dimension                              = 2
+set End time                               = 500
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 1
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 500
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Load balancing strategy = remove and add particles
+  set List of particle properties = initial position, position
+  set Maximum particles per cell = 10
+  set Minimum particles per cell = 5
+  set Integration scheme = euler
+  set Update ghost particles = true
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 100
+    end
+  end
+end
diff --git a/tests/particle_load_balancing_repartition.prm.bak b/tests/particle_load_balancing_repartition.prm.bak
new file mode 100644
index 00000000000..60b97add43d
--- /dev/null
+++ b/tests/particle_load_balancing_repartition.prm.bak
@@ -0,0 +1,19 @@
+# A test for the particle load balancing strategy 'repartition'.
+#
+# The load is distributed according to a balanced weight defined
+# as: n_locally_owned_cells + particle_weight/1000 * n_locally_owned_particles.
+# This test uses the default particle weight.
+
+# MPI: 4
+
+include $ASPECT_SOURCE_DIR/tests/particle_load_balancing_none.prm
+
+set Dimension                              = 2
+
+subsection Postprocess
+end
+
+subsection Particles
+  set Load balancing strategy = repartition
+  set Particle weight = 10
+end
diff --git a/tests/particle_load_balancing_repartition_1000.prm.bak b/tests/particle_load_balancing_repartition_1000.prm.bak
new file mode 100644
index 00000000000..cceec166e6b
--- /dev/null
+++ b/tests/particle_load_balancing_repartition_1000.prm.bak
@@ -0,0 +1,20 @@
+# A test for the particle load balancing strategy 'repartition'.
+#
+# The load is distributed according to a balanced weight defined
+# as: n_locally_owned_cells + particle_weight/1000 * n_locally_owned_particles.
+# This test uses a large particle weight to ensure a good particle distribution
+# at the cost of an imbalance in the cell distribution.
+
+# MPI: 4
+
+include $ASPECT_SOURCE_DIR/tests/particle_load_balancing_none.prm
+
+set Dimension                              = 2
+
+subsection Postprocess
+end
+
+subsection Particles
+  set Load balancing strategy = repartition
+  set Particle weight = 1000
+end
diff --git a/tests/particle_melt_advection.cc.bak b/tests/particle_melt_advection.cc.bak
new file mode 100644
index 00000000000..41a9c23ffdf
--- /dev/null
+++ b/tests/particle_melt_advection.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "rising_melt_blob.cc"
diff --git a/tests/particle_melt_advection.prm.bak b/tests/particle_melt_advection.prm.bak
new file mode 100644
index 00000000000..258ed8a649b
--- /dev/null
+++ b/tests/particle_melt_advection.prm.bak
@@ -0,0 +1,166 @@
+# This is a test for the melt particle functionality.
+# It is the same setup as in the rising_melt_blob test,
+# with added passive particles that move with the melt
+# velocity. The test checks if the particles are moving
+# correctly, and if they are correctly labelled with the
+# property 'melt presence' if the porosity is above a
+# threshold at their location.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 3000 # 20000
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 50
+set CFL number                             = 0.2
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.2
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Bottom temperature = 1600
+    set Top temperature    = 293
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = #2,3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+
+  subsection Function
+    set Function constants  = b=100000, c=20000
+    set Variable names      = x,y
+    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 200000
+    set Y extent = 100000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 1e6
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
+    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
+  end
+end
+
+subsection Material model
+  set Model name = melting rate
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating #, latent heat melt, shear heating
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average, particles
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Interpolate output            = true
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+
+  subsection Depth average
+    set Number of zones = 12
+    set Time between graphical output = 6e5
+  end
+
+  subsection Particles
+    set Time between data output      = 0
+    set Data output format            = ascii
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint = 1700
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
+
+subsection Particles
+  set Particle generator name       = reference cell
+  set List of particle properties   = melt particle
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 1
+    end
+  end
+end
diff --git a/tests/particle_output_gnuplot.prm.bak b/tests/particle_output_gnuplot.prm.bak
new file mode 100644
index 00000000000..a01d1e7b972
--- /dev/null
+++ b/tests/particle_output_gnuplot.prm.bak
@@ -0,0 +1,107 @@
+# A simple test that checks the gnuplot output option for particles in parallel
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = gnuplot
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_output_hdf5.prm.bak b/tests/particle_output_hdf5.prm.bak
new file mode 100644
index 00000000000..373198fd6c0
--- /dev/null
+++ b/tests/particle_output_hdf5.prm.bak
@@ -0,0 +1,107 @@
+# A simple test that checks the hdf5 output option for particles in parallel
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = hdf5
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_output_multiple_formats.prm.bak b/tests/particle_output_multiple_formats.prm.bak
new file mode 100644
index 00000000000..2a48a19db93
--- /dev/null
+++ b/tests/particle_output_multiple_formats.prm.bak
@@ -0,0 +1,106 @@
+# A simple test that checks the possibility to write particle output in
+# multiple formats
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = gnuplot, vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_output_none.prm.bak b/tests/particle_output_none.prm.bak
new file mode 100644
index 00000000000..847d7f8d6c7
--- /dev/null
+++ b/tests/particle_output_none.prm.bak
@@ -0,0 +1,109 @@
+# This is a modification of the van-keken-particle tests.
+# It tests that the 'no output' particle output option works, i.e.
+# that no particle output is written, but the particles are generated and
+# advected. Since we can not test for not existing files the only test is
+# that no particle output file is mentioned in the screen output.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 10
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 30
+    end
+  end
+end
diff --git a/tests/particle_output_vtu.prm.bak b/tests/particle_output_vtu.prm.bak
new file mode 100644
index 00000000000..9304b79c6ca
--- /dev/null
+++ b/tests/particle_output_vtu.prm.bak
@@ -0,0 +1,107 @@
+# A simple test that checks the compressed vtu output option for particles in parallel
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_output_vtu_group.prm.bak b/tests/particle_output_vtu_group.prm.bak
new file mode 100644
index 00000000000..da030887079
--- /dev/null
+++ b/tests/particle_output_vtu_group.prm.bak
@@ -0,0 +1,110 @@
+# A simple test that checks the vtu output option for particles in parallel
+# In particular in this test we test the ability to group output into a single
+# file using MPI I/O.
+#
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+    set Number of grouped files = 1
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_output_vtu_temp.prm.bak b/tests/particle_output_vtu_temp.prm.bak
new file mode 100644
index 00000000000..11df7012a84
--- /dev/null
+++ b/tests/particle_output_vtu_temp.prm.bak
@@ -0,0 +1,109 @@
+# A simple test that checks the vtu output option for particles in parallel
+# In particular we here write to a temporary location first.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+    set Temporary output location = /tmp
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_periodic_boundaries.prm.bak b/tests/particle_periodic_boundaries.prm.bak
new file mode 100644
index 00000000000..26f0cdc0ac1
--- /dev/null
+++ b/tests/particle_periodic_boundaries.prm.bak
@@ -0,0 +1,114 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file and makes the
+# x boundary periodic to test the particle handling at these boundaries
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set X extent   = 0.9142
+    set Y extent   = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net x translation
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_periodic_boundaries_dc.prm.bak b/tests/particle_periodic_boundaries_dc.prm.bak
new file mode 100644
index 00000000000..2d3b4db6be2
--- /dev/null
+++ b/tests/particle_periodic_boundaries_dc.prm.bak
@@ -0,0 +1,35 @@
+# A test for periodic boundary conditions with particles
+
+# MPI: 2
+
+include $ASPECT_SOURCE_DIR/tests/particle_periodic_boundaries.prm
+
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Compositional fields
+  set Compositional field methods = particles
+  set Mapped particle properties = C_1:initial C_1
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Strategy                           = composition
+  set Initial global refinement          = 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles, composition statistics
+end
+
+subsection Particles
+  set Interpolation scheme = bilinear least squares
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10000
+    end
+  end
+end
diff --git a/tests/particle_periodic_boundaries_rk4.prm.bak b/tests/particle_periodic_boundaries_rk4.prm.bak
new file mode 100644
index 00000000000..6e5c2de2ea2
--- /dev/null
+++ b/tests/particle_periodic_boundaries_rk4.prm.bak
@@ -0,0 +1,113 @@
+# A description of the van Keken et al. benchmark.
+# This test adds particles to the cookbook parameter file and makes the
+# x boundary periodic to test the particle handling at these boundaries,
+# in particular for the RK4 velocity integration scheme.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 200
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set X extent   = 0.9142
+    set Y extent   = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net x translation
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 200
+    set Data output format = gnuplot
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_periodic_quarter_shell.prm.bak b/tests/particle_periodic_quarter_shell.prm.bak
new file mode 100644
index 00000000000..e4822ac7e94
--- /dev/null
+++ b/tests/particle_periodic_quarter_shell.prm.bak
@@ -0,0 +1,112 @@
+# This test adapts tests/particle_periodic_boundaries.prm to test the particle
+# handling at periodic boundaries in the polar direction for a quarter
+# spherical shell geometry.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 5
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3.481
+    set Outer radius = 6.336
+    set Phi periodic = true
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net x translation
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = r, phi
+    set Function constants  = pi=3.1415926
+    set Coordinate system = spherical
+    set Function expression = if( r < 4.195 + (0.3*sin(3*phi)) + (0.3*cos(3*phi)), 1, 0)
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles, visualization
+
+  subsection Particles
+    set Time between data output = 5
+    set Data output format = gnuplot
+  end
+end
+
+subsection Particles
+  set Integration scheme = euler
+  set Particle generator name = probability density function
+  set List of particle properties = function, initial composition, initial position
+
+  subsection Generator
+    subsection Probability density function
+      set Function expression = (y < 0.1) ? 1.0 : ((x < 0.1) ? 1.0 : 0.0)
+      set Number of particles = 50
+    end
+  end
+end
diff --git a/tests/particle_periodic_quarter_shell_2.prm.bak b/tests/particle_periodic_quarter_shell_2.prm.bak
new file mode 100644
index 00000000000..dc9385257ad
--- /dev/null
+++ b/tests/particle_periodic_quarter_shell_2.prm.bak
@@ -0,0 +1,122 @@
+# This test adapts tests/particle_periodic_quarter_shell.prm to test the particle
+# handling at periodic boundaries in the polar direction for a quarter
+# spherical shell geometry.
+# The velocity and the initial particle locations are prescribed so that we know
+# where particles should end up. The time step size is precribed in such a way
+# that particles at the outer boundary should move exactly half of a cell in
+# angular direction in each time step, and particles at the inner boundary move
+# exactly a quarter of a cell in angular direction in each time step.
+# (There are 96 cells in longitudinal direction.)
+
+set Dimension                              = 2
+set End time                               = 0.032725
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, no Stokes
+set Maximum time step                      = 0.00818125
+
+# We prescibe rotating flow with an angular velocity increase with radius
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Function expression = -y * sqrt(x*x+y*y); x * sqrt(x*x+y*y)
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 0.5
+    set Outer radius = 1
+    set Phi periodic = true
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1000
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = r, phi
+    set Function constants  = pi=3.1415926
+    set Coordinate system = spherical
+    set Function expression = if( r < 4.195 + (0.3*sin(3*phi)) + (0.3*cos(3*phi)), 1, 0)
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particle count statistics, particles, visualization
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = gnuplot
+  end
+end
+
+subsection Particles
+  set Particle generator name = uniform radial
+  set List of particle properties = function, position, reference position, initial position
+  set Integration scheme = rk2
+
+  subsection Generator
+    subsection Uniform radial
+      set Maximum latitude = 180
+      set Maximum longitude = 89.999
+      set Maximum radius = 0.9999
+      set Minimum latitude = 0.
+      set Minimum longitude = 89
+      set Minimum radius = 0.5001
+      set Radial layers = 10
+      set Number of particles = 50
+    end
+  end
+end
diff --git a/tests/particle_property_composition.cc.bak b/tests/particle_property_composition.cc.bak
new file mode 100644
index 00000000000..069053c7cd3
--- /dev/null
+++ b/tests/particle_property_composition.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solitary_wave/solitary_wave.cc"
diff --git a/tests/particle_property_composition.prm.bak b/tests/particle_property_composition.prm.bak
new file mode 100644
index 00000000000..db45740c57d
--- /dev/null
+++ b/tests/particle_property_composition.prm.bak
@@ -0,0 +1,188 @@
+# Listing of Parameters
+# ---------------------
+# Uses the solitary wave benchmark to demonstrate the particle property melt particle,
+# which records the presence of melt over the melt transport threshold
+
+set Additional shared libraries            = ./libsolitary_wave.so
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = particle_property_composition
+set Max nonlinear iterations               = 10
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.001
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity,peridotite
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+# we apply the phase speed of the wave here, so that it always stays in the same place in our model
+# the phase speed is c = 5.25e-11 m/s, but we have to convert it to m/years using the same conversion
+# that is used internally in ASPECT: year_in_seconds = 60*60*24*365.2425
+
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    #    set Function expression = 0;-8.2836999e-5
+    set Function expression = 0;-1.65673998e-4
+
+    #    set Function expression = 0;-3.31347996e-4
+    #    set Function expression = 0;-6.62695992e-4
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 10
+    set Y extent  = 400
+    set Y repetitions = 40
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Initial composition model
+  set Model name = Solitary wave initial condition
+
+  subsection Solitary wave initial condition
+    set Offset = 200
+    set Read solution from file = false
+    set Amplitude = 0.01
+    set Background porosity = 0.001
+  end
+end
+
+subsection Material model
+  set Model name = Solitary Wave
+
+  subsection Solitary wave
+    set Reference permeability = 5e-9
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 2
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = particles,visualization,composition statistics,velocity statistics,solitary wave statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = gnuplot
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 5e5
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+
+  subsection Particles
+    set Time between data output      = 0
+  end
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-14
+  set Temperature solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-10
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Particles
+  set Particle generator name       = ascii file
+  set List of particle properties   = composition
+
+  subsection Generator
+    subsection Ascii file
+      set Data file name            = particle_property_composition.txt
+    end
+  end
+end
diff --git a/tests/particle_property_function.prm.bak b/tests/particle_property_function.prm.bak
new file mode 100644
index 00000000000..eca0a29a958
--- /dev/null
+++ b/tests/particle_property_function.prm.bak
@@ -0,0 +1,113 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and specifically tests
+# the probability density function generator.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity,function, initial composition, initial position
+  set Particle generator name = probability density function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Variable names      = x,z
+      set Function expression = x*x*z
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_property_initial_composition.prm.bak b/tests/particle_property_initial_composition.prm.bak
new file mode 100644
index 00000000000..29c45a5e97e
--- /dev/null
+++ b/tests/particle_property_initial_composition.prm.bak
@@ -0,0 +1,106 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and specifically tests
+# the particle property initial composition and its naming scheme
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields  = anomaly
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial composition
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_property_initial_composition_boundary.prm.bak b/tests/particle_property_initial_composition_boundary.prm.bak
new file mode 100644
index 00000000000..6426861d1b3
--- /dev/null
+++ b/tests/particle_property_initial_composition_boundary.prm.bak
@@ -0,0 +1,103 @@
+# This is an extension of the particle_property_initial_composition test that
+# sets a boundary condition for the composition. Additional particles with the
+# initial composition property that are generated at this boundary are now
+# initialized with this boundary value, instead of the interpolated value of
+# other particles in that cell.
+
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom, top
+  set Tangential velocity boundary indicators = left, right
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields  = anomaly
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = left, bottom
+  set List of model names = box
+
+  subsection Box
+    set Left composition = -1.0
+    set Bottom composition = 3.0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = gnuplot
+  end
+end
+
+subsection Particles
+  set Particle generator name = reference cell
+  set List of particle properties = initial composition
+  set Load balancing strategy = add particles
+  set Minimum particles per cell = 40
+
+  subsection Generator
+  end
+end
diff --git a/tests/particle_property_integrated_strain_invariant.prm.bak b/tests/particle_property_integrated_strain_invariant.prm.bak
new file mode 100644
index 00000000000..3afb9c1e3b5
--- /dev/null
+++ b/tests/particle_property_integrated_strain_invariant.prm.bak
@@ -0,0 +1,112 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 10
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = particle_property_integrated_strain_invariant
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 1
+    set Data output format = ascii
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain invariant
+  set Particle generator name = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 100
+    end
+  end
+end
diff --git a/tests/particle_property_integrated_strain_pure_shear.prm.bak b/tests/particle_property_integrated_strain_pure_shear.prm.bak
new file mode 100644
index 00000000000..0785b14ce83
--- /dev/null
+++ b/tests/particle_property_integrated_strain_pure_shear.prm.bak
@@ -0,0 +1,92 @@
+# This model tests the particle property integrated strain in a pure shear deformation.
+# Particles at the bottom left experience only deformation and no rotation (perfect pure
+# shear), while particles at the upper right corner only experience solid body rotation
+# and no deformation.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left,bottom
+  set Prescribed velocity boundary indicators = top:function, right:function
+
+  subsection Function
+    set Function expression = 1-y; x-1
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 1.0
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain
+  set Particle generator name = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_property_integrated_strain_simple_shear.prm.bak b/tests/particle_property_integrated_strain_simple_shear.prm.bak
new file mode 100644
index 00000000000..a478e50f2db
--- /dev/null
+++ b/tests/particle_property_integrated_strain_simple_shear.prm.bak
@@ -0,0 +1,91 @@
+# This model tests the particle property integrated strain in a simple shear deformation.
+# All particles in the domain experience the same velocity gradients that lead to a combined
+# rotation and deformation.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 1
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set X periodic = true
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+
+  subsection Function
+    set Function expression = if (y < 0.5, -1, 1); 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles
+
+  subsection Particles
+    set Time between data output = 1
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain
+  set Particle generator name = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_property_multiple_functions.prm.bak b/tests/particle_property_multiple_functions.prm.bak
new file mode 100644
index 00000000000..96ec0638246
--- /dev/null
+++ b/tests/particle_property_multiple_functions.prm.bak
@@ -0,0 +1,115 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file with two particle properties
+# defined by two different functions. One is a discontinuous function and the other
+# is a smooth function.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity, function, initial composition, initial position
+  set Particle generator name = probability density function
+
+  subsection Function
+    set Number of components = 2
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 ); 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Variable names      = x,z
+      set Function expression = x*x*z
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_property_multiple_functions_with_interpolation.prm.bak b/tests/particle_property_multiple_functions_with_interpolation.prm.bak
new file mode 100644
index 00000000000..7ca7edd0853
--- /dev/null
+++ b/tests/particle_property_multiple_functions_with_interpolation.prm.bak
@@ -0,0 +1,118 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds active particles to the cookbook parameter file,
+# and interpolates two particle properties defined by two functions
+# onto two compositional fields.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = advection_field, advection_particle, advection_particle2
+  set Compositional field methods = field, particles, particles
+  set Mapped particle properties = advection_particle:function [0], advection_particle2:function [1]
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02));0.0;0.0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = velocity, function, initial composition
+  set Update ghost particles = true
+  set Particle generator name = random uniform
+
+  subsection Function
+    set Number of components = 2
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 ); 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Variable names      = x,z
+      set Function expression = x*x*z
+      set Number of particles = 1024
+    end
+  end
+end
diff --git a/tests/particle_property_post_initialize_function.cc.bak b/tests/particle_property_post_initialize_function.cc.bak
new file mode 100644
index 00000000000..d5c7d46c01e
--- /dev/null
+++ b/tests/particle_property_post_initialize_function.cc.bak
@@ -0,0 +1,86 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/simulator_access.h>
+#include <aspect/particle/property/interface.h>
+
+#include <iostream>
+
+unsigned int counter_without = 0, counter_with = 0;
+bool quiet = true;
+
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      template <int dim>
+      class PostInitializeParticleProperty : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+      {
+        public:
+
+          virtual
+          void
+          initialize ()
+          {
+            std::cout << "initialize" << std::endl;
+            const Particle::Property::Manager<dim> &manager = this->get_particle_world(this->get_particle_world_index()).get_property_manager();
+            post_initialized_info = manager.get_data_info().get_field_index_by_name("initial position");
+            std::cout << "initial position: post_initialized_info = " << post_initialized_info << std::endl;
+
+            post_initialized_info = manager.get_data_info().get_field_index_by_name("initial C_1");
+            std::cout << "initial composition C_1: post_initialized_info = " << post_initialized_info << std::endl;
+
+            post_initialized_info = manager.get_data_info().get_field_index_by_name("velocity");
+            std::cout << "velocity: post_initialized_info = " << post_initialized_info << std::endl;
+            exit(0);
+          }
+
+          virtual
+          std::vector<std::pair<std::string, unsigned int>>
+          get_property_information() const
+          {
+            return std::vector<std::pair<std::string, unsigned int>>();
+          }
+
+        private:
+          unsigned int post_initialized_info;
+
+      };
+    }
+  }
+}
+
+
+namespace aspect
+{
+  namespace Particle
+  {
+    namespace Property
+    {
+      ASPECT_REGISTER_PARTICLE_PROPERTY(PostInitializeParticleProperty,
+                                        "PostInitializeParticleProperty",
+                                        "")
+    }
+  }
+}
diff --git a/tests/particle_property_post_initialize_function.prm.bak b/tests/particle_property_post_initialize_function.prm.bak
new file mode 100644
index 00000000000..041646d981c
--- /dev/null
+++ b/tests/particle_property_post_initialize_function.prm.bak
@@ -0,0 +1,105 @@
+#########################################################
+# This is a variation of the particle_exclude_three_properties_vtu.prm
+# parameter file.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+
+  subsection Particles
+    set Time between data output = 0.1
+    set Data output format       = vtu
+    set Exclude output properties = initial C_2, initial C_9
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 10
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
+  end
+end
+
+subsection Particles
+  set List of particle properties = initial position, initial composition, PostInitializeParticleProperty, velocity
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles        = 100
+    end
+  end
+end
diff --git a/tests/particle_timing_information.prm.bak b/tests/particle_timing_information.prm.bak
new file mode 100644
index 00000000000..63decad61d4
--- /dev/null
+++ b/tests/particle_timing_information.prm.bak
@@ -0,0 +1,109 @@
+# This tests the behavior of the particles postprocessor, when the
+# 'Run postprocessors on initial refinement option is set. We do not
+# want to advect the particles in this case, because we are solving the
+# first timestep multiple times.
+
+# MPI: 2
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Run postprocessors on initial refinement = true
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = ascii
+  end
+end
+
+subsection Particles
+  set Particle generator name = uniform box
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.3
+      set Maximum x = 0.5
+      set Minimum y = 0.1
+      set Maximum y = 0.3
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/particle_visualization_particle_count.prm.bak b/tests/particle_visualization_particle_count.prm.bak
new file mode 100644
index 00000000000..de616e01b41
--- /dev/null
+++ b/tests/particle_visualization_particle_count.prm.bak
@@ -0,0 +1,110 @@
+# This is a copy of the particle_property_function test, but instead of the
+# function property it tests the 'particle count' visualization plugin that
+# outputs the number of particles per cell.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 70
+    set Output format = gnuplot
+    set List of output variables = particle count
+  end
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set Particle generator name = probability density function
+
+  subsection Generator
+    subsection Probability density function
+      set Variable names      = x,z
+      set Function expression = x*x*z
+      set Number of particles = 30
+    end
+  end
+end
diff --git a/tests/particles_with_AMR_on.prm.bak b/tests/particles_with_AMR_on.prm.bak
new file mode 100644
index 00000000000..d2dc06ca5ee
--- /dev/null
+++ b/tests/particles_with_AMR_on.prm.bak
@@ -0,0 +1,124 @@
+# A description of the falling box benchmark see the reference:
+# Gerya, T. V., Yuen, D. A., 2003a. Characteristics-based marker-in-cell method
+# with conservative finite-differences schemes for modeling geological flows with
+# strongly variable transport properties
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 5e5
+set Use years in output instead of seconds = true
+set CFL number                             = 1
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500e3
+    set Y extent  = 500e3
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# Thermal expansion coeff = 0 --> no temperature dependence
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3200
+    set Viscosity                     = 1e21
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = 100  # 3300 kg/m^3
+    set Composition viscosity prefactor = 1  # ONLY PARAMETER THAT CHANGES IN THESE TESTS
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = composition
+  set Compositional field methods = particles
+  set Mapped particle properties = composition:function
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(((x>187.5e3)&&(x<312.5e3)&&(z>312.5e3)&&(z<437.5e3)), 1, 0)
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Strategy                           = composition approximate gradient
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 1
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+  set Normalize individual refinement criteria = true
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Discretization
+  set Use discontinuous composition discretization = true
+end
+
+subsection Postprocess
+  set List of postprocessors = particles, velocity statistics, composition statistics
+
+  subsection Particles
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set Load balancing strategy = remove and add particles
+  set Minimum particles per cell = 9
+  set Maximum particles per cell = 36
+  set List of particle properties = function
+  set Integration scheme = rk2
+  set Interpolation scheme = cell average
+  set Update ghost particles = true
+  set Particle generator name = reference cell
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(((x>187.5e3)&&(x<312.5e3)&&(z>312.5e3)&&(z<437.5e3)), 1, 0)
+  end
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 8
+    end
+  end
+end
diff --git a/tests/passive_comp.prm.bak b/tests/passive_comp.prm.bak
new file mode 100644
index 00000000000..7b813db72d0
--- /dev/null
+++ b/tests/passive_comp.prm.bak
@@ -0,0 +1,280 @@
+# Listing of Parameters
+# ---------------------
+# In computations, the time step $k$ is chosen according to $k = c \min_K
+# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
+# and the denominator is the maximal magnitude of the velocity on cell $K$
+# times the polynomial degree $p_T$ of the temperature discretization. The
+# dimensionless constant $c$ is called the CFL number in this program. For
+# time discretizations that have explicit components, $c$ must be less than a
+# constant that depends on the details of the time discretization and that is
+# no larger than one. On the other hand, for implicit discretizations such as
+# the one chosen here, one can choose the time step as large as one wants (in
+# particular, one can choose $c>1$) though a CFL number significantly larger
+# than one will yield rather diffusive solutions. Units: None.
+set CFL number                             = 1.0
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 8e12
+
+# The name of the directory into which all output files should be placed. This
+# may be an absolute or a relative path.
+
+# A flag indicating whether the computation should be resumed from a
+# previously saved state (if true) or start from scratch (if false).
+set Resume computation                     = false
+
+# The start time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set Start time                             = 0
+
+# When computing results for mantle convection simulations, it is often
+# difficult to judge the order of magnitude of results when they are stated in
+# MKS units involving seconds. Rather, some kinds of results such as
+# velocities are often stated in terms of meters per year (or, sometimes,
+# centimeters per year). On the other hand, for non-dimensional computations,
+# one wants results in their natural unit system as used inside the code. If
+# this flag is set to 'true' conversion to years happens; if it is 'false', no
+# such conversion happens.
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+
+  # A comma separated list of integers denoting those boundaries on which the
+  # temperature is fixed and described by the boundary temperature object
+  # selected in its own section of this input file. All boundary indicators
+  # used by the geometry but not explicitly listed here will end up with
+  # no-flux (insulating) boundary conditions.
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    # Temperature at the inner boundary (core mantle boundary). Units: K.
+    set Inner temperature = 0
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: K.
+    set Outer temperature = 0
+  end
+end
+
+subsection Discretization
+  # The polynomial degree to use for the velocity variables in the Stokes
+  # system. Units: None.
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+
+  # The polynomial degree to use for the composition variable(s). Units: None.
+  set Composition polynomial degree           = 2
+
+  # Whether to use a Stokes discretization that is locally conservative at the
+  # expense of a larger number of degrees of freedom (true), or to go with a
+  # cheaper discretization that does not locally conserve mass, although it is
+  # globally conservative (false).
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.11
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set List of normalized fields =
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    # Inner radius of the spherical shell. Units: \\si{\\meter}.
+    set Inner radius  = 3481000
+
+    # Opening angle in degrees of the section of the shell that we want to
+    # build. Units: degrees.
+    set Opening angle = 360
+
+    # Outer radius of the spherical shell. Units: \\si{\\meter}.
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+
+  subsection Radial constant
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+
+  subsection Spherical gaussian perturbation
+    # The amplitude of the perturbation.
+    set Amplitude             = 0.00
+
+    # The angle where the center of the perturbation is placed.
+    set Angle                 = 0e0
+
+    # The non-dimensional radial distance where the center of the perturbation
+    # is placed.
+    set Non-dimensional depth = 0.7
+
+    # The standard deviation of the Gaussian perturbation.
+    set Sigma                 = 0.2
+
+    # The sign of the perturbation.
+    set Sign                  = 1
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = if(x > 0,0,1)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
+    set Reference density             = 3300
+
+    # The reference temperature $T_0$. Units: \\si{\\kelvin}.
+    set Reference temperature         = 293
+
+    # The value of the thermal conductivity $k$. Units: \\si{\\watt\\per\\meter\\per\\kelvin}.
+    set Thermal conductivity          = 4.7#1e-6
+
+    # The value of the thermal expansion coefficient $\beta$. Units: \\si{\\per\\kelvin}.
+    set Thermal expansion coefficient = 4e-5
+
+    # The value of the constant viscosity. Units: \\si{\\pascal\\second}.
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  # A list of times so that if the end time of a time step is beyond this
+  # time, an additional round of mesh refinement is triggered. This is mostly
+  # useful to make sure we can get through the initial transient phase of a
+  # simulation on a relatively coarse mesh, and then refine again when we are
+  # in a time range that we are interested in and where we would like to use a
+  # finer mesh. Units: each element of the list has units years if the 'Use
+  # years in output instead of seconds' parameter is set; seconds otherwise.
+  set Additional refinement times        =
+
+  # The number of adaptive refinement steps performed after initial global
+  # refinement but while still within the first time step.
+  set Initial adaptive refinement        = 0
+
+  # The number of global refinement steps performed on the initial coarse
+  # mesh, before the problem is first solved there.
+  set Initial global refinement          = 3
+
+  # The fraction of cells with the largest error that should be flagged for
+  # refinement.
+  set Refinement fraction                = 0.0
+
+  # The fraction of cells with the smallest error that should be flagged for
+  # coarsening.
+  set Coarsening fraction                = 0.00
+
+  # The method used to determine which cells to refine and which to coarsen.
+  set Strategy                           = temperature
+
+  # The number of time steps after which the mesh is to be adapted again based
+  # on computed error indicators.
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1:function
+
+  subsection Function
+    # The name of the variables as they will be used in the function,
+    # separated by ','.
+    set Variable names      = x,y
+
+    # Any constant used inside the function which is not a variable name.
+    set Function constants  = pi=3.1415926
+
+    # Vector valued expression for the velocity; separate components by ';'
+    set Function expression = if(x>0,-1.e-14*sqrt(x*x+y*y)*sin(atan(y/x)),1.e-14*sqrt(x*x+y*y)*sin(atan(y/x))); if(x>0,1.e-14*sqrt(x*x+y*y)*cos(atan(y/x)),-1.e-14*sqrt(x*x+y*y)*cos(atan(y/x)))
+  end
+end
+
+subsection Postprocess
+  # A comma separated list of postprocessor objects that should be run at the
+  # end of each time step. Some of these postprocessors will declare their own
+  # parameters which may, for example, include that they will actually do
+  # something only every so many time steps or years. Alternatively, the text
+  # 'all' indicates that all available postprocessors should be run after each
+  # time step.
+  #
+  # The following postprocessors are available:
+  #
+  # `visualization':
+  # A postprocessor that takes the solution and writes it into files that can
+  # be read by a graphical visualization program. Additional run time
+  # parameters are read from the parameter subsection
+  # 'Visualization'.
+  #
+  # `velocity statistics': A postprocessor that computes
+  # some statistics about the velocity field.
+  #
+  # `temperature statistics': A
+  # postprocessor that computes some statistics about the temperature
+  # field.
+  #
+  # `velocity statistics for the table model': A postprocessor that
+  # computes some statistics about the velocity field.
+  #
+  # `heat flux statistics
+  # for the table model': A postprocessor that computes some statistics about
+  # the heat flux across boundaries.
+  #
+  # `heat flux statistics': A postprocessor
+  # that computes some statistics about the heat flux across boundaries.
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 1e6
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/tests/periodic_box.prm.bak b/tests/periodic_box.prm.bak
new file mode 100644
index 00000000000..833c83059b1
--- /dev/null
+++ b/tests/periodic_box.prm.bak
@@ -0,0 +1,108 @@
+#Test for running a box in 2D with periodic boundary conditions
+#in the x condition.  Also tests the removal of net translations
+#in the periodic direction
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e6
+set Output directory                       = output
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set X extent = 1.e6
+    set Y extent = 5.e5
+    set Z extent = 5.e5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e20
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 10
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 2,3
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net x translation
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+  end
+end
diff --git a/tests/periodic_box2.prm.bak b/tests/periodic_box2.prm.bak
new file mode 100644
index 00000000000..71f719b3098
--- /dev/null
+++ b/tests/periodic_box2.prm.bak
@@ -0,0 +1,97 @@
+# like periodic_box.prm, except we are now periodic in x and y and running in
+# parallel
+#
+# MPI: 2
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e6
+set Output directory                       = output
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set Y periodic = true
+    set X extent = 1.e6
+    set Y extent = 5.e5
+    set Z extent = 5.e5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e20
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 10
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net translation
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+  end
+end
diff --git a/tests/periodic_box_freesurface.prm.bak b/tests/periodic_box_freesurface.prm.bak
new file mode 100644
index 00000000000..fce3480d6cb
--- /dev/null
+++ b/tests/periodic_box_freesurface.prm.bak
@@ -0,0 +1,116 @@
+#Test for running a box in 2D with periodic boundary conditions
+#in the x condition and a free surface on the top.
+#  Also tests the removal of net translations in the periodic direction
+
+set Dimension = 2
+set CFL number                             = 0.4
+set End time                               = 1e6
+set Output directory                       = output
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set X extent = 1.e6
+    set Y extent = 5.e5
+    set Z extent = 5.e5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e20
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 6
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 10
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators        = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 1.0
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net x translation
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 4
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  topography,
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+  end
+end
diff --git a/tests/periodic_box_gmg.prm b/tests/periodic_box_gmg.prm
index 1cc7f1860ed..941cda5467f 100644
--- a/tests/periodic_box_gmg.prm
+++ b/tests/periodic_box_gmg.prm
@@ -100,7 +100,7 @@ end
 subsection Mesh refinement
   set Additional refinement times        =
   set Initial adaptive refinement        = 2
-  set Initial global refinement          = 5                       # default: 2
+  set Initial global refinement          = 5
   set Minimum refinement level                            = 5
   set Refinement fraction                = 0.3
   set Coarsening fraction                = 0.03
diff --git a/tests/periodic_box_gmg.prm.bak b/tests/periodic_box_gmg.prm.bak
new file mode 100644
index 00000000000..1cc7f1860ed
--- /dev/null
+++ b/tests/periodic_box_gmg.prm.bak
@@ -0,0 +1,124 @@
+# Test that periodic boundary conditions work with GMG. This test will
+# currently crash if run with a larger end time as we will run into a
+# situation with adaptive refinement across the periodic border, which
+# is not supported.
+
+# MPI: 2
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 20000
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = no
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 0.0
+    set Bottom temperature = 1000.0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set X extent = 1.e6
+    set Y extent = 5.e5
+    set Z extent = 5.e5
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net x translation
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1e-8
+    set Number of cheap Stokes solver steps = 100
+  end
+
+  subsection Matrix Free
+    set Output details = true
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e20
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 5                       # default: 2
+  set Minimum refinement level                            = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.03
+  set Strategy                           = thermal energy density#, equal periodic refinement
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables =
+    set Number of grouped files       = 1
+    set Output format                 = vtu
+    set Time between graphical output = 0#1.e3
+  end
+end
diff --git a/tests/periodic_box_mpi4.prm.bak b/tests/periodic_box_mpi4.prm.bak
new file mode 100644
index 00000000000..9fa52a3281e
--- /dev/null
+++ b/tests/periodic_box_mpi4.prm.bak
@@ -0,0 +1,99 @@
+# like periodic_box2.prm. This test shows bugs inside
+# SimulatorAccess<dim>::get_fe() and handling of nullspace constraints that
+# happen if one MPI process does not own any DoFs. We force this here be using
+# a coarse mesh and 4 tasks.
+
+# MPI: 4
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e6
+set Output directory                       = output
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set Y periodic = true
+    set X extent = 1.e6
+    set Y extent = 5.e5
+    set Z extent = 5.e5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e20
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = net translation
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, visualization
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+  end
+end
diff --git a/tests/periodic_compressible.prm.bak b/tests/periodic_compressible.prm.bak
new file mode 100644
index 00000000000..f5752e3fe04
--- /dev/null
+++ b/tests/periodic_compressible.prm.bak
@@ -0,0 +1,84 @@
+# This is a test case for periodic boundary conditions in a model
+# with a compressible material model.
+
+set Dimension                              = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+set Output directory                       = periodic
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 3
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent   = 2900000
+    set Y extent   = 2900000
+    set X periodic = true
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 3773
+    set Top temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set List of model names = adiabatic, function
+
+  subsection Function
+    set Coordinate system   = cartesian
+    set Variable names      = x, y
+    set Function constants  = d = 2900000
+    set Function expression = 50 * sin(2*x/d*pi)*sin(2*y/d*pi)
+  end
+
+  subsection Adiabatic
+    set Age top boundary layer = 1e8
+    set Age bottom boundary layer = 1e8
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top
+  set Zero velocity boundary indicators = bottom
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics,temperature statistics,heat flux statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set List of output variables      = viscosity, density, thermal expansivity, specific heat, nonadiabatic temperature #, named additional outputs
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/tests/periodic_linear_momentum.prm.bak b/tests/periodic_linear_momentum.prm.bak
new file mode 100644
index 00000000000..a658346c553
--- /dev/null
+++ b/tests/periodic_linear_momentum.prm.bak
@@ -0,0 +1,112 @@
+# Test linear x momentum for periodic box.
+# This is based off of periodic_box.prm
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e6
+set Output directory                       = output
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set X extent = 1.e6
+    set Y extent = 5.e5
+    set Z extent = 5.e5
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e20
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 10
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 2,3
+end
+
+subsection Nullspace removal
+  set Remove nullspace                        = linear x momentum
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+  end
+end
diff --git a/tests/periodic_quarter_shell.prm.bak b/tests/periodic_quarter_shell.prm.bak
new file mode 100644
index 00000000000..7d9e88e7e70
--- /dev/null
+++ b/tests/periodic_quarter_shell.prm.bak
@@ -0,0 +1,77 @@
+# testing for periodic conditions in phi direction
+# for 2D quarter spherical shell geometry
+# based on boundary_velocity_function_spherical.prm
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+    set Phi periodic = true
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 3
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner
+  set Prescribed velocity boundary indicators = outer: function
+
+  subsection Function
+    set Coordinate system   = spherical
+    set Variable names      = r, phi
+    set Function expression = 0.0;0.1
+    set Use spherical unit vectors = true
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 5
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/plugin.cc.bak b/tests/plugin.cc.bak
new file mode 100644
index 00000000000..28ad2b0dff3
--- /dev/null
+++ b/tests/plugin.cc.bak
@@ -0,0 +1,41 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// make sure we can include deal.II and aspect files
+#include <aspect/simulator.h>
+#include <aspect/utilities.h>
+#include <deal.II/grid/tria.h>
+
+#include <iostream>
+#include <typeinfo>
+
+// create a function that is run upon loading the plugin
+// and that produces some output
+int f()
+{
+  std::cout << aspect::Utilities::expand_ASPECT_SOURCE_DIR("srcdir='$ASPECT_SOURCE_DIR'") << std::endl;
+
+  std::cout << typeid(dealii::Triangulation<2>).name() << ' '
+            << typeid(aspect::Simulator<2>).name() << std::endl;
+  return 42;
+}
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/plugin.prm.bak b/tests/plugin.prm.bak
new file mode 100644
index 00000000000..4c4846cfe0d
--- /dev/null
+++ b/tests/plugin.prm.bak
@@ -0,0 +1,80 @@
+# a test that simply verifies that the plugin described in
+# plugin.cc is indeed run
+
+
+
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/plugin_dependency.cc.bak b/tests/plugin_dependency.cc.bak
new file mode 100644
index 00000000000..0220c9f8685
--- /dev/null
+++ b/tests/plugin_dependency.cc.bak
@@ -0,0 +1,56 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// create a postprocessor that does exactly the same as
+// SolCxPostprocessor, but also requires something else
+
+#include "../benchmarks/solcx/solcx.cc"
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    class NewPostprocessor : public aspect::InclusionBenchmark::SolCxPostprocessor<dim>
+    {
+      public:
+        virtual
+        std::list<std::string>
+        required_other_postprocessors () const
+        {
+          // select a postprocessor that is not selected in the .prm file
+          std::list<std::string> deps;
+          deps.push_back ("velocity statistics");
+          return deps;
+        }
+    };
+  }
+}
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(NewPostprocessor,
+                                  "new postprocessor",
+                                  ".")
+  }
+}
diff --git a/tests/plugin_dependency.prm.bak b/tests/plugin_dependency.prm.bak
new file mode 100644
index 00000000000..951f6a70549
--- /dev/null
+++ b/tests/plugin_dependency.prm.bak
@@ -0,0 +1,78 @@
+# Test that the way we provide postprocessors to state that they
+# depend on other postprocessors works
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  # choose a postprocessor that will in turn require another one
+  # to run as well (here, velocity statistics)
+  set List of postprocessors = new postprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/plugin_dependency_redundant.cc.bak b/tests/plugin_dependency_redundant.cc.bak
new file mode 100644
index 00000000000..2e05a4d2efa
--- /dev/null
+++ b/tests/plugin_dependency_redundant.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Exactly like plugin_dependency.cc
+
+#include "plugin_dependency.cc"
diff --git a/tests/plugin_dependency_redundant.prm.bak b/tests/plugin_dependency_redundant.prm.bak
new file mode 100644
index 00000000000..ff11c3cbd8c
--- /dev/null
+++ b/tests/plugin_dependency_redundant.prm.bak
@@ -0,0 +1,80 @@
+# like plugin_dependency, but also list the required plugin in the
+# .prm file. this is then redundant, and this test ensures that we
+# don't load the plugin twice
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  # choose a postprocessor that will in turn require another one
+  # to run as well (here, velocity statistics). check that
+  # redundancy is no problem
+  set List of postprocessors = new postprocessor, velocity statistics
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/plugin_dependency_redundant_02.cc.bak b/tests/plugin_dependency_redundant_02.cc.bak
new file mode 100644
index 00000000000..2e05a4d2efa
--- /dev/null
+++ b/tests/plugin_dependency_redundant_02.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Exactly like plugin_dependency.cc
+
+#include "plugin_dependency.cc"
diff --git a/tests/plugin_dependency_redundant_02.prm.bak b/tests/plugin_dependency_redundant_02.prm.bak
new file mode 100644
index 00000000000..35d30bb9ee3
--- /dev/null
+++ b/tests/plugin_dependency_redundant_02.prm.bak
@@ -0,0 +1,79 @@
+# like plugin_dependency_redundant, but list plugins in reverse order. this
+# should still no lead to any redundancy
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  # choose a postprocessor that will in turn require another one
+  # to run as well (here, velocity statistics). check that
+  # redundancy is no problem
+  set List of postprocessors = velocity statistics, new postprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/point_value_01.prm.bak b/tests/point_value_01.prm.bak
new file mode 100644
index 00000000000..315b5ed6ed3
--- /dev/null
+++ b/tests/point_value_01.prm.bak
@@ -0,0 +1,102 @@
+# A variation of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for evaluating the solution at chosen points
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.1
+set Use years in output instead of seconds = false
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0.0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, point values
+
+  subsection Point values
+    set Evaluation points = 0.25, 0.5  ; \
+                            0.5 , 0.25 ; \
+                            0.75, 0.75
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/point_value_02.prm.bak b/tests/point_value_02.prm.bak
new file mode 100644
index 00000000000..24de8b255f5
--- /dev/null
+++ b/tests/point_value_02.prm.bak
@@ -0,0 +1,109 @@
+# A variation of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for evaluating the solution at chosen points
+#
+# This variation tests that we correctly convert output to years as well.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.001
+set Use years in output instead of seconds = true
+set Pressure normalization                 = volume
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 5
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0.0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, point values
+
+  subsection Point values
+    set Evaluation points = 0.25, 0.5  ; \
+                            0.5 , 0.25 ; \
+                            0.75, 0.75
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity, artificial viscosity composition
+
+    subsection Artificial viscosity composition
+      set Name of compositional field = C_1
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/point_value_02_mpi.prm.bak b/tests/point_value_02_mpi.prm.bak
new file mode 100644
index 00000000000..f81605536f0
--- /dev/null
+++ b/tests/point_value_02_mpi.prm.bak
@@ -0,0 +1,107 @@
+# A variation of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
+# file for evaluating the solution at chosen points
+
+# This variant of the _02 test checks that everything still runs for
+# parallel computations.
+
+# MPI: 3
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.001
+set Use years in output instead of seconds = true
+set Pressure normalization                 = volume
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0000
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = left, right, bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Reference density             = 1
+    set Viscosity                     = 1
+    set Thermal expansion coefficient = 0.0
+    set Composition viscosity prefactor = 1e6
+    set Density differential for compositional field 1 = 10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization, point values
+
+  subsection Point values
+    set Evaluation points = 0.25, 0.5  ; \
+                            0.5 , 0.25 ; \
+                            0.75, 0.75
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set List of output variables = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/point_value_03.prm.bak b/tests/point_value_03.prm.bak
new file mode 100644
index 00000000000..e98372d8ba6
--- /dev/null
+++ b/tests/point_value_03.prm.bak
@@ -0,0 +1,103 @@
+# A variation of cell_in_circumference to test that the point values
+# postprocessor also works with non-rectangular meshes
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 5000000
+    set Outer radius = 6371000
+    set Opening angle = 360
+
+    # use a number of cells the is guaranteed to not create any
+    # symmetries
+    set Cells along circumference = 11
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Additional refinement times              = 0,0
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, point values
+
+  # Choose points that are for sure in the domain but not
+  # at symmetry points
+  subsection Point values
+    set Evaluation points = 6000000, 1000  ; \
+                            1000, 6000000  ; \
+                            4014515, 4234567
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/point_value_natural_coordinates.prm.bak b/tests/point_value_natural_coordinates.prm.bak
new file mode 100644
index 00000000000..284770c03b5
--- /dev/null
+++ b/tests/point_value_natural_coordinates.prm.bak
@@ -0,0 +1,86 @@
+# A test for the point values postprocessor
+# using natural coordinates
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3481000
+    set Chunk outer radius = 6371000
+    set Chunk minimum longitude = 0
+    set Chunk maximum longitude = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = point values
+
+  subsection Point values
+    # Get values at 0, 10 and 20 degrees longitude and 71 km depth
+    set Evaluation points = 6300e3, 0  ; \
+                            6300e3, 0.1745 ; \
+                            6300e3, 0.3491
+    set Use natural coordinates = true
+  end
+end
diff --git a/tests/point_value_natural_coordinates_shell.prm.bak b/tests/point_value_natural_coordinates_shell.prm.bak
new file mode 100644
index 00000000000..1fa8d3688d9
--- /dev/null
+++ b/tests/point_value_natural_coordinates_shell.prm.bak
@@ -0,0 +1,86 @@
+# A test for the point values postprocessor
+# using natural coordinates
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if((sqrt((x-3483208.)^2+(y-3483208.)^2)<5e5) , 1800.0, 1613.0)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = point values
+
+  subsection Point values
+    # Get values at 45 degrees longitude and 1 and 1445 km depth.
+    # The former should give a temperature of 1613 K and the latter
+    # of 1800 K.
+    set Evaluation points = 6370e3, 0.7854; \
+                            4926e3, 0.7854
+    set Use natural coordinates = true
+  end
+end
diff --git a/tests/point_value_specific_output_times.prm.bak b/tests/point_value_specific_output_times.prm.bak
new file mode 100644
index 00000000000..0bcc0cd7242
--- /dev/null
+++ b/tests/point_value_specific_output_times.prm.bak
@@ -0,0 +1,104 @@
+# A variation of cell_in_circumference to test that the point values
+# postprocessor also works when requesting output at specific time intervals only.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 3e16
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 5000000
+    set Outer radius = 6371000
+    set Opening angle = 360
+
+    # use a number of cells the is guaranteed to not create any
+    # symmetries
+    set Cells along circumference = 11
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Additional refinement times              = 0,0
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, point values
+
+  # Choose points that are for sure in the domain but not
+  # at symmetry points
+  subsection Point values
+    set Time between point values output = 2e16
+    set Evaluation points = 6000000, 1000  ; \
+                            1000, 6000000  ; \
+                            4014515, 4234567
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/poiseuille_2d.prm.bak b/tests/poiseuille_2d.prm.bak
new file mode 100644
index 00000000000..b04faa39c19
--- /dev/null
+++ b/tests/poiseuille_2d.prm.bak
@@ -0,0 +1,72 @@
+# A simple Poiseuille flow example in which we prescribe the velocity to
+# be (z*(z-1),0)^T and see what pressure we get. We switch off gravity
+# so the pressure is purely the dynamic pressure. It is only determined
+# up to a constant, and with a viscosity of eta=1, should be between
+# +2 at the left inlet and -2 at the right outlet.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function
+  set Zero velocity boundary indicators       = 2, 3
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z*(1-z);0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
+end
diff --git a/tests/poiseuille_2d_horizontal_pressure_bc.prm.bak b/tests/poiseuille_2d_horizontal_pressure_bc.prm.bak
new file mode 100644
index 00000000000..f1061d1bc45
--- /dev/null
+++ b/tests/poiseuille_2d_horizontal_pressure_bc.prm.bak
@@ -0,0 +1,102 @@
+# Like the poiseuille_2d.prm test, but instead of prescribing the
+# velocity at the left and right ends, prescribe the horizontal
+# component of the traction. At the same time, set the vertical
+# component of the velocity to zero. This should yield the same answer.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary traction model
+  # Prescribe a horizontal traction on the vertical boundaries
+  set Prescribed traction boundary indicators = 0 x: function, 1 x: function
+
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 2;0
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 2, 3
+
+  # Prescribe a zero vertical velocity component on the vertical boundaries
+  set Prescribed velocity boundary indicators = 0 y: function, 1 y: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = 0;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
+end
diff --git a/tests/poiseuille_2d_pressure_bc.prm.bak b/tests/poiseuille_2d_pressure_bc.prm.bak
new file mode 100644
index 00000000000..1fc3a5e84c2
--- /dev/null
+++ b/tests/poiseuille_2d_pressure_bc.prm.bak
@@ -0,0 +1,94 @@
+# Like the poiseuille_2d.prm test, but instead of prescribing the
+# velocity at the left and right ends, prescribe the pressure. This
+# should yield the same answer, of course.
+# In this case however, there will be pressure singularities
+# in the corners of the domain.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 0 : function, 1 : function
+
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 2;0
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
+end
diff --git a/tests/poiseuille_2d_pressure_bc_gmg.prm.bak b/tests/poiseuille_2d_pressure_bc_gmg.prm.bak
new file mode 100644
index 00000000000..7b919c72e10
--- /dev/null
+++ b/tests/poiseuille_2d_pressure_bc_gmg.prm.bak
@@ -0,0 +1,105 @@
+# Like the poiseuille_2d_pressure_bc.prm test, but using GMG instead.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Solver parameters
+  subsection Matrix Free
+    set Output details = true
+  end
+
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps             = 200
+    set Maximum number of expensive Stokes solver steps = 0
+    set Linear solver tolerance                         = 1e-6
+    set GMRES solver restart length                     = 100
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 0 : function, 1 : function
+
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 2;0
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
+end
diff --git a/tests/poiseuille_3d_x_horizontal_pressure_bc.prm.bak b/tests/poiseuille_3d_x_horizontal_pressure_bc.prm.bak
new file mode 100644
index 00000000000..1df32b084f5
--- /dev/null
+++ b/tests/poiseuille_3d_x_horizontal_pressure_bc.prm.bak
@@ -0,0 +1,100 @@
+# Like the poiseuille_2d_horizontal_pressure_bc.prm test,
+# but in 3d.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Box
+    set Left temperature = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary traction model
+  # Prescribe a horizontal traction on the vertical boundaries
+  set Prescribed traction boundary indicators = 0 x: function, 1 x: function
+
+  subsection Function
+    set Variable names = x,y,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0;0). On the right (1;0;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0;0) = - (2) (-1;0;0) = (2;0;0).
+    # Right boundary: tau = - pressure(right) (1;0;0) = - (-2) (1;0;0) = (2;0;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 2;0;0
+  end
+end
+
+subsection Boundary velocity model
+  # Prescribe zero y and z velocity components on the vertical boundaries
+  set Prescribed velocity boundary indicators = 0 yz: function, 1 yz: function
+  set Zero velocity boundary indicators       = 2, 3, 4, 5
+
+  subsection Function
+    set Variable names = x,y,z
+    set Function expression = 0;0;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
+end
diff --git a/tests/postprocess_initial.prm.bak b/tests/postprocess_initial.prm.bak
new file mode 100644
index 00000000000..102096617ad
--- /dev/null
+++ b/tests/postprocess_initial.prm.bak
@@ -0,0 +1,105 @@
+#########################################################
+# this tests that "Run postprocessors on initial refinement = true"
+# is working correctly (in particular that it increases the id
+# of the output files)
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1e-15
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0.01
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 3
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+  set Run postprocessors on initial refinement = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/tests/postprocess_iterations_Stokes_only.cc.bak b/tests/postprocess_iterations_Stokes_only.cc.bak
new file mode 100644
index 00000000000..9130c172908
--- /dev/null
+++ b/tests/postprocess_iterations_Stokes_only.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "compressibility_iterated_stokes_direct_solver.cc"
diff --git a/tests/postprocess_iterations_Stokes_only.prm.bak b/tests/postprocess_iterations_Stokes_only.prm.bak
new file mode 100644
index 00000000000..a92bb623bb5
--- /dev/null
+++ b/tests/postprocess_iterations_Stokes_only.prm.bak
@@ -0,0 +1,88 @@
+#########################################################
+# This is a model setup to test the postprocessing of
+# nonlinear iterations for the no Advection, iterated Stokes solver.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 5
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = compressibility iterated stokes
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set Run postprocessors on nonlinear iterations = true
+  set List of postprocessors = visualization, dynamic topography, heat flux map, compressibility
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/postprocess_iterations_iterated_Stokes.cc.bak b/tests/postprocess_iterations_iterated_Stokes.cc.bak
new file mode 100644
index 00000000000..1f606d76070
--- /dev/null
+++ b/tests/postprocess_iterations_iterated_Stokes.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "no_adiabatic_heating_03.cc"
diff --git a/tests/postprocess_iterations_iterated_Stokes.prm.bak b/tests/postprocess_iterations_iterated_Stokes.prm.bak
new file mode 100644
index 00000000000..00eda6f3a7d
--- /dev/null
+++ b/tests/postprocess_iterations_iterated_Stokes.prm.bak
@@ -0,0 +1,96 @@
+#########################################################
+# This is a model setup to test the postprocessing of
+# nonlinear iterations for the iterated Stokes solver.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = .1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 5
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2
+
+  subsection Box
+    set Bottom temperature = 0
+  end
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = no adiabatic heating
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set Run postprocessors on nonlinear iterations = true
+  set List of postprocessors = visualization, dynamic topography, heat flux map, temperature statistics, velocity statistics, basic statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/tests/postprocess_iterations_iterated_advection_and_stokes.prm.bak b/tests/postprocess_iterations_iterated_advection_and_stokes.prm.bak
new file mode 100644
index 00000000000..0eb8d91e950
--- /dev/null
+++ b/tests/postprocess_iterations_iterated_advection_and_stokes.prm.bak
@@ -0,0 +1,133 @@
+#########################################################
+# This is a model setup to test the postprocessing of
+# nonlinear iterations for the iterated Advection and Stokes solver.
+
+
+set Adiabatic surface temperature          = 0
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+
+  subsection Stabilization parameters
+    set beta  = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 150000
+    set Y extent  = 65000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 0
+    set Thermal expansion coefficient = 1
+    set Thermal viscosity exponent = 0.0
+    set Reference specific heat = 1.0
+    set Reference density = 1.0
+    set Reference temperature = 0
+    set Viscosity = 1e16
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set Run postprocessors on nonlinear iterations = true
+  set List of postprocessors = visualization, dynamic topography, heat flux map
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/pre_data_out_build_patches.cc.bak b/tests/pre_data_out_build_patches.cc.bak
new file mode 100644
index 00000000000..69dd5dd1148
--- /dev/null
+++ b/tests/pre_data_out_build_patches.cc.bak
@@ -0,0 +1,45 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_signals.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+
+namespace aspect
+{
+  template <int dim>
+  void pre_data_out_build_patches (DataOut<dim> &)
+  {
+    std::cout << "\npre_data_out_build_patches:\n";
+  }
+
+
+  template <int dim>
+  void signal_connector (SimulatorSignals<dim> &signals)
+  {
+    std::cout << "Connecting signals" << std::endl;
+    signals.pre_data_out_build_patches.connect (&pre_data_out_build_patches<dim>);
+  }
+
+
+  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                    signal_connector<3>)
+}
diff --git a/tests/pre_data_out_build_patches.prm.bak b/tests/pre_data_out_build_patches.prm.bak
new file mode 100644
index 00000000000..63eab17f78a
--- /dev/null
+++ b/tests/pre_data_out_build_patches.prm.bak
@@ -0,0 +1,72 @@
+# A copy of stokes_solver.prm
+# to test the pre_data_out_build_patches signal
+# in visualization.cc.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0.1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set List of output variables      = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/prescribed_dilation.cc.bak b/tests/prescribed_dilation.cc.bak
new file mode 100644
index 00000000000..1cd8e57417b
--- /dev/null
+++ b/tests/prescribed_dilation.cc.bak
@@ -0,0 +1,413 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  namespace Benchmark
+  {
+    using namespace dealii;
+
+    /**
+     * u = cos(y), sin(x)+xy
+     * p = 2/3 eta x
+     * grad p = 2/3 eta
+     * R = div u = x
+     * => grad p and compressibility term cancel
+     */
+
+    namespace AnalyticSolutions
+    {
+      Tensor<1,2>
+      velocity (const Point<2> &pos,
+                const double /*eta*/)
+      {
+
+        const double x = pos[0];
+        const double y = pos[1];
+
+        return Point<2> (cos(y), sin(x)+x*y);
+      }
+
+      double
+      pressure (const Point<2> &pos,
+                const double eta)
+      {
+        const double x = pos[0];
+        //        const double y = pos[1];
+
+        return 2./3.*eta*(x-1.0);
+      }
+
+
+      /**
+       * The exact solution for the benchmark.
+       */
+      template <int dim>
+      class Exact : public Function<dim>
+      {
+        public:
+          Exact (const double eta)
+            :
+            Function<dim>(dim+2),
+            eta(eta)
+          {}
+
+          virtual void vector_value (const Point<dim>   &pos,
+                                     Vector<double>   &values) const
+          {
+            Assert (dim == 2, ExcNotImplemented());
+            Assert (values.size() >= 3, ExcInternalError());
+
+            const Point<2> p (pos[0], pos[1]);
+
+            const Tensor<1,2> v = AnalyticSolutions::velocity (p, eta);
+            values[0] = v[0];
+            values[1] = v[1];
+
+            values[2] = AnalyticSolutions::pressure (p, eta);
+          }
+
+        private:
+          const double eta;
+      };
+    }
+
+
+
+    template <int dim>
+    class MyBoundary : public BoundaryVelocity::Interface<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        MyBoundary();
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        virtual
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_indicator,
+                           const Point<dim> &position) const;
+
+      private:
+        const double eta;
+    };
+
+    template <int dim>
+    MyBoundary<dim>::MyBoundary ()
+      :
+      eta (0)
+    {}
+
+
+
+    template <>
+    Tensor<1,2>
+    MyBoundary<2>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<2> &p) const
+    {
+      return AnalyticSolutions::velocity (p, eta);
+    }
+
+
+
+    template <>
+    Tensor<1,3>
+    MyBoundary<3>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<3> &p) const
+    {
+      Assert (false, ExcNotImplemented());
+      return Tensor<1,3>();
+    }
+
+
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class MyMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const
+        {
+          MaterialModel::PrescribedPlasticDilation<dim>
+          *prescribed_dilation = out.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>();
+
+          MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
+          *force = out.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> &p = in.position[i];
+
+              const double x=p[0];
+              const double y=p[1];
+
+              out.viscosities[i] = eta;
+              out.thermal_conductivities[i] = 0.0;
+              out.densities[i] = 1.0;
+
+              out.thermal_expansion_coefficients[i] = 0.0;
+              out.compressibilities[i] = 0.0;
+
+              out.specific_heat[i] = 0.0;
+
+              // Pressure derivative of entropy at the given positions.
+              out.entropy_derivative_pressure[i] = 0.0;
+              // Temperature derivative of entropy at the given positions.
+              out.entropy_derivative_temperature[i] = 0.0;
+              // Change in composition due to chemical reactions at the
+              // given positions. The term reaction_terms[i][c] is the
+              // change in compositional field c at point i.
+              for (unsigned int c=0; c<in.composition[i].size(); ++c)
+                out.reaction_terms[i][c] = 0.0;
+
+              if (force)
+                {
+                  force->rhs_u[i][0] = -eta*(1-cos(y));
+                  force->rhs_u[i][1] = -eta*(-sin(x));
+                  force->rhs_p[i] = 0.;
+                }
+              if (prescribed_dilation)
+                {
+                  prescribed_dilation->dilation[i] = x;
+                }
+
+            }
+
+        }
+
+        virtual bool is_compressible () const;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+
+        double get_eta () const;
+
+        /**
+         * viscosity value in the inclusion
+         */
+        double eta;
+    };
+
+
+
+    template <int dim>
+    double
+    MyMaterial<dim>::
+    get_eta () const
+    {
+      return eta;
+    }
+
+    template <int dim>
+    bool
+    MyMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    MyMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      // create a global section in the parameter file for parameters
+      // that describe this benchmark. note that we declare them here
+      // in the material model, but other kinds of plugins (e.g., the gravity
+      // model below) may also read these parameters even though they do not
+      // declare them
+      prm.enter_subsection("My benchmark");
+
+      {
+        prm.declare_entry("Viscosity parameter", "10",
+                          Patterns::Double (0),
+                          "Viscosity the benchmark.");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    MyMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("My benchmark");
+      {
+        eta = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+
+
+
+
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the paper Duretz et al. reference above.
+      */
+    template <int dim>
+    class MyPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        virtual
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics);
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    MyPostprocessor<dim>::execute (TableHandler &statistics)
+    {
+      std::unique_ptr<Function<dim>> ref_func;
+      {
+        const MyMaterial<dim> *
+        material_model
+          = dynamic_cast<const MyMaterial<dim> *>(&this->get_material_model());
+
+        ref_func = std::make_unique<AnalyticSolutions::Exact<dim>>(material_model->get_eta());
+      }
+
+      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                          dim+2);
+      ComponentSelectFunction<dim> comp_p(dim, dim+2);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_u,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_p,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_p);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_ul2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_pl2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+      std::ostringstream os;
+      os << std::scientific << u_l2 << ", " << p_l2;
+
+      return std::make_pair("Errors u_L2, p_L2:", os.str());
+    }
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Benchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(MyMaterial,
+                                   "MyMaterial",
+                                   "A material model that corresponds to the `My' benchmark. "
+                                   "See the manual for more information.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(MyBoundary,
+                                            "MyBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "`My' benchmark. See the manual for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(MyPostprocessor,
+                                  "MyPostprocessor",
+                                  "A postprocessor that compares the solution of the `My' benchmark "
+                                  "with the one computed by ASPECT "
+                                  "and reports the error. See the manual for more information.")
+  }
+}
diff --git a/tests/prescribed_dilation.prm.bak b/tests/prescribed_dilation.prm.bak
new file mode 100644
index 00000000000..86af3ebbb17
--- /dev/null
+++ b/tests/prescribed_dilation.prm.bak
@@ -0,0 +1,71 @@
+# Manufactured solution to test PrescribedDilation
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+subsection Formulation
+  set Enable prescribed dilation          = true
+  set Enable additional Stokes RHS            = true
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2
+    set Y extent  = 2
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:MyBoundary, 1:MyBoundary, 2:MyBoundary, 3:MyBoundary
+end
+
+subsection Material model
+  set Model name = MyMaterial
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 1.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Run postprocessors on initial refinement = true
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, MyPostprocessor, visualization
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/prescribed_dilation_gmg.cc.bak b/tests/prescribed_dilation_gmg.cc.bak
new file mode 100644
index 00000000000..0c5505e0b32
--- /dev/null
+++ b/tests/prescribed_dilation_gmg.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "prescribed_dilation.cc"
diff --git a/tests/prescribed_dilation_gmg.prm.bak b/tests/prescribed_dilation_gmg.prm.bak
new file mode 100644
index 00000000000..75f4507e657
--- /dev/null
+++ b/tests/prescribed_dilation_gmg.prm.bak
@@ -0,0 +1,19 @@
+# like prescribed_dilation.prm but using GMG
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/prescribed_dilation.prm
+
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 200
+
+    #set Maximum number of expensive Stokes solver steps = 40
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/tests/prescribed_dilation_newton.cc.bak b/tests/prescribed_dilation_newton.cc.bak
new file mode 100644
index 00000000000..0c5505e0b32
--- /dev/null
+++ b/tests/prescribed_dilation_newton.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "prescribed_dilation.cc"
diff --git a/tests/prescribed_dilation_newton.prm.bak b/tests/prescribed_dilation_newton.prm.bak
new file mode 100644
index 00000000000..43536b2edd1
--- /dev/null
+++ b/tests/prescribed_dilation_newton.prm.bak
@@ -0,0 +1,18 @@
+# like prescribed_dilation.prm but using Newton solver
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/prescribed_dilation.prm
+
+set Nonlinear solver scheme = iterated Advection and Newton Stokes
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    #    set Stokes solver type = block GMG
+    #    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  #  set Material averaging = harmonic average
+end
diff --git a/tests/prescribed_dilation_newton_singleadvection.cc.bak b/tests/prescribed_dilation_newton_singleadvection.cc.bak
new file mode 100644
index 00000000000..0c5505e0b32
--- /dev/null
+++ b/tests/prescribed_dilation_newton_singleadvection.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "prescribed_dilation.cc"
diff --git a/tests/prescribed_dilation_newton_singleadvection.prm.bak b/tests/prescribed_dilation_newton_singleadvection.prm.bak
new file mode 100644
index 00000000000..251b62c988b
--- /dev/null
+++ b/tests/prescribed_dilation_newton_singleadvection.prm.bak
@@ -0,0 +1,18 @@
+# like prescribed_dilation.prm but using Newton solver
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/prescribed_dilation.prm
+
+set Nonlinear solver scheme = single Advection, iterated Newton Stokes
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    #    set Stokes solver type = block GMG
+    #    set Number of cheap Stokes solver steps = 200
+  end
+end
+
+subsection Material model
+  #  set Material averaging = harmonic average
+end
diff --git a/tests/prescribed_field.cc.bak b/tests/prescribed_field.cc.bak
new file mode 100644
index 00000000000..a722b8b0f79
--- /dev/null
+++ b/tests/prescribed_field.cc.bak
@@ -0,0 +1,92 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class PrescribedFieldMaterial : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+        virtual
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    PrescribedFieldMaterial<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      Simple<dim>::evaluate(in, out);
+
+      // set up variable to interpolate prescribed field outputs onto compositional fields
+      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
+
+      if (prescribed_field_out != nullptr)
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          prescribed_field_out->prescribed_field_outputs[i][1] = out.densities[i];
+    }
+
+
+    template <int dim>
+    void
+    PrescribedFieldMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points, this->n_compositional_fields()));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedFieldMaterial,
+                                   "prescribed field material",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but creates prescribed field outputs.")
+  }
+}
diff --git a/tests/prescribed_field.prm.bak b/tests/prescribed_field.prm.bak
new file mode 100644
index 00000000000..244bfd50701
--- /dev/null
+++ b/tests/prescribed_field.prm.bak
@@ -0,0 +1,90 @@
+# A testcase that demonstrates that interpolating material model
+# outputs into compositional fields works.
+#
+# The density is chosen as rho = 1 + 0.1*sin(2*pi*x)*sin(2*pi*y)
+# and is copied into the compositional field 'prescribed field',
+# so the minimum and maximum composition should be 0.9 at 1.1,
+# respectively.
+# The test also contains another compositional field that does
+# not use this method, so it should remain zero everywhere
+# (which is what the initial condition is).
+
+set Dimension = 2
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields  = normal_field, prescribed_field
+  set Compositional field methods = field, prescribed field
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.1 * sin(2*3.1416*x) * sin(2*3.1416*y)
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0; 0.0
+  end
+end
+
+subsection Material model
+  set Model name = prescribed field material
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/prescribed_field_temperature.cc.bak b/tests/prescribed_field_temperature.cc.bak
new file mode 100644
index 00000000000..cc5d415d51d
--- /dev/null
+++ b/tests/prescribed_field_temperature.cc.bak
@@ -0,0 +1,93 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class PrescribedFieldMaterial : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+        virtual
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    PrescribedFieldMaterial<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      Simple<dim>::evaluate(in, out);
+
+      // set up variable to interpolate prescribed field outputs onto temperature field
+      PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>();
+
+      if (prescribed_temperature_out != nullptr)
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          prescribed_temperature_out->prescribed_temperature_outputs[i] = in.pressure[i];
+    }
+
+
+    template <int dim>
+    void
+    PrescribedFieldMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>> (n_points));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedFieldMaterial,
+                                   "prescribed field material",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but creates prescribed field outputs "
+                                   "for the temperature.")
+  }
+}
diff --git a/tests/prescribed_field_temperature.prm.bak b/tests/prescribed_field_temperature.prm.bak
new file mode 100644
index 00000000000..295da0b20e9
--- /dev/null
+++ b/tests/prescribed_field_temperature.prm.bak
@@ -0,0 +1,78 @@
+# A testcase that demonstrates that interpolating material model
+# outputs into the temperature field works.
+#
+# The material model prescribes the temperature to be exactly the
+# pressure of the model
+# and is copied into the temperature field,
+# so the minimum and maximum temperature should be 0.0 and 1.0,
+# respectively.
+
+set Dimension = 2
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+
+subsection Temperature field
+  set Temperature method                     = prescribed field
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5
+  end
+end
+
+subsection Material model
+  set Model name = prescribed field material
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/prescribed_field_temperature_max_isotherm.prm.bak b/tests/prescribed_field_temperature_max_isotherm.prm.bak
new file mode 100644
index 00000000000..2df6f62e5b7
--- /dev/null
+++ b/tests/prescribed_field_temperature_max_isotherm.prm.bak
@@ -0,0 +1,21 @@
+set Additional shared libraries = ./libprescribed_temperature_in_field.so
+
+include $ASPECT_SOURCE_DIR/tests/prescribed_temperature_in_field.prm
+
+
+## The temperature will be fixed in the 'Fixed'
+## compositional field. The maximum fixed temperature
+## will also allow temperature to be constrained
+## outside of the fixed compositional model, as long
+## as the temperature is below 500 K.
+subsection Prescribed internal temperature model
+  set Maximum fixed temperature isosurface = 500
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if(x>=0.4, if(y<=0.5, 600, 400), 1000)
+  end
+end
diff --git a/tests/prescribed_field_with_diffusion.cc.bak b/tests/prescribed_field_with_diffusion.cc.bak
new file mode 100644
index 00000000000..e318fd79b7c
--- /dev/null
+++ b/tests/prescribed_field_with_diffusion.cc.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class PrescribedFieldMaterial : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+        virtual
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    PrescribedFieldMaterial<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      Simple<dim>::evaluate(in, out);
+
+      // set up variable to interpolate prescribed field outputs onto compositional fields
+      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
+
+      if (prescribed_field_out != nullptr)
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          {
+            const double y = in.position[i](1);
+            prescribed_field_out->prescribed_field_outputs[i][1] = std::exp(-y*y/2.0);
+          }
+    }
+
+
+    template <int dim>
+    void
+    PrescribedFieldMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points, this->n_compositional_fields()));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedFieldMaterial,
+                                   "prescribed field material",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but creates prescribed field outputs.")
+  }
+}
diff --git a/tests/prescribed_field_with_diffusion.prm.bak b/tests/prescribed_field_with_diffusion.prm.bak
new file mode 100644
index 00000000000..fac752e786f
--- /dev/null
+++ b/tests/prescribed_field_with_diffusion.prm.bak
@@ -0,0 +1,107 @@
+# A testcase that demonstrates that interpolating material model
+# outputs into compositional fields and diffusing them works.
+#
+# The property copied into the compositional field 'prescribed field',
+# is a Gaussian with an amplitude of 1, namely exp(-0.5*x*x).
+# We choose the diffusion length scale in a way that its amplitude
+# should be reduced to 0.95 when the diffusion equation is solved.
+#
+# The test also contains another compositional field that does
+# not use this method, so it should remain zero everywhere
+# (which is what the initial condition is).
+
+set Dimension = 2
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+
+subsection Solver parameters
+  subsection Diffusion solver parameters
+    set Diffusion length scale = 0.23241476
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 0.1
+    set Y extent = 10
+    set Y repetitions = 100
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields  = normal_field, diffused_field
+  set Compositional field methods = field, prescribed field with diffusion
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.1
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0; 0.0
+  end
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators = top
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 0; 0
+  end
+end
+
+subsection Material model
+  set Model name = prescribed field material
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = named additional outputs
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/prescribed_stokes_solution.prm.bak b/tests/prescribed_stokes_solution.prm.bak
new file mode 100644
index 00000000000..305c6e7a82b
--- /dev/null
+++ b/tests/prescribed_stokes_solution.prm.bak
@@ -0,0 +1,95 @@
+# test PrescribedStokesSolution
+# This test is based on depth_average_01, and is similar to cookbooks/convection_box.prm
+# Here we prescribe a circular Stokes flow
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/prescribed_stokes_solution_DG_periodic.prm.bak b/tests/prescribed_stokes_solution_DG_periodic.prm.bak
new file mode 100644
index 00000000000..31cf14989f2
--- /dev/null
+++ b/tests/prescribed_stokes_solution_DG_periodic.prm.bak
@@ -0,0 +1,72 @@
+# test DG advection solver on a PrescribedStokesSolution (u,v) = (0,1 )
+# with periodic boundary conditions on both x and y axes
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 1
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Function expression = 0;1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X periodic = true
+    set Y periodic = true
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926536
+    set Function expression = cos(2*pi*x)*sin(2*pi*y)
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 2
+  set Use discontinuous temperature discretization = true
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/prescribed_stokes_solution_melt.prm.bak b/tests/prescribed_stokes_solution_melt.prm.bak
new file mode 100644
index 00000000000..31df81fce04
--- /dev/null
+++ b/tests/prescribed_stokes_solution_melt.prm.bak
@@ -0,0 +1,109 @@
+# This test is a copy of the prescribed_stokes_solution test,
+# except that is uses melt transport.
+# The original test is based on depth_average_01, and is similar
+# to cookbooks/convection_box.prm.
+# We prescribe a circular Stokes flow.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use operator splitting                 = true
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Melt settings
+  set Use discontinuous compaction pressure = false
+  set Include melt transport                  = true
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Reference solid density       = 1
+    set Reference melt density        = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Reference shear viscosity     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/prescribed_temperature.cc.bak b/tests/prescribed_temperature.cc.bak
new file mode 100644
index 00000000000..410067357c5
--- /dev/null
+++ b/tests/prescribed_temperature.cc.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class PrescribedTemperatureMaterial : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+        virtual
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    PrescribedTemperatureMaterial<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      Simple<dim>::evaluate(in, out);
+
+      // set up variable to interpolate prescribed field outputs onto compositional fields
+      PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>();
+
+      if (prescribed_temperature_out != nullptr)
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          {
+            const double y = in.position[i](1);
+            prescribed_temperature_out->prescribed_temperature_outputs[i] = y>0.5 ? 5.605170186 : 1.0;
+          }
+    }
+
+
+    template <int dim>
+    void
+    PrescribedTemperatureMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>> (n_points));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedTemperatureMaterial,
+                                   "prescribed temperature material",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but creates prescribed temperature outputs.")
+  }
+}
diff --git a/tests/prescribed_temperature.prm.bak b/tests/prescribed_temperature.prm.bak
new file mode 100644
index 00000000000..59778fd43b1
--- /dev/null
+++ b/tests/prescribed_temperature.prm.bak
@@ -0,0 +1,85 @@
+# A testcase that demonstrates that interpolating material model
+# outputs into the temperature field works, and that this
+# temperature is actually being used to compute the material
+# properties.
+#
+# The property copied into the temperature field has a large
+# value in the upper half of the box and a low value in the lower
+# half of the box. If viscosities are being computed correctly,
+# then the strain rate should be much larger in the top half.
+
+set Dimension = 2
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set X periodic = true
+  end
+end
+
+subsection Temperature field
+  set Temperature method = prescribed field
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Material model
+  set Model name = prescribed temperature material
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+    set Thermal viscosity exponent    = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = top:function, bottom:function
+
+  subsection Function
+    set Function expression = y; 0.0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = named additional outputs, strain rate, material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/prescribed_temperature_in_field.cc.bak b/tests/prescribed_temperature_in_field.cc.bak
new file mode 100644
index 00000000000..643a8743841
--- /dev/null
+++ b/tests/prescribed_temperature_in_field.cc.bak
@@ -0,0 +1,182 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/parsed_function.h>
+#include <deal.II/fe/fe_values.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/initial_temperature/interface.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  // Declare and parse additional parameters
+  bool prescribe_internal_temperature;
+  std::vector <std::string> fixed_compositional_fields;
+  double max_isotherm;
+
+
+  void declare_parameters(const unsigned int /*dim*/,
+                          ParameterHandler &prm)
+  {
+    prm.enter_subsection ("Prescribed internal temperature model");
+    {
+      prm.declare_entry ("Prescribe internal temperature", "false",
+                         Patterns::Bool (),
+                         "Whether or not to use any prescribed internal temperatures. "
+                         "Locations in which to prescribe temperature are defined "
+                         "based on the values of the compositional fields specified by "
+                         "the parameter ``Names of compositional fields with fixed temperature'' "
+                         "and the temperature is fixed to its initial state. Indicators are evaluated "
+                         "separately at each support point."
+                        );
+      prm.declare_entry ("Maximum fixed temperature isosurface", "0",
+                         Patterns::Double (),
+                         "The maximum temperature that will remain fixed. Temperatures above this "
+                         "value will be treated normally."
+                        );
+      prm.declare_entry ("Names of compositional fields with fixed temperature", "",
+                         Patterns::List(Patterns::Anything ()),
+                         "The names of compositional fields that determine the location where the "
+                         "temperature is fixed to the values it was initialized with. The temperature "
+                         "will be fixed if any of the fields listed here is above 0.5."
+                        );
+    }
+    prm.leave_subsection ();
+  }
+
+
+
+  template <int dim>
+  void parse_parameters(const Parameters<dim> &,
+                        ParameterHandler &prm)
+  {
+    prm.enter_subsection ("Prescribed internal temperature model");
+    {
+      prescribe_internal_temperature = prm.get_bool ("Prescribe internal temperature");
+      fixed_compositional_fields = Utilities::split_string_list (prm.get("Names of compositional fields with fixed temperature"));
+      max_isotherm = prm.get_double ("Maximum fixed temperature isosurface");
+    }
+    prm.leave_subsection ();
+  }
+
+  /**
+   * This function is called by a signal which is triggered after the other constraints
+   * have been calculated. This enables the definition of additional constraints in the mass
+   * matrix on any arbitrary degree of freedom in the model space.
+   */
+  template <int dim>
+  void constrain_internal_temperature (const SimulatorAccess<dim> &simulator_access,
+                                       AffineConstraints<double> &current_constraints)
+  {
+    // Save access to the initial temperature manager the first time
+    // we get here so that we can access it past the first time step
+    // as well.
+    static std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature_manager;
+    if (initial_temperature_manager == nullptr)
+      initial_temperature_manager = simulator_access.get_initial_temperature_manager_pointer();
+
+    if (prescribe_internal_temperature)
+      {
+        const std::vector<Point<dim>> points = aspect::Utilities::get_unit_support_points(simulator_access);
+        const Quadrature<dim> quadrature (points);
+        FEValues<dim> fe_values (simulator_access.get_fe(), quadrature, update_quadrature_points | update_values | update_gradients);
+        typename DoFHandler<dim>::active_cell_iterator cell;
+        MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), simulator_access.introspection().n_compositional_fields);
+
+        // Loop over all cells
+        for (cell = simulator_access.get_dof_handler().begin_active();
+             cell != simulator_access.get_dof_handler().end();
+             ++cell)
+
+          if (! cell->is_artificial())
+            {
+              fe_values.reinit (cell);
+              in.reinit(fe_values, cell, simulator_access.introspection(), simulator_access.get_solution());
+
+              std::vector<types::global_dof_index> local_dof_indices(simulator_access.get_fe().dofs_per_cell);
+              cell->get_dof_indices (local_dof_indices);
+              for (unsigned int q=0; q<quadrature.size(); q++)
+                {
+
+                  // If it's okay to constrain this DOF
+                  if (current_constraints.can_store_line(local_dof_indices[q]) &&
+                      !current_constraints.is_constrained(local_dof_indices[q]))
+                    {
+
+                      bool constrain_temperature = false;
+                      for (unsigned int c=0; c < fixed_compositional_fields.size(); ++c)
+                        {
+
+                          const unsigned int composition_idx = simulator_access.introspection().compositional_index_for_name(fixed_compositional_fields[c]);
+                          if (in.composition[q][composition_idx] >= 0.5 || in.temperature[q] <= max_isotherm)
+                            {
+                              constrain_temperature = true;
+                            }
+                        }
+
+                      if (constrain_temperature)
+                        {
+                          // Get the temperature component index
+                          const unsigned int c_idx = simulator_access.get_fe().system_to_component_index(q).first;
+
+                          // If we're on one of the temperature DOFs
+                          if (c_idx == simulator_access.introspection().component_indices.temperature)
+                            {
+
+                              // Set the temperature to be equal to the initial temperature
+                              in.temperature[q] = initial_temperature_manager->initial_temperature(in.position[q]);
+                              // Update the constraints
+                              current_constraints.add_line (local_dof_indices[q]);
+                              current_constraints.set_inhomogeneity (local_dof_indices[q], in.temperature[q]);
+                            }
+
+
+                        }
+                    }
+                }
+            }
+      }
+  }
+
+  // Connect declare_parameters and parse_parameters to appropriate signals.
+  void parameter_connector ()
+  {
+    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
+    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
+
+    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
+    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
+  }
+
+  // Connect constraints function to correct signal.
+  template <int dim>
+  void signal_connector (SimulatorSignals<dim> &signals)
+  {
+    signals.post_constraints_creation.connect (&constrain_internal_temperature<dim>);
+  }
+
+  // Tell ASPECT to send signals to the connector functions
+  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
+  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
+}
diff --git a/tests/prescribed_temperature_in_field.prm.bak b/tests/prescribed_temperature_in_field.prm.bak
new file mode 100644
index 00000000000..9f5a54d3154
--- /dev/null
+++ b/tests/prescribed_temperature_in_field.prm.bak
@@ -0,0 +1,67 @@
+# Load the signal library.
+set Additional shared libraries = ./libprescribed_temperature_in_field.so
+set Dimension   = 2
+set End time    = 10000
+
+subsection Geometry model
+  set Model name = box
+end
+
+## The temperature will be fixed in the 'Fixed'
+## compositional field
+subsection Prescribed internal temperature model
+  set Prescribe internal temperature = true
+  set Names of compositional fields with fixed temperature = Fixed
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = Fixed, Not_fixed
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x,y
+    set Function expression = if(x<=0.5, 1, 0); if(x>=0.5, 1, 0)
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if(x<=0.4, 1000, 100)
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top, bottom, right, left
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 4
+  set Initial adaptive refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/prescribed_temperature_with_diffusion.cc.bak b/tests/prescribed_temperature_with_diffusion.cc.bak
new file mode 100644
index 00000000000..b6f22c64398
--- /dev/null
+++ b/tests/prescribed_temperature_with_diffusion.cc.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class PrescribedTemperatureMaterial : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+        virtual
+        void
+        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    PrescribedTemperatureMaterial<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      Simple<dim>::evaluate(in, out);
+
+      // set up variable to interpolate prescribed field outputs onto compositional fields
+      PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>();
+
+      if (prescribed_temperature_out != nullptr)
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          {
+            const double y = in.position[i](1);
+            prescribed_temperature_out->prescribed_temperature_outputs[i] = std::exp(-y*y/2.0);
+          }
+    }
+
+
+    template <int dim>
+    void
+    PrescribedTemperatureMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      if (out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
+        {
+          const unsigned int n_points = out.n_evaluation_points();
+          out.additional_outputs.push_back(
+            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>> (n_points));
+        }
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedTemperatureMaterial,
+                                   "prescribed temperature material",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but creates prescribed temperature outputs.")
+  }
+}
diff --git a/tests/prescribed_temperature_with_diffusion.prm.bak b/tests/prescribed_temperature_with_diffusion.prm.bak
new file mode 100644
index 00000000000..5bd3bf5c48d
--- /dev/null
+++ b/tests/prescribed_temperature_with_diffusion.prm.bak
@@ -0,0 +1,84 @@
+# A testcase that demonstrates that interpolating material model
+# outputs into the temperature field and diffusing it works.
+#
+# The property copied into the temperature field
+# is a Gaussian with an amplitude of 1, namely exp(-0.5*x*x).
+# We choose the diffusion length scale in a way that its amplitude
+# should be reduced to 0.95 when the diffusion equation is solved.
+
+set Dimension = 2
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+
+subsection Solver parameters
+  subsection Diffusion solver parameters
+    set Diffusion length scale = 0.23241476
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 0.1
+    set Y extent = 10
+    set Y repetitions = 100
+  end
+end
+
+subsection Temperature field
+  set Temperature method = prescribed field with diffusion
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = prescribed temperature material
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = named additional outputs
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/prescribed_velocity.cc.bak b/tests/prescribed_velocity.cc.bak
new file mode 100644
index 00000000000..910cee787e0
--- /dev/null
+++ b/tests/prescribed_velocity.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../cookbooks/prescribed_velocity/prescribed_velocity.cc"
diff --git a/tests/prescribed_velocity.prm.bak b/tests/prescribed_velocity.prm.bak
new file mode 100644
index 00000000000..6ee60456eb1
--- /dev/null
+++ b/tests/prescribed_velocity.prm.bak
@@ -0,0 +1,58 @@
+## First we set up a unit length box model with uniform everything.
+set Dimension                              = 2
+set End time                               = 0
+
+## Turn prescribed velocities on
+set Prescribe internal velocities = true
+
+subsection Geometry model
+  set Model name = box
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 3
+  set Initial adaptive refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics
+end
+
+subsection Prescribed velocities
+  subsection Indicator function
+    set Variable names = x,y,t
+
+    # Return where to prescribe u_x; u_y; u_z (last one only used if dimension = 3)
+    # 1 if velocity should be prescribed, 0 otherwise
+    set Function expression = if(((x>.1)&(x<.9))&(abs(x-(1-y))<.05),1,0); \
+                                if(((x>.1)&(x<.9))&(abs(x-(1-y))<.05),1,0)
+  end
+
+  subsection Velocity function
+    set Variable names = x,y,t
+
+    # Return u_x; u_y; u_z (u_z only used if in 3d)
+    set Function expression = (exp(-1*abs(x-(1-y))/.05)); \
+                                -(exp(-1*abs(x-(1-y))/.05))
+  end
+end
diff --git a/tests/prescribed_velocity_boundary.cc.bak b/tests/prescribed_velocity_boundary.cc.bak
new file mode 100644
index 00000000000..f8e9d98ec96
--- /dev/null
+++ b/tests/prescribed_velocity_boundary.cc.bak
@@ -0,0 +1,446 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+      // based on http://geodynamics.org/hg/cs/AMR/Discontinuous_Stokes with permission
+      void _Inclusion(double pos[2], double r_inclusion, double eta, double *vx, double *vy, double *p)
+      {
+        const double min_eta = 1.0;
+        const double max_eta = eta;
+        const double epsilon = 1; // strain rate
+        const double A(min_eta*(max_eta-min_eta)/(max_eta+min_eta));
+        std::complex<double> phi, psi, dphi;
+        const double offset[2]= {1.0, 1.0};
+        double r2_inclusion = r_inclusion * r_inclusion;
+
+        double x = pos[0]-offset[0];
+        double y = pos[1]-offset[1];
+        double r2 = x*x+y*y;
+
+        std::complex<double> z(x,y);
+        if (r2<r2_inclusion)
+          {
+            // inside the inclusion
+            phi=0;
+            dphi=0;
+            psi=-4*epsilon*(max_eta*min_eta/(min_eta+max_eta))*z;
+          }
+        else
+          {
+            // outside the inclusion
+            phi=-2*epsilon*A*r2_inclusion/z;
+            dphi=-phi/z;
+            psi=-2*epsilon*(min_eta*z+A*r2_inclusion*r2_inclusion/(z*z*z));
+          }
+        double visc = (r2<r2_inclusion)? max_eta : 1.0;
+        std::complex<double> v = (phi - z*conj(dphi) - conj(psi))/(2.0*visc);
+        *vx=v.real();
+        *vy=v.imag();
+        *p=-2*epsilon*dphi.real();
+      }
+
+
+
+
+
+      /**
+       * The exact solution for the Inclusion benchmark.
+       */
+      template <int dim>
+      class FunctionInclusion : public Function<dim>
+      {
+        public:
+          FunctionInclusion (double eta_B) : Function<dim>(dim+2), eta_B_(eta_B) {}
+          virtual void vector_value (const Point<dim>   &p,
+                                     Vector<double>   &values) const
+          {
+            double pos[2]= {p(0),p(1)};
+            AnalyticSolutions::_Inclusion
+            (pos,0.2,eta_B_, &values[0], &values[1], &values[2]);
+          }
+
+        private:
+          double eta_B_;
+      };
+    }
+
+
+
+    template <int dim>
+    class InclusionBoundary : public BoundaryVelocity::Interface<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        InclusionBoundary(): eta_B (1e3)
+        {}
+
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        virtual
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id boundary_id,
+                           const Point<dim> &position) const;
+
+        virtual void initialize ()
+        { }
+
+
+      private:
+
+        double eta_B;
+    };
+
+
+    template <int dim>
+    Tensor<1,dim>
+    InclusionBoundary<dim>::
+    boundary_velocity (const types::boundary_id boundary_id,
+                       const Point<dim> &p) const
+    {
+      Assert (dim == 2, ExcNotImplemented());
+
+      std::cout << "Boundary_velocity called with boundary_id ="
+                << static_cast<int>(boundary_id) << std::endl;
+
+      return Tensor<1,dim>();
+      double pos[2]= {p(0),p(1)};
+
+      Tensor<1,dim> velocity;
+      double pressure;
+      AnalyticSolutions::_Inclusion
+      (pos,0.2,eta_B, &velocity[0], &velocity[1], &pressure);
+
+      return velocity;
+    }
+
+
+
+
+    /**
+     * A material model that describes the "Pure shear/Inclusion" benchmark
+     * of the paper cited in the documentation of the DuretzEtAl namespace.
+     *
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     *
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class InclusionMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const Point<dim> &pos = in.position[i];
+              const double r2 = ( pos[0] - 1.0 ) * ( pos[0] - 1.0 ) + ( pos[1] - 1.0 ) * ( pos[1] - 1.0 );
+              out.viscosities[i] = ( r2 < 0.2 * 0.2 ) ? eta_B : 1.0;
+              out.densities[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.compressibilities[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+              out.specific_heat[i] = 0;
+            }
+        }
+
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        virtual bool is_compressible () const;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+
+
+
+        /**
+         * Returns the viscosity value in the inclusion
+         */
+        double get_eta_B() const;
+
+      private:
+        /**
+         * viscosity value in the inclusion
+         */
+        double eta_B;
+    };
+
+    template <int dim>
+    bool
+    InclusionMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    InclusionMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Inclusion");
+        {
+          prm.declare_entry ("Viscosity jump", "1e3",
+                             Patterns::Double (0),
+                             "Viscosity in the Inclusion.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    InclusionMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection("Inclusion");
+        {
+          eta_B = prm.get_double ("Viscosity jump");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+    template <int dim>
+    double
+    InclusionMaterial<dim>::get_eta_B() const
+    {
+      return eta_B;
+    }
+
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution of the
+      * aspect::MaterialModel::DuretzEtAl::Inclusion material models.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the following paper:
+      * @code
+      *  @Article{DMGT11,
+      *    author =       {T. Duretz and D. A. May and T. V. Gerya and P. J. Tackley},
+      *    title =        {Discretization errors and free surface stabilization in the
+      *                  finite difference and marker-in-cell method for applied
+      *                  geodynamics: {A} numerical study},
+      *    journal =      {Geochemistry Geophysics Geosystems},
+      *    year =         2011,
+      *    volume =       12,
+      *    pages =        {Q07004/1--26}}
+      * @endcode
+      *
+      * @note While this paper summarizes the benchmarks used here, some of the
+      * benchmarks actually originate in earlier papers. For the original
+      * references, see the bibliography of the paper above.
+      * @ingroup Postprocessing
+      */
+    template <int dim>
+    class InclusionPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        virtual
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics);
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    InclusionPostprocessor<dim>::execute (TableHandler &statistics)
+    {
+      std::unique_ptr<Function<dim>> ref_func;
+      if (dynamic_cast<const InclusionMaterial<dim> *>(&this->get_material_model()) != nullptr)
+        {
+          const InclusionMaterial<dim> *
+          material_model
+            = dynamic_cast<const InclusionMaterial<dim> *>(&this->get_material_model());
+
+          ref_func = std::make_unique<AnalyticSolutions::FunctionInclusion<dim>>(material_model->get_eta_B());
+        }
+      else
+        {
+          AssertThrow(false,
+                      ExcMessage("Postprocessor DuretzEtAl only works with the material model SolCx, SolKz, and Inclusion."));
+        }
+
+      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
+
+      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                          dim+2);
+      ComponentSelectFunction<dim> comp_p(dim, dim+2);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_u,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_p,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_p);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_ul2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_pl2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+      std::ostringstream os;
+      os << std::scientific << u_l1
+         << ", " << p_l1
+         << ", " << u_l2
+         << ", " << p_l2;
+
+      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
+    }
+
+
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InclusionBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(InclusionMaterial,
+                                   "InclusionMaterial",
+                                   "A material model that corresponds to the 'Inclusion' benchmark "
+                                   "defined in Duretz et al., G-Cubed, 2011.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(InclusionBoundary,
+                                            "InclusionBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "``inclusion'' benchmark. See the manual and the Kronbichler, Heister "
+                                            "and Bangerth paper on ASPECT for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(InclusionPostprocessor,
+                                  "InclusionPostprocessor",
+                                  "A postprocessor that compares the solution of the benchmarks from "
+                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
+                                  "and reports the error. Specifically, it can compute the errors for "
+                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
+                                  "which material model is currently being used and adjusts "
+                                  "which exact solution to use accordingly.")
+  }
+}
diff --git a/tests/prescribed_velocity_boundary.prm.bak b/tests/prescribed_velocity_boundary.prm.bak
new file mode 100644
index 00000000000..c7d3b9a94d2
--- /dev/null
+++ b/tests/prescribed_velocity_boundary.prm.bak
@@ -0,0 +1,88 @@
+# copied from inclusion_2 to test VelocityBoundaryConditions::initialize(indicator)
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 1
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = InclusionMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Strategy                           = thermal energy density
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, InclusionPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/prescribed_velocity_dgp.cc.bak b/tests/prescribed_velocity_dgp.cc.bak
new file mode 100644
index 00000000000..30afa2c63f3
--- /dev/null
+++ b/tests/prescribed_velocity_dgp.cc.bak
@@ -0,0 +1,264 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/parsed_function.h>
+#include <deal.II/fe/fe_values.h>
+#include <aspect/global.h>
+#include <aspect/utilities.h>
+#include <aspect/simulator_signals.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  // Global variables (to be set by parameters)
+  bool prescribe_internal_velocities;
+
+  // Because we do not initially know what dimension we're in, we need
+  // function parser objects for both 2d and 3d.
+  Functions::ParsedFunction<2> prescribed_velocity_indicator_function_2d (2);
+  Functions::ParsedFunction<3> prescribed_velocity_indicator_function_3d (3);
+  Functions::ParsedFunction<2> prescribed_velocity_function_2d (2);
+  Functions::ParsedFunction<3> prescribed_velocity_function_3d (3);
+
+
+
+  /**
+   * Declare additional parameters.
+   */
+  void declare_parameters(const unsigned int dim,
+                          ParameterHandler &prm)
+  {
+    prm.declare_entry ("Prescribe internal velocities", "false",
+                       Patterns::Bool (),
+                       "Whether or not to use any prescribed internal velocities. "
+                       "Locations in which to prescribe velocities are defined "
+                       "in section ``Prescribed velocities/Indicator function'' "
+                       "and the velocities are defined in section ``Prescribed "
+                       "velocities/Velocity function''. Indicators are evaluated "
+                       "at the center of each cell, and all DOFs associated with "
+                       "the specified velocity component at the indicated cells "
+                       "are constrained."
+                      );
+
+    prm.enter_subsection ("Prescribed velocities");
+    {
+      prm.enter_subsection ("Indicator function");
+      {
+        if (dim == 2)
+          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
+        else
+          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
+      }
+      prm.leave_subsection ();
+
+      prm.enter_subsection ("Velocity function");
+      {
+        if (dim == 2)
+          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
+        else
+          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
+      }
+      prm.leave_subsection ();
+    }
+    prm.leave_subsection ();
+  }
+
+
+
+  template <int dim>
+  void parse_parameters(const Parameters<dim> &,
+                        ParameterHandler &prm)
+  {
+    prescribe_internal_velocities = prm.get_bool ("Prescribe internal velocities");
+    prm.enter_subsection ("Prescribed velocities");
+    {
+      prm.enter_subsection("Indicator function");
+      {
+        try
+          {
+            if (dim == 2)
+              prescribed_velocity_indicator_function_2d.parse_parameters (prm);
+            else
+              prescribed_velocity_indicator_function_3d.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Prescribed velocities.Indicator function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'";
+            throw;
+          }
+      }
+      prm.leave_subsection();
+
+      prm.enter_subsection("Velocity function");
+      {
+        try
+          {
+            if (dim == 2)
+              prescribed_velocity_function_2d.parse_parameters (prm);
+            else
+              prescribed_velocity_function_3d.parse_parameters (prm);
+          }
+        catch (...)
+          {
+            std::cerr << "ERROR: FunctionParser failed to parse\n"
+                      << "\t'Prescribed velocities.Velocity function'\n"
+                      << "with expression\n"
+                      << "\t'" << prm.get("Function expression") << "'";
+            throw;
+          }
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection ();
+  }
+
+
+
+  /**
+   * This function is called by a signal which is triggered after the other constraints
+   * have been calculated. This enables us to define additional constraints in the mass
+   * matrix on any arbitrary degree of freedom in the model space.
+   */
+  template <int dim>
+  void constrain_internal_velocities (const SimulatorAccess<dim> &simulator_access,
+                                      AffineConstraints<double> &current_constraints)
+  {
+    if (prescribe_internal_velocities)
+      {
+        const std::vector<Point<dim>> points = aspect::Utilities::get_unit_support_points(simulator_access);
+        const Quadrature<dim> quadrature (points);
+        FEValues<dim> fe_values (simulator_access.get_fe(), quadrature, update_quadrature_points);
+        typename DoFHandler<dim>::active_cell_iterator cell;
+
+        // Loop over all cells
+        for (cell = simulator_access.get_dof_handler().begin_active();
+             cell != simulator_access.get_dof_handler().end();
+             ++cell)
+          if (! cell->is_artificial())
+            {
+              fe_values.reinit (cell);
+              std::vector<types::global_dof_index> local_dof_indices(simulator_access.get_fe().dofs_per_cell);
+              cell->get_dof_indices (local_dof_indices);
+
+              for (unsigned int q=0; q<quadrature.size(); q++)
+                // If it's okay to constrain this DOF
+                if (current_constraints.can_store_line(local_dof_indices[q]) &&
+                    !current_constraints.is_constrained(local_dof_indices[q]))
+                  {
+                    // Get the velocity component index
+                    const unsigned int c_idx =
+                      simulator_access.get_fe().system_to_component_index(q).first;
+
+                    // If we're on one of the velocity DOFs
+                    if ((c_idx >=
+                         simulator_access.introspection().component_indices.velocities[0])
+                        &&
+                        (c_idx <=
+                         simulator_access.introspection().component_indices.velocities[dim-1]))
+                      {
+                        // Which velocity component is this DOF associated with?
+                        const unsigned int component_direction
+                          = (c_idx
+                             - simulator_access.introspection().component_indices.velocities[0]);
+
+                        // we get time passed as seconds (always) but may want
+                        // to reinterpret it in years
+                        double time = simulator_access.get_time();
+                        if (simulator_access.convert_output_to_years())
+                          time /= year_in_seconds;
+
+                        prescribed_velocity_indicator_function_2d.set_time (time);
+                        prescribed_velocity_indicator_function_3d.set_time (time);
+                        prescribed_velocity_function_2d.set_time (time);
+                        prescribed_velocity_function_3d.set_time (time);
+
+                        const Point<dim> p = fe_values.quadrature_point(q);
+
+                        // Because we defined and parsed our parameter
+                        // file differently for 2d and 3d we need to
+                        // be sure to query the correct object for
+                        // function values. The function parser
+                        // objects expect points of a certain
+                        // dimension, but Point p will be compiled for
+                        // both 2d and 3d, so we need some careful
+                        // casts to make this compile. Casting Point
+                        // objects between 2d and 3d is somewhat
+                        // meaningless but the offending casts will
+                        // never actually be executed because they are
+                        // protected by the if/else statements.
+                        double indicator, u_i;
+                        if (dim == 2)
+                          {
+                            indicator = prescribed_velocity_indicator_function_2d.value
+                                        (reinterpret_cast<const Point<2>&>(p),
+                                         component_direction);
+                            u_i       = prescribed_velocity_function_2d.value
+                                        (reinterpret_cast<const Point<2>&>(p),
+                                         component_direction);
+                          }
+                        else
+                          {
+                            indicator = prescribed_velocity_indicator_function_3d.value
+                                        (reinterpret_cast<const Point<3>&>(p),
+                                         component_direction);
+                            u_i       = prescribed_velocity_function_3d.value
+                                        (reinterpret_cast<const Point<3>&>(p),
+                                         component_direction);
+                          }
+
+                        if (indicator > 0.5)
+                          {
+                            // Add a constraint of the form dof[q] = u_i
+                            // to the list of constraints.
+                            current_constraints.add_line (local_dof_indices[q]);
+                            current_constraints.set_inhomogeneity (local_dof_indices[q], u_i);
+                          }
+                      }
+                  }
+            }
+      }
+  }
+
+  // Connect declare_parameters and parse_parameters to appropriate signals.
+  void parameter_connector ()
+  {
+    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
+    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
+
+    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
+    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
+  }
+
+  // Connect constraints function to correct signal.
+  template <int dim>
+  void signal_connector (SimulatorSignals<dim> &signals)
+  {
+    signals.post_constraints_creation.connect (&constrain_internal_velocities<dim>);
+  }
+
+  // Tell ASPECT to send signals to the connector functions
+  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
+  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
+}
diff --git a/tests/prescribed_velocity_dgp.prm.bak b/tests/prescribed_velocity_dgp.prm.bak
new file mode 100644
index 00000000000..85385afdda4
--- /dev/null
+++ b/tests/prescribed_velocity_dgp.prm.bak
@@ -0,0 +1,62 @@
+## First we set up a unit length box model with uniform everything.
+set Dimension                              = 2
+set End time                               = 0
+
+## Turn prescribed velocities on
+set Prescribe internal velocities = true
+
+subsection Discretization
+  set Use locally conservative discretization = true
+end
+
+subsection Geometry model
+  set Model name = box
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 3
+  set Initial adaptive refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics
+end
+
+subsection Prescribed velocities
+  subsection Indicator function
+    set Variable names = x,y,t
+
+    # Return where to prescribe u_x; u_y; u_z (last one only used if dimension = 3)
+    # 1 if velocity should be prescribed, 0 otherwise
+    set Function expression = if(((x>.1)&(x<.9))&(abs(x-(1-y))<.05),1,0); \
+                                if(((x>.1)&(x<.9))&(abs(x-(1-y))<.05),1,0)
+  end
+
+  subsection Velocity function
+    set Variable names = x,y,t
+
+    # Return u_x; u_y; u_z (u_z only used if in 3d)
+    set Function expression = (exp(-1*abs(x-(1-y))/.05)); \
+                                -(exp(-1*abs(x-(1-y))/.05))
+  end
+end
diff --git a/tests/prescribed_viscosity_additional_outputs.prm.bak b/tests/prescribed_viscosity_additional_outputs.prm.bak
new file mode 100644
index 00000000000..a3c82cca0dd
--- /dev/null
+++ b/tests/prescribed_viscosity_additional_outputs.prm.bak
@@ -0,0 +1,41 @@
+# Like grain_size_growth.prm, but check that additional
+# material model outputs can be postprocessed correctly
+# in the prescribed viscosity material model.
+
+############### Global parameters
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
+
+set End time = 0
+
+subsection Material model
+  set Model name = prescribed viscosity
+
+  subsection Prescribed viscosity
+    set Base model = grain size
+
+    subsection Indicator function
+      # Return where to prescribe the viscosity
+      set Function expression = if(x>50000, 1, 0)
+    end
+
+    subsection Viscosity function
+      set Function expression = 1e22
+    end
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables = viscosity, named additional outputs
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/prescribed_viscosity_happy.prm.bak b/tests/prescribed_viscosity_happy.prm.bak
new file mode 100644
index 00000000000..d88a4fb44f8
--- /dev/null
+++ b/tests/prescribed_viscosity_happy.prm.bak
@@ -0,0 +1,72 @@
+set Dimension   = 2
+set CFL number  = 0.5
+set End time    = 0
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1e3
+    set Y extent = 1e3
+    set X repetitions = 1
+    set Y repetitions = 1
+  end
+end
+
+subsection Mesh refinement
+  set Time steps between mesh refinement = 5
+  set Initial global refinement = 5
+  set Initial adaptive refinement = 4
+  set Strategy = viscosity
+  set Skip solvers on initial refinement = true
+end
+
+subsection Material model
+  set Model name = prescribed viscosity
+  set Material averaging = geometric average only viscosity
+
+  subsection Prescribed viscosity
+    set Base model = simple
+
+    subsection Indicator function
+      set Variable names = x,y,t
+
+      # Return where to prescribe u_x; u_y; u_z
+      # (last one only used if dimension = 3)
+      # 1 if velocity should be prescribed, 0 otherwise
+      set Function expression = if(y>425,if(x<500, \
+      if(sqrt((x-250)*(x-250)+(y-750)*(y-750))<100,1,0), \
+      if(sqrt((x-750)*(x-750)+(y-750)*(y-750))<100,1,0)), \
+      if(sqrt((x-500)*(x-500)+(y-500)*(y-500))>200 & sqrt((x-500)*(x-500)+(y-500)*(y-500))<300,1,0))
+    end
+
+    subsection Viscosity function
+      set Variable names = x,y,t
+
+      # Return u_x; u_y; u_z (u_z only used if in 3d)
+      set Function expression = if(y>425,if(x<500, \
+      if(sqrt((x-250)*(x-250)+(y-750)*(y-750))<100,if(y<775,if(sqrt((x-250)*(x-250)+(y-750)*(y-750))>25,7.5e25,1e25),1e26),0), \
+      if(sqrt((x-750)*(x-750)+(y-750)*(y-750))<100,if(y<775,if(sqrt((x-750)*(x-750)+(y-750)*(y-750))>25,7.5e25,1e25),1e26),0)), \
+      if(sqrt((x-500)*(x-500)+(y-500)*(y-500))>200 & sqrt((x-500)*(x-500)+(y-500)*(y-500))<300,1e24*sqrt((x-500)*(x-500)+(y-500)*(y-500))/3,0))
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables = material properties
+    set Output format                 = gnuplot
+    set Number of grouped files       = 0
+  end
+end
diff --git a/tests/pressure_boundary.prm.bak b/tests/pressure_boundary.prm.bak
new file mode 100644
index 00000000000..0f92413fee8
--- /dev/null
+++ b/tests/pressure_boundary.prm.bak
@@ -0,0 +1,92 @@
+# like refine_vel.prm, but run the "spherical velocity statistics"
+# postprocessor
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e300
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Pressure normalization = volume
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Additional refinement times              = 0,0
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, boundary pressures
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/pressure_compatibility.prm.bak b/tests/pressure_compatibility.prm.bak
new file mode 100644
index 00000000000..035384a4bff
--- /dev/null
+++ b/tests/pressure_compatibility.prm.bak
@@ -0,0 +1,77 @@
+# A test, whether we apply the right pressure compatibility
+# correction in the case of prescribed boundary conditions.
+# This test is essentially similar to the platelike-boundary
+# cookbook but uses a strongly compressible material model.
+# Previously we did not correct the pressure RHS in this setup,
+# which prevented it from converging.
+
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.1
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Reference compressibility     = 7e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heat flux statistics, velocity statistics
+end
diff --git a/tests/pressure_compatibility_2.prm.bak b/tests/pressure_compatibility_2.prm.bak
new file mode 100644
index 00000000000..b8e200639c4
--- /dev/null
+++ b/tests/pressure_compatibility_2.prm.bak
@@ -0,0 +1,95 @@
+# This is a compressible test case that shall
+# test the behavior of the pressure compatibility
+# mechanism in case of prescribed normal velocities
+# integrated over the boundaries. It is converging
+# in this setup, but if the solver tolerance is
+# decreased or the prescribed normal velocity is
+# increased it fails to converge, which is exactly
+# the behavior we intend.
+
+set CFL number                             = 1
+set End time                               = 400
+set Adiabatic surface temperature          = 0.5
+set Use years in output instead of seconds = false
+set Pressure normalization                 = no
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 2
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 0.01
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density = 1
+    set Reference specific heat = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity = 1
+    set Thermal conductivity = 1e-7
+    set Reference compressibility = 1e-6
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,3
+  set Prescribed velocity boundary indicators = 2:function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1e-9
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, temperature statistics
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/pressure_compatibility_3.prm.bak b/tests/pressure_compatibility_3.prm.bak
new file mode 100644
index 00000000000..b37e5210a48
--- /dev/null
+++ b/tests/pressure_compatibility_3.prm.bak
@@ -0,0 +1,94 @@
+# This is a compressible test case that tests
+# the behavior of the pressure compatibility
+# mechanism in case of prescribed normal velocities
+# whose integral over the boundaries is non-zero.
+# This checks that the linear solver converges, even
+# with low solver tolerance and a significant in- or
+# outflow.
+
+set CFL number                             = 1
+set End time                               = 50
+set Adiabatic surface temperature          = 0.5
+set Use years in output instead of seconds = false
+set Pressure normalization                 = no
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 2
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 0.01
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density = 1
+    set Reference specific heat = 1
+    set Thermal expansion coefficient = 1
+    set Viscosity = 1
+    set Thermal conductivity = 1e-7
+    set Reference compressibility = 1e-6
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,3
+  set Prescribed velocity boundary indicators = 2:function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;0.01
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, temperature statistics, mass flux statistics
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/pressure_compatibility_4.prm.bak b/tests/pressure_compatibility_4.prm.bak
new file mode 100644
index 00000000000..c453722fd3b
--- /dev/null
+++ b/tests/pressure_compatibility_4.prm.bak
@@ -0,0 +1,101 @@
+# This is a compressible test case that tests
+# the behavior of the pressure compatibility
+# mechanism in case of prescribed normal velocities
+# whose integral over the boundaries is zero when
+# using the exact values, but non-zero when using the
+# interpolated values (i.e. constant at the top, and
+# sin(x) at the bottom). This checks that the linear
+# solver converges, even with a very low solver tolerance.
+
+set CFL number                             = 1
+set End time                               = 5e-5
+set Adiabatic surface temperature          = 0.5
+set Use years in output instead of seconds = false
+set Pressure normalization                 = no
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 2
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 0.01
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density = 1
+    set Reference specific heat = 1
+    set Thermal expansion coefficient = 0
+    set Viscosity = 1
+    set Thermal conductivity = 1e-7
+    set Reference compressibility = 1e-6
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;if(y<0.5,1e3*(1-cos(1.0)),1e3*sin(x))
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, temperature statistics, mass flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-15
+  end
+end
diff --git a/tests/pressure_compatibility_dg.prm.bak b/tests/pressure_compatibility_dg.prm.bak
new file mode 100644
index 00000000000..faab4b7cd27
--- /dev/null
+++ b/tests/pressure_compatibility_dg.prm.bak
@@ -0,0 +1,9 @@
+# like pressure_compatibility.prm but with DG pressure
+# MPI: 2
+
+include $ASPECT_SOURCE_DIR/tests/pressure_compatibility.prm
+
+
+subsection Discretization
+  set Use locally conservative discretization = true
+end
diff --git a/tests/pressure_compatibility_dg_direct.prm.bak b/tests/pressure_compatibility_dg_direct.prm.bak
new file mode 100644
index 00000000000..e3e760b55ca
--- /dev/null
+++ b/tests/pressure_compatibility_dg_direct.prm.bak
@@ -0,0 +1,15 @@
+# like pressure_compatibility.prm but with DG pressure and a direct solver
+# MPI: 2
+
+include $ASPECT_SOURCE_DIR/tests/pressure_compatibility.prm
+
+
+subsection Discretization
+  set Use locally conservative discretization = true
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/pressure_compatibility_direct.prm.bak b/tests/pressure_compatibility_direct.prm.bak
new file mode 100644
index 00000000000..ae9795796d7
--- /dev/null
+++ b/tests/pressure_compatibility_direct.prm.bak
@@ -0,0 +1,11 @@
+# like pressure_compatibility.prm but with a direct solver
+# MPI: 2
+
+include $ASPECT_SOURCE_DIR/tests/pressure_compatibility.prm
+
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
diff --git a/tests/pressure_constraint.cc.bak b/tests/pressure_constraint.cc.bak
new file mode 100644
index 00000000000..2b1f1a84868
--- /dev/null
+++ b/tests/pressure_constraint.cc.bak
@@ -0,0 +1,60 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <deal.II/base/parameter_handler.h>
+#include <deal.II/base/parsed_function.h>
+#include <deal.II/fe/fe_values.h>
+#include <aspect/global.h>
+#include <aspect/simulator_signals.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  template <int dim>
+  void modify_constraints (const SimulatorAccess<dim> &simulator_access,
+                           AffineConstraints<double> &current_constraints)
+  {
+    // Hack: the first pressure dof is only this easy to compute if we don't
+    // use a direct solver or reorganize the blocks of the linear system in
+    // some other way. Good enough for this test though!
+    const types::global_dof_index first_pressure_dof =
+      simulator_access.introspection().system_dofs_per_block[0];
+
+    const double value = 100;
+
+    current_constraints.add_line(first_pressure_dof);
+    current_constraints.set_inhomogeneity (first_pressure_dof, value);
+
+    std::cout << "adding constraint idx= " << first_pressure_dof
+              << " to value= " << value
+              << std::endl;
+  }
+
+  // Connect constraints function to correct signal.
+  template <int dim>
+  void signal_connector (SimulatorSignals<dim> &signals)
+  {
+    signals.post_constraints_creation.connect (&modify_constraints<dim>);
+  }
+
+  // Tell ASPECT to send signals to the connector functions
+  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
+}
diff --git a/tests/pressure_constraint.prm.bak b/tests/pressure_constraint.prm.bak
new file mode 100644
index 00000000000..55d04041fa8
--- /dev/null
+++ b/tests/pressure_constraint.prm.bak
@@ -0,0 +1,70 @@
+# based on poiseuille_2d.prm but add a pressure constraint to one
+# pressure DoF
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0.1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Pressure normalization = no
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 0
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function
+  set Zero velocity boundary indicators       = 2, 3
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z*(1-z);0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, matrix statistics
+end
diff --git a/tests/pressure_scaling_signal.cc.bak b/tests/pressure_scaling_signal.cc.bak
new file mode 100644
index 00000000000..0a0c76af191
--- /dev/null
+++ b/tests/pressure_scaling_signal.cc.bak
@@ -0,0 +1,44 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/inclusion/inclusion.cc"
+
+#include <aspect/simulator_signals.h>
+
+
+double my_signal(const double pressure_scaling, const double reference_viscosity, const double length_scale)
+{
+  std::cout << "pressure_scaling = " << pressure_scaling
+            << " reference_viscosity = " << reference_viscosity
+            << " length_scale = " << length_scale << std::endl;
+  // Now change it to something different:
+  return 42.0;
+}
+
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  std::cout << "* Connecting signals" << std::endl;
+  signals.modify_pressure_scaling.connect(&my_signal);
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/pressure_scaling_signal.prm.bak b/tests/pressure_scaling_signal.prm.bak
new file mode 100644
index 00000000000..a7704a9ad35
--- /dev/null
+++ b/tests/pressure_scaling_signal.prm.bak
@@ -0,0 +1,88 @@
+# copy of inclusion_4.prm to test the signal modify_pressure_scaling.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = volume
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 1
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = InclusionMaterial
+
+  subsection Inclusion
+    set Viscosity jump = 1e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = thermal energy density
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, InclusionPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/principal_deviatoric_stress.cc.bak b/tests/principal_deviatoric_stress.cc.bak
new file mode 100644
index 00000000000..c45fb20207c
--- /dev/null
+++ b/tests/principal_deviatoric_stress.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "simple_shear.cc"
diff --git a/tests/principal_deviatoric_stress.prm.bak b/tests/principal_deviatoric_stress.prm.bak
new file mode 100644
index 00000000000..d0b0fd38671
--- /dev/null
+++ b/tests/principal_deviatoric_stress.prm.bak
@@ -0,0 +1,117 @@
+# This is a copy of simple_shear.prm that tests the 'principal stress'
+# postprocessor when computing principal stresses for the deviatoric stress
+# only. Due to the nature of the benchmark the principal deviatoric stress
+# should be 200/-200 Pa respectively (see simple_shear.prm) for a description
+# of the benchmark.
+
+set Dimension                              = 2
+set End time                               = 0.025
+set Use years in output instead of seconds = false
+set Output directory = simple_shear
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set X periodic = true
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+
+  subsection Function
+    set Function expression = if (y < 0.5, -1, 1); 0
+  end
+end
+
+subsection Material model
+  set Model name = finite strain
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0;0.0;0.0;1.0
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, composition statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = strain rate, stress, principal stress
+    set Output format = gnuplot
+    set Time between graphical output = 0.05
+
+    subsection Principal stress
+      set Use deviatoric stress = true
+    end
+  end
+
+  subsection Particles
+    set Time between data output = 0.05
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain
+  set Particle generator name = ascii file
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/finite_strain/
+      set Data file name = simple_shear_particle.dat
+    end
+  end
+end
diff --git a/tests/prm_distance_polygon.cc.bak b/tests/prm_distance_polygon.cc.bak
new file mode 100644
index 00000000000..50d48fda0f8
--- /dev/null
+++ b/tests/prm_distance_polygon.cc.bak
@@ -0,0 +1,77 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+#include <iostream>
+
+int f()
+{
+  using namespace aspect::Utilities;
+
+  const int dim=3;
+
+  // A square polygon
+  std::vector<Point<2>> polygon(4);
+  polygon[0] = Point<2>(0.0,0.0);
+  polygon[1] = Point<2>(1.0,0.0);
+  polygon[2] = Point<2>(1.0,1.0);
+  polygon[3] = Point<2>(0.0,1.0);
+
+  // A concave polygon
+  std::vector<Point<2>> concave_polygon(5);
+  concave_polygon[0] = Point<2>(0.0,0.0);
+  concave_polygon[1] = Point<2>(1.0,0.0);
+  concave_polygon[2] = Point<2>(1.0,1.0);
+  concave_polygon[3] = Point<2>(0.5,0.5);
+  concave_polygon[4] = Point<2>(0.0,1.0);
+
+  // A selfcrossing polygon
+  std::vector<Point<2>> crossing_polygon(4);
+  crossing_polygon[0] = Point<2>(0.0,0.0);
+  crossing_polygon[1] = Point<2>(1.0,0.0);
+  crossing_polygon[2] = Point<2>(1.0,-1.0);
+  crossing_polygon[3] = Point<2>(0.0,1.0);
+
+
+  // Some points inside and outside the polygon
+  Point<2> points[] = {Point<2>(0.5,-1), Point<2>(0.5,0.5), Point<2>(0.001,0.2), Point<2>(2.0,2.0), Point<2>(0.25,0.70)};
+
+  std::cout << "Testing distance to polygon function with the following parameters: (polygon 1) "
+            << polygon[0] << ", " << polygon[1] << ", " << polygon[2] << ", " << polygon[3] << ", "
+            << "(polygon 2) " << concave_polygon[0] << ", " << concave_polygon[1] << ", " << concave_polygon[2] << ", " << concave_polygon[3] << ", " << concave_polygon[4] << ", "
+            << "(polygon 3) " << crossing_polygon[0] << ", " << crossing_polygon[1] << ", " << crossing_polygon[2] << ", " << crossing_polygon[3]
+            << ", (points) "
+            << points[0] << ", " << points[1] << ", " << points[2] << ", " << points[3] << ", " << points[4] << std::endl;
+
+  for (unsigned int i = 0; i < 5; i++)
+    {
+      std::cout << "Minimal distance of point " << points[i] << " to polygon 1 = " << signed_distance_to_polygon<dim>(polygon,points[i]) << std::endl;
+      std::cout << "Minimal distance of point " << points[i] << " to polygon 2 = " << signed_distance_to_polygon<dim>(concave_polygon,points[i]) << std::endl;
+      std::cout << "Minimal distance of point " << points[i] << " to polygon 3 = " << signed_distance_to_polygon<dim>(crossing_polygon,points[i]) << std::endl;
+    }
+
+  exit(0);
+  return 42;
+}
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/prm_distance_polygon.prm.bak b/tests/prm_distance_polygon.prm.bak
new file mode 100644
index 00000000000..583a5b0da38
--- /dev/null
+++ b/tests/prm_distance_polygon.prm.bak
@@ -0,0 +1 @@
+set Additional shared libraries = tests/libprm_distance_polygon.so
diff --git a/tests/prm_polygon_in_out.cc.bak b/tests/prm_polygon_in_out.cc.bak
new file mode 100644
index 00000000000..c9a9b1d222e
--- /dev/null
+++ b/tests/prm_polygon_in_out.cc.bak
@@ -0,0 +1,82 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/geometry_model/initial_topography_model/interface.h>
+#include <aspect/geometry_model/initial_topography_model/prm_polygon.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+
+int f()
+{
+  using namespace aspect;
+  const int dim=3;
+  std::string parameters_clockwise = "100 > 0,0;0,5;5,5;5,0 & -100 > 10,10;10,15;15,15";
+  std::string parameters_anticlockwise = "100 > 0,0;5,0;5,5;0,5 & -100 > 10,10;15,15;10,15";
+  InitialTopographyModel::PrmPolygon<dim> topo_clockwise;
+  InitialTopographyModel::PrmPolygon<dim> topo_anticlockwise;
+
+  ParameterHandler prm_clockwise;
+  topo_clockwise.declare_parameters(prm_clockwise);
+  prm_clockwise.enter_subsection("Geometry model");
+  prm_clockwise.enter_subsection ("Initial topography model");
+  prm_clockwise.enter_subsection ("Prm polygon");
+  prm_clockwise.set ("Topography parameters", parameters_clockwise);
+  prm_clockwise.leave_subsection();
+  prm_clockwise.leave_subsection();
+  prm_clockwise.leave_subsection();
+
+  ParameterHandler prm_anticlockwise;
+  topo_anticlockwise.declare_parameters(prm_anticlockwise);
+  prm_anticlockwise.enter_subsection("Geometry model");
+  prm_anticlockwise.enter_subsection ("Initial topography model");
+  prm_anticlockwise.enter_subsection ("Prm polygon");
+  prm_anticlockwise.set ("Topography parameters", parameters_anticlockwise);
+  prm_anticlockwise.leave_subsection();
+  prm_anticlockwise.leave_subsection();
+  prm_anticlockwise.leave_subsection();
+
+  topo_clockwise.parse_parameters(prm_clockwise);
+  topo_anticlockwise.parse_parameters(prm_anticlockwise);
+
+  Point<2> points[] = {Point<2>(-1,-1),Point<2>(0,0),Point<2>(0.001,0),Point<2>(0,0.001),Point<2>(0.001,0.001),
+                       Point<2>(0,-0.001),Point<2>(-0.001,-0.001),Point<2>(-0.01,2.5),Point<2>(0,2.5),Point<2>(0.01,2.5),
+                       Point<2>(0,4.99),Point<2>(0,5),Point<2>(0.01,5),Point<2>(2.5,5),Point<2>(2.5,-0.01),
+                       Point<2>(2.5,0),Point<2>(2.5,0.01),Point<2>(4.99,0),Point<2>(5,0),Point<2>(5,0.01),
+                       Point<2>(5,2.5),Point<2>(4.99,5),Point<2>(5,4.99),Point<2>(5,5),Point<2>(5,5.01),
+                       Point<2>(1,1),Point<2>(12.5,12),Point<2>(11.5,12),Point<2>(15,10),Point<2>(14,10),
+                       Point<2>(15,11),Point<2>(5,6),Point<2>(6,5),Point<2>(0,-1),Point<2>(-1,0),
+                       Point<2>(-1,5),Point<2>(0,6),Point<2>(5,-1),Point<2>(6,0),Point<2>(6,-1),
+                       Point<2>(16,16),Point<2>(12.5,15),Point<2>(10,12.5),Point<2>(10,15),Point<2>(10,10)
+                      };
+
+  std::cout << "Testing prm polygon plugin with the following parameters: (clockwise) " << parameters_clockwise << ", (anticlockwise) " << parameters_anticlockwise << std::endl;
+  for (unsigned int i = 0; i < 45; i++)
+    {
+      std::cout << "Clockwise topo at     (" << points[i] << ") = " << topo_clockwise.value(points[i]) << std::endl;
+      std::cout << "Anticlockwise Topo at (" << points[i] << ") = " << topo_anticlockwise.value(points[i]) << std::endl;
+    }
+
+  exit(0);
+  return 42;
+}
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/prm_polygon_in_out.prm.bak b/tests/prm_polygon_in_out.prm.bak
new file mode 100644
index 00000000000..2f9359eb8db
--- /dev/null
+++ b/tests/prm_polygon_in_out.prm.bak
@@ -0,0 +1 @@
+set Additional shared libraries = tests/libprm_polygon_in_out.so
diff --git a/tests/prmbackslash.prm b/tests/prmbackslash.prm
index 63063c53811..735593109e8 100644
--- a/tests/prmbackslash.prm
+++ b/tests/prmbackslash.prm
@@ -51,11 +51,6 @@ subsection Mesh refinement
   set Initial global refinement          = 5
 end
 
-# The parameters below this comment were created by the update script
-# as replacement for the old 'Model settings' subsection. They can be
-# safely merged with any existing subsections with the same name.
-
-
 subsection Boundary velocity model
   set Tangential velocity boundary indicators = 1
   set Zero velocity boundary indicators       = 0, 2, 3
diff --git a/tests/prmbackslash.prm.bak b/tests/prmbackslash.prm.bak
new file mode 100644
index 00000000000..63063c53811
--- /dev/null
+++ b/tests/prmbackslash.prm.bak
@@ -0,0 +1,72 @@
+# a test that tests #
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = \
+1e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Maximum time step                      = 42
+
+# \ test
+# bla
+
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+# The parameters below this comment were created by the update script
+# as replacement for the old 'Model settings' subsection. They can be
+# safely merged with any existing subsections with the same name.
+
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+  set End step                  = 5
+end
diff --git a/tests/prmbackslash_2.cc.bak b/tests/prmbackslash_2.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/prmbackslash_2.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/prmbackslash_2.prm b/tests/prmbackslash_2.prm
index 7a211a97e07..8495edefa4e 100644
--- a/tests/prmbackslash_2.prm
+++ b/tests/prmbackslash_2.prm
@@ -1,156 +1,96 @@
-# Based on the sol_c\
-x_2.prm test input, split\
- every input file after 20
-# characters with a \
-backslash. In some cases,\
- split it more than once.
-# The output should \
-still be the same.
+# Based on the sol_cx_2.prm test input, split every input file after 20
+# characters with a backslash. In some cases, split it more than once.
+# The output should still be the same.
 
 
 set Dimension = 2
-
-set CFL number      \
-                       = \
+set CFL number                        = \
 1.0
-set End time        \
-                       = \
+set End time                        = \
 0
-
-
-set Resume computati\
-on                     = \
+set Resume computation                     = \
 false
-set Start time      \
-                       = \
+set Start time                        = \
 0
-set Adiabatic surfac\
-e temperature          = \
+set Adiabatic surface temperature          = \
 0
-set Surface pressure\
-                       = \
+set Surface pressure                        = \
 0
-set Use years in out\
-put instead of seconds = \
+set Use years in output instead of seconds = \
 false
-set Nonlinear solver \
- scheme                = \
+set Nonlinear solver scheme                = \
 no Advection, iterated Stokes
 
-subsection Boundary \
-temperature model
+subsection Boundary temperature model
   set Model name = b\
 ox
+  set Fixed temperature boundary indicators  = 0, 1
 end
 
+subsection Discretization
+  set Stokes velocity polynomial degree  = 2
+  set Temperature polynomial degree  = 2
+  set Use locally conservative discretization  = false
 
-subsection Discretiz\
-ation
-  set Stokes velocit\
-y polynomial degree      \
- = 2
-  set Temperature po\
-lynomial degree          \
- = 2
-  set Use locally co\
-nservative discretization\
- = false
-  subsection Stabili\
-zation parameters
+  subsection Stabilization parameters
     set alpha = 2
     set beta  = 0.07\
 8
     set cR    = 0.5 \
-
   end
-end
-
+  end
 
-subsection Geometry \
-model
-  set Model name = b\
+  subsection Geometry model
+    set Model name = b\
 ox
 
-  subsection Box
-    set X extent = 1\
-
+    subsection Box
+      set X extent = 1\
     set Y extent = 1\
-
     set Z extent = 1\
-
   end
-end
-
+    end
 
-subsection Gravity m\
-odel
-  set Model name = v\
+    subsection Gravity model
+      set Model name = v\
 ertical
-end
+    end
 
-
-subsection Initial t\
-emperature model
-  set Model name = p\
+    subsection Initial temperature model
+      set Model name = p\
 erturbed box
-end
+    end
 
-
-subsection Material \
-model
-  set Model name = S\
+    subsection Material model
+      set Model name = S\
 olCxMaterial
-end
-
-
-subsection Mesh refi\
-nement
-  set Initial adapti\
-ve refinement        = 0 \
-
-  set Initial global \
- refinement          = 2 \
+    end
 
-
-  set Strategy      \
-                     = de\
+    subsection Mesh refinement
+      set Initial adaptive refinement        = 0 \
+  set Initial global refinement          = 2 \
+  set Strategy                      = de\
 nsity, temperature
-end
-
+    end
 
-subsection Boundary temp\
-erature model
-  set Fixed temperat\
-ure boundary indicators  \
- = 0, 1
-end
-subsection Boundary velo\
-city model
-  set Tangential vel\
-ocity boundary indicators\
- = 0,1,2,3
-end
+    subsection Boundary velocity model
+      set Tangential velocity boundary indicators  = 0,1,2,3
+    end
 
+    subsection Postprocess
+      set List of postprocessors = SolCxPostprocessor
 
-subsection Postproce\
-ss
-  set List of postpr\
-ocessors = SolCxPostprocessor
-  subsection Depth a\
-verage
-    set Time between \
- graphical output = 1e8
-  end
+      subsection Depth average
+        set Time between graphical output = 1e8
+      end
 
-  subsection Visuali\
-zation
-    set Number of gr\
-ouped files       = 0
-    set Output forma\
-t                 = gnupl\
+      subsection Visualization
+        set Number of grouped files       = 0
+        set Output format                 = gnupl\
 ot
-    set Time between \
- graphical output = 0   #\
+        set Time between graphical output = 0   #\
  default: 1e8
+      end
+    end
   end
 end
diff --git a/tests/prmbackslash_2.prm.bak b/tests/prmbackslash_2.prm.bak
new file mode 100644
index 00000000000..7a211a97e07
--- /dev/null
+++ b/tests/prmbackslash_2.prm.bak
@@ -0,0 +1,156 @@
+# Based on the sol_c\
+x_2.prm test input, split\
+ every input file after 20
+# characters with a \
+backslash. In some cases,\
+ split it more than once.
+# The output should \
+still be the same.
+
+
+set Dimension = 2
+
+set CFL number      \
+                       = \
+1.0
+set End time        \
+                       = \
+0
+
+
+set Resume computati\
+on                     = \
+false
+set Start time      \
+                       = \
+0
+set Adiabatic surfac\
+e temperature          = \
+0
+set Surface pressure\
+                       = \
+0
+set Use years in out\
+put instead of seconds = \
+false
+set Nonlinear solver \
+ scheme                = \
+no Advection, iterated Stokes
+
+subsection Boundary \
+temperature model
+  set Model name = b\
+ox
+end
+
+
+subsection Discretiz\
+ation
+  set Stokes velocit\
+y polynomial degree      \
+ = 2
+  set Temperature po\
+lynomial degree          \
+ = 2
+  set Use locally co\
+nservative discretization\
+ = false
+  subsection Stabili\
+zation parameters
+    set alpha = 2
+    set beta  = 0.07\
+8
+    set cR    = 0.5 \
+
+  end
+end
+
+
+subsection Geometry \
+model
+  set Model name = b\
+ox
+
+  subsection Box
+    set X extent = 1\
+
+    set Y extent = 1\
+
+    set Z extent = 1\
+
+  end
+end
+
+
+subsection Gravity m\
+odel
+  set Model name = v\
+ertical
+end
+
+
+subsection Initial t\
+emperature model
+  set Model name = p\
+erturbed box
+end
+
+
+subsection Material \
+model
+  set Model name = S\
+olCxMaterial
+end
+
+
+subsection Mesh refi\
+nement
+  set Initial adapti\
+ve refinement        = 0 \
+
+  set Initial global \
+ refinement          = 2 \
+
+
+  set Strategy      \
+                     = de\
+nsity, temperature
+end
+
+
+subsection Boundary temp\
+erature model
+  set Fixed temperat\
+ure boundary indicators  \
+ = 0, 1
+end
+subsection Boundary velo\
+city model
+  set Tangential vel\
+ocity boundary indicators\
+ = 0,1,2,3
+end
+
+
+subsection Postproce\
+ss
+  set List of postpr\
+ocessors = SolCxPostprocessor
+  subsection Depth a\
+verage
+    set Time between \
+ graphical output = 1e8
+  end
+
+  subsection Visuali\
+zation
+    set Number of gr\
+ouped files       = 0
+    set Output forma\
+t                 = gnupl\
+ot
+    set Time between \
+ graphical output = 0   #\
+ default: 1e8
+  end
+end
diff --git a/tests/projected_density_vertical_pipe.cc.bak b/tests/projected_density_vertical_pipe.cc.bak
new file mode 100644
index 00000000000..6856cf8980d
--- /dev/null
+++ b/tests/projected_density_vertical_pipe.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/projected_density_vertical_pipe.prm b/tests/projected_density_vertical_pipe.prm
index 608164a1ba8..c3ef1d902ac 100644
--- a/tests/projected_density_vertical_pipe.prm
+++ b/tests/projected_density_vertical_pipe.prm
@@ -13,7 +13,7 @@ set Nonlinear solver tolerance  = 1e-5
 subsection Boundary composition model
   set Allow fixed composition on outflow boundaries = true
   set Fixed composition boundary indicators = top, bottom
-  set Model name = box
+  set List of model names = box
 
   # The test is to make sure these values are ignored
   subsection Box
diff --git a/tests/projected_density_vertical_pipe.prm.bak b/tests/projected_density_vertical_pipe.prm.bak
new file mode 100644
index 00000000000..608164a1ba8
--- /dev/null
+++ b/tests/projected_density_vertical_pipe.prm.bak
@@ -0,0 +1,31 @@
+# This is a test for the benchmark described in
+# $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe
+
+include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm
+
+
+# It makes sure that boundary conditions are not applied to the projected density field
+
+# Fewer time steps, higher solver tolerance
+set End time                    = 2.2e6
+set Nonlinear solver tolerance  = 1e-5
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = true
+  set Fixed composition boundary indicators = top, bottom
+  set Model name = box
+
+  # The test is to make sure these values are ignored
+  subsection Box
+    set Bottom composition = 2000
+    set Top composition = 3000
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics, composition statistics
+end
+
+subsection Discretization
+  set Use discontinuous composition discretization = false
+end
diff --git a/tests/pure_shear.cc.bak b/tests/pure_shear.cc.bak
new file mode 100644
index 00000000000..c45fb20207c
--- /dev/null
+++ b/tests/pure_shear.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "simple_shear.cc"
diff --git a/tests/pure_shear.prm.bak b/tests/pure_shear.prm.bak
new file mode 100644
index 00000000000..80d8517d4e6
--- /dev/null
+++ b/tests/pure_shear.prm.bak
@@ -0,0 +1,145 @@
+# This parameter file reproduces an analytical benchmark for the evolution
+# of finite strain in a model of pure shear as described (for a specific
+# application) in McKenzie & Jackson (1983): "The relationship between
+# strain rates, crustal thickening, paleomagnetism, finite strain and
+# fault movements within a deforming zone." They show that the analytical
+# solution for the deformation gradient tensor F in pure shear deformation is:
+#
+# F_xx = e^(u_x,x * t)
+# F_xy = 0
+# F_yx = 0
+# F_yy = e^(-u_x,x * t),
+#
+# where u is the velocity, t is time, and a comma represents a derivative
+# in that particular direction. u_x,x in this example is equivalent to
+# -u_y,y so that also: F_yy = e^(u_y,y * t) which is intuitive.
+# For this benchmark it is important to recognize that the deformation in
+# this model is actually only "pure" pure shear at the origin, since the
+# deformation field around is a mixture of pure shear and a rotational
+# component. Also the value of u_x,x at the origin is not prescribed
+# directly, but is a model output, because we only know velocity profiles
+# for the top and right boundaries. Using the computed velocity field we
+# can calculate u_x,x approximately at the origin to be 1.253, and therefore
+# expect:
+# F_xx (t=1.0) = 3.501
+# F_yy (t=1.0) = 0.2856
+# This parameter file tracks the finite strain in two ways, once by using
+# compositional fields as illustrated in the finite strain cookbook, and
+# once by using a particle particle that sits and remains at the origin.
+# The results should of course be the same.
+#
+# Numerical results for particle tracking show excellent agreement:
+# F_xx (t=1.0) = 3.50088
+# F_yy (t=1.0) = 0.285643
+#
+# Numerical results for compositional fields also show good results.
+# F_xx (t=1.0) = 3.49776
+# F_yy (t=1.0) = 0.286723
+# The compositional field results are slightly less accurate, probably due to
+# numerical diffusion, but were found to converge against the analytical
+# values with increasing resolution.
+
+set Dimension                              = 2
+set End time                               = 0.025
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom
+  set Prescribed velocity boundary indicators = top:function, right:function
+
+  subsection Function
+    set Function expression = 1-y; x-1
+  end
+end
+
+subsection Material model
+  set Model name = finite strain
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0;0.0;0.0;1.0
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, visualization, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = strain rate, shear stress, principal stress
+    set Output format = gnuplot
+    set Time between graphical output = 0.05
+  end
+
+  subsection Particles
+    set Time between data output = 0.05
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain
+  set Particle generator name = ascii file
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/finite_strain/
+      set Data file name = pure_shear_particle.dat
+    end
+  end
+end
diff --git a/tests/q1_q1.cc.bak b/tests/q1_q1.cc.bak
new file mode 100644
index 00000000000..7a614ac255c
--- /dev/null
+++ b/tests/q1_q1.cc.bak
@@ -0,0 +1,474 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Check the Donea-Huerta benchmark using the Q1 x Q1 element
+
+#include <aspect/simulator.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/utilities.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+namespace aspect
+{
+  namespace DoneaHuertaBenchmark
+  {
+    using namespace dealii;
+
+    namespace AnalyticSolutions
+    {
+
+      Tensor<1,2>
+      DoneaHuerta_velocity (const Point<2> &pos,
+                            const double /*beta*/)
+      {
+        const double x = pos[0];
+        const double y = pos[1];
+        const double v_x =  x*x*(1.-x)*(1.-x)*(2.*y-6.*y*y+4.*y*y*y) ;
+        const double v_y = -y*y*(1.-y)*(1.-y)*(2.*x-6.*x*x+4.*x*x*x) ;
+        return Point<2> (v_x,v_y);
+      }
+
+      double
+      DoneaHuerta_pressure (const Point<2> &pos,
+                            const double /*beta*/)
+      {
+        const double x = pos[0];
+        return x*(1.-x)-1./6.;
+      }
+
+
+      template <int dim>
+      class FunctionDoneaHuerta : public Function<dim>
+      {
+        public:
+          FunctionDoneaHuerta (const double beta)
+            :
+            Function<dim>(dim+2),
+            beta_(beta)
+          {}
+
+          virtual void vector_value (const Point<dim>   &pos,
+                                     Vector<double>   &values) const
+          {
+            Assert (dim == 2, ExcNotImplemented());
+            Assert (values.size() >= 4, ExcInternalError());
+
+            const Point<2> p (pos[0], pos[1]);
+
+            const Tensor<1,2> v = AnalyticSolutions::DoneaHuerta_velocity (p, beta_);
+            values[0] = v[0];
+            values[1] = v[1];
+            values[2] = AnalyticSolutions::DoneaHuerta_pressure (p, beta_);
+          }
+
+        private:
+          const double beta_;
+      };
+    }
+
+
+
+    template <int dim>
+    class DoneaHuertaBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        DoneaHuertaBoundary();
+
+        /**
+         * Return the boundary velocity as a function of position.
+         */
+        virtual
+        Tensor<1,dim>
+        boundary_velocity (const types::boundary_id ,
+                           const Point<dim> &position) const;
+
+      private:
+        const double beta;
+    };
+
+
+    /**
+     * @note This benchmark only talks about the flow field, not about a
+     * temperature field. All quantities related to the temperature are
+     * therefore set to zero in the implementation of this class.
+     _r*
+     * @ingroup MaterialModels
+     */
+    template <int dim>
+    class DoneaHuertaMaterial : public MaterialModel::Interface<dim>
+    {
+      public:
+        /**
+         * @name Physical parameters used in the basic equations
+         * @{
+         */
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const
+        {
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              out.viscosities[i] = 1.;
+              out.densities[i] = 1;
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 0;
+              out.thermal_expansion_coefficients[i] = 0;
+              out.thermal_conductivities[i] = 0.0;
+            }
+        }
+        /**
+         * @}
+         */
+
+        /**
+         * @name Qualitative properties one can ask a material model
+         * @{
+         */
+
+        /**
+         * Return whether the model is compressible or not.
+         * Incompressibility does not necessarily imply that the density is
+         * constant; rather, it may still depend on temperature or pressure.
+         * In the current context, compressibility means whether we should
+         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
+         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
+         * (incompressible Stokes).
+         */
+        virtual bool is_compressible () const;
+        /**
+         * @}
+         */
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+
+
+
+        /**
+         * Returns the viscosity value in the inclusion
+         */
+        double get_beta() const;
+
+        /**
+         * viscosity value in the inclusion
+         */
+        double beta;
+    };
+
+
+    template <int dim>
+    bool
+    DoneaHuertaMaterial<dim>::
+    is_compressible () const
+    {
+      return false;
+    }
+
+    template <int dim>
+    void
+    DoneaHuertaMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      //create a global section in the parameter file for parameters
+      //that describe this benchmark. note that we declare them here
+      //in the material model, but other kinds of plugins (e.g., the gravity
+      //model below) may also read these parameters even though they do not
+      //declare them
+      prm.enter_subsection("DoneaHuerta benchmark");
+      {
+        prm.declare_entry("Viscosity parameter", "1",
+                          Patterns::Double (),
+                          "Viscosity parameter beta in the DoneaHuerta benchmark.");
+      }
+      prm.leave_subsection();
+    }
+
+
+    template <int dim>
+    void
+    DoneaHuertaMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("DoneaHuerta benchmark");
+      {
+        beta = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+    }
+
+
+    template <int dim>
+    double
+    DoneaHuertaMaterial<dim>::get_beta() const
+    {
+      return beta;
+    }
+
+    template <int dim>
+    DoneaHuertaBoundary<dim>::DoneaHuertaBoundary ()
+      :
+      beta (0)
+    {}
+
+
+
+    template <>
+    Tensor<1,2>
+    DoneaHuertaBoundary<2>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<2> &p) const
+    {
+      const DoneaHuertaMaterial<2> *
+      material_model
+        = dynamic_cast<const DoneaHuertaMaterial<2> *>(&this->get_material_model());
+      return AnalyticSolutions::DoneaHuerta_velocity (p, material_model->get_beta());
+    }
+
+
+
+    template <>
+    Tensor<1,3>
+    DoneaHuertaBoundary<3>::
+    boundary_velocity (const types::boundary_id ,
+                       const Point<3> &) const
+    {
+      Assert (false, ExcNotImplemented());
+      return Tensor<1,3>();
+    }
+
+
+
+
+    /**
+     *gravity model for the DoneaHuerta benchmark
+    */
+
+    template <int dim>
+    class DoneaHuertaGravity : public aspect::GravityModel::Interface<dim>
+    {
+      public:
+        virtual Tensor<1,dim> gravity_vector (const Point<dim> &pos) const;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+        */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+
+        double beta;
+    };
+
+
+    template <int dim>
+    Tensor<1,dim>
+    DoneaHuertaGravity<dim>::
+    gravity_vector(const Point<dim> &pos) const
+    {
+      const double x=pos[0];
+      const double y=pos[1];
+      Tensor<1,dim> g;
+      g[0]= ( (12.-24.*y)*x*x*x*x + (-24.+48.*y)*x*x*x + (-48.*y+72.*y*y-48.*y*y*y+12.)*x*x
+              + (-2.+24.*y-72.*y*y+48.*y*y*y)*x + 1.-4.*y+12.*y*y-8.*y*y*y );
+
+      g[1]= ( (8.-48.*y+48.*y*y)*x*x*x + (-12.+72.*y-72*y*y)*x*x
+              +  (4.-24.*y+48.*y*y-48.*y*y*y+24.*y*y*y*y)*x - 12.*y*y + 24.*y*y*y -12.*y*y*y*y);
+      return g;
+    }
+
+    template <int dim>
+    void
+    DoneaHuertaGravity<dim>::declare_parameters (ParameterHandler &/*prm*/)
+    {
+      //nothing to declare here. This plugin will however, read parameters
+      //declared by the material model in the "Burstedde benchmark" section
+    }
+
+    template <int dim>
+    void
+    DoneaHuertaGravity<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("DoneaHuerta benchmark");
+      {
+        beta = prm.get_double ("Viscosity parameter");
+      }
+      prm.leave_subsection();
+    }
+
+
+
+
+
+    /**
+      * A postprocessor that evaluates the accuracy of the solution.
+      *
+      * The implementation of error evaluators that correspond to the
+      * benchmarks defined in the paper Duretz et al. reference above.
+      */
+    template <int dim>
+    class DoneaHuertaPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Generate graphical output from the current solution.
+         */
+        virtual
+        std::pair<std::string,std::string>
+        execute (TableHandler &statistics);
+
+      private:
+        /**
+         * Calculate the L2 dynamic topography error.
+         */
+        //double
+        //compute_dynamic_topography_error() const;
+    };
+
+    template <int dim>
+    std::pair<std::string,std::string>
+    DoneaHuertaPostprocessor<dim>::execute (TableHandler &)
+    {
+      std::unique_ptr<Function<dim>> ref_func;
+      {
+        const DoneaHuertaMaterial<dim> *
+        material_model
+          = dynamic_cast<const DoneaHuertaMaterial<dim> *>(&this->get_material_model());
+
+        ref_func.reset (new AnalyticSolutions::FunctionDoneaHuerta<dim>(material_model->get_beta()));
+      }
+
+      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
+
+      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
+      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
+
+      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
+                                          dim+2);
+      ComponentSelectFunction<dim> comp_p(dim, dim+2);
+
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_u,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_p,
+                                         quadrature_formula,
+                                         VectorTools::L1_norm,
+                                         &comp_p);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_ul2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_u);
+      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
+                                         this->get_solution(),
+                                         *ref_func,
+                                         cellwise_errors_pl2,
+                                         quadrature_formula,
+                                         VectorTools::L2_norm,
+                                         &comp_p);
+
+      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
+      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
+      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
+      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
+
+      std::ostringstream os;
+
+      os << std::scientific <<  u_l1
+         << ", " << p_l1
+         << ", " << u_l2
+         << ", " << p_l2;
+
+      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
+    }
+  }
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace DoneaHuertaBenchmark
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(DoneaHuertaMaterial,
+                                   "DoneaHuertaMaterial",
+                                   "A material model that corresponds to the `DoneaHuerta' benchmark. "
+                                   "See the manual for more information.")
+
+    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(DoneaHuertaBoundary,
+                                            "DoneaHuertaBoundary",
+                                            "Implementation of the velocity boundary conditions for the "
+                                            "`DoneaHuerta' benchmark. See the manual for more information about this "
+                                            "benchmark.")
+
+    ASPECT_REGISTER_POSTPROCESSOR(DoneaHuertaPostprocessor,
+                                  "DoneaHuertaPostprocessor",
+                                  "A postprocessor that compares the solution of the `DoneaHuerta' benchmark "
+                                  "with the one computed by ASPECT "
+                                  "and reports the error. See the manual for more information.")
+
+    ASPECT_REGISTER_GRAVITY_MODEL(DoneaHuertaGravity,
+                                  "DoneaHuertaGravity",
+                                  "A gravity model in corresponding to the `DoneaHuerta' benchmark. "
+                                  "See the manual for more information.")
+  }
+}
diff --git a/tests/q1_q1.prm.bak b/tests/q1_q1.prm.bak
new file mode 100644
index 00000000000..ecd37b4bcf9
--- /dev/null
+++ b/tests/q1_q1.prm.bak
@@ -0,0 +1,98 @@
+# Check the Donea-Huerta benchmark using the Q1 x Q1 element
+
+
+############### Global parameters
+# We use a 2d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0  : DoneaHuertaBoundary, \
+                                                1  : DoneaHuertaBoundary, \
+                                                2  : DoneaHuertaBoundary, \
+                                                3  : DoneaHuertaBoundary
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 1
+  set Use equal order interpolation for Stokes = true
+end
+
+subsection Material model
+  set Model name = DoneaHuertaMaterial
+end
+
+subsection Gravity model
+  set Model name = DoneaHuertaGravity
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, DoneaHuertaPostprocessor
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, gravity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+
+    #    set Use direct solver for Stokes system             = true
+  end
+end
diff --git a/tests/q1_q1_6.cc.bak b/tests/q1_q1_6.cc.bak
new file mode 100644
index 00000000000..2c4484f5fb0
--- /dev/null
+++ b/tests/q1_q1_6.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "q1_q1.cc"
diff --git a/tests/q1_q1_6.prm.bak b/tests/q1_q1_6.prm.bak
new file mode 100644
index 00000000000..5ae04385321
--- /dev/null
+++ b/tests/q1_q1_6.prm.bak
@@ -0,0 +1,95 @@
+############### Global parameters
+# We use a 2d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory                       = output
+set Pressure normalization                 = volume
+
+############### Parameters describing the model
+# Because the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+#Boundary conditions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0  : DoneaHuertaBoundary, \
+                                                1  : DoneaHuertaBoundary, \
+                                                2  : DoneaHuertaBoundary, \
+                                                3  : DoneaHuertaBoundary
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 1
+  set Use equal order interpolation for Stokes = true
+end
+
+subsection Material model
+  set Model name = DoneaHuertaMaterial
+end
+
+subsection Gravity model
+  set Model name = DoneaHuertaGravity
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 6
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, DoneaHuertaPostprocessor
+
+  subsection Visualization
+    set List of output variables = density, viscosity, strain rate, gravity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+    set Number of cheap Stokes solver steps = 0
+
+    #    set Use direct solver for Stokes system             = true
+  end
+end
diff --git a/tests/quarter_shell_variable_coordinate_systems_cartesian.prm.bak b/tests/quarter_shell_variable_coordinate_systems_cartesian.prm.bak
new file mode 100644
index 00000000000..7ed50df7d0f
--- /dev/null
+++ b/tests/quarter_shell_variable_coordinate_systems_cartesian.prm.bak
@@ -0,0 +1,86 @@
+# A simple setup for convection in a quarter of a 2d shell with
+# user input allowing for different coordinate systems
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output_quarter_shell_variable_coordinate_systems_cartesian
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = .45
+    set Outer radius  = 1
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4370
+    set Outer temperature = 273
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Coordinate system = cartesian
+    set Function expression = if ((x > 0.6 && x < 0.8 && y > 0.1 && y < 0.5), 8000, 0)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/tests/quarter_shell_variable_coordinate_systems_depth.prm.bak b/tests/quarter_shell_variable_coordinate_systems_depth.prm.bak
new file mode 100644
index 00000000000..56f0167b66b
--- /dev/null
+++ b/tests/quarter_shell_variable_coordinate_systems_depth.prm.bak
@@ -0,0 +1,86 @@
+# A simple setup for convection in a quarter of a 2d shell with
+# user input allowing for different coordinate systems
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output_quarter_shell_variable_coordinate_systems_depth
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = .45
+    set Outer radius  = 1
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4370
+    set Outer temperature = 273
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = d, na
+    set Coordinate system = depth
+    set Function expression = if ((d < 0.65), 8000, 0)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/tests/quarter_shell_variable_coordinate_systems_spherical.prm.bak b/tests/quarter_shell_variable_coordinate_systems_spherical.prm.bak
new file mode 100644
index 00000000000..b1f122e474d
--- /dev/null
+++ b/tests/quarter_shell_variable_coordinate_systems_spherical.prm.bak
@@ -0,0 +1,86 @@
+# A simple setup for convection in a quarter of a 2d shell with
+# user input allowing for different coordinate systems
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output_quarter_shell_variable_coordinate_systems_spherical
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = .45
+    set Outer radius  = 1
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4370
+    set Outer temperature = 273
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = r,phi
+    set Coordinate system = spherical
+    set Function expression = if ((r <0.8 && r >0.5 && phi <  3.14159265/2 && phi > 3.14159265/4), 8000, 0)
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/tests/quick_mpi.cc.bak b/tests/quick_mpi.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/quick_mpi.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/quick_mpi.prm.bak b/tests/quick_mpi.prm.bak
new file mode 100644
index 00000000000..5b0270d17a3
--- /dev/null
+++ b/tests/quick_mpi.prm.bak
@@ -0,0 +1,82 @@
+# derived from non_conservative_with_mpi used for the quick tests (ASPECT_RUN_ALL_TESTS=OFF)
+
+# we do not include statistics with the hope that this makes the test work on
+# a wide range of machines
+
+# Enable if: QUICK_TEST
+# MPI: 2
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/radioactive_decay.prm.bak b/tests/radioactive_decay.prm.bak
new file mode 100644
index 00000000000..c2623965c39
--- /dev/null
+++ b/tests/radioactive_decay.prm.bak
@@ -0,0 +1,87 @@
+# A simple setup for convection in a quarter of a 2d shell. See the
+# manual for more information.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1e6
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = R=6.336e6 ,Rc=300e3
+    set Variable names      = x,y
+    set Function expression = if(R-sqrt(x*x+y*y)<Rc,1,0)
+  end
+end
+
+subsection Heating model
+  set List of model names = radioactive decay
+
+  subsection Radioactive decay
+    set Number of elements    = 2
+    set Heating rates                 = 1e-5,  2e-5
+    set Half decay times              = 5e6,   2.5e6
+    set Initial concentrations mantle = 0.0,   0.1
+    set Initial concentrations crust  = 0.1,   0.0
+    set Crust defined by composition  = true
+    set Crust composition number      = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0
+  set Tangential velocity boundary indicators = 1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = heating statistics
+end
diff --git a/tests/radiogenic_heating.prm.bak b/tests/radiogenic_heating.prm.bak
new file mode 100644
index 00000000000..761ddc384e7
--- /dev/null
+++ b/tests/radiogenic_heating.prm.bak
@@ -0,0 +1,91 @@
+############### Global parameters
+# This is a test for the radiogenic heating.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 1000
+set Use years in output instead of seconds = false
+set Output directory = radiogenic_heating
+
+subsection Heating model
+  set List of model names = constant heating
+
+  subsection Constant heating
+    set Radiogenic heating rate = 1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000000
+    set Y extent = 1000000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = 3
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0, 1
+
+  subsection Function
+    set Function expression = 0;-1
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density                              = 3400
+    set Reference specific heat                        = 1000
+    set Reference temperature                          = 1000
+    set Thermal conductivity                           = 0.0
+    set Thermal expansion coefficient                  = 0.0
+    set Thermal viscosity exponent                     = 0.0
+    set Viscosity                                      = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
diff --git a/tests/random_perturbation_box.prm.bak b/tests/random_perturbation_box.prm.bak
new file mode 100644
index 00000000000..6921b91881c
--- /dev/null
+++ b/tests/random_perturbation_box.prm.bak
@@ -0,0 +1,70 @@
+# This is a test for the random Gaussian perturbation initial
+# temperature model. 10 perturbations are placed within the
+# box.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 20000
+    set Y extent = 15000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+# The perturbation will be added to the temperature given
+# by the function plugin.
+subsection Initial temperature model
+  set List of model names = function, random Gaussian perturbation
+
+  subsection Function
+    set Function expression = 500
+  end
+
+  subsection Random Gaussian perturbation
+    set Number of perturbations = 10
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1
+    set Thermal expansion coefficient                  = 1e-4
+    set Viscosity                                      = 1e20
+    set Reference density                              = 3300
+    set Reference temperature                          = 500
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/tests/random_perturbation_chunk.prm.bak b/tests/random_perturbation_chunk.prm.bak
new file mode 100644
index 00000000000..4bbce2b2d2b
--- /dev/null
+++ b/tests/random_perturbation_chunk.prm.bak
@@ -0,0 +1,72 @@
+# This is a test for the random Gaussian perturbation initial
+# temperature model. 10 perturbations are placed within the
+# chunk.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk inner radius = 3481000
+    set Chunk outer radius = 6371000
+    set Chunk maximum longitude = 45
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+# The perturbation will be added to the temperature given
+# by the function plugin.
+subsection Initial temperature model
+  set List of model names = function, random Gaussian perturbation
+
+  subsection Function
+    set Function expression = 500
+  end
+
+  subsection Random Gaussian perturbation
+    set Number of perturbations = 10
+    set Width = 200000
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1
+    set Thermal expansion coefficient                  = 1e-4
+    set Viscosity                                      = 1e20
+    set Reference density                              = 3300
+    set Reference temperature                          = 500
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/tests/random_perturbation_merged_boxes.prm.bak b/tests/random_perturbation_merged_boxes.prm.bak
new file mode 100644
index 00000000000..477038e777c
--- /dev/null
+++ b/tests/random_perturbation_merged_boxes.prm.bak
@@ -0,0 +1,73 @@
+# This is a test for the random Gaussian perturbation initial
+# temperature model. 10 perturbations are placed within the
+# two merged boxes.
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Geometry model
+  set Model name = box with lithosphere boundary indicators
+
+  subsection Box with lithosphere boundary indicators
+    set X extent = 20000
+    set Y extent = 15000
+    set Z extent = 15000
+    set Box origin X coordinate = 10000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+# The perturbation will be added to the temperature given
+# by the function plugin.
+subsection Initial temperature model
+  set List of model names = function, random Gaussian perturbation
+
+  subsection Function
+    set Function expression = 500
+  end
+
+  subsection Random Gaussian perturbation
+    set Number of perturbations = 10
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1
+    set Thermal expansion coefficient                  = 1e-4
+    set Viscosity                                      = 1e20
+    set Reference density                              = 3300
+    set Reference temperature                          = 500
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/tests/random_perturbation_sphere.prm.bak b/tests/random_perturbation_sphere.prm.bak
new file mode 100644
index 00000000000..0bb1fff06df
--- /dev/null
+++ b/tests/random_perturbation_sphere.prm.bak
@@ -0,0 +1,67 @@
+# This is a test for the random Gaussian perturbation initial
+# temperature model. 10 perturbations are placed within the
+# sphere.
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Geometry model
+  set Model name = sphere
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+# The perturbation will be added to the temperature given
+# by the function plugin.
+subsection Initial temperature model
+  set List of model names = function, random Gaussian perturbation
+
+  subsection Function
+    set Function expression = 500
+  end
+
+  subsection Random Gaussian perturbation
+    set Number of perturbations = 10
+    set Width = 500000
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1
+    set Thermal expansion coefficient                  = 1e-4
+    set Viscosity                                      = 1e20
+    set Reference density                              = 3300
+    set Reference temperature                          = 500
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/tests/random_perturbation_spherical_shell.prm.bak b/tests/random_perturbation_spherical_shell.prm.bak
new file mode 100644
index 00000000000..3313b06449a
--- /dev/null
+++ b/tests/random_perturbation_spherical_shell.prm.bak
@@ -0,0 +1,66 @@
+# This is a test for the random Gaussian perturbation initial
+# temperature model. 10 perturbations are placed within the
+# spherical shell.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = spherical shell
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+# The perturbation will be added to the temperature given
+# by the function plugin.
+subsection Initial temperature model
+  set List of model names = function, random Gaussian perturbation
+
+  subsection Function
+    set Function expression = 500
+  end
+
+  subsection Random Gaussian perturbation
+    set Number of perturbations = 10
+    set Width = 500000
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1
+    set Thermal expansion coefficient                  = 1e-4
+    set Viscosity                                      = 1e20
+    set Reference density                              = 3300
+    set Reference temperature                          = 500
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0.1
+  end
+end
diff --git a/tests/reactive_fluid_transport_no_reaction.prm.bak b/tests/reactive_fluid_transport_no_reaction.prm.bak
new file mode 100644
index 00000000000..0d56ea7c6a9
--- /dev/null
+++ b/tests/reactive_fluid_transport_no_reaction.prm.bak
@@ -0,0 +1,25 @@
+# This model tests the reactive fluid transport material
+# 'no reaction' scenario to ensure that there is no reaction
+# between the fluid and solid phases. The values of
+# porosity (0) and the bound fluid (0.01) are initially
+# spatially uniform. The absence of reactions between
+# the two phases and near zero velocities (free-slip on
+# all sides) produces no change in their values through time.
+
+# As this test is very similar to the reactive_fluid_transport_zero_solubility
+# test, we include the latter parameter file and only change relevant parameters.
+include $ASPECT_SOURCE_DIR/tests/reactive_fluid_transport_zero_solubility.prm
+
+set Output directory                       = reactive_fluid_transport_no_reaction
+
+# As there are no reactions between the fluid and solid,
+# there is no need to use operator splitting.
+set Use operator splitting                     = false
+
+# Use the no reaction scheme in the reactive fluid
+# transport model.
+subsection Material model
+  subsection Reactive Fluid Transport Model
+    set Fluid-solid reaction scheme = no reaction
+  end
+end
diff --git a/tests/reactive_fluid_transport_zero_solubility.prm.bak b/tests/reactive_fluid_transport_zero_solubility.prm.bak
new file mode 100644
index 00000000000..dbcae34b6a2
--- /dev/null
+++ b/tests/reactive_fluid_transport_zero_solubility.prm.bak
@@ -0,0 +1,138 @@
+# This model tests the reactive material model "zero solubility"
+# reaction scenario, where all of the bound fluid in a solid
+# with zero solubility should go into the free fluid phase
+# (tracked by porosity field). The model begins with no free fluid
+# (zero porosity) and 1% bound fluid (0.01). For a fluid reaction
+# time scale of 1e3 years and a time step size of 10e3 years,
+# the reaction should be complete at the end of the first time step
+# giving a porosity of 0.01 and a bound fluid value of 0.
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = reactive_fluid_transport_zero_solubility
+set Max nonlinear iterations               = 1
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+set End time                               = 10e3
+
+# Because the model includes reactions that might be on a faster time scale
+# than the time step of the model (release of bound fluid into free fluid),
+# we use the operator splitting scheme.
+set Use operator splitting                     = true
+
+# Melt transport is turned on to ensure it works
+# with this reaction scheme. If set to false,
+# a separate velocity and pressure would not be
+# calculated for the fluid phase, and the porosity
+# field would be advected with the solid velocity
+# unless a separate advection scheme is specified.
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+# There are two compositional fields, one that tracks the amount of free fluid
+# (the porosity) and one that tracks the amount of bound fluid (bound_fluid).
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, bound_fluid
+end
+
+# Initially, there is no free water (the porosity is zero) and the water content
+# of the material is 1%.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0; 0.01
+  end
+end
+
+# The composition is not fixed on any boundary
+subsection Boundary composition model
+  set Fixed composition boundary indicators =
+  set List of model names = initial composition
+end
+
+# Free slip on all sides
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+# The model is 2x2 km
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2e3
+    set Y extent  = 2e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# The temperature is not important for this model, so we simply
+# set it to 1600 K everywhere (including the boundary).
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1600
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Maximal temperature = 1600
+    set Minimal temperature = 1600
+  end
+end
+
+# The reactive fluid transport model is composited
+# on top of the visco plastic material model.
+subsection Material model
+  set Model name = reactive fluid transport
+
+  subsection Reactive Fluid Transport Model
+    set Base model = visco plastic
+    set Reference fluid density = 2995
+    set Shear to bulk viscosity ratio = 0.1
+    set Reference fluid viscosity = 10
+    set Reference permeability = 2.5e-6
+    set Exponential fluid weakening factor = 0
+    set Fluid reaction time scale for operator splitting = 1e3
+    set Fluid-solid reaction scheme = zero solubility
+  end
+
+  subsection Visco Plastic
+    set Reference temperature                   = 1600
+    set Prefactors for diffusion creep          = 5e-21
+    set Viscous flow law = diffusion
+    set Densities                   = 3000
+    set Viscosity averaging scheme  = harmonic
+    set Minimum viscosity           = 1e19
+    set Maximum viscosity           = 1e19
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 0
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, melt statistics, velocity statistics
+end
diff --git a/tests/refine_vel.prm.bak b/tests/refine_vel.prm.bak
new file mode 100644
index 00000000000..315f32bfd2e
--- /dev/null
+++ b/tests/refine_vel.prm.bak
@@ -0,0 +1,92 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e300
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+  set End step                  = 3
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Additional refinement times              = 0,0
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/refinement_artificial_viscosity_1.prm.bak b/tests/refinement_artificial_viscosity_1.prm.bak
new file mode 100644
index 00000000000..5f4b3aece5a
--- /dev/null
+++ b/tests/refinement_artificial_viscosity_1.prm.bak
@@ -0,0 +1,101 @@
+# Test MeshRefinement::ArtificialViscosity
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0.08
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = Alice, Bob
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,1,2,3
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if(x+y<0.4,1.0,0.1);if((1-x)^2+y^2<0.25,0.0,100.0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy = artificial viscosity
+  set Additional refinement times              = 0.06
+
+  subsection Artificial viscosity
+    set Temperature scaling factor = 1.0
+    set Compositional field scaling factors =
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,temperature statistics,composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = artificial viscosity#, artificial viscosity composition
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/refinement_artificial_viscosity_2.prm.bak b/tests/refinement_artificial_viscosity_2.prm.bak
new file mode 100644
index 00000000000..4116b08fc27
--- /dev/null
+++ b/tests/refinement_artificial_viscosity_2.prm.bak
@@ -0,0 +1,11 @@
+# Test MeshRefinement::ArtificialViscosity
+
+include $ASPECT_SOURCE_DIR/tests/refinement_artificial_viscosity_1.prm
+
+
+subsection Mesh refinement
+  subsection Artificial viscosity
+    set Temperature scaling factor = 0.0
+    set Compositional field scaling factors = 1.0, 0.0
+  end
+end
diff --git a/tests/refinement_artificial_viscosity_3.prm.bak b/tests/refinement_artificial_viscosity_3.prm.bak
new file mode 100644
index 00000000000..188da3cc623
--- /dev/null
+++ b/tests/refinement_artificial_viscosity_3.prm.bak
@@ -0,0 +1,11 @@
+# Test MeshRefinement::ArtificialViscosity
+
+include $ASPECT_SOURCE_DIR/tests/refinement_artificial_viscosity_1.prm
+
+
+subsection Mesh refinement
+  subsection Artificial viscosity
+    set Temperature scaling factor = 0.0
+    set Compositional field scaling factors = 0.0, 1.0
+  end
+end
diff --git a/tests/refinement_boundary.prm.bak b/tests/refinement_boundary.prm.bak
new file mode 100644
index 00000000000..4da199e7cf6
--- /dev/null
+++ b/tests/refinement_boundary.prm.bak
@@ -0,0 +1,71 @@
+# Test that we indeed refine the boundaries when using the
+# 'boundary' mesh refinement criterion
+#
+# As far as output is concerned, all we care about is the number
+# of cells, which is always printed by default.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 3
+  set Initial global refinement          = 2
+  set Strategy                           = boundary
+
+  subsection Boundary
+    set Boundary refinement indicators = top, bottom, left, right
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
diff --git a/tests/refinement_composition_gradient.prm.bak b/tests/refinement_composition_gradient.prm.bak
new file mode 100644
index 00000000000..25ddfdfb106
--- /dev/null
+++ b/tests/refinement_composition_gradient.prm.bak
@@ -0,0 +1,95 @@
+# Test MeshRefinement::CompositionGradient
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Dimension                              = 2
+set End time                               = 0.08
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = Alice, Bob
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,1,2,3
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if(x+y<0.4,1.0,0.1);1.0+exp(-(x-0.5)^2/0.05-(y-0.4)^2/0.05)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.4
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy = composition gradient
+  set Additional refinement times              = 0.02,0.04,0.06
+
+  subsection Composition gradient
+    set Compositional field scaling factors = 0.0, 1.0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,temperature statistics,composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = artificial viscosity
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/refinement_composition_threshold.prm.bak b/tests/refinement_composition_threshold.prm.bak
new file mode 100644
index 00000000000..2e6dedbcaf4
--- /dev/null
+++ b/tests/refinement_composition_threshold.prm.bak
@@ -0,0 +1,18 @@
+# Test MeshRefinement::CompositionThreshold
+
+include $ASPECT_SOURCE_DIR/tests/refinement_composition_gradient.prm
+
+set End time                               = 0.07
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.4
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy = composition threshold
+  set Additional refinement times              = 0.04,0.06
+
+  subsection Composition threshold
+    set Compositional field thresholds = 0.5, 1.5
+  end
+end
diff --git a/tests/refinement_nonadiabatic_temperature.prm.bak b/tests/refinement_nonadiabatic_temperature.prm.bak
new file mode 100644
index 00000000000..871025c9cc5
--- /dev/null
+++ b/tests/refinement_nonadiabatic_temperature.prm.bak
@@ -0,0 +1,27 @@
+# A setup that tests if the nonadiabatic temperature threshold mesh
+# refinement plugin works correctly and that its interaction with the
+# minimum and maximum refinement level plugins makes sense.
+
+include $ASPECT_SOURCE_DIR/cookbooks/convection-box/convection-box.prm
+
+set End time                               = 0.02
+set Adiabatic surface temperature          = 0.5
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 2
+  set Time steps between mesh refinement       = 1
+  set Strategy = nonadiabatic temperature threshold, minimum refinement function, maximum refinement function
+
+  subsection Minimum refinement function
+    set Function expression = if(x > 0.5, 3, 4)
+  end
+
+  subsection Maximum refinement function
+    set Function expression = if(x > 0.5, 4, 5)
+  end
+
+  subsection Nonadiabatic temperature threshold
+    set Threshold = 0.25
+  end
+end
diff --git a/tests/refinement_strainrate.prm.bak b/tests/refinement_strainrate.prm.bak
new file mode 100644
index 00000000000..efab27c5a44
--- /dev/null
+++ b/tests/refinement_strainrate.prm.bak
@@ -0,0 +1,121 @@
+# check strain rate based refinement
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+# The setup is a 3d box with edge length 2890000 in which
+# all 6 sides have free slip boundary conditions. Because
+# the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2890000
+    set Y extent  = 2890000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Viscosity                     = 1e22
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# This, however, is the more important part: We need to describe
+# the compositional field and its influence on the density
+# function. The following blocks say that we want to
+# advect a single compositional field and that we give it an
+# initial value that is zero outside a sphere of radius
+# r=200000m and centered at the point (p,p,p) with
+# p=1445000 (which is half the diameter of the box) and one inside.
+# The last block re-opens the material model and sets the
+# density differential per unit change in compositional field to
+# 100.
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = r=250000,p=1445000
+    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)) > r, 0, 1)
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.2
+  set Coarsening fraction                = 0.
+  set Strategy                           = strain rate
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density, viscosity, strain rate
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/refinement_switch.prm.bak b/tests/refinement_switch.prm.bak
new file mode 100644
index 00000000000..628a342240e
--- /dev/null
+++ b/tests/refinement_switch.prm.bak
@@ -0,0 +1,111 @@
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.5
+set Output directory                       = refinement_switch
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 2
+  set Time steps between mesh refinement       = 1000
+  set Refinement fraction = 0.25
+  set Coarsening fraction = 0
+  set Adapt by fraction of cells = true
+  set Strategy = temperature
+  set Run postprocessors on initial refinement = true
+end
+
+subsection Compositional fields
+  set List of normalized fields = 0
+  set Names of fields           = heat
+  set Number of fields          = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if (y > 0.5, 1, 0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables      = error indicator
+  end
+end
+
+subsection Termination criteria
+  set End step                  = 1
+  set Termination criteria      = end step
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/refinement_topography.cc.bak b/tests/refinement_topography.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/refinement_topography.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/refinement_topography.prm.bak b/tests/refinement_topography.prm.bak
new file mode 100644
index 00000000000..048fc546127
--- /dev/null
+++ b/tests/refinement_topography.prm.bak
@@ -0,0 +1,68 @@
+# Test that we indeed refine towards the surface when using the
+# 'topography' mesh refinement criterion
+#
+# As far as output is concerned, all we care about is the number
+# of cells, which is always printed by default.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 2
+  set Strategy                           = topography
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
diff --git a/tests/remove_angular_momentum.prm.bak b/tests/remove_angular_momentum.prm.bak
new file mode 100644
index 00000000000..403902ded41
--- /dev/null
+++ b/tests/remove_angular_momentum.prm.bak
@@ -0,0 +1,63 @@
+# Test for removing the angular momentum in 2D spherical
+# shells.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 5.e6 #by this time net rotation will start to be evident
+set Output directory                       = output
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e20
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 100
+    set Outer temperature = 0
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace = angular momentum
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, rotation statistics
+end
diff --git a/tests/remove_angular_momentum_3d.prm.bak b/tests/remove_angular_momentum_3d.prm.bak
new file mode 100644
index 00000000000..7494245f661
--- /dev/null
+++ b/tests/remove_angular_momentum_3d.prm.bak
@@ -0,0 +1,66 @@
+# This test is based on rotation_statistics_3D_asymmetric, with the modification
+# that we solve for the velocity solution and remove the angular momentum.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set End time                               = 1
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Nullspace removal
+  set Remove nullspace = angular momentum
+end
+
+subsection Geometry model
+  set Model name = sphere
+
+  subsection Sphere
+    set Radius = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if (x>0, if (y>0, 1.0, 2.0), if (y<0, 1.0, 2.0))
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 2
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0.5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, rotation statistics
+
+  subsection Rotation statistics
+    set Output full moment of inertia tensor = true
+  end
+end
diff --git a/tests/remove_net_rotation.prm.bak b/tests/remove_net_rotation.prm.bak
new file mode 100644
index 00000000000..344b39430eb
--- /dev/null
+++ b/tests/remove_net_rotation.prm.bak
@@ -0,0 +1,67 @@
+# Test for removing the net rotation in 2D spherical
+# shells.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 5.e6 #by this time net rotation will start to be evident
+set Output directory                       = output
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e20
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 100
+    set Outer temperature = 0
+  end
+end
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, rotation statistics
+
+  subsection Rotation statistics
+    set Use constant density of one = true
+  end
+end
diff --git a/tests/remove_net_rotation_3d.prm.bak b/tests/remove_net_rotation_3d.prm.bak
new file mode 100644
index 00000000000..b70a64ec4d7
--- /dev/null
+++ b/tests/remove_net_rotation_3d.prm.bak
@@ -0,0 +1,67 @@
+# This test is based on rotation_statistics_3D_asymmetric, with the modification
+# that we solve for the velocity solution and remove the net rotation.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set End time                               = 1
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Nullspace removal
+  set Remove nullspace = net rotation
+end
+
+subsection Geometry model
+  set Model name = sphere
+
+  subsection Sphere
+    set Radius = 1
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if (x>0, if (y>0, 1.0, 2.0), if (y<0, 1.0, 2.0))
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 2
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0.5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, rotation statistics
+
+  subsection Rotation statistics
+    set Use constant density of one = true
+    set Output full moment of inertia tensor = true
+  end
+end
diff --git a/tests/remove_net_surface_rotation.prm.bak b/tests/remove_net_surface_rotation.prm.bak
new file mode 100644
index 00000000000..d5ab550d1b9
--- /dev/null
+++ b/tests/remove_net_surface_rotation.prm.bak
@@ -0,0 +1,15 @@
+# Test for removing the net surface rotation in 2D spherical
+# shells. Setup is identical to the 'remove_net_rotation' test,
+# except we remove net surface rotation instead of volume rotation.
+# The 'rotation statistics' postprocessor will show negligible
+# surface angular velocity, and higher overall angular velocity
+# than for 'remove_net_rotation'.
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/remove_net_rotation.prm
+
+
+subsection Nullspace removal
+  set Remove nullspace = net surface rotation
+end
diff --git a/tests/replace_lithosphere_viscosity_file.prm.bak b/tests/replace_lithosphere_viscosity_file.prm.bak
new file mode 100644
index 00000000000..cf7aaba0864
--- /dev/null
+++ b/tests/replace_lithosphere_viscosity_file.prm.bak
@@ -0,0 +1,65 @@
+# Test replace lithosphere viscosity material model
+# using base model ''simple'' and lithosphere-asthenosphere
+# boundary taken from file
+
+
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 1e05
+
+subsection Material model
+  set Model name = replace lithosphere viscosity
+
+  subsection Replace lithosphere viscosity
+    set Base model = simple
+    set Lithosphere viscosity = 1e25
+    set Depth specification method = File
+  end
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = depth
+    set Function constants = temp=2500
+    set Function expression = temp
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics
+end
diff --git a/tests/resume_free_surface.cc.bak b/tests/resume_free_surface.cc.bak
new file mode 100644
index 00000000000..4ae77524790
--- /dev/null
+++ b/tests/resume_free_surface.cc.bak
@@ -0,0 +1,95 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+
+/*
+ * Launch the following function when this plugin is created. Launch ASPECT
+ * twice to test checkpoint/resume and then abort the outer ASPECT run.
+ */
+int f()
+{
+  std::cout << "* starting from beginning:" << std::endl;
+
+  // call ASPECT with "--" and pipe an existing input file into it.
+  int ret;
+
+  ret = system ("cd output-resume_free_surface ; "
+                "(cat " ASPECT_SOURCE_DIR "/tests/resume_free_surface.prm "
+                " ; "
+                " echo 'set Output directory = output1.tmp' "
+                " ; "
+                " rm -rf output1.tmp ; mkdir output1.tmp "
+                ") "
+                "| ../../aspect -- >/dev/null ");
+
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  ret = system ("cd output-resume_free_surface ; "
+                " rm -rf output2.tmp ; cp -r output1.tmp output2.tmp ;"
+                " rm -f output1.tmp/log.txt; "
+                " cp output1.tmp/restart.mesh.old output1.tmp/restart.mesh;"
+                " cp output1.tmp/restart.mesh.info.old output1.tmp/restart.mesh.info;"
+                " cp output1.tmp/restart.resume.z.old output1.tmp/restart.resume.z;");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+
+  std::cout << "* now resuming:" << std::endl;
+  ret = system ("cd output-resume_free_surface ; "
+                "(cat " ASPECT_SOURCE_DIR "/tests/resume_free_surface.prm "
+                " ; "
+                " echo 'set Output directory = output1.tmp' "
+                " ; "
+                " echo 'set Resume computation = true' "
+                ") "
+                "| ../../aspect -- >/dev/null");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  std::cout << "* now comparing:" << std::endl;
+
+  ret = system ("cd output-resume_free_surface ; "
+                " cp output1.tmp/solution/solution-00004.0000.gnuplot solution/solution-00004.0000.gnuplot1 ;"
+                " cp output2.tmp/solution/solution-00004.0000.gnuplot solution/solution-00004.0000.gnuplot2 ;"
+                " cp output1.tmp/log.txt log.txt1 ;"
+                " cp output2.tmp/log.txt log.txt2 ;"
+                " cp output1.tmp/statistics statistics1 ;"
+                " cp output2.tmp/statistics statistics2");
+
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  ret = system ("cd output-resume_free_surface ; "
+                "diff -c output?.tmp/restart.resume.z ; "
+                "diff -c output?.tmp/restart.mesh ; "
+                "");
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // abort current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/resume_free_surface.prm.bak b/tests/resume_free_surface.prm.bak
new file mode 100644
index 00000000000..35699f9222e
--- /dev/null
+++ b/tests/resume_free_surface.prm.bak
@@ -0,0 +1,130 @@
+#Test for resuming simulations with a free surface
+set Dimension = 2
+set CFL number                             = 0.5
+set End time                               = 1e9
+
+#set Output directory                       = output
+#set Resume computation                     = true
+set Start time                             = 0
+set Pressure normalization                 = no
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:200,3:200
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 2
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function expression = (500e3-x)/500e3*100
+      set Maximum topography value = 100
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-160.e3)^2 ) < 25.e3, 0.0, 200.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e19
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 1.0
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 4
+  set Checkpoint on termination = false
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, basic statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format = gnuplot
+    set Time between graphical output = 0.
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+  end
+end
diff --git a/tests/rheology_scaled_profile.cc.bak b/tests/rheology_scaled_profile.cc.bak
new file mode 100644
index 00000000000..3795ec41aad
--- /dev/null
+++ b/tests/rheology_scaled_profile.cc.bak
@@ -0,0 +1,296 @@
+/*
+  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+
+#include <aspect/geometry_model/interface.h>
+#include <aspect/material_model/rheology/ascii_depth_profile.h>
+#include <aspect/lateral_averaging.h>
+
+namespace aspect
+{
+  using namespace dealii;
+
+  namespace MaterialModel
+  {
+    /**
+     * Additional output fields for the viscosity prior to scaling to be added to
+     * the MaterialModel::MaterialModelOutputs structure and filled in the
+     * MaterialModel::Interface::evaluate() function.
+     */
+    template <int dim>
+    class UnscaledViscosityAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
+    {
+      public:
+        UnscaledViscosityAdditionalOutputs(const unsigned int n_points)
+          : NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1, "unscaled_viscosity"),
+                                                n_points)
+        {}
+    };
+  }
+
+  namespace internal
+  {
+    template <int dim>
+    class FunctorDepthAverageUnscaledViscosity: public internal::FunctorBase<dim>
+    {
+      public:
+        FunctorDepthAverageUnscaledViscosity()
+        {}
+
+        bool need_material_properties() const override
+        {
+          return true;
+        }
+
+        void
+        create_additional_material_model_outputs (const unsigned int n_points,
+                                                  MaterialModel::MaterialModelOutputs<dim> &outputs) const override
+        {
+          if (outputs.template get_additional_output<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>() == nullptr)
+            {
+              outputs.additional_outputs.push_back(
+                std::make_unique<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>> (n_points));
+            }
+        }
+
+        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
+                        const MaterialModel::MaterialModelOutputs<dim> &out,
+                        const FEValues<dim> &,
+                        const LinearAlgebra::BlockVector &,
+                        std::vector<double> &output) override
+        {
+          const MaterialModel::UnscaledViscosityAdditionalOutputs<dim> *unscaled_viscosity_outputs
+            = out.template get_additional_output<const MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>();
+
+          Assert(unscaled_viscosity_outputs != nullptr,ExcInternalError());
+
+          for (unsigned int q=0; q<output.size(); ++q)
+            output[q] = unscaled_viscosity_outputs->output_values[0][q];
+        }
+    };
+  }
+
+  namespace MaterialModel
+  {
+    /**
+     * A material model that tests the variable depth averaging routines. The material properties are
+     * constant, except that the viscosity is set to a reference viscosity profile by first computing
+     * an unscaled (constant) viscosity profile, which is then scaled by the quotient between reference
+     * profile and unscaled viscosity.
+     */
+    template <int dim>
+    class ScaledViscosityProfileMaterial : public MaterialModel::Interface<dim>, public aspect::SimulatorAccess<dim>
+    {
+      public:
+        void initialize() override
+        {
+          reference_viscosity_coordinates = reference_viscosity_profile->get_interpolation_point_coordinates();
+        }
+
+        void update() override
+        {
+          std::vector<std::unique_ptr<internal::FunctorBase<dim>>> lateral_averaging_properties;
+          lateral_averaging_properties.push_back(std::make_unique<internal::FunctorDepthAverageUnscaledViscosity<dim>>());
+
+          std::vector<std::vector<double>> averages =
+            this->get_lateral_averaging().compute_lateral_averages(reference_viscosity_coordinates,
+                                                                   lateral_averaging_properties);
+
+          laterally_averaged_viscosity_profile.swap(averages[0]);
+
+          for (unsigned int i = 0; i < laterally_averaged_viscosity_profile.size(); ++i)
+            AssertThrow(numbers::is_finite(laterally_averaged_viscosity_profile[i]),
+                        ExcMessage("In computing depth averages, there is at"
+                                   " least one depth band that does not have"
+                                   " any quadrature points in it."
+                                   " Consider reducing number of depth layers"
+                                   " for averaging."));
+        }
+
+
+
+        double
+        compute_viscosity_scaling (const double depth) const
+        {
+          // Make maximal depth slightly larger to ensure depth < maximal_depth
+          const double maximal_depth = this->get_geometry_model().maximal_depth() *
+                                       (1.0+std::numeric_limits<double>::epsilon());
+          Assert(depth < maximal_depth, ExcInternalError());
+
+          unsigned int depth_index;
+          if (depth < reference_viscosity_coordinates.front())
+            {
+              depth_index = 0;
+            }
+          else if (depth > reference_viscosity_coordinates.back())
+            {
+              depth_index = reference_viscosity_coordinates.size() - 1;
+            }
+          else
+            {
+              depth_index = std::distance(reference_viscosity_coordinates.begin(),
+                                          std::lower_bound(reference_viscosity_coordinates.begin(),
+                                                           reference_viscosity_coordinates.end(),
+                                                           depth));
+            }
+          // depth_index calculated above is the first layer boundary larger than depth,
+          // the correct layer index is then one less than this (except for depth == depth_bounds[0],
+          // in which case the depth_bounds index is also the layer_index, namely 0).
+          // For depths > depth_bounds[n-1], where, n is the size of the depth_bounds, we need to use
+          // the depth_bound one less than this, i.e. depth_bounds[n-2] to compute the averages of the
+          // last layer.
+          if (depth_index > 0)
+            depth_index -= 1;
+
+          // When evaluating reference viscosity, evaluate at the next lower depth that is stored
+          // in the reference profile instead of the actual depth. This makes the profile piecewise
+          // constant. This will be specific to the viscosity profile used (and ignore the entry with
+          // the largest depth in the profile).
+          const double reference_viscosity = reference_viscosity_profile->compute_viscosity(reference_viscosity_coordinates.at(depth_index));
+
+          const double average_viscosity = laterally_averaged_viscosity_profile[depth_index];
+
+          return reference_viscosity / average_viscosity;
+        }
+
+
+
+        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                      MaterialModel::MaterialModelOutputs<dim> &out) const override
+        {
+          UnscaledViscosityAdditionalOutputs<dim> *unscaled_viscosity_out =
+            out.template get_additional_output<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>();
+
+          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+            {
+              const double depth = this->get_geometry_model().depth(in.position[i]);
+              const std::array<double, dim> spherical_coordinates =
+                Utilities::Coordinates::cartesian_to_spherical_coordinates(in.position[i]);
+
+              out.densities[i] = 3300.0;
+              out.viscosities[i] = (1 - 2. * spherical_coordinates[1]/numbers::PI) * 1e20 +
+                                   2. * spherical_coordinates[1]/numbers::PI * 1e21;
+
+              // store unscaled viscosity to compute averaged profile use for compute scaling factor
+              if (unscaled_viscosity_out != nullptr)
+                {
+                  unscaled_viscosity_out->output_values[0][i] = out.viscosities[i];
+                }
+
+              if (this->simulator_is_past_initialization() == true && this->get_timestep_number() > 0)
+                out.viscosities[i] *= compute_viscosity_scaling(depth);
+
+              out.compressibilities[i] = 0;
+              out.specific_heat[i] = 1200;
+              out.thermal_expansion_coefficients[i] = 3e-5;
+              out.thermal_conductivities[i] = 4.7;
+            }
+        }
+
+        bool is_compressible() const override
+        {
+          return false;
+        }
+
+        void
+        create_additional_named_outputs (MaterialModelOutputs<dim> &outputs) const override
+        {
+          if (outputs.template get_additional_output<UnscaledViscosityAdditionalOutputs<dim>>() == nullptr)
+            {
+              const unsigned int n_points = outputs.n_evaluation_points();
+              outputs.additional_outputs.push_back(
+                std::make_unique<UnscaledViscosityAdditionalOutputs<dim>> (n_points));
+            }
+        }
+
+        static
+        void
+        declare_parameters(ParameterHandler &prm)
+        {
+          prm.enter_subsection("Material model");
+          {
+            // Depth-dependent parameters from the rheology plugin
+            Rheology::AsciiDepthProfile<dim>::declare_parameters(prm, "Depth dependent model");
+          }
+          prm.leave_subsection();
+        }
+
+        void
+        parse_parameters(ParameterHandler &prm) override
+        {
+          prm.enter_subsection("Material model");
+          {
+            reference_viscosity_profile = std::make_unique<Rheology::AsciiDepthProfile<dim>>();
+            reference_viscosity_profile->initialize_simulator (this->get_simulator());
+            reference_viscosity_profile->parse_parameters(prm, "Depth dependent model");
+            reference_viscosity_profile->initialize();
+          }
+          prm.leave_subsection();
+
+          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
+          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
+        }
+
+      private:
+        /**
+         * A reference depth-profile for viscosity. Can be used for simply
+         * depth-dependent rheologies, or to compare (and potentially scale)
+         * the grain-size dependent viscosity to a reference profile.
+         */
+        std::unique_ptr<Rheology::AsciiDepthProfile<dim>> reference_viscosity_profile;
+
+        /**
+         * Reference viscosity profile coordinates.
+         */
+        std::vector<double> reference_viscosity_coordinates;
+
+        /**
+         * A depth-profile of the laterally averaged viscosity in each layer
+         * in the current model. Can be used to compare (and potentially scale)
+         * the computed viscosity to the reference profile.
+         */
+        std::vector<double> laterally_averaged_viscosity_profile;
+    };
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ScaledViscosityProfileMaterial,
+                                   "scaled viscosity profile",
+                                   "A material model that scales a constant viscosity to a given "
+                                   "reference profile.")
+
+#define INSTANTIATE(dim) \
+  template class UnscaledViscosityAdditionalOutputs<dim>;
+
+    ASPECT_INSTANTIATE(INSTANTIATE)
+
+  }
+}
diff --git a/tests/rheology_scaled_profile.prm.bak b/tests/rheology_scaled_profile.prm.bak
new file mode 100644
index 00000000000..98d00e935e1
--- /dev/null
+++ b/tests/rheology_scaled_profile.prm.bak
@@ -0,0 +1,82 @@
+# 2d quarter shell using a scaled viscosity profile
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1.0e5
+
+subsection Material model
+  set Model name = scaled viscosity profile
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = top, left, right
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average, material statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 0
+    set Number of grouped files       = 0
+    set List of output variables      = material properties, named additional outputs
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 3
+    set Depth boundaries of zones = 0, 1e6, 2e6, 3e6
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/tests/rigid_shear_instantaneous.cc.bak b/tests/rigid_shear_instantaneous.cc.bak
new file mode 100644
index 00000000000..6b7d8b8ffaa
--- /dev/null
+++ b/tests/rigid_shear_instantaneous.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/rigid_shear/plugin/rigid_shear.cc"
diff --git a/tests/rigid_shear_instantaneous.prm.bak b/tests/rigid_shear_instantaneous.prm.bak
new file mode 100644
index 00000000000..06780bfd48c
--- /dev/null
+++ b/tests/rigid_shear_instantaneous.prm.bak
@@ -0,0 +1,5 @@
+# A description of the rigid shear benchmark for which a known solution
+# is available. See the benchmark folder for more information.
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/rigid_shear/instantaneous/rigid_shear.prm
diff --git a/tests/rigid_shear_steady_state.cc.bak b/tests/rigid_shear_steady_state.cc.bak
new file mode 100644
index 00000000000..6b7d8b8ffaa
--- /dev/null
+++ b/tests/rigid_shear_steady_state.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/rigid_shear/plugin/rigid_shear.cc"
diff --git a/tests/rigid_shear_steady_state.prm.bak b/tests/rigid_shear_steady_state.prm.bak
new file mode 100644
index 00000000000..f3d21ce9b92
--- /dev/null
+++ b/tests/rigid_shear_steady_state.prm.bak
@@ -0,0 +1,5 @@
+# A description of the rigid shear benchmark for which a known solution
+# is available. See the benchmark folder for more information.
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/rigid_shear/steady-state/rigid_shear.prm
diff --git a/tests/rigid_shear_transient.cc.bak b/tests/rigid_shear_transient.cc.bak
new file mode 100644
index 00000000000..6b7d8b8ffaa
--- /dev/null
+++ b/tests/rigid_shear_transient.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/rigid_shear/plugin/rigid_shear.cc"
diff --git a/tests/rigid_shear_transient.prm.bak b/tests/rigid_shear_transient.prm.bak
new file mode 100644
index 00000000000..7e79d574cc1
--- /dev/null
+++ b/tests/rigid_shear_transient.prm.bak
@@ -0,0 +1,7 @@
+# A description of the rigid shear benchmark for which a known solution
+# is available. See the benchmark folder for more information.
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/rigid_shear/transient/rigid_shear.prm
+
+set End time = 0.1
diff --git a/tests/rising_melt_blob.cc.bak b/tests/rising_melt_blob.cc.bak
new file mode 100644
index 00000000000..d1ff721b04f
--- /dev/null
+++ b/tests/rising_melt_blob.cc.bak
@@ -0,0 +1,103 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/melt.h>
+#include <aspect/boundary_velocity/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+
+#include <deal.II/dofs/dof_tools.h>
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+#include <deal.II/numerics/error_estimator.h>
+#include <deal.II/numerics/vector_tools.h>
+
+using namespace dealii;
+
+
+namespace aspect
+{
+  template <int dim>
+  class MeltingRate:
+    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual double reference_darcy_coefficient () const
+      {
+        return 1e-8 * std::pow(0.01, 3.0) / 10.0;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              out.reaction_terms[i][c] = 0.0;
+
+            out.viscosities[i] = 5e20;
+            out.densities[i] = 3000.0 * (1 - 2e-5 * (in.temperature[i] - 293.0));
+            out.thermal_expansion_coefficients[i] = 2e-5;
+            out.specific_heat[i] = 1250.0;
+            out.thermal_conductivities[i] = 4.7;
+            out.compressibilities[i] = 0.0;
+          }
+
+        // fill melt outputs if they exist
+        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
+
+        if (melt_out != nullptr)
+          {
+            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
+            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+              {
+                const double porosity = in.composition[i][porosity_idx];
+
+                melt_out->compaction_viscosities[i] = 5e20 * 0.05/std::max(porosity,0.00025);
+                melt_out->fluid_viscosities[i]= 10.0;
+                melt_out->permeabilities[i]= 1e-8 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
+                melt_out->fluid_densities[i]= 2500.0;
+                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
+              }
+          }
+      }
+
+  };
+
+
+}
+
+
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(MeltingRate,
+                                 "melting rate",
+                                 "")
+}
diff --git a/tests/rising_melt_blob.prm.bak b/tests/rising_melt_blob.prm.bak
new file mode 100644
index 00000000000..9d35d29cc69
--- /dev/null
+++ b/tests/rising_melt_blob.prm.bak
@@ -0,0 +1,135 @@
+#########################################################
+# This is a test for the new melt solver. It checks if
+# melt transport works correctly in a model that has both
+# regions with and without melt (so only some of the cells
+# are "melt cells").
+
+# The initial porosity is zero everywhere, except for a
+# Gaussian in the center of the model (the "melt blob").
+# As there is no melting or freezing, the blob should
+# just rise, conserving the total porosity.
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 20000
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 50
+set CFL number                             = 0.2
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+############### Parameters describing the model
+# Let us here choose again a box domain
+# where we fix the temperature at the bottom and top,
+# allow free slip along the boundaries
+# and include melt migration.
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 200000
+    set Y extent = 100000
+    set X repetitions = 2
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1600
+    set Top temperature    = 293
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Melt settings
+  set Include melt transport = true
+end
+
+############### Compositional fields
+# We want to use two compositional fields, the porosity and
+# an additional field, to check if the melting rate functionality
+# has the same effect as the reaction term for the other
+# compositional fields. As the porosity field is advected by
+# a different mechanism, slight differences between the fields
+# are expected.
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+# We then choose a vertical gravity model and describe the
+# initial temperature with a vertical gradient.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 1e6
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
+    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
+  end
+end
+
+subsection Material model
+  set Model name = melting rate
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
+    end
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/rising_melt_blob_freezing.prm.bak b/tests/rising_melt_blob_freezing.prm.bak
new file mode 100644
index 00000000000..e24eff65436
--- /dev/null
+++ b/tests/rising_melt_blob_freezing.prm.bak
@@ -0,0 +1,123 @@
+#########################################################
+# This is a test for the melting rate functionality,
+# in particular the freezing of melt.
+# It uses the melt simple model.
+
+# The initial porosity has the form of a Gaussian function
+# there is a fixed (constant) freezing rate.
+
+# The amplitude of the Gaussian is 0.2, and the melting time
+# scale is chosen in such a way that the fraction of melt
+# should be cut in half every year (visible in the maximum
+# value of the porosity field).
+
+############### Global parameters
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 2
+set Use years in output instead of seconds = true
+set Adiabatic surface temperature          = 1600
+
+# Do not solve for Stokes to speed up test
+# (see rising_melt_blob for the same test that solves Stokes)
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+# number of nonlinear iterations reduced from 50 to 10 to speed up test.
+set Max nonlinear iterations               = 10
+set Maximum time step                      = 1
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use operator splitting                     = true
+
+subsection Prescribed Stokes solution
+  set Model name = function
+end
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Melt extraction depth = 0.0
+    set Freezing rate         = 1.0
+    set Melting time scale for operator splitting = 1.442695041
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
+
+############### Parameters describing the model
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100000
+    set Y extent = 100000
+  end
+end
+
+subsection Melt settings
+  set Include melt transport = true
+
+  # Set to false in order to prescribe Stokes solution
+  set Use discontinuous compaction pressure = false
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 293
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = pi=3.1415926,x0=50000,y0=50000,c=10000
+    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.0 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
+  end
+end
+
+# The final part of this input file describes how many times the
+# mesh is refined and what to do with the solution once computed
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
+    end
+  end
+end
diff --git a/tests/rotation_statistics.prm.bak b/tests/rotation_statistics.prm.bak
new file mode 100644
index 00000000000..4d388250206
--- /dev/null
+++ b/tests/rotation_statistics.prm.bak
@@ -0,0 +1,76 @@
+# This test is based on prescribed_stokes_solution, with the modification
+# that we create a rotating sphere. The velocity is prescribed with a angular velocity
+# of 1, and this is mostly a test that the 'rotation statistics' postprocessor
+# correctly computes this angular velocity w, and the corresponding angular
+# momentum L = I * w. Since the moment of inertia I of a 2D sphere rotating around z is
+#
+# I = 1/2 M R^2 = 1/2 rho V R^2 = 1/2 rho * PI R^2 R^2
+#
+# with rho=1 and R=1: I = 1/2 * PI = 1.570796
+#
+# and with the angular velocity w=1 the angular momentum we expect
+# L = I = 1.570796. The test output is slightly off, but converges with
+# increasing resolution towards this value.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 1
+end
+
+subsection Geometry model
+  set Model name = sphere
+
+  subsection Sphere
+    set Radius = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, rotation statistics
+end
diff --git a/tests/rotation_statistics_3d.prm.bak b/tests/rotation_statistics_3d.prm.bak
new file mode 100644
index 00000000000..ee1bce63953
--- /dev/null
+++ b/tests/rotation_statistics_3d.prm.bak
@@ -0,0 +1,76 @@
+# This test is based on prescribed_stokes_solution, with the modification
+# that we create a rotating sphere. The velocity is prescribed with a angular velocity
+# of 1, and this is mostly a test that the 'rotation statistics' postprocessor
+# correctly computes this angular velocity w, and the corresponding angular
+# momentum L = I * w. Since the moment of inertia I of a 3D sphere is
+#
+# I = 2/5 M R^2 = 2/5 rho V R^2 = 2/5 rho * 4/3 PI R^3 R^2
+#
+# with rho=1 and R=1: I = 2/5 * 4/3 * PI = 1.675516
+#
+# and with the angular velocity w=1 the angular momentum we expect
+# L = I = 1.675516. The test output is slightly off, but converges with
+# increasing resolution towards this value.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 1
+end
+
+subsection Geometry model
+  set Model name = sphere
+
+  subsection Sphere
+    set Radius = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, rotation statistics
+end
diff --git a/tests/rotation_statistics_3d_asymmetric.prm.bak b/tests/rotation_statistics_3d_asymmetric.prm.bak
new file mode 100644
index 00000000000..9cdcb3fdfc5
--- /dev/null
+++ b/tests/rotation_statistics_3d_asymmetric.prm.bak
@@ -0,0 +1,76 @@
+# This test is based on rotation_statistics_3D, with the modification
+# that we create a rotating sphere with an asymmetric density distribution.
+# More precisely the density is 2 if (x>0 && y>0) or (x<0 && y<0), and 1 otherwise.
+# This allows us to compute the xy entry of the moment of inertia tensor I as
+# a sum of a full sphere with density 1 (for which I_xy == 0) and two
+# anomalies in the first and third quadrant of the x-y plane with delta_rho=1:
+#
+# I_xy = -1 * \int_V delta_rho * x * y dV
+#      = -1 * \int_V (r*cos(phi)*sin(theta) * r*sin(phi)*sin(theta)) dV
+#      = -2 * \int_(phi=0)^(pi/2) \int_(theta=0)^(pi) \int_(r=0)^(R)
+#        r^2 sin(phi) cos(phi) sin^2(theta) * r^2 sin(theta) dr dtheta dphi
+#      = -4/15 R^5 = -0.266666
+#
+# This is mostly a test that the 'rotation statistics' postprocessor
+# correctly computes this moment of inertia tensor (including the correct
+# sign).
+
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Geometry model
+  set Model name = sphere
+
+  subsection Sphere
+    set Radius = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if (x>0, if (y>0, 1.0, 2.0), if (y<0, 1.0, 2.0))
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Vertical
+    set Magnitude = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 2
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 0.5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, rotation statistics
+
+  subsection Rotation statistics
+    set Output full moment of inertia tensor = true
+  end
+end
diff --git a/tests/rotation_statistics_3d_surface.prm.bak b/tests/rotation_statistics_3d_surface.prm.bak
new file mode 100644
index 00000000000..9463c5fc6dc
--- /dev/null
+++ b/tests/rotation_statistics_3d_surface.prm.bak
@@ -0,0 +1,20 @@
+# This test is based on 'rotation_statistics_3d', with the modification
+# that the sphere rotates with a radially varying angular velocity of
+# w=r instead of w=1. Since our sphere has a radius of 1 this means the
+# volume net rotation is different from 'rotation_statistics_3d', but
+# the surface net rotation should still be 1, which the postprocessor
+# 'rotation statistics' reports correctly.
+
+set Dimension                              = 3
+
+include $ASPECT_SOURCE_DIR/tests/rotation_statistics_3d.prm
+
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,z,t
+    set Function expression = -y*sqrt(x*x+y*y+z*z); x*sqrt(x*x+y*y+z*z); 0
+  end
+end
diff --git a/tests/sea_level_postprocessor.prm.bak b/tests/sea_level_postprocessor.prm.bak
new file mode 100644
index 00000000000..b07ad6a1198
--- /dev/null
+++ b/tests/sea_level_postprocessor.prm.bak
@@ -0,0 +1,95 @@
+# A simple setup to test the sea level postprocessor.
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set Start time                             = 0
+set End time                               = 0
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Timing output frequency                = 1
+set Pressure normalization                 = no
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3480.e3
+    set Outer radius = 6371.e3
+    set Opening angle = 360
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 0
+  set Initial adaptive refinement        = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = outer: free surface
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner
+end
+
+subsection Nullspace removal
+  set Remove nullspace = angular momentum
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = inner, outer
+  set List of model names = initial temperature
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+subsection Material model
+  set Model name = simpler
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = basic statistics, temperature statistics, velocity statistics, topography, geoid, sea level
+
+  subsection Topography
+    set Output to file = true
+  end
+
+  subsection Geoid
+    set Include surface topography contribution = true
+    set Include CMB topography contribution = false
+    set Output data in geographical coordinates = true
+    set Maximum degree = 3
+  end
+
+  subsection Sea level
+    set Output to file = true
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end time
+end
diff --git a/tests/segregation_heating.cc.bak b/tests/segregation_heating.cc.bak
new file mode 100644
index 00000000000..6628a39f34f
--- /dev/null
+++ b/tests/segregation_heating.cc.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/boundary_fluid_pressure/interface.h>
+#include <aspect/gravity_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/global.h>
+#include <aspect/melt.h>
+
+namespace aspect
+{
+
+  template <int dim>
+  class PressureBdry:
+    public BoundaryFluidPressure::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual
+      void fluid_pressure_gradient (
+        const types::boundary_id /*boundary_indicator*/,
+        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
+        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
+        const std::vector<Tensor<1,dim>> &normal_vectors,
+        std::vector<double> &fluid_pressure_gradient_outputs
+      ) const
+      {
+        const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
+        Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for shear heating with melt."));
+
+        for (unsigned int q=0; q<fluid_pressure_gradient_outputs.size(); ++q)
+          {
+            const double density = material_model_outputs.densities[q];
+            const double melt_density = melt_outputs->fluid_densities[q];
+            const double porosity = material_model_inputs.composition[q][this->introspection().compositional_index_for_name("porosity")];
+
+            const double bulk_density = (porosity * melt_density + (1.0 - porosity) * density);
+            fluid_pressure_gradient_outputs[q] = this->get_gravity_model().gravity_vector(material_model_inputs.position[q]) * bulk_density * normal_vectors[q];
+          }
+      }
+
+  };
+
+}
+
+// explicit instantiations
+namespace aspect
+{
+  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
+                                                "PressureBdry",
+                                                "A fluid pressure boundary condition that prescribes the "
+                                                "gradient of the fluid pressure at the boundaries as "
+                                                "calculated in the analytical solution. ")
+
+}
diff --git a/tests/segregation_heating.prm.bak b/tests/segregation_heating.prm.bak
new file mode 100644
index 00000000000..c6cc3aa80bd
--- /dev/null
+++ b/tests/segregation_heating.prm.bak
@@ -0,0 +1,142 @@
+# This test is used to check if the shear heating
+# of melt, in particular the segregation heating, is
+# calculated correctly.
+# There is no in- or outflux of solid material, but melt
+# is allowed to flow in freely, so that it moves upwards
+# with a constant velocity determined by its buoyancy.
+# Hence there is no shear of the solid material, but there
+# is dissipation due to the segregation of melt:
+# \eta_f porosity^2 / permeability * (u_f - u_s)^2.
+#
+# With the material properties in this benchmark, shear
+# heating of melt should have a value of 0.78125 (for the
+# Total shear heating with melt rate).
+#
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 0.1
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression       = 1600
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5; 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+
+  subsection Function
+    set Function expression = 0;0
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+  set Heat advection by melt = true
+end
+
+subsection Heating model
+  set List of model names = shear heating, shear heating with melt
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = PressureBdry
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Reference solid density    = 2
+    set Reference melt density     = 1
+    set Reference specific heat    = 1
+    set Reference temperature      = 1600
+    set Thermal conductivity       = 0.0
+    set Surface solidus            = 10000.0
+    set Include melting and freezing = false
+    set Reference permeability       = 1
+    set Reference shear viscosity    = 1
+    set Reference bulk viscosity     = 1
+    set Reference melt viscosity     = 1
+    set Thermal viscosity exponent   = 0
+    set Exponential melt weakening factor = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heating statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature, heating
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
diff --git a/tests/shear_bands.cc.bak b/tests/shear_bands.cc.bak
new file mode 100644
index 00000000000..63d03d90ae7
--- /dev/null
+++ b/tests/shear_bands.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/shear_bands/shear_bands.cc"
diff --git a/tests/shear_bands.prm.bak b/tests/shear_bands.prm.bak
new file mode 100644
index 00000000000..69518b45218
--- /dev/null
+++ b/tests/shear_bands.prm.bak
@@ -0,0 +1,128 @@
+# Listing of Parameters
+# ---------------------
+# This is a test for the magmatic shear bands test case,
+# which also checks the strain rate parameter in the entropy
+# viscosity stabilization.
+
+set Additional shared libraries            = ./libshear_bands.so
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 4
+set Nonlinear solver tolerance             = 1e-5
+set Dimension                              = 2
+set End time                               = 3e-8
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.078
+    set gamma = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# we apply simple shear here, so that the top and bottom boundaries
+# move with the same speed u0, but in opposite directions
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+
+  subsection Function
+    set Function constants = u0=5e2,ymid=0.0005
+    set Function expression = u0*(y/ymid-1.0);0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.004
+    set Y extent  = 0.001
+    set X periodic = true
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=64000
+    set Function expression = 0.0
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = shear bands initial condition
+end
+
+subsection Material model
+  set Model name = shear bands material
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, strain rate, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-24
+  set Temperature solver tolerance = 1e-20
+
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/shear_heating.prm.bak b/tests/shear_heating.prm.bak
new file mode 100644
index 00000000000..f2a820b47d9
--- /dev/null
+++ b/tests/shear_heating.prm.bak
@@ -0,0 +1,85 @@
+# A test case for shear heating. The viscosity is constant and a
+# constant shear strain rate is applied by prescribing the velocities
+# at the upper and lower boundaries of the box domain; the sides are
+# periodic. This yields a constant strain rate [[0,1/2],[1/2,0]]
+# with norm |dot eps|=1/sqrt(2), so that together with the viscosity
+# of 1, the shear heating 2 * eta * pow(|dot eps|,2) = 1.
+#
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set X periodic = true
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = heating, viscosity, strain rate
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/shear_heating_compressible.prm.bak b/tests/shear_heating_compressible.prm.bak
new file mode 100644
index 00000000000..1f5a4f217f8
--- /dev/null
+++ b/tests/shear_heating_compressible.prm.bak
@@ -0,0 +1,114 @@
+# This is a test for the correct behavior of
+# the shear heating in the compressible case.
+# The velocity is prescribed using the prescribed
+# Stokes solution plugin so that the strain rate is
+# [0 0.5 0.5 2./3.], which means that we can calculate
+# the solution for the shear heating (2 eta eps:eps),
+# which should be 2.111111.
+
+set CFL number                             = 1
+set End time                               = 0
+set Adiabatic surface temperature          = 0.5
+set Surface pressure                       = 0.0
+set Use years in output instead of seconds = false
+set Pressure normalization                 = surface
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y
+    set Function expression = 0.0;x+y
+  end
+
+  subsection Pressure function
+    set Variable names = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 0.01
+    set Reference temperature = 0.5
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density = 1
+    set Reference specific heat = 1
+    set Thermal expansion coefficient = 0.1
+    set Viscosity = 1
+    set Thermal conductivity = 1e-7
+    set Reference compressibility = 1e-6
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Boundary velocity model
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;0.01
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics,  heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = heating, viscosity, strain rate
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/shear_heating_compressible_melt.prm.bak b/tests/shear_heating_compressible_melt.prm.bak
new file mode 100644
index 00000000000..ee6c2ca8036
--- /dev/null
+++ b/tests/shear_heating_compressible_melt.prm.bak
@@ -0,0 +1,147 @@
+# This is a copy of the shear_heating_compressible
+# test, except that it uses melt transport.
+
+# The test is for the correct behavior of
+# the shear heating in the compressible case.
+# The velocity is prescribed using the prescribed
+# Stokes solution plugin so that the strain rate is
+# [0 0.5 0.5 2./3.], which means that we can calculate
+# the solution for the shear heating (2 eta eps:eps),
+# which should be 2.111111.
+
+set CFL number                             = 1
+set End time                               = 0
+set Adiabatic surface temperature          = 0.5
+set Surface pressure                       = 0.0
+set Use years in output instead of seconds = false
+set Pressure normalization                 = surface
+set Nonlinear solver scheme                = single Advection, no Stokes
+set Use operator splitting                 = true
+
+subsection Melt settings
+  set Use discontinuous compaction pressure = false
+  set Include melt transport                  = true
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y
+    set Function expression = 0.0;x+y
+  end
+
+  subsection Fluid velocity function
+    set Variable names = x,y
+    set Function expression = 0.0;x+y
+  end
+
+  subsection Pressure function
+    set Variable names = x,y
+    set Function expression = 0.0
+  end
+
+  subsection Fluid pressure function
+    set Variable names = x,y
+    set Function expression = 0.0
+  end
+
+  subsection Compaction pressure function
+    set Variable names = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 0.01
+    set Reference temperature = 0.5
+  end
+end
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Reference solid density = 1
+    set Reference melt density        = 1
+    set Reference specific heat = 1
+    set Reference temperature = 0.5
+    set Thermal expansion coefficient = 0.1
+    set Reference shear viscosity = 1
+    set Reference bulk viscosity = 1e5
+    set Thermal conductivity = 1e-7
+    set Solid compressibility = 1e-6
+    set Use full compressibility = true
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Boundary velocity model
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;0.01
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics,  heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = heating, viscosity, strain rate, density
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/shear_heating_limited.prm.bak b/tests/shear_heating_limited.prm.bak
new file mode 100644
index 00000000000..5b4723fcce2
--- /dev/null
+++ b/tests/shear_heating_limited.prm.bak
@@ -0,0 +1,30 @@
+# A test case for shear heating. The viscosity is constant and a
+# constant shear strain rate is applied by prescribing the velocities
+# at the upper and lower boundaries of the box domain; the sides are
+# periodic. This yields a constant strain rate [[0,1/2],[1/2,0]]
+# with norm |dot eps|=1/sqrt(2), so that together with the viscosity
+# of 1, the shear heating 2 * eta * pow(|dot eps|,2) = 1.
+# We then limit the stress that is being used in the shear heating
+# computation to 0.5 Pa (half of the stress in the model), so the
+# resulting shear heating is 0.5 W/kg.
+
+include $ASPECT_SOURCE_DIR/tests/shear_heating.prm
+
+
+subsection Heating model
+  set List of model names = shear heating
+
+  subsection Shear heating
+    set Limit stress contribution to shear heating = true
+    set Cohesion for maximum shear stress = 0.5
+    set Friction angle for maximum shear stress = 0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = heating statistics, visualization
+
+  subsection Visualization
+    set List of output variables = heating, viscosity, strain rate, stress second invariant
+  end
+end
diff --git a/tests/shear_heating_with_melt.prm.bak b/tests/shear_heating_with_melt.prm.bak
new file mode 100644
index 00000000000..73a574f4f64
--- /dev/null
+++ b/tests/shear_heating_with_melt.prm.bak
@@ -0,0 +1,210 @@
+# This is a test for the heating model plugins related to
+# melt migration, in particular shear heating with melt.
+# In this 1D model, material is upwelling with a high temperature
+# from the bottom boundary and melting adiabatically. This
+# leads to dissipation heating due to the relative movement of
+# melt and solid. As these terms scale with 1/porosity, this
+# can lead to instabilities. However, this can be avoided by
+# choosing a resolution that is high enough and choosing the
+# Darcy coefficient variation threshold to be not too small
+# (here, the default value is sufficient).
+
+# The test is based on the model of 1D upwelling melting in a
+# plume with melt-related heating in the Supplementary material
+# of Dannberg & Heister, 2016.
+# To better compare the results with Dannberg & Heister, 2016,
+# the bottom boundary temperature can be changed to 2000 K
+# (this is just not feasible in the test, as it would take too
+# many time time steps until the onset of melting).
+
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+set Dimension                              = 2
+set End time                               = 1e4
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+set Use operator splitting                 = true
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+  set Composition polynomial degree     = 1
+
+  subsection Stabilization parameters
+    set beta  = 0.1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = 2
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 1850
+  end
+
+  subsection Function
+    set Function expression = if(y<150000,2200,293)
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    set Function constants  = u0=1.5
+    set Variable names      = x,z
+    set Function expression = 0;u0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 7200
+    set Y extent  = 300000
+    set Y repetitions = 40
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 5e9
+    set Age bottom boundary layer   = 0.0
+    set Amplitude                   = 0
+    set Radius                      = 0
+
+    subsection Function
+      set Function expression       = 0;0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,a = 1e-6, b = 300000, c = 20000, d=0.0
+    set Function expression = 0;0 #d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c)); d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = melt simple
+
+  subsection Melt simple
+    set Reference solid density = 3400
+    set Reference melt density = 2776
+    set Thermal expansion coefficient = 3.5e-5
+    set Reference permeability = 5e-9
+    set Reference shear viscosity = 5e18
+    set Reference bulk viscosity = 5e19
+    set Exponential melt weakening factor = 10
+    set Thermal viscosity exponent = 5
+    set Thermal bulk viscosity exponent = 5
+    set Reference temperature = 1600
+    set Solid compressibility = 3.2e-12
+    set Melt compressibility = 3.8462e-11
+    set Melt bulk modulus derivative = 1.6
+    set Use full compressibility = false
+    set Thermal conductivity = 4.7
+    set Melt extraction depth = 0.0
+    set Freezing rate = 0
+    set Mass fraction cpx = 0.1
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.00
+  set Refinement fraction                      = 0.999
+  set Initial adaptive refinement              = 1
+  set Initial global refinement                = 0
+  set Strategy                                 = minimum refinement function, composition threshold
+  set Time steps between mesh refinement       = 0
+
+  subsection Composition threshold
+    set Compositional field thresholds = 5e-6,1.0
+  end
+
+  subsection Composition
+    set Compositional field scaling factors = 1,0
+  end
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Function expression = if(y>220000,0,0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+  set Heat advection by melt                  = true
+end
+
+subsection Heating model
+  set List of model names                     = adiabatic heating, latent heat melt, shear heating, adiabatic heating of melt, shear heating with melt
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics,velocity statistics, mass flux statistics, heating statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set List of output variables      = material properties, melt material properties, nonadiabatic temperature, nonadiabatic pressure, melt fraction, heating
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set Time between graphical output = 2500
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
diff --git a/tests/shear_thinning.cc.bak b/tests/shear_thinning.cc.bak
new file mode 100644
index 00000000000..47997051b48
--- /dev/null
+++ b/tests/shear_thinning.cc.bak
@@ -0,0 +1,194 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class ShearThinning : public MaterialModel::Simple<dim>
+    {
+      public:
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+        void
+        parse_parameters (ParameterHandler &prm);
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    ShearThinning<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      Simple<dim>::evaluate(in, out);
+      if (in.requests_property(MaterialProperties::viscosity))
+        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+          out.viscosities[i] = 1./(1+in.strain_rate[i].norm());
+    }
+
+    template <int dim>
+    void
+    ShearThinning<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      Simple<dim>::parse_parameters(prm);
+
+      // Declare dependencies on solution variables that are different from simple
+      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::strain_rate;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(ShearThinning,
+                                   "shear thinning",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but has a viscosity equal to 1/|strain rate|.")
+  }
+}
+
+
+
+#include <aspect/postprocess/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    class ShearThinning : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        virtual
+        std::pair<std::string,std::string>
+        execute (TableHandler &);
+    };
+  }
+}
+
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    template <int dim>
+    std::pair<std::string,std::string>
+    ShearThinning<dim>::execute (TableHandler &)
+    {
+      // create a quadrature formula based on the temperature element alone.
+      // be defensive about determining that what we think is the temperature
+      // element is indeed the temperature element
+      Assert (this->get_fe().n_base_elements() == 3+(this->n_compositional_fields()>0 ? 1 : 0),
+              ExcNotImplemented());
+      const QGauss<dim> quadrature_formula (this->get_fe().base_element(2).degree+1);
+
+      FEValues<dim> fe_values (this->get_mapping(),
+                               this->get_fe(),
+                               quadrature_formula,
+                               update_gradients         | update_values |
+                               update_quadrature_points | update_JxW_values);
+
+      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell = this->get_dof_handler().begin_active(),
+      endc = this->get_dof_handler().end();
+
+      typename MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
+      typename MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, this->n_compositional_fields());
+      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
+
+      // compute the integral of the viscosity. since we're on a unit box,
+      // this also is the average value
+      double viscosity_integral = 0;
+      for (; cell!=endc; ++cell)
+        if (cell->is_locally_owned())
+          {
+            fe_values.reinit (cell);
+            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
+                                                                                         in.temperature);
+            fe_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
+                                                                                      in.pressure);
+            fe_values[this->introspection().extractors.velocities].get_function_symmetric_gradients (this->get_solution(),
+                in.strain_rate);
+            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+              fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
+                  composition_values[c]);
+
+            in.position = fe_values.get_quadrature_points();
+            for (unsigned int i=0; i<fe_values.n_quadrature_points; ++i)
+              {
+                for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
+                  in.composition[i][c] = composition_values[c][i];
+              }
+
+            this->get_material_model().evaluate(in, out);
+
+
+            for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
+              viscosity_integral += out.viscosities[q] * fe_values.JxW(q);
+          }
+
+      std::ostringstream screen_text;
+      screen_text.precision(4);
+      screen_text << Utilities::MPI::sum(viscosity_integral, this->get_mpi_communicator());
+
+      return std::pair<std::string, std::string> ("Average viscosity:",
+                                                  screen_text.str());
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(ShearThinning,
+                                  "shear thinning",
+                                  "A postprocessor that computes some statistics about "
+                                  "the viscosity.")
+  }
+}
diff --git a/tests/shear_thinning.prm.bak b/tests/shear_thinning.prm.bak
new file mode 100644
index 00000000000..b97a2990bb4
--- /dev/null
+++ b/tests/shear_thinning.prm.bak
@@ -0,0 +1,88 @@
+# A testcase that demonstrates shear thinning. It solves the
+# equations on a box with Dirichlet boundary conditions equal to
+# (z,0), which then is also the velocity everywhere. This yields
+# a constant strain rate [[0,1/2],[1/2,0]] with norm |dot eps|=1/sqrt(2).
+#
+# We then have a viscosity that depends on
+# the strain rate as eta=1/(1+|dot eps|). Because the strain rate
+# is constant, so is the viscosity.
+#
+# In this version of the testcase, we only run a single Advection and a single Stokes step,
+# so the viscosity we use for the first velocity step is eta=1.
+# We can only tell that the correct viscosity is computed in a
+# postprocessor, which we implement in the .cc file. The correct
+# value that needs to be computed is viscosity=1/(1+|dot eps|),
+# i.e., viscosity=0.585786
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = shear thinning
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = shear thinning
+end
diff --git a/tests/shearbox_particle_strain_rate.prm b/tests/shearbox_particle_strain_rate.prm
index 725fb4c788a..8e29130e79f 100644
--- a/tests/shearbox_particle_strain_rate.prm
+++ b/tests/shearbox_particle_strain_rate.prm
@@ -110,7 +110,7 @@ subsection Gravity model
 end
 
 subsection Material model
-  set Model name = simple # default:
+  set Model name = simple
 
   subsection Simple model
     set Reference density             = 1
diff --git a/tests/shearbox_particle_strain_rate.prm.bak b/tests/shearbox_particle_strain_rate.prm.bak
new file mode 100644
index 00000000000..725fb4c788a
--- /dev/null
+++ b/tests/shearbox_particle_strain_rate.prm.bak
@@ -0,0 +1,186 @@
+# A description of convection in a 3d box. See the manual for more information.
+set CFL number = 0.1
+set Timing output frequency = 5000
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 3
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is. We
+# also designate an output directory.
+set Use years in output instead of seconds = false
+set End time                               = 0.001 #100. #00.0 #0.0125 #5.0
+set Nonlinear solver scheme = single Advection, no Stokes
+set Output directory  = test_shearbox3d
+
+# Then there are variables that describe how the pressure should
+# be normalized. Here, we choose a zero average pressure
+# at the surface of the domain (for the current geometry, the
+# surface is defined as the top boundary).
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+    set Box origin X coordinate = -0.5
+    set Box origin Y coordinate = -0.5
+    set Box origin Z coordinate = -0.5
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1 ## Annotation: Temperature function
+  end
+end
+
+# Then follows a section that describes the boundary conditions for the
+# temperature. The model we choose is called 'box' and allows to set a constant
+# temperature on each of the four sides of the box geometry. In our case, we
+# choose something that is heated from below and cooled from above.
+# All other parts of the boundary are insulated (i.e., no heat flux through
+# these boundaries; this is also often used to specify symmetry boundaries).
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top, left, right, front, back
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 1
+    set Right temperature  = 1
+    set Top temperature    = 1
+    set Front temperature  = 1
+    set Back temperature   = 1
+  end
+end
+
+subsection Boundary velocity model
+  subsection Function
+    set Variable names = x,y,z,t
+    set Function expression = z;0;0; ## Annotation: set velocity condition
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,z,t
+    set Function expression = z;0;0; ## Annotation: set velocity condition
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple # default:
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+
+  #  set Time steps between mesh refinement       = 5
+  #  set Strategy = strain rate
+
+  #  set Additional refinement times              = 0.003
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, visualization, particles
+
+  subsection Visualization
+    set Time between graphical output = 0.001 #0.024999
+    set List of output variables = strain rate tensor
+  end
+
+  subsection Particles
+    set Time between data output = 0.001 #0.02499999999999
+    set Data output format       = vtu, ascii
+  end
+end
+
+subsection Checkpointing
+  # The number of timesteps between performing checkpoints. If 0 and time
+  # between checkpoint is not specified, checkpointing will not be performed.
+  # Units: None.
+  #set Steps between checkpoint = 50
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
+
+subsection Particles
+  set List of particle properties =  integrated strain invariant, strain rate
+  set Particle generator name = ascii file
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = $ASPECT_SOURCE_DIR/data/particle/generator/ascii/
+      set Data file name = shearbox_particle_strain_rate.dat
+    end
+  end
+end
diff --git a/tests/shell_2d_gmg.prm.bak b/tests/shell_2d_gmg.prm.bak
new file mode 100644
index 00000000000..d29de762b21
--- /dev/null
+++ b/tests/shell_2d_gmg.prm.bak
@@ -0,0 +1,81 @@
+# 2d shell with no flux top boundary to test GMG
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1.0e5
+set Output directory                       = output-shell_2d_gmg
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average only viscosity
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 2
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e5
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/tests/shell_3d_gmg.prm.bak b/tests/shell_3d_gmg.prm.bak
new file mode 100644
index 00000000000..cb123cdc243
--- /dev/null
+++ b/tests/shell_3d_gmg.prm.bak
@@ -0,0 +1,87 @@
+# 3d shell with GMG
+# MPI: 4
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0.0
+set Output directory                       = output-shell_simple_3d
+set Nonlinear solver scheme                = no Advection, single Stokes
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average only viscosity
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = bottom
+  set Tangential velocity boundary indicators = top
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 1973
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.473e3
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 1
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 1
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1.5e6
+    set Output format                 = vtu
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 50
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1e-4
+  end
+end
diff --git a/tests/shell_boundary_composition_spherical_constant.prm.bak b/tests/shell_boundary_composition_spherical_constant.prm.bak
new file mode 100644
index 00000000000..811b6c62f44
--- /dev/null
+++ b/tests/shell_boundary_composition_spherical_constant.prm.bak
@@ -0,0 +1,89 @@
+# 2d shell with 'spherical constant' boundary composition
+# for multiple compositions.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output-shell_boundary_composition_spherical_constant
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average only viscosity
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Boundary composition model
+  set List of model names = spherical constant
+  set Fixed composition boundary indicators = top, bottom
+
+  subsection Spherical constant
+    set Inner composition = 1,2
+    set Outer composition = 2,3
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 2; 2
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+end
diff --git a/tests/shell_quarter_BC.prm.bak b/tests/shell_quarter_BC.prm.bak
new file mode 100644
index 00000000000..241cc75947f
--- /dev/null
+++ b/tests/shell_quarter_BC.prm.bak
@@ -0,0 +1,17 @@
+# This is a copy of shell_quarter_gmg.prm.
+# It tests if boundary conditions are applied correctly at
+# tangential boundaries (in this case, top) when they are not
+# fixed on outflow parts of the boundary.
+
+include $ASPECT_SOURCE_DIR/tests/shell_quarter_gmg.prm
+
+set End time                               = 3e6
+
+subsection Boundary temperature model
+  set Allow fixed temperature on outflow boundaries = false
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       =
+  set Tangential velocity boundary indicators = top, left, right, bottom
+end
diff --git a/tests/shell_quarter_gmg.prm.bak b/tests/shell_quarter_gmg.prm.bak
new file mode 100644
index 00000000000..95ea7bb5243
--- /dev/null
+++ b/tests/shell_quarter_gmg.prm.bak
@@ -0,0 +1,81 @@
+# 2d quarter shell with no flux top boundary to test GMG
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1.0e5
+set Output directory                       = output-shell_2d_gmg
+
+subsection Material model
+  set Model name = simple
+  set Material averaging = harmonic average
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = top, left, right
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 2
+  set Initial adaptive refinement        = 2
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                 = vtu
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e5
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/tests/shell_surface_base_variables.prm b/tests/shell_surface_base_variables.prm
index d47555aad0f..9d65bed9446 100644
--- a/tests/shell_surface_base_variables.prm
+++ b/tests/shell_surface_base_variables.prm
@@ -8,13 +8,9 @@ set End time                               = 1e300
 set Start time                             = 0
 set Adiabatic surface temperature          = 1613.0
 set Surface pressure                       = 0
-set Use years in output instead of seconds = false  # default: true
+set Use years in output instead of seconds = false
 set Nonlinear solver scheme                = single Advection, single Stokes
 
-# The parameters below this comment were created by the update script
-# as replacement for the old 'Model settings' subsection. They can be
-# safely merged with any existing subsections with the same name.
-
 subsection Boundary temperature model
   set List of model names = initial temperature
   set Fixed temperature boundary indicators   = 0, 1
@@ -49,10 +45,10 @@ subsection Material model
   subsection Simple model
     set Reference density             = 3300
     set Reference specific heat       = 1250
-    set Reference temperature         = 1613 # default: 293
-    set Thermal conductivity          = 1e-6 # default: 4.7
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
     set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22    # default: 5e24
+    set Viscosity                     = 1e22
   end
 end
 
diff --git a/tests/shell_surface_base_variables.prm.bak b/tests/shell_surface_base_variables.prm.bak
new file mode 100644
index 00000000000..d47555aad0f
--- /dev/null
+++ b/tests/shell_surface_base_variables.prm.bak
@@ -0,0 +1,96 @@
+# A quarter-shell spherical 2d model to test
+# the output of the base variables velocity, pressure
+# temperature etc on the mesh boundary.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e300
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false  # default: true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+# The parameters below this comment were created by the update script
+# as replacement for the old 'Model settings' subsection. They can be
+# safely merged with any existing subsections with the same name.
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Termination criteria
+  set Termination criteria      = end step
+  set End step                  = 1
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613 # default: 293
+    set Thermal conductivity          = 1e-6 # default: 4.7
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22    # default: 5e24
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Additional refinement times        = 0,0
+  set Strategy = velocity
+  set Time steps between mesh refinement = 2
+  set Refinement fraction                = 0.8
+  set Coarsening fraction                = 0.0
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 2413.0, 1613)
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, spherical velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+    set Output base variables on mesh surface = true
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/shell_with_variable_coordinate_systems.prm.bak b/tests/shell_with_variable_coordinate_systems.prm.bak
new file mode 100644
index 00000000000..5cbd7313921
--- /dev/null
+++ b/tests/shell_with_variable_coordinate_systems.prm.bak
@@ -0,0 +1,92 @@
+# A simple setup for convection in a quarter of a 2d shell with
+# user input allowing for different coordinate systems
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Output directory                       = output
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = .45
+    set Outer radius  = 1
+    set Opening angle = 360
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Prescribed velocity boundary indicators = outer:function
+
+  subsection Function
+    set Variable names = r,phi
+    set Coordinate system = spherical
+    set Function expression = if (phi < 3.14159265, 1e-8*cos(phi), -1e-8*cos(phi)) ; 5e-8*cos(phi)
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner, outer
+  set List of model names = function
+
+  subsection Spherical constant
+    set Inner temperature = 4370
+    set Outer temperature = 273
+  end
+
+  subsection Function
+    set Variable names = r,phi
+    set Coordinate system = spherical
+    set Function expression = if ((r >0.9 && phi <  3.14159265), 0, 386)
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 5
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 1e6
+    set Number of grouped files       = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+  end
+end
diff --git a/tests/signal_fem.cc.bak b/tests/signal_fem.cc.bak
new file mode 100644
index 00000000000..43a2872fb9e
--- /dev/null
+++ b/tests/signal_fem.cc.bak
@@ -0,0 +1,71 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+#include <aspect/simulator/assemblers/interface.h>
+
+#include <deal.II/fe/fe_dgq.h>
+#include <iostream>
+
+using namespace dealii;
+
+namespace aspect
+{
+
+  template <int dim>
+  void my_signal(std::vector<VariableDeclaration<dim>> &variables)
+  {
+    std::cout << "* signals.edit_finite_element_variables:" << std::endl;
+
+    VariableDeclaration<dim> dummy("dummy",
+                                   std::make_shared<FE_DGQ<dim>>(4),
+                                   2,
+                                   1);
+    variables.insert(variables.begin()+3, dummy);
+
+    for (unsigned int i=0; i<variables.size(); ++i)
+      {
+        std::cout << " name=" << variables[i].name
+                  << " fe=" << variables[i].fe->get_name()
+                  << " multiplicity=" << variables[i].multiplicity
+                  << " n_blocks=" << variables[i].n_blocks
+                  << " n_components=" << variables[i].n_components()
+                  << std::endl;
+      }
+
+    std::cout << std::endl;
+  }
+}
+
+
+
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  std::cout << "* Connecting signals" << std::endl;
+  signals.edit_finite_element_variables.connect(&aspect::my_signal<dim>);
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/signal_fem.prm.bak b/tests/signal_fem.prm.bak
new file mode 100644
index 00000000000..b0cc97254a5
--- /dev/null
+++ b/tests/signal_fem.prm.bak
@@ -0,0 +1,91 @@
+# A test that adds an assembler that tests if we can create additional
+# material model outputs
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = A, B
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;0
+    set Variable names      = x,y
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set List of output variables      = viscosity
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/signals.cc.bak b/tests/signals.cc.bak
new file mode 100644
index 00000000000..d9542efa2eb
--- /dev/null
+++ b/tests/signals.cc.bak
@@ -0,0 +1,60 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// make sure we can include deal.II and aspect files
+#include <aspect/simulator_signals.h>
+
+#include <iostream>
+
+using namespace aspect;
+
+
+// create a function that is run upon loading the plugin
+// when declaring parameters, and that produces some output
+void declare_parameters(const unsigned int dim,
+                        ParameterHandler &prm)
+{
+  std::cout << "declaring parameters" << std::endl;
+  prm.declare_entry("abc", "42", Patterns::Integer(21,43));
+}
+
+
+// same for parsing parameters
+template <int dim>
+void parse_parameters(const Parameters<dim> &parameters,
+                      ParameterHandler &prm)
+{
+  std::cout << "parsing parameters: abc="
+            << prm.get("abc") << std::endl;
+  Assert (prm.get_integer ("abc") == 21, ExcInternalError());
+}
+
+
+void parameter_connector ()
+{
+  SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
+  SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
+
+  SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
+  SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
+}
+
+
+ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
diff --git a/tests/signals.prm.bak b/tests/signals.prm.bak
new file mode 100644
index 00000000000..c8d149ed66b
--- /dev/null
+++ b/tests/signals.prm.bak
@@ -0,0 +1,80 @@
+# a test that simply verifies that the plugin described in
+# signals.cc is indeed run and that it can declare and
+# parse parameters
+
+
+# a parameter declared from a slot connected to a signal
+set abc = 21
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/signals_connect.cc.bak b/tests/signals_connect.cc.bak
new file mode 100644
index 00000000000..d30a2127fa5
--- /dev/null
+++ b/tests/signals_connect.cc.bak
@@ -0,0 +1,49 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_signals.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+
+using namespace aspect;
+
+
+template <int dim>
+void post_constraints_creation (const SimulatorAccess<dim> &,
+                                AffineConstraints<double> &)
+{
+  std::cout << std::endl
+            << "*** constraints signal called ***"
+            << std::endl
+            << std::endl;
+}
+
+
+template <int dim>
+void signal_connector (SimulatorSignals<dim> &signals)
+{
+  std::cout << "Connecting signals" << std::endl;
+  signals.post_constraints_creation.connect (&post_constraints_creation<dim>);
+}
+
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/signals_connect.prm.bak b/tests/signals_connect.prm.bak
new file mode 100644
index 00000000000..2a0c7c469f0
--- /dev/null
+++ b/tests/signals_connect.prm.bak
@@ -0,0 +1,78 @@
+# a test that simply verifies that the plugin described in
+# signals_connect.cc is indeed run and that it can declare and
+# parse parameters
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/signals_post_constraints.cc.bak b/tests/signals_post_constraints.cc.bak
new file mode 100644
index 00000000000..f7dea1de7aa
--- /dev/null
+++ b/tests/signals_post_constraints.cc.bak
@@ -0,0 +1,47 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_signals.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+
+using namespace aspect;
+
+
+template <int dim>
+void post_constraints_creation (const SimulatorAccess<dim> &simulator_access,
+                                AffineConstraints<double> &current_constraints)
+{
+  simulator_access.get_statistics_object()
+  .add_value ("number of constraints",
+              current_constraints.n_constraints());
+}
+
+
+template <int dim>
+void signal_connector (SimulatorSignals<dim> &signals)
+{
+  signals.post_constraints_creation.connect (&post_constraints_creation<dim>);
+}
+
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/signals_post_constraints.prm.bak b/tests/signals_post_constraints.prm.bak
new file mode 100644
index 00000000000..1255e5d6f4f
--- /dev/null
+++ b/tests/signals_post_constraints.prm.bak
@@ -0,0 +1,73 @@
+# output some status information for every time step from the
+# post-constraints signal
+#
+# otherwise identical to blankenbach.prm
+
+set End time                               = 0.002 # 1.0 for full benchmark
+set Use years in output instead of seconds = false
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e3
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
+    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-3
+    set Viscosity                     = 1e-4
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/simple_composite.prm.bak b/tests/simple_composite.prm.bak
new file mode 100644
index 00000000000..a3b65c4ffc9
--- /dev/null
+++ b/tests/simple_composite.prm.bak
@@ -0,0 +1,96 @@
+# Duplicate of simple incompressible test using a compositing model to
+# select all material properties from the simple incompressible model.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = compositing
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+
+  subsection Compositing
+    set Viscosity = simple
+    set Density = simple
+    set Thermal expansion coefficient = simple
+    set Specific heat = simple
+    set Thermal conductivity = simple
+    set Compressibility = simple
+    set Entropy derivative pressure = simple
+    set Entropy derivative temperature = simple
+    set Reaction terms = simple
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/simple_compressibility_iterated_stokes.cc.bak b/tests/simple_compressibility_iterated_stokes.cc.bak
new file mode 100644
index 00000000000..aff05b345ec
--- /dev/null
+++ b/tests/simple_compressibility_iterated_stokes.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "compressibility.cc"
diff --git a/tests/simple_compressibility_iterated_stokes.prm.bak b/tests/simple_compressibility_iterated_stokes.prm.bak
new file mode 100644
index 00000000000..88d8fa0f358
--- /dev/null
+++ b/tests/simple_compressibility_iterated_stokes.prm.bak
@@ -0,0 +1,81 @@
+# A variation on the 'compressibility_iterated_stokes' testcase.
+# The only variation is the used material model. This test adapts the
+# 'simple compressible' material model plugin to do the same job as the
+# shared library material model from compressibility_iterated_stokes.cc
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Max nonlinear iterations               = 5
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density             = 0.909090909090
+    set Reference compressibility     = 0.01
+    set Reference specific heat       = 1250
+    set Thermal conductivity          = 1e-6
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1
+  set Prescribed velocity boundary indicators = 2: function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = compressibility
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/simple_compressibility_iterated_stokes_gmg.cc.bak b/tests/simple_compressibility_iterated_stokes_gmg.cc.bak
new file mode 100644
index 00000000000..aff05b345ec
--- /dev/null
+++ b/tests/simple_compressibility_iterated_stokes_gmg.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "compressibility.cc"
diff --git a/tests/simple_compressibility_iterated_stokes_gmg.prm.bak b/tests/simple_compressibility_iterated_stokes_gmg.prm.bak
new file mode 100644
index 00000000000..e4c6cc1614d
--- /dev/null
+++ b/tests/simple_compressibility_iterated_stokes_gmg.prm.bak
@@ -0,0 +1,19 @@
+# like simple_compressibility_iterated_stokes.prm but using GMG
+
+include $ASPECT_SOURCE_DIR/tests/simple_compressibility_iterated_stokes.prm
+
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
diff --git a/tests/simple_compressible.prm.bak b/tests/simple_compressible.prm.bak
new file mode 100644
index 00000000000..44d94da9cd2
--- /dev/null
+++ b/tests/simple_compressible.prm.bak
@@ -0,0 +1,95 @@
+# This is a relatively realistic compressible model setup.
+# There is no simple analytical solution to it, it is rather
+# intended to serve as a comparison for more complicated
+# material models, which should be able to reproduce it.
+# The material model used here is already tested by
+# simple_compressibility_iterated_stokes.
+# Currently there is the steinberger_compressible test
+# reproducing this test.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+    set Reference compressibility = 2.5e-12
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/simple_incompressible.prm.bak b/tests/simple_incompressible.prm.bak
new file mode 100644
index 00000000000..05fd020e33e
--- /dev/null
+++ b/tests/simple_incompressible.prm.bak
@@ -0,0 +1,88 @@
+# This is a relatively realistic incompressible model setup.
+# There is no simple analytical solution to it, it is rather
+# intended to serve as a comparison for more complicated
+# material models, which should be able to reproduce it.
+# Currently there is the steinberger_incompressible test
+# reproducing this test.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/simple_nonlinear.cc.bak b/tests/simple_nonlinear.cc.bak
new file mode 100644
index 00000000000..db839536247
--- /dev/null
+++ b/tests/simple_nonlinear.cc.bak
@@ -0,0 +1,253 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/newton.h>
+
+#include <iostream>
+
+#include <aspect/utilities.h>
+
+#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
+
+template <int dim>
+int f(double parameter)
+{
+
+  std::cout << std::endl << "Test for p = " << parameter << " with dimension " << dim << std::endl;
+
+  using namespace aspect::MaterialModel;
+
+  // first set all material model values
+  MaterialModelInputs<dim> in_base(5,3);
+  in_base.composition[0][0] = 0;
+  in_base.composition[0][1] = 0;
+  in_base.composition[0][2] = 0;
+  in_base.composition[1][0] = 0.75;
+  in_base.composition[1][1] = 0.15;
+  in_base.composition[1][2] = 0.10;
+  in_base.composition[2][0] = 0;
+  in_base.composition[2][1] = 0.2;
+  in_base.composition[2][2] = 0.4;
+  in_base.composition[3][0] = 0;
+  in_base.composition[3][1] = 0.2;
+  in_base.composition[3][2] = 0.4;
+  in_base.composition[4][0] = 1;
+  in_base.composition[4][1] = 0;
+  in_base.composition[4][2] = 0;
+
+  in_base.temperature[0] = 293;
+  in_base.temperature[1] = 1600;
+  in_base.temperature[2] = 2000;
+  in_base.temperature[3] = 2100;
+  in_base.temperature[4] = 2200;
+
+  in_base.pressure[0] = 1e9;
+  in_base.pressure[1] = 5e9;
+  in_base.pressure[2] = 2e10;
+  in_base.pressure[3] = 2e11;
+  in_base.pressure[4] = 2e12;
+
+  /**
+   * We can't take to small strain-rates, because then the difference in the
+   * viscosity will be too small for the double accuracy which stores
+   * the viscosity solutions and the finite difference solution.
+   */
+  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
+  in_base.strain_rate[0][0][0] = 1e-12;
+  in_base.strain_rate[0][0][1] = 1e-12;
+  in_base.strain_rate[0][1][1] = 1e-11;
+  if (dim == 3)
+    {
+      in_base.strain_rate[0][2][0] = 1e-12;
+      in_base.strain_rate[0][2][1] = 1e-12;
+      in_base.strain_rate[0][2][2] = 1e-11;
+    }
+
+  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[1][0][0] = -1.71266e-13;
+  in_base.strain_rate[1][0][1] = -5.82647e-12;
+  in_base.strain_rate[1][1][1] = 4.21668e-14;
+  if (dim == 3)
+    {
+      in_base.strain_rate[1][2][0] = -5.42647e-12;
+      in_base.strain_rate[1][2][1] = -5.22647e-12;
+      in_base.strain_rate[1][2][2] = 4.21668e-14;
+    }
+  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[2][1][1] = 1e-13;
+  in_base.strain_rate[2][0][1] = 1e-11;
+  in_base.strain_rate[2][0][0] = -1e-12;
+  if (dim == 3)
+    {
+      in_base.strain_rate[2][2][0] = 1e-11;
+      in_base.strain_rate[2][2][1] = 1e-11;
+      in_base.strain_rate[2][2][2] = -1e-12;
+    }
+  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[3][1][1] = 4.9e-21;
+  in_base.strain_rate[3][0][1] = 4.9e-21;
+  in_base.strain_rate[3][0][0] = 4.9e-21;
+  if (dim == 3)
+    {
+      in_base.strain_rate[3][2][0] = 4.9e-21;
+      in_base.strain_rate[3][2][1] = 4.9e-21;
+      in_base.strain_rate[3][2][2] = 4.9e-21;
+    }
+  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[4][1][1] = 1e-11;
+  in_base.strain_rate[4][0][1] = 1e-11;
+  in_base.strain_rate[4][0][0] = 1e-11;
+  if (dim == 3)
+    {
+      in_base.strain_rate[4][2][0] = 1e-11;
+      in_base.strain_rate[4][2][1] = 1e-11;
+      in_base.strain_rate[4][2][2] = 1e-11;
+    }
+
+  // initialize some variables we will need later.
+  double finite_difference_accuracy = 1e-7;
+  double finite_difference_factor = 1+finite_difference_accuracy;
+
+
+  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
+
+  MaterialModelOutputs<dim> out_base(5,3);
+  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
+
+  if (out_base.template get_additional_output<MaterialModelDerivatives<dim>>() != nullptr)
+    throw "error";
+
+  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
+
+  // initialize the material we want to test.
+  SimpleNonlinear<dim> mat;
+  ParameterHandler prm;
+  mat.declare_parameters(prm);
+
+  prm.enter_subsection("Compositional fields");
+  {
+    prm.set("Number of fields","3");
+  }
+  prm.leave_subsection();
+  prm.enter_subsection("Material model");
+  {
+    prm.enter_subsection ("Simple nonlinear");
+    {
+      prm.set ("Viscosity prefactor", "1e-37,1e-36,1e-35,5e-36");
+      prm.set ("Viscosity averaging p", std::to_string(parameter));
+      prm.set ("Minimum strain rate", 1.4e-20);
+    }
+    prm.leave_subsection();
+  }
+  prm.leave_subsection();
+
+  mat.parse_parameters(prm);
+
+  mat.evaluate(in_base, out_base);
+
+  // set up additional output for the derivatives
+  MaterialModelDerivatives<dim> *derivatives;
+  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
+  double temp;
+
+  // have a bool so we know whether the test has succeed or not.
+  bool Error = false;
+
+  // this material is not pressure dependent, so we do not test it.
+
+  // test the strain-rate derivative.
+  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
+    {
+      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
+                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
+                                                    * finite_difference_accuracy
+                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
+        }
+
+
+      mat.evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          // prevent division by zero. If it is zero, the test has passed, because or
+          // the finite difference and the analytical result match perfectly, or (more
+          // likely) the material model in independent of this variable.
+          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
+          if (temp != 0)
+            {
+              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
+            }
+          std::cout << "strain-rate: component = " << component << ", point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
+          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
+            {
+              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
+              Error = true;
+            }
+
+        }
+
+    }
+
+  if (Error)
+    {
+      std::cout << "Some parts of the test were not successful." << std::endl;
+    }
+  else
+    {
+      std::cout << "OK" << std::endl;
+    }
+
+  return 42;
+}
+
+int exit_function()
+{
+  exit(0);
+  return 42;
+}
+// run this function by initializing a global variable by it
+// test 2D
+int ii2 = f<2>(-1000); // Testing min function
+int iz2 = f<2>(-2); // Testing generalized p norm mean with negative p
+int ij2 = f<2>(-1.5); // Testing generalized p norm mean with negative, non int p
+int ik2 = f<2>(-1); // Testing harmonic mean
+int ji2 = f<2>(0); // Testing geometric mean
+int jj2 = f<2>(1); // Testing arithmetic mean
+int jk2 = f<2>(2); // Testing generalized p norm mean with positive p
+int kj2 = f<2>(1000); // Testing max function
+// test 3D
+int ii3 = f<3>(-1000); // Testing min function
+int iz3 = f<3>(-2); // Testing generalized p norm mean with negative p
+int ij3 = f<3>(-1.5); // Testing generalized p norm mean with negative, non int p
+int ik3 = f<3>(-1); // Testing harmonic mean
+int ji3 = f<3>(0); // Testing geometric mean
+int jj3 = f<3>(1); // Testing arithmetic mean
+int jk3 = f<3>(2); // Testing generalized p norm mean with positive p
+int kj3 = f<3>(1000); // Testing max function
+// exit
+int kl2 = exit_function();
diff --git a/tests/simple_nonlinear.prm.bak b/tests/simple_nonlinear.prm.bak
new file mode 100644
index 00000000000..df918fdb908
--- /dev/null
+++ b/tests/simple_nonlinear.prm.bak
@@ -0,0 +1,4 @@
+# This test checks whether the derivatives of the simple nonlinear
+# material model are the same as the finite difference derivatives
+# created by the simple nonlinear material model.
+set Additional shared libraries = tests/libsimple_nonlinear.so
diff --git a/tests/simple_shear.cc.bak b/tests/simple_shear.cc.bak
new file mode 100644
index 00000000000..8cb157267d4
--- /dev/null
+++ b/tests/simple_shear.cc.bak
@@ -0,0 +1,124 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class FiniteStrain : public MaterialModel::Simple<dim>
+    {
+      public:
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+        virtual void parse_parameters(ParameterHandler &prm);
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    FiniteStrain<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // First, we use the material descriptions of the 'simple' material model to fill all of the material
+      // model outputs. Below, we will then overwrite selected properties (the reaction terms), which are
+      // needed to track the finite strain.
+      Simple<dim>::evaluate(in, out);
+
+      // We need the velocity gradient for the finite strain (they are not included in material model inputs),
+      // so we get them from the finite element.
+      if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0)
+        {
+          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +1);
+          FEValues<dim> fe_values (this->get_mapping(),
+                                   this->get_fe(),
+                                   quadrature_formula,
+                                   update_gradients);
+
+          std::vector<Tensor<2,dim>> velocity_gradients (quadrature_formula.size(), Tensor<2,dim>());
+
+          fe_values.reinit (in.current_cell);
+          fe_values[this->introspection().extractors.velocities].get_function_gradients (this->get_solution(),
+                                                                                         velocity_gradients);
+
+          // Assign the strain components to the compositional fields reaction terms.
+          // If there are too many fields, we simply fill only the first fields with the
+          // existing strain rate tensor components.
+          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
+            {
+              // Convert the compositional fields into the tensor quantity they represent.
+              const Tensor<2,dim> strain(make_array_view(&in.composition[q][0],
+                                                         &in.composition[q][0] + Tensor<2,dim>::n_independent_components));
+
+              // Compute the strain accumulated in this timestep.
+              const Tensor<2,dim> strain_increment = this->get_timestep() * (velocity_gradients[q] * strain);
+
+              // Output the strain increment component-wise to its respective compositional field's reaction terms.
+              strain_increment.unroll(&out.reaction_terms[q][0],
+                                      &out.reaction_terms[q][0] + Tensor<2,dim>::n_independent_components);
+            }
+        }
+    }
+
+
+    template <int dim>
+    void
+    FiniteStrain<dim>::
+    parse_parameters (ParameterHandler &prm)
+    {
+      Simple<dim>::parse_parameters (prm);
+
+      AssertThrow(this->n_compositional_fields() >= (Tensor<2,dim>::n_independent_components),
+                  ExcMessage("There must be at least as many compositional fields as independent components in the full "
+                             "strain rate tensor."));
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(FiniteStrain,
+                                   "finite strain",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but tracks the finite strain as compositional "
+                                   "fields. The model assumes that the first 4 (in 2D) "
+                                   " or 9 (in 3D) compositional fields contain the finite "
+                                   "strain components. ")
+  }
+}
diff --git a/tests/simple_shear.prm.bak b/tests/simple_shear.prm.bak
new file mode 100644
index 00000000000..0d2d8a40cf9
--- /dev/null
+++ b/tests/simple_shear.prm.bak
@@ -0,0 +1,134 @@
+# This parameter file reproduces an analytical benchmark for the evolution
+# of finite strain in a model of simple shear as described (for a specific
+# application) in McKenzie & Jackson (1983): "The relationship between
+# strain rates, crustal thickening, paleomagnetism, finite strain and
+# fault movements within a deforming zone." They show that the analytical
+# solution for the deformation gradient tensor F in simple shear deformation is:
+#
+# F_xx = 1.0
+# F_xy = u_x,y * t
+# F_yx = 0
+# F_yy = 1.0,
+#
+# where u is the velocity, t is time, and a comma represents a derivative
+# in that particular direction.
+# Because u_x,y = 2.0 / 1.0 is constant in the whole domain (and over time) we expect
+# a constant F at any given time, and in particular:
+# F_xy (t=1.0) = 2.0
+#
+# This parameter file tracks the finite strain in two ways, once by using
+# compositional fields as illustrated in the finite strain cookbook, and
+# once by using a particle particle that sits and remains in the center of the domain.
+# The results should of course be the same.
+#
+# Numerical results for particle tracking and compositional fields
+# show equally excellent agreement:
+# F_xy (t=1.0) = 2.0
+
+set Dimension                              = 2
+set End time                               = 0.025
+set Use years in output instead of seconds = false
+set Output directory = simple_shear
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set X periodic = true
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+
+  subsection Function
+    set Function expression = if (y < 0.5, -1, 1); 0
+  end
+end
+
+subsection Material model
+  set Model name = finite strain
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0;0.0;0.0;1.0
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, composition statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = strain rate, stress, principal stress
+    set Output format = gnuplot
+    set Time between graphical output = 0.05
+  end
+
+  subsection Particles
+    set Time between data output = 0.05
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain
+  set Particle generator name = ascii file
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/finite_strain/
+      set Data file name = simple_shear_particle.dat
+    end
+  end
+end
diff --git a/tests/simple_shear_output_the_mobility.cc.bak b/tests/simple_shear_output_the_mobility.cc.bak
new file mode 100644
index 00000000000..8cb157267d4
--- /dev/null
+++ b/tests/simple_shear_output_the_mobility.cc.bak
@@ -0,0 +1,124 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class FiniteStrain : public MaterialModel::Simple<dim>
+    {
+      public:
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+        virtual void parse_parameters(ParameterHandler &prm);
+    };
+
+  }
+}
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+
+    template <int dim>
+    void
+    FiniteStrain<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      // First, we use the material descriptions of the 'simple' material model to fill all of the material
+      // model outputs. Below, we will then overwrite selected properties (the reaction terms), which are
+      // needed to track the finite strain.
+      Simple<dim>::evaluate(in, out);
+
+      // We need the velocity gradient for the finite strain (they are not included in material model inputs),
+      // so we get them from the finite element.
+      if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0)
+        {
+          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +1);
+          FEValues<dim> fe_values (this->get_mapping(),
+                                   this->get_fe(),
+                                   quadrature_formula,
+                                   update_gradients);
+
+          std::vector<Tensor<2,dim>> velocity_gradients (quadrature_formula.size(), Tensor<2,dim>());
+
+          fe_values.reinit (in.current_cell);
+          fe_values[this->introspection().extractors.velocities].get_function_gradients (this->get_solution(),
+                                                                                         velocity_gradients);
+
+          // Assign the strain components to the compositional fields reaction terms.
+          // If there are too many fields, we simply fill only the first fields with the
+          // existing strain rate tensor components.
+          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
+            {
+              // Convert the compositional fields into the tensor quantity they represent.
+              const Tensor<2,dim> strain(make_array_view(&in.composition[q][0],
+                                                         &in.composition[q][0] + Tensor<2,dim>::n_independent_components));
+
+              // Compute the strain accumulated in this timestep.
+              const Tensor<2,dim> strain_increment = this->get_timestep() * (velocity_gradients[q] * strain);
+
+              // Output the strain increment component-wise to its respective compositional field's reaction terms.
+              strain_increment.unroll(&out.reaction_terms[q][0],
+                                      &out.reaction_terms[q][0] + Tensor<2,dim>::n_independent_components);
+            }
+        }
+    }
+
+
+    template <int dim>
+    void
+    FiniteStrain<dim>::
+    parse_parameters (ParameterHandler &prm)
+    {
+      Simple<dim>::parse_parameters (prm);
+
+      AssertThrow(this->n_compositional_fields() >= (Tensor<2,dim>::n_independent_components),
+                  ExcMessage("There must be at least as many compositional fields as independent components in the full "
+                             "strain rate tensor."));
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(FiniteStrain,
+                                   "finite strain",
+                                   "A simple material model that is like the "
+                                   "'Simple' model, but tracks the finite strain as compositional "
+                                   "fields. The model assumes that the first 4 (in 2D) "
+                                   " or 9 (in 3D) compositional fields contain the finite "
+                                   "strain components. ")
+  }
+}
diff --git a/tests/simple_shear_output_the_mobility.prm.bak b/tests/simple_shear_output_the_mobility.prm.bak
new file mode 100644
index 00000000000..5c31e38bc0a
--- /dev/null
+++ b/tests/simple_shear_output_the_mobility.prm.bak
@@ -0,0 +1,139 @@
+# This parameter file is a copy of simple_shear.prm but with the added postprocessor
+# "mobility statistics" following Lourenco et al., 2020.
+# Mobility = surface rms velocity / whole domain rms velocity.
+# This result of ~1.73205 in this test is very close to the analytical
+# solution of sqrt(3).
+#
+# This parameter file reproduces an analytical benchmark for the evolution
+# of finite strain in a model of simple shear as described (for a specific
+# application) in McKenzie & Jackson (1983): "The relationship between
+# strain rates, crustal thickening, paleomagnetism, finite strain and
+# fault movements within a deforming zone." They show that the analytical
+# solution for the deformation gradient tensor F in simple shear deformation is:
+#
+# F_xx = 1.0
+# F_xy = u_x,y * t
+# F_yx = 0
+# F_yy = 1.0,
+#
+# where u is the velocity, t is time, and a comma represents a derivative
+# in that particular direction.
+# Because u_x,y = 2.0 / 1.0 is constant in the whole domain (and over time) we expect
+# a constant F at any given time, and in particular:
+# F_xy (t=1.0) = 2.0
+#
+# This parameter file tracks the finite strain in two ways, once by using
+# compositional fields as illustrated in the finite strain cookbook, and
+# once by using a particle that sits and remains in the center of the domain.
+# The results should be the same.
+#
+# Numerical results for particle tracking and compositional fields
+# show equally excellent agreement.
+
+set Dimension                              = 2
+set End time                               = 0.025
+set Use years in output instead of seconds = false
+set Output directory = simple_shear_output_the_mobility
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set X periodic = true
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function, top:function
+
+  subsection Function
+    set Function expression = if (y < 0.5, -1, 1); 0
+  end
+end
+
+subsection Material model
+  set Model name = finite strain
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0;0.0;0.0;1.0
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = particles, composition statistics, visualization, mobility statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = strain rate, stress, principal stress
+    set Output format = gnuplot
+    set Time between graphical output = 0.05
+  end
+
+  subsection Particles
+    set Time between data output = 0.05
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain
+  set Particle generator name = ascii file
+
+  subsection Generator
+    subsection Ascii file
+      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/finite_strain/
+      set Data file name = simple_shear_particle.dat
+    end
+  end
+end
diff --git a/tests/simpler_box.prm.bak b/tests/simpler_box.prm.bak
new file mode 100644
index 00000000000..b6f00e8dc5a
--- /dev/null
+++ b/tests/simpler_box.prm.bak
@@ -0,0 +1,63 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/simpler_composition.prm.bak b/tests/simpler_composition.prm.bak
new file mode 100644
index 00000000000..ae05f34ed4f
--- /dev/null
+++ b/tests/simpler_composition.prm.bak
@@ -0,0 +1,61 @@
+# This test ensures that the Simpler material model works
+# with compositional fields enabled
+
+set Dimension                              = 2
+set End time                               = 0
+
+subsection Compositional fields
+  set Number of fields          = 1
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent                = 1024e3
+    set X repetitions           = 2
+    set Y extent                = 1024e3
+    set Y repetitions           = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 500
+  end
+end
+
+subsection Material model
+  set Model name         = simpler
+
+  subsection Simpler model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, top, bottom
+end
diff --git a/tests/single_Advection_iterated_defect_correction_Stokes.prm.bak b/tests/single_Advection_iterated_defect_correction_Stokes.prm.bak
new file mode 100644
index 00000000000..3358f9ece04
--- /dev/null
+++ b/tests/single_Advection_iterated_defect_correction_Stokes.prm.bak
@@ -0,0 +1,127 @@
+#########################################################
+# This is a model setup to test the iterated Advection and Stokes solver.
+# Both the calculation of the residuum and the convergence
+# with prescribed boundary conditions are tested.
+
+set Adiabatic surface temperature          = 0
+set CFL number                             = 0.5
+set Nonlinear solver scheme                = single Advection, iterated defect correction Stokes
+set Max nonlinear iterations               = 10
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  set Stokes velocity polynomial degree = 2
+
+  subsection Stabilization parameters
+    set beta  = 0.5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Box
+    set Top temperature = 0
+    set Bottom temperature = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 150000
+    set Y extent  = 65000
+    set X repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
+    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity = 0
+    set Thermal expansion coefficient = 1
+    set Thermal viscosity exponent = 0.0
+    set Reference specific heat = 1.0
+    set Reference density = 1.0
+    set Reference temperature = 0
+    set Viscosity = 1e16
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-2
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/sinking_block.cc.bak b/tests/sinking_block.cc.bak
new file mode 100644
index 00000000000..d5f03fd9261
--- /dev/null
+++ b/tests/sinking_block.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/sinking_block/sinking_block.cc"
diff --git a/tests/sinking_block.prm.bak b/tests/sinking_block.prm.bak
new file mode 100644
index 00000000000..46e689f4ced
--- /dev/null
+++ b/tests/sinking_block.prm.bak
@@ -0,0 +1,10 @@
+# This is a test for the sinking block benchmark.
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/sinking_block/sinking_block.prm
+
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+end
diff --git a/tests/skip_initial_conditions_setup_on_initial_refinement.prm.bak b/tests/skip_initial_conditions_setup_on_initial_refinement.prm.bak
new file mode 100644
index 00000000000..97c8b432af3
--- /dev/null
+++ b/tests/skip_initial_conditions_setup_on_initial_refinement.prm.bak
@@ -0,0 +1,66 @@
+##### simple test for skipping initial conditions setup
+##### on initial refinement.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1
+set Output directory                       = output-test
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 2
+  set Time steps between mesh refinement       = 0
+  set Skip solvers on initial refinement       = true
+  set Skip setup initial conditions on initial refinement = true
+  set Strategy                                 = minimum refinement function
+
+  subsection Minimum refinement function
+    set Variable names        = x, y
+    set Function expression   = if(x>330000, 3 ,1)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = heat flux statistics
+end
diff --git a/tests/skip_refinement.prm.bak b/tests/skip_refinement.prm.bak
new file mode 100644
index 00000000000..193151e2736
--- /dev/null
+++ b/tests/skip_refinement.prm.bak
@@ -0,0 +1,165 @@
+# A simulation with adaptive refinement only based on minimum
+# refinement function. As a consequence, refinement will not change
+# the mesh after the minimum refinement is reached. Confirm that
+# ASPECT detects this and skips the mesh refinement routines.
+
+#  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 100
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set CFL number                             = 0.5
+set Maximum time step                      = 50
+set Pressure normalization                 = no
+
+# Solver parameters
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 2000
+    set Linear solver tolerance = 1e-7
+    set GMRES solver restart length = 50
+  end
+end
+
+# Model geometry
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 2
+    set Y repetitions = 4
+    set X extent      = 1500e3
+    set Y extent      = 2891e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 3
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 1
+  set Strategy                           = minimum refinement function
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function expression = y>=2791.e3 ? 4 : 1
+  end
+end
+
+# Element types
+subsection Discretization
+  set Composition polynomial degree     = 2
+  set Stokes velocity polynomial degree = 2
+  set Temperature polynomial degree     = 1
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = top: free surface
+  set Additional tangential mesh velocity boundary indicators = left,right
+
+  subsection Free surface
+    set Surface velocity projection = normal
+  end
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+end
+
+# Prescribe a fixed vertical traction on the top boundary
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = top y: function
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants  = r0=100.e3, H0=1.e3, t1=90.e3, t2=100.e3, rhoi=931, g=9.815
+    set Function expression = 0; (x^2+y^2)<r0^2 ? t<t1 ? abs(cos(t/100.*pi))==1.0 ? -g*H0*rhoi*t/t1 : -g*H0*rhoi*(t+50.)/t1 : t<t2 ? abs(cos(t/100.*pi))==1.0 ? -g*H0*rhoi*(1-(t-t1)/(t2-t1)) : -g*H0*rhoi*(1-(t+50.-t1)/(t2-t1)) : 0 : 0;
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 7
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, LM, TZ, UM, Lith
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; if(y<=2221e3,1,0); if(y<=2471e3 && y>2221e3,1,0); if(y<=2821e3 && y>2471e3,1,0); if(y>2821e3,1,0);
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = true
+  set List of model names = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# Temperature initial conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+  set Material averaging = harmonic average only viscosity
+
+  subsection Viscoelastic
+    set Densities                   = 4978, 4978, 4978, 4978, 4978, 3871, 3438, 3037
+    set Viscosities                 = 2.e21, 2.e21, 2.e21, 2.e21, 2.e21, 1.e21, 1.e21, 1.e40
+    set Elastic shear moduli        = 2.28340e11, 2.28340e11, 2.28340e11, 2.28340e11, 2.28340e11, 1.05490e11, 0.70363e11, 0.50605e11
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 2.5
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.815
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = visualization, basic statistics, composition statistics, temperature statistics, topography, velocity statistics
+
+  subsection Visualization
+    set List of output variables = material properties, nonadiabatic pressure, strain rate
+    set Time between graphical output = 10000
+    set Interpolate output = false
+    set Number of grouped files = 1
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+end
diff --git a/tests/skip_solvers_on_initial_refinement.prm.bak b/tests/skip_solvers_on_initial_refinement.prm.bak
new file mode 100644
index 00000000000..d2251e6693b
--- /dev/null
+++ b/tests/skip_solvers_on_initial_refinement.prm.bak
@@ -0,0 +1,65 @@
+##### simple test for skipping solvers on initial refinement
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1
+set Output directory                       = output-test
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 660000
+    set Y extent = 660000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
+
+  subsection Function
+    set Function expression = 1;0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 2
+  set Time steps between mesh refinement       = 0
+  set Skip solvers on initial refinement       = true
+  set Skip setup initial conditions on initial refinement = false
+  set Strategy                                 = minimum refinement function
+
+  subsection Minimum refinement function
+    set Variable names        = x, y
+    set Function expression   = if(x>330000, 3 ,1)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = heat flux statistics
+end
diff --git a/tests/slab2_initial_composition_3d_shell.prm.bak b/tests/slab2_initial_composition_3d_shell.prm.bak
new file mode 100644
index 00000000000..2de5db0b27f
--- /dev/null
+++ b/tests/slab2_initial_composition_3d_shell.prm.bak
@@ -0,0 +1,78 @@
+##### simple test for slab2 model as initial composition
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 30
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = bottom, top, west, east, south
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, west, east, south
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields  = slabs
+  set Compositional field methods = static
+end
+
+subsection Initial composition model
+  set Model name = slab model
+
+  # The following lines point to the location of the slab2 model
+  # data file, generated using the jupyter notebook in the
+  # /data/initial-composition/slab-model/ folder.
+  subsection Slab model
+    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/slab-model/
+    set Data file name       = shell_3d.txt
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, composition statistics, visualization
+end
diff --git a/tests/slab_tip_depth.prm b/tests/slab_tip_depth.prm
index 0e1532e6b75..35558060eba 100644
--- a/tests/slab_tip_depth.prm
+++ b/tests/slab_tip_depth.prm
@@ -5,7 +5,7 @@
 # With increasing resolution, it should return the following
 # maximum depths of the composition fields:
 # 82, 110 and 82 km, resp.
-# The postprocessors viscous dissipation statistics and
+# The postprocessors heating statistics and
 # viscous dissipation per compositional field return
 # the viscous dissipation over the whole domain and
 # per area of each field, resp. With enough resolution,
@@ -146,7 +146,7 @@ subsection Formulation
 end
 
 subsection Postprocess
-  set List of postprocessors = velocity statistics, maximum depth of field, viscous dissipation statistics
+  set List of postprocessors = velocity statistics, maximum depth of field, heating statistics
 end
 
 subsection Solver parameters
diff --git a/tests/slab_tip_depth.prm.bak b/tests/slab_tip_depth.prm.bak
new file mode 100644
index 00000000000..0e1532e6b75
--- /dev/null
+++ b/tests/slab_tip_depth.prm.bak
@@ -0,0 +1,157 @@
+# This test considers the first timestep of a
+# 2d subduction setup with prescribed in- and outflow.
+# The postprocessor maximum depth of field
+# returns the depth of the deepest point of each field.
+# With increasing resolution, it should return the following
+# maximum depths of the composition fields:
+# 82, 110 and 82 km, resp.
+# The postprocessors viscous dissipation statistics and
+# viscous dissipation per compositional field return
+# the viscous dissipation over the whole domain and
+# per area of each field, resp. With enough resolution,
+# the dissipation over the whole domain should be
+# approx. 8.5 kW/m and that over the subducting plate approx. 4 kW/m.
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set CFL number                             = 0.5
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Adiabatic surface temperature          = 0
+
+# We fix composition on the right boundary,
+# because we have inflow there.
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = right
+  set List of model names = initial composition
+end
+
+# We fix temperature on the top and bottom,
+# as well as on the right boundary because
+# we have inflow through the latter.
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 0
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+# prescribe horizontal in- and outflow through the right boundary
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom, top
+  set Prescribed velocity boundary indicators = right x:function
+
+  subsection Function
+    set Function constants  = cm=100.0
+    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
+                                 if(z>560000.0, -5.0/cm, \
+                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
+                              0
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Reference temperature         = 0.0
+    set Viscosity averaging scheme    = maximum composition
+
+    # background, OP, ML SP, crust SP
+    set Viscosities                   = 1.e20, 1.e23, 1.e23, 1.e20
+    set Densities                     = 3200.0, 3250.0, 3250.0, 3250.0
+    set Thermal conductivities        = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = OP, ML_SP, crust_SP
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  = Ax=1475600.0, Az=670000.0, \
+                              Bx=1500000.0, Bz=670000.0, \
+                              Cx=1358500.0, Cz=588000.0, \
+                              Dx=1382900.0, Dz=588000.0, \
+                              Ex=1530000.0, Ez=560000.0, \
+                              Fz=663000.0, Gz=662000.0, \
+                              Hz=631000.0, Iz=630000.0
+    set Function expression = \
+                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
+                              if((x>=Ex&z>=Ez&z<Gz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
+                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)|z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0)
+    set Variable names      = x,z
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent   = 3000e3
+    set Y extent   = 670e3
+    set X repetitions = 4
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# We ignore any temperature effects
+subsection Initial temperature model
+  set List of model names = function
+
+  subsection Function
+    set Function constants  =
+    set Function expression = 0
+    set Variable names      = x,y,t
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 2
+  set Initial global refinement                = 4
+  set Minimum refinement level                 = 4
+  set Coarsening fraction                      = 0.01
+  set Refinement fraction                      = 0.95
+  set Skip solvers on initial refinement       = true
+  set Strategy                                 = minimum refinement function
+  set Time steps between mesh refinement       = 16
+
+  subsection Minimum refinement function
+    set Coordinate system = depth
+    set Variable names = x,z,t
+    set Function constants = vel_trans=150e3
+    set Function expression = if(x<vel_trans,6,4)
+  end
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, maximum depth of field, viscous dissipation statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-6
+    set Number of cheap Stokes solver steps = 200
+  end
+end
diff --git a/tests/slope_refinement.prm.bak b/tests/slope_refinement.prm.bak
new file mode 100644
index 00000000000..f39e9d10960
--- /dev/null
+++ b/tests/slope_refinement.prm.bak
@@ -0,0 +1,114 @@
+#Test for slope-based refinement
+
+set Dimension = 2
+set CFL number                             = 0.1
+set End time                               = 1e9
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature,slope
+  set Time steps between mesh refinement = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/smoothing.prm.bak b/tests/smoothing.prm.bak
new file mode 100644
index 00000000000..6930c3b3e10
--- /dev/null
+++ b/tests/smoothing.prm.bak
@@ -0,0 +1,98 @@
+# Smoothing
+# Here we prescribe a circular Stokes flow and test if EV with smoothing works while it rotates
+
+# set CFL number = 0.1
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = .5
+set Output directory                       = output
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 2
+
+  subsection Stabilization parameters
+    set Use artificial viscosity smoothing = true
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+    set Box origin X coordinate = -1
+    set Box origin Y coordinate = -1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression =  if((sqrt((x-0)^2+(y-0.5)^2)<0.3)&(abs(x)>=0.05|y>=0.7),1,if(sqrt((x-0)^2+(y+0.5)^2)<0.3,1-sqrt((x-0)^2+(y+0.5)^2)/0.3,if(sqrt((x+0.5)^2+(y+0)^2)<0.3,1.0/4.0*(1+cos(pi*min(sqrt((x+0.5)^2+(y+0)^2)/0.3,1))),0)))
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top, bottom, left, right
+
+  subsection Box
+    set Bottom temperature = 0
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0  # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-5
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = .1
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/smoothing_composition_passive.prm.bak b/tests/smoothing_composition_passive.prm.bak
new file mode 100644
index 00000000000..60b1dee1a4c
--- /dev/null
+++ b/tests/smoothing_composition_passive.prm.bak
@@ -0,0 +1,108 @@
+#########################################################
+# SMOOTHING - COMPOSITIONAL PASSIVE
+# This is a test based off of that composition-passive.prm file.
+# All settings are exactly the same with the exception
+# that we are using entropy viscosity with smoothing,
+# and that things were made slightly simpler to make
+# the test run faster.
+#
+# See the manual for more information about this setup.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+set Output directory                       = output
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set Use artificial viscosity smoothing = true
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/tests/sol_cx_2.cc.bak b/tests/sol_cx_2.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_2.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2.prm.bak b/tests/sol_cx_2.prm.bak
new file mode 100644
index 00000000000..1446019093c
--- /dev/null
+++ b/tests/sol_cx_2.prm.bak
@@ -0,0 +1,74 @@
+set Additional shared libraries            = ./libsolcx.so
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_2_conservative.cc.bak b/tests/sol_cx_2_conservative.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_2_conservative.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_conservative.prm.bak b/tests/sol_cx_2_conservative.prm.bak
new file mode 100644
index 00000000000..63673305a3c
--- /dev/null
+++ b/tests/sol_cx_2_conservative.prm.bak
@@ -0,0 +1,73 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = true
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_2_equal_order.cc.bak b/tests/sol_cx_2_equal_order.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_2_equal_order.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_equal_order.prm.bak b/tests/sol_cx_2_equal_order.prm.bak
new file mode 100644
index 00000000000..37e77dc4c0a
--- /dev/null
+++ b/tests/sol_cx_2_equal_order.prm.bak
@@ -0,0 +1,76 @@
+# Check the SolCx benchmark, but using the Q1 x Q1 element
+
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 1
+  set Temperature polynomial degree           = 1
+  set Use equal order interpolation for Stokes = true
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_2_gmg.cc.bak b/tests/sol_cx_2_gmg.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_2_gmg.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_gmg.prm.bak b/tests/sol_cx_2_gmg.prm.bak
new file mode 100644
index 00000000000..730301c673b
--- /dev/null
+++ b/tests/sol_cx_2_gmg.prm.bak
@@ -0,0 +1,86 @@
+# The Solcx benchmark solved with the block
+# GMG preconditioner and harmonic averaging
+# for 2 global refinements
+
+
+set Additional shared libraries            = ./libsolcx.so
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+  set Material averaging = harmonic average only viscosity
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_2_normalized_pressure.cc.bak b/tests/sol_cx_2_normalized_pressure.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_2_normalized_pressure.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_normalized_pressure.prm.bak b/tests/sol_cx_2_normalized_pressure.prm.bak
new file mode 100644
index 00000000000..eb2e6792fde
--- /dev/null
+++ b/tests/sol_cx_2_normalized_pressure.prm.bak
@@ -0,0 +1,74 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = volume
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_2_q3.cc.bak b/tests/sol_cx_2_q3.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_2_q3.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_q3.prm.bak b/tests/sol_cx_2_q3.prm.bak
new file mode 100644
index 00000000000..3e821efd853
--- /dev/null
+++ b/tests/sol_cx_2_q3.prm.bak
@@ -0,0 +1,73 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 3
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_4.cc.bak b/tests/sol_cx_4.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_4.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4.prm.bak b/tests/sol_cx_4.prm.bak
new file mode 100644
index 00000000000..3142b8d808f
--- /dev/null
+++ b/tests/sol_cx_4.prm.bak
@@ -0,0 +1,73 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_4_conservative.cc.bak b/tests/sol_cx_4_conservative.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_4_conservative.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_conservative.prm.bak b/tests/sol_cx_4_conservative.prm.bak
new file mode 100644
index 00000000000..a2be5091bd6
--- /dev/null
+++ b/tests/sol_cx_4_conservative.prm.bak
@@ -0,0 +1,73 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = true
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_4_equal_order.cc.bak b/tests/sol_cx_4_equal_order.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_4_equal_order.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_equal_order.prm.bak b/tests/sol_cx_4_equal_order.prm.bak
new file mode 100644
index 00000000000..664f5e00814
--- /dev/null
+++ b/tests/sol_cx_4_equal_order.prm.bak
@@ -0,0 +1,75 @@
+# Check the SolCx benchmark, but using the Q1 x Q1 element
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 1
+  set Temperature polynomial degree           = 1
+  set Use equal order interpolation for Stokes = true
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor, visualization
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_4_gmg.cc.bak b/tests/sol_cx_4_gmg.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_4_gmg.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_gmg.prm.bak b/tests/sol_cx_4_gmg.prm.bak
new file mode 100644
index 00000000000..96800a5d76c
--- /dev/null
+++ b/tests/sol_cx_4_gmg.prm.bak
@@ -0,0 +1,84 @@
+# The Solcx benchmark solved with the block
+# GMG preconditioner and harmonic averaging
+# for 4 global refinements
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+  set Material averaging = harmonic average only viscosity
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_4_normalized_pressure.cc.bak b/tests/sol_cx_4_normalized_pressure.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_4_normalized_pressure.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_normalized_pressure.prm.bak b/tests/sol_cx_4_normalized_pressure.prm.bak
new file mode 100644
index 00000000000..c07efe8c9ed
--- /dev/null
+++ b/tests/sol_cx_4_normalized_pressure.prm.bak
@@ -0,0 +1,74 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization = volume
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_4_normalized_pressure_large_static_pressure.cc.bak b/tests/sol_cx_4_normalized_pressure_large_static_pressure.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_4_normalized_pressure_large_static_pressure.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_normalized_pressure_large_static_pressure.prm.bak b/tests/sol_cx_4_normalized_pressure_large_static_pressure.prm.bak
new file mode 100644
index 00000000000..ff66ace7930
--- /dev/null
+++ b/tests/sol_cx_4_normalized_pressure_large_static_pressure.prm.bak
@@ -0,0 +1,96 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = volume
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# a case where we have a large static pressure, 1e6 times larger than the
+# dynamic pressure, by making the material very heavy. verify that we still
+# get the correct solution.
+#
+# note that to get the same number of iterations as for the
+# sol_cx_4_normalized_pressure testcase, we have to set the linear solver
+# tolerance to something smaller, because the right hand side vector is
+# much larger when using a large background density. then, however, using
+# the exact same number of iterations, we get the exact same error, as
+# claimed in the appendix of the first ASPECT paper
+
+
+subsection Material model
+  set Model name = SolCxMaterial
+
+  subsection SolCx
+    set Background density = 1e6
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 0.6e-9
+  end
+end
diff --git a/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.cc.bak b/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.prm.bak b/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.prm.bak
new file mode 100644
index 00000000000..bb4e0638565
--- /dev/null
+++ b/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.prm.bak
@@ -0,0 +1,90 @@
+# a case where we set the linear solver tolerance to a more loose value
+# than the default to see that it affects the overall accuracy. it turns
+# out that we can reduce the tolerance from 1e-7 to 1e-3 without changing
+# the accuracy in the solution very much. with 1e-2 the iteration error
+# now becomes so that it affects the overall error (which is iteration
+# plus discretization)
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = volume
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 1
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-2
+  end
+end
diff --git a/tests/sol_cx_mpi_2.cc.bak b/tests/sol_cx_mpi_2.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_mpi_2.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_mpi_2.prm.bak b/tests/sol_cx_mpi_2.prm.bak
new file mode 100644
index 00000000000..132bf623ad6
--- /dev/null
+++ b/tests/sol_cx_mpi_2.prm.bak
@@ -0,0 +1,78 @@
+# Like sol_cx_2.prm, but with 2 processors
+
+# MPI: 2
+
+set Additional shared libraries            = ./libsolcx.so
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_newton_crash.cc.bak b/tests/sol_cx_newton_crash.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/sol_cx_newton_crash.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_newton_crash.prm.bak b/tests/sol_cx_newton_crash.prm.bak
new file mode 100644
index 00000000000..631b5d98956
--- /dev/null
+++ b/tests/sol_cx_newton_crash.prm.bak
@@ -0,0 +1,83 @@
+# A linear problem (copied from sol_cx_4) that crashes when "iterated Newton Stokes" is
+# used an the linear tolerance is reduced.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance                         = 1e-9
+  end
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+  set Material averaging = harmonic average only viscosity
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_cx_particles.cc.bak b/tests/sol_cx_particles.cc.bak
new file mode 100644
index 00000000000..5d18c190496
--- /dev/null
+++ b/tests/sol_cx_particles.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc"
diff --git a/tests/sol_cx_particles.prm.bak b/tests/sol_cx_particles.prm.bak
new file mode 100644
index 00000000000..60758de0b1c
--- /dev/null
+++ b/tests/sol_cx_particles.prm.bak
@@ -0,0 +1,9 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/solcx/compositional_fields/solcx_particles.prm
+
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 1
+end
diff --git a/tests/sol_kz_2.cc.bak b/tests/sol_kz_2.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/sol_kz_2.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2.prm.bak b/tests/sol_kz_2.prm.bak
new file mode 100644
index 00000000000..95f4a9122cd
--- /dev/null
+++ b/tests/sol_kz_2.prm.bak
@@ -0,0 +1,73 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolKzPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_kz_2_cheaper_first_phase_solver.cc.bak b/tests/sol_kz_2_cheaper_first_phase_solver.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/sol_kz_2_cheaper_first_phase_solver.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_cheaper_first_phase_solver.prm.bak b/tests/sol_kz_2_cheaper_first_phase_solver.prm.bak
new file mode 100644
index 00000000000..23dc0d1701d
--- /dev/null
+++ b/tests/sol_kz_2_cheaper_first_phase_solver.prm.bak
@@ -0,0 +1,79 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolKzPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 20
+  end
+end
diff --git a/tests/sol_kz_2_conservative.cc.bak b/tests/sol_kz_2_conservative.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/sol_kz_2_conservative.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_conservative.prm.bak b/tests/sol_kz_2_conservative.prm.bak
new file mode 100644
index 00000000000..823da8106b2
--- /dev/null
+++ b/tests/sol_kz_2_conservative.prm.bak
@@ -0,0 +1,73 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolKzPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_kz_2_no_first_phase_solver.cc.bak b/tests/sol_kz_2_no_first_phase_solver.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/sol_kz_2_no_first_phase_solver.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_no_first_phase_solver.prm.bak b/tests/sol_kz_2_no_first_phase_solver.prm.bak
new file mode 100644
index 00000000000..1e31796636d
--- /dev/null
+++ b/tests/sol_kz_2_no_first_phase_solver.prm.bak
@@ -0,0 +1,79 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolKzPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/sol_kz_2_project_q1_only_visc.cc.bak b/tests/sol_kz_2_project_q1_only_visc.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/sol_kz_2_project_q1_only_visc.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_project_q1_only_visc.prm.bak b/tests/sol_kz_2_project_q1_only_visc.prm.bak
new file mode 100644
index 00000000000..06803a88518
--- /dev/null
+++ b/tests/sol_kz_2_project_q1_only_visc.prm.bak
@@ -0,0 +1,14 @@
+# Solkz benchmark using project to Q1 only viscosity material modeling averaging
+
+include $ASPECT_SOURCE_DIR/benchmarks/solkz/solkz.prm
+
+
+subsection Material model
+  set Model name = SolKzMaterial
+  set Material averaging = project to Q1 only viscosity
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
diff --git a/tests/sol_kz_2_q3.cc.bak b/tests/sol_kz_2_q3.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/sol_kz_2_q3.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_q3.prm.bak b/tests/sol_kz_2_q3.prm.bak
new file mode 100644
index 00000000000..785fef07fbe
--- /dev/null
+++ b/tests/sol_kz_2_q3.prm.bak
@@ -0,0 +1,73 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 3
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolKzPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_kz_4.cc.bak b/tests/sol_kz_4.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/sol_kz_4.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_4.prm.bak b/tests/sol_kz_4.prm.bak
new file mode 100644
index 00000000000..b092a55d92b
--- /dev/null
+++ b/tests/sol_kz_4.prm.bak
@@ -0,0 +1,73 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolKzPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/sol_kz_4_conservative.cc.bak b/tests/sol_kz_4_conservative.cc.bak
new file mode 100644
index 00000000000..d6275281d3e
--- /dev/null
+++ b/tests/sol_kz_4_conservative.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_4_conservative.prm.bak b/tests/sol_kz_4_conservative.prm.bak
new file mode 100644
index 00000000000..9a63dc35f49
--- /dev/null
+++ b/tests/sol_kz_4_conservative.prm.bak
@@ -0,0 +1,73 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolKzMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolKzPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/solidus_initial_conditions.cc.bak b/tests/solidus_initial_conditions.cc.bak
new file mode 100644
index 00000000000..e45783c44fa
--- /dev/null
+++ b/tests/solidus_initial_conditions.cc.bak
@@ -0,0 +1,447 @@
+/*
+  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/initial_temperature/interface.h>
+#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+#include <aspect/geometry_model/spherical_shell.h>
+#include <aspect/boundary_temperature/interface.h>
+
+#include <cmath>
+
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    /**
+     * Data class to handle the melting curve.
+     */
+    class MeltingCurve
+    {
+      public:
+
+        /**
+         * Read the data file into the class.
+         */
+        void read(const std::string &filename,
+                  const MPI_Comm comm);
+
+        /**
+         * Get the melting temperature.
+         */
+        double T(const double p, const double radius) const;
+
+        /**
+         * Is the melting curve dependent on radius. The melting curve can be
+         * dependent on radius or pressure.
+         */
+        bool is_radius;
+
+        /**
+         * Number of data points in the melting curve data.
+         */
+        unsigned int n_points;
+      private:
+        /**
+         * Data array for temperature.
+         */
+        std::vector<double> T_array;
+
+        /**
+         * Data array for pressure/radius.
+         */
+        std::vector<double> P_or_R_array;
+
+        /**
+         * Name of the data file.
+         */
+        std::string data_filename;
+    };
+
+
+    /**
+     * A class that implements temperature initial conditions based on solidus
+     * provided by a data file.
+     *
+     * @ingroup InitialTemperatures
+     */
+    template <int dim>
+    class Solidus : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * Constructor.
+         */
+        Solidus ();
+
+        /**
+         * Return the initial temperature as a function of position.
+         */
+        double initial_temperature (const Point<dim> &position) const override;
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        void
+        parse_parameters (ParameterHandler &prm) override;
+
+      private:
+        /**
+         * Returns spherical coordinates of a cartesian position.
+         */
+        const Tensor<1,dim>
+        spherical_surface_coordinates(const Tensor<1,dim> &position) const;
+
+        /**
+         * Lithosphere thickness.
+         */
+        double       litho_thick;
+
+        /**
+         * Magnitude of temperature perturbation.
+         */
+        double       magnitude_T;
+
+        /**
+         * Magnitude of lithosphere thickness perturbation.
+         */
+        double       magnitude_lith;
+
+        /**
+         * Temperature difference from solidus, so the initial condition can
+         * be super-solidus or sub-solidus.
+         */
+        double       deltaT;
+
+        /**
+         * The lateral wave number  of the harmonic perturbation in the first
+         * dimension. This is the only lateral wave number in 2D and equals
+         * the degree of the spherical harmonics in a 3D spherical shell.
+         */
+        int          lateral_wave_number_1;
+
+        /**
+         * The lateral wave number of the harmonic perturbation in the second
+         * dimension. This is not used in 2D and equals the order of the
+         * spherical harmonics in a 3D spherical shell.
+         */
+        int          lateral_wave_number_2;
+
+        /**
+         * The data file name for solidus data.
+         */
+        std::string  solidus_filename;
+
+        /**
+         * Data class for melting curve
+         */
+        MeltingCurve solidus_curve;
+    };
+
+    void MeltingCurve::read(const std::string &filename,
+                            const MPI_Comm comm)
+    {
+      data_filename=filename;
+      // Read data from disk and distribute among processes
+      std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
+
+      std::string dummy;
+
+      std::string T_Unit,P_Unit;
+      n_points=0;
+      getline (in, dummy);
+      in>>T_Unit>>P_Unit;
+      getline (in, dummy);
+      while (!in.eof())
+        {
+          double T,p;
+          in>>T>>p;
+          if (!in.fail())
+            {
+              // Unit switching
+              if (T_Unit=="C")
+                {
+                  T+=273.15;                      // Degree C to K
+                }
+              else if (T_Unit!="K")
+                {
+                  AssertThrow(false,ExcMessage ("Unit of the first column of melting curve data "
+                                                "has to be one of the following: C/K."));
+                }
+
+              is_radius=false;                    // Second column is pressure
+              if (P_Unit=="kbar")
+                p*=1.e8;                        // kbar to Pa
+              else if (P_Unit=="GPa")
+                p*=1.e9;                        // GPa to Pa
+              else
+                {
+                  is_radius=true;                 // Second column is radius instead of pressure
+                  if (P_Unit=="km")
+                    p*=1.e3;                    // km to meters
+                  else if (P_Unit!="m")
+                    AssertThrow(false,ExcMessage ("Unit of the second column of melting curve data "
+                                                  "has to be one of the following: Pa/GPa/km/m."));
+                }
+              T_array.push_back(T);
+              P_or_R_array.push_back(p);
+              n_points++;
+            }
+          getline (in, dummy);
+        }
+    }
+
+
+
+    double MeltingCurve::T(const double p, const double radius) const
+    {
+      double T_value,P_or_R_value=is_radius?radius:p;
+      if (T_array.size()==0)return (0);
+      for (unsigned i=1; i<n_points; i++)
+        {
+          if (     (i==n_points-1) ||
+                   (is_radius && P_or_R_value>P_or_R_array[i]) ||
+                   (!is_radius && P_or_R_value<P_or_R_array[i]) )
+            {
+              T_value=T_array[i-1]+(T_array[i]-T_array[i-1])/(P_or_R_array[i]-P_or_R_array[i-1])*(P_or_R_value-P_or_R_array[i-1]);
+              return (T_value);
+            }
+        }
+      AssertThrow(false,ExcMessage(std::string("Something wrong with the melting curve data ")+ data_filename ));
+      return (-1);
+    }
+
+
+
+    template <int dim>
+    Solidus<dim>::Solidus ():
+      solidus_curve()
+    {}
+
+    template <int dim>
+    double
+    Solidus<dim>::
+    initial_temperature (const Point<dim> &position) const
+    {
+      double T_min,T_litho;
+      double T_solidus,T_perturbation;
+      double litho_thick_theta;
+      double lateral_perturbation;
+      double Depth=this->get_geometry_model().depth(position);
+
+      AssertThrow(solidus_curve.n_points!=0,ExcMessage("Error reading solidus file."));
+      AssertThrow(solidus_curve.is_radius==true,ExcMessage("The solidus curve has to be radius dependent."));
+      const GeometryModel::SphericalShell<dim> *spherical_geometry_model=
+        dynamic_cast<const GeometryModel::SphericalShell<dim> *>(&this->get_geometry_model());
+
+      AssertThrow(spherical_geometry_model!=0,
+                  ExcMessage("This initial condition can only be used with spherical shell geometry model."));
+
+      AssertThrow(this->has_boundary_temperature(),
+                  ExcMessage("This initial condition can only be used with a prescribed boundary temperature."));
+
+      T_min=(this->get_boundary_temperature_manager()).minimal_temperature();
+
+      // In case of spherical shell calculate spherical coordinates
+      const Tensor<1,dim> scoord = spherical_surface_coordinates(position);
+      if (dim==2)
+        {
+          // Use a sine as lateral perturbation that is scaled to the opening angle of the geometry.
+          // This way the perturbation is always 0 at the model boundaries.
+          const double opening_angle = spherical_geometry_model->opening_angle() * constants::degree_to_radians;
+          lateral_perturbation = std::sin(lateral_wave_number_1*scoord[1]*numbers::PI/opening_angle);
+        }
+      else if (dim==3)
+        {
+          // Spherical harmonics are only defined for order <= degree
+          // and degree >= 0. Verify that it is indeed.
+          Assert ( std::abs(lateral_wave_number_2) <= lateral_wave_number_1,
+                   ExcMessage ("Spherical harmonics can only be computed for "
+                               "order <= degree."));
+          Assert ( lateral_wave_number_1 >= 0,
+                   ExcMessage ("Spherical harmonics can only be computed for "
+                               "degree >= 0."));
+          // use a spherical harmonic function as lateral perturbation
+          std::pair<double,double> sph_harm_vals = Utilities::real_spherical_harmonic( lateral_wave_number_1, lateral_wave_number_2, scoord[2], scoord[1] );
+          lateral_perturbation = sph_harm_vals.first;
+        }
+      litho_thick_theta=litho_thick-magnitude_lith*lateral_perturbation;
+      T_litho=solidus_curve.T(0,spherical_geometry_model->outer_radius()-litho_thick_theta)+deltaT;
+
+      if (litho_thick_theta>0 && Depth<litho_thick_theta)
+        T_solidus=T_min+(T_litho-T_min)*(Depth/litho_thick_theta);
+      else
+        T_solidus=solidus_curve.T(0,sqrt(position.square()))+deltaT;
+
+      T_perturbation=Depth/( this->get_geometry_model().maximal_depth() )*magnitude_T*lateral_perturbation;
+      return T_solidus+T_perturbation;
+    }
+
+
+
+    template <int dim>
+    const Tensor<1,dim>
+    Solidus<dim>::
+    spherical_surface_coordinates(const Tensor<1,dim> &position) const
+    {
+      Tensor<1,dim> scoord;
+
+      scoord[0] = std::sqrt(position.norm_square());                // R
+      scoord[1] = std::atan2(position[1],position[0]);              // Phi
+      if (scoord[1] < 0.0) scoord[1] = 2*numbers::PI + scoord[1];   // correct phi to [0,2*pi]
+      if (dim==3)
+        scoord[2] = std::acos(position[2]/std::sqrt(position.norm_square())); // Theta
+
+      return scoord;
+    }
+
+
+
+    template <int dim>
+    void
+    Solidus<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Solidus");
+        {
+          prm.declare_entry ("Supersolidus","0e0",
+                             Patterns::Double (),
+                             "The difference from solidus, use this number to generate initial conditions "
+                             "that close to solidus instead of exactly at solidus. Use small negative number"
+                             " in this parameter to prevent large melting generation at the beginning. "
+                             "  Units: \\si{\\kelvin} ");
+          prm.declare_entry ("Lithosphere thickness","0",
+                             Patterns::Double (0),
+                             "The thickness of lithosphere thickness. Units: \\si{\\meter}");
+          prm.enter_subsection("Perturbation");
+          {
+            prm.declare_entry ("Temperature amplitude", "0e0",
+                               Patterns::Double (0),
+                               "The amplitude of the initial spherical temperature perturbation in (K)");
+            prm.declare_entry ("Lithosphere thickness amplitude", "0e0",
+                               Patterns::Double (),
+                               "The amplitude of the initial lithosphere thickness perturbation in (m)");
+            prm.declare_entry ("Lateral wave number one","3",
+                               Patterns::Integer(),
+                               "Doubled first lateral wave number of the harmonic perturbation. "
+                               "Equals the spherical harmonic degree in 3D spherical shells. "
+                               "In all other cases one equals half of a sine period over "
+                               "the model domain. This allows for single up-/downswings. "
+                               "Negative numbers reverse the sign of the perturbation but are "
+                               "not allowed for the spherical harmonic case.");
+            prm.declare_entry ("Lateral wave number two", "2",
+                               Patterns::Integer (),
+                               "Doubled second lateral wave number of the harmonic perturbation. "
+                               "Equals the spherical harmonic order in 3D spherical shells. "
+                               "In all other cases one equals half of a sine period over "
+                               "the model domain. This allows for single up-/downswings. "
+                               "Negative numbers reverse the sign of the perturbation.");
+          }
+          prm.leave_subsection();
+          prm.enter_subsection ("Data");
+          {
+            prm.declare_entry ("Solidus filename", "",
+                               Patterns::Anything(),
+                               "The solidus data filename. It is a function of radius or pressure "
+                               "in the following format: \n"
+                               "Line 1:  Header \n"
+                               "Line 2:  Unit of temperature (C/K)        "
+                               "Unit of pressure (GPa/kbar) or radius (km/m) \n"
+                               "Line 3~: Column of solidus temperature    Column of radius/pressure \n"
+                               "See data/initial-temperature/solidus.Mars as an example."
+                               "\n\n"
+                               "In order to facilitate placing input files in locations relative "
+                               "to the ASPECT source directory, the file name may also include the special "
+                               "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
+                               "in which the ASPECT source files were located when ASPECT was "
+                               "compiled. This interpretation allows, for example, to reference "
+                               "files located in the `data/' subdirectory of ASPECT.");
+          }
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    Solidus<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection ("Initial temperature model");
+      {
+        prm.enter_subsection("Solidus");
+        {
+          deltaT=prm.get_double("Supersolidus");
+          litho_thick=prm.get_double("Lithosphere thickness");
+          prm.enter_subsection("Perturbation");
+          {
+            magnitude_T    = prm.get_double("Temperature amplitude");
+            magnitude_lith = prm.get_double("Lithosphere thickness amplitude");
+            lateral_wave_number_1 = prm.get_integer ("Lateral wave number one");
+            lateral_wave_number_2 = prm.get_integer ("Lateral wave number two");
+          }
+          prm.leave_subsection();
+          prm.enter_subsection("Data");
+          solidus_filename = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Solidus filename"));
+          solidus_curve.read(solidus_filename,this->get_mpi_communicator());
+          prm.leave_subsection();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+  }
+
+
+}
+
+
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace InitialTemperature
+  {
+    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(Solidus,
+                                              "solidus",
+                                              "This is a temperature initial condition that "
+                                              "starts the model close to solidus, it also contains "
+                                              "a user defined lithosphere thickness and with perturbations "
+                                              " in both lithosphere thickness and temperature based on "
+                                              "spherical harmonic functions. It was used as the initial condition "
+                                              "of early Mars after the freezing of the magma ocean, "
+                                              "using the solidus from Parmentier et al., "
+                                              "Melt-solid segregation, Fractional magma ocean solidification, and implications for "
+                                              "long term planetary evolution. Luna and Planetary Science, 2007.")
+  }
+}
diff --git a/tests/solidus_initial_conditions.prm.bak b/tests/solidus_initial_conditions.prm.bak
new file mode 100644
index 00000000000..1198dbadfd6
--- /dev/null
+++ b/tests/solidus_initial_conditions.prm.bak
@@ -0,0 +1,85 @@
+# A simple setup for initial condition close to solidus of Mars in a 2d shell with perturbations. See the
+# manual for more information.
+
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1.5e-9
+set Adiabatic surface temperature          = 1200
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 1700000
+    set Outer radius  = 3385000
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0
+  set Tangential velocity boundary indicators = 1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2200
+    set Outer temperature = 250
+  end
+end
+
+subsection Initial temperature model
+  set Model name              = solidus
+
+  subsection Solidus
+    set Supersolidus          = -50
+    set Lithosphere thickness = 500e3
+
+    subsection Perturbation
+      set Temperature amplitude           = 100
+      set Lithosphere thickness amplitude = 250e3
+      set Lateral wave number one         = 12
+      set Lateral wave number two         = 6
+    end
+
+    subsection Data
+      set Solidus filename = $ASPECT_SOURCE_DIR/data/initial-temperature/solidus.Mars
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 1e6
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
diff --git a/tests/solitary_wave.cc.bak b/tests/solitary_wave.cc.bak
new file mode 100644
index 00000000000..069053c7cd3
--- /dev/null
+++ b/tests/solitary_wave.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solitary_wave/solitary_wave.cc"
diff --git a/tests/solitary_wave.prm.bak b/tests/solitary_wave.prm.bak
new file mode 100644
index 00000000000..5e0fb993e6a
--- /dev/null
+++ b/tests/solitary_wave.prm.bak
@@ -0,0 +1,159 @@
+# Listing of Parameters
+# ---------------------
+# Set up the solitary wave benchmark
+# (Barcilon & Richter, 1986; Simpson & Spiegelman, 2011;
+# Keller et al., 2013; Schmeling, 2000)
+
+set Adiabatic surface temperature          = 1623
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+set Nonlinear solver tolerance             = 1e-5
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 1 times its wavelength during the model time.
+set End time                               = 2e3
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta  = 0.001
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Initial temperature
+    # Temperature at the inner boundary (core mantle boundary). Units: \\si{\\kelvin}.
+    set Maximal temperature = 3773
+
+    # Temperature at the outer boundary (lithosphere water/air). Units: \\si{\\kelvin}.
+    set Minimal temperature = 273
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2,3
+end
+
+# we apply the phase speed of the wave here, so that it always stays in the same place in our model
+# the phase speed is c = 5.25e-11 m/s, but we have to convert it to m/years using the same conversion
+# that is used internally in ASPECT: year_in_seconds = 60*60*24*365.2425
+
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function, 3:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    #    set Function expression = 0;-8.2836999e-5
+    set Function expression = 0;-1.65673998e-4
+
+    #    set Function expression = 0;-3.31347996e-4
+    #    set Function expression = 0;-6.62695992e-4
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 10
+    set Y extent  = 400
+    set Y repetitions = 40
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Initial composition model
+  set Model name = Solitary wave initial condition
+
+  subsection Solitary wave initial condition
+    set Offset = 200
+    set Read solution from file = false
+    set Amplitude = 0.01
+    set Background porosity = 0.001
+  end
+end
+
+subsection Material model
+  set Model name = Solitary Wave
+
+  subsection Solitary wave
+    set Reference permeability = 5e-9
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.0
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 2
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics,solitary wave statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = vtu
+    set Time between graphical output = 5e5
+
+    subsection Melt material properties
+      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
+    end
+  end
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-14
+  set Temperature solver tolerance = 1e-14
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-10
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/solubility.cc.bak b/tests/solubility.cc.bak
new file mode 100644
index 00000000000..c6871a82a73
--- /dev/null
+++ b/tests/solubility.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solubility/plugin/solubility.cc"
diff --git a/tests/solubility.prm.bak b/tests/solubility.prm.bak
new file mode 100644
index 00000000000..8faad431cd7
--- /dev/null
+++ b/tests/solubility.prm.bak
@@ -0,0 +1,11 @@
+# 1D solubility test
+
+include $ASPECT_SOURCE_DIR/benchmarks/solubility/solubility.prm
+
+set End time = 15000
+
+subsection Geometry model
+  subsection Box
+    set Y repetitions = 100
+  end
+end
diff --git a/tests/solve_no_advection_no_stokes.prm.bak b/tests/solve_no_advection_no_stokes.prm.bak
new file mode 100644
index 00000000000..a927cd68012
--- /dev/null
+++ b/tests/solve_no_advection_no_stokes.prm.bak
@@ -0,0 +1,71 @@
+set Dimension                              = 3
+set Use years in output instead of seconds = false
+set Start time                             = 0
+set End time                               = 0
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Output directory                       = output-solve_no_advection_no_stokes
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = outer,west,south,east
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = inner,outer
+  set List of model names = initial temperature
+end
+
+subsection Initial temperature model
+  set List of model names = ascii profile, harmonic perturbation
+  set List of model operators = add
+
+  subsection Ascii profile
+    set Data directory = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-profile/tests/
+    set Data file name = simple_test.txt
+  end
+
+  subsection Harmonic perturbation
+    set Magnitude = 2.0
+    set Reference temperature = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 0
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 15
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/solver_history.cc.bak b/tests/solver_history.cc.bak
new file mode 100644
index 00000000000..3d2ff3b3010
--- /dev/null
+++ b/tests/solver_history.cc.bak
@@ -0,0 +1,49 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator_signals.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+
+namespace aspect
+{
+  template <int dim>
+  void post_stokes_solver (const SimulatorAccess<dim> &,
+                           const unsigned int /*number_S_iterations*/,
+                           const unsigned int /*number_A_iterations*/,
+                           const SolverControl &/*solver_control_cheap*/,
+                           const SolverControl &/*solver_control_expensive*/)
+  {
+    std::cout << "\npost_stokes_solver:\n";
+  }
+
+
+  template <int dim>
+  void signal_connector (SimulatorSignals<dim> &signals)
+  {
+    std::cout << "Connecting signals" << std::endl;
+    signals.post_stokes_solver.connect (&post_stokes_solver<dim>);
+  }
+
+
+  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                    signal_connector<3>)
+}
diff --git a/tests/solver_history.prm.bak b/tests/solver_history.prm.bak
new file mode 100644
index 00000000000..b137a2a3cc7
--- /dev/null
+++ b/tests/solver_history.prm.bak
@@ -0,0 +1,69 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0.1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, Stokes residual
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 30
+  end
+end
diff --git a/tests/solver_scheme_no_advection_single_stokes.cc.bak b/tests/solver_scheme_no_advection_single_stokes.cc.bak
new file mode 100644
index 00000000000..033218a35c0
--- /dev/null
+++ b/tests/solver_scheme_no_advection_single_stokes.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/solver_scheme_no_advection_single_stokes.prm.bak b/tests/solver_scheme_no_advection_single_stokes.prm.bak
new file mode 100644
index 00000000000..39c34cb24d2
--- /dev/null
+++ b/tests/solver_scheme_no_advection_single_stokes.prm.bak
@@ -0,0 +1,84 @@
+# solcx test, based on no_cheap_gmg.prm to show "no Advection, single Stokes"
+# scheme works
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+  set Material averaging = harmonic average
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = SolCxPostprocessor
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/spectral_comparison.prm.bak b/tests/spectral_comparison.prm.bak
new file mode 100644
index 00000000000..ef947a04fcb
--- /dev/null
+++ b/tests/spectral_comparison.prm.bak
@@ -0,0 +1,16 @@
+# A test for the geoid, gravity and dynamic topography postprocessor
+
+set Dimension                              = 3
+
+include $ASPECT_SOURCE_DIR/benchmarks/geoid-spectral-comparison/spectral-comparison.prm
+
+
+subsection Mesh refinement
+  set Initial global refinement = 0
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps             = 200
+  end
+end
diff --git a/tests/spherical_constant_boundary_3d_sphere.prm.bak b/tests/spherical_constant_boundary_3d_sphere.prm.bak
new file mode 100644
index 00000000000..3b332afb107
--- /dev/null
+++ b/tests/spherical_constant_boundary_3d_sphere.prm.bak
@@ -0,0 +1,74 @@
+# This test ensures that the spherical constant
+# boundary composition sets the composition
+# at the surface of a sphere
+
+set Dimension                              = 2
+set End time                               = 0
+
+subsection Compositional fields
+  set Number of fields          = 1
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = spherical constant
+  set Fixed composition boundary indicators   = 0
+
+  subsection Spherical constant
+    set Outer composition = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = sphere
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 500
+  end
+end
+
+subsection Material model
+  set Model name         = simpler
+
+  subsection Simpler model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = depth
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/spherical_nsinker.cc.bak b/tests/spherical_nsinker.cc.bak
new file mode 100644
index 00000000000..19f0a384ea2
--- /dev/null
+++ b/tests/spherical_nsinker.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/nsinker_spherical_shell/nsinker.cc"
diff --git a/tests/spherical_nsinker.prm.bak b/tests/spherical_nsinker.prm.bak
new file mode 100644
index 00000000000..22621d3e4f5
--- /dev/null
+++ b/tests/spherical_nsinker.prm.bak
@@ -0,0 +1,16 @@
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/benchmarks/nsinker_spherical_shell/gmg.prm
+
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+end
+
+subsection Postprocess
+  subsection Memory statistics
+    # disable as it is not deterministic:
+    set Output peak virtual memory (VmPeak) = false
+  end
+end
diff --git a/tests/spherical_shell_initial_topography_ascii_data_3d.prm.bak b/tests/spherical_shell_initial_topography_ascii_data_3d.prm.bak
new file mode 100644
index 00000000000..898ba1a57ee
--- /dev/null
+++ b/tests/spherical_shell_initial_topography_ascii_data_3d.prm.bak
@@ -0,0 +1,93 @@
+# An input script to test the chunk geometry model
+# with additional initial topography.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = -20
+    set Chunk maximum longitude = 20
+    set Longitude repetitions = 1
+    set Chunk minimum latitude = -20
+    set Chunk maximum latitude = 20
+    set Latitude repetitions = 1
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+      set Data file name       = shell_3d_outer.0.txt
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer, east, west, north, south
+  set Zero velocity boundary indicators       = inner
+end
+
+# The ascii data file prescribes a topography between -2000 m and
+# +9000 m. The topography postprocessor output should match with this.
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables = surface elevation
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/spherical_shell_initial_topography_function_3d.prm.bak b/tests/spherical_shell_initial_topography_function_3d.prm.bak
new file mode 100644
index 00000000000..8f6e7ff86f8
--- /dev/null
+++ b/tests/spherical_shell_initial_topography_function_3d.prm.bak
@@ -0,0 +1,88 @@
+# An input script to test the spherical geometry model with additional
+# initial topography described as a function. We don't actually solve
+# for anything, but produce output that should show the topography.
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+
+  # Have a 2 km high mountain belt around the equator that decreases
+  # linearly over a (z-)distance of 2000km
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function constants = z0=2000000, H=2000
+      set Function expression = if(abs(z)<z0, H*(z0-abs(z))/z0, 0)
+      set Maximum topography value = 2000
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables = surface elevation
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/spherical_velocity_statistics.prm.bak b/tests/spherical_velocity_statistics.prm.bak
new file mode 100644
index 00000000000..85e7b318afe
--- /dev/null
+++ b/tests/spherical_velocity_statistics.prm.bak
@@ -0,0 +1,95 @@
+# like refine_vel.prm, but run the "spherical velocity statistics"
+# postprocessor
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e300
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+  set End step                  = 1
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Additional refinement times              = 0,0
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, spherical velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/spiegelman_fail_test.cc.bak b/tests/spiegelman_fail_test.cc.bak
new file mode 100644
index 00000000000..60ed8005162
--- /dev/null
+++ b/tests/spiegelman_fail_test.cc.bak
@@ -0,0 +1,678 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/simulator_access.h>
+#include <aspect/newton.h>
+#include <aspect/parameters.h>
+
+#include <iostream>
+
+#include <aspect/utilities.h>
+
+#include <aspect/material_model/interface.h>
+
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    using namespace dealii;
+
+    /**
+     * The same material model as Drucker Prager, but this one supports multiple
+     * compositions in a way to reproduce the Spiegelman 2016 paper.
+     *
+     * The model is considered incompressible, following the definition
+     * described in Interface::is_compressible.
+     *
+     * The viscosity is computed according to the Drucker Prager frictional
+     * plasticity criterion based on a user-defined internal angle of friction $\phi$
+     * and cohesion $C$. In 3D:
+     * $\sigma_y = \frac{6 C \cos(\phi)}{\sqrt(3) (3+\sin(\phi))} +
+     * \frac{6 P \sin(\phi)}{\sqrt(3) (3+\sin(\phi))}$,
+     * where $P$ is the pressure.
+     * See for example Zienkiewicz, O. C., Humpheson, C. and Lewis, R. W. (1975),
+     * G&eacute;otechnique 25, No. 4, 671-689.
+     * With this formulation we circumscribe instead of inscribe the Mohr Coulomb
+     * yield surface.
+     * In 2D the Drucker Prager yield surface is the same
+     * as the Mohr Coulomb surface:
+     * $\sigma_y = P \sin(\phi) + C \cos(\phi)$.
+     * Note that in 2D for $\phi=0$, these criteria
+     * revert to the von Mises criterion (no pressure dependence).
+     * See for example Thieulot, C. (2011), PEPI 188, 47-68.
+     *
+     * Note that we enforce the pressure to be positive in the computation of
+     * the yield strength by replacing it with
+     * a zero value whenever it is negative to prevent negative
+     * yield strengths and viscosities.
+     * We then use the computed yield strength to scale back the viscosity on
+     * to the yield surface using the Viscosity Rescaling Method described in
+     * Kachanov, L. M. (2004), Fundamentals of the Theory of Plasticity,
+     * Dover Publications, Inc.
+     *
+     * To avoid numerically unfavourably large (or even negative) viscosity ranges,
+     * we regularize the viscosity by $\eta_{\text{eff}} = \eta_{\text{ref}} * \eta
+     * / (\eta_{\text{ref}} + \eta)$. Furthermore,
+     * we cut off the viscosity with a user-defined minimum and maximum viscosity:
+     * $\eta_eff = \frac{1}{\frac{1}{\eta_min + \eta}+
+     * \frac{1}{\eta_max}}$.
+     *
+     * Note that this model uses the formulation that assumes an incompressible
+     * medium despite the fact that the density follows the law
+     * $\rho(T)=\rho_0(1-\beta(T-T_{\text{ref}}))$.
+     *
+     *
+     * @ingroup MaterialModels
+     */
+
+    template <int dim>
+    class SpiegelmanMaterial : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        double compute_second_invariant(const SymmetricTensor<2,dim> strain_rate, const double min_strain_rate) const;
+
+        double compute_viscosity(const double edot_ii,const double pressure,const int comp, const double constant_viscosity,const bool compute_full_viscosity, const double min_visc, const double max_visc) const;
+
+        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                              MaterialModel::MaterialModelOutputs<dim> &out) const;
+
+        /**
+         * Return whether the model is compressible or not.  Incompressibility
+         * does not necessarily imply that the density is constant; rather, it
+         * may still depend on temperature or pressure. In the current
+         * context, compressibility means whether we should solve the continuity
+         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
+         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
+         *
+         * This material model is incompressible.
+         */
+        virtual bool is_compressible () const;
+
+        virtual double reference_density () const;
+
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+
+      private:
+
+        double reference_T;
+
+
+        /**
+         * Whether or not to use the deviator of the strain-rate in the
+         * viscosity calculation.
+         */
+        bool use_deviator_of_strain_rate;
+
+        /**
+         * Defining a minimum strain rate stabilizes the viscosity calculation,
+         * which involves a division by the strain rate. Units: $\\si{\\per\\second}$.
+         */
+        std::vector<double> min_strain_rate;
+        std::vector<double> min_visc;
+        std::vector<double> max_visc;
+        std::vector<double> veff_coefficient;
+        double ref_visc;
+        double reference_compressibility;
+        std::vector<double> ref_visc_list;
+
+        std::vector<double> thermal_diffusivity;
+        std::vector<double> heat_capacity;
+
+
+        std::vector<double> densities;
+        std::vector<double> thermal_expansivities;
+
+        std::vector<double> cohesion;
+        std::vector<double> phi;
+
+        /**
+         * The friction angles phi for each of the compositional fields. Since we use their
+         * sines and cosines a lot, we only compute these values (for each of the phis) once
+         * and cache them.
+         */
+        std::vector<double> sin_phi;
+        std::vector<double> cos_phi;
+
+        std::vector<double> constant_viscosity;
+
+        unsigned int n_fields;
+
+        /**
+         * This parameter is used in the averaging of the  of the different compositions.
+         * It is implemented as a generalized mean, where p < -1000 is the minimum, p ==-1
+         * is the harmonic average, p == 0 is the geometric average, p == 1 is the arithmetic
+         * average and p > 1000 is the maximum.
+         */
+        double viscosity_averaging_p;
+
+        /**
+         * This value determines whether to use the analytical or the
+         * finite difference derivative for the Newton solver. Although
+         * the analytical derivative should be much faster to compute, the
+         * finite difference derivative can be useful when changing the
+         * rheology.
+         */
+        bool use_analytical_derivative;
+    };
+
+  }
+
+
+  namespace
+  {
+    std::vector<double>
+    get_vector_double (const std::string &parameter, const unsigned int n_fields, ParameterHandler &prm)
+    {
+      std::vector<double> parameter_list;
+      parameter_list = Utilities::string_to_double(Utilities::split_string_list(prm.get (parameter)));
+      if (parameter_list.size() == 1)
+        parameter_list.resize(n_fields, parameter_list[0]);
+
+      AssertThrow(parameter_list.size() == n_fields,
+                  ExcMessage("Length of " + parameter + " list (size "+ std::to_string(parameter_list.size()) +") must be either one,"
+                             " or n_compositional_fields+1 (= " + std::to_string(n_fields) + ")."));
+
+      return parameter_list;
+    }
+  }
+
+  namespace MaterialModel
+  {
+    template <int dim>
+    double
+    SpiegelmanMaterial<dim>::
+    compute_second_invariant(const SymmetricTensor<2,dim> strain_rate, const double min_strain_rate) const
+    {
+      const double edot_ii_strict = std::sqrt(strain_rate*strain_rate);
+      const double edot_ii = std::max(edot_ii_strict, min_strain_rate);
+      return edot_ii;
+    }
+
+    template <int dim>
+    double
+    SpiegelmanMaterial<dim>::
+    compute_viscosity(const double edot_ii,
+                      const double pressure,
+                      const int comp,
+                      const double constant_viscosity,
+                      const bool compute_full_viscosity,
+                      const double min_visc,
+                      const double max_visc) const
+    {
+      double viscosity;
+
+      if (constant_viscosity == 0)
+        {
+          const double strength = ( (dim==3)
+                                    ?
+                                    ( 6.0 * cohesion[comp] * cos_phi[comp] + 6.0 * std::max(pressure,0.0) * sin_phi[comp] )
+                                    / ( std::sqrt(3) * ( 3.0 + sin_phi[comp] ) )
+                                    :
+                                    cohesion[comp] * cos_phi[comp] + std::max(pressure,0.0) * sin_phi[comp] );
+
+          // Rescale the viscosity back onto the yield surface
+          if (strength != 0 && edot_ii != 0)
+            viscosity = strength / ( 2.0 * std::sqrt(0.5) * edot_ii );
+          else
+            viscosity = ref_visc;
+
+          if (compute_full_viscosity == true)
+            viscosity = ref_visc * viscosity / (ref_visc + viscosity);
+        }
+      else
+        {
+          viscosity = constant_viscosity;
+        }
+
+      if (compute_full_viscosity == true)
+        return std::max(std::min(viscosity, max_visc), min_visc);
+      else
+        return viscosity;
+    }
+
+    template <int dim>
+    void
+    SpiegelmanMaterial<dim>::
+    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+             MaterialModel::MaterialModelOutputs<dim> &out) const
+    {
+      //set up additional output for the derivatives
+      MaterialModelDerivatives<dim> *derivatives;
+      derivatives = out.template get_additional_output<MaterialModelDerivatives<dim>>();
+
+      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
+        {
+          const double temperature = in.temperature[i];
+          const double pressure = in.pressure[i];
+
+          // Averaging composition-field dependent properties
+          // Compositions
+          //This assert may be help when designing tests for this material model
+          AssertThrow(in.composition[i].size()+1 == n_fields,
+                      ExcMessage("Number of compositional fields + 1 not equal to number of fields given in input file."));
+
+          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
+          double density = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            {
+              const double temperature_factor = (1 - thermal_expansivities[c] * (temperature - reference_T));
+              density += volume_fractions[c] * densities[c] * std::exp(reference_compressibility * pressure) * temperature_factor;
+            }
+
+          // thermal expansivities
+          double thermal_expansivity = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            thermal_expansivity += volume_fractions[c] * thermal_expansivities[c];
+
+          // Specific heat at the given positions.
+          double specific_heat = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            specific_heat += volume_fractions[c] * heat_capacity[c];
+
+          // Thermal conductivity at the given positions.
+          double thermal_conductivities = 0.0;
+          for (unsigned int c=0; c < volume_fractions.size(); ++c)
+            thermal_conductivities += volume_fractions[c] * thermal_diffusivity[c] * heat_capacity[c] * densities[c];
+
+          // calculate effective viscosity
+          if (in.requests_property(MaterialProperties::viscosity))
+            {
+              // This function calculates viscosities assuming that all the compositional fields
+              // experience the same strain rate (isostrain). Since there is only one process in
+              // this material model (a general powerlaw) we do not need to worry about how to
+              // distribute the strain-rate and stress over the processes.
+              std::vector<double> composition_viscosities(volume_fractions.size());
+              std::vector<SymmetricTensor<2,dim>> composition_viscosities_derivatives(volume_fractions.size());
+              std::vector<double> composition_dviscosities_dpressure(volume_fractions.size());
+
+              const SymmetricTensor<2,dim> edot = use_deviator_of_strain_rate ? deviator(in.strain_rate[i]) : in.strain_rate[i];
+
+              for (unsigned int c=0; c < volume_fractions.size(); ++c)
+                {
+                  // If strain rate is zero (like during the first time step) set it to some very small number
+                  // to prevent a division-by-zero, and a floating point exception.
+                  // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
+                  // strain rate (often simplified as epsilondot_ii)
+
+                  const double edot_ii = compute_second_invariant(edot, min_strain_rate[c]);
+
+                  // Find effective viscosities for each of the individual phases
+                  // Viscosities should have same number of entries as compositional fields
+
+                  // Regularized Drucker Prager viscosity (see Spiegelman et al, 2016)
+                  composition_viscosities[c] = compute_viscosity(edot_ii,pressure,c,constant_viscosity[c],true,min_visc[c],max_visc[c]);
+
+                  Assert(dealii::numbers::is_finite(composition_viscosities[c]),ExcMessage ("Error: Viscosity is not finite."));
+
+                  if (derivatives != nullptr)
+                    {
+                      if (use_analytical_derivative)
+                        {
+                          //analytic
+                          if (constant_viscosity[c] == 0  && composition_viscosities[c] <= max_visc[c] && composition_viscosities[c] >= min_visc[c])
+                            {
+                              // we only want the pure durcker prager here, so the regularization should be off and the min and max values should not be used.
+                              // Therefore we set the compute_full_viscosity flag to false. The min and max viscosity values  won't be used with this flag,
+                              // so we enter dummy values.
+                              const double drucker_prager_viscosity = compute_viscosity(edot_ii,pressure,c,constant_viscosity[c],false,std::numeric_limits<double>::min(),std::numeric_limits<double>::max());
+                              const double regularization_adjustment = (ref_visc * ref_visc)
+                                                                       / (ref_visc * ref_visc + 2.0 * ref_visc * drucker_prager_viscosity
+                                                                          + drucker_prager_viscosity * drucker_prager_viscosity);
+
+                              composition_viscosities_derivatives[c] = -regularization_adjustment *
+                                                                       (drucker_prager_viscosity / (edot_ii * edot_ii)) * edot;
+
+                              if (use_deviator_of_strain_rate == true)
+                                composition_viscosities_derivatives[c] = composition_viscosities_derivatives[c] * deviator_tensor<dim>();
+
+                              composition_dviscosities_dpressure[c] = regularization_adjustment *
+                                                                      ((dim == 3)
+                                                                       ?
+                                                                       6 * sin_phi[c] / (std::sqrt(3) * (3.0 + sin_phi[c]) * 2.0 * std::sqrt(0.5) * edot_ii)
+                                                                       :
+                                                                       sin_phi[c] / (2.0 * std::sqrt(0.5) * edot_ii));
+                            }
+                          else
+                            {
+                              composition_viscosities_derivatives[c] = 0;
+                              composition_dviscosities_dpressure[c] = 0;
+                            }
+                        }
+                      else
+                        {
+                          // finite difference
+                          const double finite_difference_accuracy = 1e-7;
+                          // For each independent component, compute the derivative.
+                          for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
+                            {
+                              // compute which of the independent index of the strain-rate tensor we are now looking at.
+                              const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
+
+                              // add a small difference to one independent component of the strain-rate tensor
+                              const SymmetricTensor<2,dim> strain_rate_difference_plus = edot + std::max(edot_ii, min_strain_rate[c]) * finite_difference_accuracy
+                                                                                         * Utilities::nth_basis_for_symmetric_tensors<dim>(component);
+                              const double second_invariant_strain_rate_difference_plus = compute_second_invariant(strain_rate_difference_plus, min_strain_rate[c]);
+                              const double eta_component_plus = compute_viscosity(second_invariant_strain_rate_difference_plus,pressure,c,constant_viscosity[c],true,min_visc[c],max_visc[c]);
+
+                              // compute the difference between the viscosity with and without the strain-rate difference.
+                              double viscosity_derivative = eta_component_plus - composition_viscosities[c];
+                              if (viscosity_derivative != 0)
+                                {
+                                  // when the difference is non-zero, divide by the difference.
+                                  viscosity_derivative /= std::max(edot_ii, min_strain_rate[c]) * finite_difference_accuracy;
+                                }
+
+                              composition_viscosities_derivatives[c][strain_rate_indices] = viscosity_derivative;
+                            }
+
+                          /**
+                           * Now compute the finite difference derivative of the viscoisty to the pressure
+                           */
+                          double pressure_difference = in.pressure[i] + (std::fabs(in.pressure[i]) * finite_difference_accuracy);
+
+                          double pressure_difference_eta = compute_viscosity(edot_ii, pressure_difference,c,constant_viscosity[c],true,min_visc[c],max_visc[c]);
+                          double deriv_pressure = pressure_difference_eta - composition_viscosities[c];
+
+
+                          if (pressure_difference_eta != 0)
+                            {
+                              if (in.pressure[i] != 0)
+                                {
+                                  deriv_pressure /= std::fabs(in.pressure[i]) * finite_difference_accuracy;
+                                }
+                              else
+                                {
+                                  deriv_pressure = 0;
+                                }
+                            }
+
+                          composition_dviscosities_dpressure[c] = deriv_pressure;
+                        }
+                    }
+                }
+              out.viscosities[i] = Utilities::weighted_p_norm_average(volume_fractions, composition_viscosities, viscosity_averaging_p);
+              Assert(dealii::numbers::is_finite(out.viscosities[i]),ExcMessage ("Error: Averaged viscosity is not finite."));
+
+              if (derivatives != nullptr)
+                {
+                  derivatives->viscosity_derivative_wrt_strain_rate[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_viscosities_derivatives, viscosity_averaging_p);
+                  derivatives->viscosity_derivative_wrt_pressure[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_dviscosities_dpressure, viscosity_averaging_p);
+
+                  Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_pressure[i]),
+                         ExcMessage ("Error: Averaged dviscosities_dpressure is not finite."));
+
+                  for (int x = 0; x < dim; ++x)
+                    for (int y = 0; y < dim; ++y)
+                      Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]),
+                             ExcMessage ("Error: Averaged dviscosities_dstrain_rate is not finite."));
+                }
+            }
+          out.densities[i] = density;
+          out.thermal_expansion_coefficients[i] = thermal_expansivity;
+          // Specific heat at the given positions.
+          out.specific_heat[i] = specific_heat;
+          // Thermal conductivity at the given positions.
+          out.thermal_conductivities[i] = thermal_conductivities;
+          // Compressibility at the given positions.
+          // The compressibility is given as
+          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
+          out.compressibilities[i] = reference_compressibility;
+          // Pressure derivative of entropy at the given positions.
+          out.entropy_derivative_pressure[i] = 0.0;
+          // Temperature derivative of entropy at the given positions.
+          out.entropy_derivative_temperature[i] = 0.0;
+          // Change in composition due to chemical reactions at the
+          // given positions. The term reaction_terms[i][c] is the
+          // change in compositional field c at point i.
+          for (unsigned int c=0; c < in.composition[i].size(); ++c)
+            out.reaction_terms[i][c] = 0.0;
+        }
+    }
+
+    template <int dim>
+    double
+    SpiegelmanMaterial<dim>::
+    reference_density () const
+    {
+      return densities[0];
+    }
+
+    template <int dim>
+    bool
+    SpiegelmanMaterial<dim>::
+    is_compressible () const
+    {
+      return (reference_compressibility != 0);
+    }
+
+    template <int dim>
+    void
+    SpiegelmanMaterial<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Compositional fields");
+      {
+        prm.declare_entry ("Number of fields", "0",
+                           Patterns::Integer (0),
+                           "The number of fields that will be advected along with the flow field, excluding "
+                           "velocity, pressure and temperature.");
+
+        // temperature and density parameters
+        prm.declare_entry ("List of conductivities", "2.25",
+                           Patterns::List (Patterns::Double(0)),
+                           "A list of thermal conductivities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("List of capacities", "1250",
+                           Patterns::List (Patterns::Double(0)),
+                           "A list of heat capacities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("Thermal expansivities", "3.5e-5",
+                           Patterns::List(Patterns::Double(0)),
+                           "List of thermal expansivities for background mantle and compositional fields, "
+                           "for a total of N+1 values, where N is the number of compositional fields. "
+                           "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}");
+        prm.declare_entry ("List of reference densities", "2700",
+                           Patterns::List (Patterns::Double(0)),
+                           "A list of reference densities equal to the number of "
+                           "compositional fields.");
+
+        // visocosity parameters
+        prm.declare_entry ("List of cohesions", "1e20",
+                           Patterns::List (Patterns::Double(0)),
+                           "A list of initial viscosities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("List of angles of internal friction", "30",
+                           Patterns::List (Patterns::Double(0)),
+                           "A list of initial viscosities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("List of initial viscosities", "1e21",
+                           Patterns::List (Patterns::Double(0)),
+                           "A list of initial viscosities equal to the number of "
+                           "compositional fields.");
+        prm.declare_entry ("List of constant viscosities", "0",
+                           Patterns::List (Patterns::Double(0)),
+                           "A list of viscous viscosities equal to the number of "
+                           "compositional fields. When it is zero, the Drucker Prager "
+                           "rheology is used, when it is nonzero, it sets the viscosity "
+                           "with the set value.");
+
+      }
+      prm.leave_subsection();
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Spiegelman 2016");
+        {
+          // Reference and minimum/maximum values
+          prm.declare_entry ("Reference temperature", "293", Patterns::Double(0),
+                             "For calculating density by thermal expansivity. Units: \\si{\\kelvin}");
+          prm.declare_entry ("Minimum strain rate", "1.96e-40", Patterns::List(Patterns::Double(0)),
+                             "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}");
+          prm.declare_entry ("Minimum viscosity", "1e10", Patterns::List(Patterns::Double(0)),
+                             "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Maximum viscosity", "1e28", Patterns::List(Patterns::Double(0)),
+                             "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
+          prm.declare_entry ("Effective viscosity coefficient", "1.0", Patterns::List(Patterns::Double(0)),
+                             "Scaling coefficient for effective viscosity.");
+          prm.declare_entry ("Reference viscosity", "1e22", Patterns::List(Patterns::Double(0)),
+                             "Reference viscosity for nondimensionalization. Units $Pa s$");
+          prm.declare_entry ("Reference compressibility", "4e-12", Patterns::Double (0),
+                             "The value of the reference compressibility. Units: \\si{\\per\\pascal}.");
+
+          // averaging parameters
+          prm.declare_entry ("Viscosity averaging p", "-1",
+                             Patterns::Double(),
+                             "This is the p value in the generalized weighed average eqation: "
+                             " mean = \\frac{1}{k}(\\sum_{i=1}^k \\big(c_i \\eta_{\\text{eff}_i}^p)\\big)^{\\frac{1}{p}}. "
+                             " Units: \\si{\\pascal\\second}");
+
+          // finite difference versus analytical
+          prm.declare_entry ("Use analytical derivative", "true",
+                             Patterns::Bool(),
+                             "This value determines whether to use the analytical or the finite difference derivative "
+                             "for the Newton solver. Although the analytical derivative should be much faster to compute, "
+                             "the finite difference derivative can be useful when changing the rheology.");
+
+          prm.declare_entry ("Use deviator of strain-rate", "true",
+                             Patterns::Bool(),
+                             "Whether or not to use the deviator of the strain-rate in the viscosity calculation.");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+
+
+    template <int dim>
+    void
+    SpiegelmanMaterial<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      using namespace Utilities;
+      // can't use this->n_compositional_fields(), because some
+      // tests never initiate the simulator, but uses the material
+      // model directly.
+      prm.enter_subsection ("Compositional fields");
+      {
+        n_fields = prm.get_integer ("Number of fields")+1;
+
+        // temperature and density parameters
+        thermal_diffusivity = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of conductivities"))),
+                                                          n_fields,
+                                                          "List of conductivities");
+        heat_capacity = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of capacities"))),
+                                                    n_fields,
+                                                    "List of capacities");
+        densities = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of reference densities"))),
+                                                n_fields,
+                                                "List of refdens");
+        thermal_expansivities = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("Thermal expansivities"))),
+                                                            n_fields,
+                                                            "Thermal expansivities");
+
+        // Rheological parameters
+        cohesion = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of cohesions"))),
+                                               n_fields,
+                                               "List of cohesions");
+        phi = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of angles of internal friction"))),
+                                          n_fields,
+                                          "List of angles of internal friction");
+
+
+        // Todo: make use of the initial viscosity
+        ref_visc_list = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of initial viscosities"))),
+                                                    n_fields,
+                                                    "List of initial viscosities");
+
+        sin_phi.resize(n_fields);
+        cos_phi.resize(n_fields);
+        for (unsigned int c = 0; c < n_fields; ++c)
+          {
+            sin_phi[c] = std::sin(phi[c] * constants::degree_to_radians);
+            cos_phi[c] = std::cos(phi[c] * constants::degree_to_radians);
+          }
+
+        constant_viscosity = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of constant viscosities"))),
+                                                         n_fields,
+                                                         "List of constant viscosities");
+      }
+      prm.leave_subsection();
+
+      prm.enter_subsection("Material model");
+      {
+        prm.enter_subsection ("Spiegelman 2016");
+        {
+
+          // Reference and minimum/maximum values
+          reference_T = prm.get_double("Reference temperature");
+          ref_visc = prm.get_double ("Reference viscosity");
+          min_strain_rate = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("Minimum strain rate"))),
+                                                        n_fields,
+                                                        "Minimum strain rate");
+          min_visc = get_vector_double ("Minimum viscosity",n_fields,prm);
+          max_visc = get_vector_double ("Maximum viscosity",n_fields,prm);
+          veff_coefficient = get_vector_double ("Effective viscosity coefficient",n_fields,prm);
+          reference_compressibility  = prm.get_double ("Reference compressibility");
+          use_deviator_of_strain_rate = prm.get_bool ("Use deviator of strain-rate");
+
+
+          // averaging parameters
+          viscosity_averaging_p = prm.get_double("Viscosity averaging p");
+
+          use_analytical_derivative = prm.get_bool("Use analytical derivative");
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+
+
+      // Declare dependencies on solution variables
+      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
+      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+      this->model_dependence.compressibility = NonlinearDependence::none;
+      this->model_dependence.specific_heat = NonlinearDependence::none;
+      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
+    }
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace MaterialModel
+  {
+    ASPECT_REGISTER_MATERIAL_MODEL(SpiegelmanMaterial,
+                                   "spiegelman 2016",
+                                   "An implementation of the spiegelman 2016 benchmark paper in gcubed "
+                                   "(doi:10.1002/ 2015GC006228). It implements a regularized Drucker Prager "
+                                   "material (when the parameter constant viscosity is 0) and a linear material "
+                                   "(when the parameter constant viscosity is not 0), which are both needed to "
+                                   "implement the Spiegelman benchmark. The derivatives for the Newton solver "
+                                   "have been implemented for this material model.")
+  }
+}
diff --git a/tests/spiegelman_fail_test.prm.bak b/tests/spiegelman_fail_test.prm.bak
new file mode 100644
index 00000000000..d3ec4a45b69
--- /dev/null
+++ b/tests/spiegelman_fail_test.prm.bak
@@ -0,0 +1,129 @@
+# This is the most difficult case of the Spiegelman benchmark. The
+# goal of this test is to show that the linear Newton solver fails
+# when the matrix becomes non Symmetric Positive Definite, and
+# is safed by forcing the matrix to be SPD. In the next timestep
+# the stabilization is reset to the user defined values.
+
+set Additional shared libraries = ../tests/libspiegelman_fail_test.so
+set Output directory = output/
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = iterated Advection and Newton Stokes
+set Max nonlinear iterations = 4
+set Nonlinear solver tolerance = 1e-14
+set Pressure normalization = no
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+    set Linear solver tolerance = 9e-1
+    set Stokes solver type = block AMG
+  end
+
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 2
+    set SPD safety factor = 9e-1
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 0
+    set Maximum linear Stokes solver tolerance = 9e-1
+    set Use Newton residual scaling method = false
+    set Use Newton failsafe = true
+    set Stabilization preconditioner = none
+    set Stabilization velocity block = none
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,z
+    set Function constants = H = 30e3
+    set Function expression = if(z < 0.25 * H,1, \
+if(z < (0.25+(1/12)-0.02)*H & x > (2-(1/12))*H & x < (2+(1/12))*H,1, \
+if(z < (0.25+(1/12))*H & (x > (2-(1/12)+0.02)*H & x < (2+(1/12)-0.02)*H | (x-(2-(1/12)+0.02)*H)^2 + (z-(0.25+(1/12)-0.02)*H)^2 < (0.02*H)^2 | (x-(2+(1/12)-0.02)*H)^2 + (z-(0.25+(1/12)-0.02)*H)^2 < (0.02*H)^2),1, \
+if(z < (0.25+0.02)*H && x > (2-(1/12)-0.02)*H && x < (2+(1/12)+0.02)*H && ((x-(2-(1/12)-0.02)*H)^2 + (z-(0.25+0.02)*H)^2 > (0.02*H)^2 && (x-(2+(1/12)+0.02)*H)^2 + (z-(0.25+0.02)*H)^2 > (0.02*H)^2),1,0))))
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 120e3
+    set Y extent = 30e3
+    set X repetitions = 4
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set List of conductivities                         = 2.25,   2.25
+  set List of capacities                             = 1250,   1250
+  set List of reference densities                    = 2700.0, 2700.0
+  set List of cohesions                              = 1e8,    0
+  set List of angles of internal friction            = 30,     0
+  set List of initial viscosities                    = 1e20,   1e21
+  set List of constant viscosities                   = 0,      1e21
+end
+
+subsection Material model
+  set Model name = spiegelman 2016
+  set Material averaging = none
+
+  subsection Spiegelman 2016
+    set Maximum viscosity = 1e24
+    set Minimum viscosity = 1e21
+    set Use deviator of strain-rate = false
+    set Viscosity averaging p = -1
+    set Use analytical derivative     = false
+    set Reference viscosity = 5e24
+    set Reference compressibility = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Strategy =  strain rate
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 2
+  set Prescribed velocity boundary indicators = 0 x:function,1 x:function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = if(x<60e3,3.96109558e-10,-3.96109558e-10);0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties,strain rate, spd factor
+    set Interpolate output = false
+  end
+end
diff --git a/tests/spiegelman_material.cc.bak b/tests/spiegelman_material.cc.bak
new file mode 100644
index 00000000000..5650b030bd8
--- /dev/null
+++ b/tests/spiegelman_material.cc.bak
@@ -0,0 +1,303 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../tests/spiegelman_fail_test.cc"
+
+int f(double parameter)
+{
+
+  std::cout << std::endl << "Test for p = " << parameter << std::endl;
+
+  const int dim=2;
+  using namespace aspect::MaterialModel;
+  MaterialModelInputs<dim> in_base(5,3);
+  in_base.composition[0][0] = 0;
+  in_base.composition[0][1] = 0;
+  in_base.composition[0][2] = 0;
+  in_base.composition[1][0] = 0.75;
+  in_base.composition[1][1] = 0.15;
+  in_base.composition[1][2] = 0.10;
+  in_base.composition[2][0] = 0;
+  in_base.composition[2][1] = 0.2;
+  in_base.composition[2][2] = 0.4;
+  in_base.composition[3][0] = 0;
+  in_base.composition[3][1] = 0.2;
+  in_base.composition[3][2] = 0.4;
+  in_base.composition[4][0] = 1;
+  in_base.composition[4][1] = 0;
+  in_base.composition[4][2] = 0;
+
+  in_base.pressure[0] = 1e9;
+  in_base.pressure[1] = 5e9;
+  in_base.pressure[2] = 2e10;
+  in_base.pressure[3] = 2e11;
+  in_base.pressure[4] = 2e12;
+
+  /**
+   * We can't take to small strain-rates, because then the difference in the
+   * viscosity will be too small for the double accuracy which stores
+   * the viscosity solutions and the finite difference solution.
+   */
+  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
+  in_base.strain_rate[0][0][0] = 1e-12;
+  in_base.strain_rate[0][0][1] = 1e-12;
+  in_base.strain_rate[0][1][1] = 1e-11;
+  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[1][0][0] = -1.71266e-13;
+  in_base.strain_rate[1][0][1] = -5.82647e-12;
+  in_base.strain_rate[1][1][1] = 4.21668e-14;
+  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[2][1][1] = 1e-13;
+  in_base.strain_rate[2][0][1] = 1e-11;
+  in_base.strain_rate[2][0][0] = -1e-12;
+  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[3][1][1] = 1e-22;
+  in_base.strain_rate[3][0][1] = 1e-22;
+  in_base.strain_rate[3][0][0] = -1e-22;
+  /**
+   * We can get it working with these values:
+   *
+   * in_base.strain_rate[3][1][1] = 9e-16;
+   * in_base.strain_rate[3][0][1] = 9e-16;
+   * in_base.strain_rate[3][0][0] = -9e-16;
+   *
+   * With very low strain-rates the differences between the finite difference and
+   * analytical solution grow. We  interpent this as that the finite difference
+   * method we use becomes unaccurate for very low strain-rates.
+   */
+  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[4][1][1] = 1e-11;
+  in_base.strain_rate[4][0][1] = 1e-11;
+  in_base.strain_rate[4][0][0] = 1e-11;
+
+  in_base.temperature[0] = 293;
+  in_base.temperature[1] = 1600;
+  in_base.temperature[2] = 2000;
+  in_base.temperature[3] = 2100;
+  in_base.temperature[4] = 2200;
+
+  SymmetricTensor<2,dim> zerozero = SymmetricTensor<2,dim>();
+  SymmetricTensor<2,dim> onezero = SymmetricTensor<2,dim>();
+  SymmetricTensor<2,dim> oneone = SymmetricTensor<2,dim>();
+
+  zerozero[0][0] = 1;
+  onezero[1][0]  = 0.5; // because symmetry doubles this entry
+  oneone[1][1]   = 1;
+
+  double finite_difference_accuracy = 1e-7;
+  double finite_difference_factor = 1+finite_difference_accuracy;
+
+  bool Error = false;
+
+  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
+  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
+
+  MaterialModelInputs<dim> in_dviscositydstrainrate_zerozero(in_base);
+  MaterialModelInputs<dim> in_dviscositydstrainrate_onezero(in_base);
+  MaterialModelInputs<dim> in_dviscositydstrainrate_oneone(in_base);
+
+  in_dviscositydstrainrate_zerozero.strain_rate[0] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[0][0][0]) * finite_difference_accuracy * zerozero;
+  in_dviscositydstrainrate_zerozero.strain_rate[1] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[1][0][0]) * finite_difference_accuracy * zerozero;
+  in_dviscositydstrainrate_zerozero.strain_rate[2] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[2][0][0]) * finite_difference_accuracy * zerozero;
+  in_dviscositydstrainrate_zerozero.strain_rate[3] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[3][0][0]) * finite_difference_accuracy * zerozero;
+  in_dviscositydstrainrate_zerozero.strain_rate[4] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[4][0][0]) * finite_difference_accuracy * zerozero;
+  in_dviscositydstrainrate_onezero.strain_rate[0]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[0][1][0]) * finite_difference_accuracy * onezero;
+  in_dviscositydstrainrate_onezero.strain_rate[1]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[1][1][0]) * finite_difference_accuracy * onezero;
+  in_dviscositydstrainrate_onezero.strain_rate[2]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[2][1][0]) * finite_difference_accuracy * onezero;
+  in_dviscositydstrainrate_onezero.strain_rate[3]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[3][1][0]) * finite_difference_accuracy * onezero;
+  in_dviscositydstrainrate_onezero.strain_rate[4]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[4][1][0]) * finite_difference_accuracy * onezero;
+  in_dviscositydstrainrate_oneone.strain_rate[0]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[0][1][1]) * finite_difference_accuracy * oneone;
+  in_dviscositydstrainrate_oneone.strain_rate[1]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[1][1][1]) * finite_difference_accuracy * oneone;
+  in_dviscositydstrainrate_oneone.strain_rate[2]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[2][1][1]) * finite_difference_accuracy * oneone;
+  in_dviscositydstrainrate_oneone.strain_rate[3]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[3][1][1]) * finite_difference_accuracy * oneone;
+  in_dviscositydstrainrate_oneone.strain_rate[4]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[4][1][1]) * finite_difference_accuracy * oneone;
+
+  MaterialModelInputs<dim> in_dviscositydtemperature(in_base);
+  in_dviscositydtemperature.temperature[0] *= 1.0000000001;
+  in_dviscositydtemperature.temperature[1] *= 1.0000000001;
+  in_dviscositydtemperature.temperature[2] *= 1.0000000001;
+  in_dviscositydtemperature.temperature[3] *= 1.0000000001;
+  in_dviscositydtemperature.temperature[4] *= 1.0000000001;
+
+
+  MaterialModelOutputs<dim> out_base(5,3);
+
+  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
+  MaterialModelOutputs<dim> out_dviscositydstrainrate_zerozero(5,3);
+  MaterialModelOutputs<dim> out_dviscositydstrainrate_onezero(5,3);
+  MaterialModelOutputs<dim> out_dviscositydstrainrate_oneone(5,3);
+  MaterialModelOutputs<dim> out_dviscositydtemperature(5,3);
+
+  if (out_base.get_additional_output<MaterialModelDerivatives<dim>>() != nullptr)
+    throw "error";
+
+  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
+
+  SpiegelmanMaterial<dim> mat;
+  ParameterHandler prm;
+  mat.declare_parameters(prm);
+
+  prm.enter_subsection("Compositional fields");
+  {
+    prm.set("Number of fields","3");
+    prm.set("List of conductivities","2.25");
+    prm.set("List of capacities","1250");
+    prm.set("List of reference densities","2700.0");
+    prm.set("List of cohesions","1e8,0,1e8,1e8");
+    prm.set("List of angles of internal friction","30.0");
+    prm.set("List of initial viscosities","1e20");
+    prm.set("List of constant viscosities","0,1e21,0,0");
+  }
+  prm.leave_subsection();
+  prm.enter_subsection("Material model");
+  {
+    prm.enter_subsection ("Spiegelman 2016");
+    {
+      prm.set("Use deviator of strain-rate", "false");
+      prm.set("Use analytical derivative", "true");
+      prm.set ("Viscosity averaging p", std::to_string(parameter));
+    }
+    prm.leave_subsection();
+  }
+  prm.leave_subsection();
+
+  mat.parse_parameters(prm);
+
+  mat.evaluate(in_base, out_base);
+  mat.evaluate(in_dviscositydpressure, out_dviscositydpressure);
+  mat.evaluate(in_dviscositydstrainrate_zerozero, out_dviscositydstrainrate_zerozero);
+  mat.evaluate(in_dviscositydstrainrate_onezero, out_dviscositydstrainrate_onezero);
+  mat.evaluate(in_dviscositydstrainrate_oneone, out_dviscositydstrainrate_oneone);
+  mat.evaluate(in_dviscositydtemperature, out_dviscositydtemperature);
+
+  //set up additional output for the derivatives
+  MaterialModelDerivatives<dim> *derivatives;
+  derivatives = out_base.get_additional_output<MaterialModelDerivatives<dim>>();
+
+  double temp;
+  for (unsigned int i = 0; i < 5; i++)
+    {
+      // prevent division by zero. If it is zero, the test has passed, because or
+      // the finite difference and the analytical result match perfectly, or (more
+      // likely) the material model in independent of this variable.
+      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
+      if (in_base.pressure[i] != 0)
+        {
+          temp /= (in_base.pressure[i] * finite_difference_accuracy);
+        }
+
+      std::cout << "pressure on quadrature point " << i << ": Finite difference = " << temp << ". Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i] << std::endl;
+      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * 0.5 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
+        {
+          std::cout << "Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
+          Error = true;
+        }
+
+    }
+
+  for (unsigned int i = 0; i < 5; i++)
+    {
+      // prevent division by zero. If it is zero, the test has passed, because or
+      // the finite difference and the analytical result match perfectly, or (more
+      // likely) the material model in independent of this variable.
+      temp = out_dviscositydstrainrate_zerozero.viscosities[i] - out_base.viscosities[i];
+      if (temp != 0)
+        {
+          temp /= std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[i][0][0]) * finite_difference_accuracy;
+        }
+      std::cout << "zerozero on quadrature point " << i << ": Finite difference = " << temp << ". Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][0][0] << std::endl;
+      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][0][0]) > 1e-3 * 0.5 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][0][0])))
+        {
+          std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
+          Error = true;
+        }
+
+
+
+    }
+
+  for (unsigned int i = 0; i < 5; i++)
+    {
+      // prevent division by zero. If it is zero, the test has passed, because or
+      // the finite difference and the analytical result match perfectly, or (more
+      // likely) the material model in independent of this variable.
+      temp = out_dviscositydstrainrate_onezero.viscosities[i] - out_base.viscosities[i];
+      if (temp != 0)
+        {
+          temp /= std::fabs(in_dviscositydstrainrate_onezero.strain_rate[i][1][0]) * finite_difference_accuracy;
+        }
+      std::cout << "onezero on quadrature point " << i << ": Finite difference = " << temp << ". Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][1][0]   << std::endl;
+      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][1][0]) > 1e-3 * 0.5 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][1][0])) )
+        {
+          std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
+          Error = true;
+        }
+    }
+
+  for (unsigned int i = 0; i < 5; i++)
+    {
+      // prevent division by zero. If it is zero, the test has passed, because or
+      // the finite difference and the analytical result match perfectly, or (more
+      // likely) the material model in independent of this variable.
+      temp = out_dviscositydstrainrate_oneone.viscosities[i] - out_base.viscosities[i];
+      if (temp != 0)
+        {
+          temp /= std::fabs(in_dviscositydstrainrate_oneone.strain_rate[i][1][1]) * finite_difference_accuracy;
+        }
+      std::cout << "oneone on quadrature point " << i << ": Finite difference = " << temp << ". Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][1][1]  << std::endl;
+      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][1][1]) > 1e-3 * 0.5 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][1][1])) )
+        {
+          std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
+          Error = true;
+        }
+
+    }
+
+  if (Error)
+    {
+      std::cout << "Some parts of the test were not successful." << std::endl;
+    }
+  else
+    {
+      std::cout << "OK" << std::endl;
+    }
+
+  return 42;
+}
+
+int exit_function()
+{
+  exit(0);
+  return 42;
+}
+// run this function by initializing a global variable by it
+int ii = f(-1000); // Testing min function
+int iz = f(-2); // Testing generalized p norm mean with negative p
+int ij = f(-1.5); // Testing generalized p norm mean with negative, non int p
+int ik = f(-1); // Testing harmonic mean
+int ji = f(0); // Testing geometric mean
+int jj = f(1); // Testing arithmetic mean
+int jk = f(2); // Testing generalized p norm mean with positive p
+int kj = f(1000); // Testing max function
+int kl = exit_function();
diff --git a/tests/spiegelman_material.prm.bak b/tests/spiegelman_material.prm.bak
new file mode 100644
index 00000000000..36979856777
--- /dev/null
+++ b/tests/spiegelman_material.prm.bak
@@ -0,0 +1,4 @@
+# This test checks whether the derivatives of the simple nonlinear
+# material model are the same as the finite difference derivatives
+# created by the simple nonlinear material model.
+set Additional shared libraries = tests/libspiegelman_material.so
diff --git a/tests/splines.cc.bak b/tests/splines.cc.bak
new file mode 100644
index 00000000000..0e2011aedbd
--- /dev/null
+++ b/tests/splines.cc.bak
@@ -0,0 +1,74 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * This tests the Utilities::tk::spline class for the linear case,
+ * the spline case and the monotone spline case.
+ */
+#include <aspect/utilities.h>
+#include <iostream>
+
+int f()
+{
+  using namespace aspect::Utilities;
+  tk::spline linear,spline,monotone_spline;
+
+  std::vector<double> x_list(5,0.0);
+  std::vector<double> y_list(5,0.0);
+
+  x_list = {1,2,3,4,5};
+  y_list = {0,5,15,2,6};
+
+  linear.set_points(x_list,y_list,false,false);
+  spline.set_points(x_list,y_list,true,false);
+  monotone_spline.set_points(x_list,y_list,true,true);
+
+  std::cout << "Linear interpolates: "
+            << "0 = " << linear(0) << ", 0.25 = " << linear(0.25) << ", 0.5 = " << linear(0.5) << ", 0.75 = " << linear(0.75)
+            << ", 1 = " << linear(1) << ", 1.25 = " << linear(1.25) << ", 1.5 = " << linear(1.5) << ", 1.75 = " << linear(1.75)
+            << ", 2 = " << linear(2) << ", 2.25 = " << linear(2.25) << ", 2.5 = " << linear(2.5) << ", 2.75 = " << linear(2.75) << std::endl
+            << "                     3 = " << linear(3) << ", 3.25 = " << linear(3.25) << ", 3.5 = " << linear(3.5) << ", 3.75 = " << linear(3.75)
+            << ", 4 = " << linear(4) << ", 4.25 = " << linear(4.25) << ", 4.5 = " << linear(4.5) << ", 4,75 = " << linear(4.75)
+            << ", 5 = " << linear(5) << ", 5.25 = " << linear(5.25) << ", 5.5 = " << linear(5.5) << ", 5.75 = " << linear(5.75)
+            << ", 6 = " << linear(6) << std::endl;
+
+  std::cout << "Spline interpolates: "
+            << "0 = " << spline(0) << ", 0.25 = " << spline(0.25) << ", 0.5 = " << spline(0.5) << ", 0.75 = " << spline(0.75)
+            << ", 1 = " << spline(1) << ", 1.25 = " << spline(1.25) << ", 1.5 = " << spline(1.5) << ", 1.75 = " << spline(1.75)
+            << ", 2 = " << spline(2) << ", 2.25 = " << spline(2.25) << ", 2.5 = " << spline(2.5) << ", 2.75 = " << spline(2.75) << std::endl
+            << "                     3 = " << spline(3) << ", 3.25 = " << spline(3.25) << ", 3.5 = " << spline(3.5) << ", 3.75 = " << spline(3.75)
+            << ", 4 = " << spline(4) << ", 4.25 = " << spline(4.25) << ", 4.5 = " << spline(4.5) << ", 4,75 = " << spline(4.75)
+            << ", 5 = " << spline(5) << ", 5.25 = " << spline(5.25) << ", 5.5 = " << spline(5.5) << ", 5.75 = " << spline(5.75)
+            << ", 6 = " << spline(6) << std::endl;
+
+  std::cout << "Monotone spline interpolates: "
+            << "0 = " << monotone_spline(0) << ", 0.25 = " << monotone_spline(0.25) << ", 0.5 = " << monotone_spline(0.5) << ", 0.75 = " << monotone_spline(0.75)
+            << ", 1 = " << monotone_spline(1) << ", 1.25 = " << monotone_spline(1.25) << ", 1.5 = " << monotone_spline(1.5) << ", 1.75 = " << monotone_spline(1.75)
+            << ", 2 = " << monotone_spline(2) << ", 2.25 = " << monotone_spline(2.25) << ", 2.5 = " << monotone_spline(2.5) << ", 2.75 = " << monotone_spline(2.75) << std::endl
+            << "                              3 = " << monotone_spline(3) << ", 3.25 = " << monotone_spline(3.25) << ", 3.5 = " << monotone_spline(3.5) << ", 3.75 = " << monotone_spline(3.75)
+            << ", 4 = " << monotone_spline(4) << ", 4.25 = " << monotone_spline(4.25) << ", 4.5 = " << monotone_spline(4.5) << ", 4,75 = " << monotone_spline(4.75)
+            << ", 5 = " << monotone_spline(5) << ", 5.25 = " << monotone_spline(5.25) << ", 5.5 = " << monotone_spline(5.5) << ", 5.75 = " << monotone_spline(5.75)
+            << ", 6 = " << monotone_spline(6) << std::endl;
+
+  exit(0);
+  return 42;
+}
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/splines.prm.bak b/tests/splines.prm.bak
new file mode 100644
index 00000000000..1afb61af5bd
--- /dev/null
+++ b/tests/splines.prm.bak
@@ -0,0 +1 @@
+set Additional shared libraries = tests/libsplines.so
diff --git a/tests/static_temperature.prm.bak b/tests/static_temperature.prm.bak
new file mode 100644
index 00000000000..3b0a5c0f967
--- /dev/null
+++ b/tests/static_temperature.prm.bak
@@ -0,0 +1,98 @@
+# Test for static temperature field option. When the temperature field is static
+# the temperature field does not change with time, but other field like the
+# composition or elastic stress can be advected and changed in time.
+
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set Start time                 = 0.0
+set End time                               = 20e3
+set Output directory                       = static_temperature
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500e3
+    set Y extent = 500e3
+  end
+end
+
+# spherical temperature anomaly (so get appreciable velocity in first time step)
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = r=50e3, p=250e3, Tref=1400
+    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)) < r, 0, Tref)
+  end
+end
+
+subsection Temperature field
+  set Temperature method = static
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1400
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 1400
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81   #
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1400
+    set Thermal conductivity          = 3.3
+    set Thermal expansion coefficient = 3.0e-5
+    set Viscosity                     = 1e20
+  end
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 2
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set List of output variables      = density, viscosity, strain rate
+    set Output format                 = gnuplot
+    set Time between graphical output = 20e3
+    set Number of grouped files       = 0
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+end
diff --git a/tests/statistics_output.prm.bak b/tests/statistics_output.prm.bak
new file mode 100644
index 00000000000..ae7c0a2dcfd
--- /dev/null
+++ b/tests/statistics_output.prm.bak
@@ -0,0 +1,142 @@
+# This test is a copy of adiabatic_heating_with_melt
+# except that a line for each nonlinear iteration is
+# written into the statistics file, which is the feature
+# that is tested.
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+# We only want to test if one line is written per iteration
+set Max nonlinear iterations               = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 6.6e12
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
+
+subsection Discretization
+  set Stokes velocity polynomial degree    = 2
+  set Composition polynomial degree        = 1
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9177
+    set Y extent = 183540      # maximum pressure 6 GPa
+    set Y repetitions = 20
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    subsection Function
+      set Function expression       = 1.0;0.0
+    end
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.1; 0.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 3:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    set Function expression = 0;1e-10
+  end
+end
+
+subsection Melt settings
+  set Include melt transport                  = true
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, adiabatic heating of melt
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = fluid density
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = melt global
+
+  subsection Melt global
+    set Reference solid density  = 3300
+    set Reference melt density   = 3000
+    set Reference specific heat  = 1000
+    set Reference temperature    = 1600
+    set Thermal conductivity     = 0.0
+    set Surface solidus          = 10000.0
+    set Include melting and freezing = false
+    set Reference permeability   = 1.2345679e-10
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, heating statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = viscosity, density, nonadiabatic temperature
+  end
+
+  subsection Global statistics
+    set Write statistics for each nonlinear iteration = true
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-12
+  end
+end
diff --git a/tests/steinberger_averaging.prm.bak b/tests/steinberger_averaging.prm.bak
new file mode 100644
index 00000000000..51bc2a687da
--- /dev/null
+++ b/tests/steinberger_averaging.prm.bak
@@ -0,0 +1,123 @@
+# This is a copy of Steinberger compressible test,
+# but it uses two tiny property tables with constant properties to
+# test the averaging schemes for the material properties.
+# The constant mass fraction of material_2 is 0.5, which for densities of
+# 2000 kg/m^3 and 3000 kg/m^3 equates to a volume fraction of 0.4.
+#
+# The correct outputs for the properties are then:
+# volume fraction of phase A: 0.5 (volume averaged, 0.6*0.5 + 0.4*0.5)
+# volume fraction of phase B: 0.3 (volume averaged, 0.6*0.5 + 0.4*0.0)
+# volume fraction of phase C: 0.2 (volume averaged, 0.6*0.0 + 0.4*0.5)
+# Seismic Vs: 5.942027625961722 (VRH average of 6 and 6)
+# Seismic Vp: 7.922703501282297 (VRH average of 8 and 8)
+# Density: 2400 kg/m^3 (volume averaged, 0.6*2000 + 0.4*3000)
+# Thermal_expansivity: 2.4e-5 (volume averaged, 0.6*2e-5 + 0.4*3e-5)
+# Specific_heat: 1500 (mass averaged, 0.5*1000 + 0.5*2000)
+
+set CFL number                             = 1.0
+set End time                               = 0.
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = constant_material_1_tiny.txt, constant_material_2_tiny.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = named additional outputs, material properties
+    set Time between graphical output = 0
+
+    subsection Vp anomaly
+      set Number of depth slices = 96
+    end
+
+    subsection Vs anomaly
+      set Number of depth slices = 96
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_background.prm.bak b/tests/steinberger_background.prm.bak
new file mode 100644
index 00000000000..395a34c3693
--- /dev/null
+++ b/tests/steinberger_background.prm.bak
@@ -0,0 +1,106 @@
+# This is a copy of the steinberger compressible test.
+# It is intended to test the ability of the steinberger
+# material model to use the first data file as a background
+# composition, and all other compositional fields as
+# anomalies modifying this composition.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = testdata.txt,testdata-modified-alpha.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity             = 1.5
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density, thermal conductivity, thermal expansivity
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_compressible.prm.bak b/tests/steinberger_compressible.prm.bak
new file mode 100644
index 00000000000..89c6c3e678b
--- /dev/null
+++ b/tests/steinberger_compressible.prm.bak
@@ -0,0 +1,95 @@
+# This is a copy of the simple compressible test.
+# However it uses the Steinberger material model, which
+# reads in lookup tables. The testdata used in this test
+# was prepared with the same equations as in the simple
+# compressible material model. The output between the two is
+# very similar, although not completely equal due to roundoff
+# errors.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = testdata.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_compressible_gmg.prm.bak b/tests/steinberger_compressible_gmg.prm.bak
new file mode 100644
index 00000000000..d301f93bc17
--- /dev/null
+++ b/tests/steinberger_compressible_gmg.prm.bak
@@ -0,0 +1,18 @@
+# Like steinberger_compressible but with GMG and harmonic averaging for viscosity
+
+include $ASPECT_SOURCE_DIR/tests/steinberger_compressible.prm
+
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/steinberger_conductivity.prm.bak b/tests/steinberger_conductivity.prm.bak
new file mode 100644
index 00000000000..0af7bee1948
--- /dev/null
+++ b/tests/steinberger_conductivity.prm.bak
@@ -0,0 +1,80 @@
+# This is a test for the pressure- and temperature-dependent
+# thermal conductivity. It uses a linearly increasing temperature
+# in x-direction and a linearly increasing pressure in y
+# direction. The results can be compared with Stackhouse et al.,
+# 2015 (https://doi.org/10.1016/j.epsl.2015.06.050).
+
+set CFL number                             = 1.0
+set End time                               = 0
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 7.5e7
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 300 + 3700 * x
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = constant_material_1_tiny.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity formulation = p-T-dependent
+    set Thermal conductivity transition depths =
+    set Reference thermal conductivities = 4.9
+    set Pressure dependencies of thermal conductivity = 1.05e-10
+    set Reference temperatures for thermal conductivity = 1200
+    set Thermal conductivity exponents   = 1
+    set Saturation prefactors            = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   =
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output            = true
+    set Output format                 = gnuplot
+    set List of output variables      = thermal conductivity
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/steinberger_conductivity_tosi.prm.bak b/tests/steinberger_conductivity_tosi.prm.bak
new file mode 100644
index 00000000000..7409e797042
--- /dev/null
+++ b/tests/steinberger_conductivity_tosi.prm.bak
@@ -0,0 +1,87 @@
+# This is a test for the pressure- and temperature-dependent
+# thermal conductivity. It uses a linearly increasing temperature
+# in x-direction and a linearly increasing pressure in y
+# direction. It has 4 conductivity layers, corresponding to
+# forsterite, wadsleyite, ringwoodite and bridgmanite +
+# ferropericlase. The results can be compared with Tosi et al.,
+# 2013 (https://doi.org/10.1016/j.pepi.2013.02.004), Figure 2.
+
+set CFL number                             = 1.0
+set End time                               = 0
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1
+    set Y extent  = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1.5e7
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1e-10 + 4000 * x
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = constant_material_1_tiny.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity formulation = p-T-dependent
+    set Thermal conductivity transition depths = 0.41, 0.52, 0.66
+    set Reference thermal conductivities = 2.47, 3.81, 3.52, 3.48
+    set Pressure dependencies of thermal conductivity = 3.3e-10, 3.4e-10, 3.6e-10, 1.2e-10
+    set Reference temperatures for thermal conductivity = 300
+    set Thermal conductivity exponents   = 0.48, 0.56, 0.61, 0.31
+    set Saturation prefactors            = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   =
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, depth average
+
+  subsection Visualization
+    set Interpolate output            = true
+    set Output format                 = gnuplot
+    set List of output variables      = thermal conductivity
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/steinberger_continuous_viscosity.prm.bak b/tests/steinberger_continuous_viscosity.prm.bak
new file mode 100644
index 00000000000..1b624339323
--- /dev/null
+++ b/tests/steinberger_continuous_viscosity.prm.bak
@@ -0,0 +1,18 @@
+# This test is like the steinberger cookbook, but with the continuous version
+# of the viscosity profile.
+
+include $ASPECT_SOURCE_DIR/cookbooks/steinberger/steinberger.prm
+
+set End time                             = 2e6
+set Nonlinear solver scheme              = single Advection, single Stokes
+
+subsection Material model
+  subsection Steinberger model
+    set Radial viscosity file name       = radial-visc-continuous.txt
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
diff --git a/tests/steinberger_cookbook.prm.bak b/tests/steinberger_cookbook.prm.bak
new file mode 100644
index 00000000000..41341225d1e
--- /dev/null
+++ b/tests/steinberger_cookbook.prm.bak
@@ -0,0 +1,12 @@
+# Copy of the steinberger cookbook, with a shorter end time,
+# lower resolution and without nonlinear iterations.
+
+include $ASPECT_SOURCE_DIR/cookbooks/steinberger/steinberger.prm
+
+set End time                             = 2e6
+set Nonlinear solver scheme              = single Advection, single Stokes
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
diff --git a/tests/steinberger_latent_heat.prm.bak b/tests/steinberger_latent_heat.prm.bak
new file mode 100644
index 00000000000..e088b86af9c
--- /dev/null
+++ b/tests/steinberger_latent_heat.prm.bak
@@ -0,0 +1,90 @@
+# This is a copy of the steinberger compressible test. However, it activates
+# latent heat by computing the thermal expansivity and specific heat as
+# derivatives of the enthalpy, which leads to temperature jumps across phase
+# transitions.
+
+set CFL number                             = 1.0
+set End time                               = 0
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = ../pyr-ringwood88.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = true
+    set Use lateral average temperature for viscosity = false
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+# Warning: Merge the parameter in the following subsection with any
+# other parameter of the same name, otherwise your model results might change
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = material properties
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/steinberger_latent_heat_2.prm.bak b/tests/steinberger_latent_heat_2.prm.bak
new file mode 100644
index 00000000000..b7de027b6dc
--- /dev/null
+++ b/tests/steinberger_latent_heat_2.prm.bak
@@ -0,0 +1,125 @@
+#########################################################
+# This is a model setup to test the latent heat generation.
+# It is identical to the latent_heat_enthalpy test, but utilizes
+# the steinberger material model to ensure a correct
+# implementation of the functionality. For details on the
+# test see the latent_heat_enthalpy testcase.
+
+set Dimension = 2
+set Start time                             = 0
+set End time                               = 1e15
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature          = 1000
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 50000
+    set Y extent = 1000000
+    set Y repetitions = 20
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  =
+    set Function expression = 8e-5
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields   = grain_size
+end
+
+# Warning: Merge the parameter in the following subsection with any
+# other parameter of the same name, otherwise your model results might change
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+############### Boundary conditions
+# We set the top temperature to T1=1000K.
+subsection Boundary temperature model
+  # We only fix the temperature at the upper boundary, the other boundaries
+  # are isolating. To guarantee a steady downward flow, we fix the velocity
+  # at the top and bottom, and set it to free slip on the sides.
+  set Fixed temperature boundary indicators   = top
+  set List of model names = box
+
+  subsection Box
+    set Top temperature = 1000
+  end
+end
+
+# We prescribe a constant downward flow.
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Function expression = 0;-2.1422e-11
+    set Variable names      = x,y
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000.0 + (y-1000000)/1000000
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Thermal conductivity             = 2.38
+    set Minimum viscosity                = 8.44e21
+    set Maximum viscosity                = 8.44e21
+    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/latent-heat-enthalpy-test/
+    set Material file names = testdata.txt
+    set Radial viscosity file name = ../steinberger/test-steinberger-compressible/test-radial-visc.txt
+    set Lateral viscosity file name = ../steinberger/test-steinberger-compressible/test-viscosity-prefactor.txt
+    set Latent heat = true
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics, composition statistics
+end
diff --git a/tests/steinberger_lateral_fail.prm.bak b/tests/steinberger_lateral_fail.prm.bak
new file mode 100644
index 00000000000..2d23dff80e9
--- /dev/null
+++ b/tests/steinberger_lateral_fail.prm.bak
@@ -0,0 +1,101 @@
+# EXPECT FAILURE
+
+# This is a copy of the simple compressible test.
+# However it uses the Steinberger material model, which
+# reads in lookup tables. The testdata used in this test
+# was prepared with the same equations as in the simple
+# compressible material model. However, the lookup table is much too large for
+# lateral averaging for the implementation currently, so an error should be
+# produced under the current conditions.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = testdata.txt
+
+    # Use overresolved viscosity prefactor file
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Use lateral average temperature for viscosity = true
+    set Number lateral average bands = 100
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_phase_fractions.prm.bak b/tests/steinberger_phase_fractions.prm.bak
new file mode 100644
index 00000000000..9cca57ff5d8
--- /dev/null
+++ b/tests/steinberger_phase_fractions.prm.bak
@@ -0,0 +1,112 @@
+# This is a copy of Steinberger compressible test,
+# but it uses a pyrolite material property table instead
+# of the test data, so that reasonable seismic velocities are
+# computed. The property table also contains volume fractions of the
+# stable phases in the rock, which can be output using
+# the "named additional outputs" in the list of named outputs for
+# the Visualization postprocessor.
+# The material property table was created from raw PerpleX-vertex output
+# using the python script
+# contrib/python/create_aspect_readable_perplex_table_with_phase_volumes.py
+
+# The PerpleX calculations were run with the
+# Stixrude and Lithgow-Bertelloni
+# (2011; https://doi.org/10.1111/j.1365-246X.2010.04890.x) dataset.
+
+# The pyrolite composition is a six-component version of the composition in
+# McDonough and Sun (1995; https://doi.org/10.1016/0009-2541(94)00140-4):
+# 0.36 wt% Na2O, 37.8 wt% MgO, 4.45 wt% Al2O3, 45.0 wt% SiO2, 3.55 wt% CaO, 8.05 wt% FeO
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names              = pyr_MS95_with_volume_fractions_lo_res.dat
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = named additional outputs, Vs anomaly, Vp anomaly
+    set Time between graphical output = 0
+
+    subsection Vp anomaly
+      set Number of depth slices = 96
+    end
+
+    subsection Vs anomaly
+      set Number of depth slices = 96
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_phase_fractions_background.prm.bak b/tests/steinberger_phase_fractions_background.prm.bak
new file mode 100644
index 00000000000..de21ee96f0c
--- /dev/null
+++ b/tests/steinberger_phase_fractions_background.prm.bak
@@ -0,0 +1,129 @@
+# This is a copy of Steinberger compressible test,
+# but it uses pyrolite and MORB-composition material property tables instead
+# of the test data, so that reasonable seismic velocities are
+# computed. The property tables also contain volume fractions of the
+# stable phases in the rock, which can be output using
+# the "named additional outputs" in the list of named outputs for
+# the Visualization postprocessor.
+# The material property tables were created from raw PerpleX-vertex output
+# using the python script
+# contrib/python/create_aspect_readable_perplex_table_with_phase_volumes.py
+
+# The PerpleX calculations were run with the
+# Stixrude and Lithgow-Bertelloni
+# (2011; https://doi.org/10.1111/j.1365-246X.2010.04890.x) dataset.
+
+# The pyrolite composition is a six-component version of the composition in
+# McDonough and Sun (1995; https://doi.org/10.1016/0009-2541(94)00140-4):
+# 0.36 wt% Na2O, 37.8 wt% MgO, 4.45 wt% Al2O3, 45.0 wt% SiO2, 3.55 wt% CaO, 8.05 wt% FeO
+
+# The MORB composition is a six-component version of the composition in
+# Gale et al (2013; https://doi.org/10.1029/2012GC004334)
+# 2.790 wt% Na2O, 7.580 wt% MgO, 14.70 wt% Al2O3, 50.47 wt% SiO2, 11.39 wt% CaO, 10.43 wt% FeO
+
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names              = pyr_MS95_with_volume_fractions_lo_res.dat, morb_G13_with_volume_fractions_lo_res.dat
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = named additional outputs, Vs anomaly, Vp anomaly
+    set Time between graphical output = 0
+
+    subsection Vp anomaly
+      set Number of depth slices = 96
+    end
+
+    subsection Vs anomaly
+      set Number of depth slices = 96
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_phases.prm.bak b/tests/steinberger_phases.prm.bak
new file mode 100644
index 00000000000..02bfaaed9a1
--- /dev/null
+++ b/tests/steinberger_phases.prm.bak
@@ -0,0 +1,110 @@
+# This is a copy of the steinberger compressible test.
+# It is intended to test the ability of the steinberger
+# material model to use the first data file as a background
+# composition, and ignore other compositional fields if
+# only a single material file is provided.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = constant_material_small.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity             = 1.5
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = material properties, named additional outputs
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_phases_2_lookups.prm.bak b/tests/steinberger_phases_2_lookups.prm.bak
new file mode 100644
index 00000000000..89de4df7f0e
--- /dev/null
+++ b/tests/steinberger_phases_2_lookups.prm.bak
@@ -0,0 +1,108 @@
+# This is a copy of the steinberger phases test,
+# but it uses to lookups instead of one to see if
+# phases indices are read in correctly.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if (x-y>1,1,0)
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = constant_material_small.txt, constant_material_2_small.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity             = 1.5
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = material properties, named additional outputs
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_phases_hefesto.prm.bak b/tests/steinberger_phases_hefesto.prm.bak
new file mode 100644
index 00000000000..d2e49c92018
--- /dev/null
+++ b/tests/steinberger_phases_hefesto.prm.bak
@@ -0,0 +1,111 @@
+# This is a copy of the steinberger phases test.
+# The only difference is that is uses the hefeasto instead
+# of the perplex data format. It should produce exactly the
+# same results.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = constant_material_small_hefesto.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity             = 1.5
+    set Material file format             = hefesto
+    set Derivatives file names           = constant_material_small_hefesto_derivatives.txt
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = material properties, named additional outputs
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility, specific heat
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_projected_density.prm.bak b/tests/steinberger_projected_density.prm.bak
new file mode 100644
index 00000000000..3bfaafa5896
--- /dev/null
+++ b/tests/steinberger_projected_density.prm.bak
@@ -0,0 +1,114 @@
+# This is a copy of the steinberger compressible test.
+# It is intended to test the ability of the steinberger
+# material model to be used with the projected density
+# approximation, which requires using compositional
+# fields that do not correspond to a look-up table.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields            = 3
+  set Names of fields             = composition, density_field, another_field
+  set Types of fields             = chemical composition, density, generic
+  set Compositional field methods = field, prescribed field, field
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (sqrt(x*x+y*y)-3481000)/(6371000-3481000); 3300; x/6371000
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = testdata.txt,testdata-modified-alpha.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity             = 1.5
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density, thermal conductivity, thermal expansivity
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
diff --git a/tests/steinberger_projected_density_dcPicard.prm.bak b/tests/steinberger_projected_density_dcPicard.prm.bak
new file mode 100644
index 00000000000..d082ef3016a
--- /dev/null
+++ b/tests/steinberger_projected_density_dcPicard.prm.bak
@@ -0,0 +1,118 @@
+# This is a copy of the steinberger compressible test,
+# where the default nonlinear solver scheme has been replaced
+# by the `iterated Advection and defect correction Stokes`
+# nonlinear solver scheme.
+# It is intended to test the ability of the steinberger
+# material model to be used with the projected density
+# approximation, which requires using compositional
+# fields that do not correspond to a look-up table.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Advection and defect correction Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields            = 3
+  set Names of fields             = composition, density_field, another_field
+  set Types of fields             = chemical composition, density, generic
+  set Compositional field methods = field, prescribed field, field
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (sqrt(x*x+y*y)-3481000)/(6371000-3481000); 3300; x/6371000
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = testdata.txt,testdata-modified-alpha.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity             = 1.5
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density, thermal conductivity, thermal expansivity
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Formulation
+  set Mass conservation = projected density field
+  set Temperature equation = real density
+end
diff --git a/tests/steinberger_seismic_velocities.prm.bak b/tests/steinberger_seismic_velocities.prm.bak
new file mode 100644
index 00000000000..4ec078721f3
--- /dev/null
+++ b/tests/steinberger_seismic_velocities.prm.bak
@@ -0,0 +1,98 @@
+# This is a copy of Steinberger compressible test,
+# but it uses the pyrolite material property table instead
+# of the test data, so that reasonable seismic velocities are
+# computed.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names              = pyr-ringwood88.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+    set List of output variables      = named additional outputs, Vs anomaly, Vp anomaly
+    set Time between graphical output = 0
+
+    subsection Vp anomaly
+      set Number of depth slices = 96
+    end
+
+    subsection Vs anomaly
+      set Number of depth slices = 96
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_several_fields.prm.bak b/tests/steinberger_several_fields.prm.bak
new file mode 100644
index 00000000000..d549b38ea19
--- /dev/null
+++ b/tests/steinberger_several_fields.prm.bak
@@ -0,0 +1,110 @@
+# This is a copy of the steinberger single field test.
+# It is intended to test the ability of the steinberger
+# material model to use the first data file as a background
+# composition, and ignore several other compositional
+# fields if only a single material file is provided.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000); 2e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000); 3e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = testdata.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity             = 1.5
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = material properties
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_single_field.prm.bak b/tests/steinberger_single_field.prm.bak
new file mode 100644
index 00000000000..713e5a079f0
--- /dev/null
+++ b/tests/steinberger_single_field.prm.bak
@@ -0,0 +1,110 @@
+# This is a copy of the steinberger compressible test.
+# It is intended to test the ability of the steinberger
+# material model to use the first data file as a background
+# composition, and ignore other compositional fields if
+# only a single material file is provided.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
+    set Material file names              = testdata.txt
+    set Lateral viscosity file name      = test-viscosity-prefactor.txt
+    set Radial viscosity file name       = test-radial-visc.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Thermal conductivity             = 1.5
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = material properties
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility
+    end
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
diff --git a/tests/steinberger_viscosity.prm.bak b/tests/steinberger_viscosity.prm.bak
new file mode 100644
index 00000000000..5afe11f033a
--- /dev/null
+++ b/tests/steinberger_viscosity.prm.bak
@@ -0,0 +1,91 @@
+# This is a copy of the steinberger_compressible test.
+# However, it uses the actual Steinberger viscosity model,
+# instead of the constant viscosity test data.
+
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names              = test-steinberger-compressible/testdata.txt
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+    set Number lateral average bands     = 40
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set List of output variables      = viscosity
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/steinberger_viscosity_adiabatic.prm.bak b/tests/steinberger_viscosity_adiabatic.prm.bak
new file mode 100644
index 00000000000..7705b90be10
--- /dev/null
+++ b/tests/steinberger_viscosity_adiabatic.prm.bak
@@ -0,0 +1,101 @@
+# This is a copy of the steinberger_compressible test.
+# However, it uses the actual Steinberger viscosity model,
+# instead of the constant viscosity test data.
+# Additionally, it calculates the temperature deviation
+# for the viscosity model against the adiabatic
+# temperature profile instead of the lateral average.
+
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = Steinberger
+
+  subsection Steinberger model
+    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
+    set Material file names              = test-steinberger-compressible/testdata.txt
+    set Use lateral average temperature for viscosity = false
+    set Bilinear interpolation           = true
+    set Latent heat                      = false
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set GMRES solver restart length = 200
+    set Use full A block as preconditioner = true
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics, depth average
+
+  subsection Visualization
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set List of output variables      = viscosity
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
diff --git a/tests/stokes.prm.bak b/tests/stokes.prm.bak
new file mode 100644
index 00000000000..5774224c597
--- /dev/null
+++ b/tests/stokes.prm.bak
@@ -0,0 +1,124 @@
+# this is a version of the stokes' law input file
+# but with less mesh refinement
+
+
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+# The setup is a 3d box with edge length 2890000 in which
+# all 6 sides have free slip boundary conditions. Because
+# the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2890000
+    set Y extent  = 2890000
+    set Z extent  = 2890000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3,4,5
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Viscosity                     = 1e22
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# This, however, is the more important part: We need to describe
+# the compositional field and its influence on the density
+# function. The following blocks say that we want to
+# advect a single compositional field and that we give it an
+# initial value that is zero outside a sphere of radius
+# r=200000m and centered at the point (p,p,p) with
+# p=1445000 (which is half the diameter of the box) and one inside.
+# The last block re-opens the material model and sets the
+# density differential per unit change in compositional field to
+# 100.
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = r=200000,p=1445000
+    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density, viscosity
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/stokes_residual.prm.bak b/tests/stokes_residual.prm.bak
new file mode 100644
index 00000000000..08a8a88a9ac
--- /dev/null
+++ b/tests/stokes_residual.prm.bak
@@ -0,0 +1,66 @@
+# similar to solver_history.prm, but check the stokes residual postprocessor
+# instead of using the signal directly.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0.1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, Stokes residual
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/stokes_residual_cheap.prm.bak b/tests/stokes_residual_cheap.prm.bak
new file mode 100644
index 00000000000..53f3b322020
--- /dev/null
+++ b/tests/stokes_residual_cheap.prm.bak
@@ -0,0 +1,11 @@
+# similar to solver_history.prm, but check the stokes residual postprocessor
+# instead of using the signal directly.
+
+include $ASPECT_SOURCE_DIR/tests/stokes_residual.prm
+
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/stokes_solver_fail.prm b/tests/stokes_solver_fail.prm
index ad8853c1ca5..0f46b4734dd 100644
--- a/tests/stokes_solver_fail.prm
+++ b/tests/stokes_solver_fail.prm
@@ -13,5 +13,5 @@ subsection Solver parameters
     set Maximum number of expensive Stokes solver steps = 0
     set Linear solver tolerance = 1e-35
     set Stokes solver type = block AMG
-   end
+  end
 end
diff --git a/tests/stokes_solver_fail.prm.bak b/tests/stokes_solver_fail.prm.bak
new file mode 100644
index 00000000000..ad8853c1ca5
--- /dev/null
+++ b/tests/stokes_solver_fail.prm.bak
@@ -0,0 +1,17 @@
+# This is a copy of simple_incompressible.prm that decreases Stokes solver
+# tolerance to provoke a crash and check the error message and solver history
+# output.
+
+# EXPECT FAILURE
+
+include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
+
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 10
+    set Maximum number of expensive Stokes solver steps = 0
+    set Linear solver tolerance = 1e-35
+    set Stokes solver type = block AMG
+   end
+end
diff --git a/tests/stokes_solver_fail_A.prm.bak b/tests/stokes_solver_fail_A.prm.bak
new file mode 100644
index 00000000000..412803ef8b7
--- /dev/null
+++ b/tests/stokes_solver_fail_A.prm.bak
@@ -0,0 +1,15 @@
+# This is a copy of simple_incompressible.prm that decreases Stokes solver
+# tolerance to provoke a crash and check the error message and solver history
+# output.
+
+# EXPECT FAILURE
+
+include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
+
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+    set Linear solver A block tolerance = 0
+  end
+end
diff --git a/tests/stokes_solver_fail_S.prm.bak b/tests/stokes_solver_fail_S.prm.bak
new file mode 100644
index 00000000000..91690f406ee
--- /dev/null
+++ b/tests/stokes_solver_fail_S.prm.bak
@@ -0,0 +1,15 @@
+# This is a copy of simple_incompressible.prm that decreases Stokes solver
+# tolerance to provoke a crash and check the error message and solver history
+# output.
+
+# EXPECT FAILURE
+
+include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
+
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+    set Linear solver S block tolerance = 0
+  end
+end
diff --git a/tests/stokes_solver_fail_cheap.prm.bak b/tests/stokes_solver_fail_cheap.prm.bak
new file mode 100644
index 00000000000..0a81f485e7a
--- /dev/null
+++ b/tests/stokes_solver_fail_cheap.prm.bak
@@ -0,0 +1,17 @@
+# This is a copy of simple_incompressible.prm that decreases Stokes solver
+# tolerance to provoke a crash and check the error message and solver history
+# output. This test in particular checks that the correct error message is shown
+# if there are only cheap Stokes solver iterations.
+
+# EXPECT FAILURE
+
+include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
+
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-35
+    set Number of cheap Stokes solver steps = 10
+    set Maximum number of expensive Stokes solver steps = 0
+  end
+end
diff --git a/tests/stokes_solver_fail_gmg.prm.bak b/tests/stokes_solver_fail_gmg.prm.bak
new file mode 100644
index 00000000000..11412d9632d
--- /dev/null
+++ b/tests/stokes_solver_fail_gmg.prm.bak
@@ -0,0 +1,21 @@
+# This is a copy of simple_incompressible.prm that decreases Stokes solver
+# tolerance to provoke a crash and check the error message and solver history
+# output.
+
+# EXPECT FAILURE
+
+include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
+
+
+subsection Material model
+  set Material averaging = project to Q1 only viscosity
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+    set Linear solver tolerance = 1e-35
+    set Number of cheap Stokes solver steps = 10
+    set Maximum number of expensive Stokes solver steps = 10
+  end
+end
diff --git a/tests/stress_vs_surface_stress.cc.bak b/tests/stress_vs_surface_stress.cc.bak
new file mode 100644
index 00000000000..c45fb20207c
--- /dev/null
+++ b/tests/stress_vs_surface_stress.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "simple_shear.cc"
diff --git a/tests/stress_vs_surface_stress.prm.bak b/tests/stress_vs_surface_stress.prm.bak
new file mode 100644
index 00000000000..1c552b2e83b
--- /dev/null
+++ b/tests/stress_vs_surface_stress.prm.bak
@@ -0,0 +1,92 @@
+# This is a variation of the pure_shear.prm file, and is used to test
+# the 'stress' visualization postprocessor as well as the 'surface
+# stress' visualization postprocessor that only outputs stuff on the
+# boundary.
+
+set Dimension                              = 2
+set End time                               = 0.025
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom
+  set Prescribed velocity boundary indicators = top:function, right:function
+
+  subsection Function
+    set Function expression = 1-y; x-1
+  end
+end
+
+subsection Material model
+  set Model name = finite strain
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0;0.0;0.0;1.0
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set Interpolate output = false
+    set List of output variables = stress, surface stress
+    set Time between graphical output = 0.05
+  end
+end
diff --git a/tests/stress_vs_surface_stress_point_values.cc.bak b/tests/stress_vs_surface_stress_point_values.cc.bak
new file mode 100644
index 00000000000..c45fb20207c
--- /dev/null
+++ b/tests/stress_vs_surface_stress_point_values.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "simple_shear.cc"
diff --git a/tests/stress_vs_surface_stress_point_values.prm.bak b/tests/stress_vs_surface_stress_point_values.prm.bak
new file mode 100644
index 00000000000..41288b89db2
--- /dev/null
+++ b/tests/stress_vs_surface_stress_point_values.prm.bak
@@ -0,0 +1,17 @@
+# This is a variation of the pure_shear.prm file, and is used to test
+# the 'stress' visualization postprocessor as well as the 'surface
+# stress' visualization postprocessor that only outputs stuff on the
+# boundary. The two ought to agree on their results at the boundary.
+
+set Dimension                              = 2
+
+include $ASPECT_SOURCE_DIR/tests/stress_vs_surface_stress.prm
+
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Point-wise stress and strain = true
+  end
+end
diff --git a/tests/subduction_initiation_compositional_fields.prm.bak b/tests/subduction_initiation_compositional_fields.prm.bak
new file mode 100644
index 00000000000..28b2d4298f6
--- /dev/null
+++ b/tests/subduction_initiation_compositional_fields.prm.bak
@@ -0,0 +1,51 @@
+# Parameter file for replicating Matsumoto & Tomoda 1983
+# see cookbooks/subduction_initiation for more details
+
+include $ASPECT_SOURCE_DIR/cookbooks/subduction_initiation/subduction_initiation.prm.base
+
+set Dimension                              = 2
+set End time                               = 0
+
+subsection Mesh refinement
+  set Initial adaptive refinement   = 0
+  set Initial global refinement     = 3
+end
+
+#materials are:
+# asthenosphere left,
+# asthenosphere right,
+# lithosphere left,
+# lithosphere right,
+# water.
+
+subsection Material model
+  set Model name = multicomponent
+
+  subsection Multicomponent
+    set Densities = 3200, 3200, 3300, 3300, 1030
+    set Viscosities = 1e21, 1e21, 1e22, 1e22, 1e18
+    set Viscosity averaging scheme = harmonic
+    set Thermal expansivities = 0
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 4
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = L0=300e3, H=180e3
+    set Function expression = if((x>=L0 && y<H-18e3),1,0) ;\
+                              if((x<=L0 && y>H-60e3 && y<=H-10e3),1,0) ;\
+                              if((x>=L0 && y>=H-18e3 && y<=H-8e3),1,0) ;\
+                              if((x<=L0 && y>H-10e3) || (x>=L0 && y>H-8e3),1,0)
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics, pressure statistics, material statistics, global statistics
+end
diff --git a/tests/supg-compositional-passive.prm.bak b/tests/supg-compositional-passive.prm.bak
new file mode 100644
index 00000000000..5e6b8c5127a
--- /dev/null
+++ b/tests/supg-compositional-passive.prm.bak
@@ -0,0 +1,107 @@
+#########################################################
+# SUPG - COMPOSITIONAL PASSIVE
+# This is a test based off of the composition-passive.prm file.
+# All settings are exactly the same with the exception
+# that we are using SUPG instead of entropy viscosity,
+# and that things were made slightly simpler to make
+# the test run faster.
+#
+# See the manual for more information about this setup.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = false
+set Output directory                       = output
+
+subsection Discretization
+  subsection Stabilization parameters
+    set Stabilization method = SUPG
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, temperature statistics, composition statistics
+
+  subsection Visualization
+    set Time between graphical output = 0.1
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields that will be
+# advected along. Their initial conditions are given by
+# a function that is one for the lowermost 0.2 height
+# units of the domain and zero otherwise in the first case,
+# and one in the top most 0.2 height units in the latter.
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
+  end
+end
diff --git a/tests/supg.prm.bak b/tests/supg.prm.bak
new file mode 100644
index 00000000000..d0d0ce3fe1e
--- /dev/null
+++ b/tests/supg.prm.bak
@@ -0,0 +1,98 @@
+# SUPG
+# Here we prescribe a circular Stokes flow and test if SUPG works while it rotates
+
+# set CFL number = 0.1
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = .5
+set Output directory                       = output
+set Nonlinear solver scheme                = single Advection, no Stokes
+
+subsection Prescribed Stokes solution
+  set Model name = circle
+end
+
+subsection Discretization
+  set Temperature polynomial degree = 2
+
+  subsection Stabilization parameters
+    set Stabilization method = SUPG
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 2
+    set Box origin X coordinate = -1
+    set Box origin Y coordinate = -1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression =  if((sqrt((x-0)^2+(y-0.5)^2)<0.3)&(abs(x)>=0.05|y>=0.7),1,if(sqrt((x-0)^2+(y+0.5)^2)<0.3,1-sqrt((x-0)^2+(y+0.5)^2)/0.3,if(sqrt((x+0.5)^2+(y+0)^2)<0.3,1.0/4.0*(1+cos(pi*min(sqrt((x+0.5)^2+(y+0)^2)/0.3,1))),0)))
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top, bottom, left, right
+
+  subsection Box
+    set Bottom temperature = 0
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0  # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-5
+    set Thermal expansion coefficient = 0
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = .1
+    set List of output variables = artificial viscosity
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/surface_elevation_box_ascii_data.prm.bak b/tests/surface_elevation_box_ascii_data.prm.bak
new file mode 100644
index 00000000000..5b05fb2996b
--- /dev/null
+++ b/tests/surface_elevation_box_ascii_data.prm.bak
@@ -0,0 +1,17 @@
+# Test the 'surface elevation' visualization postprocessor using a
+# model that imposes an initial topography.
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/tests/box_initial_topography_ascii_data.prm
+
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = surface elevation
+  end
+end
diff --git a/tests/surface_elevation_box_ascii_data_moved_origin.prm.bak b/tests/surface_elevation_box_ascii_data_moved_origin.prm.bak
new file mode 100644
index 00000000000..2d7bb232045
--- /dev/null
+++ b/tests/surface_elevation_box_ascii_data_moved_origin.prm.bak
@@ -0,0 +1,17 @@
+# Test the 'surface elevation' visualization postprocessor using a
+# model that imposes an initial topography.
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/tests/box_initial_topography_ascii_data_moved_origin.prm
+
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = surface elevation
+  end
+end
diff --git a/tests/surface_elevation_box_function.prm.bak b/tests/surface_elevation_box_function.prm.bak
new file mode 100644
index 00000000000..e86ffcaa379
--- /dev/null
+++ b/tests/surface_elevation_box_function.prm.bak
@@ -0,0 +1,17 @@
+# Test the 'surface elevation' visualization postprocessor using a
+# model that imposes an initial topography.
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/box_initial_topography_function.prm
+
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = surface elevation
+  end
+end
diff --git a/tests/surface_elevation_box_prm_polygon.prm.bak b/tests/surface_elevation_box_prm_polygon.prm.bak
new file mode 100644
index 00000000000..48345b0f6f8
--- /dev/null
+++ b/tests/surface_elevation_box_prm_polygon.prm.bak
@@ -0,0 +1,17 @@
+# Test the 'surface elevation' visualization postprocessor using a
+# model that imposes an initial topography.
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/tests/box_initial_topography_prm_polygon.prm
+
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = surface elevation
+  end
+end
diff --git a/tests/surface_elevation_chunk_ascii_data.prm.bak b/tests/surface_elevation_chunk_ascii_data.prm.bak
new file mode 100644
index 00000000000..c1e5a5e0e03
--- /dev/null
+++ b/tests/surface_elevation_chunk_ascii_data.prm.bak
@@ -0,0 +1,17 @@
+# Test the 'surface elevation' visualization postprocessor using a
+# model that imposes an initial topography.
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/chunk_initial_topography_ascii_data.prm
+
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = surface elevation
+  end
+end
diff --git a/tests/surface_elevation_chunk_ascii_data_3d.prm.bak b/tests/surface_elevation_chunk_ascii_data_3d.prm.bak
new file mode 100644
index 00000000000..f35229adb01
--- /dev/null
+++ b/tests/surface_elevation_chunk_ascii_data_3d.prm.bak
@@ -0,0 +1,17 @@
+# Test the 'surface elevation' visualization postprocessor using a
+# model that imposes an initial topography.
+
+set Dimension = 3
+
+include $ASPECT_SOURCE_DIR/tests/chunk_initial_topography_ascii_data_3d.prm
+
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = surface elevation
+  end
+end
diff --git a/tests/surface_elevation_chunk_ascii_data_3d_colatitude.prm.bak b/tests/surface_elevation_chunk_ascii_data_3d_colatitude.prm.bak
new file mode 100644
index 00000000000..43bc34d8ef2
--- /dev/null
+++ b/tests/surface_elevation_chunk_ascii_data_3d_colatitude.prm.bak
@@ -0,0 +1,32 @@
+# Test the 'surface elevation' visualization postprocessor using a
+# model that imposes an initial topography.
+
+set Dimension = 3
+
+## From here on, this is a copy of the chunk_initial_topography_ascii_data_3d_colatitude.prm
+## file because apparently we cannot recursively include .prm files.
+include $ASPECT_SOURCE_DIR/tests/chunk_initial_topography_ascii_data_3d.prm
+
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
+      set Data file name       = shell_3d_outer_2.0.txt
+    end
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = surface elevation
+  end
+end
diff --git a/tests/surface_elevation_chunk_ascii_data_global_3d.prm.bak b/tests/surface_elevation_chunk_ascii_data_global_3d.prm.bak
new file mode 100644
index 00000000000..0cde540b5fd
--- /dev/null
+++ b/tests/surface_elevation_chunk_ascii_data_global_3d.prm.bak
@@ -0,0 +1,112 @@
+# Test the 'surface elevation' visualization postprocessor using a
+# model that imposes an initial topography that is read from a data file
+# that describes global topography at 1-degree resolution.
+
+
+##############################################3
+# Start with a copy of chunk_initial_topography_ascii_data_3d.prm,
+# but with a different data file (a global topography description
+# with 1 degree accuracy
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+
+###################################
+# This is the part that is different: Specifically, do not actually
+# solve anything, and output the elevation so that we can inspect it.
+# Also use a higher mesh resolution
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    #    set Chunk minimum longitude = -10
+    #    set Chunk maximum longitude = 90
+    #    set Chunk minimum latitude = -45
+    #    set Chunk maximum latitude = 45
+
+    set Chunk minimum longitude = -45
+    set Chunk maximum longitude = 45
+    set Chunk minimum latitude = -45
+    set Chunk maximum latitude = 45
+    set Longitude repetitions = 1
+    set Latitude repetitions = 1
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/
+      set Data file name       = global_1deg.txt.gz
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 3
+  set Initial global refinement          = 2
+  set Skip solvers on initial refinement = false
+  set Strategy                           = topography
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = outer, east, west, north, south
+  set Zero velocity boundary indicators       = inner
+end
+
+# The ascii data file prescribes a topography between -2000 m and
+# +9000 m. The topography postprocessor output should match with this.
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = surface elevation
+  end
+end
diff --git a/tests/surface_elevation_spherical_shell_ascii_data_global_3d.prm.bak b/tests/surface_elevation_spherical_shell_ascii_data_global_3d.prm.bak
new file mode 100644
index 00000000000..653dd878e4c
--- /dev/null
+++ b/tests/surface_elevation_spherical_shell_ascii_data_global_3d.prm.bak
@@ -0,0 +1,95 @@
+# Test the 'surface elevation' visualization postprocessor using a
+# model that imposes an initial topography that is read from a data file
+# that describes global topography at 1-degree resolution.
+
+
+##############################################3
+# Start with a copy of chunk_initial_topography_ascii_data_3d.prm,
+# but with a different data file (a global topography description
+# with 1 degree accuracy
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+
+###################################
+# This is the part that is different: Specifically, do not actually
+# solve anything, and output the elevation so that we can inspect it.
+# Also use a higher mesh resolution
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Initial topography model
+    set Model name = ascii data
+
+    subsection Ascii data model
+      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/
+      set Data file name       = global_1deg.txt.gz
+    end
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = function
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Function
+    set Function expression = 1613.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Skip solvers on initial refinement = false
+  set Strategy                           = topography
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators =
+  set Zero velocity boundary indicators       = inner
+end
+
+# The ascii data file prescribes a topography between -2000 m and
+# +9000 m. The topography postprocessor output should match with this.
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = surface elevation
+  end
+end
diff --git a/tests/surface_stress_strainrate_3d.cc.bak b/tests/surface_stress_strainrate_3d.cc.bak
new file mode 100644
index 00000000000..45d7c30f6ef
--- /dev/null
+++ b/tests/surface_stress_strainrate_3d.cc.bak
@@ -0,0 +1 @@
+#include "simple_shear.cc"
diff --git a/tests/surface_stress_strainrate_3d.prm.bak b/tests/surface_stress_strainrate_3d.prm.bak
new file mode 100644
index 00000000000..a78383d0c43
--- /dev/null
+++ b/tests/surface_stress_strainrate_3d.prm.bak
@@ -0,0 +1,99 @@
+# This is a variation of the pure_shear.prm file, and is used to test
+# in 3D the 'stress' and 'strain rate tensor' visualization postprocessors
+# as well as the 'surface stress' and 'surface strain rate tensor'
+# visualization postprocessors that only output stuff on the
+# boundary. They ought to agree on their results at the boundary.
+set Dimension                              = 3
+set End time                               = 0.025
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 1.0
+    set Y extent  = 1.0
+    set Z extent  = 1.0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, bottom, front, back
+  set Prescribed velocity boundary indicators = top:function, right:function
+
+  subsection Function
+    set Function expression = 1-z; 0; x-1
+  end
+end
+
+subsection Material model
+  set Model name = finite strain
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 9
+  set Names of fields = strain_xx, strain_xy, strain_xz, strain_yx, strain_yy, strain_yz, strain_zx, strain_zy, strain_zz
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 1.0
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = top
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = strain rate
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set Interpolate output = false
+    set List of output variables = stress, surface stress, strain rate tensor, surface strain rate tensor
+    set Time between graphical output = 0.025
+    set Point-wise stress and strain = true
+  end
+end
diff --git a/tests/symbolic_boundary_names_box.prm.bak b/tests/symbolic_boundary_names_box.prm.bak
new file mode 100644
index 00000000000..24523600a45
--- /dev/null
+++ b/tests/symbolic_boundary_names_box.prm.bak
@@ -0,0 +1,66 @@
+# like simpler_box.prm, but use symbolic names for all boundary
+# components
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = left, right
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = right
+  set Zero velocity boundary indicators       = left, bottom, top
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/symbolic_boundary_names_box_constant_bc.prm.bak b/tests/symbolic_boundary_names_box_constant_bc.prm.bak
new file mode 100644
index 00000000000..7d3df1f9397
--- /dev/null
+++ b/tests/symbolic_boundary_names_box_constant_bc.prm.bak
@@ -0,0 +1,70 @@
+# like symbolic_boundary_names_box but use the 'constant' boundary
+# temperature model and use symbolic names there.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = left, right, bottom, top
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 0: 42, right: 84, bottom: 126, 3: 168
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = right
+  set Zero velocity boundary indicators       = left, bottom, top
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/symbolic_boundary_names_spherical_shell_2d_180_degrees.prm.bak b/tests/symbolic_boundary_names_spherical_shell_2d_180_degrees.prm.bak
new file mode 100644
index 00000000000..74be6d2b0cc
--- /dev/null
+++ b/tests/symbolic_boundary_names_spherical_shell_2d_180_degrees.prm.bak
@@ -0,0 +1,64 @@
+# like simpler_box.prm, but use symbolic names for all boundary
+# components
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 180
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, left
+  set Zero velocity boundary indicators       = outer, right
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/symbolic_boundary_names_spherical_shell_2d_90_degrees.prm.bak b/tests/symbolic_boundary_names_spherical_shell_2d_90_degrees.prm.bak
new file mode 100644
index 00000000000..7ec1b30e48d
--- /dev/null
+++ b/tests/symbolic_boundary_names_spherical_shell_2d_90_degrees.prm.bak
@@ -0,0 +1,64 @@
+# like simpler_box.prm, but use symbolic names for all boundary
+# components
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, left
+  set Zero velocity boundary indicators       = outer, right
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/symbolic_boundary_names_spherical_shell_2d_full.prm.bak b/tests/symbolic_boundary_names_spherical_shell_2d_full.prm.bak
new file mode 100644
index 00000000000..4d9dbd07b62
--- /dev/null
+++ b/tests/symbolic_boundary_names_spherical_shell_2d_full.prm.bak
@@ -0,0 +1,60 @@
+# like simpler_box.prm, but use symbolic names for all boundary
+# components
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner
+  set Zero velocity boundary indicators       = outer
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/symbolic_boundary_names_spherical_shell_3d_90_degrees.prm.bak b/tests/symbolic_boundary_names_spherical_shell_3d_90_degrees.prm.bak
new file mode 100644
index 00000000000..d218a6e3e11
--- /dev/null
+++ b/tests/symbolic_boundary_names_spherical_shell_3d_90_degrees.prm.bak
@@ -0,0 +1,64 @@
+# like simpler_box.prm, but use symbolic names for all boundary
+# components
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner, east
+  set Zero velocity boundary indicators       = outer, west, south
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/symbolic_boundary_names_spherical_shell_3d_full.prm.bak b/tests/symbolic_boundary_names_spherical_shell_3d_full.prm.bak
new file mode 100644
index 00000000000..0077e3c6847
--- /dev/null
+++ b/tests/symbolic_boundary_names_spherical_shell_3d_full.prm.bak
@@ -0,0 +1,60 @@
+# like simpler_box.prm, but use symbolic names for all boundary
+# components
+
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+end
+
+subsection Gravity model
+  set Model name = radial constant
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Material model
+  set Model name = simpler
+
+  subsection Simpler model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner
+  set Zero velocity boundary indicators       = outer
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity
+  end
+end
diff --git a/tests/tangurnis.cc.bak b/tests/tangurnis.cc.bak
new file mode 100644
index 00000000000..e603297ca45
--- /dev/null
+++ b/tests/tangurnis.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/tangurnis/code/tangurnis.cc"
diff --git a/tests/tangurnis_ba.cc.bak b/tests/tangurnis_ba.cc.bak
new file mode 100644
index 00000000000..7966a8ab1f8
--- /dev/null
+++ b/tests/tangurnis_ba.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "tangurnis.cc"
diff --git a/tests/tangurnis_ba.prm.bak b/tests/tangurnis_ba.prm.bak
new file mode 100644
index 00000000000..2f85430f32b
--- /dev/null
+++ b/tests/tangurnis_ba.prm.bak
@@ -0,0 +1,248 @@
+# TanGurnis BA benchmark
+
+set Additional shared libraries            = ./code/libtangurnis.so
+
+# At the top, state that the program should be run for a two-dimensional
+# simulation
+set Dimension = 2
+
+# In computations, the time step $k$ is chosen according to $k = c \min_K
+# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
+# and the denominator is the maximal magnitude of the velocity on cell $K$
+# times the polynomial degree $p_T$ of the temperature discretization. The
+# dimensionless constant $c$ is called the CFL number in this program. For
+# time discretizations that have explicit components, $c$ must be less than a
+# constant that depends on the details of the time discretization and that is
+# no larger than one. On the other hand, for implicit discretizations such as
+# the one chosen here, one can choose the time step as large as one wants (in
+# particular, one can choose $c>1$) though a CFL number significantly larger
+# than one will yield rather diffusive solutions. Units: None.
+set CFL number                             = 1.0
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0.0001
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# The name of the directory into which all output files should be placed. This
+# may be an absolute or a relative path.
+set Output directory                       = output
+
+# A flag indicating whether the computation should be resumed from a
+# previously saved state (if true) or start from scratch (if false).
+set Resume computation                     = false
+
+# The start time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set Start time                             = 0
+
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Adiabatic surface temperature          = 0
+
+# The mathematical equations that describe thermal convection only determine
+# the pressure up to an arbitrary constant. On the other hand, for comparison
+# and for looking up material parameters it is important that the pressure be
+# normalized somehow. We do this by enforcing a particular average pressure
+# value at the surface of the domain, where the geometry model determines
+# where the surface is. This parameter describes what this average surface
+# pressure value is supposed to be. By default, it is set to zero, but one may
+# want to choose a different value for example for simulating only the volume
+# of the mantle below the lithosphere, in which case the surface pressure
+# should be the lithostatic pressure at the bottom of the lithosphere.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Surface pressure                       = 0
+
+# When computing results for mantle convection simulations, it is often
+# difficult to judge the order of magnitude of results when they are stated in
+# MKS units involving seconds. Rather, some kinds of results such as
+# velocities are often stated in terms of meters per year (or, sometimes,
+# centimeters per year). On the other hand, for non-dimensional computations,
+# one wants results in their natural unit system as used inside the code. If
+# this flag is set to 'true' conversion to years happens; if it is 'false', no
+# such conversion happens.
+set Use years in output instead of seconds = false
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=0.0, gamma=1.0
+    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+subsection Formulation
+  set Formulation = Boussinesq approximation
+
+  #set Mass conservation        = incompressible
+  #set Temperature equation     = reference density profile
+end
+
+subsection Boundary temperature model
+  set List of model names = Tan Gurnis
+
+  # A comma separated list of integers denoting those boundaries on which the
+  # temperature is fixed and described by the boundary temperature object
+  # selected in its own section of this input file. All boundary indicators
+  # used by the geometry but not explicitly listed here will end up with
+  # no-flux (insulating) boundary conditions.
+  set Fixed temperature boundary indicators   = left, right, bottom, top
+end
+
+subsection Discretization
+  # The polynomial degree to use for the velocity variables in the Stokes
+  # system. Units: None.
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+
+  # Whether to use a Stokes discretization that is locally conservative at the
+  # expense of a larger number of degrees of freedom (true), or to go with a
+  # cheaper discretization that does not locally conserve mass, although it is
+  # globally conservative (false).
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    # Extent of the box in x-direction. Units: \\si{\\meter}.
+    set X extent = 1
+
+    # Extent of the box in y-direction. Units: \\si{\\meter}.
+    set Y extent = 1
+
+    # Extent of the box in z-direction. This value is ignored if the
+    # simulation is in 2d Units: \\si{\\meter}.
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*y)*cos(pi*1*x)
+  end
+end
+
+subsection Material model
+  set Model name = Tan Gurnis
+
+  subsection Tan Gurnis model
+    set Di                            = 0
+    set gamma                         = 1 # infinity really, but does not matter
+    set a                             = 0
+    set wavenumber                    = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+
+  # The method used to determine which cells to refine and which to coarsen.
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 100
+end
+
+subsection Boundary velocity model
+  # A comma separated list of integers denoting those boundaries on which the
+  # velocity is tangential and unrestrained, i.e., where no external forces
+  # act to prescribe a particular tangential velocity (although there is a
+  # force that requires the flow to be tangential).
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  # A comma separated list of postprocessor objects that should be run at the
+  # end of each time step. Some of these postprocessors will declare their own
+  # parameters which may, for example, include that they will actually do
+  # something only every so many time steps or years. Alternatively, the text
+  # 'all' indicates that all available postprocessors should be run after each
+  # time step.
+  #
+  # The following postprocessors are available:
+  #
+  # `depth average': A postprocessor that computes depth averaged quantities
+  # and writes them out.
+  #
+  # `heat flux statistics': A postprocessor that computes some statistics
+  # about the heat flux across boundaries.
+  #
+  # `heat flux statistics for the table model': A postprocessor that computes
+  # some statistics about the heat flux across boundaries.
+  #
+  # `velocity statistics for the table model': A postprocessor that computes
+  # some statistics about the velocity field.
+  #
+  # `temperature statistics': A postprocessor that computes some statistics
+  # about the temperature field.
+  #
+  # `velocity statistics': A postprocessor that computes some statistics about
+  # the velocity field.
+  #
+  # `visualization': A postprocessor that takes the solution and writes it
+  # into files that can be read by a graphical visualization program.
+  # Additional run time parameters are read from the parameter subsection
+  # 'Visualization'.
+  set List of postprocessors = Tan Gurnis error, visualization
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/tangurnis_ba_custom.cc.bak b/tests/tangurnis_ba_custom.cc.bak
new file mode 100644
index 00000000000..7966a8ab1f8
--- /dev/null
+++ b/tests/tangurnis_ba_custom.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "tangurnis.cc"
diff --git a/tests/tangurnis_ba_custom.prm.bak b/tests/tangurnis_ba_custom.prm.bak
new file mode 100644
index 00000000000..0e466aaaed5
--- /dev/null
+++ b/tests/tangurnis_ba_custom.prm.bak
@@ -0,0 +1,247 @@
+# identical to tangurnis_ba.prm, but using a custom "formulation" instead of BA
+
+set Additional shared libraries            = ./code/libtangurnis.so
+
+# At the top, state that the program should be run for a two-dimensional
+# simulation
+set Dimension = 2
+
+# In computations, the time step $k$ is chosen according to $k = c \min_K
+# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
+# and the denominator is the maximal magnitude of the velocity on cell $K$
+# times the polynomial degree $p_T$ of the temperature discretization. The
+# dimensionless constant $c$ is called the CFL number in this program. For
+# time discretizations that have explicit components, $c$ must be less than a
+# constant that depends on the details of the time discretization and that is
+# no larger than one. On the other hand, for implicit discretizations such as
+# the one chosen here, one can choose the time step as large as one wants (in
+# particular, one can choose $c>1$) though a CFL number significantly larger
+# than one will yield rather diffusive solutions. Units: None.
+set CFL number                             = 1.0
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0.0001
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# The name of the directory into which all output files should be placed. This
+# may be an absolute or a relative path.
+set Output directory                       = output
+
+# A flag indicating whether the computation should be resumed from a
+# previously saved state (if true) or start from scratch (if false).
+set Resume computation                     = false
+
+# The start time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set Start time                             = 0
+
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Adiabatic surface temperature          = 0
+
+# The mathematical equations that describe thermal convection only determine
+# the pressure up to an arbitrary constant. On the other hand, for comparison
+# and for looking up material parameters it is important that the pressure be
+# normalized somehow. We do this by enforcing a particular average pressure
+# value at the surface of the domain, where the geometry model determines
+# where the surface is. This parameter describes what this average surface
+# pressure value is supposed to be. By default, it is set to zero, but one may
+# want to choose a different value for example for simulating only the volume
+# of the mantle below the lithosphere, in which case the surface pressure
+# should be the lithostatic pressure at the bottom of the lithosphere.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Surface pressure                       = 0
+
+# When computing results for mantle convection simulations, it is often
+# difficult to judge the order of magnitude of results when they are stated in
+# MKS units involving seconds. Rather, some kinds of results such as
+# velocities are often stated in terms of meters per year (or, sometimes,
+# centimeters per year). On the other hand, for non-dimensional computations,
+# one wants results in their natural unit system as used inside the code. If
+# this flag is set to 'true' conversion to years happens; if it is 'false', no
+# such conversion happens.
+set Use years in output instead of seconds = false
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=0.0, gamma=1.0
+    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation        = incompressible
+  set Temperature equation     = reference density profile
+end
+
+subsection Boundary temperature model
+  set List of model names = Tan Gurnis
+
+  # A comma separated list of integers denoting those boundaries on which the
+  # temperature is fixed and described by the boundary temperature object
+  # selected in its own section of this input file. All boundary indicators
+  # used by the geometry but not explicitly listed here will end up with
+  # no-flux (insulating) boundary conditions.
+  set Fixed temperature boundary indicators   = left, right, bottom, top
+end
+
+subsection Discretization
+  # The polynomial degree to use for the velocity variables in the Stokes
+  # system. Units: None.
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+
+  # Whether to use a Stokes discretization that is locally conservative at the
+  # expense of a larger number of degrees of freedom (true), or to go with a
+  # cheaper discretization that does not locally conserve mass, although it is
+  # globally conservative (false).
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    # Extent of the box in x-direction. Units: \\si{\\meter}.
+    set X extent = 1
+
+    # Extent of the box in y-direction. Units: \\si{\\meter}.
+    set Y extent = 1
+
+    # Extent of the box in z-direction. This value is ignored if the
+    # simulation is in 2d Units: \\si{\\meter}.
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*y)*cos(pi*1*x)
+  end
+end
+
+subsection Material model
+  set Model name = Tan Gurnis
+
+  subsection Tan Gurnis model
+    set Di                            = 0
+    set gamma                         = 1 # infinity really, but does not matter
+    set a                             = 0
+    set wavenumber                    = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+
+  # The method used to determine which cells to refine and which to coarsen.
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 100
+end
+
+subsection Boundary velocity model
+  # A comma separated list of integers denoting those boundaries on which the
+  # velocity is tangential and unrestrained, i.e., where no external forces
+  # act to prescribe a particular tangential velocity (although there is a
+  # force that requires the flow to be tangential).
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  # A comma separated list of postprocessor objects that should be run at the
+  # end of each time step. Some of these postprocessors will declare their own
+  # parameters which may, for example, include that they will actually do
+  # something only every so many time steps or years. Alternatively, the text
+  # 'all' indicates that all available postprocessors should be run after each
+  # time step.
+  #
+  # The following postprocessors are available:
+  #
+  # `depth average': A postprocessor that computes depth averaged quantities
+  # and writes them out.
+  #
+  # `heat flux statistics': A postprocessor that computes some statistics
+  # about the heat flux across boundaries.
+  #
+  # `heat flux statistics for the table model': A postprocessor that computes
+  # some statistics about the heat flux across boundaries.
+  #
+  # `velocity statistics for the table model': A postprocessor that computes
+  # some statistics about the velocity field.
+  #
+  # `temperature statistics': A postprocessor that computes some statistics
+  # about the temperature field.
+  #
+  # `velocity statistics': A postprocessor that computes some statistics about
+  # the velocity field.
+  #
+  # `visualization': A postprocessor that takes the solution and writes it
+  # into files that can be read by a graphical visualization program.
+  # Additional run time parameters are read from the parameter subsection
+  # 'Visualization'.
+  set List of postprocessors = Tan Gurnis error, visualization
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/tangurnis_tala.cc.bak b/tests/tangurnis_tala.cc.bak
new file mode 100644
index 00000000000..7966a8ab1f8
--- /dev/null
+++ b/tests/tangurnis_tala.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "tangurnis.cc"
diff --git a/tests/tangurnis_tala.prm.bak b/tests/tangurnis_tala.prm.bak
new file mode 100644
index 00000000000..7e2a84cd8dd
--- /dev/null
+++ b/tests/tangurnis_tala.prm.bak
@@ -0,0 +1,262 @@
+# TanGurnis benchmark TALA
+
+set Additional shared libraries            = ./code/libtangurnis.so
+
+# At the top, state that the program should be run for a two-dimensional
+# simulation
+set Dimension = 2
+
+# In computations, the time step $k$ is chosen according to $k = c \min_K
+# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
+# and the denominator is the maximal magnitude of the velocity on cell $K$
+# times the polynomial degree $p_T$ of the temperature discretization. The
+# dimensionless constant $c$ is called the CFL number in this program. For
+# time discretizations that have explicit components, $c$ must be less than a
+# constant that depends on the details of the time discretization and that is
+# no larger than one. On the other hand, for implicit discretizations such as
+# the one chosen here, one can choose the time step as large as one wants (in
+# particular, one can choose $c>1$) though a CFL number significantly larger
+# than one will yield rather diffusive solutions. Units: None.
+set CFL number                             = 1.0
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0.0001
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# The name of the directory into which all output files should be placed. This
+# may be an absolute or a relative path.
+set Output directory                       = output_tala
+
+# A flag indicating whether the computation should be resumed from a
+# previously saved state (if true) or start from scratch (if false).
+set Resume computation                     = false
+
+# The start time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set Start time                             = 0
+
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Adiabatic surface temperature          = 0
+
+# The mathematical equations that describe thermal convection only determine
+# the pressure up to an arbitrary constant. On the other hand, for comparison
+# and for looking up material parameters it is important that the pressure be
+# normalized somehow. We do this by enforcing a particular average pressure
+# value at the surface of the domain, where the geometry model determines
+# where the surface is. This parameter describes what this average surface
+# pressure value is supposed to be. By default, it is set to zero, but one may
+# want to choose a different value for example for simulating only the volume
+# of the mantle below the lithosphere, in which case the surface pressure
+# should be the lithostatic pressure at the bottom of the lithosphere.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Surface pressure                       = 0
+
+# When computing results for mantle convection simulations, it is often
+# difficult to judge the order of magnitude of results when they are stated in
+# MKS units involving seconds. Rather, some kinds of results such as
+# velocities are often stated in terms of meters per year (or, sometimes,
+# centimeters per year). On the other hand, for non-dimensional computations,
+# one wants results in their natural unit system as used inside the code. If
+# this flag is set to 'true' conversion to years happens; if it is 'false', no
+# such conversion happens.
+set Use years in output instead of seconds = false
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=0.5, gamma=1.0
+    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation        = reference density profile
+  set Temperature equation     = reference density profile
+end
+
+subsection Boundary temperature model
+  set List of model names = Tan Gurnis
+
+  # A comma separated list of integers denoting those boundaries on which the
+  # temperature is fixed and described by the boundary temperature object
+  # selected in its own section of this input file. All boundary indicators
+  # used by the geometry but not explicitly listed here will end up with
+  # no-flux (insulating) boundary conditions.
+  set Fixed temperature boundary indicators   = left, right, bottom, top
+end
+
+subsection Discretization
+  # The polynomial degree to use for the velocity variables in the Stokes
+  # system. Units: None.
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+
+  # Whether to use a Stokes discretization that is locally conservative at the
+  # expense of a larger number of degrees of freedom (true), or to go with a
+  # cheaper discretization that does not locally conserve mass, although it is
+  # globally conservative (false).
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    # Extent of the box in x-direction. Units: \\si{\\meter}.
+    set X extent = 1
+
+    # Extent of the box in y-direction. Units: \\si{\\meter}.
+    set Y extent = 1
+
+    # Extent of the box in z-direction. This value is ignored if the
+    # simulation is in 2d Units: \\si{\\meter}.
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*y)*cos(pi*1*x)
+  end
+end
+
+subsection Material model
+  set Model name = Tan Gurnis
+
+  subsection Tan Gurnis model
+    set Di                            = 0.5
+    set gamma                         = 1
+    set a                             = 0
+    set wavenumber                    = 1
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+
+  # The method used to determine which cells to refine and which to coarsen.
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 100
+end
+
+subsection Boundary velocity model
+  # A comma separated list of integers denoting those boundaries on which the
+  # velocity is tangential and unrestrained, i.e., where no external forces
+  # act to prescribe a particular tangential velocity (although there is a
+  # force that requires the flow to be tangential).
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  # A comma separated list of postprocessor objects that should be run at the
+  # end of each time step. Some of these postprocessors will declare their own
+  # parameters which may, for example, include that they will actually do
+  # something only every so many time steps or years. Alternatively, the text
+  # 'all' indicates that all available postprocessors should be run after each
+  # time step.
+  #
+  # The following postprocessors are available:
+  #
+  # `depth average': A postprocessor that computes depth averaged quantities
+  # and writes them out.
+  #
+  # `heat flux statistics': A postprocessor that computes some statistics
+  # about the heat flux across boundaries.
+  #
+  # `heat flux statistics for the table model': A postprocessor that computes
+  # some statistics about the heat flux across boundaries.
+  #
+  # `velocity statistics for the table model': A postprocessor that computes
+  # some statistics about the velocity field.
+  #
+  # `temperature statistics': A postprocessor that computes some statistics
+  # about the temperature field.
+  #
+  # `velocity statistics': A postprocessor that computes some statistics about
+  # the velocity field.
+  #
+  # `visualization': A postprocessor that takes the solution and writes it
+  # into files that can be read by a graphical visualization program.
+  # Additional run time parameters are read from the parameter subsection
+  # 'Visualization'.
+  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, adiabat
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/tangurnis_tala_c.cc.bak b/tests/tangurnis_tala_c.cc.bak
new file mode 100644
index 00000000000..7966a8ab1f8
--- /dev/null
+++ b/tests/tangurnis_tala_c.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "tangurnis.cc"
diff --git a/tests/tangurnis_tala_c.prm.bak b/tests/tangurnis_tala_c.prm.bak
new file mode 100644
index 00000000000..0614afabf96
--- /dev/null
+++ b/tests/tangurnis_tala_c.prm.bak
@@ -0,0 +1,262 @@
+# TanGurnis benchmark TALA benchmark with a=2
+
+set Additional shared libraries            = ./code/libtangurnis.so
+
+# At the top, state that the program should be run for a two-dimensional
+# simulation
+set Dimension = 2
+
+# In computations, the time step $k$ is chosen according to $k = c \min_K
+# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
+# and the denominator is the maximal magnitude of the velocity on cell $K$
+# times the polynomial degree $p_T$ of the temperature discretization. The
+# dimensionless constant $c$ is called the CFL number in this program. For
+# time discretizations that have explicit components, $c$ must be less than a
+# constant that depends on the details of the time discretization and that is
+# no larger than one. On the other hand, for implicit discretizations such as
+# the one chosen here, one can choose the time step as large as one wants (in
+# particular, one can choose $c>1$) though a CFL number significantly larger
+# than one will yield rather diffusive solutions. Units: None.
+set CFL number                             = 1.0
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0.0001
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# The name of the directory into which all output files should be placed. This
+# may be an absolute or a relative path.
+set Output directory                       = output
+
+# A flag indicating whether the computation should be resumed from a
+# previously saved state (if true) or start from scratch (if false).
+set Resume computation                     = false
+
+# The start time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set Start time                             = 0
+
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Adiabatic surface temperature          = 0
+
+# The mathematical equations that describe thermal convection only determine
+# the pressure up to an arbitrary constant. On the other hand, for comparison
+# and for looking up material parameters it is important that the pressure be
+# normalized somehow. We do this by enforcing a particular average pressure
+# value at the surface of the domain, where the geometry model determines
+# where the surface is. This parameter describes what this average surface
+# pressure value is supposed to be. By default, it is set to zero, but one may
+# want to choose a different value for example for simulating only the volume
+# of the mantle below the lithosphere, in which case the surface pressure
+# should be the lithostatic pressure at the bottom of the lithosphere.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Surface pressure                       = 0
+
+# When computing results for mantle convection simulations, it is often
+# difficult to judge the order of magnitude of results when they are stated in
+# MKS units involving seconds. Rather, some kinds of results such as
+# velocities are often stated in terms of meters per year (or, sometimes,
+# centimeters per year). On the other hand, for non-dimensional computations,
+# one wants results in their natural unit system as used inside the code. If
+# this flag is set to 'true' conversion to years happens; if it is 'false', no
+# such conversion happens.
+set Use years in output instead of seconds = false
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=0.5, gamma=1.0
+    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation        = reference density profile
+  set Temperature equation     = reference density profile
+end
+
+subsection Boundary temperature model
+  set List of model names = Tan Gurnis
+
+  # A comma separated list of integers denoting those boundaries on which the
+  # temperature is fixed and described by the boundary temperature object
+  # selected in its own section of this input file. All boundary indicators
+  # used by the geometry but not explicitly listed here will end up with
+  # no-flux (insulating) boundary conditions.
+  set Fixed temperature boundary indicators   = left, right, bottom, top
+end
+
+subsection Discretization
+  # The polynomial degree to use for the velocity variables in the Stokes
+  # system. Units: None.
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+
+  # Whether to use a Stokes discretization that is locally conservative at the
+  # expense of a larger number of degrees of freedom (true), or to go with a
+  # cheaper discretization that does not locally conserve mass, although it is
+  # globally conservative (false).
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    # Extent of the box in x-direction. Units: \\si{\\meter}.
+    set X extent = 1
+
+    # Extent of the box in y-direction. Units: \\si{\\meter}.
+    set Y extent = 1
+
+    # Extent of the box in z-direction. This value is ignored if the
+    # simulation is in 2d Units: \\si{\\meter}.
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*y)*cos(pi*1*x)
+  end
+end
+
+subsection Material model
+  set Model name = Tan Gurnis
+
+  subsection Tan Gurnis model
+    set Di                            = 0.5
+    set gamma                         = 1
+    set a                             = 2
+    set wavenumber                    = 1
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+
+  # The method used to determine which cells to refine and which to coarsen.
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 100
+end
+
+subsection Boundary velocity model
+  # A comma separated list of integers denoting those boundaries on which the
+  # velocity is tangential and unrestrained, i.e., where no external forces
+  # act to prescribe a particular tangential velocity (although there is a
+  # force that requires the flow to be tangential).
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  # A comma separated list of postprocessor objects that should be run at the
+  # end of each time step. Some of these postprocessors will declare their own
+  # parameters which may, for example, include that they will actually do
+  # something only every so many time steps or years. Alternatively, the text
+  # 'all' indicates that all available postprocessors should be run after each
+  # time step.
+  #
+  # The following postprocessors are available:
+  #
+  # `depth average': A postprocessor that computes depth averaged quantities
+  # and writes them out.
+  #
+  # `heat flux statistics': A postprocessor that computes some statistics
+  # about the heat flux across boundaries.
+  #
+  # `heat flux statistics for the table model': A postprocessor that computes
+  # some statistics about the heat flux across boundaries.
+  #
+  # `velocity statistics for the table model': A postprocessor that computes
+  # some statistics about the velocity field.
+  #
+  # `temperature statistics': A postprocessor that computes some statistics
+  # about the temperature field.
+  #
+  # `velocity statistics': A postprocessor that computes some statistics about
+  # the velocity field.
+  #
+  # `visualization': A postprocessor that takes the solution and writes it
+  # into files that can be read by a graphical visualization program.
+  # Additional run time parameters are read from the parameter subsection
+  # 'Visualization'.
+  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, adiabat
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+  end
+end
diff --git a/tests/tangurnis_tala_gmg.cc.bak b/tests/tangurnis_tala_gmg.cc.bak
new file mode 100644
index 00000000000..7966a8ab1f8
--- /dev/null
+++ b/tests/tangurnis_tala_gmg.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "tangurnis.cc"
diff --git a/tests/tangurnis_tala_gmg.prm.bak b/tests/tangurnis_tala_gmg.prm.bak
new file mode 100644
index 00000000000..e53df20f5ea
--- /dev/null
+++ b/tests/tangurnis_tala_gmg.prm.bak
@@ -0,0 +1,19 @@
+# TanGurnis benchmark TALA using geometric multigrid preconditioner
+
+include $ASPECT_SOURCE_DIR/benchmarks/tangurnis/tala/tan.prm
+
+
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
diff --git a/tests/tangurnis_tala_implicit.cc.bak b/tests/tangurnis_tala_implicit.cc.bak
new file mode 100644
index 00000000000..7966a8ab1f8
--- /dev/null
+++ b/tests/tangurnis_tala_implicit.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "tangurnis.cc"
diff --git a/tests/tangurnis_tala_implicit.prm.bak b/tests/tangurnis_tala_implicit.prm.bak
new file mode 100644
index 00000000000..8e7086c7949
--- /dev/null
+++ b/tests/tangurnis_tala_implicit.prm.bak
@@ -0,0 +1,265 @@
+# TanGurnis benchmark TALA, like tangurnis_tala.prm but using the implicit
+# mass formulation leading to a single newton step
+
+set Additional shared libraries            = ./code/libtangurnis.so
+
+# At the top, state that the program should be run for a two-dimensional
+# simulation
+set Dimension = 2
+
+# In computations, the time step $k$ is chosen according to $k = c \min_K
+# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
+# and the denominator is the maximal magnitude of the velocity on cell $K$
+# times the polynomial degree $p_T$ of the temperature discretization. The
+# dimensionless constant $c$ is called the CFL number in this program. For
+# time discretizations that have explicit components, $c$ must be less than a
+# constant that depends on the details of the time discretization and that is
+# no larger than one. On the other hand, for implicit discretizations such as
+# the one chosen here, one can choose the time step as large as one wants (in
+# particular, one can choose $c>1$) though a CFL number significantly larger
+# than one will yield rather diffusive solutions. Units: None.
+set CFL number                             = 1.0
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 0.0001
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+# The name of the directory into which all output files should be placed. This
+# may be an absolute or a relative path.
+set Output directory                       = output_tala
+
+# A flag indicating whether the computation should be resumed from a
+# previously saved state (if true) or start from scratch (if false).
+set Resume computation                     = false
+
+# The start time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set Start time                             = 0
+
+# In order to make the problem in the first time step easier to solve, we need
+# a reasonable guess for the temperature and pressure. To obtain it, we use an
+# adiabatic pressure and temperature field. This parameter describes what the
+# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
+# zero). Note that this value need not coincide with the boundary condition
+# posed at this point. Rather, the boundary condition may differ significantly
+# from the adiabatic value, and then typically induce a thermal boundary
+# layer.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Adiabatic surface temperature          = 0
+
+# The mathematical equations that describe thermal convection only determine
+# the pressure up to an arbitrary constant. On the other hand, for comparison
+# and for looking up material parameters it is important that the pressure be
+# normalized somehow. We do this by enforcing a particular average pressure
+# value at the surface of the domain, where the geometry model determines
+# where the surface is. This parameter describes what this average surface
+# pressure value is supposed to be. By default, it is set to zero, but one may
+# want to choose a different value for example for simulating only the volume
+# of the mantle below the lithosphere, in which case the surface pressure
+# should be the lithostatic pressure at the bottom of the lithosphere.
+# For more information, see the section in the manual that discusses the
+# general mathematical model.
+set Surface pressure                       = 0
+
+# When computing results for mantle convection simulations, it is often
+# difficult to judge the order of magnitude of results when they are stated in
+# MKS units involving seconds. Rather, some kinds of results such as
+# velocities are often stated in terms of meters per year (or, sometimes,
+# centimeters per year). On the other hand, for non-dimensional computations,
+# one wants results in their natural unit system as used inside the code. If
+# this flag is set to 'true' conversion to years happens; if it is 'false', no
+# such conversion happens.
+set Use years in output instead of seconds = false
+
+subsection Adiabatic conditions model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = Di=0.5, gamma=1.0
+    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
+    set Variable names      = depth
+  end
+end
+
+subsection Formulation
+  set Formulation = custom
+  set Mass conservation        = implicit reference density profile
+  set Temperature equation     = reference density profile
+end
+
+subsection Boundary temperature model
+  set List of model names = Tan Gurnis
+
+  # A comma separated list of integers denoting those boundaries on which the
+  # temperature is fixed and described by the boundary temperature object
+  # selected in its own section of this input file. All boundary indicators
+  # used by the geometry but not explicitly listed here will end up with
+  # no-flux (insulating) boundary conditions.
+  set Fixed temperature boundary indicators   = left, right, bottom, top
+end
+
+subsection Discretization
+  # The polynomial degree to use for the velocity variables in the Stokes
+  # system. Units: None.
+  set Stokes velocity polynomial degree       = 2
+
+  # The polynomial degree to use for the temperature variable. Units: None.
+  set Temperature polynomial degree           = 2
+
+  # Whether to use a Stokes discretization that is locally conservative at the
+  # expense of a larger number of degrees of freedom (true), or to go with a
+  # cheaper discretization that does not locally conserve mass, although it is
+  # globally conservative (false).
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
+    # None.
+    set alpha = 2
+
+    # The $\beta$ factor in the artificial viscosity stabilization. An
+    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
+    set beta  = 0.078
+
+    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    # Extent of the box in x-direction. Units: \\si{\\meter}.
+    set X extent = 1
+
+    # Extent of the box in y-direction. Units: \\si{\\meter}.
+    set Y extent = 1
+
+    # Extent of the box in z-direction. This value is ignored if the
+    # simulation is in 2d Units: \\si{\\meter}.
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = sin(pi*y)*cos(pi*1*x)
+  end
+end
+
+subsection Material model
+  set Model name = Tan Gurnis
+  set Material averaging = none
+
+  subsection Tan Gurnis model
+    set Di                            = 0.5
+    set gamma                         = 1
+    set a                             = 0
+    set wavenumber                    = 1
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+
+  # The method used to determine which cells to refine and which to coarsen.
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 100
+end
+
+subsection Boundary velocity model
+  # A comma separated list of integers denoting those boundaries on which the
+  # velocity is tangential and unrestrained, i.e., where no external forces
+  # act to prescribe a particular tangential velocity (although there is a
+  # force that requires the flow to be tangential).
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Postprocess
+  # A comma separated list of postprocessor objects that should be run at the
+  # end of each time step. Some of these postprocessors will declare their own
+  # parameters which may, for example, include that they will actually do
+  # something only every so many time steps or years. Alternatively, the text
+  # 'all' indicates that all available postprocessors should be run after each
+  # time step.
+  #
+  # The following postprocessors are available:
+  #
+  # `depth average': A postprocessor that computes depth averaged quantities
+  # and writes them out.
+  #
+  # `heat flux statistics': A postprocessor that computes some statistics
+  # about the heat flux across boundaries.
+  #
+  # `heat flux statistics for the table model': A postprocessor that computes
+  # some statistics about the heat flux across boundaries.
+  #
+  # `velocity statistics for the table model': A postprocessor that computes
+  # some statistics about the velocity field.
+  #
+  # `temperature statistics': A postprocessor that computes some statistics
+  # about the temperature field.
+  #
+  # `velocity statistics': A postprocessor that computes some statistics about
+  # the velocity field.
+  #
+  # `visualization': A postprocessor that takes the solution and writes it
+  # into files that can be read by a graphical visualization program.
+  # Additional run time parameters are read from the parameter subsection
+  # 'Visualization'.
+  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
+
+  subsection Depth average
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, adiabat
+
+    # VTU file output supports grouping files from several CPUs into one file
+    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
+    # grouping. This will disable parallel file output and instead write one
+    # file per processor in a background thread. A value of 1 will generate
+    # one big file containing the whole solution.
+    set Number of grouped files       = 0
+
+    # The file format to be used for graphical output.
+    set Output format                 = vtu
+
+    # The time interval between each generation of graphical output files. A
+    # value of zero indicates that output should be generated in each time
+    # step. Units: years if the 'Use years in output instead of seconds'
+    # parameter is set; seconds otherwise.
+    set Time between graphical output = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = false
+    set Stokes solver type = block AMG
+  end
+end
diff --git a/tests/temperature_dependent_stokes_matrix.prm.bak b/tests/temperature_dependent_stokes_matrix.prm.bak
new file mode 100644
index 00000000000..a88d77568ed
--- /dev/null
+++ b/tests/temperature_dependent_stokes_matrix.prm.bak
@@ -0,0 +1,76 @@
+# We used to have the problem that if the viscosity
+# depended on the temperature, we would still not want
+# to re-compute the Stokes matrix. This was a clear bug.
+# This test verifies that this is now fixed by creating
+# a temperature-dependent viscosity and using it to run
+# a model that has several time steps. The velocities we
+# get need to be the ones that come from the re-computed
+# Stokes matrix, and they have different RMS values.
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e6
+set Start time                             = 0
+set Adiabatic surface temperature          = 1.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+
+    # This is the point of this test:
+    set Thermal viscosity exponent = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity
+  end
+end
diff --git a/tests/terminate_user_request.cc.bak b/tests/terminate_user_request.cc.bak
new file mode 100644
index 00000000000..7186bafb99f
--- /dev/null
+++ b/tests/terminate_user_request.cc.bak
@@ -0,0 +1,34 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+
+// Create a function that is run upon loading the plugin. We delete the
+// restart.mesh file that is used as a trigger for terminating
+// ASPECT. Otherwise we might have a left over file that triggers termination
+// immediately.
+int f()
+{
+  system ("rm -f output-terminate_user_request/restart.mesh");
+  return 42;
+}
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/terminate_user_request.prm.bak b/tests/terminate_user_request.prm.bak
new file mode 100644
index 00000000000..a761cbf58ca
--- /dev/null
+++ b/tests/terminate_user_request.prm.bak
@@ -0,0 +1,71 @@
+# a test that verifies that we indeed terminate when a particular file was
+# found in the output directory. the file name we choose is that of a
+# checkpointing file that we write at the end of time step 5, so that we
+# terminate after time step 6
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e7
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = user request
+
+  subsection User request
+    set File name = restart.mesh
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 5
+end
diff --git a/tests/thermal_alpha_s40rts.prm.bak b/tests/thermal_alpha_s40rts.prm.bak
new file mode 100644
index 00000000000..7568693c500
--- /dev/null
+++ b/tests/thermal_alpha_s40rts.prm.bak
@@ -0,0 +1,66 @@
+# Test for S40RTS initial condition using thermal expansion from the material model
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1600
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity                     = 1e22
+    set Thermal viscosity exponent    = 5.0
+    set Reference temperature         = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = 0,1
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 2600
+    set Outer temperature = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = S40RTS perturbation
+
+  subsection S40RTS perturbation
+    set Use thermal expansion coefficient from material model = true
+    set Thermal expansion coefficient in initial temperature scaling = 1 # large value since this shouldn't be used
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
+end
diff --git a/tests/tian_MORB.prm.bak b/tests/tian_MORB.prm.bak
new file mode 100644
index 00000000000..4b0706a9f3e
--- /dev/null
+++ b/tests/tian_MORB.prm.bak
@@ -0,0 +1,27 @@
+# This model generates a representation of a phase diagram for the equilibrium
+# wt% water that can be stored in a MORB as shown in Figure 5 of Tian et. al., 2019.
+# This model reproduces that phase diagram (very low res by default), with an important
+# caveat being that the pressure axis is inverted relative to the ASPECT output.
+# A surface pressure of 600 MPa is imposed to reproduce the pressure axis,
+# and a lateral temperature gradient is imposed to reproduce the temperature axis.
+include $ASPECT_SOURCE_DIR/tests/tian_peridotite.prm
+
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = initial_porosity; \
+                              initial_bound_water; \
+                              0; \
+                              0; \
+                              1; \
+                              0
+  end
+end
+
+subsection Material model
+  subsection Reactive Fluid Transport Model
+    set Maximum weight percent water in MORB                    = 5.3
+  end
+end
diff --git a/tests/tian_gabbro.prm.bak b/tests/tian_gabbro.prm.bak
new file mode 100644
index 00000000000..b96ed026bf8
--- /dev/null
+++ b/tests/tian_gabbro.prm.bak
@@ -0,0 +1,27 @@
+# This model generates a representation of a phase diagram for the equilibrium
+# wt% water that can be stored in a gabbro as shown in Figure 2 of Tian et. al., 2019.
+# This model reproduces that phase diagram (very low res by default), with an important
+# caveat being that the pressure axis is inverted relative to the ASPECT output.
+# A surface pressure of 600 MPa is imposed to reproduce the pressure axis,
+# and a lateral temperature gradient is imposed to reproduce the temperature axis.
+include $ASPECT_SOURCE_DIR/tests/tian_peridotite.prm
+
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = initial_porosity; \
+                              initial_bound_water; \
+                              0; \
+                              1; \
+                              0; \
+                              0
+  end
+end
+
+subsection Material model
+  subsection Reactive Fluid Transport Model
+    set Maximum weight percent water in gabbro                    = 5.1
+  end
+end
diff --git a/tests/tian_peridotite.prm.bak b/tests/tian_peridotite.prm.bak
new file mode 100644
index 00000000000..df0f6571a49
--- /dev/null
+++ b/tests/tian_peridotite.prm.bak
@@ -0,0 +1,122 @@
+# This model generates a representation of a phase diagram for the equilibrium
+# wt% water that can be stored in an upper mantle peridotite (PUM) as shown in
+# Figure 11 of  Tian et. al., 2019. This model reproduces that phase diagram
+# (very low res by default), with an important caveat being that the pressure axis
+# is inverted relative to the ASPECT output. A surface pressure of 600 MPa is imposed
+# to reproduce the pressure axis,and a lateral temperature gradient is imposed to
+# reproduce the temperature axis.
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 10
+set Nonlinear solver tolerance             = 1e-5
+set Surface pressure                       = 0.6e9
+set Dimension                              = 2
+set End time                               = 1e3
+set Maximum time step                      = 1e3
+set Use operator splitting                 = true
+
+# The Tian approximation implementation requires that all 4 rock compositions exist
+# as compositional fields, though they do not have to all be non zero.
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields = porosity, bound_fluid, peridotite, gabbro, MORB, sediment
+end
+
+# Specify that the entire domain is peridotite, with an initial bound water content
+# of 11% everywhere, the bound_water will evolve to the parametrized phase diagram
+# for peridotite.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = initial_porosity=0.0, initial_bound_water=0.11
+    set Function expression = initial_porosity; \
+                              initial_bound_water; \
+                              1; \
+                              0; \
+                              0; \
+                              0
+  end
+end
+
+# Zero velocity boundaries
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = left, right, top, bottom
+end
+
+# Make the model 200km x 200km so that the Pressure extends to 6 GPa,
+# as in phase diagrams from Tian et al., 2019
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 200e3
+    set Y extent  = 200e3
+    set Y repetitions = 1
+    set X repetitions = 1
+  end
+end
+
+# 10 m/s^2 vertical gravity
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Lateral temperature gradient from 300 - 1000 C, as in
+# phase diagrams from Tian et al., 2019
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system   = cartesian
+    set Variable names      = x,y
+    set Function constants  = Tmin=573, Tmax=1273
+    set Function expression = Tmin + (Tmax - Tmin) * x/200e3
+  end
+end
+
+# Keep the temperature fixed
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom, right, left
+  set List of model names = initial temperature
+
+  subsection Initial temperature
+    set Maximal temperature = 573
+    set Minimal temperature = 1273
+  end
+end
+
+# Material model, using the simpler base model and selecting the tian approximation
+# as the fluid solid reaction scheme for the reactive fluid transport model.
+subsection Material model
+  set Model name = reactive fluid transport
+
+  subsection Reactive Fluid Transport Model
+    set Base model                                       = simpler
+    set Reference fluid density                          = 3000
+    set Fluid reaction time scale for operator splitting = 1e2
+    set Fluid-solid reaction scheme                      = tian approximation
+    set Maximum weight percent water in peridotite       = 11
+  end
+
+  subsection Simpler model
+    set Reference density             = 3000.0
+    set Thermal expansion coefficient = 1e-5
+  end
+end
+
+subsection Melt settings
+  set Include melt transport = true
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 2
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
diff --git a/tests/tian_sediment.prm.bak b/tests/tian_sediment.prm.bak
new file mode 100644
index 00000000000..9e2f6973ba7
--- /dev/null
+++ b/tests/tian_sediment.prm.bak
@@ -0,0 +1,27 @@
+# This model generates a representation of a phase diagram for the equilibrium
+# wt% water that can be stored in a sediment as shown in Figure 8 of Tian et. al., 2019.
+# This model reproduces that phase diagram (very low res by default), with an important
+# caveat being that the pressure axis is inverted relative to the ASPECT output.
+# A surface pressure of 600 MPa is imposed to reproduce the pressure axis,
+# and a lateral temperature gradient is imposed to reproduce the temperature axis.
+include $ASPECT_SOURCE_DIR/tests/tian_peridotite.prm
+
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = initial_porosity; \
+                              initial_bound_water; \
+                              0; \
+                              0; \
+                              0; \
+                              1
+  end
+end
+
+subsection Material model
+  subsection Reactive Fluid Transport Model
+    set Maximum weight percent water in sediment                 = 3.2
+  end
+end
diff --git a/tests/time_dependent_annulus.cc.bak b/tests/time_dependent_annulus.cc.bak
new file mode 100644
index 00000000000..d763f64cea7
--- /dev/null
+++ b/tests/time_dependent_annulus.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc"
diff --git a/tests/time_dependent_annulus.prm.bak b/tests/time_dependent_annulus.prm.bak
new file mode 100644
index 00000000000..34f4829f94d
--- /dev/null
+++ b/tests/time_dependent_annulus.prm.bak
@@ -0,0 +1,10 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/benchmarks/time_dependent_annulus/time_dependent_annulus.prm
+
+set End time = 0.003
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 1
+end
diff --git a/tests/time_dependent_temperature_bc.cc.bak b/tests/time_dependent_temperature_bc.cc.bak
new file mode 100644
index 00000000000..0d4ed45e8ac
--- /dev/null
+++ b/tests/time_dependent_temperature_bc.cc.bak
@@ -0,0 +1,251 @@
+/*
+  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef __aspect__boundary_temperature_time_dep_box_h
+#define __aspect__boundary_temperature_time_dep_box_h
+
+#include <aspect/boundary_temperature/interface.h>
+#include <aspect/simulator_access.h>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    /**
+     * A class that implements a temperature boundary condition for a time_dep_box
+     * geometry.
+     *
+     * @ingroup BoundaryTemperatures
+     */
+    template <int dim>
+    class Time_Dep_Box : public Interface<dim>, public SimulatorAccess<dim>
+    {
+      public:
+        /**
+         * This plugin prescribes time dependent temperatures for all boundaries.
+         *
+         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
+         */
+        virtual
+        double boundary_temperature (const types::boundary_id boundary_indicator,
+                                     const Point<dim> &position) const;
+
+        /**
+         * Return the minimal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        virtual
+        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const;
+
+        /**
+         * Return the maximal the temperature on that part of the boundary on
+         * which Dirichlet conditions are posed.
+         *
+         * This value is used in computing dimensionless numbers such as the
+         * Nusselt number indicating heat flux.
+         */
+        virtual
+        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const;
+
+        /**
+         * Declare the parameters this class takes through input files. This
+         * class declares the inner and outer boundary temperatures.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+
+      private:
+        double temperature_[2*dim];
+    };
+  }
+}
+
+
+#endif
+
+#include <utility>
+#include <limits>
+#include <aspect/geometry_model/box.h>
+
+
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+// ------------------------------ Time_Dep_Box -------------------
+
+    template <int dim>
+    double
+    Time_Dep_Box<dim>::
+    boundary_temperature (const types::boundary_id boundary_indicator,
+                          const Point<dim> &position) const
+    {
+      // verify that the geometry is a time_dep_box since only
+      // for this geometry do we know for sure what boundary indicators it
+      // uses and what they mean
+      Assert (dynamic_cast<const GeometryModel::Box<dim>*>(&this->get_geometry_model())
+              != 0,
+              ExcMessage ("This boundary model is only implemented if the geometry is "
+                          "a time_dep_box."));
+
+      Assert (boundary_indicator<2*dim, ExcMessage ("Unknown boundary indicator."));
+      return temperature_[boundary_indicator] * this->get_time();
+    }
+
+
+    template <int dim>
+    double
+    Time_Dep_Box<dim>::
+    minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
+    {
+      if (fixed_boundary_ids.empty())
+        return *std::min_element(temperature_, temperature_+2*dim);
+      else
+        {
+          double min = maximal_temperature(fixed_boundary_ids);
+          for (typename std::set<types::boundary_id>::const_iterator
+               p = fixed_boundary_ids.begin();
+               p != fixed_boundary_ids.end(); ++p)
+            if (p != fixed_boundary_ids.end())
+              min = std::min(min,temperature_[*p]);
+          return min;
+        }
+    }
+
+
+
+    template <int dim>
+    double
+    Time_Dep_Box<dim>::
+    maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
+    {
+      if (fixed_boundary_ids.empty())
+        return *std::max_element(temperature_, temperature_+2*dim);
+      else
+        {
+          double max = -std::numeric_limits<double>::max();
+          for (typename std::set<types::boundary_id>::const_iterator
+               p = fixed_boundary_ids.begin();
+               p != fixed_boundary_ids.end(); ++p)
+            if (p != fixed_boundary_ids.end())
+              max = std::max(max,temperature_[*p]);
+          return max;
+        }
+    }
+
+    template <int dim>
+    void
+    Time_Dep_Box<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Time_Dep_Box");
+        {
+          prm.declare_entry ("Left temperature", "1",
+                             Patterns::Double (),
+                             "Temperature at the left boundary (at minimal x-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Right temperature", "0",
+                             Patterns::Double (),
+                             "Temperature at the right boundary (at maximal x-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Bottom temperature", "0",
+                             Patterns::Double (),
+                             "Temperature at the bottom boundary (at minimal z-value). Units: \\si{\\kelvin}.");
+          prm.declare_entry ("Top temperature", "0",
+                             Patterns::Double (),
+                             "Temperature at the top boundary (at maximal x-value). Units: \\si{\\kelvin}.");
+          if (dim==3)
+            {
+              prm.declare_entry ("Front temperature", "0",
+                                 Patterns::Double (),
+                                 "Temperature at the front boundary (at minimal y-value). Units: \\si{\\kelvin}.");
+              prm.declare_entry ("Back temperature", "0",
+                                 Patterns::Double (),
+                                 "Temperature at the back boundary (at maximal y-value). Units: \\si{\\kelvin}.");
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+    template <int dim>
+    void
+    Time_Dep_Box<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Boundary temperature model");
+      {
+        prm.enter_subsection("Time_Dep_Box");
+        {
+          switch (dim)
+            {
+              case 2:
+                temperature_[0] = prm.get_double ("Left temperature");
+                temperature_[1] = prm.get_double ("Right temperature");
+                temperature_[2] = prm.get_double ("Bottom temperature");
+                temperature_[3] = prm.get_double ("Top temperature");
+                break;
+
+              case 3:
+                temperature_[0] = prm.get_double ("Left temperature");
+                temperature_[1] = prm.get_double ("Right temperature");
+                temperature_[2] = prm.get_double ("Front temperature");
+                temperature_[3] = prm.get_double ("Back temperature");
+                temperature_[4] = prm.get_double ("Bottom temperature");
+                temperature_[5] = prm.get_double ("Top temperature");
+                break;
+
+              default:
+                Assert (false, ExcNotImplemented());
+            }
+        }
+        prm.leave_subsection ();
+      }
+      prm.leave_subsection ();
+    }
+
+
+  }
+}
+
+// explicit instantiations
+namespace aspect
+{
+  namespace BoundaryTemperature
+  {
+    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Time_Dep_Box,
+                                               "time_dep_box",
+                                               "A model in which the temperature is chosen constant on "
+                                               "all the sides of a time_dep_box.")
+  }
+}
diff --git a/tests/time_dependent_temperature_bc.prm.bak b/tests/time_dependent_temperature_bc.prm.bak
new file mode 100644
index 00000000000..2e4c3431d68
--- /dev/null
+++ b/tests/time_dependent_temperature_bc.prm.bak
@@ -0,0 +1,100 @@
+# originally taken from diffusion.prm, but intended to test that we can deal
+# with time dependent temperature boundary conditions
+#
+# this is just a preliminary test. we used to crash because we forgot to set
+# the time before we evaluate the temperature boundary conditions for the
+# first time, and plugins providing such boundary conditions consequently
+# had no way to tell the time when evaluated when computing the initial
+# solution
+
+
+set Dimension = 2
+set CFL number                             = 0.01
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = time_dep_box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Time_Dep_Box
+    set Bottom temperature = 0
+    set Top temperature    = 1 # the model interprets this as T(t)=1*t
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Checkpointing
+  set Time between checkpoint                = 0
+  set Steps between checkpoint               = 50
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
diff --git a/tests/time_dependent_temperature_bc_2.cc.bak b/tests/time_dependent_temperature_bc_2.cc.bak
new file mode 100644
index 00000000000..ca9a0f67c4c
--- /dev/null
+++ b/tests/time_dependent_temperature_bc_2.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "time_dependent_temperature_bc.cc"
diff --git a/tests/time_dependent_temperature_bc_2.prm.bak b/tests/time_dependent_temperature_bc_2.prm.bak
new file mode 100644
index 00000000000..c81d3513e3f
--- /dev/null
+++ b/tests/time_dependent_temperature_bc_2.prm.bak
@@ -0,0 +1,97 @@
+# originally taken from diffusion.prm, but intended to test that we can deal
+# with time dependent temperature boundary conditions
+#
+# we use a time dependent boundary condition at the top boundary and verify
+# that the temperature at the indeed changes with time as expected
+
+
+set Dimension = 2
+set CFL number                             = 1
+set End time                               = 1
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = time_dep_box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Time_Dep_Box
+    set Bottom temperature = 0
+    set Top temperature    = 1 # the model interprets this as T(t)=1*t
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Checkpointing
+  set Time between checkpoint                = 0
+  set Steps between checkpoint               = 50
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
diff --git a/tests/time_stepping_fail.prm.bak b/tests/time_stepping_fail.prm.bak
new file mode 100644
index 00000000000..c1f746bc4d7
--- /dev/null
+++ b/tests/time_stepping_fail.prm.bak
@@ -0,0 +1,65 @@
+# test "Time stepping::Function" plugin with a negative time step, based on box_end_time_1e7_terminate.prm
+
+# EXPECT FAILURE
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.5e4
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Time stepping
+  set List of model names = function
+
+  subsection Function
+    set Function expression = if (time<5e2,1e2,-1)
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
diff --git a/tests/time_stepping_function.prm.bak b/tests/time_stepping_function.prm.bak
new file mode 100644
index 00000000000..395168a90c3
--- /dev/null
+++ b/tests/time_stepping_function.prm.bak
@@ -0,0 +1,63 @@
+# test "Time stepping::Function" plugin, based on box_end_time_1e7_terminate.prm
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.5e4
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Time stepping
+  set List of model names = function
+
+  subsection Function
+    set Function expression = if (time<5e3,2e2+1e2*cos(2*3.141*time/5e3),3e2+time/1e3)
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
diff --git a/tests/time_stepping_min.prm.bak b/tests/time_stepping_min.prm.bak
new file mode 100644
index 00000000000..8f270500b39
--- /dev/null
+++ b/tests/time_stepping_min.prm.bak
@@ -0,0 +1,66 @@
+# test "Time stepping::Function" plugin combined with a minimum step size
+#
+# based on time_stepping_function.prm
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1.5e4
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Time stepping
+  set Minimum time step size = 101
+  set List of model names = function
+
+  subsection Function
+    set Function expression = if (time<5e3,2e2+1e2*cos(2*3.141*time/5e3),3e2+time/1e3)
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
diff --git a/tests/time_stepping_repeat.prm.bak b/tests/time_stepping_repeat.prm.bak
new file mode 100644
index 00000000000..bdf8860cc0a
--- /dev/null
+++ b/tests/time_stepping_repeat.prm.bak
@@ -0,0 +1,99 @@
+# Test TimeStepping plugin "repeat on cutback" by having a change in
+# prescribed surface velocity
+
+set Dimension                              = 2
+set End time                               = 0.755
+set Use years in output instead of seconds = false
+set Maximum relative increase in time step     = 2
+
+subsection Time stepping
+  set List of model names = convection time step, repeat on cutback
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(t<0.75, if(x<0.5,-1,1), 100); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(z<0.2, 1, 0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-7
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1e-5
+
+    #    set Output format                 = gnuplot
+  end
+end
+
+# This is the new part: We declare that there will
+# be two compositional fields with same initial condition
+# and only the first one will be advected along.
+subsection Compositional fields
+  set Number of fields = 0
+
+  #  set Compositional field methods = field,static
+end
+
+subsection Initial composition model
+  #  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y<0.2, 1, 0)
+  end
+end
diff --git a/tests/time_stepping_repeat_particles.prm.bak b/tests/time_stepping_repeat_particles.prm.bak
new file mode 100644
index 00000000000..28934691f49
--- /dev/null
+++ b/tests/time_stepping_repeat_particles.prm.bak
@@ -0,0 +1,127 @@
+# Test TimeStepping plugin "repeat on cutback" by having a change in
+# prescribed surface velocity in combination with the advection
+# of particles. There are two compositional fields, one based on
+# the field method and one on the particle method. The initial condition
+# for the fields is the same (idenical to the temperature field).
+# For sufficient mesh and particle resolution,
+# the end result for the two fields should be practically the same.
+
+set Dimension                              = 2
+set End time                               = 0.755
+set Use years in output instead of seconds = false
+set Maximum relative increase in time step     = 2
+
+subsection Time stepping
+  set List of model names = convection time step, repeat on cutback
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+    set X repetitions = 2
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(t<0.75, if(x<0.5,-1,1), 100); 0
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if(z<0.2, 1, 0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity          = 1e-7
+    set Thermal expansion coefficient = 1e-4
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, particles
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1e-1
+    set Output format = gnuplot
+  end
+
+  subsection Particles
+    set Time between data output = 1e-1
+    set Data output format          = gnuplot
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = field, particles
+  set Compositional field methods = field,particles
+  set Mapped particle properties  = particles:initial particles
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(y<0.2, 1, 0) ; if(y<0.2, 1, 0)
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell  = 0
+  set Maximum particles per cell  = 100
+  set Load balancing strategy     = remove and add particles
+  set List of particle properties = initial composition, composition
+  set Update ghost particles      = true
+  set Allow cells without particles = true
+  set Particle generator name = uniform box
+
+  subsection Generator
+    subsection Uniform box
+      set Minimum x = 0.
+      set Maximum x = 2.
+      set Minimum y = 0.
+      set Maximum y = 0.3
+      set Number of particles = 64
+    end
+  end
+end
diff --git a/tests/time_stepping_repeat_particles_iterated_advection.prm.bak b/tests/time_stepping_repeat_particles_iterated_advection.prm.bak
new file mode 100644
index 00000000000..64125a220a5
--- /dev/null
+++ b/tests/time_stepping_repeat_particles_iterated_advection.prm.bak
@@ -0,0 +1,30 @@
+# Test TimeStepping plugin "repeat on cutback" by having a change in
+# prescribed surface velocity in combination with the advection
+# of particles. There are two compositional fields, one based on
+# the field method and one on the particle method. The initial condition
+# for the fields is the same (identical to the temperature field).
+# For sufficient mesh and particle resolution,
+# the end result for the two fields should be practically the same.
+# Same as time_stepping_repeat_particles.prm except for the prescribed
+# boundary velocity and the iterative Advection scheme.
+# For this scheme, the particle positions and properties
+# have to be restored before each second or later nonlinear iteration
+# within a timestep. The sudden change in surface velocity is
+# less extreme so that the second temperature nonlinear iteration after
+# the change still converges.
+
+include $ASPECT_SOURCE_DIR/tests/time_stepping_repeat_particles.prm
+
+set Dimension                  = 2
+set Nonlinear solver scheme    = iterated Advection and Stokes
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, left, right
+  set Prescribed velocity boundary indicators = top: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(t<0.75, if(x<0.5,-1,1), if(x<0.5,-15,15)); 0
+  end
+end
diff --git a/tests/tomography_based_plate_motions_cookbook.cc.bak b/tests/tomography_based_plate_motions_cookbook.cc.bak
new file mode 100644
index 00000000000..5c70f768d86
--- /dev/null
+++ b/tests/tomography_based_plate_motions_cookbook.cc.bak
@@ -0,0 +1,22 @@
+/*
+  Copyright (C) 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc"
+#include "../cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc"
diff --git a/tests/tomography_based_plate_motions_cookbook.prm.bak b/tests/tomography_based_plate_motions_cookbook.prm.bak
new file mode 100644
index 00000000000..25677171d64
--- /dev/null
+++ b/tests/tomography_based_plate_motions_cookbook.prm.bak
@@ -0,0 +1,39 @@
+# This is a test for the cookbook described in
+# $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/models
+
+include $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm
+
+set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/plugins/libtomography_based_plate_motions.release.so
+set World builder file                     = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/world_builder_smac_cratons_faults_2D.json
+set Output directory                       = output
+set Max nonlinear iterations               = 1
+
+subsection Mesh refinement
+  set Initial adaptive refinement = 1
+  set Initial global refinement = 1
+  set Skip solvers on initial refinement = true
+end
+
+subsection Material model
+  set Model name                    = tomography based plate motions
+
+  subsection Tomography based plate motions model
+    subsection Density velocity scaling
+      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
+      set Data file name                            = rho_vs_scaling.txt
+    end
+
+    subsection Temperature velocity scaling
+      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
+      set Data file name                            = dT_vs_scaling.txt
+    end
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors         = boundary velocity residual statistics, velocity boundary statistics, visualization, heat flux statistics, depth average
+
+  subsection Visualization
+    set Output format                = gnuplot
+  end
+end
diff --git a/tests/topo_box.prm.bak b/tests/topo_box.prm.bak
new file mode 100644
index 00000000000..5533d14d98e
--- /dev/null
+++ b/tests/topo_box.prm.bak
@@ -0,0 +1,119 @@
+#Test topography postprocessor with box geometry
+set Output directory                       = topo_box
+set CFL number                             = 0.5
+set Dimension                              = 2
+set End time                               = 1e+7
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Nonlinear solver tolerance             = 1e-6
+set Pressure normalization                 = no
+set Resume computation                     = false
+set Start time                             = 0
+set Timing output frequency                = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators = top
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom
+  set Prescribed velocity boundary indicators = left: function, right:function
+
+  subsection Function
+    set Function constants  = cm=0.01, year=3.155e7, pi=3.141593, angle=60, total_depth=512e3, crustal_depth=30e3, lithospheric_depth=120e3
+    set Function expression = if (x<50e3, if (z > total_depth-lithospheric_depth, 1*cm, -(lithospheric_depth/(total_depth-lithospheric_depth))*cm), if (z > total_depth-lithospheric_depth, -1*cm, (lithospheric_depth/(total_depth-lithospheric_depth))*cm)); 0
+    set Variable names      = x,z
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators     = top: free surface
+  set Additional tangential mesh velocity boundary indicators = right, left
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+    set Surface velocity projection = vertical
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Box origin X coordinate = 0
+    set Box origin Y coordinate = 0
+    set Box origin Z coordinate = 0
+    set X extent                = 1024e3
+    set X periodic              = false
+    set X repetitions           = 2
+    set Y extent                = 512e3
+    set Y periodic              = false
+    set Y repetitions           = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = reference_t=293, crustal_t = 420, lith_t = 1350, mantle_t = 1470, total_depth=512e3, crustal_depth=30e3, lithospheric_depth=120e3,
+    set Function expression = if (z>total_depth-crustal_depth,reference_t+(total_depth-z)*(crustal_t/crustal_depth), if (z>total_depth-lithospheric_depth,reference_t+crustal_t+(total_depth-crustal_depth-z)*(lith_t-crustal_t)/(lithospheric_depth-crustal_depth), reference_t+lith_t+(total_depth-lithospheric_depth-z)*(mantle_t-lith_t)/(total_depth-lithospheric_depth)))
+    set Variable names      = x,z
+  end
+end
+
+subsection Material model
+  set Model name         = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Minimum refinement level                 = 4
+end
+
+subsection Boundary composition model
+  set Fixed composition boundary indicators   = left, right
+  set List of model names = initial composition
+end
+
+subsection Postprocess
+  set List of postprocessors = topography
+
+  subsection Topography
+    set Time between text output       = 0
+    set Output to file = true
+  end
+end
+
+subsection Termination criteria
+  set End step                  = 1
+  set Termination criteria      = end step
+
+  subsection Steady state velocity
+    set Maximum relative deviation = 0.05
+    set Time in steady state       = 1e6
+  end
+
+  subsection User request
+    set File name = terminate-aspect
+  end
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-10
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-8
+  end
+end
diff --git a/tests/topo_chunk.prm.bak b/tests/topo_chunk.prm.bak
new file mode 100644
index 00000000000..7d1d64d95c5
--- /dev/null
+++ b/tests/topo_chunk.prm.bak
@@ -0,0 +1,86 @@
+#Test topography postprocessor with chunk geometry
+set Dimension = 2
+set CFL number                             = 1.0
+set Adiabatic surface temperature          = 1600.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Output directory              = topo_chunk
+set Pressure normalization = no
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = chunk
+
+  subsection Chunk
+    set Chunk minimum longitude = 60
+    set Chunk maximum longitude = 120
+    set Longitude repetitions = 1
+    set Chunk inner radius = 3000000
+    set Chunk outer radius = 6000000
+    set Radius repetitions = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 1800
+    set Outer temperature = 273
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = outer: free surface
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+end
+
+subsection Postprocess
+  set List of postprocessors = topography
+
+  subsection Topography
+    set Time between text output       = 0
+    set Output to file = true
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step                               = 1
+end
diff --git a/tests/topo_shell.prm.bak b/tests/topo_shell.prm.bak
new file mode 100644
index 00000000000..a02260cccb3
--- /dev/null
+++ b/tests/topo_shell.prm.bak
@@ -0,0 +1,75 @@
+#Test topography postprocessor with spherical shell geometry
+set Dimension                              = 2
+set Use years in output instead of seconds = true
+set End time                               = 1.5e9
+set Output directory                       = topo_shell
+set Pressure normalization                 = no
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Outer radius  = 6336000
+    set Opening angle = 90
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = inner
+  set Tangential velocity boundary indicators = left, right
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = top, bottom
+  set List of model names = spherical constant
+
+  subsection Spherical constant
+    set Inner temperature = 4273
+    set Outer temperature = 973
+  end
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators     = top: free surface
+end
+
+subsection Heating model
+  set List of model names =  shear heating
+end
+
+subsection Initial temperature model
+  set Model name = spherical hexagonal perturbation
+end
+
+subsection Gravity model
+  set Model name = ascii data
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = topography
+
+  subsection Topography
+    set Time between text output       = 0
+    set Output to file = true
+  end
+end
+
+subsection Termination criteria
+  set End step                  = 1
+  set Termination criteria      = end step
+end
diff --git a/tests/tosi_benchmark.cc.bak b/tests/tosi_benchmark.cc.bak
new file mode 100644
index 00000000000..8e2b0e4e121
--- /dev/null
+++ b/tests/tosi_benchmark.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark.prm.bak b/tests/tosi_benchmark.prm.bak
new file mode 100644
index 00000000000..1de3651779a
--- /dev/null
+++ b/tests/tosi_benchmark.prm.bak
@@ -0,0 +1,8 @@
+# This is a test for the benchmark described in
+# $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015
+
+include $ASPECT_SOURCE_DIR/benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm
+
+set Additional shared libraries            = ./libtosi_benchmark.so
+set End time                               = 0.005
+set Max nonlinear iterations               = 15
diff --git a/tests/tosi_benchmark_gmg_dc_picard_solver.cc.bak b/tests/tosi_benchmark_gmg_dc_picard_solver.cc.bak
new file mode 100644
index 00000000000..7dfc1e32ff1
--- /dev/null
+++ b/tests/tosi_benchmark_gmg_dc_picard_solver.cc.bak
@@ -0,0 +1 @@
+#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark_gmg_dc_picard_solver.prm.bak b/tests/tosi_benchmark_gmg_dc_picard_solver.prm.bak
new file mode 100644
index 00000000000..d4e0b9aae33
--- /dev/null
+++ b/tests/tosi_benchmark_gmg_dc_picard_solver.prm.bak
@@ -0,0 +1,17 @@
+# Test GMG  iterated defect correction Stokes solver based on
+# benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
+
+include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
+
+set Nonlinear solver scheme = single Advection, iterated defect correction Stokes
+set End time                               = 0.0022
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/tests/tosi_benchmark_gmg_newton_solver.cc.bak b/tests/tosi_benchmark_gmg_newton_solver.cc.bak
new file mode 100644
index 00000000000..8e2b0e4e121
--- /dev/null
+++ b/tests/tosi_benchmark_gmg_newton_solver.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark_gmg_newton_solver.prm.bak b/tests/tosi_benchmark_gmg_newton_solver.prm.bak
new file mode 100644
index 00000000000..1034fe649d0
--- /dev/null
+++ b/tests/tosi_benchmark_gmg_newton_solver.prm.bak
@@ -0,0 +1,18 @@
+# Test Newton GMG solver based on
+# benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm
+
+set Additional shared libraries            = $ASPECT_SOURCE_DIR/benchmarks/tosi_et_al_2015_gcubed/libtosi_benchmark.so
+
+include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
+
+set End time                               = 0.0022
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average
+end
diff --git a/tests/tosi_benchmark_newton_solver.cc.bak b/tests/tosi_benchmark_newton_solver.cc.bak
new file mode 100644
index 00000000000..8e2b0e4e121
--- /dev/null
+++ b/tests/tosi_benchmark_newton_solver.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark_newton_solver.prm.bak b/tests/tosi_benchmark_newton_solver.prm.bak
new file mode 100644
index 00000000000..4e6f87f530f
--- /dev/null
+++ b/tests/tosi_benchmark_newton_solver.prm.bak
@@ -0,0 +1,8 @@
+# This is a test for the benchmark described in
+# $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015
+
+include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
+
+set Additional shared libraries            = ./libnewton_solver_tosi.so
+set End time                               = 0.0021
+set Max nonlinear iterations               = 15
diff --git a/tests/tosi_benchmark_newton_solver_full_A.cc.bak b/tests/tosi_benchmark_newton_solver_full_A.cc.bak
new file mode 100644
index 00000000000..8e2b0e4e121
--- /dev/null
+++ b/tests/tosi_benchmark_newton_solver_full_A.cc.bak
@@ -0,0 +1,21 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark_newton_solver_full_A.prm.bak b/tests/tosi_benchmark_newton_solver_full_A.prm.bak
new file mode 100644
index 00000000000..3422d700046
--- /dev/null
+++ b/tests/tosi_benchmark_newton_solver_full_A.prm.bak
@@ -0,0 +1,15 @@
+# This is a test for the Tosi benchmark using the Newton solver and the full A block
+# as preconditioner. Prior to this test there was a bug assigning the correct assemblers
+# for this case.
+
+include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
+
+set Additional shared libraries            = ./libnewton_solver_tosi.so
+set End time                               = 0.0021
+set Max nonlinear iterations               = 15
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use full A block as preconditioner = true
+  end
+end
diff --git a/tests/traction_ascii_data.prm.bak b/tests/traction_ascii_data.prm.bak
new file mode 100644
index 00000000000..946e2f042c6
--- /dev/null
+++ b/tests/traction_ascii_data.prm.bak
@@ -0,0 +1,133 @@
+# This is a test model for the ascii data traction plugin.
+# It reads traction boundary conditions from a file
+# located in the data/traction-boundary-conditions/ascii-data/test/
+# directory and applies them at the left side of a 2d box
+# model.
+
+
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 3
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 0 #1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 3
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 3000000
+    set Y extent  = 660000
+    set X repetitions = 9
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 1e8
+    set Age bottom boundary layer   = 0.0
+    set Amplitude                   = 250
+    set Radius                      = 400000
+  end
+end
+
+subsection Material model
+  set Model name = diffusion dislocation
+  set Material averaging = none
+
+  subsection Diffusion dislocation
+    set Densities                                 = 3330
+    set Maximum viscosity                         = 1e26
+    set Minimum viscosity                         = 1e17
+    set Heat capacity                             = 1200
+    set Thermal expansivities                     = 3.3e-5
+    set Activation energies for diffusion creep   = 375000
+    set Activation volumes for diffusion creep    = 6e-6
+    set Grain size exponents for diffusion creep  = 4
+    set Prefactors for diffusion creep            = 1.5e-16
+    set Activation energies for dislocation creep = 480000
+    set Prefactors for dislocation creep          = 2e-15
+    set Activation volumes for dislocation creep  = 8e-6
+    set Maximum strain rate ratio iterations      = 10000
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 0:ascii data
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-traction/ascii-data/test/
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set Time between graphical output = 50
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint = 1700
+end
+
+subsection Heating model
+  set List of model names =  latent heat
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block AMG
+  end
+end
diff --git a/tests/traction_multiple_model.prm.bak b/tests/traction_multiple_model.prm.bak
new file mode 100644
index 00000000000..dffe3da3ef9
--- /dev/null
+++ b/tests/traction_multiple_model.prm.bak
@@ -0,0 +1,135 @@
+# This is a test model for the allowing multiple traction models for a single boundary.
+# It reads traction boundary conditions from a file
+# located in the data/traction-boundary-conditions/ascii-data/test/
+# directory and combine it with a traction function and applies them at
+# the left side of a 2d box model.
+
+
+set Adiabatic surface temperature          = 1600
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Max nonlinear iterations               = 3
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 0 #1e5
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 3
+
+  subsection Initial temperature
+    set Minimal temperature = 293
+    set Maximal temperature = 1600
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 3000000
+    set Y extent  = 660000
+    set X repetitions = 9
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 1e8
+    set Age bottom boundary layer   = 0.0
+    set Amplitude                   = 250
+    set Radius                      = 400000
+  end
+end
+
+subsection Material model
+  set Model name = diffusion dislocation
+  set Material averaging =  harmonic average only viscosity
+
+  subsection Diffusion dislocation
+    set Densities                                 = 3330
+    set Maximum viscosity                         = 1e26
+    set Minimum viscosity                         = 1e17
+    set Heat capacity                             = 1200
+    set Thermal expansivities                     = 3.3e-5
+    set Activation energies for diffusion creep   = 375000
+    set Activation volumes for diffusion creep    = 6e-6
+    set Grain size exponents for diffusion creep  = 4
+    set Prefactors for diffusion creep            = 1.5e-16
+    set Activation energies for dislocation creep = 480000
+    set Prefactors for dislocation creep          = 2e-15
+    set Activation volumes for dislocation creep  = 8e-6
+    set Maximum strain rate ratio iterations      = 10000
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 4
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary traction model
+  set Prescribed traction boundary indicators = 0:ascii data, 0:function
+
+  subsection Function
+    set Variable names      = x,y
+
+    # The following line is the stress applied to the side boundaries (in Pa)
+    set Function constants  = stress=2000e6
+    set Function expression = if (y>600e3 ,-stress,0); 0
+  end
+
+  subsection Ascii data model
+    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-traction/ascii-data/test/
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set Time between graphical output = 50
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+  end
+end
+
+subsection Checkpointing
+  set Time between checkpoint = 1700
+end
+
+subsection Heating model
+  set List of model names =  latent heat
+end
diff --git a/tests/transform_fault_behn_2007.prm.bak b/tests/transform_fault_behn_2007.prm.bak
new file mode 100644
index 00000000000..d294510054a
--- /dev/null
+++ b/tests/transform_fault_behn_2007.prm.bak
@@ -0,0 +1,11 @@
+include $ASPECT_SOURCE_DIR/cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm
+
+set World builder file = $ASPECT_SOURCE_DIR/contrib/world_builder/cookbooks/3d_cartesian_transform_fault/3d_cartesian_transform_fault.wb
+set Dimension = 3
+set End time = 0
+
+subsection Mesh refinement
+  set Initial global refinement = 2
+  set Initial adaptive refinement = 0
+  set Minimum refinement level = 2
+end
diff --git a/tests/two_merged_boxes_free_surface.prm.bak b/tests/two_merged_boxes_free_surface.prm.bak
new file mode 100644
index 00000000000..a9a2b35c0e2
--- /dev/null
+++ b/tests/two_merged_boxes_free_surface.prm.bak
@@ -0,0 +1,72 @@
+set Dimension = 3
+set CFL number                             = 1.0
+set End time                               = 1
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+set Pressure normalization                 = no
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box with lithosphere boundary indicators
+
+  subsection Box with lithosphere boundary indicators
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1000
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3,6,7,8,9
+  set Zero velocity boundary indicators       = 4
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 5: free surface
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set List of output variables = depth
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/uncoupled_two_phase_tian_parameterization_kinematic_slab.prm.bak b/tests/uncoupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
new file mode 100644
index 00000000000..11bc6fe9b90
--- /dev/null
+++ b/tests/uncoupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
@@ -0,0 +1,50 @@
+# This test is for the uncoupled Simplified Subduction Model with Parameterized
+# Solid-Fluid Reactions cookbook.
+
+include $ASPECT_SOURCE_DIR/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm
+
+set Adiabatic surface temperature              = 1600
+set Nonlinear solver scheme                    = single Advection, single Stokes
+set End time                                   = 2000
+
+subsection Mesh refinement
+  set Initial global refinement = 1
+
+  subsection Minimum refinement function
+    set Function expression = 1
+  end
+end
+
+subsection Compositional fields
+  set Compositional field methods = darcy field, field, field, field, field, field
+end
+
+# Slightly change composition model to ensure that there is bound_fluid
+# and porosity at the end of the test.
+subsection Boundary composition model
+  set Fixed composition boundary indicators         = left
+  set List of model names                           = function
+
+  subsection Function
+    set Function constants  = initial_porosity=0, initial_bound_sed=0.03, initial_bound_MORB=0.02, initial_bound_gabbro=0.01, \
+                              sediment_min=0, sediment_max=5e3, MORB_min=5e3, MORB_max=12e3, gabbro_min=12e3, gabbro_max=20e3, \
+                              onset_time=0, slab_thickness=20e3
+    set Function expression = initial_porosity; \
+                              if( t<=onset_time, 0, \
+                              if( (y<=slab_thickness - sediment_min) & (y>slab_thickness - sediment_max), initial_bound_sed, \
+                              if( (y<=slab_thickness - MORB_min) & (y>slab_thickness - MORB_max), initial_bound_MORB, \
+                              if( (y<=slab_thickness - gabbro_min) & (y>slab_thickness - gabbro_max), initial_bound_gabbro, 0.0)))); \
+                              if(y>slab_thickness, 1, 0); \
+                              if(y<=8e3, 1, 0); \
+                              if(y>8e3 & y<=15e3, 1, 0); \
+                              if(y>15e3 & y<=slab_thickness, 1, 0)
+  end
+end
+
+subsection Melt settings
+  set Include melt transport = false
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
diff --git a/tests/update_script.cc.bak b/tests/update_script.cc.bak
new file mode 100644
index 00000000000..24f1c669c67
--- /dev/null
+++ b/tests/update_script.cc.bak
@@ -0,0 +1,65 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Use the update
+ * script to update this parameter file. Unfortunately at this point the file
+ * has already been loaded, so the current ASPECT instance would get the old
+ * file. Thus we start a new ASPECT instance that will load the new file.
+ * To avoid an endless recursion we remove the shared library from the new
+ * input file (otherwise the new instance would call this library again, and so
+ * on). After finishing the new instance we exit to not continue the old one.
+ */
+int f()
+{
+  int ret;
+  std::string command;
+
+  command = ("cp update_script.x.prm output-update_script/updated.prm &&"
+             "sed -i.bak 's:set Additional shared libraries = ./libupdate_script.so::' output-update_script/updated.prm &&"
+             "bash " ASPECT_SOURCE_DIR "/contrib/utilities/update_prm_files.sh output-update_script/updated.prm &&"
+             "rm output-update_script/updated.prm.bak");
+
+  std::cout << "Executing the update script:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  command = ("../aspect output-update_script/updated.prm");
+  std::cout << "Running ASPECT with updated parameter file:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // abort current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/update_script_2.cc.bak b/tests/update_script_2.cc.bak
new file mode 100644
index 00000000000..63ae1fcdcff
--- /dev/null
+++ b/tests/update_script_2.cc.bak
@@ -0,0 +1,70 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <iostream>
+
+/*
+ * Launch the following function when this plugin is created. Use the update
+ * script to update this parameter file. Unfortunately at this point the file
+ * has already been loaded, so the current ASPECT instance would get the old
+ * file. Thus we start a new ASPECT instance that will load the new file.
+ * To avoid an endless recursion we remove the shared library from the new
+ * input file (otherwise the new instance would call this library again, and so
+ * on). After finishing the new instance we exit to not continue the old one.
+ *
+ * This test in particular calls the update script multiple times on the same
+ * file, and ensures that only the first time changes happen. Every subsequent
+ * application should not change the file any more.
+ */
+int f()
+{
+  int ret;
+  std::string command;
+
+  command = ("cp update_script_2.x.prm output-update_script_2/updated2.prm;"
+             "sed -i.bak 's:set Additional shared libraries = ./libupdate_script_2.so::' output-update_script_2/updated2.prm;"
+             "bash " ASPECT_SOURCE_DIR "/contrib/utilities/update_prm_files.sh output-update_script_2/updated2.prm;"
+             "bash " ASPECT_SOURCE_DIR "/contrib/utilities/update_prm_files.sh output-update_script_2/updated2.prm;"
+             "rm output-update_script_2/updated2.prm.bak");
+
+  std::cout << "Executing the update script:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  command = ("../aspect output-update_script_2/updated2.prm");
+  std::cout << "Running ASPECT with updated parameter file:\n"
+            << command
+            << std::endl;
+  ret = system (command.c_str());
+  if (ret!=0)
+    std::cout << "system() returned error " << ret << std::endl;
+
+  // abort current process:
+  exit (0);
+  return 42;
+}
+
+
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/update_script_2/updated2.prm.bak b/tests/update_script_2/updated2.prm.bak
new file mode 100644
index 00000000000..cf003367e9b
--- /dev/null
+++ b/tests/update_script_2/updated2.prm.bak
@@ -0,0 +1,135 @@
+# This test is a modified copy of update_script.prm.
+# It differs from update_script.prm by applying the update script twice,
+# and checking that it does not add additional lines after the
+# first run.
+
+# The content of this prm file is only executable by ASPECT <=1.5, but the
+# corresponding shared library in update_script.cc will first execute the
+# update script on this .prm file before running ASPECT with the updated
+# version of the file. The success of this test means the script did its job
+# and ASPECT 2.0 is able to read the twice updated file and the twice updated
+# file does not differ from the once updated file.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+set Output directory = output-update_script_2
+
+subsection Adiabatic conditions model
+  set Model name = compute profile
+
+  subsection Compute profile
+    set Use surface condition function = true
+
+    subsection Surface condition function
+      set Function expression = 1e-2*t; 1613.0+1e-13*t
+    end
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Boundary composition model
+  set List of model names = function
+end
+
+subsection Initial composition model
+  set Model name = function
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial linear
+
+  subsection Radial linear
+    set Magnitude at bottom = 10.7
+    set Magnitude at surface = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+    set Reference compressibility = 2.5e-12
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average, dynamic topography, particles, heating statistics
+
+  subsection Dynamic topography
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = vtu
+    set List of output variables      = density, heating
+    set Time between graphical output = 0
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 10
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating
+end
+
+subsection Particles
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 50
+    end
+  end
+end
diff --git a/tests/upwelling_melting_peridotite.prm.bak b/tests/upwelling_melting_peridotite.prm.bak
new file mode 100644
index 00000000000..cf1d2b9f663
--- /dev/null
+++ b/tests/upwelling_melting_peridotite.prm.bak
@@ -0,0 +1,135 @@
+# This test is used to check if the latent heat of
+# melting of peridotite is calculated correctly.
+# The material is upwelling with a constant velocity
+# (without separation of melt and solid) and without
+# conduction of heat, so that the steady state of the
+# model is an adiabatic temperature profile. An approximated
+# analytical solution for this profile to compare the solution
+# to is described in Katz et al., 2003 (A new parameterization
+# of hydrous mantle melting).
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 2.5e13
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9177
+    set Y extent = 183540      # maximum pressure 6 GPa
+    set Y repetitions = 20
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    set Function expression = 0;1e-10
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = latent heat melt
+
+  subsection Latent heat melt
+    set Reference density        = 3300
+    set Mass fraction cpx        = 0.10
+    set Reference specific heat  = 1000
+    set Relative density of melt = 0.878787879  # melt density of 2900 kg/m^3
+    set Reference temperature    = 1623.15      # 1350°C adiabat
+    set Peridotite melting entropy change = -300
+    set Thermal conductivity     = 0.0
+    set Compressibility          = 0.0
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = melt fraction, viscosity, density, nonadiabatic temperature
+
+    subsection Melt fraction
+      set Mass fraction cpx = 0.10
+    end
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, latent heat
+end
diff --git a/tests/upwelling_melting_peridotite_compressible.prm.bak b/tests/upwelling_melting_peridotite_compressible.prm.bak
new file mode 100644
index 00000000000..affddc66fcf
--- /dev/null
+++ b/tests/upwelling_melting_peridotite_compressible.prm.bak
@@ -0,0 +1,128 @@
+# This test is used to check if the compressible variation
+# of the upwelling_melting_peridotite test is calculated correctly.
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 2.5e13
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9177
+    set Y extent = 183540      # maximum pressure 6 GPa
+    set Y repetitions = 20
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    set Function expression = 0;1e-10
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = latent heat melt
+
+  subsection Latent heat melt
+    set Reference density        = 3300
+    set Mass fraction cpx        = 0.10
+    set Reference specific heat  = 1000
+    set Relative density of melt = 0.878787879  # melt density of 2900 kg/m^3
+    set Reference temperature    = 1623.15      # 1350°C adiabat
+    set Peridotite melting entropy change = -300
+    set Thermal conductivity     = 0.0
+    set Compressibility          = 4e-12
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.01
+    set List of output variables = melt fraction, viscosity, density, nonadiabatic temperature
+
+    subsection Melt fraction
+      set Mass fraction cpx = 0.10
+    end
+  end
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, latent heat
+end
diff --git a/tests/upwelling_melting_pyroxenite.prm.bak b/tests/upwelling_melting_pyroxenite.prm.bak
new file mode 100644
index 00000000000..c898f927597
--- /dev/null
+++ b/tests/upwelling_melting_pyroxenite.prm.bak
@@ -0,0 +1,161 @@
+# This test is used to check if the latent heat of
+# melting of pyroxenite is calculated correctly.
+# The material is upwelling with a constant velocity
+# (without separation of melt and solid) and without
+# conduction of heat, so that the steady state of the
+# model is an adiabatic temperature profile. An approximated
+# analytical solution for this profile to compare the solution
+# to can be calculated analogue to the description in Katz
+# et al., 2003 (A new parameterization of hydrous mantle melting)
+# by numerically integrating equation (23) of that paper and
+# using the corresponding parameters of the pyroxenite melting
+# parameterization from Sobolev et al., 2011 (Linking mantle plumes,
+# large igneous provinces and environmental catastrophes).
+
+# At the top, we define the number of space dimensions we would like to
+# work in:
+set Dimension                              = 2
+
+# There are several global variables that have to do with what
+# time system we want to work in and what the end time is.
+set Use years in output instead of seconds = false
+set End time                               = 2.5e13
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1623.15   # 1350°C adiabat
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Discretization
+  subsection Stabilization parameters
+    set beta = 0.13
+  end
+end
+
+# Then come a number of sections that deal with the setup
+# of the problem to solve. The first one deals with the
+# geometry of the domain within which we want to solve.
+# The sections that follow all have the same basic setup
+# where we select the name of a particular model (here,
+# the box geometry) and then, in a further subsection,
+# set the parameters that are specific to this particular
+# model.
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 9177
+    set Y extent = 183540      # maximum pressure 6 GPa
+    set Y repetitions = 20
+  end
+end
+
+# The next section deals with the initial conditions for the
+# temperature (there are no initial conditions for the
+# velocity variable since the velocity is assumed to always
+# be in a static equilibrium with the temperature field).
+# There are a number of models with the 'function' model
+# a generic one that allows us to enter the actual initial
+# conditions in the form of a formula that can contain
+# constants. We choose a linear temperature profile that
+# matches the boundary conditions defined below plus
+# a small perturbation:
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1746.794 - z/183540.0 * 300
+    set Variable names      = x,z
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1.0
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2
+
+  subsection Box
+    set Bottom temperature = 1746.794  # 1350°C adiabat
+  end
+end
+
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 2
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 2:function
+  set Tangential velocity boundary indicators = 0,1
+
+  subsection Function
+    set Function expression = 0;1e-10
+  end
+end
+
+# The following two sections describe first the
+# direction (vertical) and magnitude of gravity and the
+# material model (i.e., density, viscosity, etc). We have
+# discussed the settings used here in the introduction to
+# this cookbook in the manual already.
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = latent heat melt
+
+  subsection Latent heat melt
+    set Reference density        = 3300
+    set Mass fraction cpx        = 0.10
+    set Reference specific heat  = 1000
+    set Relative density of melt = 0.878787879  # melt density of 2900 kg/m^3
+    set Reference temperature    = 1623.15      # 1350°C adiabat
+    set Pyroxenite melting entropy change = -300
+    set Thermal conductivity     = 0.0
+    set Compressibility          = 0.0
+  end
+end
+
+# The settings above all pertain to the description of the
+# continuous partial differential equations we want to solve.
+# The following section deals with the discretization of
+# this problem, namely the kind of mesh we want to compute
+# on. We here use a globally refined mesh without
+# adaptive mesh refinement.
+subsection Mesh refinement
+  set Initial global refinement                = 3
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# The final part is to specify what ASPECT should do with the
+# solution once computed at the end of every time step. The
+# process of evaluating the solution is called `postprocessing'
+# and we choose to compute velocity and temperature statistics,
+# statistics about the heat flux through the boundaries of the
+# domain, and to generate graphical output files for later
+# visualization. These output files are created every time
+# a time step crosses time points separated by 0.01. Given
+# our start time (zero) and final time (0.5) this means that
+# we will obtain 50 output files.
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, latent heat
+end
diff --git a/tests/use_full_A_block_preconditioner.prm.bak b/tests/use_full_A_block_preconditioner.prm.bak
new file mode 100644
index 00000000000..9e81c204546
--- /dev/null
+++ b/tests/use_full_A_block_preconditioner.prm.bak
@@ -0,0 +1,88 @@
+# This is a relatively realistic compressible model setup.
+# There is no simple analytical solution to it, it is rather
+# intended to serve as a comparison for more complicated
+# models. This variation is particularly made to test using
+# the full A block as preconditioner for the Stokes system
+# instead of the simplified approximation described in the
+# first ASPECT paper.
+
+set CFL number                             = 1.0
+set End time                               = 1e5
+set Adiabatic surface temperature          = 1600.0
+set Use years in output instead of seconds = true
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use full A block as preconditioner = true
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0,1
+
+  subsection Spherical constant
+    set Inner temperature = 4250
+    set Outer temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius  = 3481000
+    set Opening angle = 90
+    set Outer radius  = 6371000
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 200.0
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density = 3340
+    set Reference specific heat = 1200
+    set Thermal expansion coefficient = 3e-5
+    set Viscosity = 1e21
+    set Reference compressibility = 2.5e-12
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.0
+  set Coarsening fraction                = 0.0
+  set Strategy                           = velocity
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,2,3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
+
+subsection Heating model
+  set List of model names = adiabatic heating, shear heating
+end
diff --git a/tests/van_keken_smooth_particle.prm.bak b/tests/van_keken_smooth_particle.prm.bak
new file mode 100644
index 00000000000..54a54304bbb
--- /dev/null
+++ b/tests/van_keken_smooth_particle.prm.bak
@@ -0,0 +1,108 @@
+# A description of the van Keken et al. benchmark using smooth initial
+# conditions instead of the discontinuous ones in
+# van-keken-discontinuous.prm. See the manual for more information.
+# This test adds particles to the cookbook parameter file, and therefore
+# tests the behavior of the particles.
+
+set Dimension                              = 2
+set End time                               = 70
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 0.9142
+    set Y extent  = 1.0000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right
+  set Zero velocity boundary indicators       = bottom, top
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1010
+    set Viscosity                     = 1e2
+    set Thermal expansion coefficient = 0
+    set Density differential for compositional field 1 = -10
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+############### Parameters describing the temperature field
+# Note: The temperature plays no role in this model
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# Note: The compositional field is what drives the flow
+# in this example
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = pi=3.1415926
+    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
+  end
+end
+
+############### Parameters describing the discretization
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Strategy                           = composition
+  set Initial global refinement          = 4
+  set Time steps between mesh refinement = 0
+  set Coarsening fraction                = 0.05
+  set Refinement fraction                = 0.3
+end
+
+############### Parameters describing what to do with the solution
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, composition statistics,particles
+
+  subsection Particles
+    set Time between data output = 70
+    set Data output format = vtu
+  end
+end
+
+subsection Particles
+  set List of particle properties = function, initial composition, initial position
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 10
+    end
+  end
+end
diff --git a/tests/vankeken_subduction.cc.bak b/tests/vankeken_subduction.cc.bak
new file mode 100644
index 00000000000..89ad2bb0304
--- /dev/null
+++ b/tests/vankeken_subduction.cc.bak
@@ -0,0 +1,2 @@
+#include "../cookbooks/prescribed_velocity/prescribed_velocity.cc"
+#include "../cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc"
diff --git a/tests/vankeken_subduction.prm.bak b/tests/vankeken_subduction.prm.bak
new file mode 100644
index 00000000000..b68d80fbffd
--- /dev/null
+++ b/tests/vankeken_subduction.prm.bak
@@ -0,0 +1,13 @@
+include $ASPECT_SOURCE_DIR/cookbooks/vankeken_subduction/vankeken_corner_flow.prm
+
+set End time = 0
+
+subsection Mesh refinement
+  set Initial global refinement = 0
+  set Initial adaptive refinement = 0
+end
+
+# Postprocessing
+subsection Postprocess
+  set List of postprocessors = velocity statistics
+end
diff --git a/tests/var_declaration_expansion.cc.bak b/tests/var_declaration_expansion.cc.bak
new file mode 100644
index 00000000000..12776345f3c
--- /dev/null
+++ b/tests/var_declaration_expansion.cc.bak
@@ -0,0 +1,55 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/utilities.h>
+
+#include <iostream>
+
+void print_string_vector(std::vector<std::string> data)
+{
+  for (std::vector<std::string>::iterator it = data.begin(); it != data.end(); ++it)
+    std::cout << "\t" << *it << std::endl;
+}
+
+int f()
+{
+  using namespace aspect::Utilities;
+
+  std::vector<std::string> base_declarations;
+  base_declarations.push_back("vector(  vec  )");
+  base_declarations.push_back("tensor(  ten )");
+
+  std::vector<std::string> var_decl_2 = expand_dimensional_variable_names<2> (base_declarations);
+  std::vector<std::string> var_decl_3 = expand_dimensional_variable_names<3> (base_declarations);
+
+  std::cout << "Dimension 2:" << std::endl;
+  print_string_vector(var_decl_2);
+
+  std::cout << "Dimension 3:" << std::endl;
+  print_string_vector(var_decl_3);
+
+  exit(0);
+
+  // dummy return for compilation warnings
+
+  return 0;
+}
+
+int ignored_variable = f();
diff --git a/tests/var_declaration_expansion.prm.bak b/tests/var_declaration_expansion.prm.bak
new file mode 100644
index 00000000000..bfa37b00c09
--- /dev/null
+++ b/tests/var_declaration_expansion.prm.bak
@@ -0,0 +1,80 @@
+# A test that simply verifies that the additional material
+# model outputs can be accessed.
+
+
+
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/velocity_boundary_statistics.prm.bak b/tests/velocity_boundary_statistics.prm.bak
new file mode 100644
index 00000000000..116d7d2dc25
--- /dev/null
+++ b/tests/velocity_boundary_statistics.prm.bak
@@ -0,0 +1,92 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e13
+set Start time                             = 0
+set Adiabatic surface temperature          = 1613.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = 0, 1
+
+  subsection Spherical constant
+    set Inner temperature = 1613.0
+    set Outer temperature = 1613.0
+  end
+end
+
+subsection Termination criteria
+  set Checkpoint on termination = true
+  set Termination criteria      = end step
+  set End step                  = 10
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 9.81
+  end
+end
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6371000
+    set Opening angle = 90
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1613
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1e22
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 4
+  set Additional refinement times              = 0,0
+  set Strategy = velocity
+  set Time steps between mesh refinement       = 2
+  set Refinement fraction                      = 0.1
+  set Coarsening fraction                      = 0.0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 2, 3
+  set Zero velocity boundary indicators       = 1
+end
+
+subsection Heating model
+  set List of model names = shear heating
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, heat flux statistics, velocity boundary statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/velocity_divergence.cc.bak b/tests/velocity_divergence.cc.bak
new file mode 100644
index 00000000000..fe5b66368ef
--- /dev/null
+++ b/tests/velocity_divergence.cc.bak
@@ -0,0 +1,69 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+
+namespace aspect
+{
+  template <int dim>
+  class TestMaterial:
+    public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
+  {
+    public:
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+
+      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
+                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
+      {
+        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
+          {
+            out.viscosities[i] = 1e19;
+            out.thermal_expansion_coefficients[i] = 0.0;
+            out.specific_heat[i] = 1.0;
+            out.thermal_conductivities[i] = 1e-4;
+            out.compressibilities[i] = 0.0;
+            out.densities[i] = 3000;
+            for (unsigned int c=0; c<in.composition[i].size(); ++c)
+              {
+                if (in.requests_property(MaterialModel::MaterialProperties::reaction_terms))
+                  out.reaction_terms[i][c] = trace(in.strain_rate[i]) * this->get_timestep();
+                else
+                  out.reaction_terms[i][c] = 0.0;
+              }
+
+          }
+      }
+  };
+}
+
+// explicit instantiations
+namespace aspect
+{
+
+  ASPECT_REGISTER_MATERIAL_MODEL(TestMaterial,
+                                 "test material",
+                                 "")
+
+}
diff --git a/tests/velocity_divergence.prm.bak b/tests/velocity_divergence.prm.bak
new file mode 100644
index 00000000000..0c667e22076
--- /dev/null
+++ b/tests/velocity_divergence.prm.bak
@@ -0,0 +1,161 @@
+# This is a test investigating if the divergence
+# of the velocity is really zero, as it should be
+# in cases where no melt is present. The material model
+# implements a reaction term for the porosity
+# compositional field that equals the velocity divergence
+# in the way it would be used in models with melt transport,
+# but in this model melt migration is not used.
+#
+# The divergence is zero if the velocity is prescribed at
+# all of the boundaries, but not with a mix of free slip and
+# prescribed velocity boundary conditions.
+# ---------------------
+set Adiabatic surface temperature          = 1580
+set CFL number                             = 1.0
+set Nonlinear solver scheme                = iterated Advection and Stokes
+set Output directory                       = test
+set Max nonlinear iterations               = 6
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+# This end time is chosen in such a way that the solitary wave travels
+# approximately 5 times its wavelength during the model time.
+set End time                               = 250.0
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = porosity
+end
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,1,2,3
+
+  subsection Box
+    set Top temperature = 293
+    set Bottom temperature = 1580
+  end
+end
+
+subsection Boundary composition model
+  set Allow fixed composition on outflow boundaries = true
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = 0,1,2,3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0:function, 1:function #,2:function, 3:function
+  set Tangential velocity boundary indicators = 2,3
+
+  subsection Function
+    set Function constants  = z0=35000, u0=1.00, x0=10000, z1=35000
+    set Variable names      = x,z
+    set Function expression = u0*z/z0;0.0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 70000
+    set Y extent  = 35000
+    set X repetitions = 2
+
+    #    set X periodic = true
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = adiabatic
+
+  subsection Adiabatic
+    set Age top boundary layer      = 1e7
+    set Age bottom boundary layer   = 0.0
+    set Amplitude                   = 0
+    set Radius                      = 30000
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = pi=3.1415926,a = 1e-5, b = 35000, c = 2000, d=17500
+    set Function expression = a * exp(-((x-b)*(x-b)+(y-d)*(y-d))/(2*c*c))
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = test material
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.005
+  set Refinement fraction                      = 0.0
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 6
+  set Strategy                                 = minimum refinement function, composition
+  set Time steps between mesh refinement       = 0
+
+  subsection Minimum refinement function
+    set Coordinate system   = cartesian
+    set Function expression = if(y>35000,if(x<60000,7,if(x<15000,5,5)),5)
+    set Variable names      = x,y
+  end
+end
+
+subsection Boundary fluid pressure model
+  set Plugin name = density
+
+  subsection Density
+    set Density formulation = solid density
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,composition statistics,velocity statistics, mass flux statistics
+
+  subsection Visualization
+    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate
+    set Number of grouped files       = 0
+    set Interpolate output            = false
+    set Output format                 = vtu
+    set Time between graphical output = 0
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+  end
+end
+
+subsection Checkpointing
+  set Steps between checkpoint = 10
+end
+
+subsection Solver parameters
+  set Composition solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+    set Use direct solver for Stokes system = false
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/velocity_in_years.prm.bak b/tests/velocity_in_years.prm.bak
new file mode 100644
index 00000000000..06492761127
--- /dev/null
+++ b/tests/velocity_in_years.prm.bak
@@ -0,0 +1,89 @@
+#########################################################
+# A variation of composition-active (but only because that
+# one has prescribed, variable boundary conditions).
+#
+# We used to have a bug in that when "Use years in output instead of seconds"
+# was set to "true", we would still interpret velocities given in the input
+# file as in m/s. Presumably, people mean to use m/year in that case. See the
+# email thread with Cedric Thieulot, subject "velocity RMS" in December 2012.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+# Prescribe velocities in the range [-1,1]. Given that above
+# we say that we want years instead of seconds, this is supposed
+# to mean "1 m/year", not "1 m/second".
+#
+# 1m/year is approximately equal to 3.17e-8 m/s.
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2
+  set Prescribed velocity boundary indicators = 3: function
+
+  subsection Function
+    set Variable names      = x,z,t
+    set Function constants  = pi=3.1415926
+    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 0
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/vep_chemical_compositions.prm.bak b/tests/vep_chemical_compositions.prm.bak
new file mode 100644
index 00000000000..2a5451f89ee
--- /dev/null
+++ b/tests/vep_chemical_compositions.prm.bak
@@ -0,0 +1,84 @@
+# This tests checks that we do not have to specify material properties
+# for compositional fields that do not represent chemical compositions.
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm
+
+
+# Global parameters
+set Dimension                              = 2
+set End time                               = 1000
+set Max nonlinear iterations               = 2
+set Output directory                       = vep_chemical_compositions
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 6
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, plastic_strain, viscous_strain, test
+  set Types of fields  = stress, stress, stress, strain, strain, chemical composition
+end
+
+# We prescribe some initial strain at the center of the domain
+# plastic_strain, viscous_strain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0; 0; 0; \
+                              if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0); \
+                              if(x>=35e3&x<=65e3&y>=35.e3&y<=65.e3,0.8,0); 1
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  # We test whether we can specify
+  # 1. the same value for all fields
+  # 2. a value for each field (old behaviour, preserved for backwards compatibility)
+  # 3. only values for chemical composition fields
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5e-23, 5e-23, 5e-23, 5e-23, 5e-23, 5e-23, 5e-23
+    set Stress exponents for dislocation creep = 1, 0, 0, 0, 0, 0, 1
+    set Activation energies for dislocation creep = 0, 0
+    set Activation volumes for dislocation creep = 0
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0,10,10,10,5,5,0
+    set Cohesions = 1.e6,0,0,0,0,0,1e6
+    set Strain weakening mechanism = plastic weakening with plastic strain and viscous weakening with viscous strain
+    set Start prefactor strain weakening intervals = 0,0
+    set End prefactor strain weakening intervals = 1,1,1,1,1,1,1
+    set Prefactor strain weakening factors = 0.5,0.5
+    set Start plasticity strain weakening intervals = 0.,0
+    set End plasticity strain weakening intervals = 1,1,1,1,1,1,1
+    set Cohesion strain weakening factors = 0.5,0.5
+    set Friction strain weakening factors = 0.5
+    set Elastic shear moduli        = 1e10,1e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Time between graphical output = 1000
+  end
+end
diff --git a/tests/vis_velocity_in_years.prm.bak b/tests/vis_velocity_in_years.prm.bak
new file mode 100644
index 00000000000..51694c3b056
--- /dev/null
+++ b/tests/vis_velocity_in_years.prm.bak
@@ -0,0 +1,63 @@
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1.0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1.2
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/visco_elastic_top_beam.prm b/tests/visco_elastic_top_beam.prm
index e27fc9f5fe3..7833dcac8b0 100644
--- a/tests/visco_elastic_top_beam.prm
+++ b/tests/visco_elastic_top_beam.prm
@@ -43,9 +43,9 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
     set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0
     set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/tests/visco_elastic_top_beam.prm.bak b/tests/visco_elastic_top_beam.prm.bak
new file mode 100644
index 00000000000..e27fc9f5fe3
--- /dev/null
+++ b/tests/visco_elastic_top_beam.prm.bak
@@ -0,0 +1,154 @@
+# Like the viscous_top_beam.prm test, but including elasticity.
+
+
+# Global parameters
+set Dimension                              = 2
+set End time                               = 2e3
+set Use years in output instead of seconds = true
+set Output directory = output_ve
+set CFL number                             = 0.5
+set Maximum time step                      = 1e3
+
+# Solver settings
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 2000
+  end
+end
+
+# Model geometry (7.5x5 km, 0.1 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 10
+    set X extent      = 7.5e3
+    set Y extent      = 5e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Element types
+subsection Discretization
+  set Temperature polynomial degree           = 1
+  set Use locally conservative discretization = false
+  set Use discontinuous temperature discretization = false
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+    set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0
+    set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0
+  end
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = top
+  set Tangential velocity boundary indicators = bottom, left, right
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, beam
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; if (x>=3.5e3 && x<=4.0e3 && y>=3.0e3, 1, 0)
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Fixed composition boundary indicators  = bottom, top, right, left
+  set List of model names                   = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 293
+    set Left temperature   = 293
+    set Right temperature  = 293
+    set Top temperature    = 293
+  end
+end
+
+# Temperature initial conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Densities            =  2800,  2800,  2800,  2800,  6000
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5.e-19, 5.e-19, 5.e-19, 5.e-19, 5.e-25
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
+    set Fixed elastic time step     = 2e3
+    set Use fixed elastic time step = true
+    set Viscosity averaging scheme  = maximum composition
+    set Cohesions = 1.e50
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate, stress second invariant, principal stress
+    set Output format = gnuplot
+    set Time steps between graphical output = 1
+    set Interpolate output = true
+
+    subsection Principal stress
+      set Use deviatoric stress = true
+    end
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+end
diff --git a/tests/visco_plastic.prm.bak b/tests/visco_plastic.prm.bak
new file mode 100644
index 00000000000..70e7a3c88a6
--- /dev/null
+++ b/tests/visco_plastic.prm.bak
@@ -0,0 +1,96 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_additional_plastic_outputs.prm.bak b/tests/visco_plastic_additional_plastic_outputs.prm.bak
new file mode 100644
index 00000000000..3344c0c6f2e
--- /dev/null
+++ b/tests/visco_plastic_additional_plastic_outputs.prm.bak
@@ -0,0 +1,132 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_additional_plastic_outputs
+set Timing output frequency                = 1
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = plastic_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 20.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/visco_plastic_adiabat_temperature.prm.bak b/tests/visco_plastic_adiabat_temperature.prm.bak
new file mode 100644
index 00000000000..e7793e437b0
--- /dev/null
+++ b/tests/visco_plastic_adiabat_temperature.prm.bak
@@ -0,0 +1,118 @@
+# A test for adding an adiabatic temperature gradient to the temperature
+# in the flow laws for the visco_plastic material model.
+# This is useful for incompressible models that do not include an adiabatic
+# temperature gradient.
+# This test modifies the visco_plastic_diffusion_dislocation_composite test
+# by adding a temperature gradient to the otherwise uniform temperature (1573).
+# The gradient is added in terms of pressure rather than depth.
+# Using a pressure gradient of 32436 Pa/m, then a value of
+# 0.3 K/km = 0.0003 K/m = 9.24e-09 K/Pa gives an earth-like adiabat.
+# At the surface P = 3e9 Pa (as defined in original test) so Tv = T + Tad ~ 1600
+# strain-rate = 4.48e-16 (from applied pure shear) and eta-comp ~ 3.43e18 Pa s.
+# At the bottom of the box (100 km, P = 3e9 + 3300*100e3*10 = 6.3e9 Pa, with g = 10 m/s^2)
+# In the test, there is some dynamic pressure, so the pressure at the bottom is 6.15e9 Pa
+# For this pressure, eta-comp ~ 20.016e18 Pa s
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_adiabat_temperature
+set Surface pressure                       = 3.e9
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1573
+    set Left temperature   = 1573
+    set Right temperature  = 1573
+    set Top temperature    = 1573
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = mm=0.001, year=1
+    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1573
+  end
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = composite
+    set Grain size = 1.e-3
+    set Grain size exponents for diffusion creep = 3.
+    set Prefactors for diffusion creep = 2.37e-15
+    set Activation energies for diffusion creep = 375.e3
+    set Activation volumes for diffusion creep = 10.e-6
+    set Prefactors for dislocation creep = 6.52e-16
+    set Stress exponents for dislocation creep = 3.5
+    set Activation energies for dislocation creep = 530.e3
+    set Activation volumes for dislocation creep = 18.e-6
+    set Adiabat temperature gradient for viscosity = 9.24e-09
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_adiabatic_heating_density.prm.bak b/tests/visco_plastic_adiabatic_heating_density.prm.bak
new file mode 100644
index 00000000000..1551c607bbc
--- /dev/null
+++ b/tests/visco_plastic_adiabatic_heating_density.prm.bak
@@ -0,0 +1,115 @@
+# A test with the visco_plastic material model to ensure
+# that the multicomponent_incompressible EOS module
+# uses the adiabatic temperature to compute density when
+# adiabatic heating is turned on. The formula specified
+# in this test follows the Extended Boussinesq approximation.
+# The initial temperature throughout the model is equal to
+# the adiabatic temperature profile. As a result, the
+# the absolute density should be constant throughout the
+# model and equal to the background values specified in
+# material model (3300 kg m^-3):
+#   density = background_density * ( 1 - thermal_expansivity * (temperature - reference_temperature)),
+# where the reference_temperature is the depth-dependent
+# adiabatic temperature. If adiabatic heating was not
+# used in the model, then the reference temperature
+# would be the constant value specified in the material
+# model (273 K), which would produce different density values.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1573
+
+# In combination with simplified adiabatic and shear heating,
+# the parameters give the Extended Boussinesq approximation.
+subsection Formulation
+  set Formulation          = custom
+  set Mass conservation    = incompressible
+  set Temperature equation = reference density profile
+end
+
+subsection Heating model
+  set List of model names = shear heating, adiabatic heating
+
+  subsection Adiabatic heating
+    set Use simplified adiabatic heating = true
+  end
+end
+
+# Model geometry (100x100 km, 100 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# No mesh refinement
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# All boundaries have a fixed temperature
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators  = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+# The initial temperature profile is equal to the adiabatic temperature profile.
+subsection Initial temperature model
+  set Model name = adiabatic
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Since adiabatic heating is used, the reference temperature
+    # specified below will be ignored and the density formulation
+    # will use the adiabatic temperature.
+    set Reference temperature = 273
+    set Thermal expansivities = 1e-5
+    set Densities             = 3300
+
+    # Constant viscosity
+    set Viscous flow law                         = diffusion
+    set Grain size exponents for diffusion creep = 0.
+    set Prefactors for diffusion creep           = 5.e-22
+    set Activation energies for diffusion creep  = 0.
+    set Activation volumes for diffusion creep   = 0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = material statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = adiabat, density
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/visco_plastic_adiabatic_pressure_in_viscous_creep.prm.bak b/tests/visco_plastic_adiabatic_pressure_in_viscous_creep.prm.bak
new file mode 100644
index 00000000000..57282f24785
--- /dev/null
+++ b/tests/visco_plastic_adiabatic_pressure_in_viscous_creep.prm.bak
@@ -0,0 +1,149 @@
+# A test for using the adiabatic pressure in creep (diffusion,
+# dislocation, peierls) viscosity calculation for the visco_plastic
+# material model. For example, the adiabatic pressure is 3.3e9 Pa
+# (= rho * g * depth = 3300 * 10 * 100e3) at the bottom. So, the
+# predicted diffusion viscosisty ‘eta_diff’ can be calculated by the
+# following equation:
+#
+#   eta_diff = 0.5 * A^(-1/n) * d^(m/n) * exp((E + P_ad*V)/(nRT))
+#            = 7.47e18 Pa*s
+#
+#  A    = 2.37e-15   # diffusion creep prefactor m^3/Pa*s
+#  d    = 1.e-3      # grain size [m]
+#  n    = 1          # stress exponent for diffusion
+#  m    = 3.         # grain size exponents for diffusion
+#  R    = 8.314      # gas constant [J/mol*K]
+#  T    = 1573       # temperature [K]
+#  E    = 375.e3     # activation energy for diffusion [J/mol]
+#  V    = 10.e-6     # activation volume for diffusion [m^3/mol]
+#  P_ad = 3.3e9      # adiabatic pressure at the bottom (Pa)
+
+# Similarly, the predicted dislocation viscosity 'eta_disl' and peierls
+# viscosity 'eta_peir' can be obtained by the corresponding equations.
+# The following 'subsection Visco Plastic' provides the relevant parameter
+# values. eta_disl = 1.14e21 Pa*s. eta_peir = 7.46e22 Pa*s. The predicted
+# composite (average) viscosity is 7.42e18 Pa*s.
+# The material model returns the harmonic average of the three creep
+# viscosities at the bottom.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_adiabatic_pressure_in_viscous_creep
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1573
+    set Left temperature   = 1573
+    set Right temperature  = 1573
+    set Top temperature    = 1573
+  end
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = mm=0.001, year=1
+    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1573
+  end
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = composite
+
+    # diffusion creep parameters
+    set Grain size = 1.e-3
+    set Grain size exponents for diffusion creep = 3.
+    set Prefactors for diffusion creep = 2.37e-15
+    set Activation energies for diffusion creep = 375.e3
+    set Activation volumes for diffusion creep = 10.e-6
+
+    # dislocation creep parameters
+    set Prefactors for dislocation creep = 6.52e-16
+    set Stress exponents for dislocation creep = 3.5
+    set Activation energies for dislocation creep = 530.e3
+    set Activation volumes for dislocation creep = 18.e-6
+
+    # peierls creep parameters
+    set Include Peierls creep                     = true
+    set Peierls creep flow law                    = exact
+    set Prefactors for Peierls creep              = 1.4e-19
+    set Activation energies for Peierls creep     = 320.e3
+    set Activation volumes for Peierls creep      = 1.4e-5
+    set Peierls stresses                          = 5.e9
+    set Stress exponents for Peierls creep        = 2.0
+    set Peierls fitting parameters                = 0.17
+    set Peierls glide parameters p                = 0.5
+    set Peierls glide parameters q                = 1.0
+    set Peierls strain rate residual tolerance    = 1e-6
+    set Maximum Peierls strain rate iterations    = 40
+    set Cutoff stresses for Peierls creep         = 0.0
+    set Use adiabatic pressure in creep viscosity = true
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_complex.prm.bak b/tests/visco_plastic_complex.prm.bak
new file mode 100644
index 00000000000..9ef7aced3bc
--- /dev/null
+++ b/tests/visco_plastic_complex.prm.bak
@@ -0,0 +1,174 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_complex
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1573
+    set Top temperature    =  273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Initial temperature field
+# Typical continental geotherm based equations 4-6 from Chapman 1986 (Geol. Soc. Lon.)
+# The initial constraints are:
+#   surface temperature (ts) = 273 K; basal temperature (tb) = 1573 K; Moho
+#   temperature (tm) = 873 K; crust heat production (A) = 9.e-7 W/m^3; crust
+#   thermal conductivity (kc) = 2.5 (W/(m K));
+# To satisfy these constraints, the following values are required:
+#   surface heat flow (qs) = 0.0635 W/m^2; basal heat flow = 0.365 W/m^2;
+#   mantle thermal conductivity (km) = 3.65 (W/(m K));
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=100e3,ts=273,tm=873.,qs=0.0635,qb=0.0365,kc=2.5,km=3.65,A=9.e-7
+    set Function expression = if( (h-y)<=30.e3, \
+                                  ts + (qs/kc)*(h-y) - (A*(h-y)*(h-y))/(2.0*kc), \
+                                  tm + (qb/km)*(h-y-30.e3))
+  end
+end
+
+# Internal heating (only internal heating for crust)
+# Assuming a very large decay time, the heat production (W/m^3) is effectively:
+#   radioactive_heating_rate (W/kg) * density (kg/m^3)
+# For a reference crustal density of 2800 kg/m^3 and 9.e-7 W/m^3 heating production,
+# the heating rate (assuming a single element) is 9.e-7/2800. = 3.214287e-10
+subsection Heating model
+  set List of model names = radioactive decay
+
+  subsection Radioactive decay
+    set Number of elements            = 1
+    set Heating rates                 = 3.2142857e-10
+    set Half decay times              = 1.e20
+    set Initial concentrations mantle = 0.0
+    set Initial concentrations crust  = 1.0
+    set Crust defined by composition  = true
+    set Crust composition number      = 1
+  end
+end
+
+# Compositional fields used to track finite strain
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = plastic_strain, crust
+end
+
+# Initial composition model
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0; if(y>=70.e3, 1, 0);
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material, strain fields and crust)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Reference values and viscosity averaging
+    set Minimum strain rate = 1.e-20
+    set Reference strain rate = 1.e-16
+    set Minimum viscosity = 1e18
+    set Maximum viscosity = 1e28
+    set Viscosity averaging scheme = harmonic
+
+    # Thermodynamic properties
+    set Thermal diffusivities = 1.474747e-6,1.474747e-6,1.190476e-6
+    set Heat capacities = 750.
+    set Densities = 3300,3300,2800
+    set Thermal expansivities = 0.
+
+    # Viscous flow laws
+    # Background: Dry olive (Hirth & Kohlstedt 2004), Crust: Wet quartzite (Rutter & Brodie 2004)
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 6.52e-16,6.52e-16,8.57e-28
+    set Stress exponents for dislocation creep = 3.5,3.5,4.0
+    set Activation energies for dislocation creep = 530.e3,530.e3,223.e3
+    set Activation volumes for dislocation creep = 18.e-6,18.e-6,0.
+
+    # Yielding mechanism and values
+    set Yield mechanism = limiter
+    set Stress limiter exponents = 10, 10, 10
+    set Angles of internal friction = 0.,0.,0.
+    set Cohesions = 1.e6,1.e6,1.e6
+
+    # Strain weakening
+    set Strain weakening mechanism = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_composite.prm.bak b/tests/visco_plastic_composite.prm.bak
new file mode 100644
index 00000000000..f7b853d6197
--- /dev/null
+++ b/tests/visco_plastic_composite.prm.bak
@@ -0,0 +1,108 @@
+# Test for the visco_plastic composite viscosity option.
+# The user-defined diffusion and dislocation viscosity are
+# 1e22 Pa s and the composite viscosity should be 5e21 Pa s.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = mm=0.001, year=1
+    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = composite
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Prefactors for diffusion creep = 5.e-23
+    set Grain size exponents for diffusion creep = 0.
+    set Activation energies for diffusion creep = 0.
+    set Activation volumes for diffusion creep = 0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_constant_viscosity_prefactor.prm.bak b/tests/visco_plastic_constant_viscosity_prefactor.prm.bak
new file mode 100644
index 00000000000..ccb4c3f7163
--- /dev/null
+++ b/tests/visco_plastic_constant_viscosity_prefactor.prm.bak
@@ -0,0 +1,104 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_constant_viscosity_prefactor
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, bottom, left, right
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = weak_layer
+end
+
+# The compositional field is only present in the lower half of the model
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if (y<=50e3,1,0)
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    # Background and compositional field both have initial viscosity of 1e23 Pa s
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-24
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+
+    # The compositional field viscosity is reduced by a factor of 10 before yielding
+    set Constant viscosity prefactors = 1., 0.1
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = material properties
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/visco_plastic_derivatives_2d.cc.bak b/tests/visco_plastic_derivatives_2d.cc.bak
new file mode 100644
index 00000000000..795ab6f89af
--- /dev/null
+++ b/tests/visco_plastic_derivatives_2d.cc.bak
@@ -0,0 +1,274 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/simulator_access.h>
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/visco_plastic.h>
+#include <aspect/simulator_access.h>
+#include <aspect/newton.h>
+#include <aspect/parameters.h>
+
+#include <deal.II/grid/tria.h>
+#include <deal.II/base/exceptions.h>
+#include <memory>
+#include <functional>
+
+#include <iostream>
+
+template <int dim>
+void f(const aspect::SimulatorAccess<dim> &simulator_access,
+       aspect::Assemblers::Manager<dim> &,
+       std::string averaging_parameter)
+{
+
+  std::cout << std::endl << "Testing ViscoPlastic derivatives against analytical derivatives for averaging parameter " << averaging_parameter << std::endl;
+
+  using namespace aspect::MaterialModel;
+
+  // first set all material model values
+  MaterialModelInputs<dim> in_base(5,3);
+  in_base.composition[0][0] = 0;
+  in_base.composition[0][1] = 0;
+  in_base.composition[0][2] = 0;
+  in_base.composition[1][0] = 0.75;
+  in_base.composition[1][1] = 0.15;
+  in_base.composition[1][2] = 0.10;
+  in_base.composition[2][0] = 0;
+  in_base.composition[2][1] = 0.2;
+  in_base.composition[2][2] = 0.4;
+  in_base.composition[3][0] = 0;
+  in_base.composition[3][1] = 0.2;
+  in_base.composition[3][2] = 0.4;
+  in_base.composition[4][0] = 1;
+  in_base.composition[4][1] = 0;
+  in_base.composition[4][2] = 0;
+
+  in_base.temperature[0] = 293;
+  in_base.temperature[1] = 1600;
+  in_base.temperature[2] = 2000;
+  in_base.temperature[3] = 2100;
+  in_base.temperature[4] = 600;
+
+  in_base.pressure[0] = 1e9;
+  in_base.pressure[1] = 5e9;
+  in_base.pressure[2] = 2e10;
+  in_base.pressure[3] = 2e11;
+  in_base.pressure[4] = 5e8;
+
+  in_base.position[0] = Point<dim>();
+  in_base.position[1] = Point<dim>();
+  in_base.position[2] = Point<dim>();
+  in_base.position[3] = Point<dim>();
+  in_base.position[4] = Point<dim>();
+
+  /**
+   * We can't take too small strain-rates, because then the difference in the
+   * viscosity will be too small for the double accuracy which stores
+   * the viscosity solutions and the finite difference solution.
+   */
+  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
+  in_base.strain_rate[0][0][0] = 1e-12;
+  in_base.strain_rate[0][0][1] = 1e-12;
+  in_base.strain_rate[0][1][1] = 1e-11;
+
+  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[1][0][0] = -1.71266e-13;
+  in_base.strain_rate[1][0][1] = -5.82647e-12;
+  in_base.strain_rate[1][1][1] = 4.21668e-14;
+
+  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[2][1][1] = 1e-13;
+  in_base.strain_rate[2][0][1] = 1e-11;
+  in_base.strain_rate[2][0][0] = -1e-12;
+
+  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[3][1][1] = 4.9e-21;
+  in_base.strain_rate[3][0][1] = 4.9e-21;
+  in_base.strain_rate[3][0][0] = 4.9e-21;
+
+  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[4][1][1] = 1e-11;
+  in_base.strain_rate[4][0][1] = 1e-11;
+  in_base.strain_rate[4][0][0] = -1e-11;
+
+
+  // initialize some variables we will need later.
+  double finite_difference_accuracy = 1e-7;
+  double finite_difference_factor = 1+finite_difference_accuracy;
+
+
+  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
+
+  MaterialModelOutputs<dim> out_base(5,3);
+  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
+  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
+
+  // initialize the material we want to test.
+  aspect::ParameterHandler prm;
+
+  const aspect::MaterialModel::ViscoPlastic<dim> &const_material_model = dynamic_cast<const aspect::MaterialModel::ViscoPlastic<dim> &>(simulator_access.get_material_model());
+  aspect::MaterialModel::ViscoPlastic<dim> &material_model = const_cast<aspect::MaterialModel::ViscoPlastic<dim> &>(const_material_model);
+
+  material_model.declare_parameters(prm);
+
+  prm.enter_subsection("Material model");
+  {
+    prm.enter_subsection ("Visco Plastic");
+    {
+      prm.set ("Viscosity averaging scheme", averaging_parameter);
+      prm.set ("Angles of internal friction", "30");
+    }
+    prm.leave_subsection();
+  }
+  prm.leave_subsection();
+
+  const_cast<aspect::MaterialModel::Interface<dim> &>(simulator_access.get_material_model()).parse_parameters(prm);
+
+  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
+
+  simulator_access.get_material_model().evaluate(in_base, out_base);
+
+  // set up additional output for the derivatives
+  MaterialModelDerivatives<dim> *derivatives;
+  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
+  double temp;
+
+  // have a bool so we know whether the test has succeed or not.
+  bool Error = false;
+
+  // test the pressure derivative.
+  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
+  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
+
+  simulator_access.get_material_model().evaluate(in_dviscositydpressure, out_dviscositydpressure);
+
+  for (unsigned int i = 0; i < 5; i++)
+    {
+      // prevent division by zero. If it is zero, the test has passed, because or
+      // the finite difference and the analytical result match perfectly, or (more
+      // likely) the material model in independent of this variable.
+      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
+      if (in_base.pressure[i] != 0)
+        {
+          temp /= (in_base.pressure[i] * finite_difference_accuracy);
+        }
+      std::cout << "pressure: point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i]  << std::endl;
+      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
+        {
+          std::cout << "   Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
+          Error = true;
+        }
+
+    }
+
+  // test the strain-rate derivative.
+  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
+    {
+      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          // components that are not on the diagonal are multiplied by 0.5, because the symmetric tensor
+          // is modified by 0.5 in both symmetric directions (xy/yx) simultaneously and we compute the combined
+          // derivative
+          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
+                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
+                                                    * (component > dim-1 ? 0.5 : 1 )
+                                                    * finite_difference_accuracy
+                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
+        }
+
+
+      simulator_access.get_material_model().evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          // prevent division by zero. If it is zero, the test has passed, because or
+          // the finite difference and the analytical result match perfectly, or (more
+          // likely) the material model in independent of this variable.
+          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
+          if (temp != 0)
+            {
+              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
+            }
+          std::cout << "strain-rate: point = " << i << ", component = " << component << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
+          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
+            {
+              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
+              Error = true;
+            }
+
+        }
+
+    }
+
+  if (Error)
+    {
+      std::cout << "Some parts of the test were not successful." << std::endl;
+    }
+  else
+    {
+      std::cout << "OK" << std::endl;
+    }
+
+}
+
+template <>
+void f(const aspect::SimulatorAccess<3> &,
+       aspect::Assemblers::Manager<3> &,
+       std::string )
+{
+  AssertThrow(false,dealii::ExcInternalError());
+}
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  using namespace dealii;
+  std::cout << "* Connecting signals" << std::endl;
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2,
+                                            "harmonic"));
+
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2,
+                                            "geometric"));
+
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2,
+                                            "arithmetic"));
+
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2,
+                                            "maximum composition"));
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/visco_plastic_derivatives_2d.prm.bak b/tests/visco_plastic_derivatives_2d.prm.bak
new file mode 100644
index 00000000000..841bc22c95a
--- /dev/null
+++ b/tests/visco_plastic_derivatives_2d.prm.bak
@@ -0,0 +1,118 @@
+# This test checks whether the derivatives of the drucker prager
+# material model are the same as the finite difference derivatives
+# created by the drucker prager material model.
+set Additional shared libraries = tests/libvisco_plastic_derivatives.so
+set Dimension                              = 2
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Adiabatic surface temperature          = 273
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);0;0
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Angles of internal friction = 30.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_derivatives_3d.cc.bak b/tests/visco_plastic_derivatives_3d.cc.bak
new file mode 100644
index 00000000000..f7432393b1b
--- /dev/null
+++ b/tests/visco_plastic_derivatives_3d.cc.bak
@@ -0,0 +1,289 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/simulator.h>
+#include <aspect/simulator_access.h>
+
+#include <aspect/material_model/interface.h>
+#include <aspect/material_model/visco_plastic.h>
+#include <aspect/simulator_access.h>
+#include <aspect/newton.h>
+#include <aspect/parameters.h>
+
+#include <deal.II/grid/tria.h>
+#include <deal.II/base/exceptions.h>
+#include <memory>
+#include <functional>
+
+#include <iostream>
+
+template <int dim>
+void f(const aspect::SimulatorAccess<dim> &simulator_access,
+       aspect::Assemblers::Manager<dim> &,
+       std::string averaging_parameter)
+{
+
+  std::cout << std::endl << "Testing ViscoPlastic derivatives against analytical derivatives for averaging parameter " << averaging_parameter << std::endl;
+
+  using namespace aspect::MaterialModel;
+
+  // first set all material model values
+  MaterialModelInputs<dim> in_base(5,3);
+  in_base.composition[0][0] = 0;
+  in_base.composition[0][1] = 0;
+  in_base.composition[0][2] = 0;
+  in_base.composition[1][0] = 0.75;
+  in_base.composition[1][1] = 0.15;
+  in_base.composition[1][2] = 0.10;
+  in_base.composition[2][0] = 0;
+  in_base.composition[2][1] = 0.2;
+  in_base.composition[2][2] = 0.4;
+  in_base.composition[3][0] = 0;
+  in_base.composition[3][1] = 0.2;
+  in_base.composition[3][2] = 0.4;
+  in_base.composition[4][0] = 1;
+  in_base.composition[4][1] = 0;
+  in_base.composition[4][2] = 0;
+
+  in_base.temperature[0] = 293;
+  in_base.temperature[1] = 1600;
+  in_base.temperature[2] = 2000;
+  in_base.temperature[3] = 2100;
+  in_base.temperature[4] = 600;
+
+  in_base.pressure[0] = 1e9;
+  in_base.pressure[1] = 5e9;
+  in_base.pressure[2] = 2e10;
+  in_base.pressure[3] = 2e11;
+  in_base.pressure[4] = 5e8;
+
+  in_base.position[0] = Point<dim>();
+  in_base.position[1] = Point<dim>();
+  in_base.position[2] = Point<dim>();
+  in_base.position[3] = Point<dim>();
+  in_base.position[4] = Point<dim>();
+
+  /**
+   * We can't take too small strain-rates, because then the difference in the
+   * viscosity will be too small for the double accuracy which stores
+   * the viscosity solutions and the finite difference solution.
+   */
+  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
+  in_base.strain_rate[0][0][0] = 1e-12;
+  in_base.strain_rate[0][0][1] = 1e-12;
+  in_base.strain_rate[0][1][1] = 1e-11;
+  in_base.strain_rate[0][2][0] = 1e-12;
+  in_base.strain_rate[0][2][1] = 1e-12;
+  in_base.strain_rate[0][2][2] = 1e-11;
+
+  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[1][0][0] = -1.71266e-13;
+  in_base.strain_rate[1][0][1] = -5.82647e-12;
+  in_base.strain_rate[1][1][1] = 4.21668e-14;
+  in_base.strain_rate[1][2][0] = -5.42647e-12;
+  in_base.strain_rate[1][2][1] = -5.22647e-12;
+  in_base.strain_rate[1][2][2] = 4.21668e-14;
+
+  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[2][1][1] = 1e-13;
+  in_base.strain_rate[2][0][1] = 1e-11;
+  in_base.strain_rate[2][0][0] = -1e-12;
+  in_base.strain_rate[2][2][0] = 1e-11;
+  in_base.strain_rate[2][2][1] = 1e-11;
+  in_base.strain_rate[2][2][2] = -1e-12;
+
+  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[3][1][1] = 4.9e-21;
+  in_base.strain_rate[3][0][1] = 4.9e-21;
+  in_base.strain_rate[3][0][0] = 4.9e-21;
+  in_base.strain_rate[3][2][0] = 4.9e-21;
+  in_base.strain_rate[3][2][1] = 4.9e-21;
+  in_base.strain_rate[3][2][2] = 4.9e-21;
+
+  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
+  in_base.strain_rate[4][1][1] = 1e-11;
+  in_base.strain_rate[4][0][1] = 1e-11;
+  in_base.strain_rate[4][0][0] = -5e-12;
+  in_base.strain_rate[4][2][0] = 1e-11;
+  in_base.strain_rate[4][2][1] = 1e-11;
+  in_base.strain_rate[4][2][2] = -5e-12;
+
+
+  // initialize some variables we will need later.
+  double finite_difference_accuracy = 1e-7;
+  double finite_difference_factor = 1+finite_difference_accuracy;
+
+
+  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
+
+  MaterialModelOutputs<dim> out_base(5,3);
+  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
+  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
+
+  // initialize the material we want to test.
+  aspect::ParameterHandler prm;
+
+  const aspect::MaterialModel::ViscoPlastic<dim> &const_material_model = dynamic_cast<const aspect::MaterialModel::ViscoPlastic<dim> &>(simulator_access.get_material_model());
+  aspect::MaterialModel::ViscoPlastic<dim> &material_model = const_cast<aspect::MaterialModel::ViscoPlastic<dim> &>(const_material_model);
+
+  material_model.declare_parameters(prm);
+
+  prm.enter_subsection("Material model");
+  {
+    prm.enter_subsection ("Visco Plastic");
+    {
+      prm.set ("Viscosity averaging scheme", averaging_parameter);
+      prm.set ("Angles of internal friction", "30");
+    }
+    prm.leave_subsection();
+  }
+  prm.leave_subsection();
+
+  const_cast<aspect::MaterialModel::Interface<dim> &>(simulator_access.get_material_model()).parse_parameters(prm);
+
+  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
+
+  simulator_access.get_material_model().evaluate(in_base, out_base);
+
+  // set up additional output for the derivatives
+  MaterialModelDerivatives<dim> *derivatives;
+  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
+  double temp;
+
+  // have a bool so we know whether the test has succeed or not.
+  bool Error = false;
+
+  // test the pressure derivative.
+  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
+  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
+  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
+
+  simulator_access.get_material_model().evaluate(in_dviscositydpressure, out_dviscositydpressure);
+
+  for (unsigned int i = 0; i < 5; i++)
+    {
+      // prevent division by zero. If it is zero, the test has passed, because or
+      // the finite difference and the analytical result match perfectly, or (more
+      // likely) the material model in independent of this variable.
+      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
+      if (in_base.pressure[i] != 0)
+        {
+          temp /= (in_base.pressure[i] * finite_difference_accuracy);
+        }
+      std::cout << "pressure: point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i]  << std::endl;
+      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
+        {
+          std::cout << "   Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
+          Error = true;
+        }
+
+    }
+
+  // test the strain-rate derivative.
+  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
+    {
+      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          // components that are not on the diagonal are multiplied by 0.5, because the symmetric tensor
+          // is modified by 0.5 in both symmetric directions (xy/yx) simultaneously and we compute the combined
+          // derivative
+          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
+                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
+                                                    * (component > dim-1 ? 0.5 : 1 )
+                                                    * finite_difference_accuracy
+                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
+        }
+
+
+      simulator_access.get_material_model().evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
+
+      for (unsigned int i = 0; i < 5; i++)
+        {
+          // prevent division by zero. If it is zero, the test has passed, because or
+          // the finite difference and the analytical result match perfectly, or (more
+          // likely) the material model in independent of this variable.
+          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
+          if (temp != 0)
+            {
+              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
+            }
+          std::cout << "strain-rate: point = " << i << ", component = " << component << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
+          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
+            {
+              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
+              Error = true;
+            }
+
+        }
+
+    }
+
+  if (Error)
+    {
+      std::cout << "Some parts of the test were not successful." << std::endl;
+    }
+  else
+    {
+      std::cout << "OK" << std::endl;
+    }
+
+}
+
+template <>
+void f(const aspect::SimulatorAccess<2> &,
+       aspect::Assemblers::Manager<2> &,
+       std::string )
+{
+  AssertThrow(false,dealii::ExcInternalError());
+}
+
+template <int dim>
+void signal_connector (aspect::SimulatorSignals<dim> &signals)
+{
+  using namespace dealii;
+  std::cout << "* Connecting signals" << std::endl;
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2,
+                                            "harmonic"));
+
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2,
+                                            "geometric"));
+
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2,
+                                            "arithmetic"));
+
+  signals.set_assemblers.connect (std::bind(&f<dim>,
+                                            std::placeholders::_1,
+                                            std::placeholders::_2,
+                                            "maximum composition"));
+}
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
diff --git a/tests/visco_plastic_derivatives_3d.prm.bak b/tests/visco_plastic_derivatives_3d.prm.bak
new file mode 100644
index 00000000000..68114301dc3
--- /dev/null
+++ b/tests/visco_plastic_derivatives_3d.prm.bak
@@ -0,0 +1,118 @@
+# This test checks whether the derivatives of the drucker prager
+# material model are the same as the finite difference derivatives
+# created by the drucker prager material model.
+set Additional shared libraries = tests/libvisco_plastic_derivatives.so
+set Dimension                              = 3
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Adiabatic surface temperature          = 273
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 3
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);0;0
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Angles of internal friction = 30.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_diffusion.prm.bak b/tests/visco_plastic_diffusion.prm.bak
new file mode 100644
index 00000000000..5199e9f5960
--- /dev/null
+++ b/tests/visco_plastic_diffusion.prm.bak
@@ -0,0 +1,110 @@
+# A test for diffusion creep in the visco_plastic material model.
+# The diffusion creep viscosity is defined as:
+#   0.5 * A^(-1/n) * d^(m/n) * exp((E + P*V)/(nRT)), with
+#   A = 2.37e-15, n = 1, d = 1e-3, m = 3, E = 375.e3,
+#   V = 10e-6, P = 3e9, T = 1573 and R = 8.3144598.
+# Using these values, the computed viscosity should be
+#   ~ 5.9266e18 Pa s.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 3.e9
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1573
+    set Left temperature   = 1573
+    set Right temperature  = 1573
+    set Top temperature    = 1573
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = mm=0.001, year=1
+    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1573
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = diffusion
+    set Grain size = 1.e-3
+    set Grain size exponents for diffusion creep = 3.
+    set Prefactors for diffusion creep = 2.37e-15
+    set Activation energies for diffusion creep = 375.e3
+    set Activation volumes for diffusion creep = 10.e-6
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_diffusion_dislocation_composite.prm.bak b/tests/visco_plastic_diffusion_dislocation_composite.prm.bak
new file mode 100644
index 00000000000..6d698882f81
--- /dev/null
+++ b/tests/visco_plastic_diffusion_dislocation_composite.prm.bak
@@ -0,0 +1,116 @@
+# A test for composite creep in the visco_plastic material model.
+# The composite creep viscosity (vis_composite) is defined as:
+#   (vis_diffusion * vis_dislocation)/(vis_diffusion + vis_dislocation)
+# The diffusion and dislocation creep viscosity values are, respectively,
+# ~ 5.9266e18 Pa s and ~ 4.4592e20 Pa s. For more information on how these
+# values are calculated, see tests visco_plastic_diffusion and
+# visco_plastic_dislocation.
+# Using these values, the composite viscosity should be:
+#   ~ 5.8488e18 Pa s.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 3.e9
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1573
+    set Left temperature   = 1573
+    set Right temperature  = 1573
+    set Top temperature    = 1573
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = mm=0.001, year=1
+    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1573
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = composite
+    set Grain size = 1.e-3
+    set Grain size exponents for diffusion creep = 3.
+    set Prefactors for diffusion creep = 2.37e-15
+    set Activation energies for diffusion creep = 375.e3
+    set Activation volumes for diffusion creep = 10.e-6
+    set Prefactors for dislocation creep = 6.52e-16
+    set Stress exponents for dislocation creep = 3.5
+    set Activation energies for dislocation creep = 530.e3
+    set Activation volumes for dislocation creep = 18.e-6
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_dislocation.prm.bak b/tests/visco_plastic_dislocation.prm.bak
new file mode 100644
index 00000000000..15fc1186c55
--- /dev/null
+++ b/tests/visco_plastic_dislocation.prm.bak
@@ -0,0 +1,109 @@
+# A test for dislocation creep in the visco_plastic material model.
+# The dislocation creep viscosity is defined as:
+#   0.5 * A^(-1/n) * edot_ii^((1-n)/n) * exp((E + P*V)/(nRT)), with
+#   A = 6.52e-16, n = 3.5, edot_ii = 3.16887e-16, E = 530.e3,
+#   V = 18e-6, P = 3e9, T = 1573 and R = 8.3144598.
+# Using these values, the computed viscosity should be
+#   ~ 4.4592e20 Pa s.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 3.e9
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1573
+    set Left temperature   = 1573
+    set Right temperature  = 1573
+    set Top temperature    = 1573
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = mm=0.001, year=1
+    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1573
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 6.52e-16
+    set Stress exponents for dislocation creep = 3.5
+    set Activation energies for dislocation creep = 530.e3
+    set Activation volumes for dislocation creep = 18.e-6
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_frank_kamenetskii.prm.bak b/tests/visco_plastic_frank_kamenetskii.prm.bak
new file mode 100644
index 00000000000..f005ed25519
--- /dev/null
+++ b/tests/visco_plastic_frank_kamenetskii.prm.bak
@@ -0,0 +1,107 @@
+# A test for Frank Kamenetskii rheology in the visco_plastic material model.
+# Frank-Kamenetskii viscosity approximation:
+# viscosity = A * exp(E * 0.5 * (1.0-(T/ref_T)))
+# A: 1.e21, E: 15., ref_T: 1573
+# Using these values, the computed viscosity should be
+#   ~ 1e21 Pa s.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1573.
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1573
+    set Left temperature   = 1573
+    set Right temperature  = 1573
+    set Top temperature    = 1573
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = mm=0.001, year=1
+    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1573
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = frank kamenetskii
+    set Viscosity ratios for Frank Kamenetskii = 15.
+    set Prefactors for Frank Kamenetskii = 1.e21
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_frank_kamenetskii_pressure.prm.bak b/tests/visco_plastic_frank_kamenetskii_pressure.prm.bak
new file mode 100644
index 00000000000..1e60e8f1902
--- /dev/null
+++ b/tests/visco_plastic_frank_kamenetskii_pressure.prm.bak
@@ -0,0 +1,108 @@
+# A test for Frank Kamenetskii rheology in the visco_plastic material model.
+# Frank-Kamenetskii viscosity approximation:
+# viscosity = A * exp(E * 0.5 * (1.0-(T/ref_T)) + F * (P-ref_P)/(ref_rho*g*h))
+# A: 1.e21, E: 15., ref_T: 1573, F: 2., ref_P = 0
+# Using these values, the computed viscosity at the model surface (P = ref_P = 0) should be
+#   ~ 1e21 Pa s.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 0
+set Adiabatic surface temperature          = 1573.
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1573
+    set Left temperature   = 1573
+    set Right temperature  = 1573
+    set Top temperature    = 1573
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = mm=0.001, year=1
+    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1573
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = frank kamenetskii
+    set Viscosity ratios for Frank Kamenetskii = 15.
+    set Prefactors for Frank Kamenetskii = 1.e21
+    set Pressure prefactors for Frank Kamenetskii = 2.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_friction_function.prm.bak b/tests/visco_plastic_friction_function.prm.bak
new file mode 100644
index 00000000000..4473ce482ea
--- /dev/null
+++ b/tests/visco_plastic_friction_function.prm.bak
@@ -0,0 +1,111 @@
+# A quadratic box where the friction angle is
+# given as a function dependent of space and time.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 3
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_friction_function
+set Timing output frequency                = 1
+set Maximum time step                      = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name      = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0; 0;
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate                     = 1.e-16
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5.e-23
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Yield mechanism                           = drucker
+    set Angles of internal friction               = 0.
+    set Cohesions                                 = 1.e6
+
+    # these are the lines you need to use the friction function
+    set Friction mechanism                        = function
+
+    subsection Friction function
+      set Coordinate system                       = cartesian
+      set Variable names                          = x,y,t
+      set Function expression                     = if(x>0 ,if(t <2 ,0, 30), 15)
+    end
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name  = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_gerya_2019_vp.prm.bak b/tests/visco_plastic_gerya_2019_vp.prm.bak
new file mode 100644
index 00000000000..e78b2a592c5
--- /dev/null
+++ b/tests/visco_plastic_gerya_2019_vp.prm.bak
@@ -0,0 +1,21 @@
+# This parameter file modifies the benchmark gerya_2019_vp.prm
+# to use a coarser resolution
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm
+
+
+#  Global parameters
+set Dimension                              = 2
+set Max nonlinear iterations               = 2
+set Output directory                       = visco_plastic_gerya_2019_vp
+
+# Reduce the number of global refinements from 5 to 3
+subsection Mesh refinement
+  set Initial global refinement          = 3
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, material statistics, velocity statistics
+  set Run postprocessors on nonlinear iterations = false
+end
diff --git a/tests/visco_plastic_newton_nonlinear_channelflow.prm.bak b/tests/visco_plastic_newton_nonlinear_channelflow.prm.bak
new file mode 100644
index 00000000000..2edc307f674
--- /dev/null
+++ b/tests/visco_plastic_newton_nonlinear_channelflow.prm.bak
@@ -0,0 +1,124 @@
+# Like the poiseuille_2d.prm test and based on the nonlinear channel
+# flow benchmark. This is used to test the velocity boundary conditions
+# of the Newton Stokes solver.
+
+set Output directory = vp_input_v_2_new
+set Dimension = 2
+set CFL number                             = 1.0
+set Maximum time step                      = 1
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 1
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme = iterated Advection and Newton Stokes
+set Max nonlinear iterations = 150
+set Nonlinear solver tolerance = 5e-12
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-5
+    set Stokes solver type = block AMG
+  end
+
+  subsection Newton solver parameters
+    set Max pre-Newton nonlinear iterations = 10
+    set Nonlinear Newton solver switch tolerance = 1e-20
+    set Max Newton line search iterations = 0
+    set Maximum linear Stokes solver tolerance = 1e-2
+    set Use Newton residual scaling method = false
+    set Use Newton failsafe = false
+    set Stabilization preconditioner = SPD
+    set Stabilization velocity block = SPD
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Left temperature = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 10e3
+    set Y extent = 8e3
+    set Y repetitions = 1
+  end
+end
+
+subsection Material model
+  set Model name = visco plastic
+  set Material averaging = none
+
+  subsection Visco Plastic
+    set Viscous flow law = dislocation
+    set Minimum viscosity = 1e19
+    set Maximum viscosity = 1e24
+    set Prefactors for diffusion creep = 1
+    set Prefactors for dislocation creep = 1e-37
+    set Grain size exponents for diffusion creep = 0
+    set Activation energies for diffusion creep = 0
+    set Activation energies for dislocation creep = 0
+    set Activation volumes for diffusion creep = 0
+    set Activation volumes for dislocation creep = 0
+    set Stress exponents for dislocation creep = 3
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = 0, 1
+  set Prescribed velocity boundary indicators = 2: function, 3: function # velocity bc
+
+  subsection Function
+    set Function constants = n = 3
+    set Variable names = x,z
+
+    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
+    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-(abs(x-(5e3))^(n+1)));
+  end
+end
+
+subsection Boundary traction model
+  subsection Function
+    set Variable names = x,z
+
+    # We want to prescribe a pressure of 2 at the left boundary
+    # and -2 at the right boundary.
+    # The traction in this case is defined as:
+    # tau =  - pressure * normal_vector.
+    # On the left boundary, the outward pointing normal vector is
+    # (-1;0). On the right (1;0).
+    # Therefore:
+    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
+    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
+    # Conveniently, the traction is the same on both boundaries.
+    set Function expression = 0;if(z>0,0,1e9)
+  end
+end
diff --git a/tests/visco_plastic_peierls_cutoff_test.prm.bak b/tests/visco_plastic_peierls_cutoff_test.prm.bak
new file mode 100644
index 00000000000..215594cc155
--- /dev/null
+++ b/tests/visco_plastic_peierls_cutoff_test.prm.bak
@@ -0,0 +1,100 @@
+# A test for the exact Peierls creep flow law
+# with the visco_plastic material model.
+# Following the general Peierls creep flow law of Idrissi
+# et al. 2016 and assuming a stress of 100 Pa. Idrissi
+# has stress exponent = 0 so that strain rate does not
+# go to 0 as stress goes to 0. To allow for convergence
+# approximate strain rate below a cutoff stress of 1000 Pa
+# as a quadratic function of stress.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 3.e2
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# No boundary-driven deformation, but the strain-rate used by the material
+# model is set in the material model section through the parameters
+# "Reference strain rate" and "Minimum strain rate".
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1073
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate                     = 9.576747017313619e-11
+    set Minimum strain rate                       = 9.576747017313619e-11
+
+    # dislocation creep parameters
+    # These values produce such a sufficiently high viscosity that the
+    # composite viscosity between the diffusion and dislocation creep
+    # is effectively equal to the Peierls creep viscosity.
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep          = 1.e-50
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0
+    set Activation volumes for dislocation creep  = 0
+
+    # Peierls creep parameters
+    set Include Peierls creep                     = true
+    set Peierls creep flow law                    = exact
+    set Prefactors for Peierls creep              = 1e6
+    set Activation energies for Peierls creep     = 566.e3
+    set Activation volumes for Peierls creep      = 0.
+    set Peierls stresses                          = 3.8e9
+    set Stress exponents for Peierls creep        = 0.0
+    set Peierls fitting parameters                = 0.15
+    set Peierls glide parameters p                = 0.5
+    set Peierls glide parameters q                = 2.0
+    set Peierls strain rate residual tolerance    = 1e-12
+    set Maximum Peierls strain rate iterations    = 40
+    set Cutoff stresses for Peierls creep         = 1000
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = material statistics
+end
diff --git a/tests/visco_plastic_peierls_idrissi_exact.prm.bak b/tests/visco_plastic_peierls_idrissi_exact.prm.bak
new file mode 100644
index 00000000000..400d651f3b8
--- /dev/null
+++ b/tests/visco_plastic_peierls_idrissi_exact.prm.bak
@@ -0,0 +1,120 @@
+# A test for the exact Peierls creep flow law
+# with the visco_plastic material model.
+# Following the general Peierls creep flow law of Idrissi
+# et al. 2016 and assuming a stress of 1.092890e8 Pa (strain rate is 1e-13 s^(-1)), the
+# exact viscosity is calculated in python through:
+#  import numpy as np
+#  A    = 1e6     # Peierls creep prefactor 1/s 1/Pa^2
+#  R    = 8.314   # gas constant [J/mol*K]
+#  T    = 1073    # temperature [K]
+#  sig  = 1.092890e8 # stress [Pa]
+#  sigp = 3.8e9   # Peierls creep stress [Pa]
+#  E    = 566e3   # Peierls creep activation energy [J/mol]
+#  V    = 0       # Peierls creep activation volume
+#  P    = 0       # Pressure (Pa)
+#  n    = 0       # Peierls creep stress exponent
+#  p    = 0.5     # First slide parameter
+#  q    = 2       # Second glide parameter
+#
+#  Strain rate invariant:
+#    edot_ii = A*np.power(sig,n)*np.exp(-(E/(R*T))*np.power( (1-np.power((sig/sigp),p) ),q) )
+#            = 1.000000e-13
+#
+#  Viscosity:
+#    visc = 0.5*sig/edot_ii = 5.464448e20
+#
+# The material model should return this viscosity.
+# The strain rate invariant (edot_ii) above is manually set in the material
+# model subsection.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 3.e9
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# No boundary-driven deformation, but the strain-rate used by the material
+# model is set in the material model section through the parameters
+# "Reference strain rate" and "Minimum strain rate".
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+# Initial temperature conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1073
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate                     = 1e-13
+    set Minimum strain rate                       = 1e-13
+
+    # dislocation creep parameters
+    # These values produce such a sufficiently high viscosity that the
+    # composite viscosity between the diffusion and dislocation creep
+    # is effectively equal to the Peierls creep viscosity.
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep          = 1.e-50
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0
+    set Activation volumes for dislocation creep  = 0
+
+    # Peierls creep parameters
+    set Include Peierls creep                     = true
+    set Peierls creep flow law                    = exact
+    set Prefactors for Peierls creep              = 1e6
+    set Activation energies for Peierls creep     = 566.e3
+    set Activation volumes for Peierls creep      = 0.
+    set Peierls stresses                          = 3.8e9
+    set Stress exponents for Peierls creep        = 0.0
+    set Peierls fitting parameters                = 0.15
+    set Peierls glide parameters p                = 0.5
+    set Peierls glide parameters q                = 2.0
+    set Peierls strain rate residual tolerance    = 1e-6
+    set Maximum Peierls strain rate iterations    = 40
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = material statistics
+end
diff --git a/tests/visco_plastic_peierls_mei_exact.prm.bak b/tests/visco_plastic_peierls_mei_exact.prm.bak
new file mode 100644
index 00000000000..f4ef1471c41
--- /dev/null
+++ b/tests/visco_plastic_peierls_mei_exact.prm.bak
@@ -0,0 +1,120 @@
+# A test for the exact Peierls creep flow law
+# with the visco_plastic material model.
+# Following the general Peierls creep flow law of Mei
+# et al. 2010 and assuming a stress of 900e6 Pa, the
+# exact viscosity is calculated in python through:
+#  import numpy as np
+#  A    = 1.4e-7/np.power(1e6,2) # Peierls creep prefactor 1/s 1/Pa^2
+#  R    = 8.314   # gas constant [J/mol*K]
+#  T    = 1073    # temperature [K]
+#  sig  = 1000e6  # stress [Pa]
+#  sigp = 5.9e9   # Peierls creep stress [Pa]
+#  E    = 320e3   # Peierls creep activation energy [J/mol]
+#  V    = 0       # Peierls creep activation volume
+#  P    = 0       # Pressure (Pa)
+#  n    = 2       # Peierls creep stress exponent
+#  p    = 0.5     # First slide parameter
+#  q    = 1       # Second glide parameter
+#
+#  Strain rate invariant:
+#    edot_ii = A*np.power(sig,n)*np.exp(-(E/(R*T))*np.power( (1-np.power((sig/sigp),p) ),q) )
+#            = 9.576747017313619e-11
+#
+#  Viscosity:
+#    visc = 0.5*sig/edot_ii = 5.22097951523685e+18
+#
+# The material model should return this viscosity.
+# The strain rate invariant (edot_ii) above is manually set in the material
+# model subsection.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 3.e9
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# No boundary-driven deformation, but the strain-rate used by the material
+# model is set in the material model section through the parameters
+# "Reference strain rate" and "Minimum strain rate".
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+# Initial temperature conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1073
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate                     = 9.576747017313619e-11
+    set Minimum strain rate                       = 9.576747017313619e-11
+
+    # dislocation creep parameters
+    # These values produce such a sufficiently high viscosity that the
+    # composite viscosity between the diffusion and dislocation creep
+    # is effectively equal to the Peierls creep viscosity.
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep          = 1.e-50
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0
+    set Activation volumes for dislocation creep  = 0
+
+    # Peierls creep parameters
+    set Include Peierls creep                     = true
+    set Peierls creep flow law                    = exact
+    set Prefactors for Peierls creep              = 1.4e-19
+    set Activation energies for Peierls creep     = 320.e3
+    set Activation volumes for Peierls creep      = 0.
+    set Peierls stresses                          = 5.9e9
+    set Stress exponents for Peierls creep        = 2.0
+    set Peierls fitting parameters                = 0.15
+    set Peierls glide parameters p                = 0.5
+    set Peierls glide parameters q                = 1.0
+    set Peierls strain rate residual tolerance    = 1e-12
+    set Maximum Peierls strain rate iterations    = 40
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = material statistics
+end
diff --git a/tests/visco_plastic_peierls_mei_viscosity_approx.prm.bak b/tests/visco_plastic_peierls_mei_viscosity_approx.prm.bak
new file mode 100644
index 00000000000..40ba99bfaf3
--- /dev/null
+++ b/tests/visco_plastic_peierls_mei_viscosity_approx.prm.bak
@@ -0,0 +1,77 @@
+# A test for the peierls creep viscosity approximation
+# with the visco_plastic material model.
+# Following the general Peierls creep flow law of Mei
+# et al. 2010 and assuming a stress of 900e6 Pa, the
+# exact viscosity is calculated in python through:
+#  import numpy as np
+#  A    = 1.4e-7/np.power(1e6,2) # Peierls creep prefactor 1/s 1/Pa^2
+#  R    = 8.314   # gas constant [J/mol*K]
+#  T    = 1073    # temperature [K]
+#  sig  = 1000e6  # stress [Pa]
+#  sigp = 5.9e9   # Peierls creep stress [Pa]
+#  E    = 320e3   # Peierls creep activation energy [J/mol]
+#  V    = 0       # Peierls creep activation volume
+#  P    = 0       # Pressure (Pa)
+#  n    = 2       # Peierls creep stress exponent
+#  p    = 0.5     # First slide parameter
+#  q    = 1       # Second glide parameter
+#
+#  Strain rate invariant:
+#    edot_ii = A*np.power(sig,n)*np.exp(-(E/(R*T))*np.power( (1-np.power((sig/sigp),p) ),q) )
+#            = 9.576747017313619e-11
+#
+#  Viscosity:
+#    visc = 0.5*sig/edot_ii = 5.22097951523685e+18
+#
+#  Fitting parameters for approximated viscosity:
+#    gamma = 0.15 # fitting parameter
+#
+#  Recalculate strain rate
+#    edot_ii = A*np.power(sig,n)*np.exp(-(E/(R*T))*np.power((1 - np.power(gamma,p)),q))*np.power(sig/(gamma*sigp),s)
+#            = 9.326722654162315e-11
+#
+#  Exponential term in Peierls creep viscosity approximation
+#    s =  p*q*np.power(g,p)*np.power((1-np.power(g,p)),q-1)*(E/(R*T))
+#
+#  # Approximated viscosity
+#    visca = 0.5*gamma*sigp/np.power(A*np.power(gamma*sigp,n),1/(s+n))*np.power(edot_ii,(1/(s+n))-1)*np.exp((E/(R*T))*np.power((1 - np.power(gamma,p)),q)/(s+n))
+#          = 5.360939941500902e+18
+#
+# The material model should return the above value of the approximated viscosity.
+# The strain rate invariant (edot_ii) above is manually set in the material
+# model subsection.
+
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_peierls_mei_exact.prm
+
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate                     = 9.326722654162315e-11
+    set Minimum strain rate                       = 9.326722654162315e-11
+
+    # dislocation creep parameters
+    # These values produce such a sufficiently high viscosity that the
+    # composite viscosity between the diffusion and dislocation creep
+    # is effectively equal to the Peierls creep viscosity.
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep          = 1.e-50
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0
+    set Activation volumes for dislocation creep  = 0
+
+    # Peierls creep parameters
+    set Include Peierls creep                     = true
+    set Peierls creep flow law                    = viscosity approximation
+    set Prefactors for Peierls creep              = 1.4e-19
+    set Activation energies for Peierls creep     = 320.e3
+    set Activation volumes for Peierls creep      = 0.
+    set Peierls stresses                          = 5.9e9
+    set Stress exponents for Peierls creep        = 2.0
+    set Peierls fitting parameters                = 0.15
+    set Peierls glide parameters p                = 0.5
+    set Peierls glide parameters q                = 1.0
+  end
+end
diff --git a/tests/visco_plastic_peierls_strict_cutoff_test.prm.bak b/tests/visco_plastic_peierls_strict_cutoff_test.prm.bak
new file mode 100644
index 00000000000..146b02a23ce
--- /dev/null
+++ b/tests/visco_plastic_peierls_strict_cutoff_test.prm.bak
@@ -0,0 +1,101 @@
+# A test for the exact Peierls creep flow law
+# with the visco_plastic material model.
+# Following the general Peierls creep flow law of Idrissi
+# et al. 2016 and assuming a strain rate of 1e-15 s^-1. The stress
+# from the Peierls rheology is limited by the cutoff stress
+# of 1000 Pa, so a viscosity of 5e17 Pa*s is computed instead
+# from:
+#     1000 / 1e-15 / 2.0 = 5e17
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Surface pressure                       = 3.e2
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# No boundary-driven deformation, but the strain-rate used by the material
+# model is set in the material model section through the parameters
+# "Reference strain rate" and "Minimum strain rate".
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1673
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate                     = 1e-15
+    set Minimum strain rate                       = 1e-15
+
+    # dislocation creep parameters
+    # These values produce such a sufficiently high viscosity that the
+    # composite viscosity between the diffusion and dislocation creep
+    # is effectively equal to the Peierls creep viscosity.
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep          = 1.e-50
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0
+    set Activation volumes for dislocation creep  = 0
+
+    # Peierls creep parameters
+    set Include Peierls creep                     = true
+    set Peierls creep flow law                    = exact
+    set Prefactors for Peierls creep              = 1e6
+    set Activation energies for Peierls creep     = 566.e3
+    set Activation volumes for Peierls creep      = 0.
+    set Peierls stresses                          = 3.8e9
+    set Stress exponents for Peierls creep        = 0.0
+    set Peierls fitting parameters                = 0.15
+    set Peierls glide parameters p                = 0.5
+    set Peierls glide parameters q                = 2.0
+    set Peierls strain rate residual tolerance    = 1e-22
+    set Maximum Peierls strain rate iterations    = 40
+    set Cutoff stresses for Peierls creep         = 1000
+    set Apply strict stress cutoff for Peierls creep = true
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = material statistics
+end
diff --git a/tests/visco_plastic_phases.prm.bak b/tests/visco_plastic_phases.prm.bak
new file mode 100644
index 00000000000..82b24b5dfe4
--- /dev/null
+++ b/tests/visco_plastic_phases.prm.bak
@@ -0,0 +1,106 @@
+# Copy of visco_plastic.prm, but include a phase transition for the EoS
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Phase transition depths = 50e3
+    set Phase transition widths = 1e3
+    set Phase transition temperatures = 273
+    set Phase transition Clapeyron slopes = 0
+    set Densities = background:3300|3400
+    set Thermal expansivities = background:3.5e-5|2e-5
+    set Heat capacities = background:1200|1000
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = material properties
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_phases_compositions.prm.bak b/tests/visco_plastic_phases_compositions.prm.bak
new file mode 100644
index 00000000000..2ad5384b058
--- /dev/null
+++ b/tests/visco_plastic_phases_compositions.prm.bak
@@ -0,0 +1,123 @@
+# Copy of visco_plastic_phases.prm, but include multiple
+# compositions and have different numbers of phase transitions
+# for different compositions (including 0).
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+
+  # background is assumed to be lithosphere
+  set Names of fields  = upper_crust, lower_crust
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = (y > 80000) ? 1.0 : 0.0; \
+                              (y > 50000) ? ((y <= 80000) ? 1.0 : 0.0) : 0.0
+  end
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Phase transition depths = upper_crust: 10e3, background: 70e3|90e3
+    set Phase transition widths = upper_crust: 1e3,background: 1e3|1e3
+    set Phase transition temperatures = upper_crust: 1000, background: 1000|1000
+    set Phase transition Clapeyron slopes = upper_crust: 0, background: 0|0
+    set Densities = upper_crust: 2700|2750, lower_crust: 2850, background:3300|3400|3500
+    set Thermal expansivities = upper_crust: 1e-5|1.5e-5, lower_crust: 7e-5, background:3.5e-5|2e-5|1e-5
+    set Heat capacities = upper_crust: 900|800, lower_crust: 600, background:1200|1000|700
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = material properties
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_phases_peierls_mei_exact.prm.bak b/tests/visco_plastic_phases_peierls_mei_exact.prm.bak
new file mode 100644
index 00000000000..3804c4fab33
--- /dev/null
+++ b/tests/visco_plastic_phases_peierls_mei_exact.prm.bak
@@ -0,0 +1,80 @@
+# This test is a copy of visco_plastic_peierls_mei_viscosity_exact.prm
+# but one in which phase transitions take place within the domain.
+# The viscosities, densities, thermal expansivities and heat capacities
+# change within the domain.
+
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_peierls_mei_exact.prm
+
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = right
+  set Compositional field methods = field
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set List of model operators = add
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y
+    set Function constants = XMAX=100e3
+    set Function expression = (x>XMAX/2.0) ? 1.0 : 0.0
+  end
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Phase transition depths = background:50e3|75e3, right:50e3|75e3
+    set Phase transition widths = background:1e3|1e3, right:1e3|1e3
+    set Phase transition temperatures = background:273|273, right:273|273
+    set Phase transition Clapeyron slopes = background:0|0, right:0|0
+    set Densities = background:3300|3400|3500, right:3600|3700|3800
+    set Thermal expansivities = background:3.5e-5|2e-5|1.5e-5, right:3.5e-5|2e-5|1.5e-5
+    set Heat capacities = background:1200|1000|900, right:1200|1000|900
+    set Reference strain rate                     = 9.326722654162315e-11
+    set Minimum strain rate                       = 9.326722654162315e-11
+
+    # dislocation creep parameters
+    # These values produce such a sufficiently high viscosity that the
+    # composite viscosity between the diffusion and dislocation creep
+    # is effectively equal to the Peierls creep viscosity.
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep          = background:1e-50|1e-50|1e-50, right:1e-50|1e-50|1e-50
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0
+    set Activation volumes for dislocation creep  = 0
+
+    # Peierls creep parameters
+    set Include Peierls creep                     = true
+    set Peierls creep flow law                    = exact
+    set Prefactors for Peierls creep              = background:2.8e-19|1.4e-19|0.7e-19, right:2.8e-18|1.4e-18|0.7e-18
+    set Activation energies for Peierls creep     = 320.e3
+    set Activation volumes for Peierls creep      = 0.
+    set Peierls stresses                          = 5.9e9
+    set Stress exponents for Peierls creep        = 2.0
+    set Peierls fitting parameters                = 0.15
+    set Peierls glide parameters p                = 0.5
+    set Peierls glide parameters q                = 1.0
+    set Peierls strain rate residual tolerance    = 1e-12
+    set Maximum Peierls strain rate iterations    = 40
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set List of output variables = material properties
+    set Time between graphical output = 0
+    set Number of grouped files       = 0
+
+    subsection Material properties
+      set List of material properties = density, thermal expansivity, specific heat, viscosity
+    end
+  end
+end
diff --git a/tests/visco_plastic_phases_plasticity.prm.bak b/tests/visco_plastic_phases_plasticity.prm.bak
new file mode 100644
index 00000000000..7caa29ebabc
--- /dev/null
+++ b/tests/visco_plastic_phases_plasticity.prm.bak
@@ -0,0 +1,111 @@
+# Copy of visco_plastic_phases.prm, but tests different plasticity parameters for different phases.
+# Above the 50km depth phase transition we set 10MPa and 20 degrees for the cohesion and internal friction angle.
+# Below the 50km depth phase transition plastic yielding is switched off by setting a high cohesion of 1e20, and friction changes to 0.
+# This is visible in the visualization output.
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_phases_plasticity
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Phase transition depths = 50e3
+    set Phase transition widths = 1e3
+    set Phase transition temperatures = 273
+    set Phase transition Clapeyron slopes = 0
+    set Densities = background:3300|3400
+    set Thermal expansivities = background:3.5e-5|2e-5
+    set Heat capacities = background:1200|1000
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Angles of internal friction = background: 20 | 0
+    set Cohesions                   = background: 1e7 | 1e20
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = material properties, named additional outputs
+    set Output format = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_phases_temperature_limit_basalt.prm.bak b/tests/visco_plastic_phases_temperature_limit_basalt.prm.bak
new file mode 100644
index 00000000000..1029c6da674
--- /dev/null
+++ b/tests/visco_plastic_phases_temperature_limit_basalt.prm.bak
@@ -0,0 +1,117 @@
+# This test uses a similar setup as visco_plastic.prm and includes the phase transitions
+# for basalt. Here I am showing the variations of material properties using the "specific heat"
+# field.
+# specifically, the usage of the "Phase transition temperature lower limits" and
+# the "Phase transition temperature upper limits" are demonstrated in this test case.
+# For other compositions, see also:
+# pyrolite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite.prm
+# pyrolite, complicated: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite_complicated.prm
+# harzburgite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_harzburgite.prm
+# basalt: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_basalt.prm
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Max nonlinear iterations               = 1
+set Timing output frequency                = 1
+
+# model geometry
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 800e3
+    set Y extent      = 800e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = left, right
+  set List of model names = box
+
+  subsection Box
+    set Left temperature   = 273
+    set Right temperature  = 2000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y
+    set Function constants = XMAX=800e3, Tl=273.0, Tr=2000.0
+    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
+  end
+end
+
+# value for material model
+# The phase transitions are separated into subgroups. subgroups are separated by blanks.
+# Moreover, subsgroups are connected but don't intersect each other
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Maximum viscosity = 1e24
+    set Phase transition depths = background:150e3|80e3|80e3| 665e3|720e3
+    set Phase transition widths = background:5e3|5e3|5e3| 5e3|5e3
+    set Phase transition temperatures = background:587.0|773.15|1173.0|  1662.0|1662.0
+    set Phase transition temperature lower limits = background:-1e31|769.0|773.15|  -1e31|-1e31
+    set Phase transition temperature upper limits = background:769.0|773.15|1e31|  1e31|1e31
+    set Phase transition Clapeyron slopes = background:-0.0|5e8|0.0|  4e6|1.3e6
+    set Thermal diffusivities = 1.0e-6
+    set Heat capacities = background:3000.0|3540.0|3540.0|3540.0| 3613.0|3871.7
+    set Densities = 3300.0
+    set Thermal expansivities = 0.0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = background:5e-20|5e-22|5e-22|5e-22| 5e-22|5e-22
+    set Grain size exponents for diffusion creep = 0.0
+    set Activation energies for diffusion creep = 0.0
+    set Activation volumes for diffusion creep = 0.0
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = material properties
+    set Output format = gnuplot
+    set Time between graphical output = 0.1e6
+  end
+end
diff --git a/tests/visco_plastic_phases_temperature_limit_harzburgite.prm.bak b/tests/visco_plastic_phases_temperature_limit_harzburgite.prm.bak
new file mode 100644
index 00000000000..5587302a38b
--- /dev/null
+++ b/tests/visco_plastic_phases_temperature_limit_harzburgite.prm.bak
@@ -0,0 +1,117 @@
+# This test uses a similar setup as visco_plastic.prm and includes the phase transitions
+# for harzburgite. Here I am showing the variations of material properties using the "specific heat"
+# field.
+# specifically, the usage of the "Phase transition temperature lower limits" and
+# the "Phase transition temperature upper limits" are demonstrated in this test case.
+# For other compositions, see also:
+# pyrolite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite.prm
+# pyrolite, complicated: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite_complicated.prm
+# harzburgite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_harzburgite.prm
+# basalt: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_basalt.prm
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Max nonlinear iterations               = 1
+set Timing output frequency                = 1
+
+# model geometry
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 800e3
+    set Y extent      = 800e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = left, right
+  set List of model names = box
+
+  subsection Box
+    set Left temperature   = 273
+    set Right temperature  = 2000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y
+    set Function constants = XMAX=800e3, Tl=273.0, Tr=2000.0
+    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
+  end
+end
+
+# value for material model
+# The phase transitions are separated into subgroups. subgroups are separated by blanks.
+# Moreover, subsgroups are connected but don't intersect each other
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Maximum viscosity = 1e24
+    set Phase transition depths = background:410e3|520e3|560e3| 670e3|670e3|670e3| 670e3|670e3
+    set Phase transition widths = background:5e3|5e3|5e3| 5e3|5e3|5e3| 5e3|5e3
+    set Phase transition temperatures = background:1662.0|1662.0|1662.0| 1662.0|1662.0|1662.0| 1662.0|1662.0
+    set Phase transition temperature lower limits = background:-1e31|-1e31|-1e31| -1e31|-1e31|-1e31| 1662.0|1662.0
+    set Phase transition temperature upper limits = background:1e31|1e31|1e31| 1662.0|1662.0|1662.0| 1e31|1e31
+    set Phase transition Clapeyron slopes = background:4e6|4.1e6|4e6| 4e6|-2e6|-3.1e6| -2e6|1.3e6
+    set Thermal diffusivities = 1.0e-6
+    set Heat capacities = background: 3235.0|3372.3|3441.7|3441.7| 3478.7|3716.1|3759.4| 3679.1|3759.4
+    set Densities = 3300.0
+    set Thermal expansivities = 0.0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = background:5e-22|5e-22|5e-22|5e-22| 5e-24|5e-24|5e-24| 5e-24|5e-24
+    set Grain size exponents for diffusion creep = 0.0
+    set Activation energies for diffusion creep = 0.0
+    set Activation volumes for diffusion creep = 0.0
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = material properties
+    set Output format = gnuplot
+    set Time between graphical output = 0.1e6
+  end
+end
diff --git a/tests/visco_plastic_phases_temperature_limit_pyrolite.prm.bak b/tests/visco_plastic_phases_temperature_limit_pyrolite.prm.bak
new file mode 100644
index 00000000000..1339d8609b0
--- /dev/null
+++ b/tests/visco_plastic_phases_temperature_limit_pyrolite.prm.bak
@@ -0,0 +1,117 @@
+# This test uses a similar setup as visco_plastic.prm and includes the phase transitions
+# for pyrolite. Here I am showing the variations of material properties using the "specific heat"
+# field.
+# specifically, the usage of the "Phase transition temperature lower limits" and
+# the "Phase transition temperature upper limits" are demonstrated in this test case.
+# For other compositions, see also:
+# pyrolite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite.prm
+# pyrolite, complicated: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite_complicated.prm
+# harzburgite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_harzburgite.prm
+# basalt: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_basalt.prm
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Max nonlinear iterations               = 1
+set Timing output frequency                = 1
+
+# model geometry
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 800e3
+    set Y extent      = 800e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = left, right
+  set List of model names = box
+
+  subsection Box
+    set Left temperature   = 273
+    set Right temperature  = 2000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y
+    set Function constants = XMAX=800e3, Tl=273.0, Tr=2000.0
+    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
+  end
+end
+
+# value for material model
+# The phase transitions are separated into subgroups. subgroups are separated by blanks.
+# Moreover, subsgroups are connected but don't intersect each other
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Maximum viscosity = 1e24
+    set Phase transition depths = background:410e3|520e3|560e3| 670e3|670e3|670e3| 670e3|670e3
+    set Phase transition widths = background:5e3|5e3|5e3| 5e3|5e3|5e3| 5e3|5e3
+    set Phase transition temperatures = background:1662.0|1662.0|1662.0| 1662.0|1662.0|1662.0| 1662.0|1662.0
+    set Phase transition temperature lower limits = background:-1e31|-1e31|-1e31| -1e31|-1e31|-1e31| 1662.0|1662.0
+    set Phase transition temperature upper limits = background:1e31|1e31|1e31| 1662.0|1662.0|1662.0| 1e31|1e31
+    set Phase transition Clapeyron slopes = background:4e6|4.1e6|4e6| 4e6|-2e6|-3.1e6| -2e6|1.3e6
+    set Thermal diffusivities = 1.0e-6
+    set Heat capacities = background: 3300.0|3394.4|3442.1|3453.2| 3527.1|3691.45|3774.7| 3616.45|3772.0
+    set Densities = 3300.0
+    set Thermal expansivities = 0.0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = background:5e-22|5e-22|5e-22|5e-22| 5e-24|5e-24|5e-24| 5e-24|5e-24
+    set Grain size exponents for diffusion creep = 0.0
+    set Activation energies for diffusion creep = 0.0
+    set Activation volumes for diffusion creep = 0.0
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = material properties
+    set Output format = gnuplot
+    set Time between graphical output = 0.1e6
+  end
+end
diff --git a/tests/visco_plastic_phases_temperature_limit_pyrolite_complicated.prm.bak b/tests/visco_plastic_phases_temperature_limit_pyrolite_complicated.prm.bak
new file mode 100644
index 00000000000..dcedabeb78c
--- /dev/null
+++ b/tests/visco_plastic_phases_temperature_limit_pyrolite_complicated.prm.bak
@@ -0,0 +1,117 @@
+# This test uses a similar setup as visco_plastic.prm and includes the phase transitions
+# of a complicated set. This is not a realistic case but is only a test for the implementation.
+# Here I am showing the variations of material properties using the "specific heat" field.
+# specifically, the usage of the "Phase transition temperature lower limits" and
+# the "Phase transition temperature upper limits" are demonstrated in this test case.
+# For other compositions, see also:
+# pyrolite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite.prm
+# pyrolite, complicated: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite_complicated.prm
+# harzburgite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_harzburgite.prm
+# basalt: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_basalt.prm
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Max nonlinear iterations               = 1
+set Timing output frequency                = 1
+
+# model geometry
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 800e3
+    set Y extent      = 800e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = left, right
+  set List of model names = box
+
+  subsection Box
+    set Left temperature   = 273
+    set Right temperature  = 2000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y
+    set Function constants = XMAX=800e3, Tl=273.0, Tr=2000.0
+    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
+  end
+end
+
+# value for material model
+# The phase transitions are separated into subgroups. subgroups are separated by blanks.
+# Moreover, subsgroups are connected but don't intersect each other
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference temperature = 273
+    set Maximum viscosity = 1e24
+    set Phase transition depths = background:670e3|670e3| 670e3|670e3|670e3| 670e3|670e3
+    set Phase transition widths = background:5e3|5e3| 5e3|5e3|5e3| 5e3|5e3
+    set Phase transition temperatures = background:1662.0|962.0| 962.0|1662.0|1662.0| 1662.0|1662.0
+    set Phase transition temperature lower limits = background:-1e31|-1e31| 1425.0|1425.0|-1e31| 1662.0|1662.0
+    set Phase transition temperature upper limits = background:1425.0|1425.0| 1e31|1662.0|1662.0| 1e31|1e31
+    set Phase transition Clapeyron slopes = background:4e6|-2e6| -2e6|4e6|-3.1e6| -3.1e6|4e6
+    set Thermal diffusivities = 1.0e-6
+    set Heat capacities = background:1000|2000|4000| 3000|4000|4500| 3500|4500
+    set Densities = 3300.0
+    set Thermal expansivities = 0.0
+    set Viscous flow law = diffusion
+    set Prefactors for diffusion creep = 5e-22
+    set Grain size exponents for diffusion creep = 0.0
+    set Activation energies for diffusion creep = 0.0
+    set Activation volumes for diffusion creep = 0.0
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = material properties
+    set Output format = gnuplot
+    set Time between graphical output = 0.1e6
+  end
+end
diff --git a/tests/visco_plastic_phases_viscosity.prm.bak b/tests/visco_plastic_phases_viscosity.prm.bak
new file mode 100644
index 00000000000..3bec9e86dc5
--- /dev/null
+++ b/tests/visco_plastic_phases_viscosity.prm.bak
@@ -0,0 +1,129 @@
+# Copy of visco_plastic.prm, but include a phase transition for the EoS
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = right
+  set Compositional field methods = field
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set List of model operators = add
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y
+    set Function constants = XMAX=100e3
+    set Function expression = (x>XMAX/2.0) ? 1.0 : 0.0
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Phase transition depths = background:50e3|75e3, right:50e3|75e3
+    set Phase transition widths = background:1e3|1e3, right:1e3|1e3
+    set Phase transition temperatures = background:273|273, right:273|273
+    set Phase transition Clapeyron slopes = background:0|0, right:0|0
+    set Densities = background:3300|3400|3500, right:3600|3700|3800
+    set Thermal expansivities = background:3.5e-5|2e-5|1.5e-5, right:3.5e-5|2e-5|1.5e-5
+    set Heat capacities = background:1200|1000|900, right:1200|1000|900
+    set Minimum viscosity = 1.e10
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for diffusion creep = background:5.e-20|5.e-19|5.e-18, right:5.e-17|5.e-16|5.e-15
+    set Grain size exponents for diffusion creep = background:3.|3.|3., right:3.|3.|3.
+    set Activation energies for diffusion creep = background:0.|0.|0., right:0.|0.|0.
+    set Activation volumes for diffusion creep = background:0.|0.|0., right:0.|0.|0.
+    set Prefactors for dislocation creep = background:5.e-23|5.e-21|5.e-19, right:5.e-18|5.e-17|5.e-16
+    set Stress exponents for dislocation creep = background:1.0|1.0|1.0, right:1.0|1.0|1.0
+    set Activation energies for dislocation creep = background:0.|0.|0., right:0.|0.|0.
+    set Activation volumes for dislocation creep = background:0.|0.|0., right:0.|0.|0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = material properties
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_phases_viscosity_max_min.prm.bak b/tests/visco_plastic_phases_viscosity_max_min.prm.bak
new file mode 100644
index 00000000000..91daf7c66d8
--- /dev/null
+++ b/tests/visco_plastic_phases_viscosity_max_min.prm.bak
@@ -0,0 +1,133 @@
+# Copy of visco_plastic.prm, but include a phase transition for the EoS
+# as well as different values of minimum and a maximum viscosity on different phases.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = right
+  set Compositional field methods = field
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set List of model operators = add
+
+  subsection Function
+    set Coordinate system = cartesian
+    set Variable names = x, y
+    set Function constants = XMAX=100e3
+    set Function expression = (x>XMAX/2.0) ? 1.0 : 0.0
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Phase transition depths = background:50e3|75e3, right:50e3|75e3
+    set Phase transition widths = background:1e3|1e3, right:1e3|1e3
+    set Phase transition temperatures = background:273|273, right:273|273
+    set Phase transition Clapeyron slopes = background:0|0, right:0|0
+    set Densities = background:3300|3400|3500, right:3600|3700|3800
+    set Thermal expansivities = background:3.5e-5|2e-5|1.5e-5, right:3.5e-5|2e-5|1.5e-5
+    set Heat capacities = background:1200|1000|900, right:1200|1000|900
+
+    # Set Maximum and Minimum viscosities on phases
+    set Maximum viscosity = background: 1.e21 | 1.e19 | 1.e21, right: 1.e20
+    set Minimum viscosity = background: 1.e17 | 1.e17 | 1.e19, right: 1.e16
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for diffusion creep = background:5.e-20|5.e-19|5.e-18, right:5.e-17|5.e-16|5.e-15
+    set Grain size exponents for diffusion creep = background:3.|3.|3., right:3.|3.|3.
+    set Activation energies for diffusion creep = background:0.|0.|0., right:0.|0.|0.
+    set Activation volumes for diffusion creep = background:0.|0.|0., right:0.|0.|0.
+    set Prefactors for dislocation creep = background:5.e-23|5.e-21|5.e-19, right:5.e-18|5.e-17|5.e-16
+    set Stress exponents for dislocation creep = background:1.0|1.0|1.0, right:1.0|1.0|1.0
+    set Activation energies for dislocation creep = background:0.|0.|0., right:0.|0.|0.
+    set Activation volumes for dislocation creep = background:0.|0.|0., right:0.|0.|0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
+
+  subsection Visualization
+    set List of output variables = material properties
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_reference_density_profile.prm.bak b/tests/visco_plastic_reference_density_profile.prm.bak
new file mode 100644
index 00000000000..f5faa67f2a0
--- /dev/null
+++ b/tests/visco_plastic_reference_density_profile.prm.bak
@@ -0,0 +1,103 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_reference_density_profile
+set Timing output frequency                = 1
+
+# Formulation
+subsection Formulation
+  set Formulation          = custom
+  set Mass conservation    = incompressible
+  set Temperature equation = reference density profile
+end
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_thermal_conductivity.prm.bak b/tests/visco_plastic_thermal_conductivity.prm.bak
new file mode 100644
index 00000000000..95efb16e900
--- /dev/null
+++ b/tests/visco_plastic_thermal_conductivity.prm.bak
@@ -0,0 +1,21 @@
+# A test to check whether using user-specified thermal conductivity
+# values gives identical results to specifying the equivalent
+# thermal diffusivity values. The test visco_plastic_diffusion
+# uses the default values for density (3000 kg/m^3), thermal
+# diffusivity (0.8e-6 m^2/s) and heat capacity (1250 1/K).
+# The thermal conductivity is thus 3000*1250*0.8e-6 = 3.0 (W/(m K)).
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_diffusion.prm
+
+
+# Global parameters
+set Dimension                              = 2
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Define thermal conductivities = true
+    set Thermal conductivities = 3.0
+  end
+end
diff --git a/tests/visco_plastic_total_strain_healing_temperature_dependent.prm.bak b/tests/visco_plastic_total_strain_healing_temperature_dependent.prm.bak
new file mode 100644
index 00000000000..c75d64b62fe
--- /dev/null
+++ b/tests/visco_plastic_total_strain_healing_temperature_dependent.prm.bak
@@ -0,0 +1,166 @@
+# This test checks whether the temperature strain healing mechanism,
+# located in source/material_model/rheology/strain_dependent.cc,
+# works as intended when the total strain (invariant) is tracked.
+#
+# In the setup below, an initial amount of strain (0.2) is applied
+# uniformly throughout the domain via the initial composition subsection.
+# The model contains a uniform initial temperature (273 K) and no-slip BC
+# to produce no movement throughout the model domain. This ensures that
+# no additional strain accumulates and the value of the compositional
+# tracking the total strain invariant will strictly dependent on the
+# temperature-dependent strain healing parameters.
+#
+# The temperature-dependent strain healing is formulated as:
+#   healed_strain = strain_healing_temperature_dependent_recovery_rate *
+#                   exp( -strain_healing_temperature_dependent_prefactor *
+#                        0.5 * ( 1.0 - temperature/reference_temperature ) ) *
+#                   time
+#
+# Above, the parameters strain_healing_temperature_dependent_recovery_rate
+# and strain_healing_temperature_dependent_prefactor are user-defined
+# values set to, respectively, 1.e-15 and 15. The parameter reference_temperature
+# is equal to the user-specified adiabatic surface temperature, which is
+# set to 273 K. The variable time simply refers to how long the model
+# has run.
+#
+# The model runs for 10 millions years with 2 million year time steps.
+# For example, the analytical prediction for the value of the compositional
+# field total_strain at 10 Myr is:
+#   0.2 - (1e-15 * exp(-15. * 0.5 * (1.0 - 273/293))*10.e6*31556952.0) ~= 0.01087
+# Note that 31556952.0 represents the conversion from years to seconds.
+#
+# Comparing the analytical and numerical solution (values from log.txt)
+# at each time step demonstrates the strain healing implementation
+# is working as expected.
+# Time      Analytical Solution   Calculated Solution
+# 0  Myr    0.200000              0.2000
+# 2  Myr    0.162174              0.1622
+# 4  Myr    0.124348              0.1243
+# 6  Myr    0.086522              0.08652
+# 8  Myr    0.048691              0.0487
+# 10 Myr    0.010870              0.01087
+#
+# The calculated value can be observed directly in the file screen-output, as the
+# composition statistics postprocessor is used. For future debugging purposes,
+# the time step is limited to 2e6 years and both statistics and solution files
+# are output as well.
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 10e6
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Maximum time step                      = 2e6
+set Output directory                       = visco_plastic_total_strain_healing_temperature_dependent
+set Timing output frequency                = 1
+set Adiabatic surface temperature = 293
+
+# Model geometry (100x100 km, 25 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 5
+    set Y repetitions = 5
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = initial temperature
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = bottom, top, left, right
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = total_strain
+end
+
+# Prescribe initial values for total_strain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.2
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-20
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5.e-23
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 30.
+    set Cohesions                   = 1.e9
+    set Strain weakening mechanism = total strain
+    set Start prefactor strain weakening intervals  = 0.0
+    set End prefactor strain weakening intervals    = 0.2
+    set Prefactor strain weakening factors          = 0.5
+    set Start plasticity strain weakening intervals = 0.0
+    set End plasticity strain weakening intervals   = 0.2
+    set Cohesion strain weakening factors           = 0.5
+    set Friction strain weakening factors           = 0.5
+    set Strain healing mechanism  = temperature dependent
+    set Strain healing temperature dependent recovery rate = 1.e-15
+    set Strain healing temperature dependent prefactor     = 15.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = composition statistics, material statistics, temperature statistics, velocity statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+    set Time between graphical output = 2e6
+  end
+end
diff --git a/tests/visco_plastic_track_noninitial_plastic_strain.prm.bak b/tests/visco_plastic_track_noninitial_plastic_strain.prm.bak
new file mode 100644
index 00000000000..e89241c9331
--- /dev/null
+++ b/tests/visco_plastic_track_noninitial_plastic_strain.prm.bak
@@ -0,0 +1,133 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1e3
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_track_noninitial_plastic_strain
+set Timing output frequency                = 1
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = plastic_strain, noninitial_plastic_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=40e3 & x<=60e3 & y>=40.3e3& y<=60.e3, 0.2, 0); 0.0;
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+    set Time between graphical output       = 1e3
+  end
+end
diff --git a/tests/visco_plastic_vep_bending_beam.prm.bak b/tests/visco_plastic_vep_bending_beam.prm.bak
new file mode 100644
index 00000000000..28d8e3927b2
--- /dev/null
+++ b/tests/visco_plastic_vep_bending_beam.prm.bak
@@ -0,0 +1,49 @@
+# This test checks whether the viscoelastic bending beam benchmark
+# works with the visco_plastic material model. In particular,
+# this benchmark is a good test to ensure that a model with
+# compositional fields that affect material properties works.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set End time  = 1e3
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 10
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Densities =  2800,  2800,  2800,  2800,  3300
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5.e-19, 5.e-19, 5.e-19, 5.e-19, 5.e-25
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
+    set Fixed elastic time step     = 1e3
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = maximum composition
+    set Cohesions = 1.e50
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/visco_plastic_vep_brick_extension.prm.bak b/tests/visco_plastic_vep_brick_extension.prm.bak
new file mode 100644
index 00000000000..dfe551c4d14
--- /dev/null
+++ b/tests/visco_plastic_vep_brick_extension.prm.bak
@@ -0,0 +1,63 @@
+# This test checks the viscoelastic_plastic brick extension benchmark,
+# but reduces the resolution and viscosity seed for the purpose of runtime
+# length. The model runs for five time steps, which reveal that in the first
+# three time steps the second nonlinear iteration requires zero linear Stokes
+# solves. This likely reflects that elastic stresses buildup prior to yielding
+# and the solution does not change significantly during this time.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm
+
+set Dimension                              = 2
+set End time                               = 5e3
+set Nonlinear solver tolerance             = 1e-7
+set Max nonlinear iterations               = 4
+set Output directory                       = visco_plastic_vep_brick_extension
+
+subsection Solver parameters
+  subsection Newton solver parameters
+    set Nonlinear Newton solver switch tolerance = 1e-2
+    set Max Newton line search iterations        = 2
+  end
+end
+
+# Model geometry (40x10 km, 2 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 5
+  end
+end
+
+# Change seed size from 800x400 to 4000x2000 meters
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; 0; \
+                              if (y<=2.0e3 && x>=18.0e3 && x<=22.0e3, 1, 0);
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, particles
+
+  subsection Particles
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell  = 2
+  set Maximum particles per cell  = 8
+
+  subsection Generator
+    subsection Reference cell
+      set Number of particles per cell per direction = 2
+    end
+  end
+end
diff --git a/tests/visco_plastic_vep_plate_flexure.prm.bak b/tests/visco_plastic_vep_plate_flexure.prm.bak
new file mode 100644
index 00000000000..eff50b0744c
--- /dev/null
+++ b/tests/visco_plastic_vep_plate_flexure.prm.bak
@@ -0,0 +1,51 @@
+# This test checks whether the viscoelastic finite-length elastic plate
+# flexure benchmark runs successfully with the Visco Plastic material model.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm
+
+set End time                               = 5
+set Output directory                       = visco_plastic_vep_plate_flexure
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 7
+  end
+end
+
+# No global refinement
+subsection Mesh refinement
+  set Initial global refinement          = 0
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5.e-18, 5.e-18, 5.e-18, 5.e-18, 5.e-36, 5.e-36
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0
+    set Elastic shear moduli        = 1.e50, 1.e50, 1.e50, 1.e50, 3.e10, 3.e10
+    set Fixed elastic time step     = 5
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = maximum composition
+    set Cohesions                   = 1.e50
+    set Densities                   = 2700,  2700,  2700,  2700,  2700,  1890
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, material statistics, velocity statistics, topography
+
+  subsection Topography
+    set Output to file           = false
+    set Time between text output = 0
+  end
+end
diff --git a/tests/visco_plastic_vep_simple_shear.prm.bak b/tests/visco_plastic_vep_simple_shear.prm.bak
new file mode 100644
index 00000000000..00184996a46
--- /dev/null
+++ b/tests/visco_plastic_vep_simple_shear.prm.bak
@@ -0,0 +1,7 @@
+# This test checks the viscoelastic_plastic simple shear benchmark,
+# but reduces the end time for the purpose of runtime.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm
+
+set Dimension                              = 2
+set End time                               = 0.05
diff --git a/tests/visco_plastic_vep_stress_build-up.prm.bak b/tests/visco_plastic_vep_stress_build-up.prm.bak
new file mode 100644
index 00000000000..0091623ef14
--- /dev/null
+++ b/tests/visco_plastic_vep_stress_build-up.prm.bak
@@ -0,0 +1,58 @@
+# This test checks viscoelastic stress buildup with a
+# constant strain rate and an elastic time step equal
+# to the numerical time step. The fixed elastic time
+# step used during the first time step is equal to the
+# numerical time step. Viscoelastic stresses (sigma_xx,
+# sigma_yy, sigma_xy) are tracked with compositional
+# fields. The parameter file is derived from the 2D
+# viscoelastic_stress_build-up benchmark with modifications
+# to the resolution, end time, material properties and
+# postprocessors.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+
+#  Global parameters
+set End time                               = 1e3
+
+# Model geometry (100x100 km, 5 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5e-22
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+    set Viscosity averaging scheme  = harmonic
+    set Densities                   = 2800.
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/visco_plastic_vep_stress_build-up_fixed_elastic_time_step.prm.bak b/tests/visco_plastic_vep_stress_build-up_fixed_elastic_time_step.prm.bak
new file mode 100644
index 00000000000..397d0d20cc5
--- /dev/null
+++ b/tests/visco_plastic_vep_stress_build-up_fixed_elastic_time_step.prm.bak
@@ -0,0 +1,57 @@
+# This test checks viscoelastic stress buildup with a
+# constant strain rate and an elastic time step equal
+# to a user-specified constant elastic time step. This
+# fixed elastic time step is double the numerical time step.
+# Viscoelastic stresses (sigma_xx, sigma_yy, sigma_xy)
+# are tracked with compositional fields. The parameter
+# file is derived from the 2D viscoelastic_stress_build-up
+# benchmark with modifications to the resolution, end time,
+# material properties and postprocessors.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+
+#  Global parameters
+set End time                               = 1e3
+
+# Model geometry (100x100 km, 5 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5e-22
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = true
+    set Fixed elastic time step     = 2e3
+    set Viscosity averaging scheme  = harmonic
+    set Densities                   = 2800.
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/visco_plastic_vep_stress_build-up_stress_averaging.prm.bak b/tests/visco_plastic_vep_stress_build-up_stress_averaging.prm.bak
new file mode 100644
index 00000000000..46bb3f501c3
--- /dev/null
+++ b/tests/visco_plastic_vep_stress_build-up_stress_averaging.prm.bak
@@ -0,0 +1,59 @@
+# This test checks viscoelastic stress buildup with a
+# constant strain rate and an elastic time step equal
+# to a user-specified constant elastic time step. This
+# fixed elastic time step is double the numerical time step.
+# Stress averaging is used to account for the difference
+# between the numerical and elastic time step. Viscoelastic
+# stresses (sigma_xx, sigma_yy, sigma_xy) are tracked
+# with compositional fields. The parameter file is derived
+# from the 2D viscoelastic_stress_build-up benchmark with
+# modifications to the resolution, end time, material
+# properties and postprocessors.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+
+#  Global parameters
+set End time                               = 1e3
+
+# Model geometry (100x100 km, 5 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5e-22
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = true
+    set Fixed elastic time step     = 2e3
+    set Viscosity averaging scheme  = harmonic
+    set Densities                   = 2800.
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/visco_plastic_vep_stress_build-up_yield.prm.bak b/tests/visco_plastic_vep_stress_build-up_yield.prm.bak
new file mode 100644
index 00000000000..69185522072
--- /dev/null
+++ b/tests/visco_plastic_vep_stress_build-up_yield.prm.bak
@@ -0,0 +1,71 @@
+# This test checks viscoelastic stress buildup with a
+# constant strain rate, an elastic time step equal
+# to the numerical time step and a yield stress of 10 MPa.
+# The fixed elastic time step used during the first time
+# step is equal to the numerical time step. Viscoelastic
+# stresses (sigma_xx, sigma_yy, sigma_xy) are tracked with
+# compositional fields. The yield stress of 10 MPa should
+# prevent elastic stresses from accumulating above this
+# value. The parameter file is derived from the 2D
+# viscoelastic_stress_build-up benchmark with modifications
+# to the resolution, end time, material properties and
+# postprocessors. Notably, other tests derived from the same
+# benchmark have a cohesion of 1e6 Pa, run for 1 time step
+# (End time = 1e3), and only do 1 nonlinear iteration. Here,
+# we have adjusted the parameters slightly to illustrate that
+# in some cases the solution may not change at all between nonlinear
+# iterations and as a result no Stokes linear iterations are
+# performed.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 2
+
+#  Global parameters
+set End time                               = 2e3
+
+# Model geometry (100x100 km, 5 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5e-22
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+    set Viscosity averaging scheme  = harmonic
+    set Angles of internal friction = 0.
+    set Cohesions                   = 1.e6
+    set Densities                   = 2800
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/visco_plastic_vep_stress_build-up_yield_particles.prm.bak b/tests/visco_plastic_vep_stress_build-up_yield_particles.prm.bak
new file mode 100644
index 00000000000..7e23790d243
--- /dev/null
+++ b/tests/visco_plastic_vep_stress_build-up_yield_particles.prm.bak
@@ -0,0 +1,92 @@
+# This test checks viscoelastic stress buildup with a
+# constant strain rate, an elastic time step equal
+# to the numerical time step and a yield stress of 10 MPa.
+# The fixed elastic time step used during the first time
+# step is equal to the numerical time step. Viscoelastic
+# stresses (sigma_xx, sigma_yy, sigma_xy) are tracked with
+# active particles. The yield stress of 10 MPa should
+# prevent elastic stresses from accumulating above this
+# value. The parameter file is derived from the 2D
+# viscoelastic_stress_build-up benchmark with modifications
+# to the resolution, end time, material properties and
+# postprocessors. Notably, other tests derived from the same
+# benchmark have a cohesion of 1e6 Pa, run for 1 time step
+# (End time = 1e3), and only do 1 nonlinear iteration. Here,
+# we have adjusted the parameters slightly to illustrate that
+# in some cases the solution may not change at all between nonlinear
+# iterations and as a result no Stokes linear iterations are
+# performed.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Nonlinear solver tolerance             = 1e-5
+set Max nonlinear iterations               = 2
+set Output directory                       = visco_plastic_vep_stress_build-up_yield_particles
+
+#  Global parameters
+set End time                               = 2e3
+
+# Model geometry (100x100 km, 5 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Track compositional fields with active particles
+subsection Compositional fields
+  set Compositional field methods = particles, particles, particles
+  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5e-22
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+    set Viscosity averaging scheme  = harmonic
+    set Angles of internal friction = 0.
+    set Cohesions                   = 1.e6
+    set Densities                   = 2800
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output    = 1e9
+    set Data output format          = vtu
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell  = 25
+  set Maximum particles per cell  = 35
+  set Load balancing strategy     = remove and add particles
+  set List of particle properties = initial composition, elastic stress
+  set Interpolation scheme        = bilinear least squares
+  set Update ghost particles      = true
+  set Particle generator name     = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 12e3
+    end
+  end
+end
diff --git a/tests/visco_plastic_viscous_strain_weakening.prm.bak b/tests/visco_plastic_viscous_strain_weakening.prm.bak
new file mode 100644
index 00000000000..d3b52dffd09
--- /dev/null
+++ b/tests/visco_plastic_viscous_strain_weakening.prm.bak
@@ -0,0 +1,130 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 10
+set Output directory                       = visco_plastic_viscous_strain_weakening
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = viscous_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=40e3&x<=60e3&y>=40e3&y<=50.e3,0.2,0);
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 6.e6
+    set Strain weakening mechanism = viscous weakening with viscous strain only
+    set Start prefactor strain weakening intervals = 0.
+    set End prefactor strain weakening intervals = 1.0
+    set Prefactor strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/visco_plastic_yield.prm.bak b/tests/visco_plastic_yield.prm.bak
new file mode 100644
index 00000000000..d602efb79b0
--- /dev/null
+++ b/tests/visco_plastic_yield.prm.bak
@@ -0,0 +1,99 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, material statistics
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_yield_max.prm.bak b/tests/visco_plastic_yield_max.prm.bak
new file mode 100644
index 00000000000..cd187a5e5b1
--- /dev/null
+++ b/tests/visco_plastic_yield_max.prm.bak
@@ -0,0 +1,118 @@
+# This test checks that the maximum yield stress is causing the
+# effective viscosity to change by the correct amount. The velocity
+# boundary conditions create a constant applied strain rate 3.1709e-16 1/s
+# (0.0005 m/y / 50e3 m / sec2yr). The drucker prager parameters create
+# a constant yield stress of 1e6 Pa, which would give a viscosity of
+# 1e6/2/3.17e-16 = 1.57e21 Pa s (this is the visco_plastic_yield test).
+# So, here we set maximum yield strength = 0.5e6 Pa, and so the effective
+# viscosity becomes 0.5e6/2/3.17e-16 = 7.88e20. The gnuplot output includes
+# the strain rate value and the viscosity.
+#
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = max_yield
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Maximum yield stress = 5.0e5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics, mass flux statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = strain rate, viscosity
+    set Output format                 = gnuplot
+    set Time between graphical output = 0.25e6
+    set Number of grouped files       = 0
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_yield_noninitial-plastic-strain_particles.prm.bak b/tests/visco_plastic_yield_noninitial-plastic-strain_particles.prm.bak
new file mode 100644
index 00000000000..b4d660ab000
--- /dev/null
+++ b/tests/visco_plastic_yield_noninitial-plastic-strain_particles.prm.bak
@@ -0,0 +1,59 @@
+# A test to check whether noninitial plastic strain is correctly tracked
+# on particles, which are also used to track plastic and viscous strain.
+# The boundary conditions (see tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm)
+# produce an incremental strain of 1e-5 per time step and material that is always yielding.
+# The initial strain values are as follows - plastic strain: 1e-5, noninitial plastic strain: 0,
+# viscous strain: 0. As a result, the viscous strain should always have a value of 0 throughout
+# the model run. Respectively, after 3 time steps the plastic and noninitial plastic values
+# should be 4e-5 and 3e-5.
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm
+
+set End time           = 3000
+set Maximum time step  = 1000
+set Output directory   = visco_plastic_yield_noninitial-plastic-strain_particles
+
+# Particles mapped to the Compositional fields used to track plastic, noninitial plastic, and viscous strain.
+subsection Compositional fields
+  set Number of fields            = 3
+  set Names of fields             = plastic_strain, noninitial_plastic_strain, viscous_strain
+  set Compositional field methods = particles, particles, particles
+  set Mapped particle properties  = plastic_strain:plastic_strain, noninitial_plastic_strain:noninitial_plastic_strain, viscous_strain:viscous_strain
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 1.e-5; 0; 0;
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = composition statistics, mass flux statistics, particles, particle count statistics, velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables       = named additional outputs, strain rate, viscosity
+    set Time between graphical output  = 0
+    set Output format                  = gnuplot
+  end
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = viscoplastic strain invariants
+  set Particle generator name = random uniform
+  set Interpolation scheme = nearest neighbor
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1e5
+    end
+  end
+end
diff --git a/tests/visco_plastic_yield_plastic_damper.prm.bak b/tests/visco_plastic_yield_plastic_damper.prm.bak
new file mode 100644
index 00000000000..fed5bf581c0
--- /dev/null
+++ b/tests/visco_plastic_yield_plastic_damper.prm.bak
@@ -0,0 +1,26 @@
+# This test modifies the benchmark gerya_2019_vp.prm
+# to include a viscous damper in the plastic viscosity calculation.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm
+
+set Max nonlinear iterations = 1
+set Output directory = visco_plastic_yield_plastic_damper
+
+subsection Mesh refinement
+  set Initial global refinement = 2
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Allow negative pressures in plasticity = true
+    set Use plastic damper = true
+    set Plastic damper viscosity = 1e19
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, material statistics, velocity statistics
+  set Run postprocessors on nonlinear iterations = false
+end
diff --git a/tests/visco_plastic_yield_plastic_strain_weakening.prm.bak b/tests/visco_plastic_yield_plastic_strain_weakening.prm.bak
new file mode 100644
index 00000000000..1fe8c29a51f
--- /dev/null
+++ b/tests/visco_plastic_yield_plastic_strain_weakening.prm.bak
@@ -0,0 +1,132 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield_plastic_strain_weakening
+set Timing output frequency                = 1
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = plastic_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = plastic weakening with plastic strain only
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/visco_plastic_yield_plastic_strain_weakening_particles.prm.bak b/tests/visco_plastic_yield_plastic_strain_weakening_particles.prm.bak
new file mode 100644
index 00000000000..a2479627110
--- /dev/null
+++ b/tests/visco_plastic_yield_plastic_strain_weakening_particles.prm.bak
@@ -0,0 +1,31 @@
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_strain_weakening.prm
+
+
+# Particles mapped to the Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Compositional field methods = particles
+  set Mapped particle properties =  plastic_strain:plastic_strain
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles
+
+  subsection Particles
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = viscoplastic strain invariants
+  set Particle generator name = random uniform
+  set Maximum particles per cell = 500
+  set Interpolation scheme = nearest neighbor
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1e5
+    end
+  end
+end
diff --git a/tests/visco_plastic_yield_plastic_viscous_strain_healing.prm.bak b/tests/visco_plastic_yield_plastic_viscous_strain_healing.prm.bak
new file mode 100644
index 00000000000..a7bd23fad4d
--- /dev/null
+++ b/tests/visco_plastic_yield_plastic_viscous_strain_healing.prm.bak
@@ -0,0 +1,148 @@
+# This test runs on 1 mpi process for 8 timesteps
+# healed_strain = strain_healing_temperature_dependent_recovery_rate *
+# exp(-strain_healing_temperature_dependent_prefactor * 0.5 * (1.0 - temperature/reference_temperature)) * this_timestep
+# The returned strain values due to strain healing should be:
+# plastic_strain: max, 4.435e-04; min, -3.198e-05
+# viscous_strain: max, 3.187e-01: min, -2.083e-01
+# Analytical value of total healed strain = 4.999e-08
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 5e7
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield_plastic_viscous_strain_healing
+set Timing output frequency                = 1
+set Adiabatic surface temperature = 273.
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = plastic_strain, viscous_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0); if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.4,0)
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = plastic weakening with plastic strain and viscous weakening with viscous strain
+    set Start prefactor strain weakening intervals = 0.
+    set End prefactor strain weakening intervals = 1.0
+    set Prefactor strain weakening factors = 0.5
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+    set Strain healing mechanism = temperature dependent
+    set Strain healing temperature dependent recovery rate = 1.e-15
+    set Strain healing temperature dependent prefactor = 15.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+    set Time between graphical output = 5e7
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm.bak b/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm.bak
new file mode 100644
index 00000000000..113cc289512
--- /dev/null
+++ b/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm.bak
@@ -0,0 +1,135 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield_plastic_viscous_strain_weakening
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = plastic_strain, viscous_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0); if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.4,0)
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = plastic weakening with plastic strain and viscous weakening with viscous strain
+    set Start prefactor strain weakening intervals = 0.
+    set End prefactor strain weakening intervals = 1.0
+    set Prefactor strain weakening factors = 0.5
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_yield_plastic_viscous_strain_weakening_particles.prm.bak b/tests/visco_plastic_yield_plastic_viscous_strain_weakening_particles.prm.bak
new file mode 100644
index 00000000000..b837029ab9f
--- /dev/null
+++ b/tests/visco_plastic_yield_plastic_viscous_strain_weakening_particles.prm.bak
@@ -0,0 +1,31 @@
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm
+
+
+# Particles mapped to the Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Compositional field methods = particles, particles
+  set Mapped particle properties =  plastic_strain:plastic_strain, viscous_strain:viscous_strain
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = viscoplastic strain invariants
+  set Particle generator name = random uniform
+  set Interpolation scheme = nearest neighbor
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1e5
+    end
+  end
+end
diff --git a/tests/visco_plastic_yield_strain_weakening.prm.bak b/tests/visco_plastic_yield_strain_weakening.prm.bak
new file mode 100644
index 00000000000..fa50b6a4c3b
--- /dev/null
+++ b/tests/visco_plastic_yield_strain_weakening.prm.bak
@@ -0,0 +1,132 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield_strain_weakening
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = total_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = plastic weakening with total strain only
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_yield_strain_weakening_compositions.prm.bak b/tests/visco_plastic_yield_strain_weakening_compositions.prm.bak
new file mode 100644
index 00000000000..5b434128f7a
--- /dev/null
+++ b/tests/visco_plastic_yield_strain_weakening_compositions.prm.bak
@@ -0,0 +1,127 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield_strain_weakening_composition
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = total_strain, weak_layer
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);if (y>50e3,1,0)
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Densities = 3300,10000,2700
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-24
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6,1e1,1e7
+    set Strain weakening mechanism = plastic weakening with total strain only
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = strain rate, named additional outputs, material properties
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/visco_plastic_yield_strain_weakening_defect_corr_stokes.prm.bak b/tests/visco_plastic_yield_strain_weakening_defect_corr_stokes.prm.bak
new file mode 100644
index 00000000000..9de62a1e28e
--- /dev/null
+++ b/tests/visco_plastic_yield_strain_weakening_defect_corr_stokes.prm.bak
@@ -0,0 +1,4 @@
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_strain_weakening.prm
+
+set Nonlinear solver scheme                = single Advection, iterated defect correction Stokes
+set Output directory                       = visco_plastic_yield_strain_weakening_defect_corr_stokes
diff --git a/tests/visco_plastic_yield_strain_weakening_full_strain_tensor.prm.bak b/tests/visco_plastic_yield_strain_weakening_full_strain_tensor.prm.bak
new file mode 100644
index 00000000000..b86a2f1fcfd
--- /dev/null
+++ b/tests/visco_plastic_yield_strain_weakening_full_strain_tensor.prm.bak
@@ -0,0 +1,134 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1e2
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield_strain_weakening_full_strain_tensor
+set Timing output frequency                = 1
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields = s11, s12, s21, s22
+end
+
+# The compositional fields have an initial value 0 or 0.5
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.5; 0; 0; 0.5;
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material and strain fields)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = finite strain tensor
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Start prefactor strain weakening intervals = 0.
+    set End prefactor strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+    set Prefactor strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_yield_strain_weakening_full_strain_tensor_3d.prm.bak b/tests/visco_plastic_yield_strain_weakening_full_strain_tensor_3d.prm.bak
new file mode 100644
index 00000000000..ff6984c1de7
--- /dev/null
+++ b/tests/visco_plastic_yield_strain_weakening_full_strain_tensor_3d.prm.bak
@@ -0,0 +1,130 @@
+# Global parameters
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 1e2
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield_strain_weakening_full_strain_tensor_3d
+set Timing output frequency                = 1
+
+# Model geometry (100x10x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 1
+    set Z repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 10e3
+    set Z extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right, front, back
+  set List of model names = initial temperature
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = front, back
+  set Prescribed velocity boundary indicators = bottom z: function, top z: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); 0; if (z<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain
+subsection Compositional fields
+  set Number of fields = 9
+  set Names of fields = s11, s12, s13, s21, s22, s23, s31, s32, s33
+end
+
+# The compositional fields have an initial value 0 or 0.5
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function expression = 0.5; 0; 0; 0; 0.5; 0; 0; 0; 0.5
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material and strain fields)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = finite strain tensor
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Start prefactor strain weakening intervals = 0.
+    set End prefactor strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+    set Prefactor strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_yield_strain_weakening_iterated_advection.prm.bak b/tests/visco_plastic_yield_strain_weakening_iterated_advection.prm.bak
new file mode 100644
index 00000000000..520bacbe8da
--- /dev/null
+++ b/tests/visco_plastic_yield_strain_weakening_iterated_advection.prm.bak
@@ -0,0 +1,44 @@
+# A test to check whether the calculated finite strain invariant
+# (total strain in this case) does not unrealistically accumulate during
+# nonlinear iterations when an iterative Advection scheme is used. We
+# check this by running the postprocessors on every nonlinear iteration.
+# The test output from the composition statistics postprocessor,
+# which prints out min/max/mass of each compositional field, confirms
+# that the total strain does not incorrectly accumulate during successive
+# nonlinear iterations.
+# The test has been slightly modified from the test linked below.
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_strain_weakening.prm
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 2e5
+set Maximum time step                      = 1e5
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = iterated Advection and Stokes
+
+# Set a very strict nonlinear tolerance such that we perform more than
+# one nonlinear iteration after the first time step.
+set Nonlinear solver tolerance             = 1e-14
+
+# Cap the number of nonlinear iterations at 5, as we
+# only need to a few iterations to see how the strain
+# field evolves within each timestep.
+set Max nonlinear iterations               = 5
+set Output directory                       = visco_plastic_yield_strain_weakening_iterated_advection
+
+# Start with no initial (total) strain such that the
+# accumulated strain should be uniform throughout
+# the domain over the course of this model run.
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, velocity statistics
+  set Run postprocessors on nonlinear iterations = true
+end
diff --git a/tests/visco_plastic_yield_strain_weakening_no-advect_no_stokes.prm.bak b/tests/visco_plastic_yield_strain_weakening_no-advect_no_stokes.prm.bak
new file mode 100644
index 00000000000..817de85ec23
--- /dev/null
+++ b/tests/visco_plastic_yield_strain_weakening_no-advect_no_stokes.prm.bak
@@ -0,0 +1,7 @@
+# A test checking that the 'no Advection, no Stokes' nonlinear solver
+# scheme can be used in combination with the strain weakening rheology module
+
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_strain_weakening.prm
+
+set Nonlinear solver scheme                = no Advection, no Stokes
+set Output directory                       = visco_plastic_yield_strain_weakening_no-advect_no_stokes
diff --git a/tests/visco_plastic_yield_strain_weakening_particles.prm.bak b/tests/visco_plastic_yield_strain_weakening_particles.prm.bak
new file mode 100644
index 00000000000..f711b92cede
--- /dev/null
+++ b/tests/visco_plastic_yield_strain_weakening_particles.prm.bak
@@ -0,0 +1,31 @@
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_strain_weakening.prm
+
+
+# Particles mapped to the Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Compositional field methods = particles
+  set Mapped particle properties =  total_strain:total_strain
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = viscoplastic strain invariants
+  set Particle generator name = random uniform
+  set Interpolation scheme = nearest neighbor
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1e5
+    end
+  end
+end
diff --git a/tests/visco_plastic_yield_temperature_activated_viscous_strain_weakening.prm.bak b/tests/visco_plastic_yield_temperature_activated_viscous_strain_weakening.prm.bak
new file mode 100644
index 00000000000..8b3b6344cf6
--- /dev/null
+++ b/tests/visco_plastic_yield_temperature_activated_viscous_strain_weakening.prm.bak
@@ -0,0 +1,46 @@
+#this tests the temperature dependence of the viscous strain weakening factor
+
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_viscous_strain_weakening.prm
+
+set Output directory = visco_plastic_yield_temperature_activated_viscous_strain_weakening
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=25.e3&x<=75.e3&y>=25.e3&y<=75.e3,0.5,0);
+  end
+end
+
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Use temperature activated strain softening  = true
+    set Lower temperature for onset of strain weakening = 800
+    set Lower temperature for maximum strain weakening  = 900
+    set Upper temperature for maximum strain weakening  = 1000
+    set Upper temperature for onset of strain weakening = 1100
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function constants = h=100e3,ts1=800,ts2=1200
+    set Function expression =  ts1 + ((ts2-ts1))*(h-y)/h;
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1200
+    set Top temperature    =  800
+  end
+end
diff --git a/tests/visco_plastic_yield_total_strain_healing.prm.bak b/tests/visco_plastic_yield_total_strain_healing.prm.bak
new file mode 100644
index 00000000000..c057fadf507
--- /dev/null
+++ b/tests/visco_plastic_yield_total_strain_healing.prm.bak
@@ -0,0 +1,147 @@
+# This test runs on 1 mpi process and computes 8 timesteps
+# healed_strain = strain_healing_temperature_dependent_recovery_rate *
+# exp(-strain_healing_temperature_dependent_prefactor * 0.5 * (1.0 - temperature/reference_temperature)) * this_timestep
+# The returned strain value due to strain healing in the last timestep should be:
+# total_strain: max, 4.435e-04; min, -3.198e-05
+# Analytical value of total healed strain = 4.999e-08
+
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 5e7
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield_total_strain_healing
+set Timing output frequency                = 1
+set Adiabatic surface temperature = 273.
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = total_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = total strain
+    set Start prefactor strain weakening intervals = 0.
+    set End prefactor strain weakening intervals = 1.0
+    set Prefactor strain weakening factors = 0.5
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+    set Strain healing mechanism = temperature dependent
+    set Strain healing temperature dependent recovery rate = 1.e-15
+    set Strain healing temperature dependent prefactor = 15.
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+    set Time between graphical output = 5e7
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/visco_plastic_yield_viscous_strain_weakening.prm.bak b/tests/visco_plastic_yield_viscous_strain_weakening.prm.bak
new file mode 100644
index 00000000000..399d6b9313e
--- /dev/null
+++ b/tests/visco_plastic_yield_viscous_strain_weakening.prm.bak
@@ -0,0 +1,131 @@
+# Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = true
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Max nonlinear iterations               = 1
+set Output directory                       = visco_plastic_yield_viscous_strain_weakening
+set Timing output frequency                = 1
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 0
+  end
+end
+
+# Model geometry (100x100 km, 10 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 10
+    set Y repetitions = 10
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Boundary classifications (fixed T boundaries, prescribed velocity)
+
+# Temperature boundary and initial conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 273
+    set Left temperature   = 273
+    set Right temperature  = 273
+    set Top temperature    = 273
+  end
+end
+
+# Velocity on boundaries characterized by functions
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = m=0.0005, year=1
+    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 273
+  end
+end
+
+# Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = viscous_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = viscous weakening with viscous strain only
+    set Start prefactor strain weakening intervals = 0.
+    set End prefactor strain weakening intervals = 1.0
+    set Prefactor strain weakening factors = 0.5
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Output format            = gnuplot
+  end
+end
diff --git a/tests/visco_plastic_yield_viscous_strain_weakening_particles.prm.bak b/tests/visco_plastic_yield_viscous_strain_weakening_particles.prm.bak
new file mode 100644
index 00000000000..ceef25a2d34
--- /dev/null
+++ b/tests/visco_plastic_yield_viscous_strain_weakening_particles.prm.bak
@@ -0,0 +1,31 @@
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_viscous_strain_weakening.prm
+
+
+# Particles mapped to the Compositional fields used to track finite strain invariant
+subsection Compositional fields
+  set Compositional field methods = particles
+  set Mapped particle properties =  viscous_strain:viscous_strain
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles
+
+  subsection Particles
+    set Time between data output = 0
+    set Data output format = none
+  end
+end
+
+subsection Particles
+  set List of particle properties = viscoplastic strain invariants
+  set Particle generator name = random uniform
+  set Interpolation scheme = nearest neighbor
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 1e5
+    end
+  end
+end
diff --git a/tests/viscoelastic_bending_beam.prm.bak b/tests/viscoelastic_bending_beam.prm.bak
new file mode 100644
index 00000000000..ce81b7b0196
--- /dev/null
+++ b/tests/viscoelastic_bending_beam.prm.bak
@@ -0,0 +1,51 @@
+# This test checks whether the viscoelastic bending beam benchmark
+# run successfully. In particular, this benchmark is a good test to
+# ensure that a model with compositional fields that affect material
+# properties works.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set End time  = 1e3
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 10
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, beam
+  set Types of fields  = stress, stress, stress, chemical composition
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities            =  2800,  3300
+    set Viscosities          = 1.e18, 1.e24
+    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
+    set Fixed elastic time step     = 1e3
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = maximum composition
+  end
+end
diff --git a/tests/viscoelastic_bending_beam_averaging.prm.bak b/tests/viscoelastic_bending_beam_averaging.prm.bak
new file mode 100644
index 00000000000..4e6683fa2fc
--- /dev/null
+++ b/tests/viscoelastic_bending_beam_averaging.prm.bak
@@ -0,0 +1,38 @@
+# This test checks whether the viscoelastic bending beam benchmark
+# runs successfully. In particular, this benchmark is a good test to
+# ensure that a model with compositional fields that affect material
+# properties works, and that material averaging works in combination
+# with elasticity.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set End time  = 1e3
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 10
+  end
+end
+
+# Use material averaging. The only options that can be used
+# with elasticity, aside from 'none', are 'harmonic average
+# only viscosity' and 'project to Q1 only viscosity'.
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/viscoelastic_bending_beam_gmg.prm.bak b/tests/viscoelastic_bending_beam_gmg.prm.bak
new file mode 100644
index 00000000000..802565674c3
--- /dev/null
+++ b/tests/viscoelastic_bending_beam_gmg.prm.bak
@@ -0,0 +1,47 @@
+# This test checks whether the viscoelastic bending beam benchmark
+# runs successfully. In particular, this benchmark is a good test to
+# ensure that a model with compositional fields that affect material
+# properties works. This test is identical to the test
+# tests/viscoelastic_bending_beam.prm, except that the GMG Stokes solver
+# and material averaging (required for GMG) is used here. Significantly,
+# the use of material averaging will produce deviations between the
+# results of the two tests, as the calculated and stresses are
+# influenced by averaging across the material interfaces.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set End time          = 1e3
+set Output directory  = viscoelastic_bending_beam_gmg
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 10
+  end
+end
+
+# Use material averaging (required for GMG Stokes solver)
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/viscoelastic_bending_beam_particles.prm.bak b/tests/viscoelastic_bending_beam_particles.prm.bak
new file mode 100644
index 00000000000..5a96946d2f5
--- /dev/null
+++ b/tests/viscoelastic_bending_beam_particles.prm.bak
@@ -0,0 +1,53 @@
+# This test checks whether the viscoelastic bending beam benchmark
+# run successfully. In particular, this benchmark is a good test to
+# ensure that a model using active particles to track both viscoelastic
+# stresses and lithologies, which affect material properties, works.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set End time         = 2e3
+set Output directory = viscoelastic_bending_beam_particles
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 10
+  end
+end
+
+# Compositional field names and methods
+subsection Compositional fields
+  set Number of fields = 4
+  set Compositional field methods =           particles,           particles,           particles,         particles
+  set Names of fields             =           ve_stress_xx,        ve_stress_yy,        ve_stress_xy,      beam
+  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy, beam:initial beam
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output    = 1e9
+    set Data output format          = vtu
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell  = 25
+  set Maximum particles per cell  = 35
+  set Load balancing strategy     = remove and add particles
+  set List of particle properties = initial composition, elastic stress
+  set Interpolation scheme        = bilinear least squares
+  set Update ghost particles      = true
+  set Particle generator name     = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 4.5e3
+    end
+  end
+end
diff --git a/tests/viscoelastic_bending_beam_principal_stress.prm.bak b/tests/viscoelastic_bending_beam_principal_stress.prm.bak
new file mode 100644
index 00000000000..bebc628441c
--- /dev/null
+++ b/tests/viscoelastic_bending_beam_principal_stress.prm.bak
@@ -0,0 +1,34 @@
+# This test checks whether the viscoelastic bending beam benchmark
+# runs successfully. This test extends viscoelastic_bending_beam by
+# also outputting the principal stresses including the elastic stresses.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
+
+set End time  = 1e3
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 10
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average, visualization
+
+  subsection Visualization
+    set List of output variables = principal stress
+    set Output format = gnuplot
+  end
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/viscoelastic_fixed_elastic_time_step.prm.bak b/tests/viscoelastic_fixed_elastic_time_step.prm.bak
new file mode 100644
index 00000000000..03c9a68deae
--- /dev/null
+++ b/tests/viscoelastic_fixed_elastic_time_step.prm.bak
@@ -0,0 +1,54 @@
+# This test checks viscoelastic stress buildup with a
+# constant strain rate and an elastic time step equal
+# to a user-specified constant elastic time step. This
+# fixed elastic time step is double the numerical time step.
+# Viscoelastic stresses (sigma_xx, sigma_yy, sigma_xy)
+# are tracked with compositional fields. The parameter
+# file is derived from the 2D viscoelastic_stress_build-up
+# benchmark with modifications to the resolution, end time,
+# material properties and postprocessors.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+
+#  Global parameters
+set End time                               = 1e3
+set Output directory                       = viscoelastic_fixed_elastic_time_step
+
+# Model geometry (100x100 km, 5 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 2800
+    set Viscosities                 = 1.e21
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = true
+    set Fixed elastic time step     = 2e3
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/viscoelastic_numerical_elastic_time_step.prm.bak b/tests/viscoelastic_numerical_elastic_time_step.prm.bak
new file mode 100644
index 00000000000..85b94327777
--- /dev/null
+++ b/tests/viscoelastic_numerical_elastic_time_step.prm.bak
@@ -0,0 +1,55 @@
+# This test checks viscoelastic stress buildup with a
+# constant strain rate and an elastic time step equal
+# to the numerical time step. The fixed elastic time
+# step used during the first time step is equal to the
+# numerical time step. Viscoelastic stresses (sigma_xx,
+# sigma_yy, sigma_xy) are tracked with compositional
+# fields. The parameter file is derived from the 2D
+# viscoelastic_stress_build-up benchmark with modifications
+# to the resolution, end time, material properties and
+# postprocessors.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+
+#  Global parameters
+set End time                               = 1e3
+set Output directory                       = viscoelastic_numerical_elastic_time_step
+
+# Model geometry (100x100 km, 5 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 2800
+    set Viscosities                 = 1.e21
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/viscoelastic_numerical_elastic_time_step_particles.prm.bak b/tests/viscoelastic_numerical_elastic_time_step_particles.prm.bak
new file mode 100644
index 00000000000..468cb571164
--- /dev/null
+++ b/tests/viscoelastic_numerical_elastic_time_step_particles.prm.bak
@@ -0,0 +1,75 @@
+# This test checks viscoelastic stress buildup with a
+# constant strain rate and an elastic time step equal
+# to the numerical time step. The fixed elastic time
+# step used during the first time step is equal to the
+# numerical time step. Viscoelastic stresses (sigma_xx,
+# sigma_yy, sigma_xy) are tracked with active particles.
+# The parameter file is derived from the 2D
+# viscoelastic_stress_build-up benchmark with modifications
+# to the compositional field method, resolution, end time, material properties and
+# postprocessors.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+
+#  Global parameters
+set End time                               = 2e3
+set Output directory                       = viscoelastic_numerical_elastic_time_step_particles
+
+# Model geometry (100x100 km, 5 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Track compositional fields with active particles
+subsection Compositional fields
+  set Compositional field methods = particles, particles, particles
+  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 2800
+    set Viscosities                 = 1.e21
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, composition statistics, particles
+
+  subsection Particles
+    set Time between data output    = 1e9
+    set Data output format          = vtu
+  end
+end
+
+subsection Particles
+  set Minimum particles per cell  = 25
+  set Maximum particles per cell  = 35
+  set Load balancing strategy     = remove and add particles
+  set List of particle properties = initial composition, elastic stress
+  set Interpolation scheme        = bilinear least squares
+  set Update ghost particles      = true
+  set Particle generator name     = random uniform
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 12e3
+    end
+  end
+end
diff --git a/tests/viscoelastic_plate_flexure.prm.bak b/tests/viscoelastic_plate_flexure.prm.bak
new file mode 100644
index 00000000000..9ec4375b878
--- /dev/null
+++ b/tests/viscoelastic_plate_flexure.prm.bak
@@ -0,0 +1,32 @@
+# This test checks whether the viscoelastic finite-length elastic plate
+# flexure benchmark runs successfully.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm
+
+set End time                               = 5
+set Output directory                       = viscoelastic_plate_flexure
+
+# Significantly reduce resolution
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 7
+  end
+end
+
+# No global refinement
+subsection Mesh refinement
+  set Initial global refinement          = 0
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = basic statistics, material statistics, velocity statistics, topography
+
+  subsection Topography
+    set Output to file           = false
+    set Time between text output = 0
+  end
+end
diff --git a/tests/viscoelastic_sheared_torsion.prm.bak b/tests/viscoelastic_sheared_torsion.prm.bak
new file mode 100644
index 00000000000..f6e5cadcf5c
--- /dev/null
+++ b/tests/viscoelastic_sheared_torsion.prm.bak
@@ -0,0 +1,9 @@
+# This is a test for the viscoelastic sheared torsion benchmark defined
+# in benchmarks/viscoelastic_sheared_torsion.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm
+
+
+# Global parameters
+set Dimension                                  = 3
+set End time                                   = 0.02
diff --git a/tests/viscoelastic_stress_averaging.prm.bak b/tests/viscoelastic_stress_averaging.prm.bak
new file mode 100644
index 00000000000..8a8f1005e7f
--- /dev/null
+++ b/tests/viscoelastic_stress_averaging.prm.bak
@@ -0,0 +1,56 @@
+# This test checks viscoelastic stress buildup with a
+# constant strain rate and an elastic time step equal
+# to a user-specified constant elastic time step. This
+# fixed elastic time step is double the numerical time step.
+# Stress averaging is used to account for the difference
+# between the numerical and elastic time step. Viscoelastic
+# stresses (sigma_xx, sigma_yy, sigma_xy) are tracked
+# with compositional fields. The parameter file is derived
+# from the 2D viscoelastic_stress_build-up benchmark with
+# modifications to the resolution, end time, material
+# properties and postprocessors.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+
+#  Global parameters
+set End time                               = 1e3
+set Output directory                       = viscoelastic_stress_averaging
+
+# Model geometry (100x100 km, 5 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 20
+    set Y repetitions = 20
+    set X extent      = 100e3
+    set Y extent      = 100e3
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 2800
+    set Viscosities                 = 1.e21
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = true
+    set Fixed elastic time step     = 2e3
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, depth average
+
+  subsection Depth average
+    set Time between graphical output = 0
+    set Number of zones = 5
+    set List of output variables = composition
+    set Output format = txt
+  end
+end
diff --git a/tests/viscoelastic_stress_build-up.prm.bak b/tests/viscoelastic_stress_build-up.prm.bak
new file mode 100644
index 00000000000..07b892908cd
--- /dev/null
+++ b/tests/viscoelastic_stress_build-up.prm.bak
@@ -0,0 +1,83 @@
+# This test is a prestressed and smaller version of the
+# viscoelastic_stress_build-up benchmark.
+# The benchmark has a 2D analytical solution for the build-up
+# of stress in an initially unstressed viscoelastic medium subject to a
+# constant strain-rate. This benchmark is described in "Robust
+# characteristics method for modelling multiphase visco-elasto-plastic
+# thermo-mechanical problems" by Gerya and Yuen, 2007, Phys. Earth. Planet.
+# Inter., v. 163, p. 83-105. Full details of the benchmark are located in
+# section 3.1 and figure 3 of this manuscript.
+#
+# The analytical solution for viscoelastic stress build-up in
+# an incompressible medium with a constant strain-rate is:
+#   sigma_ij = 2 * edot_ii * eta * (1 - e^(-mu*t/eta)),
+# where sigma_ij is the elastic deviatoric stress tensor, edot_ij is
+# the deviatoric strain-rate, eta is the background viscosity, mu is the
+# shear modulus and t is time.
+#
+# Following the conditions described in section 3.1 and figure 3 from
+# Gerya and Yuen (2007), a 100x100 km body is subject to a constant
+# strain-rate of 1.e-14 s^-1 in both the horizontal and vertical directions.
+# Constant deformation is driven by inflow and outflow, respectively,
+# on the right and bottom walls. The top and left walls are free-slip.
+# The material has a viscosity of 1e22 Pa s and a shear modulus of 1e10 Pa.
+# With these values, the analytical solution predicts a horizontal
+# or vertical viscoelastic stress magnitude of ~ 200 MPa after 250 Kyr
+# of deformation. Significantly, the effective "viscoelastic" viscosity
+# is enforced to be constant through time by using a constant time step.
+# This is achieved by setting a maximum time step (1000 years) much lower
+# than the time step size given by the CFL number of 0.5.
+#
+# This result can be observed by viewing the compositional field values
+# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
+# of the viscoselastic stress tensor. Significantly, the composition is not
+# fixed on any boundary in order to prevent the formation of boundary artifacts
+# in the compositional fields tracking viscoelastic stresses.
+#
+# For the current test, we prescribe initial values to the compositional fields
+# that track the viscoelastic stresses that are equal to the
+# analytical solution for the viscoelastic stress after 250 Kyr.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+
+#  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1000
+set Use years in output instead of seconds = true
+set Output directory                       = output
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, left
+  set Prescribed velocity boundary indicators = bottom y:function, right x:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = Lx = 100000, yinsec = 31557600, eps_ii = 1e-14
+    set Function expression = if (x>50e3, Lx*eps_ii*yinsec, 0.); if (y<50e3, Lx*eps_ii*yinsec, 0.);
+  end
+end
+
+# Spatial domain of different compositional fields:
+# ve_stress_xx, ve_stress_yy, ve_stress_xy
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = eta = 1e22, mu = 1e10, eps = 1e-14, t = 250000, yinsec = 31557600
+    set Function expression = 2.*eta*eps*(1.-exp(-mu*t*yinsec/eta)); \
+                              -2.*eta*eps*(1.-exp(-mu*t*yinsec/eta)); \
+                              0
+  end
+end
+
+subsection Postprocess
+  subsection Visualization
+    set Time between graphical output = 1e3
+    set List of output variables = stress, shear stress, stress second invariant
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/viscoelastic_stress_build-up_gmg.prm.bak b/tests/viscoelastic_stress_build-up_gmg.prm.bak
new file mode 100644
index 00000000000..9c1f3235417
--- /dev/null
+++ b/tests/viscoelastic_stress_build-up_gmg.prm.bak
@@ -0,0 +1,98 @@
+# This test is a prestressed and smaller version of the
+# viscoelastic_stress_build-up benchmark. The only differences
+# between this test case and tests/viscoelastic_stress_build-up.prm
+# are the use of the GMG solver and material averaging (required for
+# GMG) in this test.  Otherwise, all of the parameters are identical
+# between the two tests.
+#
+# The benchmark has a 2D analytical solution for the build-up
+# of stress in an initially unstressed viscoelastic medium subject to a
+# constant strain-rate. This benchmark is described in "Robust
+# characteristics method for modelling multiphase visco-elasto-plastic
+# thermo-mechanical problems" by Gerya and Yuen, 2007, Phys. Earth. Planet.
+# Inter., v. 163, p. 83-105. Full details of the benchmark are located in
+# section 3.1 and figure 3 of this manuscript.
+#
+# The analytical solution for viscoelastic stress build-up in
+# an incompressible medium with a constant strain-rate is:
+#   simga_ij = 2 * edot_ii * eta * (1 - e^(-mu*t/eta)),
+# where sigma_ij is the elastic deviatoric stress tensor, edot_ij is
+# the deviatoric strain-rate, eta is the background viscosity, mu is the
+# shear modulus and t is time.
+#
+# Following the conditions described in section 3.1 and figure 3 from
+# Gerya and Yuen (2007), a 100x100 km body is subject to a constant
+# strain-rate of 1.e-14 s^-1 in both the horizontal and vertical directions.
+# Constant deformation is driven by inflow and outflow, respectively,
+# on the right and bottom walls. The top and left walls are free-slip.
+# The material has a viscosity of 1e22 Pa s and a shear modulus of 1e10 Pa.
+# With these values, the analytical solution predicts a horizontal
+# or vertical viscoelastic stress magnitude of ~ 200 MPa after 250 Kyr
+# of deformation. Significantly, the effective "viscoelastic" viscosity
+# is enforced to be constant through time by using a constant time step.
+# This is achieved by setting a maximum time step (1000 years) much lower
+# than the time step size given by the CFL number of 0.5.
+#
+# This result can be observed by viewing the compositional field values
+# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
+# of the viscoselastic stress tensor. Significantly, the composition is not
+# fixed on any boundary in order to prevent the formation of boundary artifacts
+# in the compositional fields tracking viscoelastic stresses.
+#
+# For the current test, we prescribe initial values to the compositional fields
+# that track the viscoelastic stresses that are equal to the eventual
+# analytical solution for the viscoelastic stress.
+
+include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
+
+
+#  Global parameters
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 1000
+set Use years in output instead of seconds = true
+set Output directory                       = viscoelastic_stress_build-up_gmg
+
+# Use GMG Stokes solver
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Stokes solver type = block GMG
+  end
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = top, left
+  set Prescribed velocity boundary indicators = bottom y:function, right x:function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = Lx = 100000, yinsec = 31557600, eps_ii = 1e-14
+    set Function expression = if (x>50e3, Lx*eps_ii*yinsec, 0.); if (y<50e3, Lx*eps_ii*yinsec, 0.);
+  end
+end
+
+# Spatial domain of different compositional fields:
+# ve_stress_xx, ve_stress_yy, ve_stress_xy
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  = eta = 1e22, mu = 1e10, eps = 1e-14, t = 250000, yinsec = 31557600
+    set Function expression = 2.*eta*eps*(1.-exp(-mu*t*yinsec/eta)); \
+                              -2.*eta*eps*(1.-exp(-mu*t*yinsec/eta)); \
+                              0
+  end
+end
+
+subsection Material model
+  set Material averaging = harmonic average only viscosity
+end
+
+subsection Postprocess
+  subsection Visualization
+    set Time between graphical output = 1e3
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/viscoelastoplastic_yield_plastic_viscous_strain_weakening.prm.bak b/tests/viscoelastoplastic_yield_plastic_viscous_strain_weakening.prm.bak
new file mode 100644
index 00000000000..4b36b78d9a2
--- /dev/null
+++ b/tests/viscoelastoplastic_yield_plastic_viscous_strain_weakening.prm.bak
@@ -0,0 +1,77 @@
+include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm
+
+
+# Global parameters
+set Dimension                              = 2
+set End time                               = 1000
+set Max nonlinear iterations               = 2
+set Output directory                       = viscoelastoplastic_yield_plastic_viscous_strain_weakening
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 5
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, plastic_strain, viscous_strain
+end
+
+# We prescribe some initial strain at the center of the domain
+# plastic_strain, viscous_strain
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0; 0; 0; \
+                              if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0); \
+                              if(x>=35e3&x<=65e3&y>=35.e3&y<=65.e3,0.8,0)
+  end
+end
+
+# Boundary composition specification
+subsection Boundary composition model
+  set List of model names = initial composition
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = true
+end
+
+# Material model (values for background material)
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Reference strain rate = 1.e-16
+    set Viscous flow law = dislocation
+    set Prefactors for dislocation creep = 5.e-23
+    set Stress exponents for dislocation creep = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep = 0.
+    set Yield mechanism = drucker
+    set Angles of internal friction = 0.
+    set Cohesions = 1.e6
+    set Strain weakening mechanism = plastic weakening with plastic strain and viscous weakening with viscous strain
+    set Start prefactor strain weakening intervals = 0.
+    set End prefactor strain weakening intervals = 1.0
+    set Prefactor strain weakening factors = 0.5
+    set Start plasticity strain weakening intervals = 0.
+    set End plasticity strain weakening intervals = 1.0
+    set Cohesion strain weakening factors = 0.5
+    set Friction strain weakening factors = 0.5
+    set Elastic shear moduli        = 1.e10
+    set Use fixed elastic time step = false
+    set Fixed elastic time step     = 1e3
+  end
+end
+
+# Post processing
+# named additional outputs includes the weakened cohesions and friction angles
+subsection Postprocess
+  set List of postprocessors = velocity statistics, mass flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = viscosity, strain rate, named additional outputs
+    set Time between graphical output = 1000
+  end
+end
diff --git a/tests/viscoplastic_melt_blob_freezing.prm.bak b/tests/viscoplastic_melt_blob_freezing.prm.bak
new file mode 100644
index 00000000000..a054fd7e2cb
--- /dev/null
+++ b/tests/viscoplastic_melt_blob_freezing.prm.bak
@@ -0,0 +1,64 @@
+#########################################################
+# This is a test for the melting rate functionality,
+# in particular the freezing of melt.
+# It uses the reactive fluid transport material model composited
+# on top of the visco plastic material model.
+
+# The initial porosity has the form of a Gaussian function
+# there is a fixed (constant) freezing rate.
+
+# The amplitude of the Gaussian is 0.2, and the melting time
+# scale is chosen in such a way that the fraction of melt
+# should be cut in half every year (visible in the maximum
+# value of the porosity field).
+
+# This is like the rising_melt_blob_freezing test, except
+# that it uses the reactive fluid transport material model
+# composited with a visco plastic solid material model.
+# Outputs of this test and rising_melt_blob freezing should
+# be identical except for the the solid viscosity. This is because
+# the melt_simple material model uses a simple temperature scaled
+# solid viscosity, and the reactive_fluid_transport model used here
+# composites with a the visco plastic material model, with a different
+# viscosity calculation than the solid in melt_simple.
+
+############### Global parameters
+include $ASPECT_SOURCE_DIR/tests/rising_melt_blob_freezing.prm
+
+set Output directory = viscoplastic_melt_blob_freezing
+
+#The reactive fluid transport material model is composited on top
+# of the visco plastic material model. This example uses the default
+# settings of the visco plastic material model for the solid deformation,
+# which are not important for this test case.
+subsection Material model
+  set Model name =  reactive fluid transport
+  set Material averaging =  harmonic average
+
+  subsection Reactive Fluid Transport Model
+    set Base model = visco plastic
+    set Fluid-solid reaction scheme = katz2003
+
+    subsection Katz 2003 model
+      set Melt extraction depth = 0.0
+      set Freezing rate         = 1.0
+      set Melting time scale for operator splitting = 1.442695041
+    end
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+
+    subsection Melt material properties
+      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
+    end
+  end
+end
diff --git a/tests/viscoplastic_melt_fraction.prm.bak b/tests/viscoplastic_melt_fraction.prm.bak
new file mode 100644
index 00000000000..07e90549a13
--- /dev/null
+++ b/tests/viscoplastic_melt_fraction.prm.bak
@@ -0,0 +1,118 @@
+# This test checks whether the katz2003 mantle melting model in the
+# reactive transport material model produces the correct melt fraction output.
+#
+# Temperature will be held constant throughout model at 1573 K so at 1 GPa
+# melt fraction should be 15% from Katz et. al. 2003 Fig. 4
+
+set Adiabatic surface temperature          = 1573
+
+# The number of space dimensions you want to run this program in.
+set Dimension                              = 2
+
+# The end time of the simulation. Units: years if the 'Use years in output
+# instead of seconds' parameter is set; seconds otherwise.
+set End time                               = 1000
+set Pressure normalization                 = surface
+set Use years in output instead of seconds = true
+set Output directory                       = output-vp-melt-fraction
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = top, bottom
+
+  subsection Initial temperature
+    set Maximal temperature = 1573
+    set Minimal temperature = 1573
+  end
+end
+
+# The composition is not fixed on any boundary
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators =
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 100e3
+    set Y extent  = 100e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    # Magnitude of the gravity vector in $m/s^2$. The direction is always
+    # radially outward from the center of the earth.
+    set Magnitude = 10
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = porosity, peridotite
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 1573
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0;0
+  end
+end
+
+#The reactive fluid transport material model is composited on top
+# of the visco plastic material model. This example uses the default
+# settings of the visco plastic material model for the solid deformation,
+# which are not important for this test case.
+subsection Material model
+  set Model name =  reactive fluid transport
+  set Material averaging =  harmonic average
+
+  subsection Reactive Fluid Transport Model
+    set Base model = visco plastic
+    set Fluid-solid reaction scheme = katz2003
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 5
+  set Strategy                                 = composition
+  set Time steps between mesh refinement       = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = bottom, top, left, right
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Use direct solver for Stokes system = true
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization, melt statistics, pressure statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set List of output variables      = melt fraction, named additional outputs
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/viscosity_refinement.prm.bak b/tests/viscosity_refinement.prm.bak
new file mode 100644
index 00000000000..fff433301f9
--- /dev/null
+++ b/tests/viscosity_refinement.prm.bak
@@ -0,0 +1,67 @@
+# Test the viscosity refinement criterion
+set Adiabatic surface temperature          = 1623
+set Dimension                              = 2
+set End time                               = 0
+
+subsection Boundary temperature model
+  set List of model names = initial temperature
+  set Fixed temperature boundary indicators   = 0,3
+
+  subsection Initial temperature
+    set Maximal temperature = 3773
+    set Minimal temperature = 273
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 500000
+    set Y extent  = 500000
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function constants  = l=250000
+    set Function expression = if(x < l, 1873, 1623)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal viscosity exponent = 5.0
+    set Reference temperature = 1750
+  end
+end
+
+subsection Mesh refinement
+  set Coarsening fraction                      = 0.05
+  set Refinement fraction                      = 0.3
+  set Initial adaptive refinement              = 3
+  set Initial global refinement                = 2
+  set Strategy                                 = viscosity
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+  set Zero velocity boundary indicators       =
+end
+
+subsection Postprocess
+  set List of postprocessors =
+end
diff --git a/tests/viscous_dissipation_statistics.prm.bak b/tests/viscous_dissipation_statistics.prm.bak
new file mode 100644
index 00000000000..8bb473c2542
--- /dev/null
+++ b/tests/viscous_dissipation_statistics.prm.bak
@@ -0,0 +1,124 @@
+# this is a version of the stokes' law input file
+# but with less mesh refinement
+
+
+
+############### Global parameters
+# We use a 3d setup. Since we are only interested
+# in a steady state solution, we set the end time
+# equal to the start time to force a single time
+# step before the program terminates.
+
+set Dimension                              = 3
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+############### Parameters describing the model
+# The setup is a 3d box with edge length 2890000 in which
+# all 6 sides have free slip boundary conditions. Because
+# the temperature plays no role in this model we need not
+# bother to describe temperature boundary conditions or
+# the material parameters that pertain to the temperature.
+
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent  = 2890000
+    set Y extent  = 2890000
+    set Z extent  = 2890000
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3,4,5
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Viscosity                     = 1e22
+    set Density differential for compositional field 1 = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 9.81
+  end
+end
+
+############### Parameters describing the temperature field
+# As above, there is no need to set anything for the
+# temperature boundary conditions.
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0
+  end
+end
+
+############### Parameters describing the compositional field
+# This, however, is the more important part: We need to describe
+# the compositional field and its influence on the density
+# function. The following blocks say that we want to
+# advect a single compositional field and that we give it an
+# initial value that is zero outside a sphere of radius
+# r=200000m and centered at the point (p,p,p) with
+# p=1445000 (which is half the diameter of the box) and one inside.
+# The last block re-opens the material model and sets the
+# density differential per unit change in compositional field to
+# 100.
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y,z
+    set Function constants  = r=200000,p=1445000
+    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
+  end
+end
+
+############### Parameters describing the discretization
+# The following parameters describe how often we want to refine
+# the mesh globally and adaptively, what fraction of cells should
+# be refined in each adaptive refinement step, and what refinement
+# indicator to use when refining the mesh adaptively.
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 2
+  set Initial global refinement          = 2
+  set Refinement fraction                = 0.2
+  set Strategy                           = velocity
+end
+
+############### Parameters describing what to do with the solution
+# The final section allows us to choose which postprocessors to
+# run at the end of each time step. We select to generate graphical
+# output that will consist of the primary variables (velocity, pressure,
+# temperature and the compositional fields) as well as the density and
+# viscosity. We also select to compute some statistics about the
+# velocity field.
+
+subsection Postprocess
+  set List of postprocessors = visualization, velocity statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = density, viscosity
+    set Output format                 = gnuplot
+  end
+end
diff --git a/tests/viscous_top_beam.prm b/tests/viscous_top_beam.prm
index 63b291dda6f..e4a1185cb57 100644
--- a/tests/viscous_top_beam.prm
+++ b/tests/viscous_top_beam.prm
@@ -51,9 +51,9 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
     set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0
     set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0
+    set Limiter for discontinuous composition solution = bound preserving
   end
 end
 
diff --git a/tests/viscous_top_beam.prm.bak b/tests/viscous_top_beam.prm.bak
new file mode 100644
index 00000000000..63b291dda6f
--- /dev/null
+++ b/tests/viscous_top_beam.prm.bak
@@ -0,0 +1,163 @@
+# This parameter file reproduces a 2D benchmark for viscoelastic deformation
+# published in "Numerical modelling of magma dynamics coupled to tectonic
+# deformation of lithosphere and crust" by Keller, May and Kaus, 2013,
+# Geophys. J. Int., v. 195,  p. 1406-1422. The model setup and results are
+# described in detail in section B.2.3 and figure B5.
+#
+# The test uses a vertical beam instead of the one in the original
+# benchmark to check the directions of computed stress in the
+# postprocessors.
+#
+# In addition, elasticity is switched off.
+
+# Global parameters
+set Dimension                              = 2
+set End time                               = 2e3
+set Use years in output instead of seconds = true
+set CFL number                             = 0.5
+set Maximum time step                      = 1e3
+
+# Solver settings
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Number of cheap Stokes solver steps = 2000
+  end
+end
+
+# Model geometry (7.5x5 km, 0.1 km spacing)
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X repetitions = 15
+    set Y repetitions = 10
+    set X extent      = 7.5e3
+    set Y extent      = 5e3
+  end
+end
+
+# Mesh refinement specifications
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+# Element types
+subsection Discretization
+  set Temperature polynomial degree           = 1
+  set Use locally conservative discretization = false
+  set Use discontinuous temperature discretization = false
+  set Use discontinuous composition discretization = true
+
+  subsection Stabilization parameters
+    set Use limiter for discontinuous composition solution = true
+    set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0
+    set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0
+  end
+end
+
+# Formulation classification
+subsection Formulation
+  set Enable elasticity = false
+end
+
+# Velocity boundary conditions
+subsection Boundary velocity model
+  set Zero velocity boundary indicators       = top
+  set Tangential velocity boundary indicators = bottom, left, right
+end
+
+# Number and name of compositional fields
+subsection Compositional fields
+  set Number of fields = 4
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, beam
+  set Types of fields = generic, generic, generic, chemical composition
+end
+
+# Spatial domain of different compositional fields
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function constants  =
+    set Function expression = 0; 0; 0; if (x>=3.5e3 && x<=4.0e3 && y>=3.0e3, 1, 0)
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set Fixed composition boundary indicators  = bottom, top, right, left
+  set List of model names                   = initial composition
+end
+
+# Temperature boundary conditions
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators = bottom, top, left, right
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 293
+    set Left temperature   = 293
+    set Right temperature  = 293
+    set Top temperature    = 293
+  end
+end
+
+# Temperature initial conditions
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 293
+  end
+end
+
+# Material model
+subsection Material model
+  set Model name = visco plastic
+
+  subsection Visco Plastic
+    set Densities            =  2800,  2800,  2800,  2800,  6000
+    set Viscous flow law                          = dislocation
+    set Prefactors for dislocation creep          = 5.e-19, 5.e-19, 5.e-19, 5.e-19, 5.e-25
+    set Stress exponents for dislocation creep    = 1.0
+    set Activation energies for dislocation creep = 0.
+    set Activation volumes for dislocation creep  = 0.
+    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
+    set Fixed elastic time step     = 2e3
+    set Use fixed elastic time step = true
+    set Viscosity averaging scheme  = maximum composition
+    set Cohesions = 1.e50
+  end
+end
+
+# Gravity model
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.
+  end
+end
+
+# Post processing
+subsection Postprocess
+  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, visualization
+
+  subsection Visualization
+    set List of output variables = material properties, strain rate, stress second invariant, principal stress
+    set Output format = gnuplot
+    set Time steps between graphical output = 1
+    set Interpolate output = true
+
+    subsection Principal stress
+      set Use deviatoric stress = true
+    end
+
+    subsection Material properties
+      set List of material properties = density, viscosity
+    end
+  end
+end
diff --git a/tests/visualization_averaged_strain_rate.prm.bak b/tests/visualization_averaged_strain_rate.prm.bak
new file mode 100644
index 00000000000..3373e94fdc1
--- /dev/null
+++ b/tests/visualization_averaged_strain_rate.prm.bak
@@ -0,0 +1,84 @@
+# A testcase for the "Point-wise stress and strain" setting for the "strain
+# rate" visualization postprocessor. It solves the equations on a box with
+# Dirichlet boundary conditions equal to (z*z,0), which then is also the
+# velocity everywhere. This yields a linear strain rate.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z*z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Point-wise stress and strain = false
+    set Output format = gnuplot
+    set List of output variables = strain rate
+  end
+end
diff --git a/tests/visualization_averaged_strain_rate2.prm.bak b/tests/visualization_averaged_strain_rate2.prm.bak
new file mode 100644
index 00000000000..d9d292ede95
--- /dev/null
+++ b/tests/visualization_averaged_strain_rate2.prm.bak
@@ -0,0 +1,12 @@
+# Like visualization_averaged_strain_rate.prm but without averaging turned on.
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/visualization_averaged_strain_rate.prm
+
+
+subsection Postprocess
+  subsection Visualization
+    set Point-wise stress and strain = true
+  end
+end
diff --git a/tests/visualization_conductivity_diffusivity.prm.bak b/tests/visualization_conductivity_diffusivity.prm.bak
new file mode 100644
index 00000000000..985766ad368
--- /dev/null
+++ b/tests/visualization_conductivity_diffusivity.prm.bak
@@ -0,0 +1,80 @@
+#########################################################
+# This tests that the thermal conductivity and diffusivity
+# visualization postprocessors are working correctly.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 3e-5
+    set Reference specific heat                        = 1
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+# For a temperature between zero and one,
+# density will vary between (1 - 3e-5) and 1.
+# The thermal conductivity is set to 1e-6 everywhere
+# and the thermal diffusivity (k/(rho c_p))
+# will thus vary from 1e-6 to 1.00003e-6
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format = gnuplot
+    set List of output variables = density, thermal conductivity, thermal diffusivity, specific heat
+  end
+end
diff --git a/tests/visualization_higher_order_output.prm.bak b/tests/visualization_higher_order_output.prm.bak
new file mode 100644
index 00000000000..3c2075d9a14
--- /dev/null
+++ b/tests/visualization_higher_order_output.prm.bak
@@ -0,0 +1,17 @@
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/cookbooks/van-keken/van-keken-smooth.prm
+
+set End time = 0.0
+
+subsection Mesh refinement
+  set Initial adaptive refinement              = 0
+  set Initial global refinement                = 3
+end
+
+subsection Postprocess
+  subsection Visualization
+    set Interpolate output = true
+    set Write higher order output = true
+  end
+end
diff --git a/tests/visualization_shear_stress.prm.bak b/tests/visualization_shear_stress.prm.bak
new file mode 100644
index 00000000000..8fb8c817718
--- /dev/null
+++ b/tests/visualization_shear_stress.prm.bak
@@ -0,0 +1,87 @@
+# A testcase for the "shear stress" visualization postprocessor. It solves the
+# equations on a box with Dirichlet boundary conditions equal to
+# (z,0), which then is also the velocity everywhere. This yields
+# a constant strain rate [[0,1/2],[1/2,0]]
+#
+# the shear stress is then simply this tensor times -2*eta and we set
+# eta=42 below.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 42
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Point-wise stress and strain = false
+    set Output format = gnuplot
+    set List of output variables = shear stress
+  end
+end
diff --git a/tests/visualization_shear_stress_pointwise.prm.bak b/tests/visualization_shear_stress_pointwise.prm.bak
new file mode 100644
index 00000000000..de0fe74a4b0
--- /dev/null
+++ b/tests/visualization_shear_stress_pointwise.prm.bak
@@ -0,0 +1,12 @@
+# Like visualization_shear_stress.prm but with point-wise output
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/visualization_shear_stress.prm
+
+
+subsection Postprocess
+  subsection Visualization
+    set Point-wise stress and strain = true
+  end
+end
diff --git a/tests/visualization_shear_stress_viscoelastic.prm.bak b/tests/visualization_shear_stress_viscoelastic.prm.bak
new file mode 100644
index 00000000000..0e5a0b948c8
--- /dev/null
+++ b/tests/visualization_shear_stress_viscoelastic.prm.bak
@@ -0,0 +1,49 @@
+# A testcase for the "shear stress" visualization postprocessor
+# when elasticity is enabled. The rheology is viscoelastic,
+# but otherwise the test is identical to visualization_shear_stress.prm.
+# In the first timestep, the elastic initial conditions
+# impose zero differential stress. A very high shear modulus relative
+# to the viscosity ensures that the differential stress quickly approaches
+# the value from the original viscous test.
+#
+# The test solves the equations on a box with Dirichlet boundary
+# conditions equal to (z,0), which then is also the velocity everywhere.
+# This yields a constant strain rate [[0,1/2],[1/2,0]].
+#
+# the stress is then simply this tensor times -2*eta plus the pressure and we set
+# eta=42 below. compared to the visualization_shear_stress test, the test
+# also includes a nonzero gravity so that we get a nonconstant pressure
+#
+# the second invariant of the deviatoric stress will be 42.
+
+include $ASPECT_SOURCE_DIR/tests/visualization_shear_stress.prm
+
+set End time                               = 1
+
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 1
+    set Viscosities                 = 42
+    set Elastic shear moduli        = 1e16
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
+end
+
+subsection Postprocess
+  subsection Visualization
+    set Time between graphical output = 1
+    set Interpolate output = true
+  end
+end
diff --git a/tests/visualization_strain_rate.prm.bak b/tests/visualization_strain_rate.prm.bak
new file mode 100644
index 00000000000..db121ab3211
--- /dev/null
+++ b/tests/visualization_strain_rate.prm.bak
@@ -0,0 +1,84 @@
+# A testcase for the "strain rate" visualization postprocessor. It solves the
+# equations on a box with Dirichlet boundary conditions equal to
+# (z,0), which then is also the velocity everywhere. This yields
+# a constant strain rate [[0,1/2],[1/2,0]] with norm |dot eps|=1/sqrt(2).
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Point-wise stress and strain = false
+    set Output format = gnuplot
+    set List of output variables = strain rate
+  end
+end
diff --git a/tests/visualization_strain_rate_pointwise.prm.bak b/tests/visualization_strain_rate_pointwise.prm.bak
new file mode 100644
index 00000000000..4e85497f782
--- /dev/null
+++ b/tests/visualization_strain_rate_pointwise.prm.bak
@@ -0,0 +1,12 @@
+# Like visualization_strain_rate.prm but with point-wise output
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/visualization_strain_rate.prm
+
+
+subsection Postprocess
+  subsection Visualization
+    set Point-wise stress and strain = true
+  end
+end
diff --git a/tests/visualization_strain_rate_tensor.prm.bak b/tests/visualization_strain_rate_tensor.prm.bak
new file mode 100644
index 00000000000..f65ccca708b
--- /dev/null
+++ b/tests/visualization_strain_rate_tensor.prm.bak
@@ -0,0 +1,83 @@
+# A testcase for the "strain rate tensor" visualization postprocessor. It solves the
+# equations on a box with Dirichlet boundary conditions equal to
+# (z,0), which then is also the velocity everywhere. This yields
+# a constant strain rate [[0,1/2],[1/2,0]].
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Point-wise stress and strain = true
+    set Output format = gnuplot
+    set List of output variables = strain rate tensor
+  end
+end
diff --git a/tests/visualization_strain_rate_tensor_pointwise.prm.bak b/tests/visualization_strain_rate_tensor_pointwise.prm.bak
new file mode 100644
index 00000000000..4a15cce0c76
--- /dev/null
+++ b/tests/visualization_strain_rate_tensor_pointwise.prm.bak
@@ -0,0 +1,12 @@
+# Like visualization_strain_rate_tensor.prm but with point-wise output
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/visualization_strain_rate_tensor.prm
+
+
+subsection Postprocess
+  subsection Visualization
+    set Point-wise stress and strain = true
+  end
+end
diff --git a/tests/visualization_stress.prm.bak b/tests/visualization_stress.prm.bak
new file mode 100644
index 00000000000..57963d287e3
--- /dev/null
+++ b/tests/visualization_stress.prm.bak
@@ -0,0 +1,90 @@
+# A testcase for the "stress" visualization postprocessor. It solves the
+# equations on a box with Dirichlet boundary conditions equal to
+# (z,0), which then is also the velocity everywhere. This yields
+# a constant strain rate [[0,1/2],[1/2,0]]
+#
+# the stress is then simply this tensor times -2*eta plus the pressure and we set
+# eta=42 below. compared to the visualization_shear_stress test, the test
+# also includes a nonzero gravity so that we get a nonconstant pressure
+#
+# the second invariant of the deviatoric stress will be 42.
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# choose a gravity to ensure that there is a pressure
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 42
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Point-wise stress and strain = false
+    set Output format = gnuplot
+    set List of output variables = stress, stress second invariant
+  end
+end
diff --git a/tests/visualization_stress_pointwise.prm.bak b/tests/visualization_stress_pointwise.prm.bak
new file mode 100644
index 00000000000..7e292b75ce7
--- /dev/null
+++ b/tests/visualization_stress_pointwise.prm.bak
@@ -0,0 +1,12 @@
+# Like visualization_stress.prm but with point-wise output
+
+set Dimension = 2
+
+include $ASPECT_SOURCE_DIR/tests/visualization_stress.prm
+
+
+subsection Postprocess
+  subsection Visualization
+    set Point-wise stress and strain = true
+  end
+end
diff --git a/tests/visualization_stress_viscoelastic.prm.bak b/tests/visualization_stress_viscoelastic.prm.bak
new file mode 100644
index 00000000000..b402535e662
--- /dev/null
+++ b/tests/visualization_stress_viscoelastic.prm.bak
@@ -0,0 +1,49 @@
+# A testcase for the "stress" visualization postprocessor
+# when elasticity is enabled. The rheology is viscoelastic,
+# but otherwise the test is identical to visualization_stress.prm.
+# In the first timestep, the elastic initial conditions
+# impose zero differential stress. A very high shear modulus relative
+# to the viscosity ensures that the differential stress quickly approaches
+# the value from the original viscous test.
+#
+# The test solves the equations on a box with Dirichlet boundary
+# conditions equal to (z,0), which then is also the velocity everywhere.
+# This yields a constant strain rate [[0,1/2],[1/2,0]].
+#
+# the stress is then simply this tensor times -2*eta plus the pressure and we set
+# eta=42 below. compared to the visualization_shear_stress test, the test
+# also includes a nonzero gravity so that we get a nonconstant pressure
+#
+# the second invariant of the deviatoric stress will be 42.
+
+include $ASPECT_SOURCE_DIR/tests/visualization_stress.prm
+
+set End time                               = 1
+
+subsection Formulation
+  set Enable elasticity = true
+end
+
+subsection Material model
+  set Model name = viscoelastic
+
+  subsection Viscoelastic
+    set Densities                   = 1
+    set Viscosities                 = 42
+    set Elastic shear moduli        = 1e16
+    set Use fixed elastic time step = false
+    set Viscosity averaging scheme  = harmonic
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
+end
+
+subsection Postprocess
+  subsection Visualization
+    set Time between graphical output = 1
+    set Interpolate output = true
+  end
+end
diff --git a/tests/visualization_temperature_anomaly.prm.bak b/tests/visualization_temperature_anomaly.prm.bak
new file mode 100644
index 00000000000..60a5b9731ab
--- /dev/null
+++ b/tests/visualization_temperature_anomaly.prm.bak
@@ -0,0 +1,85 @@
+#########################################################
+# This tests that the temperature anomaly
+# visualization postprocessor is working correctly.
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 2
+    set Y extent = 1
+  end
+end
+
+subsection Boundary temperature model
+  set Fixed temperature boundary indicators   = 2, 3
+  set List of model names = box
+
+  subsection Box
+    set Bottom temperature = 1
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0, 1, 2, 3
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function expression = (1-z)
+  end
+end
+
+# Compared to the passive material model, we here make
+# the density composition dependent by letting it depend
+# linearly on the value of the first compositional field.
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Thermal conductivity                           = 1e-6
+    set Thermal expansion coefficient                  = 3e-5
+    set Reference specific heat                        = 1
+    set Viscosity                                      = 1
+    set Reference density                              = 1
+    set Reference temperature                          = 0
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+# For a temperature between zero and one,
+# density will vary between (1 - 3e-5) and 1.
+# The thermal conductivity is set to 1e-6 everywhere
+# and the thermal diffusivity (k/(rho c_p))
+# will thus vary from 1e-6 to 1.00003e-6
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format = gnuplot
+    set List of output variables = temperature anomaly
+
+    subsection Temperature anomaly
+      set Number of depth slices = 6
+      set Use maximal temperature for bottom = false
+    end
+  end
+end
diff --git a/tests/visualization_unique_list.prm.bak b/tests/visualization_unique_list.prm.bak
new file mode 100644
index 00000000000..1fdb22897c0
--- /dev/null
+++ b/tests/visualization_unique_list.prm.bak
@@ -0,0 +1,83 @@
+# A testcase to make sure the has_unique_entries function
+# successfully reports wrong input files.
+
+# EXPECT FAILURE
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1, 2, 3
+end
+
+# no gravity. the pressure will equal just the dynamic component
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 0
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+# temperature field doesn't matter. set it to zero
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Function expression = x
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
+
+  subsection Function
+    set Variable names = x,z
+    set Function expression = z;0
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set Output format = gnuplot
+    set List of output variables = strain rate, strain rate
+  end
+end
diff --git a/tests/visualization_vertical_heat_flux.prm.bak b/tests/visualization_vertical_heat_flux.prm.bak
new file mode 100644
index 00000000000..d035ec9757e
--- /dev/null
+++ b/tests/visualization_vertical_heat_flux.prm.bak
@@ -0,0 +1,90 @@
+# Test for vertical heat flux visualization postprocessor
+
+set Dimension                              = 2
+set Use years in output instead of seconds = false
+set End time                               = 0.0
+set Output directory                       = output
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,z
+    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
+    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = bottom, top
+
+  subsection Box
+    set Bottom temperature = 1
+    set Left temperature   = 0
+    set Right temperature  = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = left, right, bottom, top
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1
+    set Thermal expansion coefficient = 1e-10
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 4
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+end
+
+# add vertical heat flux to visualization postprocessor
+subsection Postprocess
+  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = vertical heat flux
+    set Time between graphical output = 0.00
+    set Output format = gnuplot
+  end
+end
+
+subsection Solver parameters
+  set Temperature solver tolerance = 1e-10
+
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1e-7
+  end
+end
diff --git a/tests/viz_mesh_deform_vector.prm.bak b/tests/viz_mesh_deform_vector.prm.bak
new file mode 100644
index 00000000000..cf12c76932a
--- /dev/null
+++ b/tests/viz_mesh_deform_vector.prm.bak
@@ -0,0 +1,124 @@
+# Test undeformed mesh output and mesh deformation displacement
+#
+# copied from free_surface_blob.prm
+
+set Dimension = 2
+set CFL number                             = 0.5
+set End time                               = 1e8
+set Output directory                       = output
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Pressure normalization                 = no
+set Timing output frequency                = 5
+set Use years in output instead of seconds = true
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = 2,3
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = 2:0,3:0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500.e3
+    set Y extent = 200.e3
+    set X repetitions = 5
+    set Y repetitions = 2
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10.0
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 3300
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0.0
+    set Thermal conductivity          = 4.7
+    set Thermal expansion coefficient = 4e-5
+    set Viscosity                     = 1.e21
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.00
+  set Strategy                           = temperature
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1
+  set Zero velocity boundary indicators       = 2
+end
+
+subsection Mesh deformation
+  set Mesh deformation boundary indicators = 3: free surface
+
+  subsection Free surface
+    set Free surface stabilization theta = 0.5
+  end
+end
+
+subsection Termination criteria
+  set Termination criteria = end step
+  set End step = 10
+end
+
+subsection Postprocess
+  set List of postprocessors = topography,velocity statistics, basic statistics, visualization
+
+  subsection Visualization
+    set Time between graphical output = 0
+    set Output undeformed mesh = true
+    set Output mesh velocity = true
+    set Output mesh displacement      = true
+    set Output format                 = gnuplot
+  end
+end
+
+subsection Solver parameters
+  subsection Stokes solver parameters
+    set Linear solver tolerance = 1.e-7
+    set Number of cheap Stokes solver steps = 0
+  end
+end
diff --git a/tests/viz_plugin_dependency.cc.bak b/tests/viz_plugin_dependency.cc.bak
new file mode 100644
index 00000000000..1975629b0b8
--- /dev/null
+++ b/tests/viz_plugin_dependency.cc.bak
@@ -0,0 +1,89 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// create a visualization postprocessor that requires something else
+//
+// this works just like the plugin_dependency* tests, just that it's a
+// viz postprocessor, not a regular postprocessor that has
+// dependencies
+
+#include "../benchmarks/solcx/solcx.cc"
+#include <aspect/postprocess/visualization.h>
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      template <int dim>
+      class MyPostprocessor
+        : public DataPostprocessorScalar<dim>,
+          public SimulatorAccess<dim>,
+          public Interface<dim>
+      {
+        public:
+          MyPostprocessor ()
+            :
+            DataPostprocessorScalar<dim> ("my_postprocessor",
+                                          update_default)
+          {}
+
+          virtual
+          void
+          evaluate_vector_field (const DataPostprocessorInputs::Vector<dim> &input_data,
+                                 std::vector<Vector<double>>               &computed_quantities) const
+          {
+            Assert (computed_quantities[0].size() == 1, ExcInternalError());
+
+            for (unsigned int q=0; q<computed_quantities.size(); ++q)
+              {
+                // not important what we do here :-)
+                computed_quantities[q](0) = 0;
+              }
+          }
+
+          virtual
+          std::list<std::string>
+          required_other_postprocessors () const
+          {
+            // select a postprocessor that is not selected in the .prm file
+            std::list<std::string> deps;
+            deps.push_back ("velocity statistics");
+            return deps;
+          }
+      };
+    }
+  }
+}
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    namespace VisualizationPostprocessors
+    {
+      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MyPostprocessor,
+                                                  "my postprocessor",
+                                                  ".")
+    }
+  }
+}
diff --git a/tests/viz_plugin_dependency.prm.bak b/tests/viz_plugin_dependency.prm.bak
new file mode 100644
index 00000000000..4da6310c80e
--- /dev/null
+++ b/tests/viz_plugin_dependency.prm.bak
@@ -0,0 +1,80 @@
+# Test that the way we provide postprocessors to state that they
+# depend on other postprocessors works
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = no Advection, iterated Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = SolCxMaterial
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+
+    # choose a postprocessor that will in turn require another one
+    # to run as well (here, velocity statistics)
+    set List of output variables = my postprocessor
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/viz_spherical_velocity_components.prm.bak b/tests/viz_spherical_velocity_components.prm.bak
new file mode 100644
index 00000000000..e8632525cea
--- /dev/null
+++ b/tests/viz_spherical_velocity_components.prm.bak
@@ -0,0 +1,80 @@
+##### test visualization postprocessor "spherical velocity components"
+
+set Dimension                              = 3
+set Use years in output instead of seconds = true
+set End time                               = 0
+set Adiabatic surface temperature          = 1613.0
+
+subsection Geometry model
+  set Model name = spherical shell
+
+  subsection Spherical shell
+    set Inner radius = 3481000
+    set Outer radius = 6336000
+  end
+end
+
+subsection Initial temperature model
+  set Model name = harmonic perturbation
+
+  subsection Harmonic perturbation
+    set Magnitude = 3
+    set Reference temperature = 1613
+  end
+end
+
+subsection Boundary temperature model
+  set List of model names = spherical constant
+  set Fixed temperature boundary indicators   = inner, outer
+
+  subsection Spherical constant
+    set Inner temperature = 3000
+    set Outer temperature = 273
+  end
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = inner
+  set Prescribed velocity boundary indicators = outer: function
+
+  subsection Function
+    set Coordinate system   = spherical
+    set Variable names      = r, phi, theta
+    set Function expression = sin(4*phi);sin(2*phi);cos(theta)
+    set Use spherical unit vectors = true
+  end
+end
+
+subsection Gravity model
+  set Model name = radial constant
+
+  subsection Radial constant
+    set Magnitude = 10
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Viscosity = 1e21
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement                = 1
+  set Initial adaptive refinement              = 0
+  set Time steps between mesh refinement       = 0
+  set Strategy                                 = temperature
+end
+
+subsection Postprocess
+  set List of postprocessors = velocity statistics, visualization
+
+  subsection Visualization
+    set List of output variables      = spherical velocity components
+    set Interpolate output = false
+    set Time between graphical output = 0
+    set Output format = gnuplot
+  end
+end
diff --git a/tests/vof_circle_1.cc.bak b/tests/vof_circle_1.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_circle_1.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_circle_1.prm.bak b/tests/vof_circle_1.prm.bak
new file mode 100644
index 00000000000..565f8d667b8
--- /dev/null
+++ b/tests/vof_circle_1.prm.bak
@@ -0,0 +1,94 @@
+# Test advecting a circle under a constant velocity field
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.25
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Box origin X coordinate = -2.0
+    set Box origin Y coordinate = -2.0
+    set X extent = 4
+    set Y extent = 4
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+    set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, volume of fluid mms
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 0.25
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+      set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
+    end
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 2.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_circle_amr.cc.bak b/tests/vof_circle_amr.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_circle_amr.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_circle_amr.prm.bak b/tests/vof_circle_amr.prm.bak
new file mode 100644
index 00000000000..6160cf141ed
--- /dev/null
+++ b/tests/vof_circle_amr.prm.bak
@@ -0,0 +1,97 @@
+# Test advecting a circle under a constant velocity field
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.25
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Minimum refinement level           = 2
+  set Initial global refinement          = 3
+  set Initial adaptive refinement        = 2
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+  set Strategy                                 = volume of fluid interface
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Box origin X coordinate = -2.0
+    set Box origin Y coordinate = -2.0
+    set X extent = 4
+    set Y extent = 4
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+    set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, volume of fluid mms
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 0.25
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+      set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
+    end
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 2.0
+    set List of output variables = volume of fluid values, error indicator
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_circle_mpi.cc.bak b/tests/vof_circle_mpi.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_circle_mpi.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_circle_mpi.prm.bak b/tests/vof_circle_mpi.prm.bak
new file mode 100644
index 00000000000..4797696b132
--- /dev/null
+++ b/tests/vof_circle_mpi.prm.bak
@@ -0,0 +1,96 @@
+# MPI: 4
+
+# Set velocity field test parameter file
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.25
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Initial global refinement          = 4
+  set Initial adaptive refinement        = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Box origin X coordinate = -2.0
+    set Box origin Y coordinate = -2.0
+    set X extent = 4
+    set Y extent = 4
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+    set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, volume of fluid mms
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 0.25
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+      set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
+    end
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 2.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_circle_mpi_amr.cc.bak b/tests/vof_circle_mpi_amr.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_circle_mpi_amr.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_circle_mpi_amr.prm.bak b/tests/vof_circle_mpi_amr.prm.bak
new file mode 100644
index 00000000000..39928ff92d1
--- /dev/null
+++ b/tests/vof_circle_mpi_amr.prm.bak
@@ -0,0 +1,99 @@
+# MPI: 4
+
+# Set velocity field test parameter file
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.04
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Minimum refinement level           = 1
+  set Initial global refinement          = 1
+  set Initial adaptive refinement        = 2
+  set Time steps between mesh refinement = 1
+  set Run postprocessors on initial refinement = true
+  set Strategy                                 = volume of fluid interface
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set Box origin X coordinate = -2.0
+    set Box origin Y coordinate = -2.0
+    set X extent = 4
+    set Y extent = 4
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+    set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, volume of fluid mms
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 0.25
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
+      set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
+    end
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 2.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_composition_init.prm.bak b/tests/vof_composition_init.prm.bak
new file mode 100644
index 00000000000..531f9132266
--- /dev/null
+++ b/tests/vof_composition_init.prm.bak
@@ -0,0 +1,81 @@
+# Test for linear interface under constant velocity
+# Error should be at machine precision
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 3
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Time steps between mesh refinement = 0
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100
+    set Y extent = 100
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:composition
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function expression = 50-y
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, composition statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_err_calc.h.bak b/tests/vof_err_calc.h.bak
new file mode 100644
index 00000000000..d51500e7d95
--- /dev/null
+++ b/tests/vof_err_calc.h.bak
@@ -0,0 +1,342 @@
+/*
+  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file doc/COPYING.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <aspect/global.h>
+#include <aspect/simulator_access.h>
+#include <aspect/postprocess/interface.h>
+#include <aspect/volume_of_fluid/utilities.h>
+#include <aspect/volume_of_fluid/handler.h>
+
+// Deal II includes
+#include <deal.II/base/parsed_function.h>
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/fe/fe_values.h>
+
+
+namespace aspect
+{
+  namespace Postprocess
+  {
+    using namespace dealii;
+
+    template <int dim>
+    class VolumeOfFluidSpecifiedSolutionDiff : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
+    {
+      public:
+        VolumeOfFluidSpecifiedSolutionDiff();
+
+        double get_next_t (const double curr_time, const double interval);
+
+        /**
+         * Evaluate the solution for some velocity statistics.
+         */
+        virtual
+        std::pair<std::string,std::string>
+        execute (TableHandler &);
+
+        /**
+         * Declare the parameters this class takes through input files.
+         */
+        static
+        void
+        declare_parameters (ParameterHandler &prm);
+
+        /**
+         * Read the parameters this class declares from the parameter file.
+         */
+        virtual
+        void
+        parse_parameters (ParameterHandler &prm);
+
+      private:
+        // Error calculation functions
+        static std::vector<std::string> error_names ();
+        static std::vector<std::string> error_abrev ();
+        std::vector<double> calc_error_level_set (const Function<dim> &func,
+                                                  const unsigned int n_samp,
+                                                  const unsigned int f_ind);
+
+        // Required variables
+        bool initialized;
+        double error_eval_interval;
+        double next_evaluation_time;
+        unsigned int n_error_samples;
+
+        /**
+         * Level set function for true solution
+         */
+        std::unique_ptr<Functions::ParsedFunction<dim>> trueSolLS;
+    };
+
+    template <int dim>
+    VolumeOfFluidSpecifiedSolutionDiff<dim>::VolumeOfFluidSpecifiedSolutionDiff ()
+      : initialized(false),
+        error_eval_interval (std::numeric_limits<double>::quiet_NaN ()),
+        next_evaluation_time (std::numeric_limits<double>::quiet_NaN ()),
+        n_error_samples (1)
+    {
+    }
+
+    template <int dim>
+    double VolumeOfFluidSpecifiedSolutionDiff<dim>::get_next_t (const double curr_time,
+                                                                const double interval)
+    {
+      const int i = (int) (curr_time / interval);
+      return (i + 1) * interval;
+    }
+
+    template <int dim>
+    std::pair<std::string, std::string>
+    VolumeOfFluidSpecifiedSolutionDiff<dim>::execute (TableHandler &)
+    {
+      std::string result_string = "";
+      std::string label_string = "";
+      if (!initialized)
+        {
+          initialized = true;
+          next_evaluation_time = this->get_time ();
+        }
+
+      if (this->get_time () >= next_evaluation_time)
+        {
+          std::vector<std::string> err_abrev = error_abrev ();
+          double curr_time = this->get_time();
+          if (this->convert_output_to_years())
+            curr_time /= year_in_seconds;
+          trueSolLS->set_time(curr_time);
+
+          std::ostringstream label_stream;
+          std::ostringstream err_str;
+          label_stream << "VoF Calculation(";
+
+          unsigned int n_err = err_abrev.size();
+          std::vector<std::string>::iterator it = err_abrev.begin();
+          for (; it!=err_abrev.end(); )
+            {
+              label_stream << *it;
+              if (++it!=err_abrev.end())
+                label_stream << '/';
+            }
+          label_stream << "):";
+          label_string = label_stream.str();
+
+          unsigned int n_volume_of_fluid_fields = this->get_volume_of_fluid_handler().get_n_fields();
+          std::vector<double> local_err_vals (n_volume_of_fluid_fields*n_err);
+          for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
+            {
+              std::vector<double> l_err_vals_f = calc_error_level_set (*trueSolLS, n_error_samples, f);
+              for (unsigned int i=0; i<n_err; ++i)
+                local_err_vals[f*n_err+i] = l_err_vals_f[i];
+            }
+
+          std::vector<double> global_err_vals(n_volume_of_fluid_fields*n_err);
+          Utilities::MPI::sum (local_err_vals, this->get_mpi_communicator(), global_err_vals);
+
+          for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
+            {
+              for (unsigned int i=0; i<n_err; ++i)
+                {
+                  err_str << std::scientific << std::setprecision (8)
+                          << global_err_vals[f*n_err+i];
+                  if (i+1<n_err)
+                    err_str << " / ";
+                }
+              if (f+1<n_volume_of_fluid_fields)
+                err_str << " // ";
+            }
+          result_string = err_str.str ();
+          next_evaluation_time = get_next_t (this->get_time (), error_eval_interval);
+        }
+      return std::make_pair (label_string, result_string);
+    }
+
+    template <int dim>
+    void
+    VolumeOfFluidSpecifiedSolutionDiff<dim>::declare_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("VoF MMS");
+        {
+          prm.declare_entry ("Time between error estimates", "1e8",
+                             Patterns::Double (0.),
+                             "Time interval between error estimates.");
+
+          prm.declare_entry ("Number error samples", "3",
+                             Patterns::Integer (1),
+                             "Number of iterations for the midpoint quadrature used to accumulate the error estimate");
+
+          prm.enter_subsection ("True LS");
+          {
+            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
+          }
+          prm.leave_subsection ();
+
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    void
+    VolumeOfFluidSpecifiedSolutionDiff<dim>::parse_parameters (ParameterHandler &prm)
+    {
+      prm.enter_subsection("Postprocess");
+      {
+        prm.enter_subsection("VoF MMS");
+        {
+          n_error_samples = prm.get_integer ("Number error samples");
+
+          error_eval_interval = prm.get_double ("Time between error estimates");
+          if (this->convert_output_to_years())
+            error_eval_interval *= year_in_seconds;
+          prm.enter_subsection ("True LS");
+          {
+            trueSolLS.reset(new Functions::ParsedFunction<dim>(this->get_volume_of_fluid_handler().get_n_fields()));
+            trueSolLS->parse_parameters (prm);
+          }
+          prm.leave_subsection ();
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection();
+    }
+
+    template <int dim>
+    std::vector<std::string> VolumeOfFluidSpecifiedSolutionDiff<dim>::error_abrev ()
+    {
+      std::vector<std::string> names (1, "IEstL1");
+      names.push_back ("FEstL1");
+      return names;
+    }
+
+    template <int dim>
+    std::vector<double> VolumeOfFluidSpecifiedSolutionDiff<dim>::calc_error_level_set (const Function<dim> &func,
+        const unsigned int n_samp,
+        const unsigned int f_ind)
+    {
+      const LinearAlgebra::BlockVector &solution = this->get_solution();
+
+      double I_err_est = 0.0;
+      double F_err_est = 0.0;
+      const double h = 1.0 / n_samp;
+
+      const DoFHandler<dim> &dof_handler = this->get_dof_handler();
+      const FiniteElement<dim> &finite_element = this->get_fe();
+      const unsigned int dofs_per_cell = finite_element.dofs_per_cell;
+      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
+
+      const QIterated<dim> quadrature (QMidpoint<1>(), n_samp);
+      FEValues<dim> fe_err (this->get_mapping(), finite_element, quadrature,
+                            update_JxW_values |
+                            update_quadrature_points);
+
+      const unsigned int volume_of_fluid_index = this->get_volume_of_fluid_handler().field_struct_for_field_index(f_ind)
+                                                 .volume_fraction.first_component_index;
+      const unsigned int volume_of_fluidN_c_index = this->get_volume_of_fluid_handler().field_struct_for_field_index(f_ind)
+                                                    .reconstruction.first_component_index;
+
+      // Compare computed solution to reinit using provided function
+      for (auto cell : dof_handler.active_cell_iterators ())
+        {
+          if (!cell->is_locally_owned ())
+            continue;
+
+          // Obtain data for this cell
+          cell->get_dof_indices (local_dof_indices);
+          Tensor<1, dim, double> normal;
+          for (unsigned int i=0; i<dim; ++i)
+            normal[i] = solution(local_dof_indices[finite_element.component_to_system_index(volume_of_fluidN_c_index+i, 0)]);
+          const double d_compute = solution(local_dof_indices[finite_element.component_to_system_index(volume_of_fluidN_c_index+dim, 0)]);
+          const double cell_volume_of_fluid = solution(local_dof_indices[finite_element.component_to_system_index(volume_of_fluid_index, 0)]);
+
+          // Calculate approximation for volume
+          fe_err.reinit (cell);
+
+          const double cell_vol = cell->measure ();
+          const double cell_diam = cell->diameter();
+          const double d_true = func.value(cell->barycenter(), f_ind);
+          double nnorm1 = 0;
+          for (unsigned int i = 0; i < dim; ++i)
+            {
+              nnorm1 += abs (normal[i]);
+            }
+
+          if (abs (d_compute) >= 0.5 * nnorm1 &&
+              abs (d_true) >= 0.5 * cell_diam &&
+              d_compute * d_true >= 0.0)
+            {
+              continue;
+            }
+
+          double val = 0.0;
+          double volume_of_fluid_reinit = 0.0;
+          for (unsigned int i = 0; i < fe_err.n_quadrature_points; ++i)
+            {
+              double d_t = 0.0;
+              Tensor<1, dim, double> grad_t;
+              Point<dim> xU = quadrature.point (i);
+              for (unsigned int di = 0; di < dim; ++di)
+                {
+                  Point<dim> xH = xU;
+                  Point<dim> xL = xU;
+                  xH[di] += 0.5 * h;
+                  xL[di] -= 0.5 * h;
+                  const double dH = func.value(cell->intermediate_point(xH), f_ind);
+                  const double dL = func.value(cell->intermediate_point(xL), f_ind);
+                  grad_t[di] = (dL - dH);
+                  d_t += (0.5 / dim) * (dH + dL);
+                }
+              const double solution_fluid_fraction_at_point = VolumeOfFluid::Utilities::compute_fluid_fraction (grad_t, d_t);
+              volume_of_fluid_reinit += solution_fluid_fraction_at_point*(fe_err.JxW (i) / cell_vol);
+              for (unsigned int di = 0; di < dim; ++di)
+                {
+                  xU[di] -= 0.5;
+                }
+              const double dot = normal * xU;
+              const double computed_fluid_fraction_at_point = VolumeOfFluid::Utilities::compute_fluid_fraction (h * normal,
+                                                              (d_compute - dot));
+              const double diff = abs (solution_fluid_fraction_at_point - computed_fluid_fraction_at_point);
+              val += diff * fe_err.JxW (i);
+            }
+          I_err_est += val;
+          F_err_est += abs (cell_volume_of_fluid - volume_of_fluid_reinit) * cell_vol;
+        }
+
+      std::vector<double> errors(1, I_err_est);
+      errors.push_back (F_err_est);
+      return errors;
+    }
+  }
+}
+
+
+// explicit instantiations
+namespace aspect
+{
+  namespace Postprocess
+  {
+    ASPECT_REGISTER_POSTPROCESSOR(VolumeOfFluidSpecifiedSolutionDiff,
+                                  "volume of fluid mms",
+                                  "A postprocessor that approximates the interface error.")
+  }
+}
diff --git a/tests/vof_linear.cc.bak b/tests/vof_linear.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_linear.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_linear.prm.bak b/tests/vof_linear.prm.bak
new file mode 100644
index 00000000000..6f4e558e4cf
--- /dev/null
+++ b/tests/vof_linear.prm.bak
@@ -0,0 +1,93 @@
+# Test for linear interface under constant velocity
+# Error should be at machine precision
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.25
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, volume of fluid mms
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 0.25
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+      set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
+    end
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_linear_2f.cc.bak b/tests/vof_linear_2f.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_linear_2f.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_linear_2f.prm.bak b/tests/vof_linear_2f.prm.bak
new file mode 100644
index 00000000000..3ded209c99d
--- /dev/null
+++ b/tests/vof_linear_2f.prm.bak
@@ -0,0 +1,93 @@
+# Test for linear interface under constant velocity
+# Error should be at machine precision
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.5
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+  set Names of fields = F_1, F_2
+  set Compositional field methods = volume of fluid, volume of fluid
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set, F_2:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0_0=1.0, y0_0=0.0, x0_1=0.75, y0_1=0.0, xv=-0.25, yv=-0.25
+    set Function expression = cos(init*pi)*(x-x0_0-xv*t)+sin(init*pi)*(y-y0_0-yv*t);cos(init*pi)*(x-x0_1-xv*t)+sin(init*pi)*(y-y0_1-yv*t)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, volume of fluid statistics, volume of fluid mms
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 0.25
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = init=1.25, x0_0=1.0, y0_0=0.0, x0_1=0.75, y0_1=0.0, xv=-0.25, yv=-0.25
+      set Function expression = cos(init*pi)*(x-x0_0-xv*t)+sin(init*pi)*(y-y0_0-yv*t);cos(init*pi)*(x-x0_1-xv*t)+sin(init*pi)*(y-y0_1-yv*t)
+    end
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_linear_amr.cc.bak b/tests/vof_linear_amr.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_linear_amr.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_linear_amr.prm.bak b/tests/vof_linear_amr.prm.bak
new file mode 100644
index 00000000000..0a94eeba27f
--- /dev/null
+++ b/tests/vof_linear_amr.prm.bak
@@ -0,0 +1,95 @@
+# Test for linear interface under constant velocity
+# Error should be at machine precision
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.25
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Minimum refinement level           = 2
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 1
+  set Strategy                           = volume of fluid interface
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, volume of fluid mms, visualization
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 0.25
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+      set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
+    end
+  end
+
+  subsection Visualization
+    set Time between graphical output = 0.2
+    set Interpolate output = false
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_linear_amr_mpi.cc.bak b/tests/vof_linear_amr_mpi.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_linear_amr_mpi.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_linear_amr_mpi.prm.bak b/tests/vof_linear_amr_mpi.prm.bak
new file mode 100644
index 00000000000..5ed24ddb505
--- /dev/null
+++ b/tests/vof_linear_amr_mpi.prm.bak
@@ -0,0 +1,97 @@
+# MPI: 4
+
+# Test for linear interface under constant velocity
+# Error should be at machine precision
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.04
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Minimum refinement level           = 2
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 1
+  set Strategy                           = volume of fluid interface
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, volume of fluid mms
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 0.25
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+      set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
+    end
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_linear_inflow.prm.bak b/tests/vof_linear_inflow.prm.bak
new file mode 100644
index 00000000000..abfcea3eb64
--- /dev/null
+++ b/tests/vof_linear_inflow.prm.bak
@@ -0,0 +1,86 @@
+# Debugging inflow boundary condition
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.03125
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = if(y<=0.5,1,0)
+  end
+end
+
+# Composition boundary conditions
+subsection Boundary composition model
+  set List of model names = initial composition
+  set Fixed composition boundary indicators   = bottom, top, left, right
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = 0;1
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_linear_periodic.cc.bak b/tests/vof_linear_periodic.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_linear_periodic.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_linear_periodic.prm.bak b/tests/vof_linear_periodic.prm.bak
new file mode 100644
index 00000000000..5110f35c30e
--- /dev/null
+++ b/tests/vof_linear_periodic.prm.bak
@@ -0,0 +1,94 @@
+# Test for linear interface under constant velocity
+# Error should be at machine precision
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 4
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 0
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Y periodic = true
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
+    set Function expression = cos(init*pi)*(x-x0)+sin(init*pi)*(y-y0)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, volume of fluid mms
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 4.0
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
+      set Function expression = cos(init*pi)*(x-x0)+sin(init*pi)*(y-y0)
+    end
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_linear_periodic_amr.cc.bak b/tests/vof_linear_periodic_amr.cc.bak
new file mode 100644
index 00000000000..279f80158ec
--- /dev/null
+++ b/tests/vof_linear_periodic_amr.cc.bak
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+// Use vof error estimator
+
+#include "vof_err_calc.h"
diff --git a/tests/vof_linear_periodic_amr.prm.bak b/tests/vof_linear_periodic_amr.prm.bak
new file mode 100644
index 00000000000..4befddeb052
--- /dev/null
+++ b/tests/vof_linear_periodic_amr.prm.bak
@@ -0,0 +1,96 @@
+# Test for linear interface under constant velocity
+# Error should be at machine precision
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0.1
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Minimum refinement level           = 2
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 3
+  set Time steps between mesh refinement = 1
+  set Strategy                           = volume of fluid interface
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Y periodic = true
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
+    set Function expression = cos(init*pi)*(x-x0)+sin(init*pi)*(y-y0)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics, volume of fluid mms
+
+  subsection VoF MMS
+    set Number error samples = 16
+    set Time between error estimates = 4.0
+
+    subsection True LS
+      set Variable names = x,y,t
+      set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
+      set Function expression = cos(init*pi)*(x-x0)+sin(init*pi)*(y-y0)
+    end
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 0.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/vof_mpi_amr_no_dof.prm.bak b/tests/vof_mpi_amr_no_dof.prm.bak
new file mode 100644
index 00000000000..b2f03d72562
--- /dev/null
+++ b/tests/vof_mpi_amr_no_dof.prm.bak
@@ -0,0 +1,85 @@
+# MPI: 4
+
+# Test for linear interface under constant velocity
+# Error should be at machine precision
+
+set Dimension                              = 2
+set Start time                             = 0
+set End time                               = 0
+set Use years in output instead of seconds = false
+set CFL number                             = 0.5
+set Output directory                       = output
+set Nonlinear solver scheme                   = single Advection, no Stokes
+
+subsection Volume of Fluid
+  set Number initialization samples = 16
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+  set Names of fields = F_1
+  set Compositional field methods = volume of fluid
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 1
+  set Initial global refinement          = 1
+  set Time steps between mesh refinement = 0
+  set Strategy                           = volume of fluid interface
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+  end
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+end
+
+subsection Initial composition model
+  set List of model names = function
+  set Volume of fluid initialization type = F_1:level set
+
+  subsection Function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
+  end
+end
+
+subsection Prescribed Stokes solution
+  set Model name = function
+
+  subsection Velocity function
+    set Variable names = x,y,t
+    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
+    set Function expression = xv;yv
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = volume of fluid statistics
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1.0
+    set List of output variables = volume of fluid values
+
+    subsection Volume of Fluid
+      set Output interface reconstruction contour = true
+    end
+  end
+end
diff --git a/tests/walltime.prm.bak b/tests/walltime.prm.bak
new file mode 100644
index 00000000000..aa0a32698c3
--- /dev/null
+++ b/tests/walltime.prm.bak
@@ -0,0 +1,64 @@
+# Tests whether the 'wall time' termination criteria work OK on a
+# minimal problem
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 1e9
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 3.3
+    set Y extent = 2.2
+    set Z extent = 1.1
+    set Box origin X coordinate = -1.9
+    set Box origin Y coordinate = 2.5
+    set Box origin Z coordinate = 3.1
+  end
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 1
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 1
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 1
+  set Zero velocity boundary indicators       = 0, 2, 3
+end
+
+subsection Termination criteria
+  set Termination criteria      = wall time
+  set Wall time                 = 0
+end
diff --git a/tests/weighted_p_norm_average.cc.bak b/tests/weighted_p_norm_average.cc.bak
new file mode 100644
index 00000000000..17f8803c8d0
--- /dev/null
+++ b/tests/weighted_p_norm_average.cc.bak
@@ -0,0 +1,46 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+//#include <aspect/simulator.h>
+//#include <aspect/geometry_model/initial_topography_model/interface.h>
+//#include <aspect/geometry_model/initial_topography_model/prm_polygon.h>
+//#include <aspect/simulator_access.h>
+#include <aspect/utilities.h>
+
+//#include <iostream>
+//
+int f()
+{
+  using namespace aspect;
+
+  std::vector<double> weights = {1,1,2,2,3,3};
+  std::vector<double> values = {6,5,4,3,2,1};
+  std::vector<double> p_norms = {-1000,-2.5,-2,-1,0,1,2,2.5,3,4,1000};
+
+  for (unsigned int i = 0; i < p_norms.size(); i++)
+    {
+      std::cout << "p = " << p_norms[i] << ", average = " << aspect::Utilities::weighted_p_norm_average(weights,values,p_norms[i]) << std::endl;
+    }
+
+  exit(0);
+  return 42;
+}
+// run this function by initializing a global variable by it
+int i = f();
diff --git a/tests/world_builder_select_composition.prm.bak b/tests/world_builder_select_composition.prm.bak
new file mode 100644
index 00000000000..0e98ebd4582
--- /dev/null
+++ b/tests/world_builder_select_composition.prm.bak
@@ -0,0 +1,69 @@
+# Enable if: ASPECT_WITH_WORLD_BUILDER
+# This test is a copy of world_builder_simple.prm and checks that we can select
+# a subset of compositions for which to evaluate the world builder.
+
+set World builder file                     = $ASPECT_SOURCE_DIR/tests/world_builder_select_composition.wb
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature = 1613
+set End time = 0
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Function expression = if(x > 1500000,1.0,0.0);0.0;0.0
+    set Composition reference profile = function
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = 1
+  set Tangential velocity boundary indicators = 0, 2, 3
+end
+
+subsection Compositional fields
+  set Number of fields = 3
+  set Names of fields = Crust, Lithosphere, Continent
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1500e3
+    set Y extent = 200e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = world builder
+end
+
+subsection Initial composition model
+  set List of model names = world builder
+
+  subsection World builder
+    set List of relevant compositions = Crust
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference temperature = 1613
+    set Viscosity = 1e21
+    set Thermal conductivity = 1e-06
+    set Density differential for compositional field 1 = 500
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 5
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics
+end
diff --git a/tests/world_builder_select_grains.prm.bak b/tests/world_builder_select_grains.prm.bak
new file mode 100644
index 00000000000..c8e434dd8cd
--- /dev/null
+++ b/tests/world_builder_select_grains.prm.bak
@@ -0,0 +1,95 @@
+# Enable if: ASPECT_WITH_WORLD_BUILDER
+# This test is a copy of world_builder_simple.prm and checks that we can select
+# a subset of grains for which to evaluate the world builder.
+
+include $ASPECT_SOURCE_DIR/tests/world_builder_select_composition.prm
+
+set World builder file                     = $ASPECT_SOURCE_DIR/tests/world_builder_select_grains.wb
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature = 1613
+set End time = 0
+set Dimension = 3
+set Nonlinear solver scheme = no Advection, no Stokes
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1000e3
+    set Y extent = 200e3
+    set Z extent = 200e3
+    set Box origin Z coordinate = -200e3
+    set Box origin Y coordinate = -100e3
+    set Box origin X coordinate = -50e3
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference temperature = 1613
+    set Viscosity = 1e21
+    set Thermal conductivity = 1e-06
+    set Density differential for compositional field 1 = 500
+  end
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 5
+end
+
+subsection Postprocess
+  set List of postprocessors = composition statistics, visualization, particles, crystal preferred orientation
+
+  subsection Crystal Preferred Orientation
+    set Time between data output = 1e6
+    set Write in background thread = true
+    set Compress cpo data files = false
+    set Write out raw cpo data = mineral 0: volume fraction, mineral 0: rotation matrix, mineral 1: volume fraction, mineral 1: rotation matrix
+    set Write out draw volume weighted cpo data = mineral 0: volume fraction, mineral 0: rotation matrix, mineral 1: volume fraction, mineral 1: rotation matrix
+  end
+
+  subsection Particles
+    set Time between data output = 1e6
+    set Data output format       = gnuplot
+    set Exclude output properties = a_cosine_matrix, volume fraction
+  end
+end
+
+subsection Particles
+  set List of particle properties = integrated strain invariant, crystal preferred orientation, cpo bingham average, cpo elastic tensor, elastic tensor decomposition
+  set Particle generator name = random uniform
+
+  subsection Crystal Preferred Orientation
+    set Random number seed = 301
+    set Number of grains per particle = 5
+    set Property advection method = Backward Euler
+    set Property advection tolerance = 1e-15
+    set CPO derivatives algorithm = D-Rex 2004
+
+    subsection Initial grains
+      set Model name = World Builder
+      set Minerals = Olivine: A-fabric , Enstatite
+      set Volume fractions minerals = 1.0,0.0
+    end
+
+    subsection D-Rex 2004
+      set Mobility = 125
+      set Stress exponents = 3.5
+      set Exponents p = 1.5
+      set Nucleation efficiency = 5
+      set Threshold GBS = 0.3
+    end
+  end
+
+  subsection CPO Bingham Average
+    set Random number seed = 200
+  end
+
+  subsection Generator
+    subsection Probability density function
+      set Number of particles = 50
+    end
+  end
+end
diff --git a/tests/world_builder_simple.prm.bak b/tests/world_builder_simple.prm.bak
new file mode 100644
index 00000000000..8f7e93e98fb
--- /dev/null
+++ b/tests/world_builder_simple.prm.bak
@@ -0,0 +1,70 @@
+# Enable if: ASPECT_WITH_WORLD_BUILDER
+# This test uses the Geodynamic World Builder to create
+# initial temperatures and compositions
+
+set World builder file                     = $ASPECT_SOURCE_DIR/tests/world_builder_simple.wb
+set Use years in output instead of seconds = false
+set Adiabatic surface temperature = 1613
+set End time = 0
+
+subsection Adiabatic conditions model
+  subsection Compute profile
+    set Function expression = if(x > 1500000,1.0,0.0)
+    set Composition reference profile = function
+  end
+end
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = 1
+  set Tangential velocity boundary indicators = 0, 2, 3
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 5
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Output format = gnuplot
+    set Interpolate output = false
+    set List of output variables = adiabat
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 1
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference temperature = 1613
+    set Viscosity = 1e21
+    set Thermal conductivity = 1e-06
+    set Density differential for compositional field 1 = 500
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1500e3
+    set Y extent = 200e3
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = world builder
+end
+
+subsection Initial composition model
+  set List of model names = world builder
+end
diff --git a/tests/world_builder_simple_2d_cartesian_sticky_air.prm.bak b/tests/world_builder_simple_2d_cartesian_sticky_air.prm.bak
new file mode 100644
index 00000000000..f781e5b4f35
--- /dev/null
+++ b/tests/world_builder_simple_2d_cartesian_sticky_air.prm.bak
@@ -0,0 +1,71 @@
+# Enable if: ASPECT_WITH_WORLD_BUILDER
+set Nonlinear solver scheme = no Advection, no Stokes
+set World builder file                     = $ASPECT_SOURCE_DIR/tests/world_builder_simple_2d_cartesian_sticky_air.wb
+set Use years in output instead of seconds = false
+set Output directory = wbdir3
+set Adiabatic surface temperature = 1613
+set End time = 0
+
+subsection Boundary velocity model
+  set Zero velocity boundary indicators = 1
+  set Tangential velocity boundary indicators = 0, 2, 3
+end
+
+subsection Mesh refinement
+  set Initial global refinement = 4
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization
+
+  subsection Visualization
+    set Interpolate output = false
+    set List of output variables = adiabat
+    set Output format = gnuplot
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 7
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference temperature = 1613
+    set Viscosity = 1e21
+    set Thermal conductivity = 1e-06
+    set Density differential for compositional field 1 = 500
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 500e3
+    set Y extent = 800e3
+  end
+
+  subsection Initial topography model
+    set Model name = function
+
+    subsection Function
+      set Function expression = 100e3
+      set Maximum topography value = 100e3
+    end
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = world builder
+end
+
+subsection Initial composition model
+  set List of model names = world builder
+end
diff --git a/tests/write_plugin_graph.cc.bak b/tests/write_plugin_graph.cc.bak
new file mode 100644
index 00000000000..ca9e8a86bfc
--- /dev/null
+++ b/tests/write_plugin_graph.cc.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <aspect/material_model/interface.h>
+#include <aspect/simulator.h>
+#include <aspect/simulator_signals.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+
+using namespace aspect;
+
+
+template <int dim>
+void post_constraints_creation (const SimulatorAccess<dim> &sim,
+                                AffineConstraints<double> &)
+{
+  static bool first = true;
+  if (first)
+    {
+      std::stringstream ss;
+      sim.get_simulator().write_plugin_graph(ss);
+      std::string content = ss.str();
+
+      const char *checks[] =
+      {
+        "digraph Plugins",
+        "label=\"TestMaterial\"",
+        "N6aspect12TestMaterialILi2EEE -> N6aspect13MaterialModel9InterfaceILi2EEE",
+        "label=\"simpler\"",
+        "Simulator -> SimulatorAccess",
+        "N6aspect19BoundaryComposition9AsciiDataILi2EEE [label=\"ascii data\""
+      };
+
+      for (unsigned int i = 0; i < sizeof(checks)/sizeof(checks[0]); ++i)
+        {
+          bool found = content.find(checks[i])!=std::string::npos;
+
+          if (found)
+            std::cout << "found " << checks[i] << std::endl;
+          Assert(found, ExcInternalError());
+        }
+
+    }
+  first = false;
+}
+
+
+template <int dim>
+void signal_connector (SimulatorSignals<dim> &signals)
+{
+  signals.post_constraints_creation.connect (&post_constraints_creation<dim>);
+}
+
+
+ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
+                                  signal_connector<3>)
+
+
+// make a dummy material model and instantiate and register it
+namespace aspect
+{
+  template <int dim>
+  class TestMaterial : public MaterialModel::Interface<dim>
+  {
+    public:
+      virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
+                            MaterialModel::MaterialModelOutputs<dim> &out) const
+      {}
+
+      virtual bool is_compressible () const
+      {
+        return false;
+      }
+  };
+
+
+  ASPECT_REGISTER_MATERIAL_MODEL(TestMaterial,
+                                 "TestMaterial",
+                                 "A material model.")
+}
diff --git a/tests/write_plugin_graph.prm.bak b/tests/write_plugin_graph.prm.bak
new file mode 100644
index 00000000000..ef203ef9686
--- /dev/null
+++ b/tests/write_plugin_graph.prm.bak
@@ -0,0 +1,76 @@
+# a test that write the plugin graph
+
+
+set Dimension = 2
+set CFL number                             = 1.0
+set End time                               = 0
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 0, 1
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = perturbed box
+end
+
+subsection Material model
+  set Model name = simple
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 2
+  set Strategy                           = density, temperature
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Postprocess
+  set List of postprocessors =
+
+  subsection Depth average
+    set Time between graphical output = 1e8
+  end
+
+  subsection Visualization
+    set Interpolate output = false
+    set Number of grouped files       = 0
+    set Output format                 = gnuplot
+    set Time between graphical output = 0
+  end
+end
diff --git a/tests/zero_RHS.prm.bak b/tests/zero_RHS.prm.bak
new file mode 100644
index 00000000000..735e10ead1b
--- /dev/null
+++ b/tests/zero_RHS.prm.bak
@@ -0,0 +1,120 @@
+# This is a test for models where the right-hand side of
+# the temperature or composition system is zero (i.e., the field
+# is zero, and there are no boundary conditions/additional RHS
+# terms).
+# In this case, the solver scheme should skip solving this
+# field.
+
+set Dimension = 2
+set End time                               = 2e5
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+# Here we specify that the model has fixed temperature
+# boundary conditions, as well as free slip boundary
+# conditions for the sides and bottom.
+
+subsection Boundary temperature model
+  set List of model names = constant
+  set Fixed temperature boundary indicators   = left, right, bottom, top
+
+  subsection Constant
+    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
+  end
+end
+
+subsection Discretization
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100.e2
+    set Y extent = 1000.e2
+    set X repetitions = 10
+    set Y repetitions = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0; if(y>500e2,1,0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density             = 3300
+    set Reference specific heat       = 0.0
+    set Thermal conductivity          = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Viscosity                     = 1.e20
+    set Reference compressibility     = 1e-11
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.0;-0.01
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics,
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1
+    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+  end
+end
diff --git a/tests/zero_matrix.prm.bak b/tests/zero_matrix.prm.bak
new file mode 100644
index 00000000000..ca072372776
--- /dev/null
+++ b/tests/zero_matrix.prm.bak
@@ -0,0 +1,115 @@
+# This is a test for models where matrix of
+# the temperature or composition system is zero (i.e., the field
+# is zero, but there are non-zero RHS terms).
+# In this case, the solver should throw an exception.
+#
+# EXPECT FAILURE
+
+set Dimension = 2
+set End time                               = 2e5
+set Nonlinear solver scheme                = single Advection, iterated Stokes
+set Pressure normalization                 = surface
+set Surface pressure                       = 0
+set Use years in output instead of seconds = true
+
+subsection Heating model
+  set List of model names = constant heating
+
+  subsection Constant heating
+    set Radiogenic heating rate = 1
+  end
+end
+
+subsection Compositional fields
+  set Number of fields = 2
+end
+
+subsection Discretization
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 100.e2
+    set Y extent = 1000.e2
+    set X repetitions = 10
+    set Y repetitions = 100
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+
+  subsection Vertical
+    set Magnitude = 10
+  end
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Initial composition model
+  set Model name = function
+
+  subsection Function
+    set Function expression = 0.0; if(y>500e2,1,0)
+    set Variable names      = x,y
+  end
+end
+
+subsection Material model
+  set Model name = simple compressible
+
+  subsection Simple compressible model
+    set Reference density             = 3300
+    set Reference specific heat       = 0.0
+    set Thermal conductivity          = 0.0
+    set Thermal expansion coefficient = 0.0
+    set Viscosity                     = 1.e20
+    set Reference compressibility     = 1e-11
+  end
+end
+
+subsection Mesh refinement
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 0
+  set Time steps between mesh refinement = 0
+end
+
+subsection Boundary velocity model
+  set Prescribed velocity boundary indicators = bottom:function
+  set Tangential velocity boundary indicators = left, right
+
+  subsection Function
+    set Variable names      = x,y
+    set Function expression = 0.0;-0.01
+  end
+end
+
+subsection Postprocess
+  set List of postprocessors = visualization,velocity statistics,
+
+  subsection Visualization
+    set Interpolate output = false
+    set Time between graphical output = 1
+    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
+
+    subsection Material properties
+      set List of material properties = density, viscosity, thermal expansivity, reaction terms
+    end
+  end
+end
diff --git a/tests/zero_temperature.prm.bak b/tests/zero_temperature.prm.bak
new file mode 100644
index 00000000000..075891af908
--- /dev/null
+++ b/tests/zero_temperature.prm.bak
@@ -0,0 +1,94 @@
+# derived from diffusion.prm. we have no velocity here, and the temperature
+# boundary values are all zero as well, so there is nothing really to do.
+# check that this works.
+
+set Dimension = 2
+set CFL number                             = 1
+set End time                               = 1
+set Resume computation                     = false
+set Start time                             = 0
+set Adiabatic surface temperature          = 0
+set Surface pressure                       = 0
+set Use years in output instead of seconds = false
+set Nonlinear solver scheme                = single Advection, single Stokes
+
+subsection Boundary temperature model
+  set List of model names = box
+  set Fixed temperature boundary indicators   = 2, 3
+
+  subsection Box
+    set Bottom temperature = 0
+    set Top temperature    = 0
+  end
+end
+
+subsection Discretization
+  set Stokes velocity polynomial degree       = 2
+  set Temperature polynomial degree           = 2
+  set Use locally conservative discretization = false
+
+  subsection Stabilization parameters
+    set alpha = 2
+    set beta  = 0.078
+    set cR    = 0.5
+  end
+end
+
+subsection Geometry model
+  set Model name = box
+
+  subsection Box
+    set X extent = 1
+    set Y extent = 1
+    set Z extent = 1
+  end
+end
+
+subsection Gravity model
+  set Model name = vertical
+end
+
+subsection Initial temperature model
+  set Model name = function
+
+  subsection Function
+    set Variable names = x,y
+    set Function expression = 0.0
+  end
+end
+
+subsection Material model
+  set Model name = simple
+
+  subsection Simple model
+    set Reference density             = 1
+    set Reference specific heat       = 1250
+    set Reference temperature         = 0
+    set Thermal conductivity          = 1e-6
+    set Thermal expansion coefficient = 2e-5
+    set Viscosity                     = 1
+  end
+end
+
+subsection Mesh refinement
+  set Additional refinement times        =
+  set Initial adaptive refinement        = 0
+  set Initial global refinement          = 5
+  set Refinement fraction                = 0.3
+  set Coarsening fraction                = 0.05
+  set Strategy                           = thermal energy density
+  set Time steps between mesh refinement = 5
+end
+
+subsection Boundary velocity model
+  set Tangential velocity boundary indicators = 0,1,2,3
+end
+
+subsection Checkpointing
+  set Time between checkpoint                = 0
+  set Steps between checkpoint               = 50
+end
+
+subsection Postprocess
+  set List of postprocessors = temperature statistics
+end
diff --git a/unit_tests/additional_outputs.cc.bak b/unit_tests/additional_outputs.cc.bak
new file mode 100644
index 00000000000..8eb691ccb58
--- /dev/null
+++ b/unit_tests/additional_outputs.cc.bak
@@ -0,0 +1,98 @@
+/*
+  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <aspect/utilities.h>
+
+// A test that simply verifies that the additional material
+// model outputs can be accessed.
+
+#include <aspect/simulator.h>
+#include <deal.II/grid/tria.h>
+#include <aspect/material_model/simple.h>
+#include <aspect/simulator_access.h>
+
+#include <iostream>
+
+namespace
+{
+  using namespace dealii;
+  using namespace aspect;
+
+  template <int dim>
+  class AdditionalOutputs1 : public MaterialModel::AdditionalMaterialOutputs<dim>
+  {
+    public:
+      AdditionalOutputs1 (const unsigned int n_points,
+                          const unsigned int /*n_comp*/)
+      {
+        additional_material_output1.resize(n_points);
+      }
+
+      std::vector<double> additional_material_output1;
+  };
+
+
+  template <int dim>
+  class Material1 : public MaterialModel::Simple<dim>
+  {
+    public:
+
+      void evaluate(const MaterialModel::MaterialModelInputs<dim> &/*in*/,
+                    MaterialModel::MaterialModelOutputs<dim> &out) const override
+      {
+        AdditionalOutputs1<dim> *additional;
+
+        additional = out.template get_additional_output<AdditionalOutputs1<dim>>();
+        additional->additional_material_output1[0] = 42.0;
+      }
+  };
+}
+
+
+TEST_CASE("AdditionalOutputs works")
+{
+  const int dim=2;
+
+  using namespace aspect::MaterialModel;
+  MaterialModelInputs<dim> in(1,1);
+  MaterialModelOutputs<dim> out(1,1);
+  in.requested_properties = MaterialProperties::additional_outputs;
+
+
+  REQUIRE(out.get_additional_output<AdditionalOutputs1<dim>>() == nullptr);
+
+  out.additional_outputs.push_back(std::make_unique<AdditionalOutputs1<dim>> (1, 1));
+
+  REQUIRE(out.get_additional_output<AdditionalOutputs1<dim>>() != nullptr);
+
+  Material1<dim> mat;
+  mat.evaluate(in, out);
+
+  REQUIRE(out.get_additional_output<AdditionalOutputs1<dim>>()->additional_material_output1[0] == 42.0);
+
+  // test const version of get_additional_output:
+  {
+    const MaterialModelOutputs<dim> &const_out = out;
+    REQUIRE(const_out.get_additional_output<AdditionalOutputs1<dim>>() != nullptr);
+    const AdditionalOutputs1<dim> *a = const_out.get_additional_output<AdditionalOutputs1<dim>>();
+    REQUIRE(a != nullptr);
+  }
+}
diff --git a/unit_tests/common.h.bak b/unit_tests/common.h.bak
new file mode 100644
index 00000000000..ebeb0b22555
--- /dev/null
+++ b/unit_tests/common.h.bak
@@ -0,0 +1,67 @@
+/*
+  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef _aspect_unit_tests_common_h
+#define _aspect_unit_tests_common_h
+
+#include <catch.hpp>
+
+#include <deal.II/base/table.h>
+
+
+using Catch::Matchers::Contains;
+using Catch::Matchers::StartsWith;
+
+/**
+ * Compare the given two std::vector<double> entries with an epsilon (using Catch::Approx)
+ */
+inline void compare_vectors_approx(
+  const std::vector<double> &computed,
+  const std::vector<double> &expected)
+{
+  REQUIRE(computed.size() == expected.size());
+  for (unsigned int i=0; i<computed.size(); ++i)
+    {
+      INFO("array index i=" << i << ": ");
+      REQUIRE(computed[i] == Approx(expected[i]));
+    }
+}
+
+/**
+ * Compare the given two table entries with an epsilon (using Catch::Approx)
+ */
+inline void compare_tables_approx(
+  const dealii::Table<2,double> &computed,
+  const dealii::Table<2,double> &expected)
+{
+  REQUIRE(computed.size() == expected.size());
+
+  for (unsigned int i=0; i<computed.n_rows(); ++i)
+    {
+      for (unsigned int j=0; j<computed.n_cols(); ++j)
+        {
+          INFO("array index i,j=" << i << ',' << j << ": ");
+          REQUIRE(computed[i][j] == Approx(expected[i][j]));
+        }
+    }
+}
+
+#endif
diff --git a/unit_tests/crystal_preferred_orientation.cc.bak b/unit_tests/crystal_preferred_orientation.cc.bak
new file mode 100644
index 00000000000..d379e32bb63
--- /dev/null
+++ b/unit_tests/crystal_preferred_orientation.cc.bak
@@ -0,0 +1,2309 @@
+/*
+  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <aspect/particle/property/elastic_tensor_decomposition.h>
+#include <aspect/particle/property/crystal_preferred_orientation.h>
+#include <aspect/particle/property/cpo_elastic_tensor.h>
+#include <deal.II/base/parameter_handler.h>
+#include <aspect/utilities.h>
+
+
+/**
+ * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
+ */
+inline void compare_3d_arrays_approx(
+  const std::array<double,3> &computed,
+  const std::array<double,3> &expected)
+{
+  CHECK(computed.size() == expected.size());
+  for (unsigned int i=0; i< computed.size(); ++i)
+    {
+      INFO("vector index i=" << i << ": ");
+      CHECK(computed[i] == Approx(expected[i]));
+    }
+}
+
+
+/**
+ * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
+ */
+inline void compare_3d_arrays_approx(
+  const std::vector<double> &computed,
+  const std::vector<double> &expected)
+{
+  CHECK(computed.size() == expected.size());
+  for (unsigned int i=0; i< computed.size(); ++i)
+    {
+      INFO("vector index i=" << i << ": ");
+      CHECK(computed[i] == Approx(expected[i]));
+    }
+}
+
+
+/**
+ * Compare two rotation matrices
+ */
+inline void compare_rotation_matrices_approx(
+  const std::array<std::array<double,3>,3> &computed,
+  const std::array<std::array<double,3>,3> &expected)
+{
+  // sign of eigenvector is not important
+  INFO("rotation matrices are not the same: \n" <<
+       "expected = " << expected[0][0] << " " << expected[0][1] << " " << expected[0][2] << "\n" <<
+       "           " << expected[1][0] << " " << expected[1][1] << " " << expected[1][2] << "\n" <<
+       "           " << expected[2][0] << " " << expected[2][1] << " " << expected[2][2] << "\n" <<
+       "computed = " << computed[0][0] << " " << computed[0][1] << " " << computed[0][2] << "\n" <<
+       "           " << computed[1][0] << " " << computed[1][1] << " " << computed[1][2] << "\n" <<
+       "           " << computed[2][0] << " " << computed[2][1] << " " << computed[2][2] << "\n" );
+  CHECK((
+          (computed[0][0] == Approx(expected[0][0]) && computed[0][1] == Approx(expected[0][1]) && computed[0][2] == Approx(expected[0][2]) &&
+           computed[1][0] == Approx(expected[1][0]) && computed[1][1] == Approx(expected[1][1]) && computed[1][2] == Approx(expected[1][2]) &&
+           computed[2][0] == Approx(expected[2][0]) && computed[2][1] == Approx(expected[2][1]) && computed[2][2] == Approx(expected[2][2]))
+          ||
+          (computed[0][0] == Approx(-expected[0][0]) && computed[0][1] == Approx(-expected[0][1]) && computed[0][2] == Approx(-expected[0][2]) &&
+           computed[1][0] == Approx(-expected[1][0]) && computed[1][1] == Approx(-expected[1][1]) && computed[1][2] == Approx(-expected[1][2]) &&
+           computed[2][0] == Approx(-expected[2][0]) && computed[2][1] == Approx(-expected[2][1]) && computed[2][2] == Approx(-expected[2][2]))));
+}
+
+/**
+ * Compare two rotation matrices
+ */
+inline void compare_rotation_matrices_approx(
+  const dealii::Tensor<2,3> &computed,
+  const dealii::Tensor<2,3> &expected)
+{
+  // sign of eigenvector is not important
+  INFO("rotation matrices are not the same: \n" <<
+       "expected = " << expected[0][0] << " " << expected[0][1] << " " << expected[0][2] << "\n" <<
+       "           " << expected[1][0] << " " << expected[1][1] << " " << expected[1][2] << "\n" <<
+       "           " << expected[2][0] << " " << expected[2][1] << " " << expected[2][2] << "\n" <<
+       "computed = " << computed[0][0] << " " << computed[0][1] << " " << computed[0][2] << "\n" <<
+       "           " << computed[1][0] << " " << computed[1][1] << " " << computed[1][2] << "\n" <<
+       "           " << computed[2][0] << " " << computed[2][1] << " " << computed[2][2] << "\n" );
+  const double tol = 1e-14;
+  CHECK((
+          ((computed[0][0] == Approx(expected[0][0]) || std::fabs(computed[0][0]) < tol)
+           && (computed[0][1] == Approx(expected[0][1]) || std::fabs(computed[0][1]) < tol)
+           && (computed[0][2] == Approx(expected[0][2]) || std::fabs(computed[0][2]) < tol)
+           && (computed[1][0] == Approx(expected[1][0]) || std::fabs(computed[1][0]) < tol)
+           && (computed[1][1] == Approx(expected[1][1]) || std::fabs(computed[1][1]) < tol)
+           && (computed[1][2] == Approx(expected[1][2]) || std::fabs(computed[1][2]) < tol)
+           && (computed[2][0] == Approx(expected[2][0]) || std::fabs(computed[2][0]) < tol)
+           && (computed[2][1] == Approx(expected[2][1]) || std::fabs(computed[2][1]) < tol)
+           && (computed[2][2] == Approx(expected[2][2]) || std::fabs(computed[2][2]) < tol))
+          ||
+          ((computed[0][0] == Approx(-expected[0][0]) || std::fabs(computed[0][0]) < tol)
+           && (computed[0][1] == Approx(-expected[0][1]) || std::fabs(computed[0][1]) < tol)
+           && (computed[0][2] == Approx(-expected[0][2]) || std::fabs(computed[0][2]) < tol)
+           && (computed[1][0] == Approx(-expected[1][0]) || std::fabs(computed[1][0]) < tol)
+           && (computed[1][1] == Approx(-expected[1][1]) || std::fabs(computed[1][1]) < tol)
+           && (computed[1][2] == Approx(-expected[1][2]) || std::fabs(computed[1][2]) < tol)
+           && (computed[2][0] == Approx(-expected[2][0]) || std::fabs(computed[2][0]) < tol)
+           && (computed[2][1] == Approx(-expected[2][1]) || std::fabs(computed[2][1]) < tol)
+           && (computed[2][2] == Approx(-expected[2][2]) || std::fabs(computed[2][2]) < tol))));
+}
+
+TEST_CASE("CPO core: Store and Load")
+{
+  // test store and load functions
+  // the first and last element should not be changed, because we start at
+  // data position = 1.
+  aspect::Particle::Property::CrystalPreferredOrientation<3> cpo;
+  aspect::ParameterHandler prm;
+  prm.enter_subsection("Particles");
+  {
+    cpo.declare_parameters(prm);
+    prm.enter_subsection("Crystal Preferred Orientation");
+    {
+      prm.set("Random number seed","1");
+      prm.set("Number of grains per particle","3");
+      prm.set("CPO derivatives algorithm","Spin tensor");
+      prm.set("Property advection method","Backward Euler");
+
+      prm.enter_subsection("Initial grains");
+      {
+        prm.set("Model name","Uniform grains and random uniform rotations");
+        // Let the minerals just passively rotate with the rotation of
+        // the particle caused by the flow.
+        prm.set("Minerals","Passive,Passive");
+        prm.set("Volume fractions minerals","0.7,0.3");
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection ();
+  }
+  prm.leave_subsection ();
+
+  prm.enter_subsection("Particles");
+  {
+    cpo.parse_parameters(prm);
+  }
+  prm.leave_subsection ();
+
+  cpo.initialize();
+
+  unsigned int cpo_data_position = 1;
+  std::vector<double> data_array(70,-1.);
+  dealii::ArrayView<double> data(&data_array[0],70);
+
+  cpo.set_volume_fraction_mineral(cpo_data_position,data,0,0.7);
+  cpo.set_volume_fraction_mineral(cpo_data_position,data,1,0.3);
+
+  using namespace dealii;
+  Tensor<2,3> rotation_matrix;
+  rotation_matrix[TableIndices<2>(0,0)] = 0;
+  rotation_matrix[TableIndices<2>(0,1)] = 1./1000.;
+  rotation_matrix[TableIndices<2>(0,2)] = 2./1000.;
+  rotation_matrix[TableIndices<2>(1,0)] = 3./1000.;
+  rotation_matrix[TableIndices<2>(1,1)] = 4./1000.;
+  rotation_matrix[TableIndices<2>(1,2)] = 5./1000.;
+  rotation_matrix[TableIndices<2>(2,0)] = 6./1000.;
+  rotation_matrix[TableIndices<2>(2,1)] = 7./1000.;
+  rotation_matrix[TableIndices<2>(2,2)] = 8./1000.;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data,0,0,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 9./1000.;
+  rotation_matrix[TableIndices<2>(0,1)] = 10./1000.;
+  rotation_matrix[TableIndices<2>(0,2)] = 11./1000.;
+  rotation_matrix[TableIndices<2>(1,0)] = 12./1000.;
+  rotation_matrix[TableIndices<2>(1,1)] = 13./1000.;
+  rotation_matrix[TableIndices<2>(1,2)] = 14./1000.;
+  rotation_matrix[TableIndices<2>(2,0)] = 15./1000.;
+  rotation_matrix[TableIndices<2>(2,1)] = 16./1000.;
+  rotation_matrix[TableIndices<2>(2,2)] = 17./1000.;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data,0,1,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 18./1000.;
+  rotation_matrix[TableIndices<2>(0,1)] = 19./1000.;
+  rotation_matrix[TableIndices<2>(0,2)] = 20./1000.;
+  rotation_matrix[TableIndices<2>(1,0)] = 21./1000.;
+  rotation_matrix[TableIndices<2>(1,1)] = 22./1000.;
+  rotation_matrix[TableIndices<2>(1,2)] = 23./1000.;
+  rotation_matrix[TableIndices<2>(2,0)] = 24./1000.;
+  rotation_matrix[TableIndices<2>(2,1)] = 25./1000.;
+  rotation_matrix[TableIndices<2>(2,2)] = 26./1000.;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data,0,2,rotation_matrix);
+
+  cpo.set_volume_fractions_grains(cpo_data_position,data,0,0,0.1);
+  cpo.set_volume_fractions_grains(cpo_data_position,data,0,1,0.2);
+  cpo.set_volume_fractions_grains(cpo_data_position,data,0,2,0.3);
+
+
+  rotation_matrix[TableIndices<2>(0,0)] = 27./1000.;
+  rotation_matrix[TableIndices<2>(0,1)] = 28./1000.;
+  rotation_matrix[TableIndices<2>(0,2)] = 29./1000.;
+  rotation_matrix[TableIndices<2>(1,0)] = 30./1000.;
+  rotation_matrix[TableIndices<2>(1,1)] = 31./1000.;
+  rotation_matrix[TableIndices<2>(1,2)] = 32./1000.;
+  rotation_matrix[TableIndices<2>(2,0)] = 33./1000.;
+  rotation_matrix[TableIndices<2>(2,1)] = 34./1000.;
+  rotation_matrix[TableIndices<2>(2,2)] = 35./1000.;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data,1,0,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 36./1000.;
+  rotation_matrix[TableIndices<2>(0,1)] = 37./1000.;
+  rotation_matrix[TableIndices<2>(0,2)] = 38./1000.;
+  rotation_matrix[TableIndices<2>(1,0)] = 39./1000.;
+  rotation_matrix[TableIndices<2>(1,1)] = 40./1000.;
+  rotation_matrix[TableIndices<2>(1,2)] = 41./1000.;
+  rotation_matrix[TableIndices<2>(2,0)] = 42./1000.;
+  rotation_matrix[TableIndices<2>(2,1)] = 43./1000.;
+  rotation_matrix[TableIndices<2>(2,2)] = 44./1000.;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data,1,1,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 45./1000.;
+  rotation_matrix[TableIndices<2>(0,1)] = 46./1000.;
+  rotation_matrix[TableIndices<2>(0,2)] = 47./1000.;
+  rotation_matrix[TableIndices<2>(1,0)] = 48./1000.;
+  rotation_matrix[TableIndices<2>(1,1)] = 49./1000.;
+  rotation_matrix[TableIndices<2>(1,2)] = 50./1000.;
+  rotation_matrix[TableIndices<2>(2,0)] = 51./1000.;
+  rotation_matrix[TableIndices<2>(2,1)] = 52./1000.;
+  rotation_matrix[TableIndices<2>(2,2)] = 53./1000.;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data,1,2,rotation_matrix);
+
+  cpo.set_volume_fractions_grains(cpo_data_position,data,1,0,0.4);
+  cpo.set_volume_fractions_grains(cpo_data_position,data,1,1,0.5);
+  cpo.set_volume_fractions_grains(cpo_data_position,data,1,2,0.6);
+
+  data[0] = 20847932.2;
+  data[65] = 6541684.3;
+
+  cpo.set_deformation_type(cpo_data_position,data,0,aspect::Particle::Property::DeformationType::passive);
+  cpo.set_deformation_type(cpo_data_position,data,1,aspect::Particle::Property::DeformationType::passive);
+
+
+  CHECK(data[0] == Approx(20847932.2)); // before data position
+  // mineral 1
+  CHECK(data[1] ==  Approx(0.0)); // deformation type
+  CHECK(data[2] ==  Approx(0.7)); //Mineral volume fraction
+  CHECK(data[3] ==  Approx(0.1)); // grain 0 volume fraction
+  double counter_rotation = 0.;
+  for (size_t iii = 4; iii < 13; iii++)
+    {
+      CHECK(data[iii] == Approx(counter_rotation));
+      counter_rotation += 1./1000.;
+    }
+  CHECK(data[13] ==  Approx(0.2)); // grain 1 volume fraction
+  for (size_t iii = 14; iii < 23; iii++)
+    {
+      CHECK(data[iii] == Approx(counter_rotation));
+      counter_rotation += 1./1000.;
+    }
+  CHECK(data[23] ==  Approx(0.3)); // grain 2 volume fraction
+  for (size_t iii = 24; iii < 33; iii++)
+    {
+      CHECK(data[iii] == Approx(counter_rotation));
+      counter_rotation += 1./1000.;
+    }
+  // mineral 2
+  CHECK(data[33] ==  Approx(0.0)); // deformation type
+  CHECK(data[34] ==  Approx(0.3)); //Mineral volume fraction
+  CHECK(data[35] ==  Approx(0.4)); // grain 0 volume fraction
+  for (size_t iii = 36; iii < 45; iii++)
+    {
+      CHECK(data[iii] == Approx(counter_rotation));
+      counter_rotation += 1./1000.;
+    }
+  CHECK(data[45] ==  Approx(0.5)); // grain 1 volume fraction
+  for (size_t iii = 46; iii < 55; iii++)
+    {
+      CHECK(data[iii] == Approx(counter_rotation));
+      counter_rotation += 1./1000.;
+    }
+  CHECK(data[55] ==  Approx(0.6)); // grain 2 volume fraction
+  for (size_t iii = 56; iii < 65; iii++)
+    {
+      CHECK(data[iii] == Approx(counter_rotation));
+      counter_rotation += 1./1000.;
+    }
+  CHECK(data[65] == Approx(6541684.3)); // after data position
+  CHECK(data[66] == Approx(-1.0)); // after data position
+
+}
+
+TEST_CASE("CPO core: Spin tensor")
+{
+  using namespace dealii;
+  using namespace aspect;
+
+  {
+    // test initialization in 3d.
+
+    aspect::Particle::Property::CrystalPreferredOrientation<3> cpo_3d;
+    aspect::ParameterHandler prm;
+    prm.enter_subsection("Particles");
+    {
+      cpo_3d.declare_parameters(prm);
+      prm.enter_subsection("Crystal Preferred Orientation");
+      {
+        prm.set("Random number seed","1");
+        prm.set("Number of grains per particle","5");
+        prm.set("CPO derivatives algorithm","Spin tensor");
+        prm.set("Property advection method","Forward Euler");
+        prm.enter_subsection("Initial grains");
+        {
+          prm.set("Model name","Uniform grains and random uniform rotations");
+          // Let the minerals just passively rotate with the rotation of
+          // the particle caused by the flow.
+          prm.set("Minerals","Passive,Passive");
+          prm.set("Volume fractions minerals","0.5,0.5");
+        }
+        prm.leave_subsection();
+      }
+      prm.leave_subsection ();
+    }
+    prm.leave_subsection ();
+
+
+    prm.enter_subsection("Particles");
+    {
+      cpo_3d.parse_parameters(prm);
+    }
+    prm.leave_subsection ();
+
+    cpo_3d.initialize();
+
+    Point<3> dummy_point;
+    std::vector<double> data;
+    cpo_3d.initialize_one_particle_property(dummy_point, data);
+    // The CPO particles are initialized. With the same seed, the outcome should
+    // always be the same, so test that for seed = 1. Furthermore, in the data
+    // I can only really test that the first entry is the water content (0) and
+    // that every first entry of each particle is 1/n_grains = 1/10 = 0.1.
+    CHECK(data[0] == Approx(-1.0));//isnan(data[0])); // default fabric type which is only computed on a update
+    CHECK(data[1] == Approx(0.5)); // default volume fraction olivine
+    CHECK(data[2] == Approx(0.2));
+    CHECK(data[3] == Approx(0.8794381492));
+    CHECK(data[4] == Approx(-0.4757482965));
+    CHECK(data[5] == Approx(-0.015877661));
+    CHECK(data[6] == Approx(-0.197154988));
+    CHECK(data[7] == Approx(-0.394402755));
+    CHECK(data[8] == Approx(0.8975390674));
+    CHECK(data[9] == Approx(-0.4332648756));
+    CHECK(data[10] == Approx(-0.7861997362));
+    CHECK(data[11] == Approx(-0.4406489786));
+    CHECK(data[12] == Approx(0.2));
+    CHECK(data[13] == Approx(-0.911475687));
+    CHECK(data[14] == Approx(0.4113536692));
+    CHECK(data[15] == Approx(0.0004804047));
+    CHECK(data[16] == Approx(-0.3056521145));
+    CHECK(data[17] == Approx(-0.6780433033));
+    CHECK(data[18] == Approx(0.6684564786));
+    CHECK(data[19] == Approx(0.2752977604));
+    CHECK(data[20] == Approx(0.6091349914));
+    CHECK(data[21] == Approx(0.7437511045));
+    CHECK(data[22] == Approx(0.2));
+    CHECK(data[32] == Approx(0.2));
+    CHECK(data[42] == Approx(0.2));
+    CHECK(data[52] == Approx(-1.0));// default fabric type which is only computed on a update
+    CHECK(data[53] == Approx(0.5)); // default volume fraction olivine
+    CHECK(data[54] == Approx(0.2));
+    CHECK(data[64] == Approx(0.2));
+    CHECK(data[74] == Approx(0.2));
+    CHECK(data[84] == Approx(0.2));
+    CHECK(data[94] == Approx(0.2));
+    CHECK(data[103] == Approx(-0.0688278144));
+
+    std::vector<double> volume_fractions(5,0.2);
+    std::vector<dealii::Tensor<2,3>> rotation_matrices_minerals(5);
+    rotation_matrices_minerals[0][0][0] = 0.5;
+    rotation_matrices_minerals[0][0][1] = 0.5;
+    rotation_matrices_minerals[0][0][2] = 0.5;
+    rotation_matrices_minerals[0][1][0] = 0.5;
+    rotation_matrices_minerals[0][1][1] = 0.5;
+    rotation_matrices_minerals[0][1][2] = 0.5;
+    rotation_matrices_minerals[0][2][0] = 0.5;
+    rotation_matrices_minerals[0][2][1] = 0.5;
+    rotation_matrices_minerals[0][2][2] = 0.5;
+
+    rotation_matrices_minerals[1][0][0] = 0.1;
+    rotation_matrices_minerals[1][0][1] = 0.2;
+    rotation_matrices_minerals[1][0][2] = 0.3;
+    rotation_matrices_minerals[1][1][0] = 0.4;
+    rotation_matrices_minerals[1][1][1] = 0.5;
+    rotation_matrices_minerals[1][1][2] = 0.6;
+    rotation_matrices_minerals[1][2][0] = 0.7;
+    rotation_matrices_minerals[1][2][1] = 0.8;
+    rotation_matrices_minerals[1][2][2] = 0.9;
+
+    rotation_matrices_minerals[2][0][0] = 0.1;
+    rotation_matrices_minerals[2][0][1] = 0.2;
+    rotation_matrices_minerals[2][0][2] = 0.3;
+    rotation_matrices_minerals[2][1][0] = 0.4;
+    rotation_matrices_minerals[2][1][1] = 0.5;
+    rotation_matrices_minerals[2][1][2] = 0.6;
+    rotation_matrices_minerals[2][2][0] = 0.7;
+    rotation_matrices_minerals[2][2][1] = 0.8;
+    rotation_matrices_minerals[2][2][2] = 0.9;
+
+    rotation_matrices_minerals[3][0][0] = 0.1;
+    rotation_matrices_minerals[3][0][1] = 0.2;
+    rotation_matrices_minerals[3][0][2] = 0.3;
+    rotation_matrices_minerals[3][1][0] = 0.4;
+    rotation_matrices_minerals[3][1][1] = 0.5;
+    rotation_matrices_minerals[3][1][2] = 0.6;
+    rotation_matrices_minerals[3][2][0] = 0.7;
+    rotation_matrices_minerals[3][2][1] = 0.8;
+    rotation_matrices_minerals[3][2][2] = 0.9;
+
+    rotation_matrices_minerals[4][0][0] = 0.1;
+    rotation_matrices_minerals[4][0][1] = 0.2;
+    rotation_matrices_minerals[4][0][2] = 0.3;
+    rotation_matrices_minerals[4][1][0] = 0.4;
+    rotation_matrices_minerals[4][1][1] = 0.5;
+    rotation_matrices_minerals[4][1][2] = 0.6;
+    rotation_matrices_minerals[4][2][0] = 0.7;
+    rotation_matrices_minerals[4][2][1] = 0.8;
+    rotation_matrices_minerals[4][2][2] = 0.9;
+
+    SymmetricTensor<2,3> strain_rate_nondimensional;
+    strain_rate_nondimensional[0][1] = 0.5959;
+
+    SymmetricTensor<2,3> compressible_strain_rate;
+
+    Tensor<2,3> velocity_gradient_tensor_nondimensional;
+    velocity_gradient_tensor_nondimensional[0][1] = 2.0* 0.5959;
+    velocity_gradient_tensor_nondimensional[1][0] = 2.0* 0.5959;
+
+    const Point<3> position;
+    const double temperature = 0;
+    const double pressure = 0;
+    const Tensor<1,3> velocity;
+    const std::vector<double> compositions;
+    const SymmetricTensor<2,3> strain_rate;
+    const double water_content = 0;
+
+    std::pair<std::vector<double>, std::vector<Tensor<2,3>>> derivatives;
+    derivatives = cpo_3d.compute_derivatives(0,
+                                             data,
+                                             0,
+                                             strain_rate_nondimensional,
+                                             velocity_gradient_tensor_nondimensional,
+                                             position,
+                                             temperature,
+                                             pressure,
+                                             velocity,
+                                             compositions,
+                                             strain_rate,
+                                             compressible_strain_rate,
+                                             water_content);
+
+    // The correct analytical solution to check against
+    // Note that this still has to be multiplied with with volume fraction
+    // of each grain to get the same solution as D-Rex would get.
+    double solution[5] = {0.0, 0.0, 0.0, 0.0 ,0.0};
+    for (unsigned int iii = 0; iii < derivatives.first.size(); ++iii)
+      CHECK(derivatives.first[iii] == Approx(solution[iii]));
+
+    Tensor<2,3> deriv_direction_solution_2_to_5;
+    deriv_direction_solution_2_to_5[0][0] = 0;
+    deriv_direction_solution_2_to_5[0][1] = 0.0;
+    deriv_direction_solution_2_to_5[0][2] = 0.0;
+    deriv_direction_solution_2_to_5[1][0] = 0.0;
+    deriv_direction_solution_2_to_5[1][1] = 0.0;
+    deriv_direction_solution_2_to_5[1][2] = 0.0;
+    deriv_direction_solution_2_to_5[2][0] = 0.0;
+    deriv_direction_solution_2_to_5[2][1] = 0.0;
+    deriv_direction_solution_2_to_5[2][2] = 0.0;
+    Tensor<2,3> deriv_direction_solution[5] = {Tensor<2,3>(),deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5};
+    for (size_t index = 0; index < 5; index++)
+      {
+        for (size_t iii = 0; iii < 3; iii++)
+          {
+            for (size_t jjj = 0; jjj < 3; jjj++)
+              {
+                CHECK(deriv_direction_solution[index][iii][jjj] == Approx(derivatives.second[index][iii][jjj]));
+              }
+          }
+      }
+    // now check if the value is the same as the D-Rex output when contracted with the direction matrix
+    Tensor<2,3> deriv_direction_full_solution_2_to_5;
+    deriv_direction_full_solution_2_to_5[0][0] = 0.0 ;
+    deriv_direction_full_solution_2_to_5[0][1] = 0.0;
+    deriv_direction_full_solution_2_to_5[0][2] = 0.0;
+    deriv_direction_full_solution_2_to_5[1][0] = 0.0;
+    deriv_direction_full_solution_2_to_5[1][1] = 0.0;
+    deriv_direction_full_solution_2_to_5[1][2] = 0.0;
+    deriv_direction_full_solution_2_to_5[2][0] = 0.0;
+    deriv_direction_full_solution_2_to_5[2][1] = 0.0;
+    deriv_direction_full_solution_2_to_5[2][2] = 0.0;
+    Tensor<2,3> deriv_direction_full_solution[5] = {Tensor<2,3>(),deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5};
+    for (size_t index = 0; index < 5; index++)
+      {
+        auto full_solution = rotation_matrices_minerals[index] * deriv_direction_solution[index];
+        for (size_t iii = 0; iii < 3; iii++)
+          {
+            for (size_t jjj = 0; jjj < 3; jjj++)
+              {
+                CHECK(full_solution[iii][jjj] == Approx(deriv_direction_full_solution[index][iii][jjj]));
+              }
+          }
+      }
+  }
+}
+
+
+TEST_CASE("Fabric determination function")
+{
+  using namespace aspect;
+  using namespace Particle::Property;
+  CrystalPreferredOrientation<3> cpo;
+  double MPa = 1e6;
+
+  CHECK(cpo.determine_deformation_type_karato_2008(379.*MPa, 0.) == DeformationType::olivine_a_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(381.*MPa, 0.) == DeformationType::olivine_d_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(0.*MPa, 100.) == DeformationType::olivine_a_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 50.) == DeformationType::olivine_a_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 50.) == DeformationType::olivine_a_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(379.*MPa, 50.) == DeformationType::olivine_d_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 49.) == DeformationType::olivine_d_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 75.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 100.) == DeformationType::olivine_a_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 100.) == DeformationType::olivine_a_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(379.*MPa, 100.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 100.) == DeformationType::olivine_b_fabric);
+
+  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 200.) == DeformationType::olivine_a_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 200.) == DeformationType::olivine_a_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 200.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 200.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 200.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 200.) == DeformationType::olivine_b_fabric);
+
+  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 300.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 300.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 300.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 300.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 300.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 300.) == DeformationType::olivine_b_fabric);
+
+  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 380.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 380.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 380.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 380.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 380.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 380.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 380.) == DeformationType::olivine_b_fabric);
+
+  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 400.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 400.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 400.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 400.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 400.) == DeformationType::olivine_c_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 400.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 400.) == DeformationType::olivine_b_fabric);
+
+  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 600.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 600.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 600.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 600.) == DeformationType::olivine_c_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 600.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 600.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 600.) == DeformationType::olivine_b_fabric);
+
+  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 800.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 800.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 800.) == DeformationType::olivine_c_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 800.) == DeformationType::olivine_c_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 800.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 800.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 800.) == DeformationType::olivine_b_fabric);
+
+  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 1000.) == DeformationType::olivine_e_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 1000.) == DeformationType::olivine_c_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 1000.) == DeformationType::olivine_c_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 1000.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 1000.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 1000.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 1000.) == DeformationType::olivine_b_fabric);
+
+  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 1200.) == DeformationType::olivine_c_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 1200.) == DeformationType::olivine_c_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 1200.) == DeformationType::olivine_c_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 1200.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 1200.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 1200.) == DeformationType::olivine_b_fabric);
+  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 1200.) == DeformationType::olivine_b_fabric);
+}
+
+
+TEST_CASE("CPO")
+{
+  using namespace dealii;
+  using namespace aspect;
+
+  {
+    // test initialization 3d.
+    const int dim3=3;
+
+    Particle::Property::CrystalPreferredOrientation<dim3> lpo_3d;
+    ParameterHandler prm;
+
+    prm.enter_subsection("Particles");
+    {
+      lpo_3d.declare_parameters(prm);
+      prm.enter_subsection("Crystal Preferred Orientation");
+      {
+        prm.set("Random number seed","1");
+        prm.set("Number of grains per particle","5");
+      }
+      prm.leave_subsection ();
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection("Particles");
+    {
+      lpo_3d.parse_parameters(prm);
+    }
+    prm.leave_subsection();
+
+    lpo_3d.initialize();
+
+
+    Point<dim3> dummy_point;
+    std::vector<double> data;
+    lpo_3d.initialize_one_particle_property(dummy_point, data);
+
+    // The LPO particles are initialized. With the same seed, the outcome should
+    // always be the same, so test that for seed = 1. Forthermore, in the data
+    // I can only really test that the first entry is the water content (0) and
+    // that every first entry of each particle is 1/n_grains = 1/10 = 0.1.
+    CHECK(data[0] == Approx(-1.0));//isnan(data[0])); // default fabric type which is only computed on a update
+    CHECK(data[1] == Approx(0.5)); // default volume fraction olivine
+    CHECK(data[2] == Approx(0.2));
+    CHECK(data[3] == Approx(0.8794381492));
+    CHECK(data[4] == Approx(-0.4757482965));
+    CHECK(data[5] == Approx(-0.015877661));
+    CHECK(data[6] == Approx(-0.197154988));
+    CHECK(data[7] == Approx(-0.394402755));
+    CHECK(data[8] == Approx(0.8975390674));
+    CHECK(data[9] == Approx(-0.4332648756));
+    CHECK(data[10] == Approx(-0.7861997362));
+    CHECK(data[11] == Approx(-0.4406489786));
+    CHECK(data[12] == Approx(0.2));
+    CHECK(data[13] == Approx(-0.911475687));
+    CHECK(data[14] == Approx(0.4113536692));
+    CHECK(data[15] == Approx(0.0004804047));
+    CHECK(data[16] == Approx(-0.3056521145));
+    CHECK(data[17] == Approx(-0.6780433033));
+    CHECK(data[18] == Approx(0.6684564786));
+    CHECK(data[19] == Approx(0.2752977604));
+    CHECK(data[20] == Approx(0.6091349914));
+    CHECK(data[21] == Approx(0.7437511045));
+    CHECK(data[22] == Approx(0.2));
+    CHECK(data[32] == Approx(0.2));
+    CHECK(data[42] == Approx(0.2));
+    CHECK(data[52] == Approx(-1.0));// default fabric type which is only computed on a update
+    CHECK(data[53] == Approx(0.5)); // default volume fraction olivine
+    CHECK(data[54] == Approx(0.2));
+    CHECK(data[64] == Approx(0.2));
+    CHECK(data[74] == Approx(0.2));
+    CHECK(data[84] == Approx(0.2));
+    CHECK(data[94] == Approx(0.2));
+    CHECK(data[103] == Approx(-0.0688278144));
+
+    std::vector<double> volume_fractions(5,0.2);
+    std::vector<dealii::Tensor<2,3>> a_cosine_matrices(5);
+    a_cosine_matrices[0][0][0] = 0.5;
+    a_cosine_matrices[0][0][1] = 0.5;
+    a_cosine_matrices[0][0][2] = 0.5;
+    a_cosine_matrices[0][1][0] = 0.5;
+    a_cosine_matrices[0][1][1] = 0.5;
+    a_cosine_matrices[0][1][2] = 0.5;
+    a_cosine_matrices[0][2][0] = 0.5;
+    a_cosine_matrices[0][2][1] = 0.5;
+    a_cosine_matrices[0][2][2] = 0.5;
+
+    a_cosine_matrices[1][0][0] = 0.1;
+    a_cosine_matrices[1][0][1] = 0.2;
+    a_cosine_matrices[1][0][2] = 0.3;
+    a_cosine_matrices[1][1][0] = 0.4;
+    a_cosine_matrices[1][1][1] = 0.5;
+    a_cosine_matrices[1][1][2] = 0.6;
+    a_cosine_matrices[1][2][0] = 0.7;
+    a_cosine_matrices[1][2][1] = 0.8;
+    a_cosine_matrices[1][2][2] = 0.9;
+
+    a_cosine_matrices[2][0][0] = 0.1;
+    a_cosine_matrices[2][0][1] = 0.2;
+    a_cosine_matrices[2][0][2] = 0.3;
+    a_cosine_matrices[2][1][0] = 0.4;
+    a_cosine_matrices[2][1][1] = 0.5;
+    a_cosine_matrices[2][1][2] = 0.6;
+    a_cosine_matrices[2][2][0] = 0.7;
+    a_cosine_matrices[2][2][1] = 0.8;
+    a_cosine_matrices[2][2][2] = 0.9;
+
+    a_cosine_matrices[3][0][0] = 0.1;
+    a_cosine_matrices[3][0][1] = 0.2;
+    a_cosine_matrices[3][0][2] = 0.3;
+    a_cosine_matrices[3][1][0] = 0.4;
+    a_cosine_matrices[3][1][1] = 0.5;
+    a_cosine_matrices[3][1][2] = 0.6;
+    a_cosine_matrices[3][2][0] = 0.7;
+    a_cosine_matrices[3][2][1] = 0.8;
+    a_cosine_matrices[3][2][2] = 0.9;
+
+    a_cosine_matrices[4][0][0] = 0.1;
+    a_cosine_matrices[4][0][1] = 0.2;
+    a_cosine_matrices[4][0][2] = 0.3;
+    a_cosine_matrices[4][1][0] = 0.4;
+    a_cosine_matrices[4][1][1] = 0.5;
+    a_cosine_matrices[4][1][2] = 0.6;
+    a_cosine_matrices[4][2][0] = 0.7;
+    a_cosine_matrices[4][2][1] = 0.8;
+    a_cosine_matrices[4][2][2] = 0.9;
+
+    lpo_3d.set_volume_fractions_grains(0,data,0,0,0.2);
+    lpo_3d.set_volume_fractions_grains(0,data,0,1,0.2);
+    lpo_3d.set_volume_fractions_grains(0,data,0,2,0.2);
+    lpo_3d.set_volume_fractions_grains(0,data,0,3,0.2);
+    lpo_3d.set_volume_fractions_grains(0,data,0,4,0.2);
+
+    lpo_3d.set_rotation_matrix_grains(0,data,0,0,a_cosine_matrices[0]);
+    lpo_3d.set_rotation_matrix_grains(0,data,0,1,a_cosine_matrices[1]);
+    lpo_3d.set_rotation_matrix_grains(0,data,0,2,a_cosine_matrices[2]);
+    lpo_3d.set_rotation_matrix_grains(0,data,0,3,a_cosine_matrices[3]);
+    lpo_3d.set_rotation_matrix_grains(0,data,0,4,a_cosine_matrices[4]);
+
+    SymmetricTensor<2,3> strain_rate_nondimensional;
+    strain_rate_nondimensional[0][1] = 0.5959;
+
+    Tensor<2,3> velocity_gradient_tensor_nondimensional;
+    velocity_gradient_tensor_nondimensional[0][1] = 2.0* 0.5959;
+    velocity_gradient_tensor_nondimensional[1][0] = 2.0* 0.5959;
+
+    std::array<double,4> ref_resolved_shear_stress;
+    ref_resolved_shear_stress[0] = 1;
+    ref_resolved_shear_stress[1] = 2;
+    ref_resolved_shear_stress[2] = 3;
+    ref_resolved_shear_stress[3] = 1e60; // can't really use nummerical limits max or infinite, because need to be able to square it without becoming infinite. This is the value fortran D-Rex uses.
+
+
+    std::pair<std::vector<double>, std::vector<Tensor<2,3>>> derivatives;
+    derivatives = lpo_3d.compute_derivatives_drex_2004(0,
+                                                       data,
+                                                       0,
+                                                       strain_rate_nondimensional,
+                                                       velocity_gradient_tensor_nondimensional,
+                                                       ref_resolved_shear_stress,
+                                                       true);
+
+
+    // The correct analytical solution to check against
+    double solution[5] = {3.150563756, -0.787640939, -0.787640939, -0.787640939 ,-0.787640939};
+    for (unsigned int i = 0; i < derivatives.first.size(); ++i)
+      CHECK(derivatives.first[i] == Approx(solution[i]));
+
+
+    Tensor<2,3> deriv_direction_solution_2_to_5;
+    deriv_direction_solution_2_to_5[0][0] = 0;
+    deriv_direction_solution_2_to_5[0][1] = 0.00501912;
+    deriv_direction_solution_2_to_5[0][2] = 0.0100382;
+    deriv_direction_solution_2_to_5[1][0] = -0.00501912;
+    deriv_direction_solution_2_to_5[1][1] = 0;
+    deriv_direction_solution_2_to_5[1][2] = 0.00501912;
+    deriv_direction_solution_2_to_5[2][0] = -0.0100382;
+    deriv_direction_solution_2_to_5[2][1] = -0.00501912;
+    deriv_direction_solution_2_to_5[2][2] = 0;
+
+    Tensor<2,3> deriv_direction_solution[5] = {Tensor<2,3>(),deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5};
+    for (size_t index = 0; index < 5; index++)
+      {
+        for (size_t iii = 0; iii < 3; iii++)
+          {
+            for (size_t jjj = 0; jjj < 3; jjj++)
+              {
+                CHECK(deriv_direction_solution[index][iii][jjj] == Approx(derivatives.second[index][iii][jjj]));
+              }
+          }
+      }
+    // now check if the value is the same as the D-Rex output when contracted with the direction matrix
+    Tensor<2,3> deriv_direction_full_solution_2_to_5;
+    deriv_direction_full_solution_2_to_5[0][0] = -0.004015284 ;
+    deriv_direction_full_solution_2_to_5[0][1] = -0.0010038242;
+    deriv_direction_full_solution_2_to_5[0][2] = 0.0020076485;
+    deriv_direction_full_solution_2_to_5[1][0] = -0.00853248;
+    deriv_direction_full_solution_2_to_5[1][1] = -0.0010038242;
+    deriv_direction_full_solution_2_to_5[1][2] = 0.0065248576;
+    deriv_direction_full_solution_2_to_5[2][0] = -0.0130497151;
+    deriv_direction_full_solution_2_to_5[2][1] = -0.0010038242;
+    deriv_direction_full_solution_2_to_5[2][2] = 0.0110420667;
+    Tensor<2,3> deriv_direction_full_solution[5] = {Tensor<2,3>(),deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5};
+    for (size_t index = 0; index < 5; index++)
+      {
+        auto full_solution = a_cosine_matrices[index] * deriv_direction_solution[index];
+        for (size_t iii = 0; iii < 3; iii++)
+          {
+            for (size_t jjj = 0; jjj < 3; jjj++)
+              {
+                CHECK(full_solution[iii][jjj] == Approx(deriv_direction_full_solution[index][iii][jjj]));
+              }
+          }
+      }
+  }
+
+  {
+    // thirdly test 3d lpo with different strain-rate and velocity gradient tensors.
+    // The solution of this test has not been analytically confirmed.
+    const int dim3=3;
+
+    Particle::Property::CrystalPreferredOrientation<dim3> lpo_3d;
+    ParameterHandler prm;
+
+    prm.enter_subsection("Particles");
+    {
+      lpo_3d.declare_parameters(prm);
+      prm.enter_subsection("Crystal Preferred Orientation");
+      {
+        prm.set("Random number seed","1");
+        prm.set("Number of grains per particle","5");
+      }
+      prm.leave_subsection ();
+    }
+    prm.leave_subsection ();
+
+    prm.enter_subsection("Particles");
+    {
+      lpo_3d.parse_parameters(prm);
+    }
+    prm.leave_subsection ();
+
+    lpo_3d.initialize();
+
+
+    Point<dim3> dummy_point;
+    std::vector<double> data;
+    lpo_3d.initialize_one_particle_property(dummy_point, data);
+
+    // The LPO particles are initialized. With the same seed, the outcome should
+    // always be the same, so test that for seed = 1. Forthermore, in the data
+    // I can only really test that the first entry is the water content (0) and
+    // that every first entry of each particle is 1/n_grains = 1/10 = 0.1.
+    CHECK(data[0] == Approx(-1.0));//isnan(data[0])); // default fabric type which is only computed on a update
+    CHECK(data[1] == Approx(0.5)); // default volume fraction olivine
+    CHECK(data[2] == Approx(0.2));
+    CHECK(data[3] == Approx(0.8794381492));
+    CHECK(data[4] == Approx(-0.4757482965));
+    CHECK(data[5] == Approx(-0.015877661));
+    CHECK(data[6] == Approx(-0.197154988));
+    CHECK(data[7] == Approx(-0.394402755));
+    CHECK(data[8] == Approx(0.8975390674));
+    CHECK(data[9] == Approx(-0.4332648756));
+    CHECK(data[10] == Approx(-0.7861997362));
+    CHECK(data[11] == Approx(-0.4406489786));
+    CHECK(data[12] == Approx(0.2));
+    CHECK(data[13] == Approx(-0.911475687));
+    CHECK(data[14] == Approx(0.4113536692));
+    CHECK(data[15] == Approx(0.0004804047));
+    CHECK(data[16] == Approx(-0.3056521145));
+    CHECK(data[17] == Approx(-0.6780433033));
+    CHECK(data[18] == Approx(0.6684564786));
+    CHECK(data[19] == Approx(0.2752977604));
+    CHECK(data[20] == Approx(0.6091349914));
+    CHECK(data[21] == Approx(0.7437511045));
+    CHECK(data[22] == Approx(0.2));
+    CHECK(data[32] == Approx(0.2));
+    CHECK(data[42] == Approx(0.2));
+    CHECK(data[52] == Approx(-1.0));// default fabric type which is only computed on a update
+    CHECK(data[53] == Approx(0.5)); // default volume fraction olivine
+    CHECK(data[54] == Approx(0.2));
+    CHECK(data[64] == Approx(0.2));
+    CHECK(data[74] == Approx(0.2));
+    CHECK(data[84] == Approx(0.2));
+    CHECK(data[94] == Approx(0.2));
+    CHECK(data[103] == Approx(-0.0688278144));
+
+    std::vector<double> volume_fractions(5,0.2);
+    std::vector<dealii::Tensor<2,3>> a_cosine_matrices(5);
+    a_cosine_matrices[0][0][0] = 0.5;
+    a_cosine_matrices[0][0][1] = 0.5;
+    a_cosine_matrices[0][0][2] = 0.5;
+    a_cosine_matrices[0][1][0] = 0.5;
+    a_cosine_matrices[0][1][1] = 0.5;
+    a_cosine_matrices[0][1][2] = 0.5;
+    a_cosine_matrices[0][2][0] = 0.5;
+    a_cosine_matrices[0][2][1] = 0.5;
+    a_cosine_matrices[0][2][2] = 0.5;
+
+    a_cosine_matrices[1][0][0] = 0.1;
+    a_cosine_matrices[1][0][1] = 0.2;
+    a_cosine_matrices[1][0][2] = 0.3;
+    a_cosine_matrices[1][1][0] = 0.4;
+    a_cosine_matrices[1][1][1] = 0.5;
+    a_cosine_matrices[1][1][2] = 0.6;
+    a_cosine_matrices[1][2][0] = 0.7;
+    a_cosine_matrices[1][2][1] = 0.8;
+    a_cosine_matrices[1][2][2] = 0.9;
+
+    a_cosine_matrices[2][0][0] = 0.1;
+    a_cosine_matrices[2][0][1] = 0.2;
+    a_cosine_matrices[2][0][2] = 0.3;
+    a_cosine_matrices[2][1][0] = 0.4;
+    a_cosine_matrices[2][1][1] = 0.5;
+    a_cosine_matrices[2][1][2] = 0.6;
+    a_cosine_matrices[2][2][0] = 0.7;
+    a_cosine_matrices[2][2][1] = 0.8;
+    a_cosine_matrices[2][2][2] = 0.9;
+
+    a_cosine_matrices[3][0][0] = 0.1;
+    a_cosine_matrices[3][0][1] = 0.2;
+    a_cosine_matrices[3][0][2] = 0.3;
+    a_cosine_matrices[3][1][0] = 0.4;
+    a_cosine_matrices[3][1][1] = 0.5;
+    a_cosine_matrices[3][1][2] = 0.6;
+    a_cosine_matrices[3][2][0] = 0.7;
+    a_cosine_matrices[3][2][1] = 0.8;
+    a_cosine_matrices[3][2][2] = 0.9;
+
+    a_cosine_matrices[4][0][0] = 0.1;
+    a_cosine_matrices[4][0][1] = 0.2;
+    a_cosine_matrices[4][0][2] = 0.3;
+    a_cosine_matrices[4][1][0] = 0.4;
+    a_cosine_matrices[4][1][1] = 0.5;
+    a_cosine_matrices[4][1][2] = 0.6;
+    a_cosine_matrices[4][2][0] = 0.7;
+    a_cosine_matrices[4][2][1] = 0.8;
+    a_cosine_matrices[4][2][2] = 0.9;
+
+
+    lpo_3d.set_volume_fractions_grains(0,data,0,0,0.2);
+    lpo_3d.set_volume_fractions_grains(0,data,0,1,0.2);
+    lpo_3d.set_volume_fractions_grains(0,data,0,2,0.2);
+    lpo_3d.set_volume_fractions_grains(0,data,0,3,0.2);
+    lpo_3d.set_volume_fractions_grains(0,data,0,4,0.2);
+
+    lpo_3d.set_rotation_matrix_grains(0,data,0,0,a_cosine_matrices[0]);
+    lpo_3d.set_rotation_matrix_grains(0,data,0,1,a_cosine_matrices[1]);
+    lpo_3d.set_rotation_matrix_grains(0,data,0,2,a_cosine_matrices[2]);
+    lpo_3d.set_rotation_matrix_grains(0,data,0,3,a_cosine_matrices[3]);
+    lpo_3d.set_rotation_matrix_grains(0,data,0,4,a_cosine_matrices[4]);
+
+    SymmetricTensor<2,dim3> strain_rate_nondimensional; // e
+    strain_rate_nondimensional[0][0] = 7.5;
+    strain_rate_nondimensional[0][1] = 8;
+    strain_rate_nondimensional[0][2] = 8.5;
+    //strain_rate_nondimensional[1][0] = 8; // symmetry
+    strain_rate_nondimensional[1][1] = 9.5;
+    strain_rate_nondimensional[1][2] = 10;
+    //strain_rate_nondimensional[2][0] = 8.5;// symmetry
+    //strain_rate_nondimensional[2][1] = 10; // symmetry
+    strain_rate_nondimensional[2][2] = 11.5;
+
+    Tensor<2,dim3> velocity_gradient_tensor_nondimensional; // l
+    velocity_gradient_tensor_nondimensional[0][0] = 2;
+    velocity_gradient_tensor_nondimensional[0][1] = 2.5;
+    velocity_gradient_tensor_nondimensional[0][2] = 3;
+    velocity_gradient_tensor_nondimensional[1][0] = 3.5;
+    velocity_gradient_tensor_nondimensional[1][1] = 4;
+    velocity_gradient_tensor_nondimensional[1][2] = 4.5;
+    velocity_gradient_tensor_nondimensional[2][0] = 5;
+    velocity_gradient_tensor_nondimensional[2][1] = 5.5;
+    velocity_gradient_tensor_nondimensional[2][2] = 6;
+
+
+    std::array<double,4> ref_resolved_shear_stress;
+    ref_resolved_shear_stress[0] = 1;
+    ref_resolved_shear_stress[1] = 2;
+    ref_resolved_shear_stress[2] = 3;
+    ref_resolved_shear_stress[3] = 1e60; // can't really use nummerical limits max or infinite, because need to be able to square it without becoming infinite. This is the value fortran D-Rex uses.
+
+
+    std::pair<std::vector<double>, std::vector<Tensor<2,3>>> derivatives;
+    derivatives = lpo_3d.compute_derivatives_drex_2004(0,
+                                                       data,
+                                                       0,
+                                                       strain_rate_nondimensional,
+                                                       velocity_gradient_tensor_nondimensional,
+                                                       ref_resolved_shear_stress,
+                                                       true);
+
+    // The correct analytical solution to check against
+    double solution[5] = {2.5350823696, -0.6337705924, -0.6337705924, -0.6337705924 ,-0.6337705924};
+    for (unsigned int i = 0; i < derivatives.first.size(); ++i)
+      CHECK(derivatives.first[i] == Approx(solution[i]));
+
+
+    Tensor<2,3> deriv_direction_solution_1;
+    deriv_direction_solution_1[0][0] = 0;
+    deriv_direction_solution_1[0][1] = 0.5;
+    deriv_direction_solution_1[0][2] = 1.0;
+    deriv_direction_solution_1[1][0] = -0.5;
+    deriv_direction_solution_1[1][1] = 0;
+    deriv_direction_solution_1[1][2] = 0.5;
+    deriv_direction_solution_1[2][0] = -1.0;
+    deriv_direction_solution_1[2][1] = -0.5;
+    deriv_direction_solution_1[2][2] = 0;
+    Tensor<2,3> deriv_direction_solution_2_to_5;
+    deriv_direction_solution_2_to_5[0][0] = 0;
+    deriv_direction_solution_2_to_5[0][1] = 0.5304624591;
+    deriv_direction_solution_2_to_5[0][2] = 1.0609249182;
+    deriv_direction_solution_2_to_5[1][0] = -0.5304624591;
+    deriv_direction_solution_2_to_5[1][1] = 0;
+    deriv_direction_solution_2_to_5[1][2] = 0.5304624591;
+    deriv_direction_solution_2_to_5[2][0] = -1.0609249182;
+    deriv_direction_solution_2_to_5[2][1] = -0.5304624591 ;
+    deriv_direction_solution_2_to_5[2][2] = 0;
+
+    Tensor<2,3> deriv_direction_solution[5] = {deriv_direction_solution_1,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5};
+    for (size_t index = 0; index < 5; index++)
+      {
+        for (size_t iii = 0; iii < 3; iii++)
+          {
+            for (size_t jjj = 0; jjj < 3; jjj++)
+              {
+                CHECK(deriv_direction_solution[index][iii][jjj] == Approx(derivatives.second[index][iii][jjj]));
+              }
+          }
+      }
+    // now check if the value is the same as the D-Rex output when contracted with the direction matrix
+    Tensor<2,3> deriv_direction_full_solution_1;
+    deriv_direction_full_solution_1[0][0] = -0.75;
+    deriv_direction_full_solution_1[0][1] = 0.0;
+    deriv_direction_full_solution_1[0][2] = 0.75;
+    deriv_direction_full_solution_1[1][0] = -0.75;
+    deriv_direction_full_solution_1[1][1] = 0;
+    deriv_direction_full_solution_1[1][2] = 0.75;
+    deriv_direction_full_solution_1[2][0] = -0.75;
+    deriv_direction_full_solution_1[2][1] = 0.0;
+    deriv_direction_full_solution_1[2][2] = 0.75;
+    Tensor<2,3> deriv_direction_full_solution_2_to_5;
+    deriv_direction_full_solution_2_to_5[0][0] = -0.4243699673 ;
+    deriv_direction_full_solution_2_to_5[0][1] = -0.1060924918;
+    deriv_direction_full_solution_2_to_5[0][2] = 0.2121849836;
+    deriv_direction_full_solution_2_to_5[1][0] = -0.9017861805;
+    deriv_direction_full_solution_2_to_5[1][1] = -0.1060924918;
+    deriv_direction_full_solution_2_to_5[1][2] = 0.6896011968;
+    deriv_direction_full_solution_2_to_5[2][0] = -1.3792023937;
+    deriv_direction_full_solution_2_to_5[2][1] = -0.1060924918;
+    deriv_direction_full_solution_2_to_5[2][2] = 1.16701741;
+    Tensor<2,3> deriv_direction_full_solution[5] = {deriv_direction_full_solution_1,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5};
+    for (size_t index = 0; index < 5; index++)
+      {
+        auto full_solution = a_cosine_matrices[index] * deriv_direction_solution[index];
+        for (size_t iii = 0; iii < 3; iii++)
+          {
+            for (size_t jjj = 0; jjj < 3; jjj++)
+              {
+                CHECK(full_solution[iii][jjj] == Approx(deriv_direction_full_solution[index][iii][jjj]));
+              }
+          }
+      }
+  }
+}
+
+
+
+TEST_CASE("CPO elastic tensor")
+{
+  std::vector<double> volume_fraction_mineral = {0.7,0.3};
+  std::vector<std::vector<double>> volume_fractions_grains(2,std::vector<double>(8));
+  std::vector<std::vector<dealii::Tensor<2,3>>> a_cosine_matrices_grains(2,std::vector<dealii::Tensor<2,3>>(8));
+
+  dealii::Tensor<2,6> reference_elastic_tensor;
+  dealii::Tensor<2,6> computed_elastic_tensor;
+
+  unsigned int cpo_data_position = 0;
+  std::vector<double> data_array(200,-1.);
+  dealii::ArrayView<double> data_cpo(&data_array[0],200);
+
+
+  // test the averaging function
+  aspect::Particle::Property::CrystalPreferredOrientation<3> cpo;
+  aspect::Particle::Property::CpoElasticTensor<3> cpo_elastic_tensor;
+  aspect::ParameterHandler prm;
+  prm.enter_subsection("Particles");
+  {
+    cpo.declare_parameters(prm);
+    cpo_elastic_tensor.declare_parameters(prm);
+    prm.enter_subsection("Crystal Preferred Orientation");
+    {
+      prm.set("Random number seed","1");
+      prm.set("Number of grains per particle","8");
+      prm.set("CPO derivatives algorithm","Spin tensor");
+      prm.set("Property advection method","Backward Euler");
+      prm.enter_subsection("Initial grains");
+      {
+        prm.set("Model name","Uniform grains and random uniform rotations");
+        // Let the minerals just passively rotate with the rotation of
+        // the particle caused by the flow.
+        prm.set("Minerals","Passive,Passive");
+        prm.set("Volume fractions minerals","0.7,0.3");
+      }
+      prm.leave_subsection();
+    }
+    prm.leave_subsection ();
+  }
+  prm.leave_subsection ();
+
+  prm.enter_subsection("Particles");
+  {
+    cpo.parse_parameters(prm);
+    cpo_elastic_tensor.parse_parameters(prm);
+  }
+  prm.leave_subsection();
+
+  cpo.initialize();
+
+
+  // All these numbers are directly from the Fortran D-Rex
+  // Had to fix the random seed to get consistent results.
+  // Fixed the random set to an array filled with zeros.
+  using namespace dealii;
+  Tensor<2,3> rotation_matrix;
+  rotation_matrix[TableIndices<2>(0,0)] = -0.87492387659370430;
+  rotation_matrix[TableIndices<2>(0,1)] = -0.47600252255715020;
+  rotation_matrix[TableIndices<2>(0,2)] = -0.10151800968122601;
+  rotation_matrix[TableIndices<2>(1,0)] = 0.13036031917262200;
+  rotation_matrix[TableIndices<2>(1,1)] = -2.6406769698713056E-002;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.99232315682823224;
+  rotation_matrix[TableIndices<2>(2,0)] = 0.46957683898444408;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.87974004016081919;
+  rotation_matrix[TableIndices<2>(2,2)] = 8.6098835151007691E-002;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,0,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = -0.98046837857873570;
+  rotation_matrix[TableIndices<2>(0,1)] = 0.19463893778994429;
+  rotation_matrix[TableIndices<2>(0,2)] = -2.8239743415760400E-002;
+  rotation_matrix[TableIndices<2>(1,0)] = 6.8942963409018593E-002;
+  rotation_matrix[TableIndices<2>(1,1)] = 0.20565757913350766;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.97619251975954824;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.18419735979776022;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.95907282258851756;
+  rotation_matrix[TableIndices<2>(2,2)] = -0.21505972600848655;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,1,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = -0.60475851993637786;
+  rotation_matrix[TableIndices<2>(0,1)] = 0.70843624030907060;
+  rotation_matrix[TableIndices<2>(0,2)] = -0.36543256811748415;
+  rotation_matrix[TableIndices<2>(1,0)] = 0.14301138974031016;
+  rotation_matrix[TableIndices<2>(1,1)] = -0.35406726088673490;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.92567249145068109;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.78533679283378455;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.61106385979914768;
+  rotation_matrix[TableIndices<2>(2,2)] = 0.11279851062549377;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,2,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 0.86791495614143876;
+  rotation_matrix[TableIndices<2>(0,1)] = 0.11797028562530290;
+  rotation_matrix[TableIndices<2>(0,2)] = -0.48441508819120616;
+  rotation_matrix[TableIndices<2>(1,0)] = 0.29623368357270952;
+  rotation_matrix[TableIndices<2>(1,1)] = 0.66075310029034506;
+  rotation_matrix[TableIndices<2>(1,2)] = 0.69114249890201696;
+  rotation_matrix[TableIndices<2>(2,0)] = 0.40054408016972737;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.74231595966649988;
+  rotation_matrix[TableIndices<2>(2,2)] = 0.53869116329275069;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,3,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 6.2142369991145308E-002;
+  rotation_matrix[TableIndices<2>(0,1)] = 0.99798524450925208;
+  rotation_matrix[TableIndices<2>(0,2)] = 1.4733749724082583E-002;
+  rotation_matrix[TableIndices<2>(1,0)] = 0.16313304505497195;
+  rotation_matrix[TableIndices<2>(1,1)] = 3.9946223138032123E-003;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.99141604427573704;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.98947772660983668;
+  rotation_matrix[TableIndices<2>(2,1)] = 6.3633828841832010E-002;
+  rotation_matrix[TableIndices<2>(2,2)] = -0.16253511002663851;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,4,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 0.95811162445076037;
+  rotation_matrix[TableIndices<2>(0,1)] = -0.24047036409864109;
+  rotation_matrix[TableIndices<2>(0,2)] = -0.18394917461469307;
+  rotation_matrix[TableIndices<2>(1,0)] = -0.26945849516984494;
+  rotation_matrix[TableIndices<2>(1,1)] = -0.95216866624585605;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.14816174866727450;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.13948857525086517;
+  rotation_matrix[TableIndices<2>(2,1)] = 0.18918653693665904;
+  rotation_matrix[TableIndices<2>(2,2)] = -0.97685775746677384;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,5,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 0.54599545795872684;
+  rotation_matrix[TableIndices<2>(0,1)] = -0.79260950430410815;
+  rotation_matrix[TableIndices<2>(0,2)] = -0.27534584625644454;
+  rotation_matrix[TableIndices<2>(1,0)] = -0.83567561116582212;
+  rotation_matrix[TableIndices<2>(1,1)] = -0.55085590166106368;
+  rotation_matrix[TableIndices<2>(1,2)] = -6.8746495709015629E-002;
+  rotation_matrix[TableIndices<2>(2,0)] = -9.6081601263635075E-002;
+  rotation_matrix[TableIndices<2>(2,1)] = 0.26479508638287669;
+  rotation_matrix[TableIndices<2>(2,2)] = -0.96221681521835400;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,6,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 0.14540407652501869;
+  rotation_matrix[TableIndices<2>(0,1)] = -0.61649901222701298;
+  rotation_matrix[TableIndices<2>(0,2)] = -0.77881206212059828;
+  rotation_matrix[TableIndices<2>(1,0)] = -0.59216315099851768;
+  rotation_matrix[TableIndices<2>(1,1)] = -0.68282211925029168;
+  rotation_matrix[TableIndices<2>(1,2)] = 0.43341920614609419;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.79819736735552915;
+  rotation_matrix[TableIndices<2>(2,1)] = 0.39350172081601731;
+  rotation_matrix[TableIndices<2>(2,2)] = -0.46322016633770996;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,7,rotation_matrix);
+
+
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,0,2.5128593570287589E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,1,0.83128842847575013);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,2,2.4387041141724769E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,3,2.4763275182773107E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,4,2.4801714431754770E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,5,2.3943562805875843E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,6,2.1493810045792379E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,7,2.4193574346041427E-002);
+
+  rotation_matrix[TableIndices<2>(0,0)] = -0.66168933252008499;
+  rotation_matrix[TableIndices<2>(0,1)] = -0.27722421136423192;
+  rotation_matrix[TableIndices<2>(0,2)] = 0.70016104334335305;
+  rotation_matrix[TableIndices<2>(1,0)] = -0.45052346117292291;
+  rotation_matrix[TableIndices<2>(1,1)] = -0.59946225647123619;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.66370395454608444;
+  rotation_matrix[TableIndices<2>(2,0)] = 0.60350910238307343;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.75116099269655345;
+  rotation_matrix[TableIndices<2>(2,2)] = 0.27207473610935284;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,0,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 0.70309122563849258;
+  rotation_matrix[TableIndices<2>(0,1)] = -0.23393734574397834;
+  rotation_matrix[TableIndices<2>(0,2)] = -0.67775637808568567;
+  rotation_matrix[TableIndices<2>(1,0)] = 0.68298185906364617;
+  rotation_matrix[TableIndices<2>(1,1)] = -6.6406501211459870E-002;
+  rotation_matrix[TableIndices<2>(1,2)] = 0.73168002139436472;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.21654097292603913;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.97001835897279087;
+  rotation_matrix[TableIndices<2>(2,2)] = 0.11341644508992850;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,1,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = -0.37892641930874921;
+  rotation_matrix[TableIndices<2>(0,1)] = 0.92610670487847191;
+  rotation_matrix[TableIndices<2>(0,2)] = 3.9338024409460159E-002;
+  rotation_matrix[TableIndices<2>(1,0)] = -0.10014673867324062;
+  rotation_matrix[TableIndices<2>(1,1)] = 2.1922389732184896E-004;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.99514251026853373;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.92466780075091537;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.37833500123197994;
+  rotation_matrix[TableIndices<2>(2,2)] = 9.2539397053637271E-002;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,2,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 0.73973803569795438;
+  rotation_matrix[TableIndices<2>(0,1)] = -0.58084801380447959;
+  rotation_matrix[TableIndices<2>(0,2)] = -0.35134329241205425;
+  rotation_matrix[TableIndices<2>(1,0)] = 0.30883050284698427;
+  rotation_matrix[TableIndices<2>(1,1)] = -0.17349072757172229;
+  rotation_matrix[TableIndices<2>(1,2)] = 0.94047567596335968;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.60686583881969203;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.79564553570809793;
+  rotation_matrix[TableIndices<2>(2,2)] = 5.0387432541084881E-002;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,3,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = 4.2730545437086563E-002;
+  rotation_matrix[TableIndices<2>(0,1)] = 0.99790446393350407;
+  rotation_matrix[TableIndices<2>(0,2)] = 4.9677348699965519E-002;
+  rotation_matrix[TableIndices<2>(1,0)] = 0.24607319829629554;
+  rotation_matrix[TableIndices<2>(1,1)] = 3.7594987859276820E-002;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.97243353311600111;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.97326576151708344;
+  rotation_matrix[TableIndices<2>(2,1)] = 5.2990062123162360E-002;
+  rotation_matrix[TableIndices<2>(2,2)] = -0.24420040893728351;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,4,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = -0.92112012021624434;
+  rotation_matrix[TableIndices<2>(0,1)] = 0.17590913101287936;
+  rotation_matrix[TableIndices<2>(0,2)] = 0.34726602737040008;
+  rotation_matrix[TableIndices<2>(1,0)] = -0.27292179963530816;
+  rotation_matrix[TableIndices<2>(1,1)] = -0.92793421776529450;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.25387354780599874;
+  rotation_matrix[TableIndices<2>(2,0)] = 0.27758135269283285;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.32862450412044819;
+  rotation_matrix[TableIndices<2>(2,2)] = 0.90274831467569783;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,5,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = -4.6028553384029648E-002;
+  rotation_matrix[TableIndices<2>(0,1)] = -0.82828827663204008;
+  rotation_matrix[TableIndices<2>(0,2)] = -0.56150509327989218;
+  rotation_matrix[TableIndices<2>(1,0)] = -0.62780239844730912;
+  rotation_matrix[TableIndices<2>(1,1)] = -0.41264414122407550;
+  rotation_matrix[TableIndices<2>(1,2)] = 0.66416683570654200;
+  rotation_matrix[TableIndices<2>(2,0)] = -0.78150657001547463;
+  rotation_matrix[TableIndices<2>(2,1)] = 0.37975977805647526;
+  rotation_matrix[TableIndices<2>(2,2)] = -0.50060220610535922;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,6,rotation_matrix);
+
+  rotation_matrix[TableIndices<2>(0,0)] = -0.69974343277254114;
+  rotation_matrix[TableIndices<2>(0,1)] = -0.60514581197791628;
+  rotation_matrix[TableIndices<2>(0,2)] = 0.38074455421574593;
+  rotation_matrix[TableIndices<2>(1,0)] = 0.27181144918830025;
+  rotation_matrix[TableIndices<2>(1,1)] = -0.71756260285634454;
+  rotation_matrix[TableIndices<2>(1,2)] = -0.64160793166977359;
+  rotation_matrix[TableIndices<2>(2,0)] = 0.66130789657394939;
+  rotation_matrix[TableIndices<2>(2,1)] = -0.34496383827187421;
+  rotation_matrix[TableIndices<2>(2,2)] = 0.66656470768691123;
+  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,7,rotation_matrix);
+
+
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,0,2.4802805652404735E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,1,2.4917064186342413E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,2,2.4790722064907112E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,3,2.4932751194567736E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,4,2.4896744967217745E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,5,0.79902139535472505);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,6,2.4861121542485400E-002);
+  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,7,5.1777395037349808E-002);
+
+  reference_elastic_tensor[0][0] = 282.99195951271281;
+  reference_elastic_tensor[0][1] = 74.161110997372660;
+  reference_elastic_tensor[0][2] = 69.528000044099443;
+  reference_elastic_tensor[0][3] = 0.85449958913948032;
+  reference_elastic_tensor[0][4] = 0.15156631865980030;
+  reference_elastic_tensor[0][5] = -10.295196344728696;
+  reference_elastic_tensor[1][0] = 74.161110997372674;
+  reference_elastic_tensor[1][1] = 223.44404040361212;
+  reference_elastic_tensor[1][2] = 70.938305212304968;
+  reference_elastic_tensor[1][3] = 1.4935368335052783;
+  reference_elastic_tensor[1][4] = -1.5555954844298270;
+  reference_elastic_tensor[1][5] = -3.5461136157235025;
+  reference_elastic_tensor[2][0] = 69.528000044099443;
+  reference_elastic_tensor[2][1] = 70.938305212304940;
+  reference_elastic_tensor[2][2] = 208.89404139751849;
+  reference_elastic_tensor[2][3] = 0.48656291118743428;
+  reference_elastic_tensor[2][4] = 0.49424401802786699;
+  reference_elastic_tensor[2][5] = -0.15651560991351129;
+  reference_elastic_tensor[3][0] = 0.85449958913948365;
+  reference_elastic_tensor[3][1] = 1.4935368335052732;
+  reference_elastic_tensor[3][2] = 0.48656291118742612;
+  reference_elastic_tensor[3][3] = 71.502776245041289;
+  reference_elastic_tensor[3][4] = -2.3939425644793477;
+  reference_elastic_tensor[3][5] = 0.62714033620769472;
+  reference_elastic_tensor[4][0] = 0.15156631865980935;
+  reference_elastic_tensor[4][1] = -1.5555954844298292;
+  reference_elastic_tensor[4][2] = 0.49424401802786488;
+  reference_elastic_tensor[4][3] = -2.3939425644793459;
+  reference_elastic_tensor[4][4] = 78.565442407530099;
+  reference_elastic_tensor[4][5] = -0.69890743507815323;
+  reference_elastic_tensor[5][0] = -10.295196344728710;
+  reference_elastic_tensor[5][1] = -3.5461136157235131;
+  reference_elastic_tensor[5][2] = -0.15651560991350758;
+  reference_elastic_tensor[5][3] = 0.62714033620769460;
+  reference_elastic_tensor[5][4] = -0.69890743507815523;
+  reference_elastic_tensor[5][5] = 80.599981331604567;
+
+
+  cpo.set_volume_fraction_mineral(cpo_data_position,data_cpo,0,0.7);
+  cpo.set_volume_fraction_mineral(cpo_data_position,data_cpo,1,0.3);
+
+  cpo.set_deformation_type(cpo_data_position,data_cpo,0,aspect::Particle::Property::DeformationType::olivine_a_fabric);
+  cpo.set_deformation_type(cpo_data_position,data_cpo,1,aspect::Particle::Property::DeformationType::enstatite);
+
+  computed_elastic_tensor = cpo_elastic_tensor.voigt_average_elastic_tensor(cpo,
+                                                                            cpo_data_position,
+                                                                            data_cpo);
+
+
+  for (size_t i = 0; i < 6; i++)
+    {
+      for (size_t j = 0; j < 6; j++)
+        {
+          CHECK(computed_elastic_tensor[i][j] == Approx(reference_elastic_tensor[i][j]));
+        }
+    }
+
+  // test store and load functions
+  // the first and last element should not be changed
+  // by these functions.
+  std::vector<double> array_ref = {0.0,
+                                   1.,2.,3.,4.,5,6,
+                                   7.,8.,9.,10,11,12,
+                                   13,14,15,16,17,18,
+                                   19,20,21,22,23,24,
+                                   25,26,27,28,29,30,
+                                   31,32,33,34,35,36,
+                                   37
+                                  };
+
+  std::vector<double> array = {0.0,
+                               1.,2.,3.,4.,5.,6.,
+                               7.,8.,9.,10,11,12,
+                               13,14,15,16,17,18,
+                               19,20,21,22,23,24,
+                               25,26,27,28,29,30,
+                               31,32,33,34,35,36,
+                               37
+                              };
+
+  // There used to be 36 unique entries, but now because we are using the
+  // symmetric tensor, there are only 21 unique entries.
+  std::vector<double> array_plus_100 = {0.0,
+                                        101.,102.,103.,104.,105.,106.,
+                                        107.,108.,109.,110.,111.,112.,
+                                        113.,114.,115.,116.,117.,118.,
+                                        119.,120.,121.,22.,23.,24.,
+                                        25.,26.,27.,28.,29.,30.,
+                                        31.,32.,33.,34.,35.,36.,
+                                        37.
+                                       };
+
+  cpo_data_position = 1;
+  dealii::ArrayView<double> data(&array[0],38);
+  dealii::SymmetricTensor<2,6> tensor = cpo_elastic_tensor.get_elastic_tensor(cpo_data_position,data);
+
+  for (unsigned int i = 0; i < dealii::SymmetricTensor<2,6>::n_independent_components ; ++i)
+    {
+      CHECK(data[cpo_data_position + i] == tensor[dealii::SymmetricTensor<2,6>::unrolled_to_component_indices(i)]);
+    }
+
+  cpo_elastic_tensor.set_elastic_tensor(cpo_data_position,data,tensor);
+
+  for (unsigned int i = 0; i < array.size() ; ++i)
+    CHECK(data[i] == array_ref[i]);
+
+  for (unsigned int i = 0; i < dealii::SymmetricTensor<2,6>::n_independent_components ; ++i)
+    {
+      tensor[dealii::SymmetricTensor<2,6>::unrolled_to_component_indices(i)] += 100;
+    }
+
+  cpo_elastic_tensor.set_elastic_tensor(cpo_data_position,data,tensor);
+
+  for (unsigned int i = 0; i < array.size() ; ++i)
+    CHECK(data[i] == array_plus_100[i]);
+
+  tensor = cpo_elastic_tensor.get_elastic_tensor(cpo_data_position,data);
+
+  for (unsigned int i = 0; i < dealii::SymmetricTensor<2,6>::n_independent_components ; ++i)
+    {
+      CHECK(data[cpo_data_position + i] == tensor[dealii::SymmetricTensor<2,6>::unrolled_to_component_indices(i)]);
+    }
+
+  for (unsigned int i = 0; i < dealii::SymmetricTensor<2,6>::n_independent_components ; ++i)
+    {
+      CHECK(array_plus_100[cpo_data_position + i] == tensor[dealii::SymmetricTensor<2,6>::unrolled_to_component_indices(i)]);
+    }
+}
+
+
+
+
+TEST_CASE("LPO elastic tensor decomposition")
+{
+  using namespace dealii;
+  using namespace aspect::Particle::Property;
+  using namespace aspect::Particle::Property::Utilities;
+  {
+    auto elastic_composition_class = ElasticTensorDecomposition<3>();
+
+    // the matrix from Browaeys and Chevrot, 2004, Geophys. J. Int. (doi: 10.1111/j.1365-246X.2004.02415.x)
+    // Note that the computed norms are not in the papers, but are an extra check.
+    SymmetricTensor<2,6> full_elastic_matrix;
+    full_elastic_matrix[0][0] = 192;
+    full_elastic_matrix[0][1] = 66;
+    full_elastic_matrix[0][2] = 60;
+    full_elastic_matrix[1][1] = 160;
+    full_elastic_matrix[1][2] = 56;
+    full_elastic_matrix[2][2] = 272;
+    full_elastic_matrix[3][3] = 60;
+    full_elastic_matrix[4][4] = 62;
+    full_elastic_matrix[5][5] = 49;
+
+    SymmetricTensor<2,6> reference_isotropic_matrix;
+    reference_isotropic_matrix[0][0] = 194.7;
+    reference_isotropic_matrix[0][1] = 67.3;
+    reference_isotropic_matrix[0][2] = 67.3;
+    reference_isotropic_matrix[1][1] = 194.7;
+    reference_isotropic_matrix[1][2] = 67.3;
+    reference_isotropic_matrix[2][2] = 194.7;
+    reference_isotropic_matrix[3][3] = 63.7;
+    reference_isotropic_matrix[4][4] = 63.7;
+    reference_isotropic_matrix[5][5] = 63.7;
+
+    SymmetricTensor<2,6> reference_hex_matrix;
+    reference_hex_matrix[0][0] = -21.7;
+    reference_hex_matrix[1][1] = -21.7;
+    reference_hex_matrix[2][2] = 77.3;
+    reference_hex_matrix[1][2] = -9.3;
+    reference_hex_matrix[0][2] = -9.3;
+    reference_hex_matrix[0][1] = 1.7;
+    reference_hex_matrix[3][3] = -2.7;
+    reference_hex_matrix[4][4] = -2.7;
+    reference_hex_matrix[5][5] = -11.7;
+
+    SymmetricTensor<2,6> reference_T_matrix;
+    reference_T_matrix[0][0] = 3;
+    reference_T_matrix[1][1] = 3;
+    reference_T_matrix[0][1] = -3;
+    reference_T_matrix[5][5] = -3;
+
+    SymmetricTensor<2,6> reference_O_matrix;
+    reference_O_matrix[0][0] = 16;
+    reference_O_matrix[1][1] = -16;
+    reference_O_matrix[1][2] = -2;
+    reference_O_matrix[0][2] = 2;
+    reference_O_matrix[3][3] = -1;
+    reference_O_matrix[4][4] = 1;
+
+    const Tensor<1,21> full_elastic_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(full_elastic_matrix);
+    const Tensor<1,21> reference_isotropic_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_isotropic_matrix);
+    const Tensor<1,21> reference_hex_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_hex_matrix);
+    const Tensor<1,21> reference_T_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_T_matrix);
+    const Tensor<1,21> reference_O_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_O_matrix);
+
+    // this matrix is already in the SCCSS, so no rotation needed, only the  projection.
+    CHECK(full_elastic_vector.norm_square() == Approx(198012.0));
+    const Tensor<1,21> mono_and_higher_vector = aspect::Particle::Property::Utilities::projection_matrix_triclinic_to_monoclinic * full_elastic_vector;
+    const Tensor<1,21> tric_vector = full_elastic_vector-mono_and_higher_vector;
+    for (size_t iii = 0; iii < 21; iii++)
+      {
+        CHECK(std::abs(tric_vector[iii]) < 1e-15);
+      }
+    CHECK(tric_vector.norm_square() == Approx(0.0));
+
+    dealii::Tensor<1,9>  mono_and_higher_vector_croped;
+    mono_and_higher_vector_croped[0] = mono_and_higher_vector[0];
+    mono_and_higher_vector_croped[1] = mono_and_higher_vector[1];
+    mono_and_higher_vector_croped[2] = mono_and_higher_vector[2];
+    mono_and_higher_vector_croped[3] = mono_and_higher_vector[3];
+    mono_and_higher_vector_croped[4] = mono_and_higher_vector[4];
+    mono_and_higher_vector_croped[5] = mono_and_higher_vector[5];
+    mono_and_higher_vector_croped[6] = mono_and_higher_vector[6];
+    mono_and_higher_vector_croped[7] = mono_and_higher_vector[7];
+    mono_and_higher_vector_croped[8] = mono_and_higher_vector[8];
+    const Tensor<1,9> ortho_and_higher_vector = aspect::Particle::Property::Utilities::projection_matrix_monoclinic_to_orthorhombic*mono_and_higher_vector_croped;
+    const Tensor<1,9> mono_vector = mono_and_higher_vector_croped-ortho_and_higher_vector;
+    for (size_t iii = 0; iii < 9; iii++)
+      {
+        CHECK(std::abs(mono_vector[iii]) < 1e-15);
+      }
+    CHECK(mono_vector.norm_square() == Approx(0.0));
+
+    const Tensor<1,9> tetra_and_higher_vector = aspect::Particle::Property::Utilities::projection_matrix_orthorhombic_to_tetragonal*ortho_and_higher_vector;
+    const Tensor<1,9> ortho_vector = ortho_and_higher_vector-tetra_and_higher_vector;
+    for (size_t iii = 0; iii < 9; iii++)
+      {
+        CHECK(ortho_vector[iii] == Approx(reference_O_vector[iii]));
+      }
+    CHECK(ortho_vector.norm_square() == Approx(536.0));
+
+    const Tensor<1,9> hexa_and_higher_vector = aspect::Particle::Property::Utilities::projection_matrix_tetragonal_to_hexagonal*tetra_and_higher_vector;
+    const Tensor<1,9> tetra_vector = tetra_and_higher_vector-hexa_and_higher_vector;
+    for (size_t iii = 0; iii < 9; iii++)
+      {
+        CHECK(tetra_vector[iii] == Approx(reference_T_vector[iii]));
+      }
+    CHECK(tetra_vector.norm_square() == Approx(72.0));
+
+    const Tensor<1,9> iso_vector = aspect::Particle::Property::Utilities::projection_matrix_hexagonal_to_isotropic*hexa_and_higher_vector;
+    for (size_t iii = 0; iii < 9; iii++)
+      {
+        // something weird is going on with the approx, somehow without a very large
+        // epsilon it thinks for example that "194.6666666667 == Approx( 194.7 )" is false.
+        CHECK(iso_vector[iii] == Approx(reference_isotropic_vector[iii]).epsilon(1e-3));
+      }
+    CHECK(iso_vector.norm_square() == Approx(189529.3333333334));
+
+    const Tensor<1,9> hexa_vector = hexa_and_higher_vector-iso_vector;
+    for (size_t iii = 0; iii < 9; iii++)
+      {
+        // same as above.
+        CHECK(hexa_vector[iii] == Approx(reference_hex_vector[iii]).epsilon(2.5e-2));
+      }
+    CHECK(hexa_vector.norm_square() == Approx(7874.6666666667));
+
+  }
+
+  {
+    // now compute the distribution in a elastic tensor which is not in SCCS.
+    // We will use the result (with the results of the steps in between) from
+    // Cowin and Mehrabadi, 1985, Mech. appl. Math.
+    SymmetricTensor<2,6> full_elastic_matrix;
+    full_elastic_matrix[0][0] = 1769.50;
+    full_elastic_matrix[0][1] = 873.50;
+    full_elastic_matrix[0][2] = 838.22;
+    full_elastic_matrix[0][3] = -17.68;
+    full_elastic_matrix[0][4] = -110.32;
+    full_elastic_matrix[0][5] = 144.92;
+    full_elastic_matrix[1][0] = 873.50;
+    full_elastic_matrix[1][1] = 1846.64;
+    full_elastic_matrix[1][2] = 836.66;
+    full_elastic_matrix[1][3] = -37.60;
+    full_elastic_matrix[1][4] = -32.32;
+    full_elastic_matrix[1][5] = 153.80;
+    full_elastic_matrix[2][0] = 838.22;
+    full_elastic_matrix[2][1] = 836.66;
+    full_elastic_matrix[2][2] = 1603.28;
+    full_elastic_matrix[2][3] = -29.68;
+    full_elastic_matrix[2][4] = -93.52;
+    full_elastic_matrix[2][5] = 22.40;
+    full_elastic_matrix[3][0] = -17.68;
+    full_elastic_matrix[3][1] = -37.60;
+    full_elastic_matrix[3][2] = -29.68;
+    full_elastic_matrix[3][3] = 438.77;
+    full_elastic_matrix[3][4] = 57.68;
+    full_elastic_matrix[3][5] = -50.50;
+    full_elastic_matrix[4][0] = -110.32;
+    full_elastic_matrix[4][1] = -32.32;
+    full_elastic_matrix[4][2] = -93.52;
+    full_elastic_matrix[4][3] = 57.68;
+    full_elastic_matrix[4][4] = 439.79;
+    full_elastic_matrix[4][5] = -34.78;
+    full_elastic_matrix[5][0] = 144.92;
+    full_elastic_matrix[5][1] = 153.80;
+    full_elastic_matrix[5][2] = 22.40;
+    full_elastic_matrix[5][3] = -50.50;
+    full_elastic_matrix[5][4] = -34.78;
+    full_elastic_matrix[5][5] = 501.80;
+    full_elastic_matrix /= 81.;
+
+    SymmetricTensor<2,3> reference_dilatation_matrix;
+    reference_dilatation_matrix[0][0] = 386.80;
+    reference_dilatation_matrix[0][1] = 35.68;
+    reference_dilatation_matrix[0][2] = -26.24;
+    //reference_dilatation_matrix[1][0] = ;
+    reference_dilatation_matrix[1][1] = 395.20;
+    reference_dilatation_matrix[1][2] = -9.44;
+    //reference_dilatation_matrix[2][0] = ;
+    //reference_dilatation_matrix[2][1] = ;
+    reference_dilatation_matrix[2][2] = 364.24;
+    reference_dilatation_matrix /= 9.;
+
+    SymmetricTensor<2,3> reference_voigt_matrix;
+    reference_voigt_matrix[0][0] = 33.47;
+    reference_voigt_matrix[0][1] = 4.4;
+    reference_voigt_matrix[0][2] = -3.14;
+    //reference_voigt_matrix[1][0] = ;
+    reference_voigt_matrix[1][1] = 34.41;
+    reference_voigt_matrix[1][2] = -1.26;
+    //reference_voigt_matrix[2][0] = ;
+    //reference_voigt_matrix[2][1] = ;
+    reference_voigt_matrix[2][2] = 30.64;
+
+    // Q in equation 2.17, but reordered from
+    // largest to smallest eigenvalue.
+    Tensor<2,3> reference_SCCS;
+    reference_SCCS[2][0] = 2./3.;
+    reference_SCCS[2][1] = -1./3.;
+    reference_SCCS[2][2] = 2./3.;
+    reference_SCCS[1][0] = 1./3.;
+    reference_SCCS[1][1] = -2./3.;
+    reference_SCCS[1][2] = -2./3.;
+    reference_SCCS[0][0] = 2./3.;
+    reference_SCCS[0][1] = 2./3.;
+    reference_SCCS[0][2] = -1./3.;
+
+    SymmetricTensor<2,6> reference_rotated_elastic_matrix;
+    reference_rotated_elastic_matrix[0][0] = 18;
+    reference_rotated_elastic_matrix[0][1] = 9.98;
+    reference_rotated_elastic_matrix[0][2] = 10.1;
+    //reference_rotated_elastic_matrix[1][0] = ;
+    reference_rotated_elastic_matrix[1][1] = 20.2;
+    reference_rotated_elastic_matrix[1][2] = 10.07;
+    //reference_rotated_elastic_matrix[2][0] = ;
+    //reference_rotated_elastic_matrix[2][1] = ;
+    reference_rotated_elastic_matrix[2][2] = 27.6;
+    reference_rotated_elastic_matrix[3][3] = 6.23;
+    reference_rotated_elastic_matrix[4][4] = 5.61;
+    reference_rotated_elastic_matrix[5][5] = 4.52;
+
+    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        for (size_t jjj = 0; jjj < 3; jjj++)
+          {
+            CHECK(reference_dilatation_matrix[iii][jjj] == Approx(dilatation_stiffness_tensor_full[iii][jjj]));
+          }
+      }
+
+    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        for (size_t jjj = 0; jjj < 3; jjj++)
+          {
+            CHECK(reference_voigt_matrix[iii][jjj] == Approx(voigt_stiffness_tensor_full[iii][jjj]));
+          }
+      }
+    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+    // chose the permutation which fits the solution given in the paper.
+    // This is not a even permutation.
+    std::array<unsigned int, 3> permutation = {{2,1,0}};
+    Tensor<2,3> permutated_SCCS;
+    for (size_t j = 0; j < 3; j++)
+      {
+        permutated_SCCS[j] = unpermutated_SCCS[permutation[j]];
+      }
+    SymmetricTensor<2,6> rotated_elastic_matrix = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(permutated_SCCS,full_elastic_matrix);
+
+    for (size_t iii = 0; iii < 6; iii++)
+      {
+        for (size_t jjj = 0; jjj < 6; jjj++)
+          {
+            CHECK(reference_rotated_elastic_matrix[iii][jjj] == Approx(rotated_elastic_matrix[iii][jjj]).margin(1e-4).epsilon(7.5e-2));
+          }
+      }
+  }
+  {
+    // This is testing some other elastic matrices of which the properties can
+    // be resonaly predicted (for example, mostly hexagonal) and some coverage
+    // testing: Case 1.
+
+    SymmetricTensor<2,6> full_elastic_matrix;
+    full_elastic_matrix[0][0] = 192;
+    full_elastic_matrix[0][1] = 66;
+    full_elastic_matrix[0][2] = 56;
+    full_elastic_matrix[1][1] = 192;
+    full_elastic_matrix[1][2] = 56;
+    full_elastic_matrix[2][2] = 272;
+    full_elastic_matrix[3][3] = 60;
+    full_elastic_matrix[4][4] = 60;
+    full_elastic_matrix[5][5] = 0.5*(full_elastic_matrix[0][0] + full_elastic_matrix[0][1]);
+
+    std::array<std::array<double,3>,7 > reference_norms;
+    reference_norms[0] = {{0,0,0}}; // no triclinic
+    reference_norms[1] = {{0,0,0}}; // no monoclinic
+    reference_norms[2] = {{12822.0,0,12822.0}}; // orthorhomic dependent on direction (remember, this is basically just one grain)
+    reference_norms[3] = {{1568.0,8712.0,1568.0}}; // tetragonal could be present
+    reference_norms[4] = {{2759.3333333333,8437.3333333333,2759.3333333333}}; // hexagonal is expected
+    reference_norms[5] = {{247182.6666666667,247182.6666666667,247182.6666666667}}; // isotropic should be the same for every permutation
+    reference_norms[6] = {{264332.0,264332.0,264332.0}}; // total should be the same for every direction
+
+    // It is already in a SCCS frame, so they should be
+    // unit vectors. The order is irrelevant.
+    Tensor<2,3> reference_unpermutated_SCCS;
+    reference_unpermutated_SCCS[0][0] = 0;
+    reference_unpermutated_SCCS[0][1] = 0;
+    reference_unpermutated_SCCS[0][2] = 1;
+    reference_unpermutated_SCCS[1][0] = 1;
+    reference_unpermutated_SCCS[1][1] = 0;
+    reference_unpermutated_SCCS[1][2] = 0;
+    reference_unpermutated_SCCS[2][0] = 0;
+    reference_unpermutated_SCCS[2][1] = 1;
+    reference_unpermutated_SCCS[2][2] = 0;
+
+    // Permutation 2 has the highest norm, so reference_unpermutated_SCCS
+    // is permutated by {1,2,0};
+    Tensor<2,3> reference_hexa_permutated_SCCS;
+    reference_hexa_permutated_SCCS[0][0] = 1;
+    reference_hexa_permutated_SCCS[0][1] = 0;
+    reference_hexa_permutated_SCCS[0][2] = 0;
+    reference_hexa_permutated_SCCS[1][0] = 0;
+    reference_hexa_permutated_SCCS[1][1] = 1;
+    reference_hexa_permutated_SCCS[1][2] = 0;
+    reference_hexa_permutated_SCCS[2][0] = 0;
+    reference_hexa_permutated_SCCS[2][1] = 0;
+    reference_hexa_permutated_SCCS[2][2] = 1;
+
+    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
+    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
+    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
+    std::array<double,3> totals = {{0,0,0}};
+    for (size_t iii = 0; iii < 7; iii++)
+      {
+        // also check that the total is equal to the full norm.
+
+        for (size_t jjj = 0; jjj < 3; jjj++)
+          {
+            INFO("i:j = " << iii << ":" << jjj );
+            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
+            if (iii < 6)
+              {
+                totals[jjj] += norms[iii][jjj];
+              }
+          }
+      }
+    for (size_t jjj = 0; jjj < 3; jjj++)
+      {
+        INFO("j = " << jjj );
+        CHECK(totals[jjj] == Approx(norms[6][jjj]));
+      }
+
+    // also check that all the isotropic and totals are the same
+    for (size_t iii = 1; iii < 3; iii++)
+      {
+        CHECK(norms[5][0] == Approx(norms[5][iii]));
+        CHECK(norms[6][0] == Approx(norms[6][iii]));
+      }
+
+    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
+    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
+    Tensor<2,3> hexa_permutated_SCCS;
+    for (size_t index = 0; index < 3; index++)
+      {
+        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
+      }
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+  }
+  {
+    // This is testing some other elastic matrices of which the properties can
+    // be resonaly predicted (for example, mostly hexagonal) and some coverage
+    // testing: Case 2: a more complicated matrix.
+
+    SymmetricTensor<2,6> full_elastic_matrix;
+    full_elastic_matrix[0][0] = 225;
+    full_elastic_matrix[0][1] = 54;
+    full_elastic_matrix[0][2] = 72;
+    full_elastic_matrix[1][1] = 214;
+    full_elastic_matrix[1][2] = 53;
+    full_elastic_matrix[2][2] = 178;
+    full_elastic_matrix[3][3] = 78;
+    full_elastic_matrix[4][4] = 82;
+    full_elastic_matrix[5][5] = 76;
+
+    std::array<std::array<double,3>,7 > reference_norms;
+    reference_norms[0] = {{0,0,0}}; // no triclinic
+    reference_norms[1] = {{0,0,0}}; // no monoclinic
+    reference_norms[2] = {{453.5,1044.0,1113.5}}; // orthorhomic dependent on direction
+    reference_norms[3] = {{91.125,84.5,595.125}}; // tetragonal could be present
+    reference_norms[4] = {{1350.175,766.3,186.175}}; // hexagonal is expected
+    reference_norms[5] = {{222364.2,222364.2,222364.2}}; // isotropic should be the same for every permutation
+    reference_norms[6] = {{224259.0,224259.0,224259.0}}; // total should be the same for every direction
+
+    // It is already in a SCCS frame, so they should be
+    // unit vectors. The order is irrelevant.
+    Tensor<2,3> reference_unpermutated_SCCS;
+    reference_unpermutated_SCCS[0][0] = 1;
+    reference_unpermutated_SCCS[0][1] = 0;
+    reference_unpermutated_SCCS[0][2] = 0;
+    reference_unpermutated_SCCS[1][0] = 0;
+    reference_unpermutated_SCCS[1][1] = 1;
+    reference_unpermutated_SCCS[1][2] = 0;
+    reference_unpermutated_SCCS[2][0] = 0;
+    reference_unpermutated_SCCS[2][1] = 0;
+    reference_unpermutated_SCCS[2][2] = 1;
+
+    // Permutation 1 has the highest norm, so reference_unpermutated_SCCS
+    // is permutated by {0,1,2};
+    Tensor<2,3> reference_hexa_permutated_SCCS;
+    reference_hexa_permutated_SCCS[0][0] = 1;
+    reference_hexa_permutated_SCCS[0][1] = 0;
+    reference_hexa_permutated_SCCS[0][2] = 0;
+    reference_hexa_permutated_SCCS[1][0] = 0;
+    reference_hexa_permutated_SCCS[1][1] = 1;
+    reference_hexa_permutated_SCCS[1][2] = 0;
+    reference_hexa_permutated_SCCS[2][0] = 0;
+    reference_hexa_permutated_SCCS[2][1] = 0;
+    reference_hexa_permutated_SCCS[2][2] = 1;
+
+    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
+    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
+    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
+    std::array<double,3> totals = {{0,0,0}};
+    for (size_t iii = 0; iii < 7; iii++)
+      {
+        // also check that the total is equal to the full norm.
+
+        for (size_t jjj = 0; jjj < 3; jjj++)
+          {
+            INFO("i:j = " << iii << ":" << jjj );
+            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
+            if (iii < 6)
+              {
+                totals[jjj] += norms[iii][jjj];
+              }
+          }
+      }
+    for (size_t jjj = 0; jjj < 3; jjj++)
+      {
+        INFO("j = " << jjj );
+        CHECK(totals[jjj] == Approx(norms[6][jjj]));
+      }
+
+    // also check that all the isotropic and totals are the same
+    for (size_t iii = 1; iii < 3; iii++)
+      {
+        CHECK(norms[5][0] == Approx(norms[5][iii]));
+        CHECK(norms[6][0] == Approx(norms[6][iii]));
+      }
+
+    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
+    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
+    Tensor<2,3> hexa_permutated_SCCS;
+    for (size_t index = 0; index < 3; index++)
+      {
+        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
+      }
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+  }
+
+  {
+    // This is testing some other elastic matrices of which the properties can
+    // be resonaly predicted (for example, mostly hexagonal) and some coverage
+    // testing: Case 3: olivine from experiments as used in D-Rex.
+
+    SymmetricTensor<2,6> full_elastic_matrix;
+    full_elastic_matrix[0][0] = 320.71;
+    full_elastic_matrix[0][1] = 69.84;
+    full_elastic_matrix[0][2] = 71.22;
+    full_elastic_matrix[1][1] = 197.25;
+    full_elastic_matrix[1][2] = 74.8;
+    full_elastic_matrix[2][2] = 234.32;
+    full_elastic_matrix[3][3] = 63.77;
+    full_elastic_matrix[4][4] = 77.67;
+    full_elastic_matrix[5][5] = 78.36;
+
+    std::array<std::array<double,3>,7 > reference_norms;
+    reference_norms[0] = {{0,0,0}}; // no triclinic
+    reference_norms[1] = {{0,0,0}}; // no monoclinic
+    reference_norms[2] = {{4181.95385,689.94905,8020.4222}}; // orthorhomic dependent on direction
+    reference_norms[3] = {{1298.2060125,90.3840125,525.5282}}; // tetragonal could be present
+    reference_norms[4] = {{4364.6051908333,9064.4319908333,1298.8146533333}}; // hexagonal is expected
+    reference_norms[5] = {{282871.5975466666,282871.5975466666,282871.5975466666}}; // isotropic should be the same for every permutation
+    reference_norms[6] = {{292716.3626,292716.3626,292716.3626}}; // total should be the same for every direction
+
+    // It is already in a SCCS frame, so they should be
+    // unit vectors. The order is irrelevant.
+    Tensor<2,3> reference_unpermutated_SCCS;
+    reference_unpermutated_SCCS[0][0] = 1;
+    reference_unpermutated_SCCS[0][1] = 0;
+    reference_unpermutated_SCCS[0][2] = 0;
+    reference_unpermutated_SCCS[1][0] = 0;
+    reference_unpermutated_SCCS[1][1] = 0;
+    reference_unpermutated_SCCS[1][2] = 1;
+    reference_unpermutated_SCCS[2][0] = 0;
+    reference_unpermutated_SCCS[2][1] = 1;
+    reference_unpermutated_SCCS[2][2] = 0;
+
+    // Permutation 2 has the highest norm, so reference_unpermutated_SCCS
+    // is permutated by {1,2,0};
+    Tensor<2,3> reference_hexa_permutated_SCCS;
+    reference_hexa_permutated_SCCS[0][0] = 0;
+    reference_hexa_permutated_SCCS[0][1] = 0;
+    reference_hexa_permutated_SCCS[0][2] = 1;
+    reference_hexa_permutated_SCCS[1][0] = 0;
+    reference_hexa_permutated_SCCS[1][1] = 1;
+    reference_hexa_permutated_SCCS[1][2] = 0;
+    reference_hexa_permutated_SCCS[2][0] = 1;
+    reference_hexa_permutated_SCCS[2][1] = 0;
+    reference_hexa_permutated_SCCS[2][2] = 0;
+
+    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
+    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
+    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
+    std::array<double,3> totals = {{0,0,0}};
+    for (size_t iii = 0; iii < 7; iii++)
+      {
+        // also check that the total is equal to the full norm.
+
+        for (size_t jjj = 0; jjj < 3; jjj++)
+          {
+            INFO("i:j = " << iii << ":" << jjj );
+            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
+            if (iii < 6)
+              {
+                totals[jjj] += norms[iii][jjj];
+              }
+          }
+      }
+    for (size_t jjj = 0; jjj < 3; jjj++)
+      {
+        INFO("j = " << jjj );
+        CHECK(totals[jjj] == Approx(norms[6][jjj]));
+      }
+
+    // also check that all the isotropic and totals are the same
+    for (size_t iii = 1; iii < 3; iii++)
+      {
+        CHECK(norms[5][0] == Approx(norms[5][iii]));
+        CHECK(norms[6][0] == Approx(norms[6][iii]));
+      }
+
+    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
+    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
+    Tensor<2,3> hexa_permutated_SCCS;
+    for (size_t index = 0; index < 3; index++)
+      {
+        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
+      }
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+  }
+
+  {
+    // This is testing some other elastic matrices of which the properties can
+    // be resonaly predicted (for example, mostly hexagonal) and some coverage
+    // testing: Case 4: enstatite from experiments as used in D-Rex.
+
+    SymmetricTensor<2,6> full_elastic_matrix;
+    full_elastic_matrix[0][0] = 236.9;
+    full_elastic_matrix[0][1] = 79.6;
+    full_elastic_matrix[0][2] = 63.2;
+    full_elastic_matrix[1][1] = 180.5;
+    full_elastic_matrix[1][2] = 56.8;
+    full_elastic_matrix[2][2] = 230.4;
+    full_elastic_matrix[3][3] = 84.3;
+    full_elastic_matrix[4][4] = 79.4;
+    full_elastic_matrix[5][5] = 80.1;
+
+    std::array<std::array<double,3>,7 > reference_norms;
+    reference_norms[0] = {{0,0,0}}; // no triclinic
+    reference_norms[1] = {{0,0,0}}; // no monoclinic
+    reference_norms[2] = {{576.245,1514.945,1679.46}}; // orthorhomic dependent on direction
+    reference_norms[3] = {{67.86125,199.00125,483.605}}; // tetragonal could be present
+    reference_norms[4] = {{2076.64175,1006.80175,557.683}}; // hexagonal is expected
+    reference_norms[5] = {{245485.992,245485.992,245485.992}}; // isotropic should be the same for every permutation
+    reference_norms[6] = {{248206.74,248206.74,248206.74}}; // total should be the same for every direction
+
+    // It is already in a SCCS frame, so they should be
+    // unit vectors. The order is irrelevant.
+    Tensor<2,3> reference_unpermutated_SCCS;
+    reference_unpermutated_SCCS[0][0] = 1;
+    reference_unpermutated_SCCS[0][1] = 0;
+    reference_unpermutated_SCCS[0][2] = 0;
+    reference_unpermutated_SCCS[1][0] = 0;
+    reference_unpermutated_SCCS[1][1] = 0;
+    reference_unpermutated_SCCS[1][2] = 1;
+    reference_unpermutated_SCCS[2][0] = 0;
+    reference_unpermutated_SCCS[2][1] = 1;
+    reference_unpermutated_SCCS[2][2] = 0;
+
+    // Permutation 1 has the highest norm, so reference_unpermutated_SCCS
+    // is permutated by {0,1,2};
+    Tensor<2,3> reference_hexa_permutated_SCCS;
+    reference_hexa_permutated_SCCS[0][0] = 1;
+    reference_hexa_permutated_SCCS[0][1] = 0;
+    reference_hexa_permutated_SCCS[0][2] = 0;
+    reference_hexa_permutated_SCCS[1][0] = 0;
+    reference_hexa_permutated_SCCS[1][1] = 0;
+    reference_hexa_permutated_SCCS[1][2] = 1;
+    reference_hexa_permutated_SCCS[2][0] = 0;
+    reference_hexa_permutated_SCCS[2][1] = 1;
+    reference_hexa_permutated_SCCS[2][2] = 0;
+
+    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
+    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
+    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
+    std::array<double,3> totals = {{0,0,0}};
+    for (size_t iii = 0; iii < 7; iii++)
+      {
+        // also check that the total is equal to the full norm.
+
+        for (size_t jjj = 0; jjj < 3; jjj++)
+          {
+            INFO("i:j = " << iii << ":" << jjj );
+            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
+            if (iii < 6)
+              {
+                totals[jjj] += norms[iii][jjj];
+              }
+          }
+      }
+    for (size_t jjj = 0; jjj < 3; jjj++)
+      {
+        INFO("j = " << jjj );
+        CHECK(totals[jjj] == Approx(norms[6][jjj]));
+      }
+
+    // also check that all the isotropic and totals are the same
+    for (size_t iii = 1; iii < 3; iii++)
+      {
+        CHECK(norms[5][0] == Approx(norms[5][iii]));
+        CHECK(norms[6][0] == Approx(norms[6][iii]));
+      }
+
+
+    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
+    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
+    Tensor<2,3> hexa_permutated_SCCS;
+    for (size_t index = 0; index < 3; index++)
+      {
+        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
+      }
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+  }
+
+  {
+    // This is testing some other elastic matrices of which the properties can
+    // be resonaly predicted (for example, mostly hexagonal) and some coverage
+    // testing: Case 4: from http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php (Be).
+    // This one should have at least in one direction almost all the the anistropy be
+    // hexagonal anisotropy.
+
+    SymmetricTensor<2,6> full_elastic_matrix;
+    full_elastic_matrix[0][0] = 192.3;
+    full_elastic_matrix[0][1] = 26.7;
+    full_elastic_matrix[0][2] = 14;
+    full_elastic_matrix[1][1] = full_elastic_matrix[0][0];
+    full_elastic_matrix[1][2] = full_elastic_matrix[0][2];
+    full_elastic_matrix[2][2] = 336.4;
+    full_elastic_matrix[3][3] = 162.5;
+    full_elastic_matrix[4][4] = full_elastic_matrix[3][3];
+    full_elastic_matrix[5][5] = 0.5*(full_elastic_matrix[0][0] + full_elastic_matrix[0][1]);
+
+    std::array<std::array<double,3>,7 > reference_norms;
+    reference_norms[0] = {{0,0,0}}; // no triclinic
+    reference_norms[1] = {{0,0,0}}; // no monoclinic
+    reference_norms[2] = {{16161.695,0.0,16161.695}}; // orthorhomic dependent on direction
+    reference_norms[3] = {{2786.31125,1425.78,2786.31125}}; // tetragonal could be present
+    reference_norms[4] = {{8079.22575,25601.452,8079.22575}}; // hexagonal is expected
+    reference_norms[5] = {{421517.088,421517.088,421517.088}}; // isotropic should be the same for every permutation
+    reference_norms[6] = {{448544.32,448544.32,448544.32}}; // total should be the same for every direction
+
+    // It is already in a SCCS frame, so they should be
+    // unit vectors. The order is irrelevant.
+    Tensor<2,3> reference_unpermutated_SCCS;
+    reference_unpermutated_SCCS[0][0] = 0;
+    reference_unpermutated_SCCS[0][1] = 0;
+    reference_unpermutated_SCCS[0][2] = 1;
+    reference_unpermutated_SCCS[1][0] = 1;
+    reference_unpermutated_SCCS[1][1] = 0;
+    reference_unpermutated_SCCS[1][2] = 0;
+    reference_unpermutated_SCCS[2][0] = 0;
+    reference_unpermutated_SCCS[2][1] = 1;
+    reference_unpermutated_SCCS[2][2] = 0;
+
+    // Permutation 2 has the highest norm, so reference_unpermutated_SCCS
+    // is permutated by {1,2,0};
+    Tensor<2,3> reference_hexa_permutated_SCCS;
+    reference_hexa_permutated_SCCS[0][0] = 1;
+    reference_hexa_permutated_SCCS[0][1] = 0;
+    reference_hexa_permutated_SCCS[0][2] = 0;
+    reference_hexa_permutated_SCCS[1][0] = 0;
+    reference_hexa_permutated_SCCS[1][1] = 1;
+    reference_hexa_permutated_SCCS[1][2] = 0;
+    reference_hexa_permutated_SCCS[2][0] = 0;
+    reference_hexa_permutated_SCCS[2][1] = 0;
+    reference_hexa_permutated_SCCS[2][2] = 1;
+
+    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
+    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
+    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
+    std::array<double,3> totals = {{0,0,0}};
+    for (size_t iii = 0; iii < 7; iii++)
+      {
+        // also check that the total is equal to the full norm.
+
+        for (size_t jjj = 0; jjj < 3; jjj++)
+          {
+            INFO("i:j = " << iii << ":" << jjj );
+            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
+            if (iii < 6)
+              {
+                totals[jjj] += norms[iii][jjj];
+              }
+          }
+      }
+    for (size_t jjj = 0; jjj < 3; jjj++)
+      {
+        INFO("j = " << jjj );
+        CHECK(totals[jjj] == Approx(norms[6][jjj]));
+      }
+
+    // also check that all the isotropic and totals are the same
+    for (size_t iii = 1; iii < 3; iii++)
+      {
+        CHECK(norms[5][0] == Approx(norms[5][iii]));
+        CHECK(norms[6][0] == Approx(norms[6][iii]));
+      }
+
+
+    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
+    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
+    Tensor<2,3> hexa_permutated_SCCS;
+    for (size_t index = 0; index < 3; index++)
+      {
+        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
+      }
+    for (size_t iii = 0; iii < 3; iii++)
+      {
+        const double epsilon = 1e-3;
+        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
+        // The direction of the eigenvectors is not important, but they do need to be consistent
+        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
+               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
+                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
+      }
+  }
+}
diff --git a/unit_tests/first.cc.bak b/unit_tests/first.cc.bak
new file mode 100644
index 00000000000..c38c7b9c367
--- /dev/null
+++ b/unit_tests/first.cc.bak
@@ -0,0 +1,89 @@
+/*
+  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <aspect/utilities.h>
+#include <aspect/citation_info.h>
+#include <deal.II/base/function_parser.h>
+
+TEST_CASE("floating point check example")
+{
+  // this would fail because of floating point arithmetic, but using Approx(f) will work:
+  //  REQUIRE(0.1*3.0 == 0.3);
+  REQUIRE(0.1*3.0 == Approx(0.3));
+}
+
+TEST_CASE("floating point std::vector checks")
+{
+  // here is how you can compare two std::vector<double>:
+  std::vector<double> computed = {0.1*3.0, 1.0};
+  std::vector<double> expected = {0.3, 1.0};
+
+  compare_vectors_approx(computed, expected);
+}
+
+TEST_CASE("Utilities::read_and_distribute_file_content")
+{
+  const std::string file_name = aspect::Utilities::expand_ASPECT_SOURCE_DIR("$ASPECT_SOURCE_DIR/VERSION");
+  const std::string content =
+    aspect::Utilities::read_and_distribute_file_content(file_name,
+                                                        MPI_COMM_WORLD);
+  REQUIRE(content.size()>0);
+
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::read_and_distribute_file_content("does-not-exist.cc",
+                                                        MPI_COMM_WORLD),
+    Contains("Could not open"));
+}
+
+TEST_CASE("function parser if() and division by zero")
+{
+  std::string variables = "x";
+  std::map<std::string,double> constants;
+
+  dealii::FunctionParser<1> fp(1);
+  fp.initialize(variables,
+                "if(x>0,1/x,-1)",
+                constants);
+  REQUIRE(fp.value(dealii::Point<1>(4.0)) == 0.25);
+  REQUIRE(fp.value(dealii::Point<1>(-5.0)) == -1.0);
+  // This will sadly trigger a floating point exception:
+  //REQUIRE(fp.value(dealii::Point<1>(0.0)) == -1.0);
+
+  fp.initialize(variables,
+                "(x>0) ? (1/x) : (-1)",
+                constants);
+  REQUIRE(fp.value(dealii::Point<1>(4.0)) == 0.25);
+  REQUIRE(fp.value(dealii::Point<1>(-5.0)) == -1.0);
+  REQUIRE(fp.value(dealii::Point<1>(0.0)) == -1.0);
+}
+
+TEST_CASE("citation test")
+{
+  using namespace aspect;
+  REQUIRE_THAT(CitationInfo::get_url_part(), StartsWith("citing.html?ver="));
+  CitationInfo::add("bla");
+  REQUIRE_THAT(CitationInfo::get_url_part(), StartsWith("citing.html?ver="));
+  REQUIRE_THAT(CitationInfo::get_url_part(), Contains("bla=1"));
+  REQUIRE_THAT(CitationInfo::get_url_part(), !Contains("blub"));
+  CitationInfo::add("blub");
+  REQUIRE_THAT(CitationInfo::get_url_part(), Contains("bla=1"));
+  REQUIRE_THAT(CitationInfo::get_url_part(), Contains("blub=1"));
+}
diff --git a/unit_tests/introspection.cc.bak b/unit_tests/introspection.cc.bak
new file mode 100644
index 00000000000..a74ea3834fc
--- /dev/null
+++ b/unit_tests/introspection.cc.bak
@@ -0,0 +1,135 @@
+/*
+  Copyright (C) 2024 - 2024 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+
+#include <aspect/parameters.h>
+#include <aspect/simulator.h>
+#include <aspect/introspection.h>
+
+TEST_CASE("Introspection::basic")
+{
+  using namespace aspect;
+  dealii::ParameterHandler prm;
+  Simulator<2>::declare_parameters(prm);
+
+
+  prm.set("Output directory", "");
+
+  prm.enter_subsection("Compositional fields");
+  prm.set("Number of fields", "3");
+  prm.set("Names of fields", "a,b,c");
+  prm.leave_subsection();
+
+  Parameters<2> parameters(prm, MPI_COMM_WORLD);
+
+  const std::vector<VariableDeclaration<2>> variables = construct_default_variables (parameters);
+  Introspection<2> introspection (variables, parameters);
+
+  dealii::FESystem<2> fe(introspection.get_fes(), introspection.get_multiplicities());
+  CHECK(fe.get_name() == "FESystem<2>[FE_Q<2>(2)^2-FE_Q<2>(1)-FE_Q<2>(2)-FE_Q<2>(2)^3]");
+
+  CHECK(introspection.n_components == 7);
+  CHECK(introspection.n_compositional_fields == 3);
+  CHECK(introspection.n_blocks == 6);
+
+  CHECK(introspection.component_indices.velocities[0] == 0);
+  CHECK(introspection.component_indices.velocities[1] == 1);
+  CHECK(introspection.component_indices.pressure == 2);
+  CHECK(introspection.component_indices.temperature == 3);
+  CHECK(introspection.component_indices.compositional_fields[0] == 4);
+
+  CHECK(introspection.block_indices.velocities == 0);
+  CHECK(introspection.block_indices.pressure == 1);
+  CHECK(introspection.block_indices.temperature == 2);
+  CHECK(introspection.block_indices.compositional_fields.size() == 3);
+  CHECK(introspection.block_indices.compositional_fields[0] == 3);
+  CHECK(introspection.block_indices.compositional_fields[1] == 4);
+  CHECK(introspection.block_indices.compositional_fields[2] == 5);
+
+  // sparsity pattern block index:
+  CHECK(introspection.block_indices.compositional_field_sparsity_pattern.size() == 3);
+  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[0] == 3);
+  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[1] == 3);
+  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[2] == 3);
+
+  CHECK(introspection.base_elements.velocities == 0);
+  CHECK(introspection.base_elements.pressure == 1);
+  CHECK(introspection.base_elements.temperature == 2);
+  // All compositional fields have the same FE:
+  CHECK(introspection.base_elements.compositional_fields == std::vector<unsigned int>({3,3,3}));
+  CHECK(introspection.get_composition_base_element_indices() == std::vector<unsigned int>({3}));
+  CHECK(introspection.get_compositional_field_indices_with_base_element(3) == std::vector<unsigned int>({0,1,2}));
+}
+
+TEST_CASE("Introspection::different-composition-types")
+{
+  using namespace aspect;
+  dealii::ParameterHandler prm;
+  Simulator<2>::declare_parameters(prm);
+
+
+  prm.set("Output directory", "");
+
+  prm.enter_subsection("Compositional fields");
+  prm.set("Number of fields", "3");
+  prm.set("Names of fields", "a,b,c");
+  prm.leave_subsection();
+  prm.enter_subsection("Discretization");
+  prm.set("Use discontinuous temperature discretization", "false");
+  prm.set("Use discontinuous composition discretization", "true,false,false");
+  prm.leave_subsection();
+
+  Parameters<2> parameters(prm, MPI_COMM_WORLD);
+
+  const std::vector<VariableDeclaration<2>> variables = construct_default_variables (parameters);
+  Introspection<2> introspection (variables, parameters);
+
+  dealii::FESystem<2> fe(introspection.get_fes(), introspection.get_multiplicities());
+  CHECK(fe.get_name() == "FESystem<2>[FE_Q<2>(2)^2-FE_Q<2>(1)-FE_Q<2>(2)-FE_DGQ<2>(2)-FE_Q<2>(2)^2]");
+
+  CHECK(introspection.n_components == 7);
+  CHECK(introspection.n_compositional_fields == 3);
+  CHECK(introspection.n_blocks == 6);
+
+  CHECK(introspection.component_indices.velocities[0] == 0);
+  CHECK(introspection.component_indices.velocities[1] == 1);
+  CHECK(introspection.component_indices.pressure == 2);
+  CHECK(introspection.component_indices.temperature == 3);
+  CHECK(introspection.component_indices.compositional_fields[0] == 4);
+
+  CHECK(introspection.block_indices.velocities == 0);
+  CHECK(introspection.block_indices.pressure == 1);
+  CHECK(introspection.block_indices.temperature == 2);
+  CHECK(introspection.block_indices.compositional_fields[0] == 3);
+  CHECK(introspection.block_indices.compositional_fields[1] == 4);
+  CHECK(introspection.block_indices.compositional_fields[2] == 5);
+
+  // sparsity pattern block index:
+  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[0] == 3);
+  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[1] == 4);
+  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[2] == 4);
+
+  // base elements:
+  CHECK(introspection.base_elements.compositional_fields == std::vector<unsigned int>({3,4,4}));
+  CHECK(introspection.get_composition_base_element_indices() == std::vector<unsigned int>({3,4}));
+  CHECK(introspection.get_compositional_field_indices_with_base_element(3) == std::vector<unsigned int>({0}));
+  CHECK(introspection.get_compositional_field_indices_with_base_element(4) == std::vector<unsigned int>({1,2}));
+}
diff --git a/unit_tests/mesh_refinement.cc.bak b/unit_tests/mesh_refinement.cc.bak
new file mode 100644
index 00000000000..efb33ec0053
--- /dev/null
+++ b/unit_tests/mesh_refinement.cc.bak
@@ -0,0 +1,59 @@
+/*
+  Copyright (C) 2020 - 2021 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <aspect/mesh_refinement/isosurfaces.h>
+
+namespace aspect
+{
+  namespace MeshRefinement
+  {
+    namespace internal
+    {
+      // Forward declaration
+      unsigned int min_max_string_to_int(const std::string &string_value, const unsigned int minimum_refinement_level, const unsigned int  maximum_refinement_level);
+    }
+  }
+}
+
+TEST_CASE("Isosurfaces min_max_string_to_int function")
+{
+
+  using namespace aspect::MeshRefinement::internal;
+  CHECK(min_max_string_to_int("min",1,5) == 1);
+  CHECK(min_max_string_to_int("min+1",1,5) == 2);
+  CHECK(min_max_string_to_int("min+2",1,5) == 3);
+  CHECK(min_max_string_to_int("min+3",1,5) == 4);
+  CHECK(min_max_string_to_int("min+4",1,5) == 5);
+  CHECK(min_max_string_to_int("max",1,5) == 5);
+  CHECK(min_max_string_to_int("max-1",1,5) == 4);
+  CHECK(min_max_string_to_int("max-2",1,5) == 3);
+  CHECK(min_max_string_to_int("max-3",1,5) == 2);
+  CHECK(min_max_string_to_int("max-4",1,5) == 1);
+  CHECK(min_max_string_to_int("2",1,5) == 2);
+
+  CHECK(min_max_string_to_int("6",1,5) == 5);
+  CHECK(min_max_string_to_int("0",1,5) == 1);
+  CHECK(min_max_string_to_int("min+5",1,5) == 5);
+  CHECK(min_max_string_to_int("max-5",1,5) == 1);
+
+  CHECK_THROWS_WITH(min_max_string_to_int("min-1",1,5),Contains("A value of min-1 was provided, but you can't provide a smaller value"));
+  CHECK_THROWS_WITH(min_max_string_to_int("max+1",1,5),Contains("A value of max+1 was provided, but you can't provide a larger value"));
+}
diff --git a/unit_tests/netcdf.cc.bak b/unit_tests/netcdf.cc.bak
new file mode 100644
index 00000000000..31de709c15a
--- /dev/null
+++ b/unit_tests/netcdf.cc.bak
@@ -0,0 +1,101 @@
+/*
+  Copyright (C) 2021 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <aspect/utilities.h>
+
+#ifdef ASPECT_WITH_NETCDF
+
+TEST_CASE("Utilities::load_netcdf-1d")
+{
+  using namespace dealii;
+
+  aspect::Utilities::StructuredDataLookup<1> lookup(1.0 /*scaling*/);
+  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/PREM_1s_depth.nc");
+
+  REQUIRE(lookup.get_column_names().size()==9);
+  REQUIRE(lookup.get_column_names()[0] == "radius");
+  REQUIRE(lookup.get_column_names()[2] == "vpv");
+
+  REQUIRE(lookup.get_data(Point<1>(1.0), 0) == Approx(6370.0)); // radius at depth = 1.0
+  REQUIRE(lookup.get_data(Point<1>(1.0), 2) == Approx(1.45)); // vpv at depth = 1.0
+}
+
+TEST_CASE("Utilities::load_netcdf-1d-column-names")
+{
+  using namespace dealii;
+
+  aspect::Utilities::StructuredDataLookup<1> lookup(1.0 /*scaling*/);
+  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/PREM_1s_depth.nc",
+                     std::vector<std::string> {"vpv","radius"});
+
+  REQUIRE(lookup.get_column_names().size()==2);
+  REQUIRE(lookup.get_column_names()[0] == "vpv");
+  REQUIRE(lookup.get_column_names()[1] == "radius");
+
+  REQUIRE(lookup.get_data(Point<1>(1.0), 0) == Approx(1.45)); // vpv at depth = 1.0
+  REQUIRE(lookup.get_data(Point<1>(1.0), 1) == Approx(6370.0)); // radius at depth = 1.0
+}
+
+TEST_CASE("Utilities::load_netcdf-3d")
+{
+  using namespace dealii;
+
+  aspect::Utilities::StructuredDataLookup<3> lookup(1.0 /*scaling*/);
+  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/test-3d-cartesian.nc");
+
+  REQUIRE(lookup.get_column_names().size()==2);
+  REQUIRE(lookup.get_column_names()[0] == "index");
+  REQUIRE(lookup.get_column_names()[1] == "depth");
+
+  REQUIRE(lookup.get_data(Point<3>(0., 500., 0.), 0) == Approx(0.));
+  REQUIRE(lookup.get_data(Point<3>(1000., 500., 0.), 0) == Approx(1.));
+}
+
+TEST_CASE("Utilities::load_netcdf-3d-spherical")
+{
+  using namespace dealii;
+
+  aspect::Utilities::StructuredDataLookup<3> lookup(1.0 /*scaling*/);
+  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/test-3d-spherical.nc");
+
+  REQUIRE(lookup.get_column_names().size()==1);
+  REQUIRE(lookup.get_column_names()[0] == "vs_anomaly");
+
+  REQUIRE(lookup.get_data(Point<3>(5297311.3326, 2.0944, 2.793), 0) == Approx(6423.5));
+  REQUIRE(lookup.get_data(Point<3>(6252530.6549, 4.1888, 3.142), 0) == Approx(4574.6));
+}
+
+TEST_CASE("Utilities::load_netcdf-3d-column-names")
+{
+  using namespace dealii;
+
+  aspect::Utilities::StructuredDataLookup<3> lookup(1.0 /*scaling*/);
+  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/test-3d-cartesian.nc",
+                     std::vector<std::string> {"index"});
+
+  REQUIRE(lookup.get_column_names().size()==1);
+  REQUIRE(lookup.get_column_names()[0] == "index");
+
+  REQUIRE(lookup.get_data(Point<3>(0., 500., 0.), 0) == Approx(0.));
+  REQUIRE(lookup.get_data(Point<3>(1000., 500., 0.), 0) == Approx(1.));
+}
+
+#endif
diff --git a/unit_tests/parse_map_to_double_array.cc.bak b/unit_tests/parse_map_to_double_array.cc.bak
new file mode 100644
index 00000000000..92669f9a9ba
--- /dev/null
+++ b/unit_tests/parse_map_to_double_array.cc.bak
@@ -0,0 +1,460 @@
+/*
+  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <aspect/utilities.h>
+#include <deal.II/base/exceptions.h>
+
+
+TEST_CASE("Utilities::parse_map_to_double_array")
+{
+  // Parse multicomponent properties
+  INFO("check 1: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, C4:400, C5:500, background:0",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"),
+  {0.0,100.0,200.0,300.0,400.0,500.0});
+
+  INFO("check 2: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("all:100",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"),
+  {100.0,100.0,100.0,100.0,100.0,100.0});
+
+  INFO("check 3: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("background:0, C1:100, C2:200, C3:300, C4:400, C5:500",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"),
+  {0.0,100.0,200.0,300.0,400.0,500.0});
+
+  INFO("check 4: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("background:0, C2:200, C1:100, C4:400, C5:500, C3:300",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"),
+  {0.0,100.0,200.0,300.0,400.0,500.0});
+
+  INFO("check 5: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, background:0, C3:300, C4:400, C5:500",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"),
+  {0.0,100.0,200.0,300.0,400.0,500.0});
+
+  INFO("check 6: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("100, 200, 300, 400, 500",
+  {"C1","C2","C3","C4","C5"},
+  false,
+  "TestField"),
+  {100.0,200.0,300.0,400.0,500.0});
+
+  INFO("check 7: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, C4:400, C5:500",
+  {"C1","C2","C3","C4","C5"},
+  false,
+  "TestField"),
+  {100.0,200.0,300.0,400.0,500.0});
+
+  INFO("check 8: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("background:0, C2:200, C1:100, C4:400, C5:500, C3:300",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"),
+  {0.0,100.0,200.0,300.0,400.0,500.0});
+
+  {
+    INFO("check 9: ");
+    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|100, C3:300, C4:400, C5:500, background:0",
+    {"C1","C2","C3","C4","C5"},
+    true,
+    "TestField",
+    true,
+    n_values_per_key),
+    {0.0,100.0,200.0,100.0,300.0,400.0,500.0});
+
+    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,1,2,1,1,1}));
+  }
+
+  {
+    INFO("check 10: ");
+    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|, C3:300, C4:400, C5:500",
+    {"C1","C2","C3","C4","C5"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    {100.0,200.0,300.0,400.0,500.0});
+
+    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,1,1,1,1}));
+  }
+
+  {
+    INFO("check 11: ");
+    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C4:400, C5:500",
+    {"C1","C2","C3","C4","C5"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    {100.0,200.0,300.0,300.0,400.0,500.0});
+
+    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,2,1,1,1}));
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C4:400, C5:500",
+    {"C1","C2","C3","C4","C5"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    {100.0,200.0,300.0,300.0,400.0,500.0});
+  }
+
+  {
+    INFO("check 12: ");
+    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("all:300|400",
+    {"C1","C2"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    {300.0,400.0,300.0,400.0});
+
+    REQUIRE(*n_values_per_key == std::vector<unsigned int> ({2,2}));
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("all:100|200",
+    {"C1","C2"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    {100.0,200.0,100.0,200.0});
+  }
+
+  INFO("check 13: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("background:0, C1:100, C4:400, C5:500, C3:300",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField",
+  false,
+  nullptr,
+  true),
+  {0.0,100.0,300.0,400.0,500.0});
+
+  INFO("check 14: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C4:400, C5:500, C3:300",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField",
+  false,
+  nullptr,
+  true),
+  {100.0,300.0,400.0,500.0});
+
+  INFO("check 16: ");
+  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField",
+  false,
+  nullptr,
+  true),
+  std::vector<double>());
+
+  {
+    INFO("check 17: ");
+    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C5:500",
+    {"C1","C2","C3","C4","C5"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key,
+    true),
+    {100.0,200.0,300.0,300.0,500.0});
+
+    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,2,1,0,1}));
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C5:500",
+    {"C1","C2","C3","C4","C5"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key,
+    true),
+    {100.0,200.0,300.0,300.0,500.0});
+  }
+
+  {
+    INFO("check 18: ");
+    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>(std::vector<unsigned int>({2,2}));
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:300|400, C2:200",
+    {"C1","C2"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    {300.0,400.0,200.0,200.0});
+
+    INFO("check 19: ");
+
+    // still using the compare_vectors_approx defined before
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("200",
+    {"C1","C2"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    {200.0,200.0,200.0,200.0});
+  }
+
+  {
+    // Check that we can provide additional allowed keys that are ignored when parsing
+    INFO("check 20: ");
+    aspect::Utilities::MapParsing::Options options({"C1","C2","C3","C5"},"TestField");
+    options.list_of_allowed_keys = {"C1","C2","C3","C4","C5","C6","C7"};
+
+    std::string input_string = "C1:100, C2:200, C3:300, C5:500";
+
+    compare_vectors_approx(aspect::Utilities::MapParsing::parse_map_to_double_array (input_string, options),
+    {100.0,200.0,300.0,500.0});
+  }
+  INFO("check complete");
+
+}
+
+using Catch::Matchers::Contains;
+
+TEST_CASE("Utilities::parse_map_to_double_array FAIL ON PURPOSE")
+{
+  // Purposefully fail Parse multicomponent properties
+  INFO("check fail 1: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_map_to_double_array ("C1:100, C1:200, C3:300, C4:400, C5:500",
+  {"C1","C2","C3","C4","C5"},
+  false,
+  "TestField"), Contains("is listed multiple times"));
+
+
+  INFO("check fail 2: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, C4:400, C5:500",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"), Contains("The keyword <background> in TestField is not listed"));
+
+
+  INFO("check fail 3: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_map_to_double_array ("C1:100, C1:200, C3:300, C4;400, C5:500, bg:3",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"), Contains("does not have the expected format"));
+
+
+  INFO("check fail 4: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, C4:400, C24:500, bg:3",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"), Contains("does not match any entries"));
+
+  INFO("check fail 5: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, all:400, C5:500, bg:3",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"), Contains("The keyword `all' in the property TestField is only allowed if"));
+
+  INFO("check fail 6: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_map_to_double_array ("C1:100",
+  {"C1","C2","C3","C4","C5"},
+  true,
+  "TestField"), Contains("The keyword <background> in TestField is not listed"));
+
+  // Subentries not allowed
+  INFO("check fail 7: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:100|200, C3:300, C4:400, C5:500",
+  {"C1","C2","C3","C4","C5"},
+  false,
+  "TestField"), Contains("The keyword <C2> in TestField has multiple values"));
+
+  // Wrong subentry format
+  INFO("check fail 8: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:|200, C3:300, C4:400, C5:500",
+  {"C1","C2","C3","C4","C5"},
+  false,
+  "TestField",
+  true), Contains("does not have the expected format"));
+
+  // No subentries
+  INFO("check fail 9: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:|, C3:300, C4:400, C5:500",
+  {"C1","C2","C3","C4","C5"},
+  false,
+  "TestField",
+  true), Contains("does not have the expected format"));
+
+  // Wrong input structure
+  {
+    INFO("check fail 10: ");
+    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C4:400, C5:500",
+    {"C1","C2","C3","C4","C5"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    {100.0,200.0,300.0,300.0,400.0,500.0});
+
+    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,2,1,1,1}));
+
+    REQUIRE_THROWS_WITH(aspect::Utilities::parse_map_to_double_array ("C1:100|200, C2:300, C3:300, C4:400, C5:500",
+    {"C1","C2","C3","C4","C5"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    Contains("The key <C1> in <TestField> does not have the expected number"));
+  }
+
+  {
+    INFO("check fail 11: ");
+    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
+
+    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("all:300|400",
+    {"C1","C2"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    {300.0,400.0,300.0,400.0});
+
+    REQUIRE(*n_values_per_key == std::vector<unsigned int>({2,2}));
+
+    REQUIRE_THROWS_WITH(aspect::Utilities::parse_map_to_double_array ("all:100|200|300",
+    {"C1","C2"},
+    false,
+    "TestField",
+    true,
+    n_values_per_key),
+    Contains("The key <C1> in <TestField> does not have the expected number"));
+  }
+}
+
+
+TEST_CASE("Utilities::parse_input_table")
+{
+  // Parse multicomponent properties
+  INFO("check 1: ");
+
+  dealii::Table<2,double> expected_result(3,3);
+
+  expected_result[0][0] = 100.0;
+  expected_result[0][1] = 10.0;
+  expected_result[0][2] = 30.0;
+  expected_result[1][0] = 25.0;
+  expected_result[1][1] = 5.0;
+  expected_result[1][2] = 1500.0;
+  expected_result[2][0] = 0.001;
+  expected_result[2][1] = 0.1;
+  expected_result[2][2] = 3.5;
+
+
+  compare_tables_approx(aspect::Utilities::parse_input_table<double> ("100,10,30; 25.0,5.0 ,1.5e3; 0.001,10e-2,3.5",
+                                                                      3, 3, "TestField"),
+                        expected_result);
+
+  expected_result[0][0] = 100.0;
+  expected_result[0][1] = 10.0;
+  expected_result[0][2] = 30.0;
+  expected_result[1][0] = 100.0;
+  expected_result[1][1] = 10.0;
+  expected_result[1][2] = 30.0;
+  expected_result[2][0] = 100.0;
+  expected_result[2][1] = 10.0;
+  expected_result[2][2] = 30.0;
+
+
+  compare_tables_approx(aspect::Utilities::parse_input_table<double> ("100,10,30",
+                                                                      3, 3, "TestField"),
+                        expected_result);
+
+  expected_result[0][0] = 100.0;
+  expected_result[0][1] = 100.0;
+  expected_result[0][2] = 100.0;
+  expected_result[1][0] = 10.0;
+  expected_result[1][1] = 10.0;
+  expected_result[1][2] = 10.0;
+  expected_result[2][0] = 30.0;
+  expected_result[2][1] = 30.0;
+  expected_result[2][2] = 30.0;
+
+
+  compare_tables_approx(aspect::Utilities::parse_input_table<double> ("100;10;30",
+                                                                      3, 3, "TestField"),
+                        expected_result);
+
+  INFO("check complete");
+
+}
+
+using Catch::Matchers::Contains;
+
+TEST_CASE("Utilities::parse_input_table FAIL ON PURPOSE")
+{
+  // Purposefully fail Parse multicomponent properties
+  INFO("check fail 1: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_input_table<double> ("100,10,30; 25.0,5.0 ,1.5e3",
+                                                  3,3,
+                                                  "TestField"), Contains("Length of TestField"));
+
+  // Purposefully fail Parse multicomponent properties
+  INFO("check fail 2: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_input_table<double> ("100,10; 25.0,5.0; 5.0,2.5",
+                                                  3,3,
+                                                  "TestField"), Contains("Length of TestField"));
+
+  // Purposefully fail Parse multicomponent properties
+  INFO("check fail 3: ");
+  REQUIRE_THROWS_WITH(
+    aspect::Utilities::parse_input_table<double> ("100,10; a,5.0; 5.0,2.5",
+                                                  3,2,
+                                                  "TestField"), Contains("bad lexical cast"));
+}
diff --git a/unit_tests/particles.cc.bak b/unit_tests/particles.cc.bak
new file mode 100644
index 00000000000..8cff8cea568
--- /dev/null
+++ b/unit_tests/particles.cc.bak
@@ -0,0 +1,56 @@
+/*
+  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <aspect/particle/property/interface.h>
+#include <aspect/particle/world.h>
+#include <deal.II/base/parameter_handler.h>
+
+TEST_CASE("Particle Manager plugin names")
+{
+  dealii::ParameterHandler prm;
+  aspect::Particle::Property::Manager<2> manager;
+  // The property manager needs to know about the integrator, which is declared in World
+  aspect::Particle::World<2>::declare_parameters(prm);
+
+  prm.enter_subsection("Particles");
+  manager.declare_parameters(prm);
+  prm.set("List of particle properties","composition, position");
+  manager.parse_parameters(prm);
+  prm.leave_subsection();
+
+  // existing and listed pluring
+  REQUIRE(manager.plugin_name_exists("composition") == true);
+  REQUIRE(manager.plugin_name_exists("position") == true);
+
+  // existing but not listed plugin
+  REQUIRE(manager.plugin_name_exists("pT path") == false);
+
+  // non-existed plugin
+  REQUIRE(manager.plugin_name_exists("non-existent plugin name") == false);
+
+  // check that one is before the other
+  REQUIRE(manager.check_plugin_order("composition", "position") == true);
+  REQUIRE(manager.check_plugin_order("position", "composition") == false);
+
+  // Check the plugin indices
+  REQUIRE(manager.get_plugin_index_by_name("composition") == 0);
+  REQUIRE(manager.get_plugin_index_by_name("position") == 1);
+}
diff --git a/unit_tests/termination_criteria.cc.bak b/unit_tests/termination_criteria.cc.bak
new file mode 100644
index 00000000000..a98c9483c08
--- /dev/null
+++ b/unit_tests/termination_criteria.cc.bak
@@ -0,0 +1,68 @@
+/*
+  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <aspect/termination_criteria/steady_temperature.h>
+
+
+/**
+ * A function that trims the handed over list and removes all entries from the front that are
+ * further back in time measured from the last entry than given by the first argument.
+ * Additionally it makes sure to always keep two entries in the list, if the list had
+ * two or more entries. Otherwise the function does not change the list.
+ */
+void trim_time_temperature_list (const double necessary_time_in_steady_state,
+                                 std::list<std::pair<double, double>> &time_temperature_list)
+{
+  // Remove old times until we're at the correct time period
+  // but ensure at least two entries remain in the list (one old, one current timestep)
+  auto it = time_temperature_list.begin();
+  while (time_temperature_list.back().first - (*it).first > necessary_time_in_steady_state &&
+         std::distance(it,time_temperature_list.end()) > 2)
+    ++it;
+
+  time_temperature_list.erase(time_temperature_list.begin(), it);
+}
+
+
+TEST_CASE("trim time_temperature_list test for steady state termination criteria")
+{
+  std::list<std::pair<double,double>> time_temperature;
+  time_temperature.emplace_back(0.0,1.0);
+  time_temperature.emplace_back(1.0,2.0);
+  time_temperature.emplace_back(1.4,3.0);
+
+  trim_time_temperature_list(1.5,time_temperature);
+
+  REQUIRE(time_temperature.front().second == 1.0);
+  REQUIRE(time_temperature.back().second == 3.0);
+
+  // Remove first entry because it is more than 1.0 away from last entry
+  trim_time_temperature_list(1.0,time_temperature);
+
+  REQUIRE(time_temperature.front().second == 2.0);
+  REQUIRE(time_temperature.back().second == 3.0);
+
+  // Try to remove first entry, should not change list, since it should keep at least 2 entries
+  trim_time_temperature_list(0.3,time_temperature);
+
+  REQUIRE(time_temperature.front().second == 2.0);
+  REQUIRE(time_temperature.back().second == 3.0);
+}
diff --git a/unit_tests/utilities.cc.bak b/unit_tests/utilities.cc.bak
new file mode 100644
index 00000000000..830dbc9eae1
--- /dev/null
+++ b/unit_tests/utilities.cc.bak
@@ -0,0 +1,628 @@
+/*
+  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
+
+  This file is part of ASPECT.
+
+  ASPECT is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2, or (at your option)
+  any later version.
+
+  ASPECT is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ASPECT; see the file LICENSE.  If not see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <aspect/utilities.h>
+
+TEST_CASE("Utilities::weighted_p_norm_average")
+{
+  std::vector<double> weights = {1,1,2,2,3,3};
+  std::vector<double> values = {6,5,4,3,2,1};
+  std::vector<double> p_norms = {-1000,-2.5,-2,-1,0,1,2,2.5,3,4,1000};
+  std::vector<double> expected = {1., 1.59237, 1.6974 , 1.98895, 2.38899, 2.83333, 3.24037, 3.41824, 3.57872, 3.85347, 6. };
+
+  for (unsigned int i = 0; i < p_norms.size(); i++)
+    {
+      INFO("check i=" << i << ": ");
+      REQUIRE(aspect::Utilities::weighted_p_norm_average(weights,values,p_norms[i]) == Approx(expected[i]));
+    }
+
+}
+
+TEST_CASE("Utilities::AsciiDataLookup")
+{
+  using namespace dealii;
+
+  //TODO: add support for setting data directly instead of relying on a file to load:
+  aspect::Utilities::StructuredDataLookup<1> lookup(2 /*n_components*/, 1.0 /*scaling*/);
+  const std::string data_filename = aspect::Utilities::expand_ASPECT_SOURCE_DIR("$ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/box_2d_left.0.txt");
+  lookup.load_file(data_filename, MPI_COMM_WORLD);
+
+  INFO(lookup.get_data(Point<1>(330000./2.0),0));
+  INFO(lookup.get_data(Point<1>(330000./2.0),1));
+  INFO(lookup.get_gradients(Point<1>(330000./2.0),0));
+  INFO(lookup.get_gradients(Point<1>(330000./2.0),1));
+
+  REQUIRE(lookup.get_data(Point<1>(330000./2.0),0) == Approx(0.5));
+  REQUIRE(lookup.get_data(Point<1>(330000./2.0),1) == Approx(0.0));
+  REQUIRE(lookup.get_gradients(Point<1>(330000./2.0),0)[0] == Approx(-1.0/330000.));
+  REQUIRE(lookup.get_gradients(Point<1>(330000./2.0),1)[0] == Approx(0.0));
+}
+
+
+TEST_CASE("Utilities::AsciiDataLookup manual dim=1")
+{
+  using namespace dealii;
+
+  aspect::Utilities::StructuredDataLookup<1> lookup(2 /*n_components*/, 1.0 /*scaling*/);
+
+  std::vector<std::string> column_names = {"a", "b"};
+  Table<1,double> table(2);
+  std::vector<Table<1,double>> raw_data(2, table);
+
+  std::vector<std::vector<double>> coordinate_values(1, std::vector<double>({1.0, 2.0}));
+  // c1:
+  raw_data[0](0) = 0.0;
+  raw_data[0](1) = 1.0;
+  // c2:
+  raw_data[1](0) = 5.0;
+  raw_data[1](1) = 3.0;
+
+  lookup.reinit(column_names, std::move(coordinate_values), std::move(raw_data),
+                MPI_COMM_SELF, numbers::invalid_unsigned_int);
+
+  INFO(lookup.get_data(Point<1>(1.5), 0));
+  INFO(lookup.get_data(Point<1>(1.5), 1));
+
+  REQUIRE(lookup.get_data(Point<1>(1.5),0) == Approx(0.5));
+  REQUIRE(lookup.get_data(Point<1>(1.5),1) == Approx(4.0));
+
+  REQUIRE(lookup.get_gradients(Point<1>(1.5),0)[0] == Approx(1.0));
+  REQUIRE(lookup.get_gradients(Point<1>(1.5),1)[0] == Approx(-2.0));
+}
+
+TEST_CASE("Utilities::AsciiDataLookup manual dim=2")
+{
+  using namespace dealii;
+
+  aspect::Utilities::StructuredDataLookup<2> lookup(1 /*n_components*/, 1.0 /*scaling*/);
+
+  std::vector<std::string> column_names = {"topography"};
+  std::vector<Table<2,double>> raw_data(1, Table<2,double>(3,3));
+  std::vector<std::vector<double>> coordinate_values(2, std::vector<double>(3, 0.));
+
+  // x:
+  coordinate_values[0] = {0., 1., 3.};
+  // y:
+  coordinate_values[1] = {5., 6., 7.};
+  // c1:
+  raw_data[0](0,0) = 1.0;
+  raw_data[0](1,0) = 2.0;
+  raw_data[0](2,0) = 3.0;
+  raw_data[0](0,1) = 4.0;
+  raw_data[0](1,1) = 5.0;
+  raw_data[0](2,1) = 6.0;
+  raw_data[0](0,2) = 0.0;
+  raw_data[0](1,2) = 0.0;
+  raw_data[0](2,2) = 0.0;
+
+  lookup.reinit(column_names, std::move(coordinate_values), std::move(raw_data),
+                MPI_COMM_SELF, numbers::invalid_unsigned_int);
+
+  REQUIRE(lookup.get_data(Point<2>(1.0,6.0),0) == Approx(5.0));
+  REQUIRE(lookup.get_data(Point<2>(2.0,6.0),0) == Approx(5.5));
+}
+
+TEST_CASE("Utilities::AsciiDataLookup manual dim=2 equid")
+{
+  using namespace dealii;
+
+  aspect::Utilities::StructuredDataLookup<2> lookup(1 /*n_components*/, 1.0 /*scaling*/);
+
+  std::vector<std::string> column_names = {"topography"};
+  std::vector<Table<2,double>> raw_data(1, Table<2,double>(3,3));
+  std::vector<std::vector<double>> coordinate_values(2, std::vector<double>(3, 0.));
+
+  // x:
+  coordinate_values[0] = {0., 1., 2.};
+  // y:
+  coordinate_values[1] = {5., 6., 7.};
+  // c1:
+  raw_data[0](0,0) = 1.0;
+  raw_data[0](1,0) = 2.0;
+  raw_data[0](2,0) = 3.0;
+  raw_data[0](0,1) = 4.0;
+  raw_data[0](1,1) = 5.0;
+  raw_data[0](2,1) = 6.0;
+  raw_data[0](0,2) = 0.0;
+  raw_data[0](1,2) = 0.0;
+  raw_data[0](2,2) = 0.0;
+
+  lookup.reinit(column_names, std::move(coordinate_values), std::move(raw_data),
+                MPI_COMM_SELF, numbers::invalid_unsigned_int);
+
+  REQUIRE(lookup.get_data(Point<2>(1.0,6.0),0) == Approx(5.0));
+  REQUIRE(lookup.get_data(Point<2>(1.5,6.0),0) == Approx(5.5));
+}
+
+TEST_CASE("Random draw volume weighted average rotation matrix")
+{
+  std::vector<double> unsorted_volume_fractions = {2.,5.,1.,3.,6.,4.};
+  std::vector<double> sorted_volume_fractions_ref = {1.,2.,3.,4.,5.,6.};
+  const std::vector<std::size_t> permutation = aspect::Utilities::compute_sorting_permutation<double>(unsorted_volume_fractions);
+  const std::vector<double> sorted_volume_fractions = aspect::Utilities::apply_permutation<double>(unsorted_volume_fractions,permutation);
+
+  for (unsigned int i = 0; i < sorted_volume_fractions.size(); i++)
+    {
+      REQUIRE(sorted_volume_fractions[i] == Approx(sorted_volume_fractions_ref[i]));
+    }
+
+  const std::vector<dealii::Tensor<2,3>> unsorted_rotation_matrices =
+  {
+    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
+    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
+    dealii::Tensor<2,3>({{1.,1.,1.},{1.,1.,1.},{1.,1.,1.}}),
+    dealii::Tensor<2,3>({{3.,3.,3.},{3.,3.,3.},{3.,3.,3.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}})
+  };
+
+  const std::vector<dealii::Tensor<2,3>> sorted_rotation_matrices_ref =
+  {
+    dealii::Tensor<2,3>({{1.,1.,1.},{1.,1.,1.},{1.,1.,1.}}),
+    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
+    dealii::Tensor<2,3>({{3.,3.,3.},{3.,3.,3.},{3.,3.,3.}}),
+    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}}),
+    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}})
+  };
+  const std::vector<dealii::Tensor<2,3>> sorted_rotation_matrices = aspect::Utilities::apply_permutation<dealii::Tensor<2,3>>(unsorted_rotation_matrices,permutation);
+  for (unsigned int i = 0; i < sorted_rotation_matrices.size(); i++)
+    {
+      REQUIRE(sorted_rotation_matrices[i][0][0] == Approx(sorted_rotation_matrices_ref[i][0][0]));
+    }
+
+  std::mt19937 random_number_generator;
+  random_number_generator.seed(5);
+  const std::vector<dealii::Tensor<2,3>> result = aspect::Utilities::rotation_matrices_random_draw_volume_weighting(unsorted_volume_fractions,
+                                                   unsorted_rotation_matrices,
+                                                   25,
+                                                   random_number_generator);
+
+  const std::vector<dealii::Tensor<2,3>> result_ref =
+  {
+    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
+    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}}),
+    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}}),
+    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{3.,3.,3.},{3.,3.,3.},{3.,3.,3.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
+    dealii::Tensor<2,3>({{3.,3.,3.},{3.,3.,3.},{3.,3.,3.}}),
+    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
+    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{1.,1.,1.},{1.,1.,1.},{1.,1.,1.}}),
+    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
+  };
+  for (unsigned int i = 0; i < result.size(); i++)
+    {
+      REQUIRE(result[i][0][0] == Approx(result_ref[i][0][0]));
+    }
+}
+
+TEST_CASE("wrap angle")
+{
+  REQUIRE(aspect::Utilities::wrap_angle(-720.) == 0.);
+  REQUIRE(aspect::Utilities::wrap_angle(-540.) == 180.);
+  REQUIRE(aspect::Utilities::wrap_angle(-361.) == 359.);
+  REQUIRE(aspect::Utilities::wrap_angle(-360.) == 0.);
+  REQUIRE(aspect::Utilities::wrap_angle(-359.) == 1.);
+  REQUIRE(aspect::Utilities::wrap_angle(-270.) == 90.);
+  REQUIRE(aspect::Utilities::wrap_angle(-180.) == 180.);
+  REQUIRE(aspect::Utilities::wrap_angle(-90.) == 270.);
+  REQUIRE(aspect::Utilities::wrap_angle(0.) == 0.);
+  REQUIRE(aspect::Utilities::wrap_angle(90.) == 90.);
+  REQUIRE(aspect::Utilities::wrap_angle(180.) == 180.);
+  REQUIRE(aspect::Utilities::wrap_angle(270.) == 270.);
+  REQUIRE(aspect::Utilities::wrap_angle(359.) == 359.);
+  REQUIRE(aspect::Utilities::wrap_angle(360.) == 0.);
+  REQUIRE(aspect::Utilities::wrap_angle(361.) == 1.);
+  REQUIRE(aspect::Utilities::wrap_angle(540.) == 180.);
+  REQUIRE(aspect::Utilities::wrap_angle(720.) == 0.);
+}
+
+TEST_CASE("CPO elastic tensor transform functions")
+{
+  dealii::SymmetricTensor<2,6> reference_elastic_tensor({1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21});
+
+// first test whether the functions are invertable
+  {
+    dealii::SymmetricTensor<2,6> result_up_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor));
+
+    for (size_t i = 0; i < 6; i++)
+      {
+        for (size_t j = 0; j < 6; j++)
+          {
+            REQUIRE(reference_elastic_tensor[i][j] == Approx(result_up_down[i][j]));
+          }
+      }
+  }
+  {
+    dealii::SymmetricTensor<2,6> result_down_up = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_elastic_tensor));
+
+    for (size_t i = 0; i < 6; i++)
+      {
+        for (size_t j = 0; j < 6; j++)
+          {
+            REQUIRE(reference_elastic_tensor[i][j] == Approx(result_down_up[i][j]));
+          }
+      }
+  }
+  {
+    dealii::SymmetricTensor<2,6> result_up_2down_up = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(aspect::Utilities::Tensors::to_voigt_stiffness_vector(aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
+
+    for (size_t i = 0; i < 6; i++)
+      {
+        for (size_t j = 0; j < 6; j++)
+          {
+            REQUIRE(reference_elastic_tensor[i][j] == Approx(result_up_2down_up[i][j]));
+          }
+      }
+  }
+
+  // test rotations
+  // rotation matrix
+  dealii::Tensor<2,3> rotation_tensor;
+
+  {
+
+    // fill the rotation matrix with a rotations in all directions
+    {
+      double radians = 0;
+      double alpha = radians;
+      double beta = radians;
+      double gamma = radians;
+      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
+      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
+      rotation_tensor[0][2] = -std::sin(beta);
+      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
+      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
+      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
+      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
+      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
+      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
+    }
+
+    {
+      dealii::SymmetricTensor<4,3> result_full_stiffness_tensor = aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor);
+      dealii::SymmetricTensor<4,3> result_full_stiffness_tensor_rotate_zero = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,result_full_stiffness_tensor);
+
+      // first check that one the tensors didn't change with zero rotation
+      for (size_t i = 0; i < 3; i++)
+        {
+          for (size_t j = 0; j < 3; j++)
+            {
+              for (size_t k = 0; k < 3; k++)
+                {
+                  for (size_t l = 0; l < 3; l++)
+                    {
+                      REQUIRE(result_full_stiffness_tensor[i][j][k][l] == Approx(result_full_stiffness_tensor_rotate_zero[i][j][k][l]));
+                    }
+                }
+            }
+        }
+    }
+
+    {
+      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
+                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
+                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
+      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor,reference_elastic_tensor);
+
+      // first check that one the tensors didn't change with zero rotation
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_up_1_rotate_down[i][j] == Approx(reference_elastic_tensor[i][j]));
+              REQUIRE(result_1_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
+            }
+        }
+
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
+            }
+        }
+    }
+
+    // fill the rotation matrix with a rotations in all directions
+    {
+      double radians = (dealii::numbers::PI/180.0)*(360/5); //0.35*dealii::numbers::PI; //(dealii::numbers::PI/180.0)*36;
+      double alpha = radians;
+      double beta = radians;
+      double gamma = radians;
+      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
+      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
+      rotation_tensor[0][2] = -std::sin(beta);
+      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
+      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
+      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
+      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
+      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
+      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
+    }
+
+    {
+      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
+                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
+                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
+      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor,reference_elastic_tensor);
+
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
+            }
+        }
+
+      dealii::SymmetricTensor<4,3> result_up_10_rotate = aspect::Utilities::Tensors::to_full_stiffness_tensor(result_up_1_rotate_down);
+
+      dealii::SymmetricTensor<2,6> result_5_rotate = result_1_rotate;
+
+      for (size_t i = 0; i < 4; i++)
+        {
+          result_up_10_rotate = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,result_up_10_rotate);
+          result_5_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, result_5_rotate);
+        }
+
+      dealii::SymmetricTensor<2,6> result_up_10_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(result_up_10_rotate);
+
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_5_rotate[i][j] == Approx(result_up_10_rotate_down[i][j]));
+              // This test doesn't work when rotating in all rotations at the same time.
+              //REQUIRE(result_1_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
+            }
+        }
+    }
+  }
+  {
+    // fill the rotation matrix with a rotations in the alpha direction
+    {
+      double radians = (dealii::numbers::PI/180.0)*(360/5); //0.35*dealii::numbers::PI; //(dealii::numbers::PI/180.0)*36;
+      double alpha = radians;
+      double beta = 0;
+      double gamma = 0;
+      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
+      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
+      rotation_tensor[0][2] = -std::sin(beta);
+      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
+      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
+      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
+      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
+      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
+      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
+    }
+
+    {
+      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
+                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
+                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
+      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor,reference_elastic_tensor);
+
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
+            }
+        }
+
+      dealii::SymmetricTensor<4,3> result_up_10_rotate = aspect::Utilities::Tensors::to_full_stiffness_tensor(result_up_1_rotate_down);
+
+      dealii::SymmetricTensor<2,6> result_5_rotate = result_1_rotate;
+
+      for (size_t i = 0; i < 4; i++)
+        {
+          result_up_10_rotate = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor, result_up_10_rotate);
+          result_5_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, result_5_rotate);
+        }
+
+      dealii::SymmetricTensor<2,6> result_up_10_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(result_up_10_rotate);
+
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_5_rotate[i][j] == Approx(result_up_10_rotate_down[i][j]));
+              REQUIRE(result_5_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
+            }
+        }
+    }
+  }
+  {
+    // fill the rotation matrix with a rotations in the beta direction
+    {
+      double radians = (dealii::numbers::PI/180.0)*(360/5); //0.35*dealii::numbers::PI; //(dealii::numbers::PI/180.0)*36;
+      double alpha = 0;
+      double beta = radians;
+      double gamma = 0;
+      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
+      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
+      rotation_tensor[0][2] = -std::sin(beta);
+      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
+      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
+      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
+      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
+      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
+      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
+    }
+
+    {
+      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
+                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
+                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
+      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, reference_elastic_tensor);
+
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
+            }
+        }
+
+      dealii::SymmetricTensor<4,3> result_up_10_rotate = aspect::Utilities::Tensors::to_full_stiffness_tensor(result_up_1_rotate_down);
+
+      dealii::SymmetricTensor<2,6> result_5_rotate = result_1_rotate;
+
+      for (size_t i = 0; i < 4; i++)
+        {
+          result_up_10_rotate = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor, result_up_10_rotate);
+          result_5_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, result_5_rotate);
+        }
+
+      dealii::SymmetricTensor<2,6> result_up_10_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(result_up_10_rotate);
+
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_5_rotate[i][j] == Approx(result_up_10_rotate_down[i][j]));
+              REQUIRE(result_5_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
+            }
+        }
+    }
+  }
+
+  {
+    // fill the rotation matrix with a rotations in the gamma direction
+    {
+      double radians = (dealii::numbers::PI/180.0)*(360/5); //0.35*dealii::numbers::PI; //(dealii::numbers::PI/180.0)*36;
+      double alpha = 0;
+      double beta = 0;
+      double gamma = radians;
+      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
+      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
+      rotation_tensor[0][2] = -std::sin(beta);
+      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
+      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
+      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
+      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
+      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
+      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
+    }
+
+    {
+      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
+                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
+                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
+      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, reference_elastic_tensor);
+
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
+            }
+        }
+
+      dealii::SymmetricTensor<4,3> result_up_10_rotate = aspect::Utilities::Tensors::to_full_stiffness_tensor(result_up_1_rotate_down);
+
+      dealii::SymmetricTensor<2,6> result_5_rotate = result_1_rotate;
+
+      for (size_t i = 0; i < 4; i++)
+        {
+          result_up_10_rotate = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor, result_up_10_rotate);
+          result_5_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, result_5_rotate);
+        }
+
+      dealii::SymmetricTensor<2,6> result_up_10_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(result_up_10_rotate);
+
+      for (size_t i = 0; i < 6; i++)
+        {
+          for (size_t j = 0; j < 6; j++)
+            {
+              REQUIRE(result_5_rotate[i][j] == Approx(result_up_10_rotate_down[i][j]));
+              REQUIRE(result_5_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
+            }
+        }
+    }
+  }
+
+  /**
+   * test Levi-Cevita tensor function
+   */
+  {
+
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][0][0] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][0][1] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][0][2] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][1][0] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][1][1] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][1][2] == Approx(1.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][2][0] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][2][1] == Approx(-1.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][2][2] == Approx(0.0));
+
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][0][0] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][0][1] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][0][2] == Approx(-1.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][1][0] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][1][1] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][1][2] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][2][0] == Approx(1.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][2][1] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][2][2] == Approx(0.0));
+
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][0][0] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][0][1] == Approx(1.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][0][2] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][1][0] == Approx(-1.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][1][1] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][1][2] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][2][0] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][2][1] == Approx(0.0));
+    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][2][2] == Approx(0.0));
+  }
+}
+
+TEST_CASE("Utilities::string_to_unsigned_int")
+{
+  CHECK(aspect::Utilities::string_to_unsigned_int("1234") == 1234);
+
+  CHECK(aspect::Utilities::string_to_unsigned_int(std::vector<std::string>({"234","0","1"}))
+        == std::vector<unsigned int>({234,0,1}));
+
+  CHECK(aspect::Utilities::string_to_unsigned_int(std::vector<std::string>({"42"}))
+        == std::vector<unsigned int>({42}));
+
+  CHECK(aspect::Utilities::string_to_unsigned_int(std::vector<std::string>({}))
+        == std::vector<unsigned int>());
+}

From aea41a41baedae9ab50ea94682373f3db110a8fd Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Sat, 27 Jul 2024 14:02:16 +0800
Subject: [PATCH 20/22] remove the .prm.bak files

---
 benchmarks/advection/drop_ev.prm.bak          |   13 -
 benchmarks/advection/drop_supg.prm.bak        |  123 -
 .../advection/rotate_shape_dg_bp.prm.bak      |   21 -
 .../advection/rotate_shape_dg_weno.prm.bak    |   26 -
 benchmarks/advection/rotate_shape_ev.prm.bak  |   13 -
 .../advection/rotate_shape_supg.prm.bak       |  119 -
 .../advection_in_annulus.cc.bak               |  162 -
 .../advection_in_annulus.prm.bak              |  120 -
 .../annulus/instantaneous/annulus.prm.bak     |   90 -
 benchmarks/annulus/plugin/annulus.cc.bak      |  837 --
 .../transient/transient_annulus.prm.bak       |   89 -
 benchmarks/blankenbach/base_case1a.prm.bak    |  111 -
 benchmarks/blankenbach/base_case1b.prm.bak    |   18 -
 benchmarks/blankenbach/base_case1c.prm.bak    |   18 -
 benchmarks/blankenbach/base_case2a.prm.bak    |  111 -
 benchmarks/blankenbach/base_case2b.prm.bak    |  118 -
 benchmarks/blankenbach/plugin/code.cc.bak     |  167 -
 .../heat_flux_statistics_gradient.cc.bak      |  198 -
 .../heat_flux_statistics_gradient.h.bak       |   53 -
 .../figure_6_1e20.prm.bak                     |  179 -
 .../figure_6_1e22.prm.bak                     |   12 -
 .../doc/convergence.part.prm.bak              |   44 -
 .../doc/velocity_bc.part.prm.bak              |   37 -
 .../buiter_et_al_2016_jsg/exp_1.prm.bak       |  191 -
 .../exp_2_high_resolution.prm.bak             |  224 -
 .../exp_2_low_resolution.prm.bak              |   32 -
 benchmarks/burstedde/burstedde.cc.bak         |  517 --
 benchmarks/burstedde/burstedde.prm.bak        |  104 -
 benchmarks/burstedde/doc/burstedde.prm.bak    |   32 -
 .../lateral_pipe/adiabatic.prm.bak            |    8 -
 .../lateral_pipe/ala.prm.bak                  |   14 -
 .../lateral_pipe/hydrostatic.prm.bak          |    4 -
 .../lateral_pipe/isentropic.prm.bak           |    4 -
 .../lateral_pipe/lateral_pipe.prm.bak         |  125 -
 .../lateral_pipe/projected_density.prm.bak    |   10 -
 .../lateral_pipe/sub_adiabatic.prm.bak        |    8 -
 .../lateral_pipe_advect/ala.prm.bak           |   12 -
 .../lateral_pipe_advect/hydrostatic.prm.bak   |    4 -
 .../lateral_pipe_advect/isentropic.prm.bak    |    4 -
 .../lateral_pipe_advect/lateral_pipe.prm.bak  |  135 -
 .../projected_density.prm.bak                 |   10 -
 .../ala.prm.bak                               |   12 -
 .../hydrostatic.prm.bak                       |    4 -
 .../isentropic.prm.bak                        |    4 -
 .../lateral_pipe.prm.bak                      |  147 -
 .../projected_density.prm.bak                 |   10 -
 .../projected_density_full_pressure.prm.bak   |   10 -
 .../lateral_pipe_transient/ala.prm.bak        |   12 -
 .../hydrostatic.prm.bak                       |    4 -
 .../lateral_pipe_transient/isentropic.prm.bak |    4 -
 .../lateral_pipe.prm.bak                      |  138 -
 .../projected_density.prm.bak                 |   10 -
 .../lateral_pipe_transient/timestep.prm.bak   |    1 -
 .../compressibility_formulations.cc.bak       |  265 -
 .../vertical_pipe/adiabatic.prm.bak           |    8 -
 .../vertical_pipe/ala.prm.bak                 |    4 -
 .../vertical_pipe/hydrostatic.prm.bak         |    4 -
 .../vertical_pipe/isentropic.prm.bak          |    4 -
 .../vertical_pipe/projected_density.prm.bak   |   10 -
 .../vertical_pipe/sub_adiabatic.prm.bak       |    8 -
 .../vertical_pipe/vertical_pipe.prm.bak       |  133 -
 .../case_1/crameri_benchmark_1.cc.bak         |  179 -
 .../case_1/crameri_benchmark_1.prm.bak        |  139 -
 .../case_1/crameri_benchmark_1_gmg.prm.bak    |   27 -
 .../case_2/crameri_benchmark_2.prm.bak        |  134 -
 .../doc/crameri_benchmark_1.prm.bak           |   18 -
 .../doc/crameri_benchmark_2.prm.bak           |   22 -
 benchmarks/davies_et_al/case-1.1.prm.bak      |  109 -
 benchmarks/davies_et_al/case-2.1.prm.bak      |  120 -
 benchmarks/davies_et_al/case-2.2.prm.bak      |  119 -
 .../davies_et_al/case-2.3-plugin/VoT.cc.bak   |  202 -
 benchmarks/davies_et_al/case-2.3.prm.bak      |  121 -
 benchmarks/davies_et_al/doc/case-1.1.prm.bak  |   51 -
 benchmarks/davies_et_al/doc/case-2.1.prm.bak  |   11 -
 benchmarks/davies_et_al/doc/case-2.2.prm.bak  |    9 -
 benchmarks/davies_et_al/doc/case-2.3.prm.bak  |   14 -
 .../1_sine_zero_flux.prm.bak                  |  125 -
 .../2_sine_constant_h.prm.bak                 |  124 -
 .../analytical_topography.cc.bak              |  369 -
 .../analytical_topography.h.bak               |  113 -
 benchmarks/doneahuerta/doneahuerta.cc.bak     |  362 -
 benchmarks/doneahuerta/doneahuerta.prm.bak    |   88 -
 .../entropy_adiabat/entropy_adiabat.prm.bak   |  184 -
 .../entropy_adiabat/entropy_combined.prm.bak  |   42 -
 .../entropy_conduction.prm.bak                |  147 -
 .../entropy_half_space.prm.bak                |  155 -
 .../plugins/entropy_advection.cc.bak          |  312 -
 .../plugins/entropy_advection.h.bak           |   58 -
 benchmarks/finite_strain/finite_strain.cc.bak |   20 -
 benchmarks/finite_strain/pure_shear.prm.bak   |  145 -
 benchmarks/finite_strain/simple_shear.prm.bak |  133 -
 ...ree_surface_VE_cylinder_2D_loading.prm.bak |  169 -
 ...linder_2D_loading_fixed_elastic_dt.prm.bak |   21 -
 ...e_VE_cylinder_2D_loading_unloading.prm.bak |   27 -
 ...ree_surface_VE_cylinder_3D_loading.prm.bak |  170 -
 ...linder_3D_loading_fixed_elastic_dt.prm.bak |   21 -
 ...urface_viscous_cylinder_2D_loading.prm.bak |   22 -
 ...urface_viscous_cylinder_3D_loading.prm.bak |   22 -
 .../spectral-comparison.prm.bak               |  124 -
 .../grain_size_plunge.prm.bak                 |  162 -
 .../gravity_mantle/mantle_gravity.prm.bak     |   76 -
 .../doc/thick_shell.prm.bak                   |   11 -
 .../gravity_thick_shell/thick_shell.prm.bak   |   72 -
 .../doc/thinshell_a.prm.bak                   |   11 -
 .../doc/thinshell_b.prm.bak                   |    1 -
 .../doc/thinshell_c.prm.bak                   |   15 -
 .../gravity_thin_shell.prm.bak                |   88 -
 benchmarks/hollow_sphere/hollow_sphere.cc.bak |  682 --
 .../hollow_sphere/hollow_sphere.prm.bak       |  103 -
 benchmarks/inclusion/adaptive.prm.base.bak    |   72 -
 .../inclusion_compositional_fields.cc.bak     |   51 -
 .../inclusion_compositional_fields.h.bak      |   34 -
 .../inclusion_compositional_fields.prm.bak    |   91 -
 .../inclusion_particles.prm.bak               |  119 -
 benchmarks/inclusion/doc/inclusion.prm.bak    |   62 -
 benchmarks/inclusion/global.prm.base.bak      |   63 -
 benchmarks/inclusion/inclusion.cc.bak         |   50 -
 benchmarks/inclusion/inclusion.h.bak          |  356 -
 .../infill_density/infill_ascii.prm.bak       |  217 -
 .../infill_density/infill_ascii_data.cc.bak   |  267 -
 benchmarks/king2dcompressible/ala.prm.bak     |  184 -
 .../king2dcompressible/plugin/code.cc.bak     |  250 -
 benchmarks/layeredflow/layeredflow.cc.bak     |  404 -
 benchmarks/layeredflow/layeredflow.prm.bak    |   94 -
 .../nonlinear_channel_flow/input_t.prm.bak    |  134 -
 .../input_t_gmg.prm.bak                       |   21 -
 .../nonlinear_channel_flow/input_v.prm.bak    |  133 -
 .../input_v_gmg.prm.bak                       |   21 -
 .../simple_nonlinear.cc.bak                   |  404 -
 .../drucker_prager_compositions.cc.bak        |  671 --
 .../spiegelman_et_al_2016/input.prm.bak       |  137 -
 .../tosi_et_al_2015/input.prm.bak             |  168 -
 .../tosi_et_al_2015/input_gmg.prm.bak         |   23 -
 benchmarks/nsinker/nsinker.cc.bak             |  352 -
 benchmarks/nsinker/nsinker.prm.bak            |   84 -
 benchmarks/nsinker/nsinker_2d.prm.bak         |   72 -
 benchmarks/nsinker/nsinker_bfbt.prm.bak       |   85 -
 benchmarks/nsinker/nsinker_gmg.prm.bak        |   92 -
 .../nsinker_spherical_shell/amg.prm.bak       |   20 -
 .../nsinker_spherical_shell/gmg.prm.bak       |   86 -
 .../nsinker_spherical_shell/nsinker.cc.bak    |  349 -
 .../convection-box-base.prm.bak               |   94 -
 .../advection_reaction.base.prm.bak           |  149 -
 .../advection_reaction.cc.bak                 |  502 --
 .../doc/exponential_decay.part.1.prm.bak      |   15 -
 .../doc/exponential_decay.part.2.prm.bak      |   38 -
 .../exponential_decay.base.prm.bak            |  121 -
 .../exponential_decay.cc.bak                  |  402 -
 .../circle.prm.bak                            |   78 -
 .../euler.part.prm.bak                        |    6 -
 .../rk2.part.prm.bak                          |    6 -
 .../rk4.part.prm.bak                          |    6 -
 benchmarks/polydiapirs/polydiapirs.prm.bak    |   96 -
 .../rayleigh_taylor_instability/blank.prm.bak |   52 -
 .../rayleigh_taylor_instability.cc.bak        |  199 -
 .../rayleigh_taylor_instability.prm.bak       |   75 -
 .../kaus_rayleigh_taylor_instability.prm.bak  |  158 -
 .../rose_rayleigh_taylor_instability.prm.bak  |   49 -
 .../instantaneous/rigid_shear.prm.bak         |   87 -
 .../rigid_shear/plugin/rigid_shear.cc.bak     |  378 -
 .../steady-state/rigid_shear.prm.bak          |  110 -
 .../rigid_shear/transient/rigid_shear.prm.bak |  134 -
 .../shear_bands/magmatic_shear_bands.prm.bak  |  146 -
 benchmarks/shear_bands/shear_bands.cc.bak     |  846 --
 benchmarks/shear_bands/shear_bands.prm.bak    |  130 -
 benchmarks/sinking_block/blank.prm.bak        |   58 -
 benchmarks/sinking_block/sinking_block.cc.bak |  232 -
 .../sinking_block/sinking_block.prm.bak       |   71 -
 .../slab_detachment/slab_detachment.prm.bak   |  152 -
 .../solcx_compositional_fields.cc.bak         |   46 -
 .../solcx_compositional_fields.h.bak          |   34 -
 .../solcx_compositional_fields.prm.bak        |   95 -
 .../solcx_particles.prm.bak                   |  128 -
 benchmarks/solcx/doc/solcx.prm.bak            |   60 -
 benchmarks/solcx/solcx.cc.bak                 |   44 -
 benchmarks/solcx/solcx.h.bak                  | 3189 -------
 benchmarks/solcx/solcx.prm.bak                |   66 -
 .../solitary_wave/doc/solitary_wave.prm.bak   |  103 -
 benchmarks/solitary_wave/solitary_wave.cc.bak | 1025 ---
 .../solitary_wave/solitary_wave.prm.bak       |  170 -
 .../solkz_compositional_fields.cc.bak         |   45 -
 .../solkz_compositional_fields.h.bak          |   33 -
 .../solkz_compositional_fields.prm.bak        |   93 -
 .../solkz_particles.prm.bak                   |  117 -
 benchmarks/solkz/doc/solkz.prm.bak            |   60 -
 benchmarks/solkz/solkz.cc.bak                 |   44 -
 benchmarks/solkz/solkz.h.bak                  |  799 --
 benchmarks/solkz/solkz.prm.bak                |   62 -
 .../solubility/plugin/solubility.cc.bak       |  424 -
 benchmarks/solubility/solubility.prm.bak      |  162 -
 benchmarks/tangurnis/ba/tan.prm.bak           |  130 -
 benchmarks/tangurnis/code/tangurnis.cc.bak    |  461 -
 benchmarks/tangurnis/tala/tan.prm.bak         |  140 -
 benchmarks/tangurnis/tala_c/tan.prm.bak       |  139 -
 .../plugin/time_dependent_annulus.cc.bak      |   55 -
 .../plugin/time_dependent_annulus.h.bak       |  377 -
 .../time_dependent_annulus.prm.bak            |  179 -
 .../tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak |   21 -
 .../tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak |   20 -
 .../tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak |   21 -
 .../tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak |   22 -
 .../tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak |   21 -
 .../tosi_et_al_2015_gcubed/Tosi_base.prm.bak  |  175 -
 .../doc/tosi_benchmark_2.prm.bak              |    8 -
 benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak |  722 --
 .../20km_opentopbot.prm.bak                   |   96 -
 .../20km_opentopbot_weno.prm.bak              |   33 -
 .../viscoelastic_bending_beam.prm.bak         |  185 -
 ...iscoelastic_bending_beam_particles.prm.bak |   41 -
 .../viscoelastic_bending_beam_weno.prm.bak    |   32 -
 .../gerya_2019/gerya_2019_vep.prm.bak         |   61 -
 .../gerya_2019/gerya_2019_vp.prm.bak          |  190 -
 .../gerya_2019/gerya_2019_vp_damper.prm.bak   |   20 -
 .../kaus_2010/kaus_2010_extension.prm.bak     |  238 -
 .../viscoelastic_plastic_simple_shear.prm.bak |  146 -
 .../viscoelastic_plate_flexure.prm.bak        |  177 -
 .../viscoelastic_sheared_torsion.prm.bak      |  172 -
 .../viscoelastic_stress_build-up.prm.bak      |  191 -
 ...oelastic_stress_build-up_particles.prm.bak |   43 -
 ...viscoelastic_stress_build-up_yield.prm.bak |   43 -
 ...ic_stress_build-up_yield_particles.prm.bak |   74 -
 .../viscosity_grooves.cc.bak                  |  473 -
 .../viscosity_grooves.prm.bak                 |   82 -
 .../anelasticity_temperature.cc.bak           |  402 -
 .../anelasticity_temperature.h.bak            |  135 -
 .../yamauchi_takei_2016_anelasticity.prm.bak  |   79 -
 benchmarks/zhong_et_al_93/zhong_case1.prm.bak |  105 -
 contrib/opendap/prm_files/aspect_test.prm.bak |   82 -
 .../opendap/prm_files/aspect_url_test.prm.bak |   78 -
 .../perplex_lookup_composition.prm.bak        |   84 -
 .../read_output_files/convection-box.prm.bak  |   10 -
 contrib/world_builder/include/app/main.h.bak  |   27 -
 contrib/world_builder/include/glm/glm.h.bak   |  248 -
 .../include/rapidjson/allocators.h.bak        |  308 -
 .../rapidjson/cursorstreamwrapper.h.bak       |   89 -
 .../include/rapidjson/encodedstream.h.bak     |  485 -
 .../include/rapidjson/encodings.h.bak         |  855 --
 .../include/rapidjson/error/en.h.bak          |   95 -
 .../include/rapidjson/error/error.h.bak       |  200 -
 .../include/rapidjson/filereadstream.h.bak    |  130 -
 .../include/rapidjson/filewritestream.h.bak   |  134 -
 .../world_builder/include/rapidjson/fwd.h.bak |  151 -
 .../rapidjson/internal/biginteger.h.bak       |  340 -
 .../include/rapidjson/internal/diyfp.h.bak    |  293 -
 .../include/rapidjson/internal/dtoa.h.bak     |  301 -
 .../include/rapidjson/internal/ieee754.h.bak  |  122 -
 .../include/rapidjson/internal/itoa.h.bak     |  329 -
 .../include/rapidjson/internal/meta.h.bak     |  229 -
 .../include/rapidjson/internal/pow10.h.bak    |   58 -
 .../include/rapidjson/internal/regex.h.bak    |  820 --
 .../include/rapidjson/internal/stack.h.bak    |  277 -
 .../include/rapidjson/internal/strfunc.h.bak  |   75 -
 .../include/rapidjson/internal/strtod.h.bak   |  317 -
 .../include/rapidjson/internal/swap.h.bak     |   48 -
 .../include/rapidjson/istreamwrapper.h.bak    |  137 -
 .../include/rapidjson/latexwriter.h.bak       |  468 -
 .../include/rapidjson/memorybuffer.h.bak      |   91 -
 .../include/rapidjson/memorystream.h.bak      |   96 -
 .../rapidjson/msinttypes/inttypes.h.bak       |  320 -
 .../include/rapidjson/msinttypes/stdint.h.bak |  300 -
 .../include/rapidjson/mystwriter.h.bak        |  528 --
 .../include/rapidjson/ostreamwrapper.h.bak    |  104 -
 .../include/rapidjson/pointer.h.bak           | 1532 ----
 .../include/rapidjson/prettywriter.h.bak      |  340 -
 .../include/rapidjson/rapidjson.h.bak         |  660 --
 .../include/rapidjson/reader.h.bak            | 2574 ------
 .../include/rapidjson/schema.h.bak            | 2927 -------
 .../include/rapidjson/stream.h.bak            |  312 -
 .../include/rapidjson/stringbuffer.h.bak      |  155 -
 .../include/rapidjson/writer.h.bak            |  867 --
 .../include/visualization/main.h.bak          |   39 -
 .../include/world_builder/assert.h.bak        |   63 -
 .../include/world_builder/bounding_box.h.bak  |  513 --
 .../include/world_builder/consts.h.bak        |   35 -
 .../world_builder/coordinate_system.h.bak     |   68 -
 .../coordinate_systems/cartesian.h.bak        |  114 -
 .../coordinate_systems/interface.h.bak        |  184 -
 .../coordinate_systems/invalid.h.bak          |  110 -
 .../coordinate_systems/spherical.h.bak        |  130 -
 .../include/world_builder/deprecate.h.bak     |   13 -
 .../features/continental_plate.h.bak          |  162 -
 .../composition/interface.h.bak               |  164 -
 .../composition/random.h.bak                  |  100 -
 .../composition/uniform.h.bak                 |   99 -
 .../grains/interface.h.bak                    |  170 -
 .../grains/random_uniform_distribution.h.bak  |  115 -
 ...andom_uniform_distribution_deflected.h.bak |  115 -
 .../grains/uniform.h.bak                      |  113 -
 .../temperature/adiabatic.h.bak               |  113 -
 .../temperature/interface.h.bak               |  169 -
 .../temperature/linear.h.bak                  |   99 -
 .../temperature/uniform.h.bak                 |   98 -
 .../world_builder/features/fault.h.bak        |  229 -
 .../fault_models/composition/interface.h.bak  |  172 -
 .../fault_models/composition/smooth.h.bak     |   97 -
 .../fault_models/composition/uniform.h.bak    |   95 -
 .../fault_models/grains/interface.h.bak       |  173 -
 .../grains/random_uniform_distribution.h.bak  |  113 -
 ...andom_uniform_distribution_deflected.h.bak |  113 -
 .../fault_models/grains/uniform.h.bak         |  112 -
 .../fault_models/temperature/adiabatic.h.bak  |  110 -
 .../fault_models/temperature/interface.h.bak  |  173 -
 .../fault_models/temperature/linear.h.bak     |   95 -
 .../fault_models/temperature/uniform.h.bak    |   95 -
 .../features/feature_utilities.h.bak          |  101 -
 .../world_builder/features/interface.h.bak    |  228 -
 .../world_builder/features/mantle_layer.h.bak |  161 -
 .../composition/interface.h.bak               |  168 -
 .../composition/uniform.h.bak                 |   98 -
 .../grains/interface.h.bak                    |  170 -
 .../grains/random_uniform_distribution.h.bak  |  114 -
 ...andom_uniform_distribution_deflected.h.bak |  114 -
 .../mantle_layer_models/grains/uniform.h.bak  |  114 -
 .../temperature/adiabatic.h.bak               |  113 -
 .../temperature/interface.h.bak               |  169 -
 .../temperature/linear.h.bak                  |   98 -
 .../temperature/uniform.h.bak                 |   97 -
 .../features/oceanic_plate.h.bak              |  158 -
 .../composition/interface.h.bak               |  168 -
 .../composition/uniform.h.bak                 |   98 -
 .../grains/interface.h.bak                    |  166 -
 .../grains/random_uniform_distribution.h.bak  |  114 -
 ...andom_uniform_distribution_deflected.h.bak |  114 -
 .../oceanic_plate_models/grains/uniform.h.bak |  114 -
 .../temperature/adiabatic.h.bak               |  112 -
 .../temperature/half_space_model.h.bak        |  103 -
 .../temperature/interface.h.bak               |  169 -
 .../temperature/linear.h.bak                  |   98 -
 .../temperature/plate_model.h.bak             |  107 -
 .../plate_model_constant_age.h.bak            |  105 -
 .../temperature/uniform.h.bak                 |   97 -
 .../world_builder/features/plume.h.bak        |  164 -
 .../plume_models/composition/interface.h.bak  |  164 -
 .../plume_models/composition/uniform.h.bak    |   97 -
 .../plume_models/grains/interface.h.bak       |  170 -
 .../plume_models/grains/uniform.h.bak         |  111 -
 .../plume_models/temperature/gaussian.h.bak   |   96 -
 .../plume_models/temperature/interface.h.bak  |  173 -
 .../plume_models/temperature/uniform.h.bak    |   98 -
 .../features/subducting_plate.h.bak           |  230 -
 .../composition/interface.h.bak               |  173 -
 .../composition/smooth.h.bak                  |   98 -
 .../composition/uniform.h.bak                 |   95 -
 .../grains/interface.h.bak                    |  173 -
 .../grains/random_uniform_distribution.h.bak  |  112 -
 ...andom_uniform_distribution_deflected.h.bak |  113 -
 .../grains/uniform.h.bak                      |  112 -
 .../temperature/adiabatic.h.bak               |  110 -
 .../temperature/interface.h.bak               |  174 -
 .../temperature/linear.h.bak                  |   96 -
 .../temperature/mass_conserving.h.bak         |  143 -
 .../temperature/plate_model.h.bak             |  102 -
 .../temperature/uniform.h.bak                 |   95 -
 .../include/world_builder/grains.h.bak        |   68 -
 .../gravity_model/interface.h.bak             |  149 -
 .../world_builder/gravity_model/uniform.h.bak |   96 -
 .../include/world_builder/kd_tree.h.bak       |  161 -
 .../include/world_builder/nan.h.bak           |   50 -
 .../world_builder/objects/bezier_curve.h.bak  |   89 -
 .../objects/closest_point_on_curve.h.bak      |   56 -
 .../objects/distance_from_surface.h.bak       |   64 -
 .../objects/natural_coordinate.h.bak          |  125 -
 .../world_builder/objects/segment.h.bak       |   79 -
 .../world_builder/objects/surface.h.bak       |  112 -
 .../include/world_builder/parameters.h.bak    |  332 -
 .../include/world_builder/point.h.bak         |  473 -
 .../include/world_builder/types/array.h.bak   |  119 -
 .../include/world_builder/types/bool.h.bak    |   77 -
 .../include/world_builder/types/double.h.bak  |   76 -
 .../include/world_builder/types/int.h.bak     |   80 -
 .../world_builder/types/interface.h.bak       |   93 -
 .../include/world_builder/types/object.h.bak  |   87 -
 .../include/world_builder/types/one_of.h.bak  |   89 -
 .../world_builder/types/plugin_system.h.bak   |   85 -
 .../include/world_builder/types/point.h.bak   |  132 -
 .../include/world_builder/types/segment.h.bak |  100 -
 .../include/world_builder/types/string.h.bak  |  103 -
 .../world_builder/types/unsigned_int.h.bak    |   80 -
 .../world_builder/types/value_at_points.h.bak |   80 -
 .../include/world_builder/utilities.h.bak     |  494 --
 .../include/world_builder/world.h.bak         |  316 -
 .../include/world_builder/wrapper_c.h.bak     |   71 -
 .../include/world_builder/wrapper_cpp.h.bak   |   94 -
 .../world_builder/source/gwb-dat/main.cc.bak  |  343 -
 .../world_builder/source/gwb-grid/main.cc.bak | 1672 ----
 .../coordinate_systems/cartesian.cc.bak       |  103 -
 .../coordinate_systems/interface.cc.bak       |  100 -
 .../coordinate_systems/invalid.cc.bak         |   88 -
 .../coordinate_systems/spherical.cc.bak       |  146 -
 .../features/continental_plate.cc.bak         |  270 -
 .../composition/interface.cc.bak              |   80 -
 .../composition/random.cc.bak                 |  144 -
 .../composition/uniform.cc.bak                |  136 -
 .../grains/interface.cc.bak                   |   81 -
 .../grains/random_uniform_distribution.cc.bak |  225 -
 ...ndom_uniform_distribution_deflected.cc.bak |  231 -
 .../grains/uniform.cc.bak                     |  177 -
 .../temperature/adiabatic.cc.bak              |  171 -
 .../temperature/interface.cc.bak              |   94 -
 .../temperature/linear.cc.bak                 |  157 -
 .../temperature/uniform.cc.bak                |  114 -
 .../world_builder/features/fault.cc.bak       |  730 --
 .../fault_models/composition/interface.cc.bak |   81 -
 .../fault_models/composition/smooth.cc.bak    |  129 -
 .../fault_models/composition/uniform.cc.bak   |  124 -
 .../fault_models/grains/interface.cc.bak      |  111 -
 .../grains/random_uniform_distribution.cc.bak |  217 -
 ...ndom_uniform_distribution_deflected.cc.bak |  223 -
 .../fault_models/grains/uniform.cc.bak        |  169 -
 .../fault_models/temperature/adiabatic.cc.bak |  164 -
 .../fault_models/temperature/interface.cc.bak |   95 -
 .../fault_models/temperature/linear.cc.bak    |  140 -
 .../fault_models/temperature/uniform.cc.bak   |  107 -
 .../features/feature_utilities.cc.bak         |   56 -
 .../world_builder/features/interface.cc.bak   |  209 -
 .../features/mantle_layer.cc.bak              |  264 -
 .../composition/interface.cc.bak              |   81 -
 .../composition/uniform.cc.bak                |  131 -
 .../grains/interface.cc.bak                   |  111 -
 .../grains/random_uniform_distribution.cc.bak |  224 -
 ...ndom_uniform_distribution_deflected.cc.bak |  231 -
 .../mantle_layer_models/grains/uniform.cc.bak |  176 -
 .../temperature/adiabatic.cc.bak              |  172 -
 .../temperature/interface.cc.bak              |   94 -
 .../temperature/linear.cc.bak                 |  147 -
 .../temperature/uniform.cc.bak                |  117 -
 .../features/oceanic_plate.cc.bak             |  285 -
 .../composition/interface.cc.bak              |   81 -
 .../composition/uniform.cc.bak                |  129 -
 .../grains/interface.cc.bak                   |  111 -
 .../grains/random_uniform_distribution.cc.bak |  224 -
 ...ndom_uniform_distribution_deflected.cc.bak |  230 -
 .../grains/uniform.cc.bak                     |  177 -
 .../temperature/adiabatic.cc.bak              |  173 -
 .../temperature/half_space_model.cc.bak       |  210 -
 .../temperature/interface.cc.bak              |   94 -
 .../temperature/linear.cc.bak                 |  145 -
 .../temperature/plate_model.cc.bak            |  214 -
 .../plate_model_constant_age.cc.bak           |  161 -
 .../temperature/uniform.cc.bak                |  116 -
 .../world_builder/features/plume.cc.bak       |  403 -
 .../plume_models/composition/interface.cc.bak |   80 -
 .../plume_models/composition/uniform.cc.bak   |  129 -
 .../plume_models/grains/interface.cc.bak      |   81 -
 .../plume_models/grains/uniform.cc.bak        |  169 -
 .../plume_models/temperature/gaussian.cc.bak  |  166 -
 .../plume_models/temperature/interface.cc.bak |   94 -
 .../plume_models/temperature/uniform.cc.bak   |  106 -
 .../features/subducting_plate.cc.bak          |  762 --
 .../composition/interface.cc.bak              |   82 -
 .../composition/smooth.cc.bak                 |  131 -
 .../composition/uniform.cc.bak                |  123 -
 .../grains/interface.cc.bak                   |  111 -
 .../grains/random_uniform_distribution.cc.bak |  217 -
 ...ndom_uniform_distribution_deflected.cc.bak |  223 -
 .../grains/uniform.cc.bak                     |  169 -
 .../temperature/adiabatic.cc.bak              |  166 -
 .../temperature/interface.cc.bak              |   94 -
 .../temperature/linear.cc.bak                 |  138 -
 .../temperature/mass_conserving.cc.bak        |  639 --
 .../temperature/plate_model.cc.bak            |  214 -
 .../temperature/uniform.cc.bak                |  109 -
 .../source/world_builder/grains.cc.bak        |   80 -
 .../gravity_model/interface.cc.bak            |   99 -
 .../gravity_model/uniform.cc.bak              |   94 -
 .../source/world_builder/kd_tree.cc.bak       |  211 -
 .../world_builder/objects/bezier_curve.cc.bak |  550 --
 .../objects/distance_from_surface.cc.bak      |   36 -
 .../objects/natural_coordinate.cc.bak         |  121 -
 .../world_builder/objects/segment.cc.bak      |  126 -
 .../world_builder/objects/surface.cc.bak      |  227 -
 .../source/world_builder/parameters.cc.bak    | 2229 -----
 .../source/world_builder/point.cc.bak         |  108 -
 .../source/world_builder/types/array.cc.bak   |   84 -
 .../source/world_builder/types/bool.cc.bak    |   62 -
 .../source/world_builder/types/double.cc.bak  |   68 -
 .../source/world_builder/types/int.cc.bak     |   64 -
 .../world_builder/types/interface.cc.bak      |   45 -
 .../source/world_builder/types/object.cc.bak  |   91 -
 .../source/world_builder/types/one_of.cc.bak  |   77 -
 .../world_builder/types/plugin_system.cc.bak  |   95 -
 .../source/world_builder/types/point.cc.bak   |  185 -
 .../source/world_builder/types/segment.cc.bak |  170 -
 .../source/world_builder/types/string.cc.bak  |  120 -
 .../world_builder/types/unsigned_int.cc.bak   |   64 -
 .../types/value_at_points.cc.bak              |   96 -
 .../source/world_builder/utilities.cc.bak     | 1510 ----
 .../source/world_builder/world.cc.bak         |  498 --
 .../source/world_builder/wrapper_c.cc.bak     |  108 -
 .../source/world_builder/wrapper_cpp.cc.bak   |   77 -
 .../tests/unit_tests/bounding_box.cc.bak      |   87 -
 .../tests/unit_tests/gwb_gravity.cc.bak       |   68 -
 .../tests/unit_tests/kd_tree.cc.bak           |  214 -
 .../tests/unit_tests/main.cc.bak              |   25 -
 .../tests/unit_tests/unit_test_wb_glm.cc.bak  |  253 -
 .../unit_tests/unit_test_world_builder.cc.bak | 7780 -----------------
 .../2d_annulus_example.prm.bak                |   89 -
 .../allken.prm.bak                            |  155 -
 .../AV_Rayleigh_Taylor.prm.bak                |  100 -
 .../anisotropic_viscosity/av_material.cc.bak  |  831 --
 .../bunge_et_al.prm.bak                       |  104 -
 cookbooks/burnman/burnman.prm.bak             |  143 -
 .../doc/adiabatic_conditions.part.prm.bak     |    8 -
 .../burnman/doc/formulation.part.prm.bak      |    3 -
 .../burnman/doc/formulation_ica.part.prm.bak  |    3 -
 .../burnman/doc/gravity_model.part.prm.bak    |    3 -
 .../burnman/doc/material_model.part.prm.bak   |   14 -
 cookbooks/burnman/doc/tala.part.prm.bak       |    5 -
 .../christensen_yuen_phase_function.prm.bak   |  172 -
 .../doc/material.part.prm.bak                 |   35 -
 .../composition-reaction.prm.bak              |  113 -
 .../doc/initial.part.prm.bak                  |    8 -
 .../doc/material.part.prm.bak                 |   12 -
 .../composition_active.prm.bak                |  106 -
 .../doc/active.part.prm.bak                   |   12 -
 .../doc/postprocess.part.prm.bak              |    8 -
 .../composition_active_particles.prm.bak      |  127 -
 .../doc/composition.part.prm.bak              |    6 -
 .../doc/particles.part.prm.bak                |   18 -
 .../composition_passive.prm.bak               |   99 -
 .../doc/passive.part.prm.bak                  |   18 -
 .../doc/postprocess.part.prm.bak              |    3 -
 .../composition_passive_particles.prm.bak     |  114 -
 ...ition_passive_particles_properties.prm.bak |  121 -
 .../doc/particle-properties.part.prm.bak      |   17 -
 .../doc/particles.part.prm.bak                |   20 -
 .../continental_extension.prm.bak             |  314 -
 ...ntal_extension_boundary_conditions.prm.bak |   36 -
 .../continental_extension_composition.prm.bak |   16 -
 ...ontinental_extension_geometry_mesh.prm.bak |   23 -
 ...ntinental_extension_material_model.prm.bak |    6 -
 .../convection-box-particles.prm.bak          |  170 -
 .../convection-box/convection-box.prm.bak     |  160 -
 .../convection-box/doc/disc.part.prm.bak      |    4 -
 .../convection-box/doc/gravity.part.prm.bak   |    5 -
 .../convection-box/doc/refine.part.prm.bak    |    5 -
 .../convection-box/doc/refine2.part.prm.bak   |    8 -
 .../model_input/convection-box.prm.bak        |  160 -
 .../model_input/convection-box2.prm.bak       |  161 -
 .../model_input/tutorial.prm.bak              |  157 -
 .../convection_box_3d.prm.bak                 |  152 -
 .../convection_box_3d/doc/amr.part.prm.bak    |    6 -
 .../doc/checkpoint.part.prm.bak               |    3 -
 .../doc/gravity.part.prm.bak                  |    7 -
 .../doc/initial.part.prm.bak                  |    9 -
 .../doc/postprocess.part.prm.bak              |    8 -
 .../convection_box_3d/doc/start.part.prm.bak  |   25 -
 .../crustal_model_2D.prm.bak                  |  134 -
 .../crustal_model_3D.prm.bak                  |  128 -
 .../doc/crustal_model_2D_part1.prm.bak        |   15 -
 .../doc/crustal_model_2D_part2.prm.bak        |    7 -
 .../doc/crustal_model_2D_part3.prm.bak        |    3 -
 .../doc/crustal_model_2D_part4.prm.bak        |    9 -
 .../doc/crustal_model_3D_part1.prm.bak        |    7 -
 .../fastscape_eroding_box.prm.bak             |  177 -
 .../doc/finite_strain.part.prm.bak            |   14 -
 cookbooks/finite_strain/finite_strain.cc.bak  |  128 -
 cookbooks/finite_strain/finite_strain.prm.bak |  119 -
 .../doc/free_surface.part.prm.bak             |   41 -
 cookbooks/free_surface/free_surface.prm.bak   |  141 -
 .../doc/free_surface_with_crust.part1.prm.bak |    4 -
 .../doc/free_surface_with_crust.part2.prm.bak |   19 -
 .../free_surface_with_crust.prm.bak           |  112 -
 .../plugin/simpler_with_crust.cc.bak          |  220 -
 cookbooks/future/mantle_setup_restart.prm.bak |   30 -
 cookbooks/future/mantle_setup_start.prm.bak   |  192 -
 cookbooks/future/net_rotation.prm.bak         |   78 -
 cookbooks/future/periodic_box.prm.bak         |  106 -
 cookbooks/future/radiogenic_heating.prm.bak   |  104 -
 .../radiogenic_heating_function.prm.bak       |  108 -
 cookbooks/future/sphere.prm.bak               |   74 -
 cookbooks/geomio/doc/geomIO.prm.bak           |   40 -
 cookbooks/geomio/geomIO.prm.bak               |   96 -
 cookbooks/global_melt/doc/global_melt.prm.bak |  248 -
 .../global_melt/doc/global_no_melt.prm.bak    |  211 -
 cookbooks/global_melt/global_melt.prm.bak     |  371 -
 cookbooks/global_melt/global_no_melt.prm.bak  |  211 -
 cookbooks/gplates/doc/gplates.part.prm.bak    |   17 -
 cookbooks/gplates/doc/slice1.part.prm.bak     |    2 -
 cookbooks/gplates/doc/slice2.part.prm.bak     |    2 -
 cookbooks/gplates/gplates_2d.prm.bak          |   88 -
 cookbooks/gplates/gplates_3d.prm.bak          |   88 -
 .../grain_size_ridge/doc/fields.part.prm.bak  |   11 -
 .../doc/material_model.part.prm.bak           |   48 -
 .../doc/particles.part.prm.bak                |   30 -
 .../grain_size_ridge/grain_size_ridge.prm.bak |  310 -
 cookbooks/heat_flow/heat-flow-plume.prm.bak   |  154 -
 cookbooks/heat_flow/heat-flow-terms.prm.bak   |   40 -
 cookbooks/heat_flow/heat-flow.prm.bak         |  143 -
 .../inclusions/ellipse_pure_shear.prm.bak     |   13 -
 .../ellipse_pure_shear_nonlinear.prm.bak      |  129 -
 cookbooks/inclusions/ellipse_ref.prm.bak      |   94 -
 .../inclusions/ellipse_simple_shear.prm.bak   |   13 -
 .../inclusions/rectangle_pure_shear.prm.bak   |   13 -
 cookbooks/inclusions/rectangle_ref.prm.bak    |   94 -
 .../inclusions/rectangle_simple_shear.prm.bak |   13 -
 .../initial-condition-S20RTS/S20RTS.prm.bak   |  152 -
 .../doc/S20RTS.part.prm.bak                   |   13 -
 .../doc/inner_core_traction.part.1.prm.bak    |   15 -
 .../doc/inner_core_traction.part.2.prm.bak    |   13 -
 .../doc/inner_core_traction.part.3.prm.bak    |   11 -
 .../inner_core_assembly.cc.bak                |  140 -
 .../inner_core_convection.cc.bak              |  488 --
 .../inner_core_traction.prm.bak               |  136 -
 .../composition_trms_statistics.cc.bak        |  227 -
 .../composition_trms_statistics.h.bak         |   75 -
 .../doc/Case1_compositions.prm.bak            |   39 -
 .../doc/Case1_materialmodel.prm.bak           |   15 -
 .../doc/Case1_meshrefinement.prm.bak          |   23 -
 .../doc/Case1_postprocessing.prm.bak          |   16 -
 .../doc/Case1_velocity.prm.bak                |   13 -
 .../doc/Case2a_materialmodel.prm.bak          |   13 -
 .../doc/Case2a_postprocessing.prm.bak         |   20 -
 .../doc/Case2a_temperatures.prm.bak           |   21 -
 .../doc/Case2b_materialmodel.prm.bak          |   25 -
 .../isotherm_depth.cc.bak                     |  152 -
 .../isotherm_depth.h.bak                      |   74 -
 ...tically_driven_subduction_2d_case1.prm.bak |  202 -
 ...ically_driven_subduction_2d_case2a.prm.bak |  107 -
 ...ically_driven_subduction_2d_case2b.prm.bak |   38 -
 .../subduction_plate_cooling.cc.bak           |  100 -
 .../subduction_plate_cooling.h.bak            |   52 -
 .../trench_location.cc.bak                    |  157 -
 .../trench_location.h.bak                     |   75 -
 .../latent-heat/doc/material.part.prm.bak     |   41 -
 cookbooks/latent-heat/latent-heat.prm.bak     |  145 -
 .../lower_crustal_flow_obstacle.prm.bak       |  116 -
 .../magnetic_stripes/magnetic_stripes.cc.bak  |  153 -
 .../magnetic_stripes/magnetic_stripes.prm.bak |  241 -
 .../modelR.prm.bak                            |  210 -
 .../doc/boundary_conditions.part.prm.bak      |   34 -
 .../doc/compaction_length.part.prm.bak        |   23 -
 .../doc/melting_and_freezing.part.prm.bak     |   38 -
 .../doc/mesh_refinement.part.prm.bak          |   28 -
 .../mid_ocean_ridge/mid_ocean_ridge.prm.bak   |  254 -
 .../doc/morency_doin.part.prm.bak             |   59 -
 .../morency_doin_2004/morency_doin.cc.bak     |  302 -
 .../morency_doin_2004/morency_doin.h.bak      |  125 -
 .../morency_doin_2004/morency_doin.prm.bak    |  113 -
 .../doc/comp.field.prm.bak                    |    5 -
 .../doc/comp.setup.prm.bak                    |   12 -
 .../doc/conductivity.setup.prm.bak            |    7 -
 .../doc/lookup.part.prm.bak                   |   10 -
 .../doc/temperature.setup.prm.bak             |   26 -
 .../steinberger_thermochemical_plume.prm.bak  |  166 -
 .../doc/check-initial-condition.part.prm.bak  |   18 -
 .../doc/mesh-refinement.part.prm.bak          |   23 -
 .../doc/repetitions.part.prm.bak              |   15 -
 .../doc/temperature.part.prm.bak              |   39 -
 .../muparser-temperature-example.prm.bak      |  159 -
 .../onset_of_convection.prm.bak               |   93 -
 .../doc/boundary.part.prm.bak                 |   10 -
 .../platelike-boundary/doc/platelike.prm.bak  |   91 -
 .../platelike-boundary.prm.bak                |   96 -
 .../opening_angle_45degrees.prm.bak           |   11 -
 .../opening_angle_90degrees.prm.bak           |   11 -
 cookbooks/plume_2D_chunk/plume2D.prm.bak      |  104 -
 .../strongly_temperature_dependent.prm.bak    |   11 -
 .../weakly_temperature_dependent.prm.bak      |   11 -
 cookbooks/prescribed_velocity/circle.prm.bak  |   62 -
 .../prescribed_velocity/corner_flow.prm.bak   |   62 -
 .../prescribed_velocity/doc/minimal.prm.bak   |   24 -
 .../prescribed_velocity.cc.bak                |  301 -
 ...escribed_velocity_ascii_data.prm.0.out.bak |    2 -
 ...escribed_velocity_ascii_data.prm.1.out.bak |   18 -
 ...escribed_velocity_ascii_data.prm.2.out.bak |    8 -
 .../prescribed_velocity_ascii_data.cc.bak     |  311 -
 .../prescribed_velocity_ascii_data.prm.bak    |  152 -
 .../doc/shell_3d_postprocess.part.prm.bak     |    9 -
 .../shell_3d_postprocess.prm.bak              |  108 -
 .../doc/shearheat.part.prm.bak                |    3 -
 cookbooks/shell_simple_2d/doc/shell.prm.bak   |   72 -
 .../shell_simple_2d/shell_simple_2d.prm.bak   |   82 -
 .../shell_simple_2d_smoothing.part.prm.bak    |   20 -
 .../shell_simple_2d_smoothing.prm.bak         |   95 -
 .../shell_simple_3d/doc/amr.part.prm.bak      |    6 -
 .../doc/checkpoint.part.prm.bak               |    3 -
 .../shell_simple_3d/doc/part1.part.prm.bak    |   13 -
 .../shell_simple_3d/doc/part2.part.prm.bak    |   13 -
 .../shell_simple_3d/doc/part3.part.prm.bak    |    9 -
 .../shell_simple_3d/doc/part4.part.prm.bak    |   11 -
 .../doc/postprocess.part.prm.bak              |   16 -
 .../shell_simple_3d/shell_simple_3d.prm.bak   |   79 -
 .../doc/conservative.prm.bak                  |    3 -
 .../sinker-with-averaging/doc/full.prm.bak    |   86 -
 .../doc/harmonic.prm.bak                      |    3 -
 .../sinker-with-averaging.prm.bak             |   86 -
 .../steinberger/doc/geometry.part.prm.bak     |   10 -
 cookbooks/steinberger/doc/lookup.part.prm.bak |   11 -
 .../steinberger/doc/nullspace.part.prm.bak    |    3 -
 .../doc/projected_density.part.prm.bak        |   11 -
 .../steinberger/doc/rheology.part.prm.bak     |   11 -
 .../steinberger/doc/rheology2.part.prm.bak    |    5 -
 cookbooks/steinberger/steinberger.prm.bak     |  215 -
 cookbooks/stokes/doc/stokeslaw.prm.bak        |  118 -
 cookbooks/stokes/stokes.prm.bak               |  121 -
 .../subduction_initiation.prm.base.bak        |   51 -
 ...on_initiation_compositional_fields.prm.bak |   50 -
 ...uction_initiation_particle_in_cell.prm.bak |   66 -
 ...an-parameterization-kinematic-slab.prm.bak |  303 -
 ...an-parameterization-kinematic-slab.prm.bak |   36 -
 .../2D_slice_with_faults_and_cratons.prm.bak  |  246 -
 ...omography_based_plate_motions.part.prm.bak |   53 -
 .../plugins/reference_profile.cc.bak          |  457 -
 .../plugins/reference_profile.h.bak           |  214 -
 .../tomography_based_plate_motions.cc.bak     | 1726 ----
 .../tomography_based_plate_motions.h.bak      |  513 --
 .../doc/material.part.prm.bak                 |   12 -
 .../doc/temperature.part.prm.bak              |   28 -
 .../temperature_dependent.prm.bak             |   24 -
 .../transform_fault_behn_2007.prm.bak         |  203 -
 cookbooks/van-keken-vof/doc/amr.part.prm.bak  |    8 -
 cookbooks/van-keken-vof/doc/main.part.prm.bak |   19 -
 .../doc/postprocess.part.prm.bak              |   13 -
 .../van-keken-vof/doc/variation.part.prm.bak  |   10 -
 cookbooks/van-keken-vof/van-keken-vof.prm.bak |  108 -
 cookbooks/van-keken/doc/main.part.prm.bak     |   19 -
 .../van-keken/doc/postprocess.part.prm.bak    |    3 -
 cookbooks/van-keken/doc/smooth.part.prm.bak   |    9 -
 .../van-keken/van-keken-discontinuous.prm.bak |   93 -
 cookbooks/van-keken/van-keken-smooth.prm.bak  |   94 -
 .../plugin/van_Keken_mesh.cc.bak              |  367 -
 .../vankeken_corner_flow.prm.bak              |  157 -
 .../doc/harzburgite.prm.bak                   |    9 -
 .../doc/material_model.prm.bak                |   15 -
 .../doc/steinberg.prm.bak                     |   17 -
 .../visualizing_phase_diagram.prm.bak         |  131 -
 doc/logo/logo.prm.bak                         |  111 -
 .../doc/boundary-conditions.part.prm.bak      |    7 -
 .../cookbooks/overview/doc/dim.part.prm.bak   |    1 -
 .../overview/doc/geometry.part.prm.bak        |   10 -
 .../overview/doc/gmg-average.part.prm.bak     |    3 -
 .../overview/doc/gmg-enable.part.prm.bak      |    5 -
 .../cookbooks/overview/doc/simple.prm.bak     |   16 -
 .../overview/doc/structure.part.prm.bak       |   20 -
 doc/manual/empty.prm.bak                      |   32 -
 .../adiabatic_conditions/ascii_data.h.bak     |  130 -
 .../compute_entropy_profile.h.bak             |  147 -
 .../compute_profile.h.bak                     |  200 -
 .../adiabatic_conditions/function.h.bak       |  107 -
 .../adiabatic_conditions/interface.h.bak      |  226 -
 .../boundary_composition/ascii_data.h.bak     |   99 -
 include/aspect/boundary_composition/box.h.bak |   84 -
 .../boundary_composition/function.h.bak       |   96 -
 .../initial_composition.h.bak                 |  114 -
 .../boundary_composition/interface.h.bak      |  323 -
 .../spherical_constant.h.bak                  |   95 -
 .../two_merged_boxes.h.bak                    |   84 -
 .../boundary_fluid_pressure/density.h.bak     |   92 -
 .../boundary_fluid_pressure/interface.h.bak   |  166 -
 .../aspect/boundary_heat_flux/function.h.bak  |   99 -
 .../aspect/boundary_heat_flux/interface.h.bak |  158 -
 .../boundary_temperature/ascii_data.h.bak     |  115 -
 include/aspect/boundary_temperature/box.h.bak |   91 -
 .../boundary_temperature/constant.h.bak       |   97 -
 .../boundary_temperature/dynamic_core.h.bak   |  517 --
 .../boundary_temperature/function.h.bak       |  129 -
 .../initial_temperature.h.bak                 |  115 -
 .../boundary_temperature/interface.h.bak      |  355 -
 .../spherical_constant.h.bak                  |  109 -
 .../two_merged_boxes.h.bak                    |   96 -
 .../aspect/boundary_traction/ascii_data.h.bak |  105 -
 .../aspect/boundary_traction/function.h.bak   |  112 -
 .../initial_lithostatic_pressure.h.bak        |  126 -
 .../aspect/boundary_traction/interface.h.bak  |  286 -
 .../boundary_traction/zero_traction.h.bak     |   61 -
 .../aspect/boundary_velocity/ascii_data.h.bak |  110 -
 .../aspect/boundary_velocity/function.h.bak   |  115 -
 .../aspect/boundary_velocity/gplates.h.bak    |  347 -
 .../aspect/boundary_velocity/interface.h.bak  |  349 -
 .../boundary_velocity/zero_velocity.h.bak     |   59 -
 include/aspect/citation_info.h.bak            |   62 -
 include/aspect/compat.h.bak                   |  216 -
 include/aspect/coordinate_systems.h.bak       |   52 -
 include/aspect/fe_variable_collection.h.bak   |  288 -
 include/aspect/geometry_model/box.h.bak       |  255 -
 include/aspect/geometry_model/chunk.h.bak     |  428 -
 .../geometry_model/ellipsoidal_chunk.h.bak    |  346 -
 .../initial_topography_model/ascii_data.h.bak |  103 -
 .../initial_topography_model/function.h.bak   |   93 -
 .../initial_topography_model/interface.h.bak  |  163 -
 .../prm_polygon.h.bak                         |   87 -
 .../zero_topography.h.bak                     |   60 -
 include/aspect/geometry_model/interface.h.bak |  447 -
 include/aspect/geometry_model/sphere.h.bak    |  164 -
 .../geometry_model/spherical_shell.h.bak      |  454 -
 .../geometry_model/two_merged_boxes.h.bak     |  265 -
 .../geometry_model/two_merged_chunks.h.bak    |  325 -
 include/aspect/global.h.bak                   |  312 -
 include/aspect/gravity_model/ascii_data.h.bak |   99 -
 include/aspect/gravity_model/function.h.bak   |  100 -
 include/aspect/gravity_model/interface.h.bak  |  143 -
 include/aspect/gravity_model/radial.h.bak     |  143 -
 include/aspect/gravity_model/vertical.h.bak   |   72 -
 .../heating_model/adiabatic_heating.h.bak     |  104 -
 .../adiabatic_heating_of_melt.h.bak           |  108 -
 .../heating_model/compositional_heating.h.bak |   94 -
 .../heating_model/constant_heating.h.bak      |   79 -
 include/aspect/heating_model/function.h.bak   |   97 -
 include/aspect/heating_model/interface.h.bak  |  384 -
 .../aspect/heating_model/latent_heat.h.bak    |   74 -
 .../heating_model/latent_heat_melt.h.bak      |   91 -
 .../heating_model/radioactive_decay.h.bak     |  119 -
 .../aspect/heating_model/shear_heating.h.bak  |  119 -
 .../shear_heating_with_melt.h.bak             |   78 -
 .../adiabatic_density.h.bak                   |   58 -
 .../initial_composition/ascii_data.h.bak      |   90 -
 .../ascii_data_layered.h.bak                  |   87 -
 .../entropy_table_lookup.h.bak                |  111 -
 .../aspect/initial_composition/function.h.bak |   89 -
 .../initial_composition/interface.h.bak       |  280 -
 .../aspect/initial_composition/porosity.h.bak |   84 -
 .../initial_composition/slab_model.h.bak      |  109 -
 .../initial_composition/world_builder.h.bak   |  105 -
 .../S40RTS_perturbation.h.bak                 |  233 -
 .../SAVANI_perturbation.h.bak                 |  196 -
 .../initial_temperature/adiabatic.h.bak       |  187 -
 .../adiabatic_boundary.h.bak                  |   89 -
 .../initial_temperature/ascii_data.h.bak      |   85 -
 .../ascii_data_layered.h.bak                  |   85 -
 .../initial_temperature/ascii_profile.h.bak   |   90 -
 include/aspect/initial_temperature/box.h.bak  |  122 -
 .../continental_geotherm.h.bak                |  114 -
 .../aspect/initial_temperature/function.h.bak |   93 -
 .../harmonic_perturbation.h.bak               |  107 -
 .../initial_temperature/interface.h.bak       |  277 -
 .../lithosphere_mask.h.bak                    |  168 -
 .../initial_temperature/patch_on_S40RTS.h.bak |  122 -
 .../prescribed_temperature.h.bak              |   73 -
 .../random_gaussian_perturbation.h.bak        |   99 -
 .../initial_temperature/spherical_shell.h.bak |  147 -
 .../initial_temperature/world_builder.h.bak   |   84 -
 include/aspect/introspection.h.bak            |  676 --
 include/aspect/lateral_averaging.h.bak        |  326 -
 .../ascii_reference_profile.h.bak             |  167 -
 include/aspect/material_model/averaging.h.bak |  168 -
 .../aspect/material_model/compositing.h.bak   |  136 -
 .../material_model/composition_reaction.h.bak |  125 -
 .../material_model/depth_dependent.h.bak      |  151 -
 .../diffusion_dislocation.h.bak               |  128 -
 .../material_model/drucker_prager.h.bak       |  170 -
 .../aspect/material_model/entropy_model.h.bak |  187 -
 .../equation_of_state/interface.h.bak         |  125 -
 .../linearized_incompressible.h.bak           |  140 -
 .../multicomponent_compressible.h.bak         |  143 -
 .../multicomponent_incompressible.h.bak       |  127 -
 .../thermodynamic_table_lookup.h.bak          |  236 -
 .../aspect/material_model/grain_size.h.bak    |  490 --
 include/aspect/material_model/interface.h.bak | 1534 ----
 .../aspect/material_model/latent_heat.h.bak   |  127 -
 .../material_model/latent_heat_melt.h.bak     |  205 -
 .../aspect/material_model/melt_boukare.h.bak  |  355 -
 .../aspect/material_model/melt_global.h.bak   |  149 -
 .../aspect/material_model/melt_simple.h.bak   |  144 -
 .../aspect/material_model/modified_tait.h.bak |  166 -
 .../material_model/multicomponent.h.bak       |  139 -
 .../multicomponent_compressible.h.bak         |  133 -
 .../material_model/nondimensional.h.bak       |  132 -
 .../material_model/perplex_lookup.h.bak       |  113 -
 .../material_model/prescribed_viscosity.h.bak |  110 -
 .../katz2003_mantle_melting.h.bak             |  168 -
 .../reactive_fluid_transport.h.bak            |  262 -
 .../replace_lithosphere_viscosity.h.bak       |  102 -
 .../rheology/ascii_depth_profile.h.bak        |   96 -
 .../rheology/composite_visco_plastic.h.bak    |  147 -
 .../compositional_viscosity_prefactors.h.bak  |  122 -
 .../rheology/constant_viscosity.h.bak         |   73 -
 .../constant_viscosity_prefactors.h.bak       |   85 -
 .../rheology/diffusion_creep.h.bak            |  167 -
 .../rheology/diffusion_dislocation.h.bak      |  139 -
 .../rheology/dislocation_creep.h.bak          |  155 -
 .../rheology/drucker_prager.h.bak             |  161 -
 .../material_model/rheology/elasticity.h.bak  |  197 -
 .../rheology/frank_kamenetskii.h.bak          |   98 -
 .../rheology/friction_models.h.bak            |  135 -
 .../rheology/peierls_creep.h.bak              |  275 -
 .../rheology/strain_dependent.h.bak           |  274 -
 .../rheology/visco_plastic.h.bak              |  339 -
 include/aspect/material_model/simple.h.bak    |  109 -
 .../material_model/simple_compressible.h.bak  |  137 -
 include/aspect/material_model/simpler.h.bak   |   86 -
 .../aspect/material_model/steinberger.h.bak   |  335 -
 include/aspect/material_model/utilities.h.bak |  680 --
 .../aspect/material_model/visco_plastic.h.bak |  283 -
 .../aspect/material_model/viscoelastic.h.bak  |  220 -
 include/aspect/melt.h.bak                     |  571 --
 .../aspect/mesh_deformation/ascii_data.h.bak  |   96 -
 .../aspect/mesh_deformation/diffusion.h.bak   |  138 -
 .../aspect/mesh_deformation/fastscape.h.bak   |  597 --
 .../mesh_deformation/free_surface.h.bak       |  116 -
 .../aspect/mesh_deformation/function.h.bak    |   87 -
 .../aspect/mesh_deformation/interface.h.bak   |  649 --
 .../artificial_viscosity.h.bak                |   78 -
 include/aspect/mesh_refinement/boundary.h.bak |   81 -
 .../mesh_refinement/compaction_length.h.bak   |   79 -
 .../aspect/mesh_refinement/composition.h.bak  |   78 -
 .../composition_approximate_gradient.h.bak    |   78 -
 .../composition_gradient.h.bak                |   78 -
 .../composition_threshold.h.bak               |   76 -
 include/aspect/mesh_refinement/density.h.bak  |   60 -
 .../aspect/mesh_refinement/interface.h.bak    |  318 -
 .../aspect/mesh_refinement/isosurfaces.h.bak  |  145 -
 .../maximum_refinement_function.h.bak         |   94 -
 .../minimum_refinement_function.h.bak         |   95 -
 .../nonadiabatic_temperature.h.bak            |   58 -
 .../nonadiabatic_temperature_threshold.h.bak  |   90 -
 .../mesh_refinement/particle_density.h.bak    |   69 -
 include/aspect/mesh_refinement/slope.h.bak    |   62 -
 .../aspect/mesh_refinement/strain_rate.h.bak  |   58 -
 .../aspect/mesh_refinement/temperature.h.bak  |   58 -
 .../thermal_energy_density.h.bak              |   59 -
 .../aspect/mesh_refinement/topography.h.bak   |   59 -
 include/aspect/mesh_refinement/velocity.h.bak |   58 -
 .../aspect/mesh_refinement/viscosity.h.bak    |   60 -
 .../volume_of_fluid_interface.h.bak           |   73 -
 include/aspect/newton.h.bak                   |  358 -
 include/aspect/parameters.h.bak               |  802 --
 .../particle/generator/ascii_file.h.bak       |   80 -
 .../aspect/particle/generator/interface.h.bak |  251 -
 .../probability_density_function.h.bak        |  128 -
 .../generator/quadrature_points.h.bak         |   63 -
 .../particle/generator/random_uniform.h.bak   |   98 -
 .../particle/generator/reference_cell.h.bak   |   94 -
 .../particle/generator/uniform_box.h.bak      |   99 -
 .../particle/generator/uniform_radial.h.bak   |  124 -
 .../aspect/particle/integrator/euler.h.bak    |  101 -
 .../particle/integrator/interface.h.bak       |  242 -
 include/aspect/particle/integrator/rk_2.h.bak |  155 -
 include/aspect/particle/integrator/rk_4.h.bak |  135 -
 include/aspect/particle/interface.h.bak       |   63 -
 .../interpolator/bilinear_least_squares.h.bak |  103 -
 .../particle/interpolator/cell_average.h.bak  |   80 -
 .../interpolator/harmonic_average.h.bak       |   80 -
 .../particle/interpolator/interface.h.bak     |  179 -
 .../interpolator/nearest_neighbor.h.bak       |   81 -
 .../quadratic_least_squares.h.bak             |  117 -
 .../particle/property/composition.h.bak       |   98 -
 .../property/cpo_bingham_average.h.bak        |  224 -
 .../property/cpo_elastic_tensor.h.bak         |  206 -
 .../crystal_preferred_orientation.h.bak       |  649 --
 .../particle/property/elastic_stress.h.bak    |  104 -
 .../elastic_tensor_decomposition.h.bak        |  274 -
 .../aspect/particle/property/function.h.bak   |  101 -
 .../aspect/particle/property/grain_size.h.bak |  123 -
 .../property/initial_composition.h.bak        |   83 -
 .../particle/property/initial_position.h.bak  |   71 -
 .../particle/property/integrated_strain.h.bak |   99 -
 .../integrated_strain_invariant.h.bak         |   98 -
 .../aspect/particle/property/interface.h.bak  |  816 --
 .../particle/property/melt_particle.h.bak     |  115 -
 .../aspect/particle/property/pT_path.h.bak    |  119 -
 .../aspect/particle/property/position.h.bak   |   87 -
 .../property/reference_position.h.bak         |   87 -
 .../particle/property/strain_rate.h.bak       |   97 -
 .../aspect/particle/property/velocity.h.bak   |   96 -
 .../viscoplastic_strain_invariants.h.bak      |  109 -
 include/aspect/particle/world.h.bak           |  531 --
 include/aspect/plugins.h.bak                  |  808 --
 .../aspect/postprocess/ODE_statistics.h.bak   |   82 -
 .../aspect/postprocess/basic_statistics.h.bak |   62 -
 .../postprocess/boundary_densities.h.bak      |   79 -
 .../postprocess/boundary_pressures.h.bak      |   79 -
 ...dary_strain_rate_residual_statistics.h.bak |  106 -
 ...oundary_velocity_residual_statistics.h.bak |  128 -
 include/aspect/postprocess/command.h.bak      |   72 -
 .../postprocess/composition_statistics.h.bak  |   53 -
 .../composition_velocity_statistics.h.bak     |   75 -
 .../aspect/postprocess/core_statistics.h.bak  |  106 -
 .../crystal_preferred_orientation.h.bak       |  279 -
 .../aspect/postprocess/depth_average.h.bak    |  156 -
 .../domain_volume_statistics.h.bak            |   54 -
 .../postprocess/dynamic_topography.h.bak      |  136 -
 .../entropy_viscosity_statistics.h.bak        |   52 -
 include/aspect/postprocess/geoid.h.bak        |  188 -
 .../postprocess/global_statistics.h.bak       |  153 -
 .../postprocess/gravity_point_values.h.bak    |  291 -
 .../postprocess/heat_flux_densities.h.bak     |   54 -
 .../aspect/postprocess/heat_flux_map.h.bak    |  109 -
 .../postprocess/heat_flux_statistics.h.bak    |   53 -
 .../postprocess/heating_statistics.h.bak      |   56 -
 include/aspect/postprocess/interface.h.bak    |  380 -
 .../postprocess/load_balance_statistics.h.bak |   66 -
 .../postprocess/mass_flux_statistics.h.bak    |   54 -
 .../postprocess/material_statistics.h.bak     |   54 -
 .../postprocess/matrix_statistics.h.bak       |   52 -
 .../aspect/postprocess/max_depth_field.h.bak  |   52 -
 .../aspect/postprocess/melt_statistics.h.bak  |   57 -
 .../postprocess/memory_statistics.h.bak       |   68 -
 .../postprocess/mobility_statistics.h.bak     |   52 -
 .../particle_count_statistics.h.bak           |   60 -
 include/aspect/postprocess/particles.h.bak    |  319 -
 include/aspect/postprocess/point_values.h.bak |  128 -
 .../postprocess/pressure_statistics.h.bak     |   52 -
 .../postprocess/rotation_statistics.h.bak     |   85 -
 include/aspect/postprocess/sea_level.h.bak    |  178 -
 .../spherical_velocity_statistics.h.bak       |   54 -
 .../aspect/postprocess/stokes_residual.h.bak  |  108 -
 .../postprocess/temperature_statistics.h.bak  |   52 -
 include/aspect/postprocess/topography.h.bak   |   91 -
 .../velocity_boundary_statistics.h.bak        |   55 -
 .../postprocess/velocity_statistics.h.bak     |   52 -
 .../viscous_dissipation_statistics.h.bak      |   54 -
 .../aspect/postprocess/visualization.h.bak    |  747 --
 .../ISA_rotation_timescale.h.bak              |   72 -
 .../postprocess/visualization/adiabat.h.bak   |   68 -
 .../visualization/artificial_viscosity.h.bak  |   60 -
 .../artificial_viscosity_composition.h.bak    |   80 -
 .../visualization/boundary_indicator.h.bak    |   65 -
 .../boundary_strain_rate_residual.h.bak       |   87 -
 .../boundary_velocity_residual.h.bak          |   84 -
 .../visualization/compositional_vector.h.bak  |   86 -
 .../postprocess/visualization/depth.h.bak     |   58 -
 .../visualization/dynamic_topography.h.bak    |   75 -
 .../visualization/error_indicator.h.bak       |   59 -
 .../postprocess/visualization/geoid.h.bak     |   84 -
 .../visualization/grain_lag_angle.h.bak       |   79 -
 .../postprocess/visualization/gravity.h.bak   |   58 -
 .../visualization/heat_flux_map.h.bak         |  105 -
 .../postprocess/visualization/heating.h.bak   |   74 -
 .../visualization/kxrcf_indicator.h.bak       |   80 -
 .../visualization/material_properties.h.bak   |   92 -
 ...aximum_horizontal_compressive_stress.h.bak |   92 -
 .../postprocess/visualization/melt.h.bak      |   84 -
 .../visualization/melt_fraction.h.bak         |  116 -
 .../named_additional_outputs.h.bak            |   79 -
 .../visualization/nonadiabatic_pressure.h.bak |   62 -
 .../nonadiabatic_temperature.h.bak            |   62 -
 .../visualization/particle_count.h.bak        |   71 -
 .../postprocess/visualization/partition.h.bak |   62 -
 .../visualization/principal_stress.h.bak      |   82 -
 .../visualization/seismic_anomalies.h.bak     |  156 -
 .../visualization/shear_stress.h.bak          |   72 -
 .../visualization/spd_factor.h.bak            |   71 -
 .../spherical_velocity_components.h.bak       |   76 -
 .../visualization/strain_rate.h.bak           |   67 -
 .../visualization/strain_rate_tensor.h.bak    |   65 -
 .../postprocess/visualization/stress.h.bak    |   71 -
 .../stress_second_invariant.h.bak             |   67 -
 .../surface_dynamic_topography.h.bak          |   72 -
 .../visualization/surface_elevation.h.bak     |   68 -
 .../surface_strain_rate_tensor.h.bak          |   68 -
 .../visualization/surface_stress.h.bak        |   73 -
 .../visualization/temperature_anomaly.h.bak   |   93 -
 .../visualization/vertical_heat_flux.h.bak    |   67 -
 .../volume_of_fluid_values.h.bak              |  116 -
 .../volumetric_strain_rate.h.bak              |   62 -
 .../volume_of_fluid_statistics.h.bak          |   53 -
 .../ascii_data.h.bak                          |   85 -
 .../prescribed_stokes_solution/circle.h.bak   |   51 -
 .../prescribed_stokes_solution/function.h.bak |  105 -
 .../interface.h.bak                           |  159 -
 include/aspect/simulator.h.bak                | 2203 -----
 .../simulator/assemblers/advection.h.bak      |  136 -
 .../simulator/assemblers/interface.h.bak      |  818 --
 .../aspect/simulator/assemblers/stokes.h.bak  |  224 -
 include/aspect/simulator_access.h.bak         | 1002 ---
 include/aspect/simulator_signals.h.bak        |  420 -
 include/aspect/stokes_matrix_free.h.bak       |  702 --
 include/aspect/structured_data.h.bak          |  778 --
 .../termination_criteria/end_step.h.bak       |   70 -
 .../termination_criteria/end_time.h.bak       |   77 -
 .../termination_criteria/end_walltime.h.bak   |   84 -
 .../termination_criteria/interface.h.bak      |  244 -
 .../steady_heat_flux.h.bak                    |   94 -
 .../steady_rms_velocity.h.bak                 |   79 -
 .../steady_temperature.h.bak                  |   78 -
 .../termination_criteria/user_request.h.bak   |   72 -
 .../time_stepping/conduction_time_step.h.bak  |   61 -
 .../time_stepping/convection_time_step.h.bak  |   62 -
 include/aspect/time_stepping/function.h.bak   |   72 -
 include/aspect/time_stepping/interface.h.bak  |  284 -
 .../time_stepping/repeat_on_cutback.h.bak     |   85 -
 include/aspect/utilities.h.bak                | 1392 ---
 include/aspect/volume_of_fluid/assembly.h.bak |  231 -
 include/aspect/volume_of_fluid/field.h.bak    |   96 -
 include/aspect/volume_of_fluid/handler.h.bak  |  226 -
 .../aspect/volume_of_fluid/utilities.h.bak    |  171 -
 source/adiabatic_conditions/ascii_data.cc.bak |  168 -
 .../compute_entropy_profile.cc.bak            |  315 -
 .../compute_profile.cc.bak                    |  427 -
 source/adiabatic_conditions/function.cc.bak   |  148 -
 source/adiabatic_conditions/interface.cc.bak  |  222 -
 source/boundary_composition/ascii_data.cc.bak |  131 -
 source/boundary_composition/box.cc.bak        |  180 -
 source/boundary_composition/function.cc.bak   |  146 -
 .../initial_composition.cc.bak                |  135 -
 source/boundary_composition/interface.cc.bak  |  376 -
 .../spherical_constant.cc.bak                 |  143 -
 .../two_merged_boxes.cc.bak                   |  207 -
 source/boundary_fluid_pressure/density.cc.bak |  154 -
 .../boundary_fluid_pressure/interface.cc.bak  |  155 -
 source/boundary_heat_flux/function.cc.bak     |  179 -
 source/boundary_heat_flux/interface.cc.bak    |  155 -
 source/boundary_temperature/ascii_data.cc.bak |  144 -
 source/boundary_temperature/box.cc.bak        |  173 -
 source/boundary_temperature/constant.cc.bak   |  189 -
 .../boundary_temperature/dynamic_core.cc.bak  |  986 ---
 source/boundary_temperature/function.cc.bak   |  186 -
 .../initial_temperature.cc.bak                |  134 -
 source/boundary_temperature/interface.cc.bak  |  390 -
 .../spherical_constant.cc.bak                 |  149 -
 .../two_merged_boxes.cc.bak                   |  191 -
 source/boundary_traction/ascii_data.cc.bak    |  140 -
 source/boundary_traction/function.cc.bak      |  158 -
 .../initial_lithostatic_pressure.cc.bak       |  442 -
 source/boundary_traction/interface.cc.bak     |  321 -
 source/boundary_traction/zero_traction.cc.bak |   62 -
 source/boundary_velocity/ascii_data.cc.bak    |  177 -
 source/boundary_velocity/function.cc.bak      |  185 -
 source/boundary_velocity/gplates.cc.bak       |  870 --
 source/boundary_velocity/interface.cc.bak     |  414 -
 source/boundary_velocity/zero_velocity.cc.bak |   54 -
 source/citation_info.cc.bak                   |   55 -
 source/compat.cc.bak                          |  800 --
 source/fe_variable_collection.cc.bak          |  268 -
 source/geometry_model/box.cc.bak              |  524 --
 source/geometry_model/chunk.cc.bak            |  949 --
 .../geometry_model/ellipsoidal_chunk.cc.bak   |  833 --
 .../ascii_data.cc.bak                         |  204 -
 .../initial_topography_model/function.cc.bak  |  190 -
 .../initial_topography_model/interface.cc.bak |  176 -
 .../prm_polygon.cc.bak                        |  172 -
 .../zero_topography.cc.bak                    |   58 -
 source/geometry_model/interface.cc.bak        |  368 -
 source/geometry_model/sphere.cc.bak           |  238 -
 source/geometry_model/spherical_shell.cc.bak  | 1074 ---
 source/geometry_model/two_merged_boxes.cc.bak |  570 --
 .../geometry_model/two_merged_chunks.cc.bak   |  635 --
 source/global.cc.bak                          |  112 -
 source/gravity_model/ascii_data.cc.bak        |  126 -
 source/gravity_model/function.cc.bak          |  138 -
 source/gravity_model/interface.cc.bak         |  167 -
 source/gravity_model/radial.cc.bak            |  211 -
 source/gravity_model/vertical.cc.bak          |   98 -
 source/heating_model/adiabatic_heating.cc.bak |  112 -
 .../adiabatic_heating_of_melt.cc.bak          |  160 -
 .../compositional_heating.cc.bak              |  141 -
 source/heating_model/constant_heating.cc.bak  |   96 -
 source/heating_model/function.cc.bak          |  157 -
 source/heating_model/interface.cc.bak         |  324 -
 source/heating_model/latent_heat.cc.bak       |   63 -
 source/heating_model/latent_heat_melt.cc.bak  |  187 -
 source/heating_model/radioactive_decay.cc.bak |  206 -
 source/heating_model/shear_heating.cc.bak     |  203 -
 .../shear_heating_with_melt.cc.bak            |  122 -
 .../adiabatic_density.cc.bak                  |   54 -
 source/initial_composition/ascii_data.cc.bak  |  118 -
 .../ascii_data_layered.cc.bak                 |  123 -
 .../entropy_table_lookup.cc.bak               |  138 -
 source/initial_composition/function.cc.bak    |  125 -
 source/initial_composition/interface.cc.bak   |  275 -
 source/initial_composition/porosity.cc.bak    |  116 -
 source/initial_composition/slab_model.cc.bak  |  147 -
 .../initial_composition/world_builder.cc.bak  |  136 -
 .../S40RTS_perturbation.cc.bak                |  530 --
 .../SAVANI_perturbation.cc.bak                |  537 --
 source/initial_temperature/adiabatic.cc.bak   |  572 --
 .../adiabatic_boundary.cc.bak                 |  136 -
 source/initial_temperature/ascii_data.cc.bak  |  112 -
 .../ascii_data_layered.cc.bak                 |  124 -
 .../initial_temperature/ascii_profile.cc.bak  |  112 -
 source/initial_temperature/box.cc.bak         |  276 -
 .../continental_geotherm.cc.bak               |  269 -
 source/initial_temperature/function.cc.bak    |  129 -
 .../harmonic_perturbation.cc.bak              |  234 -
 source/initial_temperature/interface.cc.bak   |  264 -
 .../lithosphere_mask.cc.bak                   |  223 -
 .../patch_on_S40RTS.cc.bak                    |  212 -
 .../prescribed_temperature.cc.bak             |   97 -
 .../random_gaussian_perturbation.cc.bak       |  211 -
 .../spherical_shell.cc.bak                    |  378 -
 .../initial_temperature/world_builder.cc.bak  |   84 -
 source/main.cc.bak                            |  892 --
 .../ascii_reference_profile.cc.bak            |  280 -
 source/material_model/averaging.cc.bak        |  464 -
 source/material_model/compositing.cc.bak      |  259 -
 .../composition_reaction.cc.bak               |  250 -
 source/material_model/depth_dependent.cc.bak  |  350 -
 .../diffusion_dislocation.cc.bak              |  219 -
 source/material_model/drucker_prager.cc.bak   |  323 -
 source/material_model/entropy_model.cc.bak    |  577 --
 .../equation_of_state/interface.cc.bak        |   85 -
 .../linearized_incompressible.cc.bak          |  160 -
 .../multicomponent_compressible.cc.bak        |  177 -
 .../multicomponent_incompressible.cc.bak      |  156 -
 .../thermodynamic_table_lookup.cc.bak         |  579 --
 source/material_model/grain_size.cc.bak       | 1687 ----
 source/material_model/interface.cc.bak        | 1239 ---
 source/material_model/latent_heat.cc.bak      |  422 -
 source/material_model/latent_heat_melt.cc.bak |  660 --
 source/material_model/melt_boukare.cc.bak     | 1314 ---
 source/material_model/melt_global.cc.bak      |  556 --
 source/material_model/melt_simple.cc.bak      |  284 -
 source/material_model/modified_tait.cc.bak    |  271 -
 source/material_model/multicomponent.cc.bak   |  179 -
 .../multicomponent_compressible.cc.bak        |  184 -
 source/material_model/nondimensional.cc.bak   |  216 -
 source/material_model/perplex_lookup.cc.bak   |  230 -
 .../prescribed_viscosity.cc.bak               |  210 -
 .../katz2003_mantle_melting.cc.bak            |  651 --
 .../reactive_fluid_transport.cc.bak           |  585 --
 .../replace_lithosphere_viscosity.cc.bak      |  172 -
 .../rheology/ascii_depth_profile.cc.bak       |   99 -
 .../rheology/composite_visco_plastic.cc.bak   |  458 -
 .../compositional_viscosity_prefactors.cc.bak |  178 -
 .../rheology/constant_viscosity.cc.bak        |   67 -
 .../constant_viscosity_prefactors.cc.bak      |  105 -
 .../rheology/diffusion_creep.cc.bak           |  303 -
 .../rheology/diffusion_dislocation.cc.bak     |  386 -
 .../rheology/dislocation_creep.cc.bak         |  285 -
 .../rheology/drucker_prager.cc.bak            |  294 -
 .../material_model/rheology/elasticity.cc.bak |  529 --
 .../rheology/frank_kamenetskii.cc.bak         |  156 -
 .../rheology/friction_models.cc.bak           |  312 -
 .../rheology/peierls_creep.cc.bak             |  679 --
 .../rheology/strain_dependent.cc.bak          |  917 --
 .../rheology/visco_plastic.cc.bak             |  855 --
 source/material_model/simple.cc.bak           |  265 -
 .../material_model/simple_compressible.cc.bak |  170 -
 source/material_model/simpler.cc.bak          |  131 -
 source/material_model/steinberger.cc.bak      |  631 --
 source/material_model/utilities.cc.bak        | 1546 ----
 source/material_model/visco_plastic.cc.bak    |  678 --
 source/material_model/viscoelastic.cc.bak     |  313 -
 source/mesh_deformation/ascii_data.cc.bak     |  151 -
 source/mesh_deformation/diffusion.cc.bak      |  582 --
 source/mesh_deformation/fastscape.cc.bak      | 1997 -----
 source/mesh_deformation/free_surface.cc.bak   |  336 -
 source/mesh_deformation/function.cc.bak       |  149 -
 source/mesh_deformation/interface.cc.bak      | 1605 ----
 .../artificial_viscosity.cc.bak               |  132 -
 source/mesh_refinement/boundary.cc.bak        |  122 -
 .../mesh_refinement/compaction_length.cc.bak  |  158 -
 source/mesh_refinement/composition.cc.bak     |  152 -
 .../composition_approximate_gradient.cc.bak   |  153 -
 .../composition_gradient.cc.bak               |  185 -
 .../composition_threshold.cc.bak              |  137 -
 source/mesh_refinement/density.cc.bak         |  143 -
 source/mesh_refinement/interface.cc.bak       |  519 --
 source/mesh_refinement/isosurfaces.cc.bak     |  404 -
 .../maximum_refinement_function.cc.bak        |  193 -
 .../minimum_refinement_function.cc.bak        |  192 -
 .../nonadiabatic_temperature.cc.bak           |  127 -
 .../nonadiabatic_temperature_threshold.cc.bak |  158 -
 .../mesh_refinement/particle_density.cc.bak   |   75 -
 source/mesh_refinement/slope.cc.bak           |  103 -
 source/mesh_refinement/strain_rate.cc.bak     |   75 -
 source/mesh_refinement/temperature.cc.bak     |   83 -
 .../thermal_energy_density.cc.bak             |  144 -
 source/mesh_refinement/topography.cc.bak      |   87 -
 source/mesh_refinement/velocity.cc.bak        |   83 -
 source/mesh_refinement/viscosity.cc.bak       |  148 -
 .../volume_of_fluid_interface.cc.bak          |  345 -
 source/particle/generator/ascii_file.cc.bak   |  133 -
 source/particle/generator/interface.cc.bak    |  306 -
 .../probability_density_function.cc.bak       |  149 -
 .../generator/quadrature_points.cc.bak        |   63 -
 .../particle/generator/random_uniform.cc.bak  |  123 -
 .../particle/generator/reference_cell.cc.bak  |  148 -
 source/particle/generator/uniform_box.cc.bak  |  175 -
 .../particle/generator/uniform_radial.cc.bak  |  254 -
 source/particle/integrator/euler.cc.bak       |  103 -
 source/particle/integrator/interface.cc.bak   |  248 -
 source/particle/integrator/rk_2.cc.bak        |  242 -
 source/particle/integrator/rk_4.cc.bak        |  281 -
 source/particle/interface.cc.bak              |   42 -
 .../bilinear_least_squares.cc.bak             |  364 -
 .../particle/interpolator/cell_average.cc.bak |  161 -
 .../interpolator/harmonic_average.cc.bak      |  169 -
 source/particle/interpolator/interface.cc.bak |  149 -
 .../interpolator/nearest_neighbor.cc.bak      |  161 -
 .../quadratic_least_squares.cc.bak            |  640 --
 source/particle/property/composition.cc.bak   |  110 -
 .../property/cpo_bingham_average.cc.bak       |  284 -
 .../property/cpo_elastic_tensor.cc.bak        |  261 -
 .../crystal_preferred_orientation.cc.bak      | 1275 ---
 .../particle/property/elastic_stress.cc.bak   |  199 -
 .../elastic_tensor_decomposition.cc.bak       |  468 -
 source/particle/property/function.cc.bak      |  113 -
 source/particle/property/grain_size.cc.bak    |  173 -
 .../property/initial_composition.cc.bak       |   91 -
 .../particle/property/initial_position.cc.bak |   72 -
 .../property/integrated_strain.cc.bak         |  124 -
 .../integrated_strain_invariant.cc.bak        |  118 -
 source/particle/property/interface.cc.bak     |  820 --
 source/particle/property/melt_particle.cc.bak |  126 -
 source/particle/property/pT_path.cc.bak       |  123 -
 source/particle/property/position.cc.bak      |   80 -
 .../property/reference_position.cc.bak        |   80 -
 source/particle/property/strain_rate.cc.bak   |  102 -
 source/particle/property/velocity.cc.bak      |   88 -
 .../viscoplastic_strain_invariants.cc.bak     |  243 -
 source/particle/world.cc.bak                  | 1384 ---
 source/plugins.cc.bak                         |   50 -
 source/postprocess/ODE_statistics.cc.bak      |  108 -
 source/postprocess/basic_statistics.cc.bak    |  165 -
 source/postprocess/boundary_densities.cc.bak  |  177 -
 source/postprocess/boundary_pressures.cc.bak  |  156 -
 ...ary_strain_rate_residual_statistics.cc.bak |  332 -
 ...undary_velocity_residual_statistics.cc.bak |  376 -
 source/postprocess/command.cc.bak             |  131 -
 .../postprocess/composition_statistics.cc.bak |  168 -
 .../composition_velocity_statistics.cc.bak    |  205 -
 source/postprocess/core_statistics.cc.bak     |  236 -
 .../crystal_preferred_orientation.cc.bak      |  870 --
 source/postprocess/depth_average.cc.bak       |  517 --
 .../domain_volume_statistics.cc.bak           |   69 -
 source/postprocess/dynamic_topography.cc.bak  |  548 --
 .../entropy_viscosity_statistics.cc.bak       |  118 -
 source/postprocess/geoid.cc.bak               | 1060 ---
 source/postprocess/global_statistics.cc.bak   |  324 -
 .../postprocess/gravity_point_values.cc.bak   |  850 --
 source/postprocess/heat_flux_densities.cc.bak |  157 -
 source/postprocess/heat_flux_map.cc.bak       |  565 --
 .../postprocess/heat_flux_statistics.cc.bak   |  160 -
 source/postprocess/heating_statistics.cc.bak  |  166 -
 source/postprocess/interface.cc.bak           |  414 -
 .../load_balance_statistics.cc.bak            |  111 -
 .../postprocess/mass_flux_statistics.cc.bak   |  188 -
 source/postprocess/material_statistics.cc.bak |  128 -
 source/postprocess/matrix_statistics.cc.bak   |  119 -
 source/postprocess/max_depth_field.cc.bak     |  131 -
 source/postprocess/melt_statistics.cc.bak     |  152 -
 source/postprocess/memory_statistics.cc.bak   |  141 -
 source/postprocess/mobility_statistics.cc.bak |  156 -
 .../particle_count_statistics.cc.bak          |   97 -
 source/postprocess/particles.cc.bak           |  758 --
 source/postprocess/point_values.cc.bak        |  369 -
 source/postprocess/pressure_statistics.cc.bak |  144 -
 source/postprocess/rotation_statistics.cc.bak |  202 -
 source/postprocess/sea_level.cc.bak           |  618 --
 .../spherical_velocity_statistics.cc.bak      |  170 -
 source/postprocess/stokes_residual.cc.bak     |  179 -
 .../postprocess/temperature_statistics.cc.bak |  172 -
 source/postprocess/topography.cc.bak          |  250 -
 .../velocity_boundary_statistics.cc.bak       |  217 -
 source/postprocess/velocity_statistics.cc.bak |  118 -
 .../viscous_dissipation_statistics.cc.bak     |  168 -
 source/postprocess/visualization.cc.bak       | 1688 ----
 .../ISA_rotation_timescale.cc.bak             |  116 -
 .../postprocess/visualization/adiabat.cc.bak  |  120 -
 .../visualization/artificial_viscosity.cc.bak |   84 -
 .../artificial_viscosity_composition.cc.bak   |  135 -
 .../visualization/boundary_indicator.cc.bak   |  112 -
 .../boundary_strain_rate_residual.cc.bak      |  148 -
 .../boundary_velocity_residual.cc.bak         |  126 -
 .../visualization/compositional_vector.cc.bak |  196 -
 source/postprocess/visualization/depth.cc.bak |   93 -
 .../visualization/dynamic_topography.cc.bak   |  142 -
 .../visualization/error_indicator.cc.bak      |   78 -
 source/postprocess/visualization/geoid.cc.bak |  113 -
 .../visualization/grain_lag_angle.cc.bak      |  180 -
 .../postprocess/visualization/gravity.cc.bak  |   80 -
 .../visualization/heat_flux_map.cc.bak        |  208 -
 .../postprocess/visualization/heating.cc.bak  |  188 -
 .../visualization/kxrcf_indicator.cc.bak      |  135 -
 .../visualization/material_properties.cc.bak  |  306 -
 ...ximum_horizontal_compressive_stress.cc.bak |  366 -
 source/postprocess/visualization/melt.cc.bak  |  278 -
 .../visualization/melt_fraction.cc.bak        |  354 -
 .../named_additional_outputs.cc.bak           |  184 -
 .../nonadiabatic_pressure.cc.bak              |   91 -
 .../nonadiabatic_temperature.cc.bak           |   81 -
 .../visualization/particle_count.cc.bak       |   90 -
 .../visualization/partition.cc.bak            |   81 -
 .../visualization/principal_stress.cc.bak     |  242 -
 .../visualization/seismic_anomalies.cc.bak    |  566 --
 .../visualization/shear_stress.cc.bak         |  148 -
 .../visualization/spd_factor.cc.bak           |  109 -
 .../spherical_velocity_components.cc.bak      |  145 -
 .../visualization/strain_rate.cc.bak          |   97 -
 .../visualization/strain_rate_tensor.cc.bak   |  105 -
 .../postprocess/visualization/stress.cc.bak   |  147 -
 .../stress_second_invariant.cc.bak            |  137 -
 .../surface_dynamic_topography.cc.bak         |  135 -
 .../visualization/surface_elevation.cc.bak    |  110 -
 .../surface_strain_rate_tensor.cc.bak         |  109 -
 .../visualization/surface_stress.cc.bak       |  143 -
 .../visualization/temperature_anomaly.cc.bak  |  190 -
 .../visualization/vertical_heat_flux.cc.bak   |  106 -
 .../volume_of_fluid_values.cc.bak             |  209 -
 .../volumetric_strain_rate.cc.bak             |   95 -
 .../volume_of_fluid_statistics.cc.bak         |  117 -
 .../ascii_data.cc.bak                         |  121 -
 .../prescribed_stokes_solution/circle.cc.bak  |   70 -
 .../function.cc.bak                           |  246 -
 .../interface.cc.bak                          |  156 -
 source/simulator/assemblers/advection.cc.bak  | 1634 ----
 source/simulator/assemblers/interface.cc.bak  |  656 --
 .../simulator/assemblers/newton_stokes.cc.bak |  972 --
 source/simulator/assemblers/stokes.cc.bak     |  994 ---
 source/simulator/assembly.cc.bak              | 1301 ---
 source/simulator/checkpoint_restart.cc.bak    |  650 --
 source/simulator/core.cc.bak                  | 2199 -----
 source/simulator/entropy_viscosity.cc.bak     |  710 --
 source/simulator/helper_functions.cc.bak      | 2521 ------
 source/simulator/initial_conditions.cc.bak    |  545 --
 source/simulator/introspection.cc.bak         |  615 --
 source/simulator/lateral_averaging.cc.bak     |  972 --
 source/simulator/limiters.cc.bak              |  876 --
 source/simulator/melt.cc.bak                  | 1960 -----
 source/simulator/newton.cc.bak                |  318 -
 source/simulator/nullspace.cc.bak             |  522 --
 source/simulator/parameters.cc.bak            | 2329 -----
 source/simulator/simulator_access.cc.bak      |  901 --
 source/simulator/simulator_signals.cc.bak     |  102 -
 source/simulator/solver.cc.bak                | 1270 ---
 source/simulator/solver_schemes.cc.bak        | 1411 ---
 source/simulator/stokes_matrix_free.cc.bak    | 2798 ------
 source/structured_data.cc.bak                 | 1952 -----
 source/termination_criteria/end_step.cc.bak   |   71 -
 source/termination_criteria/end_time.cc.bak   |   95 -
 .../termination_criteria/end_walltime.cc.bak  |   80 -
 source/termination_criteria/interface.cc.bak  |  284 -
 .../steady_heat_flux.cc.bak                   |  233 -
 .../steady_rms_velocity.cc.bak                |  172 -
 .../steady_temperature.cc.bak                 |  199 -
 .../termination_criteria/user_request.cc.bak  |   95 -
 .../time_stepping/conduction_time_step.cc.bak |  131 -
 .../time_stepping/convection_time_step.cc.bak |  109 -
 source/time_stepping/function.cc.bak          |  106 -
 source/time_stepping/interface.cc.bak         |  380 -
 source/time_stepping/repeat_on_cutback.cc.bak |  115 -
 source/utilities.cc.bak                       | 3601 --------
 source/volume_of_fluid/assembler.cc.bak       |  650 --
 source/volume_of_fluid/handler.cc.bak         |  647 --
 source/volume_of_fluid/reconstruct.cc.bak     |  519 --
 .../setup_initial_conditions.cc.bak           |  245 -
 source/volume_of_fluid/solver.cc.bak          |  106 -
 source/volume_of_fluid/utilities.cc.bak       |  694 --
 tests/2d_annulus_pyvista_cookbook.prm.bak     |   90 -
 tests/ISA_rotation_timescale.prm.bak          |  102 -
 tests/Picard_compressible.prm.bak             |  249 -
 tests/additional_outputs_02.cc.bak            |  171 -
 tests/additional_outputs_02.prm.bak           |   77 -
 tests/additional_outputs_03.cc.bak            |  185 -
 tests/additional_outputs_03.prm.bak           |   78 -
 tests/adiabatic_boundary.prm.bak              |   66 -
 tests/adiabatic_conditions.prm.bak            |   75 -
 ...ic_conditions_composition_function.prm.bak |   83 -
 tests/adiabatic_conditions_function.prm.bak   |   83 -
 .../adiabatic_conditions_time_change.prm.bak  |   88 -
 tests/adiabatic_heating.prm.bak               |  124 -
 tests/adiabatic_heating_simplified.prm.bak    |  130 -
 tests/adiabatic_heating_with_melt.prm.bak     |  146 -
 tests/adiabatic_initial_conditions.prm.bak    |   99 -
 ...adiabatic_initial_conditions_chunk.prm.bak |   94 -
 ...abatic_initial_conditions_chunk_3d.prm.bak |   98 -
 ...ic_initial_conditions_compressible.prm.bak |   95 -
 ...abatic_initial_conditions_constant.prm.bak |   89 -
 ...diabatic_initial_conditions_points.prm.bak |  105 -
 ...initial_conditions_subadiabaticity.prm.bak |   93 -
 ...nitial_conditions_without_boundary.prm.bak |   66 -
 tests/adiabatic_plate_cooling.prm.bak         |   81 -
 tests/adiabatic_plate_function.prm.bak        |   86 -
 tests/advect_field_with_melt_velocity.cc.bak  |   21 -
 tests/advect_field_with_melt_velocity.prm.bak |  142 -
 tests/advect_mesh_vertically.prm.bak          |  128 -
 tests/advection_reaction.cc.bak               |   21 -
 tests/advection_reaction.prm.bak              |  152 -
 tests/advection_solver_fail.prm.bak           |   12 -
 tests/airy_isostasy.prm.bak                   |  140 -
 tests/airy_isostasy_initial_topo.cc.bak       |   77 -
 tests/airy_isostasy_initial_topo.prm.bak      |   37 -
 ..._initial_topo_lithostatic_pressure.prm.bak |   41 -
 tests/always_refine.prm.bak                   |  107 -
 tests/analytic_artificial_viscosity_0.prm.bak |   93 -
 tests/anisotropic_viscosity.cc.bak            |  830 --
 tests/anisotropic_viscosity.prm.bak           |   91 -
 tests/annulus.cc.bak                          |   21 -
 tests/annulus.prm.bak                         |   10 -
 tests/annulus_transient.cc.bak                |   21 -
 tests/annulus_transient.prm.bak               |   96 -
 tests/artificial_postprocess.cc.bak           |   83 -
 tests/artificial_postprocess.prm.bak          |  112 -
 tests/artificial_viscosity.prm.bak            |  124 -
 ...ial_viscosity_dirichlet_boundaries.prm.bak |  110 -
 tests/artificial_viscosity_list.prm.bak       |   93 -
 tests/ascii_boundary_member.cc.bak            |  212 -
 tests/ascii_boundary_member.prm.bak           |   67 -
 tests/ascii_data_adiabatic_conditions.prm.bak |   78 -
 ...a_boundary_composition_2d_box_time.prm.bak |   89 -
 ...i_data_boundary_composition_3d_box.prm.bak |   78 -
 ...a_boundary_temperature_2d_box_time.prm.bak |   71 -
 ...i_data_boundary_temperature_3d_box.prm.bak |   68 -
 ...scii_data_boundary_velocity_2d_box.prm.bak |   67 -
 ...data_boundary_velocity_2d_box_list.prm.bak |   73 -
 ...data_boundary_velocity_2d_box_time.prm.bak |   74 -
 ...dary_velocity_2d_box_time_backward.prm.bak |   77 -
 ...locity_2d_box_time_non_equidistant.prm.bak |   73 -
 ...ii_data_boundary_velocity_2d_chunk.prm.bak |   72 -
 ...ii_data_boundary_velocity_2d_shell.prm.bak |   72 -
 ...undary_velocity_2d_shell_spherical.prm.bak |   73 -
 ...scii_data_boundary_velocity_3d_box.prm.bak |   74 -
 ...ii_data_boundary_velocity_3d_chunk.prm.bak |   75 -
 ...ii_data_boundary_velocity_3d_shell.prm.bak |   72 -
 ...undary_velocity_3d_shell_spherical.prm.bak |   73 -
 ...i_data_boundary_velocity_3d_sphere.prm.bak |   70 -
 ...a_boundary_velocity_residual_shell.prm.bak |   84 -
 tests/ascii_data_fail_1.prm.bak               |   71 -
 tests/ascii_data_fail_2.prm.bak               |   71 -
 tests/ascii_data_fail_3.prm.bak               |   71 -
 tests/ascii_data_fail_4.prm.bak               |   71 -
 tests/ascii_data_gravity.prm.bak              |   79 -
 ...ii_data_initial_composition_2d_box.prm.bak |   77 -
 ...data_initial_composition_2d_box_gz.prm.bak |   79 -
 ..._data_initial_composition_3d_chunk.prm.bak |   85 -
 ..._data_initial_composition_3d_shell.prm.bak |   83 -
 ...ii_data_initial_temperature_2d_box.prm.bak |   59 -
 ..._data_initial_temperature_3d_chunk.prm.bak |   63 -
 ...l_temperature_3d_ellipsoidal_chunk.prm.bak |   62 -
 ..._data_initial_temperature_3d_shell.prm.bak |   60 -
 ..._initial_temperature_3d_two_chunks.prm.bak |   66 -
 ...layered_initial_composition_2d_box.prm.bak |   77 -
 ...layered_initial_temperature_2d_box.prm.bak |   65 -
 ...yered_initial_temperature_2d_chunk.prm.bak |   67 -
 ...layered_initial_temperature_3d_box.prm.bak |   67 -
 ...yered_initial_temperature_3d_chunk.prm.bak |   74 -
 ...perature_piecewise_constant_3d_box.prm.bak |   66 -
 ...uniform_initial_composition_2d_box.prm.bak |   87 -
 ...scii_data_prescribed_stokes_2d_box.prm.bak |   73 -
 tests/ascii_data_slice.prm.bak                |  111 -
 tests/ascii_data_slice_temperature.prm.bak    |   64 -
 tests/average_arithmetic.prm.bak              |   95 -
 ...ge_density_boundary_fluid_pressure.prm.bak |  280 -
 tests/average_geometric.prm.bak               |   95 -
 tests/average_harmonic.prm.bak                |   95 -
 tests/average_log.prm.bak                     |   95 -
 tests/average_none.prm.bak                    |   96 -
 tests/average_nwd_arithmetic.prm.bak          |  100 -
 tests/average_nwd_geometric.prm.bak           |  100 -
 tests/average_nwd_harmonic.prm.bak            |  100 -
 tests/average_pick_largest.prm.bak            |   95 -
 tests/average_project_to_q1.prm.bak           |   96 -
 tests/background_output_writer.prm.bak        |   14 -
 tests/backward_advection.prm.bak              |   84 -
 tests/benchmark_layeredflow.cc.bak            |   21 -
 tests/benchmark_layeredflow.prm.bak           |   13 -
 ...chmark_particle_integration_scheme.prm.bak |    7 -
 tests/blankenbach.prm.bak                     |   80 -
 tests/blankenbach_approximation.prm.bak       |   93 -
 tests/blankenbach_case1a.cc.bak               |   22 -
 tests/blankenbach_case1a.prm.bak              |   20 -
 tests/blankenbach_case1b.cc.bak               |   22 -
 tests/blankenbach_case1b.prm.bak              |   26 -
 tests/blankenbach_case1c.cc.bak               |   22 -
 tests/blankenbach_case1c.prm.bak              |   26 -
 tests/blankenbach_case2a.cc.bak               |   22 -
 tests/blankenbach_case2a.prm.bak              |   20 -
 tests/blankenbach_case2b.cc.bak               |   22 -
 tests/blankenbach_case2b.prm.bak              |   20 -
 tests/boukare_bulk_composition.prm.bak        |  211 -
 tests/boukare_conserve_mass.prm.bak           |  159 -
 tests/boukare_latent_heat.prm.bak             |  166 -
 tests/boukare_melting_diagram.prm.bak         |  162 -
 tests/boundary_composition_list.prm.bak       |  103 -
 ...dary_composition_passive_cartesian.prm.bak |  102 -
 ...boundary_composition_passive_depth.prm.bak |  102 -
 ...oundary_composition_passive_sphere.prm.bak |  102 -
 tests/boundary_heatflux.prm.bak               |  124 -
 tests/boundary_heatflux_update.cc.bak         |  108 -
 tests/boundary_heatflux_update.prm.bak        |  102 -
 tests/boundary_temperature_function.prm.bak   |   70 -
 tests/boundary_temperature_list.prm.bak       |   74 -
 ...on_function_cartesian_free_surface.prm.bak |  143 -
 ...on_function_spherical_free_surface.prm.bak |  144 -
 ...undary_velocity_function_spherical.prm.bak |   74 -
 tests/box_end_time_1e7_terminate.prm.bak      |   67 -
 tests/box_first_time_step.prm.bak             |   58 -
 .../box_first_time_step_alternate_bc.prm.bak  |   64 -
 tests/box_initial_mesh_deformation.cc.bak     |   68 -
 tests/box_initial_mesh_deformation.prm.bak    |   81 -
 ...nitial_mesh_deformation_ascii_data.prm.bak |  102 -
 ...x_initial_mesh_deformation_periodic.cc.bak |   21 -
 ..._initial_mesh_deformation_periodic.prm.bak |   25 -
 .../box_initial_topography_ascii_data.prm.bak |   99 -
 ...topography_ascii_data_moved_origin.prm.bak |  101 -
 tests/box_initial_topography_function.prm.bak |   98 -
 ...box_initial_topography_prm_polygon.prm.bak |   91 -
 tests/box_lithostatic_pressure_2d.prm.bak     |  142 -
 tests/box_lithostatic_pressure_3d.prm.bak     |  140 -
 tests/box_origin.prm.bak                      |   68 -
 tests/box_repetitions.prm.bak                 |   65 -
 ...simple_log_viscosity_depth_average.prm.bak |  104 -
 ...imple_surface_strain_rate_residual.prm.bak |   99 -
 tests/box_steady_state_terminate.prm.bak      |   63 -
 .../box_steady_temperature_terminate.prm.bak  |   73 -
 tests/box_surface_base_variables.prm.bak      |  105 -
 tests/bunge_cookbook.prm.bak                  |   17 -
 tests/burnman_seismic_test.prm.bak            |  151 -
 tests/burnman_test.prm.bak                    |  128 -
 tests/burstedde.cc.bak                        |   21 -
 tests/burstedde.prm.bak                       |   94 -
 tests/burstedde_stokes_rhs.cc.bak             |  472 -
 tests/burstedde_stokes_rhs.prm.bak            |   99 -
 tests/cell_reference.cc.bak                   |   61 -
 tests/cell_reference.prm.bak                  |   68 -
 tests/cells_in_circumference.prm.bak          |   91 -
 ...check_compositional_field_functions.cc.bak |   71 -
 ...heck_compositional_field_functions.prm.bak |   13 -
 tests/check_compositional_field_names.cc.bak  |   76 -
 tests/check_compositional_field_names.prm.bak |   14 -
 tests/checkpoint_01.cc.bak                    |  100 -
 tests/checkpoint_01.prm.bak                   |   87 -
 tests/checkpoint_01_check_parameters.cc.bak   |  112 -
 tests/checkpoint_01_check_parameters.prm.bak  |   85 -
 tests/checkpoint_02.cc.bak                    |   97 -
 tests/checkpoint_02.prm.bak                   |   86 -
 tests/checkpoint_02_direct.cc.bak             |   97 -
 tests/checkpoint_02_direct.prm.bak            |   81 -
 tests/checkpoint_03_particles.cc.bak          |   98 -
 tests/checkpoint_03_particles.prm.bak         |   97 -
 .../checkpoint_04_particles_no_output.cc.bak  |   96 -
 .../checkpoint_04_particles_no_output.prm.bak |   97 -
 tests/checkpoint_05_mpi_create.prm.bak        |    5 -
 tests/checkpoint_05_mpi_resume.cc.bak         |   55 -
 tests/checkpoint_05_mpi_resume.prm.bak        |   12 -
 tests/checkpoint_06_spherical_shell.cc.bak    |   98 -
 tests/checkpoint_06_spherical_shell.prm.bak   |   66 -
 ...oint_07_enable_free_surface_create.prm.bak |   74 -
 ...point_07_enable_free_surface_resume.cc.bak |   55 -
 ...oint_07_enable_free_surface_resume.prm.bak |   31 -
 tests/chunk_ascii_initial_temperature.prm.bak |   75 -
 tests/chunk_conditions.prm.bak                |   77 -
 tests/chunk_cross_hemisphere.prm.bak          |   74 -
 tests/chunk_first_time_step_2d.prm.bak        |   74 -
 tests/chunk_first_time_step_3d.prm.bak        |   74 -
 ...hunk_initial_topography_ascii_data.prm.bak |   83 -
 ...k_initial_topography_ascii_data_3d.prm.bak |   88 -
 ...opography_ascii_data_3d_colatitude.prm.bak |   19 -
 tests/chunk_lithostatic_pressure_2d.prm.bak   |  132 -
 ...tic_pressure_2d_initial_topography.prm.bak |   46 -
 tests/chunk_tangential_velocity.prm.bak       |   92 -
 tests/chunk_topography_postprocessor.prm.bak  |  115 -
 tests/command_postprocessor.prm.bak           |   40 -
 tests/compaction_length_refinement.prm.bak    |  128 -
 tests/compaction_length_visualization.prm.bak |  123 -
 tests/composite_viscous_outputs.cc.bak        |  208 -
 tests/composite_viscous_outputs.prm.bak       |   80 -
 tests/compositing_02.prm.bak                  |  119 -
 tests/compositing_named_outputs.prm.bak       |   92 -
 tests/composition_active.prm.bak              |  107 -
 tests/composition_active_nans.prm.bak         |   21 -
 tests/composition_active_with_melt.cc.bak     |  158 -
 tests/composition_active_with_melt.prm.bak    |  106 -
 tests/composition_active_without_melt.cc.bak  |   21 -
 tests/composition_active_without_melt.prm.bak |  100 -
 tests/composition_cg_dg_fem.prm.bak           |   96 -
 tests/composition_names.prm.bak               |  117 -
 tests/composition_names_duplicates.prm.bak    |   95 -
 ...ion_passive_discontinuous_constant.prm.bak |   99 -
 tests/composition_passive_particles.prm.bak   |  111 -
 ...on_passive_quarter_shell_cartesian.prm.bak |  108 -
 ...sition_passive_quarter_shell_depth.prm.bak |  108 -
 ...on_passive_quarter_shell_spherical.prm.bak |  108 -
 tests/composition_passive_static.prm.bak      |   95 -
 tests/composition_reaction.prm.bak            |  110 -
 ...composition_reaction_iterated_IMPES.cc.bak |   91 -
 ...omposition_reaction_iterated_IMPES.prm.bak |  121 -
 tests/composition_stabilization.prm.bak       |  113 -
 tests/compositional_boundary_values.prm.bak   |  101 -
 .../compositional_boundary_values_02.prm.bak  |  102 -
 .../compositional_boundary_values_03.prm.bak  |  100 -
 tests/compositional_heating.prm.bak           |  166 -
 ...itional_heating_exclude_background.prm.bak |  113 -
 tests/compositional_vectors.prm.bak           |   60 -
 tests/compositional_vectors_3d.prm.bak        |   60 -
 tests/compressibility.cc.bak                  |  215 -
 tests/compressibility.prm.bak                 |  110 -
 tests/compressibility_iterated_stokes.cc.bak  |   89 -
 tests/compressibility_iterated_stokes.prm.bak |   99 -
 ...ility_iterated_stokes_direct_solver.cc.bak |   21 -
 ...lity_iterated_stokes_direct_solver.prm.bak |   86 -
 tests/compressibility_lateral_pipe.cc.bak     |   21 -
 tests/compressibility_lateral_pipe.prm.bak    |    5 -
 ...compressibility_lateral_pipe_advect.cc.bak |   21 -
 ...ompressibility_lateral_pipe_advect.prm.bak |    5 -
 ...teral_pipe_advect_projected_density.cc.bak |   21 -
 ...eral_pipe_advect_projected_density.prm.bak |    8 -
 ...lity_lateral_pipe_increase_pressure.cc.bak |   21 -
 ...ity_lateral_pipe_increase_pressure.prm.bak |    5 -
 ...increase_pressure_projected_density.cc.bak |   21 -
 ...ncrease_pressure_projected_density.prm.bak |    8 -
 ...lity_lateral_pipe_projected_density.cc.bak |   21 -
 ...ity_lateral_pipe_projected_density.prm.bak |    8 -
 ...pressibility_lateral_pipe_transient.cc.bak |   21 -
 ...ressibility_lateral_pipe_transient.prm.bak |    5 -
 ...al_pipe_transient_projected_density.cc.bak |   21 -
 ...l_pipe_transient_projected_density.prm.bak |    8 -
 tests/compressibility_vertical_pipe.cc.bak    |   21 -
 tests/compressibility_vertical_pipe.prm.bak   |    5 -
 ...ity_vertical_pipe_projected_density.cc.bak |   21 -
 ...ty_vertical_pipe_projected_density.prm.bak |    8 -
 ...pressibility_volumetric_strain_rate.cc.bak |   21 -
 ...ressibility_volumetric_strain_rate.prm.bak |   87 -
 tests/compressible_forsterite_box.prm.bak     |   87 -
 tests/compression_heating.cc.bak              |   69 -
 tests/compression_heating.prm.bak             |  141 -
 ...compute-no-normal-flux-constraints.prm.bak |  146 -
 tests/conservative_with_mpi.cc.bak            |   21 -
 tests/conservative_with_mpi.prm.bak           |   81 -
 ...t_boundary_flux_adjacent_dirichlet.prm.bak |   90 -
 .../consistent_boundary_flux_neumann.prm.bak  |   84 -
 ...istent_boundary_flux_open_boundary.prm.bak |   88 -
 .../constant_composition_convergence.prm.bak  |   77 -
 ...nt_temperature_boundary_conditions.prm.bak |   70 -
 tests/continental_extension.prm.bak           |   51 -
 tests/convection_box_particles.prm.bak        |    4 -
 tests/convection_box_phase_function.prm.bak   |  143 -
 ...cookbook_mantle_convection_annulus.prm.bak |   36 -
 tests/cookbook_simpler_with_crust.cc.bak      |  208 -
 tests/coordinate_transformation.cc.bak        |   94 -
 tests/coordinate_transformation.prm.bak       |   80 -
 ...an_parameterization_kinematic_slab.prm.bak |   59 -
 tests/cpo_simple_shearbox.prm.bak             |  154 -
 tests/crameri_benchmark_1_gmg.cc.bak          |   21 -
 tests/crameri_benchmark_1_gmg.prm.bak         |   52 -
 tests/crustal_model_3D.prm.bak                |  124 -
 tests/custom_spherical_shell_2d_list.prm.bak  |   82 -
 .../custom_spherical_shell_2d_slices.prm.bak  |   82 -
 tests/custom_spherical_shell_3d_list.prm.bak  |   82 -
 .../custom_spherical_shell_3d_slices.prm.bak  |   82 -
 .../damped_viscoelastic_bending_beam.prm.bak  |   49 -
 tests/darcy_velocity.cc.bak                   |   21 -
 tests/darcy_velocity.prm.bak                  |  145 -
 tests/darcy_velocity_vertical.cc.bak          |   21 -
 tests/darcy_velocity_vertical.prm.bak         |   37 -
 tests/dash_dash.cc.bak                        |   50 -
 tests/dash_dash.prm.bak                       |    8 -
 tests/dc_Picard_compressible.prm.bak          |  263 -
 tests/density_boundary.prm.bak                |   95 -
 tests/depth_average_01.prm.bak                |   90 -
 tests/depth_average_02.prm.bak                |   88 -
 tests/depth_average_03.prm.bak                |   93 -
 tests/depth_average_04.prm.bak                |   91 -
 tests/depth_average_05.prm.bak                |   91 -
 tests/depth_average_06.prm.bak                |   79 -
 tests/depth_average_rounding_bug.prm.bak      |   85 -
 tests/depth_average_txt_output.prm.bak        |   90 -
 tests/depth_average_underres.prm.bak          |   92 -
 ...pth_dependent_3d_shell_list_simple.prm.bak |   83 -
 ...depth_dependent_additional_outputs.prm.bak |   34 -
 tests/depth_dependent_box_file_simple.prm.bak |  159 -
 ...epth_dependent_box_function_simple.prm.bak |  161 -
 ...endent_box_function_time_dependent.prm.bak |  164 -
 tests/depth_dependent_box_none_simple.prm.bak |  157 -
 ...th_dependent_initialize_base_model.prm.bak |  133 -
 tests/depth_postprocessor_box.prm.bak         |   64 -
 tests/depth_postprocessor_chunk.prm.bak       |   70 -
 ...th_postprocessor_ellipsoidal_chunk.prm.bak |   78 -
 tests/depth_postprocessor_sphere.prm.bak      |   68 -
 ...epth_postprocessor_spherical_shell.prm.bak |   67 -
 ...pth_postprocessor_two_merged_boxes.prm.bak |   68 -
 ...rivative_of_weighted_p_norm_average.cc.bak |   41 -
 ...ivative_of_weighted_p_norm_average.prm.bak |    1 -
 tests/diffusion.prm.bak                       |  304 -
 tests/diffusion_dislocation.prm.bak           |  122 -
 ...sion_dislocation_fixed_strain_rate.prm.bak |   92 -
 ...ion_dislocation_fixed_strain_rate2.prm.bak |   88 -
 ...location_reference_density_profile.prm.bak |  124 -
 tests/diffusion_velocity.prm.bak              |  303 -
 tests/direct_solver_1.prm.bak                 |  152 -
 tests/direct_solver_2.prm.bak                 |  150 -
 tests/discontinuous_composition_1.prm.bak     |   95 -
 ...mposition_bound_preserving_limiter.prm.bak |  100 -
 ...sition_bound_preserving_limiter_3d.prm.bak |  101 -
 ...preserving_limiter_selected_fields.prm.bak |   88 -
 ...us_composition_serial_periodic_amr.prm.bak |   80 -
 tests/discontinuous_temperature.prm.bak       |   95 -
 ...scontinuous_temperature_blankenbach.cc.bak |   21 -
 ...continuous_temperature_blankenbach.prm.bak |  119 -
 ...ous_temperature_spherical_shell_3d.prm.bak |   94 -
 tests/doneahuerta_3.cc.bak                    |   21 -
 tests/doneahuerta_3.prm.bak                   |   88 -
 tests/drucker_prager_compression.prm.bak      |  124 -
 tests/drucker_prager_derivatives_2d.cc.bak    |  247 -
 tests/drucker_prager_derivatives_2d.prm.bak   |  108 -
 tests/drucker_prager_derivatives_3d.cc.bak    |  262 -
 tests/drucker_prager_derivatives_3d.prm.bak   |  108 -
 tests/drucker_prager_extension.prm.bak        |  124 -
 tests/dynamic_core.prm.bak                    |  101 -
 tests/dynamic_friction.prm.bak                |  141 -
 tests/dynamic_topography.prm.bak              |  101 -
 tests/dynamic_topography2.prm.bak             |  102 -
 tests/dynamic_topography3.prm.bak             |   79 -
 tests/dynamic_topography_back.prm.bak         |  101 -
 ...aphy_vs_surface_dynamic_topography.prm.bak |  103 -
 tests/edit_parameters.cc.bak                  |   98 -
 tests/edit_parameters.prm.bak                 |   72 -
 ...ic_stabilization_time_scale_factor.prm.bak |   38 -
 ...ipsoidal_chunk_coordinate_parallel.prm.bak |   86 -
 tests/ellipsoidal_chunk_geometry.cc.bak       |  121 -
 tests/ellipsoidal_chunk_geometry.prm.bak      |   78 -
 ...oidal_chunk_noncoordinate_parallel.prm.bak |   87 -
 tests/ellipsoidal_chunk_topography.prm.bak    |   93 -
 tests/entropy_adiabat.cc.bak                  |   21 -
 tests/entropy_adiabat.prm.bak                 |   13 -
 tests/entropy_conduction.cc.bak               |   21 -
 tests/entropy_conduction.prm.bak              |    7 -
 tests/entropy_half_space.cc.bak               |   21 -
 tests/entropy_half_space.prm.bak              |   13 -
 tests/entropy_initial_lookup.cc.bak           |   21 -
 tests/entropy_initial_lookup.prm.bak          |  136 -
 tests/entropy_initial_lookup_wb.cc.bak        |   21 -
 tests/entropy_initial_lookup_wb.prm.bak       |  141 -
 tests/entropy_plasticity.cc.bak               |   21 -
 tests/entropy_plasticity.prm.bak              |  152 -
 tests/entropy_read_multi_table.cc.bak         |   21 -
 tests/entropy_read_multi_table.prm.bak        |  116 -
 tests/entropy_viscosity_statistics.prm.bak    |   11 -
 tests/exponential_decay.cc.bak                |   21 -
 tests/exponential_decay.prm.bak               |  124 -
 tests/fail.prm.bak                            |    5 -
 tests/find_boundary_composition_model.cc.bak  |   88 -
 tests/find_boundary_composition_model.prm.bak |   75 -
 ...d_boundary_composition_model_fail_1.cc.bak |   61 -
 ..._boundary_composition_model_fail_1.prm.bak |   81 -
 tests/find_mesh_refinement.cc.bak             |   88 -
 tests/find_mesh_refinement.prm.bak            |   61 -
 tests/find_mesh_refinement_fail_1.cc.bak      |   60 -
 tests/find_mesh_refinement_fail_1.prm.bak     |   65 -
 tests/find_postprocess.cc.bak                 |   88 -
 tests/find_postprocess.prm.bak                |   58 -
 tests/find_postprocess_fail_1.cc.bak          |   61 -
 tests/find_postprocess_fail_1.prm.bak         |   64 -
 ...er_2D_loading_fixed_elastic_dt_gmg.prm.bak |   33 -
 tests/free_surface_adaptive_blob.prm.bak      |  115 -
 tests/free_surface_blob.prm.bak               |  114 -
 tests/free_surface_blob_gmg.prm.bak           |   17 -
 tests/free_surface_blob_melt.cc.bak           |  326 -
 tests/free_surface_blob_melt.prm.bak          |  135 -
 tests/free_surface_blob_nonzero_melt.cc.bak   |   21 -
 tests/free_surface_blob_nonzero_melt.prm.bak  |  153 -
 tests/free_surface_iterated_IMPES.prm.bak     |  121 -
 tests/free_surface_iterated_stokes.prm.bak    |  120 -
 .../free_surface_iterated_stokes_gmg.prm.bak  |   21 -
 tests/free_surface_relaxation.cc.bak          |  178 -
 tests/free_surface_relaxation.prm.bak         |  121 -
 ...e_surface_tangential_mesh_velocity.prm.bak |   86 -
 ...surface_tangential_mesh_velocity_2.prm.bak |   83 -
 tests/free_surface_timestep_repeat.prm.bak    |  176 -
 ...formation_tangential_mesh_velocity.prm.bak |   86 -
 tests/gaussian_initial_temperature.prm.bak    |   81 -
 tests/geoid.prm.bak                           |  101 -
 tests/geoid_freesurface.prm.bak               |  116 -
 tests/geoid_no_topo.prm.bak                   |   89 -
 tests/geoid_visualization.prm.bak             |  104 -
 tests/geometric_average_crash.prm.bak         |   59 -
 .../geometric_average_only_viscosity.prm.bak  |   80 -
 tests/global_latent_heat.prm.bak              |  159 -
 tests/global_melt.prm.bak                     |  216 -
 tests/global_melt_parallel.prm.bak            |  214 -
 tests/global_refine_amr.cc.bak                |  105 -
 tests/global_refine_amr.prm.bak               |   59 -
 tests/global_refine_bug.prm.bak               |   74 -
 tests/gmg_mesh_deform.prm.bak                 |   18 -
 tests/gmg_mesh_deform_adaptive.prm.bak        |   21 -
 tests/gmg_mesh_deform_adaptive_bug.prm.bak    |   25 -
 tests/gmg_mesh_deform_adaptive_bug2.prm.bak   |  139 -
 tests/gmg_mesh_deform_function.prm.bak        |   17 -
 tests/gmg_mesh_deform_ghost_entries.prm.bak   |   38 -
 tests/gmg_mesh_deform_prescribed.cc.bak       |   21 -
 tests/gmg_mesh_deform_prescribed.prm.bak      |   17 -
 tests/gmg_mesh_deform_topo.prm.bak            |  109 -
 tests/gmg_no_normal_flux_only.prm.bak         |   87 -
 tests/gmg_test_project_q1.prm.bak             |  102 -
 ...g_velocity_boundary_2d_box_no_flux.prm.bak |  100 -
 ...ity_boundary_2d_box_no_normal_flux.prm.bak |   99 -
 ...velocity_boundary_2d_chunk_no_flux.prm.bak |  103 -
 ...y_boundary_2d_chunk_no_normal_flux.prm.bak |  102 -
 ...g_velocity_boundary_3d_box_no_flux.prm.bak |  103 -
 ...ity_boundary_3d_box_no_normal_flux.prm.bak |  102 -
 ...velocity_boundary_3d_chunk_no_flux.prm.bak |  106 -
 ...y_boundary_3d_chunk_no_normal_flux.prm.bak |  105 -
 tests/gmg_velocity_boundary_component.prm.bak |   20 -
 tests/gplates_1_3.prm.bak                     |   78 -
 tests/gplates_1_4.prm.bak                     |   81 -
 tests/gplates_3d.prm.bak                      |   77 -
 tests/gplates_rotation.prm.bak                |   77 -
 tests/gplates_scale_factor.prm.bak            |   84 -
 tests/grain_lag_angle.prm.bak                 |  102 -
 tests/grain_size_additional_outputs.prm.bak   |   24 -
 tests/grain_size_averaging.prm.bak            |   16 -
 tests/grain_size_crossed_transition.prm.bak   |  172 -
 tests/grain_size_friction_heating.prm.bak     |  131 -
 tests/grain_size_growth.prm.bak               |  159 -
 tests/grain_size_growth_one_cell.prm.bak      |  144 -
 ...ain_size_growth_one_cell_particles.prm.bak |   43 -
 tests/grain_size_growth_particles.prm.bak     |   49 -
 tests/grain_size_growth_pinned.prm.bak        |   34 -
 tests/grain_size_latent_heat.cc.bak           |  237 -
 tests/grain_size_latent_heat.prm.bak          |  131 -
 tests/grain_size_phase_function.prm.bak       |  149 -
 tests/grain_size_plunge.prm.bak               |   10 -
 tests/grain_size_ridge.prm.bak                |   23 -
 tests/grain_size_ridge_traction.prm.bak       |  112 -
 tests/grain_size_strain.prm.bak               |  130 -
 tests/grain_size_strain_pinned.prm.bak        |   77 -
 tests/grain_size_strain_pinned_state.prm.bak  |   58 -
 tests/grain_size_yield.prm.bak                |   55 -
 tests/graphical_output.cc.bak                 |   21 -
 tests/graphical_output.prm.bak                |   74 -
 tests/graphical_output_02.prm.bak             |   76 -
 tests/graphical_output_hdf5.cc.bak            |   21 -
 tests/graphical_output_hdf5.prm.bak           |   78 -
 tests/gravity_function.prm.bak                |   71 -
 tests/gravity_function_time.prm.bak           |   72 -
 tests/gravity_model_cartesian.prm.bak         |   99 -
 tests/gravity_model_depth.prm.bak             |   89 -
 tests/gravity_model_spherical.prm.bak         |   99 -
 tests/gravity_point_values_list.prm.bak       |   69 -
 tests/gravity_point_values_map.prm.bak        |   69 -
 tests/gravity_point_values_spiral.prm.bak     |   68 -
 ...avity_point_values_spiral_parallel.prm.bak |    9 -
 tests/gravity_prem.prm.bak                    |   72 -
 ...gravity_quadrature_degree_increase.prm.bak |   70 -
 tests/gs_drucker_prager.prm.bak               |  131 -
 tests/gs_drucker_prager_extension.prm.bak     |   93 -
 ...drucker_prager_extension_adiabatic.prm.bak |   92 -
 tests/heat_advection_by_melt.cc.bak           |  127 -
 tests/heat_advection_by_melt.prm.bak          |  143 -
 ...dvection_by_melt_operator_splitting.cc.bak |   21 -
 ...vection_by_melt_operator_splitting.prm.bak |  134 -
 tests/heat_flow.prm.bak                       |    4 -
 tests/heat_flow_plume.prm.bak                 |    4 -
 tests/heat_flux_densities.prm.bak             |  110 -
 tests/heat_flux_map.prm.bak                   |   72 -
 tests/heat_flux_map_vis.prm.bak               |   79 -
 tests/heat_flux_map_vis_point_wise.prm.bak    |   20 -
 tests/heating_function.prm.bak                |   67 -
 tests/heating_function_depth.prm.bak          |   16 -
 tests/heating_function_spherical.prm.bak      |   17 -
 tests/hexagonal_initial_temperature.prm.bak   |   84 -
 tests/hill_diffusion.prm.bak                  |  115 -
 tests/hill_diffusion_3D.prm.bak               |  116 -
 ...vine_composite_hydration_prefactor.prm.bak |  144 -
 ...mposite_hydration_prefactor_cutoff.prm.bak |   23 -
 ...vine_diffusion_hydration_prefactor.prm.bak |  131 -
 ...ne_dislocation_hydration_prefactor.prm.bak |  128 -
 tests/hollow_sphere.cc.bak                    |   21 -
 tests/hollow_sphere.prm.bak                   |   99 -
 tests/hollow_sphere_gmg.cc.bak                |   21 -
 tests/hollow_sphere_gmg.prm.bak               |  101 -
 tests/hollow_sphere_gmg_project_q1.cc.bak     |   21 -
 tests/hollow_sphere_gmg_project_q1.prm.bak    |   29 -
 tests/hollow_sphere_gmg_q3.cc.bak             |   21 -
 tests/hollow_sphere_gmg_q3.prm.bak            |  105 -
 tests/hydrostatic_compression.cc.bak          |  313 -
 tests/hydrostatic_compression.prm.bak         |  113 -
 tests/inclusion_2.cc.bak                      |   21 -
 tests/inclusion_2.prm.bak                     |   86 -
 tests/inclusion_4.cc.bak                      |   21 -
 tests/inclusion_4.prm.bak                     |   86 -
 tests/inclusion_adaptive.cc.bak               |   21 -
 tests/inclusion_adaptive.prm.bak              |   89 -
 tests/infill_density_flexure.cc.bak           |   21 -
 tests/infill_density_flexure.prm.bak          |   10 -
 tests/initial_composition_list.prm.bak        |   81 -
 ...ial_composition_list_using_maximum.prm.bak |   82 -
 ...ial_composition_list_using_minimum.prm.bak |   82 -
 ...al_composition_list_using_subtract.prm.bak |   82 -
 tests/initial_condition_S20RTS.prm.bak        |   70 -
 tests/initial_condition_S20RTS_2D.prm.bak     |   10 -
 tests/initial_condition_S20RTS_dgp.prm.bak    |   75 -
 tests/initial_condition_S40RTS.prm.bak        |   71 -
 tests/initial_condition_SAVANI.prm.bak        |   74 -
 ...initial_condition_lithosphere_mask.prm.bak |   62 -
 .../initial_condition_patch_on_S40RTS.prm.bak |   62 -
 tests/initial_condition_vs_to_density.prm.bak |   77 -
 ...ial_condition_vs_to_density_SAVANI.prm.bak |   77 -
 tests/initial_global_refinement.prm.bak       |   88 -
 tests/initial_porosity.prm.bak                |  216 -
 tests/initial_temperature_list.prm.bak        |   63 -
 ...ial_temperature_list_using_maximum.prm.bak |   64 -
 ...ial_temperature_list_using_minimum.prm.bak |   64 -
 ...al_temperature_list_using_subtract.prm.bak |   64 -
 tests/initial_temperature_profile.prm.bak     |   69 -
 tests/inner_core.cc.bak                       |   21 -
 tests/inner_core.prm.bak                      |  142 -
 tests/internal_heating_statistics.prm.bak     |  100 -
 ...erpolor_particles_harmonic_average.prm.bak |   21 -
 ...erpolor_particles_nearest_neighbor.prm.bak |    8 -
 ..._particles_quadratic_least_squares.prm.bak |    8 -
 tests/isosurfaces_simple_box_2D.prm.bak       |   96 -
 ...es_simple_box_2D_custom_fieldnames.prm.bak |   21 -
 ...mple_box_2D_custom_fieldnames_fail.prm.bak |   21 -
 ...sosurfaces_simple_box_2D_min_max_1.prm.bak |   14 -
 ...sosurfaces_simple_box_2D_min_max_2.prm.bak |   14 -
 tests/isosurfaces_simple_box_3D.prm.bak       |   56 -
 tests/isosurfaces_slab_2D.prm.bak             |  102 -
 tests/isosurfaces_slab_3D.prm.bak             |   67 -
 ...ction_and_defect_correction_Stokes.prm.bak |  127 -
 tests/iterated_advection_and_stokes.prm.bak   |  127 -
 .../iterated_advection_and_stokes_DG.prm.bak  |  128 -
 ...ed_advection_and_stokes_DG_limiter.prm.bak |  135 -
 ...advection_and_stokes_direct_solver.prm.bak |  130 -
 ...ated_advection_and_stokes_residual.prm.bak |  127 -
 .../kaus_rayleigh_taylor_instability.prm.bak  |   41 -
 ...tically_driven_subduction_2d_case1.prm.bak |  177 -
 ...tically_driven_subduction_2d_case2a.cc.bak |    4 -
 ...ically_driven_subduction_2d_case2a.prm.bak |  176 -
 ...tically_driven_subduction_2d_case2b.cc.bak |    4 -
 ...ically_driven_subduction_2d_case2b.prm.bak |  195 -
 tests/king_ala.cc.bak                         |   22 -
 tests/king_ala.prm.bak                        |   11 -
 tests/king_ala_nondim.prm.bak                 |  163 -
 tests/latent_heat.prm.bak                     |  132 -
 tests/latent_heat_composition.prm.bak         |  164 -
 tests/latent_heat_enthalpy.cc.bak             |  188 -
 tests/latent_heat_enthalpy.prm.bak            |  115 -
 tests/latent_heat_melt.prm.bak                |  145 -
 tests/latent_heat_melt_operator_split.prm.bak |  172 -
 tests/latent_heat_melt_statistics.prm.bak     |  127 -
 tests/latent_heat_melt_transport.prm.bak      |  162 -
 tests/latent_heat_pressure.prm.bak            |  126 -
 tests/latent_heat_viscosity.prm.bak           |  113 -
 tests/latent_heat_viscosity_adiabatic.prm.bak |  102 -
 tests/lithosphere_boundary_indicator.prm.bak  |  130 -
 .../lithosphere_boundary_indicator_3d.prm.bak |  133 -
 ...ere_boundary_indicator_3d_one_grid.prm.bak |   13 -
 ...ere_boundary_indicator_3d_periodic.prm.bak |  152 -
 ...sphere_boundary_indicator_one_grid.prm.bak |   13 -
 ...hosphere_boundary_indicator_origin.prm.bak |   15 -
 tests/logo.prm.bak                            |   14 -
 tests/magnetic_stripes.cc.bak                 |   21 -
 tests/magnetic_stripes.prm.bak                |    8 -
 tests/mass_flux_statistics.prm.bak            |   44 -
 tests/mass_reaction_term.prm.bak              |  173 -
 tests/material_model_dependencies.cc.bak      |  132 -
 ...terial_model_dependencies_burstedde.cc.bak |   22 -
 ...erial_model_dependencies_burstedde.prm.bak |   86 -
 ...l_dependencies_composition_reaction.cc.bak |   21 -
 ..._dependencies_composition_reaction.prm.bak |   67 -
 ...es_cookbooks_freesurface_with_crust.cc.bak |   22 -
 ...s_cookbooks_freesurface_with_crust.prm.bak |   67 -
 ..._dependencies_diffusion_dislocation.cc.bak |   21 -
 ...dependencies_diffusion_dislocation.prm.bak |   73 -
 ...rial_model_dependencies_inclusion_2.cc.bak |   22 -
 ...ial_model_dependencies_inclusion_2.prm.bak |   67 -
 ...rial_model_dependencies_latent_heat.cc.bak |   21 -
 ...ial_model_dependencies_latent_heat.prm.bak |  104 -
 ...model_dependencies_latent_heat_melt.cc.bak |   21 -
 ...odel_dependencies_latent_heat_melt.prm.bak |   67 -
 ...ial_model_dependencies_morency_doin.cc.bak |   23 -
 ...al_model_dependencies_morency_doin.prm.bak |   67 -
 ...l_model_dependencies_multicomponent.cc.bak |   21 -
 ..._model_dependencies_multicomponent.prm.bak |   67 -
 ...l_model_dependencies_shear_thinning.cc.bak |   22 -
 ..._model_dependencies_shear_thinning.prm.bak |   76 -
 .../material_model_dependencies_simple.cc.bak |   21 -
 ...material_model_dependencies_simple.prm.bak |   67 -
 ...el_dependencies_simple_compressible.cc.bak |   21 -
 ...l_dependencies_simple_compressible.prm.bak |   67 -
 ...material_model_dependencies_simpler.cc.bak |   21 -
 ...aterial_model_dependencies_simpler.prm.bak |   67 -
 .../material_model_dependencies_solcx.cc.bak  |   22 -
 .../material_model_dependencies_solcx.prm.bak |   67 -
 .../material_model_dependencies_solkz.cc.bak  |   22 -
 .../material_model_dependencies_solkz.prm.bak |   67 -
 ...rial_model_dependencies_steinberger.cc.bak |   21 -
 ...ial_model_dependencies_steinberger.prm.bak |   85 -
 ...terial_model_dependencies_tangurnis.cc.bak |   22 -
 ...erial_model_dependencies_tangurnis.prm.bak |   86 -
 tests/material_statistics.prm.bak             |   80 -
 tests/matrix_nonzeros_1.prm.bak               |   85 -
 tests/matrix_nonzeros_2.prm.bak               |  100 -
 tests/matrix_nonzeros_3.prm.bak               |  106 -
 tests/matrix_nonzeros_4.prm.bak               |  114 -
 tests/matrix_nonzeros_5.prm.bak               |  110 -
 tests/matrix_nonzeros_6.prm.bak               |  111 -
 tests/matrix_nonzeros_7.prm.bak               |  117 -
 tests/max_timesteps_btwn_output.prm.bak       |  168 -
 ...zontal_compressive_stress_case_one.prm.bak |  108 -
 ...zontal_compressive_stress_case_two.prm.bak |  110 -
 tests/maximum_refinement_function.prm.bak     |  154 -
 ...imum_refinement_function_cartesian.prm.bak |  144 -
 ...imum_refinement_function_spherical.prm.bak |  136 -
 tests/maxtimestep.prm.bak                     |   64 -
 tests/melt_and_traction.prm.bak               |  276 -
 tests/melt_boukare_EOS.prm.bak                |  157 -
 tests/melt_boukare_averaging.prm.bak          |  157 -
 tests/melt_boundary_heat_flux.cc.bak          |   21 -
 tests/melt_boundary_heat_flux.prm.bak         |  127 -
 tests/melt_compressible_advection.cc.bak      |  213 -
 tests/melt_compressible_advection.prm.bak     |  132 -
 tests/melt_force_vector.cc.bak                |  338 -
 tests/melt_force_vector.prm.bak               |  160 -
 tests/melt_fraction_postprocessor.prm.bak     |  126 -
 tests/melt_introspection.cc.bak               |  138 -
 tests/melt_introspection.prm.bak              |   95 -
 tests/melt_material_1.cc.bak                  |  102 -
 tests/melt_material_1.prm.bak                 |  109 -
 tests/melt_material_2.cc.bak                  |  129 -
 tests/melt_material_2.prm.bak                 |  132 -
 tests/melt_material_3.cc.bak                  |  129 -
 tests/melt_material_3.prm.bak                 |  132 -
 tests/melt_material_4.cc.bak                  |  240 -
 tests/melt_material_4.prm.bak                 |  143 -
 tests/melt_postprocessor_peridotite.prm.bak   |  121 -
 tests/melt_postprocessor_pyroxenite.prm.bak   |  140 -
 tests/melt_property_visualization.cc.bak      |   21 -
 tests/melt_property_visualization.prm.bak     |  139 -
 tests/melt_restart.cc.bak                     |   96 -
 tests/melt_restart.prm.bak                    |  223 -
 tests/melt_statistics.prm.bak                 |  141 -
 tests/melt_track.cc.bak                       |   21 -
 tests/melt_track.prm.bak                      |  189 -
 tests/melt_transport.prm.bak                  |  151 -
 tests/melt_transport_adaptive.cc.bak          |  518 --
 tests/melt_transport_adaptive.prm.bak         |  135 -
 tests/melt_transport_compressible.cc.bak      |  370 -
 tests/melt_transport_compressible.prm.bak     |  142 -
 ...lt_transport_compressible_iterative.cc.bak |   21 -
 ...t_transport_compressible_iterative.prm.bak |  135 -
 .../melt_transport_convergence_simple.cc.bak  |  326 -
 .../melt_transport_convergence_simple.prm.bak |  135 -
 tests/melt_transport_convergence_test.cc.bak  |  330 -
 tests/melt_transport_convergence_test.prm.bak |  136 -
 .../melt_velocity_boundary_conditions.cc.bak  |   21 -
 .../melt_velocity_boundary_conditions.prm.bak |  154 -
 tests/melt_visco_plastic.cc.bak               | 1038 ---
 ...isco_plastic_mohr_circle_compaction.cc.bak |   21 -
 ...sco_plastic_mohr_circle_compaction.prm.bak |  163 -
 ...elt_visco_plastic_mohr_circle_shear.cc.bak |   21 -
 ...lt_visco_plastic_mohr_circle_shear.prm.bak |  162 -
 tests/melting_rate.cc.bak                     |  126 -
 tests/melting_rate.prm.bak                    |  138 -
 tests/melting_rate_operator_splitting.prm.bak |  154 -
 .../melting_rate_operator_splitting2.prm.bak  |  144 -
 tests/melting_rate_test.prm.bak               |  156 -
 tests/memory_statistics_1.prm.bak             |   69 -
 tests/merged_chunks_2D.prm.bak                |  132 -
 tests/merged_chunks_2D_one_grid.prm.bak       |   13 -
 tests/merged_chunks_3D.prm.bak                |  140 -
 tests/merged_chunks_3D_one_grid.prm.bak       |   13 -
 ...deformation_gmg_2d_spherical_shell.prm.bak |   96 -
 tests/mesh_deformation_particles.cc.bak       |   71 -
 tests/mesh_deformation_particles.prm.bak      |   85 -
 tests/mesh_velocity_output.prm.bak            |  121 -
 tests/mid_ocean_ridge.prm.bak                 |   26 -
 tests/minimum_refinement_function.prm.bak     |  154 -
 ...imum_refinement_function_cartesian.prm.bak |  144 -
 ...imum_refinement_function_spherical.prm.bak |  136 -
 ...refinement_function_time_dependent.prm.bak |  154 -
 tests/modified_tait_forsterite_box.prm.bak    |  101 -
 tests/morency_doin.cc.bak                     |   22 -
 tests/morency_doin.prm.bak                    |  100 -
 tests/multicomponent_arithmetic.prm.bak       |  128 -
 ...ticomponent_compressible_averaging.prm.bak |  129 -
 tests/multicomponent_geometric.prm.bak        |  128 -
 tests/multicomponent_harmonic.prm.bak         |  128 -
 tests/multicomponent_max_composition.prm.bak  |  128 -
 tests/multicomponent_steinberger.prm.bak      |  121 -
 .../multiple_named_additional_outputs.cc.bak  |  112 -
 .../multiple_named_additional_outputs.prm.bak |   99 -
 tests/muparser-temperature-example.prm.bak    |  149 -
 tests/n_expensive_stokes_solver_steps.prm.bak |  160 -
 tests/natural_coordinates_conversion.cc.bak   |  217 -
 tests/natural_coordinates_conversion.prm.bak  |    1 -
 tests/netcdf_boundary_velocity_2d_box.prm.bak |   71 -
 tests/newton_postprocess_nonlinear.prm.bak    |  175 -
 ..._iterated_defect_correction_Stokes.prm.bak |  127 -
 tests/no_adiabatic_heating.cc.bak             |   57 -
 tests/no_adiabatic_heating.prm.bak            |   82 -
 tests/no_adiabatic_heating_02.cc.bak          |   65 -
 tests/no_adiabatic_heating_02.prm.bak         |   82 -
 tests/no_adiabatic_heating_03.cc.bak          |   57 -
 tests/no_adiabatic_heating_03.prm.bak         |  115 -
 tests/no_cheap_gmg.cc.bak                     |   21 -
 tests/no_cheap_gmg.prm.bak                    |   83 -
 tests/no_conduction_timestep.prm.bak          |   80 -
 tests/no_dirichlet_on_outflow.prm.bak         |  168 -
 tests/no_dirichlet_on_outflow_C.prm.bak       |  172 -
 .../no_dirichlet_on_outflow_adaptive.prm.bak  |  172 -
 tests/no_dirichlet_on_outflow_melt.cc.bak     |   21 -
 tests/no_dirichlet_on_outflow_melt.prm.bak    |  144 -
 ...et_on_outflow_only_new_constraints.prm.bak |  168 -
 tests/no_dirichlet_on_outflow_refine.prm.bak  |  123 -
 tests/no_flow.prm.bak                         |   85 -
 tests/non_conservative_with_mpi.cc.bak        |   21 -
 tests/non_conservative_with_mpi.prm.bak       |   79 -
 ...hannel_flow_tractions_Newton_Stokes.cc.bak |   21 -
 ...annel_flow_tractions_Newton_Stokes.prm.bak |  131 -
 ...el_flow_tractions_Newton_Stokes_GMG.cc.bak |   21 -
 ...l_flow_tractions_Newton_Stokes_GMG.prm.bak |   17 -
 ...tractions_Newton_Stokes_no_deviator.cc.bak |   21 -
 ...ractions_Newton_Stokes_no_deviator.prm.bak |  132 -
 ...ctions_Newton_Stokes_no_line_search.cc.bak |   21 -
 ...tions_Newton_Stokes_no_line_search.prm.bak |    8 -
 ...w_tractions_Newton_Stokes_particles.cc.bak |   21 -
 ..._tractions_Newton_Stokes_particles.prm.bak |   38 -
 ...flow_tractions_dc_picard_Stokes_GMG.cc.bak |    1 -
 ...low_tractions_dc_picard_Stokes_GMG.prm.bak |   17 -
 ...annel_flow_tractions_iterated_IMPES.cc.bak |   21 -
 ...nnel_flow_tractions_iterated_IMPES.prm.bak |  129 -
 ...annel_flow_velocities_Newton_Stokes.cc.bak |   21 -
 ...nnel_flow_velocities_Newton_Stokes.prm.bak |  134 -
 ...l_flow_velocities_Newton_Stokes_GMG.cc.bak |   21 -
 ..._flow_velocities_Newton_Stokes_GMG.prm.bak |   23 -
 ...ocities_Newton_Stokes_no_derivative.cc.bak |   21 -
 ...cities_Newton_Stokes_no_derivative.prm.bak |   21 -
 ...ties_Newton_Stokes_no_derivative_EW.cc.bak |   21 -
 ...ies_Newton_Stokes_no_derivative_EW.prm.bak |   21 -
 ...elocities_Newton_Stokes_no_deviator.cc.bak |   21 -
 ...locities_Newton_Stokes_no_deviator.prm.bak |   17 -
 ...cities_Newton_Stokes_no_line_search.cc.bak |   21 -
 ...ities_Newton_Stokes_no_line_search.prm.bak |    8 -
 ...nnel_flow_velocities_iterated_IMPES.cc.bak |   21 -
 ...nel_flow_velocities_iterated_IMPES.prm.bak |  128 -
 ...ties_single_advection_Newton_Stokes.cc.bak |   21 -
 ...ies_single_advection_Newton_Stokes.prm.bak |    9 -
 ...r_convergence_for_small_composition.cc.bak |   71 -
 ..._convergence_for_small_composition.prm.bak |  162 -
 tests/nonlinear_solver_history.cc.bak         |   46 -
 tests/nonlinear_solver_history.prm.bak        |   69 -
 tests/normalize_initial_composition.prm.bak   |   62 -
 tests/normalize_pressure_volume.prm.bak       |   70 -
 tests/nsinker.cc.bak                          |   21 -
 tests/nsinker.prm.bak                         |    9 -
 tests/nsinker_2d.cc.bak                       |   21 -
 tests/nsinker_2d.prm.bak                      |    8 -
 tests/nsinker_bfbt.cc.bak                     |   21 -
 tests/nsinker_bfbt.prm.bak                    |    9 -
 tests/nsinker_gmg_idr.cc.bak                  |   21 -
 tests/nsinker_gmg_idr.prm.bak                 |   24 -
 tests/octagonal_initial_temperature.prm.bak   |   90 -
 ...tial_temperature_ellipsoidal_chunk.prm.bak |   94 -
 ...agonal_initial_temperature_rotated.prm.bak |   91 -
 tests/onset_of_convection.prm.bak             |    4 -
 tests/original_prm.prm.bak                    |   10 -
 tests/original_prm/original.prm.bak           |   13 -
 tests/output_averaging_arithmetic.cc.bak      |   21 -
 tests/output_averaging_arithmetic.prm.bak     |   82 -
 tests/output_averaging_harmonic.cc.bak        |   21 -
 tests/output_averaging_harmonic.prm.bak       |   82 -
 tests/own_gravity.cc.bak                      |   44 -
 tests/own_gravity.prm.bak                     |   77 -
 tests/parallel_output_group_0.prm.bak         |   76 -
 tests/parallel_output_group_1.prm.bak         |   76 -
 tests/parallel_output_group_2.prm.bak         |   76 -
 tests/parallel_refine_crash.prm.bak           |  112 -
 tests/particle_count_statistics.cc.bak        |   21 -
 tests/particle_count_statistics.prm.bak       |   91 -
 tests/particle_exclude_all_properties.prm.bak |  117 -
 tests/particle_exclude_one_property.prm.bak   |  117 -
 .../particle_exclude_one_property_vtu.prm.bak |  117 -
 ...ticle_exclude_three_properties_vtu.prm.bak |  117 -
 ...article_exclude_two_properties_vtu.prm.bak |  117 -
 ...le_fast_evaluate_many_compositions.prm.bak |  116 -
 ...ast_evaluate_multiple_compositions.prm.bak |  116 -
 tests/particle_free_surface.prm.bak           |  114 -
 tests/particle_generator_ascii.prm.bak        |  108 -
 tests/particle_generator_box.prm.bak          |  113 -
 tests/particle_generator_box_3d.prm.bak       |  118 -
 ...rticle_generator_quadrature_points.prm.bak |  108 -
 tests/particle_generator_radial.prm.bak       |  116 -
 .../particle_generator_random_uniform.prm.bak |  109 -
 ...ator_random_uniform_3mpi_1particle.prm.bak |  109 -
 ...ator_random_uniform_3mpi_2particle.prm.bak |  109 -
 ...ator_random_uniform_3mpi_3particle.prm.bak |  109 -
 ...ator_random_uniform_3mpi_4particle.prm.bak |  109 -
 ..._random_uniform_deterministic_cell.prm.bak |  110 -
 ...enerator_random_uniform_empty_rank.prm.bak |  109 -
 .../particle_generator_reference_cell.prm.bak |  111 -
 tests/particle_handler_copy.cc.bak            |   83 -
 tests/particle_handler_copy.prm.bak           |   96 -
 .../particle_initial_adaptive_output.prm.bak  |  107 -
 ...rticle_initial_adaptive_refinement.prm.bak |  107 -
 tests/particle_integrator_euler.prm.bak       |  109 -
 ...le_integrator_rk2_first_order_time.prm.bak |   26 -
 tests/particle_integrator_rk4.prm.bak         |  109 -
 .../particle_interpolator_bilinear_3d.prm.bak |  118 -
 ...rpolator_bilinear_3d_add_particles.prm.bak |  113 -
 ...interpolator_bilinear_add_particles.cc.bak |   21 -
 ...nterpolator_bilinear_add_particles.prm.bak |  118 -
 ...olator_bilinear_least_squares_solkz.cc.bak |   21 -
 ...lator_bilinear_least_squares_solkz.prm.bak |  115 -
 ...icle_interpolator_bilinear_limiter.prm.bak |  120 -
 ...particle_interpolator_cell_average.prm.bak |  125 -
 ...rticle_interpolator_cell_average_2.prm.bak |  119 -
 .../particle_interpolator_empty_cells.prm.bak |  100 -
 ...icle_interpolator_from_ghost_cells.prm.bak |  102 -
 ...interpolator_harmonic_average_solkz.cc.bak |   21 -
 ...nterpolator_harmonic_average_solkz.prm.bak |  119 -
 ...icle_interpolator_nearest_neighbor.prm.bak |  127 -
 ...atic_least_squares_2d_add_particles.cc.bak |   21 -
 ...tic_least_squares_2d_add_particles.prm.bak |  120 -
 ..._quadratic_least_squares_2d_limiter.cc.bak |   21 -
 ...quadratic_least_squares_2d_limiter.prm.bak |   28 -
 ...uadratic_least_squares_2d_periodic.prm.bak |   41 -
 ...polator_quadratic_least_squares_3d.prm.bak |  119 -
 ...ticle_interpolator_time_dependence.prm.bak |  109 -
 ...rticle_linear_accelerated_flow_rk2.prm.bak |   86 -
 tests/particle_load_balancing_none.prm.bak    |  106 -
 ...particle_load_balancing_refinement.prm.bak |  105 -
 ...ticle_load_balancing_refinement_02.prm.bak |  105 -
 tests/particle_load_balancing_removal.prm.bak |  103 -
 ...le_load_balancing_removal_addition.prm.bak |  106 -
 ...ancing_removal_addition_properties.prm.bak |  107 -
 ...article_load_balancing_repartition.prm.bak |   19 -
 ...le_load_balancing_repartition_1000.prm.bak |   20 -
 tests/particle_melt_advection.cc.bak          |   21 -
 tests/particle_melt_advection.prm.bak         |  166 -
 tests/particle_output_gnuplot.prm.bak         |  107 -
 tests/particle_output_hdf5.prm.bak            |  107 -
 .../particle_output_multiple_formats.prm.bak  |  106 -
 tests/particle_output_none.prm.bak            |  109 -
 tests/particle_output_vtu.prm.bak             |  107 -
 tests/particle_output_vtu_group.prm.bak       |  110 -
 tests/particle_output_vtu_temp.prm.bak        |  109 -
 tests/particle_periodic_boundaries.prm.bak    |  114 -
 tests/particle_periodic_boundaries_dc.prm.bak |   35 -
 .../particle_periodic_boundaries_rk4.prm.bak  |  113 -
 tests/particle_periodic_quarter_shell.prm.bak |  112 -
 .../particle_periodic_quarter_shell_2.prm.bak |  122 -
 tests/particle_property_composition.cc.bak    |   21 -
 tests/particle_property_composition.prm.bak   |  188 -
 tests/particle_property_function.prm.bak      |  113 -
 ...ticle_property_initial_composition.prm.bak |  106 -
 ...perty_initial_composition_boundary.prm.bak |  103 -
 ...operty_integrated_strain_invariant.prm.bak |  112 -
 ...perty_integrated_strain_pure_shear.prm.bak |   92 -
 ...rty_integrated_strain_simple_shear.prm.bak |   91 -
 ...rticle_property_multiple_functions.prm.bak |  115 -
 ...tiple_functions_with_interpolation.prm.bak |  118 -
 ...e_property_post_initialize_function.cc.bak |   86 -
 ..._property_post_initialize_function.prm.bak |  105 -
 tests/particle_timing_information.prm.bak     |  109 -
 ...ticle_visualization_particle_count.prm.bak |  110 -
 tests/particles_with_AMR_on.prm.bak           |  124 -
 tests/passive_comp.prm.bak                    |  280 -
 tests/periodic_box.prm.bak                    |  108 -
 tests/periodic_box2.prm.bak                   |   97 -
 tests/periodic_box_freesurface.prm.bak        |  116 -
 tests/periodic_box_gmg.prm.bak                |  124 -
 tests/periodic_box_mpi4.prm.bak               |   99 -
 tests/periodic_compressible.prm.bak           |   84 -
 tests/periodic_linear_momentum.prm.bak        |  112 -
 tests/periodic_quarter_shell.prm.bak          |   77 -
 tests/plugin.cc.bak                           |   41 -
 tests/plugin.prm.bak                          |   80 -
 tests/plugin_dependency.cc.bak                |   56 -
 tests/plugin_dependency.prm.bak               |   78 -
 tests/plugin_dependency_redundant.cc.bak      |   23 -
 tests/plugin_dependency_redundant.prm.bak     |   80 -
 tests/plugin_dependency_redundant_02.cc.bak   |   23 -
 tests/plugin_dependency_redundant_02.prm.bak  |   79 -
 tests/point_value_01.prm.bak                  |  102 -
 tests/point_value_02.prm.bak                  |  109 -
 tests/point_value_02_mpi.prm.bak              |  107 -
 tests/point_value_03.prm.bak                  |  103 -
 tests/point_value_natural_coordinates.prm.bak |   86 -
 ...nt_value_natural_coordinates_shell.prm.bak |   86 -
 .../point_value_specific_output_times.prm.bak |  104 -
 tests/poiseuille_2d.prm.bak                   |   72 -
 ...iseuille_2d_horizontal_pressure_bc.prm.bak |  102 -
 tests/poiseuille_2d_pressure_bc.prm.bak       |   94 -
 tests/poiseuille_2d_pressure_bc_gmg.prm.bak   |  105 -
 ...euille_3d_x_horizontal_pressure_bc.prm.bak |  100 -
 tests/postprocess_initial.prm.bak             |  105 -
 .../postprocess_iterations_Stokes_only.cc.bak |   21 -
 ...postprocess_iterations_Stokes_only.prm.bak |   88 -
 ...tprocess_iterations_iterated_Stokes.cc.bak |   21 -
 ...process_iterations_iterated_Stokes.prm.bak |   96 -
 ...ions_iterated_advection_and_stokes.prm.bak |  133 -
 tests/pre_data_out_build_patches.cc.bak       |   45 -
 tests/pre_data_out_build_patches.prm.bak      |   72 -
 tests/prescribed_dilation.cc.bak              |  413 -
 tests/prescribed_dilation.prm.bak             |   71 -
 tests/prescribed_dilation_gmg.cc.bak          |   21 -
 tests/prescribed_dilation_gmg.prm.bak         |   19 -
 tests/prescribed_dilation_newton.cc.bak       |   21 -
 tests/prescribed_dilation_newton.prm.bak      |   18 -
 ...bed_dilation_newton_singleadvection.cc.bak |   21 -
 ...ed_dilation_newton_singleadvection.prm.bak |   18 -
 tests/prescribed_field.cc.bak                 |   92 -
 tests/prescribed_field.prm.bak                |   90 -
 tests/prescribed_field_temperature.cc.bak     |   93 -
 tests/prescribed_field_temperature.prm.bak    |   78 -
 ...bed_field_temperature_max_isotherm.prm.bak |   21 -
 tests/prescribed_field_with_diffusion.cc.bak  |   95 -
 tests/prescribed_field_with_diffusion.prm.bak |  107 -
 tests/prescribed_stokes_solution.prm.bak      |   95 -
 ...cribed_stokes_solution_DG_periodic.prm.bak |   72 -
 tests/prescribed_stokes_solution_melt.prm.bak |  109 -
 tests/prescribed_temperature.cc.bak           |   95 -
 tests/prescribed_temperature.prm.bak          |   85 -
 tests/prescribed_temperature_in_field.cc.bak  |  182 -
 tests/prescribed_temperature_in_field.prm.bak |   67 -
 ...escribed_temperature_with_diffusion.cc.bak |   95 -
 ...scribed_temperature_with_diffusion.prm.bak |   84 -
 tests/prescribed_velocity.cc.bak              |   21 -
 tests/prescribed_velocity.prm.bak             |   58 -
 tests/prescribed_velocity_boundary.cc.bak     |  446 -
 tests/prescribed_velocity_boundary.prm.bak    |   88 -
 tests/prescribed_velocity_dgp.cc.bak          |  264 -
 tests/prescribed_velocity_dgp.prm.bak         |   62 -
 ...ribed_viscosity_additional_outputs.prm.bak |   41 -
 tests/prescribed_viscosity_happy.prm.bak      |   72 -
 tests/pressure_boundary.prm.bak               |   92 -
 tests/pressure_compatibility.prm.bak          |   77 -
 tests/pressure_compatibility_2.prm.bak        |   95 -
 tests/pressure_compatibility_3.prm.bak        |   94 -
 tests/pressure_compatibility_4.prm.bak        |  101 -
 tests/pressure_compatibility_dg.prm.bak       |    9 -
 .../pressure_compatibility_dg_direct.prm.bak  |   15 -
 tests/pressure_compatibility_direct.prm.bak   |   11 -
 tests/pressure_constraint.cc.bak              |   60 -
 tests/pressure_constraint.prm.bak             |   70 -
 tests/pressure_scaling_signal.cc.bak          |   44 -
 tests/pressure_scaling_signal.prm.bak         |   88 -
 tests/principal_deviatoric_stress.cc.bak      |   21 -
 tests/principal_deviatoric_stress.prm.bak     |  117 -
 tests/prm_distance_polygon.cc.bak             |   77 -
 tests/prm_distance_polygon.prm.bak            |    1 -
 tests/prm_polygon_in_out.cc.bak               |   82 -
 tests/prm_polygon_in_out.prm.bak              |    1 -
 tests/prmbackslash.prm.bak                    |   72 -
 tests/prmbackslash_2.cc.bak                   |   21 -
 tests/prmbackslash_2.prm.bak                  |  156 -
 tests/projected_density_vertical_pipe.cc.bak  |   21 -
 tests/projected_density_vertical_pipe.prm.bak |   31 -
 tests/pure_shear.cc.bak                       |   21 -
 tests/pure_shear.prm.bak                      |  145 -
 tests/q1_q1.cc.bak                            |  474 -
 tests/q1_q1.prm.bak                           |   98 -
 tests/q1_q1_6.cc.bak                          |   21 -
 tests/q1_q1_6.prm.bak                         |   95 -
 ...iable_coordinate_systems_cartesian.prm.bak |   86 -
 ..._variable_coordinate_systems_depth.prm.bak |   86 -
 ...iable_coordinate_systems_spherical.prm.bak |   86 -
 tests/quick_mpi.cc.bak                        |   21 -
 tests/quick_mpi.prm.bak                       |   82 -
 tests/radioactive_decay.prm.bak               |   87 -
 tests/radiogenic_heating.prm.bak              |   91 -
 tests/random_perturbation_box.prm.bak         |   70 -
 tests/random_perturbation_chunk.prm.bak       |   72 -
 .../random_perturbation_merged_boxes.prm.bak  |   73 -
 tests/random_perturbation_sphere.prm.bak      |   67 -
 ...andom_perturbation_spherical_shell.prm.bak |   66 -
 ...active_fluid_transport_no_reaction.prm.bak |   25 -
 ...ve_fluid_transport_zero_solubility.prm.bak |  138 -
 tests/refine_vel.prm.bak                      |   92 -
 .../refinement_artificial_viscosity_1.prm.bak |  101 -
 .../refinement_artificial_viscosity_2.prm.bak |   11 -
 .../refinement_artificial_viscosity_3.prm.bak |   11 -
 tests/refinement_boundary.prm.bak             |   71 -
 tests/refinement_composition_gradient.prm.bak |   95 -
 .../refinement_composition_threshold.prm.bak  |   18 -
 ...efinement_nonadiabatic_temperature.prm.bak |   27 -
 tests/refinement_strainrate.prm.bak           |  121 -
 tests/refinement_switch.prm.bak               |  111 -
 tests/refinement_topography.cc.bak            |   21 -
 tests/refinement_topography.prm.bak           |   68 -
 tests/remove_angular_momentum.prm.bak         |   63 -
 tests/remove_angular_momentum_3d.prm.bak      |   66 -
 tests/remove_net_rotation.prm.bak             |   67 -
 tests/remove_net_rotation_3d.prm.bak          |   67 -
 tests/remove_net_surface_rotation.prm.bak     |   15 -
 ...replace_lithosphere_viscosity_file.prm.bak |   65 -
 tests/resume_free_surface.cc.bak              |   95 -
 tests/resume_free_surface.prm.bak             |  130 -
 tests/rheology_scaled_profile.cc.bak          |  296 -
 tests/rheology_scaled_profile.prm.bak         |   82 -
 tests/rigid_shear_instantaneous.cc.bak        |   21 -
 tests/rigid_shear_instantaneous.prm.bak       |    5 -
 tests/rigid_shear_steady_state.cc.bak         |   21 -
 tests/rigid_shear_steady_state.prm.bak        |    5 -
 tests/rigid_shear_transient.cc.bak            |   21 -
 tests/rigid_shear_transient.prm.bak           |    7 -
 tests/rising_melt_blob.cc.bak                 |  103 -
 tests/rising_melt_blob.prm.bak                |  135 -
 tests/rising_melt_blob_freezing.prm.bak       |  123 -
 tests/rotation_statistics.prm.bak             |   76 -
 tests/rotation_statistics_3d.prm.bak          |   76 -
 .../rotation_statistics_3d_asymmetric.prm.bak |   76 -
 tests/rotation_statistics_3d_surface.prm.bak  |   20 -
 tests/sea_level_postprocessor.prm.bak         |   95 -
 tests/segregation_heating.cc.bak              |   71 -
 tests/segregation_heating.prm.bak             |  142 -
 tests/shear_bands.cc.bak                      |   21 -
 tests/shear_bands.prm.bak                     |  128 -
 tests/shear_heating.prm.bak                   |   85 -
 tests/shear_heating_compressible.prm.bak      |  114 -
 tests/shear_heating_compressible_melt.prm.bak |  147 -
 tests/shear_heating_limited.prm.bak           |   30 -
 tests/shear_heating_with_melt.prm.bak         |  210 -
 tests/shear_thinning.cc.bak                   |  194 -
 tests/shear_thinning.prm.bak                  |   88 -
 tests/shearbox_particle_strain_rate.prm.bak   |  186 -
 tests/shell_2d_gmg.prm.bak                    |   81 -
 tests/shell_3d_gmg.prm.bak                    |   87 -
 ...ary_composition_spherical_constant.prm.bak |   89 -
 tests/shell_quarter_BC.prm.bak                |   17 -
 tests/shell_quarter_gmg.prm.bak               |   81 -
 tests/shell_surface_base_variables.prm.bak    |   96 -
 ...l_with_variable_coordinate_systems.prm.bak |   92 -
 tests/signal_fem.cc.bak                       |   71 -
 tests/signal_fem.prm.bak                      |   91 -
 tests/signals.cc.bak                          |   60 -
 tests/signals.prm.bak                         |   80 -
 tests/signals_connect.cc.bak                  |   49 -
 tests/signals_connect.prm.bak                 |   78 -
 tests/signals_post_constraints.cc.bak         |   47 -
 tests/signals_post_constraints.prm.bak        |   73 -
 tests/simple_composite.prm.bak                |   96 -
 ...ple_compressibility_iterated_stokes.cc.bak |   21 -
 ...le_compressibility_iterated_stokes.prm.bak |   81 -
 ...compressibility_iterated_stokes_gmg.cc.bak |   21 -
 ...ompressibility_iterated_stokes_gmg.prm.bak |   19 -
 tests/simple_compressible.prm.bak             |   95 -
 tests/simple_incompressible.prm.bak           |   88 -
 tests/simple_nonlinear.cc.bak                 |  253 -
 tests/simple_nonlinear.prm.bak                |    4 -
 tests/simple_shear.cc.bak                     |  124 -
 tests/simple_shear.prm.bak                    |  134 -
 tests/simple_shear_output_the_mobility.cc.bak |  124 -
 .../simple_shear_output_the_mobility.prm.bak  |  139 -
 tests/simpler_box.prm.bak                     |   63 -
 tests/simpler_composition.prm.bak             |   61 -
 ..._iterated_defect_correction_Stokes.prm.bak |  127 -
 tests/sinking_block.cc.bak                    |   21 -
 tests/sinking_block.prm.bak                   |   10 -
 ...itions_setup_on_initial_refinement.prm.bak |   66 -
 tests/skip_refinement.prm.bak                 |  165 -
 ...skip_solvers_on_initial_refinement.prm.bak |   65 -
 ...slab2_initial_composition_3d_shell.prm.bak |   78 -
 tests/slab_tip_depth.prm.bak                  |  157 -
 tests/slope_refinement.prm.bak                |  114 -
 tests/smoothing.prm.bak                       |   98 -
 tests/smoothing_composition_passive.prm.bak   |  108 -
 tests/sol_cx_2.cc.bak                         |   21 -
 tests/sol_cx_2.prm.bak                        |   74 -
 tests/sol_cx_2_conservative.cc.bak            |   21 -
 tests/sol_cx_2_conservative.prm.bak           |   73 -
 tests/sol_cx_2_equal_order.cc.bak             |   21 -
 tests/sol_cx_2_equal_order.prm.bak            |   76 -
 tests/sol_cx_2_gmg.cc.bak                     |   21 -
 tests/sol_cx_2_gmg.prm.bak                    |   86 -
 tests/sol_cx_2_normalized_pressure.cc.bak     |   21 -
 tests/sol_cx_2_normalized_pressure.prm.bak    |   74 -
 tests/sol_cx_2_q3.cc.bak                      |   21 -
 tests/sol_cx_2_q3.prm.bak                     |   73 -
 tests/sol_cx_4.cc.bak                         |   21 -
 tests/sol_cx_4.prm.bak                        |   73 -
 tests/sol_cx_4_conservative.cc.bak            |   21 -
 tests/sol_cx_4_conservative.prm.bak           |   73 -
 tests/sol_cx_4_equal_order.cc.bak             |   21 -
 tests/sol_cx_4_equal_order.prm.bak            |   75 -
 tests/sol_cx_4_gmg.cc.bak                     |   21 -
 tests/sol_cx_4_gmg.prm.bak                    |   84 -
 tests/sol_cx_4_normalized_pressure.cc.bak     |   21 -
 tests/sol_cx_4_normalized_pressure.prm.bak    |   74 -
 ...ized_pressure_large_static_pressure.cc.bak |   21 -
 ...zed_pressure_large_static_pressure.prm.bak |   96 -
 ...lized_pressure_low_solver_tolerance.cc.bak |   21 -
 ...ized_pressure_low_solver_tolerance.prm.bak |   90 -
 tests/sol_cx_mpi_2.cc.bak                     |   21 -
 tests/sol_cx_mpi_2.prm.bak                    |   78 -
 tests/sol_cx_newton_crash.cc.bak              |   21 -
 tests/sol_cx_newton_crash.prm.bak             |   83 -
 tests/sol_cx_particles.cc.bak                 |   21 -
 tests/sol_cx_particles.prm.bak                |    9 -
 tests/sol_kz_2.cc.bak                         |   21 -
 tests/sol_kz_2.prm.bak                        |   73 -
 ...sol_kz_2_cheaper_first_phase_solver.cc.bak |   21 -
 ...ol_kz_2_cheaper_first_phase_solver.prm.bak |   79 -
 tests/sol_kz_2_conservative.cc.bak            |   21 -
 tests/sol_kz_2_conservative.prm.bak           |   73 -
 tests/sol_kz_2_no_first_phase_solver.cc.bak   |   21 -
 tests/sol_kz_2_no_first_phase_solver.prm.bak  |   79 -
 tests/sol_kz_2_project_q1_only_visc.cc.bak    |   21 -
 tests/sol_kz_2_project_q1_only_visc.prm.bak   |   14 -
 tests/sol_kz_2_q3.cc.bak                      |   21 -
 tests/sol_kz_2_q3.prm.bak                     |   73 -
 tests/sol_kz_4.cc.bak                         |   21 -
 tests/sol_kz_4.prm.bak                        |   73 -
 tests/sol_kz_4_conservative.cc.bak            |   21 -
 tests/sol_kz_4_conservative.prm.bak           |   73 -
 tests/solidus_initial_conditions.cc.bak       |  447 -
 tests/solidus_initial_conditions.prm.bak      |   85 -
 tests/solitary_wave.cc.bak                    |   21 -
 tests/solitary_wave.prm.bak                   |  159 -
 tests/solubility.cc.bak                       |   21 -
 tests/solubility.prm.bak                      |   11 -
 tests/solve_no_advection_no_stokes.prm.bak    |   71 -
 tests/solver_history.cc.bak                   |   49 -
 tests/solver_history.prm.bak                  |   69 -
 ...r_scheme_no_advection_single_stokes.cc.bak |   21 -
 ..._scheme_no_advection_single_stokes.prm.bak |   84 -
 tests/spectral_comparison.prm.bak             |   16 -
 ...erical_constant_boundary_3d_sphere.prm.bak |   74 -
 tests/spherical_nsinker.cc.bak                |   21 -
 tests/spherical_nsinker.prm.bak               |   16 -
 ...l_initial_topography_ascii_data_3d.prm.bak |   93 -
 ...ell_initial_topography_function_3d.prm.bak |   88 -
 tests/spherical_velocity_statistics.prm.bak   |   95 -
 tests/spiegelman_fail_test.cc.bak             |  678 --
 tests/spiegelman_fail_test.prm.bak            |  129 -
 tests/spiegelman_material.cc.bak              |  303 -
 tests/spiegelman_material.prm.bak             |    4 -
 tests/splines.cc.bak                          |   74 -
 tests/splines.prm.bak                         |    1 -
 tests/static_temperature.prm.bak              |   98 -
 tests/statistics_output.prm.bak               |  142 -
 tests/steinberger_averaging.prm.bak           |  123 -
 tests/steinberger_background.prm.bak          |  106 -
 tests/steinberger_compressible.prm.bak        |   95 -
 tests/steinberger_compressible_gmg.prm.bak    |   18 -
 tests/steinberger_conductivity.prm.bak        |   80 -
 tests/steinberger_conductivity_tosi.prm.bak   |   87 -
 .../steinberger_continuous_viscosity.prm.bak  |   18 -
 tests/steinberger_cookbook.prm.bak            |   12 -
 tests/steinberger_latent_heat.prm.bak         |   90 -
 tests/steinberger_latent_heat_2.prm.bak       |  125 -
 tests/steinberger_lateral_fail.prm.bak        |  101 -
 tests/steinberger_phase_fractions.prm.bak     |  112 -
 ...nberger_phase_fractions_background.prm.bak |  129 -
 tests/steinberger_phases.prm.bak              |  110 -
 tests/steinberger_phases_2_lookups.prm.bak    |  108 -
 tests/steinberger_phases_hefesto.prm.bak      |  111 -
 tests/steinberger_projected_density.prm.bak   |  114 -
 ...nberger_projected_density_dcPicard.prm.bak |  118 -
 tests/steinberger_seismic_velocities.prm.bak  |   98 -
 tests/steinberger_several_fields.prm.bak      |  110 -
 tests/steinberger_single_field.prm.bak        |  110 -
 tests/steinberger_viscosity.prm.bak           |   91 -
 tests/steinberger_viscosity_adiabatic.prm.bak |  101 -
 tests/stokes.prm.bak                          |  124 -
 tests/stokes_residual.prm.bak                 |   66 -
 tests/stokes_residual_cheap.prm.bak           |   11 -
 tests/stokes_solver_fail.prm.bak              |   17 -
 tests/stokes_solver_fail_A.prm.bak            |   15 -
 tests/stokes_solver_fail_S.prm.bak            |   15 -
 tests/stokes_solver_fail_cheap.prm.bak        |   17 -
 tests/stokes_solver_fail_gmg.prm.bak          |   21 -
 tests/stress_vs_surface_stress.cc.bak         |   21 -
 tests/stress_vs_surface_stress.prm.bak        |   92 -
 ...ress_vs_surface_stress_point_values.cc.bak |   21 -
 ...ess_vs_surface_stress_point_values.prm.bak |   17 -
 ...on_initiation_compositional_fields.prm.bak |   51 -
 tests/supg-compositional-passive.prm.bak      |  107 -
 tests/supg.prm.bak                            |   98 -
 .../surface_elevation_box_ascii_data.prm.bak  |   17 -
 ...vation_box_ascii_data_moved_origin.prm.bak |   17 -
 tests/surface_elevation_box_function.prm.bak  |   17 -
 .../surface_elevation_box_prm_polygon.prm.bak |   17 -
 ...surface_elevation_chunk_ascii_data.prm.bak |   17 -
 ...face_elevation_chunk_ascii_data_3d.prm.bak |   17 -
 ...ion_chunk_ascii_data_3d_colatitude.prm.bak |   32 -
 ...evation_chunk_ascii_data_global_3d.prm.bak |  112 -
 ...herical_shell_ascii_data_global_3d.prm.bak |   95 -
 tests/surface_stress_strainrate_3d.cc.bak     |    1 -
 tests/surface_stress_strainrate_3d.prm.bak    |   99 -
 tests/symbolic_boundary_names_box.prm.bak     |   66 -
 ...lic_boundary_names_box_constant_bc.prm.bak |   70 -
 ...mes_spherical_shell_2d_180_degrees.prm.bak |   64 -
 ...ames_spherical_shell_2d_90_degrees.prm.bak |   64 -
 ...dary_names_spherical_shell_2d_full.prm.bak |   60 -
 ...ames_spherical_shell_3d_90_degrees.prm.bak |   64 -
 ...dary_names_spherical_shell_3d_full.prm.bak |   60 -
 tests/tangurnis.cc.bak                        |   21 -
 tests/tangurnis_ba.cc.bak                     |   21 -
 tests/tangurnis_ba.prm.bak                    |  248 -
 tests/tangurnis_ba_custom.cc.bak              |   21 -
 tests/tangurnis_ba_custom.prm.bak             |  247 -
 tests/tangurnis_tala.cc.bak                   |   21 -
 tests/tangurnis_tala.prm.bak                  |  262 -
 tests/tangurnis_tala_c.cc.bak                 |   21 -
 tests/tangurnis_tala_c.prm.bak                |  262 -
 tests/tangurnis_tala_gmg.cc.bak               |   21 -
 tests/tangurnis_tala_gmg.prm.bak              |   19 -
 tests/tangurnis_tala_implicit.cc.bak          |   21 -
 tests/tangurnis_tala_implicit.prm.bak         |  265 -
 ...emperature_dependent_stokes_matrix.prm.bak |   76 -
 tests/terminate_user_request.cc.bak           |   34 -
 tests/terminate_user_request.prm.bak          |   71 -
 tests/thermal_alpha_s40rts.prm.bak            |   66 -
 tests/tian_MORB.prm.bak                       |   27 -
 tests/tian_gabbro.prm.bak                     |   27 -
 tests/tian_peridotite.prm.bak                 |  122 -
 tests/tian_sediment.prm.bak                   |   27 -
 tests/time_dependent_annulus.cc.bak           |   21 -
 tests/time_dependent_annulus.prm.bak          |   10 -
 tests/time_dependent_temperature_bc.cc.bak    |  251 -
 tests/time_dependent_temperature_bc.prm.bak   |  100 -
 tests/time_dependent_temperature_bc_2.cc.bak  |   21 -
 tests/time_dependent_temperature_bc_2.prm.bak |   97 -
 tests/time_stepping_fail.prm.bak              |   65 -
 tests/time_stepping_function.prm.bak          |   63 -
 tests/time_stepping_min.prm.bak               |   66 -
 tests/time_stepping_repeat.prm.bak            |   99 -
 tests/time_stepping_repeat_particles.prm.bak  |  127 -
 ...epeat_particles_iterated_advection.prm.bak |   30 -
 ...graphy_based_plate_motions_cookbook.cc.bak |   22 -
 ...raphy_based_plate_motions_cookbook.prm.bak |   39 -
 tests/topo_box.prm.bak                        |  119 -
 tests/topo_chunk.prm.bak                      |   86 -
 tests/topo_shell.prm.bak                      |   75 -
 tests/tosi_benchmark.cc.bak                   |   21 -
 tests/tosi_benchmark.prm.bak                  |    8 -
 ...tosi_benchmark_gmg_dc_picard_solver.cc.bak |    1 -
 ...osi_benchmark_gmg_dc_picard_solver.prm.bak |   17 -
 tests/tosi_benchmark_gmg_newton_solver.cc.bak |   21 -
 .../tosi_benchmark_gmg_newton_solver.prm.bak  |   18 -
 tests/tosi_benchmark_newton_solver.cc.bak     |   21 -
 tests/tosi_benchmark_newton_solver.prm.bak    |    8 -
 ...tosi_benchmark_newton_solver_full_A.cc.bak |   21 -
 ...osi_benchmark_newton_solver_full_A.prm.bak |   15 -
 tests/traction_ascii_data.prm.bak             |  133 -
 tests/traction_multiple_model.prm.bak         |  135 -
 tests/transform_fault_behn_2007.prm.bak       |   11 -
 tests/two_merged_boxes_free_surface.prm.bak   |   72 -
 ...an_parameterization_kinematic_slab.prm.bak |   50 -
 tests/update_script.cc.bak                    |   65 -
 tests/update_script_2.cc.bak                  |   70 -
 tests/update_script_2/updated2.prm.bak        |  135 -
 tests/upwelling_melting_peridotite.prm.bak    |  135 -
 ...ng_melting_peridotite_compressible.prm.bak |  128 -
 tests/upwelling_melting_pyroxenite.prm.bak    |  161 -
 tests/use_full_A_block_preconditioner.prm.bak |   88 -
 tests/van_keken_smooth_particle.prm.bak       |  108 -
 tests/vankeken_subduction.cc.bak              |    2 -
 tests/vankeken_subduction.prm.bak             |   13 -
 tests/var_declaration_expansion.cc.bak        |   55 -
 tests/var_declaration_expansion.prm.bak       |   80 -
 tests/velocity_boundary_statistics.prm.bak    |   92 -
 tests/velocity_divergence.cc.bak              |   69 -
 tests/velocity_divergence.prm.bak             |  161 -
 tests/velocity_in_years.prm.bak               |   89 -
 tests/vep_chemical_compositions.prm.bak       |   84 -
 tests/vis_velocity_in_years.prm.bak           |   63 -
 tests/visco_elastic_top_beam.prm.bak          |  154 -
 tests/visco_plastic.prm.bak                   |   96 -
 ...plastic_additional_plastic_outputs.prm.bak |  132 -
 .../visco_plastic_adiabat_temperature.prm.bak |  118 -
 ..._plastic_adiabatic_heating_density.prm.bak |  115 -
 ...diabatic_pressure_in_viscous_creep.prm.bak |  149 -
 tests/visco_plastic_complex.prm.bak           |  174 -
 tests/visco_plastic_composite.prm.bak         |  108 -
 ...astic_constant_viscosity_prefactor.prm.bak |  104 -
 tests/visco_plastic_derivatives_2d.cc.bak     |  274 -
 tests/visco_plastic_derivatives_2d.prm.bak    |  118 -
 tests/visco_plastic_derivatives_3d.cc.bak     |  289 -
 tests/visco_plastic_derivatives_3d.prm.bak    |  118 -
 tests/visco_plastic_diffusion.prm.bak         |  110 -
 ...ic_diffusion_dislocation_composite.prm.bak |  116 -
 tests/visco_plastic_dislocation.prm.bak       |  109 -
 tests/visco_plastic_frank_kamenetskii.prm.bak |  107 -
 ...plastic_frank_kamenetskii_pressure.prm.bak |  108 -
 tests/visco_plastic_friction_function.prm.bak |  111 -
 tests/visco_plastic_gerya_2019_vp.prm.bak     |   21 -
 ...astic_newton_nonlinear_channelflow.prm.bak |  124 -
 .../visco_plastic_peierls_cutoff_test.prm.bak |  100 -
 ...isco_plastic_peierls_idrissi_exact.prm.bak |  120 -
 tests/visco_plastic_peierls_mei_exact.prm.bak |  120 -
 ...astic_peierls_mei_viscosity_approx.prm.bak |   77 -
 ...plastic_peierls_strict_cutoff_test.prm.bak |  101 -
 tests/visco_plastic_phases.prm.bak            |  106 -
 .../visco_plastic_phases_compositions.prm.bak |  123 -
 ...o_plastic_phases_peierls_mei_exact.prm.bak |   80 -
 tests/visco_plastic_phases_plasticity.prm.bak |  111 -
 ...ic_phases_temperature_limit_basalt.prm.bak |  117 -
 ...ases_temperature_limit_harzburgite.prm.bak |  117 -
 ..._phases_temperature_limit_pyrolite.prm.bak |  117 -
 ...erature_limit_pyrolite_complicated.prm.bak |  117 -
 tests/visco_plastic_phases_viscosity.prm.bak  |  129 -
 ...o_plastic_phases_viscosity_max_min.prm.bak |  133 -
 ..._plastic_reference_density_profile.prm.bak |  103 -
 ...visco_plastic_thermal_conductivity.prm.bak |   21 -
 ...rain_healing_temperature_dependent.prm.bak |  166 -
 ...ic_track_noninitial_plastic_strain.prm.bak |  133 -
 tests/visco_plastic_vep_bending_beam.prm.bak  |   49 -
 .../visco_plastic_vep_brick_extension.prm.bak |   63 -
 tests/visco_plastic_vep_plate_flexure.prm.bak |   51 -
 tests/visco_plastic_vep_simple_shear.prm.bak  |    7 -
 .../visco_plastic_vep_stress_build-up.prm.bak |   58 -
 ...s_build-up_fixed_elastic_time_step.prm.bak |   57 -
 ...p_stress_build-up_stress_averaging.prm.bak |   59 -
 ..._plastic_vep_stress_build-up_yield.prm.bak |   71 -
 ...ep_stress_build-up_yield_particles.prm.bak |   92 -
 ...o_plastic_viscous_strain_weakening.prm.bak |  130 -
 tests/visco_plastic_yield.prm.bak             |   99 -
 tests/visco_plastic_yield_max.prm.bak         |  118 -
 ...oninitial-plastic-strain_particles.prm.bak |   59 -
 ...visco_plastic_yield_plastic_damper.prm.bak |   26 -
 ...tic_yield_plastic_strain_weakening.prm.bak |  132 -
 ...plastic_strain_weakening_particles.prm.bak |   31 -
 ...eld_plastic_viscous_strain_healing.prm.bak |  148 -
 ...d_plastic_viscous_strain_weakening.prm.bak |  135 -
 ...viscous_strain_weakening_particles.prm.bak |   31 -
 ...sco_plastic_yield_strain_weakening.prm.bak |  132 -
 ...ield_strain_weakening_compositions.prm.bak |  127 -
 ...train_weakening_defect_corr_stokes.prm.bak |    4 -
 ...train_weakening_full_strain_tensor.prm.bak |  134 -
 ...in_weakening_full_strain_tensor_3d.prm.bak |  130 -
 ...train_weakening_iterated_advection.prm.bak |   44 -
 ...rain_weakening_no-advect_no_stokes.prm.bak |    7 -
 ...c_yield_strain_weakening_particles.prm.bak |   31 -
 ...activated_viscous_strain_weakening.prm.bak |   46 -
 ...plastic_yield_total_strain_healing.prm.bak |  147 -
 ...tic_yield_viscous_strain_weakening.prm.bak |  131 -
 ...viscous_strain_weakening_particles.prm.bak |   31 -
 tests/viscoelastic_bending_beam.prm.bak       |   51 -
 ...iscoelastic_bending_beam_averaging.prm.bak |   38 -
 tests/viscoelastic_bending_beam_gmg.prm.bak   |   47 -
 ...iscoelastic_bending_beam_particles.prm.bak |   53 -
 ...stic_bending_beam_principal_stress.prm.bak |   34 -
 ...scoelastic_fixed_elastic_time_step.prm.bak |   54 -
 ...lastic_numerical_elastic_time_step.prm.bak |   55 -
 ...erical_elastic_time_step_particles.prm.bak |   75 -
 tests/viscoelastic_plate_flexure.prm.bak      |   32 -
 tests/viscoelastic_sheared_torsion.prm.bak    |    9 -
 tests/viscoelastic_stress_averaging.prm.bak   |   56 -
 tests/viscoelastic_stress_build-up.prm.bak    |   83 -
 .../viscoelastic_stress_build-up_gmg.prm.bak  |   98 -
 ...d_plastic_viscous_strain_weakening.prm.bak |   77 -
 tests/viscoplastic_melt_blob_freezing.prm.bak |   64 -
 tests/viscoplastic_melt_fraction.prm.bak      |  118 -
 tests/viscosity_refinement.prm.bak            |   67 -
 tests/viscous_dissipation_statistics.prm.bak  |  124 -
 tests/viscous_top_beam.prm.bak                |  163 -
 ...visualization_averaged_strain_rate.prm.bak |   84 -
 ...isualization_averaged_strain_rate2.prm.bak |   12 -
 ...alization_conductivity_diffusivity.prm.bak |   80 -
 .../visualization_higher_order_output.prm.bak |   17 -
 tests/visualization_shear_stress.prm.bak      |   87 -
 ...sualization_shear_stress_pointwise.prm.bak |   12 -
 ...lization_shear_stress_viscoelastic.prm.bak |   49 -
 tests/visualization_strain_rate.prm.bak       |   84 -
 ...isualization_strain_rate_pointwise.prm.bak |   12 -
 .../visualization_strain_rate_tensor.prm.bak  |   83 -
 ...ation_strain_rate_tensor_pointwise.prm.bak |   12 -
 tests/visualization_stress.prm.bak            |   90 -
 tests/visualization_stress_pointwise.prm.bak  |   12 -
 .../visualization_stress_viscoelastic.prm.bak |   49 -
 .../visualization_temperature_anomaly.prm.bak |   85 -
 tests/visualization_unique_list.prm.bak       |   83 -
 .../visualization_vertical_heat_flux.prm.bak  |   90 -
 tests/viz_mesh_deform_vector.prm.bak          |  124 -
 tests/viz_plugin_dependency.cc.bak            |   89 -
 tests/viz_plugin_dependency.prm.bak           |   80 -
 .../viz_spherical_velocity_components.prm.bak |   80 -
 tests/vof_circle_1.cc.bak                     |   23 -
 tests/vof_circle_1.prm.bak                    |   94 -
 tests/vof_circle_amr.cc.bak                   |   23 -
 tests/vof_circle_amr.prm.bak                  |   97 -
 tests/vof_circle_mpi.cc.bak                   |   23 -
 tests/vof_circle_mpi.prm.bak                  |   96 -
 tests/vof_circle_mpi_amr.cc.bak               |   23 -
 tests/vof_circle_mpi_amr.prm.bak              |   99 -
 tests/vof_composition_init.prm.bak            |   81 -
 tests/vof_err_calc.h.bak                      |  342 -
 tests/vof_linear.cc.bak                       |   23 -
 tests/vof_linear.prm.bak                      |   93 -
 tests/vof_linear_2f.cc.bak                    |   23 -
 tests/vof_linear_2f.prm.bak                   |   93 -
 tests/vof_linear_amr.cc.bak                   |   23 -
 tests/vof_linear_amr.prm.bak                  |   95 -
 tests/vof_linear_amr_mpi.cc.bak               |   23 -
 tests/vof_linear_amr_mpi.prm.bak              |   97 -
 tests/vof_linear_inflow.prm.bak               |   86 -
 tests/vof_linear_periodic.cc.bak              |   23 -
 tests/vof_linear_periodic.prm.bak             |   94 -
 tests/vof_linear_periodic_amr.cc.bak          |   23 -
 tests/vof_linear_periodic_amr.prm.bak         |   96 -
 tests/vof_mpi_amr_no_dof.prm.bak              |   85 -
 tests/walltime.prm.bak                        |   64 -
 tests/weighted_p_norm_average.cc.bak          |   46 -
 .../world_builder_select_composition.prm.bak  |   69 -
 tests/world_builder_select_grains.prm.bak     |   95 -
 tests/world_builder_simple.prm.bak            |   70 -
 ...der_simple_2d_cartesian_sticky_air.prm.bak |   71 -
 tests/write_plugin_graph.cc.bak               |   98 -
 tests/write_plugin_graph.prm.bak              |   76 -
 tests/zero_RHS.prm.bak                        |  120 -
 tests/zero_matrix.prm.bak                     |  115 -
 tests/zero_temperature.prm.bak                |   94 -
 unit_tests/additional_outputs.cc.bak          |   98 -
 unit_tests/common.h.bak                       |   67 -
 .../crystal_preferred_orientation.cc.bak      | 2309 -----
 unit_tests/first.cc.bak                       |   89 -
 unit_tests/introspection.cc.bak               |  135 -
 unit_tests/mesh_refinement.cc.bak             |   59 -
 unit_tests/netcdf.cc.bak                      |  101 -
 unit_tests/parse_map_to_double_array.cc.bak   |  460 -
 unit_tests/particles.cc.bak                   |   56 -
 unit_tests/termination_criteria.cc.bak        |   68 -
 unit_tests/utilities.cc.bak                   |  628 --
 2889 files changed, 427131 deletions(-)
 delete mode 100644 benchmarks/advection/drop_ev.prm.bak
 delete mode 100644 benchmarks/advection/drop_supg.prm.bak
 delete mode 100644 benchmarks/advection/rotate_shape_dg_bp.prm.bak
 delete mode 100644 benchmarks/advection/rotate_shape_dg_weno.prm.bak
 delete mode 100644 benchmarks/advection/rotate_shape_ev.prm.bak
 delete mode 100644 benchmarks/advection/rotate_shape_supg.prm.bak
 delete mode 100644 benchmarks/advection_in_annulus/advection_in_annulus.cc.bak
 delete mode 100644 benchmarks/advection_in_annulus/advection_in_annulus.prm.bak
 delete mode 100644 benchmarks/annulus/instantaneous/annulus.prm.bak
 delete mode 100644 benchmarks/annulus/plugin/annulus.cc.bak
 delete mode 100644 benchmarks/annulus/transient/transient_annulus.prm.bak
 delete mode 100644 benchmarks/blankenbach/base_case1a.prm.bak
 delete mode 100644 benchmarks/blankenbach/base_case1b.prm.bak
 delete mode 100644 benchmarks/blankenbach/base_case1c.prm.bak
 delete mode 100644 benchmarks/blankenbach/base_case2a.prm.bak
 delete mode 100644 benchmarks/blankenbach/base_case2b.prm.bak
 delete mode 100644 benchmarks/blankenbach/plugin/code.cc.bak
 delete mode 100644 benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc.bak
 delete mode 100644 benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.h.bak
 delete mode 100644 benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm.bak
 delete mode 100644 benchmarks/buiter_et_al_2008_jgr/figure_6_1e22.prm.bak
 delete mode 100644 benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm.bak
 delete mode 100644 benchmarks/buiter_et_al_2016_jsg/doc/velocity_bc.part.prm.bak
 delete mode 100644 benchmarks/buiter_et_al_2016_jsg/exp_1.prm.bak
 delete mode 100644 benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm.bak
 delete mode 100644 benchmarks/buiter_et_al_2016_jsg/exp_2_low_resolution.prm.bak
 delete mode 100644 benchmarks/burstedde/burstedde.cc.bak
 delete mode 100644 benchmarks/burstedde/burstedde.prm.bak
 delete mode 100644 benchmarks/burstedde/doc/burstedde.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe/adiabatic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe/ala.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe/hydrostatic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe/isentropic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe/sub_adiabatic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/ala.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/hydrostatic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/isentropic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/ala.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/hydrostatic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/isentropic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density_full_pressure.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/ala.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/hydrostatic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/isentropic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/lateral_pipe_transient/timestep.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc.bak
 delete mode 100644 benchmarks/compressibility_formulations/vertical_pipe/adiabatic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/vertical_pipe/ala.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/vertical_pipe/hydrostatic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/vertical_pipe/isentropic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/vertical_pipe/sub_adiabatic.prm.bak
 delete mode 100644 benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm.bak
 delete mode 100644 benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc.bak
 delete mode 100644 benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm.bak
 delete mode 100644 benchmarks/crameri_et_al/case_1/crameri_benchmark_1_gmg.prm.bak
 delete mode 100644 benchmarks/crameri_et_al/case_2/crameri_benchmark_2.prm.bak
 delete mode 100644 benchmarks/crameri_et_al/doc/crameri_benchmark_1.prm.bak
 delete mode 100644 benchmarks/crameri_et_al/doc/crameri_benchmark_2.prm.bak
 delete mode 100644 benchmarks/davies_et_al/case-1.1.prm.bak
 delete mode 100644 benchmarks/davies_et_al/case-2.1.prm.bak
 delete mode 100644 benchmarks/davies_et_al/case-2.2.prm.bak
 delete mode 100644 benchmarks/davies_et_al/case-2.3-plugin/VoT.cc.bak
 delete mode 100644 benchmarks/davies_et_al/case-2.3.prm.bak
 delete mode 100644 benchmarks/davies_et_al/doc/case-1.1.prm.bak
 delete mode 100644 benchmarks/davies_et_al/doc/case-2.1.prm.bak
 delete mode 100644 benchmarks/davies_et_al/doc/case-2.2.prm.bak
 delete mode 100644 benchmarks/davies_et_al/doc/case-2.3.prm.bak
 delete mode 100644 benchmarks/diffusion_of_hill/1_sine_zero_flux.prm.bak
 delete mode 100644 benchmarks/diffusion_of_hill/2_sine_constant_h.prm.bak
 delete mode 100644 benchmarks/diffusion_of_hill/analytical_topography.cc.bak
 delete mode 100644 benchmarks/diffusion_of_hill/analytical_topography.h.bak
 delete mode 100644 benchmarks/doneahuerta/doneahuerta.cc.bak
 delete mode 100644 benchmarks/doneahuerta/doneahuerta.prm.bak
 delete mode 100644 benchmarks/entropy_adiabat/entropy_adiabat.prm.bak
 delete mode 100644 benchmarks/entropy_adiabat/entropy_combined.prm.bak
 delete mode 100644 benchmarks/entropy_adiabat/entropy_conduction.prm.bak
 delete mode 100644 benchmarks/entropy_adiabat/entropy_half_space.prm.bak
 delete mode 100644 benchmarks/entropy_adiabat/plugins/entropy_advection.cc.bak
 delete mode 100644 benchmarks/entropy_adiabat/plugins/entropy_advection.h.bak
 delete mode 100644 benchmarks/finite_strain/finite_strain.cc.bak
 delete mode 100644 benchmarks/finite_strain/pure_shear.prm.bak
 delete mode 100644 benchmarks/finite_strain/simple_shear.prm.bak
 delete mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm.bak
 delete mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt.prm.bak
 delete mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_unloading.prm.bak
 delete mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading.prm.bak
 delete mode 100644 benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading_fixed_elastic_dt.prm.bak
 delete mode 100644 benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_2D_loading.prm.bak
 delete mode 100644 benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_3D_loading.prm.bak
 delete mode 100644 benchmarks/geoid-spectral-comparison/spectral-comparison.prm.bak
 delete mode 100644 benchmarks/grain_size_pinned_state/grain_size_plunge.prm.bak
 delete mode 100644 benchmarks/gravity_mantle/mantle_gravity.prm.bak
 delete mode 100644 benchmarks/gravity_thick_shell/doc/thick_shell.prm.bak
 delete mode 100644 benchmarks/gravity_thick_shell/thick_shell.prm.bak
 delete mode 100644 benchmarks/gravity_thin_shell/doc/thinshell_a.prm.bak
 delete mode 100644 benchmarks/gravity_thin_shell/doc/thinshell_b.prm.bak
 delete mode 100644 benchmarks/gravity_thin_shell/doc/thinshell_c.prm.bak
 delete mode 100644 benchmarks/gravity_thin_shell/gravity_thin_shell.prm.bak
 delete mode 100644 benchmarks/hollow_sphere/hollow_sphere.cc.bak
 delete mode 100644 benchmarks/hollow_sphere/hollow_sphere.prm.bak
 delete mode 100644 benchmarks/inclusion/adaptive.prm.base.bak
 delete mode 100644 benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.cc.bak
 delete mode 100644 benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.h.bak
 delete mode 100644 benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.prm.bak
 delete mode 100644 benchmarks/inclusion/compositional_fields/inclusion_particles.prm.bak
 delete mode 100644 benchmarks/inclusion/doc/inclusion.prm.bak
 delete mode 100644 benchmarks/inclusion/global.prm.base.bak
 delete mode 100644 benchmarks/inclusion/inclusion.cc.bak
 delete mode 100644 benchmarks/inclusion/inclusion.h.bak
 delete mode 100644 benchmarks/infill_density/infill_ascii.prm.bak
 delete mode 100644 benchmarks/infill_density/infill_ascii_data.cc.bak
 delete mode 100644 benchmarks/king2dcompressible/ala.prm.bak
 delete mode 100644 benchmarks/king2dcompressible/plugin/code.cc.bak
 delete mode 100644 benchmarks/layeredflow/layeredflow.cc.bak
 delete mode 100644 benchmarks/layeredflow/layeredflow.prm.bak
 delete mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm.bak
 delete mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t_gmg.prm.bak
 delete mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm.bak
 delete mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v_gmg.prm.bak
 delete mode 100644 benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc.bak
 delete mode 100644 benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/drucker_prager_compositions.cc.bak
 delete mode 100644 benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/input.prm.bak
 delete mode 100644 benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm.bak
 delete mode 100644 benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm.bak
 delete mode 100644 benchmarks/nsinker/nsinker.cc.bak
 delete mode 100644 benchmarks/nsinker/nsinker.prm.bak
 delete mode 100644 benchmarks/nsinker/nsinker_2d.prm.bak
 delete mode 100644 benchmarks/nsinker/nsinker_bfbt.prm.bak
 delete mode 100644 benchmarks/nsinker/nsinker_gmg.prm.bak
 delete mode 100644 benchmarks/nsinker_spherical_shell/amg.prm.bak
 delete mode 100644 benchmarks/nsinker_spherical_shell/gmg.prm.bak
 delete mode 100644 benchmarks/nsinker_spherical_shell/nsinker.cc.bak
 delete mode 100644 benchmarks/onset-of-convection/convection-box-base.prm.bak
 delete mode 100644 benchmarks/operator_splitting/advection_reaction/advection_reaction.base.prm.bak
 delete mode 100644 benchmarks/operator_splitting/advection_reaction/advection_reaction.cc.bak
 delete mode 100644 benchmarks/operator_splitting/doc/exponential_decay.part.1.prm.bak
 delete mode 100644 benchmarks/operator_splitting/doc/exponential_decay.part.2.prm.bak
 delete mode 100644 benchmarks/operator_splitting/exponential_decay/exponential_decay.base.prm.bak
 delete mode 100644 benchmarks/operator_splitting/exponential_decay/exponential_decay.cc.bak
 delete mode 100644 benchmarks/particle_integration_scheme/circle.prm.bak
 delete mode 100644 benchmarks/particle_integration_scheme/euler.part.prm.bak
 delete mode 100644 benchmarks/particle_integration_scheme/rk2.part.prm.bak
 delete mode 100644 benchmarks/particle_integration_scheme/rk4.part.prm.bak
 delete mode 100644 benchmarks/polydiapirs/polydiapirs.prm.bak
 delete mode 100644 benchmarks/rayleigh_taylor_instability/blank.prm.bak
 delete mode 100644 benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.cc.bak
 delete mode 100644 benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.prm.bak
 delete mode 100644 benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm.bak
 delete mode 100644 benchmarks/rayleigh_taylor_instability_free_surface/rose_rayleigh_taylor_instability.prm.bak
 delete mode 100644 benchmarks/rigid_shear/instantaneous/rigid_shear.prm.bak
 delete mode 100644 benchmarks/rigid_shear/plugin/rigid_shear.cc.bak
 delete mode 100644 benchmarks/rigid_shear/steady-state/rigid_shear.prm.bak
 delete mode 100644 benchmarks/rigid_shear/transient/rigid_shear.prm.bak
 delete mode 100644 benchmarks/shear_bands/magmatic_shear_bands.prm.bak
 delete mode 100644 benchmarks/shear_bands/shear_bands.cc.bak
 delete mode 100644 benchmarks/shear_bands/shear_bands.prm.bak
 delete mode 100644 benchmarks/sinking_block/blank.prm.bak
 delete mode 100644 benchmarks/sinking_block/sinking_block.cc.bak
 delete mode 100644 benchmarks/sinking_block/sinking_block.prm.bak
 delete mode 100644 benchmarks/slab_detachment/slab_detachment.prm.bak
 delete mode 100644 benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc.bak
 delete mode 100644 benchmarks/solcx/compositional_fields/solcx_compositional_fields.h.bak
 delete mode 100644 benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm.bak
 delete mode 100644 benchmarks/solcx/compositional_fields/solcx_particles.prm.bak
 delete mode 100644 benchmarks/solcx/doc/solcx.prm.bak
 delete mode 100644 benchmarks/solcx/solcx.cc.bak
 delete mode 100644 benchmarks/solcx/solcx.h.bak
 delete mode 100644 benchmarks/solcx/solcx.prm.bak
 delete mode 100644 benchmarks/solitary_wave/doc/solitary_wave.prm.bak
 delete mode 100644 benchmarks/solitary_wave/solitary_wave.cc.bak
 delete mode 100644 benchmarks/solitary_wave/solitary_wave.prm.bak
 delete mode 100644 benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc.bak
 delete mode 100644 benchmarks/solkz/compositional_fields/solkz_compositional_fields.h.bak
 delete mode 100644 benchmarks/solkz/compositional_fields/solkz_compositional_fields.prm.bak
 delete mode 100644 benchmarks/solkz/compositional_fields/solkz_particles.prm.bak
 delete mode 100644 benchmarks/solkz/doc/solkz.prm.bak
 delete mode 100644 benchmarks/solkz/solkz.cc.bak
 delete mode 100644 benchmarks/solkz/solkz.h.bak
 delete mode 100644 benchmarks/solkz/solkz.prm.bak
 delete mode 100644 benchmarks/solubility/plugin/solubility.cc.bak
 delete mode 100644 benchmarks/solubility/solubility.prm.bak
 delete mode 100644 benchmarks/tangurnis/ba/tan.prm.bak
 delete mode 100644 benchmarks/tangurnis/code/tangurnis.cc.bak
 delete mode 100644 benchmarks/tangurnis/tala/tan.prm.bak
 delete mode 100644 benchmarks/tangurnis/tala_c/tan.prm.bak
 delete mode 100644 benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc.bak
 delete mode 100644 benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.h.bak
 delete mode 100644 benchmarks/time_dependent_annulus/time_dependent_annulus.prm.bak
 delete mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak
 delete mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak
 delete mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak
 delete mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak
 delete mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak
 delete mode 100644 benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm.bak
 delete mode 100644 benchmarks/tosi_et_al_2015_gcubed/doc/tosi_benchmark_2.prm.bak
 delete mode 100644 benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak
 delete mode 100644 benchmarks/viscoelastic_beam_modified/20km_opentopbot.prm.bak
 delete mode 100644 benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm.bak
 delete mode 100644 benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm.bak
 delete mode 100644 benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_particles.prm.bak
 delete mode 100644 benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm.bak
 delete mode 100644 benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vep.prm.bak
 delete mode 100644 benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm.bak
 delete mode 100644 benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp_damper.prm.bak
 delete mode 100644 benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm.bak
 delete mode 100644 benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm.bak
 delete mode 100644 benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm.bak
 delete mode 100644 benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm.bak
 delete mode 100644 benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm.bak
 delete mode 100644 benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_particles.prm.bak
 delete mode 100644 benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield.prm.bak
 delete mode 100644 benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield_particles.prm.bak
 delete mode 100644 benchmarks/viscosity_grooves/viscosity_grooves.cc.bak
 delete mode 100644 benchmarks/viscosity_grooves/viscosity_grooves.prm.bak
 delete mode 100644 benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.cc.bak
 delete mode 100644 benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.h.bak
 delete mode 100644 benchmarks/yamauchi_takei_2016_anelasticity/yamauchi_takei_2016_anelasticity.prm.bak
 delete mode 100644 benchmarks/zhong_et_al_93/zhong_case1.prm.bak
 delete mode 100644 contrib/opendap/prm_files/aspect_test.prm.bak
 delete mode 100644 contrib/opendap/prm_files/aspect_url_test.prm.bak
 delete mode 100644 contrib/perplex/perplex_lookup_composition.prm.bak
 delete mode 100644 contrib/python/notebooks/read_output_files/convection-box.prm.bak
 delete mode 100644 contrib/world_builder/include/app/main.h.bak
 delete mode 100644 contrib/world_builder/include/glm/glm.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/allocators.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/cursorstreamwrapper.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/encodedstream.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/encodings.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/error/en.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/error/error.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/filereadstream.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/filewritestream.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/fwd.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/biginteger.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/diyfp.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/dtoa.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/ieee754.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/itoa.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/meta.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/pow10.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/regex.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/stack.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/strfunc.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/strtod.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/internal/swap.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/istreamwrapper.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/latexwriter.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/memorybuffer.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/memorystream.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/msinttypes/inttypes.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/msinttypes/stdint.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/mystwriter.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/ostreamwrapper.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/pointer.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/prettywriter.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/rapidjson.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/reader.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/schema.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/stream.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/stringbuffer.h.bak
 delete mode 100644 contrib/world_builder/include/rapidjson/writer.h.bak
 delete mode 100644 contrib/world_builder/include/visualization/main.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/assert.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/bounding_box.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/consts.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/coordinate_system.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/coordinate_systems/cartesian.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/coordinate_systems/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/coordinate_systems/invalid.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/coordinate_systems/spherical.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/deprecate.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/composition/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/composition/random.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/composition/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/grains/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/grains/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/adiabatic.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/linear.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/composition/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/composition/smooth.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/composition/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/grains/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/grains/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/temperature/adiabatic.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/temperature/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/temperature/linear.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/fault_models/temperature/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/feature_utilities.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/adiabatic.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/linear.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/adiabatic.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/half_space_model.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/linear.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/plume.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/plume_models/composition/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/plume_models/composition/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/plume_models/grains/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/plume_models/grains/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/plume_models/temperature/gaussian.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/plume_models/temperature/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/plume_models/temperature/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/smooth.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/adiabatic.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/linear.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/mass_conserving.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/plate_model.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/grains.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/gravity_model/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/gravity_model/uniform.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/kd_tree.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/nan.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/objects/bezier_curve.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/objects/closest_point_on_curve.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/objects/distance_from_surface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/objects/natural_coordinate.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/objects/segment.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/objects/surface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/parameters.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/point.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/array.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/bool.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/double.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/int.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/interface.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/object.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/one_of.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/plugin_system.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/point.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/segment.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/string.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/unsigned_int.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/types/value_at_points.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/utilities.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/world.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/wrapper_c.h.bak
 delete mode 100644 contrib/world_builder/include/world_builder/wrapper_cpp.h.bak
 delete mode 100644 contrib/world_builder/source/gwb-dat/main.cc.bak
 delete mode 100644 contrib/world_builder/source/gwb-grid/main.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/coordinate_systems/cartesian.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/coordinate_systems/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/coordinate_systems/invalid.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/coordinate_systems/spherical.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/composition/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/composition/random.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/composition/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/grains/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/grains/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/adiabatic.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/linear.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/composition/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/composition/smooth.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/composition/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/grains/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/grains/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/temperature/adiabatic.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/temperature/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/temperature/linear.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/fault_models/temperature/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/feature_utilities.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/adiabatic.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/linear.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/adiabatic.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/half_space_model.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/linear.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/plume.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/plume_models/composition/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/plume_models/composition/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/plume_models/grains/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/plume_models/grains/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/plume_models/temperature/gaussian.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/plume_models/temperature/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/plume_models/temperature/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/smooth.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/adiabatic.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/linear.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/mass_conserving.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/plate_model.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/grains.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/gravity_model/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/gravity_model/uniform.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/kd_tree.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/objects/bezier_curve.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/objects/distance_from_surface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/objects/natural_coordinate.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/objects/segment.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/objects/surface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/parameters.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/point.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/array.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/bool.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/double.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/int.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/interface.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/object.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/one_of.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/plugin_system.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/point.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/segment.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/string.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/unsigned_int.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/types/value_at_points.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/utilities.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/world.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/wrapper_c.cc.bak
 delete mode 100644 contrib/world_builder/source/world_builder/wrapper_cpp.cc.bak
 delete mode 100644 contrib/world_builder/tests/unit_tests/bounding_box.cc.bak
 delete mode 100644 contrib/world_builder/tests/unit_tests/gwb_gravity.cc.bak
 delete mode 100644 contrib/world_builder/tests/unit_tests/kd_tree.cc.bak
 delete mode 100644 contrib/world_builder/tests/unit_tests/main.cc.bak
 delete mode 100644 contrib/world_builder/tests/unit_tests/unit_test_wb_glm.cc.bak
 delete mode 100644 contrib/world_builder/tests/unit_tests/unit_test_world_builder.cc.bak
 delete mode 100644 cookbooks/2d_annulus_visualization/2d_annulus_example.prm.bak
 delete mode 100644 cookbooks/allken_et_al_2012_rift_interaction/allken.prm.bak
 delete mode 100644 cookbooks/anisotropic_viscosity/AV_Rayleigh_Taylor.prm.bak
 delete mode 100644 cookbooks/anisotropic_viscosity/av_material.cc.bak
 delete mode 100644 cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm.bak
 delete mode 100644 cookbooks/burnman/burnman.prm.bak
 delete mode 100644 cookbooks/burnman/doc/adiabatic_conditions.part.prm.bak
 delete mode 100644 cookbooks/burnman/doc/formulation.part.prm.bak
 delete mode 100644 cookbooks/burnman/doc/formulation_ica.part.prm.bak
 delete mode 100644 cookbooks/burnman/doc/gravity_model.part.prm.bak
 delete mode 100644 cookbooks/burnman/doc/material_model.part.prm.bak
 delete mode 100644 cookbooks/burnman/doc/tala.part.prm.bak
 delete mode 100644 cookbooks/christensen_yuen_phase_function/christensen_yuen_phase_function.prm.bak
 delete mode 100644 cookbooks/christensen_yuen_phase_function/doc/material.part.prm.bak
 delete mode 100644 cookbooks/composition-reaction/composition-reaction.prm.bak
 delete mode 100644 cookbooks/composition-reaction/doc/initial.part.prm.bak
 delete mode 100644 cookbooks/composition-reaction/doc/material.part.prm.bak
 delete mode 100644 cookbooks/composition_active/composition_active.prm.bak
 delete mode 100644 cookbooks/composition_active/doc/active.part.prm.bak
 delete mode 100644 cookbooks/composition_active/doc/postprocess.part.prm.bak
 delete mode 100644 cookbooks/composition_active_particles/composition_active_particles.prm.bak
 delete mode 100644 cookbooks/composition_active_particles/doc/composition.part.prm.bak
 delete mode 100644 cookbooks/composition_active_particles/doc/particles.part.prm.bak
 delete mode 100644 cookbooks/composition_passive/composition_passive.prm.bak
 delete mode 100644 cookbooks/composition_passive/doc/passive.part.prm.bak
 delete mode 100644 cookbooks/composition_passive/doc/postprocess.part.prm.bak
 delete mode 100644 cookbooks/composition_passive_particles/composition_passive_particles.prm.bak
 delete mode 100644 cookbooks/composition_passive_particles/composition_passive_particles_properties.prm.bak
 delete mode 100644 cookbooks/composition_passive_particles/doc/particle-properties.part.prm.bak
 delete mode 100644 cookbooks/composition_passive_particles/doc/particles.part.prm.bak
 delete mode 100644 cookbooks/continental_extension/continental_extension.prm.bak
 delete mode 100644 cookbooks/continental_extension/doc/continental_extension_boundary_conditions.prm.bak
 delete mode 100644 cookbooks/continental_extension/doc/continental_extension_composition.prm.bak
 delete mode 100644 cookbooks/continental_extension/doc/continental_extension_geometry_mesh.prm.bak
 delete mode 100644 cookbooks/continental_extension/doc/continental_extension_material_model.prm.bak
 delete mode 100644 cookbooks/convection-box-particles/convection-box-particles.prm.bak
 delete mode 100644 cookbooks/convection-box/convection-box.prm.bak
 delete mode 100644 cookbooks/convection-box/doc/disc.part.prm.bak
 delete mode 100644 cookbooks/convection-box/doc/gravity.part.prm.bak
 delete mode 100644 cookbooks/convection-box/doc/refine.part.prm.bak
 delete mode 100644 cookbooks/convection-box/doc/refine2.part.prm.bak
 delete mode 100644 cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box.prm.bak
 delete mode 100644 cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box2.prm.bak
 delete mode 100644 cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm.bak
 delete mode 100644 cookbooks/convection_box_3d/convection_box_3d.prm.bak
 delete mode 100644 cookbooks/convection_box_3d/doc/amr.part.prm.bak
 delete mode 100644 cookbooks/convection_box_3d/doc/checkpoint.part.prm.bak
 delete mode 100644 cookbooks/convection_box_3d/doc/gravity.part.prm.bak
 delete mode 100644 cookbooks/convection_box_3d/doc/initial.part.prm.bak
 delete mode 100644 cookbooks/convection_box_3d/doc/postprocess.part.prm.bak
 delete mode 100644 cookbooks/convection_box_3d/doc/start.part.prm.bak
 delete mode 100644 cookbooks/crustal_deformation/crustal_model_2D.prm.bak
 delete mode 100644 cookbooks/crustal_deformation/crustal_model_3D.prm.bak
 delete mode 100644 cookbooks/crustal_deformation/doc/crustal_model_2D_part1.prm.bak
 delete mode 100644 cookbooks/crustal_deformation/doc/crustal_model_2D_part2.prm.bak
 delete mode 100644 cookbooks/crustal_deformation/doc/crustal_model_2D_part3.prm.bak
 delete mode 100644 cookbooks/crustal_deformation/doc/crustal_model_2D_part4.prm.bak
 delete mode 100644 cookbooks/crustal_deformation/doc/crustal_model_3D_part1.prm.bak
 delete mode 100644 cookbooks/fastscape_eroding_box/fastscape_eroding_box.prm.bak
 delete mode 100644 cookbooks/finite_strain/doc/finite_strain.part.prm.bak
 delete mode 100644 cookbooks/finite_strain/finite_strain.cc.bak
 delete mode 100644 cookbooks/finite_strain/finite_strain.prm.bak
 delete mode 100644 cookbooks/free_surface/doc/free_surface.part.prm.bak
 delete mode 100644 cookbooks/free_surface/free_surface.prm.bak
 delete mode 100644 cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part1.prm.bak
 delete mode 100644 cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part2.prm.bak
 delete mode 100644 cookbooks/free_surface_with_crust/free_surface_with_crust.prm.bak
 delete mode 100644 cookbooks/free_surface_with_crust/plugin/simpler_with_crust.cc.bak
 delete mode 100644 cookbooks/future/mantle_setup_restart.prm.bak
 delete mode 100644 cookbooks/future/mantle_setup_start.prm.bak
 delete mode 100644 cookbooks/future/net_rotation.prm.bak
 delete mode 100644 cookbooks/future/periodic_box.prm.bak
 delete mode 100644 cookbooks/future/radiogenic_heating.prm.bak
 delete mode 100644 cookbooks/future/radiogenic_heating_function.prm.bak
 delete mode 100644 cookbooks/future/sphere.prm.bak
 delete mode 100644 cookbooks/geomio/doc/geomIO.prm.bak
 delete mode 100644 cookbooks/geomio/geomIO.prm.bak
 delete mode 100644 cookbooks/global_melt/doc/global_melt.prm.bak
 delete mode 100644 cookbooks/global_melt/doc/global_no_melt.prm.bak
 delete mode 100644 cookbooks/global_melt/global_melt.prm.bak
 delete mode 100644 cookbooks/global_melt/global_no_melt.prm.bak
 delete mode 100644 cookbooks/gplates/doc/gplates.part.prm.bak
 delete mode 100644 cookbooks/gplates/doc/slice1.part.prm.bak
 delete mode 100644 cookbooks/gplates/doc/slice2.part.prm.bak
 delete mode 100644 cookbooks/gplates/gplates_2d.prm.bak
 delete mode 100644 cookbooks/gplates/gplates_3d.prm.bak
 delete mode 100644 cookbooks/grain_size_ridge/doc/fields.part.prm.bak
 delete mode 100644 cookbooks/grain_size_ridge/doc/material_model.part.prm.bak
 delete mode 100644 cookbooks/grain_size_ridge/doc/particles.part.prm.bak
 delete mode 100644 cookbooks/grain_size_ridge/grain_size_ridge.prm.bak
 delete mode 100644 cookbooks/heat_flow/heat-flow-plume.prm.bak
 delete mode 100644 cookbooks/heat_flow/heat-flow-terms.prm.bak
 delete mode 100644 cookbooks/heat_flow/heat-flow.prm.bak
 delete mode 100644 cookbooks/inclusions/ellipse_pure_shear.prm.bak
 delete mode 100644 cookbooks/inclusions/ellipse_pure_shear_nonlinear.prm.bak
 delete mode 100644 cookbooks/inclusions/ellipse_ref.prm.bak
 delete mode 100644 cookbooks/inclusions/ellipse_simple_shear.prm.bak
 delete mode 100644 cookbooks/inclusions/rectangle_pure_shear.prm.bak
 delete mode 100644 cookbooks/inclusions/rectangle_ref.prm.bak
 delete mode 100644 cookbooks/inclusions/rectangle_simple_shear.prm.bak
 delete mode 100644 cookbooks/initial-condition-S20RTS/S20RTS.prm.bak
 delete mode 100644 cookbooks/initial-condition-S20RTS/doc/S20RTS.part.prm.bak
 delete mode 100644 cookbooks/inner_core_convection/doc/inner_core_traction.part.1.prm.bak
 delete mode 100644 cookbooks/inner_core_convection/doc/inner_core_traction.part.2.prm.bak
 delete mode 100644 cookbooks/inner_core_convection/doc/inner_core_traction.part.3.prm.bak
 delete mode 100644 cookbooks/inner_core_convection/inner_core_assembly.cc.bak
 delete mode 100644 cookbooks/inner_core_convection/inner_core_convection.cc.bak
 delete mode 100644 cookbooks/inner_core_convection/inner_core_traction.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.h.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_compositions.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_materialmodel.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_meshrefinement.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case1_velocity.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case2a_materialmodel.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case2a_temperatures.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/doc/Case2b_materialmodel.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/isotherm_depth.h.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2b.prm.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.h.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/trench_location.cc.bak
 delete mode 100644 cookbooks/kinematically_driven_subduction_2d/trench_location.h.bak
 delete mode 100644 cookbooks/latent-heat/doc/material.part.prm.bak
 delete mode 100644 cookbooks/latent-heat/latent-heat.prm.bak
 delete mode 100644 cookbooks/lower_crustal_flow/lower_crustal_flow_obstacle.prm.bak
 delete mode 100644 cookbooks/magnetic_stripes/magnetic_stripes.cc.bak
 delete mode 100644 cookbooks/magnetic_stripes/magnetic_stripes.prm.bak
 delete mode 100644 cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm.bak
 delete mode 100644 cookbooks/mid_ocean_ridge/doc/boundary_conditions.part.prm.bak
 delete mode 100644 cookbooks/mid_ocean_ridge/doc/compaction_length.part.prm.bak
 delete mode 100644 cookbooks/mid_ocean_ridge/doc/melting_and_freezing.part.prm.bak
 delete mode 100644 cookbooks/mid_ocean_ridge/doc/mesh_refinement.part.prm.bak
 delete mode 100644 cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm.bak
 delete mode 100644 cookbooks/morency_doin_2004/doc/morency_doin.part.prm.bak
 delete mode 100644 cookbooks/morency_doin_2004/morency_doin.cc.bak
 delete mode 100644 cookbooks/morency_doin_2004/morency_doin.h.bak
 delete mode 100644 cookbooks/morency_doin_2004/morency_doin.prm.bak
 delete mode 100644 cookbooks/multicomponent_steinberger/doc/comp.field.prm.bak
 delete mode 100644 cookbooks/multicomponent_steinberger/doc/comp.setup.prm.bak
 delete mode 100644 cookbooks/multicomponent_steinberger/doc/conductivity.setup.prm.bak
 delete mode 100644 cookbooks/multicomponent_steinberger/doc/lookup.part.prm.bak
 delete mode 100644 cookbooks/multicomponent_steinberger/doc/temperature.setup.prm.bak
 delete mode 100644 cookbooks/multicomponent_steinberger/steinberger_thermochemical_plume.prm.bak
 delete mode 100644 cookbooks/muparser_temperature_example/doc/check-initial-condition.part.prm.bak
 delete mode 100644 cookbooks/muparser_temperature_example/doc/mesh-refinement.part.prm.bak
 delete mode 100644 cookbooks/muparser_temperature_example/doc/repetitions.part.prm.bak
 delete mode 100644 cookbooks/muparser_temperature_example/doc/temperature.part.prm.bak
 delete mode 100644 cookbooks/muparser_temperature_example/muparser-temperature-example.prm.bak
 delete mode 100644 cookbooks/onset_of_convection/onset_of_convection.prm.bak
 delete mode 100644 cookbooks/platelike-boundary/doc/boundary.part.prm.bak
 delete mode 100644 cookbooks/platelike-boundary/doc/platelike.prm.bak
 delete mode 100644 cookbooks/platelike-boundary/platelike-boundary.prm.bak
 delete mode 100644 cookbooks/plume_2D_chunk/opening_angle_45degrees.prm.bak
 delete mode 100644 cookbooks/plume_2D_chunk/opening_angle_90degrees.prm.bak
 delete mode 100644 cookbooks/plume_2D_chunk/plume2D.prm.bak
 delete mode 100644 cookbooks/plume_2D_chunk/strongly_temperature_dependent.prm.bak
 delete mode 100644 cookbooks/plume_2D_chunk/weakly_temperature_dependent.prm.bak
 delete mode 100644 cookbooks/prescribed_velocity/circle.prm.bak
 delete mode 100644 cookbooks/prescribed_velocity/corner_flow.prm.bak
 delete mode 100644 cookbooks/prescribed_velocity/doc/minimal.prm.bak
 delete mode 100644 cookbooks/prescribed_velocity/prescribed_velocity.cc.bak
 delete mode 100644 cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.0.out.bak
 delete mode 100644 cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.1.out.bak
 delete mode 100644 cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.2.out.bak
 delete mode 100644 cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.cc.bak
 delete mode 100644 cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.prm.bak
 delete mode 100644 cookbooks/shell_3d_postprocess/doc/shell_3d_postprocess.part.prm.bak
 delete mode 100644 cookbooks/shell_3d_postprocess/shell_3d_postprocess.prm.bak
 delete mode 100644 cookbooks/shell_simple_2d/doc/shearheat.part.prm.bak
 delete mode 100644 cookbooks/shell_simple_2d/doc/shell.prm.bak
 delete mode 100644 cookbooks/shell_simple_2d/shell_simple_2d.prm.bak
 delete mode 100644 cookbooks/shell_simple_2d_smoothing/doc/shell_simple_2d_smoothing.part.prm.bak
 delete mode 100644 cookbooks/shell_simple_2d_smoothing/shell_simple_2d_smoothing.prm.bak
 delete mode 100644 cookbooks/shell_simple_3d/doc/amr.part.prm.bak
 delete mode 100644 cookbooks/shell_simple_3d/doc/checkpoint.part.prm.bak
 delete mode 100644 cookbooks/shell_simple_3d/doc/part1.part.prm.bak
 delete mode 100644 cookbooks/shell_simple_3d/doc/part2.part.prm.bak
 delete mode 100644 cookbooks/shell_simple_3d/doc/part3.part.prm.bak
 delete mode 100644 cookbooks/shell_simple_3d/doc/part4.part.prm.bak
 delete mode 100644 cookbooks/shell_simple_3d/doc/postprocess.part.prm.bak
 delete mode 100644 cookbooks/shell_simple_3d/shell_simple_3d.prm.bak
 delete mode 100644 cookbooks/sinker-with-averaging/doc/conservative.prm.bak
 delete mode 100644 cookbooks/sinker-with-averaging/doc/full.prm.bak
 delete mode 100644 cookbooks/sinker-with-averaging/doc/harmonic.prm.bak
 delete mode 100644 cookbooks/sinker-with-averaging/sinker-with-averaging.prm.bak
 delete mode 100644 cookbooks/steinberger/doc/geometry.part.prm.bak
 delete mode 100644 cookbooks/steinberger/doc/lookup.part.prm.bak
 delete mode 100644 cookbooks/steinberger/doc/nullspace.part.prm.bak
 delete mode 100644 cookbooks/steinberger/doc/projected_density.part.prm.bak
 delete mode 100644 cookbooks/steinberger/doc/rheology.part.prm.bak
 delete mode 100644 cookbooks/steinberger/doc/rheology2.part.prm.bak
 delete mode 100644 cookbooks/steinberger/steinberger.prm.bak
 delete mode 100644 cookbooks/stokes/doc/stokeslaw.prm.bak
 delete mode 100644 cookbooks/stokes/stokes.prm.bak
 delete mode 100644 cookbooks/subduction_initiation/subduction_initiation.prm.base.bak
 delete mode 100644 cookbooks/subduction_initiation/subduction_initiation_compositional_fields.prm.bak
 delete mode 100644 cookbooks/subduction_initiation/subduction_initiation_particle_in_cell.prm.bak
 delete mode 100644 cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
 delete mode 100644 cookbooks/tian_parameterization_kinematic_slab/uncoupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
 delete mode 100644 cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm.bak
 delete mode 100644 cookbooks/tomography_based_plate_motions/doc/tomography_based_plate_motions.part.prm.bak
 delete mode 100644 cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc.bak
 delete mode 100644 cookbooks/tomography_based_plate_motions/plugins/reference_profile.h.bak
 delete mode 100644 cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc.bak
 delete mode 100644 cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.h.bak
 delete mode 100644 cookbooks/transform_fault_behn_2007/doc/material.part.prm.bak
 delete mode 100644 cookbooks/transform_fault_behn_2007/doc/temperature.part.prm.bak
 delete mode 100644 cookbooks/transform_fault_behn_2007/temperature_dependent.prm.bak
 delete mode 100644 cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm.bak
 delete mode 100644 cookbooks/van-keken-vof/doc/amr.part.prm.bak
 delete mode 100644 cookbooks/van-keken-vof/doc/main.part.prm.bak
 delete mode 100644 cookbooks/van-keken-vof/doc/postprocess.part.prm.bak
 delete mode 100644 cookbooks/van-keken-vof/doc/variation.part.prm.bak
 delete mode 100644 cookbooks/van-keken-vof/van-keken-vof.prm.bak
 delete mode 100644 cookbooks/van-keken/doc/main.part.prm.bak
 delete mode 100644 cookbooks/van-keken/doc/postprocess.part.prm.bak
 delete mode 100644 cookbooks/van-keken/doc/smooth.part.prm.bak
 delete mode 100644 cookbooks/van-keken/van-keken-discontinuous.prm.bak
 delete mode 100644 cookbooks/van-keken/van-keken-smooth.prm.bak
 delete mode 100644 cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc.bak
 delete mode 100644 cookbooks/vankeken_subduction/vankeken_corner_flow.prm.bak
 delete mode 100644 cookbooks/visualizing_phase_diagram/doc/harzburgite.prm.bak
 delete mode 100644 cookbooks/visualizing_phase_diagram/doc/material_model.prm.bak
 delete mode 100644 cookbooks/visualizing_phase_diagram/doc/steinberg.prm.bak
 delete mode 100644 cookbooks/visualizing_phase_diagram/visualizing_phase_diagram.prm.bak
 delete mode 100644 doc/logo/logo.prm.bak
 delete mode 100644 doc/manual/cookbooks/overview/doc/boundary-conditions.part.prm.bak
 delete mode 100644 doc/manual/cookbooks/overview/doc/dim.part.prm.bak
 delete mode 100644 doc/manual/cookbooks/overview/doc/geometry.part.prm.bak
 delete mode 100644 doc/manual/cookbooks/overview/doc/gmg-average.part.prm.bak
 delete mode 100644 doc/manual/cookbooks/overview/doc/gmg-enable.part.prm.bak
 delete mode 100644 doc/manual/cookbooks/overview/doc/simple.prm.bak
 delete mode 100644 doc/manual/cookbooks/overview/doc/structure.part.prm.bak
 delete mode 100644 doc/manual/empty.prm.bak
 delete mode 100644 include/aspect/adiabatic_conditions/ascii_data.h.bak
 delete mode 100644 include/aspect/adiabatic_conditions/compute_entropy_profile.h.bak
 delete mode 100644 include/aspect/adiabatic_conditions/compute_profile.h.bak
 delete mode 100644 include/aspect/adiabatic_conditions/function.h.bak
 delete mode 100644 include/aspect/adiabatic_conditions/interface.h.bak
 delete mode 100644 include/aspect/boundary_composition/ascii_data.h.bak
 delete mode 100644 include/aspect/boundary_composition/box.h.bak
 delete mode 100644 include/aspect/boundary_composition/function.h.bak
 delete mode 100644 include/aspect/boundary_composition/initial_composition.h.bak
 delete mode 100644 include/aspect/boundary_composition/interface.h.bak
 delete mode 100644 include/aspect/boundary_composition/spherical_constant.h.bak
 delete mode 100644 include/aspect/boundary_composition/two_merged_boxes.h.bak
 delete mode 100644 include/aspect/boundary_fluid_pressure/density.h.bak
 delete mode 100644 include/aspect/boundary_fluid_pressure/interface.h.bak
 delete mode 100644 include/aspect/boundary_heat_flux/function.h.bak
 delete mode 100644 include/aspect/boundary_heat_flux/interface.h.bak
 delete mode 100644 include/aspect/boundary_temperature/ascii_data.h.bak
 delete mode 100644 include/aspect/boundary_temperature/box.h.bak
 delete mode 100644 include/aspect/boundary_temperature/constant.h.bak
 delete mode 100644 include/aspect/boundary_temperature/dynamic_core.h.bak
 delete mode 100644 include/aspect/boundary_temperature/function.h.bak
 delete mode 100644 include/aspect/boundary_temperature/initial_temperature.h.bak
 delete mode 100644 include/aspect/boundary_temperature/interface.h.bak
 delete mode 100644 include/aspect/boundary_temperature/spherical_constant.h.bak
 delete mode 100644 include/aspect/boundary_temperature/two_merged_boxes.h.bak
 delete mode 100644 include/aspect/boundary_traction/ascii_data.h.bak
 delete mode 100644 include/aspect/boundary_traction/function.h.bak
 delete mode 100644 include/aspect/boundary_traction/initial_lithostatic_pressure.h.bak
 delete mode 100644 include/aspect/boundary_traction/interface.h.bak
 delete mode 100644 include/aspect/boundary_traction/zero_traction.h.bak
 delete mode 100644 include/aspect/boundary_velocity/ascii_data.h.bak
 delete mode 100644 include/aspect/boundary_velocity/function.h.bak
 delete mode 100644 include/aspect/boundary_velocity/gplates.h.bak
 delete mode 100644 include/aspect/boundary_velocity/interface.h.bak
 delete mode 100644 include/aspect/boundary_velocity/zero_velocity.h.bak
 delete mode 100644 include/aspect/citation_info.h.bak
 delete mode 100644 include/aspect/compat.h.bak
 delete mode 100644 include/aspect/coordinate_systems.h.bak
 delete mode 100644 include/aspect/fe_variable_collection.h.bak
 delete mode 100644 include/aspect/geometry_model/box.h.bak
 delete mode 100644 include/aspect/geometry_model/chunk.h.bak
 delete mode 100644 include/aspect/geometry_model/ellipsoidal_chunk.h.bak
 delete mode 100644 include/aspect/geometry_model/initial_topography_model/ascii_data.h.bak
 delete mode 100644 include/aspect/geometry_model/initial_topography_model/function.h.bak
 delete mode 100644 include/aspect/geometry_model/initial_topography_model/interface.h.bak
 delete mode 100644 include/aspect/geometry_model/initial_topography_model/prm_polygon.h.bak
 delete mode 100644 include/aspect/geometry_model/initial_topography_model/zero_topography.h.bak
 delete mode 100644 include/aspect/geometry_model/interface.h.bak
 delete mode 100644 include/aspect/geometry_model/sphere.h.bak
 delete mode 100644 include/aspect/geometry_model/spherical_shell.h.bak
 delete mode 100644 include/aspect/geometry_model/two_merged_boxes.h.bak
 delete mode 100644 include/aspect/geometry_model/two_merged_chunks.h.bak
 delete mode 100644 include/aspect/global.h.bak
 delete mode 100644 include/aspect/gravity_model/ascii_data.h.bak
 delete mode 100644 include/aspect/gravity_model/function.h.bak
 delete mode 100644 include/aspect/gravity_model/interface.h.bak
 delete mode 100644 include/aspect/gravity_model/radial.h.bak
 delete mode 100644 include/aspect/gravity_model/vertical.h.bak
 delete mode 100644 include/aspect/heating_model/adiabatic_heating.h.bak
 delete mode 100644 include/aspect/heating_model/adiabatic_heating_of_melt.h.bak
 delete mode 100644 include/aspect/heating_model/compositional_heating.h.bak
 delete mode 100644 include/aspect/heating_model/constant_heating.h.bak
 delete mode 100644 include/aspect/heating_model/function.h.bak
 delete mode 100644 include/aspect/heating_model/interface.h.bak
 delete mode 100644 include/aspect/heating_model/latent_heat.h.bak
 delete mode 100644 include/aspect/heating_model/latent_heat_melt.h.bak
 delete mode 100644 include/aspect/heating_model/radioactive_decay.h.bak
 delete mode 100644 include/aspect/heating_model/shear_heating.h.bak
 delete mode 100644 include/aspect/heating_model/shear_heating_with_melt.h.bak
 delete mode 100644 include/aspect/initial_composition/adiabatic_density.h.bak
 delete mode 100644 include/aspect/initial_composition/ascii_data.h.bak
 delete mode 100644 include/aspect/initial_composition/ascii_data_layered.h.bak
 delete mode 100644 include/aspect/initial_composition/entropy_table_lookup.h.bak
 delete mode 100644 include/aspect/initial_composition/function.h.bak
 delete mode 100644 include/aspect/initial_composition/interface.h.bak
 delete mode 100644 include/aspect/initial_composition/porosity.h.bak
 delete mode 100644 include/aspect/initial_composition/slab_model.h.bak
 delete mode 100644 include/aspect/initial_composition/world_builder.h.bak
 delete mode 100644 include/aspect/initial_temperature/S40RTS_perturbation.h.bak
 delete mode 100644 include/aspect/initial_temperature/SAVANI_perturbation.h.bak
 delete mode 100644 include/aspect/initial_temperature/adiabatic.h.bak
 delete mode 100644 include/aspect/initial_temperature/adiabatic_boundary.h.bak
 delete mode 100644 include/aspect/initial_temperature/ascii_data.h.bak
 delete mode 100644 include/aspect/initial_temperature/ascii_data_layered.h.bak
 delete mode 100644 include/aspect/initial_temperature/ascii_profile.h.bak
 delete mode 100644 include/aspect/initial_temperature/box.h.bak
 delete mode 100644 include/aspect/initial_temperature/continental_geotherm.h.bak
 delete mode 100644 include/aspect/initial_temperature/function.h.bak
 delete mode 100644 include/aspect/initial_temperature/harmonic_perturbation.h.bak
 delete mode 100644 include/aspect/initial_temperature/interface.h.bak
 delete mode 100644 include/aspect/initial_temperature/lithosphere_mask.h.bak
 delete mode 100644 include/aspect/initial_temperature/patch_on_S40RTS.h.bak
 delete mode 100644 include/aspect/initial_temperature/prescribed_temperature.h.bak
 delete mode 100644 include/aspect/initial_temperature/random_gaussian_perturbation.h.bak
 delete mode 100644 include/aspect/initial_temperature/spherical_shell.h.bak
 delete mode 100644 include/aspect/initial_temperature/world_builder.h.bak
 delete mode 100644 include/aspect/introspection.h.bak
 delete mode 100644 include/aspect/lateral_averaging.h.bak
 delete mode 100644 include/aspect/material_model/ascii_reference_profile.h.bak
 delete mode 100644 include/aspect/material_model/averaging.h.bak
 delete mode 100644 include/aspect/material_model/compositing.h.bak
 delete mode 100644 include/aspect/material_model/composition_reaction.h.bak
 delete mode 100644 include/aspect/material_model/depth_dependent.h.bak
 delete mode 100644 include/aspect/material_model/diffusion_dislocation.h.bak
 delete mode 100644 include/aspect/material_model/drucker_prager.h.bak
 delete mode 100644 include/aspect/material_model/entropy_model.h.bak
 delete mode 100644 include/aspect/material_model/equation_of_state/interface.h.bak
 delete mode 100644 include/aspect/material_model/equation_of_state/linearized_incompressible.h.bak
 delete mode 100644 include/aspect/material_model/equation_of_state/multicomponent_compressible.h.bak
 delete mode 100644 include/aspect/material_model/equation_of_state/multicomponent_incompressible.h.bak
 delete mode 100644 include/aspect/material_model/equation_of_state/thermodynamic_table_lookup.h.bak
 delete mode 100644 include/aspect/material_model/grain_size.h.bak
 delete mode 100644 include/aspect/material_model/interface.h.bak
 delete mode 100644 include/aspect/material_model/latent_heat.h.bak
 delete mode 100644 include/aspect/material_model/latent_heat_melt.h.bak
 delete mode 100644 include/aspect/material_model/melt_boukare.h.bak
 delete mode 100644 include/aspect/material_model/melt_global.h.bak
 delete mode 100644 include/aspect/material_model/melt_simple.h.bak
 delete mode 100644 include/aspect/material_model/modified_tait.h.bak
 delete mode 100644 include/aspect/material_model/multicomponent.h.bak
 delete mode 100644 include/aspect/material_model/multicomponent_compressible.h.bak
 delete mode 100644 include/aspect/material_model/nondimensional.h.bak
 delete mode 100644 include/aspect/material_model/perplex_lookup.h.bak
 delete mode 100644 include/aspect/material_model/prescribed_viscosity.h.bak
 delete mode 100644 include/aspect/material_model/reaction_model/katz2003_mantle_melting.h.bak
 delete mode 100644 include/aspect/material_model/reactive_fluid_transport.h.bak
 delete mode 100644 include/aspect/material_model/replace_lithosphere_viscosity.h.bak
 delete mode 100644 include/aspect/material_model/rheology/ascii_depth_profile.h.bak
 delete mode 100644 include/aspect/material_model/rheology/composite_visco_plastic.h.bak
 delete mode 100644 include/aspect/material_model/rheology/compositional_viscosity_prefactors.h.bak
 delete mode 100644 include/aspect/material_model/rheology/constant_viscosity.h.bak
 delete mode 100644 include/aspect/material_model/rheology/constant_viscosity_prefactors.h.bak
 delete mode 100644 include/aspect/material_model/rheology/diffusion_creep.h.bak
 delete mode 100644 include/aspect/material_model/rheology/diffusion_dislocation.h.bak
 delete mode 100644 include/aspect/material_model/rheology/dislocation_creep.h.bak
 delete mode 100644 include/aspect/material_model/rheology/drucker_prager.h.bak
 delete mode 100644 include/aspect/material_model/rheology/elasticity.h.bak
 delete mode 100644 include/aspect/material_model/rheology/frank_kamenetskii.h.bak
 delete mode 100644 include/aspect/material_model/rheology/friction_models.h.bak
 delete mode 100644 include/aspect/material_model/rheology/peierls_creep.h.bak
 delete mode 100644 include/aspect/material_model/rheology/strain_dependent.h.bak
 delete mode 100644 include/aspect/material_model/rheology/visco_plastic.h.bak
 delete mode 100644 include/aspect/material_model/simple.h.bak
 delete mode 100644 include/aspect/material_model/simple_compressible.h.bak
 delete mode 100644 include/aspect/material_model/simpler.h.bak
 delete mode 100644 include/aspect/material_model/steinberger.h.bak
 delete mode 100644 include/aspect/material_model/utilities.h.bak
 delete mode 100644 include/aspect/material_model/visco_plastic.h.bak
 delete mode 100644 include/aspect/material_model/viscoelastic.h.bak
 delete mode 100644 include/aspect/melt.h.bak
 delete mode 100644 include/aspect/mesh_deformation/ascii_data.h.bak
 delete mode 100644 include/aspect/mesh_deformation/diffusion.h.bak
 delete mode 100644 include/aspect/mesh_deformation/fastscape.h.bak
 delete mode 100644 include/aspect/mesh_deformation/free_surface.h.bak
 delete mode 100644 include/aspect/mesh_deformation/function.h.bak
 delete mode 100644 include/aspect/mesh_deformation/interface.h.bak
 delete mode 100644 include/aspect/mesh_refinement/artificial_viscosity.h.bak
 delete mode 100644 include/aspect/mesh_refinement/boundary.h.bak
 delete mode 100644 include/aspect/mesh_refinement/compaction_length.h.bak
 delete mode 100644 include/aspect/mesh_refinement/composition.h.bak
 delete mode 100644 include/aspect/mesh_refinement/composition_approximate_gradient.h.bak
 delete mode 100644 include/aspect/mesh_refinement/composition_gradient.h.bak
 delete mode 100644 include/aspect/mesh_refinement/composition_threshold.h.bak
 delete mode 100644 include/aspect/mesh_refinement/density.h.bak
 delete mode 100644 include/aspect/mesh_refinement/interface.h.bak
 delete mode 100644 include/aspect/mesh_refinement/isosurfaces.h.bak
 delete mode 100644 include/aspect/mesh_refinement/maximum_refinement_function.h.bak
 delete mode 100644 include/aspect/mesh_refinement/minimum_refinement_function.h.bak
 delete mode 100644 include/aspect/mesh_refinement/nonadiabatic_temperature.h.bak
 delete mode 100644 include/aspect/mesh_refinement/nonadiabatic_temperature_threshold.h.bak
 delete mode 100644 include/aspect/mesh_refinement/particle_density.h.bak
 delete mode 100644 include/aspect/mesh_refinement/slope.h.bak
 delete mode 100644 include/aspect/mesh_refinement/strain_rate.h.bak
 delete mode 100644 include/aspect/mesh_refinement/temperature.h.bak
 delete mode 100644 include/aspect/mesh_refinement/thermal_energy_density.h.bak
 delete mode 100644 include/aspect/mesh_refinement/topography.h.bak
 delete mode 100644 include/aspect/mesh_refinement/velocity.h.bak
 delete mode 100644 include/aspect/mesh_refinement/viscosity.h.bak
 delete mode 100644 include/aspect/mesh_refinement/volume_of_fluid_interface.h.bak
 delete mode 100644 include/aspect/newton.h.bak
 delete mode 100644 include/aspect/parameters.h.bak
 delete mode 100644 include/aspect/particle/generator/ascii_file.h.bak
 delete mode 100644 include/aspect/particle/generator/interface.h.bak
 delete mode 100644 include/aspect/particle/generator/probability_density_function.h.bak
 delete mode 100644 include/aspect/particle/generator/quadrature_points.h.bak
 delete mode 100644 include/aspect/particle/generator/random_uniform.h.bak
 delete mode 100644 include/aspect/particle/generator/reference_cell.h.bak
 delete mode 100644 include/aspect/particle/generator/uniform_box.h.bak
 delete mode 100644 include/aspect/particle/generator/uniform_radial.h.bak
 delete mode 100644 include/aspect/particle/integrator/euler.h.bak
 delete mode 100644 include/aspect/particle/integrator/interface.h.bak
 delete mode 100644 include/aspect/particle/integrator/rk_2.h.bak
 delete mode 100644 include/aspect/particle/integrator/rk_4.h.bak
 delete mode 100644 include/aspect/particle/interface.h.bak
 delete mode 100644 include/aspect/particle/interpolator/bilinear_least_squares.h.bak
 delete mode 100644 include/aspect/particle/interpolator/cell_average.h.bak
 delete mode 100644 include/aspect/particle/interpolator/harmonic_average.h.bak
 delete mode 100644 include/aspect/particle/interpolator/interface.h.bak
 delete mode 100644 include/aspect/particle/interpolator/nearest_neighbor.h.bak
 delete mode 100644 include/aspect/particle/interpolator/quadratic_least_squares.h.bak
 delete mode 100644 include/aspect/particle/property/composition.h.bak
 delete mode 100644 include/aspect/particle/property/cpo_bingham_average.h.bak
 delete mode 100644 include/aspect/particle/property/cpo_elastic_tensor.h.bak
 delete mode 100644 include/aspect/particle/property/crystal_preferred_orientation.h.bak
 delete mode 100644 include/aspect/particle/property/elastic_stress.h.bak
 delete mode 100644 include/aspect/particle/property/elastic_tensor_decomposition.h.bak
 delete mode 100644 include/aspect/particle/property/function.h.bak
 delete mode 100644 include/aspect/particle/property/grain_size.h.bak
 delete mode 100644 include/aspect/particle/property/initial_composition.h.bak
 delete mode 100644 include/aspect/particle/property/initial_position.h.bak
 delete mode 100644 include/aspect/particle/property/integrated_strain.h.bak
 delete mode 100644 include/aspect/particle/property/integrated_strain_invariant.h.bak
 delete mode 100644 include/aspect/particle/property/interface.h.bak
 delete mode 100644 include/aspect/particle/property/melt_particle.h.bak
 delete mode 100644 include/aspect/particle/property/pT_path.h.bak
 delete mode 100644 include/aspect/particle/property/position.h.bak
 delete mode 100644 include/aspect/particle/property/reference_position.h.bak
 delete mode 100644 include/aspect/particle/property/strain_rate.h.bak
 delete mode 100644 include/aspect/particle/property/velocity.h.bak
 delete mode 100644 include/aspect/particle/property/viscoplastic_strain_invariants.h.bak
 delete mode 100644 include/aspect/particle/world.h.bak
 delete mode 100644 include/aspect/plugins.h.bak
 delete mode 100644 include/aspect/postprocess/ODE_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/basic_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/boundary_densities.h.bak
 delete mode 100644 include/aspect/postprocess/boundary_pressures.h.bak
 delete mode 100644 include/aspect/postprocess/boundary_strain_rate_residual_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/boundary_velocity_residual_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/command.h.bak
 delete mode 100644 include/aspect/postprocess/composition_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/composition_velocity_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/core_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/crystal_preferred_orientation.h.bak
 delete mode 100644 include/aspect/postprocess/depth_average.h.bak
 delete mode 100644 include/aspect/postprocess/domain_volume_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/dynamic_topography.h.bak
 delete mode 100644 include/aspect/postprocess/entropy_viscosity_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/geoid.h.bak
 delete mode 100644 include/aspect/postprocess/global_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/gravity_point_values.h.bak
 delete mode 100644 include/aspect/postprocess/heat_flux_densities.h.bak
 delete mode 100644 include/aspect/postprocess/heat_flux_map.h.bak
 delete mode 100644 include/aspect/postprocess/heat_flux_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/heating_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/interface.h.bak
 delete mode 100644 include/aspect/postprocess/load_balance_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/mass_flux_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/material_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/matrix_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/max_depth_field.h.bak
 delete mode 100644 include/aspect/postprocess/melt_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/memory_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/mobility_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/particle_count_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/particles.h.bak
 delete mode 100644 include/aspect/postprocess/point_values.h.bak
 delete mode 100644 include/aspect/postprocess/pressure_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/rotation_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/sea_level.h.bak
 delete mode 100644 include/aspect/postprocess/spherical_velocity_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/stokes_residual.h.bak
 delete mode 100644 include/aspect/postprocess/temperature_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/topography.h.bak
 delete mode 100644 include/aspect/postprocess/velocity_boundary_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/velocity_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/viscous_dissipation_statistics.h.bak
 delete mode 100644 include/aspect/postprocess/visualization.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/ISA_rotation_timescale.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/adiabat.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/artificial_viscosity.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/artificial_viscosity_composition.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/boundary_indicator.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/boundary_strain_rate_residual.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/boundary_velocity_residual.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/compositional_vector.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/depth.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/dynamic_topography.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/error_indicator.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/geoid.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/grain_lag_angle.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/gravity.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/heat_flux_map.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/heating.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/kxrcf_indicator.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/material_properties.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/melt.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/melt_fraction.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/named_additional_outputs.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/nonadiabatic_pressure.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/nonadiabatic_temperature.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/particle_count.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/partition.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/principal_stress.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/seismic_anomalies.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/shear_stress.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/spd_factor.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/spherical_velocity_components.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/strain_rate.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/strain_rate_tensor.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/stress.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/stress_second_invariant.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/surface_dynamic_topography.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/surface_elevation.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/surface_strain_rate_tensor.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/surface_stress.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/temperature_anomaly.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/vertical_heat_flux.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/volume_of_fluid_values.h.bak
 delete mode 100644 include/aspect/postprocess/visualization/volumetric_strain_rate.h.bak
 delete mode 100644 include/aspect/postprocess/volume_of_fluid_statistics.h.bak
 delete mode 100644 include/aspect/prescribed_stokes_solution/ascii_data.h.bak
 delete mode 100644 include/aspect/prescribed_stokes_solution/circle.h.bak
 delete mode 100644 include/aspect/prescribed_stokes_solution/function.h.bak
 delete mode 100644 include/aspect/prescribed_stokes_solution/interface.h.bak
 delete mode 100644 include/aspect/simulator.h.bak
 delete mode 100644 include/aspect/simulator/assemblers/advection.h.bak
 delete mode 100644 include/aspect/simulator/assemblers/interface.h.bak
 delete mode 100644 include/aspect/simulator/assemblers/stokes.h.bak
 delete mode 100644 include/aspect/simulator_access.h.bak
 delete mode 100644 include/aspect/simulator_signals.h.bak
 delete mode 100644 include/aspect/stokes_matrix_free.h.bak
 delete mode 100644 include/aspect/structured_data.h.bak
 delete mode 100644 include/aspect/termination_criteria/end_step.h.bak
 delete mode 100644 include/aspect/termination_criteria/end_time.h.bak
 delete mode 100644 include/aspect/termination_criteria/end_walltime.h.bak
 delete mode 100644 include/aspect/termination_criteria/interface.h.bak
 delete mode 100644 include/aspect/termination_criteria/steady_heat_flux.h.bak
 delete mode 100644 include/aspect/termination_criteria/steady_rms_velocity.h.bak
 delete mode 100644 include/aspect/termination_criteria/steady_temperature.h.bak
 delete mode 100644 include/aspect/termination_criteria/user_request.h.bak
 delete mode 100644 include/aspect/time_stepping/conduction_time_step.h.bak
 delete mode 100644 include/aspect/time_stepping/convection_time_step.h.bak
 delete mode 100644 include/aspect/time_stepping/function.h.bak
 delete mode 100644 include/aspect/time_stepping/interface.h.bak
 delete mode 100644 include/aspect/time_stepping/repeat_on_cutback.h.bak
 delete mode 100644 include/aspect/utilities.h.bak
 delete mode 100644 include/aspect/volume_of_fluid/assembly.h.bak
 delete mode 100644 include/aspect/volume_of_fluid/field.h.bak
 delete mode 100644 include/aspect/volume_of_fluid/handler.h.bak
 delete mode 100644 include/aspect/volume_of_fluid/utilities.h.bak
 delete mode 100644 source/adiabatic_conditions/ascii_data.cc.bak
 delete mode 100644 source/adiabatic_conditions/compute_entropy_profile.cc.bak
 delete mode 100644 source/adiabatic_conditions/compute_profile.cc.bak
 delete mode 100644 source/adiabatic_conditions/function.cc.bak
 delete mode 100644 source/adiabatic_conditions/interface.cc.bak
 delete mode 100644 source/boundary_composition/ascii_data.cc.bak
 delete mode 100644 source/boundary_composition/box.cc.bak
 delete mode 100644 source/boundary_composition/function.cc.bak
 delete mode 100644 source/boundary_composition/initial_composition.cc.bak
 delete mode 100644 source/boundary_composition/interface.cc.bak
 delete mode 100644 source/boundary_composition/spherical_constant.cc.bak
 delete mode 100644 source/boundary_composition/two_merged_boxes.cc.bak
 delete mode 100644 source/boundary_fluid_pressure/density.cc.bak
 delete mode 100644 source/boundary_fluid_pressure/interface.cc.bak
 delete mode 100644 source/boundary_heat_flux/function.cc.bak
 delete mode 100644 source/boundary_heat_flux/interface.cc.bak
 delete mode 100644 source/boundary_temperature/ascii_data.cc.bak
 delete mode 100644 source/boundary_temperature/box.cc.bak
 delete mode 100644 source/boundary_temperature/constant.cc.bak
 delete mode 100644 source/boundary_temperature/dynamic_core.cc.bak
 delete mode 100644 source/boundary_temperature/function.cc.bak
 delete mode 100644 source/boundary_temperature/initial_temperature.cc.bak
 delete mode 100644 source/boundary_temperature/interface.cc.bak
 delete mode 100644 source/boundary_temperature/spherical_constant.cc.bak
 delete mode 100644 source/boundary_temperature/two_merged_boxes.cc.bak
 delete mode 100644 source/boundary_traction/ascii_data.cc.bak
 delete mode 100644 source/boundary_traction/function.cc.bak
 delete mode 100644 source/boundary_traction/initial_lithostatic_pressure.cc.bak
 delete mode 100644 source/boundary_traction/interface.cc.bak
 delete mode 100644 source/boundary_traction/zero_traction.cc.bak
 delete mode 100644 source/boundary_velocity/ascii_data.cc.bak
 delete mode 100644 source/boundary_velocity/function.cc.bak
 delete mode 100644 source/boundary_velocity/gplates.cc.bak
 delete mode 100644 source/boundary_velocity/interface.cc.bak
 delete mode 100644 source/boundary_velocity/zero_velocity.cc.bak
 delete mode 100644 source/citation_info.cc.bak
 delete mode 100644 source/compat.cc.bak
 delete mode 100644 source/fe_variable_collection.cc.bak
 delete mode 100644 source/geometry_model/box.cc.bak
 delete mode 100644 source/geometry_model/chunk.cc.bak
 delete mode 100644 source/geometry_model/ellipsoidal_chunk.cc.bak
 delete mode 100644 source/geometry_model/initial_topography_model/ascii_data.cc.bak
 delete mode 100644 source/geometry_model/initial_topography_model/function.cc.bak
 delete mode 100644 source/geometry_model/initial_topography_model/interface.cc.bak
 delete mode 100644 source/geometry_model/initial_topography_model/prm_polygon.cc.bak
 delete mode 100644 source/geometry_model/initial_topography_model/zero_topography.cc.bak
 delete mode 100644 source/geometry_model/interface.cc.bak
 delete mode 100644 source/geometry_model/sphere.cc.bak
 delete mode 100644 source/geometry_model/spherical_shell.cc.bak
 delete mode 100644 source/geometry_model/two_merged_boxes.cc.bak
 delete mode 100644 source/geometry_model/two_merged_chunks.cc.bak
 delete mode 100644 source/global.cc.bak
 delete mode 100644 source/gravity_model/ascii_data.cc.bak
 delete mode 100644 source/gravity_model/function.cc.bak
 delete mode 100644 source/gravity_model/interface.cc.bak
 delete mode 100644 source/gravity_model/radial.cc.bak
 delete mode 100644 source/gravity_model/vertical.cc.bak
 delete mode 100644 source/heating_model/adiabatic_heating.cc.bak
 delete mode 100644 source/heating_model/adiabatic_heating_of_melt.cc.bak
 delete mode 100644 source/heating_model/compositional_heating.cc.bak
 delete mode 100644 source/heating_model/constant_heating.cc.bak
 delete mode 100644 source/heating_model/function.cc.bak
 delete mode 100644 source/heating_model/interface.cc.bak
 delete mode 100644 source/heating_model/latent_heat.cc.bak
 delete mode 100644 source/heating_model/latent_heat_melt.cc.bak
 delete mode 100644 source/heating_model/radioactive_decay.cc.bak
 delete mode 100644 source/heating_model/shear_heating.cc.bak
 delete mode 100644 source/heating_model/shear_heating_with_melt.cc.bak
 delete mode 100644 source/initial_composition/adiabatic_density.cc.bak
 delete mode 100644 source/initial_composition/ascii_data.cc.bak
 delete mode 100644 source/initial_composition/ascii_data_layered.cc.bak
 delete mode 100644 source/initial_composition/entropy_table_lookup.cc.bak
 delete mode 100644 source/initial_composition/function.cc.bak
 delete mode 100644 source/initial_composition/interface.cc.bak
 delete mode 100644 source/initial_composition/porosity.cc.bak
 delete mode 100644 source/initial_composition/slab_model.cc.bak
 delete mode 100644 source/initial_composition/world_builder.cc.bak
 delete mode 100644 source/initial_temperature/S40RTS_perturbation.cc.bak
 delete mode 100644 source/initial_temperature/SAVANI_perturbation.cc.bak
 delete mode 100644 source/initial_temperature/adiabatic.cc.bak
 delete mode 100644 source/initial_temperature/adiabatic_boundary.cc.bak
 delete mode 100644 source/initial_temperature/ascii_data.cc.bak
 delete mode 100644 source/initial_temperature/ascii_data_layered.cc.bak
 delete mode 100644 source/initial_temperature/ascii_profile.cc.bak
 delete mode 100644 source/initial_temperature/box.cc.bak
 delete mode 100644 source/initial_temperature/continental_geotherm.cc.bak
 delete mode 100644 source/initial_temperature/function.cc.bak
 delete mode 100644 source/initial_temperature/harmonic_perturbation.cc.bak
 delete mode 100644 source/initial_temperature/interface.cc.bak
 delete mode 100644 source/initial_temperature/lithosphere_mask.cc.bak
 delete mode 100644 source/initial_temperature/patch_on_S40RTS.cc.bak
 delete mode 100644 source/initial_temperature/prescribed_temperature.cc.bak
 delete mode 100644 source/initial_temperature/random_gaussian_perturbation.cc.bak
 delete mode 100644 source/initial_temperature/spherical_shell.cc.bak
 delete mode 100644 source/initial_temperature/world_builder.cc.bak
 delete mode 100644 source/main.cc.bak
 delete mode 100644 source/material_model/ascii_reference_profile.cc.bak
 delete mode 100644 source/material_model/averaging.cc.bak
 delete mode 100644 source/material_model/compositing.cc.bak
 delete mode 100644 source/material_model/composition_reaction.cc.bak
 delete mode 100644 source/material_model/depth_dependent.cc.bak
 delete mode 100644 source/material_model/diffusion_dislocation.cc.bak
 delete mode 100644 source/material_model/drucker_prager.cc.bak
 delete mode 100644 source/material_model/entropy_model.cc.bak
 delete mode 100644 source/material_model/equation_of_state/interface.cc.bak
 delete mode 100644 source/material_model/equation_of_state/linearized_incompressible.cc.bak
 delete mode 100644 source/material_model/equation_of_state/multicomponent_compressible.cc.bak
 delete mode 100644 source/material_model/equation_of_state/multicomponent_incompressible.cc.bak
 delete mode 100644 source/material_model/equation_of_state/thermodynamic_table_lookup.cc.bak
 delete mode 100644 source/material_model/grain_size.cc.bak
 delete mode 100644 source/material_model/interface.cc.bak
 delete mode 100644 source/material_model/latent_heat.cc.bak
 delete mode 100644 source/material_model/latent_heat_melt.cc.bak
 delete mode 100644 source/material_model/melt_boukare.cc.bak
 delete mode 100644 source/material_model/melt_global.cc.bak
 delete mode 100644 source/material_model/melt_simple.cc.bak
 delete mode 100644 source/material_model/modified_tait.cc.bak
 delete mode 100644 source/material_model/multicomponent.cc.bak
 delete mode 100644 source/material_model/multicomponent_compressible.cc.bak
 delete mode 100644 source/material_model/nondimensional.cc.bak
 delete mode 100644 source/material_model/perplex_lookup.cc.bak
 delete mode 100644 source/material_model/prescribed_viscosity.cc.bak
 delete mode 100644 source/material_model/reaction_model/katz2003_mantle_melting.cc.bak
 delete mode 100644 source/material_model/reactive_fluid_transport.cc.bak
 delete mode 100644 source/material_model/replace_lithosphere_viscosity.cc.bak
 delete mode 100644 source/material_model/rheology/ascii_depth_profile.cc.bak
 delete mode 100644 source/material_model/rheology/composite_visco_plastic.cc.bak
 delete mode 100644 source/material_model/rheology/compositional_viscosity_prefactors.cc.bak
 delete mode 100644 source/material_model/rheology/constant_viscosity.cc.bak
 delete mode 100644 source/material_model/rheology/constant_viscosity_prefactors.cc.bak
 delete mode 100644 source/material_model/rheology/diffusion_creep.cc.bak
 delete mode 100644 source/material_model/rheology/diffusion_dislocation.cc.bak
 delete mode 100644 source/material_model/rheology/dislocation_creep.cc.bak
 delete mode 100644 source/material_model/rheology/drucker_prager.cc.bak
 delete mode 100644 source/material_model/rheology/elasticity.cc.bak
 delete mode 100644 source/material_model/rheology/frank_kamenetskii.cc.bak
 delete mode 100644 source/material_model/rheology/friction_models.cc.bak
 delete mode 100644 source/material_model/rheology/peierls_creep.cc.bak
 delete mode 100644 source/material_model/rheology/strain_dependent.cc.bak
 delete mode 100644 source/material_model/rheology/visco_plastic.cc.bak
 delete mode 100644 source/material_model/simple.cc.bak
 delete mode 100644 source/material_model/simple_compressible.cc.bak
 delete mode 100644 source/material_model/simpler.cc.bak
 delete mode 100644 source/material_model/steinberger.cc.bak
 delete mode 100644 source/material_model/utilities.cc.bak
 delete mode 100644 source/material_model/visco_plastic.cc.bak
 delete mode 100644 source/material_model/viscoelastic.cc.bak
 delete mode 100644 source/mesh_deformation/ascii_data.cc.bak
 delete mode 100644 source/mesh_deformation/diffusion.cc.bak
 delete mode 100644 source/mesh_deformation/fastscape.cc.bak
 delete mode 100644 source/mesh_deformation/free_surface.cc.bak
 delete mode 100644 source/mesh_deformation/function.cc.bak
 delete mode 100644 source/mesh_deformation/interface.cc.bak
 delete mode 100644 source/mesh_refinement/artificial_viscosity.cc.bak
 delete mode 100644 source/mesh_refinement/boundary.cc.bak
 delete mode 100644 source/mesh_refinement/compaction_length.cc.bak
 delete mode 100644 source/mesh_refinement/composition.cc.bak
 delete mode 100644 source/mesh_refinement/composition_approximate_gradient.cc.bak
 delete mode 100644 source/mesh_refinement/composition_gradient.cc.bak
 delete mode 100644 source/mesh_refinement/composition_threshold.cc.bak
 delete mode 100644 source/mesh_refinement/density.cc.bak
 delete mode 100644 source/mesh_refinement/interface.cc.bak
 delete mode 100644 source/mesh_refinement/isosurfaces.cc.bak
 delete mode 100644 source/mesh_refinement/maximum_refinement_function.cc.bak
 delete mode 100644 source/mesh_refinement/minimum_refinement_function.cc.bak
 delete mode 100644 source/mesh_refinement/nonadiabatic_temperature.cc.bak
 delete mode 100644 source/mesh_refinement/nonadiabatic_temperature_threshold.cc.bak
 delete mode 100644 source/mesh_refinement/particle_density.cc.bak
 delete mode 100644 source/mesh_refinement/slope.cc.bak
 delete mode 100644 source/mesh_refinement/strain_rate.cc.bak
 delete mode 100644 source/mesh_refinement/temperature.cc.bak
 delete mode 100644 source/mesh_refinement/thermal_energy_density.cc.bak
 delete mode 100644 source/mesh_refinement/topography.cc.bak
 delete mode 100644 source/mesh_refinement/velocity.cc.bak
 delete mode 100644 source/mesh_refinement/viscosity.cc.bak
 delete mode 100644 source/mesh_refinement/volume_of_fluid_interface.cc.bak
 delete mode 100644 source/particle/generator/ascii_file.cc.bak
 delete mode 100644 source/particle/generator/interface.cc.bak
 delete mode 100644 source/particle/generator/probability_density_function.cc.bak
 delete mode 100644 source/particle/generator/quadrature_points.cc.bak
 delete mode 100644 source/particle/generator/random_uniform.cc.bak
 delete mode 100644 source/particle/generator/reference_cell.cc.bak
 delete mode 100644 source/particle/generator/uniform_box.cc.bak
 delete mode 100644 source/particle/generator/uniform_radial.cc.bak
 delete mode 100644 source/particle/integrator/euler.cc.bak
 delete mode 100644 source/particle/integrator/interface.cc.bak
 delete mode 100644 source/particle/integrator/rk_2.cc.bak
 delete mode 100644 source/particle/integrator/rk_4.cc.bak
 delete mode 100644 source/particle/interface.cc.bak
 delete mode 100644 source/particle/interpolator/bilinear_least_squares.cc.bak
 delete mode 100644 source/particle/interpolator/cell_average.cc.bak
 delete mode 100644 source/particle/interpolator/harmonic_average.cc.bak
 delete mode 100644 source/particle/interpolator/interface.cc.bak
 delete mode 100644 source/particle/interpolator/nearest_neighbor.cc.bak
 delete mode 100644 source/particle/interpolator/quadratic_least_squares.cc.bak
 delete mode 100644 source/particle/property/composition.cc.bak
 delete mode 100644 source/particle/property/cpo_bingham_average.cc.bak
 delete mode 100644 source/particle/property/cpo_elastic_tensor.cc.bak
 delete mode 100644 source/particle/property/crystal_preferred_orientation.cc.bak
 delete mode 100644 source/particle/property/elastic_stress.cc.bak
 delete mode 100644 source/particle/property/elastic_tensor_decomposition.cc.bak
 delete mode 100644 source/particle/property/function.cc.bak
 delete mode 100644 source/particle/property/grain_size.cc.bak
 delete mode 100644 source/particle/property/initial_composition.cc.bak
 delete mode 100644 source/particle/property/initial_position.cc.bak
 delete mode 100644 source/particle/property/integrated_strain.cc.bak
 delete mode 100644 source/particle/property/integrated_strain_invariant.cc.bak
 delete mode 100644 source/particle/property/interface.cc.bak
 delete mode 100644 source/particle/property/melt_particle.cc.bak
 delete mode 100644 source/particle/property/pT_path.cc.bak
 delete mode 100644 source/particle/property/position.cc.bak
 delete mode 100644 source/particle/property/reference_position.cc.bak
 delete mode 100644 source/particle/property/strain_rate.cc.bak
 delete mode 100644 source/particle/property/velocity.cc.bak
 delete mode 100644 source/particle/property/viscoplastic_strain_invariants.cc.bak
 delete mode 100644 source/particle/world.cc.bak
 delete mode 100644 source/plugins.cc.bak
 delete mode 100644 source/postprocess/ODE_statistics.cc.bak
 delete mode 100644 source/postprocess/basic_statistics.cc.bak
 delete mode 100644 source/postprocess/boundary_densities.cc.bak
 delete mode 100644 source/postprocess/boundary_pressures.cc.bak
 delete mode 100644 source/postprocess/boundary_strain_rate_residual_statistics.cc.bak
 delete mode 100644 source/postprocess/boundary_velocity_residual_statistics.cc.bak
 delete mode 100644 source/postprocess/command.cc.bak
 delete mode 100644 source/postprocess/composition_statistics.cc.bak
 delete mode 100644 source/postprocess/composition_velocity_statistics.cc.bak
 delete mode 100644 source/postprocess/core_statistics.cc.bak
 delete mode 100644 source/postprocess/crystal_preferred_orientation.cc.bak
 delete mode 100644 source/postprocess/depth_average.cc.bak
 delete mode 100644 source/postprocess/domain_volume_statistics.cc.bak
 delete mode 100644 source/postprocess/dynamic_topography.cc.bak
 delete mode 100644 source/postprocess/entropy_viscosity_statistics.cc.bak
 delete mode 100644 source/postprocess/geoid.cc.bak
 delete mode 100644 source/postprocess/global_statistics.cc.bak
 delete mode 100644 source/postprocess/gravity_point_values.cc.bak
 delete mode 100644 source/postprocess/heat_flux_densities.cc.bak
 delete mode 100644 source/postprocess/heat_flux_map.cc.bak
 delete mode 100644 source/postprocess/heat_flux_statistics.cc.bak
 delete mode 100644 source/postprocess/heating_statistics.cc.bak
 delete mode 100644 source/postprocess/interface.cc.bak
 delete mode 100644 source/postprocess/load_balance_statistics.cc.bak
 delete mode 100644 source/postprocess/mass_flux_statistics.cc.bak
 delete mode 100644 source/postprocess/material_statistics.cc.bak
 delete mode 100644 source/postprocess/matrix_statistics.cc.bak
 delete mode 100644 source/postprocess/max_depth_field.cc.bak
 delete mode 100644 source/postprocess/melt_statistics.cc.bak
 delete mode 100644 source/postprocess/memory_statistics.cc.bak
 delete mode 100644 source/postprocess/mobility_statistics.cc.bak
 delete mode 100644 source/postprocess/particle_count_statistics.cc.bak
 delete mode 100644 source/postprocess/particles.cc.bak
 delete mode 100644 source/postprocess/point_values.cc.bak
 delete mode 100644 source/postprocess/pressure_statistics.cc.bak
 delete mode 100644 source/postprocess/rotation_statistics.cc.bak
 delete mode 100644 source/postprocess/sea_level.cc.bak
 delete mode 100644 source/postprocess/spherical_velocity_statistics.cc.bak
 delete mode 100644 source/postprocess/stokes_residual.cc.bak
 delete mode 100644 source/postprocess/temperature_statistics.cc.bak
 delete mode 100644 source/postprocess/topography.cc.bak
 delete mode 100644 source/postprocess/velocity_boundary_statistics.cc.bak
 delete mode 100644 source/postprocess/velocity_statistics.cc.bak
 delete mode 100644 source/postprocess/viscous_dissipation_statistics.cc.bak
 delete mode 100644 source/postprocess/visualization.cc.bak
 delete mode 100644 source/postprocess/visualization/ISA_rotation_timescale.cc.bak
 delete mode 100644 source/postprocess/visualization/adiabat.cc.bak
 delete mode 100644 source/postprocess/visualization/artificial_viscosity.cc.bak
 delete mode 100644 source/postprocess/visualization/artificial_viscosity_composition.cc.bak
 delete mode 100644 source/postprocess/visualization/boundary_indicator.cc.bak
 delete mode 100644 source/postprocess/visualization/boundary_strain_rate_residual.cc.bak
 delete mode 100644 source/postprocess/visualization/boundary_velocity_residual.cc.bak
 delete mode 100644 source/postprocess/visualization/compositional_vector.cc.bak
 delete mode 100644 source/postprocess/visualization/depth.cc.bak
 delete mode 100644 source/postprocess/visualization/dynamic_topography.cc.bak
 delete mode 100644 source/postprocess/visualization/error_indicator.cc.bak
 delete mode 100644 source/postprocess/visualization/geoid.cc.bak
 delete mode 100644 source/postprocess/visualization/grain_lag_angle.cc.bak
 delete mode 100644 source/postprocess/visualization/gravity.cc.bak
 delete mode 100644 source/postprocess/visualization/heat_flux_map.cc.bak
 delete mode 100644 source/postprocess/visualization/heating.cc.bak
 delete mode 100644 source/postprocess/visualization/kxrcf_indicator.cc.bak
 delete mode 100644 source/postprocess/visualization/material_properties.cc.bak
 delete mode 100644 source/postprocess/visualization/maximum_horizontal_compressive_stress.cc.bak
 delete mode 100644 source/postprocess/visualization/melt.cc.bak
 delete mode 100644 source/postprocess/visualization/melt_fraction.cc.bak
 delete mode 100644 source/postprocess/visualization/named_additional_outputs.cc.bak
 delete mode 100644 source/postprocess/visualization/nonadiabatic_pressure.cc.bak
 delete mode 100644 source/postprocess/visualization/nonadiabatic_temperature.cc.bak
 delete mode 100644 source/postprocess/visualization/particle_count.cc.bak
 delete mode 100644 source/postprocess/visualization/partition.cc.bak
 delete mode 100644 source/postprocess/visualization/principal_stress.cc.bak
 delete mode 100644 source/postprocess/visualization/seismic_anomalies.cc.bak
 delete mode 100644 source/postprocess/visualization/shear_stress.cc.bak
 delete mode 100644 source/postprocess/visualization/spd_factor.cc.bak
 delete mode 100644 source/postprocess/visualization/spherical_velocity_components.cc.bak
 delete mode 100644 source/postprocess/visualization/strain_rate.cc.bak
 delete mode 100644 source/postprocess/visualization/strain_rate_tensor.cc.bak
 delete mode 100644 source/postprocess/visualization/stress.cc.bak
 delete mode 100644 source/postprocess/visualization/stress_second_invariant.cc.bak
 delete mode 100644 source/postprocess/visualization/surface_dynamic_topography.cc.bak
 delete mode 100644 source/postprocess/visualization/surface_elevation.cc.bak
 delete mode 100644 source/postprocess/visualization/surface_strain_rate_tensor.cc.bak
 delete mode 100644 source/postprocess/visualization/surface_stress.cc.bak
 delete mode 100644 source/postprocess/visualization/temperature_anomaly.cc.bak
 delete mode 100644 source/postprocess/visualization/vertical_heat_flux.cc.bak
 delete mode 100644 source/postprocess/visualization/volume_of_fluid_values.cc.bak
 delete mode 100644 source/postprocess/visualization/volumetric_strain_rate.cc.bak
 delete mode 100644 source/postprocess/volume_of_fluid_statistics.cc.bak
 delete mode 100644 source/prescribed_stokes_solution/ascii_data.cc.bak
 delete mode 100644 source/prescribed_stokes_solution/circle.cc.bak
 delete mode 100644 source/prescribed_stokes_solution/function.cc.bak
 delete mode 100644 source/prescribed_stokes_solution/interface.cc.bak
 delete mode 100644 source/simulator/assemblers/advection.cc.bak
 delete mode 100644 source/simulator/assemblers/interface.cc.bak
 delete mode 100644 source/simulator/assemblers/newton_stokes.cc.bak
 delete mode 100644 source/simulator/assemblers/stokes.cc.bak
 delete mode 100644 source/simulator/assembly.cc.bak
 delete mode 100644 source/simulator/checkpoint_restart.cc.bak
 delete mode 100644 source/simulator/core.cc.bak
 delete mode 100644 source/simulator/entropy_viscosity.cc.bak
 delete mode 100644 source/simulator/helper_functions.cc.bak
 delete mode 100644 source/simulator/initial_conditions.cc.bak
 delete mode 100644 source/simulator/introspection.cc.bak
 delete mode 100644 source/simulator/lateral_averaging.cc.bak
 delete mode 100644 source/simulator/limiters.cc.bak
 delete mode 100644 source/simulator/melt.cc.bak
 delete mode 100644 source/simulator/newton.cc.bak
 delete mode 100644 source/simulator/nullspace.cc.bak
 delete mode 100644 source/simulator/parameters.cc.bak
 delete mode 100644 source/simulator/simulator_access.cc.bak
 delete mode 100644 source/simulator/simulator_signals.cc.bak
 delete mode 100644 source/simulator/solver.cc.bak
 delete mode 100644 source/simulator/solver_schemes.cc.bak
 delete mode 100644 source/simulator/stokes_matrix_free.cc.bak
 delete mode 100644 source/structured_data.cc.bak
 delete mode 100644 source/termination_criteria/end_step.cc.bak
 delete mode 100644 source/termination_criteria/end_time.cc.bak
 delete mode 100644 source/termination_criteria/end_walltime.cc.bak
 delete mode 100644 source/termination_criteria/interface.cc.bak
 delete mode 100644 source/termination_criteria/steady_heat_flux.cc.bak
 delete mode 100644 source/termination_criteria/steady_rms_velocity.cc.bak
 delete mode 100644 source/termination_criteria/steady_temperature.cc.bak
 delete mode 100644 source/termination_criteria/user_request.cc.bak
 delete mode 100644 source/time_stepping/conduction_time_step.cc.bak
 delete mode 100644 source/time_stepping/convection_time_step.cc.bak
 delete mode 100644 source/time_stepping/function.cc.bak
 delete mode 100644 source/time_stepping/interface.cc.bak
 delete mode 100644 source/time_stepping/repeat_on_cutback.cc.bak
 delete mode 100644 source/utilities.cc.bak
 delete mode 100644 source/volume_of_fluid/assembler.cc.bak
 delete mode 100644 source/volume_of_fluid/handler.cc.bak
 delete mode 100644 source/volume_of_fluid/reconstruct.cc.bak
 delete mode 100644 source/volume_of_fluid/setup_initial_conditions.cc.bak
 delete mode 100644 source/volume_of_fluid/solver.cc.bak
 delete mode 100644 source/volume_of_fluid/utilities.cc.bak
 delete mode 100644 tests/2d_annulus_pyvista_cookbook.prm.bak
 delete mode 100644 tests/ISA_rotation_timescale.prm.bak
 delete mode 100644 tests/Picard_compressible.prm.bak
 delete mode 100644 tests/additional_outputs_02.cc.bak
 delete mode 100644 tests/additional_outputs_02.prm.bak
 delete mode 100644 tests/additional_outputs_03.cc.bak
 delete mode 100644 tests/additional_outputs_03.prm.bak
 delete mode 100644 tests/adiabatic_boundary.prm.bak
 delete mode 100644 tests/adiabatic_conditions.prm.bak
 delete mode 100644 tests/adiabatic_conditions_composition_function.prm.bak
 delete mode 100644 tests/adiabatic_conditions_function.prm.bak
 delete mode 100644 tests/adiabatic_conditions_time_change.prm.bak
 delete mode 100644 tests/adiabatic_heating.prm.bak
 delete mode 100644 tests/adiabatic_heating_simplified.prm.bak
 delete mode 100644 tests/adiabatic_heating_with_melt.prm.bak
 delete mode 100644 tests/adiabatic_initial_conditions.prm.bak
 delete mode 100644 tests/adiabatic_initial_conditions_chunk.prm.bak
 delete mode 100644 tests/adiabatic_initial_conditions_chunk_3d.prm.bak
 delete mode 100644 tests/adiabatic_initial_conditions_compressible.prm.bak
 delete mode 100644 tests/adiabatic_initial_conditions_constant.prm.bak
 delete mode 100644 tests/adiabatic_initial_conditions_points.prm.bak
 delete mode 100644 tests/adiabatic_initial_conditions_subadiabaticity.prm.bak
 delete mode 100644 tests/adiabatic_initial_conditions_without_boundary.prm.bak
 delete mode 100644 tests/adiabatic_plate_cooling.prm.bak
 delete mode 100644 tests/adiabatic_plate_function.prm.bak
 delete mode 100644 tests/advect_field_with_melt_velocity.cc.bak
 delete mode 100644 tests/advect_field_with_melt_velocity.prm.bak
 delete mode 100644 tests/advect_mesh_vertically.prm.bak
 delete mode 100644 tests/advection_reaction.cc.bak
 delete mode 100644 tests/advection_reaction.prm.bak
 delete mode 100644 tests/advection_solver_fail.prm.bak
 delete mode 100644 tests/airy_isostasy.prm.bak
 delete mode 100644 tests/airy_isostasy_initial_topo.cc.bak
 delete mode 100644 tests/airy_isostasy_initial_topo.prm.bak
 delete mode 100644 tests/airy_isostasy_initial_topo_lithostatic_pressure.prm.bak
 delete mode 100644 tests/always_refine.prm.bak
 delete mode 100644 tests/analytic_artificial_viscosity_0.prm.bak
 delete mode 100644 tests/anisotropic_viscosity.cc.bak
 delete mode 100644 tests/anisotropic_viscosity.prm.bak
 delete mode 100644 tests/annulus.cc.bak
 delete mode 100644 tests/annulus.prm.bak
 delete mode 100644 tests/annulus_transient.cc.bak
 delete mode 100644 tests/annulus_transient.prm.bak
 delete mode 100644 tests/artificial_postprocess.cc.bak
 delete mode 100644 tests/artificial_postprocess.prm.bak
 delete mode 100644 tests/artificial_viscosity.prm.bak
 delete mode 100644 tests/artificial_viscosity_dirichlet_boundaries.prm.bak
 delete mode 100644 tests/artificial_viscosity_list.prm.bak
 delete mode 100644 tests/ascii_boundary_member.cc.bak
 delete mode 100644 tests/ascii_boundary_member.prm.bak
 delete mode 100644 tests/ascii_data_adiabatic_conditions.prm.bak
 delete mode 100644 tests/ascii_data_boundary_composition_2d_box_time.prm.bak
 delete mode 100644 tests/ascii_data_boundary_composition_3d_box.prm.bak
 delete mode 100644 tests/ascii_data_boundary_temperature_2d_box_time.prm.bak
 delete mode 100644 tests/ascii_data_boundary_temperature_3d_box.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_2d_box.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_2d_box_list.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_2d_box_time.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_2d_box_time_backward.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_2d_box_time_non_equidistant.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_2d_chunk.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_2d_shell.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_2d_shell_spherical.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_3d_box.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_3d_chunk.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_3d_shell.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_3d_shell_spherical.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_3d_sphere.prm.bak
 delete mode 100644 tests/ascii_data_boundary_velocity_residual_shell.prm.bak
 delete mode 100644 tests/ascii_data_fail_1.prm.bak
 delete mode 100644 tests/ascii_data_fail_2.prm.bak
 delete mode 100644 tests/ascii_data_fail_3.prm.bak
 delete mode 100644 tests/ascii_data_fail_4.prm.bak
 delete mode 100644 tests/ascii_data_gravity.prm.bak
 delete mode 100644 tests/ascii_data_initial_composition_2d_box.prm.bak
 delete mode 100644 tests/ascii_data_initial_composition_2d_box_gz.prm.bak
 delete mode 100644 tests/ascii_data_initial_composition_3d_chunk.prm.bak
 delete mode 100644 tests/ascii_data_initial_composition_3d_shell.prm.bak
 delete mode 100644 tests/ascii_data_initial_temperature_2d_box.prm.bak
 delete mode 100644 tests/ascii_data_initial_temperature_3d_chunk.prm.bak
 delete mode 100644 tests/ascii_data_initial_temperature_3d_ellipsoidal_chunk.prm.bak
 delete mode 100644 tests/ascii_data_initial_temperature_3d_shell.prm.bak
 delete mode 100644 tests/ascii_data_initial_temperature_3d_two_chunks.prm.bak
 delete mode 100644 tests/ascii_data_layered_initial_composition_2d_box.prm.bak
 delete mode 100644 tests/ascii_data_layered_initial_temperature_2d_box.prm.bak
 delete mode 100644 tests/ascii_data_layered_initial_temperature_2d_chunk.prm.bak
 delete mode 100644 tests/ascii_data_layered_initial_temperature_3d_box.prm.bak
 delete mode 100644 tests/ascii_data_layered_initial_temperature_3d_chunk.prm.bak
 delete mode 100644 tests/ascii_data_layered_initial_temperature_piecewise_constant_3d_box.prm.bak
 delete mode 100644 tests/ascii_data_nonuniform_initial_composition_2d_box.prm.bak
 delete mode 100644 tests/ascii_data_prescribed_stokes_2d_box.prm.bak
 delete mode 100644 tests/ascii_data_slice.prm.bak
 delete mode 100644 tests/ascii_data_slice_temperature.prm.bak
 delete mode 100644 tests/average_arithmetic.prm.bak
 delete mode 100644 tests/average_density_boundary_fluid_pressure.prm.bak
 delete mode 100644 tests/average_geometric.prm.bak
 delete mode 100644 tests/average_harmonic.prm.bak
 delete mode 100644 tests/average_log.prm.bak
 delete mode 100644 tests/average_none.prm.bak
 delete mode 100644 tests/average_nwd_arithmetic.prm.bak
 delete mode 100644 tests/average_nwd_geometric.prm.bak
 delete mode 100644 tests/average_nwd_harmonic.prm.bak
 delete mode 100644 tests/average_pick_largest.prm.bak
 delete mode 100644 tests/average_project_to_q1.prm.bak
 delete mode 100644 tests/background_output_writer.prm.bak
 delete mode 100644 tests/backward_advection.prm.bak
 delete mode 100644 tests/benchmark_layeredflow.cc.bak
 delete mode 100644 tests/benchmark_layeredflow.prm.bak
 delete mode 100644 tests/benchmark_particle_integration_scheme.prm.bak
 delete mode 100644 tests/blankenbach.prm.bak
 delete mode 100644 tests/blankenbach_approximation.prm.bak
 delete mode 100644 tests/blankenbach_case1a.cc.bak
 delete mode 100644 tests/blankenbach_case1a.prm.bak
 delete mode 100644 tests/blankenbach_case1b.cc.bak
 delete mode 100644 tests/blankenbach_case1b.prm.bak
 delete mode 100644 tests/blankenbach_case1c.cc.bak
 delete mode 100644 tests/blankenbach_case1c.prm.bak
 delete mode 100644 tests/blankenbach_case2a.cc.bak
 delete mode 100644 tests/blankenbach_case2a.prm.bak
 delete mode 100644 tests/blankenbach_case2b.cc.bak
 delete mode 100644 tests/blankenbach_case2b.prm.bak
 delete mode 100644 tests/boukare_bulk_composition.prm.bak
 delete mode 100644 tests/boukare_conserve_mass.prm.bak
 delete mode 100644 tests/boukare_latent_heat.prm.bak
 delete mode 100644 tests/boukare_melting_diagram.prm.bak
 delete mode 100644 tests/boundary_composition_list.prm.bak
 delete mode 100644 tests/boundary_composition_passive_cartesian.prm.bak
 delete mode 100644 tests/boundary_composition_passive_depth.prm.bak
 delete mode 100644 tests/boundary_composition_passive_sphere.prm.bak
 delete mode 100644 tests/boundary_heatflux.prm.bak
 delete mode 100644 tests/boundary_heatflux_update.cc.bak
 delete mode 100644 tests/boundary_heatflux_update.prm.bak
 delete mode 100644 tests/boundary_temperature_function.prm.bak
 delete mode 100644 tests/boundary_temperature_list.prm.bak
 delete mode 100644 tests/boundary_traction_function_cartesian_free_surface.prm.bak
 delete mode 100644 tests/boundary_traction_function_spherical_free_surface.prm.bak
 delete mode 100644 tests/boundary_velocity_function_spherical.prm.bak
 delete mode 100644 tests/box_end_time_1e7_terminate.prm.bak
 delete mode 100644 tests/box_first_time_step.prm.bak
 delete mode 100644 tests/box_first_time_step_alternate_bc.prm.bak
 delete mode 100644 tests/box_initial_mesh_deformation.cc.bak
 delete mode 100644 tests/box_initial_mesh_deformation.prm.bak
 delete mode 100644 tests/box_initial_mesh_deformation_ascii_data.prm.bak
 delete mode 100644 tests/box_initial_mesh_deformation_periodic.cc.bak
 delete mode 100644 tests/box_initial_mesh_deformation_periodic.prm.bak
 delete mode 100644 tests/box_initial_topography_ascii_data.prm.bak
 delete mode 100644 tests/box_initial_topography_ascii_data_moved_origin.prm.bak
 delete mode 100644 tests/box_initial_topography_function.prm.bak
 delete mode 100644 tests/box_initial_topography_prm_polygon.prm.bak
 delete mode 100644 tests/box_lithostatic_pressure_2d.prm.bak
 delete mode 100644 tests/box_lithostatic_pressure_3d.prm.bak
 delete mode 100644 tests/box_origin.prm.bak
 delete mode 100644 tests/box_repetitions.prm.bak
 delete mode 100644 tests/box_simple_log_viscosity_depth_average.prm.bak
 delete mode 100644 tests/box_simple_surface_strain_rate_residual.prm.bak
 delete mode 100644 tests/box_steady_state_terminate.prm.bak
 delete mode 100644 tests/box_steady_temperature_terminate.prm.bak
 delete mode 100644 tests/box_surface_base_variables.prm.bak
 delete mode 100644 tests/bunge_cookbook.prm.bak
 delete mode 100644 tests/burnman_seismic_test.prm.bak
 delete mode 100644 tests/burnman_test.prm.bak
 delete mode 100644 tests/burstedde.cc.bak
 delete mode 100644 tests/burstedde.prm.bak
 delete mode 100644 tests/burstedde_stokes_rhs.cc.bak
 delete mode 100644 tests/burstedde_stokes_rhs.prm.bak
 delete mode 100644 tests/cell_reference.cc.bak
 delete mode 100644 tests/cell_reference.prm.bak
 delete mode 100644 tests/cells_in_circumference.prm.bak
 delete mode 100644 tests/check_compositional_field_functions.cc.bak
 delete mode 100644 tests/check_compositional_field_functions.prm.bak
 delete mode 100644 tests/check_compositional_field_names.cc.bak
 delete mode 100644 tests/check_compositional_field_names.prm.bak
 delete mode 100644 tests/checkpoint_01.cc.bak
 delete mode 100644 tests/checkpoint_01.prm.bak
 delete mode 100644 tests/checkpoint_01_check_parameters.cc.bak
 delete mode 100644 tests/checkpoint_01_check_parameters.prm.bak
 delete mode 100644 tests/checkpoint_02.cc.bak
 delete mode 100644 tests/checkpoint_02.prm.bak
 delete mode 100644 tests/checkpoint_02_direct.cc.bak
 delete mode 100644 tests/checkpoint_02_direct.prm.bak
 delete mode 100644 tests/checkpoint_03_particles.cc.bak
 delete mode 100644 tests/checkpoint_03_particles.prm.bak
 delete mode 100644 tests/checkpoint_04_particles_no_output.cc.bak
 delete mode 100644 tests/checkpoint_04_particles_no_output.prm.bak
 delete mode 100644 tests/checkpoint_05_mpi_create.prm.bak
 delete mode 100644 tests/checkpoint_05_mpi_resume.cc.bak
 delete mode 100644 tests/checkpoint_05_mpi_resume.prm.bak
 delete mode 100644 tests/checkpoint_06_spherical_shell.cc.bak
 delete mode 100644 tests/checkpoint_06_spherical_shell.prm.bak
 delete mode 100644 tests/checkpoint_07_enable_free_surface_create.prm.bak
 delete mode 100644 tests/checkpoint_07_enable_free_surface_resume.cc.bak
 delete mode 100644 tests/checkpoint_07_enable_free_surface_resume.prm.bak
 delete mode 100644 tests/chunk_ascii_initial_temperature.prm.bak
 delete mode 100644 tests/chunk_conditions.prm.bak
 delete mode 100644 tests/chunk_cross_hemisphere.prm.bak
 delete mode 100644 tests/chunk_first_time_step_2d.prm.bak
 delete mode 100644 tests/chunk_first_time_step_3d.prm.bak
 delete mode 100644 tests/chunk_initial_topography_ascii_data.prm.bak
 delete mode 100644 tests/chunk_initial_topography_ascii_data_3d.prm.bak
 delete mode 100644 tests/chunk_initial_topography_ascii_data_3d_colatitude.prm.bak
 delete mode 100644 tests/chunk_lithostatic_pressure_2d.prm.bak
 delete mode 100644 tests/chunk_lithostatic_pressure_2d_initial_topography.prm.bak
 delete mode 100644 tests/chunk_tangential_velocity.prm.bak
 delete mode 100644 tests/chunk_topography_postprocessor.prm.bak
 delete mode 100644 tests/command_postprocessor.prm.bak
 delete mode 100644 tests/compaction_length_refinement.prm.bak
 delete mode 100644 tests/compaction_length_visualization.prm.bak
 delete mode 100644 tests/composite_viscous_outputs.cc.bak
 delete mode 100644 tests/composite_viscous_outputs.prm.bak
 delete mode 100644 tests/compositing_02.prm.bak
 delete mode 100644 tests/compositing_named_outputs.prm.bak
 delete mode 100644 tests/composition_active.prm.bak
 delete mode 100644 tests/composition_active_nans.prm.bak
 delete mode 100644 tests/composition_active_with_melt.cc.bak
 delete mode 100644 tests/composition_active_with_melt.prm.bak
 delete mode 100644 tests/composition_active_without_melt.cc.bak
 delete mode 100644 tests/composition_active_without_melt.prm.bak
 delete mode 100644 tests/composition_cg_dg_fem.prm.bak
 delete mode 100644 tests/composition_names.prm.bak
 delete mode 100644 tests/composition_names_duplicates.prm.bak
 delete mode 100644 tests/composition_passive_discontinuous_constant.prm.bak
 delete mode 100644 tests/composition_passive_particles.prm.bak
 delete mode 100644 tests/composition_passive_quarter_shell_cartesian.prm.bak
 delete mode 100644 tests/composition_passive_quarter_shell_depth.prm.bak
 delete mode 100644 tests/composition_passive_quarter_shell_spherical.prm.bak
 delete mode 100644 tests/composition_passive_static.prm.bak
 delete mode 100644 tests/composition_reaction.prm.bak
 delete mode 100644 tests/composition_reaction_iterated_IMPES.cc.bak
 delete mode 100644 tests/composition_reaction_iterated_IMPES.prm.bak
 delete mode 100644 tests/composition_stabilization.prm.bak
 delete mode 100644 tests/compositional_boundary_values.prm.bak
 delete mode 100644 tests/compositional_boundary_values_02.prm.bak
 delete mode 100644 tests/compositional_boundary_values_03.prm.bak
 delete mode 100644 tests/compositional_heating.prm.bak
 delete mode 100644 tests/compositional_heating_exclude_background.prm.bak
 delete mode 100644 tests/compositional_vectors.prm.bak
 delete mode 100644 tests/compositional_vectors_3d.prm.bak
 delete mode 100644 tests/compressibility.cc.bak
 delete mode 100644 tests/compressibility.prm.bak
 delete mode 100644 tests/compressibility_iterated_stokes.cc.bak
 delete mode 100644 tests/compressibility_iterated_stokes.prm.bak
 delete mode 100644 tests/compressibility_iterated_stokes_direct_solver.cc.bak
 delete mode 100644 tests/compressibility_iterated_stokes_direct_solver.prm.bak
 delete mode 100644 tests/compressibility_lateral_pipe.cc.bak
 delete mode 100644 tests/compressibility_lateral_pipe.prm.bak
 delete mode 100644 tests/compressibility_lateral_pipe_advect.cc.bak
 delete mode 100644 tests/compressibility_lateral_pipe_advect.prm.bak
 delete mode 100644 tests/compressibility_lateral_pipe_advect_projected_density.cc.bak
 delete mode 100644 tests/compressibility_lateral_pipe_advect_projected_density.prm.bak
 delete mode 100644 tests/compressibility_lateral_pipe_increase_pressure.cc.bak
 delete mode 100644 tests/compressibility_lateral_pipe_increase_pressure.prm.bak
 delete mode 100644 tests/compressibility_lateral_pipe_increase_pressure_projected_density.cc.bak
 delete mode 100644 tests/compressibility_lateral_pipe_increase_pressure_projected_density.prm.bak
 delete mode 100644 tests/compressibility_lateral_pipe_projected_density.cc.bak
 delete mode 100644 tests/compressibility_lateral_pipe_projected_density.prm.bak
 delete mode 100644 tests/compressibility_lateral_pipe_transient.cc.bak
 delete mode 100644 tests/compressibility_lateral_pipe_transient.prm.bak
 delete mode 100644 tests/compressibility_lateral_pipe_transient_projected_density.cc.bak
 delete mode 100644 tests/compressibility_lateral_pipe_transient_projected_density.prm.bak
 delete mode 100644 tests/compressibility_vertical_pipe.cc.bak
 delete mode 100644 tests/compressibility_vertical_pipe.prm.bak
 delete mode 100644 tests/compressibility_vertical_pipe_projected_density.cc.bak
 delete mode 100644 tests/compressibility_vertical_pipe_projected_density.prm.bak
 delete mode 100644 tests/compressibility_volumetric_strain_rate.cc.bak
 delete mode 100644 tests/compressibility_volumetric_strain_rate.prm.bak
 delete mode 100644 tests/compressible_forsterite_box.prm.bak
 delete mode 100644 tests/compression_heating.cc.bak
 delete mode 100644 tests/compression_heating.prm.bak
 delete mode 100644 tests/compute-no-normal-flux-constraints.prm.bak
 delete mode 100644 tests/conservative_with_mpi.cc.bak
 delete mode 100644 tests/conservative_with_mpi.prm.bak
 delete mode 100644 tests/consistent_boundary_flux_adjacent_dirichlet.prm.bak
 delete mode 100644 tests/consistent_boundary_flux_neumann.prm.bak
 delete mode 100644 tests/consistent_boundary_flux_open_boundary.prm.bak
 delete mode 100644 tests/constant_composition_convergence.prm.bak
 delete mode 100644 tests/constant_temperature_boundary_conditions.prm.bak
 delete mode 100644 tests/continental_extension.prm.bak
 delete mode 100644 tests/convection_box_particles.prm.bak
 delete mode 100644 tests/convection_box_phase_function.prm.bak
 delete mode 100644 tests/cookbook_mantle_convection_annulus.prm.bak
 delete mode 100644 tests/cookbook_simpler_with_crust.cc.bak
 delete mode 100644 tests/coordinate_transformation.cc.bak
 delete mode 100644 tests/coordinate_transformation.prm.bak
 delete mode 100644 tests/coupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
 delete mode 100644 tests/cpo_simple_shearbox.prm.bak
 delete mode 100644 tests/crameri_benchmark_1_gmg.cc.bak
 delete mode 100644 tests/crameri_benchmark_1_gmg.prm.bak
 delete mode 100644 tests/crustal_model_3D.prm.bak
 delete mode 100644 tests/custom_spherical_shell_2d_list.prm.bak
 delete mode 100644 tests/custom_spherical_shell_2d_slices.prm.bak
 delete mode 100644 tests/custom_spherical_shell_3d_list.prm.bak
 delete mode 100644 tests/custom_spherical_shell_3d_slices.prm.bak
 delete mode 100644 tests/damped_viscoelastic_bending_beam.prm.bak
 delete mode 100644 tests/darcy_velocity.cc.bak
 delete mode 100644 tests/darcy_velocity.prm.bak
 delete mode 100644 tests/darcy_velocity_vertical.cc.bak
 delete mode 100644 tests/darcy_velocity_vertical.prm.bak
 delete mode 100644 tests/dash_dash.cc.bak
 delete mode 100644 tests/dash_dash.prm.bak
 delete mode 100644 tests/dc_Picard_compressible.prm.bak
 delete mode 100644 tests/density_boundary.prm.bak
 delete mode 100644 tests/depth_average_01.prm.bak
 delete mode 100644 tests/depth_average_02.prm.bak
 delete mode 100644 tests/depth_average_03.prm.bak
 delete mode 100644 tests/depth_average_04.prm.bak
 delete mode 100644 tests/depth_average_05.prm.bak
 delete mode 100644 tests/depth_average_06.prm.bak
 delete mode 100644 tests/depth_average_rounding_bug.prm.bak
 delete mode 100644 tests/depth_average_txt_output.prm.bak
 delete mode 100644 tests/depth_average_underres.prm.bak
 delete mode 100644 tests/depth_dependent_3d_shell_list_simple.prm.bak
 delete mode 100644 tests/depth_dependent_additional_outputs.prm.bak
 delete mode 100644 tests/depth_dependent_box_file_simple.prm.bak
 delete mode 100644 tests/depth_dependent_box_function_simple.prm.bak
 delete mode 100644 tests/depth_dependent_box_function_time_dependent.prm.bak
 delete mode 100644 tests/depth_dependent_box_none_simple.prm.bak
 delete mode 100644 tests/depth_dependent_initialize_base_model.prm.bak
 delete mode 100644 tests/depth_postprocessor_box.prm.bak
 delete mode 100644 tests/depth_postprocessor_chunk.prm.bak
 delete mode 100644 tests/depth_postprocessor_ellipsoidal_chunk.prm.bak
 delete mode 100644 tests/depth_postprocessor_sphere.prm.bak
 delete mode 100644 tests/depth_postprocessor_spherical_shell.prm.bak
 delete mode 100644 tests/depth_postprocessor_two_merged_boxes.prm.bak
 delete mode 100644 tests/derivative_of_weighted_p_norm_average.cc.bak
 delete mode 100644 tests/derivative_of_weighted_p_norm_average.prm.bak
 delete mode 100644 tests/diffusion.prm.bak
 delete mode 100644 tests/diffusion_dislocation.prm.bak
 delete mode 100644 tests/diffusion_dislocation_fixed_strain_rate.prm.bak
 delete mode 100644 tests/diffusion_dislocation_fixed_strain_rate2.prm.bak
 delete mode 100644 tests/diffusion_dislocation_reference_density_profile.prm.bak
 delete mode 100644 tests/diffusion_velocity.prm.bak
 delete mode 100644 tests/direct_solver_1.prm.bak
 delete mode 100644 tests/direct_solver_2.prm.bak
 delete mode 100644 tests/discontinuous_composition_1.prm.bak
 delete mode 100644 tests/discontinuous_composition_bound_preserving_limiter.prm.bak
 delete mode 100644 tests/discontinuous_composition_bound_preserving_limiter_3d.prm.bak
 delete mode 100644 tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm.bak
 delete mode 100644 tests/discontinuous_composition_serial_periodic_amr.prm.bak
 delete mode 100644 tests/discontinuous_temperature.prm.bak
 delete mode 100644 tests/discontinuous_temperature_blankenbach.cc.bak
 delete mode 100644 tests/discontinuous_temperature_blankenbach.prm.bak
 delete mode 100644 tests/discontinuous_temperature_spherical_shell_3d.prm.bak
 delete mode 100644 tests/doneahuerta_3.cc.bak
 delete mode 100644 tests/doneahuerta_3.prm.bak
 delete mode 100644 tests/drucker_prager_compression.prm.bak
 delete mode 100644 tests/drucker_prager_derivatives_2d.cc.bak
 delete mode 100644 tests/drucker_prager_derivatives_2d.prm.bak
 delete mode 100644 tests/drucker_prager_derivatives_3d.cc.bak
 delete mode 100644 tests/drucker_prager_derivatives_3d.prm.bak
 delete mode 100644 tests/drucker_prager_extension.prm.bak
 delete mode 100644 tests/dynamic_core.prm.bak
 delete mode 100644 tests/dynamic_friction.prm.bak
 delete mode 100644 tests/dynamic_topography.prm.bak
 delete mode 100644 tests/dynamic_topography2.prm.bak
 delete mode 100644 tests/dynamic_topography3.prm.bak
 delete mode 100644 tests/dynamic_topography_back.prm.bak
 delete mode 100644 tests/dynamic_topography_vs_surface_dynamic_topography.prm.bak
 delete mode 100644 tests/edit_parameters.cc.bak
 delete mode 100644 tests/edit_parameters.prm.bak
 delete mode 100644 tests/elastic_stabilization_time_scale_factor.prm.bak
 delete mode 100644 tests/ellipsoidal_chunk_coordinate_parallel.prm.bak
 delete mode 100644 tests/ellipsoidal_chunk_geometry.cc.bak
 delete mode 100644 tests/ellipsoidal_chunk_geometry.prm.bak
 delete mode 100644 tests/ellipsoidal_chunk_noncoordinate_parallel.prm.bak
 delete mode 100644 tests/ellipsoidal_chunk_topography.prm.bak
 delete mode 100644 tests/entropy_adiabat.cc.bak
 delete mode 100644 tests/entropy_adiabat.prm.bak
 delete mode 100644 tests/entropy_conduction.cc.bak
 delete mode 100644 tests/entropy_conduction.prm.bak
 delete mode 100644 tests/entropy_half_space.cc.bak
 delete mode 100644 tests/entropy_half_space.prm.bak
 delete mode 100644 tests/entropy_initial_lookup.cc.bak
 delete mode 100644 tests/entropy_initial_lookup.prm.bak
 delete mode 100644 tests/entropy_initial_lookup_wb.cc.bak
 delete mode 100644 tests/entropy_initial_lookup_wb.prm.bak
 delete mode 100644 tests/entropy_plasticity.cc.bak
 delete mode 100644 tests/entropy_plasticity.prm.bak
 delete mode 100644 tests/entropy_read_multi_table.cc.bak
 delete mode 100644 tests/entropy_read_multi_table.prm.bak
 delete mode 100644 tests/entropy_viscosity_statistics.prm.bak
 delete mode 100644 tests/exponential_decay.cc.bak
 delete mode 100644 tests/exponential_decay.prm.bak
 delete mode 100644 tests/fail.prm.bak
 delete mode 100644 tests/find_boundary_composition_model.cc.bak
 delete mode 100644 tests/find_boundary_composition_model.prm.bak
 delete mode 100644 tests/find_boundary_composition_model_fail_1.cc.bak
 delete mode 100644 tests/find_boundary_composition_model_fail_1.prm.bak
 delete mode 100644 tests/find_mesh_refinement.cc.bak
 delete mode 100644 tests/find_mesh_refinement.prm.bak
 delete mode 100644 tests/find_mesh_refinement_fail_1.cc.bak
 delete mode 100644 tests/find_mesh_refinement_fail_1.prm.bak
 delete mode 100644 tests/find_postprocess.cc.bak
 delete mode 100644 tests/find_postprocess.prm.bak
 delete mode 100644 tests/find_postprocess_fail_1.cc.bak
 delete mode 100644 tests/find_postprocess_fail_1.prm.bak
 delete mode 100644 tests/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg.prm.bak
 delete mode 100644 tests/free_surface_adaptive_blob.prm.bak
 delete mode 100644 tests/free_surface_blob.prm.bak
 delete mode 100644 tests/free_surface_blob_gmg.prm.bak
 delete mode 100644 tests/free_surface_blob_melt.cc.bak
 delete mode 100644 tests/free_surface_blob_melt.prm.bak
 delete mode 100644 tests/free_surface_blob_nonzero_melt.cc.bak
 delete mode 100644 tests/free_surface_blob_nonzero_melt.prm.bak
 delete mode 100644 tests/free_surface_iterated_IMPES.prm.bak
 delete mode 100644 tests/free_surface_iterated_stokes.prm.bak
 delete mode 100644 tests/free_surface_iterated_stokes_gmg.prm.bak
 delete mode 100644 tests/free_surface_relaxation.cc.bak
 delete mode 100644 tests/free_surface_relaxation.prm.bak
 delete mode 100644 tests/free_surface_tangential_mesh_velocity.prm.bak
 delete mode 100644 tests/free_surface_tangential_mesh_velocity_2.prm.bak
 delete mode 100644 tests/free_surface_timestep_repeat.prm.bak
 delete mode 100644 tests/function_mesh_deformation_tangential_mesh_velocity.prm.bak
 delete mode 100644 tests/gaussian_initial_temperature.prm.bak
 delete mode 100644 tests/geoid.prm.bak
 delete mode 100644 tests/geoid_freesurface.prm.bak
 delete mode 100644 tests/geoid_no_topo.prm.bak
 delete mode 100644 tests/geoid_visualization.prm.bak
 delete mode 100644 tests/geometric_average_crash.prm.bak
 delete mode 100644 tests/geometric_average_only_viscosity.prm.bak
 delete mode 100644 tests/global_latent_heat.prm.bak
 delete mode 100644 tests/global_melt.prm.bak
 delete mode 100644 tests/global_melt_parallel.prm.bak
 delete mode 100644 tests/global_refine_amr.cc.bak
 delete mode 100644 tests/global_refine_amr.prm.bak
 delete mode 100644 tests/global_refine_bug.prm.bak
 delete mode 100644 tests/gmg_mesh_deform.prm.bak
 delete mode 100644 tests/gmg_mesh_deform_adaptive.prm.bak
 delete mode 100644 tests/gmg_mesh_deform_adaptive_bug.prm.bak
 delete mode 100644 tests/gmg_mesh_deform_adaptive_bug2.prm.bak
 delete mode 100644 tests/gmg_mesh_deform_function.prm.bak
 delete mode 100644 tests/gmg_mesh_deform_ghost_entries.prm.bak
 delete mode 100644 tests/gmg_mesh_deform_prescribed.cc.bak
 delete mode 100644 tests/gmg_mesh_deform_prescribed.prm.bak
 delete mode 100644 tests/gmg_mesh_deform_topo.prm.bak
 delete mode 100644 tests/gmg_no_normal_flux_only.prm.bak
 delete mode 100644 tests/gmg_test_project_q1.prm.bak
 delete mode 100644 tests/gmg_velocity_boundary_2d_box_no_flux.prm.bak
 delete mode 100644 tests/gmg_velocity_boundary_2d_box_no_normal_flux.prm.bak
 delete mode 100644 tests/gmg_velocity_boundary_2d_chunk_no_flux.prm.bak
 delete mode 100644 tests/gmg_velocity_boundary_2d_chunk_no_normal_flux.prm.bak
 delete mode 100644 tests/gmg_velocity_boundary_3d_box_no_flux.prm.bak
 delete mode 100644 tests/gmg_velocity_boundary_3d_box_no_normal_flux.prm.bak
 delete mode 100644 tests/gmg_velocity_boundary_3d_chunk_no_flux.prm.bak
 delete mode 100644 tests/gmg_velocity_boundary_3d_chunk_no_normal_flux.prm.bak
 delete mode 100644 tests/gmg_velocity_boundary_component.prm.bak
 delete mode 100644 tests/gplates_1_3.prm.bak
 delete mode 100644 tests/gplates_1_4.prm.bak
 delete mode 100644 tests/gplates_3d.prm.bak
 delete mode 100644 tests/gplates_rotation.prm.bak
 delete mode 100644 tests/gplates_scale_factor.prm.bak
 delete mode 100644 tests/grain_lag_angle.prm.bak
 delete mode 100644 tests/grain_size_additional_outputs.prm.bak
 delete mode 100644 tests/grain_size_averaging.prm.bak
 delete mode 100644 tests/grain_size_crossed_transition.prm.bak
 delete mode 100644 tests/grain_size_friction_heating.prm.bak
 delete mode 100644 tests/grain_size_growth.prm.bak
 delete mode 100644 tests/grain_size_growth_one_cell.prm.bak
 delete mode 100644 tests/grain_size_growth_one_cell_particles.prm.bak
 delete mode 100644 tests/grain_size_growth_particles.prm.bak
 delete mode 100644 tests/grain_size_growth_pinned.prm.bak
 delete mode 100644 tests/grain_size_latent_heat.cc.bak
 delete mode 100644 tests/grain_size_latent_heat.prm.bak
 delete mode 100644 tests/grain_size_phase_function.prm.bak
 delete mode 100644 tests/grain_size_plunge.prm.bak
 delete mode 100644 tests/grain_size_ridge.prm.bak
 delete mode 100644 tests/grain_size_ridge_traction.prm.bak
 delete mode 100644 tests/grain_size_strain.prm.bak
 delete mode 100644 tests/grain_size_strain_pinned.prm.bak
 delete mode 100644 tests/grain_size_strain_pinned_state.prm.bak
 delete mode 100644 tests/grain_size_yield.prm.bak
 delete mode 100644 tests/graphical_output.cc.bak
 delete mode 100644 tests/graphical_output.prm.bak
 delete mode 100644 tests/graphical_output_02.prm.bak
 delete mode 100644 tests/graphical_output_hdf5.cc.bak
 delete mode 100644 tests/graphical_output_hdf5.prm.bak
 delete mode 100644 tests/gravity_function.prm.bak
 delete mode 100644 tests/gravity_function_time.prm.bak
 delete mode 100644 tests/gravity_model_cartesian.prm.bak
 delete mode 100644 tests/gravity_model_depth.prm.bak
 delete mode 100644 tests/gravity_model_spherical.prm.bak
 delete mode 100644 tests/gravity_point_values_list.prm.bak
 delete mode 100644 tests/gravity_point_values_map.prm.bak
 delete mode 100644 tests/gravity_point_values_spiral.prm.bak
 delete mode 100644 tests/gravity_point_values_spiral_parallel.prm.bak
 delete mode 100644 tests/gravity_prem.prm.bak
 delete mode 100644 tests/gravity_quadrature_degree_increase.prm.bak
 delete mode 100644 tests/gs_drucker_prager.prm.bak
 delete mode 100644 tests/gs_drucker_prager_extension.prm.bak
 delete mode 100644 tests/gs_drucker_prager_extension_adiabatic.prm.bak
 delete mode 100644 tests/heat_advection_by_melt.cc.bak
 delete mode 100644 tests/heat_advection_by_melt.prm.bak
 delete mode 100644 tests/heat_advection_by_melt_operator_splitting.cc.bak
 delete mode 100644 tests/heat_advection_by_melt_operator_splitting.prm.bak
 delete mode 100644 tests/heat_flow.prm.bak
 delete mode 100644 tests/heat_flow_plume.prm.bak
 delete mode 100644 tests/heat_flux_densities.prm.bak
 delete mode 100644 tests/heat_flux_map.prm.bak
 delete mode 100644 tests/heat_flux_map_vis.prm.bak
 delete mode 100644 tests/heat_flux_map_vis_point_wise.prm.bak
 delete mode 100644 tests/heating_function.prm.bak
 delete mode 100644 tests/heating_function_depth.prm.bak
 delete mode 100644 tests/heating_function_spherical.prm.bak
 delete mode 100644 tests/hexagonal_initial_temperature.prm.bak
 delete mode 100644 tests/hill_diffusion.prm.bak
 delete mode 100644 tests/hill_diffusion_3D.prm.bak
 delete mode 100644 tests/hk04_olivine_composite_hydration_prefactor.prm.bak
 delete mode 100644 tests/hk04_olivine_composite_hydration_prefactor_cutoff.prm.bak
 delete mode 100644 tests/hk04_olivine_diffusion_hydration_prefactor.prm.bak
 delete mode 100644 tests/hk04_olivine_dislocation_hydration_prefactor.prm.bak
 delete mode 100644 tests/hollow_sphere.cc.bak
 delete mode 100644 tests/hollow_sphere.prm.bak
 delete mode 100644 tests/hollow_sphere_gmg.cc.bak
 delete mode 100644 tests/hollow_sphere_gmg.prm.bak
 delete mode 100644 tests/hollow_sphere_gmg_project_q1.cc.bak
 delete mode 100644 tests/hollow_sphere_gmg_project_q1.prm.bak
 delete mode 100644 tests/hollow_sphere_gmg_q3.cc.bak
 delete mode 100644 tests/hollow_sphere_gmg_q3.prm.bak
 delete mode 100644 tests/hydrostatic_compression.cc.bak
 delete mode 100644 tests/hydrostatic_compression.prm.bak
 delete mode 100644 tests/inclusion_2.cc.bak
 delete mode 100644 tests/inclusion_2.prm.bak
 delete mode 100644 tests/inclusion_4.cc.bak
 delete mode 100644 tests/inclusion_4.prm.bak
 delete mode 100644 tests/inclusion_adaptive.cc.bak
 delete mode 100644 tests/inclusion_adaptive.prm.bak
 delete mode 100644 tests/infill_density_flexure.cc.bak
 delete mode 100644 tests/infill_density_flexure.prm.bak
 delete mode 100644 tests/initial_composition_list.prm.bak
 delete mode 100644 tests/initial_composition_list_using_maximum.prm.bak
 delete mode 100644 tests/initial_composition_list_using_minimum.prm.bak
 delete mode 100644 tests/initial_composition_list_using_subtract.prm.bak
 delete mode 100644 tests/initial_condition_S20RTS.prm.bak
 delete mode 100644 tests/initial_condition_S20RTS_2D.prm.bak
 delete mode 100644 tests/initial_condition_S20RTS_dgp.prm.bak
 delete mode 100644 tests/initial_condition_S40RTS.prm.bak
 delete mode 100644 tests/initial_condition_SAVANI.prm.bak
 delete mode 100644 tests/initial_condition_lithosphere_mask.prm.bak
 delete mode 100644 tests/initial_condition_patch_on_S40RTS.prm.bak
 delete mode 100644 tests/initial_condition_vs_to_density.prm.bak
 delete mode 100644 tests/initial_condition_vs_to_density_SAVANI.prm.bak
 delete mode 100644 tests/initial_global_refinement.prm.bak
 delete mode 100644 tests/initial_porosity.prm.bak
 delete mode 100644 tests/initial_temperature_list.prm.bak
 delete mode 100644 tests/initial_temperature_list_using_maximum.prm.bak
 delete mode 100644 tests/initial_temperature_list_using_minimum.prm.bak
 delete mode 100644 tests/initial_temperature_list_using_subtract.prm.bak
 delete mode 100644 tests/initial_temperature_profile.prm.bak
 delete mode 100644 tests/inner_core.cc.bak
 delete mode 100644 tests/inner_core.prm.bak
 delete mode 100644 tests/internal_heating_statistics.prm.bak
 delete mode 100644 tests/interpolor_particles_harmonic_average.prm.bak
 delete mode 100644 tests/interpolor_particles_nearest_neighbor.prm.bak
 delete mode 100644 tests/interpolor_particles_quadratic_least_squares.prm.bak
 delete mode 100644 tests/isosurfaces_simple_box_2D.prm.bak
 delete mode 100644 tests/isosurfaces_simple_box_2D_custom_fieldnames.prm.bak
 delete mode 100644 tests/isosurfaces_simple_box_2D_custom_fieldnames_fail.prm.bak
 delete mode 100644 tests/isosurfaces_simple_box_2D_min_max_1.prm.bak
 delete mode 100644 tests/isosurfaces_simple_box_2D_min_max_2.prm.bak
 delete mode 100644 tests/isosurfaces_simple_box_3D.prm.bak
 delete mode 100644 tests/isosurfaces_slab_2D.prm.bak
 delete mode 100644 tests/isosurfaces_slab_3D.prm.bak
 delete mode 100644 tests/iterated_advection_and_defect_correction_Stokes.prm.bak
 delete mode 100644 tests/iterated_advection_and_stokes.prm.bak
 delete mode 100644 tests/iterated_advection_and_stokes_DG.prm.bak
 delete mode 100644 tests/iterated_advection_and_stokes_DG_limiter.prm.bak
 delete mode 100644 tests/iterated_advection_and_stokes_direct_solver.prm.bak
 delete mode 100644 tests/iterated_advection_and_stokes_residual.prm.bak
 delete mode 100644 tests/kaus_rayleigh_taylor_instability.prm.bak
 delete mode 100644 tests/kinematically_driven_subduction_2d_case1.prm.bak
 delete mode 100644 tests/kinematically_driven_subduction_2d_case2a.cc.bak
 delete mode 100644 tests/kinematically_driven_subduction_2d_case2a.prm.bak
 delete mode 100644 tests/kinematically_driven_subduction_2d_case2b.cc.bak
 delete mode 100644 tests/kinematically_driven_subduction_2d_case2b.prm.bak
 delete mode 100644 tests/king_ala.cc.bak
 delete mode 100644 tests/king_ala.prm.bak
 delete mode 100644 tests/king_ala_nondim.prm.bak
 delete mode 100644 tests/latent_heat.prm.bak
 delete mode 100644 tests/latent_heat_composition.prm.bak
 delete mode 100644 tests/latent_heat_enthalpy.cc.bak
 delete mode 100644 tests/latent_heat_enthalpy.prm.bak
 delete mode 100644 tests/latent_heat_melt.prm.bak
 delete mode 100644 tests/latent_heat_melt_operator_split.prm.bak
 delete mode 100644 tests/latent_heat_melt_statistics.prm.bak
 delete mode 100644 tests/latent_heat_melt_transport.prm.bak
 delete mode 100644 tests/latent_heat_pressure.prm.bak
 delete mode 100644 tests/latent_heat_viscosity.prm.bak
 delete mode 100644 tests/latent_heat_viscosity_adiabatic.prm.bak
 delete mode 100644 tests/lithosphere_boundary_indicator.prm.bak
 delete mode 100644 tests/lithosphere_boundary_indicator_3d.prm.bak
 delete mode 100644 tests/lithosphere_boundary_indicator_3d_one_grid.prm.bak
 delete mode 100644 tests/lithosphere_boundary_indicator_3d_periodic.prm.bak
 delete mode 100644 tests/lithosphere_boundary_indicator_one_grid.prm.bak
 delete mode 100644 tests/lithosphere_boundary_indicator_origin.prm.bak
 delete mode 100644 tests/logo.prm.bak
 delete mode 100644 tests/magnetic_stripes.cc.bak
 delete mode 100644 tests/magnetic_stripes.prm.bak
 delete mode 100644 tests/mass_flux_statistics.prm.bak
 delete mode 100644 tests/mass_reaction_term.prm.bak
 delete mode 100644 tests/material_model_dependencies.cc.bak
 delete mode 100644 tests/material_model_dependencies_burstedde.cc.bak
 delete mode 100644 tests/material_model_dependencies_burstedde.prm.bak
 delete mode 100644 tests/material_model_dependencies_composition_reaction.cc.bak
 delete mode 100644 tests/material_model_dependencies_composition_reaction.prm.bak
 delete mode 100644 tests/material_model_dependencies_cookbooks_freesurface_with_crust.cc.bak
 delete mode 100644 tests/material_model_dependencies_cookbooks_freesurface_with_crust.prm.bak
 delete mode 100644 tests/material_model_dependencies_diffusion_dislocation.cc.bak
 delete mode 100644 tests/material_model_dependencies_diffusion_dislocation.prm.bak
 delete mode 100644 tests/material_model_dependencies_inclusion_2.cc.bak
 delete mode 100644 tests/material_model_dependencies_inclusion_2.prm.bak
 delete mode 100644 tests/material_model_dependencies_latent_heat.cc.bak
 delete mode 100644 tests/material_model_dependencies_latent_heat.prm.bak
 delete mode 100644 tests/material_model_dependencies_latent_heat_melt.cc.bak
 delete mode 100644 tests/material_model_dependencies_latent_heat_melt.prm.bak
 delete mode 100644 tests/material_model_dependencies_morency_doin.cc.bak
 delete mode 100644 tests/material_model_dependencies_morency_doin.prm.bak
 delete mode 100644 tests/material_model_dependencies_multicomponent.cc.bak
 delete mode 100644 tests/material_model_dependencies_multicomponent.prm.bak
 delete mode 100644 tests/material_model_dependencies_shear_thinning.cc.bak
 delete mode 100644 tests/material_model_dependencies_shear_thinning.prm.bak
 delete mode 100644 tests/material_model_dependencies_simple.cc.bak
 delete mode 100644 tests/material_model_dependencies_simple.prm.bak
 delete mode 100644 tests/material_model_dependencies_simple_compressible.cc.bak
 delete mode 100644 tests/material_model_dependencies_simple_compressible.prm.bak
 delete mode 100644 tests/material_model_dependencies_simpler.cc.bak
 delete mode 100644 tests/material_model_dependencies_simpler.prm.bak
 delete mode 100644 tests/material_model_dependencies_solcx.cc.bak
 delete mode 100644 tests/material_model_dependencies_solcx.prm.bak
 delete mode 100644 tests/material_model_dependencies_solkz.cc.bak
 delete mode 100644 tests/material_model_dependencies_solkz.prm.bak
 delete mode 100644 tests/material_model_dependencies_steinberger.cc.bak
 delete mode 100644 tests/material_model_dependencies_steinberger.prm.bak
 delete mode 100644 tests/material_model_dependencies_tangurnis.cc.bak
 delete mode 100644 tests/material_model_dependencies_tangurnis.prm.bak
 delete mode 100644 tests/material_statistics.prm.bak
 delete mode 100644 tests/matrix_nonzeros_1.prm.bak
 delete mode 100644 tests/matrix_nonzeros_2.prm.bak
 delete mode 100644 tests/matrix_nonzeros_3.prm.bak
 delete mode 100644 tests/matrix_nonzeros_4.prm.bak
 delete mode 100644 tests/matrix_nonzeros_5.prm.bak
 delete mode 100644 tests/matrix_nonzeros_6.prm.bak
 delete mode 100644 tests/matrix_nonzeros_7.prm.bak
 delete mode 100644 tests/max_timesteps_btwn_output.prm.bak
 delete mode 100644 tests/maximum_horizontal_compressive_stress_case_one.prm.bak
 delete mode 100644 tests/maximum_horizontal_compressive_stress_case_two.prm.bak
 delete mode 100644 tests/maximum_refinement_function.prm.bak
 delete mode 100644 tests/maximum_refinement_function_cartesian.prm.bak
 delete mode 100644 tests/maximum_refinement_function_spherical.prm.bak
 delete mode 100644 tests/maxtimestep.prm.bak
 delete mode 100644 tests/melt_and_traction.prm.bak
 delete mode 100644 tests/melt_boukare_EOS.prm.bak
 delete mode 100644 tests/melt_boukare_averaging.prm.bak
 delete mode 100644 tests/melt_boundary_heat_flux.cc.bak
 delete mode 100644 tests/melt_boundary_heat_flux.prm.bak
 delete mode 100644 tests/melt_compressible_advection.cc.bak
 delete mode 100644 tests/melt_compressible_advection.prm.bak
 delete mode 100644 tests/melt_force_vector.cc.bak
 delete mode 100644 tests/melt_force_vector.prm.bak
 delete mode 100644 tests/melt_fraction_postprocessor.prm.bak
 delete mode 100644 tests/melt_introspection.cc.bak
 delete mode 100644 tests/melt_introspection.prm.bak
 delete mode 100644 tests/melt_material_1.cc.bak
 delete mode 100644 tests/melt_material_1.prm.bak
 delete mode 100644 tests/melt_material_2.cc.bak
 delete mode 100644 tests/melt_material_2.prm.bak
 delete mode 100644 tests/melt_material_3.cc.bak
 delete mode 100644 tests/melt_material_3.prm.bak
 delete mode 100644 tests/melt_material_4.cc.bak
 delete mode 100644 tests/melt_material_4.prm.bak
 delete mode 100644 tests/melt_postprocessor_peridotite.prm.bak
 delete mode 100644 tests/melt_postprocessor_pyroxenite.prm.bak
 delete mode 100644 tests/melt_property_visualization.cc.bak
 delete mode 100644 tests/melt_property_visualization.prm.bak
 delete mode 100644 tests/melt_restart.cc.bak
 delete mode 100644 tests/melt_restart.prm.bak
 delete mode 100644 tests/melt_statistics.prm.bak
 delete mode 100644 tests/melt_track.cc.bak
 delete mode 100644 tests/melt_track.prm.bak
 delete mode 100644 tests/melt_transport.prm.bak
 delete mode 100644 tests/melt_transport_adaptive.cc.bak
 delete mode 100644 tests/melt_transport_adaptive.prm.bak
 delete mode 100644 tests/melt_transport_compressible.cc.bak
 delete mode 100644 tests/melt_transport_compressible.prm.bak
 delete mode 100644 tests/melt_transport_compressible_iterative.cc.bak
 delete mode 100644 tests/melt_transport_compressible_iterative.prm.bak
 delete mode 100644 tests/melt_transport_convergence_simple.cc.bak
 delete mode 100644 tests/melt_transport_convergence_simple.prm.bak
 delete mode 100644 tests/melt_transport_convergence_test.cc.bak
 delete mode 100644 tests/melt_transport_convergence_test.prm.bak
 delete mode 100644 tests/melt_velocity_boundary_conditions.cc.bak
 delete mode 100644 tests/melt_velocity_boundary_conditions.prm.bak
 delete mode 100644 tests/melt_visco_plastic.cc.bak
 delete mode 100644 tests/melt_visco_plastic_mohr_circle_compaction.cc.bak
 delete mode 100644 tests/melt_visco_plastic_mohr_circle_compaction.prm.bak
 delete mode 100644 tests/melt_visco_plastic_mohr_circle_shear.cc.bak
 delete mode 100644 tests/melt_visco_plastic_mohr_circle_shear.prm.bak
 delete mode 100644 tests/melting_rate.cc.bak
 delete mode 100644 tests/melting_rate.prm.bak
 delete mode 100644 tests/melting_rate_operator_splitting.prm.bak
 delete mode 100644 tests/melting_rate_operator_splitting2.prm.bak
 delete mode 100644 tests/melting_rate_test.prm.bak
 delete mode 100644 tests/memory_statistics_1.prm.bak
 delete mode 100644 tests/merged_chunks_2D.prm.bak
 delete mode 100644 tests/merged_chunks_2D_one_grid.prm.bak
 delete mode 100644 tests/merged_chunks_3D.prm.bak
 delete mode 100644 tests/merged_chunks_3D_one_grid.prm.bak
 delete mode 100644 tests/mesh_deformation_gmg_2d_spherical_shell.prm.bak
 delete mode 100644 tests/mesh_deformation_particles.cc.bak
 delete mode 100644 tests/mesh_deformation_particles.prm.bak
 delete mode 100644 tests/mesh_velocity_output.prm.bak
 delete mode 100644 tests/mid_ocean_ridge.prm.bak
 delete mode 100644 tests/minimum_refinement_function.prm.bak
 delete mode 100644 tests/minimum_refinement_function_cartesian.prm.bak
 delete mode 100644 tests/minimum_refinement_function_spherical.prm.bak
 delete mode 100644 tests/minimum_refinement_function_time_dependent.prm.bak
 delete mode 100644 tests/modified_tait_forsterite_box.prm.bak
 delete mode 100644 tests/morency_doin.cc.bak
 delete mode 100644 tests/morency_doin.prm.bak
 delete mode 100644 tests/multicomponent_arithmetic.prm.bak
 delete mode 100644 tests/multicomponent_compressible_averaging.prm.bak
 delete mode 100644 tests/multicomponent_geometric.prm.bak
 delete mode 100644 tests/multicomponent_harmonic.prm.bak
 delete mode 100644 tests/multicomponent_max_composition.prm.bak
 delete mode 100644 tests/multicomponent_steinberger.prm.bak
 delete mode 100644 tests/multiple_named_additional_outputs.cc.bak
 delete mode 100644 tests/multiple_named_additional_outputs.prm.bak
 delete mode 100644 tests/muparser-temperature-example.prm.bak
 delete mode 100644 tests/n_expensive_stokes_solver_steps.prm.bak
 delete mode 100644 tests/natural_coordinates_conversion.cc.bak
 delete mode 100644 tests/natural_coordinates_conversion.prm.bak
 delete mode 100644 tests/netcdf_boundary_velocity_2d_box.prm.bak
 delete mode 100644 tests/newton_postprocess_nonlinear.prm.bak
 delete mode 100644 tests/no_Advection_iterated_defect_correction_Stokes.prm.bak
 delete mode 100644 tests/no_adiabatic_heating.cc.bak
 delete mode 100644 tests/no_adiabatic_heating.prm.bak
 delete mode 100644 tests/no_adiabatic_heating_02.cc.bak
 delete mode 100644 tests/no_adiabatic_heating_02.prm.bak
 delete mode 100644 tests/no_adiabatic_heating_03.cc.bak
 delete mode 100644 tests/no_adiabatic_heating_03.prm.bak
 delete mode 100644 tests/no_cheap_gmg.cc.bak
 delete mode 100644 tests/no_cheap_gmg.prm.bak
 delete mode 100644 tests/no_conduction_timestep.prm.bak
 delete mode 100644 tests/no_dirichlet_on_outflow.prm.bak
 delete mode 100644 tests/no_dirichlet_on_outflow_C.prm.bak
 delete mode 100644 tests/no_dirichlet_on_outflow_adaptive.prm.bak
 delete mode 100644 tests/no_dirichlet_on_outflow_melt.cc.bak
 delete mode 100644 tests/no_dirichlet_on_outflow_melt.prm.bak
 delete mode 100644 tests/no_dirichlet_on_outflow_only_new_constraints.prm.bak
 delete mode 100644 tests/no_dirichlet_on_outflow_refine.prm.bak
 delete mode 100644 tests/no_flow.prm.bak
 delete mode 100644 tests/non_conservative_with_mpi.cc.bak
 delete mode 100644 tests/non_conservative_with_mpi.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_iterated_IMPES.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_tractions_iterated_IMPES.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_iterated_IMPES.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_iterated_IMPES.prm.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.cc.bak
 delete mode 100644 tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.prm.bak
 delete mode 100644 tests/nonlinear_convergence_for_small_composition.cc.bak
 delete mode 100644 tests/nonlinear_convergence_for_small_composition.prm.bak
 delete mode 100644 tests/nonlinear_solver_history.cc.bak
 delete mode 100644 tests/nonlinear_solver_history.prm.bak
 delete mode 100644 tests/normalize_initial_composition.prm.bak
 delete mode 100644 tests/normalize_pressure_volume.prm.bak
 delete mode 100644 tests/nsinker.cc.bak
 delete mode 100644 tests/nsinker.prm.bak
 delete mode 100644 tests/nsinker_2d.cc.bak
 delete mode 100644 tests/nsinker_2d.prm.bak
 delete mode 100644 tests/nsinker_bfbt.cc.bak
 delete mode 100644 tests/nsinker_bfbt.prm.bak
 delete mode 100644 tests/nsinker_gmg_idr.cc.bak
 delete mode 100644 tests/nsinker_gmg_idr.prm.bak
 delete mode 100644 tests/octagonal_initial_temperature.prm.bak
 delete mode 100644 tests/octagonal_initial_temperature_ellipsoidal_chunk.prm.bak
 delete mode 100644 tests/octagonal_initial_temperature_rotated.prm.bak
 delete mode 100644 tests/onset_of_convection.prm.bak
 delete mode 100644 tests/original_prm.prm.bak
 delete mode 100644 tests/original_prm/original.prm.bak
 delete mode 100644 tests/output_averaging_arithmetic.cc.bak
 delete mode 100644 tests/output_averaging_arithmetic.prm.bak
 delete mode 100644 tests/output_averaging_harmonic.cc.bak
 delete mode 100644 tests/output_averaging_harmonic.prm.bak
 delete mode 100644 tests/own_gravity.cc.bak
 delete mode 100644 tests/own_gravity.prm.bak
 delete mode 100644 tests/parallel_output_group_0.prm.bak
 delete mode 100644 tests/parallel_output_group_1.prm.bak
 delete mode 100644 tests/parallel_output_group_2.prm.bak
 delete mode 100644 tests/parallel_refine_crash.prm.bak
 delete mode 100644 tests/particle_count_statistics.cc.bak
 delete mode 100644 tests/particle_count_statistics.prm.bak
 delete mode 100644 tests/particle_exclude_all_properties.prm.bak
 delete mode 100644 tests/particle_exclude_one_property.prm.bak
 delete mode 100644 tests/particle_exclude_one_property_vtu.prm.bak
 delete mode 100644 tests/particle_exclude_three_properties_vtu.prm.bak
 delete mode 100644 tests/particle_exclude_two_properties_vtu.prm.bak
 delete mode 100644 tests/particle_fast_evaluate_many_compositions.prm.bak
 delete mode 100644 tests/particle_fast_evaluate_multiple_compositions.prm.bak
 delete mode 100644 tests/particle_free_surface.prm.bak
 delete mode 100644 tests/particle_generator_ascii.prm.bak
 delete mode 100644 tests/particle_generator_box.prm.bak
 delete mode 100644 tests/particle_generator_box_3d.prm.bak
 delete mode 100644 tests/particle_generator_quadrature_points.prm.bak
 delete mode 100644 tests/particle_generator_radial.prm.bak
 delete mode 100644 tests/particle_generator_random_uniform.prm.bak
 delete mode 100644 tests/particle_generator_random_uniform_3mpi_1particle.prm.bak
 delete mode 100644 tests/particle_generator_random_uniform_3mpi_2particle.prm.bak
 delete mode 100644 tests/particle_generator_random_uniform_3mpi_3particle.prm.bak
 delete mode 100644 tests/particle_generator_random_uniform_3mpi_4particle.prm.bak
 delete mode 100644 tests/particle_generator_random_uniform_deterministic_cell.prm.bak
 delete mode 100644 tests/particle_generator_random_uniform_empty_rank.prm.bak
 delete mode 100644 tests/particle_generator_reference_cell.prm.bak
 delete mode 100644 tests/particle_handler_copy.cc.bak
 delete mode 100644 tests/particle_handler_copy.prm.bak
 delete mode 100644 tests/particle_initial_adaptive_output.prm.bak
 delete mode 100644 tests/particle_initial_adaptive_refinement.prm.bak
 delete mode 100644 tests/particle_integrator_euler.prm.bak
 delete mode 100644 tests/particle_integrator_rk2_first_order_time.prm.bak
 delete mode 100644 tests/particle_integrator_rk4.prm.bak
 delete mode 100644 tests/particle_interpolator_bilinear_3d.prm.bak
 delete mode 100644 tests/particle_interpolator_bilinear_3d_add_particles.prm.bak
 delete mode 100644 tests/particle_interpolator_bilinear_add_particles.cc.bak
 delete mode 100644 tests/particle_interpolator_bilinear_add_particles.prm.bak
 delete mode 100644 tests/particle_interpolator_bilinear_least_squares_solkz.cc.bak
 delete mode 100644 tests/particle_interpolator_bilinear_least_squares_solkz.prm.bak
 delete mode 100644 tests/particle_interpolator_bilinear_limiter.prm.bak
 delete mode 100644 tests/particle_interpolator_cell_average.prm.bak
 delete mode 100644 tests/particle_interpolator_cell_average_2.prm.bak
 delete mode 100644 tests/particle_interpolator_empty_cells.prm.bak
 delete mode 100644 tests/particle_interpolator_from_ghost_cells.prm.bak
 delete mode 100644 tests/particle_interpolator_harmonic_average_solkz.cc.bak
 delete mode 100644 tests/particle_interpolator_harmonic_average_solkz.prm.bak
 delete mode 100644 tests/particle_interpolator_nearest_neighbor.prm.bak
 delete mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_add_particles.cc.bak
 delete mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm.bak
 delete mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_limiter.cc.bak
 delete mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_limiter.prm.bak
 delete mode 100644 tests/particle_interpolator_quadratic_least_squares_2d_periodic.prm.bak
 delete mode 100644 tests/particle_interpolator_quadratic_least_squares_3d.prm.bak
 delete mode 100644 tests/particle_interpolator_time_dependence.prm.bak
 delete mode 100644 tests/particle_linear_accelerated_flow_rk2.prm.bak
 delete mode 100644 tests/particle_load_balancing_none.prm.bak
 delete mode 100644 tests/particle_load_balancing_refinement.prm.bak
 delete mode 100644 tests/particle_load_balancing_refinement_02.prm.bak
 delete mode 100644 tests/particle_load_balancing_removal.prm.bak
 delete mode 100644 tests/particle_load_balancing_removal_addition.prm.bak
 delete mode 100644 tests/particle_load_balancing_removal_addition_properties.prm.bak
 delete mode 100644 tests/particle_load_balancing_repartition.prm.bak
 delete mode 100644 tests/particle_load_balancing_repartition_1000.prm.bak
 delete mode 100644 tests/particle_melt_advection.cc.bak
 delete mode 100644 tests/particle_melt_advection.prm.bak
 delete mode 100644 tests/particle_output_gnuplot.prm.bak
 delete mode 100644 tests/particle_output_hdf5.prm.bak
 delete mode 100644 tests/particle_output_multiple_formats.prm.bak
 delete mode 100644 tests/particle_output_none.prm.bak
 delete mode 100644 tests/particle_output_vtu.prm.bak
 delete mode 100644 tests/particle_output_vtu_group.prm.bak
 delete mode 100644 tests/particle_output_vtu_temp.prm.bak
 delete mode 100644 tests/particle_periodic_boundaries.prm.bak
 delete mode 100644 tests/particle_periodic_boundaries_dc.prm.bak
 delete mode 100644 tests/particle_periodic_boundaries_rk4.prm.bak
 delete mode 100644 tests/particle_periodic_quarter_shell.prm.bak
 delete mode 100644 tests/particle_periodic_quarter_shell_2.prm.bak
 delete mode 100644 tests/particle_property_composition.cc.bak
 delete mode 100644 tests/particle_property_composition.prm.bak
 delete mode 100644 tests/particle_property_function.prm.bak
 delete mode 100644 tests/particle_property_initial_composition.prm.bak
 delete mode 100644 tests/particle_property_initial_composition_boundary.prm.bak
 delete mode 100644 tests/particle_property_integrated_strain_invariant.prm.bak
 delete mode 100644 tests/particle_property_integrated_strain_pure_shear.prm.bak
 delete mode 100644 tests/particle_property_integrated_strain_simple_shear.prm.bak
 delete mode 100644 tests/particle_property_multiple_functions.prm.bak
 delete mode 100644 tests/particle_property_multiple_functions_with_interpolation.prm.bak
 delete mode 100644 tests/particle_property_post_initialize_function.cc.bak
 delete mode 100644 tests/particle_property_post_initialize_function.prm.bak
 delete mode 100644 tests/particle_timing_information.prm.bak
 delete mode 100644 tests/particle_visualization_particle_count.prm.bak
 delete mode 100644 tests/particles_with_AMR_on.prm.bak
 delete mode 100644 tests/passive_comp.prm.bak
 delete mode 100644 tests/periodic_box.prm.bak
 delete mode 100644 tests/periodic_box2.prm.bak
 delete mode 100644 tests/periodic_box_freesurface.prm.bak
 delete mode 100644 tests/periodic_box_gmg.prm.bak
 delete mode 100644 tests/periodic_box_mpi4.prm.bak
 delete mode 100644 tests/periodic_compressible.prm.bak
 delete mode 100644 tests/periodic_linear_momentum.prm.bak
 delete mode 100644 tests/periodic_quarter_shell.prm.bak
 delete mode 100644 tests/plugin.cc.bak
 delete mode 100644 tests/plugin.prm.bak
 delete mode 100644 tests/plugin_dependency.cc.bak
 delete mode 100644 tests/plugin_dependency.prm.bak
 delete mode 100644 tests/plugin_dependency_redundant.cc.bak
 delete mode 100644 tests/plugin_dependency_redundant.prm.bak
 delete mode 100644 tests/plugin_dependency_redundant_02.cc.bak
 delete mode 100644 tests/plugin_dependency_redundant_02.prm.bak
 delete mode 100644 tests/point_value_01.prm.bak
 delete mode 100644 tests/point_value_02.prm.bak
 delete mode 100644 tests/point_value_02_mpi.prm.bak
 delete mode 100644 tests/point_value_03.prm.bak
 delete mode 100644 tests/point_value_natural_coordinates.prm.bak
 delete mode 100644 tests/point_value_natural_coordinates_shell.prm.bak
 delete mode 100644 tests/point_value_specific_output_times.prm.bak
 delete mode 100644 tests/poiseuille_2d.prm.bak
 delete mode 100644 tests/poiseuille_2d_horizontal_pressure_bc.prm.bak
 delete mode 100644 tests/poiseuille_2d_pressure_bc.prm.bak
 delete mode 100644 tests/poiseuille_2d_pressure_bc_gmg.prm.bak
 delete mode 100644 tests/poiseuille_3d_x_horizontal_pressure_bc.prm.bak
 delete mode 100644 tests/postprocess_initial.prm.bak
 delete mode 100644 tests/postprocess_iterations_Stokes_only.cc.bak
 delete mode 100644 tests/postprocess_iterations_Stokes_only.prm.bak
 delete mode 100644 tests/postprocess_iterations_iterated_Stokes.cc.bak
 delete mode 100644 tests/postprocess_iterations_iterated_Stokes.prm.bak
 delete mode 100644 tests/postprocess_iterations_iterated_advection_and_stokes.prm.bak
 delete mode 100644 tests/pre_data_out_build_patches.cc.bak
 delete mode 100644 tests/pre_data_out_build_patches.prm.bak
 delete mode 100644 tests/prescribed_dilation.cc.bak
 delete mode 100644 tests/prescribed_dilation.prm.bak
 delete mode 100644 tests/prescribed_dilation_gmg.cc.bak
 delete mode 100644 tests/prescribed_dilation_gmg.prm.bak
 delete mode 100644 tests/prescribed_dilation_newton.cc.bak
 delete mode 100644 tests/prescribed_dilation_newton.prm.bak
 delete mode 100644 tests/prescribed_dilation_newton_singleadvection.cc.bak
 delete mode 100644 tests/prescribed_dilation_newton_singleadvection.prm.bak
 delete mode 100644 tests/prescribed_field.cc.bak
 delete mode 100644 tests/prescribed_field.prm.bak
 delete mode 100644 tests/prescribed_field_temperature.cc.bak
 delete mode 100644 tests/prescribed_field_temperature.prm.bak
 delete mode 100644 tests/prescribed_field_temperature_max_isotherm.prm.bak
 delete mode 100644 tests/prescribed_field_with_diffusion.cc.bak
 delete mode 100644 tests/prescribed_field_with_diffusion.prm.bak
 delete mode 100644 tests/prescribed_stokes_solution.prm.bak
 delete mode 100644 tests/prescribed_stokes_solution_DG_periodic.prm.bak
 delete mode 100644 tests/prescribed_stokes_solution_melt.prm.bak
 delete mode 100644 tests/prescribed_temperature.cc.bak
 delete mode 100644 tests/prescribed_temperature.prm.bak
 delete mode 100644 tests/prescribed_temperature_in_field.cc.bak
 delete mode 100644 tests/prescribed_temperature_in_field.prm.bak
 delete mode 100644 tests/prescribed_temperature_with_diffusion.cc.bak
 delete mode 100644 tests/prescribed_temperature_with_diffusion.prm.bak
 delete mode 100644 tests/prescribed_velocity.cc.bak
 delete mode 100644 tests/prescribed_velocity.prm.bak
 delete mode 100644 tests/prescribed_velocity_boundary.cc.bak
 delete mode 100644 tests/prescribed_velocity_boundary.prm.bak
 delete mode 100644 tests/prescribed_velocity_dgp.cc.bak
 delete mode 100644 tests/prescribed_velocity_dgp.prm.bak
 delete mode 100644 tests/prescribed_viscosity_additional_outputs.prm.bak
 delete mode 100644 tests/prescribed_viscosity_happy.prm.bak
 delete mode 100644 tests/pressure_boundary.prm.bak
 delete mode 100644 tests/pressure_compatibility.prm.bak
 delete mode 100644 tests/pressure_compatibility_2.prm.bak
 delete mode 100644 tests/pressure_compatibility_3.prm.bak
 delete mode 100644 tests/pressure_compatibility_4.prm.bak
 delete mode 100644 tests/pressure_compatibility_dg.prm.bak
 delete mode 100644 tests/pressure_compatibility_dg_direct.prm.bak
 delete mode 100644 tests/pressure_compatibility_direct.prm.bak
 delete mode 100644 tests/pressure_constraint.cc.bak
 delete mode 100644 tests/pressure_constraint.prm.bak
 delete mode 100644 tests/pressure_scaling_signal.cc.bak
 delete mode 100644 tests/pressure_scaling_signal.prm.bak
 delete mode 100644 tests/principal_deviatoric_stress.cc.bak
 delete mode 100644 tests/principal_deviatoric_stress.prm.bak
 delete mode 100644 tests/prm_distance_polygon.cc.bak
 delete mode 100644 tests/prm_distance_polygon.prm.bak
 delete mode 100644 tests/prm_polygon_in_out.cc.bak
 delete mode 100644 tests/prm_polygon_in_out.prm.bak
 delete mode 100644 tests/prmbackslash.prm.bak
 delete mode 100644 tests/prmbackslash_2.cc.bak
 delete mode 100644 tests/prmbackslash_2.prm.bak
 delete mode 100644 tests/projected_density_vertical_pipe.cc.bak
 delete mode 100644 tests/projected_density_vertical_pipe.prm.bak
 delete mode 100644 tests/pure_shear.cc.bak
 delete mode 100644 tests/pure_shear.prm.bak
 delete mode 100644 tests/q1_q1.cc.bak
 delete mode 100644 tests/q1_q1.prm.bak
 delete mode 100644 tests/q1_q1_6.cc.bak
 delete mode 100644 tests/q1_q1_6.prm.bak
 delete mode 100644 tests/quarter_shell_variable_coordinate_systems_cartesian.prm.bak
 delete mode 100644 tests/quarter_shell_variable_coordinate_systems_depth.prm.bak
 delete mode 100644 tests/quarter_shell_variable_coordinate_systems_spherical.prm.bak
 delete mode 100644 tests/quick_mpi.cc.bak
 delete mode 100644 tests/quick_mpi.prm.bak
 delete mode 100644 tests/radioactive_decay.prm.bak
 delete mode 100644 tests/radiogenic_heating.prm.bak
 delete mode 100644 tests/random_perturbation_box.prm.bak
 delete mode 100644 tests/random_perturbation_chunk.prm.bak
 delete mode 100644 tests/random_perturbation_merged_boxes.prm.bak
 delete mode 100644 tests/random_perturbation_sphere.prm.bak
 delete mode 100644 tests/random_perturbation_spherical_shell.prm.bak
 delete mode 100644 tests/reactive_fluid_transport_no_reaction.prm.bak
 delete mode 100644 tests/reactive_fluid_transport_zero_solubility.prm.bak
 delete mode 100644 tests/refine_vel.prm.bak
 delete mode 100644 tests/refinement_artificial_viscosity_1.prm.bak
 delete mode 100644 tests/refinement_artificial_viscosity_2.prm.bak
 delete mode 100644 tests/refinement_artificial_viscosity_3.prm.bak
 delete mode 100644 tests/refinement_boundary.prm.bak
 delete mode 100644 tests/refinement_composition_gradient.prm.bak
 delete mode 100644 tests/refinement_composition_threshold.prm.bak
 delete mode 100644 tests/refinement_nonadiabatic_temperature.prm.bak
 delete mode 100644 tests/refinement_strainrate.prm.bak
 delete mode 100644 tests/refinement_switch.prm.bak
 delete mode 100644 tests/refinement_topography.cc.bak
 delete mode 100644 tests/refinement_topography.prm.bak
 delete mode 100644 tests/remove_angular_momentum.prm.bak
 delete mode 100644 tests/remove_angular_momentum_3d.prm.bak
 delete mode 100644 tests/remove_net_rotation.prm.bak
 delete mode 100644 tests/remove_net_rotation_3d.prm.bak
 delete mode 100644 tests/remove_net_surface_rotation.prm.bak
 delete mode 100644 tests/replace_lithosphere_viscosity_file.prm.bak
 delete mode 100644 tests/resume_free_surface.cc.bak
 delete mode 100644 tests/resume_free_surface.prm.bak
 delete mode 100644 tests/rheology_scaled_profile.cc.bak
 delete mode 100644 tests/rheology_scaled_profile.prm.bak
 delete mode 100644 tests/rigid_shear_instantaneous.cc.bak
 delete mode 100644 tests/rigid_shear_instantaneous.prm.bak
 delete mode 100644 tests/rigid_shear_steady_state.cc.bak
 delete mode 100644 tests/rigid_shear_steady_state.prm.bak
 delete mode 100644 tests/rigid_shear_transient.cc.bak
 delete mode 100644 tests/rigid_shear_transient.prm.bak
 delete mode 100644 tests/rising_melt_blob.cc.bak
 delete mode 100644 tests/rising_melt_blob.prm.bak
 delete mode 100644 tests/rising_melt_blob_freezing.prm.bak
 delete mode 100644 tests/rotation_statistics.prm.bak
 delete mode 100644 tests/rotation_statistics_3d.prm.bak
 delete mode 100644 tests/rotation_statistics_3d_asymmetric.prm.bak
 delete mode 100644 tests/rotation_statistics_3d_surface.prm.bak
 delete mode 100644 tests/sea_level_postprocessor.prm.bak
 delete mode 100644 tests/segregation_heating.cc.bak
 delete mode 100644 tests/segregation_heating.prm.bak
 delete mode 100644 tests/shear_bands.cc.bak
 delete mode 100644 tests/shear_bands.prm.bak
 delete mode 100644 tests/shear_heating.prm.bak
 delete mode 100644 tests/shear_heating_compressible.prm.bak
 delete mode 100644 tests/shear_heating_compressible_melt.prm.bak
 delete mode 100644 tests/shear_heating_limited.prm.bak
 delete mode 100644 tests/shear_heating_with_melt.prm.bak
 delete mode 100644 tests/shear_thinning.cc.bak
 delete mode 100644 tests/shear_thinning.prm.bak
 delete mode 100644 tests/shearbox_particle_strain_rate.prm.bak
 delete mode 100644 tests/shell_2d_gmg.prm.bak
 delete mode 100644 tests/shell_3d_gmg.prm.bak
 delete mode 100644 tests/shell_boundary_composition_spherical_constant.prm.bak
 delete mode 100644 tests/shell_quarter_BC.prm.bak
 delete mode 100644 tests/shell_quarter_gmg.prm.bak
 delete mode 100644 tests/shell_surface_base_variables.prm.bak
 delete mode 100644 tests/shell_with_variable_coordinate_systems.prm.bak
 delete mode 100644 tests/signal_fem.cc.bak
 delete mode 100644 tests/signal_fem.prm.bak
 delete mode 100644 tests/signals.cc.bak
 delete mode 100644 tests/signals.prm.bak
 delete mode 100644 tests/signals_connect.cc.bak
 delete mode 100644 tests/signals_connect.prm.bak
 delete mode 100644 tests/signals_post_constraints.cc.bak
 delete mode 100644 tests/signals_post_constraints.prm.bak
 delete mode 100644 tests/simple_composite.prm.bak
 delete mode 100644 tests/simple_compressibility_iterated_stokes.cc.bak
 delete mode 100644 tests/simple_compressibility_iterated_stokes.prm.bak
 delete mode 100644 tests/simple_compressibility_iterated_stokes_gmg.cc.bak
 delete mode 100644 tests/simple_compressibility_iterated_stokes_gmg.prm.bak
 delete mode 100644 tests/simple_compressible.prm.bak
 delete mode 100644 tests/simple_incompressible.prm.bak
 delete mode 100644 tests/simple_nonlinear.cc.bak
 delete mode 100644 tests/simple_nonlinear.prm.bak
 delete mode 100644 tests/simple_shear.cc.bak
 delete mode 100644 tests/simple_shear.prm.bak
 delete mode 100644 tests/simple_shear_output_the_mobility.cc.bak
 delete mode 100644 tests/simple_shear_output_the_mobility.prm.bak
 delete mode 100644 tests/simpler_box.prm.bak
 delete mode 100644 tests/simpler_composition.prm.bak
 delete mode 100644 tests/single_Advection_iterated_defect_correction_Stokes.prm.bak
 delete mode 100644 tests/sinking_block.cc.bak
 delete mode 100644 tests/sinking_block.prm.bak
 delete mode 100644 tests/skip_initial_conditions_setup_on_initial_refinement.prm.bak
 delete mode 100644 tests/skip_refinement.prm.bak
 delete mode 100644 tests/skip_solvers_on_initial_refinement.prm.bak
 delete mode 100644 tests/slab2_initial_composition_3d_shell.prm.bak
 delete mode 100644 tests/slab_tip_depth.prm.bak
 delete mode 100644 tests/slope_refinement.prm.bak
 delete mode 100644 tests/smoothing.prm.bak
 delete mode 100644 tests/smoothing_composition_passive.prm.bak
 delete mode 100644 tests/sol_cx_2.cc.bak
 delete mode 100644 tests/sol_cx_2.prm.bak
 delete mode 100644 tests/sol_cx_2_conservative.cc.bak
 delete mode 100644 tests/sol_cx_2_conservative.prm.bak
 delete mode 100644 tests/sol_cx_2_equal_order.cc.bak
 delete mode 100644 tests/sol_cx_2_equal_order.prm.bak
 delete mode 100644 tests/sol_cx_2_gmg.cc.bak
 delete mode 100644 tests/sol_cx_2_gmg.prm.bak
 delete mode 100644 tests/sol_cx_2_normalized_pressure.cc.bak
 delete mode 100644 tests/sol_cx_2_normalized_pressure.prm.bak
 delete mode 100644 tests/sol_cx_2_q3.cc.bak
 delete mode 100644 tests/sol_cx_2_q3.prm.bak
 delete mode 100644 tests/sol_cx_4.cc.bak
 delete mode 100644 tests/sol_cx_4.prm.bak
 delete mode 100644 tests/sol_cx_4_conservative.cc.bak
 delete mode 100644 tests/sol_cx_4_conservative.prm.bak
 delete mode 100644 tests/sol_cx_4_equal_order.cc.bak
 delete mode 100644 tests/sol_cx_4_equal_order.prm.bak
 delete mode 100644 tests/sol_cx_4_gmg.cc.bak
 delete mode 100644 tests/sol_cx_4_gmg.prm.bak
 delete mode 100644 tests/sol_cx_4_normalized_pressure.cc.bak
 delete mode 100644 tests/sol_cx_4_normalized_pressure.prm.bak
 delete mode 100644 tests/sol_cx_4_normalized_pressure_large_static_pressure.cc.bak
 delete mode 100644 tests/sol_cx_4_normalized_pressure_large_static_pressure.prm.bak
 delete mode 100644 tests/sol_cx_4_normalized_pressure_low_solver_tolerance.cc.bak
 delete mode 100644 tests/sol_cx_4_normalized_pressure_low_solver_tolerance.prm.bak
 delete mode 100644 tests/sol_cx_mpi_2.cc.bak
 delete mode 100644 tests/sol_cx_mpi_2.prm.bak
 delete mode 100644 tests/sol_cx_newton_crash.cc.bak
 delete mode 100644 tests/sol_cx_newton_crash.prm.bak
 delete mode 100644 tests/sol_cx_particles.cc.bak
 delete mode 100644 tests/sol_cx_particles.prm.bak
 delete mode 100644 tests/sol_kz_2.cc.bak
 delete mode 100644 tests/sol_kz_2.prm.bak
 delete mode 100644 tests/sol_kz_2_cheaper_first_phase_solver.cc.bak
 delete mode 100644 tests/sol_kz_2_cheaper_first_phase_solver.prm.bak
 delete mode 100644 tests/sol_kz_2_conservative.cc.bak
 delete mode 100644 tests/sol_kz_2_conservative.prm.bak
 delete mode 100644 tests/sol_kz_2_no_first_phase_solver.cc.bak
 delete mode 100644 tests/sol_kz_2_no_first_phase_solver.prm.bak
 delete mode 100644 tests/sol_kz_2_project_q1_only_visc.cc.bak
 delete mode 100644 tests/sol_kz_2_project_q1_only_visc.prm.bak
 delete mode 100644 tests/sol_kz_2_q3.cc.bak
 delete mode 100644 tests/sol_kz_2_q3.prm.bak
 delete mode 100644 tests/sol_kz_4.cc.bak
 delete mode 100644 tests/sol_kz_4.prm.bak
 delete mode 100644 tests/sol_kz_4_conservative.cc.bak
 delete mode 100644 tests/sol_kz_4_conservative.prm.bak
 delete mode 100644 tests/solidus_initial_conditions.cc.bak
 delete mode 100644 tests/solidus_initial_conditions.prm.bak
 delete mode 100644 tests/solitary_wave.cc.bak
 delete mode 100644 tests/solitary_wave.prm.bak
 delete mode 100644 tests/solubility.cc.bak
 delete mode 100644 tests/solubility.prm.bak
 delete mode 100644 tests/solve_no_advection_no_stokes.prm.bak
 delete mode 100644 tests/solver_history.cc.bak
 delete mode 100644 tests/solver_history.prm.bak
 delete mode 100644 tests/solver_scheme_no_advection_single_stokes.cc.bak
 delete mode 100644 tests/solver_scheme_no_advection_single_stokes.prm.bak
 delete mode 100644 tests/spectral_comparison.prm.bak
 delete mode 100644 tests/spherical_constant_boundary_3d_sphere.prm.bak
 delete mode 100644 tests/spherical_nsinker.cc.bak
 delete mode 100644 tests/spherical_nsinker.prm.bak
 delete mode 100644 tests/spherical_shell_initial_topography_ascii_data_3d.prm.bak
 delete mode 100644 tests/spherical_shell_initial_topography_function_3d.prm.bak
 delete mode 100644 tests/spherical_velocity_statistics.prm.bak
 delete mode 100644 tests/spiegelman_fail_test.cc.bak
 delete mode 100644 tests/spiegelman_fail_test.prm.bak
 delete mode 100644 tests/spiegelman_material.cc.bak
 delete mode 100644 tests/spiegelman_material.prm.bak
 delete mode 100644 tests/splines.cc.bak
 delete mode 100644 tests/splines.prm.bak
 delete mode 100644 tests/static_temperature.prm.bak
 delete mode 100644 tests/statistics_output.prm.bak
 delete mode 100644 tests/steinberger_averaging.prm.bak
 delete mode 100644 tests/steinberger_background.prm.bak
 delete mode 100644 tests/steinberger_compressible.prm.bak
 delete mode 100644 tests/steinberger_compressible_gmg.prm.bak
 delete mode 100644 tests/steinberger_conductivity.prm.bak
 delete mode 100644 tests/steinberger_conductivity_tosi.prm.bak
 delete mode 100644 tests/steinberger_continuous_viscosity.prm.bak
 delete mode 100644 tests/steinberger_cookbook.prm.bak
 delete mode 100644 tests/steinberger_latent_heat.prm.bak
 delete mode 100644 tests/steinberger_latent_heat_2.prm.bak
 delete mode 100644 tests/steinberger_lateral_fail.prm.bak
 delete mode 100644 tests/steinberger_phase_fractions.prm.bak
 delete mode 100644 tests/steinberger_phase_fractions_background.prm.bak
 delete mode 100644 tests/steinberger_phases.prm.bak
 delete mode 100644 tests/steinberger_phases_2_lookups.prm.bak
 delete mode 100644 tests/steinberger_phases_hefesto.prm.bak
 delete mode 100644 tests/steinberger_projected_density.prm.bak
 delete mode 100644 tests/steinberger_projected_density_dcPicard.prm.bak
 delete mode 100644 tests/steinberger_seismic_velocities.prm.bak
 delete mode 100644 tests/steinberger_several_fields.prm.bak
 delete mode 100644 tests/steinberger_single_field.prm.bak
 delete mode 100644 tests/steinberger_viscosity.prm.bak
 delete mode 100644 tests/steinberger_viscosity_adiabatic.prm.bak
 delete mode 100644 tests/stokes.prm.bak
 delete mode 100644 tests/stokes_residual.prm.bak
 delete mode 100644 tests/stokes_residual_cheap.prm.bak
 delete mode 100644 tests/stokes_solver_fail.prm.bak
 delete mode 100644 tests/stokes_solver_fail_A.prm.bak
 delete mode 100644 tests/stokes_solver_fail_S.prm.bak
 delete mode 100644 tests/stokes_solver_fail_cheap.prm.bak
 delete mode 100644 tests/stokes_solver_fail_gmg.prm.bak
 delete mode 100644 tests/stress_vs_surface_stress.cc.bak
 delete mode 100644 tests/stress_vs_surface_stress.prm.bak
 delete mode 100644 tests/stress_vs_surface_stress_point_values.cc.bak
 delete mode 100644 tests/stress_vs_surface_stress_point_values.prm.bak
 delete mode 100644 tests/subduction_initiation_compositional_fields.prm.bak
 delete mode 100644 tests/supg-compositional-passive.prm.bak
 delete mode 100644 tests/supg.prm.bak
 delete mode 100644 tests/surface_elevation_box_ascii_data.prm.bak
 delete mode 100644 tests/surface_elevation_box_ascii_data_moved_origin.prm.bak
 delete mode 100644 tests/surface_elevation_box_function.prm.bak
 delete mode 100644 tests/surface_elevation_box_prm_polygon.prm.bak
 delete mode 100644 tests/surface_elevation_chunk_ascii_data.prm.bak
 delete mode 100644 tests/surface_elevation_chunk_ascii_data_3d.prm.bak
 delete mode 100644 tests/surface_elevation_chunk_ascii_data_3d_colatitude.prm.bak
 delete mode 100644 tests/surface_elevation_chunk_ascii_data_global_3d.prm.bak
 delete mode 100644 tests/surface_elevation_spherical_shell_ascii_data_global_3d.prm.bak
 delete mode 100644 tests/surface_stress_strainrate_3d.cc.bak
 delete mode 100644 tests/surface_stress_strainrate_3d.prm.bak
 delete mode 100644 tests/symbolic_boundary_names_box.prm.bak
 delete mode 100644 tests/symbolic_boundary_names_box_constant_bc.prm.bak
 delete mode 100644 tests/symbolic_boundary_names_spherical_shell_2d_180_degrees.prm.bak
 delete mode 100644 tests/symbolic_boundary_names_spherical_shell_2d_90_degrees.prm.bak
 delete mode 100644 tests/symbolic_boundary_names_spherical_shell_2d_full.prm.bak
 delete mode 100644 tests/symbolic_boundary_names_spherical_shell_3d_90_degrees.prm.bak
 delete mode 100644 tests/symbolic_boundary_names_spherical_shell_3d_full.prm.bak
 delete mode 100644 tests/tangurnis.cc.bak
 delete mode 100644 tests/tangurnis_ba.cc.bak
 delete mode 100644 tests/tangurnis_ba.prm.bak
 delete mode 100644 tests/tangurnis_ba_custom.cc.bak
 delete mode 100644 tests/tangurnis_ba_custom.prm.bak
 delete mode 100644 tests/tangurnis_tala.cc.bak
 delete mode 100644 tests/tangurnis_tala.prm.bak
 delete mode 100644 tests/tangurnis_tala_c.cc.bak
 delete mode 100644 tests/tangurnis_tala_c.prm.bak
 delete mode 100644 tests/tangurnis_tala_gmg.cc.bak
 delete mode 100644 tests/tangurnis_tala_gmg.prm.bak
 delete mode 100644 tests/tangurnis_tala_implicit.cc.bak
 delete mode 100644 tests/tangurnis_tala_implicit.prm.bak
 delete mode 100644 tests/temperature_dependent_stokes_matrix.prm.bak
 delete mode 100644 tests/terminate_user_request.cc.bak
 delete mode 100644 tests/terminate_user_request.prm.bak
 delete mode 100644 tests/thermal_alpha_s40rts.prm.bak
 delete mode 100644 tests/tian_MORB.prm.bak
 delete mode 100644 tests/tian_gabbro.prm.bak
 delete mode 100644 tests/tian_peridotite.prm.bak
 delete mode 100644 tests/tian_sediment.prm.bak
 delete mode 100644 tests/time_dependent_annulus.cc.bak
 delete mode 100644 tests/time_dependent_annulus.prm.bak
 delete mode 100644 tests/time_dependent_temperature_bc.cc.bak
 delete mode 100644 tests/time_dependent_temperature_bc.prm.bak
 delete mode 100644 tests/time_dependent_temperature_bc_2.cc.bak
 delete mode 100644 tests/time_dependent_temperature_bc_2.prm.bak
 delete mode 100644 tests/time_stepping_fail.prm.bak
 delete mode 100644 tests/time_stepping_function.prm.bak
 delete mode 100644 tests/time_stepping_min.prm.bak
 delete mode 100644 tests/time_stepping_repeat.prm.bak
 delete mode 100644 tests/time_stepping_repeat_particles.prm.bak
 delete mode 100644 tests/time_stepping_repeat_particles_iterated_advection.prm.bak
 delete mode 100644 tests/tomography_based_plate_motions_cookbook.cc.bak
 delete mode 100644 tests/tomography_based_plate_motions_cookbook.prm.bak
 delete mode 100644 tests/topo_box.prm.bak
 delete mode 100644 tests/topo_chunk.prm.bak
 delete mode 100644 tests/topo_shell.prm.bak
 delete mode 100644 tests/tosi_benchmark.cc.bak
 delete mode 100644 tests/tosi_benchmark.prm.bak
 delete mode 100644 tests/tosi_benchmark_gmg_dc_picard_solver.cc.bak
 delete mode 100644 tests/tosi_benchmark_gmg_dc_picard_solver.prm.bak
 delete mode 100644 tests/tosi_benchmark_gmg_newton_solver.cc.bak
 delete mode 100644 tests/tosi_benchmark_gmg_newton_solver.prm.bak
 delete mode 100644 tests/tosi_benchmark_newton_solver.cc.bak
 delete mode 100644 tests/tosi_benchmark_newton_solver.prm.bak
 delete mode 100644 tests/tosi_benchmark_newton_solver_full_A.cc.bak
 delete mode 100644 tests/tosi_benchmark_newton_solver_full_A.prm.bak
 delete mode 100644 tests/traction_ascii_data.prm.bak
 delete mode 100644 tests/traction_multiple_model.prm.bak
 delete mode 100644 tests/transform_fault_behn_2007.prm.bak
 delete mode 100644 tests/two_merged_boxes_free_surface.prm.bak
 delete mode 100644 tests/uncoupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
 delete mode 100644 tests/update_script.cc.bak
 delete mode 100644 tests/update_script_2.cc.bak
 delete mode 100644 tests/update_script_2/updated2.prm.bak
 delete mode 100644 tests/upwelling_melting_peridotite.prm.bak
 delete mode 100644 tests/upwelling_melting_peridotite_compressible.prm.bak
 delete mode 100644 tests/upwelling_melting_pyroxenite.prm.bak
 delete mode 100644 tests/use_full_A_block_preconditioner.prm.bak
 delete mode 100644 tests/van_keken_smooth_particle.prm.bak
 delete mode 100644 tests/vankeken_subduction.cc.bak
 delete mode 100644 tests/vankeken_subduction.prm.bak
 delete mode 100644 tests/var_declaration_expansion.cc.bak
 delete mode 100644 tests/var_declaration_expansion.prm.bak
 delete mode 100644 tests/velocity_boundary_statistics.prm.bak
 delete mode 100644 tests/velocity_divergence.cc.bak
 delete mode 100644 tests/velocity_divergence.prm.bak
 delete mode 100644 tests/velocity_in_years.prm.bak
 delete mode 100644 tests/vep_chemical_compositions.prm.bak
 delete mode 100644 tests/vis_velocity_in_years.prm.bak
 delete mode 100644 tests/visco_elastic_top_beam.prm.bak
 delete mode 100644 tests/visco_plastic.prm.bak
 delete mode 100644 tests/visco_plastic_additional_plastic_outputs.prm.bak
 delete mode 100644 tests/visco_plastic_adiabat_temperature.prm.bak
 delete mode 100644 tests/visco_plastic_adiabatic_heating_density.prm.bak
 delete mode 100644 tests/visco_plastic_adiabatic_pressure_in_viscous_creep.prm.bak
 delete mode 100644 tests/visco_plastic_complex.prm.bak
 delete mode 100644 tests/visco_plastic_composite.prm.bak
 delete mode 100644 tests/visco_plastic_constant_viscosity_prefactor.prm.bak
 delete mode 100644 tests/visco_plastic_derivatives_2d.cc.bak
 delete mode 100644 tests/visco_plastic_derivatives_2d.prm.bak
 delete mode 100644 tests/visco_plastic_derivatives_3d.cc.bak
 delete mode 100644 tests/visco_plastic_derivatives_3d.prm.bak
 delete mode 100644 tests/visco_plastic_diffusion.prm.bak
 delete mode 100644 tests/visco_plastic_diffusion_dislocation_composite.prm.bak
 delete mode 100644 tests/visco_plastic_dislocation.prm.bak
 delete mode 100644 tests/visco_plastic_frank_kamenetskii.prm.bak
 delete mode 100644 tests/visco_plastic_frank_kamenetskii_pressure.prm.bak
 delete mode 100644 tests/visco_plastic_friction_function.prm.bak
 delete mode 100644 tests/visco_plastic_gerya_2019_vp.prm.bak
 delete mode 100644 tests/visco_plastic_newton_nonlinear_channelflow.prm.bak
 delete mode 100644 tests/visco_plastic_peierls_cutoff_test.prm.bak
 delete mode 100644 tests/visco_plastic_peierls_idrissi_exact.prm.bak
 delete mode 100644 tests/visco_plastic_peierls_mei_exact.prm.bak
 delete mode 100644 tests/visco_plastic_peierls_mei_viscosity_approx.prm.bak
 delete mode 100644 tests/visco_plastic_peierls_strict_cutoff_test.prm.bak
 delete mode 100644 tests/visco_plastic_phases.prm.bak
 delete mode 100644 tests/visco_plastic_phases_compositions.prm.bak
 delete mode 100644 tests/visco_plastic_phases_peierls_mei_exact.prm.bak
 delete mode 100644 tests/visco_plastic_phases_plasticity.prm.bak
 delete mode 100644 tests/visco_plastic_phases_temperature_limit_basalt.prm.bak
 delete mode 100644 tests/visco_plastic_phases_temperature_limit_harzburgite.prm.bak
 delete mode 100644 tests/visco_plastic_phases_temperature_limit_pyrolite.prm.bak
 delete mode 100644 tests/visco_plastic_phases_temperature_limit_pyrolite_complicated.prm.bak
 delete mode 100644 tests/visco_plastic_phases_viscosity.prm.bak
 delete mode 100644 tests/visco_plastic_phases_viscosity_max_min.prm.bak
 delete mode 100644 tests/visco_plastic_reference_density_profile.prm.bak
 delete mode 100644 tests/visco_plastic_thermal_conductivity.prm.bak
 delete mode 100644 tests/visco_plastic_total_strain_healing_temperature_dependent.prm.bak
 delete mode 100644 tests/visco_plastic_track_noninitial_plastic_strain.prm.bak
 delete mode 100644 tests/visco_plastic_vep_bending_beam.prm.bak
 delete mode 100644 tests/visco_plastic_vep_brick_extension.prm.bak
 delete mode 100644 tests/visco_plastic_vep_plate_flexure.prm.bak
 delete mode 100644 tests/visco_plastic_vep_simple_shear.prm.bak
 delete mode 100644 tests/visco_plastic_vep_stress_build-up.prm.bak
 delete mode 100644 tests/visco_plastic_vep_stress_build-up_fixed_elastic_time_step.prm.bak
 delete mode 100644 tests/visco_plastic_vep_stress_build-up_stress_averaging.prm.bak
 delete mode 100644 tests/visco_plastic_vep_stress_build-up_yield.prm.bak
 delete mode 100644 tests/visco_plastic_vep_stress_build-up_yield_particles.prm.bak
 delete mode 100644 tests/visco_plastic_viscous_strain_weakening.prm.bak
 delete mode 100644 tests/visco_plastic_yield.prm.bak
 delete mode 100644 tests/visco_plastic_yield_max.prm.bak
 delete mode 100644 tests/visco_plastic_yield_noninitial-plastic-strain_particles.prm.bak
 delete mode 100644 tests/visco_plastic_yield_plastic_damper.prm.bak
 delete mode 100644 tests/visco_plastic_yield_plastic_strain_weakening.prm.bak
 delete mode 100644 tests/visco_plastic_yield_plastic_strain_weakening_particles.prm.bak
 delete mode 100644 tests/visco_plastic_yield_plastic_viscous_strain_healing.prm.bak
 delete mode 100644 tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm.bak
 delete mode 100644 tests/visco_plastic_yield_plastic_viscous_strain_weakening_particles.prm.bak
 delete mode 100644 tests/visco_plastic_yield_strain_weakening.prm.bak
 delete mode 100644 tests/visco_plastic_yield_strain_weakening_compositions.prm.bak
 delete mode 100644 tests/visco_plastic_yield_strain_weakening_defect_corr_stokes.prm.bak
 delete mode 100644 tests/visco_plastic_yield_strain_weakening_full_strain_tensor.prm.bak
 delete mode 100644 tests/visco_plastic_yield_strain_weakening_full_strain_tensor_3d.prm.bak
 delete mode 100644 tests/visco_plastic_yield_strain_weakening_iterated_advection.prm.bak
 delete mode 100644 tests/visco_plastic_yield_strain_weakening_no-advect_no_stokes.prm.bak
 delete mode 100644 tests/visco_plastic_yield_strain_weakening_particles.prm.bak
 delete mode 100644 tests/visco_plastic_yield_temperature_activated_viscous_strain_weakening.prm.bak
 delete mode 100644 tests/visco_plastic_yield_total_strain_healing.prm.bak
 delete mode 100644 tests/visco_plastic_yield_viscous_strain_weakening.prm.bak
 delete mode 100644 tests/visco_plastic_yield_viscous_strain_weakening_particles.prm.bak
 delete mode 100644 tests/viscoelastic_bending_beam.prm.bak
 delete mode 100644 tests/viscoelastic_bending_beam_averaging.prm.bak
 delete mode 100644 tests/viscoelastic_bending_beam_gmg.prm.bak
 delete mode 100644 tests/viscoelastic_bending_beam_particles.prm.bak
 delete mode 100644 tests/viscoelastic_bending_beam_principal_stress.prm.bak
 delete mode 100644 tests/viscoelastic_fixed_elastic_time_step.prm.bak
 delete mode 100644 tests/viscoelastic_numerical_elastic_time_step.prm.bak
 delete mode 100644 tests/viscoelastic_numerical_elastic_time_step_particles.prm.bak
 delete mode 100644 tests/viscoelastic_plate_flexure.prm.bak
 delete mode 100644 tests/viscoelastic_sheared_torsion.prm.bak
 delete mode 100644 tests/viscoelastic_stress_averaging.prm.bak
 delete mode 100644 tests/viscoelastic_stress_build-up.prm.bak
 delete mode 100644 tests/viscoelastic_stress_build-up_gmg.prm.bak
 delete mode 100644 tests/viscoelastoplastic_yield_plastic_viscous_strain_weakening.prm.bak
 delete mode 100644 tests/viscoplastic_melt_blob_freezing.prm.bak
 delete mode 100644 tests/viscoplastic_melt_fraction.prm.bak
 delete mode 100644 tests/viscosity_refinement.prm.bak
 delete mode 100644 tests/viscous_dissipation_statistics.prm.bak
 delete mode 100644 tests/viscous_top_beam.prm.bak
 delete mode 100644 tests/visualization_averaged_strain_rate.prm.bak
 delete mode 100644 tests/visualization_averaged_strain_rate2.prm.bak
 delete mode 100644 tests/visualization_conductivity_diffusivity.prm.bak
 delete mode 100644 tests/visualization_higher_order_output.prm.bak
 delete mode 100644 tests/visualization_shear_stress.prm.bak
 delete mode 100644 tests/visualization_shear_stress_pointwise.prm.bak
 delete mode 100644 tests/visualization_shear_stress_viscoelastic.prm.bak
 delete mode 100644 tests/visualization_strain_rate.prm.bak
 delete mode 100644 tests/visualization_strain_rate_pointwise.prm.bak
 delete mode 100644 tests/visualization_strain_rate_tensor.prm.bak
 delete mode 100644 tests/visualization_strain_rate_tensor_pointwise.prm.bak
 delete mode 100644 tests/visualization_stress.prm.bak
 delete mode 100644 tests/visualization_stress_pointwise.prm.bak
 delete mode 100644 tests/visualization_stress_viscoelastic.prm.bak
 delete mode 100644 tests/visualization_temperature_anomaly.prm.bak
 delete mode 100644 tests/visualization_unique_list.prm.bak
 delete mode 100644 tests/visualization_vertical_heat_flux.prm.bak
 delete mode 100644 tests/viz_mesh_deform_vector.prm.bak
 delete mode 100644 tests/viz_plugin_dependency.cc.bak
 delete mode 100644 tests/viz_plugin_dependency.prm.bak
 delete mode 100644 tests/viz_spherical_velocity_components.prm.bak
 delete mode 100644 tests/vof_circle_1.cc.bak
 delete mode 100644 tests/vof_circle_1.prm.bak
 delete mode 100644 tests/vof_circle_amr.cc.bak
 delete mode 100644 tests/vof_circle_amr.prm.bak
 delete mode 100644 tests/vof_circle_mpi.cc.bak
 delete mode 100644 tests/vof_circle_mpi.prm.bak
 delete mode 100644 tests/vof_circle_mpi_amr.cc.bak
 delete mode 100644 tests/vof_circle_mpi_amr.prm.bak
 delete mode 100644 tests/vof_composition_init.prm.bak
 delete mode 100644 tests/vof_err_calc.h.bak
 delete mode 100644 tests/vof_linear.cc.bak
 delete mode 100644 tests/vof_linear.prm.bak
 delete mode 100644 tests/vof_linear_2f.cc.bak
 delete mode 100644 tests/vof_linear_2f.prm.bak
 delete mode 100644 tests/vof_linear_amr.cc.bak
 delete mode 100644 tests/vof_linear_amr.prm.bak
 delete mode 100644 tests/vof_linear_amr_mpi.cc.bak
 delete mode 100644 tests/vof_linear_amr_mpi.prm.bak
 delete mode 100644 tests/vof_linear_inflow.prm.bak
 delete mode 100644 tests/vof_linear_periodic.cc.bak
 delete mode 100644 tests/vof_linear_periodic.prm.bak
 delete mode 100644 tests/vof_linear_periodic_amr.cc.bak
 delete mode 100644 tests/vof_linear_periodic_amr.prm.bak
 delete mode 100644 tests/vof_mpi_amr_no_dof.prm.bak
 delete mode 100644 tests/walltime.prm.bak
 delete mode 100644 tests/weighted_p_norm_average.cc.bak
 delete mode 100644 tests/world_builder_select_composition.prm.bak
 delete mode 100644 tests/world_builder_select_grains.prm.bak
 delete mode 100644 tests/world_builder_simple.prm.bak
 delete mode 100644 tests/world_builder_simple_2d_cartesian_sticky_air.prm.bak
 delete mode 100644 tests/write_plugin_graph.cc.bak
 delete mode 100644 tests/write_plugin_graph.prm.bak
 delete mode 100644 tests/zero_RHS.prm.bak
 delete mode 100644 tests/zero_matrix.prm.bak
 delete mode 100644 tests/zero_temperature.prm.bak
 delete mode 100644 unit_tests/additional_outputs.cc.bak
 delete mode 100644 unit_tests/common.h.bak
 delete mode 100644 unit_tests/crystal_preferred_orientation.cc.bak
 delete mode 100644 unit_tests/first.cc.bak
 delete mode 100644 unit_tests/introspection.cc.bak
 delete mode 100644 unit_tests/mesh_refinement.cc.bak
 delete mode 100644 unit_tests/netcdf.cc.bak
 delete mode 100644 unit_tests/parse_map_to_double_array.cc.bak
 delete mode 100644 unit_tests/particles.cc.bak
 delete mode 100644 unit_tests/termination_criteria.cc.bak
 delete mode 100644 unit_tests/utilities.cc.bak

diff --git a/benchmarks/advection/drop_ev.prm.bak b/benchmarks/advection/drop_ev.prm.bak
deleted file mode 100644
index d0f3400f9d1..00000000000
--- a/benchmarks/advection/drop_ev.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# like drop_supg.prm but with entropy viscosity
-
-set Dimension                              = 2
-
-include drop_supg.prm
-
-set Output directory                       = output-drop-ev
-
-subsection Discretization
-  subsection Stabilization parameters
-    set Stabilization method = entropy viscosity
-  end
-end
diff --git a/benchmarks/advection/drop_supg.prm.bak b/benchmarks/advection/drop_supg.prm.bak
deleted file mode 100644
index 73c1421d522..00000000000
--- a/benchmarks/advection/drop_supg.prm.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-# Dropping box benchmark on the right half of the domain
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 5.0
-set Output directory                       = output-drop-supg
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Function expression = 0; if (x>0,-0.2,0)
-  end
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 2
-
-  subsection Stabilization parameters
-    set Stabilization method = SUPG
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-    set Box origin X coordinate = -1
-    set Box origin Y coordinate = -1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = if ((abs(x)<0.2)&(abs(y-0.5)<0.2),1,0)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = if ((abs(x)<0.2)&(abs(y-0.5)<0.2),1,0)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top, bottom, left, right
-
-  subsection Box
-    set Bottom temperature = 0
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = box
-  set Fixed composition boundary indicators   = top, bottom, left, right
-
-  subsection Box
-    set Bottom composition = 0
-    set Left composition   = 0
-    set Right composition  = 0
-    set Top composition    = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-5
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Compositional field methods = field
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = .1
-    set List of output variables = artificial viscosity
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/benchmarks/advection/rotate_shape_dg_bp.prm.bak b/benchmarks/advection/rotate_shape_dg_bp.prm.bak
deleted file mode 100644
index bf877a98975..00000000000
--- a/benchmarks/advection/rotate_shape_dg_bp.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# Like rotate_shape_supg but with discontinuous Galerkin method
-# and bound-preserving limiter
-
-set Dimension                              = 2
-
-include rotate_shape_supg.prm
-
-set Output directory                       = output-rotate-shape-dg-bp
-
-subsection Discretization
-  set Use discontinuous temperature discretization = true
-  set Use discontinuous composition discretization = true
-  subsection Stabilization parameters
-    set Limiter for discontinuous temperature solution = bound preserving
-    set Limiter for discontinuous composition solution = bound preserving
-    set Global temperature maximum = 1
-    set Global temperature minimum = 0
-    set Global composition maximum = 1
-    set Global composition minimum = 0
-  end
-end
diff --git a/benchmarks/advection/rotate_shape_dg_weno.prm.bak b/benchmarks/advection/rotate_shape_dg_weno.prm.bak
deleted file mode 100644
index 895cf0ccdb3..00000000000
--- a/benchmarks/advection/rotate_shape_dg_weno.prm.bak
+++ /dev/null
@@ -1,26 +0,0 @@
-# Like rotate_shape_supg but with discontinuous Galerkin method
-# and WENO limiter
-
-set Dimension                              = 2
-
-include rotate_shape_supg.prm
-
-set Output directory                       = output-rotate-shape-dg-weno
-
-subsection Discretization
-  set Use discontinuous temperature discretization = true
-  set Use discontinuous composition discretization = true
-  subsection Stabilization parameters
-    set Limiter for discontinuous temperature solution = WENO
-    set Limiter for discontinuous composition solution = WENO
-  end
-end
-
-subsection Postprocess
-  subsection Visualization
-    set List of output variables = kxrcf indicator
-    subsection KXRCF indicator
-      set Name of advection field = C_1
-    end
-  end
-end
diff --git a/benchmarks/advection/rotate_shape_ev.prm.bak b/benchmarks/advection/rotate_shape_ev.prm.bak
deleted file mode 100644
index 72d335d9bb4..00000000000
--- a/benchmarks/advection/rotate_shape_ev.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# Like rotate_shape_supg but with entropy viscosity
-
-set Dimension                              = 2
-
-include rotate_shape_supg.prm
-
-set Output directory                       = output-rotate-shape-ev
-
-subsection Discretization
-  subsection Stabilization parameters
-    set Stabilization method = entropy viscosity
-  end
-end
diff --git a/benchmarks/advection/rotate_shape_supg.prm.bak b/benchmarks/advection/rotate_shape_supg.prm.bak
deleted file mode 100644
index 2ec59286181..00000000000
--- a/benchmarks/advection/rotate_shape_supg.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-# Rotating shapes
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 6.2831
-set Output directory                       = output-rotate-shape-supg
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 2
-
-  subsection Stabilization parameters
-    set Stabilization method = SUPG
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-    set Box origin X coordinate = -1
-    set Box origin Y coordinate = -1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression =  if((sqrt((x-0)^2+(y-0.5)^2)<0.3)&(abs(x)>=0.05|y>=0.7),1,if(sqrt((x-0)^2+(y+0.5)^2)<0.3,1-sqrt((x-0)^2+(y+0.5)^2)/0.3,if(sqrt((x+0.5)^2+(y+0)^2)<0.3,1.0/4.0*(1+cos(pi*min(sqrt((x+0.5)^2+(y+0)^2)/0.3,1))),0)))
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression =  if((sqrt((x-0)^2+(y-0.5)^2)<0.3)&(abs(x)>=0.05|y>=0.7),1,if(sqrt((x-0)^2+(y+0.5)^2)<0.3,1-sqrt((x-0)^2+(y+0.5)^2)/0.3,if(sqrt((x+0.5)^2+(y+0)^2)<0.3,1.0/4.0*(1+cos(pi*min(sqrt((x+0.5)^2+(y+0)^2)/0.3,1))),0)))
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top, bottom, left, right
-
-  subsection Box
-    set Bottom temperature = 0
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = box
-  set Fixed composition boundary indicators   = top, bottom, left, right
-
-  subsection Box
-    set Bottom composition = 0
-    set Left composition   = 0
-    set Right composition  = 0
-    set Top composition    = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0  # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-5
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Compositional field methods = field
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = .12566 # = 2pi/50
-    set List of output variables = artificial viscosity
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/benchmarks/advection_in_annulus/advection_in_annulus.cc.bak b/benchmarks/advection_in_annulus/advection_in_annulus.cc.bak
deleted file mode 100644
index b0eeeb741e5..00000000000
--- a/benchmarks/advection_in_annulus/advection_in_annulus.cc.bak
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/postprocess/dynamic_topography.h>
-
-#include <aspect/prescribed_stokes_solution/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  /**
-   * This is a variation of the "annulus" benchmark in benchmark/annulus
-   * that tests the influence of the stabilization method on the temperature
-   * equation.
-   *
-   */
-  namespace AdvectionInAnnulus
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-      const double A=2.0, B=-3.0/std::log(2.0), C=-1;
-      const double outer_radius = 2.;
-      const double rho_0 = 1000.;
-      const double gravity = 1.;
-
-      Tensor<1,2>
-      Annulus_velocity (const Point<2> &pos,
-                        const double k)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const double r = std::sqrt(x*x+y*y);
-        const double theta = std::atan2(y,x);
-        const double f_r = A*r + B/r;
-        const double g_r = A*r/2 + B*std::log(r)/r + C/r;
-        const double v_r = g_r*k*sin(k*theta);
-        const double v_theta = f_r*cos(k*theta);
-        const double v_x = cos(theta)*v_r - sin(theta)*v_theta;
-        const double v_y = sin(theta)*v_r + cos(theta)*v_theta;
-        return Point<2> (v_x,v_y);
-      }
-
-      double
-      Annulus_pressure (const Point<2> &pos,
-                        const double k)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const double r=std::sqrt(x*x+y*y);
-        const double theta = std::atan2(y,x);
-        const double f_r = 2*r + B/r;
-        const double g_r = A*r/2 + B*std::log(r)/r + C/r;
-        const double h_r=(2*g_r-f_r)/r;
-        return k*h_r*sin(k*theta)+rho_0*gravity*(outer_radius-r);
-      }
-
-      template <int dim>
-      double
-      Annulus_normal_traction (const Point<dim> &pos,
-                               const double k)
-      {
-        Assert (dim == 2, ExcNotImplemented());
-        const double x = pos[0];
-        const double y = pos[1];
-        const double r=std::sqrt(x*x+y*y);
-        const double theta = std::atan2(y,x);
-        const double f_r = 2*r + B/r;
-        const double g_r = A*r/2 + B*std::log(r)/r + C/r;
-        return k * 3.*f_r/r * std::sin(k*theta) - rho_0 * g_r * (outer_radius - r);
-      }
-
-    }
-  }
-}
-
-
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements the flow field of the annulus benchmark.
-     *
-     * @ingroup PrescribedStokesSolution
-     */
-    template <int dim>
-    class AdvectionInAnnulus : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        void stokes_solution (const Point<dim> &p, Vector<double> &value) const override;
-    };
-  }
-}
-
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    template <int dim>
-    void AdvectionInAnnulus<dim>::stokes_solution (const Point<dim> &, Vector<double> &) const
-    {
-      return;
-    }
-
-
-    template <>
-    void AdvectionInAnnulus<2>::stokes_solution (const Point<2> &p, Vector<double> &value) const
-    {
-      Tensor<1,2> velocity = aspect::AdvectionInAnnulus::AnalyticSolutions::Annulus_velocity (p, 4);
-      value(0) = velocity[0];
-      value(1) = velocity[1];
-
-      double pressure = aspect::AdvectionInAnnulus::AnalyticSolutions::Annulus_pressure (p, 4);
-      value(2) = pressure;       // pressure
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(AdvectionInAnnulus,
-                                               "advection in annulus",
-                                               "This plugin prescribes the Stokes solution of "
-                                               "the annulus benchmark.")
-  }
-}
diff --git a/benchmarks/advection_in_annulus/advection_in_annulus.prm.bak b/benchmarks/advection_in_annulus/advection_in_annulus.prm.bak
deleted file mode 100644
index ba93d9017d5..00000000000
--- a/benchmarks/advection_in_annulus/advection_in_annulus.prm.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-# The advection benchmark creates a simple, 2d annulus
-# with prescribed Stokes flow creating 4 convection cells.
-# Various parameters can be changed to test their effect
-# on the overall cooling of the model.
-#
-# See run_all_models.sh for running multiple iterations
-# of various parameters in a row.
-#
-# Also see creates_formatted_tables for grabbing specific
-# data points from the log file.
-
-############### Global parameters
-# We use a 2d setup. We are only interested in
-# advection, so we prescribe a Stokes flow and
-# solve only for advection.
-
-set Additional shared libraries            = ./libadvection_in_annulus.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, no Stokes
-set Output directory                       = output_advection_in_annulus
-set Pressure normalization                 = surface
-set Timing output frequency                = 100
-
-subsection Prescribed Stokes solution
-  set Model name = advection in annulus
-end
-
-############### Parameters describing the model
-# We are interested in the flow of heat out of the top
-# boundary and how the advection is stabilized. Interesting
-# values to look at are in subsection Discretization, which
-# control the stabilization directly, as well as thermal
-# conductivity which effectively controls the Rayleigh number.
-# The thermal conductivity and Rayleigh number are inversely
-# proportional.
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  # NOTE: the analytical solutions are hard-coded
-  # to these geometry values: do not change them.
-  subsection Spherical shell
-    set Inner radius = 1
-    set Outer radius = 2
-    set Opening angle = 360
-  end
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 2
-
-  subsection Stabilization parameters
-    set beta = 0.052
-    set cR = 0.11
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density = 1.0
-    set Reference temperature = 1.0
-    set Viscosity = 1.0
-    set Thermal conductivity = 1e-3
-    set Reference specific heat = 1.0
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude =  1
-  end
-end
-
-############### Parameters describing the temperature field
-# Since we are interested in the flow of heat through
-# the top of the model, we set the temperature to 1
-# everywhere within the model except for the top
-# boundary, which is set to 0.
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators = top
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, entropy viscosity statistics, depth average
-
-  subsection Visualization
-    set List of output variables = heat flux map, artificial viscosity
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/benchmarks/annulus/instantaneous/annulus.prm.bak b/benchmarks/annulus/instantaneous/annulus.prm.bak
deleted file mode 100644
index 1417770fa71..00000000000
--- a/benchmarks/annulus/instantaneous/annulus.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# The 2D Stokes in an annulus benchmark, for which an
-# analytical solution is available.
-#
-# See the manual for more information.
-
-# We use a 2d setup. Since we are only interested
-# in an instantaneous solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Additional shared libraries            = ../plugin/libannulus.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, single Stokes
-set Output directory                       = output
-set Pressure normalization                 = surface
-
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  # NOTE: the analytical solutions are hard-coded
-  # to these geometry values: do not change them.
-  subsection Spherical shell
-    set Inner radius = 1
-    set Outer radius = 2
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom : AnnulusBoundary, \
-                                                top : AnnulusBoundary
-end
-
-subsection Material model
-  set Model name = AnnulusMaterial
-end
-
-subsection Gravity model
-  set Model name = annulus gravity
-end
-
-# k controls the number of convection cells.
-subsection Annulus benchmark
-  set k = 4
-end
-
-# Temperature does not influence this benchmark
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-# Disable adaptive mesh refinement
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, AnnulusPostprocessor
-
-  subsection Dynamic topography
-    set Density above = 0
-    set Density below = 0
-  end
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, dynamic topography, AnnulusVisualizationPostprocessor
-    set Time between graphical output = 0
-  end
-end
-
-# Increase Stokes solver accuracy to ensure convergence to
-# very low error values
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
diff --git a/benchmarks/annulus/plugin/annulus.cc.bak b/benchmarks/annulus/plugin/annulus.cc.bak
deleted file mode 100644
index 72f77ca337f..00000000000
--- a/benchmarks/annulus/plugin/annulus.cc.bak
+++ /dev/null
@@ -1,837 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-
-#include <aspect/gravity_model/interface.h>
-#include <aspect/postprocess/dynamic_topography.h>
-#include <aspect/postprocess/visualization.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  /**
-   * This is the "annulus" benchmark defined in the following paper:
-   * @code
-   *  @Article{thph17,
-   *    author =       {Rene Gassm\"{o}ller, Juliane Dannberg, Wolfgang Bangerth, Elbridge Gerry Puckett, Cedric Thieulot},
-   *    title =        {Benchmarking the accuracy of higher order particle methods in geodynamic models of transient flow},
-   *    journal =      {xxx},
-   *    year =         2023,
-   *    volume =       xxx,
-   *    number =       {x},
-   *    publisher =    {xxx},
-   *    pages =        {xxx--xxx}}
-   * @endcode
-   *
-   */
-  namespace AnnulusBenchmark
-  {
-    using namespace dealii;
-    using namespace aspect::Utilities::Coordinates;
-
-    /**
-     * The exact solution for the Annulus benchmark.
-     */
-    namespace AnalyticSolutions
-    {
-      // Inner and outer radius are hard-coded to guarantee
-      // tangential flow at the boundaries
-      const double R1 = 1.0;
-      const double R2 = 2.0;
-      const double A = 2.0;
-      const double B = -3.0/std::log(2.0);
-      const double C=-1;
-      const double rho_0 = 1000.;
-      const double gravity = 1.;
-
-      double
-      phase(const double t)
-      {
-        return std::exp(t)-1;
-      }
-
-
-
-      double
-      f(const double r)
-      {
-        return A*r + B/r;
-      }
-
-
-
-      double
-      g(const double r)
-      {
-        return A*r/2 + B*std::log(r)/r + C/r;
-      }
-
-
-
-      double
-      h(const double r)
-      {
-        return (2*g(r)-f(r))/r;
-      }
-
-
-
-      double
-      m(const double r, const double k)
-      {
-        const double f_prime = A - B/(r*r);
-        const double g_prime = A/2 - B*std::log(r)/(r*r) + B/(r*r) - C/(r*r);
-        const double g_prime_prime = -B/(r*r*r)*(3-2*std::log(r)) - 2./(r*r*r);
-        return g_prime_prime - g_prime/r - (g(r)*(k*k - 1))/(r*r) + f(r)/(r*r) + f_prime/r;
-      }
-
-
-
-      template <int dim>
-      Tensor<1,dim>
-      Annulus_velocity (const Point<dim> &pos,
-                        const double k,
-                        const double t,
-                        const bool transient)
-      {
-        Assert (dim == 2, ExcNotImplemented());
-
-        const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
-        const double r = spherical_position[0];
-        const double theta = spherical_position[1];
-
-        Tensor<1,dim> spherical_velocity;
-        spherical_velocity[0] = g(r) * k * std::sin(k*(theta-phase(t)));
-        spherical_velocity[1] = f(r) * std::cos(k*(theta-phase(t)));
-
-        if (transient == true)
-          spherical_velocity[1] += r * std::exp(t);
-
-        return spherical_to_cartesian_vector(spherical_velocity, pos);
-      }
-
-
-
-      template <int dim>
-      double
-      Annulus_pressure (const Point<dim> &pos,
-                        const double k,
-                        const double t)
-      {
-        Assert (dim == 2, ExcNotImplemented());
-        const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
-        const double r = spherical_position[0];
-        const double theta = spherical_position[1];
-
-        return k * h(r) * std::sin(k*(theta-phase(t)))
-               + rho_0 * gravity * (R2-r);
-      }
-
-
-
-      template <int dim>
-      double
-      Annulus_normal_traction (const Point<dim> &pos,
-                               const double k,
-                               const double t)
-      {
-        Assert (dim == 2, ExcNotImplemented());
-        const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
-        const double r = spherical_position[0];
-        const double theta = spherical_position[1];
-
-        return k * 3.*f(r)/r * std::sin(k*(theta-phase(t))) - rho_0 * g(r) * (R2 - r);
-      }
-
-
-
-      template <int dim>
-      double
-      Annulus_density (const Point<dim> &pos,
-                       const double k,
-                       const double t,
-                       const bool transient)
-      {
-        Assert (dim == 2, ExcNotImplemented());
-        const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
-        const double r = spherical_position[0];
-        const double theta = spherical_position[1];
-
-        double density = 0.0;
-        if (transient == true)
-          {
-            const double stream_function = -((A/2)*r*r + B * std::log(r) + C) * std::cos(k*(theta-phase(t)));
-            density = stream_function + rho_0;
-          }
-        else
-          {
-            density = m(r,k) * k * std::sin(k*theta) + rho_0;
-          }
-
-        return density;
-      }
-
-
-
-      template <int dim>
-      Tensor<1,dim>
-      Annulus_gravity (const Point<dim> &pos,
-                       const double k,
-                       const double t,
-                       const bool transient)
-      {
-        Assert (dim == 2, ExcNotImplemented());
-
-        double gravity_magnitude = 1.0;
-
-        // see benchmark description for a justification. we want to change
-        // the density, but keep the forcing term of the Stokes equation constant
-        if (transient == true)
-          {
-            const std::array<double,dim> spherical_position = cartesian_to_spherical_coordinates(pos);
-            const double r = spherical_position[0];
-            const double theta = spherical_position[1];
-
-            const double forcing_term = m(r,k)*k*sin(k*(theta-phase(t))) + rho_0;
-            gravity_magnitude = forcing_term / Annulus_density(pos,k,t, transient);
-          }
-
-        const Tensor<1,dim> gravity_direction = -pos / pos.norm();
-        return gravity_magnitude * gravity_direction;
-      }
-
-
-
-      template <int dim>
-      class FunctionAnnulus : public Function<dim>
-      {
-        public:
-          FunctionAnnulus (const double k,
-                           const unsigned int n_comp,
-                           const bool transient)
-            :
-            Function<dim>(n_comp),
-            k_(k),
-            n_components(n_comp),
-            transient_(transient)
-          {
-            Assert(n_components >= 4, ExcInternalError());
-          }
-
-          void
-          vector_value (const Point<dim>   &pos,
-                        Vector<double>   &values) const override
-          {
-            Assert (dim == 2, ExcNotImplemented());
-            Assert (values.size() >= n_components, ExcInternalError());
-
-            const double t = this->get_time();
-
-            const Tensor<1,dim> v = AnalyticSolutions::Annulus_velocity (pos, k_, t, transient_);
-            values[0] = v[0];
-            values[1] = v[1];
-            values[2] = AnalyticSolutions::Annulus_pressure (pos, k_, t);
-            values[3] = 0.0;
-
-            if (n_components >= 5)
-              values[4] = AnalyticSolutions::Annulus_density (pos, k_, t, transient_);
-          }
-
-        private:
-          const double k_;
-          const unsigned int n_components;
-          const bool transient_;
-      };
-    }
-
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class AnnulusMaterial : public MaterialModel::Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        void
-        evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                 MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          double t = 0.0;
-          if (this->simulator_is_past_initialization() == true)
-            t = this->get_time();
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              out.viscosities[i] = 1;
-              if (use_analytical_density == true)
-                {
-                  out.densities[i] = AnalyticSolutions::Annulus_density(in.position[i], k, t, use_transient_flow_solution);
-                }
-              else
-                {
-                  out.densities[i] = in.composition[i][density_index];
-                }
-
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                out.reaction_terms[i][c] = 0.0;
-            }
-        }
-
-
-
-        bool is_compressible () const override
-        {
-          return false;
-        }
-
-
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm)
-        {
-          // create a global section in the parameter file for parameters
-          // that describe this benchmark. note that we declare them here
-          // in the material model, but other kinds of plugins
-          // may also read these parameters even though they do not
-          // declare them.
-          prm.enter_subsection("Annulus benchmark");
-          {
-            prm.declare_entry("k", "0",
-                              Patterns::Double (0),
-                              "Parameter k in the Annulus benchmark solution. This "
-                              "parameter controls the number of convection cells in "
-                              "the solution (which is 2*k).");
-
-            prm.declare_entry("Use analytical density", "true",
-                              Patterns::Bool(),
-                              "Whether to use the analytical density solution, or to look for a "
-                              "field named <density_field> to use as density.");
-
-            prm.declare_entry("Use transient solution", "false",
-                              Patterns::Bool(),
-                              "Whether to use the transient flow solution, or to use the "
-                              "default instantaneous solution.");
-          }
-          prm.leave_subsection();
-        }
-
-
-
-        void
-        parse_parameters (ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Annulus benchmark");
-          {
-            k = prm.get_double ("k");
-            use_analytical_density = prm.get_bool ("Use analytical density");
-            use_transient_flow_solution = prm.get_bool ("Use transient solution");
-          }
-          prm.leave_subsection();
-
-          density_index = numbers::invalid_unsigned_int;
-          if (use_analytical_density == false)
-            {
-              Assert(this->introspection().compositional_name_exists("density_field"),
-                     ExcInternalError());
-              density_index = this->introspection().compositional_index_for_name("density_field");
-            }
-
-          // Declare dependencies on solution variables
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-
-
-        double get_k() const
-        {
-          return k;
-        }
-
-
-
-        bool use_transient_solution() const
-        {
-          return use_transient_flow_solution;
-        }
-
-
-
-        bool analytical_density() const
-        {
-          return use_analytical_density;
-        }
-
-      private:
-        /**
-         * Whether to use the analytical density.
-         */
-        bool use_analytical_density;
-
-        /**
-         * If not using the analytical density, store the
-         * field index of the density field.
-        */
-        unsigned int density_index;
-
-        /**
-         * Number of positive and negative density anomalies,
-         * resulting in 2*k convection cells.
-         */
-        double k;
-
-        /**
-         * Whether to use the transient flow solution.
-        */
-        bool use_transient_flow_solution;
-    };
-
-
-
-    /**
-     * Velocity boundary condition for the Annulus benchmark
-     */
-    template <int dim>
-    class AnnulusBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id ,
-                           const Point<dim> &position) const override
-        {
-          Assert (dim==2, ExcNotImplemented());
-
-          const AnnulusMaterial<dim> &
-          material_model
-            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
-
-          return AnalyticSolutions::Annulus_velocity (position,
-                                                      material_model.get_k(),
-                                                      this->get_time(),
-                                                      material_model.use_transient_solution());
-        }
-    };
-
-
-
-    /**
-     * Gravity model for the Annulus benchmark
-     */
-    template <int dim>
-    class AnnulusGravity : public aspect::GravityModel::Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        Tensor<1,dim>
-        gravity_vector (const Point<dim> &pos) const override
-        {
-          const AnnulusMaterial<dim> &material_model
-            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
-
-          double t = 0.0;
-          if (this->simulator_is_past_initialization() == true)
-            t = this->get_time();
-
-          return AnalyticSolutions::Annulus_gravity(pos,
-                                                    material_model.get_k(),
-                                                    t,
-                                                    material_model.use_transient_solution());
-        }
-    };
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      */
-    template <int dim>
-    class AnnulusPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void initialize() override
-        {
-          const AnnulusMaterial<dim> &material_model
-            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
-          const unsigned int n_components = this->introspection().n_components;
-
-          compute_density_error = (material_model.analytical_density() == false);
-          reference_solution = std::make_unique<AnalyticSolutions::FunctionAnnulus<dim>>(material_model.get_k(),
-                                                                                          n_components,
-                                                                                          material_model.use_transient_solution());
-        }
-
-
-
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override
-        {
-          const unsigned int n_components = this->introspection().n_components;
-          reference_solution->set_time(this->get_time());
-
-          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-          Vector<double> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-          Vector<double> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                              n_components);
-          ComponentSelectFunction<dim> comp_p(dim, n_components);
-
-          VectorTools::integrate_difference (this->get_mapping(),
-                                             this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *reference_solution,
-                                             cellwise_errors_ul2,
-                                             quadrature_formula,
-                                             VectorTools::L2_norm,
-                                             &comp_u);
-          VectorTools::integrate_difference (this->get_mapping(),
-                                             this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *reference_solution,
-                                             cellwise_errors_pl2,
-                                             quadrature_formula,
-                                             VectorTools::L2_norm,
-                                             &comp_p);
-
-
-          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-          // we output the density error either way, but set it to 0 if we do not compute it.
-          // this simplifies postprocessing the output.
-          double rho_l2 = 0.0;
-          if (compute_density_error == true)
-            {
-              Vector<double> cellwise_errors_rhol2 (this->get_triangulation().n_active_cells());
-              ComponentSelectFunction<dim> comp_rho(dim+2, n_components);
-              VectorTools::integrate_difference (this->get_mapping(),
-                                                 this->get_dof_handler(),
-                                                 this->get_solution(),
-                                                 *reference_solution,
-                                                 cellwise_errors_rhol2,
-                                                 quadrature_formula,
-                                                 VectorTools::L2_norm,
-                                                 &comp_rho);
-              rho_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_rhol2, VectorTools::L2_norm);
-            }
-
-          const double topo_l2 = compute_dynamic_topography_error();
-
-          statistics.add_value ("u_L2",
-                                u_l2);
-          statistics.set_precision ("u_L2", 14);
-          statistics.set_scientific ("u_L2", true);
-
-          statistics.add_value ("p_L2",
-                                p_l2);
-          statistics.set_precision ("p_L2", 14);
-          statistics.set_scientific ("p_L2", true);
-
-          statistics.add_value ("rho_L2",
-                                rho_l2);
-          statistics.set_precision ("rho_L2", 14);
-          statistics.set_scientific ("rho_L2", true);
-
-          statistics.add_value ("topo_L2",
-                                topo_l2);
-          statistics.set_precision ("topo_L2", 14);
-          statistics.set_scientific ("topo_L2", true);
-
-          std::ostringstream os;
-
-          os << std::scientific <<  u_l2
-             << ", " << p_l2
-             << ", " << rho_l2
-             << ", " << topo_l2;
-
-          return std::make_pair("Errors u_L2, p_L2, rho_L2, topo_L2:", os.str());
-        }
-
-
-
-        std::list<std::string>
-        required_other_postprocessors() const override
-        {
-          return std::list<std::string> (1, "dynamic topography");
-        }
-
-      private:
-        /**
-         * Function that defines the reference solution to compare against.
-         */
-        std::unique_ptr<Function<dim>> reference_solution;
-
-        /**
-         * Whether to compute the density error. This only makes sense
-         * if the material model does not use the analytical density solution,
-         * otherwise the error is always 0.
-         */
-        bool compute_density_error;
-
-        /**
-         * Calculate the L2 dynamic topography error.
-         */
-        double
-        compute_dynamic_topography_error() const
-        {
-          const Postprocess::DynamicTopography<dim> &dynamic_topography =
-            this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<dim>>();
-
-          const AnnulusMaterial<dim> &material_model
-            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
-          const double k = material_model.get_k();
-
-          const QGauss<dim-1> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-          FEFaceValues<dim> fe_face_values(this->get_mapping(),
-                                           this->get_fe(),
-                                           quadrature_formula,
-                                           update_values | update_gradients |
-                                           update_quadrature_points | update_JxW_values);
-          LinearAlgebra::BlockVector topo_vector = dynamic_topography.topography_vector();
-          std::vector<double> topo_values(quadrature_formula.size());
-
-          double l2_error = 0.;
-
-          typename DoFHandler<dim>::active_cell_iterator
-          cell = this->get_dof_handler().begin_active(),
-          endc = this->get_dof_handler().end();
-
-          for (; cell!=endc; ++cell)
-            if (cell->is_locally_owned())
-              if (cell->at_boundary())
-                for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
-                  if (cell->face(f)->at_boundary())
-                    {
-                      fe_face_values.reinit(cell, f);
-                      MaterialModel::MaterialModelInputs<dim> in_face(fe_face_values, cell, this->introspection(), this->get_solution());
-                      MaterialModel::MaterialModelOutputs<dim> out_face(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-                      fe_face_values[this->introspection().extractors.temperature].get_function_values(topo_vector, topo_values);
-                      in_face.requested_properties = MaterialModel::MaterialProperties::density;
-                      material_model.evaluate(in_face, out_face);
-
-                      for (unsigned int q=0; q < quadrature_formula.size(); ++q)
-                        {
-                          const Point<dim> p = fe_face_values.quadrature_point(q);
-                          const double analytic_normal_stress = AnalyticSolutions::Annulus_normal_traction<dim>(p, k, this->get_time());
-                          const double gravity = this->get_gravity_model().gravity_vector(p).norm();
-                          const double density = out_face.densities[q];
-                          const double diff = - analytic_normal_stress / gravity/ density - topo_values[q];
-                          l2_error += (diff*diff) * fe_face_values.JxW(q);
-                        }
-                    }
-          const double total_l2_error =  Utilities::MPI::sum(l2_error,this->get_mpi_communicator());
-          return std::sqrt(total_l2_error);
-        }
-    };
-
-    /**
-      * A postprocessor that visualizes the analytical solution.
-      */
-    template <int dim>
-    class AnnulusVisualizationPostprocessor : public DataPostprocessor<dim>,
-      public Postprocess::VisualizationPostprocessors::Interface<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        AnnulusVisualizationPostprocessor ()
-          :
-          DataPostprocessor<dim> ()
-        {};
-
-        std::vector<std::string>
-        get_names () const override
-        {
-          std::vector<std::string> solution_names;
-
-          solution_names.push_back ("analytic_pressure");
-          solution_names.push_back ("analytic_density");
-          return solution_names;
-        };
-
-        std::vector<DataComponentInterpretation::DataComponentInterpretation>
-        get_data_component_interpretation () const override
-        {
-          std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretation;
-          interpretation.push_back (DataComponentInterpretation::component_is_scalar);
-          interpretation.push_back (DataComponentInterpretation::component_is_scalar);
-
-          return interpretation;
-        };
-
-        UpdateFlags
-        get_needed_update_flags () const override
-        {
-          return update_quadrature_points;
-        };
-
-        void
-        evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                              std::vector<Vector<double>> &computed_quantities) const override
-        {
-          const unsigned int n_quadrature_points = input_data.solution_values.size();
-          Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-          Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
-
-
-          const AnnulusMaterial<dim> &material_model
-            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
-
-          for (unsigned int q=0; q<n_quadrature_points; ++q)
-            {
-              computed_quantities[q][0] = AnalyticSolutions::Annulus_pressure(input_data.evaluation_points[q],
-                                                                              material_model.get_k(),
-                                                                              this->get_time());
-              computed_quantities[q][1] = AnalyticSolutions::Annulus_density(input_data.evaluation_points[q],
-                                                                             material_model.get_k(),
-                                                                             this->get_time(),
-                                                                             material_model.use_transient_solution());
-            }
-        };
-    };
-
-
-
-    /**
-     * A particle property that represents the density on particles.
-     */
-    template <int dim>
-    class ParticleDensity : public aspect::Particle::Property::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void
-        initialize_one_particle_property (const Point<dim> &position,
-                                          std::vector<double> &particle_properties) const override
-        {
-          const AnnulusMaterial<dim> &material_model
-            = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
-
-          const double density = AnalyticSolutions::Annulus_density(position,
-                                                                    material_model.get_k(),
-                                                                    /*time*/ 0.0,
-                                                                    material_model.use_transient_solution());
-
-          particle_properties.push_back(density);
-        }
-
-
-
-        std::vector<std::pair<std::string, unsigned int>>
-        get_property_information() const override
-        {
-          return {{"particle_density",1}};
-        }
-    };
-
-
-
-    /**
-    * A initial condition for compositional fields that represents the initial density.
-    */
-    template <int dim>
-    class AnnulusInitialDensity : public aspect::InitialComposition::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        double initial_composition (const Point<dim> &position,
-                                    const unsigned int n_comp) const override
-        {
-          const double density_index = this->introspection().compositional_index_for_name("density_field");
-
-          if (n_comp == density_index)
-            {
-              const AnnulusMaterial<dim> &material_model
-                = Plugins::get_plugin_as_type<const AnnulusMaterial<dim>>(this->get_material_model());
-
-              return AnalyticSolutions::Annulus_density(position,
-                                                        material_model.get_k(),
-                                                        /*time*/ 0.0,
-                                                        material_model.use_transient_solution());
-            }
-
-          return 0.0;
-        }
-    };
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace AnnulusBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(AnnulusMaterial,
-                                   "AnnulusMaterial",
-                                   "A material model that corresponds to the `Annulus' benchmark. "
-                                   "See the manual for more information.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(AnnulusBoundary,
-                                            "AnnulusBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "`Annulus' benchmark. See the manual for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(AnnulusPostprocessor,
-                                  "AnnulusPostprocessor",
-                                  "A postprocessor that compares the solution of the `Annulus' benchmark "
-                                  "with the one computed by ASPECT "
-                                  "and reports the error. See the manual for more information.")
-
-    ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(AnnulusVisualizationPostprocessor,
-                                                "AnnulusVisualizationPostprocessor",
-                                                "A visualization output object that visualizes "
-                                                "the analytical solution of the Annulus benchmark.")
-
-    ASPECT_REGISTER_PARTICLE_PROPERTY(ParticleDensity,
-                                      "particle density",
-                                      "A particle property that represents the density.")
-
-    ASPECT_REGISTER_GRAVITY_MODEL(AnnulusGravity,
-                                  "annulus gravity",
-                                  "A gravity model for the `Annulus' benchmark.")
-
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(AnnulusInitialDensity,
-                                              "initial density",
-                                              "An initial condition for composition following the initial density.")
-  }
-}
diff --git a/benchmarks/annulus/transient/transient_annulus.prm.bak b/benchmarks/annulus/transient/transient_annulus.prm.bak
deleted file mode 100644
index 46833d000a9..00000000000
--- a/benchmarks/annulus/transient/transient_annulus.prm.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-# The 2D Stokes in an annulus benchmark, for which an
-# analytical solution is available. This is the rotating
-# version of the benchmark described in Gassmoeller et al. 2023.
-#
-# See the doc/ directory or manual for more information.
-
-# Most parameters are identical to the instantaneous version
-# of the benchmark. Refer to that parameter file for most settings.
-include $ASPECT_SOURCE_DIR/benchmarks/annulus/instantaneous/annulus.prm
-
-
-# Only list parameters that are specific for the transient benchmark
-set Additional shared libraries            = ../plugin/libannulus.so
-set Dimension                              = 2
-
-# for benchmark: t = log(1 + 4 pi)
-set End time                                = 2.6075939815049280917817614240391581472837221358084918109292273672
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_field
-end
-
-subsection Initial composition model
-  set List of model names = initial density
-end
-
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-end
-
-subsection Annulus benchmark
-  set Use analytical density  = false
-  set Use transient solution  = true
-  set k                       = 4
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, AnnulusPostprocessor, rotation statistics
-
-  subsection Dynamic topography
-    set Density above = 0
-    set Density below = 0
-  end
-
-  subsection Visualization
-    set List of output variables = density, gravity, AnnulusVisualizationPostprocessor
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 2.6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 200
-    set Stokes solver type = block GMG
-    set Krylov method for cheap solver steps = IDR(s)
-    set IDR(s) parameter = 4
-  end
-end
-
-subsection Particles
-  set Integration scheme = rk2
-  set Interpolation scheme = bilinear least squares
-  set List of particle properties = particle density
-  set Update ghost particles = true
-  set Particle generator name = random uniform
-  set Load balancing strategy = add particles
-  set Minimum particles per cell = 12
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 49152
-    end
-  end
-end
diff --git a/benchmarks/blankenbach/base_case1a.prm.bak b/benchmarks/blankenbach/base_case1a.prm.bak
deleted file mode 100644
index 67dfd748504..00000000000
--- a/benchmarks/blankenbach/base_case1a.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-# This is case 1a from the Blankenbach Benchmark (Blankenbach 1989).
-
-set Additional shared libraries            = ./plugin/libblankenbach.so
-set End time                               = 1.0
-set Use years in output instead of seconds = false
-set CFL number = 5.0
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0; 0; 1
-    set Variable names      = depth
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-
-  subsection Ascii data model
-    set Data directory =
-    set Data file name = initial_temperature_case1a.txt
-  end
-end
-
-subsection Material model
-  set Model name = nondimensional
-
-  subsection Nondimensional model
-    set Di                      = 0.0
-    set Ra                      = 1e4
-    set Reference density       = 1
-    set Reference specific heat = 1
-    set Use TALA                = false
-    set Viscosity temperature prefactor = 0.0
-    set Viscosity depth prefactor = 0.0
-    set gamma                   = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 1.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Formulation
-  set Formulation          = custom # with this selection equivalent to BA
-  set Mass conservation    = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heat flux statistics gradient, heating statistics, heat flux densities, temperature ascii out
-
-  subsection Visualization
-    set Time between graphical output = 0.05
-    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = steady state velocity
-
-  subsection Steady state velocity
-    set Maximum relative deviation = 1e-5
-    set Time in steady state       = 0.1
-  end
-end
diff --git a/benchmarks/blankenbach/base_case1b.prm.bak b/benchmarks/blankenbach/base_case1b.prm.bak
deleted file mode 100644
index 80953a9d798..00000000000
--- a/benchmarks/blankenbach/base_case1b.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-include base_case1a.prm
-
-set Additional shared libraries            = ./plugin/libblankenbach.so
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory =
-    set Data file name = initial_temperature_case1b.txt
-  end
-end
-
-subsection Material model
-  subsection Nondimensional model
-    set Ra                      = 1e5
-  end
-end
diff --git a/benchmarks/blankenbach/base_case1c.prm.bak b/benchmarks/blankenbach/base_case1c.prm.bak
deleted file mode 100644
index 4f3c92497d9..00000000000
--- a/benchmarks/blankenbach/base_case1c.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-include base_case1a.prm
-
-set Additional shared libraries            = ./plugin/libblankenbach.so
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory =
-    set Data file name = initial_temperature_case1c.txt
-  end
-end
-
-subsection Material model
-  subsection Nondimensional model
-    set Ra                      = 1e6
-  end
-end
diff --git a/benchmarks/blankenbach/base_case2a.prm.bak b/benchmarks/blankenbach/base_case2a.prm.bak
deleted file mode 100644
index 34442d9d319..00000000000
--- a/benchmarks/blankenbach/base_case2a.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-# This is case 2a from the Blankenbach Benchmark (Blankenbach 1989).
-
-set Additional shared libraries            = ./plugin/libblankenbach.so
-set End time                               = 1.0
-set Use years in output instead of seconds = false
-set CFL number = 5.0
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0; 0; 1
-    set Variable names      = depth
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-
-  subsection Ascii data model
-    set Data directory =
-    set Data file name = initial_temperature_case2a.txt
-  end
-end
-
-subsection Material model
-  set Model name = nondimensional
-
-  subsection Nondimensional model
-    set Di                      = 0.0
-    set Ra                      = 1e4
-    set Reference density       = 1
-    set Reference specific heat = 1
-    set Use TALA                = false
-    set Viscosity temperature prefactor = 6.907755279
-    set Viscosity depth prefactor = 0.0
-    set gamma                   = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 1.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Formulation
-  set Formulation          = custom # with this selection equivalent to BA
-  set Mass conservation    = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heat flux statistics gradient, heating statistics, heat flux densities, temperature ascii out
-
-  subsection Visualization
-    set Time between graphical output = 0.05
-    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = steady state velocity
-
-  subsection Steady state velocity
-    set Maximum relative deviation = 1e-5
-    set Time in steady state       = 0.1
-  end
-end
diff --git a/benchmarks/blankenbach/base_case2b.prm.bak b/benchmarks/blankenbach/base_case2b.prm.bak
deleted file mode 100644
index 0851fcf0cf5..00000000000
--- a/benchmarks/blankenbach/base_case2b.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# This is case 2b from the Blankenbach Benchmark (Blankenbach 1989).
-
-set Additional shared libraries            = ./plugin/libblankenbach.so
-set End time                               = 1.0
-set Use years in output instead of seconds = false
-set CFL number = 5.0
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0; 0; 1
-    set Variable names      = depth
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2.5
-    set Y extent = 1
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1, ratio=2.5
-    set Function expression = 1* ((1.0-z/L) + p*cos(k*pi*x/L/ratio)*sin(pi*z/L))
-  end
-
-  subsection Ascii data model
-    set Data directory =
-    set Data file name = initial_temperature_case2b.txt
-  end
-end
-
-subsection Material model
-  set Model name = nondimensional
-
-  subsection Nondimensional model
-    set Di                      = 0.0
-    set Ra                      = 1e4
-    set Reference density       = 1
-    set Reference specific heat = 1
-    set Use TALA                = false
-    set Viscosity temperature prefactor = 9.70406052783923433184
-    set Viscosity depth prefactor = 4.1588830833596718565
-    set gamma                   = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.0
-  set Refinement fraction                = 1.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Formulation
-  set Formulation          = custom # with this selection equivalent to BA
-  set Mass conservation    = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heat flux statistics gradient, heating statistics, heat flux densities, temperature ascii out
-
-  subsection Visualization
-    set Time between graphical output = 0.002
-    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = steady state velocity
-  set Checkpoint on termination = true
-
-  subsection Steady state velocity
-    set Maximum relative deviation = 1e-5
-    set Time in steady state       = 0.1
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint = 600
-end
diff --git a/benchmarks/blankenbach/plugin/code.cc.bak b/benchmarks/blankenbach/plugin/code.cc.bak
deleted file mode 100644
index 49920460923..00000000000
--- a/benchmarks/blankenbach/plugin/code.cc.bak
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <algorithm>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that generates ascii data output of the temperature
-     * field to be used as initial condition.
-     */
-    template <int dim>
-    class TemperatureAsciiOut : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    TemperatureAsciiOut<dim>::execute (TableHandler &)
-    {
-      std::string filename = (this->get_output_directory() + "temperature_ascii_data.txt");
-
-      struct entry
-      {
-        Point<dim> p;
-        double t;
-      };
-      std::vector<entry> entries;
-
-      const QMidpoint<dim> quadrature_formula;
-
-      const unsigned int n_q_points =  quadrature_formula.size();
-      FEValues<dim> fe_values (this->get_mapping(), this->get_fe(),  quadrature_formula,
-                               update_JxW_values | update_values | update_quadrature_points);
-
-      std::vector<double> temperature_values(n_q_points);
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(), temperature_values);
-
-            for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
-              {
-                entry e;
-                e.p = fe_values.quadrature_point(q);
-                e.t = temperature_values[q];
-                entries.push_back(e);
-              }
-          }
-
-      struct sorter
-      {
-        bool operator() (const entry &i, const entry &j)
-        {
-          if (std::abs(i.p[1]-j.p[1])<1e-6)
-            return i.p[0] < j.p[0];
-          else
-            return i.p[1] < j.p[1];
-        }
-      } sorter_instance;
-      std::sort(entries.begin(), entries.end(), sorter_instance);
-
-      unsigned int n_x, n_y;
-      {
-        // find unique number of x and y values by stuffing them into a std::set
-        struct sort_double
-        {
-          bool operator() (const double &i, const double &j)
-          {
-            return i<j;
-          }
-        } sort_double_instance;
-        struct compare_double_eps
-        {
-          bool operator() (const double &i, const double &j)
-          {
-            return (std::abs(i-j)<1e-6);
-          }
-        } compare_double_instance;
-
-        std::vector<double> x_values, y_values;
-        for (unsigned int idx = 0; idx< entries.size(); ++idx)
-          {
-            x_values.push_back(entries[idx].p(0));
-            y_values.push_back(entries[idx].p(1));
-          }
-        std::sort(x_values.begin(), x_values.end(), sort_double_instance);
-        x_values.erase( std::unique( x_values.begin(), x_values.end(), compare_double_instance ), x_values.end() );
-        std::sort(y_values.begin(), y_values.end(), sort_double_instance);
-        y_values.erase( std::unique( y_values.begin(), y_values.end(), compare_double_instance ), y_values.end() );
-
-        n_x = x_values.size();
-        n_y = y_values.size();
-      }
-
-
-      std::stringstream f;
-
-      f << std::scientific << std::setprecision(15);
-
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          // Note: POINTS is only useful if our mesh is a structured grid
-          f << "# POINTS: " << n_x << ' ' << n_y << "\n";
-          f << "# x y T\n";
-        }
-
-      for (unsigned int idx = 0; idx< entries.size(); ++idx)
-        f << entries[idx].p << ' ' << entries[idx].t << '\n';
-
-      aspect::Utilities::collect_and_write_file_content(filename,
-                                                        f.str(),
-                                                        this->get_mpi_communicator());
-
-      return std::make_pair (std::string ("Writing TemperatureAsciiOut:"),
-                             filename);
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(TemperatureAsciiOut,
-                                  "temperature ascii out",
-                                  "A postprocessor that generates ascii data "
-                                  "output of the temperature field that can "
-                                  "be read in in a subsequent computation.")
-  }
-}
diff --git a/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc.bak b/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc.bak
deleted file mode 100644
index 33dd11fe2fa..00000000000
--- a/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc.bak
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "heat_flux_statistics_gradient.h"
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    HeatFluxStatisticsGradient<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the temperature element alone.
-      const QGauss<dim-1> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.temperature).degree+1);
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula,
-                                        update_gradients      | update_values |
-                                        update_normal_vectors |
-                                        update_quadrature_points       | update_JxW_values);
-
-      std::vector<Tensor<1,dim>> temperature_gradients (quadrature_formula.size());
-      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-
-      std::map<types::boundary_id, double> local_boundary_fluxes;
-
-      MaterialModel::MaterialModelInputs<dim> in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-
-      // for every surface face on which it makes sense to compute a
-      // heat flux and that is owned by this processor,
-      // integrate the normal heat flux given by the formula
-      //   j =  - k * n . grad T
-      //
-      // for the spherical shell geometry, note that for the inner boundary,
-      // the normal vector points *into* the core, i.e. we compute the flux
-      // *out* of the mantle, not into it. we fix this when we add the local
-      // contribution to the global flux
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
-            if (cell->at_boundary(f))
-              {
-                fe_face_values.reinit (cell, f);
-                in.reinit(fe_face_values, cell, this->introspection(), this->get_solution());
-
-                this->get_material_model().evaluate(in, out);
-
-                // Get the temperature gradients from the solution.
-                fe_face_values[this->introspection().extractors.temperature].get_function_gradients (this->get_solution(), temperature_gradients);
-
-                double local_normal_flux = 0;
-                for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                  {
-                    const double thermal_conductivity
-                      = out.thermal_conductivities[q];
-
-                    local_normal_flux
-                    +=
-                      -thermal_conductivity *
-                      (temperature_gradients[q] *
-                       fe_face_values.normal_vector(q)) *
-                      fe_face_values.JxW(q);
-                  }
-
-                const types::boundary_id boundary_indicator
-                  = cell->face(f)->boundary_id();
-                local_boundary_fluxes[boundary_indicator] += local_normal_flux;
-              }
-
-      // now communicate to get the global values
-      std::map<types::boundary_id, double> global_boundary_fluxes;
-      {
-        // first collect local values in the same order in which they are listed
-        // in the set of boundary indicators
-        const std::set<types::boundary_id>
-        boundary_indicators
-          = this->get_geometry_model().get_used_boundary_indicators ();
-        std::vector<double> local_values;
-        for (std::set<types::boundary_id>::const_iterator
-             p = boundary_indicators.begin();
-             p != boundary_indicators.end(); ++p)
-          local_values.push_back (local_boundary_fluxes[*p]);
-
-        // then collect contributions from all processors
-        std::vector<double> global_values (local_values.size());
-        Utilities::MPI::sum (local_values, this->get_mpi_communicator(), global_values);
-
-        // and now take them apart into the global map again
-        unsigned int index = 0;
-        for (std::set<types::boundary_id>::const_iterator
-             p = boundary_indicators.begin();
-             p != boundary_indicators.end(); ++p, ++index)
-          global_boundary_fluxes[*p] = global_values[index];
-      }
-
-      // now add all of the computed heat fluxes to the statistics object
-      // and create a single string that can be output to the screen
-      std::ostringstream screen_text;
-      unsigned int index = 0;
-      for (std::map<types::boundary_id, double>::const_iterator
-           p = global_boundary_fluxes.begin();
-           p != global_boundary_fluxes.end(); ++p, ++index)
-        {
-          const std::string name = "Outward heat flux (gradient) through boundary with indicator "
-                                   + Utilities::int_to_string(p->first)
-                                   + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                 .translate_id_to_symbol_name (p->first))
-                                   + " (W)";
-          statistics.add_value (name, p->second);
-
-          // also make sure that the other columns filled by the this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (name, 8);
-          statistics.set_scientific (name, true);
-
-          // finally have something for the screen
-          screen_text.precision(4);
-          screen_text << p->second << " W"
-                      << (index == global_boundary_fluxes.size()-1 ? "" : ", ");
-        }
-
-      return std::pair<std::string, std::string> ("Heat fluxes (gradient) through boundary parts:",
-                                                  screen_text.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(HeatFluxStatisticsGradient,
-                                  "heat flux statistics gradient",
-                                  "A postprocessor that computes some statistics about "
-                                  "the (conductive) heat flux across boundaries. For each boundary "
-                                  "indicator (see your geometry description for which boundary "
-                                  "indicators are used), the heat flux is computed in outward "
-                                  "direction, i.e., from the domain to the outside, using the "
-                                  "formula $\\int_{\\Gamma_i} -k \\nabla T \\cdot \\mathbf n$ "
-                                  "where $\\Gamma_i$ is the part of the boundary with indicator $i$, "
-                                  "$k$ is the thermal conductivity as reported by the material model, "
-                                  "$T$ is the temperature, and $\\mathbf n$ is the outward normal. "
-                                  "Note that the quantity so computed does not include any energy "
-                                  "transported across the boundary by material transport in cases "
-                                  "where $\\mathbf u \\cdot \\mathbf n \\neq 0$. The point-wise "
-                                  "heat flux can be obtained from the heat flux map postprocessor, "
-                                  "which outputs the heat flux to a file, or the heat flux map "
-                                  "visualization postprocessor, which outputs the heat flux for "
-                                  "visualization. "
-                                  "\n\n"
-                                  "As stated, this postprocessor computes the \\textit{outbound} heat "
-                                  "flux. If you "
-                                  "are interested in the opposite direction, for example from "
-                                  "the core into the mantle when the domain describes the "
-                                  "mantle, then you need to multiply the result by -1."
-                                  "\n\n"
-                                  "\\note{In geodynamics, the term ``heat flux'' is often understood "
-                                  "to be the quantity $- k \\nabla T$, which is really a heat "
-                                  "flux \\textit{density}, i.e., a vector-valued field. In contrast "
-                                  "to this, the current postprocessor only computes the integrated "
-                                  "flux over each part of the boundary. Consequently, the units of "
-                                  "the quantity computed here are $W=\\frac{J}{s}$.}"
-                                  "\n\n"
-                                  "The ``heat flux densities'' postprocessor computes the same "
-                                  "quantity as the one here, but divided by the area of "
-                                  "the surface.")
-  }
-}
diff --git a/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.h.bak b/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.h.bak
deleted file mode 100644
index be9b019128c..00000000000
--- a/benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.h.bak
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_heat_flux_statistics_gradient_h
-#define _aspect_postprocess_heat_flux_statistics_gradient_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    /**
-     * A postprocessor that computes some statistics about the heat_flux based
-     * on the gradient of the temperature.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class HeatFluxStatisticsGradient : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm.bak b/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm.bak
deleted file mode 100644
index d3006d93625..00000000000
--- a/benchmarks/buiter_et_al_2008_jgr/figure_6_1e20.prm.bak
+++ /dev/null
@@ -1,179 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1e6
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-3
-set Max nonlinear iterations               = 100
-set CFL number                             = 0.5
-set Output directory                       = output_figure_6_1e20
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-
-# Model geometry (400x35 km)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 400
-    set Y repetitions = 100
-    set X extent      = 400e3
-    set Y extent      = 35e3
-  end
-end
-
-# No mesh refinement, but the coarse mesh is 400x100
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# The nonlinear solver typically converges more quickly
-# when no cheap Stokes solver steps are used for
-# problems with Drucker-Prager plasticity.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-# Free surface boundary classifications.
-# Advecting the free surface vertically rather than
-# in the surface normal direction can result in a
-# more stable mesh when the deformation is large
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Surface velocity projection = vertical
-  end
-end
-
-# Velocity on boundaries characterized by functions
-# Total extension rate is 1 cm/yr (0.5 cm/yr on each side)
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: function, right x:function
-  set Tangential velocity boundary indicators = bottom
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.005, year=1
-    set Function expression = if (x<200e3 , -1*m/year, 1*m/year); 0.
-  end
-end
-
-# Number and name of compositional fields
-# The field plastic_strain is used for tracking the plastic finite strain invariant
-# upper: brittle upper crust; seed: 'weaker' brittle region
-# lower: viscous lower crust
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = plastic_strain, upper, seed, lower
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0; \
-                              if((y>=17.5e3 && x<=198.0e3) || (y>=17.5e3 && x>=202.0e3) || \
-                                 (y>=18.9e3 && x>=198.0e3 && x<=202.0e3), 1, 0); \
-                              if(y>=17.5e3 && y<18.9e3 && x>198.0e3 && x<202.0e3, 1, 0); \
-                              if(y<17.5e3, 1, 0);
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Use discontinuous composition bound preserving limiter
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 2
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
-    set Global composition maximum = 100.0, 1.0, 1.0, 1.0
-    set Global composition minimum =   0.0, 0.0, 0.0, 1.0
-  end
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Temperature initial conditions (isothermal)
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Minimum strain rate   = 1.e-20
-    set Reference strain rate = 1.e-16
-    set Minimum viscosity     = 1e18
-    set Maximum viscosity     = 1e26
-    set Thermal diffusivities = 1.e-6
-    set Heat capacities       = 750.
-    set Densities             = 2800
-    set Thermal expansivities = 0.
-    set Viscosity averaging scheme = harmonic
-    set Viscous flow law           = dislocation
-    set Prefactors for dislocation creep          = 5.e-25, 5.e-25, 5.e-25, 5.e-25, 5.e-21
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Angles of internal friction =   30.,   30.,   30.,   4.,   30.
-    set Cohesions                   = 20.e6, 20.e6, 20.e6, 2.e6, 1.e11
-    set Strain weakening mechanism = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals  =     0.5,    0.5,    0.5, 0.5, 0.5
-    set End plasticity strain weakening intervals    =     1.5,    1.5,    1.5, 1.5, 1.5
-    set Cohesion strain weakening factors            =     0.1,    0.1,    0.1, 1.0, 1.0
-    set Friction strain weakening factors            = 0.13333, 0.1333, 0.1333, 1.0, 1.0
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, error indicator, partition
-    set Time between graphical output = 1e5
-    set Interpolate output = false
-  end
-end
diff --git a/benchmarks/buiter_et_al_2008_jgr/figure_6_1e22.prm.bak b/benchmarks/buiter_et_al_2008_jgr/figure_6_1e22.prm.bak
deleted file mode 100644
index 1a5a5380b6d..00000000000
--- a/benchmarks/buiter_et_al_2008_jgr/figure_6_1e22.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-include figure_6_1e20.prm
-
-set Dimension                              = 2
-set Output directory                       = output_figure_6_1e22
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Prefactors for dislocation creep = 5.e-25, 5.e-25, 5.e-25, 5.e-25, 5.e-23
-  end
-end
diff --git a/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm.bak b/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm.bak
deleted file mode 100644
index 544ad88b0ac..00000000000
--- a/benchmarks/buiter_et_al_2016_jsg/doc/convergence.part.prm.bak
+++ /dev/null
@@ -1,44 +0,0 @@
-# Note that the Linear/Nonlinear solver tolerance should be sufficiently strict
-# to avoid numerical instabilities.
-set Nonlinear solver scheme                 = single Advection, iterated Stokes
-set Nonlinear solver tolerance               = 1e-7
-set Max nonlinear iterations                = 100
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance             = 1e-8
-    set Number of cheap Stokes solver steps = 0
-
-    # A higher restart length makes the solver more robust for large viscosity
-    # contrasts.
-    set GMRES solver restart length         = 200
-  end
-end
-
-# The  discontinuous composition bound preserving limiter produces sharp
-# interfaces between compositional layers.
-subsection Discretization
-  set Use discontinuous composition discretization   = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-    set Global composition maximum                 = 1, 1, 1, 1, 1, 100
-    set Global composition minimum                 = 0, 0, 0, 0, 0, 0
-  end
-end
-
-# Material properties
-# Using harmonic material averaging is required to achieve reasonable
-# convergence behavior, particulally when the viscosity contrast is large.
-subsection Material model
-  set Material averaging                             = harmonic average
-  set Model name                                     = visco plastic
-
-  subsection Visco Plastic
-    # The viscosity contrast is 10^7 here and any value higher than this causes
-    # divergence of the solver.
-    set Minimum viscosity                            = 1e5
-    set Maximum viscosity                            = 1e12
-    set Viscosity averaging scheme                   = harmonic
-  end
-end
diff --git a/benchmarks/buiter_et_al_2016_jsg/doc/velocity_bc.part.prm.bak b/benchmarks/buiter_et_al_2016_jsg/doc/velocity_bc.part.prm.bak
deleted file mode 100644
index 3a997ed04db..00000000000
--- a/benchmarks/buiter_et_al_2016_jsg/doc/velocity_bc.part.prm.bak
+++ /dev/null
@@ -1,37 +0,0 @@
-# Spatial domain of different compositional fields:
-# Quartz sand (qsand) has two layers with 1 cm thickness each.
-# Corundum sand (csand) is in the middle of the 2-layer quatz sand and is
-# 1 cm thick.
-# The boundary 2-mm-thin layers (bound) sit on both the bottom of the domain and
-# between the sand and rigid indenter block. The right boundary has a constant
-# inflow velocity, which pushes a rigid block that approximates a mobile wall.
-# Movement of the rigid block drives deformation in the sand layers.
-# The boundary between the rigid block and boundary layers produces a sharp
-# velocity discontinuity that localizes brittle deformation.
-# The sticky air layer is set on top of the sand layer and approximates a
-# free surface.
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Zero velocity boundary indicators              = bottom    #no slip
-  set Tangential velocity boundary indicators        = left      #free slip
-
-  # right - material inflow with a velocity of 2.5 cm/hour at the height of
-  # the pushing block. The velocity linearly decreases from the base of the
-  # rigid block to 0 cm/hour at the base of the model.
-  set Prescribed velocity boundary indicators        = right:function
-
-  subsection Function
-    set Variable names                             = x,y
-    set Function constants                         = cm=0.01, h=3600, th=0.002
-    set Function expression                        = if(y>th, -2.5*cm/h, -(y/th)*2.5*cm/h); 0
-  end
-end
-
-# The top boundary is open (zero traction), which allows the sticky air to
-# flow freely through it as topography develops along the wedge. Additional
-# testing revealed that using a true free surface leads to significant mesh
-# distortion and associated numerical instabilities.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators        = top: zero traction
-end
diff --git a/benchmarks/buiter_et_al_2016_jsg/exp_1.prm.bak b/benchmarks/buiter_et_al_2016_jsg/exp_1.prm.bak
deleted file mode 100644
index 51b2116626e..00000000000
--- a/benchmarks/buiter_et_al_2016_jsg/exp_1.prm.bak
+++ /dev/null
@@ -1,191 +0,0 @@
-# This is an input file for the setup for the benchmark described in Buiter et al, 2016
-# which simulates a stable wedge undergoing translation.
-# Experiment 2 can be found in $ASPECT_INSTALL/aspect/benchmarks/buiter_et_al_2016_jsg
-# Please refer to the README file for further details on the experimental setup and results.
-#####  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 14400 # Equivalent to 10 cm of horizontal translation
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-
-# Note that the Linear/Nonlinear solver tolerance should be sufficiently
-# strict to avoid numerical instabilities.
-
-set Nonlinear solver tolerance             = 1e-7
-set Max nonlinear iterations               = 100
-set CFL number                             = 0.5
-set Output directory                       = output-stable_wedge
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-set Resume computation         = auto
-
-#### Parameters describing the model
-
-# Model geometry
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 300
-    set Y repetitions = 70
-    set X extent      = 0.15
-    set Y extent      = 0.035
-  end
-end
-
-# Mesh refinement specifications
-# AMR is not used since model X,Y repetitions are defined.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications
-# Temperature boundary conditions
-# Temperature does not affect model
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left
-  set Prescribed velocity boundary indicators = right:function
-  set Zero velocity boundary indicators       = bottom
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = cm=0.01, h=3600., th=0.002                  # h = hr = 3600 s; th = thickness of bounding box
-    set Function expression = if (y>th, -2.5*cm/h, -(y/th)*2.5*cm/h) ; 0. # velocity BC is defined such that the wedge is pushed at 2.5 cm/h to the left above the bound                            -ing box and tapers to zero from the top to the bottom of the bounding box.
-  end
-end
-
-# The zero traction surface allows sticky air to leave the system in response to compression.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = top: zero traction
-end
-
-# Initial temperature field
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 100
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 5
-  set Names of fields  = sand, bound, block, sticky_air, total_strain
-end
-
-# Spatial domain of different compositional fields:
-# Sand wedge with taper angle of 20 degrees,
-# Box bounding simulated sandbox experiment,
-# Rigid indentor used to translate wedge, and
-# Sticky air layer above modelled materials
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = th=0.002
-    set Function expression = if((x<0.1324 && x>=0.05) && (y<=0.36408*x-0.0182039 && y>=th), 1, 0); \
-                              if((x>=0.1324 && x<0.1329) || (x>0 && y<=th),1,0); \
-                              if(x>=0.1329 && y>th,1,0); \
-            if((x<=0.1324 && y>0.36408*x-0.0182039 && y>th) || (x<0.05 && y>th),1,0); \
-            0;
-  end
-end
-
-# Use disccontinous composition bound preserving limiter
-subsection Discretization
-  set Use discontinuous composition discretization  = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-
-    #                                            [sand,  bound, block, sticky_air, total_strain]
-    set Global composition maximum                = 1.,     1.,    1.,    1.,         1e5
-    set Global composition minimum                = 0.,     0.,    0.,    0.,         0.
-  end
-end
-
-# Material model
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    #                                                 [bkd, sand,  bound, block, sticky_air, total_strain]
-    set Densities                                   = 1560, 1560., 3100,  1560 , 0,          1560
-    set Reference temperature                       = 293
-    set Heat capacities                             = 750.
-    set Thermal diffusivities                       = 1e-6
-    set Thermal expansivities                       = 0.
-    set Minimum viscosity                           = 1e4
-    set Maximum viscosity                           = 1e12
-    set Viscosity averaging scheme                  = maximum composition
-    set Viscous flow law                            = dislocation
-    set Prefactors for dislocation creep            = 5e-11,5e-50, 5e-50, 5e-11, 5e-5,       1e5
-    set Stress exponents for dislocation creep      = 1.0
-    set Activation energies for dislocation creep   = 0.
-    set Activation volumes for dislocation creep    = 0.
-
-    #                                                 [bkd, sand,  bound, block, sticky_air, total_strain]
-    set Reference strain rate                       = 1.e-5
-    set Minimum strain rate                         = 1.e-10
-    set Strain weakening mechanism                  = total strain
-    set Start plasticity strain weakening intervals = 0,    0.50,  0.5,   0,     0,          1e5
-    set End plasticity strain weakening intervals   = 0.1,  1.00,  1,     0.1,   0.1,        1e4
-    set Angles of internal friction                 = 36.,  36.,   1.6,   0.,    0.,         1e5
-    set Friction strain weakening factors           = 1,    0.861, 1,     1,     1,          1e5
-    set Cohesions                                   = 30.,  30.,   3.,    1.e18, 1.e18,      1e5
-    set Cohesion strain weakening factors           = 1,    1.00,  1,     1,     1,          1e5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name  = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# Checkpointing for restart files
-subsection Checkpointing
-  set Steps between checkpoint = 10
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, visualization
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, strain rate, named additional outputs
-    set Output format                 = vtu
-    set Time between graphical output = 144
-    set Interpolate output            = false
-  end
-end
-
-# Termination Criteria
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step             = 10000
-end
-
-# Note that the Linear/Nonlinear solver tolerance should be sufficiently
-# strict to avoid numerical instabilities.
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance             = 1e-8
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm.bak b/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm.bak
deleted file mode 100644
index b2496ed311c..00000000000
--- a/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm.bak
+++ /dev/null
@@ -1,224 +0,0 @@
-# This parameter file reproduces the unstable wedge experiment 2 from
-# Buiter et al., 2016, JSG.
-# Experiment 2 tests how an unstable subcritical wedge deforms to reach the
-# critical taper solution. Horizontal layers of sand have 10 cm shortening
-# by inward movement of a mobile wall with a velocity of 2.5 cm/hour. Both
-# the base and the surface are horizontal and the “wedge” is thus in the
-# unstable field. This experiment builds a thrust wedge through a combination
-# of mainly in-sequence forward and backward thrusting. Deformation starts by
-# forming a pop-up structure near the high viscosity rigid indenter.
-
-#  Global parameters
-set Dimension                                        = 2
-set Start time                                       = 0
-set End time                                         = 14400 #Equivalent to ~10 cm of shortening
-set Use years in output instead of seconds           = false
-set CFL number                                       = 0.5
-set Output directory                                 = output-Brittle_thrust_wedge_exp2
-set Pressure normalization                           = no
-set Timing output frequency                          = 20
-
-# Note that the Linear/Nonlinear solver tolerance should be sufficiently
-# strict to avoid numerical instabilities.
-set Nonlinear solver scheme                          = single Advection, iterated Stokes
-set Nonlinear solver tolerance                       = 1e-7
-set Max nonlinear iterations                         = 100
-
-# For restarting the model
-set Resume computation                               = auto
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                      = 1e-8
-    set Number of cheap Stokes solver steps          = 0
-
-    # A higher restart length makes the solver more robust for large viscosity
-    # contrasts.
-    set GMRES solver restart length                  = 200
-  end
-end
-
-# The  discontinuous composition bound preserving limiter produces sharp
-# interfaces between compositional layers.
-subsection Discretization
-  set Composition polynomial degree                  = 2
-  set Temperature polynomial degree                  = 2
-  set Stokes velocity polynomial degree              = 2
-  set Use locally conservative discretization        = false
-  set Use discontinuous composition discretization   = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-    set Global composition maximum                 = 1, 1, 1, 1, 1, 100
-    set Global composition minimum                 = 0, 0, 0, 0, 0, 0
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint                       = 20
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name                                     = vertical
-
-  subsection Vertical
-    set Magnitude                                    = 9.81
-  end
-end
-
-### Parameters describing the model
-
-# Model geometry (36 x 8 cm)
-subsection Geometry model
-  set Model name                                    = box
-
-  subsection Box
-    set X repetitions                               = 180
-    set Y repetitions                               = 40
-    set X extent                                    = 0.36
-    set Y extent                                    = 0.08
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement                    = 0
-
-  #The resolution is 0.5 mm/cell
-  set Initial global refinement                      = 2
-  set Time steps between mesh refinement             = 0
-end
-
-# Boundary conditions & initial conditions
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Fixed composition boundary indicators          = bottom, left, right
-  set List of model names                            = initial composition
-end
-
-# Number and names of compositional fields
-subsection Compositional fields
-  set Number of fields                               = 6
-  set Names of fields                                = qsand,csand,bound,block, \
-                                                       sticky_air,total_strain
-end
-
-# Spatial domain of different compositional fields:
-# Quartz sand (qsand) has two layers with 1 cm thickness each.
-# Corundum sand (csand) is in the middle of the 2-layer quatz sand and is
-# 1 cm thick.
-# The boundary 2-mm-thin layers (bound) sit on both the bottom of the domain and
-# between the sand and rigid indenter block. The right boundary has a constant
-# inflow velocity, which pushes a rigid block that approximates a mobile wall.
-# Movement of the rigid block drives deformation in the sand layers.
-# The boundary between the rigid block and boundary layers produces a sharp
-# velocity discontinuity that localizes brittle deformation.
-# The sticky air layer is set on top of the sand layer and approximates a
-# free surface.
-
-subsection Initial composition model
-  set Model name                                     = function
-
-  subsection Function
-    set Variable names                               = x,y
-    set Function constants                           = w1=0.35, w2=0.352, \
-                                                     h1=0.002, h2=0.012, \
-                                                     h3=0.022, h4=0.032
-    set Function expression = if((x<=w1 & y<=h2 & y>h1) || (x<= w1 & y>h3 & y<=h4), 1,0); \
-                              if((x<=w1 & y>h2 & y<=h3), 1,0); \
-                              if((x>w1 & x<=w2 & y>h1) ||(y<=h1), 1, 0); \
-                              if(x>w2 & y>h1,1,0); \
-                              if(x<=w1 & y>h4,1,0); 0
-  end
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators          = bottom, top
-  set List of model names                            = initial temperature
-end
-
-# Initial temperature field
-subsection Initial temperature model
-  set Model name                                     = function
-
-  subsection Function
-    set Function expression                          = 293
-  end
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Zero velocity boundary indicators              = bottom    #no slip
-  set Tangential velocity boundary indicators        = left      #free slip
-
-  # right - material inflow with a velocity of 2.5 cm/hour at the height of
-  # the pushing block. The velocity linearly decreases from the base of the
-  # rigid block to 0 cm/hour at the base of the model.
-  set Prescribed velocity boundary indicators        = right:function
-
-  subsection Function
-    set Variable names                             = x,y
-    set Function constants                         = cm=0.01, h=3600, th=0.002
-    set Function expression                        = if(y>th, -2.5*cm/h, -(y/th)*2.5*cm/h); 0
-  end
-end
-
-# The top boundary is open (zero traction), which allows the sticky air to
-# flow freely through it as topography develops along the wedge. Additional
-# testing revealed that using a true free surface leads to significant mesh
-# distortion and associated numerical instabilities.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators        = top: zero traction
-end
-
-# Material properties
-# Using harmonic material averaging is required to achieve reasonable
-# convergence behavior, particulally when the viscosity contrast is large.
-subsection Material model
-  set Material averaging                             = harmonic average
-  set Model name                                     = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature                        = 293
-    set Minimum strain rate                          = 1e-20
-    set Reference strain rate                        = 2e-5
-
-    # The viscosity contrast is 10^7 here and any value higher than this causes
-    # divergence of the solver.
-    set Minimum viscosity                            = 1e5
-    set Maximum viscosity                            = 1e12
-    set Thermal diffusivities                        = 1e-6
-    set Heat capacities                              = 750
-    set Densities                                    = 1560, 1560, 1890, 1560, 3000, 0, 1e5
-    set Thermal expansivities                        = 0
-    set Viscosity averaging scheme                   = harmonic
-    set Viscous flow law                             = dislocation
-    set Prefactors for dislocation creep             = 5e-15, 5e-15, 5e-15, 5e-15, 5e-18, 5e-5, 5e-18
-    set Stress exponents for dislocation creep       = 1
-    set Activation energies for dislocation creep    = 0
-    set Activation volumes for dislocation creep     = 0
-    set Angles of internal friction                  = 36, 36, 36, 16, 0, 0, 1e18
-    set Cohesions                                    = 30, 30, 30, 30, 1e18, 1e18, 1e18
-    set Strain weakening mechanism                   = total strain
-    set Start plasticity strain weakening intervals  = 0.5
-    set End plasticity strain weakening intervals    = 1
-    set Cohesion strain weakening factors            = 1
-    set Friction strain weakening factors            = 1, 0.861, 0.861, 0.875, 1, 1, 1
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors                         = velocity statistics, basic statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set List of output variables                     = density, viscosity, strain rate, error indicator
-    set Output format                                = vtu
-    set Time between graphical output                = 144   # Equivalent to ~0.5 cm of shortening
-    set Interpolate output                           = true
-    set Number of grouped files                      = 1
-  end
-end
diff --git a/benchmarks/buiter_et_al_2016_jsg/exp_2_low_resolution.prm.bak b/benchmarks/buiter_et_al_2016_jsg/exp_2_low_resolution.prm.bak
deleted file mode 100644
index 977ff6d9841..00000000000
--- a/benchmarks/buiter_et_al_2016_jsg/exp_2_low_resolution.prm.bak
+++ /dev/null
@@ -1,32 +0,0 @@
-# This is the unstable wedge experiment 2
-# This prm file is the same as the exp_2_high_resolution.prm file except
-# changes below.
-
-
-
-include $ASPECT_SOURCE_DIR/benchmarks/buiter_et_al_2016_jsg/exp_2_high_resolution.prm
-
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement                 = 0
-
-  # The resolution is 2 mm/cell.
-  set Initial global refinement                   = 0
-  set Time steps between mesh refinement          = 0
-end
-
-# Material properties
-
-subsection Material model
-  set Model name                                  = visco plastic
-
-  subsection Visco Plastic
-    # Further testing revealed that decreasing the model resolution allows
-    # using a higher contrast between the minimum and maximum viscosity.
-    # The viscosity contrast is 10^8 here and any value higher than this
-    # causes divergence of the solver.
-    set Minimum viscosity                        = 1e4
-    set Maximum viscosity                        = 1e12
-  end
-end
diff --git a/benchmarks/burstedde/burstedde.cc.bak b/benchmarks/burstedde/burstedde.cc.bak
deleted file mode 100644
index 08a0b68dbb1..00000000000
--- a/benchmarks/burstedde/burstedde.cc.bak
+++ /dev/null
@@ -1,517 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/postprocess/interface.h>
-
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  /**
-   * This is the "Burstedde" benchmark defined in the following paper:
-   * @code
-   *  @Article{busa13,
-   *    author =       {Burstedde, Carsten and Stadler, Georg and Alisic, Laura and Wilcox, Lucas C and Tan, Eh and Gurnis, Michael and Ghattas, Omar},
-   *    title =        {Large-scale adaptive mantle convection simulation},
-   *    journal =      {Geophysical Journal International},
-   *    year =         2013,
-   *    volume =       192,
-   *    number =       {3},
-   *    publisher =    {Oxford University Press},
-   *    pages =        {889--906}}
-   * @endcode
-   *
-   */
-  namespace BursteddeBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-      Tensor<1,3>
-      burstedde_velocity (const Point<3> &pos,
-                          const double /*eta*/)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const double z = pos[2];
-
-        // create a Point<3> (because it has a constructor that takes
-        // three doubles) and return it (it automatically converts to
-        // the necessary Tensor<1,3>).
-        return Point<3> (x+x*x+x*y+x*x*x*y,
-                         y+x*y+y*y+x*x*y*y,
-                         -2.*z-3.*x*z-3.*y*z-5.*x*x*y*z);
-      }
-
-      double
-      burstedde_pressure (const Point<3> &pos,
-                          const double /*eta*/)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const double z = pos[2];
-
-        return x*y*z+x*x*x*y*y*y*z-5./32.;
-      }
-
-
-      /**
-       * The exact solution for the Burstedde benchmark.
-       */
-      template <int dim>
-      class FunctionBurstedde : public Function<dim>
-      {
-        public:
-          FunctionBurstedde (const double beta)
-            :
-            Function<dim>(dim+2),
-            beta_(beta)
-          {}
-
-          void vector_value (const Point<dim>   &pos,
-                             Vector<double>   &values) const override
-          {
-            Assert (dim == 3, ExcNotImplemented());
-            Assert (values.size() >= 4, ExcInternalError());
-
-            const Point<3> p (pos[0], pos[1], pos[2]);
-
-            const Tensor<1,3> v = AnalyticSolutions::burstedde_velocity (p, beta_);
-            values[0] = v[0];
-            values[1] = v[1];
-            values[2] = v[2];
-
-            values[3] = AnalyticSolutions::burstedde_pressure (p, beta_);
-          }
-
-        private:
-          const double beta_;
-      };
-    }
-
-
-
-    template <int dim>
-    class BursteddeBoundary : public BoundaryVelocity::Interface<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        BursteddeBoundary();
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position) const override;
-
-      private:
-        const double beta;
-    };
-
-    template <int dim>
-    BursteddeBoundary<dim>::BursteddeBoundary ()
-      :
-      beta (0)
-    {}
-
-
-
-    template <>
-    Tensor<1,2>
-    BursteddeBoundary<2>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<2> &/*p*/) const
-    {
-      Assert (false, ExcNotImplemented());
-      return Tensor<1,2>();
-    }
-
-
-
-    template <>
-    Tensor<1,3>
-    BursteddeBoundary<3>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<3> &p) const
-    {
-      return AnalyticSolutions::burstedde_velocity (p, beta);
-    }
-
-
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class BursteddeMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> &p = in.position[i];
-
-              const double x=p[0];
-              const double y=p[1];
-              const double z=p[2];
-              const double mu=exp(1. - beta * (x*(1.-x)+y*(1.-y) + z*(1.-z)));
-
-              out.viscosities[i] = mu;
-              out.thermal_conductivities[i] = 0.0;
-              out.densities[i] = 1.0;
-
-              out.thermal_expansion_coefficients[i] = 0.0;
-              out.compressibilities[i] = 0.0;
-
-              out.specific_heat[i] = 0.0;
-
-              // Pressure derivative of entropy at the given positions.
-              out.entropy_derivative_pressure[i] = 0.0;
-              // Temperature derivative of entropy at the given positions.
-              out.entropy_derivative_temperature[i] = 0.0;
-              // Change in composition due to chemical reactions at the
-              // given positions. The term reaction_terms[i][c] is the
-              // change in compositional field c at point i.
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                out.reaction_terms[i][c] = 0.0;
-
-            }
-
-        }
-
-
-
-
-
-
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Returns the viscosity value in the inclusion
-         */
-        double get_beta() const;
-
-        /**
-         * viscosity value in the inclusion
-         */
-        double beta;
-    };
-
-
-
-    template <int dim>
-    bool
-    BursteddeMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    BursteddeMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      //create a global section in the parameter file for parameters
-      //that describe this benchmark. note that we declare them here
-      //in the material model, but other kinds of plugins (e.g., the gravity
-      //model below) may also read these parameters even though they do not
-      //declare them
-      prm.enter_subsection("Burstedde benchmark");
-      {
-        prm.declare_entry("Viscosity parameter", "20",
-                          Patterns::Double (0),
-                          "Viscosity in the Burstedde benchmark.");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    BursteddeMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Burstedde benchmark");
-      {
-        beta = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-
-    template <int dim>
-    double
-    BursteddeMaterial<dim>::get_beta() const
-    {
-      return beta;
-    }
-
-    /**
-     * Gravity model for the Burstedde benchmark
-     */
-
-    template <int dim>
-    class BursteddeGravity : public aspect::GravityModel::Interface<dim>
-    {
-      public:
-        Tensor<1,dim> gravity_vector (const Point<dim> &pos) const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-        */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        double beta;
-    };
-
-    template <int dim>
-    Tensor<1,dim>
-    BursteddeGravity<dim>::
-    gravity_vector(const Point<dim> &pos) const
-    {
-
-      const double x=pos[0];
-      const double y=pos[1];
-      const double z=pos[2];
-      const double mu=exp(1. - beta * (x*(1.-x)+y*(1.-y) + z*(1.-z)));
-
-      const double dmudx=-beta*(1.-2.*x)*mu;
-      const double dmudy=-beta*(1.-2.*y)*mu;
-      const double dmudz=-beta*(1.-2.*z)*mu;
-
-      Tensor<1,dim> g;
-
-      g[0]=((y*z+3.*std::pow(x,2)*std::pow(y,3)*z)- mu*(2.+6.*x*y))
-           -dmudx*(2.+4.*x+2.*y+6.*std::pow(x,2)*y)
-           -dmudy*(x+std::pow(x,3)+y+2.*x*std::pow(y,2))
-           -dmudz*(-3.*z-10.*x*y*z);
-
-      g[1]=((x*z+3.*std::pow(x,3)*std::pow(y,2)*z)- mu*(2.+2.*std::pow(x,2)+2.*std::pow(y,2)))
-           -dmudx*(x+std::pow(x,3)+y+2.*x*std::pow(y,2))
-           -dmudy*(2.+2.*x+4.*y+4.*std::pow(x,2)*y)
-           -dmudz*(-3.*z-5.*std::pow(x,2)*z);
-
-      g[2]=((x*y+std::pow(x,3)*std::pow(y,3)) - mu*(-10.*y*z))
-           -dmudx*(-3.*z-10.*x*y*z)
-           -dmudy*(-3.*z-5.*std::pow(x,2)*z)
-           -dmudz*(-4.-6.*x-6.*y-10.*std::pow(x,2)*y);
-
-      return g;
-    }
-
-    template <int dim>
-    void
-    BursteddeGravity<dim>::declare_parameters (ParameterHandler &)
-    {
-      //nothing to declare here. This plugin will however, read parameters
-      //declared by the material model in the "Burstedde benchmark" section
-    }
-
-    template <int dim>
-    void
-    BursteddeGravity<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Burstedde benchmark");
-      {
-        beta = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-    }
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the paper Duretz et al. reference above.
-      */
-    template <int dim>
-    class BursteddePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    BursteddePostprocessor<dim>::execute (TableHandler &)
-    {
-      std::unique_ptr<Function<dim>> ref_func;
-      {
-        const BursteddeMaterial<dim> &
-        material_model
-          = Plugins::get_plugin_as_type<const BursteddeMaterial<dim>>(this->get_material_model());
-
-        ref_func = std::make_unique<AnalyticSolutions::FunctionBurstedde<dim>>(material_model.get_beta());
-      }
-
-      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                          dim+2);
-      ComponentSelectFunction<dim> comp_p(dim, dim+2);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_u,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_p,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_p);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_ul2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_pl2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-      std::ostringstream os;
-
-      os << std::scientific <<  u_l1
-         << ", " << p_l1
-         << ", " << u_l2
-         << ", " << p_l2;
-
-      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
-    }
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BursteddeBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(BursteddeMaterial,
-                                   "BursteddeMaterial",
-                                   "A material model that corresponds to the `Burstedde' benchmark. "
-                                   "See the manual for more information.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(BursteddeBoundary,
-                                            "BursteddeBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "`Burstedde' benchmark. See the manual for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(BursteddePostprocessor,
-                                  "BursteddePostprocessor",
-                                  "A postprocessor that compares the solution of the `Burstedde' benchmark "
-                                  "with the one computed by ASPECT "
-                                  "and reports the error. See the manual for more information.")
-    ASPECT_REGISTER_GRAVITY_MODEL(BursteddeGravity,
-                                  "BursteddeGravity",
-                                  "A gravity model in corresponding to the `Burstedde' benchmark. "
-                                  "See the manual for more information.")
-  }
-}
diff --git a/benchmarks/burstedde/burstedde.prm.bak b/benchmarks/burstedde/burstedde.prm.bak
deleted file mode 100644
index fc5bcb93414..00000000000
--- a/benchmarks/burstedde/burstedde.prm.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-# The 3D polynomial Stokes (burstedde) benchmark, for which an
-# analytical solution is available.
-#
-# See the manual for more information.
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-set Additional shared libraries            = ./libburstedde.so
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-############### Parameters describing the model
-# The setup is a 3d unit cube.
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-    set Z extent  = 1
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left  : BursteddeBoundary, \
-                                                right : BursteddeBoundary, \
-                                                front : BursteddeBoundary, \
-                                                back  : BursteddeBoundary, \
-                                                bottom: BursteddeBoundary, \
-                                                top   : BursteddeBoundary
-end
-
-subsection Material model
-  set Model name = BursteddeMaterial
-end
-
-subsection Gravity model
-  set Model name = BursteddeGravity
-end
-
-subsection Burstedde benchmark
-  #Viscosity parameter is beta
-  set Viscosity parameter             = 20
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, BursteddePostprocessor
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate
-  end
-end
diff --git a/benchmarks/burstedde/doc/burstedde.prm.bak b/benchmarks/burstedde/doc/burstedde.prm.bak
deleted file mode 100644
index 830ec42fd67..00000000000
--- a/benchmarks/burstedde/doc/burstedde.prm.bak
+++ /dev/null
@@ -1,32 +0,0 @@
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                = 1e-12
-  end
-end
-
-# Boundary conditions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left  : BursteddeBoundary, \
-                                                right : BursteddeBoundary, \
-                                                front : BursteddeBoundary, \
-                                                back  : BursteddeBoundary, \
-                                                bottom: BursteddeBoundary, \
-                                                top   : BursteddeBoundary
-end
-
-subsection Material model
-  set Model name = BursteddeMaterial
-end
-
-subsection Gravity model
-  set Model name = BursteddeGravity
-end
-
-subsection Burstedde benchmark
-  # Viscosity parameter is beta
-  set Viscosity parameter             = 20
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, BursteddePostprocessor
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/adiabatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/adiabatic.prm.bak
deleted file mode 100644
index 24921c5158f..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe/adiabatic.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left
-  set List of model names = box
-
-  subsection Box
-    set Left temperature = 1600
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/ala.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/ala.prm.bak
deleted file mode 100644
index ea154381bf0..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe/ala.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-subsection Formulation
-  set Mass conservation = reference density profile
-  set Temperature equation = reference density profile
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # A gravity is currently necessary to compute the reference profile.
-    # Set is so low that it does not affect the solution
-    set Magnitude = 0.000000001
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/hydrostatic.prm.bak
deleted file mode 100644
index 503708897df..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe/hydrostatic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = hydrostatic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/isentropic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/isentropic.prm.bak
deleted file mode 100644
index 74b3defb28c..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe/isentropic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = isentropic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm.bak
deleted file mode 100644
index afca18ae037..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm.bak
+++ /dev/null
@@ -1,125 +0,0 @@
-# This is a benchmark to illustrate the effect of different formulations
-# of compressibility. It starts from a simple lateral pipe flow model,
-# in which material enters a lateral pipe with a prescribed velocity.
-# Due to internal heating the material expands and the velocity
-# changes to conserve mass.
-
-set Additional shared libraries = ../plugins/libcompressibility_formulations.so
-set Dimension = 2
-set End time                               = 5e8
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-12
-set Max nonlinear iterations               = 25
-set Output directory                       = output-lateral_pipe
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Number of points = 100000
-    set Composition reference profile = function
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = true
-  set Use discontinuous composition discretization = true
-  set Use discontinuous temperature discretization = true
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_field
-  set Compositional field methods = prescribed field
-  set Types of fields             = density
-end
-
-subsection Initial composition model
-  set Model name = adiabatic density
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Y extent = 100000
-    set X extent = 1000000
-    set X repetitions = 8
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Heating model
-  set List of model names =  adiabatic heating, shear heating, function
-
-  subsection Function
-    set Function expression = 1e-10 * exp(x/1000000)
-  end
-end
-
-############### Boundary conditions
-# We only fix the temperature at the upper boundary, the other boundaries
-# are isolating.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left
-  set List of model names = initial temperature
-end
-
-# To guarantuee a steady downward flow, we fix the velocity
-# at the top and bottom, and set it to free slip on the sides.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left:function
-  set Tangential velocity boundary indicators = bottom,top
-
-  subsection Function
-    set Function expression = 1e-2;0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Material model
-  set Model name = compressibility formulations
-
-  subsection Simple compressible model
-    set Thermal conductivity = 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics
-
-  subsection Visualization
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 1e7
-    set List of output variables = nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm.bak
deleted file mode 100644
index 71b048352cb..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Material model
-  subsection Projected density model
-    set Use adiabatic pressure for density = true
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe/sub_adiabatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe/sub_adiabatic.prm.bak
deleted file mode 100644
index b1991f6d47d..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe/sub_adiabatic.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left
-  set List of model names = box
-
-  subsection Box
-    set Left temperature = 1400
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/ala.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/ala.prm.bak
deleted file mode 100644
index ae46431d4a2..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_advect/ala.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-subsection Formulation
-  set Mass conservation = reference density profile
-  set Temperature equation = reference density profile
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.000000001
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/hydrostatic.prm.bak
deleted file mode 100644
index 503708897df..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_advect/hydrostatic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = hydrostatic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/isentropic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/isentropic.prm.bak
deleted file mode 100644
index 74b3defb28c..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_advect/isentropic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = isentropic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm.bak
deleted file mode 100644
index c627e9cd948..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-# This is a benchmark to illustrate the effect of different formulations
-# of compressibility. It starts from a simple lateral pipe flow model,
-# in which material enters a vertical pipe with a prescribed velocity.
-# Due to increasing temperature at the boundary a density gradient is
-# advected into the model.
-
-set Additional shared libraries = ../plugins/libcompressibility_formulations.so
-set Dimension = 2
-set End time                               = 6201145.069582775
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-14
-set Max nonlinear iterations               = 25
-set Output directory                       = output-lateral_pipe
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Number of points = 100000
-    set Composition reference profile = function
-  end
-end
-
-subsection Heating model
-  set List of model names =
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-  set Composition polynomial degree = 2
-  set Use locally conservative discretization = true
-  set Use discontinuous composition discretization = true
-  set Use discontinuous temperature discretization = true
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-14
-  set Composition solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-14
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_field
-  set Compositional field methods = prescribed field
-  set Types of fields             = density
-end
-
-subsection Initial composition model
-  set Model name = adiabatic density
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Y extent = 100000
-    set X extent = 1000000
-    set X repetitions = 8
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-############### Boundary conditions
-# We only fix the temperature at the upper boundary, the other boundaries
-# are isolating.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 1600 + 200 * t / 1e7
-  end
-end
-
-# To guarantuee a steady downward flow, we fix the velocity
-# at the top and bottom, and set it to free slip on the sides.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left:function
-  set Tangential velocity boundary indicators = bottom,top
-
-  subsection Function
-    set Function expression = 2*1000000/(1e7*(exp(1)-1)) * exp(t/1e7); 0.0
-    set Variable names      = x,y,t
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600 + 200 * ln(1-x*(exp(1)-1)/(2*1000000))
-  end
-end
-
-subsection Material model
-  set Model name = compressibility formulations
-
-  subsection Simple compressible model
-    set Thermal conductivity = 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, material statistics, mass flux statistics
-
-  subsection Visualization
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 6201145.069582775 #1e7
-    set List of output variables = nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm.bak
deleted file mode 100644
index 71b048352cb..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Material model
-  subsection Projected density model
-    set Use adiabatic pressure for density = true
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/ala.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/ala.prm.bak
deleted file mode 100644
index ae46431d4a2..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/ala.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-subsection Formulation
-  set Mass conservation = reference density profile
-  set Temperature equation = reference density profile
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.000000001
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/hydrostatic.prm.bak
deleted file mode 100644
index 503708897df..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/hydrostatic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = hydrostatic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/isentropic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/isentropic.prm.bak
deleted file mode 100644
index 74b3defb28c..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/isentropic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = isentropic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm.bak
deleted file mode 100644
index ec3f7efd58c..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-# This is a benchmark to illustrate the effect of different formulations
-# of compressibility. It starts from a simple lateral pipe flow model.
-# There is no prescribed velocity and one end of the pipe is left open.
-# Then the pressure at the open end is contiuously increased over time,
-# which should lead to a compression of the material in the pipe.
-# This effect can not be captured by all common compressibility
-# approximations except the projected density approximation if it
-# used the full (instead of the adiabatic) pressure.
-
-set Additional shared libraries = ../plugins/libcompressibility_formulations.so
-set Dimension = 2
-
-# 1e7 years
-set End time                               = 31557600e7
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-12
-set Maximum time step                      = 31557600e5
-set Pressure normalization                 = no
-set Output directory                       = output-lateral-pipe
-set Max nonlinear iterations               = 10
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Number of points = 100000
-    set Composition reference profile = function
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = true
-  set Use discontinuous composition discretization = true
-  set Use discontinuous temperature discretization = true
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
-
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_field
-  set Compositional field methods = prescribed field
-  set Types of fields             = density
-end
-
-subsection Initial composition model
-  set Model name = adiabatic density
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Y extent = 100000
-    set X extent = 1000000
-    set X repetitions = 32
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Heating model
-  set List of model names =
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators =
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right:function
-
-  subsection Function
-    # This generates a pressure of e * 100 MPa at 10 Myr
-    #set Function expression = -10 * t / (3600*24*365.25); 0.0
-    set Function expression = -1e8 * exp (t / (1e7*3600*24*365.25)); 0.0
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left:function
-  set Tangential velocity boundary indicators = bottom,top
-
-  subsection Function
-    set Function expression = 0.0;0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600
-  end
-end
-
-subsection Material model
-  set Model name = compressibility formulations
-
-  subsection Simple compressible model
-    set Thermal conductivity = 0.0
-
-    # We need to change the reference viscosity here
-    # slightly, to improve the accuracy, because
-    # of a more appropriate pressure scaling.
-    # This model is somewhat unusual in that all
-    # velocities are driven by dynamic pressure.
-    set Viscosity = 1e20
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics, pressure statistics
-
-  subsection Visualization
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 1e7
-    set List of output variables = adiabat, nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm.bak
deleted file mode 100644
index 71b048352cb..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Material model
-  subsection Projected density model
-    set Use adiabatic pressure for density = true
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density_full_pressure.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density_full_pressure.prm.bak
deleted file mode 100644
index 500450965b7..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density_full_pressure.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Material model
-  subsection Projected density model
-    set Use adiabatic pressure for density = false
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/ala.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/ala.prm.bak
deleted file mode 100644
index ae46431d4a2..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_transient/ala.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-subsection Formulation
-  set Mass conservation = reference density profile
-  set Temperature equation = reference density profile
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.000000001
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/hydrostatic.prm.bak
deleted file mode 100644
index 503708897df..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_transient/hydrostatic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = hydrostatic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/isentropic.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/isentropic.prm.bak
deleted file mode 100644
index 74b3defb28c..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_transient/isentropic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = isentropic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm.bak
deleted file mode 100644
index ffb9245c2b6..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm.bak
+++ /dev/null
@@ -1,138 +0,0 @@
-# This is a benchmark to illustrate the effect of different formulations
-# of compressibility. It starts from a simple lateral pipe flow model.
-# There is no prescribed velocity, and one end of the pipe is open.
-# Due to internal heating the material in the pipe heats up, expands,
-# and creates a flow out of the open end of the pipe. The parameters
-# for this benchmark were chosen so that an analytical solution for
-# the mass flow out of the pipe exists.
-
-set Additional shared libraries = ../plugins/libcompressibility_formulations.so
-set Dimension = 2
-
-# 1e7 years
-set End time                               = 31557600e7
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-12
-set Maximum time step                      = 31557600e5
-set Output directory                       = output-lateral_pipe
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Number of points = 100000
-    set Composition reference profile = function
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = true
-  set Use discontinuous composition discretization = true
-  set Use discontinuous temperature discretization = true
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
-
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_field
-  set Compositional field methods = prescribed field
-  set Types of fields             = density
-end
-
-subsection Initial composition model
-  set Model name = adiabatic density
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Y extent = 100000
-    set X extent = 1000000
-    set X repetitions = 32
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Heating model
-  set List of model names = function
-
-  subsection Function
-    # dT_dt[K/yr] / yr_in_secs * c_P
-    set Function expression = 1e-4 / 31557600 * 1000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators =
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left:function
-  set Tangential velocity boundary indicators = bottom,top
-
-  subsection Function
-    set Function expression = 0.0;0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600
-  end
-end
-
-subsection Material model
-  set Model name = compressibility formulations
-
-  subsection Simple compressible model
-    set Thermal conductivity = 0.0
-    set Reference specific heat = 1000
-    set Reference compressibility     = 0.0
-    set Reference density             = 3300
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics
-
-  subsection Visualization
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 1e7
-    set List of output variables = adiabat, nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm.bak
deleted file mode 100644
index 71b048352cb..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Material model
-  subsection Projected density model
-    set Use adiabatic pressure for density = true
-  end
-end
diff --git a/benchmarks/compressibility_formulations/lateral_pipe_transient/timestep.prm.bak b/benchmarks/compressibility_formulations/lateral_pipe_transient/timestep.prm.bak
deleted file mode 100644
index f18ce58326e..00000000000
--- a/benchmarks/compressibility_formulations/lateral_pipe_transient/timestep.prm.bak
+++ /dev/null
@@ -1 +0,0 @@
-set Maximum time step = 24654375e5
diff --git a/benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc.bak b/benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc.bak
deleted file mode 100644
index 29fce8b2b58..00000000000
--- a/benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc.bak
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
-  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/simulator/assemblers/stokes.h>
-#include <aspect/material_model/simple_compressible.h>
-#include <aspect/simulator_access.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    /**
-     * A material model that is identical to the simple compressible model,
-     * except that the density is tracked in a compositional field of type
-     * 'density' using the prescribed field advection method. It also
-     * allows some modification to the density and thermal expansivity
-     * calculation for the compressibility benchmarks.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class CompressibilityFormulations : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void initialize() override;
-
-        void update() override;
-
-        bool is_compressible () const override;
-
-        void
-        evaluate (const MaterialModelInputs<dim> &in,
-                  MaterialModelOutputs<dim> &out) const override;
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        static void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Pointer to the material model used as the base model
-         */
-        std::shared_ptr<MaterialModel::Interface<dim>> base_model;
-
-        /**
-         * The reference density
-         */
-        double reference_rho;
-
-        /**
-         * The constant thermal expansivity
-         */
-        double thermal_alpha;
-        bool use_exponential_alpha;
-
-        /**
-         * The constant compressibility.
-         */
-        double reference_compressibility;
-
-        /**
-         * Use the adiabatic instead of the full pressure for the
-         * density calculation.
-         */
-        bool use_adiabatic_pressure_for_density;
-    };
-
-
-
-    template <int dim>
-    void
-    CompressibilityFormulations<dim>::initialize()
-    {
-      base_model->initialize();
-    }
-
-
-
-    template <int dim>
-    void
-    CompressibilityFormulations<dim>::update()
-    {
-      base_model->update();
-    }
-
-
-
-    template <int dim>
-    bool
-    CompressibilityFormulations<dim>::
-    is_compressible () const
-    {
-      return this->get_parameters().formulation_mass_conservation != Parameters<dim>::Formulation::MassConservation::incompressible;
-    }
-
-
-
-    template <int dim>
-    void
-    CompressibilityFormulations<dim>::evaluate(const MaterialModelInputs<dim> &in,
-                                               MaterialModelOutputs<dim> &out) const
-    {
-      base_model->evaluate(in,out);
-
-      const unsigned int density_field_index = this->introspection().find_composition_type(Parameters<dim>::CompositionalFieldDescription::density);
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          double pressure_for_density = in.pressure[i];
-
-          // If using the PDA avoid using the real pressure for the density calculation to prevent
-          // pressure waves from forming
-          if (use_adiabatic_pressure_for_density)
-            pressure_for_density = this->get_adiabatic_conditions().pressure(in.position[i]);
-
-          double thermal_expansivity = thermal_alpha;
-          if (use_exponential_alpha)
-            {
-              thermal_expansivity *= std::exp(-1.117979323e-11*pressure_for_density);
-              out.thermal_expansion_coefficients[i] = thermal_expansivity;
-            }
-
-          // Use a thermodynamically consistent thermal expansivity
-          // (if alpha is constant, rho needs to depend exponentially on it, not linearly)
-          out.densities[i] = reference_rho * std::exp(reference_compressibility * (pressure_for_density - this->get_surface_pressure()) -
-                                                      thermal_expansivity * (in.temperature[i] - this->get_adiabatic_surface_temperature()));
-
-          // For the ICA, we have to provide the isentropic rather than isothermal compressibility
-          // for the mass conservation equation.
-          if (this->get_parameters().formulation_mass_conservation ==
-              Parameters<dim>::Formulation::MassConservation::isentropic_compression)
-            {
-              out.compressibilities[i] = reference_compressibility - std::pow(thermal_expansivity, 2) * in.temperature[i]
-                                         / (out.densities[i] * out.specific_heat[i]);
-            }
-        }
-
-      // prescribe the density field to the current value of the density. The actual projection
-      // only happens inside Simulator<dim>::interpolate_material_output_into_compositional_field,
-      // this just sets the correct term the field will be set to.
-      if (PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>())
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          prescribed_field_out->prescribed_field_outputs[i][density_field_index] = out.densities[i];
-    }
-
-
-
-    template <int dim>
-    void
-    CompressibilityFormulations<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::unique_ptr<MaterialModel::AdditionalMaterialOutputs<dim>>
-            (new MaterialModel::PrescribedFieldOutputs<dim> (n_points, this->n_compositional_fields())));
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    CompressibilityFormulations<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Projected density model");
-        {
-          prm.declare_entry ("Use adiabatic pressure for density", "false",
-                             Patterns::Bool(),
-                             "");
-          prm.declare_entry ("Use exponential thermal expansivity", "false",
-                             Patterns::Bool(),
-                             "");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      SimpleCompressible<dim>::declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    CompressibilityFormulations<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Projected density model");
-        {
-          use_adiabatic_pressure_for_density = prm.get_bool("Use adiabatic pressure for density");
-          use_exponential_alpha = prm.get_bool("Use exponential thermal expansivity");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simple compressible model");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-          reference_compressibility  = prm.get_double ("Reference compressibility");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // create the base model and initialize its SimulatorAccess base
-      // class; it will get a chance to read its parameters below after we
-      // leave the current section
-      base_model = create_material_model<dim>("simple compressible");
-      if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
-        sim->initialize_simulator (this->get_simulator());
-      base_model->parse_parameters(prm);
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(CompressibilityFormulations,
-                                   "compressibility formulations",
-                                   "A material model that is identical to the simple compressible model, "
-                                   "except that the density is tracked in a compositional field of type "
-                                   "'density' using the prescribed field advection method. It also "
-                                   "allows some modification to the density and thermal expansivity "
-                                   "calculation for the compressibility benchmarks.")
-  }
-}
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/adiabatic.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/adiabatic.prm.bak
deleted file mode 100644
index e7004ab4649..00000000000
--- a/benchmarks/compressibility_formulations/vertical_pipe/adiabatic.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1600
-  end
-end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/ala.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/ala.prm.bak
deleted file mode 100644
index 2c233e84e40..00000000000
--- a/benchmarks/compressibility_formulations/vertical_pipe/ala.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = reference density profile
-  set Temperature equation = reference density profile
-end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/hydrostatic.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/hydrostatic.prm.bak
deleted file mode 100644
index 503708897df..00000000000
--- a/benchmarks/compressibility_formulations/vertical_pipe/hydrostatic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = hydrostatic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/isentropic.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/isentropic.prm.bak
deleted file mode 100644
index 74b3defb28c..00000000000
--- a/benchmarks/compressibility_formulations/vertical_pipe/isentropic.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Formulation
-  set Mass conservation = isentropic compression
-  set Temperature equation = real density
-end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm.bak
deleted file mode 100644
index 71b048352cb..00000000000
--- a/benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Material model
-  subsection Projected density model
-    set Use adiabatic pressure for density = true
-  end
-end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/sub_adiabatic.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/sub_adiabatic.prm.bak
deleted file mode 100644
index 7665fa17edc..00000000000
--- a/benchmarks/compressibility_formulations/vertical_pipe/sub_adiabatic.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1400
-  end
-end
diff --git a/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm.bak b/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm.bak
deleted file mode 100644
index 04866b04635..00000000000
--- a/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-# This is a benchmark to illustrate the effect of different formulations
-# of compressibility. It starts from a simple downward pipe flow model,
-# in which material enters a vertical pipe with a prescribed velocity.
-# Due to gravity and pressure the material compresses and the velocity
-# changes to conserve mass.
-
-set Additional shared libraries = ../plugins/libcompressibility_formulations.so
-set Dimension = 2
-set End time                               = 2e8
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-12
-set Max nonlinear iterations               = 25
-set Output directory                       = output-vertical_pipe
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Number of points = 1000000
-    set Composition reference profile = function
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = true
-  set Use discontinuous composition discretization = true
-  set Use discontinuous temperature discretization = true
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
-
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_field
-  set Compositional field methods = prescribed field
-  set Types of fields             = density
-end
-
-subsection Initial composition model
-  set Model name = adiabatic density
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10000
-    set Y extent = 1000000
-    set Y repetitions = 8
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-############### Boundary conditions
-# We only fix the temperature at the upper boundary, the other boundaries
-# are insulating.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1600
-  end
-end
-
-# To guarantuee a steady downward flow, we fix the velocity
-# at the bottom, leave the top open, and set it to free slip on the sides.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Function expression = 0;-1e-2
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Material model
-  set Model name = compressibility formulations
-
-  subsection Simple compressible model
-    set Thermal conductivity = 0.0
-  end
-end
-
-# We use a global refinement of 0 to have a single cell in width. More cells
-# allow for instabilities at the open boundary that would influence the
-# accuracy with increasing resolution.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics
-
-  subsection Visualization
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 1e7
-    set List of output variables = nonadiabatic temperature, nonadiabatic pressure, heating, material properties, strain rate
-  end
-end
diff --git a/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc.bak b/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc.bak
deleted file mode 100644
index 51ee940146a..00000000000
--- a/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc.bak
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/geometry_model/box.h>
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/tria_accessor.h>
-#include <deal.II/grid/tria.h>
-#include <cmath>
-#include <vector>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    /**
-     * A class deriving from Box<dim>, which changes the upper boundary
-       with a sinusoidal perturbation of a given order and amplitude.
-       The top surface is initialized with smooth sinusoidal topography.
-       Subsequent refinements at the surface would do linear interpolations
-       between the mesh points, potentially affecting the quality of the
-       sinusoidal perturbation. As such, if this class is used for topographic
-       relaxation benchmarks, it makes most sense to do it without mesh
-       refinement.
-     */
-    template <int dim>
-    class ReboundBox : public Box<dim>
-    {
-      public:
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         * Makes perturbs the top boundary of the box with a function
-         * of the form z' = amplitude * cos(order * x )
-         */
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter
-         * file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Give the depth of a point.
-         */
-        double depth( const Point<dim> &position) const override;
-
-        /**
-         * Give the maximal depth of a point.
-         */
-        double maximal_depth() const override;
-
-      private:
-
-        double order;  //Order of the perturbation
-        double amplitude;  //amplitude of the perturbation
-
-    };
-
-    template <int dim>
-    void
-    ReboundBox<dim>::
-    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
-    {
-
-      //Call the normal Box mesh generator
-      Box<dim>::create_coarse_mesh( coarse_grid );
-
-      //move the vertices
-      std::vector<bool> vertex_touched (coarse_grid.n_vertices(), false);
-
-      typename parallel::distributed::Triangulation<dim>::active_cell_iterator cell;
-      for (cell = coarse_grid.begin_active();  cell != coarse_grid.end();  ++cell)
-        for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell;  ++v)
-          if (vertex_touched[cell->vertex_index(v)] == false)
-            {
-              Point<dim> &vertex = cell->vertex(v);
-              vertex[dim-1] = vertex[dim-1] + std::cos(order*2.0*M_PI*vertex[0]/(this->get_extents()[0]))*
-                              amplitude*vertex[dim-1]/(this->get_extents()[dim-1]);
-              vertex_touched[cell->vertex_index(v)] = true;
-            }
-
-    }
-
-    template <int dim>
-    double
-    ReboundBox<dim>::maximal_depth() const
-    {
-      return Box<dim>::maximal_depth()+amplitude;
-    }
-
-    template <int dim>
-    double
-    ReboundBox<dim>::depth(const Point<dim> &position) const
-    {
-      return maximal_depth()-position(dim-1);
-    }
-
-    template <int dim>
-    void
-    ReboundBox<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      Box<dim>::declare_parameters(prm);
-
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Rebound Box");
-        {
-          prm.declare_entry ("Order", "1",
-                             Patterns::Double (0),
-                             "Order of the perturbation");
-          prm.declare_entry ("Amplitude", "0.1",
-                             Patterns::Double (0),
-                             "Scaled amplitude of the perturbation");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ReboundBox<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      Box<dim>::parse_parameters(prm);
-
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Rebound Box");
-        {
-          order = prm.get_double ("Order");
-          amplitude = prm.get_double ("Amplitude");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    ASPECT_REGISTER_GEOMETRY_MODEL(ReboundBox,
-                                   "rebound box",
-                                   "Geometry model for benchmarking relaxation of topography.")
-  }
-}
diff --git a/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm.bak b/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm.bak
deleted file mode 100644
index 86783abb78a..00000000000
--- a/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm.bak
+++ /dev/null
@@ -1,139 +0,0 @@
-# Can check this benchmark in gnuplot by opening it and running:
-# plot "statistics" using 2:(-$14), "statistics" using 2:(7000.*exp(-$2/14825))
-# This compares relaxation of the topography to an analytical solution
-
-
-set Dimension = 2
-set CFL number                             = 0.01
-set End time                               = 1e5
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-set Additional shared libraries = ./libcrameri_benchmark_1.so
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = bottom:0, top:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = rebound box
-
-  subsection Rebound Box
-    set Order = 1
-    set Amplitude = 7.e3
-  end
-
-  subsection Box
-    set X extent = 28.e5
-    set Y extent = 7.e5
-    set X repetitions = 300
-    set Y repetitions = 75
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  0.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-    set Density differential for compositional field 1 = 0.0
-    set Composition viscosity prefactor = 100.
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.00
-  set Strategy                           = composition
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y>600.e3, 1, 0);
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,topography
-
-  subsection Visualization
-    set List of output variables = viscosity
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-    set Time between graphical output = 1.e4
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/benchmarks/crameri_et_al/case_1/crameri_benchmark_1_gmg.prm.bak b/benchmarks/crameri_et_al/case_1/crameri_benchmark_1_gmg.prm.bak
deleted file mode 100644
index 4ef00bc5874..00000000000
--- a/benchmarks/crameri_et_al/case_1/crameri_benchmark_1_gmg.prm.bak
+++ /dev/null
@@ -1,27 +0,0 @@
-# Same as crameri_benchmark_1.prm, but using GMG.
-
-include $ASPECT_SOURCE_DIR/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm
-
-set Additional shared libraries = $ASPECT_SOURCE_DIR/benchmarks/crameri_et_al/case_1/libcrameri_benchmark_1.so
-set Dimension = 2
-set Output directory = output-crameri-gmg
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Material model
-  set Material averaging =  harmonic average
-end
-
-subsection Postprocess
-  subsection Visualization
-    set Output mesh velocity = true
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
diff --git a/benchmarks/crameri_et_al/case_2/crameri_benchmark_2.prm.bak b/benchmarks/crameri_et_al/case_2/crameri_benchmark_2.prm.bak
deleted file mode 100644
index 1111ebef04b..00000000000
--- a/benchmarks/crameri_et_al/case_2/crameri_benchmark_2.prm.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-set Dimension = 2
-set CFL number                             = 0.1
-set End time                               = 2e7
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = no
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 0.0
-    set Bottom temperature = 0.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 28.e5
-    set Y extent = 7.e5
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  0.0
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature = 0.0
-    set Densities = 3300, 3200, 3300
-    set Specific heats = 1250
-    set Thermal conductivities = 4.7
-    set Thermal expansivities = 4e-5
-    set Viscosities = 1.e21, 1.e20, 1.e23
-    set Viscosity averaging scheme = harmonic
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 4
-  set Initial global refinement          = 6
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.0
-  set Strategy                           = density,composition,boundary
-  set Refinement criteria scaling factors =
-  set Refinement criteria merge operation = plus
-  set Time steps between mesh refinement = 5
-
-  subsection Boundary
-    set Boundary refinement indicators = top
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    # Theta from Kaus et al 2010
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( sqrt( (x-14.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( y > 6.e5, 1, 0)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,topography
-
-  subsection Visualization
-    set List of output variables = viscosity,density
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/benchmarks/crameri_et_al/doc/crameri_benchmark_1.prm.bak b/benchmarks/crameri_et_al/doc/crameri_benchmark_1.prm.bak
deleted file mode 100644
index ad0fa09035b..00000000000
--- a/benchmarks/crameri_et_al/doc/crameri_benchmark_1.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-set CFL number                             = 0.01
-set Additional shared libraries = ./libcrameri_benchmark_1.so
-
-subsection Geometry model
-  set Model name = rebound box
-
-  subsection Rebound Box
-    set Order = 1
-    set Amplitude = 7.e3
-  end
-
-  subsection Box
-    set X extent = 28.e5
-    set Y extent = 7.e5
-    set X repetitions = 300
-    set Y repetitions = 75
-  end
-end
diff --git a/benchmarks/crameri_et_al/doc/crameri_benchmark_2.prm.bak b/benchmarks/crameri_et_al/doc/crameri_benchmark_2.prm.bak
deleted file mode 100644
index 728009ee14c..00000000000
--- a/benchmarks/crameri_et_al/doc/crameri_benchmark_2.prm.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-set CFL number                   = 0.1
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities = 3300, 3200, 3300
-    set Viscosities = 1.e21, 1.e20, 1.e23
-    set Viscosity averaging scheme = harmonic
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 4
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.0
-  set Strategy                           = density,composition
-  set Refinement criteria merge operation = plus
-  set Time steps between mesh refinement = 5
-end
diff --git a/benchmarks/davies_et_al/case-1.1.prm.bak b/benchmarks/davies_et_al/case-1.1.prm.bak
deleted file mode 100644
index 7426df13493..00000000000
--- a/benchmarks/davies_et_al/case-1.1.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-############### Global parameters
-
-set CFL number                             = 10
-set End time                               = 2
-set Output directory                       = output
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1.22
-    set Opening angle = 360
-    set Outer radius  = 2.22
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top, bottom
-end
-
-# Ra is determined by g*alpha
-# Ra = 10^4
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude =  1e10
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1.
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-6
-    set Viscosity                     = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-############### Parameters describing the temperature field
-# Angular mode is set to 4 in order to match the number of
-# convective cells reported by Davies et al.
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-
-  subsection Spherical hexagonal perturbation
-    set Angular mode          = 4
-    set Rotation offset       = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.11
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 1
-  set Coarsening fraction                = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics,temperature statistics,heat flux statistics, depth average, velocity boundary statistics, spherical velocity statistics
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0.025
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/benchmarks/davies_et_al/case-2.1.prm.bak b/benchmarks/davies_et_al/case-2.1.prm.bak
deleted file mode 100644
index 7bd853a1769..00000000000
--- a/benchmarks/davies_et_al/case-2.1.prm.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-############### Global parameters
-
-set CFL number                             = 10
-set End time                               = 2
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Checkpointing
-  set Steps between checkpoint = 15
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-end
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1.22
-    set Opening angle = 360
-    set Outer radius  = 2.22
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net rotation
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude =  1e10
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1.
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-6
-    set Viscosity                     = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-############### Parameters describing the temperature field
-# Angular mode is set to 4 in order to match the number of
-# convective cells reported by Davies et al.
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-
-  subsection Spherical hexagonal perturbation
-    set Angular mode          = 4
-    set Rotation offset       = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.11
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 1
-  set Coarsening fraction                = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics,temperature statistics,heat flux statistics, depth average, velocity boundary statistics, spherical velocity statistics
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0.025
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/benchmarks/davies_et_al/case-2.2.prm.bak b/benchmarks/davies_et_al/case-2.2.prm.bak
deleted file mode 100644
index 38edd8d3d18..00000000000
--- a/benchmarks/davies_et_al/case-2.2.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-############### Global parameters
-# Case 2.2 begins with the final steady state solution of Case 2.1
-# Resume computation must be set to true, and Output directory must
-# point to the folder that contains the results of Case 2.1.
-
-set CFL number                             = 10
-set End time                               = 3
-set Output directory                       = output
-set Resume computation                     = true
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Checkpointing
-  set Steps between checkpoint = 15
-end
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1.22
-    set Opening angle = 360
-    set Outer radius  = 2.22
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net rotation
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude =  1e11
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1.
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-6
-    set Viscosity                     = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-############### Parameters describing the temperature field
-# Angular mode is set to 4 in order to match the number of
-# convective cells reported by Davies et al.
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-
-  subsection Spherical hexagonal perturbation
-    set Angular mode          = 4
-    set Rotation offset       = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.11
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 1
-  set Coarsening fraction                = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics,temperature statistics,heat flux statistics, depth average, velocity boundary statistics, spherical velocity statistics
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0.025
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/benchmarks/davies_et_al/case-2.3-plugin/VoT.cc.bak b/benchmarks/davies_et_al/case-2.3-plugin/VoT.cc.bak
deleted file mode 100644
index e3f82ec394e..00000000000
--- a/benchmarks/davies_et_al/case-2.3-plugin/VoT.cc.bak
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/parameter_handler.h>
-
-#include <cmath>
-
-
-using namespace dealii;
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    /**
-     * A material model similar to the "Simpler" model, but with a temperature
-     * dependent viscosity (a "viscosity as a function of temperature", or VoT).
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class VoT : public Interface<dim>
-    {
-      public:
-
-        bool is_compressible () const override;
-
-        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                      typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        double reference_rho;
-        double reference_T;
-        double eta;
-        double thermal_alpha;
-        double reference_specific_heat;
-        double k_value;
-    };
-
-
-    template <int dim>
-    bool
-    VoT<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-
-    template <int dim>
-    void
-    VoT<dim>::
-    evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-             typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          out.viscosities[i] = eta*std::pow(1000,(-in.temperature[i]));
-
-          out.densities[i] = reference_rho * (1.0 - thermal_alpha * (in.temperature[i] - reference_T));
-          out.thermal_expansion_coefficients[i] = thermal_alpha;
-          out.specific_heat[i] = reference_specific_heat;
-          out.thermal_conductivities[i] = k_value;
-          out.compressibilities[i] = 0.0;
-          out.entropy_derivative_pressure[i] = 0.0;
-          out.entropy_derivative_temperature[i] = 0.0;
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-
-    template <int dim>
-    void
-    VoT<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("VoT model");
-        {
-          prm.declare_entry ("Reference density", "3300.",
-                             Patterns::Double (0.),
-                             "Reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. The reference temperature is used "
-                             "in the density formula. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Viscosity", "5e24",
-                             Patterns::Double (0.),
-                             "The value of the viscosity $\\eta$. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250.",
-                             Patterns::Double (0.),
-                             "The value of the specific heat $cp$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\beta$. "
-                             "Units: \\si{\\per\\kelvin}.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    VoT<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("VoT model");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          reference_T                = prm.get_double ("Reference temperature");
-          eta                        = prm.get_double ("Viscosity");
-          k_value                    = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature;
-      this->model_dependence.density = NonlinearDependence::temperature;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(VoT,
-                                   "VoT",
-                                   "A material model that has constant values "
-                                   "except for density, which depends linearly on temperature: "
-                                   "\\begin{align}"
-                                   "  \\rho(p,T) &= \\left(1-\\alpha (T-T_0)\\right)\\rho_0."
-                                   "\\end{align}"
-                                   "\n\n"
-                                   "\\note{This material model fills the role the ``simple'' material "
-                                   "model was originally intended to fill, before the latter acquired "
-                                   "all sorts of complicated temperature and compositional dependencies.}")
-  }
-}
diff --git a/benchmarks/davies_et_al/case-2.3.prm.bak b/benchmarks/davies_et_al/case-2.3.prm.bak
deleted file mode 100644
index 3af059bae65..00000000000
--- a/benchmarks/davies_et_al/case-2.3.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-set Additional shared libraries            = ./case-2.3-plugin/libVoT.so
-
-############### Global parameters
-# Case 2.3 begins with the final steady state solution of Case 2.1
-# Resume computation must be set to true, and Output directory must
-# point to the folder that contains the results of Case 2.1.
-
-set CFL number                             = 10
-set End time                               = 3
-set Output directory                       = output
-set Resume computation                     = true
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Checkpointing
-  set Steps between checkpoint = 15
-end
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1.22
-    set Opening angle = 360
-    set Outer radius  = 2.22
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net rotation
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude =  1e8
-  end
-end
-
-subsection Material model
-  set Model name = VoT
-
-  subsection VoT model
-    set Reference density             = 1
-    set Reference specific heat       = 1.
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-############### Parameters describing the temperature field
-# Angular mode is set to 4 in order to match the number of
-# convective cells reported by Davies et al.
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-
-  subsection Spherical hexagonal perturbation
-    set Angular mode          = 4
-    set Rotation offset       = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.11
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 1
-  set Coarsening fraction                = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics,temperature statistics,heat flux statistics, depth average, velocity boundary statistics, spherical velocity statistics
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0.25
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/benchmarks/davies_et_al/doc/case-1.1.prm.bak b/benchmarks/davies_et_al/doc/case-1.1.prm.bak
deleted file mode 100644
index c714e462cce..00000000000
--- a/benchmarks/davies_et_al/doc/case-1.1.prm.bak
+++ /dev/null
@@ -1,51 +0,0 @@
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1.22
-    set Opening angle = 360
-    set Outer radius  = 2.22
-  end
-end
-
-# [...]
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1.
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-6
-    set Viscosity                     = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Angular mode is set to 4 in order to match the number of
-# convective cells reported by Davies et al.
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-
-  subsection Spherical hexagonal perturbation
-    set Angular mode          = 4
-    set Rotation offset       = 0
-  end
-end
-
-############### Prescribe the Rayleigh number as g*alpha
-# Here, Ra = 10^4 and alpha was chosen as 10^-6 above.
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude =  1e10
-  end
-end
-
-# [...]
diff --git a/benchmarks/davies_et_al/doc/case-2.1.prm.bak b/benchmarks/davies_et_al/doc/case-2.1.prm.bak
deleted file mode 100644
index 9e6273a2e01..00000000000
--- a/benchmarks/davies_et_al/doc/case-2.1.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-subsection Nullspace removal
-  set Remove nullspace                        = net rotation
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-end
diff --git a/benchmarks/davies_et_al/doc/case-2.2.prm.bak b/benchmarks/davies_et_al/doc/case-2.2.prm.bak
deleted file mode 100644
index 98a936fd85e..00000000000
--- a/benchmarks/davies_et_al/doc/case-2.2.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-############### Global parameters
-# Case 2.2 begins with the final steady state solution of Case 2.1
-# "Resume computation" must be set to true, and "Output directory" must
-# point to the folder that contains the results of Case 2.1.
-
-set CFL number                             = 10
-set End time                               = 3
-set Output directory                       = output
-set Resume computation                     = true
diff --git a/benchmarks/davies_et_al/doc/case-2.3.prm.bak b/benchmarks/davies_et_al/doc/case-2.3.prm.bak
deleted file mode 100644
index e50b233ad69..00000000000
--- a/benchmarks/davies_et_al/doc/case-2.3.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-set Additional shared libraries            = ./case-2.3-plugin/libVoT.so
-
-subsection Material model
-  set Model name = VoT
-
-  subsection VoT model
-    set Reference density             = 1
-    set Reference specific heat       = 1.
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-5
-    set Viscosity                     = 1
-  end
-end
diff --git a/benchmarks/diffusion_of_hill/1_sine_zero_flux.prm.bak b/benchmarks/diffusion_of_hill/1_sine_zero_flux.prm.bak
deleted file mode 100644
index e674c494033..00000000000
--- a/benchmarks/diffusion_of_hill/1_sine_zero_flux.prm.bak
+++ /dev/null
@@ -1,125 +0,0 @@
-set Additional shared libraries            = libanalytical_topography.so
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.1
-set Maximum time step                      = 0.0005
-set Output directory                       = output-1_sine_zero_flux/
-set Nonlinear solver scheme = no Advection, no Stokes
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# 1x1 box with an initial hill topography
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function constants = A=0.075, L=1.
-      set Function expression = \
-                                A * sin(x*pi)
-    end
-  end
-end
-
-# Temperature effects are ignored
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = initial temperature
-end
-
-# Free slip on all boundaries
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The mesh will be deformed according to the displacement
-# of the surface nodes due to diffusion of the topography.
-# The mesh is allowed to move vertical along the left and
-# right boundary.
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: diffusion
-  set Additional tangential mesh velocity boundary indicators = left, right
-
-  subsection Diffusion
-    # The diffusivity
-    set Hillslope transport coefficient = 0.25
-  end
-end
-
-# Vertical gravity
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-# One material with unity properties
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 6
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# We output the computed topography and the analytical topography
-# value to file.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, analytical topography
-
-  subsection Topography
-    set Output to file = true
-    set Analytical solution of example = 1
-    set Diffusivity = 0.25
-    set Initial sinusoidal topography amplitude = 0.075
-  end
-
-  subsection Visualization
-    set Time between graphical output = 0.025
-    set Output mesh velocity = true
-    set Interpolate output = false
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                         = 1e-7
-  end
-end
diff --git a/benchmarks/diffusion_of_hill/2_sine_constant_h.prm.bak b/benchmarks/diffusion_of_hill/2_sine_constant_h.prm.bak
deleted file mode 100644
index 537cefb97df..00000000000
--- a/benchmarks/diffusion_of_hill/2_sine_constant_h.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-set Additional shared libraries            = libanalytical_topography.so
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-
-# You will want to run the model for longer to see
-# significant changes in model height
-set End time                               = 3.15576e9 # 100 yr
-set Maximum time step                      = 3.15576e7 # 1 yr
-set Output directory                       = output-2_sine_constant_h
-set Nonlinear solver scheme = no Advection, no Stokes
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# 1x1 box with or without an initial hill topography
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10000
-    set Y extent = 10000
-  end
-
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function constants = A=100, L=10000.
-      set Function expression = \
-                                A * sin(x*pi/L)
-    end
-  end
-end
-
-# Temperature effects are ignored
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = initial temperature
-end
-
-# Free slip on the top and bottom boundaries,
-# no slip on the left and right boundaries.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-  set Zero velocity boundary indicators = left, right
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top : diffusion
-
-  subsection Diffusion
-    # The diffusivity
-    set Hillslope transport coefficient = 0.0001
-  end
-end
-
-# Vertical gravity
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# One material
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 2.5
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e20
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 6
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# We output the computed topography and the analytical topography
-# value to file.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, analytical topography
-
-  subsection Topography
-    set Output to file = true
-    set Analytical solution of example = 2
-    set Diffusivity = 0.0001
-    set Initial sinusoidal topography amplitude = 100
-  end
-
-  subsection Visualization
-    set Time between graphical output = 3.15576e8
-    set Output mesh velocity = true
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                         = 1e-7
-  end
-end
diff --git a/benchmarks/diffusion_of_hill/analytical_topography.cc.bak b/benchmarks/diffusion_of_hill/analytical_topography.cc.bak
deleted file mode 100644
index aa4b00cdde1..00000000000
--- a/benchmarks/diffusion_of_hill/analytical_topography.cc.bak
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "analytical_topography.h"
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <cmath>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    AnalyticalTopography<dim>::execute (TableHandler &statistics)
-    {
-      // Only allow use of the plugin with the box geometry model
-      AssertThrow(Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
-                  Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
-                  ExcMessage("Topography postprocessor is only implemented for the box geometry model. ") );
-
-      const types::boundary_id relevant_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id ("top");
-
-      // Get a quadrature rule that exists only on the corners
-      const QTrapezoid<dim-1> face_corners;
-
-      FEFaceValues<dim> face_vals (this->get_mapping(), this->get_fe(), face_corners, update_quadrature_points);
-
-      // have a stream into which we write the data. the text stream is then
-      // later sent to processor 0
-      std::ostringstream output_stats;
-      std::ostringstream output_file;
-
-      // on processor 0, write the file header
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          output_file << "# "
-                      << ((dim==2)? "x y" : "x y z")
-                      << " topography" << ((analytical_solution_example != 0)? " analytical topography" : "") << std::endl;
-        }
-
-      // Choose stupidly large values for initialization
-      double local_max_height = -std::numeric_limits<double>::max();
-      double local_min_height = std::numeric_limits<double>::max();
-
-      // Set up some variables for the analytical solution of the
-      // topography
-      const unsigned int n_max = 5000;
-      const double time = this->get_time();
-
-      // loop over all of the surface cells and save the elevation to stored_value
-      for (const auto &cell : this->get_triangulation().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          for (const unsigned int face_no : cell->face_indices())
-            if (cell->face(face_no)->at_boundary())
-              {
-                if ( cell->face(face_no)->boundary_id() != relevant_boundary)
-                  continue;
-
-                face_vals.reinit(cell, face_no);
-
-                for (unsigned int corner = 0; corner < face_corners.size(); ++corner)
-                  {
-                    const Point<dim> vertex = face_vals.quadrature_point(corner);
-                    const double elevation = this->get_geometry_model().height_above_reference_surface(vertex);
-
-                    if (write_to_file)
-                      {
-                        switch (analytical_solution_example)
-                          {
-                            // If there is no analytical solution corresponding to the
-                            // model setup, just output the topography
-                            case 0:
-                            {
-                              output_file << vertex << ' '<< elevation << std::endl;
-                              break;
-                            }
-                            // If the setup corresponds to anaytical solution 1,
-                            // output the topography and the first solution
-                            case 1:
-                            {
-                              double topo = 0;
-
-                              // initial topography
-                              if (time <= 0.)
-                                topo = amplitude * std::sin(numbers::PI*vertex[0]/domain_width);
-                              else
-                                {
-                                  // compute analytical solution
-                                  double sum = 0.;
-                                  for (unsigned int n=1; n<=n_max; ++n)
-                                    {
-                                      sum += std::cos(2.*n*numbers::PI*vertex[0]/domain_width)
-                                             * std::exp(-kappa*4.*n*n*numbers::PI*numbers::PI*time/(domain_width*domain_width))
-                                             / ((4.*n*n)-1.)
-                                             * (-4.*amplitude/numbers::PI);
-                                    }
-                                  // a0=4A/pi --> a0/2=2A/pi
-                                  topo = 2.*amplitude/numbers::PI + sum;
-                                }
-                              // write out predicted and analytical topography
-                              output_file << vertex << ' ' << elevation << ' ' << topo << std::endl;
-                              break;
-                            }
-                            // If the setup corresponds to anaytical solution 2,
-                            // output the topography and the second solution
-                            case 2:
-                            {
-                              const double topo = amplitude * std::sin(vertex[0]*numbers::PI/domain_width)
-                                                  * std::exp(-kappa*numbers::PI*numbers::PI*time/(domain_width*domain_width));
-                              // write out predicted and analytical topography
-                              output_file << vertex << ' ' << elevation << ' ' << topo << std::endl;
-                              break;
-                            }
-                            default:
-                              Assert(false, ExcInternalError());
-                          }
-
-                        if (elevation > local_max_height)
-                          local_max_height = elevation;
-                        if (elevation < local_min_height)
-                          local_min_height = elevation;
-                      }
-                  }
-              }
-
-      // Calculate min/max topography across all processes
-      const double max_topography = Utilities::MPI::max(local_max_height, this->get_mpi_communicator());
-      const double min_topography = Utilities::MPI::min(local_min_height, this->get_mpi_communicator());
-
-      // Calculate min/max analytical topography
-      double max_analytical_topography = 0., min_analytical_topography = 0.;
-      switch (analytical_solution_example)
-        {
-          case 0:
-          {
-            // In this case, there is no analytical solution,
-            // so set the min/max values to something clearly
-            // nonsensical.
-            min_analytical_topography = std::numeric_limits<double>::quiet_NaN();
-            max_analytical_topography = std::numeric_limits<double>::quiet_NaN();
-            break;
-          }
-          case 1:
-          {
-            if (time<=0)
-              max_analytical_topography = amplitude * std::sin(0.5*numbers::PI);
-            else
-              {
-                double sum_min = 0., sum_max = 0.;
-                for (unsigned int n=1; n<=n_max; ++n)
-                  {
-                    sum_min += std::exp(-kappa*4.*n*n*numbers::PI*numbers::PI*time/(domain_width*domain_width))
-                               / ((4.*n*n)-1.) * -4.*amplitude/numbers::PI;
-                    sum_max += std::cos(n*numbers::PI)
-                               * std::exp(-kappa*4.*n*n*numbers::PI*numbers::PI*time/(domain_width*domain_width))
-                               / ((4.*n*n)-1.) * -4.*amplitude/numbers::PI;
-                  }
-                // a0=4A/pi --> a0/2=2A/pi
-                min_analytical_topography = 2.*amplitude/numbers::PI + sum_min;
-                max_analytical_topography = 2.*amplitude/numbers::PI + sum_max;
-              }
-            break;
-          }
-          case 2:
-          {
-            max_analytical_topography = amplitude * std::sin(0.5*numbers::PI)
-                                        * std::exp(-kappa*numbers::PI*numbers::PI*time/(domain_width*domain_width));
-            min_analytical_topography = 0.;
-            break;
-          }
-          default:
-            Assert(false, ExcInternalError());
-        }
-
-      // Write results to statistics file
-      statistics.add_value ("Minimum topography (m)",
-                            min_topography);
-      statistics.add_value ("Maximum topography (m)",
-                            max_topography);
-      statistics.add_value ("Minimum analytical topography (m)",
-                            min_analytical_topography);
-      statistics.add_value ("Maximum analytical topography (m)",
-                            max_analytical_topography);
-      const char *columns[] = { "Minimum topography (m)",
-                                "Maximum topography (m)",
-                                "Minimum analytical topography (m)",
-                                "Maximum analytical topography (m)"
-                              };
-      for (unsigned int i=0; i<sizeof(columns)/sizeof(columns[0]); ++i)
-        {
-          statistics.set_precision (columns[i], 8);
-          statistics.set_scientific (columns[i], true);
-        }
-
-      output_stats.precision(4);
-      output_stats << min_topography << " m, "
-                   << max_topography << " m, "
-                   << min_analytical_topography << " m, "
-                   << max_analytical_topography << " m";
-
-      // Write the solution to file
-
-      // if this is the first time we get here, set the last output time
-      // to the current time - output_interval. this makes sure we
-      // always produce data during the first time step
-      if (std::isnan(last_output_time))
-        {
-          last_output_time = this->get_time() - output_interval;
-        }
-
-      // Just return stats if text output is not required at all or not needed at this time
-      if (!write_to_file || ((this->get_time() < last_output_time + output_interval)
-                             && (this->get_timestep_number() != 0)))
-        return std::pair<std::string, std::string> ("Predicted and analytical topography min/max:",
-                                                    output_stats.str());
-
-      std::string filename = this->get_output_directory() +
-                             "topography." +
-                             Utilities::int_to_string(this->get_timestep_number(), 5);
-      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
-        filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
-
-      Utilities::collect_and_write_file_content(filename, output_file.str(), this->get_mpi_communicator());
-
-      // if output_interval is positive, then update the last supposed output
-      // time
-      if (output_interval > 0)
-        {
-          // We need to find the last time output was supposed to be written.
-          // this is the last_output_time plus the largest positive multiple
-          // of output_intervals that passed since then. We need to handle the
-          // edge case where last_output_time+output_interval==current_time,
-          // we did an output and std::floor sadly rounds to zero. This is done
-          // by forcing std::floor to round 1.0-eps to 1.0.
-          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-          last_output_time = last_output_time + std::floor((this->get_time()-last_output_time)/output_interval*magic) * output_interval/magic;
-        }
-
-      return std::pair<std::string, std::string> ("Predicted and analytical topography min/max:",
-                                                  output_stats.str());
-    }
-
-
-
-    template <int dim>
-    void
-    AnalyticalTopography<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Topography");
-        {
-          prm.declare_entry ("Output to file", "false",
-                             Patterns::Bool(),
-                             "Whether or not to write topography to a text file named named "
-                             "'topography.NNNNN' in the output directory.");
-          prm.declare_entry ("Time between text output", "0.",
-                             Patterns::Double (0),
-                             "The time interval between each generation of "
-                             "text output files. A value of zero indicates "
-                             "that output should be generated in each time step. "
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-          prm.declare_entry ("Analytical solution of example", "1",
-                             Patterns::Integer (0),
-                             "The number of the diffusion example for "
-                             "which we output the analytical solution. "
-                             "For a value of 0, we do not write the "
-                             "analytical solution.");
-          prm.declare_entry ("Diffusivity", "0.5",
-                             Patterns::Double (0),
-                             "The diffusivity in the diffusion equation. "
-                             "Units: \\si{m^2/s}.");
-          prm.declare_entry ("Initial sinusoidal topography amplitude", "0.5",
-                             Patterns::Double (0),
-                             "The maximum amplitude of the initial sinusoidal topography. "
-                             "Units: \\si{m}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AnalyticalTopography<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Topography");
-        {
-          write_to_file        = prm.get_bool ("Output to file");
-          output_interval = prm.get_double ("Time between text output");
-          if (this->convert_output_to_years())
-            {
-              output_interval *= year_in_seconds;
-            }
-          analytical_solution_example = prm.get_integer ("Analytical solution of example");
-          kappa = prm.get_double ("Diffusivity");
-          amplitude = prm.get_double ("Initial sinusoidal topography amplitude");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Box");
-        {
-          domain_width = prm.get_double ("X extent");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(AnalyticalTopography,
-                                  "analytical topography",
-                                  "A postprocessor intended for use with a deforming top surface. After every step "
-                                  "it loops over all the vertices on the top surface and determines the "
-                                  "maximum and minimum topography relative to a reference datum (initial "
-                                  "box height). "
-                                  "If 'Topography.Output to file' is set to true, also outputs topography "
-                                  "into text files named `topography.NNNNN' in the output directory, "
-                                  "where NNNNN is the number of the time step."
-                                  "If 'Analytical solution of example' is set to 1 or 2, the analytical solution of "
-                                  "the topography of a decaying hill is also written to file.\n"
-                                  "The file format then consists of lines with Euclidean coordinates "
-                                  "followed by the corresponding topography value."
-                                  "Topography is printed/written in meters.")
-  }
-}
diff --git a/benchmarks/diffusion_of_hill/analytical_topography.h.bak b/benchmarks/diffusion_of_hill/analytical_topography.h.bak
deleted file mode 100644
index fc5ab18da29..00000000000
--- a/benchmarks/diffusion_of_hill/analytical_topography.h.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_analytical_topography_h
-#define _aspect_postprocess_analytical_topography_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that outputs the surface topography to file.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class AnalyticalTopography : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Output predicted and analytical topography [m] to file.
-         */
-        std::pair<std::string,std::string> execute (TableHandler &statistics) override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        /**
-         * Whether or not to produce text files with topography values
-         */
-        bool write_to_file;
-
-        /**
-         * Interval between the generation of text output. This parameter
-         * is read from the input file and consequently is not part of the
-         * state that needs to be saved and restored.
-         */
-        double output_interval;
-
-        /**
-         * A time (in seconds) at which the last text output was supposed
-         * to be produced. Used to check for the next necessary output time.
-         */
-        double last_output_time;
-
-        /**
-         * The amplitude of the sinusoidal initial topography.
-         */
-        double amplitude;
-
-        /**
-         * The diffusivity used in computing the diffusion of the surface
-         * topography.
-         */
-        double kappa;
-
-        /**
-         * The width (X extent) of the 2D rectangular domain.
-         */
-        double domain_width;
-
-        /**
-         * A switch to vary between different analytical solutions.
-         */
-        unsigned int analytical_solution_example;
-
-    };
-  }
-}
-
-
-#endif
diff --git a/benchmarks/doneahuerta/doneahuerta.cc.bak b/benchmarks/doneahuerta/doneahuerta.cc.bak
deleted file mode 100644
index 156c8926bac..00000000000
--- a/benchmarks/doneahuerta/doneahuerta.cc.bak
+++ /dev/null
@@ -1,362 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  namespace DoneaHuertaBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-
-      Tensor<1,2>
-      DoneaHuerta_velocity (const Point<2> &pos)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const double v_x =  x*x*(1.-x)*(1.-x)*(2.*y-6.*y*y+4.*y*y*y) ;
-        const double v_y = -y*y*(1.-y)*(1.-y)*(2.*x-6.*x*x+4.*x*x*x) ;
-        return Point<2> (v_x,v_y);
-      }
-
-      double
-      DoneaHuerta_pressure (const Point<2> &pos)
-      {
-        const double x = pos[0];
-        return x*(1.-x)-1./6.;
-      }
-
-      template <int dim>
-      class FunctionDoneaHuerta : public Function<dim>
-      {
-        public:
-          FunctionDoneaHuerta ()
-            :
-            Function<dim>(dim+2)
-          {}
-
-          void vector_value (const Point<dim>   &pos,
-                             Vector<double>   &values) const override
-          {
-            Assert (dim == 2, ExcNotImplemented());
-            Assert (values.size() >= 4, ExcInternalError());
-
-            const Point<2> p (pos[0], pos[1]);
-
-            const Tensor<1,2> v = AnalyticSolutions::DoneaHuerta_velocity (p);
-            values[0] = v[0];
-            values[1] = v[1];
-            values[2] = AnalyticSolutions::DoneaHuerta_pressure (p);
-          }
-      };
-    }
-
-
-
-    template <int dim>
-    class DoneaHuertaBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        DoneaHuertaBoundary();
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id ,
-                           const Point<dim> &position) const override;
-    };
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class DoneaHuertaMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              out.viscosities[i] = 1.;
-              out.densities[i] = 1;
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-    };
-
-
-    template <int dim>
-    bool
-    DoneaHuertaMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    DoneaHuertaMaterial<dim>::declare_parameters (ParameterHandler &)
-    {
-    }
-
-
-    template <int dim>
-    void
-    DoneaHuertaMaterial<dim>::parse_parameters (ParameterHandler &)
-    {
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-
-    template <int dim>
-    DoneaHuertaBoundary<dim>::DoneaHuertaBoundary ()
-    {}
-
-
-    template <>
-    Tensor<1,2>
-    DoneaHuertaBoundary<2>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<2> &p) const
-    {
-      return AnalyticSolutions::DoneaHuerta_velocity (p);
-    }
-
-
-    template <>
-    Tensor<1,3>
-    DoneaHuertaBoundary<3>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<3> &) const
-    {
-      Assert (false, ExcNotImplemented());
-      return Tensor<1,3>();
-    }
-
-    /**
-     * Gravity model for the DoneaHuerta benchmark
-    */
-
-    template <int dim>
-    class DoneaHuertaGravity : public aspect::GravityModel::Interface<dim>
-    {
-      public:
-        Tensor<1,dim> gravity_vector (const Point<dim> &pos) const override;
-    };
-
-
-    template <int dim>
-    Tensor<1,dim>
-    DoneaHuertaGravity<dim>::
-    gravity_vector(const Point<dim> &pos) const
-    {
-      const double x=pos[0];
-      const double y=pos[1];
-      Tensor<1,dim> g;
-      g[0]= ( (12.-24.*y)*x*x*x*x + (-24.+48.*y)*x*x*x + (-48.*y+72.*y*y-48.*y*y*y+12.)*x*x
-              + (-2.+24.*y-72.*y*y+48.*y*y*y)*x + 1.-4.*y+12.*y*y-8.*y*y*y );
-
-      g[1]= ( (8.-48.*y+48.*y*y)*x*x*x + (-12.+72.*y-72*y*y)*x*x
-              +  (4.-24.*y+48.*y*y-48.*y*y*y+24.*y*y*y*y)*x - 12.*y*y + 24.*y*y*y -12.*y*y*y*y);
-      return g;
-    }
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the Donea and Huerta FEM book (see manual).
-      */
-    template <int dim>
-    class DoneaHuertaPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    DoneaHuertaPostprocessor<dim>::execute (TableHandler &)
-    {
-      std::unique_ptr<Function<dim>> ref_func =
-        std::make_unique<AnalyticSolutions::FunctionDoneaHuerta<dim>>();
-
-      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                          dim+2);
-      ComponentSelectFunction<dim> comp_p(dim, dim+2);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_u,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_p,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_p);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_ul2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_pl2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-      std::ostringstream os;
-
-      os << std::scientific <<  u_l1
-         << ", " << p_l1
-         << ", " << u_l2
-         << ", " << p_l2;
-
-      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace DoneaHuertaBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(DoneaHuertaMaterial,
-                                   "DoneaHuertaMaterial",
-                                   "A material model that corresponds to the `DoneaHuerta' benchmark. "
-                                   "See the manual for more information.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(DoneaHuertaBoundary,
-                                            "DoneaHuertaBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "`DoneaHuerta' benchmark. See the manual for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(DoneaHuertaPostprocessor,
-                                  "DoneaHuertaPostprocessor",
-                                  "A postprocessor that compares the solution of the `DoneaHuerta' benchmark "
-                                  "with the one computed by ASPECT "
-                                  "and reports the error. See the manual for more information.")
-
-    ASPECT_REGISTER_GRAVITY_MODEL(DoneaHuertaGravity,
-                                  "DoneaHuertaGravity",
-                                  "A gravity model in corresponding to the `DoneaHuerta' benchmark. "
-                                  "See the manual for more information.")
-  }
-}
diff --git a/benchmarks/doneahuerta/doneahuerta.prm.bak b/benchmarks/doneahuerta/doneahuerta.prm.bak
deleted file mode 100644
index 84cf6380f7e..00000000000
--- a/benchmarks/doneahuerta/doneahuerta.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-############### Global parameters
-# This is the manufactured solution of Donea & Huerta,
-# Finite element methods for flow problems,
-# Wiley, 2003. page 306
-
-set Additional shared libraries            = ./libdoneahuerta.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0  : DoneaHuertaBoundary, \
-                                                1  : DoneaHuertaBoundary, \
-                                                2  : DoneaHuertaBoundary, \
-                                                3  : DoneaHuertaBoundary
-end
-
-subsection Material model
-  set Model name = DoneaHuertaMaterial
-end
-
-subsection Gravity model
-  set Model name = DoneaHuertaGravity
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, DoneaHuertaPostprocessor
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, gravity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/benchmarks/entropy_adiabat/entropy_adiabat.prm.bak b/benchmarks/entropy_adiabat/entropy_adiabat.prm.bak
deleted file mode 100644
index 274e78cc5d0..00000000000
--- a/benchmarks/entropy_adiabat/entropy_adiabat.prm.bak
+++ /dev/null
@@ -1,184 +0,0 @@
-# Adiabatic downwelling along a pipe. Initially all material starts on one
-# adiabat (at constant entropy), with material inflow on another adiabat (a
-# different constant entropy). The adiabatic reference profile is computed for
-# this different inflow adiabat so that the difference between adiabatic
-# profile and actual profile in the model is expected to go to 0 with time. The
-# material data contains a discontinuous phase transition (in
-# pressure-temperature space), which would make convergence of this model hard.
-# Accurate results in particular for the latent heat effects would be nearly
-# impossible if not for the new feature in this benchmark, which is to solve
-# the advection-diffusion equation in terms of entropy instead of temperature.
-# In pressure-entropy space there is no jump in entropy across the phase
-# transition, and the equation can be accurately solved (in fact it is trivial
-# for this example as the steady-state solution is at constant entropy
-# everywhere in the model once the warmer inflowing material has replaced the
-# initial material in the model). The resulting temperature for any given
-# pressure-entropy is looked up in the used material data table.
-
-# As a benchmark this model can only test that ASPECT's results are consistent
-# with the results of the thermodynamic modeling package that produced the
-# entropy-pressure tables for material properties (in this case HeFESTo). This
-# test is done by replacing the 'compute entropy profile' adiabatic conditions
-# plugin with the 'ascii data' plugin, which will load a precomputed adiabat
-# from HeFESTo instead of computing an adiabat inside ASPECT. The disadvantage
-# of this approach is of course that it is only possible for those adiabats
-# that have been precomputed (in this case one for 1600 K), while the 'compute
-# entropy profile' plugin can compute adiabats at arbitrary entropy.
-
-set Additional shared libraries            = ./plugins/libentropy_plugins.so
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 2.5e8
-set Output directory                       = output-entropy-adiabat
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600.1243896484375
-
-subsection Formulation
-  set Mass conservation = projected density field
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 13000
-    set Y extent = 1300000
-    set Y repetitions = 200
-  end
-end
-
-subsection Initial temperature model
-  # The actual initial temperature is irrelevant, because it
-  # is recalculated from the entropy during the first timestep.
-  # The value below corresponds to the entropy of 2534 J/kg/K
-  # used as the top boundary condition.
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600.1243896484375
-  end
-end
-
-subsection Adiabatic conditions model
-  # The 'ascii data' option does not need the additional
-  # plugin, but is limited to the available adiabat data files.
-  # 'compute entropy profile' computes arbitrary adiabats
-  # internally, based on the data table.
-  # Use 'ascii data' to compare against HeFESTo adiabat.
-  set Model name = compute entropy profile
-
-  subsection Compute entropy profile
-    # Entropy equivalent to T=1600 K according to the used table
-    set Surface entropy = 2534
-  end
-
-  subsection Ascii data model
-    set Data directory  = $ASPECT_SOURCE_DIR/data/material-model/
-    set Data file name  = entropy-table/opxtable/1600K_adiabat.txt
-  end
-end
-
-# We prescribe temperatures according to the data table.
-# This output is computed in the material model.
-subsection Temperature field
-  set Temperature method = prescribed field with diffusion
-end
-
-# We solve the entropy equation for the compositional field with name
-# 'entropy'. Temperature and density are then computed based on entropy and
-# pressure.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = entropy, density_field
-  set Types of fields = entropy, density
-  set Compositional field methods = field, prescribed field
-end
-
-subsection Boundary temperature model
-  # No temperature boundary conditions,
-  # as the temperature equation is not solved
-  set Fixed temperature boundary indicators = top
-  set List of model names = initial temperature
-end
-
-# We prescribe the entropy of the inflowing material to
-# be different from the initial entropy in the model.
-subsection Boundary composition model
-  set Fixed composition boundary indicators = top
-  set List of model names = function
-
-  subsection Function
-    # Only the first component (entropy) matters, the other equations
-    # are not solved but computed from entropy.
-    set Function expression = 2534; 3300
-  end
-end
-
-# Prescribing downward flow through a vertical pipe with
-# tangential side boundaries.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Function expression = 0; -0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We start at a lower entropy than the one used for the
-# adiabatic profile.
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    # Entropy equivalent to T=1405 K according to table
-    set Function expression = 2360; 0.0
-  end
-end
-
-# We use a data table for orthopyroxene computed using the thermodynamic
-# modeling software HeFESTo.
-subsection Material model
-  set Model name = entropy model
-
-  subsection Entropy model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
-    set Material file name               = material_table.txt
-    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
-    set Thermal conductivity formulation = constant
-    set Thermal conductivity             = 0.1
-  end
-
-  subsection Depth dependent viscosity
-    set Data directory                   = $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/data/
-    set Data file name                   = constant_viscosity.txt
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e7
-    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
-    end
-  end
-end
diff --git a/benchmarks/entropy_adiabat/entropy_combined.prm.bak b/benchmarks/entropy_adiabat/entropy_combined.prm.bak
deleted file mode 100644
index c06bcf6ae60..00000000000
--- a/benchmarks/entropy_adiabat/entropy_combined.prm.bak
+++ /dev/null
@@ -1,42 +0,0 @@
-# Downwelling along a pipe.
-# This is a modification of the entropy adiabat example with added diffusion.
-# According to Schubert, Turcotte and Olson (part 1, p. 194), the added
-# diffusion should only affect the temperature profile above the phase transition.
-# Schubert, Turcotte and Olson also give an analytical solution for the
-# temperature profile. However, since they do not include adiabatic heating, this
-# model does not yield the exact solution from Schubert, Turcotte and Olson.
-# Instead, the temperature is slightly cooler below the phase transition due to
-# the additional heat conduction along the adiabat.
-
-include ./entropy_adiabat.prm
-
-set Additional shared libraries            = ./plugins/libentropy_plugins.so
-set Dimension                              = 2
-set End time                               = 2.5e8
-set Output directory                       = output-entropy-combined
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600.1243896484375
-
-# We start at the same entropy as the one used for the
-# adiabatic profile.
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    # Entropy equivalent to T=1600 K according to table
-    set Function expression = 2534; 0.0
-  end
-end
-
-# We increase the thermal conductivity compared to the
-# entropy adiabat example. We choose a very large value
-# here because the thermal diffusion effects only become
-# visible for large conductivities (or slow flow).
-subsection Material model
-  set Model name = entropy model
-
-  subsection Entropy model
-    set Thermal conductivity formulation = constant
-    set Thermal conductivity             = 50
-  end
-end
diff --git a/benchmarks/entropy_adiabat/entropy_conduction.prm.bak b/benchmarks/entropy_adiabat/entropy_conduction.prm.bak
deleted file mode 100644
index 3a1c77c6b4b..00000000000
--- a/benchmarks/entropy_adiabat/entropy_conduction.prm.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-# Conduction along an adiabat. Initially all material starts on one adiabat
-# (at constant entropy), with no material inflow. The adiabatic reference
-# profile is computed based on this initial entropy, using a look-up table
-# for orthopyroxene, which has one narrow phase transition in the center of
-# the model. The temperature is fixed at the top, and the bottom is set as
-# an insulating boundary. Consequently, the model should cool down over
-# time as heat flows out conductively through the top boundary, eventually
-# reaching a constant temperature.
-
-
-set Additional shared libraries            = ./plugins/libentropy_plugins.so
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 2.5e11
-set Maximum time step                      = 1e7
-set Output directory                       = output-entropy-conduction
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600.1243896484375
-
-subsection Formulation
-  set Mass conservation = projected density field
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 13000
-    set Y extent = 1300000
-    set Y repetitions = 200
-  end
-end
-
-subsection Initial temperature model
-  # We convert the initial temperature from the
-  # initial entropy.
-  # The value below corresponds to the entropy of 2534 J/kg/K
-  # used as the top boundary condition and the initial condition.
-  set Model name = prescribed temperature
-end
-
-subsection Adiabatic conditions model
-  # 'compute entropy profile' computes arbitrary adiabats
-  # internally, based on the data table.
-  set Model name = compute entropy profile
-
-  subsection Compute entropy profile
-    # Entropy equivalent to T=1600 K according to the used table
-    set Surface entropy = 2534
-  end
-end
-
-# We prescribe temperatures according to the data table.
-# This output is computed in the material model.
-subsection Temperature field
-  set Temperature method = prescribed field with diffusion
-end
-
-# We solve the entropy equation for the compositional field with name
-# 'entropy'. Temperature and density are then computed based on entropy and
-# pressure.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = entropy, density_field
-  set Types of fields = entropy, density
-  set Compositional field methods = field, prescribed field
-end
-
-subsection Boundary temperature model
-  # No temperature boundary conditions,
-  # as the temperature equation is not solved
-  set Fixed temperature boundary indicators = top
-  set List of model names = initial temperature
-end
-
-# We prescribe the entropy at the top.
-subsection Boundary composition model
-  set Fixed composition boundary indicators = top
-  set List of model names = function
-
-  subsection Function
-    # Only the first component (entropy) matters, the other equations
-    # are not solved but computed from entropy.
-    set Function expression = 2534; 3300
-  end
-end
-
-# Prescribing closed boundaries.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, left, right, bottom
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We start at the same entropy as the one used for the
-# adiabatic profile.
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    # Entropy equivalent to T=1600 K according to table
-    set Function expression = 2534; 0.0
-  end
-end
-
-# We use a data table for orthopyroxene computed using the thermodynamic
-# modeling software HeFESTo.
-# We use a very large viscosity to make sure the material does not move.
-subsection Material model
-  set Model name = entropy model
-
-  subsection Entropy model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
-    set Material file name               = material_table.txt
-    set Maximum viscosity                = 1e30
-    set Minimum viscosity                = 1e30
-    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
-    set Thermal conductivity formulation = constant
-    set Thermal conductivity             = 4.7
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e8
-    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
-    end
-  end
-end
diff --git a/benchmarks/entropy_adiabat/entropy_half_space.prm.bak b/benchmarks/entropy_adiabat/entropy_half_space.prm.bak
deleted file mode 100644
index ac06b3691c9..00000000000
--- a/benchmarks/entropy_adiabat/entropy_half_space.prm.bak
+++ /dev/null
@@ -1,155 +0,0 @@
-# Conduction in a boundary layer, without adiabatic effects. Initially all
-# material starts at a constant temperature. Adiabatic effects are switched
-# off by setting the gravity to zero. The temperature is fixed at the top,
-# and the bottom is set as an insulating boundary. Consequently, the model
-# should cool down over time according to the half-space cooling model.
-# The temperature at the end of the model run can be compared to the
-# solution of the half-space cooling model given in the compositional
-# field "half_space".
-# Note that density and specific heat are temperature- and, consequently,
-# time-dependent, so the solution might slightly deviate from this
-# reference profile.
-
-set Additional shared libraries            = ./plugins/libentropy_plugins.so
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e9
-set Maximum time step                      = 1e6
-set Output directory                       = output-entropy-half-space
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 50
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600.1243896484375
-
-subsection Formulation
-  set Mass conservation = projected density field
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 13000
-    set Y extent = 1300000
-    set Y repetitions = 200
-  end
-end
-
-subsection Initial temperature model
-  # The actual initial temperature is irrelevant, because it
-  # is recalculated from the entropy during the first timestep.
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1500
-  end
-end
-
-subsection Adiabatic conditions model
-  # 'compute entropy profile' computes arbitrary adiabats
-  # internally, based on the data table.
-  set Model name = compute entropy profile
-
-  subsection Compute entropy profile
-    # Entropy equivalent to T=1600 K according to the used table
-    set Surface entropy = 2534
-  end
-end
-
-# We prescribe temperatures according to the data table.
-# This output is computed in the material model.
-subsection Temperature field
-  set Temperature method = prescribed field with diffusion
-end
-
-# We solve the entropy equation for the compositional field with name
-# 'entropy'. Temperature and density are then computed based on entropy and
-# pressure.
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = entropy, density_field, half_space
-  set Types of fields = entropy, density, generic
-  set Compositional field methods = field, prescribed field, static
-end
-
-subsection Boundary temperature model
-  # No temperature boundary conditions,
-  # as the temperature equation is not solved
-  set Fixed temperature boundary indicators = top
-  set List of model names = initial temperature
-end
-
-# We prescribe the entropy at the top.
-subsection Boundary composition model
-  set Fixed composition boundary indicators = top
-  set List of model names = function
-
-  subsection Function
-    # Only the first component (entropy) matters, the other equations
-    # are not solved but computed from entropy.
-    set Function expression = 2450; 3300; 1500
-  end
-end
-
-# Prescribing closed boundaries.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, left, right, bottom
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-# We start at the same entropy as the one used for the
-# adiabatic profile. The last compositional field gives
-# the analytical solution for the temperature at the
-# end of the model run based on the half-space cooling
-# model.
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    # Entropy equivalent to T=1600 K according to table
-    set Function expression = 2534; 0.0; 1600 - 100 * erfc((1300000 - y)/(2 * sqrt(4.7/(1342*3380)*3600*24*365.25*1e9)))
-  end
-end
-
-# We use a data table for orthopyroxene computed using the thermodynamic
-# modeling software HeFESTo.
-# We use a very large viscosity to make sure the material does not move.
-subsection Material model
-  set Model name = entropy model
-
-  subsection Entropy model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
-    set Material file name               = material_table.txt
-    set Maximum viscosity                = 1e30
-    set Minimum viscosity                = 1e30
-    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
-    set Thermal conductivity formulation = constant
-    set Thermal conductivity             = 4.7
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e8
-    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
-    end
-  end
-end
diff --git a/benchmarks/entropy_adiabat/plugins/entropy_advection.cc.bak b/benchmarks/entropy_adiabat/plugins/entropy_advection.cc.bak
deleted file mode 100644
index 61c005ec1f5..00000000000
--- a/benchmarks/entropy_adiabat/plugins/entropy_advection.cc.bak
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "entropy_advection.h"
-#include <aspect/material_model/entropy_model.h>
-
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-#include <aspect/plugins.h>
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    template <int dim>
-    void
-    EntropyAdvectionSystem<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                                          internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-      const std::vector<CompositionalFieldDescription> &composition_descriptions = this->introspection().get_composition_descriptions();
-      if (!advection_field.is_temperature()
-          && composition_descriptions[advection_field.compositional_variable].type != CompositionalFieldDescription::entropy)
-        return;
-
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
-
-      const bool   use_bdf2_scheme = (this->get_timestep_number() > 1);
-      const double time_step = this->get_timestep();
-      const double old_time_step = this->get_old_timestep();
-
-      const double bdf2_factor = (use_bdf2_scheme)? ((2*time_step + old_time_step) /
-                                                     (time_step + old_time_step)) : 1.0;
-
-      const unsigned int solution_component = advection_field.component_index(introspection);
-      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
-
-      scratch.finite_element_values[introspection.extractors.temperature].get_function_values (this->get_old_solution(),
-          scratch.old_temperature_values);
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          // precompute the values of shape functions and their gradients.
-          // We only need to look up values of shape functions if they
-          // belong to 'our' component. They are zero otherwise anyway.
-          // Note that we later only look at the values that we do set here.
-          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
-            {
-              if (fe.system_to_component_index(i).first == solution_component)
-                {
-                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
-                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
-                  ++i_advection;
-                }
-              ++i;
-            }
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          // solve the diffusion equation for the temperature
-          if (advection_field.is_temperature())
-            {
-              const double density_c_P = scratch.material_model_outputs.densities[q] *
-                                         scratch.material_model_outputs.specific_heat[q];
-
-              const double field_term_for_rhs = scratch.old_field_values[q] * density_c_P;
-
-              // do the actual assembly. note that we only need to loop over the advection
-              // shape functions because these are the only contributions we compute here
-              for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-                {
-                  data.local_rhs(i)
-                  += field_term_for_rhs * scratch.phi_field[i] * JxW;
-
-                  for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                    {
-                      data.local_matrix(i,j)
-                      += (
-                           (time_step * scratch.material_model_outputs.thermal_conductivities[q]
-                            * (scratch.grad_phi_field[i] * scratch.grad_phi_field[j]))
-                           + (scratch.phi_field[i] * scratch.phi_field[j]) * density_c_P
-                         )
-                         * JxW;
-                    }
-                }
-            }
-          else
-            // solve the entropy equation
-            {
-              const double rho_T              =
-                scratch.material_model_outputs.densities[q] *
-                scratch.material_model_inputs.temperature[q];
-
-              Assert (rho_T >= 0,
-                      ExcMessage ("The product of density and temperature needs to be a "
-                                  "non-negative quantity."));
-
-              const double gamma =
-                scratch.heating_model_outputs.heating_source_terms[q];
-
-              const double field_term_for_rhs
-                = (use_bdf2_scheme ?
-                   (scratch.old_field_values[q] *
-                    (1 + time_step/old_time_step)
-                    -
-                    scratch.old_old_field_values[q] *
-                    (time_step * time_step) /
-                    (old_time_step * (time_step + old_time_step)))
-                   :
-                   scratch.old_field_values[q])
-                  *
-                  (rho_T);
-
-              Tensor<1,dim> current_u = scratch.current_velocity_values[q];
-              // Subtract off the mesh velocity for ALE corrections if necessary
-              if (this->get_parameters().mesh_deformation_enabled)
-                current_u -= scratch.mesh_velocity_values[q];
-
-              // We compute the amount of diffusion based on the solution of the temperature equation.
-              const double diffusion_term = (scratch.material_model_inputs.temperature[q] - scratch.old_temperature_values[q])
-                                            * scratch.material_model_outputs.densities[q] * scratch.material_model_outputs.specific_heat[q];
-
-              // do the actual assembly. note that we only need to loop over the advection
-              // shape functions because these are the only contributions we compute here
-              for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-                {
-                  data.local_rhs(i)
-                  += (field_term_for_rhs * scratch.phi_field[i]
-                      + diffusion_term * scratch.phi_field[i]
-                      + time_step * scratch.phi_field[i] * gamma)
-                     *
-                     JxW;
-
-                  for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                    {
-                      data.local_matrix(i,j)
-                      += (
-                           (time_step * scratch.artificial_viscosity
-                            * scratch.grad_phi_field[i] * scratch.grad_phi_field[j])
-                           + ((time_step * (scratch.phi_field[i] * (current_u * scratch.grad_phi_field[j])))
-                              + (bdf2_factor * scratch.phi_field[i] * scratch.phi_field[j])) *
-                           (rho_T)
-                         )
-                         * JxW;
-                    }
-                }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    EntropyAdvectionSystem<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      std::vector<double> residuals(n_q_points,0.0);
-
-      const std::vector<CompositionalFieldDescription> &composition_descriptions = this->introspection().get_composition_descriptions();
-      if (!advection_field.is_temperature()
-          && composition_descriptions[advection_field.compositional_variable].type != CompositionalFieldDescription::entropy)
-        return residuals;
-
-      this->get_heating_model_manager().evaluate(scratch.material_model_inputs,
-                                                 scratch.material_model_outputs,
-                                                 scratch.heating_model_outputs);
-
-      for (unsigned int q=0; q < n_q_points; ++q)
-        {
-          const Tensor<1,dim> u = (scratch.old_velocity_values[q] +
-                                   scratch.old_old_velocity_values[q]) / 2;
-
-          const double dField_dt = (this->get_old_timestep() == 0.0) ? 0.0 :
-                                   (
-                                     ((scratch.old_field_values)[q] - (scratch.old_old_field_values)[q])
-                                     / this->get_old_timestep());
-          const double u_grad_field = u * (scratch.old_field_grads[q] +
-                                           scratch.old_old_field_grads[q]) / 2;
-
-          const double density      = scratch.material_model_outputs.densities[q];
-          const double gamma        = scratch.heating_model_outputs.heating_source_terms[q];
-
-          // Because we solve the diffusion equation for the temperature before the advection equation, we can use
-          // the current and old temperature here, together with the current time step.
-          const double diffusion_term = (this->get_timestep() == 0.0) ? 0.0
-                                        :
-                                        (scratch.material_model_inputs.temperature[q] - scratch.old_temperature_values[q]) / this->get_timestep()
-                                        * scratch.material_model_outputs.densities[q] * scratch.material_model_outputs.specific_heat[q];
-
-
-          residuals[q]
-            = std::abs((density * scratch.material_model_inputs.temperature[q]) * (dField_dt + u_grad_field) - gamma - diffusion_term);
-        }
-      return residuals;
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    EntropyAdvectionSystem<dim>::advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-
-      std::vector<double> prefactors(scratch.material_model_inputs.n_evaluation_points(), 0.0);
-
-      for (unsigned int i=0; i<prefactors.size(); ++i)
-        prefactors[i] = scratch.material_model_outputs.densities[i] * scratch.material_model_inputs.temperature[i];
-
-      return prefactors;
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    EntropyAdvectionSystem<dim>::diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-
-      std::vector<double> prefactors(scratch.material_model_inputs.n_evaluation_points(), 0.0);
-
-      for (unsigned int i=0; i<prefactors.size(); ++i)
-        prefactors[i] = scratch.material_model_outputs.thermal_conductivities[i] *
-                        scratch.material_model_inputs.temperature[i] /
-                        scratch.material_model_outputs.specific_heat[i];
-
-      return prefactors;
-    }
-  }
-
-// The function below replaces the normal temperature advection assembler with the entropy advection assembler of this file
-  template <int dim>
-  void set_assemblers_entropy_advection(const SimulatorAccess<dim> &simulator_access,
-                                        Assemblers::Manager<dim> &assemblers)
-  {
-    AssertThrow (Plugins::plugin_type_matches<MaterialModel::EntropyModel<dim>>
-                 (simulator_access.get_material_model()),
-                 ExcMessage ("The entropy advection assembler can only be used with the "
-                             "material model 'entropy model'!"));
-
-    AssertThrow (simulator_access.get_heating_model_manager().adiabatic_heating_enabled() == false,
-                 ExcMessage("The entropy advection assembler requires "
-                            "that adiabatic heating is disabled."));
-
-    // Replace all existing assemblers for the temperature and entropy fields by the one for the entropy equation.
-    const unsigned int temperature_index = 0;
-    assemblers.advection_system[temperature_index].clear();
-    assemblers.advection_system[temperature_index].emplace_back (std::make_unique<Assemblers::EntropyAdvectionSystem<dim>>());
-    assemblers.advection_system_assembler_properties[temperature_index].needed_update_flags = update_hessians;
-
-    if (simulator_access.introspection().composition_type_exists(CompositionalFieldDescription::entropy))
-      {
-        // Find the index of the entropy field and replace the assembler for it.
-        // The index of the entropy field is its index in the compositional fields plus one (for the temperature field).
-        const unsigned int entropy_index = simulator_access.introspection().get_indices_for_fields_of_type(CompositionalFieldDescription::entropy)[0]
-                                           + 1;
-        assemblers.advection_system[entropy_index].clear();
-        assemblers.advection_system[entropy_index].emplace_back (std::make_unique<Assemblers::EntropyAdvectionSystem<dim>>());
-        assemblers.advection_system_assembler_properties[entropy_index].needed_update_flags = update_hessians;
-      }
-  }
-} // namespace aspect
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  signals.set_assemblers.connect (&aspect::set_assemblers_entropy_advection<dim>);
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace Assemblers
-  {
-#define INSTANTIATE(dim) \
-  template class EntropyAdvectionSystem<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-  }
-}
diff --git a/benchmarks/entropy_adiabat/plugins/entropy_advection.h.bak b/benchmarks/entropy_adiabat/plugins/entropy_advection.h.bak
deleted file mode 100644
index 1d0c41a1b67..00000000000
--- a/benchmarks/entropy_adiabat/plugins/entropy_advection.h.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_simulator_assemblers_entropy_advection_h
-#define _aspect_simulator_assemblers_entropy_advection_h
-
-
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    /**
-     * This class assembles the terms for the matrix and right-hand-side of the entropy
-     * advection equation for the current cell.
-     */
-    template <int dim>
-    class EntropyAdvectionSystem : public Assemblers::Interface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
-
-        std::vector<double>
-        compute_residual(internal::Assembly::Scratch::ScratchBase<dim>  &scratch) const override;
-
-        std::vector<double>
-        advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
-
-        std::vector<double>
-        diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/benchmarks/finite_strain/finite_strain.cc.bak b/benchmarks/finite_strain/finite_strain.cc.bak
deleted file mode 100644
index 7084bcac0ef..00000000000
--- a/benchmarks/finite_strain/finite_strain.cc.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
-  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include "../../cookbooks/finite_strain/finite_strain.cc"
diff --git a/benchmarks/finite_strain/pure_shear.prm.bak b/benchmarks/finite_strain/pure_shear.prm.bak
deleted file mode 100644
index fcfe9eb7802..00000000000
--- a/benchmarks/finite_strain/pure_shear.prm.bak
+++ /dev/null
@@ -1,145 +0,0 @@
-# This parameter file reproduces an analytical benchmark for the evolution
-# of finite strain in a model of pure shear as described (for a specific
-# application) in McKenzie & Jackson (1983): "The relationship between
-# strain rates, crustal thickening, paleomagnetism, finite strain and
-# fault movements within a deforming zone." They show that the analytical
-# solution for the deformation gradient tensor F in pure shear deformation is:
-#
-# F_xx = e^(u_x,x * t)
-# F_xy = 0
-# F_yx = 0
-# F_yy = e^(-u_x,x * t),
-#
-# where u is the velocity, t is time, and a comma represents a derivative
-# in that particular direction. u_x,x in this example is equivalent to
-# -u_y,y so that also: F_yy = e^(u_y,y * t) which is intuitive.
-# For this benchmark it is important to recognize that the deformation in
-# this model is actually only "pure" pure shear at the origin, since the
-# deformation field around is a mixture of pure shear and a rotational
-# component. Also the value of u_x,x at the origin is not prescribed
-# directly, but is a model output, because we only know velocity profiles
-# for the top and right boundaries. Using the computed velocity field we
-# can calculate u_x,x approximately at the origin to be 1.253, and therefore
-# expect:
-# F_xx (t=1.0) = 3.501
-# F_yy (t=1.0) = 0.2856
-# This parameter file tracks the finite strain in two ways, once by using
-# compositional fields as illustrated in the finite strain cookbook, and
-# once by using a particle particle that sits and remains at the origin.
-# The results should of course be the same.
-#
-# Numerical results for particle tracking show excellent agreement:
-# F_xx (t=1.0) = 3.50088
-# F_yy (t=1.0) = 0.285643
-#
-# Numerical results for compositional fields also show good results.
-# F_xx (t=1.0) = 3.49776
-# F_yy (t=1.0) = 0.286723
-# The compositional field results are slightly less accurate, probably due to
-# numerical diffusion, but were found to converge against the analytical
-# values with increasing resolution.
-
-set Additional shared libraries            = ./libfinite_strain.so
-set Dimension                              = 2
-set End time                               = 1.0
-set Use years in output instead of seconds = false
-set Output directory                       = output-pure_shear
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom
-  set Prescribed velocity boundary indicators = top:function, right:function
-
-  subsection Function
-    set Function expression = 1-y; x-1
-  end
-end
-
-subsection Material model
-  set Model name = finite strain
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0;0.0;0.0;1.0
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, visualization
-
-  subsection Visualization
-    set List of output variables = strain rate, shear stress
-    set Time between graphical output = 0.05
-  end
-
-  subsection Particles
-    set Time between data output = 0.05
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain
-  set Particle generator name = ascii file
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = ./
-      set Data file name = pure_shear_particle.dat
-    end
-  end
-end
diff --git a/benchmarks/finite_strain/simple_shear.prm.bak b/benchmarks/finite_strain/simple_shear.prm.bak
deleted file mode 100644
index 866ca5d7822..00000000000
--- a/benchmarks/finite_strain/simple_shear.prm.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-# This parameter file reproduces an analytical benchmark for the evolution
-# of finite strain in a model of simple shear as described (for a specific
-# application) in McKenzie & Jackson (1983): "The relationship between
-# strain rates, crustal thickening, paleomagnetism, finite strain and
-# fault movements within a deforming zone." They show that the analytical
-# solution for the deformation gradient tensor F in simple shear deformation is:
-#
-# F_xx = 1.0
-# F_xy = u_x,y * t
-# F_yx = 0
-# F_yy = 1.0,
-#
-# where u is the velocity, t is time, and a comma represents a derivative
-# in that particular direction.
-# Because u_x,y = 2.0 / 1.0 is constant in the whole domain (and over time) we expect
-# a constant F at any given time, and in particular:
-# F_xy (t=1.0) = 2.0
-#
-# This parameter file tracks the finite strain in two ways, once by using
-# compositional fields as illustrated in the finite strain cookbook, and
-# once by using a particle particle that sits and remains in the center of the domain.
-# The results should of course be the same.
-#
-# Numerical results for particle tracking and compositional fields
-# show equally excellent agreement:
-# F_xy (t=1.0) = 2.0
-
-set Additional shared libraries            = ./libfinite_strain.so
-set Dimension                              = 2
-set End time                               = 1.0
-set Use years in output instead of seconds = false
-set Output directory = output-simple_shear
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set X periodic = true
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-
-  subsection Function
-    set Function expression = if (y < 0.5, -1, 1); 0
-  end
-end
-
-subsection Material model
-  set Model name = finite strain
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0;0.0;0.0;1.0
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, visualization
-
-  subsection Visualization
-    set List of output variables = strain rate
-    set Time between graphical output = 0.05
-  end
-
-  subsection Particles
-    set Time between data output = 0.05
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain
-  set Particle generator name = ascii file
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = ./
-      set Data file name = simple_shear_particle.dat
-    end
-  end
-end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm.bak
deleted file mode 100644
index 6bba7d2ad73..00000000000
--- a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm.bak
+++ /dev/null
@@ -1,169 +0,0 @@
-# This model applies a surface load (using the traction
-# boundary condition) on a free surface overlying
-# a viscoelastic box. It approximates the analytical solution
-# of Nakiboglu and Lambeck (1982) for an applied/removed
-# axisymmetric cylindrical load over a viscoelastic half-space.
-
-#  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1500
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set CFL number                             = 0.5
-set Maximum time step                      = 10
-set Output directory                       = output_free_surface_VE_cylinder_2D_loading
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-
-# Model geometry (500x500 km, 50 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 500e3
-    set Y extent      = 500e3
-  end
-end
-
-# Mesh refinement specifications
-# Mesh refinement does not seem to affect
-# deformation of free surface (at least in 2-D).
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Time steps between mesh refinement = 1
-  set Strategy         = strain rate
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Mesh deformation
-  set Additional tangential mesh velocity boundary indicators = left,right
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Surface velocity projection      = normal
-  end
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-end
-
-# Prescribe a fixed vertical traction on the top boundary
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = top y: function
-
-  subsection Function
-    set Variable names = x,y,t
-
-    #set Function expression = 0; 1.e9 + -20.e3*x
-    set Function constants  = r0=100.e3, H0=1.e3, t1=1.e3, rhoi=900, g=9.8, t0=1.e3
-
-    # r0 is load radius, H0 is load height, t1 is time load is fully removed,
-    # rhoi is density of ice/load
-    # option to linearly thin load beginning at time t0.
-    set Function expression = 0; if (x<r0 ,if(t<t0,-g*H0*rhoi,if(t<t1,-g*H0*rhoi*(1-(t-t0)/t1),0)), 0)
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0;
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = true
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# Temperature initial conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 3300
-    set Viscosities                 = 3.e20
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e2
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.8
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate
-    set Time between graphical output = 1e2
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-
-  subsection Topography
-    set Output to file = true
-    set Time between text output = 100
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt.prm.bak
deleted file mode 100644
index 4ffb854ca76..00000000000
--- a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# Same as free_surface_VE_cylinder_2D_loading.prm, but uses
-# a fixed elastic timestep in combination with stress averaging
-# to smooth out the elastic response to instantaneous stress changes.
-
-include free_surface_VE_cylinder_2D_loading.prm
-
-
-#  Global parameters
-set Dimension                              = 2
-set Output directory                       = output_free_surface_VE_cylinder_2D_loading_fixed_elastic_dt
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Use fixed elastic time step = true
-    set Fixed elastic time step     = 1e2
-    set Viscosity averaging scheme  = harmonic
-  end
-end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_unloading.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_unloading.prm.bak
deleted file mode 100644
index cef117fb836..00000000000
--- a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading_unloading.prm.bak
+++ /dev/null
@@ -1,27 +0,0 @@
-# This model applies a surface load (using the traction
-# boundary condition) on a free surface overlying
-# a viscoelastic box. It approximates the analytical solution
-# of Nakiboglu and Lambeck (1982) for an applied/removed
-# axisymmetric cylindrical load over a viscoelastic half-space.
-
-# Modified such that linear unloading occurs at intermediate
-# time steps. Compare to soln_reload files.
-
-include free_surface_VE_cylinder_2D_loading.prm
-
-
-#  Global parameters
-set Dimension                              = 2
-set Output directory                       = output_free_surface_VE_cylinder_2D_loading_unloading
-
-subsection Boundary traction model
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants  = r0=100.e3, H0=1.e3, t1=1.e3, rhoi=900, g=9.8, t0=5.e2
-
-    # r0 is load radius, H0 is load height, t1 is time load is fully removed,
-    # rhoi is density of ice/load
-    # option to linearly thin load beginning at time t0.
-    set Function expression = 0; if (x<r0 ,if(t<t0,-g*H0*rhoi,if(t<t1,-g*H0*rhoi*(1-(t-t0)/t1),0)), 0)
-  end
-end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading.prm.bak
deleted file mode 100644
index fca02c2d27c..00000000000
--- a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading.prm.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-# This model applies a surface load (using the traction
-# boundary condition) on a free surface overlying
-# a viscoelastic box. It approximates the analytical solution
-# of Nakiboglu and Lambeck (1982) for an applied/removed
-# axisymmetric cylindrical load over a viscoelastic half-space.
-
-
-#  Global parameters
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 1500
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set CFL number                             = 0.5
-set Maximum time step                      = 10
-set Output directory                       = output_free_surface_VE_cylinder_3D_loading
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-
-# Model geometry (500x500x500 km, 50 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set Z repetitions = 10
-    set X extent      = 500e3
-    set Y extent      = 500e3
-    set Z extent      = 500e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Time steps between mesh refinement = 1
-  set Strategy         = strain rate
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Mesh deformation
-  set Additional tangential mesh velocity boundary indicators = left, right, front, back
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Surface velocity projection      = normal
-  end
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right, front, back
-end
-
-# Prescribe a fixed vertical traction on the top boundary
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = top z: function
-
-  subsection Function
-    set Variable names = x,y,z,t
-
-    #set Function expression = 0; 1.e9 + -20.e3*x
-    set Function constants  = r0=100.e3, H0=1.e3, t1=1.e3, rhoi=900, g=9.8, t0=1.e3
-
-    # r0 is load radius, H0 is load height, t1 is time load is fully removed,
-    # rhoi is density of ice/load
-    # option to linearly thin load beginning at time t0.
-    set Function expression = 0; 0; if ((x^2+y^2)<r0^2 ,if(t<t0,-g*H0*rhoi,if(t<t1,-g*H0*rhoi*(1-(t-t0)/t1),0)), 0)
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_zz, ve_stress_xy, ve_stress_xz, ve_stress_yz
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  =
-    set Function expression = 0; 0; 0; 0; 0; 0;
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = true
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right, front, back
-  set List of model names = initial temperature
-end
-
-# Temperature initial conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 3300
-    set Viscosities                 = 3.e20
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e2
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.8
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate
-    set Time between graphical output = 1e2
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-
-  subsection Topography
-    set Output to file = true
-    set Time between text output = 100
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading_fixed_elastic_dt.prm.bak b/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading_fixed_elastic_dt.prm.bak
deleted file mode 100644
index db965ee7966..00000000000
--- a/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_3D_loading_fixed_elastic_dt.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# Same as free_surface_VE_cylinder_3D_loading.prm, instead
-# setting fixed elastic timestep and allowing stress averaging,
-# to smooth out elastic response to instantaneous stress changes.
-
-include free_surface_VE_cylinder_3D_loading.prm
-
-
-#  Global parameters
-set Dimension                              = 3
-set Output directory                       = output_free_surface_VE_cylinder_3D_loading_fixed_elastic_dt
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Use fixed elastic time step = true
-    set Fixed elastic time step     = 1e2
-    set Viscosity averaging scheme  = harmonic
-  end
-end
diff --git a/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_2D_loading.prm.bak b/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_2D_loading.prm.bak
deleted file mode 100644
index 5cb6d26b333..00000000000
--- a/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_2D_loading.prm.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-# This model applies a surface load (using the traction
-# boundary condition) on a free surface overlying
-# a viscous box. It approximates the analytical solution
-# of Haskell (1935a) for an instantaneously applied
-# axisymmetric cylindrical load over a viscous half-space.
-
-# This is done by using the viscoelastic model and
-# setting a high shear modulus, which produces viscous behavior.
-
-include ../viscoelastic/free_surface_VE_cylinder_2D_loading.prm
-
-set Dimension                              = 2
-set Output directory                       = output_free_surface_viscous_cylinder_2D_loading
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Elastic shear moduli        = 1.e50
-  end
-end
diff --git a/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_3D_loading.prm.bak b/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_3D_loading.prm.bak
deleted file mode 100644
index 1bae0228576..00000000000
--- a/benchmarks/free_surface_tractions/viscous/free_surface_viscous_cylinder_3D_loading.prm.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-# This model applies a surface load (using the traction
-# boundary condition) on a free surface overlying
-# a viscous box. It approximates the analytical solution
-# of Haskell (1935a) for an instantaneously applied
-# axisymmetric cylindrical load over a viscous half-space.
-
-# This is done by using the viscoelastic model and
-# setting a high shear modulus.
-
-include ../viscoelastic/free_surface_VE_cylinder_3D_loading.prm
-
-set Dimension                              = 3
-set Output directory                       = output_free_surface_viscous_cylinder_3D_loading
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Elastic shear moduli        = 1.e50
-  end
-end
diff --git a/benchmarks/geoid-spectral-comparison/spectral-comparison.prm.bak b/benchmarks/geoid-spectral-comparison/spectral-comparison.prm.bak
deleted file mode 100644
index 132e9d825ac..00000000000
--- a/benchmarks/geoid-spectral-comparison/spectral-comparison.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# Spectral Comparison of the Geoid
-
-# Define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 3
-
-# Specify the time you want to let the model run for in
-# years and the output directory. Here we only calculate
-# the instantaneous solution.
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Output directory                       = output
-
-# The following variables describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Here we specify the residual tolerance for the linear solver.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-5
-    set Number of cheap Stokes solver steps             = 0
-  end
-end
-
-# Here we specify the geometry of the domain, which is
-# a spherical shell with inner radius of 3481km and
-# outer radius of 6371km
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6371000
-  end
-end
-
-# This section describes the gravity field, which is pointing
-# towards the Earth's center with the same magnitude of 10 m/s^2
-# everywhere
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-# This section prescribes the initial condition in the temperature
-# field, which is chosen as a scaled version of the S20RTS shear
-# wave velocity model (Ritsema et al., 2000). S20RTS is defined
-# by spherical harmonics up to degree 20 that are radially interpolated
-# with a cubic spline.
-subsection Initial temperature model
-  set Model name = S40RTS perturbation
-
-  subsection S40RTS perturbation
-    # The two input options here are S20RTS or the higher resolution
-    # S40RTS (Ritsema et al., 2011). One can choose to remove the
-    # degree 0 from these files so that the depth average value
-    # is zero.
-    set Initial condition file name       = S20RTS.sph
-    set Remove degree 0 from perturbation = false
-
-    # The following parameters determine the scaling from shear wave
-    # velocity perturbation to temperature differences. We chose the
-    # scaling to density perturbation as 0.15
-    set Vs to density scaling             = 0.15
-    set Thermal expansion coefficient in initial temperature scaling = 3e-5
-
-    # This specifies the background temperature to which we add the
-    # temperature difference.
-    set Reference temperature             = 1600
-
-    #    set Remove temperature heterogeneity down to specified depth = 660000
-  end
-end
-
-# The material model is based on the simple material model, which assumes
-# a constant density, and other parameters as stated below.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                 = 3300
-    set Viscosity                         = 1e21
-    set Thermal expansion coefficient     = 3e-5
-    set Reference temperature             = 1600
-    set Thermal conductivity              = 4.125
-    set Reference specific heat           = 1250
-  end
-end
-
-# For this calculation we only do 3 global refinement steps. This resolution
-# is too low to fully resolve the mantle flow, however it does capture
-# the main features.
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 0
-end
-
-# We assume free slip at the inner and outer boundary
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom
-end
-
-# We output the density, velocity, dynamic topography, geoid and heat flux density
-# for plotting.
-subsection Postprocess
-  set List of postprocessors = geoid, dynamic topography, visualization, basic statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set List of output variables      = geoid, dynamic topography,  density, viscosity, gravity
-    set Time between graphical output = 0
-    set Number of grouped files       = 1
-  end
-
-  subsection Geoid
-    set Also output the gravity anomaly  = true
-  end
-end
diff --git a/benchmarks/grain_size_pinned_state/grain_size_plunge.prm.bak b/benchmarks/grain_size_pinned_state/grain_size_plunge.prm.bak
deleted file mode 100644
index c4d11dfca7c..00000000000
--- a/benchmarks/grain_size_pinned_state/grain_size_plunge.prm.bak
+++ /dev/null
@@ -1,162 +0,0 @@
-# A test for the grain size material model using pinned state damage formulation.
-# This test is like tests/grain_size_strain_pinned_state.prm, but uses the parameters
-# from Mulyukova and Bercovici (2018) at constant
-# temperature and stress in their Figure 4.
-
-# The output can be compared to the analytical solution computed in the
-# grain_size_plunge.ipynb notebook located in the same folder as this input file.
-
-set Dimension                              = 2
-set End time                               = 1e7
-set Output directory                       = output-grain_size_plunge
-set Use years in output instead of seconds = true
-set Maximum first time step                = 10
-set Maximum relative increase in time step = 1
-set Nonlinear solver scheme                = iterated Advection and defect correction Stokes
-set Max nonlinear iterations               = 50
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1100
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-    set X periodic = true
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top,bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 1100
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = top x: function, bottom x: function
-
-  subsection Function
-    set Variable names = x,y
-
-    # We want to prescribe a tangential traction of 50 MPa
-    # at the top boundary and -50 at the bottom boundary.
-    set Function constants = traction = 50e6, y_extent = 1e5
-    set Function expression = if (y>y_extent/2, traction, -traction)  ;  0
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top y: function, bottom y: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 0
-
-    subsection Function
-      set Function expression       = 0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-
-    # This is the test case from Mulyukova and Bercovici (2018) using
-    # the parameters from their figure 4 and a grain size of 1e-2 m.
-    set Function expression = 1e-2
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-end
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                = 3400
-    set Thermal conductivity             = 0
-    set Thermal expansion coefficient    = 0
-    set Reference compressibility        = 0
-    set Viscosity                        = 1e18
-    set Minimum viscosity                = 1e16
-    set Reference temperature            = 1100
-    set Recrystallized grain size        =
-    set Grain growth activation energy       = 3e5
-    set Grain growth activation volume       = 0.0
-    set Grain growth rate constant           = 1.6E-022
-    set Grain growth exponent                = 4
-    set Average specific grain boundary energy = 1.0
-    set Geometric constant                   = 3
-    set Grain size evolution formulation     = pinned grain damage
-
-    # Mulyukova and Bercovici (2018)
-    # Diffusion creep
-    set Diffusion creep prefactor            = 27.2e-24 # s^-1 Pa^-1 m^p
-    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 3e5 #J/mol
-    set Diffusion activation volume          = 0 # m^3/mol
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # Dislocation creep
-    set Dislocation creep prefactor          = 8.8e-13 # s^-1 Pa^-n
-    set Dislocation creep exponent           = 3
-    set Dislocation activation energy        = 530000 # J/mol
-    set Dislocation activation volume        = 0 # m^3/mol
-    set Minimum grain size                   = 1e-8
-
-    subsection Grain damage partitioning
-      set Minimum grain size reduction work fraction = 5e-3
-      set Maximum grain size reduction work fraction = 5e-3
-    end
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, visualization, material statistics, ODE statistics
-
-  subsection Visualization
-    set List of output variables = viscosity, shear stress, stress, stress second invariant
-    set Time between graphical output = 5e3
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net x translation
-end
diff --git a/benchmarks/gravity_mantle/mantle_gravity.prm.bak b/benchmarks/gravity_mantle/mantle_gravity.prm.bak
deleted file mode 100644
index 82754a08720..00000000000
--- a/benchmarks/gravity_mantle/mantle_gravity.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# A simple setup for testing the gravity postprocessor using the
-# sample scheme 'map'.
-# See the corresponding section in the manual for more information.
-
-# General parameters
-set Dimension                              = 3
-set End time                               = 0
-set Output directory                       = output-gravity-mantle
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3480e3
-    set Outer radius  = 6251e3
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Thermal expansion coefficient = 3e-5
-  end
-end
-
-# Model initial temperature
-subsection Initial temperature model
-  set Model name = S40RTS perturbation
-
-  subsection S40RTS perturbation
-    set Initial condition file name       = S40RTS.sph
-    set Spline knots depth file name      = Spline_knots.txt
-    set Remove degree 0 from perturbation = false
-    set Vs to density scaling             = 0.15
-    set Thermal expansion coefficient in initial temperature scaling = 3e-5
-    set Reference temperature             = 0
-  end
-end
-
-# Model gravity
-subsection Gravity model
-  set Model name = radial constant
-end
-
-# Mesh refinement
-subsection Mesh refinement
-  set Initial global refinement = 3
-end
-
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = gravity calculation,visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity
-    set Time between graphical output = 0
-    set Interpolate output = false
-  end
-
-  subsection Gravity calculation
-    set Sampling scheme = map
-    set Minimum radius = 6621e3
-    set Minimum longitude = -180
-    set Maximum longitude = 179
-    set Number points longitude = 180
-    set Minimum latitude = -90
-    set Maximum latitude = +90
-    set Number points latitude  = 90
-    set Quadrature degree increase = 01
-  end
-end
diff --git a/benchmarks/gravity_thick_shell/doc/thick_shell.prm.bak b/benchmarks/gravity_thick_shell/doc/thick_shell.prm.bak
deleted file mode 100644
index d21edf6563d..00000000000
--- a/benchmarks/gravity_thick_shell/doc/thick_shell.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = gravity calculation,visualization
-
-  subsection Gravity calculation
-    set Sampling scheme = list of points
-    set List of radius    = 0,1e6,2e6,3e6,3.5e6,4e6,4.5e6,5e6,5.5e6,6e6,6.371e6,6.5e6,7e6,8e6,9e6,10e6
-    set List of longitude = 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
-    set List of latitude  = 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
-    set Quadrature degree increase = 1
-  end
-end
diff --git a/benchmarks/gravity_thick_shell/thick_shell.prm.bak b/benchmarks/gravity_thick_shell/thick_shell.prm.bak
deleted file mode 100644
index 911dd9853f8..00000000000
--- a/benchmarks/gravity_thick_shell/thick_shell.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# A simple setup for testing the gravity postprocessor using the
-# sample scheme 'list of points'. The domain is a 2891 km thick
-# shell of constant density, i.e. the Earth mantle.
-# An analytical solution exists for the gravitational acceleration
-# and potential so that values returned by the gravity postprocessor
-# can be benchmarked on a line from the center of the planet to
-# 10,000 km outside.
-# See the corresponding section in the manual for more information.
-
-# General parameters
-set Dimension                              = 3
-set End time                               = 0
-set Output directory                       = output_shellgravity
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3480e3
-    set Outer radius = 6371e3
-  end
-end
-
-# Model boundary velocity
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top, bottom
-end
-
-# Material model
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3300
-    set Thermal expansion coefficient = 0
-  end
-end
-
-# Model gravity
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-# Mesh refinement
-subsection Mesh refinement
-  set Initial global refinement = 4
-end
-
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = gravity calculation,visualization
-
-  subsection Visualization
-    set List of output variables = density
-    set Time between graphical output = 0
-    set Interpolate output = false
-  end
-
-  subsection Gravity calculation
-    set Sampling scheme = list of points
-    set List of radius    = 0,1e6,2e6,3e6,3.5e6,4e6,4.5e6,5e6,5.5e6,6e6,6.371e6,6.5e6,7e6,8e6,9e6,10e6
-    set List of longitude = 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
-    set List of latitude  = 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13
-    set Quadrature degree increase = 1
-  end
-end
diff --git a/benchmarks/gravity_thin_shell/doc/thinshell_a.prm.bak b/benchmarks/gravity_thin_shell/doc/thinshell_a.prm.bak
deleted file mode 100644
index aec41ce6b98..00000000000
--- a/benchmarks/gravity_thin_shell/doc/thinshell_a.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 6266e3
-    set Outer radius = 6276e3
-    set Custom mesh subdivision = number of slices
-    set Number of slices = 1
-    set Initial lateral refinement = 5
-  end
-end
diff --git a/benchmarks/gravity_thin_shell/doc/thinshell_b.prm.bak b/benchmarks/gravity_thin_shell/doc/thinshell_b.prm.bak
deleted file mode 100644
index 3bf6a339c65..00000000000
--- a/benchmarks/gravity_thin_shell/doc/thinshell_b.prm.bak
+++ /dev/null
@@ -1 +0,0 @@
-set Nonlinear solver scheme = no Advection, no Stokes
diff --git a/benchmarks/gravity_thin_shell/doc/thinshell_c.prm.bak b/benchmarks/gravity_thin_shell/doc/thinshell_c.prm.bak
deleted file mode 100644
index 7185128e5de..00000000000
--- a/benchmarks/gravity_thin_shell/doc/thinshell_c.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = gravity calculation,visualization
-
-  subsection Gravity calculation
-    set Sampling scheme = map
-    set Minimum radius = 6621e3
-    set Minimum longitude = -180
-    set Maximum longitude = 179
-    set Number points longitude = 180
-    set Minimum latitude = -90
-    set Maximum latitude = +90
-    set Number points latitude  = 90
-    set Quadrature degree increase = 1
-  end
-end
diff --git a/benchmarks/gravity_thin_shell/gravity_thin_shell.prm.bak b/benchmarks/gravity_thin_shell/gravity_thin_shell.prm.bak
deleted file mode 100644
index 4b778bd997f..00000000000
--- a/benchmarks/gravity_thin_shell/gravity_thin_shell.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# A simple setup for testing the gravity postprocessor using the
-# sample scheme 'map'. The domain is a 5 km thick thin shell of constant density.
-# An analytical solution exists for the gravitational acceleration
-# and potential so that values returned by the gravity postprocessor
-# can be benchmarked on a longitude-latitude grid at satellite orbit height.
-
-set Dimension                              = 3
-set End time                               = 0
-set Output directory                       = output_thin_shell_gravity
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry
-# The thin shell (5 km thickness) can be centered around 5 different depths,
-# 0, 100, 500, 1500 and 3000 km, i.e. radii 6371, 6271, 5871, 4871 and 3371 km.
-# The default depth is here 100 km while other corresponding inner and outer
-# radii are commented.
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    # layer 0 km depth
-    #set Inner radius = 6366e3
-    #set Outer radius = 6376e3
-    # layer 100 km depth
-    set Inner radius = 6266e3
-    set Outer radius = 6276e3
-
-    # layer 500 km depth
-    #set Inner radius = 5866e3
-    #set Outer radius = 5876e3
-    # layer 1500 km depth
-    #set Inner radius = 4866e3
-    #set Outer radius = 4876e3
-    # layer 3000 km depth
-    #set Inner radius = 3366e3
-    #set Outer radius = 3376e3
-    set Custom mesh subdivision = number of slices
-    set Number of slices = 1
-    set Initial lateral refinement = 5
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top, bottom
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3300
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = gravity calculation,visualization
-
-  subsection Visualization
-    set List of output variables = density, viscosity, partition
-    set Time between graphical output = 0
-    set Interpolate output = false
-  end
-
-  subsection Gravity calculation
-    set Sampling scheme = map
-    set Minimum radius = 6621e3
-    set Minimum longitude = -180
-    set Maximum longitude = 179
-    set Number points longitude = 180
-    set Minimum latitude = -90
-    set Maximum latitude = +90
-    set Number points latitude  = 90
-    set Quadrature degree increase = 1
-  end
-end
diff --git a/benchmarks/hollow_sphere/hollow_sphere.cc.bak b/benchmarks/hollow_sphere/hollow_sphere.cc.bak
deleted file mode 100644
index 12ebe62fc77..00000000000
--- a/benchmarks/hollow_sphere/hollow_sphere.cc.bak
+++ /dev/null
@@ -1,682 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/postprocess/dynamic_topography.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-
-namespace aspect
-{
-  /**
-   * This is the "HollowSphere" benchmark defined in the following paper:
-   * Analytical solution for viscous incompressible Stokes flow in a spherical shell
-   * C. Thieulot, in prep.
-   */
-  namespace HollowSphereBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-      const double gammma = 1.0;
-
-      const double R1 = 0.5;
-      const double R2 = 1.0;
-
-      const double gravity = 1.0;
-      const double mu0=1;
-      const double rho_0 = 1000;
-
-      Tensor<1,3>
-      hollow_sphere_velocity (const Point<3> &pos,
-                              const double mmm)
-      {
-
-        const std::array<double,3> spos =
-          aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(pos);
-
-        const double r=spos[0];
-        const double phi=spos[1];
-        const double theta=spos[2];
-
-
-        double alpha,beta,fr,gr;
-
-        if (mmm == -1)
-          {
-            alpha=-gammma*(pow(R2,3)-pow(R1,3))/(pow(R2,3)*log(R1)-pow(R1,3)*log(R2));
-            beta=-3*gammma*(log(R2)-log(R1))/(pow(R1,3)*log(R2)-pow(R2,3)*log(R1)) ;
-            fr=alpha/(r*r)+beta*r;
-            gr=-2/(r*r)*(alpha*log(r)+beta/3*pow(r,3)+gammma);
-          }
-        else
-          {
-            alpha=gammma*(mmm+1)*(pow(R1,-3)-pow(R2,-3))/(pow(R1,-mmm-4)-pow(R2,-mmm-4));
-            beta=-3*gammma*(pow(R1,mmm+1)-pow(R2,mmm+1))/(pow(R1,mmm+4)-pow(R2,mmm+4));
-            fr=alpha/pow(r,mmm+3)+beta*r;
-            gr=-2/(r*r)*(-alpha/(mmm+1)*pow(r,-mmm-1)+beta/3*pow(r,3)+gammma);
-          }
-
-        const double v_r    =gr*cos(theta);
-        const double v_theta=fr*sin(theta);
-        const double v_phi  =fr*sin(theta);
-        const double v_x=sin(theta)*cos(phi)*v_r + cos(theta)*cos(phi)*v_theta-sin(phi)*v_phi;
-        const double v_y=sin(theta)*sin(phi)*v_r + cos(theta)*sin(phi)*v_theta+cos(phi)*v_phi;
-        const double v_z=cos(theta)*v_r - sin(theta)*v_theta;
-
-        // create a Point<3> (because it has a constructor that takes
-        // three doubles) and return it (it automatically converts to
-        // the necessary Tensor<1,3>).
-        return Point<3> (v_x,v_y,v_z);
-      }
-
-      double
-      hollow_sphere_pressure (const Point<3> &pos,
-                              const double mmm)
-      {
-        const std::array<double,3> spos =
-          aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(pos);
-
-        const double r=spos[0];
-        const double theta=spos[2];
-
-        double alpha,beta,gr,hr,mur;
-
-
-        if (mmm == -1)
-          {
-            mur=mu0;
-            alpha=-gammma*(pow(R2,3)-pow(R1,3))/(pow(R2,3)*log(R1)-pow(R1,3)*log(R2));
-            beta=-3*gammma*(log(R2)-log(R1))/(pow(R1,3)*log(R2)-pow(R2,3)*log(R1)) ;
-            gr=-2/(r*r)*(alpha*log(r)+beta/3*pow(r,3)+gammma);
-            hr=2/r*gr*mur;
-          }
-        else
-          {
-            mur=mu0*pow(r,mmm+1);
-            alpha=gammma*(mmm+1)*(pow(R1,-3)-pow(R2,-3))/(pow(R1,-mmm-4)-pow(R2,-mmm-4));
-            beta=-3*gammma*(pow(R1,mmm+1)-pow(R2,mmm+1))/(pow(R1,mmm+4)-pow(R2,mmm+4));
-            gr=-2/(r*r)*(-alpha/(mmm+1)*pow(r,-mmm-1)+beta/3*pow(r,3)+gammma);
-            hr=(mmm+3)/r*gr*mur;
-          }
-
-        return hr*cos(theta) + rho_0 * gravity * (R2 - r);
-      }
-
-      template <int dim>
-      double
-      hollow_sphere_normal_traction(const Point<dim> &pos,
-                                    const double mmm)
-      {
-        Assert (dim == 3, ExcNotImplemented());
-
-        const double r=std::sqrt(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2]);
-        const double theta=std::acos(pos[2]/r);
-
-        double alpha,beta,fr,gr;
-
-
-        if (mmm == -1)
-          {
-            alpha=-gammma*(pow(R2,3)-pow(R1,3))/(pow(R2,3)*log(R1)-pow(R1,3)*log(R2));
-            beta=-3*gammma*(log(R2)-log(R1))/(pow(R1,3)*log(R2)-pow(R2,3)*log(R1)) ;
-            fr=alpha/(r*r)+beta*r;
-            gr=-2/(r*r)*(alpha*log(r)+beta/3*pow(r,3)+gammma);
-          }
-        else
-          {
-            alpha=gammma*(mmm+1)*(pow(R1,-3)-pow(R2,-3))/(pow(R1,-mmm-4)-pow(R2,-mmm-4));
-            beta=-3*gammma*(pow(R1,mmm+1)-pow(R2,mmm+1))/(pow(R1,mmm+4)-pow(R2,mmm+4));
-            fr=alpha/pow(r,mmm+3)+beta*r;
-            gr=-2/(r*r)*(-alpha/(mmm+1)*pow(r,-mmm-1)+beta/3*pow(r,3)+gammma);
-          }
-
-        return -(6.*gr + 4.*fr) * cos(theta) * mu0 / r;
-      }
-
-
-      /**
-       * The exact solution for the HollowSphere benchmark.
-       */
-      template <int dim>
-      class FunctionHollowSphere : public Function<dim>
-      {
-        public:
-          FunctionHollowSphere (const double mmm)
-            :
-            Function<dim>(dim+2),
-            mmm_(mmm)
-          {}
-
-          void vector_value (const Point<dim>   &pos,
-                             Vector<double>   &values) const override
-          {
-            Assert (dim == 3, ExcNotImplemented());
-            Assert (values.size() >= 4, ExcInternalError());
-
-            const Point<3> p (pos[0], pos[1], pos[2]);
-
-            const Tensor<1,3> v = AnalyticSolutions::hollow_sphere_velocity (p, mmm_);
-            values[0] = v[0];
-            values[1] = v[1];
-            values[2] = v[2];
-
-            values[3] = AnalyticSolutions::hollow_sphere_pressure (p, mmm_);
-          }
-
-        private:
-          const double mmm_;
-      };
-    }
-
-
-
-    template <int dim>
-    class HollowSphereBoundary : public BoundaryVelocity::Interface<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        HollowSphereBoundary();
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id ,
-                           const Point<dim> &position) const override;
-
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-        */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-
-      private:
-        double mmm;
-    };
-
-    template <int dim>
-    HollowSphereBoundary<dim>::HollowSphereBoundary ()
-      :
-      mmm (0)
-    {}
-
-
-
-    template <>
-    Tensor<1,2>
-    HollowSphereBoundary<2>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<2> &) const
-    {
-      Assert (false, ExcNotImplemented());
-      return Tensor<1,2>();
-    }
-
-
-
-    template <>
-    Tensor<1,3>
-    HollowSphereBoundary<3>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<3> &p) const
-    {
-      return AnalyticSolutions::hollow_sphere_velocity (p, mmm);
-    }
-
-
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class HollowSphereMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-
-        /**
-         * Returns the viscosity value in the inclusion
-         */
-        double get_mmm() const;
-
-        /**
-         * viscosity value in the inclusion
-         */
-        double mmm;
-    };
-
-
-
-    template <int dim>
-    bool
-    HollowSphereMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-
-    template <>
-    void
-    HollowSphereMaterial<2>::
-    evaluate (const MaterialModel::MaterialModelInputs<2> &/*in*/,
-              MaterialModel::MaterialModelOutputs<2> &/*out*/) const
-    {
-      Assert (false, ExcNotImplemented());
-    }
-
-
-
-    template <>
-    void
-    HollowSphereMaterial<3>::
-    evaluate (const MaterialModel::MaterialModelInputs<3> &in,
-              MaterialModel::MaterialModelOutputs<3> &out) const
-    {
-      const unsigned int dim = 3;
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const Point<dim> &pos = in.position[i];
-          const std::array<double,dim> spos = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(pos);
-          const double r = spos[0];
-          const double mu = pow(r,mmm+1);
-          out.viscosities[i] = mu;
-
-          const double theta=spos[2];
-
-          const double gammma = 1.0;
-          const double R1 = 0.5;
-          const double R2 = 1.0;
-
-          double alpha,beta,rho;
-          const double rho_0 = 1000.;
-
-          if (mmm == -1)
-            {
-              alpha = -gammma*(pow(R2,3)-pow(R1,3))/(pow(R2,3)*log(R1)-pow(R1,3)*log(R2));
-              beta  = -3*gammma*(log(R2)-log(R1))/(pow(R1,3)*log(R2)-pow(R2,3)*log(R1)) ;
-              rho = -(alpha/pow(r,4)*(8*log(r)-6) + 8./3.*beta/r+8*gammma/pow(r,4))*cos(theta) + rho_0;
-            }
-          else
-            {
-              alpha=gammma*(mmm+1)*(pow(R1,-3)-pow(R2,-3))/(pow(R1,-mmm-4)-pow(R2,-mmm-4));
-              beta=-3*gammma*(pow(R1,mmm+1)-pow(R2,mmm+1))/(pow(R1,mmm+4)-pow(R2,mmm+4));
-              rho= -(2*alpha*pow(r,-4)*(mmm+3)/(mmm+1)*(mmm-1)-2*beta/3*(mmm-1)*(mmm+3)*pow(r,mmm)-mmm*(mmm+5)*2*gammma*pow(r,mmm-3) )*cos(theta) + rho_0;
-            }
-
-          out.densities[i] = rho;
-
-          out.specific_heat[i] = 0;
-          out.thermal_conductivities[i] = 0.0;
-          out.compressibilities[i] = 0;
-          out.thermal_expansion_coefficients[i] = 0;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    HollowSphereMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      //create a global section in the parameter file for parameters
-      //that describe this benchmark. note that we declare them here
-      //in the material model, but other kinds of plugins (e.g., the gravity
-      //model below) may also read these parameters even though they do not
-      //declare them
-      prm.enter_subsection("HollowSphere benchmark");
-      {
-        prm.declare_entry("Viscosity parameter", "-1",
-                          Patterns::Double (),
-                          "Viscosity in the HollowSphere benchmark.");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    HollowSphereMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("HollowSphere benchmark");
-      {
-        mmm = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-    template <int dim>
-    void
-    HollowSphereBoundary<dim>::declare_parameters (ParameterHandler &)
-    {
-      //nothing to declare here. This plugin will however, read parameters
-      //declared by the material model in the "HollowSphere benchmark" section
-    }
-
-
-    template <int dim>
-    void
-    HollowSphereBoundary<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("HollowSphere benchmark");
-      {
-        mmm = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    double
-    HollowSphereMaterial<dim>::get_mmm() const
-    {
-      return mmm;
-    }
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the paper Duretz et al. reference above.
-      */
-    template <int dim>
-    class HollowSpherePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * List the other postprocessors required by this plugin.
-         */
-        std::list<std::string>
-        required_other_postprocessors() const override;
-
-      private:
-        /**
-         * Calculate the L2 dynamic topography error.
-         */
-        double
-        compute_dynamic_topography_error() const;
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    HollowSpherePostprocessor<dim>::execute (TableHandler &)
-    {
-      std::unique_ptr<Function<dim>> ref_func;
-      {
-        const HollowSphereMaterial<dim> &
-        material_model
-          = Plugins::get_plugin_as_type<const HollowSphereMaterial<dim>>(this->get_material_model());
-
-        ref_func = std::make_unique<AnalyticSolutions::FunctionHollowSphere<dim>>(material_model.get_mmm());
-      }
-
-      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                          dim+2);
-      ComponentSelectFunction<dim> comp_p(dim, dim+2);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_u,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_p,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_p);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_ul2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_pl2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-      const double topo_l2 = compute_dynamic_topography_error();
-
-      std::ostringstream os;
-
-      os << std::scientific <<  u_l1
-         << ", " << p_l1
-         << ", " << u_l2
-         << ", " << p_l2
-         << ", " << topo_l2;
-
-      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2 topo_L2:", os.str());
-    }
-
-    /**
-     * Register the other postprocessor that we need: DynamicTopography
-     */
-    template <int dim>
-    std::list<std::string>
-    HollowSpherePostprocessor<dim>::required_other_postprocessors() const
-    {
-      return std::list<std::string> (1, "dynamic topography");
-    }
-
-
-    template <>
-    double
-    HollowSpherePostprocessor<2>::compute_dynamic_topography_error () const
-    {
-      Assert (false, ExcNotImplemented());
-      return 0.0;
-    }
-
-
-
-    /**
-     * Integrate the difference between the analytical and numerical
-     * solutions for dynamic topography.
-     */
-    template <>
-    double
-    HollowSpherePostprocessor<3>::compute_dynamic_topography_error() const
-    {
-      const unsigned int dim = 3;
-      const Postprocess::DynamicTopography<dim> &dynamic_topography =
-        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<dim>>();
-
-      const HollowSphereMaterial<dim> &material_model
-        = Plugins::get_plugin_as_type<const HollowSphereMaterial<dim>>(this->get_material_model());
-      const double beta = material_model.get_mmm();
-
-      const QGauss<dim-1> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-      FEFaceValues<dim> fe_face_values(this->get_mapping(),
-                                       this->get_fe(),
-                                       quadrature_formula,
-                                       update_values | update_gradients |
-                                       update_quadrature_points | update_JxW_values);
-      LinearAlgebra::BlockVector topo_vector = dynamic_topography.topography_vector();
-      std::vector<double> topo_values(quadrature_formula.size());
-
-      double l2_error = 0.;
-
-      typename DoFHandler<dim>::active_cell_iterator
-      cell = this->get_dof_handler().begin_active(),
-      endc = this->get_dof_handler().end();
-
-      Point<dim> test;
-      test[2] = 1.0;
-      test[0] = 0.;
-      test[1] = 0.;
-      for (; cell!=endc; ++cell)
-        if (cell->is_locally_owned())
-          if (cell->at_boundary())
-            for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
-              if (cell->face(f)->at_boundary() && cell->face(f)->boundary_id() == 1 /*outer surface*/)
-                {
-                  fe_face_values.reinit(cell, f);
-                  MaterialModel::MaterialModelInputs<dim> in_face(fe_face_values, cell, this->introspection(), this->get_solution());
-                  MaterialModel::MaterialModelOutputs<dim> out_face(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-                  in_face.requested_properties = MaterialModel::MaterialProperties::density;
-                  fe_face_values[this->introspection().extractors.temperature].get_function_values(topo_vector, topo_values);
-                  this->get_material_model().evaluate(in_face, out_face);
-
-                  for (unsigned int q=0; q < quadrature_formula.size(); ++q)
-                    {
-                      const Point<dim> p = fe_face_values.quadrature_point(q);
-                      const double analytic_normal_stress = AnalyticSolutions::hollow_sphere_normal_traction<dim>(p, beta);
-                      const double gravity = this->get_gravity_model().gravity_vector(p).norm();
-                      const double density = out_face.densities[q];
-                      const double diff = -analytic_normal_stress / gravity / density - topo_values[q];
-                      l2_error += (diff*diff) * fe_face_values.JxW(q);
-                    }
-                }
-      const double total_l2_error =  Utilities::MPI::sum(l2_error,this->get_mpi_communicator());
-      return std::sqrt(total_l2_error);
-    }
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HollowSphereBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(HollowSphereMaterial,
-                                   "HollowSphereMaterial",
-                                   "A material model that corresponds to the `HollowSphere' benchmark. "
-                                   "See the manual for more information.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(HollowSphereBoundary,
-                                            "HollowSphereBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "`HollowSphere' benchmark. See the manual for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(HollowSpherePostprocessor,
-                                  "HollowSpherePostprocessor",
-                                  "A postprocessor that compares the solution of the `HollowSphere' benchmark "
-                                  "with the one computed by ASPECT "
-                                  "and reports the error. See the manual for more information.")
-  }
-}
diff --git a/benchmarks/hollow_sphere/hollow_sphere.prm.bak b/benchmarks/hollow_sphere/hollow_sphere.prm.bak
deleted file mode 100644
index b7678faba23..00000000000
--- a/benchmarks/hollow_sphere/hollow_sphere.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-# The 3D HollowSphere benchmark, for which an
-# analytical solution is available (Thieulot, in prep).
-
-
-############### Global parameters
-
-set Additional shared libraries            = ./libhollow_sphere.so
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Output directory                       = output
-set Pressure normalization                 = surface
-
-############### Parameters describing the model
-# The setup is a 3D shell
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 0.5
-    set Outer radius = 1.0
-    set Cells along circumference = 12
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom : HollowSphereBoundary, \
-                                                top : HollowSphereBoundary
-end
-
-subsection Material model
-  set Model name = HollowSphereMaterial
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 1.0
-  end
-end
-
-subsection HollowSphere benchmark
-  #Viscosity parameter is m
-  set Viscosity parameter             = 3
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-#subsection Discretization
-#set Stokes velocity polynomial degree = 1
-#set Use locally conservative discretization = true
-#end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, HollowSpherePostprocessor, memory statistics, dynamic topography
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, dynamic topography, gravity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/benchmarks/inclusion/adaptive.prm.base.bak b/benchmarks/inclusion/adaptive.prm.base.bak
deleted file mode 100644
index c539065b2ad..00000000000
--- a/benchmarks/inclusion/adaptive.prm.base.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-############### Global parameters
-
-set Additional shared libraries            = ./libinclusion.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
-                                                right : InclusionBoundary, \
-                                                bottom: InclusionBoundary, \
-                                                top   : InclusionBoundary
-end
-
-subsection Material model
-  set Model name = InclusionMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 13
-  set Initial global refinement                = 4
-  set Strategy = velocity#viscosity
-  set Run postprocessors on initial refinement = true
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.5
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = InclusionPostprocessor, visualization
-
-  subsection Visualization
-    set List of output variables = viscosity
-    set Time between graphical output = 0
-  end
-end
diff --git a/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.cc.bak b/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.cc.bak
deleted file mode 100644
index 0ba0f0693a5..00000000000
--- a/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.cc.bak
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include "inclusion_compositional_fields.h"
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(InclusionCompositionalMaterial,
-                                   "InclusionCompositionalMaterial",
-                                   "A material model that corresponds to the 'Inclusion' benchmark "
-                                   "defined in Duretz et al., G-Cubed, 2011. using "
-                                   "compositional fields.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(InclusionBoundary,
-                                            "InclusionBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "``inclusion'' benchmark. See the manual and the Kronbichler, Heister "
-                                            "and Bangerth paper on ASPECT for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(InclusionPostprocessor,
-                                  "InclusionPostprocessor",
-                                  "A postprocessor that compares the solution of the benchmarks from "
-                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
-                                  "and reports the error. Specifically, it can compute the errors for "
-                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
-                                  "which material model is currently being used and adjusts "
-                                  "which exact solution to use accordingly.")
-  }
-}
diff --git a/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.h.bak b/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.h.bak
deleted file mode 100644
index b8d29972826..00000000000
--- a/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.h.bak
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef ASPECT_INCLUSION_COMPOSITIONAL_FIELDS_H
-#define ASPECT_INCLUSION_COMPOSITIONAL_FIELDS_H
-
-#include "../inclusion.h"
-
-
-
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class InclusionCompositionalMaterial : public InclusionMaterial<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              out.viscosities[i] = in.composition[i][0];
-              out.densities[i] = 0;
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-    };
-  }
-}
-#endif
diff --git a/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.prm.bak b/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.prm.bak
deleted file mode 100644
index 0a368f998f3..00000000000
--- a/benchmarks/inclusion/compositional_fields/inclusion_compositional_fields.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# A description of the SolVI or Inclusion benchmark using
-# compositional fields for which a known solution is available.
-# See the manual for more information.
-
-############### Global parameters
-
-set Additional shared libraries            = ./libinclusion_compositional_fields.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
-                                                right : InclusionBoundary, \
-                                                bottom: InclusionBoundary, \
-                                                top   : InclusionBoundary
-end
-
-subsection Material model
-  set Model name = InclusionCompositionalMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Composition polynomial degree                = 1
-  set Stokes velocity polynomial degree            = 2
-  set Use discontinuous composition discretization = true
-  set Use locally conservative discretization      = false
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-subsection Compositional fields
-  set Number of fields            = 1
-  set Names of fields             = viscosity_comp
-  set Compositional field methods = field
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = eta_b=1e3, rmax=0.2
-    set Function expression = if((x-1.0)*(x-1.0)+(z-1.0)*(z-1.0)<=0.04,eta_b,1.0)
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, InclusionPostprocessor
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Number of grouped files       = 1
-    set Time between graphical output = 0
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/benchmarks/inclusion/compositional_fields/inclusion_particles.prm.bak b/benchmarks/inclusion/compositional_fields/inclusion_particles.prm.bak
deleted file mode 100644
index 41aa2dc74df..00000000000
--- a/benchmarks/inclusion/compositional_fields/inclusion_particles.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-# A description of the SolVI or Inclusion benchmark using
-# active particles for which a known solution is available.
-# See the manual for more information.
-
-############### Global parameters
-
-set Additional shared libraries            = ./libinclusion_compositional_fields.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
-                                                right : InclusionBoundary, \
-                                                bottom: InclusionBoundary, \
-                                                top   : InclusionBoundary
-end
-
-subsection Material model
-  set Model name = InclusionCompositionalMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Composition polynomial degree                = 2
-  set Stokes velocity polynomial degree            = 2
-  set Use discontinuous composition discretization = true
-  set Use locally conservative discretization      = false
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = viscosity_comp
-  set Compositional field methods = particles
-  set Mapped particle properties = viscosity_comp:function
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = eta_b=1e3, rmax=0.2
-    set Function expression = if((x-1.0)*(x-1.0)+(z-1.0)*(z-1.0)<=0.04,eta_b,1.0)
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, visualization, InclusionPostprocessor
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Number of grouped files       = 1
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = cell average
-  set Maximum particles per cell = 16384
-  set Update ghost particles = true
-  set Particle generator name = reference cell
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = eta_b=1e3, rmax=0.2
-    set Function expression = if((x-1.0)*(x-1.0)+(z-1.0)*(z-1.0)<=0.04,eta_b,1.0)
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 4
-    end
-  end
-end
diff --git a/benchmarks/inclusion/doc/inclusion.prm.bak b/benchmarks/inclusion/doc/inclusion.prm.bak
deleted file mode 100644
index d9a6f297152..00000000000
--- a/benchmarks/inclusion/doc/inclusion.prm.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-############### Global parameters
-
-set Additional shared libraries            = ./libinclusion.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
-                                                right : InclusionBoundary, \
-                                                bottom: InclusionBoundary, \
-                                                top   : InclusionBoundary
-end
-
-subsection Material model
-  set Model name = InclusionMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 6
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = InclusionPostprocessor, visualization
-end
diff --git a/benchmarks/inclusion/global.prm.base.bak b/benchmarks/inclusion/global.prm.base.bak
deleted file mode 100644
index 176659deda1..00000000000
--- a/benchmarks/inclusion/global.prm.base.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-############### Global parameters
-
-set Additional shared libraries            = ./libinclusion.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left  : InclusionBoundary, \
-                                                right : InclusionBoundary, \
-                                                bottom: InclusionBoundary, \
-                                                top   : InclusionBoundary
-end
-
-subsection Material model
-  set Model name = InclusionMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = InclusionPostprocessor, visualization
-end
diff --git a/benchmarks/inclusion/inclusion.cc.bak b/benchmarks/inclusion/inclusion.cc.bak
deleted file mode 100644
index d8ac9d6b466..00000000000
--- a/benchmarks/inclusion/inclusion.cc.bak
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include "inclusion.h"
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(InclusionMaterial,
-                                   "InclusionMaterial",
-                                   "A material model that corresponds to the 'Inclusion' benchmark "
-                                   "defined in Duretz et al., G-Cubed, 2011.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(InclusionBoundary,
-                                            "InclusionBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "``inclusion'' benchmark. See the manual and the Kronbichler, Heister "
-                                            "and Bangerth paper on ASPECT for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(InclusionPostprocessor,
-                                  "InclusionPostprocessor",
-                                  "A postprocessor that compares the solution of the benchmarks from "
-                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
-                                  "and reports the error. Specifically, it can compute the errors for "
-                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
-                                  "which material model is currently being used and adjusts "
-                                  "which exact solution to use accordingly.")
-  }
-}
diff --git a/benchmarks/inclusion/inclusion.h.bak b/benchmarks/inclusion/inclusion.h.bak
deleted file mode 100644
index 9c9a0bb8ed9..00000000000
--- a/benchmarks/inclusion/inclusion.h.bak
+++ /dev/null
@@ -1,356 +0,0 @@
-#ifndef ASPECT_INCLUSION_H
-#define ASPECT_INCLUSION_H
-
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-
-namespace aspect
-{
-  /**
-   * This is the "Pure shear/Inclusion" benchmark defined in the following paper:
-   * @code
-   *  @Article{DMGT11,
-   *    author =       {T. Duretz and D. A. May and T. V. Gerya and P. J. Tackley},
-   *    title =        {Discretization errors and free surface stabilization in the
-   *                  finite difference and marker-in-cell method for applied
-   *                  geodynamics: {A} numerical study},
-   *    journal =      {Geochemistry Geophysics Geosystems},
-   *    year =         2011,
-   *    volume =       12,
-   *    pages =        {Q07004/1--26}}
-   * @endcode
-   *
-   * The results are published in Kronbichler, Heister and Bangerth paper.
-   */
-  namespace InclusionBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-      // based on http://geodynamics.org/hg/cs/AMR/Discontinuous_Stokes with permission
-      void _Inclusion(double pos[2], double r_inclusion, double eta, double *vx, double *vy, double *p)
-      {
-        const double min_eta = 1.0;
-        const double max_eta = eta;
-        const double epsilon = 1; //strain rate
-        const double A(min_eta*(max_eta-min_eta)/(max_eta+min_eta));
-        std::complex<double> phi, psi, dphi;
-        const double offset[2]= {1.0, 1.0};
-        double r2_inclusion = r_inclusion * r_inclusion;
-
-        double x = pos[0]-offset[0];
-        double y = pos[1]-offset[1];
-        double r2 = x*x+y*y;
-
-        std::complex<double> z(x,y);
-        if (r2<r2_inclusion)
-          {
-            //inside the inclusion
-            phi=0;
-            dphi=0;
-            psi=-4*epsilon*(max_eta*min_eta/(min_eta+max_eta))*z;
-          }
-        else
-          {
-            //outside the inclusion
-            phi=-2*epsilon*A*r2_inclusion/z;
-            dphi=-phi/z;
-            psi=-2*epsilon*(min_eta*z+A*r2_inclusion*r2_inclusion/(z*z*z));
-          }
-        double visc = (r2<r2_inclusion)? max_eta : 1.0;
-        std::complex<double> v = (phi - z*conj(dphi) - conj(psi))/(2.0*visc);
-        *vx=v.real();
-        *vy=v.imag();
-        *p=-2*epsilon*dphi.real();
-      }
-
-
-
-      /**
-       * The exact solution for the Inclusion benchmark.
-       */
-      template <int dim>
-      class FunctionInclusion : public Function<dim>
-      {
-        public:
-          FunctionInclusion (double eta_B,
-                             const unsigned int n_compositional_fields)
-            : Function<dim>(dim+2+n_compositional_fields), eta_B_(eta_B) {}
-
-          void vector_value (const Point<dim>   &p,
-                             Vector<double>   &values) const override
-          {
-            double pos[2]= {p(0),p(1)};
-            AnalyticSolutions::_Inclusion
-            (pos,0.2,eta_B_, &values[0], &values[1], &values[2]);
-          }
-
-        private:
-          double eta_B_;
-      };
-    }
-
-
-
-    template <int dim>
-    class InclusionBoundary : public BoundaryVelocity::Interface<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        InclusionBoundary() : eta_B(1e3) {}
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id ,
-                           const Point<dim> &position) const override
-        {
-          Assert (dim == 2, ExcNotImplemented());
-
-          double pos[2]= {position(0),position(1)};
-
-          Tensor<1,dim> velocity;
-          double pressure;
-          AnalyticSolutions::_Inclusion
-          (pos,0.2,eta_B, &velocity[0], &velocity[1], &pressure);
-
-          return velocity;
-        };
-
-      private:
-        double eta_B;
-    };
-
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class InclusionMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> &pos = in.position[i];
-              double r2 = (pos[0]-1.0)*(pos[0]-1.0) + (pos[1]-1.0)*(pos[1]-1.0);
-
-              out.viscosities[i] = (r2<0.2*0.2)? eta_B : 1.0;
-
-              out.densities[i] = 0;
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-              out.entropy_derivative_pressure[i] = 0.0;
-              out.entropy_derivative_temperature[i] = 0.0;
-            }
-        }
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override
-        {
-          return false;
-        }
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm)
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("Inclusion");
-            {
-              prm.declare_entry ("Viscosity jump", "1e3",
-                                 Patterns::Double (0.),
-                                 "Viscosity in the Inclusion.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("Inclusion");
-            {
-              eta_B = prm.get_double ("Viscosity jump");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          // Declare dependencies on solution variables
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-
-
-        /**
-         * Returns the viscosity value in the inclusion
-         */
-        double get_eta_B() const
-        {
-          return eta_B;
-        }
-
-      private:
-        /**
-         * viscosity value in the inclusion
-         */
-        double eta_B;
-    };
-
-
-
-    /**
-     * A postprocessor that evaluates the accuracy of the solution.
-     *
-     * The implementation of error evaluators that correspond to the
-     * benchmarks defined in the paper Duretz et al. reference above.
-     */
-    template <int dim>
-    class InclusionPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &/*statistics*/) override
-        {
-          AssertThrow(Plugins::plugin_type_matches<const InclusionMaterial<dim>>(this->get_material_model()),
-                      ExcMessage("Postprocessor only works with the inclusion material model."));
-
-          const InclusionMaterial<dim> &
-          material_model
-            = Plugins::get_plugin_as_type<const InclusionMaterial<dim>>(this->get_material_model());
-
-          std::unique_ptr<Function<dim>> ref_func
-            = std::make_unique<AnalyticSolutions::FunctionInclusion<dim>>(
-                material_model.get_eta_B(),
-                this->n_compositional_fields());
-
-          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-          Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                              this->get_fe().n_components());
-          ComponentSelectFunction<dim> comp_p(dim,
-                                              this->get_fe().n_components());
-
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_u,
-                                             quadrature_formula,
-                                             VectorTools::L1_norm,
-                                             &comp_u);
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_p,
-                                             quadrature_formula,
-                                             VectorTools::L1_norm,
-                                             &comp_p);
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_ul2,
-                                             quadrature_formula,
-                                             VectorTools::L2_norm,
-                                             &comp_u);
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_pl2,
-                                             quadrature_formula,
-                                             VectorTools::L2_norm,
-                                             &comp_p);
-
-          const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-          const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-          // Compute stokes unknowns, do not include temperature
-          types::global_dof_index n_stokes_dofs = this->introspection().system_dofs_per_block[this->introspection().block_indices.velocities];
-          if (this->introspection().block_indices.velocities != this->introspection().block_indices.pressure)
-            n_stokes_dofs  += this->introspection().system_dofs_per_block[this->introspection().block_indices.pressure];
-
-          std::ostringstream os;
-          os << n_stokes_dofs << "; "
-             << std::scientific << u_l1
-             << ", " << p_l1
-             << ", " << u_l2
-             << ", " << p_l2;
-
-          return std::make_pair("DoFs; Errors u_L1, p_L1, u_L2, p_L2:", os.str());
-        }
-    };
-  }
-}
-#endif
diff --git a/benchmarks/infill_density/infill_ascii.prm.bak b/benchmarks/infill_density/infill_ascii.prm.bak
deleted file mode 100644
index dbed3116c5c..00000000000
--- a/benchmarks/infill_density/infill_ascii.prm.bak
+++ /dev/null
@@ -1,217 +0,0 @@
-# This model demonstrates ASPECT's ability to be used to
-# model load induced flexure from a topographic feature
-# on top of the lithosphere. The model uses the viscoelastic
-# material model and is composed of an 'elastic' high viscosity
-# lithosphere and a low viscosity mantle beneath the elastic
-# lithosphere. A time dependent axisymmetric box load is applied
-# to the top boundary using ASCII files, with the center of the load
-# at the left boundary of the 2D cartesian model domain. The model
-# is run for 120'000 years, which is equivalent to 40*tm:
-# tm = eta_m / mu
-# eta_m = mantle viscosity
-# mu = elastic shear modulus
-# tm is the time scale of viscous stress relaxation for the mantle.
-# This allows for virtually all stresses in the mantle to be relaxed
-# and for the elastic lithosphere to be fully compensating the load.
-# The analytic solution for this setup is outlined in the Generic
-# Mapping Tools function grdflexure:
-# <https://docs.generic-mapping-tools.org/6.1/supplements/potential/grdflexure.html>
-
-#  Global parameters
-set Additional shared libraries            = ./libinfill_density.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 120e3
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set CFL number                             = 0.1
-set Maximum time step                      = 750
-set Output directory                       = output
-set Pressure normalization                 = no
-
-# Model geometry (1200x1200 km, 80 km spacing in x direction, 40km spacing in y direction)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 30
-    set X extent      = 1200e3
-    set Y extent      = 1200e3
-  end
-end
-
-# Mesh refinement specifications
-# Refine the mesh in the uppermost part of the model
-# to better capture lithospheric response to the load.
-# (10x5km mesh in the lithosphere)
-subsection Mesh refinement
-  set Initial adaptive refinement              = 2
-  set Initial global refinement                = 1
-  set Time steps between mesh refinement       = 1
-  set Minimum refinement level                 = 0
-  set Strategy                                 = minimum refinement function, strain rate
-
-  subsection Minimum refinement function
-    set Coordinate system                      = cartesian
-    set Variable names                         = x,y,t
-    set Function expression                    = if(y>=1050e3, 3, 0)
-  end
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree           = 2
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 1
-  set Use locally conservative discretization = true
-  set Use discontinuous temperature discretization = false
-
-  # Discontinuous (DG) elements are used for compositional fields to more accurately track
-  # the lithosphere-asthenosphere boundary.
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-    set Global composition maximum =  1.e13,  1.e13,  1.e13, 1.0
-    set Global composition minimum = -1.e13, -1.e13, -1.e13, 0.0
-  end
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-  set Additional tangential mesh velocity boundary indicators = left, right
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-end
-
-# Velocity boundary conditions
-# The left boundary is set to free slip to allow the lithosphere
-# to vertically deform along this boundary and act as mirror plane
-# for the other 'half' of the load.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left
-end
-
-# Prescribe a fixed vertical traction on the top boundary
-# The right boundary is open in order to allow outflow of the
-# mantle as lithospheric flexure pushes the mantle to the right.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = top y: infill ascii data, right: initial lithostatic pressure
-
-  subsection Infill ascii data
-    set Rock density = 2000
-    set Sediment density = 2000
-    set Height for specifying rock infill = 0
-
-    subsection Ascii data model
-      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/infill_density/data/
-      set First data file model time = 0
-      set Data file name = box_2d_%s.%d.txt
-      set Data file time step = 750
-    end
-  end
-
-  subsection Initial lithostatic pressure
-    set Representative point = 1200e3, 0
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, lithosphere
-end
-
-#Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; if(y>=1125e3, 1, 0)
-  end
-end
-
-#Composition boundary conditions
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# Temperature initial conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 3300
-
-    # The first valueis assigned to the mantle and the next three are assigned to the compositional
-    # fields representing viscoelastic stresses, but significantly these values are not used in the
-    # viscosity calculation (i.e., only values representing lithologies are used). Respectively, the
-    # fourth and fifth values are assigned to the compositional fields representing the lithosphere.
-    set Viscosities                 = 1.e21, 1.e21, 1.e21, 1.e21, 1.e26
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = true
-    set Fixed elastic time step     = 7500
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, temperature statistics, topography, velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate, shear stress, boundary indicators
-    set Number of grouped files = 1
-    set Time between graphical output = 7500
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = viscosity
-    end
-  end
-
-  subsection Topography
-    set Output to file = true
-    set Time between text output = 7500
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/benchmarks/infill_density/infill_ascii_data.cc.bak b/benchmarks/infill_density/infill_ascii_data.cc.bak
deleted file mode 100644
index 92c66e10a1d..00000000000
--- a/benchmarks/infill_density/infill_ascii_data.cc.bak
+++ /dev/null
@@ -1,267 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_traction/ascii_data.h>
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements prescribed traction boundary conditions determined
-     * from pressures given in an AsciiData input file.
-     *
-     * @ingroup BoundaryTractions
-     */
-    template <int dim>
-    class InfillAsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        InfillAsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataBoundary<dim>::initialize;
-
-        /**
-         * Return the boundary traction as a function of position. The
-         * (outward) normal vector to the domain is also provided as
-         * a second argument.
-         */
-        Tensor<1,dim>
-        boundary_traction (const types::boundary_id surface_boundary_id,
-                           const Point<dim> &position,
-                           const Tensor<1,dim> &normal_vector) const override;
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the boundary values will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        types::boundary_id surface_boundary_id;
-        double rock_density;
-        double sediment_density;
-        double crustal_density;
-        double rock_infill_height;
-    };
-
-    template <int dim>
-    InfillAsciiData<dim>::InfillAsciiData ()
-      :
-      surface_boundary_id(numbers::invalid_unsigned_int)
-    {}
-
-
-    template <int dim>
-    void
-    InfillAsciiData<dim>::initialize ()
-    {
-      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-      std::set<types::boundary_id> surface_boundary_set;
-      surface_boundary_set.insert(surface_boundary_id);
-
-      // The input ascii table contains one data column (Traction [Pa]) due to
-      // the load in addition to the coordinate columns.
-      Utilities::AsciiDataBoundary<dim>::initialize(surface_boundary_set,
-                                                    1);
-    }
-
-
-    template <int dim>
-    Tensor<1,dim>
-    InfillAsciiData<dim>::
-    boundary_traction (const types::boundary_id surface_boundary_id,
-                       const Point<dim> &position,
-                       const Tensor<1,dim> &normal_vector) const
-    {
-      const double load = Utilities::AsciiDataBoundary<dim>::get_data_component(surface_boundary_id,
-                                                                                position,
-                                                                                0);
-      Tensor<1, dim> traction = normal_vector;
-      const double gravity_norm = this->get_gravity_model().gravity_vector(position).norm();
-      const double elevation = this->get_geometry_model().height_above_reference_surface(position);
-
-      // Check if the load at the current point has a height which exceeds the
-      // 'rock_infill height'. The assumption is that the values taken from the
-      // ASCII file are specifying the part of the load that is above the undeformed
-      // reference surface. If we consider a seamount as the load, the ASCII
-      // file takes the bathymetry of the seamount and provides it as a traction.
-      // However, the volcanic rock comprising the seamount also fills in the
-      // flexural moat, providing an additional traction. Since it is much harder to
-      // specify this traction, 'rock_infill_height' determines where the rock_density
-      // that the seamount is made of will infill the flexural moat, and where
-      // sediment_density will infill the flexural moat. For this test, this
-      // variable is not that important given the idealized load, but this is useful
-      // when using more complicated bathymetry maps where small scale seafloor
-      // features makes it unrealistic to set rock_infill_height=0.
-      if (load >= rock_infill_height*gravity_norm*rock_density)
-        {
-          traction = (-load + elevation*gravity_norm*rock_density) * normal_vector;
-        }
-      else
-        {
-          traction = (-load + elevation*gravity_norm*sediment_density) * normal_vector;
-        }
-      return traction;
-    }
-
-
-    template <int dim>
-    void
-    InfillAsciiData<dim>::update()
-    {
-      Interface<dim>::update ();
-      Utilities::AsciiDataBoundary<dim>::update();
-    }
-
-
-    template <int dim>
-    void
-    InfillAsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary traction model");
-      {
-        // Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
-        //                                                       "$ASPECT_SOURCE_DIR/tests/infill_density/",
-        //                                                       "box_2d_%s.%d.txt");
-        prm.enter_subsection("Infill ascii data");
-        {
-          Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
-                                                                "$ASPECT_SOURCE_DIR/tests/infill_density/",
-                                                                "box_2d_%s.%d.txt");
-          prm.declare_entry ("Rock density", "2800",
-                             Patterns::Double(0.),
-                             "Density of the volcanic edifice that infills the flexural moat.");
-          prm.declare_entry ("Sediment density", "2300",
-                             Patterns::Double(0.),
-                             "Density of the sediment that infills the flexural moat.");
-          prm.declare_entry ("Height for specifying rock infill", "500",
-                             Patterns::Double(0.),
-                             "If the load defined in the ASCII file has a height equal to or greater than "
-                             "the Height for specifying rock infill, then the infill material will be rock, "
-                             "otherwise it will be sediment");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    InfillAsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary traction model");
-      {
-        // Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
-        prm.enter_subsection("Infill ascii data");
-        {
-          Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
-          rock_density = prm.get_double("Rock density");
-          sediment_density = prm.get_double("Sediment density");
-          rock_infill_height = prm.get_double("Height for specifying rock infill");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(InfillAsciiData,
-                                            "infill ascii data",
-                                            "Implementation of a model in which the boundary "
-                                            "traction is derived from files containing pressure data "
-                                            "in ascii format. This model differs from the normal ascii data "
-                                            "model as the pressure given in the data file is summed with another "
-                                            "traction that depends on the current state of flexure in the model. "
-                                            "The traction sum is applied normal to the surface of a given boundary, "
-                                            "pointing inwards. Note the required format of the "
-                                            "input data: The first lines may contain any number of comments "
-                                            "if they begin with `#', but one of these lines needs to "
-                                            "contain the number of grid points in each dimension as "
-                                            "for example `# POINTS: 3 3'. "
-                                            "The order of the data columns "
-                                            "has to be `x', `Pressure [Pa]' in a 2d model and "
-                                            " `x', `y', `Pressure [Pa]' in a 3d model, which means that "
-                                            "there has to be a single column "
-                                            "containing the pressure. "
-                                            "Note that the data in the input "
-                                            "files need to be sorted in a specific order: "
-                                            "the first coordinate needs to ascend first, "
-                                            "followed by the second in order to "
-                                            "assign the correct data to the prescribed coordinates. "
-                                            "If you use a spherical model, "
-                                            "then the data will still be handled as Cartesian, "
-                                            "however the assumed grid changes. `x' will be replaced by "
-                                            "the radial distance of the point to the bottom of the model, "
-                                            "`y' by the azimuth angle and `z' by the polar angle measured "
-                                            "positive from the north pole. The grid will be assumed to be "
-                                            "a latitude-longitude grid. Note that the order "
-                                            "of spherical coordinates is `r', `phi', `theta' "
-                                            "and not `r', `theta', `phi', since this allows "
-                                            "for dimension independent expressions.")
-  }
-}
diff --git a/benchmarks/king2dcompressible/ala.prm.bak b/benchmarks/king2dcompressible/ala.prm.bak
deleted file mode 100644
index 0bb0a4f018a..00000000000
--- a/benchmarks/king2dcompressible/ala.prm.bak
+++ /dev/null
@@ -1,184 +0,0 @@
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# We can use a large CFL number because we are only interested in the
-# steady state solution.
-set CFL number = 5.0
-set Additional shared libraries            = ./plugin/libking.so
-
-# This is the non-dimensionalized surface temperature, which is the
-# ratio of the dimensional surface temperature T_surf = 273 K and
-# the temperature change across the domain DeltaT = 3000 K.
-set Adiabatic surface temperature          = 0.091
-set Use years in output instead of seconds = false
-set End time                               = 10
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Discretization
-  subsection Stabilization parameters
-    set alpha                                              = 2
-    set beta                                               = 0.005
-    set cR                                                 = 0.033
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria = end time, steady state velocity
-
-  subsection Steady state velocity
-    set Maximum relative deviation = 1e-7
-    set Time in steady state       = 1
-  end
-end
-
-# In this section we define the adiabatic profiles of temperature,
-# pressure and density. The temperature and density profiles are
-# equivalent to the reference profiles bar(T) and bar(rho) defined
-# in the King 2010 benchmark.
-# gamma is the grueneisen parameter, which defines the compressibility
-# of the material, and we have to choose the same value for gamma as
-# in the material model below.
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=1.0, gamma=1.0
-    set Function expression = 0.091*exp(depth*Di); gamma/Di*(exp(depth*Di/gamma)-1); exp(depth*Di/gamma)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-# The King benchmark uses the anelastic liquid approximation.
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
-
-# The benchmark is defined in terms of the nondimensional numbers
-# Di (dissipation number) and Ra (Rayleigh number).
-# As ASPECT uses physical properties instead of these dimensionless
-# numbers in its equations, we replicate the benchmark formulation
-# by using a new material model that fixes all of the material
-# constants to 1, except for the thermal expansivity, which is set
-# to Di, and the viscosity, which is set to Di/Ra.
-subsection Material model
-  set Model name = king material
-
-  subsection King model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-
-    # The value of the Rayleigh number Ra.
-    set Ra                            = 1e4
-
-    # The dissipation number Di determines the slope of the
-    # adiabatic/reference temperature profile.
-    # For the Boussinesq approximation, Di would be zero.
-    set Di                            = 1.0
-    set b                             = 0
-    set c                             = 0
-    set gamma                         = 1.0
-  end
-end
-
-# The model domain is the unit square.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# We choose a linear initial temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression =  1* ((1.0-z/L) + p*cos(k*pi*x/L/1.0)*sin(pi*z/L)) +0.091
-  end
-end
-
-# We prescibe the adiabatic surface temperature as top temperature
-# and the (nondimensional) temperature change across the boundary
-# is set to 1 (with no flux conditions at the sides).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Top temperature    = 0.091
-    set Bottom temperature = 1.091
-    set Left temperature   = 0
-    set Right temperature  = 0
-  end
-end
-
-# The velocity boundary conditions are free slip on all boundaries.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-# This subsection describes which heating models we want to use.
-# This benchmark includes adiabatic heating and shear heating.
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    # A flag indicating whether the adiabatic heating should be simplified
-    # from $\alpha T (\mathbf u \cdot \nabla p)$
-    # to $ \alpha \rho T (\mathbf u \cdot \mathbf g) $.
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-# As we are only interested in the steady state, we start on a
-# coarse mesh and refine once the solution is close to steady state.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 1.0
-end
-
-# In addition to some general postprocessing, we output
-# velocity statistics (needed for the root mean square velocity),
-# temperature statistics (needed for the average temperature),
-# heat flux statistics using the CBF method (needed for the Nusselt number) and
-# heating statistics (needed for shear and adiabatic heating).
-# We also include a simpler heat flux statistics postprocessor
-# that illustrates the superiority of the CBF method in the default
-# heat flux statistics postprocessor.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heat flux statistics gradient, visualization, depth average, heating statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e-2
-    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
-  end
-end
-
-# We would like the benchmark to converge to very high accuracy,
-# so we tighten the linear solver tolerance compared to default of 1e-7.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-9
-  end
-end
diff --git a/benchmarks/king2dcompressible/plugin/code.cc.bak b/benchmarks/king2dcompressible/plugin/code.cc.bak
deleted file mode 100644
index f0099ccc8ad..00000000000
--- a/benchmarks/king2dcompressible/plugin/code.cc.bak
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/global.h>
-
-#include <aspect/material_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  /**
-   * This benchmark is from the article
-   * @code
-   * @article{KLKLZTTK10,
-   *   title={A community benchmark for 2-{D} {C}artesian compressible
-   *          convection in the {E}arth's mantle},
-   *   author={King, Scott D and Lee, Changyeol and Van Keken, Peter E
-   *           and Leng, Wei and Zhong, Shijie and Tan, Eh and Tosi, Nicola
-   *           and Kameyama, Masanori C},
-   *   journal={Geophysical Journal International},
-   *   volume={180},
-   *   number={1},
-   *   pages={73--87},
-   *   year={2010},
-   *   publisher={Oxford University Press}
-   * }
-   * @endcode
-   */
-
-
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    class Material : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-        * Evaluate material properties.
-        */
-        void evaluate(const MaterialModelInputs<dim> &in,
-                      MaterialModelOutputs<dim> &out) const override
-        {
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> position = in.position[i];
-              const double temperature = in.temperature[i];
-              const double pressure = in.pressure[i];
-
-              const double depth = 1.0-position(dim-1);
-
-              out.viscosities[i] = ((Di==0.0)?1.0:Di)/Ra*exp(-b*(temperature- this->get_adiabatic_conditions().temperature(position))+c*depth);
-
-              out.specific_heat[i] = reference_specific_heat;
-              out.thermal_conductivities[i] = 1.0;
-              out.thermal_expansion_coefficients[i] = (Di==0.0)?1.0:Di;
-
-              double rho = reference_rho * exp(depth * Di/gamma);
-              rho *= 1.0 - out.thermal_expansion_coefficients[i] * (temperature - this->get_adiabatic_conditions().temperature(position))
-                     + (tala?0.0:1.0)*Di*gamma
-                     *  (pressure - this->get_adiabatic_conditions().pressure(position));
-
-              out.densities[i] = rho;
-
-              out.compressibilities[i] = 0.0;
-              out.entropy_derivative_pressure[i] = 0.0;
-              out.entropy_derivative_temperature[i] = 0.0;
-              // Change in composition due to chemical reactions at the
-              // given positions. The term reaction_terms[i][c] is the
-              // change in compositional field c at point i.
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                out.reaction_terms[i][c] = 0.0;
-            }
-        }
-
-        bool is_compressible () const override
-        {
-          return true;
-        }
-
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-
-        /**
-         * @}
-         */
-
-      private:
-
-        bool tala;
-
-        /**
-         * Parameters describing temperature and depth-dependence
-         * of viscosity.
-         */
-        double b, c;
-
-        /**
-         * The surface density.
-         */
-        double reference_rho;
-
-        /**
-         * The nondimensional numbers (Dissipation number,
-         * Rayleigh number, grueneisen parameter).
-         */
-        double Di, Ra, gamma;
-
-        /**
-         * The constant specific heat
-         */
-        double reference_specific_heat;
-    };
-
-
-
-    template <int dim>
-    void
-    Material<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("King model");
-        {
-          prm.declare_entry ("Reference density", "3300",
-                             Patterns::Double (0),
-                             "Reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Ra", "1e4",
-                             Patterns::Double (0),
-                             "");
-          prm.declare_entry ("Di", "0.0",
-                             Patterns::Double (0),
-                             "");
-          prm.declare_entry ("gamma", "1.0",
-                             Patterns::Double (0),
-                             "");
-          prm.declare_entry ("Reference specific heat", "1250",
-                             Patterns::Double (0),
-                             "The value of the specific heat $cp$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("b", "6.907755279",
-                             Patterns::Double (0),
-                             "");
-          prm.declare_entry ("c", "0",
-                             Patterns::Double (0),
-                             "");
-          prm.declare_entry ("Use TALA", "false",
-                             Patterns::Bool (),
-                             "Whether to use the TALA instead of the ALA "
-                             "approximation.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Material<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("King model");
-        {
-          reference_rho   = prm.get_double ("Reference density");
-          b               = prm.get_double ("b");
-          c               = prm.get_double ("c");
-          Di              = prm.get_double ("Di");
-          Ra              = prm.get_double ("Ra");
-          gamma           = prm.get_double ("gamma");
-
-          tala            = prm.get_bool ("Use TALA");
-
-          reference_specific_heat = prm.get_double ("Reference specific heat");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature;
-      this->model_dependence.density = NonlinearDependence::none;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-    }
-  }
-
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Material,
-                                   "king material",
-                                   "A simple compressible material model based on a benchmark "
-                                   "from the paper of King et al. (2010). It uses the "
-                                   "nondimensional numbers Di, Ra and gamma to define material "
-                                   "properties.")
-  }
-
-}
diff --git a/benchmarks/layeredflow/layeredflow.cc.bak b/benchmarks/layeredflow/layeredflow.cc.bak
deleted file mode 100644
index 2f1c3bc6fac..00000000000
--- a/benchmarks/layeredflow/layeredflow.cc.bak
+++ /dev/null
@@ -1,404 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  namespace LayeredFlowBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-
-      Tensor<1,2>
-      LayeredFlow_velocity (const Point<2> &pos,
-                            const double beta,
-                            const double epsilon)
-      {
-        const double y0 = 1./3.;
-        const double yplus=(1.+y0)/beta;
-        const double yminus=(1.-y0)/beta;
-        const double C1 = 2.*numbers::PI /
-                          ( beta*std::log(beta*beta+pow(1.+y0,2.0))-2.*(1.+y0)*std::atan(yplus)
-                            - beta*std::log(beta*beta+pow(1.-y0,2.0))+2.*(1.-y0)*std::atan(yminus)
-                            + 2.*numbers::PI*(1.+2.*epsilon) );
-
-        const double C2 = ( beta*std::log( beta*beta+std::pow(1+y0,2.) )- 2.*(1.+y0)*std::atan(yplus)
-                            + numbers::PI*(1.+2.*epsilon) )*C1 ;
-        const double y = pos[1]-1.0;
-        const double v_x = (-beta*C1*std::log(beta*beta+std::pow(y-y0,2.0))+2.*(y-y0)*C1*std::atan((y-y0)/beta)
-                            + numbers::PI*(1.+2.*epsilon)*y*C1+C2)/(2.*numbers::PI);
-        const double v_y = 0;
-        return Point<2> (v_x,v_y);
-      }
-
-      double
-      LayeredFlow_pressure (const Point<2> &,
-                            const double &,
-                            const double)
-      {
-        return 0;
-      }
-
-
-      template <int dim>
-      class FunctionLayeredFlow : public Function<dim>
-      {
-        public:
-          FunctionLayeredFlow (const double beta, const double epsilon)
-            :
-            Function<dim>(dim+2),
-            beta_(beta),
-            epsilon_(epsilon)
-          {}
-
-          void vector_value (const Point<dim>   &pos,
-                             Vector<double>   &values) const override
-          {
-            Assert (dim == 2, ExcNotImplemented());
-            Assert (values.size() >= 4, ExcInternalError());
-
-            const Point<2> p (pos[0], pos[1]);
-
-            const Tensor<1,2> v = AnalyticSolutions::LayeredFlow_velocity (p, beta_, epsilon_);
-            values[0] = v[0];
-            values[1] = v[1];
-            values[2] = AnalyticSolutions::LayeredFlow_pressure (p, beta_, epsilon_);
-          }
-
-        private:
-          const double beta_;
-          const double epsilon_;
-      };
-    }
-
-
-    template <int dim>
-    class LayeredFlowBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        LayeredFlowBoundary();
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id ,
-                           const Point<dim> &position) const override;
-
-      private:
-        const double beta;
-        const double epsilon;
-    };
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class LayeredFlowMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> &pos = in.position[i];
-
-              const double y = pos[1]-1.0;
-              const double y0 = 1./3.;
-              out.viscosities[i] = 1.0/(std::atan((y-y0)/beta)/numbers::PI + 0.5 + epsilon);
-              out.densities[i] = 1;
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-
-        /**
-         * Returns the viscosity value in the inclusion
-         */
-        double get_beta() const;
-        double get_epsilon() const;
-
-        /**
-         * viscosity value in the inclusion
-         */
-        double beta;
-        double epsilon;
-    };
-
-
-    template <int dim>
-    bool
-    LayeredFlowMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    LayeredFlowMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      //create a global section in the parameter file for parameters
-      //that describe this benchmark. note that we declare them here
-      //in the material model, but other kinds of plugins (e.g., the gravity
-      //model below) may also read these parameters even though they do not
-      //declare them
-      prm.enter_subsection("LayeredFlow benchmark");
-      {
-        prm.declare_entry("Viscosity parameter beta", "1",
-                          Patterns::Double (),
-                          "Viscosity parameter beta in the LayeredFlow benchmark.");
-        prm.declare_entry("Viscosity parameter epsilon", "0.1",
-                          Patterns::Double (),
-                          "Viscosity parameter epsilon in the LayeredFlow benchmark.");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    LayeredFlowMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("LayeredFlow benchmark");
-      {
-        beta = prm.get_double ("Viscosity parameter beta");
-        epsilon = prm.get_double ("Viscosity parameter epsilon");
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-
-    template <int dim>
-    double
-    LayeredFlowMaterial<dim>::get_beta() const
-    {
-      return beta;
-    }
-
-    template <int dim>
-    double
-    LayeredFlowMaterial<dim>::get_epsilon() const
-    {
-      return epsilon;
-    }
-
-    template <int dim>
-    LayeredFlowBoundary<dim>::LayeredFlowBoundary ()
-      :
-      beta (0),
-      epsilon (0)
-    {}
-
-
-
-    template <>
-    Tensor<1,2>
-    LayeredFlowBoundary<2>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<2> &p) const
-    {
-      const LayeredFlowMaterial<2> &
-      material_model
-        = Plugins::get_plugin_as_type<const LayeredFlowMaterial<2>>(this->get_material_model());
-
-      return AnalyticSolutions::LayeredFlow_velocity (p, material_model.get_beta(),
-                                                      material_model.get_epsilon());
-    }
-
-
-
-    template <>
-    Tensor<1,3>
-    LayeredFlowBoundary<3>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<3> &) const
-    {
-      Assert (false, ExcNotImplemented());
-      return Tensor<1,3>();
-    }
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the manual.
-      */
-    template <int dim>
-    class LayeredFlowPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    LayeredFlowPostprocessor<dim>::execute (TableHandler &)
-    {
-      std::unique_ptr<Function<dim>> ref_func;
-      {
-        const LayeredFlowMaterial<dim> &
-        material_model
-          = Plugins::get_plugin_as_type<const LayeredFlowMaterial<dim>>(this->get_material_model());
-
-        ref_func = std::make_unique<AnalyticSolutions::FunctionLayeredFlow<dim>>(material_model.get_beta(),
-                                                                                  material_model.get_epsilon());
-      }
-
-      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                          dim+2);
-      ComponentSelectFunction<dim> comp_p(dim, dim+2);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_ul2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_pl2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-      std::ostringstream os;
-      os << std::scientific <<  u_l2
-         << ", " << p_l2;
-
-      return std::make_pair("Errors u_L2, p_L2:", os.str());
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace LayeredFlowBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(LayeredFlowMaterial,
-                                   "LayeredFlowMaterial",
-                                   "A material model that corresponds to the `LayeredFlow' benchmark. "
-                                   "See the manual for more information.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(LayeredFlowBoundary,
-                                            "LayeredFlowBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "`LayeredFlow' benchmark. See the manual for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(LayeredFlowPostprocessor,
-                                  "LayeredFlowPostprocessor",
-                                  "A postprocessor that compares the solution of the `LayeredFlow' benchmark "
-                                  "with the one computed by ASPECT "
-                                  "and reports the error. See the manual for more information.")
-  }
-}
diff --git a/benchmarks/layeredflow/layeredflow.prm.bak b/benchmarks/layeredflow/layeredflow.prm.bak
deleted file mode 100644
index b0152284960..00000000000
--- a/benchmarks/layeredflow/layeredflow.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-############### Global parameters
-
-set Additional shared libraries            = ./liblayeredflow.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0  : LayeredFlowBoundary, \
-                                                1  : LayeredFlowBoundary, \
-                                                2  : LayeredFlowBoundary, \
-                                                3  : LayeredFlowBoundary
-end
-
-subsection Material model
-  set Model name = LayeredFlowMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection LayeredFlow benchmark
-  set Viscosity parameter beta = 0.001
-  set Viscosity parameter epsilon = 0.05
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, LayeredFlowPostprocessor
-
-  subsection Visualization
-    set List of output variables = viscosity, strain rate
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm.bak
deleted file mode 100644
index ca7b64af468..00000000000
--- a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Output directory = results/b1SNL_BTt_NS_ST1e-20_UFSfalse_NSP-SPD_NSA-SPD_C0_g6_ag0_AEWfalse_UDStrue_SF9e-1_NLT1e-14_ABT1e-2_LT1e-5_mLT9e-1_I150_P5_EW1_theta1_LS0_RSMtrue_AV-1_phi0_vel0_BV1e19_n5
-set Dimension = 2
-set CFL number                             = 1.0
-set Maximum time step                      = 1
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = iterated Advection and Newton Stokes
-set Max nonlinear iterations = 150
-set Nonlinear solver tolerance = 1e-14
-set Additional shared libraries = libsimple_nonlinear.so
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-5
-  end
-
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 5
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 0
-    set Maximum linear Stokes solver tolerance = 9e-1
-    set Use Newton residual scaling method = true
-    set Use Newton failsafe = false
-    set Stabilization preconditioner = SPD
-    set Stabilization velocity block = SPD
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10e3
-    set Y extent = 8e3
-    set Y repetitions = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple nonlinear
-
-  subsection Simple nonlinear
-    set Minimum viscosity = 1e19
-    set Maximum viscosity = 1e25
-    set Stress exponent = 5
-    set Viscosity averaging p = 10000
-    set Viscosity prefactor = 1e-37
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 2 y: function, 3 y: function # pressure bc: Prescribe a horizontal traction on the vertical boundaries
-
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 0;if(z>0,0,1e9)
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1
-  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
-
-  subsection Function
-    set Function constants = n = 5
-    set Variable names = x,z
-
-    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
-    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
-
-  subsection Depth average
-    set List of output variables = viscosity
-  end
-
-  subsection Visualization
-    set List of output variables = material properties,strain rate, spd factor
-
-    #    set Output format = gnuplot
-    set Time between graphical output = 2
-  end
-end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t_gmg.prm.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t_gmg.prm.bak
deleted file mode 100644
index 9350829516d..00000000000
--- a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t_gmg.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# Like the newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
-# benchmark, but use GMG instead.
-
-include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
-
-set Additional shared libraries = libsimple_nonlinear.so
-set Output directory = results/output-t-gmg
-
-subsection Material model
-  set Material averaging = harmonic average
-end
-
-subsection Solver parameters
-  subsection Matrix Free
-    set Output details = true
-  end
-
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm.bak
deleted file mode 100644
index 37534cc3107..00000000000
--- a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Output directory = a2_itIMPES_ST1e-20_UFSfalse_NSP-SPD_NSA-none_C0_g6_ag0_AEWfalse_SF9e-1_NLT1e-14_ABT1e-2_LT1e-5_mLT9e-1_I150_P3_EW1_theta1_LS5_RSMfalse_AV-1_n5
-set Dimension = 2
-set CFL number                             = 1.0
-set Maximum time step                      = 1
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = iterated Advection and Stokes #Newton Stokes
-set Max nonlinear iterations = 150
-set Nonlinear solver tolerance = 1e-14
-set Additional shared libraries = libsimple_nonlinear.so
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-15
-  end
-
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 3
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 5
-    set Maximum linear Stokes solver tolerance = 9e-1
-    set Use Newton residual scaling method = false
-    set Use Newton failsafe = false
-    set Stabilization preconditioner = SPD
-    set Stabilization velocity block = none
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10e3
-    set Y extent = 8e3
-    set Y repetitions = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple nonlinear
-
-  subsection Simple nonlinear
-    set Minimum viscosity = 1e19
-    set Maximum viscosity = 1e24
-    set Stress exponent = 5
-    set Viscosity averaging p = 10000
-    set Viscosity prefactor = 1e-37
-    set Use deviator of strain-rate = false
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1
-  set Prescribed velocity boundary indicators = 2: function, 3: function # velocity bc
-
-  subsection Function
-    set Function constants = n = 5
-    set Variable names = x,z
-
-    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
-    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-(abs(x-(5e3))^(n+1)));
-  end
-end
-
-subsection Boundary traction model
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 0;if(z>0,0,1e9)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
-
-  subsection Depth average
-    set List of output variables = viscosity
-  end
-
-  subsection Visualization
-    set List of output variables = material properties,strain rate#, spd factor
-
-    #    set Output format = gnuplot
-    set Time between graphical output = 2
-  end
-end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v_gmg.prm.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v_gmg.prm.bak
deleted file mode 100644
index de4a4b69a82..00000000000
--- a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v_gmg.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# Like the newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm
-# benchmark, but use GMG instead.
-
-include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_v.prm
-
-set Additional shared libraries = libsimple_nonlinear.so
-set Output directory = results/output-v-gmg
-
-subsection Material model
-  set Material averaging = harmonic average
-end
-
-subsection Solver parameters
-  subsection Matrix Free
-    set Output details = true
-  end
-
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc.bak b/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc.bak
deleted file mode 100644
index 8f72dd39357..00000000000
--- a/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc.bak
+++ /dev/null
@@ -1,404 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/newton.h>
-
-#include <iostream>
-
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model based on a simple power law rheology and
-     * implementing the derivatives needed for the Newton method.
-     *
-     * Power law equation to compute the viscosity $\eta$ per composition:
-     * $\eta = A^{\frac{-1}{n}} * \left(2.0 * \dot\varepsilon_{II}\right)
-     * ^{\frac{1}{n}-1}$ where $A$ is the prefactor, $\dot\varepsion$ is
-     * the strain-rate, II indicates the square root of the second invariant
-     * defined as $\frac{1}{2} \dot\varepsilon_{ij} \dot\varepsilon_{ij}$,
-     * and $n$ is the stress exponent.
-     *
-     * The viscosities per composition are averaged using the
-     * utilities weighted p-norm function. The volume fractions are used
-     * as weights for the averaging.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class SimpleNonlinear : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * This material model is incompressible.
-         */
-        bool is_compressible () const override;
-
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * For calculating density by thermal expansivity. Units: $\\si{\\kelvin}$
-         */
-        double reference_temperature;
-
-        /**
-         * Defining a minimum strain rate stabilizes the viscosity calculation,
-         * which involves a division by the strain rate. Units: $\\si{\\per\\second}$.
-         */
-        std::vector<double> min_strain_rate;
-        std::vector<double> min_viscosity;
-        std::vector<double> max_viscosity;
-
-        std::vector<double> thermal_diffusivity;
-        std::vector<double> heat_capacity;
-
-
-        std::vector<double> densities;
-        std::vector<double> thermal_expansivities;
-
-
-        std::vector<double> viscosity_prefactor;
-        std::vector<double> stress_exponent;
-
-        unsigned int n_fields;
-        /**
-         * averaging parameters used for the power exponent
-         * in the Utilities::weighted_p_norm_average and
-         * Utilities::derivative_of_weighted_p_norm_average.
-         */
-        double viscosity_averaging_p;
-
-        bool use_deviator_of_strain_rate;
-    };
-  }
-}
-
-
-
-using namespace dealii;
-
-namespace aspect
-{
-
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    SimpleNonlinear<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      //set up additional output for the derivatives
-      MaterialModelDerivatives<dim> *derivatives = out.template get_additional_output<MaterialModelDerivatives<dim>>();
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double temperature = in.temperature[i];
-
-          // Averaging composition-field dependent properties
-          // Compositions
-          //This assert may be help when designing tests for this material model
-          AssertThrow(in.composition[i].size()+1 == n_fields,
-                      ExcMessage("Number of compositional fields + 1 not equal to number of fields given in input file."));
-
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
-          double density = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            {
-              //not strictly correct if thermal expansivities are different, since we are interpreting
-              //these compositions as volume fractions, but the error introduced should not be too bad.
-              const double temperature_factor = (1.0 - thermal_expansivities[c] * (temperature - reference_temperature));
-              density += volume_fractions[c] * densities[c] * temperature_factor;
-            }
-
-          // thermal expansivities
-          double thermal_expansivity = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            thermal_expansivity += volume_fractions[c] * thermal_expansivities[c];
-
-          // Specific heat at the given positions.
-          double specific_heat = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            specific_heat += volume_fractions[c] * heat_capacity[c];
-
-          // Thermal conductivity at the given positions.
-          double thermal_conductivities = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            thermal_conductivities += volume_fractions[c] * thermal_diffusivity[c] * heat_capacity[c] * densities[c];
-
-          // calculate effective viscosity
-          if (in.requests_property(MaterialProperties::viscosity))
-            {
-              // This function calculates viscosities assuming that all the compositional fields
-              // experience the same strain rate (isostrain). Since there is only one process in
-              // this material model (a general powerlaw) we do not need to worry about how to
-              // distribute the strain-rate and stress over the processes.
-              std::vector<double> composition_viscosities(volume_fractions.size());
-
-              std::vector<SymmetricTensor<2,dim>> composition_viscosities_derivatives(volume_fractions.size());
-
-              for (unsigned int c=0; c < volume_fractions.size(); ++c)
-                {
-                  // If strain rate is zero (like during the first time step) set it to some very small number
-                  // to prevent a division-by-zero, and a floating point exception.
-                  // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
-                  // strain rate (often simplified as epsilondot_ii)
-                  const SymmetricTensor<2,dim> edot = use_deviator_of_strain_rate ? deviator(in.strain_rate[i]) : in.strain_rate[i];
-                  const double edot_ii_strict = std::sqrt(0.5*edot*edot);
-                  const double edot_ii = 2.0 * std::max(edot_ii_strict, min_strain_rate[c]);
-
-                  const double stress_exponent_inv = 1/stress_exponent[c];
-                  composition_viscosities[c] = std::max(std::min(std::pow(viscosity_prefactor[c],-stress_exponent_inv) * std::pow(edot_ii,stress_exponent_inv-1), max_viscosity[c]), min_viscosity[c]);
-                  Assert(dealii::numbers::is_finite(composition_viscosities[c]), ExcMessage ("Error: Viscosity is not finite."));
-                  if (derivatives != nullptr)
-                    {
-                      if (edot_ii_strict > min_strain_rate[c] && composition_viscosities[c] < max_viscosity[c] && composition_viscosities[c] > min_viscosity[c])
-                        {
-                          composition_viscosities_derivatives[c] = (stress_exponent_inv-1) * composition_viscosities[c] * (1.0/(edot*edot)) * edot;
-
-                          if (use_deviator_of_strain_rate == true)
-                            composition_viscosities_derivatives[c] = composition_viscosities_derivatives[c] * deviator_tensor<dim>();
-                        }
-                      else
-                        {
-                          composition_viscosities_derivatives[c] = 0;
-                        }
-                    }
-                }
-
-              out.viscosities[i] = Utilities::weighted_p_norm_average(volume_fractions, composition_viscosities, viscosity_averaging_p);
-              Assert(dealii::numbers::is_finite(out.viscosities[i]), ExcMessage ("Error: Averaged viscosity is not finite."));
-
-              if (derivatives != nullptr)
-                {
-                  derivatives->viscosity_derivative_wrt_strain_rate[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_viscosities_derivatives, viscosity_averaging_p);
-
-                  for (unsigned int x = 0; x < dim; x++)
-                    for (unsigned int y = 0; y < dim; y++)
-                      Assert (dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]),
-                              ExcMessage ("Averaged viscosity to strain-rate devrivative is not finite."));
-
-                  derivatives->viscosity_derivative_wrt_pressure[i]  = 0;
-
-                }
-            }
-          out.densities[i] = density;
-          out.thermal_expansion_coefficients[i] = thermal_expansivity;
-          // Specific heat at the given positions.
-          out.specific_heat[i] = specific_heat;
-          // Thermal conductivity at the given positions.
-          out.thermal_conductivities[i] = thermal_conductivities;
-          // Compressibility at the given positions.
-          // The compressibility is given as
-          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
-          out.compressibilities[i] = 0.0;
-          // Pressure derivative of entropy at the given positions.
-          out.entropy_derivative_pressure[i] = 0.0;
-          // Temperature derivative of entropy at the given positions.
-          out.entropy_derivative_temperature[i] = 0.0;
-          // Change in composition due to chemical reactions at the
-          // given positions. The term reaction_terms[i][c] is the
-          // change in compositional field c at point i.
-          for (unsigned int c=0; c < in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-    template <int dim>
-    bool
-    SimpleNonlinear<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    SimpleNonlinear<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Compositional fields");
-      {
-        prm.declare_entry ("Number of fields", "0",
-                           Patterns::Integer (0),
-                           "The number of fields that will be advected along with the flow field, excluding "
-                           "velocity, pressure and temperature.");
-      }
-      prm.leave_subsection();
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Simple nonlinear");
-        {
-          // Reference and minimum/maximum values
-          prm.declare_entry ("Reference temperature", "293.", Patterns::Double(0.),
-                             "For calculating density by thermal expansivity. Units: \\si{\\kelvin}");
-          prm.declare_entry ("Minimum strain rate", "1.96e-40", Patterns::List(Patterns::Double(0.)),
-                             "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}");
-          prm.declare_entry ("Minimum viscosity", "1e10", Patterns::List(Patterns::Double(0.)),
-                             "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Maximum viscosity", "1e28", Patterns::List(Patterns::Double(0.)),
-                             "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Effective viscosity coefficient", "1.0", Patterns::List(Patterns::Double(0.)),
-                             "Scaling coefficient for effective viscosity.");
-
-          // Equation of state parameters
-          prm.declare_entry ("Thermal diffusivity", "0.8e-6", Patterns::List(Patterns::Double(0.)),
-                             "Units: \\si{\\meter\\squared\\per\\second}");
-          prm.declare_entry ("Heat capacity", "1.25e3", Patterns::List(Patterns::Double(0.)),
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}");
-          prm.declare_entry ("Densities", "3300.",
-                             Patterns::List(Patterns::Double(0.)),
-                             "List of densities, $\\rho$, for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "If only one value is given, then all use the same value. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}");
-          prm.declare_entry ("Thermal expansivities", "3.5e-5",
-                             Patterns::List(Patterns::Double(0.)),
-                             "List of thermal expansivities for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}");
-
-
-          // SimpleNonlinear creep parameters
-          prm.declare_entry ("Viscosity prefactor", "1e-37",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of viscosity prefactors, $A$, for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "If only one value is given, then all use the same value. "
-                             "Units: \\si{\\pascal}$^{-n_{\\text{dislocation}}}$ \\si{\\meter}$^{n_{\\text{dislocation}}/m_{\\text{dislocation}}}$ \\si{\\per\\second}");
-          prm.declare_entry ("Stress exponent", "3.",
-                             Patterns::List(Patterns::Double(0.)),
-                             "List of stress exponents, $n_dislocation$, for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "If only one value is given, then all use the same value.  Units: None");
-
-          // averaging parameters
-          prm.declare_entry ("Viscosity averaging p", "-1.",
-                             Patterns::Double(),
-                             "This is the p value in the generalized weighed average equation: "
-                             " $\\text{mean} = \\frac{1}{k}(\\sum_{i=1}^k \\big(c_i \\eta_{\\text{eff}_i}^p)\\big)^{\\frac{1}{p}}$. "
-                             " Units: \\si{\\pascal\\second}");
-
-          // strain-rate deviator parameter
-          prm.declare_entry ("Use deviator of strain-rate", "true",
-                             Patterns::Bool(),
-                             "This value determines whether to use the deviator of the strain-rate in computing the viscosity, "
-                             "or simply the strain rate $\\varepsilon(\\mathbf u)$.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    SimpleNonlinear<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // Can't use this->n_compositional_fields(), because some
-      // tests never initialize the simulator, but uses the material
-      // model directly.
-      prm.enter_subsection ("Compositional fields");
-      {
-        n_fields = prm.get_integer ("Number of fields")+1;
-      }
-      prm.leave_subsection();
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Simple nonlinear");
-        {
-
-          // Reference and minimum/maximum values
-          reference_temperature = prm.get_double("Reference temperature");
-          min_strain_rate =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Minimum strain rate"))),n_fields,"Minimum strain rate");
-          min_viscosity =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get ("Minimum viscosity"))),n_fields,"Minimum viscosity");
-          max_viscosity =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get ("Maximum viscosity"))),n_fields,"Maximum viscosity");
-
-          // Equation of state parameters
-          thermal_diffusivity =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal diffusivity"))),n_fields,"Thermal diffusivity");
-          heat_capacity =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Heat capacity"))),n_fields,"Heat capacity");
-
-          // Compositional parameters
-          densities =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Densities"))),n_fields,"Densities");
-          thermal_expansivities =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal expansivities"))),n_fields,"Thermal expansivities");
-
-          // Rheological parameters
-          viscosity_prefactor =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Viscosity prefactor"))),n_fields,"Viscosity prefactor");
-          stress_exponent =  Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Stress exponent"))),n_fields,"Stress exponent");
-
-          // averaging parameters
-          viscosity_averaging_p = prm.get_double("Viscosity averaging p");
-
-          use_deviator_of_strain_rate = prm.get_bool ("Use deviator of strain-rate");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SimpleNonlinear,
-                                   "simple nonlinear",
-                                   "A material model based on a simple power law rheology and implementing the derivatives "
-                                   "needed for the Newton method. "
-                                   "Power law equation to compute the viscosity $\\eta$ per composition comes from the book Introduction "
-                                   "to Geodynamic Modelling by Taras Gerya (2010): "
-                                   "$\\eta = A^{\\frac{-1}{n}} * \\left(2.0 * \\dot\\varepsilon_{II}\\right)^{\\frac{1}{n}-1}$ "
-                                   "where $A$ is the prefactor, $\\dot\\varepsion$ is the strain-rate, II indicates the square "
-                                   "root of the second invariant defined as $\\frac{1}{2} \\dot\\varepsilon_{ij} \\dot\\varepsilon_{ij}$, "
-                                   "and $n$ is the stress exponent. "
-                                   "The viscosities per composition are averaged using the utilities weighted "
-                                   "p-norm function. The volume fractions are used as weights for the averaging. ")
-  }
-}
diff --git a/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/drucker_prager_compositions.cc.bak b/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/drucker_prager_compositions.cc.bak
deleted file mode 100644
index e1a213fc455..00000000000
--- a/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/drucker_prager_compositions.cc.bak
+++ /dev/null
@@ -1,671 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-/**
- * This material model is specifically designed for the
- * Spiegelman benchmark as reproduced in the Fraters (2019)
- * paper on Newton solvers. It is not meant to be used for
- * general purpose models. For more details see that paper.
- */
-
-#ifndef __aspect__model_drucker_prager_compositions_h
-#define __aspect__model_drucker_prager_compositions_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/newton.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * The same material model as Drucker Prager, but this one supports multiple
-     * compositions. Designed to run the Spiegelman et al. 2016 benchmark.
-     *
-     * The model is considered incompressible, following the definition
-     * described in Interface::is_compressible.
-     *
-     * The viscosity is computed according to the Drucker Prager frictional
-     * plasticity criterion based on a user-defined internal angle of friction $\phi$
-     * and cohesion $C$. In 3D:
-     * $\sigma_y = \frac{6 C \cos(\phi)}{\sqrt(3) (3+\sin(\phi))} +
-     * \frac{6 P \sin(\phi)}{\sqrt(3) (3+\sin(\phi))}$,
-     * where $P$ is the pressure.
-     * See for example Zienkiewicz, O. C., Humpheson, C. and Lewis, R. W. (1975),
-     * Géotechnique 25, No. 4, 671-689.
-     * With this formulation we circumscribe instead of inscribe the Mohr Coulomb
-     * yield surface.
-     * In 2D the Drucker Prager yield surface is the same
-     * as the Mohr Coulomb surface:
-     * $\sigma_y = P \sin(\phi) + C \cos(\phi)$.
-     * Note that in 2D for $\phi=0$, these criteria
-     * revert to the von Mises criterion (no pressure dependence).
-     * See for example Thieulot, C. (2011), PEPI 188, 47-68.
-     *
-     * Note that we enforce the pressure to be positive in the computation of
-     * the yield strength by replacing it with
-     * a zero value whenever it is negative to prevent negative
-     * yield strengths and viscosities.
-     * We then use the computed yield strength to scale back the viscosity on
-     * to the yield surface using the Viscosity Rescaling Method described in
-     * Kachanov, L. M. (2004), Fundamentals of the Theory of Plasticity,
-     * Dover Publications, Inc.
-     *
-     * To avoid numerically unfavourably large (or even negative) viscosity ranges,
-     * we cut off the viscosity with a user-defined minimum and maximum viscosity:
-     * $\eta_eff = \max(\min(eta,max_visc),min_visc)$.
-     *
-     * Note that this model uses the formulation that assumes an incompressible
-     * medium despite the fact that the density follows the law
-     * $\rho(T)=\rho_0(1-\beta(T-T_{\text{ref}}))$.
-     *
-     *
-     * @ingroup MaterialModels
-     */
-
-    template <int dim>
-    class DruckerPragerCompositions : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        double compute_second_invariant(const SymmetricTensor<2,dim> strain_rate, const double min_strain_rate) const;
-
-        double compute_viscosity(const double edot_ii,const double pressure,const int comp, const double prefactor,const bool regularize, const double min_visc, const double max_visc) const;
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-        *
-        * This material model is incompressible.
-         */
-        bool is_compressible () const override;
-
-        double reference_density () const;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        double reference_T;
-        std::vector<double> reference_T_list;
-
-        /**
-         * Defining a minimum strain rate stabilizes the viscosity calculation,
-         * which involves a division by the strain rate. Units: $\\si{\\per\\second}$.
-         */
-        bool use_deviator_of_strain_rate;
-        std::vector<double> min_strain_rate;
-        std::vector<double> min_visc;
-        std::vector<double> max_visc;
-        std::vector<double> veff_coefficient;
-        double ref_visc;
-        double reference_compressibility;
-        std::vector<double> ref_visc_list;
-
-        std::vector<double> thermal_diffusivity;
-        std::vector<double> heat_capacity;
-
-
-        std::vector<double> densities;
-        std::vector<double> thermal_expansivities;
-
-        std::vector<double> cohesion;
-        std::vector<double> phi;
-
-        std::vector<double> prefactor;
-        std::vector<double> stress_exponent;
-
-        unsigned int n_fields;
-        // averaging parameters
-        double viscosity_averaging_p;
-
-        bool use_analytical_derivative;
-
-        //optimize variables
-        const double sqrt_3 = std::sqrt(3);
-        const double sqrt_half = std::sqrt(0.5);
-        std::vector<double> sin_phi;
-        std::vector<double> cos_phi;
-
-
-
-    };
-
-  }
-}
-
-#endif
-
-#include <aspect/utilities.h>
-#include <aspect/parameters.h>
-
-using namespace dealii;
-
-namespace aspect
-{
-  namespace
-  {
-    std::vector<double>
-    get_vector_double (const std::string &parameter, const unsigned int n_fields, ParameterHandler &prm)
-    {
-      std::vector<double> parameter_list;
-      parameter_list = Utilities::string_to_double(Utilities::split_string_list(prm.get (parameter)));
-      if (parameter_list.size() == 1)
-        parameter_list.resize(n_fields, parameter_list[0]);
-
-      AssertThrow(parameter_list.size() == n_fields,
-                  ExcMessage("Length of " + parameter + " list (size "+ std::to_string(parameter_list.size()) +") must be either one,"
-                             " or n_compositional_fields+1 (= " + std::to_string(n_fields) + ")."));
-
-      return parameter_list;
-    }
-  }
-
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    double
-    DruckerPragerCompositions<dim>::
-    compute_second_invariant(const SymmetricTensor<2,dim> strain_rate, const double min_strain_rate) const
-    {
-      const double edot_ii_strict = std::sqrt(strain_rate*strain_rate);
-      const double edot_ii = std::max(edot_ii_strict, min_strain_rate*min_strain_rate);
-      return edot_ii;
-    }
-
-    template <int dim>
-    double
-    DruckerPragerCompositions<dim>::
-    compute_viscosity(const double edot_ii,const double pressure,const int comp,const double prefactor,const bool regularize, const double min_visc, const double max_visc) const
-    {
-      double viscosity;
-      if (comp == 0)
-        {
-          const double strength = ( (dim==3)
-                                    ?
-                                    ( 6.0 * cohesion[comp] * cos_phi[comp] + 6.0 * std::max(pressure,0.0) * sin_phi[comp] )
-                                    / ( sqrt_3 * ( 3.0 + sin_phi[comp] ) )
-                                    :
-                                    cohesion[comp] * cos_phi[comp] + std::max(pressure,0.0) * sin_phi[comp] );
-
-          // Rescale the viscosity back onto the yield surface
-          if (strength != 0 && edot_ii != 0)
-            viscosity = strength / ( 2.0 * sqrt_half * edot_ii );
-          else
-            viscosity = ref_visc;
-          if (regularize == true)
-            viscosity = ref_visc*viscosity / (ref_visc + viscosity);
-        }
-      else
-        {
-          viscosity = prefactor;
-        }
-
-      return std::max(std::min(viscosity,max_visc),min_visc);
-    }
-
-    template <int dim>
-    void
-    DruckerPragerCompositions<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      //set up additional output for the derivatives
-      MaterialModelDerivatives<dim> *derivatives;
-      derivatives = out.template get_additional_output<MaterialModelDerivatives<dim>>();
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double temperature = in.temperature[i];
-          const double pressure = in.pressure[i];
-
-          // Averaging composition-field dependent properties
-          // Compositions
-          //This assert may be help when designing tests for this material model
-          AssertThrow(in.composition[i].size()+1 == n_fields,
-                      ExcMessage("Number of compositional fields + 1 not equal to number of fields given in input file."));
-
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
-          double density = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            {
-              const double temperature_factor = (1 - thermal_expansivities[c] * (temperature - reference_T));
-              density += volume_fractions[c] * densities[c] * std::exp(reference_compressibility * pressure) * temperature_factor;
-            }
-
-          // thermal expansivities
-          double thermal_expansivity = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            thermal_expansivity += volume_fractions[c] * thermal_expansivities[c];
-
-          // Specific heat at the given positions.
-          double specific_heat = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            specific_heat += volume_fractions[c] * heat_capacity[c];
-
-          // Thermal conductivity at the given positions.
-          double thermal_conductivities = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            thermal_conductivities += volume_fractions[c] * thermal_diffusivity[c] * heat_capacity[c] * densities[c];
-
-          // calculate effective viscosity
-          if (in.requests_property(MaterialProperties::viscosity))
-            {
-              // This function calculates viscosities assuming that all the compositional fields
-              // experience the same strain rate (isostrain). Since there is only one process in
-              // this material model (a general powerlaw) we do not need to worry about how to
-              // distribute the strain-rate and stress over the processes.
-              std::vector<double> composition_viscosities(volume_fractions.size());
-              std::vector<SymmetricTensor<2,dim>> composition_viscosities_derivatives(volume_fractions.size());
-              std::vector<double> composition_dviscosities_dpressure(volume_fractions.size());
-
-              const SymmetricTensor<2,dim> deviator_strain_rate = use_deviator_of_strain_rate ? deviator(in.strain_rate[i]) : in.strain_rate[i];
-
-              for (unsigned int c=0; c < volume_fractions.size(); ++c)
-                {
-                  // If strain rate is zero (like during the first time step) set it to some very small number
-                  // to prevent a division-by-zero, and a floating point exception.
-                  // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
-                  // strain rate (often simplified as epsilondot_ii)
-
-                  const double edot_ii = compute_second_invariant(deviator_strain_rate, min_strain_rate[c]);
-
-                  // Find effective viscosities for each of the individual phases
-                  // Viscosities should have same number of entries as compositional fields
-
-                  // Regularized Drucker Prager viscosity (see Spiegelman et al, 2016)
-                  composition_viscosities[c] = compute_viscosity(edot_ii,pressure,c,prefactor[c],true,min_visc[c],max_visc[c]);
-
-                  Assert(dealii::numbers::is_finite(composition_viscosities[c]),ExcMessage ("Error: Viscosity is not finite."));
-
-                  if (derivatives != nullptr)
-                    {
-                      if (use_analytical_derivative)
-                        {
-                          //analytic
-                          if (c == 0  && composition_viscosities[c] <= max_visc[c] && composition_viscosities[c] >= min_visc[c])
-                            {
-                              const double drucker_prager_viscosity = compute_viscosity(edot_ii,pressure,c,prefactor[c],false,min_visc[c],max_visc[c]);
-                              const double regulaization_adjustment = (ref_visc * ref_visc)
-                                                                      / (ref_visc * ref_visc + 2.0 * ref_visc * drucker_prager_viscosity
-                                                                         + drucker_prager_viscosity * drucker_prager_viscosity);
-
-                              composition_viscosities_derivatives[c] = -regulaization_adjustment *
-                                                                       (drucker_prager_viscosity / (edot_ii * edot_ii)) * deviator_strain_rate;
-
-                              if (use_deviator_of_strain_rate == true)
-                                composition_viscosities_derivatives[c]*deviator_tensor<dim>();
-
-                              composition_dviscosities_dpressure[c] = regulaization_adjustment *
-                                                                      ((dim == 3)
-                                                                       ?
-                                                                       6 * sin_phi[c] / (sqrt_3 * (3.0 + sin_phi[c]) * 2.0 * sqrt_half * edot_ii)
-                                                                       :
-                                                                       sin_phi[c] / (2.0 * sqrt_half * edot_ii));
-                            }
-                          else
-                            {
-                              composition_viscosities_derivatives[c] = 0;
-                              composition_dviscosities_dpressure[c] = 0;
-                            }
-                        }
-                      else
-                        {
-                          // finite difference
-                          const double finite_difference_accuracy = 1e-7;
-                          // For each independent component, compute the derivative.
-                          for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
-                            {
-                              // compute which of the independent index of the strain-rate tensor we are now looking at.
-                              const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
-
-                              // add a small difference to one independent component of the strain-rate tensor
-                              const SymmetricTensor<2,dim> strain_rate_difference_plus = deviator_strain_rate + std::max(edot_ii, min_strain_rate[c]*min_strain_rate[c]) * finite_difference_accuracy
-                                                                                         * Utilities::nth_basis_for_symmetric_tensors<dim>(component);
-                              const double second_invariant_strain_rate_difference_plus = compute_second_invariant(strain_rate_difference_plus, min_strain_rate[c]);
-                              const double eta_component_plus = compute_viscosity(second_invariant_strain_rate_difference_plus,pressure,c,prefactor[c],true,min_visc[c],max_visc[c]);
-
-                              // compute the difference between the viscosity with and without the strain-rate difference.
-                              double viscosity_derivative = eta_component_plus - composition_viscosities[c];
-                              if (viscosity_derivative != 0)
-                                {
-                                  // when the difference is non-zero, divide by the difference.
-                                  viscosity_derivative /= std::max(edot_ii, min_strain_rate[c]*min_strain_rate[c]) * finite_difference_accuracy;
-                                }
-
-                              composition_viscosities_derivatives[c][strain_rate_indices] = viscosity_derivative;
-                            }
-
-                          /**
-                           * Now compute the finite difference derivative of the viscoisty to the pressure
-                           */
-                          double pressure_difference = in.pressure[i] + (std::fabs(in.pressure[i]) * finite_difference_accuracy);
-
-                          double pressure_difference_eta = compute_viscosity(edot_ii, pressure_difference,c,prefactor[c],true,min_visc[c],max_visc[c]);
-                          double deriv_pressure = pressure_difference_eta - composition_viscosities[c];
-
-
-                          if (pressure_difference_eta != 0)
-                            {
-                              if (in.pressure[i] != 0)
-                                {
-                                  deriv_pressure /= std::fabs(in.pressure[i]) * finite_difference_accuracy;
-                                }
-                              else
-                                {
-                                  deriv_pressure = 0;
-                                }
-                            }
-
-                          composition_dviscosities_dpressure[c] = deriv_pressure;
-                        }
-                    }
-                }
-              out.viscosities[i] = Utilities::weighted_p_norm_average(volume_fractions, composition_viscosities, viscosity_averaging_p);
-              Assert(dealii::numbers::is_finite(out.viscosities[i]),ExcMessage ("Error: Averaged viscosity is not finite."));
-
-              if (derivatives != nullptr)
-                {
-                  derivatives->viscosity_derivative_wrt_strain_rate[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_viscosities_derivatives, viscosity_averaging_p);
-                  derivatives->viscosity_derivative_wrt_pressure[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_dviscosities_dpressure, viscosity_averaging_p);
-
-
-#ifdef DEBUG
-                  for (int x = 0; x < dim; x++)
-                    for (int y = 0; y < dim; y++)
-                      if (!dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]))
-                        std::cout << "Error: Averaged viscosity to strain-rate devrivative is not finite." << std::endl;
-
-                  if (!dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_pressure[i]))
-                    {
-                      std::cout << "Error: Averaged viscosity to pressure devrivative is not finite. " << std::endl;
-                      for (unsigned int c=0; c < volume_fractions.size(); ++c)
-                        std::cout << composition_dviscosities_dpressure[c] << ',';
-                      std::cout << std::endl;
-                    }
-                  Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_pressure[i]),ExcMessage ("Error: Averaged dviscosities_dpressure is not finite."));
-                  for (int x = 0; x < dim; x++)
-                    for (int y = 0; y < dim; y++)
-                      Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]),ExcMessage ("Error: Averaged dviscosities_dstrain_rate is not finite."));
-#endif
-                }
-            }
-          out.densities[i] = density;
-          out.thermal_expansion_coefficients[i] = thermal_expansivity;
-          // Specific heat at the given positions.
-          out.specific_heat[i] = specific_heat;
-          // Thermal conductivity at the given positions.
-          out.thermal_conductivities[i] = thermal_conductivities;
-          // Compressibility at the given positions.
-          // The compressibility is given as
-          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
-          out.compressibilities[i] = reference_compressibility;
-          // Pressure derivative of entropy at the given positions.
-          out.entropy_derivative_pressure[i] = 0.0;
-          // Temperature derivative of entropy at the given positions.
-          out.entropy_derivative_temperature[i] = 0.0;
-          // Change in composition due to chemical reactions at the
-          // given positions. The term reaction_terms[i][c] is the
-          // change in compositional field c at point i.
-          for (unsigned int c=0; c < in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-    template <int dim>
-    double
-    DruckerPragerCompositions<dim>::
-    reference_density () const
-    {
-      return densities[0];
-    }
-
-    template <int dim>
-    bool
-    DruckerPragerCompositions<dim>::
-    is_compressible () const
-    {
-      return (reference_compressibility != 0);
-    }
-
-    template <int dim>
-    void
-    DruckerPragerCompositions<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Compositional fields");
-      {
-        prm.declare_entry ("Number of fields", "0",
-                           Patterns::Integer(0),
-                           "The number of fields that will be advected along with the flow field, excluding "
-                           "velocity, pressure and temperature.");
-        prm.declare_entry ("Conductivities", "2.25",
-                           Patterns::List (Patterns::Double(0.)),
-                           "A list of thermal conductivities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("Heat capacities", "1250.",
-                           Patterns::List (Patterns::Double(0.)),
-                           "A list of heat capacities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("Reference temperatures", "0.",
-                           Patterns::List (Patterns::Double(0.)),
-                           "A list of reference temperatures equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("Reference densities", "2700.",
-                           Patterns::List (Patterns::Double(0.)),
-                           "A list of reference densities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("Thermal expansivities", "3.5e-5",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of thermal expansivities for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of compositional fields. "
-                           "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}");
-        prm.declare_entry ("Stress exponents", "1.",
-                           Patterns::List (Patterns::Double(0.)),
-                           "A list of stress exponents equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("Cohesions", "1e20",
-                           Patterns::List (Patterns::Double(0.)),
-                           "A list of initial viscosities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("Angles of internal friction", "30.",
-                           Patterns::List (Patterns::Double(0.)),
-                           "A list of initial viscosities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("Initial viscosities", "1e21",
-                           Patterns::List (Patterns::Double(0.)),
-                           "A list of initial viscosities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("Viscous prefactors", "1e21",
-                           Patterns::List (Patterns::Double(0.)),
-                           "A list of viscous viscosities equal to the number of "
-                           "compositional fields.");
-
-      }
-      prm.leave_subsection();
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Drucker prager compositions");
-        {
-          // Reference and minimum/maximum values
-          prm.declare_entry ("Reference temperature", "293.", Patterns::Double(0.),
-                             "For calculating density by thermal expansivity. Units: \\si{\\kelvin}");
-          prm.declare_entry ("Minimum strain rate", "1.4e-20", Patterns::List(Patterns::Double(0.)),
-                             "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}");
-          prm.declare_entry ("Minimum viscosity", "1e10", Patterns::List(Patterns::Double(0.)),
-                             "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Maximum viscosity", "1e28", Patterns::List(Patterns::Double(0.)),
-                             "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Effective viscosity coefficient", "1.0", Patterns::List(Patterns::Double(0.)),
-                             "Scaling coefficient for effective viscosity.");
-          prm.declare_entry ("Reference viscosity", "1e22", Patterns::List(Patterns::Double(0.)),
-                             "Reference viscosity for nondimensionalization. Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Reference compressibility", "4e-12", Patterns::Double(0.),
-                             "The value of the reference compressibility. Units: \\si{\\per\\pascal}.");
-
-          // averaging parameters
-          prm.declare_entry ("Viscosity averaging p", "-1",
-                             Patterns::Double(),
-                             "This is the p value in the generalized weighed average eqation: "
-                             " mean = \\frac{1}{k}(\\sum_{i=1}^k \\big(c_i \\eta_{\\text{eff}_i}^p)\\big)^{\\frac{1}{p}}. "
-                             " Units: \\si{\\pascal\\second}");
-
-          // finite difference versus analytical
-          prm.declare_entry ("Use analytical derivative", "false",
-                             Patterns::Bool(),
-                             "A bool indicating whether to use finite differences to compute the derivative or to use "
-                             "the analytical derivative.");
-
-          prm.declare_entry ("Use deviator of strain-rate", "true",
-                             Patterns::Bool(),
-                             "Todo.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    DruckerPragerCompositions<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // can't use this->n_compositional_fields(), because some
-      // tests never initiate the simulator, but uses the material
-      // model directly.
-      prm.enter_subsection ("Compositional fields");
-      {
-        n_fields = prm.get_integer ("Number of fields")+1;
-        //AssertThrow(n_fields > 0, ExcMessage("This material model needs at least one compositional field."))
-        reference_T_list = get_vector_double("Reference temperatures",n_fields,prm);
-        ref_visc_list = get_vector_double ("Initial viscosities",n_fields,prm);
-        thermal_diffusivity = get_vector_double("Conductivities",n_fields,prm);
-        heat_capacity = get_vector_double("Heat capacities",n_fields,prm);
-
-        // ---- Compositional parameters
-        densities = get_vector_double("Reference densities",n_fields,prm);
-        thermal_expansivities = get_vector_double("Thermal expansivities",n_fields,prm);
-
-        // Rheological parameters
-        cohesion = get_vector_double("Cohesions",n_fields,prm);
-        phi = get_vector_double("Angles of internal friction",n_fields,prm);
-
-        sin_phi.resize(n_fields);
-        cos_phi.resize(n_fields);
-        for (unsigned int c = 0; c < n_fields; ++c)
-          {
-            sin_phi[c] = std::sin(phi[c] * constants::degree_to_radians);
-            cos_phi[c] = std::cos(phi[c] * constants::degree_to_radians);
-          }
-
-        prefactor = get_vector_double("Viscous prefactors",n_fields,prm);
-        stress_exponent = get_vector_double("Stress exponents",n_fields,prm);
-      }
-      prm.leave_subsection();
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Drucker prager compositions");
-        {
-
-          // Reference and minimum/maximum values
-          reference_T = prm.get_double("Reference temperature");
-          ref_visc = prm.get_double ("Reference viscosity");
-          min_strain_rate = get_vector_double("Minimum strain rate",n_fields,prm);
-          min_visc = get_vector_double ("Minimum viscosity",n_fields,prm);
-          max_visc = get_vector_double ("Maximum viscosity",n_fields,prm);
-          veff_coefficient = get_vector_double ("Effective viscosity coefficient",n_fields,prm);
-          reference_compressibility  = prm.get_double ("Reference compressibility");
-          use_deviator_of_strain_rate = prm.get_bool ("Use deviator of strain-rate");
-
-
-          // averaging parameters
-          viscosity_averaging_p = prm.get_double("Viscosity averaging p");
-
-          use_analytical_derivative = prm.get_bool("Use analytical derivative");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(DruckerPragerCompositions,
-                                   "drucker prager compositions",
-                                   " An implementation of a viscous rheology including diffusion"
-                                   " and dislocation creep allowing for different compositions."
-                                   " Designed for testing the Spiegelman et al. (2016) benchmark."
-                                   " Compositional fields can each be assigned individual"
-                                   " activation energies, reference densities, thermal expansivities,"
-                                   " and stress exponents. The effective viscosity is defined as"
-                                   " \n\n"
-                                   " \\[v_\\text{eff} = \\left(\\frac{1}{v_\\text{eff}^\\text{diff}}+"
-                                   " \\frac{1}{v_\\text{eff}^\\text{dis}}\\right)^{-1}\\]"
-                                   " where"
-                                   " \\[v_\\text{i} = 0.5 * A^{-\\frac{1}{n_i}} d^\\frac{m_i}{n_i}"
-                                   " \\dot{\\varepsilon_i}^{\\frac{1-n_i}{n_i}}"
-                                   " \\exp\\left(\\frac{E_i^* + PV_i^*}{n_iRT}\\right)\\]"
-                                   " \n\n"
-                                   " where $d$ is grain size, $i$ corresponds to diffusion or dislocation creep,"
-                                   " $\\dot{\\varepsilon}$ is the square root of the second invariant of the"
-                                   " strain rate tensor, $R$ is the gas constant, $T$ is temperature, "
-                                   " and $P$ is pressure."
-                                   " $A_i$ are prefactors, $n_i$ and $m_i$ are stress and grain size exponents"
-                                   " $E_i$ are the activation energies and $V_i$ are the activation volumes."
-                                   " \n\n"
-                                   " The ratio of diffusion to dislocation strain rate is found by Newton's"
-                                   " method, iterating to find the stress which satisfies the above equations."
-                                   " The value for the components of this formula and additional"
-                                   " parameters are read from the parameter file in subsection"
-                                   " 'Material model/SimpleNonlinear'.")
-  }
-}
diff --git a/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/input.prm.bak b/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/input.prm.bak
deleted file mode 100644
index a35e871b3ca..00000000000
--- a/benchmarks/newton_solver_benchmark_set/spiegelman_et_al_2016/input.prm.bak
+++ /dev/null
@@ -1,137 +0,0 @@
-set Additional shared libraries            = ./libdrucker_prager_compositions.so
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = iterated Advection and Newton Stokes
-set Max nonlinear iterations               = 150
-set Nonlinear solver tolerance             = 1e-14
-set Pressure normalization                 = no
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-    set Linear solver tolerance             = 1e-5
-  end
-
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations      = 5
-    set SPD safety factor                        = 0.9
-    set Nonlinear Newton solver switch tolerance = 1e-20 #
-    set Max Newton line search iterations        = 0
-    set Maximum linear Stokes solver tolerance   = 9e-1
-    set Use Newton residual scaling method       = false
-    set Use Newton failsafe                      = false
-    set Stabilization preconditioner             = SPD
-    set Stabilization velocity block             = SPD
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = H = 30e3
-
-    # The function below lays out the composition structure as described in the Spiegelman paper.
-    # It generates a composition at the bottom which has a square with round eges sticking out in
-    # the center.
-    set Function expression = if(z < 0.25 * H,1, \
-if(z < (0.25+(1/12)-0.02)*H & x > (2-(1/12))*H & x < (2+(1/12))*H,1, \
-if(z < (0.25+(1/12))*H & (x > (2-(1/12)+0.02)*H & x < (2+(1/12)-0.02)*H | (x-(2-(1/12)+0.02)*H)^2 + (z-(0.25+(1/12)-0.02)*H)^2 < (0.02*H)^2 | (x-(2+(1/12)-0.02)*H)^2 + (z-(0.25+(1/12)-0.02)*H)^2 < (0.02*H)^2),1, \
-if(z < (0.25+0.02)*H && x > (2-(1/12)-0.02)*H && x < (2+(1/12)+0.02)*H && ((x-(2-(1/12)-0.02)*H)^2 + (z-(0.25+0.02)*H)^2 > (0.02*H)^2 && (x-(2+(1/12)+0.02)*H)^2 + (z-(0.25+0.02)*H)^2 > (0.02*H)^2),1,0))))
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent      = 120e3
-    set Y extent      = 30e3
-    set X repetitions = 4
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-
-  #parameters for all rheologies
-  set Conductivities                         = 2.25,          2.25
-  set Heat capacities                        = 1250,          1250
-  set Reference temperatures                 = 0,             0
-  set Reference densities                    = 2700.0,        2700.0
-
-  #plastic parameters
-  set Cohesions                              = 1e8,0
-  set Angles of internal friction            = 30,0
-
-  #Dislocation parameters
-  set Stress exponents                       = 50,            1
-  set Initial viscosities                    = 1e20, 1e21
-
-  # the first value is ignored by the specific drucker prager compositions material model
-  # in this benchmark folder, so set it to a nonsensical value: 0.
-  set Viscous prefactors                     = 0, 1e21
-end
-
-subsection Material model
-  set Model name = drucker prager compositions
-
-  subsection Drucker prager compositions
-    set Maximum viscosity           = 1e24
-    set Minimum viscosity           = 1e21
-    set Viscosity averaging p       = -1
-    set Use deviator of strain-rate = true
-    set Use analytical derivative   = false
-    set Reference viscosity         = 5e24
-    set Reference compressibility   = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement   = 5
-  set Strategy                    = strain rate
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   =
-end
-
-subsection Boundary velocity model
-  # Prescribe a horizontal traction on the vertical boundaries
-  set Tangential velocity boundary indicators = 2
-  set Zero velocity boundary indicators       =
-
-  # Prescribe a zero vertical velocity component on the vertical boundaries
-  set Prescribed velocity boundary indicators = 0 x:function,1 x:function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = if(x<60e3,7.92219116e-11,-7.92219116e-11);0
-  end
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators =
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties,strain rate, spd factor
-    set Interpolate output       = false
-  end
-end
diff --git a/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm.bak b/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm.bak
deleted file mode 100644
index b6cca66b629..00000000000
--- a/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-# A description of viscoplastic convection in a 2d box as
-# described in Tosi et al. (2015).
-
-# We add the necessary plugins through a shared library
-set Additional shared libraries            = $ASPECT_SOURCE_DIR/benchmarks/tosi_et_al_2015_gcubed/libtosi_benchmark.so
-
-# This is a 2D benchmark.
-set Dimension                              = 2
-
-# We run the model from time = 0 to time = 1 and to handle
-# the nonlinearity of the viscosity correctly, we use
-# the iterated Advection and Stokes nonlinear solver and skip the cheap
-# Stokes solves.
-set Use years in output instead of seconds = false
-set End time                               = 0.01
-set Output directory                       = Case4_3_T15_NS_analytical_9e-1_release
-set Nonlinear solver scheme                = iterated Advection and Newton Stokes
-set Max nonlinear iterations               = 30
-set Nonlinear solver tolerance             = 1e-7
-
-# We choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 200
-    set Linear solver tolerance = 1e-6
-  end
-
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 5
-    set SPD safety factor = 0.9
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 0
-    set Maximum linear Stokes solver tolerance = 9e-1
-    set Use Newton residual scaling method = false
-    set Use Newton failsafe = false
-    set Stabilization preconditioner = SPD
-    set Stabilization velocity block = SPD
-  end
-end
-
-# Our model domain is the unit square.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# We prescribe a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation with amplitude A.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = A=0.01, pi=3.1415926536
-    set Function expression = (1.0-z) + A*cos(pi*x)*sin(pi*z)
-  end
-end
-
-# The top and bottom boundary carry a prescribed boundary temperature, whereas
-# all other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  # The temperature at the bottom is set to 1; at the top to 0.
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  # Here, all four sides of the box allow tangential
-  # unrestricted flow but with a zero normal component:
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# Gravity is vertical and of magnitude 1e8.
-# //TODO elaborate on scaling/rayleigh
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e8
-  end
-end
-
-subsection Material model
-  set Model name = TosiMaterial
-
-  subsection Tosi benchmark
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-06
-    set Thermal viscosity parameter   = 1e5
-    set Pressure viscosity parameter  = 10
-    set Yield stress          = 1
-    set Nonlinear viscosity constant  = 1e-3
-    set Initial viscosity        = 1e-1
-    set Minimum viscosity        = 1e-6
-    set Maximum viscosity        = 10
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.05. Given
-# our start time (0.0) and final time (1.0) this means that
-# we will obtain 20 output files.
-#
-# The statistics file includes the data reported in Tosi et al. (2015):
-# - average temperature (temperature statistics)
-# - top and bottom Nusselt numbers (heat flux statistics)
-# - Vrms over the whole domain (velocity statistics)
-# - Vrms along the surface (velocity boundary statistics)
-# - Vmax along the surface (velocity boundary statistics)
-# - average rate of viscous dissipation (tosi viscous dissipation statistics)
-# - average rate of work against gravity (tosi viscous dissipation statistics)
-# - percentage error difference work and dissipation (tosi viscous dissipation statistics)
-#
-# Tosi et al. (2015) also report depth averages; averages for viscosity
-# and temperature are produced every 0.05 units of time.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization , depth average, velocity boundary statistics #, tosi dissipation and work statistics, depth average, velocity boundary statistics
-
-  subsection Depth average
-    set List of output variables = temperature, viscosity
-    set Time between graphical output = 0.05
-    set Number of zones = 10
-  end
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate, gravity
-    set Time between graphical output = 0.05
-  end
-end
diff --git a/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm.bak b/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm.bak
deleted file mode 100644
index d76f0ae4e05..00000000000
--- a/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-# Same as the newton_solver_benchmark_set/tosi_et_al_2015/input.prm
-# benchmark but using GMG instead.
-
-# We add the necessary plugins through a shared library
-set Additional shared libraries            = $ASPECT_SOURCE_DIR/benchmarks/tosi_et_al_2015_gcubed/libtosi_benchmark.so
-
-include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
-
-set Output directory                       = output-gmg
-
-subsection Solver parameters
-  subsection Matrix Free
-    set Output details = true
-  end
-
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/benchmarks/nsinker/nsinker.cc.bak b/benchmarks/nsinker/nsinker.cc.bak
deleted file mode 100644
index c031bdea433..00000000000
--- a/benchmarks/nsinker/nsinker.cc.bak
+++ /dev/null
@@ -1,352 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/global.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_signals.h>
-
-#include <deal.II/base/point.h>
-#include <deal.II/base/exceptions.h>
-
-
-namespace aspect
-{
-  /**
-   * This is the "NSinker" benchmark as defined in Rudi et al. (2017),
-   * which is based on May et al. (2014). It creates a number of
-   * spherical high-viscosity, high-density sinking spheres in a box
-   * geometry that provide a challenge for the Stokes preconditioner.
-   * The difficulty of the problem is determined by the number of
-   * sinkers and the viscosity contrast between sinkers and
-   * background.
-   */
-  namespace NSinkerBenchmark
-  {
-    using namespace dealii;
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class NSinkerMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * Constructor
-         */
-        NSinkerMaterial ();
-
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          const double sqrt_dynamic_viscosity_ratio = std::sqrt(dynamic_viscosity_ratio);
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const double chi = inside_outside_factor(in.position[i]);
-              out.viscosities[i] = (sqrt_dynamic_viscosity_ratio - 1./sqrt_dynamic_viscosity_ratio)*(1-chi) + 1./sqrt_dynamic_viscosity_ratio;
-              out.densities[i] = sinker_density * (1.0 - chi);
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override
-        {
-          return false;
-        }
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm)
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("NSinker");
-            {
-              prm.declare_entry ("Dynamic viscosity ratio", "1e3",
-                                 Patterns::Double (0),
-                                 "Viscosity in the sinkers.");
-              prm.declare_entry ("Sinker density", "10",
-                                 Patterns::Double (0),
-                                 "Density in the sinkers.");
-              prm.declare_entry ("Number of sinkers", "4",
-                                 Patterns::Integer (0,75),
-                                 "Number of sinking spheres.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("NSinker");
-            {
-              dynamic_viscosity_ratio = prm.get_double ("Dynamic viscosity ratio");
-              sinker_density = prm.get_double ("Sinker density");
-              n_sinkers = prm.get_integer ("Number of sinkers");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          // Declare dependencies on solution variables
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-
-
-      private:
-        /**
-         * Ratio of viscosities between sinkers and background material.
-         */
-        double dynamic_viscosity_ratio;
-
-        /**
-         * Sinker density. For a gravity of 1 this corresponds to
-         * the size of the right-hand-side forcing term.
-         */
-        double sinker_density;
-
-        /**
-         * Number of sinking spheres.
-         */
-        unsigned int n_sinkers;
-
-        /**
-         * Centers for the sinkers provided by Cedric Thielot (pers. comm. from Dave May)
-         */
-        std::vector<Point<3>> centers;
-
-        /**
-         * Parameters for evaluating viscosity
-         */
-        double delta;
-        double omega;
-
-        /**
-         * Return a factor that indicates whether a point is inside or
-         * outside the sinker spheres. The function can be thought of
-         * as a 1 (outside) vs 0 (inside) factor, but is in reality a
-         * smoothed version of this that takes into account the
-         * distance from the centers of the sinkers.
-         */
-        double inside_outside_factor (const Point<dim> &p) const;
-    };
-
-
-    template <int dim>
-    NSinkerMaterial<dim>::NSinkerMaterial ()
-    {
-      delta = 200.0;
-      omega = 0.1;
-
-      centers.resize(75);
-      centers[0] = Point<3>(2.4257829890e-01, 1.3469574514e-02, 3.8313885004e-01);
-      centers[1] = Point<3>(4.1465269048e-01, 6.7768972864e-02, 9.9312692973e-01);
-      centers[2] = Point<3>(4.8430804651e-01, 7.6533776604e-01, 3.1833815403e-02);
-      centers[3] = Point<3>(3.0935481671e-02, 9.3264044027e-01, 8.8787953411e-01);
-      centers[4] = Point<3>(5.9132973039e-01, 4.7877868473e-01, 8.3335433660e-01);
-      centers[5] = Point<3>(1.8633519681e-01, 7.3565270739e-01, 1.1505317181e-01);
-      centers[6] = Point<3>(6.9865863058e-01, 3.5560411138e-01, 6.3830000658e-01);
-      centers[7] = Point<3>(9.0821050755e-01, 2.9400041480e-01, 2.6497158886e-01);
-      centers[8] = Point<3>(3.7749399775e-01, 5.4162011554e-01, 9.2818150340e-03);
-      centers[9] = Point<3>(8.5247022139e-01, 4.6701098395e-01, 5.3607231962e-02);
-      centers[10] = Point<3>(9.7674759057e-01, 1.9675474344e-01, 8.5697294067e-01);
-      centers[11] = Point<3>(1.4421375987e-01, 8.0066218823e-01, 7.2939761948e-01);
-      centers[12] = Point<3>(9.8579064709e-01, 1.8340570954e-01, 4.9976021075e-01);
-      centers[13] = Point<3>(4.6986202126e-01, 9.7099129947e-01, 4.5077026191e-01);
-      centers[14] = Point<3>(9.5791877292e-02, 9.7408164664e-01, 3.9023506101e-01);
-      centers[15] = Point<3>(6.8067035576e-01, 2.6669318800e-02, 2.3124107450e-01);
-      centers[16] = Point<3>(4.6873909443e-01, 9.7960100555e-02, 4.1541002524e-01);
-      centers[17] = Point<3>(7.9629418710e-01, 3.1640260216e-01, 7.7853444953e-01);
-      centers[18] = Point<3>(8.2849331472e-01, 4.8714042059e-01, 3.6904878000e-01);
-      centers[19] = Point<3>(6.0284549678e-01, 2.4264360789e-02, 8.1111178631e-01);
-      centers[20] = Point<3>(3.5579259291e-01, 8.0610905439e-01, 2.7487712366e-01);
-      centers[21] = Point<3>(8.5981739865e-01, 9.5101905612e-01, 7.7727618477e-01);
-      centers[22] = Point<3>(6.8083745971e-01, 8.3518540665e-01, 9.6112961413e-01);
-      centers[23] = Point<3>(7.0542474869e-01, 7.3751226102e-02, 5.3685709440e-01);
-      centers[24] = Point<3>(9.5718558131e-01, 4.1806501915e-01, 4.1877679639e-01);
-      centers[25] = Point<3>(3.8161700050e-01, 8.3692747440e-01, 2.4006224854e-01);
-      centers[26] = Point<3>(7.2621119848e-01, 4.3161282150e-01, 1.1669089744e-01);
-      centers[27] = Point<3>(2.2391322592e-01, 3.0958795748e-01, 2.4480139429e-01);
-      centers[28] = Point<3>(3.7703382754e-01, 8.0753940242e-01, 3.1473643301e-01);
-      centers[29] = Point<3>(7.7522956709e-01, 2.8333410774e-01, 9.9634871585e-01);
-      centers[30] = Point<3>(6.3286731189e-01, 6.0091089904e-01, 5.0948022423e-01);
-      centers[31] = Point<3>(8.3412860373e-01, 1.9944285005e-01, 3.5980841627e-02);
-      centers[32] = Point<3>(7.3000523063e-01, 1.9791117972e-01, 2.9319749786e-01);
-      centers[33] = Point<3>(7.7034656693e-01, 2.1475035521e-01, 3.0922000730e-01);
-      centers[34] = Point<3>(6.0662675677e-02, 5.5759010630e-01, 4.1691651960e-01);
-      centers[35] = Point<3>(1.1594487686e-01, 6.8554530558e-01, 9.5995079957e-01);
-      centers[36] = Point<3>(2.7973348288e-02, 1.4806467395e-01, 5.2297503060e-01);
-      centers[37] = Point<3>(6.4133927209e-01, 9.8914607800e-01, 5.7813295237e-01);
-      centers[38] = Point<3>(6.8053043246e-01, 6.7497840462e-01, 3.6204645148e-01);
-      centers[39] = Point<3>(9.1470996426e-01, 5.3036934674e-01, 9.1761070439e-01);
-      centers[40] = Point<3>(2.8310876353e-01, 2.0898862472e-01, 4.7181570645e-01);
-      centers[41] = Point<3>(8.0657831198e-01, 1.6168943288e-01, 5.1429839456e-01);
-      centers[42] = Point<3>(8.1311740159e-01, 6.4168478858e-02, 4.7962416312e-01);
-      centers[43] = Point<3>(4.3309508843e-02, 9.0291512474e-01, 2.9450144167e-01);
-      centers[44] = Point<3>(6.8573011443e-01, 6.6033273035e-02, 8.2121989495e-01);
-      centers[45] = Point<3>(2.4277445452e-01, 3.1025718772e-01, 4.9255406554e-01);
-      centers[46] = Point<3>(3.5617944848e-01, 3.0799053857e-01, 3.9698166931e-01);
-      centers[47] = Point<3>(7.0916077621e-02, 8.8651657239e-01, 6.8403214295e-01);
-      centers[48] = Point<3>(5.2822650202e-01, 9.0281945043e-01, 6.8650344000e-01);
-      centers[49] = Point<3>(6.3316007640e-02, 1.5214040370e-01, 2.3765034985e-02);
-      centers[50] = Point<3>(4.1894298765e-01, 1.7479340461e-01, 7.5275125343e-01);
-      centers[51] = Point<3>(4.9031640053e-01, 7.4774375406e-01, 3.2927456281e-01);
-      centers[52] = Point<3>(1.1757708859e-01, 1.1812786251e-01, 3.7498524244e-01);
-      centers[53] = Point<3>(3.7696964032e-01, 7.2874483733e-01, 1.4480990830e-02);
-      centers[54] = Point<3>(3.8201288152e-01, 4.9049964756e-01, 8.2757658503e-01);
-      centers[55] = Point<3>(7.9664661586e-02, 9.2396727806e-01, 1.1804237828e-01);
-      centers[56] = Point<3>(9.3825167927e-01, 1.9597347043e-01, 7.2611756191e-01);
-      centers[57] = Point<3>(8.5786301170e-01, 1.0363770514e-01, 8.3891028205e-01);
-      centers[58] = Point<3>(5.6511039453e-01, 8.1040084307e-01, 4.0696941614e-01);
-      centers[59] = Point<3>(9.3497714490e-01, 1.6087440083e-01, 8.1605472361e-01);
-      centers[60] = Point<3>(4.3173963829e-01, 2.4810082244e-01, 8.3052277138e-01);
-      centers[61] = Point<3>(5.9621858625e-01, 6.4577903070e-01, 6.0816894547e-01);
-      centers[62] = Point<3>(4.9546643556e-01, 3.0438243752e-01, 7.5562733447e-01);
-      centers[63] = Point<3>(8.2861043319e-01, 4.5555055302e-01, 4.3814466774e-01);
-      centers[64] = Point<3>(8.9743076959e-01, 1.1894442752e-01, 9.8993320995e-02);
-      centers[65] = Point<3>(6.9884936497e-01, 5.6127713367e-01, 3.8478565932e-01);
-      centers[66] = Point<3>(9.2576270966e-02, 9.2938612771e-01, 1.9264837596e-01);
-      centers[67] = Point<3>(8.4125479722e-01, 9.6937695284e-01, 3.1844636161e-01);
-      centers[68] = Point<3>(1.2799954700e-01, 2.8838638276e-01, 9.0993508972e-01);
-      centers[69] = Point<3>(2.7905288352e-01, 4.1813262758e-02, 7.5550716964e-01);
-      centers[70] = Point<3>(8.0900019305e-01, 8.6624463269e-01, 9.7354159503e-01);
-      centers[71] = Point<3>(3.1358765965e-01, 4.6779574243e-01, 2.4304298462e-01);
-      centers[72] = Point<3>(8.2344259034e-01, 5.9961585635e-01, 7.4369772512e-01);
-      centers[73] = Point<3>(3.2766604253e-01, 8.3176720460e-02, 9.5114077951e-01);
-      centers[74] = Point<3>(8.2308128282e-01, 5.2712029523e-01, 3.1080186614e-01);
-    }
-
-
-
-    template <>
-    double
-    NSinkerMaterial<2>::inside_outside_factor (const Point<2> &p) const
-    {
-      double chi = 1.0;
-
-      for (unsigned int s=0; s<n_sinkers; ++s)
-        {
-          double dist = p.distance(Point<2>(centers[s](0), centers[s](1)));
-          double temp = 1-std::exp(-delta*
-                                   std::pow(std::max(0.0,dist-omega/2.0),2));
-          chi *= temp;
-        }
-      return chi;
-    }
-
-
-
-    template <>
-    double
-    NSinkerMaterial<3>::inside_outside_factor (const Point<3> &p) const
-    {
-      double chi = 1.0;
-
-      for (unsigned int s=0; s<n_sinkers; ++s)
-        {
-          double dist = p.distance(centers[s]);
-          double temp = 1-std::exp(-delta*
-                                   std::pow(std::max(0.0,dist-omega/2.0),2));
-          chi *= temp;
-        }
-      return chi;
-    }
-  }
-}
-
-
-// Change pressure scaling to 1.0:
-double pressure_scaling_signal(const double /*pressure_scaling*/,
-                               const double /*reference_viscosity*/,
-                               const double /*length_scale*/)
-{
-  return 1.0;
-}
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  signals.modify_pressure_scaling.connect(&pressure_scaling_signal);
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
-
-
-namespace aspect
-{
-  namespace NSinkerBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(NSinkerMaterial,
-                                   "nsinker",
-                                   "A material model that corresponds to the 'NSinker' benchmark "
-                                   "defined in May et al., G-Cubed, 2015. We here implement the "
-                                   "version defined in Rudi et al., SIAM Journal on Scientific "
-                                   "Computing, 2017. Number of sinkers and viscosity ratio can be chosen "
-                                   "as input parameters.")
-  }
-}
diff --git a/benchmarks/nsinker/nsinker.prm.bak b/benchmarks/nsinker/nsinker.prm.bak
deleted file mode 100644
index 3e7adb91f88..00000000000
--- a/benchmarks/nsinker/nsinker.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# This is the "NSinker" benchmark defined in May et al. (2015,G3) in the
-# implementation of Rudi et al., (2017, SIAM J.Sci.Comp.). It creates a number
-# of spherical high-viscosity, high-density sinking spheres in a box geometry
-# that provide a challenge for the Stokes preconditioner. The difficulty of the
-# problem is determined by the number of sinkers and the viscosity contrast
-# between sinkers and background.
-
-set Additional shared libraries            = ./libnsinker.so
-set Dimension                              = 3
-set End time                               = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, single Stokes
-set Max nonlinear iterations               = 1
-set Use years in output instead of seconds = false
-
-
-# Follow as closely as possible the parameters from Rudi et al. (2017)
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use full A block as preconditioner              = true
-    set Number of cheap Stokes solver steps             = 500
-    set Maximum number of expensive Stokes solver steps = 1000
-    set Linear solver tolerance                         = 1e-6
-    set GMRES solver restart length                     = 100
-    set Use weighted BFBT for Schur complement          = false
-    set Krylov method for cheap solver steps            = GMRES
-  end
-  subsection AMG parameters
-   set AMG aggregation threshold = 0.02
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = false
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = left,right,bottom,top,front,back
-end
-
-subsection Material model
-  set Model name = nsinker
-  set Material averaging = none
-
-  subsection NSinker
-    set Number of sinkers = 8
-    set Dynamic viscosity ratio = 1e4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables = material properties
-  end
-end
diff --git a/benchmarks/nsinker/nsinker_2d.prm.bak b/benchmarks/nsinker/nsinker_2d.prm.bak
deleted file mode 100644
index 070b9bdef40..00000000000
--- a/benchmarks/nsinker/nsinker_2d.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# This is a 2D version of the original 3D "NSinker" problem.
-
-set Additional shared libraries            = ./libnsinker.so
-set Dimension                              = 2
-set End time                               = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, single Stokes
-set Max nonlinear iterations               = 1
-set Use years in output instead of seconds = false
-
-# Follow as closely as possible the parameters from Rudi et al. (2017)
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use full A block as preconditioner              = true
-    set Number of cheap Stokes solver steps             = 0
-    set Maximum number of expensive Stokes solver steps = 1000
-    set Linear solver tolerance                         = 1e-6
-    set GMRES solver restart length                     = 100
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = true
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left,right,bottom
-end
-
-subsection Material model
-  set Model name = nsinker
-  set Material averaging = none
-
-  subsection NSinker
-    set Number of sinkers = 1
-    set Dynamic viscosity ratio = 1e4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables = material properties
-  end
-end
diff --git a/benchmarks/nsinker/nsinker_bfbt.prm.bak b/benchmarks/nsinker/nsinker_bfbt.prm.bak
deleted file mode 100644
index ed104447980..00000000000
--- a/benchmarks/nsinker/nsinker_bfbt.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# This is the "NSinker" benchmark defined in May et al. (2015,G3) in the
-# implementation of Rudi et al., (2017, SIAM J.Sci.Comp.). It creates a number
-# of spherical high-viscosity, high-density sinking spheres in a box geometry
-# that provide a challenge for the Stokes preconditioner. The difficulty of the
-# problem is determined by the number of sinkers and the viscosity contrast
-# between sinkers and background. In this benchmark, we use the
-# weighted BFBT preconditioner introduced by Rudi et al., (2017).
-
-set Additional shared libraries            = ./libnsinker.so
-set Dimension                              = 3
-set End time                               = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, single Stokes
-set Max nonlinear iterations               = 1
-set Use years in output instead of seconds = false
-
-
-# Follow as closely as possible the parameters from Rudi et al. (2017)
-subsection Solver parameters
-   subsection Stokes solver parameters
-    set Use full A block as preconditioner              = true
-    set Number of cheap Stokes solver steps             = 500
-    set Maximum number of expensive Stokes solver steps = 1000
-    set Linear solver tolerance                         = 1e-6
-    set GMRES solver restart length                     = 100
-    set Use weighted BFBT for Schur complement          = true
-    set Krylov method for cheap solver steps            = GMRES
-  end
-  subsection AMG parameters
-   set AMG aggregation threshold = 0.02
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = false
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = left,right,bottom,top,front,back
-end
-
-subsection Material model
-  set Model name = nsinker
-  set Material averaging = none
-
-  subsection NSinker
-    set Number of sinkers = 8
-    set Dynamic viscosity ratio = 1e4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables = material properties
-  end
-end
diff --git a/benchmarks/nsinker/nsinker_gmg.prm.bak b/benchmarks/nsinker/nsinker_gmg.prm.bak
deleted file mode 100644
index aa4817332bf..00000000000
--- a/benchmarks/nsinker/nsinker_gmg.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# This is the "NSinker" benchmark defined in May et al. (2015,G3) in the
-# implementation of Rudi et al., (2017, SIAM J.Sci.Comp.). It creates a number
-# of spherical high-viscosity, high-density sinking spheres in a box geometry
-# that provide a challenge for the Stokes preconditioner. The difficulty of the
-# problem is determined by the number of sinkers and the viscosity contrast
-# between sinkers and background.
-
-set Additional shared libraries            = ./libnsinker.so
-set Dimension                              = 3
-set End time                               = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, single Stokes
-set Max nonlinear iterations               = 1
-set Use years in output instead of seconds = false
-set Output directory = output-gmg
-
-# Follow as closely as possible the parameters from Rudi et al. (2017)
-subsection Solver parameters
-  subsection Matrix Free
-    set Output details = true
-  end
-
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps             = 200
-    set Maximum number of expensive Stokes solver steps = 0
-    set Linear solver tolerance                         = 1e-6
-    set GMRES solver restart length                     = 100
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = false
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = left,right,bottom,top,front,back
-end
-
-subsection Material model
-  set Model name = nsinker
-  set Material averaging = harmonic average
-
-  subsection NSinker
-    set Number of sinkers = 4
-    set Dynamic viscosity ratio = 1e4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 4
-  set Initial adaptive refinement = 5
-  set Adapt by fraction of cells = true
-  set Strategy = velocity
-  set Run postprocessors on initial refinement = true
-  set Coarsening fraction       = 0.0
-  set Refinement fraction       = 0.147 #0.14285714285
-end
-
-subsection Postprocess
-  set List of postprocessors = memory statistics, visualization
-
-  subsection Memory statistics
-    set Output peak virtual memory (VmPeak) = true
-  end
-
-  subsection Visualization
-    set List of output variables = viscosity
-  end
-end
diff --git a/benchmarks/nsinker_spherical_shell/amg.prm.bak b/benchmarks/nsinker_spherical_shell/amg.prm.bak
deleted file mode 100644
index 64b627b59c4..00000000000
--- a/benchmarks/nsinker_spherical_shell/amg.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-# This is the "Spherical Shell NSinker" benchmark
-#
-# This file uses the AMG instead of GMG solver
-
-set Additional shared libraries            = ./libnsinker_spherical_shell.so
-
-include gmg.prm
-
-set Dimension                              = 3
-set Output directory = output-amg
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block AMG
-    set Number of cheap Stokes solver steps             = 2000
-    set Maximum number of expensive Stokes solver steps = 0
-    set Linear solver tolerance                         = 1e-6
-    set GMRES solver restart length                     = 100
-  end
-end
diff --git a/benchmarks/nsinker_spherical_shell/gmg.prm.bak b/benchmarks/nsinker_spherical_shell/gmg.prm.bak
deleted file mode 100644
index 58a4eab153b..00000000000
--- a/benchmarks/nsinker_spherical_shell/gmg.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# This is the "Spherical Shell NSinker" benchmark
-
-set Additional shared libraries            = ./libnsinker_spherical_shell.so
-set Dimension                              = 3
-set End time                               = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, single Stokes
-set Use years in output instead of seconds = false
-set Output directory = output-gmg
-
-subsection Solver parameters
-  subsection Matrix Free
-    set Output details = true
-  end
-
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps             = 2000
-    set Maximum number of expensive Stokes solver steps = 0
-    set Linear solver tolerance                         = 1e-6
-    set GMRES solver restart length                     = 200
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = false
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 0.54
-    set Outer radius  = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top,bottom
-end
-
-subsection Material model
-  set Model name = nsinker
-  set Material averaging = harmonic average
-
-  subsection NSinker
-    set Number of sinkers = 5
-    set Dynamic viscosity ratio = 1e2
-    set Sinker density = 10
-    set Transition zone viscosity jump = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 2
-  set Initial adaptive refinement = 5
-  set Adapt by fraction of cells = true
-  set Strategy = velocity
-  set Run postprocessors on initial refinement = true
-  set Coarsening fraction       = 0.0
-  set Refinement fraction       = 0.147
-end
-
-subsection Postprocess
-  set List of postprocessors = memory statistics, visualization
-
-  subsection Memory statistics
-    set Output peak virtual memory (VmPeak) = true
-  end
-
-  subsection Visualization
-    set List of output variables = viscosity
-  end
-end
diff --git a/benchmarks/nsinker_spherical_shell/nsinker.cc.bak b/benchmarks/nsinker_spherical_shell/nsinker.cc.bak
deleted file mode 100644
index 9ae67327596..00000000000
--- a/benchmarks/nsinker_spherical_shell/nsinker.cc.bak
+++ /dev/null
@@ -1,349 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-
-#include <deal.II/base/point.h>
-#include <deal.II/base/exceptions.h>
-
-
-namespace aspect
-{
-  /**
-   * This is the "Spherical Shell NSinker" benchmark.
-   */
-  namespace NSinkerBenchmark
-  {
-    using namespace dealii;
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class NSinkerMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * Constructor
-         */
-        NSinkerMaterial ();
-
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          const double sqrt_dynamic_viscosity_ratio = std::sqrt(dynamic_viscosity_ratio);
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const double chi = inside_outside_factor(in.position[i]);
-              out.viscosities[i] = (sqrt_dynamic_viscosity_ratio - 1./sqrt_dynamic_viscosity_ratio)*(1-chi) + 1./sqrt_dynamic_viscosity_ratio;
-              if (in.position[i].norm()<0.89583) // below "660km"?
-                out.viscosities[i] *= transition_zone_jump;
-              out.densities[i] = sinker_density * (1.0 - chi);
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override
-        {
-          return false;
-        }
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm)
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("NSinker");
-            {
-              prm.declare_entry ("Dynamic viscosity ratio", "1e3",
-                                 Patterns::Double (0),
-                                 "Viscosity in the sinkers.");
-              prm.declare_entry ("Sinker density", "10",
-                                 Patterns::Double (0),
-                                 "Density in the sinkers.");
-              prm.declare_entry ("Number of sinkers", "4",
-                                 Patterns::Integer (0,31),
-                                 "Number of sinking spheres.");
-              prm.declare_entry ("Transition zone viscosity jump", "1.0",
-                                 Patterns::Double (0),
-                                 "The factor by which the viscosity increases below the base of the "
-                                 "transition zone at a depth of 660km.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("NSinker");
-            {
-              dynamic_viscosity_ratio = prm.get_double ("Dynamic viscosity ratio");
-              sinker_density = prm.get_double ("Sinker density");
-              n_sinkers = prm.get_integer ("Number of sinkers");
-              transition_zone_jump = prm.get_double("Transition zone viscosity jump");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          // Declare dependencies on solution variables
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-
-
-      private:
-        /**
-         * Ratio of viscosities between sinkers and background material.
-         */
-        double dynamic_viscosity_ratio;
-
-        /**
-         * Sinker density. For a gravity of 1 this corresponds to
-         * the size of the right-hand-side forcing term.
-         */
-        double sinker_density;
-
-        /**
-         * Magnitude of the jump of viscosity when going below the transition zone.
-         */
-        double transition_zone_jump;
-
-        /**
-         * Number of sinking spheres.
-         */
-        unsigned int n_sinkers;
-
-        /**
-         * Centers for the sinkers provided by Cedric Thielot (pers. comm. from Dave May)
-         */
-        std::vector<Point<3>> centers;
-
-        /**
-         * Parameters for evaluating viscosity
-         */
-        double delta;
-        double omega;
-
-        /**
-         * Return a factor that indicates whether a point is inside or
-         * outside the sinker spheres. The function can be thought of
-         * as a 1 (outside) vs 0 (inside) factor, but is in reality a
-         * smoothed version of this that takes into account the
-         * distance from the centers of the sinkers.
-         */
-        double inside_outside_factor (const Point<dim> &p) const;
-    };
-
-
-    template <int dim>
-    NSinkerMaterial<dim>::NSinkerMaterial ()
-    {
-      delta = 2*200.0;
-      omega = 2*0.1;
-
-      // The original 75 randomly placed sinkers from the nsinker benchmark:
-      centers.resize(75);
-      centers[0] = Point<3>(2.4257829890e-01, 1.3469574514e-02, 3.8313885004e-01);
-      centers[1] = Point<3>(4.1465269048e-01, 6.7768972864e-02, 9.9312692973e-01);
-      centers[2] = Point<3>(4.8430804651e-01, 7.6533776604e-01, 3.1833815403e-02);
-      centers[3] = Point<3>(3.0935481671e-02, 9.3264044027e-01, 8.8787953411e-01);
-      centers[4] = Point<3>(5.9132973039e-01, 4.7877868473e-01, 8.3335433660e-01);
-      centers[5] = Point<3>(1.8633519681e-01, 7.3565270739e-01, 1.1505317181e-01);
-      centers[6] = Point<3>(6.9865863058e-01, 3.5560411138e-01, 6.3830000658e-01);
-      centers[7] = Point<3>(9.0821050755e-01, 2.9400041480e-01, 2.6497158886e-01);
-      centers[8] = Point<3>(3.7749399775e-01, 5.4162011554e-01, 9.2818150340e-03);
-      centers[9] = Point<3>(8.5247022139e-01, 4.6701098395e-01, 5.3607231962e-02);
-      centers[10] = Point<3>(9.7674759057e-01, 1.9675474344e-01, 8.5697294067e-01);
-      centers[11] = Point<3>(1.4421375987e-01, 8.0066218823e-01, 7.2939761948e-01);
-      centers[12] = Point<3>(9.8579064709e-01, 1.8340570954e-01, 4.9976021075e-01);
-      centers[13] = Point<3>(4.6986202126e-01, 9.7099129947e-01, 4.5077026191e-01);
-      centers[14] = Point<3>(9.5791877292e-02, 9.7408164664e-01, 3.9023506101e-01);
-      centers[15] = Point<3>(6.8067035576e-01, 2.6669318800e-02, 2.3124107450e-01);
-      centers[16] = Point<3>(4.6873909443e-01, 9.7960100555e-02, 4.1541002524e-01);
-      centers[17] = Point<3>(7.9629418710e-01, 3.1640260216e-01, 7.7853444953e-01);
-      centers[18] = Point<3>(8.2849331472e-01, 4.8714042059e-01, 3.6904878000e-01);
-      centers[19] = Point<3>(6.0284549678e-01, 2.4264360789e-02, 8.1111178631e-01);
-      centers[20] = Point<3>(3.5579259291e-01, 8.0610905439e-01, 2.7487712366e-01);
-      centers[21] = Point<3>(8.5981739865e-01, 9.5101905612e-01, 7.7727618477e-01);
-      centers[22] = Point<3>(6.8083745971e-01, 8.3518540665e-01, 9.6112961413e-01);
-      centers[23] = Point<3>(7.0542474869e-01, 7.3751226102e-02, 5.3685709440e-01);
-      centers[24] = Point<3>(9.5718558131e-01, 4.1806501915e-01, 4.1877679639e-01);
-      centers[25] = Point<3>(3.8161700050e-01, 8.3692747440e-01, 2.4006224854e-01);
-      centers[26] = Point<3>(7.2621119848e-01, 4.3161282150e-01, 1.1669089744e-01);
-      centers[27] = Point<3>(2.2391322592e-01, 3.0958795748e-01, 2.4480139429e-01);
-      centers[28] = Point<3>(3.7703382754e-01, 8.0753940242e-01, 3.1473643301e-01);
-      centers[29] = Point<3>(7.7522956709e-01, 2.8333410774e-01, 9.9634871585e-01);
-      centers[30] = Point<3>(6.3286731189e-01, 6.0091089904e-01, 5.0948022423e-01);
-      centers[31] = Point<3>(8.3412860373e-01, 1.9944285005e-01, 3.5980841627e-02);
-      centers[32] = Point<3>(7.3000523063e-01, 1.9791117972e-01, 2.9319749786e-01);
-      centers[33] = Point<3>(7.7034656693e-01, 2.1475035521e-01, 3.0922000730e-01);
-      centers[34] = Point<3>(6.0662675677e-02, 5.5759010630e-01, 4.1691651960e-01);
-      centers[35] = Point<3>(1.1594487686e-01, 6.8554530558e-01, 9.5995079957e-01);
-      centers[36] = Point<3>(2.7973348288e-02, 1.4806467395e-01, 5.2297503060e-01);
-      centers[37] = Point<3>(6.4133927209e-01, 9.8914607800e-01, 5.7813295237e-01);
-      centers[38] = Point<3>(6.8053043246e-01, 6.7497840462e-01, 3.6204645148e-01);
-      centers[39] = Point<3>(9.1470996426e-01, 5.3036934674e-01, 9.1761070439e-01);
-      centers[40] = Point<3>(2.8310876353e-01, 2.0898862472e-01, 4.7181570645e-01);
-      centers[41] = Point<3>(8.0657831198e-01, 1.6168943288e-01, 5.1429839456e-01);
-      centers[42] = Point<3>(8.1311740159e-01, 6.4168478858e-02, 4.7962416312e-01);
-      centers[43] = Point<3>(4.3309508843e-02, 9.0291512474e-01, 2.9450144167e-01);
-      centers[44] = Point<3>(6.8573011443e-01, 6.6033273035e-02, 8.2121989495e-01);
-      centers[45] = Point<3>(2.4277445452e-01, 3.1025718772e-01, 4.9255406554e-01);
-      centers[46] = Point<3>(3.5617944848e-01, 3.0799053857e-01, 3.9698166931e-01);
-      centers[47] = Point<3>(7.0916077621e-02, 8.8651657239e-01, 6.8403214295e-01);
-      centers[48] = Point<3>(5.2822650202e-01, 9.0281945043e-01, 6.8650344000e-01);
-      centers[49] = Point<3>(6.3316007640e-02, 1.5214040370e-01, 2.3765034985e-02);
-      centers[50] = Point<3>(4.1894298765e-01, 1.7479340461e-01, 7.5275125343e-01);
-      centers[51] = Point<3>(4.9031640053e-01, 7.4774375406e-01, 3.2927456281e-01);
-      centers[52] = Point<3>(1.1757708859e-01, 1.1812786251e-01, 3.7498524244e-01);
-      centers[53] = Point<3>(3.7696964032e-01, 7.2874483733e-01, 1.4480990830e-02);
-      centers[54] = Point<3>(3.8201288152e-01, 4.9049964756e-01, 8.2757658503e-01);
-      centers[55] = Point<3>(7.9664661586e-02, 9.2396727806e-01, 1.1804237828e-01);
-      centers[56] = Point<3>(9.3825167927e-01, 1.9597347043e-01, 7.2611756191e-01);
-      centers[57] = Point<3>(8.5786301170e-01, 1.0363770514e-01, 8.3891028205e-01);
-      centers[58] = Point<3>(5.6511039453e-01, 8.1040084307e-01, 4.0696941614e-01);
-      centers[59] = Point<3>(9.3497714490e-01, 1.6087440083e-01, 8.1605472361e-01);
-      centers[60] = Point<3>(4.3173963829e-01, 2.4810082244e-01, 8.3052277138e-01);
-      centers[61] = Point<3>(5.9621858625e-01, 6.4577903070e-01, 6.0816894547e-01);
-      centers[62] = Point<3>(4.9546643556e-01, 3.0438243752e-01, 7.5562733447e-01);
-      centers[63] = Point<3>(8.2861043319e-01, 4.5555055302e-01, 4.3814466774e-01);
-      centers[64] = Point<3>(8.9743076959e-01, 1.1894442752e-01, 9.8993320995e-02);
-      centers[65] = Point<3>(6.9884936497e-01, 5.6127713367e-01, 3.8478565932e-01);
-      centers[66] = Point<3>(9.2576270966e-02, 9.2938612771e-01, 1.9264837596e-01);
-      centers[67] = Point<3>(8.4125479722e-01, 9.6937695284e-01, 3.1844636161e-01);
-      centers[68] = Point<3>(1.2799954700e-01, 2.8838638276e-01, 9.0993508972e-01);
-      centers[69] = Point<3>(2.7905288352e-01, 4.1813262758e-02, 7.5550716964e-01);
-      centers[70] = Point<3>(8.0900019305e-01, 8.6624463269e-01, 9.7354159503e-01);
-      centers[71] = Point<3>(3.1358765965e-01, 4.6779574243e-01, 2.4304298462e-01);
-      centers[72] = Point<3>(8.2344259034e-01, 5.9961585635e-01, 7.4369772512e-01);
-      centers[73] = Point<3>(3.2766604253e-01, 8.3176720460e-02, 9.5114077951e-01);
-      centers[74] = Point<3>(8.2308128282e-01, 5.2712029523e-01, 3.1080186614e-01);
-
-      // First rescale their location from [0,1] to [-1,1]:
-      for (auto &p: centers)
-        for (int d=0; d<3; ++d)
-          p[d] = p[d]*2.0-1.0;
-
-      // Now erase all points with center outside our shell. This
-      // means some of them are not fully inside the domain, but this is ok.
-      auto e = std::remove_if(centers.begin(), centers.end(), [](const Point<3> &p)
-      {
-        return (p.norm()<0.54) || (p.norm()>1.0);
-      });
-      centers.erase(e, centers.end());
-    }
-
-
-
-    template <>
-    double
-    NSinkerMaterial<2>::inside_outside_factor (const Point<2> &p) const
-    {
-      double chi = 1.0;
-
-      for (unsigned int s=0; s<n_sinkers; ++s)
-        {
-          double dist = p.distance(Point<2>(centers[s](0), centers[s](1)));
-          double temp = 1-std::exp(-delta*
-                                   std::pow(std::max(0.0,dist-omega/2.0),2));
-          chi *= temp;
-        }
-      return chi;
-    }
-
-
-
-    template <>
-    double
-    NSinkerMaterial<3>::inside_outside_factor (const Point<3> &p) const
-    {
-      double chi = 1.0;
-
-      for (unsigned int s=0; s<n_sinkers; ++s)
-        {
-          double dist = p.distance(centers[s]);
-          double temp = 1-std::exp(-delta*
-                                   std::pow(std::max(0.0,dist-omega/2.0),2));
-          chi *= temp;
-        }
-      return chi;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace NSinkerBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(NSinkerMaterial,
-                                   "nsinker",
-                                   "A material model that corresponds to the 'Spherical Shell NSinker' benchmark.")
-  }
-}
diff --git a/benchmarks/onset-of-convection/convection-box-base.prm.bak b/benchmarks/onset-of-convection/convection-box-base.prm.bak
deleted file mode 100644
index b8a879461ee..00000000000
--- a/benchmarks/onset-of-convection/convection-box-base.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# This is the 'base' input file from which additional input files are generated
-# for the onset of convection example in:
-# benchmarks/onset-of-convection/onset-of-convection.ipynb.
-# UPPERCASE strings are replaced automatically by the python script
-# with appropriate values for each model run. This .prm file will fail if run
-# without substituting appropriate values for each UPPERCASE string.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use conduction timestep                = true
-
-subsection Termination criteria
-  set Termination criteria                 = end step
-  set End step                 = 1
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = WIDTH
-    set Y extent = HEIGHT
-    set X repetitions = NX
-    set Y repetitions = NY
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=PMAG, L=WIDTH,H=HEIGHT, pi=3.1415926536, k=2
-    set Function expression = DELTA_T*(1.0-z/H) - p*cos(k*pi*x/L)*sin(pi*z/H)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = DELTA_T
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = GRAVITY
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = DENSITY
-    set Reference specific heat       = SPECIFIC_HEAT
-    set Reference temperature         = 0
-    set Thermal conductivity          = KTHERMAL
-    set Thermal expansion coefficient = ALPHA
-    set Viscosity                     = VISCOSITY
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = IREF
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, point values
-
-  subsection Point values
-    set Evaluation points = EVALUATION_POINTS
-  end
-end
diff --git a/benchmarks/operator_splitting/advection_reaction/advection_reaction.base.prm.bak b/benchmarks/operator_splitting/advection_reaction/advection_reaction.base.prm.bak
deleted file mode 100644
index 2dc0f08dadb..00000000000
--- a/benchmarks/operator_splitting/advection_reaction/advection_reaction.base.prm.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-#########################################################
-# This is a benchmark case that tests the operator split
-# solver scheme, which can use a different time step to
-# compute reactions between compositional fields than
-# the time step used for advection.
-# In comparison to the example 'exponential_decay', the
-# initial comosition depends on x, and there is a constant
-# horizontal velocity. The composition decays over time,
-# following the equations for exponential decay with a decay
-# rate that depends on y.
-
-set Additional shared libraries = ./libadvection_reaction.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-# We use a new solver scheme option that enables the operator split.
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Use operator splitting                 = true
-set Maximum time step                      = 1
-
-# As we split the time-stepping of advection and reactions,
-# there are now two different time steps in the model:
-# We control the advection time step using the 'Maximum time step'
-# parameter (for easy comparison with the exponential decay test
-# case), and the reaction time step using the 'Reaction time step'
-# parameter. We will vary both parameters in different model runs.
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction time step                 = 0.0005
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.0
-    set cR = 0.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-# The velocity on all boundaries is prescribed to a constant
-# value, leading to horizontal flow from left to right.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  =
-    set Function expression = 0.01;0.0
-  end
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-# For this model, we choose a sinusoidal initial temperature
-# and composition, so that we can see how the field changes
-# over time as it is advected and decays over time.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = sin(2*pi*x)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = sin(2*pi*x)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0
-  set List of model names = ExponentialDecayBoundary
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = 0
-  set List of model names = ExponentialDecayBoundary
-end
-
-# We choose material and heating models that let temperature
-# and composition decay over time, and that is implemented in
-# a plugin.
-subsection Heating model
-  set List of model names = exponential decay heating
-
-  subsection Exponential decay heating
-    set Half life = 10
-  end
-end
-
-subsection Material model
-  set Model name = exponential decay
-
-  subsection Exponential decay
-    set Half life = 10
-  end
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1e5
-    set Density differential for compositional field 1 = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization, ExponentialDecayPostprocessor
-
-  subsection Visualization
-    set Time between graphical output = 0
-  end
-end
diff --git a/benchmarks/operator_splitting/advection_reaction/advection_reaction.cc.bak b/benchmarks/operator_splitting/advection_reaction/advection_reaction.cc.bak
deleted file mode 100644
index 3fb6fcdf568..00000000000
--- a/benchmarks/operator_splitting/advection_reaction/advection_reaction.cc.bak
+++ /dev/null
@@ -1,502 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <deal.II/base/function_lib.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_composition/interface.h>
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/melt.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/numerics/vector_tools.h>
-
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class ExponentialDecay : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-        static void declare_parameters (ParameterHandler &prm);
-        void parse_parameters(ParameterHandler &prm) override;
-
-        bool is_compressible () const override;
-
-        void create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-      private:
-
-        /**
-         * Pointer to the material model used as the base model
-         */
-        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
-
-        /**
-         * Parameters determining the initial decay rate.
-         */
-        double half_life;
-    };
-  }
-
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class ExponentialDecayHeating : public HeatingModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        static void declare_parameters (ParameterHandler &prm);
-
-        void parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Parameter determining the decay rate.
-         */
-        double half_life;
-    };
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    bool
-    ExponentialDecay<dim>::
-    is_compressible () const
-    {
-      return base_model->is_compressible();
-    }
-
-
-    template <int dim>
-    void
-    ExponentialDecay<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      AssertThrow(this->introspection().n_compositional_fields == 1,
-                  ExcMessage("Exponential decay model needs exactly one compositional field."));
-
-      // Fill material model outputs using the base model.
-      base_model->evaluate(in,out);
-      const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-      for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
-        for (unsigned int c=0; c < this->introspection().n_compositional_fields; ++c)
-          out.reaction_terms[q][c] = 0.0;
-
-      // fill melt reaction rates if they exist
-      ReactionRateOutputs<dim> *reaction_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
-
-      if (reaction_out != nullptr)
-        {
-          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
-            {
-              // dC/dt = - z * lambda * C
-              const double decay_constant = half_life > 0.0 ? log(2.0) / half_life : 0.0;
-              const double z = in.position[q](1);
-              reaction_out->reaction_rates[q][0] = - decay_constant * z / time_scale * in.composition[q][0];
-            }
-        }
-    }
-
-
-    template <int dim>
-    void
-    ExponentialDecay<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Exponential decay");
-        {
-          prm.declare_entry("Base model","composition reaction",
-                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
-                            "The name of a material model that will be modified by a position "
-                            "dependent melting rate. Valid values for this parameter "
-                            "are the names of models that are also valid for the "
-                            "``Material models/Model name'' parameter. See the documentation for "
-                            "that for more information.");
-          prm.declare_entry ("Half life", "0",
-                             Patterns::Double (0),
-                             "Time required for a compositional field to reduce to half its "
-                             "initial value. Units: Years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    ExponentialDecay<dim>::
-    parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Exponential decay");
-        {
-          AssertThrow( prm.get("Base model") != "reaction rate function",
-                       ExcMessage("You may not use ``reaction rate function'' as the base model for "
-                                  "a reaction rate function model.") );
-
-          // create the base model and initialize its SimulatorAccess base
-          // class; it will get a chance to read its parameters below after we
-          // leave the current section
-          base_model = create_material_model<dim>(prm.get("Base model"));
-          if (auto s = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
-            s->initialize_simulator (this->get_simulator());
-
-          half_life              = prm.get_double ("Half life");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // After parsing the parameters for the exponential decay material model,
-      // also parse the parameters related to the base model.
-      base_model->parse_parameters(prm);
-      this->model_dependence = base_model->get_model_dependence();
-    }
-
-
-    template <int dim>
-    void
-    ExponentialDecay<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
-        }
-    }
-  }
-
-
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    ExponentialDecayHeating<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
-              const MaterialModel::MaterialModelOutputs<dim> & /*out*/,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == in.n_evaluation_points(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          // dC/dt = - z * lambda * C
-          const double decay_constant = half_life > 0.0 ? log(2.0) / half_life : 0.0;
-          const double z = in.position[q](1);
-          heating_model_outputs.rates_of_temperature_change[q] = - decay_constant * z / time_scale * in.composition[q][0];
-
-          heating_model_outputs.heating_source_terms[q] = 0.0;
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-    template <int dim>
-    void
-    ExponentialDecayHeating<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Exponential decay heating");
-        {
-          prm.declare_entry ("Half life", "0",
-                             Patterns::Double (0),
-                             "Time required for the temperature to reduce to half of its "
-                             "initial value. Units: Years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ExponentialDecayHeating<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Exponential decay heating");
-        {
-          half_life              = prm.get_double ("Half life");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(dim+3) {}
-
-      void vector_value (const Point<dim>   &p,
-                         Vector<double>   &values) const override
-      {
-        double x = p(0);
-        double z = p(1);
-        double t = this->get_time();
-
-        values[0] = 0.0; // velocity x
-        values[1] = 0.0; // velocity z
-        values[2] = 0.0; // pressure
-        values[3] = sin(2*numbers::PI*(x-t*0.01))*exp(-log(2.0)/10.0*z*t); // temperature
-        values[4] = sin(2*numbers::PI*(x-t*0.01))*exp(-log(2.0)/10.0*z*t); // composition
-      }
-  };
-
-
-
-  template <int dim>
-  class ExponentialDecayBoundary : public BoundaryComposition::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Return the boundary composition as a function of position.
-       */
-      double
-      boundary_composition (const types::boundary_id boundary_indicator,
-                            const Point<dim> &position,
-                            const unsigned int compositional_field) const override;
-  };
-
-
-  template <int dim>
-  double
-  ExponentialDecayBoundary<dim>::
-  boundary_composition (const types::boundary_id /*boundary_indicator*/,
-                        const Point<dim> &p,
-                        const unsigned int /*compositional_field*/) const
-  {
-    double x = p(0);
-    double z = p(1);
-    const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-    double t = this->get_time() / time_scale;
-
-    return sin(2*numbers::PI*(x-t*0.01))*exp(-log(2.0)/10.0*z*t);
-  }
-
-
-
-  template <int dim>
-  class ExponentialDecayBoundaryTemperature : public BoundaryTemperature::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Return the boundary composition as a function of position.
-       */
-      double
-      boundary_temperature (const types::boundary_id boundary_indicator,
-                            const Point<dim> &position) const override;
-
-      double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-      double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-  };
-
-
-  template <int dim>
-  double
-  ExponentialDecayBoundaryTemperature<dim>::
-  boundary_temperature (const types::boundary_id /*boundary_indicator*/,
-                        const Point<dim> &p) const
-  {
-    double x = p(0);
-    double z = p(1);
-    const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-    double t = this->get_time() / time_scale;
-
-    return sin(2*numbers::PI*(x-t*0.01))*exp(-log(2.0)/10.0*z*t);
-  }
-
-  template <int dim>
-  double
-  ExponentialDecayBoundaryTemperature<dim>::
-  minimal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
-  {
-    return 0.0;
-  }
-
-
-
-  template <int dim>
-  double
-  ExponentialDecayBoundaryTemperature<dim>::
-  maximal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
-  {
-    return 1.0;
-  }
-
-
-
-  /**
-     * A postprocessor that evaluates the accuracy of the solution
-     * by using the L2 norm.
-     */
-  template <int dim>
-  class ExponentialDecayPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      ExponentialDecayPostprocessor();
-
-      /**
-       * Generate graphical output from the current solution.
-       */
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics) override;
-
-      double max_error;
-      double max_error_T;
-  };
-
-  template <int dim>
-  ExponentialDecayPostprocessor<dim>::ExponentialDecayPostprocessor ()
-  {
-    max_error = 0.0;
-    max_error_T = 0.0;
-  }
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  ExponentialDecayPostprocessor<dim>::execute (TableHandler & /*statistics*/)
-  {
-    AssertThrow (this->n_compositional_fields() == 1, ExcInternalError());
-
-    RefFunction<dim> ref_func;
-    ref_func.set_time(this->get_time());
-
-    const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.velocities).degree+2);
-
-    const unsigned int n_total_comp = this->introspection().n_components;
-
-    Vector<float> cellwise_errors_composition (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_temperature (this->get_triangulation().n_active_cells());
-
-    ComponentSelectFunction<dim> comp_C(this->introspection().component_indices.compositional_fields[0], n_total_comp);
-    ComponentSelectFunction<dim> comp_T(this->introspection().component_indices.temperature, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_composition,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_C);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_temperature,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_T);
-
-    const double current_error = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_composition, VectorTools::L2_norm);
-    max_error = std::max(max_error, current_error);
-
-    const double current_error_T = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_temperature, VectorTools::L2_norm);
-    max_error_T = std::max(max_error_T, current_error_T);
-
-    std::ostringstream os;
-    os << std::scientific
-       << "time=" << this->get_time()
-       << " ndofs= " << this->get_solution().size()
-       << " C_L2_current= " << current_error
-       << " C_L2_max= " << max_error
-       << " T_L2_current= " << current_error_T
-       << " T_L2_max= " << max_error_T
-       ;
-
-    return std::make_pair("Errors", os.str());
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ExponentialDecay,
-                                   "exponential decay",
-                                   "A material model that can be derived from any of the other "
-                                   "material model and that will replace the reaction rate by a "
-                                   "function that models exponential decay. The half life can be "
-                                   "chosen as an input parameter.")
-  }
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(ExponentialDecayHeating,
-                                  "exponential decay heating",
-                                  "A heating model that will use a model for exponential decay as "
-                                  "the heating reaction rate. The half life can be chosen as an "
-                                  "input parameter.")
-
-  }
-  ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(ExponentialDecayBoundary,
-                                             "ExponentialDecayBoundary",
-                                             "A boundary composition model that prescribes the analytical "
-                                             "solution for an initially sinusoidal field that is advected "
-                                             "and decays over time.")
-
-  ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(ExponentialDecayBoundaryTemperature,
-                                             "ExponentialDecayBoundary",
-                                             "A boundary composition model that prescribes the analytical "
-                                             "solution for an initially sinusoidal field that is advected "
-                                             "and decays over time.")
-
-  ASPECT_REGISTER_POSTPROCESSOR(ExponentialDecayPostprocessor,
-                                "ExponentialDecayPostprocessor",
-                                "A postprocessor that compares the solution "
-                                "to the analytical solution for exponential decay.")
-}
diff --git a/benchmarks/operator_splitting/doc/exponential_decay.part.1.prm.bak b/benchmarks/operator_splitting/doc/exponential_decay.part.1.prm.bak
deleted file mode 100644
index 767dd3beb7d..00000000000
--- a/benchmarks/operator_splitting/doc/exponential_decay.part.1.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-set Additional shared libraries = ./libexponential_decay.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 100
-
-# We use a new solver scheme option that enables the operator split.
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Use operator splitting                 = true
-set Maximum time step                      = 10
-
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction time step                 = 0.0005
-  end
-end
diff --git a/benchmarks/operator_splitting/doc/exponential_decay.part.2.prm.bak b/benchmarks/operator_splitting/doc/exponential_decay.part.2.prm.bak
deleted file mode 100644
index 7a74c690dce..00000000000
--- a/benchmarks/operator_splitting/doc/exponential_decay.part.2.prm.bak
+++ /dev/null
@@ -1,38 +0,0 @@
-# Both initial temperature and composition are set to 1,
-# and will decay starting from this value.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1.0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1.0
-  end
-end
-
-# We choose material and heating models that let temperature
-# and composition decay over time, and that is implemented in
-# a plugin.
-subsection Heating model
-  set List of model names = exponential decay heating
-
-  subsection Exponential decay heating
-    set Half life = 10
-  end
-end
-
-subsection Material model
-  set Model name = exponential decay
-
-  subsection Exponential decay
-    set Half life = 10
-  end
-end
diff --git a/benchmarks/operator_splitting/exponential_decay/exponential_decay.base.prm.bak b/benchmarks/operator_splitting/exponential_decay/exponential_decay.base.prm.bak
deleted file mode 100644
index f2b055294b7..00000000000
--- a/benchmarks/operator_splitting/exponential_decay/exponential_decay.base.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-#########################################################
-# This is a benchmark case that tests the operator split
-# solver scheme, which can use a different time step to
-# compute reactions between compositional fields than
-# the time step used for advection.
-# In this test case, there is no advection, and we start
-# from a composition (and temperature) that is 1 everywhere
-# in the domain and then decays over time, following the
-# equations for exponential decay.
-
-# We use a plugin that implements the reactions for exponential
-# decay.
-set Additional shared libraries = ./libexponential_decay.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 100
-set Use years in output instead of seconds = false
-
-# We use a new solver scheme option that enables the operator split.
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Use operator splitting                 = true
-set Maximum time step                      = 10
-
-# As we split the time-stepping of advection and reactions,
-# there are now two different time steps in the model:
-# We control the advection time step using the 'Maximum time step'
-# parameter (as this benchmark has no driving force, and hence very
-# low velocities, we can not use the CFL number), and the reaction
-# time step using the 'Reaction time step' parameter.
-# We will vary both parameters in different model runs.
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction time step                 = 0.0005
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-# Both initial temperature and composition are set to 1,
-# and will decay starting from this value.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1.0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1.0
-  end
-end
-
-# We choose material and heating models that let temperature
-# and composition decay over time, and that is implemented in
-# a plugin.
-subsection Heating model
-  set List of model names = exponential decay heating
-
-  subsection Exponential decay heating
-    set Half life = 10
-  end
-end
-
-subsection Material model
-  set Model name = exponential decay
-
-  subsection Exponential decay
-    set Half life = 10
-  end
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1e5
-    set Density differential for compositional field 1 = 0
-  end
-end
-
-# As composition and temperature do not depend on x or y,
-# we can use a coarse resolution.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-# We output some statistics about the composition, and make
-# use of a postprocessor that computes errors compared to the
-# analytical solution for exponential decay.
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization, ExponentialDecayPostprocessor
-
-  subsection Visualization
-    set Time between graphical output = 0
-  end
-end
diff --git a/benchmarks/operator_splitting/exponential_decay/exponential_decay.cc.bak b/benchmarks/operator_splitting/exponential_decay/exponential_decay.cc.bak
deleted file mode 100644
index d856eec21fb..00000000000
--- a/benchmarks/operator_splitting/exponential_decay/exponential_decay.cc.bak
+++ /dev/null
@@ -1,402 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <deal.II/base/function_lib.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/melt.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/numerics/vector_tools.h>
-
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class ExponentialDecay : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        static void declare_parameters (ParameterHandler &prm);
-
-        void parse_parameters(ParameterHandler &prm) override;
-
-        bool is_compressible () const override;
-
-        void create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-      private:
-
-        /**
-         * Pointer to the material model used as the base model
-         */
-        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
-
-        /**
-         * Parameter determining the decay rate.
-         */
-        double half_life;
-    };
-  }
-
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class ExponentialDecayHeating : public HeatingModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        static void declare_parameters (ParameterHandler &prm);
-
-        void parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Parameter determining the decay rate.
-         */
-        double half_life;
-    };
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    bool
-    ExponentialDecay<dim>::
-    is_compressible () const
-    {
-      return base_model->is_compressible();
-    }
-
-
-    template <int dim>
-    void
-    ExponentialDecay<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      AssertThrow(this->introspection().n_compositional_fields == 1,
-                  ExcMessage("Exponential decay model needs exactly one compositional field."));
-
-      // Fill material model outputs using the base model.
-      base_model->evaluate(in,out);
-      const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-      for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
-        for (unsigned int c=0; c < this->introspection().n_compositional_fields; ++c)
-          out.reaction_terms[q][c] = 0.0;
-
-      // fill melt reaction rates if they exist
-      ReactionRateOutputs<dim> *reaction_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
-
-      if (reaction_out != nullptr)
-        {
-          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
-            {
-              // dC/dt = - lambda * C
-              const double decay_constant = half_life > 0.0 ? log(2.0) / half_life : 0.0;
-              reaction_out->reaction_rates[q][0] = - decay_constant / time_scale * in.composition[q][0];
-            }
-        }
-    }
-
-
-    template <int dim>
-    void
-    ExponentialDecay<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Exponential decay");
-        {
-          prm.declare_entry("Base model","composition reaction",
-                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
-                            "The name of a material model that will be modified by a position "
-                            "dependent melting rate. Valid values for this parameter "
-                            "are the names of models that are also valid for the "
-                            "``Material models/Model name'' parameter. See the documentation for "
-                            "that for more information.");
-          prm.declare_entry ("Half life", "0",
-                             Patterns::Double (0),
-                             "Time required for a compositional field to reduce to half its "
-                             "initial value. Units: Years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    ExponentialDecay<dim>::
-    parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Exponential decay");
-        {
-          AssertThrow( prm.get("Base model") != "reaction rate function",
-                       ExcMessage("You may not use ``reaction rate function'' as the base model for "
-                                  "a reaction rate function model.") );
-
-          // create the base model and initialize its SimulatorAccess base
-          // class; it will get a chance to read its parameters below after we
-          // leave the current section
-          base_model = create_material_model<dim>(prm.get("Base model"));
-          if (auto s = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
-            s->initialize_simulator (this->get_simulator());
-
-          half_life              = prm.get_double ("Half life");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // After parsing the parameters for the exponential decay material model,
-      // also parse the parameters related to the base model.
-      base_model->parse_parameters(prm);
-      this->model_dependence = base_model->get_model_dependence();
-    }
-
-
-    template <int dim>
-    void
-    ExponentialDecay<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
-        }
-    }
-  }
-
-
-
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    ExponentialDecayHeating<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
-              const MaterialModel::MaterialModelOutputs<dim> & /*out*/,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == in.n_evaluation_points(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          // dC/dt = - lambda * C
-          const double decay_constant = half_life > 0.0 ? log(2.0) / half_life : 0.0;
-          heating_model_outputs.rates_of_temperature_change[q] = - decay_constant / time_scale * in.composition[q][0];
-
-          heating_model_outputs.heating_source_terms[q] = 0.0;
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-    template <int dim>
-    void
-    ExponentialDecayHeating<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Exponential decay heating");
-        {
-          prm.declare_entry ("Half life", "0",
-                             Patterns::Double (0),
-                             "Time required for the temperature to reduce to half of its "
-                             "initial value. Units: Years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ExponentialDecayHeating<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Exponential decay heating");
-        {
-          half_life              = prm.get_double ("Half life");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(dim+3) {}
-      void vector_value (const Point<dim> &/*position*/,
-                         Vector<double>   &values) const override
-      {
-        values[0] = 0.0; // velocity x
-        values[1] = 0.0; // velocity z
-        values[2] = 0.0; // pressure
-        values[3] = exp(-log(2.0)/10.0*this->get_time()); // temperature
-        values[4] = exp(-log(2.0)/10.0*this->get_time()); // composition
-      }
-  };
-
-
-
-  /**
-     * A postprocessor that evaluates the accuracy of the solution
-     * by using the L2 norm.
-     */
-  template <int dim>
-  class ExponentialDecayPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      ExponentialDecayPostprocessor();
-
-      /**
-       * Generate graphical output from the current solution.
-       */
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics) override;
-
-      double max_error;
-      double max_error_T;
-  };
-
-  template <int dim>
-  ExponentialDecayPostprocessor<dim>::ExponentialDecayPostprocessor ()
-  {
-    max_error = 0.0;
-    max_error_T = 0.0;
-  }
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  ExponentialDecayPostprocessor<dim>::execute (TableHandler & /*statistics*/)
-  {
-    AssertThrow (this->n_compositional_fields() == 1, ExcInternalError());
-
-    RefFunction<dim> ref_func;
-    ref_func.set_time(this->get_time());
-
-    const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.velocities).degree+2);
-
-    const unsigned int n_total_comp = this->introspection().n_components;
-
-    Vector<float> cellwise_errors_composition (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_temperature (this->get_triangulation().n_active_cells());
-
-    ComponentSelectFunction<dim> comp_C(this->introspection().component_indices.compositional_fields[0], n_total_comp);
-    ComponentSelectFunction<dim> comp_T(this->introspection().component_indices.temperature, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_composition,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_C);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_temperature,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_T);
-
-    const double current_error = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_composition, VectorTools::L2_norm);
-    max_error = std::max(max_error, current_error);
-
-    const double current_error_T = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_temperature, VectorTools::L2_norm);
-    max_error_T = std::max(max_error_T, current_error_T);
-
-    std::ostringstream os;
-    os << std::scientific
-       << "time=" << this->get_time()
-       << " ndofs= " << this->get_solution().size()
-       << " C_L2_current= " << current_error
-       << " C_L2_max= " << max_error
-       << " T_L2_current= " << current_error_T
-       << " T_L2_max= " << max_error_T
-       ;
-
-    return std::make_pair("Errors", os.str());
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ExponentialDecay,
-                                   "exponential decay",
-                                   "A material model that can be derived from any of the other "
-                                   "material model and that will replace the reaction rate by a "
-                                   "function that models exponential decay. The half life can be "
-                                   "chosen as an input parameter.")
-
-  }
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(ExponentialDecayHeating,
-                                  "exponential decay heating",
-                                  "A heating model that will use a model for exponential decay as "
-                                  "the heating reaction rate. The half life can be chosen as an "
-                                  "input parameter.")
-
-  }
-  ASPECT_REGISTER_POSTPROCESSOR(ExponentialDecayPostprocessor,
-                                "ExponentialDecayPostprocessor",
-                                "A postprocessor that compares the solution "
-                                "to the analytical solution for exponential decay.")
-}
diff --git a/benchmarks/particle_integration_scheme/circle.prm.bak b/benchmarks/particle_integration_scheme/circle.prm.bak
deleted file mode 100644
index 83ac384ab47..00000000000
--- a/benchmarks/particle_integration_scheme/circle.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1.0
-set Use years in output instead of seconds = false
-set CFL number                             = 1.0
-set Output directory                       = circle_euler_1.0
-set Timing output frequency                = 100
-set Nonlinear solver scheme                = Advection only
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 4
-    set Y extent = 4
-    set Box origin X coordinate = -2
-    set Box origin Y coordinate = -2
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function expression = 2 * pi * (1+0.0*sin(t))*-y; 2 * pi * (1+0.0*sin(t))*x
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Particle generator name = ascii file
-  set Integration scheme = rk2
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/particle_integration_scheme/
-      set Data file name = particle.dat
-    end
-  end
-end
diff --git a/benchmarks/particle_integration_scheme/euler.part.prm.bak b/benchmarks/particle_integration_scheme/euler.part.prm.bak
deleted file mode 100644
index bc430c393c8..00000000000
--- a/benchmarks/particle_integration_scheme/euler.part.prm.bak
+++ /dev/null
@@ -1,6 +0,0 @@
-subsection Postprocess
-end
-
-subsection Particles
-  set Integration scheme = euler
-end
diff --git a/benchmarks/particle_integration_scheme/rk2.part.prm.bak b/benchmarks/particle_integration_scheme/rk2.part.prm.bak
deleted file mode 100644
index f68ef89b515..00000000000
--- a/benchmarks/particle_integration_scheme/rk2.part.prm.bak
+++ /dev/null
@@ -1,6 +0,0 @@
-subsection Postprocess
-end
-
-subsection Particles
-  set Integration scheme = rk2
-end
diff --git a/benchmarks/particle_integration_scheme/rk4.part.prm.bak b/benchmarks/particle_integration_scheme/rk4.part.prm.bak
deleted file mode 100644
index 1158abaf34f..00000000000
--- a/benchmarks/particle_integration_scheme/rk4.part.prm.bak
+++ /dev/null
@@ -1,6 +0,0 @@
-subsection Postprocess
-end
-
-subsection Particles
-  set Integration scheme = rk4
-end
diff --git a/benchmarks/polydiapirs/polydiapirs.prm.bak b/benchmarks/polydiapirs/polydiapirs.prm.bak
deleted file mode 100644
index b473530e640..00000000000
--- a/benchmarks/polydiapirs/polydiapirs.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# This is the setup of a polydiapirs experiment, i.e.
-# multiwavelength gravity structures.
-# It consists of three layers of Newtonian fluids
-# set in motion by gravitational instability, as in
-# case II of Weinberg and Schmeling 1992.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 250
-set Use years in output instead of seconds = false
-set CFL number                             = 1.
-set Maximum time step                      = 0.1
-set Output directory                       = output_polydiapirs
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2.24
-    set Y extent  = 1.0000
-    set X repetitions = 2
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right,top
-  set Zero velocity boundary indicators       = bottom
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities = 100, 90, 89
-    set Viscosities = 100, 1, 1
-    set Viscosity averaging scheme = harmonic
-    set Thermal expansivities = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z< 0.25 + (rand()-0.5)/5000. && z>=0.125+(rand()-0.5)/5000.) ,1 , 0 ) ; if (z<0.125+(rand    ()-0.5)/5000., 1 , 0)
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 7
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics, material statistics, global statistics, Stokes residual
-
-  subsection Visualization
-    set List of output variables = viscosity,density, strain rate
-    set Output format                 = vtu
-    set Time between graphical output = 5
-  end
-end
diff --git a/benchmarks/rayleigh_taylor_instability/blank.prm.bak b/benchmarks/rayleigh_taylor_instability/blank.prm.bak
deleted file mode 100644
index 51699401b79..00000000000
--- a/benchmarks/rayleigh_taylor_instability/blank.prm.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-set Additional shared libraries  = ./librayleigh_taylor_instability.so
-set Dimension                    = 2
-set Start time                   = 0
-set End time                     = 0
-set Output directory             = output
-set Pressure normalization       = volume
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 512e3
-    set Y extent  = 512e3
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators =  bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity, strain rate
-  end
-end
diff --git a/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.cc.bak b/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.cc.bak
deleted file mode 100644
index 879c094ac89..00000000000
--- a/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.cc.bak
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  namespace RTinstabilityBenchmark
-  {
-    using namespace dealii;
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class RTinstabilityMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> &pos = in.position[i];
-
-              if ( pos[1]< 256e3 + amplitude*std::cos(pos[0]/lambda*2.0*numbers::PI))
-                {
-                  out.viscosities[i] = eta2;
-                  out.densities[i] = rho2;
-                }
-              else
-                {
-                  out.viscosities[i] = eta1;
-                  out.densities[i] = rho1;
-                }
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm)
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("RTinstability");
-            {
-              prm.declare_entry ("eta1", "1e21",
-                                 Patterns::Double (0),
-                                 "Viscosity of the mantle.");
-              prm.declare_entry ("eta2", "1e23",
-                                 Patterns::Double (0),
-                                 "Viscosity in the inclusion.");
-              prm.declare_entry ("rho1", "3200",
-                                 Patterns::Double (0),
-                                 "density of the mantle.");
-              prm.declare_entry ("rho2", "3232",
-                                 Patterns::Double (0),
-                                 "density in the inclusion.");
-              prm.declare_entry ("amplitude", "1000",
-                                 Patterns::Double (0),
-                                 "perturbation amplitude.");
-              prm.declare_entry ("lambda", "256e3",
-                                 Patterns::Double (0),
-                                 "perturbation wavelength.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("RTinstability");
-            {
-              eta1 = prm.get_double ("eta1");
-              eta2 = prm.get_double ("eta2");
-              rho1 = prm.get_double ("rho1");
-              rho2 = prm.get_double ("rho2");
-              amplitude = prm.get_double ("amplitude");
-              lambda = prm.get_double ("lambda");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          // Declare dependencies on solution variables
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-      private:
-        double eta1;
-        double eta2;
-        double rho1;
-        double rho2;
-        double amplitude;
-        double lambda;
-
-    };
-
-
-    template <int dim>
-    bool
-    RTinstabilityMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace RTinstabilityBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(RTinstabilityMaterial,
-                                   "RTinstabilityMaterial",
-                                   "A material model that corresponds to the `RTinstability' benchmark. "
-                                   "See the manual for more information.")
-  }
-}
diff --git a/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.prm.bak b/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.prm.bak
deleted file mode 100644
index 7a0a18a736a..00000000000
--- a/benchmarks/rayleigh_taylor_instability/rayleigh_taylor_instability.prm.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-set Additional shared libraries  = ./librayleigh_taylor_instability.so
-set Dimension                    = 2
-set Start time                   = 0
-set End time                     = 0
-set Output directory             = output
-set Pressure normalization       = volume
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 512e3
-    set Y extent  = 512e3
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators =  bottom, top
-end
-
-subsection Material model
-  set Model name  = RTinstabilityMaterial
-
-  subsection RTinstability
-    set eta1 = 1e21
-    set eta2 = 1e21
-    set rho1 = 3300
-    set rho2 = 3000
-    set amplitude = 4000
-    set lambda = 256e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement     = 4
-  set Initial adaptive refinement   = 6
-  set Strategy                      = density
-  set Refinement fraction           = 0.5
-  set Run postprocessors on initial refinement = true
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity, strain rate
-  end
-end
diff --git a/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm.bak b/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm.bak
deleted file mode 100644
index 08f66c0330c..00000000000
--- a/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm.bak
+++ /dev/null
@@ -1,158 +0,0 @@
-# Input file for the 2D Rayleigh Taylor benchmark described
-# in Kaus et al. (2010, 10.1016/j.pepi.2010.04.007).
-# The benchmark considers a denser, more viscous layer
-# overlying lighter, less viscous mantle. The interface
-# between the layers is perturbed, leading to drips along
-# the vertical domain boundaries. A free surface allows
-# for the development of surface topography.
-
-############### Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 6e6
-
-# For a timestep of 2500 yr and no stabilization,
-# the model is stable. For a timestep of 10000 yr,
-# it is not ("drunken sailor").
-set Maximum time step                      = 100e2
-set Use years in output instead of seconds = true
-set CFL number                             = 0.5
-set Output directory                       = output_nostab_10000
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Pressure normalization                 = no
-
-############## Element types
-# Use dicontinuous composition elements for a sharp interface
-subsection Discretization
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-    set Global composition maximum = 1
-    set Global composition minimum = 0
-  end
-end
-
-############### Geometry
-# We consider a 2D box of 500x500 km
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500e3
-    set Y extent  = 500e3
-  end
-end
-
-############### Boundary conditions
-# Vertical boundaries are free slip,
-# the bottom boundary is no slip,
-# and the top boundary is a free surface.
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators                    = top: free surface
-  set Additional tangential mesh velocity boundary indicators = left, right
-
-  subsection Free surface
-    # We test the stability of the free surface
-    # for a timestep of 2500 and 10000 yr with
-    # (0.5) and without (0.0) stabilization.
-    set Free surface stabilization theta = 0.0
-
-    # We compare the vertical and normal projection of
-    # the free surface.
-    #set Surface velocity projection      = normal
-    set Surface velocity projection      = vertical
-  end
-end
-
-############### Material properties
-# No temperature effects.
-# The top layer is denser and more viscous.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                                      = 1.0e20
-    set Composition viscosity prefactor                = 10
-    set Reference temperature                          = 1.0
-    set Reference density                              = 3200.0
-    set Density differential for compositional field 1 = 100
-    set Thermal expansion coefficient                  = 0.0
-    set Thermal conductivity                           = 2.7
-    set Reference specific heat                        = 1250
-  end
-end
-
-############## Gravity
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# We ignore any temperature effects.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom, left, right
-  set List of model names = initial temperature
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional fields
-# We include one compositional field plus the background material.
-# The material interface is sinusoidally perturbed with an amplitude
-# A of 5 km.
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = A=5000, W=250e3, C=250e3
-    set Function expression = if(y>400e3+A*cos(pi*(x-C)/W),1,0)
-  end
-end
-
-############### Mesh refinement
-# The Kaus paper considers a resolution of 50x50 elements.
-# We use 64x64.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-# We monitor the topography over time.
-subsection Postprocess
-  set List of postprocessors = visualization, topography, composition statistics, maximum depth of field, velocity statistics
-
-  subsection Visualization
-    set Time between graphical output = 1.0e5
-    set List of output variables      = viscosity, density
-    set Output mesh velocity          = true
-  end
-
-  subsection Topography
-    set Output to file           = true
-    set Time between text output = 2.e5
-  end
-end
diff --git a/benchmarks/rayleigh_taylor_instability_free_surface/rose_rayleigh_taylor_instability.prm.bak b/benchmarks/rayleigh_taylor_instability_free_surface/rose_rayleigh_taylor_instability.prm.bak
deleted file mode 100644
index fad2de9f2ff..00000000000
--- a/benchmarks/rayleigh_taylor_instability_free_surface/rose_rayleigh_taylor_instability.prm.bak
+++ /dev/null
@@ -1,49 +0,0 @@
-# Input file for the 2D Rayleigh Taylor benchmark described
-# in Rose et al. (2017, 10.1016/j.pepi.2016.11.007).
-# The benchmark considers a denser, more viscous layer
-# overlying lighter, less viscous mantle. The interface
-# between the layers is perturbed, leading to drips along
-# the vertical domain boundaries. A free surface allows
-# for the development of surface topography.
-# Compared to the setup in Kaus et al. (2010), the resolution
-# of the layer interface is higher and therefore a timestep
-# of 5000 yr is still stable without free surface stabilization,
-# while a timestep of 10,000 yr is not.
-
-############### Global parameters
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm
-
-set Start time                             = 0
-set Maximum time step                      = 1e5
-set End time                               = 6e6
-set CFL number                             = 0.2
-set Output directory                       = output_Rose_stab_CFL02
-
-############### Boundary conditions
-subsection Mesh deformation
-  set Mesh deformation boundary indicators                    = top: free surface
-  set Additional tangential mesh velocity boundary indicators = left, right
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-    set Surface velocity projection      = vertical
-  end
-end
-
-############### Mesh refinement
-# The Rose et al. (2017) paper considers a maximum local resolution
-# of ~1 km by using global and adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 4
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.95
-  set Coarsening fraction                = 0.05
-  set Strategy                           = composition, boundary
-  set Time steps between mesh refinement = 5
-
-  subsection Boundary
-    set Boundary refinement indicators = top
-  end
-end
diff --git a/benchmarks/rigid_shear/instantaneous/rigid_shear.prm.bak b/benchmarks/rigid_shear/instantaneous/rigid_shear.prm.bak
deleted file mode 100644
index a60074dacad..00000000000
--- a/benchmarks/rigid_shear/instantaneous/rigid_shear.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# A description of the "Rigid shear" benchmark for which a known solution
-# is available. See Gassmoeller et al. "Evaluating
-# the Accuracy of Hybrid Finite Element/Particle-In-Cell Methods for
-# Modeling Incompressible Stokes Flow" for a discussion.
-
-set Additional shared libraries            = ../plugin/librigid_shear.so
-set Dimension                              = 2
-set End time                               = 0.0
-set Output directory                       = output
-set Pressure normalization                 = no
-set Nonlinear solver scheme                = no Advection, single Stokes
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Compositional fields
-  set Names of fields = density_comp
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*x)*sin(pi*y) + 2.0
-  end
-end
-
-subsection Material model
-  set Model name = rigid shear
-end
-
-subsection Rigid shear benchmark
-  set Use analytical density = true
-  set Use transient solution = false
-end
-
-subsection Gravity model
-  set Model name = rigid shear
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators =
-  set List of model names =
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (x<0.5) ? 0.4 : 0.6
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, rigid shear
-
-  subsection Visualization
-    set Time between graphical output = 0.0
-    set List of output variables = material properties
-  end
-end
-
-# Increase Stokes solver accuracy to ensure convergence to
-# very low error values
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
diff --git a/benchmarks/rigid_shear/plugin/rigid_shear.cc.bak b/benchmarks/rigid_shear/plugin/rigid_shear.cc.bak
deleted file mode 100644
index 903b0ce97ee..00000000000
--- a/benchmarks/rigid_shear/plugin/rigid_shear.cc.bak
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/gravity_model/interface.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/postprocess/particles.h>
-#include <aspect/particle/property/interface.h>
-#include <aspect/particle/world.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace RigidShearBenchmark
-  {
-    /**
-     * This is the "Rigid shear" benchmark based on a suggestion in the following paper:
-     * @code
-     *  @Article{KKSCND97,
-     *  author =       {P. E. van Keken and S. D. King and H. Schmeling and U. R. Christensen and D. Neumeister and M.-P. Doin},
-     *  title =        {A comparison of methods for the modeling of thermochemical convection},
-     *  journal =      {J. Geoph. Res.},
-     *  year =         1997,
-     *  volume =       102,
-     *  pages =        {22477--22495}}
-     * @endcode
-     *
-     * The results of the modification are published in Gassmoeller,
-     * Lokavarapu, Bangerth, Puckett, 2019, "Evaluating the Accuracy of Hybrid
-     * Finite Element/Particle-In-Cell Methods for Modeling Incompressible
-     * Stokes Flow".
-     */
-    namespace AnalyticSolutions
-    {
-      double
-      phase_function(const double t)
-      {
-        return std::exp(t)-1.;
-      }
-
-      template <int dim>
-      double
-      density(const Point<dim> &p,
-              const double t,
-              const bool transient)
-      {
-        const double pi = numbers::PI;
-        const double phase = (transient == true) ? phase_function(t) : 0.0;
-
-        return std::sin(pi*(p[0]-phase)) * std::sin(pi*p[1]) + 2.0;
-      }
-
-      /**
-       * The exact solution for the Rigid Shear benchmark.
-       */
-      template <int dim>
-      class FunctionRigidShear : public Function<dim>
-      {
-        public:
-          FunctionRigidShear(const unsigned int n_components,
-                             const bool transient)
-            : Function<dim>(n_components),
-              transient(transient) {}
-
-          void vector_value(const Point<dim> &p,
-                            Vector<double> &values) const override
-          {
-            const double pi = numbers::PI;
-            const double t = this->get_time();
-            const double phase = (transient == true) ? phase_function(t) : 0.0;
-
-            values[0] = std::sin(pi*(p[0]-phase)) * std::cos(pi*p[1]);
-
-            if (transient == true)
-              values[0] += std::exp(t);
-
-            values[1] = -std::cos(pi*(p[0]-phase)) * std::sin(pi*p[1]);
-            values[2] = 2.0 * pi * std::cos(pi*(p[0]-phase)) * std::cos(pi*p[1]);
-            values[4] = density(p,t,transient);
-            return;
-          }
-
-        private:
-          bool transient;
-      };
-    }
-
-
-
-    /**
-     * A material model for the stationary form of the rigid shear benchmark. All properties
-     * are defined in dependence of position.
-     */
-    template <int dim>
-    class RigidShearMaterial : public MaterialModel::Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          const double t = (this->simulator_is_past_initialization()) ? this->get_time() : 0.0;
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              if (use_analytical_density == true)
-                out.densities[i] = AnalyticSolutions::density(in.position[i],t,use_transient_flow_solution);
-              else
-                out.densities[i] = in.composition[i][0];
-
-              out.viscosities[i] = 1.0;
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0.0;
-              out.thermal_conductivities[i] = 0.0;
-
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                out.reaction_terms[i][c] = 0.0;
-            }
-        }
-
-
-
-        bool is_compressible() const override
-        {
-          return false;
-        }
-
-
-
-        bool use_transient_solution() const
-        {
-          return use_transient_flow_solution;
-        }
-
-
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm)
-        {
-          //create a global section in the parameter file for parameters
-          //that describe this benchmark. note that we declare them here
-          //in the material model, but other kinds of plugins (e.g., the gravity
-          //model below) may also read these parameters even though they do not
-          //declare them
-          prm.enter_subsection("Rigid shear benchmark");
-          {
-            prm.declare_entry("Use analytical density", "true",
-                              Patterns::Bool(),
-                              "Whether to use the analytical density solution, or to look for a "
-                              "compositional field named <density_field> to use as density.");
-
-            prm.declare_entry("Use transient solution", "false",
-                              Patterns::Bool(),
-                              "Whether to use the transient flow solution, or to use the "
-                              "default steady-state solution.");
-          }
-          prm.leave_subsection();
-        }
-
-        void
-        parse_parameters(ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Rigid shear benchmark");
-          {
-            use_analytical_density = prm.get_bool ("Use analytical density");
-            use_transient_flow_solution = prm.get_bool ("Use transient solution");
-          }
-          prm.leave_subsection();
-
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-        bool use_analytical_density;
-        bool use_transient_flow_solution;
-    };
-
-
-
-
-    /**
-     * Gravity model for the Rigid shear benchmark
-     */
-    template <int dim>
-    class RigidShearGravity : public aspect::GravityModel::Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        Tensor<1,dim> gravity_vector (const Point<dim> &pos) const override
-        {
-          const double pi = numbers::PI;
-          const double t = (this->simulator_is_past_initialization()) ? this->get_time() : 0.0;
-
-          const RigidShearMaterial<dim> &
-          material_model
-            = Plugins::get_plugin_as_type<const RigidShearMaterial<dim>>(this->get_material_model());
-          const bool transient = material_model.use_transient_solution();
-          const double phase = (transient == true) ? AnalyticSolutions::phase_function(t) : 0.0;
-
-          const double forcing_term = - 4.0 * pi * pi * std::cos(pi*(pos[0] - phase)) * std::sin(pi*pos[1]);
-
-          Tensor<1,dim> gravity;
-          gravity[0] =  0.0;
-          gravity[1] =  forcing_term / AnalyticSolutions::density(pos,t,transient);
-
-          return gravity;
-        }
-    };
-
-    /**
-     * A postprocessor that evaluates the accuracy of the solution.
-     *
-     * The implementation of error evaluators that correspond to the
-     * benchmarks defined in the paper Gassmoeller et al. referenced above.
-     */
-    template <int dim>
-    class RigidShearPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate error output for velocity, pressure, and density.
-         */
-        std::pair<std::string, std::string>
-        execute(TableHandler &statistics) override
-        {
-          const RigidShearMaterial<dim> &
-          material_model
-            = Plugins::get_plugin_as_type<const RigidShearMaterial<dim>>(this->get_material_model());
-
-          AnalyticSolutions::FunctionRigidShear<dim> ref_func(this->introspection().n_components,
-                                                              material_model.use_transient_solution());
-          ref_func.set_time(this->get_time());
-
-          AssertThrow(Plugins::plugin_type_matches<const RigidShearMaterial<dim>>(this->get_material_model()),
-                      ExcMessage(
-                        "Postprocessor RigidShearPostprocessor only works with the material model RigidShearMaterial."));
-
-          const QGauss<dim> quadrature_formula(this->introspection().polynomial_degree.velocities + 2);
-
-          Vector<double> cellwise_errors_u(this->get_triangulation().n_active_cells());
-          Vector<double> cellwise_errors_p(this->get_triangulation().n_active_cells());
-          Vector<double> cellwise_errors_ul2(this->get_triangulation().n_active_cells());
-          Vector<double> cellwise_errors_pl2(this->get_triangulation().n_active_cells());
-          Vector<double> cellwise_errors_rhol2(this->get_triangulation().n_active_cells());
-
-          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0, dim),
-                                              this->get_fe().n_components());
-          ComponentSelectFunction<dim> comp_p(dim,
-                                              this->get_fe().n_components());
-          ComponentSelectFunction<dim> comp_rho(dim+2,
-                                                this->get_fe().n_components());
-
-          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
-                                            this->get_solution(),
-                                            ref_func,
-                                            cellwise_errors_u,
-                                            quadrature_formula,
-                                            VectorTools::L1_norm,
-                                            &comp_u);
-          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
-                                            this->get_solution(),
-                                            ref_func,
-                                            cellwise_errors_p,
-                                            quadrature_formula,
-                                            VectorTools::L1_norm,
-                                            &comp_p);
-          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
-                                            this->get_solution(),
-                                            ref_func,
-                                            cellwise_errors_ul2,
-                                            quadrature_formula,
-                                            VectorTools::L2_norm,
-                                            &comp_u);
-          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
-                                            this->get_solution(),
-                                            ref_func,
-                                            cellwise_errors_pl2,
-                                            quadrature_formula,
-                                            VectorTools::L2_norm,
-                                            &comp_p);
-          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
-                                            this->get_solution(),
-                                            ref_func,
-                                            cellwise_errors_rhol2,
-                                            quadrature_formula,
-                                            VectorTools::L2_norm,
-                                            &comp_rho);
-
-          const double u_l1 = Utilities::MPI::sum(cellwise_errors_u.l1_norm(), this->get_mpi_communicator());
-          const double p_l1 = Utilities::MPI::sum(cellwise_errors_p.l1_norm(), this->get_mpi_communicator());
-          const double u_l2 = std::sqrt(
-                                Utilities::MPI::sum(cellwise_errors_ul2.norm_sqr(), this->get_mpi_communicator()));
-          const double p_l2 = std::sqrt(
-                                Utilities::MPI::sum(cellwise_errors_pl2.norm_sqr(), this->get_mpi_communicator()));
-          const double rho_l2 = std::sqrt(
-                                  Utilities::MPI::sum(cellwise_errors_rhol2.norm_sqr(), this->get_mpi_communicator()));
-
-          statistics.add_value ("u_L2",
-                                u_l2);
-          statistics.set_precision ("u_L2", 14);
-          statistics.set_scientific ("u_L2", true);
-
-          statistics.add_value ("p_L2",
-                                p_l2);
-          statistics.set_precision ("p_L2", 14);
-          statistics.set_scientific ("p_L2", true);
-
-          statistics.add_value ("rho_L2",
-                                rho_l2);
-          statistics.set_precision ("rho_L2", 14);
-          statistics.set_scientific ("rho_L2", true);
-
-          std::ostringstream os;
-          os << std::scientific << u_l1
-             << ", " << p_l1
-             << ", " << u_l2
-             << ", " << p_l2
-             << ", " << rho_l2;
-
-          return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2, rho_L2:", os.str());
-        }
-    };
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace RigidShearBenchmark
-  {
-    ASPECT_REGISTER_GRAVITY_MODEL(RigidShearGravity,
-                                  "rigid shear",
-                                  "A gravity model.")
-
-    ASPECT_REGISTER_MATERIAL_MODEL(RigidShearMaterial,
-                                   "rigid shear",
-                                   "A material model for the stationary form of the rigid shear benchmark. All properties "
-                                   "are defined in dependence of position.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(RigidShearPostprocessor,
-                                  "rigid shear",
-                                  "The implementation of error evaluators that correspond to the "
-                                  "benchmarks defined in the paper Gassmoeller et al. referenced above.")
-  }
-}
diff --git a/benchmarks/rigid_shear/steady-state/rigid_shear.prm.bak b/benchmarks/rigid_shear/steady-state/rigid_shear.prm.bak
deleted file mode 100644
index ec607b5004c..00000000000
--- a/benchmarks/rigid_shear/steady-state/rigid_shear.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# A description of the time-dependent "Rigid shear" benchmark for which a known
-# solution is available. See Gassmoeller et al. "Evaluating the Accuracy of
-# Hybrid Finite Element/Particle-In-Cell Methods for Modeling Incompressible
-# Stokes Flow" for a discussion.
-
-set Additional shared libraries            = ../plugin/librigid_shear.so
-set Dimension                              = 2
-set End time                               = 0.1
-set Output directory                       = output
-set Pressure normalization                 = no
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_comp
-  set Compositional field methods = particles
-  set Mapped particle properties = density_comp:function
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*x)*sin(pi*y) + 2.0
-  end
-end
-
-subsection Material model
-  set Model name = rigid shear
-end
-
-subsection Rigid shear benchmark
-  set Use analytical density = false
-  set Use transient solution = false
-end
-
-subsection Gravity model
-  set Model name = rigid shear
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators =
-  set List of model names =
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (x<0.5) ? 0.4 : 0.6
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 3
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles, rigid shear
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-    set List of output variables = material properties, gravity
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = bilinear least squares
-  set Update ghost particles = true
-  set Minimum particles per cell = 9
-  set Maximum particles per cell = 16384
-  set Particle generator name = reference cell
-
-  subsection Function
-    set Function expression = sin(pi*x)*sin(pi*y) + 2.0
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 9
-    end
-  end
-end
diff --git a/benchmarks/rigid_shear/transient/rigid_shear.prm.bak b/benchmarks/rigid_shear/transient/rigid_shear.prm.bak
deleted file mode 100644
index 6ce240c74c3..00000000000
--- a/benchmarks/rigid_shear/transient/rigid_shear.prm.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-# A description of the time-dependent "Rigid shear" benchmark for which a known
-# solution is available. See Gassmoeller et al. "Benchmarking the accuracy of
-# higher order particle methods in geodynamic models of transient flow" for a
-# discussion.
-
-set Additional shared libraries            = ../plugin/librigid_shear.so
-set Dimension                              = 2
-set End time                               = 1.098612289
-set Output directory                       = output
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set X repetitions = 2
-    set Y extent = 1
-    set X periodic = true
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-
-    #set Stokes solver type = block GMG
-    set Krylov method for cheap solver steps = IDR(s)
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom: function, top: function
-
-  subsection Function
-    set Function expression = sin(pi*(x-exp(t)+1))*cos(pi*y) + exp(t); 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_comp
-
-  #set Compositional field methods = particles
-  #set Mapped particle properties = density_comp:function
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*x)*sin(pi*y) + 2
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-  set Model name = rigid shear
-end
-
-subsection Rigid shear benchmark
-  set Use analytical density = false
-  set Use transient solution = true
-end
-
-subsection Gravity model
-  set Model name = rigid shear
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators =
-  set List of model names =
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (x<0.5) ? 0.4 : 0.6
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 3
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, rigid shear
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-    set List of output variables = material properties, gravity
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = bilinear least squares
-  set Update ghost particles = true
-  set Minimum particles per cell = 12
-  set Maximum particles per cell = 16384
-  set Particle generator name = random uniform
-  set Load balancing strategy = add particles
-
-  subsection Function
-    set Function expression = sin(pi*x)*sin(pi*y) + 2
-  end
-
-  subsection Interpolator
-    subsection Quadratic least squares
-      set Use boundary extrapolation = true
-    end
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 8192
-    end
-  end
-end
diff --git a/benchmarks/shear_bands/magmatic_shear_bands.prm.bak b/benchmarks/shear_bands/magmatic_shear_bands.prm.bak
deleted file mode 100644
index 0696dfdb4f9..00000000000
--- a/benchmarks/shear_bands/magmatic_shear_bands.prm.bak
+++ /dev/null
@@ -1,146 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Set up the magmatic shear bands testcase
-# for Newtonian rheology and analyze it using
-# the relations given in Spiegelman (2003):
-# Linear analysis of melt band formation by
-# simple shear, Geochemistry, Geophysics,
-# Geosystems, 4(9), 8615.
-
-set Additional shared libraries            = ./libshear_bands.so
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = output
-set Max nonlinear iterations               = 5
-set Nonlinear solver tolerance             = 1e-5
-set Dimension                              = 2
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.0005
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# we apply simple shear here, so that the top and bottom boundaries
-# move with the same speed u0, but in opposite directions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-
-  subsection Function
-    set Function constants = u0=5e2,ymid=0.0005
-    set Function expression = u0*(y/ymid-1.0);0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.004
-    set Y extent  = 0.001
-    set X periodic = true
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=64000
-    set Function expression = 0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = plane wave melt bands initial condition
-
-  subsection Plane wave melt bands initial condition
-    set Wave amplitude = 1e-4
-    set Initial band angle = 30
-    set Wave number = 4000
-  end
-end
-
-subsection Material model
-  set Model name = shear bands material
-
-  subsection Shear bands material
-    set Dislocation creep exponent = 1.0
-    set Porosity exponent          = -1.0
-    set Compaction viscosity exponent = 1.0
-    set Permeability exponent = 2
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 8
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, shear bands growth rate
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, thermal expansivity, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-24
-  set Temperature solver tolerance = 1e-20
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
diff --git a/benchmarks/shear_bands/shear_bands.cc.bak b/benchmarks/shear_bands/shear_bands.cc.bak
deleted file mode 100644
index 370bc5a9afb..00000000000
--- a/benchmarks/shear_bands/shear_bands.cc.bak
+++ /dev/null
@@ -1,846 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/initial_composition/interface.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-#include <deal.II/base/table.h>
-#include <deal.II/base/table_indices.h>
-#include <array>
-
-
-namespace aspect
-{
-  /**
-   * This is the "Shear bands" benchmark defined in the following paper:
-   * @code
-   *  @Article{DMGT11,
-   *    author =       {R. F. Katz and M. Spiegelman and B. Holtzman},
-   *    title =        {The dynamics of melt and shear localization in
-   *                    partially molten aggregates},
-   *    journal =      {Nature},
-   *    year =         2006,
-   *    volume =       442,
-   *    pages =        {676-679}
-   * @endcode
-   *
-   * Magmatic shear bands are generated by a combination of porosity- and
-   * strain-rate dependent viscosity in a simple shear regime; and the
-   * angle of the shear bands is measured.
-   *
-   */
-  namespace ShearBands
-  {
-    using namespace dealii;
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class ShearBandsMaterial : public MaterialModel::MeltInterface<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        bool is_compressible () const override
-        {
-          return false;
-        }
-
-        double reference_viscosity () const
-        {
-          return eta_0;
-        }
-
-        double reference_darcy_coefficient () const override
-        {
-          return reference_permeability * pow(0.01, permeability_exponent) / eta_f;
-        }
-
-
-        double
-        get_background_porosity () const;
-
-        double
-        get_reference_compaction_viscosity () const;
-
-        double
-        get_porosity_exponent () const;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                      typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const override
-        {
-          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-          const double strain_rate_dependence = (1.0 - dislocation_creep_exponent) / dislocation_creep_exponent;
-
-          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-            {
-              double porosity = std::max(in.composition[i][porosity_idx],1e-4);
-              out.viscosities[i] = eta_0 * std::exp(alpha*(porosity - background_porosity));
-              if (in.requests_property(MaterialModel::MaterialProperties::viscosity))
-                {
-                  const SymmetricTensor<2,dim> shear_strain_rate = in.strain_rate[i]
-                                                                   - 1./dim * trace(in.strain_rate[i]) * unit_symmetric_tensor<dim>();
-                  const double second_strain_rate_invariant = std::sqrt(std::abs(second_invariant(shear_strain_rate)));
-
-                  if (std::abs(second_strain_rate_invariant) > 1e-30)
-                    out.viscosities[i] *= std::pow(second_strain_rate_invariant,strain_rate_dependence);
-                }
-
-
-              out.densities[i] = reference_rho_s;
-              out.thermal_expansion_coefficients[i] = 0.0;
-              out.specific_heat[i] = 1.0;
-              out.thermal_conductivities[i] = 0.0;
-              out.compressibilities[i] = 0.0;
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                out.reaction_terms[i][c] = 0.0;
-            }
-
-          // fill melt outputs if they exist
-          aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-          if (melt_out != nullptr)
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                double porosity = std::max(in.composition[i][porosity_idx],1e-4);
-
-                melt_out->compaction_viscosities[i] = xi_0 * pow(porosity/background_porosity,-compaction_viscosity_exponent);
-                melt_out->fluid_viscosities[i]= eta_f;
-                melt_out->permeabilities[i]= reference_permeability * std::pow(porosity,permeability_exponent);
-                melt_out->fluid_densities[i]= reference_rho_f;
-                melt_out->fluid_density_gradients[i] = 0.0;
-              }
-        }
-
-      private:
-        double reference_rho_s;
-        double reference_rho_f;
-        double eta_0;
-        double xi_0;
-        double eta_f;
-        double reference_permeability;
-        double dislocation_creep_exponent;
-        double alpha;
-        double background_porosity;
-        double compaction_viscosity_exponent;
-        double permeability_exponent;
-    };
-
-    template <int dim>
-    double
-    ShearBandsMaterial<dim>::get_background_porosity () const
-    {
-      return background_porosity;
-    }
-
-    template <int dim>
-    double
-    ShearBandsMaterial<dim>::get_reference_compaction_viscosity () const
-    {
-      return xi_0;
-    }
-
-    template <int dim>
-    double
-    ShearBandsMaterial<dim>::get_porosity_exponent () const
-    {
-      return alpha;
-    }
-
-
-    template <int dim>
-    void
-    ShearBandsMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Shear bands material");
-        {
-          prm.declare_entry ("Reference solid density", "3000",
-                             Patterns::Double (0),
-                             "Reference density of the solid $\\rho_{s,0}$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference melt density", "3000",
-                             Patterns::Double (0),
-                             "Reference density of the melt/fluid$\\rho_{f,0}$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference shear viscosity", "1.41176e7",
-                             Patterns::Double (0),
-                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Reference compaction viscosity", "1.41176e8",
-                             Patterns::Double (0),
-                             "The value of the constant volumetric viscosity $\\xi_0$ of the solid matrix. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Reference melt viscosity", "100.0",
-                             Patterns::Double (0),
-                             "The value of the constant melt viscosity $\\eta_f$. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Reference permeability", "5e-9",
-                             Patterns::Double(),
-                             "Reference permeability of the solid host rock."
-                             "Units: \\si{\\meter\\squared}.");
-          prm.declare_entry ("Dislocation creep exponent", "6.0",
-                             Patterns::Double(0),
-                             "Power-law exponent $n_{dis}$ for dislocation creep. "
-                             "Units: none.");
-          prm.declare_entry ("Porosity exponent", "-27.0",
-                             Patterns::Double(),
-                             "Exponent $\alpha$ for the exponential porosity-dependence "
-                             "of the viscosity. "
-                             "Units: none.");
-          prm.declare_entry ("Background porosity", "0.05",
-                             Patterns::Double (0),
-                             "Background porosity used in the viscosity law. Units: none.");
-          prm.declare_entry ("Compaction viscosity exponent", "0.0",
-                             Patterns::Double(0),
-                             "Power-law exponent $m$ for the compaction viscosity. "
-                             "Units: none.");
-          prm.declare_entry ("Permeability exponent", "3.0",
-                             Patterns::Double(0),
-                             "Power-law exponent $n$ for the porosity-dependence of permeability. "
-                             "Units: none.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ShearBandsMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Shear bands material");
-        {
-          reference_rho_s            = prm.get_double ("Reference solid density");
-          reference_rho_f            = prm.get_double ("Reference melt density");
-          eta_0                      = prm.get_double ("Reference shear viscosity");
-          xi_0                       = prm.get_double ("Reference compaction viscosity");
-          eta_f                      = prm.get_double ("Reference melt viscosity");
-          reference_permeability     = prm.get_double ("Reference permeability");
-          dislocation_creep_exponent = prm.get_double ("Dislocation creep exponent");
-          alpha                      = prm.get_double ("Porosity exponent");
-          background_porosity        = prm.get_double ("Background porosity");
-          compaction_viscosity_exponent = prm.get_double ("Compaction viscosity exponent");
-          permeability_exponent      = prm.get_double ("Permeability exponent");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    /**
-     * An initial conditions model for the shear bands benchmark
-     * that implements a background porosity plus white noise with
-     * a certain amplitude.
-     */
-    template <int dim>
-    class ShearBandsInitialCondition : public InitialComposition::Interface<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Return the initial porosity as a function of position.
-         */
-        double
-        initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Initialization function.
-         */
-        void
-        initialize () override;
-
-      private:
-        double noise_amplitude;
-        double background_porosity;
-        std::array<unsigned int,dim> grid_intervals;
-        std::unique_ptr<Functions::InterpolatedUniformGridData<dim>> interpolate_noise;
-    };
-
-
-
-    template <int dim>
-    void
-    ShearBandsInitialCondition<dim>::initialize ()
-    {
-      AssertThrow(Plugins::plugin_type_matches<const ShearBandsMaterial<dim>>(this->get_material_model()),
-                  ExcMessage("Initial condition shear bands only works with the material model shear bands."));
-
-      const ShearBandsMaterial<dim> &
-      material_model
-        = Plugins::get_plugin_as_type<const ShearBandsMaterial<dim>>(this->get_material_model());
-
-      background_porosity = material_model.get_background_porosity();
-
-      AssertThrow(noise_amplitude < background_porosity,
-                  ExcMessage("Amplitude of the white noise must be smaller "
-                             "than the background porosity."));
-
-      Point<dim> extents;
-      TableIndices<dim> size_idx;
-      for (unsigned int d=0; d<dim; ++d)
-        size_idx[d] = grid_intervals[d]+1;
-
-      Table<dim,double> white_noise;
-      white_noise.TableBase<dim,double>::reinit(size_idx);
-      std::array<std::pair<double,double>,dim> grid_extents;
-
-      AssertThrow(Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
-                  ExcMessage("Initial condition shear bands only works with the box geometry model."));
-
-      const GeometryModel::Box<dim> &
-      geometry_model
-        = Plugins::get_plugin_as_type<const GeometryModel::Box<dim>>(this->get_geometry_model());
-
-      extents = geometry_model.get_extents();
-
-      for (unsigned int d=0; d<dim; ++d)
-        {
-          grid_extents[d].first=0;
-          grid_extents[d].second=extents[d];
-        }
-
-      // use a fixed number as seed for random generator
-      // this is important if we run the code on more than 1 processor
-      std::srand(0);
-
-      TableIndices<dim> idx;
-
-      for (unsigned int i=0; i<white_noise.size()[0]; ++i)
-        {
-          idx[0] = i;
-          for (unsigned int j=0; j<white_noise.size()[1]; ++j)
-            {
-              idx[1] = j;
-              white_noise(idx) = noise_amplitude * ((std::rand() % 10000) / 5000.0 - 1.0);
-            }
-        }
-
-      interpolate_noise
-        = std::make_unique<Functions::InterpolatedUniformGridData<dim>> (grid_extents,
-                                                                          grid_intervals,
-                                                                          white_noise);
-    }
-
-
-    template <int dim>
-    double
-    ShearBandsInitialCondition<dim>::
-    initial_composition (const Point<dim> &position, const unsigned int /*n_comp*/) const
-    {
-      return background_porosity + interpolate_noise->value(position);
-    }
-
-
-    template <int dim>
-    void
-    ShearBandsInitialCondition<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Shear bands initial condition");
-        {
-          prm.declare_entry ("Noise amplitude", "0.0005",
-                             Patterns::Double (0),
-                             "Amplitude of the white noise added to the initial "
-                             "porosity. Units: none.");
-          prm.declare_entry ("Grid intervals for noise X", "100",
-                             Patterns::Integer (0),
-                             "Grid intervals in X directions for the white noise added to "
-                             "the initial background porosity that will then be interpolated "
-                             "to the model grid. "
-                             "Units: none.");
-          prm.declare_entry ("Grid intervals for noise Y", "25",
-                             Patterns::Integer (0),
-                             "Grid intervals in Y directions for the white noise added to "
-                             "the initial background porosity that will then be interpolated "
-                             "to the model grid. "
-                             "Units: none.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ShearBandsInitialCondition<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Shear bands initial condition");
-        {
-          noise_amplitude      = prm.get_double ("Noise amplitude");
-          grid_intervals[0]    = prm.get_integer ("Grid intervals for noise X");
-          grid_intervals[1]    = prm.get_integer ("Grid intervals for noise Y");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    /**
-     * An initial conditions model for the plane wave melt bands benchmark
-     * that implements a background porosity plus a plave wave in the porosity
-     * field with a certain amplitude.
-     */
-    template <int dim>
-    class PlaneWaveMeltBandsInitialCondition : public InitialComposition::Interface<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Return the initial porosity as a function of position.
-         */
-        double
-        initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Initialization function.
-         */
-        void
-        initialize () override;
-
-        double
-        get_wave_amplitude () const;
-
-        double
-        get_wave_number () const;
-
-        double
-        get_initial_band_angle () const;
-
-      private:
-        double amplitude;
-        double background_porosity;
-        double wave_number;
-        double initial_band_angle;
-    };
-
-
-
-    template <int dim>
-    void
-    PlaneWaveMeltBandsInitialCondition<dim>::initialize ()
-    {
-      AssertThrow(Plugins::plugin_type_matches<ShearBandsMaterial<dim>>(this->get_material_model()),
-                  ExcMessage("Initial condition shear bands only works with the material model shear bands."));
-
-      const ShearBandsMaterial<dim> &
-      material_model
-        = Plugins::get_plugin_as_type<const ShearBandsMaterial<dim>>(this->get_material_model());
-
-      background_porosity = material_model.get_background_porosity();
-
-      AssertThrow(amplitude < 1.0,
-                  ExcMessage("Amplitude of the melt bands must be smaller "
-                             "than the background porosity."));
-    }
-
-
-    template <int dim>
-    double
-    PlaneWaveMeltBandsInitialCondition<dim>::get_wave_amplitude () const
-    {
-      return amplitude;
-    }
-
-    template <int dim>
-    double
-    PlaneWaveMeltBandsInitialCondition<dim>::get_wave_number () const
-    {
-      return wave_number;
-    }
-
-    template <int dim>
-    double
-    PlaneWaveMeltBandsInitialCondition<dim>::get_initial_band_angle () const
-    {
-      return initial_band_angle;
-    }
-
-
-    template <int dim>
-    double
-    PlaneWaveMeltBandsInitialCondition<dim>::
-    initial_composition (const Point<dim> &position, const unsigned int /*n_comp*/) const
-    {
-      return background_porosity * (1.0 + amplitude * cos(wave_number*position[0]*sin(initial_band_angle)
-                                                          + wave_number*position[1]*cos(initial_band_angle)));
-    }
-
-
-    template <int dim>
-    void
-    PlaneWaveMeltBandsInitialCondition<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Plane wave melt bands initial condition");
-        {
-          prm.declare_entry ("Wave amplitude", "1e-4",
-                             Patterns::Double (0),
-                             "Amplitude of the plane wave added to the initial "
-                             "porosity. Units: none.");
-          prm.declare_entry ("Wave number", "2000",
-                             Patterns::Double (0),
-                             "Wave number of the plane wave added to the initial "
-                             "porosity. Is multiplied by 2 pi internally. "
-                             "Units: 1/m.");
-          prm.declare_entry ("Initial band angle", "30",
-                             Patterns::Double (0),
-                             "Initial angle of the plane wave added to the initial "
-                             "porosity. Units: degrees.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    PlaneWaveMeltBandsInitialCondition<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Plane wave melt bands initial condition");
-        {
-          amplitude          = prm.get_double ("Wave amplitude");
-          wave_number        = 2.0 * numbers::PI * prm.get_double ("Wave number");
-          initial_band_angle = 2.0 * numbers::PI / 360.0 * prm.get_double ("Initial band angle");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-
-    /**
-      * A postprocessor that evaluates the angle of the shear bands.
-      */
-    template <int dim>
-    class ShearBandsPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    ShearBandsPostprocessor<dim>::execute (TableHandler &/*statistics*/)
-    {
-      // write output that can be used to calculate the angle of the shear bands
-      const unsigned int max_lvl = this->get_triangulation().n_global_levels();
-
-      std::stringstream output;
-      output.precision (16);
-      output << std::scientific;
-
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          // write header
-          output << "x                      y                      porosity" << std::endl;
-        }
-
-      // we want to have equidistant points in the output
-      const QMidpoint<1> mp_rule;
-      const QIterated<dim> quadrature_formula (mp_rule, 2);
-      const unsigned int n_q_points =  quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(), this->get_fe(),  quadrature_formula,
-                               update_JxW_values | update_values | update_quadrature_points);
-
-      std::vector<double>         porosity_values (quadrature_formula.size());
-      const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.compositional_fields[porosity_idx]].get_function_values (this->get_solution(), porosity_values);
-
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                output << fe_values.quadrature_point (q) (0) << " "
-                       << fe_values.quadrature_point (q) (1) << " "
-                       << porosity_values[q] << std::endl;
-              }
-          }
-
-      std::string filename = this->get_output_directory() + "shear_bands_" +
-                             Utilities::int_to_string(max_lvl) +
-                             ".csv";
-
-      Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
-
-      return std::make_pair("writing:", filename);
-    }
-
-
-
-    /**
-      * A postprocessor that evaluates the groeth rate of the shear bands.
-      *
-      * The implementation of error evaluators correspond to the
-      * benchmarks defined in the paper:
-      * Laura Alisic, John F. Rudge, Richard F. Katz, Garth N. Wells, Sander Rhebergen:
-      * "Compaction around a rigid, circular inclusion in partially molten rock."
-      * Journal of Geophysical Research: Solid Earth 119.7 (2014): 5903-5920.
-      */
-    template <int dim>
-    class ShearBandsGrowthRate : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Initialization function. Take references to the material model and
-         * initial conditions model to get the parameters necessary for computing
-         * the analytical solution for the growth rate and store them.
-         */
-        void
-        initialize () override;
-
-      private:
-        double amplitude;
-        double background_porosity;
-        double initial_band_angle;
-        double eta_0;
-        double xi_0;
-        double alpha;
-    };
-
-
-    template <int dim>
-    void
-    ShearBandsGrowthRate<dim>::initialize ()
-    {
-      AssertThrow(Plugins::plugin_type_matches<const ShearBandsMaterial<dim>>(this->get_material_model()),
-                  ExcMessage("Postprocessor shear bands growth rate only works with the material model shear bands."));
-
-      const ShearBandsMaterial<dim> &
-      material_model
-        = Plugins::get_plugin_as_type<const ShearBandsMaterial<dim>>(this->get_material_model());
-
-      background_porosity = material_model.get_background_porosity();
-      eta_0               = material_model.reference_viscosity();
-      xi_0                = material_model.get_reference_compaction_viscosity();
-      alpha               = material_model.get_porosity_exponent();
-
-      const PlaneWaveMeltBandsInitialCondition<dim> &initial_composition
-        = this->get_initial_composition_manager().template
-          get_matching_initial_composition_model<PlaneWaveMeltBandsInitialCondition<dim>> ();
-
-      amplitude           = initial_composition.get_wave_amplitude();
-      initial_band_angle  = initial_composition.get_initial_band_angle();
-    }
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    ShearBandsGrowthRate<dim>::execute (TableHandler &/*statistics*/)
-    {
-      // compute analytical melt band growth rate
-      const double time = this->get_time();
-      const Point<dim> upper_boundary_point = this->get_geometry_model().representative_point(0.0);
-      const Point<dim> lower_boundary_point = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
-
-      types::boundary_id upper_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-      types::boundary_id lower_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
-
-      const BoundaryVelocity::Manager<dim> &bm = this->get_boundary_velocity_manager();
-      const double max_velocity = bm.boundary_velocity(upper_boundary, upper_boundary_point).norm();
-      const double min_velocity = bm.boundary_velocity(lower_boundary, lower_boundary_point).norm();
-
-      const double strain_rate = 0.5 * (max_velocity + min_velocity) / this->get_geometry_model().maximal_depth();
-      const double theta = std::atan(std::sin(initial_band_angle) / (std::cos(initial_band_angle) - time * strain_rate/sqrt(2.0) * std::sin(initial_band_angle)));
-      const double analytical_growth_rate = - eta_0 / (xi_0 + 4.0/3.0 * eta_0) * alpha * (1.0 - background_porosity)
-                                            * 2.0 * strain_rate * std::sin(2.0 * theta);
-
-      // integrate velocity divergence
-      const QGauss<dim> quadrature_formula (this->get_fe()
-                                            .base_element(this->introspection().base_elements.velocities).degree+1);
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_gradients   |
-                               update_quadrature_points |
-                               update_JxW_values);
-      std::vector<double> velocity_divergences(n_q_points);
-      std::vector<Point<dim>> position(n_q_points);
-
-      double local_velocity_divergence_max = 0.0;
-      double local_velocity_divergence_min = 0.0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.velocities].get_function_divergences (this->get_solution(),
-                velocity_divergences);
-            position = fe_values.get_quadrature_points();
-
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                const double relative_depth = this->get_geometry_model().depth(position[q]) / this->get_geometry_model().maximal_depth();
-                const double relative_x = 0.25 * position[q](0) / this->get_geometry_model().maximal_depth();
-                if (relative_depth < 0.55 && relative_depth > 0.45 && relative_x < 0.75 && relative_x > 0.25)
-                  {
-                    local_velocity_divergence_max = std::max (velocity_divergences[q], local_velocity_divergence_max);
-                    local_velocity_divergence_min = std::min (velocity_divergences[q], local_velocity_divergence_min);
-                  }
-              }
-          }
-
-      const double global_velocity_divergence_max
-        = Utilities::MPI::max (local_velocity_divergence_max, this->get_mpi_communicator());
-      const double global_velocity_divergence_min
-        = Utilities::MPI::min (local_velocity_divergence_min, this->get_mpi_communicator());
-
-      // compute modelled melt band growth rate
-      const double numerical_growth_rate = (0 <= initial_band_angle && initial_band_angle < numbers::PI /2.
-                                            ?
-                                            (1.0 - background_porosity) / (amplitude * background_porosity) * global_velocity_divergence_max
-                                            :
-                                            (1.0 - background_porosity) / (amplitude * background_porosity) * global_velocity_divergence_min);
-
-      const double relative_error = (analytical_growth_rate != 0.0) ?
-                                    std::abs(numerical_growth_rate - analytical_growth_rate)/analytical_growth_rate
-                                    :
-                                    1.0;
-
-      // compute and output error
-      std::ostringstream os;
-      os << std::scientific << initial_band_angle
-         << ", " << analytical_growth_rate
-         << ", " << numerical_growth_rate
-         << ", " << relative_error;
-
-      return std::make_pair("Initial angle, Analytical growth rate, Modelled growth rate, Error:", os.str());
-    }
-
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace ShearBands
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ShearBandsMaterial,
-                                   "shear bands material",
-                                   "A material model that corresponds to the setup to"
-                                   "generate magmatic shear bands described in Katz et al., "
-                                   "Nature, 2006.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(ShearBandsPostprocessor,
-                                  "shear bands statistics",
-                                  "A postprocessor that writes output for the porosity field, "
-                                  "which can be used to calculate the angle of the shear "
-                                  "bands in the model.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(ShearBandsGrowthRate,
-                                  "shear bands growth rate",
-                                  "A postprocessor computes the growth rate of melt bands as "
-                                  "presicted from linear stability analysis (Spiegelman, 2003), "
-                                  "and compares modelled and analytical solution.")
-
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(ShearBandsInitialCondition,
-                                              "shear bands initial condition",
-                                              "Composition is set to background porosity plus "
-                                              "white noise.")
-
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(PlaneWaveMeltBandsInitialCondition,
-                                              "plane wave melt bands initial condition",
-                                              "Composition is set to background porosity plus "
-                                              "plane wave.")
-  }
-}
diff --git a/benchmarks/shear_bands/shear_bands.prm.bak b/benchmarks/shear_bands/shear_bands.prm.bak
deleted file mode 100644
index 7ded4bef6be..00000000000
--- a/benchmarks/shear_bands/shear_bands.prm.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Set up the magmatic shear bands testcase
-# with non-linear rheology after Katz et al.,
-# 2006: The dynamics of melt and shear
-# localization in partially molten aggregates.
-
-set Additional shared libraries            = ./libshear_bands.so
-set Adiabatic surface temperature          = 1623
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = output
-set Max nonlinear iterations               = 50
-set Nonlinear solver tolerance             = 1e-5
-set Dimension                              = 2
-set End time                               = 3.125e-8
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-# we want to have a similar contribution of velocity and strain rate
-# in the stabilization. Velocities are on the order of 1e-3 and cell
-# size * strain rate (which is used in the stabilization and scaled
-# by the parameter gamma) is on the order of 1e-5, so we set gamma to
-# 100.
-subsection Discretization
-  set Composition polynomial degree = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.05
-    set gamma = 100
-    set Use artificial viscosity smoothing = true
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# we apply simple shear here, so that the top and bottom boundaries
-# move with the same speed u0, but in opposite directions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-
-  subsection Function
-    set Function constants = u0=3.2e4,ymid=0.0005
-    set Function expression = u0*(y/ymid-1.0);0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.004
-    set Y extent  = 0.001
-    set X periodic = true
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=64000
-    set Function expression = 0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = shear bands initial condition
-end
-
-subsection Material model
-  set Model name = shear bands material
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics,shear bands statistics
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, thermal expansivity, strain rate, melt material properties, artificial viscosity composition
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Artificial viscosity composition
-      set Name of compositional field = porosity
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
diff --git a/benchmarks/sinking_block/blank.prm.bak b/benchmarks/sinking_block/blank.prm.bak
deleted file mode 100644
index 30107e52825..00000000000
--- a/benchmarks/sinking_block/blank.prm.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-# This is the common core prm file for the sinking block benchmark.
-# It is used by the run_benchmark script which runs the benchmark
-# for various viscosity ratios and density differences.
-# This file cannot be used by aspect - see instead sinking_block.prm
-
-set Additional shared libraries  = ./libsinking_block.so
-set Dimension                    = 2
-set Start time                   = 0
-set End time                     = 0
-set Pressure normalization       = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 512e3
-    set Y extent  = 512e3
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, point values, matrix statistics
-
-  subsection Point values
-    set Evaluation points = 256e3,384e3
-  end
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
diff --git a/benchmarks/sinking_block/sinking_block.cc.bak b/benchmarks/sinking_block/sinking_block.cc.bak
deleted file mode 100644
index 16d038841ee..00000000000
--- a/benchmarks/sinking_block/sinking_block.cc.bak
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  namespace SinkingBlockBenchmark
-  {
-    using namespace dealii;
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class SinkingBlockMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> &pos = in.position[i];
-              if (method==0)
-                {
-                  if ( std::abs(pos[0]-256e3)<64e3 && std::abs(pos[1]-384e3)<64e3)
-                    {
-                      out.viscosities[i] = eta2;
-                      out.densities[i] = rho2;
-                    }
-                  else
-                    {
-                      out.viscosities[i] = eta1;
-                      out.densities[i] = rho1;
-                    }
-                }
-              else if (method==1)
-                {
-                  if ( std::abs(pos[0]-256e3)<64e3 && std::abs(pos[1]-384e3)<64e3)
-                    {
-                      out.viscosities[i] = eta2;
-                      out.densities[i] = rho2-rho1;
-                    }
-                  else
-                    {
-                      out.viscosities[i] = eta1;
-                      out.densities[i] = 0;
-                    }
-                }
-              else if (method==2)
-                {
-                  if ( std::abs(pos[1]-384e3)<64e3)
-                    {
-                      if ( std::abs(pos[0]-256e3)<64e3) // in block
-                        {
-                          out.viscosities[i] = eta2;
-                          out.densities[i] = 0.75*(rho2-rho1);
-                        }
-                      else // left and right of block
-                        {
-                          out.viscosities[i] = eta1;
-                          out.densities[i] = -0.25*(rho2-rho1);
-                        }
-                    }
-                  else
-                    {
-                      out.viscosities[i] = eta1;
-                      out.densities[i] = 0;
-                    }
-                }
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm)
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("SinkingBlock");
-            {
-              prm.declare_entry ("eta1", "1e21",
-                                 Patterns::Double (0),
-                                 "Viscosity of the mantle.");
-              prm.declare_entry ("eta2", "1e23",
-                                 Patterns::Double (0),
-                                 "Viscosity in the Inclusion.");
-              prm.declare_entry ("rho1", "3200",
-                                 Patterns::Double (0),
-                                 "density of the mantle.");
-              prm.declare_entry ("rho2", "3232",
-                                 Patterns::Double (0),
-                                 "density in the Inclusion.");
-              prm.declare_entry ("method", "0",
-                                 Patterns::Integer (0,2),
-                                 "density field treatment. Acceptable values are "
-                                 "0 (full densities), 1 (reduced densities), and "
-                                 "2 (vertically averaged density profile is removed"
-                                 " --see Thieulot and Bangerth, In prep.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("SinkingBlock");
-            {
-              eta1 = prm.get_double ("eta1");
-              eta2 = prm.get_double ("eta2");
-              rho1 = prm.get_double ("rho1");
-              rho2 = prm.get_double ("rho2");
-              method = prm.get_integer ("method");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          // Declare dependencies on solution variables
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-      private:
-        double eta1;
-        double eta2;
-        double rho1;
-        double rho2;
-        int method;
-
-    };
-
-
-    template <int dim>
-    bool
-    SinkingBlockMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace SinkingBlockBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SinkingBlockMaterial,
-                                   "SinkingBlockMaterial",
-                                   "A material model that corresponds to the `SinkingBlock' benchmark. "
-                                   "See the manual for more information.")
-  }
-}
diff --git a/benchmarks/sinking_block/sinking_block.prm.bak b/benchmarks/sinking_block/sinking_block.prm.bak
deleted file mode 100644
index 3d1e1348fd5..00000000000
--- a/benchmarks/sinking_block/sinking_block.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# This is the standalone prm file for the sinking block benchmark.
-
-set Additional shared libraries  = ./libsinking_block.so
-set Dimension                    = 2
-set Start time                   = 0
-set End time                     = 0
-set Output directory             = output-block
-set Pressure normalization       = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 512e3
-    set Y extent  = 512e3
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name  = SinkingBlockMaterial
-
-  subsection SinkingBlock
-    set eta1 = 1e21
-    set eta2 = 1e22
-    set rho1 = 3200
-    set rho2 = 3208
-    set method = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 5
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
diff --git a/benchmarks/slab_detachment/slab_detachment.prm.bak b/benchmarks/slab_detachment/slab_detachment.prm.bak
deleted file mode 100644
index eacb778f226..00000000000
--- a/benchmarks/slab_detachment/slab_detachment.prm.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-# Input file for the Detachment benchmark of
-# Schmalholz 2011 as performed in the paper of Glerum et al. 2017.
-# It considers a 2D box with a lithosphere of nonlinear rheology
-# and a vertically hanging slab that necks over time.
-
-set Dimension                              = 2
-set End time                               = 7.8894e14 #seconds = 25My
-set Use years in output instead of seconds = true
-set Output directory                       = output_slab_detachment
-
-#set Nonlinear solver scheme                = iterated Advection and Newton Stokes
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-6
-set Max nonlinear iterations               = 50
-set CFL number                             = 1
-
-# A 2D rectangle of 1000x660 km.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000.0
-    set Y extent = 660000.0
-    set X repetitions = 100
-    set Y repetitions = 66
-  end
-end
-
-# Vertical gravity.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# setting up DG for composition(s)
-#subsection Discretization
-#   set Use discontinuous composition discretization = true
-#   subsection Stabilization parameters
-#      set Use limiter for discontinuous composition solution = true
-#      set Global composition maximum = 1.
-#      set Global composition minimum = 0.
-#   end
-#end
-
-# there are two compositions, one background (mantle) and one additional (slab)
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = slab
-end
-
-# Dislocation rheology set to linear viscosity in the mantle.
-# Temperature effects are not considered.
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature  = 273
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0,      0
-    set Heat capacities       = 750.,   750.
-    set Densities             = 3150,   3300
-    set Thermal expansivities = 0,      0
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep          =  1e-21, 1.22773766e-48
-    set Stress exponents for dislocation creep    =   1, 4
-    set Activation energies for dislocation creep =   0, 0
-    set Activation volumes for dislocation creep  =   0, 0
-
-    # cohesion set really high to generate very large plastic
-    # viscosities which will not be taken into account
-    # by the material model.
-    set Angles of internal friction = 0 , 0
-    set Cohesions                   = 1e15, 1e15
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-#free slip boundary conditions on the top and bottom,
-# no slip on left and right boundaries
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-  set Zero velocity boundary indicators       = left, right
-end
-
-# Temperature effects are not considered,
-# so we set everything to zero.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273 # cannot be zero!!!
-  end
-end
-
-# Description of the initial compositional fields mantle and slab
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = if((x<460000.0&z<580000.0)|(z<330000.0&x>=460000.0&x<540000.0)|(z<580000.0&x>=540000.0),0,1)
-  end
-end
-
-# We output the solution every 1 My and monitor the velocity
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, particles
-
-  subsection Visualization
-    set Time between graphical output = 1e6
-    set List of output variables      = strain rate, viscosity, density
-  end
-
-  subsection Particles
-    set Time between data output  = 1e6
-    set Data output format        = ascii
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-# We read a file with 22 initial particle locations and
-# output the new particle locations over time to an ascii file.
-subsection Particles
-  set Particle generator name   = ascii file
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/slab_detachment/
-      set Data file name = initial_particle_location.dat
-    end
-  end
-end
diff --git a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc.bak b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc.bak
deleted file mode 100644
index 4c98e51cf63..00000000000
--- a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc.bak
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "solcx_compositional_fields.h"
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SolCxCompositionalMaterial,
-                                   "SolCxCompositionalMaterial",
-                                   "A material model that corresponds to the 'SolCx' benchmark "
-                                   "as defined in Duretz et al., G-Cubed, 2011 using "
-                                   "compositional fields. ")
-
-
-    ASPECT_REGISTER_POSTPROCESSOR(SolCxPostprocessor,
-                                  "SolCxPostprocessor",
-                                  "A postprocessor that compares the solution of the benchmarks from "
-                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
-                                  "and reports the error. Specifically, it can compute the errors for "
-                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
-                                  "which material model is currently being used and adjusts "
-                                  "which exact solution to use accordingly.")
-  }
-}
diff --git a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.h.bak b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.h.bak
deleted file mode 100644
index 40eafb19602..00000000000
--- a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.h.bak
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef ASPECT_SOLCX_COMPOSITIONAL_FIELDS_H
-#define ASPECT_SOLCX_COMPOSITIONAL_FIELDS_H
-
-#include "../solcx.h"
-
-
-
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class SolCxCompositionalMaterial : public SolCxMaterial<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              out.densities[i] = in.composition[i][0];
-              out.viscosities[i] = in.composition[i][1];
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-    };
-  }
-}
-#endif
diff --git a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm.bak b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm.bak
deleted file mode 100644
index 724762bcdfb..00000000000
--- a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# A description of the SolCX benchmark for which a known solution
-# is available. See the manual for more information.
-
-set Additional shared libraries            = ./libsolcx_compositional_fields.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolCxCompositionalMaterial
-
-  subsection SolCx
-    set Viscosity jump = 1e6
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = density_comp, viscosity_comp
-  set Compositional field methods = field, field
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x, z
-    set Function constants  = pi=3.1415926536, eta_b=1e6, background_density=0.0
-    set Function expression = background_density - sin(pi*z) * cos(pi*x); if(x<=0.5, 1, eta_b)
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Composition polynomial degree           = 2
-  set Stokes velocity polynomial degree       = 2
-  set Use discontinuous composition discretization = true
-  set Use locally conservative discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
-    set Global composition maximum = 1, 1e6
-    set Global composition minimum = -1, 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, SolCxPostprocessor
-
-  subsection Visualization
-    set Output format = vtu
-    set Number of grouped files = 1
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
diff --git a/benchmarks/solcx/compositional_fields/solcx_particles.prm.bak b/benchmarks/solcx/compositional_fields/solcx_particles.prm.bak
deleted file mode 100644
index 624d2616aaa..00000000000
--- a/benchmarks/solcx/compositional_fields/solcx_particles.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# A description of the SolCX benchmark using active particles
-# to interpolate both density and viscosity onto the compositional
-# field for which a known solution is available. See the manual
-# for more information.
-
-set Additional shared libraries            = ./libsolcx_compositional_fields.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolCxCompositionalMaterial
-
-  subsection SolCx
-    set Viscosity jump = 1e6
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = true
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = false # apply the limiter to the DG solutions
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = density_comp, viscosity_comp
-  set Compositional field methods = particles, particles
-
-  # In the source code, we assumed that density is being carried
-  # on compositional field 1 (at index 0) and viscosity is being
-  # carried on compositional field 2 (at index 1).  If this order
-  # is changed, then the evaluate() function in solcx_compositional_fields.h
-  # must also be changed.
-  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926, eta_b=1e6, background_density=0.0
-    set Function expression = background_density - sin(pi*y) * cos(pi*x); if(x<0.5, 1, eta_b)
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, visualization, SolCxPostprocessor
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Number of grouped files       = 1
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = cell average
-  set Maximum particles per cell = 16384
-  set Update ghost particles = true
-  set Particle generator name = reference cell
-
-  subsection Function
-    set Number of components = 2
-    set Variable names      = x, y
-    set Function constants  = pi=3.1415926, eta_b=1e6, background_density=0.0
-    set Function expression =  background_density - sin(pi*y) * cos(pi*x); if(x<0.5, 1, eta_b)
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 4
-    end
-  end
-end
diff --git a/benchmarks/solcx/doc/solcx.prm.bak b/benchmarks/solcx/doc/solcx.prm.bak
deleted file mode 100644
index fa9a9331c43..00000000000
--- a/benchmarks/solcx/doc/solcx.prm.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-set Additional shared libraries            = ./libsolcx.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-
-  subsection SolCx
-    set Viscosity jump = 1e6
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor, visualization
-end
diff --git a/benchmarks/solcx/solcx.cc.bak b/benchmarks/solcx/solcx.cc.bak
deleted file mode 100644
index 96081618aad..00000000000
--- a/benchmarks/solcx/solcx.cc.bak
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include "solcx.h"
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SolCxMaterial,
-                                   "SolCxMaterial",
-                                   "A material model that corresponds to the 'SolCx' benchmark "
-                                   "defined in Duretz et al., G-Cubed, 2011.")
-
-
-    ASPECT_REGISTER_POSTPROCESSOR(SolCxPostprocessor,
-                                  "SolCxPostprocessor",
-                                  "A postprocessor that compares the solution of the benchmarks from "
-                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
-                                  "and reports the error. Specifically, it can compute the errors for "
-                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
-                                  "which material model is currently being used and adjusts "
-                                  "which exact solution to use accordingly.")
-  }
-}
diff --git a/benchmarks/solcx/solcx.h.bak b/benchmarks/solcx/solcx.h.bak
deleted file mode 100644
index 0e7c8100a48..00000000000
--- a/benchmarks/solcx/solcx.h.bak
+++ /dev/null
@@ -1,3189 +0,0 @@
-#ifndef ASPECT_SOLCX_H
-#define ASPECT_SOLCX_H
-
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-
-namespace aspect
-{
-  /**
-   * This is the "Sol Cx" benchmark defined in the following paper:
-   * @code
-   *  @Article{DMGT11,
-   *    author =       {T. Duretz and D. A. May and T. V. Gerya and P. J. Tackley},
-   *    title =        {Discretization errors and free surface stabilization in the
-   *                  finite difference and marker-in-cell method for applied
-   *                  geodynamics: {A} numerical study},
-   *    journal =      {Geochemistry Geophysics Geosystems},
-   *    year =         2011,
-   *    volume =       12,
-   *    pages =        {Q07004/1--26}}
-   * @endcode
-   *
-   * The results are published in Kronbichler, Heister and Bangerth paper.
-   */
-  namespace InclusionBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-      // based on http://geodynamics.org/hg/cs/AMR/Discontinuous_Stokes with permission
-      // The following code has been taken from http://www.underworldproject.org/,
-      // release 1.7.0. As mentioned in the Underworld Manual, this code has been
-      // released under the GNU General Public License (GPL).
-
-      void _Velic_solCx(
-        double pos[],
-        double _eta_A, double _eta_B,   /* Input parameters: density, viscosity A, viscosity B */
-        double _x_c, int _n,      /* Input parameters: viscosity jump location, wavenumber in x */
-        double vel[], double *presssure,
-        double total_stress[], double strain_rate[])
-      {
-        const double PI = numbers::PI;
-        double Z, u1, u2, u3, u4, u5, u6, ZA, ZB;
-        double sum1, sum2, sum3, sum4, sum5, sum6, x, z, xc;
-        double _C1A, _C2A, _C3A, _C4A, _C1B, _C2B, _C3B, _C4B, _C1, _C2, _C3, _C4;
-        int n, nx;
-
-        double t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29, t30, t31, t32, t33, t34, t35, t36, t37, t38, t39, t40;
-        double t41, t42, t43, t44, t45, t46, t47, t48, t49, t50, t51, t52, t53, t54, t55, t56, t57, t58, t59, t60, t61, t62, t63, t64, t65, t66, t67, t68, t69, t70, t71, t72, t73, t74, t75, t76, t77, t78, t79, t80;
-        double t81, t82, t83, t84, t85, t86, t87, t88, t89, t90, t91, t92, t93, t94, t95, t96, t97, t98, t99, t100, t101, t102, t103, t104, t105, t106, t107, t108, t109, t110, t111, t112, t113, t115, t116, t117, t118, t119, t120;
-        double t121, t122, t123, t124, t125, t126, t127, t128, t129, t130, t131, t132, t133, t134, t135, t136, t137, t138, t139, t140, t141, t142, t143, t144, t145, t146, t147, t148, t149, t150, t151, t152, t153, t154, t155, t156, t157, t158, t159, t160;
-        double t161, t162, t163, t164, t165, t166, t167, t168, t169, t170, t171, t172, t173, t174, t175, t176, t177, t178, t179, t180, t181, t182, t183, t184, t186, t187, t188, t189, t190, t191, t192, t193, t194, t195, t196, t197, t198, t199;
-        double t201, t202, t203, t204, t206, t207, t208, t209, t210, t211, t212, t213, t215, t216, t217, t218, t219, t220, t221, t222, t223, t224, t225, t226, t227, t228, t229, t230, t231, t232, t233, t234, t235, t236, t237, t238, t239, t240;
-        double t241, t242, t243, t244, t245, t246, t247, t248, t249, t250, t251, t252, t253, t254, t255, t256, t257, t258, t259, t260, t261, t262, t263, t264, t265, t267, t268, t269, t270, t272, t273, t274, t275, t276, t277, t278, t279, t280;
-        double t281, t282, t283, t284, t285, t286, t288, t289, t290, t291, t292, t295, t296, t297, t298, t299, t300, t301, t303, t304, t305, t307, t308, t310, t311, t312, t313, t314, t315, t316, t317, t318, t319, t320;
-        double t321, t322, t323, t324, t325, t326, t327, t328, t329, t330, t331, t332, t334, t335, t336, t337, t338, t339, t340, t341, t342, t344, t345, t346, t347, t348, t349, t350, t351, t352, t353, t354, t355, t356, t358, t359, t360;
-        double t361, t362, t363, t364, t365, t366, t367, t368, t369, t370, t371, t372, t373, t374, t375, t376, t377, t378, t379, t380, t381, t382, t383, t384, t385, t386, t387, t389, t390, t391, t393, t394, t395, t396, t397, t398;
-        double t401, t402, t403, t404, t405, t406, t407, t408, t409, t410, t411, t412, t413, t414, t415, t416, t417, t418, t419, t421, t422, t423, t424, t425, t426, t427, t428, t429, t430, t431, t432, t433, t434, t436, t437, t438, t439, t440;
-        double t441, t442, t443, t444, t445, t446, t447, t448, t450, t451, t453, t454, t455, t456, t457, t458, t459, t461, t462, t463, t464, t465, t466, t468, t469, t470, t471, t474, t475, t478, t480;
-        double t482, t483, t484, t485, t488, t489, t490, t492, t493, t495, t497, t498, t499, t501, t502, t503, t504, t505, t507, t508, t509, t510, t511, t512, t513, t515, t518, t520;
-        double t522, t525, t527, t528, t529, t530, t532, t533, t534, t535, t536, t538, t539, t541, t542, t544, t545, t546, t547, t548, t549, t550, t551, t552, t553, t554, t555, t556, t557, t560;
-        double t561, t562, t563, t564, t567, t568, t571, t573, t575, t576, t578, t579, t583, t590, t591, t594, t595, t596, t597, t598, t600;
-        double t601, t602, t604, t606, t607, t608, t611, t613, t615, t616, t617, t619, t621, t623, t624, t625, t626, t627, t629, t630, t632, t633, t634, t638, t639, t640;
-        double t641, t642, t643, t644, t645, t647, t648, t649, t650, t651, t652, t653, t654, t655, t656, t657, t658, t659, t660, t662, t663, t665, t666, t667, t668, t670, t671, t672, t673, t674, t675, t676, t679, t680;
-        double t682, t683, t684, t685, t686, t688, t689, t690, t691, t693, t694, t695, t696, t697, t698, t699, t700, t701, t702, t704, t705, t708, t709, t711, t712, t713, t714, t717, t718, t719;
-        double t721, t722, t723, t726, t727, t728, t730, t733, t734, t735, t736, t737, t738, t739, t740, t741, t744, t745, t746, t749, t750, t752, t753, t754, t755, t757, t758, t759, t760;
-        double t761, t762, t763, t764, t766, t767, t768, t770, t771, t772, t773, t774, t775, t776, t777, t778, t780, t781, t782, t785, t786, t789, t790, t791, t792, t793, t794, t795, t796, t797, t798, t800;
-        double t801, t806, t807, t808, t809, t811, t812, t817, t818, t819, t821, t822, t824, t827, t828, t830, t834, t835, t837, t840;
-        double t842, t843, t844, t845, t846, t849, t850, t853, t854, t855, t857, t858, t859, t860, t863, t864, t867, t868, t869, t873, t874, t877, t878, t879, t880;
-        double t884, t888, t891, t894, t900, t901, t903, t904, t907, t908, t909, t911, t914, t915, t916, t919, t920;
-        double t923, t924, t925, t926, t927, t929, t932, t935, t937, t939, t942, t943, t944, t945, t947, t948, t949, t950, t952, t953, t954, t955, t956, t957;
-        double t961, t964, t965, t966, t967, t968, t969, t971, t972, t974, t977, t978, t981, t983, t987, t988, t992, t993, t994, t997, t998;
-        double t1001, t1003, t1005, t1006, t1009, t1010, t1012, t1013, t1015, t1016, t1017, t1018, t1020, t1021, t1029, t1031, t1032, t1033, t1040;
-        double t1041, t1042, t1044, t1047, t1050, t1054, t1055, t1057, t1058, t1063, t1068, t1069, t1070, t1079, t1080;
-        double t1088, t1089, t1091, t1092, t1094, t1096, t1101, t1102, t1103, t1104, t1105, t1108, t1112, t1113, t1118, t1119, t1120;
-        double t1121, t1122, t1123, t1124, t1125, t1126, t1127, t1128, t1129, t1130, t1132, t1133, t1134, t1135, t1138, t1139, t1140, t1141, t1142, t1145, t1146, t1148, t1149, t1150, t1153, t1154, t1156, t1157, t1158, t1159;
-        double t1161, t1162, t1165, t1166, t1170, t1171, t1172, t1173, t1175, t1176, t1178, t1180, t1181, t1182, t1185, t1189, t1192, t1193, t1195, t1196, t1199;
-        double t1201, t1203, t1209, t1210, t1211, t1213, t1214, t1218, t1221, t1224, t1225, t1226, t1228, t1233, t1234, t1235, t1236, t1237, t1240;
-        double t1241, t1242, t1243, t1244, t1245, t1248, t1251, t1252, t1257, t1258, t1259, t1260, t1263, t1268, t1269, t1272, t1280;
-        double t1282, t1283, t1284, t1285, t1287, t1288, t1289, t1292, t1293, t1296, t1297, t1300, t1304, t1307, t1310, t1311, t1312, t1316, t1317, t1320;
-        double t1321, t1323, t1328, t1330, t1331, t1332, t1333, t1336, t1338, t1343, t1344, t1346, t1349, t1350, t1354;
-        double t1366, t1369, t1370, t1371, t1376, t1378, t1380, t1383, t1386, t1387, t1388, t1391, t1393, t1399;
-        double t1411, t1412, t1420, t1427;
-        double t1450, t1456, t1468, t1472, t1474, t1478;
-        double t1504, t1511;
-        double t1545;
-        double t1564, t1583;
-
-
-        /* del_rho = sin(n*Pi*z)*cos(nx*Pi*x)  n=nx gives only non-zero terms*/
-        n = _n; /* only one n in Fourier series because  del_rho has cos term */
-        nx = 1; /* can set these two to whatever we like */
-
-        ZA = _eta_A; /* left column viscosity */
-        ZB = _eta_B; /* right column viscosity */
-        xc = _x_c;
-
-        x = pos[0];
-        z = pos[1];
-
-        sum1 = 0.0;
-        sum2 = 0.0;
-        sum3 = 0.0;
-        sum4 = 0.0;
-        sum5 = 0.0;
-        sum6 = 0.0;
-
-        // Note that there is no Fourier sum here.
-        /****************************************************************************************/
-        _C1A = 0;
-        /****************************************************************************************/
-        t1 = nx * 0.3141592654e1;
-        t2 = sin(t1);
-        t3 = nx * t2;
-        t4 = n * n;
-        t5 = t4 * t4;
-        t6 = 0.3141592654e1 * 0.3141592654e1;
-        t8 = t3 * t5 * t6;
-        t9 = ZA * xc;
-        t12 = exp(xc * n * 0.3141592654e1);
-        t13 = t12 * t12;
-        t15 = n * 0.3141592654e1;
-        t16 = exp(t15);
-        t17 = t16 * t16;
-        t18 = t17 * t16;
-        t19 = ZB * t13 * t18;
-        t20 = t9 * t19;
-        t23 = ZA * ZA;
-        t24 = nx * nx;
-        t25 = t24 * nx;
-        t26 = t23 * t25;
-        t28 = t13 * t13;
-        t29 = t28 * t13;
-        t33 = nx * ZB;
-        t34 = t1 * xc;
-        t35 = sin(t34);
-        t36 = t4 * n;
-        t37 = t35 * t36;
-        t38 = t33 * t37;
-        t39 = 0.3141592654e1 * ZA;
-        t40 = t13 * t12;
-        t41 = t17 * t40;
-        t45 = ZB * ZB;
-        t46 = t45 * t24;
-        t47 = t46 * t4;
-        t48 = 0.3141592654e1 * xc;
-        t49 = t13 * t17;
-        t53 = xc * xc;
-        t54 = t36 * t53;
-        t56 = t54 * t6 * t45;
-        t57 = cos(t34);
-        t58 = t57 * t24;
-        t59 = t28 * t12;
-        t60 = t17 * t59;
-        t61 = t58 * t60;
-        t64 = t25 * t2;
-        t65 = t64 * t15;
-        t72 = nx * t23;
-        t74 = t72 * t2 * t5;
-        t75 = t6 * t53;
-        t76 = t16 * t29;
-        t80 = t23 * n;
-        t81 = t80 * 0.3141592654e1;
-        t82 = t18 * t28;
-        t86 = nx * t5;
-        t87 = t23 * t6;
-        t89 = xc * t2;
-        t90 = t13 * t18;
-        t91 = t89 * t90;
-        t94 = t28 * t28;
-        t96 = t24 * n;
-        t98 = t4 * t45;
-        t99 = t98 * 0.3141592654e1;
-        t100 = t58 * t41;
-        t104 = 0.3141592654e1 * t25;
-        t105 = ZA * n * t104;
-        t106 = t2 * ZB;
-        t110 = t17 * t17;
-        t111 = ZA * t110;
-        t116 = n * t28;
-        t122 = t64 * t4 * t6;
-        t126 = t23 * t29 * t4;
-        t128 = t24 * xc;
-        t132 = t36 * t23;
-        t133 = t6 * t57;
-        t135 = t128 * t41;
-        t138 = t6 * xc;
-        t142 = t72 * t2;
-        t147 = 0.4e1 * t8 * t20 - 0.2e1 * t26 * t2 * t16 * t29 - 0.8e1 * t38 * t39 * t41 + 0.4e1 * t47 * t48 * t49 -
-               0.8e1 * t56 * t61 - 0.4e1 * t65 * t20 + 0.2e1 * t26 * t2 * t18 * t28 - 0.4e1 * t74 * t75 * t76 -
-               0.2e1 * t81 * t64 * t82 - 0.4e1 * t86 * t87 * t91 - t23 * t94 * t96 + 0.8e1 * t99 * t100 -
-               0.2e1 * t105 * t106 * t82 - 0.4e1 * t38 * t48 * t111 * t12 + 0.2e1 * t116 * ZB * t111 * t24 +
-               0.4e1 * t122 * t20 + 0.4e1 * t126 * 0.3141592654e1 * t17 * t128 + 0.8e1 * t132 * t133 * t135 +
-               0.4e1 * t74 * t138 * t76 - 0.2e1 * t142 * t4 * t18 * t28;
-        t149 = ZA * t25 * t2;
-        t150 = ZB * t28;
-        t154 = t35 * t5;
-        t155 = t72 * t154;
-        t156 = t75 * t41;
-        t159 = nx * ZA;
-        t160 = t2 * t36;
-        t161 = t159 * t160;
-        t162 = 0.3141592654e1 * ZB;
-        t163 = t28 * t16;
-        t167 = t23 * t57;
-        t168 = t167 * t24;
-        t169 = n * t110;
-        t170 = t169 * t40;
-        t173 = ZA * ZB;
-        t174 = t173 * t90;
-        t177 = t36 * 0.3141592654e1;
-        t181 = t80 * t104;
-        t184 = n * t17;
-        t188 = t17 * t29;
-        t190 = t4 * 0.3141592654e1;
-        t191 = t190 * t24;
-        t206 = t138 * t60;
-        t209 = t23 * t4;
-        t211 = t209 * t6 * t25;
-        t212 = t89 * t76;
-        t216 = ZB * t16 * t29;
-        t217 = t9 * t216;
-        t220 = ZB * t110;
-        t221 = ZA * t24;
-        t222 = t221 * n;
-        t225 = t132 * t75;
-        t232 = t45 * t28;
-        t233 = t110 * t24;
-        t234 = t233 * n;
-        t236 = t209 * 0.3141592654e1;
-        t237 = t17 * xc;
-        t239 = t237 * t13 * t24;
-        t242 = -0.2e1 * t149 * t150 * t16 - 0.8e1 * t155 * t156 - 0.2e1 * t161 * t162 * t163 + 0.2e1 * t168 * t170 +
-               0.2e1 * t65 * t174 - 0.2e1 * t142 * t177 * t76 + 0.4e1 * t181 * t91 - 0.4e1 * t168 * t184 * t59 -
-               0.4e1 * t188 * t23 * t191 + 0.4e1 * t38 * t48 * ZA * t17 * t40 + 0.4e1 * t49 * t23 * t191 +
-               0.2e1 * t26 * t2 * t13 * t18 - 0.8e1 * t155 * t206 + 0.4e1 * t211 * t212 - 0.4e1 * t8 * t217 +
-               0.2e1 * t220 * t222 - 0.8e1 * t225 * t100 + 0.2e1 * t142 * t4 * t16 * t29 + t232 * t234 -
-               0.4e1 * t236 * t239;
-        t244 = nx * t45;
-        t245 = t244 * t37;
-        t246 = t110 * t40;
-        t251 = t237 * t59;
-        t256 = t64 * t90;
-        t260 = t36 * t45 * t133;
-        t263 = t45 * t57;
-        t264 = t263 * t24;
-        t265 = t169 * t12;
-        t269 = t6 * t36;
-        t270 = t17 * t24;
-        t274 = t110 * t13;
-        t276 = t190 * t128;
-        t279 = nx * t36;
-        t281 = t28 * t40;
-        t282 = t281 * t35;
-        t286 = t138 * t41;
-        t289 = t75 * t60;
-        t296 = t190 * t173;
-        t305 = t86 * t45 * t35;
-        t312 = t33 * t154;
-        t313 = t6 * ZA;
-        t324 = t232 * t270;
-        t327 = -0.2e1 * t245 * t48 * t246 + 0.4e1 * t159 * t37 * t162 * t251 + 0.4e1 * t209 * t75 * t256 +
-               0.8e1 * t260 * t135 + 0.2e1 * t264 * t265 + 0.32e2 * t9 * t150 * t269 * t270 +
-               0.4e1 * t274 * t23 * t276 + 0.2e1 * t279 * t45 * t282 * t48 + 0.8e1 * t155 * t286 +
-               0.8e1 * t155 * t289 - 0.8e1 * t150 * ZA * t96 * t17 + 0.8e1 * t296 * t61 -
-               0.2e1 * t105 * t106 * t163 - 0.2e1 * t81 * t256 - 0.8e1 * t305 * t156 -
-               0.4e1 * t33 * t282 * t177 * t9 - 0.16e2 * t312 * t313 * t237 * t40 - 0.4e1 * t168 * t184 * t40 +
-               0.2e1 * t168 * t265 + 0.16e2 * t269 * t53 * t324;
-        t328 = t3 * t4;
-        t331 = t72 * t37;
-        t332 = t48 * t60;
-        t335 = n * t94;
-        t345 = t72 * t35;
-        t349 = t173 * t57;
-        t355 = t53 * t17;
-        t364 = t54 * t6 * ZB;
-        t365 = t28 * t17;
-        t369 = xc * ZB;
-        t370 = t269 * t369;
-        t371 = ZA * t57;
-        t373 = t371 * t270 * t40;
-        t385 = nx * t35;
-        t396 = t4 * xc;
-        t397 = t396 * t162;
-        t415 = t37 * t48;
-        t418 = -0.32e2 * t364 * t365 * t221 - 0.16e2 * t370 * t373 - 0.4e1 * t331 * t48 * t41 +
-               0.4e1 * t86 * t23 * t53 * t6 * t2 * t90 + 0.2e1 * t385 * t177 * t23 * xc * t246 +
-               0.16e2 * t132 * t53 * t6 * t28 * t270 - 0.4e1 * t397 * t371 * t233 * t12 -
-               0.12e2 * t173 * t58 * t190 * t251 + 0.2e1 * t385 * t36 * 0.3141592654e1 * t23 * xc * t59 -
-               0.8e1 * t99 * t61 - 0.2e1 * t244 * t59 * t415;
-        t427 = t371 * t270 * t59;
-        t439 = t209 * t48;
-        t440 = t110 * t12;
-        t441 = t58 * t440;
-        t447 = t36 * xc;
-        t455 = t48 * t440;
-        t471 = ZB * t17;
-        t492 = 0.12e2 * t397 * t373 - 0.4e1 * t122 * t217 + 0.16e2 * t364 * t427 +
-               0.16e2 * t312 * t313 * t355 * t40 - 0.8e1 * t279 * t39 * t35 * ZB * t60 + 0.2e1 * t439 * t441 -
-               0.2e1 * t81 * t64 * t163 + 0.8e1 * t447 * t87 * t61 + 0.2e1 * t23 * t59 * t57 * t276 +
-               0.2e1 * t245 * t455 - 0.4e1 * t349 * t96 * t440 - 0.16e2 * t370 * t427 + 0.4e1 * t181 * t212 -
-               0.16e2 * t365 * t23 * t269 * t128 + 0.16e2 * t86 * t138 * ZA * t35 * t471 * t59 +
-               0.8e1 * t305 * t289 - 0.4e1 * t439 * t100 + 0.2e1 * ZB * t25 * t2 * ZA * t18 * t28 +
-               0.2e1 * t142 * t4 * t28 * t16 - 0.8e1 * t56 * t100;
-        t499 = ZA * t53 * t19;
-        t505 = t396 * 0.3141592654e1;
-        t518 = t173 * t53 * t16 * t29;
-        t533 = t23 * t28;
-        t535 = t188 * t45;
-        t538 = t24 * t4;
-        t545 = t3 * t177;
-        t546 = t173 * t76;
-        t555 = t45 * t110;
-        t557 = t72 * t160;
-        t561 = -0.8e1 * t225 * t61 - 0.2e1 * t161 * t162 * t82 + t533 * t234 + 0.4e1 * t535 * t191 +
-               0.4e1 * t167 * t538 * t332 + 0.4e1 * t349 * t96 * t60 + 0.2e1 * t545 * t546 - 0.2e1 * t264 * t170 +
-               0.4e1 * t397 * t281 * ZA * t58 - t555 * t96 - 0.4e1 * t557 * t48 * t76;
-        t567 = t396 * 0.3141592654e1 * t45;
-        t568 = t58 * t246;
-        t597 = t58 * n;
-        t615 = t13 * t45;
-        t616 = t615 * t233;
-        t619 = t94 * t45;
-        t621 = t45 * t59;
-        t625 = 0.2e1 * t149 * t216 + 0.2e1 * t567 * t568 - 0.16e2 * t269 * xc * t324 -
-               0.2e1 * t236 * xc * t281 * t58 - 0.2e1 * t142 * t177 * t90 - 0.8e1 * t567 * t100 +
-               0.2e1 * t65 * t546 - 0.8e1 * t305 * t206 + 0.2e1 * n * t45 * t281 * t57 * t24 - t23 * t110 * t96 -
-               0.8e1 * t296 * t100 + 0.2e1 * t23 * t281 * t597 + 0.4e1 * t545 * t20 +
-               0.2e1 * t159 * t2 * t4 * ZB * t163 - 0.4e1 * t557 * t48 * t90 + 0.4e1 * t122 * t518 +
-               0.8e1 * t263 * t538 * t332 - 0.4e1 * t505 * t616 - t619 * t96 - 0.2e1 * t621 * t57 * t276;
-        t626 = t49 * t45;
-        t660 = t29 * t45;
-        t685 = 0.2e1 * t545 * t174 - 0.4e1 * t126 * 0.3141592654e1 * t24 * xc - 0.4e1 * t47 * t48 * t188 +
-               0.4e1 * t505 * t660 * t24 - 0.2e1 * t142 * t177 * t163 - 0.2e1 * t142 * t4 * t13 * t18 +
-               0.8e1 * t260 * t128 * t60 - 0.2e1 * t328 * t546 - 0.2e1 * t26 * t2 * t28 * t16 +
-               0.4e1 * t545 * t217 - 0.4e1 * t209 * t138 * t256;
-        t690 = t6 * 0.3141592654e1;
-        t691 = ZA * t690;
-        t693 = t24 * t24;
-        t694 = t693 * xc;
-        t695 = t188 * t694;
-        t698 = t23 * ZA;
-        t699 = t698 * t690;
-        t700 = t699 * t5;
-        t704 = t5 * t4;
-        t705 = t691 * t704;
-        t709 = t691 * t5;
-        t713 = t5 * n;
-        t714 = t713 * ZB;
-        t718 = t698 * t6;
-        t719 = t713 * t28;
-        t722 = t699 * t704;
-        t726 = t713 * t94;
-        t733 = t713 * t45;
-        t736 = t87 * t36;
-        t740 = -0.4e1 * t691 * t98 * t695 + 0.8e1 * t700 * t270 * t13 + 0.4e1 * t705 * t660 * xc +
-               0.8e1 * t709 * t660 * t128 + 0.2e1 * t87 * t714 * t110 + t718 * t719 * t110 -
-               0.4e1 * t722 * t237 * t13 - t313 * t726 * t45 - 0.4e1 * t699 * t704 * xc * t29 + t313 * t733 * t28 +
-               0.4e1 * t736 * t150 * t233;
-        t746 = t313 * t36;
-        t752 = t6 * t6;
-        t753 = t23 * t752;
-        t759 = t698 * t752;
-        t760 = t759 * t36;
-        t761 = t17 * t693;
-        t762 = xc * t28;
-        t763 = t761 * t762;
-        t766 = t87 * t713;
-        t773 = t699 * t4;
-        t774 = t110 * t693;
-        t775 = xc * t13;
-        t785 = t704 * t17;
-        t789 = -0.16e2 * t736 * t150 * t270 + t718 * t116 * t693 - 0.2e1 * t746 * t555 * t24 + 0.4e1 * t705 * t535 +
-               0.64e2 * t753 * t713 * t17 * t150 * t128 - 0.16e2 * t760 * t763 + 0.2e1 * t766 * t150 * t110 +
-               0.4e1 * t722 * t274 * xc + 0.4e1 * t773 * t774 * t775 - 0.8e1 * t766 * t150 * t17 +
-               0.8e1 * t700 * t233 * t775 + 0.4e1 * t699 * t785 * t13;
-        t791 = t691 * t4;
-        t792 = t45 * t693;
-        t793 = t49 * t792;
-        t796 = t759 * t713;
-        t797 = t53 * t28;
-        t798 = t270 * t797;
-        t801 = t87 * n;
-        t818 = t5 * t36;
-        t819 = t753 * t818;
-        t827 = t753 * t36 * ZB;
-        t830 = xc * t45;
-        t834 = -0.4e1 * t791 * t793 + 0.32e2 * t796 * t798 + 0.2e1 * t801 * ZB * t693 * t110 +
-               0.2e1 * t718 * t36 * t28 * t24 - 0.8e1 * t700 * t128 * t29 - 0.8e1 * t700 * t239 -
-               0.8e1 * t801 * t150 * t761 + 0.32e2 * t819 * t365 * t369 - 0.64e2 * t753 * t714 * t798 +
-               0.32e2 * t827 * t763 + 0.4e1 * t705 * t830 * t49;
-        t842 = xc * t29;
-        t843 = t270 * t842;
-        t849 = t759 * t818;
-        t853 = t691 * t396;
-        t857 = t691 * t5 * t45;
-        t869 = t313 * n;
-        t874 = -0.2e1 * t718 * t36 * t94 * t24 - 0.4e1 * t773 * t761 * t29 + 0.8e1 * t700 * t843 +
-               0.2e1 * t87 * t726 * ZB + 0.16e2 * t849 * t797 * t17 + 0.4e1 * t853 * t793 + 0.8e1 * t857 * t239 +
-               0.2e1 * t801 * t150 * t693 - 0.8e1 * t700 * t270 * t29 - 0.8e1 * t709 * t49 * t46 -
-               t869 * t619 * t693 + t869 * t232 * t693;
-        t877 = ZA * t752;
-        t878 = t877 * t818;
-        t911 = 0.16e2 * t878 * t53 * t45 * t365 - 0.4e1 * t699 * t785 * t29 - 0.4e1 * t705 * t188 * t830 +
-               0.2e1 * t801 * t94 * t693 * ZB - 0.8e1 * t857 * t843 - t718 * t726 + 0.4e1 * t773 * t761 * t13 -
-               0.4e1 * t705 * t775 * t555 + 0.2e1 * t746 * t232 * t233 - 0.16e2 * t878 * t830 * t365 -
-               0.2e1 * t746 * t619 * t24;
-        t916 = t110 * t28;
-        t945 = t28 * t693 * t45 * t17;
-        t948 = 0.32e2 * t877 * t733 * t798 + 0.2e1 * t718 * t36 * t916 * t24 - 0.4e1 * t705 * t626 +
-               t718 * n * t916 * t693 - t869 * t792 * t110 - 0.4e1 * t773 * t761 * t775 + t718 * t719 +
-               0.2e1 * t746 * t232 * t24 - 0.16e2 * t849 * t365 * xc - t718 * t713 * t110 -
-               0.4e1 * t773 * t694 * t29 + 0.16e2 * t877 * t54 * t945;
-        t974 = t761 * t797;
-        t987 = 0.4e1 * t773 * t695 + 0.4e1 * t736 * t150 * t24 + 0.4e1 * t722 * t842 * t17 -
-               0.16e2 * t877 * t447 * t945 + 0.2e1 * t87 * t714 * t28 + t313 * t713 * t916 * t45 -
-               0.4e1 * t853 * t615 * t774 - 0.32e2 * t877 * t713 * xc * t324 + 0.16e2 * t760 * t974 +
-               0.4e1 * t736 * t94 * t24 * ZB + t869 * t792 * t916 - 0.8e1 * t691 * t5 * xc * t616;
-        t1021 = -t718 * t169 * t693 - 0.32e2 * t827 * t974 + 0.2e1 * t801 * t150 * t774 +
-                0.4e1 * t791 * t188 * t792 + 0.4e1 * t736 * t220 * t24 + 0.4e1 * t791 * t842 * t792 +
-                0.8e1 * t709 * t660 * t270 - t718 * t335 * t693 - 0.2e1 * t718 * t36 * t110 * t24 -
-                0.32e2 * t819 * t797 * t471 - t313 * t733 * t110 - 0.32e2 * t796 * t270 * t762;
-
-        _C2A = (t147 - 0.4e1 * t65 * t217 + t418 + 0.2e1 * t150 * t222 + t327 - 0.2e1 * t149 * t19 +
-                0.2e1 * t335 * ZB * t24 * ZA - 0.16e2 * t312 * t313 * t355 * t59 - 0.4e1 * t281 * ZB * ZA * t597 -
-                0.2e1 * t505 * t45 * t281 * t58 - 0.4e1 * t211 * t2 * t53 * t76 + 0.8e1 * t305 * t286 -
-                0.4e1 * t122 * t499 - 0.4e1 * t331 * t332 + 0.8e1 * t345 * t177 * t60 - 0.2e1 * t142 * t177 * t82 +
-                0.2e1 * t72 * t281 * t415 + 0.4e1 * t349 * t96 * t41 - 0.2e1 * t81 * t64 * t76 +
-                0.2e1 * t58 * t80 * t59 + 0.8e1 * t345 * t177 * t41 - 0.4e1 * t8 * t499 + t242 + 0.4e1 * t8 * t518 +
-                t625 + t685 + 0.2e1 * t328 * t174 + 0.2e1 * t331 * t455 - 0.2e1 * t33 * t2 * t4 * ZA * t82 -
-                0.4e1 * t626 * t191 + 0.16e2 * t364 * t373 - 0.2e1 * t621 * t597 - 0.2e1 * t439 * t568 + t492 +
-                t533 * t96 + t232 * t96 + 0.2e1 * t567 * t441 + t561) /
-               (t740 + t789 + t834 + t874 + t911 + t948 + t987 + t1021);
-        /****************************************************************************************/
-        t1 = n * n;
-        t2 = t1 * n;
-        t3 = t2 * 0.3141592654e1;
-        t4 = t3 * xc;
-        t5 = ZB * ZB;
-        t7 = exp(n * 0.3141592654e1);
-        t8 = t7 * t7;
-        t9 = t5 * t8;
-        t12 = exp(xc * n * 0.3141592654e1);
-        t13 = t12 * t12;
-        t14 = t13 * t13;
-        t15 = t14 * t13;
-        t19 = nx * nx;
-        t21 = nx * 0.3141592654e1;
-        t22 = sin(t21);
-        t23 = t19 * nx * t22;
-        t24 = t23 * 0.3141592654e1;
-        t25 = ZA * ZB;
-        t26 = t7 * t15;
-        t27 = t25 * t26;
-        t30 = t21 * xc;
-        t31 = sin(t30);
-        t32 = t31 * nx;
-        t33 = t32 * n;
-        t34 = ZA * ZA;
-        t35 = t8 * t8;
-        t36 = t34 * t35;
-        t40 = t2 * t34;
-        t41 = 0.3141592654e1 * t8;
-        t42 = t41 * t15;
-        t45 = t1 * t5;
-        t46 = t14 * t14;
-        t49 = t19 * t5;
-        t51 = t19 * t46;
-        t53 = t19 * t34;
-        t55 = t8 * t7;
-        t56 = t13 * t55;
-        t57 = t25 * t56;
-        t60 = t2 * nx;
-        t61 = 0.3141592654e1 * 0.3141592654e1;
-        t63 = t60 * t31 * t61;
-        t64 = xc * xc;
-        t65 = ZA * t64;
-        t66 = ZB * t8;
-        t67 = t14 * t12;
-        t68 = t66 * t67;
-        t69 = t65 * t68;
-        t72 = -0.4e1 * t4 * t9 * t15 + 0.4e1 * t24 * t27 + 0.4e1 * t33 * t36 * t12 - 0.4e1 * t40 * t42 - t45 * t46 +
-              t45 * t14 - t49 * t14 + t51 * t5 - t53 * t14 + 0.4e1 * t24 * t57 + 0.32e2 * t63 * t69;
-        t73 = t1 * nx;
-        t75 = t73 * t31 * 0.3141592654e1;
-        t76 = t8 * t67;
-        t77 = t25 * t76;
-        t80 = t1 * t1;
-        t81 = t80 * t34;
-        t83 = t61 * t14;
-        t87 = t1 * t19;
-        t88 = cos(t30);
-        t90 = t87 * t88 * t61;
-        t91 = t5 * t64;
-        t92 = t13 * t12;
-        t93 = t8 * t92;
-        t94 = t91 * t93;
-        t100 = ZB * t64 * ZA * t8 * t92;
-        t103 = n * t19;
-        t105 = t103 * t88 * 0.3141592654e1;
-        t106 = ZA * xc;
-        t107 = ZB * t35;
-        t109 = t106 * t107 * t12;
-        t112 = t34 * xc;
-        t113 = t112 * t93;
-        t116 = t35 * t14;
-        t118 = t1 * ZA;
-        t119 = ZB * t14;
-        t122 = t1 * t46;
-        t125 = t19 * ZB;
-        t126 = t35 * ZA;
-        t127 = t125 * t126;
-        t129 = t1 * ZB;
-        t132 = -0.16e2 * t75 * t77 + 0.16e2 * t81 * t64 * t83 * t8 + 0.16e2 * t90 * t94 - 0.32e2 * t90 * t100 +
-               0.8e1 * t105 * t109 - 0.8e1 * t75 * t113 + t45 * t116 + 0.2e1 * t118 * t119 + 0.2e1 * t122 * t25 -
-               0.2e1 * t127 + 0.2e1 * t129 * t126;
-        t134 = t1 * t34;
-        t136 = t34 * t64;
-        t137 = t136 * t76;
-        t141 = t91 * t76;
-        t145 = t103 * t34;
-        t146 = 0.3141592654e1 * xc;
-        t147 = t8 * t13;
-        t153 = t14 * ZA;
-        t156 = xc * t5;
-        t157 = t156 * t93;
-        t160 = t103 * t5;
-        t162 = t146 * t8 * t15;
-        t166 = t34 * t7 * t15;
-        t169 = t134 * t116 - 0.16e2 * t63 * t137 - t49 * t116 - 0.16e2 * t63 * t141 - t53 * t116 +
-               0.4e1 * t145 * t146 * t147 - 0.2e1 * t51 * t25 - 0.2e1 * t125 * t153 - 0.16e2 * t75 * t157 +
-               0.4e1 * t160 * t162 - 0.4e1 * t24 * t166;
-        t170 = t106 * t68;
-        t177 = t35 * t92;
-        t178 = t112 * t177;
-        t181 = t156 * t76;
-        t186 = t35 * t12;
-        t187 = t112 * t186;
-        t193 = t5 * 0.3141592654e1;
-        t206 = t34 * t14;
-        t207 = t206 * t7;
-        t210 = -0.32e2 * t63 * t170 + 0.32e2 * t90 * t170 + 0.8e1 * t75 * t109 + 0.4e1 * t105 * t178 -
-               0.16e2 * t75 * t181 - 0.16e2 * t90 * t113 - 0.4e1 * t75 * t187 + 0.16e2 * t90 * t141 -
-               0.4e1 * t103 * t15 * t193 * xc + 0.16e2 * t73 * t22 * t34 * t146 * t26 +
-               0.4e1 * t32 * n * t34 * t67 + 0.4e1 * t24 * t207;
-        t217 = t106 * t66 * t92;
-        t226 = t88 * t19 * n;
-        t227 = 0.3141592654e1 * t34;
-        t229 = t227 * xc * t67;
-        t232 = t73 * t31;
-        t234 = t146 * t5 * t67;
-        t238 = t61 * ZB;
-        t239 = t14 * t8;
-        t240 = t238 * t239;
-        t243 = t136 * t93;
-        t246 = -0.8e1 * t33 * t25 * t186 + 0.32e2 * t90 * t217 - t45 * t35 + t53 * t35 - t134 * t35 - t134 * t46 +
-               t134 * t14 - 0.4e1 * t226 * t229 + 0.4e1 * t232 * t234 + 0.32e2 * t87 * t65 * t240 +
-               0.16e2 * t63 * t243;
-        t247 = t14 * t92;
-        t249 = t227 * t247 * xc;
-        t254 = t73 * t22;
-        t259 = t60 * t22 * t61;
-        t260 = t112 * t26;
-        t264 = t146 * t247 * t5;
-        t268 = xc * t14;
-        t274 = t5 * t14;
-        t275 = t274 * t8;
-        t280 = n * nx;
-        t281 = t280 * t22;
-        t282 = t55 * t14;
-        t283 = t25 * t282;
-        t290 = ZA * t247 * xc * ZB;
-        t295 = t22 * nx * t1 * 0.3141592654e1;
-        t298 = -0.4e1 * t232 * t249 + 0.8e1 * t105 * t217 - 0.4e1 * t254 * t227 * t26 - 0.8e1 * t259 * t260 -
-               0.4e1 * t232 * t264 - 0.16e2 * t81 * t61 * t268 * t8 + 0.16e2 * t80 * t64 * t61 * t275 -
-               0.4e1 * t232 * t229 + 0.8e1 * t281 * t283 - 0.4e1 * t105 * t187 + 0.8e1 * t75 * t290 +
-               0.4e1 * t295 * t27;
-        t301 = t61 * t5;
-        t307 = t87 * t34;
-        t312 = t61 * xc;
-        t313 = t312 * t239;
-        t317 = t34 * t55 * t14;
-        t329 = ZB * t13 * t55;
-        t330 = t65 * t329;
-        t337 = -0.16e2 * t87 * t64 * t301 * t239 - 0.32e2 * t90 * t69 - 0.16e2 * t307 * t64 * t61 * t239 +
-               0.16e2 * t307 * t313 + 0.4e1 * t24 * t317 + t53 * t46 + t49 * t35 - 0.32e2 * t63 * t100 -
-               0.4e1 * t280 * t31 * t34 * t247 + 0.8e1 * t259 * t330 - 0.4e1 * t280 * t31 * t247 * t5;
-        t340 = t5 * t35;
-        t344 = t25 * t93;
-        t356 = t41 * t13;
-        t360 = t23 * n * t61;
-        t363 = t25 * t64 * t7 * t15;
-        t366 = t156 * t177;
-        t369 = t14 * t7;
-        t370 = t25 * t369;
-        t373 = t156 * t186;
-        t378 = 0.4e1 * t24 * t283 + 0.4e1 * t33 * t340 * t12 - 0.16e2 * t75 * t344 - 0.4e1 * t280 * t31 * t5 * t67 +
-               0.8e1 * t33 * t25 * t247 + 0.32e2 * t63 * t217 + 0.4e1 * t40 * t356 - 0.8e1 * t360 * t363 +
-               0.4e1 * t75 * t366 + 0.4e1 * t295 * t370 - 0.4e1 * t75 * t373 - 0.4e1 * t105 * t366;
-        t382 = t112 * t76;
-        t387 = t80 * t61;
-        t391 = t136 * t26;
-        t409 = 0.16e2 * t63 * t382 + 0.4e1 * t226 * t234 - 0.16e2 * t387 * xc * t275 + 0.8e1 * t259 * t391 -
-               0.16e2 * t105 * t344 + 0.4e1 * t226 * t264 - 0.8e1 * t105 * t170 + 0.16e2 * t232 * t193 * t76 +
-               0.8e1 * t360 * t330 - 0.8e1 * t105 * t290 + 0.16e2 * t90 * t243;
-        t423 = t153 * t8;
-        t426 = t34 * t13;
-        t427 = t426 * t55;
-        t430 = t34 * t8;
-        t437 = t80 * ZA;
-        t441 = 0.4e1 * t145 * t42 - 0.16e2 * t90 * t157 + 0.24e2 * t75 * t217 + 0.4e1 * t226 * t249 +
-               0.4e1 * t254 * t227 * t282 + 0.4e1 * t160 * t356 - 0.8e1 * t129 * t423 - 0.8e1 * t281 * t427 -
-               0.8e1 * t33 * t430 * t67 + 0.8e1 * t33 * t430 * t92 + 0.32e2 * t437 * ZB * t313;
-        t453 = t106 * ZB * t7 * t15;
-        t456 = t2 * t5;
-        t459 = t112 * t56;
-        t462 = t126 * t14;
-        t474 = t40 * 0.3141592654e1;
-        t475 = xc * t8;
-        t480 = t146 * t13 * t35;
-        t483 = -0.4e1 * t103 * xc * t193 * t147 + 0.16e2 * t87 * t61 * t156 * t239 + 0.8e1 * t259 * t453 -
-               0.4e1 * t456 * t356 + 0.8e1 * t259 * t459 - 0.2e1 * t125 * t462 - 0.8e1 * t281 * t207 +
-               0.16e2 * t295 * t459 - 0.8e1 * t60 * t22 * ZA * t312 * t329 + 0.4e1 * t474 * t475 * t15 +
-               0.4e1 * t160 * t480;
-        t497 = t136 * t56;
-        t504 = t9 * t13;
-        t509 = t475 * t13;
-        t512 = -0.8e1 * t105 * t113 - 0.4e1 * t254 * t227 * t56 + 0.8e1 * t281 * t57 + 0.4e1 * t295 * t283 +
-               0.2e1 * t129 * t462 + 0.4e1 * t24 * t370 - 0.8e1 * t360 * t497 - 0.4e1 * t24 * t427 -
-               0.4e1 * t145 * t162 + 0.4e1 * t4 * t504 - 0.8e1 * t281 * t370 - 0.4e1 * t474 * t509;
-        t528 = t5 * t13;
-        t529 = t528 * t35;
-        t532 = t106 * t329;
-        t542 = -0.16e2 * t295 * t453 - 0.32e2 * t437 * t64 * t240 + 0.8e1 * t281 * t317 + 0.24e2 * t75 * t170 -
-               0.4e1 * t75 * t178 + 0.8e1 * t360 * t453 - 0.4e1 * t4 * t529 - 0.16e2 * t295 * t532 -
-               0.8e1 * t33 * t344 - 0.16e2 * t90 * t181 + 0.4e1 * t33 * t340 * t92;
-        t557 = t146 * t15;
-        t562 = xc * t15;
-        t563 = t562 * t5;
-        t573 = 0.16e2 * t232 * t193 * t93 - 0.8e1 * t259 * t363 - 0.8e1 * t259 * t497 + 0.8e1 * t33 * t77 +
-               0.8e1 * t360 * t391 + 0.4e1 * t254 * t227 * t369 + 0.4e1 * t145 * t557 + 0.8e1 * t281 * t166 +
-               0.4e1 * t3 * t563 + 0.8e1 * t105 * t382 - 0.4e1 * t145 * t480 - 0.4e1 * t33 * t36 * t92;
-        t600 = 0.4e1 * t456 * t42 - 0.8e1 * t360 * t260 - 0.4e1 * t40 * t557 - 0.4e1 * t105 * t373 +
-               0.16e2 * t226 * t227 * t93 - 0.16e2 * t90 * t382 - 0.4e1 * t145 * t356 - 0.16e2 * t63 * t157 -
-               0.32e2 * t87 * t25 * t313 - 0.16e2 * t226 * t227 * t76 - 0.16e2 * t63 * t113;
-        t623 = xc * t13;
-        t627 = 0.8e1 * t125 * t423 - 0.8e1 * t360 * t532 + 0.16e2 * t90 * t137 - 0.4e1 * t160 * t42 +
-               0.16e2 * t63 * t94 + 0.16e2 * t63 * t181 - 0.8e1 * t281 * t27 - 0.8e1 * t75 * t382 +
-               0.8e1 * t360 * t459 + 0.4e1 * t295 * t57 + 0.16e2 * t105 * t77 + 0.4e1 * t474 * t623 * t35;
-        t632 = t61 * 0.3141592654e1;
-        t633 = t632 * t8;
-        t634 = t80 * n;
-        t638 = t632 * t634;
-        t639 = t638 * xc;
-        t642 = t61 * t34;
-        t643 = t122 * t19;
-        t649 = t61 * t61;
-        t650 = t649 * t1;
-        t652 = t19 * t19;
-        t653 = t14 * t652;
-        t654 = t653 * t9;
-        t657 = t14 * t1;
-        t658 = t657 * t19;
-        t665 = t632 * t34;
-        t666 = t665 * t2;
-        t667 = t8 * t19;
-        t668 = t667 * t623;
-        t674 = t665 * n;
-        t675 = t652 * xc;
-        t682 = 0.8e1 * t633 * t426 * t634 - 0.8e1 * t639 * t529 - 0.4e1 * t642 * t643 + 0.2e1 * t642 * t116 * t80 +
-               0.32e2 * t650 * t64 * t654 + 0.4e1 * t301 * t658 + 0.4e1 * t387 * t46 * ZA * ZB -
-               0.16e2 * t666 * t668 - 0.16e2 * t666 * t667 * t15 - 0.8e1 * t674 * t675 * t15 +
-               0.4e1 * t238 * t153 * t80;
-        t683 = t46 * t652;
-        t686 = t633 * t15;
-        t691 = t35 * t80;
-        t698 = t35 * t652;
-        t705 = t14 * t80;
-        t708 = t61 * t35;
-        t717 = -0.2e1 * t642 * t683 - 0.8e1 * t686 * t5 * t634 * xc - 0.2e1 * t301 * t691 + 0.8e1 * t638 * t563 -
-               0.2e1 * t642 * t691 - 0.2e1 * t642 * t698 - 0.2e1 * t301 * t698 - 0.2e1 * t301 * t683 +
-               0.2e1 * t642 * t705 + 0.2e1 * t708 * t274 * t80 + 0.2e1 * t301 * t653 - 0.2e1 * t642 * t80 * t46;
-        t727 = t61 * t46;
-        t737 = t649 * t34;
-        t738 = t737 * t1;
-        t739 = t8 * t652;
-        t740 = t739 * t268;
-        t746 = t61 * ZA;
-        t754 = t632 * n * xc;
-        t758 = 0.2e1 * t301 * t705 + 0.2e1 * t642 * t653 - 0.8e1 * t665 * xc * t634 * t15 -
-               0.2e1 * t727 * t5 * t80 - 0.32e2 * t650 * xc * t654 + 0.2e1 * t301 * t698 * t14 -
-               0.32e2 * t738 * t740 + 0.8e1 * t674 * t739 * t562 + 0.4e1 * t746 * t119 * t652 +
-               0.8e1 * t674 * t698 * t623 - 0.8e1 * t754 * t528 * t698;
-        t762 = t633 * t13;
-        t764 = t5 * n * t652;
-        t767 = t80 * t1;
-        t768 = t649 * t767;
-        t772 = t649 * ZA;
-        t773 = t772 * t129;
-        t777 = t35 * t1 * t19;
-        t780 = t632 * t5;
-        t781 = t780 * t15;
-        t786 = t698 * ZA;
-        t790 = t64 * t14;
-        t800 = t649 * t8;
-        t809 = 0.4e1 * t238 * t126 * t80 - 0.8e1 * t762 * t764 - 0.32e2 * t768 * xc * t275 + 0.64e2 * t773 * t740 -
-               0.4e1 * t301 * t777 - 0.8e1 * t781 * n * t8 * t675 + 0.4e1 * t238 * t786 +
-               0.32e2 * t768 * t34 * t790 * t8 - 0.8e1 * t633 * t528 * t634 + 0.8e1 * t754 * t528 * t739 +
-               0.128e3 * t800 * t119 * t80 * t19 * t106 + 0.8e1 * t674 * t739 * t13;
-        t812 = t649 * t80;
-        t817 = t83 * ZB;
-        t824 = t746 * ZB;
-        t828 = t800 * t14;
-        t855 = -0.64e2 * t812 * xc * t274 * t667 + 0.4e1 * t817 * t786 + 0.4e1 * t727 * ZA * t652 * ZB -
-               0.32e2 * t824 * t657 * t667 - 0.32e2 * t828 * t34 * t767 * xc - 0.8e1 * t633 * t15 * t34 * t634 -
-               0.8e1 * t674 * t739 * t15 + 0.32e2 * t768 * t64 * t275 + 0.4e1 * t708 * t14 * t307 +
-               0.2e1 * t708 * t206 * t652 + 0.8e1 * t632 * t35 * t13 * t34 * t634 * xc;
-        t858 = t35 * t19;
-        t873 = t2 * t8;
-        t878 = t61 * t1;
-        t901 = -0.16e2 * t632 * t2 * xc * t528 * t858 + 0.8e1 * t824 * t658 + 0.4e1 * t301 * t14 * t777 -
-               0.8e1 * t665 * t634 * t509 - 0.8e1 * t674 * t739 * t623 - 0.16e2 * t781 * t873 * t19 * xc +
-               0.8e1 * t878 * t14 * t127 + 0.8e1 * t878 * ZA * t51 * ZB + 0.8e1 * t686 * t764 +
-               0.8e1 * t665 * xc * t634 * t15 * t8 + 0.8e1 * t633 * t15 * t5 * t634 +
-               0.4e1 * t387 * t14 * t107 * ZA;
-        t903 = t739 * t790;
-        t923 = t737 * t80;
-        t924 = t667 * t790;
-        t927 = t780 * t2;
-        t937 = t15 * t19 * xc;
-        t943 = 0.32e2 * t738 * t903 + 0.16e2 * t781 * t873 * t19 + 0.8e1 * t754 * t15 * t652 * t5 +
-               0.16e2 * t666 * t858 * t623 + 0.64e2 * t828 * t25 * t767 * xc - 0.16e2 * t762 * t456 * t19 +
-               0.64e2 * t923 * t924 + 0.16e2 * t927 * t668 - 0.64e2 * t768 * ZA * t790 * t66 -
-               0.64e2 * t773 * t903 + 0.16e2 * t927 * t937 + 0.16e2 * t666 * t667 * t562;
-        t977 = 0.64e2 * t812 * t5 * t924 + 0.8e1 * t639 * t504 + 0.8e1 * t238 * t35 * t118 * t19 +
-               0.4e1 * t642 * t658 - 0.16e2 * t817 * t437 * t8 - 0.128e3 * t772 * ZB * t80 * t924 +
-               0.16e2 * t666 * t667 * t13 - 0.4e1 * t301 * t643 - 0.16e2 * t824 * t653 * t8 - 0.4e1 * t642 * t777 -
-               0.64e2 * t923 * t667 * t268 - 0.16e2 * t666 * t937;
-
-        _C3A = (t72 + t132 + t169 + t210 + t246 + t298 + t337 + t378 + t409 + t441 + t483 + t512 + t542 + t573 +
-                t600 + t627) / (t682 + t717 + t758 + t809 + t855 + t901 + t943 + t977);
-        /****************************************************************************************/
-        _C4A = 0;
-        /****************************************************************************************/
-        t1 = nx * 0.3141592654e1;
-        t2 = t1 * xc;
-        t3 = cos(t2);
-        t4 = nx * nx;
-        t6 = n * 0.3141592654e1;
-        t7 = t3 * t4 * t6;
-        t8 = ZA * ZB;
-        t9 = exp(t6);
-        t10 = t9 * t9;
-        t11 = xc * n;
-        t13 = exp(t11 * 0.3141592654e1);
-        t14 = t13 * t13;
-        t15 = t14 * t13;
-        t16 = t14 * t14;
-        t17 = t16 * t15;
-        t18 = t10 * t17;
-        t19 = t8 * t18;
-        t22 = sin(t2);
-        t23 = nx * t22;
-        t24 = t23 * n;
-        t25 = ZB * ZB;
-        t30 = n * n;
-        t31 = t30 * n;
-        t32 = t31 * nx;
-        t33 = 0.3141592654e1 * 0.3141592654e1;
-        t35 = t32 * t22 * t33;
-        t36 = ZA * ZA;
-        t37 = t36 * xc;
-        t38 = t16 * t13;
-        t39 = t10 * t38;
-        t40 = t37 * t39;
-        t43 = sin(t1);
-        t44 = nx * t43;
-        t45 = t30 * 0.3141592654e1;
-        t46 = t44 * t45;
-        t47 = ZA * xc;
-        t49 = ZB * t16 * t9;
-        t54 = t4 * nx * t43;
-        t55 = xc * xc;
-        t57 = t54 * t30 * t55;
-        t58 = t33 * 0.3141592654e1;
-        t59 = t58 * t25;
-        t60 = t16 * t9;
-        t61 = t59 * t60;
-        t64 = xc * t25;
-        t65 = t14 * t9;
-        t66 = t64 * t65;
-        t70 = t44 * t31 * t33;
-        t71 = t37 * t65;
-        t74 = t10 * t15;
-        t75 = t64 * t74;
-        t78 = t25 * t10;
-        t83 = t54 * n * t33;
-        t84 = t55 * t25;
-        t85 = t10 * t9;
-        t86 = t14 * t85;
-        t87 = t84 * t86;
-        t90 = t30 * t30;
-        t92 = t44 * t90 * t58;
-        t93 = t55 * xc;
-        t94 = t93 * t25;
-        t95 = t85 * t16;
-        t96 = t94 * t95;
-        t102 = t23 * t45;
-        t103 = t10 * t10;
-        t104 = ZB * t103;
-        t106 = t47 * t104 * t15;
-        t111 = t54 * 0.3141592654e1;
-        t112 = t25 * t85;
-        t113 = t112 * t16;
-        t115 = t8 * t39;
-        t118 = t16 * t14;
-        t119 = t85 * t118;
-        t120 = t37 * t119;
-        t123 = t16 * t16;
-        t124 = t36 * t123;
-        t125 = t124 * t9;
-        t127 = -0.8e1 * t7 * t19 + 0.2e1 * t24 * t25 * t13 * t10 - 0.16e2 * t35 * t40 - 0.16e2 * t46 * t47 * t49 -
-               0.8e1 * t57 * t61 + 0.4e1 * t46 * t66 + 0.2e1 * t70 * t71 - 0.16e2 * t35 * t75 +
-               0.6e1 * t24 * t78 * t38 - 0.2e1 * t83 * t87 - 0.8e1 * t92 * t96 - 0.8e1 * t46 * t37 * t95 -
-               0.12e2 * t102 * t106 + 0.2e1 * t83 * t71 + t111 * t113 + 0.8e1 * t7 * t115 + 0.2e1 * t83 * t120 +
-               t111 * t125;
-        t128 = t37 * t74;
-        t131 = t44 * n;
-        t133 = t25 * t9 * t118;
-        t136 = t36 * t14;
-        t137 = t136 * t9;
-        t140 = t30 * t4;
-        t142 = t140 * t3 * t33;
-        t143 = t64 * t39;
-        t147 = t30 * nx * t43;
-        t148 = 0.3141592654e1 * t36;
-        t149 = t9 * t118;
-        t153 = t44 * t31 * ZA;
-        t154 = t33 * xc;
-        t155 = t154 * t49;
-        t160 = ZA * t17 * xc * ZB;
-        t163 = t103 * t13;
-        t164 = t64 * t163;
-        t170 = t44 * t90 * t55;
-        t171 = t58 * ZB;
-        t172 = ZA * t16;
-        t174 = t171 * t172 * t9;
-        t177 = t36 * t55;
-        t178 = t177 * t149;
-        t181 = t54 * t11;
-        t182 = t33 * t25;
-        t186 = t25 * t14;
-        t187 = t186 * t9;
-        t193 = t186 * t85;
-        t198 = ZB * t55;
-        t199 = ZA * t103;
-        t201 = t198 * t199 * t15;
-        t204 = 0.2e1 * t7 * t128 - 0.2e1 * t131 * t133 - 0.2e1 * t131 * t137 + 0.16e2 * t142 * t143 -
-               t147 * t148 * t149 + 0.8e1 * t153 * t155 - 0.4e1 * t7 * t160 + 0.2e1 * t7 * t164 +
-               0.10e2 * t102 * t40 + 0.16e2 * t170 * t174 + 0.2e1 * t83 * t178 - 0.2e1 * t181 * t182 * t65 -
-               t111 * t187 - 0.2e1 * t70 * t87 + 0.4e1 * t102 * t160 - 0.2e1 * t131 * t193 - 0.16e2 * t142 * t75 +
-               0.16e2 * t35 * t201;
-        t210 = t32 * t22;
-        t211 = t33 * t55;
-        t212 = t25 * t38;
-        t213 = t211 * t212;
-        t216 = n * nx;
-        t217 = t22 * t25;
-        t222 = ZB * t85 * t16;
-        t226 = t23 * t30;
-        t227 = t13 * t10;
-        t228 = t148 * t227;
-        t233 = t37 * t163;
-        t237 = n * t4 * t3;
-        t238 = t148 * t74;
-        t241 = t64 * t86;
-        t245 = t148 * xc * t15;
-        t248 = t112 * t118;
-        t250 = t22 * t36;
-        t256 = 0.3141592654e1 * t25;
-        t257 = t256 * t39;
-        t262 = t38 * t103;
-        t263 = t37 * t262;
-        t267 = t148 * t17 * xc;
-        t270 = -0.6e1 * t7 * t143 - 0.4e1 * t24 * t19 - 0.8e1 * t210 * t213 - 0.2e1 * t216 * t217 * t15 -
-               0.32e2 * t153 * t211 * t222 + 0.4e1 * t226 * t228 + 0.16e2 * t142 * t201 + 0.2e1 * t7 * t233 -
-               0.4e1 * t237 * t238 - 0.2e1 * t83 * t241 - 0.2e1 * t237 * t245 + t111 * t248 +
-               0.2e1 * t216 * t250 * t15 - 0.2e1 * t131 * t125 - 0.4e1 * t226 * t257 + t147 * t148 * t95 -
-               0.2e1 * t102 * t263 + 0.2e1 * t237 * t267;
-        t273 = t37 * t149;
-        t277 = t47 * t104 * t13;
-        t285 = t31 * t36;
-        t286 = t44 * t285;
-        t291 = t25 * t123 * t9;
-        t304 = 0.3141592654e1 * xc;
-        t305 = t304 * t212;
-        t312 = t256 * t18;
-        t315 = t8 * t60;
-        t319 = t54 * t30 * t58;
-        t323 = t90 * t36;
-        t324 = t44 * t323;
-        t325 = t55 * t58;
-        t326 = t325 * t60;
-        t329 = 0.2e1 * t102 * t164 + 0.2e1 * t83 * t273 - 0.4e1 * t102 * t277 - 0.2e1 * t7 * t263 +
-               0.4e1 * t24 * t8 * t17 - 0.4e1 * t286 * t154 * t60 - 0.2e1 * t131 * t291 - t147 * t148 * t119 +
-               0.2e1 * t24 * t78 * t17 + 0.2e1 * t54 * t85 * 0.3141592654e1 * ZA * ZB - 0.4e1 * t226 * t305 -
-               0.2e1 * t70 * t66 + t147 * t256 * t95 + 0.4e1 * t237 * t312 + 0.2e1 * t111 * t315 -
-               0.8e1 * t319 * t96 - t111 * t193 - 0.8e1 * t324 * t326;
-        t332 = t8 * t95;
-        t335 = t136 * t85;
-        t337 = t256 * t227;
-        t340 = t177 * t119;
-        t346 = t37 * t86;
-        t351 = t103 * t15;
-        t352 = t177 * t351;
-        t355 = t64 * t119;
-        t358 = t8 * t227;
-        t361 = t85 * 0.3141592654e1;
-        t365 = t84 * t39;
-        t372 = ZB * t10;
-        t373 = t372 * t38;
-        t374 = t47 * t373;
-        t379 = t177 * t39;
-        t384 = -0.2e1 * t46 * t332 + t111 * t335 + 0.4e1 * t237 * t337 - 0.2e1 * t83 * t340 +
-               0.16e2 * t286 * t211 * t95 + 0.2e1 * t70 * t346 - 0.8e1 * t170 * t61 - 0.8e1 * t142 * t352 -
-               0.2e1 * t83 * t355 - 0.4e1 * t24 * t358 + 0.2e1 * t147 * t361 * t8 + 0.8e1 * t35 * t365 -
-               0.2e1 * t226 * t267 + 0.8e1 * t102 * t115 - 0.12e2 * t102 * t374 + 0.16e2 * t142 * t40 -
-               0.8e1 * t142 * t379 + 0.4e1 * t237 * t228;
-        t386 = t54 * t30 * t93;
-        t387 = ZA * t85;
-        t389 = t171 * t387 * t16;
-        t394 = t64 * t60;
-        t398 = t304 * t25 * t15;
-        t401 = t361 * t25;
-        t405 = t84 * t65;
-        t410 = t148 * t18;
-        t414 = t25 * t16 * t9;
-        t417 = t84 * t74;
-        t422 = t177 * t86;
-        t428 = ZB * t38;
-        t429 = t47 * t428;
-        t432 = t148 * t39;
-        t439 = 0.16e2 * t386 * t389 - 0.16e2 * t386 * t174 + 0.8e1 * t46 * t394 + 0.2e1 * t237 * t398 -
-               t147 * t401 + 0.4e1 * t7 * t374 + 0.2e1 * t83 * t405 - 0.4e1 * t46 * t241 - 0.4e1 * t226 * t410 +
-               0.2e1 * t131 * t414 + 0.8e1 * t35 * t417 - 0.8e1 * t142 * t365 + 0.2e1 * t70 * t422 -
-               0.4e1 * t181 * t182 * t60 + 0.12e2 * t102 * t429 - 0.4e1 * t226 * t432 + 0.32e2 * t35 * t374 -
-               0.4e1 * t7 * t106;
-        t442 = t36 * t9 * t118;
-        t444 = t123 * t9;
-        t445 = t8 * t444;
-        t448 = t361 * t36;
-        t451 = t47 * t372 * t17;
-        t454 = t94 * t60;
-        t457 = t25 * t103;
-        t465 = t47 * t372 * t15;
-        t468 = t36 * t85;
-        t469 = t468 * t16;
-        t474 = t43 * t85;
-        t478 = t8 * t74;
-        t484 = t256 * t74;
-        t489 = t198 * ZA * t10 * t15;
-        t501 = -t111 * t442 + 0.4e1 * t131 * t445 - t147 * t448 + 0.4e1 * t7 * t451 + 0.8e1 * t92 * t454 -
-               0.2e1 * t24 * t457 * t13 - 0.2e1 * t286 * t211 * t65 + 0.4e1 * t7 * t465 + t111 * t469 -
-               0.2e1 * t216 * t250 * t17 - 0.2e1 * t216 * t474 * t25 - 0.4e1 * t24 * t478 + 0.4e1 * t24 * t8 * t38 +
-               0.4e1 * t226 * t484 - 0.16e2 * t142 * t489 - 0.2e1 * t24 * t212 * t103 -
-               0.2e1 * t216 * t22 * t17 * t25 + 0.2e1 * t70 * t120;
-        t504 = t33 * t36 * t55 * t38;
-        t507 = t37 * t18;
-        t512 = t47 * ZB * t13 * t10;
-        t518 = t59 * t95;
-        t530 = t84 * t351;
-        t534 = t37 * t227;
-        t549 = -0.8e1 * t210 * t504 + 0.2e1 * t102 * t507 + 0.4e1 * t7 * t512 + t111 * t133 - 0.16e2 * t35 * t489 +
-               0.8e1 * t170 * t518 + 0.2e1 * t24 * t36 * t13 * t10 + 0.4e1 * t131 * t387 * ZB +
-               0.12e2 * t102 * t465 - 0.8e1 * t142 * t530 + t111 * t291 - 0.2e1 * t102 * t534 - 0.4e1 * t70 * t394 -
-               0.10e2 * t102 * t128 + 0.4e1 * t237 * t305 + 0.8e1 * t102 * t19 + 0.2e1 * t83 * t346 -
-               0.16e2 * t35 * t128;
-        t557 = t468 * t118;
-        t562 = t93 * t58;
-        t563 = t562 * t60;
-        t567 = t44 * t90 * t93;
-        t575 = ZA * t55;
-        t576 = t575 * t428;
-        t583 = t37 * t60;
-        t590 = t140 * t3;
-        t601 = -0.2e1 * t226 * t398 - 0.2e1 * t70 * t340 - 0.2e1 * t131 * t557 - 0.4e1 * t24 * t115 +
-               0.8e1 * t324 * t563 + 0.16e2 * t567 * t389 + 0.16e2 * t70 * t84 * t95 + 0.2e1 * t70 * t178 -
-               0.16e2 * t142 * t576 - 0.4e1 * t237 * t257 - 0.4e1 * t226 * t312 + 0.8e1 * t46 * t583 +
-               0.2e1 * t24 * t36 * t38 * t103 + 0.8e1 * t590 * t213 + 0.2e1 * t102 * t143 - 0.16e2 * t35 * t143 +
-               0.2e1 * t131 * t248 + 0.4e1 * t46 * t346;
-        t604 = n * t36;
-        t606 = t154 * t95;
-        t625 = t36 * t103;
-        t640 = t30 * t36;
-        t641 = t54 * t640;
-        t642 = t325 * t95;
-        t647 = -0.4e1 * t131 * t315 - 0.4e1 * t54 * t604 * t606 - t147 * t148 * t60 + 0.16e2 * t35 * t576 -
-               0.8e1 * t102 * t478 + 0.32e2 * t142 * t465 - 0.4e1 * t237 * t484 - 0.2e1 * t70 * t355 +
-               0.2e1 * t70 * t273 + 0.2e1 * t102 * t233 - 0.2e1 * t24 * t625 * t13 - 0.8e1 * t7 * t358 -
-               0.2e1 * t111 * t445 - 0.4e1 * t7 * t429 + 0.16e2 * t46 * t47 * t222 + 0.2e1 * t131 * t113 +
-               0.8e1 * t641 * t642 - 0.2e1 * t7 * t534;
-        t652 = t36 * t16;
-        t653 = t652 * t9;
-        t655 = t64 * t227;
-        t658 = t182 * t95;
-        t663 = t562 * t95;
-        t684 = t64 * t351;
-        t689 = t36 * t10;
-        t695 = t154 * t222;
-        t698 = -0.4e1 * t216 * t217 * t38 - t111 * t653 - 0.2e1 * t7 * t655 - 0.4e1 * t181 * t658 +
-               0.2e1 * t131 * t469 - 0.8e1 * t641 * t663 - 0.4e1 * t83 * t583 - 0.2e1 * t83 * t177 * t65 -
-               0.4e1 * t24 * t457 * t15 + 0.16e2 * t70 * t84 * t60 + 0.8e1 * t57 * t518 - 0.32e2 * t142 * t374 +
-               0.4e1 * t24 * t8 * t351 + 0.4e1 * t102 * t684 - t147 * t256 * t86 - 0.2e1 * t24 * t689 * t15 -
-               0.2e1 * t70 * t241 + 0.8e1 * t153 * t695;
-        t711 = t575 * t373;
-        t717 = t304 * t17 * t25;
-        t736 = t177 * t74;
-        t739 = 0.2e1 * t226 * t245 - 0.8e1 * t102 * t358 - 0.16e2 * t57 * t389 - 0.2e1 * t102 * t655 +
-               0.8e1 * t590 * t504 - 0.8e1 * t641 * t326 - 0.16e2 * t35 * t711 - t111 * t557 + t111 * t137 -
-               0.2e1 * t226 * t717 + 0.8e1 * t102 * t37 * t351 + 0.2e1 * t131 * t335 - 0.4e1 * t131 * t332 -
-               0.2e1 * t216 * t474 * t36 - 0.2e1 * t111 * t332 + 0.16e2 * t142 * t711 - t147 * t256 * t60 +
-               0.8e1 * t142 * t736;
-        t750 = t64 * t262;
-        t763 = t44 * t640;
-        t770 = t84 * t119;
-        t782 = 0.4e1 * t102 * t512 + 0.8e1 * t142 * t417 + 0.8e1 * t641 * t563 - 0.2e1 * t7 * t507 +
-               0.2e1 * t7 * t750 - 0.8e1 * t35 * t352 + 0.4e1 * t237 * t410 + 0.4e1 * t7 * t684 -
-               0.2e1 * t46 * t445 + t147 * t148 * t65 + 0.4e1 * t763 * t304 * t119 + 0.16e2 * t70 * t177 * t60 +
-               0.2e1 * t70 * t770 - t111 * t414 - 0.16e2 * t567 * t174 - 0.4e1 * t46 * t71 - 0.4e1 * t46 * t355 -
-               0.4e1 * t7 * t277;
-        t797 = t64 * t149;
-        t821 = -t54 * t448 + 0.2e1 * t131 * t442 + 0.8e1 * t7 * t478 + 0.8e1 * t35 * t379 -
-               0.2e1 * t181 * t182 * t149 + 0.2e1 * t70 * t405 + 0.2e1 * t83 * t770 - 0.2e1 * t70 * t797 -
-               0.6e1 * t7 * t75 - 0.4e1 * t286 * t606 - 0.4e1 * t237 * t432 + t147 * t256 * t149 -
-               0.4e1 * t763 * t304 * t149 - 0.2e1 * t102 * t75 + 0.2e1 * t237 * t717 + 0.8e1 * t324 * t642 -
-               0.16e2 * t170 * t389 + 0.2e1 * t83 * t422;
-        t827 = t84 * t149;
-        t846 = t54 * n * ZA;
-        t854 = t64 * t18;
-        t867 = -0.16e2 * t142 * t128 + 0.32e2 * t35 * t465 - 0.2e1 * t83 * t827 + 0.2e1 * t46 * t315 +
-               t147 * t148 * t86 - 0.4e1 * t102 * t451 - 0.8e1 * t226 * t148 * xc * t38 - 0.2e1 * t24 * t689 * t38 +
-               0.2e1 * t131 * t187 + 0.8e1 * t846 * t155 + 0.8e1 * t35 * t736 + 0.2e1 * t24 * t689 * t17 -
-               0.2e1 * t7 * t854 + t147 * t256 * t119 + 0.2e1 * t102 * t854 - 0.8e1 * t35 * t530 +
-               0.4e1 * t46 * t797 + 0.2e1 * t102 * t750;
-        t909 = -0.8e1 * t324 * t663 + t147 * t256 * t444 - t147 * t256 * t65 + 0.4e1 * t226 * t238 +
-               0.2e1 * t7 * t40 - t54 * t401 + 0.16e2 * t57 * t174 + 0.4e1 * t226 * t337 + 0.4e1 * t24 * t8 * t163 +
-               0.8e1 * t846 * t695 + 0.8e1 * t319 * t454 + 0.2e1 * t131 * t653 - 0.8e1 * t46 * t64 * t95 +
-               0.6e1 * t24 * t78 * t15 - 0.4e1 * t44 * t31 * xc * t658 - 0.32e2 * t153 * t211 * t49 -
-               0.2e1 * t70 * t827 + t147 * t148 * t444;
-        t914 = t25 * ZB;
-        t915 = t33 * t914;
-        t919 = t4 * t4;
-        t920 = t16 * t919;
-        t929 = t123 * t90;
-        t932 = t919 * t103;
-        t935 = t33 * ZB;
-        t939 = t652 * t919;
-        t942 = t16 * t30;
-        t943 = t942 * t4;
-        t949 = t103 * t16;
-        t950 = t949 * t90;
-        t953 = -0.2e1 * t915 * t103 * t90 + 0.2e1 * t915 * t920 - 0.2e1 * t915 * t123 * t919 +
-               0.2e1 * t915 * t16 * t90 - 0.2e1 * t915 * t929 - 0.2e1 * t915 * t932 - 0.2e1 * t935 * t323 * t123 +
-               0.2e1 * t935 * t939 + 0.4e1 * t915 * t943 + 0.4e1 * t182 * t172 * t90 + 0.2e1 * t915 * t950;
-        t954 = t171 * t36;
-        t955 = t90 * n;
-        t956 = xc * t955;
-        t957 = t118 * t10;
-        t964 = t33 * t33;
-        t965 = t964 * ZB;
-        t966 = t965 * t640;
-        t967 = t10 * t919;
-        t968 = t55 * t16;
-        t969 = t967 * t968;
-        t972 = t935 * t36;
-        t974 = t103 * t30 * t4;
-        t977 = xc * t16;
-        t978 = t967 * t977;
-        t981 = t90 * t30;
-        t983 = t16 * t10;
-        t987 = t182 * ZA;
-        t988 = t4 * t10;
-        t992 = t171 * t604;
-        t993 = xc * t14;
-        t994 = t932 * t993;
-        t997 = t182 * t30;
-        t1005 = t171 * t285;
-        t1006 = t988 * t993;
-        t1009 = t58 * t914;
-        t1010 = t1009 * t31;
-        t1013 = 0.8e1 * t954 * t956 * t957 + 0.2e1 * t915 * t932 * t16 + 0.32e2 * t966 * t969 -
-                0.4e1 * t972 * t974 - 0.32e2 * t966 * t978 + 0.32e2 * t965 * t981 * t177 * t983 -
-                0.32e2 * t987 * t942 * t988 + 0.8e1 * t992 * t994 + 0.8e1 * t997 * t949 * ZA * t4 -
-                0.2e1 * t935 * t124 * t919 - 0.16e2 * t1005 * t1006 + 0.16e2 * t1010 * t1006;
-        t1015 = t964 * t25;
-        t1016 = ZA * t30;
-        t1017 = t1015 * t1016;
-        t1020 = t967 * t993;
-        t1031 = t1009 * t118;
-        t1032 = t31 * t10;
-        t1040 = t964 * t914;
-        t1041 = t1040 * t90;
-        t1044 = t55 * t10 * t4 * t16;
-        t1047 = t1040 * t30;
-        t1050 = t123 * ZA;
-        t1054 = t977 * t988;
-        t1057 = 0.64e2 * t1017 * t978 - 0.8e1 * t992 * t1020 + 0.2e1 * t972 * t950 + 0.4e1 * t182 * t929 * ZA +
-                0.4e1 * t182 * t199 * t90 - 0.16e2 * t1031 * t1032 * t4 * xc + 0.4e1 * t182 * t172 * t919 +
-                0.64e2 * t1041 * t1044 + 0.32e2 * t1047 * t969 + 0.4e1 * t182 * t1050 * t919 -
-                0.64e2 * t1041 * t1054;
-        t1058 = t1009 * n;
-        t1063 = t932 * ZA;
-        t1069 = t123 * t30 * t4;
-        t1080 = t993 * t103 * t4;
-        t1088 = t935 * t103;
-        t1094 = -0.8e1 * t1058 * t994 - 0.32e2 * t1047 * t978 + 0.4e1 * t182 * t1063 - 0.4e1 * t915 * t974 -
-                0.4e1 * t915 * t1069 - 0.2e1 * t935 * t625 * t90 - 0.8e1 * t1009 * t10 * t14 * t955 -
-                0.16e2 * t1010 * t1080 - 0.2e1 * t935 * t625 * t919 - 0.64e2 * t1017 * t969 + 0.2e1 * t1088 * t939 +
-                0.8e1 * t1009 * t957 * t955;
-        t1113 = t955 * t118 * xc;
-        t1120 = t4 * t118;
-        t1125 = t981 * xc;
-        t1133 = n * t10;
-        t1140 = -0.8e1 * t954 * t955 * t10 * t993 + 0.2e1 * t935 * t652 * t90 -
-                0.64e2 * t1015 * t981 * t575 * t983 + 0.8e1 * t182 * t103 * t1016 * t4 + 0.8e1 * t1009 * t1113 +
-                0.16e2 * t954 * t1032 * t4 * t14 - 0.16e2 * t954 * t1032 * t1120 +
-                0.64e2 * t1015 * t10 * t172 * t1125 + 0.8e1 * t171 * t103 * t136 * t956 -
-                0.8e1 * t1031 * t1133 * t919 * xc + 0.8e1 * t1058 * t1020;
-        t1153 = xc * t118;
-        t1165 = t182 * t16;
-        t1170 = t171 * t10;
-        t1178 = ZA * t90;
-        t1182 = 0.4e1 * t1088 * t652 * t140 + 0.8e1 * t954 * t1133 * t919 * t14 + 0.4e1 * t972 * t943 -
-                0.4e1 * t972 * t1069 - 0.16e2 * t954 * t31 * t4 * t1153 - 0.8e1 * t954 * n * t919 * t1153 -
-                0.8e1 * t954 * t1133 * t919 * t118 + 0.4e1 * t1165 * t1063 + 0.16e2 * t1005 * t1080 -
-                0.8e1 * t1170 * t118 * t36 * t955 - 0.16e2 * t987 * t920 * t10 - 0.16e2 * t1165 * t1178 * t10;
-        t1195 = t1040 * t981;
-        t1199 = t1009 * t955;
-        t1203 = t1009 * t10;
-        t1211 = t965 * t323;
-        t1225 = -0.32e2 * t965 * t10 * t652 * t1125 + 0.4e1 * t915 * t16 * t974 + 0.4e1 * t182 * t90 * t949 * ZA +
-                0.32e2 * t1195 * t968 * t10 - 0.8e1 * t1199 * t993 * t103 + 0.8e1 * t1203 * t118 * n * t919 +
-                0.8e1 * t1170 * t136 * t955 + 0.64e2 * t1211 * t1044 + 0.16e2 * t1031 * t1032 * t4 +
-                0.8e1 * t987 * t943 + 0.8e1 * t1199 * t993 * t10 + 0.8e1 * t997 * t1050 * t4;
-        t1263 = -0.128e3 * t1015 * t1178 * t1044 + 0.16e2 * t1005 * t988 * t1153 + 0.8e1 * t1058 * t1153 * t919 +
-                0.16e2 * t1010 * t1120 * xc - 0.8e1 * t954 * t1113 - 0.8e1 * t1203 * t14 * n * t919 -
-                0.16e2 * t1203 * t14 * t31 * t4 - 0.8e1 * t1203 * t1113 - 0.32e2 * t1195 * t977 * t10 -
-                0.64e2 * t1211 * t1054 + 0.8e1 * t992 * t967 * t1153 + 0.128e3 * t1015 * t983 * t90 * t4 * t47;
-
-        _C1B = (t127 + t204 + t270 + t329 + t384 + t439 + t501 + t549 + t601 + t647 + t698 + t739 + t782 + t821 +
-                t867 + t909) / (t953 + t1013 + t1057 + t1094 + t1140 + t1182 + t1225 + t1263);
-        /****************************************************************************************/
-        t1 = n * n;
-        t2 = t1 * n;
-        t3 = nx * t2;
-        t4 = 0.3141592654e1 * ZA;
-        t5 = t3 * t4;
-        t6 = nx * 0.3141592654e1;
-        t7 = t6 * xc;
-        t8 = sin(t7);
-        t9 = t8 * ZB;
-        t10 = n * 0.3141592654e1;
-        t11 = exp(t10);
-        t12 = t11 * t11;
-        t15 = exp(xc * n * 0.3141592654e1);
-        t16 = t15 * t15;
-        t17 = t16 * t16;
-        t18 = t17 * t15;
-        t19 = t12 * t18;
-        t23 = t1 * t1;
-        t24 = nx * t23;
-        t25 = ZB * ZB;
-        t27 = t18 * t8;
-        t28 = 0.3141592654e1 * 0.3141592654e1;
-        t29 = xc * xc;
-        t30 = t28 * t29;
-        t34 = t1 * xc;
-        t35 = 0.3141592654e1 * ZB;
-        t36 = t34 * t35;
-        t37 = cos(t7);
-        t38 = ZA * t37;
-        t39 = nx * nx;
-        t40 = t39 * t12;
-        t41 = t16 * t15;
-        t43 = t38 * t40 * t41;
-        t46 = t25 * n;
-        t47 = t46 * 0.3141592654e1;
-        t48 = t39 * nx;
-        t49 = sin(t6);
-        t50 = t48 * t49;
-        t51 = t12 * t11;
-        t52 = t51 * t17;
-        t53 = t50 * t52;
-        t56 = t34 * 0.3141592654e1 * t25;
-        t57 = t37 * t39;
-        t58 = t17 * t41;
-        t59 = t12 * t58;
-        t60 = t57 * t59;
-        t63 = t25 * t18;
-        t64 = t57 * n;
-        t67 = ZA * ZA;
-        t68 = t67 * n;
-        t69 = 0.3141592654e1 * t48;
-        t70 = t68 * t69;
-        t71 = t49 * xc;
-        t72 = t17 * t16;
-        t73 = t11 * t72;
-        t74 = t71 * t73;
-        t77 = t1 * t67;
-        t78 = t77 * 0.3141592654e1;
-        t81 = nx * t25;
-        t82 = t81 * t49;
-        t83 = t17 * t17;
-        t85 = t1 * t83 * t11;
-        t87 = nx * ZB;
-        t88 = t8 * t2;
-        t89 = t87 * t88;
-        t90 = 0.3141592654e1 * xc;
-        t91 = t12 * t12;
-        t92 = ZA * t91;
-        t97 = ZB * ZA;
-        t98 = t97 * t37;
-        t99 = t39 * n;
-        t100 = t12 * t41;
-        t104 = 0.8e1 * t5 * t9 * t19 + 0.8e1 * t24 * t25 * t27 * t30 + 0.12e2 * t36 * t43 - t47 * t53 -
-               0.2e1 * t56 * t60 - 0.4e1 * t63 * t64 + 0.6e1 * t70 * t74 + 0.4e1 * t78 * t60 - t82 * t85 +
-               0.4e1 * t89 * t90 * t92 * t41 + 0.4e1 * t98 * t99 * t100;
-        t105 = t67 * t48;
-        t106 = t49 * t51;
-        t107 = t106 * t72;
-        t109 = t1 * 0.3141592654e1;
-        t110 = t109 * xc;
-        t115 = nx * t67;
-        t116 = t115 * t49;
-        t117 = t1 * t16;
-        t118 = t117 * t11;
-        t120 = t2 * t25;
-        t121 = t28 * 0.3141592654e1;
-        t122 = t121 * t29;
-        t123 = t120 * t122;
-        t129 = t1 * ZB;
-        t130 = t129 * t4;
-        t131 = t57 * t100;
-        t134 = t12 * t16;
-        t136 = t109 * t39;
-        t139 = ZB * t18;
-        t141 = t39 * t1;
-        t142 = t141 * t90;
-        t145 = t77 * t90;
-        t146 = t91 * t41;
-        t147 = t57 * t146;
-        t151 = t25 * t39 * t1;
-        t152 = t72 * t12;
-        t156 = t49 * t2;
-        t158 = t83 * t11;
-        t162 = -t105 * t107 + 0.8e1 * t110 * t72 * t25 * t39 - t116 * t118 + 0.8e1 * t123 * t53 +
-               0.8e1 * t5 * t9 * t59 - 0.8e1 * t130 * t131 - 0.8e1 * t134 * t25 * t136 -
-               0.12e2 * t139 * t38 * t142 - 0.8e1 * t145 * t147 - 0.8e1 * t151 * t90 * t152 -
-               0.2e1 * t87 * t156 * t4 * t158;
-        t164 = t115 * t88;
-        t165 = t90 * t19;
-        t168 = t25 * t48;
-        t169 = t49 * t16;
-        t170 = t169 * t11;
-        t174 = ZA * n * t69;
-        t175 = ZB * t51;
-        t176 = t175 * t17;
-        t177 = t71 * t176;
-        t180 = t1 * t29;
-        t181 = t28 * t25;
-        t182 = t180 * t181;
-        t183 = t50 * t73;
-        t186 = ZA * t1;
-        t187 = t28 * t48;
-        t188 = t186 * t187;
-        t189 = ZB * t17;
-        t190 = t189 * t11;
-        t191 = t71 * t190;
-        t194 = t50 * t158;
-        t196 = t115 * t156;
-        t197 = t90 * t73;
-        t201 = t49 * t17 * t11;
-        t204 = t88 * t90;
-        t207 = t68 * 0.3141592654e1;
-        t208 = t17 * t11;
-        t209 = t50 * t208;
-        t211 = -0.2e1 * t164 * t165 - t168 * t170 + t168 * t107 + 0.8e1 * t174 * t177 + 0.2e1 * t182 * t183 +
-               0.8e1 * t188 * t191 + t47 * t194 - 0.6e1 * t196 * t197 - t168 * t201 - 0.4e1 * t81 * t18 * t204 -
-               t207 * t209;
-        t212 = t2 * 0.3141592654e1;
-        t213 = t212 * t52;
-        t215 = t81 * t8;
-        t216 = t212 * t59;
-        t219 = t3 * t90;
-        t220 = t25 * t8;
-        t221 = t18 * t91;
-        t225 = t71 * t52;
-        t231 = t16 * t51;
-        t232 = t50 * t231;
-        t237 = ZA * t12;
-        t243 = t67 * t28;
-        t244 = t24 * t243;
-        t245 = t71 * t231;
-        t249 = -t116 * t213 - 0.4e1 * t215 * t216 + 0.2e1 * t219 * t220 * t221 - 0.4e1 * t70 * t225 +
-               0.4e1 * t98 * t99 * t146 + t47 * t232 - 0.2e1 * t145 * t57 * t221 + 0.4e1 * t89 * t90 * t237 * t41 -
-               t105 * t201 - 0.6e1 * t244 * t245 + t105 * t170;
-        t252 = t25 * t37;
-        t253 = t252 * t39;
-        t255 = n * t15 * t12;
-        t258 = t2 * t29;
-        t259 = ZB * t28;
-        t260 = t258 * t259;
-        t263 = t106 * t17;
-        t265 = xc * t25;
-        t269 = t25 * t49;
-        t270 = t269 * t52;
-        t273 = t1 * t25;
-        t274 = t273 * 0.3141592654e1;
-        t275 = t57 * t19;
-        t278 = t24 * t30;
-        t288 = t1 * t11 * t72;
-        t290 = t212 * t208;
-        t292 = t2 * xc;
-        t296 = 0.2e1 * t253 * t255 + 0.16e2 * t260 * t43 + t105 * t263 - 0.4e1 * t10 * t265 * t53 +
-               0.4e1 * t219 * t270 - 0.12e2 * t274 * t275 + 0.8e1 * t278 * t270 -
-               0.2e1 * ZB * n * t69 * t49 * ZA * t158 - t82 * t288 - t116 * t290 + 0.16e2 * t292 * t243 * t275;
-        t301 = t50 * t176;
-        t304 = t51 * t72;
-        t305 = t71 * t304;
-        t308 = t25 * t41;
-        t311 = ZA * t48;
-        t312 = t311 * t49;
-        t317 = t91 * t15;
-        t318 = t57 * t317;
-        t321 = t81 * t88;
-        t322 = t90 * t59;
-        t325 = t212 * t231;
-        t327 = t15 * t12;
-        t328 = t57 * t327;
-        t331 = t77 * t187;
-        t334 = t2 * ZA;
-        t335 = t334 * t122;
-        t336 = t50 * t190;
-        t339 = 0.8e1 * t151 * t90 * t134 + 0.16e2 * t186 * t30 * t301 - 0.2e1 * t70 * t305 + 0.2e1 * t308 * t64 -
-               0.2e1 * t312 * ZB * t83 * t11 + 0.2e1 * t56 * t318 + 0.2e1 * t321 * t322 - t116 * t325 -
-               0.4e1 * t274 * t328 + 0.2e1 * t331 * t305 - 0.16e2 * t335 * t336;
-        t341 = t169 * t51;
-        t344 = t49 * t11 * t72;
-        t346 = t77 * t30;
-        t347 = t50 * t304;
-        t350 = t25 * t51;
-        t352 = nx * ZA;
-        t353 = t49 * t23;
-        t354 = t352 * t353;
-        t355 = t28 * xc;
-        t362 = t25 * t91;
-        t365 = t23 * n;
-        t366 = nx * t365;
-        t367 = t366 * t122;
-        t368 = ZB * t49;
-        t369 = ZA * t51;
-        t370 = t369 * t17;
-        t371 = t368 * t370;
-        t374 = t115 * t353;
-        t375 = t355 * t73;
-        t381 = t105 * t341 - t105 * t344 - 0.2e1 * t346 * t347 - t350 * t50 - 0.8e1 * t354 * t355 * t176 -
-               0.4e1 * t98 * t99 * t317 - 0.2e1 * t362 * t99 - 0.16e2 * t367 * t371 + 0.6e1 * t374 * t375 -
-               0.8e1 * t182 * t53 - t82 * t290;
-        t382 = t71 * t208;
-        t394 = t2 * t67;
-        t395 = t394 * t122;
-        t398 = t352 * t156;
-        t402 = t17 * t12;
-        t403 = t39 * ZA;
-        t404 = t402 * t403;
-        t407 = t269 * t208;
-        t411 = t49 * t83 * t11;
-        t413 = t46 * t69;
-        t419 = -0.4e1 * t331 * t382 + 0.2e1 * t115 * t58 * t204 - 0.2e1 * t145 * t60 + 0.12e2 * t274 * t131 +
-               0.2e1 * t346 * t232 + 0.8e1 * t395 * t53 - 0.8e1 * t398 * t90 * t176 - 0.64e2 * t260 * t404 +
-               0.4e1 * t219 * t407 + t168 * t411 - 0.6e1 * t413 * t74 - 0.2e1 * t110 * t308 * t57;
-        t424 = t16 * t11;
-        t425 = t212 * t424;
-        t427 = t258 * t181;
-        t430 = t67 * t29;
-        t431 = t366 * t430;
-        t432 = t121 * t49;
-        t433 = t432 * t52;
-        t436 = n * t12;
-        t437 = t436 * t18;
-        t440 = t29 * xc;
-        t441 = t440 * t121;
-        t442 = t394 * t441;
-        t445 = t67 * t37;
-        t446 = t445 * t39;
-        t448 = n * t18 * t91;
-        t453 = t352 * t49;
-        t458 = t8 * t23;
-        t462 = t81 * t458;
-        t463 = t30 * t19;
-        t466 = -t47 * t209 + t116 * t425 - 0.8e1 * t427 * t275 + 0.8e1 * t431 * t433 - 0.2e1 * t253 * t437 -
-               0.8e1 * t442 * t53 - 0.2e1 * t446 * t448 + 0.2e1 * t175 * t312 + 0.6e1 * t453 * t129 * t208 +
-               0.8e1 * t115 * t18 * t458 * t30 + 0.8e1 * t462 * t463;
-        t470 = t436 * t58;
-        t475 = t2 * t121 * t440 * t25;
-        t485 = t212 * t73;
-        t488 = t67 * t72 * t1;
-        t490 = t39 * xc;
-        t501 = 0.4e1 * t374 * t355 * t52 + 0.2e1 * t446 * t470 - 0.8e1 * t475 * t53 - 0.2e1 * t446 * t437 -
-               0.4e1 * t36 * t38 * t39 * t15 * t12 - t116 * t485 + 0.8e1 * t488 * 0.3141592654e1 * t12 * t490 -
-               t207 * t183 - 0.2e1 * t182 * t232 - 0.6e1 * t413 * t245 - 0.4e1 * t413 * t382;
-        t503 = t115 * t8;
-        t510 = t355 * t19;
-        t513 = t432 * t208;
-        t525 = t38 * t40 * t18;
-        t533 = -0.4e1 * t503 * t216 - 0.4e1 * t89 * t90 * t92 * t15 - 0.16e2 * t462 * t510 + 0.8e1 * t431 * t513 -
-               0.4e1 * t78 * t131 + t47 * t183 - 0.2e1 * t67 * t83 * t99 + 0.4e1 * t331 * t225 +
-               0.16e2 * t260 * t525 - 0.4e1 * t89 * t90 * t237 * t58 - t207 * t53;
-        t536 = t28 * t37;
-        t538 = t490 * t100;
-        t541 = t334 * t441;
-        t547 = t394 * t30;
-        t550 = t212 * t19;
-        t553 = t366 * t441;
-        t556 = n * t17;
-        t571 = -0.8e1 * t427 * t131 + 0.16e2 * t394 * t536 * t538 + 0.16e2 * t541 * t336 +
-               0.2e1 * t453 * t129 * t158 - 0.8e1 * t547 * t147 + 0.4e1 * t503 * t550 - 0.8e1 * t553 * t270 +
-               0.4e1 * t556 * ZB * t92 * t39 - 0.2e1 * t67 * t91 * t99 - t82 * t425 + 0.4e1 * t78 * t275 +
-               0.2e1 * t78 * xc * t41 * t57;
-        t583 = t90 * t317;
-        t594 = t212 * t158;
-        t596 = t152 * t67;
-        t602 = t67 * t17;
-        t607 = 0.8e1 * t367 * t407 - 0.4e1 * t98 * t99 * t59 + 0.16e2 * t260 * t18 * ZA * t57 +
-               0.2e1 * t321 * t583 - 0.6e1 * t174 * t368 * t52 - 0.4e1 * t89 * t90 * ZA * t15 * t12 + t116 * t594 -
-               0.8e1 * t596 * t136 - 0.4e1 * t98 * t99 * t327 + 0.2e1 * t602 * t99 + 0.2e1 * t164 * t583;
-        t613 = t83 * t25;
-        t616 = t81 * t156;
-        t627 = t90 * t231;
-        t630 = t91 * t16;
-        t638 = 0.4e1 * t196 * t90 * t208 - 0.8e1 * t130 * t60 - 0.2e1 * t613 * t99 + 0.6e1 * t616 * t197 -
-               0.8e1 * t547 * t131 + 0.8e1 * t67 * t18 * t37 * t142 + 0.2e1 * t145 * t328 - 0.6e1 * t196 * t627 +
-               0.8e1 * t630 * t67 * t142 - 0.8e1 * t547 * t275 + 0.8e1 * t395 * t209;
-        t643 = t77 * t355;
-        t648 = t115 * t458;
-        t651 = t134 * t67;
-        t657 = t30 * t304;
-        t660 = t30 * t146;
-        t665 = t25 * t17;
-        t668 = t50 * t424;
-        t671 = -0.4e1 * t321 * t90 * t146 - 0.6e1 * t643 * t232 + 0.8e1 * t182 * t209 - 0.16e2 * t648 * t510 +
-               0.8e1 * t651 * t136 + 0.8e1 * t89 * t4 * t100 - 0.2e1 * t374 * t657 - 0.8e1 * t648 * t660 +
-               0.8e1 * t130 * t328 + 0.2e1 * t665 * t99 + 0.2e1 * t346 * t668;
-        t672 = t90 * t424;
-        t676 = t120 * t536;
-        t680 = t436 * t41;
-        t688 = t366 * t67 * t440;
-        t696 = xc * t12;
-        t697 = t696 * t18;
-        t701 = t252 * t141;
-        t702 = t90 * t221;
-        t705 = 0.2e1 * t196 * t672 - t47 * t347 + 0.16e2 * t676 * t538 - t116 * t85 - 0.2e1 * t253 * t680 +
-               t207 * t194 + 0.4e1 * t98 * t99 * t19 - 0.8e1 * t688 * t433 + 0.16e2 * t541 * t301 -
-               0.6e1 * t312 * t190 + 0.4e1 * t352 * t88 * t35 * t697 + 0.2e1 * t701 * t702;
-        t712 = t24 * t430;
-        t713 = t28 * t49;
-        t721 = t1 * t17 * t11;
-        t726 = ZB * xc;
-        t737 = n * t91;
-        t741 = 0.8e1 * t346 * t209 + 0.2e1 * t712 * t713 * t424 + 0.8e1 * t130 * t275 - t47 * t668 + t116 * t721 -
-               0.8e1 * t688 * t513 + 0.4e1 * t352 * t27 * t212 * t726 + 0.8e1 * t648 * t463 + 0.4e1 * t274 * t60 -
-               0.4e1 * t374 * t355 * t208 - 0.4e1 * t253 * t737 * t41;
-        t745 = t269 * t231;
-        t749 = t1 * t28 * t265;
-        t757 = t16 * t39;
-        t758 = t696 * t757;
-        t762 = t69 * t49;
-        t772 = t355 * t100;
-        t775 = t81 * t353;
-        t778 = -0.8e1 * t398 * t90 * t190 - 0.2e1 * t278 * t745 + 0.4e1 * t749 * t53 +
-               0.32e2 * t394 * t29 * t28 * t17 * t40 - 0.8e1 * t78 * t758 + t350 * n * t762 -
-               0.6e1 * t87 * t49 * t186 * t52 - 0.8e1 * t553 * t407 - 0.4e1 * t749 * t209 + 0.16e2 * t648 * t772 -
-               0.6e1 * t775 * t375;
-        t790 = t212 * t304;
-        t793 = t156 * 0.3141592654e1;
-        t795 = t355 * t304;
-        t800 = t91 * t39;
-        t801 = t800 * n;
-        t807 = t2 * t28;
-        t808 = t807 * t726;
-        t811 = -0.2e1 * t616 * t672 - 0.2e1 * t446 * t680 - 0.2e1 * t78 * xc * t58 * t57 + 0.8e1 * t367 * t270 -
-               t82 * t790 + t115 * t51 * t793 - 0.2e1 * t775 * t795 + 0.8e1 * t123 * t209 + 0.2e1 * t665 * t801 -
-               0.2e1 * t67 * t41 * t64 - 0.32e2 * t808 * t43;
-        t812 = t117 * t51;
-        t821 = t24 * t355;
-        t827 = t90 * t304;
-        t840 = t800 * t41;
-        t844 = -t116 * t812 - 0.2e1 * t110 * t25 * t58 * t57 - 0.4e1 * t78 * t328 + t82 * t485 -
-               0.4e1 * t821 * t407 + 0.4e1 * t196 * t90 * t52 + 0.2e1 * t196 * t827 + t82 * t325 +
-               0.2e1 * t253 * t448 - 0.32e2 * t402 * t67 * t807 * t490 - t207 * t232 +
-               0.12e2 * t186 * t90 * ZB * t37 * t840;
-        t849 = t1 * t51;
-        t850 = t849 * t17;
-        t860 = t269 * t424;
-        t863 = t273 * t187;
-        t874 = 0.16e2 * t462 * t772 - t116 * t850 + 0.16e2 * t553 * t371 + t116 * t288 -
-               0.12e2 * t97 * t57 * t109 * t697 + t82 * t594 - 0.2e1 * t278 * t860 - 0.2e1 * t863 * t305 -
-               0.16e2 * t180 * t259 * t311 * t201 - 0.6e1 * t863 * t74 + 0.8e1 * t174 * t191;
-        t879 = xc * ZA;
-        t888 = t67 * t51;
-        t901 = ZA * t17;
-        t903 = t368 * t901 * t11;
-        t908 = -0.2e1 * t352 * t51 * t156 * t35 + 0.64e2 * t879 * t189 * t807 * t40 +
-               0.2e1 * t46 * t58 * t37 * t39 - t888 * t50 + t105 * t411 - 0.16e2 * t335 * t301 +
-               0.8e1 * t152 * t25 * t136 - 0.8e1 * t278 * t407 + 0.2e1 * t712 * t713 * t231 - 0.16e2 * t367 * t903 +
-               0.2e1 * t145 * t318;
-        t923 = t71 * t424;
-        t926 = t87 * t458;
-        t927 = t28 * ZA;
-        t944 = 0.8e1 * t354 * t355 * t190 - 0.8e1 * t110 * t16 * t25 * t800 - 0.2e1 * t374 * t30 * t73 -
-               0.16e2 * t354 * t30 * t176 - 0.2e1 * t244 * t923 - 0.32e2 * t926 * t927 * t696 * t41 -
-               0.32e2 * t808 * t525 + 0.6e1 * t749 * t232 - 0.8e1 * t188 * t177 + 0.4e1 * t36 * t58 * ZA * t57 +
-               0.4e1 * t821 * t270;
-        t948 = t90 * t327;
-        t961 = t30 * t100;
-        t964 = t29 * t49;
-        t981 = t106 * t1;
-        t983 = -0.2e1 * t219 * t220 * t100 + 0.2e1 * t321 * t948 - 0.16e2 * t189 * ZA * t99 * t12 -
-               0.2e1 * t369 * n * t69 * t368 + 0.2e1 * t374 * t795 - 0.8e1 * t462 * t961 -
-               0.8e1 * t244 * t964 * t208 + 0.2e1 * t413 * t923 + 0.4e1 * t36 * t38 * t40 * t58 -
-               0.2e1 * t87 * t51 * t49 * t1 * ZA + t888 * n * t762 + t115 * t981;
-        t1012 = 0.6e1 * t616 * t627 - t82 * t213 + 0.2e1 * t775 * t657 - 0.12e2 * t215 * t550 -
-                0.6e1 * t145 * t131 + 0.2e1 * t81 * t41 * t204 + 0.6e1 * ZB * t48 * t49 * t370 -
-                0.4e1 * t70 * t382 + 0.2e1 * t446 * t255 + 0.8e1 * t89 * t4 * t327 - 0.4e1 * t56 * t147;
-        t1018 = t212 * t100;
-        t1029 = t212 * t327;
-        t1040 = 0.6e1 * t70 * t245 + 0.2e1 * t56 * t328 + t207 * t668 + 0.4e1 * t503 * t1018 + 0.2e1 * t253 * t470 -
-                0.6e1 * t398 * t35 * t208 - 0.8e1 * t331 * t964 * t52 - 0.4e1 * t503 * t1029 + 0.6e1 * t821 * t745 +
-                0.4e1 * t63 * t37 * t142 + 0.16e2 * t260 * t38 * t840;
-        t1068 = t207 * t347 - 0.2e1 * t164 * t702 - 0.2e1 * t331 * t964 * t73 + 0.8e1 * t374 * t30 * t52 +
-                0.16e2 * t278 * t903 + 0.2e1 * t863 * t923 + 0.6e1 * t445 * t141 * t165 -
-                0.2e1 * t164 * t90 * t100 + 0.6e1 * t331 * t74 - 0.2e1 * t182 * t668 - 0.2e1 * t115 * t41 * t204;
-        t1079 = t58 * t8;
-        t1091 = t807 * t29;
-        t1092 = t665 * t40;
-        t1101 = ZB * t91;
-        t1102 = t403 * n;
-        t1105 = -0.4e1 * t58 * ZB * ZA * t64 - t82 * t850 + 0.2e1 * t821 * t860 + t81 * t51 * t793 +
-                0.2e1 * t3 * t25 * t1079 * t90 + t82 * t721 - 0.2e1 * t643 * t668 +
-                0.16e2 * t926 * t927 * t29 * t91 * t41 + 0.32e2 * t1091 * t1092 - 0.2e1 * t219 * t220 * t19 +
-                0.4e1 * t139 * ZA * t64 + 0.4e1 * t1101 * t1102;
-        t1108 = t849 * t72;
-        t1121 = t737 * t15;
-        t1124 = t29 * t12;
-        t1133 = t116 * t1108 - 0.8e1 * t475 * t209 - 0.32e2 * t807 * xc * t1092 + 0.2e1 * t278 * t269 * t73 +
-                t82 * t812 - 0.6e1 * t56 * t131 + 0.2e1 * t253 * t1121 + 0.16e2 * t926 * t927 * t1124 * t41 +
-                t168 * t263 - 0.2e1 * t616 * t827 + t81 * t981;
-        t1134 = t394 * t28;
-        t1159 = -0.8e1 * t1134 * t29 * t18 * t57 + t82 * t118 - 0.12e2 * t215 * t1018 + 0.2e1 * t602 * t801 -
-                t168 * t341 + 0.2e1 * t67 * t58 * t64 + t168 * t344 - 0.6e1 * t174 * t368 * t208 +
-                0.16e2 * t553 * t903 + t116 * t790 - 0.4e1 * t36 * t38 * t800 * t15;
-        t1161 = n * t83;
-        t1173 = ZB * t12;
-        t1196 = 0.4e1 * t1161 * ZB * t39 * ZA - 0.4e1 * t215 * t1029 - 0.8e1 * t488 * 0.3141592654e1 * t39 * xc +
-                0.32e2 * t821 * ZA * t8 * t1173 * t18 - 0.8e1 * t427 * t147 + 0.6e1 * t701 * t165 -
-                0.16e2 * t926 * t927 * t1124 * t18 - 0.8e1 * t1091 * t63 * t57 - 0.8e1 * t442 * t209 -
-                0.8e1 * t462 * t660 - 0.6e1 * t398 * t35 * t52;
-        t1228 = 0.2e1 * t413 * t305 - 0.8e1 * t648 * t961 - 0.16e2 * t87 * t27 * t23 * t28 * ZA * t29 +
-                0.4e1 * t189 * t1102 - 0.4e1 * t87 * t1079 * t212 * t879 + 0.2e1 * t164 * t948 -
-                0.2e1 * t70 * t923 + 0.2e1 * t164 * t322 + 0.2e1 * t446 * t1121 + 0.2e1 * t863 * t964 * t304 -
-                t82 * t1108 + 0.16e2 * t676 * t490 * t19;
-        t1234 = t25 * ZB;
-        t1235 = t1234 * t28;
-        t1236 = t365 * t91;
-        t1240 = ZB * t121;
-        t1241 = t1240 * t77;
-        t1242 = t39 * t39;
-        t1243 = t12 * t1242;
-        t1244 = xc * t72;
-        t1245 = t1243 * t1244;
-        t1248 = t365 * t25;
-        t1252 = t243 * n;
-        t1257 = t23 * t1;
-        t1258 = t1240 * t1257;
-        t1259 = t67 * t12;
-        t1260 = xc * t16;
-        t1268 = t1234 * t121;
-        t1269 = t1268 * t23;
-        t1272 = t1242 * t91;
-        t1280 = t67 * xc;
-        t1284 = t28 * t28;
-        t1285 = t67 * t1284;
-        t1287 = t1285 * t2 * ZB;
-        t1288 = t17 * xc;
-        t1289 = t1243 * t1288;
-        t1292 = 0.2e1 * t1235 * t1236 * t17 + 0.8e1 * t1241 * t1245 + 0.4e1 * t927 * t1248 * t91 -
-                0.2e1 * t1252 * ZB * t1242 * t91 - 0.8e1 * t1258 * t1259 * t1260 - 0.4e1 * t1235 * t2 * t83 * t39 +
-                0.16e2 * t1269 * t758 + 0.2e1 * t1252 * t189 * t1272 - 0.2e1 * t1252 * t83 * t1242 * ZB +
-                0.8e1 * t1258 * t630 * t1280 - 0.32e2 * t1287 * t1289;
-        t1293 = t365 * t83;
-        t1300 = ZA * t1284;
-        t1304 = t17 * t1242 * t25 * t12;
-        t1307 = t927 * t2;
-        t1311 = t23 * t2;
-        t1312 = t1300 * t1311;
-        t1316 = t1234 * t1284;
-        t1317 = t1316 * t1311;
-        t1321 = t1240 * t23;
-        t1331 = t1240 * t23 * t67;
-        t1332 = t40 * t1244;
-        t1338 = t1243 * t1260;
-        t1344 = -0.2e1 * t1235 * t1293 - 0.16e2 * t181 * t365 * t901 * t12 - 0.64e2 * t1300 * t258 * t1304 +
-                0.8e1 * t1307 * t613 * t39 + 0.64e2 * t1312 * t265 * t402 - 0.32e2 * t1317 * t1288 * t12 -
-                0.16e2 * t1321 * t67 * t39 * t1244 + 0.2e1 * t1235 * n * t1272 * t17 + 0.16e2 * t1331 * t1332 +
-                0.64e2 * t1300 * t292 * t1304 - 0.8e1 * t1241 * t1338 - 0.2e1 * t243 * t1293 * ZB;
-        t1346 = t1316 * t2;
-        t1349 = t927 * n;
-        t1350 = t25 * t1242;
-        t1354 = t1268 * t1257;
-        t1366 = t1268 * t1;
-        t1370 = t29 * t17;
-        t1371 = t1243 * t1370;
-        t1386 = -0.32e2 * t1346 * t1289 + 0.4e1 * t1349 * t1350 * t91 + 0.8e1 * t1354 * t1260 * t12 -
-                0.16e2 * t181 * n * t901 * t1243 - 0.4e1 * t1235 * t2 * t91 * t39 + 0.8e1 * t1366 * t152 * t1242 +
-                0.32e2 * t1287 * t1371 + 0.8e1 * t1258 * t1280 * t152 - 0.8e1 * t1354 * t1260 * t91 +
-                0.128e3 * t1300 * t365 * xc * t1092 + 0.8e1 * t1366 * t1338;
-        t1387 = t1257 * t12;
-        t1391 = t1240 * t1;
-        t1399 = t1272 * t1260;
-        t1412 = t1285 * t1311;
-        t1427 = -0.8e1 * t1268 * t1387 * t16 - 0.8e1 * t1391 * t67 * t1242 * t1244 - 0.4e1 * t1134 * t1101 * t39 +
-                0.8e1 * t1241 * t1399 - 0.8e1 * t1258 * t596 + 0.4e1 * t927 * t1293 * t25 - 0.16e2 * t1331 * t758 +
-                0.8e1 * t1307 * t665 * t39 + 0.32e2 * t1412 * t1370 * t1173 + 0.8e1 * t1307 * t665 * t800 +
-                0.8e1 * t1391 * t1259 * t1242 * t16 - 0.8e1 * t1391 * t1259 * t1242 * t72;
-        t1456 = t365 * ZB;
-        t1468 = 0.4e1 * t927 * t1248 * t17 - 0.2e1 * t1235 * n * t1242 * t91 + 0.8e1 * t1366 * t1244 * t1242 -
-                0.16e2 * t1269 * t134 * t39 + 0.8e1 * t1268 * t1257 * t72 * xc + 0.16e2 * t1321 * t1259 * t757 +
-                0.32e2 * t1317 * t1370 * t12 + 0.4e1 * t1349 * t613 * t1242 + 0.2e1 * t243 * t1456 * t17 -
-                0.64e2 * t1285 * t365 * t12 * t189 * t490 - 0.8e1 * t1354 * t152 * xc;
-        t1472 = t1316 * t365;
-        t1474 = t1124 * t39 * t17;
-        t1478 = t17 * t91;
-        t1504 = t72 * t39;
-        t1511 = 0.4e1 * t1134 * t189 * t800 + 0.64e2 * t1472 * t1474 + 0.4e1 * t1235 * t2 * t1478 * t39 +
-                0.4e1 * t1349 * t665 * t1242 - 0.8e1 * t1258 * t1280 * t72 + 0.2e1 * t1252 * t189 * t1242 +
-                0.2e1 * t243 * t365 * t189 * t91 + 0.4e1 * t927 * t365 * t1478 * t25 -
-                0.128e3 * t1300 * t1248 * t1474 - 0.2e1 * t1235 * t1236 + 0.16e2 * t1269 * t1504 * xc +
-                0.2e1 * t1235 * t365 * t17;
-        t1545 = -0.2e1 * t1235 * t1161 * t1242 + 0.4e1 * t1349 * t1350 * t1478 - 0.8e1 * t1366 * t1245 +
-                0.2e1 * t1235 * t556 * t1242 - 0.32e2 * t1412 * t402 * t726 - 0.8e1 * t1366 * t1399 +
-                0.8e1 * t1258 * t651 - 0.2e1 * t243 * t1456 * t91 + 0.8e1 * t1268 * t1387 * t72 -
-                0.16e2 * t1269 * t1332 + 0.4e1 * t1134 * t189 * t39 + 0.16e2 * t1269 * t152 * t39;
-        t1564 = t1260 * t800;
-        t1583 = 0.64e2 * t1285 * t1456 * t1474 - 0.64e2 * t1472 * t1288 * t40 - 0.8e1 * t1366 * t134 * t1242 +
-                0.8e1 * t1307 * t362 * t39 + 0.4e1 * t1235 * t2 * t17 * t39 + 0.32e2 * t1346 * t1371 -
-                0.16e2 * t1269 * t1564 - 0.16e2 * t1321 * t1259 * t1504 + 0.16e2 * t1331 * t1564 -
-                0.64e2 * t1312 * t29 * t25 * t402 - 0.4e1 * t1134 * t83 * t39 * ZB - 0.32e2 * t181 * t2 * t404;
-
-        _C2B = (t1133 + t1196 + t1068 + t811 + t466 + t1012 + t381 + t162 + t249 + t533 + t844 + t104 + t1159 +
-                t571 + t211 + t874 + t607 + t339 + t296 + t638 + t908 + t671 + t419 + t983 + t705 + t1105 + t501 +
-                t778 + t1040 + t1228 + t741 + t944) /
-               (t1292 + t1344 + t1386 + t1427 + t1468 + t1511 + t1545 + t1583);
-        /****************************************************************************************/
-        t1 = n * n;
-        t2 = t1 * n;
-        t3 = t2 * nx;
-        t4 = nx * 0.3141592654e1;
-        t5 = t4 * xc;
-        t6 = sin(t5);
-        t7 = 0.3141592654e1 * 0.3141592654e1;
-        t9 = t3 * t6 * t7;
-        t10 = xc * xc;
-        t11 = ZA * ZA;
-        t12 = t10 * t11;
-        t13 = n * 0.3141592654e1;
-        t14 = exp(t13);
-        t15 = t14 * t14;
-        t16 = xc * n;
-        t18 = exp(t16 * 0.3141592654e1);
-        t19 = t18 * t18;
-        t20 = t19 * t18;
-        t21 = t15 * t20;
-        t22 = t12 * t21;
-        t25 = nx * t6;
-        t26 = t1 * 0.3141592654e1;
-        t27 = t25 * t26;
-        t28 = ZA * ZB;
-        t29 = t18 * t15;
-        t30 = t28 * t29;
-        t33 = t25 * n;
-        t34 = t11 * t15;
-        t35 = t19 * t19;
-        t36 = t35 * t18;
-        t40 = t25 * t1;
-        t41 = 0.3141592654e1 * t11;
-        t42 = t15 * t36;
-        t43 = t41 * t42;
-        t46 = nx * nx;
-        t47 = t1 * t46;
-        t48 = t47 * t11;
-        t49 = t7 * xc;
-        t50 = t35 * t15;
-        t51 = t49 * t50;
-        t55 = sin(t4);
-        t56 = t46 * nx * t55;
-        t58 = t56 * n * t7;
-        t59 = ZB * ZB;
-        t60 = t10 * t59;
-        t61 = t15 * t14;
-        t62 = t19 * t61;
-        t63 = t60 * t62;
-        t66 = t19 * t14;
-        t67 = t60 * t66;
-        t70 = t28 * t42;
-        t73 = cos(t5);
-        t74 = t47 * t73;
-        t75 = t7 * t11;
-        t77 = t75 * t10 * t36;
-        t80 = t73 * t46;
-        t81 = t80 * n;
-        t82 = 0.3141592654e1 * t59;
-        t83 = t82 * t42;
-        t87 = xc * t11;
-        t88 = t87 * t62;
-        t91 = n * nx;
-        t92 = t55 * t61;
-        t96 = nx * t55;
-        t98 = t96 * t2 * t7;
-        t101 = xc * t59;
-        t102 = t101 * t62;
-        t108 = t1 * t1;
-        t109 = t108 * t7;
-        t111 = t59 * t35;
-        t112 = t111 * t15;
-        t115 = t35 * t20;
-        t123 = t1 * nx * t55;
-        t124 = t61 * t35;
-        t127 = t35 * t19;
-        t128 = t61 * t127;
-        t129 = t60 * t128;
-        t132 = t56 * t16;
-        t133 = t7 * t59;
-        t134 = t133 * t124;
-        t137 = 0.6e1 * t58 * t88 - 0.2e1 * t91 * t92 * t11 + 0.2e1 * t98 * t63 - 0.6e1 * t58 * t102 -
-               0.2e1 * t91 * t92 * t59 - 0.16e2 * t109 * xc * t112 - 0.2e1 * t91 * t6 * t115 * t59 +
-               0.12e2 * t40 * t83 + t123 * t41 * t124 - 0.2e1 * t58 * t129 + 0.4e1 * t132 * t134;
-        t139 = t56 * 0.3141592654e1;
-        t140 = t111 * t14;
-        t144 = t49 * t124;
-        t147 = t91 * t55;
-        t148 = t61 * ZA;
-        t154 = ZA * t115 * xc * ZB;
-        t157 = t7 * 0.3141592654e1;
-        t159 = t96 * t108 * t157;
-        t160 = t10 * xc;
-        t161 = t160 * t59;
-        t162 = t35 * t14;
-        t163 = t161 * t162;
-        t166 = t28 * t162;
-        t169 = t80 * t13;
-        t170 = t101 * t42;
-        t173 = t2 * t11;
-        t174 = t96 * t173;
-        t175 = t7 * t10;
-        t179 = t59 * t15;
-        t184 = t15 * t15;
-        t193 = t139 * t140 + 0.4e1 * t56 * n * t11 * t144 + 0.4e1 * t147 * t148 * ZB + 0.4e1 * t27 * t154 +
-               0.8e1 * t159 * t163 - 0.12e2 * t147 * t166 + 0.2e1 * t169 * t170 - 0.16e2 * t174 * t175 * t124 +
-               0.2e1 * t33 * t179 * t20 - 0.2e1 * t33 * t11 * t36 * t184 +
-               0.2e1 * t56 * t61 * 0.3141592654e1 * ZA * ZB;
-        t194 = t173 * 0.3141592654e1;
-        t195 = xc * t15;
-        t196 = t195 * t19;
-        t202 = t15 * t115;
-        t203 = t28 * t202;
-        t206 = t96 * t26;
-        t207 = t14 * t127;
-        t208 = t101 * t207;
-        t211 = t12 * t128;
-        t218 = t11 * t61;
-        t219 = t218 * t35;
-        t221 = t108 * ZA;
-        t223 = t7 * ZB;
-        t224 = t223 * t50;
-        t227 = ZA * xc;
-        t228 = ZB * t15;
-        t229 = t228 * t36;
-        t230 = t227 * t229;
-        t233 = t87 * t207;
-        t236 = t6 * t11;
-        t240 = -0.4e1 * t194 * t196 + 0.4e1 * t194 * t195 * t127 + 0.4e1 * t33 * t203 - 0.12e2 * t206 * t208 +
-               0.2e1 * t58 * t211 - 0.16e2 * t47 * t10 * t133 * t50 + t139 * t219 - 0.32e2 * t221 * t10 * t224 -
-               0.4e1 * t169 * t230 - 0.6e1 * t98 * t233 + 0.2e1 * t91 * t236 * t20;
-        t244 = t227 * t228 * t20;
-        t252 = t184 * t18;
-        t253 = t101 * t252;
-        t256 = t35 * t35;
-        t257 = t256 * t14;
-        t258 = t28 * t257;
-        t261 = t108 * t11;
-        t263 = t7 * t35;
-        t268 = ZB * t61 * t35;
-        t273 = t96 * t108 * t160;
-        t274 = t157 * ZB;
-        t276 = t274 * t148 * t35;
-        t279 = t101 * t21;
-        t282 = 0.3141592654e1 * xc;
-        t283 = t59 * t36;
-        t284 = t282 * t283;
-        t289 = 0.4e1 * t169 * t244 - 0.4e1 * t132 * t133 * t162 - 0.2e1 * t147 * t140 - 0.2e1 * t27 * t253 +
-               0.2e1 * t139 * t258 + 0.16e2 * t261 * t10 * t263 * t15 - 0.16e2 * t206 * t227 * t268 -
-               0.16e2 * t273 * t276 - 0.6e1 * t27 * t279 - 0.4e1 * t40 * t284 - 0.32e2 * t9 * t230;
-        t290 = t1 * t11;
-        t291 = t96 * t290;
-        t297 = t59 * t61;
-        t298 = t297 * t127;
-        t300 = ZB * t36;
-        t301 = t227 * t300;
-        t304 = t1 * t59;
-        t305 = t184 * t35;
-        t310 = t46 * ZB;
-        t311 = t184 * ZA;
-        t312 = t310 * t311;
-        t314 = t60 * t21;
-        t317 = t1 * ZA;
-        t318 = ZB * t35;
-        t321 = t1 * t256;
-        t324 = t96 * t261;
-        t325 = t10 * t157;
-        t326 = t325 * t124;
-        t329 = -0.4e1 * t291 * t282 * t128 + t123 * t82 * t62 - t139 * t298 + 0.12e2 * t27 * t301 + t304 * t305 -
-               0.2e1 * t58 * t12 * t66 - 0.2e1 * t312 + 0.8e1 * t9 * t314 + 0.2e1 * t317 * t318 +
-               0.2e1 * t321 * t28 - 0.8e1 * t324 * t326;
-        t331 = t28 * t124;
-        t334 = 0.3141592654e1 * t15;
-        t335 = t334 * t127;
-        t338 = t35 * ZA;
-        t341 = t46 * t256;
-        t344 = t46 * t11;
-        t346 = t46 * t59;
-        t348 = t297 * t35;
-        t351 = ZA * t10;
-        t352 = t351 * t300;
-        t355 = t1 * ZB;
-        t362 = 0.12e2 * t147 * t331 - 0.4e1 * t173 * t335 - 0.2e1 * t310 * t338 - 0.2e1 * t341 * t28 - t344 * t305 -
-               t346 * t305 + 0.2e1 * t147 * t348 + 0.16e2 * t9 * t352 + 0.2e1 * t355 * t311 + t290 * t305 +
-               0.2e1 * t33 * t34 * t20;
-        t363 = t36 * t184;
-        t364 = t87 * t363;
-        t368 = t47 * t73 * t7;
-        t373 = t160 * t157;
-        t374 = t373 * t124;
-        t377 = t311 * t35;
-        t380 = t12 * t62;
-        t386 = ZB * t10 * ZA * t15 * t20;
-        t389 = t87 * t66;
-        t393 = t56 * t1 * t10;
-        t401 = 0.2e1 * t27 * t364 - 0.16e2 * t368 * t279 - t123 * t41 * t257 + 0.8e1 * t324 * t374 +
-               0.2e1 * t355 * t377 - 0.2e1 * t98 * t380 - 0.16e2 * t9 * t386 + 0.2e1 * t58 * t389 +
-               0.16e2 * t393 * t276 + t123 * t82 * t162 - 0.2e1 * t33 * t179 * t36;
-        t412 = t11 * t14 * t127;
-        t416 = t11 * t19;
-        t417 = t416 * t61;
-        t421 = t96 * t2 * ZA;
-        t426 = t56 * n * ZA;
-        t427 = t318 * t14;
-        t428 = t49 * t427;
-        t431 = t82 * t29;
-        t434 = t87 * t21;
-        t442 = 0.2e1 * t33 * t11 * t184 * t18 + 0.4e1 * t81 * t284 - t139 * t412 + 0.2e1 * t147 * t219 -
-               0.2e1 * t147 * t417 + 0.32e2 * t421 * t175 * t268 + 0.8e1 * t426 * t428 + 0.4e1 * t81 * t431 -
-               0.2e1 * t169 * t434 - 0.2e1 * t98 * t129 - 0.32e2 * t47 * t28 * t51;
-        t443 = t184 * t20;
-        t447 = t61 * 0.3141592654e1;
-        t448 = t447 * t11;
-        t450 = t49 * t268;
-        t453 = t60 * t42;
-        t456 = t41 * t202;
-        t463 = t101 * t443;
-        t469 = t41 * xc * t20;
-        t474 = -0.8e1 * t27 * t87 * t443 - t56 * t448 - 0.8e1 * t426 * t450 + 0.8e1 * t368 * t453 +
-               0.4e1 * t40 * t456 + 0.4e1 * t40 * t431 - 0.4e1 * t81 * t456 - 0.4e1 * t27 * t463 +
-               0.6e1 * t139 * t331 + 0.2e1 * t40 * t469 - 0.16e2 * t9 * t434;
-        t482 = t108 * t10;
-        t492 = n * t46;
-        t493 = t492 * t11;
-        t495 = t282 * t19 * t184;
-        t498 = t56 * t290;
-        t499 = t325 * t162;
-        t502 = t416 * t14;
-        t504 = t60 * t207;
-        t507 = -t123 * t82 * t257 - 0.4e1 * t169 * t301 + t123 * t41 * t162 + 0.16e2 * t482 * t7 * t112 -
-               0.12e2 * t206 * t102 - t123 * t82 * t66 - 0.4e1 * t147 * t258 - 0.4e1 * t493 * t495 -
-               0.8e1 * t498 * t499 + t139 * t502 - 0.2e1 * t98 * t504;
-        t508 = t101 * t162;
-        t512 = t41 * t115 * xc;
-        t515 = t87 * t42;
-        t520 = ZB * t184;
-        t522 = t227 * t520 * t18;
-        t525 = t492 * t59;
-        t528 = t6 * t59;
-        t532 = t520 * t20;
-        t533 = t351 * t532;
-        t539 = t447 * t59;
-        t544 = 0.8e1 * t206 * t508 - 0.2e1 * t40 * t512 - 0.16e2 * t368 * t515 + 0.12e2 * t206 * t88 +
-               0.4e1 * t27 * t522 + 0.4e1 * t525 * t495 - 0.4e1 * t91 * t528 * t36 - 0.16e2 * t368 * t533 -
-               0.16e2 * t206 * t227 * t427 - t56 * t539 - 0.2e1 * t132 * t133 * t66;
-        t551 = t87 * t162;
-        t554 = t351 * t229;
-        t560 = t59 * t19;
-        t561 = t560 * t14;
-        t564 = t101 * t202;
-        t567 = t87 * t252;
-        t573 = t227 * t228 * t115;
-        t578 = 0.4e1 * t33 * t70 + 0.4e1 * t493 * t335 - 0.4e1 * t58 * t551 + 0.16e2 * t9 * t554 -
-               0.4e1 * t33 * t28 * t252 + 0.2e1 * t147 * t561 + 0.2e1 * t169 * t564 - 0.2e1 * t27 * t567 -
-               0.8e1 * t324 * t499 - 0.4e1 * t169 * t573 + 0.12e2 * t27 * t244;
-        t579 = t82 * t202;
-        t591 = t282 * t115 * t59;
-        t598 = t101 * t66;
-        t606 = -0.4e1 * t81 * t579 - 0.2e1 * t169 * t567 - 0.6e1 * t27 * t170 + 0.8e1 * t169 * t203 +
-               0.2e1 * t98 * t67 + 0.2e1 * t81 * t591 + 0.32e2 * t368 * t244 - 0.2e1 * t27 * t564 +
-               0.4e1 * t206 * t598 + 0.16e2 * t9 * t170 + 0.2e1 * t33 * t283 * t184;
-        t608 = t373 * t162;
-        t611 = t59 * t184;
-        t617 = t101 * t29;
-        t624 = t227 * ZB * t18 * t15;
-        t629 = t157 * t59;
-        t630 = t629 * t124;
-        t633 = t3 * t6;
-        t634 = t175 * t283;
-        t644 = 0.8e1 * t498 * t608 + 0.2e1 * t33 * t611 * t18 - 0.4e1 * t206 * t389 - 0.2e1 * t27 * t617 -
-               0.4e1 * t169 * t154 + 0.4e1 * t27 * t624 + 0.12e2 * t27 * t230 - 0.8e1 * t393 * t630 -
-               0.8e1 * t633 * t634 + 0.16e2 * t47 * t7 * t101 * t50 + 0.2e1 * t123 * t447 * t28;
-        t645 = t41 * t29;
-        t648 = t2 * 0.3141592654e1;
-        t649 = t648 * xc;
-        t650 = t560 * t184;
-        t656 = t56 * t1 * t157;
-        t659 = t87 * t128;
-        t662 = t96 * t482;
-        t663 = t629 * t162;
-        t671 = t161 * t124;
-        t674 = t218 * t127;
-        t679 = 0.4e1 * t81 * t645 - 0.4e1 * t649 * t650 - 0.8e1 * t169 * t70 + 0.8e1 * t656 * t163 -
-               0.2e1 * t98 * t659 - 0.8e1 * t662 * t663 - 0.32e2 * t421 * t175 * t427 - 0.2e1 * t147 * t502 +
-               0.8e1 * t656 * t671 + 0.2e1 * t147 * t674 - 0.16e2 * t368 * t386;
-        t714 = t334 * t19;
-        t719 = t12 * t42;
-        t722 = t304 * t35 - t346 * t35 + t341 * t59 - t344 * t35 + t344 * t256 + t346 * t184 -
-               0.16e2 * t368 * t554 - 0.16e2 * t48 * t175 * t50 + 0.4e1 * t525 * t714 - 0.2e1 * t58 * t659 +
-               0.8e1 * t368 * t719;
-        t730 = xc * t19;
-        t735 = t59 * t256 * t14;
-        t752 = 0.4e1 * t173 * t714 - 0.6e1 * t27 * t515 - 0.16e2 * t9 * t279 + 0.4e1 * t194 * t730 * t184 -
-               t139 * t735 - 0.4e1 * t492 * t127 * t82 * xc - 0.4e1 * t98 * t508 - t123 * t41 * t207 -
-               0.2e1 * t147 * t298 + 0.8e1 * t368 * t314 + 0.6e1 * t132 * t133 * t207;
-        t755 = t28 * t21;
-        t759 = t274 * t338 * t14;
-        t767 = t11 * t35;
-        t768 = t767 * t14;
-        t778 = t560 * t61;
-        t781 = -0.2e1 * t58 * t504 - 0.8e1 * t27 * t755 + 0.16e2 * t662 * t759 + 0.12e2 * t291 * t282 * t207 -
-               0.6e1 * t27 * t434 + t139 * t768 - 0.8e1 * t498 * t326 + 0.4e1 * t33 * t611 * t20 +
-               0.2e1 * t81 * t512 - t139 * t561 + 0.2e1 * t147 * t778;
-        t786 = t12 * t443;
-        t790 = t282 * t59 * t20;
-        t796 = t59 * t14 * t127;
-        t806 = t41 * t21;
-        t811 = -0.8e1 * t393 * t663 + 0.8e1 * t368 * t786 + 0.2e1 * t81 * t790 + 0.4e1 * t169 * t624 + t139 * t796 +
-               0.2e1 * t206 * t258 - 0.2e1 * t40 * t591 - 0.8e1 * t662 * t630 - 0.4e1 * t33 * t30 -
-               0.4e1 * t40 * t806 + 0.8e1 * t9 * t786;
-        t819 = t282 * t15 * t127;
-        t822 = t101 * t363;
-        t830 = t11 * t256 * t14;
-        t835 = t227 * t532;
-        t842 = 0.2e1 * t33 * t11 * t18 * t15 + t123 * t41 * t66 - 0.4e1 * t493 * t819 - 0.2e1 * t27 * t822 -
-               0.16e2 * t368 * t170 - 0.4e1 * t169 * t463 - t139 * t830 - 0.4e1 * t649 * t179 * t127 +
-               0.12e2 * t27 * t835 - 0.16e2 * t368 * t434 - 0.2e1 * t40 * t790;
-        t845 = t87 * t202;
-        t854 = t338 * t15;
-        t859 = t12 * t207;
-        t868 = t139 * t348 - 0.2e1 * t27 * t845 + 0.8e1 * t169 * t755 - 0.2e1 * t58 * t380 + 0.6e1 * t206 * t331 +
-               0.8e1 * t310 * t854 - 0.2e1 * t169 * t822 + 0.2e1 * t98 * t859 + 0.8e1 * t159 * t671 +
-               0.8e1 * t74 * t634 - 0.2e1 * t169 * t253;
-        t880 = t60 * t443;
-        t891 = t101 * t128;
-        t894 = -t123 * t539 - 0.2e1 * t147 * t796 + 0.32e2 * t368 * t230 + t139 * t674 - 0.16e2 * t98 * t60 * t124 +
-               0.32e2 * t9 * t244 + 0.8e1 * t368 * t880 - 0.8e1 * t40 * t41 * xc * t36 - t123 * t82 * t128 -
-               0.6e1 * t58 * t233 + 0.2e1 * t58 * t891;
-        t903 = t179 * t19;
-        t920 = t56 * t1 * t160;
-        t925 = -0.2e1 * t174 * t175 * t66 - 0.4e1 * t493 * t714 + 0.4e1 * t649 * t903 - 0.4e1 * t81 * t43 +
-               t123 * t82 * t207 + 0.4e1 * t206 * t891 - 0.16e2 * t273 * t759 - 0.8e1 * t27 * t203 +
-               0.32e2 * t221 * ZB * t51 - 0.16e2 * t920 * t759 - 0.8e1 * t9 * t453;
-        t932 = t87 * t29;
-        t945 = t82 * t21;
-        t953 = -0.16e2 * t920 * t276 - 0.8e1 * t169 * t30 - 0.8e1 * t633 * t77 - 0.2e1 * t27 * t932 -
-               0.4e1 * t174 * t49 * t162 + 0.8e1 * t206 * t87 * t124 - 0.2e1 * t147 * t768 + 0.4e1 * t169 * t522 -
-               0.12e2 * t81 * t945 + 0.4e1 * t33 * t28 * t115 + 0.4e1 * t525 * t819;
-        t971 = t282 * t127;
-        t978 = -0.6e1 * t98 * t102 + 0.2e1 * t169 * t515 - 0.2e1 * t310 * t377 + 0.2e1 * t147 * t830 +
-               0.8e1 * t368 * t22 - 0.2e1 * t169 * t617 + 0.16e2 * t662 * t276 - 0.8e1 * t355 * t854 +
-               0.4e1 * t493 * t971 - 0.16e2 * t9 * t533 - 0.2e1 * t169 * t279;
-        t997 = xc * t127;
-        t998 = t997 * t59;
-        t1003 = 0.4e1 * t40 * t579 + 0.2e1 * t169 * t845 + 0.16e2 * t9 * t515 + 0.8e1 * t206 * t551 +
-                t123 * t41 * t128 + 0.16e2 * t98 * t60 * t162 + 0.2e1 * t169 * t364 - 0.2e1 * t169 * t932 +
-                t139 * t778 + 0.4e1 * t648 * t998 + 0.2e1 * t147 * t412;
-        t1006 = t2 * t59;
-        t1017 = xc * t35;
-        t1033 = 0.4e1 * t1006 * t335 + 0.4e1 * t81 * t806 - 0.2e1 * t33 * t34 * t115 + 0.8e1 * t498 * t374 -
-                0.16e2 * t261 * t7 * t1017 * t15 + 0.8e1 * t206 * t101 * t124 - t123 * t448 + 0.2e1 * t147 * t735 +
-                0.6e1 * t98 * t208 + 0.6e1 * t98 * t88 - 0.4e1 * t33 * t755;
-        t1055 = -0.4e1 * t173 * t971 + 0.2e1 * t98 * t891 + 0.8e1 * t9 * t880 + 0.4e1 * t169 * t835 - t304 * t184 +
-                t344 * t184 - t123 * t41 * t62 - 0.2e1 * t98 * t598 + 0.2e1 * t58 * t859 +
-                0.32e2 * t47 * t351 * t224 + 0.2e1 * t98 * t389;
-        t1070 = t15 * t19;
-        t1089 = -0.16e2 * t368 * t352 - 0.8e1 * t9 * t719 + 0.4e1 * t96 * t2 * xc * t134 -
-                0.2e1 * t91 * t236 * t115 + 0.4e1 * t27 * t573 + 0.4e1 * t493 * t282 * t1070 +
-                0.2e1 * t33 * t59 * t18 * t15 + 0.12e2 * t40 * t945 - 0.4e1 * t492 * xc * t82 * t1070 -
-                0.2e1 * t91 * t528 * t20 + 0.8e1 * t324 * t608;
-        t1113 = t123 * t82 * t124 + 0.8e1 * t421 * t428 - t139 * t417 + 0.4e1 * t40 * t645 + 0.16e2 * t393 * t759 -
-                0.2e1 * t33 * t179 * t115 - 0.4e1 * t525 * t335 + 0.4e1 * t33 * t28 * t36 - 0.4e1 * t1006 * t714 +
-                0.6e1 * t206 * t166 - 0.8e1 * t421 * t450;
-        t1119 = t321 * t46;
-        t1122 = t157 * t11;
-        t1123 = t1122 * t2;
-        t1124 = t184 * t46;
-        t1128 = t108 * n;
-        t1132 = t7 * t7;
-        t1133 = t1132 * t11;
-        t1134 = t1133 * t108;
-        t1135 = t15 * t46;
-        t1139 = t7 * ZA;
-        t1140 = t1139 * ZB;
-        t1141 = t1 * t35;
-        t1145 = t629 * t2;
-        t1146 = t1135 * t730;
-        t1149 = t157 * t1128;
-        t1150 = t1149 * xc;
-        t1153 = t46 * xc;
-        t1154 = t1153 * t127;
-        t1158 = t184 * t1 * t46;
-        t1161 = t46 * t46;
-        t1162 = t35 * t1161;
-        t1166 = t7 * t1;
-        t1170 = -0.4e1 * t133 * t1119 + 0.16e2 * t1123 * t1124 * t730 - 0.8e1 * t1122 * t1128 * t196 -
-                0.64e2 * t1134 * t1135 * t1017 - 0.32e2 * t1140 * t1141 * t1135 + 0.16e2 * t1145 * t1146 -
-                0.8e1 * t1150 * t650 - 0.16e2 * t1123 * t1154 - 0.4e1 * t133 * t1158 -
-                0.16e2 * t1140 * t1162 * t15 + 0.8e1 * t1166 * t35 * t312;
-        t1171 = t1161 * t184;
-        t1175 = t1122 * n;
-        t1176 = t15 * t1161;
-        t1180 = t1132 * ZA;
-        t1181 = t1180 * t355;
-        t1182 = t1176 * t1017;
-        t1185 = t1161 * xc;
-        t1189 = t1133 * t1;
-        t1192 = t108 * t1;
-        t1193 = t1132 * t1192;
-        t1195 = t10 * t35;
-        t1199 = t157 * t15;
-        t1203 = t1141 * t46;
-        t1211 = t184 * t108;
-        t1218 = 0.2e1 * t133 * t1171 * t35 + 0.8e1 * t1175 * t1176 * t997 + 0.64e2 * t1181 * t1182 -
-                0.8e1 * t1175 * t1185 * t127 - 0.32e2 * t1189 * t1182 - 0.64e2 * t1193 * ZA * t1195 * t228 +
-                0.8e1 * t1199 * t416 * t1128 + 0.8e1 * t1140 * t1203 - 0.4e1 * t75 * t1158 -
-                0.8e1 * t1199 * t560 * t1128 - 0.2e1 * t133 * t1211 - 0.8e1 * t1199 * t127 * t11 * t1128;
-        t1221 = t256 * t1161;
-        t1224 = t35 * t108;
-        t1233 = t7 * t256;
-        t1236 = -t75 * t1211 - t75 * t1221 - t133 * t1221 + t75 * t1224 - t75 * t1171 - t133 * t1171 +
-                t133 * t1224 + t75 * t1162 - t75 * t108 * t256 + t133 * t1162 - t1233 * t59 * t108;
-        t1240 = t1135 * t1195;
-        t1252 = t629 * t127;
-        t1263 = t1171 * ZA;
-        t1280 = -0.128e3 * t1180 * ZB * t108 * t1240 + 0.32e2 * t1193 * t10 * t112 + 0.4e1 * t133 * t1203 +
-                0.4e1 * t109 * t256 * ZA * ZB - 0.8e1 * t1252 * n * t15 * t1185 + 0.8e1 * t1175 * t1171 * t730 -
-                0.8e1 * t1175 * t1176 * t127 + 0.4e1 * t223 * t1263 - 0.8e1 * t1175 * t1176 * t730 +
-                0.8e1 * t1166 * ZA * t341 * ZB + 0.64e2 * t1134 * t1240 + 0.8e1 * t1122 * xc * t1128 * t127 * t15;
-        t1283 = t1199 * t19;
-        t1287 = t1199 * t127;
-        t1289 = t59 * n * t1161;
-        t1293 = t157 * n * xc;
-        t1304 = t1132 * t108;
-        t1310 = t263 * ZB;
-        t1316 = t2 * t15;
-        t1323 = -0.16e2 * t1283 * t1006 * t46 + 0.8e1 * t1287 * t1289 + 0.8e1 * t1293 * t127 * t1161 * t59 +
-                0.16e2 * t1123 * t1135 * t19 + 0.8e1 * t1293 * t560 * t1176 + 0.64e2 * t1304 * t59 * t1240 +
-                0.4e1 * t75 * t1203 + 0.4e1 * t1310 * t1263 + 0.4e1 * t223 * t338 * t108 -
-                0.16e2 * t1252 * t1316 * t1153 - 0.16e2 * t1310 * t221 * t15;
-        t1330 = t1132 * t15;
-        t1336 = t1132 * t1;
-        t1338 = t1162 * t179;
-        t1370 = 0.8e1 * t1175 * t1176 * t19 + 0.4e1 * t1139 * t318 * t1161 +
-                0.128e3 * t1330 * t318 * t108 * t46 * t227 - 0.32e2 * t1336 * xc * t1338 +
-                0.4e1 * t1233 * ZA * t1161 * ZB - 0.8e1 * t1287 * t59 * t1128 * xc + 0.2e1 * t75 * t305 * t108 +
-                0.8e1 * t1199 * t127 * t59 * t1128 - 0.8e1 * t1283 * t1289 - 0.8e1 * t1293 * t560 * t1171 +
-                0.4e1 * t133 * t35 * t1158 + 0.8e1 * t157 * t184 * t19 * t11 * t1128 * xc;
-        t1376 = t7 * t184;
-        t1380 = t1176 * t1195;
-        t1393 = t1330 * t35;
-        t1411 = 0.16e2 * t1145 * t1154 + 0.8e1 * t1149 * t998 + 0.4e1 * t1376 * t35 * t48 + 0.32e2 * t1189 * t1380 +
-                0.32e2 * t1193 * t11 * t1195 * t15 - 0.64e2 * t1304 * xc * t111 * t1135 - 0.16e2 * t1123 * t1146 +
-                0.64e2 * t1393 * t28 * t1192 * xc - 0.16e2 * t1123 * t1135 * t127 -
-                0.8e1 * t1122 * xc * t1128 * t127 - 0.32e2 * t1193 * xc * t112 + 0.16e2 * t1252 * t1316 * t46;
-        t1450 = 0.2e1 * t1376 * t767 * t1161 + 0.2e1 * t1376 * t111 * t108 + 0.4e1 * t223 * t311 * t108 +
-                0.4e1 * t109 * t35 * t520 * ZA + 0.16e2 * t1123 * t1135 * t997 - 0.64e2 * t1181 * t1380 +
-                0.8e1 * t1150 * t903 - 0.32e2 * t1393 * t11 * t1192 * xc - 0.16e2 * t157 * t2 * xc * t560 * t1124 +
-                0.8e1 * t223 * t184 * t317 * t46 + 0.32e2 * t1336 * t10 * t1338 - 0.4e1 * t75 * t1119;
-        _C3B = (t606 + t722 + t1089 + t781 + 0.16e2 * t48 * t51 + t978 + t868 + t507 - t304 * t256 +
-                0.8e1 * t9 * t22 + t752 + 0.4e1 * t174 * t144 - 0.2e1 * t81 * t469 + 0.6e1 * t139 * t166 + t362 +
-                0.2e1 * t98 * t211 + t925 + t137 - t290 * t184 + 0.12e2 * t81 * t83 + t842 + 0.8e1 * t74 * t77 +
-                0.16e2 * t98 * t12 * t162 - 0.4e1 * t33 * t28 * t443 - 0.8e1 * t27 * t70 - 0.2e1 * t33 * t34 * t36 -
-                0.8e1 * t27 * t30 + 0.2e1 * t58 * t67 - 0.4e1 * t40 * t43 + 0.2e1 * t58 * t63 + t1033 -
-                t290 * t256 + t290 * t35 + t193 + t1113 + t578 + t442 + t474 + t544 + t329 + t679 + t401 + t953 +
-                t811 + t644 + t894 + t289 + t240 + t1055 + t1003) /
-               (t1170 + t1218 + 0.2e1 * t1236 + t1280 + t1323 + t1370 + t1411 + t1450);
-        /****************************************************************************************/
-        t1 = n * n;
-        t2 = t1 * xc;
-        t3 = ZB * ZB;
-        t5 = t2 * 0.3141592654e1 * t3;
-        t6 = nx * 0.3141592654e1;
-        t7 = t6 * xc;
-        t8 = cos(t7);
-        t9 = nx * nx;
-        t10 = t8 * t9;
-        t11 = n * 0.3141592654e1;
-        t12 = exp(t11);
-        t13 = t12 * t12;
-        t16 = exp(xc * n * 0.3141592654e1);
-        t17 = t16 * t16;
-        t18 = t17 * t16;
-        t19 = t17 * t17;
-        t20 = t19 * t18;
-        t21 = t13 * t20;
-        t22 = t10 * t21;
-        t25 = ZA * ZA;
-        t26 = t1 * t25;
-        t27 = xc * 0.3141592654e1;
-        t28 = t26 * t27;
-        t29 = t19 * t16;
-        t30 = t13 * t13;
-        t31 = t29 * t30;
-        t35 = t9 * nx;
-        t36 = t3 * t35;
-        t37 = sin(t6);
-        t38 = t13 * t12;
-        t39 = t37 * t38;
-        t40 = t39 * t19;
-        t42 = t1 * t1;
-        t43 = nx * t42;
-        t44 = xc * xc;
-        t45 = t25 * t44;
-        t46 = t43 * t45;
-        t47 = 0.3141592654e1 * 0.3141592654e1;
-        t48 = t47 * t37;
-        t49 = t17 * t38;
-        t54 = 0.3141592654e1 * t35;
-        t55 = ZA * n * t54;
-        t56 = t37 * ZB;
-        t57 = t19 * t12;
-        t61 = t25 * t8;
-        t62 = t61 * t9;
-        t63 = n * t30;
-        t64 = t63 * t16;
-        t67 = t1 * n;
-        t69 = t47 * ZB;
-        t70 = t67 * t44 * t69;
-        t75 = nx * t3;
-        t76 = t75 * t37;
-        t77 = t67 * 0.3141592654e1;
-        t78 = t19 * t19;
-        t79 = t78 * t12;
-        t80 = t77 * t79;
-        t82 = t3 * t38;
-        t84 = t54 * t37;
-        t87 = sin(t7);
-        t88 = t29 * t87;
-        t89 = t47 * t44;
-        t93 = nx * t25;
-        t94 = t87 * t42;
-        t95 = t93 * t94;
-        t96 = t47 * xc;
-        t97 = t13 * t29;
-        t98 = t96 * t97;
-        t101 = t87 * t67;
-        t102 = t93 * t101;
-        t103 = t13 * t18;
-        t107 = t47 * t35;
-        t108 = t26 * t107;
-        t109 = t37 * t44;
-        t110 = t19 * t17;
-        t111 = t12 * t110;
-        t116 = t37 * t19 * t12;
-        t118 = t37 * xc;
-        t119 = ZB * t19;
-        t120 = t119 * t12;
-        t121 = t118 * t120;
-        t125 = xc * t3;
-        t126 = t1 * t47 * t125;
-        t127 = t35 * t37;
-        t128 = t38 * t19;
-        t129 = t127 * t128;
-        t132 = t26 * 0.3141592654e1;
-        t133 = t16 * t13;
-        t134 = t10 * t133;
-        t137 = 0.3141592654e1 * ZB;
-        t138 = t2 * t137;
-        t139 = ZA * t8;
-        t140 = t9 * t13;
-        t145 = t30 * t18;
-        t146 = t10 * t145;
-        t149 = t3 * t8;
-        t150 = t149 * t9;
-        t153 = 0.2e1 * t5 * t22 + 0.2e1 * t28 * t10 * t31 + t36 * t40 - 0.2e1 * t46 * t48 * t49 -
-               0.2e1 * t55 * t56 * t57 - 0.2e1 * t62 * t64 + 0.16e2 * t70 * t29 * ZA * t10 - t76 * t80 +
-               t82 * n * t84 + 0.8e1 * t43 * t3 * t88 * t89 + 0.16e2 * t95 * t98 + 0.2e1 * t102 * t27 * t103 -
-               0.2e1 * t108 * t109 * t111 + t36 * t116 + 0.8e1 * t55 * t121 - 0.4e1 * t126 * t129 -
-               0.4e1 * t132 * t134 - 0.4e1 * t138 * t139 * t140 * t20 + 0.8e1 * t28 * t146 - 0.2e1 * t150 * t64;
-        t154 = t42 * n;
-        t155 = nx * t154;
-        t156 = t44 * xc;
-        t157 = t47 * 0.3141592654e1;
-        t158 = t156 * t157;
-        t159 = t155 * t158;
-        t162 = t56 * ZA * t19 * t12;
-        t165 = t77 * t49;
-        t167 = t1 * t3;
-        t168 = t167 * t89;
-        t169 = t127 * t49;
-        t172 = t37 * t67;
-        t173 = t75 * t172;
-        t174 = t38 * t110;
-        t175 = t27 * t174;
-        t179 = t47 * t25;
-        t181 = t10 * t97;
-        t184 = t27 * t31;
-        t187 = t67 * t47;
-        t188 = t44 * t3;
-        t189 = t187 * t188;
-        t192 = t25 * t35;
-        t193 = t37 * t17;
-        t194 = t193 * t12;
-        t196 = nx * ZA;
-        t197 = t196 * t172;
-        t198 = ZB * t38;
-        t199 = t198 * t19;
-        t204 = t1 * t12 * t110;
-        t207 = nx * ZB;
-        t209 = t1 * ZA;
-        t215 = t67 * t3;
-        t216 = t47 * t8;
-        t217 = t215 * t216;
-        t218 = t9 * xc;
-        t222 = nx * t67;
-        t223 = t222 * t27;
-        t224 = t3 * t87;
-        t228 = t167 * t107;
-        t232 = t26 * t96;
-        t235 = t207 * t94;
-        t236 = t47 * ZA;
-        t243 = xc * t13;
-        t244 = t243 * t29;
-        t248 = t25 * n;
-        t249 = t248 * 0.3141592654e1;
-        t253 = ZB * ZA;
-        t254 = t253 * t8;
-        t255 = t9 * n;
-        t256 = t30 * t16;
-        t260 = 0.2e1 * t207 * t37 * t209 * t128 + 0.2e1 * t5 * t134 - 0.16e2 * t217 * t218 * t97 -
-               0.2e1 * t223 * t224 * t31 - 0.2e1 * t228 * t109 * t174 - 0.2e1 * t232 * t169 -
-               0.16e2 * t235 * t236 * t44 * t30 * t18 - 0.4e1 * t196 * t101 * t137 * t244 + t249 * t169 +
-               0.8e1 * t168 * t129 + 0.4e1 * t254 * t255 * t256;
-        t263 = t43 * t179;
-        t267 = t3 * n;
-        t268 = t267 * t54;
-        t269 = t118 * t57;
-        t272 = t39 * t1;
-        t274 = t67 * t25;
-        t275 = t274 * t158;
-        t278 = t75 * t87;
-        t279 = t77 * t103;
-        t282 = t25 * t38;
-        t285 = ZA * t38;
-        t290 = t267 * 0.3141592654e1;
-        t296 = t77 * t111;
-        t298 = t196 * t37;
-        t299 = t1 * ZB;
-        t303 = t37 * t42;
-        t304 = t196 * t303;
-        t308 = t77 * t57;
-        t310 = t26 * t89;
-        t313 = t77 * t128;
-        t316 = t101 * t27;
-        t319 = t93 * t87;
-        t320 = t77 * t97;
-        t323 = t127 * t57;
-        t326 = t10 * n;
-        t329 = t118 * t174;
-        t332 = -0.8e1 * t263 * t109 * t57 - 0.4e1 * t268 * t269 + t93 * t272 + 0.8e1 * t275 * t129 -
-               0.4e1 * t278 * t279 + t282 * n * t84 - 0.2e1 * t285 * n * t54 * t56 - t290 * t169 -
-               0.2e1 * t196 * t38 * t172 * t137 + t76 * t296 - 0.2e1 * t298 * t299 * t79 +
-               0.8e1 * t304 * t96 * t120 + t76 * t308 - 0.2e1 * t310 * t169 - t76 * t313 +
-               0.2e1 * t75 * t18 * t316 + 0.4e1 * t319 * t320 + t249 * t323 - 0.2e1 * t25 * t18 * t326 +
-               0.2e1 * t228 * t329;
-        t335 = t75 * t101;
-        t336 = t27 * t21;
-        t342 = t77 * t133;
-        t347 = t209 * t137;
-        t350 = t9 * t1;
-        t351 = t149 * t350;
-        t355 = t37 * t78 * t12;
-        t359 = t93 * t303;
-        t367 = t172 * 0.3141592654e1;
-        t369 = t96 * t103;
-        t376 = t209 * t107;
-        t379 = t10 * t103;
-        t383 = t207 * t101;
-        t389 = 0.3141592654e1 * ZA;
-        t390 = t222 * t389;
-        t391 = t87 * ZB;
-        t398 = -0.2e1 * t102 * t336 + t93 * t38 * t367 + 0.16e2 * t95 * t369 - t82 * t127 -
-               0.8e1 * t197 * t27 * t120 + 0.8e1 * t376 * t121 - 0.8e1 * t189 * t379 - t249 * t129 -
-               0.4e1 * t383 * t27 * ZA * t16 * t13 - 0.8e1 * t390 * t391 * t21 - 0.2e1 * t197 * t137 * t57;
-        t402 = t39 * t110;
-        t404 = t193 * t38;
-        t406 = t127 * t174;
-        t408 = t167 * 0.3141592654e1;
-        t411 = t44 * t157;
-        t412 = t155 * t411;
-        t413 = t285 * t19;
-        t414 = t56 * t413;
-        t417 = ZA * t30;
-        t424 = t93 * t37;
-        t426 = t248 * t54;
-        t427 = t17 * t12;
-        t428 = t118 * t427;
-        t431 = t77 * t21;
-        t438 = ZA * t13;
-        t443 = t93 * t172;
-        t444 = t27 * t427;
-        t448 = t1 * t78 * t12;
-        t455 = t274 * t89;
-        t461 = t118 * t111;
-        t464 = -t36 * t402 + t36 * t404 - t249 * t406 - 0.4e1 * t408 * t134 + 0.16e2 * t412 * t414 -
-               0.4e1 * t383 * t27 * t417 * t18 + 0.2e1 * t28 * t22 - t424 * t80 - 0.2e1 * t426 * t428 +
-               0.4e1 * t278 * t431 + 0.4e1 * t254 * t255 * t103 + t290 * t323 + 0.4e1 * t383 * t27 * t438 * t20 +
-               0.2e1 * t443 * t444 + t424 * t448 - t36 * t194 - 0.32e2 * t235 * t236 * t243 * t18 +
-               0.8e1 * t455 * t181 - 0.4e1 * t359 * t96 * t128 - 0.2e1 * t426 * t461;
-        t469 = n * t16 * t13;
-        t474 = t1 * t38;
-        t475 = t474 * t19;
-        t480 = t89 * t103;
-        t483 = t67 * ZA;
-        t484 = t483 * t411;
-        t485 = t127 * t120;
-        t488 = t127 * t111;
-        t497 = t77 * t427;
-        t502 = t27 * t97;
-        t508 = t1 * t19 * t12;
-        t511 = t155 * t25 * t156;
-        t512 = t157 * t37;
-        t513 = t512 * t128;
-        t527 = t1 * t17;
-        t528 = t527 * t38;
-        t530 = -t76 * t497 - 0.4e1 * t254 * t255 * t97 - 0.2e1 * t102 * t502 - 0.4e1 * t108 * t269 - t76 * t508 +
-               0.8e1 * t511 * t513 + 0.4e1 * t150 * t63 * t18 + 0.4e1 * t383 * t27 * t438 * t18 +
-               0.4e1 * t132 * t379 + 0.2e1 * t168 * t488 - t76 * t528;
-        t535 = t44 * t13;
-        t542 = t527 * t12;
-        t544 = n * t13;
-        t545 = t544 * t20;
-        t548 = t75 * t303;
-        t549 = t96 * t111;
-        t552 = ZA * t35;
-        t553 = t552 * t37;
-        t562 = t43 * t96;
-        t563 = t3 * t37;
-        t564 = t563 * t128;
-        t579 = t474 * t110;
-        t590 = t9 * t30;
-        t591 = t590 * t18;
-        t595 = t127 * t427;
-        t598 = t77 * t174;
-        t600 = 0.4e1 * t5 * t146 + 0.16e2 * t235 * t236 * t535 * t18 + 0.8e1 * t455 * t146 + t76 * t542 -
-               0.2e1 * t150 * t545 + 0.2e1 * t548 * t549 - 0.2e1 * t553 * t120 + t290 * t488 -
-               0.8e1 * t274 * t47 * t44 * t29 * t10 - 0.4e1 * t562 * t564 - 0.2e1 * t132 * xc * t20 * t10 -
-               0.32e2 * t562 * ZA * t87 * ZB * t13 * t29 - 0.8e1 * t347 * t379 + t76 * t579 -
-               0.4e1 * t359 * t96 * t57 + 0.4e1 * t408 * t181 - 0.4e1 * t223 * t564 -
-               0.12e2 * t209 * t27 * ZB * t8 * t591 + 0.2e1 * t310 * t595 + t76 * t598;
-        t601 = t27 * t49;
-        t604 = t127 * t79;
-        t606 = ZB * t29;
-        t616 = t139 * t140 * t18;
-        t638 = t10 * t256;
-        t643 = t118 * t199;
-        t653 = t544 * t29;
-        t658 = t3 * t29;
-        t660 = t350 * t27;
-        t663 = -0.4e1 * t254 * t255 * t145 + 0.2e1 * t267 * t20 * t8 * t9 - 0.4e1 * t138 * t139 * t9 * t16 * t13 -
-               0.2e1 * t5 * t638 + 0.2e1 * t126 * t169 + 0.8e1 * t376 * t643 + 0.4e1 * t335 * t27 * t145 +
-               0.16e2 * t235 * t236 * t535 * t29 + 0.6e1 * t150 * t653 - 0.4e1 * t426 * t269 +
-               0.4e1 * t658 * t8 * t660;
-        t670 = t274 * t411;
-        t673 = t118 * t49;
-        t694 = t155 * t45;
-        t713 = n * t29 * t30;
-        t717 = t20 * t87;
-        t723 = t512 * t57;
-        t728 = -0.2e1 * t443 * t175 - 0.8e1 * t670 * t129 + 0.2e1 * t426 * t673 -
-               0.16e2 * t207 * t88 * t42 * t47 * ZA * t44 + 0.4e1 * t254 * t255 * t21 + t249 * t595 +
-               0.8e1 * t25 * t29 * t8 * t660 + 0.2e1 * t268 * t461 + 0.8e1 * t189 * t181 - 0.8e1 * t694 * t513 +
-               0.2e1 * t198 * t553 - 0.12e2 * t606 * t139 * t660 - 0.2e1 * t359 * t549 +
-               0.4e1 * t138 * t139 * t590 * t16 + 0.8e1 * t93 * t29 * t94 * t89 - 0.2e1 * t150 * t713 +
-               0.2e1 * t222 * t3 * t717 * t27 + 0.8e1 * t670 * t323 + 0.8e1 * t694 * t723 - 0.2e1 * t62 * t653;
-        t734 = t43 * t89;
-        t735 = t563 * t427;
-        t740 = t75 * t94;
-        t744 = ZB * xc;
-        t750 = t563 * t57;
-        t754 = t218 * t103;
-        t771 = t127 * t199;
-        t776 = t89 * t174;
-        t791 = -0.4e1 * t207 * t717 * t77 * xc * ZA + 0.4e1 * t443 * t27 * t57 + t192 * t40 - 0.8e1 * t55 * t643 -
-               0.16e2 * t209 * t89 * t771 - 0.8e1 * t275 * t323 + 0.2e1 * t359 * t776 + 0.16e2 * t304 * t89 * t199 +
-               0.4e1 * t278 * t320 + 0.2e1 * t207 * t172 * t389 * t79 - 0.8e1 * t390 * t391 * t97;
-        t794 = t483 * t158;
-        t801 = t2 * 0.3141592654e1;
-        t818 = t215 * t411;
-        t827 = t96 * t174;
-        t837 = t37 * t12 * t110;
-        t845 = 0.16e2 * t794 * t485 + 0.8e1 * t159 * t564 - 0.8e1 * t455 * t379 - 0.2e1 * t801 * t3 * t20 * t10 -
-               0.4e1 * t132 * t22 - 0.8e1 * t734 * t564 - 0.8e1 * t187 * t44 * t658 * t10 - 0.8e1 * t412 * t564 +
-               0.4e1 * t132 * t181 - 0.8e1 * t818 * t129 + 0.2e1 * t46 * t48 * t427 - 0.4e1 * t75 * t29 * t316 -
-               0.2e1 * t359 * t827 - t290 * t595 + 0.16e2 * t217 * t754 - t424 * t542 - 0.8e1 * t734 * t750 -
-               t192 * t837 - 0.4e1 * t254 * t255 * t133 + 0.8e1 * t304 * t96 * t199;
-        t864 = t544 * t18;
-        t867 = t3 * t18;
-        t884 = t27 * t256;
-        t891 = t187 * t744;
-        t894 = t563 * t49;
-        t900 = -0.2e1 * t263 * t428 + 0.2e1 * t228 * t428 - 0.6e1 * t223 * t224 * t103 - t192 * t404 +
-               0.2e1 * t268 * t428 - 0.2e1 * t335 * t884 - t424 * t296 + 0.2e1 * t93 * t20 * t316 -
-               0.32e2 * t891 * t616 + 0.2e1 * t562 * t894 - 0.2e1 * t801 * t867 * t10;
-        t904 = t27 * t111;
-        t907 = t118 * t128;
-        t915 = t89 * t145;
-        t947 = t139 * t140 * t29;
-        t952 = -0.2e1 * t173 * t904 + 0.4e1 * t426 * t907 + 0.12e2 * t253 * t10 * t1 * 0.3141592654e1 * t244 +
-               0.8e1 * t95 * t915 - t36 * t355 - 0.16e2 * t794 * t771 - 0.8e1 * t511 * t723 + 0.16e2 * t734 * t162 +
-               t36 * t837 + 0.2e1 * t298 * t299 * t57 - 0.2e1 * t28 * t638 - 0.2e1 * t62 * t545 +
-               0.2e1 * t310 * t406 + 0.12e2 * t138 * t616 + 0.4e1 * t223 * t750 + t424 * t497 +
-               0.2e1 * t734 * t894 + 0.2e1 * t132 * xc * t18 * t10 - 0.16e2 * t70 * t947 + 0.32e2 * t891 * t947;
-        t969 = t67 * t157 * t156 * t3;
-        t974 = t27 * t133;
-        t1001 = -0.8e1 * t159 * t750 - 0.16e2 * t412 * t162 - t290 * t129 + 0.8e1 * t310 * t323 -
-                0.4e1 * t319 * t342 + t75 * t272 + t192 * t402 - 0.8e1 * t359 * t89 * t128 -
-                0.10e2 * t61 * t350 * t502 + 0.8e1 * t818 * t323 - 0.4e1 * t108 * t907;
-        t1042 = t89 * t97;
-        t1055 = -0.2e1 * t168 * t595 + 0.16e2 * t484 * t771 + 0.4e1 * t11 * t125 * t129 - 0.2e1 * t173 * t444 +
-                0.2e1 * ZB * n * t54 * t37 * ZA * t79 - t424 * t475 + 0.2e1 * t562 * t735 - 0.2e1 * t548 * t776 +
-                t424 * t204 + 0.2e1 * t25 * t20 * t326 + 0.8e1 * t383 * t389 * t133 + t75 * t38 * t367 +
-                0.2e1 * t62 * t469 + 0.2e1 * t197 * t137 * t128 - 0.2e1 * t102 * t884 - 0.2e1 * t5 * t379 -
-                0.8e1 * t740 * t1042 - 0.16e2 * t159 * t414 - 0.2e1 * ZB * t35 * t37 * t413 +
-                0.2e1 * t553 * ZB * t78 * t12;
-        t1096 = 0.2e1 * t443 * t904 - 0.2e1 * t268 * t329 - 0.2e1 * t443 * t601 + 0.2e1 * t102 * t974 -
-                0.2e1 * t263 * t673 + t424 * t165 + 0.2e1 * t62 * t713 + t424 * t308 - t424 * t313 +
-                0.8e1 * t347 * t22 - t424 * t598;
-        t1103 = t42 * t1 * t157;
-        t1104 = t1103 * t25;
-        t1108 = t3 * t19;
-        t1112 = n * t47;
-        t1113 = t9 * t9;
-        t1118 = t42 * t157;
-        t1119 = t1118 * t9;
-        t1120 = t25 * xc;
-        t1121 = t13 * t110;
-        t1122 = t1120 * t1121;
-        t1125 = t47 * t47;
-        t1126 = t67 * t1125;
-        t1127 = t1113 * ZA;
-        t1128 = t1126 * t1127;
-        t1129 = t19 * t13;
-        t1130 = t744 * t1129;
-        t1133 = t154 * t1125;
-        t1134 = t1133 * t9;
-        t1135 = t45 * t1129;
-        t1138 = t154 * t47;
-        t1139 = t25 * t30;
-        t1142 = t1126 * t1113;
-        t1145 = t125 * t1129;
-        t1148 = t1103 * xc;
-        t1149 = t3 * t13;
-        t1150 = t1149 * t17;
-        t1153 = t25 * t78;
-        t1156 = -0.8e1 * t1104 * t243 * t17 + 0.4e1 * t187 * t1108 * t9 - 0.2e1 * t1112 * t3 * t1113 * t30 +
-                0.16e2 * t1119 * t1122 + 0.64e2 * t1128 * t1130 + 0.64e2 * t1134 * t1135 - 0.2e1 * t1138 * t1139 +
-                0.32e2 * t1142 * t1135 - 0.32e2 * t1142 * t1145 + 0.8e1 * t1148 * t1150 - 0.2e1 * t1138 * t1153;
-        t1157 = t25 * t13;
-        t1158 = t1157 * t17;
-        t1161 = t13 * t17;
-        t1162 = t1120 * t1161;
-        t1165 = t3 * t78;
-        t1170 = t42 * t67 * t1125;
-        t1172 = t1108 * t13;
-        t1175 = t1 * t157;
-        t1176 = t1175 * t1113;
-        t1182 = t1120 * t1129;
-        t1189 = t110 * t9 * xc;
-        t1192 = t1149 * t110;
-        t1201 = 0.8e1 * t1103 * t1158 - 0.16e2 * t1119 * t1162 - 0.2e1 * t1112 * t1165 * t1113 +
-                0.32e2 * t1170 * t44 * t1172 - 0.8e1 * t1176 * t1162 + 0.8e1 * t1104 * t243 * t110 -
-                0.64e2 * t1134 * t1182 - 0.64e2 * t1134 * t1145 + 0.16e2 * t1118 * t3 * t1189 +
-                0.16e2 * t1119 * t1192 - 0.4e1 * t187 * t1165 * t9 - 0.4e1 * t187 * t1139 * t9;
-        t1209 = t17 * t30;
-        t1210 = t125 * t1209;
-        t1213 = t1138 * ZA;
-        t1214 = ZB * t30;
-        t1218 = t1157 * t110;
-        t1226 = t3 * t30;
-        t1237 = t1170 * t25;
-        t1242 = 0.4e1 * t1112 * ZA * t119 * t1113 - 0.16e2 * t1119 * t1150 - 0.8e1 * t1176 * t1210 +
-                0.4e1 * t1213 * t1214 * t19 - 0.16e2 * t1119 * t1218 - 0.32e2 * t1142 * t1182 -
-                0.8e1 * t1103 * t1120 * t110 - 0.4e1 * t187 * t1226 * t9 + 0.8e1 * t1103 * t1192 +
-                0.4e1 * t1112 * ZB * t1113 * t30 * ZA - 0.32e2 * t1237 * xc * t19 * t13;
-        t1251 = t125 * t1121;
-        t1260 = t1120 * t1209;
-        t1263 = t1139 * t19;
-        t1282 = 0.8e1 * t1103 * t110 * t3 * xc + 0.8e1 * t1104 * xc * t17 * t30 - 0.8e1 * t1176 * t1251 +
-                0.16e2 * t1119 * t1158 + 0.4e1 * t1112 * t78 * t1127 * ZB + 0.16e2 * t1119 * t1260 +
-                0.2e1 * t1138 * t1263 - 0.32e2 * t1170 * xc * t1172 - 0.16e2 * t1213 * t119 * t13 +
-                0.4e1 * t1138 * t1214 * ZA + 0.32e2 * t1237 * t44 * t19 * t13 - 0.16e2 * t1118 * t25 * t1189;
-        t1287 = t188 * t1129;
-        t1292 = t25 * t19;
-        t1296 = t187 * t9;
-        t1297 = t1226 * t19;
-        t1311 = t1112 * t1113;
-        t1317 = -0.8e1 * t1176 * t1150 + 0.32e2 * t1142 * t1287 - 0.8e1 * t1103 * t1150 +
-                0.2e1 * t1112 * t1292 * t1113 + 0.4e1 * t1296 * t1297 + 0.8e1 * t1176 * t1192 +
-                0.4e1 * t1296 * t1263 + 0.8e1 * t1176 * t1158 - 0.8e1 * t1175 * t25 * t1113 * xc * t110 +
-                0.2e1 * t1311 * t1297 + 0.2e1 * t1112 * t1108 * t1113;
-        t1320 = t253 * t1129;
-        t1328 = t253 * t30 * t19;
-        t1333 = t125 * t1161;
-        t1343 = ZB * t44 * t1129;
-        t1350 = -0.8e1 * t1176 * t1218 - 0.16e2 * t1311 * t1320 + 0.8e1 * t1176 * t1260 - 0.16e2 * t1119 * t1210 +
-                0.4e1 * t1311 * t1328 + 0.2e1 * t1311 * t1263 + 0.8e1 * t1176 * t1333 +
-                0.8e1 * t187 * ZB * t417 * t9 - 0.2e1 * t1138 * t1165 - 0.64e2 * t1128 * t1343 +
-                0.64e2 * t1134 * t1287 + 0.2e1 * t1138 * t1108;
-        t1369 = t1133 * t9 * ZA;
-        t1378 = t187 * ZA;
-        t1383 = t1170 * ZA;
-        t1388 = 0.2e1 * t1138 * t1297 - 0.8e1 * t1148 * t1192 + 0.2e1 * t1138 * t1292 - 0.16e2 * t1119 * t1251 +
-                0.8e1 * t1175 * xc * t110 * t1113 * t3 - 0.2e1 * t1112 * t1153 * t1113 + 0.128e3 * t1369 * t1130 +
-                0.16e2 * t1119 * t1333 + 0.4e1 * t1138 * t78 * ZA * ZB + 0.8e1 * t1378 * t78 * t9 * ZB -
-                0.64e2 * t1383 * t1343 + 0.64e2 * t1383 * t1130;
-        t1420 = 0.4e1 * t1138 * t119 * ZA - 0.128e3 * t1369 * t1343 - 0.4e1 * t187 * t1153 * t9 -
-                0.2e1 * t1138 * t1226 + 0.8e1 * t1296 * t1328 - 0.2e1 * t1112 * t1139 * t1113 -
-                0.8e1 * t1148 * t3 * t17 * t30 - 0.32e2 * t1296 * t1320 + 0.8e1 * t1176 * t1122 +
-                0.4e1 * t187 * t1292 * t9 + 0.8e1 * t1378 * t119 * t9 - 0.8e1 * t1103 * t1218;
-
-        _C4B = (-t424 * t508 + 0.8e1 * t412 * t750 - 0.2e1 * t232 * t595 - 0.4e1 * t126 * t323 + t1096 -
-                t76 * t204 + t728 + 0.2e1 * t548 * t827 + 0.2e1 * t150 * t469 + t398 + 0.8e1 * t189 * t146 + t260 -
-                0.2e1 * t351 * t184 - 0.2e1 * t268 * t673 - 0.4e1 * t319 * t279 + t464 - 0.2e1 * t108 * t461 +
-                0.16e2 * t740 * t369 + 0.16e2 * t274 * t216 * t754 - 0.16e2 * t70 * t139 * t591 +
-                0.2e1 * t55 * t56 * t128 - 0.2e1 * t359 * t89 * t111 + 0.2e1 * t734 * t563 * t111 +
-                0.6e1 * t223 * t224 * t97 + 0.8e1 * t383 * t389 * t103 + 0.4e1 * t606 * ZA * t326 -
-                0.2e1 * t93 * t18 * t316 - 0.4e1 * t443 * t27 * t128 + 0.8e1 * t197 * t27 * t199 +
-                0.8e1 * t108 * t109 * t128 - t249 * t604 + 0.16e2 * t70 * t616 - 0.8e1 * t969 * t323 + t845 -
-                t424 * t579 + 0.16e2 * t159 * t162 + t290 * t406 - 0.6e1 * t150 * t864 + t192 * t116 +
-                0.2e1 * t867 * t326 - 0.4e1 * t658 * t326 - 0.2e1 * t351 * t502 - t76 * t165 + t900 +
-                0.8e1 * t168 * t323 + t791 + 0.8e1 * t740 * t915 - 0.4e1 * t562 * t750 - 0.4e1 * t278 * t342 +
-                0.4e1 * t319 * t431 + 0.2e1 * t173 * t175 + t424 * t528 + 0.8e1 * t969 * t129 -
-                0.8e1 * t347 * t181 + t332 + t530 - 0.2e1 * t108 * t329 - 0.2e1 * t207 * t38 * t37 * t1 * ZA +
-                t1001 + 0.4e1 * t408 * t379 + t76 * t448 + 0.2e1 * t102 * t184 + 0.2e1 * t426 * t329 +
-                0.16e2 * t740 * t98 - t282 * t127 - 0.16e2 * t1 * t44 * t69 * t552 * t116 + 0.2e1 * t168 * t169 +
-                0.2e1 * t28 * t134 - t290 * t604 - 0.16e2 * t484 * t485 - 0.8e1 * t740 * t480 +
-                0.2e1 * t173 * t601 - 0.2e1 * t335 * t336 + t600 + 0.2e1 * t62 * t864 + t952 + 0.8e1 * t347 * t134 -
-                t192 * t355 + t192 * t194 + 0.2e1 * t228 * t461 + t663 + 0.4e1 * t383 * t27 * t417 * t16 +
-                0.4e1 * t138 * t20 * ZA * t10 - 0.4e1 * t20 * ZB * ZA * t326 + 0.4e1 * t196 * t88 * t77 * t744 -
-                0.16e2 * t67 * xc * t179 * t181 - 0.8e1 * t95 * t480 - t249 * t488 - t76 * t475 + t1055 -
-                0.4e1 * t408 * t22 - 0.10e2 * t28 * t379 + 0.2e1 * t335 * t974 + t153 - 0.8e1 * t95 * t1042 -
-                0.2e1 * t734 * t735) / (t1156 + t1201 + t1242 + t1282 + t1317 + t1350 + t1388 + t1420);
-        /****************************************************************************************/
-        /****************************************************************************************/
-
-        if (x > xc)
-          {
-            _C1 = _C1B;
-            _C2 = _C2B;
-            _C3 = _C3B;
-            _C4 = _C4B;
-            Z = ZB;
-          }
-        else
-          {
-            _C1 = _C1A;
-            _C2 = _C2A;
-            _C3 = _C3A;
-            _C4 = _C4A;
-            Z = ZA;
-          }
-        /****************************************************************************************/
-        /****************************************************************************************/
-        t1 = n * n;
-        t2 = t1 * t1;
-        t3 = t2 * n;
-        t4 = x * t3;
-        t5 = 0.3141592654e1 * 0.3141592654e1;
-        t6 = t5 * 0.3141592654e1;
-        t11 = _C3 * t6;
-        t12 = x * n;
-        t13 = nx * nx;
-        t14 = t13 * t13;
-        t15 = t12 * t14;
-        t19 = exp(t12 * 0.3141592654e1);
-        t20 = t19 * t19;
-        t21 = t4 * t20;
-        t24 = _C1 * t5;
-        t25 = Z * t20;
-        t29 = _C1 * t6;
-        t30 = t29 * Z;
-        t31 = t1 * n;
-        t32 = x * t31;
-        t33 = t32 * t13;
-        t36 = t11 * x;
-        t41 = n * t20;
-        t45 = t6 * _C4;
-        t49 = t20 * t1;
-        t51 = _C2 * Z;
-        t55 = -0.2e1 * t4 * t6 * _C2 * Z - 0.2e1 * t11 * t15 - 0.2e1 * t11 * t21 + 0.2e1 * t24 * t25 * t14 - t13 +
-              0.4e1 * t30 * t33 - 0.4e1 * t36 * t31 * t20 * t13 - 0.2e1 * t36 * t41 * t14 - 0.2e1 * t4 * t45 * t20 -
-              t49 - 0.2e1 * t4 * t6 * t51 * t20;
-        t58 = t32 * t6;
-        t59 = _C4 * t20;
-        t63 = t20 * t13;
-        t67 = t12 * t6;
-        t68 = t20 * t14;
-        t87 = t49 * t13;
-        t90 = -0.4e1 * t11 * t33 - 0.4e1 * t58 * t59 * t13 - 0.4e1 * t58 * t51 * t63 - 0.2e1 * t67 * t51 * t68 +
-              0.4e1 * t32 * t45 * t13 - 0.2e1 * t67 * t59 * t14 - 0.2e1 * t30 * t21 + t1 + 0.2e1 * t24 * t25 * t2 +
-              0.2e1 * t12 * t45 * t14 + 0.4e1 * t24 * Z * t87;
-        t106 = _C3 * t5;
-        t120 = -0.4e1 * t30 * t32 * t63 + t63 + 0.4e1 * t24 * Z * t1 * t13 + 0.2e1 * t29 * Z * x * t3 -
-               0.4e1 * t58 * t51 * t13 - 0.2e1 * t106 * t2 + t32 * 0.3141592654e1 - 0.2e1 * t106 * t14 -
-               0.2e1 * t30 * t12 * t68 - 0.2e1 * t67 * t51 * t14 + 0.4e1 * t106 * t87;
-        t129 = sin(nx * 0.3141592654e1 * x);
-        t155 = 0.2e1 * t30 * t15 + x * 0.3141592654e1 * t41 * t13 - 0.4e1 * t19 * nx * t129 * n +
-               t32 * 0.3141592654e1 * t20 + 0.2e1 * t106 * t68 + 0.2e1 * t106 * t20 * t2 - 0.4e1 * t106 * t1 * t13 -
-               0.2e1 * t11 * t4 + 0.2e1 * t4 * t45 + 0.2e1 * t24 * Z * t2 + 0.2e1 * t24 * Z * t14 +
-               t12 * 0.3141592654e1 * t13;
-        t158 = t5 * Z;
-
-        u1 = (t55 + t90 + t120 + t155) /
-             (0.4e1 * t158 * t19 * t2 + 0.8e1 * t158 * t19 * t1 * t13 + 0.4e1 * t158 * t19 * t14);
-        /****************************************************************************************/
-        /****************************************************************************************/
-        t1 = n * n;
-        t2 = t1 * n;
-        t3 = x * t2;
-        t4 = 0.3141592654e1 * 0.3141592654e1;
-        t5 = t4 * 0.3141592654e1;
-        t6 = t3 * t5;
-        t7 = _C2 * Z;
-        t8 = nx * nx;
-        t12 = t1 * t1;
-        t13 = t12 * n;
-        t14 = x * t13;
-        t15 = t5 * _C4;
-        t16 = x * n;
-        t18 = exp(t16 * 0.3141592654e1);
-        t19 = t18 * t18;
-        t23 = t16 * t5;
-        t24 = t8 * t8;
-        t28 = _C3 * t5;
-        t29 = t14 * t19;
-        t32 = _C1 * t5;
-        t33 = t32 * Z;
-        t34 = t16 * t24;
-        t37 = _C4 * t19;
-        t45 = _C2 * t4;
-        t53 = t19 * t8;
-        t58 = _C4 * t4;
-        t60 = t1 * t19 * t8;
-        t63 = t19 * t24;
-        t67 = t3 * t8;
-        t73 = n * t19;
-        t86 = t28 * x;
-        t91 = 0.4e1 * t58 * t60 + 0.2e1 * t33 * t16 * t63 + 0.4e1 * t33 * t67 + 0.2e1 * t33 * t29 -
-              x * 0.3141592654e1 * t73 * t8 - 0.2e1 * t53 + 0.2e1 * t32 * Z * x * t13 - 0.2e1 * t58 * t12 -
-              0.2e1 * t58 * t24 + t3 * 0.3141592654e1 + 0.4e1 * t86 * t2 * t19 * t8;
-        t94 = Z * t12;
-        t121 = -0.2e1 * t8 + 0.2e1 * t45 * t94 * t19 + 0.2e1 * t14 * t5 * t7 * t19 + 0.4e1 * t6 * t7 * t53 +
-               0.2e1 * t23 * t7 * t63 - 0.4e1 * t28 * t67 + 0.2e1 * t45 * t94 + 0.2e1 * t58 * t12 * t19 +
-               t16 * 0.3141592654e1 * t8 + 0.2e1 * t14 * t15 - 0.2e1 * t28 * t14;
-        t146 = cos(nx * 0.3141592654e1 * x);
-        t156 = -t3 * 0.3141592654e1 * t19 + 0.2e1 * t58 * t63 - 0.4e1 * t58 * t1 * t8 + 0.4e1 * t45 * Z * t1 * t8 -
-               0.2e1 * t28 * t34 + 0.2e1 * t86 * t73 * t24 + 0.4e1 * t3 * t15 * t8 + 0.4e1 * t45 * Z * t60 +
-               0.4e1 * t18 * t146 * t8 + 0.2e1 * t45 * Z * t24 + 0.2e1 * t16 * t15 * t24;
-        t159 = t4 * Z;
-
-        u2 = (-0.4e1 * t6 * t7 * t8 + 0.2e1 * t14 * t15 * t19 - 0.2e1 * t23 * t7 * t24 + 0.2e1 * t28 * t29 +
-              0.2e1 * t33 * t34 + 0.4e1 * t6 * t37 * t8 - 0.2e1 * t14 * t5 * _C2 * Z + 0.2e1 * t45 * Z * t19 * t24 +
-              0.2e1 * t23 * t37 * t24 + 0.4e1 * t33 * t3 * t53 + t91 + t121 + t156) /
-             (0.4e1 * t159 * t18 * t12 + 0.8e1 * t159 * t18 * t1 * t8 + 0.4e1 * t159 * t18 * t24);
-        /****************************************************************************************/
-        /****************************************************************************************/
-        t1 = 0.3141592654e1 * 0.3141592654e1;
-        t2 = t1 * 0.3141592654e1;
-        t3 = _C1 * t2;
-        t4 = t3 * Z;
-        t5 = n * n;
-        t6 = t5 * t5;
-        t7 = t6 * n;
-        t8 = x * t7;
-        t9 = x * n;
-        t11 = exp(t9 * 0.3141592654e1);
-        t12 = t11 * t11;
-        t13 = t8 * t12;
-        t16 = t5 * n;
-        t17 = x * t16;
-        t18 = t17 * t2;
-        t19 = _C4 * t12;
-        t20 = nx * nx;
-        t24 = t2 * _C4;
-        t28 = _C3 * t2;
-        t29 = t28 * x;
-        t30 = t12 * n;
-        t31 = t20 * t20;
-        t40 = _C2 * Z;
-        t44 = t9 * t2;
-        t48 = t12 * t20;
-        t52 = t17 * t20;
-        t57 = -0.2e1 * t4 * t13 - 0.4e1 * t18 * t19 * t20 - 0.2e1 * t8 * t24 * t12 - 0.2e1 * t29 * t30 * t31 +
-              0.2e1 * t8 * t2 * _C2 * Z - 0.2e1 * t8 * t2 * t40 * t12 - 0.2e1 * t44 * t19 * t31 -
-              0.4e1 * t18 * t40 * t48 + t20 + 0.4e1 * t28 * t52 + t17 * 0.3141592654e1 * t12;
-        t58 = t9 * t31;
-        t61 = _C3 * t1;
-        t62 = t12 * t31;
-        t73 = t5 * t20;
-        t78 = _C1 * t1;
-        t90 = Z * t12;
-        t94 = 0.2e1 * t28 * t58 + 0.2e1 * t61 * t62 + 0.2e1 * t61 * t12 * t6 - 0.4e1 * t4 * t17 * t48 +
-              0.2e1 * t28 * t8 + 0.4e1 * t61 * t73 - 0.2e1 * t8 * t24 - 0.2e1 * t78 * Z * t6 -
-              0.2e1 * t44 * t40 * t62 - 0.2e1 * t78 * Z * t31 - t9 * 0.3141592654e1 * t20 + 0.2e1 * t78 * t90 * t6;
-        t101 = cos(nx * 0.3141592654e1 * x);
-        t102 = t11 * t101;
-        t109 = t12 * t5;
-        t110 = t109 * t20;
-        t128 = 0.2e1 * t61 * t6 - t17 * 0.3141592654e1 + 0.2e1 * t102 * t5 - 0.4e1 * t17 * t24 * t20 +
-               0.4e1 * t78 * Z * t110 - 0.2e1 * t9 * t24 * t31 - 0.4e1 * t4 * t52 - 0.2e1 * t4 * t9 * t62 +
-               x * 0.3141592654e1 * t30 * t20 - t5 - 0.4e1 * t78 * Z * t5 * t20;
-        t156 = 0.2e1 * t78 * t90 * t31 - 0.2e1 * t3 * Z * x * t7 + t48 + 0.4e1 * t61 * t110 +
-               0.4e1 * t18 * t40 * t20 - 0.2e1 * t102 * t20 + 0.2e1 * t61 * t31 + 0.2e1 * t44 * t40 * t31 - t109 -
-               0.2e1 * t4 * t58 - 0.2e1 * t28 * t13 - 0.4e1 * t29 * t16 * t12 * t20;
-        t159 = t1 * t11;
-
-        u3 = (t57 + t94 + t128 + t156) / (0.4e1 * t159 * t6 + 0.8e1 * t159 * t73 + 0.4e1 * t159 * t31);
-        /****************************************************************************************/
-        /****************************************************************************************/
-        t1 = _C2 * Z;
-        t2 = 0.3141592654e1 * 0.3141592654e1;
-        t3 = t2 * 0.3141592654e1;
-        t4 = n * n;
-        t5 = t4 * t4;
-        t6 = t5 * t4;
-        t8 = t3 * t6 * x;
-        t11 = x * t4;
-        t12 = t11 * t3;
-        t15 = exp(x * n * 0.3141592654e1);
-        t16 = t15 * t15;
-        t17 = _C3 * t16;
-        t18 = nx * nx;
-        t19 = t18 * t18;
-        t23 = t5 * n;
-        t24 = t2 * t23;
-        t28 = t1 * t3;
-        t29 = t6 * x;
-        t30 = t29 * t16;
-        t33 = _C4 * t3;
-        t34 = t5 * x;
-        t35 = t34 * t18;
-        t41 = sin(nx * 0.3141592654e1 * x);
-        t47 = t11 * t19;
-        t54 = t3 * _C3;
-        t57 = 0.2e1 * t1 * t8 + 0.2e1 * t12 * t17 * t19 + 0.2e1 * t1 * t24 * t16 + 0.2e1 * t28 * t30 -
-              0.4e1 * t33 * t35 + 0.2e1 * t15 * nx * t41 * t4 + 0.4e1 * t28 * t35 - 0.2e1 * t33 * t47 -
-              0.2e1 * t1 * t24 - 0.2e1 * t33 * t29 + 0.2e1 * t29 * t54;
-        t58 = 0.3141592654e1 * t16;
-        t60 = t2 * _C4;
-        t69 = t4 * n;
-        t73 = t1 * t2;
-        t75 = t69 * t16 * t18;
-        t79 = x * t16;
-        t83 = n * t16;
-        t84 = t83 * t19;
-        t95 = -t34 * t58 + 0.2e1 * t60 * t23 * t16 + 0.2e1 * t60 * n * t19 - t11 * 0.3141592654e1 * t18 +
-              0.4e1 * t60 * t69 * t18 + 0.4e1 * t73 * t75 + 0.4e1 * t33 * t5 * t79 * t18 + 0.2e1 * t73 * t84 +
-              0.2e1 * t60 * t84 + 0.2e1 * t33 * t4 * t79 * t19 + 0.4e1 * t60 * t75;
-        t97 = t34 * t3;
-        t101 = Z * _C1;
-        t102 = t16 * t19;
-        t106 = t16 * t18;
-        t127 = t2 * t69;
-        t131 = t2 * n;
-        t135 = 0.4e1 * t97 * t17 * t18 + 0.2e1 * t12 * t101 * t102 + 0.4e1 * t28 * t34 * t106 +
-               0.2e1 * t28 * t11 * t102 - 0.2e1 * t29 * t3 * Z * _C1 - 0.4e1 * t97 * t101 * t18 -
-               0.2e1 * t12 * t101 * t19 + 0.2e1 * t60 * t23 - 0.2e1 * t83 * t18 - 0.4e1 * t1 * t127 * t18 -
-               0.2e1 * t1 * t131 * t19;
-        t164 = 0.2e1 * t28 * t47 + 0.2e1 * t11 * t54 * t19 + 0.2e1 * t8 * t101 * t16 + 0.2e1 * t33 * t30 -
-               t11 * t58 * t18 + 0.2e1 * t29 * t54 * t16 + 0.4e1 * t34 * t54 * t18 + 0.4e1 * t97 * t101 * t106 -
-               0.2e1 * t15 * t18 * nx * t41 - t34 * 0.3141592654e1 + 0.2e1 * n * t18;
-
-        u4 = (t57 + t95 + t135 + t164) / (0.4e1 * t24 * t15 + 0.8e1 * t127 * t15 * t18 + 0.4e1 * t131 * t15 * t19);
-
-
-        /****************************************************************************************/
-        /****************************************************************************************/
-
-
-        u5 = (double) (-2 * Z * n * PI * u2 - u3 * 2 * n * PI) * cos(n * PI * z); /* pressure */
-
-        u6 = (double) (u3 * 2 * n * PI + 4 * Z * n * PI * u2) * cos(n * PI * z); /* zz stress */
-        sum5 += u5;
-        sum6 += u6;
-
-        u1 *= cos(n * PI * z); /* x velocity */
-        sum1 += u1;
-        u2 *= sin(n * PI * z); /* z velocity */
-        sum2 += u2;
-        u3 *= 2 * n * PI * cos(n * PI * z); /* xx stress */
-        sum3 += u3;
-        u4 *= 2 * n * PI * sin(n * PI * z); /* zx stress */
-        sum4 += u4;
-
-        /*printf("%0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f\n",x,z,sum1,sum2,sum3,sum4,sum5,sum6);*/
-
-        /* Output */
-        if (vel != nullptr)
-          {
-            vel[0] = sum1;
-            vel[1] = sum2;
-          }
-        if (presssure != nullptr)
-          {
-            (*presssure) = sum5;
-          }
-        if (total_stress != nullptr)
-          {
-            total_stress[0] = sum3;
-            total_stress[1] = sum6;
-            total_stress[2] = sum4;
-          }
-        if (strain_rate != nullptr)
-          {
-            if (x > xc)
-              {
-                Z = ZB;
-              }
-            else
-              {
-                Z = ZA;
-              }
-            strain_rate[0] = (sum3 + sum5) / (2.0 * Z);
-            strain_rate[1] = (sum6 + sum5) / (2.0 * Z);
-            strain_rate[2] = (sum4) / (2.0 * Z);
-          }
-        /* Value checks, could be cleaned up if needed. Julian Giordani 2-Oct-2006*/
-        if (fabs(sum5 - (-0.5 * (sum6 + sum3))) > 1e-5)
-          {
-            assert(0);
-          }
-      }
-
-
-
-      /**
-       * The exact solution for the SolCx benchmark, given the value of the
-       * jump in viscosity $\eta_B$.
-       */
-      template <int dim>
-      class FunctionSolCx : public Function<dim>
-      {
-        public:
-          FunctionSolCx(const double eta_B,
-                        const double background_density,
-                        const unsigned int n_compositional_fields)
-            :
-            Function<dim>(dim+2+n_compositional_fields),
-            eta_B_(eta_B),
-            background_density(background_density),
-            n_compositional_fields(n_compositional_fields) {}
-
-
-          void vector_value(const Point<dim> &p,
-                            Vector<double> &values) const override
-          {
-            AssertDimension(values.size(), 4 + n_compositional_fields);
-
-            double pos[2] = {p(0), p(1)};
-            double total_stress[3], strain_rate[3];
-            double eta_A = 1.0;
-            double eta_B = eta_B_;
-
-            // call the analytic function for the solution with a zero
-            // background density
-            AnalyticSolutions::_Velic_solCx
-            (pos,
-             eta_A, eta_B,
-             0.5, 1,
-             &values[0], &values[2], total_stress, strain_rate);
-
-            // then add the background pressure to the value we just got
-            values[2] += (0.5 - p[1]) * background_density;
-          }
-
-        private:
-          double eta_B_, background_density;
-          unsigned int n_compositional_fields;
-      };
-    }
-
-
-
-    /**
-     * A material model that describes the <i>SolCx</i> benchmark of the paper
-     * cited in the documentation of the DuretzEtAl namespace.
-     *
-     * @note The SolCx benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @note The analytic solution of this benchmark is implemented in the
-     * "SolCx error" postprocessor in aspect::Postprocessor::DuretzEtAl::SolCx
-     * class and can be used to assess the accuracy of the computed solution.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class SolCxMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-
-              const Point<dim> &pos = in.position[i];
-              out.viscosities[i] = (pos[0] < 0.5 ? 1 : eta_B);
-              out.densities[i] =  background_density-std::sin(numbers::PI*pos[1])*std::cos(numbers::PI*pos[0]);
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-
-            }
-        }
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override
-        {
-          return false;
-        }
-        /**
-         * @}
-         */
-
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm)
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("SolCx");
-            {
-              prm.declare_entry ("Viscosity jump", "1e6",
-                                 Patterns::Double (0.),
-                                 "Viscosity in the right half of the domain.");
-              prm.declare_entry ("Background density", "0.",
-                                 Patterns::Double (0.),
-                                 "Density value upon which the variation of this testcase "
-                                 "is overlaid. Since this background density is constant "
-                                 "it does not affect the flow pattern but it adds to the "
-                                 "total pressure since it produces a nonzero adiabatic "
-                                 "pressure if set to a nonzero value.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("SolCx");
-            {
-              eta_B = prm.get_double ("Viscosity jump");
-              background_density = prm.get_double("Background density");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          // Declare dependencies on solution variables
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-
-        /**
-         * Returns the viscosity value on the right half of the domain,
-         * typically 1 or 1e6
-         */
-        double get_eta_B() const
-        {
-          return  eta_B;
-        }
-
-        /**
-         * Returns the background density of this model. See the
-         * corresponding member variable of this class for more information.
-         */
-        double get_background_density() const
-        {
-          return background_density;
-        }
-
-      private:
-        /**
-         * Viscosity value on the right half of the domain, typically 1 or
-         * 1e6
-         */
-        double eta_B;
-
-        /**
-         * A constant background density over which the density variations
-         * are overlaid. This constant density has no effect on the dynamic
-         * pressure and consequently on the flow field, but it contributes
-         * to the total pressure via the adiabatic pressure. We use this
-         * field to support our claim in the first ASPECT paper that the
-         * accuracy of the solutions is guaranteed even if we don't subtract
-         * the adiabatic pressure in our computations.
-         */
-        double background_density;
-    };
-
-
-
-
-    /**
-     * A postprocessor that evaluates the accuracy of the solution.
-     *
-     * The implementation of error evaluators that correspond to the
-     * benchmarks defined in the paper Duretz et al. reference above.
-     */
-    template <int dim>
-    class SolCxPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &/*statistics*/) override
-        {
-
-          AssertThrow(Plugins::plugin_type_matches<const SolCxMaterial<dim>>(this->get_material_model()),
-                      ExcMessage("Postprocessor DuretzEtAl only works with the material model SolCx, SolKz, and Inclusion."));
-
-          const SolCxMaterial<dim> &
-          material_model
-            = Plugins::get_plugin_as_type<const SolCxMaterial<dim>>(this->get_material_model());
-
-          std::unique_ptr<Function<dim>> ref_func
-            = std::make_unique<AnalyticSolutions::FunctionSolCx<dim>>(material_model.get_eta_B(),
-                                                                       material_model.get_background_density(),
-                                                                       this->n_compositional_fields());
-
-          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities + 2);
-
-          Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                              this->get_fe().n_components());
-          ComponentSelectFunction<dim> comp_p(dim,
-                                              this->get_fe().n_components());
-
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_u,
-                                             quadrature_formula,
-                                             VectorTools::L1_norm,
-                                             &comp_u);
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_p,
-                                             quadrature_formula,
-                                             VectorTools::L1_norm,
-                                             &comp_p);
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_ul2,
-                                             quadrature_formula,
-                                             VectorTools::L2_norm,
-                                             &comp_u);
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_pl2,
-                                             quadrature_formula,
-                                             VectorTools::L2_norm,
-                                             &comp_p);
-
-          const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-          const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-          std::ostringstream os;
-          os << std::scientific << u_l1
-             << ", " << p_l1
-             << ", " << u_l2
-             << ", " << p_l2;
-
-          return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
-        }
-    };
-
-  }
-}
-#endif
diff --git a/benchmarks/solcx/solcx.prm.bak b/benchmarks/solcx/solcx.prm.bak
deleted file mode 100644
index b21e251c484..00000000000
--- a/benchmarks/solcx/solcx.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# A description of the SolCX benchmark for which a known solution
-# is available. See the manual for more information.
-
-set Additional shared libraries            = ./libsolcx.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-
-  subsection SolCx
-    set Viscosity jump = 1e6
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor, visualization
-end
diff --git a/benchmarks/solitary_wave/doc/solitary_wave.prm.bak b/benchmarks/solitary_wave/doc/solitary_wave.prm.bak
deleted file mode 100644
index faf3e731475..00000000000
--- a/benchmarks/solitary_wave/doc/solitary_wave.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Set up the solitary wave benchmark
-# (Barcilon & Richter, 1986; Simpson & Spiegelman, 2011;
-# Keller et al., 2013; Schmeling, 200
-
-set Additional shared libraries            = ./libsolitary_wave.so
-
-# A non-linear solver has to be used for models with melt migration
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-set Nonlinear solver tolerance             = 1e-5
-
-# The end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 6e6
-
-# To model melt migration, there has to be a compositional field with
-# the name 'porosity'.
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-# Enable modeling of melt migration in addition to the advection of
-# solid material.
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-######### Parameters for the porosity field ########################
-
-# We use the initial conditions and material model from the
-# solitary wave plugin and choose a wave with an amplitude of
-# 0.01 and a background porosity of 0.001.
-subsection Initial composition model
-  set Model name = Solitary wave initial condition
-
-  subsection Solitary wave initial condition
-    set Offset = 200
-    set Read solution from file = true
-    set Amplitude = 0.01
-    set Background porosity = 0.001
-  end
-end
-
-subsection Material model
-  set Model name = Solitary Wave
-end
-
-# As material is flowing in, we prescribe the porosity at the
-# upper and lower boundary.
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-# As we know that our solution does not have any steep gradients
-# we can use a low stabilization to avoid too much diffusion.
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.001
-  end
-end
-
-######### Model geometry ##############################################
-
-# Our domain is a pseudo-1D-profile 400 m in height, but only a few elements wide
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 10
-    set Y extent  = 400
-    set Y repetitions = 40
-  end
-end
-
-######### Velocity boundary conditions ################################
-
-# We apply the phase speed of the wave here, so that it always stays in the
-# same place in our model. The phase speed is c = 5.25e-11 m/s, but we have
-# to convert it to m/years using the same conversion that is used internally
-# in ASPECT: year_in_seconds = 60*60*24*365.2425.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-
-  subsection Function
-    set Function expression = 0;-1.65673998e-4
-  end
-end
-
-# Postprocessor for the error calculation
-subsection Postprocess
-  set List of postprocessors = solitary wave statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-10
-  end
-end
diff --git a/benchmarks/solitary_wave/solitary_wave.cc.bak b/benchmarks/solitary_wave/solitary_wave.cc.bak
deleted file mode 100644
index 715f6dd3301..00000000000
--- a/benchmarks/solitary_wave/solitary_wave.cc.bak
+++ /dev/null
@@ -1,1025 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/melt.h>
-#include <aspect/initial_composition/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-/**
- * MPI operator used by MPI_max_and_data
- */
-void myop_func(void *invec,
-               void *inoutvec,
-               int *len,
-               MPI_Datatype *datatype)
-{
-  AssertThrow(*len > 1, dealii::ExcNotImplemented());
-  AssertThrow(*datatype == MPI_DOUBLE, dealii::ExcNotImplemented());
-
-  double *indata = static_cast<double *>(invec);
-  double *inoutdata = static_cast<double *>(inoutvec);
-
-  if (indata[0]>inoutdata[0])
-    {
-      for (int i=0; i<*len; ++i)
-        inoutdata[i] = indata[i];
-    }
-}
-
-
-/**
- * Computes MPI_MAX of @p local_max like Allreduce, but also transmits the
- * @p local_data from the rank with the largest @local_max to every rank
- * (returned in @p global_data).
- */
-void MPI_max_and_data(const double &local_max,
-                      const double &local_data,
-                      double &global_max,
-                      double &global_data)
-{
-  MPI_Op myop;
-  MPI_Op_create(&myop_func, /* commutes? */ 1 ,&myop);
-
-  double local[] = {local_max, local_data};
-  double global[2];
-
-  MPI_Allreduce(local, global, 2, MPI_DOUBLE, myop, MPI_COMM_WORLD);
-  global_max = global[0];
-  global_data = global[1];
-  MPI_Op_free(&myop);
-}
-
-
-namespace aspect
-{
-  /**
-   * This is the "Solitary wave" benchmark defined in the following paper:
-   * @code
-   *  @Article{DMGT11,
-   *    author =       {T. Keller and D. A. May and B. J. P. Kaus},
-   *    title =        {Numerical modelling of magma dynamics coupled
-   *                    to tectonic deformation of lithosphere and crust},
-   *    journal =      {Geophysical Journal International},
-   *    year =         2013,
-   *    volume =       195(3),
-   *    pages =        {1406-1442}
-   * @endcode
-   *
-   * To calculate the initial condition, which is a solitary wave solution of
-   * the magma dynamics equations, we use the equation for the one-dinemsional
-   * case and the non-dimensionalization as it is described in
-   * @code
-   *  @Article{SS11,
-   *    author =       {G. Simpson and M. Spiegelman},
-   *    title =        {Solitary Wave Benchmarks in Magma Dynamics},
-   *    journal =      {Journal of Scientific Computing},
-   *    year =         2011,
-   *    volume =       49(3),
-   *    pages =        {268-290}
-   * @endcode
-   *
-   * Specifically, this means that we scale the porosity with the background
-   * porosity, and the coordinates with the compaction length $\delta_0$, which is
-   * defined as $\sqrt \frac{k(\phi_0) \xi^{*}+4/3 \eta^{*}}{\eta_f}$.  $k(\phi_0)$ is the
-   * permeability at background porosity, $\xi^{*}$ is the compaction viscosity,
-   * $\eta^{*}$ is the shear viscosity of the fluid and $\eta_f$ is the shear viscosity
-   * of the melt.
-   */
-  namespace SolitaryWaveBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-      // vectors to store the porosity field and the corresponding coordinate in
-      const unsigned int max_points = 2e8;
-      std::vector<double> porosity, coordinate;
-
-      /**
-       * @note The solitary wave solution only exists as a function x = func(phi)
-       * and not phi = func(x), which is what we would like to have for describing
-       * the shape of the wave. Thus, we calculate x = func(phi) for a range of phis
-       * between the background porosity and the amplitude of the wave. In a next
-       * step, we interpolate these values to the grid.
-       *
-       * @param phi The characteristic shape of the wave, with phi --> 1
-       * for x --> +- infinity
-       *
-       * @param amplitude The amplitude of the solitary wave, which is always
-       * greater than 1.
-       */
-      double solitary_wave_solution (const double phi, const double amplitude)
-      {
-        AssertThrow(phi > 1.0 && phi <= amplitude,
-                    ExcMessage("The solitary wave solution can only be computed "
-                               "for porosities larger than the background porosity of 1 "
-                               "and smaller than or equal to the amplitude of the wave."));
-        AssertThrow(amplitude > 1,
-                    ExcMessage("Amplitude of the solitary wave must be larger than 1!"));
-        const double A_1   = std::sqrt(amplitude - 1.0);
-        const double A_phi = std::sqrt(amplitude - phi);
-        return std::sqrt(amplitude + 0.5)
-               * (2 * A_phi - 1.0/A_1 * std::log((A_1 - A_phi)/(A_1 + A_phi)));
-      }
-
-
-      /**
-       * This function reads the coordinate and the porosity of the solitary wave
-       * from an input file.
-       *
-       * @param filename Name of the input file.
-       */
-      void read_solitary_wave_solution (const std::string &filename,
-                                        const MPI_Comm comm)
-      {
-        std::string temp;
-        std::stringstream in(Utilities::read_and_distribute_file_content(filename, comm));
-
-        while (!in.eof())
-          {
-            double x, f;
-            in >> x >> f;
-            if (in.eof())
-              break;
-            getline(in, temp);
-
-            coordinate.insert(coordinate.begin(),x);
-            porosity.insert(porosity.begin(),f);
-          }
-      }
-
-
-      /**
-       * This function gets the coordinate as an input parameters and gives
-       * back the porosity of the solitary wave. As this function is only defined
-       * implicitly, we have to interpolate from the coordinates where we have the
-       * porosity to our mesh.
-       *
-       * @param amplitude The amplitude of the solitary wave, which is always
-       * greater than 1.
-       * @param offset The offset of the center of the solitary wave from the
-       * boundary of the domain.
-       */
-      void compute_porosity (const double amplitude,
-                             const double background_porosity,
-                             const double /*offset*/,
-                             const double compaction_length,
-                             const bool read_solution,
-                             const std::string file_name,
-                             const MPI_Comm comm)
-      {
-        // non-dimensionalize the amplitude
-        const double non_dim_amplitude = amplitude / background_porosity;
-
-        if (read_solution)
-          read_solitary_wave_solution(file_name, comm);
-        else
-          {
-            porosity.resize(max_points);
-            coordinate.resize(max_points);
-
-            // get the coordinates where we have the solution
-            for (unsigned int i=0; i<max_points; ++i)
-              {
-                porosity[i] = 1.0 + 1e-10*non_dim_amplitude
-                              + double(i)/double(max_points-1) * (non_dim_amplitude * (1.0 - 1e-10) - 1.0);
-                coordinate[i] = solitary_wave_solution(porosity[i], non_dim_amplitude);
-              }
-          }
-
-        for (unsigned int i=0; i<coordinate.size(); ++i)
-          {
-            // re-scale porosity and position
-            porosity[i] *= background_porosity;
-            coordinate[i] *= compaction_length;
-          }
-      }
-
-
-      double interpolate (const double position,
-                          const double offset)
-      {
-        // interpolate from the solution grid to the mesh used in the simulation
-        // solitary wave is a monotonically decreasing function, so the coordinates
-        // should be in descending order
-
-        // we only have the solution of the solitary wave for
-        // coordinates larger than 0 (one half of the wave)
-        const double x = (position > offset
-                          ?
-                          position - offset
-                          :
-                          offset - position);
-
-        if (x > coordinate[0])
-          return porosity[0];
-
-        unsigned int j= coordinate.size()-2;
-        unsigned int i = j/2;
-        while (!(x < coordinate[j] && x >= coordinate[j+1]))
-          {
-            if (x < coordinate[j])
-              j += i;
-            else
-              j -= i;
-            if (i>1)
-              i /= 2;
-          }
-
-        const double distance = (x - coordinate[j+1])
-                                /(coordinate[j] - coordinate[j+1]);
-        return porosity[j+1] + distance * (porosity[j] - porosity[j+1]);
-      }
-
-      /**
-       * The exact solution for the Solitary wave benchmark.
-       */
-      template <int dim>
-      class FunctionSolitaryWave : public Function<dim>
-      {
-        public:
-          FunctionSolitaryWave (const double offset, const double delta, const std::vector<double> &initial_pressure, const double max_z, const unsigned int n_components)
-            :
-            Function<dim>(n_components),
-            offset_(offset),
-            delta_(delta),
-            initial_pressure_(initial_pressure),
-            max_z_(max_z)
-          {}
-
-          void set_delta(const double delta)
-          {
-            delta_ = delta;
-          }
-
-          void vector_value (const Point<dim> &p,
-                             Vector<double>   &values) const override
-          {
-            unsigned int index = static_cast<int>((p[dim-1]-delta_)/max_z_ * (initial_pressure_.size()-1));
-            if (p[dim-1]-delta_ < 0)
-              index = 0;
-            else if (p[dim-1]-delta_ > max_z_)
-              index = initial_pressure_.size()-1;
-            AssertThrow(index < initial_pressure_.size(), ExcMessage("not in range"));
-            const double z_coordinate1 = static_cast<double>(index)/static_cast<double>(initial_pressure_.size()-1) * max_z_;
-            const double z_coordinate2 = static_cast<double>(index+1)/static_cast<double>(initial_pressure_.size()-1) * max_z_;
-            const double interpolated_pressure = (index == initial_pressure_.size()-1)
-                                                 ?
-                                                 initial_pressure_[index]
-                                                 :
-                                                 initial_pressure_[index] + (initial_pressure_[index+1] - initial_pressure_[index])
-                                                 * (p[dim-1]-delta_ - z_coordinate1) / (z_coordinate2 - z_coordinate1);
-
-            values[dim+2+dim+2] = AnalyticSolutions::interpolate(p[dim-1]-delta_,offset_); //porosity
-            values[dim+1] = interpolated_pressure;                                   //compaction pressure
-          }
-
-        private:
-          const double offset_;
-          double delta_;
-          const std::vector<double> initial_pressure_;
-          const double max_z_;
-      };
-    }
-
-
-    /**
-     * An initial conditions model for the solitary waves benchmark.
-     */
-    template <int dim>
-    class SolitaryWaveInitialCondition : public InitialComposition::Interface<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Initialization function. Take references to the material model and
-         * get the compaction length, so that it can be used subsequently to
-         * compute the analytical solution for the shape of the solitary wave.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        double
-        initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        double
-        get_amplitude () const;
-
-        double
-        get_background_porosity () const;
-
-        double
-        get_offset () const;
-
-      private:
-        double amplitude;
-        double background_porosity;
-        double offset;
-        double compaction_length;
-        bool read_solution;
-        std::string file_name;
-    };
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class SolitaryWaveMaterial : public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        bool is_compressible () const override
-        {
-          return false;
-        }
-
-        double reference_darcy_coefficient () const override
-        {
-          // Make sure we keep track of the initial composition manager and
-          // that it continues to live beyond the time when the simulator
-          // class releases its pointer to it.
-          if (initial_composition_manager == nullptr)
-            const_cast<std::shared_ptr<const aspect::InitialComposition::Manager<dim>>&>(initial_composition_manager)
-              = this->get_initial_composition_manager_pointer();
-
-          // Note that this number is based on the background porosity in the
-          // solitary wave initial condition.
-          const SolitaryWaveInitialCondition<dim> &initial_composition =
-            initial_composition_manager->template
-            get_matching_initial_composition_model<SolitaryWaveInitialCondition<dim>>();
-
-          return reference_permeability * pow(initial_composition.get_background_porosity(), 3.0) / eta_f;
-
-        }
-
-        double length_scaling (const double porosity) const
-        {
-          return std::sqrt(reference_permeability * std::pow(porosity,3) * (xi_0 + 4.0/3.0 * eta_0) / eta_f);
-        }
-
-        double velocity_scaling (const double porosity) const
-        {
-          const Point<dim> surface_point = this->get_geometry_model().representative_point(0.0);
-          return reference_permeability * std::pow(porosity,2) * (reference_rho_s - reference_rho_f)
-                 * this->get_gravity_model().gravity_vector(surface_point).norm() / eta_f;
-        }
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                      typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const override
-        {
-          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-            {
-              double porosity = in.composition[i][porosity_idx];
-
-              out.viscosities[i] = eta_0 * (1.0 - porosity);
-              out.densities[i] = reference_rho_s;
-              out.thermal_expansion_coefficients[i] = 0.0;
-              out.specific_heat[i] = 1.0;
-              out.thermal_conductivities[i] = 0.0;
-              out.compressibilities[i] = 0.0;
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                out.reaction_terms[i][c] = 0.0;
-            }
-
-          // fill melt outputs if they exist
-          aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-          if (melt_out != nullptr)
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                double porosity = in.composition[i][porosity_idx];
-
-                melt_out->compaction_viscosities[i] = xi_0 * (1.0 - porosity);
-                melt_out->fluid_viscosities[i]= eta_f;
-                melt_out->permeabilities[i]= reference_permeability * std::pow(porosity,3);
-                melt_out->fluid_densities[i]= reference_rho_f;
-                melt_out->fluid_density_gradients[i] = 0.0;
-              }
-
-        }
-
-      private:
-        double reference_rho_s;
-        double reference_rho_f;
-        double eta_0;
-        double xi_0;
-        double eta_f;
-        double reference_permeability;
-
-        /**
-         * A shared pointer to the initial composition object
-         * that ensures that the current object can continue
-         * to access the initial composition object beyond the
-         * first time step.
-         */
-        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition_manager;
-    };
-
-    template <int dim>
-    void
-    SolitaryWaveMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Solitary wave");
-        {
-          prm.declare_entry ("Reference solid density", "3000",
-                             Patterns::Double (0),
-                             "Reference density of the solid $\\rho_{s,0}$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference melt density", "2500",
-                             Patterns::Double (0),
-                             "Reference density of the melt/fluid$\\rho_{f,0}$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference shear viscosity", "1e20",
-                             Patterns::Double (0),
-                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Reference compaction viscosity", "1e20",
-                             Patterns::Double (0),
-                             "The value of the constant volumetric viscosity $\\xi_0$ of the solid matrix. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Reference melt viscosity", "100.0",
-                             Patterns::Double (0),
-                             "The value of the constant melt viscosity $\\eta_f$. "
-                             "Units: \\si{\\pascal\\second}.");
-
-          prm.declare_entry ("Reference permeability", "5e-9",
-                             Patterns::Double(),
-                             "Reference permeability of the solid host rock."
-                             "Units: \\si{\\meter\\squared}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    SolitaryWaveMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Solitary wave");
-        {
-          reference_rho_s            = prm.get_double ("Reference solid density");
-          reference_rho_f            = prm.get_double ("Reference melt density");
-          eta_0                      = prm.get_double ("Reference shear viscosity");
-          xi_0                       = prm.get_double ("Reference compaction viscosity");
-          eta_f                      = prm.get_double ("Reference melt viscosity");
-          reference_permeability     = prm.get_double ("Reference permeability");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    double
-    SolitaryWaveInitialCondition<dim>::get_amplitude () const
-    {
-      return amplitude;
-    }
-
-    template <int dim>
-    double
-    SolitaryWaveInitialCondition<dim>::get_background_porosity () const
-    {
-      return background_porosity;
-    }
-
-    template <int dim>
-    double
-    SolitaryWaveInitialCondition<dim>::get_offset () const
-    {
-      return offset;
-    }
-
-    template <int dim>
-    void
-    SolitaryWaveInitialCondition<dim>::initialize ()
-    {
-      std::cout << "Initialize solitary wave solution"
-                << std::endl;
-
-      AssertThrow(Plugins::plugin_type_matches<const SolitaryWaveMaterial<dim>>(this->get_material_model()),
-                  ExcMessage("Initial condition Solitary Wave only works with the material model Solitary wave."));
-
-      const SolitaryWaveMaterial<dim> &
-      material_model
-        = Plugins::get_plugin_as_type<const SolitaryWaveMaterial<dim>>(this->get_material_model());
-
-      compaction_length = material_model.length_scaling(background_porosity);
-
-      AnalyticSolutions::compute_porosity(amplitude,
-                                          background_porosity,
-                                          offset,
-                                          compaction_length,
-                                          read_solution,
-                                          file_name,
-                                          this->get_mpi_communicator());
-    }
-
-
-    template <int dim>
-    double
-    SolitaryWaveInitialCondition<dim>::
-    initial_composition (const Point<dim> &position, const unsigned int /*n_comp*/) const
-    {
-      return AnalyticSolutions::interpolate(position[dim-1],
-                                            offset);
-    }
-
-
-    template <int dim>
-    void
-    SolitaryWaveInitialCondition<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Solitary wave initial condition");
-        {
-          prm.declare_entry ("Amplitude", "0.01",
-                             Patterns::Double (0),
-                             "Amplitude of the solitary wave. Units: none.");
-          prm.declare_entry ("Background porosity", "0.001",
-                             Patterns::Double (0),
-                             "Background porosity of the solitary wave. Units: none.");
-          prm.declare_entry ("Offset", "150",
-                             Patterns::Double (0),
-                             "Offset of the center of the solitary wave from the boundary"
-                             "of the domain. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Read solution from file", "false",
-                             Patterns::Bool (),
-                             "Whether to read the porosity initial condition from "
-                             "a file or to compute it.");
-          prm.declare_entry ("File name", "solitary_wave.txt",
-                             Patterns::Anything (),
-                             "The file name of the porosity initial condition data. ");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    SolitaryWaveInitialCondition<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Solitary wave initial condition");
-        {
-          amplitude            = prm.get_double ("Amplitude");
-          background_porosity  = prm.get_double ("Background porosity");
-          offset               = prm.get_double ("Offset");
-          read_solution        = prm.get_bool ("Read solution from file");
-          file_name            = prm.get ("File name");
-
-          AssertThrow(amplitude > background_porosity,
-                      ExcMessage("Amplitude of the solitary wave must be larger "
-                                 "than the background porosity."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the paper Keller et al. reference above.
-      */
-    template <int dim>
-    class SolitaryWavePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Initialization function. Take references to the material model and
-         * initial conditions model to get the parameters necessary for computing
-         * the analytical solution for the shape of the solitary wave and store them.
-         */
-        void
-        initialize () override;
-
-        void
-        store_initial_pressure ();
-
-        double
-        compute_phase_shift ();
-
-      private:
-        double amplitude;
-        double background_porosity;
-        double offset;
-        double compaction_length;
-        double velocity_scaling;
-        double boundary_velocity;
-        unsigned int max_points;
-        std::vector<double> initial_pressure;
-        double maximum_pressure;
-        std::shared_ptr<AnalyticSolutions::FunctionSolitaryWave<dim>> ref_func;
-
-    };
-
-    template <int dim>
-    void
-    SolitaryWavePostprocessor<dim>::initialize ()
-    {
-      // verify that we are using the "Solitary wave" initial conditions and material model,
-      // then get the parameters we need
-
-      const SolitaryWaveInitialCondition<dim> &initial_composition
-        = this->get_initial_composition_manager().template get_matching_initial_composition_model<SolitaryWaveInitialCondition<dim>> ();
-
-      amplitude           = initial_composition.get_amplitude();
-      background_porosity = initial_composition.get_background_porosity();
-      offset              = initial_composition.get_offset();
-
-      AssertThrow(Plugins::plugin_type_matches<const SolitaryWaveMaterial<dim>>(this->get_material_model()),
-                  ExcMessage("Postprocessor Solitary Wave only works with the material model Solitary wave."));
-
-      const SolitaryWaveMaterial<dim> &material_model
-        = Plugins::get_plugin_as_type<const SolitaryWaveMaterial<dim>>(this->get_material_model());
-
-      compaction_length = material_model.length_scaling(background_porosity);
-      velocity_scaling = material_model.velocity_scaling(background_porosity);
-
-
-      // we also need the boundary velocity, but we can not get it from simulator access
-      // TODO: write solitary wave boundary condition where the phase speed is calculated!
-
-      max_points = 1e6;
-      initial_pressure.resize(max_points);
-      maximum_pressure = 0.0;
-    }
-
-    template <int dim>
-    void
-    SolitaryWavePostprocessor<dim>::store_initial_pressure ()
-    {
-      const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.pressure).degree);
-      const unsigned int n_q_points = quadrature_formula.size();
-      const double max_depth = this->get_geometry_model().maximal_depth();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      // do the same stuff we do in depth average
-      std::vector<double> volume(max_points,0.0);
-      std::vector<double> pressure(max_points,0.0);
-      std::vector<double> p_c(n_q_points);
-      double local_max_pressure = 0.0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().variable("compaction pressure").extractor_scalar()]
-            .get_function_values (this->get_solution(),
-                                  p_c);
-
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                double z = fe_values.quadrature_point(q)[dim-1];
-                const unsigned int idx = static_cast<unsigned int>((z*(max_points-1))/max_depth);
-                AssertThrow(idx < max_points, ExcInternalError());
-
-                pressure[idx] += p_c[q] * fe_values.JxW(q);
-                volume[idx] += fe_values.JxW(q);
-
-                local_max_pressure = std::max (local_max_pressure, std::abs(p_c[q]));
-              }
-          }
-
-      std::vector<double> volume_all(max_points, 0.0);
-      Utilities::MPI::sum(volume, this->get_mpi_communicator(), volume_all);
-      Utilities::MPI::sum(pressure, this->get_mpi_communicator(), initial_pressure);
-      maximum_pressure = Utilities::MPI::max (local_max_pressure, this->get_mpi_communicator());
-
-      for (unsigned int i=0; i<initial_pressure.size(); ++i)
-        {
-          initial_pressure[i] = initial_pressure[i] / (static_cast<double>(volume_all[i])+1e-20);
-        }
-
-      // fill the first and last element of the initial_pressure vector if they are empty
-      // this makes sure they can be used for the interpolation later on
-      if (initial_pressure[0] == 0.0)
-        {
-          unsigned int j = 1;
-          while (initial_pressure[j] == 0.0)
-            j++;
-          initial_pressure[0] = initial_pressure[j];
-        }
-
-      if (initial_pressure[max_points-1] == 0.0)
-        {
-          unsigned int k = max_points-2;
-          while (initial_pressure[k] == 0.0)
-            k--;
-          initial_pressure[max_points-1] = initial_pressure[k];
-        }
-
-      // interpolate between the non-zero elements to fill the elements that are 0
-      for (unsigned int i=1; i<max_points-1; ++i)
-        {
-          if (initial_pressure[i] == 0.0)
-            {
-              // interpolate between the values we have
-              unsigned int k = i-1;
-              while (initial_pressure[k] == 0.0)
-                {
-                  Assert(k > 0, ExcInternalError());
-                  k--;
-                }
-
-              unsigned int j = i+1;
-              while (initial_pressure[j] == 0.0)
-                j++;
-              Assert(j < max_points, ExcInternalError());
-              initial_pressure[i] = initial_pressure[k] + (initial_pressure[j]-initial_pressure[k]) * static_cast<double>(i-k)/static_cast<double>(j-k);
-            }
-        }
-    }
-
-    template <int dim>
-    double
-    SolitaryWavePostprocessor<dim>::compute_phase_shift ()
-    {
-      AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                  ExcMessage("Postprocessor Solitary Wave only works if there is a compositional field called porosity."));
-      const unsigned int porosity_index = this->introspection().compositional_index_for_name("porosity");
-      const typename Simulator<dim>::AdvectionField porosity = Simulator<dim>::AdvectionField::composition(porosity_index);
-
-      // create a quadrature formula based on the compositional element alone.
-      AssertThrow (this->introspection().n_compositional_fields > 0,
-                   ExcMessage("This postprocessor cannot be used without compositional fields."));
-
-      const QGauss<dim> quadrature_formula (this->get_fe().base_element(porosity.base_element(this->introspection())).degree+1);
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      std::vector<double> compositional_values(n_q_points);
-
-      // The idea here is to first find the maximum, and then use the analytical solution of the
-      // solitary wave to calculate a phase shift for every point.
-      // This has to be done separately for points left and right of the maximum, as the analytical
-      // solution is only defined for coordinates > 0.
-      // In the end, these values for the phase shift are averaged.
-
-      // compute the maximum composition by quadrature (because we also need the coordinate)
-      double z_max_porosity = std::numeric_limits<double>::quiet_NaN();
-      {
-        double local_max_porosity = -std::numeric_limits<double>::max();
-        double local_max_z_location = std::numeric_limits<double>::quiet_NaN();
-
-        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              fe_values.reinit (cell);
-              fe_values[this->introspection().extractors.compositional_fields[porosity_index]].get_function_values (this->get_solution(),
-                  compositional_values);
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  const double composition = compositional_values[q];
-
-                  if (composition > local_max_porosity)
-                    {
-                      local_max_porosity = composition;
-                      local_max_z_location = fe_values.quadrature_point(q)[dim-1];
-                    }
-                }
-            }
-
-        double max_porosity = 0.0;
-        MPI_max_and_data(local_max_porosity, local_max_z_location, max_porosity, z_max_porosity);
-      }
-
-
-      // iterate over all points and calculate the phase shift
-      double phase_shift_integral = 0.0;
-      unsigned int number_of_points = 0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.compositional_fields[porosity_index]].get_function_values (this->get_solution(),
-                compositional_values);
-
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                const double composition = compositional_values[q];
-
-                // we do not want to include the constant-porosity background in the calculation
-                // nor the peak of the wave where we maximum of the composition is not a good indicator
-                // if we are left or right of the maximum of the analytical solution
-                if (composition > background_porosity + (amplitude - background_porosity)*0.05  && composition <= amplitude*0.9)
-                  {
-                    double z_analytical = compaction_length
-                                          * AnalyticSolutions::solitary_wave_solution(composition/background_porosity,
-                                                                                      amplitude/background_porosity);
-                    double z = fe_values.quadrature_point(q)[dim-1];
-
-                    if (z > z_max_porosity)
-                      {
-                        z -= offset;
-                        phase_shift_integral += (z - z_analytical);
-                      }
-                    else
-                      {
-                        z = offset - z;
-                        phase_shift_integral -= (z - z_analytical);
-                      }
-
-                    number_of_points += 1;
-                  }
-              }
-          }
-
-      double integral = Utilities::MPI::sum (phase_shift_integral, this->get_mpi_communicator())
-                        / Utilities::MPI::sum (static_cast<double>(number_of_points), this->get_mpi_communicator());
-
-      // TODO: different case for moving wave (with zero boundary velocity)
-      // const double phase_speed = velocity_scaling * (2.0 * amplitude / background_porosity + 1);
-      return integral; // + phase_speed * this->get_time();
-    }
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    SolitaryWavePostprocessor<dim>::execute (TableHandler & /*statistics*/)
-    {
-      // as we do not have an analytical solution for the pressure, we store the initial solution
-      if (this->get_timestep_number()==0)
-        {
-          store_initial_pressure();
-          ref_func = std::make_unique<AnalyticSolutions::FunctionSolitaryWave<dim>>(offset,0.0,initial_pressure,
-                                                                                     this->get_geometry_model().maximal_depth(), this->introspection().n_components);
-        }
-
-      double delta=0;
-
-      delta = compute_phase_shift();
-      // reset the phase shift of the analytical solution so we can compare the shape of the wave
-      ref_func->set_delta(delta);
-
-      // what we want to compare:
-      // (1) error of the numerical phase speed c:
-      // c_numerical = c_analytical - Delta / time;
-      const double c_analytical = velocity_scaling * (2.0 * amplitude / background_porosity + 1);
-      const double c_numerical = c_analytical + (this->get_time() > 0 ? delta / this->get_time() : 0.0);
-      const double error_c = std::abs (c_numerical / c_analytical - 1);
-
-      // (3) preservation of shape of melt fraction
-      // (4) preservation of the shape of compaction pressure
-
-      Vector<float> cellwise_errors_f (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-
-      // get correct components for porosity and compaction pressure
-      const unsigned int n_total_comp = this->introspection().n_components;
-      ComponentSelectFunction<dim> comp_f(dim+2+dim+2, n_total_comp);
-      ComponentSelectFunction<dim> comp_p(dim+1, n_total_comp);
-
-      const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.pressure).degree+1);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_f,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_f);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_p,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double e_f = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_f, VectorTools::L2_norm);
-      const double e_p = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
-
-      std::ostringstream os;
-      os << std::scientific << e_f / amplitude
-         << ", " << e_p / maximum_pressure
-         << ", " << error_c
-         << ", " << std::abs(delta);
-
-
-      return std::make_pair("Errors e_f, e_p_c_bar, e_c, delta:", os.str());
-    }
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace SolitaryWaveBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SolitaryWaveMaterial,
-                                   "Solitary Wave",
-                                   "A material model that corresponds to the 'SolitaryWave' benchmark "
-                                   "defined in Keller et al., JGI, 2013.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(SolitaryWavePostprocessor,
-                                  "solitary wave statistics",
-                                  "A postprocessor that compares the solution of the benchmarks from "
-                                  "the Keller et al., JGI, 2013, paper with the one computed by ASPECT "
-                                  "and reports the error.")
-
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(SolitaryWaveInitialCondition,
-                                              "Solitary wave initial condition",
-                                              "Composition is set to a solitary wave function.")
-  }
-}
diff --git a/benchmarks/solitary_wave/solitary_wave.prm.bak b/benchmarks/solitary_wave/solitary_wave.prm.bak
deleted file mode 100644
index 6d3059ca04f..00000000000
--- a/benchmarks/solitary_wave/solitary_wave.prm.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Set up the solitary wave benchmark
-# (Barcilon & Richter, 1986; Simpson & Spiegelman, 2011;
-# Keller et al., 2013; Schmeling, 200
-
-set Additional shared libraries            = ./libsolitary_wave.so
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = output
-set Max nonlinear iterations               = 10
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 6e6
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.001
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = top, bottom
-  set List of model names = initial composition
-end
-
-# we apply the phase speed of the wave here, so that it always stays in the same place in our model
-# the phase speed is c = 5.25e-11 m/s, but we have to convert it to m/years using the same conversion
-# that is used internally in ASPECT: year_in_seconds = 60*60*24*365.2425
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Prescribed velocity boundary indicators = top:function, bottom:function
-
-  subsection Function
-    #    set Function expression = 0;-8.2836999e-5
-    set Function expression = 0;-1.65673998e-4
-
-    #    set Function expression = 0;-3.31347996e-4
-    #    set Function expression = 0;-6.62695992e-4
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 10
-    set Y extent  = 400
-    set Y repetitions = 40
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Initial composition model
-  set Model name = Solitary wave initial condition
-
-  subsection Solitary wave initial condition
-    set Offset = 200
-    set Read solution from file = true
-    set Amplitude = 0.01
-    set Background porosity = 0.001
-  end
-end
-
-subsection Material model
-  set Model name = Solitary Wave
-
-  subsection Solitary wave
-    set Reference permeability = 5e-9
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics,solitary wave statistics
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 5e5
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-14
-  set Temperature solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-10
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc.bak b/benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc.bak
deleted file mode 100644
index b9fab75725b..00000000000
--- a/benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc.bak
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include "solkz_compositional_fields.h"
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SolKzCompositionalMaterial,
-                                   "SolKzCompositionalMaterial",
-                                   "A material model that corresponds to the 'SolKz' benchmark "
-                                   "defined in Duretz et al., G-Cubed, 2011. using "
-                                   "compositional fields. ")
-
-
-    ASPECT_REGISTER_POSTPROCESSOR(SolKzPostprocessor,
-                                  "SolKzPostprocessor",
-                                  "A postprocessor that compares the solution of the benchmarks from "
-                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
-                                  "and reports the error. Specifically, it can compute the errors for "
-                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
-                                  "which material model is currently being used and adjusts "
-                                  "which exact solution to use accordingly.")
-  }
-}
diff --git a/benchmarks/solkz/compositional_fields/solkz_compositional_fields.h.bak b/benchmarks/solkz/compositional_fields/solkz_compositional_fields.h.bak
deleted file mode 100644
index 8e2e4e7232e..00000000000
--- a/benchmarks/solkz/compositional_fields/solkz_compositional_fields.h.bak
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef ASPECT_SOLKZ_COMPOSITIONAL_FIELDS_H
-#define ASPECT_SOLKZ_COMPOSITIONAL_FIELDS_H
-
-
-#include "../solkz.h"
-
-
-
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class SolKzCompositionalMaterial : public SolKzMaterial<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          SolKzMaterial<dim>::evaluate(in, out);
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              out.densities[i] = in.composition[i][0];
-              out.viscosities[i] = in.composition[i][1];
-            }
-        }
-    };
-  }
-}
-#endif
diff --git a/benchmarks/solkz/compositional_fields/solkz_compositional_fields.prm.bak b/benchmarks/solkz/compositional_fields/solkz_compositional_fields.prm.bak
deleted file mode 100644
index 67f3ebe888c..00000000000
--- a/benchmarks/solkz/compositional_fields/solkz_compositional_fields.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# A description of the SolKZ benchmark using compositional fields
-# for which a known solution is available. See the manual for
-# more information.
-
-set Additional shared libraries            = ./libsolkz_compositional_fields.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolKzCompositionalMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-
-  # Whether to use a composition discretization that is discontinuous as
-  # opposed to continuous. This then requires the assembly of face terms
-  # between cells, and weak imposition of boundary terms for the composition
-  # field via the discontinuous Galerkin method.
-
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-############### Parameters describing the compositional field
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = density_comp, viscosity_comp
-  set Compositional field methods = field, field
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi = 3.1415926536
-    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(1e6)*z)
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, SolKzPostprocessor
-
-  subsection Visualization
-    set Output format = vtu
-    set Number of grouped files = 1
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
diff --git a/benchmarks/solkz/compositional_fields/solkz_particles.prm.bak b/benchmarks/solkz/compositional_fields/solkz_particles.prm.bak
deleted file mode 100644
index 44f32cc289b..00000000000
--- a/benchmarks/solkz/compositional_fields/solkz_particles.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-# A description of the SolKZ benchmark using active particles
-# to interpolate both density and viscosity onto the compositional
-# fields for which a known solution is available. See the manual
-# for more information.
-
-set Additional shared libraries            = ./libsolkz_compositional_fields.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolKzCompositionalMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = density_comp, viscosity_comp
-  set Compositional field methods = particles, particles
-  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, visualization, SolKzPostprocessor
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Number of grouped files       = 1
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = cell average
-  set Maximum particles per cell = 16384
-  set Update ghost particles = true
-  set Particle generator name = reference cell
-
-  subsection Function
-    set Number of components = 2
-    set Variable names      = x, z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression =  -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 4
-    end
-  end
-end
diff --git a/benchmarks/solkz/doc/solkz.prm.bak b/benchmarks/solkz/doc/solkz.prm.bak
deleted file mode 100644
index 99e6a93d934..00000000000
--- a/benchmarks/solkz/doc/solkz.prm.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-# A description of the SolKZ benchmark for which a known solution
-# is available. See the manual for more information.
-
-set Additional shared libraries            = ./libsolkz.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = SolKzPostprocessor, visualization
-end
diff --git a/benchmarks/solkz/solkz.cc.bak b/benchmarks/solkz/solkz.cc.bak
deleted file mode 100644
index cc972af1460..00000000000
--- a/benchmarks/solkz/solkz.cc.bak
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include "solkz.h"
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SolKzMaterial,
-                                   "SolKzMaterial",
-                                   "A material model that corresponds to the 'SolKz' benchmark "
-                                   "defined in Duretz et al., G-Cubed, 2011.")
-
-
-    ASPECT_REGISTER_POSTPROCESSOR(SolKzPostprocessor,
-                                  "SolKzPostprocessor",
-                                  "A postprocessor that compares the solution of the benchmarks from "
-                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
-                                  "and reports the error. Specifically, it can compute the errors for "
-                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
-                                  "which material model is currently being used and adjusts "
-                                  "which exact solution to use accordingly.")
-  }
-}
diff --git a/benchmarks/solkz/solkz.h.bak b/benchmarks/solkz/solkz.h.bak
deleted file mode 100644
index 50d8e0765e2..00000000000
--- a/benchmarks/solkz/solkz.h.bak
+++ /dev/null
@@ -1,799 +0,0 @@
-#ifndef ASPECT_SOLKZ_H
-#define ASPECT_SOLKZ_H
-
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-
-namespace aspect
-{
-  /**
-   * This is the "Sol Kz" benchmark defined in the following paper:
-   * @code
-   *  @Article{DMGT11,
-   *    author =       {T. Duretz and D. A. May and T. V. Gerya and P. J. Tackley},
-   *    title =        {Discretization errors and free surface stabilization in the
-   *                  finite difference and marker-in-cell method for applied
-   *                  geodynamics: {A} numerical study},
-   *    journal =      {Geochemistry Geophysics Geosystems},
-   *    year =         2011,
-   *    volume =       12,
-   *    pages =        {Q07004/1--26}}
-   * @endcode
-   *
-   * The results are published in Kronbichler, Heister and Bangerth paper.
-   */
-  namespace InclusionBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-      // based on http://geodynamics.org/hg/cs/AMR/Discontinuous_Stokes with permission
-      // The following code has been taken from http://www.underworldproject.org/,
-      // release 1.7.0. As mentioned in the Underworld Manual, this code has been
-      // released under the GNU General Public License (GPL).
-
-      void _Velic_solKz(
-        double pos[],
-        double _sigma, /* density */
-        double _km, int _n, /* wavelength in z, wavenumber in x */
-        double _B, /* viscosity parameter */
-        double vel[], double *presssure,
-        double total_stress[], double strain_rate[])
-      {
-        double Z;
-        double u1, u2, u3, u4, u5, u6, SS;
-        double sum1, sum2, sum3, sum4, sum5, sum6, sum7, x, z;
-        double sigma;
-        int n;
-        double kn;
-        double _C1, _C2, _C3, _C4;
-        double B, Rp, UU, VV;
-        double rho, a, b, r, _aa, _bb, AA, BB, Rm, km;
-
-
-        double t1, t2, t3, t4, t5, t6, t7, t8, t9, t10;
-        double t11, t12, t13, t14, t15, t16, t17, t18, t19, t20;
-        double t21, t22, t23, t24, t25, t26, t27, t28, t29, t31;
-        double t33, t34, t35, t37, t38, t40, t41, t42, t43, t45;
-        double t47, t51, t52, t53, t54, t55, t56, t57, t58, t59;
-        double t60, t61, t62, t64, t65, t66, t67, t68, t69, t70;
-        double t71, t72, t73, t74, t75, t76, t77, t78, t79, t80;
-        double t81, t82, t83, t84, t85, t86, t89, t90, t92, t94;
-        double t96, t97, t98, t99, t100, t101, t103, t104, t105, t106;
-        double t107, t108, t109, t110, t111, t112, t113, t114, t115, t116;
-        double t117, t118, t119, t120, t121, t122, t123, t124, t125, t126;
-        double t127, t130, t131, t132, t134, t135, t141, t144, t147, t148;
-        double t150, t151, t152, t161, t171;
-
-
-
-        /*************************************************************************/
-        /*************************************************************************/
-        /* rho = -sigma*sin(km*z)*cos(kn*x) */
-        /* viscosity  Z= exp(2*B*z)  */
-        B = _B; /* viscosity parameter must be non-zero*/
-        km = _km; /* solution valid for km not zero -- should get trivial solution if km=0 */
-        n = _n; /* solution valid for n not zero */
-        sigma = _sigma;
-        /*************************************************************************/
-        /*************************************************************************/
-        kn = (double) _n * M_PI;
-        a = B * B + kn * kn;
-        b = 2.0 * kn * B;
-        r = sqrt(a * a + b * b);
-        Rp = sqrt((r + a) / 2.0);
-        Rm = sqrt((r - a) / 2.0);
-        UU = Rp - B;
-        VV = Rp + B;
-
-
-        x = pos[0];
-        z = pos[1];
-
-        sum1 = 0.0;
-        sum2 = 0.0;
-        sum3 = 0.0;
-        sum4 = 0.0;
-        sum5 = 0.0;
-        sum6 = 0.0;
-        sum7 = 0.0;
-
-
-
-
-        /*******************************************/
-        /*         calculate the constants         */
-        /*******************************************/
-
-        t3 = kn * kn;
-        t4 = km * km;
-        t6 = B * B;
-        t8 = 0.4e1 * t3 * t6;
-        t10 = 0.4e1 * t4 * t6;
-        t13 = 0.8e1 * kn * t6 * km;
-        t14 = t4 * t4;
-        t16 = 0.2e1 * t3 * t4;
-        t17 = t3 * t3;
-        _aa = -0.4e1 * B * km * kn * (t3 + t4) / (t8 + t10 + t13 + t14 + t16 + t17) /
-              (-t13 + t8 + t10 + t14 + t16 + t17);
-
-        t1 = kn * kn;
-        t2 = t1 * t1;
-        t3 = B * B;
-        t5 = 0.4e1 * t1 * t3;
-        t6 = km * km;
-        t7 = t6 * t6;
-        t9 = 0.2e1 * t1 * t6;
-        t11 = 0.4e1 * t3 * t6;
-        t16 = 0.8e1 * kn * t3 * km;
-        _bb = kn * (t2 + t5 + t7 + t9 - t11) / (t5 + t11 + t16 + t7 + t9 + t2) /
-              (-t16 + t5 + t11 + t7 + t9 + t2);
-
-        AA = _aa;
-        BB = _bb;
-
-        t1 = B * B;
-        t2 = t1 * Rp;
-        t4 = Rm * Rm;
-        t5 = t4 * Rp;
-        t7 = t4 * B;
-        t8 = km * km;
-        t12 = Rp * Rp;
-        t13 = B * t12;
-        t21 = 0.8e1 * t1 * km * BB * Rp;
-        t23 = 0.2e1 * Rm;
-        t24 = cos(t23);
-        t26 = Rm * Rp;
-        t38 = sin(t23);
-        t51 = exp(-0.2e1 * Rp);
-        t53 = B + Rp;
-        t54 = Rm * t53;
-        t55 = Rm * B;
-        t57 = 0.2e1 * B * km;
-        t58 = t55 + t57 - t26;
-        t62 = 0.3e1 * t1;
-        t64 = 0.2e1 * Rp * B;
-        t65 = t62 + t64 + t4 - t8 - t12;
-        t67 = t54 * t65 * BB;
-        t69 = Rm - km;
-        t70 = cos(t69);
-        t72 = -t57 + t55 - t26;
-        t77 = Rm + km;
-        t78 = cos(t77);
-        t81 = t54 * t65 * AA;
-        t86 = sin(t77);
-        t92 = sin(t69);
-        t96 = exp(-t53);
-        t98 = B - Rp;
-        t99 = Rm * t98;
-        t100 = t55 + t57 + t26;
-        t104 = t62 - t64 + t4 - t8 - t12;
-        t106 = t99 * t104 * BB;
-        t109 = -t57 + t55 + t26;
-        t116 = t99 * t104 * AA;
-        t130 = exp(-0.3e1 * Rp - B);
-        t135 = exp(-0.4e1 * Rp);
-        t144 = t4 * t1;
-        t150 = t4 * t12;
-        _C1 = (((0.2e1 * Rp * (0.2e1 * t2 + 0.2e1 * t5 + t7 + B * t8 - 0.3e1 * t1 * B + t13) * AA + t21) * t24 +
-                (-0.2e1 * t26 * (t4 - t8 - t12 + 0.5e1 * t1) * AA + 0.8e1 * B * BB * km * Rm * Rp) * t38 -
-                0.2e1 * B * (0.2e1 * t13 + t12 * Rp - 0.3e1 * t2 + t5 + 0.2e1 * t7 + t8 * Rp) * AA - t21) *
-               t51 + ((0.2e1 * t54 * t58 * AA + t67) * t70 + (0.2e1 * t54 * t72 * AA - t67) * t78 +
-                      (t81 + 0.2e1 * t54 * t72 * BB) * t86 + (t81 - 0.2e1 * t54 * t58 * BB) * t92) * t96 +
-               ((-0.2e1 * t99 * t100 * AA - t106) * t70 + (-0.2e1 * t99 * t109 * AA + t106) * t78 +
-                (-t116 - 0.2e1 * t99 * t109 * BB) * t86 + (-t116 + 0.2e1 * t99 * t100 * BB) * t92) * t130 +
-               0.4e1 * t4 * t98 * t53 * AA * t135) /
-              (((-0.8e1 * t4 - 0.8e1 * t1) * t12 * t24 + 0.8e1 * t144 + 0.8e1 * t12 * t1) * t51 +
-               (0.4e1 * t150 - 0.4e1 * t144) * t135 + 0.4e1 * t150 - 0.4e1 * t144);
-
-        t1 = Rm * Rp;
-        t2 = Rm * Rm;
-        t3 = km * km;
-        t4 = Rp * Rp;
-        t5 = B * B;
-        t12 = km * Rm;
-        t17 = 0.2e1 * Rm;
-        t18 = cos(t17);
-        t22 = t2 * Rp;
-        t25 = B * t3;
-        t26 = t5 * B;
-        t33 = t5 * km;
-        t38 = sin(t17);
-        t40 = Rm * B;
-        t41 = 0.3e1 * t5;
-        t51 = exp(-0.2e1 * Rp);
-        t53 = B + Rp;
-        t54 = Rm * t53;
-        t57 = t41 + 0.2e1 * Rp * B + t2 - t3 - t4;
-        t59 = t54 * t57 * AA;
-        t60 = B * km;
-        t61 = 0.2e1 * t60;
-        t62 = t40 + t61 - t1;
-        t67 = Rm - km;
-        t68 = cos(t67);
-        t70 = -t61 + t40 - t1;
-        t75 = Rm + km;
-        t76 = cos(t75);
-        t82 = t54 * t57 * BB;
-        t84 = sin(t75);
-        t90 = sin(t67);
-        t94 = exp(-t53);
-        t97 = 0.3e1 * Rm * t26;
-        t98 = t2 * Rm;
-        t99 = t98 * B;
-        t100 = t3 * Rm;
-        t101 = t100 * Rp;
-        t103 = Rm * t4 * B;
-        t104 = t4 * Rp;
-        t105 = Rm * t104;
-        t107 = 0.8e1 * t33 * Rp;
-        t109 = 0.5e1 * t1 * t5;
-        t110 = t98 * Rp;
-        t111 = t100 * B;
-        t112 = t97 + t99 - t101 + t103 - t105 + t107 + t109 + t110 - t111;
-        t114 = t2 * t4;
-        t116 = 0.2e1 * t60 * t1;
-        t117 = t2 * t5;
-        t119 = 0.3e1 * t26 * Rp;
-        t120 = t104 * B;
-        t121 = t4 * t5;
-        t122 = 0.2e1 * t121;
-        t123 = t22 * B;
-        t125 = 0.2e1 * t33 * Rm;
-        t126 = t25 * Rp;
-        t127 = t114 + t116 + t117 - t119 + t120 + t122 + t123 + t125 + t126;
-        t132 = -t107 + t103 - t105 - t101 + t97 - t111 + t110 + t109 + t99;
-        t134 = t120 - t125 + t123 - t116 + t122 + t117 + t114 + t126 - t119;
-        t152 = exp(-0.3e1 * Rp - B);
-        t161 = exp(-0.4e1 * Rp);
-        _C2 = (((0.2e1 * t1 * (t2 - t3 - t4 + 0.5e1 * t5) * AA - 0.8e1 * B * BB * t12 * Rp) * t18 +
-                (0.2e1 * Rp * (0.2e1 * t5 * Rp + 0.2e1 * t22 + t2 * B + t25 - 0.3e1 * t26 + B * t4) * AA +
-                 0.8e1 * t33 * BB * Rp) * t38 + 0.2e1 * t40 * (t41 + t4 + t2 - t3) * AA -
-                0.8e1 * t5 * BB * t12) * t51 +
-               ((-t59 + 0.2e1 * t54 * t62 * BB) * t68 + (-t59 - 0.2e1 * t54 * t70 * BB) * t76 +
-                (0.2e1 * t54 * t70 * AA - t82) * t84 + (0.2e1 * t54 * t62 * AA + t82) * t90) * t94 +
-               ((t112 * AA - 0.2e1 * t127 * BB) * t68 + (t132 * AA + 0.2e1 * t134 * BB) * t76 +
-                (-0.2e1 * t134 * AA + t132 * BB) * t84 + (-0.2e1 * t127 * AA - t112 * BB) * t90) * t152 +
-               (-0.2e1 * t59 + 0.8e1 * t40 * km * t53 * BB) * t161) /
-              (((-0.8e1 * t2 - 0.8e1 * t5) * t4 * t18 + 0.8e1 * t117 + 0.8e1 * t121) * t51 +
-               (0.4e1 * t114 - 0.4e1 * t117) * t161 + 0.4e1 * t114 - 0.4e1 * t117);
-
-        t1 = B * B;
-        t2 = t1 * Rp;
-        t4 = Rm * Rm;
-        t5 = t4 * Rp;
-        t7 = Rp * Rp;
-        t8 = B * t7;
-        t11 = km * km;
-        t13 = t4 * B;
-        t21 = 0.8e1 * t1 * km * BB * Rp;
-        t23 = 0.2e1 * Rm;
-        t24 = cos(t23);
-        t26 = Rm * Rp;
-        t38 = sin(t23);
-        t51 = exp(-0.2e1 * Rp);
-        t53 = B + Rp;
-        t54 = Rm * t53;
-        t55 = Rm * B;
-        t57 = 0.2e1 * B * km;
-        t58 = t55 + t57 - t26;
-        t62 = 0.3e1 * t1;
-        t64 = 0.2e1 * Rp * B;
-        t65 = t62 + t64 + t4 - t11 - t7;
-        t67 = t54 * t65 * BB;
-        t69 = Rm - km;
-        t70 = cos(t69);
-        t72 = -t57 + t55 - t26;
-        t77 = Rm + km;
-        t78 = cos(t77);
-        t81 = t54 * t65 * AA;
-        t86 = sin(t77);
-        t92 = sin(t69);
-        t96 = exp(-t53);
-        t98 = B - Rp;
-        t99 = Rm * t98;
-        t100 = t55 + t57 + t26;
-        t104 = t62 - t64 + t4 - t11 - t7;
-        t106 = t99 * t104 * BB;
-        t109 = -t57 + t55 + t26;
-        t116 = t99 * t104 * AA;
-        t130 = exp(-0.3e1 * Rp - B);
-        t141 = t4 * t1;
-        t147 = t4 * t7;
-        t151 = exp(-0.4e1 * Rp);
-        _C3 = (((-0.2e1 * Rp * (-0.2e1 * t2 - 0.2e1 * t5 + t8 - 0.3e1 * t1 * B + B * t11 + t13) * AA - t21) *
-                t24 + (0.2e1 * t26 * (t4 - t11 - t7 + 0.5e1 * t1) * AA - 0.8e1 * B * BB * km * Rm * Rp) * t38 -
-                0.2e1 * B * (0.2e1 * t8 + 0.2e1 * t13 + 0.3e1 * t2 - t7 * Rp - t5 - t11 * Rp) * AA + t21) *
-               t51 + ((-0.2e1 * t54 * t58 * AA - t67) * t70 + (-0.2e1 * t54 * t72 * AA + t67) * t78 +
-                      (-t81 - 0.2e1 * t54 * t72 * BB) * t86 + (-t81 + 0.2e1 * t54 * t58 * BB) * t92) * t96 +
-               ((0.2e1 * t99 * t100 * AA + t106) * t70 + (0.2e1 * t99 * t109 * AA - t106) * t78 +
-                (t116 + 0.2e1 * t99 * t109 * BB) * t86 + (t116 - 0.2e1 * t99 * t100 * BB) * t92) * t130 +
-               0.4e1 * t4 * t98 * t53 * AA) /
-              (((-0.8e1 * t4 - 0.8e1 * t1) * t7 * t24 + 0.8e1 * t141 + 0.8e1 * t7 * t1) * t51 +
-               (0.4e1 * t147 - 0.4e1 * t141) * t151 + 0.4e1 * t147 - 0.4e1 * t141);
-
-        t1 = Rm * Rp;
-        t2 = Rm * Rm;
-        t3 = km * km;
-        t4 = Rp * Rp;
-        t5 = B * B;
-        t12 = km * Rm;
-        t17 = 0.2e1 * Rm;
-        t18 = cos(t17);
-        t22 = t2 * Rp;
-        t25 = t5 * B;
-        t27 = B * t3;
-        t33 = t5 * km;
-        t38 = sin(t17);
-        t40 = Rm * B;
-        t41 = 0.3e1 * t5;
-        t51 = exp(-0.2e1 * Rp);
-        t53 = t2 * Rm;
-        t54 = t53 * B;
-        t56 = 0.5e1 * t1 * t5;
-        t58 = Rm * t4 * B;
-        t59 = t3 * Rm;
-        t60 = t59 * Rp;
-        t62 = 0.8e1 * t33 * Rp;
-        t64 = 0.3e1 * Rm * t25;
-        t65 = t53 * Rp;
-        t66 = t59 * B;
-        t67 = t4 * Rp;
-        t68 = Rm * t67;
-        t69 = t54 - t56 + t58 + t60 - t62 + t64 - t65 - t66 + t68;
-        t71 = t2 * t4;
-        t73 = 0.3e1 * t25 * Rp;
-        t74 = t2 * t5;
-        t75 = t27 * Rp;
-        t76 = B * km;
-        t78 = 0.2e1 * t76 * t1;
-        t80 = 0.2e1 * t33 * Rm;
-        t81 = t22 * B;
-        t82 = t4 * t5;
-        t83 = 0.2e1 * t82;
-        t84 = t67 * B;
-        t85 = t71 + t73 + t74 - t75 - t78 + t80 - t81 + t83 - t84;
-        t89 = Rm - km;
-        t90 = cos(t89);
-        t92 = t60 - t66 - t65 + t58 + t54 - t56 + t62 + t68 + t64;
-        t94 = t73 + t78 - t81 + t74 - t80 - t84 - t75 + t83 + t71;
-        t98 = Rm + km;
-        t99 = cos(t98);
-        t105 = sin(t98);
-        t111 = sin(t89);
-        t115 = exp(-Rp - B);
-        t117 = B - Rp;
-        t118 = Rm * t117;
-        t121 = t41 - 0.2e1 * Rp * B + t2 - t3 - t4;
-        t123 = t118 * t121 * AA;
-        t124 = 0.2e1 * t76;
-        t125 = t40 + t124 + t1;
-        t131 = -t124 + t40 + t1;
-        t141 = t118 * t121 * BB;
-        t152 = exp(-0.3e1 * Rp - B);
-        t171 = exp(-0.4e1 * Rp);
-        _C4 = (((-0.2e1 * t1 * (t2 - t3 - t4 + 0.5e1 * t5) * AA + 0.8e1 * B * BB * t12 * Rp) * t18 +
-                (-0.2e1 * Rp * (-0.2e1 * t5 * Rp - 0.2e1 * t22 + t4 * B - 0.3e1 * t25 + t27 + t2 * B) * AA -
-                 0.8e1 * t33 * BB * Rp) * t38 + 0.2e1 * t40 * (t41 + t4 + t2 - t3) * AA -
-                0.8e1 * t5 * BB * t12) * t51 +
-               ((t69 * AA - 0.2e1 * t85 * BB) * t90 + (t92 * AA + 0.2e1 * t94 * BB) * t99 +
-                (-0.2e1 * t94 * AA + t92 * BB) * t105 + (-0.2e1 * t85 * AA - t69 * BB) * t111) * t115 +
-               ((-t123 + 0.2e1 * t118 * t125 * BB) * t90 + (-t123 - 0.2e1 * t118 * t131 * BB) * t99 +
-                (0.2e1 * t118 * t131 * AA - t141) * t105 + (0.2e1 * t118 * t125 * AA + t141) * t111) * t152 -
-               0.2e1 * t123 + 0.8e1 * t40 * km * t117 * BB) /
-              (((-0.8e1 * t2 - 0.8e1 * t5) * t4 * t18 + 0.8e1 * t74 + 0.8e1 * t82) * t51 +
-               (0.4e1 * t71 - 0.4e1 * t74) * t171 + 0.4e1 * t71 - 0.4e1 * t74);
-
-        /******************************************************************/
-        /******************************************************************/
-
-        /*******************************************/
-        /*       calculate the velocities etc      */
-        /*******************************************/
-
-        t2 = exp(UU * z);
-        t3 = Rm * z;
-        t4 = cos(t3);
-        t6 = sin(t3);
-        t11 = exp(-VV * z);
-        t18 = exp(-0.2e1 * z * B);
-        t19 = km * z;
-        t20 = cos(t19);
-        t22 = sin(t19);
-        u1 = kn * (t2 * (_C1 * t4 + _C2 * t6) + t11 * (_C3 * t4 + _C4 * t6) + t18 * (AA * t20 + BB * t22));
-
-        t1 = Rm * z;
-        t2 = cos(t1);
-        t4 = sin(t1);
-        t14 = exp(UU * z);
-        t26 = exp(-VV * z);
-        t28 = km * z;
-        t29 = cos(t28);
-        t31 = sin(t28);
-        t43 = exp(-0.2e1 * z * B);
-        u2 = (-UU * (_C1 * t2 + _C2 * t4) + _C1 * t4 * Rm - _C2 * t2 * Rm) * t14 +
-             (VV * (_C3 * t2 + _C4 * t4) + _C3 * t4 * Rm - _C4 * t2 * Rm) * t26 +
-             (0.2e1 * B * (AA * t29 + BB * t31) + AA * t31 * km - BB * t29 * km) * t43;
-
-        t2 = 0.2e1 * z * B;
-        t3 = exp(t2);
-        t4 = t3 * kn;
-        t5 = Rm * z;
-        t6 = cos(t5);
-        t8 = sin(t5);
-        t18 = exp(UU * z);
-        t31 = exp(-VV * z);
-        t34 = km * z;
-        t35 = cos(t34);
-        t37 = sin(t34);
-        t47 = exp(-t2);
-        u3 = 0.2e1 * t4 * (UU * (_C1 * t6 + _C2 * t8) - _C1 * t8 * Rm + _C2 * t6 * Rm) * t18 +
-             0.2e1 * t4 * (-VV * (_C3 * t6 + _C4 * t8) - _C3 * t8 * Rm + _C4 * t6 * Rm) * t31 +
-             0.2e1 * t4 * (-0.2e1 * B * (AA * t35 + BB * t37) - AA * t37 * km + BB * t35 * km) * t47;
-
-        t1 = Rm * Rm;
-        t3 = UU * UU;
-        t8 = kn * kn;
-        t11 = Rm * z;
-        t12 = sin(t11);
-        t14 = cos(t11);
-        t20 = t14 * Rm;
-        t27 = 0.2e1 * z * B;
-        t28 = exp(t27);
-        t31 = exp(UU * z);
-        t38 = VV * VV;
-        t54 = exp(-VV * z);
-        t56 = km * km;
-        t59 = B * B;
-        t66 = km * z;
-        t67 = sin(t66);
-        t69 = cos(t66);
-        t83 = exp(-t27);
-        u4 = ((_C2 * t1 - t3 * _C2 + 0.2e1 * UU * _C1 * Rm - _C2 * t8) * t12 + _C1 * t14 * t1 - t3 * _C1 * t14 -
-              0.2e1 * UU * _C2 * t20 - t8 * _C1 * t14) * t28 * t31 +
-             ((-0.2e1 * VV * _C3 * Rm + _C4 * t1 - _C4 * t8 - t38 * _C4) * t12 + 0.2e1 * VV * _C4 * t20 +
-              _C3 * t14 * t1 - t8 * _C3 * t14 - t38 * _C3 * t14) * t28 * t54 +
-             ((BB * t56 - t8 * BB - 0.4e1 * t59 * BB - 0.4e1 * B * AA * km) * t67 + AA * t69 * t56 -
-              t8 * AA * t69 - 0.4e1 * t59 * AA * t69 + 0.4e1 * B * BB * t69 * km) * t28 * t83;
-
-
-        t1 = Rm * z;
-        t2 = sin(t1);
-        t3 = Rm * Rm;
-        t4 = t3 * Rm;
-        t5 = t2 * t4;
-        t6 = UU * UU;
-        t7 = t6 * UU;
-        t8 = cos(t1);
-        t15 = 0.2e1 * B * t8 * t3;
-        t19 = B * UU;
-        t20 = t2 * Rm;
-        t23 = kn * kn;
-        t24 = B * t23;
-        t26 = 0.2e1 * t24 * t8;
-        t27 = t23 * UU;
-        t29 = B * t6;
-        t33 = t23 * t2 * Rm;
-        t35 = 0.1e1 / kn;
-        t42 = 0.2e1 * B * t2 * t3;
-        t43 = t8 * t4;
-        t45 = 0.2e1 * t24 * t2;
-        t52 = t23 * t8 * Rm;
-        t53 = t8 * Rm;
-        t64 = 0.2e1 * z * B;
-        t65 = exp(t64);
-        t68 = exp(UU * z);
-        t70 = B * VV;
-        t76 = t23 * VV;
-        t78 = VV * VV;
-        t79 = t78 * VV;
-        t84 = B * t78;
-        t108 = exp(-VV * z);
-        t111 = km * z;
-        t112 = sin(t111);
-        t113 = km * km;
-        t118 = cos(t111);
-        t119 = t118 * km;
-        t121 = B * B;
-        t123 = t112 * km;
-        t130 = t113 * km;
-        t148 = exp(-t64);
-        u5 = (-(-t5 - t7 * t8 + 0.3e1 * UU * t8 * t3 + t15 + 0.3e1 * t6 * t2 * Rm + 0.4e1 * t19 * t20 - t26 +
-                t27 * t8 - 0.2e1 * t29 * t8 - t33) * t35 * _C1 -
-              (-t7 * t2 + t27 * t2 + t42 + t43 - t45 + 0.3e1 * UU * t2 * t3 - 0.2e1 * t29 * t2 + t52 -
-               0.4e1 * t19 * t53 - 0.3e1 * t6 * t8 * Rm) * t35 * _C2) * t65 * t68 +
-             (-(t15 - 0.4e1 * t70 * t20 - t33 - 0.3e1 * VV * t8 * t3 - t76 * t8 + t79 * t8 +
-                0.3e1 * t78 * t2 * Rm - 0.2e1 * t84 * t8 - t26 - t5) * t35 * _C3 -
-              (t52 - 0.3e1 * VV * t2 * t3 + t79 * t2 + 0.4e1 * t70 * t53 - 0.3e1 * t78 * t8 * Rm -
-               0.2e1 * t84 * t2 + t43 - t76 * t2 + t42 - t45) * t35 * _C4) * t65 * t108 - t65 *
-             (-0.4e1 * B * BB *
-              t112 * t113 +
-              t23 * BB * t119 +
-              0.4e1 * t121 * AA *
-              t123 -
-              0.4e1 * t121 * BB *
-              t119 +
-              BB * t118 * t130 -
-              AA * t112 * t130 -
-              0.4e1 * B * AA *
-              t118 * t113 -
-              t23 * AA * t123 -
-              0.4e1 * t24 * AA *
-              t118 -
-              0.4e1 * t24 * BB *
-              t112) * t35 * t148;
-
-
-        t2 = 0.2e1 * z * B;
-        t3 = exp(t2);
-        t4 = t3 * kn;
-        t5 = Rm * z;
-        t6 = cos(t5);
-        t8 = sin(t5);
-        t18 = exp(UU * z);
-        t31 = exp(-VV * z);
-        t34 = km * z;
-        t35 = cos(t34);
-        t37 = sin(t34);
-        t47 = exp(-t2);
-        u6 = -0.2e1 * t4 * (UU * (_C1 * t6 + _C2 * t8) - _C1 * t8 * Rm + _C2 * t6 * Rm) * t18 -
-             0.2e1 * t4 * (-VV * (_C3 * t6 + _C4 * t8) - _C3 * t8 * Rm + _C4 * t6 * Rm) * t31 -
-             0.2e1 * t4 * (-0.2e1 * B * (AA * t35 + BB * t37) - AA * t37 * km + BB * t35 * km) * t47;
-
-
-
-
-        /******************************************************************/
-        /******************************************************************/
-
-
-
-        sum5 += u5 * cos(n * M_PI * x);  /* pressure */
-        u6 -= u5; /* get total stress */
-        sum6 += u6 * cos(n * M_PI * x);  /* xx stress */
-
-        u1 *= cos(n * M_PI * x); /* z velocity */
-        sum1 += u1;
-        u2 *= sin(n * M_PI * x); /* x velocity */
-        sum2 += u2;
-        u3 -= u5; /* get total stress */
-        u3 *= cos(n * M_PI * x); /* zz stress */
-        sum3 += u3;
-        u4 *= sin(n * M_PI * x); /* zx stress */
-        sum4 += u4;
-
-        rho = -sigma * sin(km * z) * cos(kn * x); /* density */
-        sum7 += rho;
-
-        SS = exp(UU * z) * (_C1 * cos(Rm * z) + _C2 * sin(Rm * z)) +
-             exp(-VV * z) * (_C3 * cos(Rm * z) + _C4 * sin(Rm * z)) +
-             exp(-2 * z * B) * (AA * cos(km * z) + BB * sin(km * z));
-        SS *= sin(kn * x); /* stream function */
-
-        //mag = sqrt(u1 * u1 + u2 * u2);
-        /*printf("%0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f %0.7f\n",x,z,sum1,sum2,sum3,sum4,sum5,sum6,mag,sum7,SS);*/
-
-
-        /* Output */
-        if (vel != nullptr)
-          {
-            vel[0] = sum2;
-            vel[1] = sum1;
-          }
-        if (presssure != nullptr)
-          {
-            (*presssure) = sum5;
-          }
-        if (total_stress != nullptr)
-          {
-            total_stress[0] = sum6;
-            total_stress[1] = sum3;
-            total_stress[2] = sum4;
-          }
-        if (strain_rate != nullptr)
-          {
-            /* sigma = tau - p, tau = sigma + p, tau[] = 2*eta*strain_rate[] */
-            Z = exp(2.0 * B * z);
-            strain_rate[0] = (sum6 + sum5) / (2.0 * Z);
-            strain_rate[1] = (sum3 + sum5) / (2.0 * Z);
-            strain_rate[2] = (sum4) / (2.0 * Z);
-          }
-        /* Value checks, could be cleaned up if needed. Julian Giordani 9-Oct-2006*/
-        if (fabs(sum5 - (-0.5 * (sum6 + sum3))) > 1e-5)
-          {
-            assert(0);
-          }
-      }
-
-
-
-      /**
-       * The exact solution for the SolKz benchmark.
-       */
-      template <int dim>
-      class FunctionSolKz : public Function<dim>
-      {
-        public:
-          FunctionSolKz(unsigned int n_components) : Function<dim>(n_components) {}
-
-          void vector_value(const Point<dim> &p,
-                            Vector<double> &values) const override
-          {
-            double pos[2] = {p(0), p(1)};
-            double total_stress[3], strain_rate[3];
-            static const double B = 0.5 * std::log(1e6);
-            AnalyticSolutions::_Velic_solKz
-            (pos,
-             1.0, 2, 3,
-             B,
-             &values[0], &values[2], total_stress, strain_rate);
-          }
-      };
-
-
-    }
-
-
-
-    template <int dim>
-    class SolKzMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-
-              const Point<dim> &pos = in.position[i];
-
-              static const double B = 0.5 * std::log(1e6);
-              out.viscosities[i] = std::exp(2 * B * pos[1]);
-
-              out.densities[i] = -std::sin(2 * pos[1]) * std::cos(3 * numbers::PI * pos[0]);
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible() const override
-        {
-          return false;
-        }
-        /**
-         * @}
-         */
-
-        void
-        parse_parameters(ParameterHandler &/*prm*/) override
-        {
-          // Declare dependencies on solution variables
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-    };
-
-
-
-    /**
-     * A postprocessor that evaluates the accuracy of the solution.
-     *
-     * The implementation of error evaluators that correspond to the
-     * benchmarks defined in the paper Duretz et al. reference above.
-     */
-    template <int dim>
-    class SolKzPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string, std::string>
-        execute(TableHandler &/*statistics*/) override
-        {
-          AnalyticSolutions::FunctionSolKz<dim> ref_func(this->introspection().n_components);
-
-          AssertThrow(Plugins::plugin_type_matches<const SolKzMaterial<dim>>(this->get_material_model()),
-                      ExcMessage(
-                        "Postprocessor SolKzPostprocessor only works with the material model SolKzn."));
-
-          const QGauss<dim> quadrature_formula(this->introspection().polynomial_degree.velocities + 2);
-
-          Vector<float> cellwise_errors_u(this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_p(this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_ul2(this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_pl2(this->get_triangulation().n_active_cells());
-
-          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0, dim),
-                                              this->get_fe().n_components());
-          ComponentSelectFunction<dim> comp_p(dim,
-                                              this->get_fe().n_components());
-
-          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
-                                            this->get_solution(),
-                                            ref_func,
-                                            cellwise_errors_u,
-                                            quadrature_formula,
-                                            VectorTools::L1_norm,
-                                            &comp_u);
-          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
-                                            this->get_solution(),
-                                            ref_func,
-                                            cellwise_errors_p,
-                                            quadrature_formula,
-                                            VectorTools::L1_norm,
-                                            &comp_p);
-          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
-                                            this->get_solution(),
-                                            ref_func,
-                                            cellwise_errors_ul2,
-                                            quadrature_formula,
-                                            VectorTools::L2_norm,
-                                            &comp_u);
-          VectorTools::integrate_difference(this->get_mapping(), this->get_dof_handler(),
-                                            this->get_solution(),
-                                            ref_func,
-                                            cellwise_errors_pl2,
-                                            quadrature_formula,
-                                            VectorTools::L2_norm,
-                                            &comp_p);
-
-          const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-          const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-          std::ostringstream os;
-          os << std::scientific << u_l1
-             << ", " << p_l1
-             << ", " << u_l2
-             << ", " << p_l2;
-
-          return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
-        }
-    };
-
-  }
-}
-
-#endif
diff --git a/benchmarks/solkz/solkz.prm.bak b/benchmarks/solkz/solkz.prm.bak
deleted file mode 100644
index 399ef6b1f1c..00000000000
--- a/benchmarks/solkz/solkz.prm.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-# A description of the SolKZ benchmark for which a known solution
-# is available. See the manual for more information.
-
-set Additional shared libraries            = ./libsolkz.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = SolKzPostprocessor, visualization
-end
diff --git a/benchmarks/solubility/plugin/solubility.cc.bak b/benchmarks/solubility/plugin/solubility.cc.bak
deleted file mode 100644
index c899cb5ed8c..00000000000
--- a/benchmarks/solubility/plugin/solubility.cc.bak
+++ /dev/null
@@ -1,424 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/melt.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <array>
-#include <utility>
-#include <limits>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * Volatiles material model.
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class Volatiles : public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>, public MaterialModel::MeltFractionModel<dim>
-    {
-      public:
-        /**
-         * Initialize the base model at the beginning of the run.
-         */
-        void initialize() override;
-
-        /**
-         * Update the base model at the beginning of each timestep.
-         */
-        void update() override;
-
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void
-        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
-                  typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * Method that indicates whether material is compressible. The model is compressible
-         * if and only if base model is compressible.
-         */
-        bool is_compressible () const override;
-
-        /**
-         * Compute the free fluid fraction that can be present in the material based on the
-         * fluid content of the material and the fluid solubility for the given input conditions.
-         * @p in and @p melt_fractions need to have the same size.
-         *
-         * @param in Object that contains the current conditions.
-         * @param melt_fractions Vector of doubles that is filled with the
-         * allowable free fluid fraction for each given input conditions.
-         */
-        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                             std::vector<double> &melt_fractions) const override;
-
-        double reference_darcy_coefficient () const override;
-
-        /**
-         * Method to declare parameters related to volatile model
-         */
-        static void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Method to parse parameters related to volatile model
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-      private:
-        /**
-         * Pointer to the material model used as the base model
-         */
-        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
-
-        // Variables that describe the properties of the fluid, i.e. its density,
-        // viscosity, and compressibility.
-        // Properties of the solid are defined in the base model.
-        double reference_rho_f;
-        double eta_f;
-        double fluid_compressibility;
-
-        // Material properties governing the transport of the fluid with respect
-        // to the solid, i.e., the bulk viscosity (relative to the shear viscosity),
-        // the permeability, and how much the solid viscosity changes in the presence
-        // of fluids.
-        double shear_to_bulk_viscosity_ratio;
-        double reference_permeability;
-        double alpha_phi;
-
-        // Time scale for fluid release and absorption.
-        double fluid_reaction_time_scale;
-    };
-
-
-
-    template <int dim>
-    void
-    Volatiles<dim>::initialize()
-    {
-      base_model->initialize();
-    }
-
-
-
-    template <int dim>
-    void
-    Volatiles<dim>::update()
-    {
-      base_model->update();
-    }
-
-
-
-    template <int dim>
-    void
-    Volatiles<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                             typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      base_model->evaluate(in,out);
-
-      // Modify the viscosity from the base model based on the presence of fluid.
-      const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-      if (in.requests_property(MaterialProperties::viscosity))
-        {
-          // Scale the base model viscosity value based on the porosity.
-          for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
-            {
-              const double porosity = std::max(in.composition[q][porosity_idx],0.0);
-              out.viscosities[q] *= (1.0 - porosity) * exp(- alpha_phi * porosity);
-            }
-        }
-
-      // Fill the melt outputs if they exist. Note that the MeltOutputs class was originally
-      // designed for two-phase flow material models in ASPECT that model the flow of melt,
-      // but can be reused for a geofluid of arbitrary composition.
-      MeltOutputs<dim> *fluid_out = out.template get_additional_output<MeltOutputs<dim>>();
-
-      if (fluid_out != nullptr)
-        {
-          for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
-            {
-              double porosity = std::max(in.composition[q][porosity_idx],0.0);
-
-              fluid_out->fluid_viscosities[q] = eta_f;
-              fluid_out->permeabilities[q] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-
-              fluid_out->fluid_densities[q] = reference_rho_f * std::exp(fluid_compressibility * (in.pressure[q] - this->get_surface_pressure()));
-
-              if (in.requests_property(MaterialProperties::viscosity))
-                {
-                  const double phi_0 = 0.05;
-                  porosity = std::max(porosity,1e-8);
-                  fluid_out->compaction_viscosities[q] = out.viscosities[q] * shear_to_bulk_viscosity_ratio * phi_0/porosity;
-                }
-            }
-        }
-
-      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
-      const unsigned int water_idx = this->introspection().compositional_index_for_name("water_content");
-
-      // Fill reaction rate outputs if the model uses operator splitting.
-      // Specifically, change the porosity (representing the amount of free water)
-      // based on the water solubility and the water content.
-      if (this->get_parameters().use_operator_splitting && reaction_rate_out != nullptr)
-        {
-          std::vector<double> eq_free_fluid_fractions(out.n_evaluation_points());
-          melt_fractions(in, eq_free_fluid_fractions);
-
-          for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
-            for (unsigned int c=0; c<in.composition[q].size(); ++c)
-              {
-                double porosity_change = eq_free_fluid_fractions[q] - in.composition[q][porosity_idx];
-                // do not allow negative porosity
-                if (in.composition[q][porosity_idx] + porosity_change < 0)
-                  porosity_change = -in.composition[q][porosity_idx];
-
-                if (c == water_idx && this->get_timestep_number() > 0)
-                  reaction_rate_out->reaction_rates[q][c] = - porosity_change / fluid_reaction_time_scale
-                                                            + in.composition[q][water_idx] * trace(in.strain_rate[q]);
-                else if (c == porosity_idx && this->get_timestep_number() > 0)
-                  reaction_rate_out->reaction_rates[q][c] = porosity_change / fluid_reaction_time_scale;
-                else
-                  reaction_rate_out->reaction_rates[q][c] = 0.0;
-              }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Volatiles<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Volatile model");
-        {
-          prm.declare_entry("Base model","visco plastic",
-                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
-                            "The name of a material model that will be modified by the "
-                            "addition of fluids. Valid values for this parameter "
-                            "are the names of models that are also valid for the "
-                            "``Material models/Model name'' parameter. See the documentation for "
-                            "that for more information.");
-          prm.declare_entry ("Reference fluid density", "2500",
-                             Patterns::Double (0),
-                             "Reference density of the melt/fluid$\\rho_{f,0}$. Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Shear to bulk viscosity ratio", "0.1",
-                             Patterns::Double (0),
-                             "Ratio between shear and bulk viscosity at the reference "
-                             "permeability $\\phi_0=0.05$. The bulk viscosity additionally "
-                             "scales with $\\phi_0/\\phi$. The shear viscosity is read in "
-                             "from the base model. Units: dimensionless.");
-          prm.declare_entry ("Reference fluid viscosity", "10",
-                             Patterns::Double (0),
-                             "The value of the constant melt/fluid viscosity $\\eta_f$. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Exponential fluid weakening factor", "27",
-                             Patterns::Double (0),
-                             "The porosity dependence of the viscosity. Units: dimensionless.");
-          prm.declare_entry ("Reference permeability", "1e-8",
-                             Patterns::Double(),
-                             "Reference permeability of the solid host rock."
-                             "Units: \\si{\\meter\\squared}.");
-          prm.declare_entry ("Fluid compressibility", "0.0",
-                             Patterns::Double (0),
-                             "The value of the compressibility of the fluid. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("Fluid reaction time scale for operator splitting", "1e3",
-                             Patterns::Double (0),
-                             "In case the operator splitting scheme is used, the porosity field can not "
-                             "be set to a new equilibrium fluid fraction instantly, but the model has to "
-                             "provide a reaction time scale instead. This time scale defines how fast fluid "
-                             "release and absorption happen, or more specifically, the parameter defines the "
-                             "time after which the deviation of the porosity from the free fluid fraction "
-                             "that would be in equilibrium with the solid will be reduced to a fraction of "
-                             "$1/e$. So if the fluid reaction time scale is small compared "
-                             "to the time step size, the reaction will be so fast that the porosity is very "
-                             "close to this equilibrium value after reactions are computed. Conversely, "
-                             "if the fluid reaction time scale is large compared to the time step size, almost no "
-                             "fluid release and absorption will occur."
-                             "\n\n"
-                             "Also note that the fluid reaction time scale has to be larger than or equal to the reaction "
-                             "time step used in the operator splitting scheme, otherwise reactions can not be "
-                             "computed. If the model does not use operator splitting, this parameter is not used. "
-                             "Units: yr or s, depending on the ``Use years "
-                             "in output instead of seconds'' parameter.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Volatiles<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Volatile model");
-        {
-          AssertThrow( prm.get("Base model") != "volatiles",
-                       ExcMessage("You may not use ``volatiles'' as the base model for "
-                                  "a the volatile model itself.") );
-
-          reference_rho_f                   = prm.get_double ("Reference fluid density");
-          shear_to_bulk_viscosity_ratio     = prm.get_double ("Shear to bulk viscosity ratio");
-          eta_f                             = prm.get_double ("Reference fluid viscosity");
-          reference_permeability            = prm.get_double ("Reference permeability");
-          alpha_phi                         = prm.get_double ("Exponential fluid weakening factor");
-          fluid_compressibility             = prm.get_double ("Fluid compressibility");
-          fluid_reaction_time_scale         = prm.get_double ("Fluid reaction time scale for operator splitting");
-
-          // Create the base model and initialize its SimulatorAccess base
-          // class; it will get a chance to read its parameters below after we
-          // leave the current section.
-          base_model = create_material_model<dim>(prm.get("Base model"));
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
-            sim->initialize_simulator (this->get_simulator());
-
-          if (this->convert_output_to_years() == true)
-            fluid_reaction_time_scale *= year_in_seconds;
-
-          if (this->get_parameters().use_operator_splitting)
-            {
-              AssertThrow(fluid_reaction_time_scale >= this->get_parameters().reaction_time_step,
-                          ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
-                                     + " in the operator splitting scheme is too large to compute melting rates! "
-                                     "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
-                                     "operator splitting' chosen in the material model, which is currently "
-                                     + Utilities::to_string(fluid_reaction_time_scale) + "."));
-              AssertThrow(fluid_reaction_time_scale > 0,
-                          ExcMessage("The Fluid reaction time scale for operator splitting must be larger than 0!"));
-            }
-
-          AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                      ExcMessage("Material model Volatiles only "
-                                 "works if there is a compositional field called porosity."));
-
-          AssertThrow(this->introspection().compositional_name_exists("water_content"),
-                      ExcMessage("Material model Volatiles only "
-                                 "works if there is a compositional field called water_content."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // After parsing the parameters for this model, parse parameters related to the base model.
-      base_model->parse_parameters(prm);
-      this->model_dependence = base_model->get_model_dependence();
-    }
-
-
-
-    template <int dim>
-    bool
-    Volatiles<dim>::
-    is_compressible () const
-    {
-      return base_model->is_compressible();
-    }
-
-
-
-    template <int dim>
-    void
-    Volatiles<dim>::
-    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                    std::vector<double> &melt_fractions) const
-    {
-      for (unsigned int q=0; q<in.temperature.size(); ++q)
-        {
-          const unsigned int water_idx = this->introspection().compositional_index_for_name("water_content");
-          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-          // A very simple model for water solubility:
-          // There are three layers, the top layer (<30 km depth) and the bottom layer (>60 km depth)
-          // can accommodate an unlimited amount of bound water (equivalent to a zero porosity).
-          // The middle layer between the two can not accommodate any water, therefore, any water
-          // present will be in the form of free water (and the porosity equals the total water available,
-          // which is the sum free and bound water, i.e. porosity + water_content.
-          if (this->get_geometry_model().depth(in.position[q]) < 3e4
-              || this->get_geometry_model().depth(in.position[q]) > 6e4)
-
-            melt_fractions[q] = 0.0;
-          else
-            melt_fractions[q] = in.composition[q][water_idx] + in.composition[q][porosity_idx];
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    Volatiles<dim>::
-    reference_darcy_coefficient () const
-    {
-      // 0.01 = 1% melt
-      return reference_permeability * std::pow(0.01,3.0) / eta_f;
-    }
-
-
-
-    template <int dim>
-    void
-    Volatiles<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (this->get_parameters().use_operator_splitting
-          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.viscosities.size();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Volatiles,
-                                   "volatiles",
-                                   "Material model that is designed to advect fluids and compute "
-                                   "fluid release and absorption based on a very simple model for "
-                                   "water solubility consisting of three layers with water only being "
-                                   "present as a free phase in the middle layer. "
-                                   "The properties of the solid can be taken from another material "
-                                   "model that is used as a base model.")
-  }
-}
diff --git a/benchmarks/solubility/solubility.prm.bak b/benchmarks/solubility/solubility.prm.bak
deleted file mode 100644
index aa8fa56c0be..00000000000
--- a/benchmarks/solubility/solubility.prm.bak
+++ /dev/null
@@ -1,162 +0,0 @@
-# This is a 1D test case for the solubility of fluids in interaction
-# with porous flow. Material with a given water content flows into the
-# model from the bottom. The model has three layers with different
-# water solubility, specifically, an infinite solubility above 30 km
-# depth and below 60 km depth, and a zero solubility in between. When
-# the upwelling material reaches the boundary at 60 km depth, water is
-# being released and can move relative to the solid as a free fluid
-# phase. Due to its lower density, it moves upwards twice as fast as the
-# solid, until it reaches 30 km depth where it is reabsorbed into the
-# solid. In steady state, the water content should be the same in the
-# top and bottom layer, and in the middle layer it should be zero (at
-# least the water_content field, representing the bound water in the
-# solid). The porosity (free water) should be 0.1, which is half of the
-# bound water content in the upper and lower layer (which follows from
-# mass conservation, since the free fluid moves twice as fast).
-
-set Additional shared libraries            = ./plugin/libsolubility.so
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = output
-set Max nonlinear iterations               = 10
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-set End time                               = 6e6
-
-# Because the model includes reactions that might be on a faster time scale
-# than the time step of the model (melting and the freezing of melt), we use
-# the operator splitting scheme.
-set Use operator splitting                     = true
-
-# There are two compositional fields, one that tracks the amount of free water
-# (the porosity) and one that tracks the amount of bound water (the water_content).
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, water_content
-end
-
-# Initially, there is no free water (the porosity is zero) and the water content
-# of the material is 1%.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0; 0.01
-  end
-end
-
-# The material flowing in from the bottom has the same water content as prescribed
-# in the initial condition.
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = bottom
-  set List of model names = initial composition
-end
-
-# We prescribe an upwelling velocity of 1 cm/yr at the bottom,
-# the left and right boundaries are closed and the top is open.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Prescribed velocity boundary indicators = bottom:function
-
-  subsection Function
-    set Function expression = 0; 1e-2
-  end
-end
-
-# The model is 1 km wide and extends 100 km in vertical direction.
-# This is because for this specific test material model, the transitions
-# between the three layers with different water solubilities are at
-# 30 km and 60 km depth.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2e2
-    set Y extent  = 1e5
-    set Y repetitions = 500
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# The temperature is not important for this model, so we simply
-# set it to 1600 K everywhere (including the boundary).
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Maximal temperature = 1600
-    set Minimal temperature = 1600
-  end
-end
-
-# We use a custom material model that implements the layers with
-# different solubility.
-subsection Material model
-  set Model name = volatiles
-
-  subsection Volatile model
-    set Base model = visco plastic
-    set Reference fluid density = 2995
-    set Shear to bulk viscosity ratio = 0.1
-    set Reference fluid viscosity = 10
-    set Reference permeability = 2.5e-6
-    set Exponential fluid weakening factor = 27
-    set Fluid reaction time scale for operator splitting = 5e4
-  end
-
-  subsection Visco Plastic
-    set Reference temperature                   = 1600
-    set Prefactors for diffusion creep          = 5e-21
-    set Viscous flow law = diffusion
-    set Densities                   = 3000
-    set Viscosity averaging scheme  = harmonic
-    set Minimum viscosity           = 1e19
-    set Maximum viscosity           = 1e19
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 0
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties, melt fraction
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Interpolate output            = false
-
-    subsection Melt material properties
-      set List of properties          = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
diff --git a/benchmarks/tangurnis/ba/tan.prm.bak b/benchmarks/tangurnis/ba/tan.prm.bak
deleted file mode 100644
index 73442056e32..00000000000
--- a/benchmarks/tangurnis/ba/tan.prm.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-# Listing of Parameters
-# ---------------------
-
-set Additional shared libraries            = ./code/libtangurnis.so
-set Dimension                              = 2
-set CFL number                             = 1.0
-
-# We only need a single time step.
-set Start time                             = 0
-set End time                               = 0.0001
-
-# The temperature is prescibed, so we only need to
-# solve the Stokes system
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-
-# In this section we define the adiabatic profiles of temperature,
-# pressure and density. The temperature and pressure profiles are
-# not used for this benchmark (and set to zero).
-# gamma is the grueneisen parameter, which defines the compressibility
-# of the material, and we have to choose the same value for gamma as
-# in the material model below.
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=0.0, gamma=1.0
-    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-# This case of the benchmark uses the Boussinesq approximation.
-subsection Formulation
-  set Formulation              = custom # equivalent to Boussinesq approximation
-  set Mass conservation        = incompressible
-  set Temperature equation     = reference density profile
-end
-
-# We define our own boundary condition that implements a boundary
-# temperature according to the prescibed temperature of the Tan & Gurnis
-# benchmark.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left, right, bottom, top
-  set List of model names = Tan Gurnis
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-# The model domain is the unit square.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*y)*cos(pi*1*x)
-  end
-end
-
-# The benchmark is defined in terms of the nondimensional numbers
-# Di (dissipation number) and gamma (grueneisen parameter).
-# As ASPECT uses physical properties instead of these dimensionless
-# numbers in its equations, we replicate the benchmark formulation
-# by using a new material model that fixes all of the material
-# constants to 1, except for the thermal expansivity and the viscosity,
-# which is set to Di, and the density profile, which depends on Di and
-# gamma.
-# For the Boussinesq case, Di=0 and gamma=infinity, and all parameters
-# are constant, except for the density, which depends on the temperature.
-subsection Material model
-  set Model name = Tan Gurnis
-
-  subsection Tan Gurnis model
-    set Di                            = 0
-    set gamma                         = 1 # infinity really, but is not used if Di=0
-    set a                             = 0   # constant viscosity
-    set wavenumber                    = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  set List of postprocessors = Tan Gurnis error, visualization
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/benchmarks/tangurnis/code/tangurnis.cc.bak b/benchmarks/tangurnis/code/tangurnis.cc.bak
deleted file mode 100644
index d4c6c372457..00000000000
--- a/benchmarks/tangurnis/code/tangurnis.cc.bak
+++ /dev/null
@@ -1,461 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/geometry_model/box.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-#include <deal.II/base/signaling_nan.h>
-
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-
-
-  /**
-   * This benchmark is from the article
-   * @code
-   *  @article{tan2007compressible,
-   *    title={Compressible thermochemical convection and application to lower mantle structures},
-   *    author={Tan, E. and Gurnis, M.},
-   *    journal={JOURNAL OF GEOPHYSICAL RESEARCH-ALL SERIES-},
-   *    volume={112},
-   *    number={B6},
-   *    pages={6304},
-   *    year={2007},
-   *    publisher={AGU AMERICAN GEOPHYSICAL UNION}
-   *    }
-   * @endcode
-   *
-   * @ingroup Postprocessing
-   */
-
-
-
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    class TanGurnis : public MaterialModel::Interface<dim>
-    {
-      public:
-
-        TanGurnis();
-
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              /**
-               * @name Physical parameters used in the basic equations
-               * @{
-               */
-
-              const Point<dim> &pos = in.position[i];
-              const double depth = 1.0 - pos[dim-1];
-              const double temperature = sin(numbers::PI*pos(dim-1))*cos(numbers::PI*wavenumber*pos(0));
-
-              out.viscosities[i] = ( Di==0.0 ? 1.0 : Di ) * exp( a * depth );
-              out.densities[i] = ( Di==0.0 ? 1.0 : Di ) * (-1.0 * temperature ) * exp( Di/gamma * (depth) );
-              out.specific_heat[i] = 1.0;
-              out.thermal_conductivities[i] = 1.0;
-              out.thermal_expansion_coefficients[i] = ( Di==0.0 ) ? 1.0 : Di;
-              out.compressibilities[i] = numbers::signaling_nan<double>();;
-            }
-        }
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-
-        double parameter_a() const;
-        double parameter_wavenumber() const;
-        double parameter_Di() const;
-        double parameter_gamma() const;
-
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-
-        double a;
-        double wavenumber;
-        double Di;
-        double gamma;
-
-    };
-
-    template <int dim>
-    TanGurnis<dim>::TanGurnis()
-    {
-      // a=0 for a constant viscosity or
-      // a=2 for a depth-dependent viscosity (case tala_c)
-      a=0;
-
-      // for BA: Di=0; gamma=inf
-      // however, we do not use gamma if Di=0, so the actual value does not matter
-
-      //TALA:
-      Di=0.5;
-      gamma=1.0;
-
-      wavenumber=1;
-    }
-
-
-    template <int dim>
-    bool
-    TanGurnis<dim>::
-    is_compressible () const
-    {
-      return Di != 0.0;
-    }
-
-
-
-    template <int dim>
-    double
-    TanGurnis<dim>::
-    parameter_a() const
-    {
-      return a;
-    }
-
-
-
-    template <int dim>
-    double
-    TanGurnis<dim>::
-    parameter_wavenumber() const
-    {
-      return wavenumber;
-    }
-
-
-
-    template <int dim>
-    double
-    TanGurnis<dim>::
-    parameter_Di() const
-    {
-      return Di;
-    }
-
-
-
-    template <int dim>
-    double
-    TanGurnis<dim>::
-    parameter_gamma() const
-    {
-      return gamma;
-    }
-
-
-
-    template <int dim>
-    void
-    TanGurnis<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Tan Gurnis model");
-        {
-          prm.declare_entry ("a", "0",
-                             Patterns::Double (0),
-                             "");
-          prm.declare_entry ("Di", "0.5",
-                             Patterns::Double (0),
-                             "");
-          prm.declare_entry ("gamma", "1",
-                             Patterns::Double (0),
-                             "");
-          prm.declare_entry ("wavenumber", "1",
-                             Patterns::Double (0),
-                             "");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    TanGurnis<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Tan Gurnis model");
-        {
-          a                       = prm.get_double("a");
-          Di                      = prm.get_double("Di");
-          gamma                   = prm.get_double("gamma");
-          wavenumber              = prm.get_double("wavenumber");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.density = NonlinearDependence::none;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-    }
-  }
-
-
-  /**
-   * A class that implements a temperature boundary condition for the
-   * tan/gurnis benchmark in a box geometry.
-   *
-   * @ingroup BoundaryTemperatures
-   */
-  template <int dim>
-  class TanGurnisBoundary : public BoundaryTemperature::Interface<dim>
-  {
-    public:
-      double boundary_temperature (const types::boundary_id /*boundary_indicator*/,
-                                   const Point<dim> &position) const override
-      {
-        double wavenumber=1;
-        return sin(numbers::PI*position(dim-1))*cos(numbers::PI*wavenumber*position(0));
-      }
-
-      double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-      double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-  };
-
-  template <int dim>
-  double
-  TanGurnisBoundary<dim>::
-  minimal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
-  {
-    return 0;
-  }
-
-
-
-  template <int dim>
-  double
-  TanGurnisBoundary<dim>::
-  maximal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
-  {
-    return 1;
-  }
-
-
-
-  /*
-   * A postprocessor that evaluates the accuracy of the solution of the
-   * aspect::MaterialModel::TanGurnis material model.
-   *
-   * The implementation writes out the solution to be read in by a matlab
-   * script.
-   */
-  template <int dim>
-  class TanGurnisPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics) override;
-  };
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  TanGurnisPostprocessor<dim>::execute (TableHandler &/*statistics*/)
-  {
-    AssertThrow(Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()) == 1,
-                ExcNotImplemented());
-
-    AssertThrow(Plugins::plugin_type_matches<const MaterialModel::TanGurnis<dim>>(this->get_material_model()),
-                ExcMessage("tan gurnis postprocessor only works with tan gurnis material model"));
-
-    const MaterialModel::TanGurnis<dim> &
-    material_model = Plugins::get_plugin_as_type<const MaterialModel::TanGurnis<dim>>(this->get_material_model());
-
-    double ref=1.0/this->get_triangulation().begin_active()->minimum_vertex_distance();
-
-    std::stringstream output;
-    output.precision (16);
-    output << material_model.parameter_Di() << ' '
-           << material_model.parameter_gamma() << ' '
-           << material_model.parameter_wavenumber() << ' '
-           << material_model.parameter_a();
-
-    // pad the first line to the same number ooutputcolumns as the data below to make MATLAB happy
-    for (unsigned int i=4; i<7+this->get_heating_model_manager().get_active_heating_models().size(); ++i)
-      output<< " -1";
-
-    output<< std::endl;
-    output<< std::scientific;
-
-
-    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-    const unsigned int n_q_points =  quadrature_formula.size();
-    FEValues<dim> fe_values (this->get_mapping(), this->get_fe(),  quadrature_formula,
-                             update_JxW_values | update_values    |
-                             update_gradients  | update_quadrature_points);
-
-    MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
-    MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, this->n_compositional_fields());
-
-    const std::list<std::unique_ptr<HeatingModel::Interface<dim>>> &heating_model_objects = this->get_heating_model_manager().get_active_heating_models();
-
-    std::vector<HeatingModel::HeatingModelOutputs> heating_model_outputs (heating_model_objects.size(),
-                                                                          HeatingModel::HeatingModelOutputs (n_q_points, this->n_compositional_fields()));
-
-    for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          in.reinit(fe_values,cell,this->introspection(),this->get_solution());
-
-          this->get_material_model().evaluate(in, out);
-
-          if (this->get_parameters().formulation_temperature_equation ==
-              Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-            {
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  out.densities[q] = this->get_adiabatic_conditions().density(in.position[q]);
-                }
-            }
-
-          unsigned int index = 0;
-          for (typename std::list<std::unique_ptr<HeatingModel::Interface<dim>>>::const_iterator
-               heating_model = heating_model_objects.begin();
-               heating_model != heating_model_objects.end(); ++heating_model, ++index)
-            {
-              (*heating_model)->evaluate(in, out, heating_model_outputs[index]);
-            }
-
-
-          for (unsigned int q = 0; q < n_q_points; ++q)
-            {
-              output
-                  <<  fe_values.quadrature_point (q) (0)
-                  << ' ' << fe_values.quadrature_point (q) (1)
-                  << ' ' << in.velocity[q][0]
-                  << ' ' << in.velocity[q][1]
-                  << ' ' << fe_values.JxW (q)
-                  << ' ' << in.pressure[q]
-                  << ' ' << in.temperature[q];
-
-              for (unsigned int i = 0; i < heating_model_objects.size(); ++i)
-                output << ' ' << heating_model_outputs[i].heating_source_terms[q];
-
-              output << std::endl;
-            }
-        }
-
-    const std::string filename = this->get_output_directory() + "vel_" +
-                                 Utilities::int_to_string(static_cast<unsigned int>(ref)) +
-                                 ".csv";
-    Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
-
-    return std::make_pair("writing:", "output.csv");
-  }
-
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_POSTPROCESSOR(TanGurnisPostprocessor,
-                                "Tan Gurnis error",
-                                "A postprocessor that compares the solution of the benchmarks from "
-                                "the Tan/Gurnis (2007) paper with the one computed by ASPECT "
-                                "by outputting data that is compared using a matlab script.")
-
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(TanGurnis,
-                                   "Tan Gurnis",
-                                   "A simple compressible material model based on a benchmark"
-                                   " from the paper of Tan/Gurnis (2007). This does not use the"
-                                   " temperature equation, but has a hardcoded temperature.")
-  }
-
-  ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(TanGurnisBoundary,
-                                             "Tan Gurnis",
-                                             "A model for the Tan/Gurnis benchmark.")
-}
diff --git a/benchmarks/tangurnis/tala/tan.prm.bak b/benchmarks/tangurnis/tala/tan.prm.bak
deleted file mode 100644
index 737d7863d79..00000000000
--- a/benchmarks/tangurnis/tala/tan.prm.bak
+++ /dev/null
@@ -1,140 +0,0 @@
-# Listing of Parameters
-# ---------------------
-
-set Additional shared libraries            = ./code/libtangurnis.so
-set Dimension                              = 2
-set CFL number                             = 1.0
-
-# We only need a single time step.
-set Start time                             = 0
-set End time                               = 0.0001
-set Output directory                       = output_tala
-
-# The temperature is prescibed, so we only need to
-# solve the Stokes system
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-
-# In this section we define the adiabatic profiles of temperature,
-# pressure and density. The temperature and pressure profiles are
-# not used for this benchmark (and set to zero).
-# gamma is the grueneisen parameter, which defines the compressibility
-# of the material, and we have to choose the same value for gamma as
-# in the material model below.
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=0.5, gamma=1.0
-    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-# This case of the benchmark uses the truncated anelastic liquid approximation.
-subsection Formulation
-  set Formulation = custom # equivalent to TALA or ALA depending on material model
-  set Mass conservation        = reference density profile
-  set Temperature equation     = reference density profile
-end
-
-# We define our own boundary condition that implements a boundary
-# temperature according to the prescibed temperature of the Tan & Gurnis
-# benchmark.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left, right, bottom, top
-  set List of model names = Tan Gurnis
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-# The model domain is the unit square.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*y)*cos(pi*1*x)
-  end
-end
-
-# The benchmark is defined in terms of the nondimensional numbers
-# Di (dissipation number) and gamma (grueneisen parameter).
-# As ASPECT uses physical properties instead of these dimensionless
-# numbers in its equations, we replicate the benchmark formulation
-# by using a new material model that fixes all of the material
-# constants to 1, except for the thermal expansivity and the viscosity,
-# which is set to Di, and the density profile, which depends on Di and
-# gamma.
-subsection Material model
-  set Model name = Tan Gurnis
-
-  subsection Tan Gurnis model
-    set Di                            = 0.5
-    set gamma                         = 1
-    set a                             = 0   # constant viscosity
-    set wavenumber                    = 1
-  end
-end
-
-# This subsection describes which heating models we want to use.
-# This case includes adiabatic heating and shear heating.
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set List of output variables      = density, adiabat
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/benchmarks/tangurnis/tala_c/tan.prm.bak b/benchmarks/tangurnis/tala_c/tan.prm.bak
deleted file mode 100644
index d5d7f6b1c26..00000000000
--- a/benchmarks/tangurnis/tala_c/tan.prm.bak
+++ /dev/null
@@ -1,139 +0,0 @@
-# Listing of Parameters
-# ---------------------
-
-set Additional shared libraries            = ./code/libtangurnis.so
-set Dimension                              = 2
-set CFL number                             = 1.0
-
-# We only need a single time step.
-set Start time                             = 0
-set End time                               = 0.0001
-
-# The temperature is prescibed, so we only need to
-# solve the Stokes system
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-
-# In this section we define the adiabatic profiles of temperature,
-# pressure and density. The temperature and pressure profiles are
-# not used for this benchmark (and set to zero).
-# gamma is the grueneisen parameter, which defines the compressibility
-# of the material, and we have to choose the same value for gamma as
-# in the material model below.
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=0.5, gamma=1.0
-    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-# This case of the benchmark uses the truncated anelastic liquid approximation.
-subsection Formulation
-  set Formulation = custom # equivalent to TALA or ALA depending on material model
-  set Mass conservation        = reference density profile
-  set Temperature equation     = reference density profile
-end
-
-# We define our own boundary condition that implements a boundary
-# temperature according to the prescibed temperature of the Tan & Gurnis
-# benchmark.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left, right, bottom, top
-  set List of model names = Tan Gurnis
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-# The model domain is the unit square.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*y)*cos(pi*1*x)
-  end
-end
-
-# The benchmark is defined in terms of the nondimensional numbers
-# Di (dissipation number) and gamma (grueneisen parameter).
-# As ASPECT uses physical properties instead of these dimensionless
-# numbers in its equations, we replicate the benchmark formulation
-# by using a new material model that fixes all of the material
-# constants to 1, except for the thermal expansivity and the viscosity,
-# which is set to Di, and the density profile, which depends on Di and
-# gamma.
-subsection Material model
-  set Model name = Tan Gurnis
-
-  subsection Tan Gurnis model
-    set Di                            = 0.5
-    set gamma                         = 1
-    set a                             = 2   # depth-dependent viscosity
-    set wavenumber                    = 1
-  end
-end
-
-# This subsection describes which heating models we want to use.
-# This case includes adiabatic heating and shear heating.
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set List of output variables      = density, adiabat
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc.bak b/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc.bak
deleted file mode 100644
index 7f85d60857b..00000000000
--- a/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc.bak
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "time_dependent_annulus.h"
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(TimeDependentAnnulus,
-                                   "time dependent annulus",
-                                   "This is the material model setup "
-                                   "for the time dependent annular flow benchmark from Section 5 of "
-                                   "``Gassmoeller, Lokavarapu, Bangerth, Puckett (2019): "
-                                   "Evaluating the Accuracy of Hybrid Finite Element/Particle-In-Cell "
-                                   "Methods for Modeling Incompressible Stokes Flow. Geophys. J. Int. "
-                                   "submitted.'' "
-                                   "The model "
-                                   "can either use the analytic density, or whatever is stored in the "
-                                   "first compositional field as the density that enters the Stokes equations. "
-                                   "This allows testing different advection schemes for the density.")
-  }
-
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(TimeDependentAnnulus,
-                                  "time dependent annulus",
-                                  "This is the error postprocessor "
-                                  "for the time dependent annular flow benchmark from Section 5 of "
-                                  "``Gassmoeller, Lokavarapu, Bangerth, Puckett (2019): "
-                                  "Evaluating the Accuracy of Hybrid Finite Element/Particle-In-Cell "
-                                  "Methods for Modeling Incompressible Stokes Flow. Geophys. J. Int. "
-                                  "submitted.'' "
-                                  "Specifically, it can compute the errors for "
-                                  "the velocity, pressure, and density variables.")
-  }
-}
diff --git a/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.h.bak b/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.h.bak
deleted file mode 100644
index 624ad9158bd..00000000000
--- a/benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.h.bak
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-#include <aspect/initial_composition/function.h>
-#include <deal.II/base/parsed_function.h>
-
-
-namespace aspect
-{
-  /**
-   * This is the analytic solution, postprocessor, and material model setup
-   * for the time dependent annular flow benchmark from Section 5 of
-   *
-   * Gassmoeller, Lokavarapu, Bangerth, Puckett (2019):
-   * Evaluating the Accuracy of Hybrid Finite Element/Particle-In-Cell
-   * Methods for Modeling Incompressible Stokes Flow. Geophys. J. Int.
-   * submitted.
-   *
-   * It features a spherical annulus with a circular flow and a
-   * time-independent analytical, but a time-dependent numerical solution,
-   * which allows to quantify how errors in the advection equation
-   * influence the accuracy of the Stokes equation. In this example
-   * the benchmark uses particles to carry density, but it can be
-   * used for other advection methods as well.
-   */
-  namespace AnalyticSolutions
-  {
-    template <int dim>
-    void analytic_solution(
-      double pos[],
-      double vel[],
-      double *pressure,
-      double *density,
-      std::shared_ptr<Functions::ParsedFunction<dim>> pressure_function,
-      std::shared_ptr<Functions::ParsedFunction<dim>> velocity_function,
-      std::shared_ptr<Functions::ParsedFunction<dim>> density_function)
-    {
-      /****************************************************************************************/
-      /****************************************************************************************/
-      /* Output */
-      for (unsigned int i=0; i < dim; i++)
-        vel[i] = velocity_function->value(Point<dim>(pos[0],pos[1]), i);
-
-      (*pressure) = pressure_function->value(Point<dim>(pos[0], pos[1]));
-
-      (*density) = density_function->value(Point<dim>(pos[0], pos[1]));
-    }
-
-    /**
-     * The exact solution for the benchmark.
-     */
-    template <int dim>
-    class FunctionStreamline : public Function<dim>
-    {
-      public:
-        FunctionStreamline (std::shared_ptr<Functions::ParsedFunction<dim>> pressure,
-                            std::shared_ptr<Functions::ParsedFunction<dim>> velocity,
-                            std::shared_ptr<Functions::ParsedFunction<dim>> density,
-                            const unsigned int n_components)
-          :
-          Function<dim>(n_components),
-          pressure_function (pressure),
-          velocity_function (velocity),
-          density_function (density)
-        {}
-
-        void vector_value (const Point<dim> &p,
-                           Vector<double>   &values) const override
-        {
-          double pos[2]= {p(0),p(1)};
-
-          AnalyticSolutions::analytic_solution<dim>
-          (pos,
-           &values[0], &values[2], &values[4], pressure_function, velocity_function, density_function);
-        }
-      private:
-        std::shared_ptr<Functions::ParsedFunction<dim>> pressure_function;
-        std::shared_ptr<Functions::ParsedFunction<dim>> velocity_function;
-        std::shared_ptr<Functions::ParsedFunction<dim>> density_function;
-    };
-  }
-
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class TimeDependentAnnulus : public MaterialModel::Interface<dim>
-    {
-      private:
-        std::shared_ptr<Functions::ParsedFunction<dim>> density_function, pressure_function, velocity_function;
-
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              if (use_analytic_density)
-                out.densities[i] = density_function->value(in.position[i]);
-              else
-                out.densities[i] = in.composition[i][0];
-
-              out.viscosities[i] = 1;
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-
-        bool is_compressible () const override
-        {
-          return false;
-        }
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm)
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("Time dependent annulus");
-            {
-              prm.declare_entry ("Use analytic density", "false",
-                                 Patterns::Bool(),
-                                 "Whether to use the analytic density for the computations, or whatever"
-                                 "density is stored in the first compositional field.");
-
-              prm.enter_subsection("Analytical density");
-              {
-                prm.enter_subsection("Function");
-                {
-                  Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-                }
-                prm.leave_subsection();
-              }
-              prm.leave_subsection();
-
-              prm.enter_subsection("Analytical pressure");
-              {
-                prm.enter_subsection("Function");
-                {
-                  Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-                }
-                prm.leave_subsection();
-              }
-              prm.leave_subsection();
-
-              prm.enter_subsection("Analytical velocity");
-              {
-                prm.enter_subsection("Function");
-                {
-                  Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-                }
-                prm.leave_subsection();
-              }
-              prm.leave_subsection();
-
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Material model");
-          {
-            prm.enter_subsection("Time dependent annulus");
-            {
-              use_analytic_density = prm.get_bool ("Use analytic density");
-
-              prm.enter_subsection("Analytical density");
-              {
-                prm.enter_subsection("Function");
-                {
-                  density_function = std::make_unique<Functions::ParsedFunction<dim>>(1);
-                  density_function->parse_parameters(prm);
-                }
-                prm.leave_subsection();
-              }
-              prm.leave_subsection();
-
-              prm.enter_subsection("Analytical pressure");
-              {
-                prm.enter_subsection("Function");
-                {
-                  pressure_function = std::make_unique<Functions::ParsedFunction<dim>>(1);
-                  pressure_function->parse_parameters(prm);
-                }
-                prm.leave_subsection();
-              }
-              prm.leave_subsection();
-
-              prm.enter_subsection("Analytical velocity");
-              {
-                prm.enter_subsection("Function");
-                {
-                  try
-                    {
-                      velocity_function = std::make_unique<Functions::ParsedFunction<dim>>(dim);
-                      velocity_function->parse_parameters (prm);
-                    }
-                  catch (...)
-                    {
-                      std::cerr << "ERROR: FunctionParser failed to parse\n"
-                                << "\t'Analytical velocity.Function'\n"
-                                << "with expression\n"
-                                << "\t'" << prm.get("Function expression") << "'\n"
-                                << "More information about the cause of the parse error \n"
-                                << "is shown below.\n";
-                      throw;
-                    }
-                }
-                prm.leave_subsection();
-              }
-              prm.leave_subsection();
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          // Declare dependencies on solution variables
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-        /**
-         * Returns the analytic solutions of this model. See the
-         * corresponding member variable of this class for more information.
-         */
-        std::shared_ptr<Functions::ParsedFunction<dim>>  get_pressure() const
-        {
-          return pressure_function;
-        }
-
-        std::shared_ptr<Functions::ParsedFunction<dim>>  get_velocity() const
-        {
-          return velocity_function;
-        }
-
-        std::shared_ptr<Functions::ParsedFunction<dim>>  get_density() const
-        {
-          return density_function;
-        }
-
-      private:
-        /**
-         * Whether to use the analytic density for the benchmark or whatever density is
-         * stored in the first compositional field.
-         */
-        bool use_analytic_density;
-    };
-  }
-
-  namespace Postprocess
-  {
-    /**
-     * A postprocessor that evaluates the accuracy of the solution.
-     *
-     */
-    template <int dim>
-    class TimeDependentAnnulus : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      private:
-        std::shared_ptr<Function<dim>> ref_func;
-
-      public:
-        void
-        initialize () override
-        {
-          const MaterialModel::TimeDependentAnnulus<dim> &material_model =
-            Plugins::get_plugin_as_type<const MaterialModel::TimeDependentAnnulus<dim>>(this->get_material_model());
-
-          ref_func = std::make_unique<AnalyticSolutions::FunctionStreamline<dim>>(material_model.get_pressure(),
-                                                                                   material_model.get_velocity(),
-                                                                                   material_model.get_density(),
-                                                                                   1 + dim + 1 + this->n_compositional_fields());
-        }
-
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override
-        {
-          const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.velocities).degree+2);
-
-          Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-          Vector<float> cellwise_errors_rhol2 (this->get_triangulation().n_active_cells());
-
-          ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                              this->get_fe().n_components());
-          ComponentSelectFunction<dim> comp_p(dim, this->get_fe().n_components());
-          ComponentSelectFunction<dim> comp_rho(dim+2, this->get_fe().n_components());
-
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_ul2,
-                                             quadrature_formula,
-                                             VectorTools::L2_norm,
-                                             &comp_u);
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_pl2,
-                                             quadrature_formula,
-                                             VectorTools::L2_norm,
-                                             &comp_p);
-          VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                             this->get_solution(),
-                                             *ref_func,
-                                             cellwise_errors_rhol2,
-                                             quadrature_formula,
-                                             VectorTools::L2_norm,
-                                             &comp_rho);
-
-          const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-          const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-          const double rho_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_rhol2, VectorTools::L2_norm);
-
-          statistics.add_value ("Error_u_l2", u_l2);
-          statistics.add_value ("Error_p_l2", p_l2);
-          statistics.add_value ("Error_rho_l2", rho_l2);
-
-          statistics.set_scientific ("Error_u_l2", true);
-          statistics.set_scientific ("Error_p_l2", true);
-          statistics.set_scientific ("Error_rho_l2", true);
-
-          std::ostringstream os;
-          os << std::scientific
-             << u_l2
-             << ", " << p_l2
-             << ", " << rho_l2;
-
-          return std::make_pair("Errors u_L2, p_L2, rho_L2", os.str());
-        }
-    };
-  }
-}
diff --git a/benchmarks/time_dependent_annulus/time_dependent_annulus.prm.bak b/benchmarks/time_dependent_annulus/time_dependent_annulus.prm.bak
deleted file mode 100644
index 7e9b37ee662..00000000000
--- a/benchmarks/time_dependent_annulus/time_dependent_annulus.prm.bak
+++ /dev/null
@@ -1,179 +0,0 @@
-# This is the setup of the time dependent annular flow benchmark
-# from Section 5 of
-#
-# Gassmoeller, Lokavarapu, Bangerth, Puckett (2019):
-# Evaluating the Accuracy of Hybrid Finite Element/Particle-In-Cell
-# Methods for Modeling Incompressible Stokes Flow. Geophys. J. Int.
-# submitted.
-#
-# It features a spherical annulus with a circular flow and a
-# time-independent analytical, but a time-dependent numerical solution,
-# which allows to quantify how errors in the advection equation
-# influence the accuracy of the Stokes equation. In this example
-# the benchmark uses particles to carry density, but it can be
-# used for other advection methods as well.
-
-
-set Additional shared libraries = ./plugin/libtime_dependent_annulus.so
-set Dimension                              = 2
-set End time                               = 0.09817477042468103
-set Output directory                       = output-time_dependent_annulus
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 1
-    set Outer radius = 2
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function
-
-  subsection Function
-    set Function constants  = pi=3.1415926
-    set Variable names      = x,y
-    set Function expression = y*sqrt(x^2 + y^2)^6;-x*sqrt(x^2 + y^2)^6
-  end
-end
-
-subsection Material model
-  set Model name = time dependent annulus
-  set Material averaging = none
-
-  subsection Time dependent annulus
-    set Use analytic density = false
-
-    subsection Analytical density
-      subsection Function
-        set Variable names = x, y
-        set Function expression = 48*sqrt(x^2 + y^2)^5
-      end
-    end
-
-    subsection Analytical pressure
-      subsection Function
-        # The term 512/72 causes the pressure to be zero at the outer boundary R = 2
-        set Function expression = (sqrt(x^2 + y^2)^9)/72 - 512/72
-      end
-    end
-
-    subsection Analytical velocity
-      subsection Function
-        set Variable names = x, y
-        set Function expression = y*sqrt(x^2 + y^2)^6;-x*sqrt(x^2 + y^2)^6
-      end
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = (x*(x^2 + y^2)/384) + (-y/sqrt(x^2 + y^2)); \
-                              (y*(x^2 + y^2)/384) + (x/sqrt(x^2 + y^2))
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_comp
-  set Compositional field methods = particles
-  set Mapped particle properties = density_comp:function[0]
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 48*sqrt(x^2 + y^2)^5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0; 0; 0
-    set Variable names      = depth
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-  set Use locally conservative discretization = false
-  set Use discontinuous composition discretization = true
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement   = 3
-  set Initial adaptive refinement = 0
-  set Time steps between mesh refinement = 0
-  set Refinement fraction         = 0
-  set Coarsening fraction         = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = time dependent annulus, particles, visualization
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Number of grouped files       = 1
-    set Time between graphical output = 0.0009817477042468104
-    set List of output variables      = density, gravity
-  end
-
-  subsection Particles
-    set Time between data output = 0.0009817477042468104
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-end
-
-subsection Checkpointing
-  set Time between checkpoint  = 7200
-end
-
-subsection Particles
-  set Integration scheme = rk2 # or rk4
-  set Interpolation scheme = bilinear least squares # or cell average
-  set List of particle properties = function
-  set Update ghost particles = true
-  set Particle generator name = reference cell
-  set Load balancing strategy = none # not necessary for uniform mesh
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 4 # or 5, 6, 7, 10, 15, 20, 32, 45, 64, 80
-    end
-  end
-
-  subsection Function
-    set Number of components = 2
-    set Variable names      = x,y
-    set Function expression = 48*sqrt(x^2 + y^2)^5;if(0<y,if(y<1/4,1,0),0)
-  end
-end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak
deleted file mode 100644
index 07bece2410e..00000000000
--- a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case1.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-include Tosi_base.prm
-
-set Additional shared libraries            = ./libtosi_benchmark.so
-set Output directory                       = Case1_5
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-end
-
-# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
-# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity constant" ($\eta^*$)
-# are varied, see Eq. (6-8) and Table 1 of the paper.
-subsection Material model
-  set Model name = TosiMaterial
-
-  subsection Tosi benchmark
-    set Pressure viscosity parameter  = 1
-    set Yield stress          = 0
-    set Nonlinear viscosity constant  = 0
-  end
-end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak
deleted file mode 100644
index bd4670b4c7c..00000000000
--- a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case2.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-include Tosi_base.prm
-
-set Additional shared libraries            = ./libtosi_benchmark.so
-set Output directory                       = Case2_4
-
-# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
-# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity constant" ($\eta^*$)
-# are varied, see Eq. (6-8) and Table 1 of the paper.
-subsection Material model
-  subsection Tosi benchmark
-    set Pressure viscosity parameter  = 1
-    set Yield stress          = 1
-    set Nonlinear viscosity constant  = 1e-3
-    set Initial viscosity        = 0.115
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak
deleted file mode 100644
index 361b9d8924e..00000000000
--- a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case3.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-include Tosi_base.prm
-
-set Additional shared libraries            = ./libtosi_benchmark.so
-set Output directory                       = Case3_6
-
-# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
-# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity parameter" ($\eta^*$)
-# are varied, see Eq. (6-8) and Table 1 of the paper.
-subsection Material model
-  set Model name = TosiMaterial
-
-  subsection Tosi benchmark
-    set Pressure viscosity parameter  = 10
-    set Yield stress          = 0
-    set Nonlinear viscosity constant  = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 6
-end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak
deleted file mode 100644
index e509c3e0a09..00000000000
--- a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case4.prm.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-include Tosi_base.prm
-
-set Additional shared libraries            = ./libtosi_benchmark.so
-set Output directory                       = Case4_6
-
-# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
-# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity parameter" ($\eta^*$)
-# are varied, see Eq. (6-8) and Table 1 of the paper.
-subsection Material model
-  set Model name = TosiMaterial
-
-  subsection Tosi benchmark
-    set Pressure viscosity parameter  = 10
-    set Yield stress          = 1
-    set Nonlinear viscosity constant  = 1e-3
-    set Initial viscosity        = 1e-1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 6
-end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak
deleted file mode 100644
index 4b06c0c01b1..00000000000
--- a/benchmarks/tosi_et_al_2015_gcubed/Tosi_Case5.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-include Tosi_base.prm
-
-set Additional shared libraries            = ./libtosi_benchmark.so
-set Output directory                       = Case5_6
-
-# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
-# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity parameter" ($\eta^*$)
-# are varied, see Eq. (6-8) and Table 1 of the paper.
-subsection Material model
-  set Model name = TosiMaterial
-
-  subsection Tosi benchmark
-    set Pressure viscosity parameter  = 10
-    set Yield stress          = 4
-    set Nonlinear viscosity constant  = 1e-3
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 6
-end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm.bak
deleted file mode 100644
index 6c0bb5b85bd..00000000000
--- a/benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm.bak
+++ /dev/null
@@ -1,175 +0,0 @@
-# A description of viscoplastic convection in a 2d box as
-# described in Tosi et al. (2015).
-# Tosi, N., et al. (2015),
-# A community benchmark for viscoplastic thermal
-# convection in a 2-D square box,
-# Geochem. Geophys. Geosyst., 16, 2175–2196,
-# doi:10.1002/2015GC005807.
-
-# We add the necessary plugins through a shared library
-set Additional shared libraries            = ./libtosi_benchmark.so
-
-# This is a 2D benchmark.
-set Dimension                              = 2
-
-# We run the model from time = 0 to time = 1 and to handle
-# the nonlinearity of the viscosity correctly, we use
-# the iterated Advection and Stokes nonlinear solver with 200 cheap
-# Stokes solves.
-set Use years in output instead of seconds = false
-set End time                               = 1
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 30
-set Nonlinear solver tolerance             = 1e-5
-
-# We choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps    = 200
-    set Linear solver tolerance                = 1e-6
-  end
-end
-
-# Our model domain is the unit square.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# We prescribe a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation with amplitude A.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = A=0.01, pi=3.1415926536
-    set Function expression = (1.0-z) + A*cos(pi*x)*sin(pi*z)
-  end
-end
-
-# The top and bottom boundary carry a prescribed boundary temperature, whereas
-# all other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-# The temperature at the bottom is set to 1; at the top to 0.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  # Here, all four sides of the box allow tangential
-  # unrestricted flow but with a zero normal component:
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# Gravity is vertical and of magnitude 1e8.
-# The Rayleigh number is defined as
-# $Ra = \frac{\rho g \alpha \Delta_T D^3}{\kappa \eta_0}$,
-# with $\rho$ the density, g the gravity magnitude, $\alpha$ thermal
-# expansivity, $\Delta_T$ the temperature contrast across the mantle and D the domain height.
-# $\eta_0$ is the reference viscosity and $\kappa$ the thermal diffusivity.
-# With the parameter values in this and the next section, this leads to
-# $Ra = \frac{1 * 1e8 * 1e-6 * 1 * 1^3}{\frac{1}{1*1} * 1e-1} = 100$.
-# Note that $\eta_0$ is not the same as the Tosi material model "Reference viscosity".
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e8
-  end
-end
-
-# Each case has a surface Rayleigh number of 100
-# and the parameter controlling the temperature
-# dependence of viscosity "Thermal viscosity parameter"
-# is always 1e5.
-# Between the cases the "Pressure viscosity parameter" ($\Delta_{\eta}_z$),
-# the "Yield stress" ($\sigma_y$) and the "Nonlinear viscosity constant" ($\eta^*$)
-# are varied, see Eq. (6-8) and Table 1 of the paper.
-subsection Material model
-  set Model name = TosiMaterial
-
-  subsection Tosi benchmark
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-06
-    set Thermal viscosity parameter   = 1e5
-    set Initial viscosity        = 1e-1
-    set Minimum viscosity        = 1e-6
-    set Maximum viscosity        = 10
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.05. Given
-# our start time (0.0) and final time (1.0) this means that
-# we will obtain 20 output files.
-#
-# The statistics file includes the data reported in Tosi et al. (2015):
-# - average temperature (temperature statistics)
-# - top and bottom Nusselt numbers (heat flux statistics)
-# - Vrms over the whole domain (velocity statistics)
-# - Vrms along the surface (velocity boundary statistics)
-# - Vmax along the surface (velocity boundary statistics)
-# - average rate of viscous dissipation (TosiPostprocessor)
-# - average rate of work against gravity (TosiPostprocessor)
-# - percentage error difference work and dissipation (TosiPostprocessor)
-#
-# Tosi et al. (2015) also report depth averages; averages for viscosity
-# and temperature are produced every 0.05 units of time.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, \
-                               visualization, TosiPostprocessor, depth average, velocity boundary statistics
-
-  subsection Depth average
-    set List of output variables = temperature, viscosity
-    set Time between graphical output = 0.05
-    set Number of zones = 10
-  end
-
-  subsection Visualization
-    set List of output variables = viscosity, strain rate, density, specific heat, thermal expansivity, gravity, heating
-    set Time between graphical output = 0.05
-  end
-end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/doc/tosi_benchmark_2.prm.bak b/benchmarks/tosi_et_al_2015_gcubed/doc/tosi_benchmark_2.prm.bak
deleted file mode 100644
index 6a257bb5dc1..00000000000
--- a/benchmarks/tosi_et_al_2015_gcubed/doc/tosi_benchmark_2.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Material model
-  subsection Tosi benchmark
-    set Pressure viscosity parameter  = 1
-    set Yield stress          = 1
-    set Nonlinear viscosity constant  = 1e-3
-    set Initial viscosity        = 0.115
-  end
-end
diff --git a/benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak b/benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak
deleted file mode 100644
index 75202bb88e8..00000000000
--- a/benchmarks/tosi_et_al_2015_gcubed/tosi.cc.bak
+++ /dev/null
@@ -1,722 +0,0 @@
-/*
-  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/global.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/newton.h>
-
-#include <aspect/simulator_access.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/text_iarchive.hpp>
-
-namespace aspect
-{
-  /**
-   * This is the material model used for the viscoplastic convection
-   * benchmark models that were presented in the open access Tosi et al. (2015) paper:
-   * @code
-   *  @Article{T15,
-   *    Author = {Tosi, N. and Stein, C. and Noack, L. and H\"uttig, C. and Maierova, P. and Samuel, H. and Davies, D. R. and Wilson, C. R. and Kramer, S. C. and Thieulot, C. and Glerum, A. and Fraters, M. and Spakman, W. and Rozel, A. and Tackley, P. J.},
-   *    Title = {A community benchmark for viscoplastic thermal convection in a 2-D square box},
-   *    Journal = {Geochemistry, Geophysics, Geosystems},
-   *    Year = {2015}
-   *    Pages = {2175-2196},
-   *    Volume = {16},
-   *    Doi = {10.1002/2015GC005807}}
-   * @endcode
-   *
-   * It is a material model that consists of globally constant values for all
-   * material parameters except density and viscosity. Density is temperature dependent,
-   * but practically constant through a small value of the thermal expansivity,
-   * and viscosity depends on temperature, depth and strain rate.
-   *
-   * The model is considered incompressible, following the definition
-   * described in Interface::is_compressible.
-   *
-   * @ingroup MaterialModels
-   */
-  namespace TosiBenchmark
-  {
-    using namespace dealii;
-
-
-    /**
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class TosiMaterial : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          /**
-           * As described in Tosi et al (2015), the viscosity \eta is computed as the
-           * harmonic average of a linear and nonlinear part.
-           *
-           * The linear part is calculated as follows
-           * (see below for the meaning of the used parameter names):
-           * $\eta_{lin}(T,z) = \exp(-\ln(\text{eta\_T} * T + \ln(\text{eta\_Z}) * z)$
-           * while the strain rate dependent nonlinear part is computed as:
-           * $\eta_{plast}(\dot\epsilon) = \text{eta\_asterisk} + \frac{\text{sigma\_yield}}{\sqrt(\dot\epsilon:\dot\epsilon)}$
-           */
-
-          //set up additional output for the derivatives
-          MaterialModel::MaterialModelDerivatives<dim> *derivatives;
-          derivatives = out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              if (in.requests_property(MaterialModel::MaterialProperties::viscosity))
-                {
-                  out.viscosities[i] = viscosity (in.temperature[i],
-                                                  in.pressure[i],
-                                                  in.composition[i],
-                                                  in.strain_rate[i],
-                                                  in.position[i]);
-                }
-
-              out.densities[i] = reference_rho * (1.0 - thermal_alpha * (in.temperature[i] - reference_T));
-              out.thermal_expansion_coefficients[i] = thermal_alpha;
-              out.specific_heat[i] = reference_specific_heat;
-              out.thermal_conductivities[i] = thermal_k;
-              out.compressibilities[i] = 0.0;
-              // Pressure derivative of entropy at the given positions.
-              out.entropy_derivative_pressure[i] = 0.0;
-              // Temperature derivative of entropy at the given positions.
-              out.entropy_derivative_temperature[i] = 0.0;
-              // Change in composition due to chemical reactions at the
-              // given positions. The term reaction_terms[i][c] is the
-              // change in compositional field c at point i.
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                out.reaction_terms[i][c] = 0.0;
-
-              // If requested compute viscosity derivatives. This is only important
-              // if using the Newton solver.
-              if (derivatives != nullptr && in.requests_property(MaterialModel::MaterialProperties::viscosity))
-                {
-                  if (use_analytical_derivative)
-                    {
-                      if (in.strain_rate[i].norm() == 0)
-                        {
-                          derivatives->viscosity_derivative_wrt_strain_rate[i] = 0;
-                          derivatives->viscosity_derivative_wrt_pressure[i] = 0;
-                        }
-                      else
-                        {
-                          const double deviator_strain_rate_norm = in.strain_rate[i].norm();
-                          const double part1 = (eta_asterisk * deviator_strain_rate_norm + sigma_yield);
-
-                          derivatives->viscosity_derivative_wrt_strain_rate[i] = -(0.5*out.viscosities[i]*out.viscosities[i])
-                                                                                 * (sigma_yield/(part1 * part1 * deviator_strain_rate_norm)) * in.strain_rate[i];
-                          derivatives->viscosity_derivative_wrt_pressure[i] = 0;
-                        }
-                    }
-                  else
-                    {
-                      // finite difference derivative
-                      const double finite_difference_accuracy = 1e-7;
-
-                      SymmetricTensor<2,dim> &deta = derivatives->viscosity_derivative_wrt_strain_rate[i];
-
-                      // derivative in xx direction
-                      SymmetricTensor<2,dim> dstrain_rate = in.strain_rate[i];
-                      dstrain_rate[0][0] += std::fabs(in.strain_rate[i][0][0]) * finite_difference_accuracy;
-                      const double eta_zero_zero = viscosity(in.temperature[i], in.pressure[i], in.composition[i], dstrain_rate, in.position[i]);
-                      deta[0][0] = eta_zero_zero - out.viscosities[i];
-
-                      if (dstrain_rate[0][0] != 0)
-                        deta[0][0] /= std::fabs(in.strain_rate[i][0][0]) * finite_difference_accuracy;
-                      else
-                        deta[0][0] = 0;
-
-                      // derivative in xy direction
-                      dstrain_rate = in.strain_rate[i];
-                      // dstrain_rate in yx direction is multiplied by 0.5, because the symmetric tensor
-                      // is modified by 0.5 in xy and yx direction simultaneously and we compute the combined
-                      // derivative
-                      dstrain_rate[1][0] += 0.5 * std::fabs(in.strain_rate[i][1][0]) * finite_difference_accuracy;
-                      const double eta_one_zero = viscosity(in.temperature[i], in.pressure[i], in.composition[i], dstrain_rate, in.position[i]);
-                      deta[1][0] = eta_one_zero - out.viscosities[i];
-
-                      if (dstrain_rate[1][0] != 0)
-                        deta[1][0] /= std::fabs(in.strain_rate[i][1][0]) * finite_difference_accuracy;
-                      else
-                        deta[1][0] = 0;
-
-                      // derivative in yy direction
-                      dstrain_rate = in.strain_rate[i];
-                      dstrain_rate[1][1] += std::fabs(in.strain_rate[i][1][1]) * finite_difference_accuracy;
-                      const double eta_one_one = viscosity(in.temperature[i], in.pressure[i], in.composition[i], dstrain_rate, in.position[i]);
-                      deta[1][1] = eta_one_one - out.viscosities[i];
-
-                      if (dstrain_rate[1][1] != 0)
-                        deta[1][1] /= std::fabs(in.strain_rate[i][1][1]) * finite_difference_accuracy;
-                      else
-                        deta[1][1] = 0;
-
-                      derivatives->viscosity_derivative_wrt_pressure[i] = 0;
-                    }
-                }
-
-            }
-
-        }
-
-
-
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        double viscosity (const double                  temperature,
-                          const double                  pressure,
-                          const std::vector<double>    &compositional_fields,
-                          const SymmetricTensor<2,dim> &strain_rate,
-                          const Point<dim>             &position) const;
-
-        /*
-         * Function to compute the linear viscosity
-         * according to equation (7) of Tosi et al. 2015.
-         */
-        double viscolin(const double etaT,
-                        const double etaZ,
-                        const double T,
-                        const double depth) const;
-
-        /*
-         * Function to compute the plastic viscosity
-         * according to equation (8) of the paper.
-         */
-        double viscoplast(const double eta_asterisk,
-                          const double stress_y,
-                          const double strain_rate_norm) const;
-
-        /**
-         * The density at reference temperature
-         */
-        double reference_rho;
-
-        /*
-         * The reference temperature
-         */
-        double reference_T;
-
-        /*
-         * The thermal expansivity
-         */
-        double thermal_alpha;
-
-        /*
-         * The reference specific heat
-         */
-        double reference_specific_heat;
-
-        /**
-         * The thermal conductivity.
-         */
-        double thermal_k;
-
-        /*
-         * The linear viscosity parameter pertaining to
-         * the viscosity contrast due to temperature
-         */
-        double eta_T;
-
-        /*
-         * The linear viscosity parameter pertaining to
-         * the viscosity contrast due to pressure (depth)
-         */
-        double eta_Z;
-
-        /*
-         * The effective viscosity at high stresses that is
-         * part of the plastic viscosity
-         */
-        double eta_asterisk;
-
-        /*
-         * The constant yield stress that is used in the
-         * plastic viscosity formula
-         */
-        double sigma_yield;
-
-        /*
-         * The lower viscosity cut-off value
-         */
-        double eta_minimum;
-
-        /*
-         * The upper viscosity cut-off value
-         */
-        double eta_maximum;
-
-        /*
-         * The initial guess of the viscosity
-         */
-        double eta_initial;
-
-        /**
-         * Whether to use analytical or finite-difference viscosity derivatives
-         * if the Newton solver is used.
-         */
-        bool use_analytical_derivative;
-
-    };
-
-    /*
-     * Function to calculate the viscosity according
-     * to equation (6) of the paper.
-     */
-    template <int dim>
-    double
-    TosiMaterial<dim>::
-    viscosity (const double temperature,
-               const double,
-               const std::vector<double> &,
-               const SymmetricTensor<2,dim> &strain_rate,
-               const Point<dim> &) const
-    {
-
-      // In the first nonlinear iteration of the (pre-refinement steps of the) first time step,
-      // strain rate is zero, so we set viscosity to eta_initial, a user-defined guess of the viscosity.
-      if (strain_rate.norm() == 0)
-        {
-          return eta_initial;
-        }
-
-      // Otherwise we compute the linear viscosity and, if needed, the plastic viscosity.
-      double viscosity = 0.0;
-      const double visc_linear = viscolin(eta_T,eta_Z,temperature,0);
-
-      if (eta_asterisk == 0.0 && sigma_yield == 0.0)
-        {
-          viscosity = visc_linear;
-        }
-      else
-        {
-          const double visc_plastic = viscoplast(eta_asterisk,sigma_yield,strain_rate.norm());
-
-          // Compute the harmonic average (equation (6) of the paper)
-          viscosity = 2.0 / ((1.0 / visc_linear) + (1.0 / visc_plastic));
-        }
-
-      // Cut-off the viscosity by user-defined values to avoid possible very large viscosity ratios
-      viscosity = std::max(std::min(viscosity,eta_maximum),eta_minimum);
-
-      return viscosity;
-    }
-
-    /*
-     * Function to compute the linear viscosity
-     * according to equation (7) of Tosi et al. 2015.
-     */
-    template <int dim>
-    double
-    TosiMaterial<dim>::
-    viscolin(const double etaT,
-             const double etaZ,
-             const double T,
-             const double z) const
-    {
-
-      return std::exp((-1.0 * std::log(etaT) * T ) + (std::log(etaZ) * z));
-    }
-
-    /*
-     * Function to compute the plastic viscosity
-     * according to equation (8) of the paper.
-     */
-    template <int dim>
-    double
-    TosiMaterial<dim>::
-    viscoplast(const double etaasterisk,
-               const double stressy,
-               const double strainratenorm) const
-    {
-      return etaasterisk + (stressy/strainratenorm);
-    }
-
-
-
-    template <int dim>
-    bool
-    TosiMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    TosiMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // Default values are for Case 1 of Tosi et al. (2015).
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Tosi benchmark");
-        {
-          prm.declare_entry ("Reference density", "1",
-                             Patterns::Double (0),
-                             "The value of the reference density $\\rho_0$.");
-          prm.declare_entry ("Reference temperature", "0",
-                             Patterns::Double (0),
-                             "The value of the reference temperature $T_0$. The reference temperature is used "
-                             "in the density calculation.");
-          prm.declare_entry ("Minimum viscosity", "1e-6",
-                             Patterns::Double (0),
-                             "The value of the minimum cut-off viscosity $\\eta_min$.");
-          prm.declare_entry ("Maximum viscosity", "1e1",
-                             Patterns::Double (0),
-                             "The value of the maximum cut-off viscosity $\\eta_max$.");
-          prm.declare_entry ("Initial viscosity", "1e-1",
-                             Patterns::Double (0),
-                             "The value of the initial viscosity guess $\\eta_init$.");
-          prm.declare_entry ("Thermal conductivity", "1",
-                             Patterns::Double (0),
-                             "The value of the thermal conductivity $k$.");
-          prm.declare_entry ("Reference specific heat", "1",
-                             Patterns::Double (0),
-                             "The value of the specific heat $cp$.");
-          prm.declare_entry ("Thermal expansion coefficient", "1e-6",
-                             Patterns::Double (0),
-                             "The value of the thermal expansion coefficient $\\alpha$.");
-          prm.declare_entry ("Thermal viscosity parameter", "1e5",
-                             Patterns::Double (0),
-                             "The value of the thermal viscosity parameter $\\eta_T$, "
-                             "as used in equation (7) of the paper.");
-          prm.declare_entry ("Pressure viscosity parameter", "1e0",
-                             Patterns::Double (0),
-                             "The value of the pressure viscosity parameter $\\eta_Z$, "
-                             "as used in equation (7) of the paper.");
-          prm.declare_entry ("Yield stress", "0",
-                             Patterns::Double (0),
-                             "The value of the plastic viscosity yield stress $\\sigma_yield$, "
-                             "as used in equation (8) of the paper.");
-          prm.declare_entry ("Nonlinear viscosity constant", "0",
-                             Patterns::Double (0),
-                             "The value of the plastic viscosity constant $\\eta_asterisk$, "
-                             "as used in equation (8) of the paper.");
-          prm.declare_entry ("Use analytical derivative", "false",
-                             Patterns::Bool (),
-                             "Whether to use the analytical or the finite difference derivative for the Newton method.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    TosiMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Tosi benchmark");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          reference_T                = prm.get_double ("Reference temperature");
-          thermal_k                  = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-          eta_T                      = prm.get_double ("Thermal viscosity parameter");
-          eta_Z                      = prm.get_double ("Pressure viscosity parameter");
-          sigma_yield                = prm.get_double ("Yield stress");
-          eta_asterisk               = prm.get_double ("Nonlinear viscosity constant");
-          eta_minimum                = prm.get_double ("Minimum viscosity");
-          eta_maximum                = prm.get_double ("Maximum viscosity");
-          eta_initial                = prm.get_double ("Initial viscosity");
-          use_analytical_derivative  = prm.get_bool ("Use analytical derivative");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = (sigma_yield != 0.0) ? MaterialModel::NonlinearDependence::strain_rate | MaterialModel::NonlinearDependence::temperature | MaterialModel::NonlinearDependence::pressure : MaterialModel::NonlinearDependence::temperature | MaterialModel::NonlinearDependence::pressure;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::temperature;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-
-    /**
-     * A postprocessor that computes some statistics about the
-     * rate of viscous dissipation, the rate of work done against gravity
-     * and the error between the two. These diagnostic quantities
-     * are reported in the Tosi et al. (2015) paper for a visco-plastic
-     * 2D thermal convection model.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class TosiPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for statistics on the rate of viscous dissipation,
-         * rate of work and the error between the two.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    TosiPostprocessor<dim>::execute (TableHandler &statistics)
-    {
-      AssertThrow(this->get_geometry_model().natural_coordinate_system() == aspect::Utilities::Coordinates::CoordinateSystem::cartesian,
-                  ExcMessage("The current calculation of rate of work only makes sense in a Cartesian geometry."));
-
-      AssertThrow(Plugins::plugin_type_matches<const TosiMaterial<dim>>(this->get_material_model()),
-                  ExcMessage("The current calculation of viscous dissipation is only for incompressible models "
-                             "and specifically computes the difference between work and dissipation as requested "
-                             "in the paper of Tosi et al. 2015."));
-
-      const QGauss<dim> quadrature_formula (this->get_fe()
-                                            .base_element(this->introspection().base_elements.velocities)
-                                            .degree+1);
-
-      const unsigned int n_q_points = quadrature_formula.size();
-      std::vector<Tensor<1,dim>> velocities(n_q_points);
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_gradients |
-                               update_JxW_values);
-
-      // the local integral values of rate of viscous dissipation and work against gravity
-      double local_dissipation_integral = 0.0;
-      double local_work = 0.0;
-
-      // the values of the compositional fields are stored as blockvectors for each field
-      // we have to extract them in this structure
-      std::vector<std::vector<double>> prelim_composition_values (this->n_compositional_fields(),
-                                                                   std::vector<double> (n_q_points));
-
-      typename MaterialModel::Interface<dim>::MaterialModelInputs in(n_q_points,
-                                                                     this->n_compositional_fields());
-      typename MaterialModel::Interface<dim>::MaterialModelOutputs out(n_q_points,
-                                                                       this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-      // loop over active, locally owned cells and
-      // extract material model input and compute integrals
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-
-            // retrieve velocities
-            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                                                                                        velocities);
-
-            // retrieve the input for the material model
-            in.position = fe_values.get_quadrature_points();
-
-            fe_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
-                                                                                      in.pressure);
-
-            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
-                                                                                         in.temperature);
-
-            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-              fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values
-              (this->get_solution(),prelim_composition_values[c]);
-
-            for (unsigned int i=0; i<n_q_points; ++i)
-              {
-                for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                  in.composition[i][c] = prelim_composition_values[c][i];
-              }
-
-            fe_values[this->introspection().extractors.velocities].get_function_symmetric_gradients (this->get_solution(),
-                in.strain_rate);
-
-            // get the output from the material model
-            this->get_material_model().evaluate(in, out);
-
-            // calculate the local viscous dissipation integral and local rate of work against gravity
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                const SymmetricTensor<2,dim> strain_rate_dev = deviator(in.strain_rate[q]);
-                local_dissipation_integral += 2.0 * out.viscosities[q] * strain_rate_dev * strain_rate_dev * fe_values.JxW(q);
-                local_work += in.temperature[q] * velocities[q][dim-1] * fe_values.JxW(q);
-              }
-          }
-
-      // compute the integrals on the whole domain
-      const double viscous_dissipation
-        = Utilities::MPI::sum (local_dissipation_integral, this->get_mpi_communicator());
-
-      const double work
-        = Utilities::MPI::sum(local_work, this->get_mpi_communicator());
-
-      // compute the percentage error between rate of dissipation (divided by the surface rayleigh number of the Tosi et al. (2015)
-      // benchmark (Ra=100)) and rate of work (see equation (21) of the paper)
-      const double error = 100.0 * (std::abs(work - (viscous_dissipation / 100.0)) / std::max(work, viscous_dissipation / 100.0));
-
-      if (this->convert_output_to_years() == true)
-        {
-          // fill statistics file
-          // make sure that the columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.add_value ("Viscous dissipation (J/yr)", viscous_dissipation * year_in_seconds);
-          statistics.set_precision ("Viscous dissipation (J/yr)", 8);
-          statistics.set_scientific ("Viscous dissipation (J/yr)", true);
-          statistics.add_value ("Rate of work (Km/yr)", work * year_in_seconds);
-          statistics.set_precision ("Rate of work (Km/yr)", 8);
-          statistics.set_scientific ("Rate of work (Km/yr)", true);
-          statistics.add_value ("Error", error);
-          statistics.set_precision ("Error", 8);
-          statistics.set_scientific ("Error", true);
-        }
-      else
-        {
-          // fill statistics file
-          // make sure that the columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.add_value ("Viscous dissipation (W)", viscous_dissipation);
-          statistics.set_precision ("Viscous dissipation (W)", 8);
-          statistics.set_scientific ("Viscous dissipation (W)", true);
-          statistics.add_value ("Rate of work (W)", work);
-          statistics.set_precision ("Rate of work (W)", 8);
-          statistics.set_scientific ("Rate of work (W)", true);
-          statistics.add_value ("Error", error);
-          statistics.set_precision ("Error", 8);
-          statistics.set_scientific ("Error", true);
-        }
-
-      std::ostringstream output;
-      output.precision(3);
-      if (this->convert_output_to_years() == true)
-        output << viscous_dissipation *year_in_seconds
-               << " J/yr "
-               << work *year_in_seconds
-               << " J/yr "
-               << error
-               << " error";
-      else
-        output << viscous_dissipation
-               << " W "
-               << work
-               << " W "
-               << error
-               << " error";
-
-      return std::pair<std::string, std::string> ("Viscous dissipation, rate of work, error:",
-                                                  output.str());
-    }
-
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TosiBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(TosiMaterial,
-                                   "TosiMaterial",
-                                   "A material model that has constant values "
-                                   "for all coefficients except the density and viscosity as described in the "
-                                   "open access paper of Tosi et al. 2015. "
-                                   "The default parameter values are chosen according to Case 1 of the paper. "
-                                   "All of the values that define this model are read "
-                                   "from a section ``Material model/Tosi model'' in the input file, see "
-                                   "Section~\\ref{parameters:Material_model/Tosi_model}."
-                                   "\n\n"
-                                   "This model uses the following set of equations for the two coefficients that "
-                                   "are non-constant (see equation (6) - (10) of the paper): "
-                                   "\\begin{align}"
-                                   "  \\eta(T,z,\\dot \\epsilon) &= 2\\frac{1}{\\frac{1}{\\eta_{lin}(T,z)}\\frac{1}{\\eta_{plast}(\\dot\\epsilon}}, \\\\"
-                                   "  \\rho(T) &= \\left(1-\\alpha (T-T_0)\\right)\\rho_0,"
-                                   "\\end{align}"
-                                   "where $z$ represents depth."
-                                   "\n\n"
-                                   "The linear and plastic viscosity parts are defined as follows:"
-                                   "\\begin{align}"
-                                   "  \\eta_{lin}(T,z) &= \\exp(-\\ln(\\eta_T)T+\\ln(\\eta_z)z), \\\\"
-                                   "  \\eta_{plast}(\\dot\\epsilon) &= \\eta^{*}+\\frac{\\sigma_y}{\\sqrt(\\dot\\epsilon : \\dot\\epsilon)} "
-                                   "\\end{align} "
-                                   "\n\n"
-                                   "Note that this model uses the formulation that assumes an incompressible "
-                                   "medium despite the fact that the density follows the law "
-                                   "$\\rho(T)=\\rho_0(1-\\alpha(T-T_0))$. ")
-    ASPECT_REGISTER_POSTPROCESSOR(TosiPostprocessor,
-                                  "TosiPostprocessor",
-                                  "A postprocessor that computes the viscous dissipation"
-                                  "for the whole domain as: "
-                                  "$\\left<\\Phi\\right>=\\int_{V} \\tau : \\dot{\\epsilon}dV$ "
-                                  "= $\\int_{V} 2\\mu\\dot{\\epsilon}:\\dot{\\epsilon} dV$. "
-                                  "Besides the dissipation, for the Tosi et al. (2015) benchmark "
-                                  "the rate of work against gravity is "
-                                  "calculated, as well as the percentage error between the two: "
-                                  "$W$ = $\\int_{V} T u_{y} dV$ and "
-                                  "$\\delta$ = $ \\frac{|W - \\frac{\\left<\\Phi\\right>}{Ra}|}{\\max\\left(\\left<W\\right>,\\frac{\\left<\\Phi\\right>}{Ra}\\right)}$. "
-                                  "This error W should tend to zero if in steady state the thermal energy is accurately preserved."
-                                  "Note that this postprocessor only makes sense for box geometries.")
-  }
-}
diff --git a/benchmarks/viscoelastic_beam_modified/20km_opentopbot.prm.bak b/benchmarks/viscoelastic_beam_modified/20km_opentopbot.prm.bak
deleted file mode 100644
index b27baca2f91..00000000000
--- a/benchmarks/viscoelastic_beam_modified/20km_opentopbot.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# This parameter file modifies the 2D benchmark 'viscoelastic_bending_beam'.
-# It has been modified to model a much larger beam, and to have an open top
-# and bottom boundary to allow the inelastic, low viscosity fluid surrounding the beam to
-# be more easily displaced while the beam flexes.
-#
-# The benchmark examines bending of a viscoelastic beam surrounded by a less dense
-# and viscous (inelastic) fluid. Gravitational forces drive initial bending
-# (elastic strain) of the beam. The analytic solution is from Geodynamics 3rd Edition by
-# Turcotte and Schubert, Chapter 3.10 (eq. 3.85 for flexure and 3.86 for stress).
-# Models have been tested for deflections that are no greater than half the thickness of
-# the beam. More flexure could potentially lead to a breakdown of the fit since the analytic
-# solution assumes small deflection relative to the thickness.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-
-# Global parameters
-set Start time                             = 0
-set End time                               = 200e3
-set Use years in output instead of seconds = true
-set Maximum time step                      = 1e3
-set Output directory                       = 20kmh_05drho
-
-# Model geometry (240x160 km, 1 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 160
-    set Y repetitions = 80
-    set X extent      = 320e3
-    set Y extent      = 160e3
-  end
-end
-
-# Mesh refinement
-subsection Mesh refinement
-  set Initial adaptive refinement        = 3
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 1
-  set Strategy                           = viscosity
-end
-
-# override boundary conditions:
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left
-  set Tangential velocity boundary indicators = right
-end
-
-# Traction Boundary Conditions
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = top: initial lithostatic pressure, bottom: initial lithostatic pressure
-
-  # Set the point for the open top and bottom boundaries
-
-  subsection Initial lithostatic pressure
-    set Representative point = 320e3, 0
-    set Number of integration points = 10000
-  end
-end
-
-# Spatial domain of different compositional fields
-# Make the beam 9x longer than it is wide to ensure the 'thin' approximation is valid
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; if ( 180e3>=x && y>=100e3 && y<=120e3, 1, 0)
-  end
-end
-
-# Material model
-# The density contrast has to be small with such a large beam to preserve the small deflection approximation
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities            =  2800,  2800,  2800,  2800,  2805
-    set Viscosities          = 1.e18, 1.e18, 1.e18, 1.e18, 1.e24
-    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
-  end
-end
-
-# Post processing
-subsection Postprocess
-  subsection Visualization
-    set Number of grouped files = 1
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm.bak b/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm.bak
deleted file mode 100644
index 3eab684ad1d..00000000000
--- a/benchmarks/viscoelastic_beam_modified/20km_opentopbot_weno.prm.bak
+++ /dev/null
@@ -1,33 +0,0 @@
-# This parameter file modifies the benchmark 20kmh_05drho.prm to use the WENO limiter
-# for viscoelastic stress components.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/20km_opentopbot.prm
-
-set Output directory = 20kmh_05drho_weno
-
-
-subsection Discretization
-  subsection Stabilization parameters
-    # Use WENO limiter for viscoelastic stress components, while using the
-    # bound-preserving limiter for the chemical field
-    set Limiter for discontinuous composition solution = WENO, WENO, WENO, bound preserving
-    # In this benchmark, the spurious oscillations at the boundaries of the beam
-    # are extremely serious, so we set the linear weight of neighbor cells one
-    # magnitude greater than the default value to make the reconstructed solution
-    # smoother.
-    set WENO linear weight of neighbor cells = 0.01
-    # The global maximum and minimum values are only used by the chemical field.
-    set Global composition maximum = 1.0
-    set Global composition minimum = 0.0
-  end
-end
-
-# Visualize the KXRCF indicator for ve_stress_xy
-subsection Postprocess
-  subsection Visualization
-    set List of output variables = material properties, strain rate, kxrcf indicator
-    subsection KXRCF indicator
-      set Name of advection field = ve_stress_xy
-    end
-  end
-end
diff --git a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm.bak b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm.bak
deleted file mode 100644
index 3d14a096e72..00000000000
--- a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm.bak
+++ /dev/null
@@ -1,185 +0,0 @@
-# This parameter file reproduces a 2D benchmark for viscoelastic deformation
-# published in "Numerical modelling of magma dynamics coupled to tectonic
-# deformation of lithosphere and crust" by Keller, May and Kaus, 2013,
-# Geophys. J. Int., v. 195,  p. 1406-1422. The model setup and results are
-# described in detail in section B.2.3 and figure B5.
-#
-# The benchmark examines bending and unbending (e.g., recovery) of a
-# viscoelastic beam surrounded by a less dense and viscous (inelastic) fluid.
-# Gravitational forces drive initial bending (elastic strain) of the beam for
-# 50 Kyr, which then recovers its shape over ~ 500 Kyr if gravity is turned
-# off. The recovery is driven by the accumulated elastic stresses and thus
-# provides a basic test for the viscoelasticity implementation.
-#
-# Compositional fields are used to track the viscoelastic stresses and material
-# representing the beam. To improve the accuracy of tracking the beam interface,
-# a discontinuous discretization and bound preserving limiter is used for the
-# compositional fields. Significantly, the time step is limited to 1 Kyr through
-# the "Maximum time step" parameter and a relatively high (0.5) CFL value. Using
-# a constant time step ensures the effective (viscoelastic) viscosity of the
-# viscoelastic beam and viscous fluid remains constants throughout the model run.
-#
-# As currently constructed, the model will run for 50 Kyr with a gravitational
-# acceleration of 10 m/s^2. To produce unbending of the beam after the model
-# has finished, change the parameter "End time" to 500 Kyr and set the
-# gravitational acceleration to 0 m/s^2. A restart file is written every 10 Kyr
-# and the parameter "Resume computation = auto" specifies that a model should
-# restart from a checkpoint file if one is present.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 50e3
-set Use years in output instead of seconds = true
-set Resume computation                     = auto
-set CFL number                             = 0.5
-set Maximum time step                      = 1e3
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0.
-
-# Solver settings
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 2000
-  end
-end
-
-# Model geometry (7.5x5 km, 0.1 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 75
-    set Y repetitions = 50
-    set X extent      = 7.5e3
-    set Y extent      = 5e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree           = 2
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 1
-  set Use locally conservative discretization = false
-  set Use discontinuous temperature discretization = false
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-    set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0
-    set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0
-  end
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left
-  set Tangential velocity boundary indicators = bottom, top, right
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, beam
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; if (x<=4.5e3 && y>=2.5e3 && y<=3.0e3, 1, 0)
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Fixed composition boundary indicators  = bottom, top, right
-  set List of model names                   = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 293
-    set Left temperature   = 293
-    set Right temperature  = 293
-    set Top temperature    = 293
-  end
-end
-
-# Temperature initial conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities            =  2800,  2800,  2800,  2800,  3300
-    set Viscosities          = 1.e18, 1.e18, 1.e18, 1.e18, 1.e24
-    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
-    set Fixed elastic time step     = 1e3
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = maximum composition
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate
-    set Time between graphical output = 0
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 500
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 10
-end
diff --git a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_particles.prm.bak b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_particles.prm.bak
deleted file mode 100644
index f48b09ce194..00000000000
--- a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_particles.prm.bak
+++ /dev/null
@@ -1,41 +0,0 @@
-# This parameter file modifies the benchmark viscoealastic_bending_beam.prm
-# to use particles, rather than compositional fields, to track viscoleastic
-# stresses and location of the beam.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-set Output directory = output_viscoelastic_bending_beam_particles
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 4
-  set Compositional field methods =           particles,           particles,           particles,         particles
-  set Names of fields             =           ve_stress_xx,        ve_stress_yy,        ve_stress_xy,      beam
-  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy, beam:initial beam
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, particles, temperature statistics, visualization
-
-  subsection Particles
-    set Time between data output    = 0
-    set Data output format          = vtu
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell  = 95
-  set Maximum particles per cell  = 105
-  set Load balancing strategy     = remove and add particles
-  set List of particle properties = initial composition, elastic stress
-  set Interpolation scheme        = nearest neighbor
-  set Update ghost particles      = true
-  set Particle generator name     = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 4e5
-    end
-  end
-end
diff --git a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm.bak b/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm.bak
deleted file mode 100644
index d6a698d676f..00000000000
--- a/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam_weno.prm.bak
+++ /dev/null
@@ -1,32 +0,0 @@
-# This parameter file modifies the benchmark viscoealastic_bending_beam.prm
-# to use the WENO limiter for viscoelastic stress components.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-set Output directory = output_viscoelastic_bending_beam_weno
-
-subsection Discretization
-  subsection Stabilization parameters
-    # Use WENO limiter for viscoelastic stress components, while using the
-    # bound-preserving limiter for the chemical field
-    set Limiter for discontinuous composition solution = WENO, WENO, WENO, bound preserving
-    # In this benchmark, the spurious oscillations at the boundaries of the beam
-    # are extremely serious, so we set the linear weight of neighbor cells one
-    # magnitude greater than the default value to make the reconstructed solution
-    # smoother.
-    set WENO linear weight of neighbor cells = 0.01
-    # The global maximum and minimum values are only used by the chemical field.
-    set Global composition maximum = 1.0
-    set Global composition minimum = 0.0
-  end
-end
-
-# Visualize the KXRCF indicator for ve_stress_xy
-subsection Postprocess
-  subsection Visualization
-    set List of output variables = material properties, strain rate, kxrcf indicator
-    subsection KXRCF indicator
-      set Name of advection field = ve_stress_xy
-    end
-  end
-end
diff --git a/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vep.prm.bak b/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vep.prm.bak
deleted file mode 100644
index ac107463d2e..00000000000
--- a/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vep.prm.bak
+++ /dev/null
@@ -1,61 +0,0 @@
-# This parameter file modifies the benchmark gerya_2019_vp.prm
-# to include viscoelasticity.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm
-
-
-#  Global parameters
-set End time                               = 500
-set Output directory                       = output_gerya_2019_vep
-
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, block, air, inclusion
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; \
-                              if ( ( x<43.75e3 && y>25.e3 && y<75.e3) || (x>56.25e3 && y>25.e3 && y<75.e3) || (y>56.25e3 && y<75.e3 && x>=43.75e3 && x<=56.25e3) || (y<43.75e3 && y>25.e3 && x>=43.75e3 && x<=56.25e3), 1, 0); \
-                              if (y<=25.e3 || y>=75.e3, 1, 0); \
-                              if (y<=56.25e3 && y>=43.75e3 && x>=43.75e3 && x<=56.25e3, 1, 0);
-  end
-end
-
-# Material model
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # For identification purposes, nonsensical Prefactor values (1e-50) are assigned to the compositional
-    # fields tracking elastic stresses, which are not included in the volume fractions computation.
-    set Prefactors for dislocation creep          = 5e-24, 1e-50, 1e-50, 1e-50, 5e-24, 5.e-18, 5e-18
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 1e11
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 20
-    set Viscosity averaging scheme  = harmonic
-
-    # Nonsensical cohesion values (1e50) are assigned to the compositional fields tracking elastic stresses
-    set Angles of internal friction = 37.,       0.,    0.,    0.,    37.,    0.,    0.
-    set Cohesions                   = 100.e6, 1.e50, 1.e50, 1.e50, 100.e6, 10.e6, 10.e6
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set Run postprocessors on nonlinear iterations = false
-end
diff --git a/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm.bak b/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm.bak
deleted file mode 100644
index 2768acc033c..00000000000
--- a/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm.bak
+++ /dev/null
@@ -1,190 +0,0 @@
-# Shortening of a visco-plastic block in the absence of gravity
-# modified from Exercise 13.2 in Gerya 2019 (Introduction to
-# Numerical Geodynamic Modeling). The benchmark has been modified
-# to remove viscoelasticity and use slightly different geometries
-# for different materials, which allows the edges of features to
-# always align with the edges of the mesh with additional global
-# refinements. The viscoelastic-plastic version of this setup is
-# provided by gerya_2019_vep.prm within this folder.
-#
-# In detail, the benchmark examines shortening of a viscoelastic
-# plastic (here, visco-plastic) block, which contains a weak
-# inclusion in the center and a weak medium layer (i.e., sticky
-# air) on the top and bottom. The thickness of the weak layers
-# and dimensions of the square inclusion have also been modified
-# so that element edges always align with these material interfaces
-# for uniformly refined meshes of level 3 and up. The velocity on
-# the boundaries is 5e-9 m/s, giving a background strain rate of
-# 1e-13 1/s. The weak medium and weak inclusion have the following
-# material properties: viscosity = 1e17 Pa s, cohesion = 1e7 Pa,
-# and internal friction angle = 0. The visco-plastic block has
-# the following material properties: viscosity = 1e23 Pa s,
-# cohesion = 1e8 Pa, and internal friction angle = 37 degrees.
-# Gravity is set to zero and the average pressure is required
-# to be equal to zero.
-
-#  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 500
-set CFL number                             = 0.5
-set Maximum time step                      = 20
-set Output directory                       = output_gerya_2019_vp
-set Timing output frequency                = 1
-set Pressure normalization                 = volume
-
-# Solver parameters
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block AMG
-    set Linear solver tolerance = 1e-7
-    set Number of cheap Stokes solver steps = 200
-  end
-
-  subsection Newton solver parameters
-    set Max Newton line search iterations        = 0
-    set Max pre-Newton nonlinear iterations      = 500 # Ensures only defect-correction Picard method is used
-    set Maximum linear Stokes solver tolerance   = 1e-2
-    set Nonlinear Newton solver switch tolerance = 1e-5
-    set SPD safety factor                        = 0.9
-    set Stabilization preconditioner             = SPD
-    set Stabilization velocity block             = SPD
-    set Use Newton failsafe                      = false
-    set Use Newton residual scaling method       = false
-    set Use Eisenstat Walker method for Picard iterations = true
-  end
-end
-
-# Model geometry (100x100 km, initial 50 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 2
-    set Y repetitions = 2
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Globally refine the mesh. A minimum of 3 global refinements
-# is needed to resolve the edges of the weak viscous inclusion.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-# Velocity boundary conditions (5e-9 m/s on each boundary)
-# The imposed velocity produces a background strain-rate
-# of 10e-13 1/s.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: function, right x:function, top y: function, bottom y: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = vel=0.15778463
-    set Function expression = if (x<50e3, vel, -vel); if (y<50e3, -vel, vel);
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = block, air, inclusion
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = if ( ( x<43.75e3 && y>25.e3 && y<75.e3) || (x>56.25e3 && y>25.e3 && y<75.e3) || (y>56.25e3 && y<75.e3 && x>=43.75e3 && x<=56.25e3) || (y<43.75e3 && y>25.e3 && x>=43.75e3 && x<=56.25e3), 1, 0); \
-                              if (y<=25.e3 || y>=75.e3, 1, 0); \
-                              if (y<=56.25e3 && y>=43.75e3 && x>=43.75e3 && x<=56.25e3, 1, 0);
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Fixed composition boundary indicators  =
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# Temperature initial conditions (isothermal)
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.
-  end
-end
-
-# Material model
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Densities                   = 2700
-    set Reference strain rate       = 1.e-13
-    set Maximum viscosity           = 1.e23
-    set Minimum viscosity           = 1.e17
-    set Prefactors for dislocation creep          = 5e-24, 5e-24, 5.e-18, 5e-18
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Angles of internal friction = 37.,       37.,    0.,    0.
-    set Cohesions                   = 100.e6, 100.e6, 10.e6, 10.e6
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, velocity statistics, visualization
-  set Run postprocessors on nonlinear iterations = true
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate, named additional outputs
-    set Time between graphical output = 0e3
-    set Interpolate output            = true
-    set Write higher order output     = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp_damper.prm.bak b/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp_damper.prm.bak
deleted file mode 100644
index 86000583382..00000000000
--- a/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp_damper.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-# This parameter file modifies the benchmark gerya_2019_vp.prm
-# to include a viscous damper in the plastic viscosity calculation.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm
-
-set Output directory = output_gerya_2019_damper
-
-subsection Mesh refinement
-  set Initial global refinement = 5
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Allow negative pressures in plasticity = true
-    set Use plastic damper = true
-    set Plastic damper viscosity = 1e19
-  end
-end
diff --git a/benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm.bak b/benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm.bak
deleted file mode 100644
index f60c43f46c0..00000000000
--- a/benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm.bak
+++ /dev/null
@@ -1,238 +0,0 @@
-# This parameter file examines shear band development in a viscoelastic-plastic
-# medium that contains a weak viscous inclusion. The experiment is based
-# directly on the setup used in Kaus, 2010, Tectonophysics, v. 484, p. 36-47.
-# This paper examines both compressional and extensional test cases, and this
-# parameter file examines the extensional case. One notable exception to the
-# Kaus et al. models and this setup is the lack of cohesion strain-softerning,
-# which helps localize deformation along the shear bands.
-#
-# The key feature of the model is the inclusion of viscoelasticity,
-# which leads to a gradual (as opposed to instantaneous for visco-plasticity)
-# development of the plastic shear bands above the weak viscous inclusion.
-# Kaus (2010) and many other studies (e.g., Glerum et al. 2018, Solid Earth)
-# have shown that the shear band angle is directly dependent on the mesh
-# resolution. Here, the model contains a very coarse resolution of 100x25
-# grid points (0.4 km grid spacing. Increasing the "Initial global refinement"
-# parameter from 0 to 1 or 2 (resolution increases by 2x or 4x) should lead
-# to an increase in the shear band angle from 45 degrees to close to 60
-# degrees. Additional key features of the model include the use of the
-# Newton solver for improved nonlinear solver convergence and a plastic
-# damper term (Duretz et al., 2019) to provide a quasi length-scale
-# and smoother viscosity for plastic shear bands.
-
-#  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20e3
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
-set Nonlinear solver tolerance             = 1e-4
-set Max nonlinear iterations               = 100
-set CFL number                             = 0.5
-set Maximum time step                      = 1000
-set Output directory                       = output_kaus_2010_extension
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-
-# Solver settings
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type                  = block AMG
-    set Number of cheap Stokes solver steps = 2000
-    set Linear solver tolerance             = 1e-7
-    set GMRES solver restart length         = 50
-    set Use full A block as preconditioner  = true
-  end
-
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations      = 5
-    set SPD safety factor                        = 0.9
-    set Nonlinear Newton solver switch tolerance = 1e-4
-    set Max Newton line search iterations        = 5
-    set Maximum linear Stokes solver tolerance   = 1e-7
-    set Use Newton residual scaling method       = false
-    set Use Newton failsafe                      = true
-    set Stabilization preconditioner             = SPD
-    set Stabilization velocity block             = SPD
-    set Use Eisenstat Walker method for Picard iterations = false
-  end
-end
-
-# Model geometry (40x10 km, 0.4 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 100
-    set Y repetitions = 25
-    set X extent      = 40e3
-    set Y extent      = 10e3
-  end
-end
-
-# Mesh refinement specifications.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-  set Additional tangential mesh velocity boundary indicators = left, right
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-end
-
-# Velocity boundary conditions
-# The imposed velocity produces a background strain-rate of 2e-15.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom
-  set Prescribed velocity boundary indicators = left x: function, right x:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = cm=0.01, year=1, vel=0.12616
-    set Function expression = if (x<20e3 , -vel*cm/year, vel*cm/year); 0;
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 5
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, plastic_strain, inclusion
-  set Types of fields  = stress, stress, stress, strain, chemical composition
-  set Compositional field methods = particles
-  set Mapped particle properties  = ve_stress_xx: ve_stress_xx, \
-                                    ve_stress_yy: ve_stress_yy, \
-                                    ve_stress_xy: ve_stress_xy, \
-                                    plastic_strain: plastic_strain, \
-                                    inclusion: initial inclusion
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; 0; \
-                              if (y<=0.4e3 && x>=19.6e3 && x<=20.4e3, 1, 0);
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Fixed composition boundary indicators  =
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# Temperature initial conditions (isothermal)
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-  set Material averaging = harmonic average only viscosity
-
-  subsection Visco Plastic
-    set Densities                   = 2700
-    set Reference strain rate       = 1.e-15
-    set Maximum viscosity           = 1.e25
-    set Minimum viscosity           = 1.e20
-    set Prefactors for dislocation creep          = 5e-26, 5e-26, 5e-26, 5e-26, 5e-26, 5e-21
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 5.e10, 5.e10, 5.e10, 5.e10, 5.e10, 1.e50
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-    set Viscosity averaging scheme  = harmonic
-    set Angles of internal friction = 30.
-    set Cohesions                   = 40.e6, 40.e6, 40.e6, 40.e6, 40.e6, 1.e20
-    set Strain weakening mechanism                   = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals  = 0.0
-    set End plasticity strain weakening intervals    = 0.1
-    set Cohesion strain weakening factors            = 0.1
-    set Friction strain weakening factors            = 1.0
-    set Use plastic damper       = true
-    set Plastic damper viscosity = 1e20
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, particles, temperature statistics, velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate
-    set Time between graphical output = 0e3
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-
-  subsection Particles
-    set Time between data output    = 0.e3
-    set Data output format          = vtu
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
-
-subsection Particles
-  set Minimum particles per cell  = 40
-  set Maximum particles per cell  = 60
-  set Load balancing strategy     = remove and add particles
-  set List of particle properties = initial composition, viscoplastic strain invariants, elastic stress
-  set Interpolation scheme        = cell average
-  set Update ghost particles      = true
-  set Particle generator name     = reference cell
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 7
-    end
-  end
-end
diff --git a/benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm.bak b/benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm.bak
deleted file mode 100644
index 33285ea8f23..00000000000
--- a/benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm.bak
+++ /dev/null
@@ -1,146 +0,0 @@
-# This parameter file constructs a simple shear benchmark, which is adapted from Farrington et al. 2014,
-# (Geophysics, Geochemistry, Geosystems). A uniform material undergoes simple shear at a constant rate
-# up until time=1.  At this point the shearing velocity is reduced to zero, and elastic stresses relax.
-# The rheology is viscoelastic plastic, with a cohesion value of 3.5. This value is slightly
-# higher than the visco-elastic stress at time=1, meaning that yielding does not occur, and the
-# analytic (visco-elastic) solution should be reasonably well approximated. If the cohesion value is reduced
-# to below the shear stress value at time t=1 (~3.1411), the shear stress will reach and remain
-# at this value until after time t=1 when stresses begin to relax.
-# This setup demonstrates an important difference between viscoelastic plastic, and visco-plastic rheology.
-# In a comparable setup, the visco-plastic rheology will exhibit yielding in the first velocity iteration,
-# as the value pre-yield stress magnitude is 3.5.
-# The analytic solution follows the expression in Farrington et al., and describes the
-# non-viscous portion of the total stress. This is equivalent to the magnitude of the stored stress
-# history tensor. The three independent components of this tensor are tracked with compositional fields
-# (ve_stress_xx, ve_stress_yy, ve_stress_xy). The choice of elastic time step (Fixed elastic time step) and
-# numerical timestep (Maximum time step) determine the degree of convergence with the analytic
-# solution. The values set in the parameter file (0.01) produce a close fit to the analytical solution.
-# The stress values are tracked through time in the log file using the composition statistics postprocessor,
-# which reports the min, max, and average value of each compositional field after each time step. Given
-# that there is no discrepancy between the numerical and elastic time steps and stress averaging is not invoked,
-# the min, max, and average stress values remain equal over time.
-
-# Global parameters
-set Dimension                                  = 2
-set Start time                                 = 0
-set End time                                   = 8
-set Use years in output instead of seconds     = false
-set Maximum time step                          = 0.01
-set Output directory                           = output-viscoelastic_plastic_simple_shear
-set Pressure normalization                     = surface
-set Surface pressure                           = 0.
-set Nonlinear solver scheme                    = single Advection, iterated Stokes
-set Max nonlinear iterations                   = 30
-set Nonlinear solver tolerance                 = 1e-5
-set Max nonlinear iterations in pre-refinement = 0
-
-# Solver settings
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance             = 1e-9
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set X repetitions = 2
-    set Y repetitions = 2
-    set X periodic = true
-  end
-end
-
-# Velocity boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-
-  subsection Function
-    set Function expression = if(t<1, if (y > 0.5, 0.05, 0), 0); \
-                              0
-  end
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Spatial domain of different compositional fields.
-# The elastic stress tensor components are set to 0 initially.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0;0.0;0.0
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Because we set the stress exponent n=1, the strain rate term of the dislocation creep
-    # equation becomes 1 as it is set to the power of 0. Furthermore E=0 and P=0 so the exponential
-    # term equals 1 as well. This leads to a simplification of the dislocation creep equation to:
-    # eta = 1/2*prefactor^(-1/stress_exponent)
-    # So this parameter file gives a viscosity eta = 1/2*0.005(⁻1/1) = 100
-    set Prefactors for dislocation creep          = 0.005
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Viscous flow law = dislocation
-    set Densities                   =  1
-    set Elastic shear moduli        = 1.e2
-
-    # Even though we do not use a fixed elastic time step,
-    # this parameters needs to be set equal to the "maximum time step"
-    # as it is used to compute time step 0.
-    set Fixed elastic time step     = 0.01
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = maximum composition
-    set Cohesions                   = 3.5
-    set Angles of internal friction = 0.
-    set Minimum viscosity           = 1e-3
-    set Maximum viscosity           = 1e3
-  end
-end
-
-# The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
diff --git a/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm.bak b/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm.bak
deleted file mode 100644
index 8b4f09583d9..00000000000
--- a/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm.bak
+++ /dev/null
@@ -1,177 +0,0 @@
-# This benchmark examines flexure of a finite-length elastic plate based
-# on the setup described in Choi et al., 2013, JGR, v.118, p.2429-2444,
-# doi:10.1002/jgrb.50148. The model setup has a 50 km long and 5 km thick
-# elastic plate (shear modulus: 30 GPa, viscosity: 1e35 Pa s) overlaying a
-# viscous layer (viscosity: 1e17 Pa s, 12.5 km thick), which both have a density
-# of 2700 kg/m^3. The top of the model is a free surface, while the bottom
-# boundary is zero-slip and the sides are free-slip. The upper right corner
-# of the viscous layer is replaced with a low density (1890 kg/m^3) elastic
-# block, which drives flexure of the elastic plate (right side goes up, left
-# side goes down). The total topography obtained after the model has reached
-# equilibrium is 330 m, with -146.5 m and 183.5 m of topography, respectively,
-# on the left and right sides. The summed value and profiles differ slightly
-# from those reported in Choi et al. (see viscoelastic_plate_flexure.png within
-# the doc/ subdirectory of this folder), but closely match more recent experiments
-# performed by Cedric Thieulot. The curves from the experiments performed by
-# Cedric Thieulot are labeled 'ELEFANT, nelx=150', 'ELEFANT, nelx=250', and
-# '100x35'. For further details on these additional experiments, visit:
-# https://github.com/naliboff/fieldstone/blob/master/python_codes/fieldstone_64/results/flexureplate
-# The figure in this folder (viscoelastic_plate_flexure.png) was made and
-# provided by Cedric Thieulot.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1e3
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set CFL number                             = 0.1
-set Maximum time step                      = 5
-set Output directory                       = output-viscoelastic_plate_flexure
-set Pressure normalization                 = no
-
-# Model geometry (500 m initial resolution)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 100
-    set Y repetitions = 35
-    set X extent      = 50.0e3
-    set Y extent      = 17.5e3
-  end
-end
-
-# Mesh refinement specifications (refine to 250 m)
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Time steps between mesh refinement = 0
-end
-
-# Element types. The temperature polynomial degree is reduced
-# from the default value of 2 to 1, as temperature is not
-# relevant in this problem.
-subsection Discretization
-  set Composition polynomial degree           = 2
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 1
-  set Use locally conservative discretization = true
-  set Use discontinuous temperature discretization = false
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-    set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0, 1.0
-    set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0, 0.0
-  end
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom
-  set Tangential velocity boundary indicators = left, right
-end
-
-# Free surface advection (vertical or normal)
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-  set Additional tangential mesh velocity boundary indicators = left, right
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 5
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, plate, inclusion
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; \
-                              if (y>12.5e3, 1, 0); \
-                              if (x>=45e3 && y>=7.5e3 && y<=12.5e3, 1, 0);
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Fixed composition boundary indicators  =
-  set List of model names = initial composition
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# Initial temperature is constant
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   =  2700,  2700,  2700,  2700,  2700,  1890
-    set Viscosities                 = 1.e17, 1.e17, 1.e17, 1.e17, 1.e35, 1.e35
-    set Elastic shear moduli        = 1.e50, 1.e50, 1.e50, 1.e50, 3.e10, 3.e10
-    set Fixed elastic time step     = 5
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = maximum composition
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, material statistics, velocity statistics, topography, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate, named additional outputs
-    set Time between graphical output = 100
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-
-  subsection Topography
-    set Output to file           = true
-    set Time between text output = 100
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm.bak b/benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm.bak
deleted file mode 100644
index f5c6bf5106f..00000000000
--- a/benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-# This parameter file constructs a 3D cube which is rotated around its vertical axis and sheared in the
-# xz-plane. It is adapted from Farrington et al. 2014 (Geophysics, Geochemistry, Geosystems), section "3.4.
-# Torsion Test in 3-D". According to the authors this is essentially an extension of the simple shear test
-# (see the viscoelastic_plastic_simple_shear benchmark prm file) into the third dimension.
-# While the model always rotates with a constant rate of 42/360 per unit time, shearing is only applied until
-# t = 0.5. At this point the shearing velocity is reduced to zero, and elastic stresses relax.
-# For t < 0.5 the analytical expression of the stress is given by:
-#   tau = exp(-mu/eta*t)*(C2*cos(V*t/h)-C1*sin(V*t/h))-C2
-# and for t >= 0.5:
-#   tau = exp(-mu/eta*tmax)*(C2*cos(V*tmax/h)-C1*sin(V*tmax/h))-C2)*exp(-mu/eta*(t-tmax))
-# with:
-#   tmax = 0.5 [s]     # time at which shearing stops
-#   eta = 100  [Pa s]  # the shear viscosity
-#   mu  = 100  [Pa]    # the shear modulus
-#   V = 0.3    [m/s]   # the shearing velocity
-#   h = 1      [m]     # the height of the box
-#   omega = 42 [deg/s] # the rotation rate
-#   C1 = -(V^2*eta^2*mu)/(mu^2*h^2+V^2*eta^2)
-#   C2 = -(V*h*eta*mu^2)/(mu^2*h^2+V^2*eta^2)
-#
-# These analytical stresses can be directly compared to the xz-component of the stress output (in the composition
-# statistics) from this parameter file.
-# Farrington et al., however, look at the stresses in an unrotated frame (their Fig. 1b), in which case both
-# the analytical stress and the ASPECT stress component need to be multiplied with cos(omega*t). Note that in the
-# Farrington paper the vertical axis is the y-axis, such that their stress component xy is ASPECT's stress
-# component xz.
-# With the time step size given in this parameter file, stresses are underestimated compared to the analytical
-# solution by about 0.9% for t < 0.5 and about 2% for t > 0.5. The fit of the numerical stress to the analytical
-# solution can be enhanced by choosing a smaller time step size.
-
-
-# Global parameters
-set Dimension                                  = 3
-set Start time                                 = 0
-set End time                                   = 2
-set Use years in output instead of seconds     = false
-
-# This will limit all time steps sizes to equal the "maximum time step" size
-set Maximum time step                          = 0.01
-set Output directory                           = output-viscoelastic_sheared_torsion
-set Pressure normalization                     = surface
-set Surface pressure                           = 0.
-set Nonlinear solver scheme                    = single Advection, iterated Stokes
-set Max nonlinear iterations                   = 30
-set Nonlinear solver tolerance                 = 1e-5
-set Max nonlinear iterations in pre-refinement = 0
-
-# Solver settings
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                = 1e-6
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set Z extent  = 1.0
-    set X repetitions = 5
-    set Y repetitions = 5
-    set Z repetitions = 5
-
-    # The axes' origins are offset such that the vertical axis runs through the middle of
-    # the box. This facilitates the velocity boundary condition of the rotational movement.
-    set Box origin X coordinate = -0.5
-    set Box origin Y coordinate = -0.5
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function, 4:function, 5:function
-
-  subsection Function
-    # circular rotation plus shearing until t=0.5
-    set Function expression = if(t<0.5, -sin(atan2(y,x))*sqrt(y*y+x*x)*42/360 + 0.3*z, -sin(atan2(y,x))*sqrt(y*y+x*x)*42/360) ;\
-                            cos(atan2(y,x))*sqrt(y*y+x*x)*42/360 ;\
-                            0
-  end
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name  = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_zz, ve_stress_xy, ve_stress_xz, ve_stress_yz
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Spatial domain of different compositional fields.
-# The elastic stress tensor components are set to 0 initially.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0;0.0;0.0;0.0;0.0;0.0
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # We use the dislocation creep law to prescribe a constant viscous viscosity.
-    # Because we set the stress exponent n=1, the strain rate term of the dislocation creep
-    # equation becomes 1 as it is set to the power of 0. Furthermore E=0 and P=0 so the exponential
-    # term equals 1 as well. This leads to a simplification of the dislocation creep equation to:
-    # eta = 1/2*prefactor^(-1/stress_exponent)
-    # So this parameter file gives a viscosity eta = 1/2*0.005(-1/1) = 100
-    set Prefactors for dislocation creep          = 0.005
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Viscous flow law = dislocation
-    set Densities                   =  1
-    set Elastic shear moduli        = 1.e2
-
-    # Even though we do not use a fixed elastic time step,
-    # this parameters needs to be set equal to the "maximum time step"
-    # as it is used to compute the elastic time step during time step 0.
-    set Fixed elastic time step     = 0.01
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = maximum composition
-
-    # Cohesion is set higher than the maximum stress expected in this benchmark,
-    # such that yielding does not occur
-    set Cohesions                   = 15
-    set Angles of internal friction = 0.
-    set Minimum viscosity           = 1e-3
-    set Maximum viscosity           = 1e3
-  end
-end
-
-# The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
diff --git a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm.bak b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm.bak
deleted file mode 100644
index aa4b2f544da..00000000000
--- a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm.bak
+++ /dev/null
@@ -1,191 +0,0 @@
-# This parameter file reproduces a 2D analytical benchmark for the build-up
-# of stress in an initially unstressed viscoelastic medium subject to a
-# constant strain-rate. This benchmark is described in "Robust
-# characteristics method for modelling multiphase visco-elasto-plastic
-# thermo-mechanical problems" by Gerya and Yuen, 2007, Phys. Earth. Planet.
-# Inter., v. 163, p. 83-105. Full details of the benchmark are located in
-# section 3.1 and figure 3 of this manuscript.
-#
-# The analytical solution for viscoelastic stress build-up in
-# an incompressible medium with a constant strain-rate is:
-#   sigma_ij = 2 * edot_ii * eta * (1 - e^(-mu*t/eta)),
-# where sigma_ij is the elastic deviatoric stress tensor, edot_ij is
-# the deviatoric strain-rate, eta is the background viscosity, mu is the
-# shear modulus and t is time.
-#
-# Following the conditions described in section 3.1 and figure 3 from
-# Gerya and Yuen (2007), a 100x100 km body is subject to a constant
-# strain-rate of 1.e-14 s^-1 in both the horizontal and vertical directions.
-# Constant deformation is driven by inflow and outflow, respectively,
-# on the right and bottom walls. The top and left walls are free-slip.
-# The material has a viscosity of 1e22 Pa s and a shear modulus of 1e10 Pa.
-# With these values, the analytical solution predicts a horizontal
-# or vertical viscoelastic stress magnitude of ~ 200 MPa after 250 Kyr
-# of deformation. Significantly, the effective "viscoelastic" viscosity
-# is enforced to be constant through time by using a constant time step.
-# This is achieved by setting a maximum time step (1000 years) much lower
-# than the time step size given by the CFL number of 0.5.
-#
-# This result can be observed by viewing the compositional field values
-# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
-# of the viscoelastic stress tensor. Significantly, the composition is not
-# fixed on any boundary in order to prevent the formation of boundary artifacts
-# in the compositional fields tracking viscoelastic stresses.
-
-#  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 250e3
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 1
-set CFL number                             = 0.5
-set Maximum time step                      = 1000
-set Output directory                       = output
-set Timing output frequency                = 1
-set Pressure normalization                 = surface
-set Surface pressure                       = 0.
-
-# Solver settings
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-    set Linear solver tolerance = 1e-7
-    set Number of cheap Stokes solver steps = 2000
-  end
-end
-
-# Model geometry (100x100 km, 2 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 50
-    set Y repetitions = 50
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, left
-  set Prescribed velocity boundary indicators = bottom y:function, right x:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = cm=0.01, year=1, vel=3.154
-    set Function expression = if (x>50e3 , vel*cm/year, 0.); if (y<50e3 , vel*cm/year, 0.);
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0;
-  end
-end
-
-# Composition boundary conditions
-# We specify that no boundaries have a fixed composition
-# in order to prevent boundary effects from developing
-# in the compositional fields tracking viscoelastic stresses.
-subsection Boundary composition model
-  set Fixed composition boundary indicators =
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 293
-    set Left temperature   = 293
-    set Right temperature  = 293
-    set Top temperature    = 293
-  end
-end
-
-# Temperature initial conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 2800
-    set Viscosities                 = 1.e22
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, temperature statistics, velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate
-    set Time between graphical output = 10e3
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_particles.prm.bak b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_particles.prm.bak
deleted file mode 100644
index 220b661bdd5..00000000000
--- a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_particles.prm.bak
+++ /dev/null
@@ -1,43 +0,0 @@
-# This parameter file modifies the benchmark viscoelastic_stress_build_up.prm
-# to use particles, rather than compositional fields, to track viscoleastic
-# stresses.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-set Output directory = output_viscoelastic_stress_build-up_particles
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Compositional field methods = particles, particles, particles
-  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, particles, temperature statistics, velocity statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0e3
-  end
-
-  subsection Particles
-    set Time between data output    = 0
-    set Data output format          = vtu
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell  = 25
-  set Maximum particles per cell  = 35
-  set Load balancing strategy     = remove and add particles
-  set List of particle properties = initial composition, elastic stress
-  set Interpolation scheme        = bilinear least squares
-  set Update ghost particles      = true
-  set Particle generator name     = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1e5
-    end
-  end
-end
diff --git a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield.prm.bak b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield.prm.bak
deleted file mode 100644
index a0d946e36fc..00000000000
--- a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield.prm.bak
+++ /dev/null
@@ -1,43 +0,0 @@
-# This parameter file modifies the benchmark viscoelastic_stress_build-up.prm
-# to use the Visco Plastic material model and include a constant
-# yield stress of 100 MPa. Without the imposed yield stress, the viscoelastic
-# stress will build up to ~ 200 MPa. However, the imposed yield stress will
-# truncate the viscoelastic stresses at the yield stress magnitude.
-# For additional information on the model setup and analytical solution,
-# see viscoelastic_stress_build-up.prm, which is located in this folder.
-#
-# The results can be observed by viewing the compositional field values
-# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
-# of the viscoelastic stress tensor. Significantly, the stress near the
-# model boundaries is incorrect due to the compositional field boundary
-# conditions, which are based on the initial compositional values (e.g., zero).
-# This leads to oscillations in the stress field near the boundaries, which
-# decay towards a constant value in the model interior as the stresses build up to
-# 100 MPa.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 100
-set End time  = 100e3
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5e-23
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-    set Viscosity averaging scheme  = harmonic
-    set Angles of internal friction = 0.
-    set Cohesions                   = 100.e6
-    set Densities                   = 2800
-  end
-end
diff --git a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield_particles.prm.bak b/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield_particles.prm.bak
deleted file mode 100644
index fb937f42ef6..00000000000
--- a/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up_yield_particles.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# This parameter file modifies the benchmark viscoelastic_stress_build-up.prm
-# to use the Visco Plastic material model and include a constant
-# yield stress of 100 MPa. Without the imposed yield stress, the viscoelastic
-# stress will build up to ~ 200 MPa. However, the imposed yield stress will
-# truncate the viscoelastic stresses at the yield stress magnitude.
-# For additional information on the model setup and analytical solution,
-# see viscoelastic_stress_build-up.prm, which is located in this folder.
-#
-# The results can be observed by viewing the compositional field values
-# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
-# of the viscoelastic stress tensor or the equivalent values on particles,
-# which are used to store and track the viscoelastic stresses. This parameter
-# file differs from viscoelastic_stress_build-up_yield.prm only in the use
-# of active particles to track the elastic stresses.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 100
-set End time                               = 100e3
-set Output directory                       = output_viscoelastic_stress_build-up_yield_particles
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Compositional field methods = particles, particles, particles
-  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5e-23
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-    set Viscosity averaging scheme  = harmonic
-    set Angles of internal friction = 0.
-    set Cohesions                   = 100.e6
-    set Densities                   = 2800
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, particles, temperature statistics, velocity statistics, visualization
-
-  subsection Particles
-    set Time between data output    = 0
-    set Data output format          = vtu
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell  = 25
-  set Maximum particles per cell  = 35
-  set Load balancing strategy     = remove and add particles
-  set List of particle properties = initial composition, elastic stress
-  set Interpolation scheme        = bilinear least squares
-  set Update ghost particles      = true
-  set Particle generator name     = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1e5
-    end
-  end
-end
diff --git a/benchmarks/viscosity_grooves/viscosity_grooves.cc.bak b/benchmarks/viscosity_grooves/viscosity_grooves.cc.bak
deleted file mode 100644
index 9b0eddf9ac3..00000000000
--- a/benchmarks/viscosity_grooves/viscosity_grooves.cc.bak
+++ /dev/null
@@ -1,473 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/box.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  namespace ViscosityGroovesBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-
-
-      Tensor<1,2>
-      ViscosityGrooves_velocity (const Point<2> &pos)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const double v_x = x*x*x*y+x*x+x*y+x;
-        const double v_y = -1.5*x*x*y*y-2*x*y-0.5*y*y-y;
-        return Point<2> (v_x,v_y);
-      }
-
-      double
-      ViscosityGrooves_pressure (const Point<2> &pos,
-                                 const GeometryModel::Interface<2> &geometry_model)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const GeometryModel::Box<2> *geometry
-          = dynamic_cast<const GeometryModel::Box<2>*> (&geometry_model);
-        const double L=geometry->get_extents()[0];
-        return x*x*y*y+x*y+5. - pow(L,4.)/9.-pow(L,2.)/4.-5.;
-      }
-
-      double
-      ViscosityGrooves_pressure (const Point<2> &, const GeometryModel::Interface<3> &)
-      {
-        Assert (false, ExcNotImplemented());
-        return 0.;
-      }
-
-      template <int dim>
-      class FunctionViscosityGrooves : public Function<dim>
-      {
-        public:
-          FunctionViscosityGrooves (const GeometryModel::Interface<dim> &geometry_model)
-            :
-            Function<dim>(dim+2),
-            geometry_model (geometry_model)
-          {}
-
-          void vector_value (const Point<dim>   &pos,
-                             Vector<double>   &values) const override
-          {
-            Assert (dim == 2, ExcNotImplemented());
-            Assert (values.size() >= 4, ExcInternalError());
-
-            const Point<2> p (pos[0], pos[1]);
-
-            const Tensor<1,2> v = AnalyticSolutions::ViscosityGrooves_velocity (p);
-            values[0] = v[0];
-            values[1] = v[1];
-            values[2] = AnalyticSolutions::ViscosityGrooves_pressure (p, geometry_model);
-          }
-
-        private:
-          const GeometryModel::Interface<dim> &geometry_model;
-      };
-    }
-
-
-    template <int dim>
-    class ViscosityGroovesBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        ViscosityGroovesBoundary();
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id ,
-                           const Point<dim> &position) const override;
-
-      private:
-        const double epsilon;
-
-    };
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class ViscosityGroovesMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> &pos = in.position[i];
-              const double x = pos[0];
-              const double y = pos[1];
-              out.viscosities[i] = -std::sin(x*x*y*y+x*y+5.)+1.+epsilon;
-              out.densities[i] = 1.;
-              out.compressibilities[i] = 0.;
-              out.specific_heat[i] = 0.;
-              out.thermal_expansion_coefficients[i] = 0.;
-              out.thermal_conductivities[i] = 0.;
-            }
-        }
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        double get_epsilon() const;
-
-        double epsilon;
-
-    };
-
-
-    template <int dim>
-    bool
-    ViscosityGroovesMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    ViscosityGroovesMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      //create a global section in the parameter file for parameters
-      //that describe this benchmark. note that we declare them here
-      //in the material model, but other kinds of plugins (e.g., the gravity
-      //model below) may also read these parameters even though they do not
-      //declare them
-      prm.enter_subsection("ViscosityGrooves benchmark");
-      {
-        prm.declare_entry("Viscosity parameter", "0.1",
-                          Patterns::Double (0.),
-                          "Viscosity parameter epsilon in the ViscosityGrooves benchmark.");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    ViscosityGroovesMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("ViscosityGrooves benchmark");
-      {
-        epsilon = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-    template <int dim>
-    double
-    ViscosityGroovesMaterial<dim>::get_epsilon() const
-    {
-      return epsilon;
-    }
-
-    template <int dim>
-    ViscosityGroovesBoundary<dim>::ViscosityGroovesBoundary ()
-      :
-      epsilon (0.)
-    {}
-
-    template <>
-    Tensor<1,2>
-    ViscosityGroovesBoundary<2>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<2> &p) const
-    {
-      return AnalyticSolutions::ViscosityGrooves_velocity (p);
-    }
-
-
-    template <>
-    Tensor<1,3>
-    ViscosityGroovesBoundary<3>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<3> &) const
-    {
-      Assert (false, ExcNotImplemented());
-      return Tensor<1,3>();
-    }
-
-    /**
-     * Gravity model for the ViscosityGrooves benchmark
-    */
-
-    template <int dim>
-    class ViscosityGroovesGravity : public aspect::GravityModel::Interface<dim>
-    {
-      public:
-        Tensor<1,dim> gravity_vector (const Point<dim> &pos) const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-        */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        double epsilon;
-
-    };
-
-    template <int dim>
-    Tensor<1,dim>
-    ViscosityGroovesGravity<dim>::
-    gravity_vector(const Point<dim> &pos) const
-    {
-      const double x=pos[0];
-      const double y=pos[1];
-      Tensor<1,dim> g;
-
-      const double eta=-std::sin(x*x*y*y+x*y+5.)+1.+epsilon;
-
-      const double costerm=std::cos(x*x*y*y+x*y+5.);
-
-      const double deta_dx=-y*(2.*x*y+1.)*costerm;
-      const double deta_dy=-x*(2.*x*y+1.)*costerm;
-
-      const double dpdx=2. * x  *y*y +y ;
-      const double dpdy=2. * x*x*y   +x ;
-
-      const double exx= 3.*x*x * y +2.*x +y +1.;
-      const double eyy=-3.*x*x * y -2.*x -y -1.;
-
-      const double exy=0.5*(x*x*x + x -3.*x*y*y -2.*y);
-      const double eyx=0.5*(x*x*x + x -3.*x*y*y -2.*y);
-
-      const double dexxdx= 6.*x*y+2.;
-      const double deyxdy=-3.*x*y-1.;
-
-      const double dexydx= 0.5*(3.*x*x +1. -3.*y*y);
-      const double deyydy= -3.*x*x -1.;
-
-      const double gx =-dpdx + 2.*eta*dexxdx + 2.*deta_dx*exx + 2.*eta*deyxdy + 2.*deta_dy*eyx;
-      const double gy =-dpdy + 2.*eta*dexydx + 2.*deta_dx*exy + 2.*eta*deyydy + 2.*deta_dy*eyy;
-
-      g[0]=-gx;
-      g[1]=-gy;
-
-      return g;
-    }
-
-    template <int dim>
-    void
-    ViscosityGroovesGravity<dim>::declare_parameters (ParameterHandler &)
-    {
-      //nothing to declare here. This plugin will however, read parameters
-      //declared by the material model in the "ViscosityGrooves benchmark" section
-    }
-
-    template <int dim>
-    void
-    ViscosityGroovesGravity<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("ViscosityGrooves benchmark");
-      {
-        epsilon = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-    }
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the Donea and Huerta FEM book (see manual).
-      */
-    template <int dim>
-    class ViscosityGroovesPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    ViscosityGroovesPostprocessor<dim>::execute (TableHandler &)
-    {
-      std::shared_ptr<Function<dim>> ref_func;
-      {
-
-        ref_func = std::make_unique<AnalyticSolutions::FunctionViscosityGrooves<dim>>(this->get_geometry_model());
-      }
-
-      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                          dim+2);
-      ComponentSelectFunction<dim> comp_p(dim, dim+2);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_u,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_p,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_p);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_ul2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_pl2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double u_l1 =  VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-      const double p_l1 =  VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-      const double u_l2 =  VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-      const double p_l2 =  VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-      std::ostringstream os;
-
-      os << std::scientific <<  u_l1
-         << ", " << p_l1
-         << ", " << u_l2
-         << ", " << p_l2;
-
-      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace ViscosityGroovesBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ViscosityGroovesMaterial,
-                                   "ViscosityGroovesMaterial",
-                                   "A material model that corresponds to the `ViscosityGrooves' benchmark. "
-                                   "See the manual for more information.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(ViscosityGroovesBoundary,
-                                            "ViscosityGroovesBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "`ViscosityGrooves' benchmark. See the manual for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(ViscosityGroovesPostprocessor,
-                                  "ViscosityGroovesPostprocessor",
-                                  "A postprocessor that compares the solution of the `ViscosityGrooves' benchmark "
-                                  "with the one computed by ASPECT "
-                                  "and reports the error. See the manual for more information.")
-
-    ASPECT_REGISTER_GRAVITY_MODEL(ViscosityGroovesGravity,
-                                  "ViscosityGroovesGravity",
-                                  "A gravity model in corresponding to the `ViscosityGrooves' benchmark. "
-                                  "See the manual for more information.")
-  }
-}
diff --git a/benchmarks/viscosity_grooves/viscosity_grooves.prm.bak b/benchmarks/viscosity_grooves/viscosity_grooves.prm.bak
deleted file mode 100644
index d7c2da3015f..00000000000
--- a/benchmarks/viscosity_grooves/viscosity_grooves.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-############### Global parameters
-# This is a manufactured solution by Dave May (unpublished).
-
-set Additional shared libraries            = ./libviscosity_grooves.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = output_viscosity_grooves
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0  : ViscosityGroovesBoundary, \
-                                                1  : ViscosityGroovesBoundary, \
-                                                2  : ViscosityGroovesBoundary, \
-                                                3  : ViscosityGroovesBoundary
-end
-
-subsection Material model
-  set Model name = ViscosityGroovesMaterial
-end
-
-subsection Gravity model
-  set Model name = ViscosityGroovesGravity
-end
-
-# This is the epsilon parameter
-
-subsection ViscosityGrooves benchmark
-  set Viscosity parameter = 0.01
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, ViscosityGroovesPostprocessor
-
-  subsection Visualization
-    set Output format = vtu
-    set List of output variables = density, viscosity, strain rate, gravity
-  end
-end
-
-# Because it is a benchmark lower solver tolerance is set.
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.cc.bak b/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.cc.bak
deleted file mode 100644
index e4b7e8fe57a..00000000000
--- a/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.cc.bak
+++ /dev/null
@@ -1,402 +0,0 @@
-/*
-  Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include "anelasticity_temperature.h"
-#include <aspect/material_model/interface.h>
-#include <aspect/initial_composition/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/simulator_access.h>
-#include <cmath>
-#include <algorithm>
-#include <functional>
-
-#include <boost/lexical_cast.hpp>
-#include <boost/math/tools/minima.hpp>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    AnelasticVs2T<dim>::AnelasticVs2T ()
-    {}
-
-    template <int dim>
-    void
-    AnelasticVs2T<dim>::initialize ()
-    {
-      Utilities::AsciiDataInitial<dim>::initialize(1);
-    }
-
-// set up Vs function that Brent minimization operates on
-    template <int dim>
-    double
-    AnelasticVs2T<dim>::
-    fVs (double x,
-         const double      depth,
-         const double      absolute_Vs,
-         const double      mu0,
-         const double      dmudT,
-         const double      dmudP,
-         const double      viscosity_prefactor,
-         const double      activation_energy,
-         const double      activation_volume,
-         const double      solidus_gradient,
-         const bool      use_original_model) const
-    {
-      return std::abs(yamauchi_takei_Vs(x,depth,mu0,dmudT,dmudP,viscosity_prefactor,activation_energy,activation_volume
-                                        ,solidus_gradient,use_original_model)-absolute_Vs);
-    }
-
-// set up volume change function that Brent minimization operates on
-    template <int dim>
-    double
-    AnelasticVs2T<dim>::
-    fdV (double x, const double bulk_modulus, const double bulk_modulus_pressure_derivative, const double pressure ) const
-    {
-      return std::abs((bulk_modulus*(3./2.)*(std::pow(x,7./3.)-std::pow(x,5./3.))*(1+(((3./4.)*
-                                                                                      (bulk_modulus_pressure_derivative-4))*(std::pow(x,2./3.)-1))))-pressure);
-    }
-
-// set up initial temperature
-    template <int dim>
-    double
-    AnelasticVs2T<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // determine depth
-      double depth;
-      depth = this->get_geometry_model().depth(position);
-
-      // declare temperature
-      double temperature;
-
-      // read absolute Vs in from ascii file
-      const double absolute_Vs = Utilities::AsciiDataInitial<dim>::get_data_component(position,0);
-
-      if (depth >= no_perturbation_depth)
-        {
-          // convert absolute Vs into temperature
-          // check if using Yamauchi & Takei 2016 parameterization
-          if (use_yamauchi_takei == true)
-            {
-              // specify anelasticity parameters
-              const double mu0=72.45;
-              const double dmudT=-0.01094;
-              const double dmudP=1.987;
-              const double viscosity_prefactor=6.22e21;
-              const double activation_energy=462.5e3;
-              const double activation_volume=7.913e-6;
-              const double solidus_gradient=1.018;
-              // specify Brent algorithm parameters
-              const double a=273;
-              const double b=3273;
-              using Result = std::pair<double, double>;
-              // create fVs function to use in Brent minimization and calculate temperature
-              auto bfunc = [ &,this] (double x)
-              {
-                return fVs(x, depth, absolute_Vs, mu0, dmudT,dmudP,
-                           viscosity_prefactor,activation_energy,activation_volume,solidus_gradient,use_original_model);
-              };
-              // determine maximum Vs
-              double maximum_Vs;
-              int fail;
-              maximum_Vs=yamauchi_takei_Vs(273.,depth,mu0,dmudT,dmudP,viscosity_prefactor,activation_energy,activation_volume
-                                           ,solidus_gradient,use_original_model);
-
-              // set number of fails to zero
-              fail=0;
-              // where absolute Vs exceeds maximum Vs, set temperature to 273 K
-              if (absolute_Vs>maximum_Vs)
-                {
-                  temperature=273.;
-                  fail=fail+1;
-                  std::cout << "Vs too fast for sensible temperature for " << fail << " points!" << std::endl;
-                }
-              else
-                {
-                  Result r1 = boost::math::tools::brent_find_minima(bfunc,a,b,16);
-                  temperature=r1.first;
-                }
-            }
-          else
-            {
-              Assert (false, ExcNotImplemented());
-              return 273.;
-            }
-        }
-      else
-        {
-          // set temperature to constant above specified depth
-          temperature = reference_temperature;
-        }
-      // return the absolute temperature in Kelvin
-      return temperature;
-    }
-
-    template <int dim>
-    double
-    AnelasticVs2T<dim>::
-    yamauchi_takei_Vs (double temperature,
-                       double depth,
-                       const double mu0,
-                       const double dmudT,
-                       const double dmudP,
-                       const double viscosity_prefactor,
-                       const double activation_energy,
-                       const double activation_volume,
-                       const double solidus_gradient,
-                       const bool use_original_model) const
-    {
-      // specify anelasticity parameters
-      const double critical_homologous_temperature = 0.94;
-      const double reduction_factor = 5;
-      const double background_amplitude = 0.664;
-      const double background_slope = 0.38;
-      const double peak_period = 6e-5;
-      const double melt_viscosity_factor = 0;
-      const double melt_peak_factor = 0;
-      const double reference_temperature = 1473;
-      const double reference_pressure = 1.5e9;
-      const double grain_size = 1e-3;
-      const double reference_grain_size = 1e-3;
-      const double grain_size_exponent = 3;
-      const double pressure_gradient = 3e-5;
-      const double gas_constant=8.3145;
-      // specify Grose & Afonso (2013) density parameters
-      const double a=1;
-      const double b=3;
-      const double bulk_modulus=130e9;
-      const double bulk_modulus_pressure_derivative=4.8;
-      const double gruneisen_parameter=6;
-      const double reference_density=3330;
-      // specify original density parameters
-      const double original_density=3291;
-      const double original_thermal_expansivity=3.59e-5;
-      const double original_bulk_modulus=115.2;
-      // initialize solidus
-      const double T_solidus = 1326.0 + 273 + (((depth-50000)/1e3)*solidus_gradient);
-      // initialize homologous_temperature
-      double homologous_temperature = temperature/T_solidus;
-      // initialize pressures
-      double pressure = depth/pressure_gradient;
-      // declare other parameters
-      double viscosity,viscosity_reduction_factor,peak_amplitude,peak_width,isothermal_volume_change;
-      double compressibility,pressure_dependent_density,integrated_thermal_expansivity,density;
-      double unrelaxed_compliance,storage_compliance,period,anelastic_Vs;
-      // begin calculation of Vs
-      if (homologous_temperature<critical_homologous_temperature)
-        {
-          viscosity_reduction_factor=1;
-        }
-      else if ((homologous_temperature>=critical_homologous_temperature) && (homologous_temperature<1))
-        {
-          viscosity_reduction_factor=std::exp((-1*((homologous_temperature-critical_homologous_temperature)/(homologous_temperature-
-                                                   (homologous_temperature*critical_homologous_temperature))))*std::log(reduction_factor));
-        }
-      else
-        {
-          viscosity_reduction_factor=(1/reduction_factor)*std::exp(-melt_viscosity_factor);
-        }
-      viscosity = std::pow(grain_size/reference_grain_size,grain_size_exponent)*viscosity_prefactor*std::exp((activation_energy/gas_constant)
-                  *(1/temperature-1/reference_temperature))*std::exp((activation_volume/gas_constant)*(pressure/temperature-reference_pressure/
-                                                                     reference_temperature))*viscosity_reduction_factor;
-      unrelaxed_compliance=1./(1e9*(mu0+(dmudP*pressure*1e-9)+(dmudT*(temperature-273))));
-      if (temperature<273)
-        {
-          // Vs is too high to give realistic temperature so viscosity, attenuation and unrelaxed compliance are reset
-          viscosity=1e40;
-          unrelaxed_compliance=1./(1e9*(mu0+(dmudP*pressure*1e-9)));
-          // attenuation=1e-9;
-        }
-      // evaluate Maxwell normalized shear wave period
-      double maxwell_relaxation_time=viscosity*unrelaxed_compliance;
-      if (use_original_model == true)
-        {
-          // set shear wave period as constant
-          period=100;
-        }
-      else
-        {
-          // calculate shear wave period incorporating depth dependence of Forsyth 1992
-          period=(3*depth)/4200;
-        }
-      double normalized_period=period/(2*M_PI*maxwell_relaxation_time);
-      // determine peak amplitudes
-      if (homologous_temperature < 0.91)
-        {
-          peak_amplitude=0.01;
-        }
-      else if ((homologous_temperature >= 0.91) && (homologous_temperature < 0.96))
-        {
-          peak_amplitude=0.01+(0.4*(homologous_temperature-0.91));
-        }
-      else if ((homologous_temperature >= 0.96) && (homologous_temperature < 1))
-        {
-          peak_amplitude=0.03;
-        }
-      else
-        {
-          peak_amplitude=0.03+melt_peak_factor;
-        }
-      // determine peak widths
-      if (homologous_temperature < 0.92)
-        {
-          peak_width=4;
-        }
-      else if ((homologous_temperature >= 0.92) && (homologous_temperature < 1))
-        {
-          peak_width=4+(37.5*(homologous_temperature-0.92));
-        }
-      else
-        {
-          peak_width=7;
-        }
-      // determine density
-      if (use_original_model == true)
-        {
-          // calculate density using original parameters from Yamauchi & Takei (2016)
-          density=original_density*(1-(original_thermal_expansivity*((temperature-273)-600))+((pressure*1e-9)/original_bulk_modulus));
-        }
-      else
-        {
-          // create fdV function to use in Brent minimization and calculate isothermal_volume_change and density using
-          // expressions in Grose & Afonso 2013
-          using Result2 = std::pair<double, double>;
-          auto vfunc = [ &,this] (double x)
-          {
-            return fdV(x, bulk_modulus, bulk_modulus_pressure_derivative, pressure);
-          };
-          Result2 r2 = boost::math::tools::brent_find_minima(vfunc,a,b,16);
-          isothermal_volume_change=r2.first;
-          compressibility=isothermal_volume_change*std::exp((gruneisen_parameter+1)*(std::pow(isothermal_volume_change,-1)-1));
-          pressure_dependent_density=reference_density*isothermal_volume_change;
-          integrated_thermal_expansivity=(2.832e-5*(temperature-273))+((0.758e-8/2)*(std::pow(temperature,2)-std::pow(273,2)));
-          density=pressure_dependent_density*(1-(compressibility*integrated_thermal_expansivity));
-        }
-      // determine J1 term (real part of complex compliance)
-      storage_compliance=unrelaxed_compliance*(1+((background_amplitude*std::pow(normalized_period,background_slope))
-                                                  /background_slope)+((std::sqrt(2*M_PI)/2)*peak_amplitude*peak_width*(1-
-                                                                      std::erf((std::log(peak_period/normalized_period))/(std::sqrt(2)*peak_width)))));
-      // determine J2 term (imaginary part of complex compliance)
-      //double loss_compliance=unrelaxed_compliance*(M_PI/2)*(background_amplitude*(std::pow(normalized_period,background_slope))+
-      // (peak_amplitude*std::exp(-1*(std::pow(std::log(peak_period/normalized_period),2)/
-      // (2*std::pow(peak_width,2))))))+(unrelaxed_compliance*normalized_period);
-      // calculate anharmonic Vs
-      // anharmonic_Vs=1/(std::sqrt(density*unrelaxed_compliance)*1e3);
-      // calculate Vs
-      anelastic_Vs=1/(std::sqrt(density*storage_compliance)*1e3);
-      // calculate attenuation
-      // attenuation=loss_compliance/storage_compliance;
-      return anelastic_Vs;
-    }
-
-    template <int dim>
-    void
-    AnelasticVs2T<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.declare_entry ("Remove temperature heterogeneity down to specified depth",
-                           boost::lexical_cast<std::string>(-std::numeric_limits<double>::max()),
-                           Patterns::Double (),
-                           "This will remove temperature variations prescribed by the input model "
-                           "down to the specified depth (in meters). Note that your resolution has "
-                           "to be adequate to capture this cutoff. For example if you specify a depth "
-                           "of 660km, but your closest spherical depth layers are only at 500km and "
-                           "750km (due to a coarse resolution) it will only remove heterogeneities "
-                           "down to 500km. Similar caution has to be taken when using adaptive meshing.");
-        prm.declare_entry ("Set reference temperature down to specified depth", "1600",
-                           Patterns::Double (),
-                           "This parameter sets the a constant value of temperature down to the specified depth.");
-        prm.declare_entry ("Use Yamauchi and Takei parameterization", "true",
-                           Patterns::Bool(),
-                           "This parameter determines whether to use the anelasticity model of "
-                           "Yamauchi & Takei (2016) to convert absolute Vs into temperature");
-        prm.declare_entry ("Use original density and frequency model of Yamauchi and Takei", "true",
-                           Patterns::Bool(),
-                           "Use original density and frequency model of Yamauchi & Takei (2016) where density"
-                           "has simple pressure-dependence and shear wave is period set at 100s");
-
-        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                          "$ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/",
-                                                          "box_2d_Vs_YT16.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AnelasticVs2T<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        no_perturbation_depth   = prm.get_double ("Remove temperature heterogeneity down to specified depth");
-        reference_temperature   = prm.get_double ("Set reference temperature down to specified depth");
-        use_yamauchi_takei = prm.get_bool ("Use Yamauchi and Takei parameterization");
-        use_original_model = prm.get_bool ("Use original density and frequency model of Yamauchi and Takei");
-
-        Utilities::AsciiDataBase<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AnelasticVs2T,
-                                              "anelastic Vs to temperature",
-                                              "Implementation of a model in which the initial temperature is calculated "
-                                              "from files containing absolute shear wave velocity (Vs) data in ascii format. "
-                                              "This plug-in allows you to select from a number of different models that"
-                                              "convert Vs into temperature, accounting for the anelastic behavior of mantle material."
-                                              "Note the required format of the "
-                                              "input data: The first lines may contain any number of comments "
-                                              "if they begin with `#', but one of these lines needs to "
-                                              "contain the number of grid points in each dimension as "
-                                              "for example `# POINTS: 3 3'. "
-                                              "The order of the data columns "
-                                              "has to be `x', `y', `Temperature [K]' in a 2d model and "
-                                              " `x', `y', `z', `Temperature [K]' in a 3d model, which means that "
-                                              "there has to be a single column "
-                                              "containing the temperature. "
-                                              "Note that the data in the input "
-                                              "files need to be sorted in a specific order: "
-                                              "the first coordinate needs to ascend first, "
-                                              "followed by the second and the third at last in order to "
-                                              "assign the correct data to the prescribed coordinates. "
-                                              "If you use a spherical model, "
-                                              "then the assumed grid changes. `x' will be replaced by "
-                                              "the radial distance of the point to the bottom of the model, "
-                                              "`y' by the azimuth angle and `z' by the polar angle measured "
-                                              "positive from the north pole. The grid will be assumed to be "
-                                              "a latitude-longitude grid. Note that the order "
-                                              "of spherical coordinates is `r', `phi', `theta' "
-                                              "and not `r', `theta', `phi', since this allows "
-                                              "for dimension independent expressions.")
-  }
-}
diff --git a/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.h.bak b/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.h.bak
deleted file mode 100644
index b6744f31e42..00000000000
--- a/benchmarks/yamauchi_takei_2016_anelasticity/anelasticity_temperature.h.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_anelasticity_temperature_h
-#define _aspect_initial_temperature_anelasticity_temperature_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-#include <cmath>
-#include <algorithm>
-#include <functional>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes an initial temperature field for a 2D or 3D shear wave velocity (Vs) model.
-     * Vs values are converted to temperature using the anelasticity parameterization of Yamauchi & Takei (2016).
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class AnelasticVs2T : public Utilities::AsciiDataInitial<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        AnelasticVs2T ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // Avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataInitial<dim>::initialize;
-
-        /**
-         * Return the boundary temperature as a function of position. For the
-         * current class, this function returns value from the text files.
-         */
-        double
-        initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters for the input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler  &prm);
-
-        /**
-         * Read the parameters from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * Function that assesses difference between input and calculated Vs for Brent minimization
-         */
-        double
-        fVs(double x, double depth, double absolute_Vs, double mu0, double dmudT,
-            double dmudP, double viscosity_prefactor, double activation_energy, double activation_volume,
-            double solidus_gradient, bool density_model_flag) const;
-
-        /**
-         * Function that assesses difference between input and calculated pressure for Brent minimization
-         */
-        double
-        fdV(double x, double bulk_modulus, double bulk_modulus_pressure_derivative, double pressure) const;
-
-        /**
-         * Function to calculate Vs using Yamauchi & Takei 2016 anelasticity parameterization
-         */
-        double
-        yamauchi_takei_Vs(double temperature, double depth, double mu0, double dmudT,
-                          double dmudP, double viscosity_prefactor, double activation_energy,
-                          double activation_volume, double solidus_gradient, bool density_model_flag) const;
-
-        /**
-         * Whether to remove temperature heterogeneity upper parts of model
-         */
-        double no_perturbation_depth;
-
-        /**
-         * Constant temperature to set where variations have been removed
-         */
-        double reference_temperature;
-
-        /**
-         * Whether to use Yamauchi & Takei (2016) anelasticity
-         * parameterization
-         */
-        bool use_yamauchi_takei;
-
-        /**
-         * Whether to use original parameters published in Yamauchi & Takei
-         * (2016) or an updated version that accounts for non-linear pressure
-         * dependence of thermal expansivity and depth dependence of shear
-         * wave period
-         */
-        bool use_original_model;
-
-    };
-  }
-}
-
-#endif
diff --git a/benchmarks/yamauchi_takei_2016_anelasticity/yamauchi_takei_2016_anelasticity.prm.bak b/benchmarks/yamauchi_takei_2016_anelasticity/yamauchi_takei_2016_anelasticity.prm.bak
deleted file mode 100644
index f704bf05f74..00000000000
--- a/benchmarks/yamauchi_takei_2016_anelasticity/yamauchi_takei_2016_anelasticity.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-# This benchmark tests the ASPECT implementation of an initial temperature model
-# that converts absolute shear wave velocity to temperature using the anelasticity model of
-# Yamauchi & Takei 2016 (JGR). This .prm aims to recreate Figure 20 in the paper.
-# Output can be plotted and compared to results in Figure 20 by running plot_output.gmt
-# in the plot_output folder.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-set Additional shared libraries = ./libanelasticity_temperature.so
-set Output directory                       = output_yamauchi_takei_2016_anelasticity
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 52000
-    set Y extent = 100000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = anelastic Vs to temperature
-  set Remove temperature heterogeneity down to specified depth = 25000
-  set Set reference temperature down to specified depth = 600
-  set Use Yamauchi and Takei parameterization = true
-  set Use original density and frequency model of Yamauchi and Takei = true
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = box_2d_Vs_YT16.txt
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 6
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, point values
-
-  subsection Point values
-    set Evaluation points = 0,25000;2000,25000;4000,25000;\
-  6000,25000;8000,25000;10000,25000;12000,25000;14000,25000;16000,25000;18000,25000;20000,25000;22000,25000;24000,25000;26000,25000;\
-  28000,25000;30000,25000;32000,25000;34000,25000;36000,25000;38000,25000;40000,25000;42000,25000;44000,25000;46000,25000;\
-  48000,25000;50000,25000;52000,25000;0,50000;2000,50000;4000,50000;6000,50000;8000,50000;10000,50000;12000,50000;14000,50000;16000,50000;\
-  18000,50000;20000,50000;22000,50000;24000,50000;26000,50000;28000,50000;30000,50000;32000,50000;34000,50000;36000,50000;\
-  38000,50000;40000,50000;42000,50000;44000,50000;46000,50000;48000,50000;50000,50000;52000,50000
-  end
-end
diff --git a/benchmarks/zhong_et_al_93/zhong_case1.prm.bak b/benchmarks/zhong_et_al_93/zhong_case1.prm.bak
deleted file mode 100644
index 0f3500e7267..00000000000
--- a/benchmarks/zhong_et_al_93/zhong_case1.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-set Dimension                              = 2
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Use a one by one box
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# Approximate a delta function
-# perturbation at depth
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x1,x2
-    set Function constants  = lambda=1, pi=3.1415926536, L=1, depth=62, sigma = 0.5, N=64
-    set Function expression = 1/(sigma/N*L * sqrt( 2 * pi) ) * exp( -0.5*(x2-depth/N)*(x2-depth/N)/sigma/sigma/L/L*N*N ) * cos(2*pi/lambda*x1/L)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 0
-    set Top temperature    = 0
-  end
-end
-
-# Boussinesq approximation
-subsection Formulation
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Material model
-  set Model name = nondimensional
-
-  subsection Nondimensional model
-    set Di = 0.0
-    set Ra = 1.0
-    set Reference density = 1
-    set Reference specific heat = 1
-    set Use TALA = false
-  end
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = dynamic topography, visualization
-
-  subsection Visualization
-    set Output format                 = vtu
-    set List of output variables      = dynamic topography
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Dynamic topography
-    set Density above          = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/contrib/opendap/prm_files/aspect_test.prm.bak b/contrib/opendap/prm_files/aspect_test.prm.bak
deleted file mode 100644
index 23b8dda81c2..00000000000
--- a/contrib/opendap/prm_files/aspect_test.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# Test the aspect simulator using local data match the file used
-# with the opendap client. See aspect_url_test.prm for an example
-# of that version.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output-adiabatic_boundary-no-url-test
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 50
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 35
-    set Chunk maximum longitude = 55
-    set Chunk minimum latitude = -28
-    set Chunk maximum latitude = -8
-    set Chunk inner radius = 5878137
-    set Chunk outer radius = 6378137
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic boundary
-
-  subsection Adiabatic boundary
-    set Data directory    = $ASPECT_SOURCE_DIR/contrib/opendap/input_files/
-    set Data file name    = lithospheric_thickness.txt
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Initial temperature
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, outer, west, east, south, north
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Material model
-  set Model name = simpler
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics
-
-  subsection Visualization
-    set List of output variables      = viscosity, density, strain rate
-    set Time between graphical output = 1.0
-    set Output format = vtu
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-    set Number of cheap Stokes solver steps = 50
-  end
-end
diff --git a/contrib/opendap/prm_files/aspect_url_test.prm.bak b/contrib/opendap/prm_files/aspect_url_test.prm.bak
deleted file mode 100644
index b5532978ba4..00000000000
--- a/contrib/opendap/prm_files/aspect_url_test.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output-adiabatic_boundary-url-test
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 50
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 35
-    set Chunk maximum longitude = 55
-    set Chunk minimum latitude = -28
-    set Chunk maximum latitude = -8
-    set Chunk inner radius = 5878137
-    set Chunk outer radius = 6378137
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic boundary
-
-  subsection Adiabatic boundary
-    set Data directory    =
-    set Data file name       = http://balto.opendap.org/opendap/lithosphere_thickness/lithospheric_thickness.csv
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Initial temperature
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, outer, west, east, south, north
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Material model
-  set Model name = simpler
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics
-
-  subsection Visualization
-    set List of output variables      = viscosity, density, strain rate
-    set Time between graphical output = 1.0
-    set Output format = vtu
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-    set Number of cheap Stokes solver steps = 50
-  end
-end
diff --git a/contrib/perplex/perplex_lookup_composition.prm.bak b/contrib/perplex/perplex_lookup_composition.prm.bak
deleted file mode 100644
index 8b519f72792..00000000000
--- a/contrib/perplex/perplex_lookup_composition.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# This test ensures that the PerpleX lookup material model works
-# with compositional fields enabled
-
-# WARNING: Please understand that the PerpleX Lookup material model is only a
-# proof-of-concept; the number of P-T-X evaluations is extremely large, which
-# means that ASPECT will be interminably slow for any real problems.
-
-set Dimension                              = 2
-set End time                               = 0
-set Adiabatic surface temperature          = 1300
-
-# KLB composition in the CFMAS system
-# The bulk composition is given by five compositional fields
-# which correspond to the components in the PerpleX input
-# file (in this case, SiO2, Al2O3, FeO and MgO).
-# As defined in the PerpleX input file, the composition is
-# given in weight amount. The total amount is normalized
-# by the PerpleX routines, so it doesn't need to equal 1 or 100.
-
-subsection Compositional fields
-  set Number of fields          = 4
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 0.44; 0.04; 0.08; 0.44
-  end
-end
-
-subsection Material model
-  set Model name                   = perplex lookup
-
-  subsection PerpleX lookup model
-    set PerpleX input file name    = pyrolite
-    set Viscosity                  = 1e21
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent                = 200e3
-    set X repetitions           = 1
-    set Y extent                = 800e3
-    set Y repetitions           = 16
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1300
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Output format = gnuplot
-    set Number of zones = 200
-  end
-end
diff --git a/contrib/python/notebooks/read_output_files/convection-box.prm.bak b/contrib/python/notebooks/read_output_files/convection-box.prm.bak
deleted file mode 100644
index 055f18b7567..00000000000
--- a/contrib/python/notebooks/read_output_files/convection-box.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-include $ASPECT_SOURCE_DIR/cookbooks/convection-box.prm
-
-set End time                               = 0.1
-set Output directory                       = output
-
-subsection Postprocess
-  subsection Visualization
-    set Output format = gnuplot
-  end
-end
diff --git a/contrib/world_builder/include/app/main.h.bak b/contrib/world_builder/include/app/main.h.bak
deleted file mode 100644
index 097d0caf137..00000000000
--- a/contrib/world_builder/include/app/main.h.bak
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-  Copyright (C) 2020 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_APP_MAIN_H_
-#define WORLD_BUILDER_APP_MAIN_H_
-
-#include <string>
-
-bool find_command_line_option(char **begin, char **end, const std::string &option);
-
-#endif
diff --git a/contrib/world_builder/include/glm/glm.h.bak b/contrib/world_builder/include/glm/glm.h.bak
deleted file mode 100644
index 3089ebc6876..00000000000
--- a/contrib/world_builder/include/glm/glm.h.bak
+++ /dev/null
@@ -1,248 +0,0 @@
-#ifndef _glm_h
-#define _glm_h
-#include <array>
-#include <math.h>
-#include <limits>
-
-namespace WorldBuilder
-{
-  /**
-   * The code in this file is derived from the OpenGL Mathematics (GLM) library, which
-   * is available under two version of MIT Lincense (see below). The derived work in
-   * this file is avaible under the same licenses.
-   *
-   * The changes are mainly specializing and isolation functions which are needed in
-   * the World Builder.
-   *
-   * ================================================================================
-   * OpenGL Mathematics (GLM)
-   * --------------------------------------------------------------------------------
-   * GLM is licensed under The Happy Bunny License and MIT License
-   *
-   * ================================================================================
-   * The Happy Bunny License (Modified MIT License)
-   * --------------------------------------------------------------------------------
-   * Copyright (c) 2005 - 2014 G-Truc Creation
-   *
-   * Permission is hereby granted, free of charge, to any person obtaining a copy
-   * of this software and associated documentation files (the "Software"), to deal
-   * in the Software without restriction, including without limitation the rights
-   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   * copies of the Software, and to permit persons to whom the Software is
-   * furnished to do so, subject to the following conditions:
-   *
-   * The above copyright notice and this permission notice shall be included in
-   * all copies or substantial portions of the Software.
-   *
-   * Restrictions:
-   *  By making use of the Software for military purposes, you choose to make a
-   *  Bunny unhappy.
-   *
-   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   * THE SOFTWARE.
-   *
-   * ================================================================================
-   * The MIT License
-   * --------------------------------------------------------------------------------
-   * Copyright (c) 2005 - 2014 G-Truc Creation
-   *
-   * Permission is hereby granted, free of charge, to any person obtaining a copy
-   * of this software and associated documentation files (the "Software"), to deal
-   * in the Software without restriction, including without limitation the rights
-   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   * copies of the Software, and to permit persons to whom the Software is
-   * furnished to do so, subject to the following conditions:
-   *
-   * The above copyright notice and this permission notice shall be included in
-   * all copies or substantial portions of the Software.
-   *
-   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   * THE SOFTWARE.
-   */
-  namespace glm
-  {
-    namespace quaternion
-    {
-      struct quat
-      {
-        quat(double w_, double x_, double y_, double z_)
-          :
-          w(w_),
-          x(x_),
-          y(y_),
-          z(z_)
-        {}
-
-
-        const quat operator-() const
-        {
-          return quat(-w, -x, -y, -z);
-        }
-
-        const quat operator-(quat &p) const
-        {
-          return quat(p.w-w, p.x-x, p.y-y, p.z-z);
-        }
-
-        quat operator*(double const &s) const
-        {
-          return quat(
-                   w * s, x * s, y * s, z * s);
-        }
-
-
-        quat operator/( double const &s)
-        {
-          return quat(
-                   w / s, x / s, y / s, z / s);
-        }
-
-        quat operator+(quat const &p)
-        {
-          return quat(w + p.w, x + p.x, y + p.y, z + p.z);
-        }
-
-        double w, x, y, z;
-      };
-
-      inline quat operator*(double const &s,quat const &q)
-      {
-        return quat(
-                 q.w * s, q.x * s, q.y * s, q.z * s);
-      }
-
-
-
-      inline double dot(quat u, quat v)
-      {
-        return u.w * v.w + u.x * v.x + u.y * v.y + u.z * v.z;
-      }
-
-      inline double mix(double const     &x,
-                        double const     &y,
-                        double const     &a )
-      {
-        return x * (1.0 - a) + y * a;
-      }
-
-      inline quat quat_cast(std::array<std::array<double,3>,3> const &m)
-      {
-        double fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
-        double fourYSquaredMinus1 = m[1][1] - m[0][0] - m[2][2];
-        double fourZSquaredMinus1 = m[2][2] - m[0][0] - m[1][1];
-        double fourWSquaredMinus1 = m[0][0] + m[1][1] + m[2][2];
-
-        int biggestIndex = 0;
-        double fourBiggestSquaredMinus1 = fourWSquaredMinus1;
-        if (fourXSquaredMinus1 > fourBiggestSquaredMinus1)
-          {
-            fourBiggestSquaredMinus1 = fourXSquaredMinus1;
-            biggestIndex = 1;
-          }
-        if (fourYSquaredMinus1 > fourBiggestSquaredMinus1)
-          {
-            fourBiggestSquaredMinus1 = fourYSquaredMinus1;
-            biggestIndex = 2;
-          }
-        if (fourZSquaredMinus1 > fourBiggestSquaredMinus1)
-          {
-            fourBiggestSquaredMinus1 = fourZSquaredMinus1;
-            biggestIndex = 3;
-          }
-
-        double biggestVal = sqrt(fourBiggestSquaredMinus1 + static_cast<double>(1)) * static_cast<double>(0.5);
-        double mult = static_cast<double>(0.25) / biggestVal;
-
-        switch (biggestIndex)
-          {
-            case 0:
-              return quat {biggestVal, (m[1][2] - m[2][1]) *mult, (m[2][0] - m[0][2]) *mult, (m[0][1] - m[1][0]) *mult};
-            case 1:
-              return quat {(m[1][2] - m[2][1]) *mult, biggestVal, (m[0][1] + m[1][0]) *mult, (m[2][0] + m[0][2]) *mult};
-            case 2:
-              return quat {(m[2][0] - m[0][2]) *mult, (m[0][1] + m[1][0]) *mult, biggestVal, (m[1][2] + m[2][1]) *mult};
-            case 3:
-              return quat {(m[0][1] - m[1][0]) *mult, (m[2][0] + m[0][2]) *mult, (m[1][2] + m[2][1]) *mult, biggestVal};
-            default: // Silence a -Wswitch-default warning in GCC. Should never actually get here. Assert is just for sanity.
-              throw (false);
-              return quat {1, 0, 0, 0};
-          }
-      }
-
-
-
-      inline std::array<std::array<double,3>,3> mat3_cast(quat const &q)
-      {
-        std::array<std::array<double,3>,3> Result;
-        double qxx(q.x * q.x);
-        double qyy(q.y * q.y);
-        double qzz(q.z * q.z);
-        double qxz(q.x * q.z);
-        double qxy(q.x * q.y);
-        double qyz(q.y * q.z);
-        double qwx(q.w * q.x);
-        double qwy(q.w * q.y);
-        double qwz(q.w * q.z);
-
-        Result[0][0] = double(1) - double(2) * (qyy +  qzz);
-        Result[0][1] = double(2) * (qxy + qwz);
-        Result[0][2] = double(2) * (qxz - qwy);
-
-        Result[1][0] = double(2) * (qxy - qwz);
-        Result[1][1] = double(1) - double(2) * (qxx +  qzz);
-        Result[1][2] = double(2) * (qyz + qwx);
-
-        Result[2][0] = double(2) * (qxz + qwy);
-        Result[2][1] = double(2) * (qyz - qwx);
-        Result[2][2] = double(1) - double(2) * (qxx +  qyy);
-        return Result;
-      }
-
-      inline quat slerp(quat const &x, quat const &y, double a)
-      {
-        static_assert(std::numeric_limits<double>::is_iec559, "'slerp' only accept floating-point inputs");
-
-        quat z = y;
-
-        double cosTheta = dot(x, y);
-
-        // If cosTheta < 0, the interpolation will take the long way around the sphere.
-        // To fix this, one quat must be negated.
-        if (cosTheta < static_cast<double>(0))
-          {
-            z = -y;
-
-            cosTheta = -cosTheta;
-          }
-
-        // Perform a linear interpolation when cosTheta is close to 1 to avoid side effect of sin(angle) becoming a zero denominator
-        if (cosTheta > 1.0 - std::numeric_limits<double>::epsilon())
-          {
-            // Linear interpolation
-            return quat(
-                     mix(x.w, z.w, a),
-                     mix(x.x, z.x, a),
-                     mix(x.y, z.y, a),
-                     mix(x.z, z.z, a));
-          }
-        else
-          {
-            // Essential Mathematics, page 467
-            double angle = acos(cosTheta);
-            return (sin((1.0 - a) * angle) * x + sin(a * angle) * z) / sin(angle);
-          }
-      }
-    }
-  }
-}
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/rapidjson/allocators.h.bak b/contrib/world_builder/include/rapidjson/allocators.h.bak
deleted file mode 100644
index 9e2aa49f7a3..00000000000
--- a/contrib/world_builder/include/rapidjson/allocators.h.bak
+++ /dev/null
@@ -1,308 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ALLOCATORS_H_
-#define RAPIDJSON_ALLOCATORS_H_
-
-#include "rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Allocator
-
-/*! \class rapidjson::Allocator
-    \brief Concept for allocating, resizing and freeing memory block.
-
-    Note that Malloc() and Realloc() are non-static but Free() is static.
-
-    So if an allocator need to support Free(), it needs to put its pointer in
-    the header of memory block.
-
-\code
-concept Allocator {
-    static const bool kNeedFree;    //!< Whether this allocator needs to call Free().
-
-    // Allocate a memory block.
-    // \param size of the memory block in bytes.
-    // \returns pointer to the memory block.
-    void* Malloc(size_t size);
-
-    // Resize a memory block.
-    // \param originalPtr The pointer to current memory block. Null pointer is permitted.
-    // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.)
-    // \param newSize the new size in bytes.
-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize);
-
-    // Free a memory block.
-    // \param pointer to the memory block. Null pointer is permitted.
-    static void Free(void *ptr);
-};
-\endcode
-*/
-
-
-/*! \def RAPIDJSON_ALLOCATOR_DEFUALT_CHUNK_CAPACITY
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-defined kDefaultChunkCapacity definition.
-
-    User can define this as any \c size that is a power of 2.
-*/
-
-#ifndef RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY
-#define RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY (64 * 1024)
-#endif
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CrtAllocator
-
-//! C-runtime library allocator.
-/*! This class is just wrapper for standard C library memory routines.
-    \note implements Allocator concept
-*/
-class CrtAllocator
-{
-  public:
-    static const bool kNeedFree = true;
-    void *Malloc(size_t size)
-    {
-      if (size) //  behavior of malloc(0) is implementation defined.
-        return std::malloc(size);
-      else
-        return NULL; // standardize to returning NULL.
-    }
-    void *Realloc(void *originalPtr, size_t originalSize, size_t newSize)
-    {
-      (void)originalSize;
-      if (newSize == 0)
-        {
-          std::free(originalPtr);
-          return NULL;
-        }
-      return std::realloc(originalPtr, newSize);
-    }
-    static void Free(void *ptr)
-    {
-      std::free(ptr);
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// MemoryPoolAllocator
-
-//! Default memory allocator used by the parser and DOM.
-/*! This allocator allocate memory blocks from pre-allocated memory chunks.
-
-    It does not free memory blocks. And Realloc() only allocate new memory.
-
-    The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.
-
-    User may also supply a buffer as the first chunk.
-
-    If the user-buffer is full then additional chunks are allocated by BaseAllocator.
-
-    The user-buffer is not deallocated by this allocator.
-
-    \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator.
-    \note implements Allocator concept
-*/
-template <typename BaseAllocator = CrtAllocator>
-class MemoryPoolAllocator
-{
-  public:
-    static const bool kNeedFree = false;    //!< Tell users that no need to call Free() with this allocator. (concept Allocator)
-
-    //! Constructor with chunkSize.
-    /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
-        \param baseAllocator The allocator for allocating memory chunks.
-    */
-    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator *baseAllocator = 0) :
-      chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
-    {
-    }
-
-    //! Constructor with user-supplied buffer.
-    /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.
-
-        The user buffer will not be deallocated when this allocator is destructed.
-
-        \param buffer User supplied buffer.
-        \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
-        \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
-        \param baseAllocator The allocator for allocating memory chunks.
-    */
-    MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator *baseAllocator = 0) :
-      chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
-    {
-      RAPIDJSON_ASSERT(buffer != 0);
-      RAPIDJSON_ASSERT(size > sizeof(ChunkHeader));
-      chunkHead_ = reinterpret_cast<ChunkHeader *>(buffer);
-      chunkHead_->capacity = size - sizeof(ChunkHeader);
-      chunkHead_->size = 0;
-      chunkHead_->next = 0;
-    }
-
-    //! Destructor.
-    /*! This deallocates all memory chunks, excluding the user-supplied buffer.
-    */
-    ~MemoryPoolAllocator()
-    {
-      Clear();
-      RAPIDJSON_DELETE(ownBaseAllocator_);
-    }
-
-    //! Deallocates all memory chunks, excluding the user-supplied buffer.
-    void Clear()
-    {
-      while (chunkHead_ && chunkHead_ != userBuffer_)
-        {
-          ChunkHeader *next = chunkHead_->next;
-          baseAllocator_->Free(chunkHead_);
-          chunkHead_ = next;
-        }
-      if (chunkHead_ && chunkHead_ == userBuffer_)
-        chunkHead_->size = 0; // Clear user buffer
-    }
-
-    //! Computes the total capacity of allocated memory chunks.
-    /*! \return total capacity in bytes.
-    */
-    size_t Capacity() const
-    {
-      size_t capacity = 0;
-      for (ChunkHeader *c = chunkHead_; c != 0; c = c->next)
-        capacity += c->capacity;
-      return capacity;
-    }
-
-    //! Computes the memory blocks allocated.
-    /*! \return total used bytes.
-    */
-    size_t Size() const
-    {
-      size_t size = 0;
-      for (ChunkHeader *c = chunkHead_; c != 0; c = c->next)
-        size += c->size;
-      return size;
-    }
-
-    //! Allocates a memory block. (concept Allocator)
-    void *Malloc(size_t size)
-    {
-      if (!size)
-        return NULL;
-
-      size = RAPIDJSON_ALIGN(size);
-      if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
-        if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
-          return NULL;
-
-      void *buffer = reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;
-      chunkHead_->size += size;
-      return buffer;
-    }
-
-    //! Resizes a memory block (concept Allocator)
-    void *Realloc(void *originalPtr, size_t originalSize, size_t newSize)
-    {
-      if (originalPtr == 0)
-        return Malloc(newSize);
-
-      if (newSize == 0)
-        return NULL;
-
-      originalSize = RAPIDJSON_ALIGN(originalSize);
-      newSize = RAPIDJSON_ALIGN(newSize);
-
-      // Do not shrink if new size is smaller than original
-      if (originalSize >= newSize)
-        return originalPtr;
-
-      // Simply expand it if it is the last allocation and there is sufficient space
-      if (originalPtr == reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize)
-        {
-          size_t increment = static_cast<size_t>(newSize - originalSize);
-          if (chunkHead_->size + increment <= chunkHead_->capacity)
-            {
-              chunkHead_->size += increment;
-              return originalPtr;
-            }
-        }
-
-      // Realloc process: allocate and copy memory, do not free original buffer.
-      if (void *newBuffer = Malloc(newSize))
-        {
-          if (originalSize)
-            std::memcpy(newBuffer, originalPtr, originalSize);
-          return newBuffer;
-        }
-      else
-        return NULL;
-    }
-
-    //! Frees a memory block (concept Allocator)
-    static void Free(void *ptr)
-    {
-      (void)ptr;  // Do nothing
-    }
-
-  private:
-    //! Copy constructor is not permitted.
-    MemoryPoolAllocator(const MemoryPoolAllocator &rhs) /* = delete */;
-    //! Copy assignment operator is not permitted.
-    MemoryPoolAllocator &operator=(const MemoryPoolAllocator &rhs) /* = delete */;
-
-    //! Creates a new chunk.
-    /*! \param capacity Capacity of the chunk in bytes.
-        \return true if success.
-    */
-    bool AddChunk(size_t capacity)
-    {
-      if (!baseAllocator_)
-        ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator)();
-      if (ChunkHeader *chunk = reinterpret_cast<ChunkHeader *>(baseAllocator_->Malloc(RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity)))
-        {
-          chunk->capacity = capacity;
-          chunk->size = 0;
-          chunk->next = chunkHead_;
-          chunkHead_ =  chunk;
-          return true;
-        }
-      else
-        return false;
-    }
-
-    static const int kDefaultChunkCapacity = RAPIDJSON_ALLOCATOR_DEFAULT_CHUNK_CAPACITY; //!< Default chunk capacity.
-
-    //! Chunk header for perpending to each chunk.
-    /*! Chunks are stored as a singly linked list.
-    */
-    struct ChunkHeader
-    {
-      size_t capacity;    //!< Capacity of the chunk in bytes (excluding the header itself).
-      size_t size;        //!< Current size of allocated memory in bytes.
-      ChunkHeader *next;  //!< Next chunk in the linked list.
-    };
-
-    ChunkHeader *chunkHead_;    //!< Head of the chunk linked-list. Only the head chunk serves allocation.
-    size_t chunk_capacity_;     //!< The minimum capacity of chunk when they are allocated.
-    void *userBuffer_;          //!< User supplied buffer.
-    BaseAllocator *baseAllocator_;  //!< base allocator for allocating memory chunks.
-    BaseAllocator *ownBaseAllocator_;   //!< base allocator created by this object.
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/contrib/world_builder/include/rapidjson/cursorstreamwrapper.h.bak b/contrib/world_builder/include/rapidjson/cursorstreamwrapper.h.bak
deleted file mode 100644
index fdaffb4e386..00000000000
--- a/contrib/world_builder/include/rapidjson/cursorstreamwrapper.h.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_CURSORSTREAMWRAPPER_H_
-#define RAPIDJSON_CURSORSTREAMWRAPPER_H_
-
-#include "stream.h"
-
-#if defined(__GNUC__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-
-//! Cursor stream wrapper for counting line and column number if error exists.
-/*!
-    \tparam InputStream     Any stream that implements Stream Concept
-*/
-template <typename InputStream, typename Encoding = UTF8<> >
-class CursorStreamWrapper : public GenericStreamWrapper<InputStream, Encoding>
-{
-  public:
-    typedef typename Encoding::Ch Ch;
-
-    CursorStreamWrapper(InputStream &is):
-      GenericStreamWrapper<InputStream, Encoding>(is), line_(1), col_(0) {}
-
-    // counting line and column number
-    Ch Take()
-    {
-      Ch ch = this->is_.Take();
-      if (ch == '\n')
-        {
-          line_ ++;
-          col_ = 0;
-        }
-      else
-        {
-          col_ ++;
-        }
-      return ch;
-    }
-
-    //! Get the error line number, if error exists.
-    size_t GetLine() const
-    {
-      return line_;
-    }
-    //! Get the error column number, if error exists.
-    size_t GetColumn() const
-    {
-      return col_;
-    }
-
-  private:
-    size_t line_;   //!< Current Line
-    size_t col_;    //!< Current Column
-};
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-RAPIDJSON_DIAG_POP
-#endif
-
-#if defined(__GNUC__)
-RAPIDJSON_DIAG_POP
-#endif
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_CURSORSTREAMWRAPPER_H_
diff --git a/contrib/world_builder/include/rapidjson/encodedstream.h.bak b/contrib/world_builder/include/rapidjson/encodedstream.h.bak
deleted file mode 100644
index 38b259332db..00000000000
--- a/contrib/world_builder/include/rapidjson/encodedstream.h.bak
+++ /dev/null
@@ -1,485 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ENCODEDSTREAM_H_
-#define RAPIDJSON_ENCODEDSTREAM_H_
-
-#include "stream.h"
-#include "memorystream.h"
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Input byte stream wrapper with a statically bound encoding.
-/*!
-    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
-    \tparam InputByteStream Type of input byte stream. For example, FileReadStream.
-*/
-template <typename Encoding, typename InputByteStream>
-class EncodedInputStream
-{
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-  public:
-    typedef typename Encoding::Ch Ch;
-
-    EncodedInputStream(InputByteStream &is) : is_(is)
-    {
-      current_ = Encoding::TakeBOM(is_);
-    }
-
-    Ch Peek() const
-    {
-      return current_;
-    }
-    Ch Take()
-    {
-      Ch c = current_;
-      current_ = Encoding::Take(is_);
-      return c;
-    }
-    size_t Tell() const
-    {
-      return is_.Tell();
-    }
-
-    // Not implemented
-    void Put(Ch)
-    {
-      RAPIDJSON_ASSERT(false);
-    }
-    void Flush()
-    {
-      RAPIDJSON_ASSERT(false);
-    }
-    Ch *PutBegin()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t PutEnd(Ch *)
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-
-  private:
-    EncodedInputStream(const EncodedInputStream &);
-    EncodedInputStream &operator=(const EncodedInputStream &);
-
-    InputByteStream &is_;
-    Ch current_;
-};
-
-//! Specialized for UTF8 MemoryStream.
-template <>
-class EncodedInputStream<UTF8<>, MemoryStream>
-{
-  public:
-    typedef UTF8<>::Ch Ch;
-
-    EncodedInputStream(MemoryStream &is) : is_(is)
-    {
-      if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
-      if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
-      if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
-    }
-    Ch Peek() const
-    {
-      return is_.Peek();
-    }
-    Ch Take()
-    {
-      return is_.Take();
-    }
-    size_t Tell() const
-    {
-      return is_.Tell();
-    }
-
-    // Not implemented
-    void Put(Ch) {}
-    void Flush() {}
-    Ch *PutBegin()
-    {
-      return 0;
-    }
-    size_t PutEnd(Ch *)
-    {
-      return 0;
-    }
-
-    MemoryStream &is_;
-
-  private:
-    EncodedInputStream(const EncodedInputStream &);
-    EncodedInputStream &operator=(const EncodedInputStream &);
-};
-
-//! Output byte stream wrapper with statically bound encoding.
-/*!
-    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
-    \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
-*/
-template <typename Encoding, typename OutputByteStream>
-class EncodedOutputStream
-{
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-  public:
-    typedef typename Encoding::Ch Ch;
-
-    EncodedOutputStream(OutputByteStream &os, bool putBOM = true) : os_(os)
-    {
-      if (putBOM)
-        Encoding::PutBOM(os_);
-    }
-
-    void Put(Ch c)
-    {
-      Encoding::Put(os_, c);
-    }
-    void Flush()
-    {
-      os_.Flush();
-    }
-
-    // Not implemented
-    Ch Peek() const
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    Ch Take()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t Tell() const
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    Ch *PutBegin()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t PutEnd(Ch *)
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-
-  private:
-    EncodedOutputStream(const EncodedOutputStream &);
-    EncodedOutputStream &operator=(const EncodedOutputStream &);
-
-    OutputByteStream &os_;
-};
-
-#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
-
-//! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
-/*!
-    \tparam CharType Type of character for reading.
-    \tparam InputByteStream type of input byte stream to be wrapped.
-*/
-template <typename CharType, typename InputByteStream>
-class AutoUTFInputStream
-{
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-  public:
-    typedef CharType Ch;
-
-    //! Constructor.
-    /*!
-        \param is input stream to be wrapped.
-        \param type UTF encoding type if it is not detected from the stream.
-    */
-    AutoUTFInputStream(InputByteStream &is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false)
-    {
-      RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
-      DetectType();
-      static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
-      takeFunc_ = f[type_];
-      current_ = takeFunc_(*is_);
-    }
-
-    UTFType GetType() const
-    {
-      return type_;
-    }
-    bool HasBOM() const
-    {
-      return hasBOM_;
-    }
-
-    Ch Peek() const
-    {
-      return current_;
-    }
-    Ch Take()
-    {
-      Ch c = current_;
-      current_ = takeFunc_(*is_);
-      return c;
-    }
-    size_t Tell() const
-    {
-      return is_->Tell();
-    }
-
-    // Not implemented
-    void Put(Ch)
-    {
-      RAPIDJSON_ASSERT(false);
-    }
-    void Flush()
-    {
-      RAPIDJSON_ASSERT(false);
-    }
-    Ch *PutBegin()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t PutEnd(Ch *)
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-
-  private:
-    AutoUTFInputStream(const AutoUTFInputStream &);
-    AutoUTFInputStream &operator=(const AutoUTFInputStream &);
-
-    // Detect encoding type with BOM or RFC 4627
-    void DetectType()
-    {
-      // BOM (Byte Order Mark):
-      // 00 00 FE FF  UTF-32BE
-      // FF FE 00 00  UTF-32LE
-      // FE FF        UTF-16BE
-      // FF FE        UTF-16LE
-      // EF BB BF     UTF-8
-
-      const unsigned char *c = reinterpret_cast<const unsigned char *>(is_->Peek4());
-      if (!c)
-        return;
-
-      unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
-      hasBOM_ = false;
-      if (bom == 0xFFFE0000)
-        {
-          type_ = kUTF32BE;
-          hasBOM_ = true;
-          is_->Take();
-          is_->Take();
-          is_->Take();
-          is_->Take();
-        }
-      else if (bom == 0x0000FEFF)
-        {
-          type_ = kUTF32LE;
-          hasBOM_ = true;
-          is_->Take();
-          is_->Take();
-          is_->Take();
-          is_->Take();
-        }
-      else if ((bom & 0xFFFF) == 0xFFFE)
-        {
-          type_ = kUTF16BE;
-          hasBOM_ = true;
-          is_->Take();
-          is_->Take();
-        }
-      else if ((bom & 0xFFFF) == 0xFEFF)
-        {
-          type_ = kUTF16LE;
-          hasBOM_ = true;
-          is_->Take();
-          is_->Take();
-        }
-      else if ((bom & 0xFFFFFF) == 0xBFBBEF)
-        {
-          type_ = kUTF8;
-          hasBOM_ = true;
-          is_->Take();
-          is_->Take();
-          is_->Take();
-        }
-
-      // RFC 4627: Section 3
-      // "Since the first two characters of a JSON text will always be ASCII
-      // characters [RFC0020], it is possible to determine whether an octet
-      // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
-      // at the pattern of nulls in the first four octets."
-      // 00 00 00 xx  UTF-32BE
-      // 00 xx 00 xx  UTF-16BE
-      // xx 00 00 00  UTF-32LE
-      // xx 00 xx 00  UTF-16LE
-      // xx xx xx xx  UTF-8
-
-      if (!hasBOM_)
-        {
-          int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
-          switch (pattern)
-            {
-              case 0x08:
-                type_ = kUTF32BE;
-                break;
-              case 0x0A:
-                type_ = kUTF16BE;
-                break;
-              case 0x01:
-                type_ = kUTF32LE;
-                break;
-              case 0x05:
-                type_ = kUTF16LE;
-                break;
-              case 0x0F:
-                type_ = kUTF8;
-                break;
-              default:
-                break; // Use type defined by user.
-            }
-        }
-
-      // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
-      if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
-      if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
-    }
-
-    typedef Ch (*TakeFunc)(InputByteStream &is);
-    InputByteStream *is_;
-    UTFType type_;
-    Ch current_;
-    TakeFunc takeFunc_;
-    bool hasBOM_;
-};
-
-//! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
-/*!
-    \tparam CharType Type of character for writing.
-    \tparam OutputByteStream type of output byte stream to be wrapped.
-*/
-template <typename CharType, typename OutputByteStream>
-class AutoUTFOutputStream
-{
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-  public:
-    typedef CharType Ch;
-
-    //! Constructor.
-    /*!
-        \param os output stream to be wrapped.
-        \param type UTF encoding type.
-        \param putBOM Whether to write BOM at the beginning of the stream.
-    */
-    AutoUTFOutputStream(OutputByteStream &os, UTFType type, bool putBOM) : os_(&os), type_(type)
-    {
-      RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
-
-      // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
-      if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
-      if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
-
-      static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
-      putFunc_ = f[type_];
-
-      if (putBOM)
-        PutBOM();
-    }
-
-    UTFType GetType() const
-    {
-      return type_;
-    }
-
-    void Put(Ch c)
-    {
-      putFunc_(*os_, c);
-    }
-    void Flush()
-    {
-      os_->Flush();
-    }
-
-    // Not implemented
-    Ch Peek() const
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    Ch Take()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t Tell() const
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    Ch *PutBegin()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t PutEnd(Ch *)
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-
-  private:
-    AutoUTFOutputStream(const AutoUTFOutputStream &);
-    AutoUTFOutputStream &operator=(const AutoUTFOutputStream &);
-
-    void PutBOM()
-    {
-      typedef void (*PutBOMFunc)(OutputByteStream &);
-      static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
-      f[type_](*os_);
-    }
-
-    typedef void (*PutFunc)(OutputByteStream &, Ch);
-
-    OutputByteStream *os_;
-    UTFType type_;
-    PutFunc putFunc_;
-};
-
-#undef RAPIDJSON_ENCODINGS_FUNC
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/contrib/world_builder/include/rapidjson/encodings.h.bak b/contrib/world_builder/include/rapidjson/encodings.h.bak
deleted file mode 100644
index 8d966002514..00000000000
--- a/contrib/world_builder/include/rapidjson/encodings.h.bak
+++ /dev/null
@@ -1,855 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ENCODINGS_H_
-#define RAPIDJSON_ENCODINGS_H_
-
-#include "rapidjson.h"
-
-#if defined(_MSC_VER) && !defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-#elif defined(__GNUC__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-RAPIDJSON_DIAG_OFF(overflow)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Encoding
-
-/*! \class rapidjson::Encoding
-    \brief Concept for encoding of Unicode characters.
-
-\code
-concept Encoding {
-    typename Ch;    //! Type of character. A "character" is actually a code unit in unicode's definition.
-
-    enum { supportUnicode = 1 }; // or 0 if not supporting unicode
-
-    //! \brief Encode a Unicode codepoint to an output stream.
-    //! \param os Output stream.
-    //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively.
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint);
-
-    //! \brief Decode a Unicode codepoint from an input stream.
-    //! \param is Input stream.
-    //! \param codepoint Output of the unicode codepoint.
-    //! \return true if a valid codepoint can be decoded from the stream.
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint);
-
-    //! \brief Validate one Unicode codepoint from an encoded stream.
-    //! \param is Input stream to obtain codepoint.
-    //! \param os Output for copying one codepoint.
-    //! \return true if it is valid.
-    //! \note This function just validating and copying the codepoint without actually decode it.
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os);
-
-    // The following functions are deal with byte streams.
-
-    //! Take a character from input byte stream, skip BOM if exist.
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is);
-
-    //! Take a character from input byte stream.
-    template <typename InputByteStream>
-    static Ch Take(InputByteStream& is);
-
-    //! Put BOM to output byte stream.
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os);
-
-    //! Put a character to output byte stream.
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, Ch c);
-};
-\endcode
-*/
-
-///////////////////////////////////////////////////////////////////////////////
-// UTF8
-
-//! UTF-8 encoding.
-/*! http://en.wikipedia.org/wiki/UTF-8
-    http://tools.ietf.org/html/rfc3629
-    \tparam CharType Code unit for storing 8-bit UTF-8 data. Default is char.
-    \note implements Encoding concept
-*/
-template<typename CharType = char>
-struct UTF8
-{
-  typedef CharType Ch;
-
-  enum { supportUnicode = 1 };
-
-  template<typename OutputStream>
-  static void Encode(OutputStream &os, unsigned codepoint)
-  {
-    if (codepoint <= 0x7F)
-      os.Put(static_cast<Ch>(codepoint & 0xFF));
-    else if (codepoint <= 0x7FF)
-      {
-        os.Put(static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
-        os.Put(static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
-      }
-    else if (codepoint <= 0xFFFF)
-      {
-        os.Put(static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
-        os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-        os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-      }
-    else
-      {
-        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-        os.Put(static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
-        os.Put(static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
-        os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-        os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-      }
-  }
-
-  template<typename OutputStream>
-  static void EncodeUnsafe(OutputStream &os, unsigned codepoint)
-  {
-    if (codepoint <= 0x7F)
-      PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
-    else if (codepoint <= 0x7FF)
-      {
-        PutUnsafe(os, static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
-        PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
-      }
-    else if (codepoint <= 0xFFFF)
-      {
-        PutUnsafe(os, static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
-        PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-        PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-      }
-    else
-      {
-        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-        PutUnsafe(os, static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
-        PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
-        PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-        PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-      }
-  }
-
-  template <typename InputStream>
-  static bool Decode(InputStream &is, unsigned *codepoint)
-  {
-#define RAPIDJSON_COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
-#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
-    typename InputStream::Ch c = is.Take();
-    if (!(c & 0x80))
-      {
-        *codepoint = static_cast<unsigned char>(c);
-        return true;
-      }
-
-    unsigned char type = GetRange(static_cast<unsigned char>(c));
-    if (type >= 32)
-      {
-        *codepoint = 0;
-      }
-    else
-      {
-        *codepoint = (0xFFu >> type) & static_cast<unsigned char>(c);
-      }
-    bool result = true;
-    switch (type)
-      {
-        case 2:
-          RAPIDJSON_TAIL();
-          return result;
-        case 3:
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          return result;
-        case 4:
-          RAPIDJSON_COPY();
-          RAPIDJSON_TRANS(0x50);
-          RAPIDJSON_TAIL();
-          return result;
-        case 5:
-          RAPIDJSON_COPY();
-          RAPIDJSON_TRANS(0x10);
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          return result;
-        case 6:
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          return result;
-        case 10:
-          RAPIDJSON_COPY();
-          RAPIDJSON_TRANS(0x20);
-          RAPIDJSON_TAIL();
-          return result;
-        case 11:
-          RAPIDJSON_COPY();
-          RAPIDJSON_TRANS(0x60);
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          return result;
-        default:
-          return false;
-      }
-#undef RAPIDJSON_COPY
-#undef RAPIDJSON_TRANS
-#undef RAPIDJSON_TAIL
-  }
-
-  template <typename InputStream, typename OutputStream>
-  static bool Validate(InputStream &is, OutputStream &os)
-  {
-#define RAPIDJSON_COPY() os.Put(c = is.Take())
-#define RAPIDJSON_TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
-#define RAPIDJSON_TAIL() RAPIDJSON_COPY(); RAPIDJSON_TRANS(0x70)
-    Ch c;
-    RAPIDJSON_COPY();
-    if (!(c & 0x80))
-      return true;
-
-    bool result = true;
-    switch (GetRange(static_cast<unsigned char>(c)))
-      {
-        case 2:
-          RAPIDJSON_TAIL();
-          return result;
-        case 3:
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          return result;
-        case 4:
-          RAPIDJSON_COPY();
-          RAPIDJSON_TRANS(0x50);
-          RAPIDJSON_TAIL();
-          return result;
-        case 5:
-          RAPIDJSON_COPY();
-          RAPIDJSON_TRANS(0x10);
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          return result;
-        case 6:
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          return result;
-        case 10:
-          RAPIDJSON_COPY();
-          RAPIDJSON_TRANS(0x20);
-          RAPIDJSON_TAIL();
-          return result;
-        case 11:
-          RAPIDJSON_COPY();
-          RAPIDJSON_TRANS(0x60);
-          RAPIDJSON_TAIL();
-          RAPIDJSON_TAIL();
-          return result;
-        default:
-          return false;
-      }
-#undef RAPIDJSON_COPY
-#undef RAPIDJSON_TRANS
-#undef RAPIDJSON_TAIL
-  }
-
-  static unsigned char GetRange(unsigned char c)
-  {
-    // Referring to DFA of http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-    // With new mapping 1 -> 0x10, 7 -> 0x20, 9 -> 0x40, such that AND operation can test multiple types.
-    static const unsigned char type[] =
-    {
-      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-      0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
-      0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
-      0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
-      0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
-      8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-      10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
-    };
-    return type[c];
-  }
-
-  template <typename InputByteStream>
-  static CharType TakeBOM(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    typename InputByteStream::Ch c = Take(is);
-    if (static_cast<unsigned char>(c) != 0xEFu) return c;
-    c = is.Take();
-    if (static_cast<unsigned char>(c) != 0xBBu) return c;
-    c = is.Take();
-    if (static_cast<unsigned char>(c) != 0xBFu) return c;
-    c = is.Take();
-    return c;
-  }
-
-  template <typename InputByteStream>
-  static Ch Take(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    return static_cast<Ch>(is.Take());
-  }
-
-  template <typename OutputByteStream>
-  static void PutBOM(OutputByteStream &os)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xEFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xBBu));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xBFu));
-  }
-
-  template <typename OutputByteStream>
-  static void Put(OutputByteStream &os, Ch c)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>(c));
-  }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// UTF16
-
-//! UTF-16 encoding.
-/*! http://en.wikipedia.org/wiki/UTF-16
-    http://tools.ietf.org/html/rfc2781
-    \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead.
-    \note implements Encoding concept
-
-    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
-    For streaming, use UTF16LE and UTF16BE, which handle endianness.
-*/
-template<typename CharType = wchar_t>
-struct UTF16
-{
-  typedef CharType Ch;
-  RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 2);
-
-  enum { supportUnicode = 1 };
-
-  template<typename OutputStream>
-  static void Encode(OutputStream &os, unsigned codepoint)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
-    if (codepoint <= 0xFFFF)
-      {
-        RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair
-        os.Put(static_cast<typename OutputStream::Ch>(codepoint));
-      }
-    else
-      {
-        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-        unsigned v = codepoint - 0x10000;
-        os.Put(static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
-        os.Put(static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
-      }
-  }
-
-
-  template<typename OutputStream>
-  static void EncodeUnsafe(OutputStream &os, unsigned codepoint)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
-    if (codepoint <= 0xFFFF)
-      {
-        RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair
-        PutUnsafe(os, static_cast<typename OutputStream::Ch>(codepoint));
-      }
-    else
-      {
-        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-        unsigned v = codepoint - 0x10000;
-        PutUnsafe(os, static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
-        PutUnsafe(os, static_cast<typename OutputStream::Ch>((v & 0x3FF) | 0xDC00));
-      }
-  }
-
-  template <typename InputStream>
-  static bool Decode(InputStream &is, unsigned *codepoint)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
-    typename InputStream::Ch c = is.Take();
-    if (c < 0xD800 || c > 0xDFFF)
-      {
-        *codepoint = static_cast<unsigned>(c);
-        return true;
-      }
-    else if (c <= 0xDBFF)
-      {
-        *codepoint = (static_cast<unsigned>(c) & 0x3FF) << 10;
-        c = is.Take();
-        *codepoint |= (static_cast<unsigned>(c) & 0x3FF);
-        *codepoint += 0x10000;
-        return c >= 0xDC00 && c <= 0xDFFF;
-      }
-    return false;
-  }
-
-  template <typename InputStream, typename OutputStream>
-  static bool Validate(InputStream &is, OutputStream &os)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
-    typename InputStream::Ch c;
-    os.Put(static_cast<typename OutputStream::Ch>(c = is.Take()));
-    if (c < 0xD800 || c > 0xDFFF)
-      return true;
-    else if (c <= 0xDBFF)
-      {
-        os.Put(c = is.Take());
-        return c >= 0xDC00 && c <= 0xDFFF;
-      }
-    return false;
-  }
-};
-
-//! UTF-16 little endian encoding.
-template<typename CharType = wchar_t>
-struct UTF16LE : UTF16<CharType>
-{
-  template <typename InputByteStream>
-  static CharType TakeBOM(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    CharType c = Take(is);
-    return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
-  }
-
-  template <typename InputByteStream>
-  static CharType Take(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    unsigned c = static_cast<uint8_t>(is.Take());
-    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
-    return static_cast<CharType>(c);
-  }
-
-  template <typename OutputByteStream>
-  static void PutBOM(OutputByteStream &os)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
-  }
-
-  template <typename OutputByteStream>
-  static void Put(OutputByteStream &os, CharType c)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
-  }
-};
-
-//! UTF-16 big endian encoding.
-template<typename CharType = wchar_t>
-struct UTF16BE : UTF16<CharType>
-{
-  template <typename InputByteStream>
-  static CharType TakeBOM(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    CharType c = Take(is);
-    return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
-  }
-
-  template <typename InputByteStream>
-  static CharType Take(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
-    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
-    return static_cast<CharType>(c);
-  }
-
-  template <typename OutputByteStream>
-  static void PutBOM(OutputByteStream &os)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
-  }
-
-  template <typename OutputByteStream>
-  static void Put(OutputByteStream &os, CharType c)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
-  }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// UTF32
-
-//! UTF-32 encoding.
-/*! http://en.wikipedia.org/wiki/UTF-32
-    \tparam CharType Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead.
-    \note implements Encoding concept
-
-    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
-    For streaming, use UTF32LE and UTF32BE, which handle endianness.
-*/
-template<typename CharType = unsigned>
-struct UTF32
-{
-  typedef CharType Ch;
-  RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 4);
-
-  enum { supportUnicode = 1 };
-
-  template<typename OutputStream>
-  static void Encode(OutputStream &os, unsigned codepoint)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
-    RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-    os.Put(codepoint);
-  }
-
-  template<typename OutputStream>
-  static void EncodeUnsafe(OutputStream &os, unsigned codepoint)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
-    RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-    PutUnsafe(os, codepoint);
-  }
-
-  template <typename InputStream>
-  static bool Decode(InputStream &is, unsigned *codepoint)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
-    Ch c = is.Take();
-    *codepoint = c;
-    return c <= 0x10FFFF;
-  }
-
-  template <typename InputStream, typename OutputStream>
-  static bool Validate(InputStream &is, OutputStream &os)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
-    Ch c;
-    os.Put(c = is.Take());
-    return c <= 0x10FFFF;
-  }
-};
-
-//! UTF-32 little endian enocoding.
-template<typename CharType = unsigned>
-struct UTF32LE : UTF32<CharType>
-{
-  template <typename InputByteStream>
-  static CharType TakeBOM(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    CharType c = Take(is);
-    return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c;
-  }
-
-  template <typename InputByteStream>
-  static CharType Take(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    unsigned c = static_cast<uint8_t>(is.Take());
-    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
-    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
-    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
-    return static_cast<CharType>(c);
-  }
-
-  template <typename OutputByteStream>
-  static void PutBOM(OutputByteStream &os)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
-  }
-
-  template <typename OutputByteStream>
-  static void Put(OutputByteStream &os, CharType c)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
-  }
-};
-
-//! UTF-32 big endian encoding.
-template<typename CharType = unsigned>
-struct UTF32BE : UTF32<CharType>
-{
-  template <typename InputByteStream>
-  static CharType TakeBOM(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    CharType c = Take(is);
-    return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c;
-  }
-
-  template <typename InputByteStream>
-  static CharType Take(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
-    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
-    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
-    c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
-    return static_cast<CharType>(c);
-  }
-
-  template <typename OutputByteStream>
-  static void PutBOM(OutputByteStream &os)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
-    os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
-  }
-
-  template <typename OutputByteStream>
-  static void Put(OutputByteStream &os, CharType c)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
-    os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
-  }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// ASCII
-
-//! ASCII encoding.
-/*! http://en.wikipedia.org/wiki/ASCII
-    \tparam CharType Code unit for storing 7-bit ASCII data. Default is char.
-    \note implements Encoding concept
-*/
-template<typename CharType = char>
-struct ASCII
-{
-  typedef CharType Ch;
-
-  enum { supportUnicode = 0 };
-
-  template<typename OutputStream>
-  static void Encode(OutputStream &os, unsigned codepoint)
-  {
-    RAPIDJSON_ASSERT(codepoint <= 0x7F);
-    os.Put(static_cast<Ch>(codepoint & 0xFF));
-  }
-
-  template<typename OutputStream>
-  static void EncodeUnsafe(OutputStream &os, unsigned codepoint)
-  {
-    RAPIDJSON_ASSERT(codepoint <= 0x7F);
-    PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
-  }
-
-  template <typename InputStream>
-  static bool Decode(InputStream &is, unsigned *codepoint)
-  {
-    uint8_t c = static_cast<uint8_t>(is.Take());
-    *codepoint = c;
-    return c <= 0X7F;
-  }
-
-  template <typename InputStream, typename OutputStream>
-  static bool Validate(InputStream &is, OutputStream &os)
-  {
-    uint8_t c = static_cast<uint8_t>(is.Take());
-    os.Put(static_cast<typename OutputStream::Ch>(c));
-    return c <= 0x7F;
-  }
-
-  template <typename InputByteStream>
-  static CharType TakeBOM(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    uint8_t c = static_cast<uint8_t>(Take(is));
-    return static_cast<Ch>(c);
-  }
-
-  template <typename InputByteStream>
-  static Ch Take(InputByteStream &is)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-    return static_cast<Ch>(is.Take());
-  }
-
-  template <typename OutputByteStream>
-  static void PutBOM(OutputByteStream &os)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    (void)os;
-  }
-
-  template <typename OutputByteStream>
-  static void Put(OutputByteStream &os, Ch c)
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-    os.Put(static_cast<typename OutputByteStream::Ch>(c));
-  }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// AutoUTF
-
-//! Runtime-specified UTF encoding type of a stream.
-enum UTFType
-{
-  kUTF8 = 0,      //!< UTF-8.
-  kUTF16LE = 1,   //!< UTF-16 little endian.
-  kUTF16BE = 2,   //!< UTF-16 big endian.
-  kUTF32LE = 3,   //!< UTF-32 little endian.
-  kUTF32BE = 4    //!< UTF-32 big endian.
-};
-
-//! Dynamically select encoding according to stream's runtime-specified UTF encoding type.
-/*! \note This class can be used with AutoUTFInputtStream and AutoUTFOutputStream, which provides GetType().
-*/
-template<typename CharType>
-struct AutoUTF
-{
-  typedef CharType Ch;
-
-  enum { supportUnicode = 1 };
-
-#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
-
-  template<typename OutputStream>
-  static RAPIDJSON_FORCEINLINE void Encode(OutputStream &os, unsigned codepoint)
-  {
-    typedef void (*EncodeFunc)(OutputStream &, unsigned);
-    static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Encode) };
-    (*f[os.GetType()])(os, codepoint);
-  }
-
-  template<typename OutputStream>
-  static RAPIDJSON_FORCEINLINE void EncodeUnsafe(OutputStream &os, unsigned codepoint)
-  {
-    typedef void (*EncodeFunc)(OutputStream &, unsigned);
-    static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(EncodeUnsafe) };
-    (*f[os.GetType()])(os, codepoint);
-  }
-
-  template <typename InputStream>
-  static RAPIDJSON_FORCEINLINE bool Decode(InputStream &is, unsigned *codepoint)
-  {
-    typedef bool (*DecodeFunc)(InputStream &, unsigned *);
-    static const DecodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Decode) };
-    return (*f[is.GetType()])(is, codepoint);
-  }
-
-  template <typename InputStream, typename OutputStream>
-  static RAPIDJSON_FORCEINLINE bool Validate(InputStream &is, OutputStream &os)
-  {
-    typedef bool (*ValidateFunc)(InputStream &, OutputStream &);
-    static const ValidateFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Validate) };
-    return (*f[is.GetType()])(is, os);
-  }
-
-#undef RAPIDJSON_ENCODINGS_FUNC
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Transcoder
-
-//! Encoding conversion.
-template<typename SourceEncoding, typename TargetEncoding>
-struct Transcoder
-{
-  //! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream.
-  template<typename InputStream, typename OutputStream>
-  static RAPIDJSON_FORCEINLINE bool Transcode(InputStream &is, OutputStream &os)
-  {
-    unsigned codepoint;
-    if (!SourceEncoding::Decode(is, &codepoint))
-      return false;
-    TargetEncoding::Encode(os, codepoint);
-    return true;
-  }
-
-  template<typename InputStream, typename OutputStream>
-  static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream &is, OutputStream &os)
-  {
-    unsigned codepoint;
-    if (!SourceEncoding::Decode(is, &codepoint))
-      return false;
-    TargetEncoding::EncodeUnsafe(os, codepoint);
-    return true;
-  }
-
-  //! Validate one Unicode codepoint from an encoded stream.
-  template<typename InputStream, typename OutputStream>
-  static RAPIDJSON_FORCEINLINE bool Validate(InputStream &is, OutputStream &os)
-  {
-    return Transcode(is, os);   // Since source/target encoding is different, must transcode.
-  }
-};
-
-// Forward declaration.
-template<typename Stream>
-inline void PutUnsafe(Stream &stream, typename Stream::Ch c);
-
-//! Specialization of Transcoder with same source and target encoding.
-template<typename Encoding>
-struct Transcoder<Encoding, Encoding>
-{
-  template<typename InputStream, typename OutputStream>
-  static RAPIDJSON_FORCEINLINE bool Transcode(InputStream &is, OutputStream &os)
-  {
-    os.Put(is.Take());  // Just copy one code unit. This semantic is different from primary template class.
-    return true;
-  }
-
-  template<typename InputStream, typename OutputStream>
-  static RAPIDJSON_FORCEINLINE bool TranscodeUnsafe(InputStream &is, OutputStream &os)
-  {
-    PutUnsafe(os, is.Take());  // Just copy one code unit. This semantic is different from primary template class.
-    return true;
-  }
-
-  template<typename InputStream, typename OutputStream>
-  static RAPIDJSON_FORCEINLINE bool Validate(InputStream &is, OutputStream &os)
-  {
-    return Encoding::Validate(is, os);  // source/target encoding are the same
-  }
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__GNUC__) || (defined(_MSC_VER) && !defined(__clang__))
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/contrib/world_builder/include/rapidjson/error/en.h.bak b/contrib/world_builder/include/rapidjson/error/en.h.bak
deleted file mode 100644
index d817e0c5825..00000000000
--- a/contrib/world_builder/include/rapidjson/error/en.h.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ERROR_EN_H_
-#define RAPIDJSON_ERROR_EN_H_
-
-#include "error.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-//RAPIDJSON_DIAG_OFF(switch -enum)
-//  RAPIDJSON_DIAG_OFF(covered-switch -default)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Maps error code of parsing into error message.
-/*!
-    \ingroup RAPIDJSON_ERRORS
-    \param parseErrorCode Error code obtained in parsing.
-    \return the error message.
-    \note User can make a copy of this function for localization.
-        Using switch-case is safer for future modification of error codes.
-*/
-inline const RAPIDJSON_ERROR_CHARTYPE *GetParseError_En(ParseErrorCode parseErrorCode)
-{
-  switch (parseErrorCode)
-    {
-      case kParseErrorNone:
-        return RAPIDJSON_ERROR_STRING("No error.");
-
-      case kParseErrorDocumentEmpty:
-        return RAPIDJSON_ERROR_STRING("The document is empty.");
-      case kParseErrorDocumentRootNotSingular:
-        return RAPIDJSON_ERROR_STRING("The document root must not be followed by other values.");
-
-      case kParseErrorValueInvalid:
-        return RAPIDJSON_ERROR_STRING("Invalid value.");
-
-      case kParseErrorObjectMissName:
-        return RAPIDJSON_ERROR_STRING("Missing a name for object member.");
-      case kParseErrorObjectMissColon:
-        return RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member.");
-      case kParseErrorObjectMissCommaOrCurlyBracket:
-        return RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member.");
-
-      case kParseErrorArrayMissCommaOrSquareBracket:
-        return RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element.");
-
-      case kParseErrorStringUnicodeEscapeInvalidHex:
-        return RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string.");
-      case kParseErrorStringUnicodeSurrogateInvalid:
-        return RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid.");
-      case kParseErrorStringEscapeInvalid:
-        return RAPIDJSON_ERROR_STRING("Invalid escape character in string.");
-      case kParseErrorStringMissQuotationMark:
-        return RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string.");
-      case kParseErrorStringInvalidEncoding:
-        return RAPIDJSON_ERROR_STRING("Invalid encoding in string.");
-
-      case kParseErrorNumberTooBig:
-        return RAPIDJSON_ERROR_STRING("Number too big to be stored in double.");
-      case kParseErrorNumberMissFraction:
-        return RAPIDJSON_ERROR_STRING("Miss fraction part in number.");
-      case kParseErrorNumberMissExponent:
-        return RAPIDJSON_ERROR_STRING("Miss exponent in number.");
-
-      case kParseErrorTermination:
-        return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
-      case kParseErrorUnspecificSyntaxError:
-        return RAPIDJSON_ERROR_STRING("Unspecific syntax error.");
-
-      default:
-        return RAPIDJSON_ERROR_STRING("Unknown error.");
-    }
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_ERROR_EN_H_
diff --git a/contrib/world_builder/include/rapidjson/error/error.h.bak b/contrib/world_builder/include/rapidjson/error/error.h.bak
deleted file mode 100644
index 3e4058097da..00000000000
--- a/contrib/world_builder/include/rapidjson/error/error.h.bak
+++ /dev/null
@@ -1,200 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ERROR_ERROR_H_
-#define RAPIDJSON_ERROR_ERROR_H_
-
-#include "../rapidjson.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-/*! \file error.h */
-
-/*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ERROR_CHARTYPE
-
-//! Character type of error messages.
-/*! \ingroup RAPIDJSON_ERRORS
-    The default character type is \c char.
-    On Windows, user can define this macro as \c TCHAR for supporting both
-    unicode/non-unicode settings.
-*/
-#ifndef RAPIDJSON_ERROR_CHARTYPE
-#define RAPIDJSON_ERROR_CHARTYPE char
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ERROR_STRING
-
-//! Macro for converting string literial to \ref RAPIDJSON_ERROR_CHARTYPE[].
-/*! \ingroup RAPIDJSON_ERRORS
-    By default this conversion macro does nothing.
-    On Windows, user can define this macro as \c _T(x) for supporting both
-    unicode/non-unicode settings.
-*/
-#ifndef RAPIDJSON_ERROR_STRING
-#define RAPIDJSON_ERROR_STRING(x) x
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// ParseErrorCode
-
-//! Error code of parsing.
-/*! \ingroup RAPIDJSON_ERRORS
-    \see GenericReader::Parse, GenericReader::GetParseErrorCode
-*/
-enum ParseErrorCode
-{
-  kParseErrorNone = 0,                        //!< No error.
-
-  kParseErrorDocumentEmpty,                   //!< The document is empty.
-  kParseErrorDocumentRootNotSingular,         //!< The document root must not follow by other values.
-
-  kParseErrorValueInvalid,                    //!< Invalid value.
-
-  kParseErrorObjectMissName,                  //!< Missing a name for object member.
-  kParseErrorObjectMissColon,                 //!< Missing a colon after a name of object member.
-  kParseErrorObjectMissCommaOrCurlyBracket,   //!< Missing a comma or '}' after an object member.
-
-  kParseErrorArrayMissCommaOrSquareBracket,   //!< Missing a comma or ']' after an array element.
-
-  kParseErrorStringUnicodeEscapeInvalidHex,   //!< Incorrect hex digit after \\u escape in string.
-  kParseErrorStringUnicodeSurrogateInvalid,   //!< The surrogate pair in string is invalid.
-  kParseErrorStringEscapeInvalid,             //!< Invalid escape character in string.
-  kParseErrorStringMissQuotationMark,         //!< Missing a closing quotation mark in string.
-  kParseErrorStringInvalidEncoding,           //!< Invalid encoding in string.
-
-  kParseErrorNumberTooBig,                    //!< Number too big to be stored in double.
-  kParseErrorNumberMissFraction,              //!< Miss fraction part in number.
-  kParseErrorNumberMissExponent,              //!< Miss exponent in number.
-
-  kParseErrorTermination,                     //!< Parsing was terminated.
-  kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
-};
-
-//! Result of parsing (wraps ParseErrorCode)
-/*!
-    \ingroup RAPIDJSON_ERRORS
-    \code
-        Document doc;
-        ParseResult ok = doc.Parse("[42]");
-        if (!ok) {
-            fprintf(stderr, "JSON parse error: %s (%u)",
-                    GetParseError_En(ok.Code()), ok.Offset());
-            exit(EXIT_FAILURE);
-        }
-    \endcode
-    \see GenericReader::Parse, GenericDocument::Parse
-*/
-struct ParseResult
-{
-    //!! Unspecified boolean type
-    typedef bool (ParseResult::*BooleanType)() const;
-  public:
-    //! Default constructor, no error.
-    ParseResult() : code_(kParseErrorNone), offset_(0) {}
-    //! Constructor to set an error.
-    ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}
-
-    //! Get the error code.
-    ParseErrorCode Code() const
-    {
-      return code_;
-    }
-    //! Get the error offset, if \ref IsError(), 0 otherwise.
-    size_t Offset() const
-    {
-      return offset_;
-    }
-
-    //! Explicit conversion to \c bool, returns \c true, iff !\ref IsError().
-    operator BooleanType() const
-    {
-      return !IsError() ? &ParseResult::IsError : NULL;
-    }
-    //! Whether the result is an error.
-    bool IsError() const
-    {
-      return code_ != kParseErrorNone;
-    }
-
-    bool operator==(const ParseResult &that) const
-    {
-      return code_ == that.code_;
-    }
-    bool operator==(ParseErrorCode code) const
-    {
-      return code_ == code;
-    }
-    friend bool operator==(ParseErrorCode code, const ParseResult &err)
-    {
-      return code == err.code_;
-    }
-
-    bool operator!=(const ParseResult &that) const
-    {
-      return !(*this == that);
-    }
-    bool operator!=(ParseErrorCode code) const
-    {
-      return !(*this == code);
-    }
-    friend bool operator!=(ParseErrorCode code, const ParseResult &err)
-    {
-      return err != code;
-    }
-
-    //! Reset error code.
-    void Clear()
-    {
-      Set(kParseErrorNone);
-    }
-    //! Update error code and offset.
-    void Set(ParseErrorCode code, size_t offset = 0)
-    {
-      code_ = code;
-      offset_ = offset;
-    }
-
-  private:
-    ParseErrorCode code_;
-    size_t offset_;
-};
-
-//! Function pointer type of GetParseError().
-/*! \ingroup RAPIDJSON_ERRORS
-
-    This is the prototype for \c GetParseError_X(), where \c X is a locale.
-    User can dynamically change locale in runtime, e.g.:
-\code
-    GetParseErrorFunc GetParseError = GetParseError_En; // or whatever
-    const RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode());
-\endcode
-*/
-typedef const RAPIDJSON_ERROR_CHARTYPE *(*GetParseErrorFunc)(ParseErrorCode);
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_ERROR_ERROR_H_
diff --git a/contrib/world_builder/include/rapidjson/filereadstream.h.bak b/contrib/world_builder/include/rapidjson/filereadstream.h.bak
deleted file mode 100644
index 076e0e48f0f..00000000000
--- a/contrib/world_builder/include/rapidjson/filereadstream.h.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_FILEREADSTREAM_H_
-#define RAPIDJSON_FILEREADSTREAM_H_
-
-#include "stream.h"
-#include <cstdio>
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-RAPIDJSON_DIAG_OFF(unreachable-code)
-RAPIDJSON_DIAG_OFF(missing-noreturn)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! File byte stream for input using fread().
-/*!
-    \note implements Stream concept
-*/
-class FileReadStream
-{
-  public:
-    typedef char Ch;    //!< Character type (byte).
-
-    //! Constructor.
-    /*!
-        \param fp File pointer opened for read.
-        \param buffer user-supplied buffer.
-        \param bufferSize size of buffer in bytes. Must >=4 bytes.
-    */
-    FileReadStream(std::FILE *fp, char *buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false)
-    {
-      RAPIDJSON_ASSERT(fp_ != 0);
-      RAPIDJSON_ASSERT(bufferSize >= 4);
-      Read();
-    }
-
-    Ch Peek() const
-    {
-      return *current_;
-    }
-    Ch Take()
-    {
-      Ch c = *current_;
-      Read();
-      return c;
-    }
-    size_t Tell() const
-    {
-      return count_ + static_cast<size_t>(current_ - buffer_);
-    }
-
-    // Not implemented
-    void Put(Ch)
-    {
-      RAPIDJSON_ASSERT(false);
-    }
-    void Flush()
-    {
-      RAPIDJSON_ASSERT(false);
-    }
-    Ch *PutBegin()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t PutEnd(Ch *)
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-
-    // For encoding detection only.
-    const Ch *Peek4() const
-    {
-      return (current_ + 4 <= bufferLast_) ? current_ : 0;
-    }
-
-  private:
-    void Read()
-    {
-      if (current_ < bufferLast_)
-        ++current_;
-      else if (!eof_)
-        {
-          count_ += readCount_;
-          readCount_ = std::fread(buffer_, 1, bufferSize_, fp_);
-          bufferLast_ = buffer_ + readCount_ - 1;
-          current_ = buffer_;
-
-          if (readCount_ < bufferSize_)
-            {
-              buffer_[readCount_] = '\0';
-              ++bufferLast_;
-              eof_ = true;
-            }
-        }
-    }
-
-    std::FILE *fp_;
-    Ch *buffer_;
-    size_t bufferSize_;
-    Ch *bufferLast_;
-    Ch *current_;
-    size_t readCount_;
-    size_t count_;  //!< Number of characters read
-    bool eof_;
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/contrib/world_builder/include/rapidjson/filewritestream.h.bak b/contrib/world_builder/include/rapidjson/filewritestream.h.bak
deleted file mode 100644
index 291e6991c87..00000000000
--- a/contrib/world_builder/include/rapidjson/filewritestream.h.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_FILEWRITESTREAM_H_
-#define RAPIDJSON_FILEWRITESTREAM_H_
-
-#include "stream.h"
-#include <cstdio>
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(unreachable-code)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Wrapper of C file stream for output using fwrite().
-/*!
-    \note implements Stream concept
-*/
-class FileWriteStream
-{
-  public:
-    typedef char Ch;    //!< Character type. Only support char.
-
-    FileWriteStream(std::FILE *fp, char *buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_)
-    {
-      RAPIDJSON_ASSERT(fp_ != 0);
-    }
-
-    void Put(char c)
-    {
-      if (current_ >= bufferEnd_)
-        Flush();
-
-      *current_++ = c;
-    }
-
-    void PutN(char c, size_t n)
-    {
-      size_t avail = static_cast<size_t>(bufferEnd_ - current_);
-      while (n > avail)
-        {
-          std::memset(current_, c, avail);
-          current_ += avail;
-          Flush();
-          n -= avail;
-          avail = static_cast<size_t>(bufferEnd_ - current_);
-        }
-
-      if (n > 0)
-        {
-          std::memset(current_, c, n);
-          current_ += n;
-        }
-    }
-
-    void Flush()
-    {
-      if (current_ != buffer_)
-        {
-          size_t result = std::fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
-          if (result < static_cast<size_t>(current_ - buffer_))
-            {
-              // failure deliberately ignored at this time
-              // added to avoid warn_unused_result build errors
-            }
-          current_ = buffer_;
-        }
-    }
-
-    // Not implemented
-    char Peek() const
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    char Take()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t Tell() const
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    char *PutBegin()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t PutEnd(char *)
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-
-  private:
-    // Prohibit copy constructor & assignment operator.
-    FileWriteStream(const FileWriteStream &);
-    FileWriteStream &operator=(const FileWriteStream &);
-
-    std::FILE *fp_;
-    char *buffer_;
-    char *bufferEnd_;
-    char *current_;
-};
-
-//! Implement specialized version of PutN() with memset() for better performance.
-template<>
-inline void PutN(FileWriteStream &stream, char c, size_t n)
-{
-  stream.PutN(c, n);
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/contrib/world_builder/include/rapidjson/fwd.h.bak b/contrib/world_builder/include/rapidjson/fwd.h.bak
deleted file mode 100644
index f280a4ea30b..00000000000
--- a/contrib/world_builder/include/rapidjson/fwd.h.bak
+++ /dev/null
@@ -1,151 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_FWD_H_
-#define RAPIDJSON_FWD_H_
-
-#include "rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-// encodings.h
-
-template<typename CharType> struct UTF8;
-template<typename CharType> struct UTF16;
-template<typename CharType> struct UTF16BE;
-template<typename CharType> struct UTF16LE;
-template<typename CharType> struct UTF32;
-template<typename CharType> struct UTF32BE;
-template<typename CharType> struct UTF32LE;
-template<typename CharType> struct ASCII;
-template<typename CharType> struct AutoUTF;
-
-template<typename SourceEncoding, typename TargetEncoding>
-struct Transcoder;
-
-// allocators.h
-
-class CrtAllocator;
-
-template <typename BaseAllocator>
-class MemoryPoolAllocator;
-
-// stream.h
-
-template <typename Encoding>
-struct GenericStringStream;
-
-typedef GenericStringStream<UTF8<char> > StringStream;
-
-template <typename Encoding>
-struct GenericInsituStringStream;
-
-typedef GenericInsituStringStream<UTF8<char> > InsituStringStream;
-
-// stringbuffer.h
-
-template <typename Encoding, typename Allocator>
-class GenericStringBuffer;
-
-typedef GenericStringBuffer<UTF8<char>, CrtAllocator> StringBuffer;
-
-// filereadstream.h
-
-class FileReadStream;
-
-// filewritestream.h
-
-class FileWriteStream;
-
-// memorybuffer.h
-
-template <typename Allocator>
-struct GenericMemoryBuffer;
-
-typedef GenericMemoryBuffer<CrtAllocator> MemoryBuffer;
-
-// memorystream.h
-
-struct MemoryStream;
-
-// reader.h
-
-template<typename Encoding, typename Derived>
-struct BaseReaderHandler;
-
-template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator>
-class GenericReader;
-
-typedef GenericReader<UTF8<char>, UTF8<char>, CrtAllocator> Reader;
-
-// writer.h
-
-template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
-class Writer;
-
-// prettywriter.h
-
-template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
-class PrettyWriter;
-
-// document.h
-
-template <typename Encoding, typename Allocator>
-struct GenericMember;
-
-template <bool Const, typename Encoding, typename Allocator>
-class GenericMemberIterator;
-
-template<typename CharType>
-struct GenericStringRef;
-
-template <typename Encoding, typename Allocator>
-class GenericValue;
-
-typedef GenericValue<UTF8<char>, MemoryPoolAllocator<CrtAllocator> > Value;
-
-template <typename Encoding, typename Allocator, typename StackAllocator>
-class GenericDocument;
-
-typedef GenericDocument<UTF8<char>, MemoryPoolAllocator<CrtAllocator>, CrtAllocator> Document;
-
-// pointer.h
-
-template <typename ValueType, typename Allocator>
-class GenericPointer;
-
-typedef GenericPointer<Value, CrtAllocator> Pointer;
-
-// schema.h
-
-template <typename SchemaDocumentType>
-class IGenericRemoteSchemaDocumentProvider;
-
-template <typename ValueT, typename Allocator>
-class GenericSchemaDocument;
-
-typedef GenericSchemaDocument<Value, CrtAllocator> SchemaDocument;
-typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
-
-template <
-  typename SchemaDocumentType,
-  typename OutputHandler,
-  typename StateAllocator>
-class GenericSchemaValidator;
-
-typedef GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<char>, void>, CrtAllocator> SchemaValidator;
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_RAPIDJSONFWD_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/biginteger.h.bak b/contrib/world_builder/include/rapidjson/internal/biginteger.h.bak
deleted file mode 100644
index 04a30c670a7..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/biginteger.h.bak
+++ /dev/null
@@ -1,340 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_BIGINTEGER_H_
-#define RAPIDJSON_BIGINTEGER_H_
-
-#include "../rapidjson.h"
-
-#if defined(_MSC_VER) && !__INTEL_COMPILER && defined(_M_AMD64)
-#include <intrin.h> // for _umul128
-#pragma intrinsic(_umul128)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-  class BigInteger
-  {
-    public:
-      typedef uint64_t Type;
-
-      BigInteger(const BigInteger &rhs) : count_(rhs.count_)
-      {
-        std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
-      }
-
-      explicit BigInteger(uint64_t u) : count_(1)
-      {
-        digits_[0] = u;
-      }
-
-      BigInteger(const char *decimals, size_t length) : count_(1)
-      {
-        RAPIDJSON_ASSERT(length > 0);
-        digits_[0] = 0;
-        size_t i = 0;
-        const size_t kMaxDigitPerIteration = 19;  // 2^64 = 18446744073709551616 > 10^19
-        while (length >= kMaxDigitPerIteration)
-          {
-            AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration);
-            length -= kMaxDigitPerIteration;
-            i += kMaxDigitPerIteration;
-          }
-
-        if (length > 0)
-          AppendDecimal64(decimals + i, decimals + i + length);
-      }
-
-      BigInteger &operator=(const BigInteger &rhs)
-      {
-        if (this != &rhs)
-          {
-            count_ = rhs.count_;
-            std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
-          }
-        return *this;
-      }
-
-      BigInteger &operator=(uint64_t u)
-      {
-        digits_[0] = u;
-        count_ = 1;
-        return *this;
-      }
-
-      BigInteger &operator+=(uint64_t u)
-      {
-        Type backup = digits_[0];
-        digits_[0] += u;
-        for (size_t i = 0; i < count_ - 1; i++)
-          {
-            if (digits_[i] >= backup)
-              return *this; // no carry
-            backup = digits_[i + 1];
-            digits_[i + 1] += 1;
-          }
-
-        // Last carry
-        if (digits_[count_ - 1] < backup)
-          PushBack(1);
-
-        return *this;
-      }
-
-      BigInteger &operator*=(uint64_t u)
-      {
-        if (u == 0) return *this = 0;
-        if (u == 1) return *this;
-        if (*this == 1) return *this = u;
-
-        uint64_t k = 0;
-        for (size_t i = 0; i < count_; i++)
-          {
-            uint64_t hi;
-            digits_[i] = MulAdd64(digits_[i], u, k, &hi);
-            k = hi;
-          }
-
-        if (k > 0)
-          PushBack(k);
-
-        return *this;
-      }
-
-      BigInteger &operator*=(uint32_t u)
-      {
-        if (u == 0) return *this = 0;
-        if (u == 1) return *this;
-        if (*this == 1) return *this = u;
-
-        uint64_t k = 0;
-        for (size_t i = 0; i < count_; i++)
-          {
-            const uint64_t c = digits_[i] >> 32;
-            const uint64_t d = digits_[i] & 0xFFFFFFFF;
-            const uint64_t uc = u * c;
-            const uint64_t ud = u * d;
-            const uint64_t p0 = ud + k;
-            const uint64_t p1 = uc + (p0 >> 32);
-            digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32);
-            k = p1 >> 32;
-          }
-
-        if (k > 0)
-          PushBack(k);
-
-        return *this;
-      }
-
-      BigInteger &operator<<=(size_t shift)
-      {
-        if (IsZero() || shift == 0) return *this;
-
-        size_t offset = shift / kTypeBit;
-        size_t interShift = shift % kTypeBit;
-        RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
-
-        if (interShift == 0)
-          {
-            std::memmove(digits_ + offset, digits_, count_ * sizeof(Type));
-            count_ += offset;
-          }
-        else
-          {
-            digits_[count_] = 0;
-            for (size_t i = count_; i > 0; i--)
-              digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift));
-            digits_[offset] = digits_[0] << interShift;
-            count_ += offset;
-            if (digits_[count_])
-              count_++;
-          }
-
-        std::memset(digits_, 0, offset * sizeof(Type));
-
-        return *this;
-      }
-
-      bool operator==(const BigInteger &rhs) const
-      {
-        return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
-      }
-
-      bool operator==(const Type rhs) const
-      {
-        return count_ == 1 && digits_[0] == rhs;
-      }
-
-      BigInteger &MultiplyPow5(unsigned exp)
-      {
-        static const uint32_t kPow5[12] =
-        {
-          5,
-          5 * 5,
-          5 * 5 * 5,
-          5 * 5 * 5 * 5,
-          5 * 5 * 5 * 5 * 5,
-          5 * 5 * 5 * 5 * 5 * 5,
-          5 * 5 * 5 * 5 * 5 * 5 * 5,
-          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-          5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
-        };
-        if (exp == 0) return *this;
-        for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
-        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
-        if (exp > 0)                 *this *= kPow5[exp - 1];
-        return *this;
-      }
-
-      // Compute absolute difference of this and rhs.
-      // Assume this != rhs
-      bool Difference(const BigInteger &rhs, BigInteger *out) const
-      {
-        int cmp = Compare(rhs);
-        RAPIDJSON_ASSERT(cmp != 0);
-        const BigInteger *a, *b;  // Makes a > b
-        bool ret;
-        if (cmp < 0)
-          {
-            a = &rhs;
-            b = this;
-            ret = true;
-          }
-        else
-          {
-            a = this;
-            b = &rhs;
-            ret = false;
-          }
-
-        Type borrow = 0;
-        for (size_t i = 0; i < a->count_; i++)
-          {
-            Type d = a->digits_[i] - borrow;
-            if (i < b->count_)
-              d -= b->digits_[i];
-            borrow = (d > a->digits_[i]) ? 1 : 0;
-            out->digits_[i] = d;
-            if (d != 0)
-              out->count_ = i + 1;
-          }
-
-        return ret;
-      }
-
-      int Compare(const BigInteger &rhs) const
-      {
-        if (count_ != rhs.count_)
-          return count_ < rhs.count_ ? -1 : 1;
-
-        for (size_t i = count_; i-- > 0;)
-          if (digits_[i] != rhs.digits_[i])
-            return digits_[i] < rhs.digits_[i] ? -1 : 1;
-
-        return 0;
-      }
-
-      size_t GetCount() const
-      {
-        return count_;
-      }
-      Type GetDigit(size_t index) const
-      {
-        RAPIDJSON_ASSERT(index < count_);
-        return digits_[index];
-      }
-      bool IsZero() const
-      {
-        return count_ == 1 && digits_[0] == 0;
-      }
-
-    private:
-      void AppendDecimal64(const char *begin, const char *end)
-      {
-        uint64_t u = ParseUint64(begin, end);
-        if (IsZero())
-          *this = u;
-        else
-          {
-            unsigned exp = static_cast<unsigned>(end - begin);
-            (MultiplyPow5(exp) <<= exp) += u;   // *this = *this * 10^exp + u
-          }
-      }
-
-      void PushBack(Type digit)
-      {
-        RAPIDJSON_ASSERT(count_ < kCapacity);
-        digits_[count_++] = digit;
-      }
-
-      static uint64_t ParseUint64(const char *begin, const char *end)
-      {
-        uint64_t r = 0;
-        for (const char *p = begin; p != end; ++p)
-          {
-            RAPIDJSON_ASSERT(*p >= '0' && *p <= '9');
-            r = r * 10u + static_cast<unsigned>(*p - '0');
-          }
-        return r;
-      }
-
-      // Assume a * b + k < 2^128
-      static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t *outHigh)
-      {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        uint64_t low = _umul128(a, b, outHigh) + k;
-        if (low < k)
-          (*outHigh)++;
-        return low;
-#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-        __extension__ typedef unsigned __int128 uint128;
-        uint128 p = static_cast<uint128>(a) * static_cast<uint128>(b);
-        p += k;
-        *outHigh = static_cast<uint64_t>(p >> 64);
-        return static_cast<uint64_t>(p);
-#else
-        const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32;
-        uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1;
-        x1 += (x0 >> 32); // can't give carry
-        x1 += x2;
-        if (x1 < x2)
-          x3 += (static_cast<uint64_t>(1) << 32);
-        uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF);
-        uint64_t hi = x3 + (x1 >> 32);
-
-        lo += k;
-        if (lo < k)
-          hi++;
-        *outHigh = hi;
-        return lo;
-#endif
-      }
-
-      static const size_t kBitCount = 3328;  // 64bit * 54 > 10^1000
-      static const size_t kCapacity = kBitCount / sizeof(Type);
-      static const size_t kTypeBit = sizeof(Type) * 8;
-
-      Type digits_[kCapacity];
-      size_t count_;
-  };
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_BIGINTEGER_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/diyfp.h.bak b/contrib/world_builder/include/rapidjson/internal/diyfp.h.bak
deleted file mode 100644
index 09de0161156..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/diyfp.h.bak
+++ /dev/null
@@ -1,293 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
-// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
-// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
-
-#ifndef RAPIDJSON_DIYFP_H_
-#define RAPIDJSON_DIYFP_H_
-
-#include "../rapidjson.h"
-#include <limits>
-
-#if defined(_MSC_VER) && defined(_M_AMD64) && !defined(__INTEL_COMPILER)
-#include <intrin.h>
-#pragma intrinsic(_BitScanReverse64)
-#pragma intrinsic(_umul128)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-#ifdef __GNUC__
-  RAPIDJSON_DIAG_PUSH
-  RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#ifdef __clang__
-  RAPIDJSON_DIAG_PUSH
-  RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-  struct DiyFp
-  {
-    DiyFp() : f(), e() {}
-
-    DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {}
-
-    explicit DiyFp(double d)
-    {
-      union
-      {
-        double d;
-        uint64_t u64;
-      } u = { d };
-
-      int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
-      uint64_t significand = (u.u64 & kDpSignificandMask);
-      if (biased_e != 0)
-        {
-          f = significand + kDpHiddenBit;
-          e = biased_e - kDpExponentBias;
-        }
-      else
-        {
-          f = significand;
-          e = kDpMinExponent + 1;
-        }
-    }
-
-    DiyFp operator-(const DiyFp &rhs) const
-    {
-      return DiyFp(f - rhs.f, e);
-    }
-
-    DiyFp operator*(const DiyFp &rhs) const
-    {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-      uint64_t h;
-      uint64_t l = _umul128(f, rhs.f, &h);
-      if (l & (uint64_t(1) << 63)) // rounding
-        h++;
-      return DiyFp(h, e + rhs.e + 64);
-#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-      __extension__ typedef unsigned __int128 uint128;
-      uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
-      uint64_t h = static_cast<uint64_t>(p >> 64);
-      uint64_t l = static_cast<uint64_t>(p);
-      if (l & (uint64_t(1) << 63)) // rounding
-        h++;
-      return DiyFp(h, e + rhs.e + 64);
-#else
-      const uint64_t M32 = 0xFFFFFFFF;
-      const uint64_t a = f >> 32;
-      const uint64_t b = f & M32;
-      const uint64_t c = rhs.f >> 32;
-      const uint64_t d = rhs.f & M32;
-      const uint64_t ac = a * c;
-      const uint64_t bc = b * c;
-      const uint64_t ad = a * d;
-      const uint64_t bd = b * d;
-      uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
-      tmp += 1U << 31;  /// mult_round
-      return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
-#endif
-    }
-
-    DiyFp Normalize() const
-    {
-      RAPIDJSON_ASSERT(f != 0); // https://stackoverflow.com/a/26809183/291737
-#if defined(_MSC_VER) && defined(_M_AMD64)
-      unsigned long index;
-      _BitScanReverse64(&index, f);
-      return DiyFp(f << (63 - index), e - (63 - index));
-#elif defined(__GNUC__) && __GNUC__ >= 4
-      int s = __builtin_clzll(f);
-      return DiyFp(f << s, e - s);
-#else
-      DiyFp res = *this;
-      while (!(res.f & (static_cast<uint64_t>(1) << 63)))
-        {
-          res.f <<= 1;
-          res.e--;
-        }
-      return res;
-#endif
-    }
-
-    DiyFp NormalizeBoundary() const
-    {
-      DiyFp res = *this;
-      while (!(res.f & (kDpHiddenBit << 1)))
-        {
-          res.f <<= 1;
-          res.e--;
-        }
-      res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
-      res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
-      return res;
-    }
-
-    void NormalizedBoundaries(DiyFp *minus, DiyFp *plus) const
-    {
-      DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
-      DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
-      mi.f <<= mi.e - pl.e;
-      mi.e = pl.e;
-      *plus = pl;
-      *minus = mi;
-    }
-
-    double ToDouble() const
-    {
-      union
-      {
-        double d;
-        uint64_t u64;
-      } u;
-      RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask);
-      if (e < kDpDenormalExponent)
-        {
-          // Underflow.
-          return 0.0;
-        }
-      if (e >= kDpMaxExponent)
-        {
-          // Overflow.
-          return std::numeric_limits<double>::infinity();
-        }
-      const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 :
-                          static_cast<uint64_t>(e + kDpExponentBias);
-      u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
-      return u.d;
-    }
-
-    static const int kDiySignificandSize = 64;
-    static const int kDpSignificandSize = 52;
-    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
-    static const int kDpMaxExponent = 0x7FF - kDpExponentBias;
-    static const int kDpMinExponent = -kDpExponentBias;
-    static const int kDpDenormalExponent = -kDpExponentBias + 1;
-    static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
-    static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
-    static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
-
-    uint64_t f;
-    int e;
-  };
-
-  inline DiyFp GetCachedPowerByIndex(size_t index)
-  {
-    // 10^-348, 10^-340, ..., 10^340
-    static const uint64_t kCachedPowers_F[] =
-    {
-      RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
-      RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
-      RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
-      RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
-      RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
-      RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
-      RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
-      RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
-      RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
-      RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
-      RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
-      RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
-      RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
-      RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
-      RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
-      RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
-      RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
-      RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
-      RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
-      RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
-      RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
-      RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
-      RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
-      RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
-      RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
-      RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
-      RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
-      RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
-      RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
-      RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
-      RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
-      RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
-      RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
-      RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
-      RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
-      RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
-      RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
-      RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
-      RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
-      RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
-      RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
-      RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
-      RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
-      RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
-    };
-    static const int16_t kCachedPowers_E[] =
-    {
-      -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
-      -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
-      -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
-      -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
-      -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
-      109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
-      375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
-      641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
-      907,   933,   960,   986,  1013,  1039,  1066
-    };
-    RAPIDJSON_ASSERT(index < 87);
-    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
-  }
-
-  inline DiyFp GetCachedPower(int e, int *K)
-  {
-
-    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
-    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
-    int k = static_cast<int>(dk);
-    if (dk - k > 0.0)
-      k++;
-
-    unsigned index = static_cast<unsigned>((k >> 3) + 1);
-    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table
-
-    return GetCachedPowerByIndex(index);
-  }
-
-  inline DiyFp GetCachedPower10(int exp, int *outExp)
-  {
-    RAPIDJSON_ASSERT(exp >= -348);
-    unsigned index = static_cast<unsigned>(exp + 348) / 8u;
-    *outExp = -348 + static_cast<int>(index) * 8;
-    return GetCachedPowerByIndex(index);
-  }
-
-#ifdef __GNUC__
-  RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __clang__
-  RAPIDJSON_DIAG_POP
-  RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_DIYFP_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/dtoa.h.bak b/contrib/world_builder/include/rapidjson/internal/dtoa.h.bak
deleted file mode 100644
index 2655748aac6..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/dtoa.h.bak
+++ /dev/null
@@ -1,301 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
-// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
-// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
-
-#ifndef RAPIDJSON_DTOA_
-#define RAPIDJSON_DTOA_
-
-#include "itoa.h" // GetDigitsLut()
-#include "diyfp.h"
-#include "ieee754.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-#ifdef __GNUC__
-  RAPIDJSON_DIAG_PUSH
-  RAPIDJSON_DIAG_OFF(effc++)
-  RAPIDJSON_DIAG_OFF(array-bounds) // some gcc versions generate wrong warnings https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124
-#endif
-
-  inline void GrisuRound(char *buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w)
-  {
-    while (rest < wp_w && delta - rest >= ten_kappa &&
-           (rest + ten_kappa < wp_w ||  /// closer
-            wp_w - rest > rest + ten_kappa - wp_w))
-      {
-        buffer[len - 1]--;
-        rest += ten_kappa;
-      }
-  }
-
-  inline int CountDecimalDigit32(uint32_t n)
-  {
-    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
-    if (n < 10) return 1;
-    if (n < 100) return 2;
-    if (n < 1000) return 3;
-    if (n < 10000) return 4;
-    if (n < 100000) return 5;
-    if (n < 1000000) return 6;
-    if (n < 10000000) return 7;
-    if (n < 100000000) return 8;
-    // Will not reach 10 digits in DigitGen()
-    //if (n < 1000000000) return 9;
-    //return 10;
-    return 9;
-  }
-
-  inline void DigitGen(const DiyFp &W, const DiyFp &Mp, uint64_t delta, char *buffer, int *len, int *K)
-  {
-    static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
-    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
-    const DiyFp wp_w = Mp - W;
-    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
-    uint64_t p2 = Mp.f & (one.f - 1);
-    int kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
-    *len = 0;
-
-    while (kappa > 0)
-      {
-        uint32_t d = 0;
-        switch (kappa)
-          {
-            case  9:
-              d = p1 /  100000000;
-              p1 %=  100000000;
-              break;
-            case  8:
-              d = p1 /   10000000;
-              p1 %=   10000000;
-              break;
-            case  7:
-              d = p1 /    1000000;
-              p1 %=    1000000;
-              break;
-            case  6:
-              d = p1 /     100000;
-              p1 %=     100000;
-              break;
-            case  5:
-              d = p1 /      10000;
-              p1 %=      10000;
-              break;
-            case  4:
-              d = p1 /       1000;
-              p1 %=       1000;
-              break;
-            case  3:
-              d = p1 /        100;
-              p1 %=        100;
-              break;
-            case  2:
-              d = p1 /         10;
-              p1 %=         10;
-              break;
-            case  1:
-              d = p1;
-              p1 =           0;
-              break;
-            default:
-              ;
-          }
-        if (d || *len)
-          buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
-        kappa--;
-        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
-        if (tmp <= delta)
-          {
-            *K += kappa;
-            GrisuRound(buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
-            return;
-          }
-      }
-
-    // kappa = 0
-    for (;;)
-      {
-        p2 *= 10;
-        delta *= 10;
-        char d = static_cast<char>(p2 >> -one.e);
-        if (d || *len)
-          buffer[(*len)++] = static_cast<char>('0' + d);
-        p2 &= one.f - 1;
-        kappa--;
-        if (p2 < delta)
-          {
-            *K += kappa;
-            int index = -kappa;
-            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[index] : 0));
-            return;
-          }
-      }
-  }
-
-  inline void Grisu2(double value, char *buffer, int *length, int *K)
-  {
-    const DiyFp v(value);
-    DiyFp w_m, w_p;
-    v.NormalizedBoundaries(&w_m, &w_p);
-
-    const DiyFp c_mk = GetCachedPower(w_p.e, K);
-    const DiyFp W = v.Normalize() * c_mk;
-    DiyFp Wp = w_p * c_mk;
-    DiyFp Wm = w_m * c_mk;
-    Wm.f++;
-    Wp.f--;
-    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
-  }
-
-  inline char *WriteExponent(int K, char *buffer)
-  {
-    if (K < 0)
-      {
-        *buffer++ = '-';
-        K = -K;
-      }
-
-    if (K >= 100)
-      {
-        *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
-        K %= 100;
-        const char *d = GetDigitsLut() + K * 2;
-        *buffer++ = d[0];
-        *buffer++ = d[1];
-      }
-    else if (K >= 10)
-      {
-        const char *d = GetDigitsLut() + K * 2;
-        *buffer++ = d[0];
-        *buffer++ = d[1];
-      }
-    else
-      *buffer++ = static_cast<char>('0' + static_cast<char>(K));
-
-    return buffer;
-  }
-
-  inline char *Prettify(char *buffer, int length, int k, int maxDecimalPlaces)
-  {
-    const int kk = length + k;  // 10^(kk-1) <= v < 10^kk
-
-    if (0 <= k && kk <= 21)
-      {
-        // 1234e7 -> 12340000000
-        for (int i = length; i < kk; i++)
-          buffer[i] = '0';
-        buffer[kk] = '.';
-        buffer[kk + 1] = '0';
-        return &buffer[kk + 2];
-      }
-    else if (0 < kk && kk <= 21)
-      {
-        // 1234e-2 -> 12.34
-        std::memmove(&buffer[kk + 1], &buffer[kk], static_cast<size_t>(length - kk));
-        buffer[kk] = '.';
-        if (0 > k + maxDecimalPlaces)
-          {
-            // When maxDecimalPlaces = 2, 1.2345 -> 1.23, 1.102 -> 1.1
-            // Remove extra trailing zeros (at least one) after truncation.
-            for (int i = kk + maxDecimalPlaces; i > kk + 1; i--)
-              if (buffer[i] != '0')
-                return &buffer[i + 1];
-            return &buffer[kk + 2]; // Reserve one zero
-          }
-        else
-          return &buffer[length + 1];
-      }
-    else if (-6 < kk && kk <= 0)
-      {
-        // 1234e-6 -> 0.001234
-        const int offset = 2 - kk;
-        std::memmove(&buffer[offset], &buffer[0], static_cast<size_t>(length));
-        buffer[0] = '0';
-        buffer[1] = '.';
-        for (int i = 2; i < offset; i++)
-          buffer[i] = '0';
-        if (length - kk > maxDecimalPlaces)
-          {
-            // When maxDecimalPlaces = 2, 0.123 -> 0.12, 0.102 -> 0.1
-            // Remove extra trailing zeros (at least one) after truncation.
-            for (int i = maxDecimalPlaces + 1; i > 2; i--)
-              if (buffer[i] != '0')
-                return &buffer[i + 1];
-            return &buffer[3]; // Reserve one zero
-          }
-        else
-          return &buffer[length + offset];
-      }
-    else if (kk < -maxDecimalPlaces)
-      {
-        // Truncate to zero
-        buffer[0] = '0';
-        buffer[1] = '.';
-        buffer[2] = '0';
-        return &buffer[3];
-      }
-    else if (length == 1)
-      {
-        // 1e30
-        buffer[1] = 'e';
-        return WriteExponent(kk - 1, &buffer[2]);
-      }
-    else
-      {
-        // 1234e30 -> 1.234e33
-        std::memmove(&buffer[2], &buffer[1], static_cast<size_t>(length - 1));
-        buffer[1] = '.';
-        buffer[length + 1] = 'e';
-        return WriteExponent(kk - 1, &buffer[0 + length + 2]);
-      }
-  }
-
-  inline char *dtoa(double value, char *buffer, int maxDecimalPlaces = 324)
-  {
-    RAPIDJSON_ASSERT(maxDecimalPlaces >= 1);
-    Double d(value);
-    if (d.IsZero())
-      {
-        if (d.Sign())
-          *buffer++ = '-';     // -0.0, Issue #289
-        buffer[0] = '0';
-        buffer[1] = '.';
-        buffer[2] = '0';
-        return &buffer[3];
-      }
-    else
-      {
-        if (value < 0)
-          {
-            *buffer++ = '-';
-            value = -value;
-          }
-        int length, K;
-        Grisu2(value, buffer, &length, &K);
-        return Prettify(buffer, length, K, maxDecimalPlaces);
-      }
-  }
-
-#ifdef __GNUC__
-  RAPIDJSON_DIAG_POP
-#endif
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_DTOA_
diff --git a/contrib/world_builder/include/rapidjson/internal/ieee754.h.bak b/contrib/world_builder/include/rapidjson/internal/ieee754.h.bak
deleted file mode 100644
index 44db4b48955..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/ieee754.h.bak
+++ /dev/null
@@ -1,122 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_IEEE754_
-#define RAPIDJSON_IEEE754_
-
-#include "../rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-  class Double
-  {
-    public:
-      Double() {}
-      Double(double d) : d_(d) {}
-      Double(uint64_t u) : u_(u) {}
-
-      double Value() const
-      {
-        return d_;
-      }
-      uint64_t Uint64Value() const
-      {
-        return u_;
-      }
-
-      double NextPositiveDouble() const
-      {
-        RAPIDJSON_ASSERT(!Sign());
-        return Double(u_ + 1).Value();
-      }
-
-      bool Sign() const
-      {
-        return (u_ & kSignMask) != 0;
-      }
-      uint64_t Significand() const
-      {
-        return u_ & kSignificandMask;
-      }
-      int Exponent() const
-      {
-        return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias);
-      }
-
-      bool IsNan() const
-      {
-        return (u_ & kExponentMask) == kExponentMask && Significand() != 0;
-      }
-      bool IsInf() const
-      {
-        return (u_ & kExponentMask) == kExponentMask && Significand() == 0;
-      }
-      bool IsNanOrInf() const
-      {
-        return (u_ & kExponentMask) == kExponentMask;
-      }
-      bool IsNormal() const
-      {
-        return (u_ & kExponentMask) != 0 || Significand() == 0;
-      }
-      bool IsZero() const
-      {
-        return (u_ & (kExponentMask | kSignificandMask)) == 0;
-      }
-
-      uint64_t IntegerSignificand() const
-      {
-        return IsNormal() ? Significand() | kHiddenBit : Significand();
-      }
-      int IntegerExponent() const
-      {
-        return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize;
-      }
-      uint64_t ToBias() const
-      {
-        return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask;
-      }
-
-      static int EffectiveSignificandSize(int order)
-      {
-        if (order >= -1021)
-          return 53;
-        else if (order <= -1074)
-          return 0;
-        else
-          return order + 1074;
-      }
-
-    private:
-      static const int kSignificandSize = 52;
-      static const int kExponentBias = 0x3FF;
-      static const int kDenormalExponent = 1 - kExponentBias;
-      static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
-      static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
-      static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
-      static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
-
-      union
-      {
-        double d_;
-        uint64_t u_;
-      };
-  };
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_IEEE754_
diff --git a/contrib/world_builder/include/rapidjson/internal/itoa.h.bak b/contrib/world_builder/include/rapidjson/internal/itoa.h.bak
deleted file mode 100644
index 23016b08a4d..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/itoa.h.bak
+++ /dev/null
@@ -1,329 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ITOA_
-#define RAPIDJSON_ITOA_
-
-#include "../rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-  inline const char *GetDigitsLut()
-  {
-    static const char cDigitsLut[200] =
-    {
-      '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
-      '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
-      '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
-      '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
-      '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
-      '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
-      '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
-      '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
-      '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
-      '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
-    };
-    return cDigitsLut;
-  }
-
-  inline char *u32toa(uint32_t value, char *buffer)
-  {
-    RAPIDJSON_ASSERT(buffer != 0);
-
-    const char *cDigitsLut = GetDigitsLut();
-
-    if (value < 10000)
-      {
-        const uint32_t d1 = (value / 100) << 1;
-        const uint32_t d2 = (value % 100) << 1;
-
-        if (value >= 1000)
-          *buffer++ = cDigitsLut[d1];
-        if (value >= 100)
-          *buffer++ = cDigitsLut[d1 + 1];
-        if (value >= 10)
-          *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-      }
-    else if (value < 100000000)
-      {
-        // value = bbbbcccc
-        const uint32_t b = value / 10000;
-        const uint32_t c = value % 10000;
-
-        const uint32_t d1 = (b / 100) << 1;
-        const uint32_t d2 = (b % 100) << 1;
-
-        const uint32_t d3 = (c / 100) << 1;
-        const uint32_t d4 = (c % 100) << 1;
-
-        if (value >= 10000000)
-          *buffer++ = cDigitsLut[d1];
-        if (value >= 1000000)
-          *buffer++ = cDigitsLut[d1 + 1];
-        if (value >= 100000)
-          *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-
-        *buffer++ = cDigitsLut[d3];
-        *buffer++ = cDigitsLut[d3 + 1];
-        *buffer++ = cDigitsLut[d4];
-        *buffer++ = cDigitsLut[d4 + 1];
-      }
-    else
-      {
-        // value = aabbbbcccc in decimal
-
-        const uint32_t a = value / 100000000; // 1 to 42
-        value %= 100000000;
-
-        if (a >= 10)
-          {
-            const unsigned i = a << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-          }
-        else
-          *buffer++ = static_cast<char>('0' + static_cast<char>(a));
-
-        const uint32_t b = value / 10000; // 0 to 9999
-        const uint32_t c = value % 10000; // 0 to 9999
-
-        const uint32_t d1 = (b / 100) << 1;
-        const uint32_t d2 = (b % 100) << 1;
-
-        const uint32_t d3 = (c / 100) << 1;
-        const uint32_t d4 = (c % 100) << 1;
-
-        *buffer++ = cDigitsLut[d1];
-        *buffer++ = cDigitsLut[d1 + 1];
-        *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-        *buffer++ = cDigitsLut[d3];
-        *buffer++ = cDigitsLut[d3 + 1];
-        *buffer++ = cDigitsLut[d4];
-        *buffer++ = cDigitsLut[d4 + 1];
-      }
-    return buffer;
-  }
-
-  inline char *i32toa(int32_t value, char *buffer)
-  {
-    RAPIDJSON_ASSERT(buffer != 0);
-    uint32_t u = static_cast<uint32_t>(value);
-    if (value < 0)
-      {
-        *buffer++ = '-';
-        u = ~u + 1;
-      }
-
-    return u32toa(u, buffer);
-  }
-
-  inline char *u64toa(uint64_t value, char *buffer)
-  {
-    RAPIDJSON_ASSERT(buffer != 0);
-    const char *cDigitsLut = GetDigitsLut();
-    const uint64_t  kTen8 = 100000000;
-    const uint64_t  kTen9 = kTen8 * 10;
-    const uint64_t kTen10 = kTen8 * 100;
-    const uint64_t kTen11 = kTen8 * 1000;
-    const uint64_t kTen12 = kTen8 * 10000;
-    const uint64_t kTen13 = kTen8 * 100000;
-    const uint64_t kTen14 = kTen8 * 1000000;
-    const uint64_t kTen15 = kTen8 * 10000000;
-    const uint64_t kTen16 = kTen8 * kTen8;
-
-    if (value < kTen8)
-      {
-        uint32_t v = static_cast<uint32_t>(value);
-        if (v < 10000)
-          {
-            const uint32_t d1 = (v / 100) << 1;
-            const uint32_t d2 = (v % 100) << 1;
-
-            if (v >= 1000)
-              *buffer++ = cDigitsLut[d1];
-            if (v >= 100)
-              *buffer++ = cDigitsLut[d1 + 1];
-            if (v >= 10)
-              *buffer++ = cDigitsLut[d2];
-            *buffer++ = cDigitsLut[d2 + 1];
-          }
-        else
-          {
-            // value = bbbbcccc
-            const uint32_t b = v / 10000;
-            const uint32_t c = v % 10000;
-
-            const uint32_t d1 = (b / 100) << 1;
-            const uint32_t d2 = (b % 100) << 1;
-
-            const uint32_t d3 = (c / 100) << 1;
-            const uint32_t d4 = (c % 100) << 1;
-
-            if (value >= 10000000)
-              *buffer++ = cDigitsLut[d1];
-            if (value >= 1000000)
-              *buffer++ = cDigitsLut[d1 + 1];
-            if (value >= 100000)
-              *buffer++ = cDigitsLut[d2];
-            *buffer++ = cDigitsLut[d2 + 1];
-
-            *buffer++ = cDigitsLut[d3];
-            *buffer++ = cDigitsLut[d3 + 1];
-            *buffer++ = cDigitsLut[d4];
-            *buffer++ = cDigitsLut[d4 + 1];
-          }
-      }
-    else if (value < kTen16)
-      {
-        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
-        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-
-        const uint32_t b0 = v0 / 10000;
-        const uint32_t c0 = v0 % 10000;
-
-        const uint32_t d1 = (b0 / 100) << 1;
-        const uint32_t d2 = (b0 % 100) << 1;
-
-        const uint32_t d3 = (c0 / 100) << 1;
-        const uint32_t d4 = (c0 % 100) << 1;
-
-        const uint32_t b1 = v1 / 10000;
-        const uint32_t c1 = v1 % 10000;
-
-        const uint32_t d5 = (b1 / 100) << 1;
-        const uint32_t d6 = (b1 % 100) << 1;
-
-        const uint32_t d7 = (c1 / 100) << 1;
-        const uint32_t d8 = (c1 % 100) << 1;
-
-        if (value >= kTen15)
-          *buffer++ = cDigitsLut[d1];
-        if (value >= kTen14)
-          *buffer++ = cDigitsLut[d1 + 1];
-        if (value >= kTen13)
-          *buffer++ = cDigitsLut[d2];
-        if (value >= kTen12)
-          *buffer++ = cDigitsLut[d2 + 1];
-        if (value >= kTen11)
-          *buffer++ = cDigitsLut[d3];
-        if (value >= kTen10)
-          *buffer++ = cDigitsLut[d3 + 1];
-        if (value >= kTen9)
-          *buffer++ = cDigitsLut[d4];
-
-        *buffer++ = cDigitsLut[d4 + 1];
-        *buffer++ = cDigitsLut[d5];
-        *buffer++ = cDigitsLut[d5 + 1];
-        *buffer++ = cDigitsLut[d6];
-        *buffer++ = cDigitsLut[d6 + 1];
-        *buffer++ = cDigitsLut[d7];
-        *buffer++ = cDigitsLut[d7 + 1];
-        *buffer++ = cDigitsLut[d8];
-        *buffer++ = cDigitsLut[d8 + 1];
-      }
-    else
-      {
-        const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
-        value %= kTen16;
-
-        if (a < 10)
-          *buffer++ = static_cast<char>('0' + static_cast<char>(a));
-        else if (a < 100)
-          {
-            const uint32_t i = a << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-          }
-        else if (a < 1000)
-          {
-            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
-
-            const uint32_t i = (a % 100) << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-          }
-        else
-          {
-            const uint32_t i = (a / 100) << 1;
-            const uint32_t j = (a % 100) << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-            *buffer++ = cDigitsLut[j];
-            *buffer++ = cDigitsLut[j + 1];
-          }
-
-        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
-        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-
-        const uint32_t b0 = v0 / 10000;
-        const uint32_t c0 = v0 % 10000;
-
-        const uint32_t d1 = (b0 / 100) << 1;
-        const uint32_t d2 = (b0 % 100) << 1;
-
-        const uint32_t d3 = (c0 / 100) << 1;
-        const uint32_t d4 = (c0 % 100) << 1;
-
-        const uint32_t b1 = v1 / 10000;
-        const uint32_t c1 = v1 % 10000;
-
-        const uint32_t d5 = (b1 / 100) << 1;
-        const uint32_t d6 = (b1 % 100) << 1;
-
-        const uint32_t d7 = (c1 / 100) << 1;
-        const uint32_t d8 = (c1 % 100) << 1;
-
-        *buffer++ = cDigitsLut[d1];
-        *buffer++ = cDigitsLut[d1 + 1];
-        *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-        *buffer++ = cDigitsLut[d3];
-        *buffer++ = cDigitsLut[d3 + 1];
-        *buffer++ = cDigitsLut[d4];
-        *buffer++ = cDigitsLut[d4 + 1];
-        *buffer++ = cDigitsLut[d5];
-        *buffer++ = cDigitsLut[d5 + 1];
-        *buffer++ = cDigitsLut[d6];
-        *buffer++ = cDigitsLut[d6 + 1];
-        *buffer++ = cDigitsLut[d7];
-        *buffer++ = cDigitsLut[d7 + 1];
-        *buffer++ = cDigitsLut[d8];
-        *buffer++ = cDigitsLut[d8 + 1];
-      }
-
-    return buffer;
-  }
-
-  inline char *i64toa(int64_t value, char *buffer)
-  {
-    RAPIDJSON_ASSERT(buffer != 0);
-    uint64_t u = static_cast<uint64_t>(value);
-    if (value < 0)
-      {
-        *buffer++ = '-';
-        u = ~u + 1;
-      }
-
-    return u64toa(u, buffer);
-  }
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ITOA_
diff --git a/contrib/world_builder/include/rapidjson/internal/meta.h.bak b/contrib/world_builder/include/rapidjson/internal/meta.h.bak
deleted file mode 100644
index 3b61258b9a0..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/meta.h.bak
+++ /dev/null
@@ -1,229 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_META_H_
-#define RAPIDJSON_INTERNAL_META_H_
-
-#include "../rapidjson.h"
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#if defined(_MSC_VER) && !defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(6334)
-#endif
-
-#if RAPIDJSON_HAS_CXX11_TYPETRAITS
-#include <type_traits>
-#endif
-
-//@cond RAPIDJSON_INTERNAL
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
-  template <typename T> struct Void
-  {
-    typedef void Type;
-  };
-
-///////////////////////////////////////////////////////////////////////////////
-// BoolType, TrueType, FalseType
-//
-  template <bool Cond> struct BoolType
-  {
-    static const bool Value = Cond;
-    typedef BoolType Type;
-  };
-  typedef BoolType<true> TrueType;
-  typedef BoolType<false> FalseType;
-
-
-///////////////////////////////////////////////////////////////////////////////
-// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
-//
-
-  template <bool C> struct SelectIfImpl
-  {
-    template <typename T1, typename T2> struct Apply
-    {
-      typedef T1 Type;
-    };
-  };
-  template <> struct SelectIfImpl<false>
-  {
-    template <typename T1, typename T2> struct Apply
-    {
-      typedef T2 Type;
-    };
-  };
-  template <bool C, typename T1, typename T2> struct SelectIfCond : SelectIfImpl<C>::template Apply<T1,T2> {};
-  template <typename C, typename T1, typename T2> struct SelectIf : SelectIfCond<C::Value, T1, T2> {};
-
-  template <bool Cond1, bool Cond2> struct AndExprCond : FalseType {};
-  template <> struct AndExprCond<true, true> : TrueType {};
-  template <bool Cond1, bool Cond2> struct OrExprCond : TrueType {};
-  template <> struct OrExprCond<false, false> : FalseType {};
-
-  template <typename C> struct BoolExpr : SelectIf<C,TrueType,FalseType>::Type {};
-  template <typename C> struct NotExpr  : SelectIf<C,FalseType,TrueType>::Type {};
-  template <typename C1, typename C2> struct AndExpr : AndExprCond<C1::Value, C2::Value>::Type {};
-  template <typename C1, typename C2> struct OrExpr  : OrExprCond<C1::Value, C2::Value>::Type {};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// AddConst, MaybeAddConst, RemoveConst
-  template <typename T> struct AddConst
-  {
-    typedef const T Type;
-  };
-  template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
-  template <typename T> struct RemoveConst
-  {
-    typedef T Type;
-  };
-  template <typename T> struct RemoveConst<const T>
-  {
-    typedef T Type;
-  };
-
-
-///////////////////////////////////////////////////////////////////////////////
-// IsSame, IsConst, IsMoreConst, IsPointer
-//
-  template <typename T, typename U> struct IsSame : FalseType {};
-  template <typename T> struct IsSame<T, T> : TrueType {};
-
-  template <typename T> struct IsConst : FalseType {};
-  template <typename T> struct IsConst<const T> : TrueType {};
-
-  template <typename CT, typename T>
-  struct IsMoreConst
-    : AndExpr<IsSame<typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>,
-      BoolType<IsConst<CT>::Value >= IsConst<T>::Value> >::Type {};
-
-  template <typename T> struct IsPointer : FalseType {};
-  template <typename T> struct IsPointer<T *> : TrueType {};
-
-///////////////////////////////////////////////////////////////////////////////
-// IsBaseOf
-//
-#if RAPIDJSON_HAS_CXX11_TYPETRAITS
-
-  template <typename B, typename D> struct IsBaseOf
-    : BoolType< ::std::is_base_of<B,D>::value> {};
-
-#else // simplified version adopted from Boost
-
-  template<typename B, typename D> struct IsBaseOfImpl
-  {
-    RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0);
-    RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0);
-
-    typedef char (&Yes)[1];
-    typedef char (&No) [2];
-
-    template <typename T>
-    static Yes Check(const D *, T);
-    static No  Check(const B *, int);
-
-    struct Host
-    {
-      operator const B *() const;
-      operator const D *();
-    };
-
-    enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) };
-  };
-
-  template <typename B, typename D> struct IsBaseOf
-    : OrExpr<IsSame<B, D>, BoolExpr<IsBaseOfImpl<B, D> > >::Type {};
-
-#endif // RAPIDJSON_HAS_CXX11_TYPETRAITS
-
-
-//////////////////////////////////////////////////////////////////////////
-// EnableIf / DisableIf
-//
-  template <bool Condition, typename T = void> struct EnableIfCond
-  {
-    typedef T Type;
-  };
-  template <typename T> struct EnableIfCond<false, T>
-  {
-    /* empty */
-  };
-
-  template <bool Condition, typename T = void> struct DisableIfCond
-  {
-    typedef T Type;
-  };
-  template <typename T> struct DisableIfCond<true, T>
-  {
-    /* empty */
-  };
-
-  template <typename Condition, typename T = void>
-  struct EnableIf : EnableIfCond<Condition::Value, T> {};
-
-  template <typename Condition, typename T = void>
-  struct DisableIf : DisableIfCond<Condition::Value, T> {};
-
-// SFINAE helpers
-  struct SfinaeTag {};
-  template <typename T> struct RemoveSfinaeTag;
-  template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)>
-  {
-    typedef T Type;
-  };
-
-#define RAPIDJSON_REMOVEFPTR_(type) \
-  typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \
-  < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type
-
-#define RAPIDJSON_ENABLEIF(cond) \
-  typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
-  <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
-
-#define RAPIDJSON_DISABLEIF(cond) \
-  typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
-  <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
-
-#define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \
-  typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
-  <RAPIDJSON_REMOVEFPTR_(cond), \
-  RAPIDJSON_REMOVEFPTR_(returntype)>::Type
-
-#define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \
-  typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
-  <RAPIDJSON_REMOVEFPTR_(cond), \
-  RAPIDJSON_REMOVEFPTR_(returntype)>::Type
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-//@endcond
-
-#if defined(_MSC_VER) && !defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_INTERNAL_META_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/pow10.h.bak b/contrib/world_builder/include/rapidjson/internal/pow10.h.bak
deleted file mode 100644
index 579502aa633..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/pow10.h.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_POW10_
-#define RAPIDJSON_POW10_
-
-#include "../rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-//! Computes integer powers of 10 in double (10.0^n).
-  /*! This function uses lookup table for fast and accurate results.
-      \param n non-negative exponent. Must <= 308.
-      \return 10.0^n
-  */
-  inline double Pow10(int n)
-  {
-    static const double e[] =   // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
-    {
-      1e+0,
-      1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20,
-      1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
-      1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
-      1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
-      1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
-      1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
-      1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
-      1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
-      1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
-      1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
-      1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
-      1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
-      1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
-      1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
-      1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
-      1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
-    };
-    RAPIDJSON_ASSERT(n >= 0 && n <= 308);
-    return e[n];
-  }
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_POW10_
diff --git a/contrib/world_builder/include/rapidjson/internal/regex.h.bak b/contrib/world_builder/include/rapidjson/internal/regex.h.bak
deleted file mode 100644
index 88274ba2a59..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/regex.h.bak
+++ /dev/null
@@ -1,820 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_REGEX_H_
-#define RAPIDJSON_INTERNAL_REGEX_H_
-
-#include "../allocators.h"
-#include "../stream.h"
-#include "stack.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-//RAPIDJSON_DIAG_OFF(switch -enum)
-RAPIDJSON_DIAG_OFF(implicit-fallthrough)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#if __GNUC__ >= 7
-RAPIDJSON_DIAG_OFF(implicit-fallthrough)
-#endif
-#endif
-
-#ifndef RAPIDJSON_REGEX_VERBOSE
-#define RAPIDJSON_REGEX_VERBOSE 0
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-///////////////////////////////////////////////////////////////////////////////
-// DecodedStream
-
-  template <typename SourceStream, typename Encoding>
-  class DecodedStream
-  {
-    public:
-      DecodedStream(SourceStream &ss) : ss_(ss), codepoint_()
-      {
-        Decode();
-      }
-      unsigned Peek()
-      {
-        return codepoint_;
-      }
-      unsigned Take()
-      {
-        unsigned c = codepoint_;
-        if (c) // No further decoding when '\0'
-          Decode();
-        return c;
-      }
-
-    private:
-      void Decode()
-      {
-        if (!Encoding::Decode(ss_, &codepoint_))
-          codepoint_ = 0;
-      }
-
-      SourceStream &ss_;
-      unsigned codepoint_;
-  };
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericRegex
-
-  static const SizeType kRegexInvalidState = ~SizeType(0);  //!< Represents an invalid index in GenericRegex::State::out, out1
-  static const SizeType kRegexInvalidRange = ~SizeType(0);
-
-  template <typename Encoding, typename Allocator>
-  class GenericRegexSearch;
-
-//! Regular expression engine with subset of ECMAscript grammar.
-  /*!
-      Supported regular expression syntax:
-      - \c ab     Concatenation
-      - \c a|b    Alternation
-      - \c a?     Zero or one
-      - \c a*     Zero or more
-      - \c a+     One or more
-      - \c a{3}   Exactly 3 times
-      - \c a{3,}  At least 3 times
-      - \c a{3,5} 3 to 5 times
-      - \c (ab)   Grouping
-      - \c ^a     At the beginning
-      - \c a$     At the end
-      - \c .      Any character
-      - \c [abc]  Character classes
-      - \c [a-c]  Character class range
-      - \c [a-z0-9_] Character class combination
-      - \c [^abc] Negated character classes
-      - \c [^a-c] Negated character class range
-      - \c [\b]   Backspace (U+0008)
-      - \c \\| \\\\ ...  Escape characters
-      - \c \\f Form feed (U+000C)
-      - \c \\n Line feed (U+000A)
-      - \c \\r Carriage return (U+000D)
-      - \c \\t Tab (U+0009)
-      - \c \\v Vertical tab (U+000B)
-
-      \note This is a Thompson NFA engine, implemented with reference to
-          Cox, Russ. "Regular Expression Matching Can Be Simple And Fast (but is slow in Java, Perl, PHP, Python, Ruby,...).",
-          https://swtch.com/~rsc/regexp/regexp1.html
-  */
-  template <typename Encoding, typename Allocator = CrtAllocator>
-  class GenericRegex
-  {
-    public:
-      typedef Encoding EncodingType;
-      typedef typename Encoding::Ch Ch;
-      template <typename, typename> friend class GenericRegexSearch;
-
-      GenericRegex(const Ch *source, Allocator *allocator = 0) :
-        states_(allocator, 256), ranges_(allocator, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(),
-        anchorBegin_(), anchorEnd_()
-      {
-        GenericStringStream<Encoding> ss(source);
-        DecodedStream<GenericStringStream<Encoding>, Encoding> ds(ss);
-        Parse(ds);
-      }
-
-      ~GenericRegex() {}
-
-      bool IsValid() const
-      {
-        return root_ != kRegexInvalidState;
-      }
-
-    private:
-      enum Operator
-      {
-        kZeroOrOne,
-        kZeroOrMore,
-        kOneOrMore,
-        kConcatenation,
-        kAlternation,
-        kLeftParenthesis
-      };
-
-      static const unsigned kAnyCharacterClass = 0xFFFFFFFF;   //!< For '.'
-      static const unsigned kRangeCharacterClass = 0xFFFFFFFE;
-      static const unsigned kRangeNegationFlag = 0x80000000;
-
-      struct Range
-      {
-        unsigned start; //
-        unsigned end;
-        SizeType next;
-      };
-
-      struct State
-      {
-        SizeType out;     //!< Equals to kInvalid for matching state
-        SizeType out1;    //!< Equals to non-kInvalid for split
-        SizeType rangeStart;
-        unsigned codepoint;
-      };
-
-      struct Frag
-      {
-        Frag(SizeType s, SizeType o, SizeType m) : start(s), out(o), minIndex(m) {}
-        SizeType start;
-        SizeType out; //!< link-list of all output states
-        SizeType minIndex;
-      };
-
-      State &GetState(SizeType index)
-      {
-        RAPIDJSON_ASSERT(index < stateCount_);
-        return states_.template Bottom<State>()[index];
-      }
-
-      const State &GetState(SizeType index) const
-      {
-        RAPIDJSON_ASSERT(index < stateCount_);
-        return states_.template Bottom<State>()[index];
-      }
-
-      Range &GetRange(SizeType index)
-      {
-        RAPIDJSON_ASSERT(index < rangeCount_);
-        return ranges_.template Bottom<Range>()[index];
-      }
-
-      const Range &GetRange(SizeType index) const
-      {
-        RAPIDJSON_ASSERT(index < rangeCount_);
-        return ranges_.template Bottom<Range>()[index];
-      }
-
-      template <typename InputStream>
-      void Parse(DecodedStream<InputStream, Encoding> &ds)
-      {
-        Allocator allocator;
-        Stack<Allocator> operandStack(&allocator, 256);     // Frag
-        Stack<Allocator> operatorStack(&allocator, 256);    // Operator
-        Stack<Allocator> atomCountStack(&allocator, 256);   // unsigned (Atom per parenthesis)
-
-        *atomCountStack.template Push<unsigned>() = 0;
-
-        unsigned codepoint;
-        while (ds.Peek() != 0)
-          {
-            switch (codepoint = ds.Take())
-              {
-                case '^':
-                  anchorBegin_ = true;
-                  break;
-
-                case '$':
-                  anchorEnd_ = true;
-                  break;
-
-                case '|':
-                  while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() < kAlternation)
-                    if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
-                      return;
-                  *operatorStack.template Push<Operator>() = kAlternation;
-                  *atomCountStack.template Top<unsigned>() = 0;
-                  break;
-
-                case '(':
-                  *operatorStack.template Push<Operator>() = kLeftParenthesis;
-                  *atomCountStack.template Push<unsigned>() = 0;
-                  break;
-
-                case ')':
-                  while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() != kLeftParenthesis)
-                    if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
-                      return;
-                  if (operatorStack.Empty())
-                    return;
-                  operatorStack.template Pop<Operator>(1);
-                  atomCountStack.template Pop<unsigned>(1);
-                  ImplicitConcatenation(atomCountStack, operatorStack);
-                  break;
-
-                case '?':
-                  if (!Eval(operandStack, kZeroOrOne))
-                    return;
-                  break;
-
-                case '*':
-                  if (!Eval(operandStack, kZeroOrMore))
-                    return;
-                  break;
-
-                case '+':
-                  if (!Eval(operandStack, kOneOrMore))
-                    return;
-                  break;
-
-                case '{':
-                {
-                  unsigned n = 0;
-                  unsigned m = 0;
-                  if (!ParseUnsigned(ds, &n))
-                    return;
-
-                  if (ds.Peek() == ',')
-                    {
-                      ds.Take();
-                      if (ds.Peek() == '}')
-                        m = kInfinityQuantifier;
-                      else if (!ParseUnsigned(ds, &m) || m < n)
-                        return;
-                    }
-                  else
-                    m = n;
-
-                  if (!EvalQuantifier(operandStack, n, m) || ds.Peek() != '}')
-                    return;
-                  ds.Take();
-                }
-                break;
-
-                case '.':
-                  PushOperand(operandStack, kAnyCharacterClass);
-                  ImplicitConcatenation(atomCountStack, operatorStack);
-                  break;
-
-                case '[':
-                {
-                  SizeType range;
-                  if (!ParseRange(ds, &range))
-                    return;
-                  SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, kRangeCharacterClass);
-                  GetState(s).rangeStart = range;
-                  *operandStack.template Push<Frag>() = Frag(s, s, s);
-                }
-                ImplicitConcatenation(atomCountStack, operatorStack);
-                break;
-
-                case '\\': // Escape character
-                  if (!CharacterEscape(ds, &codepoint))
-                    return; // Unsupported escape character
-                // fall through to default
-
-                default: // Pattern character
-                  PushOperand(operandStack, codepoint);
-                  ImplicitConcatenation(atomCountStack, operatorStack);
-              }
-          }
-
-        while (!operatorStack.Empty())
-          if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
-            return;
-
-        // Link the operand to matching state.
-        if (operandStack.GetSize() == sizeof(Frag))
-          {
-            Frag *e = operandStack.template Pop<Frag>(1);
-            Patch(e->out, NewState(kRegexInvalidState, kRegexInvalidState, 0));
-            root_ = e->start;
-
-#if RAPIDJSON_REGEX_VERBOSE
-            printf("root: %d\n", root_);
-            for (SizeType i = 0; i < stateCount_ ; i++)
-              {
-                State &s = GetState(i);
-                printf("[%2d] out: %2d out1: %2d c: '%c'\n", i, s.out, s.out1, (char)s.codepoint);
-              }
-            printf("\n");
-#endif
-          }
-      }
-
-      SizeType NewState(SizeType out, SizeType out1, unsigned codepoint)
-      {
-        State *s = states_.template Push<State>();
-        s->out = out;
-        s->out1 = out1;
-        s->codepoint = codepoint;
-        s->rangeStart = kRegexInvalidRange;
-        return stateCount_++;
-      }
-
-      void PushOperand(Stack<Allocator> &operandStack, unsigned codepoint)
-      {
-        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, codepoint);
-        *operandStack.template Push<Frag>() = Frag(s, s, s);
-      }
-
-      void ImplicitConcatenation(Stack<Allocator> &atomCountStack, Stack<Allocator> &operatorStack)
-      {
-        if (*atomCountStack.template Top<unsigned>())
-          *operatorStack.template Push<Operator>() = kConcatenation;
-        (*atomCountStack.template Top<unsigned>())++;
-      }
-
-      SizeType Append(SizeType l1, SizeType l2)
-      {
-        SizeType old = l1;
-        while (GetState(l1).out != kRegexInvalidState)
-          l1 = GetState(l1).out;
-        GetState(l1).out = l2;
-        return old;
-      }
-
-      void Patch(SizeType l, SizeType s)
-      {
-        for (SizeType next; l != kRegexInvalidState; l = next)
-          {
-            next = GetState(l).out;
-            GetState(l).out = s;
-          }
-      }
-
-      bool Eval(Stack<Allocator> &operandStack, Operator op)
-      {
-        switch (op)
-          {
-            case kConcatenation:
-              RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag) * 2);
-              {
-                Frag e2 = *operandStack.template Pop<Frag>(1);
-                Frag e1 = *operandStack.template Pop<Frag>(1);
-                Patch(e1.out, e2.start);
-                *operandStack.template Push<Frag>() = Frag(e1.start, e2.out, Min(e1.minIndex, e2.minIndex));
-              }
-              return true;
-
-            case kAlternation:
-              if (operandStack.GetSize() >= sizeof(Frag) * 2)
-                {
-                  Frag e2 = *operandStack.template Pop<Frag>(1);
-                  Frag e1 = *operandStack.template Pop<Frag>(1);
-                  SizeType s = NewState(e1.start, e2.start, 0);
-                  *operandStack.template Push<Frag>() = Frag(s, Append(e1.out, e2.out), Min(e1.minIndex, e2.minIndex));
-                  return true;
-                }
-              return false;
-
-            case kZeroOrOne:
-              if (operandStack.GetSize() >= sizeof(Frag))
-                {
-                  Frag e = *operandStack.template Pop<Frag>(1);
-                  SizeType s = NewState(kRegexInvalidState, e.start, 0);
-                  *operandStack.template Push<Frag>() = Frag(s, Append(e.out, s), e.minIndex);
-                  return true;
-                }
-              return false;
-
-            case kZeroOrMore:
-              if (operandStack.GetSize() >= sizeof(Frag))
-                {
-                  Frag e = *operandStack.template Pop<Frag>(1);
-                  SizeType s = NewState(kRegexInvalidState, e.start, 0);
-                  Patch(e.out, s);
-                  *operandStack.template Push<Frag>() = Frag(s, s, e.minIndex);
-                  return true;
-                }
-              return false;
-
-            default:
-              RAPIDJSON_ASSERT(op == kOneOrMore);
-              if (operandStack.GetSize() >= sizeof(Frag))
-                {
-                  Frag e = *operandStack.template Pop<Frag>(1);
-                  SizeType s = NewState(kRegexInvalidState, e.start, 0);
-                  Patch(e.out, s);
-                  *operandStack.template Push<Frag>() = Frag(e.start, s, e.minIndex);
-                  return true;
-                }
-              return false;
-          }
-      }
-
-      bool EvalQuantifier(Stack<Allocator> &operandStack, unsigned n, unsigned m)
-      {
-        RAPIDJSON_ASSERT(n <= m);
-        RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag));
-
-        if (n == 0)
-          {
-            if (m == 0)                             // a{0} not support
-              return false;
-            else if (m == kInfinityQuantifier)
-              Eval(operandStack, kZeroOrMore);    // a{0,} -> a*
-            else
-              {
-                Eval(operandStack, kZeroOrOne);         // a{0,5} -> a?
-                for (unsigned i = 0; i < m - 1; i++)
-                  CloneTopOperand(operandStack);      // a{0,5} -> a? a? a? a? a?
-                for (unsigned i = 0; i < m - 1; i++)
-                  Eval(operandStack, kConcatenation); // a{0,5} -> a?a?a?a?a?
-              }
-            return true;
-          }
-
-        for (unsigned i = 0; i < n - 1; i++)        // a{3} -> a a a
-          CloneTopOperand(operandStack);
-
-        if (m == kInfinityQuantifier)
-          Eval(operandStack, kOneOrMore);         // a{3,} -> a a a+
-        else if (m > n)
-          {
-            CloneTopOperand(operandStack);          // a{3,5} -> a a a a
-            Eval(operandStack, kZeroOrOne);         // a{3,5} -> a a a a?
-            for (unsigned i = n; i < m - 1; i++)
-              CloneTopOperand(operandStack);      // a{3,5} -> a a a a? a?
-            for (unsigned i = n; i < m; i++)
-              Eval(operandStack, kConcatenation); // a{3,5} -> a a aa?a?
-          }
-
-        for (unsigned i = 0; i < n - 1; i++)
-          Eval(operandStack, kConcatenation);     // a{3} -> aaa, a{3,} -> aaa+, a{3.5} -> aaaa?a?
-
-        return true;
-      }
-
-      static SizeType Min(SizeType a, SizeType b)
-      {
-        return a < b ? a : b;
-      }
-
-      void CloneTopOperand(Stack<Allocator> &operandStack)
-      {
-        const Frag src = *operandStack.template Top<Frag>(); // Copy constructor to prevent invalidation
-        SizeType count = stateCount_ - src.minIndex; // Assumes top operand contains states in [src->minIndex, stateCount_)
-        State *s = states_.template Push<State>(count);
-        memcpy(s, &GetState(src.minIndex), count * sizeof(State));
-        for (SizeType j = 0; j < count; j++)
-          {
-            if (s[j].out != kRegexInvalidState)
-              s[j].out += count;
-            if (s[j].out1 != kRegexInvalidState)
-              s[j].out1 += count;
-          }
-        *operandStack.template Push<Frag>() = Frag(src.start + count, src.out + count, src.minIndex + count);
-        stateCount_ += count;
-      }
-
-      template <typename InputStream>
-      bool ParseUnsigned(DecodedStream<InputStream, Encoding> &ds, unsigned *u)
-      {
-        unsigned r = 0;
-        if (ds.Peek() < '0' || ds.Peek() > '9')
-          return false;
-        while (ds.Peek() >= '0' && ds.Peek() <= '9')
-          {
-            if (r >= 429496729 && ds.Peek() > '5') // 2^32 - 1 = 4294967295
-              return false; // overflow
-            r = r * 10 + (ds.Take() - '0');
-          }
-        *u = r;
-        return true;
-      }
-
-      template <typename InputStream>
-      bool ParseRange(DecodedStream<InputStream, Encoding> &ds, SizeType *range)
-      {
-        bool isBegin = true;
-        bool negate = false;
-        int step = 0;
-        SizeType start = kRegexInvalidRange;
-        SizeType current = kRegexInvalidRange;
-        unsigned codepoint;
-        while ((codepoint = ds.Take()) != 0)
-          {
-            if (isBegin)
-              {
-                isBegin = false;
-                if (codepoint == '^')
-                  {
-                    negate = true;
-                    continue;
-                  }
-              }
-
-            switch (codepoint)
-              {
-                case ']':
-                  if (start == kRegexInvalidRange)
-                    return false;   // Error: nothing inside []
-                  if (step == 2)   // Add trailing '-'
-                    {
-                      SizeType r = NewRange('-');
-                      RAPIDJSON_ASSERT(current != kRegexInvalidRange);
-                      GetRange(current).next = r;
-                    }
-                  if (negate)
-                    GetRange(start).start |= kRangeNegationFlag;
-                  *range = start;
-                  return true;
-
-                case '\\':
-                  if (ds.Peek() == 'b')
-                    {
-                      ds.Take();
-                      codepoint = 0x0008; // Escape backspace character
-                    }
-                  else if (!CharacterEscape(ds, &codepoint))
-                    return false;
-                // fall through to default
-
-                default:
-                  switch (step)
-                    {
-                      case 1:
-                        if (codepoint == '-')
-                          {
-                            step++;
-                            break;
-                          }
-                      // fall through to step 0 for other characters
-
-                      case 0:
-                      {
-                        SizeType r = NewRange(codepoint);
-                        if (current != kRegexInvalidRange)
-                          GetRange(current).next = r;
-                        if (start == kRegexInvalidRange)
-                          start = r;
-                        current = r;
-                      }
-                      step = 1;
-                      break;
-
-                      default:
-                        RAPIDJSON_ASSERT(step == 2);
-                        GetRange(current).end = codepoint;
-                        step = 0;
-                    }
-              }
-          }
-        return false;
-      }
-
-      SizeType NewRange(unsigned codepoint)
-      {
-        Range *r = ranges_.template Push<Range>();
-        r->start = r->end = codepoint;
-        r->next = kRegexInvalidRange;
-        return rangeCount_++;
-      }
-
-      template <typename InputStream>
-      bool CharacterEscape(DecodedStream<InputStream, Encoding> &ds, unsigned *escapedCodepoint)
-      {
-        unsigned codepoint;
-        switch (codepoint = ds.Take())
-          {
-            case '^':
-            case '$':
-            case '|':
-            case '(':
-            case ')':
-            case '?':
-            case '*':
-            case '+':
-            case '.':
-            case '[':
-            case ']':
-            case '{':
-            case '}':
-            case '\\':
-              *escapedCodepoint = codepoint;
-              return true;
-            case 'f':
-              *escapedCodepoint = 0x000C;
-              return true;
-            case 'n':
-              *escapedCodepoint = 0x000A;
-              return true;
-            case 'r':
-              *escapedCodepoint = 0x000D;
-              return true;
-            case 't':
-              *escapedCodepoint = 0x0009;
-              return true;
-            case 'v':
-              *escapedCodepoint = 0x000B;
-              return true;
-            default:
-              return false; // Unsupported escape character
-          }
-      }
-
-      Stack<Allocator> states_;
-      Stack<Allocator> ranges_;
-      SizeType root_;
-      SizeType stateCount_;
-      SizeType rangeCount_;
-
-      static const unsigned kInfinityQuantifier = ~0u;
-
-      // For SearchWithAnchoring()
-      bool anchorBegin_;
-      bool anchorEnd_;
-  };
-
-  template <typename RegexType, typename Allocator = CrtAllocator>
-  class GenericRegexSearch
-  {
-    public:
-      typedef typename RegexType::EncodingType Encoding;
-      typedef typename Encoding::Ch Ch;
-
-      GenericRegexSearch(const RegexType &regex, Allocator *allocator = 0) :
-        regex_(regex), allocator_(allocator), ownAllocator_(0),
-        state0_(allocator, 0), state1_(allocator, 0), stateSet_()
-      {
-        RAPIDJSON_ASSERT(regex_.IsValid());
-        if (!allocator_)
-          ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-        stateSet_ = static_cast<unsigned *>(allocator_->Malloc(GetStateSetSize()));
-        state0_.template Reserve<SizeType>(regex_.stateCount_);
-        state1_.template Reserve<SizeType>(regex_.stateCount_);
-      }
-
-      ~GenericRegexSearch()
-      {
-        Allocator::Free(stateSet_);
-        RAPIDJSON_DELETE(ownAllocator_);
-      }
-
-      template <typename InputStream>
-      bool Match(InputStream &is)
-      {
-        return SearchWithAnchoring(is, true, true);
-      }
-
-      bool Match(const Ch *s)
-      {
-        GenericStringStream<Encoding> is(s);
-        return Match(is);
-      }
-
-      template <typename InputStream>
-      bool Search(InputStream &is)
-      {
-        return SearchWithAnchoring(is, regex_.anchorBegin_, regex_.anchorEnd_);
-      }
-
-      bool Search(const Ch *s)
-      {
-        GenericStringStream<Encoding> is(s);
-        return Search(is);
-      }
-
-    private:
-      typedef typename RegexType::State State;
-      typedef typename RegexType::Range Range;
-
-      template <typename InputStream>
-      bool SearchWithAnchoring(InputStream &is, bool anchorBegin, bool anchorEnd)
-      {
-        DecodedStream<InputStream, Encoding> ds(is);
-
-        state0_.Clear();
-        Stack<Allocator> *current = &state0_, *next = &state1_;
-        const size_t stateSetSize = GetStateSetSize();
-        std::memset(stateSet_, 0, stateSetSize);
-
-        bool matched = AddState(*current, regex_.root_);
-        unsigned codepoint = 0;
-        while (!current->Empty() && (codepoint = ds.Take()) != 0)
-          {
-            std::memset(stateSet_, 0, stateSetSize);
-            next->Clear();
-            matched = false;
-            for (const SizeType *s = current->template Bottom<SizeType>(); s != current->template End<SizeType>(); ++s)
-              {
-                const State &sr = regex_.GetState(*s);
-                if (sr.codepoint == codepoint ||
-                    sr.codepoint == RegexType::kAnyCharacterClass ||
-                    (sr.codepoint == RegexType::kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))
-                  {
-                    matched = AddState(*next, sr.out) || matched;
-                    if (!anchorEnd && matched)
-                      return true;
-                  }
-                if (!anchorBegin)
-                  AddState(*next, regex_.root_);
-              }
-            internal::Swap(current, next);
-          }
-
-        return matched;
-      }
-
-      size_t GetStateSetSize() const
-      {
-        return (regex_.stateCount_ + 31) / 32 * 4;
-      }
-
-      // Return whether the added states is a match state
-      bool AddState(Stack<Allocator> &l, SizeType index)
-      {
-        RAPIDJSON_ASSERT(index != kRegexInvalidState);
-
-        const State &s = regex_.GetState(index);
-        if (s.out1 != kRegexInvalidState)   // Split
-          {
-            bool matched = AddState(l, s.out);
-            return AddState(l, s.out1) || matched;
-          }
-        else if (!(stateSet_[index >> 5] & (1u << (index & 31))))
-          {
-            stateSet_[index >> 5] |= (1u << (index & 31));
-            *l.template PushUnsafe<SizeType>() = index;
-          }
-        return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation.
-      }
-
-      bool MatchRange(SizeType rangeIndex, unsigned codepoint) const
-      {
-        bool yes = (regex_.GetRange(rangeIndex).start & RegexType::kRangeNegationFlag) == 0;
-        while (rangeIndex != kRegexInvalidRange)
-          {
-            const Range &r = regex_.GetRange(rangeIndex);
-            if (codepoint >= (r.start & ~RegexType::kRangeNegationFlag) && codepoint <= r.end)
-              return yes;
-            rangeIndex = r.next;
-          }
-        return !yes;
-      }
-
-      const RegexType &regex_;
-      Allocator *allocator_;
-      Allocator *ownAllocator_;
-      Stack<Allocator> state0_;
-      Stack<Allocator> state1_;
-      uint32_t *stateSet_;
-  };
-
-  typedef GenericRegex<UTF8<> > Regex;
-  typedef GenericRegexSearch<Regex> RegexSearch;
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#if defined(__clang__) || defined(_MSC_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_INTERNAL_REGEX_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/stack.h.bak b/contrib/world_builder/include/rapidjson/internal/stack.h.bak
deleted file mode 100644
index 8d64a7a451c..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/stack.h.bak
+++ /dev/null
@@ -1,277 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_STACK_H_
-#define RAPIDJSON_INTERNAL_STACK_H_
-
-#include "../allocators.h"
-#include "swap.h"
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-///////////////////////////////////////////////////////////////////////////////
-// Stack
-
-//! A type-unsafe stack for storing different types of data.
-  /*! \tparam Allocator Allocator for allocating stack memory.
-  */
-  template <typename Allocator>
-  class Stack
-  {
-    public:
-      // Optimization note: Do not allocate memory for stack_ in constructor.
-      // Do it lazily when first Push() -> Expand() -> Resize().
-      Stack(Allocator *allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity)
-      {
-      }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-      Stack(Stack &&rhs)
-        : allocator_(rhs.allocator_),
-          ownAllocator_(rhs.ownAllocator_),
-          stack_(rhs.stack_),
-          stackTop_(rhs.stackTop_),
-          stackEnd_(rhs.stackEnd_),
-          initialCapacity_(rhs.initialCapacity_)
-      {
-        rhs.allocator_ = 0;
-        rhs.ownAllocator_ = 0;
-        rhs.stack_ = 0;
-        rhs.stackTop_ = 0;
-        rhs.stackEnd_ = 0;
-        rhs.initialCapacity_ = 0;
-      }
-#endif
-
-      ~Stack()
-      {
-        Destroy();
-      }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-      Stack &operator=(Stack&& rhs)
-      {
-        if (&rhs != this)
-          {
-            Destroy();
-
-            allocator_ = rhs.allocator_;
-            ownAllocator_ = rhs.ownAllocator_;
-            stack_ = rhs.stack_;
-            stackTop_ = rhs.stackTop_;
-            stackEnd_ = rhs.stackEnd_;
-            initialCapacity_ = rhs.initialCapacity_;
-
-            rhs.allocator_ = 0;
-            rhs.ownAllocator_ = 0;
-            rhs.stack_ = 0;
-            rhs.stackTop_ = 0;
-            rhs.stackEnd_ = 0;
-            rhs.initialCapacity_ = 0;
-          }
-        return *this;
-      }
-#endif
-
-      void Swap(Stack &rhs) RAPIDJSON_NOEXCEPT
-      {
-        internal::Swap(allocator_, rhs.allocator_);
-        internal::Swap(ownAllocator_, rhs.ownAllocator_);
-        internal::Swap(stack_, rhs.stack_);
-        internal::Swap(stackTop_, rhs.stackTop_);
-        internal::Swap(stackEnd_, rhs.stackEnd_);
-        internal::Swap(initialCapacity_, rhs.initialCapacity_);
-      }
-
-      void Clear()
-      {
-        stackTop_ = stack_;
-      }
-
-      void ShrinkToFit()
-      {
-        if (Empty())
-          {
-            // If the stack is empty, completely deallocate the memory.
-            Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc)
-            stack_ = 0;
-            stackTop_ = 0;
-            stackEnd_ = 0;
-          }
-        else
-          Resize(GetSize());
-      }
-
-      // Optimization note: try to minimize the size of this function for force inline.
-      // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
-      template<typename T>
-      RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1)
-      {
-        // Expand the stack if needed
-        if (RAPIDJSON_UNLIKELY(stackTop_ + sizeof(T) * count > stackEnd_))
-          Expand<T>(count);
-      }
-
-      template<typename T>
-      RAPIDJSON_FORCEINLINE T *Push(size_t count = 1)
-      {
-        Reserve<T>(count);
-        return PushUnsafe<T>(count);
-      }
-
-      template<typename T>
-      RAPIDJSON_FORCEINLINE T *PushUnsafe(size_t count = 1)
-      {
-        RAPIDJSON_ASSERT(stackTop_);
-        RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_);
-        T *ret = reinterpret_cast<T *>(stackTop_);
-        stackTop_ += sizeof(T) * count;
-        return ret;
-      }
-
-      template<typename T>
-      T *Pop(size_t count)
-      {
-        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
-        stackTop_ -= count * sizeof(T);
-        return reinterpret_cast<T *>(stackTop_);
-      }
-
-      template<typename T>
-      T *Top()
-      {
-        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
-        return reinterpret_cast<T *>(stackTop_ - sizeof(T));
-      }
-
-      template<typename T>
-      const T *Top() const
-      {
-        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
-        return reinterpret_cast<T *>(stackTop_ - sizeof(T));
-      }
-
-      template<typename T>
-      T *End()
-      {
-        return reinterpret_cast<T *>(stackTop_);
-      }
-
-      template<typename T>
-      const T *End() const
-      {
-        return reinterpret_cast<T *>(stackTop_);
-      }
-
-      template<typename T>
-      T *Bottom()
-      {
-        return reinterpret_cast<T *>(stack_);
-      }
-
-      template<typename T>
-      const T *Bottom() const
-      {
-        return reinterpret_cast<T *>(stack_);
-      }
-
-      bool HasAllocator() const
-      {
-        return allocator_ != 0;
-      }
-
-      Allocator &GetAllocator()
-      {
-        RAPIDJSON_ASSERT(allocator_);
-        return *allocator_;
-      }
-
-      bool Empty() const
-      {
-        return stackTop_ == stack_;
-      }
-      size_t GetSize() const
-      {
-        return static_cast<size_t>(stackTop_ - stack_);
-      }
-      size_t GetCapacity() const
-      {
-        return static_cast<size_t>(stackEnd_ - stack_);
-      }
-
-    private:
-      template<typename T>
-      void Expand(size_t count)
-      {
-        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
-        size_t newCapacity;
-        if (stack_ == 0)
-          {
-            if (!allocator_)
-              ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-            newCapacity = initialCapacity_;
-          }
-        else
-          {
-            newCapacity = GetCapacity();
-            newCapacity += (newCapacity + 1) / 2;
-          }
-        size_t newSize = GetSize() + sizeof(T) * count;
-        if (newCapacity < newSize)
-          newCapacity = newSize;
-
-        Resize(newCapacity);
-      }
-
-      void Resize(size_t newCapacity)
-      {
-        const size_t size = GetSize();  // Backup the current size
-        stack_ = static_cast<char *>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
-        stackTop_ = stack_ + size;
-        stackEnd_ = stack_ + newCapacity;
-      }
-
-      void Destroy()
-      {
-        Allocator::Free(stack_);
-        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
-      }
-
-      // Prohibit copy constructor & assignment operator.
-      Stack(const Stack &);
-      Stack &operator=(const Stack &);
-
-      Allocator *allocator_;
-      Allocator *ownAllocator_;
-      char *stack_;
-      char *stackTop_;
-      char *stackEnd_;
-      size_t initialCapacity_;
-  };
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_STACK_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/strfunc.h.bak b/contrib/world_builder/include/rapidjson/internal/strfunc.h.bak
deleted file mode 100644
index c6a36d50f69..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/strfunc.h.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_STRFUNC_H_
-#define RAPIDJSON_INTERNAL_STRFUNC_H_
-
-#include "../stream.h"
-#include <cwchar>
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-//! Custom strlen() which works on different character types.
-  /*! \tparam Ch Character type (e.g. char, wchar_t, short)
-      \param s Null-terminated input string.
-      \return Number of characters in the string.
-      \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
-  */
-  template <typename Ch>
-  inline SizeType StrLen(const Ch *s)
-  {
-    RAPIDJSON_ASSERT(s != 0);
-    const Ch *p = s;
-    while (*p) ++p;
-    return SizeType(p - s);
-  }
-
-  template <>
-  inline SizeType StrLen(const char *s)
-  {
-    return SizeType(std::strlen(s));
-  }
-
-  template <>
-  inline SizeType StrLen(const wchar_t *s)
-  {
-    return SizeType(std::wcslen(s));
-  }
-
-//! Returns number of code points in a encoded string.
-  template<typename Encoding>
-  bool CountStringCodePoint(const typename Encoding::Ch *s, SizeType length, SizeType *outCount)
-  {
-    RAPIDJSON_ASSERT(s != 0);
-    RAPIDJSON_ASSERT(outCount != 0);
-    GenericStringStream<Encoding> is(s);
-    const typename Encoding::Ch *end = s + length;
-    SizeType count = 0;
-    while (is.src_ < end)
-      {
-        unsigned codepoint;
-        if (!Encoding::Decode(is, &codepoint))
-          return false;
-        count++;
-      }
-    *outCount = count;
-    return true;
-  }
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_INTERNAL_STRFUNC_H_
diff --git a/contrib/world_builder/include/rapidjson/internal/strtod.h.bak b/contrib/world_builder/include/rapidjson/internal/strtod.h.bak
deleted file mode 100644
index b98760f7345..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/strtod.h.bak
+++ /dev/null
@@ -1,317 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_STRTOD_
-#define RAPIDJSON_STRTOD_
-
-#include "ieee754.h"
-#include "biginteger.h"
-#include "diyfp.h"
-#include "pow10.h"
-#include <climits>
-#include <limits>
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-  inline double FastPath(double significand, int exp)
-  {
-    if (exp < -308)
-      return 0.0;
-    else if (exp >= 0)
-      return significand * internal::Pow10(exp);
-    else
-      return significand / internal::Pow10(-exp);
-  }
-
-  inline double StrtodNormalPrecision(double d, int p)
-  {
-    if (p < -308)
-      {
-        // Prevent expSum < -308, making Pow10(p) = 0
-        d = FastPath(d, -308);
-        d = FastPath(d, p + 308);
-      }
-    else
-      d = FastPath(d, p);
-    return d;
-  }
-
-  template <typename T>
-  inline T Min3(T a, T b, T c)
-  {
-    T m = a;
-    if (m > b) m = b;
-    if (m > c) m = c;
-    return m;
-  }
-
-  inline int CheckWithinHalfULP(double b, const BigInteger &d, int dExp)
-  {
-    const Double db(b);
-    const uint64_t bInt = db.IntegerSignificand();
-    const int bExp = db.IntegerExponent();
-    const int hExp = bExp - 1;
-
-    int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
-
-    // Adjust for decimal exponent
-    if (dExp >= 0)
-      {
-        dS_Exp2 += dExp;
-        dS_Exp5 += dExp;
-      }
-    else
-      {
-        bS_Exp2 -= dExp;
-        bS_Exp5 -= dExp;
-        hS_Exp2 -= dExp;
-        hS_Exp5 -= dExp;
-      }
-
-    // Adjust for binary exponent
-    if (bExp >= 0)
-      bS_Exp2 += bExp;
-    else
-      {
-        dS_Exp2 -= bExp;
-        hS_Exp2 -= bExp;
-      }
-
-    // Adjust for half ulp exponent
-    if (hExp >= 0)
-      hS_Exp2 += hExp;
-    else
-      {
-        dS_Exp2 -= hExp;
-        bS_Exp2 -= hExp;
-      }
-
-    // Remove common power of two factor from all three scaled values
-    int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
-    dS_Exp2 -= common_Exp2;
-    bS_Exp2 -= common_Exp2;
-    hS_Exp2 -= common_Exp2;
-
-    BigInteger dS = d;
-    dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);
-
-    BigInteger bS(bInt);
-    bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);
-
-    BigInteger hS(1);
-    hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);
-
-    BigInteger delta(0);
-    dS.Difference(bS, &delta);
-
-    return delta.Compare(hS);
-  }
-
-  inline bool StrtodFast(double d, int p, double *result)
-  {
-    // Use fast path for string-to-double conversion if possible
-    // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
-    if (p > 22  && p < 22 + 16)
-      {
-        // Fast Path Cases In Disguise
-        d *= internal::Pow10(p - 22);
-        p = 22;
-      }
-
-    if (p >= -22 && p <= 22 && d <= 9007199254740991.0)   // 2^53 - 1
-      {
-        *result = FastPath(d, p);
-        return true;
-      }
-    else
-      return false;
-  }
-
-// Compute an approximation and see if it is within 1/2 ULP
-  inline bool StrtodDiyFp(const char *decimals, int dLen, int dExp, double *result)
-  {
-    uint64_t significand = 0;
-    int i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999
-    for (; i < dLen; i++)
-      {
-        if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
-            (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
-          break;
-        significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
-      }
-
-    if (i < dLen && decimals[i] >= '5') // Rounding
-      significand++;
-
-    int remaining = dLen - i;
-    const int kUlpShift = 3;
-    const int kUlp = 1 << kUlpShift;
-    int64_t error = (remaining == 0) ? 0 : kUlp / 2;
-
-    DiyFp v(significand, 0);
-    v = v.Normalize();
-    error <<= -v.e;
-
-    dExp += remaining;
-
-    int actualExp;
-    DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
-    if (actualExp != dExp)
-      {
-        static const DiyFp kPow10[] =
-        {
-          DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 0x00000000), -60),  // 10^1
-          DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 0x00000000), -57),  // 10^2
-          DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 0x00000000), -54),  // 10^3
-          DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), -50),  // 10^4
-          DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 0x00000000), -47),  // 10^5
-          DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 0x00000000), -44),  // 10^6
-          DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 0x00000000), -40)   // 10^7
-        };
-        int adjustment = dExp - actualExp;
-        RAPIDJSON_ASSERT(adjustment >= 1 && adjustment < 8);
-        v = v * kPow10[adjustment - 1];
-        if (dLen + adjustment > 19) // has more digits than decimal digits in 64-bit
-          error += kUlp / 2;
-      }
-
-    v = v * cachedPower;
-
-    error += kUlp + (error == 0 ? 0 : 1);
-
-    const int oldExp = v.e;
-    v = v.Normalize();
-    error <<= oldExp - v.e;
-
-    const int effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
-    int precisionSize = 64 - effectiveSignificandSize;
-    if (precisionSize + kUlpShift >= 64)
-      {
-        int scaleExp = (precisionSize + kUlpShift) - 63;
-        v.f >>= scaleExp;
-        v.e += scaleExp;
-        error = (error >> scaleExp) + 1 + kUlp;
-        precisionSize -= scaleExp;
-      }
-
-    DiyFp rounded(v.f >> precisionSize, v.e + precisionSize);
-    const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
-    const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
-    if (precisionBits >= halfWay + static_cast<unsigned>(error))
-      {
-        rounded.f++;
-        if (rounded.f & (DiyFp::kDpHiddenBit << 1))   // rounding overflows mantissa (issue #340)
-          {
-            rounded.f >>= 1;
-            rounded.e++;
-          }
-      }
-
-    *result = rounded.ToDouble();
-
-    return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
-  }
-
-  inline double StrtodBigInteger(double approx, const char *decimals, int dLen, int dExp)
-  {
-    RAPIDJSON_ASSERT(dLen >= 0);
-    const BigInteger dInt(decimals, static_cast<unsigned>(dLen));
-    Double a(approx);
-    int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
-    if (cmp < 0)
-      return a.Value();  // within half ULP
-    else if (cmp == 0)
-      {
-        // Round towards even
-        if (a.Significand() & 1)
-          return a.NextPositiveDouble();
-        else
-          return a.Value();
-      }
-    else // adjustment
-      return a.NextPositiveDouble();
-  }
-
-  inline double StrtodFullPrecision(double d, int p, const char *decimals, size_t length, size_t decimalPosition, int exp)
-  {
-    RAPIDJSON_ASSERT(d >= 0.0);
-    RAPIDJSON_ASSERT(length >= 1);
-
-    double result = 0.0;
-    if (StrtodFast(d, p, &result))
-      return result;
-
-    RAPIDJSON_ASSERT(length <= INT_MAX);
-    int dLen = static_cast<int>(length);
-
-    RAPIDJSON_ASSERT(length >= decimalPosition);
-    RAPIDJSON_ASSERT(length - decimalPosition <= INT_MAX);
-    int dExpAdjust = static_cast<int>(length - decimalPosition);
-
-    RAPIDJSON_ASSERT(exp >= INT_MIN + dExpAdjust);
-    int dExp = exp - dExpAdjust;
-
-    // Make sure length+dExp does not overflow
-    RAPIDJSON_ASSERT(dExp <= INT_MAX - dLen);
-
-    // Trim leading zeros
-    while (dLen > 0 && *decimals == '0')
-      {
-        dLen--;
-        decimals++;
-      }
-
-    // Trim trailing zeros
-    while (dLen > 0 && decimals[dLen - 1] == '0')
-      {
-        dLen--;
-        dExp++;
-      }
-
-    if (dLen == 0)   // Buffer only contains zeros.
-      {
-        return 0.0;
-      }
-
-    // Trim right-most digits
-    const int kMaxDecimalDigit = 767 + 1;
-    if (dLen > kMaxDecimalDigit)
-      {
-        dExp += dLen - kMaxDecimalDigit;
-        dLen = kMaxDecimalDigit;
-      }
-
-    // If too small, underflow to zero.
-    // Any x <= 10^-324 is interpreted as zero.
-    if (dLen + dExp <= -324)
-      return 0.0;
-
-    // If too large, overflow to infinity.
-    // Any x >= 10^309 is interpreted as +infinity.
-    if (dLen + dExp > 309)
-      return std::numeric_limits<double>::infinity();
-
-    if (StrtodDiyFp(decimals, dLen, dExp, &result))
-      return result;
-
-    // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
-    return StrtodBigInteger(result, decimals, dLen, dExp);
-  }
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_STRTOD_
diff --git a/contrib/world_builder/include/rapidjson/internal/swap.h.bak b/contrib/world_builder/include/rapidjson/internal/swap.h.bak
deleted file mode 100644
index dfb1f19e77e..00000000000
--- a/contrib/world_builder/include/rapidjson/internal/swap.h.bak
+++ /dev/null
@@ -1,48 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_INTERNAL_SWAP_H_
-#define RAPIDJSON_INTERNAL_SWAP_H_
-
-#include "../rapidjson.h"
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal
-{
-
-//! Custom swap() to avoid dependency on C++ <algorithm> header
-  /*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.
-      \note This has the same semantics as std::swap().
-  */
-  template <typename T>
-  inline void Swap(T &a, T &b) RAPIDJSON_NOEXCEPT
-  {
-    T tmp = a;
-    a = b;
-    b = tmp;
-  }
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_INTERNAL_SWAP_H_
diff --git a/contrib/world_builder/include/rapidjson/istreamwrapper.h.bak b/contrib/world_builder/include/rapidjson/istreamwrapper.h.bak
deleted file mode 100644
index f3b83b6858f..00000000000
--- a/contrib/world_builder/include/rapidjson/istreamwrapper.h.bak
+++ /dev/null
@@ -1,137 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_ISTREAMWRAPPER_H_
-#define RAPIDJSON_ISTREAMWRAPPER_H_
-
-#include "stream.h"
-#include <iosfwd>
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Wrapper of \c std::basic_istream into RapidJSON's Stream concept.
-/*!
-    The classes can be wrapped including but not limited to:
-
-    - \c std::istringstream
-    - \c std::stringstream
-    - \c std::wistringstream
-    - \c std::wstringstream
-    - \c std::ifstream
-    - \c std::fstream
-    - \c std::wifstream
-    - \c std::wfstream
-
-    \tparam StreamType Class derived from \c std::basic_istream.
-*/
-
-template <typename StreamType>
-class BasicIStreamWrapper
-{
-  public:
-    typedef typename StreamType::char_type Ch;
-    BasicIStreamWrapper(StreamType &stream) : stream_(stream), count_(), peekBuffer_() {}
-
-    Ch Peek() const
-    {
-      typename StreamType::int_type c = stream_.peek();
-      return RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()) ? static_cast<Ch>(c) : static_cast<Ch>('\0');
-    }
-
-    Ch Take()
-    {
-      typename StreamType::int_type c = stream_.get();
-      if (RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()))
-        {
-          count_++;
-          return static_cast<Ch>(c);
-        }
-      else
-        return '\0';
-    }
-
-    // tellg() may return -1 when failed. So we count by ourself.
-    size_t Tell() const
-    {
-      return count_;
-    }
-
-    Ch *PutBegin()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    void Put(Ch)
-    {
-      RAPIDJSON_ASSERT(false);
-    }
-    void Flush()
-    {
-      RAPIDJSON_ASSERT(false);
-    }
-    size_t PutEnd(Ch *)
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-
-    // For encoding detection only.
-    const Ch *Peek4() const
-    {
-      RAPIDJSON_ASSERT(sizeof(Ch) == 1); // Only usable for byte stream.
-      int i;
-      bool hasError = false;
-      for (i = 0; i < 4; ++i)
-        {
-          typename StreamType::int_type c = stream_.get();
-          if (c == StreamType::traits_type::eof())
-            {
-              hasError = true;
-              stream_.clear();
-              break;
-            }
-          peekBuffer_[i] = static_cast<Ch>(c);
-        }
-      for (--i; i >= 0; --i)
-        stream_.putback(peekBuffer_[i]);
-      return !hasError ? peekBuffer_ : 0;
-    }
-
-  private:
-    BasicIStreamWrapper(const BasicIStreamWrapper &);
-    BasicIStreamWrapper &operator=(const BasicIStreamWrapper &);
-
-    StreamType &stream_;
-    size_t count_;  //!< Number of characters read. Note:
-    mutable Ch peekBuffer_[4];
-};
-
-typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
-typedef BasicIStreamWrapper<std::wistream> WIStreamWrapper;
-
-#if defined(__clang__) || defined(_MSC_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ISTREAMWRAPPER_H_
diff --git a/contrib/world_builder/include/rapidjson/latexwriter.h.bak b/contrib/world_builder/include/rapidjson/latexwriter.h.bak
deleted file mode 100644
index 85c07e958ad..00000000000
--- a/contrib/world_builder/include/rapidjson/latexwriter.h.bak
+++ /dev/null
@@ -1,468 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_LATEXWRITER_H_
-#define RAPIDJSON_LATEXWRITER_H_
-
-#include "writer.h"
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-
-//! Writer with indentation and spacing.
-/*!
-    \tparam OutputStream Type of output os.
-    \tparam SourceEncoding Encoding of source string.
-    \tparam TargetEncoding Encoding of output stream.
-    \tparam StackAllocator Type of allocator for allocating memory of stack.
-*/
-template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
-class LatexWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags>
-{
-  public:
-    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base;
-    typedef typename Base::Ch Ch;
-
-    //! Constructor
-    /*! \param os Output stream.
-        \param allocator User supplied allocator. If it is null, it will create a private one.
-        \param levelDepth Initial capacity of stack.
-    */
-    explicit LatexWriter(OutputStream &os, StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
-      Base(os, allocator, levelDepth)
-    {
-      level_type.resize(0);
-      array_number.resize(0);
-      path.resize(0);
-    }
-
-
-    explicit LatexWriter(StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
-      Base(allocator, levelDepth)
-    {
-      level_type.resize(0);
-      array_number.resize(0);
-      path.resize(0);
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    LatexWriter(LatexWriter &&rhs) :
-      Base(std::forward<LatexWriter>(rhs))
-    {
-      level_type.resize(0);
-      array_number.resize(0);
-      path.resize(0);
-    }
-#endif
-
-    /*! @name Implementation of Handler
-        \see Handler
-    */
-    //@{
-
-    bool Null()
-    {
-      return Base::EndValue(Base::WriteNull());
-    }
-    bool Bool(bool b)
-    {
-      Base::EndValue(Base::WriteBool(b));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Int(int i)
-    {
-      Base::EndValue(Base::WriteInt(i));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Uint(unsigned u)
-    {
-      Base::EndValue(Base::WriteUint(u));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Int64(int64_t i64)
-    {
-      Base::EndValue(Base::WriteInt64(i64));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Uint64(uint64_t u64)
-    {
-      Base::EndValue(Base::WriteUint64(u64));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Double(double d)
-    {
-      Base::EndValue(Base::WriteDouble(d));
-      Base::os_->Put('\n');
-      return true;
-    }
-
-    bool RawNumber(const Ch *str, SizeType length, bool /*copy = false*/)
-    {
-      RAPIDJSON_ASSERT(str != 0);
-      Base::EndValue(Base::WriteString(str, length, false));
-      Base::os_->Put('\n');
-      return true;
-    }
-
-    bool String(const Ch *str, SizeType length, bool /*copy = false*/)
-    {
-      RAPIDJSON_ASSERT(str != 0);
-      if (small_array == true)
-        {
-          if (first_small_array == true)
-            first_small_array = false;
-          else
-            {
-              Base::os_->Put(',');
-              Base::os_->Put(' ');
-            }
-        }
-      Base::EndValue(Base::WriteString(str, length, false));
-
-      if (small_array == false)
-        Base::os_->Put('\n');
-      return true;
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool String(const std::basic_string<Ch> &str)
-    {
-      return String(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool StartObject()
-    {
-      std::string begin = "";
-      if (level_type.size() != 0 && level_type.back() == 1)
-        {
-          // this is a properties starting, so first clear all the itemize
-          // the lvel_type.push_back(1) has already been done by the key: properties
-          for (unsigned int i = 0; i < itemize_open; ++i)
-            {
-              begin += "\\end{itemize}";
-            }
-          itemize_open = 0;
-          if (skip_next_push_back == false)
-            {
-              if (section_level <= 2)
-                begin += "\\section{(" + std::to_string(section_level) + ") " + get_path() + "}";
-              else if (section_level <= 5)
-                begin += "\\subsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
-              else if (section_level <= 8)
-                begin += "\\subsubsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
-              else
-                begin += "\\paragraph{(" + std::to_string(section_level) + ") " + get_path() + "}";
-
-              open_new_itemize = true;
-              level_type.push_back(0);
-            }
-          else
-            {
-              skip_next_push_back = false;
-            }
-        }
-      else if (level_type.size() != 0 && level_type.back() == 2)
-        {
-          // this is a array starting, so first clear all the itemize
-          // the lvel_type.push_back(1) has already been done by the key: properties
-          for (unsigned int i = 0; i < itemize_open; ++i)
-            {
-              begin += "\\end{itemize}";
-            }
-          itemize_open = 0;
-          unsigned int number = array_number.back() + 1;
-          array_number.back() = number;
-          path.push_back(std::to_string(array_number.back()));
-          level_type.push_back(0);
-          // have arrrays (/oneOf/1) as new section level
-          section_level++;
-
-          if (section_level <= 2)
-            begin += "\\section{(" + std::to_string(section_level) + ") " + get_path() + "}";
-          else if (section_level <= 5)
-            begin += "\\subsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
-          else if (section_level <= 8)
-            begin += "\\subsubsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
-          else
-            begin += "\\paragraph{(" + std::to_string(section_level) + ") " + get_path() + "}";
-
-          open_new_itemize = true;
-        }
-      else
-        {
-          for (unsigned int i = 0; i < itemize_open; ++i)
-            {
-              begin += "\\end{itemize}";
-            }
-          itemize_open = 0;
-
-          //begin += "C";
-          if (section_level <= 2)
-            begin += "\\section{(" + std::to_string(section_level) + ") " + get_path() + "}";
-          else if (section_level <= 5)
-            begin += "\\subsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
-          else if (section_level <= 8)
-            begin += "\\subsubsection{(" + std::to_string(section_level) + ") " + get_path() + "}";
-          else
-            begin += "\\paragraph{(" + std::to_string(section_level) + ") " + get_path() + "}";
-
-          open_new_itemize = true;
-          if (level_type.size() > 0 && (level_type.back() != 3 || level_type.size() == 0))
-            level_type.push_back(0);
-        }
-
-      Base::WriteString(begin.c_str(), static_cast<rapidjson::SizeType>(begin.size()), false);
-      Base::os_->Put('\n');
-
-      return true;
-    }
-
-    bool Key(const Ch *str, SizeType /*length*/, bool /*copy = false*/)
-    {
-      std::string item = "";
-
-
-      std::string key(str);
-      if (key == "properties")
-        {
-          if (open_new_itemize == true)
-            {
-              item += "\\begin{itemize}[leftmargin=" + std::to_string(section_level) + "em]";
-              itemize_open++;
-            }
-          level_type.push_back(1);
-          skip_next_push_back = true;
-        }
-      else if (key == "oneOf")
-        {
-          level_type.push_back(2);
-          path.push_back(key);
-        }
-      else if (key == "items")
-        {
-          if (open_new_itemize == true)
-            {
-              item += "\\begin{itemize}[leftmargin=" + std::to_string(section_level) + "em]";
-              itemize_open++;
-            }
-          section_level++;
-          level_type.push_back(3);
-          path.push_back(key);
-        }
-      else if (level_type.size() > 0 && level_type.back() == 1)
-        {
-          // the level just below properties, these are the sections
-          // add to the path
-
-          section_level++;
-          path.push_back(key);
-        }
-      else
-        {
-          if (open_new_itemize == true)
-            {
-              item += "\\begin{itemize}[leftmargin=" + std::to_string(section_level) + "em]";
-              itemize_open++;
-
-            }
-          item += "\\item {\\bf " + std::string(str) + "}: ";
-        }
-
-      open_new_itemize = false;
-      Base::WriteString(item.c_str(), static_cast<rapidjson::SizeType>(item.length()), false);
-
-      return true;
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool Key(const std::basic_string<Ch> &str)
-    {
-      return Key(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool EndObject(SizeType /*memberCount = 0*/)
-    {
-      std::string end = "";
-      if (itemize_open > 0)
-        {
-          end = "\\end{itemize}";
-          itemize_open--;
-        }
-      itemize_open = 0;
-      // If this assert fails it could be an indicator that
-      // the world builder library is not fuly linked to the
-      // appllication.
-      if (level_type.size() > 0 && (level_type.back() == 0 || level_type.back() == 3))
-        section_level = section_level > 0 ? section_level-1 : 0;
-
-
-      if (level_type.size() > 0 && path.size() > 0 &&
-          ( level_type.back() == 3 || level_type.back() == 0))
-        {
-          path.pop_back();
-        }
-
-      if (level_type.size() > 0)
-        level_type.pop_back();
-
-      Base::WriteString(end.c_str(), static_cast<rapidjson::SizeType>(end.length()), false);
-
-      return true;
-    }
-
-    bool StartArray()
-    {
-      std::string begin = "";
-      if (level_type.size() != 0 && level_type.back() == 2)
-        {
-          // this is a properties starting, so first clear all the itemize
-          // the lvel_type.push_back(1) has already been done by the key: properties
-          for (unsigned int i = 0; i < itemize_open; ++i)
-            {
-              begin += "\\end{itemize}";
-            }
-          itemize_open = 0;
-
-          open_new_itemize = true;
-          array_number.push_back(0);
-        }
-      else
-        {
-          begin = "[";
-          small_array = true;
-          first_small_array = true;
-        }
-
-      Base::WriteString(begin.c_str(), static_cast<rapidjson::SizeType>(begin.size()), false);
-
-      if (small_array == false)
-        Base::os_->Put('\n');
-
-      return true;
-    }
-
-    bool EndArray(SizeType /*memberCount = 0*/)
-    {
-      std::string end = "";
-      if (level_type.size() != 0 && level_type.back() == 2)
-        {
-          array_number.pop_back();
-          level_type.pop_back();
-
-          if (path.size() > 0)
-            path.pop_back();
-        }
-      else
-        {
-          end = "]";
-          small_array = false;
-        }
-
-      Base::WriteString(end.c_str(), static_cast<rapidjson::SizeType>(end.size()), false);
-
-      return true;
-    }
-
-    //@}
-
-    /*! @name Convenience extensions */
-    //@{
-
-    //! Simpler but slower overload.
-    bool String(const Ch *str)
-    {
-      return String(str, internal::StrLen(str));
-    }
-    bool Key(const Ch *str)
-    {
-      return Key(str, internal::StrLen(str));
-    }
-
-    //@}
-
-    //! Write a raw JSON value.
-    /*!
-        For user to write a stringified JSON as a value.
-
-        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
-        \param length Length of the json.
-        \param type Type of the root of json.
-        \note When using LatexWriter::RawValue(), the result json may not be indented correctly.
-    */
-    bool RawValue(const Ch *json, size_t length, Type /*type*/)
-    {
-      RAPIDJSON_ASSERT(json != 0);
-      return Base::EndValue(Base::WriteRawValue(json, length));
-    }
-
-  protected:
-
-    std::string get_path()
-    {
-      std::string return_path;
-      for (auto string : path)
-        {
-          return_path += "/" + string;
-        }
-      return return_path == "" ? "/" : return_path;
-    }
-
-    unsigned int itemize_open = 0;
-    std::vector<unsigned int> level_type;
-    std::vector<unsigned int> array_number;
-    bool skip_next_push_back = false;
-    bool small_array = false;
-    bool first_small_array = false;
-    bool open_new_itemize = false;
-    unsigned int section_level = 0;
-
-  private:
-    std::vector<std::string> path;
-    // Prohibit copy constructor & assignment operator.
-    LatexWriter(const LatexWriter &);
-    LatexWriter &operator=(const LatexWriter &);
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/rapidjson/memorybuffer.h.bak b/contrib/world_builder/include/rapidjson/memorybuffer.h.bak
deleted file mode 100644
index f77b612f24e..00000000000
--- a/contrib/world_builder/include/rapidjson/memorybuffer.h.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_MEMORYBUFFER_H_
-#define RAPIDJSON_MEMORYBUFFER_H_
-
-#include "stream.h"
-#include "internal/stack.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Represents an in-memory output byte stream.
-/*!
-    This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream.
-
-    It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file.
-
-    Differences between MemoryBuffer and StringBuffer:
-    1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer.
-    2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator.
-
-    \tparam Allocator type for allocating memory buffer.
-    \note implements Stream concept
-*/
-template <typename Allocator = CrtAllocator>
-struct GenericMemoryBuffer
-{
-  typedef char Ch; // byte
-
-  GenericMemoryBuffer(Allocator *allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
-
-  void Put(Ch c)
-  {
-    *stack_.template Push<Ch>() = c;
-  }
-  void Flush() {}
-
-  void Clear()
-  {
-    stack_.Clear();
-  }
-  void ShrinkToFit()
-  {
-    stack_.ShrinkToFit();
-  }
-  Ch *Push(size_t count)
-  {
-    return stack_.template Push<Ch>(count);
-  }
-  void Pop(size_t count)
-  {
-    stack_.template Pop<Ch>(count);
-  }
-
-  const Ch *GetBuffer() const
-  {
-    return stack_.template Bottom<Ch>();
-  }
-
-  size_t GetSize() const
-  {
-    return stack_.GetSize();
-  }
-
-  static const size_t kDefaultCapacity = 256;
-  mutable internal::Stack<Allocator> stack_;
-};
-
-typedef GenericMemoryBuffer<> MemoryBuffer;
-
-//! Implement specialized version of PutN() with memset() for better performance.
-template<>
-inline void PutN(MemoryBuffer &memoryBuffer, char c, size_t n)
-{
-  std::memset(memoryBuffer.stack_.Push<char>(n), c, n * sizeof(c));
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/contrib/world_builder/include/rapidjson/memorystream.h.bak b/contrib/world_builder/include/rapidjson/memorystream.h.bak
deleted file mode 100644
index 68000d9938a..00000000000
--- a/contrib/world_builder/include/rapidjson/memorystream.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_MEMORYSTREAM_H_
-#define RAPIDJSON_MEMORYSTREAM_H_
-
-#include "stream.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(unreachable-code)
-RAPIDJSON_DIAG_OFF(missing-noreturn)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Represents an in-memory input byte stream.
-/*!
-    This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream.
-
-    It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file.
-
-    Differences between MemoryStream and StringStream:
-    1. StringStream has encoding but MemoryStream is a byte stream.
-    2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source.
-    3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4().
-    \note implements Stream concept
-*/
-struct MemoryStream
-{
-  typedef char Ch; // byte
-
-  MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}
-
-  Ch Peek() const
-  {
-    return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_;
-  }
-  Ch Take()
-  {
-    return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_++;
-  }
-  size_t Tell() const
-  {
-    return static_cast<size_t>(src_ - begin_);
-  }
-
-  Ch *PutBegin()
-  {
-    RAPIDJSON_ASSERT(false);
-    return 0;
-  }
-  void Put(Ch)
-  {
-    RAPIDJSON_ASSERT(false);
-  }
-  void Flush()
-  {
-    RAPIDJSON_ASSERT(false);
-  }
-  size_t PutEnd(Ch *)
-  {
-    RAPIDJSON_ASSERT(false);
-    return 0;
-  }
-
-  // For encoding detection only.
-  const Ch *Peek4() const
-  {
-    return Tell() + 4 <= size_ ? src_ : 0;
-  }
-
-  const Ch *src_;     //!< Current read position.
-  const Ch *begin_;   //!< Original head of the string.
-  const Ch *end_;     //!< End of stream.
-  size_t size_;       //!< Size of the stream.
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/contrib/world_builder/include/rapidjson/msinttypes/inttypes.h.bak b/contrib/world_builder/include/rapidjson/msinttypes/inttypes.h.bak
deleted file mode 100644
index 502d4bfe1e0..00000000000
--- a/contrib/world_builder/include/rapidjson/msinttypes/inttypes.h.bak
+++ /dev/null
@@ -1,320 +0,0 @@
-// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
-//
-//  Copyright (c) 2006-2013 Alexander Chemeris
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-//   1. Redistributions of source code must retain the above copyright notice,
-//      this list of conditions and the following disclaimer.
-//
-//   2. Redistributions in binary form must reproduce the above copyright
-//      notice, this list of conditions and the following disclaimer in the
-//      documentation and/or other materials provided with the distribution.
-//
-//   3. Neither the name of the product nor the names of its contributors may
-//      be used to endorse or promote products derived from this software
-//      without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-// The above software in this distribution may have been modified by
-// THL A29 Limited ("Tencent Modifications").
-// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
-namespace rapidjson
-{
-#ifndef _MSC_VER // [
-#error "Use this header only with Microsoft Visual C++ compilers!"
-#endif // _MSC_VER ]
-
-#ifndef _MSC_INTTYPES_H_ // [
-#define _MSC_INTTYPES_H_
-
-#if _MSC_VER > 1000
-#pragma once
-#endif
-
-#include "stdint.h"
-
-// miloyip: VC supports inttypes.h since VC2013
-#if _MSC_VER >= 1800
-#include <inttypes.h>
-#else
-
-// 7.8 Format conversion of integer types
-
-  typedef struct
-  {
-    intmax_t quot;
-    intmax_t rem;
-  } imaxdiv_t;
-
-// 7.8.1 Macros for format specifiers
-
-#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
-
-// The fprintf macros for signed integers are:
-#define PRId8       "d"
-#define PRIi8       "i"
-#define PRIdLEAST8  "d"
-#define PRIiLEAST8  "i"
-#define PRIdFAST8   "d"
-#define PRIiFAST8   "i"
-
-#define PRId16       "hd"
-#define PRIi16       "hi"
-#define PRIdLEAST16  "hd"
-#define PRIiLEAST16  "hi"
-#define PRIdFAST16   "hd"
-#define PRIiFAST16   "hi"
-
-#define PRId32       "I32d"
-#define PRIi32       "I32i"
-#define PRIdLEAST32  "I32d"
-#define PRIiLEAST32  "I32i"
-#define PRIdFAST32   "I32d"
-#define PRIiFAST32   "I32i"
-
-#define PRId64       "I64d"
-#define PRIi64       "I64i"
-#define PRIdLEAST64  "I64d"
-#define PRIiLEAST64  "I64i"
-#define PRIdFAST64   "I64d"
-#define PRIiFAST64   "I64i"
-
-#define PRIdMAX     "I64d"
-#define PRIiMAX     "I64i"
-
-#define PRIdPTR     "Id"
-#define PRIiPTR     "Ii"
-
-// The fprintf macros for unsigned integers are:
-#define PRIo8       "o"
-#define PRIu8       "u"
-#define PRIx8       "x"
-#define PRIX8       "X"
-#define PRIoLEAST8  "o"
-#define PRIuLEAST8  "u"
-#define PRIxLEAST8  "x"
-#define PRIXLEAST8  "X"
-#define PRIoFAST8   "o"
-#define PRIuFAST8   "u"
-#define PRIxFAST8   "x"
-#define PRIXFAST8   "X"
-
-#define PRIo16       "ho"
-#define PRIu16       "hu"
-#define PRIx16       "hx"
-#define PRIX16       "hX"
-#define PRIoLEAST16  "ho"
-#define PRIuLEAST16  "hu"
-#define PRIxLEAST16  "hx"
-#define PRIXLEAST16  "hX"
-#define PRIoFAST16   "ho"
-#define PRIuFAST16   "hu"
-#define PRIxFAST16   "hx"
-#define PRIXFAST16   "hX"
-
-#define PRIo32       "I32o"
-#define PRIu32       "I32u"
-#define PRIx32       "I32x"
-#define PRIX32       "I32X"
-#define PRIoLEAST32  "I32o"
-#define PRIuLEAST32  "I32u"
-#define PRIxLEAST32  "I32x"
-#define PRIXLEAST32  "I32X"
-#define PRIoFAST32   "I32o"
-#define PRIuFAST32   "I32u"
-#define PRIxFAST32   "I32x"
-#define PRIXFAST32   "I32X"
-
-#define PRIo64       "I64o"
-#define PRIu64       "I64u"
-#define PRIx64       "I64x"
-#define PRIX64       "I64X"
-#define PRIoLEAST64  "I64o"
-#define PRIuLEAST64  "I64u"
-#define PRIxLEAST64  "I64x"
-#define PRIXLEAST64  "I64X"
-#define PRIoFAST64   "I64o"
-#define PRIuFAST64   "I64u"
-#define PRIxFAST64   "I64x"
-#define PRIXFAST64   "I64X"
-
-#define PRIoMAX     "I64o"
-#define PRIuMAX     "I64u"
-#define PRIxMAX     "I64x"
-#define PRIXMAX     "I64X"
-
-#define PRIoPTR     "Io"
-#define PRIuPTR     "Iu"
-#define PRIxPTR     "Ix"
-#define PRIXPTR     "IX"
-
-// The fscanf macros for signed integers are:
-#define SCNd8       "d"
-#define SCNi8       "i"
-#define SCNdLEAST8  "d"
-#define SCNiLEAST8  "i"
-#define SCNdFAST8   "d"
-#define SCNiFAST8   "i"
-
-#define SCNd16       "hd"
-#define SCNi16       "hi"
-#define SCNdLEAST16  "hd"
-#define SCNiLEAST16  "hi"
-#define SCNdFAST16   "hd"
-#define SCNiFAST16   "hi"
-
-#define SCNd32       "ld"
-#define SCNi32       "li"
-#define SCNdLEAST32  "ld"
-#define SCNiLEAST32  "li"
-#define SCNdFAST32   "ld"
-#define SCNiFAST32   "li"
-
-#define SCNd64       "I64d"
-#define SCNi64       "I64i"
-#define SCNdLEAST64  "I64d"
-#define SCNiLEAST64  "I64i"
-#define SCNdFAST64   "I64d"
-#define SCNiFAST64   "I64i"
-
-#define SCNdMAX     "I64d"
-#define SCNiMAX     "I64i"
-
-#ifdef _WIN64 // [
-#  define SCNdPTR     "I64d"
-#  define SCNiPTR     "I64i"
-#else  // _WIN64 ][
-#  define SCNdPTR     "ld"
-#  define SCNiPTR     "li"
-#endif  // _WIN64 ]
-
-// The fscanf macros for unsigned integers are:
-#define SCNo8       "o"
-#define SCNu8       "u"
-#define SCNx8       "x"
-#define SCNX8       "X"
-#define SCNoLEAST8  "o"
-#define SCNuLEAST8  "u"
-#define SCNxLEAST8  "x"
-#define SCNXLEAST8  "X"
-#define SCNoFAST8   "o"
-#define SCNuFAST8   "u"
-#define SCNxFAST8   "x"
-#define SCNXFAST8   "X"
-
-#define SCNo16       "ho"
-#define SCNu16       "hu"
-#define SCNx16       "hx"
-#define SCNX16       "hX"
-#define SCNoLEAST16  "ho"
-#define SCNuLEAST16  "hu"
-#define SCNxLEAST16  "hx"
-#define SCNXLEAST16  "hX"
-#define SCNoFAST16   "ho"
-#define SCNuFAST16   "hu"
-#define SCNxFAST16   "hx"
-#define SCNXFAST16   "hX"
-
-#define SCNo32       "lo"
-#define SCNu32       "lu"
-#define SCNx32       "lx"
-#define SCNX32       "lX"
-#define SCNoLEAST32  "lo"
-#define SCNuLEAST32  "lu"
-#define SCNxLEAST32  "lx"
-#define SCNXLEAST32  "lX"
-#define SCNoFAST32   "lo"
-#define SCNuFAST32   "lu"
-#define SCNxFAST32   "lx"
-#define SCNXFAST32   "lX"
-
-#define SCNo64       "I64o"
-#define SCNu64       "I64u"
-#define SCNx64       "I64x"
-#define SCNX64       "I64X"
-#define SCNoLEAST64  "I64o"
-#define SCNuLEAST64  "I64u"
-#define SCNxLEAST64  "I64x"
-#define SCNXLEAST64  "I64X"
-#define SCNoFAST64   "I64o"
-#define SCNuFAST64   "I64u"
-#define SCNxFAST64   "I64x"
-#define SCNXFAST64   "I64X"
-
-#define SCNoMAX     "I64o"
-#define SCNuMAX     "I64u"
-#define SCNxMAX     "I64x"
-#define SCNXMAX     "I64X"
-
-#ifdef _WIN64 // [
-#  define SCNoPTR     "I64o"
-#  define SCNuPTR     "I64u"
-#  define SCNxPTR     "I64x"
-#  define SCNXPTR     "I64X"
-#else  // _WIN64 ][
-#  define SCNoPTR     "lo"
-#  define SCNuPTR     "lu"
-#  define SCNxPTR     "lx"
-#  define SCNXPTR     "lX"
-#endif  // _WIN64 ]
-
-#endif // __STDC_FORMAT_MACROS ]
-
-// 7.8.2 Functions for greatest-width integer types
-
-// 7.8.2.1 The imaxabs function
-#define imaxabs _abs64
-
-// 7.8.2.2 The imaxdiv function
-
-// This is modified version of div() function from Microsoft's div.c found
-// in %MSVC.NET%\crt\src\div.c
-#ifdef STATIC_IMAXDIV // [
-  static
-#else // STATIC_IMAXDIV ][
-  _inline
-#endif // STATIC_IMAXDIV ]
-  imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
-  {
-    imaxdiv_t result;
-
-    result.quot = numer / denom;
-    result.rem = numer % denom;
-
-    if (numer < 0 && result.rem > 0)
-      {
-        // did division wrong; must fix up
-        ++result.quot;
-        result.rem -= denom;
-      }
-
-    return result;
-  }
-
-// 7.8.2.3 The strtoimax and strtoumax functions
-#define strtoimax _strtoi64
-#define strtoumax _strtoui64
-
-// 7.8.2.4 The wcstoimax and wcstoumax functions
-#define wcstoimax _wcstoi64
-#define wcstoumax _wcstoui64
-
-#endif // _MSC_VER >= 1800
-
-#endif // _MSC_INTTYPES_H_ ]
-}
\ No newline at end of file
diff --git a/contrib/world_builder/include/rapidjson/msinttypes/stdint.h.bak b/contrib/world_builder/include/rapidjson/msinttypes/stdint.h.bak
deleted file mode 100644
index 421edf64459..00000000000
--- a/contrib/world_builder/include/rapidjson/msinttypes/stdint.h.bak
+++ /dev/null
@@ -1,300 +0,0 @@
-// ISO C9x  compliant stdint.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
-//
-//  Copyright (c) 2006-2013 Alexander Chemeris
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-//   1. Redistributions of source code must retain the above copyright notice,
-//      this list of conditions and the following disclaimer.
-//
-//   2. Redistributions in binary form must reproduce the above copyright
-//      notice, this list of conditions and the following disclaimer in the
-//      documentation and/or other materials provided with the distribution.
-//
-//   3. Neither the name of the product nor the names of its contributors may
-//      be used to endorse or promote products derived from this software
-//      without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-// The above software in this distribution may have been modified by
-// THL A29 Limited ("Tencent Modifications").
-// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
-
-#ifndef _MSC_VER // [
-#error "Use this header only with Microsoft Visual C++ compilers!"
-#endif // _MSC_VER ]
-
-#ifndef _MSC_STDINT_H_ // [
-#define _MSC_STDINT_H_
-
-#if _MSC_VER > 1000
-#pragma once
-#endif
-
-// miloyip: Originally Visual Studio 2010 uses its own stdint.h. However it generates warning with INT64_C(), so change to use this file for vs2010.
-#if _MSC_VER >= 1600 // [
-#include <stdint.h>
-
-#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
-
-#undef INT8_C
-#undef INT16_C
-#undef INT32_C
-#undef INT64_C
-#undef UINT8_C
-#undef UINT16_C
-#undef UINT32_C
-#undef UINT64_C
-
-// 7.18.4.1 Macros for minimum-width integer constants
-
-#define INT8_C(val)  val##i8
-#define INT16_C(val) val##i16
-#define INT32_C(val) val##i32
-#define INT64_C(val) val##i64
-
-#define UINT8_C(val)  val##ui8
-#define UINT16_C(val) val##ui16
-#define UINT32_C(val) val##ui32
-#define UINT64_C(val) val##ui64
-
-// 7.18.4.2 Macros for greatest-width integer constants
-// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
-// Check out Issue 9 for the details.
-#ifndef INTMAX_C //   [
-#  define INTMAX_C   INT64_C
-#endif // INTMAX_C    ]
-#ifndef UINTMAX_C //  [
-#  define UINTMAX_C  UINT64_C
-#endif // UINTMAX_C   ]
-
-#endif // __STDC_CONSTANT_MACROS ]
-
-#else // ] _MSC_VER >= 1700 [
-
-#include <limits.h>
-
-// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
-// compiling for ARM we have to wrap <wchar.h> include with 'extern "C++" {}'
-// or compiler would give many errors like this:
-//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
-#if defined(__cplusplus) && !defined(_M_ARM)
-extern "C" {
-#endif
-#  include <wchar.h>
-#if defined(__cplusplus) && !defined(_M_ARM)
-}
-#endif
-
-// Define _W64 macros to mark types changing their size, like intptr_t.
-#ifndef _W64
-#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
-#     define _W64 __w64
-#  else
-#     define _W64
-#  endif
-#endif
-
-
-// 7.18.1 Integer types
-
-// 7.18.1.1 Exact-width integer types
-
-// Visual Studio 6 and Embedded Visual C++ 4 doesn't
-// realize that, e.g. char has the same size as __int8
-// so we give up on __intX for them.
-#if (_MSC_VER < 1300)
-typedef signed char       int8_t;
-typedef signed short      int16_t;
-typedef signed int        int32_t;
-typedef unsigned char     uint8_t;
-typedef unsigned short    uint16_t;
-typedef unsigned int      uint32_t;
-#else
-typedef signed __int8     int8_t;
-typedef signed __int16    int16_t;
-typedef signed __int32    int32_t;
-typedef unsigned __int8   uint8_t;
-typedef unsigned __int16  uint16_t;
-typedef unsigned __int32  uint32_t;
-#endif
-typedef signed __int64       int64_t;
-typedef unsigned __int64     uint64_t;
-
-
-// 7.18.1.2 Minimum-width integer types
-typedef int8_t    int_least8_t;
-typedef int16_t   int_least16_t;
-typedef int32_t   int_least32_t;
-typedef int64_t   int_least64_t;
-typedef uint8_t   uint_least8_t;
-typedef uint16_t  uint_least16_t;
-typedef uint32_t  uint_least32_t;
-typedef uint64_t  uint_least64_t;
-
-// 7.18.1.3 Fastest minimum-width integer types
-typedef int8_t    int_fast8_t;
-typedef int16_t   int_fast16_t;
-typedef int32_t   int_fast32_t;
-typedef int64_t   int_fast64_t;
-typedef uint8_t   uint_fast8_t;
-typedef uint16_t  uint_fast16_t;
-typedef uint32_t  uint_fast32_t;
-typedef uint64_t  uint_fast64_t;
-
-// 7.18.1.4 Integer types capable of holding object pointers
-#ifdef _WIN64 // [
-typedef signed __int64    intptr_t;
-typedef unsigned __int64  uintptr_t;
-#else // _WIN64 ][
-typedef _W64 signed int   intptr_t;
-typedef _W64 unsigned int uintptr_t;
-#endif // _WIN64 ]
-
-// 7.18.1.5 Greatest-width integer types
-typedef int64_t   intmax_t;
-typedef uint64_t  uintmax_t;
-
-
-// 7.18.2 Limits of specified-width integer types
-
-#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
-
-// 7.18.2.1 Limits of exact-width integer types
-#define INT8_MIN     ((int8_t)_I8_MIN)
-#define INT8_MAX     _I8_MAX
-#define INT16_MIN    ((int16_t)_I16_MIN)
-#define INT16_MAX    _I16_MAX
-#define INT32_MIN    ((int32_t)_I32_MIN)
-#define INT32_MAX    _I32_MAX
-#define INT64_MIN    ((int64_t)_I64_MIN)
-#define INT64_MAX    _I64_MAX
-#define UINT8_MAX    _UI8_MAX
-#define UINT16_MAX   _UI16_MAX
-#define UINT32_MAX   _UI32_MAX
-#define UINT64_MAX   _UI64_MAX
-
-// 7.18.2.2 Limits of minimum-width integer types
-#define INT_LEAST8_MIN    INT8_MIN
-#define INT_LEAST8_MAX    INT8_MAX
-#define INT_LEAST16_MIN   INT16_MIN
-#define INT_LEAST16_MAX   INT16_MAX
-#define INT_LEAST32_MIN   INT32_MIN
-#define INT_LEAST32_MAX   INT32_MAX
-#define INT_LEAST64_MIN   INT64_MIN
-#define INT_LEAST64_MAX   INT64_MAX
-#define UINT_LEAST8_MAX   UINT8_MAX
-#define UINT_LEAST16_MAX  UINT16_MAX
-#define UINT_LEAST32_MAX  UINT32_MAX
-#define UINT_LEAST64_MAX  UINT64_MAX
-
-// 7.18.2.3 Limits of fastest minimum-width integer types
-#define INT_FAST8_MIN    INT8_MIN
-#define INT_FAST8_MAX    INT8_MAX
-#define INT_FAST16_MIN   INT16_MIN
-#define INT_FAST16_MAX   INT16_MAX
-#define INT_FAST32_MIN   INT32_MIN
-#define INT_FAST32_MAX   INT32_MAX
-#define INT_FAST64_MIN   INT64_MIN
-#define INT_FAST64_MAX   INT64_MAX
-#define UINT_FAST8_MAX   UINT8_MAX
-#define UINT_FAST16_MAX  UINT16_MAX
-#define UINT_FAST32_MAX  UINT32_MAX
-#define UINT_FAST64_MAX  UINT64_MAX
-
-// 7.18.2.4 Limits of integer types capable of holding object pointers
-#ifdef _WIN64 // [
-#  define INTPTR_MIN   INT64_MIN
-#  define INTPTR_MAX   INT64_MAX
-#  define UINTPTR_MAX  UINT64_MAX
-#else // _WIN64 ][
-#  define INTPTR_MIN   INT32_MIN
-#  define INTPTR_MAX   INT32_MAX
-#  define UINTPTR_MAX  UINT32_MAX
-#endif // _WIN64 ]
-
-// 7.18.2.5 Limits of greatest-width integer types
-#define INTMAX_MIN   INT64_MIN
-#define INTMAX_MAX   INT64_MAX
-#define UINTMAX_MAX  UINT64_MAX
-
-// 7.18.3 Limits of other integer types
-
-#ifdef _WIN64 // [
-#  define PTRDIFF_MIN  _I64_MIN
-#  define PTRDIFF_MAX  _I64_MAX
-#else  // _WIN64 ][
-#  define PTRDIFF_MIN  _I32_MIN
-#  define PTRDIFF_MAX  _I32_MAX
-#endif  // _WIN64 ]
-
-#define SIG_ATOMIC_MIN  INT_MIN
-#define SIG_ATOMIC_MAX  INT_MAX
-
-#ifndef SIZE_MAX // [
-#  ifdef _WIN64 // [
-#     define SIZE_MAX  _UI64_MAX
-#  else // _WIN64 ][
-#     define SIZE_MAX  _UI32_MAX
-#  endif // _WIN64 ]
-#endif // SIZE_MAX ]
-
-// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
-#ifndef WCHAR_MIN // [
-#  define WCHAR_MIN  0
-#endif  // WCHAR_MIN ]
-#ifndef WCHAR_MAX // [
-#  define WCHAR_MAX  _UI16_MAX
-#endif  // WCHAR_MAX ]
-
-#define WINT_MIN  0
-#define WINT_MAX  _UI16_MAX
-
-#endif // __STDC_LIMIT_MACROS ]
-
-
-// 7.18.4 Limits of other integer types
-
-#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
-
-// 7.18.4.1 Macros for minimum-width integer constants
-
-#define INT8_C(val)  val##i8
-#define INT16_C(val) val##i16
-#define INT32_C(val) val##i32
-#define INT64_C(val) val##i64
-
-#define UINT8_C(val)  val##ui8
-#define UINT16_C(val) val##ui16
-#define UINT32_C(val) val##ui32
-#define UINT64_C(val) val##ui64
-
-// 7.18.4.2 Macros for greatest-width integer constants
-// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
-// Check out Issue 9 for the details.
-#ifndef INTMAX_C //   [
-#  define INTMAX_C   INT64_C
-#endif // INTMAX_C    ]
-#ifndef UINTMAX_C //  [
-#  define UINTMAX_C  UINT64_C
-#endif // UINTMAX_C   ]
-
-#endif // __STDC_CONSTANT_MACROS ]
-
-#endif // _MSC_VER >= 1600 ]
-
-#endif // _MSC_STDINT_H_ ]
diff --git a/contrib/world_builder/include/rapidjson/mystwriter.h.bak b/contrib/world_builder/include/rapidjson/mystwriter.h.bak
deleted file mode 100644
index b684ddaf12b..00000000000
--- a/contrib/world_builder/include/rapidjson/mystwriter.h.bak
+++ /dev/null
@@ -1,528 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_MYSTWRITER_H_
-#define RAPIDJSON_MYSTWRITER_H_
-
-#include "writer.h"
-
-#include "assert.h"
-
-#include <algorithm>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-#define MAX_PATH_LEVEL 25
-
-//! Writer with indentation and spacing.
-/*!
-    \tparam OutputStream Type of output os.
-    \tparam SourceEncoding Encoding of source string.
-    \tparam TargetEncoding Encoding of output stream.
-    \tparam StackAllocator Type of allocator for allocating memory of stack.
-*/
-template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
-class MySTWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags>
-{
-  public:
-    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base;
-    typedef typename Base::Ch Ch;
-
-    //! Constructor
-    /*! \param os Output stream.
-        \param allocator User supplied allocator. If it is null, it will create a private one.
-        \param levelDepth Initial capacity of stack.
-    */
-    explicit MySTWriter(OutputStream &os, bool _make_open = false, StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
-      Base(os, allocator, levelDepth)
-    {
-      make_open = _make_open;
-      level_type.resize(0);
-      array_number.resize(0);
-      path.resize(0);
-    }
-
-
-    explicit MySTWriter(StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
-      Base(allocator, levelDepth)
-    {
-      level_type.resize(0);
-      array_number.resize(0);
-      path.resize(0);
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    MySTWriter(MySTWriter &&rhs) :
-      Base(std::forward<MySTWriter>(rhs))
-    {
-      level_type.resize(0);
-      array_number.resize(0);
-      path.resize(0);
-    }
-#endif
-
-    /*! @name Implementation of Handler
-        \see Handler
-    */
-    //@{
-
-    bool Null()
-    {
-      return Base::EndValue(Base::WriteNull());
-    }
-    bool Bool(bool b)
-    {
-      Base::EndValue(Base::WriteBool(b));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Int(int i)
-    {
-      Base::EndValue(Base::WriteInt(i));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Uint(unsigned u)
-    {
-      Base::EndValue(Base::WriteUint(u));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Int64(int64_t i64)
-    {
-      Base::EndValue(Base::WriteInt64(i64));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Uint64(uint64_t u64)
-    {
-      Base::EndValue(Base::WriteUint64(u64));
-      Base::os_->Put('\n');
-      return true;
-    }
-    bool Double(double d)
-    {
-      Base::EndValue(Base::WriteDouble(d));
-      Base::os_->Put('\n');
-      return true;
-    }
-
-    bool RawNumber(const Ch *str, SizeType length, bool /*copy = false*/)
-    {
-      RAPIDJSON_ASSERT(str != 0);
-      Base::EndValue(Base::WriteString(str, length, false));
-      Base::os_->Put('\n');
-      return true;
-    }
-
-    bool String(const Ch *str, SizeType length, bool /*copy = false*/)
-    {
-      RAPIDJSON_ASSERT(str != 0);
-      if (small_array == true)
-        {
-          if (first_small_array == true)
-            first_small_array = false;
-          else
-            {
-              Base::os_->Put(',');
-              Base::os_->Put(' ');
-            }
-        }
-      Base::EndValue(Base::WriteString(str, length, false));
-
-      if (small_array == false)
-        Base::os_->Put('\n');
-      return true;
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool String(const std::basic_string<Ch> &str)
-    {
-      return String(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool StartObject()
-    {
-      bool wrote_dropdown = false;
-      std::string begin = "";
-      if (level_type.size() != 0 && level_type.back() == 1)
-        {
-          // this is a properties starting, so first clear all the itemize
-          // the lvel_type.push_back(1) has already been done by the key: properties
-
-          if (skip_next_push_back == false)
-            {
-              for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
-                {
-                  begin += ":";
-                }
-              begin += "{dropdown} " + get_path();
-
-              wrote_dropdown =  true;
-              level_type.push_back(0);
-            }
-          else
-            {
-              skip_next_push_back = false;
-            }
-        }
-      else if (level_type.size() != 0 && level_type.back() == 2)
-        {
-          unsigned int number = array_number.back() + 1;
-          array_number.back() = number;
-          path.push_back(std::to_string(array_number.back()));
-          level_type.push_back(0);
-
-          for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
-            {
-              begin += ":";
-            }
-          begin += "{dropdown} " + get_path();
-
-
-          wrote_dropdown =  true;
-        }
-      else if (level_type.size() != 0 && level_type.back() == 5)
-        {
-          unsigned int number = array_number.back() + 1;
-          array_number.back() = number;
-          path.push_back(std::to_string(array_number.back()));
-          level_type.push_back(0);
-
-          for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
-            {
-              begin += ":";
-            }
-          begin += "{dropdown} " + get_path();
-
-
-          wrote_dropdown =  true;
-        }
-      else
-        {
-          for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
-            {
-              begin += ":";
-            }
-          begin += "{dropdown} " + get_path();
-
-
-          wrote_dropdown =  true;
-          if (level_type.size() > 0 && (level_type.back() != 3 || level_type.size() == 0))
-            level_type.push_back(0);
-        }
-
-      Base::WriteString(begin.c_str(), static_cast<rapidjson::SizeType>(begin.size()), false);
-
-      Base::os_->Put('\n');
-      if (level_type.size() == 0 && !make_open)
-        {
-          std::string string_open = ":open:";
-          Base::WriteString(string_open.c_str(), static_cast<rapidjson::SizeType>(string_open.size()), false);
-          Base::os_->Put('\n');
-        }
-
-      if (wrote_dropdown)
-        {
-          if (make_open)
-            {
-              std::string open = ":open:";
-              Base::WriteString(open.c_str(), static_cast<rapidjson::SizeType>(open.size()), false);
-              Base::os_->Put('\n');
-              std::string name = ":name: open" + get_path_underscore() + "";
-              Base::WriteString(name.c_str(), static_cast<rapidjson::SizeType>(name.size()), false);
-              Base::os_->Put('\n');
-              Base::os_->Put('\n');
-            }
-          else
-            {
-              std::string name = ":name: closed" + get_path_underscore() + "";
-              Base::WriteString(name.c_str(), static_cast<rapidjson::SizeType>(name.size()), false);
-              Base::os_->Put('\n');
-              Base::os_->Put('\n');
-            }
-        }
-
-      return true;
-    }
-
-    bool Key(const Ch *str, SizeType /*length*/, bool /*copy = false*/)
-    {
-      std::string item = "";
-
-
-      std::string key(str);
-      if (key == "properties")
-        {
-          level_type.push_back(1);
-          skip_next_push_back = true;
-        }
-      else if (key == "oneOf")
-        {
-          level_type.push_back(2);
-          path.push_back(key);
-        }
-      else if (key == "items")
-        {
-          level_type.push_back(3);
-          path.push_back(key);
-        }
-      else if (key == "enum" || key == "required" )
-        {
-          level_type.push_back(4);
-          item += "- **" + std::string(str) + "**:";
-        }
-      else if (key == "anyOf")
-        {
-          level_type.push_back(5);
-          path.push_back(key);
-        }
-      else if (level_type.size() > 0 && (level_type.back() == 1 || level_type.back() == 2 || level_type.back() == 5))
-        {
-          // the level just below properties, these are the sections
-          // add to the path
-          path.push_back(key);
-        }
-      else
-        {
-          item += "- **" + std::string(str) + "**:";
-        }
-
-      Base::WriteString(item.c_str(), static_cast<rapidjson::SizeType>(item.length()), false);
-
-      return true;
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool Key(const std::basic_string<Ch> &str)
-    {
-      return Key(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool EndObject(SizeType /*memberCount = 0*/)
-    {
-      std::string end = "";
-
-      // If this assert fails it could be an indicator that
-      // the world builder library is not fuly linked to the
-      // appllication.
-
-      if (level_type.size() > 0 && path.size() > 0 &&
-          ( level_type.back() == 3 || level_type.back() == 0))
-        {
-
-          for (size_t level =MAX_PATH_LEVEL-path.size(); level != 0; level--)
-            {
-              WBAssert(path.size() < MAX_PATH_LEVEL, "EA: path size is larger than 90: " << path.size() << ", level = " << level);
-              end += ':';
-            }
-
-          path.pop_back();
-        }
-
-      if (level_type.size() > 0)
-        {
-          level_type.pop_back();
-        }
-
-      Base::WriteString(end.c_str(), static_cast<rapidjson::SizeType>(end.length()), false);
-
-      Base::os_->Put('\n');
-      Base::os_->Put('\n');
-      return true;
-    }
-
-    bool StartArray()
-    {
-      bool wrote_dropdown = false;
-      std::string begin = "";
-      if (level_type.size() != 0 && (level_type.back() == 2|| level_type.back() == 3|| level_type.back() == 5 ))
-        {
-          //begin += "level type" + std::to_string(level_type.back());
-          // this is a properties starting, so first clear all the itemize
-          // the lvel_type.push_back(1) has already been done by the key: properties
-
-          for (size_t level = MAX_PATH_LEVEL-path.size(); level != 0; level--)
-            {
-              WBAssert(path.size() < MAX_PATH_LEVEL, "SA: path size is larger than 90: " << path.size() << ", level = " << level);
-              begin += ":";
-            }
-          begin += "{dropdown} " + get_path();
-
-          wrote_dropdown = true;
-          array_number.push_back(0);
-        }
-      else
-        {
-          begin += "[";
-          small_array = true;
-          first_small_array = true;
-        }
-
-      Base::WriteString(begin.c_str(), static_cast<rapidjson::SizeType>(begin.size()), false);
-
-      if (small_array == false)
-        Base::os_->Put('\n');
-
-
-      if (wrote_dropdown)
-        {
-          if (make_open)
-            {
-              std::string open = ":open:";
-              Base::WriteString(open.c_str(), static_cast<rapidjson::SizeType>(open.size()), false);
-              Base::os_->Put('\n');
-              std::string name = ":name: open" + get_path_underscore() + "";
-              Base::WriteString(name.c_str(), static_cast<rapidjson::SizeType>(name.size()), false);
-              Base::os_->Put('\n');
-              Base::os_->Put('\n');
-            }
-          else
-            {
-              std::string name = ":name: closed" + get_path_underscore() + "";
-              Base::WriteString(name.c_str(), static_cast<rapidjson::SizeType>(name.size()), false);
-              Base::os_->Put('\n');
-              Base::os_->Put('\n');
-            }
-        }
-      return true;
-    }
-
-    bool EndArray(SizeType /*memberCount = 0*/)
-    {
-      std::string end = "";
-      if (level_type.size() != 0 && (level_type.back() == 1 || level_type.back() == 2 || level_type.back() == 3 || level_type.back() == 5))
-        {
-          array_number.pop_back();
-          level_type.pop_back();
-
-          if (path.size() > 0)
-            path.pop_back();
-        }
-      else
-        {
-
-          end = "]";
-
-          small_array = false;
-
-          if (level_type.size() > 0 && (level_type.back() == 4))// || level_type.back() == 0))
-            {
-              level_type.pop_back();
-            }
-        }
-
-      Base::WriteString(end.c_str(), static_cast<rapidjson::SizeType>(end.size()), false);
-
-      Base::os_->Put('\n');
-      return true;
-    }
-
-    //@}
-
-    /*! @name Convenience extensions */
-    //@{
-
-    //! Simpler but slower overload.
-    bool String(const Ch *str)
-    {
-      return String(str, internal::StrLen(str));
-    }
-    bool Key(const Ch *str)
-    {
-      return Key(str, internal::StrLen(str));
-    }
-
-    //@}
-
-    //! Write a raw JSON value.
-    /*!
-        For user to write a stringified JSON as a value.
-
-        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
-        \param length Length of the json.
-        \param type Type of the root of json.
-        \note When using MySTWriter::RawValue(), the result json may not be indented correctly.
-    */
-    bool RawValue(const Ch *json, size_t length, Type /*type*/)
-    {
-      RAPIDJSON_ASSERT(json != 0);
-      return Base::EndValue(Base::WriteRawValue(json, length));
-    }
-
-  protected:
-
-    std::string get_path()
-    {
-      std::string return_path;
-      for (auto string : path)
-        {
-          return_path += "/" + string;
-        }
-      return return_path == "" ? "/" : return_path;
-    }
-
-    std::string get_path_underscore()
-    {
-      std::string return_path;
-      for (auto string : path)
-        {
-          return_path += "_" + string;
-        }
-      const char space  = ' ';
-      const char dash = '-';
-      std::replace(return_path.begin(), return_path.end(), space, dash);
-      return return_path == "" ? "_" : return_path;
-    }
-
-    std::vector<unsigned int> level_type;
-    std::vector<unsigned int> array_number;
-    bool make_open = false;
-    bool skip_next_push_back = false;
-    bool small_array = false;
-    bool first_small_array = false;
-
-  private:
-    std::vector<std::string> path;
-    // Prohibit copy constructor & assignment operator.
-    MySTWriter(const MySTWriter &);
-    MySTWriter &operator=(const MySTWriter &);
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/rapidjson/ostreamwrapper.h.bak b/contrib/world_builder/include/rapidjson/ostreamwrapper.h.bak
deleted file mode 100644
index 70cb06ba940..00000000000
--- a/contrib/world_builder/include/rapidjson/ostreamwrapper.h.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_OSTREAMWRAPPER_H_
-#define RAPIDJSON_OSTREAMWRAPPER_H_
-
-#include "stream.h"
-#include <iosfwd>
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Wrapper of \c std::basic_ostream into RapidJSON's Stream concept.
-/*!
-    The classes can be wrapped including but not limited to:
-
-    - \c std::ostringstream
-    - \c std::stringstream
-    - \c std::wpstringstream
-    - \c std::wstringstream
-    - \c std::ifstream
-    - \c std::fstream
-    - \c std::wofstream
-    - \c std::wfstream
-
-    \tparam StreamType Class derived from \c std::basic_ostream.
-*/
-
-template <typename StreamType>
-class BasicOStreamWrapper
-{
-  public:
-    typedef typename StreamType::char_type Ch;
-    BasicOStreamWrapper(StreamType &stream) : stream_(stream) {}
-
-    void Put(Ch c)
-    {
-      stream_.put(c);
-    }
-
-    void Flush()
-    {
-      stream_.flush();
-    }
-
-    // Not implemented
-    char Peek() const
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    char Take()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t Tell() const
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    char *PutBegin()
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-    size_t PutEnd(char *)
-    {
-      RAPIDJSON_ASSERT(false);
-      return 0;
-    }
-
-  private:
-    BasicOStreamWrapper(const BasicOStreamWrapper &);
-    BasicOStreamWrapper &operator=(const BasicOStreamWrapper &);
-
-    StreamType &stream_;
-};
-
-typedef BasicOStreamWrapper<std::ostream> OStreamWrapper;
-typedef BasicOStreamWrapper<std::wostream> WOStreamWrapper;
-
-#ifdef __clang__
-RAPIDJSON_DIAG_POP
-#endif
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_OSTREAMWRAPPER_H_
diff --git a/contrib/world_builder/include/rapidjson/pointer.h.bak b/contrib/world_builder/include/rapidjson/pointer.h.bak
deleted file mode 100644
index f2dee09185e..00000000000
--- a/contrib/world_builder/include/rapidjson/pointer.h.bak
+++ /dev/null
@@ -1,1532 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_POINTER_H_
-#define RAPIDJSON_POINTER_H_
-
-#include "document.h"
-#include "internal/itoa.h"
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-//RAPIDJSON_DIAG_OFF(switch -enum)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-static const SizeType kPointerInvalidIndex = ~SizeType(0);  //!< Represents an invalid index in GenericPointer::Token
-
-//! Error code of parsing.
-/*! \ingroup RAPIDJSON_ERRORS
-    \see GenericPointer::GenericPointer, GenericPointer::GetParseErrorCode
-*/
-enum PointerParseErrorCode
-{
-  kPointerParseErrorNone = 0,                     //!< The parse is successful
-
-  kPointerParseErrorTokenMustBeginWithSolidus,    //!< A token must begin with a '/'
-  kPointerParseErrorInvalidEscape,                //!< Invalid escape
-  kPointerParseErrorInvalidPercentEncoding,       //!< Invalid percent encoding in URI fragment
-  kPointerParseErrorCharacterMustPercentEncode    //!< A character must percent encoded in URI fragment
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericPointer
-
-//! Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
-/*!
-    This class implements RFC 6901 "JavaScript Object Notation (JSON) Pointer"
-    (https://tools.ietf.org/html/rfc6901).
-
-    A JSON pointer is for identifying a specific value in a JSON document
-    (GenericDocument). It can simplify coding of DOM tree manipulation, because it
-    can access multiple-level depth of DOM tree with single API call.
-
-    After it parses a string representation (e.g. "/foo/0" or URI fragment
-    representation (e.g. "#/foo/0") into its internal representation (tokens),
-    it can be used to resolve a specific value in multiple documents, or sub-tree
-    of documents.
-
-    Contrary to GenericValue, Pointer can be copy constructed and copy assigned.
-    Apart from assignment, a Pointer cannot be modified after construction.
-
-    Although Pointer is very convenient, please aware that constructing Pointer
-    involves parsing and dynamic memory allocation. A special constructor with user-
-    supplied tokens eliminates these.
-
-    GenericPointer depends on GenericDocument and GenericValue.
-
-    \tparam ValueType The value type of the DOM tree. E.g. GenericValue<UTF8<> >
-    \tparam Allocator The allocator type for allocating memory for internal representation.
-
-    \note GenericPointer uses same encoding of ValueType.
-    However, Allocator of GenericPointer is independent of Allocator of Value.
-*/
-template <typename ValueType, typename Allocator = CrtAllocator>
-class GenericPointer
-{
-  public:
-    typedef typename ValueType::EncodingType EncodingType;  //!< Encoding type from Value
-    typedef typename ValueType::Ch Ch;                      //!< Character type from Value
-
-    //! A token is the basic units of internal representation.
-    /*!
-        A JSON pointer string representation "/foo/123" is parsed to two tokens:
-        "foo" and 123. 123 will be represented in both numeric form and string form.
-        They are resolved according to the actual value type (object or array).
-
-        For token that are not numbers, or the numeric value is out of bound
-        (greater than limits of SizeType), they are only treated as string form
-        (i.e. the token's index will be equal to kPointerInvalidIndex).
-
-        This struct is public so that user can create a Pointer without parsing and
-        allocation, using a special constructor.
-    */
-    struct Token
-    {
-      const Ch *name;             //!< Name of the token. It has null character at the end but it can contain null character.
-      SizeType length;            //!< Length of the name.
-      SizeType index;             //!< A valid array index, if it is not equal to kPointerInvalidIndex.
-    };
-
-    //!@name Constructors and destructor.
-    //@{
-
-    //! Default constructor.
-    GenericPointer(Allocator *allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
-
-    //! Constructor that parses a string or URI fragment representation.
-    /*!
-        \param source A null-terminated, string or URI fragment representation of JSON pointer.
-        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
-    */
-    explicit GenericPointer(const Ch *source, Allocator *allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
-    {
-      Parse(source, internal::StrLen(source));
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Constructor that parses a string or URI fragment representation.
-    /*!
-        \param source A string or URI fragment representation of JSON pointer.
-        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
-        \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-    */
-    explicit GenericPointer(const std::basic_string<Ch> &source, Allocator *allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
-    {
-      Parse(source.c_str(), source.size());
-    }
-#endif
-
-    //! Constructor that parses a string or URI fragment representation, with length of the source string.
-    /*!
-        \param source A string or URI fragment representation of JSON pointer.
-        \param length Length of source.
-        \param allocator User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.
-        \note Slightly faster than the overload without length.
-    */
-    GenericPointer(const Ch *source, size_t length, Allocator *allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
-    {
-      Parse(source, length);
-    }
-
-    //! Constructor with user-supplied tokens.
-    /*!
-        This constructor let user supplies const array of tokens.
-        This prevents the parsing process and eliminates allocation.
-        This is preferred for memory constrained environments.
-
-        \param tokens An constant array of tokens representing the JSON pointer.
-        \param tokenCount Number of tokens.
-
-        \b Example
-        \code
-        #define NAME(s) { s, sizeof(s) / sizeof(s[0]) - 1, kPointerInvalidIndex }
-        #define INDEX(i) { #i, sizeof(#i) - 1, i }
-
-        static const Pointer::Token kTokens[] = { NAME("foo"), INDEX(123) };
-        static const Pointer p(kTokens, sizeof(kTokens) / sizeof(kTokens[0]));
-        // Equivalent to static const Pointer p("/foo/123");
-
-        #undef NAME
-        #undef INDEX
-        \endcode
-    */
-    GenericPointer(const Token *tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token *>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
-
-    //! Copy constructor.
-    GenericPointer(const GenericPointer &rhs) : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
-    {
-      *this = rhs;
-    }
-
-    //! Copy constructor.
-    GenericPointer(const GenericPointer &rhs, Allocator *allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone)
-    {
-      *this = rhs;
-    }
-
-    //! Destructor.
-    ~GenericPointer()
-    {
-      if (nameBuffer_)    // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated.
-        Allocator::Free(tokens_);
-      RAPIDJSON_DELETE(ownAllocator_);
-    }
-
-    //! Assignment operator.
-    GenericPointer &operator=(const GenericPointer &rhs)
-    {
-      if (this != &rhs)
-        {
-          // Do not delete ownAllcator
-          if (nameBuffer_)
-            Allocator::Free(tokens_);
-
-          tokenCount_ = rhs.tokenCount_;
-          parseErrorOffset_ = rhs.parseErrorOffset_;
-          parseErrorCode_ = rhs.parseErrorCode_;
-
-          if (rhs.nameBuffer_)
-            CopyFromRaw(rhs); // Normally parsed tokens.
-          else
-            {
-              tokens_ = rhs.tokens_; // User supplied const tokens.
-              nameBuffer_ = 0;
-            }
-        }
-      return *this;
-    }
-
-    //@}
-
-    //!@name Append token
-    //@{
-
-    //! Append a token and return a new Pointer
-    /*!
-        \param token Token to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(const Token &token, Allocator *allocator = 0) const
-    {
-      GenericPointer r;
-      r.allocator_ = allocator;
-      Ch *p = r.CopyFromRaw(*this, 1, token.length + 1);
-      std::memcpy(p, token.name, (token.length + 1) * sizeof(Ch));
-      r.tokens_[tokenCount_].name = p;
-      r.tokens_[tokenCount_].length = token.length;
-      r.tokens_[tokenCount_].index = token.index;
-      return r;
-    }
-
-    //! Append a name token with length, and return a new Pointer
-    /*!
-        \param name Name to be appended.
-        \param length Length of name.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(const Ch *name, SizeType length, Allocator *allocator = 0) const
-    {
-      Token token = { name, length, kPointerInvalidIndex };
-      return Append(token, allocator);
-    }
-
-    //! Append a name token without length, and return a new Pointer
-    /*!
-        \param name Name (const Ch*) to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >), (GenericPointer))
-    Append(T *name, Allocator *allocator = 0) const
-    {
-      return Append(name, internal::StrLen(name), allocator);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Append a name token, and return a new Pointer
-    /*!
-        \param name Name to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(const std::basic_string<Ch> &name, Allocator *allocator = 0) const
-    {
-      return Append(name.c_str(), static_cast<SizeType>(name.size()), allocator);
-    }
-#endif
-
-    //! Append a index token, and return a new Pointer
-    /*!
-        \param index Index to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(SizeType index, Allocator *allocator = 0) const
-    {
-      char buffer[21];
-      char *end = sizeof(SizeType) == 4 ? internal::u32toa(index, buffer) : internal::u64toa(index, buffer);
-      SizeType length = static_cast<SizeType>(end - buffer);
-      buffer[length] = '\0';
-
-      if (sizeof(Ch) == 1)
-        {
-          Token token = { reinterpret_cast<Ch *>(buffer), length, index };
-          return Append(token, allocator);
-        }
-      else
-        {
-          Ch name[21];
-          for (size_t i = 0; i <= length; i++)
-            name[i] = static_cast<Ch>(buffer[i]);
-          Token token = { name, length, index };
-          return Append(token, allocator);
-        }
-    }
-
-    //! Append a token by value, and return a new Pointer
-    /*!
-        \param token token to be appended.
-        \param allocator Allocator for the newly return Pointer.
-        \return A new Pointer with appended token.
-    */
-    GenericPointer Append(const ValueType &token, Allocator *allocator = 0) const
-    {
-      if (token.IsString())
-        return Append(token.GetString(), token.GetStringLength(), allocator);
-      else
-        {
-          RAPIDJSON_ASSERT(token.IsUint64());
-          RAPIDJSON_ASSERT(token.GetUint64() <= SizeType(~0));
-          return Append(static_cast<SizeType>(token.GetUint64()), allocator);
-        }
-    }
-
-    //!@name Handling Parse Error
-    //@{
-
-    //! Check whether this is a valid pointer.
-    bool IsValid() const
-    {
-      return parseErrorCode_ == kPointerParseErrorNone;
-    }
-
-    //! Get the parsing error offset in code unit.
-    size_t GetParseErrorOffset() const
-    {
-      return parseErrorOffset_;
-    }
-
-    //! Get the parsing error code.
-    PointerParseErrorCode GetParseErrorCode() const
-    {
-      return parseErrorCode_;
-    }
-
-    //@}
-
-    //! Get the allocator of this pointer.
-    Allocator &GetAllocator()
-    {
-      return *allocator_;
-    }
-
-    //!@name Tokens
-    //@{
-
-    //! Get the token array (const version only).
-    const Token *GetTokens() const
-    {
-      return tokens_;
-    }
-
-    //! Get the number of tokens.
-    size_t GetTokenCount() const
-    {
-      return tokenCount_;
-    }
-
-    //@}
-
-    //!@name Equality/inequality operators
-    //@{
-
-    //! Equality operator.
-    /*!
-        \note When any pointers are invalid, always returns false.
-    */
-    bool operator==(const GenericPointer &rhs) const
-    {
-      if (!IsValid() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_)
-        return false;
-
-      for (size_t i = 0; i < tokenCount_; i++)
-        {
-          if (tokens_[i].index != rhs.tokens_[i].index ||
-              tokens_[i].length != rhs.tokens_[i].length ||
-              (tokens_[i].length != 0 && std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch)* tokens_[i].length) != 0))
-            {
-              return false;
-            }
-        }
-
-      return true;
-    }
-
-    //! Inequality operator.
-    /*!
-        \note When any pointers are invalid, always returns true.
-    */
-    bool operator!=(const GenericPointer &rhs) const
-    {
-      return !(*this == rhs);
-    }
-
-    //@}
-
-    //!@name Stringify
-    //@{
-
-    //! Stringify the pointer into string representation.
-    /*!
-        \tparam OutputStream Type of output stream.
-        \param os The output stream.
-    */
-    template<typename OutputStream>
-    bool Stringify(OutputStream &os) const
-    {
-      return Stringify<false, OutputStream>(os);
-    }
-
-    //! Stringify the pointer into URI fragment representation.
-    /*!
-        \tparam OutputStream Type of output stream.
-        \param os The output stream.
-    */
-    template<typename OutputStream>
-    bool StringifyUriFragment(OutputStream &os) const
-    {
-      return Stringify<true, OutputStream>(os);
-    }
-
-    //@}
-
-    //!@name Create value
-    //@{
-
-    //! Create a value in a subtree.
-    /*!
-        If the value is not exist, it creates all parent values and a JSON Null value.
-        So it always succeed and return the newly created or existing value.
-
-        Remind that it may change types of parents according to tokens, so it
-        potentially removes previously stored values. For example, if a document
-        was an array, and "/foo" is used to create a value, then the document
-        will be changed to an object, and all existing array elements are lost.
-
-        \param root Root value of a DOM subtree to be resolved. It can be any value other than document root.
-        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
-        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
-        \return The resolved newly created (a JSON Null value), or already exists value.
-    */
-    ValueType &Create(ValueType &root, typename ValueType::AllocatorType &allocator, bool *alreadyExist = 0) const
-    {
-      RAPIDJSON_ASSERT(IsValid());
-      ValueType *v = &root;
-      bool exist = true;
-      for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t)
-        {
-          if (v->IsArray() && t->name[0] == '-' && t->length == 1)
-            {
-              v->PushBack(ValueType().Move(), allocator);
-              v = &((*v)[v->Size() - 1]);
-              exist = false;
-            }
-          else
-            {
-              if (t->index == kPointerInvalidIndex)   // must be object name
-                {
-                  if (!v->IsObject())
-                    v->SetObject(); // Change to Object
-                }
-              else   // object name or array index
-                {
-                  if (!v->IsArray() && !v->IsObject())
-                    v->SetArray(); // Change to Array
-                }
-
-              if (v->IsArray())
-                {
-                  if (t->index >= v->Size())
-                    {
-                      v->Reserve(t->index + 1, allocator);
-                      while (t->index >= v->Size())
-                        v->PushBack(ValueType().Move(), allocator);
-                      exist = false;
-                    }
-                  v = &((*v)[t->index]);
-                }
-              else
-                {
-                  typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
-                  if (m == v->MemberEnd())
-                    {
-                      v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator);
-                      v = &(--v->MemberEnd())->value; // Assumes AddMember() appends at the end
-                      exist = false;
-                    }
-                  else
-                    v = &m->value;
-                }
-            }
-        }
-
-      if (alreadyExist)
-        *alreadyExist = exist;
-
-      return *v;
-    }
-
-    //! Creates a value in a document.
-    /*!
-        \param document A document to be resolved.
-        \param alreadyExist If non-null, it stores whether the resolved value is already exist.
-        \return The resolved newly created, or already exists value.
-    */
-    template <typename stackAllocator>
-    ValueType &Create(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, bool *alreadyExist = 0) const
-    {
-      return Create(document, document.GetAllocator(), alreadyExist);
-    }
-
-    //@}
-
-    //!@name Query value
-    //@{
-
-    //! Query a value in a subtree.
-    /*!
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \param unresolvedTokenIndex If the pointer cannot resolve a token in the pointer, this parameter can obtain the index of unresolved token.
-        \return Pointer to the value if it can be resolved. Otherwise null.
-
-        \note
-        There are only 3 situations when a value cannot be resolved:
-        1. A value in the path is not an array nor object.
-        2. An object value does not contain the token.
-        3. A token is out of range of an array value.
-
-        Use unresolvedTokenIndex to retrieve the token index.
-    */
-    ValueType *Get(ValueType &root, size_t *unresolvedTokenIndex = 0) const
-    {
-      RAPIDJSON_ASSERT(IsValid());
-      ValueType *v = &root;
-      for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t)
-        {
-          switch (v->GetType())
-            {
-              case kObjectType:
-              {
-                typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
-                if (m == v->MemberEnd())
-                  break;
-                v = &m->value;
-              }
-              continue;
-              case kArrayType:
-                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
-                  break;
-                v = &((*v)[t->index]);
-                continue;
-              default:
-                break;
-            }
-
-          // Error: unresolved token
-          if (unresolvedTokenIndex)
-            *unresolvedTokenIndex = static_cast<size_t>(t - tokens_);
-          return 0;
-        }
-      return v;
-    }
-
-    //! Query a const value in a const subtree.
-    /*!
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \return Pointer to the value if it can be resolved. Otherwise null.
-    */
-    const ValueType *Get(const ValueType &root, size_t *unresolvedTokenIndex = 0) const
-    {
-      return Get(const_cast<ValueType &>(root), unresolvedTokenIndex);
-    }
-
-    //@}
-
-    //!@name Query a value with default
-    //@{
-
-    //! Query a value in a subtree with default value.
-    /*!
-        Similar to Get(), but if the specified value do not exists, it creates all parents and clone the default value.
-        So that this function always succeed.
-
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \param defaultValue Default value to be cloned if the value was not exists.
-        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
-        \see Create()
-    */
-    ValueType &GetWithDefault(ValueType &root, const ValueType &defaultValue, typename ValueType::AllocatorType &allocator) const
-    {
-      bool alreadyExist;
-      ValueType &v = Create(root, allocator, &alreadyExist);
-      return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
-    }
-
-    //! Query a value in a subtree with default null-terminated string.
-    ValueType &GetWithDefault(ValueType &root, const Ch *defaultValue, typename ValueType::AllocatorType &allocator) const
-    {
-      bool alreadyExist;
-      ValueType &v = Create(root, allocator, &alreadyExist);
-      return alreadyExist ? v : v.SetString(defaultValue, allocator);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Query a value in a subtree with default std::basic_string.
-    ValueType &GetWithDefault(ValueType &root, const std::basic_string<Ch> &defaultValue, typename ValueType::AllocatorType &allocator) const
-    {
-      bool alreadyExist;
-      ValueType &v = Create(root, allocator, &alreadyExist);
-      return alreadyExist ? v : v.SetString(defaultValue, allocator);
-    }
-#endif
-
-    //! Query a value in a subtree with default primitive value.
-    /*!
-        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType &))
-    GetWithDefault(ValueType &root, T defaultValue, typename ValueType::AllocatorType &allocator) const
-    {
-      return GetWithDefault(root, ValueType(defaultValue).Move(), allocator);
-    }
-
-    //! Query a value in a document with default value.
-    template <typename stackAllocator>
-    ValueType &GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const ValueType &defaultValue) const
-    {
-      return GetWithDefault(document, defaultValue, document.GetAllocator());
-    }
-
-    //! Query a value in a document with default null-terminated string.
-    template <typename stackAllocator>
-    ValueType &GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const Ch *defaultValue) const
-    {
-      return GetWithDefault(document, defaultValue, document.GetAllocator());
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Query a value in a document with default std::basic_string.
-    template <typename stackAllocator>
-    ValueType &GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const std::basic_string<Ch> &defaultValue) const
-    {
-      return GetWithDefault(document, defaultValue, document.GetAllocator());
-    }
-#endif
-
-    //! Query a value in a document with default primitive value.
-    /*!
-        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
-    */
-    template <typename T, typename stackAllocator>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType &))
-    GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, T defaultValue) const
-    {
-      return GetWithDefault(document, defaultValue, document.GetAllocator());
-    }
-
-    //@}
-
-    //!@name Set a value
-    //@{
-
-    //! Set a value in a subtree, with move semantics.
-    /*!
-        It creates all parents if they are not exist or types are different to the tokens.
-        So this function always succeeds but potentially remove existing values.
-
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \param value Value to be set.
-        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
-        \see Create()
-    */
-    ValueType &Set(ValueType &root, ValueType &value, typename ValueType::AllocatorType &allocator) const
-    {
-      return Create(root, allocator) = value;
-    }
-
-    //! Set a value in a subtree, with copy semantics.
-    ValueType &Set(ValueType &root, const ValueType &value, typename ValueType::AllocatorType &allocator) const
-    {
-      return Create(root, allocator).CopyFrom(value, allocator);
-    }
-
-    //! Set a null-terminated string in a subtree.
-    ValueType &Set(ValueType &root, const Ch *value, typename ValueType::AllocatorType &allocator) const
-    {
-      return Create(root, allocator) = ValueType(value, allocator).Move();
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Set a std::basic_string in a subtree.
-    ValueType &Set(ValueType &root, const std::basic_string<Ch> &value, typename ValueType::AllocatorType &allocator) const
-    {
-      return Create(root, allocator) = ValueType(value, allocator).Move();
-    }
-#endif
-
-    //! Set a primitive value in a subtree.
-    /*!
-        \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType &))
-    Set(ValueType &root, T value, typename ValueType::AllocatorType &allocator) const
-    {
-      return Create(root, allocator) = ValueType(value).Move();
-    }
-
-    //! Set a value in a document, with move semantics.
-    template <typename stackAllocator>
-    ValueType &Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, ValueType &value) const
-    {
-      return Create(document) = value;
-    }
-
-    //! Set a value in a document, with copy semantics.
-    template <typename stackAllocator>
-    ValueType &Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const ValueType &value) const
-    {
-      return Create(document).CopyFrom(value, document.GetAllocator());
-    }
-
-    //! Set a null-terminated string in a document.
-    template <typename stackAllocator>
-    ValueType &Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const Ch *value) const
-    {
-      return Create(document) = ValueType(value, document.GetAllocator()).Move();
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Sets a std::basic_string in a document.
-    template <typename stackAllocator>
-    ValueType &Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, const std::basic_string<Ch> &value) const
-    {
-      return Create(document) = ValueType(value, document.GetAllocator()).Move();
-    }
-#endif
-
-    //! Set a primitive value in a document.
-    /*!
-    \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c bool
-    */
-    template <typename T, typename stackAllocator>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType &))
-    Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, T value) const
-    {
-      return Create(document) = value;
-    }
-
-    //@}
-
-    //!@name Swap a value
-    //@{
-
-    //! Swap a value with a value in a subtree.
-    /*!
-        It creates all parents if they are not exist or types are different to the tokens.
-        So this function always succeeds but potentially remove existing values.
-
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \param value Value to be swapped.
-        \param allocator Allocator for creating the values if the specified value or its parents are not exist.
-        \see Create()
-    */
-    ValueType &Swap(ValueType &root, ValueType &value, typename ValueType::AllocatorType &allocator) const
-    {
-      return Create(root, allocator).Swap(value);
-    }
-
-    //! Swap a value with a value in a document.
-    template <typename stackAllocator>
-    ValueType &Swap(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator> &document, ValueType &value) const
-    {
-      return Create(document).Swap(value);
-    }
-
-    //@}
-
-    //! Erase a value in a subtree.
-    /*!
-        \param root Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
-        \return Whether the resolved value is found and erased.
-
-        \note Erasing with an empty pointer \c Pointer(""), i.e. the root, always fail and return false.
-    */
-    bool Erase(ValueType &root) const
-    {
-      RAPIDJSON_ASSERT(IsValid());
-      if (tokenCount_ == 0) // Cannot erase the root
-        return false;
-
-      ValueType *v = &root;
-      const Token *last = tokens_ + (tokenCount_ - 1);
-      for (const Token *t = tokens_; t != last; ++t)
-        {
-          switch (v->GetType())
-            {
-              case kObjectType:
-              {
-                typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
-                if (m == v->MemberEnd())
-                  return false;
-                v = &m->value;
-              }
-              break;
-              case kArrayType:
-                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
-                  return false;
-                v = &((*v)[t->index]);
-                break;
-              default:
-                return false;
-            }
-        }
-
-      switch (v->GetType())
-        {
-          case kObjectType:
-            return v->EraseMember(GenericStringRef<Ch>(last->name, last->length));
-          case kArrayType:
-            if (last->index == kPointerInvalidIndex || last->index >= v->Size())
-              return false;
-            v->Erase(v->Begin() + last->index);
-            return true;
-          default:
-            return false;
-        }
-    }
-
-  private:
-    //! Clone the content from rhs to this.
-    /*!
-        \param rhs Source pointer.
-        \param extraToken Extra tokens to be allocated.
-        \param extraNameBufferSize Extra name buffer size (in number of Ch) to be allocated.
-        \return Start of non-occupied name buffer, for storing extra names.
-    */
-    Ch *CopyFromRaw(const GenericPointer &rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0)
-    {
-      if (!allocator_) // allocator is independently owned.
-        ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-
-      size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens
-      for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t)
-        nameBufferSize += t->length;
-
-      tokenCount_ = rhs.tokenCount_ + extraToken;
-      tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + (nameBufferSize + extraNameBufferSize) * sizeof(Ch)));
-      nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
-      if (rhs.tokenCount_ > 0)
-        {
-          std::memcpy(tokens_, rhs.tokens_, rhs.tokenCount_ * sizeof(Token));
-        }
-      if (nameBufferSize > 0)
-        {
-          std::memcpy(nameBuffer_, rhs.nameBuffer_, nameBufferSize * sizeof(Ch));
-        }
-
-      // Adjust pointers to name buffer
-      std::ptrdiff_t diff = nameBuffer_ - rhs.nameBuffer_;
-      for (Token *t = tokens_; t != tokens_ + rhs.tokenCount_; ++t)
-        t->name += diff;
-
-      return nameBuffer_ + nameBufferSize;
-    }
-
-    //! Check whether a character should be percent-encoded.
-    /*!
-        According to RFC 3986 2.3 Unreserved Characters.
-        \param c The character (code unit) to be tested.
-    */
-    bool NeedPercentEncode(Ch c) const
-    {
-      return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~');
-    }
-
-    //! Parse a JSON String or its URI fragment representation into tokens.
-#ifndef __clang__ // -Wdocumentation
-    /*!
-        \param source Either a JSON Pointer string, or its URI fragment representation. Not need to be null terminated.
-        \param length Length of the source string.
-        \note Source cannot be JSON String Representation of JSON Pointer, e.g. In "/\u0000", \u0000 will not be unescaped.
-    */
-#endif
-    void Parse(const Ch *source, size_t length)
-    {
-      RAPIDJSON_ASSERT(source != NULL);
-      RAPIDJSON_ASSERT(nameBuffer_ == 0);
-      RAPIDJSON_ASSERT(tokens_ == 0);
-
-      // Create own allocator if user did not supply.
-      if (!allocator_)
-        ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-
-      // Count number of '/' as tokenCount
-      tokenCount_ = 0;
-      for (const Ch *s = source; s != source + length; s++)
-        if (*s == '/')
-          tokenCount_++;
-
-      Token *token = tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + length * sizeof(Ch)));
-      Ch *name = nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
-      size_t i = 0;
-
-      // Detect if it is a URI fragment
-      bool uriFragment = false;
-      if (source[i] == '#')
-        {
-          uriFragment = true;
-          i++;
-        }
-
-      if (i != length && source[i] != '/')
-        {
-          parseErrorCode_ = kPointerParseErrorTokenMustBeginWithSolidus;
-          goto error;
-        }
-
-      while (i < length)
-        {
-          RAPIDJSON_ASSERT(source[i] == '/');
-          i++; // consumes '/'
-
-          token->name = name;
-          bool isNumber = true;
-
-          while (i < length && source[i] != '/')
-            {
-              Ch c = source[i];
-              if (uriFragment)
-                {
-                  // Decoding percent-encoding for URI fragment
-                  if (c == '%')
-                    {
-                      PercentDecodeStream is(&source[i], source + length);
-                      GenericInsituStringStream<EncodingType> os(name);
-                      Ch *begin = os.PutBegin();
-                      if (!Transcoder<UTF8<>, EncodingType>().Validate(is, os) || !is.IsValid())
-                        {
-                          parseErrorCode_ = kPointerParseErrorInvalidPercentEncoding;
-                          goto error;
-                        }
-                      size_t len = os.PutEnd(begin);
-                      i += is.Tell() - 1;
-                      if (len == 1)
-                        c = *name;
-                      else
-                        {
-                          name += len;
-                          isNumber = false;
-                          i++;
-                          continue;
-                        }
-                    }
-                  else if (NeedPercentEncode(c))
-                    {
-                      parseErrorCode_ = kPointerParseErrorCharacterMustPercentEncode;
-                      goto error;
-                    }
-                }
-
-              i++;
-
-              // Escaping "~0" -> '~', "~1" -> '/'
-              if (c == '~')
-                {
-                  if (i < length)
-                    {
-                      c = source[i];
-                      if (c == '0')       c = '~';
-                      else if (c == '1')  c = '/';
-                      else
-                        {
-                          parseErrorCode_ = kPointerParseErrorInvalidEscape;
-                          goto error;
-                        }
-                      i++;
-                    }
-                  else
-                    {
-                      parseErrorCode_ = kPointerParseErrorInvalidEscape;
-                      goto error;
-                    }
-                }
-
-              // First check for index: all of characters are digit
-              if (c < '0' || c > '9')
-                isNumber = false;
-
-              *name++ = c;
-            }
-          token->length = static_cast<SizeType>(name - token->name);
-          if (token->length == 0)
-            isNumber = false;
-          *name++ = '\0'; // Null terminator
-
-          // Second check for index: more than one digit cannot have leading zero
-          if (isNumber && token->length > 1 && token->name[0] == '0')
-            isNumber = false;
-
-          // String to SizeType conversion
-          SizeType n = 0;
-          if (isNumber)
-            {
-              for (size_t j = 0; j < token->length; j++)
-                {
-                  SizeType m = n * 10 + static_cast<SizeType>(token->name[j] - '0');
-                  if (m < n)     // overflow detection
-                    {
-                      isNumber = false;
-                      break;
-                    }
-                  n = m;
-                }
-            }
-
-          token->index = isNumber ? n : kPointerInvalidIndex;
-          token++;
-        }
-
-      RAPIDJSON_ASSERT(name <= nameBuffer_ + length); // Should not overflow buffer
-      parseErrorCode_ = kPointerParseErrorNone;
-      return;
-
-    error:
-      Allocator::Free(tokens_);
-      nameBuffer_ = 0;
-      tokens_ = 0;
-      tokenCount_ = 0;
-      parseErrorOffset_ = i;
-      return;
-    }
-
-    //! Stringify to string or URI fragment representation.
-    /*!
-        \tparam uriFragment True for stringifying to URI fragment representation. False for string representation.
-        \tparam OutputStream type of output stream.
-        \param os The output stream.
-    */
-    template<bool uriFragment, typename OutputStream>
-    bool Stringify(OutputStream &os) const
-    {
-      RAPIDJSON_ASSERT(IsValid());
-
-      if (uriFragment)
-        os.Put('#');
-
-      for (Token *t = tokens_; t != tokens_ + tokenCount_; ++t)
-        {
-          os.Put('/');
-          for (size_t j = 0; j < t->length; j++)
-            {
-              Ch c = t->name[j];
-              if (c == '~')
-                {
-                  os.Put('~');
-                  os.Put('0');
-                }
-              else if (c == '/')
-                {
-                  os.Put('~');
-                  os.Put('1');
-                }
-              else if (uriFragment && NeedPercentEncode(c))
-                {
-                  // Transcode to UTF8 sequence
-                  GenericStringStream<typename ValueType::EncodingType> source(&t->name[j]);
-                  PercentEncodeStream<OutputStream> target(os);
-                  if (!Transcoder<EncodingType, UTF8<> >().Validate(source, target))
-                    return false;
-                  j += source.Tell() - 1;
-                }
-              else
-                os.Put(c);
-            }
-        }
-      return true;
-    }
-
-    //! A helper stream for decoding a percent-encoded sequence into code unit.
-    /*!
-        This stream decodes %XY triplet into code unit (0-255).
-        If it encounters invalid characters, it sets output code unit as 0 and
-        mark invalid, and to be checked by IsValid().
-    */
-    class PercentDecodeStream
-    {
-      public:
-        typedef typename ValueType::Ch Ch;
-
-        //! Constructor
-        /*!
-            \param source Start of the stream
-            \param end Past-the-end of the stream.
-        */
-        PercentDecodeStream(const Ch *source, const Ch *end) : src_(source), head_(source), end_(end), valid_(true) {}
-
-        Ch Take()
-        {
-          if (*src_ != '%' || src_ + 3 > end_)   // %XY triplet
-            {
-              valid_ = false;
-              return 0;
-            }
-          src_++;
-          Ch c = 0;
-          for (int j = 0; j < 2; j++)
-            {
-              c = static_cast<Ch>(c << 4);
-              Ch h = *src_;
-              if      (h >= '0' && h <= '9') c = static_cast<Ch>(c + h - '0');
-              else if (h >= 'A' && h <= 'F') c = static_cast<Ch>(c + h - 'A' + 10);
-              else if (h >= 'a' && h <= 'f') c = static_cast<Ch>(c + h - 'a' + 10);
-              else
-                {
-                  valid_ = false;
-                  return 0;
-                }
-              src_++;
-            }
-          return c;
-        }
-
-        size_t Tell() const
-        {
-          return static_cast<size_t>(src_ - head_);
-        }
-        bool IsValid() const
-        {
-          return valid_;
-        }
-
-      private:
-        const Ch *src_;     //!< Current read position.
-        const Ch *head_;    //!< Original head of the string.
-        const Ch *end_;     //!< Past-the-end position.
-        bool valid_;        //!< Whether the parsing is valid.
-    };
-
-    //! A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence.
-    template <typename OutputStream>
-    class PercentEncodeStream
-    {
-      public:
-        PercentEncodeStream(OutputStream &os) : os_(os) {}
-        void Put(char c)   // UTF-8 must be byte
-        {
-          unsigned char u = static_cast<unsigned char>(c);
-          static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-          os_.Put('%');
-          os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u >> 4]));
-          os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u & 15]));
-        }
-      private:
-        OutputStream &os_;
-    };
-
-    Allocator *allocator_;                  //!< The current allocator. It is either user-supplied or equal to ownAllocator_.
-    Allocator *ownAllocator_;               //!< Allocator owned by this Pointer.
-    Ch *nameBuffer_;                        //!< A buffer containing all names in tokens.
-    Token *tokens_;                         //!< A list of tokens.
-    size_t tokenCount_;                     //!< Number of tokens in tokens_.
-    size_t parseErrorOffset_;               //!< Offset in code unit when parsing fail.
-    PointerParseErrorCode parseErrorCode_;  //!< Parsing error code.
-};
-
-//! GenericPointer for Value (UTF-8, default allocator).
-typedef GenericPointer<Value> Pointer;
-
-//!@name Helper functions for GenericPointer
-//@{
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType &CreateValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, typename T::AllocatorType &a)
-{
-  return pointer.Create(root, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType &CreateValueByPointer(T &root, const CharType(&source)[N], typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Create(root, a);
-}
-
-// No allocator parameter
-
-template <typename DocumentType>
-typename DocumentType::ValueType &CreateValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer)
-{
-  return pointer.Create(document);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType &CreateValueByPointer(DocumentType &document, const CharType(&source)[N])
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Create(document);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType *GetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, size_t *unresolvedTokenIndex = 0)
-{
-  return pointer.Get(root, unresolvedTokenIndex);
-}
-
-template <typename T>
-const typename T::ValueType *GetValueByPointer(const T &root, const GenericPointer<typename T::ValueType> &pointer, size_t *unresolvedTokenIndex = 0)
-{
-  return pointer.Get(root, unresolvedTokenIndex);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType *GetValueByPointer(T &root, const CharType (&source)[N], size_t *unresolvedTokenIndex = 0)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
-}
-
-template <typename T, typename CharType, size_t N>
-const typename T::ValueType *GetValueByPointer(const T &root, const CharType(&source)[N], size_t *unresolvedTokenIndex = 0)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType &GetValueByPointerWithDefault(T &root, const GenericPointer<typename T::ValueType> &pointer, const typename T::ValueType &defaultValue, typename T::AllocatorType &a)
-{
-  return pointer.GetWithDefault(root, defaultValue, a);
-}
-
-template <typename T>
-typename T::ValueType &GetValueByPointerWithDefault(T &root, const GenericPointer<typename T::ValueType> &pointer, const typename T::Ch *defaultValue, typename T::AllocatorType &a)
-{
-  return pointer.GetWithDefault(root, defaultValue, a);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename T>
-typename T::ValueType &GetValueByPointerWithDefault(T &root, const GenericPointer<typename T::ValueType> &pointer, const std::basic_string<typename T::Ch> &defaultValue, typename T::AllocatorType &a)
-{
-  return pointer.GetWithDefault(root, defaultValue, a);
-}
-#endif
-
-template <typename T, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType &))
-GetValueByPointerWithDefault(T &root, const GenericPointer<typename T::ValueType> &pointer, T2 defaultValue, typename T::AllocatorType &a)
-{
-  return pointer.GetWithDefault(root, defaultValue, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType &GetValueByPointerWithDefault(T &root, const CharType(&source)[N], const typename T::ValueType &defaultValue, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType &GetValueByPointerWithDefault(T &root, const CharType(&source)[N], const typename T::Ch *defaultValue, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename T, typename CharType, size_t N>
-typename T::ValueType &GetValueByPointerWithDefault(T &root, const CharType(&source)[N], const std::basic_string<typename T::Ch> &defaultValue, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
-}
-#endif
-
-template <typename T, typename CharType, size_t N, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType &))
-GetValueByPointerWithDefault(T &root, const CharType(&source)[N], T2 defaultValue, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
-}
-
-// No allocator parameter
-
-template <typename DocumentType>
-typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const typename DocumentType::ValueType &defaultValue)
-{
-  return pointer.GetWithDefault(document, defaultValue);
-}
-
-template <typename DocumentType>
-typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const typename DocumentType::Ch *defaultValue)
-{
-  return pointer.GetWithDefault(document, defaultValue);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename DocumentType>
-typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const std::basic_string<typename DocumentType::Ch> &defaultValue)
-{
-  return pointer.GetWithDefault(document, defaultValue);
-}
-#endif
-
-template <typename DocumentType, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType &))
-GetValueByPointerWithDefault(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, T2 defaultValue)
-{
-  return pointer.GetWithDefault(document, defaultValue);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const CharType(&source)[N], const typename DocumentType::ValueType &defaultValue)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const CharType(&source)[N], const typename DocumentType::Ch *defaultValue)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType &GetValueByPointerWithDefault(DocumentType &document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch> &defaultValue)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
-}
-#endif
-
-template <typename DocumentType, typename CharType, size_t N, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType &))
-GetValueByPointerWithDefault(DocumentType &document, const CharType(&source)[N], T2 defaultValue)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType &SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, typename T::ValueType &value, typename T::AllocatorType &a)
-{
-  return pointer.Set(root, value, a);
-}
-
-template <typename T>
-typename T::ValueType &SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, const typename T::ValueType &value, typename T::AllocatorType &a)
-{
-  return pointer.Set(root, value, a);
-}
-
-template <typename T>
-typename T::ValueType &SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, const typename T::Ch *value, typename T::AllocatorType &a)
-{
-  return pointer.Set(root, value, a);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename T>
-typename T::ValueType &SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, const std::basic_string<typename T::Ch> &value, typename T::AllocatorType &a)
-{
-  return pointer.Set(root, value, a);
-}
-#endif
-
-template <typename T, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType &))
-SetValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, T2 value, typename T::AllocatorType &a)
-{
-  return pointer.Set(root, value, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType &SetValueByPointer(T &root, const CharType(&source)[N], typename T::ValueType &value, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType &SetValueByPointer(T &root, const CharType(&source)[N], const typename T::ValueType &value, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType &SetValueByPointer(T &root, const CharType(&source)[N], const typename T::Ch *value, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename T, typename CharType, size_t N>
-typename T::ValueType &SetValueByPointer(T &root, const CharType(&source)[N], const std::basic_string<typename T::Ch> &value, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-#endif
-
-template <typename T, typename CharType, size_t N, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType &))
-SetValueByPointer(T &root, const CharType(&source)[N], T2 value, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
-}
-
-// No allocator parameter
-
-template <typename DocumentType>
-typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, typename DocumentType::ValueType &value)
-{
-  return pointer.Set(document, value);
-}
-
-template <typename DocumentType>
-typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const typename DocumentType::ValueType &value)
-{
-  return pointer.Set(document, value);
-}
-
-template <typename DocumentType>
-typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const typename DocumentType::Ch *value)
-{
-  return pointer.Set(document, value);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename DocumentType>
-typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, const std::basic_string<typename DocumentType::Ch> &value)
-{
-  return pointer.Set(document, value);
-}
-#endif
-
-template <typename DocumentType, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType &))
-SetValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, T2 value)
-{
-  return pointer.Set(document, value);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const CharType(&source)[N], typename DocumentType::ValueType &value)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const CharType(&source)[N], const typename DocumentType::ValueType &value)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const CharType(&source)[N], const typename DocumentType::Ch *value)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType &SetValueByPointer(DocumentType &document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch> &value)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-#endif
-
-template <typename DocumentType, typename CharType, size_t N, typename T2>
-RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType &))
-SetValueByPointer(DocumentType &document, const CharType(&source)[N], T2 value)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-typename T::ValueType &SwapValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer, typename T::ValueType &value, typename T::AllocatorType &a)
-{
-  return pointer.Swap(root, value, a);
-}
-
-template <typename T, typename CharType, size_t N>
-typename T::ValueType &SwapValueByPointer(T &root, const CharType(&source)[N], typename T::ValueType &value, typename T::AllocatorType &a)
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Swap(root, value, a);
-}
-
-template <typename DocumentType>
-typename DocumentType::ValueType &SwapValueByPointer(DocumentType &document, const GenericPointer<typename DocumentType::ValueType> &pointer, typename DocumentType::ValueType &value)
-{
-  return pointer.Swap(document, value);
-}
-
-template <typename DocumentType, typename CharType, size_t N>
-typename DocumentType::ValueType &SwapValueByPointer(DocumentType &document, const CharType(&source)[N], typename DocumentType::ValueType &value)
-{
-  return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Swap(document, value);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-bool EraseValueByPointer(T &root, const GenericPointer<typename T::ValueType> &pointer)
-{
-  return pointer.Erase(root);
-}
-
-template <typename T, typename CharType, size_t N>
-bool EraseValueByPointer(T &root, const CharType(&source)[N])
-{
-  return GenericPointer<typename T::ValueType>(source, N - 1).Erase(root);
-}
-
-//@}
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__) || defined(_MSC_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_POINTER_H_
diff --git a/contrib/world_builder/include/rapidjson/prettywriter.h.bak b/contrib/world_builder/include/rapidjson/prettywriter.h.bak
deleted file mode 100644
index ea658987976..00000000000
--- a/contrib/world_builder/include/rapidjson/prettywriter.h.bak
+++ /dev/null
@@ -1,340 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_PRETTYWRITER_H_
-#define RAPIDJSON_PRETTYWRITER_H_
-
-#include "writer.h"
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Combination of PrettyWriter format flags.
-/*! \see PrettyWriter::SetFormatOptions
- */
-enum PrettyFormatOptions
-{
-  kFormatDefault = 0,         //!< Default pretty formatting.
-  kFormatSingleLineArray = 1  //!< Format arrays on a single line.
-};
-
-//! Writer with indentation and spacing.
-/*!
-    \tparam OutputStream Type of output os.
-    \tparam SourceEncoding Encoding of source string.
-    \tparam TargetEncoding Encoding of output stream.
-    \tparam StackAllocator Type of allocator for allocating memory of stack.
-*/
-template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
-class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags>
-{
-  public:
-    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base;
-    typedef typename Base::Ch Ch;
-
-    //! Constructor
-    /*! \param os Output stream.
-        \param allocator User supplied allocator. If it is null, it will create a private one.
-        \param levelDepth Initial capacity of stack.
-    */
-    explicit PrettyWriter(OutputStream &os, StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
-      Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
-
-
-    explicit PrettyWriter(StackAllocator *allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) :
-      Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    PrettyWriter(PrettyWriter &&rhs) :
-      Base(std::forward<PrettyWriter>(rhs)), indentChar_(rhs.indentChar_), indentCharCount_(rhs.indentCharCount_), formatOptions_(rhs.formatOptions_) {}
-#endif
-
-    //! Set custom indentation.
-    /*! \param indentChar       Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
-        \param indentCharCount  Number of indent characters for each indentation level.
-        \note The default indentation is 4 spaces.
-    */
-    PrettyWriter &SetIndent(Ch indentChar, unsigned indentCharCount)
-    {
-      RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
-      indentChar_ = indentChar;
-      indentCharCount_ = indentCharCount;
-      return *this;
-    }
-
-    //! Set pretty writer formatting options.
-    /*! \param options Formatting options.
-    */
-    PrettyWriter &SetFormatOptions(PrettyFormatOptions options)
-    {
-      formatOptions_ = options;
-      return *this;
-    }
-
-    /*! @name Implementation of Handler
-        \see Handler
-    */
-    //@{
-
-    bool Null()
-    {
-      PrettyPrefix(kNullType);
-      return Base::EndValue(Base::WriteNull());
-    }
-    bool Bool(bool b)
-    {
-      PrettyPrefix(b ? kTrueType : kFalseType);
-      return Base::EndValue(Base::WriteBool(b));
-    }
-    bool Int(int i)
-    {
-      PrettyPrefix(kNumberType);
-      return Base::EndValue(Base::WriteInt(i));
-    }
-    bool Uint(unsigned u)
-    {
-      PrettyPrefix(kNumberType);
-      return Base::EndValue(Base::WriteUint(u));
-    }
-    bool Int64(int64_t i64)
-    {
-      PrettyPrefix(kNumberType);
-      return Base::EndValue(Base::WriteInt64(i64));
-    }
-    bool Uint64(uint64_t u64)
-    {
-      PrettyPrefix(kNumberType);
-      return Base::EndValue(Base::WriteUint64(u64));
-    }
-    bool Double(double d)
-    {
-      PrettyPrefix(kNumberType);
-      return Base::EndValue(Base::WriteDouble(d));
-    }
-
-    bool RawNumber(const Ch *str, SizeType length, bool copy = false)
-    {
-      RAPIDJSON_ASSERT(str != 0);
-      (void)copy;
-      PrettyPrefix(kNumberType);
-      return Base::EndValue(Base::WriteString(str, length));
-    }
-
-    bool String(const Ch *str, SizeType length, bool copy = false)
-    {
-      RAPIDJSON_ASSERT(str != 0);
-      (void)copy;
-      PrettyPrefix(kStringType);
-      return Base::EndValue(Base::WriteString(str, length));
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool String(const std::basic_string<Ch> &str)
-    {
-      return String(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool StartObject()
-    {
-      PrettyPrefix(kObjectType);
-      new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
-      return Base::WriteStartObject();
-    }
-
-    bool Key(const Ch *str, SizeType length, bool copy = false)
-    {
-      return String(str, length, copy);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool Key(const std::basic_string<Ch> &str)
-    {
-      return Key(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool EndObject(SizeType memberCount = 0)
-    {
-      (void)memberCount;
-      RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object
-      RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray); // currently inside an Array, not Object
-      RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top<typename Base::Level>()->valueCount % 2); // Object has a Key without a Value
-
-      bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
-
-      if (!empty)
-        {
-          Base::os_->Put('\n');
-          WriteIndent();
-        }
-      bool ret = Base::EndValue(Base::WriteEndObject());
-      (void)ret;
-      RAPIDJSON_ASSERT(ret == true);
-      if (Base::level_stack_.Empty()) // end of json text
-        Base::Flush();
-      return true;
-    }
-
-    bool StartArray()
-    {
-      PrettyPrefix(kArrayType);
-      new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
-      return Base::WriteStartArray();
-    }
-
-    bool EndArray(SizeType memberCount = 0)
-    {
-      (void)memberCount;
-      RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
-      RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
-      bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
-
-      if (!empty && !(formatOptions_ & kFormatSingleLineArray))
-        {
-          Base::os_->Put('\n');
-          WriteIndent();
-        }
-      bool ret = Base::EndValue(Base::WriteEndArray());
-      (void)ret;
-      RAPIDJSON_ASSERT(ret == true);
-      if (Base::level_stack_.Empty()) // end of json text
-        Base::Flush();
-      return true;
-    }
-
-    //@}
-
-    /*! @name Convenience extensions */
-    //@{
-
-    //! Simpler but slower overload.
-    bool String(const Ch *str)
-    {
-      return String(str, internal::StrLen(str));
-    }
-    bool Key(const Ch *str)
-    {
-      return Key(str, internal::StrLen(str));
-    }
-
-    //@}
-
-    //! Write a raw JSON value.
-    /*!
-        For user to write a stringified JSON as a value.
-
-        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
-        \param length Length of the json.
-        \param type Type of the root of json.
-        \note When using PrettyWriter::RawValue(), the result json may not be indented correctly.
-    */
-    bool RawValue(const Ch *json, size_t length, Type type)
-    {
-      RAPIDJSON_ASSERT(json != 0);
-      PrettyPrefix(type);
-      return Base::EndValue(Base::WriteRawValue(json, length));
-    }
-
-  protected:
-    void PrettyPrefix(Type type)
-    {
-      (void)type;
-      if (Base::level_stack_.GetSize() != 0)   // this value is not at root
-        {
-          typename Base::Level *level = Base::level_stack_.template Top<typename Base::Level>();
-
-          if (level->inArray)
-            {
-              if (level->valueCount > 0)
-                {
-                  Base::os_->Put(','); // add comma if it is not the first element in array
-                  if (formatOptions_ & kFormatSingleLineArray)
-                    Base::os_->Put(' ');
-                }
-
-              if (!(formatOptions_ & kFormatSingleLineArray))
-                {
-                  Base::os_->Put('\n');
-                  WriteIndent();
-                }
-            }
-          else    // in object
-            {
-              if (level->valueCount > 0)
-                {
-                  if (level->valueCount % 2 == 0)
-                    {
-                      Base::os_->Put(',');
-                      Base::os_->Put('\n');
-                    }
-                  else
-                    {
-                      Base::os_->Put(':');
-                      Base::os_->Put(' ');
-                    }
-                }
-              else
-                Base::os_->Put('\n');
-
-              if (level->valueCount % 2 == 0)
-                WriteIndent();
-            }
-          if (!level->inArray && level->valueCount % 2 == 0)
-            RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
-          level->valueCount++;
-        }
-      else
-        {
-          RAPIDJSON_ASSERT(!Base::hasRoot_);  // Should only has one and only one root.
-          Base::hasRoot_ = true;
-        }
-    }
-
-    void WriteIndent()
-    {
-      size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
-      PutN(*Base::os_, static_cast<typename OutputStream::Ch>(indentChar_), count);
-    }
-
-    Ch indentChar_;
-    unsigned indentCharCount_;
-    PrettyFormatOptions formatOptions_;
-
-  private:
-    // Prohibit copy constructor & assignment operator.
-    PrettyWriter(const PrettyWriter &);
-    PrettyWriter &operator=(const PrettyWriter &);
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/rapidjson/rapidjson.h.bak b/contrib/world_builder/include/rapidjson/rapidjson.h.bak
deleted file mode 100644
index d857baeea34..00000000000
--- a/contrib/world_builder/include/rapidjson/rapidjson.h.bak
+++ /dev/null
@@ -1,660 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_RAPIDJSON_H_
-#define RAPIDJSON_RAPIDJSON_H_
-
-/*!\file rapidjson.h
-    \brief common definitions and configuration
-
-    \see RAPIDJSON_CONFIG
- */
-
-/*! \defgroup RAPIDJSON_CONFIG RapidJSON configuration
-    \brief Configuration macros for library features
-
-    Some RapidJSON features are configurable to adapt the library to a wide
-    variety of platforms, environments and usage scenarios.  Most of the
-    features can be configured in terms of overridden or predefined
-    preprocessor macros at compile-time.
-
-    Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs.
-
-    \note These macros should be given on the compiler command-line
-          (where applicable)  to avoid inconsistent values when compiling
-          different translation units of a single application.
- */
-
-#include <cstdlib>  // malloc(), realloc(), free(), size_t
-#include <cstring>  // memset(), memcpy(), memmove(), memcmp()
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_VERSION_STRING
-//
-// ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt.
-//
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-// token stringification
-#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x)
-#define RAPIDJSON_DO_STRINGIFY(x) #x
-
-// token concatenation
-#define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y)
-#define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y)
-#define RAPIDJSON_DO_JOIN2(X, Y) X##Y
-//!@endcond
-
-/*! \def RAPIDJSON_MAJOR_VERSION
-    \ingroup RAPIDJSON_CONFIG
-    \brief Major version of RapidJSON in integer.
-*/
-/*! \def RAPIDJSON_MINOR_VERSION
-    \ingroup RAPIDJSON_CONFIG
-    \brief Minor version of RapidJSON in integer.
-*/
-/*! \def RAPIDJSON_PATCH_VERSION
-    \ingroup RAPIDJSON_CONFIG
-    \brief Patch version of RapidJSON in integer.
-*/
-/*! \def RAPIDJSON_VERSION_STRING
-    \ingroup RAPIDJSON_CONFIG
-    \brief Version of RapidJSON in "<major>.<minor>.<patch>" string format.
-*/
-#define RAPIDJSON_MAJOR_VERSION 1
-#define RAPIDJSON_MINOR_VERSION 1
-#define RAPIDJSON_PATCH_VERSION 0
-#define RAPIDJSON_VERSION_STRING \
-  RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION)
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NAMESPACE_(BEGIN|END)
-/*! \def RAPIDJSON_NAMESPACE
-    \ingroup RAPIDJSON_CONFIG
-    \brief   provide custom rapidjson namespace
-
-    In order to avoid symbol clashes and/or "One Definition Rule" errors
-    between multiple inclusions of (different versions of) RapidJSON in
-    a single binary, users can customize the name of the main RapidJSON
-    namespace.
-
-    In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE
-    to a custom name (e.g. \c MyRapidJSON) is sufficient.  If multiple
-    levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref
-    RAPIDJSON_NAMESPACE_END need to be defined as well:
-
-    \code
-    // in some .cpp file
-    #define RAPIDJSON_NAMESPACE my::rapidjson
-    #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {
-    #define RAPIDJSON_NAMESPACE_END   } }
-    #include "rapidjson/..."
-    \endcode
-
-    \see rapidjson
- */
-/*! \def RAPIDJSON_NAMESPACE_BEGIN
-    \ingroup RAPIDJSON_CONFIG
-    \brief   provide custom rapidjson namespace (opening expression)
-    \see RAPIDJSON_NAMESPACE
-*/
-/*! \def RAPIDJSON_NAMESPACE_END
-    \ingroup RAPIDJSON_CONFIG
-    \brief   provide custom rapidjson namespace (closing expression)
-    \see RAPIDJSON_NAMESPACE
-*/
-#ifndef RAPIDJSON_NAMESPACE
-#define RAPIDJSON_NAMESPACE rapidjson
-#endif
-#ifndef RAPIDJSON_NAMESPACE_BEGIN
-#define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE {
-#endif
-#ifndef RAPIDJSON_NAMESPACE_END
-#define RAPIDJSON_NAMESPACE_END }
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_HAS_STDSTRING
-
-#ifndef RAPIDJSON_HAS_STDSTRING
-#ifdef RAPIDJSON_DOXYGEN_RUNNING
-#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation
-#else
-#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default
-#endif
-/*! \def RAPIDJSON_HAS_STDSTRING
-    \ingroup RAPIDJSON_CONFIG
-    \brief Enable RapidJSON support for \c std::string
-
-    By defining this preprocessor symbol to \c 1, several convenience functions for using
-    \ref rapidjson::GenericValue with \c std::string are enabled, especially
-    for construction and comparison.
-
-    \hideinitializer
-*/
-#endif // !defined(RAPIDJSON_HAS_STDSTRING)
-
-#if RAPIDJSON_HAS_STDSTRING
-#include <string>
-#endif // RAPIDJSON_HAS_STDSTRING
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NO_INT64DEFINE
-
-/*! \def RAPIDJSON_NO_INT64DEFINE
-    \ingroup RAPIDJSON_CONFIG
-    \brief Use external 64-bit integer types.
-
-    RapidJSON requires the 64-bit integer types \c int64_t and  \c uint64_t types
-    to be available at global scope.
-
-    If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to
-    prevent RapidJSON from defining its own types.
-*/
-#ifndef RAPIDJSON_NO_INT64DEFINE
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#if defined(_MSC_VER) && (_MSC_VER < 1800)  // Visual Studio 2013
-#include "msinttypes/stdint.h"
-#include "msinttypes/inttypes.h"
-#else
-// Other compilers should have this.
-#include <stdint.h>
-#include <inttypes.h>
-#endif
-//!@endcond
-#ifdef RAPIDJSON_DOXYGEN_RUNNING
-#define RAPIDJSON_NO_INT64DEFINE
-#endif
-#endif // RAPIDJSON_NO_INT64TYPEDEF
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_FORCEINLINE
-
-#ifndef RAPIDJSON_FORCEINLINE
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#if defined(_MSC_VER) && defined(NDEBUG)
-#define RAPIDJSON_FORCEINLINE __forceinline
-#elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG)
-#define RAPIDJSON_FORCEINLINE __attribute__((always_inline))
-#else
-#define RAPIDJSON_FORCEINLINE
-#endif
-//!@endcond
-#endif // RAPIDJSON_FORCEINLINE
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ENDIAN
-#define RAPIDJSON_LITTLEENDIAN  0   //!< Little endian machine
-#define RAPIDJSON_BIGENDIAN     1   //!< Big endian machine
-
-//! Endianness of the machine.
-/*!
-    \def RAPIDJSON_ENDIAN
-    \ingroup RAPIDJSON_CONFIG
-
-    GCC 4.6 provided macro for detecting endianness of the target machine. But other
-    compilers may not have this. User can define RAPIDJSON_ENDIAN to either
-    \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN.
-
-    Default detection implemented with reference to
-    \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html
-    \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp
-*/
-#ifndef RAPIDJSON_ENDIAN
-// Detect with GCC 4.6's macro
-#  ifdef __BYTE_ORDER__
-#    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-#    else
-#      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
-#    endif // __BYTE_ORDER__
-// Detect with GLIBC's endian.h
-#  elif defined(__GLIBC__)
-#    include <endian.h>
-#    if (__BYTE_ORDER == __LITTLE_ENDIAN)
-#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#    elif (__BYTE_ORDER == __BIG_ENDIAN)
-#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-#    else
-#      error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
-#   endif // __GLIBC__
-// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
-#  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#  elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-// Detect with architecture macros
-#  elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-#  elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#  elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
-#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#  elif defined(RAPIDJSON_DOXYGEN_RUNNING)
-#    define RAPIDJSON_ENDIAN
-#  else
-#    error Unknown machine endianness detected. User needs to define RAPIDJSON_ENDIAN.
-#  endif
-#endif // RAPIDJSON_ENDIAN
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_64BIT
-
-//! Whether using 64-bit architecture
-#ifndef RAPIDJSON_64BIT
-#if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__)
-#define RAPIDJSON_64BIT 1
-#else
-#define RAPIDJSON_64BIT 0
-#endif
-#endif // RAPIDJSON_64BIT
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ALIGN
-
-//! Data alignment of the machine.
-/*! \ingroup RAPIDJSON_CONFIG
-    \param x pointer to align
-
-    Some machines require strict data alignment. The default is 8 bytes.
-    User can customize by defining the RAPIDJSON_ALIGN function macro.
-*/
-#ifndef RAPIDJSON_ALIGN
-#define RAPIDJSON_ALIGN(x) (((x) + static_cast<size_t>(7u)) & ~static_cast<size_t>(7u))
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_UINT64_C2
-
-//! Construct a 64-bit literal by a pair of 32-bit integer.
-/*!
-    64-bit literal with or without ULL suffix is prone to compiler warnings.
-    UINT64_C() is C macro which cause compilation problems.
-    Use this macro to define 64-bit constants by a pair of 32-bit integer.
-*/
-#ifndef RAPIDJSON_UINT64_C2
-#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_48BITPOINTER_OPTIMIZATION
-
-//! Use only lower 48-bit address for some pointers.
-/*!
-    \ingroup RAPIDJSON_CONFIG
-
-    This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address.
-    The higher 16-bit can be used for storing other data.
-    \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture.
-*/
-#ifndef RAPIDJSON_48BITPOINTER_OPTIMIZATION
-#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
-#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 1
-#else
-#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 0
-#endif
-#endif // RAPIDJSON_48BITPOINTER_OPTIMIZATION
-
-#if RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1
-#if RAPIDJSON_64BIT != 1
-#error RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when RAPIDJSON_64BIT=1
-#endif
-#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x))))
-#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
-#else
-#define RAPIDJSON_SETPOINTER(type, p, x) (p = (x))
-#define RAPIDJSON_GETPOINTER(type, p) (p)
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_NEON/RAPIDJSON_SIMD
-
-/*! \def RAPIDJSON_SIMD
-    \ingroup RAPIDJSON_CONFIG
-    \brief Enable SSE2/SSE4.2/Neon optimization.
-
-    RapidJSON supports optimized implementations for some parsing operations
-    based on the SSE2, SSE4.2 or NEon SIMD extensions on modern Intel
-    or ARM compatible processors.
-
-    To enable these optimizations, three different symbols can be defined;
-    \code
-    // Enable SSE2 optimization.
-    #define RAPIDJSON_SSE2
-
-    // Enable SSE4.2 optimization.
-    #define RAPIDJSON_SSE42
-    \endcode
-
-    // Enable ARM Neon optimization.
-    #define RAPIDJSON_NEON
-    \endcode
-
-    \c RAPIDJSON_SSE42 takes precedence over SSE2, if both are defined.
-
-    If any of these symbols is defined, RapidJSON defines the macro
-    \c RAPIDJSON_SIMD to indicate the availability of the optimized code.
-*/
-#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \
-    || defined(RAPIDJSON_NEON) || defined(RAPIDJSON_DOXYGEN_RUNNING)
-#define RAPIDJSON_SIMD
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NO_SIZETYPEDEFINE
-
-#ifndef RAPIDJSON_NO_SIZETYPEDEFINE
-/*! \def RAPIDJSON_NO_SIZETYPEDEFINE
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-provided \c SizeType definition.
-
-    In order to avoid using 32-bit size types for indexing strings and arrays,
-    define this preprocessor symbol and provide the type rapidjson::SizeType
-    before including RapidJSON:
-    \code
-    #define RAPIDJSON_NO_SIZETYPEDEFINE
-    namespace rapidjson { typedef ::std::size_t SizeType; }
-    #include "rapidjson/..."
-    \endcode
-
-    \see rapidjson::SizeType
-*/
-#ifdef RAPIDJSON_DOXYGEN_RUNNING
-#define RAPIDJSON_NO_SIZETYPEDEFINE
-#endif
-RAPIDJSON_NAMESPACE_BEGIN
-//! Size type (for string lengths, array sizes, etc.)
-/*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,
-    instead of using \c size_t. Users may override the SizeType by defining
-    \ref RAPIDJSON_NO_SIZETYPEDEFINE.
-*/
-typedef unsigned SizeType;
-RAPIDJSON_NAMESPACE_END
-#endif
-
-// always import std::size_t to rapidjson namespace
-RAPIDJSON_NAMESPACE_BEGIN
-using std::size_t;
-RAPIDJSON_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ASSERT
-
-//! Assertion.
-/*! \ingroup RAPIDJSON_CONFIG
-    By default, rapidjson uses C \c assert() for internal assertions.
-    User can override it by defining RAPIDJSON_ASSERT(x) macro.
-
-    \note Parsing errors are handled and can be customized by the
-          \ref RAPIDJSON_ERRORS APIs.
-*/
-#ifndef RAPIDJSON_ASSERT
-#include "world_builder/assert.h"
-#define RAPIDJSON_ASSERT(x) WBAssertThrow(x, "RapidJSON error.")
-#endif // RAPIDJSON_ASSERT
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_STATIC_ASSERT
-
-// Prefer C++11 static_assert, if available
-#ifndef RAPIDJSON_STATIC_ASSERT
-#if __cplusplus >= 201103L || ( defined(_MSC_VER) && _MSC_VER >= 1800 )
-#define RAPIDJSON_STATIC_ASSERT(x) \
-  static_assert(x, RAPIDJSON_STRINGIFY(x))
-#endif // C++11
-#endif // RAPIDJSON_STATIC_ASSERT
-
-// Adopt C++03 implementation from boost
-#ifndef RAPIDJSON_STATIC_ASSERT
-#ifndef __clang__
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#endif
-RAPIDJSON_NAMESPACE_BEGIN
-template <bool x> struct STATIC_ASSERTION_FAILURE;
-template <> struct STATIC_ASSERTION_FAILURE<true>
-{
-  enum { value = 1 };
-};
-template <size_t x> struct StaticAssertTest {};
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__GNUC__) || defined(__clang__)
-#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
-#else
-#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
-#endif
-#ifndef __clang__
-//!@endcond
-#endif
-
-/*! \def RAPIDJSON_STATIC_ASSERT
-    \brief (Internal) macro to check for conditions at compile-time
-    \param x compile-time condition
-    \hideinitializer
- */
-#define RAPIDJSON_STATIC_ASSERT(x) \
-  typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \
-  sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
-  RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
-#endif // RAPIDJSON_STATIC_ASSERT
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY
-
-//! Compiler branching hint for expression with high probability to be true.
-/*!
-    \ingroup RAPIDJSON_CONFIG
-    \param x Boolean expression likely to be true.
-*/
-#ifndef RAPIDJSON_LIKELY
-#if defined(__GNUC__) || defined(__clang__)
-#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
-#else
-#define RAPIDJSON_LIKELY(x) (x)
-#endif
-#endif
-
-//! Compiler branching hint for expression with low probability to be true.
-/*!
-    \ingroup RAPIDJSON_CONFIG
-    \param x Boolean expression unlikely to be true.
-*/
-#ifndef RAPIDJSON_UNLIKELY
-#if defined(__GNUC__) || defined(__clang__)
-#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
-#else
-#define RAPIDJSON_UNLIKELY(x) (x)
-#endif
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// Helpers
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-
-#define RAPIDJSON_MULTILINEMACRO_BEGIN do {
-#define RAPIDJSON_MULTILINEMACRO_END \
-  } while((void)0, 0)
-
-// adopted from Boost
-#define RAPIDJSON_VERSION_CODE(x,y,z) \
-  (((x)*100000) + ((y)*100) + (z))
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF
-
-#if defined(__GNUC__)
-#define RAPIDJSON_GNUC \
-  RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
-#endif
-
-#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0))
-
-#define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x))
-#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x)
-#define RAPIDJSON_DIAG_OFF(x) \
-  RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x)))
-
-// push/pop support in Clang and GCC>=4.6
-#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0))
-#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
-#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
-#else // GCC >= 4.2, < 4.6
-#define RAPIDJSON_DIAG_PUSH /* ignored */
-#define RAPIDJSON_DIAG_POP /* ignored */
-#endif
-
-#elif defined(_MSC_VER)
-
-// pragma (MSVC specific)
-#define RAPIDJSON_PRAGMA(x) __pragma(x)
-#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x))
-
-#define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x)
-#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
-#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
-
-#else
-
-#define RAPIDJSON_DIAG_OFF(x) /* ignored */
-#define RAPIDJSON_DIAG_PUSH   /* ignored */
-#define RAPIDJSON_DIAG_POP    /* ignored */
-
-#endif // RAPIDJSON_DIAG_*
-
-///////////////////////////////////////////////////////////////////////////////
-// C++11 features
-
-#ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
-#if defined(__clang__)
-#if __has_feature(cxx_rvalue_references) && \
-    (defined(_MSC_VER) || defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
-#else
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
-#endif
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
-      (defined(_MSC_VER) && _MSC_VER >= 1600) || \
-      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
-
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
-#else
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
-#endif
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-#ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
-#if defined(__clang__)
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
-    (defined(_MSC_VER) && _MSC_VER >= 1900) || \
-    (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
-#else
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
-#endif
-#endif
-#if RAPIDJSON_HAS_CXX11_NOEXCEPT
-#define RAPIDJSON_NOEXCEPT noexcept
-#else
-#define RAPIDJSON_NOEXCEPT /* noexcept */
-#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
-
-// no automatic detection, yet
-#ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
-#if (defined(_MSC_VER) && _MSC_VER >= 1700)
-#define RAPIDJSON_HAS_CXX11_TYPETRAITS 1
-#else
-#define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
-#endif
-#endif
-
-#ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR
-#if defined(__clang__)
-#define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
-      (defined(_MSC_VER) && _MSC_VER >= 1700) || \
-      (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 && defined(__GXX_EXPERIMENTAL_CXX0X__))
-#define RAPIDJSON_HAS_CXX11_RANGE_FOR 1
-#else
-#define RAPIDJSON_HAS_CXX11_RANGE_FOR 0
-#endif
-#endif // RAPIDJSON_HAS_CXX11_RANGE_FOR
-
-//!@endcond
-
-//! Assertion (in non-throwing contexts).
-/*! \ingroup RAPIDJSON_CONFIG
-   Some functions provide a \c noexcept guarantee, if the compiler supports it.
-   In these cases, the \ref RAPIDJSON_ASSERT macro cannot be overridden to
-   throw an exception.  This macro adds a separate customization point for
-   such cases.
-
-   Defaults to C \c assert() (as \ref RAPIDJSON_ASSERT), if \c noexcept is
-   supported, and to \ref RAPIDJSON_ASSERT otherwise.
-*/
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NOEXCEPT_ASSERT
-
-#ifdef RAPIDJSON_ASSERT_THROWS
-#if RAPIDJSON_HAS_CXX11_NOEXCEPT
-#define RAPIDJSON_NOEXCEPT_ASSERT(x)
-#else
-#include<cassert>
-#define RAPIDJSON_NOEXCEPT_ASSERT(x) assert(x)
-#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
-#else
-#include<cassert>
-#define RAPIDJSON_NOEXCEPT_ASSERT(x) assert(x)
-#endif // RAPIDJSON_ASSERT_THROWS
-
-///////////////////////////////////////////////////////////////////////////////
-// new/delete
-
-#ifndef RAPIDJSON_NEW
-///! customization point for global \c new
-#define RAPIDJSON_NEW(TypeName) new TypeName
-#endif
-#ifndef RAPIDJSON_DELETE
-///! customization point for global \c delete
-#define RAPIDJSON_DELETE(x) delete x
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// Type
-
-/*! \namespace rapidjson
-    \brief main RapidJSON namespace
-    \see RAPIDJSON_NAMESPACE
-*/
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Type of JSON value
-enum Type
-{
-  kNullType = 0,      //!< null
-  kFalseType = 1,     //!< false
-  kTrueType = 2,      //!< true
-  kObjectType = 3,    //!< object
-  kArrayType = 4,     //!< array
-  kStringType = 5,    //!< string
-  kNumberType = 6     //!< number
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/rapidjson/reader.h.bak b/contrib/world_builder/include/rapidjson/reader.h.bak
deleted file mode 100644
index 064a3e56ba8..00000000000
--- a/contrib/world_builder/include/rapidjson/reader.h.bak
+++ /dev/null
@@ -1,2574 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_READER_H_
-#define RAPIDJSON_READER_H_
-
-/*! \file reader.h */
-
-#include "allocators.h"
-#include "stream.h"
-#include "encodedstream.h"
-#include "internal/meta.h"
-#include "internal/stack.h"
-#include "internal/strtod.h"
-#include <limits>
-
-#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
-#include <intrin.h>
-#pragma intrinsic(_BitScanForward)
-#endif
-#ifdef RAPIDJSON_SSE42
-#include <nmmintrin.h>
-#elif defined(RAPIDJSON_SSE2)
-#include <emmintrin.h>
-#elif defined(RAPIDJSON_NEON)
-#include <arm_neon.h>
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(old-style-cast)
-RAPIDJSON_DIAG_OFF(padded)
-//RAPIDJSON_DIAG_OFF(switch -enum)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127)  // conditional expression is constant
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#define RAPIDJSON_NOTHING /* deliberately empty */
-#ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN
-#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \
-  RAPIDJSON_MULTILINEMACRO_BEGIN \
-  if (RAPIDJSON_UNLIKELY(HasParseError())) { return value; } \
-  RAPIDJSON_MULTILINEMACRO_END
-#endif
-#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \
-  RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
-//!@endcond
-
-/*! \def RAPIDJSON_PARSE_ERROR_NORETURN
-    \ingroup RAPIDJSON_ERRORS
-    \brief Macro to indicate a parse error.
-    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
-    \param offset  position of the error in JSON input (\c size_t)
-
-    This macros can be used as a customization point for the internal
-    error handling mechanism of RapidJSON.
-
-    A common usage model is to throw an exception instead of requiring the
-    caller to explicitly check the \ref rapidjson::GenericReader::Parse's
-    return value:
-
-    \code
-    #define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \
-       throw ParseException(parseErrorCode, #parseErrorCode, offset)
-
-    #include <stdexcept>               // std::runtime_error
-    #include "rapidjson/error/error.h" // rapidjson::ParseResult
-
-    struct ParseException : std::runtime_error, rapidjson::ParseResult {
-      ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset)
-        : std::runtime_error(msg), ParseResult(code, offset) {}
-    };
-
-    #include "rapidjson/reader.h"
-    \endcode
-
-    \see RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse
- */
-#ifndef RAPIDJSON_PARSE_ERROR_NORETURN
-#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \
-  RAPIDJSON_MULTILINEMACRO_BEGIN \
-  RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
-  SetParseError(parseErrorCode, offset); \
-  RAPIDJSON_MULTILINEMACRO_END
-#endif
-
-/*! \def RAPIDJSON_PARSE_ERROR
-    \ingroup RAPIDJSON_ERRORS
-    \brief (Internal) macro to indicate and handle a parse error.
-    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
-    \param offset  position of the error in JSON input (\c size_t)
-
-    Invokes RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing.
-
-    \see RAPIDJSON_PARSE_ERROR_NORETURN
-    \hideinitializer
- */
-#ifndef RAPIDJSON_PARSE_ERROR
-#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \
-  RAPIDJSON_MULTILINEMACRO_BEGIN \
-  RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
-  RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
-  RAPIDJSON_MULTILINEMACRO_END
-#endif
-
-#include "error/error.h" // ParseErrorCode, ParseResult
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// ParseFlag
-
-/*! \def RAPIDJSON_PARSE_DEFAULT_FLAGS
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-defined kParseDefaultFlags definition.
-
-    User can define this as any \c ParseFlag combinations.
-*/
-#ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS
-#define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags
-#endif
-
-//! Combination of parseFlags
-/*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream
- */
-enum ParseFlag
-{
-  kParseNoFlags = 0,              //!< No flags are set.
-  kParseInsituFlag = 1,           //!< In-situ(destructive) parsing.
-  kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings.
-  kParseIterativeFlag = 4,        //!< Iterative(constant complexity in terms of function call stack size) parsing.
-  kParseStopWhenDoneFlag = 8,     //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error.
-  kParseFullPrecisionFlag = 16,   //!< Parse number in full precision (but slower).
-  kParseCommentsFlag = 32,        //!< Allow one-line (//) and multi-line (/**/) comments.
-  kParseNumbersAsStringsFlag = 64,    //!< Parse all numbers (ints/doubles) as strings.
-  kParseTrailingCommasFlag = 128, //!< Allow trailing commas at the end of objects and arrays.
-  kParseNanAndInfFlag = 256,      //!< Allow parsing NaN, Inf, Infinity, -Inf and -Infinity as doubles.
-  kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS  //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Handler
-
-/*! \class rapidjson::Handler
-    \brief Concept for receiving events from GenericReader upon parsing.
-    The functions return true if no error occurs. If they return false,
-    the event publisher should terminate the process.
-\code
-concept Handler {
-    typename Ch;
-
-    bool Null();
-    bool Bool(bool b);
-    bool Int(int i);
-    bool Uint(unsigned i);
-    bool Int64(int64_t i);
-    bool Uint64(uint64_t i);
-    bool Double(double d);
-    /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
-    bool RawNumber(const Ch* str, SizeType length, bool copy);
-    bool String(const Ch* str, SizeType length, bool copy);
-    bool StartObject();
-    bool Key(const Ch* str, SizeType length, bool copy);
-    bool EndObject(SizeType memberCount);
-    bool StartArray();
-    bool EndArray(SizeType elementCount);
-};
-\endcode
-*/
-///////////////////////////////////////////////////////////////////////////////
-// BaseReaderHandler
-
-//! Default implementation of Handler.
-/*! This can be used as base class of any reader handler.
-    \note implements Handler concept
-*/
-template<typename Encoding = UTF8<>, typename Derived = void>
-struct BaseReaderHandler
-{
-  typedef typename Encoding::Ch Ch;
-
-  typedef typename internal::SelectIf<internal::IsSame<Derived, void>, BaseReaderHandler, Derived>::Type Override;
-
-  bool Default()
-  {
-    return true;
-  }
-  bool Null()
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool Bool(bool)
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool Int(int)
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool Uint(unsigned)
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool Int64(int64_t)
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool Uint64(uint64_t)
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool Double(double)
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  /// enabled via kParseNumbersAsStringsFlag, string is not null-terminated (use length)
-  bool RawNumber(const Ch *str, SizeType len, bool copy)
-  {
-    return static_cast<Override &>(*this).String(str, len, copy);
-  }
-  bool String(const Ch *, SizeType, bool)
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool StartObject()
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool Key(const Ch *str, SizeType len, bool copy)
-  {
-    return static_cast<Override &>(*this).String(str, len, copy);
-  }
-  bool EndObject(SizeType)
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool StartArray()
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-  bool EndArray(SizeType)
-  {
-    return static_cast<Override &>(*this).Default();
-  }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// StreamLocalCopy
-
-namespace internal
-{
-
-  template<typename Stream, int = StreamTraits<Stream>::copyOptimization>
-  class StreamLocalCopy;
-
-//! Do copy optimization.
-  template<typename Stream>
-  class StreamLocalCopy<Stream, 1>
-  {
-    public:
-      StreamLocalCopy(Stream &original) : s(original), original_(original) {}
-      ~StreamLocalCopy()
-      {
-        original_ = s;
-      }
-
-      Stream s;
-
-    private:
-      StreamLocalCopy &operator=(const StreamLocalCopy &) /* = delete */;
-
-      Stream &original_;
-  };
-
-//! Keep reference.
-  template<typename Stream>
-  class StreamLocalCopy<Stream, 0>
-  {
-    public:
-      StreamLocalCopy(Stream &original) : s(original) {}
-
-      Stream &s;
-
-    private:
-      StreamLocalCopy &operator=(const StreamLocalCopy &) /* = delete */;
-  };
-
-} // namespace internal
-
-///////////////////////////////////////////////////////////////////////////////
-// SkipWhitespace
-
-//! Skip the JSON white spaces in a stream.
-/*! \param is A input stream for skipping white spaces.
-    \note This function has SSE2/SSE4.2 specialization.
-*/
-template<typename InputStream>
-void SkipWhitespace(InputStream &is)
-{
-  internal::StreamLocalCopy<InputStream> copy(is);
-  InputStream &s(copy.s);
-
-  typename InputStream::Ch c;
-  while ((c = s.Peek()) == ' ' || c == '\n' || c == '\r' || c == '\t')
-    s.Take();
-}
-
-inline const char *SkipWhitespace(const char *p, const char *end)
-{
-  while (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
-    ++p;
-  return p;
-}
-
-#ifdef RAPIDJSON_SSE42
-//! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once.
-inline const char *SkipWhitespace_SIMD(const char *p)
-{
-  // Fast return for single non-whitespace
-  if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-    ++p;
-  else
-    return p;
-
-  // 16-byte align to the next boundary
-  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-  while (p != nextAligned)
-    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-      ++p;
-    else
-      return p;
-
-  // The rest of string using SIMD
-  static const char whitespace[16] = " \n\r\t";
-  const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
-
-  for (;; p += 16)
-    {
-      const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-      const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
-      if (r != 16)    // some of characters is non-whitespace
-        return p + r;
-    }
-}
-
-inline const char *SkipWhitespace_SIMD(const char *p, const char *end)
-{
-  // Fast return for single non-whitespace
-  if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
-    ++p;
-  else
-    return p;
-
-  // The middle of string using SIMD
-  static const char whitespace[16] = " \n\r\t";
-  const __m128i w = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespace[0]));
-
-  for (; p <= end - 16; p += 16)
-    {
-      const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
-      const int r = _mm_cmpistri(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT | _SIDD_NEGATIVE_POLARITY);
-      if (r != 16)    // some of characters is non-whitespace
-        return p + r;
-    }
-
-  return SkipWhitespace(p, end);
-}
-
-#elif defined(RAPIDJSON_SSE2)
-
-//! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once.
-inline const char *SkipWhitespace_SIMD(const char *p)
-{
-  // Fast return for single non-whitespace
-  if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-    ++p;
-  else
-    return p;
-
-  // 16-byte align to the next boundary
-  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-  while (p != nextAligned)
-    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-      ++p;
-    else
-      return p;
-
-  // The rest of string
-#define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
-  static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
-#undef C16
-
-  const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
-  const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
-  const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
-  const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
-
-  for (;; p += 16)
-    {
-      const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-      __m128i x = _mm_cmpeq_epi8(s, w0);
-      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
-      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
-      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
-      unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
-      if (r != 0)     // some of characters may be non-whitespace
-        {
-#ifdef _MSC_VER         // Find the index of first non-whitespace
-          unsigned long offset;
-          _BitScanForward(&offset, r);
-          return p + offset;
-#else
-          return p + __builtin_ffs(r) - 1;
-#endif
-        }
-    }
-}
-
-inline const char *SkipWhitespace_SIMD(const char *p, const char *end)
-{
-  // Fast return for single non-whitespace
-  if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
-    ++p;
-  else
-    return p;
-
-  // The rest of string
-#define C16(c) { c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c }
-  static const char whitespaces[4][16] = { C16(' '), C16('\n'), C16('\r'), C16('\t') };
-#undef C16
-
-  const __m128i w0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[0][0]));
-  const __m128i w1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[1][0]));
-  const __m128i w2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[2][0]));
-  const __m128i w3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&whitespaces[3][0]));
-
-  for (; p <= end - 16; p += 16)
-    {
-      const __m128i s = _mm_loadu_si128(reinterpret_cast<const __m128i *>(p));
-      __m128i x = _mm_cmpeq_epi8(s, w0);
-      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
-      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
-      x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
-      unsigned short r = static_cast<unsigned short>(~_mm_movemask_epi8(x));
-      if (r != 0)     // some of characters may be non-whitespace
-        {
-#ifdef _MSC_VER         // Find the index of first non-whitespace
-          unsigned long offset;
-          _BitScanForward(&offset, r);
-          return p + offset;
-#else
-          return p + __builtin_ffs(r) - 1;
-#endif
-        }
-    }
-
-  return SkipWhitespace(p, end);
-}
-
-#elif defined(RAPIDJSON_NEON)
-
-//! Skip whitespace with ARM Neon instructions, testing 16 8-byte characters at once.
-inline const char *SkipWhitespace_SIMD(const char *p)
-{
-  // Fast return for single non-whitespace
-  if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-    ++p;
-  else
-    return p;
-
-  // 16-byte align to the next boundary
-  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-  while (p != nextAligned)
-    if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-      ++p;
-    else
-      return p;
-
-  const uint8x16_t w0 = vmovq_n_u8(' ');
-  const uint8x16_t w1 = vmovq_n_u8('\n');
-  const uint8x16_t w2 = vmovq_n_u8('\r');
-  const uint8x16_t w3 = vmovq_n_u8('\t');
-
-  for (;; p += 16)
-    {
-      const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
-      uint8x16_t x = vceqq_u8(s, w0);
-      x = vorrq_u8(x, vceqq_u8(s, w1));
-      x = vorrq_u8(x, vceqq_u8(s, w2));
-      x = vorrq_u8(x, vceqq_u8(s, w3));
-
-      x = vmvnq_u8(x);                       // Negate
-      x = vrev64q_u8(x);                     // Rev in 64
-      uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-      uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
-
-      if (low == 0)
-        {
-          if (high != 0)
-            {
-              int lz =__builtin_clzll(high);;
-              return p + 8 + (lz >> 3);
-            }
-        }
-      else
-        {
-          int lz = __builtin_clzll(low);;
-          return p + (lz >> 3);
-        }
-    }
-}
-
-inline const char *SkipWhitespace_SIMD(const char *p, const char *end)
-{
-  // Fast return for single non-whitespace
-  if (p != end && (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t'))
-    ++p;
-  else
-    return p;
-
-  const uint8x16_t w0 = vmovq_n_u8(' ');
-  const uint8x16_t w1 = vmovq_n_u8('\n');
-  const uint8x16_t w2 = vmovq_n_u8('\r');
-  const uint8x16_t w3 = vmovq_n_u8('\t');
-
-  for (; p <= end - 16; p += 16)
-    {
-      const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
-      uint8x16_t x = vceqq_u8(s, w0);
-      x = vorrq_u8(x, vceqq_u8(s, w1));
-      x = vorrq_u8(x, vceqq_u8(s, w2));
-      x = vorrq_u8(x, vceqq_u8(s, w3));
-
-      x = vmvnq_u8(x);                       // Negate
-      x = vrev64q_u8(x);                     // Rev in 64
-      uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-      uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
-
-      if (low == 0)
-        {
-          if (high != 0)
-            {
-              int lz = __builtin_clzll(high);
-              return p + 8 + (lz >> 3);
-            }
-        }
-      else
-        {
-          int lz = __builtin_clzll(low);
-          return p + (lz >> 3);
-        }
-    }
-
-  return SkipWhitespace(p, end);
-}
-
-#endif // RAPIDJSON_NEON
-
-#ifdef RAPIDJSON_SIMD
-//! Template function specialization for InsituStringStream
-template<> inline void SkipWhitespace(InsituStringStream &is)
-{
-  is.src_ = const_cast<char *>(SkipWhitespace_SIMD(is.src_));
-}
-
-//! Template function specialization for StringStream
-template<> inline void SkipWhitespace(StringStream &is)
-{
-  is.src_ = SkipWhitespace_SIMD(is.src_);
-}
-
-template<> inline void SkipWhitespace(EncodedInputStream<UTF8<>, MemoryStream> &is)
-{
-  is.is_.src_ = SkipWhitespace_SIMD(is.is_.src_, is.is_.end_);
-}
-#endif // RAPIDJSON_SIMD
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericReader
-
-//! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator.
-/*! GenericReader parses JSON text from a stream, and send events synchronously to an
-    object implementing Handler concept.
-
-    It needs to allocate a stack for storing a single decoded string during
-    non-destructive parsing.
-
-    For in-situ parsing, the decoded string is directly written to the source
-    text string, no temporary buffer is required.
-
-    A GenericReader object can be reused for parsing multiple JSON text.
-
-    \tparam SourceEncoding Encoding of the input stream.
-    \tparam TargetEncoding Encoding of the parse output.
-    \tparam StackAllocator Allocator type for stack.
-*/
-template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>
-class GenericReader
-{
-  public:
-    typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type
-
-    //! Constructor.
-    /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
-        \param stackCapacity stack capacity in bytes for storing a single decoded string.  (Only use for non-destructive parsing)
-    */
-    GenericReader(StackAllocator *stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) :
-      stack_(stackAllocator, stackCapacity), parseResult_(), state_(IterativeParsingStartState) {}
-
-    //! Parse JSON text.
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \tparam InputStream Type of input stream, implementing Stream concept.
-        \tparam Handler Type of handler, implementing Handler concept.
-        \param is Input stream to be parsed.
-        \param handler The handler to receive events.
-        \return Whether the parsing is successful.
-    */
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    ParseResult Parse(InputStream &is, Handler &handler)
-    {
-      if (parseFlags & kParseIterativeFlag)
-        return IterativeParse<parseFlags>(is, handler);
-
-      parseResult_.Clear();
-
-      ClearStackOnExit scope(*this);
-
-      SkipWhitespaceAndComments<parseFlags>(is);
-      RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-
-      if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
-        {
-          RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-        }
-      else
-        {
-          ParseValue<parseFlags>(is, handler);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-
-          if (!(parseFlags & kParseStopWhenDoneFlag))
-            {
-              SkipWhitespaceAndComments<parseFlags>(is);
-              RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-
-              if (RAPIDJSON_UNLIKELY(is.Peek() != '\0'))
-                {
-                  RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
-                  RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-                }
-            }
-        }
-
-      return parseResult_;
-    }
-
-    //! Parse JSON text (with \ref kParseDefaultFlags)
-    /*! \tparam InputStream Type of input stream, implementing Stream concept
-        \tparam Handler Type of handler, implementing Handler concept.
-        \param is Input stream to be parsed.
-        \param handler The handler to receive events.
-        \return Whether the parsing is successful.
-    */
-    template <typename InputStream, typename Handler>
-    ParseResult Parse(InputStream &is, Handler &handler)
-    {
-      return Parse<kParseDefaultFlags>(is, handler);
-    }
-
-    //! Initialize JSON text token-by-token parsing
-    /*!
-     */
-    void IterativeParseInit()
-    {
-      parseResult_.Clear();
-      state_ = IterativeParsingStartState;
-    }
-
-    //! Parse one token from JSON text
-    /*! \tparam InputStream Type of input stream, implementing Stream concept
-        \tparam Handler Type of handler, implementing Handler concept.
-        \param is Input stream to be parsed.
-        \param handler The handler to receive events.
-        \return Whether the parsing is successful.
-     */
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    bool IterativeParseNext(InputStream &is, Handler &handler)
-    {
-      while (RAPIDJSON_LIKELY(is.Peek() != '\0'))
-        {
-          SkipWhitespaceAndComments<parseFlags>(is);
-
-          Token t = Tokenize(is.Peek());
-          IterativeParsingState n = Predict(state_, t);
-          IterativeParsingState d = Transit<parseFlags>(state_, t, n, is, handler);
-
-          // If we've finished or hit an error...
-          if (RAPIDJSON_UNLIKELY(IsIterativeParsingCompleteState(d)))
-            {
-              // Report errors.
-              if (d == IterativeParsingErrorState)
-                {
-                  HandleError(state_, is);
-                  return false;
-                }
-
-              // Transition to the finish state.
-              RAPIDJSON_ASSERT(d == IterativeParsingFinishState);
-              state_ = d;
-
-              // If StopWhenDone is not set...
-              if (!(parseFlags & kParseStopWhenDoneFlag))
-                {
-                  // ... and extra non-whitespace data is found...
-                  SkipWhitespaceAndComments<parseFlags>(is);
-                  if (is.Peek() != '\0')
-                    {
-                      // ... this is considered an error.
-                      HandleError(state_, is);
-                      return false;
-                    }
-                }
-
-              // Success! We are done!
-              return true;
-            }
-
-          // Transition to the new state.
-          state_ = d;
-
-          // If we parsed anything other than a delimiter, we invoked the handler, so we can return true now.
-          if (!IsIterativeParsingDelimiterState(n))
-            return true;
-        }
-
-      // We reached the end of file.
-      stack_.Clear();
-
-      if (state_ != IterativeParsingFinishState)
-        {
-          HandleError(state_, is);
-          return false;
-        }
-
-      return true;
-    }
-
-    //! Check if token-by-token parsing JSON text is complete
-    /*! \return Whether the JSON has been fully decoded.
-     */
-    RAPIDJSON_FORCEINLINE bool IterativeParseComplete() const
-    {
-      return IsIterativeParsingCompleteState(state_);
-    }
-
-    //! Whether a parse error has occurred in the last parsing.
-    bool HasParseError() const
-    {
-      return parseResult_.IsError();
-    }
-
-    //! Get the \ref ParseErrorCode of last parsing.
-    ParseErrorCode GetParseErrorCode() const
-    {
-      return parseResult_.Code();
-    }
-
-    //! Get the position of last parsing error in input, 0 otherwise.
-    size_t GetErrorOffset() const
-    {
-      return parseResult_.Offset();
-    }
-
-  protected:
-    void SetParseError(ParseErrorCode code, size_t offset)
-    {
-      parseResult_.Set(code, offset);
-    }
-
-  private:
-    // Prohibit copy constructor & assignment operator.
-    GenericReader(const GenericReader &);
-    GenericReader &operator=(const GenericReader &);
-
-    void ClearStack()
-    {
-      stack_.Clear();
-    }
-
-    // clear stack on any exit from ParseStream, e.g. due to exception
-    struct ClearStackOnExit
-    {
-        explicit ClearStackOnExit(GenericReader &r) : r_(r) {}
-        ~ClearStackOnExit()
-        {
-          r_.ClearStack();
-        }
-      private:
-        GenericReader &r_;
-        ClearStackOnExit(const ClearStackOnExit &);
-        ClearStackOnExit &operator=(const ClearStackOnExit &);
-    };
-
-    template<unsigned parseFlags, typename InputStream>
-    void SkipWhitespaceAndComments(InputStream &is)
-    {
-      SkipWhitespace(is);
-
-      if (parseFlags & kParseCommentsFlag)
-        {
-          while (RAPIDJSON_UNLIKELY(Consume(is, '/')))
-            {
-              if (Consume(is, '*'))
-                {
-                  while (true)
-                    {
-                      if (RAPIDJSON_UNLIKELY(is.Peek() == '\0'))
-                        RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
-                      else if (Consume(is, '*'))
-                        {
-                          if (Consume(is, '/'))
-                            break;
-                        }
-                      else
-                        is.Take();
-                    }
-                }
-              else if (RAPIDJSON_LIKELY(Consume(is, '/')))
-                while (is.Peek() != '\0' && is.Take() != '\n') {}
-              else
-                RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
-
-              SkipWhitespace(is);
-            }
-        }
-    }
-
-    // Parse object: { string : value, ... }
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseObject(InputStream &is, Handler &handler)
-    {
-      RAPIDJSON_ASSERT(is.Peek() == '{');
-      is.Take();  // Skip '{'
-
-      if (RAPIDJSON_UNLIKELY(!handler.StartObject()))
-        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-
-      SkipWhitespaceAndComments<parseFlags>(is);
-      RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-      if (Consume(is, '}'))
-        {
-          if (RAPIDJSON_UNLIKELY(!handler.EndObject(0)))  // empty object
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-          return;
-        }
-
-      for (SizeType memberCount = 0;;)
-        {
-          if (RAPIDJSON_UNLIKELY(is.Peek() != '"'))
-            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
-
-          ParseString<parseFlags>(is, handler, true);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-          SkipWhitespaceAndComments<parseFlags>(is);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-          if (RAPIDJSON_UNLIKELY(!Consume(is, ':')))
-            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
-
-          SkipWhitespaceAndComments<parseFlags>(is);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-          ParseValue<parseFlags>(is, handler);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-          SkipWhitespaceAndComments<parseFlags>(is);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-          ++memberCount;
-
-          switch (is.Peek())
-            {
-              case ',':
-                is.Take();
-                SkipWhitespaceAndComments<parseFlags>(is);
-                RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-                break;
-              case '}':
-                is.Take();
-                if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
-                  RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-                return;
-              default:
-                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());
-                break; // This useless break is only for making warning and coverage happy
-            }
-
-          if (parseFlags & kParseTrailingCommasFlag)
-            {
-              if (is.Peek() == '}')
-                {
-                  if (RAPIDJSON_UNLIKELY(!handler.EndObject(memberCount)))
-                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-                  is.Take();
-                  return;
-                }
-            }
-        }
-    }
-
-    // Parse array: [ value, ... ]
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseArray(InputStream &is, Handler &handler)
-    {
-      RAPIDJSON_ASSERT(is.Peek() == '[');
-      is.Take();  // Skip '['
-
-      if (RAPIDJSON_UNLIKELY(!handler.StartArray()))
-        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-
-      SkipWhitespaceAndComments<parseFlags>(is);
-      RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-      if (Consume(is, ']'))
-        {
-          if (RAPIDJSON_UNLIKELY(!handler.EndArray(0))) // empty array
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-          return;
-        }
-
-      for (SizeType elementCount = 0;;)
-        {
-          ParseValue<parseFlags>(is, handler);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-          ++elementCount;
-          SkipWhitespaceAndComments<parseFlags>(is);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-          if (Consume(is, ','))
-            {
-              SkipWhitespaceAndComments<parseFlags>(is);
-              RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-            }
-          else if (Consume(is, ']'))
-            {
-              if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-              return;
-            }
-          else
-            RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
-
-          if (parseFlags & kParseTrailingCommasFlag)
-            {
-              if (is.Peek() == ']')
-                {
-                  if (RAPIDJSON_UNLIKELY(!handler.EndArray(elementCount)))
-                    RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-                  is.Take();
-                  return;
-                }
-            }
-        }
-    }
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseNull(InputStream &is, Handler &handler)
-    {
-      RAPIDJSON_ASSERT(is.Peek() == 'n');
-      is.Take();
-
-      if (RAPIDJSON_LIKELY(Consume(is, 'u') && Consume(is, 'l') && Consume(is, 'l')))
-        {
-          if (RAPIDJSON_UNLIKELY(!handler.Null()))
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        }
-      else
-        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
-    }
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseTrue(InputStream &is, Handler &handler)
-    {
-      RAPIDJSON_ASSERT(is.Peek() == 't');
-      is.Take();
-
-      if (RAPIDJSON_LIKELY(Consume(is, 'r') && Consume(is, 'u') && Consume(is, 'e')))
-        {
-          if (RAPIDJSON_UNLIKELY(!handler.Bool(true)))
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        }
-      else
-        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
-    }
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseFalse(InputStream &is, Handler &handler)
-    {
-      RAPIDJSON_ASSERT(is.Peek() == 'f');
-      is.Take();
-
-      if (RAPIDJSON_LIKELY(Consume(is, 'a') && Consume(is, 'l') && Consume(is, 's') && Consume(is, 'e')))
-        {
-          if (RAPIDJSON_UNLIKELY(!handler.Bool(false)))
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        }
-      else
-        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
-    }
-
-    template<typename InputStream>
-    RAPIDJSON_FORCEINLINE static bool Consume(InputStream &is, typename InputStream::Ch expect)
-    {
-      if (RAPIDJSON_LIKELY(is.Peek() == expect))
-        {
-          is.Take();
-          return true;
-        }
-      else
-        return false;
-    }
-
-    // Helper function to parse four hexadecimal digits in \uXXXX in ParseString().
-    template<typename InputStream>
-    unsigned ParseHex4(InputStream &is, size_t escapeOffset)
-    {
-      unsigned codepoint = 0;
-      for (int i = 0; i < 4; i++)
-        {
-          Ch c = is.Peek();
-          codepoint <<= 4;
-          codepoint += static_cast<unsigned>(c);
-          if (c >= '0' && c <= '9')
-            codepoint -= '0';
-          else if (c >= 'A' && c <= 'F')
-            codepoint -= 'A' - 10;
-          else if (c >= 'a' && c <= 'f')
-            codepoint -= 'a' - 10;
-          else
-            {
-              RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, escapeOffset);
-              RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
-            }
-          is.Take();
-        }
-      return codepoint;
-    }
-
-    template <typename CharType>
-    class StackStream
-    {
-      public:
-        typedef CharType Ch;
-
-        StackStream(internal::Stack<StackAllocator> &stack) : stack_(stack), length_(0) {}
-        RAPIDJSON_FORCEINLINE void Put(Ch c)
-        {
-          *stack_.template Push<Ch>() = c;
-          ++length_;
-        }
-
-        RAPIDJSON_FORCEINLINE void *Push(SizeType count)
-        {
-          length_ += count;
-          return stack_.template Push<Ch>(count);
-        }
-
-        size_t Length() const
-        {
-          return length_;
-        }
-
-        Ch *Pop()
-        {
-          return stack_.template Pop<Ch>(length_);
-        }
-
-      private:
-        StackStream(const StackStream &);
-        StackStream &operator=(const StackStream &);
-
-        internal::Stack<StackAllocator> &stack_;
-        SizeType length_;
-    };
-
-    // Parse string and generate String event. Different code paths for kParseInsituFlag.
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseString(InputStream &is, Handler &handler, bool isKey = false)
-    {
-      internal::StreamLocalCopy<InputStream> copy(is);
-      InputStream &s(copy.s);
-
-      RAPIDJSON_ASSERT(s.Peek() == '\"');
-      s.Take();  // Skip '\"'
-
-      bool success = false;
-      if (parseFlags & kParseInsituFlag)
-        {
-          typename InputStream::Ch *head = s.PutBegin();
-          ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-          size_t length = s.PutEnd(head) - 1;
-          RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
-          const typename TargetEncoding::Ch *const str = reinterpret_cast<typename TargetEncoding::Ch *>(head);
-          success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
-        }
-      else
-        {
-          StackStream<typename TargetEncoding::Ch> stackStream(stack_);
-          ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-          SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
-          const typename TargetEncoding::Ch *const str = stackStream.Pop();
-          success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
-        }
-      if (RAPIDJSON_UNLIKELY(!success))
-        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
-    }
-
-    // Parse string to an output is
-    // This function handles the prefix/suffix double quotes, escaping, and optional encoding validation.
-    template<unsigned parseFlags, typename SEncoding, typename TEncoding, typename InputStream, typename OutputStream>
-    RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream &is, OutputStream &os)
-    {
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-      static const char escape[256] =
-      {
-        Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/',
-        Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
-        0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
-        0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
-      };
-#undef Z16
-//!@endcond
-
-      for (;;)
-        {
-          // Scan and copy string before "\\\"" or < 0x20. This is an optional optimzation.
-          if (!(parseFlags & kParseValidateEncodingFlag))
-            ScanCopyUnescapedString(is, os);
-
-          Ch c = is.Peek();
-          if (RAPIDJSON_UNLIKELY(c == '\\'))      // Escape
-            {
-              size_t escapeOffset = is.Tell();    // For invalid escaping, report the initial '\\' as error offset
-              is.Take();
-              Ch e = is.Peek();
-              if ((sizeof(Ch) == 1 || unsigned(e) < 256) && RAPIDJSON_LIKELY(escape[static_cast<unsigned char>(e)]))
-                {
-                  is.Take();
-                  os.Put(static_cast<typename TEncoding::Ch>(escape[static_cast<unsigned char>(e)]));
-                }
-              else if (RAPIDJSON_LIKELY(e == 'u'))      // Unicode
-                {
-                  is.Take();
-                  unsigned codepoint = ParseHex4(is, escapeOffset);
-                  RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-                  if (RAPIDJSON_UNLIKELY(codepoint >= 0xD800 && codepoint <= 0xDBFF))
-                    {
-                      // Handle UTF-16 surrogate pair
-                      if (RAPIDJSON_UNLIKELY(!Consume(is, '\\') || !Consume(is, 'u')))
-                        RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
-                      unsigned codepoint2 = ParseHex4(is, escapeOffset);
-                      RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-                      if (RAPIDJSON_UNLIKELY(codepoint2 < 0xDC00 || codepoint2 > 0xDFFF))
-                        RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, escapeOffset);
-                      codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
-                    }
-                  TEncoding::Encode(os, codepoint);
-                }
-              else
-                RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, escapeOffset);
-            }
-          else if (RAPIDJSON_UNLIKELY(c == '"'))      // Closing double quote
-            {
-              is.Take();
-              os.Put('\0');   // null-terminate the string
-              return;
-            }
-          else if (RAPIDJSON_UNLIKELY(static_cast<unsigned>(c) < 0x20))   // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
-            {
-              if (c == '\0')
-                RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell());
-              else
-                RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
-            }
-          else
-            {
-              size_t offset = is.Tell();
-              if (RAPIDJSON_UNLIKELY((parseFlags & kParseValidateEncodingFlag ?
-                                      !Transcoder<SEncoding, TEncoding>::Validate(is, os) :
-                                      !Transcoder<SEncoding, TEncoding>::Transcode(is, os))))
-                RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, offset);
-            }
-        }
-    }
-
-    template<typename InputStream, typename OutputStream>
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InputStream &, OutputStream &)
-    {
-      // Do nothing for generic version
-    }
-
-#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
-    // StringStream -> StackStream<char>
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream &is, StackStream<char> &os)
-    {
-      const char *p = is.src_;
-
-      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-      while (p != nextAligned)
-        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
-          {
-            is.src_ = p;
-            return;
-          }
-        else
-          os.Put(*p++);
-
-      // The rest of string using SIMD
-      static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
-      static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
-      static const char space[16]  = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
-      const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
-      const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
-      const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
-
-      for (;; p += 16)
-        {
-          const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-          const __m128i t1 = _mm_cmpeq_epi8(s, dq);
-          const __m128i t2 = _mm_cmpeq_epi8(s, bs);
-          const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
-          const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
-          unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
-          if (RAPIDJSON_UNLIKELY(r != 0))     // some of characters is escaped
-            {
-              SizeType length;
-#ifdef _MSC_VER         // Find the index of first escaped
-              unsigned long offset;
-              _BitScanForward(&offset, r);
-              length = offset;
-#else
-              length = static_cast<SizeType>(__builtin_ffs(r) - 1);
-#endif
-              if (length != 0)
-                {
-                  char *q = reinterpret_cast<char *>(os.Push(length));
-                  for (size_t i = 0; i < length; i++)
-                    q[i] = p[i];
-
-                  p += length;
-                }
-              break;
-            }
-          _mm_storeu_si128(reinterpret_cast<__m128i *>(os.Push(16)), s);
-        }
-
-      is.src_ = p;
-    }
-
-    // InsituStringStream -> InsituStringStream
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream &is, InsituStringStream &os)
-    {
-      RAPIDJSON_ASSERT(&is == &os);
-      (void)os;
-
-      if (is.src_ == is.dst_)
-        {
-          SkipUnescapedString(is);
-          return;
-        }
-
-      char *p = is.src_;
-      char *q = is.dst_;
-
-      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-      while (p != nextAligned)
-        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
-          {
-            is.src_ = p;
-            is.dst_ = q;
-            return;
-          }
-        else
-          *q++ = *p++;
-
-      // The rest of string using SIMD
-      static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
-      static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
-      static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
-      const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
-      const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
-      const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
-
-      for (;; p += 16, q += 16)
-        {
-          const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-          const __m128i t1 = _mm_cmpeq_epi8(s, dq);
-          const __m128i t2 = _mm_cmpeq_epi8(s, bs);
-          const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
-          const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
-          unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
-          if (RAPIDJSON_UNLIKELY(r != 0))     // some of characters is escaped
-            {
-              size_t length;
-#ifdef _MSC_VER         // Find the index of first escaped
-              unsigned long offset;
-              _BitScanForward(&offset, r);
-              length = offset;
-#else
-              length = static_cast<size_t>(__builtin_ffs(r) - 1);
-#endif
-              for (const char *pend = p + length; p != pend; )
-                *q++ = *p++;
-              break;
-            }
-          _mm_storeu_si128(reinterpret_cast<__m128i *>(q), s);
-        }
-
-      is.src_ = p;
-      is.dst_ = q;
-    }
-
-    // When read/write pointers are the same for insitu stream, just skip unescaped characters
-    static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream &is)
-    {
-      RAPIDJSON_ASSERT(is.src_ == is.dst_);
-      char *p = is.src_;
-
-      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-      for (; p != nextAligned; p++)
-        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
-          {
-            is.src_ = is.dst_ = p;
-            return;
-          }
-
-      // The rest of string using SIMD
-      static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
-      static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
-      static const char space[16] = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
-      const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
-      const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
-      const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
-
-      for (;; p += 16)
-        {
-          const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-          const __m128i t1 = _mm_cmpeq_epi8(s, dq);
-          const __m128i t2 = _mm_cmpeq_epi8(s, bs);
-          const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
-          const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
-          unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
-          if (RAPIDJSON_UNLIKELY(r != 0))     // some of characters is escaped
-            {
-              size_t length;
-#ifdef _MSC_VER         // Find the index of first escaped
-              unsigned long offset;
-              _BitScanForward(&offset, r);
-              length = offset;
-#else
-              length = static_cast<size_t>(__builtin_ffs(r) - 1);
-#endif
-              p += length;
-              break;
-            }
-        }
-
-      is.src_ = is.dst_ = p;
-    }
-#elif defined(RAPIDJSON_NEON)
-    // StringStream -> StackStream<char>
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(StringStream &is, StackStream<char> &os)
-    {
-      const char *p = is.src_;
-
-      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-      while (p != nextAligned)
-        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
-          {
-            is.src_ = p;
-            return;
-          }
-        else
-          os.Put(*p++);
-
-      // The rest of string using SIMD
-      const uint8x16_t s0 = vmovq_n_u8('"');
-      const uint8x16_t s1 = vmovq_n_u8('\\');
-      const uint8x16_t s2 = vmovq_n_u8('\b');
-      const uint8x16_t s3 = vmovq_n_u8(32);
-
-      for (;; p += 16)
-        {
-          const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
-          uint8x16_t x = vceqq_u8(s, s0);
-          x = vorrq_u8(x, vceqq_u8(s, s1));
-          x = vorrq_u8(x, vceqq_u8(s, s2));
-          x = vorrq_u8(x, vcltq_u8(s, s3));
-
-          x = vrev64q_u8(x);                     // Rev in 64
-          uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-          uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
-
-          SizeType length = 0;
-          bool escaped = false;
-          if (low == 0)
-            {
-              if (high != 0)
-                {
-                  unsigned lz = (unsigned)__builtin_clzll(high);;
-                  length = 8 + (lz >> 3);
-                  escaped = true;
-                }
-            }
-          else
-            {
-              unsigned lz = (unsigned)__builtin_clzll(low);;
-              length = lz >> 3;
-              escaped = true;
-            }
-          if (RAPIDJSON_UNLIKELY(escaped))     // some of characters is escaped
-            {
-              if (length != 0)
-                {
-                  char *q = reinterpret_cast<char *>(os.Push(length));
-                  for (size_t i = 0; i < length; i++)
-                    q[i] = p[i];
-
-                  p += length;
-                }
-              break;
-            }
-          vst1q_u8(reinterpret_cast<uint8_t *>(os.Push(16)), s);
-        }
-
-      is.src_ = p;
-    }
-
-    // InsituStringStream -> InsituStringStream
-    static RAPIDJSON_FORCEINLINE void ScanCopyUnescapedString(InsituStringStream &is, InsituStringStream &os)
-    {
-      RAPIDJSON_ASSERT(&is == &os);
-      (void)os;
-
-      if (is.src_ == is.dst_)
-        {
-          SkipUnescapedString(is);
-          return;
-        }
-
-      char *p = is.src_;
-      char *q = is.dst_;
-
-      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-      while (p != nextAligned)
-        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
-          {
-            is.src_ = p;
-            is.dst_ = q;
-            return;
-          }
-        else
-          *q++ = *p++;
-
-      // The rest of string using SIMD
-      const uint8x16_t s0 = vmovq_n_u8('"');
-      const uint8x16_t s1 = vmovq_n_u8('\\');
-      const uint8x16_t s2 = vmovq_n_u8('\b');
-      const uint8x16_t s3 = vmovq_n_u8(32);
-
-      for (;; p += 16, q += 16)
-        {
-          const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
-          uint8x16_t x = vceqq_u8(s, s0);
-          x = vorrq_u8(x, vceqq_u8(s, s1));
-          x = vorrq_u8(x, vceqq_u8(s, s2));
-          x = vorrq_u8(x, vcltq_u8(s, s3));
-
-          x = vrev64q_u8(x);                     // Rev in 64
-          uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-          uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
-
-          SizeType length = 0;
-          bool escaped = false;
-          if (low == 0)
-            {
-              if (high != 0)
-                {
-                  unsigned lz = (unsigned)__builtin_clzll(high);
-                  length = 8 + (lz >> 3);
-                  escaped = true;
-                }
-            }
-          else
-            {
-              unsigned lz = (unsigned)__builtin_clzll(low);
-              length = lz >> 3;
-              escaped = true;
-            }
-          if (RAPIDJSON_UNLIKELY(escaped))     // some of characters is escaped
-            {
-              for (const char *pend = p + length; p != pend; )
-                {
-                  *q++ = *p++;
-                }
-              break;
-            }
-          vst1q_u8(reinterpret_cast<uint8_t *>(q), s);
-        }
-
-      is.src_ = p;
-      is.dst_ = q;
-    }
-
-    // When read/write pointers are the same for insitu stream, just skip unescaped characters
-    static RAPIDJSON_FORCEINLINE void SkipUnescapedString(InsituStringStream &is)
-    {
-      RAPIDJSON_ASSERT(is.src_ == is.dst_);
-      char *p = is.src_;
-
-      // Scan one by one until alignment (unaligned load may cross page boundary and cause crash)
-      const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-      for (; p != nextAligned; p++)
-        if (RAPIDJSON_UNLIKELY(*p == '\"') || RAPIDJSON_UNLIKELY(*p == '\\') || RAPIDJSON_UNLIKELY(static_cast<unsigned>(*p) < 0x20))
-          {
-            is.src_ = is.dst_ = p;
-            return;
-          }
-
-      // The rest of string using SIMD
-      const uint8x16_t s0 = vmovq_n_u8('"');
-      const uint8x16_t s1 = vmovq_n_u8('\\');
-      const uint8x16_t s2 = vmovq_n_u8('\b');
-      const uint8x16_t s3 = vmovq_n_u8(32);
-
-      for (;; p += 16)
-        {
-          const uint8x16_t s = vld1q_u8(reinterpret_cast<uint8_t *>(p));
-          uint8x16_t x = vceqq_u8(s, s0);
-          x = vorrq_u8(x, vceqq_u8(s, s1));
-          x = vorrq_u8(x, vceqq_u8(s, s2));
-          x = vorrq_u8(x, vcltq_u8(s, s3));
-
-          x = vrev64q_u8(x);                     // Rev in 64
-          uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-          uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
-
-          if (low == 0)
-            {
-              if (high != 0)
-                {
-                  int lz = __builtin_clzll(high);
-                  p += 8 + (lz >> 3);
-                  break;
-                }
-            }
-          else
-            {
-              int lz = __builtin_clzll(low);
-              p += lz >> 3;
-              break;
-            }
-        }
-
-      is.src_ = is.dst_ = p;
-    }
-#endif // RAPIDJSON_NEON
-
-    template<typename InputStream, bool backup, bool pushOnTake>
-    class NumberStream;
-
-    template<typename InputStream>
-    class NumberStream<InputStream, false, false>
-    {
-      public:
-        typedef typename InputStream::Ch Ch;
-
-        NumberStream(GenericReader &reader, InputStream &s) : is(s)
-        {
-          (void)reader;
-        }
-
-        RAPIDJSON_FORCEINLINE Ch Peek() const
-        {
-          return is.Peek();
-        }
-        RAPIDJSON_FORCEINLINE Ch TakePush()
-        {
-          return is.Take();
-        }
-        RAPIDJSON_FORCEINLINE Ch Take()
-        {
-          return is.Take();
-        }
-        RAPIDJSON_FORCEINLINE void Push(char) {}
-
-        size_t Tell()
-        {
-          return is.Tell();
-        }
-        size_t Length()
-        {
-          return 0;
-        }
-        const char *Pop()
-        {
-          return 0;
-        }
-
-      protected:
-        NumberStream &operator=(const NumberStream &);
-
-        InputStream &is;
-    };
-
-    template<typename InputStream>
-    class NumberStream<InputStream, true, false> : public NumberStream<InputStream, false, false>
-    {
-        typedef NumberStream<InputStream, false, false> Base;
-      public:
-        NumberStream(GenericReader &reader, InputStream &is) : Base(reader, is), stackStream(reader.stack_) {}
-
-        RAPIDJSON_FORCEINLINE Ch TakePush()
-        {
-          stackStream.Put(static_cast<char>(Base::is.Peek()));
-          return Base::is.Take();
-        }
-
-        RAPIDJSON_FORCEINLINE void Push(char c)
-        {
-          stackStream.Put(c);
-        }
-
-        size_t Length()
-        {
-          return stackStream.Length();
-        }
-
-        const char *Pop()
-        {
-          stackStream.Put('\0');
-          return stackStream.Pop();
-        }
-
-      private:
-        StackStream<char> stackStream;
-    };
-
-    template<typename InputStream>
-    class NumberStream<InputStream, true, true> : public NumberStream<InputStream, true, false>
-    {
-        typedef NumberStream<InputStream, true, false> Base;
-      public:
-        NumberStream(GenericReader &reader, InputStream &is) : Base(reader, is) {}
-
-        RAPIDJSON_FORCEINLINE Ch Take()
-        {
-          return Base::TakePush();
-        }
-    };
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseNumber(InputStream &is, Handler &handler)
-    {
-      internal::StreamLocalCopy<InputStream> copy(is);
-      NumberStream<InputStream,
-                   ((parseFlags & kParseNumbersAsStringsFlag) != 0) ?
-                   ((parseFlags & kParseInsituFlag) == 0) :
-                   ((parseFlags & kParseFullPrecisionFlag) != 0),
-                   (parseFlags & kParseNumbersAsStringsFlag) != 0 &&
-                   (parseFlags & kParseInsituFlag) == 0> s(*this, copy.s);
-
-      size_t startOffset = s.Tell();
-      double d = 0.0;
-      bool useNanOrInf = false;
-
-      // Parse minus
-      bool minus = Consume(s, '-');
-
-      // Parse int: zero / ( digit1-9 *DIGIT )
-      unsigned i = 0;
-      uint64_t i64 = 0;
-      bool use64bit = false;
-      int significandDigit = 0;
-      if (RAPIDJSON_UNLIKELY(s.Peek() == '0'))
-        {
-          i = 0;
-          s.TakePush();
-        }
-      else if (RAPIDJSON_LIKELY(s.Peek() >= '1' && s.Peek() <= '9'))
-        {
-          i = static_cast<unsigned>(s.TakePush() - '0');
-
-          if (minus)
-            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-              {
-                if (RAPIDJSON_UNLIKELY(i >= 214748364))   // 2^31 = 2147483648
-                  {
-                    if (RAPIDJSON_LIKELY(i != 214748364 || s.Peek() > '8'))
-                      {
-                        i64 = i;
-                        use64bit = true;
-                        break;
-                      }
-                  }
-                i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                significandDigit++;
-              }
-          else
-            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-              {
-                if (RAPIDJSON_UNLIKELY(i >= 429496729))   // 2^32 - 1 = 4294967295
-                  {
-                    if (RAPIDJSON_LIKELY(i != 429496729 || s.Peek() > '5'))
-                      {
-                        i64 = i;
-                        use64bit = true;
-                        break;
-                      }
-                  }
-                i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                significandDigit++;
-              }
-        }
-      // Parse NaN or Infinity here
-      else if ((parseFlags & kParseNanAndInfFlag) && RAPIDJSON_LIKELY((s.Peek() == 'I' || s.Peek() == 'N')))
-        {
-          if (Consume(s, 'N'))
-            {
-              if (Consume(s, 'a') && Consume(s, 'N'))
-                {
-                  d = std::numeric_limits<double>::quiet_NaN();
-                  useNanOrInf = true;
-                }
-            }
-          else if (RAPIDJSON_LIKELY(Consume(s, 'I')))
-            {
-              if (Consume(s, 'n') && Consume(s, 'f'))
-                {
-                  d = (minus ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity());
-                  useNanOrInf = true;
-
-                  if (RAPIDJSON_UNLIKELY(s.Peek() == 'i' && !(Consume(s, 'i') && Consume(s, 'n')
-                                                              && Consume(s, 'i') && Consume(s, 't') && Consume(s, 'y'))))
-                    {
-                      RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
-                    }
-                }
-            }
-
-          if (RAPIDJSON_UNLIKELY(!useNanOrInf))
-            {
-              RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
-            }
-        }
-      else
-        RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
-
-      // Parse 64bit int
-      bool useDouble = false;
-      if (use64bit)
-        {
-          if (minus)
-            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-              {
-                if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC))) // 2^63 = 9223372036854775808
-                  if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8'))
-                    {
-                      d = static_cast<double>(i64);
-                      useDouble = true;
-                      break;
-                    }
-                i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                significandDigit++;
-              }
-          else
-            while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-              {
-                if (RAPIDJSON_UNLIKELY(i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999))) // 2^64 - 1 = 18446744073709551615
-                  if (RAPIDJSON_LIKELY(i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5'))
-                    {
-                      d = static_cast<double>(i64);
-                      useDouble = true;
-                      break;
-                    }
-                i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                significandDigit++;
-              }
-        }
-
-      // Force double for big integer
-      if (useDouble)
-        {
-          while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-            {
-              d = d * 10 + (s.TakePush() - '0');
-            }
-        }
-
-      // Parse frac = decimal-point 1*DIGIT
-      int expFrac = 0;
-      size_t decimalPosition;
-      if (Consume(s, '.'))
-        {
-          decimalPosition = s.Length();
-
-          if (RAPIDJSON_UNLIKELY(!(s.Peek() >= '0' && s.Peek() <= '9')))
-            RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
-
-          if (!useDouble)
-            {
-#if RAPIDJSON_64BIT
-              // Use i64 to store significand in 64-bit architecture
-              if (!use64bit)
-                i64 = i;
-
-              while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-                {
-                  if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
-                    break;
-                  else
-                    {
-                      i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                      --expFrac;
-                      if (i64 != 0)
-                        significandDigit++;
-                    }
-                }
-
-              d = static_cast<double>(i64);
-#else
-              // Use double to store significand in 32-bit architecture
-              d = static_cast<double>(use64bit ? i64 : i);
-#endif
-              useDouble = true;
-            }
-
-          while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-            {
-              if (significandDigit < 17)
-                {
-                  d = d * 10.0 + (s.TakePush() - '0');
-                  --expFrac;
-                  if (RAPIDJSON_LIKELY(d > 0.0))
-                    significandDigit++;
-                }
-              else
-                s.TakePush();
-            }
-        }
-      else
-        decimalPosition = s.Length(); // decimal position at the end of integer.
-
-      // Parse exp = e [ minus / plus ] 1*DIGIT
-      int exp = 0;
-      if (Consume(s, 'e') || Consume(s, 'E'))
-        {
-          if (!useDouble)
-            {
-              d = static_cast<double>(use64bit ? i64 : i);
-              useDouble = true;
-            }
-
-          bool expMinus = false;
-          if (Consume(s, '+'))
-            ;
-          else if (Consume(s, '-'))
-            expMinus = true;
-
-          if (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-            {
-              exp = static_cast<int>(s.Take() - '0');
-              if (expMinus)
-                {
-                  // (exp + expFrac) must not underflow int => we're detecting when -exp gets
-                  // dangerously close to INT_MIN (a pessimistic next digit 9 would push it into
-                  // underflow territory):
-                  //
-                  //        -(exp * 10 + 9) + expFrac >= INT_MIN
-                  //   <=>  exp <= (expFrac - INT_MIN - 9) / 10
-                  RAPIDJSON_ASSERT(expFrac <= 0);
-                  int maxExp = (expFrac + 2147483639) / 10;
-
-                  while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-                    {
-                      exp = exp * 10 + static_cast<int>(s.Take() - '0');
-                      if (RAPIDJSON_UNLIKELY(exp > maxExp))
-                        {
-                          while (RAPIDJSON_UNLIKELY(s.Peek() >= '0' && s.Peek() <= '9'))  // Consume the rest of exponent
-                            s.Take();
-                        }
-                    }
-                }
-              else    // positive exp
-                {
-                  int maxExp = 308 - expFrac;
-                  while (RAPIDJSON_LIKELY(s.Peek() >= '0' && s.Peek() <= '9'))
-                    {
-                      exp = exp * 10 + static_cast<int>(s.Take() - '0');
-                      if (RAPIDJSON_UNLIKELY(exp > maxExp))
-                        RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
-                    }
-                }
-            }
-          else
-            RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
-
-          if (expMinus)
-            exp = -exp;
-        }
-
-      // Finish parsing, call event according to the type of number.
-      bool cont = true;
-
-      if (parseFlags & kParseNumbersAsStringsFlag)
-        {
-          if (parseFlags & kParseInsituFlag)
-            {
-              s.Pop();  // Pop stack no matter if it will be used or not.
-              typename InputStream::Ch *head = is.PutBegin();
-              const size_t length = s.Tell() - startOffset;
-              RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
-              // unable to insert the \0 character here, it will erase the comma after this number
-              const typename TargetEncoding::Ch *const str = reinterpret_cast<typename TargetEncoding::Ch *>(head);
-              cont = handler.RawNumber(str, SizeType(length), false);
-            }
-          else
-            {
-              SizeType numCharsToCopy = static_cast<SizeType>(s.Length());
-              StringStream srcStream(s.Pop());
-              StackStream<typename TargetEncoding::Ch> dstStream(stack_);
-              while (numCharsToCopy--)
-                {
-                  Transcoder<UTF8<>, TargetEncoding>::Transcode(srcStream, dstStream);
-                }
-              dstStream.Put('\0');
-              const typename TargetEncoding::Ch *str = dstStream.Pop();
-              const SizeType length = static_cast<SizeType>(dstStream.Length()) - 1;
-              cont = handler.RawNumber(str, SizeType(length), true);
-            }
-        }
-      else
-        {
-          size_t length = s.Length();
-          const char *decimal = s.Pop();  // Pop stack no matter if it will be used or not.
-
-          if (useDouble)
-            {
-              int p = exp + expFrac;
-              if (parseFlags & kParseFullPrecisionFlag)
-                d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
-              else
-                d = internal::StrtodNormalPrecision(d, p);
-
-              // Use > max, instead of == inf, to fix bogus warning -Wfloat-equal
-              if (d > (std::numeric_limits<double>::max)())
-                {
-                  // Overflow
-                  // TODO: internal::StrtodX should report overflow (or underflow)
-                  RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, startOffset);
-                }
-
-              cont = handler.Double(minus ? -d : d);
-            }
-          else if (useNanOrInf)
-            {
-              cont = handler.Double(d);
-            }
-          else
-            {
-              if (use64bit)
-                {
-                  if (minus)
-                    cont = handler.Int64(static_cast<int64_t>(~i64 + 1));
-                  else
-                    cont = handler.Uint64(i64);
-                }
-              else
-                {
-                  if (minus)
-                    cont = handler.Int(static_cast<int32_t>(~i + 1));
-                  else
-                    cont = handler.Uint(i);
-                }
-            }
-        }
-      if (RAPIDJSON_UNLIKELY(!cont))
-        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, startOffset);
-    }
-
-    // Parse any JSON value
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseValue(InputStream &is, Handler &handler)
-    {
-      switch (is.Peek())
-        {
-          case 'n':
-            ParseNull  <parseFlags>(is, handler);
-            break;
-          case 't':
-            ParseTrue  <parseFlags>(is, handler);
-            break;
-          case 'f':
-            ParseFalse <parseFlags>(is, handler);
-            break;
-          case '"':
-            ParseString<parseFlags>(is, handler);
-            break;
-          case '{':
-            ParseObject<parseFlags>(is, handler);
-            break;
-          case '[':
-            ParseArray <parseFlags>(is, handler);
-            break;
-          default :
-            ParseNumber<parseFlags>(is, handler);
-            break;
-
-        }
-    }
-
-    // Iterative Parsing
-
-    // States
-    enum IterativeParsingState
-    {
-      IterativeParsingFinishState = 0, // sink states at top
-      IterativeParsingErrorState,      // sink states at top
-      IterativeParsingStartState,
-
-      // Object states
-      IterativeParsingObjectInitialState,
-      IterativeParsingMemberKeyState,
-      IterativeParsingMemberValueState,
-      IterativeParsingObjectFinishState,
-
-      // Array states
-      IterativeParsingArrayInitialState,
-      IterativeParsingElementState,
-      IterativeParsingArrayFinishState,
-
-      // Single value state
-      IterativeParsingValueState,
-
-      // Delimiter states (at bottom)
-      IterativeParsingElementDelimiterState,
-      IterativeParsingMemberDelimiterState,
-      IterativeParsingKeyValueDelimiterState,
-
-      cIterativeParsingStateCount
-    };
-
-    // Tokens
-    enum Token
-    {
-      LeftBracketToken = 0,
-      RightBracketToken,
-
-      LeftCurlyBracketToken,
-      RightCurlyBracketToken,
-
-      CommaToken,
-      ColonToken,
-
-      StringToken,
-      FalseToken,
-      TrueToken,
-      NullToken,
-      NumberToken,
-
-      kTokenCount
-    };
-
-    RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const
-    {
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#define N NumberToken
-#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
-      // Maps from ASCII to Token
-      static const unsigned char tokenMap[256] =
-      {
-        N16, // 00~0F
-        N16, // 10~1F
-        N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F
-        N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F
-        N16, // 40~4F
-        N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F
-        N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F
-        N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F
-        N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF
-      };
-#undef N
-#undef N16
-//!@endcond
-
-      if (sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256)
-        return static_cast<Token>(tokenMap[static_cast<unsigned char>(c)]);
-      else
-        return NumberToken;
-    }
-
-    RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) const
-    {
-      // current state x one lookahead token -> new state
-      static const char G[cIterativeParsingStateCount][kTokenCount] =
-      {
-        // Finish(sink state)
-        {
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState
-        },
-        // Error(sink state)
-        {
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState
-        },
-        // Start
-        {
-          IterativeParsingArrayInitialState,  // Left bracket
-          IterativeParsingErrorState,         // Right bracket
-          IterativeParsingObjectInitialState, // Left curly bracket
-          IterativeParsingErrorState,         // Right curly bracket
-          IterativeParsingErrorState,         // Comma
-          IterativeParsingErrorState,         // Colon
-          IterativeParsingValueState,         // String
-          IterativeParsingValueState,         // False
-          IterativeParsingValueState,         // True
-          IterativeParsingValueState,         // Null
-          IterativeParsingValueState          // Number
-        },
-        // ObjectInitial
-        {
-          IterativeParsingErrorState,         // Left bracket
-          IterativeParsingErrorState,         // Right bracket
-          IterativeParsingErrorState,         // Left curly bracket
-          IterativeParsingObjectFinishState,  // Right curly bracket
-          IterativeParsingErrorState,         // Comma
-          IterativeParsingErrorState,         // Colon
-          IterativeParsingMemberKeyState,     // String
-          IterativeParsingErrorState,         // False
-          IterativeParsingErrorState,         // True
-          IterativeParsingErrorState,         // Null
-          IterativeParsingErrorState          // Number
-        },
-        // MemberKey
-        {
-          IterativeParsingErrorState,             // Left bracket
-          IterativeParsingErrorState,             // Right bracket
-          IterativeParsingErrorState,             // Left curly bracket
-          IterativeParsingErrorState,             // Right curly bracket
-          IterativeParsingErrorState,             // Comma
-          IterativeParsingKeyValueDelimiterState, // Colon
-          IterativeParsingErrorState,             // String
-          IterativeParsingErrorState,             // False
-          IterativeParsingErrorState,             // True
-          IterativeParsingErrorState,             // Null
-          IterativeParsingErrorState              // Number
-        },
-        // MemberValue
-        {
-          IterativeParsingErrorState,             // Left bracket
-          IterativeParsingErrorState,             // Right bracket
-          IterativeParsingErrorState,             // Left curly bracket
-          IterativeParsingObjectFinishState,      // Right curly bracket
-          IterativeParsingMemberDelimiterState,   // Comma
-          IterativeParsingErrorState,             // Colon
-          IterativeParsingErrorState,             // String
-          IterativeParsingErrorState,             // False
-          IterativeParsingErrorState,             // True
-          IterativeParsingErrorState,             // Null
-          IterativeParsingErrorState              // Number
-        },
-        // ObjectFinish(sink state)
-        {
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState
-        },
-        // ArrayInitial
-        {
-          IterativeParsingArrayInitialState,      // Left bracket(push Element state)
-          IterativeParsingArrayFinishState,       // Right bracket
-          IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
-          IterativeParsingErrorState,             // Right curly bracket
-          IterativeParsingErrorState,             // Comma
-          IterativeParsingErrorState,             // Colon
-          IterativeParsingElementState,           // String
-          IterativeParsingElementState,           // False
-          IterativeParsingElementState,           // True
-          IterativeParsingElementState,           // Null
-          IterativeParsingElementState            // Number
-        },
-        // Element
-        {
-          IterativeParsingErrorState,             // Left bracket
-          IterativeParsingArrayFinishState,       // Right bracket
-          IterativeParsingErrorState,             // Left curly bracket
-          IterativeParsingErrorState,             // Right curly bracket
-          IterativeParsingElementDelimiterState,  // Comma
-          IterativeParsingErrorState,             // Colon
-          IterativeParsingErrorState,             // String
-          IterativeParsingErrorState,             // False
-          IterativeParsingErrorState,             // True
-          IterativeParsingErrorState,             // Null
-          IterativeParsingErrorState              // Number
-        },
-        // ArrayFinish(sink state)
-        {
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState
-        },
-        // Single Value (sink state)
-        {
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-          IterativeParsingErrorState
-        },
-        // ElementDelimiter
-        {
-          IterativeParsingArrayInitialState,      // Left bracket(push Element state)
-          IterativeParsingArrayFinishState,       // Right bracket
-          IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
-          IterativeParsingErrorState,             // Right curly bracket
-          IterativeParsingErrorState,             // Comma
-          IterativeParsingErrorState,             // Colon
-          IterativeParsingElementState,           // String
-          IterativeParsingElementState,           // False
-          IterativeParsingElementState,           // True
-          IterativeParsingElementState,           // Null
-          IterativeParsingElementState            // Number
-        },
-        // MemberDelimiter
-        {
-          IterativeParsingErrorState,         // Left bracket
-          IterativeParsingErrorState,         // Right bracket
-          IterativeParsingErrorState,         // Left curly bracket
-          IterativeParsingObjectFinishState,  // Right curly bracket
-          IterativeParsingErrorState,         // Comma
-          IterativeParsingErrorState,         // Colon
-          IterativeParsingMemberKeyState,     // String
-          IterativeParsingErrorState,         // False
-          IterativeParsingErrorState,         // True
-          IterativeParsingErrorState,         // Null
-          IterativeParsingErrorState          // Number
-        },
-        // KeyValueDelimiter
-        {
-          IterativeParsingArrayInitialState,      // Left bracket(push MemberValue state)
-          IterativeParsingErrorState,             // Right bracket
-          IterativeParsingObjectInitialState,     // Left curly bracket(push MemberValue state)
-          IterativeParsingErrorState,             // Right curly bracket
-          IterativeParsingErrorState,             // Comma
-          IterativeParsingErrorState,             // Colon
-          IterativeParsingMemberValueState,       // String
-          IterativeParsingMemberValueState,       // False
-          IterativeParsingMemberValueState,       // True
-          IterativeParsingMemberValueState,       // Null
-          IterativeParsingMemberValueState        // Number
-        },
-      }; // End of G
-
-      return static_cast<IterativeParsingState>(G[state][token]);
-    }
-
-    // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit().
-    // May return a new state on state pop.
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream &is, Handler &handler)
-    {
-      (void)token;
-
-      switch (dst)
-        {
-          case IterativeParsingErrorState:
-            return dst;
-
-          case IterativeParsingObjectInitialState:
-          case IterativeParsingArrayInitialState:
-          {
-            // Push the state(Element or MemeberValue) if we are nested in another array or value of member.
-            // In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop.
-            IterativeParsingState n = src;
-            if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
-              n = IterativeParsingElementState;
-            else if (src == IterativeParsingKeyValueDelimiterState)
-              n = IterativeParsingMemberValueState;
-            // Push current state.
-            *stack_.template Push<SizeType>(1) = n;
-            // Initialize and push the member/element count.
-            *stack_.template Push<SizeType>(1) = 0;
-            // Call handler
-            bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
-            // On handler short circuits the parsing.
-            if (!hr)
-              {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
-                return IterativeParsingErrorState;
-              }
-            else
-              {
-                is.Take();
-                return dst;
-              }
-          }
-
-          case IterativeParsingMemberKeyState:
-            ParseString<parseFlags>(is, handler, true);
-            if (HasParseError())
-              return IterativeParsingErrorState;
-            else
-              return dst;
-
-          case IterativeParsingKeyValueDelimiterState:
-            RAPIDJSON_ASSERT(token == ColonToken);
-            is.Take();
-            return dst;
-
-          case IterativeParsingMemberValueState:
-            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
-            ParseValue<parseFlags>(is, handler);
-            if (HasParseError())
-              {
-                return IterativeParsingErrorState;
-              }
-            return dst;
-
-          case IterativeParsingElementState:
-            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
-            ParseValue<parseFlags>(is, handler);
-            if (HasParseError())
-              {
-                return IterativeParsingErrorState;
-              }
-            return dst;
-
-          case IterativeParsingMemberDelimiterState:
-          case IterativeParsingElementDelimiterState:
-            is.Take();
-            // Update member/element count.
-            *stack_.template Top<SizeType>() = *stack_.template Top<SizeType>() + 1;
-            return dst;
-
-          case IterativeParsingObjectFinishState:
-          {
-            // Transit from delimiter is only allowed when trailing commas are enabled
-            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingMemberDelimiterState)
-              {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorObjectMissName, is.Tell());
-                return IterativeParsingErrorState;
-              }
-            // Get member count.
-            SizeType c = *stack_.template Pop<SizeType>(1);
-            // If the object is not empty, count the last member.
-            if (src == IterativeParsingMemberValueState)
-              ++c;
-            // Restore the state.
-            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
-            // Transit to Finish state if this is the topmost scope.
-            if (n == IterativeParsingStartState)
-              n = IterativeParsingFinishState;
-            // Call handler
-            bool hr = handler.EndObject(c);
-            // On handler short circuits the parsing.
-            if (!hr)
-              {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
-                return IterativeParsingErrorState;
-              }
-            else
-              {
-                is.Take();
-                return n;
-              }
-          }
-
-          case IterativeParsingArrayFinishState:
-          {
-            // Transit from delimiter is only allowed when trailing commas are enabled
-            if (!(parseFlags & kParseTrailingCommasFlag) && src == IterativeParsingElementDelimiterState)
-              {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorValueInvalid, is.Tell());
-                return IterativeParsingErrorState;
-              }
-            // Get element count.
-            SizeType c = *stack_.template Pop<SizeType>(1);
-            // If the array is not empty, count the last element.
-            if (src == IterativeParsingElementState)
-              ++c;
-            // Restore the state.
-            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
-            // Transit to Finish state if this is the topmost scope.
-            if (n == IterativeParsingStartState)
-              n = IterativeParsingFinishState;
-            // Call handler
-            bool hr = handler.EndArray(c);
-            // On handler short circuits the parsing.
-            if (!hr)
-              {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
-                return IterativeParsingErrorState;
-              }
-            else
-              {
-                is.Take();
-                return n;
-              }
-          }
-
-          default:
-            // This branch is for IterativeParsingValueState actually.
-            // Use `default:` rather than
-            // `case IterativeParsingValueState:` is for code coverage.
-
-            // The IterativeParsingStartState is not enumerated in this switch-case.
-            // It is impossible for that case. And it can be caught by following assertion.
-
-            // The IterativeParsingFinishState is not enumerated in this switch-case either.
-            // It is a "derivative" state which cannot triggered from Predict() directly.
-            // Therefore it cannot happen here. And it can be caught by following assertion.
-            RAPIDJSON_ASSERT(dst == IterativeParsingValueState);
-
-            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
-            ParseValue<parseFlags>(is, handler);
-            if (HasParseError())
-              {
-                return IterativeParsingErrorState;
-              }
-            return IterativeParsingFinishState;
-        }
-    }
-
-    template <typename InputStream>
-    void HandleError(IterativeParsingState src, InputStream &is)
-    {
-      if (HasParseError())
-        {
-          // Error flag has been set.
-          return;
-        }
-
-      switch (src)
-        {
-          case IterativeParsingStartState:
-            RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell());
-            return;
-          case IterativeParsingFinishState:
-            RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell());
-            return;
-          case IterativeParsingObjectInitialState:
-          case IterativeParsingMemberDelimiterState:
-            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
-            return;
-          case IterativeParsingMemberKeyState:
-            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
-            return;
-          case IterativeParsingMemberValueState:
-            RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());
-            return;
-          case IterativeParsingKeyValueDelimiterState:
-          case IterativeParsingArrayInitialState:
-          case IterativeParsingElementDelimiterState:
-            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell());
-            return;
-          default:
-            RAPIDJSON_ASSERT(src == IterativeParsingElementState);
-            RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
-            return;
-        }
-    }
-
-    RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(IterativeParsingState s) const
-    {
-      return s >= IterativeParsingElementDelimiterState;
-    }
-
-    RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(IterativeParsingState s) const
-    {
-      return s <= IterativeParsingErrorState;
-    }
-
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    ParseResult IterativeParse(InputStream &is, Handler &handler)
-    {
-      parseResult_.Clear();
-      ClearStackOnExit scope(*this);
-      IterativeParsingState state = IterativeParsingStartState;
-
-      SkipWhitespaceAndComments<parseFlags>(is);
-      RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-      while (is.Peek() != '\0')
-        {
-          Token t = Tokenize(is.Peek());
-          IterativeParsingState n = Predict(state, t);
-          IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
-
-          if (d == IterativeParsingErrorState)
-            {
-              HandleError(state, is);
-              break;
-            }
-
-          state = d;
-
-          // Do not further consume streams if a root JSON has been parsed.
-          if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
-            break;
-
-          SkipWhitespaceAndComments<parseFlags>(is);
-          RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-        }
-
-      // Handle the end of file.
-      if (state != IterativeParsingFinishState)
-        HandleError(state, is);
-
-      return parseResult_;
-    }
-
-    static const size_t kDefaultStackCapacity = 256;    //!< Default stack capacity in bytes for storing a single decoded string.
-    internal::Stack<StackAllocator> stack_;  //!< A stack for storing decoded string temporarily during non-destructive parsing.
-    ParseResult parseResult_;
-    IterativeParsingState state_;
-}; // class GenericReader
-
-//! Reader with UTF8 encoding and default allocator.
-typedef GenericReader<UTF8<>, UTF8<> > Reader;
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__) || defined(_MSC_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_READER_H_
diff --git a/contrib/world_builder/include/rapidjson/schema.h.bak b/contrib/world_builder/include/rapidjson/schema.h.bak
deleted file mode 100644
index 66a90b3a44e..00000000000
--- a/contrib/world_builder/include/rapidjson/schema.h.bak
+++ /dev/null
@@ -1,2927 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available->
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip-> All rights reserved->
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License-> You may obtain a copy of the License at
-//
-// http://opensource->org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied-> See the License for the
-// specific language governing permissions and limitations under the License->
-
-#ifndef RAPIDJSON_SCHEMA_H_
-#define RAPIDJSON_SCHEMA_H_
-
-#include "document.h"
-#include "pointer.h"
-#include "stringbuffer.h"
-#include <cmath> // abs, floor
-
-#if !defined(RAPIDJSON_SCHEMA_USE_INTERNALREGEX)
-#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 1
-#else
-#define RAPIDJSON_SCHEMA_USE_INTERNALREGEX 0
-#endif
-
-#if !RAPIDJSON_SCHEMA_USE_INTERNALREGEX && defined(RAPIDJSON_SCHEMA_USE_STDREGEX) && (__cplusplus >=201103L || (defined(_MSC_VER) && _MSC_VER >= 1800))
-#define RAPIDJSON_SCHEMA_USE_STDREGEX 1
-#else
-#define RAPIDJSON_SCHEMA_USE_STDREGEX 0
-#endif
-
-#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
-#include "internal/regex.h"
-#elif RAPIDJSON_SCHEMA_USE_STDREGEX
-#include <regex>
-#endif
-
-#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX || RAPIDJSON_SCHEMA_USE_STDREGEX
-#define RAPIDJSON_SCHEMA_HAS_REGEX 1
-#else
-#define RAPIDJSON_SCHEMA_HAS_REGEX 0
-#endif
-
-#ifndef RAPIDJSON_SCHEMA_VERBOSE
-#define RAPIDJSON_SCHEMA_VERBOSE 0
-#endif
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-#include "stringbuffer.h"
-#endif
-
-RAPIDJSON_DIAG_PUSH
-
-#if defined(__GNUC__)
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_OFF(weak-vtables)
-RAPIDJSON_DIAG_OFF(exit-time-destructors)
-RAPIDJSON_DIAG_OFF(c++98-compat-pedantic)
-RAPIDJSON_DIAG_OFF(variadic-macros)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Verbose Utilities
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-
-namespace internal
-{
-
-  inline void PrintInvalidKeyword(const char *keyword)
-  {
-    printf("Fail keyword: %s\n", keyword);
-  }
-
-  inline void PrintInvalidKeyword(const wchar_t *keyword)
-  {
-    wprintf(L"Fail keyword: %ls\n", keyword);
-  }
-
-  inline void PrintInvalidDocument(const char *document)
-  {
-    printf("Fail document: %s\n\n", document);
-  }
-
-  inline void PrintInvalidDocument(const wchar_t *document)
-  {
-    wprintf(L"Fail document: %ls\n\n", document);
-  }
-
-  inline void PrintValidatorPointers(unsigned depth, const char *s, const char *d)
-  {
-    printf("S: %*s%s\nD: %*s%s\n\n", depth * 4, " ", s, depth * 4, " ", d);
-  }
-
-  inline void PrintValidatorPointers(unsigned depth, const wchar_t *s, const wchar_t *d)
-  {
-    wprintf(L"S: %*ls%ls\nD: %*ls%ls\n\n", depth * 4, L" ", s, depth * 4, L" ", d);
-  }
-
-} // namespace internal
-
-#endif // RAPIDJSON_SCHEMA_VERBOSE
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_INVALID_KEYWORD_RETURN
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword) internal::PrintInvalidKeyword(keyword)
-#else
-#define RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword)
-#endif
-
-#define RAPIDJSON_INVALID_KEYWORD_RETURN(keyword)\
-  RAPIDJSON_MULTILINEMACRO_BEGIN\
-  context.invalidKeyword = keyword.GetString();\
-  RAPIDJSON_INVALID_KEYWORD_VERBOSE(keyword.GetString());\
-  return false;\
-  RAPIDJSON_MULTILINEMACRO_END
-
-///////////////////////////////////////////////////////////////////////////////
-// Forward declarations
-
-template <typename ValueType, typename Allocator>
-class GenericSchemaDocument;
-
-namespace internal
-{
-
-  template <typename SchemaDocumentType>
-  class Schema;
-
-///////////////////////////////////////////////////////////////////////////////
-// ISchemaValidator
-
-  class ISchemaValidator
-  {
-    public:
-      virtual ~ISchemaValidator() {}
-      virtual bool IsValid() const = 0;
-  };
-
-///////////////////////////////////////////////////////////////////////////////
-// ISchemaStateFactory
-
-  template <typename SchemaType>
-  class ISchemaStateFactory
-  {
-    public:
-      virtual ~ISchemaStateFactory() {}
-      virtual ISchemaValidator *CreateSchemaValidator(const SchemaType &) = 0;
-      virtual void DestroySchemaValidator(ISchemaValidator *validator) = 0;
-      virtual void *CreateHasher() = 0;
-      virtual uint64_t GetHashCode(void *hasher) = 0;
-      virtual void DestroryHasher(void *hasher) = 0;
-      virtual void *MallocState(size_t size) = 0;
-      virtual void FreeState(void *p) = 0;
-  };
-
-///////////////////////////////////////////////////////////////////////////////
-// IValidationErrorHandler
-
-  template <typename SchemaType>
-  class IValidationErrorHandler
-  {
-    public:
-      typedef typename SchemaType::Ch Ch;
-      typedef typename SchemaType::SValue SValue;
-
-      virtual ~IValidationErrorHandler() {}
-
-      virtual void NotMultipleOf(int64_t actual, const SValue &expected) = 0;
-      virtual void NotMultipleOf(uint64_t actual, const SValue &expected) = 0;
-      virtual void NotMultipleOf(double actual, const SValue &expected) = 0;
-      virtual void AboveMaximum(int64_t actual, const SValue &expected, bool exclusive) = 0;
-      virtual void AboveMaximum(uint64_t actual, const SValue &expected, bool exclusive) = 0;
-      virtual void AboveMaximum(double actual, const SValue &expected, bool exclusive) = 0;
-      virtual void BelowMinimum(int64_t actual, const SValue &expected, bool exclusive) = 0;
-      virtual void BelowMinimum(uint64_t actual, const SValue &expected, bool exclusive) = 0;
-      virtual void BelowMinimum(double actual, const SValue &expected, bool exclusive) = 0;
-
-      virtual void TooLong(const Ch *str, SizeType length, SizeType expected) = 0;
-      virtual void TooShort(const Ch *str, SizeType length, SizeType expected) = 0;
-      virtual void DoesNotMatch(const Ch *str, SizeType length) = 0;
-
-      virtual void DisallowedItem(SizeType index) = 0;
-      virtual void TooFewItems(SizeType actualCount, SizeType expectedCount) = 0;
-      virtual void TooManyItems(SizeType actualCount, SizeType expectedCount) = 0;
-      virtual void DuplicateItems(SizeType index1, SizeType index2) = 0;
-
-      virtual void TooManyProperties(SizeType actualCount, SizeType expectedCount) = 0;
-      virtual void TooFewProperties(SizeType actualCount, SizeType expectedCount) = 0;
-      virtual void StartMissingProperties() = 0;
-      virtual void AddMissingProperty(const SValue &name) = 0;
-      virtual bool EndMissingProperties() = 0;
-      virtual void PropertyViolations(ISchemaValidator **subvalidators, SizeType count) = 0;
-      virtual void DisallowedProperty(const Ch *name, SizeType length) = 0;
-
-      virtual void StartDependencyErrors() = 0;
-      virtual void StartMissingDependentProperties() = 0;
-      virtual void AddMissingDependentProperty(const SValue &targetName) = 0;
-      virtual void EndMissingDependentProperties(const SValue &sourceName) = 0;
-      virtual void AddDependencySchemaError(const SValue &souceName, ISchemaValidator *subvalidator) = 0;
-      virtual bool EndDependencyErrors() = 0;
-
-      virtual void DisallowedValue() = 0;
-      virtual void StartDisallowedType() = 0;
-      virtual void AddExpectedType(const typename SchemaType::ValueType &expectedType) = 0;
-      virtual void EndDisallowedType(const typename SchemaType::ValueType &actualType) = 0;
-      virtual void NotAllOf(ISchemaValidator **subvalidators, SizeType count) = 0;
-      virtual void NoneOf(ISchemaValidator **subvalidators, SizeType count) = 0;
-      virtual void NotOneOf(ISchemaValidator **subvalidators, SizeType count) = 0;
-      virtual void Disallowed() = 0;
-  };
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Hasher
-
-// For comparison of compound value
-  template<typename Encoding, typename Allocator>
-  class Hasher
-  {
-    public:
-      typedef typename Encoding::Ch Ch;
-
-      Hasher(Allocator *allocator = 0, size_t stackCapacity = kDefaultSize) : stack_(allocator, stackCapacity) {}
-
-      bool Null()
-      {
-        return WriteType(kNullType);
-      }
-      bool Bool(bool b)
-      {
-        return WriteType(b ? kTrueType : kFalseType);
-      }
-      bool Int(int i)
-      {
-        Number n;
-        n.u.i = i;
-        n.d = static_cast<double>(i);
-        return WriteNumber(n);
-      }
-      bool Uint(unsigned u)
-      {
-        Number n;
-        n.u.u = u;
-        n.d = static_cast<double>(u);
-        return WriteNumber(n);
-      }
-      bool Int64(int64_t i)
-      {
-        Number n;
-        n.u.i = i;
-        n.d = static_cast<double>(i);
-        return WriteNumber(n);
-      }
-      bool Uint64(uint64_t u)
-      {
-        Number n;
-        n.u.u = u;
-        n.d = static_cast<double>(u);
-        return WriteNumber(n);
-      }
-      bool Double(double d)
-      {
-        Number n;
-        if (d < 0) n.u.i = static_cast<int64_t>(d);
-        else       n.u.u = static_cast<uint64_t>(d);
-        n.d = d;
-        return WriteNumber(n);
-      }
-
-      bool RawNumber(const Ch *str, SizeType len, bool)
-      {
-        WriteBuffer(kNumberType, str, len * sizeof(Ch));
-        return true;
-      }
-
-      bool String(const Ch *str, SizeType len, bool)
-      {
-        WriteBuffer(kStringType, str, len * sizeof(Ch));
-        return true;
-      }
-
-      bool StartObject()
-      {
-        return true;
-      }
-      bool Key(const Ch *str, SizeType len, bool copy)
-      {
-        return String(str, len, copy);
-      }
-      bool EndObject(SizeType memberCount)
-      {
-        uint64_t h = Hash(0, kObjectType);
-        uint64_t *kv = stack_.template Pop<uint64_t>(memberCount * 2);
-        for (SizeType i = 0; i < memberCount; i++)
-          h ^= Hash(kv[i * 2], kv[i * 2 + 1]);  // Use xor to achieve member order insensitive
-        *stack_.template Push<uint64_t>() = h;
-        return true;
-      }
-
-      bool StartArray()
-      {
-        return true;
-      }
-      bool EndArray(SizeType elementCount)
-      {
-        uint64_t h = Hash(0, kArrayType);
-        uint64_t *e = stack_.template Pop<uint64_t>(elementCount);
-        for (SizeType i = 0; i < elementCount; i++)
-          h = Hash(h, e[i]); // Use hash to achieve element order sensitive
-        *stack_.template Push<uint64_t>() = h;
-        return true;
-      }
-
-      bool IsValid() const
-      {
-        return stack_.GetSize() == sizeof(uint64_t);
-      }
-
-      uint64_t GetHashCode() const
-      {
-        RAPIDJSON_ASSERT(IsValid());
-        return *stack_.template Top<uint64_t>();
-      }
-
-    private:
-      static const size_t kDefaultSize = 256;
-      struct Number
-      {
-        union U
-        {
-          uint64_t u;
-          int64_t i;
-        } u;
-        double d;
-      };
-
-      bool WriteType(Type type)
-      {
-        return WriteBuffer(type, 0, 0);
-      }
-
-      bool WriteNumber(const Number &n)
-      {
-        return WriteBuffer(kNumberType, &n, sizeof(n));
-      }
-
-      bool WriteBuffer(Type type, const void *data, size_t len)
-      {
-        // FNV-1a from http://isthe.com/chongo/tech/comp/fnv/
-        uint64_t h = Hash(RAPIDJSON_UINT64_C2(0x84222325, 0xcbf29ce4), type);
-        const unsigned char *d = static_cast<const unsigned char *>(data);
-        for (size_t i = 0; i < len; i++)
-          h = Hash(h, d[i]);
-        *stack_.template Push<uint64_t>() = h;
-        return true;
-      }
-
-      static uint64_t Hash(uint64_t h, uint64_t d)
-      {
-        static const uint64_t kPrime = RAPIDJSON_UINT64_C2(0x00000100, 0x000001b3);
-        h ^= d;
-        h *= kPrime;
-        return h;
-      }
-
-      Stack<Allocator> stack_;
-  };
-
-///////////////////////////////////////////////////////////////////////////////
-// SchemaValidationContext
-
-  template <typename SchemaDocumentType>
-  struct SchemaValidationContext
-  {
-    typedef Schema<SchemaDocumentType> SchemaType;
-    typedef ISchemaStateFactory<SchemaType> SchemaValidatorFactoryType;
-    typedef IValidationErrorHandler<SchemaType> ErrorHandlerType;
-    typedef typename SchemaType::ValueType ValueType;
-    typedef typename ValueType::Ch Ch;
-
-    enum PatternValidatorType
-    {
-      kPatternValidatorOnly,
-      kPatternValidatorWithProperty,
-      kPatternValidatorWithAdditionalProperty
-    };
-
-    SchemaValidationContext(SchemaValidatorFactoryType &f, ErrorHandlerType &eh, const SchemaType *s) :
-      factory(f),
-      error_handler(eh),
-      schema(s),
-      valueSchema(),
-      invalidKeyword(),
-      hasher(),
-      arrayElementHashCodes(),
-      validators(),
-      validatorCount(),
-      patternPropertiesValidators(),
-      patternPropertiesValidatorCount(),
-      patternPropertiesSchemas(),
-      patternPropertiesSchemaCount(),
-      valuePatternValidatorType(kPatternValidatorOnly),
-      propertyExist(),
-      inArray(false),
-      valueUniqueness(false),
-      arrayUniqueness(false)
-    {
-    }
-
-    ~SchemaValidationContext()
-    {
-      if (hasher)
-        factory.DestroryHasher(hasher);
-      if (validators)
-        {
-          for (SizeType i = 0; i < validatorCount; i++)
-            factory.DestroySchemaValidator(validators[i]);
-          factory.FreeState(validators);
-        }
-      if (patternPropertiesValidators)
-        {
-          for (SizeType i = 0; i < patternPropertiesValidatorCount; i++)
-            factory.DestroySchemaValidator(patternPropertiesValidators[i]);
-          factory.FreeState(patternPropertiesValidators);
-        }
-      if (patternPropertiesSchemas)
-        factory.FreeState(patternPropertiesSchemas);
-      if (propertyExist)
-        factory.FreeState(propertyExist);
-    }
-
-    SchemaValidatorFactoryType &factory;
-    ErrorHandlerType &error_handler;
-    const SchemaType *schema;
-    const SchemaType *valueSchema;
-    const Ch *invalidKeyword;
-    void *hasher; // Only validator access
-    void *arrayElementHashCodes; // Only validator access this
-    ISchemaValidator **validators;
-    SizeType validatorCount;
-    ISchemaValidator **patternPropertiesValidators;
-    SizeType patternPropertiesValidatorCount;
-    const SchemaType **patternPropertiesSchemas;
-    SizeType patternPropertiesSchemaCount;
-    PatternValidatorType valuePatternValidatorType;
-    PatternValidatorType objectPatternValidatorType;
-    SizeType arrayElementIndex;
-    bool *propertyExist;
-    bool inArray;
-    bool valueUniqueness;
-    bool arrayUniqueness;
-  };
-
-///////////////////////////////////////////////////////////////////////////////
-// Schema
-
-  template <typename SchemaDocumentType>
-  class Schema
-  {
-    public:
-      typedef typename SchemaDocumentType::ValueType ValueType;
-      typedef typename SchemaDocumentType::AllocatorType AllocatorType;
-      typedef typename SchemaDocumentType::PointerType PointerType;
-      typedef typename ValueType::EncodingType EncodingType;
-      typedef typename EncodingType::Ch Ch;
-      typedef SchemaValidationContext<SchemaDocumentType> Context;
-      typedef Schema<SchemaDocumentType> SchemaType;
-      typedef GenericValue<EncodingType, AllocatorType> SValue;
-      typedef IValidationErrorHandler<Schema> ErrorHandler;
-      friend class GenericSchemaDocument<ValueType, AllocatorType>;
-
-      Schema(SchemaDocumentType *schemaDocument, const PointerType &p, const ValueType &value, const ValueType &document, AllocatorType *allocator) :
-        allocator_(allocator),
-        uri_(schemaDocument->GetURI(), *allocator),
-        pointer_(p),
-        typeless_(schemaDocument->GetTypeless()),
-        enum_(),
-        enumCount_(),
-        not_(),
-        type_((1 << kTotalSchemaType) - 1), // typeless
-        validatorCount_(),
-        notValidatorIndex_(),
-        properties_(),
-        additionalPropertiesSchema_(),
-        patternProperties_(),
-        patternPropertyCount_(),
-        propertyCount_(),
-        minProperties_(),
-        maxProperties_(SizeType(~0)),
-        additionalProperties_(true),
-        hasDependencies_(),
-        hasRequired_(),
-        hasSchemaDependencies_(),
-        additionalItemsSchema_(),
-        itemsList_(),
-        itemsTuple_(),
-        itemsTupleCount_(),
-        minItems_(),
-        maxItems_(SizeType(~0)),
-        additionalItems_(true),
-        uniqueItems_(false),
-        pattern_(),
-        minLength_(0),
-        maxLength_(~SizeType(0)),
-        exclusiveMinimum_(false),
-        exclusiveMaximum_(false),
-        defaultValueLength_(0)
-      {
-        typedef typename ValueType::ConstValueIterator ConstValueIterator;
-        typedef typename ValueType::ConstMemberIterator ConstMemberIterator;
-
-        if (!value.IsObject())
-          return;
-
-        if (const ValueType *v = GetMember(value, GetTypeString()))
-          {
-            type_ = 0;
-            if (v->IsString())
-              AddType(*v);
-            else if (v->IsArray())
-              for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr)
-                AddType(*itr);
-          }
-
-        if (const ValueType *v = GetMember(value, GetEnumString()))
-          if (v->IsArray() && v->Size() > 0)
-            {
-              enum_ = static_cast<uint64_t *>(allocator_->Malloc(sizeof(uint64_t) * v->Size()));
-              for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr)
-                {
-                  typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
-                  char buffer[256u + 24];
-                  MemoryPoolAllocator<> hasherAllocator(buffer, sizeof(buffer));
-                  EnumHasherType h(&hasherAllocator, 256);
-                  itr->Accept(h);
-                  enum_[enumCount_++] = h.GetHashCode();
-                }
-            }
-
-        if (schemaDocument)
-          {
-            AssignIfExist(allOf_, *schemaDocument, p, value, GetAllOfString(), document);
-            AssignIfExist(anyOf_, *schemaDocument, p, value, GetAnyOfString(), document);
-            AssignIfExist(oneOf_, *schemaDocument, p, value, GetOneOfString(), document);
-          }
-
-        if (const ValueType *v = GetMember(value, GetNotString()))
-          {
-            schemaDocument->CreateSchema(&not_, p.Append(GetNotString(), allocator_), *v, document);
-            notValidatorIndex_ = validatorCount_;
-            validatorCount_++;
-          }
-
-        // Object
-
-        const ValueType *properties = GetMember(value, GetPropertiesString());
-        const ValueType *required = GetMember(value, GetRequiredString());
-        const ValueType *dependencies = GetMember(value, GetDependenciesString());
-        {
-          // Gather properties from properties/required/dependencies
-          SValue allProperties(kArrayType);
-
-          if (properties && properties->IsObject())
-            for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr)
-              AddUniqueElement(allProperties, itr->name);
-
-          if (required && required->IsArray())
-            for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
-              if (itr->IsString())
-                AddUniqueElement(allProperties, *itr);
-
-          if (dependencies && dependencies->IsObject())
-            for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr)
-              {
-                AddUniqueElement(allProperties, itr->name);
-                if (itr->value.IsArray())
-                  for (ConstValueIterator i = itr->value.Begin(); i != itr->value.End(); ++i)
-                    if (i->IsString())
-                      AddUniqueElement(allProperties, *i);
-              }
-
-          if (allProperties.Size() > 0)
-            {
-              propertyCount_ = allProperties.Size();
-              properties_ = static_cast<Property *>(allocator_->Malloc(sizeof(Property) * propertyCount_));
-              for (SizeType i = 0; i < propertyCount_; i++)
-                {
-                  new (&properties_[i]) Property();
-                  properties_[i].name = allProperties[i];
-                  properties_[i].schema = typeless_;
-                }
-            }
-        }
-
-        if (properties && properties->IsObject())
-          {
-            PointerType q = p.Append(GetPropertiesString(), allocator_);
-            for (ConstMemberIterator itr = properties->MemberBegin(); itr != properties->MemberEnd(); ++itr)
-              {
-                SizeType index;
-                if (FindPropertyIndex(itr->name, &index))
-                  schemaDocument->CreateSchema(&properties_[index].schema, q.Append(itr->name, allocator_), itr->value, document);
-              }
-          }
-
-        if (const ValueType *v = GetMember(value, GetPatternPropertiesString()))
-          {
-            PointerType q = p.Append(GetPatternPropertiesString(), allocator_);
-            patternProperties_ = static_cast<PatternProperty *>(allocator_->Malloc(sizeof(PatternProperty) * v->MemberCount()));
-            patternPropertyCount_ = 0;
-
-            for (ConstMemberIterator itr = v->MemberBegin(); itr != v->MemberEnd(); ++itr)
-              {
-                new (&patternProperties_[patternPropertyCount_]) PatternProperty();
-                patternProperties_[patternPropertyCount_].pattern = CreatePattern(itr->name);
-                schemaDocument->CreateSchema(&patternProperties_[patternPropertyCount_].schema, q.Append(itr->name, allocator_), itr->value, document);
-                patternPropertyCount_++;
-              }
-          }
-
-        if (required && required->IsArray())
-          for (ConstValueIterator itr = required->Begin(); itr != required->End(); ++itr)
-            if (itr->IsString())
-              {
-                SizeType index;
-                if (FindPropertyIndex(*itr, &index))
-                  {
-                    properties_[index].required = true;
-                    hasRequired_ = true;
-                  }
-              }
-
-        if (dependencies && dependencies->IsObject())
-          {
-            PointerType q = p.Append(GetDependenciesString(), allocator_);
-            hasDependencies_ = true;
-            for (ConstMemberIterator itr = dependencies->MemberBegin(); itr != dependencies->MemberEnd(); ++itr)
-              {
-                SizeType sourceIndex = 0;
-                if (FindPropertyIndex(itr->name, &sourceIndex))
-                  {
-                    if (itr->value.IsArray())
-                      {
-                        properties_[sourceIndex].dependencies = static_cast<bool *>(allocator_->Malloc(sizeof(bool) * propertyCount_));
-                        std::memset(properties_[sourceIndex].dependencies, 0, sizeof(bool)* propertyCount_);
-                        for (ConstValueIterator targetItr = itr->value.Begin(); targetItr != itr->value.End(); ++targetItr)
-                          {
-                            SizeType targetIndex = 0;
-                            if (FindPropertyIndex(*targetItr, &targetIndex))
-                              properties_[sourceIndex].dependencies[targetIndex] = true;
-                          }
-                      }
-                    else if (itr->value.IsObject())
-                      {
-                        hasSchemaDependencies_ = true;
-                        schemaDocument->CreateSchema(&properties_[sourceIndex].dependenciesSchema, q.Append(itr->name, allocator_), itr->value, document);
-                        properties_[sourceIndex].dependenciesValidatorIndex = validatorCount_;
-                        validatorCount_++;
-                      }
-                  }
-              }
-          }
-
-        if (const ValueType *v = GetMember(value, GetAdditionalPropertiesString()))
-          {
-            if (v->IsBool())
-              additionalProperties_ = v->GetBool();
-            else if (v->IsObject())
-              schemaDocument->CreateSchema(&additionalPropertiesSchema_, p.Append(GetAdditionalPropertiesString(), allocator_), *v, document);
-          }
-
-        AssignIfExist(minProperties_, value, GetMinPropertiesString());
-        AssignIfExist(maxProperties_, value, GetMaxPropertiesString());
-
-        // Array
-        if (const ValueType *v = GetMember(value, GetItemsString()))
-          {
-            PointerType q = p.Append(GetItemsString(), allocator_);
-            if (v->IsObject()) // List validation
-              schemaDocument->CreateSchema(&itemsList_, q, *v, document);
-            else if (v->IsArray())   // Tuple validation
-              {
-                itemsTuple_ = static_cast<const Schema **>(allocator_->Malloc(sizeof(const Schema *) * v->Size()));
-                SizeType index = 0;
-                for (ConstValueIterator itr = v->Begin(); itr != v->End(); ++itr, index++)
-                  schemaDocument->CreateSchema(&itemsTuple_[itemsTupleCount_++], q.Append(index, allocator_), *itr, document);
-              }
-          }
-
-        AssignIfExist(minItems_, value, GetMinItemsString());
-        AssignIfExist(maxItems_, value, GetMaxItemsString());
-
-        if (const ValueType *v = GetMember(value, GetAdditionalItemsString()))
-          {
-            if (v->IsBool())
-              additionalItems_ = v->GetBool();
-            else if (v->IsObject())
-              schemaDocument->CreateSchema(&additionalItemsSchema_, p.Append(GetAdditionalItemsString(), allocator_), *v, document);
-          }
-
-        AssignIfExist(uniqueItems_, value, GetUniqueItemsString());
-
-        // String
-        AssignIfExist(minLength_, value, GetMinLengthString());
-        AssignIfExist(maxLength_, value, GetMaxLengthString());
-
-        if (const ValueType *v = GetMember(value, GetPatternString()))
-          pattern_ = CreatePattern(*v);
-
-        // Number
-        if (const ValueType *v = GetMember(value, GetMinimumString()))
-          if (v->IsNumber())
-            minimum_.CopyFrom(*v, *allocator_);
-
-        if (const ValueType *v = GetMember(value, GetMaximumString()))
-          if (v->IsNumber())
-            maximum_.CopyFrom(*v, *allocator_);
-
-        AssignIfExist(exclusiveMinimum_, value, GetExclusiveMinimumString());
-        AssignIfExist(exclusiveMaximum_, value, GetExclusiveMaximumString());
-
-        if (const ValueType *v = GetMember(value, GetMultipleOfString()))
-          if (v->IsNumber() && v->GetDouble() > 0.0)
-            multipleOf_.CopyFrom(*v, *allocator_);
-
-        // Default
-        if (const ValueType *v = GetMember(value, GetDefaultValueString()))
-          if (v->IsString())
-            defaultValueLength_ = v->GetStringLength();
-
-      }
-
-      ~Schema()
-      {
-        AllocatorType::Free(enum_);
-        if (properties_)
-          {
-            for (SizeType i = 0; i < propertyCount_; i++)
-              properties_[i].~Property();
-            AllocatorType::Free(properties_);
-          }
-        if (patternProperties_)
-          {
-            for (SizeType i = 0; i < patternPropertyCount_; i++)
-              patternProperties_[i].~PatternProperty();
-            AllocatorType::Free(patternProperties_);
-          }
-        AllocatorType::Free(itemsTuple_);
-#if RAPIDJSON_SCHEMA_HAS_REGEX
-        if (pattern_)
-          {
-            pattern_->~RegexType();
-            AllocatorType::Free(pattern_);
-          }
-#endif
-      }
-
-      const SValue &GetURI() const
-      {
-        return uri_;
-      }
-
-      const PointerType &GetPointer() const
-      {
-        return pointer_;
-      }
-
-      bool BeginValue(Context &context) const
-      {
-        if (context.inArray)
-          {
-            if (uniqueItems_)
-              context.valueUniqueness = true;
-
-            if (itemsList_)
-              context.valueSchema = itemsList_;
-            else if (itemsTuple_)
-              {
-                if (context.arrayElementIndex < itemsTupleCount_)
-                  context.valueSchema = itemsTuple_[context.arrayElementIndex];
-                else if (additionalItemsSchema_)
-                  context.valueSchema = additionalItemsSchema_;
-                else if (additionalItems_)
-                  context.valueSchema = typeless_;
-                else
-                  {
-                    context.error_handler.DisallowedItem(context.arrayElementIndex);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetItemsString());
-                  }
-              }
-            else
-              context.valueSchema = typeless_;
-
-            context.arrayElementIndex++;
-          }
-        return true;
-      }
-
-      RAPIDJSON_FORCEINLINE bool EndValue(Context &context) const
-      {
-        if (context.patternPropertiesValidatorCount > 0)
-          {
-            bool otherValid = false;
-            SizeType count = context.patternPropertiesValidatorCount;
-            if (context.objectPatternValidatorType != Context::kPatternValidatorOnly)
-              otherValid = context.patternPropertiesValidators[--count]->IsValid();
-
-            bool patternValid = true;
-            for (SizeType i = 0; i < count; i++)
-              if (!context.patternPropertiesValidators[i]->IsValid())
-                {
-                  patternValid = false;
-                  break;
-                }
-
-            if (context.objectPatternValidatorType == Context::kPatternValidatorOnly)
-              {
-                if (!patternValid)
-                  {
-                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
-                  }
-              }
-            else if (context.objectPatternValidatorType == Context::kPatternValidatorWithProperty)
-              {
-                if (!patternValid || !otherValid)
-                  {
-                    context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
-                  }
-              }
-            else if (!patternValid && !otherValid)   // kPatternValidatorWithAdditionalProperty)
-              {
-                context.error_handler.PropertyViolations(context.patternPropertiesValidators, count + 1);
-                RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternPropertiesString());
-              }
-          }
-
-        if (enum_)
-          {
-            const uint64_t h = context.factory.GetHashCode(context.hasher);
-            for (SizeType i = 0; i < enumCount_; i++)
-              if (enum_[i] == h)
-                goto foundEnum;
-            context.error_handler.DisallowedValue();
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetEnumString());
-          foundEnum:
-            ;
-          }
-
-        if (allOf_.schemas)
-          for (SizeType i = allOf_.begin; i < allOf_.begin + allOf_.count; i++)
-            if (!context.validators[i]->IsValid())
-              {
-                context.error_handler.NotAllOf(&context.validators[allOf_.begin], allOf_.count);
-                RAPIDJSON_INVALID_KEYWORD_RETURN(GetAllOfString());
-              }
-
-        if (anyOf_.schemas)
-          {
-            for (SizeType i = anyOf_.begin; i < anyOf_.begin + anyOf_.count; i++)
-              if (context.validators[i]->IsValid())
-                goto foundAny;
-            context.error_handler.NoneOf(&context.validators[anyOf_.begin], anyOf_.count);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetAnyOfString());
-          foundAny:
-            ;
-          }
-
-        if (oneOf_.schemas)
-          {
-            bool oneValid = false;
-            for (SizeType i = oneOf_.begin; i < oneOf_.begin + oneOf_.count; i++)
-              if (context.validators[i]->IsValid())
-                {
-                  if (oneValid)
-                    {
-                      context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
-                      RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
-                    }
-                  else
-                    oneValid = true;
-                }
-            if (!oneValid)
-              {
-                context.error_handler.NotOneOf(&context.validators[oneOf_.begin], oneOf_.count);
-                RAPIDJSON_INVALID_KEYWORD_RETURN(GetOneOfString());
-              }
-          }
-
-        if (not_ && context.validators[notValidatorIndex_]->IsValid())
-          {
-            context.error_handler.Disallowed();
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetNotString());
-          }
-
-        return true;
-      }
-
-      bool Null(Context &context) const
-      {
-        if (!(type_ & (1 << kNullSchemaType)))
-          {
-            DisallowedType(context, GetNullString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
-          }
-        return CreateParallelValidator(context);
-      }
-
-      bool Bool(Context &context, bool) const
-      {
-        if (!(type_ & (1 << kBooleanSchemaType)))
-          {
-            DisallowedType(context, GetBooleanString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
-          }
-        return CreateParallelValidator(context);
-      }
-
-      bool Int(Context &context, int i) const
-      {
-        if (!CheckInt(context, i))
-          return false;
-        return CreateParallelValidator(context);
-      }
-
-      bool Uint(Context &context, unsigned u) const
-      {
-        if (!CheckUint(context, u))
-          return false;
-        return CreateParallelValidator(context);
-      }
-
-      bool Int64(Context &context, int64_t i) const
-      {
-        if (!CheckInt(context, i))
-          return false;
-        return CreateParallelValidator(context);
-      }
-
-      bool Uint64(Context &context, uint64_t u) const
-      {
-        if (!CheckUint(context, u))
-          return false;
-        return CreateParallelValidator(context);
-      }
-
-      bool Double(Context &context, double d) const
-      {
-        if (!(type_ & (1 << kNumberSchemaType)))
-          {
-            DisallowedType(context, GetNumberString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
-          }
-
-        if (!minimum_.IsNull() && !CheckDoubleMinimum(context, d))
-          return false;
-
-        if (!maximum_.IsNull() && !CheckDoubleMaximum(context, d))
-          return false;
-
-        if (!multipleOf_.IsNull() && !CheckDoubleMultipleOf(context, d))
-          return false;
-
-        return CreateParallelValidator(context);
-      }
-
-      bool String(Context &context, const Ch *str, SizeType length, bool) const
-      {
-        if (!(type_ & (1 << kStringSchemaType)))
-          {
-            DisallowedType(context, GetStringString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
-          }
-
-        if (minLength_ != 0 || maxLength_ != SizeType(~0))
-          {
-            SizeType count;
-            if (internal::CountStringCodePoint<EncodingType>(str, length, &count))
-              {
-                if (count < minLength_)
-                  {
-                    context.error_handler.TooShort(str, length, minLength_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinLengthString());
-                  }
-                if (count > maxLength_)
-                  {
-                    context.error_handler.TooLong(str, length, maxLength_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxLengthString());
-                  }
-              }
-          }
-
-        if (pattern_ && !IsPatternMatch(pattern_, str, length))
-          {
-            context.error_handler.DoesNotMatch(str, length);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetPatternString());
-          }
-
-        return CreateParallelValidator(context);
-      }
-
-      bool StartObject(Context &context) const
-      {
-        if (!(type_ & (1 << kObjectSchemaType)))
-          {
-            DisallowedType(context, GetObjectString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
-          }
-
-        if (hasDependencies_ || hasRequired_)
-          {
-            context.propertyExist = static_cast<bool *>(context.factory.MallocState(sizeof(bool) * propertyCount_));
-            std::memset(context.propertyExist, 0, sizeof(bool) * propertyCount_);
-          }
-
-        if (patternProperties_)   // pre-allocate schema array
-          {
-            SizeType count = patternPropertyCount_ + 1; // extra for valuePatternValidatorType
-            context.patternPropertiesSchemas = static_cast<const SchemaType **>(context.factory.MallocState(sizeof(const SchemaType *) * count));
-            context.patternPropertiesSchemaCount = 0;
-            std::memset(context.patternPropertiesSchemas, 0, sizeof(SchemaType *) * count);
-          }
-
-        return CreateParallelValidator(context);
-      }
-
-      bool Key(Context &context, const Ch *str, SizeType len, bool) const
-      {
-        if (patternProperties_)
-          {
-            context.patternPropertiesSchemaCount = 0;
-            for (SizeType i = 0; i < patternPropertyCount_; i++)
-              if (patternProperties_[i].pattern && IsPatternMatch(patternProperties_[i].pattern, str, len))
-                {
-                  context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = patternProperties_[i].schema;
-                  context.valueSchema = typeless_;
-                }
-          }
-
-        SizeType index;
-        if (FindPropertyIndex(ValueType(str, len).Move(), &index))
-          {
-            if (context.patternPropertiesSchemaCount > 0)
-              {
-                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = properties_[index].schema;
-                context.valueSchema = typeless_;
-                context.valuePatternValidatorType = Context::kPatternValidatorWithProperty;
-              }
-            else
-              context.valueSchema = properties_[index].schema;
-
-            if (context.propertyExist)
-              context.propertyExist[index] = true;
-
-            return true;
-          }
-
-        if (additionalPropertiesSchema_)
-          {
-            if (additionalPropertiesSchema_ && context.patternPropertiesSchemaCount > 0)
-              {
-                context.patternPropertiesSchemas[context.patternPropertiesSchemaCount++] = additionalPropertiesSchema_;
-                context.valueSchema = typeless_;
-                context.valuePatternValidatorType = Context::kPatternValidatorWithAdditionalProperty;
-              }
-            else
-              context.valueSchema = additionalPropertiesSchema_;
-            return true;
-          }
-        else if (additionalProperties_)
-          {
-            context.valueSchema = typeless_;
-            return true;
-          }
-
-        if (context.patternPropertiesSchemaCount == 0)   // patternProperties are not additional properties
-          {
-            context.error_handler.DisallowedProperty(str, len);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetAdditionalPropertiesString());
-          }
-
-        return true;
-      }
-
-      bool EndObject(Context &context, SizeType memberCount) const
-      {
-        if (hasRequired_)
-          {
-            context.error_handler.StartMissingProperties();
-            for (SizeType index = 0; index < propertyCount_; index++)
-              if (properties_[index].required && !context.propertyExist[index])
-                if (properties_[index].schema->defaultValueLength_ == 0 )
-                  context.error_handler.AddMissingProperty(properties_[index].name);
-            if (context.error_handler.EndMissingProperties())
-              RAPIDJSON_INVALID_KEYWORD_RETURN(GetRequiredString());
-          }
-
-        if (memberCount < minProperties_)
-          {
-            context.error_handler.TooFewProperties(memberCount, minProperties_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinPropertiesString());
-          }
-
-        if (memberCount > maxProperties_)
-          {
-            context.error_handler.TooManyProperties(memberCount, maxProperties_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxPropertiesString());
-          }
-
-        if (hasDependencies_)
-          {
-            context.error_handler.StartDependencyErrors();
-            for (SizeType sourceIndex = 0; sourceIndex < propertyCount_; sourceIndex++)
-              {
-                const Property &source = properties_[sourceIndex];
-                if (context.propertyExist[sourceIndex])
-                  {
-                    if (source.dependencies)
-                      {
-                        context.error_handler.StartMissingDependentProperties();
-                        for (SizeType targetIndex = 0; targetIndex < propertyCount_; targetIndex++)
-                          if (source.dependencies[targetIndex] && !context.propertyExist[targetIndex])
-                            context.error_handler.AddMissingDependentProperty(properties_[targetIndex].name);
-                        context.error_handler.EndMissingDependentProperties(source.name);
-                      }
-                    else if (source.dependenciesSchema)
-                      {
-                        ISchemaValidator *dependenciesValidator = context.validators[source.dependenciesValidatorIndex];
-                        if (!dependenciesValidator->IsValid())
-                          context.error_handler.AddDependencySchemaError(source.name, dependenciesValidator);
-                      }
-                  }
-              }
-            if (context.error_handler.EndDependencyErrors())
-              RAPIDJSON_INVALID_KEYWORD_RETURN(GetDependenciesString());
-          }
-
-        return true;
-      }
-
-      bool StartArray(Context &context) const
-      {
-        if (!(type_ & (1 << kArraySchemaType)))
-          {
-            DisallowedType(context, GetArrayString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
-          }
-
-        context.arrayElementIndex = 0;
-        context.inArray = true;
-
-        return CreateParallelValidator(context);
-      }
-
-      bool EndArray(Context &context, SizeType elementCount) const
-      {
-        context.inArray = false;
-
-        if (elementCount < minItems_)
-          {
-            context.error_handler.TooFewItems(elementCount, minItems_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinItemsString());
-          }
-
-        if (elementCount > maxItems_)
-          {
-            context.error_handler.TooManyItems(elementCount, maxItems_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaxItemsString());
-          }
-
-        return true;
-      }
-
-      // Generate functions for string literal according to Ch
-#define RAPIDJSON_STRING_(name, ...) \
-  static const ValueType& Get##name##String() {\
-    static const Ch s[] = { __VA_ARGS__, '\0' };\
-    static const ValueType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1));\
-    return v;\
-  }
-
-      RAPIDJSON_STRING_(Null, 'n', 'u', 'l', 'l')
-      RAPIDJSON_STRING_(Boolean, 'b', 'o', 'o', 'l', 'e', 'a', 'n')
-      RAPIDJSON_STRING_(Object, 'o', 'b', 'j', 'e', 'c', 't')
-      RAPIDJSON_STRING_(Array, 'a', 'r', 'r', 'a', 'y')
-      RAPIDJSON_STRING_(String, 's', 't', 'r', 'i', 'n', 'g')
-      RAPIDJSON_STRING_(Number, 'n', 'u', 'm', 'b', 'e', 'r')
-      RAPIDJSON_STRING_(Integer, 'i', 'n', 't', 'e', 'g', 'e', 'r')
-      RAPIDJSON_STRING_(Type, 't', 'y', 'p', 'e')
-      RAPIDJSON_STRING_(Enum, 'e', 'n', 'u', 'm')
-      RAPIDJSON_STRING_(AllOf, 'a', 'l', 'l', 'O', 'f')
-      RAPIDJSON_STRING_(AnyOf, 'a', 'n', 'y', 'O', 'f')
-      RAPIDJSON_STRING_(OneOf, 'o', 'n', 'e', 'O', 'f')
-      RAPIDJSON_STRING_(Not, 'n', 'o', 't')
-      RAPIDJSON_STRING_(Properties, 'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-      RAPIDJSON_STRING_(Required, 'r', 'e', 'q', 'u', 'i', 'r', 'e', 'd')
-      RAPIDJSON_STRING_(Dependencies, 'd', 'e', 'p', 'e', 'n', 'd', 'e', 'n', 'c', 'i', 'e', 's')
-      RAPIDJSON_STRING_(PatternProperties, 'p', 'a', 't', 't', 'e', 'r', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-      RAPIDJSON_STRING_(AdditionalProperties, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-      RAPIDJSON_STRING_(MinProperties, 'm', 'i', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-      RAPIDJSON_STRING_(MaxProperties, 'm', 'a', 'x', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's')
-      RAPIDJSON_STRING_(Items, 'i', 't', 'e', 'm', 's')
-      RAPIDJSON_STRING_(MinItems, 'm', 'i', 'n', 'I', 't', 'e', 'm', 's')
-      RAPIDJSON_STRING_(MaxItems, 'm', 'a', 'x', 'I', 't', 'e', 'm', 's')
-      RAPIDJSON_STRING_(AdditionalItems, 'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'I', 't', 'e', 'm', 's')
-      RAPIDJSON_STRING_(UniqueItems, 'u', 'n', 'i', 'q', 'u', 'e', 'I', 't', 'e', 'm', 's')
-      RAPIDJSON_STRING_(MinLength, 'm', 'i', 'n', 'L', 'e', 'n', 'g', 't', 'h')
-      RAPIDJSON_STRING_(MaxLength, 'm', 'a', 'x', 'L', 'e', 'n', 'g', 't', 'h')
-      RAPIDJSON_STRING_(Pattern, 'p', 'a', 't', 't', 'e', 'r', 'n')
-      RAPIDJSON_STRING_(Minimum, 'm', 'i', 'n', 'i', 'm', 'u', 'm')
-      RAPIDJSON_STRING_(Maximum, 'm', 'a', 'x', 'i', 'm', 'u', 'm')
-      RAPIDJSON_STRING_(ExclusiveMinimum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'i', 'n', 'i', 'm', 'u', 'm')
-      RAPIDJSON_STRING_(ExclusiveMaximum, 'e', 'x', 'c', 'l', 'u', 's', 'i', 'v', 'e', 'M', 'a', 'x', 'i', 'm', 'u', 'm')
-      RAPIDJSON_STRING_(MultipleOf, 'm', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'O', 'f')
-      RAPIDJSON_STRING_(DefaultValue, 'd', 'e', 'f', 'a', 'u', 'l', 't')
-
-#undef RAPIDJSON_STRING_
-
-    private:
-      enum SchemaValueType
-      {
-        kNullSchemaType,
-        kBooleanSchemaType,
-        kObjectSchemaType,
-        kArraySchemaType,
-        kStringSchemaType,
-        kNumberSchemaType,
-        kIntegerSchemaType,
-        kTotalSchemaType
-      };
-
-#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
-      typedef internal::GenericRegex<EncodingType, AllocatorType> RegexType;
-#elif RAPIDJSON_SCHEMA_USE_STDREGEX
-      typedef std::basic_regex<Ch> RegexType;
-#else
-      typedef char RegexType;
-#endif
-
-      struct SchemaArray
-      {
-        SchemaArray() : schemas(), count() {}
-        ~SchemaArray()
-        {
-          AllocatorType::Free(schemas);
-        }
-        const SchemaType **schemas;
-        SizeType begin; // begin index of context.validators
-        SizeType count;
-      };
-
-      template <typename V1, typename V2>
-      void AddUniqueElement(V1 &a, const V2 &v)
-      {
-        for (typename V1::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
-          if (*itr == v)
-            return;
-        V1 c(v, *allocator_);
-        a.PushBack(c, *allocator_);
-      }
-
-      static const ValueType *GetMember(const ValueType &value, const ValueType &name)
-      {
-        typename ValueType::ConstMemberIterator itr = value.FindMember(name);
-        return itr != value.MemberEnd() ? &(itr->value) : 0;
-      }
-
-      static void AssignIfExist(bool &out, const ValueType &value, const ValueType &name)
-      {
-        if (const ValueType *v = GetMember(value, name))
-          if (v->IsBool())
-            out = v->GetBool();
-      }
-
-      static void AssignIfExist(SizeType &out, const ValueType &value, const ValueType &name)
-      {
-        if (const ValueType *v = GetMember(value, name))
-          if (v->IsUint64() && v->GetUint64() <= SizeType(~0))
-            out = static_cast<SizeType>(v->GetUint64());
-      }
-
-      void AssignIfExist(SchemaArray &out, SchemaDocumentType &schemaDocument, const PointerType &p, const ValueType &value, const ValueType &name, const ValueType &document)
-      {
-        if (const ValueType *v = GetMember(value, name))
-          {
-            if (v->IsArray() && v->Size() > 0)
-              {
-                PointerType q = p.Append(name, allocator_);
-                out.count = v->Size();
-                out.schemas = static_cast<const Schema **>(allocator_->Malloc(out.count * sizeof(const Schema *)));
-                memset(out.schemas, 0, sizeof(Schema *)* out.count);
-                for (SizeType i = 0; i < out.count; i++)
-                  schemaDocument.CreateSchema(&out.schemas[i], q.Append(i, allocator_), (*v)[i], document);
-                out.begin = validatorCount_;
-                validatorCount_ += out.count;
-              }
-          }
-      }
-
-#if RAPIDJSON_SCHEMA_USE_INTERNALREGEX
-      template <typename ValueType>
-      RegexType *CreatePattern(const ValueType &value)
-      {
-        if (value.IsString())
-          {
-            RegexType *r = new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), allocator_);
-            if (!r->IsValid())
-              {
-                r->~RegexType();
-                AllocatorType::Free(r);
-                r = 0;
-              }
-            return r;
-          }
-        return 0;
-      }
-
-      static bool IsPatternMatch(const RegexType *pattern, const Ch *str, SizeType)
-      {
-        GenericRegexSearch<RegexType> rs(*pattern);
-        return rs.Search(str);
-      }
-#elif RAPIDJSON_SCHEMA_USE_STDREGEX
-      template <typename ValueType>
-      RegexType *CreatePattern(const ValueType &value)
-      {
-        if (value.IsString())
-          try
-            {
-              return new (allocator_->Malloc(sizeof(RegexType))) RegexType(value.GetString(), std::size_t(value.GetStringLength()), std::regex_constants::ECMAScript);
-            }
-          catch (const std::regex_error &)
-            {
-            }
-        return 0;
-      }
-
-      static bool IsPatternMatch(const RegexType *pattern, const Ch *str, SizeType length)
-      {
-        std::match_results<const Ch *> r;
-        return std::regex_search(str, str + length, r, *pattern);
-      }
-#else
-      template <typename ValueType>
-      RegexType *CreatePattern(const ValueType &)
-      {
-        return 0;
-      }
-
-      static bool IsPatternMatch(const RegexType *, const Ch *, SizeType)
-      {
-        return true;
-      }
-#endif // RAPIDJSON_SCHEMA_USE_STDREGEX
-
-      void AddType(const ValueType &type)
-      {
-        if      (type == GetNullString()   ) type_ |= 1 << kNullSchemaType;
-        else if (type == GetBooleanString()) type_ |= 1 << kBooleanSchemaType;
-        else if (type == GetObjectString() ) type_ |= 1 << kObjectSchemaType;
-        else if (type == GetArrayString()  ) type_ |= 1 << kArraySchemaType;
-        else if (type == GetStringString() ) type_ |= 1 << kStringSchemaType;
-        else if (type == GetIntegerString()) type_ |= 1 << kIntegerSchemaType;
-        else if (type == GetNumberString() ) type_ |= (1 << kNumberSchemaType) | (1 << kIntegerSchemaType);
-      }
-
-      bool CreateParallelValidator(Context &context) const
-      {
-        if (enum_ || context.arrayUniqueness)
-          context.hasher = context.factory.CreateHasher();
-
-        if (validatorCount_)
-          {
-            RAPIDJSON_ASSERT(context.validators == 0);
-            context.validators = static_cast<ISchemaValidator **>(context.factory.MallocState(sizeof(ISchemaValidator *) * validatorCount_));
-            context.validatorCount = validatorCount_;
-
-            if (allOf_.schemas)
-              CreateSchemaValidators(context, allOf_);
-
-            if (anyOf_.schemas)
-              CreateSchemaValidators(context, anyOf_);
-
-            if (oneOf_.schemas)
-              CreateSchemaValidators(context, oneOf_);
-
-            if (not_)
-              context.validators[notValidatorIndex_] = context.factory.CreateSchemaValidator(*not_);
-
-            if (hasSchemaDependencies_)
-              {
-                for (SizeType i = 0; i < propertyCount_; i++)
-                  if (properties_[i].dependenciesSchema)
-                    context.validators[properties_[i].dependenciesValidatorIndex] = context.factory.CreateSchemaValidator(*properties_[i].dependenciesSchema);
-              }
-          }
-
-        return true;
-      }
-
-      void CreateSchemaValidators(Context &context, const SchemaArray &schemas) const
-      {
-        for (SizeType i = 0; i < schemas.count; i++)
-          context.validators[schemas.begin + i] = context.factory.CreateSchemaValidator(*schemas.schemas[i]);
-      }
-
-      // O(n)
-      bool FindPropertyIndex(const ValueType &name, SizeType *outIndex) const
-      {
-        SizeType len = name.GetStringLength();
-        const Ch *str = name.GetString();
-        for (SizeType index = 0; index < propertyCount_; index++)
-          if (properties_[index].name.GetStringLength() == len &&
-              (std::memcmp(properties_[index].name.GetString(), str, sizeof(Ch) * len) == 0))
-            {
-              *outIndex = index;
-              return true;
-            }
-        return false;
-      }
-
-      bool CheckInt(Context &context, int64_t i) const
-      {
-        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
-          {
-            DisallowedType(context, GetIntegerString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
-          }
-
-        if (!minimum_.IsNull())
-          {
-            if (minimum_.IsInt64())
-              {
-                if (exclusiveMinimum_ ? i <= minimum_.GetInt64() : i < minimum_.GetInt64())
-                  {
-                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
-                  }
-              }
-            else if (minimum_.IsUint64())
-              {
-                context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
-                RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString()); // i <= max(int64_t) < minimum.GetUint64()
-              }
-            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
-              return false;
-          }
-
-        if (!maximum_.IsNull())
-          {
-            if (maximum_.IsInt64())
-              {
-                if (exclusiveMaximum_ ? i >= maximum_.GetInt64() : i > maximum_.GetInt64())
-                  {
-                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
-                  }
-              }
-            else if (maximum_.IsUint64()) { }
-            /* do nothing */ // i <= max(int64_t) < maximum_.GetUint64()
-            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
-              return false;
-          }
-
-        if (!multipleOf_.IsNull())
-          {
-            if (multipleOf_.IsUint64())
-              {
-                if (static_cast<uint64_t>(i >= 0 ? i : -i) % multipleOf_.GetUint64() != 0)
-                  {
-                    context.error_handler.NotMultipleOf(i, multipleOf_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
-                  }
-              }
-            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
-              return false;
-          }
-
-        return true;
-      }
-
-      bool CheckUint(Context &context, uint64_t i) const
-      {
-        if (!(type_ & ((1 << kIntegerSchemaType) | (1 << kNumberSchemaType))))
-          {
-            DisallowedType(context, GetIntegerString());
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetTypeString());
-          }
-
-        if (!minimum_.IsNull())
-          {
-            if (minimum_.IsUint64())
-              {
-                if (exclusiveMinimum_ ? i <= minimum_.GetUint64() : i < minimum_.GetUint64())
-                  {
-                    context.error_handler.BelowMinimum(i, minimum_, exclusiveMinimum_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
-                  }
-              }
-            else if (minimum_.IsInt64())
-              /* do nothing */; // i >= 0 > minimum.Getint64()
-            else if (!CheckDoubleMinimum(context, static_cast<double>(i)))
-              return false;
-          }
-
-        if (!maximum_.IsNull())
-          {
-            if (maximum_.IsUint64())
-              {
-                if (exclusiveMaximum_ ? i >= maximum_.GetUint64() : i > maximum_.GetUint64())
-                  {
-                    context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
-                  }
-              }
-            else if (maximum_.IsInt64())
-              {
-                context.error_handler.AboveMaximum(i, maximum_, exclusiveMaximum_);
-                RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString()); // i >= 0 > maximum_
-              }
-            else if (!CheckDoubleMaximum(context, static_cast<double>(i)))
-              return false;
-          }
-
-        if (!multipleOf_.IsNull())
-          {
-            if (multipleOf_.IsUint64())
-              {
-                if (i % multipleOf_.GetUint64() != 0)
-                  {
-                    context.error_handler.NotMultipleOf(i, multipleOf_);
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
-                  }
-              }
-            else if (!CheckDoubleMultipleOf(context, static_cast<double>(i)))
-              return false;
-          }
-
-        return true;
-      }
-
-      bool CheckDoubleMinimum(Context &context, double d) const
-      {
-        if (exclusiveMinimum_ ? d <= minimum_.GetDouble() : d < minimum_.GetDouble())
-          {
-            context.error_handler.BelowMinimum(d, minimum_, exclusiveMinimum_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMinimumString());
-          }
-        return true;
-      }
-
-      bool CheckDoubleMaximum(Context &context, double d) const
-      {
-        if (exclusiveMaximum_ ? d >= maximum_.GetDouble() : d > maximum_.GetDouble())
-          {
-            context.error_handler.AboveMaximum(d, maximum_, exclusiveMaximum_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMaximumString());
-          }
-        return true;
-      }
-
-      bool CheckDoubleMultipleOf(Context &context, double d) const
-      {
-        double a = std::abs(d), b = std::abs(multipleOf_.GetDouble());
-        double q = std::floor(a / b);
-        double r = a - q * b;
-        if (r > 0.0)
-          {
-            context.error_handler.NotMultipleOf(d, multipleOf_);
-            RAPIDJSON_INVALID_KEYWORD_RETURN(GetMultipleOfString());
-          }
-        return true;
-      }
-
-      void DisallowedType(Context &context, const ValueType &actualType) const
-      {
-        ErrorHandler &eh = context.error_handler;
-        eh.StartDisallowedType();
-
-        if (type_ & (1 << kNullSchemaType)) eh.AddExpectedType(GetNullString());
-        if (type_ & (1 << kBooleanSchemaType)) eh.AddExpectedType(GetBooleanString());
-        if (type_ & (1 << kObjectSchemaType)) eh.AddExpectedType(GetObjectString());
-        if (type_ & (1 << kArraySchemaType)) eh.AddExpectedType(GetArrayString());
-        if (type_ & (1 << kStringSchemaType)) eh.AddExpectedType(GetStringString());
-
-        if (type_ & (1 << kNumberSchemaType)) eh.AddExpectedType(GetNumberString());
-        else if (type_ & (1 << kIntegerSchemaType)) eh.AddExpectedType(GetIntegerString());
-
-        eh.EndDisallowedType(actualType);
-      }
-
-      struct Property
-      {
-        Property() : schema(), dependenciesSchema(), dependenciesValidatorIndex(), dependencies(), required(false) {}
-        ~Property()
-        {
-          AllocatorType::Free(dependencies);
-        }
-        SValue name;
-        const SchemaType *schema;
-        const SchemaType *dependenciesSchema;
-        SizeType dependenciesValidatorIndex;
-        bool *dependencies;
-        bool required;
-      };
-
-      struct PatternProperty
-      {
-        PatternProperty() : schema(), pattern() {}
-        ~PatternProperty()
-        {
-          if (pattern)
-            {
-              pattern->~RegexType();
-              AllocatorType::Free(pattern);
-            }
-        }
-        const SchemaType *schema;
-        RegexType *pattern;
-      };
-
-      AllocatorType *allocator_;
-      SValue uri_;
-      PointerType pointer_;
-      const SchemaType *typeless_;
-      uint64_t *enum_;
-      SizeType enumCount_;
-      SchemaArray allOf_;
-      SchemaArray anyOf_;
-      SchemaArray oneOf_;
-      const SchemaType *not_;
-      unsigned type_; // bitmask of kSchemaType
-      SizeType validatorCount_;
-      SizeType notValidatorIndex_;
-
-      Property *properties_;
-      const SchemaType *additionalPropertiesSchema_;
-      PatternProperty *patternProperties_;
-      SizeType patternPropertyCount_;
-      SizeType propertyCount_;
-      SizeType minProperties_;
-      SizeType maxProperties_;
-      bool additionalProperties_;
-      bool hasDependencies_;
-      bool hasRequired_;
-      bool hasSchemaDependencies_;
-
-      const SchemaType *additionalItemsSchema_;
-      const SchemaType *itemsList_;
-      const SchemaType **itemsTuple_;
-      SizeType itemsTupleCount_;
-      SizeType minItems_;
-      SizeType maxItems_;
-      bool additionalItems_;
-      bool uniqueItems_;
-
-      RegexType *pattern_;
-      SizeType minLength_;
-      SizeType maxLength_;
-
-      SValue minimum_;
-      SValue maximum_;
-      SValue multipleOf_;
-      bool exclusiveMinimum_;
-      bool exclusiveMaximum_;
-
-      SizeType defaultValueLength_;
-  };
-
-  template<typename Stack, typename Ch>
-  struct TokenHelper
-  {
-    RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack &documentStack, SizeType index)
-    {
-      *documentStack.template Push<Ch>() = '/';
-      char buffer[21];
-      size_t length = static_cast<size_t>((sizeof(SizeType) == 4 ? u32toa(index, buffer) : u64toa(index, buffer)) - buffer);
-      for (size_t i = 0; i < length; i++)
-        *documentStack.template Push<Ch>() = static_cast<Ch>(buffer[i]);
-    }
-  };
-
-// Partial specialized version for char to prevent buffer copying.
-  template <typename Stack>
-  struct TokenHelper<Stack, char>
-  {
-    RAPIDJSON_FORCEINLINE static void AppendIndexToken(Stack &documentStack, SizeType index)
-    {
-      if (sizeof(SizeType) == 4)
-        {
-          char *buffer = documentStack.template Push<char>(1 + 10); // '/' + uint
-          *buffer++ = '/';
-          const char *end = internal::u32toa(index, buffer);
-          documentStack.template Pop<char>(static_cast<size_t>(10 - (end - buffer)));
-        }
-      else
-        {
-          char *buffer = documentStack.template Push<char>(1 + 20); // '/' + uint64
-          *buffer++ = '/';
-          const char *end = internal::u64toa(index, buffer);
-          documentStack.template Pop<char>(static_cast<size_t>(20 - (end - buffer)));
-        }
-    }
-  };
-
-} // namespace internal
-
-///////////////////////////////////////////////////////////////////////////////
-// IGenericRemoteSchemaDocumentProvider
-
-template <typename SchemaDocumentType>
-class IGenericRemoteSchemaDocumentProvider
-{
-  public:
-    typedef typename SchemaDocumentType::Ch Ch;
-
-    virtual ~IGenericRemoteSchemaDocumentProvider() {}
-    virtual const SchemaDocumentType *GetRemoteDocument(const Ch *uri, SizeType length) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericSchemaDocument
-
-//! JSON schema document.
-/*!
-    A JSON schema document is a compiled version of a JSON schema.
-    It is basically a tree of internal::Schema.
-
-    \note This is an immutable class (i.e. its instance cannot be modified after construction).
-    \tparam ValueT Type of JSON value (e.g. \c Value ), which also determine the encoding.
-    \tparam Allocator Allocator type for allocating memory of this document.
-*/
-template <typename ValueT, typename Allocator = CrtAllocator>
-class GenericSchemaDocument
-{
-  public:
-    typedef ValueT ValueType;
-    typedef IGenericRemoteSchemaDocumentProvider<GenericSchemaDocument> IRemoteSchemaDocumentProviderType;
-    typedef Allocator AllocatorType;
-    typedef typename ValueType::EncodingType EncodingType;
-    typedef typename EncodingType::Ch Ch;
-    typedef internal::Schema<GenericSchemaDocument> SchemaType;
-    typedef GenericPointer<ValueType, Allocator> PointerType;
-    typedef GenericValue<EncodingType, Allocator> URIType;
-    friend class internal::Schema<GenericSchemaDocument>;
-    template <typename, typename, typename>
-    friend class GenericSchemaValidator;
-
-    //! Constructor.
-    /*!
-        Compile a JSON document into schema document.
-
-        \param document A JSON document as source.
-        \param uri The base URI of this schema document for purposes of violation reporting.
-        \param uriLength Length of \c name, in code points.
-        \param remoteProvider An optional remote schema document provider for resolving remote reference. Can be null.
-        \param allocator An optional allocator instance for allocating memory. Can be null.
-    */
-    explicit GenericSchemaDocument(const ValueType &document, const Ch *uri = 0, SizeType uriLength = 0,
-                                   IRemoteSchemaDocumentProviderType *remoteProvider = 0, Allocator *allocator = 0) :
-      remoteProvider_(remoteProvider),
-      allocator_(allocator),
-      ownAllocator_(),
-      root_(),
-      typeless_(),
-      schemaMap_(allocator, kInitialSchemaMapSize),
-      schemaRef_(allocator, kInitialSchemaRefSize)
-    {
-      if (!allocator_)
-        ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();
-
-      Ch noUri[1] = {0};
-      uri_.SetString(uri ? uri : noUri, uriLength, *allocator_);
-
-      typeless_ = static_cast<SchemaType *>(allocator_->Malloc(sizeof(SchemaType)));
-      new (typeless_) SchemaType(this, PointerType(), ValueType(kObjectType).Move(), ValueType(kObjectType).Move(), allocator_);
-
-      // Generate root schema, it will call CreateSchema() to create sub-schemas,
-      // And call AddRefSchema() if there are $ref.
-      CreateSchemaRecursive(&root_, PointerType(), document, document);
-
-      // Resolve $ref
-      while (!schemaRef_.Empty())
-        {
-          SchemaRefEntry *refEntry = schemaRef_.template Pop<SchemaRefEntry>(1);
-          if (const SchemaType *s = GetSchema(refEntry->target))
-            {
-              if (refEntry->schema)
-                *refEntry->schema = s;
-
-              // Create entry in map if not exist
-              if (!GetSchema(refEntry->source))
-                {
-                  new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(refEntry->source, const_cast<SchemaType *>(s), false, allocator_);
-                }
-            }
-          else if (refEntry->schema)
-            *refEntry->schema = typeless_;
-
-          refEntry->~SchemaRefEntry();
-        }
-
-      RAPIDJSON_ASSERT(root_ != 0);
-
-      schemaRef_.ShrinkToFit(); // Deallocate all memory for ref
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move constructor in C++11
-  GenericSchemaDocument(GenericSchemaDocument &&rhs) RAPIDJSON_NOEXCEPT :
-    remoteProvider_(rhs.remoteProvider_),
-                    allocator_(rhs.allocator_),
-                    ownAllocator_(rhs.ownAllocator_),
-                    root_(rhs.root_),
-                    typeless_(rhs.typeless_),
-                    schemaMap_(std::move(rhs.schemaMap_)),
-                    schemaRef_(std::move(rhs.schemaRef_)),
-                    uri_(std::move(rhs.uri_))
-    {
-      rhs.remoteProvider_ = 0;
-      rhs.allocator_ = 0;
-      rhs.ownAllocator_ = 0;
-      rhs.typeless_ = 0;
-    }
-#endif
-
-    //! Destructor
-    ~GenericSchemaDocument()
-    {
-      while (!schemaMap_.Empty())
-        schemaMap_.template Pop<SchemaEntry>(1)->~SchemaEntry();
-
-      if (typeless_)
-        {
-          typeless_->~SchemaType();
-          Allocator::Free(typeless_);
-        }
-
-      RAPIDJSON_DELETE(ownAllocator_);
-    }
-
-    const URIType &GetURI() const
-    {
-      return uri_;
-    }
-
-    //! Get the root schema.
-    const SchemaType &GetRoot() const
-    {
-      return *root_;
-    }
-
-  private:
-    //! Prohibit copying
-    GenericSchemaDocument(const GenericSchemaDocument &);
-    //! Prohibit assignment
-    GenericSchemaDocument &operator=(const GenericSchemaDocument &);
-
-    struct SchemaRefEntry
-    {
-      SchemaRefEntry(const PointerType &s, const PointerType &t, const SchemaType **outSchema, Allocator *allocator) : source(s, allocator), target(t, allocator), schema(outSchema) {}
-      PointerType source;
-      PointerType target;
-      const SchemaType **schema;
-    };
-
-    struct SchemaEntry
-    {
-      SchemaEntry(const PointerType &p, SchemaType *s, bool o, Allocator *allocator) : pointer(p, allocator), schema(s), owned(o) {}
-      ~SchemaEntry()
-      {
-        if (owned)
-          {
-            schema->~SchemaType();
-            Allocator::Free(schema);
-          }
-      }
-      PointerType pointer;
-      SchemaType *schema;
-      bool owned;
-    };
-
-    void CreateSchemaRecursive(const SchemaType **schema, const PointerType &pointer, const ValueType &v, const ValueType &document)
-    {
-      if (schema)
-        *schema = typeless_;
-
-      if (v.GetType() == kObjectType)
-        {
-          const SchemaType *s = GetSchema(pointer);
-          if (!s)
-            CreateSchema(schema, pointer, v, document);
-
-          for (typename ValueType::ConstMemberIterator itr = v.MemberBegin(); itr != v.MemberEnd(); ++itr)
-            CreateSchemaRecursive(0, pointer.Append(itr->name, allocator_), itr->value, document);
-        }
-      else if (v.GetType() == kArrayType)
-        for (SizeType i = 0; i < v.Size(); i++)
-          CreateSchemaRecursive(0, pointer.Append(i, allocator_), v[i], document);
-    }
-
-    void CreateSchema(const SchemaType **schema, const PointerType &pointer, const ValueType &v, const ValueType &document)
-    {
-      RAPIDJSON_ASSERT(pointer.IsValid());
-      if (v.IsObject())
-        {
-          if (!HandleRefSchema(pointer, schema, v, document))
-            {
-              SchemaType *s = new (allocator_->Malloc(sizeof(SchemaType))) SchemaType(this, pointer, v, document, allocator_);
-              new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(pointer, s, true, allocator_);
-              if (schema)
-                *schema = s;
-            }
-        }
-    }
-
-    bool HandleRefSchema(const PointerType &source, const SchemaType **schema, const ValueType &v, const ValueType &document)
-    {
-      static const Ch kRefString[] = { '$', 'r', 'e', 'f', '\0' };
-      static const ValueType kRefValue(kRefString, 4);
-
-      typename ValueType::ConstMemberIterator itr = v.FindMember(kRefValue);
-      if (itr == v.MemberEnd())
-        return false;
-
-      if (itr->value.IsString())
-        {
-          SizeType len = itr->value.GetStringLength();
-          if (len > 0)
-            {
-              const Ch *s = itr->value.GetString();
-              SizeType i = 0;
-              while (i < len && s[i] != '#') // Find the first #
-                i++;
-
-              if (i > 0)   // Remote reference, resolve immediately
-                {
-                  if (remoteProvider_)
-                    {
-                      if (const GenericSchemaDocument *remoteDocument = remoteProvider_->GetRemoteDocument(s, i))
-                        {
-                          PointerType pointer(&s[i], len - i, allocator_);
-                          if (pointer.IsValid())
-                            {
-                              if (const SchemaType *sc = remoteDocument->GetSchema(pointer))
-                                {
-                                  if (schema)
-                                    *schema = sc;
-                                  new (schemaMap_.template Push<SchemaEntry>()) SchemaEntry(source, const_cast<SchemaType *>(sc), false, allocator_);
-                                  return true;
-                                }
-                            }
-                        }
-                    }
-                }
-              else if (s[i] == '#')   // Local reference, defer resolution
-                {
-                  PointerType pointer(&s[i], len - i, allocator_);
-                  if (pointer.IsValid())
-                    {
-                      if (const ValueType *nv = pointer.Get(document))
-                        if (HandleRefSchema(source, schema, *nv, document))
-                          return true;
-
-                      new (schemaRef_.template Push<SchemaRefEntry>()) SchemaRefEntry(source, pointer, schema, allocator_);
-                      return true;
-                    }
-                }
-            }
-        }
-      return false;
-    }
-
-    const SchemaType *GetSchema(const PointerType &pointer) const
-    {
-      for (const SchemaEntry *target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
-        if (pointer == target->pointer)
-          return target->schema;
-      return 0;
-    }
-
-    PointerType GetPointer(const SchemaType *schema) const
-    {
-      for (const SchemaEntry *target = schemaMap_.template Bottom<SchemaEntry>(); target != schemaMap_.template End<SchemaEntry>(); ++target)
-        if (schema == target->schema)
-          return target->pointer;
-      return PointerType();
-    }
-
-    const SchemaType *GetTypeless() const
-    {
-      return typeless_;
-    }
-
-    static const size_t kInitialSchemaMapSize = 64;
-    static const size_t kInitialSchemaRefSize = 64;
-
-    IRemoteSchemaDocumentProviderType *remoteProvider_;
-    Allocator *allocator_;
-    Allocator *ownAllocator_;
-    const SchemaType *root_;                //!< Root schema.
-    SchemaType *typeless_;
-    internal::Stack<Allocator> schemaMap_;  // Stores created Pointer -> Schemas
-    internal::Stack<Allocator> schemaRef_;  // Stores Pointer from $ref and schema which holds the $ref
-    URIType uri_;
-};
-
-//! GenericSchemaDocument using Value type.
-typedef GenericSchemaDocument<Value> SchemaDocument;
-//! IGenericRemoteSchemaDocumentProvider using SchemaDocument.
-typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericSchemaValidator
-
-//! JSON Schema Validator.
-/*!
-    A SAX style JSON schema validator.
-    It uses a \c GenericSchemaDocument to validate SAX events.
-    It delegates the incoming SAX events to an output handler.
-    The default output handler does nothing.
-    It can be reused multiple times by calling \c Reset().
-
-    \tparam SchemaDocumentType Type of schema document.
-    \tparam OutputHandler Type of output handler. Default handler does nothing.
-    \tparam StateAllocator Allocator for storing the internal validation states.
-*/
-template <
-  typename SchemaDocumentType,
-  typename OutputHandler = BaseReaderHandler<typename SchemaDocumentType::SchemaType::EncodingType>,
-  typename StateAllocator = CrtAllocator>
-class GenericSchemaValidator :
-  public internal::ISchemaStateFactory<typename SchemaDocumentType::SchemaType>,
-  public internal::ISchemaValidator,
-  public internal::IValidationErrorHandler<typename SchemaDocumentType::SchemaType>
-{
-  public:
-    typedef typename SchemaDocumentType::SchemaType SchemaType;
-    typedef typename SchemaDocumentType::PointerType PointerType;
-    typedef typename SchemaType::EncodingType EncodingType;
-    typedef typename SchemaType::SValue SValue;
-    typedef typename EncodingType::Ch Ch;
-    typedef GenericStringRef<Ch> StringRefType;
-    typedef GenericValue<EncodingType, StateAllocator> ValueType;
-
-    //! Constructor without output handler.
-    /*!
-        \param schemaDocument The schema document to conform to.
-        \param allocator Optional allocator for storing internal validation states.
-        \param schemaStackCapacity Optional initial capacity of schema path stack.
-        \param documentStackCapacity Optional initial capacity of document path stack.
-    */
-    GenericSchemaValidator(
-      const SchemaDocumentType &schemaDocument,
-      StateAllocator *allocator = 0,
-      size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
-      size_t documentStackCapacity = kDefaultDocumentStackCapacity)
-      :
-      schemaDocument_(&schemaDocument),
-      root_(schemaDocument.GetRoot()),
-      stateAllocator_(allocator),
-      ownStateAllocator_(0),
-      schemaStack_(allocator, schemaStackCapacity),
-      documentStack_(allocator, documentStackCapacity),
-      outputHandler_(0),
-      error_(kObjectType),
-      currentError_(),
-      missingDependents_(),
-      valid_(true)
-#if RAPIDJSON_SCHEMA_VERBOSE
-      , depth_(0)
-#endif
-    {
-    }
-
-    //! Constructor with output handler.
-    /*!
-        \param schemaDocument The schema document to conform to.
-        \param allocator Optional allocator for storing internal validation states.
-        \param schemaStackCapacity Optional initial capacity of schema path stack.
-        \param documentStackCapacity Optional initial capacity of document path stack.
-    */
-    GenericSchemaValidator(
-      const SchemaDocumentType &schemaDocument,
-      OutputHandler &outputHandler,
-      StateAllocator *allocator = 0,
-      size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
-      size_t documentStackCapacity = kDefaultDocumentStackCapacity)
-      :
-      schemaDocument_(&schemaDocument),
-      root_(schemaDocument.GetRoot()),
-      stateAllocator_(allocator),
-      ownStateAllocator_(0),
-      schemaStack_(allocator, schemaStackCapacity),
-      documentStack_(allocator, documentStackCapacity),
-      outputHandler_(&outputHandler),
-      error_(kObjectType),
-      currentError_(),
-      missingDependents_(),
-      valid_(true)
-#if RAPIDJSON_SCHEMA_VERBOSE
-      , depth_(0)
-#endif
-    {
-    }
-
-    //! Destructor.
-    ~GenericSchemaValidator()
-    {
-      Reset();
-      RAPIDJSON_DELETE(ownStateAllocator_);
-    }
-
-    //! Reset the internal states.
-    void Reset()
-    {
-      while (!schemaStack_.Empty())
-        PopSchema();
-      documentStack_.Clear();
-      error_.SetObject();
-      currentError_.SetNull();
-      missingDependents_.SetNull();
-      valid_ = true;
-    }
-
-    //! Checks whether the current state is valid.
-    // Implementation of ISchemaValidator
-    bool IsValid() const override final
-    {
-      return valid_;
-    }
-
-    //! Gets the error object.
-    ValueType &GetError()
-    {
-      return error_;
-    }
-    const ValueType &GetError() const
-    {
-      return error_;
-    }
-
-    //! Gets the JSON pointer pointed to the invalid schema.
-    PointerType GetInvalidSchemaPointer() const
-    {
-      return schemaStack_.Empty() ? PointerType() : CurrentSchema().GetPointer();
-    }
-
-    //! Gets the keyword of invalid schema.
-    const Ch *GetInvalidSchemaKeyword() const
-    {
-      return schemaStack_.Empty() ? 0 : CurrentContext().invalidKeyword;
-    }
-
-    //! Gets the JSON pointer pointed to the invalid value.
-    PointerType GetInvalidDocumentPointer() const
-    {
-      if (documentStack_.Empty())
-        {
-          return PointerType();
-        }
-      else
-        {
-          return PointerType(documentStack_.template Bottom<Ch>(), documentStack_.GetSize() / sizeof(Ch));
-        }
-    }
-
-    void NotMultipleOf(int64_t actual, const SValue &expected) override final
-    {
-      AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
-    }
-    void NotMultipleOf(uint64_t actual, const SValue &expected) override final
-    {
-      AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
-    }
-    void NotMultipleOf(double actual, const SValue &expected) override final
-    {
-      AddNumberError(SchemaType::GetMultipleOfString(), ValueType(actual).Move(), expected);
-    }
-    void AboveMaximum(int64_t actual, const SValue &expected, bool exclusive) override final
-    {
-      AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
-                     exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
-    }
-    void AboveMaximum(uint64_t actual, const SValue &expected, bool exclusive) override final
-    {
-      AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
-                     exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
-    }
-    void AboveMaximum(double actual, const SValue &expected, bool exclusive) override final
-    {
-      AddNumberError(SchemaType::GetMaximumString(), ValueType(actual).Move(), expected,
-                     exclusive ? &SchemaType::GetExclusiveMaximumString : 0);
-    }
-    void BelowMinimum(int64_t actual, const SValue &expected, bool exclusive) override final
-    {
-      AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
-                     exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
-    }
-    void BelowMinimum(uint64_t actual, const SValue &expected, bool exclusive) override final
-    {
-      AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
-                     exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
-    }
-    void BelowMinimum(double actual, const SValue &expected, bool exclusive) override final
-    {
-      AddNumberError(SchemaType::GetMinimumString(), ValueType(actual).Move(), expected,
-                     exclusive ? &SchemaType::GetExclusiveMinimumString : 0);
-    }
-
-    void TooLong(const Ch *str, SizeType length, SizeType expected) override final
-    {
-      AddNumberError(SchemaType::GetMaxLengthString(),
-                     ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
-    }
-    void TooShort(const Ch *str, SizeType length, SizeType expected) override final
-    {
-      AddNumberError(SchemaType::GetMinLengthString(),
-                     ValueType(str, length, GetStateAllocator()).Move(), SValue(expected).Move());
-    }
-    void DoesNotMatch(const Ch *str, SizeType length) override final
-    {
-      currentError_.SetObject();
-      currentError_.AddMember(GetActualString(), ValueType(str, length, GetStateAllocator()).Move(), GetStateAllocator());
-      AddCurrentError(SchemaType::GetPatternString());
-    }
-
-    void DisallowedItem(SizeType index) override final
-    {
-      currentError_.SetObject();
-      currentError_.AddMember(GetDisallowedString(), ValueType(index).Move(), GetStateAllocator());
-      AddCurrentError(SchemaType::GetAdditionalItemsString(), true);
-    }
-    void TooFewItems(SizeType actualCount, SizeType expectedCount) override final
-    {
-      AddNumberError(SchemaType::GetMinItemsString(),
-                     ValueType(actualCount).Move(), SValue(expectedCount).Move());
-    }
-    void TooManyItems(SizeType actualCount, SizeType expectedCount) override final
-    {
-      AddNumberError(SchemaType::GetMaxItemsString(),
-                     ValueType(actualCount).Move(), SValue(expectedCount).Move());
-    }
-    void DuplicateItems(SizeType index1, SizeType index2) override final
-    {
-      ValueType duplicates(kArrayType);
-      duplicates.PushBack(index1, GetStateAllocator());
-      duplicates.PushBack(index2, GetStateAllocator());
-      currentError_.SetObject();
-      currentError_.AddMember(GetDuplicatesString(), duplicates, GetStateAllocator());
-      AddCurrentError(SchemaType::GetUniqueItemsString(), true);
-    }
-
-    void TooManyProperties(SizeType actualCount, SizeType expectedCount) override final
-    {
-      AddNumberError(SchemaType::GetMaxPropertiesString(),
-                     ValueType(actualCount).Move(), SValue(expectedCount).Move());
-    }
-    void TooFewProperties(SizeType actualCount, SizeType expectedCount) override final
-    {
-      AddNumberError(SchemaType::GetMinPropertiesString(),
-                     ValueType(actualCount).Move(), SValue(expectedCount).Move());
-    }
-    void StartMissingProperties() override final
-    {
-      currentError_.SetArray();
-    }
-    void AddMissingProperty(const SValue &name) override final
-    {
-      currentError_.PushBack(ValueType(name, GetStateAllocator()).Move(), GetStateAllocator());
-    }
-    bool EndMissingProperties() override final
-    {
-      if (currentError_.Empty())
-        return false;
-      ValueType error(kObjectType);
-      error.AddMember(GetMissingString(), currentError_, GetStateAllocator());
-      currentError_ = error;
-      AddCurrentError(SchemaType::GetRequiredString());
-      return true;
-    }
-    void PropertyViolations(ISchemaValidator **subvalidators, SizeType count) override final
-    {
-      for (SizeType i = 0; i < count; ++i)
-        MergeError(static_cast<GenericSchemaValidator *>(subvalidators[i])->GetError());
-    }
-    void DisallowedProperty(const Ch *name, SizeType length) override final
-    {
-      currentError_.SetObject();
-      currentError_.AddMember(GetDisallowedString(), ValueType(name, length, GetStateAllocator()).Move(), GetStateAllocator());
-      AddCurrentError(SchemaType::GetAdditionalPropertiesString(), true);
-    }
-
-    void StartDependencyErrors() override final
-    {
-      currentError_.SetObject();
-    }
-    void StartMissingDependentProperties() override final
-    {
-      missingDependents_.SetArray();
-    }
-    void AddMissingDependentProperty(const SValue &targetName) override final
-    {
-      missingDependents_.PushBack(ValueType(targetName, GetStateAllocator()).Move(), GetStateAllocator());
-    }
-    void EndMissingDependentProperties(const SValue &sourceName) override final
-    {
-      if (!missingDependents_.Empty())
-        currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
-                                missingDependents_, GetStateAllocator());
-    }
-    void AddDependencySchemaError(const SValue &sourceName, ISchemaValidator *subvalidator) override final
-    {
-      currentError_.AddMember(ValueType(sourceName, GetStateAllocator()).Move(),
-                              static_cast<GenericSchemaValidator *>(subvalidator)->GetError(), GetStateAllocator());
-    }
-    bool EndDependencyErrors() override final
-    {
-      if (currentError_.ObjectEmpty())
-        return false;
-      ValueType error(kObjectType);
-      error.AddMember(GetErrorsString(), currentError_, GetStateAllocator());
-      currentError_ = error;
-      AddCurrentError(SchemaType::GetDependenciesString());
-      return true;
-    }
-
-    void DisallowedValue() override final
-    {
-      currentError_.SetObject();
-      AddCurrentError(SchemaType::GetEnumString());
-    }
-    void StartDisallowedType() override final
-    {
-      currentError_.SetArray();
-    }
-    void AddExpectedType(const typename SchemaType::ValueType &expectedType) override final
-    {
-      currentError_.PushBack(ValueType(expectedType, GetStateAllocator()).Move(), GetStateAllocator());
-    }
-    void EndDisallowedType(const typename SchemaType::ValueType &actualType) override final
-    {
-      ValueType error(kObjectType);
-      error.AddMember(GetExpectedString(), currentError_, GetStateAllocator());
-      error.AddMember(GetActualString(), ValueType(actualType, GetStateAllocator()).Move(), GetStateAllocator());
-      currentError_ = error;
-      AddCurrentError(SchemaType::GetTypeString());
-    }
-    void NotAllOf(ISchemaValidator **subvalidators, SizeType count) override final
-    {
-      for (SizeType i = 0; i < count; ++i)
-        {
-          MergeError(static_cast<GenericSchemaValidator *>(subvalidators[i])->GetError());
-        }
-    }
-    void NoneOf(ISchemaValidator **subvalidators, SizeType count) override final
-    {
-      AddErrorArray(SchemaType::GetAnyOfString(), subvalidators, count);
-    }
-    void NotOneOf(ISchemaValidator **subvalidators, SizeType count) override final
-    {
-      AddErrorArray(SchemaType::GetOneOfString(), subvalidators, count);
-    }
-    void Disallowed() override final
-    {
-      currentError_.SetObject();
-      AddCurrentError(SchemaType::GetNotString());
-    }
-
-#define RAPIDJSON_STRING_(name, ...) \
-  static const StringRefType& Get##name##String() {\
-    static const Ch s[] = { __VA_ARGS__, '\0' };\
-    static const StringRefType v(s, static_cast<SizeType>(sizeof(s) / sizeof(Ch) - 1)); \
-    return v;\
-  }
-
-    RAPIDJSON_STRING_(InstanceRef, 'i', 'n', 's', 't', 'a', 'n', 'c', 'e', 'R', 'e', 'f')
-    RAPIDJSON_STRING_(SchemaRef, 's', 'c', 'h', 'e', 'm', 'a', 'R', 'e', 'f')
-    RAPIDJSON_STRING_(Expected, 'e', 'x', 'p', 'e', 'c', 't', 'e', 'd')
-    RAPIDJSON_STRING_(Actual, 'a', 'c', 't', 'u', 'a', 'l')
-    RAPIDJSON_STRING_(Disallowed, 'd', 'i', 's', 'a', 'l', 'l', 'o', 'w', 'e', 'd')
-    RAPIDJSON_STRING_(Missing, 'm', 'i', 's', 's', 'i', 'n', 'g')
-    RAPIDJSON_STRING_(Errors, 'e', 'r', 'r', 'o', 'r', 's')
-    RAPIDJSON_STRING_(Duplicates, 'd', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e', 's')
-
-#undef RAPIDJSON_STRING_
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_() \
-  RAPIDJSON_MULTILINEMACRO_BEGIN\
-  *documentStack_.template Push<Ch>() = '\0';\
-  documentStack_.template Pop<Ch>(1);\
-  internal::PrintInvalidDocument(documentStack_.template Bottom<Ch>());\
-  RAPIDJSON_MULTILINEMACRO_END
-#else
-#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_()
-#endif
-
-#define RAPIDJSON_SCHEMA_HANDLE_BEGIN_(method, arg1)\
-  if (!valid_) return false; \
-  if (!BeginValue() || !CurrentSchema().method arg1) {\
-      RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_();\
-      return valid_ = false;\
-    }
-
-#define RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2)\
-  for (Context* context = schemaStack_.template Bottom<Context>(); context != schemaStack_.template End<Context>(); context++) {\
-      if (context->hasher)\
-        static_cast<HasherType*>(context->hasher)->method arg2;\
-      if (context->validators)\
-        for (SizeType i_ = 0; i_ < context->validatorCount; i_++)\
-          static_cast<GenericSchemaValidator*>(context->validators[i_])->method arg2;\
-      if (context->patternPropertiesValidators)\
-        for (SizeType i_ = 0; i_ < context->patternPropertiesValidatorCount; i_++)\
-          static_cast<GenericSchemaValidator*>(context->patternPropertiesValidators[i_])->method arg2;\
-    }
-
-#define RAPIDJSON_SCHEMA_HANDLE_END_(method, arg2)\
-  return valid_ = EndValue() && (!outputHandler_ || outputHandler_->method arg2)
-
-#define RAPIDJSON_SCHEMA_HANDLE_VALUE_(method, arg1, arg2) \
-  RAPIDJSON_SCHEMA_HANDLE_BEGIN_   (method, arg1);\
-  RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(method, arg2);\
-  RAPIDJSON_SCHEMA_HANDLE_END_     (method, arg2)
-
-    bool Null()
-    {
-      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null,   (CurrentContext()), ( ));
-    }
-    bool Bool(bool b)
-    {
-      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool,   (CurrentContext(), b), (b));
-    }
-    bool Int(int i)
-    {
-      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int,    (CurrentContext(), i), (i));
-    }
-    bool Uint(unsigned u)
-    {
-      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint,   (CurrentContext(), u), (u));
-    }
-    bool Int64(int64_t i)
-    {
-      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int64,  (CurrentContext(), i), (i));
-    }
-    bool Uint64(uint64_t u)
-    {
-      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint64, (CurrentContext(), u), (u));
-    }
-    bool Double(double d)
-    {
-      RAPIDJSON_SCHEMA_HANDLE_VALUE_(Double, (CurrentContext(), d), (d));
-    }
-    bool RawNumber(const Ch *str, SizeType length, bool copy)
-    {
-      RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy));
-    }
-    bool String(const Ch *str, SizeType length, bool copy)
-    {
-      RAPIDJSON_SCHEMA_HANDLE_VALUE_(String, (CurrentContext(), str, length, copy), (str, length, copy));
-    }
-
-    bool StartObject()
-    {
-      RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartObject, (CurrentContext()));
-      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartObject, ());
-      return valid_ = !outputHandler_ || outputHandler_->StartObject();
-    }
-
-    bool Key(const Ch *str, SizeType len, bool copy)
-    {
-      if (!valid_) return false;
-      AppendToken(str, len);
-      if (!CurrentSchema().Key(CurrentContext(), str, len, copy)) return valid_ = false;
-      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(Key, (str, len, copy));
-      return valid_ = !outputHandler_ || outputHandler_->Key(str, len, copy);
-    }
-
-    bool EndObject(SizeType memberCount)
-    {
-      if (!valid_) return false;
-      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndObject, (memberCount));
-      if (!CurrentSchema().EndObject(CurrentContext(), memberCount)) return valid_ = false;
-      RAPIDJSON_SCHEMA_HANDLE_END_(EndObject, (memberCount));
-    }
-
-    bool StartArray()
-    {
-      RAPIDJSON_SCHEMA_HANDLE_BEGIN_(StartArray, (CurrentContext()));
-      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(StartArray, ());
-      return valid_ = !outputHandler_ || outputHandler_->StartArray();
-    }
-
-    bool EndArray(SizeType elementCount)
-    {
-      if (!valid_) return false;
-      RAPIDJSON_SCHEMA_HANDLE_PARALLEL_(EndArray, (elementCount));
-      if (!CurrentSchema().EndArray(CurrentContext(), elementCount)) return valid_ = false;
-      RAPIDJSON_SCHEMA_HANDLE_END_(EndArray, (elementCount));
-    }
-
-#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_VERBOSE_
-#undef RAPIDJSON_SCHEMA_HANDLE_BEGIN_
-#undef RAPIDJSON_SCHEMA_HANDLE_PARALLEL_
-#undef RAPIDJSON_SCHEMA_HANDLE_VALUE_
-
-    // Implementation of ISchemaStateFactory<SchemaType>
-    ISchemaValidator *CreateSchemaValidator(const SchemaType &root) override final
-    {
-      return new (GetStateAllocator().Malloc(sizeof(GenericSchemaValidator))) GenericSchemaValidator(*schemaDocument_, root, documentStack_.template Bottom<char>(), documentStack_.GetSize(),
-#if RAPIDJSON_SCHEMA_VERBOSE
-             depth_ + 1,
-#endif
-             &GetStateAllocator());
-    }
-
-    void DestroySchemaValidator(ISchemaValidator *validator) override final
-    {
-      GenericSchemaValidator *v = static_cast<GenericSchemaValidator *>(validator);
-      v->~GenericSchemaValidator();
-      StateAllocator::Free(v);
-    }
-
-    void *CreateHasher() override final
-    {
-      return new (GetStateAllocator().Malloc(sizeof(HasherType))) HasherType(&GetStateAllocator());
-    }
-
-    uint64_t GetHashCode(void *hasher) override final
-    {
-      return static_cast<HasherType *>(hasher)->GetHashCode();
-    }
-
-    void DestroryHasher(void *hasher) override final
-    {
-      HasherType *h = static_cast<HasherType *>(hasher);
-      h->~HasherType();
-      StateAllocator::Free(h);
-    }
-
-    void *MallocState(size_t size) override final
-    {
-      return GetStateAllocator().Malloc(size);
-    }
-
-    void FreeState(void *p) override final
-    {
-      StateAllocator::Free(p);
-    }
-
-  private:
-    typedef typename SchemaType::Context Context;
-    typedef GenericValue<UTF8<>, StateAllocator> HashCodeArray;
-    typedef internal::Hasher<EncodingType, StateAllocator> HasherType;
-
-    GenericSchemaValidator(
-      const SchemaDocumentType &schemaDocument,
-      const SchemaType &root,
-      const char *basePath, size_t basePathSize,
-#if RAPIDJSON_SCHEMA_VERBOSE
-      unsigned depth,
-#endif
-      StateAllocator *allocator = 0,
-      size_t schemaStackCapacity = kDefaultSchemaStackCapacity,
-      size_t documentStackCapacity = kDefaultDocumentStackCapacity)
-      :
-      schemaDocument_(&schemaDocument),
-      root_(root),
-      stateAllocator_(allocator),
-      ownStateAllocator_(0),
-      schemaStack_(allocator, schemaStackCapacity),
-      documentStack_(allocator, documentStackCapacity),
-      outputHandler_(0),
-      error_(kObjectType),
-      currentError_(),
-      missingDependents_(),
-      valid_(true)
-#if RAPIDJSON_SCHEMA_VERBOSE
-      , depth_(depth)
-#endif
-    {
-      if (basePath && basePathSize)
-        memcpy(documentStack_.template Push<char>(basePathSize), basePath, basePathSize);
-    }
-
-    StateAllocator &GetStateAllocator()
-    {
-      if (!stateAllocator_)
-        stateAllocator_ = ownStateAllocator_ = RAPIDJSON_NEW(StateAllocator)();
-      return *stateAllocator_;
-    }
-
-    bool BeginValue()
-    {
-      if (schemaStack_.Empty())
-        PushSchema(root_);
-      else
-        {
-          if (CurrentContext().inArray)
-            internal::TokenHelper<internal::Stack<StateAllocator>, Ch>::AppendIndexToken(documentStack_, CurrentContext().arrayElementIndex);
-
-          if (!CurrentSchema().BeginValue(CurrentContext()))
-            return false;
-
-          SizeType count = CurrentContext().patternPropertiesSchemaCount;
-          const SchemaType **sa = CurrentContext().patternPropertiesSchemas;
-          typename Context::PatternValidatorType patternValidatorType = CurrentContext().valuePatternValidatorType;
-          bool valueUniqueness = CurrentContext().valueUniqueness;
-          RAPIDJSON_ASSERT(CurrentContext().valueSchema);
-          PushSchema(*CurrentContext().valueSchema);
-
-          if (count > 0)
-            {
-              CurrentContext().objectPatternValidatorType = patternValidatorType;
-              ISchemaValidator ** &va = CurrentContext().patternPropertiesValidators;
-              SizeType &validatorCount = CurrentContext().patternPropertiesValidatorCount;
-              va = static_cast<ISchemaValidator **>(MallocState(sizeof(ISchemaValidator *) * count));
-              for (SizeType i = 0; i < count; i++)
-                va[validatorCount++] = CreateSchemaValidator(*sa[i]);
-            }
-
-          CurrentContext().arrayUniqueness = valueUniqueness;
-        }
-      return true;
-    }
-
-    bool EndValue()
-    {
-      if (!CurrentSchema().EndValue(CurrentContext()))
-        return false;
-
-#if RAPIDJSON_SCHEMA_VERBOSE
-      GenericStringBuffer<EncodingType> sb;
-      schemaDocument_->GetPointer(&CurrentSchema()).Stringify(sb);
-
-      *documentStack_.template Push<Ch>() = '\0';
-      documentStack_.template Pop<Ch>(1);
-      internal::PrintValidatorPointers(depth_, sb.GetString(), documentStack_.template Bottom<Ch>());
-#endif
-
-      uint64_t h = CurrentContext().arrayUniqueness ? static_cast<HasherType *>(CurrentContext().hasher)->GetHashCode() : 0;
-
-      PopSchema();
-
-      if (!schemaStack_.Empty())
-        {
-          Context &context = CurrentContext();
-          if (context.valueUniqueness)
-            {
-              HashCodeArray *a = static_cast<HashCodeArray *>(context.arrayElementHashCodes);
-              if (!a)
-                CurrentContext().arrayElementHashCodes = a = new (GetStateAllocator().Malloc(sizeof(HashCodeArray))) HashCodeArray(kArrayType);
-              for (typename HashCodeArray::ConstValueIterator itr = a->Begin(); itr != a->End(); ++itr)
-                if (itr->GetUint64() == h)
-                  {
-                    DuplicateItems(static_cast<SizeType>(itr - a->Begin()), a->Size());
-                    RAPIDJSON_INVALID_KEYWORD_RETURN(SchemaType::GetUniqueItemsString());
-                  }
-              a->PushBack(h, GetStateAllocator());
-            }
-        }
-
-      // Remove the last token of document pointer
-      while (!documentStack_.Empty() && *documentStack_.template Pop<Ch>(1) != '/')
-        ;
-
-      return true;
-    }
-
-    void AppendToken(const Ch *str, SizeType len)
-    {
-      documentStack_.template Reserve<Ch>(1 + len * 2); // worst case all characters are escaped as two characters
-      *documentStack_.template PushUnsafe<Ch>() = '/';
-      for (SizeType i = 0; i < len; i++)
-        {
-          if (str[i] == '~')
-            {
-              *documentStack_.template PushUnsafe<Ch>() = '~';
-              *documentStack_.template PushUnsafe<Ch>() = '0';
-            }
-          else if (str[i] == '/')
-            {
-              *documentStack_.template PushUnsafe<Ch>() = '~';
-              *documentStack_.template PushUnsafe<Ch>() = '1';
-            }
-          else
-            *documentStack_.template PushUnsafe<Ch>() = str[i];
-        }
-    }
-
-    RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType &schema)
-    {
-      new (schemaStack_.template Push<Context>()) Context(*this, *this, &schema);
-    }
-
-    RAPIDJSON_FORCEINLINE void PopSchema()
-    {
-      Context *c = schemaStack_.template Pop<Context>(1);
-      if (HashCodeArray *a = static_cast<HashCodeArray *>(c->arrayElementHashCodes))
-        {
-          a->~HashCodeArray();
-          StateAllocator::Free(a);
-        }
-      c->~Context();
-    }
-
-    void AddErrorLocation(ValueType &result, bool parent)
-    {
-      GenericStringBuffer<EncodingType> sb;
-      PointerType instancePointer = GetInvalidDocumentPointer();
-      ((parent && instancePointer.GetTokenCount() > 0)
-       ? PointerType(instancePointer.GetTokens(), instancePointer.GetTokenCount() - 1)
-       : instancePointer).StringifyUriFragment(sb);
-      ValueType instanceRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
-                            GetStateAllocator());
-      result.AddMember(GetInstanceRefString(), instanceRef, GetStateAllocator());
-      sb.Clear();
-      memcpy(sb.Push(CurrentSchema().GetURI().GetStringLength()),
-             CurrentSchema().GetURI().GetString(),
-             CurrentSchema().GetURI().GetStringLength() * sizeof(Ch));
-      GetInvalidSchemaPointer().StringifyUriFragment(sb);
-      ValueType schemaRef(sb.GetString(), static_cast<SizeType>(sb.GetSize() / sizeof(Ch)),
-                          GetStateAllocator());
-      result.AddMember(GetSchemaRefString(), schemaRef, GetStateAllocator());
-    }
-
-    void AddError(ValueType &keyword, ValueType &error)
-    {
-      typename ValueType::MemberIterator member = error_.FindMember(keyword);
-      if (member == error_.MemberEnd())
-        error_.AddMember(keyword, error, GetStateAllocator());
-      else
-        {
-          if (member->value.IsObject())
-            {
-              ValueType errors(kArrayType);
-              errors.PushBack(member->value, GetStateAllocator());
-              member->value = errors;
-            }
-          member->value.PushBack(error, GetStateAllocator());
-        }
-    }
-
-    void AddCurrentError(const typename SchemaType::ValueType &keyword, bool parent = false)
-    {
-      AddErrorLocation(currentError_, parent);
-      AddError(ValueType(keyword, GetStateAllocator(), false).Move(), currentError_);
-    }
-
-    void MergeError(ValueType &other)
-    {
-      for (typename ValueType::MemberIterator it = other.MemberBegin(), end = other.MemberEnd(); it != end; ++it)
-        {
-          AddError(it->name, it->value);
-        }
-    }
-
-    void AddNumberError(const typename SchemaType::ValueType &keyword, ValueType &actual, const SValue &expected,
-                        const typename SchemaType::ValueType& (*exclusive)() = 0)
-    {
-      currentError_.SetObject();
-      currentError_.AddMember(GetActualString(), actual, GetStateAllocator());
-      currentError_.AddMember(GetExpectedString(), ValueType(expected, GetStateAllocator()).Move(), GetStateAllocator());
-      if (exclusive)
-        currentError_.AddMember(ValueType(exclusive(), GetStateAllocator()).Move(), true, GetStateAllocator());
-      AddCurrentError(keyword);
-    }
-
-    void AddErrorArray(const typename SchemaType::ValueType &keyword,
-                       ISchemaValidator **subvalidators, SizeType count)
-    {
-      ValueType errors(kArrayType);
-      for (SizeType i = 0; i < count; ++i)
-        errors.PushBack(static_cast<GenericSchemaValidator *>(subvalidators[i])->GetError(), GetStateAllocator());
-      currentError_.SetObject();
-      currentError_.AddMember(GetErrorsString(), errors, GetStateAllocator());
-      AddCurrentError(keyword);
-    }
-
-    const SchemaType &CurrentSchema() const
-    {
-      return *schemaStack_.template Top<Context>()->schema;
-    }
-    Context &CurrentContext()
-    {
-      return *schemaStack_.template Top<Context>();
-    }
-    const Context &CurrentContext() const
-    {
-      return *schemaStack_.template Top<Context>();
-    }
-
-    static const size_t kDefaultSchemaStackCapacity = 1024;
-    static const size_t kDefaultDocumentStackCapacity = 256;
-    const SchemaDocumentType *schemaDocument_;
-    const SchemaType &root_;
-    StateAllocator *stateAllocator_;
-    StateAllocator *ownStateAllocator_;
-    internal::Stack<StateAllocator> schemaStack_;    //!< stack to store the current path of schema (BaseSchemaType *)
-    internal::Stack<StateAllocator> documentStack_;  //!< stack to store the current path of validating document (Ch)
-    OutputHandler *outputHandler_;
-    ValueType error_;
-    ValueType currentError_;
-    ValueType missingDependents_;
-    bool valid_;
-#if RAPIDJSON_SCHEMA_VERBOSE
-    unsigned depth_;
-#endif
-};
-
-typedef GenericSchemaValidator<SchemaDocument> SchemaValidator;
-
-///////////////////////////////////////////////////////////////////////////////
-// SchemaValidatingReader
-
-//! A helper class for parsing with validation.
-/*!
-    This helper class is a functor, designed as a parameter of \ref GenericDocument::Populate().
-
-    \tparam parseFlags Combination of \ref ParseFlag.
-    \tparam InputStream Type of input stream, implementing Stream concept.
-    \tparam SourceEncoding Encoding of the input stream.
-    \tparam SchemaDocumentType Type of schema document.
-    \tparam StackAllocator Allocator type for stack.
-*/
-template <
-  unsigned parseFlags,
-  typename InputStream,
-  typename SourceEncoding,
-  typename SchemaDocumentType = SchemaDocument,
-  typename StackAllocator = CrtAllocator>
-class SchemaValidatingReader
-{
-  public:
-    typedef typename SchemaDocumentType::PointerType PointerType;
-    typedef typename InputStream::Ch Ch;
-    typedef GenericValue<SourceEncoding, StackAllocator> ValueType;
-
-    //! Constructor
-    /*!
-        \param is Input stream.
-        \param sd Schema document.
-    */
-    SchemaValidatingReader(InputStream &is, const SchemaDocumentType &sd) : is_(is), sd_(sd), invalidSchemaKeyword_(), error_(kObjectType), isValid_(true) {}
-
-    template <typename Handler>
-    bool operator()(Handler &handler)
-    {
-      GenericReader<SourceEncoding, typename SchemaDocumentType::EncodingType, StackAllocator> reader;
-      GenericSchemaValidator<SchemaDocumentType, Handler> validator(sd_, handler);
-      parseResult_ = reader.template Parse<parseFlags>(is_, validator);
-
-      isValid_ = validator.IsValid();
-      if (isValid_)
-        {
-          invalidSchemaPointer_ = PointerType();
-          invalidSchemaKeyword_ = 0;
-          invalidDocumentPointer_ = PointerType();
-          error_.SetObject();
-        }
-      else
-        {
-          invalidSchemaPointer_ = validator.GetInvalidSchemaPointer();
-          invalidSchemaKeyword_ = validator.GetInvalidSchemaKeyword();
-          invalidDocumentPointer_ = validator.GetInvalidDocumentPointer();
-          error_.CopyFrom(validator.GetError(), allocator_);
-        }
-
-      return parseResult_;
-    }
-
-    const ParseResult &GetParseResult() const
-    {
-      return parseResult_;
-    }
-    bool IsValid() const
-    {
-      return isValid_;
-    }
-    const PointerType &GetInvalidSchemaPointer() const
-    {
-      return invalidSchemaPointer_;
-    }
-    const Ch *GetInvalidSchemaKeyword() const
-    {
-      return invalidSchemaKeyword_;
-    }
-    const PointerType &GetInvalidDocumentPointer() const
-    {
-      return invalidDocumentPointer_;
-    }
-    const ValueType &GetError() const
-    {
-      return error_;
-    }
-
-  private:
-    InputStream &is_;
-    const SchemaDocumentType &sd_;
-
-    ParseResult parseResult_;
-    PointerType invalidSchemaPointer_;
-    const Ch *invalidSchemaKeyword_;
-    PointerType invalidDocumentPointer_;
-    StackAllocator allocator_;
-    ValueType error_;
-    bool isValid_;
-};
-
-RAPIDJSON_NAMESPACE_END
-RAPIDJSON_DIAG_POP
-
-#endif // RAPIDJSON_SCHEMA_H_
diff --git a/contrib/world_builder/include/rapidjson/stream.h.bak b/contrib/world_builder/include/rapidjson/stream.h.bak
deleted file mode 100644
index adf4ed30cff..00000000000
--- a/contrib/world_builder/include/rapidjson/stream.h.bak
+++ /dev/null
@@ -1,312 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#include "rapidjson.h"
-
-#ifndef RAPIDJSON_STREAM_H_
-#define RAPIDJSON_STREAM_H_
-
-#include "encodings.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-//  Stream
-
-/*! \class rapidjson::Stream
-    \brief Concept for reading and writing characters.
-
-    For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().
-
-    For write-only stream, only need to implement Put() and Flush().
-
-\code
-concept Stream {
-    typename Ch;    //!< Character type of the stream.
-
-    //! Read the current character from stream without moving the read cursor.
-    Ch Peek() const;
-
-    //! Read the current character from stream and moving the read cursor to next character.
-    Ch Take();
-
-    //! Get the current read cursor.
-    //! \return Number of characters read from start.
-    size_t Tell();
-
-    //! Begin writing operation at the current read pointer.
-    //! \return The begin writer pointer.
-    Ch* PutBegin();
-
-    //! Write a character.
-    void Put(Ch c);
-
-    //! Flush the buffer.
-    void Flush();
-
-    //! End the writing operation.
-    //! \param begin The begin write pointer returned by PutBegin().
-    //! \return Number of characters written.
-    size_t PutEnd(Ch* begin);
-}
-\endcode
-*/
-
-//! Provides additional information for stream.
-/*!
-    By using traits pattern, this type provides a default configuration for stream.
-    For custom stream, this type can be specialized for other configuration.
-    See TEST(Reader, CustomStringStream) in readertest.cpp for example.
-*/
-template<typename Stream>
-struct StreamTraits
-{
-  //! Whether to make local copy of stream for optimization during parsing.
-  /*!
-      By default, for safety, streams do not use local copy optimization.
-      Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
-  */
-  enum { copyOptimization = 0 };
-};
-
-//! Reserve n characters for writing to a stream.
-template<typename Stream>
-inline void PutReserve(Stream &stream, size_t count)
-{
-  (void)stream;
-  (void)count;
-}
-
-//! Write character to a stream, presuming buffer is reserved.
-template<typename Stream>
-inline void PutUnsafe(Stream &stream, typename Stream::Ch c)
-{
-  stream.Put(c);
-}
-
-//! Put N copies of a character to a stream.
-template<typename Stream, typename Ch>
-inline void PutN(Stream &stream, Ch c, size_t n)
-{
-  PutReserve(stream, n);
-  for (size_t i = 0; i < n; i++)
-    PutUnsafe(stream, c);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericStreamWrapper
-
-//! A Stream Wrapper
-/*! \tThis string stream is a wrapper for any stream by just forwarding any
-    \treceived message to the origin stream.
-    \note implements Stream concept
-*/
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
-#endif
-
-template <typename InputStream, typename Encoding = UTF8<> >
-class GenericStreamWrapper
-{
-  public:
-    typedef typename Encoding::Ch Ch;
-    GenericStreamWrapper(InputStream &is): is_(is) {}
-
-    Ch Peek() const
-    {
-      return is_.Peek();
-    }
-    Ch Take()
-    {
-      return is_.Take();
-    }
-    size_t Tell()
-    {
-      return is_.Tell();
-    }
-    Ch *PutBegin()
-    {
-      return is_.PutBegin();
-    }
-    void Put(Ch ch)
-    {
-      is_.Put(ch);
-    }
-    void Flush()
-    {
-      is_.Flush();
-    }
-    size_t PutEnd(Ch *ch)
-    {
-      return is_.PutEnd(ch);
-    }
-
-    // wrapper for MemoryStream
-    const Ch *Peek4() const
-    {
-      return is_.Peek4();
-    }
-
-    // wrapper for AutoUTFInputStream
-    UTFType GetType() const
-    {
-      return is_.GetType();
-    }
-    bool HasBOM() const
-    {
-      return is_.HasBOM();
-    }
-
-  protected:
-    InputStream &is_;
-};
-
-#if defined(_MSC_VER) && _MSC_VER <= 1800
-RAPIDJSON_DIAG_POP
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// StringStream
-
-//! Read-only string stream.
-/*! \note implements Stream concept
-*/
-template <typename Encoding>
-struct GenericStringStream
-{
-  typedef typename Encoding::Ch Ch;
-
-  GenericStringStream(const Ch *src) : src_(src), head_(src) {}
-
-  Ch Peek() const
-  {
-    return *src_;
-  }
-  Ch Take()
-  {
-    return *src_++;
-  }
-  size_t Tell() const
-  {
-    return static_cast<size_t>(src_ - head_);
-  }
-
-  Ch *PutBegin()
-  {
-    RAPIDJSON_ASSERT(false);
-    return 0;
-  }
-  void Put(Ch)
-  {
-    RAPIDJSON_ASSERT(false);
-  }
-  void Flush()
-  {
-    RAPIDJSON_ASSERT(false);
-  }
-  size_t PutEnd(Ch *)
-  {
-    RAPIDJSON_ASSERT(false);
-    return 0;
-  }
-
-  const Ch *src_;     //!< Current read position.
-  const Ch *head_;    //!< Original head of the string.
-};
-
-template <typename Encoding>
-struct StreamTraits<GenericStringStream<Encoding> >
-{
-  enum { copyOptimization = 1 };
-};
-
-//! String stream with UTF8 encoding.
-typedef GenericStringStream<UTF8<> > StringStream;
-
-///////////////////////////////////////////////////////////////////////////////
-// InsituStringStream
-
-//! A read-write string stream.
-/*! This string stream is particularly designed for in-situ parsing.
-    \note implements Stream concept
-*/
-template <typename Encoding>
-struct GenericInsituStringStream
-{
-  typedef typename Encoding::Ch Ch;
-
-  GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
-
-  // Read
-  Ch Peek()
-  {
-    return *src_;
-  }
-  Ch Take()
-  {
-    return *src_++;
-  }
-  size_t Tell()
-  {
-    return static_cast<size_t>(src_ - head_);
-  }
-
-  // Write
-  void Put(Ch c)
-  {
-    RAPIDJSON_ASSERT(dst_ != 0);
-    *dst_++ = c;
-  }
-
-  Ch *PutBegin()
-  {
-    return dst_ = src_;
-  }
-  size_t PutEnd(Ch *begin)
-  {
-    return static_cast<size_t>(dst_ - begin);
-  }
-  void Flush() {}
-
-  Ch *Push(size_t count)
-  {
-    Ch *begin = dst_;
-    dst_ += count;
-    return begin;
-  }
-  void Pop(size_t count)
-  {
-    dst_ -= count;
-  }
-
-  Ch *src_;
-  Ch *dst_;
-  Ch *head_;
-};
-
-template <typename Encoding>
-struct StreamTraits<GenericInsituStringStream<Encoding> >
-{
-  enum { copyOptimization = 1 };
-};
-
-//! Insitu string stream with UTF8 encoding.
-typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_STREAM_H_
diff --git a/contrib/world_builder/include/rapidjson/stringbuffer.h.bak b/contrib/world_builder/include/rapidjson/stringbuffer.h.bak
deleted file mode 100644
index 1e917796e4c..00000000000
--- a/contrib/world_builder/include/rapidjson/stringbuffer.h.bak
+++ /dev/null
@@ -1,155 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_STRINGBUFFER_H_
-#define RAPIDJSON_STRINGBUFFER_H_
-
-#include "stream.h"
-#include "internal/stack.h"
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-#include <utility> // std::move
-#endif
-
-#include "internal/stack.h"
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Represents an in-memory output stream.
-/*!
-    \tparam Encoding Encoding of the stream.
-    \tparam Allocator type for allocating memory buffer.
-    \note implements Stream concept
-*/
-template <typename Encoding, typename Allocator = CrtAllocator>
-class GenericStringBuffer
-{
-  public:
-    typedef typename Encoding::Ch Ch;
-
-    GenericStringBuffer(Allocator *allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericStringBuffer(GenericStringBuffer &&rhs) : stack_(std::move(rhs.stack_)) {}
-    GenericStringBuffer &operator=(GenericStringBuffer&& rhs)
-    {
-      if (&rhs != this)
-        stack_ = std::move(rhs.stack_);
-      return *this;
-    }
-#endif
-
-    void Put(Ch c)
-    {
-      *stack_.template Push<Ch>() = c;
-    }
-    void PutUnsafe(Ch c)
-    {
-      *stack_.template PushUnsafe<Ch>() = c;
-    }
-    void Flush() {}
-
-    void Clear()
-    {
-      stack_.Clear();
-    }
-    void ShrinkToFit()
-    {
-      // Push and pop a null terminator. This is safe.
-      *stack_.template Push<Ch>() = '\0';
-      stack_.ShrinkToFit();
-      stack_.template Pop<Ch>(1);
-    }
-
-    void Reserve(size_t count)
-    {
-      stack_.template Reserve<Ch>(count);
-    }
-    Ch *Push(size_t count)
-    {
-      return stack_.template Push<Ch>(count);
-    }
-    Ch *PushUnsafe(size_t count)
-    {
-      return stack_.template PushUnsafe<Ch>(count);
-    }
-    void Pop(size_t count)
-    {
-      stack_.template Pop<Ch>(count);
-    }
-
-    const Ch *GetString() const
-    {
-      // Push and pop a null terminator. This is safe.
-      *stack_.template Push<Ch>() = '\0';
-      stack_.template Pop<Ch>(1);
-
-      return stack_.template Bottom<Ch>();
-    }
-
-    //! Get the size of string in bytes in the string buffer.
-    size_t GetSize() const
-    {
-      return stack_.GetSize();
-    }
-
-    //! Get the length of string in Ch in the string buffer.
-    size_t GetLength() const
-    {
-      return stack_.GetSize() / sizeof(Ch);
-    }
-
-    static const size_t kDefaultCapacity = 256;
-    mutable internal::Stack<Allocator> stack_;
-
-  private:
-    // Prohibit copy constructor & assignment operator.
-    GenericStringBuffer(const GenericStringBuffer &);
-    GenericStringBuffer &operator=(const GenericStringBuffer &);
-};
-
-//! String buffer with UTF8 encoding
-typedef GenericStringBuffer<UTF8<> > StringBuffer;
-
-template<typename Encoding, typename Allocator>
-inline void PutReserve(GenericStringBuffer<Encoding, Allocator> &stream, size_t count)
-{
-  stream.Reserve(count);
-}
-
-template<typename Encoding, typename Allocator>
-inline void PutUnsafe(GenericStringBuffer<Encoding, Allocator> &stream, typename Encoding::Ch c)
-{
-  stream.PutUnsafe(c);
-}
-
-//! Implement specialized version of PutN() with memset() for better performance.
-template<>
-inline void PutN(GenericStringBuffer<UTF8<> > &stream, char c, size_t n)
-{
-  std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_STRINGBUFFER_H_
diff --git a/contrib/world_builder/include/rapidjson/writer.h.bak b/contrib/world_builder/include/rapidjson/writer.h.bak
deleted file mode 100644
index 815dfcdde83..00000000000
--- a/contrib/world_builder/include/rapidjson/writer.h.bak
+++ /dev/null
@@ -1,867 +0,0 @@
-// Tencent is pleased to support the open source community by making RapidJSON available.
-//
-// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
-//
-// Licensed under the MIT License (the "License"); you may not use this file except
-// in compliance with the License. You may obtain a copy of the License at
-//
-// http://opensource.org/licenses/MIT
-//
-// Unless required by applicable law or agreed to in writing, software distributed
-// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-// CONDITIONS OF ANY KIND, either express or implied. See the License for the
-// specific language governing permissions and limitations under the License.
-
-#ifndef RAPIDJSON_WRITER_H_
-#define RAPIDJSON_WRITER_H_
-
-#include "stream.h"
-#include "internal/meta.h"
-#include "internal/stack.h"
-#include "internal/strfunc.h"
-#include "internal/dtoa.h"
-#include "internal/itoa.h"
-#include "stringbuffer.h"
-#include <new>      // placement new
-
-#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
-#include <intrin.h>
-#pragma intrinsic(_BitScanForward)
-#endif
-#ifdef RAPIDJSON_SSE42
-#include <nmmintrin.h>
-#elif defined(RAPIDJSON_SSE2)
-#include <emmintrin.h>
-#elif defined(RAPIDJSON_NEON)
-#include <arm_neon.h>
-#endif
-
-#ifdef __clang__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(padded)
-RAPIDJSON_DIAG_OFF(unreachable-code)
-RAPIDJSON_DIAG_OFF(c++98-compat)
-#elif defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// WriteFlag
-
-/*! \def RAPIDJSON_WRITE_DEFAULT_FLAGS
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-defined kWriteDefaultFlags definition.
-
-    User can define this as any \c WriteFlag combinations.
-*/
-#ifndef RAPIDJSON_WRITE_DEFAULT_FLAGS
-#define RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags
-#endif
-
-//! Combination of writeFlags
-enum WriteFlag
-{
-  kWriteNoFlags = 0,              //!< No flags are set.
-  kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings.
-  kWriteNanAndInfFlag = 2,        //!< Allow writing of Infinity, -Infinity and NaN.
-  kWriteDefaultFlags = RAPIDJSON_WRITE_DEFAULT_FLAGS  //!< Default write flags. Can be customized by defining RAPIDJSON_WRITE_DEFAULT_FLAGS
-};
-
-//! JSON writer
-/*! Writer implements the concept Handler.
-    It generates JSON text by events to an output os.
-
-    User may programmatically calls the functions of a writer to generate JSON text.
-
-    On the other side, a writer can also be passed to objects that generates events,
-
-    for example Reader::Parse() and Document::Accept().
-
-    \tparam OutputStream Type of output stream.
-    \tparam SourceEncoding Encoding of source string.
-    \tparam TargetEncoding Encoding of output stream.
-    \tparam StackAllocator Type of allocator for allocating memory of stack.
-    \note implements Handler concept
-*/
-template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
-class Writer
-{
-  public:
-    typedef typename SourceEncoding::Ch Ch;
-
-    static const int kDefaultMaxDecimalPlaces = 324;
-
-    //! Constructor
-    /*! \param os Output stream.
-        \param stackAllocator User supplied allocator. If it is null, it will create a private one.
-        \param levelDepth Initial capacity of stack.
-    */
-    explicit
-    Writer(OutputStream &os, StackAllocator *stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) :
-      os_(&os), level_stack_(stackAllocator, levelDepth *sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
-
-    explicit
-    Writer(StackAllocator *allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
-      os_(0), level_stack_(allocator, levelDepth *sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    Writer(Writer &&rhs) :
-      os_(rhs.os_), level_stack_(std::move(rhs.level_stack_)), maxDecimalPlaces_(rhs.maxDecimalPlaces_), hasRoot_(rhs.hasRoot_)
-    {
-      rhs.os_ = 0;
-    }
-#endif
-
-    //! Reset the writer with a new stream.
-    /*!
-        This function reset the writer with a new stream and default settings,
-        in order to make a Writer object reusable for output multiple JSONs.
-
-        \param os New output stream.
-        \code
-        Writer<OutputStream> writer(os1);
-        writer.StartObject();
-        // ...
-        writer.EndObject();
-
-        writer.Reset(os2);
-        writer.StartObject();
-        // ...
-        writer.EndObject();
-        \endcode
-    */
-    void Reset(OutputStream &os)
-    {
-      os_ = &os;
-      hasRoot_ = false;
-      level_stack_.Clear();
-    }
-
-    //! Checks whether the output is a complete JSON.
-    /*!
-        A complete JSON has a complete root object or array.
-    */
-    bool IsComplete() const
-    {
-      return hasRoot_ && level_stack_.Empty();
-    }
-
-    int GetMaxDecimalPlaces() const
-    {
-      return maxDecimalPlaces_;
-    }
-
-    //! Sets the maximum number of decimal places for double output.
-    /*!
-        This setting truncates the output with specified number of decimal places.
-
-        For example,
-
-        \code
-        writer.SetMaxDecimalPlaces(3);
-        writer.StartArray();
-        writer.Double(0.12345);                 // "0.123"
-        writer.Double(0.0001);                  // "0.0"
-        writer.Double(1.234567890123456e30);    // "1.234567890123456e30" (do not truncate significand for positive exponent)
-        writer.Double(1.23e-4);                 // "0.0"                  (do truncate significand for negative exponent)
-        writer.EndArray();
-        \endcode
-
-        The default setting does not truncate any decimal places. You can restore to this setting by calling
-        \code
-        writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces);
-        \endcode
-    */
-    void SetMaxDecimalPlaces(int maxDecimalPlaces)
-    {
-      maxDecimalPlaces_ = maxDecimalPlaces;
-    }
-
-    /*!@name Implementation of Handler
-        \see Handler
-    */
-    //@{
-
-    bool Null()
-    {
-      Prefix(kNullType);
-      return EndValue(WriteNull());
-    }
-    bool Bool(bool b)
-    {
-      Prefix(b ? kTrueType : kFalseType);
-      return EndValue(WriteBool(b));
-    }
-    bool Int(int i)
-    {
-      Prefix(kNumberType);
-      return EndValue(WriteInt(i));
-    }
-    bool Uint(unsigned u)
-    {
-      Prefix(kNumberType);
-      return EndValue(WriteUint(u));
-    }
-    bool Int64(int64_t i64)
-    {
-      Prefix(kNumberType);
-      return EndValue(WriteInt64(i64));
-    }
-    bool Uint64(uint64_t u64)
-    {
-      Prefix(kNumberType);
-      return EndValue(WriteUint64(u64));
-    }
-
-    //! Writes the given \c double value to the stream
-    /*!
-        \param d The value to be written.
-        \return Whether it is succeed.
-    */
-    bool Double(double d)
-    {
-      Prefix(kNumberType);
-      return EndValue(WriteDouble(d));
-    }
-
-    bool RawNumber(const Ch *str, SizeType length, bool copy = false)
-    {
-      RAPIDJSON_ASSERT(str != 0);
-      (void)copy;
-      Prefix(kNumberType);
-      return EndValue(WriteString(str, length));
-    }
-
-    bool String(const Ch *str, SizeType length, bool copy = false)
-    {
-      RAPIDJSON_ASSERT(str != 0);
-      (void)copy;
-      Prefix(kStringType);
-      return EndValue(WriteString(str, length));
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool String(const std::basic_string<Ch> &str)
-    {
-      return String(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool StartObject()
-    {
-      Prefix(kObjectType);
-      new (level_stack_.template Push<Level>()) Level(false);
-      return WriteStartObject();
-    }
-
-    bool Key(const Ch *str, SizeType length, bool copy = false)
-    {
-      return String(str, length, copy);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool Key(const std::basic_string<Ch> &str)
-    {
-      return Key(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool EndObject(SizeType memberCount = 0)
-    {
-      (void)memberCount;
-      RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level)); // not inside an Object
-      RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray); // currently inside an Array, not Object
-      RAPIDJSON_ASSERT(0 == level_stack_.template Top<Level>()->valueCount % 2); // Object has a Key without a Value
-      level_stack_.template Pop<Level>(1);
-      return EndValue(WriteEndObject());
-    }
-
-    bool StartArray()
-    {
-      Prefix(kArrayType);
-      new (level_stack_.template Push<Level>()) Level(true);
-      return WriteStartArray();
-    }
-
-    bool EndArray(SizeType elementCount = 0)
-    {
-      (void)elementCount;
-      RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
-      RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
-      level_stack_.template Pop<Level>(1);
-      return EndValue(WriteEndArray());
-    }
-    //@}
-
-    /*! @name Convenience extensions */
-    //@{
-
-    //! Simpler but slower overload.
-    bool String(const Ch *const &str)
-    {
-      return String(str, internal::StrLen(str));
-    }
-    bool Key(const Ch *const &str)
-    {
-      return Key(str, internal::StrLen(str));
-    }
-
-    //@}
-
-    //! Write a raw JSON value.
-    /*!
-        For user to write a stringified JSON as a value.
-
-        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
-        \param length Length of the json.
-        \param type Type of the root of json.
-    */
-    bool RawValue(const Ch *json, size_t length, Type type)
-    {
-      RAPIDJSON_ASSERT(json != 0);
-      Prefix(type);
-      return EndValue(WriteRawValue(json, length));
-    }
-
-    //! Flush the output stream.
-    /*!
-        Allows the user to flush the output stream immediately.
-     */
-    void Flush()
-    {
-      os_->Flush();
-    }
-
-  protected:
-    //! Information for each nested level
-    struct Level
-    {
-      Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
-      size_t valueCount;  //!< number of values in this level
-      bool inArray;       //!< true if in array, otherwise in object
-    };
-
-    static const size_t kDefaultLevelDepth = 32;
-
-    bool WriteNull()
-    {
-      PutReserve(*os_, 4);
-      PutUnsafe(*os_, 'n');
-      PutUnsafe(*os_, 'u');
-      PutUnsafe(*os_, 'l');
-      PutUnsafe(*os_, 'l');
-      return true;
-    }
-
-    bool WriteBool(bool b)
-    {
-      if (b)
-        {
-          PutReserve(*os_, 4);
-          PutUnsafe(*os_, 't');
-          PutUnsafe(*os_, 'r');
-          PutUnsafe(*os_, 'u');
-          PutUnsafe(*os_, 'e');
-        }
-      else
-        {
-          PutReserve(*os_, 5);
-          PutUnsafe(*os_, 'f');
-          PutUnsafe(*os_, 'a');
-          PutUnsafe(*os_, 'l');
-          PutUnsafe(*os_, 's');
-          PutUnsafe(*os_, 'e');
-        }
-      return true;
-    }
-
-    bool WriteInt(int i)
-    {
-      char buffer[11];
-      const char *end = internal::i32toa(i, buffer);
-      PutReserve(*os_, static_cast<size_t>(end - buffer));
-      for (const char *p = buffer; p != end; ++p)
-        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-      return true;
-    }
-
-    bool WriteUint(unsigned u)
-    {
-      char buffer[10];
-      const char *end = internal::u32toa(u, buffer);
-      PutReserve(*os_, static_cast<size_t>(end - buffer));
-      for (const char *p = buffer; p != end; ++p)
-        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-      return true;
-    }
-
-    bool WriteInt64(int64_t i64)
-    {
-      char buffer[21];
-      const char *end = internal::i64toa(i64, buffer);
-      PutReserve(*os_, static_cast<size_t>(end - buffer));
-      for (const char *p = buffer; p != end; ++p)
-        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-      return true;
-    }
-
-    bool WriteUint64(uint64_t u64)
-    {
-      char buffer[20];
-      char *end = internal::u64toa(u64, buffer);
-      PutReserve(*os_, static_cast<size_t>(end - buffer));
-      for (char *p = buffer; p != end; ++p)
-        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-      return true;
-    }
-
-    bool WriteDouble(double d)
-    {
-      if (internal::Double(d).IsNanOrInf())
-        {
-          if (!(writeFlags & kWriteNanAndInfFlag))
-            return false;
-          if (internal::Double(d).IsNan())
-            {
-              PutReserve(*os_, 3);
-              PutUnsafe(*os_, 'N');
-              PutUnsafe(*os_, 'a');
-              PutUnsafe(*os_, 'N');
-              return true;
-            }
-          if (internal::Double(d).Sign())
-            {
-              PutReserve(*os_, 9);
-              PutUnsafe(*os_, '-');
-            }
-          else
-            PutReserve(*os_, 8);
-          PutUnsafe(*os_, 'I');
-          PutUnsafe(*os_, 'n');
-          PutUnsafe(*os_, 'f');
-          PutUnsafe(*os_, 'i');
-          PutUnsafe(*os_, 'n');
-          PutUnsafe(*os_, 'i');
-          PutUnsafe(*os_, 't');
-          PutUnsafe(*os_, 'y');
-          return true;
-        }
-
-      char buffer[25];
-      char *end = internal::dtoa(d, buffer, maxDecimalPlaces_);
-      PutReserve(*os_, static_cast<size_t>(end - buffer));
-      for (char *p = buffer; p != end; ++p)
-        PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
-      return true;
-    }
-
-    bool WriteString(const Ch *str, SizeType length, bool quotes = true)
-    {
-      static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-      static const char escape[256] =
-      {
-#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-        //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
-        'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
-        'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
-        0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
-        Z16, Z16,                                                                       // 30~4F
-        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
-        Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
-#undef Z16
-      };
-
-      if (quotes)
-        {
-          if (TargetEncoding::supportUnicode)
-            PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
-          else
-            PutReserve(*os_, 2 + length * 12);  // "\uxxxx\uyyyy..."
-        }
-      else
-        {
-          if (TargetEncoding::supportUnicode)
-            PutReserve(*os_, length * 6); // "\uxxxx..."
-          else
-            PutReserve(*os_, length * 12);  // "\uxxxx\uyyyy..."
-        }
-
-      if (quotes)
-        PutUnsafe(*os_, '\"');
-      GenericStringStream<SourceEncoding> is(str);
-      while (ScanWriteUnescapedString(is, length))
-        {
-          const Ch c = is.Peek();
-          if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80)
-            {
-              // Unicode escaping
-              unsigned codepoint;
-              if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
-                return false;
-              PutUnsafe(*os_, '\\');
-              PutUnsafe(*os_, 'u');
-              if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF))
-                {
-                  PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
-                  PutUnsafe(*os_, hexDigits[(codepoint >>  8) & 15]);
-                  PutUnsafe(*os_, hexDigits[(codepoint >>  4) & 15]);
-                  PutUnsafe(*os_, hexDigits[(codepoint      ) & 15]);
-                }
-              else
-                {
-                  RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
-                  // Surrogate pair
-                  unsigned s = codepoint - 0x010000;
-                  unsigned lead = (s >> 10) + 0xD800;
-                  unsigned trail = (s & 0x3FF) + 0xDC00;
-                  PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
-                  PutUnsafe(*os_, hexDigits[(lead >>  8) & 15]);
-                  PutUnsafe(*os_, hexDigits[(lead >>  4) & 15]);
-                  PutUnsafe(*os_, hexDigits[(lead      ) & 15]);
-                  PutUnsafe(*os_, '\\');
-                  PutUnsafe(*os_, 'u');
-                  PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
-                  PutUnsafe(*os_, hexDigits[(trail >>  8) & 15]);
-                  PutUnsafe(*os_, hexDigits[(trail >>  4) & 15]);
-                  PutUnsafe(*os_, hexDigits[(trail      ) & 15]);
-                }
-            }
-          else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)]))
-            {
-              is.Take();
-              if (quotes)
-                PutUnsafe(*os_, '\\');
-              PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(escape[static_cast<unsigned char>(c)]));
-              if (escape[static_cast<unsigned char>(c)] == 'u')
-                {
-                  PutUnsafe(*os_, '0');
-                  PutUnsafe(*os_, '0');
-                  PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
-                  PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
-                }
-            }
-          else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ?
-                                        Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
-                                        Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
-            return false;
-        }
-      if (quotes)
-        PutUnsafe(*os_, '\"');
-      return true;
-    }
-
-    bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding> &is, size_t length)
-    {
-      return RAPIDJSON_LIKELY(is.Tell() < length);
-    }
-
-    bool WriteStartObject()
-    {
-      os_->Put('{');
-      return true;
-    }
-    bool WriteEndObject()
-    {
-      os_->Put('}');
-      return true;
-    }
-    bool WriteStartArray()
-    {
-      os_->Put('[');
-      return true;
-    }
-    bool WriteEndArray()
-    {
-      os_->Put(']');
-      return true;
-    }
-
-    bool WriteRawValue(const Ch *json, size_t length)
-    {
-      PutReserve(*os_, length);
-      GenericStringStream<SourceEncoding> is(json);
-      while (RAPIDJSON_LIKELY(is.Tell() < length))
-        {
-          RAPIDJSON_ASSERT(is.Peek() != '\0');
-          if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ?
-                                   Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
-                                   Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
-            return false;
-        }
-      return true;
-    }
-
-    void Prefix(Type type)
-    {
-      (void)type;
-      if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0))   // this value is not at root
-        {
-          Level *level = level_stack_.template Top<Level>();
-          if (level->valueCount > 0)
-            {
-              if (level->inArray)
-                os_->Put(','); // add comma if it is not the first element in array
-              else  // in object
-                os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
-            }
-          if (!level->inArray && level->valueCount % 2 == 0)
-            RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
-          level->valueCount++;
-        }
-      else
-        {
-          RAPIDJSON_ASSERT(!hasRoot_);    // Should only has one and only one root.
-          hasRoot_ = true;
-        }
-    }
-
-    // Flush the value if it is the top level one.
-    bool EndValue(bool ret)
-    {
-      if (RAPIDJSON_UNLIKELY(level_stack_.Empty()))   // end of json text
-        Flush();
-      return ret;
-    }
-
-    OutputStream *os_;
-    internal::Stack<StackAllocator> level_stack_;
-    int maxDecimalPlaces_;
-    bool hasRoot_;
-
-  private:
-    // Prohibit copy constructor & assignment operator.
-    Writer(const Writer &);
-    Writer &operator=(const Writer &);
-};
-
-// Full specialization for StringStream to prevent memory copying
-
-template<>
-inline bool Writer<StringBuffer>::WriteInt(int i)
-{
-  char *buffer = os_->Push(11);
-  const char *end = internal::i32toa(i, buffer);
-  os_->Pop(static_cast<size_t>(11 - (end - buffer)));
-  return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteUint(unsigned u)
-{
-  char *buffer = os_->Push(10);
-  const char *end = internal::u32toa(u, buffer);
-  os_->Pop(static_cast<size_t>(10 - (end - buffer)));
-  return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteInt64(int64_t i64)
-{
-  char *buffer = os_->Push(21);
-  const char *end = internal::i64toa(i64, buffer);
-  os_->Pop(static_cast<size_t>(21 - (end - buffer)));
-  return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteUint64(uint64_t u)
-{
-  char *buffer = os_->Push(20);
-  const char *end = internal::u64toa(u, buffer);
-  os_->Pop(static_cast<size_t>(20 - (end - buffer)));
-  return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteDouble(double d)
-{
-  if (internal::Double(d).IsNanOrInf())
-    {
-      // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
-      if (!(kWriteDefaultFlags & kWriteNanAndInfFlag))
-        return false;
-      if (internal::Double(d).IsNan())
-        {
-          PutReserve(*os_, 3);
-          PutUnsafe(*os_, 'N');
-          PutUnsafe(*os_, 'a');
-          PutUnsafe(*os_, 'N');
-          return true;
-        }
-      if (internal::Double(d).Sign())
-        {
-          PutReserve(*os_, 9);
-          PutUnsafe(*os_, '-');
-        }
-      else
-        PutReserve(*os_, 8);
-      PutUnsafe(*os_, 'I');
-      PutUnsafe(*os_, 'n');
-      PutUnsafe(*os_, 'f');
-      PutUnsafe(*os_, 'i');
-      PutUnsafe(*os_, 'n');
-      PutUnsafe(*os_, 'i');
-      PutUnsafe(*os_, 't');
-      PutUnsafe(*os_, 'y');
-      return true;
-    }
-
-  char *buffer = os_->Push(25);
-  char *end = internal::dtoa(d, buffer, maxDecimalPlaces_);
-  os_->Pop(static_cast<size_t>(25 - (end - buffer)));
-  return true;
-}
-
-#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
-template<>
-inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream &is, size_t length)
-{
-  if (length < 16)
-    return RAPIDJSON_LIKELY(is.Tell() < length);
-
-  if (!RAPIDJSON_LIKELY(is.Tell() < length))
-    return false;
-
-  const char *p = is.src_;
-  const char *end = is.head_ + length;
-  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-  const char *endAligned = reinterpret_cast<const char *>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
-  if (nextAligned > end)
-    return true;
-
-  while (p != nextAligned)
-    if (*p < 0x20 || *p == '\"' || *p == '\\')
-      {
-        is.src_ = p;
-        return RAPIDJSON_LIKELY(is.Tell() < length);
-      }
-    else
-      os_->PutUnsafe(*p++);
-
-  // The rest of string using SIMD
-  static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
-  static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
-  static const char space[16]  = { 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F };
-  const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
-  const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
-  const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
-
-  for (; p != endAligned; p += 16)
-    {
-      const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
-      const __m128i t1 = _mm_cmpeq_epi8(s, dq);
-      const __m128i t2 = _mm_cmpeq_epi8(s, bs);
-      const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x1F) == 0x1F
-      const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
-      unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
-      if (RAPIDJSON_UNLIKELY(r != 0))     // some of characters is escaped
-        {
-          SizeType len;
-#ifdef _MSC_VER         // Find the index of first escaped
-          unsigned long offset;
-          _BitScanForward(&offset, r);
-          len = offset;
-#else
-          len = static_cast<SizeType>(__builtin_ffs(r) - 1);
-#endif
-          char *q = reinterpret_cast<char *>(os_->PushUnsafe(len));
-          for (size_t i = 0; i < len; i++)
-            q[i] = p[i];
-
-          p += len;
-          break;
-        }
-      _mm_storeu_si128(reinterpret_cast<__m128i *>(os_->PushUnsafe(16)), s);
-    }
-
-  is.src_ = p;
-  return RAPIDJSON_LIKELY(is.Tell() < length);
-}
-#elif defined(RAPIDJSON_NEON)
-template<>
-inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream &is, size_t length)
-{
-  if (length < 16)
-    return RAPIDJSON_LIKELY(is.Tell() < length);
-
-  if (!RAPIDJSON_LIKELY(is.Tell() < length))
-    return false;
-
-  const char *p = is.src_;
-  const char *end = is.head_ + length;
-  const char *nextAligned = reinterpret_cast<const char *>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
-  const char *endAligned = reinterpret_cast<const char *>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
-  if (nextAligned > end)
-    return true;
-
-  while (p != nextAligned)
-    if (*p < 0x20 || *p == '\"' || *p == '\\')
-      {
-        is.src_ = p;
-        return RAPIDJSON_LIKELY(is.Tell() < length);
-      }
-    else
-      os_->PutUnsafe(*p++);
-
-  // The rest of string using SIMD
-  const uint8x16_t s0 = vmovq_n_u8('"');
-  const uint8x16_t s1 = vmovq_n_u8('\\');
-  const uint8x16_t s2 = vmovq_n_u8('\b');
-  const uint8x16_t s3 = vmovq_n_u8(32);
-
-  for (; p != endAligned; p += 16)
-    {
-      const uint8x16_t s = vld1q_u8(reinterpret_cast<const uint8_t *>(p));
-      uint8x16_t x = vceqq_u8(s, s0);
-      x = vorrq_u8(x, vceqq_u8(s, s1));
-      x = vorrq_u8(x, vceqq_u8(s, s2));
-      x = vorrq_u8(x, vcltq_u8(s, s3));
-
-      x = vrev64q_u8(x);                     // Rev in 64
-      uint64_t low = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 0);   // extract
-      uint64_t high = vgetq_lane_u64(reinterpret_cast<uint64x2_t>(x), 1);  // extract
-
-      SizeType len = 0;
-      bool escaped = false;
-      if (low == 0)
-        {
-          if (high != 0)
-            {
-              unsigned lz = (unsigned)__builtin_clzll(high);
-              len = 8 + (lz >> 3);
-              escaped = true;
-            }
-        }
-      else
-        {
-          unsigned lz = (unsigned)__builtin_clzll(low);
-          len = lz >> 3;
-          escaped = true;
-        }
-      if (RAPIDJSON_UNLIKELY(escaped))     // some of characters is escaped
-        {
-          char *q = reinterpret_cast<char *>(os_->PushUnsafe(len));
-          for (size_t i = 0; i < len; i++)
-            q[i] = p[i];
-
-          p += len;
-          break;
-        }
-      vst1q_u8(reinterpret_cast<uint8_t *>(os_->PushUnsafe(16)), s);
-    }
-
-  is.src_ = p;
-  return RAPIDJSON_LIKELY(is.Tell() < length);
-}
-#endif // RAPIDJSON_NEON
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(_MSC_VER) || defined(__clang__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/contrib/world_builder/include/visualization/main.h.bak b/contrib/world_builder/include/visualization/main.h.bak
deleted file mode 100644
index de5685a9a84..00000000000
--- a/contrib/world_builder/include/visualization/main.h.bak
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-  Copyright (C) 2020 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_VISUALIZATION_MAIN_H_
-#define WORLD_BUILDER_VISUALIZATION_MAIN_H_
-
-#include <vector>
-#include <string>
-
-void project_on_sphere(double, double &, double &, double &);
-
-void lay_points(double x1, double y1, double z1,
-                double x2, double y2, double z2,
-                double x3, double y3, double z3,
-                double x4, double y4, double z4,
-                std::vector<double> &x, std::vector<double> &y, std::vector<double> &z,
-                std::vector<bool> &hull, size_t level);
-
-std::vector<std::string> get_command_line_options_vector(int argc, char **argv);
-
-bool find_command_line_option(char **begin, char **end, const std::string &option);
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/assert.h.bak b/contrib/world_builder/include/world_builder/assert.h.bak
deleted file mode 100644
index c0b563cfd07..00000000000
--- a/contrib/world_builder/include/world_builder/assert.h.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#ifndef WORLD_BUILDER_ASSERT_H_
-#define WORLD_BUILDER_ASSERT_H_
-
-#include <sstream>
-
-namespace WorldBuilder
-{
-#ifndef NDEBUG
-#   define WBAssert(condition, message) \
-  do { \
-      if (! (condition)) { \
-          std::stringstream smessage; \
-          smessage << "Assert `" #condition "` failed in " << __FILE__ \
-                   << " at line " << __LINE__ << ": " << message << std::endl << std::endl << "Error not recoverable, aborting program."; \
-          throw std::runtime_error(smessage.str()); \
-        } \
-    } while (false)
-#else
-#   define WBAssert(condition, message) do { } while (false)
-#endif
-
-#   define WBAssertThrow(condition, message) \
-  do { \
-      if (! (condition)) { \
-          std::stringstream smessage; \
-          smessage << "AssertThrow `" #condition "` failed in " << __FILE__ \
-                   << " at line " << __LINE__ << ": " << message << std::endl << std::endl << "Error not recoverable, aborting program."; \
-          throw std::runtime_error(smessage.str()); \
-        } \
-    } while (false)
-
-
-#   define WBAssertThrowExc(condition, exc, message) \
-  do { \
-      if (! (condition)) { \
-          exc \
-          std::stringstream smessage; \
-          smessage << "AssertThrow `" #condition "` failed in " << __FILE__ \
-                   << " at line " << __LINE__ << ": " << message << std::endl; \
-          throw std::runtime_error(smessage.str()); \
-        } \
-    } while (false)
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/bounding_box.h.bak b/contrib/world_builder/include/world_builder/bounding_box.h.bak
deleted file mode 100644
index 808c15cb8f0..00000000000
--- a/contrib/world_builder/include/world_builder/bounding_box.h.bak
+++ /dev/null
@@ -1,513 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2017 - 2021 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-#ifndef WORLD_BUILDER_BOUNDING_BOX_H
-#define WORLD_BUILDER_BOUNDING_BOX_H
-
-
-#include "assert.h"
-#include "point.h"
-
-#include <limits>
-
-
-namespace WorldBuilder
-{
-
-
-  /**
-   * A class that represents a box of arbitrary dimension <tt>spacedim</tt> and
-   * with sides parallel to the coordinate axes, that is, a region
-   * @f[
-   * [x_0^L, x_0^U] \times ... \times [x_{spacedim-1}^L, x_{spacedim-1}^U],
-   * @f]
-   * where $(x_0^L , ..., x_{spacedim-1}^L)$ and $(x_0^U , ..., x_{spacedim-1}^U)$
-   * denote the two vertices (bottom left and top right) which are used to
-   * represent the box. The quantities $x_k^L$ and $x_k^U$ denote the "lower"
-   * and "upper" bounds of values that are within the box for each coordinate
-   * direction $k$.
-   *
-   * Geometrically, a bounding box is thus:
-   * - 1D: a segment (represented by its vertices in the proper order)
-   * - 2D: a rectangle (represented by the vertices V at bottom left, top right)
-   * @code
-   * .--------V
-   * |        |
-   * V--------.
-   * @endcode
-   *
-   * - 3D: a cuboid (in which case the two vertices V follow the convention and
-   * are not owned by the same face)
-   * @code
-   *   .------V
-   *  /      /|
-   * .------. |
-   * |      | /
-   * |      |/
-   * V------.
-   * @endcode
-   *
-   * Bounding boxes are, for example, useful in parallel distributed meshes to
-   * give a general description of the owners of each portion of the mesh. More
-   * generally, bounding boxes are often used to roughly describe a region of
-   * space in which an object is contained; if a candidate point is not within
-   * the bounding box (a test that is cheap to execute), then it is not necessary
-   * to perform an expensive test whether the candidate point is in fact inside
-   * the object itself. Bounding boxes are therefore often used as a first,
-   * cheap rejection test before more detailed checks. As such, bounding boxes
-   * serve many of the same purposes as the
-   * [convex hull](https://en.wikipedia.org/wiki/Convex_hull), for which it is
-   * also relatively straightforward to compute whether a point is inside or
-   * outside, though not quite as cheap as for the bounding box.
-   *
-   * Taking the cross section of a BoundingBox<spacedim> orthogonal to a given
-   * direction gives a box in one dimension lower: BoundingBox<spacedim - 1>.
-   * In 3D, the 2 coordinates of the cross section of BoundingBox<3> can be
-   * ordered in 2 different ways. That is, if we take the cross section orthogonal
-   * to the y direction we could either order a 3D-coordinate into a
-   * 2D-coordinate as $(x,z)$ or as $(z,x)$. This class uses the second
-   * convention, corresponding to the coordinates being ordered cyclicly
-   * $x \rightarrow y \rightarrow z \rightarrow x \rightarrow ... $
-   * To be precise, if we take a cross section:
-   *
-   * | Orthogonal to | Cross section coordinates ordered as |
-   * |:-------------:|:------------------------------------:|
-   * |      x        |               (y, z)                 |
-   * |      y        |               (z, x)                 |
-   * |      z        |               (x, y)                 |
-   *
-   * This is according to the convention set by the function
-   * <code>coordinate_to_one_dim_higher</code>.
-   *
-   * @note The majority of this class is copied from the deal.II library.
-   */
-  template <unsigned int spacedim>
-  class BoundingBox
-  {
-    public:
-      /**
-       * Standard constructor. Creates an object that corresponds to a
-       * box that corresponds to the entire space, i.e. a degenerate
-       * box with end points at minus and plus infinity.
-       */
-      BoundingBox();
-
-      /**
-       * Standard constructor for non-empty boxes: it uses a pair of points
-       * which describe the box: one for the bottom and one for the top
-       * corner.
-       */
-      BoundingBox(const std::pair<Point<spacedim>, Point<spacedim>>
-                  &boundary_points);
-
-      /**
-       * Construct the bounding box that encloses all the points in the given
-       * container.
-       *
-       * The constructor supports any Container that provides begin() and end()
-       * iterators to Point<spacedim> elements.
-       */
-      template <class Container>
-      BoundingBox(const Container &points);
-
-      /**
-       * Return a reference to the boundary_points
-       */
-      std::pair<Point<spacedim>, Point<spacedim>> &get_boundary_points();
-
-      /**
-       * Return a const reference to the boundary_points
-       */
-      const std::pair<Point<spacedim>, Point<spacedim>> &get_boundary_points() const;
-
-      /**
-       * Test for equality.
-       */
-      bool
-      operator==(const BoundingBox<spacedim> &box) const;
-
-      /**
-       * Test for inequality.
-       */
-      bool
-      operator!=(const BoundingBox<spacedim> &box) const;
-
-      /**
-       * Enlarge the current object so that it contains @p other_bbox .
-       * If the current object already contains @p other_bbox then it is not changed
-       * by this function.
-       */
-      void
-      merge_with(const BoundingBox<spacedim> &other_bbox);
-
-      /**
-       * Return true if the point is inside the Bounding Box, false otherwise. The
-       * parameter @p tolerance is a factor by which the bounding box is enlarged
-       * relative to the dimensions of the bounding box in order to determine in a
-       * numerically robust way whether the point is inside.
-       *
-       * This function is a wrapper for the function point_inside_implementation
-       * to also test point+2pi is the longtiude is smaller then zero and point-2pi
-       * if the longitude is larger than zero.
-       */
-      bool
-      point_inside(
-        const Point<spacedim> &p,
-        const double tolerance = std::numeric_limits<double>::epsilon()) const;
-
-      /**
-       * Increase (or decrease) the size of the bounding box by the given amount.
-       * After calling this method, the lower left corner of the bounding box will
-       * have each coordinate decreased by @p amount, and the upper right corner
-       * of the bounding box will have each coordinate increased by @p amount.
-       *
-       * If you call this method with a negative number, and one of the axes of the
-       * original bounding box is smaller than amount/2, the method will trigger
-       * an assertion.
-       */
-      void
-      extend(const double amount);
-
-      /**
-       * Compute the volume (i.e. the dim-dimensional measure) of the BoundingBox.
-       */
-      double
-      volume() const;
-
-      /**
-       * Returns the point in the center of the box.
-       */
-      Point<spacedim>
-      center() const;
-
-      /**
-       * Returns the side length of the box in @p direction.
-       */
-      double
-      side_length(const unsigned int direction) const;
-
-      /**
-       * Return the lower bound of the box in @p direction.
-       */
-      double
-      lower_bound(const unsigned int direction) const;
-
-      /**
-       * Return the upper bound of the box in @p direction.
-       */
-      double
-      upper_bound(const unsigned int direction) const;
-
-    private:
-      /**
-       * Return true if the point is inside the Bounding Box, false otherwise. The
-       * parameter @p tolerance is a factor by which the bounding box is enlarged
-       * relative to the dimensions of the bounding box in order to determine in a
-       * numerically robust way whether the point is inside.
-       *
-       * This function is supposed to be only used by the point_inside function.
-       */
-      bool
-      point_inside_implementation(
-        const Point<spacedim> &p,
-        const double tolerance = std::numeric_limits<double>::epsilon()) const;
-
-      std::pair<Point<spacedim>, Point<spacedim>> boundary_points;
-
-  };
-
-
-  /*------------------------ Inline functions: BoundingBox --------------------*/
-
-#ifndef DOXYGEN
-
-
-  template <>
-  inline BoundingBox<2>::BoundingBox()
-    :
-    boundary_points ({{
-      -std::numeric_limits<double>::max(),
-      -std::numeric_limits<double>::max(),
-      cartesian
-    },
-    {
-      +std::numeric_limits<double>::max(),
-      +std::numeric_limits<double>::max(),
-      cartesian
-    }
-  })
-  {}
-
-  template <>
-  inline BoundingBox<3>::BoundingBox()
-    :
-    boundary_points ({{
-      -std::numeric_limits<double>::max(),
-      -std::numeric_limits<double>::max(),
-      -std::numeric_limits<double>::max(),
-      cartesian
-    },
-    {
-      +std::numeric_limits<double>::max(),
-      +std::numeric_limits<double>::max(),
-      +std::numeric_limits<double>::max(),
-      cartesian
-    }
-  })
-  {}
-
-
-
-  template <unsigned int spacedim>
-  inline BoundingBox<spacedim>::BoundingBox(
-    const std::pair<Point<spacedim>, Point<spacedim>>
-    &boundary_points_)
-    :
-    boundary_points (boundary_points_)
-  {
-    // We check the Bounding Box is not degenerate
-    for (unsigned int i = 0; i < spacedim; ++i)
-      WBAssert(boundary_points.first[i] <= boundary_points.second[i],
-               "Bounding Box can't be created: the points' "
-               "order should be bottom left, top right!");
-  }
-
-
-
-  template <unsigned int spacedim>
-  template <class Container>
-  inline BoundingBox<spacedim>::BoundingBox(const Container &points)
-  {
-    // Use the default constructor in case points is empty instead of setting
-    // things to +oo and -oo
-    if (points.size() > 0)
-      {
-        auto &min = boundary_points.first;
-        auto &max = boundary_points.second;
-        std::fill(min.begin_raw(),
-                  min.end_raw(),
-                  std::numeric_limits<double>::infinity());
-        std::fill(max.begin_raw(),
-                  max.end_raw(),
-                  -std::numeric_limits<double>::infinity());
-
-        for (const Point<spacedim> &point : points)
-          for (unsigned int d = 0; d < spacedim; ++d)
-            {
-              min[d] = std::min(min[d], point[d]);
-              max[d] = std::max(max[d], point[d]);
-            }
-      }
-  }
-
-
-
-  template <unsigned int spacedim>
-  inline std::pair<Point<spacedim>, Point<spacedim>> &BoundingBox<spacedim>::get_boundary_points()
-  {
-    return this->boundary_points;
-  }
-
-
-
-  template <unsigned int spacedim>
-  inline const std::pair<Point<spacedim>, Point<spacedim>> &BoundingBox<spacedim>::get_boundary_points() const
-  {
-    return this->boundary_points;
-  }
-
-
-
-  template <unsigned int spacedim>
-  inline bool
-  BoundingBox<spacedim>::
-  operator==(const BoundingBox<spacedim> &box) const
-  {
-    return boundary_points == box.boundary_points;
-  }
-
-
-
-  template <unsigned int spacedim>
-  inline bool
-  BoundingBox<spacedim>::
-  operator!=(const BoundingBox<spacedim> &box) const
-  {
-    return boundary_points != box.boundary_points;
-  }
-
-
-
-  template <unsigned int spacedim>
-  inline void
-  BoundingBox<spacedim>::extend(const double amount)
-  {
-    for (unsigned int d = 0; d < spacedim; ++d)
-      {
-        boundary_points.first[d] -= amount;
-        boundary_points.second[d] += amount;
-        WBAssert(boundary_points.first[d] <= boundary_points.second[d],
-                 "Bounding Box can't be shrunk this much: the points' "
-                 "order should remain bottom left, top right.");
-      }
-  }
-
-
-  template <unsigned int spacedim>
-  inline
-  bool
-  BoundingBox<spacedim>::point_inside(const Point<spacedim> &point,
-                                      const double tolerance) const
-  {
-    WBAssert(boundary_points.first.get_coordinate_system() == point.get_coordinate_system(),
-             "Cannot compare two points which represent different coordinate systems.");
-    WBAssert(boundary_points.second.get_coordinate_system() == point.get_coordinate_system(),
-             "Cannot compare two points which represent different coordinate systems.");
-
-    if (point.get_coordinate_system() == CoordinateSystem::spherical)
-      {
-        Point<spacedim> other_point = point;
-        if (spacedim == 2)
-          {
-            other_point[0] += point[0] < 0 ? 2.0 * Consts::PI : -2.0 * Consts::PI;
-          }
-        else
-          {
-            // spacedim == 3 (rad,long,lat)
-            other_point[1] += point[1] < 0 ? 2.0 * Consts::PI : -2.0 * Consts::PI;
-          }
-
-        return (point_inside_implementation(point, tolerance) ||
-                point_inside_implementation(other_point, tolerance));
-      }
-
-    return point_inside_implementation(point, tolerance);
-
-  }
-
-  template <unsigned int spacedim>
-  inline
-  bool
-  BoundingBox<spacedim>::point_inside_implementation(const Point<spacedim> &p,
-                                                     const double tolerance) const
-  {
-    WBAssert(boundary_points.first.get_coordinate_system() == p.get_coordinate_system(),
-             "Cannot compare two points which represent different coordinate systems.");
-    WBAssert(boundary_points.second.get_coordinate_system() == p.get_coordinate_system(),
-             "Cannot compare two points which represent different coordinate systems.");
-
-    for (unsigned int i = 0; i < spacedim; ++i)
-      {
-        // Bottom left-top right convention: the point is outside if it's smaller
-        // than the first or bigger than the second boundary point The bounding
-        // box is defined as a closed set
-        if ((p[i] < this->boundary_points.first[i] -
-             tolerance * std::abs(this->boundary_points.second[i] -
-                                  this->boundary_points.first[i])) ||
-            (p[i] > this->boundary_points.second[i] +
-             tolerance * std::abs(this->boundary_points.second[i] -
-                                  this->boundary_points.first[i])))
-          return false;
-      }
-    return true;
-  }
-
-
-
-  template <unsigned int spacedim>
-  inline
-  void
-  BoundingBox<spacedim>::merge_with(
-    const BoundingBox<spacedim> &other_bbox)
-  {
-    for (unsigned int i = 0; i < spacedim; ++i)
-      {
-        this->boundary_points.first[i] =
-          std::min(this->boundary_points.first[i],
-                   other_bbox.boundary_points.first[i]);
-        this->boundary_points.second[i] =
-          std::max(this->boundary_points.second[i],
-                   other_bbox.boundary_points.second[i]);
-      }
-  }
-
-
-
-  template <unsigned int spacedim>
-  double
-  BoundingBox<spacedim>::volume() const
-  {
-    double vol = 1.0;
-    for (unsigned int i = 0; i < spacedim; ++i)
-      vol *= (this->boundary_points.second[i] - this->boundary_points.first[i]);
-    return vol;
-  }
-
-
-
-  template <unsigned int spacedim>
-  inline
-  double
-  BoundingBox<spacedim>::lower_bound(const unsigned int direction) const
-  {
-    WBAssert(direction, spacedim);
-
-    return boundary_points.first[direction];
-  }
-
-
-
-  template <unsigned int spacedim>
-  inline
-  double
-  BoundingBox<spacedim>::upper_bound(const unsigned int direction) const
-  {
-    WBAssert(direction, spacedim);
-
-    return boundary_points.second[direction];
-  }
-
-
-
-  template <unsigned int spacedim>
-  Point<spacedim>
-  BoundingBox<spacedim>::center() const
-  {
-    Point<spacedim> point = boundary_points.first; // initialize to inherit coordinate system
-    for (unsigned int i = 0; i < spacedim; ++i)
-      point[i] = .5 * (boundary_points.first[i] + boundary_points.second[i]);
-
-    return point;
-  }
-
-
-
-  template <unsigned int spacedim>
-  inline
-  double
-  BoundingBox<spacedim>::side_length(const unsigned int direction) const
-  {
-    WBAssert(direction < spacedim, "Invalid index");
-
-    return boundary_points.second[direction] - boundary_points.first[direction];
-  }
-
-
-#endif // DOXYGEN
-
-}
-
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/consts.h.bak b/contrib/world_builder/include/world_builder/consts.h.bak
deleted file mode 100644
index 56d01f284a5..00000000000
--- a/contrib/world_builder/include/world_builder/consts.h.bak
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_GLOBAL_H
-#define WORLD_BUILDER_GLOBAL_H
-
-#include <limits>
-#include <iostream>
-
-namespace WorldBuilder
-{
-  namespace Consts
-  {
-    constexpr double PI = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066;
-  } // namespace Consts
-
-}
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/coordinate_system.h.bak b/contrib/world_builder/include/world_builder/coordinate_system.h.bak
deleted file mode 100644
index f60195abff5..00000000000
--- a/contrib/world_builder/include/world_builder/coordinate_system.h.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_COORDINATE_SYSTEM_H
-#define WORLD_BUILDER_COORDINATE_SYSTEM_H
-
-namespace WorldBuilder
-{
-  /**
-   * This enum lists available coordinate systems that can be used for the
-   * function variables. Allowed values are 'cartesian', 'spherical'.
-   * 'spherical' coordinates follow: r, phi (2D) or r, phi, theta (3D); where
-   * r is radius, phi is longitude, and theta is the polar angle (colatitude).
-   */
-  enum CoordinateSystem
-  {
-    cartesian,
-    spherical,
-    invalid
-  };
-
-  /**
-   * There are three ways to look at what should happen when the user gives an
-   * angle to go down in a sphere. The first one is the easiest, which is just
-   * to tread the system as a Cartesian system. This means taking the angle
-   * with the surface tangential at the starting point at the surface
-   * everywhere. The advantage is that it is very intuitive and easy to
-   * predict what geometry should be produced. This option is called
-   * 'angle_at_starting_point_with_surface'. The other end member is that
-   * going down with an angle in a sphere should mean that it always goes down
-   * with a constant angle relative to the surface tangential at that
-   * longitude and latitude. This means a the geometry would a a logarithmic
-   * spiral. This option is called 'continuous_angle_with_surface'. Because it
-   * is currently to time consuming to implement this option with all the
-   * required features, there is an option which approximates this behavior,
-   * by using the option 'angle_at_starting_point_with_surface'. This option
-   * uses the surface tangential at the beginning of every segment. This means
-   * that in the limit of segments going to length zero, this option produces
-   * exactly the same geometry as 'continuous_angle_with_surface'.
-   */
-  enum DepthMethod
-  {
-    angle_at_starting_point_with_surface,
-    angle_at_begin_segment_with_surface,
-    angle_at_begin_segment_applied_to_end_segment_with_surface,
-    continuous_angle_with_surface,
-    none
-  };
-} // namespace WorldBuilder
-
-#endif
-
diff --git a/contrib/world_builder/include/world_builder/coordinate_systems/cartesian.h.bak b/contrib/world_builder/include/world_builder/coordinate_systems/cartesian.h.bak
deleted file mode 100644
index cb196e4b8c4..00000000000
--- a/contrib/world_builder/include/world_builder/coordinate_systems/cartesian.h.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_CARTESIAN_H
-#define WORLD_BUILDER_COORDINATE_SYSTEMS_CARTESIAN_H
-
-#include "world_builder/coordinate_systems/interface.h"
-
-namespace WorldBuilder
-{
-
-  namespace CoordinateSystems
-  {
-    /**
-     * Register header file
-     */
-    //WB_REGISTER_COORDINATE_SYSTEM_HEADER(Cartesian)
-
-
-    /**
-     * This implements a Cartesian geometry model.The Cartesian geometry model
-     * doesn't do anything with the coordinates, but is needed to have a common
-     * interface for all the geometry models.
-     */
-    class Cartesian final : public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        Cartesian(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~Cartesian() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-        /**
-         * Returns what the natural coordinate system for this Coordinate System is.
-         */
-        CoordinateSystem natural_coordinate_system() const override final;
-
-        /**
-         * Returns what method should be used to go down with an angle into
-         * the domain.
-         * \sa DepthMethod
-         */
-        DepthMethod depth_method() const override final;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a box
-         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
-         * model it  will be (radius, longitude) in 2d and (radius, longitude,
-         * latitude) in 3d.
-         */
-        std::array<double,3> cartesian_to_natural_coordinates(const std::array<double,3> &position) const override final;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        std::array<double,3> natural_to_cartesian_coordinates(const std::array<double,3> &position) const override final;
-
-
-        /**
-         * Computes the distance between two points which are on the same depth.
-         * The input is two 3d points at that depth. It is implemented as the
-         */
-        double distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const override final;
-
-        /**
-         * Returns the max model depth. This always returns infinity for Cartesian
-         * models.
-         */
-        virtual
-        double max_model_depth() const override final;
-
-      private:
-
-    };
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/coordinate_systems/interface.h.bak b/contrib/world_builder/include/world_builder/coordinate_systems/interface.h.bak
deleted file mode 100644
index d8147fe0d4c..00000000000
--- a/contrib/world_builder/include/world_builder/coordinate_systems/interface.h.bak
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_INTERFACE_H
-#define WORLD_BUILDER_COORDINATE_SYSTEMS_INTERFACE_H
-
-#include "world_builder/coordinate_systems/interface.h"
-
-#include "world_builder/coordinate_system.h"
-#include "world_builder/parameters.h"
-#include "world_builder/types/string.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-
-  namespace CoordinateSystems
-  {
-
-    class ObjectFactory;
-
-    /**
-     * This class is an interface for the specific coordinate systems.
-     */
-    class Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        Interface();
-
-        /**
-         * Destructor
-         */
-        virtual
-        ~Interface();
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm,
-                             const std::string &parent_name,
-                             const std::vector<std::string> &required_entries);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        virtual
-        void parse_entries(Parameters &prm) = 0;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is.
-         */
-        virtual
-        CoordinateSystem natural_coordinate_system() const = 0;
-
-        /**
-         * Returns what method should be used to go down with an angle into
-         * the domain.
-         * \sa DepthMethod
-         */
-        virtual
-        DepthMethod depth_method() const = 0;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a box
-         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
-         * model it  will be (radius, longitude) in 2d and (radius, longitude,
-         * latitude) in 3d.
-         */
-        virtual
-        std::array<double,3> cartesian_to_natural_coordinates(const std::array<double,3> &position) const = 0;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        virtual
-        std::array<double,3> natural_to_cartesian_coordinates(const std::array<double,3> &position) const = 0;
-
-        /**
-         * Computes the distance between two points which are on the same depth.
-         * The input is two 3d points at that depth.
-         */
-        virtual
-        double distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const = 0;
-
-        /**
-         * Returns the max model depth. This should be the infinity for Cartesian
-         * models and the radius in spherical models.
-         */
-        virtual
-        double max_model_depth() const = 0;
-
-        /**
-         * A function to register a new type. This is part of the automatic
-         * registration of the object factory.
-         */
-        static void registerType(const std::string &name,
-                                 void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                 ObjectFactory *factory);
-
-        /**
-         * A function to create a new type. This is part of the automatic
-         * registration of the object factory.
-         */
-        static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-      protected:
-        /**
-         * A pointer to the world class to retrieve variables.
-         */
-        WorldBuilder::World *world;
-
-
-
-      private:
-        static std::map<std::string, ObjectFactory *> &get_factory_map()
-        {
-          static std::map<std::string, ObjectFactory *> factories;
-          return factories;
-        }
-
-        static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-        {
-          static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-          return declares;
-        }
-    };
-
-
-
-    /**
-     * A class to create new objects
-     */
-    class ObjectFactory
-    {
-      public:
-        virtual std::unique_ptr<Interface> create(World *world) = 0;
-    };
-
-    /**
-     * A macro which should be in every derived cpp file to automatically
-     * register it. Because this is a library, we need some extra measures
-     * to ensure that the static variable is actually initialized.
-     */
-#define WB_REGISTER_COORDINATE_SYSTEM(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/coordinate_systems/invalid.h.bak b/contrib/world_builder/include/world_builder/coordinate_systems/invalid.h.bak
deleted file mode 100644
index 481929abdf3..00000000000
--- a/contrib/world_builder/include/world_builder/coordinate_systems/invalid.h.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_INVALID_H
-#define WORLD_BUILDER_COORDINATE_SYSTEMS_INVALID_H
-
-#include "world_builder/coordinate_systems/interface.h"
-#include "world_builder/nan.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace CoordinateSystems
-  {
-    /**
-     * This implements a Invalid geometry model.The Invalid geometry model
-     * doesn't do anything with the coordinates, but is needed to have a common
-     * interface for all the geometry models.
-     */
-    class Invalid final : public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        Invalid(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~Invalid() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-        /**
-         * Returns what the natural coordinate system for this Coordinate System is.
-         */
-        CoordinateSystem natural_coordinate_system() const override final;
-
-        /**
-         * Returns what method should be used to go down with an angle into
-         * the domain.
-         * \sa DepthMethod
-         */
-        DepthMethod depth_method() const override final;
-
-        /**
-         * Takes the Invalid points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a box
-         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
-         * model it  will be (radius, longitude) in 2d and (radius, longitude,
-         * latitude) in 3d.
-         */
-        std::array<double,3> cartesian_to_natural_coordinates(const std::array<double,3> &position) const override final;
-
-        /**
-         * Undoes the action of invalid_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Invalid coordinates.
-         */
-        std::array<double,3> natural_to_cartesian_coordinates(const std::array<double,3> &position) const override final;
-
-
-        /**
-         * Computes the distance between two points which are on the same depth.
-         * The input is two 3d points at that depth. It is implemented as the
-         */
-        double distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const override final;
-
-        /**
-         * Returns the max model depth. This always returns infinity for Invalid
-         * models.
-         */
-        virtual
-        double max_model_depth() const override final;
-
-      private:
-
-    };
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/coordinate_systems/spherical.h.bak b/contrib/world_builder/include/world_builder/coordinate_systems/spherical.h.bak
deleted file mode 100644
index 6fe89645e40..00000000000
--- a/contrib/world_builder/include/world_builder/coordinate_systems/spherical.h.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_SPHERICAL_H
-#define WORLD_BUILDER_COORDINATE_SYSTEMS_SPHERICAL_H
-
-#include "world_builder/coordinate_systems/interface.h"
-
-#include <string>
-
-namespace WorldBuilder
-{
-
-  namespace CoordinateSystems
-  {
-    /**
-     * Register header file
-     */
-    //WB_REGISTER_COORDINATE_SYSTEM_HEADER(Spherical)
-
-    /**
-     * This implements a Spherical geometry model.The Cartesian geometry model
-     * doesn't do anything with the coordinates, but is needed to have a common
-     * interface for all the geometry models.
-     */
-    class Spherical final : public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        Spherical(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~Spherical() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-        /**
-         * Returns what the natural coordinate system for this Coordinate System is.
-         */
-        CoordinateSystem natural_coordinate_system() const override final;
-
-        /**
-         * Returns what method should be used to go down with an angle into
-         * the domain.
-         * \sa DepthMethod
-         */
-        DepthMethod depth_method() const override final;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a box
-         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
-         * model it  will be (radius, longitude) in 2d and (radius, longitude,
-         * latitude) in 3d.
-         */
-        std::array<double,3> cartesian_to_natural_coordinates(const std::array<double,3> &position) const override final;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        std::array<double,3> natural_to_cartesian_coordinates(const std::array<double,3> &position) const override final;
-
-
-        /**
-         * Computes the distance between two points which are on the same depth.
-         * The input is two 2d points at that depth. The distance is returned
-         * in meters. To compute this distance from spherical coordinates the
-         * radius is multiplied with the central angle. The central angle is
-         * compute in the most accurate way given on wikipedia
-         * (https://en.wikipedia.org/wiki/Great-circle_distance), through a
-         * special case of the Vincenty formula for an ellipsoid with equal
-         * major and minor axes (https://doi.org/10.1179/sre.1975.23.176.88).
-         */
-        double distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const override final;
-
-        /**
-         * Returns the max model depth. This returns the radius in spherical
-         * models.
-         */
-        virtual
-        double max_model_depth() const override final;
-
-        /**
-         * What depth method the spherical coordinates use.
-         */
-        DepthMethod used_depth_method;
-
-      private:
-        /**
-         * The maximum depth of the model. In the spherical case that is equal to the
-         * radius of the sphere.
-         */
-        double radius_sphere;
-    };
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/deprecate.h.bak b/contrib/world_builder/include/world_builder/deprecate.h.bak
deleted file mode 100644
index 2c7296ce4db..00000000000
--- a/contrib/world_builder/include/world_builder/deprecate.h.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-// if deprecated is supported, which is definitely C++14, but some compilers support it before C++14.
-// Once the world builder switches to C++14 this can be simplified.
-#if defined(__has_cpp_attribute)
-#if __has_cpp_attribute(deprecated)
-#define DEPRECATED(msg, func) [[deprecated(msg)]] func
-#endif
-#else
-#if defined(__GNUC__) || defined(__clang__)
-#define DEPRECATED(msg, func) func __attribute__ ((deprecated(msg)))
-#elif defined(_MSC_VER)
-#define DEPRECATED(msg, func) __declspec(deprecated(msg)) func
-#endif
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate.h.bak
deleted file mode 100644
index ac3f55111ad..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate.h.bak
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_H
-
-
-#include "world_builder/features/interface.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-  class World;
-
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace ContinentalPlateModels
-
-    /**
-     * This class represents a continental plate and can implement submodules
-     * for temperature and composition. These submodules determine what
-     * the returned temperature or composition of the temperature and composition
-     * functions of this class will be.
-     */
-    class ContinentalPlate final: public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        ContinentalPlate(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~ContinentalPlate() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm,
-                             const std::string &parent_name = "",
-                             const std::vector<std::string> &required_entries = {});
-
-        /**
-         * Produce a JSON snippet for the schema
-         */
-        static
-        void make_snippet(Parameters &prm);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-        /**
-         * Returns different values at a single point in one go stored in a vector of doubles.
-         *
-         * The properties input decides what each entry means, and the output is generated in the
-         * same order as the properties input. The properties input consists of
-         * a 3D array, where the first entry identifies the property and the last two entries
-         * provide extra information about that property.
-         *
-         * Temperature is identified by 1 and no extra information is needed. So temperature
-         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
-         * vector.
-         *
-         * Composition is identified by 2. This produces one
-         * value in the output. The second entry  identifies the composition number and the third
-         * number is not used. So a commposition query asking about composition 1 looks like this:
-         * {2,1,0}. A composition query prodoces one entry in the output vector.
-         *
-         * Grains are identified by 2. The second entry is the grain composition number and the third
-         * entry is the number of grains. A query about the grains, where it asks about composition 1
-         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
-         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
-         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
-         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
-         *
-         * The entries in output variable relates the index of the property to the index in the output.
-         */
-        void
-        properties(const Point<3> &position_in_cartesian_coordinates,
-                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                   const double depth,
-                   const std::vector<std::array<unsigned int,3>> &properties,
-                   const double gravity,
-                   const std::vector<size_t> &entry_in_output,
-                   std::vector<double> &output) const override final;
-
-      private:
-        /**
-         * A vector containing all the pointers to the temperature models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::ContinentalPlateModels::Temperature::Interface> > temperature_models;
-
-        /**
-         * A vector containing all the pointers to the composition models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::ContinentalPlateModels::Composition::Interface> > composition_models;
-
-        /**
-         * A vector containing all the pointers to the grains models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::ContinentalPlateModels::Grains::Interface> > grains_models;
-
-
-        double min_depth;
-        Objects::Surface min_depth_surface;
-        double max_depth;
-        Objects::Surface max_depth_surface;
-
-    };
-
-
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/interface.h.bak
deleted file mode 100644
index 61e34188168..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/interface.h.bak
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_INTERFACE_H
-
-
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-namespace WorldBuilder
-{
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace ContinentalPlateModels
-    {
-      namespace Composition
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
-
-
-            /**
-             * takes composition and position and returns a composition.
-             */
-            virtual
-            double get_composition(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_CONTINENTAL_PLATE_COMPOSITION_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Composition
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/random.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/random.h.bak
deleted file mode 100644
index 5d7a9f40110..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/random.h.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_RANDOM_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_RANDOM_H
-
-
-#include "world_builder/features/continental_plate_models/composition/interface.h"
-#include "world_builder/objects/surface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace ContinentalPlateModels
-    {
-      namespace Composition
-      {
-        /**
-         * This class represents a continental plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Random final : public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Random(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Random() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a composition based on the given position, depth in the model,
-             * gravity and current composition.
-             */
-            double get_composition(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // Random composition submodule parameters
-
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> compositions;
-            std::vector<double> min_value;
-            std::vector<double> max_value;
-            Operations operation;
-
-        };
-      } // namespace Composition
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/uniform.h.bak
deleted file mode 100644
index f6540cf8227..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/composition/uniform.h.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_COMPOSITION_UNIFORM_H
-
-
-#include "world_builder/features/continental_plate_models/composition/interface.h"
-#include "world_builder/objects/surface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace ContinentalPlateModels
-    {
-      namespace Composition
-      {
-        /**
-         * This class represents a continental plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final : public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a composition based on the given position, depth in the model,
-             * gravity and current composition.
-             */
-            double get_composition(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // uniform composition submodule parameters
-
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> compositions;
-            std::vector<double> fractions;
-            Operations operation;
-
-        };
-      } // namespace Composition
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/interface.h.bak
deleted file mode 100644
index 20693855c07..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/interface.h.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_INTERFACE_H
-
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace ContinentalPlateModels
-    {
-      namespace Grains
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
-
-
-            /**
-             * takes composition and position and returns grains.
-             */
-            virtual
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_CONTINENTAL_PLATE_GRAINS_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      virtual std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Grains
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution.h.bak
deleted file mode 100644
index dfa20197d28..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution.h.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-
-
-#include "world_builder/features/continental_plate_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a continental plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistribution final : public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistribution(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistribution() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-        };
-      } // namespace Grains
-    }   // namespace ContinentalPlateModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h.bak
deleted file mode 100644
index 4e8cf717326..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-
-
-#include "world_builder/features/continental_plate_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a continental plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistributionDeflected final : public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistributionDeflected(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistributionDeflected() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-            std::vector<double> deflections;
-        };
-      } // namespace Grains
-    }   // namespace ContinentalPlateModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/uniform.h.bak
deleted file mode 100644
index 6a054a9506e..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/grains/uniform.h.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_GRAINS_UNIFORM_H
-
-
-#include "world_builder/features/continental_plate_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a continental plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class Uniform final : public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
-            std::vector<double> grain_sizes;
-        };
-      } // namespace Grains
-    }   // namespace ContinentalPlateModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/adiabatic.h.bak
deleted file mode 100644
index d8be4739f71..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/adiabatic.h.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
-
-
-#include "world_builder/features/continental_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace ContinentalPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a continental plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Adiabatic final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Adiabatic(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Adiabatic() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // adiabatic temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            /**
-             * Todo
-             */
-            double potential_mantle_temperature;
-
-
-            /**
-             * Todo
-             */
-            double thermal_expansion_coefficient;
-
-            /**
-             * Todo
-             */
-            double specific_heat;
-
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/interface.h.bak
deleted file mode 100644
index 4bc2b1bac40..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/interface.h.bak
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_INTERFACE_H
-
-
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace ContinentalPlateModels
-    {
-      namespace Temperature
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
-
-
-            /**
-             * takes temperature and position and returns a temperature.
-             */
-            virtual
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            /**
-             * The name of the feature type.
-             */
-            std::string name;
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_CONTINENTAL_PLATE_TEMPERATURE_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Temperature
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/linear.h.bak
deleted file mode 100644
index 07a2a022ed6..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/linear.h.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_LINEAR_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_LINEAR_H
-
-
-#include "world_builder/features/continental_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace ContinentalPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a continental plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Linear final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Linear(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Linear() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // linear temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            double top_temperature;
-            double bottom_temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/uniform.h.bak
deleted file mode 100644
index bb70e04a21e..00000000000
--- a/contrib/world_builder/include/world_builder/features/continental_plate_models/temperature/uniform.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_CONTINENTAL_PLATE_MODELS_TEMPERATURE_UNIFORM_H
-
-
-#include "world_builder/features/continental_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace ContinentalPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a continental plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // uniform temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            double temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault.h.bak b/contrib/world_builder/include/world_builder/features/fault.h.bak
deleted file mode 100644
index f8e98d11242..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault.h.bak
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_H
-#define WORLD_BUILDER_FEATURES_FAULT_H
-
-
-#include "world_builder/features/fault_models/composition/interface.h"
-#include "world_builder/features/fault_models/grains/interface.h"
-#include "world_builder/features/fault_models/temperature/interface.h"
-#include "world_builder/objects/segment.h"
-#include "world_builder/bounding_box.h"
-#include "world_builder/objects/distance_from_surface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-  class World;
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace FaultModels
-
-    /**
-     * This class represents a fault and can implement submodules
-     * for temperature and composition. These submodules determine what
-     * the returned temperature or composition of the temperature and composition
-     * functions of this class will be.
-     */
-    class Fault final: public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        Fault(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~Fault() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm,
-                             const std::string &parent_name = "",
-                             const std::vector<std::string> &required_entries = {});
-
-        /**
-         * Produce a JSON snippet for the schema
-         */
-        static
-        void make_snippet(Parameters &prm);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-        /**
-         * Computes the bounding points for a BoundingBox object using two extreme points in all the surface
-         * coordinates and an additional buffer zone that accounts for the fault thickness and length. The first and second
-         * points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
-         * documentation in include/bounding_box.h).
-         * For the spherical system, the buffer zone along the longitudal direction is calculated using the
-         * corresponding latitude points.
-         */
-        const BoundingBox<2>  &get_surface_bounding_box () const;
-
-        /**
-         * Returns different values at a single point in one go stored in a vector of doubles.
-         *
-         * The properties input decides what each entry means, and the output is generated in the
-         * same order as the properties input. The properties input consists of
-         * a 3D array, where the first entry identifies the property and the last two entries
-         * provide extra information about that property.
-         *
-         * Temperature is identified by 1 and no extra information is needed. So temperature
-         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
-         * vector.
-         *
-         * Composition is identified by 2. This produces one
-         * value in the output. The second entry  identifies the composition number and the third
-         * number is not used. So a commposition query asking about composition 1 looks like this:
-         * {2,1,0}. A composition query prodoces one entry in the output vector.
-         *
-         * Grains are identified by 2. The second entry is the grain composition number and the third
-         * entry is the number of grains. A query about the grains, where it asks about composition 1
-         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
-         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
-         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
-         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
-         *
-         * The entries in output variable relates the index of the property to the index in the output.
-         */
-        void
-        properties(const Point<3> &position_in_cartesian_coordinates,
-                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                   const double depth,
-                   const std::vector<std::array<unsigned int,3>> &properties,
-                   const double gravity,
-                   const std::vector<size_t> &entry_in_output,
-                   std::vector<double> &output) const override final;
-
-        /**
-        * Returns a PlaneDistances object that has the distance from and along a fault plane,
-        * calculated from the coordinates and the depth of the point.
-        */
-        Objects::PlaneDistances
-        distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
-                                  const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                  const double depth) const override;
-
-      private:
-        std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> > default_temperature_models;
-        std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface>  > default_composition_models;
-        std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface>  > default_grains_models;
-
-        std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
-            Features::FaultModels::Composition::Interface,
-            Features::FaultModels::Grains::Interface> > default_segment_vector;
-
-        std::vector< std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
-            Features::FaultModels::Composition::Interface,
-            Features::FaultModels::Grains::Interface> > > sections_segment_vector;
-
-        // This vector stores segments to this coordinate/section.
-        //First used (raw) pointers to the segment relevant to this coordinate/section,
-        // but I do not trust it won't fail when memory is moved. So storing the all the data now.
-        std::vector<std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
-            Features::FaultModels::Composition::Interface,
-            Features::FaultModels::Grains::Interface> > > segment_vector;
-
-        // todo: the memory of this can be greatly improved by
-        // or using a plugin system for the submodules, or
-        // putting the variables in a union. Although the memory
-        // used by this program is in real cases expected to be
-        // insignificant compared to what a calling program may
-        // use, a smaller amount of memory used in here, could
-        // theoretically speed up the computation, because more
-        // relevant data could be stored in the cache. But this
-        // not a urgent problem, and would require testing.
-
-        /**
-         * This variable stores the depth at which the fault
-         * starts. It makes this depth effectively the surface
-         * of the model for the fault.
-         */
-        double starting_depth;
-
-        /**
-         * The depth which below the fault may no longer
-         * be present. This can not only help setting up models with
-         * less effort, but can also improve performance, because
-         * the algorithm doesn't have to search in locations below
-         * this depth.
-         */
-        double maximum_depth;
-
-        /**
-         * Computee bounding points for a BoundingBox object using two extreme points in all the surface
-         * coordinates and an additional buffer zone that accounts for the fault thickness and length. The first and second
-         * points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
-         * documentation in include/bounding_box.h).
-         * For the spherical system, the buffer zone along the longitudal direction is calculated using the
-         * corresponding latitude points.
-         */
-        BoundingBox<2> surface_bounding_box;
-
-        /**
-         * A point on the surface to which the fault dips.
-         */
-        WorldBuilder::Point<2> reference_point;
-
-        std::vector<std::vector<double> > fault_segment_lengths;
-        std::vector<std::vector<Point<2> > > fault_segment_thickness;
-        std::vector<std::vector<Point<2> > > fault_segment_top_truncation;
-        std::vector<std::vector<Point<2> > > fault_segment_angles;
-        std::vector<double> total_fault_length;
-        double maximum_total_fault_length;
-        double maximum_fault_thickness;
-
-        double min_along_x;
-        double max_along_x;
-        double min_along_y;
-        double max_along_y;
-        double min_lat_cos_inv;
-        double max_lat_cos_inv;
-        double buffer_around_fault_cartesian;
-
-    };
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/composition/interface.h.bak
deleted file mode 100644
index 379f23198e7..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/composition/interface.h.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_COMPOSITION_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_COMPOSITION_INTERFACE_H
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/utilities.h"
-#include "world_builder/features/feature_utilities.h"
-
-#include <map>
-#include <vector>
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as oceanic plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm) = 0;
-
-
-            /**
-             * takes composition and position and returns a composition.
-             */
-            virtual
-            double get_composition(const Point<3> &position,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_FAULT_COMPOSITION_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Composition
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/composition/smooth.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/composition/smooth.h.bak
deleted file mode 100644
index cf2797297a9..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/composition/smooth.h.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef _world_builder_features_fault_composition_smooth_h
-#define _world_builder_features_fault_composition_smooth_h
-
-#include <world_builder/features/fault_models/composition/interface.h>
-#include <world_builder/features/feature_utilities.h>
-#include <world_builder/world.h>
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Smooth: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Smooth(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Smooth();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a composition based on the given position, depth in the model,
-             * and current composition.
-             */
-            double get_composition(const Point<3> &position,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-          private:
-            // linear temperature submodule parameters
-            double min_distance;
-            double side_distance;
-            std::vector<double> center_fraction;
-            // currently not using the side composition, but maybe useful if you want another composition towards the end
-            std::vector<double> side_fraction;
-            std::vector<unsigned int> compositions;
-            Operations operation;
-
-        };
-      }
-    }
-  }
-}
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/composition/uniform.h.bak
deleted file mode 100644
index d4cf27758c6..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/composition/uniform.h.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_COMPOSITION_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_COMPOSITION_UNIFORM_H
-
-
-#include "world_builder/features/fault_models/composition/interface.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a composition based on the given position, depth in the model,
-             * gravity and current composition.
-             */
-            double get_composition(const Point<3> &position,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-
-          private:
-            // uniform composition submodule parameters
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> compositions;
-            std::vector<double> fractions;
-            Operations operation;
-
-        };
-      } // namespace Composition
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/grains/interface.h.bak
deleted file mode 100644
index 64fc61674bb..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/grains/interface.h.bak
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_INTERFACE_H
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/utilities.h"
-#include "world_builder/features/feature_utilities.h"
-
-#include <map>
-#include <vector>
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as oceanic plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace FaultModels
-    {
-      namespace Grains
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm) = 0;
-
-
-            /**
-             * takes composition and position and returns a composition.
-             */
-            virtual
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth,
-                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                       const AdditionalParameters &additional_parameters) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_FAULT_GRAINS_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      virtual std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Grains
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution.h.bak
deleted file mode 100644
index 67712d21156..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution.h.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-
-
-#include "world_builder/features/fault_models/grains/interface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace FaultModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a continental plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistribution final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistribution(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistribution() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth,
-                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                       const AdditionalParameters &additional_parameters) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-        };
-      } // namespace Grains
-    }   // namespace FaultModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h.bak
deleted file mode 100644
index 82d2c683f07..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-
-
-#include "world_builder/features/fault_models/grains/interface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace FaultModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a fault and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistributionDeflected final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistributionDeflected(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistributionDeflected() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth,
-                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                       const AdditionalParameters &additional_parameters) const override final;
-
-          private:
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-            std::vector<double> deflections;
-        };
-      } // namespace Grains
-    }   // namespace FaultModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/grains/uniform.h.bak
deleted file mode 100644
index d56b49a9ecf..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/grains/uniform.h.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_GRAINS_UNIFORM_H
-
-
-#include "world_builder/features/fault_models/grains/interface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a oceanic plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth,
-                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                       const AdditionalParameters &additional_parameters) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
-            std::vector<double> grain_sizes;
-        };
-      } // namespace Grains
-    }   // namespace FaultModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/temperature/adiabatic.h.bak
deleted file mode 100644
index 0cf1e7a4686..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/temperature/adiabatic.h.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_ADIABATIC_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_ADIABATIC_H
-
-
-#include "world_builder/features/fault_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Adiabatic final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Adiabatic(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Adiabatic() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-
-          private:
-            // adiabatic temperature submodule parameters
-            double min_depth;
-            double max_depth;
-            /**
-             * Todo
-             */
-            double potential_mantle_temperature;
-
-
-            /**
-             * Todo
-             */
-            double thermal_expansion_coefficient;
-
-            /**
-             * Todo
-             */
-            double specific_heat;
-
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/temperature/interface.h.bak
deleted file mode 100644
index 57a74886f30..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/temperature/interface.h.bak
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_INTERFACE_H
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/utilities.h"
-#include "world_builder/features/feature_utilities.h"
-
-#include <map>
-#include <vector>
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as oceanic plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace FaultModels
-    {
-      namespace Temperature
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm) = 0;
-
-
-            /**
-             * takes temperature and position and returns a temperature.
-             */
-            virtual
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            /**
-             * The name of the feature type.
-             */
-            std::string name;
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_FAULT_TEMPERATURE_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Temperature
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/temperature/linear.h.bak
deleted file mode 100644
index d70b8c57c15..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/temperature/linear.h.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_LINEAR_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_LINEAR_H
-
-
-#include "world_builder/features/fault_models/temperature/interface.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Linear final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Linear(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Linear() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-
-          private:
-            // linear temperature submodule parameters
-            double min_depth;
-            double max_depth;
-            double center_temperature;
-            double side_temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/fault_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/fault_models/temperature/uniform.h.bak
deleted file mode 100644
index 2b42e9faa4d..00000000000
--- a/contrib/world_builder/include/world_builder/features/fault_models/temperature/uniform.h.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_FAULT_MODELS_TEMPERATURE_UNIFORM_H
-
-
-#include "world_builder/features/fault_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-
-          private:
-            // uniform temperature submodule parameters
-            double min_depth;
-            double max_depth;
-            double temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/feature_utilities.h.bak b/contrib/world_builder/include/world_builder/features/feature_utilities.h.bak
deleted file mode 100644
index 997eed98995..00000000000
--- a/contrib/world_builder/include/world_builder/features/feature_utilities.h.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef WORLD_BUILDER_FEATURES_FEATURE_UTILITIES_H
-#define WORLD_BUILDER_FEATURES_FEATURE_UTILITIES_H
-
-#include <limits>
-#include <vector>
-
-#include "world_builder/assert.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace FeatureUtilities
-    {
-      enum class Operations
-      {
-        REPLACE,ADD,SUBTRACT,REPLACE_DEFINED_ONLY
-      };
-
-      /**
-       * transforms string operations into enums.
-       */
-      Operations
-      string_operations_to_enum(const std::string &operation);
-
-
-      /**
-       * Applies different operations such as replace, add and subtract to the original values
-       */
-      inline double
-      apply_operation(const Operations operation,
-                      const double old_value,
-                      const double new_value)
-      {
-        switch (operation)
-          {
-            case Operations::REPLACE:
-            case Operations::REPLACE_DEFINED_ONLY:
-              return new_value;
-              break;
-
-            case Operations::ADD:
-              return old_value + new_value;
-              break;
-
-            case Operations::SUBTRACT:
-              return old_value - new_value;
-
-            default:
-              WBAssert(false,"Operation not found.");
-          }
-
-        return std::numeric_limits<double>::signaling_NaN();
-      }
-
-      /**
-       * A struct that is used to hold additional values based on the output of
-       *  the function distance_point_from_curved_planes().
-       */
-      struct AdditionalParameters
-      {
-        // The total length of all the segments at the location of the plane.
-        double total_local_segment_length;
-
-        // The local thickness of the segment at the location of the plane.
-        double local_thickness;
-      };
-
-
-      /**
-       * Add a string to a vector of strings, if the exact string isn't already
-       * in the vector. Returns the location of the string in the final vector.
-       */
-      size_t
-      add_vector_unique(std::vector<std::string> &vector,const std::string &add_string);
-
-    } // namespace Utilities
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/interface.h.bak b/contrib/world_builder/include/world_builder/features/interface.h.bak
deleted file mode 100644
index a23a45c7592..00000000000
--- a/contrib/world_builder/include/world_builder/features/interface.h.bak
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_INTERFACE_H
-
-
-#include "world_builder/grains.h"
-#include "world_builder/utilities.h"
-#include "world_builder/objects/distance_from_surface.h"
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-
-
-  namespace Features
-  {
-    class ObjectFactory;
-
-    /**
-     * This class is an interface for the specific plate tectonic feature classes,
-     * such as continental plate, oceanic plate and subduction zone.
-     */
-    class Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        Interface();
-
-        /**
-         * Destructor
-         */
-        virtual
-        ~Interface();
-
-        /**
-         * helper function to parse coordinates.
-         */
-        void
-        get_coordinates(const std::string &name,
-                        Parameters &prm,
-                        const CoordinateSystem coordinate_system);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm,
-                             const std::string &parent_name,
-                             const std::vector<std::string> &required_entries);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        virtual
-        void parse_entries(Parameters &prm) = 0;
-
-
-        /**
-         * takes a set of properties and a position and return a new set of properties
-         */
-        virtual
-        void properties(const Point<3> &position_in_cartesian_coordinates,
-                        const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                        const double depth,
-                        const std::vector<std::array<unsigned int,3>> &properties,
-                        const double gravity,
-                        const std::vector<size_t> &entry_in_output,
-                        std::vector<double> &output) const = 0;
-
-        /**
-         * A function to register a new type. This is part of the automatic
-         * registration of the object factory.
-         */
-        static void registerType(const std::string &name,
-                                 void ( * /*declare_entries*/)(Parameters &, const std::string &, const std::vector<std::string> &required_entries),
-                                 void ( *make_snippet)(Parameters &),
-                                 ObjectFactory *factory);
-
-        std::string get_name() const
-        {
-          return name;
-        };
-
-
-        /**
-         * A function to create a new type. This is part of the automatic
-         * registration of the object factory.
-         */
-        static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-        /**
-        * Returns a PlaneDistances object that has the distance from and along a feature plane,
-        * calculated from the coordinates and the depth of the point.
-        */
-        virtual
-        Objects::PlaneDistances
-        distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
-                                  const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                  const double depth) const;
-
-
-      protected:
-        /**
-         * A pointer to the world class to retrieve variables.
-         */
-        WorldBuilder::World *world;
-
-        /**
-         * The name of the feature type.
-         */
-        std::string name;
-
-        /**
-         * The index of the tag for this feature.
-         * This corresponds to the index in the feature_tags variable which is store in the World.
-         */
-        size_t tag_index;
-
-        /**
-         * The type of interpolation used to get the line position between the points.
-         */
-        WorldBuilder::Utilities::InterpolationType interpolation_type;
-
-        /**
-         * number of original coordinates, before adding
-         * more automatically.
-         */
-        std::size_t original_number_of_coordinates;
-
-        /**
-         * The coordinates at the surface of the feature
-         */
-        std::vector<Point<2> > coordinates;
-
-        /**
-         * The x and y spline
-         */
-        WorldBuilder::Objects::BezierCurve bezier_curve;
-
-
-        /**
-         * The name of the temperature submodule used by this feature.
-         */
-        std::string temperature_submodule_name;
-
-        /**
-         * The name of the composition submodule used by this feature.
-         */
-        std::string composition_submodule_name;
-
-
-      private:
-        static std::map<std::string, ObjectFactory *> &get_factory_map()
-        {
-          static std::map<std::string, ObjectFactory *> factories;
-          return factories;
-        }
-
-        static std::map<std::string, void ( *)(Parameters &,
-                                               const std::string &,
-                                               const std::vector<std::string>& required_entries)> &get_declare_map()
-        {
-          static std::map<std::string, void ( *)(Parameters &,
-                                                 const std::string &,
-                                                 const std::vector<std::string>& required_entries)> declares;
-          return declares;
-        }
-
-        static std::map<std::string, void ( *)(Parameters &)> &get_snippet_map()
-        {
-          static std::map<std::string, void ( *)(Parameters &)> declares;
-          return declares;
-        }
-    };
-
-
-    /**
-     * A class to create new objects
-     */
-    class ObjectFactory
-    {
-      public:
-        virtual std::unique_ptr<Interface> create(World *world) = 0;
-    };
-
-    /**
-     * A macro which should be in every derived cpp file to automatically
-     * register it. Because this is a library, we need some extra measures
-     * to ensure that the static variable is actually initialized.
-     */
-#define WB_REGISTER_FEATURE(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, klass::make_snippet, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer.h.bak
deleted file mode 100644
index 39785617f47..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer.h.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_H
-
-
-#include "world_builder/features/interface.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-  class World;
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace MantleLayerModels
-
-    /**
-     * This class represents a mantle layer and can implement submodules
-     * for temperature and composition. These submodules determine what
-     * the returned temperature or composition of the temperature and composition
-     * functions of this class will be.
-     */
-    class MantleLayer final: public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        MantleLayer(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~MantleLayer() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm,
-                             const std::string &parent_name = "",
-                             const std::vector<std::string> &required_entries = {});
-
-        /**
-         * Produce a JSON snippet for the schema
-         */
-        static
-        void make_snippet(Parameters &prm);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-        /**
-         * Returns different values at a single point in one go stored in a vector of doubles.
-         *
-         * The properties input decides what each entry means, and the output is generated in the
-         * same order as the properties input. The properties input consists of
-         * a 3D array, where the first entry identifies the property and the last two entries
-         * provide extra information about that property.
-         *
-         * Temperature is identified by 1 and no extra information is needed. So temperature
-         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
-         * vector.
-         *
-         * Composition is identified by 2. This produces one
-         * value in the output. The second entry  identifies the composition number and the third
-         * number is not used. So a commposition query asking about composition 1 looks like this:
-         * {2,1,0}. A composition query prodoces one entry in the output vector.
-         *
-         * Grains are identified by 2. The second entry is the grain composition number and the third
-         * entry is the number of grains. A query about the grains, where it asks about composition 1
-         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
-         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
-         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
-         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
-         *
-         * The entries in output variable relates the index of the property to the index in the output.
-         */
-        void
-        properties(const Point<3> &position_in_cartesian_coordinates,
-                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                   const double depth,
-                   const std::vector<std::array<unsigned int,3>> &properties,
-                   const double gravity,
-                   const std::vector<size_t> &entry_in_output,
-                   std::vector<double> &output) const override final;
-
-      private:
-        /**
-         * A vector containing all the pointers to the temperature models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::MantleLayerModels::Temperature::Interface> > temperature_models;
-
-        /**
-         * A vector containing all the pointers to the composition models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::MantleLayerModels::Composition::Interface> > composition_models;
-
-        /**
-         * A vector containing all the pointers to the grains models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::MantleLayerModels::Grains::Interface> > grains_models;
-
-        double min_depth;
-        Objects::Surface min_depth_surface;
-        double max_depth;
-        Objects::Surface max_depth_surface;
-
-    };
-
-
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/interface.h.bak
deleted file mode 100644
index 280cc7471bf..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/interface.h.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_COMPOSITION_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_COMPOSITION_INTERFACE_H
-
-
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace MantleLayerModels
-    {
-      namespace Composition
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
-
-
-            /**
-             * takes composition and position and returns a composition.
-             */
-            virtual
-            double get_composition(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_MANTLE_LAYER_COMPOSITION_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Composition
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/uniform.h.bak
deleted file mode 100644
index 247125db618..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/composition/uniform.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_COMPOSITION_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_COMPOSITION_UNIFORM_H
-
-
-#include "world_builder/features/mantle_layer_models/composition/interface.h"
-#include "world_builder/objects/surface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace MantleLayerModels
-    {
-      namespace Composition
-      {
-        /**
-         * This class represents a mantle layer and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a composition based on the given position, depth in the model,
-             * gravity and current composition.
-             */
-            double get_composition(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // uniform composition submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> compositions;
-            std::vector<double> fractions;
-            Operations operation;
-
-        };
-      } // namespace Composition
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/interface.h.bak
deleted file mode 100644
index 3d86a58fb16..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/interface.h.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_INTERFACE_H
-
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace MantleLayerModels
-    {
-      namespace Grains
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
-
-
-            /**
-             * takes composition and position and returns grains.
-             */
-            virtual
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_MANTLE_LAYER_GRAINS_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      virtual std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Grains
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h.bak
deleted file mode 100644
index ac8476e3742..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-
-
-#include "world_builder/features/mantle_layer_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a continental plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistribution final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistribution(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistribution() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-        };
-      } // namespace Grains
-    }   // namespace MantleLayerModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h.bak
deleted file mode 100644
index 4d0bd807be8..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-
-
-#include "world_builder/features/mantle_layer_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a mantle layer and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistributionDeflected final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistributionDeflected(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistributionDeflected() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-            std::vector<double> deflections;
-        };
-      } // namespace Grains
-    }   // namespace MantleLayerModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/uniform.h.bak
deleted file mode 100644
index 60b8cd87b96..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/grains/uniform.h.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_GRAINS_UNIFORM_H
-
-
-#include "world_builder/features/mantle_layer_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a oceanic plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
-            std::vector<double> grain_sizes;
-        };
-      } // namespace Grains
-    } // namespace MantleLayerModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/adiabatic.h.bak
deleted file mode 100644
index e281a0510e2..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/adiabatic.h.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_ADIABATIC_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_ADIABATIC_H
-
-
-#include "world_builder/features/mantle_layer_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace MantleLayerModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a mantle layer and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Adiabatic final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Adiabatic(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Adiabatic() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // adiabatic temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            /**
-             * Todo
-             */
-            double potential_mantle_temperature;
-
-
-            /**
-             * Todo
-             */
-            double thermal_expansion_coefficient;
-
-            /**
-             * Todo
-             */
-            double specific_heat;
-
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/interface.h.bak
deleted file mode 100644
index cc4dc67b6bd..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/interface.h.bak
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_INTERFACE_H
-
-
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace MantleLayerModels
-    {
-      namespace Temperature
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
-
-
-            /**
-             * takes temperature and position and returns a temperature.
-             */
-            virtual
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            /**
-             * The name of the feature type.
-             */
-            std::string name;
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_MANTLE_LAYER_TEMPERATURE_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Temperature
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/linear.h.bak
deleted file mode 100644
index df29e574412..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/linear.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_LINEAR_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_LINEAR_H
-
-
-#include "world_builder/features/mantle_layer_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace MantleLayerModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a mantle layer and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Linear final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Linear(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Linear() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // linear temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            double top_temperature;
-            double bottom_temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/uniform.h.bak
deleted file mode 100644
index beb7a69d9ab..00000000000
--- a/contrib/world_builder/include/world_builder/features/mantle_layer_models/temperature/uniform.h.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_MANTLE_LAYER_MODELS_TEMPERATURE_UNIFORM_H
-
-
-#include "world_builder/features/mantle_layer_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace MantleLayerModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a mantle layer and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // uniform temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            double temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate.h.bak
deleted file mode 100644
index 50ec29c9c66..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate.h.bak
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_H
-
-
-#include "world_builder/features/interface.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-  class World;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace OceanicPlateModels
-
-    /**
-     * This class represents a oceanic plate and can implement submodules
-     * for temperature and composition. These submodules determine what
-     * the returned temperature or composition of the temperature and composition
-     * functions of this class will be.
-     */
-    class OceanicPlate final: public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        OceanicPlate(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~OceanicPlate() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm,
-                             const std::string &parent_name = "",
-                             const std::vector<std::string> &required_entries = {});
-
-        /**
-         * Produce a JSON snippet for the schema
-         */
-        static
-        void make_snippet(Parameters &prm);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-        /**
-         * Returns different values at a single point in one go stored in a vector of doubles.
-         *
-         * The properties input decides what each entry means, and the output is generated in the
-         * same order as the properties input. The properties input consists of
-         * a 3D array, where the first entry identifies the property and the last two entries
-         * provide extra information about that property.
-         *
-         * Temperature is identified by 1 and no extra information is needed. So temperature
-         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
-         * vector.
-         *
-         * Composition is identified by 2. This produces one
-         * value in the output. The second entry  identifies the composition number and the third
-         * number is not used. So a commposition query asking about composition 1 looks like this:
-         * {2,1,0}. A composition query prodoces one entry in the output vector.
-         *
-         * Grains are identified by 2. The second entry is the grain composition number and the third
-         * entry is the number of grains. A query about the grains, where it asks about composition 1
-         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
-         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
-         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
-         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
-         *
-         * The entries in output variable relates the index of the property to the index in the output.
-         */
-        void
-        properties(const Point<3> &position_in_cartesian_coordinates,
-                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                   const double depth,
-                   const std::vector<std::array<unsigned int,3>> &properties,
-                   const double gravity,
-                   const std::vector<size_t> &entry_in_output,
-                   std::vector<double> &output) const override final;
-
-      private:
-        /**
-         * A vector containing all the pointers to the temperature models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::OceanicPlateModels::Temperature::Interface> > temperature_models;
-
-        /**
-         * A vector containing all the pointers to the composition models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::OceanicPlateModels::Composition::Interface> > composition_models;
-
-        /**
-         * A vector containing all the pointers to the grains models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::OceanicPlateModels::Grains::Interface> > grains_models;
-
-        double min_depth;
-        Objects::Surface min_depth_surface;
-        double max_depth;
-        Objects::Surface max_depth_surface;
-    };
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/interface.h.bak
deleted file mode 100644
index afb2cdf25f4..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/interface.h.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_COMPOSITION_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_COMPOSITION_INTERFACE_H
-
-
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as oceanic plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace OceanicPlateModels
-    {
-      namespace Composition
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
-
-
-            /**
-             * takes composition and position and returns a composition.
-             */
-            virtual
-            double get_composition(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_OCEANIC_PLATE_COMPOSITION_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Composition
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/uniform.h.bak
deleted file mode 100644
index d4ffad6943f..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/composition/uniform.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_COMPOSITION_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_COMPOSITION_UNIFORM_H
-
-
-#include "world_builder/features/oceanic_plate_models/composition/interface.h"
-#include "world_builder/objects/surface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace OceanicPlateModels
-    {
-      namespace Composition
-      {
-        /**
-         * This class represents a oceanic plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a composition based on the given position, depth in the model,
-             * gravity and current composition.
-             */
-            double get_composition(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // uniform composition submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> compositions;
-            std::vector<double> fractions;
-            Operations operation;
-
-        };
-      } // namespace Composition
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/interface.h.bak
deleted file mode 100644
index 33cb8afaf05..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/interface.h.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_INTERFACE_H
-
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as oceanic plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace OceanicPlateModels
-    {
-      namespace Grains
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
-
-
-            /**
-             * takes composition and position and returns grains.
-             */
-            virtual
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_OCEANIC_PLATE_GRAINS_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      virtual std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Grains
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h.bak
deleted file mode 100644
index 6b9604d0f2c..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-
-
-#include "world_builder/features/oceanic_plate_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a continental plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistribution final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistribution(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistribution() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-        };
-      } // namespace Grains
-    }   // namespace OceanicPlateModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h.bak
deleted file mode 100644
index 4a80945817d..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-
-
-#include "world_builder/features/oceanic_plate_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a continental plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistributionDeflected final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistributionDeflected(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistributionDeflected() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-            std::vector<double> deflections;
-        };
-      } // namespace Grains
-    }   // namespace OceanicPlateModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/uniform.h.bak
deleted file mode 100644
index ba08f845e69..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/grains/uniform.h.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_GRAINS_UNIFORM_H
-
-
-#include "world_builder/features/oceanic_plate_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a oceanic plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
-            std::vector<double> grain_sizes;
-        };
-      } // namespace Grains
-    }   // namespace OceanicPlateModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/adiabatic.h.bak
deleted file mode 100644
index 9147f3b99fb..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/adiabatic.h.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
-
-
-#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a oceanic plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Adiabatic final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Adiabatic(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Adiabatic() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // adiabatic temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            /**
-             * Todo
-             */
-            double potential_mantle_temperature;
-
-
-            /**
-             * Todo
-             */
-            double thermal_expansion_coefficient;
-
-            /**
-             * Todo
-             */
-            double specific_heat;
-
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/half_space_model.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/half_space_model.h.bak
deleted file mode 100644
index 967134ec5c9..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/half_space_model.h.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_HALF_SPACE_MODEL_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_HALF_SPACE_MODEL_H
-
-
-#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-  class World;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a oceanic plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class HalfSpaceModel final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            HalfSpaceModel(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~HalfSpaceModel() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-          private:
-            // plate model temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            double top_temperature;
-            double bottom_temperature;
-            std::pair<std::vector<double>,std::vector<double>> spreading_velocities;
-            std::vector<std::vector<Point<2> > > mid_oceanic_ridges;
-            std::vector<std::vector<double>> spreading_velocities_at_each_ridge_point;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/interface.h.bak
deleted file mode 100644
index 5239b8570b5..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/interface.h.bak
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_INTERFACE_H
-
-
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as oceanic plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) = 0;
-
-
-            /**
-             * takes temperature and position and returns a temperature.
-             */
-            virtual
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            /**
-             * The name of the feature type.
-             */
-            std::string name;
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/linear.h.bak
deleted file mode 100644
index 3044603f3af..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/linear.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_LINEAR_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_LINEAR_H
-
-
-#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a oceanic plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Linear final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Linear(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Linear() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // linear temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            double top_temperature;
-            double bottom_temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model.h.bak
deleted file mode 100644
index ef381bd6f0a..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model.h.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_H
-
-
-#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-  class World;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a oceanic plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         * In this plugin, the temperature of the plate is derived from the plate model,
-         * featuring continuous cooling of a plate from a spreading ridge by both vertical
-         * and horizontal heat conduction.
-         */
-        class PlateModel final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            PlateModel(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~PlateModel() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // plate model temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            double top_temperature;
-            double bottom_temperature;
-            std::pair<std::vector<double>,std::vector<double>> spreading_velocities;
-            std::vector<std::vector<Point<2> > > mid_oceanic_ridges;
-            std::vector<std::vector<double>> spreading_velocities_at_each_ridge_point;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h.bak
deleted file mode 100644
index b73e6ebfc51..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_CONSTANT_AGE_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_CONSTANT_AGE_H
-
-
-#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-  class World;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a oceanic plate of constant age and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         * In this plugin, the temperature of the plate is derived from the plate model,
-         * featuring cooling of a plate from a ridge by vertical heat conduction,
-         * while the effects of horizontal heat conduction are ignored.
-         */
-        class PlateModelConstantAge final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            PlateModelConstantAge(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~PlateModelConstantAge() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // plate model constant age temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            double top_temperature;
-            double bottom_temperature;
-            double plate_age;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/uniform.h.bak
deleted file mode 100644
index 031e3c3a004..00000000000
--- a/contrib/world_builder/include/world_builder/features/oceanic_plate_models/temperature/uniform.h.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_OCEANIC_PLATE_MODELS_TEMPERATURE_UNIFORM_H
-
-
-#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a oceanic plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // uniform temperature submodule parameters
-            double min_depth;
-            Objects::Surface min_depth_surface;
-            double max_depth;
-            Objects::Surface max_depth_surface;
-            double temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume.h.bak b/contrib/world_builder/include/world_builder/features/plume.h.bak
deleted file mode 100644
index cbd73cf8d4a..00000000000
--- a/contrib/world_builder/include/world_builder/features/plume.h.bak
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_PLUME_H
-#define WORLD_BUILDER_FEATURES_PLUME_H
-
-
-#include "world_builder/features/interface.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-  class World;
-
-  namespace Features
-  {
-    namespace PlumeModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace PlumeModels
-
-    /**
-     * This class represents a plume and can implement submodules
-     * for temperature and composition. These submodules determine what
-     * the returned temperature or composition of the temperature and composition
-     * functions of this class will be.
-     */
-    class Plume final: public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        Plume(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~Plume() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm,
-                             const std::string &parent_name = "",
-                             const std::vector<std::string> &required_entries = {});
-
-        /**
-         * Produce a JSON snippet for the schema
-         */
-        static
-        void make_snippet(Parameters &prm);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-        /**
-         * Returns different values at a single point in one go stored in a vector of doubles.
-         *
-         * The properties input decides what each entry means, and the output is generated in the
-         * same order as the properties input. The properties input consists of
-         * a 3D array, where the first entry identifies the property and the last two entries
-         * provide extra information about that property.
-         *
-         * Temperature is identified by 1 and no extra information is needed. So temperature
-         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
-         * vector.
-         *
-         * Composition is identified by 2. This produces one
-         * value in the output. The second entry  identifies the composition number and the third
-         * number is not used. So a commposition query asking about composition 1 looks like this:
-         * {2,1,0}. A composition query produces one entry in the output vector.
-         *
-         * Grains are identified by 2. The second entry is the grain composition number and the third
-         * entry is the number of grains. A query about the grains, where it asks about composition 1
-         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
-         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
-         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
-         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
-         *
-         * The entries in output variable relates the index of the property to the index in the output.
-         */
-        void
-        properties(const Point<3> &position_in_cartesian_coordinates,
-                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                   const double depth,
-                   const std::vector<std::array<unsigned int,3>> &properties,
-                   const double gravity,
-                   const std::vector<size_t> &entry_in_output,
-                   std::vector<double> &output) const override final;
-
-      private:
-        /**
-         * A vector containing all the pointers to the temperature models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::PlumeModels::Temperature::Interface> > temperature_models;
-
-        /**
-         * A vector containing all the pointers to the composition models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::PlumeModels::Composition::Interface> > composition_models;
-
-        /**
-         * A vector containing all the pointers to the grains models. This vector is
-         * responsible for the features and has ownership over them. Therefore
-         * unique pointers are used.
-         * @see Features
-         */
-        std::vector<std::unique_ptr<Features::PlumeModels::Grains::Interface> > grains_models;
-
-
-        double min_depth;
-        double max_depth;
-
-        std::vector<double> depths;
-        std::vector<double> semi_major_axis_lengths;
-        std::vector<double> eccentricities;
-        std::vector<double> rotation_angles;
-    };
-
-
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/composition/interface.h.bak
deleted file mode 100644
index ad34a427e22..00000000000
--- a/contrib/world_builder/include/world_builder/features/plume_models/composition/interface.h.bak
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_COMPOSITION_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_PLUME_MODELS_COMPOSITION_INTERFACE_H
-
-
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-namespace WorldBuilder
-{
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace PlumeModels
-    {
-      namespace Composition
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm) = 0;
-
-
-            /**
-             * takes composition and position and returns a composition.
-             */
-            virtual
-            double get_composition(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_PLUME_COMPOSITION_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Composition
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/composition/uniform.h.bak
deleted file mode 100644
index 209bd78c2d6..00000000000
--- a/contrib/world_builder/include/world_builder/features/plume_models/composition/uniform.h.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_COMPOSITION_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_PLUME_MODELS_COMPOSITION_UNIFORM_H
-
-
-#include "world_builder/features/plume_models/composition/interface.h"
-#include "world_builder/objects/surface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace PlumeModels
-    {
-      namespace Composition
-      {
-        /**
-         * This class represents a plume and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final : public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a composition based on the given position, depth in the model,
-             * gravity and current composition.
-             */
-            double get_composition(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth) const override final;
-
-
-          private:
-            // uniform composition submodule parameters
-
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> compositions;
-            std::vector<double> fractions;
-            Operations operation;
-
-        };
-      } // namespace Composition
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/grains/interface.h.bak
deleted file mode 100644
index b18fbd11b17..00000000000
--- a/contrib/world_builder/include/world_builder/features/plume_models/grains/interface.h.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_GRAINS_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_PLUME_MODELS_GRAINS_INTERFACE_H
-
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace PlumeModels
-    {
-      namespace Grains
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm) = 0;
-
-
-            /**
-             * takes composition and position and returns grains.
-             */
-            virtual
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_PLUME_GRAINS_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      virtual std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Grains
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/grains/uniform.h.bak
deleted file mode 100644
index ad906fa95d3..00000000000
--- a/contrib/world_builder/include/world_builder/features/plume_models/grains/uniform.h.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_GRAINS_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_PLUME_MODELS_GRAINS_UNIFORM_H
-
-
-#include "world_builder/features/plume_models/grains/interface.h"
-#include "world_builder/objects/surface.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace PlumeModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a plume and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class Uniform final : public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
-            std::vector<double> grain_sizes;
-        };
-      } // namespace Grains
-    }   // namespace PlumeModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/temperature/gaussian.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/temperature/gaussian.h.bak
deleted file mode 100644
index 6dd80a0b8ee..00000000000
--- a/contrib/world_builder/include/world_builder/features/plume_models/temperature/gaussian.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_GAUSSIAN_H
-#define WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_GAUSSIAN_H
-
-
-#include "world_builder/features/plume_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace PlumeModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a plume and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Gaussian final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Gaussian(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Gaussian() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const double relative_distance_from_center) const override final;
-
-
-          private:
-            // Gaussian temperature submodule parameters
-            std::vector<double> depths;
-            std::vector<double> center_temperatures;
-            std::vector<double> gaussian_sigmas;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/temperature/interface.h.bak
deleted file mode 100644
index 8f4ba5dd579..00000000000
--- a/contrib/world_builder/include/world_builder/features/plume_models/temperature/interface.h.bak
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_INTERFACE_H
-
-
-#include "world_builder/parameters.h"
-#include "world_builder/objects/natural_coordinate.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-
-    namespace PlumeModels
-    {
-      namespace Temperature
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm) = 0;
-
-
-            /**
-             * takes temperature and position and returns a temperature.
-             * The relative distance from center gives the result of the ellipse
-             * equation, i.e., x^2/a^2 + y^2/b^2, i.e., it tells us how far we
-             * are between the center and margin of the ellipse.
-             */
-            virtual
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const double relative_distance_from_center) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            /**
-             * The name of the feature type.
-             */
-            std::string name;
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_PLUME_TEMPERATURE_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Temperature
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/plume_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/plume_models/temperature/uniform.h.bak
deleted file mode 100644
index d6032cd8d66..00000000000
--- a/contrib/world_builder/include/world_builder/features/plume_models/temperature/uniform.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_PLUME_MODELS_TEMPERATURE_UNIFORM_H
-
-
-#include "world_builder/features/plume_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/objects/surface.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace PlumeModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a plume and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         * In this class, the temperature within the plume is uniform.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const double relative_distance_from_center) const override final;
-
-
-          private:
-            // uniform temperature submodule parameters
-            double min_depth;
-            double max_depth;
-            double temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate.h.bak
deleted file mode 100644
index 2be2f50939e..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate.h.bak
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_H
-
-
-#include "world_builder/features/subducting_plate_models/composition/interface.h"
-#include "world_builder/features/subducting_plate_models/grains/interface.h"
-#include "world_builder/features/subducting_plate_models/temperature/interface.h"
-#include "world_builder/objects/segment.h"
-#include "world_builder/bounding_box.h"
-#include "world_builder/objects/distance_from_surface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-  class World;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace SubductingPlateModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace SubductingPlateModels
-
-    /**
-     * This class represents a subducting plate and can implement submodules
-     * for temperature and composition. These submodules determine what
-     * the returned temperature or composition of the temperature and composition
-     * functions of this class will be.
-     */
-    class SubductingPlate final: public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        SubductingPlate(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~SubductingPlate() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm,
-                             const std::string &parent_name = "",
-                             const std::vector<std::string> &required_entries = {});
-
-        /**
-         * Produce a JSON snippet for the schema
-         */
-        static
-        void make_snippet(Parameters &prm);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-        /**
-         * Returns the bounding points for a BoundingBox object using two extreme points in all the surface
-         * coordinates and an additional buffer zone that accounts for the fault thickness and length. The first and second
-         * points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
-         * documentation in include/bounding_box.h).
-         * For the spherical system, the buffer zone along the longitudal direction is calculated using the
-         * corresponding latitude points.
-         */
-        const BoundingBox<2>  &get_surface_bounding_box () const;
-
-        /**
-         * Returns different values at a single point in one go stored in a vector of doubles.
-         *
-         * The properties input decides what each entry means, and the output is generated in the
-         * same order as the properties input. The properties input consists of
-         * a 3D array, where the first entry identifies the property and the last two entries
-         * provide extra information about that property.
-         *
-         * Temperature is identified by 1 and no extra information is needed. So temperature
-         * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
-         * vector.
-         *
-         * Composition is identified by 2. This produces one
-         * value in the output. The second entry  identifies the composition number and the third
-         * number is not used. So a commposition query asking about composition 1 looks like this:
-         * {2,1,0}. A composition query prodoces one entry in the output vector.
-         *
-         * Grains are identified by 2. The second entry is the grain composition number and the third
-         * entry is the number of grains. A query about the grains, where it asks about composition 1
-         * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
-         * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
-         * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
-         * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
-         *
-         * The entries in output variable relates the index of the property to the index in the output.
-         */
-        void
-        properties(const Point<3> &position_in_cartesian_coordinates,
-                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                   const double depth,
-                   const std::vector<std::array<unsigned int,3>> &properties,
-                   const double gravity,
-                   const std::vector<size_t> &entry_in_output,
-                   std::vector<double> &output) const override final;
-
-        /**
-        * Returns a PlaneDistances object that has the distance from and along a subducting plate plane,
-        * calculated from the coordinates and the depth of the point.
-        */
-        Objects::PlaneDistances
-        distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
-                                  const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                  const double depth) const override;
-
-
-      private:
-        std::vector<std::shared_ptr<Features::SubductingPlateModels::Temperature::Interface> > default_temperature_models;
-        std::vector<std::shared_ptr<Features::SubductingPlateModels::Composition::Interface>  > default_composition_models;
-        std::vector<std::shared_ptr<Features::SubductingPlateModels::Grains::Interface>  > default_grains_models;
-
-        std::vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
-            Features::SubductingPlateModels::Composition::Interface,
-            Features::SubductingPlateModels::Grains::Interface> > default_segment_vector;
-
-        std::vector< std::vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
-            Features::SubductingPlateModels::Composition::Interface,
-            Features::SubductingPlateModels::Grains::Interface> > > sections_segment_vector;
-
-        // This vector stores segments to this coordinate/section.
-        //First used (raw) pointers to the segment relevant to this coordinate/section,
-        // but I do not trust it won't fail when memory is moved. So storing the all the data now.
-        std::vector<std::vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
-            Features::SubductingPlateModels::Composition::Interface,
-            Features::SubductingPlateModels::Grains::Interface> > > segment_vector;
-
-        // todo: the memory of this can be greatly improved by
-        // or using a plugin system for the submodules, or
-        // putting the variables in a union. Although the memory
-        // used by this program is in real cases expected to be
-        // Insignificant compared to what a calling program may
-        // use, a smaller amount of memory used in here, could
-        // theoretically speed up the computation, because more
-        // relevant data could be stored in the cache. But this
-        // not a urgent problem, and would require testing.
-
-        /**
-         * This variable stores the depth at which the subducting
-         * plate starts. It makes this depth effectively the surface
-         * of the model for the slab.
-         */
-        double starting_depth;
-
-        /**
-         * The depth which below the subducting plate may no longer
-         * be present. This can not only help setting up models with
-         * less effort, but can also improve performance, because
-         * the algorithm doesn't have to search in locations below
-         * this depth.
-         */
-        double maximum_depth;
-
-        /**
-         * Stores the bounding points for a BoundingBox object using two extreme points in all the surface
-         * coordinates and an additional buffer zone that accounts for the fault thickness and length. The first and second
-         * points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
-         * documentation in include/bounding_box.h).
-         * For the spherical system, the buffer zone along the longitudal direction is calculated using the
-         * corresponding latitude points.
-         */
-        BoundingBox<2> surface_bounding_box;
-
-        /**
-         * A point on the surface to which the subducting plates subduct.
-         */
-        Point<2> reference_point;
-
-        std::vector<std::vector<double> > slab_segment_lengths;
-        std::vector<std::vector<Point<2> > > slab_segment_thickness;
-        std::vector<std::vector<Point<2> > > slab_segment_top_truncation;
-        std::vector<std::vector<Point<2> > > slab_segment_angles;
-        std::vector<double> total_slab_length;
-        double maximum_total_slab_length;
-        double maximum_slab_thickness;
-
-        double min_along_x;
-        double max_along_x;
-        double min_along_y;
-        double max_along_y;
-        double min_lat_cos_inv;
-        double max_lat_cos_inv;
-        double buffer_around_slab_cartesian;
-    };
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/interface.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/interface.h.bak
deleted file mode 100644
index 130ad43c0e0..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/interface.h.bak
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_COMPOSITION_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_COMPOSITION_INTERFACE_H
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/utilities.h"
-#include "world_builder/features/feature_utilities.h"
-
-#include <map>
-#include <vector>
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as oceanic plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-
-    namespace SubductingPlateModels
-    {
-      namespace Composition
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm) = 0;
-
-
-            /**
-             * takes composition and position and returns a composition.
-             */
-            virtual
-            double get_composition(const Point<3> &position,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_SUBDUCTING_PLATE_COMPOSITION_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Composition
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/smooth.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/smooth.h.bak
deleted file mode 100644
index b6ff89a5fa8..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/smooth.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef _world_builder_features_subducting_plate_composition_smooth_h
-#define _world_builder_features_subducting_plate_composition_smooth_h
-
-#include <world_builder/features/subducting_plate_models/composition/interface.h>
-#include <world_builder/features/feature_utilities.h>
-#include <world_builder/world.h>
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace SubductingPlateModels
-    {
-      namespace Composition
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Smooth: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Smooth(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Smooth();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a composition based on the given position, depth in the model,
-             * and current composition.
-             */
-            double get_composition(const Point<3> &position,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-          private:
-            // linear temperature submodule parameters
-            double min_distance;
-            double max_distance;
-            double side_distance;
-            std::vector<double> top_fraction;
-            // currently not using the side composition, but maybe usefu if you want another composition towards the end
-            std::vector<double> bottom_fraction;
-            std::vector<unsigned int> compositions;
-            Operations operation;
-
-        };
-      }
-    }
-  }
-}
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/uniform.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/uniform.h.bak
deleted file mode 100644
index dd10cfb725d..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/composition/uniform.h.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_COMPOSITION_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_COMPOSITION_UNIFORM_H
-
-
-#include "world_builder/features/subducting_plate_models/composition/interface.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Composition
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a composition based on the given position, depth in the model,
-             * gravity and current composition.
-             */
-            double get_composition(const Point<3> &position,
-                                   const double depth,
-                                   const unsigned int composition_number,
-                                   double composition,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-
-          private:
-            // uniform composition submodule parameters
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> compositions;
-            std::vector<double> fractions;
-            Operations operation;
-
-        };
-      } // namespace Composition
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/interface.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/interface.h.bak
deleted file mode 100644
index 82999be947f..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/interface.h.bak
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_INTERFACE_H
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/utilities.h"
-#include "world_builder/features/feature_utilities.h"
-
-#include <map>
-#include <vector>
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as oceanic plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace SubductingPlateModels
-    {
-      namespace Grains
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm) = 0;
-
-
-            /**
-             * takes composition and position and returns a composition.
-             */
-            virtual
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth,
-                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                       const AdditionalParameters &additional_parameters) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            std::string name;
-
-
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_SUBDUCTING_PLATE_GRAINS_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      virtual std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Grains
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h.bak
deleted file mode 100644
index 45f1e8f2395..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_H
-
-
-#include "world_builder/features/subducting_plate_models/grains/interface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a continental plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistribution final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistribution(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistribution() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth,
-                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                       const AdditionalParameters &additional_parameters) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-        };
-      } // namespace Grains
-    }   // namespace SubductingPlateModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h.bak
deleted file mode 100644
index ddaada0be0b..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_RANDOM_UNIFORM_DISTRIBUTION_DEFLECTED_H
-
-
-#include "world_builder/features/subducting_plate_models/grains/interface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a subducting plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class RandomUniformDistributionDeflected final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            RandomUniformDistributionDeflected(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~RandomUniformDistributionDeflected() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth,
-                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                       const AdditionalParameters &additional_parameters) const override final;
-
-          private:
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<double> grain_sizes;
-            std::vector<bool> normalize_grain_sizes;
-            std::vector<double> deflections;
-
-        };
-      } // namespace Grains
-    }   // namespace SubductingPlateModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/uniform.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/uniform.h.bak
deleted file mode 100644
index 7265453073a..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/grains/uniform.h.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_GRAINS_UNIFORM_H
-
-
-#include "world_builder/features/subducting_plate_models/grains/interface.h"
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Grains
-      {
-        /**
-         * This class represents a oceanic plate and can implement
-         * submodules for temperature and grains. These submodules determine
-         * what the returned temperature or grains of the temperature and grains
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_entries(Parameters &prm,
-                                        const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void declare_grain_size_model_entries(
-              Parameters &prm, const std::string &parent_name,
-              const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            static void
-            declare_fixed_size_model_entries(Parameters &prm,
-                                             const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters
-             * class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-            /**
-             * Returns a grains based on the given position, composition (e.g.
-             * olivine and/or enstatite)depth in the model, gravity and current grains.
-             */
-            WorldBuilder::grains
-            get_grains(const Point<3> &position,
-                       const double depth,
-                       const unsigned int composition_number,
-                       WorldBuilder::grains grains,
-                       const double feature_min_depth,
-                       const double feature_max_depth,
-                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                       const AdditionalParameters &additional_parameters) const override final;
-
-          private:
-            // uniform grains submodule parameters
-            double min_depth;
-            double max_depth;
-            std::vector<unsigned int> grains;
-            std::vector<unsigned int> compositions;
-            std::string operation;
-            std::vector<std::array<std::array<double, 3>, 3>> rotation_matrices;
-            std::vector<double> grain_sizes;
-        };
-      } // namespace Grains
-    } // namespace SubductingPlateModels
-  }     // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/adiabatic.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/adiabatic.h.bak
deleted file mode 100644
index 9fb26e304ff..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/adiabatic.h.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_ADIABATIC_H
-
-
-#include "world_builder/features/subducting_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Adiabatic final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Adiabatic(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Adiabatic() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-
-          private:
-            // adiabatic temperature submodule parameters
-            double min_depth;
-            double max_depth;
-            /**
-             * Todo
-             */
-            double potential_mantle_temperature;
-
-
-            /**
-             * Todo
-             */
-            double thermal_expansion_coefficient;
-
-            /**
-             * Todo
-             */
-            double specific_heat;
-
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/interface.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/interface.h.bak
deleted file mode 100644
index 78bf056680e..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/interface.h.bak
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_INTERFACE_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_INTERFACE_H
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/utilities.h"
-#include "world_builder/features/feature_utilities.h"
-
-#include <map>
-#include <vector>
-
-namespace WorldBuilder
-{
-  class World;
-  class Parameters;
-  template <unsigned int dim> class Point;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as oceanic plate, oceanic plate and subduction zone.
-   */
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        class ObjectFactory;
-
-        class Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Interface();
-
-            /**
-             * Destructor
-             */
-            virtual
-            ~Interface();
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm,
-                                 const std::string &parent_name,
-                                 const std::vector<std::string> &required_entries);
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            virtual
-            void parse_entries(Parameters &prm) = 0;
-
-
-            /**
-             * takes temperature and position and returns a temperature.
-             */
-            virtual
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const = 0;
-            /**
-             * A function to register a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static void registerType(const std::string &name,
-                                     void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                     ObjectFactory *factory);
-
-
-            /**
-             * A function to create a new type. This is part of the automatic
-             * registration of the object factory.
-             */
-            static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-            /**
-             * Returns the name of the plugin
-             */
-            std::string get_name() const
-            {
-              return name;
-            };
-
-          protected:
-            /**
-             * A pointer to the world class to retrieve variables.
-             */
-            WorldBuilder::World *world;
-
-            /**
-             * The name of the feature type.
-             */
-            std::string name;
-
-          private:
-            static std::map<std::string, ObjectFactory *> &get_factory_map()
-            {
-              static std::map<std::string, ObjectFactory *> factories;
-              return factories;
-            }
-
-            static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-            {
-              static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-              return declares;
-            }
-
-        };
-
-
-        /**
-         * A class to create new objects
-         */
-        class ObjectFactory
-        {
-          public:
-            virtual std::unique_ptr<Interface> create(World *world) = 0;
-        };
-
-        /**
-         * A macro which should be in every derived cpp file to automatically
-         * register it. Because this is a library, we need some extra measures
-         * to ensure that the static variable is actually initialized.
-         */
-#define WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/linear.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/linear.h.bak
deleted file mode 100644
index 7484cf35fe8..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/linear.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_LINEAR_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_LINEAR_H
-
-
-#include "world_builder/features/subducting_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Linear final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Linear(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Linear() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-
-          private:
-            // linear temperature submodule parameters
-            double min_depth;
-            double max_depth;
-            double top_temperature;
-            double bottom_temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/mass_conserving.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/mass_conserving.h.bak
deleted file mode 100644
index 38344fb90c1..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/mass_conserving.h.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_MASS_CONSERVING_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_MASS_CONSERVING_H
-
-
-#include "world_builder/features/subducting_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a subducting plate temperature model. The temperature
-         * model uses the heat content (proportional to to thermal mass anomaly) to
-         * define a smooth temperature profile that conserves mass along the slab length.
-         * An empirical (linear) model is used to define how the minimum temperature
-         * increases with depth and how the location of the minimum temperature shifts
-         * into the slab interior. The slab is divided in to top and bottom parts,
-         * which meet at the location where the minimum temperature occurs in the slab.
-         * For the bottom slab the temperature is defined by a half-space cooling model.
-         * For the top of the slab the temperature is defined by one side of a 1D infinite
-         * space cooling model. The age of the overriding plate is used so the slab temperature
-         * at shallow depth smoothly transitions to the temperature of the overriding plate:
-         * this is not perfect, and is affected by the value of "top truncation" parameter
-         * subducting plate. Also note that the parameter "thickness" for the subducting plate
-         * segments needs to be defined but is not used.
-         * Note that the empirical model used to define how Tmin increases with depth
-         * and how the position of Tmin shift with depth is expected to change somewhat
-         * after better calibrating with further tests.
-         */
-        class MassConserving final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            MassConserving(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~MassConserving() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-            /**
-             * Returns a temperature based on the given heat content, temperatures, effective plate age,
-             * and adjusted distance to the coldest point in the slab. The temperature is formulated by
-             * the analytical solutions.
-             */
-            double get_temperature_analytic(const double top_heat_content,
-                                            const double min_temperature,
-                                            const double background_temperature,
-                                            const double temperature_,
-                                            const double plate_velocity,
-                                            const double effective_plate_age,
-                                            const double adjusted_distance) const;
-
-
-          private:
-            //  temperature submodule parameters
-            double min_depth;
-            double max_depth;
-            double density;
-            std::vector<std::vector<double>> subducting_velocities;
-            std::pair<std::vector<double>,std::vector<double>> ridge_spreading_velocities;
-            std::vector<std::vector<double>> ridge_spreading_velocities_at_each_ridge_point;
-            double mantle_coupling_depth;
-            double forearc_cooling_factor;
-            double thermal_conductivity;
-            double thermal_expansion_coefficient;
-            double specific_heat;
-            double thermal_diffusivity;
-            double potential_mantle_temperature;
-            double surface_temperature;
-            double taper_distance;
-            bool adiabatic_heating;
-            std::vector<std::vector<Point<2>>> mid_oceanic_ridges;
-            Operations operation;
-            enum ReferenceModelName
-            {
-              half_space_model,
-              plate_model
-            };
-            ReferenceModelName reference_model_name;
-            const int plate_model_summation_number = 100; // for the plate model
-            bool apply_spline;
-            unsigned int spline_n_points;
-        };
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/plate_model.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/plate_model.h.bak
deleted file mode 100644
index b92f9e995a5..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/plate_model.h.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_PLATE_MODEL_H
-
-
-#include "world_builder/features/subducting_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class PlateModel final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            PlateModel(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~PlateModel() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-
-          private:
-            // plate model temperature submodule parameters
-            double min_depth;
-            double max_depth;
-            double density;
-            double plate_velocity;
-            double thermal_conductivity;
-            double thermal_expansion_coefficient;
-            double specific_heat;
-            double potential_mantle_temperature;
-            double surface_temperature;
-            bool adiabatic_heating;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/uniform.h.bak b/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/uniform.h.bak
deleted file mode 100644
index 2abcc838346..00000000000
--- a/contrib/world_builder/include/world_builder/features/subducting_plate_models/temperature/uniform.h.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_UNIFORM_H
-#define WORLD_BUILDER_FEATURES_SUBDUCTING_PLATE_MODELS_TEMPERATURE_UNIFORM_H
-
-
-#include "world_builder/features/subducting_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        /**
-         * This class represents a subducting plate and can implement submodules
-         * for temperature and composition. These submodules determine what
-         * the returned temperature or composition of the temperature and composition
-         * functions of this class will be.
-         */
-        class Uniform final: public Interface
-        {
-          public:
-            /**
-             * constructor
-             */
-            Uniform(WorldBuilder::World *world);
-
-            /**
-             * Destructor
-             */
-            ~Uniform() override final;
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            static
-            void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-            /**
-             * declare and read in the world builder file into the parameters class
-             */
-            void parse_entries(Parameters &prm) override final;
-
-
-            /**
-             * Returns a temperature based on the given position, depth in the model,
-             * gravity and current temperature.
-             */
-            double get_temperature(const Point<3> &position,
-                                   const double depth,
-                                   const double gravity,
-                                   double temperature,
-                                   const double feature_min_depth,
-                                   const double feature_max_depth,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters &additional_parameters) const override final;
-
-
-          private:
-            // uniform temperature submodule parameters
-            double min_depth;
-            double max_depth;
-            double temperature;
-            Operations operation;
-
-        };
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/grains.h.bak b/contrib/world_builder/include/world_builder/grains.h.bak
deleted file mode 100644
index eb47b2a12d2..00000000000
--- a/contrib/world_builder/include/world_builder/grains.h.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_GRAINS_H
-#define WORLD_BUILDER_GRAINS_H
-
-#include <array>
-#include <ostream>
-#include <vector>
-
-namespace WorldBuilder
-{
-  /**
-   * This is a simple structure to store information about grains.
-   * The advantage of storing all grains in separate vectors, compared
-   * to having a vector of individual grains, is that the vectors can
-   * be empty if the information is not needed.
-   */
-  struct grains
-  {
-    grains();
-
-    grains(const std::vector<double> &vector,
-           const size_t number_of_grains,
-           const size_t start_entry = 0);
-
-    void unroll_into(std::vector<double> &vector,
-                     const size_t start_entry = 0) const;
-
-    // The sizes of the grains
-    std::vector<double> sizes;
-
-    // the rotation matrices of the latices of the grains.
-    // todo: convention.
-    std::vector<std::array<std::array<double,3>,3> > rotation_matrices;
-
-    friend std::ostream &operator<<(std::ostream &os, const grains &grains)
-    {
-      for (unsigned int i = 0; i < grains.sizes.size(); ++i)
-        {
-          os << i << ": s=" << grains.sizes[i] << ", R="
-             << grains.rotation_matrices[i][0][0] << " " << grains.rotation_matrices[i][0][1] << " " << grains.rotation_matrices[i][0][2] << " "
-             << grains.rotation_matrices[i][1][0] << " " << grains.rotation_matrices[i][1][1] << " " << grains.rotation_matrices[i][1][2] << " "
-             << grains.rotation_matrices[i][2][0] << " " << grains.rotation_matrices[i][2][1] << " " << grains.rotation_matrices[i][2][2] << " ";
-        }
-      return os;
-    }
-  };
-
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/gravity_model/interface.h.bak b/contrib/world_builder/include/world_builder/gravity_model/interface.h.bak
deleted file mode 100644
index 79c20b01a24..00000000000
--- a/contrib/world_builder/include/world_builder/gravity_model/interface.h.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_GRAVITY_MODELS_INTERFACE_H
-#define WORLD_BUILDER_GRAVITY_MODELS_INTERFACE_H
-
-#include "world_builder/gravity_model/interface.h"
-
-#include "world_builder/parameters.h"
-#include "world_builder/types/string.h"
-
-
-namespace WorldBuilder
-{
-  class World;
-
-  namespace GravityModel
-  {
-
-    class ObjectFactory;
-
-    /**
-     * This class is an interface for the specific coordinate systems.
-     */
-    class Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        Interface();
-
-        /**
-         * Destructor
-         */
-        virtual
-        ~Interface();
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm,
-                             const std::string &parent_name,
-                             const std::vector<std::string> &required_entries);
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        virtual
-        void parse_entries(Parameters &prm) = 0;
-
-        /**
-         * Returns the gravity vector in a Cartesian coordinate system at a given position.
-         */
-        virtual
-        Point<3> gravity_vector(Point<3> point) const = 0;
-
-        /**
-         * Returns the norm of the gravity at a given position.
-         */
-        virtual
-        double gravity_norm(Point<3> point) const = 0;
-
-        /**
-         * A function to register a new type. This is part of the automatic
-         * registration of the object factory.
-         */
-        static void registerType(const std::string &name,
-                                 void ( * /*declare_entries*/)(Parameters &, const std::string &),
-                                 ObjectFactory *factory);
-
-        /**
-         * A function to create a new type. This is part of the automatic
-         * registration of the object factory.
-         */
-        static std::unique_ptr<Interface> create(const std::string &name, WorldBuilder::World *world);
-
-      protected:
-        /**
-         * A pointer to the world class to retrieve variables.
-         */
-        WorldBuilder::World *world;
-
-
-
-      private:
-        static std::map<std::string, ObjectFactory *> &get_factory_map()
-        {
-          static std::map<std::string, ObjectFactory *> factories;
-          return factories;
-        }
-
-        static std::map<std::string, void ( *)(Parameters &,const std::string &)> &get_declare_map()
-        {
-          static std::map<std::string, void ( *)(Parameters &,const std::string &)> declares;
-          return declares;
-        }
-    };
-
-
-
-    /**
-     * A class to create new objects
-     */
-    class ObjectFactory
-    {
-      public:
-        virtual std::unique_ptr<Interface> create(World *world) = 0;
-    };
-
-    /**
-     * A macro which should be in every derived cpp file to automatically
-     * register it. Because this is a library, we need some extra measures
-     * to ensure that the static variable is actually initialized.
-     */
-#define WB_REGISTER_GRAVITY_MODEL(klass,name) \
-  class klass##Factory : public ObjectFactory { \
-    public: \
-      klass##Factory() \
-      { \
-        Interface::registerType(#name, klass::declare_entries, this); \
-      } \
-      std::unique_ptr<Interface> create(World *world) override final { \
-        return std::unique_ptr<Interface>(new klass(world)); \
-      } \
-  }; \
-  static klass##Factory global_##klass##Factory;
-
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/gravity_model/uniform.h.bak b/contrib/world_builder/include/world_builder/gravity_model/uniform.h.bak
deleted file mode 100644
index b3f5c29cc68..00000000000
--- a/contrib/world_builder/include/world_builder/gravity_model/uniform.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_COORDINATE_SYSTEMS_UNIFORM_H
-#define WORLD_BUILDER_COORDINATE_SYSTEMS_UNIFORM_H
-
-#include "world_builder/gravity_model/interface.h"
-
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace GravityModel
-  {
-    /**
-     * Register header file
-     */
-    //WB_REGISTER_COORDINATE_SYSTEM_HEADER(Uniform)
-
-
-    /**
-     * This implements a Uniform geometry model.The Uniform geometry model
-     * doesn't do anything with the coordinates, but is needed to have a common
-     * interface for all the geometry models.
-     */
-    class Uniform final : public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        Uniform(WorldBuilder::World *world);
-
-        /**
-         * Destructor
-         */
-        ~Uniform() override final;
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        static
-        void declare_entries(Parameters &prm, const std::string &parent_name = "");
-
-        /**
-         * declare and read in the world builder file into the parameters class
-         */
-        void parse_entries(Parameters &prm) override final;
-
-
-
-        /**
-         * Returns the gravity vector in a Cartesian coordinate system at a given position,
-         * which has a constant magitude for the whole domain. The vector points down in
-         * cartesian coordinates and to the center of the sphere in spherical coordinates.
-         */
-        virtual
-        Point<3> gravity_vector(Point<3> point) const override final;
-
-        /**
-         * Returns the norm of the gravity at a given position, which is a constant
-         * number for the whole domain.
-         */
-        virtual
-        double gravity_norm(Point<3> point) const override final;
-
-      private:
-
-        /**
-         * The uniform gravity.
-         */
-        double gravity_magnitude;
-
-    };
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/kd_tree.h.bak b/contrib/world_builder/include/world_builder/kd_tree.h.bak
deleted file mode 100644
index 1dcef34f0f0..00000000000
--- a/contrib/world_builder/include/world_builder/kd_tree.h.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef KD_TREE_H
-#define KD_TREE_H
-
-#include <vector>
-#include <cstddef>
-#include <iostream>
-#include <limits>
-
-#include "world_builder/assert.h"
-#include "world_builder/point.h"
-
-namespace WorldBuilder
-{
-  namespace KDTree
-  {
-    /**
-     * A struct to store an index for a point and the
-     * distance to that point.
-     */
-    struct IndexDistance
-    {
-      size_t index;
-      double distance;
-    };
-
-
-    /**
-     * A struct to store an index for a point and the
-     * distance to that point.
-     */
-    struct IndexDistances
-    {
-      size_t min_index;
-      double min_distance;
-      std::vector<IndexDistance> vector;
-    };
-
-    /**
-     * Each item contains an index and an x and y coordinate
-     */
-    struct Node
-    {
-      size_t index;
-      double x;
-      double y;
-
-      Node(size_t index_, double x_, double y_)
-        :
-        index(index_),
-        x(x_),
-        y(y_)
-      {}
-
-
-      /**
-       * access index (const)
-       */
-      inline
-      const double &operator[](const bool y_axis) const
-      {
-        WBAssert(std::fabs((y_axis ? y : x) - *(&x+y_axis)) < std::numeric_limits<double>::epsilon(),
-                 "Internal error: y_axis=" << y_axis << ", x=" << x << ", y=" << y <<", *(&x+y_axis)=" << *(&x+y_axis)
-                 << ", ((bool)y_axis ? x : y) - *(&x+y_axis)=" << fabs((y_axis ? x : y) - *(&x+y_axis)));
-        return *(&x+y_axis);
-      }
-    };
-
-    class KDTree
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        KDTree() = default;
-        /**
-         * Constructor. Requires a list of Nodes.
-         */
-        KDTree(const std::vector<Node> point_list);
-
-        /**
-         * Create a tree based on the current information in the
-         * node vector.
-         */
-        void create_tree(const size_t left,
-                         const size_t right,
-                         const bool x_axis);
-
-        /**
-         * Return a reference to the vector containing the nodes.
-         */
-        const std::vector<Node> &get_nodes() const;
-
-        /**
-         * Returns the index of the closest point and the distance
-         * of that point to the check point.
-         */
-        IndexDistance find_closest_point(const Point<2> &check_point) const;
-
-
-
-        /**
-         * Returns the index of the closest point and the distance
-         * of that point to the check point. Stores the points searched
-         * through in a unsorted vector.
-         * Note: I can only guarantee that the point with the least distance
-         * is the closest point. The point in the list with the second/third/etc.
-         * smallest distance may or may not actually be the global point
-         * with the second/third/etc. smallest distance. It will most likely be a
-         * very good guess though.
-         */
-        IndexDistances find_closest_points(const Point<2> &check_point) const;
-
-
-      private:
-        /**
-         * Returns the index of the closest point and the distance
-         * of that point to the check point. This function is used
-         * by find_closest_point to find the correct point.
-         */
-        void find_closest_point_recursive(const Point<2> &check_point,
-                                          const size_t left,
-                                          const size_t right,
-                                          const bool y_axis,
-                                          IndexDistance &index_distance) const;
-
-
-        /**
-         * Returns the index of the closest point and the distance
-         * of that point to the check point. This function is used
-         * by find_closest_point to find the correct point.
-         */
-        void find_closest_points_recursive(const Point<2> &check_point,
-                                           const size_t left,
-                                           const size_t right,
-                                           const bool y_axis,
-                                           IndexDistances &index_distances) const;
-
-        std::vector<Node> nodes;
-    };
-  }
-}
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/nan.h.bak b/contrib/world_builder/include/world_builder/nan.h.bak
deleted file mode 100644
index 96916c783e5..00000000000
--- a/contrib/world_builder/include/world_builder/nan.h.bak
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_NAN_H
-#define WORLD_BUILDER_NAN_H
-
-#include <limits>
-
-namespace WorldBuilder
-{
-  namespace NaN
-  {
-    /**
-     * A double signaling NaN
-     */
-    const double DQNAN = std::numeric_limits<double>::quiet_NaN();
-
-    /**
-     * A unsigned int signaling NaN
-     */
-    const unsigned int IQNAN = std::numeric_limits<unsigned int>::quiet_NaN();
-    /**
-     * A double signaling NaN
-     */
-    const double DSNAN = std::numeric_limits<double>::signaling_NaN();
-
-    /**
-     * A unsigned int signaling NaN
-     */
-    const unsigned int ISNAN = std::numeric_limits<unsigned int>::signaling_NaN();
-  } // namespace NaN
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/objects/bezier_curve.h.bak b/contrib/world_builder/include/world_builder/objects/bezier_curve.h.bak
deleted file mode 100644
index cc0868da52a..00000000000
--- a/contrib/world_builder/include/world_builder/objects/bezier_curve.h.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_OBJECTS_BEZIER_CURVE_H
-#define WORLD_BUILDER_OBJECTS_BEZIER_CURVE_H
-
-#include "world_builder/objects/closest_point_on_curve.h"
-#include "world_builder/point.h"
-#include <array>
-#include <vector>
-
-namespace WorldBuilder
-{
-  namespace Objects
-  {
-
-    /**
-     * @brief Class for circle line/spline, including interpolation on it
-     *
-     */
-    class BezierCurve
-    {
-      public:
-        /**
-         * @brief Construct a new Bezier Curve object
-         *
-         * @param p
-         * @param angle_constrains
-         */
-        BezierCurve() = default;
-
-        /**
-         * @brief Construct a new Bezier Curve object
-         *
-         * @param p
-         * @param angle_constrains
-         */
-        BezierCurve(const std::vector<Point<2> > &p, const std::vector<double> &angle_constrains = {});
-
-        /**
-         * @brief Finds the closest point on the curve. If the the closest point
-         *        doesn't fall on the segment, return a point with x and y being nan.
-         *
-         * @param p
-         * @param verbose Whether this function should be outputting its Newton iteration
-         * to std::cout while running. This is very expensive, but useful for debugging
-         * purposes.
-         * @return ClosestPointOnCurve
-         */
-        ClosestPointOnCurve closest_point_on_curve_segment(const Point<2> &p, const bool verbose = false) const;
-
-        /**
-         * @brief
-         *
-         * @param i
-         * @param x
-         * @return Point<2>
-         */
-        Point<2> operator()(const size_t i, const double x) const;
-
-      private:
-        std::vector<Point<2> > points;
-        std::vector<std::array<Point<2>,2 > > control_points;
-        std::vector<double> lengths;
-        std::vector<double> angles;
-
-    };
-  }
-
-}
-
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/objects/closest_point_on_curve.h.bak b/contrib/world_builder/include/world_builder/objects/closest_point_on_curve.h.bak
deleted file mode 100644
index 19377d61e39..00000000000
--- a/contrib/world_builder/include/world_builder/objects/closest_point_on_curve.h.bak
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_OBJECTS_CLOSEST_POINT_ON_CURVE_H
-#define WORLD_BUILDER_OBJECTS_CLOSEST_POINT_ON_CURVE_H
-
-
-#include "world_builder/point.h"
-#include "world_builder/nan.h"
-
-//using namespace WorldBuilder;
-
-namespace WorldBuilder
-{
-  namespace Objects
-  {
-
-
-    struct ClosestPointOnCurve
-    {
-      ClosestPointOnCurve()
-        :
-        distance(std::numeric_limits<double>::infinity()),
-        parametric_fraction(NaN::DSNAN),
-        interpolation_fraction(NaN::DSNAN),
-        index(0),
-        point(Point<2>(NaN::DQNAN,NaN::DQNAN,CoordinateSystem::invalid)),
-        normal(Point<2>(NaN::DSNAN,NaN::DSNAN,CoordinateSystem::invalid))
-      {}
-
-      double distance;
-      double parametric_fraction;
-      double interpolation_fraction;
-      size_t index;
-      Point<2> point;
-      Point<2> normal;
-    };
-  }
-}
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/objects/distance_from_surface.h.bak b/contrib/world_builder/include/world_builder/objects/distance_from_surface.h.bak
deleted file mode 100644
index d0b45d1dfc0..00000000000
--- a/contrib/world_builder/include/world_builder/objects/distance_from_surface.h.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_OBJECTS_DISTANCE_FROM_SURFACE_H
-#define WORLD_BUILDER_OBJECTS_DISTANCE_FROM_SURFACE_H
-
-namespace WorldBuilder
-{
-  namespace Objects
-  {
-    class PlaneDistances
-    {
-      public:
-
-        /**
-         * Constructor to create an PlaneDistances object from the distance
-         * from and along the surface of plane
-         */
-        PlaneDistances(const double distance_from_surface_, const double distance_along_surface_)
-          :
-          distance_from_surface(distance_from_surface_),
-          distance_along_surface(distance_along_surface_)
-        {}
-
-        /**
-         * Function to get the distance from the surface
-        */
-        double get_distance_from_surface() const;
-
-        /**
-         * Function to get the distance along the surface
-        */
-        double get_distance_along_surface() const;
-
-      private:
-        /**
-        * the distance from the surface of the plane
-        */
-        double distance_from_surface;
-        /**
-        * the distance along the surface of the plane
-        */
-        double distance_along_surface;
-    };
-  }
-}
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/objects/natural_coordinate.h.bak b/contrib/world_builder/include/world_builder/objects/natural_coordinate.h.bak
deleted file mode 100644
index 27f82163823..00000000000
--- a/contrib/world_builder/include/world_builder/objects/natural_coordinate.h.bak
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_OBJECTS_NATURAL_COORDINATE_H
-#define WORLD_BUILDER_OBJECTS_NATURAL_COORDINATE_H
-
-#include <array>
-#include "world_builder/point.h"
-#include "world_builder/coordinate_systems/interface.h"
-
-namespace WorldBuilder
-{
-  namespace Objects
-  {
-    /*
-    * A class that represents a point in a chosen coordinate system.
-    */
-    class NaturalCoordinate
-    {
-      public:
-        /**
-         * Constructor based on providing the geometry model as a pointer
-         */
-        NaturalCoordinate(const std::array<double,3> &position,
-                          const ::WorldBuilder::CoordinateSystems::Interface &coordinate_system);
-
-        /**
-         * Constructor based on providing the geometry model as a pointer
-         */
-        NaturalCoordinate(const Point<3> &position,
-                          const ::WorldBuilder::CoordinateSystems::Interface &coordinate_system);
-
-        /**
-         * Returns the coordinates in the given coordinate system, which may
-         * not be Cartesian.
-         */
-        const std::array<double,3> &get_coordinates() const;
-
-        /**
-         * The coordinate that represents the 'surface' directions in the
-         * chosen coordinate system.
-         */
-        std::array<double,2> get_surface_coordinates() const;
-
-        /**
-         * The coordinate that represents the 'surface' directions in the
-         * chosen coordinate system.
-         */
-        Point<2> get_surface_point() const;
-
-        /**
-         * The coordinate that represents the 'depth' direction in the chosen
-         * coordinate system.
-         */
-        double get_depth_coordinate() const;
-
-        /**
-         * Return a reference to the coordinate that represents the 'depth' direction
-         * in the chosen coordinate system.
-         */
-        double &get_ref_depth_coordinate();
-
-        /**
-         * get the coordinate system type of this coordinate.
-         */
-        CoordinateSystem get_coordinate_system() const;
-
-      private:
-        /**
-         * An enum which stores the coordinate system of this natural
-         * point
-         */
-        CoordinateSystem coordinate_system;
-
-        /**
-         * An array which stores the coordinates in the coordinates system
-         */
-        std::array<double,3> coordinates;
-    };
-
-
-    inline
-    double
-    NaturalCoordinate::get_depth_coordinate() const
-    {
-      switch (coordinate_system)
-        {
-          case CoordinateSystem::cartesian:
-          {
-            return coordinates[2];
-            break;
-          }
-
-          case CoordinateSystem::spherical:
-          {
-            return coordinates[0];
-            break;
-          }
-
-          default:
-            WBAssertThrow (false, "Coordinate system not implemented.");
-        }
-
-      return 0;
-    }
-  }
-}
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/objects/segment.h.bak b/contrib/world_builder/include/world_builder/objects/segment.h.bak
deleted file mode 100644
index 5b2b7319d91..00000000000
--- a/contrib/world_builder/include/world_builder/objects/segment.h.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_OBJECTS_SEGMENT_H
-#define WORLD_BUILDER_OBJECTS_SEGMENT_H
-
-
-#include "world_builder/types/plugin_system.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Objects
-  {
-
-    /**
-      * This class represents an actual segment
-      */
-    template <class A, class B, class C>
-    class Segment
-    {
-      public:
-
-        /**
-         * A constructor for the clone and set_entry function
-         */
-        Segment(const double default_length,
-                const WorldBuilder::Point<2> &default_thickness,
-                const WorldBuilder::Point<2> &default_top_truncation,
-                const WorldBuilder::Point<2> &default_angle,
-                std::vector<std::shared_ptr<A> > temperature_systems,
-                std::vector<std::shared_ptr<B> > composition_systems,
-                std::vector<std::shared_ptr<C> > grains_systems);
-
-        /**
-         * Copy constructor
-         */
-        Segment(Segment const &other);
-
-        /**
-         * Destructor
-         */
-        ~Segment();
-
-        double value_length;
-        double default_length;
-        WorldBuilder::Point<2> value_thickness;
-        WorldBuilder::Point<2> value_top_truncation;
-        WorldBuilder::Point<2> value_angle;
-        std::vector<std::shared_ptr<A> > temperature_systems;
-        std::vector<std::shared_ptr<B> > composition_systems;
-        std::vector<std::shared_ptr<C> > grains_systems;
-
-      protected:
-      private:
-
-    };
-  } // namespace Objects
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/objects/surface.h.bak b/contrib/world_builder/include/world_builder/objects/surface.h.bak
deleted file mode 100644
index f55a862e040..00000000000
--- a/contrib/world_builder/include/world_builder/objects/surface.h.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_OBJECTS_SURFACE_H
-#define WORLD_BUILDER_OBJECTS_SURFACE_H
-
-#include "world_builder/utilities.h"
-#include "world_builder/kd_tree.h"
-
-namespace WorldBuilder
-{
-  namespace Objects
-  {
-    struct SurfaceValueInfo
-    {
-      size_t triangle_index;
-      double interpolated_value;
-      double interpolator_s;
-      double interpolator_t;
-
-      SurfaceValueInfo(
-        size_t triangle_index_,
-        double interpolated_value_,
-        double interpolator_s_,
-        double interpolator_t_)
-        :
-        triangle_index(triangle_index_),
-        interpolated_value(interpolated_value_),
-        interpolator_s(interpolator_s_),
-        interpolator_t(interpolator_t_) {};
-
-      SurfaceValueInfo(double interpolated_value_)
-        :
-        triangle_index(NaN::IQNAN),
-        interpolated_value(interpolated_value_),
-        interpolator_s(NaN::DQNAN),
-        interpolator_t(NaN::DQNAN) {};
-    };
-
-    class Surface
-    {
-      public:
-        /**
-         * Constructor to create an empty surface.
-         */
-        Surface();
-
-        /**
-         * Constructor to create a surface from value at points object output.
-         */
-        Surface(std::pair<std::vector<double>,std::vector<double>> values_at_points);
-
-        /**
-         * Returns the value of the surface at the check point.
-         */
-        SurfaceValueInfo local_value(const Point<2> &check_point) const;
-
-        /**
-         * Whether the surface is a constant value or not. This is used for optimalization.
-         */
-        bool constant_value;
-
-        /**
-         * The minimum value of all provided points.
-         */
-        double minimum;
-
-        /**
-         * The maximum value of all provided points.
-         */
-        double maximum;
-
-        /**
-         * The KD tree which stores the centroids of all triangles and an index to the triangle points
-         * and values stored in the triangles member variable.
-         */
-        KDTree::KDTree tree;
-
-        /**
-         * Stores the triangles as a list of three points.
-         */
-        std::vector<std::array<std::array<double,3>,3> > triangles;
-
-        /**
-         * @brief Stores precomputed values
-         */
-        std::vector<std::array<double,8> > in_triangle_precomputed;
-
-      private:
-
-    };
-  }
-
-}
-
-#endif
\ No newline at end of file
diff --git a/contrib/world_builder/include/world_builder/parameters.h.bak b/contrib/world_builder/include/world_builder/parameters.h.bak
deleted file mode 100644
index 8323d981830..00000000000
--- a/contrib/world_builder/include/world_builder/parameters.h.bak
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_PARAMETERS_H
-#define WORLD_BUILDER_PARAMETERS_H
-
-#include <map>
-#include <memory>
-#include <vector>
-
-#include "rapidjson/schema.h"
-#include "world_builder/point.h"
-#include "world_builder/types/unsigned_int.h"
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-    class Interface;
-    template<unsigned int dim>
-    class Point;
-    class Double;
-    class String;
-    class Segment;
-    class Array;
-    class Bool;
-    class UnsignedInt;
-    class Int;
-  } // namespace Types
-
-  namespace Features
-  {
-    class Interface;
-  } // namespace Features
-
-  namespace CoordinateSystems
-  {
-    class Interface;
-  } // namespace CoordinateSystems
-
-  namespace GravityModel
-  {
-    class Interface;
-  } // namespace GravityModel
-
-  class World;
-
-  /**
-   * A class to hold all the parameters needed by the world builder. Internally
-   * it holds all values in the form of vectors of class Types. Values can be
-   * entered in two ways into this class. The first way is through the
-   * load_entry function which load the value from the provided world builder
-   * file. The second way is through the set_entry function, through which
-   * values can be directly entered into the parameter class. Values can be
-   * retrieved through the get functions which take the name of the value
-   * with which it was set. It is also required for bot loading, setting and
-   * getting values to do it in the correct subsection. Subsections can be
-   * entered with the enter_subsection function and left with the
-   * leave_subsection function. The current path can be retrieved through the
-   * function get_current_path() and get_current_path_without_arrays().
-   */
-  class Parameters
-  {
-    public:
-      /**
-       * Constructor
-       * \param world A reference to the World class
-       */
-      Parameters(World &world);
-
-      /**
-       * Destructor
-       */
-      ~Parameters();
-
-      /**
-       * Initializes the parameter file
-       * \param filename A string with the path to the world builder file
-       * \param has_output_dir A bool indicating whether the world builder may write out information.
-       * \param output_dir A string with the path to the directory where it can output information if allowed by has_output_dir
-       */
-      void initialize(std::string &filename, bool has_output_dir = false, const std::string &output_dir = "");
-
-      /**
-       * A generic get function to retrieve setting from the parameter file.
-       * Note that this is dependent on the current path/subsection which you are in.
-       * \param name The name of the entry to retrieved
-       * @see path
-       * @see enter_subsection()
-       * @see leave_subsection()
-       */
-      template<class T>
-      T get(const std::string &name);
-
-      /**
-       * A specialized version of get which can return vectors/arrays.
-       * \param name The name of the entry to retrieved
-       */
-      template<class T>
-      std::vector<T> get_vector(const std::string &name);
-
-      std::vector<std::vector<double>> get_vector_or_double(const std::string &name);
-
-      /**
-       * A specialized version of get which can return a value at points type.
-       * \param name The name of the entry to retrieved
-       * \param name additional points to be added to the list at either the default value or at the value of a single value array in the list
-       */
-      std::pair<std::vector<double>,std::vector<double>>
-                                                      get(const std::string &name,
-                                                          const std::vector<Point<2> > &addition_points = {});
-
-      /**
-       * A specialized version of get which can return a values at times type.
-       * \param name The name of the entry to retrieved
-       */
-      std::pair<std::vector<double>,std::vector<double>> get_value_at_array(const std::string &name);
-
-      /**
-       * A specialized version of get which can return vectors/arrays.
-       * This version is designed for the plugin system.
-       * \param name The name of the entry to retrieved
-       */
-      template<class T, class A, class B, class C>
-      std::vector<T> get_vector(const std::string &name, std::vector<std::shared_ptr<A> > &, std::vector<std::shared_ptr<B> > &, std::vector<std::shared_ptr<C> > &);
-
-      /**
-       * A specialized version of get which can return unique pointers.
-       * \param name The name of the entry to retrieved
-       */
-      template<class T>
-      std::unique_ptr<T> get_unique_pointer(const std::string &name);
-
-      /**
-       * A specialized version of get which can return unique pointers as an argument
-       * and returns a bool to indicate whether it was successful or not.
-       * Note that this function will erase all information in the vector.
-       * \param name The name of the entry to retrieved
-       * \param vector A vector of unique pointers.
-       */
-      template<class T>
-      bool
-      get_unique_pointers(const std::string &name, std::vector<std::unique_ptr<T> > &vector);
-
-      /**
-       * A specialized version of get which can return shared pointers as an argument
-       * and returns a bool to indicate whether it was successful or not.
-       * Note that this function will erase all information in the vector.
-       * \param name The name of the entry to retrieved
-       * \param vector A vector of shared pointers.
-       */
-      template<class T>
-      bool
-      get_shared_pointers(const std::string &name, std::vector<std::shared_ptr<T> > & /*vector*/);
-
-      /**
-       * Checks for the existence of an entry in the parameter file.
-       * Return true when an entry is specified and false when it is not.
-       * This is independent of whether an entry has been declared or not.
-       * The main intended usage is to check whether the user has provided
-       * the specified entry in the user supplied parameters file, since
-       * the get functions may use default values.
-       * \param name The name of the entry to be checked.
-       */
-      bool
-      check_entry(const std::string &name) const;
-
-      /**
-       * Declares the existence an entry in the parameters class.
-       * Default values are supplied by the type.
-       * \param name The name of the entry to be declared
-       * \param type The type of entry (e.g. Double, Array, etc.)
-       * \param documentation A string containing information about this parameter.
-       */
-      void declare_entry(const std::string &name,
-                         const Types::Interface &type,
-                         const std::string &documentation);
-
-
-      /**
-       * This function is used to enter a subsection. It appends to the path
-       * variable. This action is revesed by the leave subsection function.
-       * \param name The name of the subsection to be entered.
-       * @see path
-       * @see leave_subsection()
-       */
-      void enter_subsection(const std::string &name);
-
-      /**
-       * This function is used to leave a subsection by removing the last
-       * element of the path variable. It reverses the action of the enter
-       * subsection function.
-       * @see path
-       * @see enter_subsection()
-       */
-      void leave_subsection();
-
-      /**
-       * A utilities function for declaring plugin model entries. This always contains a model declaration entry with the plugin name.
-       * @param model_group_name The name of the model group which is declared.
-       * @param parent_name The name of the parent declaration group.
-       * @param declaration_map A map containing plugin names and plugin declaration functions
-       * @param required_entries A vector containing what entries should be required from the user. Default value is empty.
-       * @param extra_declarations A vector containing extra declarations common to all plugins in this group. Default value is empty.
-       */
-      void
-      declare_model_entries(const std::string &model_group_name,
-                            const std::string &parent_name,
-                            const std::map<std::string, void ( *)(Parameters &,const std::string &)> &declare_map,
-                            const std::vector<std::string> &required_entries = {},
-                            const std::vector<std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string> > &extra_declarations = {});
-
-
-      /**
-       * A reference to the World class. This is needed to create the features.
-       */
-      World &world;
-
-      /**
-       * This variable stores what path separator is used in the property tree
-       * and in this class.
-       */
-      const std::string path_separator = ".";
-
-      /**
-       * This variable stores the path in a vector of strings.
-       * @see enter_subsection()
-       * @see leave_subsection()
-       */
-      std::vector<std::string> path;
-
-      rapidjson::Document declarations;
-      rapidjson::Document parameters;
-
-
-
-
-      /**
-       * A vector containing all the pointers to the features. This vector is
-       * responsible for the features and has ownership over them. Therefore
-       * unique pointers are used.
-       * @see Features
-       */
-      std::vector<std::unique_ptr<WorldBuilder::Features::Interface> > features;
-
-      /**
-       * A pointers to the corodinate system. This variable is responsible for
-       * the coordinate system and has ownership over it. Therefore a unique
-       * pointer are used.
-       * @see CoordinateSystem
-       */
-      std::unique_ptr<WorldBuilder::CoordinateSystems::Interface> coordinate_system;
-
-      /**
-       * A pointers to the gravity model. This variable is responsible for
-       * the gravity model and has ownership over it. Therefore a unique
-       * pointer are used.
-       * @see CoordinateSystem
-       */
-      std::unique_ptr<WorldBuilder::GravityModel::Interface> gravity_model;
-
-      /**
-       * This function return the current path as stored in the path variable
-       * as a string in json pointer format.
-       * \return std::string
-       */
-      std::string get_full_json_path(size_t max_size = std::numeric_limits<size_t>::max()) const;
-
-      /**
-       * todo: Warning: do not use before declarations is filled.
-       * This function return the current path as stored in the path variable
-       * as a string in json pointer format.
-       * \return std::string
-       */
-      std::string get_full_json_schema_path() const;
-
-      /**
-       * This function return the current path as stored in the path variable
-       * as a string.
-       * \return std::string
-       */
-      //std::string get_full_path() const;
-
-      /**
-       * This function return the current path as stored in the path variable
-       * as a string, but the arrays are striped. This is useful for working
-       * with the boost property tree.
-       * \return std::string
-       */
-      //std::string get_full_path_without_arrays() const;
-
-    private:
-
-
-      /**
-       * This is used for the get relative path functions. It stores how many
-       * top entries of the path should be ignored.
-       */
-      size_t path_level;
-
-      /**
-       * A function which returns the relative path, which is the full path
-       * minus the path_level top entries..
-       * @see get_current_path()
-       */
-      std::string get_relative_path() const;
-
-      /**
-       * A function which returns the relative path, which is the full path
-       * minus the path_level top entries., without names for the arrays.
-       * @see get_current_path_without_arrays()
-       */
-      std::string get_relative_path_without_arrays() const;
-  };
-} // namespace WorldBuilder
-#endif
diff --git a/contrib/world_builder/include/world_builder/point.h.bak b/contrib/world_builder/include/world_builder/point.h.bak
deleted file mode 100644
index c3b0bca2d85..00000000000
--- a/contrib/world_builder/include/world_builder/point.h.bak
+++ /dev/null
@@ -1,473 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_POINT_H
-#define WORLD_BUILDER_POINT_H
-#include "nan.h"
-#define _USE_MATH_DEFINES
-#include <array>
-#include <cmath>
-#include <limits>
-#include <iostream>
-
-#include "world_builder/assert.h"
-#include "world_builder/consts.h"
-#include "world_builder/coordinate_system.h"
-
-namespace WorldBuilder
-{
-
-  /**
-   * This namespace contains some faster but less accurate version of the
-   * trigonomic functions and a faster version of the fmod function.
-   */
-  namespace FT
-  {
-    /**
-     * Fast version of the fmod function.
-     */
-    inline double fmod(const double x, const double y)
-    {
-      if (y < 0.0 || y > 0.0)
-        {
-          const double x_div_y = x/y;
-          return (x_div_y-static_cast<int>(x_div_y))*y;
-        }
-      return NaN::DQNAN;
-    }
-
-    /**
-     * Fast sin function, accurate for values between 0 and pi. The implementation is
-     * based on discussion at https://stackoverflow.com/a/6104692.
-     *
-     * The accuracy seem good enough for most purposes. The unit test tests in steps
-     * of 0.01 from -4 pi to 4 pi and compares against the std sin function and the difference
-     * is always smaller than 1.2e-5. If the test is run with intervals of 0.001 then there
-     * are 12 entries which are (very slightly) above that (<3e-8) at angles of about
-     * -174, -6, 6  and 174.
-     *
-     */
-    inline double fast_sin_d(const double angle)
-    {
-      constexpr double A = 4.0/(Consts::PI * Consts::PI);
-      constexpr double oneminPmin = 1.-0.1952403377008734-0.01915214119105392;
-
-      const double y = A* angle * ( Consts::PI - angle );
-      return y*( oneminPmin + y*( 0.1952403377008734 + y * 0.01915214119105392 ) ) ;
-    }
-
-    /**
-     * Fast but less accurate sin function for any angle.
-     * Implemented by calling fast_sin_d with a mirrored x if needed to
-     * forfill the constrained of fast_sin_d to only have values between
-     * zero and pi.
-     */
-    inline double sin(const double raw_angle)
-    {
-      const double angle = (raw_angle > -Consts::PI && raw_angle < Consts::PI)
-                           ?
-                           raw_angle
-                           :
-                           FT::fmod(raw_angle + std::copysign(Consts::PI,raw_angle), Consts::PI * 2.0) - std::copysign(Consts::PI,raw_angle);
-
-      if (angle >= 0)
-        return fast_sin_d(angle);
-      return -fast_sin_d(-angle);
-    }
-
-    /**
-     * Fast but less accurate cos function for any angle.
-     */
-    inline double cos(const double angle)
-    {
-      return FT::sin((Consts::PI*0.5)-angle);
-    }
-  } // namespace FT
-
-
-  /**
-   * A class which stores 2d and 3d arrays of doubles (depending on the dimension),
-   * and the coordinate system which the coordinates can be used for. It also
-   * implements several operations such as the computation of the l2 norm and the
-   * dot product.
-   */
-  template<unsigned int dim>
-  class Point
-  {
-    public:
-      /**
-       * Constructor. Constructs a Point at (0,0) in 2d or (0,0,0) in 3d
-       * with a Cartesian coordinate system.
-       */
-      inline
-      Point(CoordinateSystem coordinate_system_)
-        :
-        point(std::array<double,dim>()),
-        coordinate_system(coordinate_system_)
-      {}
-
-      /**
-       * Constructor. Constructs a Point from a std::array<double,dim> and
-       * a coordinate system.
-       */
-      inline
-      Point(const std::array<double,dim> &location, CoordinateSystem coordinate_system_)
-        :
-        point(location),
-        coordinate_system(coordinate_system_)
-      {}
-
-      /**
-       * Constructor. Constructs a Point from an other Point and
-       * a coordinate system.
-       */
-      inline
-      Point(const Point<dim> &location, CoordinateSystem coordinate_system_)
-        :
-        point(location.get_array()),
-        coordinate_system(coordinate_system_)
-      {}
-
-      /**
-       * Constructor. Constructs a Point from an other Point.
-       */
-      inline
-      Point(const Point<dim> &location)
-        :
-        point(location.get_array()),
-        coordinate_system(location.get_coordinate_system())
-      {}
-
-      /**
-       * Constructor. Constructs a 2d Point from two doubles and
-       * a coordinate system.
-       */
-      Point(const double x, const double y, CoordinateSystem coordinate_system);
-
-      /**
-       * Constructor. Constructs a 3d Point from three doubles and
-       * a coordinate system.
-       */
-      Point(const double x, const double y, const double z, CoordinateSystem coordinate_system);
-
-      /**
-       * Destructor
-       */
-      inline
-      ~Point() = default;
-
-      inline
-      Point<dim> &operator=(const Point<dim> &point_right)
-      {
-        point = point_right.point;
-        coordinate_system = point_right.coordinate_system;
-        return *this;
-      }
-
-      /**
-       * dot product
-       */
-      inline
-      double operator*(const Point<dim> &point_right) const
-      {
-        WBAssert(coordinate_system == point_right.get_coordinate_system(),
-                 "Cannot take the dot product of two points which represent different coordinate systems.");
-        const std::array<double,dim> &array = point_right.get_array();
-        double dot_product = 0;
-        for (unsigned int i = 0; i < dim; ++i)
-          dot_product += point[i] * array[i];
-        return dot_product;
-      }
-
-
-      /**
-       * Multiply the vector with a scalar
-       */
-      inline
-      Point<dim> operator*(const double scalar) const
-      {
-        // initialize the array to zero.
-        std::array<double,dim> array;
-        for (unsigned int i = 0; i < dim; ++i)
-          array[i] = point[i] * scalar;
-        return Point<dim>(array,coordinate_system);
-      }
-
-      /**
-       * Divide the vector through a scalar
-       */
-      inline
-      Point<dim> operator/(const double scalar) const
-      {
-        // initialize the array to zero.
-        std::array<double,dim> array;
-        const double one_over_scalar = 1/scalar;
-        for (unsigned int i = 0; i < dim; ++i)
-          array[i] = point[i] * one_over_scalar;
-        return Point<dim>(array,coordinate_system);
-      }
-
-      /**
-       * add two points
-       */
-      inline
-      Point<dim> operator+(const Point<dim> &point_right) const
-      {
-        WBAssert(coordinate_system == point_right.get_coordinate_system(),
-                 "Cannot add two points which represent different coordinate systems.");
-        Point<dim> point_tmp(point,coordinate_system);
-        for (unsigned int i = 0; i < dim; ++i)
-          point_tmp[i] += point_right[i];
-
-        return point_tmp;
-      }
-
-
-      /**
-       * Subtract two points
-       */
-      inline
-      Point<dim> operator-(const Point<dim> &point_right) const
-      {
-        WBAssert(coordinate_system == point_right.get_coordinate_system(),
-                 "Cannot subtract two points which represent different coordinate systems. Internal has type " << static_cast<int>(coordinate_system)
-                 << ", other point has type " << static_cast<int>(point_right.get_coordinate_system()));
-        Point<dim> point_tmp(point,coordinate_system);
-        for (unsigned int i = 0; i < dim; ++i)
-          point_tmp[i] -= point_right[i];
-
-        return point_tmp;
-      }
-
-
-      /**
-       * Multiply the vector with a scalar
-       */
-      inline
-      Point<dim> &operator*=(const double scalar)
-      {
-        for (unsigned int i = 0; i < dim; ++i)
-          point[i] *= scalar;
-        return *this;
-      }
-      /**
-       * Divide the vector through a scalar
-       */
-      inline
-      Point<dim> &operator/=(const double scalar)
-      {
-        for (unsigned int i = 0; i < dim; ++i)
-          point[i] /= scalar;
-        return *this;
-      }
-
-      /**
-       * add two points
-       */
-      inline
-      Point<dim> &operator+=(const Point<dim> &point_right)
-      {
-        WBAssert(coordinate_system == point_right.get_coordinate_system(),
-                 "Cannot add two points which represent different coordinate systems.");
-        for (unsigned int i = 0; i < dim; ++i)
-          point[i] += point_right[i];
-        return *this;
-      }
-
-      /**
-       * Check if all values are the same.
-       *
-       * Note: compares floating points with an epsilon
-       */
-      inline
-      bool operator==(const Point<dim> &point_) const
-      {
-        if (coordinate_system != point_.coordinate_system)
-          return false;
-        WorldBuilder::Point<dim> point_tmp(point,coordinate_system);
-        point_tmp -= point_;
-        if (std::fabs(point_tmp[0]) > std::numeric_limits<double>::epsilon())
-          return false;
-        if (std::fabs(point_tmp[1]) > std::numeric_limits<double>::epsilon())
-          return false;
-        if (dim == 3 && std::fabs(point_tmp[2]) > std::numeric_limits<double>::epsilon())
-          return false;
-
-        return true;
-      }
-
-      /**
-       * subtract two points
-       */
-      inline
-      Point<dim> &operator-=(const Point<dim> &point_right)
-      {
-        WBAssert(coordinate_system == point_right.get_coordinate_system(),
-                 "Cannot subtract two points which represent different coordinate systems.");
-        for (unsigned int i = 0; i < dim; ++i)
-          point[i] -= point_right[i];
-        return *this;
-      }
-
-      /**
-       * access index (const)
-       */
-      inline
-      const double &operator[](const size_t index) const
-      {
-        WBAssert(index <= dim, "Can't ask for element " << index << " in an point with dimension " << dim << '.');
-        return point[index];
-      }
-
-
-      /**
-       * access index
-       */
-      inline double &operator[](const size_t index)
-      {
-        WBAssert(index <= dim, "Can't ask for element " << index << " in an point with dimension " << dim << '.');
-        return point[index];
-      }
-
-      /**
-       * Computes the distance between this and a given point.
-       * In spherical coordinates it returns the central angle in radians.
-       */
-      double
-      distance(const Point<2> &two) const;
-
-      /**
-       * Computes the cheapest relative distance between this and a given point in spherical coordinates.
-       * The return value itself is only guartenteed to have the property that a
-       * larger value is further away.
-       * In the current implementation that means for the cartasian case the squared
-       * value is returned and for the spherical value the result of the havearsine
-       * function without asin and sqrt is returned.
-       */
-      double
-      cheap_relative_distance_spherical(const Point<2> &two) const
-      {
-        const double d_longitude = two[0] - this->point[0];
-        const double d_latitude = two[1] - this->point[1];
-        const double sin_d_lat = FT::sin(d_latitude * 0.5);
-        const double sin_d_long = FT::sin(d_longitude * 0.5);
-        return (sin_d_lat * sin_d_lat) + (sin_d_long*sin_d_long) * FT::cos(this->point[1]) * FT::cos(two[1]);
-      }
-
-      /**
-       * Computes the cheapest relative distance between this and a given point in cartesian coordinates.
-       * The return value itself is only guartenteed to have the property that a
-       * larger value is further away.
-       * In the current implementation that means for the cartasian case the squared
-       * value is returned and for the spherical value the result of the havearsine
-       * function without asin and sqrt is returned.
-       */
-      double
-      cheap_relative_distance_cartesian(const Point<2> &two) const
-      {
-        const double x_distance_to_reference_point = point[0]-two[0];
-        const double y_distance_to_reference_point = point[1]-two[1];
-        return (x_distance_to_reference_point*x_distance_to_reference_point) + (y_distance_to_reference_point*y_distance_to_reference_point);
-      }
-
-      /**
-       * return the internal array which stores the point data.
-       */
-      inline
-      const std::array<double,dim> &get_array() const
-      {
-        return point;
-      }
-
-
-      /**
-       * returns the coordinate system associated with the data.
-       */
-      inline
-      CoordinateSystem get_coordinate_system() const
-      {
-        return coordinate_system;
-      }
-
-
-      /**
-      * Computes the L2 norm: sqrt(x_i * x_i + y_i * y_i + z_i * z_i) in 3d.
-      */
-      inline
-      double norm() const
-      {
-        return std::sqrt(this->norm_square());
-      }
-
-
-      /**
-      * Computes the square of the norm, which is the sum of the absolute squares
-      * x_i * x_i + y_i * y_i + z_i * z_i in 3d.
-      */
-      inline
-      double norm_square() const
-      {
-        WBAssertThrow(false,"This function is only available in 2d or 3d.");
-        return 0;
-      }
-
-      /**
-       * Outputs the values of the point to std cout separated by spaces. This does not
-       * output the coordinate system.
-       */
-      friend std::ostream &operator<<( std::ostream &output, const Point<dim> &stream_point )
-      {
-        for (size_t i = 0; i < dim-1; i++)
-          {
-            output <<  stream_point[i] << ' ';
-          }
-        output << stream_point[dim-1];
-
-        return output;
-      }
-
-
-    private:
-      std::array<double,dim> point;
-      CoordinateSystem coordinate_system;
-
-  };
-
-  template <>
-  inline
-  double Point<2>::norm_square() const
-  {
-    return (point[0] * point[0]) + (point[1] * point[1]);
-  }
-
-  template <>
-  inline
-  double Point<3>::norm_square() const
-  {
-    return (point[0] * point[0]) + (point[1] * point[1]) + (point[2] * point[2]);
-  }
-
-  template<unsigned int dim>
-  inline
-  Point<dim> operator*(const double scalar, const Point<dim> &point)
-  {
-    return point*scalar;
-  }
-} // namespace WorldBuilder
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/array.h.bak b/contrib/world_builder/include/world_builder/types/array.h.bak
deleted file mode 100644
index f2dba5dc7ca..00000000000
--- a/contrib/world_builder/include/world_builder/types/array.h.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_ARRAY_H
-#define WORLD_BUILDER_TYPES_ARRAY_H
-
-
-#include "world_builder/types/interface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-    /**
-     * This class represents an array of values which can be of any Types. It
-     * stores the type of values it is holding and an vector of indices where
-     * the values are actually stored in the parameters vector which hold all
-     * the values of that type. This type can also hold a unique pointer to
-     * the type is should hold. This is used for declaring types.The difference
-    * between an array and a list is that the array holds the values retrievable
-    * by index, and a list holds the values strictly ordered, only accessible
-    * an iterator. An other difference it that lists have a name.
-     */
-    class Array final: public Interface
-    {
-      public:
-        /**
-         * Constructor for the declaration
-         */
-        Array(const Interface &type,
-              const unsigned int min_items = 0,
-              const unsigned int max_items = std::numeric_limits<unsigned int>::max(),
-              const bool unique_items = false);
-
-        /**
-         * Constructor for cloning an array.
-         */
-        Array(Array const &other);
-
-
-        /**
-         * Destructor
-         */
-        ~Array() override final;
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-        /**
-         * An enum of the type which this class points to
-         * @see Types::type
-         */
-        Types::type inner_type;
-
-        /**
-         * This class is sometimes responsible for the object it points to, but
-         * sometimes it is not responsible for the object is points to.
-         * When it is responsible the unique_inner_type points to it and the
-         * inner_type should have size zero. When it is not responsible,
-         * unique_inner_type should point to the nullptr and inner_type should
-         * have a size larger then zero.
-         * @see inner_type_index
-         */
-        std::unique_ptr<Interface> inner_type_ptr;
-
-
-        /**
-         * Todo
-         */
-        bool required;
-
-        /**
-         * Todo
-         */
-        unsigned int min_items;
-
-        /**
-         * Todo
-         */
-        unsigned int max_items;
-
-        /**
-         * Todo
-         */
-        bool unique_items;
-
-      protected:
-        Array *clone_impl() const override final
-        {
-          return new Array(*this);
-        };
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/bool.h.bak b/contrib/world_builder/include/world_builder/types/bool.h.bak
deleted file mode 100644
index 77bafbb7c60..00000000000
--- a/contrib/world_builder/include/world_builder/types/bool.h.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_BOOL_H
-#define WORLD_BUILDER_TYPES_BOOL_H
-
-
-#include "world_builder/types/interface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-
-    /**
-     * This class represents a bool value with documentation
-     */
-    class Bool final: public Interface
-    {
-      public:
-        /**
-         * A constructor for the load_entry function
-         */
-        Bool(const bool default_value);
-
-        /**
-         * Copy constructor
-         */
-        Bool(Bool const &other);
-
-        /**
-         * Destructor
-         */
-        ~Bool() override final;
-
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-        bool default_value;
-
-      protected:
-        Bool *clone_impl() const override final
-        {
-          return new Bool(*this);
-        };
-
-      private:
-
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/double.h.bak b/contrib/world_builder/include/world_builder/types/double.h.bak
deleted file mode 100644
index 05bd3b74de3..00000000000
--- a/contrib/world_builder/include/world_builder/types/double.h.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_DOUBLE_H
-#define WORLD_BUILDER_TYPES_DOUBLE_H
-
-
-#include "world_builder/types/interface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-
-    /**
-     * This class represents a double value with documentation
-     */
-    class Double final: public Interface
-    {
-      public:
-        /**
-         * A constructor for the load_entry function
-         */
-        Double(const double default_value);
-
-        /**
-         * Copy constructor
-         */
-        Double(Double const &other);
-
-        /**
-         * Destructor
-         */
-        ~Double() override final;
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-        double default_value;
-
-      protected:
-        Double *clone_impl() const override final
-        {
-          return new Double(*this);
-        };
-
-      private:
-
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/int.h.bak b/contrib/world_builder/include/world_builder/types/int.h.bak
deleted file mode 100644
index 44cd4f13c65..00000000000
--- a/contrib/world_builder/include/world_builder/types/int.h.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_INT_H
-#define WORLD_BUILDER_TYPES_INT_H
-
-
-#include "world_builder/types/interface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-
-    /**
-     * This class represents a bool value with documentation
-     */
-    class Int final: public Interface
-    {
-      public:
-        /**
-         * A constructor for the load_entry function
-         */
-        Int(int default_value = 0);
-
-        /**
-         * Copy constructor
-         */
-        Int(Int const &other);
-
-        /**
-         * Destructor
-         */
-        ~Int() override final;
-
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-        int value {0};
-        int default_value;
-
-      protected:
-        /**
-         * This implements the actual cloneing for the clone function in the base class.
-         */
-        Int *clone_impl() const override final
-        {
-          return new Int(*this);
-        };
-      private:
-
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/interface.h.bak b/contrib/world_builder/include/world_builder/types/interface.h.bak
deleted file mode 100644
index 40cd8b58616..00000000000
--- a/contrib/world_builder/include/world_builder/types/interface.h.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_INTERFACE_H
-#define WORLD_BUILDER_TYPES_INTERFACE_H
-
-#include "rapidjson/pointer.h"
-#include "assert.h"
-
-#include <memory>
-#include <iostream>
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  /**
-   * This class is an interface for the specific plate tectonic feature classes,
-   * such as continental plate, oceanic plate and subduction zone.
-   */
-  namespace Types
-  {
-
-    enum class type
-    {
-      None,Bool,String,Double,Int,UnsignedInt,Array,Object,List,Point2D,Point3D,CoordinateSystem,PluginSystem,Segment,ConstantLayer,ValueAtPoints,OneOf
-    };
-
-    class Interface
-    {
-      public:
-        /**
-         * Constructor
-         */
-        Interface();
-
-        /**
-         * Destructor
-         */
-        virtual
-        ~Interface();
-
-        /**
-         * Todo
-         */
-        virtual
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const = 0;
-
-        /**
-         * clone
-         */
-        virtual
-        std::unique_ptr<Interface> clone() const
-        {
-          return std::unique_ptr<Interface>(clone_impl());
-        }
-
-        /**
-         * read in the world builder file
-         */
-
-        type get_type() const;
-
-
-      protected:
-        type type_name {type::None};
-
-
-        virtual
-        Interface *clone_impl() const = 0;
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/object.h.bak b/contrib/world_builder/include/world_builder/types/object.h.bak
deleted file mode 100644
index a188450ff13..00000000000
--- a/contrib/world_builder/include/world_builder/types/object.h.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_OBJECT_H
-#define WORLD_BUILDER_TYPES_OBJECT_H
-
-#include <vector>
-
-#include "world_builder/types/interface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-    /**
-     * This class represents an object of values which can be of any Types. It
-     * stores the type of values it is holding and an vector of indices where
-     * the values are actually stored in the parameters vector which hold all
-     * the values of that type. This type can also hold a unique pointer to
-     * the type is should hold. This is used for declaring types.The difference
-    * between an object and a list is that the object holds the values retrievable
-    * by index, and a list holds the values strictly ordered, only accessible
-    * an iterator. An other difference it that lists have a name.
-     */
-    class Object final: public Interface
-    {
-      public:
-        /**
-         * Constructor for the declaration
-         */
-        Object(std::vector<std::string> required = std::vector<std::string>(),
-               const bool additional_properties = false);
-
-        /**
-         * Copy constructor
-         */
-        Object(Object const &other);
-
-        /**
-         * Destructor
-         */
-        ~Object() final;
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-
-        /**
-         * Todo
-         */
-        std::vector<std::string> required;
-        bool additional_properties;
-
-      protected:
-        Object *clone_impl() const override final
-        {
-          return new Object(*this);
-        };
-
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/one_of.h.bak b/contrib/world_builder/include/world_builder/types/one_of.h.bak
deleted file mode 100644
index c4aedcaaa89..00000000000
--- a/contrib/world_builder/include/world_builder/types/one_of.h.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_ONE_OF_H
-#define WORLD_BUILDER_TYPES_ONE_OF_H
-
-
-#include "world_builder/types/interface.h"
-#include <vector>
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-    /**
-     * This class represents an a single choice between options (one of).
-     */
-    class OneOf final: public Interface
-    {
-      public:
-        /**
-         * Constructor for the declaration
-         */
-        OneOf(const Interface &type_1,
-              const Interface &type_2);
-
-        /**
-         * Constructor for cloning an array.
-         */
-        OneOf(OneOf const &other);
-
-
-        /**
-         * Destructor
-         */
-        ~OneOf() override final;
-
-        /**
-         * Write schema
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-        /**
-         * An enum of the type which this class points to
-         * @see Types::type
-         */
-        Types::type inner_type;
-
-        /**
-         * This class is sometimes responsible for the object it points to, but
-         * sometimes it is not responsible for the object is points to.
-         * When it is responsible the unique_inner_type points to it and the
-         * inner_type should have size zero. When it is not responsible,
-         * unique_inner_type should point to the nullptr and inner_type should
-         * have a size larger then zero.
-         * @see inner_type_index
-         */
-        std::vector<std::unique_ptr<Interface>> inner_types_ptr;
-
-      protected:
-        OneOf *clone_impl() const override final
-        {
-          return new OneOf(*this);
-        };
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/plugin_system.h.bak b/contrib/world_builder/include/world_builder/types/plugin_system.h.bak
deleted file mode 100644
index a3ac0827929..00000000000
--- a/contrib/world_builder/include/world_builder/types/plugin_system.h.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_PLUGIN_SYSTEM_H
-#define WORLD_BUILDER_TYPES_PLUGIN_SYSTEM_H
-
-
-#include "world_builder/features/interface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-
-    /**
-     * This class represents a plate tectonic feature class, such as the
-     * continental plate class, oceanic plate class and subduction zone class.
-     */
-    class PluginSystem final: public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        PluginSystem(std::string default_value_,
-                     void ( *declare_entries)(Parameters &, const std::string &, const std::vector<std::string> &),
-                     std::vector<std::string> required_entries,
-                     const bool allow_multiple = true);
-
-
-        /**
-         * Copy constructor
-         */
-        PluginSystem(PluginSystem const &plugin_system);
-
-        /**
-         * Destructor
-         */
-        ~PluginSystem() override final;
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-
-        std::string default_value;
-        void( *declare_entries)(Parameters &, const std::string &, const std::vector<std::string> &);
-        std::vector<std::string> required_entries;
-        bool allow_multiple;
-
-      protected:
-        PluginSystem *clone_impl() const override final
-        {
-          return new PluginSystem(*this);
-        };
-
-      private:
-
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/point.h.bak b/contrib/world_builder/include/world_builder/types/point.h.bak
deleted file mode 100644
index d73ce91c3e4..00000000000
--- a/contrib/world_builder/include/world_builder/types/point.h.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_POINT_H
-#define WORLD_BUILDER_TYPES_POINT_H
-
-
-#include "world_builder/point.h"
-#include "world_builder/types/interface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-
-    /**
-     * This class represents a continental plate and can implement submodules
-     * for temperature and composition. These submodules determine what
-     * the returned temperature or composition of the temperature and composition
-     * functions of this class will be.
-     */
-    template <unsigned int dim>
-    class Point final: public Interface
-    {
-      public:
-
-        /**
-         * A constructor used for the load_entry function
-         */
-        Point();
-
-        /**
-         * A constructor used for the load_entry function
-         */
-        Point(const WorldBuilder::Point<dim> &default_value, std::string description);
-
-        /**
-         * A constructor used for cloning and the set_entry function
-         */
-        Point(const WorldBuilder::Point<dim> &value, const WorldBuilder::Point<dim> &default_value, std::string description);
-
-        /**
-         * Copy constructor
-         */
-        Point(Point const &other);
-
-        /**
-         * Destructor
-         */
-        ~Point() override final;
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-        /**
-         * dot product
-         */
-        double operator*(const Point<dim> &point) const;
-
-
-        /**
-         * Multiply the vector with a scalar
-         */
-        WorldBuilder::Point<dim> operator*(const double scalar) const;
-
-        /**
-         * add two points
-         */
-        WorldBuilder::Point<dim> operator+(const Point<dim> &point) const;
-
-
-        /**
-         * Subtract two points
-         */
-        WorldBuilder::Point<dim> operator-(const Point<dim> &point) const;
-
-        /**
-         * access index (const)
-         */
-        const double &operator[](const unsigned int index) const;
-
-
-        /**
-         * access index
-         */
-        double &operator[](const unsigned int index);
-
-
-
-        WorldBuilder::Point<dim> value;
-        WorldBuilder::Point<dim> default_value;
-        std::string description;
-
-      protected:
-        Point *clone_impl() const override final
-        {
-          return new Point(*this);
-        };
-
-      private:
-
-    };
-
-    template<unsigned int dim>
-    WorldBuilder::Point<dim> operator*(const double scalar, const Point<dim> &point);
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/segment.h.bak b/contrib/world_builder/include/world_builder/types/segment.h.bak
deleted file mode 100644
index 6ab28793047..00000000000
--- a/contrib/world_builder/include/world_builder/types/segment.h.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_SEGMENT_H
-#define WORLD_BUILDER_TYPES_SEGMENT_H
-
-
-#include "world_builder/types/plugin_system.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-
-    /**
-     * This class represents a segment value with documentation
-     */
-    class Segment : public Interface
-    {
-      public:
-        /**
-         * A constructor
-         */
-        Segment(const double default_length,
-                const WorldBuilder::Point<2> &default_thickness,
-                const WorldBuilder::Point<2> &default_top_truncation,
-                const WorldBuilder::Point<2> &default_angle,
-                const Types::Interface &temperature_plugin_system,
-                const Types::Interface &composition_plugin_system,
-                const Types::Interface &grains_plugin_system_);
-
-        /**
-         * A constructor for the load_entry function
-         */
-        Segment(double default_length,
-                WorldBuilder::Point<2> default_thickness,
-                WorldBuilder::Point<2> default_angle,
-                std::string description);
-
-        /**
-         * Copy constructor
-         */
-        Segment(Segment const &other);
-
-
-        /**
-         * Destructor
-         */
-        ~Segment() override;
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-
-        double value_length;
-        double default_length;
-        WorldBuilder::Point<2> value_thickness;
-        WorldBuilder::Point<2> default_thickness;
-        WorldBuilder::Point<2> default_top_truncation;
-        WorldBuilder::Point<2> value_angle;
-        WorldBuilder::Point<2> default_angle;
-        std::unique_ptr<Types::Interface> temperature_plugin_system;
-        std::unique_ptr<Types::Interface> composition_plugin_system;
-        std::unique_ptr<Types::Interface> grains_plugin_system;
-
-      protected:
-        Segment *clone_impl() const override final
-        {
-          return new Segment(*this);
-        };
-      private:
-
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/string.h.bak b/contrib/world_builder/include/world_builder/types/string.h.bak
deleted file mode 100644
index 6a83b654c52..00000000000
--- a/contrib/world_builder/include/world_builder/types/string.h.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_STRING_H
-#define WORLD_BUILDER_TYPES_STRING_H
-
-#include <vector>
-
-#include "world_builder/types/interface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-
-    /**
-     * This class represents a continental plate and can implement submodules
-     * for temperature and composition. These submodules determine what
-     * the returned temperature or composition of the temperature and composition
-     * functions of this class will be.
-     */
-    class String final: public Interface
-    {
-      public:
-        /**
-         * constructor
-         */
-        String(std::string default_value);
-
-        /**
-         * constructor
-         */
-        String(std::string default_value, const std::string &restricted_value);
-
-        /**
-         * constructor
-         */
-        String(std::string default_value, std::vector<std::string> restricted_values);
-
-        /**
-         * constructor
-         */
-        //String(std::string default_value, std::string description);
-
-
-        /**
-         * A constructor for the clone and set_entry function
-         */
-        String(std::string value, std::string default_value, std::string description);
-
-        /**
-         * Copy constructor
-         */
-        String(String const &other);
-
-        /**
-         * Destructor
-         */
-        ~String() final;
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-
-        std::string value;
-        std::string default_value;
-        std::string description;
-        std::vector<std::string> restricted_values;
-
-
-      protected:
-        String *clone_impl() const override final
-        {
-          return new String(*this);
-        };
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/unsigned_int.h.bak b/contrib/world_builder/include/world_builder/types/unsigned_int.h.bak
deleted file mode 100644
index 1afd9a62f9b..00000000000
--- a/contrib/world_builder/include/world_builder/types/unsigned_int.h.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_UNSIGNED_INT_H
-#define WORLD_BUILDER_TYPES_UNSIGNED_INT_H
-
-
-#include "world_builder/types/interface.h"
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-
-    /**
-     * This class represents a bool value with documentation
-     */
-    class UnsignedInt final: public Interface
-    {
-      public:
-        /**
-         * A constructor for the load_entry function
-         */
-        UnsignedInt(unsigned int default_value = 0);
-
-        /**
-         * Copy constructor
-         */
-        UnsignedInt(UnsignedInt const &other);
-
-        /**
-         * Destructor
-         */
-        ~UnsignedInt() override final;
-
-
-        /**
-         * Todo
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-        unsigned int value {0};
-        unsigned int default_value;
-
-      protected:
-        /**
-         * This implements the actual cloneing for the clone function in the base class.
-         */
-        UnsignedInt *clone_impl() const override final
-        {
-          return new UnsignedInt(*this);
-        };
-      private:
-
-    };
-  } // namespace Types
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/types/value_at_points.h.bak b/contrib/world_builder/include/world_builder/types/value_at_points.h.bak
deleted file mode 100644
index a3878b616cd..00000000000
--- a/contrib/world_builder/include/world_builder/types/value_at_points.h.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_TYPES_VALUE_AT_POINTS_H
-#define WORLD_BUILDER_TYPES_VALUE_AT_POINTS_H
-
-#include "world_builder/types/point.h"
-#include <vector>
-
-
-namespace WorldBuilder
-{
-  class Parameters;
-
-  namespace Types
-  {
-    /**
-     * This class represents a depth surface value with documentation
-     */
-    class ValueAtPoints : public Interface
-    {
-      public:
-        /**
-         * A constructor
-         */
-        ValueAtPoints(const double default_value,
-                      uint64_t max_values_in_array,
-                      std::vector<Point<2>> default_points_ = std::vector<Point<2>>());
-
-        /**
-         * Copy constructor
-         */
-        ValueAtPoints(ValueAtPoints const &other);
-
-
-        /**
-         * Destructor
-         */
-        ~ValueAtPoints() override;
-
-        /**
-         * Write schema
-         */
-        void write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const override final;
-
-        double default_value;
-        uint64_t max_values_in_array;
-        std::vector<Point<2> > default_points;
-
-      protected:
-        ValueAtPoints *clone_impl() const override final
-        {
-          return new ValueAtPoints(*this);
-        };
-      private:
-
-    };
-  } // namespace Types
-
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/utilities.h.bak b/contrib/world_builder/include/world_builder/utilities.h.bak
deleted file mode 100644
index 9b5d2687a2d..00000000000
--- a/contrib/world_builder/include/world_builder/utilities.h.bak
+++ /dev/null
@@ -1,494 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_UTILITIES_H
-#define WORLD_BUILDER_UTILITIES_H
-
-
-#include "world_builder/nan.h"
-#include "world_builder/coordinate_systems/interface.h"
-#include "world_builder/objects/natural_coordinate.h"
-#include "world_builder/objects/bezier_curve.h"
-#include <iostream>
-
-
-namespace WorldBuilder
-{
-
-  namespace CoordinateSystems
-  {
-    class Interface;
-  } // namespace CoordinateSystems
-  namespace Utilities
-  {
-
-    /**
-     * provide a short way to test if two doubles are equal.
-     * Based on https://stackoverflow.com/a/4010279.
-     * Removed a==b test since it triggers warnings. If used in
-     * performance critical parts where this could matter, a fast
-     * version could be added.
-     */
-    inline bool approx(double a, double b, double error_factor=1e4)
-    {
-      return std::abs(a-b)<std::abs(std::min(a,b))*std::numeric_limits<double>::epsilon()*
-             error_factor;
-    }
-
-    /**
-     * Given a 2d point and a list of points which form a polygon, computes if
-     * the point falls within the polygon. For spherical coordinates it will
-     * return true if the point or the point where the longitude is shifted
-     * by 2 * PI is inside on of the polygons. It calls
-     * polygon_contains_point_implementation to do the real work.
-     */
-    bool
-    polygon_contains_point(const std::vector<Point<2> > &point_list,
-                           const Point<2> &point);
-
-    /**
-     * Given a 2d point and a list of points which form a polygon, computes if the point
-     * falls within the polygon.
-     */
-    bool
-    polygon_contains_point_implementation(const std::vector<Point<2> > &point_list,
-                                          const Point<2> &point);
-
-
-    /**
-     * Given a 2d point, a semi-major axis, and an eccentricity, computes where
-     * the point falls within the ellipse. If the fraction is larger than 1, the
-     * point is outside the ellipse.
-     */
-    double
-    fraction_from_ellipse_center (const Point<2> &ellipse_center,
-                                  const double semi_major_axis,
-                                  const double eccentricity,
-                                  const double rotation_angle,
-                                  const Point<2> &point);
-
-
-    /**
-     * Given a 2d point and a list of points which form a polygon, compute the smallest
-     * distance of the point to the polygon. The sign is negative for points outside of
-     * the polygon and positive for points inside the polygon.
-     */
-    double
-    signed_distance_to_polygon(const std::vector<Point<2> > &point_list_,
-                               const Point<2> &point_);
-
-
-    /**
-     * Returns spherical coordinates of a Cartesian point. The returned array
-     * is filled with radius, phi and theta (polar angle). If the dimension is
-     * set to 2 theta is omitted. Phi is always normalized to [0,2*pi].
-     *
-     */
-    std::array<double,3>
-    cartesian_to_spherical_coordinates(const Point<3> &position);
-
-    /**
-     * Return the Cartesian point of a spherical position defined by radius,
-     * phi and theta (polar angle). If the dimension is set to 2 theta is
-     * omitted.
-     */
-    Point<3>
-    spherical_to_cartesian_coordinates(const std::array<double,3> &scoord);
-
-    /**
-     * Returns ellipsoidal coordinates of a Cartesian point. The returned array
-     * is filled with phi, theta and radius.
-     *
-     */
-    std::array<double,3>
-    cartesian_to_ellipsoidal_coordinates(const Point<3> &position,
-                                         const double semi_major_axis_a,
-                                         const double eccentricity);
-
-    /**
-     * Return the Cartesian point of a ellipsoidal position defined by phi,
-     * phi and radius.
-     */
-    Point<3>
-    ellipsoidal_to_cartesian_coordinates(const std::array<double,3> &phi_theta_d,
-                                         const double semi_major_axis_a,
-                                         const double eccentricity);
-
-    /**
-     * A function that takes a string representation of the name of a
-     * coordinate system (as represented by the CoordinateSystem enum)
-     * and returns the corresponding value.
-     */
-    CoordinateSystem
-    string_to_coordinate_system (const std::string & /*coordinate_system*/);
-
-
-    /**
-     * Convert point to array
-     */
-    template<unsigned int dim>
-    std::array<double,dim> convert_point_to_array(const Point<dim> &point);
-
-    /**
-     * Converts a string to a double
-     */
-    double
-    string_to_double(const std::string &string);
-
-    /**
-     * Converts a string to a int
-     */
-    int
-    string_to_int(const std::string &string);
-
-
-    /**
-     * Converts a string to a unsigned int
-     */
-    unsigned int
-    string_to_unsigned_int(const std::string &string);
-
-
-    /**
-     * Cross product between two 3d points.
-     */
-    Point<3> cross_product(const Point<3> &a, const Point<3> &b);
-
-    /**
-     * Enum class for interolation type
-     */
-    enum class InterpolationType
-    {
-      None,
-      Linear,
-      MonotoneSpline,
-      ContinuousMonotoneSpline,
-      Invalid,
-    };
-
-    /**
-     * Class for linear and monotone spline interpolation
-     */
-    class interpolation
-    {
-      public:
-        /**
-         * Initialize the spline. This function assumes that all y points are spaced 1 in the x direction.
-         *
-         * @param y Values in the interpolation points.
-         */
-        void set_points(const std::vector<double> &y);
-
-
-        /**
-         * Evaluate at point @p x.
-         */
-        inline
-        double operator() (const double x) const
-        {
-          if (x >= 0. && x <= static_cast<double>(mx_size_min))
-            {
-              const size_t idx = static_cast<size_t>(x);
-              const double h = x-static_cast<double>(idx);
-              return ((m[idx][0]*h + m[idx][1])*h + m[idx][2])*h + m[idx][3];
-            }
-          const size_t idx = std::min(static_cast<size_t>(std::max( static_cast<int>(x), static_cast<int>(0))),mx_size_min);
-          const double h = x-static_cast<double>(idx);
-          return (m[idx][1]*h + m[idx][2])*h + m[idx][3];
-        }
-
-
-        inline
-        double operator() (const double x, const size_t idx, const double h) const
-        {
-          return (x >= 0. && x <= static_cast<double>(mx_size_min))
-                 ?
-                 ((m[idx][0]*h + m[idx][1])*h + m[idx][2])*h + m[idx][3]
-                 :
-                 (m[idx][1]*h + m[idx][2])*h + m[idx][3];
-        }
-
-
-        /**
-         * Evaluate at point @p x. assumes x is between 0 and mx_size_min.
-         * assume size_t idx = (size_t)x and h = x-idx.
-         */
-        inline
-        double value_inside (const size_t idx, const double h) const
-        {
-          WBAssert(idx <= mx_size_min, "Internal error: using value_inside outside the range of 0 to " << mx_size_min << ", but value was outside of this range: " << idx << ".");
-          WBAssert(h >= 0 && h <= 1., "Internal error: using value_inside outside the range of 0 to " << mx_size_min << ", but value was outside of this range: " << h << ".");
-          return ((m[idx][0]*h + m[idx][1])*h + m[idx][2])*h + m[idx][3];
-        }
-
-
-        /**
-         * Evaluate at point @p x. assumes x is between 0 and mx_size_min.
-         * assume size_t idx = (size_t)x and h = x-idx.
-         */
-        inline
-        double value_outside (const size_t idx, const double h) const
-        {
-          WBAssert(idx <= mx_size_min, "Internal error: using value_inside outside the range of 0 to " << mx_size_min << ", but value was outside of this range: " << idx << ".");
-          WBAssert(!(static_cast<double>(idx) + h >= 0 && static_cast<double>(idx) + h <= 1.), "Internal error: using value_inside outside the range of 0 to " << mx_size_min << ", but value was outside of this range: " << static_cast<double>(idx) + h << " (h=" << h << ", idx = " << idx << ").");
-          return (m[idx][1]*h + m[idx][2])*h + m[idx][3];
-        }
-
-
-        /**
-         * number of x coordinates of points
-         */
-        size_t mx_size_min;
-
-        /**
-         * interpolation parameters
-         * \[
-         * f(x) = a*(x-x_i)^3 + b*(x-x_i)^2 + c*(x-x_i) + y_i
-         * \]
-         */
-        std::vector<std::array<double,4>> m; //m_a, m_b, m_c, m_y;
-
-      private:
-    };
-
-    /**
-     * A struct that is used to hold the return values of the function
-     * distance_point_from_curved_planes(). See there for a documentation
-     * of the meaning of the member variables. The variables are describing
-     * a where a point is with respect to a plane/surface. The surface is
-     * meshed by a grid. The axis parallel to the surface are formed by
-     * sections, and the axis perpendicuar to the surface are formed segments.
-     * Both sections and elements represent a whole cell in the grid, which is
-     * an integer. This structure also provides the fraction in each direction
-     * the closest point on the plane is along these two axes (sections and
-     * segments). These variables are called fractions.
-     *
-     * This structure furthermore provides the distance the provided point is
-     * from the closest point on the surface and the average angle. The variable
-     * local_thickness will not be automatically filled by the distance_point_from_curved_planes
-     * function.
-     */
-    struct PointDistanceFromCurvedPlanes
-    {
-      /**
-       * Constructor
-       */
-      PointDistanceFromCurvedPlanes(CoordinateSystem coordinate_system)
-        :
-        distance_from_plane(NaN::DSNAN),
-        distance_along_plane(NaN::DSNAN),
-        fraction_of_section(NaN::DSNAN),
-        fraction_of_segment(NaN::DSNAN),
-        section(NaN::ISNAN),
-        segment(NaN::ISNAN),
-        average_angle(NaN::DSNAN),
-        depth_reference_surface(NaN::DSNAN),
-        closest_trench_point(Point<3>(coordinate_system))
-      {}
-
-      /**
-       * The shortest distance between point and plane.
-       */
-      double distance_from_plane;
-
-      /**
-       * The distance between the start of the first segment (usually at
-       * the surface) to the provided point following the (curved) plane.
-       */
-      double distance_along_plane;
-
-      /**
-       * The fraction of the section that lies before the projected point
-       * on the plane (when looking from the start point of the section).
-       */
-      double fraction_of_section;
-
-      /**
-       * The fraction of the segment that lies before the projected point
-       * on the plane (when looking from the start point of the segment).
-       */
-      double fraction_of_segment;
-
-      /**
-       * The number of the section that is closest to the point
-       */
-      size_t section;
-
-      /**
-       * The number of the segment that is closest to the point.
-       */
-      size_t segment;
-
-      /**
-       * The average dip angle of the plane at the location where the
-       * point is projected onto the plane.
-       */
-      double average_angle;
-
-      /**
-       * The depth of the closest point on reference surface.
-       */
-      double depth_reference_surface;
-
-      /**
-       * The closest point on the trench line in cartesian coordinates.
-       */
-      Point<3> closest_trench_point;
-    };
-
-    /**
-     * Computes the distance of a point to a curved plane.
-     * TODO: add more info on how this works/is implemented.
-     * \param check_point This is the cartesian point of which we want to know the
-     * distance to the curved planes
-     * \param check_point_natural the check_point in the natural coordinates of the
-     * current coordinate system.
-     * \param reference_point This is a 2d point in natural coordinates at the
-     * surface which the curved planes dip towards. Natural coordinates are in
-     * cartesian (x,y,z) in meters and in spherical radius in meters and longitude
-     * and latitude in radians.
-     * \param point_list This is a vector of 2d Points in natural coordinates at the
-     * surface which define the line along the surface at which the curved planes
-     * start. Natural coordinates are in cartesian (x,y,z) in meters and in spherical
-     * radius in meters and longitude and latitude in radians.
-     * \param plane_segment_lengths This is a vector of vectors of doubles. It contains
-     * the length of every segment at point in the point_list (in the same order as
-     * the point_list.
-     * \param plane_segment_angles This is a vector of vectors of 2d points. It contains
-     * the begin and end angle of every segment at point in the point_list (in the same
-     * order as the point_list.
-     * \param start_radius This value contains the radius or height from bottom of the box
-     * at which the plane starts. This means that the start_radius effectively becomes the
-     * surface for this slab.
-     * \param coordinate_system This is a reference to the coordinate system of the
-     * World Builder. This is used to convert cartesian to natural coordinates and back.
-     * \param only_positive This value determines whether only the part below the
-     * plane should count as distance or both sides of the plane. It is called only_positive
-     * because the area below the plane, the distance is positive, and above the plane the
-     * distance is negative.
-     * \param interpolation_type This value determines what interpolation type should be used
-     * when determining the location with respect to the curved plane.
-     * \param spline_x the spline representing the x coordinate.
-     * \param spline_y the spline representing the y coordinate.
-     * \param global_x_list This is a list of one dimensional coorindates, with zero or the
-     * amount of coordinates entries, used for interpolation. An empty list is interpreted
-     * as a list filled with {0,1,2,...,number of coordinates}. Filling this list with other
-     * values changes the returned section fraction. It allows for, for example, adding
-     * extra coordinates automatically, and still reference the user provided coordinates by
-     * the original number. Note that no whole numbers may be skipped. So for a list of 4 points,
-     * {0,0.5,1,2} is allowed, but {0,2,3,4} is not.
-     *
-     * The function returns a struct that contains which segment and section of the curved
-     * planes the point is closest to, what fraction of those segment and section lies before
-     * the point (looking from the start of segment/section), the distance
-     * of the point from the plane and the distance of the point along the plane,
-     * and the average angle of the closest segment/section.
-     */
-    PointDistanceFromCurvedPlanes distance_point_from_curved_planes(const Point<3> &check_point,
-                                                                    const Objects::NaturalCoordinate &check_point_natural,
-                                                                    const Point<2> &reference_point,
-                                                                    const std::vector<Point<2> > &point_list,
-                                                                    const std::vector<std::vector<double> > &plane_segment_lengths,
-                                                                    const std::vector<std::vector<Point<2> > > &plane_segment_angles,
-                                                                    const double start_radius,
-                                                                    const std::unique_ptr<CoordinateSystems::Interface> &coordinate_system,
-                                                                    const bool only_positive,
-                                                                    const Objects::BezierCurve &bezier_curve);
-
-
-
-    /**
-     * Ensure angle is between 0 and 360 degrees
-     */
-    double wrap_angle(const double angle);
-
-    /**
-     * Interpolate between two angles (angle1 and angle2),
-     * with fraction defining the weighting between the two,
-     * taking into account we might cross over from 360 to 0 degrees.
-     */
-    double interpolate_angle_across_zero(const double angle_1,
-                                         const double angle_2,
-                                         const double fraction);
-
-    /**
-     * Transform a rotation matrix into euler angles
-     */
-    std::array<double,3>
-    euler_angles_from_rotation_matrix(const std::array<std::array<double,3>,3> &rotation_matrix);
-
-    /**
-     * Transform euler angles into a rotation matrix
-     */
-    std::array<std::array<double,3>,3>
-    euler_angles_to_rotation_matrix(double phi1, double theta, double phi2);
-
-    /**
-     * Read a file and distribute the content over all MPI processes.
-     * If WB_WITH_MPI is not defined, this function will just read the file.
-     *
-     * @param filename The name of the file to read.
-     * @return The content of the file.
-    */
-    std::string
-    read_and_distribute_file_content(const std::string &filename);
-
-    /**
-     * Calculate the distance of a point from a mid oceanic ridge, and also calculate
-     * the spreading velocity of the ridge at this point.
-     * TODO: make the spreading velocity spatially/temporally variable
-     *
-     * @param mid_oceanic_ridges The coordinates of the mid oceanic ridges
-     * @param mid_oceanic_spreading_velocities The spreading rate of the mid oceanic ridges at each ridge coordinate
-     * @param coordinate_system The coordinate system
-     * @param position_in_natural_coordinates_at_min_depth the current position in natural_coordinates
-     * @param subducting_plate_velocities the subducting plate velocities, currently this is only an optional parameter
-     * that can be used in the mass conserving subducting plate temperature model. This parameter allows the user to
-     * track the effect of ridge migration on the slab thermal structure
-     * @param ridge_migration_times the times that the corresponding section of the ridge has been moving, in years. This
-     * is used in combination with subducting_plate_velocities, and mid_oceanic_spreading_velocities to compute the distance
-     * that the spreading center has migrated. This vector is obtained from the input parameter "spreading velocity" in the
-     * mass conserving model when "spreading velocity" has the form: [ [t1,[[v11, v12, ...]], [t2,[[v21, v22, ...]], ... ].
-     * where tn is the time that ridge section n has been moving.
-     * @return The content of the file.
-    */
-    std::vector<double>
-    calculate_ridge_distance_and_spreading(std::vector<std::vector<Point<2>>> mid_oceanic_ridges,
-                                           std::vector<std::vector<double>> mid_oceanic_spreading_velocities,
-                                           const std::unique_ptr<WorldBuilder::CoordinateSystems::Interface> &coordinate_system,
-                                           const Objects::NaturalCoordinate &position_in_natural_coordinates_at_min_depth,
-                                           const std::vector<std::vector<double>> &subducting_plate_velocities,
-                                           const std::vector<double> &ridge_migration_times);
-
-    // todo_effective
-    /**
-     * Calculate the effective plate ages of a point on the slab surface, and also calculates
-     * the effective trench ages at the start of subduction.
-     * @param ridge_parameters The distance and spreading velocity relative to a mid ocean ridge
-     * @param distance_along_plane The distance along the slab surface plane
-     * @return The effective plate age and the trench age
-    */
-    std::vector<double>
-    calculate_effective_trench_and_plate_ages(std::vector<double> ridge_parameters, double distance_along_plane);
-
-  } // namespace Utilities
-} // namespace WorldBuilder
-
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/world.h.bak b/contrib/world_builder/include/world_builder/world.h.bak
deleted file mode 100644
index 0627eb60d84..00000000000
--- a/contrib/world_builder/include/world_builder/world.h.bak
+++ /dev/null
@@ -1,316 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_WORLD_H
-#define WORLD_BUILDER_WORLD_H
-
-#include "world_builder/grains.h"
-#include "world_builder/parameters.h"
-#include "world_builder/utilities.h"
-#include "world_builder/objects/distance_from_surface.h"
-
-#include <random>
-
-/**
-* The global namespace for the Geodynamic World Builder
-*/
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    class Interface;
-  } // namespace Features
-
-  class World
-  {
-    public:
-      /**
-       * Constructor. This constructor requires the parameter filename. Other parameters
-       * are optional.
-       * \param filename  a string with the location of
-       * the world builder file to initialize the world.
-       * \param has_output_dir a bool indicating whether the world builder is allowed to
-       * write out information to a directly.
-       * \param output_dir a string with the location of the directory where the world builder
-       * is allowed to write information to if it is allowed by the bool has_output_dir.
-       * \param random_number_seed a double containing a seed for the random number generator.
-       * The world builder uses a deterministic random number generator for some plugins. This
-       * is a deterministic random number generator on prorpose because even though you might
-       * want to use random numbers to initialize some fields, the result should be reproducible.
-       * Note that when the world builder is used in for example MPI programs you should supply
-       * the world builder created each MPI process a different seed. You can use the MPI RANK
-       * for this (seed is seed + MPI_RANK). Because the generator is deterministic (known and
-       * documented algorithm), we can test the results and they should be the same even for different
-       * compilers and machines.
-       */
-      World(std::string filename, bool has_output_dir = false, const std::string &output_dir = "", unsigned long random_number_seed = 1, const bool limit_debug_consistency_checks = true);
-
-      /**
-       * Destructor
-       */
-      ~World();
-
-
-      /**
-       * Describe what the world builder file should look like
-       */
-      static void declare_entries(Parameters &prm);
-
-      /**
-       * read in the world builder file
-       */
-      void parse_entries(Parameters &prm);
-
-      /**
-       * Returns different values at a single point in one go stored in a vector of doubles.
-       *
-       * The properties input decides what each entry means, and the output is generated in the
-       * same order as the properties input. The properties input consists of
-       * a 3D array, where the first entry identifies the property and the last two entries
-       * provide extra information about that property.
-       *
-       * Temperature is identified by 1 and no extra information is needed. So temperature
-       * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
-       * vector.
-       *
-       * Composition is identified by 2. This produces one
-       * value in the output. The second entry  identifies the composition number and the third
-       * number is not used. So a commposition query asking about composition 1 looks like this:
-       * {2,1,0}. A composition query prodoces one entry in the output vector.
-       *
-       * Grains are identified by 2. The second entry is the grain composition number and the third
-       * entry is the number of grains. A query about the grains, where it asks about composition 1
-       * (for example enstatite) and 500 grains, looks like this: {2,1,500}.
-       * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
-       * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
-       * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
-       */
-      std::vector<double> properties(const std::array<double, 2> &point,
-                                     const double depth,
-                                     const std::vector<std::array<unsigned int,3>> &properties) const;
-
-      /**
-       * Returns different values at a single point in one go stored in a vector of doubles.
-       *
-       * The properties input decides what each entry means, and the output is generated in the
-       * same order as the properties input. The properties input consists of
-       * a 3D array, where the first entry identifies the property and the last two entries
-       * provide extra information about that property.
-       *
-       * Temperature is identified by 1 and no extra information is needed. So temperature
-       * input usually looks like {1,0,0}. A temperature query prodoces one entry in the output
-       * vector.
-       *
-       * Composition is identified by 2. This produces one
-       * value in the output. The second entry  identifies the composition number and the third
-       * number is not used. So a composition query asking about composition 1 looks like this:
-       * {2,1,0}. A composition query prodoces one entry in the output vector.
-       *
-       * Grains are identified by 3. The second entry is the grain composition number and the third
-       * entry is the number of grains. A query about the grains, where it asks about composition 1
-       * (for example enstatite) and 500 grains, looks like this: {3,1,500}.
-       * A composition query prodoces n_grains*10 entries in the output vector. The first n_grains
-       * entries are the sizes of all the grains, and the other 9 entries are sets of rotation
-       * matrices. The rotation matrix entries are ordered [0][0],[0][1],[0][2],[1][0],[1][1],etc.
-       *
-       * The tag is identified by 4 and no extra information is needed. So the tag
-       * input usually looks like {4,0,0}. A tag query prodoces one entry in the output
-       * vector, representing the index of the tag of the last/dominant feature.
-       */
-      std::vector<double> properties(const std::array<double, 3> &point,
-                                     const double depth,
-                                     const std::vector<std::array<unsigned int,3>> &properties) const;
-
-      /**
-       * Returns the temperature based on a 2d Cartesian point, the depth in the
-       * model at that point and the gravity norm at that point.
-       */
-      double temperature(const std::array<double, 2> &point, const double depth) const;
-
-      /**
-       * Returns the temperature based on a 3d Cartesian point, the depth in the
-       * model at that point and the gravity norm at that point.
-       */
-      double temperature(const std::array<double, 3> &point, const double depth) const;
-
-      /**
-       * Returns the temperature based on a 2d Cartesian point, the depth in the
-       * model at that point and the gravity norm at that point.
-       * Note: gravity norm is no longer used, instead use the gravity model from the input file.
-       */
-      [[deprecated("Replaced by a temperature function without the gravity. This function will be removed in future versions.")]]
-      double temperature(const std::array<double, 2> &point, const double depth, const double gravity_norm) const;
-
-      /**
-       * Returns the temperature based on a 3d Cartesian point, the depth in the
-       * model at that point and the gravity norm at that point.
-       * Note: gravity norm is no longer used, instead use the gravity model from the input file.
-       */
-      [[deprecated("Replaced by a temperature function without the gravity. This function will be removed in future versions.")]]
-      double temperature(const std::array<double, 3> &point, const double depth, const double gravity_norm) const;
-
-      /**
-       * Returns the composition value based on a 2d Cartesian point, the depth in
-       * the model at that point and the gravity norm at that point.
-       */
-      double composition(const std::array<double, 2> &point, const double depth, const unsigned int composition_number) const;
-
-      /**
-       * Returns the composition value based on a 3d Cartesian point, the depth in
-       * the model at that point and the gravity norm at that point.
-       */
-      double composition(const std::array<double, 3> &point, const double depth, const unsigned int composition_number) const;
-
-      /**
-       * Returns the grain orientations and sizes based on a 2d Cartesian point, the depth in
-       * the model at that point and the gravity norm at that point.
-       */
-      WorldBuilder::grains grains(const std::array<double, 2> &point,
-                                  const double depth,
-                                  const unsigned int composition_number,
-                                  size_t number_of_grains) const;
-
-      /**
-       * Returns the grain orientations and sizes based on a 3d Cartesian point, the depth in
-       * the model at that point and the gravity norm at that point.
-       */
-      WorldBuilder::grains grains(const std::array<double, 3> &point,
-                                  const double depth,
-                                  const unsigned int composition_number,
-                                  size_t number_of_grains) const;
-      /**
-       * Returns a PlaneDistances object that has the distance from and along a feature plane,
-       * calculated from the coordinates and the depth of the point.
-       \param point the coordinates in the cartesian geometry
-       \param depth the depth of the point
-       \param name the name of the feature (i.e. the string provided to the key word "name" in the wb file)
-      */
-      Objects::PlaneDistances
-      distance_to_plane(const std::array<double, 3> &point,
-                        const double depth,
-                        const std::string &name) const;
-
-      /**
-       * The MPI rank. Set to zero if MPI is not available.
-       */
-      int MPI_RANK;
-
-      /**
-       * The MPI size. Set to one if MPI is not available.
-       */
-      int MPI_SIZE;
-
-      /**
-       * Return a reference to the mt19937 random number.
-       * The seed is provided to the world builder at construction.
-       */
-      std::mt19937 &get_random_number_engine();
-
-      /**
-       * This is the parameter class, which stores all the values loaded in
-       * from the parameter file or which are set directly.
-       */
-      Parameters parameters;
-
-      /**
-       * Todo
-       */
-      std::vector<Point<2> > cross_section;
-
-      /**
-       * Todo
-       */
-      Point<2> surface_coord_conversions;
-
-      /**
-       * Todo
-       */
-      double potential_mantle_temperature;
-
-      /**
-       * Todo
-       */
-      double surface_temperature;
-
-      /**
-       * Todo
-       */
-      bool force_surface_temperature;
-
-      /**
-       * Todo
-       */
-      double thermal_expansion_coefficient;
-
-      /**
-       * Todo
-       */
-      double specific_heat;
-
-      /**
-       * Todo
-       */
-      double thermal_diffusivity;
-
-      /**
-       * Todo
-       */
-      double maximum_distance_between_coordinates;
-
-      /**
-       * Todo
-       */
-      std::string interpolation;
-
-      /**
-       * A list of all the feature tags.
-       */
-      std::vector<std::string> feature_tags;
-
-    private:
-      /**
-       * The minimum dimension. If cross section data is provided, it is set
-       * to 2, which means the 2d function of temperature and composition can
-       * be used. Otherwise it is set to 3, which means that they can't be
-       * used.
-       */
-      unsigned int dim;
-
-
-      /**
-       * random number generator engine
-       */
-      std::mt19937 random_number_engine;
-
-      /**
-       * limits some of the consistency checks in debug mode.
-       * Current only prevents a check whether depth in spherical
-       * coordinates is consistent with the computed depth from
-       * x,y,z and provided radius.
-       * Note: Recommended to keep it at false, unless you know what you are doing.
-       */
-      bool limit_debug_consistency_checks;
-
-
-
-  };
-} // namespace WorldBuilder
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/wrapper_c.h.bak b/contrib/world_builder/include/world_builder/wrapper_c.h.bak
deleted file mode 100644
index e1598ab666b..00000000000
--- a/contrib/world_builder/include/world_builder/wrapper_c.h.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_WRAPPER_C_H
-#define WORLD_BUILDER_WRAPPER_C_H
-
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * This function creates an object of the world builder and returns a pointer
- * to it. This pointer can then be used to call the temperature and composition
- * functions. When done call the release world function to destroy the object.
- */
-void create_world(void **ptr_ptr_world, const char *world_builder_file, const bool *has_output_dir, const char *output_dir, const unsigned long random_number_seed);
-
-/**
- * This function return the temperature at a specific location given x, z, depth and
- * gravity.
- * Note: gravity value is no longer used, instead use the gravity model from the input file.
- */
-void temperature_2d(void *ptr_ptr_world, double x, double z, double depth, double *temperature);
-
-/**
- * This function return the temperature at a specific location given x, y, z, depth and
- * gravity.
- */
-void temperature_3d(void *ptr_ptr_world, double x, double y, double z, double depth, double *temperature);
-
-/**
- * This function return the composition at a specific location given x, z, depth and
- * composition number.
- */
-void composition_2d(void *ptr_ptr_world, double x, double z, double depth, unsigned int composition_number, double *composition);
-
-/**
- * This function return the composition at a specific location given x, y, z, depth and
- * composition number.
- */
-void composition_3d(void *ptr_ptr_world, double x, double y, double z, double depth, unsigned int composition_number, double *composition);
-
-/**
- * The destructor for the world builder class. Call this function when done with the
- * world builder.
- */
-void release_world(void *ptr_ptr_world);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/contrib/world_builder/include/world_builder/wrapper_cpp.h.bak b/contrib/world_builder/include/world_builder/wrapper_cpp.h.bak
deleted file mode 100644
index 610ff1bbc58..00000000000
--- a/contrib/world_builder/include/world_builder/wrapper_cpp.h.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#ifndef WORLD_BUILDER_WRAPPER_CPP_H
-#define WORLD_BUILDER_WRAPPER_CPP_H
-
-#include <string>
-#include "world_builder/deprecate.h"
-
-namespace wrapper_cpp
-{
-  /**
-   * This class is to be used by SWIG. To make it easy for SWIG we do not use any
-   * other world builder header file in this header file. This means that the class
-   * stores a void pointer internally. The cpp implementation can use the world builder
-   * header files.
-   */
-  class WorldBuilderWrapper
-  {
-    public:
-      /**
-       * constructor
-       */
-      WorldBuilderWrapper(std::string filename, bool has_output_dir = false, const std::string &output_dir = "", const unsigned long random_number_seed = 1.0);
-
-      /**
-       * destructor
-       */
-      ~WorldBuilderWrapper();
-
-      /**
-       * This function return the temperature at a specific location given x, z, depth and
-       * gravity.
-       */
-      double temperature_2d(double x, double z, double depth);
-
-      /**
-       * This function return the temperature at a specific location given x, y, z, depth and
-       * gravity.
-       */
-      double temperature_3d(double x, double y, double z, double depth);
-
-      /**
-       * DEPRECATED: Replaced by a temperature function without the gravity. This function will be removed in future versions.
-       * This function return the temperature at a specific location given x, z, depth and
-       * gravity.
-       * Note: gravity value is no longer used, instead use the gravity model from the input file.
-       */
-      double temperature_2d(double x, double z, double depth, double gravity);
-
-      /**
-       * DEPRECATED: Replaced by a temperature function without the gravity. This function will be removed in future versions.
-       * This function return the temperature at a specific location given x, y, z, depth and
-       * gravity.
-       * Note: gravity value is no longer used, instead use the gravity model from the input file.
-       */
-      double temperature_3d(double x, double y, double z, double depth, double gravity);
-
-      /**
-       * This function return the composition at a specific location given x, z, depth and
-       * composition number.
-       */
-      double composition_2d(double x, double z, double depth, unsigned int composition_number);
-
-      /**
-       * This function return the composition at a specific location given x, y, z, depth and
-       * composition number.
-       */
-      double composition_3d(double x, double y, double z, double depth, unsigned int composition_number);
-
-
-    private:
-      void *ptr_ptr_world;
-
-
-  };
-} // namespace wrapper_cpp
-#endif
diff --git a/contrib/world_builder/source/gwb-dat/main.cc.bak b/contrib/world_builder/source/gwb-dat/main.cc.bak
deleted file mode 100644
index 0ef4ca636a2..00000000000
--- a/contrib/world_builder/source/gwb-dat/main.cc.bak
+++ /dev/null
@@ -1,343 +0,0 @@
-/*
-  Copyright (C) 2018 - 2021 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-
-#include "app/main.h"
-
-#include "world_builder/assert.h"
-#include "world_builder/consts.h"
-#include "world_builder/point.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-#ifdef WB_WITH_MPI
-// we don't need the c++ MPI wrappers
-#define OMPI_SKIP_MPICXX 1
-#define MPICH_SKIP_MPICXX
-#include <mpi.h>
-#endif
-
-#include <algorithm>
-#include <fstream>
-#include <iostream>
-#include <memory>
-
-#ifndef NDEBUG
-#ifdef WB_USE_FP_EXCEPTIONS
-#include <cfenv>
-#endif
-#endif
-
-using namespace WorldBuilder::Utilities;
-
-bool find_command_line_option(char **begin, char **end, const std::string &option)
-{
-  return std::find(begin, end, option) != end;
-}
-
-int main(int argc, char **argv)
-{
-
-#ifndef NDEBUG
-#ifdef WB_USE_FP_EXCEPTIONS
-  // Some implementations seem to not initialize the floating point exception
-  // bits to zero. Make sure we start from a clean state.
-  feclearexcept(FE_DIVBYZERO|FE_INVALID);
-
-  // enable floating point exceptions
-  feenableexcept(FE_DIVBYZERO|FE_INVALID);
-#endif
-#endif
-
-  /**
-   * First parse the command line options
-   */
-  std::string wb_file;
-  std::string data_file;
-
-  unsigned int dim = 3;
-  unsigned int compositions = 0;
-  unsigned int grain_compositions = 0;
-  size_t n_grains = 0;
-  bool convert_spherical = false;
-  bool limit_debug_consistency_checks = false;
-  bool output_json_files = false;
-
-  if (find_command_line_option(argv, argv+argc, "-h") || find_command_line_option(argv, argv+argc, "--help"))
-    {
-      std::cout << "This program allows to use the world builder library directly with a world builder file and a data file. "
-                "The data file will be filled with initial conditions from the world as set by the world builder file." << std::endl
-                << "Besides providing two files, where the first is the world builder file and the second is the data file, the available options are: " << std::endl
-                << "-h or --help to get this help screen." << std::endl;
-      return 0;
-    }
-
-  if (find_command_line_option(argv, argv+argc, "-ldcc") || find_command_line_option(argv, argv+argc, "--limit-debug-consistency-checks"))
-    limit_debug_consistency_checks = true;
-
-  if (find_command_line_option(argv, argv+argc, "--output-json-files"))
-    output_json_files = true;
-
-  if (argc == 1)
-    {
-      std::cout << "Error: There where no files passed to the World Builder, use --help for more " << std::endl
-                << "information on how  to use the World Builder app." << std::endl;
-      return 0;
-    }
-
-
-  if (argc == 2)
-    {
-      std::cout << "Error:  The World Builder app requires at least two files, a World Builder file " << std::endl
-                << "and a data file to convert." << std::endl;
-      return 0;
-    }
-
-  if ((argc == 3 && limit_debug_consistency_checks && output_json_files) || (argc == 4 && !(!limit_debug_consistency_checks != !output_json_files)) || (argc == 5 && (!limit_debug_consistency_checks && !output_json_files)) || argc > 5)
-    {
-      std::cout << "Only exactly two command line arguments may be given, which should be the world builder file location and the data file location (in that order) "
-                << "or exactly three command line arguments, which should be the world builder file location, the data file location and --limit-debug-consistency-checks or --output-json-files (in that order),"
-                "or exactly four command line arguments, which should be the world builder file location, the data file location and --limit-debug-consistency-checks and --output-json-files (in that order),"
-                << ", argc = " << argc << ", limit_debug_consistency_checks = " << (limit_debug_consistency_checks ? "true" : "false") << ", output_json_files = " << (output_json_files ? "true" : "false") << std::endl;
-      return 0;
-    }
-
-  int MPI_RANK = 0;
-#ifdef WB_WITH_MPI
-  int MPI_SIZE = 1;
-  MPI_Init(&argc,&argv);
-  MPI_Comm_rank(MPI_COMM_WORLD, &MPI_RANK);
-  MPI_Comm_size(MPI_COMM_WORLD, &MPI_SIZE);
-#endif
-
-  if (MPI_RANK == 0)
-    {
-      wb_file = argv[1];
-      data_file = argv[2];
-
-      /**
-       * Try to start the world builder
-       */
-      std::unique_ptr<WorldBuilder::World> world;
-      //try
-      {
-        const std::string output_dir = wb_file.substr(0,wb_file.find_last_of("/\\") + 1);
-        world = std::make_unique<WorldBuilder::World>(wb_file, output_json_files, output_dir,1,limit_debug_consistency_checks);
-      }
-      /*catch (std::exception &e)
-        {
-          std::cerr << "Could not start the World builder, error: " << e.what() << "\n";
-          return 1;
-        }
-      catch (...)
-        {
-          std::cerr << "Exception of unknown type!\n";
-          return 1;
-        }*/
-
-
-      /**
-       * Read the data from the data files
-       */
-      std::ifstream data_stream(data_file);
-
-      // move the data into a vector of strings
-      std::vector<std::vector<std::string> > data;
-      std::string temp;
-
-      while (std::getline(data_stream, temp))
-        {
-          std::istringstream buffer(temp);
-          std::vector<std::string> line((std::istream_iterator<std::string>(buffer)),
-                                        std::istream_iterator<std::string>());
-
-          // remove the comma's in case it is a comma separated file.
-          // TODO: make it split for comma's and/or spaces
-          for (auto &line_i : line)
-            line_i.erase(std::remove(line_i.begin(), line_i.end(), ','), line_i.end());
-
-          data.push_back(line);
-        }
-
-      // Read config from data if present
-      for (auto &line_i : data)
-        {
-          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "dim" && line_i[2] == "=")
-            {
-              dim = string_to_unsigned_int(line_i[3]);
-            }
-
-          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "compositions" && line_i[2] == "=")
-            compositions = string_to_unsigned_int(line_i[3]);
-
-          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "grain" && line_i[2] == "compositions" && line_i[3] == "=")
-            grain_compositions = string_to_unsigned_int(line_i[4]);
-
-          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "number" && line_i[2] == "of" && line_i[3] == "grains" && line_i[4] == "=")
-            n_grains = string_to_unsigned_int(line_i[5]);
-
-          if (!line_i.empty() && line_i[0] == "#" && line_i[1] == "convert" && line_i[2] == "spherical" && line_i[3] == "=" && line_i[4] == "true")
-            convert_spherical = true;
-        }
-
-      // set properties
-      std::vector<std::array<unsigned ,3>> properties;
-      properties.push_back({{1,0,0}}); // temperature
-
-      for (size_t c = 0; c < compositions; ++c)
-        properties.push_back({{2,static_cast<unsigned int>(c),0}}); // composition c
-
-      for (size_t gc = 0; gc < grain_compositions; ++gc)
-        properties.push_back({{3,static_cast<unsigned int>(gc),static_cast<unsigned int>(n_grains)}}); // grains gc
-
-      properties.push_back({{4,0,0}}); // tag
-
-
-      switch (dim)
-        {
-          case 2:
-            WBAssertThrow(!convert_spherical, "Converting to spherical values is only available in 3D.");
-            // set the header
-            std::cout << "# x z d T ";
-
-            for (unsigned int c = 0; c < compositions; ++c)
-              std::cout << 'c' << c << ' ';
-
-            for (unsigned int gc = 0; gc < grain_compositions; ++gc)
-              for (size_t g = 0; g < n_grains; g++)
-                std::cout << "gs" << gc << '-' << g << ' ' // gs = grain size, gm = grain rotation matrix
-                          << "gm" << gc << '-' << g << "[0:0] " << "gm" << gc << '-' << g << "[0:1] " << "gm" << gc << '-' << g << "[0:2] "
-                          << "gm" << gc << '-' << g << "[1:0] " << "gm" << gc << '-' << g << "[1:1] " << "gm" << gc << '-' << g << "[1:2] "
-                          << "gm" << gc << '-' << g << "[2:0] " << "gm" << gc << '-' << g << "[2:1] " << "gm" << gc << '-' << g << "[2:2] ";
-
-            std::cout << "tag ";
-            std::cout <<std::endl;
-
-            // set the values
-            for (unsigned int i = 0; i < data.size(); ++i)
-              if (data[i].size() > 0 && data[i][0] != "#")
-                {
-
-                  WBAssertThrow(data[i].size() == dim + 1, "The file needs to contain dim + 1 entries, but contains " << data[i].size() << " entries "
-                                " on line " << i+1 << " of the data file (" << data_file << ").  Dim is " << dim << '.');
-                  const std::array<double,2> coords = {{
-                      string_to_double(data[i][0]),
-                      string_to_double(data[i][1])
-                    }
-                  };
-                  std::cout << data[i][0] << ' ' << data[i][1] << ' ' << data[i][2] << ' ';
-                  std::vector<double> output = world->properties(coords, string_to_double(data[i][2]),properties);
-                  std::cout << output[0]  << ' ';
-
-                  for (unsigned int c = 0; c < compositions; ++c)
-                    {
-                      std::cout << output[1+c]  << ' ';
-                    }
-
-                  for (unsigned int gc = 0; gc < grain_compositions; ++gc)
-                    {
-                      const size_t start = 1+compositions+gc*n_grains*10;
-                      for (unsigned int g = 0; g < n_grains; ++g)
-                        {
-                          std::cout << output[start+g]  << ' '
-                                    << output[start+n_grains+g*9] << ' ' << output[start+n_grains+g*9+1] << ' ' << output[start+n_grains+g*9+2] << ' '
-                                    << output[start+n_grains+g*9+3] << ' ' << output[start+n_grains+g*9+4] << ' ' << output[start+n_grains+g*9+5] << ' '
-                                    << output[start+n_grains+g*9+6] << ' ' << output[start+n_grains+g*9+7] << ' ' << output[start+n_grains+g*9+8] << ' ';
-
-                        }
-                    }
-                  std::cout << " " << output[output.size()-1] << std::endl;
-
-                }
-            break;
-          case 3:
-            // set the header
-            std::cout << "# x y z d g T ";
-
-            for (unsigned int c = 0; c < compositions; ++c)
-              std::cout << 'c' << c << ' ';
-
-            for (unsigned int gc = 0; gc < grain_compositions; ++gc)
-              for (size_t g = 0; g < n_grains; g++)
-                std::cout << "gs" << gc << '-' << g << ' ' // gs = grain size, gm = grain rotation matrix
-                          << "gm" << gc << '-' << g << "[0:0] " << "gm" << gc << '-' << g << "[0:1] " << "gm" << gc << '-' << g << "[0:2] "
-                          << "gm" << gc << '-' << g << "[1:0] " << "gm" << gc << '-' << g << "[1:1] " << "gm" << gc << '-' << g << "[1:2] "
-                          << "gm" << gc << '-' << g << "[2:0] " << "gm" << gc << '-' << g << "[2:1] " << "gm" << gc << '-' << g << "[2:2] ";
-
-            std::cout << "tag ";
-            std::cout <<std::endl;
-
-            // set the values
-            for (unsigned int i = 0; i < data.size(); ++i)
-              if (data[i].size() > 0 && data[i][0] != "#")
-                {
-                  WBAssertThrow(data[i].size() == dim + 1, "The file needs to contain dim + 1 entries, but contains " << data[i].size() << " entries "
-                                " on line " << i+1 << " of the data file (" << data_file << "). Dim is " << dim << '.');
-                  std::array<double,3> coords = {{
-                      string_to_double(data[i][0]), // x or R
-                      string_to_double(data[i][1]) *(convert_spherical ? (WorldBuilder::Consts::PI/180.): 1.), // y or long
-                      string_to_double(data[i][2]) *(convert_spherical ? (WorldBuilder::Consts::PI/180.): 1.) // z or lat
-                    }
-                  };
-
-                  if (convert_spherical)
-                    {
-                      coords = spherical_to_cartesian_coordinates(coords).get_array();
-                    }
-
-                  std::cout << data[i][0] << ' ' << data[i][1] << ' ' << data[i][2] << ' ' << data[i][3] << ' ';
-                  std::vector<double> output = world->properties(coords, string_to_double(data[i][3]),properties);
-                  std::cout << output[0]  << ' ';
-
-                  for (unsigned int c = 0; c < compositions; ++c)
-                    {
-                      std::cout << output[1+c]  << ' ';
-                    }
-
-                  for (unsigned int gc = 0; gc < grain_compositions; ++gc)
-                    {
-                      const size_t start = 1+compositions+gc*n_grains*10;
-                      for (unsigned int g = 0; g < n_grains; ++g)
-                        {
-                          std::cout << output[start+g]  << ' '
-                                    << output[start+n_grains+g*9] << ' ' << output[start+n_grains+g*9+1] << ' ' << output[start+n_grains+g*9+2] << ' '
-                                    << output[start+n_grains+g*9+3] << ' ' << output[start+n_grains+g*9+4] << ' ' << output[start+n_grains+g*9+5] << ' '
-                                    << output[start+n_grains+g*9+6] << ' ' << output[start+n_grains+g*9+7] << ' ' << output[start+n_grains+g*9+8] << ' ';
-
-                        }
-                    }
-                  std::cout << " " << output[output.size()-1] << std::endl;
-
-                }
-            break;
-          default:
-            std::cout << "The World Builder can only be run in 2d and 3d but a different space dimension " << std::endl
-                      << "is given: dim = " << dim << '.';
-
-#ifdef WB_WITH_MPI
-            MPI_Finalize();
-#endif
-            return 0;
-        }
-    }
-#ifdef WB_WITH_MPI
-  MPI_Finalize();
-#endif
-  return 0;
-}
diff --git a/contrib/world_builder/source/gwb-grid/main.cc.bak b/contrib/world_builder/source/gwb-grid/main.cc.bak
deleted file mode 100644
index a8b931b31a0..00000000000
--- a/contrib/world_builder/source/gwb-grid/main.cc.bak
+++ /dev/null
@@ -1,1672 +0,0 @@
-/*
-  Copyright (C) 2018 - 2021 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-/**
- * Much of this code was based on GHOST (https://github.com/cedrict/GHOST),
- * and was contribute to the World Builder with the permission and help of
- * the author of GHOST.
- */
-
-#include "visualization/main.h"
-
-#include "world_builder/assert.h"
-#include "world_builder/coordinate_system.h"
-#include "world_builder/nan.h"
-#include "world_builder/point.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-#include "world_builder/config.h"
-
-#include <algorithm>
-#include <limits>
-
-
-#include "vtu11/vtu11.hpp"
-#undef max
-#undef min
-
-#ifdef WB_WITH_MPI
-// we don't need the c++ MPI wrappers
-#define OMPI_SKIP_MPICXX 1
-#define MPICH_SKIP_MPICXX
-#include <mpi.h>
-#endif
-
-#ifndef NDEBUG
-#ifdef WB_USE_FP_EXCEPTIONS
-#include <cfenv>
-#endif
-#endif
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <iostream>
-#include <iterator>
-#include <memory>
-#include <string>
-#include <thread>
-#include <vector>
-
-using namespace WorldBuilder;
-using namespace WorldBuilder::Utilities;
-
-
-
-/**
- * Filter the cells of a VTU mesh based on a given tag. All tags with smaller value than @p first_tag will be removed
- */
-void filter_vtu_mesh(int dim,
-                     const std::vector<bool> &include_tag,
-                     vtu11::Vtu11UnstructuredMesh &input_mesh,
-                     const std::vector<vtu11::DataSetData> &input_data,
-                     vtu11::Vtu11UnstructuredMesh &output_mesh,
-                     std::vector<vtu11::DataSetData> &output_data);
-
-void filter_vtu_mesh(int dim,
-                     const std::vector<bool> &include_tag,
-                     vtu11::Vtu11UnstructuredMesh &input_mesh,
-                     const std::vector<vtu11::DataSetData> &input_data,
-                     vtu11::Vtu11UnstructuredMesh &output_mesh,
-                     std::vector<vtu11::DataSetData> &output_data)
-{
-  output_data.resize(input_data.size());
-  const std::int64_t invalid = -1;
-  std::vector<std::int64_t> vertex_index_map(input_mesh.points().size(), invalid);
-
-  const unsigned int n_vert_per_cell = (dim==3)?8:4;
-
-  const std::size_t n_cells = input_mesh.types().size();
-  std::uint64_t dst_cellid = 0;
-  for (std::size_t cellidx = 0; cellidx <n_cells; ++cellidx)
-    {
-      int highest_tag = -1;
-      for (size_t idx=cellidx*n_vert_per_cell; idx<(cellidx+1)*n_vert_per_cell; ++idx)
-        {
-          const std::size_t src_vid = static_cast<size_t>(input_mesh.connectivity()[idx]);
-          highest_tag = std::max(highest_tag,static_cast<int>(input_data[2][src_vid]));
-        }
-      if (highest_tag < 0 || include_tag[static_cast<size_t>(highest_tag)]==false)
-        continue;
-
-      ++dst_cellid;
-
-      for (size_t idx=cellidx*n_vert_per_cell; idx<(cellidx+1)*n_vert_per_cell; ++idx)
-        {
-          const size_t src_vid = static_cast<size_t>(input_mesh.connectivity()[idx]);
-
-          std::int64_t dst_vid = vertex_index_map[src_vid];
-          if (dst_vid == invalid)
-            {
-              dst_vid = static_cast<std::int64_t>(output_mesh.points().size()/3);
-              vertex_index_map[src_vid] = dst_vid;
-
-              for (unsigned int i=0; i<3; ++i)
-                output_mesh.points().push_back(input_mesh.points()[src_vid*3+i]);
-
-              for (unsigned int d=0; d<input_data.size(); ++d)
-                output_data[d].push_back(input_data[d][src_vid]);
-            }
-
-          output_mesh.connectivity().push_back(dst_vid);
-
-        }
-      output_mesh.offsets().push_back(static_cast<long int>(dst_cellid*n_vert_per_cell));
-
-      output_mesh.types().push_back(input_mesh.types()[cellidx]);
-    }
-}
-
-/**
- * A very simple threadpool class. The threadpool currently only supports a
- * parallel for function, to easily parallelize the for function.
- *
- * Todo: might need something more advanced and safe in the future.
- */
-class ThreadPool
-{
-  public:
-
-    /**
-     * Constructor
-     */
-    explicit ThreadPool(size_t number_of_threads)
-    {
-      pool.resize(number_of_threads);
-    }
-
-    /**
-     * A function which allows to parallelize for loops.
-     */
-    template<typename Callable>
-    void parallel_for(size_t start, size_t end, Callable func)
-    {
-      // Determine the size of the slice for the loop
-      const size_t n = end - start + 1;
-      size_t slice = static_cast<size_t>(std::round(n / static_cast<size_t>((pool.size()))));
-      slice = std::max(slice, static_cast<size_t>(1));
-
-      // Function which loops the passed function func
-      auto loop_function = [&func] (size_t k1, size_t k2)
-      {
-        for (size_t k = k1; k < k2; k++)
-          {
-            func(k);
-          }
-      };
-
-      // Launch jobs
-      size_t i1 = start;
-      size_t i2 = std::min(start + slice, end);
-      for (size_t i = 0; i + 1 < pool.size() && i1 < end; ++i)
-        {
-          pool[i] = std::thread(loop_function, i1, i2);
-          i1 = i2;
-          i2 = std::min(i2 + slice, end);
-        }
-      if (i1 < end)
-        {
-          pool[pool.size()-1] = std::thread(loop_function, i1, end);
-        }
-
-      // Wait for jobs to finish
-      for (std::thread &t : pool)
-        {
-          if (t.joinable())
-            {
-              t.join();
-            }
-        }
-    }
-
-  private:
-    std::vector<std::thread> pool;
-
-};
-
-
-void project_on_sphere(double radius, double &x_, double &y_, double &z_)
-{
-  double x = x_;
-  double y = y_;
-  double z = z_;
-  const WorldBuilder::Point<3> in_point(std::array<double,3> {{x,y,z}}, WorldBuilder::CoordinateSystem::cartesian);
-  const WorldBuilder::Point<3> output_point(std::array<double,3> {{0,0,0}}, WorldBuilder::CoordinateSystem::cartesian);
-  const double r = in_point.norm();
-  const double theta = std::atan2(in_point[1],in_point[0]);
-  const double phi = std::acos(in_point[2]/r);
-
-  x_ = radius * std::cos(theta) * std::sin(phi);
-  y_ = radius * std::sin(theta) * std::sin(phi);
-  z_ = radius * std::cos(phi);
-
-}
-
-void lay_points(double x1, double y1, double z1,
-                double x2, double y2, double z2,
-                double x3, double y3, double z3,
-                double x4, double y4, double z4,
-                std::vector<double> &x, std::vector<double> &y, std::vector<double> &z,
-                std::vector<bool> &hull, size_t level)
-{
-  // TODO: Assert that the vectors have the correct size;
-  size_t counter = 0;
-  for (size_t j = 0; j < level+1; ++j)
-    {
-      for (size_t i = 0; i < level+1; ++i)
-        {
-          // equidistant (is this irrelevant?)
-          // double r = -1.0 + (2.0 / level) * i;
-          // double s = -1.0 + (2.0 / level) * j;
-
-          // equiangular
-          const double pi4 = Consts::PI*0.25;
-          const double x0 = -pi4 + static_cast<double>(i) * 2.0 * static_cast<double>(pi4)/static_cast<double>(level);
-          const double y0 = -pi4 + static_cast<double>(j) * 2.0 * static_cast<double>(pi4)/static_cast<double>(level);
-          const double r = std::tan(x0);
-          const double s = std::tan(y0);
-
-
-          const double N1 = 0.25 * (1.0 - r) * (1.0 - s);
-          const double N2 = 0.25 * (1.0 + r) * (1.0 - s);
-          const double N3 = 0.25 * (1.0 + r) * (1.0 + s);
-          const double N4 = 0.25 * (1.0 - r) * (1.0 + s);
-
-          x[counter] = x1 * N1 + x2 * N2 + x3 * N3 + x4 * N4;
-          y[counter] = y1 * N1 + y2 * N2 + y3 * N3 + y4 * N4;
-          z[counter] = z1 * N1 + z2 * N2 + z3 * N3 + z4 * N4;
-
-          if (i == 0) hull[counter] = true;
-          if (j == 0) hull[counter] = true;
-          if (i == level) hull[counter] = true;
-          if (j == level) hull[counter] = true;
-          counter++;
-        }
-    }
-}
-
-
-std::vector<std::string> get_command_line_options_vector(int argc, char **argv)
-{
-  std::vector<std::string> vector;
-  for (int i=1; i < argc; ++i)
-    vector.emplace_back(argv[i]);
-
-  return vector;
-}
-
-bool find_command_line_option(char **begin, char **end, const std::string &option)
-{
-  return std::find(begin, end, option) != end;
-}
-
-int main(int argc, char **argv)
-{
-
-#ifndef NDEBUG
-#ifdef WB_USE_FP_EXCEPTIONS
-  // Some implementations seem to not initialize the floating point exception
-  // bits to zero. Make sure we start from a clean state.
-  feclearexcept(FE_DIVBYZERO|FE_INVALID);
-
-  // enable floating point exceptions
-  feenableexcept(FE_DIVBYZERO|FE_INVALID);
-#endif
-#endif
-
-  /**
-   * First parse the command line options
-   */
-  std::string wb_file;
-  std::string data_file;
-
-  // If set to true, we will output one visualization file per "tag"
-  // with only the cells corresponding to that tag included.
-  bool output_by_tag = false;
-  // If set to true, we output a .filtered.vtu file without the background/mantle
-  bool output_filtered = false;
-
-  size_t dim = 3;
-  size_t compositions = 0;
-
-  // common
-  std::string grid_type = "chunk";
-
-  size_t n_cell_x = NaN::ISNAN; // x or long
-  size_t n_cell_y = NaN::ISNAN; // y or lat
-  size_t n_cell_z = NaN::ISNAN; // z or depth
-
-
-  // spherical
-  double x_min = NaN::DSNAN;  // x or long
-  double x_max = NaN::DSNAN;  // x or long
-  double y_min = NaN::DSNAN; // y or lat
-  double y_max = NaN::DSNAN; // y or lat
-  double z_min = NaN::DSNAN; // z or inner_radius
-  double z_max = NaN::DSNAN; // z or outer_radius
-
-  // Conservative choice for the number of threads to use:
-  size_t number_of_threads = std::min(20u,1+std::thread::hardware_concurrency()/2);
-  unsigned int max_resolution = std::numeric_limits<unsigned int>::max();
-
-  try
-    {
-      if (find_command_line_option(argv, argv+argc, "-v") || find_command_line_option(argv, argv+argc, "--version"))
-        {
-          std::cout << "World Builder Grid Visualization tool.\n"
-                    << "GWB Version: " << WorldBuilder::Version::MAJOR << "."
-                    << WorldBuilder::Version::MINOR << "."
-                    << WorldBuilder::Version::PATCH << "."
-                    << WorldBuilder::Version::LABEL << "\n"
-                    << "git hash: " << WorldBuilder::Version::GIT_SHA1 << " branch: " << WorldBuilder::Version::GIT_BRANCH
-                    << std::endl;
-          return 0;
-        }
-
-      if (find_command_line_option(argv, argv+argc, "-h") || find_command_line_option(argv, argv+argc, "--help"))
-        {
-          std::cout << "World Builder Grid Visualization tool.\n"
-                    <<  "This program loads a world builder file and generates a visualization on a structured grid "
-                    << "based on information specified in a separate .grid configuration file.\n\n"
-                    << "Usage:\n"
-                    << argv[0] << " [-j N] [--filtered] [--by-tag] example.wb example.grid\n\n"
-                    << "Available options:\n"
-                    << "  -j N                  Specify the number of threads the visualizer is allowed to use. Default: " << number_of_threads << ".\n"
-                    << "  --filtered            Also produce a .filtered.vtu that removes cells only containing mantle or background.\n"
-                    << "  --by-tag              Also produce a sequence of .N.vtu files that only contain cells of a specific tag.\n"
-                    << "  --resolution-limit X  Specify a maximum resolution."
-                    << "  -h or --help          To get this help screen.\n"
-                    << "  -v or --version       To see version information.\n";
-          return 0;
-        }
-
-      std::vector<std::string> options_vector = get_command_line_options_vector(argc, argv);
-
-      for (size_t i = 0; i < options_vector.size(); ++i)
-        {
-          if (options_vector[i] == "-j")
-            {
-              number_of_threads = Utilities::string_to_unsigned_int(options_vector[i+1]);
-              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
-              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
-              --i;
-              continue;
-            }
-          if (options_vector[i] == "--filtered")
-            {
-              output_filtered = true;
-              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
-              --i;
-              continue;
-            }
-          if (options_vector[i] == "--by-tag")
-            {
-              output_by_tag = true;
-              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
-              --i;
-              continue;
-            }
-          if (options_vector[i] == "--resolution-limit")
-            {
-              max_resolution = Utilities::string_to_unsigned_int(options_vector[i+1]);
-              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
-              options_vector.erase(options_vector.begin()+static_cast<std::vector<std::string>::difference_type>(i));
-              --i;
-              continue;
-            }
-        }
-
-      if (options_vector.size() != 2)
-        {
-          std::cout << "World Builder Grid Visualization tool.\n"
-                    << "Usage: " << argv[0] << " example.wb example.grid\n"
-                    << "Try '" << argv[0] << " --help' for more information." << std::endl;
-          return 0;
-        }
-
-
-      wb_file = options_vector[0];
-      data_file = options_vector[1];
-
-    }
-  catch (std::exception &e)
-    {
-      std::cerr << "error: " << e.what() << "\n";
-      return 1;
-    }
-  catch (...)
-    {
-      std::cerr << "Exception of unknown type!\n";
-      return 1;
-    }
-
-
-  int MPI_RANK = 0;
-#ifdef WB_WITH_MPI
-  MPI_Init(&argc,&argv);
-  MPI_Comm_rank(MPI_COMM_WORLD, &MPI_RANK);
-#endif
-
-  std::cout << "[1/6] Parsing file...                         \r";
-
-  if (MPI_RANK ==  0)
-    {
-      /**
-       * Try to start the world builder
-       */
-      std::cout << "[2/6] Starting the world builder with " << number_of_threads << " threads...                         \r";
-      std::cout.flush();
-
-      std::unique_ptr<WorldBuilder::World> world;
-      try
-        {
-          world = std::make_unique<WorldBuilder::World>(wb_file);
-        }
-      catch (std::exception &e)
-        {
-          std::cerr << "Could not start the World builder from file '" << wb_file << "', error: " << e.what() << "\n";
-
-#ifdef WB_WITH_MPI
-          MPI_Finalize();
-#endif
-          return 1;
-        }
-      catch (...)
-        {
-          std::cerr << "Exception of unknown type!\n";
-
-#ifdef WB_WITH_MPI
-          MPI_Finalize();
-#endif
-          return 1;
-        }
-
-      /**
-       * start the thread pool
-       */
-      ThreadPool pool(number_of_threads);
-
-      /**
-       * Read the data from the data files
-       */
-      std::cout << "[3/6] Reading grid file...                        \r";
-      std::cout.flush();
-
-
-      std::ifstream data_stream(data_file);
-
-      // if config file is available, parse it
-      WBAssertThrow(data_stream.good(),
-                    "Could not find the provided config file at the specified location: " + data_file);
-
-
-      // move the data into a vector of strings
-      std::vector<std::vector<std::string> > data;
-      std::string temp;
-
-      while (std::getline(data_stream, temp))
-        {
-          std::istringstream buffer(temp);
-          std::vector<std::string> line((std::istream_iterator<std::string>(buffer)),
-                                        std::istream_iterator<std::string>());
-
-          // remove the comma's in case it is a comma separated file.
-          // TODO: make it split for comma's and/or spaces
-          for (auto &line_i : line)
-            line_i.erase(std::remove(line_i.begin(), line_i.end(), ','), line_i.end());
-
-          data.push_back(line);
-        }
-
-      std::string vtu_output_format = "RawBinaryCompressed";
-      // Read config from data if present
-      for (auto &line_i : data)
-        {
-          if (line_i.empty())
-            continue;
-
-          if (line_i[0] == "#")
-            continue;
-
-          if (line_i[0] == "grid_type" && line_i[1] == "=")
-            {
-              grid_type = line_i[2];
-            }
-
-          if (line_i[0] == "dim" && line_i[1] == "=")
-            {
-              dim = string_to_unsigned_int(line_i[2]);
-            }
-
-          if (line_i[0] == "vtu_output_format" && line_i[1] == "=")
-            {
-              vtu_output_format = line_i[2];
-            }
-
-          if (line_i[0] == "compositions" && line_i[1] == "=")
-            compositions = string_to_unsigned_int(line_i[2]);
-
-          if (line_i[0] == "x_min" && line_i[1] == "=")
-            x_min = string_to_double(line_i[2]);
-          if (line_i[0] == "x_max" && line_i[1] == "=")
-            x_max = string_to_double(line_i[2]);
-          if (line_i[0] == "y_min" && line_i[1] == "=")
-            y_min = string_to_double(line_i[2]);
-          if (line_i[0] == "y_max" && line_i[1] == "=")
-            y_max = string_to_double(line_i[2]);
-          if (line_i[0] == "z_min" && line_i[1] == "=")
-            z_min = string_to_double(line_i[2]);
-          if (line_i[0] == "z_max" && line_i[1] == "=")
-            z_max = string_to_double(line_i[2]);
-
-          if (line_i[0] == "n_cell_x" && line_i[1] == "=")
-            n_cell_x = std::min(string_to_unsigned_int(line_i[2]),max_resolution);
-          if (line_i[0] == "n_cell_y" && line_i[1] == "=")
-            n_cell_y = std::min(string_to_unsigned_int(line_i[2]),max_resolution);
-          if (line_i[0] == "n_cell_z" && line_i[1] == "=")
-            n_cell_z = std::min(string_to_unsigned_int(line_i[2]),max_resolution);
-
-        }
-
-      WBAssertThrow(dim == 2 || dim == 3, "dim should be set in the grid file and can only be 2 or 3.");
-
-      WBAssertThrow(!std::isnan(x_min), "x_min is not a number:" << x_min << ". This value has probably not been provided in the grid file.");
-      WBAssertThrow(!std::isnan(x_max), "x_max is not a number:" << x_max << ". This value has probably not been provided in the grid file.");
-      WBAssertThrow(dim == 2 || !std::isnan(y_min), "y_min is not a number:" << y_min << ". This value has probably not been provided in the grid file.");
-      WBAssertThrow(dim == 2 || !std::isnan(y_max), "y_max is not a number:" << y_max << ". This value has probably not been provided in the grid file.");
-      WBAssertThrow(!std::isnan(z_min), "z_min is not a number:" << z_min << ". This value has probably not been provided in the grid file.");
-      WBAssertThrow(!std::isnan(z_max), "z_max is not a number:" << z_max << ". This value has probably not been provided in the grid file.");
-
-
-      WBAssertThrow(n_cell_x != 0, "n_cell_z may not be equal to zero: " << n_cell_x << '.');
-      // int's cannot generally be nan's (see https://stackoverflow.com/questions/3949457/can-an-integer-be-nan-in-c),
-      // but visual studio is giving problems over this, so it is taken out for now.
-      //WBAssertThrow(!std::isnan(n_cell_x), "n_cell_z is not a number:" << n_cell_x << '.');
-
-      WBAssertThrow(dim == 3 || n_cell_z != 0, "In 3d n_cell_z may not be equal to zero: " << n_cell_y << '.');
-      // int's cannot generally be nan's (see https://stackoverflow.com/questions/3949457/can-an-integer-be-nan-in-c),
-      // but visual studio is giving problems over this, so it is taken out for now.
-      //WBAssertThrow(!std::isnan(n_cell_z), "n_cell_z is not a number:" << n_cell_y << '.');
-
-      WBAssertThrow(n_cell_z != 0, "n_cell_z may not be equal to zero: " << n_cell_z << '.');
-      // int's cannot generally be nan's (see https://stackoverflow.com/questions/3949457/can-an-integer-be-nan-in-c),
-      // but visual studio is giving problems over this, so it is taken out for now.
-      //WBAssertThrow(!std::isnan(n_cell_z), "n_cell_z is not a number:" << n_cell_z << '.');
-
-
-
-
-
-      /**
-       * All variables set by the user
-       */
-
-      if (grid_type == "sphere")
-        WBAssert(n_cell_x == n_cell_y, "For the sphere grid the amount of cells in the x (long) and y (lat) direction have to be the same.");
-
-      if (grid_type == "spherical" ||
-          grid_type == "chunk" ||
-          grid_type == "annulus")
-        {
-          x_min *= (Consts::PI/180);
-          x_max *= (Consts::PI/180);
-          y_min *= (Consts::PI/180);
-          y_max *= (Consts::PI/180);
-        }
-
-
-
-      /**
-       * All variables needed for the visualization
-       */
-      size_t n_cell = NaN::ISNAN;
-      size_t n_p = NaN::ISNAN;
-
-      std::vector<double> grid_x(0);
-      std::vector<double> grid_y(0);
-      std::vector<double> grid_z(0);
-      std::vector<double> grid_depth(0);
-
-      std::vector<std::vector<size_t> > grid_connectivity(0);
-
-
-      const bool compress_size = true;
-
-
-
-
-      /**
-       * Begin making the grid
-       */
-      std::cout << "[4/6] Building the grid...                        \r";
-      std::cout.flush();
-      WBAssertThrow(dim == 2 || dim == 3, "Dimension should be 2d or 3d.");
-      if (grid_type == "cartesian")
-        {
-          n_cell = n_cell_x * n_cell_z * (dim == 3 ? n_cell_y : 1);
-          if (!compress_size && dim == 3)
-            n_p = n_cell * 8 ; // it shouldn't matter for 2d in the output, so just do 3d.
-          else
-            n_p = (n_cell_x + 1) * (n_cell_z + 1) * (dim == 3 ? (n_cell_y + 1) : 1);
-
-
-          const double dx = (x_max - x_min) / static_cast<double>(n_cell_x);
-          const double dy = dim == 2 ? 0 : (y_max - y_min) / static_cast<double>(n_cell_y);
-          const double dz = (z_max - z_min) / static_cast<double>(n_cell_z);
-
-
-          WBAssertThrow(!std::isnan(dx), "dz is not a number:" << dz << '.');
-          WBAssertThrow(dim == 2 || !std::isnan(dy), "dz is not a number:" << dz << '.');
-          WBAssertThrow(!std::isnan(dz), "dz is not a number:" << dz << '.');
-
-          // todo: determine whether a input variable is desirable for this.
-          const double surface = z_max;
-
-          grid_x.resize(n_p);
-          grid_z.resize(n_p);
-
-          if (dim == 3)
-            grid_y.resize(n_p);
-
-          grid_depth.resize(n_p);
-
-          // compute positions
-          size_t counter = 0;
-          if (dim == 2)
-            {
-              for (size_t j = 0; j <= n_cell_z; ++j)
-                {
-                  for (size_t i = 0; i <= n_cell_x; ++i)
-                    {
-                      grid_x[counter] = x_min + static_cast<double>(i) * dx;
-                      grid_z[counter] = z_min + static_cast<double>(j) * dz;
-                      grid_depth[counter] = (surface - z_min) - static_cast<double>(j) * dz;
-                      counter++;
-                    }
-                }
-            }
-          else
-            {
-              if (compress_size)
-                {
-                  for (size_t i = 0; i <= n_cell_x; ++i)
-                    {
-                      for (size_t j = 0; j <= n_cell_y; ++j)
-                        {
-                          for (size_t k = 0; k <= n_cell_z; ++k)
-                            {
-                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
-                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
-                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
-                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
-                              counter++;
-                            }
-                        }
-                    }
-                }
-              else
-                {
-                  for (size_t i = 0; i < n_cell_x; ++i)
-                    {
-                      for (size_t j = 0; j < n_cell_y; ++j)
-                        {
-                          for (size_t k = 0; k < n_cell_z; ++k)
-                            {
-                              // position is defined by the vtk file format
-                              // position 0 of this cell
-                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
-                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
-                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
-                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
-                              counter++;
-                              // position 1 of this cell
-                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dx;
-                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
-                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
-                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
-                              counter++;
-                              // position 2 of this cell
-                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dx;
-                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dy;
-                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
-                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
-                              counter++;
-                              // position 3 of this cell
-                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
-                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dy;
-                              grid_z[counter] = z_min + static_cast<double>(k) * dz;
-                              grid_depth[counter] = (surface - z_min) - static_cast<double>(k) * dz;
-                              counter++;
-                              // position 0 of this cell
-                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
-                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
-                              grid_z[counter] = z_min + (static_cast<double>(k) + 1.0) * dz;
-                              grid_depth[counter] = (surface - z_min) - (static_cast<double>(k) + 1.0) * dz;
-                              counter++;
-                              // position 1 of this cell
-                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dx;
-                              grid_y[counter] = y_min + static_cast<double>(j) * dy;
-                              grid_z[counter] = z_min + (static_cast<double>(k) + 1.0) * dz;
-                              grid_depth[counter] = (surface - z_min) - (static_cast<double>(k) + 1.0) * dz;
-                              counter++;
-                              // position 2 of this cell
-                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dx;
-                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dy;
-                              grid_z[counter] = z_min + (static_cast<double>(k) + 1.0) * dz;
-                              grid_depth[counter] = (surface - z_min) - (static_cast<double>(k) + 1.0) * dz;
-                              counter++;
-                              // position 3 of this cell
-                              grid_x[counter] = x_min + static_cast<double>(i) * dx;
-                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dy;
-                              grid_z[counter] = z_min + (static_cast<double>(k) + 1.0) * dz;
-                              grid_depth[counter] = (surface - z_min) - (static_cast<double>(k) + 1.0) * dz;
-                              WBAssert(counter < n_p, "Assert counter smaller then n_P: counter = " << counter << ", n_p = " << n_p);
-                              counter++;
-                            }
-                        }
-                    }
-                }
-            }
-
-          // compute connectivity. Local to global mapping.
-          grid_connectivity.resize(n_cell,std::vector<size_t>((dim-1)*4));
-
-          counter = 0;
-          if (dim == 2)
-            {
-              for (size_t j = 1; j <= n_cell_z; ++j)
-                {
-                  for (size_t i = 1; i <= n_cell_x; ++i)
-                    {
-                      grid_connectivity[counter][0] = i + (j - 1) * (n_cell_x + 1) - 1;
-                      grid_connectivity[counter][1] = i + 1 + (j - 1) * (n_cell_x + 1) - 1;
-                      grid_connectivity[counter][2] = i + 1  + j * (n_cell_x + 1) - 1;
-                      grid_connectivity[counter][3] = i + j * (n_cell_x + 1) - 1;
-                      counter++;
-                    }
-                }
-            }
-          else
-            {
-              if (compress_size)
-                {
-                  for (size_t i = 1; i <= n_cell_x; ++i)
-                    {
-                      for (size_t j = 1; j <= n_cell_y; ++j)
-                        {
-                          for (size_t k = 1; k <= n_cell_z; ++k)
-                            {
-                              grid_connectivity[counter][0] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j - 1) + k - 1;
-                              grid_connectivity[counter][1] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j - 1) + k - 1;
-                              grid_connectivity[counter][2] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j    ) + k - 1;
-                              grid_connectivity[counter][3] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j    ) + k - 1;
-                              grid_connectivity[counter][4] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j - 1) + k;
-                              grid_connectivity[counter][5] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j - 1) + k;
-                              grid_connectivity[counter][6] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j    ) + k;
-                              grid_connectivity[counter][7] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j    ) + k;
-                              counter++;
-                            }
-                        }
-                    }
-                }
-              else
-                {
-                  for (size_t i = 0; i < n_cell; ++i)
-                    {
-                      grid_connectivity[i][0] = counter;
-                      grid_connectivity[i][1] = counter + 1;
-                      grid_connectivity[i][2] = counter + 2;
-                      grid_connectivity[i][3] = counter + 3;
-                      grid_connectivity[i][4] = counter + 4;
-                      grid_connectivity[i][5] = counter + 5;
-                      grid_connectivity[i][6] = counter + 6;
-                      grid_connectivity[i][7] = counter + 7;
-                      counter = counter + 8;
-                    }
-                }
-            }
-        }
-      else if (grid_type == "annulus")
-        {
-          /**
-           * An annulus which is a 2d hollow sphere.
-           * TODO: make it so you can determine your own cross section.
-           */
-          WBAssertThrow(dim == 2, "The annulus only works in 2d.");
-
-
-          const double inner_radius = z_min;
-          const double outer_radius = z_max;
-
-          const double l_outer = 2.0 * Consts::PI * outer_radius;
-
-          const double lr = outer_radius - inner_radius;
-          const double dr = lr / static_cast<double>(n_cell_z);
-
-          const size_t n_cell_t = static_cast<size_t>((2.0 * Consts::PI * outer_radius)/dr);
-
-          // compute the amount of cells
-          n_cell = n_cell_t *n_cell_z;
-          n_p = n_cell_t *(n_cell_z + 1);  // one less then cartesian because two cells overlap.
-
-          const double sx = l_outer / static_cast<double>(n_cell_t);
-          const double sz = dr;
-
-          grid_x.resize(n_p);
-          grid_z.resize(n_p);
-          grid_depth.resize(n_p);
-
-          size_t counter = 0;
-          for (size_t j = 0; j <= n_cell_z; ++j)
-            {
-              for (size_t i = 1; i <= n_cell_t; ++i)
-                {
-                  grid_x[counter] = (static_cast<double>(i) - 1.0) * sx;
-                  grid_z[counter] = static_cast<double>(j) * sz;
-                  counter++;
-                }
-            }
-
-          counter = 0;
-          for (size_t j = 1; j <= n_cell_z+1; ++j)
-            {
-              for (size_t i = 1; i <= n_cell_t; ++i)
-                {
-                  const double xi = grid_x[counter];
-                  const double zi = grid_z[counter];
-                  const double theta = xi / l_outer * 2.0 * Consts::PI;
-                  grid_x[counter] = std::cos(theta) * (inner_radius + zi);
-                  grid_z[counter] = std::sin(theta) * (inner_radius + zi);
-                  grid_depth[counter] = outer_radius - std::sqrt(grid_x[counter] * grid_x[counter] + grid_z[counter] * grid_z [counter]);
-                  grid_depth[counter] = (std::fabs(grid_depth[counter]) < 1e-8 ? 0 : grid_depth[counter]);
-                  counter++;
-                }
-            }
-
-          grid_connectivity.resize(n_cell,std::vector<size_t>(4));
-          counter = 0;
-          for (size_t j = 1; j <= n_cell_z; ++j)
-            {
-              for (size_t i = 1; i <= n_cell_t; ++i)
-                {
-                  std::vector<size_t> cell_connectivity(4);
-                  cell_connectivity[0] = counter + 1;
-                  cell_connectivity[1] = counter + 1 + 1;
-                  cell_connectivity[2] = i + j * n_cell_t + 1;
-                  cell_connectivity[3] = i + j * n_cell_t;
-                  if (i == n_cell_t)
-                    {
-                      cell_connectivity[1] = cell_connectivity[1] - n_cell_t;
-                      cell_connectivity[2] = cell_connectivity[2] - n_cell_t;
-                    }
-                  grid_connectivity[counter][0] = cell_connectivity[1] - 1;
-                  grid_connectivity[counter][1] = cell_connectivity[0] - 1;
-                  grid_connectivity[counter][2] = cell_connectivity[3] - 1;
-                  grid_connectivity[counter][3] = cell_connectivity[2] - 1;
-                  counter++;
-                }
-            }
-        }
-      else if (grid_type == "chunk")
-        {
-          const double inner_radius = z_min;
-          const double outer_radius = z_max;
-
-          WBAssertThrow(x_min <= x_max, "The minimum longitude must be less than the maximum longitude.");
-          WBAssertThrow(y_min <= y_max, "The minimum latitude must be less than the maximum latitude.");
-          WBAssertThrow(inner_radius < outer_radius, "The inner radius must be less than the outer radius.");
-
-          WBAssertThrow(x_min - x_max <= 2.0 * Consts::PI, "The difference between the minimum and maximum longitude "
-                        " must be less than or equal to 360 degree.");
-
-          WBAssertThrow(y_min >= - 0.5 * Consts::PI, "The minimum latitude must be larger then or equal to -90 degree.");
-          WBAssertThrow(y_min <= 0.5 * Consts::PI, "The maximum latitude must be smaller then or equal to 90 degree.");
-
-          const double opening_angle_long_rad = (x_max - x_min);
-          const double opening_angle_lat_rad =  (y_max - y_min);
-
-          n_cell = n_cell_x * n_cell_z * (dim == 3 ? n_cell_y : 1);
-          if (!compress_size && dim == 3)
-            n_p = n_cell * 8 ; // it shouldn't matter for 2d in the output, so just do 3d.
-          else
-            n_p = (n_cell_x + 1) * (n_cell_z + 1) * (dim == 3 ? (n_cell_y + 1) : 1);
-
-          const double dlong = opening_angle_long_rad / static_cast<double>(n_cell_x);
-          const double dlat = dim == 3 ? opening_angle_lat_rad / static_cast<double>(n_cell_y) : 0.;
-          const double lr = outer_radius - inner_radius;
-          const double dr = lr / static_cast<double>(n_cell_z);
-
-          grid_x.resize(n_p);
-          grid_y.resize(dim == 3 ? n_p : 0);
-          grid_z.resize(n_p);
-          grid_depth.resize(n_p);
-
-          std::cout << "[4/6] Building the grid: stage 1 of 3                        \r";
-          std::cout.flush();
-          size_t counter = 0;
-          if (dim == 2)
-            {
-              for (size_t i = 1; i <= n_cell_x + 1; ++i)
-                for (size_t j = 1; j <= n_cell_z + 1; ++j)
-                  {
-                    grid_x[counter] = x_min + (static_cast<double>(i) - 1.0) * dlong;
-                    grid_z[counter] = inner_radius + (static_cast<double>(j) - 1.0) * dr;
-                    grid_depth[counter] = lr - (static_cast<double>(j) - 1.0) * dr;
-                    counter++;
-                  }
-            }
-          else
-            {
-              if (compress_size)
-                {
-                  for (size_t i = 1; i <= n_cell_x + 1; ++i)
-                    for (size_t j = 1; j <= n_cell_y + 1; ++j)
-                      for (size_t k = 1; k <= n_cell_z + 1; ++k)
-                        {
-                          grid_x[counter] = x_min + (static_cast<double>(i) - 1.0) * dlong;
-                          grid_y[counter] = y_min + (static_cast<double>(j) - 1.0) * dlat;
-                          grid_z[counter] = inner_radius + (static_cast<double>(k) - 1.0) * dr;
-                          grid_depth[counter] = lr - (static_cast<double>(k) - 1.0) * dr;
-                          counter++;
-                        }
-                }
-              else
-                {
-                  for (size_t i = 0; i < n_cell_x; ++i)
-                    {
-                      for (size_t j = 0; j < n_cell_y; ++j)
-                        {
-                          for (size_t k = 0; k < n_cell_z; ++k)
-                            {
-                              // position is defined by the vtk file format
-                              // position 0 of this cell
-                              grid_x[counter] = x_min + static_cast<double>(i) * dlong;
-                              grid_y[counter] = y_min + static_cast<double>(j) * dlat;
-                              grid_z[counter] = inner_radius + static_cast<double>(k) * dr;
-                              grid_depth[counter] = lr - static_cast<double>(k) * dr;
-                              counter++;
-                              // position 1 of this cell
-                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dlong;
-                              grid_y[counter] = y_min + static_cast<double>(j) * dlat;
-                              grid_z[counter] = inner_radius + static_cast<double>(k) * dr;
-                              grid_depth[counter] = lr - static_cast<double>(k) * dr;
-                              counter++;
-                              // position 2 of this cell
-                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dlong;
-                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dlat;
-                              grid_z[counter] = inner_radius + static_cast<double>(k) * dr;
-                              grid_depth[counter] = lr - static_cast<double>(k) * dr;
-                              counter++;
-                              // position 3 of this cell
-                              grid_x[counter] = x_min + static_cast<double>(i) * dlong;
-                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dlat;
-                              grid_z[counter] = inner_radius + static_cast<double>(k) * dr;
-                              grid_depth[counter] = lr - static_cast<double>(k) * dr;
-                              counter++;
-                              // position 0 of this cell
-                              grid_x[counter] = x_min + static_cast<double>(i) * dlong;
-                              grid_y[counter] = y_min + static_cast<double>(j) * dlat;
-                              grid_z[counter] = inner_radius + (static_cast<double>(k) + 1.0) * dr;
-                              grid_depth[counter] = lr - (static_cast<double>(k) + 1.0) * dr;
-                              counter++;
-                              // position 1 of this cell
-                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dlong;
-                              grid_y[counter] = y_min + static_cast<double>(j) * dlat;
-                              grid_z[counter] = inner_radius + (static_cast<double>(k) + 1.0) * dr;
-                              grid_depth[counter] = lr - (static_cast<double>(k) + 1.0) * dr;
-                              counter++;
-                              // position 2 of this cell
-                              grid_x[counter] = x_min + (static_cast<double>(i) + 1.0) * dlong;
-                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dlat;
-                              grid_z[counter] = inner_radius + (static_cast<double>(k) + 1.0) * dr;
-                              grid_depth[counter] = lr - (static_cast<double>(k) + 1.0) * dr;
-                              counter++;
-                              // position 3 of this cell
-                              grid_x[counter] = x_min + static_cast<double>(i) * dlong;
-                              grid_y[counter] = y_min + (static_cast<double>(j) + 1.0) * dlat;
-                              grid_z[counter] = inner_radius + (static_cast<double>(k) + 1.0) * dr;
-                              grid_depth[counter] = lr - (static_cast<double>(k) + 1.0) * dr;
-                              WBAssert(counter < n_p, "Assert counter smaller then n_P: counter = " << counter << ", n_p = " << n_p);
-                              counter++;
-                            }
-                        }
-                    }
-                }
-            }
-
-          std::cout << "[4/6] Building the grid: stage 2 of 3                        \r";
-          std::cout.flush();
-          if (dim == 2)
-            {
-              for (size_t i = 0; i < n_p; ++i)
-                {
-
-                  const double longitude = grid_x[i];
-                  const double radius = grid_z[i];
-
-                  grid_x[i] = radius * std::cos(longitude);
-                  grid_z[i] = radius * std::sin(longitude);
-                }
-            }
-          else
-            {
-              for (size_t i = 0; i < n_p; ++i)
-                {
-
-                  const double longitude = grid_x[i];
-                  const double latitutde = grid_y[i];
-                  const double radius = grid_z[i];
-
-                  grid_x[i] = radius * std::cos(latitutde) * std::cos(longitude);
-                  grid_y[i] = radius * std::cos(latitutde) * std::sin(longitude);
-                  grid_z[i] = radius * std::sin(latitutde);
-                }
-            }
-          std::cout << "[4/6] Building the grid: stage 3 of 3                        \r";
-          std::cout.flush();
-          // compute connectivity. Local to global mapping.
-          grid_connectivity.resize(n_cell,std::vector<size_t>((dim-1)*4));
-
-          counter = 0;
-          if (dim == 2)
-            {
-              for (size_t i = 1; i <= n_cell_x; ++i)
-                {
-                  for (size_t j = 1; j <= n_cell_z; ++j)
-                    {
-                      grid_connectivity[counter][0] = (n_cell_z + 1) * (i - 1) + j - 1;
-                      grid_connectivity[counter][1] = (n_cell_z + 1) * (i - 1) + j;
-                      grid_connectivity[counter][2] = (n_cell_z + 1) * (i    ) + j;
-                      grid_connectivity[counter][3] = (n_cell_z + 1) * (i    ) + j - 1;
-
-                      counter = counter+1;
-                      std::cout << "[4/6] Building the grid: stage 3 of 3 [" << (static_cast<double>(i)/static_cast<double>(n_cell))*100.0 << "%]                       \r";
-                      std::cout.flush();
-                    }
-                }
-            }
-          else
-            {
-              if (compress_size)
-                {
-                  for (size_t i = 1; i <= n_cell_x; ++i)
-                    {
-                      for (size_t j = 1; j <= n_cell_y; ++j)
-                        {
-                          for (size_t k = 1; k <= n_cell_z; ++k)
-                            {
-                              grid_connectivity[counter][0] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j - 1) + k - 1;
-                              grid_connectivity[counter][1] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j - 1) + k - 1;
-                              grid_connectivity[counter][2] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j    ) + k - 1;
-                              grid_connectivity[counter][3] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j    ) + k - 1;
-                              grid_connectivity[counter][4] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j - 1) + k;
-                              grid_connectivity[counter][5] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j - 1) + k;
-                              grid_connectivity[counter][6] = (n_cell_y + 1) * (n_cell_z + 1) * (i    ) + (n_cell_z + 1) * (j    ) + k;
-                              grid_connectivity[counter][7] = (n_cell_y + 1) * (n_cell_z + 1) * (i - 1) + (n_cell_z + 1) * (j    ) + k;
-                              counter++;
-                            }
-                        }
-                    }
-                }
-              else
-                {
-                  for (size_t i = 0; i < n_cell; ++i)
-                    {
-                      grid_connectivity[i][0] = counter;
-                      grid_connectivity[i][1] = counter + 1;
-                      grid_connectivity[i][2] = counter + 2;
-                      grid_connectivity[i][3] = counter + 3;
-                      grid_connectivity[i][4] = counter + 4;
-                      grid_connectivity[i][5] = counter + 5;
-                      grid_connectivity[i][6] = counter + 6;
-                      grid_connectivity[i][7] = counter + 7;
-                      counter = counter + 8;
-                      std::cout << "[4/6] Building the grid: stage 3 of 3 [" << (static_cast<double>(i)/static_cast<double>(n_cell))*100.0 << "%]                       \r";
-                      std::cout.flush();
-                    }
-                }
-            }
-        }
-      else if (grid_type == "sphere")
-        {
-
-          WBAssertThrow(dim == 3, "The sphere only works in 3d.");
-
-
-          const double inner_radius = z_min;
-          const double outer_radius = z_max;
-
-          const size_t n_block = 12;
-
-          const size_t block_n_cell = n_cell_x*n_cell_x;
-          const size_t block_n_p = (n_cell_x + 1) * (n_cell_x + 1);
-          const size_t block_n_v = 4;
-
-
-          std::vector<std::vector<double> > block_grid_x(n_block,std::vector<double>(block_n_p));
-          std::vector<std::vector<double> > block_grid_y(n_block,std::vector<double>(block_n_p));
-          std::vector<std::vector<double> > block_grid_z(n_block,std::vector<double>(block_n_p));
-          std::vector<std::vector<std::vector<size_t> > > block_grid_connectivity(n_block,std::vector<std::vector<size_t> >(block_n_cell,std::vector<size_t>(block_n_v)));
-          std::vector<std::vector<bool> > block_grid_hull(n_block,std::vector<bool>(block_n_p));
-
-          /**
-           * block node layout
-           */
-          for (size_t i_block = 0; i_block < n_block; ++i_block)
-            {
-              const size_t block_n_cell_x = n_cell_x;
-              const size_t block_n_cell_y = n_cell_x;
-              const double Lx = 1.0;
-              const double Ly = 1.0;
-
-              size_t counter = 0;
-              for (size_t j = 0; j <= block_n_cell_y; ++j)
-                {
-                  for (size_t i = 0; i <= block_n_cell_y; ++i)
-                    {
-                      block_grid_x[i_block][counter] = static_cast<double>(i) * Lx / static_cast<double>(block_n_cell_x);
-                      block_grid_y[i_block][counter] = static_cast<double>(j) * Ly / static_cast<double>(block_n_cell_y);
-                      block_grid_z[i_block][counter] = 0.0;
-                      counter++;
-                    }
-                }
-
-              counter = 0;
-              // using i=1 and j=1 here because i an j are not used in lookup and storage
-              // so the code can remain very similar to ghost and the cartesian code.
-              for (size_t j = 1; j <= block_n_cell_y; ++j)
-                {
-                  for (size_t i = 1; i <= block_n_cell_x; ++i)
-                    {
-                      block_grid_connectivity[i_block][counter][0] = i + (j - 1) * (block_n_cell_x + 1) - 1;
-                      block_grid_connectivity[i_block][counter][1] = i + 1 + (j - 1) * (block_n_cell_x + 1) - 1;
-                      block_grid_connectivity[i_block][counter][2] = i + 1  + j * (block_n_cell_x + 1) - 1;
-                      block_grid_connectivity[i_block][counter][3] = i + j * (block_n_cell_x + 1) - 1;
-                      counter++;
-                    }
-                }
-            }
-
-          /**
-           * map blocks
-           */
-          double radius = 1;
-
-          // four corners
-          double xA = -1.0;
-          double yA = 0.0;
-          double zA = -1.0 / std::sqrt(2.0);
-
-          double xB = 1.0;
-          double yB = 0.0;
-          double zB = -1.0 / std::sqrt(2.0);
-
-          double xC = 0.0;
-          double yC = -1.0;
-          double zC = 1.0 / std::sqrt(2.0);
-
-          double xD = 0.0;
-          double yD = 1.0;
-          double zD = 1.0 / std::sqrt(2.0);
-
-          // middles of faces
-          double xM = (xA+xB+xC)/3.0;
-          double yM = (yA+yB+yC)/3.0;
-          double zM = (zA+zB+zC)/3.0;
-
-          double xN = (xA+xD+xC)/3.0;
-          double yN = (yA+yD+yC)/3.0;
-          double zN = (zA+zD+zC)/3.0;
-
-          double xP = (xA+xD+xB)/3.0;
-          double yP = (yA+yD+yB)/3.0;
-          double zP = (zA+zD+zB)/3.0;
-
-          double xQ = (xC+xD+xB)/3.0;
-          double yQ = (yC+yD+yB)/3.0;
-          double zQ = (zC+zD+zB)/3.0;
-
-          // middle of edges
-          double xF = (xB+xC)/2.0;
-          double yF = (yB+yC)/2.0;
-          double zF = (zB+zC)/2.0;
-
-          double xG = (xA+xC)/2.0;
-          double yG = (yA+yC)/2.0;
-          double zG = (zA+zC)/2.0;
-
-          double xE = (xB+xA)/2.0;
-          double yE = (yB+yA)/2.0;
-          double zE = (zB+zA)/2.0;
-
-          double xH = (xD+xC)/2.0;
-          double yH = (yD+yC)/2.0;
-          double zH = (zD+zC)/2.0;
-
-          double xJ = (xD+xA)/2.0;
-          double yJ = (yD+yA)/2.0;
-          double zJ = (zD+zA)/2.0;
-
-          double xK = (xD+xB)/2.0;
-          double yK = (yD+yB)/2.0;
-          double zK = (zD+zB)/2.0;
-
-          // Making sure points A..Q are on a sphere
-          project_on_sphere(radius,xA,yA,zA);
-          project_on_sphere(radius,xB,yB,zB);
-          project_on_sphere(radius,xC,yC,zC);
-          project_on_sphere(radius,xD,yD,zD);
-          project_on_sphere(radius,xE,yE,zE);
-          project_on_sphere(radius,xF,yF,zF);
-          project_on_sphere(radius,xG,yG,zG);
-          project_on_sphere(radius,xH,yH,zH);
-          project_on_sphere(radius,xJ,yJ,zJ);
-          project_on_sphere(radius,xK,yK,zK);
-          project_on_sphere(radius,xM,yM,zM);
-          project_on_sphere(radius,xN,yN,zN);
-          project_on_sphere(radius,xP,yP,zP);
-          project_on_sphere(radius,xQ,yQ,zQ);
-
-          lay_points(xM,yM,zM,xG,yG,zG,xA,yA,zA,xE,yE,zE,block_grid_x[0], block_grid_y[0], block_grid_z[0],block_grid_hull[0], n_cell_x);
-          lay_points(xF,yF,zF,xM,yM,zM,xE,yE,zE,xB,yB,zB,block_grid_x[1], block_grid_y[1], block_grid_z[1],block_grid_hull[1], n_cell_x);
-          lay_points(xC,yC,zC,xG,yG,zG,xM,yM,zM,xF,yF,zF,block_grid_x[2], block_grid_y[2], block_grid_z[2],block_grid_hull[2], n_cell_x);
-          lay_points(xG,yG,zG,xN,yN,zN,xJ,yJ,zJ,xA,yA,zA,block_grid_x[3], block_grid_y[3], block_grid_z[3],block_grid_hull[3], n_cell_x);
-          lay_points(xC,yC,zC,xH,yH,zH,xN,yN,zN,xG,yG,zG,block_grid_x[4], block_grid_y[4], block_grid_z[4],block_grid_hull[4], n_cell_x);
-          lay_points(xH,yH,zH,xD,yD,zD,xJ,yJ,zJ,xN,yN,zN,block_grid_x[5], block_grid_y[5], block_grid_z[5],block_grid_hull[5], n_cell_x);
-          lay_points(xA,yA,zA,xJ,yJ,zJ,xP,yP,zP,xE,yE,zE,block_grid_x[6], block_grid_y[6], block_grid_z[6],block_grid_hull[6], n_cell_x);
-          lay_points(xJ,yJ,zJ,xD,yD,zD,xK,yK,zK,xP,yP,zP,block_grid_x[7], block_grid_y[7], block_grid_z[7],block_grid_hull[7], n_cell_x);
-          lay_points(xP,yP,zP,xK,yK,zK,xB,yB,zB,xE,yE,zE,block_grid_x[8], block_grid_y[8], block_grid_z[8],block_grid_hull[8], n_cell_x);
-          lay_points(xQ,yQ,zQ,xK,yK,zK,xD,yD,zD,xH,yH,zH,block_grid_x[9], block_grid_y[9], block_grid_z[9],block_grid_hull[9], n_cell_x);
-          lay_points(xQ,yQ,zQ,xH,yH,zH,xC,yC,zC,xF,yF,zF,block_grid_x[10], block_grid_y[10], block_grid_z[10],block_grid_hull[10], n_cell_x);
-          lay_points(xQ,yQ,zQ,xF,yF,zF,xB,yB,zB,xK,yK,zK,block_grid_x[11], block_grid_y[11], block_grid_z[11],block_grid_hull[11], n_cell_x);
-
-          // make sure all points end up on a sphere
-          for (size_t i_block = 0; i_block < n_block; ++i_block)
-            {
-              for (size_t i_point = 0; i_point < block_n_p; ++i_point)
-                {
-                  project_on_sphere(radius,block_grid_x[i_block][i_point],block_grid_y[i_block][i_point],block_grid_z[i_block][i_point]);
-                }
-            }
-
-          /**
-           * merge blocks
-           */
-          std::vector<double> temp_x(n_block * block_n_p);
-          std::vector<double> temp_y(n_block * block_n_p);
-          std::vector<double> temp_z(n_block * block_n_p);
-          std::vector<bool> sides(n_block * block_n_p);
-
-          for (size_t i = 0; i < n_block; ++i)
-            {
-              size_t counter = 0;
-              for (size_t j = i * block_n_p; j < i * block_n_p + block_n_p; ++j)
-                {
-                  WBAssert(j < temp_x.size(), "j should be smaller then the size of the array temp_x.");
-                  WBAssert(j < temp_y.size(), "j should be smaller then the size of the array temp_y.");
-                  WBAssert(j < temp_z.size(), "j should be smaller then the size of the array temp_z.");
-                  temp_x[j] = block_grid_x[i][counter];
-                  temp_y[j] = block_grid_y[i][counter];
-                  temp_z[j] = block_grid_z[i][counter];
-                  sides[j] = block_grid_hull[i][counter];
-                  counter++;
-                }
-            }
-
-
-          std::vector<bool> double_points(n_block * block_n_p,false);
-          std::vector<size_t> point_to(n_block * block_n_p);
-
-          for (size_t i = 0; i < n_block * block_n_p; ++i)
-            point_to[i] = i;
-
-          // TODO: This becomes problematic with too large values of outer radius. Find a better way, maybe through an epsilon.
-          const double distance = 1e-12*outer_radius;
-
-          size_t counter = 0;
-          size_t amount_of_double_points = 0;
-          for (size_t i = 1; i < n_block * block_n_p; ++i)
-            {
-              if (sides[i])
-                {
-                  const double gxip = temp_x[i];
-                  const double gyip = temp_y[i];
-                  const double gzip = temp_z[i];
-                  for (size_t j = 0; j < i-1; ++j)
-                    {
-                      if (sides[j])
-                        {
-                          if (std::fabs(gxip-temp_x[j]) < distance &&
-                              std::fabs(gyip-temp_y[j]) < distance &&
-                              std::fabs(gzip-temp_z[j]) < distance)
-                            {
-                              double_points[i] = true;
-                              point_to[i] = j;
-                              amount_of_double_points++;
-                              break;
-                            }
-                        }
-                    }
-                }
-            }
-
-
-          const size_t shell_n_p = n_block * block_n_p - amount_of_double_points;
-          const size_t shell_n_cell = n_block * block_n_cell;
-          const size_t shell_n_v = block_n_v;
-
-          std::vector<double> shell_grid_x(shell_n_p);
-          std::vector<double> shell_grid_y(shell_n_p);
-          std::vector<double> shell_grid_z(shell_n_p);
-          std::vector<std::vector<size_t> > shell_grid_connectivity(shell_n_cell,std::vector<size_t>(shell_n_v));
-
-          counter = 0;
-          for (size_t i = 0; i < n_block * block_n_p; ++i)
-            {
-              if (!double_points[i])
-                {
-                  shell_grid_x[counter] = fabs(temp_x[i]) < 1e-8 ? 0. : temp_x[i];
-                  shell_grid_y[counter] = fabs(temp_y[i]) < 1e-8 ? 0. : temp_y[i];
-                  shell_grid_z[counter] = fabs(temp_z[i]) < 1e-8 ? 0. : temp_z[i];
-
-                  counter++;
-                }
-            }
-
-          for (size_t i = 0; i < n_block; ++i)
-            {
-              counter = 0;
-              for (size_t j = i * block_n_cell; j < i * block_n_cell + block_n_cell; ++j)
-                {
-                  for (size_t k = 0; k < shell_n_v; ++k)
-                    {
-                      shell_grid_connectivity[j][k] = block_grid_connectivity[i][counter][k] + i * block_n_p;
-                    }
-                  counter++;
-                }
-            }
-
-          for (size_t i = 0; i < shell_n_cell; ++i)
-            {
-              for (size_t j = 0; j < shell_n_v; ++j)
-                {
-                  shell_grid_connectivity[i][j] = point_to[shell_grid_connectivity[i][j]];
-                }
-            }
-
-          std::vector<size_t> compact(n_block * block_n_p);
-
-          counter = 0;
-          for (size_t i = 0; i < n_block * block_n_p; ++i)
-            {
-              if (!double_points[i])
-                {
-                  compact[i] = counter;
-                  counter++;
-                }
-            }
-
-
-          for (size_t i = 0; i < shell_n_cell; ++i)
-            {
-              for (size_t j = 0; j < shell_n_v; ++j)
-                {
-                  shell_grid_connectivity[i][j] = compact[shell_grid_connectivity[i][j]];
-                }
-            }
-
-
-          /**
-           * build hollow sphere
-           */
-
-          std::vector<double> temp_shell_grid_x(shell_n_p);
-          std::vector<double> temp_shell_grid_y(shell_n_p);
-          std::vector<double> temp_shell_grid_z(shell_n_p);
-
-          const size_t n_v = shell_n_v * 2;
-          n_p = (n_cell_z + 1) * shell_n_p;
-          n_cell = (n_cell_z) * shell_n_cell;
-
-          grid_x.resize(n_p);
-          grid_y.resize(n_p);
-          grid_z.resize(n_p);
-          grid_depth.resize(n_p);
-          grid_connectivity.resize(n_cell,std::vector<size_t>(n_v));
-
-
-          for (size_t i = 0; i < n_cell_z + 1; ++i)
-            {
-              temp_shell_grid_x = shell_grid_x;
-              temp_shell_grid_y = shell_grid_y;
-              temp_shell_grid_z = shell_grid_z;
-
-              // We do not need to copy the shell_grid_connectivity into a
-              // temperorary variable, because we do not change it. We can
-              // directly use it.
-
-              radius = inner_radius + ((outer_radius - inner_radius) / static_cast<double>(n_cell_z)) * static_cast<double>(i);
-              for (size_t j = 0; j < shell_n_p; ++j)
-                {
-                  WBAssert(j < temp_shell_grid_x.size(), "ERROR: j = " << j << ", temp_shell_grid_x.size() = " << temp_shell_grid_x.size());
-                  WBAssert(j < temp_shell_grid_y.size(), "ERROR: j = " << j << ", temp_shell_grid_y.size() = " << temp_shell_grid_y.size());
-                  WBAssert(j < temp_shell_grid_z.size(), "ERROR: j = " << j << ", temp_shell_grid_z.size() = " << temp_shell_grid_z.size());
-                  project_on_sphere(radius, temp_shell_grid_x[j], temp_shell_grid_y[j], temp_shell_grid_z[j]);
-                }
-
-              const size_t i_beg =  i * shell_n_p;
-              const size_t i_end = (i+1) * shell_n_p;
-              counter = 0;
-              for (size_t j = i_beg; j < i_end; ++j)
-                {
-                  WBAssert(j < grid_x.size(), "ERROR: j = " << j << ", grid_x.size() = " << grid_x.size());
-                  WBAssert(j < grid_y.size(), "ERROR: j = " << j << ", grid_y.size() = " << grid_y.size());
-                  WBAssert(j < grid_z.size(), "ERROR: j = " << j << ", grid_z.size() = " << grid_z.size());
-                  grid_x[j] = temp_shell_grid_x[counter];
-                  grid_y[j] = temp_shell_grid_y[counter];
-                  grid_z[j] = temp_shell_grid_z[counter];
-                  grid_depth[j] = outer_radius - std::sqrt(grid_x[j] * grid_x[j] + grid_y[j] * grid_y[j] + grid_z[j] * grid_z[j]);
-                  grid_depth[j] = (std::fabs(grid_depth[j]) < 1e-8 ? 0 : grid_depth[j]);
-
-                  counter++;
-                }
-            }
-
-          for (size_t i = 0; i < n_cell_z; ++i)
-            {
-              const size_t i_beg = i * shell_n_cell;
-              const size_t i_end = (i+1) * shell_n_cell;
-              counter = 0;
-              for (size_t j = i_beg; j < i_end; ++j)
-                {
-                  for (size_t k = 0; k < shell_n_v; ++k)
-                    {
-                      grid_connectivity[j][k] = shell_grid_connectivity[counter][k] + i * shell_n_p;
-                    }
-                  counter++;
-                }
-
-
-              counter = 0;
-              for (size_t j = i_beg; j < i_end; ++j)
-                {
-                  for (size_t k = shell_n_v ; k < 2 * shell_n_v; ++k)
-                    {
-                      WBAssert(k-shell_n_v < shell_grid_connectivity[counter].size(), "k - shell_n_v is larger then shell_grid_connectivity[counter]: k= " << k << ", shell_grid_connectivity[counter].size() = " << shell_grid_connectivity[counter].size());
-                      grid_connectivity[j][k] = shell_grid_connectivity[counter][k-shell_n_v] + (i+1) * shell_n_p;
-                    }
-                  counter++;
-                }
-            }
-        }
-      else
-        {
-          WBAssertThrow(false, "Geometry type '" << grid_type << "' is not a valid geometry type. Valid geometry types are: "
-                        << "'cartesian', 'annulus', 'chunk' and 'sphere'. "
-                        << "Please note that the annulus can only be used in 2d and the sphere can only be used in 3d.");
-        }
-
-      // create paraview file.
-      std::cout << "[5/6] Preparing to write the paraview file...                                                   \r";
-      std::cout.flush();
-
-      const std::string base_filename = wb_file.substr(wb_file.find_last_of("/\\") + 1);
-      std::string::size_type  const p(base_filename.find_last_of('.'));
-      const std::string file_without_extension = base_filename.substr(0, p);
-
-      const std::stringstream buffer;
-      const std::ofstream myfile;
-
-      std::cout << "[5/6] Preparing to write the paraview file: stage 1 of 6, converting the points                              \r";
-      std::cout.flush();
-      std::vector<double> points(grid_x.size()*3, 0.0);
-      if (dim == 2)
-        for (size_t i = 0; i < n_p; ++i)
-          {
-            points[i*3] = grid_x[i];
-            points[i*3+1] = grid_z[i];
-            // third one is zero
-          }
-      else
-        {
-          for (size_t i = 0; i < n_p; ++i)
-            {
-              points[i*3] = grid_x[i];
-              points[i*3+1] = grid_y[i];
-              points[i*3+2] = grid_z[i];
-            }
-        }
-      std::cout << "[5/6] Preparing to write the paraview file: stage 2 of 6, converting the connectivity                              \r";
-      std::cout.flush();
-      const size_t pow_2_dim = dim == 2 ? 4 : 8;
-      std::vector<vtu11::VtkIndexType> connectivity(n_cell*pow_2_dim);
-      if (dim == 2)
-        for (size_t i = 0; i < n_cell; ++i)
-          {
-            connectivity[i*pow_2_dim] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][0]);
-            connectivity[i*pow_2_dim+1] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][1]);
-            connectivity[i*pow_2_dim+2] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][2]);
-            connectivity[i*pow_2_dim+3] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][3]);
-          }
-      else
-        for (size_t i = 0; i < n_cell; ++i)
-          {
-
-            connectivity[i*pow_2_dim] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][0]);
-            connectivity[i*pow_2_dim+1] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][1]);
-            connectivity[i*pow_2_dim+2] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][2]);
-            connectivity[i*pow_2_dim+3] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][3]);
-            connectivity[i*pow_2_dim+4] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][4]);
-            connectivity[i*pow_2_dim+5] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][5]);
-            connectivity[i*pow_2_dim+6] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][6]);
-            connectivity[i*pow_2_dim+7] = static_cast<vtu11::VtkIndexType>(grid_connectivity[i][7]);
-          }
-      std::cout << "[5/6] Preparing to write the paraview file: stage 3 of 6, creating the offsets                              \r";
-      std::cout.flush();
-      std::vector<vtu11::VtkIndexType> offsets(n_cell);
-      if (dim == 2)
-        for (size_t i = 0; i < n_cell; ++i)
-          offsets[i] = static_cast<vtu11::VtkIndexType>((i+1) * 4);
-      else
-        for (size_t i = 0; i < n_cell; ++i)
-          offsets[i] = static_cast<vtu11::VtkIndexType>((i+1) * 8);
-
-      std::cout << "[5/6] Preparing to write the paraview file: stage 4 of 6, creating the Data set info                              \r";
-      std::cout.flush();
-      std::vector<vtu11::VtkCellType> types(n_cell, dim == 2 ? 9 : 12);
-
-      // Create tuples with (name, association, number of components) for each data set
-      std::vector<vtu11::DataSetInfo> dataSetInfo
-      {
-        { "Depth", vtu11::DataSetType::PointData, 1 },
-        { "Temperature", vtu11::DataSetType::PointData, 1 },
-        { "Tag", vtu11::DataSetType::PointData, 1 },
-      };
-      for (size_t c = 0; c < compositions; ++c)
-        {
-          dataSetInfo.emplace_back( "Composition "+std::to_string(c), vtu11::DataSetType::PointData, 1 );
-        }
-
-      std::cout << "[5/6] Preparing to write the paraview file: stage 5 of 5, computing the properties                              \r";
-      std::cout.flush();
-
-      std::vector<std::array<unsigned ,3>> properties;
-      properties.push_back({{1,0,0}}); // temperature
-
-      properties.push_back({{4,0,0}}); // tag
-
-      for (unsigned int c = 0; c < compositions; ++c)
-        properties.push_back({{2,c,0}}); // composition c
-
-
-      // compute temperature
-      std::vector<vtu11::DataSetData> data_set(3+compositions);
-      data_set[0] = grid_depth;
-      data_set[1].resize(n_p);
-      data_set[2].resize(n_p);
-      for (size_t c = 0; c < compositions; ++c)
-        data_set[3+c].resize(n_p);
-
-      if (dim == 2)
-        {
-          pool.parallel_for(0, n_p, [&] (size_t i)
-          {
-            const std::array<double,2> coords = {{grid_x[i], grid_z[i]}};
-            std::vector<double> output = world->properties(coords, grid_depth[i],properties);
-            data_set[1][i] = output[0];
-            data_set[2][i] = output[1];
-            for (size_t c = 0; c < compositions; ++c)
-              {
-                data_set[3+c][i] = output[2+c];
-              }
-          });
-        }
-      else
-        {
-          pool.parallel_for(0, n_p, [&] (size_t i)
-          {
-            const std::array<double,3> coords = {{grid_x[i], grid_y[i], grid_z[i]}};
-            std::vector<double> output = world->properties(coords, grid_depth[i],properties);
-            data_set[1][i] = output[0];
-            data_set[2][i] = output[1];
-            for (size_t c = 0; c < compositions; ++c)
-              {
-                data_set[3+c][i] = output[2+c];
-              }
-          });
-        }
-      std::cout << "[6/6] Writing the paraview file                                                                                \r";
-      std::cout.flush();
-
-      {
-        vtu11::Vtu11UnstructuredMesh mesh { points, connectivity, offsets, types };
-        vtu11::writeVtu( file_without_extension + ".vtu", mesh, dataSetInfo, data_set, vtu_output_format );
-
-        if (output_filtered)
-          {
-            std::vector<bool> include_tag(world->feature_tags.size(), true);
-            for (unsigned int idx = 0; idx<include_tag.size(); ++idx)
-              {
-                if (world->feature_tags[idx]=="mantle layer")
-                  include_tag[idx] = false;
-              }
-            std::vector<double> filtered_points;
-            std::vector<vtu11::VtkIndexType> filtered_connectivity;
-            std::vector<vtu11::VtkIndexType> filtered_offsets;
-            std::vector<vtu11::VtkCellType> filtered_types;
-
-            vtu11::Vtu11UnstructuredMesh filtered_mesh {filtered_points, filtered_connectivity, filtered_offsets, filtered_types};
-            std::vector<vtu11::DataSetData> filtered_data_set;
-
-            filter_vtu_mesh(static_cast<int>(dim), include_tag, mesh, data_set, filtered_mesh, filtered_data_set);
-            vtu11::writeVtu( file_without_extension + ".filtered.vtu", filtered_mesh, dataSetInfo, filtered_data_set, vtu_output_format );
-          }
-
-        if (output_by_tag)
-          {
-            for (unsigned int idx = 0; idx<world->feature_tags.size(); ++idx)
-              {
-                if (world->feature_tags[idx]=="mantle layer")
-                  continue;
-
-                std::vector<double> filtered_points;
-                std::vector<vtu11::VtkIndexType> filtered_connectivity;
-                std::vector<vtu11::VtkIndexType> filtered_offsets;
-                std::vector<vtu11::VtkCellType> filtered_types;
-
-                vtu11::Vtu11UnstructuredMesh filtered_mesh {filtered_points, filtered_connectivity, filtered_offsets, filtered_types};
-                std::vector<vtu11::DataSetData> filtered_data_set;
-
-                std::vector<bool> include_tag(world->feature_tags.size(), false);
-                include_tag[idx]=true;
-                filter_vtu_mesh(static_cast<int>(dim), include_tag, mesh, data_set, filtered_mesh, filtered_data_set);
-                const std::string filename = file_without_extension + "."+ std::to_string(idx)+".vtu";
-                vtu11::writeVtu( filename, filtered_mesh, dataSetInfo, filtered_data_set, vtu_output_format );
-              }
-          }
-      }
-      std::cout << "                                                                                                               \r";
-      std::cout.flush();
-    }
-
-#ifdef WB_WITH_MPI
-  MPI_Finalize();
-#endif
-  return 0;
-}
diff --git a/contrib/world_builder/source/world_builder/coordinate_systems/cartesian.cc.bak b/contrib/world_builder/source/world_builder/coordinate_systems/cartesian.cc.bak
deleted file mode 100644
index a6222ae9161..00000000000
--- a/contrib/world_builder/source/world_builder/coordinate_systems/cartesian.cc.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/coordinate_systems/cartesian.h"
-#include "world_builder/types/object.h"
-
-
-namespace WorldBuilder
-{
-  namespace CoordinateSystems
-  {
-    Cartesian::Cartesian(WorldBuilder::World *world_)
-    {
-      this->world = world_;
-    }
-
-    Cartesian::~Cartesian()
-      = default;
-
-    void
-    Cartesian::declare_entries(Parameters &prm, const std::string & /*unused*/)
-    {
-      prm.declare_entry("", Types::Object(),
-                        "A Cartesian coordinate system. Coordinates are (x,y,z) and extend infinitely in all directions.");
-    }
-
-    void
-    Cartesian::parse_entries(Parameters & /*prm*/)
-    {}
-
-
-    CoordinateSystem
-    Cartesian::natural_coordinate_system() const
-    {
-      return CoordinateSystem::cartesian;
-    }
-
-
-    DepthMethod
-    Cartesian::depth_method() const
-    {
-      return DepthMethod::none;
-    }
-
-
-    std::array<double,3>
-    Cartesian::cartesian_to_natural_coordinates(const std::array<double,3> &position) const
-    {
-      return position;
-    }
-
-
-    std::array<double,3>
-    Cartesian::natural_to_cartesian_coordinates(const std::array<double,3> &position) const
-    {
-      return position;
-    }
-
-
-    double
-    Cartesian::distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const
-    {
-      WBAssert(point_1.get_coordinate_system() == cartesian,
-               "Can not convert non-Cartesian points through the Cartesian coordinate system.");
-      WBAssert(point_2.get_coordinate_system() == cartesian,
-               "Can not convert non-Cartesian points through the Cartesian coordinate system.");
-      // Todo: check that points are at the same depth.
-      const Point<3> difference = point_1-point_2;
-      const Point<2> point_at_depth(difference[0],difference[1], cartesian);
-
-      return point_at_depth.norm();
-    }
-
-
-    double
-    Cartesian::max_model_depth() const
-    {
-      return std::numeric_limits<double>::infinity();
-    }
-
-    /**
-     * Register plugin
-     */
-    WB_REGISTER_COORDINATE_SYSTEM(Cartesian, cartesian)
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/coordinate_systems/interface.cc.bak b/contrib/world_builder/source/world_builder/coordinate_systems/interface.cc.bak
deleted file mode 100644
index 6332ef2b2ce..00000000000
--- a/contrib/world_builder/source/world_builder/coordinate_systems/interface.cc.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/coordinate_systems/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/object.h"
-
-
-namespace WorldBuilder
-{
-  namespace CoordinateSystems
-  {
-
-    Interface::Interface()
-      = default;
-
-    Interface::~Interface ()
-      = default;
-
-    void
-    Interface::declare_entries(Parameters &prm, const std::string &parent_name, const std::vector<std::string> &required_entries)
-    {
-
-      unsigned int counter = 0;
-      for (auto &iter : get_declare_map())
-        {
-          prm.enter_subsection("oneOf");
-          {
-            prm.enter_subsection(std::to_string(counter));
-            {
-              prm.enter_subsection("properties");
-              {
-                prm.declare_entry("", Types::Object(required_entries), "Coordinate system object");
-
-                prm.declare_entry("model",Types::String("",iter.first),
-                                  "The name of the coordinate system to use.");
-
-                iter.second(prm, parent_name);
-              }
-              prm.leave_subsection();
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          counter++;
-
-        }
-    }
-
-    void
-    Interface::registerType(const std::string &name,
-                            void ( *declare_entries)(Parameters &, const std::string &),
-                            ObjectFactory *factory)
-    {
-      get_factory_map()[name] = factory;
-      get_declare_map()[name] = declare_entries;
-    }
-
-    std::unique_ptr<Interface>
-    Interface::create(const std::string &name, WorldBuilder::World *world)
-    {
-      std::string lower_case_name;
-      std::transform(name.begin(),
-                     name.end(),
-                     std::back_inserter(lower_case_name),
-                     ::tolower);;
-
-      // Have a nice assert message to check whether a plugin exists in the case
-      // of a debug compilation.
-      WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                    "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                    "The size of factories is " << get_factory_map().size() << '.');
-
-      // Using at() because the [] will just insert values
-      // which is undesirable in this case. An exception is
-      // thrown when the name is not present.
-      return get_factory_map().at(lower_case_name)->create(world);
-    }
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/coordinate_systems/invalid.cc.bak b/contrib/world_builder/source/world_builder/coordinate_systems/invalid.cc.bak
deleted file mode 100644
index 72ca62e9034..00000000000
--- a/contrib/world_builder/source/world_builder/coordinate_systems/invalid.cc.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/coordinate_systems/invalid.h"
-#include "world_builder/types/object.h"
-
-
-namespace WorldBuilder
-{
-  namespace CoordinateSystems
-  {
-    Invalid::Invalid(WorldBuilder::World *world_)
-    {
-      this->world = world_;
-    }
-
-    Invalid::~Invalid()
-      = default;
-
-    void
-    Invalid::parse_entries(Parameters & /*prm*/)
-    {}
-
-
-    CoordinateSystem
-    Invalid::natural_coordinate_system() const
-    {
-      return CoordinateSystem::invalid;
-    }
-
-
-    DepthMethod
-    Invalid::depth_method() const
-    {
-      return DepthMethod::none;
-    }
-
-
-    std::array<double,3>
-    Invalid::cartesian_to_natural_coordinates(const std::array<double,3> & /*position*/) const
-    {
-      return {{NaN::DQNAN,NaN::DQNAN,NaN::DQNAN}};
-    }
-
-
-    std::array<double,3>
-    Invalid::natural_to_cartesian_coordinates(const std::array<double,3> & /*position*/) const
-    {
-      return {{NaN::DQNAN,NaN::DQNAN,NaN::DQNAN}};
-    }
-
-
-    double
-    Invalid::distance_between_points_at_same_depth(const Point<3> & /*point_1*/, const Point<3> & /*point_2*/) const
-    {
-      return NaN::DQNAN;
-    }
-
-
-    double
-    Invalid::max_model_depth() const
-    {
-      return NaN::DQNAN;
-    }
-
-    /**
-     * Not registering plugin because this is only used for testing.
-     */
-    //WB_REGISTER_COORDINATE_SYSTEM(Invalid, invalid)
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/coordinate_systems/spherical.cc.bak b/contrib/world_builder/source/world_builder/coordinate_systems/spherical.cc.bak
deleted file mode 100644
index 0ed922b9b9b..00000000000
--- a/contrib/world_builder/source/world_builder/coordinate_systems/spherical.cc.bak
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/coordinate_systems/spherical.h"
-
-
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/utilities.h"
-
-namespace WorldBuilder
-{
-  namespace CoordinateSystems
-  {
-    Spherical::Spherical(WorldBuilder::World *world_)
-    {
-      this->world = world_;
-    }
-
-    Spherical::~Spherical()
-      = default;
-
-    void
-    Spherical::declare_entries(Parameters &prm, const std::string & /*unused*/)
-    {
-
-      // Add depth method to the required parameters.
-      prm.declare_entry("", Types::Object({"depth method"}),
-                        "A spherical coordinate system. The coordinates are (radius, longitude, latitude). "
-                        "The radius is set in this plugin, the longitude extends at least from -360 to 360 degrees, "
-                        "and the latitude extends from -90 to 90. It is required to choose a depth method. Please "
-                        "see the manual for more information.");
-
-
-      prm.declare_entry("depth method",
-                        Types::String("",std::vector<std::string>({"starting point", "begin segment","begin at end segment", "continuous"})),
-                        R"(Which depth method to use in the spherical case. The available options are 'starting point', )"
-                        R"('begin segment' and 'begin at end segment'. See the manual section on coordinate systems for )"
-                        R"(more info.)");
-
-      prm.declare_entry("radius",
-                        Types::Double(6371000.),
-                        R"(The radius of the sphere.)");
-
-
-    }
-
-    void
-    Spherical::parse_entries(Parameters &prm)
-    {
-      prm.enter_subsection("coordinate system");
-      {
-        const std::string string_depth_method = prm.get<std::string>("depth method");
-        if (string_depth_method == "starting point")
-          used_depth_method = DepthMethod::angle_at_starting_point_with_surface;
-        else if (string_depth_method == "begin segment")
-          used_depth_method = DepthMethod::angle_at_begin_segment_with_surface;
-        else if (string_depth_method == "begin at end segment")
-          used_depth_method = DepthMethod::angle_at_begin_segment_applied_to_end_segment_with_surface;
-        //else if (string_depth_method == "continuous")
-        //used_depth_method = DepthMethod::continuous_angle_with_surface;
-        else
-          WBAssertThrow(true,"Option " << string_depth_method << " is not a valid depth method for spherical "
-                        "coordinates. The available options are 'starting point', 'begin segment' and 'begin at end segment'. "
-                        "The option 'continuous' is not yet available.");
-
-        radius_sphere = prm.get<double>("radius");
-      }
-      prm.leave_subsection();
-    }
-
-
-    CoordinateSystem
-    Spherical::natural_coordinate_system() const
-    {
-      return CoordinateSystem::spherical;
-    }
-
-
-    DepthMethod
-    Spherical::depth_method() const
-    {
-      return used_depth_method;
-    }
-
-
-    std::array<double,3>
-    Spherical::cartesian_to_natural_coordinates(const std::array<double,3> &position) const
-    {
-      return Utilities::cartesian_to_spherical_coordinates(Point<3>(position,cartesian));
-    }
-
-
-    std::array<double,3>
-    Spherical::natural_to_cartesian_coordinates(const std::array<double,3> &position) const
-    {
-      return Utilities::spherical_to_cartesian_coordinates(position).get_array();
-    }
-
-    double
-    Spherical::distance_between_points_at_same_depth(const Point<3> &point_1, const Point<3> &point_2) const
-    {
-      WBAssert(point_1.get_coordinate_system() == spherical,
-               "Can not convert non spherical points through the spherical coordinate system.");
-      WBAssert(point_2.get_coordinate_system() == spherical,
-               "Can not convert non spherical points through the spherical coordinate system.");
-      const double radius = point_1[0];
-      WBAssert((radius - point_2[0]) < std::numeric_limits<double>::epsilon() * std::max(1.0,radius), "The radius of point 1 is not the same as the radius of point 2.");
-
-      // based on https://math.stackexchange.com/questions/1304169/distance-between-two-points-on-a-sphere
-      const Point<3> point_1_cart = Utilities::spherical_to_cartesian_coordinates(point_1.get_array());
-      const Point<3> point_2_cart = Utilities::spherical_to_cartesian_coordinates(point_2.get_array());
-
-      return radius * std::acos(std::min(1.,std::max(0.,point_1_cart*point_2_cart/(radius*radius))));
-    }
-
-
-    double
-    Spherical::max_model_depth() const
-    {
-      return radius_sphere;
-    }
-
-    /**
-     * Register plugin
-     */
-    WB_REGISTER_COORDINATE_SYSTEM(Spherical, spherical)
-  } // namespace CoordinateSystems
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate.cc.bak
deleted file mode 100644
index 31ca36646b9..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate.cc.bak
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate.h"
-
-
-#include "world_builder/features/continental_plate_models/composition/interface.h"
-#include "world_builder/features/continental_plate_models/grains/interface.h"
-#include "world_builder/features/continental_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/plugin_system.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-#include <iostream>
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    ContinentalPlate::ContinentalPlate(WorldBuilder::World *world_)
-      :
-      min_depth(NaN::DSNAN),
-      max_depth(NaN::DSNAN)
-    {
-      this->world = world_;
-      this->name = "continental plate";
-    }
-
-    ContinentalPlate::~ContinentalPlate()
-      = default;
-
-    void ContinentalPlate::make_snippet(Parameters &prm)
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-
-      const std::string path = prm.get_full_json_path();
-
-      Pointer((path + "/body").c_str()).Set(declarations,"object");
-      Pointer((path + "/body/model").c_str()).Set(declarations,"continental plate");
-      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Plate}");
-      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
-    }
-
-
-
-    void
-    ContinentalPlate::declare_entries(Parameters &prm,
-                                      const std::string & /*unused*/,
-                                      const std::vector<std::string> &required_entries)
-    {
-
-
-
-      prm.declare_entry("", Types::Object(required_entries), "Continental plate object. Requires properties `model` and `coordinates`.");
-
-      prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                        "The depth from which this feature is present");
-      prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                        "The depth to which this feature is present");
-      prm.declare_entry("temperature models",
-                        Types::PluginSystem("", Features::ContinentalPlateModels::Temperature::Interface::declare_entries, {"model"}),
-                        "A list of temperature models.");
-      prm.declare_entry("composition models",
-                        Types::PluginSystem("", Features::ContinentalPlateModels::Composition::Interface::declare_entries, {"model"}),
-                        "A list of composition models.");
-      prm.declare_entry("grains models",
-                        Types::PluginSystem("", Features::ContinentalPlateModels::Grains::Interface::declare_entries, {"model"}),
-                        "A list of grains models.");
-    }
-
-    void
-    ContinentalPlate::parse_entries(Parameters &prm)
-    {
-      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
-
-      this->name = prm.get<std::string>("name");
-
-      std::string tag = prm.get<std::string>("tag");
-      if (tag == "")
-        {
-          tag = "continental plate";
-        }
-      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
-
-      this->get_coordinates("coordinates", prm, coordinate_system);
-
-      min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-      min_depth = min_depth_surface.minimum;
-
-      max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-      max_depth = max_depth_surface.maximum;
-
-
-      prm.get_unique_pointers<Features::ContinentalPlateModels::Temperature::Interface>("temperature models", temperature_models);
-
-      prm.enter_subsection("temperature models");
-      {
-        for (unsigned int i = 0; i < temperature_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              temperature_models[i]->parse_entries(prm,coordinates);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-
-      prm.get_unique_pointers<Features::ContinentalPlateModels::Composition::Interface>("composition models", composition_models);
-
-      prm.enter_subsection("composition models");
-      {
-        for (unsigned int i = 0; i < composition_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              composition_models[i]->parse_entries(prm, coordinates);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-
-      prm.get_unique_pointers<Features::ContinentalPlateModels::Grains::Interface>("grains models", grains_models);
-
-      prm.enter_subsection("grains models");
-      {
-        for (unsigned int i = 0; i < grains_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              grains_models[i]->parse_entries(prm,coordinates);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-    }
-
-
-
-    void
-    ContinentalPlate::properties(const Point<3> &position_in_cartesian_coordinates,
-                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                 const double depth,
-                                 const std::vector<std::array<unsigned int,3>> &properties,
-                                 const double gravity_norm,
-                                 const std::vector<size_t> &entry_in_output,
-                                 std::vector<double> &output) const
-    {
-      if (depth <= max_depth && depth >= min_depth &&
-          WorldBuilder::Utilities::polygon_contains_point(coordinates, Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
-                                                                                world->parameters.coordinate_system->natural_coordinate_system())))
-        {
-          const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-          const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-          if (depth <= max_depth_local &&  depth >= min_depth_local)
-            {
-              for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
-                {
-                  switch (properties[i_property][0])
-                    {
-                      case 1:  // temperature
-                      {
-                        for (const auto &temperature_model: temperature_models)
-                          {
-                            output[entry_in_output[i_property]] = temperature_model->get_temperature(position_in_cartesian_coordinates,
-                                                                                                     position_in_natural_coordinates,
-                                                                                                     depth,
-                                                                                                     gravity_norm,
-                                                                                                     output[entry_in_output[i_property]],
-                                                                                                     min_depth_local,
-                                                                                                     max_depth_local);
-
-                            WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Temperature is not a number: " << output[entry_in_output[i_property]]
-                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-                            WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Temperature is not a finite: " << output[entry_in_output[i_property]]
-                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-
-                          }
-                        break;
-                        case 2: // composition
-
-                          for (const auto &composition_model: composition_models)
-                            {
-                              output[entry_in_output[i_property]] = composition_model->get_composition(position_in_cartesian_coordinates,
-                                                                                                       position_in_natural_coordinates,
-                                                                                                       depth,
-                                                                                                       properties[i_property][1],
-                                                                                                       output[entry_in_output[i_property]],
-                                                                                                       min_depth_local,
-                                                                                                       max_depth_local);
-
-                              WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Composition is not a number: " << output[entry_in_output[i_property]]
-                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-                              WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Composition is not a finite: " << output[entry_in_output[i_property]]
-                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-
-                            }
-
-                          break;
-                        }
-                      case 3: // grains
-                      {
-                        WorldBuilder::grains  grains(output,properties[i_property][2],entry_in_output[i_property]);
-                        for (const auto &grains_model: grains_models)
-                          {
-                            grains = grains_model->get_grains(position_in_cartesian_coordinates,
-                                                              position_in_natural_coordinates,
-                                                              depth,
-                                                              properties[i_property][1],
-                                                              grains,
-                                                              min_depth_local,
-                                                              max_depth_local);
-
-                          }
-                        grains.unroll_into(output,entry_in_output[i_property]);
-                        break;
-                      }
-                      case 4:
-                      {
-                        output[entry_in_output[i_property]] = static_cast<double>(tag_index);
-                        break;
-                      }
-                      default:
-                      {
-                        WBAssertThrow(false,
-                                      "Internal error: Unimplemented property provided. " <<
-                                      "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
-                                      "Provided property number was: " << properties[i_property][0]);
-                      }
-                    }
-                }
-            }
-        }
-    }
-
-    WB_REGISTER_FEATURE(ContinentalPlate, continental plate)
-
-  } // namespace Features
-} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/interface.cc.bak
deleted file mode 100644
index 6f48a19c616..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/interface.cc.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/composition/interface.h"
-
-#include <algorithm>
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Composition
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Composition
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/random.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/random.cc.bak
deleted file mode 100644
index cfb0d2086b5..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/random.cc.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/composition/random.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-#include <random>
-
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace ContinentalPlateModels
-    {
-      namespace Composition
-      {
-        Random::Random(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-        {
-          this->world = world_;
-          this->name = "random";
-        }
-
-        Random::~Random()
-          = default;
-
-        void
-        Random::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform compositional model. Sets constant compositional field.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the labels of the composition which are present there.");
-
-          prm.declare_entry("min value", Types::Array(Types::Double(0.0),1),
-                            "Minimum value of the range within which we want to generate a random compositional value "
-                            "corresponding to the compositional field.");
-
-          prm.declare_entry("max value", Types::Array(Types::Double(1.0),1),
-                            "Maximum value of the range within which we want to generate a random compositional value "
-                            "corresponding to the compositional field.");
-
-          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value. Replacing implies that all compositions not "
-                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
-
-        }
-
-        void
-        Random::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-
-          compositions = prm.get_vector<unsigned int>("compositions");
-          min_value    = prm.get_vector<double>("min value");
-          max_value    = prm.get_vector<double>("max value");
-          operation    = string_operations_to_enum(prm.get<std::string>("operation"));
-        }
-
-
-        double
-        Random::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                const double depth,
-                                const unsigned int composition_number,
-                                double composition,
-                                const double  /*feature_min_depth*/,
-                                const double  /*feature_max_depth*/) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i : compositions)
-                    {
-                      if (i == composition_number)
-                        {
-                          std::uniform_real_distribution<> dist(min_value[0], max_value[0]);
-                          const double composition_ = dist(world->get_random_number_engine());
-                          return apply_operation(operation,composition,composition_);
-                        }
-                    }
-
-                  if (operation == Operations::REPLACE)
-                    return 0.0;
-                }
-            }
-          return composition;
-        }
-        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_COMPOSITION_MODEL(Random, random)
-      } // namespace Composition
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/uniform.cc.bak
deleted file mode 100644
index 51130ef82c3..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/composition/uniform.cc.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/composition/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace ContinentalPlateModels
-    {
-      namespace Composition
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform compositional model. Sets constant compositional field.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the labels of the composition which are present there.");
-
-          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
-                            "TA list of compositional fractions corresponding to the compositions list.");
-
-          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value. Replacing implies that all compositions not "
-                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-
-          compositions = prm.get_vector<unsigned int>("compositions");
-          fractions = prm.get_vector<double>("fractions");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          WBAssertThrow(compositions.size() == fractions.size(),
-                        "There are not the same amount of compositions and fractions.");
-        }
-
-
-        double
-        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                 const double depth,
-                                 const unsigned int composition_number,
-                                 double composition,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          return apply_operation(operation,composition,fractions[i]);
-                        }
-                    }
-
-                  if (operation == Operations::REPLACE)
-                    return 0.0;
-                }
-            }
-          return composition;
-        }
-        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_COMPOSITION_MODEL(Uniform, uniform)
-      } // namespace Composition
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/interface.cc.bak
deleted file mode 100644
index c10e151f158..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/interface.cc.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/grains/interface.h"
-
-#include <algorithm>
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Grains
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          prm.declare_model_entries("grains",parent_name, get_declare_map(),required_entries);
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Grains
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution.cc.bak
deleted file mode 100644
index 516b9413ad6..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution.cc.bak
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/grains/random_uniform_distribution.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution";
-        }
-
-        RandomUniformDistribution::~RandomUniformDistribution()
-          = default;
-
-        void
-        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistribution::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                              const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                              const double depth,
-                                              const unsigned int composition_number,
-                                              WorldBuilder::grains grains_,
-                                              const double  /*feature_min_depth*/,
-                                              const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          std::uniform_real_distribution<> dist(0.0,1.0);
-                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                            {
-                              // set a uniform random a_cosine_matrix per grain
-                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                              // and is licenend accourding to this website with the following licence:
-                              //
-                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                              // don't be a jerk, and remember that anything free comes with no guarantee.""
-                              //
-                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                              // the public domain, and is yours to study, modify, and use."
-
-                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                              const double one = dist(world->get_random_number_engine());
-                              const double two = dist(world->get_random_number_engine());
-                              const double three = dist(world->get_random_number_engine());
-
-                              const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
-                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                              const double z = 2.0* three; //For magnitude of pole deflection.
-
-                              // Compute a vector V used for distributing points over the sphere
-                              // via the reflection I - V Transpose(V).  This formulation of V
-                              // will guarantee that if x[1] and x[2] are uniformly distributed,
-                              // the reflected points will be uniform on the sphere.  Note that V
-                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                              const double r  = std::sqrt( z );
-                              const double Vx = std::sin( phi ) * r;
-                              const double Vy = std::cos( phi ) * r;
-                              const double Vz = std::sqrt( 2.F - z );
-
-                              // Compute the row vector S = Transpose(V) * R, where R is a simple
-                              // rotation by theta about the z-axis.  No need to compute Sz since
-                              // it's just Vz.
-
-                              const double st = std::sin( theta );
-                              const double ct = std::cos( theta );
-                              const double Sx = Vx * ct - Vy * st;
-                              const double Sy = Vx * st + Vy * ct;
-
-                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                              // is equivalent to V S - R.
-
-                              it_rotation_matrices[0][0] = Vx * Sx - ct;
-                              it_rotation_matrices[0][1] = Vx * Sy - st;
-                              it_rotation_matrices[0][2] = Vx * Vz;
-
-                              it_rotation_matrices[1][0] = Vy * Sx + st;
-                              it_rotation_matrices[1][1] = Vy * Sy - ct;
-                              it_rotation_matrices[1][2] = Vy * Vz;
-
-                              it_rotation_matrices[2][0] = Vz * Sx;
-                              it_rotation_matrices[2][1] = Vz * Sy;
-                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                            }
-
-                          double total_size = 0;
-                          for (auto &&it_sizes : grains_local.sizes)
-                            {
-                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                              total_size += it_sizes;
-                            }
-
-                          if (normalize_grain_sizes[i])
-                            {
-                              const double one_over_total_size = 1/total_size;
-                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                            }
-
-
-                          return grains_local;
-                        }
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
-      } // namespace Grains
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.cc.bak
deleted file mode 100644
index 02150f29edc..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.cc.bak
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/grains/random_uniform_distribution_deflected.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution deflected";
-        }
-
-        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
-          = default;
-
-        void
-        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-          prm.declare_entry("deflections",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistributionDeflected::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-          deflections = prm.get_vector<double>("deflections");
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == deflections.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and deflections (" << deflections.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                                       const double depth,
-                                                       const unsigned int composition_number,
-                                                       WorldBuilder::grains grains_,
-                                                       const double  /*feature_min_depth*/,
-                                                       const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          std::uniform_real_distribution<> dist(0.0,1.0);
-                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                            {
-                              // set a uniform random a_cosine_matrix per grain
-                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                              // and is licenend accourding to this website with the following licence:
-                              //
-                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                              // don't be a jerk, and remember that anything free comes with no guarantee.""
-                              //
-                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                              // the public domain, and is yours to study, modify, and use."
-
-                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                              const double one = dist(world->get_random_number_engine());
-                              const double two = dist(world->get_random_number_engine());
-                              const double three = dist(world->get_random_number_engine());
-
-                              const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z)
-                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                              const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
-
-                              // Compute a vector V used for distributing points over the sphere
-                              // via the reflection I - V Transpose(V).  This formulation of V
-                              // will guarantee that if x[1] and x[2] are uniformly distributed,
-                              // the reflected points will be uniform on the sphere.  Note that V
-                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                              const double r  = std::sqrt( z );
-                              const double Vx = std::sin( phi ) * r;
-                              const double Vy = std::cos( phi ) * r;
-                              const double Vz = std::sqrt( 2.F - z );
-
-                              // Compute the row vector S = Transpose(V) * R, where R is a simple
-                              // rotation by theta about the z-axis.  No need to compute Sz since
-                              // it's just Vz.
-
-                              const double st = std::sin( theta );
-                              const double ct = std::cos( theta );
-                              const double Sx = Vx * ct - Vy * st;
-                              const double Sy = Vx * st + Vy * ct;
-
-                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                              // is equivalent to V S - R.
-
-                              it_rotation_matrices[0][0] = Vx * Sx - ct;
-                              it_rotation_matrices[0][1] = Vx * Sy - st;
-                              it_rotation_matrices[0][2] = Vx * Vz;
-
-                              it_rotation_matrices[1][0] = Vy * Sx + st;
-                              it_rotation_matrices[1][1] = Vy * Sy - ct;
-                              it_rotation_matrices[1][2] = Vy * Vz;
-
-                              it_rotation_matrices[2][0] = Vz * Sx;
-                              it_rotation_matrices[2][1] = Vz * Sy;
-                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                            }
-
-                          double total_size = 0;
-                          for (auto &&it_sizes : grains_local.sizes)
-                            {
-                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                              total_size += it_sizes;
-                            }
-
-                          if (normalize_grain_sizes[i])
-                            {
-                              const double one_over_total_size = 1/total_size;
-                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                            }
-
-
-                          return grains_local;
-                        }
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
-      } // namespace Grains
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/uniform.cc.bak
deleted file mode 100644
index 110bd919078..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/grains/uniform.cc.bak
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/grains/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/utilities.h"
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Grains
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform grains model. All grains start exactly the same.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
-                            "A list with the rotation matrices of the grains which are present there for each compositions.");
-
-          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
-                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace", "multiply"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(-1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
-
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
-          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
-
-          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
-                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
-
-
-          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
-                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
-
-          if (set_euler_angles)
-            {
-              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
-              rotation_matrices.resize(euler_angles_vector.size());
-              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
-                {
-                  rotation_matrices[i] = Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
-                }
-
-            }
-          else
-            {
-              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
-            }
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-
-
-          WBAssertThrow(compositions.size() == rotation_matrices.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                            const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                            const double depth,
-                            const unsigned int composition_number,
-                            WorldBuilder::grains grains_,
-                            const double  /*feature_min_depth*/,
-                            const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
-
-                          const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
-                          std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
-
-                          return grains_local;
-                        }
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_GRAINS_MODEL(Uniform, uniform)
-      } // namespace Grains
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/adiabatic.cc.bak
deleted file mode 100644
index 88d83639032..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/adiabatic.cc.bak
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/temperature/adiabatic.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace ContinentalPlateModels
-    {
-      namespace Temperature
-      {
-        Adiabatic::Adiabatic(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          potential_mantle_temperature(NaN::DSNAN),
-          thermal_expansion_coefficient(NaN::DSNAN),
-          specific_heat(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "adiabatic";
-        }
-
-        Adiabatic::~Adiabatic()
-          = default;
-
-        void
-        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          prm.declare_entry("", Types::Object(),
-                            "Adiabatic temperature model. Uses global values by default.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("potential mantle temperature", Types::Double(-1),
-                            "The potential temperature of the mantle at the surface in Kelvin. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
-                            "The thermal expansion coefficient in $K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("specific heat", Types::Double(-1),
-                            "The specific heat in $J kg^{-1} K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-        }
-
-        void
-        Adiabatic::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
-          if (potential_mantle_temperature < 0)
-            potential_mantle_temperature =  this->world->potential_mantle_temperature;
-
-
-          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
-          if (thermal_expansion_coefficient < 0)
-            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
-
-          specific_heat = prm.get<double>("specific heat");
-          if (specific_heat < 0)
-            specific_heat =  this->world->specific_heat;
-
-          // Some assertions in debug mode can't hurt and have helped before.
-          WBAssert(!std::isnan(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
-          WBAssert(std::isfinite(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
-
-          WBAssert(!std::isnan(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
-
-          WBAssert(!std::isnan(specific_heat),
-                   "specific_heat is not a number: " << specific_heat << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "specific_heat is not a finite: " << specific_heat << '.');
-
-        }
-
-
-        double
-        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity_norm,
-                                   double temperature_,
-                                   const double /*feature_min_depth*/,
-                                   const double /*feature_max_depth*/) const
-        {
-
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  const double adabatic_temperature = potential_mantle_temperature *
-                                                      std::exp(((thermal_expansion_coefficient * gravity_norm) /
-                                                                specific_heat) * depth);
-
-
-                  WBAssert(!std::isnan(adabatic_temperature),
-                           "adabatic_temperature is not a number: " << adabatic_temperature << ". "
-                           <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
-                           <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
-                           << ", gravity_norm = " << gravity_norm
-                           << ", specific_heat = " << specific_heat
-                           << ", depth = " << depth);
-
-                  WBAssert(std::isfinite(adabatic_temperature),
-                           "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
-
-                  return apply_operation(operation,temperature_,adabatic_temperature);
-                }
-            }
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_TEMPERATURE_MODEL(Adiabatic, adiabatic)
-      } // namespace Temperature
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/interface.cc.bak
deleted file mode 100644
index 1e582d955ce..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/interface.cc.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/temperature/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Temperature
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          // The type needs to be stored in a separate value, otherwise there are memory issues
-          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
-
-          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
-          {
-            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
-            {
-              "operation", type,
-              "Whether the value should replace any value previously defined at this location (replace), "
-              "add the value to the previously define value (add) or subtract the value to the previously "
-              "define value (subtract)."
-            }
-          });
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Temperature
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/linear.cc.bak
deleted file mode 100644
index 2c92fae4f7d..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/linear.cc.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/temperature/linear.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace ContinentalPlateModels
-    {
-      namespace Temperature
-      {
-        Linear::Linear(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          top_temperature(NaN::DSNAN),
-          bottom_temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "linear";
-        }
-
-        Linear::~Linear()
-          = default;
-
-        void
-        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `max depth` to the required parameters.
-          prm.declare_entry("", Types::Object({"max depth"}),
-                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("top temperature", Types::Double(293.15),
-                            "The temperature at the top in degree Kelvin of this feature."
-                            "If the value is below zero, the an adiabatic temperature is used.");
-
-          prm.declare_entry("bottom temperature", Types::Double(-1),
-                            "The temperature at the top in degree Kelvin of this feature. "
-                            "If the value is below zero, an adiabatic temperature is used.");
-
-        }
-
-        void
-        Linear::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          top_temperature = prm.get<double>("top temperature");
-          bottom_temperature = prm.get<double>("bottom temperature");
-        }
-
-
-        double
-        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                const double depth,
-                                const double gravity_norm,
-                                double temperature_,
-                                const double feature_min_depth,
-                                const double feature_max_depth) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  const double min_depth_local_local = std::max(feature_min_depth, min_depth_local);
-                  const double max_depth_local_local = std::min(feature_max_depth, max_depth_local);
-
-                  double top_temperature_local = top_temperature;
-                  if (top_temperature_local < 0)
-                    {
-                      top_temperature_local =  this->world->potential_mantle_temperature *
-                                               std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                         this->world->specific_heat) * min_depth_local_local);
-                    }
-
-                  double bottom_temperature_local = bottom_temperature;
-                  if (bottom_temperature_local < 0)
-                    {
-                      bottom_temperature_local =  this->world->potential_mantle_temperature *
-                                                  std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                            this->world->specific_heat) * max_depth_local_local);
-                    }
-
-                  const double new_temperature = top_temperature_local + (max_depth_local_local - min_depth_local_local < 10.0*std::numeric_limits<double>::epsilon() ? 0.0 :
-                                                        (depth - min_depth_local) *
-                                                        ((bottom_temperature_local - top_temperature_local) / (max_depth_local_local - min_depth_local_local)));
-
-                  WBAssert(!std::isnan(new_temperature), "Temperature is not a number: " << new_temperature
-                           << ", based on a temperature model with the name " << this->name);
-                  WBAssert(std::isfinite(new_temperature), "Temperature is not a finite: " << new_temperature
-                           << ", based on a temperature model with the name " << this->name
-                           << ", top_temperature_local = " << top_temperature_local << ", depth = " << depth << ", min_depth_local = " << min_depth_local
-                           << ", bottom_temperature_local= " << bottom_temperature_local << ", top_temperature_local=" << top_temperature_local
-                           << ",max_depth_local_local=" << max_depth_local_local << ", min_depth_local_local =" << min_depth_local_local
-                           << ", feature_max_depth = " << feature_max_depth << ", feature_max_depth = " << feature_max_depth);
-
-                  return apply_operation(operation,temperature_,new_temperature);
-                }
-            }
-
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_TEMPERATURE_MODEL(Linear, linear)
-      } // namespace Temperature
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/uniform.cc.bak
deleted file mode 100644
index ff4b8d695b3..00000000000
--- a/contrib/world_builder/source/world_builder/features/continental_plate_models/temperature/uniform.cc.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/continental_plate_models/temperature/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace ContinentalPlateModels
-    {
-      namespace Temperature
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `temperature` to the required parameters.
-          prm.declare_entry("", Types::Object({"temperature"}),
-                            "Uniform temperature model. Set the temperature to a constant value.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("temperature", Types::Double(293.15),
-                            "The temperature in degree Kelvin which this feature should have");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          temperature = prm.get<double>("temperature");
-        }
-
-
-        double
-        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                 const double depth,
-                                 const double  /*gravity*/,
-                                 double temperature_,
-                                 const double /*feature_min_depth*/,
-                                 const double /*feature_max_depth*/) const
-        {
-          const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-          const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-          if (depth <= max_depth_local &&  depth >= min_depth_local)
-            {
-              if (depth <= max_depth && depth >= min_depth)
-                {
-                  return apply_operation(operation,temperature_,temperature);
-                }
-            }
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_CONTINENTAL_PLATE_TEMPERATURE_MODEL(Uniform, uniform)
-      } // namespace Temperature
-    } // namespace ContinentalPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/fault.cc.bak b/contrib/world_builder/source/world_builder/features/fault.cc.bak
deleted file mode 100644
index 7f0c43fd5bf..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault.cc.bak
+++ /dev/null
@@ -1,730 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include "world_builder/features/fault.h"
-
-
-#include "glm/glm.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/point.h"
-#include "world_builder/types/segment.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/world.h"
-#include <algorithm>
-
-using namespace std;
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    Fault::Fault(WorldBuilder::World *world_)
-      :
-      reference_point(0,0,cartesian)
-    {
-      this->world = world_;
-      this->name = "fault";
-    }
-
-    Fault::~Fault()
-      = default;
-
-
-
-    void Fault::make_snippet(Parameters &prm)
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-
-      const std::string path = prm.get_full_json_path();
-
-      Pointer((path + "/body").c_str()).Set(declarations,"object");
-      Pointer((path + "/body/model").c_str()).Set(declarations,"fault");
-      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Fault}");
-      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/segments").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/sections").c_str()).Create(declarations).SetArray();
-    }
-
-
-
-    void
-    Fault::declare_entries(Parameters &prm,
-                           const std::string &parent_name,
-                           const std::vector<std::string> &required_entries)
-    {
-
-      // This statement is needed because of the recursion associated with
-      // the sections entry.
-      if (parent_name == "items")
-        {
-          prm.enter_subsection("properties");
-        }
-      else
-        {
-          prm.declare_entry("", Types::Object(required_entries), "Fault object. Requires properties `model` and `coordinates`.");
-        }
-      prm.declare_entry("min depth", Types::Double(0),
-                        "The depth to which this feature is present");
-      prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
-                        "The depth to which this feature is present");
-      prm.declare_entry("dip point", Types::Point<2>(),
-                        "The depth to which this feature is present");
-
-      prm.declare_entry("segments", Types::Array(Types::Segment(0,Point<2>(0,0,invalid),Point<2>(0,0,invalid),Point<2>(0,0,invalid),
-                                                                Types::PluginSystem("", Features::FaultModels::Temperature::Interface::declare_entries, {"model"}),
-                                                                Types::PluginSystem("", Features::FaultModels::Composition::Interface::declare_entries, {"model"}),
-                                                                Types::PluginSystem("", Features::FaultModels::Grains::Interface::declare_entries, {"model"}))),
-                        "The depth to which this feature is present");
-
-      prm.declare_entry("temperature models",
-                        Types::PluginSystem("", Features::FaultModels::Temperature::Interface::declare_entries, {"model"}),
-                        "A list of temperature models.");
-      prm.declare_entry("composition models",
-                        Types::PluginSystem("", Features::FaultModels::Composition::Interface::declare_entries, {"model"}),
-                        "A list of composition models.");
-      prm.declare_entry("grains models",
-                        Types::PluginSystem("", Features::FaultModels::Grains::Interface::declare_entries, {"model"}),
-                        "A list of grains models.");
-
-      if (parent_name != "items")
-        {
-          // This only happens if we are not in sections
-          prm.declare_entry("sections", Types::Array(Types::PluginSystem("",Features::Fault::declare_entries, {"coordinate"}, false)),"A list of feature properties for a coordinate.");
-        }
-      else
-        {
-
-          // this only happens in sections
-          prm.declare_entry("coordinate", Types::UnsignedInt(0),
-                            "The coordinate which should be overwritten");
-
-          prm.leave_subsection();
-        }
-    }
-
-    void
-    Fault::parse_entries(Parameters &prm)
-    {
-      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
-
-      this->name = prm.get<std::string>("name");
-
-      std::string tag = prm.get<std::string>("tag");
-      if (tag == "")
-        {
-          tag = "fault";
-        }
-      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
-
-      this->get_coordinates("coordinates", prm, coordinate_system);
-
-
-      starting_depth = prm.get<double>("min depth");
-      maximum_depth = prm.get<double>("max depth");
-
-      const size_t n_sections = this->original_number_of_coordinates;
-
-      reference_point = prm.get<Point<2> >("dip point");
-
-      if (coordinate_system == spherical)
-        {
-          // When spherical, input is in degrees, so change to radians for internal use.
-          reference_point *= (Consts::PI/180);
-        }
-
-      default_temperature_models.resize(0);
-      default_composition_models.resize(0);
-      default_grains_models.resize(0);
-      prm.get_shared_pointers<Features::FaultModels::Temperature::Interface>("temperature models", default_temperature_models);
-      prm.get_shared_pointers<Features::FaultModels::Composition::Interface>("composition models", default_composition_models);
-      prm.get_shared_pointers<Features::FaultModels::Grains::Interface>("grains models", default_grains_models);
-
-      // get the default segments.
-      default_segment_vector = prm.get_vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
-      Features::FaultModels::Composition::Interface,
-      Features::FaultModels::Grains::Interface> >("segments", default_temperature_models, default_composition_models,default_grains_models);
-
-
-      // This vector stores segments to this coordinate/section.
-      // First used (raw) pointers to the segment relevant to this coordinate/section,
-      // but I do not trust it won't fail when memory is moved. So storing the all the data now.
-      segment_vector.resize(0);
-      segment_vector.resize(n_sections, default_segment_vector);
-
-
-      // now search whether a section is present, if so, replace the default segments.
-      std::vector<std::unique_ptr<Features::Fault> > sections_vector;
-      prm.get_unique_pointers("sections", sections_vector);
-
-      prm.enter_subsection("sections");
-      for (unsigned int i_section = 0; i_section < n_sections; ++i_section)
-        {
-          // first check whether this section/coordinate has a a special overwrite
-          for (unsigned int i_sector = 0; i_sector < sections_vector.size(); ++i_sector)
-            {
-              prm.enter_subsection(std::to_string(i_sector));
-              {
-                const unsigned int change_coord_number = prm.get<unsigned int>("coordinate");
-
-                WBAssertThrow(segment_vector.size() > change_coord_number, "Error: for subducting plate with name: '" << this->name
-                              << "', trying to change the section of coordinate " << change_coord_number
-                              << " while only " << segment_vector.size() << " coordinates are defined.");
-
-                std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> > local_default_temperature_models;
-                std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface>  > local_default_composition_models;
-                std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface>  > local_default_grains_models;
-
-                if (!prm.get_shared_pointers<Features::FaultModels::Temperature::Interface>("temperature models", local_default_temperature_models))
-                  {
-                    // no local temperature model, use global default
-                    local_default_temperature_models = default_temperature_models;
-                  }
-
-                if (!prm.get_shared_pointers<Features::FaultModels::Composition::Interface>("composition models", local_default_composition_models))
-                  {
-                    // no local composition model, use global default
-                    local_default_composition_models = default_composition_models;
-                  }
-
-                if (!prm.get_shared_pointers<Features::FaultModels::Grains::Interface>("grains models", local_default_grains_models))
-                  {
-                    // no local grains model, use global default
-                    local_default_grains_models = default_grains_models;
-                  }
-
-                segment_vector[change_coord_number] = prm.get_vector<Objects::Segment<Features::FaultModels::Temperature::Interface,
-                                                      Features::FaultModels::Composition::Interface,
-                                                      Features::FaultModels::Grains::Interface> >("segments", local_default_temperature_models, local_default_composition_models, local_default_grains_models);
-
-                WBAssertThrow(segment_vector[change_coord_number].size() == default_segment_vector.size(),
-                              "Error: There are not the same amount of segments in section with coordinate " << change_coord_number
-                              << " (" << segment_vector[change_coord_number].size() << " segments) as in the default segment ("
-                              << default_segment_vector.size() << " segments). This is not allowed.");
-
-                prm.enter_subsection("segments");
-                {
-                  for (unsigned int i = 0; i < segment_vector[change_coord_number].size(); ++i)
-                    {
-                      prm.enter_subsection(std::to_string(i));
-                      {
-                        prm.enter_subsection("temperature models");
-                        {
-                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].temperature_systems.size(); ++j)
-                            {
-                              prm.enter_subsection(std::to_string(j));
-                              {
-                                segment_vector[change_coord_number][i].temperature_systems[j]->parse_entries(prm);
-                              }
-                              prm.leave_subsection();
-                            }
-                        }
-                        prm.leave_subsection();
-
-
-                        prm.enter_subsection("composition models");
-                        {
-                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].composition_systems.size(); ++j)
-                            {
-                              prm.enter_subsection(std::to_string(j));
-                              {
-                                segment_vector[change_coord_number][i].composition_systems[j]->parse_entries(prm);
-                              }
-                              prm.leave_subsection();
-                            }
-                        }
-                        prm.leave_subsection();
-
-
-                        prm.enter_subsection("grains models");
-                        {
-                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].grains_systems.size(); ++j)
-                            {
-                              prm.enter_subsection(std::to_string(j));
-                              {
-                                segment_vector[change_coord_number][i].grains_systems[j]->parse_entries(prm);
-                              }
-                              prm.leave_subsection();
-                            }
-                        }
-                        prm.leave_subsection();
-                      }
-                      prm.leave_subsection();
-                    }
-                }
-                prm.leave_subsection();
-
-              }
-              prm.leave_subsection();
-            }
-
-        }
-      prm.leave_subsection();
-
-
-      prm.enter_subsection("segments");
-      {
-        for (unsigned int i = 0; i < default_segment_vector.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              prm.enter_subsection("temperature models");
-              {
-                for (unsigned int j = 0; j < default_segment_vector[i].temperature_systems.size(); ++j)
-                  {
-                    prm.enter_subsection(std::to_string(j));
-                    {
-                      default_segment_vector[i].temperature_systems[j]->parse_entries(prm);
-                    }
-                    prm.leave_subsection();
-                  }
-              }
-              prm.leave_subsection();
-
-
-              prm.enter_subsection("composition models");
-              {
-                for (unsigned int j = 0; j < default_segment_vector[i].composition_systems.size(); ++j)
-                  {
-                    prm.enter_subsection(std::to_string(j));
-                    {
-                      default_segment_vector[i].composition_systems[j]->parse_entries(prm);
-                    }
-                    prm.leave_subsection();
-                  }
-              }
-              prm.leave_subsection();
-
-
-              prm.enter_subsection("grains models");
-              {
-                for (unsigned int j = 0; j < default_segment_vector[i].grains_systems.size(); ++j)
-                  {
-                    prm.enter_subsection(std::to_string(j));
-                    {
-                      default_segment_vector[i].grains_systems[j]->parse_entries(prm);
-                    }
-                    prm.leave_subsection();
-                  }
-              }
-              prm.leave_subsection();
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-
-      maximum_fault_thickness = 0;
-      maximum_total_fault_length = 0;
-      total_fault_length.resize(original_number_of_coordinates);
-      fault_segment_lengths.resize(original_number_of_coordinates);
-      fault_segment_thickness.resize(original_number_of_coordinates);
-      fault_segment_top_truncation.resize(original_number_of_coordinates);
-      fault_segment_angles.resize(original_number_of_coordinates);
-
-      for (unsigned int i = 0; i < segment_vector.size(); ++i)
-        {
-          double local_total_fault_length = 0;
-          fault_segment_lengths[i].resize(segment_vector[i].size());
-          fault_segment_thickness[i].resize(segment_vector[i].size(), Point<2>(invalid));
-          fault_segment_top_truncation[i].resize(segment_vector[i].size(), Point<2>(invalid));
-          fault_segment_angles[i].resize(segment_vector[i].size(), Point<2>(invalid));
-
-          for (unsigned int j = 0; j < segment_vector[i].size(); ++j)
-            {
-              fault_segment_lengths[i][j] = segment_vector[i][j].value_length;
-              local_total_fault_length += segment_vector[i][j].value_length;
-
-              fault_segment_thickness[i][j] = segment_vector[i][j].value_thickness;
-              maximum_fault_thickness = std::max(maximum_fault_thickness, fault_segment_thickness[i][j][0]);
-              maximum_fault_thickness = std::max(maximum_fault_thickness, fault_segment_thickness[i][j][1]);
-              fault_segment_top_truncation[i][j] = segment_vector[i][j].value_top_truncation;
-
-              fault_segment_angles[i][j] = segment_vector[i][j].value_angle * (Consts::PI/180);
-            }
-          total_fault_length[i] = local_total_fault_length;
-          maximum_total_fault_length = std::max(maximum_total_fault_length, local_total_fault_length);
-        }
-
-
-      // Find minimal and maximal coordinates. Do this by finding the
-      // leftmost/rightmost point with regard to either the [0] or [1]
-      // coordinate, and then takes its [0] or [1] element.
-      auto compare_x_coordinate = [](auto p1, auto p2)
-      {
-        return p1[0]<p2[0];
-      };
-
-      min_along_x = (*std::min_element(coordinates.begin(), coordinates.end(), compare_x_coordinate)) [0];
-      max_along_x = (*std::max_element(coordinates.begin(), coordinates.end(), compare_x_coordinate)) [0];
-
-
-      auto compare_y_coordinate = [](auto p1, auto p2)
-      {
-        return p1[1]<p2[1];
-      };
-
-      min_along_y = (*std::min_element(coordinates.begin(), coordinates.end(), compare_y_coordinate)) [1];
-      max_along_y = (*std::max_element(coordinates.begin(), coordinates.end(), compare_y_coordinate)) [1];
-
-      min_lat_cos_inv = 1. / std::cos(min_along_y);
-      max_lat_cos_inv = 1. / std::cos(max_along_y);
-
-
-      // Compute the surface bounding box
-      buffer_around_fault_cartesian = (maximum_fault_thickness + maximum_total_fault_length);
-      if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical)
-        {
-          const double starting_radius_inv = 1 / (world->parameters.coordinate_system->max_model_depth());
-          std::pair<Point<2>, Point<2> > &spherical_bounding_box = surface_bounding_box.get_boundary_points();
-
-          const double buffer_around_fault_spherical = 2 * Consts::PI * buffer_around_fault_cartesian * starting_radius_inv;
-
-          spherical_bounding_box.first = {(min_along_x - buffer_around_fault_spherical * min_lat_cos_inv) ,
-                                          (min_along_y - buffer_around_fault_spherical), spherical
-                                         } ;
-
-          spherical_bounding_box.second = {(max_along_x + buffer_around_fault_spherical * max_lat_cos_inv) ,
-                                           (max_along_y + buffer_around_fault_spherical), spherical
-                                          };
-        }
-      else if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::cartesian)
-        {
-          std::pair<Point<2>, Point<2> > &bounding_box = surface_bounding_box.get_boundary_points();
-          bounding_box.first = {min_along_x, min_along_y, cartesian};
-          bounding_box.second = {max_along_x, max_along_y, cartesian};
-          surface_bounding_box.extend(buffer_around_fault_cartesian);
-        }
-    }
-
-
-    const BoundingBox<2> &
-    Fault::get_surface_bounding_box () const
-    {
-      return surface_bounding_box;
-    }
-
-
-    void
-    Fault::properties(const Point<3> &position_in_cartesian_coordinates,
-                      const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                      const double depth,
-                      const std::vector<std::array<unsigned int,3>> &properties,
-                      const double gravity_norm,
-                      const std::vector<size_t> &entry_in_output,
-                      std::vector<double> &output) const
-    {
-      // The 'depth coordinate' is the z-coordinate in Cartesian coordinates, and radius in spherical coordinates.
-      // The depth input parameter is the distance from the surface to the position,
-      // the starting radius is the distance from the bottom of the model to the surface.
-      const double starting_radius = position_in_natural_coordinates.get_depth_coordinate() + depth - starting_depth;
-
-      WBAssert(std::abs(starting_radius) > std::numeric_limits<double>::epsilon(), "World Builder error: starting_radius can not be zero. "
-               << "Position = " << position_in_cartesian_coordinates[0] << ':' << position_in_cartesian_coordinates[1] << ':' << position_in_cartesian_coordinates[2]
-               << ", position_in_natural_coordinates.get_depth_coordinate() = " << position_in_natural_coordinates.get_depth_coordinate()
-               << ", depth = " << depth
-               << ", starting_depth " << starting_depth
-              );
-
-      // todo: explain and check -starting_depth
-      if (depth <= maximum_depth && depth >= starting_depth && depth <= maximum_total_fault_length + maximum_fault_thickness &&
-          get_surface_bounding_box().point_inside(Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
-                                                           world->parameters.coordinate_system->natural_coordinate_system())))
-        {
-          // todo: explain
-          const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
-            WorldBuilder::Utilities::distance_point_from_curved_planes(position_in_cartesian_coordinates,
-                                                                       position_in_natural_coordinates,
-                                                                       reference_point,
-                                                                       coordinates,
-                                                                       fault_segment_lengths,
-                                                                       fault_segment_angles,
-                                                                       starting_radius,
-                                                                       this->world->parameters.coordinate_system,
-                                                                       true,
-                                                                       this->bezier_curve);
-
-          const double distance_from_plane = distance_from_planes.distance_from_plane;
-          const double distance_along_plane = distance_from_planes.distance_along_plane;
-          const double section_fraction = distance_from_planes.fraction_of_section;
-          const size_t current_section = distance_from_planes.section;
-          const size_t next_section = current_section + 1;
-          const size_t current_segment = distance_from_planes.segment;
-          const double segment_fraction = distance_from_planes.fraction_of_segment;
-
-          if (abs(distance_from_plane) < std::numeric_limits<double>::infinity() || (distance_along_plane) < std::numeric_limits<double>::infinity())
-            {
-              // We want to do both section (horizontal) and segment (vertical) interpolation.
-              // first for thickness
-              const double thickness_up = fault_segment_thickness[current_section][current_segment][0]
-                                          + section_fraction
-                                          * (fault_segment_thickness[next_section][current_segment][0]
-                                             - fault_segment_thickness[current_section][current_segment][0]);
-              const double thickness_down = fault_segment_thickness[current_section][current_segment][1]
-                                            + section_fraction
-                                            * (fault_segment_thickness[next_section][current_segment][1]
-                                               - fault_segment_thickness[current_section][current_segment][1]);
-              const double thickness_local = thickness_up + segment_fraction * (thickness_down - thickness_up);
-
-
-              // if the thickness is zero, we don't need to compute anything, so return.
-              if (std::fabs(thickness_local) < 2.0 * std::numeric_limits<double>::epsilon())
-                return;
-
-              // secondly for top truncation
-              const double top_truncation_up = fault_segment_top_truncation[current_section][current_segment][0]
-                                               + section_fraction
-                                               * (fault_segment_top_truncation[next_section][current_segment][0]
-                                                  - fault_segment_top_truncation[current_section][current_segment][0]);
-              const double top_truncation_down = fault_segment_top_truncation[current_section][current_segment][1]
-                                                 + section_fraction
-                                                 * (fault_segment_top_truncation[next_section][current_segment][1]
-                                                    - fault_segment_top_truncation[current_section][current_segment][1]);
-              const double top_truncation_local = top_truncation_up + segment_fraction * (top_truncation_down - top_truncation_up);
-
-              // if the thickness is smaller than what is truncated off at the top, we don't need to compute anything, so return.
-              if (thickness_local < top_truncation_local)
-                return;
-
-
-
-              const double max_fault_length = total_fault_length[current_section] +
-                                              section_fraction *
-                                              (total_fault_length[next_section] - total_fault_length[current_section]);
-              const AdditionalParameters additional_parameters = {max_fault_length,thickness_local};
-
-              // Check if we are inside the fault.
-              // Every distance from -thickness/2 to +thickness/2 is inside the fault.
-              if (std::fabs(distance_from_plane) <= thickness_local * 0.5 &&
-                  distance_along_plane > 0 &&
-                  distance_along_plane <= max_fault_length)
-                {
-                  for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
-                    {
-                      switch (properties[i_property][0])
-                        {
-                          case 1: // temperature
-                          {
-                            double temperature_current_section = output[entry_in_output[i_property]];
-                            double temperature_next_section = output[entry_in_output[i_property]];
-
-                            for (const auto &temperature_model: segment_vector[current_section][current_segment].temperature_systems)
-                              {
-                                temperature_current_section = temperature_model->get_temperature(position_in_cartesian_coordinates,
-                                                                                                 depth,
-                                                                                                 gravity_norm,
-                                                                                                 temperature_current_section,
-                                                                                                 starting_depth,
-                                                                                                 maximum_depth,
-                                                                                                 distance_from_planes,
-                                                                                                 additional_parameters);
-
-                                WBAssert(!std::isnan(temperature_current_section), "Temperature is not a number: " << temperature_current_section
-                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-                                WBAssert(std::isfinite(temperature_current_section), "Temperature is not finite: " << temperature_current_section
-                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-
-                              }
-
-                            for (const auto &temperature_model: segment_vector[next_section][current_segment].temperature_systems)
-                              {
-                                temperature_next_section = temperature_model->get_temperature(position_in_cartesian_coordinates,
-                                                                                              depth,
-                                                                                              gravity_norm,
-                                                                                              temperature_next_section,
-                                                                                              starting_depth,
-                                                                                              maximum_depth,
-                                                                                              distance_from_planes,
-                                                                                              additional_parameters);
-
-                                WBAssert(!std::isnan(temperature_next_section), "Temperature is not a number: " << temperature_next_section
-                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-                                WBAssert(std::isfinite(temperature_next_section), "Temperature is not a finite: " << temperature_next_section
-                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-
-                              }
-
-                            // linear interpolation between current and next section temperatures
-                            output[entry_in_output[i_property]] = temperature_current_section + section_fraction * (temperature_next_section - temperature_current_section);
-                            break;
-                          }
-                          case 2: // composition
-                          {
-                            double composition_current_section = output[entry_in_output[i_property]];
-                            double composition_next_section = output[entry_in_output[i_property]];
-
-                            for (const auto &composition_model: segment_vector[current_section][current_segment].composition_systems)
-                              {
-                                composition_current_section = composition_model->get_composition(position_in_cartesian_coordinates,
-                                                                                                 depth,
-                                                                                                 properties[i_property][1],
-                                                                                                 composition_current_section,
-                                                                                                 starting_depth,
-                                                                                                 maximum_depth,
-                                                                                                 distance_from_planes,
-                                                                                                 additional_parameters);
-
-                                WBAssert(!std::isnan(composition_current_section), "Composition_current_section is not a number: " << composition_current_section
-                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-                                WBAssert(std::isfinite(composition_current_section), "Composition_current_section is not finite: " << composition_current_section
-                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-
-                              }
-
-                            for (const auto &composition_model: segment_vector[next_section][current_segment].composition_systems)
-                              {
-                                composition_next_section = composition_model->get_composition(position_in_cartesian_coordinates,
-                                                                                              depth,
-                                                                                              properties[i_property][1],
-                                                                                              composition_next_section,
-                                                                                              starting_depth,
-                                                                                              maximum_depth,
-                                                                                              distance_from_planes,
-                                                                                              additional_parameters);
-
-                                WBAssert(!std::isnan(composition_next_section), "Composition_next_section is not a number: " << composition_next_section
-                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-                                WBAssert(std::isfinite(composition_next_section), "Composition_next_section is not finite: " << composition_next_section
-                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-
-                              }
-
-                            // linear interpolation between current and next section temperatures
-                            output[entry_in_output[i_property]] = composition_current_section + section_fraction * (composition_next_section - composition_current_section);
-                            break;
-                          }
-                          case 3: // grains
-                          {
-                            WorldBuilder::grains grains(output,properties[i_property][2],entry_in_output[i_property]);
-                            WorldBuilder::grains grains_current_section = grains;
-                            WorldBuilder::grains grains_next_section = grains;
-
-                            for (const auto &grains_model: segment_vector[current_section][current_segment].grains_systems)
-                              {
-                                grains_current_section = grains_model->get_grains(position_in_cartesian_coordinates,
-                                                                                  depth,
-                                                                                  properties[i_property][1],
-                                                                                  grains_current_section,
-                                                                                  starting_depth,
-                                                                                  maximum_depth,
-                                                                                  distance_from_planes,
-                                                                                  additional_parameters);
-
-                              }
-
-                            for (const auto &grains_model: segment_vector[next_section][current_segment].grains_systems)
-                              {
-                                grains_next_section = grains_model->get_grains(position_in_cartesian_coordinates,
-                                                                               depth,
-                                                                               properties[i_property][1],
-                                                                               grains_next_section,
-                                                                               starting_depth,
-                                                                               maximum_depth,
-                                                                               distance_from_planes,
-                                                                               additional_parameters);
-
-                              }
-
-                            // linear interpolation between current and next section temperatures
-                            for (size_t i = 0; i < grains.sizes.size(); i++)
-                              {
-                                grains.sizes[i] = grains_current_section.sizes[i] + section_fraction * (grains_next_section.sizes[i] - grains_current_section.sizes[i]);
-                              }
-
-                            // average two rotations matrices through quaternions.
-                            for (size_t i = 0; i < grains_current_section.rotation_matrices.size(); i++)
-                              {
-                                const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(grains_current_section.rotation_matrices[i]);
-                                const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(grains_next_section.rotation_matrices[i]);
-
-                                const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,section_fraction);
-
-                                grains.rotation_matrices[i] = glm::quaternion::mat3_cast(quat_average);
-                              }
-
-                            grains.unroll_into(output,entry_in_output[i_property]);
-                            break;
-                          }
-                          case 4:
-                          {
-                            output[entry_in_output[i_property]] = static_cast<double>(tag_index);
-                            break;
-                          }
-                          default:
-                          {
-                            WBAssertThrow(false,
-                                          "Internal error: Unimplemented property provided. " <<
-                                          "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
-                                          "Provided property number was: " << properties[i_property][0]);
-                          }
-                        }
-                    }
-
-                }
-            }
-        }
-
-    }
-
-    Objects::PlaneDistances
-    Fault::distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
-                                     const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                     const double depth) const
-    {
-      // The depth variable is the distance from the surface to the position, the depth
-      // coordinate is the distance from the bottom of the model to the position and
-      // the starting radius is the distance from the bottom of the model to the surface.
-      const double starting_radius = position_in_natural_coordinates.get_depth_coordinate() + depth - starting_depth;
-
-      WBAssert(std::abs(starting_radius) > std::numeric_limits<double>::epsilon(), "World Builder error: starting_radius can not be zero. "
-               << "Position = " << position_in_cartesian_coordinates[0] << ':' << position_in_cartesian_coordinates[1] << ':' << position_in_cartesian_coordinates[2]
-               << ", natural_coordinate.get_depth_coordinate() = " << position_in_natural_coordinates.get_depth_coordinate()
-               << ", depth = " << depth
-               << ", starting_depth " << starting_depth
-              );
-
-      const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
-        WorldBuilder::Utilities::distance_point_from_curved_planes(position_in_cartesian_coordinates,
-                                                                   position_in_natural_coordinates,
-                                                                   reference_point,
-                                                                   coordinates,
-                                                                   fault_segment_lengths,
-                                                                   fault_segment_angles,
-                                                                   starting_radius,
-                                                                   this->world->parameters.coordinate_system,
-                                                                   false,
-                                                                   this->bezier_curve);
-
-      Objects::PlaneDistances plane_distances(distance_from_planes.distance_from_plane, distance_from_planes.distance_along_plane);
-      return plane_distances;
-    }
-
-    /**
-     * Register plugin
-     */
-    WB_REGISTER_FEATURE(Fault, fault)
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/composition/interface.cc.bak
deleted file mode 100644
index ed645a38e29..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/composition/interface.cc.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/composition/interface.h"
-
-#include <algorithm>
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Composition
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/composition/smooth.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/composition/smooth.cc.bak
deleted file mode 100644
index e9e31c1bdf7..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/composition/smooth.cc.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/composition/smooth.h"
-
-#include <world_builder/assert.h>
-#include <world_builder/nan.h>
-#include <world_builder/parameters.h>
-#include <world_builder/utilities.h>
-
-#include <world_builder/types/array.h>
-#include <world_builder/types/double.h>
-#include <world_builder/types/object.h>
-#include <world_builder/types/string.h>
-#include <world_builder/types/unsigned_int.h>
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        Smooth::Smooth(WorldBuilder::World *world_)
-          :
-          min_distance(NaN::DSNAN),
-          side_distance(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "smooth";
-        }
-
-        Smooth::~Smooth()
-          = default;
-
-        void
-        Smooth::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}), "Compositional model object");
-
-          prm.declare_entry("min distance fault center", Types::Double(0),
-                            "The distance in meters from which the composition of this feature is present.");
-          prm.declare_entry("side distance fault center", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance over which the composition is reduced from 1 to 0.");
-          prm.declare_entry("center fractions",  Types::Array(Types::Double(1.0),1),
-                            "The composition fraction at the center of the fault.");
-          prm.declare_entry("side fractions",  Types::Array(Types::Double(0.0),1),
-                            "The composition fraction at the sides of this feature.");
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the labels of the composition which are present there.");
-          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value. Replacing implies that all compositions not "
-                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
-        }
-
-        void
-        Smooth::parse_entries(Parameters &prm)
-        {
-          min_distance = prm.get<double>("min distance fault center");
-          side_distance = prm.get<double>("side distance fault center");
-          WBAssert(side_distance >= min_distance, "distance at the side needs to be larger or equal than the min distance.");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          center_fraction = prm.get_vector<double>("center fractions");
-          side_fraction = prm.get_vector<double>("side fractions");
-          compositions = prm.get_vector<unsigned int>("compositions");
-        }
-
-
-        double
-        Smooth::get_composition( const Point<3> & /*position*/,
-                                 const double  /*depth*/,
-                                 const unsigned int composition_number,
-                                 double composition_,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/,
-                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                 const AdditionalParameters & /*additional_parameters*/) const
-        {
-          double composition = composition_;
-
-          for (unsigned int i =0; i < compositions.size(); ++i)
-            {
-              if (compositions[i] == composition_number)
-                {
-
-                  // Hyperbolic tangent goes from 0 to 1 over approximately x=(0, 2) without any arguments. The function is written
-                  // so that the composition returned 1 to 0 over the side_distance on either sides.
-                  composition = (center_fraction[i] - side_fraction[i]) * ( 1 - std::tanh(10 * (distance_from_planes.distance_from_plane
-                                                                                                - side_distance/2)/side_distance ) )/2 ;
-
-                  return apply_operation(operation,composition_,composition);
-                }
-            }
-
-          if (operation == Operations::REPLACE)
-            return 0.0;
-
-          return composition;
-        }
-
-        WB_REGISTER_FEATURE_FAULT_COMPOSITION_MODEL (Smooth, smooth)
-      } // namespace Composition
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/composition/uniform.cc.bak
deleted file mode 100644
index c125eb39440..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/composition/uniform.cc.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/composition/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform compositional model. Sets constant compositional field.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance fault center", Types::Double(0),
-                            "The distance in meters from which the composition of this feature is present.");
-          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance in meters to which the composition of this feature is present.");
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the labels of the composition which are present there.");
-          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
-                            "TA list of compositional fractions corresponding to the compositions list.");
-          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value. Replacing implies that all compositions not "
-                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance fault center");
-          max_depth = prm.get<double>("max distance fault center");
-          compositions = prm.get_vector<unsigned int>("compositions");
-          fractions = prm.get_vector<double>("fractions");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          WBAssertThrow(compositions.size() == fractions.size(),
-                        "There are not the same amount of compositions and fractions.");
-        }
-
-
-        double
-        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const double  /*depth*/,
-                                 const unsigned int composition_number,
-                                 double composition,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/,
-                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
-                                 const AdditionalParameters & /*additional_parameters*/) const
-        {
-          if (std::fabs(distance_from_plane.distance_from_plane) <= max_depth && std::fabs(distance_from_plane.distance_from_plane) >= min_depth)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      return apply_operation(operation,composition,fractions[i]);
-                    }
-                }
-
-              if (operation == Operations::REPLACE)
-                return 0.0;
-            }
-          return composition;
-        }
-        WB_REGISTER_FEATURE_FAULT_COMPOSITION_MODEL(Uniform, uniform)
-      } // namespace Composition
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/grains/interface.cc.bak
deleted file mode 100644
index 12de398c263..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/grains/interface.cc.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/grains/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/object.h"
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Grains
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          unsigned int counter = 0;
-          for (auto &it : get_declare_map())
-            {
-              // prevent infinite recursion
-              if (it.first != parent_name)
-                {
-                  prm.enter_subsection("oneOf");
-                  {
-                    prm.enter_subsection(std::to_string(counter));
-                    {
-                      prm.enter_subsection("properties");
-                      {
-                        prm.declare_entry("", Types::Object(required_entries), "grains object");
-
-                        prm.declare_entry("model", Types::String("",it.first),
-                                          "The name of the grains model.");
-
-                        it.second(prm, parent_name);
-                      }
-                      prm.leave_subsection();
-                    }
-                    prm.leave_subsection();
-                  }
-                  prm.leave_subsection();
-
-                  counter++;
-
-                }
-            }
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Grains
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution.cc.bak
deleted file mode 100644
index 06ccaebcad0..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution.cc.bak
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/grains/random_uniform_distribution.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution";
-        }
-
-        RandomUniformDistribution::~RandomUniformDistribution()
-          = default;
-
-        void
-        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance fault center", Types::Double(0),
-                            "The distance from the fault center in meters from which the composition of this feature is present.");
-          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance from the fault in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistribution::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance fault center");
-          max_depth = prm.get<double>("max distance fault center");
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                              const double /*depth*/,
-                                              const unsigned int composition_number,
-                                              WorldBuilder::grains grains_,
-                                              const double /*feature_min_depth*/,
-                                              const double /*feature_max_depth*/,
-                                              const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                              const AdditionalParameters & /*additional_parameters*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (std::fabs(distance_from_planes.distance_from_plane) <= max_depth && std::fabs(distance_from_planes.distance_from_plane) >= min_depth)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      std::uniform_real_distribution<> dist(0.0,1.0);
-                      for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                        {
-                          // set a uniform random a_cosine_matrix per grain
-                          // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                          // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                          // and is licenend accourding to this website with the following licence:
-                          //
-                          // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                          // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                          // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                          // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                          // don't be a jerk, and remember that anything free comes with no guarantee.""
-                          //
-                          // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                          // the public domain, and is yours to study, modify, and use."
-
-                          // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                          const double one = dist(world->get_random_number_engine());
-                          const double two = dist(world->get_random_number_engine());
-                          const double three = dist(world->get_random_number_engine());
-
-                          const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
-                          const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                          const double z = 2.0* three; //For magnitude of pole deflection.
-
-                          // Compute a vector V used for distributing points over the sphere
-                          // via the reflection I - V Transpose(V).  This formulation of V
-                          // will guarantee that if x[1] and x[2] are uniformly distributed,
-                          // the reflected points will be uniform on the sphere.  Note that V
-                          // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                          const double r  = std::sqrt( z );
-                          const double Vx = std::sin( phi ) * r;
-                          const double Vy = std::cos( phi ) * r;
-                          const double Vz = std::sqrt( 2.F - z );
-
-                          // Compute the row vector S = Transpose(V) * R, where R is a simple
-                          // rotation by theta about the z-axis.  No need to compute Sz since
-                          // it's just Vz.
-
-                          const double st = std::sin( theta );
-                          const double ct = std::cos( theta );
-                          const double Sx = Vx * ct - Vy * st;
-                          const double Sy = Vx * st + Vy * ct;
-
-                          // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                          // is equivalent to V S - R.
-
-                          it_rotation_matrices[0][0] = Vx * Sx - ct;
-                          it_rotation_matrices[0][1] = Vx * Sy - st;
-                          it_rotation_matrices[0][2] = Vx * Vz;
-
-                          it_rotation_matrices[1][0] = Vy * Sx + st;
-                          it_rotation_matrices[1][1] = Vy * Sy - ct;
-                          it_rotation_matrices[1][2] = Vy * Vz;
-
-                          it_rotation_matrices[2][0] = Vz * Sx;
-                          it_rotation_matrices[2][1] = Vz * Sy;
-                          it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                        }
-
-                      double total_size = 0;
-                      for (auto &&it_sizes : grains_local.sizes)
-                        {
-                          it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                          total_size += it_sizes;
-                        }
-
-                      if (normalize_grain_sizes[i])
-                        {
-                          const double one_over_total_size = 1/total_size;
-                          std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                         [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                        }
-
-                      return grains_local;
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_FAULT_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
-      } // namespace Grains
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.cc.bak
deleted file mode 100644
index 1f970ee202e..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/grains/random_uniform_distribution_deflected.cc.bak
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/grains/random_uniform_distribution_deflected.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution deflected";
-        }
-
-        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
-          = default;
-
-        void
-        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance fault center", Types::Double(0),
-                            "The distance from the fault center in meters from which the composition of this feature is present.");
-          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance from the fault in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-          prm.declare_entry("deflections",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistributionDeflected::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance fault center");
-          max_depth = prm.get<double>("max distance fault center");
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-          deflections = prm.get_vector<double>("deflections");
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == deflections.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and deflections (" << deflections.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                                       const double /*depth*/,
-                                                       const unsigned int composition_number,
-                                                       WorldBuilder::grains grains_,
-                                                       const double /*feature_min_depth*/,
-                                                       const double /*feature_max_depth*/,
-                                                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                                       const AdditionalParameters & /*additional_parameters*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (std::fabs(distance_from_planes.distance_from_plane) <= max_depth && std::fabs(distance_from_planes.distance_from_plane) >= min_depth)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      std::uniform_real_distribution<> dist(0.0,1.0);
-                      for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                        {
-                          // set a uniform random a_cosine_matrix per grain
-                          // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                          // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                          // and is licenend accourding to this website with the following licence:
-                          //
-                          // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                          // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                          // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                          // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                          // don't be a jerk, and remember that anything free comes with no guarantee.""
-                          //
-                          // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                          // the public domain, and is yours to study, modify, and use."
-
-                          // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                          const double one = dist(world->get_random_number_engine());
-                          const double two = dist(world->get_random_number_engine());
-                          const double three = dist(world->get_random_number_engine());
-
-                          const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z).
-                          const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                          const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
-
-                          // Compute a vector V used for distributing points over the sphere
-                          // via the reflection I - V Transpose(V).  This formulation of V
-                          // will guarantee that if x[1] and x[2] are uniformly distributed,
-                          // the reflected points will be uniform on the sphere.  Note that V
-                          // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                          const double r  = std::sqrt( z );
-                          const double Vx = std::sin( phi ) * r;
-                          const double Vy = std::cos( phi ) * r;
-                          const double Vz = std::sqrt( 2.F - z );
-
-                          // Compute the row vector S = Transpose(V) * R, where R is a simple
-                          // rotation by theta about the z-axis.  No need to compute Sz since
-                          // it's just Vz.
-
-                          const double st = std::sin( theta );
-                          const double ct = std::cos( theta );
-                          const double Sx = Vx * ct - Vy * st;
-                          const double Sy = Vx * st + Vy * ct;
-
-                          // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                          // is equivalent to V S - R.
-
-                          it_rotation_matrices[0][0] = Vx * Sx - ct;
-                          it_rotation_matrices[0][1] = Vx * Sy - st;
-                          it_rotation_matrices[0][2] = Vx * Vz;
-
-                          it_rotation_matrices[1][0] = Vy * Sx + st;
-                          it_rotation_matrices[1][1] = Vy * Sy - ct;
-                          it_rotation_matrices[1][2] = Vy * Vz;
-
-                          it_rotation_matrices[2][0] = Vz * Sx;
-                          it_rotation_matrices[2][1] = Vz * Sy;
-                          it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                        }
-
-                      double total_size = 0;
-                      for (auto &&it_sizes : grains_local.sizes)
-                        {
-                          it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                          total_size += it_sizes;
-                        }
-
-                      if (normalize_grain_sizes[i])
-                        {
-                          const double one_over_total_size = 1/total_size;
-                          std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                         [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                        }
-
-                      return grains_local;
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_FAULT_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
-      } // namespace Grains
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/grains/uniform.cc.bak
deleted file mode 100644
index d1449f81bb9..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/grains/uniform.cc.bak
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/grains/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Grains
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform grains model. All grains start exactly the same.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance fault center", Types::Double(0),
-                            "The distance from the fault center in meters from which the composition of this feature is present.");
-          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance from the fault in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
-                            "A list with the labels of the grains which are present there for each compositions.");
-
-          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
-                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(-1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
-
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance fault center");
-          max_depth = prm.get<double>("max distance fault center");
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
-          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
-
-          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
-                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
-
-
-          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
-                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
-
-          if (set_euler_angles)
-            {
-              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
-              rotation_matrices.resize(euler_angles_vector.size());
-              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
-                {
-                  rotation_matrices[i] = WorldBuilder::Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
-                }
-
-            }
-          else
-            {
-              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
-            }
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-
-
-          WBAssertThrow(compositions.size() == rotation_matrices.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                            const double /*depth*/,
-                            const unsigned int composition_number,
-                            WorldBuilder::grains grains_,
-                            const double /*feature_min_depth*/,
-                            const double /*feature_max_depth*/,
-                            const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                            const AdditionalParameters & /*additional_parameters*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (std::fabs(distance_from_planes.distance_from_plane) <= max_depth && std::fabs(distance_from_planes.distance_from_plane) >= min_depth)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
-
-                      const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
-                      std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
-
-                      return grains_local;
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_FAULT_GRAINS_MODEL(Uniform, uniform)
-      } // namespace Grains
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/temperature/adiabatic.cc.bak
deleted file mode 100644
index 64b98312018..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/temperature/adiabatic.cc.bak
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/temperature/adiabatic.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Temperature
-      {
-        Adiabatic::Adiabatic(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          potential_mantle_temperature(NaN::DSNAN),
-          thermal_expansion_coefficient(NaN::DSNAN),
-          specific_heat(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "adiabatic";
-        }
-
-        Adiabatic::~Adiabatic()
-          = default;
-
-        void
-        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          prm.declare_entry("", Types::Object(),
-                            "Adiabatic temperature model. Uses global values by default.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance fault center", Types::Double(0),
-                            "todo The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
-                            "todo The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("potential mantle temperature", Types::Double(-1),
-                            "The potential temperature of the mantle at the surface in Kelvin. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
-                            "The thermal expansion coefficient in $K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("specific heat", Types::Double(-1),
-                            "The specific heat in $J kg^{-1} K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-        }
-
-        void
-        Adiabatic::parse_entries(Parameters &prm)
-        {
-
-          min_depth = prm.get<double>("min distance fault center");
-          max_depth = prm.get<double>("max distance fault center");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
-          if (potential_mantle_temperature < 0)
-            potential_mantle_temperature =  this->world->potential_mantle_temperature;
-
-
-          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
-          if (thermal_expansion_coefficient < 0)
-            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
-
-          specific_heat = prm.get<double>("specific heat");
-          if (specific_heat < 0)
-            specific_heat =  this->world->specific_heat;
-
-          // Some assertions in debug mode can't hurt and have helped before.
-          WBAssert(!std::isnan(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
-          WBAssert(std::isfinite(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
-
-          WBAssert(!std::isnan(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
-
-          WBAssert(!std::isnan(specific_heat),
-                   "specific_heat is not a number: " << specific_heat << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "specific_heat is not a finite: " << specific_heat << '.');
-
-        }
-
-
-        double
-        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                   const double depth,
-                                   const double gravity_norm,
-                                   double temperature_,
-                                   const double  /*feature_min_depth*/,
-                                   const double  /*feature_max_depth*/,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes & /*distance_from_planes*/,
-                                   const AdditionalParameters & /*additional_parameters*/) const
-        {
-
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double adabatic_temperature = potential_mantle_temperature *
-                                                  std::exp(((thermal_expansion_coefficient * gravity_norm) /
-                                                            specific_heat) * depth);
-
-
-              WBAssert(!std::isnan(adabatic_temperature),
-                       "adabatic_temperature is not a number: " << adabatic_temperature << ". "
-                       <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
-                       <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
-                       << ", gravity_norm = " << gravity_norm
-                       << ", specific_heat = " << specific_heat
-                       << ", depth = " << depth);
-
-              WBAssert(std::isfinite(adabatic_temperature),
-                       "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
-
-              return apply_operation(operation,temperature_,adabatic_temperature);
-            }
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_FAULT_TEMPERATURE_MODEL(Adiabatic, adiabatic)
-      } // namespace Temperature
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/temperature/interface.cc.bak
deleted file mode 100644
index fe7d7b00284..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/temperature/interface.cc.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-
-#include "world_builder/features/fault_models/temperature/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Temperature
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          // The type needs to be stored in a separate value, otherwise there are memory issues
-          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
-
-          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
-          {
-            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
-            {
-              "operation", type,
-              "Whether the value should replace any value previously defined at this location (replace), "
-              "add the value to the previously define value (add) or subtract the value to the previously "
-              "define value (subtract)."
-            }
-          });
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Temperature
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/temperature/linear.cc.bak
deleted file mode 100644
index 16a1f2b03d7..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/temperature/linear.cc.bak
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/temperature/linear.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Temperature
-      {
-        Linear::Linear(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          center_temperature(NaN::DSNAN),
-          side_temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "linear";
-        }
-
-        Linear::~Linear()
-          = default;
-
-        void
-        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `max distance fault` center to the required parameters.
-          prm.declare_entry("", Types::Object({"max distance fault center"}),
-                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance fault center", Types::Double(0),
-                            "The minimum distance to the center of the fault. This determines where the linear temperature starts.");
-
-          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
-                            "The minimum distance to the center of the fault. This determines where the linear temperature end.");
-
-          prm.declare_entry("center temperature", Types::Double(293.15),
-                            "The temperature at the center of this feature in degree Kelvin."
-                            "If the value is below zero, the an adiabatic temperature is used.");
-
-          prm.declare_entry("side temperature", Types::Double(-1),
-                            "The temperature at the sides of this feature in degree Kelvin. "
-                            "If the value is below zero, an adiabatic temperature is used.");
-
-        }
-
-        void
-        Linear::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance fault center");
-          max_depth = prm.get<double>("max distance fault center");
-          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          center_temperature = prm.get<double>("center temperature");
-          side_temperature = prm.get<double>("side temperature");
-        }
-
-
-        double
-        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                const double /*depth*/,
-                                const double gravity_norm,
-                                double temperature_,
-                                const double /*feature_min_depth*/,
-                                const double /*feature_max_depth*/,
-                                const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                const AdditionalParameters & /*additional_parameters*/) const
-        {
-
-          if (std::fabs(distance_from_planes.distance_from_plane) <= max_depth && std::fabs(distance_from_planes.distance_from_plane) >= min_depth)
-            {
-              const double min_depth_local = min_depth;
-              const double max_depth_local = max_depth;
-
-              double center_temperature_local = center_temperature;
-              if (center_temperature_local < 0)
-                {
-                  center_temperature_local =  this->world->potential_mantle_temperature *
-                                              std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                        this->world->specific_heat) * min_depth_local);
-                }
-
-              double side_temperature_local = side_temperature;
-              if (side_temperature_local < 0)
-                {
-                  side_temperature_local =  this->world->potential_mantle_temperature *
-                                            std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                      this->world->specific_heat) * max_depth_local);
-                }
-
-              const double new_temperature =   center_temperature_local +
-                                               (std::fabs(distance_from_planes.distance_from_plane) - min_depth_local) *
-                                               ((side_temperature_local - center_temperature_local) / (max_depth_local - min_depth_local));
-
-              return apply_operation(operation,temperature_,new_temperature);
-
-            }
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_FAULT_TEMPERATURE_MODEL(Linear, linear)
-      } // namespace Temperature
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/fault_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/fault_models/temperature/uniform.cc.bak
deleted file mode 100644
index fdddb360d1a..00000000000
--- a/contrib/world_builder/source/world_builder/features/fault_models/temperature/uniform.cc.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/fault_models/temperature/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Temperature
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `temperature` and to the required parameters.
-          prm.declare_entry("", Types::Object({"temperature"}),
-                            "Uniform temperature model. Set the temperature to a constant value.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance fault center", Types::Double(0),
-                            "The distance in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max distance fault center", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("temperature", Types::Double(293.15),
-                            "The temperature in degree Kelvin which this feature should have");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance fault center");
-          max_depth = prm.get<double>("max distance fault center");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          temperature = prm.get<double>("temperature");
-        }
-
-
-        double
-        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const double  /*depth*/,
-                                 const double  /*gravity*/,
-                                 double temperature_,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/,
-                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
-                                 const AdditionalParameters & /*additional_parameters*/) const
-        {
-
-          if (std::fabs(distance_from_plane.distance_from_plane) <= max_depth && std::fabs(distance_from_plane.distance_from_plane) >= min_depth)
-            {
-              return apply_operation(operation,temperature_,temperature);
-            }
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_FAULT_TEMPERATURE_MODEL(Uniform, uniform)
-      } // namespace Temperature
-    } // namespace FaultModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/feature_utilities.cc.bak b/contrib/world_builder/source/world_builder/features/feature_utilities.cc.bak
deleted file mode 100644
index 4bbd05f3fa8..00000000000
--- a/contrib/world_builder/source/world_builder/features/feature_utilities.cc.bak
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/feature_utilities.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace FeatureUtilities
-    {
-      Operations
-      string_operations_to_enum(const std::string &operation)
-      {
-        if (operation == "add") return Operations::ADD;
-        if (operation == "subtract") return Operations::SUBTRACT;
-        if (operation == "replace defined only") return Operations::REPLACE_DEFINED_ONLY;
-
-        WBAssert(operation == "replace", "Could not find operation: " << operation << '.');
-        return Operations::REPLACE;
-      }
-
-      size_t
-      add_vector_unique(std::vector<std::string> &vector,const std::string &add_string)
-      {
-        for (size_t i = 0; i < vector.size(); ++i)
-          {
-            if (vector[i] == add_string)
-              {
-                return i;
-              }
-          }
-
-        vector.push_back(add_string);
-        return vector.size()-1;
-      }
-    } // namespace FeatureUtilities
-  } // namespace Features
-} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/features/interface.cc.bak b/contrib/world_builder/source/world_builder/features/interface.cc.bak
deleted file mode 100644
index 0678ad0635e..00000000000
--- a/contrib/world_builder/source/world_builder/features/interface.cc.bak
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/array.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/point.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace Internal
-    {
-
-
-
-      /**
-       * A function to turn strings into interpolation type enums.
-       */
-      static InterpolationType string_to_interpolation_type (const std::string &string)
-      {
-        if (string == "continuous monotone spline")
-          {
-            return InterpolationType::ContinuousMonotoneSpline;
-          }
-
-        WBAssertThrow(false,
-                      "You provided an interpolation type which is not supported: " << string
-                      << "This may be due to all options besides continuous monotone spline have been "
-                      << "removed since version 0.5. It is best to remove the interpolation variable "
-                      << "from you input file as it may be removed in future versions.");
-
-        return InterpolationType::Invalid;
-      }
-    } // namespace Internal
-
-    Interface::Interface()
-      = default;
-
-    Interface::~Interface ()
-      = default;
-
-    void
-    Interface::declare_entries(Parameters &prm, const std::string &parent_name, const std::vector<std::string> &required_entries)
-    {
-
-      {
-        using namespace rapidjson;
-        Document &declarations = prm.declarations;
-
-        prm.enter_subsection("defaultSnippets");
-        const std::string path = prm.get_full_json_path();
-
-        unsigned int idx = 0;
-        for (auto  &it : get_snippet_map())
-          {
-            std::string item =  path + "/"+std::to_string(idx);
-
-            Pointer((item).c_str()).Set(declarations, "object");
-            Pointer((item+"/label").c_str()).Set(declarations,("add a '" + it.first + "'").c_str());
-            prm.enter_subsection(std::to_string(idx).c_str());
-            it.second(prm);
-            prm.leave_subsection();
-
-            ++idx;
-          }
-
-        prm.leave_subsection();
-      }
-
-      unsigned int counter = 0;
-      for (auto  &it : get_declare_map())
-        {
-          prm.enter_subsection("oneOf");
-          {
-            prm.enter_subsection(std::to_string(counter));
-            {
-
-              prm.enter_subsection("properties");
-              {
-                prm.declare_entry("", Types::Object(required_entries), "feature object");
-
-                prm.declare_entry("model", Types::String("",it.first),
-                                  "The model name of the feature determining its type.");
-                prm.declare_entry("name", Types::String(""),
-                                  "The name which the user has given to the feature. "
-                                  "This is mostly used for documentation purposes, and should in most cases be unique, "
-                                  "although this is not enforced.");
-                prm.declare_entry("tag", Types::String(""),
-                                  "A tag which can be given to a feature. This is meant to categorize different features. "
-                                  "If the tag is not provided or empty, it is set to the model name.");
-                prm.declare_entry("coordinates", Types::Array(Types::Point<2>(), 1),
-                                  "An array of 2d Points representing an array of coordinates where the feature is located.");
-
-                prm.declare_entry("interpolation",Types::String("global"),
-                                  "What type of interpolation should be used to enforce the minimum points per "
-                                  "distance parameter. Options are 'global' and "
-                                  "'continuous monotone spline' interpolation. If this "
-                                  "value is set to global, the global value for interpolation is used. "
-                                  "This option is deprecated and will be removed in a future release.");
-                WBAssert(it.second != NULL, "No declare entries given.");
-                it.second(prm, parent_name, {});
-              }
-              prm.leave_subsection();
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          counter++;
-
-        }
-    }
-
-
-    void
-    Interface::get_coordinates(const std::string & /*unused*/,
-                               Parameters &prm,
-                               const CoordinateSystem coordinate_system)
-    {
-      coordinates = prm.get_vector<Point<2> >("coordinates");
-      if (coordinate_system == CoordinateSystem::spherical)
-        std::transform(coordinates.begin(),coordinates.end(), coordinates.begin(),
-                       [](const WorldBuilder::Point<2> &p) -> WorldBuilder::Point<2> { return p *Consts::PI / 180.0;});
-
-
-      // If global is given, we use the global interpolation setting, otherwise use the provided value.
-      const std::string interpolation_type_string = prm.get<std::string>("interpolation") == "global" ? this->world->interpolation : prm.get<std::string>("interpolation");
-      interpolation_type = WorldBuilder::Features::Internal::string_to_interpolation_type(interpolation_type_string);
-
-      original_number_of_coordinates = coordinates.size();
-
-      WBAssert(interpolation_type == WorldBuilder::Utilities::InterpolationType::Linear ||
-               interpolation_type == WorldBuilder::Utilities::InterpolationType::MonotoneSpline ||
-               interpolation_type == WorldBuilder::Utilities::InterpolationType::ContinuousMonotoneSpline,
-               "For interpolation, linear and monotone spline are the only allowed values. "
-               << "You provided " << interpolation_type_string << '.');
-
-      bezier_curve = Objects::BezierCurve(coordinates);
-
-    }
-
-
-    void
-    Interface::registerType(const std::string &name,
-                            void ( *declare_entries)(Parameters &, const std::string &,const std::vector<std::string> &),
-                            void ( *make_snippet)(Parameters &),
-                            ObjectFactory *factory)
-    {
-      get_factory_map()[name] = factory;
-      get_declare_map()[name] = declare_entries;
-      get_snippet_map()[name] = make_snippet;
-    }
-
-    std::unique_ptr<Interface>
-    Interface::create(const std::string &name, WorldBuilder::World *world)
-    {
-      std::string lower_case_name;
-      std::transform(name.begin(),
-                     name.end(),
-                     std::back_inserter(lower_case_name),
-                     ::tolower);;
-
-      // Have a nice assert message to check whether a plugin exists in the case
-      // of a debug compilation.
-      WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                    "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                    "The size of factories is " << get_factory_map().size() << '.');
-
-      // Using at() because the [] will just insert values
-      // which is undesirable in this case. An exception is
-      // thrown when the name is not present.
-      return get_factory_map().at(lower_case_name)->create(world);
-    }
-
-    Objects::PlaneDistances
-    Interface::distance_to_feature_plane(const Point<3> & /*unused*/,
-                                         const Objects::NaturalCoordinate & /*unused*/,
-                                         const double /*unused*/) const
-    {
-      WBAssertThrow(false, "The distance_to_feature_plane is not yet implemented for the desinated object");
-    }
-
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer.cc.bak
deleted file mode 100644
index 7e66108db0d..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer.cc.bak
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer.h"
-
-
-#include "world_builder/features/mantle_layer_models/composition/interface.h"
-#include "world_builder/features/mantle_layer_models/grains/interface.h"
-#include "world_builder/features/mantle_layer_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/plugin_system.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    MantleLayer::MantleLayer(WorldBuilder::World *world_)
-    {
-      this->world = world_;
-      this->name = "mantle layer";
-    }
-
-    MantleLayer::~MantleLayer()
-      = default;
-
-
-
-    void MantleLayer::make_snippet(Parameters &prm)
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-
-      const std::string path = prm.get_full_json_path();
-
-      Pointer((path + "/body").c_str()).Set(declarations,"object");
-      Pointer((path + "/body/model").c_str()).Set(declarations,"mantle layer");
-      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Mantle Layer}");
-      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/temperature models").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/composition models").c_str()).Create(declarations).SetArray();
-    }
-
-
-
-    void
-    MantleLayer::declare_entries(Parameters &prm,
-                                 const std::string &/*parent_name*/,
-                                 const std::vector<std::string> &required_entries)
-    {
-      prm.declare_entry("", Types::Object(required_entries), "Mantle layer object. Requires properties `model` and `coordinates`.");
-
-      prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                        "The depth from which this feature is present");
-      prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                        "The depth to which this feature is present");
-      prm.declare_entry("temperature models",
-                        Types::PluginSystem("", Features::MantleLayerModels::Temperature::Interface::declare_entries, {"model"}),
-                        "A list of temperature models.");
-      prm.declare_entry("composition models",
-                        Types::PluginSystem("", Features::MantleLayerModels::Composition::Interface::declare_entries, {"model"}),
-                        "A list of composition models.");
-      prm.declare_entry("grains models",
-                        Types::PluginSystem("", Features::MantleLayerModels::Grains::Interface::declare_entries, {"model"}),
-                        "A list of grains models.");
-    }
-
-    void
-    MantleLayer::parse_entries(Parameters &prm)
-    {
-      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
-
-      this->name = prm.get<std::string>("name");
-
-      std::string tag = prm.get<std::string>("tag");
-      if (tag == "")
-        {
-          tag = "mantle layer";
-        }
-      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
-
-      this->get_coordinates("coordinates", prm, coordinate_system);
-
-      min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-      min_depth = min_depth_surface.minimum;
-
-      max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-      max_depth = max_depth_surface.maximum;
-
-
-      prm.get_unique_pointers<Features::MantleLayerModels::Temperature::Interface>("temperature models", temperature_models);
-
-      prm.enter_subsection("temperature models");
-      {
-        for (unsigned int i = 0; i < temperature_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              temperature_models[i]->parse_entries(prm,coordinates);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-
-      prm.get_unique_pointers<Features::MantleLayerModels::Composition::Interface>("composition models", composition_models);
-
-      prm.enter_subsection("composition models");
-      {
-        for (unsigned int i = 0; i < composition_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              composition_models[i]->parse_entries(prm,coordinates);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-
-      prm.get_unique_pointers<Features::MantleLayerModels::Grains::Interface>("grains models", grains_models);
-
-      prm.enter_subsection("grains models");
-      {
-        for (unsigned int i = 0; i < grains_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              grains_models[i]->parse_entries(prm,coordinates);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-    }
-
-
-    void
-    MantleLayer::properties(const Point<3> &position_in_cartesian_coordinates,
-                            const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                            const double depth,
-                            const std::vector<std::array<unsigned int,3>> &properties,
-                            const double gravity_norm,
-                            const std::vector<size_t> &entry_in_output,
-                            std::vector<double> &output) const
-    {
-      if (depth <= max_depth && depth >= min_depth &&
-          WorldBuilder::Utilities::polygon_contains_point(coordinates, Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
-                                                                                world->parameters.coordinate_system->natural_coordinate_system())))
-        {
-          const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-          const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-          if (depth <= max_depth_local &&  depth >= min_depth_local)
-            {
-              for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
-                {
-                  switch (properties[i_property][0])
-                    {
-                      case 1:  // temperature
-                      {
-                        for (const auto &temperature_model: temperature_models)
-                          {
-                            output[entry_in_output[i_property]] = temperature_model->get_temperature(position_in_cartesian_coordinates,
-                                                                                                     position_in_natural_coordinates,
-                                                                                                     depth,
-                                                                                                     gravity_norm,
-                                                                                                     output[entry_in_output[i_property]],
-                                                                                                     min_depth_local,
-                                                                                                     max_depth_local);
-
-                            WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Temperature is not a number: " << output[entry_in_output[i_property]]
-                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-                            WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Temperature is not a finite: " << output[entry_in_output[i_property]]
-                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-
-                          }
-                        break;
-                        case 2: // composition
-
-                          for (const auto &composition_model: composition_models)
-                            {
-                              output[entry_in_output[i_property]] = composition_model->get_composition(position_in_cartesian_coordinates,
-                                                                                                       position_in_natural_coordinates,
-                                                                                                       depth,
-                                                                                                       properties[i_property][1],
-                                                                                                       output[entry_in_output[i_property]],
-                                                                                                       min_depth_local,
-                                                                                                       max_depth_local);
-
-                              WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Composition is not a number: " << output[entry_in_output[i_property]]
-                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-                              WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Composition is not a finite: " << output[entry_in_output[i_property]]
-                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-
-                            }
-
-                          break;
-                        }
-                      case 3: // grains
-                      {
-                        WorldBuilder::grains  grains(output,properties[i_property][2],entry_in_output[i_property]);
-                        for (const auto &grains_model: grains_models)
-                          {
-                            grains = grains_model->get_grains(position_in_cartesian_coordinates,
-                                                              position_in_natural_coordinates,
-                                                              depth,
-                                                              properties[i_property][1],
-                                                              grains,
-                                                              min_depth_local,
-                                                              max_depth_local);
-
-                          }
-                        grains.unroll_into(output,entry_in_output[i_property]);
-                        break;
-                      }
-                      case 4:
-                      {
-                        output[entry_in_output[i_property]] = static_cast<double>(tag_index);
-                        break;
-                      }
-                      break;
-                      default:
-                      {
-                        WBAssertThrow(false,
-                                      "Internal error: Unimplemented property provided. " <<
-                                      "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
-                                      "Provided property number was: " << properties[i_property][0]);
-                      }
-                    }
-                }
-            }
-        }
-    }
-
-    WB_REGISTER_FEATURE(MantleLayer, mantle layer)
-
-  } // namespace Features
-} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/interface.cc.bak
deleted file mode 100644
index 0f626ab049e..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/interface.cc.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/composition/interface.h"
-
-#include <algorithm>
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Composition
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Composition
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/uniform.cc.bak
deleted file mode 100644
index a61230f5e12..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/composition/uniform.cc.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/composition/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Composition
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform compositional model. Sets constant compositional field.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the labels of the composition which are present there.");
-          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
-                            "TA list of compositional fractions corresponding to the compositions list.");
-          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value. Replacing implies that all compositions not "
-                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-          fractions = prm.get_vector<double>("fractions");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          WBAssertThrow(compositions.size() == fractions.size(),
-                        "There are not the same amount of compositions and fractions.");
-        }
-
-
-        double
-        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                 const double depth,
-                                 const unsigned int composition_number,
-                                 double composition,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          return apply_operation(operation,composition,fractions[i]);
-                        }
-                    }
-
-                  if (operation == Operations::REPLACE)
-                    return 0.0;
-                }
-            }
-          return composition;
-        }
-        WB_REGISTER_FEATURE_MANTLE_LAYER_COMPOSITION_MODEL(Uniform, uniform)
-      } // namespace Composition
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/interface.cc.bak
deleted file mode 100644
index 259b393aa45..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/interface.cc.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/grains/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/object.h"
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Grains
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          unsigned int counter = 0;
-          for (auto &it : get_declare_map())
-            {
-              // prevent infinite recursion
-              if (it.first != parent_name)
-                {
-                  prm.enter_subsection("oneOf");
-                  {
-                    prm.enter_subsection(std::to_string(counter));
-                    {
-                      prm.enter_subsection("properties");
-                      {
-                        prm.declare_entry("", Types::Object(required_entries), "grains object");
-
-                        prm.declare_entry("model", Types::String("",it.first),
-                                          "The name of the grains model.");
-
-                        it.second(prm, parent_name);
-                      }
-                      prm.leave_subsection();
-                    }
-                    prm.leave_subsection();
-                  }
-                  prm.leave_subsection();
-
-                  counter++;
-
-                }
-            }
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Grains
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.cc.bak
deleted file mode 100644
index 9d75e3de185..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution.cc.bak
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/grains/random_uniform_distribution.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution";
-        }
-
-        RandomUniformDistribution::~RandomUniformDistribution()
-          = default;
-
-        void
-        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistribution::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                              const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                              const double depth,
-                                              const unsigned int composition_number,
-                                              WorldBuilder::grains grains_,
-                                              const double  /*feature_min_depth*/,
-                                              const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          std::uniform_real_distribution<> dist(0.0,1.0);
-                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                            {
-                              // set a uniform random a_cosine_matrix per grain
-                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                              // and is licenend accourding to this website with the following licence:
-                              //
-                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                              // don't be a jerk, and remember that anything free comes with no guarantee.""
-                              //
-                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                              // the public domain, and is yours to study, modify, and use."
-
-                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                              const double one = dist(world->get_random_number_engine());
-                              const double two = dist(world->get_random_number_engine());
-                              const double three = dist(world->get_random_number_engine());
-
-                              const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
-                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                              const double z = 2.0* three; //For magnitude of pole deflection.
-
-                              // Compute a vector V used for distributing points over the sphere
-                              // via the reflection I - V Transpose(V).  This formulation of V
-                              // will guarantee that if x[1] and x[2] are uniformly distributed,
-                              // the reflected points will be uniform on the sphere.  Note that V
-                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                              const double r  = std::sqrt( z );
-                              const double Vx = std::sin( phi ) * r;
-                              const double Vy = std::cos( phi ) * r;
-                              const double Vz = std::sqrt( 2.F - z );
-
-                              // Compute the row vector S = Transpose(V) * R, where R is a simple
-                              // rotation by theta about the z-axis.  No need to compute Sz since
-                              // it's just Vz.
-
-                              const double st = std::sin( theta );
-                              const double ct = std::cos( theta );
-                              const double Sx = Vx * ct - Vy * st;
-                              const double Sy = Vx * st + Vy * ct;
-
-                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                              // is equivalent to V S - R.
-
-                              it_rotation_matrices[0][0] = Vx * Sx - ct;
-                              it_rotation_matrices[0][1] = Vx * Sy - st;
-                              it_rotation_matrices[0][2] = Vx * Vz;
-
-                              it_rotation_matrices[1][0] = Vy * Sx + st;
-                              it_rotation_matrices[1][1] = Vy * Sy - ct;
-                              it_rotation_matrices[1][2] = Vy * Vz;
-
-                              it_rotation_matrices[2][0] = Vz * Sx;
-                              it_rotation_matrices[2][1] = Vz * Sy;
-                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                            }
-
-                          double total_size = 0;
-                          for (auto &&it_sizes : grains_local.sizes)
-                            {
-                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                              total_size += it_sizes;
-                            }
-
-                          if (normalize_grain_sizes[i])
-                            {
-                              const double one_over_total_size = 1/total_size;
-                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                            }
-
-                          return grains_local;
-                        }
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_MANTLE_LAYER_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
-      } // namespace Grains
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.cc.bak
deleted file mode 100644
index d3cf85005b2..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.cc.bak
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/grains/random_uniform_distribution_deflected.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution deflected";
-        }
-
-        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
-          = default;
-
-        void
-        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-          prm.declare_entry("deflections",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistributionDeflected::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-          deflections = prm.get_vector<double>("deflections");
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == deflections.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and deflections (" << deflections.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                                       const double depth,
-                                                       const unsigned int composition_number,
-                                                       WorldBuilder::grains grains_,
-                                                       const double  /*feature_min_depth*/,
-                                                       const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          std::uniform_real_distribution<> dist(0.0,1.0);
-                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                            {
-                              // set a uniform random a_cosine_matrix per grain
-                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                              // and is licenend accourding to this website with the following licence:
-                              //
-                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                              // don't be a jerk, and remember that anything free comes with no guarantee.""
-                              //
-                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                              // the public domain, and is yours to study, modify, and use."
-
-                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                              const double one = dist(world->get_random_number_engine());
-                              const double two = dist(world->get_random_number_engine());
-                              const double three = dist(world->get_random_number_engine());
-
-                              // the distribution is restricted by the deflection (between 0 and 1)
-                              const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z)
-                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                              const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
-
-                              // Compute a vector V used for distributing points over the sphere
-                              // via the reflection I - V Transpose(V).  This formulation of V
-                              // will guarantee that if x[1] and x[2] are uniformly distributed,
-                              // the reflected points will be uniform on the sphere.  Note that V
-                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                              const double r  = std::sqrt( z );
-                              const double Vx = std::sin( phi ) * r;
-                              const double Vy = std::cos( phi ) * r;
-                              const double Vz = std::sqrt( 2.F - z );
-
-                              // Compute the row vector S = Transpose(V) * R, where R is a simple
-                              // rotation by theta about the z-axis.  No need to compute Sz since
-                              // it's just Vz.
-
-                              const double st = std::sin( theta );
-                              const double ct = std::cos( theta );
-                              const double Sx = Vx * ct - Vy * st;
-                              const double Sy = Vx * st + Vy * ct;
-
-                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                              // is equivalent to V S - R.
-
-                              it_rotation_matrices[0][0] = Vx * Sx - ct;
-                              it_rotation_matrices[0][1] = Vx * Sy - st;
-                              it_rotation_matrices[0][2] = Vx * Vz;
-
-                              it_rotation_matrices[1][0] = Vy * Sx + st;
-                              it_rotation_matrices[1][1] = Vy * Sy - ct;
-                              it_rotation_matrices[1][2] = Vy * Vz;
-
-                              it_rotation_matrices[2][0] = Vz * Sx;
-                              it_rotation_matrices[2][1] = Vz * Sy;
-                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                            }
-
-                          double total_size = 0;
-                          for (auto &&it_sizes : grains_local.sizes)
-                            {
-                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                              total_size += it_sizes;
-                            }
-
-                          if (normalize_grain_sizes[i])
-                            {
-                              const double one_over_total_size = 1/total_size;
-                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                            }
-
-                          return grains_local;
-                        }
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_MANTLE_LAYER_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
-      } // namespace Grains
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/uniform.cc.bak
deleted file mode 100644
index dea13791d9e..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/grains/uniform.cc.bak
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/grains/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Grains
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform grains model. All grains start exactly the same.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
-                            "A list with the labels of the grains which are present there for each compositions.");
-
-          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
-                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(-1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
-
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
-          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
-
-          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
-                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
-
-
-          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
-                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
-
-          if (set_euler_angles)
-            {
-              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
-              rotation_matrices.resize(euler_angles_vector.size());
-              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
-                {
-                  rotation_matrices[i] = WorldBuilder::Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
-                }
-
-            }
-          else
-            {
-              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
-            }
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-
-
-          WBAssertThrow(compositions.size() == rotation_matrices.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                            const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                            const double depth,
-                            const unsigned int composition_number,
-                            WorldBuilder::grains grains_,
-                            const double  /*feature_min_depth*/,
-                            const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
-
-                          const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
-                          std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
-
-                          return grains_local;
-                        }
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_MANTLE_LAYER_GRAINS_MODEL(Uniform, uniform)
-      } // namespace Grains
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/adiabatic.cc.bak
deleted file mode 100644
index 28c172b2e6c..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/adiabatic.cc.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/temperature/adiabatic.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace MantleLayerModels
-    {
-      namespace Temperature
-      {
-        Adiabatic::Adiabatic(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          potential_mantle_temperature(NaN::DSNAN),
-          thermal_expansion_coefficient(NaN::DSNAN),
-          specific_heat(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "adiabatic";
-        }
-
-        Adiabatic::~Adiabatic()
-          = default;
-
-        void
-        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          prm.declare_entry("", Types::Object(),
-                            "Adiabatic temperature model. Uses global values by default.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the temperature of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the temperature of this feature is present.");
-
-          prm.declare_entry("potential mantle temperature", Types::Double(-1),
-                            "The potential temperature of the mantle at the surface in Kelvin. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
-                            "The thermal expansion coefficient in $K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("specific heat", Types::Double(-1),
-                            "The specific heat in $J kg^{-1} K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-        }
-
-        void
-        Adiabatic::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
-          if (potential_mantle_temperature < 0)
-            potential_mantle_temperature =  this->world->potential_mantle_temperature;
-
-
-          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
-          if (thermal_expansion_coefficient < 0)
-            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
-
-          specific_heat = prm.get<double>("specific heat");
-          if (specific_heat < 0)
-            specific_heat =  this->world->specific_heat;
-
-          // Some assertions in debug mode can't hurt and have helped before.
-          WBAssert(!std::isnan(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
-          WBAssert(std::isfinite(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
-
-          WBAssert(!std::isnan(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
-
-          WBAssert(!std::isnan(specific_heat),
-                   "specific_heat is not a number: " << specific_heat << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "specific_heat is not a finite: " << specific_heat << '.');
-
-        }
-
-
-        double
-        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity_norm,
-                                   double temperature_,
-                                   const double  /*feature_min_depth*/,
-                                   const double  /*feature_max_depth*/) const
-        {
-
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  const double adabatic_temperature = potential_mantle_temperature *
-                                                      std::exp(((thermal_expansion_coefficient * gravity_norm) /
-                                                                specific_heat) * depth);
-
-
-                  WBAssert(!std::isnan(adabatic_temperature),
-                           "adabatic_temperature is not a number: " << adabatic_temperature << ". "
-                           <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
-                           <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
-                           << ", gravity_norm = " << gravity_norm
-                           << ", specific_heat = " << specific_heat
-                           << ", depth = " << depth);
-
-                  WBAssert(std::isfinite(adabatic_temperature),
-                           "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
-
-                  return apply_operation(operation,temperature_,adabatic_temperature);
-                }
-            }
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_MANTLE_LAYER_TEMPERATURE_MODEL(Adiabatic, adiabatic)
-      } // namespace Temperature
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/interface.cc.bak
deleted file mode 100644
index bfcd5474434..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/interface.cc.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/temperature/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Temperature
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          // The type needs to be stored in a separate value, otherwise there are memory issues
-          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
-
-          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
-          {
-            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
-            {
-              "operation", type,
-              "Whether the value should replace any value previously defined at this location (replace), "
-              "add the value to the previously define value (add) or subtract the value to the previously "
-              "define value (subtract)."
-            }
-          });
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Temperature
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/linear.cc.bak
deleted file mode 100644
index b8e64d70ec7..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/linear.cc.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/temperature/linear.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Temperature
-      {
-        Linear::Linear(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          top_temperature(NaN::DSNAN),
-          bottom_temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "linear";
-        }
-
-        Linear::~Linear()
-          = default;
-
-        void
-        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add max depth to the required parameters.
-          prm.declare_entry("", Types::Object({"max depth"}),
-                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the temperature of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the temperature of this feature is present.");
-
-          prm.declare_entry("top temperature", Types::Double(293.15),
-                            "The temperature at the top in degree Kelvin of this feature."
-                            "If the value is below zero, the an adiabatic temperature is used.");
-
-          prm.declare_entry("bottom temperature", Types::Double(-1),
-                            "The temperature at the top in degree Kelvin of this feature. "
-                            "If the value is below zero, an adiabatic temperature is used.");
-        }
-
-        void
-        Linear::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          top_temperature = prm.get<double>("top temperature");
-          bottom_temperature = prm.get<double>("bottom temperature");
-        }
-
-
-        double
-        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                const double depth,
-                                const double gravity_norm,
-                                double temperature_,
-                                const double feature_min_depth,
-                                const double feature_max_depth) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  const double min_depth_local_local = std::max(feature_min_depth, min_depth_local);
-                  const double max_depth_local_local = std::min(feature_max_depth, max_depth_local);
-
-                  double top_temperature_local = top_temperature;
-                  if (top_temperature_local < 0)
-                    {
-                      top_temperature_local =  this->world->potential_mantle_temperature *
-                                               std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                         this->world->specific_heat) * min_depth_local_local);
-                    }
-
-                  double bottom_temperature_local = bottom_temperature;
-                  if (bottom_temperature_local < 0)
-                    {
-                      bottom_temperature_local =  this->world->potential_mantle_temperature *
-                                                  std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                            this->world->specific_heat) * max_depth_local_local);
-
-                    }
-
-                  const double new_temperature =  top_temperature_local + (max_depth_local_local - min_depth_local_local < 10.0*std::numeric_limits<double>::epsilon() ? 0.0 :
-                                                                           (depth - min_depth_local_local) *
-                                                                           ((bottom_temperature_local - top_temperature_local) / (max_depth_local_local - min_depth_local_local)));
-
-                  return apply_operation(operation,temperature_,new_temperature);
-                }
-            }
-
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_MANTLE_LAYER_TEMPERATURE_MODEL(Linear, linear)
-      } // namespace Temperature
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/uniform.cc.bak
deleted file mode 100644
index 742a922cb99..00000000000
--- a/contrib/world_builder/source/world_builder/features/mantle_layer_models/temperature/uniform.cc.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/mantle_layer_models/temperature/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace MantleLayerModels
-    {
-      namespace Temperature
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `temperature` and to the required parameters.
-          prm.declare_entry("", Types::Object({"temperature"}),
-                            "Uniform temperature model. Set the temperature to a constant value.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the temperature of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the temperature of this feature is present.");
-
-          prm.declare_entry("temperature", Types::Double(293.15),
-                            "The temperature in degree Kelvin which this feature should have");
-
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          temperature = prm.get<double>("temperature");
-        }
-
-
-        double
-        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                 const double depth,
-                                 const double  /*gravity*/,
-                                 double temperature_,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/) const
-        {
-
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  return apply_operation(operation,temperature_,temperature);
-                }
-            }
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_MANTLE_LAYER_TEMPERATURE_MODEL(Uniform, uniform)
-      } // namespace Temperature
-    } // namespace MantleLayerModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate.cc.bak
deleted file mode 100644
index d7beaaf3b50..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate.cc.bak
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include "world_builder/features/oceanic_plate.h"
-
-#include "world_builder/features/oceanic_plate_models/composition/interface.h"
-#include "world_builder/features/oceanic_plate_models/grains/interface.h"
-#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/plugin_system.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    OceanicPlate::OceanicPlate(WorldBuilder::World *world_)
-      :
-      min_depth(NaN::DSNAN),
-      max_depth(NaN::DSNAN)
-    {
-      this->world = world_;
-      this->name = "oceanic plate";
-    }
-
-    OceanicPlate::~OceanicPlate()
-      = default;
-
-
-
-    void OceanicPlate::make_snippet(Parameters &prm)
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-
-      const std::string path = prm.get_full_json_path();
-
-      /*
-      ideally:
-       {
-        "model": "fault",
-        "name": "${1:default name}",
-        "dip point":[0.0,0.0],
-        "coordinates": [[0.0,0.0]],
-        "segments": [],
-        "sections": [],
-        "temperature models":[{"model":"uniform", "temperature":600.0}],
-        "composition models":[{"model":"uniform", "compositions": [0], "fractions":[1.0]}]
-       }
-       */
-
-      Pointer((path + "/body").c_str()).Set(declarations,"object");
-      Pointer((path + "/body/model").c_str()).Set(declarations,"oceanic plate");
-      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Oceanic Plate}");
-      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/temperature models").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/composition models").c_str()).Create(declarations).SetArray();
-    }
-
-
-
-    void
-    OceanicPlate::declare_entries(Parameters &prm,
-                                  const std::string & /*unused*/,
-                                  const std::vector<std::string> &required_entries)
-    {
-      prm.declare_entry("", Types::Object(required_entries), "Oceanic plate object. Requires properties `model` and `coordinates`.");
-
-      prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                        "The depth from which this feature is present");
-      prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                        "The depth to which this feature is present");
-      prm.declare_entry("temperature models",
-                        Types::PluginSystem("", Features::OceanicPlateModels::Temperature::Interface::declare_entries, {"model"}),
-                        "A list of temperature models.");
-      prm.declare_entry("composition models",
-                        Types::PluginSystem("", Features::OceanicPlateModels::Composition::Interface::declare_entries, {"model"}),
-                        "A list of composition models.");
-      prm.declare_entry("grains models",
-                        Types::PluginSystem("", Features::OceanicPlateModels::Grains::Interface::declare_entries, {"model"}),
-                        "A list of grains models.");
-    }
-
-    void
-    OceanicPlate::parse_entries(Parameters &prm)
-    {
-
-      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
-
-      this->name = prm.get<std::string>("name");
-
-      std::string tag = prm.get<std::string>("tag");
-      if (tag == "")
-        {
-          tag = "oceanic plate";
-        }
-      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
-
-      this->get_coordinates("coordinates", prm, coordinate_system);
-
-      min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-      min_depth = min_depth_surface.minimum;
-
-      max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-      max_depth = max_depth_surface.maximum;
-
-
-      prm.get_unique_pointers<Features::OceanicPlateModels::Temperature::Interface>("temperature models", temperature_models);
-
-      prm.enter_subsection("temperature models");
-      {
-        for (unsigned int i = 0; i < temperature_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              temperature_models[i]->parse_entries(prm,coordinates);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-
-      prm.get_unique_pointers<Features::OceanicPlateModels::Composition::Interface>("composition models", composition_models);
-
-      prm.enter_subsection("composition models");
-      {
-        for (unsigned int i = 0; i < composition_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              composition_models[i]->parse_entries(prm,coordinates);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-
-      prm.get_unique_pointers<Features::OceanicPlateModels::Grains::Interface>("grains models", grains_models);
-
-      prm.enter_subsection("grains models");
-      {
-        for (unsigned int i = 0; i < grains_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              grains_models[i]->parse_entries(prm,coordinates);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-    }
-
-
-    void
-    OceanicPlate::properties(const Point<3> &position_in_cartesian_coordinates,
-                             const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                             const double depth,
-                             const std::vector<std::array<unsigned int,3>> &properties,
-                             const double gravity_norm,
-                             const std::vector<size_t> &entry_in_output,
-                             std::vector<double> &output) const
-    {
-      if (depth <= max_depth && depth >= min_depth &&
-          WorldBuilder::Utilities::polygon_contains_point(coordinates, Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
-                                                                                world->parameters.coordinate_system->natural_coordinate_system())))
-        {
-          const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-          const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-          if (depth <= max_depth_local &&  depth >= min_depth_local)
-            {
-              for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
-                {
-                  switch (properties[i_property][0])
-                    {
-                      case 1:  // temperature
-                      {
-                        for (const auto &temperature_model: temperature_models)
-                          {
-                            output[entry_in_output[i_property]] = temperature_model->get_temperature(position_in_cartesian_coordinates,
-                                                                                                     position_in_natural_coordinates,
-                                                                                                     depth,
-                                                                                                     gravity_norm,
-                                                                                                     output[entry_in_output[i_property]],
-                                                                                                     min_depth_local,
-                                                                                                     max_depth_local);
-
-                            WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Temperature is not a number: " << output[entry_in_output[i_property]]
-                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-                            WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Temperature is not a finite: " << output[entry_in_output[i_property]]
-                                     << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-
-                          }
-                        break;
-                        case 2: // composition
-
-                          for (const auto &composition_model: composition_models)
-                            {
-                              output[entry_in_output[i_property]] = composition_model->get_composition(position_in_cartesian_coordinates,
-                                                                                                       position_in_natural_coordinates,
-                                                                                                       depth,
-                                                                                                       properties[i_property][1],
-                                                                                                       output[entry_in_output[i_property]],
-                                                                                                       min_depth_local,
-                                                                                                       max_depth_local);
-
-                              WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Composition is not a number: " << output[entry_in_output[i_property]]
-                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-                              WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Composition is not a finite: " << output[entry_in_output[i_property]]
-                                       << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-
-                            }
-
-                          break;
-                        }
-                      case 3: // grains
-                      {
-                        WorldBuilder::grains  grains(output,properties[i_property][2],entry_in_output[i_property]);
-                        for (const auto &grains_model: grains_models)
-                          {
-                            grains = grains_model->get_grains(position_in_cartesian_coordinates,
-                                                              position_in_natural_coordinates,
-                                                              depth,
-                                                              properties[i_property][1],
-                                                              grains,
-                                                              min_depth_local,
-                                                              max_depth_local);
-
-                          }
-                        grains.unroll_into(output,entry_in_output[i_property]);
-                        break;
-                      }
-                      case 4:
-                      {
-                        output[entry_in_output[i_property]] = static_cast<double>(tag_index);
-                        break;
-                      }
-                      break;
-                      default:
-                      {
-                        WBAssertThrow(false,
-                                      "Internal error: Unimplemented property provided. " <<
-                                      "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
-                                      "Provided property number was: " << properties[i_property][0]);
-                      }
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Register plugin
-     */
-    WB_REGISTER_FEATURE(OceanicPlate, oceanic plate)
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/interface.cc.bak
deleted file mode 100644
index 543e29701ce..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/interface.cc.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/composition/interface.h"
-
-#include <algorithm>
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Composition
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Composition
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/uniform.cc.bak
deleted file mode 100644
index ea2c7f7c0dc..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/composition/uniform.cc.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/composition/uniform.h"
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Composition
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform compositional model. Sets constant compositional field.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the labels of the composition which are present there.");
-          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
-                            "TA list of compositional fractions corresponding to the compositions list.");
-          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value. Replacing implies that all compositions not "
-                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-          fractions = prm.get_vector<double>("fractions");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          WBAssertThrow(compositions.size() == fractions.size(),
-                        "There are not the same amount of compositions and fractions.");
-        }
-
-
-        double
-        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                 const double depth,
-                                 const unsigned int composition_number,
-                                 double composition,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          return apply_operation(operation,composition,fractions[i]);
-                        }
-                    }
-
-                  if (operation == Operations::REPLACE)
-                    return 0.0;
-                }
-            }
-          return composition;
-        }
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_COMPOSITION_MODEL(Uniform, uniform)
-      } // namespace Composition
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/interface.cc.bak
deleted file mode 100644
index f7e1b13aa56..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/interface.cc.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/grains/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/object.h"
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Grains
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          unsigned int counter = 0;
-          for (auto &it : get_declare_map())
-            {
-              // prevent infinite recursion
-              if (it.first != parent_name)
-                {
-                  prm.enter_subsection("oneOf");
-                  {
-                    prm.enter_subsection(std::to_string(counter));
-                    {
-                      prm.enter_subsection("properties");
-                      {
-                        prm.declare_entry("", Types::Object(required_entries), "grains object");
-
-                        prm.declare_entry("model", Types::String("",it.first),
-                                          "The name of the grains model.");
-
-                        it.second(prm, parent_name);
-                      }
-                      prm.leave_subsection();
-                    }
-                    prm.leave_subsection();
-                  }
-                  prm.leave_subsection();
-
-                  counter++;
-
-                }
-            }
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Grains
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.cc.bak
deleted file mode 100644
index 95f95476802..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.cc.bak
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/grains/random_uniform_distribution.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution";
-        }
-
-        RandomUniformDistribution::~RandomUniformDistribution()
-          = default;
-
-        void
-        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistribution::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                              const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                              const double depth,
-                                              const unsigned int composition_number,
-                                              WorldBuilder::grains grains_,
-                                              const double  /*feature_min_depth*/,
-                                              const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          std::uniform_real_distribution<> dist(0.0,1.0);
-                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                            {
-                              // set a uniform random a_cosine_matrix per grain
-                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                              // and is licenend accourding to this website with the following licence:
-                              //
-                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                              // don't be a jerk, and remember that anything free comes with no guarantee.""
-                              //
-                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                              // the public domain, and is yours to study, modify, and use."
-
-                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                              const double one = dist(world->get_random_number_engine());
-                              const double two = dist(world->get_random_number_engine());
-                              const double three = dist(world->get_random_number_engine());
-
-                              const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
-                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                              const double z = 2.0* three; //For magnitude of pole deflection.
-
-                              // Compute a vector V used for distributing points over the sphere
-                              // via the reflection I - V Transpose(V).  This formulation of V
-                              // will guarantee that if x[1] and x[2] are uniformly distributed,
-                              // the reflected points will be uniform on the sphere.  Note that V
-                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                              const double r  = std::sqrt( z );
-                              const double Vx = std::sin( phi ) * r;
-                              const double Vy = std::cos( phi ) * r;
-                              const double Vz = std::sqrt( 2.F - z );
-
-                              // Compute the row vector S = Transpose(V) * R, where R is a simple
-                              // rotation by theta about the z-axis.  No need to compute Sz since
-                              // it's just Vz.
-
-                              const double st = std::sin( theta );
-                              const double ct = std::cos( theta );
-                              const double Sx = Vx * ct - Vy * st;
-                              const double Sy = Vx * st + Vy * ct;
-
-                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                              // is equivalent to V S - R.
-
-                              it_rotation_matrices[0][0] = Vx * Sx - ct;
-                              it_rotation_matrices[0][1] = Vx * Sy - st;
-                              it_rotation_matrices[0][2] = Vx * Vz;
-
-                              it_rotation_matrices[1][0] = Vy * Sx + st;
-                              it_rotation_matrices[1][1] = Vy * Sy - ct;
-                              it_rotation_matrices[1][2] = Vy * Vz;
-
-                              it_rotation_matrices[2][0] = Vz * Sx;
-                              it_rotation_matrices[2][1] = Vz * Sy;
-                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                            }
-
-                          double total_size = 0;
-                          for (auto &&it_sizes : grains_local.sizes)
-                            {
-                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                              total_size += it_sizes;
-                            }
-
-                          if (normalize_grain_sizes[i])
-                            {
-                              const double one_over_total_size = 1/total_size;
-                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                            }
-
-                          return grains_local;
-                        }
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
-      } // namespace Grains
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.cc.bak
deleted file mode 100644
index ffac673631f..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.cc.bak
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/grains/random_uniform_distribution_deflected.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution deflected";
-        }
-
-        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
-          = default;
-
-        void
-        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-          prm.declare_entry("deflections",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistributionDeflected::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-          deflections = prm.get_vector<double>("deflections");
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == deflections.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and deflections (" << deflections.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                                       const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                                       const double depth,
-                                                       const unsigned int composition_number,
-                                                       WorldBuilder::grains grains_,
-                                                       const double  /*feature_min_depth*/,
-                                                       const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          std::uniform_real_distribution<> dist(0.0,1.0);
-                          for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                            {
-                              // set a uniform random a_cosine_matrix per grain
-                              // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                              // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                              // and is licenend accourding to this website with the following licence:
-                              //
-                              // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                              // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                              // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                              // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                              // don't be a jerk, and remember that anything free comes with no guarantee.""
-                              //
-                              // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                              // the public domain, and is yours to study, modify, and use."
-
-                              // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                              const double one = dist(world->get_random_number_engine());
-                              const double two = dist(world->get_random_number_engine());
-                              const double three = dist(world->get_random_number_engine());
-
-                              const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z)
-                              const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                              const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
-
-                              // Compute a vector V used for distributing points over the sphere
-                              // via the reflection I - V Transpose(V).  This formulation of V
-                              // will guarantee that if x[1] and x[2] are uniformly distributed,
-                              // the reflected points will be uniform on the sphere.  Note that V
-                              // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                              const double r  = std::sqrt( z );
-                              const double Vx = std::sin( phi ) * r;
-                              const double Vy = std::cos( phi ) * r;
-                              const double Vz = std::sqrt( 2.F - z );
-
-                              // Compute the row vector S = Transpose(V) * R, where R is a simple
-                              // rotation by theta about the z-axis.  No need to compute Sz since
-                              // it's just Vz.
-
-                              const double st = std::sin( theta );
-                              const double ct = std::cos( theta );
-                              const double Sx = Vx * ct - Vy * st;
-                              const double Sy = Vx * st + Vy * ct;
-
-                              // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                              // is equivalent to V S - R.
-
-                              it_rotation_matrices[0][0] = Vx * Sx - ct;
-                              it_rotation_matrices[0][1] = Vx * Sy - st;
-                              it_rotation_matrices[0][2] = Vx * Vz;
-
-                              it_rotation_matrices[1][0] = Vy * Sx + st;
-                              it_rotation_matrices[1][1] = Vy * Sy - ct;
-                              it_rotation_matrices[1][2] = Vy * Vz;
-
-                              it_rotation_matrices[2][0] = Vz * Sx;
-                              it_rotation_matrices[2][1] = Vz * Sy;
-                              it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                            }
-
-                          double total_size = 0;
-                          for (auto &&it_sizes : grains_local.sizes)
-                            {
-                              it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                              total_size += it_sizes;
-                            }
-
-                          if (normalize_grain_sizes[i])
-                            {
-                              const double one_over_total_size = 1/total_size;
-                              std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                             [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                            }
-
-                          return grains_local;
-                        }
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
-      } // namespace Grains
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/uniform.cc.bak
deleted file mode 100644
index ddb408107a9..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/grains/uniform.cc.bak
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/grains/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Grains
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform grains model. All grains start exactly the same.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
-                            "A list with the labels of the grains which are present there for each compositions.");
-
-          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
-                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(-1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
-
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
-          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
-
-          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
-                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
-
-
-          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
-                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
-
-          if (set_euler_angles)
-            {
-              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
-              rotation_matrices.resize(euler_angles_vector.size());
-              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
-                {
-                  rotation_matrices[i] = WorldBuilder::Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
-                }
-
-            }
-          else
-            {
-              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
-            }
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-
-
-          WBAssertThrow(compositions.size() == rotation_matrices.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                            const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                            const double depth,
-                            const unsigned int composition_number,
-                            WorldBuilder::grains grains_,
-                            const double  /*feature_min_depth*/,
-                            const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  for (unsigned int i =0; i < compositions.size(); ++i)
-                    {
-                      if (compositions[i] == composition_number)
-                        {
-                          std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
-
-                          const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
-                          std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
-
-
-                          return grains_local;
-                        }
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_GRAINS_MODEL(Uniform, uniform)
-      } // namespace Grains
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/adiabatic.cc.bak
deleted file mode 100644
index d41973ad571..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/adiabatic.cc.bak
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/temperature/adiabatic.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        Adiabatic::Adiabatic(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          potential_mantle_temperature(NaN::DSNAN),
-          thermal_expansion_coefficient(NaN::DSNAN),
-          specific_heat(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "adiabatic";
-        }
-
-        Adiabatic::~Adiabatic()
-          = default;
-
-        void
-        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          prm.declare_entry("", Types::Object(),
-                            "Adiabatic temperature model. Uses global values by default.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the temperature of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the temperature of this feature is present.");
-
-          prm.declare_entry("potential mantle temperature", Types::Double(-1),
-                            "The potential temperature of the mantle at the surface in Kelvin. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
-                            "The thermal expansion coefficient in $K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("specific heat", Types::Double(-1),
-                            "The specific heat in $J kg^{-1} K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-        }
-
-        void
-        Adiabatic::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
-          if (potential_mantle_temperature < 0)
-            potential_mantle_temperature =  this->world->potential_mantle_temperature;
-
-
-          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
-          if (thermal_expansion_coefficient < 0)
-            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
-
-          specific_heat = prm.get<double>("specific heat");
-          if (specific_heat < 0)
-            specific_heat =  this->world->specific_heat;
-
-          // Some assertions in debug mode can't hurt and have helped before.
-          WBAssert(!std::isnan(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
-          WBAssert(std::isfinite(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
-
-          WBAssert(!std::isnan(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
-
-          WBAssert(!std::isnan(specific_heat),
-                   "specific_heat is not a number: " << specific_heat << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "specific_heat is not a finite: " << specific_heat << '.');
-
-        }
-
-
-        double
-        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                   const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                   const double depth,
-                                   const double gravity_norm,
-                                   double temperature_,
-                                   const double  /*feature_min_depth*/,
-                                   const double  /*feature_max_depth*/) const
-        {
-
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  const double adabatic_temperature = potential_mantle_temperature *
-                                                      std::exp(((thermal_expansion_coefficient * gravity_norm) /
-                                                                specific_heat) * depth);
-
-
-                  WBAssert(!std::isnan(adabatic_temperature),
-                           "adabatic_temperature is not a number: " << adabatic_temperature << ". "
-                           <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
-                           <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
-                           << ", gravity_norm = " << gravity_norm
-                           << ", specific_heat = " << specific_heat
-                           << ", depth = " << depth);
-
-                  WBAssert(std::isfinite(adabatic_temperature),
-                           "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
-
-                  return apply_operation(operation,temperature_,adabatic_temperature);
-                }
-            }
-
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(Adiabatic, adiabatic)
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/half_space_model.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/half_space_model.cc.bak
deleted file mode 100644
index e6d80f203dc..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/half_space_model.cc.bak
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/temperature/half_space_model.h"
-
-
-#include "world_builder/consts.h"
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/point.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-#include <cstdint>
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        HalfSpaceModel::HalfSpaceModel(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          top_temperature(NaN::DSNAN),
-          bottom_temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "half space model";
-        }
-
-        HalfSpaceModel::~HalfSpaceModel()
-          = default;
-
-        void
-        HalfSpaceModel::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `ridge coordinates`, `spreading velocity`, `max depth` to the required parameters.
-          prm.declare_entry("", Types::Object({"ridge coordinates", "spreading velocity", "max depth"}),
-                            "Half space cooling mode");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the temperature of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the temperature of this feature is present."
-                            "Because half-space reaches background temperature asymptotically, "
-                            "this value should be ~2 times the nominal plate thickness of 100 km" );
-
-          prm.declare_entry("top temperature", Types::Double(293.15),
-                            "The actual surface temperature in degree Kelvin for this feature.");
-
-          prm.declare_entry("bottom temperature", Types::Double(-1),
-                            "The mantle temperature for the half-space cooling model"
-                            "in degree Kelvin for this feature. If the model has an adiabatic gradient"
-                            "this should be the mantle potential temperature, and T = Tad + Thalf. ");
-
-          prm.declare_entry("spreading velocity", Types::OneOf(Types::Double(0.05),Types::Array(Types::ValueAtPoints(0.05, std::numeric_limits<uint64_t>::max()))),
-                            "The spreading velocity of the plate in meter per year. "
-                            "This is the velocity with which one side moves away from the ridge.");
-
-          prm.declare_entry("ridge coordinates", Types::Array(Types::Array(Types::Point<2>(), 2),1),
-                            "An list of ridges. Each ridge is a lists of at least 2 2d points which "
-                            "define the location of the ridge. You need to define at least one ridge."
-                            "So the an example with two ridges is "
-                            "[[[10,20],[20,30],[10,40]],[[50,10],[60,10]]].");
-        }
-
-        void
-        HalfSpaceModel::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          top_temperature = prm.get<double>("top temperature");
-          bottom_temperature = prm.get<double>("bottom temperature");
-          spreading_velocities = prm.get_value_at_array("spreading velocity");
-
-          mid_oceanic_ridges = prm.get_vector<std::vector<Point<2>>>("ridge coordinates");
-          const double dtr = prm.coordinate_system->natural_coordinate_system() == spherical ? Consts::PI / 180.0 : 1.0;
-          for (auto &ridge_coordinates : mid_oceanic_ridges)
-            for (auto &ridge_coordinate : ridge_coordinates)
-              {
-                ridge_coordinate *= dtr;
-              }
-
-          unsigned int ridge_point_index = 0;
-          for (const auto &mid_oceanic_ridge : mid_oceanic_ridges)
-            {
-              std::vector<double> spreading_rates_for_ridge;
-              for (unsigned int index_y = 0; index_y < mid_oceanic_ridge.size(); index_y++)
-                {
-                  if (spreading_velocities.second.size() <= 1)
-                    {
-                      spreading_rates_for_ridge.push_back(spreading_velocities.second[0]);
-                    }
-                  else
-                    {
-                      spreading_rates_for_ridge.push_back(spreading_velocities.second[ridge_point_index]);
-                    }
-                  ridge_point_index += 1;
-                }
-              spreading_velocities_at_each_ridge_point.push_back(spreading_rates_for_ridge);
-            }
-        }
-
-        double
-        HalfSpaceModel::get_temperature(const Point<3> &position,
-                                        const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                        const double depth,
-                                        const double gravity_norm,
-                                        double temperature_,
-                                        const double /*feature_min_depth*/,
-                                        const double /*feature_max_depth*/) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  Objects::NaturalCoordinate position_in_natural_coordinates_at_min_depth = Objects::NaturalCoordinate(position,
-                                                                                            *(world->parameters.coordinate_system));
-                  position_in_natural_coordinates_at_min_depth.get_ref_depth_coordinate() += depth-min_depth;
-                  std::vector<std::vector<double>> subducting_plate_velocities = {{0}};
-                  std::vector<double> ridge_migration_times = {0.0};
-
-                  double bottom_temperature_local = bottom_temperature;
-
-                  if (bottom_temperature_local < 0)
-                    {
-                      bottom_temperature_local =  this->world->potential_mantle_temperature *
-                                                  std::exp(((this->world->thermal_expansion_coefficient* gravity_norm) /
-                                                            this->world->specific_heat) * depth);
-                    }
-
-                  std::vector<double> ridge_parameters = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                                         spreading_velocities_at_each_ridge_point,
-                                                         world->parameters.coordinate_system,
-                                                         position_in_natural_coordinates_at_min_depth,
-                                                         subducting_plate_velocities,
-                                                         ridge_migration_times);
-
-
-
-                  const double thermal_diffusivity = this->world->thermal_diffusivity;
-                  const double age = ridge_parameters[1] / ridge_parameters[0];
-
-                  double  temperature = bottom_temperature_local;
-
-                  temperature = temperature + (age > 0 ? (top_temperature - bottom_temperature_local)*std::erfc(depth/(2*std::sqrt(thermal_diffusivity*age))) : 0.);
-
-                  WBAssert(!std::isnan(temperature), "Temperature inside half-space cooling model is not a number: " << temperature
-                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
-                           << ", top_temperature = " << top_temperature
-                           << ", max_depth = " << max_depth
-                           << ", spreading_velocity = " << ridge_parameters[0]
-                           << ", thermal_diffusivity = " << thermal_diffusivity
-                           << ", age = " << age << '.');
-                  WBAssert(std::isfinite(temperature), "Temperature inside half-space cooling model is not a finite: " << temperature                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
-                           << ", top_temperature = " << top_temperature
-                           << ", spreading_velocity = " << ridge_parameters[0]
-                           << ", thermal_diffusivity = " << thermal_diffusivity
-                           << ", age = " << age << '.');
-
-
-                  return apply_operation(operation,temperature_,temperature);
-
-                }
-            }
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(HalfSpaceModel, half space model)
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/interface.cc.bak
deleted file mode 100644
index ddebc6632c8..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/interface.cc.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          // The type needs to be stored in a separate value, otherwise there are memory issues
-          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
-
-          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
-          {
-            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
-            {
-              "operation", type,
-              "Whether the value should replace any value previously defined at this location (replace), "
-              "add the value to the previously define value (add) or subtract the value to the previously "
-              "define value (subtract)."
-            }
-          });
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/linear.cc.bak
deleted file mode 100644
index 3dad3b341bb..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/linear.cc.bak
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/temperature/linear.h"
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        Linear::Linear(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          top_temperature(NaN::DSNAN),
-          bottom_temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "linear";
-        }
-
-        Linear::~Linear()
-          = default;
-
-        void
-        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add max depth to the required parameters.
-          prm.declare_entry("", Types::Object({"max depth"}),
-                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the temperature of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the temperature of this feature is present.");
-
-          prm.declare_entry("top temperature", Types::Double(293.15),
-                            "The temperature at the top in degree Kelvin of this feature."
-                            "If the value is below zero, the an adiabatic temperature is used.");
-
-          prm.declare_entry("bottom temperature", Types::Double(-1),
-                            "The temperature at the top in degree Kelvin of this feature. "
-                            "If the value is below zero, an adiabatic temperature is used.");
-        }
-
-        void
-        Linear::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          top_temperature = prm.get<double>("top temperature");
-          bottom_temperature = prm.get<double>("bottom temperature");
-        }
-
-
-        double
-        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                const double depth,
-                                const double gravity_norm,
-                                double temperature_,
-                                const double feature_min_depth,
-                                const double feature_max_depth) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  const double min_depth_local_local = std::max(feature_min_depth, min_depth_local);
-                  const double max_depth_local_local = std::min(feature_max_depth, max_depth_local);
-
-                  double top_temperature_local = top_temperature;
-                  if (top_temperature_local < 0)
-                    {
-                      top_temperature_local =  this->world->potential_mantle_temperature *
-                                               std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                         this->world->specific_heat) * min_depth_local_local);
-                    }
-
-                  double bottom_temperature_local = bottom_temperature;
-                  if (bottom_temperature_local < 0)
-                    {
-                      bottom_temperature_local =  this->world->potential_mantle_temperature *
-                                                  std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                            this->world->specific_heat) * max_depth_local_local);
-                    }
-
-                  const double new_temperature =  top_temperature_local + (max_depth_local_local - min_depth_local_local < 10.0*std::numeric_limits<double>::epsilon() ? 0.0 :
-                                                         (depth - min_depth_local_local) *
-                                                         ((bottom_temperature_local - top_temperature_local) / (max_depth_local_local - min_depth_local_local)));
-
-                  return apply_operation(operation,temperature_,new_temperature);
-                }
-            }
-
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(Linear, linear)
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model.cc.bak
deleted file mode 100644
index 9184711f9a1..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model.cc.bak
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/temperature/plate_model.h"
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/point.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        PlateModel::PlateModel(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          top_temperature(NaN::DSNAN),
-          bottom_temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "plate model";
-        }
-
-        PlateModel::~PlateModel()
-          = default;
-
-        void
-        PlateModel::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add temperature to the required parameters.
-          prm.declare_entry("", Types::Object({"max depth"}),
-                            "Plate model.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the temperature of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the temperature of this feature is present.");
-
-          prm.declare_entry("top temperature", Types::Double(293.15),
-                            "The temperature in degree Kelvin which this feature should have");
-
-          prm.declare_entry("bottom temperature", Types::Double(-1),
-                            "The temperature in degree Kelvin which this feature should have");
-
-          prm.declare_entry("spreading velocity", Types::OneOf(Types::Double(0.05),Types::Array(Types::ValueAtPoints(0.05, std::numeric_limits<uint64_t>::max()))),
-                            "The spreading velocity of the plate in meter per year. "
-                            "This is the velocity with which one side moves away from the ridge.");
-
-          prm.declare_entry("ridge coordinates", Types::Array(Types::Array(Types::Point<2>(), 2),1),
-                            "An list of ridges. Each ridge is a lists of at least 2 2d points which "
-                            "define the location of the ridge. You need to define at least one ridge."
-                            "So the an example with two ridges is "
-                            "[[[10,20],[20,30],[10,40]],[[50,10],[60,10]]].");
-
-        }
-
-        void
-        PlateModel::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          top_temperature = prm.get<double>("top temperature");
-          bottom_temperature = prm.get<double>("bottom temperature");
-          spreading_velocities = prm.get_value_at_array("spreading velocity");
-
-          mid_oceanic_ridges = prm.get_vector<std::vector<Point<2>>>("ridge coordinates");
-          const double dtr = prm.coordinate_system->natural_coordinate_system() == spherical ? Consts::PI / 180.0 : 1.0;
-          for (auto &ridge_coordinates : mid_oceanic_ridges)
-            for (auto &ridge_coordinate : ridge_coordinates)
-              {
-                ridge_coordinate *= dtr;
-              }
-
-          unsigned int ridge_point_index = 0;
-          for (const auto &mid_oceanic_ridge : mid_oceanic_ridges)
-            {
-              std::vector<double> spreading_rates_for_ridge;
-              for (unsigned int index_y = 0; index_y < mid_oceanic_ridge.size(); index_y++)
-                {
-                  if (spreading_velocities.second.size() <= 1)
-                    {
-                      spreading_rates_for_ridge.push_back(spreading_velocities.second[0]);
-                    }
-                  else
-                    {
-                      spreading_rates_for_ridge.push_back(spreading_velocities.second[ridge_point_index]);
-                    }
-                  ridge_point_index += 1;
-                }
-              spreading_velocities_at_each_ridge_point.push_back(spreading_rates_for_ridge);
-            }
-        }
-
-
-        double
-        PlateModel::get_temperature(const Point<3> &position,
-                                    const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                    const double depth,
-                                    const double gravity_norm,
-                                    double temperature_,
-                                    const double /*feature_min_depth*/,
-                                    const double /*feature_max_depth*/) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  Objects::NaturalCoordinate position_in_natural_coordinates_at_min_depth = Objects::NaturalCoordinate(position,
-                                                                                            *(world->parameters.coordinate_system));
-                  position_in_natural_coordinates_at_min_depth.get_ref_depth_coordinate() += depth-min_depth;
-                  std::vector<std::vector<double>> subducting_plate_velocities = {{0}};
-                  std::vector<double> ridge_migration_times = {0.0};
-                  double bottom_temperature_local = bottom_temperature;
-
-                  if (bottom_temperature_local < 0)
-                    {
-                      bottom_temperature_local =  this->world->potential_mantle_temperature *
-                                                  std::exp(((this->world->thermal_expansion_coefficient* gravity_norm) /
-                                                            this->world->specific_heat) * depth);
-                    }
-
-                  const int summation_number = 100;
-
-                  std::vector<double> ridge_parameters = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                                         spreading_velocities_at_each_ridge_point,
-                                                         world->parameters.coordinate_system,
-                                                         position_in_natural_coordinates_at_min_depth,
-                                                         subducting_plate_velocities,
-                                                         ridge_migration_times);
-
-                  const double thermal_diffusivity = this->world->thermal_diffusivity;
-                  const double age = ridge_parameters[1] / ridge_parameters[0];
-                  double temperature = top_temperature + (bottom_temperature_local - top_temperature) * (depth / max_depth);
-
-                  // This formula addresses the horizontal heat transfer by having the spreading velocity and distance to the ridge in it.
-                  // (Chapter 7 Heat, Fowler M. The solid earth: an introduction to global geophysics[M]. Cambridge University Press, 1990)
-                  for (int i = 1; i<summation_number+1; ++i)
-                    {
-                      temperature = temperature + (bottom_temperature_local - top_temperature) *
-                                    ((2 / (double(i) * Consts::PI)) * std::sin((double(i) * Consts::PI * depth) / max_depth) *
-                                     std::exp((((ridge_parameters[0] * max_depth)/(2 * thermal_diffusivity)) -
-                                               std::sqrt(((ridge_parameters[0]*ridge_parameters[0]*max_depth*max_depth) /
-                                                          (4*thermal_diffusivity*thermal_diffusivity)) + double(i) * double(i) * Consts::PI * Consts::PI)) *
-                                              ((ridge_parameters[0] * age) / max_depth)));
-
-                    }
-
-                  WBAssert(!std::isnan(temperature), "Temperature inside plate model is not a number: " << temperature
-                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
-                           << ", top_temperature = " << top_temperature
-                           << ", max_depth = " << max_depth
-                           << ", spreading_velocity = " << ridge_parameters[0]
-                           << ", thermal_diffusivity = " << thermal_diffusivity
-                           << ", age = " << age << '.');
-                  WBAssert(std::isfinite(temperature), "Temperature inside plate model is not a finite: " << temperature                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
-                           << ", top_temperature = " << top_temperature
-                           << ", spreading_velocity = " << ridge_parameters[0]
-                           << ", thermal_diffusivity = " << thermal_diffusivity
-                           << ", age = " << age << '.');
-
-
-                  return apply_operation(operation,temperature_,temperature);
-
-                }
-            }
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(PlateModel, plate model)
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.cc.bak
deleted file mode 100644
index 98e5b7e0413..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.cc.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/temperature/plate_model_constant_age.h"
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/point.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        PlateModelConstantAge::PlateModelConstantAge(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          top_temperature(NaN::DSNAN),
-          bottom_temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "plate model constant age";
-        }
-
-        PlateModelConstantAge::~PlateModelConstantAge()
-          = default;
-
-        void
-        PlateModelConstantAge::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add temperature to the required parameters.
-          prm.declare_entry("", Types::Object({"max depth"}),
-                            "Plate model, but with a fixed age.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the temperature of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the temperature of this feature is present.");
-
-          prm.declare_entry("top temperature", Types::Double(293.15),
-                            "The temperature in degree Kelvin which this feature should have");
-
-          prm.declare_entry("bottom temperature", Types::Double(-1),
-                            "The temperature in degree Kelvin which this feature should have");
-
-          prm.declare_entry("plate age", Types::Double(80e3),
-                            "The age of the plate in year. "
-                            "This age is assigned to the whole plate. ");
-        }
-
-        void
-        PlateModelConstantAge::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          top_temperature = prm.get<double>("top temperature");
-          bottom_temperature = prm.get<double>("bottom temperature");
-          plate_age = prm.get<double>("plate age")*31557600;
-        }
-
-
-        double
-        PlateModelConstantAge::get_temperature(const Point<3> & /*position*/,
-                                               const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                               const double depth,
-                                               const double gravity_norm,
-                                               double temperature_,
-                                               const double /*feature_min_depth*/,
-                                               const double /*feature_max_depth*/) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  double bottom_temperature_local = bottom_temperature;
-
-                  if (bottom_temperature_local < 0)
-                    {
-                      bottom_temperature_local =  this->world->potential_mantle_temperature *
-                                                  std::exp(((this->world->thermal_expansion_coefficient* gravity_norm) /
-                                                            this->world->specific_heat) * depth);
-                    }
-                  const int sommation_number = 100;
-
-                  // some aliases
-                  //const double top_temperature = top_temperature;
-                  const double thermal_diffusivity = this->world->thermal_diffusivity;
-                  double temperature = top_temperature + (bottom_temperature_local - top_temperature) * (depth / max_depth);
-
-                  // This formula ignores the horizontal heat transfer by just having the age of the plate in it.
-                  // (Chapter 7 Heat, Fowler M. The solid earth: an introduction to global geophysics[M]. Cambridge University Press, 1990)
-                  for (int i = 1; i<sommation_number+1; ++i)
-                    {
-                      temperature = temperature + (bottom_temperature_local - top_temperature) *
-                                    ((2 / (double(i) * Consts::PI)) * std::sin((double(i) * Consts::PI * depth) / max_depth) *
-                                     std::exp(-1.0 * i * i * Consts::PI * Consts::PI * thermal_diffusivity * plate_age / (max_depth * max_depth)));
-                    }
-
-                  WBAssert(!std::isnan(temperature), "Temperature inside plate model constant age is not a number: " << temperature
-                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
-                           << ", top_temperature = " << top_temperature
-                           << ", max_depth = " << max_depth
-                           << ", thermal_diffusivity = " << thermal_diffusivity
-                           << ", age = " << plate_age << '.');
-                  WBAssert(std::isfinite(temperature), "Temperature inside plate model constant age is not a finite: " << temperature                           << ". Relevant variables: bottom_temperature_local = " << bottom_temperature_local
-                           << ", top_temperature = " << top_temperature
-                           << ", thermal_diffusivity = " << thermal_diffusivity
-                           << ", age = " << plate_age << '.');
-
-
-                  return apply_operation(operation,temperature_,temperature);
-
-                }
-            }
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(PlateModelConstantAge, plate model constant age)
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/uniform.cc.bak
deleted file mode 100644
index ec3bf293ce9..00000000000
--- a/contrib/world_builder/source/world_builder/features/oceanic_plate_models/temperature/uniform.cc.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/oceanic_plate_models/temperature/uniform.h"
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace OceanicPlateModels
-    {
-      namespace Temperature
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `temperature` and to the required parameters.
-          prm.declare_entry("", Types::Object({"temperature"}),
-                            "Uniform temperature model. Set the temperature to a constant value.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::OneOf(Types::Double(0),Types::Array(Types::ValueAtPoints(0., 2.))),
-                            "The depth in meters from which the temperature of this feature is present.");
-
-          prm.declare_entry("max depth", Types::OneOf(Types::Double(std::numeric_limits<double>::max()),Types::Array(Types::ValueAtPoints(std::numeric_limits<double>::max(), 2.))),
-                            "The depth in meters to which the temperature of this feature is present.");
-
-          prm.declare_entry("temperature", Types::Double(293.15),
-                            "The temperature in degree Kelvin which this feature should have");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm, const std::vector<Point<2>> &coordinates)
-        {
-
-          min_depth_surface = Objects::Surface(prm.get("min depth",coordinates));
-          min_depth = min_depth_surface.minimum;
-          max_depth_surface = Objects::Surface(prm.get("max depth",coordinates));
-          max_depth = max_depth_surface.maximum;
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          temperature = prm.get<double>("temperature");
-        }
-
-
-        double
-        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                 const double depth,
-                                 const double  /*gravity*/,
-                                 double temperature_,
-                                 const double /*feature_min_depth*/,
-                                 const double /*feature_max_depth*/) const
-        {
-
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              const double min_depth_local = min_depth_surface.constant_value ? min_depth : min_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              const double max_depth_local = max_depth_surface.constant_value ? max_depth : max_depth_surface.local_value(position_in_natural_coordinates.get_surface_point()).interpolated_value;
-              if (depth <= max_depth_local &&  depth >= min_depth_local)
-                {
-                  return apply_operation(operation,temperature_,temperature);
-                }
-            }
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_OCEANIC_PLATE_TEMPERATURE_MODEL(Uniform, uniform)
-      } // namespace Temperature
-    } // namespace OceanicPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/plume.cc.bak b/contrib/world_builder/source/world_builder/features/plume.cc.bak
deleted file mode 100644
index 3e3ca597318..00000000000
--- a/contrib/world_builder/source/world_builder/features/plume.cc.bak
+++ /dev/null
@@ -1,403 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/plume.h"
-
-
-#include "world_builder/features/plume_models/composition/interface.h"
-#include "world_builder/features/plume_models/grains/interface.h"
-#include "world_builder/features/plume_models/temperature/interface.h"
-#include "world_builder/features/feature_utilities.h"
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/plugin_system.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/world.h"
-
-#include <iostream>
-#include <algorithm>
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    Plume::Plume(WorldBuilder::World *world_)
-      :
-      min_depth(NaN::DSNAN),
-      max_depth(NaN::DSNAN)
-    {
-      this->world = world_;
-      this->name = "plume";
-    }
-
-    Plume::~Plume()
-      = default;
-
-
-
-    void Plume::make_snippet(Parameters &prm)
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-
-      const std::string path = prm.get_full_json_path();
-
-      Pointer((path + "/body").c_str()).Set(declarations,"object");
-      Pointer((path + "/body/model").c_str()).Set(declarations,"plume");
-      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Plume}");
-      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/temperature models").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/composition models").c_str()).Create(declarations).SetArray();
-    }
-
-
-
-    void
-    Plume::declare_entries(Parameters &prm,
-                           const std::string & /*unused*/,
-                           const std::vector<std::string> &required_entries)
-    {
-      prm.declare_entry("", Types::Object(required_entries), "Plume object. Requires properties `model` and `coordinates`.");
-
-      prm.declare_entry("min depth", Types::Double(0),
-                        "The depth from which this feature is present, in other words, the "
-                        "depth of the tip of the plume. If the first entry in the cross "
-                        "section depths has a greater depth, an ellipsoidal plume head will "
-                        "be added in between. Units: m.");
-      prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
-                        "The depth to which this feature is present. Units: m.");
-      prm.declare_entry("cross section depths", Types::Array(Types::Double(0)),
-                        "The depths of the elliptic cross section of the plume. Units: m.");
-      prm.declare_entry("semi-major axis", Types::Array(Types::Double(100.e3)),
-                        "The lengths of the semi-major axes of the elliptic cross sections of the plume. "
-                        "In spherical coordinates, this is in degrees, otherwise in meters.");
-      prm.declare_entry("eccentricity", Types::Array(Types::Double(0)),
-                        "The eccentricities of the cross sections.");
-      prm.declare_entry("rotation angles", Types::Array(Types::Double(0)),
-                        "The directions that the semi-major axis of the elliptic cross-sections "
-                        "are pointing to, in degrees. This direction is expressed as the angle from "
-                        "geographic North in spherical coordinates, or as the angle from the Y axis "
-                        "(clockwise) in Cartesian coordinates. "
-                        "The angle should be between 0 and 360 degrees.");
-
-      prm.declare_entry("temperature models",
-                        Types::PluginSystem("", Features::PlumeModels::Temperature::Interface::declare_entries, {"model"}),
-                        "A list of temperature models.");
-      prm.declare_entry("composition models",
-                        Types::PluginSystem("", Features::PlumeModels::Composition::Interface::declare_entries, {"model"}),
-                        "A list of composition models.");
-      prm.declare_entry("grains models",
-                        Types::PluginSystem("", Features::PlumeModels::Grains::Interface::declare_entries, {"model"}),
-                        "A list of grains models.");
-    }
-
-    void
-    Plume::parse_entries(Parameters &prm)
-    {
-      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
-
-      this->name = prm.get<std::string>("name");
-
-      std::string tag = prm.get<std::string>("tag");
-      if (tag == "")
-        {
-          tag = "plume";
-        }
-      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
-
-      this->get_coordinates("coordinates", prm, coordinate_system);
-
-      min_depth = prm.get<double>("min depth");
-      max_depth = prm.get<double>("max depth");
-
-      depths = prm.get_vector<double>("cross section depths");
-      semi_major_axis_lengths = prm.get_vector<double>("semi-major axis");
-      eccentricities = prm.get_vector<double>("eccentricity");
-      rotation_angles = prm.get_vector<double>("rotation angles");
-
-      for (unsigned int i = 0; i < depths.size()-1; ++i)
-        WBAssert(depths[i] < depths[i+1],
-                 "The depths of the elliptic cross sections of the plume need to be listed in ascending order.");
-
-      WBAssert(depths.size() == coordinates.size(),
-               "The cross section depths array needs to have the same number of entries as there are coordinates. At the moment there are: "
-               << depths.size()
-               << " depth entries but "
-               << coordinates.size()
-               << " coordinates!");
-
-      WBAssert(semi_major_axis_lengths.size() == coordinates.size(),
-               "The semi-major axis array needs to have the same number of entries as there are coordinates. At the moment there are: "
-               << semi_major_axis_lengths.size()
-               << " semi-major axis entries but "
-               << coordinates.size()
-               << " coordinates!");
-
-      WBAssert(eccentricities.size() == coordinates.size(),
-               "The eccentricity array needs to have the same number of entries as there are coordinates. At the moment there are: "
-               << eccentricities.size()
-               << " eccentricity entries but "
-               << coordinates.size()
-               << " coordinates!");
-
-      WBAssert(rotation_angles.size() == coordinates.size(),
-               "The rotation angles array needs to have the same number of entries as there are coordinates. At the moment there are: "
-               << rotation_angles.size()
-               << " rotation angle entries but "
-               << coordinates.size()
-               << " coordinates!");
-
-
-      // Convert degrees to radians, convert from geographical to mathematical
-      for (double &rotation_angle : rotation_angles)
-        rotation_angle = Consts::PI/2. - rotation_angle * Consts::PI/180.;
-
-      // convert semi_major_axis_lengths to radians if we are in spherical coordinates
-      if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical)
-        for (double &semi_major_axis_length : semi_major_axis_lengths)
-          {
-            semi_major_axis_length *= Consts::PI/180.;
-          }
-
-      prm.get_unique_pointers<Features::PlumeModels::Temperature::Interface>("temperature models", temperature_models);
-
-      prm.enter_subsection("temperature models");
-      {
-        for (unsigned int i = 0; i < temperature_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              temperature_models[i]->parse_entries(prm);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-
-      prm.get_unique_pointers<Features::PlumeModels::Composition::Interface>("composition models", composition_models);
-
-      prm.enter_subsection("composition models");
-      {
-        for (unsigned int i = 0; i < composition_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              composition_models[i]->parse_entries(prm);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-
-      prm.get_unique_pointers<Features::PlumeModels::Grains::Interface>("grains models", grains_models);
-
-      prm.enter_subsection("grains models");
-      {
-        for (unsigned int i = 0; i < grains_models.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              grains_models[i]->parse_entries(prm);
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-    }
-
-
-
-    void
-    Plume::properties(const Point<3> &position_in_cartesian_coordinates,
-                      const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                      const double depth,
-                      const std::vector<std::array<unsigned int,3>> &properties,
-                      const double gravity_norm,
-                      const std::vector<size_t> &entry_in_output,
-                      std::vector<double> &output) const
-    {
-      // Figure out if the point is within the plume
-      auto upper = std::upper_bound(depths.begin(), depths.end(), depth);
-
-      Point<2> plume_center(coordinates[0]);
-      double semi_major_axis_length;
-      double eccentricity;
-      double rotation_angle;
-
-      if (depth < min_depth)
-        return;
-      else if (upper - depths.begin() == 0)
-        {
-          // interpolate to make the top of the plume spherical
-          plume_center = coordinates.front();
-          eccentricity = eccentricities.front();
-          rotation_angle = rotation_angles.front();
-
-          const double fraction = (depth - min_depth) / (depths.front() - min_depth);
-
-          const double a = depths.front() - min_depth;
-          const double b = semi_major_axis_lengths.front();
-          const double y = (1. - fraction) * a;
-
-          // use ellipse equation:
-          semi_major_axis_length = std::sqrt((1 - std::pow(y/a,2)) * b*b);
-        }
-      else if (upper - depths.end() == 0)
-        {
-          plume_center = coordinates.back();
-          semi_major_axis_length = semi_major_axis_lengths.back();
-          eccentricity = eccentricities.back();
-          rotation_angle = rotation_angles.back();
-        }
-      else
-        {
-          const unsigned int index = static_cast<unsigned int>(std::distance(depths.begin(), upper));
-          const double fraction = (depth - depths[index-1]) / (depths[index] - depths[index-1]);
-
-          plume_center[0] = (1-fraction) * coordinates[index-1][0] + fraction * (coordinates[index][0]);
-          plume_center[1] = (1-fraction) * coordinates[index-1][1] + fraction * (coordinates[index][1]);
-
-          semi_major_axis_length = (1-fraction) * semi_major_axis_lengths[index-1] + fraction * semi_major_axis_lengths[index];
-          eccentricity = (1-fraction) * eccentricities[index-1] + fraction * eccentricities[index];
-
-          // For the angles, we only want to go between zero and pi, and we have to make sure we
-          // interpolate the values close to zero/pi correctly:
-          rotation_angle = interpolate_angle_across_zero(rotation_angles[index-1], rotation_angles[index], fraction);
-        }
-
-      const Point<2> surface_point(position_in_natural_coordinates.get_surface_coordinates(),
-                                   world->parameters.coordinate_system->natural_coordinate_system());
-
-      double relative_distance_from_center =
-        WorldBuilder::Utilities::fraction_from_ellipse_center(plume_center,
-                                                              semi_major_axis_length,
-                                                              eccentricity,
-                                                              rotation_angle,
-                                                              surface_point);
-
-      // If we are in the tip, we have to compute the difference diffently:
-      if (depth >= min_depth && depth < depths.front())
-        {
-          const double a = semi_major_axis_lengths.front();
-          const double b = a * std::sqrt(1 - std::pow(eccentricity, 2));
-          const double c = depths.front() - min_depth;
-
-          const double x = (surface_point[0] - plume_center[0]) * std::cos(rotation_angle) + (surface_point[1] - plume_center[1])* std::sin(rotation_angle);
-          const double y = -(surface_point[0] - plume_center[0]) * std::sin(rotation_angle) + (surface_point[1] - plume_center[1])* std::cos(rotation_angle);
-          const double z = depths.front() - depth;
-
-          // use ellipsoid equation:
-          relative_distance_from_center = (x*x)/(a*a) + (y*y)/(b*b) + (z*z)/(c*c);
-        }
-
-      if (depth <= max_depth && depth >= min_depth && relative_distance_from_center <= 1.)
-        {
-
-          for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
-            {
-              switch (properties[i_property][0])
-                {
-                  case 1:  // temperature
-                  {
-                    for (const auto &temperature_model: temperature_models)
-                      {
-                        output[entry_in_output[i_property]] = temperature_model->get_temperature(position_in_cartesian_coordinates,
-                                                                                                 position_in_natural_coordinates,
-                                                                                                 depth,
-                                                                                                 gravity_norm,
-                                                                                                 output[entry_in_output[i_property]],
-                                                                                                 min_depth,
-                                                                                                 max_depth,
-                                                                                                 relative_distance_from_center);
-
-                        WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Temperature is not a number: " << output[entry_in_output[i_property]]
-                                 << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-                        WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Temperature is not finite: " << output[entry_in_output[i_property]]
-                                 << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-
-                      }
-                    break;
-                    case 2: // composition
-
-                      for (const auto &composition_model: composition_models)
-                        {
-                          output[entry_in_output[i_property]] = composition_model->get_composition(position_in_cartesian_coordinates,
-                                                                                                   position_in_natural_coordinates,
-                                                                                                   depth,
-                                                                                                   properties[i_property][1],
-                                                                                                   output[entry_in_output[i_property]],
-                                                                                                   min_depth,
-                                                                                                   max_depth);
-
-                          WBAssert(!std::isnan(output[entry_in_output[i_property]]), "Composition is not a number: " << output[entry_in_output[i_property]]
-                                   << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-                          WBAssert(std::isfinite(output[entry_in_output[i_property]]), "Composition is not finite: " << output[entry_in_output[i_property]]
-                                   << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-
-                        }
-
-                      break;
-                    }
-                  case 3: // grains
-                  {
-                    WorldBuilder::grains  grains(output,properties[i_property][2],entry_in_output[i_property]);
-                    for (const auto &grains_model: grains_models)
-                      {
-                        grains = grains_model->get_grains(position_in_cartesian_coordinates,
-                                                          position_in_natural_coordinates,
-                                                          depth,
-                                                          properties[i_property][1],
-                                                          grains,
-                                                          min_depth,
-                                                          max_depth);
-
-                      }
-                    grains.unroll_into(output,entry_in_output[i_property]);
-                    break;
-                  }
-                  case 4:
-                  {
-                    output[entry_in_output[i_property]] = static_cast<double>(tag_index);
-                    break;
-                  }
-                  default:
-                  {
-                    WBAssertThrow(false,
-                                  "Internal error: Unimplemented property provided. " <<
-                                  "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
-                                  "Provided property number was: " << properties[i_property][0]);
-                  }
-                }
-            }
-        }
-    }
-
-    WB_REGISTER_FEATURE(Plume, plume)
-
-  } // namespace Features
-} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/composition/interface.cc.bak
deleted file mode 100644
index 0921105f353..00000000000
--- a/contrib/world_builder/source/world_builder/features/plume_models/composition/interface.cc.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/plume_models/composition/interface.h"
-
-#include <algorithm>
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace PlumeModels
-    {
-      namespace Composition
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Composition
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/composition/uniform.cc.bak
deleted file mode 100644
index 66065e75d46..00000000000
--- a/contrib/world_builder/source/world_builder/features/plume_models/composition/uniform.cc.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/plume_models/composition/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    using namespace FeatureUtilities;
-    namespace PlumeModels
-    {
-      namespace Composition
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform compositional model. Sets constant compositional field.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::Double(0),
-                            "The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
-                            "The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the labels of the composition which are present there.");
-
-          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
-                            "TA list of compositional fractions corresponding to the compositions list.");
-
-          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value. Replacing implies that all compositions not "
-                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min depth");
-          max_depth = prm.get<double>("max depth");
-
-          compositions = prm.get_vector<unsigned int>("compositions");
-          fractions = prm.get_vector<double>("fractions");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          WBAssertThrow(compositions.size() == fractions.size(),
-                        "There are not the same amount of compositions and fractions.");
-        }
-
-
-        double
-        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const Objects::NaturalCoordinate & /*position_in_natural_coordinates*/,
-                                 const double depth,
-                                 const unsigned int composition_number,
-                                 double composition,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      return apply_operation(operation,composition,fractions[i]);
-                    }
-                }
-
-              if (operation == Operations::REPLACE)
-                return 0.0;
-            }
-          return composition;
-        }
-        WB_REGISTER_FEATURE_PLUME_COMPOSITION_MODEL(Uniform, uniform)
-      } // namespace Composition
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/grains/interface.cc.bak
deleted file mode 100644
index 69abaa7394a..00000000000
--- a/contrib/world_builder/source/world_builder/features/plume_models/grains/interface.cc.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/plume_models/grains/interface.h"
-
-#include <algorithm>
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace PlumeModels
-    {
-      namespace Grains
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          prm.declare_model_entries("grains",parent_name, get_declare_map(),required_entries);
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Grains
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/grains/uniform.cc.bak
deleted file mode 100644
index d6976a7ff4f..00000000000
--- a/contrib/world_builder/source/world_builder/features/plume_models/grains/uniform.cc.bak
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/plume_models/grains/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/utilities.h"
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace PlumeModels
-    {
-      namespace Grains
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform grains model. All grains start exactly the same.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::Double(0),
-                            "The depth in meters from which the grains of this feature are present.");
-          prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
-                            "The depth in meters to which the grains of this feature are present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
-                            "A list with the rotation matrices of the grains which are present there for each compositions.");
-
-          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
-                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace", "multiply"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(-1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
-
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min depth");
-          max_depth = prm.get<double>("max depth");
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
-          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
-
-          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
-                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
-
-
-          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
-                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
-
-          if (set_euler_angles)
-            {
-              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
-              rotation_matrices.resize(euler_angles_vector.size());
-              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
-                {
-                  rotation_matrices[i] = Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
-                }
-
-            }
-          else
-            {
-              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
-            }
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-
-
-          WBAssertThrow(compositions.size() == rotation_matrices.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                            const Objects::NaturalCoordinate & /*position_in_natural_coordinates*/,
-                            const double depth,
-                            const unsigned int composition_number,
-                            WorldBuilder::grains grains_,
-                            const double  /*feature_min_depth*/,
-                            const double /*feature_max_depth*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
-
-                      const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
-                      std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
-
-                      return grains_local;
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_PLUME_GRAINS_MODEL(Uniform, uniform)
-      } // namespace Grains
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/temperature/gaussian.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/temperature/gaussian.cc.bak
deleted file mode 100644
index e7fc12d4277..00000000000
--- a/contrib/world_builder/source/world_builder/features/plume_models/temperature/gaussian.cc.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/plume_models/temperature/gaussian.h"
-
-
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/array.h"
-#include "world_builder/world.h"
-
-#include <algorithm>
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace PlumeModels
-    {
-      namespace Temperature
-      {
-        Gaussian::Gaussian(WorldBuilder::World *world_)
-          :
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "gaussian";
-        }
-
-        Gaussian::~Gaussian()
-          = default;
-
-        void
-        Gaussian::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `max distance fault` center to the required parameters.
-          prm.declare_entry("", Types::Object({"centerline temperatures"}),
-                            "Gaussian temperature model. The temperature is interpolated between the plume center "
-                            "and margin (as defined by the plume feature) using a Gaussian function: "
-                            "T(r) = T_center(z) exp(-r^2/(2 sigma^2). "
-                            "The temperature at the plume centerline T_center can be changed with depth by defining "
-                            "an array of depths and centerline temperatures, and temperature is interpolated linearly "
-                            "with depth. Similarly, the sigma of the Gaussian function (relative to the width of "
-                            "the plume as given by the plume feature) can be changed with depth. "
-                            "Temperature is always interpolated in a horizonzal/radial plane, except for the plume "
-                            "head: If the first depth of the plume centerline and the minimum depth of the plume "
-                            "feature are different, an ellipsoidal plume head is created in this depth range. "
-                            "Within this plume head, temperature is interpolated radially, i.e., depending on the "
-                            "distance from the center of the ellipsoid.");
-
-          prm.declare_entry("depths", Types::Array(Types::Double(0)),
-                            "The list of depths where both the temperature in the center of the plume "
-                            "and the width of the temperature anomaly in terms of the sigma of a Gaussian "
-                            "function can be provided. Temperature is interpolated linearly in vertical "
-                            "direction between these depths. Units: m.");
-          prm.declare_entry("centerline temperatures", Types::Array(Types::Double(0)),
-                            "The temperature at the center of this feature in degree Kelvin."
-                            "If the value is below zero, then an adiabatic temperature is used.");
-          prm.declare_entry("gaussian sigmas", Types::Array(Types::Double(0.3)),
-                            "The sigma (standard deviation) of the Gaussian function used to compute the "
-                            "temperature distribution within the plume. This sigma is non-dimensional, i.e. "
-                            "it is defined relative to the distance between the plume center and margin as "
-                            "defined by the plume feature. Choosing a sigma of 1 therefore means that the "
-                            "temperature at the plume margin is set to a fraction of 1/sqrt(e) (approx. 0.61) "
-                            "of the centerline temperature. To achieve a smoother transition between the "
-                            "plume temperature and the outside temperature a smaller values has to be chosen "
-                            "for the gaussian sigmas.");
-        }
-
-        void
-        Gaussian::parse_entries(Parameters &prm)
-        {
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          depths = prm.get_vector<double>("depths");
-          center_temperatures = prm.get_vector<double>("centerline temperatures");
-          gaussian_sigmas = prm.get_vector<double>("gaussian sigmas");
-
-          WBAssert(center_temperatures.size() == depths.size() && gaussian_sigmas.size() == depths.size(),
-                   "The depths, center_temperatures and gaussian_sigmas arrays need to have the same number of entries. "
-                   "At the moment there are: "
-                   << depths.size() << " depth entries, "
-                   << center_temperatures.size() << " centerline temperature entries, and "
-                   << gaussian_sigmas.size() << " gaussian sigma entries!");
-        }
-
-
-        double
-        Gaussian::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                  const Objects::NaturalCoordinate & /*position_in_natural_coordinates*/,
-                                  const double depth,
-                                  const double gravity_norm,
-                                  double temperature_,
-                                  const double feature_min_depth,
-                                  const double feature_max_depth,
-                                  const double relative_distance_from_center) const
-        {
-          if (depth <= feature_max_depth && depth >= feature_min_depth && relative_distance_from_center <= 1.)
-            {
-              // Figure out if the point is within the plume
-              auto upper = std::upper_bound(depths.begin(), depths.end(), depth);
-
-              double center_temperature_local;
-              double gaussian_sigma;
-
-              if (upper - depths.begin() == 0)
-                {
-                  center_temperature_local = center_temperatures.front();
-                  gaussian_sigma = gaussian_sigmas.front();
-                }
-              else if (upper - depths.end() == 0)
-                {
-                  center_temperature_local = center_temperatures.back();
-                  gaussian_sigma = gaussian_sigmas.back();
-                }
-              else
-                {
-                  const unsigned int index = static_cast<unsigned int>(std::distance(depths.begin(), upper));
-                  const double fraction = (depth - depths[index-1]) / (depths[index] - depths[index-1]);
-
-                  center_temperature_local = (1-fraction) * center_temperatures[index-1] + fraction * center_temperatures[index];
-                  gaussian_sigma = (1-fraction) * gaussian_sigmas[index-1] + fraction * gaussian_sigmas[index];
-                }
-
-              if (center_temperature_local < 0)
-                {
-                  center_temperature_local =  this->world->potential_mantle_temperature *
-                                              std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                        this->world->specific_heat) * depth);
-                }
-
-              const double new_temperature =   center_temperature_local * std::exp(-relative_distance_from_center/(2.*std::pow(gaussian_sigma, 2)));
-
-              return apply_operation(operation,temperature_,new_temperature);
-
-            }
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_PLUME_TEMPERATURE_MODEL(Gaussian, gaussian)
-      } // namespace Temperature
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/temperature/interface.cc.bak
deleted file mode 100644
index 98c36d94b9a..00000000000
--- a/contrib/world_builder/source/world_builder/features/plume_models/temperature/interface.cc.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/plume_models/temperature/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace PlumeModels
-    {
-      namespace Temperature
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          // The type needs to be stored in a separate value, otherwise there are memory issues
-          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
-
-          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
-          {
-            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
-            {
-              "operation", type,
-              "Whether the value should replace any value previously defined at this location (replace), "
-              "add the value to the previously define value (add) or subtract the value to the previously "
-              "define value (subtract)."
-            }
-          });
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Temperature
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/plume_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/plume_models/temperature/uniform.cc.bak
deleted file mode 100644
index 99438d63b31..00000000000
--- a/contrib/world_builder/source/world_builder/features/plume_models/temperature/uniform.cc.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/plume_models/temperature/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/value_at_points.h"
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace PlumeModels
-    {
-      namespace Temperature
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `temperature` to the required parameters.
-          prm.declare_entry("", Types::Object({"temperature"}),
-                            "Uniform temperature model. Set the temperature to a constant value.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min depth", Types::Double(0),
-                            "The depth in meters from which the temperature of this feature is present.");
-          prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
-                            "The depth in meters to which the temperature of this feature is present.");
-
-          prm.declare_entry("temperature", Types::Double(293.15),
-                            "The temperature in degree Kelvin which this feature should have");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min depth");
-          max_depth = prm.get<double>("max depth");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          temperature = prm.get<double>("temperature");
-        }
-
-
-        double
-        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const Objects::NaturalCoordinate & /*position_in_natural_coordinates*/,
-                                 const double depth,
-                                 const double  /*gravity*/,
-                                 double temperature_,
-                                 const double /*feature_min_depth*/,
-                                 const double /*feature_max_depth*/,
-                                 const double /*relative_distance_from_center*/) const
-        {
-          if (depth <= max_depth && depth >= min_depth)
-            {
-              return apply_operation(operation,temperature_,temperature);
-            }
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_PLUME_TEMPERATURE_MODEL(Uniform, uniform)
-      } // namespace Temperature
-    } // namespace PlumeModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate.cc.bak
deleted file mode 100644
index 8d5faa53360..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate.cc.bak
+++ /dev/null
@@ -1,762 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include "world_builder/features/subducting_plate.h"
-
-
-#include "glm/glm.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/point.h"
-#include "world_builder/types/segment.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/world.h"
-#include <algorithm>
-
-using namespace std;
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    SubductingPlate::SubductingPlate(WorldBuilder::World *world_)
-      :
-      reference_point(0,0,cartesian)
-    {
-      this->world = world_;
-      this->name = "subducting plate";
-    }
-
-    SubductingPlate::~SubductingPlate()
-      = default;
-
-
-
-    void SubductingPlate::make_snippet(Parameters &prm)
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-
-      const std::string path = prm.get_full_json_path();
-
-      /*
-      ideally:
-       {
-        "model": "fault",
-        "name": "${1:default name}",
-        "dip point":[0.0,0.0],
-        "coordinates": [[0.0,0.0]],
-        "segments": [],
-        "sections": [],
-        "temperature models":[{"model":"uniform", "temperature":600.0}],
-        "composition models":[{"model":"uniform", "compositions": [0], "fractions":[1.0]}]
-       }
-       */
-
-      Pointer((path + "/body").c_str()).Set(declarations,"object");
-      Pointer((path + "/body/model").c_str()).Set(declarations,"subducting plate");
-      Pointer((path + "/body/name").c_str()).Set(declarations,"${1:My Subducting Plate}");
-      Pointer((path + "/body/coordinates").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/temperature models").c_str()).Create(declarations).SetArray();
-      Pointer((path + "/body/composition models").c_str()).Create(declarations).SetArray();
-    }
-
-
-
-    void
-    SubductingPlate::declare_entries(Parameters &prm,
-                                     const std::string &parent_name,
-                                     const std::vector<std::string> &required_entries)
-    {
-      // This statement is needed because of the recursion associated with
-      // the sections entry.
-      if (parent_name == "items")
-        {
-          prm.enter_subsection("properties");
-        }
-      else
-        {
-          prm.declare_entry("", Types::Object(required_entries), "Subducting slab object. Requires properties `model` and `coordinates`.");
-        }
-
-
-      prm.declare_entry("min depth", Types::Double(0),
-                        "The depth to which this feature is present");
-      prm.declare_entry("max depth", Types::Double(std::numeric_limits<double>::max()),
-                        "The depth to which this feature is present");
-      prm.declare_entry("dip point", Types::Point<2>(),
-                        "The depth to which this feature is present");
-
-      /*prm.declare_entry("segments", Types::Array(Types::Segment(0,Point<2>(0,0,invalid),Point<2>(0,0,invalid),Point<2>(0,0,invalid),
-                                                                Types::PluginSystem("", Features::SubductingPlateModels::Temperature::Interface::declare_entries, {"model"}),
-                                                                Types::PluginSystem("", Features::SubductingPlateModels::Composition::Interface::declare_entries, {"model"}),
-                                                                Types::PluginSystem("", Features::SubductingPlateModels::Grains::Interface::declare_entries, {"model"}))),
-                        "The depth to which this feature is present");*/
-      prm.declare_entry("segments", Types::Array(Types::Segment(0,Point<2>(0,0,invalid),Point<2>(0,0,invalid),Point<2>(0,0,invalid),
-                                                                Types::PluginSystem("", Features::SubductingPlateModels::Temperature::Interface::declare_entries, {"model"}),
-                                                                Types::PluginSystem("", Features::SubductingPlateModels::Composition::Interface::declare_entries, {"model"}),
-                                                                Types::PluginSystem("", Features::SubductingPlateModels::Grains::Interface::declare_entries, {"model"}))),
-                        "The depth to which this feature is present");
-
-      prm.declare_entry("temperature models",
-                        Types::PluginSystem("", Features::SubductingPlateModels::Temperature::Interface::declare_entries, {"model"}),
-                        "A list of temperature models.");
-      prm.declare_entry("composition models",
-                        Types::PluginSystem("", Features::SubductingPlateModels::Composition::Interface::declare_entries, {"model"}),
-                        "A list of composition models.");
-      prm.declare_entry("grains models",
-                        Types::PluginSystem("", Features::SubductingPlateModels::Grains::Interface::declare_entries, {"model"}),
-                        "A list of grains models.");
-
-      if (parent_name != "items")
-        {
-          // This only happens if we are not in sections
-          prm.declare_entry("sections", Types::Array(Types::PluginSystem("",Features::SubductingPlate::declare_entries, {"coordinate"}, false)),"A list of feature properties for a coordinate.");
-        }
-      else
-        {
-
-          // this only happens in sections
-          prm.declare_entry("coordinate", Types::UnsignedInt(0),
-                            "The coordinate which should be overwritten");
-
-          prm.leave_subsection();
-        }
-    }
-
-    void
-    SubductingPlate::parse_entries(Parameters &prm)
-    {
-      const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
-
-      this->name = prm.get<std::string>("name");
-
-      std::string tag = prm.get<std::string>("tag");
-      if (tag == "")
-        {
-          tag = "subducting plate";
-        }
-      this->tag_index = FeatureUtilities::add_vector_unique(this->world->feature_tags,tag);
-
-      this->get_coordinates("coordinates", prm, coordinate_system);
-
-
-      starting_depth = prm.get<double>("min depth");
-      maximum_depth = prm.get<double>("max depth");
-
-      const size_t n_sections = this->original_number_of_coordinates;
-
-      reference_point = prm.get<Point<2> >("dip point");
-
-      if (coordinate_system == spherical)
-        {
-          // When spherical, input is in degrees, so change to radians for internal use.
-          reference_point *= (Consts::PI/180.);
-        }
-
-      default_temperature_models.resize(0);
-      default_composition_models.resize(0);
-      default_grains_models.resize(0);
-      prm.get_shared_pointers<Features::SubductingPlateModels::Temperature::Interface>("temperature models", default_temperature_models);
-      prm.get_shared_pointers<Features::SubductingPlateModels::Composition::Interface>("composition models", default_composition_models);
-      prm.get_shared_pointers<Features::SubductingPlateModels::Grains::Interface>("grains models", default_grains_models);
-
-      // get the default segments.
-      default_segment_vector = prm.get_vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
-      Features::SubductingPlateModels::Composition::Interface,
-      Features::SubductingPlateModels::Grains::Interface> >("segments", default_temperature_models, default_composition_models, default_grains_models);
-
-
-      // This vector stores segments to this coordinate/section.
-      //First used (raw) pointers to the segment relevant to this coordinate/section,
-      // but I do not trust it won't fail when memory is moved. So storing the all the data now.
-      segment_vector.resize(0);
-      segment_vector.resize(n_sections, default_segment_vector);
-
-
-      // now search whether a section is present, if so, replace the default segments.
-      std::vector<std::unique_ptr<Features::SubductingPlate> > sections_vector;
-      prm.get_unique_pointers("sections", sections_vector);
-
-      prm.enter_subsection("sections");
-      for (unsigned int i_section = 0; i_section < n_sections; ++i_section)
-        {
-          // first check whether this section/coordinate has a a special overwrite
-          for (unsigned int i_sector = 0; i_sector < sections_vector.size(); ++i_sector)
-            {
-              prm.enter_subsection(std::to_string(i_sector));
-              {
-                const unsigned int change_coord_number = prm.get<unsigned int>("coordinate");
-
-                WBAssertThrow(segment_vector.size() > change_coord_number, "Error: for subducting plate with name: '" << this->name
-                              << "', trying to change the section of coordinate " << change_coord_number
-                              << " while only " << segment_vector.size() << " coordinates are defined.");
-
-                std::vector<std::shared_ptr<Features::SubductingPlateModels::Temperature::Interface> > local_default_temperature_models;
-                std::vector<std::shared_ptr<Features::SubductingPlateModels::Composition::Interface>  > local_default_composition_models;
-                std::vector<std::shared_ptr<Features::SubductingPlateModels::Grains::Interface>  > local_default_grains_models;
-
-                if (!prm.get_shared_pointers<Features::SubductingPlateModels::Temperature::Interface>("temperature models", local_default_temperature_models))
-                  {
-                    // no local temperature model, use global default
-                    local_default_temperature_models = default_temperature_models;
-                  }
-
-                if (!prm.get_shared_pointers<Features::SubductingPlateModels::Composition::Interface>("composition models", local_default_composition_models))
-                  {
-                    // no local composition model, use global default
-                    local_default_composition_models = default_composition_models;
-                  }
-
-                if (!prm.get_shared_pointers<Features::SubductingPlateModels::Grains::Interface>("grains models", local_default_grains_models))
-                  {
-                    // no local composition model, use global default
-                    local_default_grains_models = default_grains_models;
-                  }
-
-                segment_vector[change_coord_number] = prm.get_vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
-                                                      Features::SubductingPlateModels::Composition::Interface,
-                                                      Features::SubductingPlateModels::Grains::Interface> >("segments", local_default_temperature_models, local_default_composition_models, local_default_grains_models);
-
-
-                WBAssertThrow(segment_vector[change_coord_number].size() == default_segment_vector.size(),
-                              "Error: There are not the same amount of segments in section with coordinate " << change_coord_number
-                              << " (" << segment_vector[change_coord_number].size() << " segments) as in the default segment ("
-                              << default_segment_vector.size() << " segments). This is not allowed.");
-
-                prm.enter_subsection("segments");
-                {
-                  for (unsigned int i = 0; i < segment_vector[change_coord_number].size(); ++i)
-                    {
-                      prm.enter_subsection(std::to_string(i));
-                      {
-                        prm.enter_subsection("temperature models");
-                        {
-                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].temperature_systems.size(); ++j)
-                            {
-                              prm.enter_subsection(std::to_string(j));
-                              {
-                                segment_vector[change_coord_number][i].temperature_systems[j]->parse_entries(prm);
-                              }
-                              prm.leave_subsection();
-                            }
-                        }
-                        prm.leave_subsection();
-
-
-                        prm.enter_subsection("composition models");
-                        {
-                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].composition_systems.size(); ++j)
-                            {
-                              prm.enter_subsection(std::to_string(j));
-                              {
-                                segment_vector[change_coord_number][i].composition_systems[j]->parse_entries(prm);
-                              }
-                              prm.leave_subsection();
-                            }
-                        }
-                        prm.leave_subsection();
-
-                        prm.enter_subsection("grains models");
-                        {
-                          for (unsigned int j = 0; j < segment_vector[change_coord_number][i].grains_systems.size(); ++j)
-                            {
-                              prm.enter_subsection(std::to_string(j));
-                              {
-                                segment_vector[change_coord_number][i].grains_systems[j]->parse_entries(prm);
-                              }
-                              prm.leave_subsection();
-                            }
-                        }
-                        prm.leave_subsection();
-                      }
-                      prm.leave_subsection();
-                    }
-                }
-                prm.leave_subsection();
-
-              }
-              prm.leave_subsection();
-            }
-
-        }
-      prm.leave_subsection();
-
-
-      prm.enter_subsection("segments");
-      {
-        for (unsigned int i = 0; i < default_segment_vector.size(); ++i)
-          {
-            prm.enter_subsection(std::to_string(i));
-            {
-              prm.enter_subsection("temperature models");
-              {
-                for (unsigned int j = 0; j < default_segment_vector[i].temperature_systems.size(); ++j)
-                  {
-                    prm.enter_subsection(std::to_string(j));
-                    {
-                      default_segment_vector[i].temperature_systems[j]->parse_entries(prm);
-                    }
-                    prm.leave_subsection();
-                  }
-              }
-              prm.leave_subsection();
-
-
-              prm.enter_subsection("composition models");
-              {
-                for (unsigned int j = 0; j < default_segment_vector[i].composition_systems.size(); ++j)
-                  {
-                    prm.enter_subsection(std::to_string(j));
-                    {
-                      default_segment_vector[i].composition_systems[j]->parse_entries(prm);
-                    }
-                    prm.leave_subsection();
-                  }
-              }
-              prm.leave_subsection();
-
-
-              prm.enter_subsection("grains models");
-              {
-                for (unsigned int j = 0; j < default_segment_vector[i].grains_systems.size(); ++j)
-                  {
-                    prm.enter_subsection(std::to_string(j));
-                    {
-                      default_segment_vector[i].grains_systems[j]->parse_entries(prm);
-                    }
-                    prm.leave_subsection();
-                  }
-              }
-              prm.leave_subsection();
-            }
-            prm.leave_subsection();
-          }
-      }
-      prm.leave_subsection();
-
-      maximum_slab_thickness = 0;
-      maximum_total_slab_length = 0;
-      total_slab_length.resize(original_number_of_coordinates);
-      slab_segment_lengths.resize(original_number_of_coordinates);
-      slab_segment_thickness.resize(original_number_of_coordinates);
-      slab_segment_top_truncation.resize(original_number_of_coordinates);
-      slab_segment_angles.resize(original_number_of_coordinates);
-
-      for (unsigned int i = 0; i < segment_vector.size(); ++i)
-        {
-          double local_total_slab_length = 0;
-          slab_segment_lengths[i].resize(segment_vector[i].size());
-          slab_segment_thickness[i].resize(segment_vector[i].size(), Point<2>(invalid));
-          slab_segment_top_truncation[i].resize(segment_vector[i].size(), Point<2>(invalid));
-          slab_segment_angles[i].resize(segment_vector[i].size(), Point<2>(invalid));
-          for (unsigned int j = 0; j < segment_vector[i].size(); ++j)
-            {
-              slab_segment_lengths[i][j] = segment_vector[i][j].value_length;
-              local_total_slab_length += segment_vector[i][j].value_length;
-
-              slab_segment_thickness[i][j] = segment_vector[i][j].value_thickness;
-              maximum_slab_thickness = std::max(maximum_slab_thickness, slab_segment_thickness[i][j][0]);
-              maximum_slab_thickness = std::max(maximum_slab_thickness, slab_segment_thickness[i][j][1]);
-              slab_segment_top_truncation[i][j] = segment_vector[i][j].value_top_truncation;
-
-              slab_segment_angles[i][j] = segment_vector[i][j].value_angle * (Consts::PI/180);
-            }
-          total_slab_length[i] = local_total_slab_length;
-          maximum_total_slab_length = std::max(maximum_total_slab_length, local_total_slab_length);
-        }
-
-      // Here, we compute the spherical bounding box using the two extreme points of the box containing all the surface
-      // coordinates and an additional buffer zone that accounts for the slab thickness and length. The first and second
-      // points correspond to the lower left and the upper right corners of the bounding box, respectively (see the
-      // documentation in include/bounding_box.h).
-      // For the spherical system, the buffer zone along the longitudal direction is calculated using the
-      // corresponding latitude points.
-
-      // Find minimal and maximal coordinates. Do this by finding the
-      // leftmost/rightmost point with regard to either the [0] or [1]
-      // coordinate, and then takes its [0] or [1] element.
-      auto compare_x_coordinate = [](auto p1, auto p2)
-      {
-        return p1[0]<p2[0];
-      };
-
-      min_along_x = (*std::min_element(coordinates.begin(), coordinates.end(), compare_x_coordinate)) [0];
-      max_along_x = (*std::max_element(coordinates.begin(), coordinates.end(), compare_x_coordinate)) [0];
-
-
-      auto compare_y_coordinate = [](auto p1, auto p2)
-      {
-        return p1[1]<p2[1];
-      };
-
-      min_along_y = (*std::min_element(coordinates.begin(), coordinates.end(), compare_y_coordinate)) [1];
-      max_along_y = (*std::max_element(coordinates.begin(), coordinates.end(), compare_y_coordinate)) [1];
-
-      min_lat_cos_inv = 1. / std::cos(min_along_y);
-      max_lat_cos_inv = 1. / std::cos(max_along_y);
-
-      buffer_around_slab_cartesian = (maximum_slab_thickness + maximum_total_slab_length);
-
-      // Compute the surface bounding box
-      buffer_around_slab_cartesian = (maximum_slab_thickness + maximum_total_slab_length);
-      if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical)
-        {
-          const double starting_radius_inv = 1 / (world->parameters.coordinate_system->max_model_depth());
-          std::pair<Point<2>, Point<2> > &spherical_bounding_box = surface_bounding_box.get_boundary_points();
-
-          const double buffer_around_slab_spherical = 2 * Consts::PI * buffer_around_slab_cartesian * starting_radius_inv;
-
-          spherical_bounding_box.first = {(min_along_x - buffer_around_slab_spherical * min_lat_cos_inv) ,
-                                          (min_along_y - buffer_around_slab_spherical), spherical
-                                         } ;
-
-          spherical_bounding_box.second = {(max_along_x + buffer_around_slab_spherical * max_lat_cos_inv) ,
-                                           (max_along_y + buffer_around_slab_spherical), spherical
-                                          };
-        }
-      else if (world->parameters.coordinate_system->natural_coordinate_system() == CoordinateSystem::cartesian)
-        {
-          std::pair<Point<2>, Point<2> > &bounding_box = surface_bounding_box.get_boundary_points();
-          bounding_box.first = {min_along_x, min_along_y, cartesian};
-          bounding_box.second = {max_along_x, max_along_y, cartesian};
-          surface_bounding_box.extend(buffer_around_slab_cartesian);
-        }
-    }
-
-
-
-    const BoundingBox<2> &
-    SubductingPlate::get_surface_bounding_box () const
-    {
-      return surface_bounding_box;
-    }
-
-
-    void
-    SubductingPlate::properties(const Point<3> &position_in_cartesian_coordinates,
-                                const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                const double depth,
-                                const std::vector<std::array<unsigned int,3>> &properties,
-                                const double gravity_norm,
-                                const std::vector<size_t> &entry_in_output,
-                                std::vector<double> &output) const
-    {
-      // The depth variable is the distance from the surface to the position, the depth
-      // coordinate is the distance from the bottom of the model to the position and
-      // the starting radius is the distance from the bottom of the model to the surface.
-      const double starting_radius = position_in_natural_coordinates.get_depth_coordinate() + depth - starting_depth;
-
-      WBAssert(std::abs(starting_radius) > std::numeric_limits<double>::epsilon(), "World Builder error: starting_radius can not be zero. "
-               << "Position = " << position_in_cartesian_coordinates[0] << ':' << position_in_cartesian_coordinates[1] << ':' << position_in_cartesian_coordinates[2]
-               << ", position_in_natural_coordinates.get_depth_coordinate() = " << position_in_natural_coordinates.get_depth_coordinate()
-               << ", depth = " << depth
-               << ", starting_depth " << starting_depth
-              );
-
-      // todo: explain and check -starting_depth
-      if (depth <= maximum_depth && depth >= starting_depth && depth <= maximum_total_slab_length + maximum_slab_thickness &&
-          get_surface_bounding_box().point_inside(Point<2>(position_in_natural_coordinates.get_surface_coordinates(),
-                                                           world->parameters.coordinate_system->natural_coordinate_system())))
-        {
-          /*WBAssert(coordinates.size() == slab_segment_lengths.size(),
-                   "Internal error: The size of coordinates (" << coordinates.size()
-                   << ") and slab_segment_lengths (" << slab_segment_lengths.size() << ") are different.");
-          WBAssert(coordinates.size() == slab_segment_angles.size(),
-                   "Internal error: The size of coordinates (" << coordinates.size()
-                   << ") and slab_segment_angles (" << slab_segment_angles.size() << ") are different.");
-          WBAssert(coordinates.size() == slab_segment_angles.size(),
-                   "Internal error: The size of coordinates (" << coordinates.size()
-                   << ") and one_dimensional_coordinates (" << one_dimensional_coordinates.size() << ") are different.");*/
-          // todo: explain
-          const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
-            WorldBuilder::Utilities::distance_point_from_curved_planes(position_in_cartesian_coordinates,
-                                                                       position_in_natural_coordinates,
-                                                                       reference_point,
-                                                                       coordinates,
-                                                                       slab_segment_lengths,
-                                                                       slab_segment_angles,
-                                                                       starting_radius,
-                                                                       this->world->parameters.coordinate_system,
-                                                                       false,
-                                                                       this->bezier_curve);
-
-          const double distance_from_plane = distance_from_planes.distance_from_plane;
-          const double distance_along_plane = distance_from_planes.distance_along_plane;
-          const double section_fraction = distance_from_planes.fraction_of_section;
-          const size_t current_section = distance_from_planes.section;
-          const size_t next_section = current_section + 1;
-          const size_t current_segment = distance_from_planes.segment; // the original value was a unsigned in, converting it back.
-          //const size_t next_segment = current_segment + 1;
-          const double segment_fraction = distance_from_planes.fraction_of_segment;
-
-          if (abs(distance_from_plane) < std::numeric_limits<double>::infinity() || (distance_along_plane) < std::numeric_limits<double>::infinity())
-            {
-              // We want to do both section (horizontal) and segment (vertical) interpolation.
-              // first for thickness
-              const double thickness_up = slab_segment_thickness[current_section][current_segment][0]
-                                          + section_fraction
-                                          * (slab_segment_thickness[next_section][current_segment][0]
-                                             - slab_segment_thickness[current_section][current_segment][0]);
-              const double thickness_down = slab_segment_thickness[current_section][current_segment][1]
-                                            + section_fraction
-                                            * (slab_segment_thickness[next_section][current_segment][1]
-                                               - slab_segment_thickness[current_section][current_segment][1]);
-              const double thickness_local = thickness_up + segment_fraction * (thickness_down - thickness_up);
-
-              // if the thickness is zero, we don't need to compute anything, so return.
-              if (std::fabs(thickness_local) < 2.0 * std::numeric_limits<double>::epsilon())
-                return;
-
-              // secondly for top truncation
-              const double top_truncation_up = slab_segment_top_truncation[current_section][current_segment][0]
-                                               + section_fraction
-                                               * (slab_segment_top_truncation[next_section][current_segment][0]
-                                                  - slab_segment_top_truncation[current_section][current_segment][0]);
-              const double top_truncation_down = slab_segment_top_truncation[current_section][current_segment][1]
-                                                 + section_fraction
-                                                 * (slab_segment_top_truncation[next_section][current_segment][1]
-                                                    - slab_segment_top_truncation[current_section][current_segment][1]);
-              const double top_truncation_local = top_truncation_up + segment_fraction * (top_truncation_down - top_truncation_up);
-
-              // if the thickness is smaller than what is truncated off at the top, we don't need to compute anything, so return.
-              if (thickness_local < top_truncation_local)
-                return;
-
-              const double max_slab_length = total_slab_length[current_section] +
-                                             section_fraction *
-                                             (total_slab_length[next_section] - total_slab_length[current_section]);
-
-              if (distance_from_plane >= top_truncation_local &&
-                  distance_from_plane <= thickness_local &&
-                  distance_along_plane >= 0 &&
-                  distance_along_plane <= max_slab_length)
-                {
-                  // Inside the slab!
-                  const Features::AdditionalParameters additional_parameters = {max_slab_length,thickness_local};
-                  for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
-                    {
-                      switch (properties[i_property][0])
-                        {
-                          case 1: // temperature
-                          {
-                            double temperature_current_section = output[entry_in_output[i_property]];
-                            double temperature_next_section = output[entry_in_output[i_property]];
-
-                            for (const auto &temperature_model: segment_vector[current_section][current_segment].temperature_systems)
-                              {
-                                temperature_current_section = temperature_model->get_temperature(position_in_cartesian_coordinates,
-                                                                                                 depth,
-                                                                                                 gravity_norm,
-                                                                                                 temperature_current_section,
-                                                                                                 starting_depth,
-                                                                                                 maximum_depth,
-                                                                                                 distance_from_planes,
-                                                                                                 additional_parameters);
-
-                                WBAssert(!std::isnan(temperature_current_section), "Temperature is not a number: " << temperature_current_section
-                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-                                WBAssert(std::isfinite(temperature_current_section), "Temperature is not a finite: " << temperature_current_section
-                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-
-                              }
-
-                            for (const auto &temperature_model: segment_vector[next_section][current_segment].temperature_systems)
-                              {
-                                temperature_next_section = temperature_model->get_temperature(position_in_cartesian_coordinates,
-                                                                                              depth,
-                                                                                              gravity_norm,
-                                                                                              temperature_next_section,
-                                                                                              starting_depth,
-                                                                                              maximum_depth,
-                                                                                              distance_from_planes,
-                                                                                              additional_parameters);
-
-                                WBAssert(!std::isnan(temperature_next_section), "Temperature is not a number: " << temperature_next_section
-                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-                                WBAssert(std::isfinite(temperature_next_section), "Temperature is not a finite: " << temperature_next_section
-                                         << ", based on a temperature model with the name " << temperature_model->get_name() << ", in feature " << this->name);
-
-                              }
-
-                            // linear interpolation between current and next section temperatures
-                            output[entry_in_output[i_property]] = temperature_current_section + section_fraction * (temperature_next_section - temperature_current_section);
-                            break;
-                          }
-                          case 2: // composition
-                          {
-                            double composition_current_section = output[entry_in_output[i_property]];
-                            double composition_next_section = output[entry_in_output[i_property]];
-
-                            for (const auto &composition_model: segment_vector[current_section][current_segment].composition_systems)
-                              {
-                                composition_current_section = composition_model->get_composition(position_in_cartesian_coordinates,
-                                                                                                 depth,
-                                                                                                 properties[i_property][1],
-                                                                                                 composition_current_section,
-                                                                                                 starting_depth,
-                                                                                                 maximum_depth,
-                                                                                                 distance_from_planes,
-                                                                                                 additional_parameters);
-
-                                WBAssert(!std::isnan(composition_current_section), "Composition_current_section is not a number: " << composition_current_section
-                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-                                WBAssert(std::isfinite(composition_current_section), "Composition_current_section is not a finite: " << composition_current_section
-                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-
-                              }
-
-                            for (const auto &composition_model: segment_vector[next_section][current_segment].composition_systems)
-                              {
-                                composition_next_section = composition_model->get_composition(position_in_cartesian_coordinates,
-                                                                                              depth,
-                                                                                              properties[i_property][1],
-                                                                                              composition_next_section,
-                                                                                              starting_depth,
-                                                                                              maximum_depth,
-                                                                                              distance_from_planes,
-                                                                                              additional_parameters);
-
-                                WBAssert(!std::isnan(composition_next_section), "Composition_next_section is not a number: " << composition_next_section
-                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-                                WBAssert(std::isfinite(composition_next_section), "Composition_next_section is not a finite: " << composition_next_section
-                                         << ", based on a composition model with the name " << composition_model->get_name() << ", in feature " << this->name);
-
-                              }
-
-                            // linear interpolation between current and next section temperatures
-                            output[entry_in_output[i_property]] = composition_current_section + section_fraction * (composition_next_section - composition_current_section);
-                            break;
-                          }
-                          case 3: // grains
-                          {
-                            WorldBuilder::grains grains(output,properties[i_property][2],entry_in_output[i_property]);
-                            WorldBuilder::grains  grains_current_section = grains;
-                            WorldBuilder::grains  grains_next_section = grains;
-
-                            for (const auto &grains_model: segment_vector[current_section][current_segment].grains_systems)
-                              {
-                                grains_current_section = grains_model->get_grains(position_in_cartesian_coordinates,
-                                                                                  depth,
-                                                                                  properties[i_property][1],
-                                                                                  grains_current_section,
-                                                                                  starting_depth,
-                                                                                  maximum_depth,
-                                                                                  distance_from_planes,
-                                                                                  additional_parameters);
-
-                              }
-
-                            for (const auto &grains_model: segment_vector[next_section][current_segment].grains_systems)
-                              {
-                                grains_next_section = grains_model->get_grains(position_in_cartesian_coordinates,
-                                                                               depth,
-                                                                               properties[i_property][1],
-                                                                               grains_next_section,
-                                                                               starting_depth,
-                                                                               maximum_depth,
-                                                                               distance_from_planes,
-                                                                               additional_parameters);
-
-                              }
-
-                            // linear interpolation between current and next section temperatures
-                            for (size_t i = 0; i < grains.sizes.size(); i++)
-                              {
-                                grains.sizes[i] = grains_current_section.sizes[i] + section_fraction * (grains_next_section.sizes[i] - grains_current_section.sizes[i]);
-                              }
-
-                            // average two rotations matrices throu quaternions.
-                            for (size_t i = 0; i < grains_current_section.rotation_matrices.size(); i++)
-                              {
-                                const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(grains_current_section.rotation_matrices[i]);
-                                const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(grains_next_section.rotation_matrices[i]);
-
-                                const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,section_fraction);
-
-                                grains.rotation_matrices[i] = glm::quaternion::mat3_cast(quat_average);
-                              }
-
-                            grains.unroll_into(output,entry_in_output[i_property]);
-                            break;
-                          }
-                          case 4:
-                          {
-                            output[entry_in_output[i_property]] = static_cast<double>(tag_index);
-                            break;
-                          }
-                          default:
-                          {
-                            WBAssertThrow(false,
-                                          "Internal error: Unimplemented property provided. " <<
-                                          "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
-                                          "Provided property number was: " << properties[i_property][0]);
-                          }
-                        }
-                    }
-
-                }
-            }
-        }
-
-    }
-
-    Objects::PlaneDistances
-    SubductingPlate::distance_to_feature_plane(const Point<3> &position_in_cartesian_coordinates,
-                                               const Objects::NaturalCoordinate &position_in_natural_coordinates,
-                                               const double depth) const
-    {
-      // The depth variable is the distance from the surface to the position, the depth
-      // coordinate is the distance from the bottom of the model to the position and
-      // the starting radius is the distance from the bottom of the model to the surface.
-      const double starting_radius = position_in_natural_coordinates.get_depth_coordinate() + depth - starting_depth;
-
-      WBAssert(std::abs(starting_radius) > std::numeric_limits<double>::epsilon(), "World Builder error: starting_radius can not be zero. "
-               << "Position = " << position_in_cartesian_coordinates[0] << ':' << position_in_cartesian_coordinates[1] << ':' << position_in_cartesian_coordinates[2]
-               << ", natural_coordinate.get_depth_coordinate() = " << position_in_natural_coordinates.get_depth_coordinate()
-               << ", depth = " << depth
-               << ", starting_depth " << starting_depth
-              );
-
-      const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
-        WorldBuilder::Utilities::distance_point_from_curved_planes(position_in_cartesian_coordinates,
-                                                                   position_in_natural_coordinates,
-                                                                   reference_point,
-                                                                   coordinates,
-                                                                   slab_segment_lengths,
-                                                                   slab_segment_angles,
-                                                                   starting_radius,
-                                                                   this->world->parameters.coordinate_system,
-                                                                   false,
-                                                                   this->bezier_curve);
-
-      Objects::PlaneDistances plane_distances(distance_from_planes.distance_from_plane, distance_from_planes.distance_along_plane);
-      return plane_distances;
-    }
-
-    /**
-     * Register plugin
-     */
-    WB_REGISTER_FEATURE(SubductingPlate, subducting plate)
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/interface.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/interface.cc.bak
deleted file mode 100644
index 8690913524e..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/interface.cc.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/composition/interface.h"
-
-#include <algorithm>
-
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Composition
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          prm.declare_model_entries("composition",parent_name, get_declare_map(),required_entries);
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Composition
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/smooth.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/smooth.cc.bak
deleted file mode 100644
index 6501fca135a..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/smooth.cc.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/composition/smooth.h"
-
-#include <world_builder/assert.h>
-#include <world_builder/nan.h>
-#include <world_builder/parameters.h>
-#include <world_builder/utilities.h>
-
-#include <world_builder/types/array.h>
-#include <world_builder/types/double.h>
-#include <world_builder/types/object.h>
-#include <world_builder/types/string.h>
-#include <world_builder/types/unsigned_int.h>
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Composition
-      {
-        Smooth::Smooth(WorldBuilder::World *world_)
-          :
-          min_distance(NaN::DSNAN),
-          side_distance(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "smooth";
-        }
-
-        Smooth::~Smooth()
-          = default;
-
-        void
-        Smooth::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}), "Compositional model object");
-
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "The distance in meters from which the composition of this layer is present.");
-          prm.declare_entry("max distance slab top", Types::Double(0),
-                            "The distance in meters from which the composition of this layer is present.");
-          prm.declare_entry("top fractions",  Types::Array(Types::Double(1.0),1),
-                            "The composition fraction at the top of the slab (layer).");
-          prm.declare_entry("bottom fractions",  Types::Array(Types::Double(0.0),1),
-                            "The composition fraction at the bottom of the slab (layer).");
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the labels of the composition which are present there.");
-          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value. Replacing implies that all compositions not "
-                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
-        }
-
-        void
-        Smooth::parse_entries(Parameters &prm)
-        {
-          min_distance = prm.get<double>("min distance slab top");
-          max_distance = prm.get<double>("max distance slab top");
-          side_distance = std::abs(max_distance-min_distance);
-          //WBAssert(side_distance >= min_distance, "distance at the side needs to be larger or equal than the min distance.");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          top_fraction = prm.get_vector<double>("top fractions");
-          bottom_fraction = prm.get_vector<double>("bottom fractions");
-          compositions = prm.get_vector<unsigned int>("compositions");
-        }
-
-
-        double
-        Smooth::get_composition( const Point<3> & /*position*/,
-                                 const double  /*depth*/,
-                                 const unsigned int composition_number,
-                                 double composition_,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/,
-                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                 const AdditionalParameters & /*additional_parameters*/) const
-        {
-          double composition = composition_;
-          if (distance_from_planes.distance_from_plane <= max_distance && distance_from_planes.distance_from_plane >= min_distance)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-
-                      // Hyperbolic tangent goes from 0 to 1 over approximately x=(0, 2) without any arguments. The function is written
-                      // so that the composition returned 1 to 0 over the side_distance on either sides.
-                      const double scaling = ( 1 - std::tanh(10 * (distance_from_planes.distance_from_plane-side_distance/2.0-min_distance)/side_distance ) )/2.0;
-                      composition = top_fraction[i]*scaling + bottom_fraction[i] * (1-scaling);
-
-                      return apply_operation(operation,composition_,composition);
-                    }
-                }
-
-              if (operation == Operations::REPLACE)
-                return 0.0;
-            }
-          return composition;
-        }
-
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_COMPOSITION_MODEL (Smooth, smooth)
-      } // namespace Composition
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/uniform.cc.bak
deleted file mode 100644
index 9d7ae9627d1..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/composition/uniform.cc.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/composition/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Composition
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform compositional model. Sets constant compositional field.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "todo The depth in meters from which the composition of this feature is present.");
-          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
-                            "todo The depth in meters to which the composition of this feature is present.");
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the labels of the composition which are present there.");
-          prm.declare_entry("fractions", Types::Array(Types::Double(1.0),1),
-                            "TA list of compositional fractions corresponding to the compositions list.");
-          prm.declare_entry("operation", Types::String("replace", std::vector<std::string> {"replace", "replace defined only", "add", "subtract"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value. Replacing implies that all compositions not "
-                            "explicitly defined are set to zero. To only replace the defined compositions use the replace only defined option.");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance slab top");
-          max_depth = prm.get<double>("max distance slab top");
-          compositions = prm.get_vector<unsigned int>("compositions");
-          fractions = prm.get_vector<double>("fractions");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          WBAssertThrow(compositions.size() == fractions.size(),
-                        "There are not the same amount of compositions and fractions.");
-        }
-
-
-        double
-        Uniform::get_composition(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const double /*depth*/,
-                                 const unsigned int composition_number,
-                                 double composition,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/,
-                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
-                                 const AdditionalParameters & /*additional_parameters*/) const
-        {
-          if (distance_from_plane.distance_from_plane <= max_depth && distance_from_plane.distance_from_plane >= min_depth)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      return apply_operation(operation,composition,fractions[i]);
-                    }
-                }
-
-              if (operation == Operations::REPLACE)
-                return 0.0;
-            }
-          return composition;
-        }
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_COMPOSITION_MODEL(Uniform, uniform)
-      } // namespace Composition
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/interface.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/interface.cc.bak
deleted file mode 100644
index 50faddd23af..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/interface.cc.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/grains/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/object.h"
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Grains
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          unsigned int counter = 0;
-          for (auto &it : get_declare_map())
-            {
-              // prevent infinite recursion
-              if (it.first != parent_name)
-                {
-                  prm.enter_subsection("oneOf");
-                  {
-                    prm.enter_subsection(std::to_string(counter));
-                    {
-                      prm.enter_subsection("properties");
-                      {
-                        prm.declare_entry("", Types::Object(required_entries), "grains object");
-
-                        prm.declare_entry("model", Types::String("",it.first),
-                                          "The name of the grains model.");
-
-                        it.second(prm, parent_name);
-                      }
-                      prm.leave_subsection();
-                    }
-                    prm.leave_subsection();
-                  }
-                  prm.leave_subsection();
-
-                  counter++;
-
-                }
-            }
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Grains
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.cc.bak
deleted file mode 100644
index 4317a90579d..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution.cc.bak
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/grains/random_uniform_distribution.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistribution::RandomUniformDistribution(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution";
-        }
-
-        RandomUniformDistribution::~RandomUniformDistribution()
-          = default;
-
-        void
-        RandomUniformDistribution::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "The distance from the slab top in meters from which the composition of this feature is present.");
-          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance from the slab top in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistribution::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance slab top");
-          max_depth = prm.get<double>("max distance slab top");
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistribution::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                              const double /*depth*/,
-                                              const unsigned int composition_number,
-                                              WorldBuilder::grains grains_,
-                                              const double /*feature_min_depth*/,
-                                              const double /*feature_max_depth*/,
-                                              const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                              const AdditionalParameters & /*additional_parameters*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (distance_from_planes.distance_from_plane <= max_depth && distance_from_planes.distance_from_plane >= min_depth)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      std::uniform_real_distribution<> dist(0.0,1.0);
-                      for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                        {
-                          // set a uniform random a_cosine_matrix per grain
-                          // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                          // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                          // and is licenend accourding to this website with the following licence:
-                          //
-                          // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                          // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                          // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                          // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                          // don't be a jerk, and remember that anything free comes with no guarantee.""
-                          //
-                          // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                          // the public domain, and is yours to study, modify, and use."
-
-                          // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                          const double one = dist(world->get_random_number_engine());
-                          const double two = dist(world->get_random_number_engine());
-                          const double three = dist(world->get_random_number_engine());
-
-                          const double theta = 2.0 * Consts::PI * one; // Rotation about the pole (Z)
-                          const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                          const double z = 2.0* three; //For magnitude of pole deflection.
-
-                          // Compute a vector V used for distributing points over the sphere
-                          // via the reflection I - V Transpose(V).  This formulation of V
-                          // will guarantee that if x[1] and x[2] are uniformly distributed,
-                          // the reflected points will be uniform on the sphere.  Note that V
-                          // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                          const double r  = std::sqrt( z );
-                          const double Vx = std::sin( phi ) * r;
-                          const double Vy = std::cos( phi ) * r;
-                          const double Vz = std::sqrt( 2.F - z );
-
-                          // Compute the row vector S = Transpose(V) * R, where R is a simple
-                          // rotation by theta about the z-axis.  No need to compute Sz since
-                          // it's just Vz.
-
-                          const double st = std::sin( theta );
-                          const double ct = std::cos( theta );
-                          const double Sx = Vx * ct - Vy * st;
-                          const double Sy = Vx * st + Vy * ct;
-
-                          // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                          // is equivalent to V S - R.
-
-                          it_rotation_matrices[0][0] = Vx * Sx - ct;
-                          it_rotation_matrices[0][1] = Vx * Sy - st;
-                          it_rotation_matrices[0][2] = Vx * Vz;
-
-                          it_rotation_matrices[1][0] = Vy * Sx + st;
-                          it_rotation_matrices[1][1] = Vy * Sy - ct;
-                          it_rotation_matrices[1][2] = Vy * Vz;
-
-                          it_rotation_matrices[2][0] = Vz * Sx;
-                          it_rotation_matrices[2][1] = Vz * Sy;
-                          it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                        }
-
-                      double total_size = 0;
-                      for (auto &&it_sizes : grains_local.sizes)
-                        {
-                          it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                          total_size += it_sizes;
-                        }
-
-                      if (normalize_grain_sizes[i])
-                        {
-                          const double one_over_total_size = 1/total_size;
-                          std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                         [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                        }
-
-                      return grains_local;
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_GRAINS_MODEL(RandomUniformDistribution, random uniform distribution)
-      } // namespace Grains
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.cc.bak
deleted file mode 100644
index bf9ac3a3e05..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.cc.bak
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/grains/random_uniform_distribution_deflected.h"
-
-#include <algorithm>
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Grains
-      {
-        RandomUniformDistributionDeflected::RandomUniformDistributionDeflected(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "random uniform distribution deflected";
-        }
-
-        RandomUniformDistributionDeflected::~RandomUniformDistributionDeflected()
-          = default;
-
-        void
-        RandomUniformDistributionDeflected::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions to the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Random uniform distribution grains model. The size of the grains can be independently set "
-                            "to a single value or to a random distribution.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "The distance from the slab top in meters from which the composition of this feature is present.");
-          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance from the slab top in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be randomized between 0 and 1.");
-
-          prm.declare_entry("normalize grain sizes",
-                            Types::Array(Types::Bool(true),0),
-                            "A list of whether the sizes of the grains should be normalized or not. If normalized, the total of the grains of a composition will be equal to 1.");
-
-          prm.declare_entry("deflections",
-                            Types::Array(Types::Double(1),0),
-                            "A list of the deflections of all of the grains in each composition between 0 and 1.");
-
-
-
-        }
-
-        void
-        RandomUniformDistributionDeflected::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance slab top");
-          max_depth = prm.get<double>("max distance slab top");
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-          normalize_grain_sizes = prm.get_vector<bool>("normalize grain sizes");
-          deflections = prm.get_vector<double>("deflections");
-
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == normalize_grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and normalize_grain_sizes (" << normalize_grain_sizes.size() << ").");
-          WBAssertThrow(compositions.size() == deflections.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and deflections (" << deflections.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        RandomUniformDistributionDeflected::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                                       const double /*depth*/,
-                                                       const unsigned int composition_number,
-                                                       WorldBuilder::grains grains_,
-                                                       const double /*feature_min_depth*/,
-                                                       const double /*feature_max_depth*/,
-                                                       const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                                       const AdditionalParameters & /*additional_parameters*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (distance_from_planes.distance_from_plane <= max_depth && distance_from_planes.distance_from_plane >= min_depth)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      std::uniform_real_distribution<> dist(0.0,1.0);
-                      for (auto &&it_rotation_matrices : grains_local.rotation_matrices)
-                        {
-                          // set a uniform random a_cosine_matrix per grain
-                          // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-                          // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-                          // and is licenend accourding to this website with the following licence:
-                          //
-                          // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-                          // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-                          // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-                          // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-                          // don't be a jerk, and remember that anything free comes with no guarantee.""
-                          //
-                          // The book saids in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-                          // the public domain, and is yours to study, modify, and use."
-
-                          // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-                          const double one = dist(world->get_random_number_engine());
-                          const double two = dist(world->get_random_number_engine());
-                          const double three = dist(world->get_random_number_engine());
-
-                          const double theta = 2.0 * Consts::PI * one * deflections[i]; // Rotation about the pole (Z)
-                          const double phi = 2.0 * Consts::PI * two; // For direction of pole deflection.
-                          const double z = 2.0* three * deflections[i]; //For magnitude of pole deflection.
-
-                          // Compute a vector V used for distributing points over the sphere
-                          // via the reflection I - V Transpose(V).  This formulation of V
-                          // will guarantee that if x[1] and x[2] are uniformly distributed,
-                          // the reflected points will be uniform on the sphere.  Note that V
-                          // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-                          const double r  = std::sqrt( z );
-                          const double Vx = std::sin( phi ) * r;
-                          const double Vy = std::cos( phi ) * r;
-                          const double Vz = std::sqrt( 2.F - z );
-
-                          // Compute the row vector S = Transpose(V) * R, where R is a simple
-                          // rotation by theta about the z-axis.  No need to compute Sz since
-                          // it's just Vz.
-
-                          const double st = std::sin( theta );
-                          const double ct = std::cos( theta );
-                          const double Sx = Vx * ct - Vy * st;
-                          const double Sy = Vx * st + Vy * ct;
-
-                          // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-                          // is equivalent to V S - R.
-
-                          it_rotation_matrices[0][0] = Vx * Sx - ct;
-                          it_rotation_matrices[0][1] = Vx * Sy - st;
-                          it_rotation_matrices[0][2] = Vx * Vz;
-
-                          it_rotation_matrices[1][0] = Vy * Sx + st;
-                          it_rotation_matrices[1][1] = Vy * Sy - ct;
-                          it_rotation_matrices[1][2] = Vy * Vz;
-
-                          it_rotation_matrices[2][0] = Vz * Sx;
-                          it_rotation_matrices[2][1] = Vz * Sy;
-                          it_rotation_matrices[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-                        }
-
-                      double total_size = 0;
-                      for (auto &&it_sizes : grains_local.sizes)
-                        {
-                          it_sizes = grain_sizes[i] < 0 ? dist(world->get_random_number_engine()) : grain_sizes[i];
-                          total_size += it_sizes;
-                        }
-
-                      if (normalize_grain_sizes[i])
-                        {
-                          const double one_over_total_size = 1/total_size;
-                          std::transform(grains_local.sizes.begin(), grains_local.sizes.end(), grains_local.sizes.begin(),
-                                         [one_over_total_size](double sizes) -> double { return sizes *one_over_total_size; });
-                        }
-
-                      return grains_local;
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_GRAINS_MODEL(RandomUniformDistributionDeflected, random uniform distribution deflected)
-      } // namespace Grains
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/uniform.cc.bak
deleted file mode 100644
index 672dac7948b..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/grains/uniform.cc.bak
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/grains/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Grains
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN)
-
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add compositions the required parameters.
-          prm.declare_entry("", Types::Object({"compositions"}),
-                            "Uniform grains model. All grains start exactly the same.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "The distance from the slab top in meters from which the composition of this feature is present.");
-          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance from the slab top in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("compositions", Types::Array(Types::UnsignedInt(),0),
-                            "A list with the integer labels of the composition which are present there.");
-
-          prm.declare_entry("rotation matrices", Types::Array(Types::Array(Types::Array(Types::Double(0),3,3),3,3),0),
-                            "A list with the labels of the grains which are present there for each compositions.");
-
-          prm.declare_entry("Euler angles z-x-z", Types::Array(Types::Array(Types::Double(0),3,3),0),
-                            "A list with the z-x-z Euler angles of the grains which are present there for each compositions.");
-
-          prm.declare_entry("orientation operation", Types::String("replace", std::vector<std::string> {"replace"}),
-                            "Whether the value should replace any value previously defined at this location (replace) or "
-                            "add the value to the previously define value (add, not implemented). Replacing implies that all values not "
-                            "explicitly defined are set to zero.");
-
-          prm.declare_entry("grain sizes",
-                            Types::Array(Types::Double(-1),0),
-                            "A list of the size of all of the grains in each composition. If set to <0, the size will be set so that the total is equal to 1.");
-
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance slab top");
-          max_depth = prm.get<double>("max distance slab top");
-          compositions = prm.get_vector<unsigned int>("compositions");
-
-          const bool set_euler_angles = prm.check_entry("Euler angles z-x-z");
-          const bool set_rotation_matrices = prm.check_entry("rotation matrices");
-
-          WBAssertThrow(!(set_euler_angles == true && set_rotation_matrices == true),
-                        "Only Euler angles or Rotation matrices may be set, but both are set for " << prm.get_full_json_path());
-
-
-          WBAssertThrow(!(set_euler_angles == false && set_rotation_matrices == false),
-                        "Euler angles or Rotation matrices have to be set, but neither are set for " << prm.get_full_json_path());
-
-          if (set_euler_angles)
-            {
-              std::vector<std::array<double,3> > euler_angles_vector = prm.get_vector<std::array<double,3> >("Euler angles z-x-z");
-              rotation_matrices.resize(euler_angles_vector.size());
-              for (size_t i = 0; i<euler_angles_vector.size(); ++i)
-                {
-                  rotation_matrices[i] = WorldBuilder::Utilities::euler_angles_to_rotation_matrix(euler_angles_vector[i][0],euler_angles_vector[i][1],euler_angles_vector[i][2]);
-                }
-
-            }
-          else
-            {
-              rotation_matrices = prm.get_vector<std::array<std::array<double,3>,3> >("rotation matrices");
-            }
-
-          operation = prm.get<std::string>("orientation operation");
-          grain_sizes = prm.get_vector<double>("grain sizes");
-
-
-          WBAssertThrow(compositions.size() == rotation_matrices.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and rotation_matrices (" << rotation_matrices.size() << ").");
-          WBAssertThrow(compositions.size() == grain_sizes.size(),
-                        "There are not the same amount of compositions (" << compositions.size()
-                        << ") and grain_sizes (" << grain_sizes.size() << ").");
-        }
-
-
-        WorldBuilder::grains
-        Uniform::get_grains(const Point<3> & /*position_in_cartesian_coordinates*/,
-                            const double /*depth*/,
-                            const unsigned int composition_number,
-                            WorldBuilder::grains grains_,
-                            const double /*feature_min_depth*/,
-                            const double /*feature_max_depth*/,
-                            const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                            const AdditionalParameters & /*additional_parameters*/) const
-        {
-          WorldBuilder::grains  grains_local = grains_;
-          if (distance_from_planes.distance_from_plane <= max_depth && distance_from_planes.distance_from_plane >= min_depth)
-            {
-              for (unsigned int i =0; i < compositions.size(); ++i)
-                {
-                  if (compositions[i] == composition_number)
-                    {
-                      std::fill(grains_local.rotation_matrices.begin(),grains_local.rotation_matrices.end(),rotation_matrices[i]);
-
-                      const double size = grain_sizes[i] < 0 ? 1.0/static_cast<double>(grains_local.sizes.size()) :  grain_sizes[i];
-                      std::fill(grains_local.sizes.begin(),grains_local.sizes.end(),size);
-
-                      return grains_local;
-                    }
-                }
-            }
-          return grains_local;
-        }
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_GRAINS_MODEL(Uniform, uniform)
-      } // namespace Grains
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/adiabatic.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/adiabatic.cc.bak
deleted file mode 100644
index 4bed92202a4..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/adiabatic.cc.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/temperature/adiabatic.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        Adiabatic::Adiabatic(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          potential_mantle_temperature(NaN::DSNAN),
-          thermal_expansion_coefficient(NaN::DSNAN),
-          specific_heat(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "adiabatic";
-        }
-
-        Adiabatic::~Adiabatic()
-          = default;
-
-        void
-        Adiabatic::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          prm.declare_entry("", Types::Object(),
-                            "Adiabatic temperature model. Uses global values by default.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "todo The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
-                            "todo The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("potential mantle temperature", Types::Double(-1),
-                            "The potential temperature of the mantle at the surface in Kelvin. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
-                            "The thermal expansion coefficient in $K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-          prm.declare_entry("specific heat", Types::Double(-1),
-                            "The specific heat in $J kg^{-1} K^{-1}$. "
-                            "If the value is lower then zero, the global value is used.");
-
-        }
-
-        void
-        Adiabatic::parse_entries(Parameters &prm)
-        {
-
-          min_depth = prm.get<double>("min distance slab top");
-          max_depth = prm.get<double>("max distance slab top");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          potential_mantle_temperature = prm.get<double>("potential mantle temperature");
-          if (potential_mantle_temperature < 0)
-            potential_mantle_temperature =  this->world->potential_mantle_temperature;
-
-
-          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
-          if (thermal_expansion_coefficient < 0)
-            thermal_expansion_coefficient =  this->world->thermal_expansion_coefficient;
-
-          specific_heat = prm.get<double>("specific heat");
-          if (specific_heat < 0)
-            specific_heat =  this->world->specific_heat;
-
-          // Some assertions in debug mode can't hurt and have helped before.
-          WBAssert(!std::isnan(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a number: " << potential_mantle_temperature << '.');
-          WBAssert(std::isfinite(potential_mantle_temperature),
-                   "potential_mantle_temperature is not a finite: " << potential_mantle_temperature << '.');
-
-          WBAssert(!std::isnan(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a number: " << thermal_expansion_coefficient << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "thermal_expansion_coefficient is not a finite: " << thermal_expansion_coefficient << '.');
-
-          WBAssert(!std::isnan(specific_heat),
-                   "specific_heat is not a number: " << specific_heat << '.');
-          WBAssert(std::isfinite(thermal_expansion_coefficient),
-                   "specific_heat is not a finite: " << specific_heat << '.');
-
-        }
-
-
-        double
-        Adiabatic::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                   const double depth,
-                                   const double gravity_norm,
-                                   double temperature_,
-                                   const double  /*feature_min_depth*/,
-                                   const double  /*feature_max_depth*/,
-                                   const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                   const AdditionalParameters & /*additional_parameters*/) const
-        {
-
-          const double distance_from_plane = distance_from_planes.distance_from_plane;
-          if (distance_from_plane <= max_depth && distance_from_plane >= min_depth)
-            {
-              const double adabatic_temperature = potential_mantle_temperature *
-                                                  std::exp(((thermal_expansion_coefficient * gravity_norm) /
-                                                            specific_heat) * depth);
-
-
-              WBAssert(!std::isnan(adabatic_temperature),
-                       "adabatic_temperature is not a number: " << adabatic_temperature << ". "
-                       <<"Parameters: potential_mantle_temperature = " << potential_mantle_temperature
-                       <<", thermal_expansion_coefficient = " << thermal_expansion_coefficient
-                       << ", gravity_norm = " << gravity_norm
-                       << ", specific_heat = " << specific_heat
-                       << ", depth = " << depth);
-
-              WBAssert(std::isfinite(adabatic_temperature),
-                       "adabatic_temperature is not a finite: " << adabatic_temperature << '.');
-
-              return apply_operation(operation,temperature_,adabatic_temperature);
-            }
-
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(Adiabatic, adiabatic)
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/interface.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/interface.cc.bak
deleted file mode 100644
index ada29a76574..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/interface.cc.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/temperature/interface.h"
-
-#include <algorithm>
-
-#include "world_builder/types/string.h"
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        Interface::Interface()
-          = default;
-
-        Interface::~Interface ()
-          = default;
-
-        void
-        Interface::declare_entries(Parameters &prm,
-                                   const std::string &parent_name,
-                                   const std::vector<std::string> &required_entries)
-        {
-          // The type needs to be stored in a separate value, otherwise there are memory issues
-          const Types::String type = Types::String("replace", std::vector<std::string> {"replace", "add", "subtract"});
-
-          prm.declare_model_entries("temperature",parent_name, get_declare_map(),required_entries,
-          {
-            std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string>
-            {
-              "operation", type,
-              "Whether the value should replace any value previously defined at this location (replace), "
-              "add the value to the previously define value (add) or subtract the value to the previously "
-              "define value (subtract)."
-            }
-          });
-        }
-
-
-        void
-        Interface::registerType(const std::string &name,
-                                void ( *declare_entries)(Parameters &, const std::string &),
-                                ObjectFactory *factory)
-        {
-          get_factory_map()[name] = factory;
-          get_declare_map()[name] = declare_entries;
-        }
-
-        std::unique_ptr<Interface>
-        Interface::create(const std::string &name, WorldBuilder::World *world)
-        {
-          std::string lower_case_name;
-          std::transform(name.begin(),
-                         name.end(),
-                         std::back_inserter(lower_case_name),
-                         ::tolower);;
-
-          // Have a nice assert message to check whether a plugin exists in the case
-          // of a debug compilation.
-          WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                        "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                        "The size of factories is " << get_factory_map().size() << '.');
-
-          // Using at() because the [] will just insert values
-          // which is undesirable in this case. An exception is
-          // thrown when the name is not present.
-          return get_factory_map().at(lower_case_name)->create(world);
-        }
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/linear.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/linear.cc.bak
deleted file mode 100644
index e4c6a70dce8..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/linear.cc.bak
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/temperature/linear.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        Linear::Linear(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          top_temperature(NaN::DSNAN),
-          bottom_temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "linear";
-        }
-
-        Linear::~Linear()
-          = default;
-
-        void
-        Linear::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `max distance slab top` center to the required parameters.
-          prm.declare_entry("", Types::Object({"max distance slab top"}),
-                            "Linear temperature model. Can be set to use an adiabatic temperature at the boundaries.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "todo The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
-                            "todo The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("top temperature", Types::Double(293.15),
-                            "The temperature at the top in degree Kelvin of this feature."
-                            "If the value is below zero, the an adiabatic temperature is used.");
-
-          prm.declare_entry("bottom temperature", Types::Double(-1),
-                            "The temperature at the bottom in degree Kelvin of this feature. "
-                            "If the value is below zero, an adiabatic temperature is used.");
-        }
-
-        void
-        Linear::parse_entries(Parameters &prm)
-        {
-          min_depth = prm.get<double>("min distance slab top");
-          max_depth = prm.get<double>("max distance slab top");
-          WBAssert(max_depth >= min_depth, "max depth needs to be larger or equal to min depth.");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          top_temperature = prm.get<double>("top temperature");
-          bottom_temperature = prm.get<double>("bottom temperature");
-        }
-
-
-        double
-        Linear::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                const double /*depth*/,
-                                const double gravity_norm,
-                                double temperature_,
-                                const double /*feature_min_depth*/,
-                                const double /*feature_max_depth*/,
-                                const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
-                                const AdditionalParameters & /*additional_parameters*/) const
-        {
-          if (distance_from_plane.distance_from_plane <= max_depth && distance_from_plane.distance_from_plane >= min_depth)
-            {
-              const double min_depth_local = min_depth;
-              const double max_depth_local = max_depth;
-
-
-              double top_temperature_local = top_temperature;
-              if (top_temperature_local < 0)
-                {
-                  top_temperature_local =  this->world->potential_mantle_temperature *
-                                           std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                     this->world->specific_heat) * min_depth_local);
-                }
-
-              double bottom_temperature_local = bottom_temperature;
-              if (bottom_temperature_local < 0)
-                {
-                  bottom_temperature_local =  this->world->potential_mantle_temperature *
-                                              std::exp(((this->world->thermal_expansion_coefficient * gravity_norm) /
-                                                        this->world->specific_heat) * max_depth_local);
-                }
-
-              const double new_temperature = top_temperature_local +
-                                             (distance_from_plane.distance_from_plane - min_depth_local) *
-                                             ((bottom_temperature_local - top_temperature_local) / (max_depth_local - min_depth_local));
-              return apply_operation(operation,temperature_,new_temperature);
-
-
-            }
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(Linear, linear)
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/mass_conserving.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/mass_conserving.cc.bak
deleted file mode 100644
index f2ad576c5c2..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/mass_conserving.cc.bak
+++ /dev/null
@@ -1,639 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-   Note that the empirical model used to define how Tmin increases with depth
-   and how the position of Tmin shift with depth is expected to change somewhat
-   after better calibrating with further tests.
-*/
-
-#include "world_builder/features/subducting_plate_models/temperature/mass_conserving.h"
-#include "world_builder/features/oceanic_plate_models/temperature/plate_model.h"
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/point.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-#include "world_builder/types/int.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        MassConserving::MassConserving(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          density(NaN::DSNAN),
-          mantle_coupling_depth(NaN::DSNAN),
-          forearc_cooling_factor(NaN::DSNAN),
-          thermal_conductivity(NaN::DSNAN),
-          thermal_expansion_coefficient(NaN::DSNAN),
-          specific_heat(NaN::DSNAN),
-          thermal_diffusivity(NaN::DSNAN),
-          potential_mantle_temperature(NaN::DSNAN),
-          surface_temperature(NaN::DSNAN),
-          taper_distance(NaN::DSNAN),
-          adiabatic_heating(true),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "mass conserving";
-        }
-
-        MassConserving::~MassConserving() = default;
-
-        void
-        MassConserving::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `plate velocity` to the required parameters.
-          prm.declare_entry("", Types::Object({"plate velocity"}),
-                            "Mass conserving temperature model. The temperature "
-                            "model uses the heat content (proportional to to thermal mass anomaly) to "
-                            "define a smooth temperature profile that conserves mass along the slab length. "
-                            "An empirical model, using error functions for smooth transitions, is used to "
-                            " define how the minimum temperature increases with depth and how the location of "
-                            "the minimum temperature shifts into the slab interior. The slab is divided into top "
-                            "and bottom parts, which meet at the location where the minimum temperature occurs in the slab. "
-                            "For the bottom slab, the temperature is defined by a half-space cooling model. "
-                            "For the top of the slab the temperature is defined by one side of a 1D infinite "
-                            "space cooling model: this function was chosen to have a smoother temperature function across "
-                            "the minimum temperature position. The age of the overriding plate is used so the slab temperature "
-                            "at shallow depth smoothly transitions to the temperature of the overriding plate: "
-                            "this is not perfect, and is affected by the value of \"top truncation\" parameter "
-                            "subducting plate. Notes:"
-                            "1) the parameter \"thickness\" for the subducting plate segments needs to be defined but is not used. "
-                            "2) because we use a negative truncation for distance above the slab, it is recommended to use"
-                            "depth method:begin at end segment, in the main part of the world-builder file."
-                            "Other methods may lead to gpas in temperatures at the segment boundaries."
-                            "3)the empirical model used to define how Tmin increases with depth "
-                            "and how the position of Tmin shift with depth is expected to change somewhat "
-                            "after better calibrating with further tests.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "The distance in meters from the top surface of the slab over which the temperature is "
-                            "determined by this feature. This parameter should be negative and should be 1.5-2 times "
-                            "larger than the nominal slab thickness to allow the diffusion of cold "
-                            "temperatures from in the slab into the mantle above the slab surface. "
-                            "Also note that the top truncation value for the slab segment needs to have a value "
-                            "of -1, otherwise the temperature above the slab will be cut off at a distance less than "
-                            "the value set here.");
-
-          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
-                            "The distance in meters from the top surface of the slab over which the temperature is "
-                            "determined by this feature. This parameter should be positive and approximately 2.5-3.0 times "
-                            "larger than the nominal slab thickness to allow the diffusion of cold"
-                            "temperatures from in the slab into the mantle below the slab surface."
-                            "For example if the slab starts with cold temperatures over a 100 km wide region, this"
-                            "parameters should be about 250 km.");
-
-          prm.declare_entry("density", Types::Double(3300),
-                            "The reference density of the subducting plate in $kg/m^3$");
-
-          prm.declare_entry("plate velocity", Types::OneOf(Types::Double(0.05),Types::Array(Types::ValueAtPoints(0.05, std::numeric_limits<uint64_t>::max()))),
-                            "The velocity with which the plate subducts in meters per year. Default is 5 cm/yr");
-
-          prm.declare_entry("subducting velocity", Types::OneOf(Types::Double(-1), Types::Array(Types::Array(Types::Double(-1), 1), 1)),
-                            "The velocity with which the ridge is moving through time, and how long the ridge "
-                            "has been moving. First value is the velocity, second is the time. Default is [0 cm/yr, 0 yr]");
-
-          prm.declare_entry("coupling depth", Types::Double(100e3),
-                            "The depth at which the slab surface first comes in contact with the hot mantle wedge "
-                            "in meters. Default is 100 km.");
-
-          prm.declare_entry("forearc cooling factor", Types::Double(1.0),
-                            "Increase the value to create thin (~2 km) cold thermal boundary layer above the slab."
-                            "Any value greater than 1 does NOT meet the instantaneous conservation of mass, but does allow "
-                            "one to account for the history of insulating the forearc from heating up to this point in time. "
-                            "Note younger subducting lithosphere provides less insulation, while thicker, older slabs "
-                            "provide more insulation. Values up to 10 to 30 have been tested and don't cause any other "
-                            "extraneous effects. The larger th value the more you are not meeting the mass conserving criteria, "
-                            "so you don't want to see this affecting the temperature beyond the coupling depth as it will "
-                            "increase the mass of the slab and affect how it sinks.  If you use higher values, you will start to "
-                            "see that this creates a very thick cool layer above the entire slab - if you see this extending beyond "
-                            "the coupling zone reduce the value. You should use a value of 1 first and then "
-                            "only increase as little as possible to cool just the forearc region. "
-                            "Please examine the output temperature carefully. ");
-
-          prm.declare_entry("thermal conductivity", Types::Double(3.3),
-                            "The thermal conductivity of the subducting plate material in $W m^{-1} K^{-1}$.");
-
-          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
-                            "The thermal expansivity of the subducting plate material in $K^{-1}$. If smaller than zero, the global value is used.");
-
-          prm.declare_entry("specific heat", Types::Double(-1),
-                            "The specific heat of the subducting plate material in $J kg^{-1} K^{-1}$. If smaller than zero, the global value is used.");
-
-          prm.declare_entry("thermal diffusivity", Types::Double(-1),
-                            "The thermal conductivity of the subducting plate material in $W m^{-1} K^{-1}$.");
-
-          prm.declare_entry("adiabatic heating", Types::Bool(true),
-                            "Whether adiabatic heating should be used for the slab.");
-
-          prm.declare_entry("taper distance", Types::Double(100e3),
-                            "Distance over which to taper the slab tip."
-                            "tapers the initial heat content to zero and the minimum temperature to the background temperature.");
-
-          prm.declare_entry("potential mantle temperature", Types::Double(-1),
-                            "The potential temperature of the mantle at the surface in Kelvin. If smaller than zero, the global value is used.");
-
-          prm.declare_entry("ridge coordinates", Types::Array(Types::Array(Types::Point<2>(), 2),1),
-                            "An list of ridges. Each ridge is a lists of at least 2 2d points which "
-                            "define the location of the ridge. You need to define at least one ridge."
-                            "So the an example with two ridges is "
-                            "[[[10,20],[20,30],[10,40]],[[50,10],[60,10]]].");
-
-          prm.declare_entry("reference model name",  Types::String("half space model"),
-                            "The type of thermal model to use in the mass conserving model of slab temperature. "
-                            "Options are half space model and plate model");
-
-          prm.declare_entry("apply spline",  Types::Bool(false),
-                            "Whether a spline should be applied on the mass conserving model.");
-
-          prm.declare_entry("number of points in spline", Types::UnsignedInt(5),
-                            "The number of points in the spline");
-
-        }
-
-        void
-        MassConserving::parse_entries(Parameters &prm)
-        {
-
-          min_depth = prm.get<double>("min distance slab top");
-          max_depth = prm.get<double>("max distance slab top");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          density = prm.get<double>("density");
-          thermal_conductivity = prm.get<double>("thermal conductivity");
-          ridge_spreading_velocities = prm.get_value_at_array("plate velocity");
-          subducting_velocities = prm.get_vector_or_double("subducting velocity");
-
-          mantle_coupling_depth = prm.get<double>("coupling depth");
-          forearc_cooling_factor = prm.get<double>("forearc cooling factor");
-
-          taper_distance = prm.get<double>("taper distance");
-
-          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
-          if (thermal_expansion_coefficient < 0)
-            thermal_expansion_coefficient = this->world->thermal_expansion_coefficient;
-
-          specific_heat = prm.get<double>("specific heat");
-          if (specific_heat < 0)
-            specific_heat = this->world->specific_heat;
-
-          thermal_diffusivity = prm.get<double>("thermal diffusivity");
-          if (thermal_diffusivity < 0)
-            thermal_diffusivity = this->world->thermal_diffusivity;
-
-          adiabatic_heating = prm.get<bool>("adiabatic heating");
-
-          potential_mantle_temperature = this->world->potential_mantle_temperature >= 0
-                                         ?
-                                         this->world->potential_mantle_temperature
-                                         :
-                                         prm.get<double>("potential mantle temperature");
-
-          surface_temperature = this->world->surface_temperature;
-
-          mid_oceanic_ridges = prm.get_vector<std::vector<Point<2>>>("ridge coordinates");
-          const double dtr = prm.coordinate_system->natural_coordinate_system() == spherical ? Consts::PI / 180.0 : 1.0;
-          for (auto &ridge_coordinates : mid_oceanic_ridges)
-            for (auto &ridge_coordinate : ridge_coordinates)
-              {
-                ridge_coordinate *= dtr;
-              }
-
-          unsigned int ridge_point_index = 0;
-          for (const auto &mid_oceanic_ridge : mid_oceanic_ridges)
-            {
-              std::vector<double> ridge_spreading_velocities_for_ridge;
-              for (unsigned int index_y = 0; index_y < mid_oceanic_ridge.size(); index_y++)
-                {
-                  if (ridge_spreading_velocities.second.size() == 1)
-                    {
-                      ridge_spreading_velocities_for_ridge.push_back(ridge_spreading_velocities.second[0]);
-                    }
-                  else
-                    {
-                      ridge_spreading_velocities_for_ridge.push_back(ridge_spreading_velocities.second[ridge_point_index]);
-                    }
-                  ridge_point_index += 1;
-                }
-              ridge_spreading_velocities_at_each_ridge_point.push_back(ridge_spreading_velocities_for_ridge);
-            }
-
-          std::string reference_model_name_str = prm.get<std::string>("reference model name");
-          if (reference_model_name_str=="plate model")
-            reference_model_name = plate_model;
-          else if (reference_model_name_str=="half space model")
-            reference_model_name = half_space_model;
-
-          apply_spline = prm.get<bool>("apply spline");
-          spline_n_points = prm.get<unsigned int>("number of points in spline");
-
-          if (subducting_velocities[0].size() > 1)
-            {
-              for (unsigned int ridge_index = 0; ridge_index < mid_oceanic_ridges.size(); ridge_index++)
-                {
-                  WBAssertThrow(subducting_velocities.size() == mid_oceanic_ridges.size() &&
-                                subducting_velocities[ridge_index].size() == mid_oceanic_ridges[ridge_index].size(),
-                                "subducting velocity must have the same dimension as the ridge coordinates parameter.");
-                  for (unsigned int point_index = 0; point_index < mid_oceanic_ridges[ridge_index].size(); point_index++)
-                    {
-                      WBAssertThrow(Utilities::approx(subducting_velocities[ridge_index][point_index],
-                                                      ridge_spreading_velocities_at_each_ridge_point[ridge_index][point_index]),
-                                    "Currently, subducting velocity must equal the spreading velocity to satisfy conservation of mass. "
-                                    "This will be changed in the future to allow for the spreading center to move depending on the relative "
-                                    "difference between the spreading velocity and the subducting velocity, thereby conserving mass.");
-                    }
-                }
-            }
-        }
-
-        double
-        MassConserving::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                        const double depth,
-                                        const double gravity_norm,
-                                        double temperature_,
-                                        const double /*feature_min_depth*/,
-                                        const double /*feature_max_depth*/,
-                                        const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                        const AdditionalParameters &additional_parameters) const
-        {
-
-          const double distance_from_plane = distance_from_planes.distance_from_plane;
-
-          if (distance_from_plane <= max_depth && distance_from_plane >= min_depth)
-            {
-
-              const Point<3> trench_point = distance_from_planes.closest_trench_point;
-              const Objects::NaturalCoordinate trench_point_natural = Objects::NaturalCoordinate(trench_point,
-                                                                      *(world->parameters.coordinate_system));
-
-              std::vector<double> ridge_parameters = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                                     ridge_spreading_velocities_at_each_ridge_point,
-                                                     world->parameters.coordinate_system,
-                                                     trench_point_natural,
-                                                     subducting_velocities,
-                                                     ridge_spreading_velocities.first);
-
-              constexpr double km2m = 1.0e3; // 1000 m/km
-              constexpr double cm2m = 100; // 100 cm/m
-              constexpr double my = 1.0e6;  // 1e6 y/my
-
-              /* information about nearest point on the slab segment */
-              const double distance_along_plane = distance_from_planes.distance_along_plane;
-              const double depth_to_reference_surface = distance_from_planes.depth_reference_surface;
-              const double total_segment_length = additional_parameters.total_local_segment_length;
-              const double average_angle = distance_from_planes.average_angle;
-
-              std::vector<double> slab_ages = calculate_effective_trench_and_plate_ages(ridge_parameters, distance_along_plane);
-
-              const double seconds_in_year = 60.0 * 60.0 * 24.0 * 365.25;  // sec/y
-              const double spreading_velocity = ridge_parameters[0] * seconds_in_year; // m/yr
-              double subducting_velocity = ridge_parameters[2] * seconds_in_year; // m/yr
-
-              if (subducting_velocity <= 0)
-                subducting_velocity = spreading_velocity;
-
-              const double age_at_trench = slab_ages[0];
-              const double plate_age_sec = age_at_trench * seconds_in_year; // y --> seconds
-              // 1. Determine initial heat content of the slab based on age of plate at trench
-              // This uses the integral of the half-space temperature profile
-              // The initial heat content is also decided from the type of thermal model to use in the
-              // mass conserving model
-              double initial_heat_content;
-              if (reference_model_name == plate_model)
-                {
-                  initial_heat_content = thermal_conductivity / thermal_diffusivity *
-                                         (surface_temperature - potential_mantle_temperature) * max_depth / 2.0;
-                  for (int i = 0; i< std::floor(plate_model_summation_number/2.0); ++i)
-                    {
-                      // because n < sommation_number + 1 and n = 2k + 1
-                      // The "spreading_velocity" instead of "spreading_velocity_UI" is used for the last instance as "age_at_trench" has
-                      // a unit of yr.
-                      const double subducting_velocity_UI = subducting_velocity / seconds_in_year;
-                      const double temp_heat_content = thermal_conductivity / thermal_diffusivity *
-                                                       (surface_temperature - potential_mantle_temperature) *
-                                                       4 * max_depth / double(2*i + 1) / double(2*i + 1) / Consts::PI / Consts::PI *
-                                                       exp((subducting_velocity_UI * max_depth / 2 / thermal_diffusivity -
-                                                            std::sqrt(subducting_velocity_UI * subducting_velocity_UI * max_depth * max_depth / 4.0 / thermal_diffusivity / thermal_diffusivity +
-                                                                      double(2*i + 1) * double(2*i + 1) * Consts::PI * Consts::PI)) *
-                                                           subducting_velocity * age_at_trench / max_depth);
-                      initial_heat_content -= temp_heat_content;
-                    }
-                }
-              else
-                {
-                  initial_heat_content = 2 * thermal_conductivity * (surface_temperature - potential_mantle_temperature) *
-                                         std::sqrt(plate_age_sec / (thermal_diffusivity * Consts::PI));
-                }
-
-              // Plate age increases with distance along the slab in the mantle
-              double effective_plate_age = slab_ages[1];
-
-              // Need adiabatic temperature at position of grid point
-              const double background_temperature = adiabatic_heating ? potential_mantle_temperature *
-                                                    std::exp(thermal_expansion_coefficient * gravity_norm * depth / specific_heat)
-                                                    : potential_mantle_temperature;
-
-              WBAssert(!std::isnan(background_temperature), "Internal error: temp is not a number: " << background_temperature << ". In exponent: "
-                       << std::exp(((thermal_expansion_coefficient * gravity_norm) / specific_heat) * depth)
-                       << ", thermal_expansion_coefficient = " << thermal_expansion_coefficient << ", gravity_norm = " << gravity_norm
-                       << ", specific_heat = " << specific_heat << ", depth = " << depth);
-
-              const double adiabatic_gradient = adiabatic_heating ? background_temperature - potential_mantle_temperature : 0;
-
-              //  2. Get Tmin and offset as a function of depth: these depend on plate velocity and plate age_at_trench.
-              //     shallow-dipping slabs will take longer to reach the same depth - this leads to larger effective age at a given depth
-              //     causing these slabs to be broader than steeper dipping slabs
-              //     These equations are empirical based on fitting the temperature profiles from dynamic subduction models.
-              //     and published kinematic models for specific subduction zones.
-
-              // increases Tmin slope for slower relative to slope for maximum plate velocity
-              // will be between 0.1 (fast) and 0.35 (slow)
-              const double max_plate_vel = 20/cm2m;  // e.g., 20 cm/yr -> 0.2 m/yr
-              const double vsubfact = std::min( std::max( 0.35 + ((0.1-0.35) / max_plate_vel) * subducting_velocity, 0.1), 0.35);
-
-              // increases Tmin slope for younger plate relative to slope for old place
-              // will be between 0.1 (old) and 0.35 *(young)
-              const double max_plate_age = 100*my; // years
-              const double max_age_fact = 1.0;
-              const double agefact = std::min( std::max( max_age_fact + ((0.1-max_age_fact) / max_plate_age) * age_at_trench, 0.1), max_age_fact);
-
-              // increases offset  relative to slab surface for older plates
-              // will be between 0.1 (young) and 0.35 (old)
-              const double agefact2 = std::max( std::min( 0.1 + ((0.35-0.1) / max_plate_age) * age_at_trench, 0.35), 0.1);
-
-              // ranges between 0.5 (old and fast) and 1.0 (young and slow)
-              const double subfact = 0.3 + vsubfact + agefact;  // this has a minimum value of 0.5 for the erfc
-              // ranges between 0.5 (young and fast) and 1 (old and slow)
-              const double subfact2 = 0.3 + vsubfact + agefact2;
-
-              // Minimum Temperature
-              const double min_Tcoup = 10; // 0.3*mantle_coupling_depth/km2m; // deg C: from 0.3deg/km * 100 km = 30 deg
-              const double max_Tcoup = 350; // deg C: from Cascadia subduction models by Gao and Wang, Gcubd 2017
-              const double Tcoup = min_Tcoup + (subfact - 0.5)*(max_Tcoup - min_Tcoup);
-
-              const double min_Tmin660 = 300; //110; // based on syracruse models (with 0.5 deg/km adiabat; (265-30)-0.5*240)
-              const double max_Tmin660 = 900;
-              const double Tmin660 =  min_Tmin660 + (subfact - 0.5)*(max_Tmin660 - min_Tmin660);
-
-              // Temperature offset
-              const double min_offset_coup = 2*km2m;  // values from syracuse and time-dep Citcom run
-              const double max_offset_coup = 10*km2m;
-              const double offset_coup = min_offset_coup + (subfact2)*(max_offset_coup - min_offset_coup);
-
-              const double min_offset660 = 15*km2m;  // values from time-dep Citcom run
-              const double max_offset660 = 25*km2m;
-              const double offset660 =  min_offset660 + (subfact2)*(max_offset660 - min_offset660);
-
-              // For tapering the slab tip temperature to the mantle temperature
-              const double start_taper_distance = total_segment_length - taper_distance;
-
-              const double upper_mantle_lengthscale = 660e3 - mantle_coupling_depth; // m
-
-
-              const double taper_con = 0.8;  // controls how close taper gets to end of segment
-              double theta = 0;
-              double min_temperature = 0;
-              double offset = 0;
-
-              if (depth_to_reference_surface < mantle_coupling_depth)
-                {
-                  // above coupling depth
-                  theta = (mantle_coupling_depth - depth_to_reference_surface) / (subfact * mantle_coupling_depth); // must be scaled depth_coupling to match Tcoup ad Tsurface.
-                  min_temperature = Tcoup * std::erfc(theta);
-                  offset = offset_coup * std::erfc(theta);
-                }
-              else if (distance_along_plane >= start_taper_distance)
-                {
-                  // beyond start taper distance to taper the slab tip
-
-                  const double depth_start_taper = depth_to_reference_surface - (distance_along_plane - start_taper_distance)
-                                                   * std::sin(average_angle * Consts::PI / 180.0);
-                  const double theta_start = (mantle_coupling_depth - depth_start_taper) / (subfact * upper_mantle_lengthscale);
-                  const double Tmin_start_taper = Tcoup + Tmin660 * (std::erfc(theta_start)) - Tmin660;
-                  //keep the offset location constant in the taper
-                  const double offset_start_taper = offset_coup + (offset660) * std::erfc(theta_start) - offset660;
-
-                  // taper Tmin to the mantle temperature
-                  theta = (distance_along_plane - start_taper_distance) / (taper_distance);
-                  min_temperature =  Tmin_start_taper + (potential_mantle_temperature - Tmin_start_taper) * (1-std::erfc(taper_con*theta));
-                  offset =  offset_start_taper + (2*max_offset660 - offset_start_taper) * (1-std::erfc(taper_con*theta));
-
-                  // Also taper the initial heat content and effective plate age
-                  initial_heat_content = initial_heat_content * std::erfc(1.5*taper_con*theta);
-                  effective_plate_age = effective_plate_age * std::erfc(1.5*taper_con*theta);
-                }
-
-              else
-                {
-                  theta = (mantle_coupling_depth - depth_to_reference_surface) / (subfact * upper_mantle_lengthscale);
-                  min_temperature = Tcoup + Tmin660 * std::erfc(theta) - Tmin660;
-                  offset = offset_coup + offset660 * std::erfc(theta) - offset660;
-                }
-
-              min_temperature = min_temperature + adiabatic_gradient + surface_temperature;
-
-              // Adjust distance for the offset of the minimum temperature from the top of the slab
-              const double adjusted_distance = distance_from_plane - offset;
-
-              // Base value chosen to insure that even young slabs have some cooling of the top of the slab
-              // Use forearc_cooling_factor input variable to increase the amount of long-term cooling of the forearc.
-              const double max_top_heat_content = -1.0e9 * forearc_cooling_factor * background_temperature; // need to multiply by background temperature  since it gets divided by something of this scale.
-
-              double temperature = 0.0;  // temperature (to be determined) at this location in the mesh
-
-              if (min_temperature < background_temperature)
-                {
-
-                  // 3. Determine the heat content for side 1 (bottom) of the slab
-                  // Comes from integrating the half-space cooling model or the plate model temperature
-                  // The bottom heat content is also decided from the type of thermal model to use in the
-                  // mass conserving model
-                  double bottom_heat_content;
-                  if (reference_model_name == plate_model)
-                    {
-                      bottom_heat_content = thermal_conductivity / thermal_diffusivity *
-                                            (min_temperature - potential_mantle_temperature) * max_depth / 2.0;
-                      for (int i = 0; i< std::floor(plate_model_summation_number/2.0); ++i)
-                        {
-                          // because n < sommation_number + 1 and n = 2k + 1
-                          const double subducting_velocity_UI = subducting_velocity / seconds_in_year;
-                          const double temp_heat_content = thermal_conductivity / thermal_diffusivity *
-                                                           (min_temperature - potential_mantle_temperature) *
-                                                           4 * max_depth / double(2*i + 1) / double(2*i + 1) / Consts::PI / Consts::PI *
-                                                           exp((subducting_velocity_UI * max_depth / 2.0 / thermal_diffusivity -
-                                                                std::sqrt(subducting_velocity_UI * subducting_velocity_UI * max_depth * max_depth / 4.0 / thermal_diffusivity / thermal_diffusivity +
-                                                                          double(2*i + 1) * double(2*i + 1) * Consts::PI * Consts::PI)) *
-                                                               subducting_velocity_UI * effective_plate_age / max_depth);
-                          bottom_heat_content -= temp_heat_content;
-                        }
-                    }
-                  else
-                    {
-                      bottom_heat_content = 2 * thermal_conductivity * (min_temperature - potential_mantle_temperature) *
-                                            std::sqrt(effective_plate_age /(thermal_diffusivity * Consts::PI));
-                    }
-
-                  // 4. The difference in heat content goes into the temperature above where Tmin occurs.
-                  // Should not be a positive value
-                  //double top_heat_content = initial_heat_content - bottom_heat_content;
-
-                  double top_heat_content =  std::min(max_top_heat_content, (initial_heat_content - bottom_heat_content) );
-
-                  // Also need to taper the top_heat_content otherwise slab top will continue to thicken to the tip.
-                  // Can't do this above because need min_temperature to get bottom_heat_content first
-                  if (distance_along_plane > start_taper_distance)
-                    {
-                      top_heat_content = top_heat_content * std::erfc(taper_con*theta);
-                    }
-
-                  double nondimensional_adjusted_distance = adjusted_distance / max_depth;
-
-                  if (apply_spline)
-                    {
-                      // A total number of (2 * spline_n_points + 1) points are picked,
-                      // spline_n_points points on each side and one at the center.
-                      // These points cover a range of (-1.0, 1.0) in adjusted_distance.
-                      Utilities::interpolation monotone_cubic_spline;
-
-                      const double interval_spline_distance = 1.0 / spline_n_points;
-                      std::vector<double> i_temperatures (2*(spline_n_points + 1), 0.0);
-
-                      for (size_t i = 0; i < 2 * spline_n_points + 1; ++i)
-                        {
-                          const double i_adjusted_distance = (static_cast<double>(i) * interval_spline_distance - 1.0) * max_depth;
-                          const double i_temperature = get_temperature_analytic(top_heat_content, min_temperature, background_temperature, temperature_, spreading_velocity, effective_plate_age, i_adjusted_distance);
-                          i_temperatures[i] = i_temperature;
-                        }
-
-                      monotone_cubic_spline.set_points(i_temperatures);
-
-                      const double index_distance = (nondimensional_adjusted_distance + 1.0) / interval_spline_distance;
-                      temperature =  monotone_cubic_spline(index_distance);
-                    }
-                  else
-                    {
-                      // Call the analytic solution to compute the temperature
-                      temperature = get_temperature_analytic(top_heat_content, min_temperature, background_temperature, temperature_, spreading_velocity, effective_plate_age, adjusted_distance);
-                    }
-                }
-              else
-                {
-                  // slab temperature anomaly is gone.
-                  temperature = temperature_;
-                }
-
-              WBAssert(!std::isnan(temperature), "Internal error: temperature is not a number: " << temperature << '.');
-              WBAssert(std::isfinite(temperature), "Internal error: temperature is not finite: " << temperature << '.');
-
-              return apply_operation(operation, temperature_, temperature);
-            }
-
-          return temperature_;
-        }
-
-        double
-        MassConserving::get_temperature_analytic(const double top_heat_content,
-                                                 const double min_temperature,
-                                                 const double background_temperature,
-                                                 const double temperature_,
-                                                 const double subducting_velocity,
-                                                 const double effective_plate_age,
-                                                 const double adjusted_distance) const
-        {
-          const double seconds_in_year = 60.0 * 60.0 * 24.0 * 365.25;  // sec/y
-
-          double temperature = 0.0;
-
-          // Assign the temperature depending on whether distance is negative (above) or positive (below) the slab
-          if (adjusted_distance < 0)
-            {
-              // use 1D infinite space solution for top (side 2) of slab the slab
-              // 2 times the "top_heat_content" because all this heat needs to be on one side of the Gaussian
-              const double time_top_slab = (1/(Consts::PI*thermal_diffusivity)) *
-                                           pow(((2 * top_heat_content) / (2 * density * specific_heat * (min_temperature - temperature_ + 1e-16))),2) + 1e-16;
-
-              // for overriding plate region where plate temperature is less the minimum slab temperature
-              // need to set temperature = temperature_ otherwise end up with temperature less than surface temperature ;
-              if (temperature_ < min_temperature)
-                {
-                  temperature = temperature_;
-                }
-              else
-                {
-                  temperature  = temperature_ + (2 * top_heat_content /
-                                                 (2*density*specific_heat * std::sqrt(Consts::PI * thermal_diffusivity * time_top_slab)))*
-                                 std::exp(-(adjusted_distance*adjusted_distance)/(4*thermal_diffusivity*time_top_slab));
-                }
-            }
-          else
-            {
-              // use half-space cooling or plate model for the bottom (side 1) of the slab
-              if (reference_model_name == plate_model)
-                {
-                  if (adjusted_distance < max_depth)
-                    {
-                      const double subducting_velocity_UI = subducting_velocity / seconds_in_year;
-                      temperature = background_temperature + (min_temperature - background_temperature) * (1 - adjusted_distance / max_depth);
-                      for (int i = 1; i< std::floor(plate_model_summation_number/2.0); ++i)
-                        {
-                          temperature = temperature - (min_temperature - background_temperature) *
-                                        ((2 / (double(i) * Consts::PI)) * std::sin((double(i) * Consts::PI * adjusted_distance) / max_depth) *
-                                         std::exp((((subducting_velocity_UI * max_depth)/(2 * thermal_diffusivity)) -
-                                                   std::sqrt(((subducting_velocity_UI*subducting_velocity_UI*max_depth*max_depth) /
-                                                              (4*thermal_diffusivity*thermal_diffusivity)) + double(i) * double(i) * Consts::PI * Consts::PI)) *
-                                                  ((subducting_velocity_UI * effective_plate_age) / max_depth)));
-                        }
-                    }
-                  else
-                    {
-                      temperature = background_temperature;
-                    }
-                }
-              else
-                {
-                  temperature = background_temperature + (min_temperature - background_temperature) *
-                                std::erfc(adjusted_distance / (2 * std::sqrt(thermal_diffusivity * effective_plate_age)));
-
-                }
-            }
-          return temperature;
-        }
-
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(MassConserving, mass conserving)
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/plate_model.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/plate_model.cc.bak
deleted file mode 100644
index 368adcdc09d..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/plate_model.cc.bak
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/temperature/plate_model.h"
-
-#include "world_builder/nan.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        PlateModel::PlateModel(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          density(NaN::DSNAN),
-          plate_velocity(NaN::DSNAN),
-          thermal_conductivity(NaN::DSNAN),
-          thermal_expansion_coefficient(NaN::DSNAN),
-          specific_heat(NaN::DSNAN),
-          potential_mantle_temperature(NaN::DSNAN),
-          surface_temperature(NaN::DSNAN),
-          adiabatic_heating(true),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "plate model";
-        }
-
-        PlateModel::~PlateModel()
-          = default;
-
-        void
-        PlateModel::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `plate velocity` to the required parameters.
-          prm.declare_entry("", Types::Object({"plate velocity"}),
-                            "Plate model (based on McKenzie, 1970).");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "todo The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
-                            "todo The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("density", Types::Double(3300),
-                            "The reference density of the subducting plate in $kg/m^3$");
-
-          prm.declare_entry("plate velocity", Types::Double(NaN::DQNAN),
-                            "The velocity in meters per year with which the plate subducts in meters per year.");
-
-          prm.declare_entry("thermal conductivity", Types::Double(2.0),
-                            "The thermal conductivity of the subducting plate material in $W m^{-1} K^{-1}$.");
-
-          prm.declare_entry("thermal expansion coefficient", Types::Double(-1),
-                            "The thermal expansivity of the subducting plate material in $K^{-1}$. If smaller than zero, the global value is used.");
-
-          prm.declare_entry("specific heat", Types::Double(-1),
-                            "The specific heat of the subducting plate material in $J kg^{-1} K^{-1}$. If smaller than zero, the global value is used.");
-
-          prm.declare_entry("adiabatic heating", Types::Bool(true),
-                            "Whether adiabatic heating should be used for the slab. Setting the parameter to false leads to equation 26 from McKenzie (1970),"
-                            "which is the result obtained from McKenzie 1969.");
-
-          prm.declare_entry("potential mantle temperature", Types::Double(-1),
-                            "The potential temperature of the mantle at the surface in Kelvin. If smaller than zero, the global value is used.");
-        }
-
-        void
-        PlateModel::parse_entries(Parameters &prm)
-        {
-
-          min_depth = prm.get<double>("min distance slab top");
-          max_depth = prm.get<double>("max distance slab top");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-
-          density = prm.get<double>("density");
-          plate_velocity = prm.get<double>("plate velocity");
-          thermal_conductivity = prm.get<double>("thermal conductivity");
-          thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
-
-          if (thermal_expansion_coefficient < 0 )
-            thermal_expansion_coefficient = this->world->thermal_expansion_coefficient;
-
-          specific_heat = prm.get<double>("specific heat");
-
-          if (specific_heat < 0)
-            specific_heat = this->world->specific_heat;
-
-          adiabatic_heating = prm.get<bool>("adiabatic heating");
-
-          potential_mantle_temperature = this->world->potential_mantle_temperature >= 0
-                                         ?
-                                         this->world->potential_mantle_temperature
-                                         :
-                                         prm.get<double>("potential mantle temperature");
-          surface_temperature = this->world->surface_temperature;
-        }
-
-
-        double
-        PlateModel::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                    const double depth,
-                                    const double gravity_norm,
-                                    double temperature_,
-                                    const double /*feature_min_depth*/,
-                                    const double /*feature_max_depth*/,
-                                    const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_planes,
-                                    const AdditionalParameters &additional_parameters) const
-        {
-          const double thickness_local = std::min(additional_parameters.local_thickness, max_depth);
-          const double distance_from_plane = distance_from_planes.distance_from_plane;
-          const double distance_along_plane = distance_from_planes.distance_along_plane;
-
-          if (distance_from_plane <= max_depth && distance_from_plane >= min_depth)
-            {
-              /*
-               * We now use the McKenzie (1970) equation to determine the
-               * temperature inside the slab. The McKenzie equation was
-               * designed for a straight slab, but we have a potentially
-               * curved slab. Since the angle is used to compute the depth
-               * of the point, we directly use the depth.
-               */
-              const double R = (density * specific_heat
-                                * (plate_velocity /(365.25 * 24.0 * 60.0 * 60.0))
-                                * thickness_local) / (2.0 * thermal_conductivity);
-
-              WBAssert(!std::isnan(R), "Internal error: R is not a number: " << R << '.');
-
-              const int n_sum = 500;
-              // distance_from_plane can be zero, so protect division.
-              const double z_scaled = 1 - (std::fabs(distance_from_plane) < 2.0 * std::numeric_limits<double>::epsilon() ?
-                                           2.0 * std::numeric_limits<double>::epsilon()
-                                           :
-                                           distance_from_plane/thickness_local);
-
-              // distance_along_plane can be zero, so protect division.
-              const double x_scaled = (std::fabs(distance_along_plane) < 2.0 * std::numeric_limits<double>::epsilon() ?
-                                       2.0 *std::numeric_limits<double>::epsilon()
-                                       :
-                                       distance_along_plane/thickness_local);
-
-              // the paper uses `(x_scaled * sin(average_angle) - z_scaled * cos(average_angle))` to compute the
-              // depth (execpt that you do not use average angles since they only have on angle). On recomputing
-              // their result it seems to me (Menno) that it should have been `(1-z_scaled)` instead of `z_scaled`.
-              // To avoid this whole problem we just use the depth directly since we have that.
-              // todo: get the local thickniss out of H, that prevents an other division.
-              // If we want to specify the bottom temperature, because we have defined a linear temperature increase in the
-              // mantle and/or oceanic plate, we have to switch off adiabatic heating for now.
-              // Todo: there may be a better way to deal with this.
-              ;
-              const double temp = adiabatic_heating ? std::exp(((thermal_expansion_coefficient * gravity_norm * depth) / specific_heat)) : 1;
-
-              WBAssert(!std::isnan(temp), "Internal error: temp is not a number: " << temp << ". In exponent: "
-                       << std::exp(((thermal_expansion_coefficient * gravity_norm) / specific_heat) * depth)
-                       << ", thermal_expansion_coefficient = " << thermal_expansion_coefficient << ", gravity_norm = " << gravity_norm
-                       << ", specific_heat = "<< specific_heat << ", depth = " << depth );
-
-              double sum=0;
-              for (int i=1; i<=n_sum; i++)
-                {
-                  sum += (std::pow((-1.0),i)/(i*Consts::PI)) *
-                         (exp((R - std::pow(R * R + i * i * Consts::PI * Consts::PI, 0.5)) * x_scaled))
-                         * (sin(i * Consts::PI * z_scaled));
-                }
-              // todo: investigate whether this 273.15 should just be the surface temperature.
-              const double temperature = temp * (potential_mantle_temperature
-                                                 + 2.0 * (potential_mantle_temperature - 273.15) * sum);
-
-              WBAssert(!std::isnan(temperature), "Internal error: temperature is not a number: " << temperature << '.');
-              WBAssert(std::isfinite(temperature), "Internal error: temperature is not finite: " << temperature << '.');
-
-
-              return apply_operation(operation,temperature_,temperature);
-            }
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(PlateModel, plate model)
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/uniform.cc.bak b/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/uniform.cc.bak
deleted file mode 100644
index aa9a904ee7e..00000000000
--- a/contrib/world_builder/source/world_builder/features/subducting_plate_models/temperature/uniform.cc.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/features/subducting_plate_models/temperature/uniform.h"
-
-
-#include "world_builder/nan.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/utilities.h"
-
-
-namespace WorldBuilder
-{
-
-  using namespace Utilities;
-
-  namespace Features
-  {
-    namespace SubductingPlateModels
-    {
-      namespace Temperature
-      {
-        Uniform::Uniform(WorldBuilder::World *world_)
-          :
-          min_depth(NaN::DSNAN),
-          max_depth(NaN::DSNAN),
-          temperature(NaN::DSNAN),
-          operation(Operations::REPLACE)
-        {
-          this->world = world_;
-          this->name = "uniform";
-        }
-
-        Uniform::~Uniform()
-          = default;
-
-        void
-        Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-        {
-          // Document plugin and require entries if needed.
-          // Add `temperature` and to the required parameters.
-          prm.declare_entry("", Types::Object({"temperature"}),
-                            "Uniform temperature model. Set the temperature to a constant value.");
-
-          // Declare entries of this plugin
-          prm.declare_entry("min distance slab top", Types::Double(0),
-                            "todo The depth in meters from which the composition of this feature is present.");
-
-          prm.declare_entry("max distance slab top", Types::Double(std::numeric_limits<double>::max()),
-                            "todo The depth in meters to which the composition of this feature is present.");
-
-          prm.declare_entry("temperature", Types::Double(293.15),
-                            "The temperature in degree Kelvin which this feature should have");
-
-        }
-
-        void
-        Uniform::parse_entries(Parameters &prm)
-        {
-
-          min_depth = prm.get<double>("min distance slab top");
-          max_depth = prm.get<double>("max distance slab top");
-          operation = string_operations_to_enum(prm.get<std::string>("operation"));
-          temperature = prm.get<double>("temperature");
-        }
-
-
-        double
-        Uniform::get_temperature(const Point<3> & /*position_in_cartesian_coordinates*/,
-                                 const double  /*depth*/,
-                                 const double  /*gravity*/,
-                                 double temperature_,
-                                 const double  /*feature_min_depth*/,
-                                 const double  /*feature_max_depth*/,
-                                 const WorldBuilder::Utilities::PointDistanceFromCurvedPlanes &distance_from_plane,
-                                 const AdditionalParameters & /*additional_parameters*/) const
-        {
-
-          if (distance_from_plane.distance_from_plane <= max_depth && distance_from_plane.distance_from_plane >= min_depth)
-            {
-              return apply_operation(operation,temperature_,temperature);
-            }
-
-          return temperature_;
-        }
-
-        WB_REGISTER_FEATURE_SUBDUCTING_PLATE_TEMPERATURE_MODEL(Uniform, uniform)
-      } // namespace Temperature
-    } // namespace SubductingPlateModels
-  } // namespace Features
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/grains.cc.bak b/contrib/world_builder/source/world_builder/grains.cc.bak
deleted file mode 100644
index b9e06ad2cde..00000000000
--- a/contrib/world_builder/source/world_builder/grains.cc.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/grains.h"
-
-namespace WorldBuilder
-{
-
-  grains::grains()
-
-
-    = default;
-
-
-  grains::grains(const std::vector<double> &vector,
-                 const size_t number_of_grains,
-                 const size_t start_entry)
-  {
-    sizes.resize(number_of_grains);
-    for (unsigned int i_grain = 0; i_grain < number_of_grains; i_grain++)
-      {
-        sizes[i_grain] = vector[start_entry+i_grain];
-      }
-
-    rotation_matrices.resize(number_of_grains);
-    for (unsigned int i_grain = 0; i_grain < number_of_grains; i_grain++)
-      {
-        rotation_matrices[i_grain][0][0] = vector[start_entry+number_of_grains+i_grain*9];
-        rotation_matrices[i_grain][0][1] = vector[start_entry+number_of_grains+i_grain*9+1];
-        rotation_matrices[i_grain][0][2] = vector[start_entry+number_of_grains+i_grain*9+2];
-        rotation_matrices[i_grain][1][0] = vector[start_entry+number_of_grains+i_grain*9+3];
-        rotation_matrices[i_grain][1][1] = vector[start_entry+number_of_grains+i_grain*9+4];
-        rotation_matrices[i_grain][1][2] = vector[start_entry+number_of_grains+i_grain*9+5];
-        rotation_matrices[i_grain][2][0] = vector[start_entry+number_of_grains+i_grain*9+6];
-        rotation_matrices[i_grain][2][1] = vector[start_entry+number_of_grains+i_grain*9+7];
-        rotation_matrices[i_grain][2][2] = vector[start_entry+number_of_grains+i_grain*9+8];
-      }
-  }
-
-
-  void
-  grains::unroll_into(std::vector<double> &vector, const size_t start_entry) const
-  {
-    const size_t number_of_grains = sizes.size();
-
-    for (unsigned int i_grain = 0; i_grain < number_of_grains; i_grain++)
-      {
-        vector[start_entry+i_grain] = sizes[i_grain];
-      }
-
-    for (unsigned int i_grain = 0; i_grain < number_of_grains; i_grain++)
-      {
-        vector[start_entry+number_of_grains+i_grain*9]   = rotation_matrices[i_grain][0][0];
-        vector[start_entry+number_of_grains+i_grain*9+1] = rotation_matrices[i_grain][0][1];
-        vector[start_entry+number_of_grains+i_grain*9+2] = rotation_matrices[i_grain][0][2];
-        vector[start_entry+number_of_grains+i_grain*9+3] = rotation_matrices[i_grain][1][0];
-        vector[start_entry+number_of_grains+i_grain*9+4] = rotation_matrices[i_grain][1][1];
-        vector[start_entry+number_of_grains+i_grain*9+5] = rotation_matrices[i_grain][1][2];
-        vector[start_entry+number_of_grains+i_grain*9+6] = rotation_matrices[i_grain][2][0];
-        vector[start_entry+number_of_grains+i_grain*9+7] = rotation_matrices[i_grain][2][1];
-        vector[start_entry+number_of_grains+i_grain*9+8] = rotation_matrices[i_grain][2][2];
-      }
-  }
-} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/gravity_model/interface.cc.bak b/contrib/world_builder/source/world_builder/gravity_model/interface.cc.bak
deleted file mode 100644
index 6a41777631b..00000000000
--- a/contrib/world_builder/source/world_builder/gravity_model/interface.cc.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/gravity_model/interface.h"
-
-#include "world_builder/types/object.h"
-
-#include <algorithm>
-
-namespace WorldBuilder
-{
-  namespace GravityModel
-  {
-
-    Interface::Interface()
-      = default;
-
-    Interface::~Interface ()
-      = default;
-
-    void
-    Interface::declare_entries(Parameters &prm, const std::string &parent_name, const std::vector<std::string> &required_entries)
-    {
-
-      unsigned int counter = 0;
-      for (auto &it : get_declare_map())
-        {
-          prm.enter_subsection("oneOf");
-          {
-            prm.enter_subsection(std::to_string(counter));
-            {
-              prm.enter_subsection("properties");
-              {
-                prm.declare_entry("", Types::Object(required_entries), "gravity model");
-
-                prm.declare_entry("model",Types::String("",it.first),
-                                  "The name of the model for the gravity to use.");
-
-                it.second(prm, parent_name);
-              }
-              prm.leave_subsection();
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-
-          counter++;
-
-        }
-    }
-
-    void
-    Interface::registerType(const std::string &name,
-                            void ( *declare_entries)(Parameters &, const std::string &),
-                            ObjectFactory *factory)
-    {
-      get_factory_map()[name] = factory;
-      get_declare_map()[name] = declare_entries;
-    }
-
-    std::unique_ptr<Interface>
-    Interface::create(const std::string &name, WorldBuilder::World *world)
-    {
-      std::string lower_case_name;
-      std::transform(name.begin(),
-                     name.end(),
-                     std::back_inserter(lower_case_name),
-                     ::tolower);;
-
-      // Have a nice assert message to check whether a plugin exists in the case
-      // of a debug compilation.
-      WBAssertThrow(get_factory_map().find(lower_case_name) != get_factory_map().end(),
-                    "Internal error: Plugin with name '" << lower_case_name << "' is not found. "
-                    "The size of factories is " << get_factory_map().size() << ".");
-
-      // Using at() because the [] will just insert values
-      // which is undesirable in this case. An exception is
-      // thrown when the name is not present.
-      return get_factory_map().at(lower_case_name)->create(world);
-    }
-  } // namespace GravityModel
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/gravity_model/uniform.cc.bak b/contrib/world_builder/source/world_builder/gravity_model/uniform.cc.bak
deleted file mode 100644
index 9978af549c5..00000000000
--- a/contrib/world_builder/source/world_builder/gravity_model/uniform.cc.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/gravity_model/uniform.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/world.h"
-
-
-namespace WorldBuilder
-{
-  namespace GravityModel
-  {
-    Uniform::Uniform(WorldBuilder::World *world_)
-    {
-      this->world = world_;
-    }
-
-    Uniform::~Uniform()
-      = default;
-
-    void
-    Uniform::declare_entries(Parameters &prm, const std::string & /*unused*/)
-    {
-      // Add depth method to the required parameters.
-      prm.declare_entry("", Types::Object(),
-                        "Uniform gravity model. It returns the gravity vector in a Cartesian coordinate system at "
-                        "a given position, which has a constant magitude for the whole domain. The vector points "
-                        "down in cartesian coordinates and to the center of the sphere in spherical coordinates.");
-
-      prm.declare_entry("magnitude",
-                        Types::Double(9.81), "The magnitude of the gravity.");
-    }
-
-    void
-    Uniform::parse_entries(Parameters &prm)
-    {
-      gravity_magnitude = prm.get<double>("magnitude");
-    }
-
-
-    Point<3>
-    Uniform::gravity_vector(Point<3> point) const
-    {
-      const CoordinateSystem coordinate_system = world->parameters.coordinate_system->natural_coordinate_system();
-
-      switch (coordinate_system)
-        {
-          case CoordinateSystem::cartesian:
-            return Point<3>(0.,0.,-gravity_magnitude,CoordinateSystem::cartesian);
-            break;
-
-          case CoordinateSystem::spherical:
-            return (point/point.norm())*-gravity_magnitude;
-            break;
-
-          default:
-            WBAssertThrow(false, "Invalid coordinate system when using the gravity vector function.");
-        }
-
-      return Point<3>(NaN::DSNAN,NaN::DSNAN,NaN::DSNAN,CoordinateSystem::invalid);
-    }
-
-
-    double
-    Uniform::gravity_norm(Point<3> /*point*/) const
-    {
-      return gravity_magnitude;
-    }
-
-
-    /**
-     * Register plugin
-     */
-    WB_REGISTER_GRAVITY_MODEL(Uniform, uniform)
-  } // namespace GravityModel
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/kd_tree.cc.bak b/contrib/world_builder/source/world_builder/kd_tree.cc.bak
deleted file mode 100644
index 6f5a8347fc6..00000000000
--- a/contrib/world_builder/source/world_builder/kd_tree.cc.bak
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/kd_tree.h"
-#include <algorithm>
-#include <utility>
-
-namespace WorldBuilder
-{
-  namespace KDTree
-  {
-    KDTree::KDTree(std::vector<Node> point_list)
-      : nodes(std::move(std::move(point_list)))
-    {}
-
-
-    void
-    KDTree::create_tree(const size_t left,
-                        const size_t right,
-                        const bool y_axis)
-    {
-      const size_t mid=(left+right)>>1;
-      std::nth_element(nodes.begin()+static_cast<long int>(left),nodes.begin()+static_cast<long int>(mid),nodes.begin()+static_cast<long int>(right)+1,
-                       [y_axis](Node& i, Node& j) -> bool
-      {
-        return i[y_axis] < j[y_axis];
-      });
-
-      if (left<mid)
-        create_tree(left,mid-1,!y_axis);
-      if (right>mid)
-        create_tree(mid+1,right,!y_axis);
-    }
-
-
-    const std::vector<Node> &
-    KDTree::get_nodes() const
-    {
-      return nodes;
-    }
-
-
-    IndexDistance
-    KDTree::find_closest_point(const Point<2> &check_point) const
-    {
-      const size_t start_node_index = 0;
-      IndexDistance index_distance = {start_node_index,
-                                      std::numeric_limits<double>::max()
-                                     };
-
-      find_closest_point_recursive(check_point,0,nodes.size()-1,false,index_distance);
-
-      return index_distance;
-    }
-
-
-    void
-    KDTree::find_closest_point_recursive(const Point<2> &check_point,
-                                         const size_t left,
-                                         const size_t right,
-                                         const bool y_axis,
-                                         IndexDistance &index_distance) const
-    {
-      // Calculate the index of this node
-      const size_t mid=(left+right)>>1;
-      const Node &node = nodes[mid];
-      if (check_point[static_cast<size_t>(y_axis)] < node[y_axis])
-        {
-          // Traverse left child
-          if (left<mid)
-            {
-              find_closest_point_recursive(check_point,left,mid-1,!y_axis,index_distance);
-            }
-
-          // Compare node's point to current closest point
-          const double distance = sqrt((node[false]-check_point[0])*(node[false]-check_point[0])
-                                       +(node[true]-check_point[1])*(node[true]-check_point[1]));
-          if (index_distance.distance > distance)
-            {
-              index_distance.index = mid;
-              index_distance.distance = distance;
-            }
-
-          // Traverse right child
-          if (right>mid)
-            {
-              if ((node[y_axis]-check_point[static_cast<size_t>(y_axis)]) < index_distance.distance)
-                {
-                  find_closest_point_recursive(check_point,mid+1,right,!y_axis,index_distance);
-                }
-            }
-        }
-      else
-        {
-          // Traverse right child
-          if (right>mid)
-            find_closest_point_recursive(check_point,mid+1,right,!y_axis,index_distance);
-
-          // Compare node's point to current closest point
-          const double distance = sqrt((node[false]-check_point[0])*(node[false]-check_point[0])
-                                       +(node[true]-check_point[1])*(node[true]-check_point[1]));
-          if (index_distance.distance > distance)
-            {
-              index_distance.index = mid;
-              index_distance.distance = distance;
-            }
-
-          // Traverse left child
-          if (left<mid)
-            if ((node[y_axis]-check_point[static_cast<size_t>(y_axis)]) < index_distance.distance)
-              find_closest_point_recursive(check_point,left,mid-1,!y_axis,index_distance);
-        }
-    }
-
-
-
-    IndexDistances
-    KDTree::find_closest_points(const Point<2> &check_point) const
-    {
-      const size_t start_node_index = 0;
-      IndexDistances index_distances = {start_node_index,
-                                        std::numeric_limits<double>::max(),
-                                        {}
-                                       };
-      index_distances.vector.reserve(nodes.size());
-
-      find_closest_points_recursive(check_point,0,nodes.size()-1,false,index_distances);
-
-      return index_distances;
-    }
-
-
-    void
-    KDTree::find_closest_points_recursive(const Point<2> &check_point,
-                                          const size_t left,
-                                          const size_t right,
-                                          const bool y_axis,
-                                          IndexDistances &index_distances) const
-    {
-      // Calculate the index of this node
-      const size_t mid=(left+right)>>1;
-      const Node &node = nodes[mid];
-      if (check_point[static_cast<size_t>(y_axis)] < node[y_axis])
-        {
-          // Traverse left child
-          if (left<mid)
-            {
-              find_closest_points_recursive(check_point,left,mid-1,!y_axis,index_distances);
-            }
-
-          // Compare node's point to current closest point
-          const double distance = sqrt((node[false]-check_point[0])*(node[false]-check_point[0])
-                                       +(node[true]-check_point[1])*(node[true]-check_point[1]));
-          if (index_distances.min_distance > distance)
-            {
-              index_distances.min_index = mid;
-              index_distances.min_distance = distance;
-            }
-
-          index_distances.vector.emplace_back(IndexDistance {mid, distance});
-
-          // Traverse right child
-          if (right>mid)
-            {
-              if ((node[y_axis]-check_point[static_cast<size_t>(y_axis)]) < index_distances.min_distance)
-                {
-                  find_closest_points_recursive(check_point,mid+1,right,!y_axis,index_distances);
-                }
-            }
-        }
-      else
-        {
-          // Traverse right child
-          if (right>mid)
-            find_closest_points_recursive(check_point,mid+1,right,!y_axis,index_distances);
-
-          // Compare node's point to current closest point
-          const double distance = sqrt((node[false]-check_point[0])*(node[false]-check_point[0])
-                                       +(node[true]-check_point[1])*(node[true]-check_point[1]));
-          if (index_distances.min_distance > distance)
-            {
-              index_distances.min_index = mid;
-              index_distances.min_distance = distance;
-            }
-
-          index_distances.vector.emplace_back(IndexDistance {mid, distance});
-
-          // Traverse left child
-          if (left<mid)
-            if ((node[y_axis]-check_point[static_cast<size_t>(y_axis)]) < index_distances.min_distance)
-              find_closest_points_recursive(check_point,left,mid-1,!y_axis,index_distances);
-        }
-    }
-  } // namespace KDTree
-} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/objects/bezier_curve.cc.bak b/contrib/world_builder/source/world_builder/objects/bezier_curve.cc.bak
deleted file mode 100644
index 74f3b57393d..00000000000
--- a/contrib/world_builder/source/world_builder/objects/bezier_curve.cc.bak
+++ /dev/null
@@ -1,550 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/assert.h"
-#include "world_builder/nan.h"
-#include "world_builder/objects/bezier_curve.h"
-
-#include <cmath>
-#include <cstddef>
-#include <iomanip>
-#include <limits>
-#include <sstream>
-
-using namespace WorldBuilder;
-
-namespace WorldBuilder
-{
-  namespace Objects
-  {
-    BezierCurve::BezierCurve(const std::vector<Point<2> > &p, const std::vector<double> &angle_constrains_input)
-    {
-      points = p;
-      const size_t n_points = p.size();
-      control_points.resize(n_points-1, {{p[0],p[0]}});
-      lengths.resize(n_points-1,NaN::DSNAN);
-      angles.resize(n_points,NaN::DSNAN);
-      std::vector<double> angle_constrains = angle_constrains_input;
-      angle_constrains.resize(n_points,NaN::DQNAN);
-
-      // if no angle is provided, compute the angle as the average angle between the previous and next point.
-      // The first angle points at the second point and the last angle points at the second to last point.
-      // The check points are set at a distance of 1/10th the line length from the point in the direction of the angle.
-      if (std::isnan(angle_constrains[0]))
-        {
-          Point<2> P1P2 = points[1]-points[0];
-          angles[0] = atan2(P1P2[1],P1P2[0]);
-        }
-      else
-        {
-          angles[0] = angle_constrains[0];
-        }
-
-      for (size_t p_i = 1; p_i < n_points-1; ++p_i)
-        {
-          // first determine the angle
-          if (std::isnan(angle_constrains[p_i]))
-            {
-              // get the average angle
-              const Point<2> P1P2 = points[p_i-1]-points[p_i];
-              const Point<2> P3P2 = points[p_i+1]-points[p_i];
-
-              const double angle_p1p2 = atan2(P1P2[1],P1P2[0]);
-              const double angle_p3p1 = atan2(P3P2[1],P3P2[0]);
-              const double average_angle = (angle_p1p2 + angle_p3p1)*0.5;
-              angles[p_i] = average_angle;
-              angles[p_i] -= Consts::PI*0.5;
-            }
-          else
-            {
-              angles[p_i] = angle_constrains[p_i];
-            }
-
-        }
-
-      if (std::isnan(angle_constrains[n_points-1]))
-        {
-          Point<2> P1P2 = points[n_points-2]-points[n_points-1];
-          angles[n_points-1] =  atan2(P1P2[1],P1P2[0]);
-        }
-      else
-        {
-          angles[n_points-1] = angle_constrains[n_points-1];
-        }
-
-      if (points.size() > 2)
-        {
-          // next determine the location of the control points
-          // the location of the control point is 1/10th p1p2 distance in the direction of the angle.
-          // make sure the angle is pointing away from the next point, e.g.
-          // the check point is on the other side of the of the line p1p2 compared to p3.
-          const double fraction_of_length = 0.2;
-          {
-            const Point<2> &p1 = points[0];
-            const Point<2> &p2 = points[1];
-            const Point<2> &p3 = points[2];
-            const double length = (points[0]-points[1]).norm(); // can be squared
-            control_points[0][0][0] = cos(angles[0])*length*fraction_of_length+p1[0];
-            control_points[0][0][1] = sin(angles[0])*length*fraction_of_length+p1[1];
-            control_points[0][1][0] = cos(angles[1])*length*fraction_of_length+p2[0];
-            control_points[0][1][1] = sin(angles[1])*length*fraction_of_length+p2[1];
-            {
-              const bool side_of_line_1 =  (p1[0] - p2[0]) * (control_points[0][1][1] - p1[1])
-                                           - (p1[1] - p2[1]) * (control_points[0][1][0] - p1[0])
-                                           < 0;
-              const bool side_of_line_2 =  (p1[0] - p2[0]) * (p3[1] - p1[1])
-                                           - (p1[1] - p2[1]) * (p3[0] - p1[0])
-                                           < 0;
-              if (side_of_line_1 == side_of_line_2)
-                {
-                  // use a 180 degree rotated angle to create this control_point
-                  control_points[0][1][0] = cos(angles[1]+Consts::PI)*length*fraction_of_length+p2[0];
-                  control_points[0][1][1] = sin(angles[1]+Consts::PI)*length*fraction_of_length+p2[1];
-                }
-            }
-          }
-
-          for (size_t p_i = 1; p_i < n_points-1; ++p_i)
-            {
-              const Point<2> &p1 = points[p_i];
-              const Point<2> &p2 = points[p_i+1];
-              const double length = (points[p_i]-points[p_i+1]).norm(); // can be squared
-              control_points[p_i][0][0] = cos(angles[p_i])*length*fraction_of_length+p1[0];
-              control_points[p_i][0][1] = sin(angles[p_i])*length*fraction_of_length+p1[1];
-
-              {
-                const bool side_of_line_1 =  (p1[0] - p2[0]) * (control_points[p_i-1][1][1] - p1[1])
-                                             - (p1[1] - p2[1]) * (control_points[p_i-1][1][0] - p1[0])
-                                             < 0;
-                const bool side_of_line_2 =  (p1[0] - p2[0]) * (control_points[p_i][0][1] - p1[1])
-                                             - (p1[1] - p2[1]) * (control_points[p_i][0][0] - p1[0])
-                                             < 0;
-                if (side_of_line_1 == side_of_line_2)
-                  {
-                    // use a 180 degree rotated angle to create this control_point
-                    control_points[p_i][0][0] = cos(angles[p_i]+Consts::PI)*length*fraction_of_length+p1[0];
-                    control_points[p_i][0][1] = sin(angles[p_i]+Consts::PI)*length*fraction_of_length+p1[1];
-                  }
-              }
-
-              control_points[p_i][1][0] = cos(angles[p_i+1])*length*fraction_of_length+points[p_i+1][0];
-              control_points[p_i][1][1] = sin(angles[p_i+1])*length*fraction_of_length+points[p_i+1][1];
-
-              if (p_i+1 < n_points-1)
-                {
-                  const Point<2> &p3 = points[p_i+2];
-                  const bool side_of_line_1 =  (p1[0] - p2[0]) * (control_points[p_i][1][1] - p1[1])
-                                               - (p1[1] - p2[1]) * (control_points[p_i][1][0] - p1[0])
-                                               < 0;
-                  const bool side_of_line_2 =  (p1[0] - p2[0]) * (p3[1] - p1[1])
-                                               - (p1[1] - p2[1]) * (p3[0] - p1[0])
-                                               < 0;
-                  if (side_of_line_1 == side_of_line_2)
-                    {
-                      // use a 180 degree rotated angle to create this control_point
-                      control_points[p_i][1][0] = cos(angles[p_i+1]+Consts::PI)*length*fraction_of_length+p2[0];
-                      control_points[p_i][1][1] = sin(angles[p_i+1]+Consts::PI)*length*fraction_of_length+p2[1];
-                    }
-                }
-            }
-        }
-    }
-
-
-    Point<2>
-    BezierCurve::operator()(const size_t i, const double t) const
-    {
-      WBAssert(i < points.size()-1 && i < control_points.size() ,
-               "Trying to access index " << i << ", but points.size() = " << points.size() << ", and control_points = " << control_points.size() << ".");
-      return (1-t)*(1-t)*(1-t)*points[i] + 3*(1-t)*(1-t)*t*control_points[i][0] + 3.*(1-t)*t*t*control_points[i][1]+t*t*t*points[i+1];
-    }
-
-
-    ClosestPointOnCurve
-    BezierCurve::closest_point_on_curve_segment(const Point<2> &check_point,
-                                                const bool verbose) const
-    {
-      ClosestPointOnCurve closest_point_on_curve;
-      const Point<2> &cp = check_point;
-      double min_squared_distance = std::numeric_limits<double>::infinity();
-      if (check_point.get_coordinate_system() == CoordinateSystem::cartesian)
-        {
-          for ( size_t cp_i = 0; cp_i < control_points.size(); ++cp_i)
-            {
-#ifndef NDEBUG
-              std::stringstream output;
-#endif
-              const Point<2> &p1 = points[cp_i];
-              const Point<2> &p2 = points[cp_i+1];
-              //min_squared_distance = std::min(std::min(min_squared_distance,(check_point-p1).norm_square()),(check_point-p1).norm_square());
-
-              // Getting an estimate for where the closest point is with a linear approximation
-              const Point<2> P1P2 = p2-p1;
-              const Point<2> P1Pc = check_point-p1;
-
-              const double P2P2_dot = P1P2*P1P2;
-
-              double est =  P2P2_dot > 0.0 ? std::min(1.,std::max(0.,(P1Pc*P1P2) / P2P2_dot)) : 1.0; // est=estimate of solution
-              bool found = false;
-
-              // based on https://stackoverflow.com/questions/2742610/closest-point-on-a-cubic-bezier-curve
-              const double a_0 = 3.*control_points[cp_i][0][0]-3.*control_points[cp_i][1][0]+points[cp_i+1][0]-points[cp_i][0];
-              const double a_1 = 3.*control_points[cp_i][0][1]-3.*control_points[cp_i][1][1]+points[cp_i+1][1]-points[cp_i][1];
-              const double b_0 = 3.*points[cp_i][0] - 6.*control_points[cp_i][0][0]+3.*control_points[cp_i][1][0];
-              const double b_1 = 3.*points[cp_i][1] - 6.*control_points[cp_i][0][1]+3.*control_points[cp_i][1][1];
-              const double c_0 = -3.*points[cp_i][0] + 3.*control_points[cp_i][0][0];
-              const double c_1 = -3.*points[cp_i][1] + 3.*control_points[cp_i][0][1];
-              const double d_0 = points[cp_i][0];
-              const double d_1 = points[cp_i][1];
-
-              const double d_min_cp_0 = d_0-cp[0];
-              const double d_min_cp_1 = d_1-cp[1];
-
-#ifndef NDEBUG
-              double estimate_point_min_cp_0_dg = a_0*est*est*est+b_0*est*est+c_0*est+d_min_cp_0;
-              double estimate_point_min_cp_1_dg = a_1*est*est*est+b_1*est*est+c_1*est+d_min_cp_1;
-              double min_squared_distance_cartesian_temp_dg = (estimate_point_min_cp_0_dg*estimate_point_min_cp_0_dg)+(estimate_point_min_cp_1_dg*estimate_point_min_cp_1_dg);
-#endif
-
-              for (size_t newton_i = 0; newton_i < 150; newton_i++)
-                {
-#ifndef NDEBUG
-                  output << "  wolfram alpha: (" << a_0 << "*x^3+" << b_0 << "*x^2+"<< c_0 << "*x+" << d_0 << "-" << cp[0] << ")^2+(" << a_1 << "*x^3+" << b_1 << "*x^2+"<< c_1 << "*x+" << d_1 << "-" << cp[1] << ")^2 with x=" << est << std::endl;
-#endif
-                  const double est_sq = est*est;
-                  const double estimate_point_min_cp_0 = a_0*est_sq*est+b_0*est_sq+c_0*est+d_min_cp_0;
-                  const double estimate_point_min_cp_1 = a_1*est_sq*est+b_1*est_sq+c_1*est+d_min_cp_1;
-
-                  const double deriv_0 = 3.0*a_0*est_sq+2.0*b_0*est+c_0;
-                  const double deriv_1 = 3.0*a_1*est_sq+2.0*b_1*est+c_1;
-                  const double squared_distance_cartesian = (estimate_point_min_cp_0*estimate_point_min_cp_0)+(estimate_point_min_cp_1*estimate_point_min_cp_1);
-
-                  const double squared_distance_cartesian_derivative = 2.0*(deriv_0*estimate_point_min_cp_0 + deriv_1*estimate_point_min_cp_1);
-                  const double squared_distance_cartesian_second_derivative_abs  = std::fabs(2.0*((6.0*a_0*est+2.0*b_0)*estimate_point_min_cp_0 + deriv_0*deriv_0
-                                                                                                  + (6.0*a_1*est+2.0*b_1)*estimate_point_min_cp_1 + deriv_1*deriv_1));
-
-                  if (squared_distance_cartesian_second_derivative_abs <= 0.0)
-                    {
-                      found = true;
-                      break;
-                    }
-
-                  // the local minimum is where  squared_distance_cartesian_derivative=0 and squared_distance_cartesian_derivative>=0
-                  const double update = std::min(0.5,std::max(-0.5,squared_distance_cartesian_derivative/squared_distance_cartesian_second_derivative_abs));
-                  double line_search = 1.;
-
-                  if (std::fabs(update) > 1e-1)
-                    {
-                      double est_test = est-update*line_search;
-                      double squared_distance_cartesian_test = squared_distance_cartesian;
-                      double squared_distance_cartesian_test_previous = squared_distance_cartesian;
-
-                      for (unsigned int i = 0; i < 10; i++)
-                        {
-                          est_test = est-update*line_search;
-                          const double est_test_sq = est_test*est_test;
-                          const double estimate_point_min_cp_test_0 = a_0*est_test_sq*est_test+b_0*est_test_sq+c_0*est_test+d_min_cp_0;
-                          const double estimate_point_min_cp_test_1 = a_1*est_test_sq*est_test+b_1*est_test_sq+c_1*est_test+d_min_cp_1;
-
-                          squared_distance_cartesian_test = (estimate_point_min_cp_test_0*estimate_point_min_cp_test_0)+(estimate_point_min_cp_test_1*estimate_point_min_cp_test_1);
-
-#ifndef NDEBUG
-                          const Point<2> a = 3.*control_points[cp_i][0]-3.*control_points[cp_i][1]+points[cp_i+1]-points[cp_i];
-                          const Point<2> b = 3.*points[cp_i] - 6.*control_points[cp_i][0]+3.*control_points[cp_i][1];
-                          const Point<2> c = -3.*points[cp_i] + 3.*control_points[cp_i][0];
-                          const Point<2> d = points[cp_i];
-                          const double squared_distance_cartesian_derivative_test = 2.0*(3.0*a_0*est_test*est_test+2.0*b_0*est_test+c_0)*(a_0*est_test*est_test*est_test+b_0*est_test*est_test+c_0*est_test+d_0-cp[0])
-                                                                                    + 2.0*(3.0*a_1*est_test*est_test+2.0*b_1*est_test+c_1)*(a_1*est_test*est_test*est_test+b_1*est_test*est_test+c_1*est_test+d_1-cp[1]);
-                          const double squared_distance_cartesian_second_derivative_test = 2.0*(6.0*a_0*est_test + 2.0*b_0)*(a_0*est_test*est_test*est_test+b_0*est_test*est_test+c_0*est_test+d_0-cp[0])
-                                                                                           + 2.0*(3.0*a_0*est_test*est_test + 2.0*b_0*est_test + c_0)*(3.0*a_0*est_test*est_test + 2.0*b_0*est_test + c_0)
-                                                                                           + 2.0*(6.0*a_1*est_test + 2.0*b_1)*(a_1*est_test*est_test*est_test+b_1*est_test*est_test+c_1*est_test+d_1-cp[1])
-                                                                                           + 2.0*(3.0*a_1*est_test*est_test + 2.0*b_1*est_test + c_1)*(3.0*a_1*est_test*est_test + 2.0*b_1*est_test + c_1) ;
-                          output << "    i: " << cp_i << ", ni: " << newton_i<< ", lsi: " << i << ", line_search_step=" << 2./3. << ": squared_distance_cartesian_test = " << squared_distance_cartesian_test << ", diff= " << squared_distance_cartesian_test-squared_distance_cartesian
-                                 << ", tests: " << (squared_distance_cartesian_test_previous < squared_distance_cartesian ? "true" : "false") << ":" << (squared_distance_cartesian_test > squared_distance_cartesian_test_previous ? "true" : "false") << ", est_test=" << est_test
-                                 << ", update=" << update << ", ls=" << line_search << ", up*ls=" << update *line_search << ", test deriv =" << squared_distance_cartesian_derivative_test  << ", test update=" << squared_distance_cartesian_derivative_test/fabs(squared_distance_cartesian_second_derivative_test)
-                                 << ", p1=" << p1 << ", p2= " << p2 << ", poc= " << a *est_test *est_test *est_test + b *est_test *est_test+c *est_test+d << ", cp= " <<  check_point << ", ds:" << ((a*est_test*est_test*est_test+b*est_test*est_test+c*est_test+d)-check_point).norm_square() << ":" << min_squared_distance_cartesian_temp_dg
-                                 << ", diff = " << squared_distance_cartesian_test-min_squared_distance_cartesian_temp_dg << std::endl;
-#endif
-                          if (i > 0 && (squared_distance_cartesian_test > squared_distance_cartesian_test_previous))
-                            {
-                              if (squared_distance_cartesian_test_previous-squared_distance_cartesian < 0)
-                                {
-                                  line_search *= 3./2.;
-                                  break;
-                                }
-                            }
-                          squared_distance_cartesian_test_previous = squared_distance_cartesian_test;
-
-                          line_search *=  2./3.;
-                        }
-                    }
-
-                  est -= update*line_search;
-
-                  if (std::fabs(update) < 1e-4 || est < -0.1 || est > 1.1)
-                    {
-                      found = true;
-                      break;
-                    }
-                }
-#ifndef NDEBUG
-              WBAssertThrow(found, "Could not find a good solution. " << output.str());
-#else
-              WBAssertThrow(found, "Could not find a good solution. Enable debug mode for more info.");
-#endif
-
-              const double est_min_cp_end_0 = a_0*est*est*est+b_0*est*est+c_0*est+d_min_cp_0;
-              const double est_min_cp_end_1 = a_1*est*est*est+b_1*est*est+c_1*est+d_min_cp_1;
-              const double min_squared_distance_temp = (est_min_cp_end_0*est_min_cp_end_0)+(est_min_cp_end_1*est_min_cp_end_1);
-              if (min_squared_distance_temp < min_squared_distance)
-                {
-                  if (est >= -1e-8 && static_cast<double>(cp_i)+est > 0 && est-1. <= 1e-8 && est-1. < static_cast<double>(cp_i))
-                    {
-                      min_squared_distance = min_squared_distance_temp;
-                      const Point<2> point_on_curve = Point<2>(a_0*est*est*est+b_0*est*est+c_0*est+d_0,a_1*est*est*est+b_1*est*est+c_1*est+d_1,cp.get_coordinate_system());
-                      WBAssert(!std::isnan(point_on_curve[0]) && !std::isnan(point_on_curve[1]), "Point on curve has NAN entries: " << point_on_curve);
-                      // the sign is rotating the derivative by 90 degrees.
-                      // When moving in the direction of increasing t, left is positive and right is negative.
-                      // https://www.wolframalpha.com/input?i=d%2Fdt+%281-t%29*%281-t%29*%281-t%29*a+%2B+3*%281-t%29*%281-t%29*t*b+%2B+3.*%281-t%29*t*t*c%2Bt*t*t*d
-                      const Point<2> derivative_point = points[cp_i]*((6.-3.*est)*est-3.) + control_points[cp_i][0]*(est*(9*est-12)+3)
-                                                        + control_points[cp_i][1]*(6.-9.*est)*est + points[cp_i+1]*3.*est*est;
-
-                      Point<2> tangent_point = derivative_point - point_on_curve;
-                      // if angle between check point and tangent point is larger than 90 degrees, return a negative distance
-                      const double dot_product = (tangent_point*(check_point-point_on_curve));
-                      const double sign = dot_product < 0. ? -1. : 1.;
-                      tangent_point = Point<2>(-tangent_point[1],tangent_point[0],tangent_point.get_coordinate_system());
-
-                      closest_point_on_curve.distance = sign*std::sqrt(min_squared_distance);
-                      closest_point_on_curve.parametric_fraction = est;
-                      closest_point_on_curve.interpolation_fraction = NaN::DSNAN; //arc_length(i,real_roots[root_i])/lengths[i];
-                      closest_point_on_curve.index = cp_i;
-                      closest_point_on_curve.point = point_on_curve;
-                      WBAssert(!std::isnan(point_on_curve[0]) && !std::isnan(point_on_curve[1]), "Point on curve has NAN entries: " << point_on_curve);
-                      Point<2> normal = point_on_curve;
-                      {
-                        Point<2> derivative = Point<2>(a_0*est*est+b_0*est+c_0,a_1*est*est+b_1*est+c_1,cp.get_coordinate_system());
-                        normal=derivative;
-                        const double normal_size = derivative.norm();
-                        if (normal_size > 0.)
-                          {
-                            normal[0] = derivative[1]/normal_size;
-                            normal[1] = -derivative[0]/normal_size;
-                          }
-                      }
-                      closest_point_on_curve.normal = normal;
-                    }
-                }
-            }
-        }
-      else
-        {
-          const double cos_cp_lat = cos(cp[1]);
-          for ( size_t cp_i = 0; cp_i < control_points.size(); ++cp_i)
-            {
-              const Point<2> &p1 = points[cp_i];
-              const Point<2> &p2 = points[cp_i+1];
-              // Getting an estimate for where the closest point is with a linear approximation
-              const Point<2> P1P2 = p2-p1;
-              const Point<2> P1Pc = check_point-p1;
-
-              const double P2P2_dot = P1P2*P1P2;
-
-              double est =  P2P2_dot > 0.0 ? std::min(1.,std::max(0.,(P1Pc*P1P2) / P2P2_dot)) : 1.0; // est=estimate of solution
-              bool found = false;
-
-              // only used if verbose is true
-              std::stringstream output;
-
-              Point<2> a = 3.*control_points[cp_i][0]-3.*control_points[cp_i][1]+points[cp_i+1]-points[cp_i];
-              Point<2> b = 3.*points[cp_i] - 6.*control_points[cp_i][0]+3.*control_points[cp_i][1];
-              Point<2> c = -3.*points[cp_i] + 3.*control_points[cp_i][0];
-              const Point<2> d = points[cp_i];
-
-              Point<2> estimate_point = a*est*est*est+b*est*est+c*est+d;
-
-              double cos_lat_dg = NaN::DSNAN;
-              double sin_d_long_h_dg = NaN::DSNAN;
-              double sin_d_lat_h_dg = NaN::DSNAN;
-              double min_squared_distance_cartesian_temp_dg = NaN::DSNAN;
-              if (verbose == true)
-                {
-                  cos_lat_dg = cos(estimate_point[1]);
-                  sin_d_long_h_dg = sin((estimate_point[0]-cp[0])*0.5);
-                  sin_d_lat_h_dg = sin((estimate_point[1]-cp[1])*0.5);
-                  min_squared_distance_cartesian_temp_dg = sin_d_lat_h_dg*sin_d_lat_h_dg+sin_d_long_h_dg*sin_d_long_h_dg*cos_cp_lat*cos_lat_dg;
-                  output << "cp_i=" << cp_i << ", init est = " << est << ", min_squared_distance = " << min_squared_distance << ", min_squared_distance_cartesian_temp_dg: " << min_squared_distance_cartesian_temp_dg << ", p1: " << p1 << ", p2: " << p2 << std::endl;
-                  output  << std::setprecision(6) << "  wolfram: sin((" << a[1] << "*x^3+" << b[1] << "*x^2+"<< c[1] << "*x+" << d[1] << "-" << cp[1] << ")*.5)^2+sin((" << a[0] << "*x^3+" << b[0] << "*x^2+"<< c[0] << "*x+" << d[0] << "-" << cp[0] << ")*.5)^2*cos(" << cp[1] << ")*cos(" << a[1] << "*x^3+" << b[1] << "*x^2+"<< c[1] << "*x+" << d[1] << "-" << cp[1] << ") with x=" << est << std::endl;
-                  output  << std::setprecision(10) << "  python: y=np.sin((" << a[1] << "*x**3+" << b[1] << "*x**2+"<< c[1] << "*x+" << d[1] << "-" << cp[1] << ")*.5)**2+np.sin((" << a[0] << "*x**3+" << b[0] << "*x**2+"<< c[0] << "*x+" << d[0] << "-" << cp[0] << ")*.5)**2*np.cos(" << cp[1] << ")*np.cos(" << a[1] << "*x**3+" << b[1] << "*x**2+"<< c[1] << "*x+" << d[1] << "-" << cp[1] << "); x=" << est << std::endl;
-                }
-              for (size_t newton_i = 0; newton_i < 150; newton_i++)
-                {
-                  // based on https://stackoverflow.com/questions/2742610/closest-point-on-a-cubic-bezier-curve
-                  estimate_point = a*est*est*est+b*est*est+c*est+d;
-
-                  double sin_d_long_h = sin((estimate_point[0]-cp[0])*0.5);
-                  double sin_d_lat_h = sin((estimate_point[1]-cp[1])*0.5);
-                  const double cos_d_lat = cos(estimate_point[1]-cp[1]);
-                  const double squared_distance_cartesian = sin_d_lat_h*sin_d_lat_h+sin_d_long_h*sin_d_long_h*cos_cp_lat*cos_d_lat;
-
-                  double sin_dlat = sin(estimate_point[1]-cp[1]);
-                  const double cos_dlong_h = cos(0.5*(estimate_point[0]-cp[0]));
-                  double cos_dlat_h = cos(0.5*(estimate_point[1]-cp[1]));
-                  double deriv_long = (3.0*a[0]*est*est+2.0*b[0]*est+c[0]);
-                  double deriv_lat = (3.0*a[1]*est*est+2.0*b[1]*est+c[1]);
-
-                  const double squared_distance_cartesian_derivative = cos_cp_lat*(-deriv_lat)*sin_d_long_h*sin_d_long_h*sin_dlat+cos_cp_lat*deriv_long*sin_d_long_h*cos_dlong_h*cos_d_lat+deriv_lat*sin_d_lat_h*cos_dlat_h;
-                  double update = NaN::DSNAN;
-                  if (std::fabs(squared_distance_cartesian_derivative) > 1e-15)
-                    {
-                      const double squared_distance_cartesian_second_derivative = cos_cp_lat*cos_d_lat*(-0.5*deriv_long*deriv_long*sin_d_long_h*sin_d_long_h+0.5*deriv_long*deriv_long*cos_dlong_h*cos_dlong_h+(6.0*a[0]*est+2.0*b[0])*sin_d_long_h*cos_dlong_h)+cos_cp_lat*sin_d_long_h*sin_d_long_h*(deriv_lat*deriv_lat*(-cos_d_lat)-(6.0*a[1]*est+2.0*b[1])*sin_dlat)-2.0*cos_cp_lat*deriv_long*deriv_lat*sin_d_long_h*cos_dlong_h*sin_dlat-0.5*deriv_lat*deriv_lat*sin_d_lat_h*sin_d_lat_h+0.5*deriv_lat*deriv_lat*cos_dlat_h*cos_dlat_h+(6.0*a[1]*est+2.0*b[1])*sin_d_lat_h*cos_dlat_h;
-
-                      if (verbose == true)
-                        {
-                          const double squared_distance_cartesian_full = sin((a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])*0.5)*sin((a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])*0.5)+sin((a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0])*0.5)*sin((a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0])*0.5)*cos(cp[1])*cos(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]);
-                          const double squared_distance_cartesian_derivative_full = cos(cp[1])*(-(3.0*a[1]*est*est+2.0*b[1]*est+c[1]))*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])+cos(cp[1])*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])+(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*sin(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))*cos(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]));
-                          const double squared_distance_cartesian_second_derivative_full = cos(cp[1])*cos(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])*(-0.5*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))+0.5*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))+(6.0*a[0]*est+2.0*b[0])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0])))+cos(cp[1])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*((3.0*a[1]*est*est+2.0*b[1]*est+c[1])*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*(-cos(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))-(6.0*a[1]*est+2.0*b[1])*sin(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))-2.0*cos(cp[1])*(3.0*a[0]*est*est+2.0*b[0]*est+c[0])*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*sin(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*cos(0.5*(a[0]*est*est*est+b[0]*est*est+c[0]*est+d[0]-cp[0]))*sin(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1])-0.5*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*sin(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))*sin(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))+0.5*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*(3.0*a[1]*est*est+2.0*b[1]*est+c[1])*cos(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))*cos(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))+(6.0*a[1]*est+2.0*b[1])*sin(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]))*cos(0.5*(a[1]*est*est*est+b[1]*est*est+c[1]*est+d[1]-cp[1]));
-                          output <<"sqd = " << squared_distance_cartesian <<":" << squared_distance_cartesian_full << ", diff=" << squared_distance_cartesian-squared_distance_cartesian_full << ", sqdd: " << squared_distance_cartesian_derivative <<":" << squared_distance_cartesian_derivative_full << ", diff="<< squared_distance_cartesian_derivative-squared_distance_cartesian_derivative_full << ", sqdd: " << squared_distance_cartesian_second_derivative << ":" << squared_distance_cartesian_second_derivative_full << ", diff= " << squared_distance_cartesian_second_derivative-squared_distance_cartesian_second_derivative_full << ", est: " << est << std::endl;
-                        }
-                      // the local minimum is where  squared_distance_cartesian_derivative=0 and squared_distance_cartesian_derivative>=0
-                      update = std::min(0.5,std::max(-0.5,squared_distance_cartesian_derivative/std::fabs(squared_distance_cartesian_second_derivative)));
-                      double line_search = 1.;
-                      double est_test = est-update*line_search;
-                      double squared_distance_cartesian_test = squared_distance_cartesian;
-                      double squared_distance_cartesian_test_previous = squared_distance_cartesian;
-                      double line_search_step = 2./3.;
-
-                      for (unsigned int i = 0; i < 10; i++)
-                        {
-                          est_test = est-update*line_search;
-                          estimate_point = a*est_test*est_test*est_test+b*est_test*est_test+c*est_test+d;
-
-                          sin_d_long_h = sin((estimate_point[0]-cp[0])*0.5);
-                          sin_d_lat_h = sin((estimate_point[1]-cp[1])*0.5);
-                          squared_distance_cartesian_test = sin_d_lat_h*sin_d_lat_h+sin_d_long_h*sin_d_long_h*cos_cp_lat*cos(estimate_point[1]-cp[1]);
-
-                          if (verbose == true)
-                            {
-                              sin_dlat = sin(estimate_point[1]-cp[1]);
-                              deriv_long = (3.0*a[0]*est_test*est_test+2.0*b[0]*est_test+c[0]);
-                              deriv_lat = (3.0*a[1]*est_test*est_test+2.0*b[1]*est_test+c[1]);
-                              const double squared_distance_cartesian_derivative_test = cos_cp_lat*(-deriv_lat)*sin_d_long_h*sin_d_long_h*sin_dlat+cos_cp_lat*deriv_long*sin_d_long_h*cos_dlong_h*cos_d_lat+deriv_lat*sin_d_lat_h*cos_dlat_h;
-                              const double squared_distance_cartesian_second_derivative_test = cos_cp_lat*cos_d_lat*(-0.5*deriv_long*deriv_long*sin_d_long_h*sin_d_long_h+0.5*deriv_long*deriv_long*cos_dlong_h*cos_dlong_h+(6.0*a[0]*est_test+2.0*b[0])*sin_d_long_h*cos_dlong_h)+cos_cp_lat*sin_d_long_h*sin_d_long_h*(deriv_lat*deriv_lat*(-cos_d_lat)-(6.0*a[1]*est_test+2.0*b[1])*sin_dlat)-2.0*cos_cp_lat*deriv_long*deriv_lat*sin_d_long_h*cos_dlong_h*sin_dlat-0.5*deriv_lat*deriv_lat*sin_d_lat_h*sin_d_lat_h+0.5*deriv_lat*deriv_lat*cos_dlat_h*cos_dlat_h+(6.0*a[1]*est_test+2.0*b[1])*sin_d_lat_h*cos_dlat_h;
-                              output << "    i: " << cp_i << ", ni: " << newton_i<< ", lsi: " << i << ", line_search_step=" << line_search_step << ": squared_distance_cartesian_test = " << squared_distance_cartesian_test << ", diff= " << squared_distance_cartesian_test-squared_distance_cartesian << ", tests: " << (squared_distance_cartesian_test_previous < squared_distance_cartesian ? "true" : "false") << ":" << (squared_distance_cartesian_test > squared_distance_cartesian_test_previous ? "true" : "false") << ", est_test=" << est_test << ", update=" << update << ", ls=" << line_search << ", up*ls=" << update *line_search << ", test deriv =" << squared_distance_cartesian_derivative_test  << ", test update=" << squared_distance_cartesian_derivative_test/fabs(squared_distance_cartesian_second_derivative_test) << ", p1=" << p1 << ", p2= " << p2 << ", poc= " << a *est_test *est_test *est_test+b *est_test *est_test+c *est_test+d << ", cp= " <<  check_point << ", ds:" << ((a*est_test*est_test*est_test+b*est_test*est_test+c*est_test+d)-check_point).norm_square() << ":" << min_squared_distance_cartesian_temp_dg << ", diff = " << squared_distance_cartesian_test-min_squared_distance_cartesian_temp_dg<< std::endl;
-                            }
-                          if (i > 0 && (squared_distance_cartesian_test > squared_distance_cartesian_test_previous))
-                            {
-                              if (squared_distance_cartesian_test_previous-squared_distance_cartesian < 0)
-                                {
-                                  line_search *= 1/line_search_step;
-                                  break;
-                                }
-                              if (i> 1)
-                                {
-                                  line_search *= (1/line_search_step)*(1/line_search_step);
-                                  est_test = est-update*line_search;
-                                  estimate_point = a*est_test*est_test*est_test+b*est_test*est_test+c*est_test+d;
-
-                                  sin_d_long_h = sin((estimate_point[0]-cp[0])*0.5);
-                                  sin_d_lat_h = sin((estimate_point[1]-cp[1])*0.5);
-                                  squared_distance_cartesian_test_previous = sin_d_lat_h*sin_d_lat_h+sin_d_long_h*sin_d_long_h*cos_cp_lat*cos(estimate_point[1]-cp[1]);
-                                  line_search_step = std::min(line_search_step*(11./10.),0.95);
-                                  continue;
-                                }
-                            }
-                          squared_distance_cartesian_test_previous = squared_distance_cartesian_test;
-
-                          line_search *= line_search_step;
-                        }
-                      if (verbose == true)
-                        {
-                          output << "    i: " << cp_i << ", ni: " << newton_i<< ", est= " << est-update *line_search << ", ls:" << line_search << ": squared_distance_cartesian_test = " << squared_distance_cartesian_test << ", diff= " << squared_distance_cartesian_test-squared_distance_cartesian << std::endl;
-                        }
-                      est -= update*line_search;
-                    }
-
-                  if (std::fabs(squared_distance_cartesian_derivative) <= 1e-15 || std::fabs(update) < 1e-4 || est < -0.1 || est > 1.1)
-                    {
-                      found = true;
-                      break;
-                    }
-                }
-
-              if (verbose == true && found == false)
-                {
-                  // report the error and print the output
-                  WBAssertThrow(found, "Could not find a good solution. " << output.str());
-                }
-              else if (verbose == false && found == false)
-                {
-                  // redo the iteration with verbose=true to be able to report the error
-                  return closest_point_on_curve_segment(check_point, true);
-                }
-
-              estimate_point = a*est*est*est+b*est*est+c*est+d;
-
-              const double sin_d_long_h = sin((estimate_point[0]-cp[0])*0.5);
-              const double sin_d_lat_h = sin((estimate_point[1]-cp[1])*0.5);
-
-              const double min_squared_distance_cartesian_temp = sin_d_lat_h*sin_d_lat_h+sin_d_long_h*sin_d_long_h*cos_cp_lat*cos(estimate_point[1]-cp[1]);
-
-              if (min_squared_distance_cartesian_temp < min_squared_distance)
-                {
-                  if (est >= -1e-8 && static_cast<double>(cp_i)+est > 0 && est-1. <= 1e-8 && est-1. < static_cast<double>(cp_i))
-                    {
-                      min_squared_distance = min_squared_distance_cartesian_temp;
-                      const Point<2> point_on_curve = a*est*est*est+b*est*est+c*est+d;
-
-                      // the sign is rotating the derivative by 90 degrees.
-                      // When moving in the direction of increasing t, left is positive and right is negative.
-                      // https://www.wolframalpha.com/input?i=d%2Fdt+%281-t%29*%281-t%29*%281-t%29*a+%2B+3*%281-t%29*%281-t%29*t*b+%2B+3.*%281-t%29*t*t*c%2Bt*t*t*d
-                      const Point<2> derivative_point = points[cp_i]*((6.-3.*est)*est-3.) + control_points[cp_i][0]*(est*(9*est-12)+3)
-                                                        + control_points[cp_i][1]*(6.-9.*est)*est + points[cp_i+1]*3.*est*est;
-
-                      Point<2> tangent_point = derivative_point - point_on_curve;
-                      // if angle between check point and tangent point is larger than 90 degrees, return a negative distance
-                      const double dot_product = (tangent_point*(check_point-point_on_curve));
-                      const double sign = dot_product < 0. ? -1. : 1.;
-                      tangent_point = Point<2>(-tangent_point[1],tangent_point[0],tangent_point.get_coordinate_system());
-
-                      closest_point_on_curve.distance = sign*std::sqrt(min_squared_distance);
-                      closest_point_on_curve.parametric_fraction = est;
-                      closest_point_on_curve.interpolation_fraction = NaN::DSNAN; //arc_length(i,real_roots[root_i])/lengths[i];
-                      closest_point_on_curve.index = cp_i;
-                      closest_point_on_curve.point = point_on_curve;
-                      Point<2> normal = point_on_curve;
-                      {
-                        Point<2> derivative = a*est*est+b*est+c;
-                        normal=derivative;
-                        const double normal_size = derivative.norm();
-                        if (normal_size > 0.)
-                          {
-                            normal[0] = derivative[1]/normal_size;
-                            normal[1] = -derivative[0]/normal_size;
-                          }
-                      }
-                      closest_point_on_curve.normal = normal;
-                    }
-                }
-            }
-
-        }
-      return closest_point_on_curve;
-    }
-  } // namespace Objects
-} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/objects/distance_from_surface.cc.bak b/contrib/world_builder/source/world_builder/objects/distance_from_surface.cc.bak
deleted file mode 100644
index 5024c3692da..00000000000
--- a/contrib/world_builder/source/world_builder/objects/distance_from_surface.cc.bak
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/objects/distance_from_surface.h"
-
-namespace WorldBuilder
-{
-  namespace Objects
-  {
-    double PlaneDistances::get_distance_from_surface() const
-    {
-      return this->distance_from_surface;
-    }
-
-    double PlaneDistances::get_distance_along_surface() const
-    {
-      return this->distance_along_surface;
-    }
-  } // namespace Objects
-} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/objects/natural_coordinate.cc.bak b/contrib/world_builder/source/world_builder/objects/natural_coordinate.cc.bak
deleted file mode 100644
index b02ddc9beb1..00000000000
--- a/contrib/world_builder/source/world_builder/objects/natural_coordinate.cc.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/objects/natural_coordinate.h"
-
-namespace WorldBuilder
-{
-  namespace Objects
-  {
-    NaturalCoordinate::NaturalCoordinate(const std::array<double,3> &position,
-                                         const CoordinateSystems::Interface &coordinate_system_)
-    {
-      coordinate_system = coordinate_system_.natural_coordinate_system();
-      coordinates = coordinate_system_.cartesian_to_natural_coordinates(position);
-    }
-
-
-    // todo, should be possible to make this without the interface, since the Point knows the coord system.
-    NaturalCoordinate::NaturalCoordinate(const Point<3> &position,
-                                         const CoordinateSystems::Interface &coordinate_system_)
-    {
-      coordinate_system = coordinate_system_.natural_coordinate_system();
-      coordinates = coordinate_system_.cartesian_to_natural_coordinates(position.get_array());
-    }
-
-
-    const std::array<double,3> &NaturalCoordinate::get_coordinates() const
-    {
-      return coordinates;
-    }
-
-
-    std::array<double,2> NaturalCoordinate::get_surface_coordinates() const
-    {
-      std::array<double,2> coordinate;
-
-      switch (coordinate_system)
-        {
-          case CoordinateSystem::cartesian:
-            coordinate[0] = coordinates[0];
-            coordinate[1] = coordinates[1];
-            break;
-
-          case CoordinateSystem::spherical:
-            coordinate[0] = coordinates[1];
-            coordinate[1] = coordinates[2];
-            break;
-
-          default:
-            WBAssertThrow (false, "Coordinate system not implemented.");
-        }
-
-      return coordinate;
-    }
-
-
-    Point<2> NaturalCoordinate::get_surface_point() const
-    {
-      Point<2> coordinate(0,0,coordinate_system);
-
-      switch (coordinate_system)
-        {
-          case CoordinateSystem::cartesian:
-            coordinate[0] = coordinates[0];
-            coordinate[1] = coordinates[1];
-            break;
-
-          case CoordinateSystem::spherical:
-            coordinate[0] = coordinates[1];
-            coordinate[1] = coordinates[2];
-            break;
-
-          default:
-            WBAssertThrow (false, "Coordinate system not implemented.");
-        }
-
-      return coordinate;
-    }
-
-
-    CoordinateSystem
-    NaturalCoordinate::get_coordinate_system() const
-    {
-      return coordinate_system;
-    }
-
-
-    double &NaturalCoordinate::get_ref_depth_coordinate()
-    {
-      switch (coordinate_system)
-        {
-          case CoordinateSystem::cartesian:
-            return coordinates[2];
-
-          case CoordinateSystem::spherical:
-            return coordinates[0];
-
-          default:
-            WBAssertThrow (false, "Coordinate system not implemented.");
-        }
-
-      return coordinates[2];
-    }
-  } // namespace Objects
-} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/objects/segment.cc.bak b/contrib/world_builder/source/world_builder/objects/segment.cc.bak
deleted file mode 100644
index 368a034ad52..00000000000
--- a/contrib/world_builder/source/world_builder/objects/segment.cc.bak
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include <utility>
-
-#include "world_builder/objects/segment.h"
-
-
-namespace WorldBuilder
-{
-
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace FaultModels
-    namespace SubductingPlateModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace SubductingPlateModels
-  }  // namespace Features
-
-
-  namespace Objects
-  {
-    // todo update function
-    template<class A, class B, class C>
-    Segment<A,B,C>::Segment(const double default_length_,
-                            const WorldBuilder::Point<2> &default_thickness_,
-                            const WorldBuilder::Point<2> &default_top_truncation_,
-                            const WorldBuilder::Point<2> &default_angle_,
-                            const std::vector<std::shared_ptr<A> > temperature_systems_,
-                            const std::vector<std::shared_ptr<B> > composition_systems_,
-                            const std::vector<std::shared_ptr<C> > grains_systems_)
-      :
-      value_length(default_length_),
-      default_length(default_length_),
-      value_thickness(default_thickness_),
-      value_top_truncation(default_top_truncation_),
-      value_angle(default_angle_),
-      temperature_systems(std::move(temperature_systems_)),
-      composition_systems(std::move(composition_systems_)),
-      grains_systems(std::move(grains_systems_))
-    {
-    }
-
-    template<class A, class B, class C>
-    Segment<A,B,C>::Segment(Segment const &other)
-      :
-      value_length(other.value_length),
-      default_length(other.default_length),
-      value_thickness(other.value_thickness),
-      value_top_truncation(other.value_top_truncation),
-      value_angle(other.value_angle),
-      temperature_systems(other.temperature_systems),
-      composition_systems(other.composition_systems),
-      grains_systems(other.grains_systems)
-    {
-    }
-
-    template<class A, class B, class C>
-    Segment<A,B,C>::~Segment ()
-      = default;
-
-
-    /**
-    * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-    * Note that the variable with this name has to be loaded before this function is called.
-    */
-    template class
-    Segment<Features::SubductingPlateModels::Temperature::Interface,Features::SubductingPlateModels::Composition::Interface,Features::SubductingPlateModels::Grains::Interface>;
-
-    /**
-    * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-    * Note that the variable with this name has to be loaded before this function is called.
-    */
-    template class
-    Segment<Features::FaultModels::Temperature::Interface,Features::FaultModels::Composition::Interface,Features::FaultModels::Grains::Interface>;
-
-    /**
-    * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-    * Note that the variable with this name has to be loaded before this function is called.
-    */
-    //template class
-    //Segment<char,char>;
-
-  } // namespace Objects
-} // namespace WorldBuilder
\ No newline at end of file
diff --git a/contrib/world_builder/source/world_builder/objects/surface.cc.bak b/contrib/world_builder/source/world_builder/objects/surface.cc.bak
deleted file mode 100644
index e509703313c..00000000000
--- a/contrib/world_builder/source/world_builder/objects/surface.cc.bak
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/assert.h"
-#include "world_builder/objects/surface.h"
-
-#include <iostream>
-
-#include "delaunator-cpp/delaunator.hpp"
-
-
-namespace WorldBuilder
-{
-  namespace Objects
-  {
-
-    namespace
-    {
-      /**
-       * Test whether a point is in a triangle. If that is the case is stores the interpolated
-       * value of the triangle into `interpolated_value` and returns true.
-       */
-      bool in_triangle(const std::array<std::array<double,3>,3> &points,
-                       const std::array<double,8> &precomputed,
-                       const Point<2> &check_point,
-                       double &interpolate_value,
-                       double &interpolator_s,
-                       double &interpolator_t)
-      {
-        double factor = 1e4;
-        // based on https://stackoverflow.com/questions/2049582/how-to-determine-if-a-point-is-in-a-2d-triangle
-        // compute s, t and area
-        const double s_no_area = -(precomputed[0] + precomputed[1]*check_point[0] + precomputed[2]*check_point[1]);
-        const double t_no_area = -(precomputed[3] + precomputed[4]*check_point[0] + precomputed[5]*check_point[1]);
-
-        if (s_no_area >= -factor*std::numeric_limits<double>::epsilon() && t_no_area >= -factor*std::numeric_limits<double>::epsilon() && s_no_area+t_no_area-precomputed[6]<=precomputed[6]*factor*std::numeric_limits<double>::epsilon())
-          {
-            // point is in this triangle
-            interpolator_s = precomputed[7]*s_no_area;
-            interpolator_t = precomputed[7]*t_no_area;
-            interpolate_value = points[0][2]*(1-interpolator_s-interpolator_t)+points[1][2]*interpolator_s+points[2][2]*interpolator_t;
-            return true;
-          }
-        return false;
-      }
-    }
-
-    Surface::Surface()
-      = default;
-
-
-    Surface::Surface(std::pair<std::vector<double>,std::vector<double>> values_at_points)
-    {
-      // first find the min and max. This need always to be done;
-      WBAssertThrow(!values_at_points.first.empty(), "internal error: no values in values_at_points.first.");
-      minimum = values_at_points.first[0];
-      maximum = values_at_points.first[0];
-
-      for (const auto &value: values_at_points.first)
-        {
-          if (value < minimum)
-            {
-              minimum = value;
-            }
-          if (value > maximum)
-            {
-              maximum = value;
-            }
-        }
-
-      // if there are points defined there is not a constant value,
-      // if there are no points defined there is a constant value.
-      if (!values_at_points.second.empty())
-        {
-          constant_value = false;
-
-          // Next make the triangulation and the kd-tree.
-          // Feed the delaunator
-          delaunator::Delaunator triangulation(values_at_points.second);
-
-          // now loop over all the triangles and add them to the correct vectors
-          triangles.resize(triangulation.triangles.size()/3);
-          std::vector<KDTree::Node> node_list;
-          for (std::size_t i = 0; i < triangulation.triangles.size(); i+=3)
-            {
-              delaunator::Delaunator &t = triangulation;
-              // 1. We need to create a triangle list where each entry contains the coordinates
-              //    and value of the points of the triangle:
-              //    [[[x0,y0,v0],[x1,y1,v1],[x2,y2,v2]],[[x1,y1,v1],[x0,y0,v0],[x3,y3,v3]],...]
-              // 2. we need to compute the centeroid locations and add those to the KD-tree
-              //    with the index stored on the triangle list
-              triangles[i/3][0][0] = t.coords[2 * t.triangles[i]]; // tx0
-              triangles[i/3][0][1] = t.coords[2 * t.triangles[i]+1]; // ty0
-              triangles[i/3][0][2] = values_at_points.first[t.triangles[i]]; // v0
-              triangles[i/3][1][0] = t.coords[2 * t.triangles[i+1]]; // tx1
-              triangles[i/3][1][1] = t.coords[2 * t.triangles[i+1]+1]; // ty1
-              triangles[i/3][1][2] = values_at_points.first[t.triangles[i+1]]; // v1
-              triangles[i/3][2][0] = t.coords[2 * t.triangles[i+2]]; // tx2
-              triangles[i/3][2][1] = t.coords[2 * t.triangles[i+2]+1]; // ty2
-              triangles[i/3][2][2] = values_at_points.first[t.triangles[i+2]]; // v2
-
-              node_list.emplace_back(i/3,
-                                     (t.coords[2*t.triangles[i]]+t.coords[2*t.triangles[i+1]]+t.coords[2*t.triangles[i+2]])/3.,
-                                     (t.coords[2*t.triangles[i]+1]+t.coords[2*t.triangles[i+1]+1]+t.coords[2*t.triangles[i+2]+1])/3.);
-
-            }
-          // now feed and create the KD-tree
-          tree = KDTree::KDTree(node_list);
-          tree.create_tree(0, node_list.size()-1, false);
-
-
-          // precompute values for in_triangle
-          in_triangle_precomputed.resize(tree.get_nodes().size());
-          for (size_t iii = 0; iii < tree.get_nodes().size(); iii++)
-            {
-              in_triangle_precomputed[iii][0] = triangles[iii][0][1]*triangles[iii][2][0] - triangles[iii][0][0]*triangles[iii][2][1];
-              in_triangle_precomputed[iii][1] = triangles[iii][2][1] - triangles[iii][0][1];
-              in_triangle_precomputed[iii][2] = triangles[iii][0][0] - triangles[iii][2][0];
-              in_triangle_precomputed[iii][3] = triangles[iii][0][0]*triangles[iii][1][1] - triangles[iii][0][1]*triangles[iii][1][0];
-              in_triangle_precomputed[iii][4] = triangles[iii][0][1] - triangles[iii][1][1];
-              in_triangle_precomputed[iii][5] = triangles[iii][1][0] - triangles[iii][0][0];
-              in_triangle_precomputed[iii][6] = -(-triangles[iii][1][1]*triangles[iii][2][0] + triangles[iii][0][1]*(-triangles[iii][1][0] + triangles[iii][2][0]) + triangles[iii][0][0]*(triangles[iii][1][1] - triangles[iii][2][1]) + triangles[iii][1][0]*triangles[iii][2][1]);
-              in_triangle_precomputed[iii][7] = 1./in_triangle_precomputed[iii][6];
-            }
-        }
-      else
-        {
-          constant_value = true;
-        }
-
-    }
-
-    SurfaceValueInfo
-    Surface::local_value(const Point<2> &check_point) const
-    {
-      if (constant_value)
-        {
-          // just min and max are the same since it is constant. Just return min.
-          return minimum;
-        }
-      // first find the closest centeroids
-      const KDTree::IndexDistances index_distances = tree.find_closest_points(check_point);
-
-      // try triangle of the closest centroid
-      double interpolated_value = 0;
-      double interpolator_s = NaN::DQNAN;
-      double interpolator_t = NaN::DQNAN;
-
-      if (in_triangle(triangles[tree.get_nodes()[index_distances.min_index].index],in_triangle_precomputed[tree.get_nodes()[index_distances.min_index].index],check_point,interpolated_value,interpolator_s,interpolator_t))
-        {
-          return SurfaceValueInfo {tree.get_nodes()[index_distances.min_index].index,interpolated_value,interpolator_s,interpolator_t};
-        }
-
-      Point<2> other_point = check_point;
-      KDTree::IndexDistances index_distances_other;
-      const bool spherical = check_point.get_coordinate_system() == CoordinateSystem::spherical;
-      if (spherical)
-        {
-          other_point[0] += check_point[0] < 0 ? 2.0 * WorldBuilder::Consts::PI : -2.0 * WorldBuilder::Consts::PI;
-          index_distances_other = tree.find_closest_points(other_point);
-
-          if (in_triangle(triangles[tree.get_nodes()[index_distances_other.min_index].index],in_triangle_precomputed[tree.get_nodes()[index_distances_other.min_index].index],other_point,interpolated_value,interpolator_s,interpolator_t))
-            {
-              return SurfaceValueInfo {tree.get_nodes()[index_distances_other.min_index].index,interpolated_value,interpolator_s,interpolator_t};
-            }
-        }
-
-
-      {
-        // if not found go to closets nodes
-        // Todo: could remove the cosest node, because it was already tested. Could also sort based no distance.
-        for (const auto &index_distance: index_distances.vector)
-          {
-            if (in_triangle(triangles[tree.get_nodes()[index_distance.index].index],in_triangle_precomputed[tree.get_nodes()[index_distance.index].index],check_point,interpolated_value,interpolator_s,interpolator_t))
-              {
-                return SurfaceValueInfo {tree.get_nodes()[index_distance.index].index,interpolated_value,interpolator_s,interpolator_t};
-              }
-          }
-        if (spherical)
-          {
-            for (auto &index_distance: index_distances_other.vector)
-              {
-                if (in_triangle(triangles[tree.get_nodes()[index_distance.index].index],in_triangle_precomputed[tree.get_nodes()[index_distance.index].index],other_point,interpolated_value,interpolator_s,interpolator_t))
-                  {
-                    return SurfaceValueInfo {tree.get_nodes()[index_distance.index].index,interpolated_value,interpolator_s,interpolator_t};
-                  }
-              }
-          }
-
-        // if still not found, go through all nodes
-        // Todo: Although this shouldonly very rearly happen, could remove already tested nodes.
-        for (const auto &nodes: tree.get_nodes())
-          {
-            if (in_triangle(triangles[nodes.index],in_triangle_precomputed[nodes.index],check_point,interpolated_value,interpolator_s,interpolator_t))
-              {
-                return SurfaceValueInfo {nodes.index,interpolated_value,interpolator_s,interpolator_t};
-              }
-            if (spherical && in_triangle(triangles[nodes.index],in_triangle_precomputed[nodes.index],other_point,interpolated_value,interpolator_s,interpolator_t))
-              {
-                return SurfaceValueInfo {nodes.index,interpolated_value,interpolator_s,interpolator_t};
-              }
-          }
-        WBAssertThrow(false, "Internal error: The requested point was not in any triangle. "
-                      << "This could be due to rounding errors if the difference between the check point and triangle points are small, "
-                      << "or you are requesting a point outside the boundaries defined by the additional points. The check point was "
-                      << check_point[0] <<  ":" << check_point[1] << ".");
-      }
-      return 0;
-    }
-  } // namespace Objects
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/parameters.cc.bak b/contrib/world_builder/source/world_builder/parameters.cc.bak
deleted file mode 100644
index a7b1afc63b9..00000000000
--- a/contrib/world_builder/source/world_builder/parameters.cc.bak
+++ /dev/null
@@ -1,2229 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-
-#include "world_builder/features/continental_plate_models/composition/interface.h"
-#include "world_builder/features/continental_plate_models/grains/interface.h"
-#include "world_builder/features/continental_plate_models/temperature/interface.h"
-#include "world_builder/features/fault.h"
-#include "world_builder/features/mantle_layer_models/composition/interface.h"
-#include "world_builder/features/mantle_layer_models/grains/interface.h"
-#include "world_builder/features/mantle_layer_models/temperature/interface.h"
-#include "world_builder/features/oceanic_plate_models/composition/interface.h"
-#include "world_builder/features/oceanic_plate_models/grains/interface.h"
-#include "world_builder/features/oceanic_plate_models/temperature/interface.h"
-#include "world_builder/features/plume_models/composition/interface.h"
-#include "world_builder/features/plume_models/grains/interface.h"
-#include "world_builder/features/plume_models/temperature/interface.h"
-#include "world_builder/features/subducting_plate.h"
-#include "world_builder/gravity_model/interface.h"
-#include "world_builder/types/object.h"
-#include "world_builder/utilities.h"
-
-#include "rapidjson/error/en.h"
-#include "rapidjson/istreamwrapper.h"
-#include "rapidjson/latexwriter.h"
-#include "rapidjson/mystwriter.h"
-#include "rapidjson/prettywriter.h"
-
-#include <fstream>
-#include <memory>
-
-using namespace rapidjson;
-
-namespace
-{
-  void remove_key(rapidjson::Value &value, const char *key)
-  {
-    if (value.IsObject())
-      {
-        auto it = value.FindMember(key);
-        if (it != value.MemberEnd())
-          value.RemoveMember(it);
-
-        for (auto &member : value.GetObject())
-          remove_key(member.value, key);
-
-      }
-    else if (value.IsArray())
-      {
-        for (auto &element : value.GetArray())
-          remove_key(element, key);
-      }
-  }
-}
-
-namespace WorldBuilder
-{
-  Parameters::Parameters(World &world_)
-    :
-    world(world_)
-  {
-  }
-
-  Parameters::~Parameters()
-    = default;
-
-  void Parameters::initialize(std::string &filename, bool has_output_dir, const std::string &output_dir)
-  {
-
-    if (has_output_dir)
-      {
-        StringBuffer buffer;
-        std::ofstream file;
-
-        // write out json schema
-        file.open (output_dir + "world_builder_declarations.schema.json");
-        WBAssertThrow(file.is_open(), "Error: Could not open file '" + output_dir + "world_builder_declarations.schema.json' for string the json declarations.");
-        PrettyWriter<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> json_writer(buffer);
-        declarations.Accept(json_writer);
-        file << buffer.GetString();
-        file.close();
-        buffer.Clear();
-
-        // remove Snippets so they don't appear in the documentation:
-        remove_key(declarations, "defaultSnippets");
-
-        // write out declarations
-        file.open (output_dir + "world_builder_declarations.tex");
-        WBAssertThrow(file.is_open(), "Error: Could not open file '" + output_dir + "world_builder_declarations.tex' for string the tex declarations.");
-
-        LatexWriter<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> tex_writer(buffer);
-        declarations.Accept(tex_writer);
-        file << buffer.GetString();
-        file.close();
-        buffer.Clear();
-
-        // write out declarations (open)
-        file.open (output_dir + "world_builder_declarations_open.md");
-        WBAssertThrow(file.is_open(), "Error: Could not open file '" + output_dir + "world_builder_declarations_open.md' for string the tex declarations.");
-
-        MySTWriter<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> myst_writer_open(buffer, true);
-        declarations.Accept(myst_writer_open);
-        file << buffer.GetString();
-        file.close();
-        buffer.Clear();
-
-        // write out declarations (closed)
-        file.open (output_dir + "world_builder_declarations_closed.md");
-        WBAssertThrow(file.is_open(), "Error: Could not open file '" + output_dir + "world_builder_declarations_closed.md' for string the tex declarations.");
-
-        MySTWriter<StringBuffer, UTF8<>, UTF8<>, CrtAllocator, kWriteNanAndInfFlag> myst_writer_closed(buffer, false);
-        declarations.Accept(myst_writer_closed);
-        file << buffer.GetString();
-        file.close();
-        buffer.Clear();
-      }
-
-    path_level =0;
-    // Now read in the world builder file into a stringstream and
-    // put it into a the rapidjson document
-    std::stringstream json_input_stream(WorldBuilder::Utilities::read_and_distribute_file_content(filename));
-    rapidjson::IStreamWrapper isw(json_input_stream);
-
-    // relaxing syntax by allowing comments () for now, maybe also allow trailing commas and (kParseTrailingCommasFlag) and nan's, inf etc (kParseNanAndInfFlag)?
-    //WBAssertThrow(!parameters.ParseStream<kParseCommentsFlag>(isw).HasParseError(), "Parsing errors world builder file");
-
-    WBAssertThrowExc(!(parameters.ParseStream<kParseCommentsFlag | kParseNanAndInfFlag>(isw).HasParseError()), std::ifstream json_input_stream_error(filename.c_str()); ,
-                     "Parsing errors world builder file: Error(offset " << static_cast<unsigned>(parameters.GetErrorOffset())
-                     << "): " << GetParseError_En(parameters.GetParseError()) << std::endl << std::endl
-                     << " Showing 50 chars before and after: "
-                     << std::string((std::istreambuf_iterator<char>(json_input_stream_error.seekg(0, json_input_stream_error.beg))),
-                                    std::istreambuf_iterator<char>()).substr(static_cast<unsigned>(parameters.GetErrorOffset()) <= 50
-                                                                             ?
-                                                                             0
-                                                                             :
-                                                                             static_cast<unsigned>(parameters.GetErrorOffset()) - 50, 100
-                                                                            ) << std::endl << std::endl
-                     << " Showing 5 chars before and after: "
-                     << std::string((std::istreambuf_iterator<char>(json_input_stream_error.seekg(0, json_input_stream_error.beg))),
-                                    std::istreambuf_iterator<char>()).substr(static_cast<unsigned>(parameters.GetErrorOffset()) <= 5
-                                                                             ? 0
-                                                                             :
-                                                                             static_cast<unsigned>(parameters.GetErrorOffset())-5,
-                                                                             (static_cast<unsigned>(parameters.GetErrorOffset()) + 10 > json_input_stream_error.seekg(0,std::ios::end).tellg()
-                                                                              ?
-                                                                              static_cast<unsigned>(json_input_stream.tellg())-static_cast<unsigned>(parameters.GetErrorOffset())
-                                                                              :
-                                                                              10)
-                                                                            ));
-
-    WBAssertThrow(parameters.IsObject(), "World builder file is is not an object.");
-
-
-    const SchemaDocument schema(declarations);
-    SchemaValidator validator(schema);
-
-    if (!parameters.Accept(validator))
-      {
-        // Input JSON is invalid according to the schema
-        // Output diagnostic information
-        StringBuffer buffer;
-        std::stringstream string;
-        validator.GetInvalidSchemaPointer().StringifyUriFragment(buffer);
-        string << "Invalid schema: " << buffer.GetString() << std::endl;
-        string << "Invalid keyword: " << validator.GetInvalidSchemaKeyword();
-        buffer.Clear();
-        validator.GetInvalidDocumentPointer().StringifyUriFragment(buffer);
-        string << "Invalid schema: " << buffer.GetString() << std::endl;
-        PrettyWriter<StringBuffer> writer(buffer);
-        validator.GetError().Accept(writer);
-        WBAssertThrow(false, string.str() << "Error document: " << std::endl << buffer.GetString());
-      }
-  }
-
-  void
-  Parameters::declare_entry(const std::string &name,
-                            const Types::Interface &type,
-                            const std::string &documentation)
-  {
-    type.write_schema(*this,name,documentation);
-  }
-
-  bool
-  Parameters::check_entry(const std::string &name) const
-  {
-    return Pointer((this->get_full_json_path() + "/" + name).c_str()).Get(parameters) != nullptr;
-  }
-
-
-  template<>
-  std::string
-  Parameters::get(const std::string &name)
-  {
-    const std::string base = this->get_full_json_path();
-    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
-
-#ifdef debug
-    bool required = false;
-    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
-      {
-        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
-          {
-            if (v.GetString() == name)
-              {
-                required = true;
-              }
-          }
-      }
-
-    WBAssert(value != NULL || required == false,
-             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
-#endif
-    if (value == nullptr)
-      {
-        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << base + "/" + name + "/default value");
-      }
-
-    return value->GetString();
-  }
-
-  template<>
-  double
-  Parameters::get(const std::string &name)
-  {
-    const std::string base = this->get_full_json_path();
-    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
-
-#ifdef debug
-    bool required = false;
-    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
-      {
-        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
-          {
-            if (v.GetString() == name)
-              {
-                required = true;
-              }
-          }
-      }
-
-    WBAssert(value != NULL || required == false,
-             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
-#endif
-    if (value == nullptr)
-      {
-        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << get_full_json_schema_path() + "/" + name + "/default value, for value: " << base + "/" + name);
-      }
-
-    double return_value;
-    try
-      {
-        return_value = value->GetDouble();
-      }
-    catch (...)
-      {
-        WBAssertThrow(false, "Could not convert values of " << base << " into doubles.");
-      }
-    return return_value;
-  }
-
-  template<>
-  size_t
-  Parameters::get(const std::string &name)
-  {
-    const std::string base = this->get_full_json_path();
-    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
-
-#ifdef debug
-    bool required = false;
-    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
-      {
-        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
-          {
-            if (v.GetString() == name)
-              {
-                required = true;
-              }
-          }
-      }
-
-    WBAssert(value != NULL || required == false,
-             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
-#endif
-    if (value == nullptr)
-      {
-        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << base + "/" + name + "/default value");
-      }
-
-    return value->GetUint();
-  }
-
-  template<>
-  unsigned int
-  Parameters::get(const std::string &name)
-  {
-    const std::string base = this->get_full_json_path();
-    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
-
-#ifdef debug
-    bool required = false;
-    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
-      {
-        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
-          {
-            if (v.GetString() == name)
-              {
-                required = true;
-              }
-          }
-      }
-
-    WBAssert(value != NULL || required == false,
-             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
-#endif
-    if (value == nullptr)
-      {
-        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << base + "/" + name + "/default value");
-      }
-
-    return value->GetUint();
-  }
-
-  template<>
-  int
-  Parameters::get(const std::string &name)
-  {
-    const std::string base = this->get_full_json_path();
-    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
-
-#ifdef debug
-    bool required = false;
-    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
-      {
-        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
-          {
-            if (v.GetString() == name)
-              {
-                required = true;
-              }
-          }
-      }
-
-    WBAssert(value != NULL || required == false,
-             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
-#endif
-    if (value == nullptr)
-      {
-        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << base + "/" + name + "/default value");
-      }
-
-    return value->GetInt();
-  }
-
-  template<>
-  bool
-  Parameters::get(const std::string &name)
-  {
-    const std::string base = this->get_full_json_path();
-    const Value *value = Pointer((base + "/" + name).c_str()).Get(parameters);
-
-#ifdef debug
-    bool required = false;
-    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
-      {
-        for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
-          {
-            if (v.GetString() == name)
-              {
-                required = true;
-              }
-          }
-      }
-
-    WBAssert(value != NULL || required == false,
-             "Internal error: Value \"" << base << '/' << name << "/type\" not found in the input file, while it was set as required.");
-#endif
-    if (value == nullptr)
-      {
-        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << base + "/" + name + "/default value");
-      }
-
-    return value->GetBool();
-  }
-
-
-  template<>
-  Point<2>
-  Parameters::get(const std::string &name)
-  {
-
-    const std::string strict_base = this->get_full_json_path();
-    const Value *array = Pointer((strict_base + "/" + name).c_str()).Get(parameters);
-
-#ifdef debug
-    bool required = false;
-    if (Pointer((strict_base + "/required").c_str()).Get(declarations) != NULL)
-      {
-        for (auto &v : Pointer((strict_base + "/required").c_str()).Get(declarations)->GetArray())
-          {
-            if (v.GetString() == name)
-              {
-                required = true;
-              }
-          }
-      }
-
-    WBAssert(array != NULL || required == false,
-             "Internal error: Value \"" << strict_base << '/' << name << "/type\" not found in the input file, while it was set as required.");
-#endif
-    if (array != nullptr)
-      {
-        const std::string base = strict_base + "/" + name;
-        //let's assume that the file is correct, because it has been checked with the json schema.
-        // So there are exactly two values.
-        double value1;
-        double value2;
-
-        try
-          {
-            value1 = Pointer((base + "/0").c_str()).Get(parameters)->GetDouble();
-            value2 = Pointer((base + "/1").c_str()).Get(parameters)->GetDouble();
-          }
-        catch (...)
-          {
-            WBAssertThrow(false, "Could not convert values of " << base << " into Point<2>, because it could not convert the sub-elements into doubles.");
-          }
-        return Point<2>(value1,value2,this->coordinate_system->natural_coordinate_system());
-      }
-    WBAssertThrow(false, "default values not implemented in get<Point<2> >. Looked in: " + strict_base + "/" << name);
-
-    return {invalid};;
-  }
-
-  template<>
-  std::vector<bool>
-  Parameters::get_vector(const std::string &name)
-  {
-    std::vector<bool> vector;
-    const std::string strict_base = this->get_full_json_path();
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-        for (size_t i = 0; i < array->Size(); ++i )
-          {
-            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-
-            vector.push_back(Pointer(base.c_str()).Get(parameters)->GetBool());
-          }
-      }
-    else
-      {
-        const Value *value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/minItems").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the minItems value at: "
-                      << this->get_full_json_schema_path() + "/" + name + "/minItems value");
-
-        const size_t min_size = value->GetUint();
-
-        const bool default_value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/items/default value").c_str()).Get(declarations)->GetBool();
-
-        // set to min size
-        for (size_t i = 0; i < min_size; ++i)
-          {
-            vector.push_back(default_value);
-          }
-      }
-    return vector;
-  }
-
-
-  std::pair<std::vector<double>,std::vector<double>>
-                                                  Parameters::get(const std::string &name,
-                                                                  const std::vector<Point<2> > &addition_points)
-  {
-    // There are four cases:
-    // 1. No value provided: use the default value everywhere. Return first with one value and second with size 0.
-    // 2. One double provided: use the default value everywhere. Return first with one value and second with size 0.
-    // 3. One value in a double array and no points provided: use that value everywhere. Return first with one value and second with size 0.
-    // 4. Other: fill the vectors with the default value and addition points and then add new point.
-    //    If a value without points is encountered, the additional points are used.
-    std::pair<std::vector<double>,std::vector<double>> result;
-
-    const std::string strict_base = this->get_full_json_path();
-
-    // start with adding the additional points with the default value
-    // to do this we need the default value
-    double default_value = 0;
-    bool is_array = true;
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr && Pointer((strict_base + "/" + name).c_str()).Get(parameters)->IsArray())
-      {
-        const std::string value_def_path = get_full_json_schema_path() + "/" + name + "/oneOf/1/items/items/anyOf/0/default value";
-        Value *value_def = Pointer(value_def_path.c_str()).Get(declarations);
-        WBAssertThrow(value_def != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << value_def_path);
-
-        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
-        // So no try/catch needed.
-        default_value = value_def->GetDouble();
-      }
-    else
-      {
-        is_array = false;
-        Value *value_def = Pointer((get_full_json_schema_path() + "/" + name + "/oneOf/0/default value").c_str()).Get(declarations);
-        WBAssertThrow(value_def != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      <<get_full_json_schema_path() + "/" + name + "/oneOf/0/default value");
-
-
-        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
-        // So no try/catch needed.
-        default_value = value_def->GetDouble();
-      }
-
-
-    // check if there is a user defined value
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        // there is a user defined value, so either case 2, 3 or 4.
-        if (is_array)
-          {
-            Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-            if (array->Size() == 1
-                && Pointer((strict_base + "/" + name + "/0/1").c_str()).Get(parameters) == nullptr)
-              {
-                // case 2: Return first with one value and second with size 0.
-                double value = 0;
-                try
-                  {
-                    value = Pointer((strict_base + "/" + name + "/0/0").c_str()).Get(parameters)->GetDouble();
-                  }
-                catch (...)
-                  {
-                    WBAssertThrow(false, "Could not convert values of " << strict_base << "/" << name << "/0/0 into a double. "
-                                  << "The provided value was \"" <<  Pointer((strict_base + "/" + name + "/0/0").c_str()).Get(parameters)->GetString() << "\".");
-                  }
-                result.first.emplace_back(value);
-              }
-            else
-              {
-                // case 3: fill the vectors with the default value and addition points and then add new point.
-                //         If a value without points is encountered, the additional points are used.
-
-                // first fill with additional points at default value
-                for (const auto &addition_point : addition_points)
-                  {
-                    result.first.emplace_back(default_value);
-                    result.second.emplace_back(addition_point[0]);
-                    result.second.emplace_back(addition_point[1]);
-                  }
-
-                // second, go through all the points in order
-                for (size_t i = 0; i < array->Size(); ++i )
-                  {
-                    // now parse a single value_at_point.
-                    const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-                    // Let's assume that the file is correct, because it has been checked with the json schema.
-                    // So there are exactly two values, the first value is a double, the second an array of 2d arrays (points).
-
-                    // Get the double
-                    double value;
-                    Value *value_pointer = Pointer((base + "/0").c_str()).Get(parameters);
-
-                    WBAssertThrow(value_pointer != nullptr, "internal error: this should not happen.");
-
-                    try
-                      {
-                        value = value_pointer->GetDouble();
-                      }
-                    catch (...)
-                      {
-                        WBAssertThrow(false, "Could not convert values of " << base << "/0 into doubles. "
-                                      << "The provided value was \"" <<  Pointer((base + "/0").c_str()).Get(parameters)->GetString() << "\".");
-                      }
-
-                    // now get the array of points.
-                    Value *coordinates_array = Pointer((base + "/1").c_str()).Get(parameters);
-                    if (coordinates_array != nullptr)
-                      {
-                        for (size_t coordinate_i = 0; coordinate_i < coordinates_array->Size(); ++coordinate_i )
-                          {
-                            // Let's assume that the file is correct, because it has been checked with the json schema.
-                            // That means that there are exactly two values per item
-                            double coordinate_0;
-                            double coordinate_1;
-                            try
-                              {
-                                coordinate_0 = Pointer((base + "/1/" + std::to_string(coordinate_i) + "/0").c_str()).Get(parameters)->GetDouble();
-                              }
-                            catch (...)
-                              {
-                                WBAssertThrow(false, "Could not convert values of " << base + "/1/" + std::to_string(coordinate_i) + "/0"
-                                              << " into a Point<2> array, because it could not convert the 1st sub-elements into doubles. "
-                                              << "The provided value was \""
-                                              <<  Pointer((base + "/1/" + std::to_string(coordinate_i) + "/0").c_str()).Get(parameters)->GetString()
-                                              << "\".");
-                              }
-                            try
-                              {
-                                coordinate_1 = Pointer((base + "/1/" + std::to_string(coordinate_i) + "/1").c_str()).Get(parameters)->GetDouble();
-                              }
-                            catch (...)
-                              {
-                                WBAssertThrow(false, "Could not convert values of " << base + "/1/" + std::to_string(coordinate_i) + "/1"
-                                              << " into a Point<2> array, because it could not convert the 2nd sub-elements into doubles. "
-                                              << "The provided value was \""
-                                              <<  Pointer((base + "/1/" + std::to_string(coordinate_i) + "/1").c_str()).Get(parameters)->GetString()
-                                              << "\".");
-                              }
-
-                            coordinate_0 *= (coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical ? Consts::PI / 180.0 : 1.);
-                            coordinate_1 *= (coordinate_system->natural_coordinate_system() == CoordinateSystem::spherical ? Consts::PI / 180.0 : 1.);
-
-                            bool found_same_point = false;
-                            unsigned int coordinate_pair_i = 0;
-                            for (; coordinate_pair_i < result.second.size(); coordinate_pair_i+=2)
-                              {
-                                if (Utilities::approx(result.second[coordinate_pair_i],coordinate_0) && Utilities::approx(result.second[coordinate_pair_i+1],coordinate_1))
-                                  {
-                                    found_same_point = true;
-                                    break;
-                                  }
-                              }
-                            if (found_same_point)
-                              {
-                                // set the value to the new value
-                                result.first[coordinate_pair_i/2] = value;
-                              }
-                            else
-                              {
-                                // add a new point
-                                result.first.emplace_back(value);
-                                result.second.emplace_back(coordinate_0);
-                                result.second.emplace_back(coordinate_1);
-                              }
-                          }
-
-                      }
-                    else
-                      {
-                        // no points are provided, so use the value to fill put in the additional points
-                        // at that value. Since we know that all the additional points are at the start
-                        // we can easily overwrite the values.
-                        for (unsigned int addition_point_i = 0; addition_point_i < addition_points.size(); ++addition_point_i)
-                          {
-                            result.first[addition_point_i] = value;
-                          }
-                      }
-                  }
-              }
-          }
-        else
-          {
-            // case 2: there one value, not an array
-            double value = 0;
-            try
-              {
-                value = Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetDouble();
-              }
-            catch (...)
-              {
-                WBAssertThrow(false, "Could not convert values of " << strict_base << "/" << name << " into a double. "
-                              << "The provided value was \"" <<  Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetString() << "\".");
-              }
-            result.first.emplace_back(value);
-          }
-      }
-    else
-      {
-        // there is no user defined value. Case one: return the default value and no points
-        result.first.emplace_back(default_value);
-      }
-
-    return result;
-  }
-
-
-  std::pair<std::vector<double>,std::vector<double>> Parameters::get_value_at_array(const std::string &name)
-  {
-    // There are two cases:
-    // 1. One double provided: use the default value everywhere. Return first with one value and second with size 0.
-    // 2. Other: fill the vectors with the default value and addition points and then add new point.
-    //    If a value without points is encountered, the additional points are used.
-    std::pair<std::vector<double>,std::vector<double>> result;
-
-    const std::string strict_base = this->get_full_json_path();
-
-    // start with adding the additional points with the default value
-    // to do this we need the default value
-    double default_value = 0;
-    bool is_array = true;
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr && Pointer((strict_base + "/" + name).c_str()).Get(parameters)->IsArray())
-      {
-        const std::string value_def_path = get_full_json_schema_path() + "/" + name + "/oneOf/1/items/items/anyOf/0/default value";
-        Value *value_def = Pointer(value_def_path.c_str()).Get(declarations);
-        WBAssertThrow(value_def != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << value_def_path);
-
-        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
-        // So no try/catch needed.
-        default_value = value_def->GetDouble();
-      }
-    else
-      {
-        is_array = false;
-        Value *value_def = Pointer((get_full_json_schema_path() + "/" + name + "/oneOf/0/default value").c_str()).Get(declarations);
-        WBAssertThrow(value_def != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      <<get_full_json_schema_path() + "/" + name + "/oneOf/0/default value");
-
-
-        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
-        // So no try/catch needed.
-        default_value = value_def->GetDouble();
-      }
-
-
-    // check if there is a user defined value
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        // there is a user defined value, so either case 2, 3 or 4.
-        if (is_array)
-          {
-            Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-            // go through all the points in order
-            for (size_t i = 0; i < array->Size(); ++i )
-              {
-                // now parse a single value_at_point.
-                const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-                // Let's assume that the file is correct, because it has been checked with the json schema.
-                // So there are exactly two values, the first value is a double, the second an array of 2d arrays (points).
-
-                // Get the double
-                double value;
-                Value *value_pointer = Pointer((base + "/0").c_str()).Get(parameters);
-
-                WBAssertThrow(value_pointer != nullptr, "internal error: this should not happen.");
-
-                try
-                  {
-                    value = value_pointer->GetDouble();
-                  }
-                catch (...)
-                  {
-                    WBAssertThrow(false, "Could not convert values of " << base << "/0 into doubles. "
-                                  << "The provided value was \"" <<  Pointer((base + "/0").c_str()).Get(parameters)->GetString() << "\".");
-                  }
-
-                // now get the array of points.
-                Value *array_of_doubles = Pointer((base + "/1").c_str()).Get(parameters);
-                double value_in_array;
-                if (array_of_doubles != nullptr)
-                  {
-                    for (size_t coordinate_i = 0; coordinate_i < array_of_doubles->Size(); ++coordinate_i )
-                      {
-                        Value *coordinate_j_array = Pointer((base + "/1/" + std::to_string(coordinate_i)).c_str()).Get(parameters);
-                        for (size_t coordinate_j = 0; coordinate_j < coordinate_j_array->Size(); ++coordinate_j)
-                          {
-                            // Let's assume that the file is correct, because it has been checked with the json schema.
-                            // That means that there are exactly two values per item
-                            try
-                              {
-                                value_in_array = Pointer((base + "/1/" + std::to_string(coordinate_i) + "/" + std::to_string(coordinate_j)).c_str()).Get(parameters)->GetDouble();
-                              }
-                            catch (...)
-                              {
-                                WBAssertThrow(false, "Could not convert values of " << base + "/1/" + std::to_string(coordinate_i) + "/" + std::to_string(coordinate_j)
-                                              << " into a Point<2> array, because it could not convert the 1st sub-elements into doubles. "
-                                              << "The provided value was \""
-                                              <<  Pointer((base + "/1/" + std::to_string(coordinate_i) + "/" + std::to_string(coordinate_j)).c_str()).Get(parameters)->GetString()
-                                              << "\".");
-                              }
-
-                            result.second.emplace_back(value_in_array);
-                          }
-                      }
-                    result.first.emplace_back(value);
-                  }
-              }
-          }
-        else
-          {
-            // case 1: there one value, not an array
-            double value = 0;
-            try
-              {
-                value = Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetDouble();
-              }
-            catch (...)
-              {
-                WBAssertThrow(false, "Could not convert values of " << strict_base << "/" << name << " into a double. "
-                              << "The provided value was \"" <<  Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetString() << "\".");
-              }
-            result.first.emplace_back(0.0);
-            result.second.emplace_back(value);
-          }
-      }
-    else
-      {
-        // there is no user defined value. Case one: return the default value and no points
-        result.first.emplace_back(0.0);
-        result.second.emplace_back(default_value);
-      }
-
-    return result;
-  }
-
-
-  template<>
-  std::vector<Point<2> >
-  Parameters::get_vector(const std::string &name)
-  {
-    std::vector<Point<2> > vector;
-    const std::string strict_base = this->get_full_json_path();
-    WBAssertThrow(Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr,"Error: " << name
-                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
-
-    Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-    for (size_t i = 0; i < array->Size(); ++i )
-      {
-        const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-        //let's assume that the file is correct, because it has been checked with the json schema.
-        // So there are exactly two values.
-        double value1;
-        double value2;
-
-        try
-          {
-            value1 = Pointer((base + "/0").c_str()).Get(parameters)->GetDouble();
-            value2 = Pointer((base + "/1").c_str()).Get(parameters)->GetDouble();
-          }
-        catch (...)
-          {
-            WBAssertThrow(false, "Could not convert values of " << base << " into a Point<2> array, because it could not convert the sub-elements into doubles.");
-          }
-        vector.emplace_back(value1,value2,this->coordinate_system->natural_coordinate_system());
-      }
-
-    return vector;
-  }
-
-  template<>
-  std::vector<std::array<double,3> >
-  Parameters::get_vector(const std::string &name)
-  {
-    std::vector<std::array<double,3> > vector;
-    const std::string strict_base = this->get_full_json_path();
-    WBAssertThrow(Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr,"Error: " << name
-                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
-
-    Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-    for (size_t i = 0; i < array->Size(); ++i )
-      {
-        const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-        //let's assume that the file is correct, because it has been checked with the json schema.
-        // So there are exactly three values.
-        try
-          {
-            const double value1 = Pointer((base + "/0").c_str()).Get(parameters)->GetDouble();
-            const double value2 = Pointer((base + "/1").c_str()).Get(parameters)->GetDouble();
-            const double value3 = Pointer((base + "/2").c_str()).Get(parameters)->GetDouble();
-            vector.push_back({{value1,value2,value3}});
-          }
-        catch (...)
-          {
-            WBAssertThrow(false, "Could not convert values of " << base << " into doubles.");
-          }
-      }
-
-
-    return vector;
-  }
-
-  std::vector<std::vector<double>>
-                                Parameters::get_vector_or_double(const std::string &name)
-  {
-    // There are two cases:
-    // 1. One double provided: use the default value everywhere. Return first with one value and second with size 0.
-    // 2. std::vector<std::vector<double>> provided: output this array.
-    std::vector<std::vector<double>> result;
-
-    const std::string strict_base = this->get_full_json_path();
-
-    // start with adding the additional points with the default value
-    // to do this we need the default value
-    double default_value = 0;
-    bool is_array = true;
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr && Pointer((strict_base + "/" + name).c_str()).Get(parameters)->IsArray())
-      {
-        const std::string value_def_path = get_full_json_schema_path() + "/" + name + "/oneOf/1/items/items/default value";
-        Value *value_def = Pointer(value_def_path.c_str()).Get(declarations);
-        WBAssertThrow(value_def != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << value_def_path);
-
-        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
-        // So no try/catch needed.
-        default_value = value_def->GetDouble();
-      }
-    else
-      {
-        is_array = false;
-        Value *value_def = Pointer((get_full_json_schema_path() + "/" + name + "/oneOf/0/default value").c_str()).Get(declarations);
-        WBAssertThrow(value_def != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      <<get_full_json_schema_path() + "/" + name + "/oneOf/0/default value");
-
-
-        // Since the default value is set in the code, if it fails it is an internal error, not a user error.
-        // So no try/catch needed.
-        default_value = value_def->GetDouble();
-      }
-
-
-    // check if there is a user defined value
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        // there is a user defined value, so either case 2, 3 or 4.
-        if (is_array)
-          {
-            Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-            // go through all the 1d-arrays within the 2d-array
-            for (size_t i = 0; i < array->Size(); ++i )
-              {
-                // now parse a single value_at_point.
-                const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-
-                // now get the array of points.
-                // Value *coordinates_array = Pointer((base + "/0").c_str()).Get(parameters);
-                Value *coordinates_array = Pointer((base).c_str()).Get(parameters);
-                double value_in_array;
-                std::vector<double> array_of_values;
-                if (coordinates_array != nullptr)
-                  {
-                    for (size_t coordinate_i = 0; coordinate_i < coordinates_array->Size(); ++coordinate_i )
-                      {
-                        // Let's assume that the file is correct, because it has been checked with the json schema.
-                        // That means that there are exactly two values per item
-                        try
-                          {
-                            value_in_array = Pointer(((base + "/") + std::to_string(coordinate_i)).c_str()).Get(parameters)->GetDouble();
-                          }
-                        catch (...)
-                          {
-                            WBAssertThrow(false, "Could not convert values of " << base + "/" + std::to_string(i) + "/" + std::to_string(coordinate_i) + "/" + std::to_string(coordinate_i)
-                                          << " into a Point<2> array, because it could not convert the 1st sub-elements into doubles. "
-                                          << "The provided value was \""
-                                          <<  Pointer((base + "/" + std::to_string(i) + "/" + std::to_string(coordinate_i)).c_str()).Get(parameters)->GetString()
-                                          << "\".");
-                          }
-                        array_of_values.emplace_back(value_in_array);
-                      }
-                    result.emplace_back(array_of_values);
-
-                  }
-              }
-          }
-        else
-          {
-            // case 1: there's one value, not an array
-            double value = 0;
-            try
-              {
-                value = Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetDouble();
-              }
-            catch (...)
-              {
-                WBAssertThrow(false, "Could not convert values of " << strict_base << "/" << name << " into a double. "
-                              << "The provided value was \"" <<  Pointer((strict_base + "/" + name).c_str()).Get(parameters)->GetString() << "\".");
-              }
-            result.emplace_back(std::vector<double> {value});
-          }
-      }
-    else
-      {
-        // there is no user defined value. Case one: return the default value and no points
-        result.emplace_back(std::vector<double> {default_value});
-      }
-
-    return result;
-  }
-
-
-
-  template<>
-  std::vector<std::array<std::array<double,3>,3> >
-  Parameters::get_vector(const std::string &name)
-  {
-    std::vector<std::array<std::array<double,3>,3>  > vector;
-    const std::string strict_base = this->get_full_json_path();
-    WBAssertThrow(Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr,"Error: " << name
-                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
-
-    Value *array1 = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-    for (size_t i = 0; i < array1->Size(); ++i )
-      {
-        const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-        Value *array2 = Pointer((base).c_str()).Get(parameters);
-
-        // Not sure why cppcheck it is generating the warning
-        // Filed a question at: https://sourceforge.net/p/cppcheck/discussion/general/thread/429759f85e/
-        // cppcheck-suppress constStatement
-        std::array<std::array<double,3>,3> array;
-        WBAssertThrow(array2->Size() == 3, "Array " << i << " is supposed to be a 3x3 array, but the outer array dimensions is "
-                      << array2->Size() << '.');
-        for (size_t j = 0; j < array2->Size(); ++j )
-          {
-            const std::string base_extended = base + "/" + std::to_string(j);
-
-            WBAssertThrow(Pointer((base_extended).c_str()).Get(parameters)->Size() == 3,
-                          "Array " << i << " is supposed to be a 3x3 array, but the inner array dimensions of "
-                          << j << " is " << Pointer((base_extended).c_str()).Get(parameters)->Size() << '.');
-            double value1;
-            double value2;
-            double value3;
-
-            try
-              {
-                value1 = Pointer((base_extended + "/0").c_str()).Get(parameters)->GetDouble();
-                value2 = Pointer((base_extended + "/1").c_str()).Get(parameters)->GetDouble();
-                value3 = Pointer((base_extended + "/2").c_str()).Get(parameters)->GetDouble();
-              }
-            catch (...)
-              {
-                WBAssertThrow(false, "Could not convert values of " << base << " into doubles.");
-              }
-            array[j][0] = value1;
-            array[j][1] = value2;
-            array[j][2] = value3;
-          }
-        vector.push_back(array);
-      }
-
-    return vector;
-  }
-
-
-  template<>
-  std::vector<std::vector<Point<2> > >
-  Parameters::get_vector(const std::string &name)
-  {
-    std::vector<std::vector<Point<2> >  > vector;
-    const std::string strict_base = this->get_full_json_path();
-    WBAssertThrow(Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr,"Error: " << name
-                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
-
-    Value *array1 = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-    for (size_t i = 0; i < array1->Size(); ++i )
-      {
-        const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-        Value *array2 = Pointer((base).c_str()).Get(parameters);
-
-        // Not sure why cppcheck it is generating the warning
-        // Filed a question at: https://sourceforge.net/p/cppcheck/discussion/general/thread/429759f85e/
-        // cppcheck-suppress constStatement
-        std::vector<Point<2> > sub_vector(array2->Size(),Point<2>(NaN::DSNAN,NaN::DSNAN,coordinate_system->natural_coordinate_system()));
-        for (size_t j = 0; j < array2->Size(); ++j )
-          {
-            const std::string base_extended = base + "/" + std::to_string(j);
-
-            WBAssertThrow(Pointer((base_extended).c_str()).Get(parameters)->Size() == 2,
-                          "Array " << i << " is supposed to be a 2d point, but the inner array dimensions of "
-                          << j << " is " << Pointer((base_extended).c_str()).Get(parameters)->Size() << '.');
-            double value1;
-            double value2;
-
-            try
-              {
-                value1 = Pointer((base_extended + "/0").c_str()).Get(parameters)->GetDouble();
-                value2 = Pointer((base_extended + "/1").c_str()).Get(parameters)->GetDouble();
-              }
-            catch (...)
-              {
-                WBAssertThrow(false, "Could not convert values of " << base << " into doubles, because it could not covert the sub-elements into doubles.");
-              }
-            sub_vector[j][0] = value1;
-            sub_vector[j][1] = value2;
-          }
-        vector.push_back(sub_vector);
-      }
-
-    return vector;
-  }
-
-
-  template<>
-  std::vector<Objects::Segment<Features::SubductingPlateModels::Temperature::Interface,
-      Features::SubductingPlateModels::Composition::Interface,
-      Features::SubductingPlateModels::Grains::Interface> >
-      Parameters::get_vector(const std::string &name,
-                             std::vector<std::shared_ptr<Features::SubductingPlateModels::Temperature::Interface> > &default_temperature_models,
-                             std::vector<std::shared_ptr<Features::SubductingPlateModels::Composition::Interface> > &default_composition_models,
-                             std::vector<std::shared_ptr<Features::SubductingPlateModels::Grains::Interface> > &default_grains_models)
-  {
-    using namespace Features::SubductingPlateModels;
-    std::vector<Objects::Segment<Temperature::Interface,Composition::Interface,Grains::Interface> > vector;
-    this->enter_subsection(name);
-    const std::string strict_base = this->get_full_json_path();
-    WBAssertThrow(Pointer((strict_base).c_str()).Get(parameters) != nullptr,"Error: " << name
-                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
-
-    // get the array of segments
-    Value *array = Pointer((strict_base).c_str()).Get(parameters);
-
-    for (size_t i = 0; i < array->Size(); ++i )
-      {
-        this->enter_subsection(std::to_string(i));
-        const std::string base = this->get_full_json_path();
-        // get one segment
-        // length
-        const double length = Pointer((base + "/length").c_str()).Get(parameters)->GetDouble();
-
-        // get thickness
-        Value *point_array = Pointer((base  + "/thickness").c_str()).Get(parameters);
-        Point<2> thickness(invalid);
-        WBAssertThrow(point_array != nullptr,"error: " << name
-                      << " was not defined in " << strict_base << "/thickness, schema path: " << this->get_full_json_schema_path() << "/thickness.");
-
-        if (point_array->Size() == 1)
-          {
-            // There is only one value, set it for both elements
-            const double local0 = Pointer((base + "/thickness/0").c_str()).Get(parameters)->GetDouble();
-            thickness = Point<2>(local0,local0,invalid);
-          }
-        else
-          {
-            const double local0 = Pointer((base + "/thickness/0").c_str()).Get(parameters)->GetDouble();
-            const double local1 = Pointer((base + "/thickness/1").c_str()).Get(parameters)->GetDouble();
-            thickness = Point<2>(local0,local1,invalid);
-          }
-
-
-        // get top truncation (default is 0,0)
-        point_array = Pointer((base  + "/top truncation").c_str()).Get(parameters);
-        Point<2> top_truncation(invalid);
-        if (point_array != nullptr)
-          {
-            if (point_array->Size() == 1)
-              {
-                // There is only one value, set it for both elements
-                const double local0 = Pointer((base + "/top truncation/0").c_str()).Get(parameters)->GetDouble();
-                top_truncation = Point<2>(local0,local0,invalid);
-              }
-            else
-              {
-                const double local0 = Pointer((base + "/top truncation/0").c_str()).Get(parameters)->GetDouble();
-                const double local1 = Pointer((base + "/top truncation/1").c_str()).Get(parameters)->GetDouble();
-                top_truncation = Point<2>(local0,local1,invalid);
-              }
-          }
-        // get thickness
-        point_array = Pointer((base  + "/angle").c_str()).Get(parameters);
-        Point<2> angle(invalid);
-        WBAssertThrow(point_array != nullptr,"error: " << name
-                      << " was not defined in " << strict_base << "/angle, schema path: " << this->get_full_json_schema_path() << "/angle.");
-
-        if (point_array->Size() == 1)
-          {
-            // There is only one value, set it for both elements
-            const double local0 = Pointer((base + "/angle/0").c_str()).Get(parameters)->GetDouble();
-            angle = Point<2>(local0,local0,invalid);
-          }
-        else
-          {
-            const double local0 = Pointer((base + "/angle/0").c_str()).Get(parameters)->GetDouble();
-            const double local1 = Pointer((base + "/angle/1").c_str()).Get(parameters)->GetDouble();
-            angle = Point<2>(local0,local1,invalid);
-          }
-
-
-        // Get temperature models
-        std::vector<std::shared_ptr<Temperature::Interface> > temperature_models;
-
-        //This is a value to look back in the path elements.
-        size_t searchback = 0;
-        if (!this->get_shared_pointers<Temperature::Interface>("temperature models", temperature_models) ||
-            Pointer((base + "/temperature model default entry").c_str()).Get(parameters) != nullptr)
-          {
-            temperature_models = default_temperature_models;
-
-            // find the default value, which is the closest to the current path
-            for (searchback = 0; searchback < path.size(); ++searchback)
-              {
-                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Get(parameters) != nullptr)
-                  {
-                    break;
-                  }
-              }
-
-            // if we can not find default value for the temperature model, skip it
-            if (searchback < path.size())
-              {
-
-                // copy the value, this unfortunately removes it.
-                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Get(parameters)->GetArray());
-
-                // now copy it
-                Value value2;
-                value2.CopyFrom(value1, parameters.GetAllocator());
-
-                // now we should have 2x the same value, so put it back and place it in the correct location.
-                Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
-
-                Pointer((base).c_str()).Get(parameters)->AddMember("temperature models", value2, parameters.GetAllocator());
-                Pointer((base + "/temperature model default entry").c_str()).Set(parameters,true);
-              }
-          }
-
-        // now do the same for compositions
-        std::vector<std::shared_ptr<Composition::Interface> > composition_models;
-        if (!this->get_shared_pointers<Composition::Interface>("composition models", composition_models) ||
-            Pointer((base + "/composition model default entry").c_str()).Get(parameters) != nullptr)
-          {
-            composition_models = default_composition_models;
-
-
-            // find the default value, which is the closest to the current path
-            for (searchback = 0; searchback < path.size(); ++searchback)
-              {
-                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Get(parameters) != nullptr)
-                  {
-                    break;
-                  }
-              }
-
-            // if we can not find default value for the temperature model, skip it
-            if (searchback < path.size())
-              {
-
-                // copy the value, this unfortunately removes it.
-                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Get(parameters)->GetArray());
-
-                // now copy it
-                Value value2;
-                value2.CopyFrom(value1, parameters.GetAllocator());
-
-                // now we should have 2x the same value, so put it back and place it in the correct location.
-                Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
-
-                Pointer((base).c_str()).Get(parameters)->AddMember("composition models", value2, parameters.GetAllocator());
-                Pointer((base + "/composition model default entry").c_str()).Set(parameters,true);
-              }
-          }
-
-        // now do the same for grains
-        std::vector<std::shared_ptr<Grains::Interface> > grains_models;
-        if (!this->get_shared_pointers<Grains::Interface>("grains models", grains_models) ||
-            Pointer((base + "/grains model default entry").c_str()).Get(parameters) != nullptr)
-          {
-            grains_models = default_grains_models;
-
-
-            // find the default value, which is the closest to the current path
-            for (searchback = 0; searchback < path.size(); ++searchback)
-              {
-                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Get(parameters) != nullptr)
-                  {
-                    break;
-                  }
-              }
-
-            // if we can not find default value for the temperature model, skip it
-            if (searchback < path.size())
-              {
-
-                // copy the value, this unfortunately removes it.
-                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Get(parameters)->GetArray());
-
-                // now copy it
-                Value value2;
-                value2.CopyFrom(value1, parameters.GetAllocator());
-
-                // now we should have 2x the same value, so put it back and place it in the correct location.
-                Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
-
-                Pointer((base).c_str()).Get(parameters)->AddMember("grains models", value2, parameters.GetAllocator());
-                Pointer((base + "/grains model default entry").c_str()).Set(parameters,true);
-              }
-          }
-        vector.emplace_back(length, thickness, top_truncation, angle, temperature_models, composition_models, grains_models);
-
-        this->leave_subsection();
-      }
-
-    this->leave_subsection();
-    return vector;
-  }
-
-
-  template<>
-  std::vector<Objects::Segment<Features::FaultModels::Temperature::Interface,Features::FaultModels::Composition::Interface, Features::FaultModels::Grains::Interface> >
-  Parameters::get_vector(const std::string &name,
-                         std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> > &default_temperature_models,
-                         std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface> > &default_composition_models,
-                         std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface> > &default_grains_models)
-  {
-    using namespace Features::FaultModels;
-    std::vector<Objects::Segment<Temperature::Interface,Composition::Interface,Grains::Interface> > vector;
-    this->enter_subsection(name);
-    const std::string strict_base = this->get_full_json_path();
-    WBAssertThrow(Pointer((strict_base).c_str()).Get(parameters) != nullptr,"error: " << name
-                  << " was not defined in " << strict_base << ", schema path: " << this->get_full_json_schema_path() << ".");
-
-    // get the array of segments
-    Value *array = Pointer((strict_base).c_str()).Get(parameters);
-
-    for (size_t i = 0; i < array->Size(); ++i )
-      {
-        this->enter_subsection(std::to_string(i));
-        const std::string base = this->get_full_json_path();
-        // get one segment
-        // length
-        const double length = Pointer((base + "/length").c_str()).Get(parameters)->GetDouble();
-
-        // get thickness
-        Value *point_array = Pointer((base  + "/thickness").c_str()).Get(parameters);
-        Point<2> thickness(invalid);
-        WBAssertThrow(point_array != nullptr,"error: " << name
-                      << " was not defined in " << strict_base << "/thickness, schema path: " << this->get_full_json_schema_path() << "/thickness.");
-
-        if (point_array->Size() == 1)
-          {
-            // There is only one value, set it for both elements
-            const double local0 = Pointer((base + "/thickness/0").c_str()).Get(parameters)->GetDouble();
-            thickness = Point<2>(local0,local0,invalid);
-          }
-        else
-          {
-            const double local0 = Pointer((base + "/thickness/0").c_str()).Get(parameters)->GetDouble();
-            const double local1 = Pointer((base + "/thickness/1").c_str()).Get(parameters)->GetDouble();
-            thickness = Point<2>(local0,local1,invalid);
-          }
-
-
-        // get top truncation (default is 0,0)
-        point_array = Pointer((base  + "/top truncation").c_str()).Get(parameters);
-        Point<2> top_truncation(invalid);
-        if (point_array != nullptr)
-          {
-            if (point_array->Size() == 1)
-              {
-                // There is only one value, set it for both elements
-                const double local0 = Pointer((base + "/top truncation/0").c_str()).Get(parameters)->GetDouble();
-                top_truncation = Point<2>(local0,local0,invalid);
-              }
-            else
-              {
-                const double local0 = Pointer((base + "/top truncation/0").c_str()).Get(parameters)->GetDouble();
-                const double local1 = Pointer((base + "/top truncation/1").c_str()).Get(parameters)->GetDouble();
-                top_truncation = Point<2>(local0,local1,invalid);
-              }
-          }
-        // get thickness
-        point_array = Pointer((base  + "/angle").c_str()).Get(parameters);
-        Point<2> angle(invalid);
-        WBAssertThrow(point_array != nullptr,"error: " << name
-                      << " was not defined in " << strict_base << "/angle, schema path: " << this->get_full_json_schema_path() << "/angle.");
-
-        if (point_array->Size() == 1)
-          {
-            // There is only one value, set it for both elements
-            const double local0 = Pointer((base + "/angle/0").c_str()).Get(parameters)->GetDouble();
-            angle = Point<2>(local0,local0,invalid);
-          }
-        else
-          {
-            const double local0 = Pointer((base + "/angle/0").c_str()).Get(parameters)->GetDouble();
-            const double local1 = Pointer((base + "/angle/1").c_str()).Get(parameters)->GetDouble();
-            angle = Point<2>(local0,local1,invalid);
-          }
-
-
-        // Get temperature models
-        std::vector<std::shared_ptr<Temperature::Interface> > temperature_models;
-
-        //This is a value to look back in the path elements.
-        size_t searchback = 0;
-        if (!this->get_shared_pointers<Temperature::Interface>("temperature models", temperature_models) ||
-            Pointer((base + "/temperature model default entry").c_str()).Get(parameters) != nullptr)
-          {
-            temperature_models = default_temperature_models;
-
-            // find the default value, which is the closest to the current path
-            for (searchback = 0; searchback < path.size(); ++searchback)
-              {
-                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Get(parameters) != nullptr)
-                  {
-                    break;
-                  }
-              }
-
-            // if we can not find default value for the temperature model, skip it
-            if (searchback < path.size())
-              {
-
-                // copy the value, this unfortunately removes it.
-                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Get(parameters)->GetArray());
-
-                // now copy it
-                Value value2;
-                value2.CopyFrom(value1, parameters.GetAllocator());
-
-                // now we should have 2x the same value, so put it back and place it in the correct location.
-                Pointer((this->get_full_json_path(path.size()-searchback) + "/temperature models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
-
-                Pointer((base).c_str()).Get(parameters)->AddMember("temperature models", value2, parameters.GetAllocator());
-                Pointer((base + "/temperature model default entry").c_str()).Set(parameters,true);
-              }
-          }
-
-        // now do the same for compositions
-        std::vector<std::shared_ptr<Composition::Interface> > composition_models;
-        if (!this->get_shared_pointers<Composition::Interface>("composition models", composition_models) ||
-            Pointer((base + "/composition model default entry").c_str()).Get(parameters) != nullptr)
-          {
-            composition_models = default_composition_models;
-
-
-            // find the default value, which is the closest to the current path
-            for (searchback = 0; searchback < path.size(); ++searchback)
-              {
-                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Get(parameters) != nullptr)
-                  {
-                    break;
-                  }
-              }
-
-            // if we can not find default value for the temperature model, skip it
-            if (searchback < path.size())
-              {
-
-                // copy the value, this unfortunately removes it.
-                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Get(parameters)->GetArray());
-
-                // now copy it
-                Value value2;
-                value2.CopyFrom(value1, parameters.GetAllocator());
-
-                // now we should have 2x the same value, so put it back and place it in the correct location.
-                Pointer((this->get_full_json_path(path.size()-searchback) + "/composition models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
-
-                Pointer((base).c_str()).Get(parameters)->AddMember("composition models", value2, parameters.GetAllocator());
-                Pointer((base + "/composition model default entry").c_str()).Set(parameters,true);
-              }
-          }
-
-        // now do the same for grains
-        std::vector<std::shared_ptr<Grains::Interface> > grains_models;
-        if (!this->get_shared_pointers<Grains::Interface>("grains models", grains_models) ||
-            Pointer((base + "/grains model default entry").c_str()).Get(parameters) != nullptr)
-          {
-            grains_models = default_grains_models;
-
-
-            // find the default value, which is the closest to the current path
-            for (searchback = 0; searchback < path.size(); ++searchback)
-              {
-                if (Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Get(parameters) != nullptr)
-                  {
-                    break;
-                  }
-              }
-
-            // if we can not find default value for the temperature model, skip it
-            if (searchback < path.size())
-              {
-
-                // copy the value, this unfortunately removes it.
-                Value value1 = Value(Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Get(parameters)->GetArray());
-
-                // now copy it
-                Value value2;
-                value2.CopyFrom(value1, parameters.GetAllocator());
-
-                // now we should have 2x the same value, so put it back and place it in the correct location.
-                Pointer((this->get_full_json_path(path.size()-searchback) + "/grains models").c_str()).Set(parameters, value1);//.Get(parameters)->Set("temperature models", value1, parameters.GetAllocator());
-
-                Pointer((base).c_str()).Get(parameters)->AddMember("grains models", value2, parameters.GetAllocator());
-                Pointer((base + "/grains model default entry").c_str()).Set(parameters,true);
-              }
-          }
-        vector.emplace_back(length, thickness, top_truncation, angle, temperature_models, composition_models, grains_models);
-
-        this->leave_subsection();
-      }
-
-    this->leave_subsection();
-    return vector;
-  }
-
-  template<>
-  std::vector<double>
-  Parameters::get_vector(const std::string &name)
-  {
-    std::vector<double> vector;
-    const std::string strict_base = this->get_full_json_path();
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-        for (size_t i = 0; i < array->Size(); ++i )
-          {
-            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-
-            vector.push_back(Pointer(base.c_str()).Get(parameters)->GetDouble());
-          }
-      }
-    else
-      {
-        const Value *value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/minItems").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the minItems value at: "
-                      << this->get_full_json_schema_path() + "/" + name + "/minItems");
-
-        const size_t min_size = value->GetUint();
-
-        value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/items/default value").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << this->get_full_json_schema_path() + "/" + name + "/default value");
-
-        const double default_value = value->GetDouble();
-
-        // set to min size
-        for (size_t i = 0; i < min_size; ++i)
-          {
-            vector.push_back(default_value);
-          }
-      }
-    return vector;
-  }
-
-  template<>
-  std::vector<size_t>
-  Parameters::get_vector(const std::string &name)
-  {
-    std::vector<size_t> vector;
-    const std::string strict_base = this->get_full_json_path();
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-        for (size_t i = 0; i < array->Size(); ++i )
-          {
-            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-
-            vector.push_back(Pointer(base.c_str()).Get(parameters)->GetUint());
-          }
-      }
-    else
-      {
-        const Value *value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/minItems").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the minItems value at: "
-                      << this->get_full_json_schema_path() + "/" + name + "/minItems");
-
-        const size_t min_size = value->GetUint();
-
-        value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/items/default value").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << this->get_full_json_schema_path() + "/" + name + "/default value");
-
-        const size_t default_value = value->GetUint();
-
-        // set to min size
-        for (size_t i = 0; i < min_size; ++i)
-          {
-            vector.push_back(default_value);
-          }
-      }
-    return vector;
-  }
-
-  template<>
-  std::vector<unsigned int>
-  Parameters::get_vector(const std::string &name)
-  {
-    std::vector<unsigned int> vector;
-    const std::string strict_base = this->get_full_json_path();
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-        for (size_t i = 0; i < array->Size(); ++i )
-          {
-            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-
-            vector.push_back(Pointer(base.c_str()).Get(parameters)->GetUint());
-          }
-      }
-    else
-      {
-        const Value *value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/minItems").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the minItems value at: "
-                      << this->get_full_json_schema_path() + "/" + name + "/minItems value");
-
-        const size_t min_size = value->GetUint();
-
-        const unsigned int default_value = Pointer((this->get_full_json_schema_path()  + "/" + name + "/items/default value").c_str()).Get(declarations)->GetUint();
-
-        // set to min size
-        for (size_t i = 0; i < min_size; ++i)
-          {
-            vector.push_back(default_value);
-          }
-      }
-    return vector;
-  }
-
-  template<class T>
-  std::unique_ptr<T>
-  Parameters::get_unique_pointer(const std::string &name)
-  {
-    const std::string base = this->get_full_json_path();
-    Value *value = Pointer((base + "/" + name + "/model").c_str()).Get(parameters);
-
-#ifdef debug
-    bool required = false;
-    if (Pointer((base + "/required").c_str()).Get(declarations) != NULL)
-      for (auto &v : Pointer((base + "/required").c_str()).Get(declarations)->GetArray())
-        {
-          if (v.GetString() == name)
-            {
-              required = true;
-            }
-        }
-
-    WBAssert(value != NULL || required == false,
-             "Internal error: Value \"" << base << '/' << name << "/model\" not found in the input file, while it was set as required.");
-#endif
-    if (value == nullptr)
-      {
-        value = Pointer((get_full_json_schema_path() + "/" + name + "/default value").c_str()).Get(declarations);
-        WBAssertThrow(value != nullptr,
-                      "internal error: could not retrieve the default value at: "
-                      << base + "/" + name + "/default value. Make sure the value has been declared.");
-      }
-
-    return T::create(value->GetString(),&world);
-  }
-
-  template<class T>
-  bool
-  Parameters::get_unique_pointers(const std::string &name, std::vector<std::unique_ptr<T> > &vector)
-  {
-    vector.resize(0);
-    const std::string strict_base = this->get_full_json_path();
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-        for (size_t i = 0; i < array->Size(); ++i )
-          {
-            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-
-            const std::string value = Pointer((base + "/model").c_str()).Get(parameters)->GetString();
-
-            vector.push_back(std::move(T::create(value, &world)));
-          }
-      }
-    else
-      {
-        return false;
-      }
-
-    return true;
-  }
-
-  template<>
-  bool
-  Parameters::get_unique_pointers(const std::string &name, std::vector<std::unique_ptr<Features::SubductingPlate> > &vector)
-  {
-    vector.resize(0);
-    const std::string strict_base = this->get_full_json_path();
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-        for (size_t i = 0; i < array->Size(); ++i )
-          {
-            vector.push_back(std::make_unique<Features::SubductingPlate>(&world));
-          }
-      }
-    else
-      {
-        return false;
-      }
-
-    return true;
-  }
-
-  template<>
-  bool
-  Parameters::get_unique_pointers(const std::string &name, std::vector<std::unique_ptr<Features::Fault> > &vector)
-  {
-    vector.resize(0);
-    const std::string strict_base = this->get_full_json_path();
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-        for (size_t i = 0; i < array->Size(); ++i )
-          {
-            vector.push_back(std::make_unique<Features::Fault>(&world));
-          }
-      }
-    else
-      {
-        return false;
-      }
-
-    return true;
-  }
-
-
-
-  template<class T>
-  bool
-  Parameters::get_shared_pointers(const std::string &name, std::vector<std::shared_ptr<T> > &vector)
-  {
-    vector.resize(0);
-    const std::string strict_base = this->get_full_json_path();
-    if (Pointer((strict_base + "/" + name).c_str()).Get(parameters) != nullptr)
-      {
-        Value *array = Pointer((strict_base  + "/" + name).c_str()).Get(parameters);
-
-        for (size_t i = 0; i < array->Size(); ++i )
-          {
-            const std::string base = (strict_base + "/").append(name).append("/").append(std::to_string(i));
-
-            const std::string value = Pointer((base + "/model").c_str()).Get(parameters)->GetString();
-
-            vector.push_back(std::move(T::create(value, &world)));
-          }
-      }
-    else
-      {
-        return false;
-      }
-
-    return true;
-  }
-
-  void
-  Parameters::enter_subsection(const std::string &name)
-  {
-    path.push_back(name);
-    //TODO: WBAssert(is path valid?)
-  }
-
-  void
-  Parameters::leave_subsection()
-  {
-    path.pop_back();
-  }
-
-
-
-  void
-  Parameters::declare_model_entries(const std::string &model_group_name,
-                                    const std::string &parent_name,
-                                    const std::map<std::string, void ( *)(Parameters &,const std::string &)> &declare_map,
-                                    const std::vector<std::string> &required_entries,
-                                    const std::vector<std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string> > &extra_declarations)
-  {
-    unsigned int counter = 0;
-    for (const auto &it : declare_map)
-      {
-        typedef std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string> DeclareEntry;
-        // prevent infinite recursion
-        if (it.first != parent_name)
-          {
-            enter_subsection("oneOf");
-            {
-              enter_subsection(std::to_string(counter));
-              {
-                enter_subsection("properties");
-                {
-                  declare_entry("", Types::Object(required_entries), model_group_name + " object");
-
-                  declare_entry("model", Types::String("",it.first),
-                                "The name of the " + model_group_name + " model.");
-
-                  for (DeclareEntry extra_declaration : extra_declarations)
-                    {
-                      declare_entry(std::get<0>(extra_declaration),std::get<1>(extra_declaration),std::get<2>(extra_declaration));
-                    }
-
-
-                  it.second(*this, parent_name);
-                }
-                leave_subsection();
-              }
-              leave_subsection();
-            }
-            leave_subsection();
-
-            counter++;
-
-          }
-      }
-  }
-
-
-
-  std::string
-  Parameters::get_full_json_path(size_t max_size) const
-  {
-    std::string collapse;
-    for (size_t i = 0; i < path.size() && i < max_size; i++)
-      {
-        collapse +=  "/" + path[i];
-      }
-    return collapse;
-  }
-
-  std::string
-  Parameters::get_full_json_schema_path() const
-  {
-    std::string collapse = "/properties";
-    for (size_t i = 0; i < path.size(); i++)
-      {
-        // first get the type
-        //WBAssert(Pointer((collapse + "/" + path[i] + "/type").c_str()).Get(declarations) != NULL, "Internal error: could not find " << collapse + "/" + path[i] + "/type");
-
-        const std::string base_path = Pointer((collapse + "/" + path[i] + "/type").c_str()).Get(declarations) != nullptr
-                                      ?
-                                      collapse + "/" + path[i]
-                                      :
-                                      collapse;
-
-        const std::string type = Pointer((base_path + "/type").c_str()).Get(declarations)->GetString();
-
-        if (type == "array")
-          {
-            // the type is an array. Arrays always have an items, but can also
-            // have a oneOf (todo: or anyOf ...). Find out whether this is the case
-            //collapse += path[i] + "/items";
-            if (Pointer((base_path + "/items/oneOf").c_str()).Get(declarations) != nullptr)
-              {
-                // it has a structure with oneOf. Find out which of the entries is needed.
-                // This means we have to take a sneak peak to figure out how to get to the
-                // next value.
-                const size_t size = Pointer((base_path + "/items/oneOf").c_str()).Get(declarations)->Size();
-#ifdef debug
-                bool found = false;
-#endif
-                size_t index = 0;
-                for (; index < size; ++index)
-                  {
-                    const std::string declarations_string = Pointer((base_path + "/items/oneOf/" + std::to_string(index)
-                                                                     + "/properties/model/enum/0").c_str()).Get(declarations)->GetString();
-
-                    // we need to get the json path relevant for the current declaration string
-                    // we are interested in, which requires an offset of 2.
-                    WBAssert(Pointer((get_full_json_path(i+2) + "/model").c_str()).Get(parameters) != nullptr, "Could not find model in: " << get_full_json_path(i+2) + "/model");
-                    const std::string parameters_string = Pointer((get_full_json_path(i+2) + "/model").c_str()).Get(parameters)->GetString();
-
-                    // currently in our case these are always objects, so go directly to find the option we need.
-                    if (declarations_string == parameters_string)
-                      {
-                        // found it for index i;
-#ifdef debug
-                        found = true;
-#endif
-                        break;
-                      }
-                  }
-#ifdef debug
-                WBAssert(found == true,
-                         "Internal error: This is an array with several possible values, "
-                         "but could not find the correct value " << collapse + "/" + path[i] + "/items/oneOf");
-#endif
-                collapse += "/" + path[i] + "/items/oneOf/" + std::to_string(index) + "/properties";
-                // add one to i, to skip the array
-                ++i;
-              }
-            else
-              {
-                collapse = base_path + "/items";
-              }
-          }
-        else if (type == "object")
-          {
-            // normal objects just have properties, but some have oneOf
-            if (Pointer((base_path + "/oneOf").c_str()).Get(declarations) != nullptr)
-              {
-                // it has a structure with oneOf. Find out which of the entries is needed.
-                // This means we have to take a sneak peak to figure out how to get to the
-                // next value.
-                const size_t size = Pointer((base_path + "/oneOf").c_str()).Get(declarations)->Size();
-#ifdef debug
-                bool found = false;
-#endif
-                size_t index = 0;
-                for (; index < size; ++index)
-                  {
-                    const std::string declarations_string = Pointer((base_path + "/oneOf/" + std::to_string(index)
-                                                                     + "/properties/model/enum/0").c_str()).Get(declarations)->GetString();
-
-                    // we need to get the json path relevant for the current declaration string
-                    // we are interested in, which requires an offset of 2.
-                    const Value *value = Pointer((get_full_json_path(i+2) + "/model").c_str()).Get(parameters);
-
-
-                    if (value == nullptr)
-                      {
-                        value = Pointer((collapse + "/" + path[i]  + "/default value").c_str()).Get(declarations);
-                        WBAssertThrow(value != nullptr,
-                                      "internal error: could not retrieve the default value at: "
-                                      << collapse + "/" + path[i]  + "/default value, for value: ");
-                      }
-
-                    const std::string parameters_string = value->GetString();
-
-                    // currently in our case these are always objects, so go directly to find the option we need.
-                    if (declarations_string == parameters_string)
-                      {
-                        // found it for index i;
-#ifdef debug
-                        found = true;
-#endif
-                        break;
-                      }
-                  }
-#ifdef debug
-                WBAssert(found == true,
-                         "Internal error: This is an array with several possible values, "
-                         "but could not find the correct value " << collapse + "/" + path[i] + "/items/oneOf");
-#endif
-                collapse += "/" + path[i] + "/oneOf/" + std::to_string(index) + "/properties";
-                // add one to i, to skip the array
-                ++i;
-
-              }
-            else
-              {
-                collapse += "/properties";
-              }
-          }
-        else
-          {
-            collapse += "/" + path[i];
-          }
-      }
-    return collapse;
-  }
-
-
-
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template std::unique_ptr<CoordinateSystems::Interface> Parameters::get_unique_pointer<CoordinateSystems::Interface>(const std::string &name);
-
-
-  /**
-   * Returns a vector of pointers to the Gravity Model based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template std::unique_ptr<GravityModel::Interface> Parameters::get_unique_pointer<GravityModel::Interface>(const std::string &name);
-
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template bool
-  Parameters::get_unique_pointers<Features::Interface>(const std::string &name,
-                                                       std::vector<std::unique_ptr<Features::Interface> > &vector);
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template bool
-  Parameters::get_unique_pointers<Features::ContinentalPlateModels::Temperature::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::ContinentalPlateModels::Temperature::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::ContinentalPlateModels::Composition::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::ContinentalPlateModels::Composition::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::ContinentalPlateModels::Grains::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::ContinentalPlateModels::Grains::Interface> > &vector);
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template bool
-  Parameters::get_unique_pointers<Features::PlumeModels::Temperature::Interface>(const std::string &name,
-                                                                                 std::vector<std::unique_ptr<Features::PlumeModels::Temperature::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::PlumeModels::Composition::Interface>(const std::string &name,
-                                                                                 std::vector<std::unique_ptr<Features::PlumeModels::Composition::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::PlumeModels::Grains::Interface>(const std::string &name,
-                                                                            std::vector<std::unique_ptr<Features::PlumeModels::Grains::Interface> > &vector);
-
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template bool
-  Parameters::get_unique_pointers<Features::OceanicPlateModels::Temperature::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::OceanicPlateModels::Temperature::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::OceanicPlateModels::Composition::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::OceanicPlateModels::Composition::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::OceanicPlateModels::Grains::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::OceanicPlateModels::Grains::Interface> > &vector);
-
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template bool
-  Parameters::get_unique_pointers<Features::MantleLayerModels::Temperature::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::MantleLayerModels::Temperature::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::MantleLayerModels::Composition::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::MantleLayerModels::Composition::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::MantleLayerModels::Grains::Interface>(const std::string &name,
-                                                                                  std::vector<std::unique_ptr<Features::MantleLayerModels::Grains::Interface> > &vector);
-
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template bool
-  Parameters::get_unique_pointers<Features::SubductingPlateModels::Temperature::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::SubductingPlateModels::Temperature::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::SubductingPlateModels::Composition::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::SubductingPlateModels::Composition::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::SubductingPlateModels::Grains::Interface>(const std::string &name,
-      std::vector<std::unique_ptr<Features::SubductingPlateModels::Grains::Interface> > &vector);
-
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template bool
-  Parameters::get_unique_pointers<Features::FaultModels::Temperature::Interface>(const std::string &name,
-                                                                                 std::vector<std::unique_ptr<Features::FaultModels::Temperature::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::FaultModels::Composition::Interface>(const std::string &name,
-                                                                                 std::vector<std::unique_ptr<Features::FaultModels::Composition::Interface> > &vector);
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_unique_pointers<Features::FaultModels::Grains::Interface>(const std::string &name,
-                                                                            std::vector<std::unique_ptr<Features::FaultModels::Grains::Interface> > &vector);
-
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template bool
-  Parameters::get_shared_pointers<Features::SubductingPlateModels::Temperature::Interface>(const std::string &name,
-      std::vector<std::shared_ptr<Features::SubductingPlateModels::Temperature::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_shared_pointers<Features::SubductingPlateModels::Composition::Interface>(const std::string &name,
-      std::vector<std::shared_ptr<Features::SubductingPlateModels::Composition::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_shared_pointers<Features::SubductingPlateModels::Grains::Interface>(const std::string &name,
-      std::vector<std::shared_ptr<Features::SubductingPlateModels::Grains::Interface> > &vector);
-
-
-  /**
-   * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-   * Note that the variable with this name has to be loaded before this function is called.
-   */
-  template bool
-  Parameters::get_shared_pointers<Features::FaultModels::Temperature::Interface>(const std::string &name,
-                                                                                 std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> > &vector);
-
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_shared_pointers<Features::FaultModels::Composition::Interface>(const std::string &name,
-                                                                                 std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface> > &vector);
-  /**
-  * Todo: Returns a vector of pointers to the Point<3> Type based on the provided name.
-  * Note that the variable with this name has to be loaded before this function is called.
-  */
-  template bool
-  Parameters::get_shared_pointers<Features::FaultModels::Grains::Interface>(const std::string &name,
-                                                                            std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface> > &vector);
-
-
-
-
-
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/point.cc.bak b/contrib/world_builder/source/world_builder/point.cc.bak
deleted file mode 100644
index e04402d4158..00000000000
--- a/contrib/world_builder/source/world_builder/point.cc.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/point.h"
-
-#include <limits>
-
-namespace WorldBuilder
-{
-
-  template<>
-  Point<2>::Point(const double x, const double y, const CoordinateSystem coordinate_system_)
-    :
-    point({{x,y}}),
-  coordinate_system(coordinate_system_)
-  {}
-
-  template<>
-  Point<3>::Point(const double /*x*/, const double /*y*/, CoordinateSystem coordinate_system_)
-    :
-    point({{std::numeric_limits<double>::signaling_NaN(),std::numeric_limits<double>::signaling_NaN(), std::numeric_limits<double>::signaling_NaN()}}),
-  coordinate_system(coordinate_system_)
-  {
-    WBAssertThrow(false,"Can't use the 2d constructor in 3d.");
-  }
-
-
-  template<>
-  Point<2>::Point(const double /*x*/, const double /*y*/, const double /*z*/, CoordinateSystem coordinate_system_)
-    :
-    point({{std::numeric_limits<double>::signaling_NaN(),std::numeric_limits<double>::signaling_NaN()}}),
-  coordinate_system(coordinate_system_)
-  {
-    WBAssertThrow(false,"Can't use the 3d constructor in 2d.");
-  }
-
-
-  template<>
-  Point<3>::Point(const double x, const double y, const double z, CoordinateSystem coordinate_system_)
-    :
-    point({{x,y,z}}),
-  coordinate_system(coordinate_system_)
-  {}
-
-
-
-
-
-
-
-  template<unsigned int dim>
-  double
-  Point<dim>::distance(const Point<2> &two) const
-  {
-    if (this->coordinate_system == spherical)
-      {
-        // spherical
-        const double d_longitude = two[0] - this->point[0];
-        const double d_latitude = two[1] - this->point[1];
-        const double sin_d_lat = std::sin(d_latitude * 0.5);
-        const double sin_d_long = std::sin(d_longitude * 0.5);
-        return 2.0 * asin(sqrt((sin_d_lat * sin_d_lat) + (sin_d_long*sin_d_long) * std::cos(this->point[1]) * std::cos(two[1])));
-      }
-
-    // cartesian
-    const double x_distance_to_reference_point = point[0]-two[0];
-    const double y_distance_to_reference_point = point[1]-two[1];
-    return sqrt((x_distance_to_reference_point*x_distance_to_reference_point) + (y_distance_to_reference_point*y_distance_to_reference_point));
-
-  }
-
-  /**
-   * The 2d version of the point class.
-   */
-  template class Point<2>;
-
-
-  /**
-   * The 3d version of the point class.
-   */
-  template class Point<3>;
-
-  /**
-   * Multiplies a 2d point with a scalar.
-   */
-  template Point<2> operator*(const double scalar, const Point<2> &point);
-
-  /**
-   * Multiplies a 3d point with a scalar.
-   */
-  template Point<3> operator*(const double scalar, const Point<3> &point);
-} // namespace WorldBuilder
diff --git a/contrib/world_builder/source/world_builder/types/array.cc.bak b/contrib/world_builder/source/world_builder/types/array.cc.bak
deleted file mode 100644
index 7c62626a976..00000000000
--- a/contrib/world_builder/source/world_builder/types/array.cc.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/types/array.h"
-
-#include "world_builder/parameters.h"
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-    Array::Array(const Interface &type,
-                 const unsigned int min_items_,
-                 const unsigned int max_items_,
-                 const bool unique_items_)
-      :
-      inner_type(type.get_type()),
-      inner_type_ptr(type.clone()),
-      required(false),
-      min_items(min_items_),
-      max_items(max_items_),
-      unique_items(unique_items_)
-    {
-      this->type_name = Types::type::Array;
-    }
-
-    Array::Array(Array const &other)
-      :
-      inner_type(other.inner_type),
-      inner_type_ptr(other.inner_type_ptr->clone()),
-      required(other.required),
-      min_items(other.min_items),
-      max_items(other.max_items),
-      unique_items(other.unique_items)
-    {
-      this->type_name = Types::type::Array;
-    }
-
-    Array::~Array ()
-      = default;
-
-
-    void
-    Array::write_schema(Parameters &prm,
-                        const std::string &name,
-                        const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-      const std::string &base = prm.get_full_json_path() + "/" + name;
-
-      Pointer((base + "/type").c_str()).Set(declarations,"array");
-      Pointer((base + "/minItems").c_str()).Set(declarations,min_items);
-      Pointer((base + "/maxItems").c_str()).Set(declarations,max_items);
-      Pointer((base + "/uniqueItems").c_str()).Set(declarations,unique_items);
-      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-
-      prm.enter_subsection(name);
-      {
-        WBAssertThrow(this->inner_type_ptr != nullptr, "Internal error, inner pointer is NULL.");
-        this->inner_type_ptr->write_schema(prm, "items", "");
-      }
-      prm.leave_subsection();
-
-
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/bool.cc.bak b/contrib/world_builder/source/world_builder/types/bool.cc.bak
deleted file mode 100644
index 94ee122cbfb..00000000000
--- a/contrib/world_builder/source/world_builder/types/bool.cc.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/types/bool.h"
-
-#include "world_builder/parameters.h"
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-    Bool::Bool(const bool default_value_)
-      :
-      default_value(default_value_)
-    {
-      this->type_name = Types::type::Bool;
-    }
-
-
-    Bool::Bool(Bool const &other)
-      :
-      default_value(other.default_value)
-    {
-      this->type_name = Types::type::Bool;
-    }
-
-
-    Bool::~Bool ()
-      = default;
-
-
-    void
-    Bool::write_schema(Parameters &prm,
-                       const std::string &name,
-                       const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-      const std::string base = prm.get_full_json_path() + "/" + name;
-
-      Pointer((base + "/default value").c_str()).Set(declarations,default_value);
-      Pointer((base + "/type").c_str()).Set(declarations,"boolean");
-      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/double.cc.bak b/contrib/world_builder/source/world_builder/types/double.cc.bak
deleted file mode 100644
index 3d1e1f2a48b..00000000000
--- a/contrib/world_builder/source/world_builder/types/double.cc.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/types/double.h"
-
-#include "world_builder/parameters.h"
-#include <cmath>
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-    Double::Double(const double default_value_)
-      :
-      default_value(default_value_)
-    {
-      this->type_name = Types::type::Double;
-    }
-
-
-    Double::Double(Double const &other)
-      :
-      default_value(other.default_value)
-    {
-      this->type_name = Types::type::Double;
-    }
-
-
-
-    Double::~Double ()
-      = default;
-
-
-    void
-    Double::write_schema(Parameters &prm,
-                         const std::string &name,
-                         const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-      const std::string base = prm.get_full_json_path() + "/" + name;
-
-      if (std::isnan(default_value))
-        Pointer((base + "/default value").c_str()).Set(declarations,"NaN");
-      else
-        Pointer((base + "/default value").c_str()).Set(declarations,default_value);
-
-      Pointer((base + "/type").c_str()).Set(declarations,"number");
-      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/int.cc.bak b/contrib/world_builder/source/world_builder/types/int.cc.bak
deleted file mode 100644
index a18c7ef3882..00000000000
--- a/contrib/world_builder/source/world_builder/types/int.cc.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/types/int.h"
-
-#include "world_builder/parameters.h"
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-    Int::Int(int default_value_)
-      :
-
-      default_value(default_value_)
-    {
-      this->type_name = Types::type::Int;
-    }
-
-
-    Int::Int(Int const &other)
-      :
-      value(other.value),
-      default_value(other.default_value)
-    {
-      this->type_name = Types::type::Int;
-    }
-
-    Int::~Int ()
-      = default;
-
-
-    void
-    Int::write_schema(Parameters &prm,
-                      const std::string &name,
-                      const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-
-      const std::string base = prm.get_full_json_path() + "/" + name;
-      Pointer((base + "/default value").c_str()).Set(declarations,default_value);
-      Pointer((base + "/type").c_str()).Set(declarations,"integer");
-      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/interface.cc.bak b/contrib/world_builder/source/world_builder/types/interface.cc.bak
deleted file mode 100644
index c1bd9560ae4..00000000000
--- a/contrib/world_builder/source/world_builder/types/interface.cc.bak
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/types/interface.h"
-
-
-
-namespace WorldBuilder
-{
-
-  namespace Types
-  {
-    Interface::Interface()
-
-
-      = default;
-
-    Interface::~Interface ()
-      = default;
-
-
-    type
-    Interface::get_type() const
-    {
-      return type_name;
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/object.cc.bak b/contrib/world_builder/source/world_builder/types/object.cc.bak
deleted file mode 100644
index fce574bd90e..00000000000
--- a/contrib/world_builder/source/world_builder/types/object.cc.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/types/object.h"
-
-
-#include "world_builder/parameters.h"
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-    Object::Object(std::vector<std::string> required_,
-                   const bool additional_properties_)
-      :
-      required(std::move(required_)),
-      additional_properties(additional_properties_)
-    {
-      this->type_name = Types::type::Object;
-    }
-
-    Object::Object(Object const &other)
-      :
-      required(other.required),
-      additional_properties(other.additional_properties)
-    {
-      this->type_name = Types::type::Object;
-    }
-
-    Object::~Object ()
-      = default;
-
-    void
-    Object::write_schema(Parameters &prm,
-                         const std::string & /*name*/,
-                         const std::string &documentation) const
-    {
-      // The object has to be defined just above the properties section.
-      // because it is very inconvenient to make this object there, we
-      // take care here to do that.
-      WBAssertThrow(!prm.path.empty() && prm.path.back() == "properties",
-                    "The Object must be defined in a subsection called properties.");
-      prm.leave_subsection();
-      {
-        using namespace rapidjson;
-        Document &declarations = prm.declarations;
-        const std::string path = prm.get_full_json_path();
-
-        Pointer((path + "/type").c_str()).Set(declarations,"object");
-        Pointer((path + "/description").c_str()).Set(declarations,documentation.c_str());
-        Pointer((path + "/additionalProperties").c_str()).Set(declarations,additional_properties);
-
-        if (!required.empty())
-          {
-            for (unsigned int i = 0; i < required.size(); ++i)
-              {
-                if (i == 0 && Pointer((path + "/required").c_str()).Get(declarations) == nullptr)
-                  {
-                    // The required array doesn't exist yet, so we create it and fill it.
-                    Pointer((path + "/required/0").c_str()).Create(declarations);
-                    Pointer((path + "/required/0").c_str()).Set(declarations, required[i].c_str());
-                  }
-                else
-                  {
-                    // The required array already exist yet, so we add an element to the end.
-                    Pointer((path + "/required/-").c_str()).Set(declarations, required[i].c_str());
-                  }
-              }
-          }
-      }
-      prm.enter_subsection("properties");
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/one_of.cc.bak b/contrib/world_builder/source/world_builder/types/one_of.cc.bak
deleted file mode 100644
index 8ee982bb1c1..00000000000
--- a/contrib/world_builder/source/world_builder/types/one_of.cc.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/types/one_of.h"
-
-#include "world_builder/parameters.h"
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-    OneOf::OneOf(const Interface &type_1,
-                 const Interface &type_2)
-    {
-      this->type_name = Types::type::OneOf;
-      inner_types_ptr.emplace_back(type_1.clone());
-      inner_types_ptr.emplace_back(type_2.clone());
-
-    }
-
-    OneOf::OneOf(OneOf const &other)
-    {
-      this->type_name = Types::type::OneOf;
-      for (const auto &i : other.inner_types_ptr)
-        {
-          inner_types_ptr.emplace_back(i->clone());
-        }
-    }
-
-    OneOf::~OneOf ()
-      = default;
-
-
-    void
-    OneOf::write_schema(Parameters &prm,
-                        const std::string &name,
-                        const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-      const std::string &base = prm.get_full_json_path() + "/" + name;
-
-      prm.enter_subsection(name);
-      {
-        Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-        prm.enter_subsection("oneOf");
-        {
-          for (size_t i = 0; i < inner_types_ptr.size(); i++)
-            {
-              WBAssertThrow(inner_types_ptr[i] != nullptr, "Internal error, inner pointer is NULL.");
-              inner_types_ptr[i]->write_schema(prm, std::to_string(i), "");
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/plugin_system.cc.bak b/contrib/world_builder/source/world_builder/types/plugin_system.cc.bak
deleted file mode 100644
index 4e5d23d1c33..00000000000
--- a/contrib/world_builder/source/world_builder/types/plugin_system.cc.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/types/plugin_system.h"
-
-
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-    PluginSystem::PluginSystem(std::string default_value_,
-                               void ( *declare_entries_)(Parameters &, const std::string &, const std::vector<std::string> &),
-                               std::vector<std::string> required_entries_,
-                               const bool allow_multiple_)
-      :
-      default_value(std::move(default_value_)),
-      declare_entries(declare_entries_),
-      required_entries(std::move(required_entries_)),
-      allow_multiple(allow_multiple_)
-    {
-      this->type_name = Types::type::PluginSystem;
-
-      WBAssert(declare_entries_ != nullptr, "declare entries may not be a null pointer.");
-    }
-
-
-    PluginSystem::PluginSystem(PluginSystem const &plugin_system)
-      :
-      default_value(plugin_system.default_value),
-      declare_entries(plugin_system.declare_entries),
-      required_entries(plugin_system.required_entries),
-      allow_multiple(plugin_system.allow_multiple)
-    {
-      this->type_name = Types::type::PluginSystem;
-    }
-
-    PluginSystem::~PluginSystem ()
-      = default;
-
-    void
-    PluginSystem::write_schema(Parameters &prm,
-                               const std::string &name,
-                               const std::string &documentation) const
-    {
-      using namespace rapidjson;
-
-      prm.enter_subsection(name);
-      {
-        const std::string path = prm.get_full_json_path();
-        Pointer((path + "/description").c_str()).Set(prm.declarations,documentation.c_str());
-        Pointer((path + "/default value").c_str()).Set(prm.declarations,default_value.c_str());
-
-        if (allow_multiple)
-          {
-            Pointer((path + "/type").c_str()).Set(prm.declarations,"array");
-
-            prm.enter_subsection("items");
-            {
-              WBAssert(this->declare_entries != nullptr, "No declare entries given.");
-
-              this->declare_entries(prm, name, required_entries);
-            }
-            prm.leave_subsection();
-          }
-        else
-          {
-            Pointer((path + "/type").c_str()).Set(prm.declarations,"object");
-
-            WBAssert(this->declare_entries != nullptr, "No declare entries given.");
-            this->declare_entries(prm, name, required_entries);
-
-
-          }
-      }
-      prm.leave_subsection();
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/point.cc.bak b/contrib/world_builder/source/world_builder/types/point.cc.bak
deleted file mode 100644
index 977fe601183..00000000000
--- a/contrib/world_builder/source/world_builder/types/point.cc.bak
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/types/point.h"
-
-
-#include "world_builder/parameters.h"
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-
-    template <unsigned int dim>
-    Point<dim>::Point()
-      :
-      value(WorldBuilder::Point<dim>(CoordinateSystem::cartesian)),
-      default_value(WorldBuilder::Point<dim>(CoordinateSystem::cartesian))
-
-    {
-      this->type_name = dim == 2 ? Types::type::Point2D : Types::type::Point3D;
-    }
-
-    template <unsigned int dim>
-    Point<dim>::Point(const WorldBuilder::Point<dim> &default_value_,
-                      std::string description_)
-      :
-      value(default_value_),
-      default_value(default_value_),
-      description(std::move(description_))
-    {
-      this->type_name = dim == 2 ? Types::type::Point2D : Types::type::Point3D;
-    }
-
-    template <unsigned int dim>
-    Point<dim>::Point(const WorldBuilder::Point<dim> &value_,
-                      const WorldBuilder::Point<dim> &default_value_,
-                      std::string description_)
-      :
-      value(value_),
-      default_value(default_value_),
-      description(std::move(description_))
-    {
-      this->type_name = dim == 2 ? Types::type::Point2D : Types::type::Point3D;
-    }
-
-    template <unsigned int dim>
-    Point<dim>::Point(Point const &other)
-      :
-      value(other.value),
-      default_value(other.default_value),
-      description(other.description)
-    {
-      this->type_name = dim == 2 ? Types::type::Point2D : Types::type::Point3D;
-    }
-
-    template <unsigned int dim>
-    Point<dim>::~Point ()
-      = default;
-
-    template<unsigned int dim>
-    void
-    Point<dim>::write_schema(Parameters &prm,
-                             const std::string &name,
-                             const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-      const std::string base = prm.get_full_json_path() + "/" + name;
-
-      Pointer((base + "/type").c_str()).Set(declarations,"array");
-      Pointer((base + "/minItems").c_str()).Set(declarations,dim);
-      Pointer((base + "/maxItems").c_str()).Set(declarations,dim);
-      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-      Pointer((base + "/items/type").c_str()).Set(declarations,"number");
-      // todo: default value
-    }
-
-
-    template<unsigned int dim>
-    double Point<dim>::operator*(const Point<dim> &point_) const
-    {
-      const std::array<double,dim> array = point_.value.get_array();
-      double dot_product = 0;
-      for (unsigned int i = 0; i < dim; ++i)
-        dot_product += value[i] * array[i];
-      return dot_product;
-    }
-
-
-    template<unsigned int dim>
-    WorldBuilder::Point<dim>
-    Point<dim>::operator*(const double scalar) const
-    {
-      // initialize the array to zero.
-      std::array<double,dim> array = WorldBuilder::Point<dim>(value.get_coordinate_system()).get_array();
-      for (unsigned int i = 0; i < dim; ++i)
-        array[i] += value[i] * scalar;
-      return WorldBuilder::Point<dim>(array,value.get_coordinate_system());
-    }
-
-    template<unsigned int dim>
-    WorldBuilder::Point<dim>
-    Point<dim>::operator+(const Point<dim> &point_) const
-    {
-      WorldBuilder::Point<dim> point_tmp(value);
-      point_tmp += point_.value;
-
-      return point_tmp;
-    }
-
-    template<unsigned int dim>
-    WorldBuilder::Point<dim>
-    Point<dim>::operator-(const Point<dim> &point_) const
-    {
-      WorldBuilder::Point<dim> point_tmp(value);
-      point_tmp -= point_.value;
-
-      return point_tmp;
-    }
-
-    /**
-     * access index
-     */
-    template<unsigned int dim>
-    double &
-    Point<dim>::operator[](const unsigned int index)
-    {
-      return value[index];
-    }
-
-    /**
-     * access index
-     */
-    template<unsigned int dim>
-    const double &
-    Point<dim>::operator[](const unsigned int index) const
-    {
-      return value[index];
-    }
-
-    /**
-     * Multiplies a Types::Point<dim> with a scalr and returns a
-     * WorldBuilder::Point<dim>.
-     */
-    template<unsigned int dim>
-    WorldBuilder::Point<dim>
-    operator*(const double scalar, const Point<dim> &point)
-    {
-      return point.value*scalar;
-    }
-
-    template class Point<2>;
-    template class Point<3>;
-
-    /**
-     * Multiplies a Types::Point<2> with a scalr and returns a
-     * WorldBuilder::Point<2>.
-     */
-    template WorldBuilder::Point<2> operator*(const double scalar, const Point<2> &point);
-
-
-    /**
-     * Multiplies a Types::Point<3> with a scalr and returns a
-     * WorldBuilder::Point<3>.
-     */
-    template WorldBuilder::Point<3> operator*(const double scalar, const Point<3> &point);
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/segment.cc.bak b/contrib/world_builder/source/world_builder/types/segment.cc.bak
deleted file mode 100644
index b51c63c1a7a..00000000000
--- a/contrib/world_builder/source/world_builder/types/segment.cc.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/types/segment.h"
-
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace FaultModels
-    namespace SubductingPlateModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace SubductingPlateModels
-  }  // namespace Features
-
-  namespace Types
-  {
-    Segment::Segment(const double default_length_,
-                     const WorldBuilder::Point<2> &default_thickness_,
-                     const WorldBuilder::Point<2> &default_top_truncation_,
-                     const WorldBuilder::Point<2> &default_angle_,
-                     const Types::Interface &temperature_plugin_system_,
-                     const Types::Interface &composition_plugin_system_,
-                     const Types::Interface &grains_plugin_system_)
-      :
-      value_length(default_length_),
-      default_length(default_length_),
-      value_thickness(default_thickness_),
-      default_thickness(default_thickness_),
-      default_top_truncation(default_top_truncation_),
-      value_angle(default_angle_),
-      default_angle(default_angle_),
-      temperature_plugin_system(temperature_plugin_system_.clone()),
-      composition_plugin_system(composition_plugin_system_.clone()),
-      grains_plugin_system(grains_plugin_system_.clone())
-    {
-      this->type_name = Types::type::Segment;
-    }
-
-
-    Segment::Segment(Segment const &other)
-      :
-      value_length(other.default_length),
-      default_length(other.default_length),
-      value_thickness(other.default_thickness),
-      default_thickness(other.default_thickness),
-      default_top_truncation(other.default_top_truncation),
-      value_angle(other.default_angle),
-      default_angle(other.default_angle),
-      temperature_plugin_system(other.temperature_plugin_system->clone()),
-      composition_plugin_system(other.composition_plugin_system->clone()),
-      grains_plugin_system(other.grains_plugin_system->clone())
-    {
-      this->type_name = Types::type::Segment;
-    }
-
-
-    Segment::~Segment ()
-      = default;
-
-
-
-    void
-    Segment::write_schema(Parameters &prm,
-                          const std::string &name,
-                          const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      prm.enter_subsection(name);
-      {
-        Document &declarations = prm.declarations;
-        std::string base = prm.get_full_json_path();
-
-        Pointer((base + "/type").c_str()).Set(declarations,"object");
-        Pointer((base + "/additionalProperties").c_str()).Set(declarations,false);
-        Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-        std::vector<std::string> restricted_values = {"length", "thickness", "angle"};
-        for (unsigned int i = 0; i < restricted_values.size(); ++i)
-          {
-            if (!restricted_values[i].empty())
-              {
-                if (i == 0 && Pointer((base + "/required").c_str()).Get(declarations) == nullptr)
-                  {
-                    // The enum array doesn't exist yet, so we create it and fill it.
-                    Pointer((base + "/required/0").c_str()).Create(declarations);
-                    Pointer((base + "/required/0").c_str()).Set(declarations, restricted_values[i].c_str());
-                  }
-                else
-                  {
-                    // The enum array already exist yet, so we add an element to the end.
-                    Pointer((base + "/required/-").c_str()).Set(declarations, restricted_values[i].c_str());
-                  }
-              }
-          }
-
-        prm.enter_subsection("properties");
-        {
-          base = prm.get_full_json_path();
-          Pointer((base + "/length/type").c_str()).Set(declarations,"number");
-
-          Pointer((base + "/thickness/type").c_str()).Set(declarations,"array");
-          Pointer((base + "/thickness/minItems").c_str()).Set(declarations,1);
-          Pointer((base + "/thickness/maxItems").c_str()).Set(declarations,2);
-          Pointer((base + "/thickness/items/type").c_str()).Set(declarations,"number");
-
-          Pointer((base + "/top truncation/type").c_str()).Set(declarations,"array");
-          Pointer((base + "/top truncation/minItems").c_str()).Set(declarations,1);
-          Pointer((base + "/top truncation/maxItems").c_str()).Set(declarations,2);
-          Pointer((base + "/top truncation/items/type").c_str()).Set(declarations,"number");
-
-          Pointer((base + "/angle/type").c_str()).Set(declarations,"array");
-          Pointer((base + "/angle/minItems").c_str()).Set(declarations,1);
-          Pointer((base + "/angle/maxItems").c_str()).Set(declarations,2);
-          Pointer((base + "/angle/items/type").c_str()).Set(declarations,"number");
-
-          temperature_plugin_system->write_schema(prm, "temperature models", "");
-          composition_plugin_system->write_schema(prm, "composition models", "");
-          grains_plugin_system->write_schema(prm, "grains models", "");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/string.cc.bak b/contrib/world_builder/source/world_builder/types/string.cc.bak
deleted file mode 100644
index 903f9ed4c24..00000000000
--- a/contrib/world_builder/source/world_builder/types/string.cc.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/types/string.h"
-
-
-#include "world_builder/parameters.h"
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-
-    String::String(std::string default_value_)
-      :
-      default_value(std::move(default_value_)),
-
-      restricted_values({})
-    {
-      this->type_name = Types::type::String;
-    }
-
-    String::String(std::string default_value_,
-                   const std::string &restricted_value_)
-      :
-      default_value(std::move(default_value_)),
-      restricted_values({restricted_value_})
-    {
-      this->type_name = Types::type::String;
-    }
-
-    String::String(String const &other)
-      :
-      value(other.value),
-      default_value(other.default_value)
-    {
-      this->type_name = Types::type::String;
-    }
-
-
-    String::String(std::string default_value_,
-                   std::vector<std::string> restricted_values_)
-      :
-      default_value(std::move(default_value_)),
-      restricted_values(std::move(restricted_values_))
-    {
-      this->type_name = Types::type::String;
-    }
-
-    /*String::String(std::string default_value, std::string description)
-      :
-      value(default_value),
-      default_value(default_value),
-      description(description)
-    {
-      this->type_name = Types::type::String;
-    }*/
-
-    String::String(std::string value_,
-                   std::string default_value_,
-                   std::string description_)
-      :
-      value(std::move(value_)),
-      default_value(std::move(default_value_)),
-      description(std::move(description_))
-    {
-      this->type_name = Types::type::String;
-    }
-
-    String::~String ()
-      = default;
-
-    void
-    String::write_schema(Parameters &prm,
-                         const std::string &name,
-                         const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-      const std::string base = prm.get_full_json_path() + "/" + name;
-      Pointer((base + "/default value").c_str()).Set(declarations,default_value.c_str());
-      Pointer((base + "/type").c_str()).Set(declarations,"string");
-      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-      for (unsigned int i = 0; i < restricted_values.size(); ++i)
-        {
-          if (!restricted_values[i].empty())
-            {
-              if (i == 0 && Pointer((base + "/enum").c_str()).Get(declarations) == nullptr)
-                {
-                  // The enum array doesn't exist yet, so we create it and fill it.
-                  Pointer((base + "/enum/0").c_str()).Create(declarations);
-                  Pointer((base + "/enum/0").c_str()).Set(declarations, restricted_values[i].c_str());
-                }
-              else
-                {
-                  // The enum array already exist yet, so we add an element to the end.
-                  Pointer((base + "/enum/-").c_str()).Set(declarations, restricted_values[i].c_str());
-                }
-            }
-        }
-    }
-
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/unsigned_int.cc.bak b/contrib/world_builder/source/world_builder/types/unsigned_int.cc.bak
deleted file mode 100644
index 9109cb72b1b..00000000000
--- a/contrib/world_builder/source/world_builder/types/unsigned_int.cc.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include "world_builder/types/unsigned_int.h"
-
-#include "world_builder/parameters.h"
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-    UnsignedInt::UnsignedInt(unsigned int default_value_)
-      :
-
-      default_value(default_value_)
-    {
-      this->type_name = Types::type::UnsignedInt;
-    }
-
-
-    UnsignedInt::UnsignedInt(UnsignedInt const &other)
-      :
-      value(other.value),
-      default_value(other.default_value)
-    {
-      this->type_name = Types::type::UnsignedInt;
-    }
-
-    UnsignedInt::~UnsignedInt ()
-      = default;
-
-
-    void
-    UnsignedInt::write_schema(Parameters &prm,
-                              const std::string &name,
-                              const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      Document &declarations = prm.declarations;
-
-      const std::string base = prm.get_full_json_path() + "/" + name;
-      Pointer((base + "/default value").c_str()).Set(declarations,default_value);
-      Pointer((base + "/type").c_str()).Set(declarations,"integer");
-      Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-
-    }
-  } // namespace Types
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/types/value_at_points.cc.bak b/contrib/world_builder/source/world_builder/types/value_at_points.cc.bak
deleted file mode 100644
index ad51d48ed97..00000000000
--- a/contrib/world_builder/source/world_builder/types/value_at_points.cc.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-#include <utility>
-
-#include "world_builder/types/value_at_points.h"
-
-#include "world_builder/parameters.h"
-
-
-namespace WorldBuilder
-{
-  namespace Types
-  {
-
-    ValueAtPoints::ValueAtPoints(const double default_value_,
-                                 uint64_t max_values_in_array_,
-                                 std::vector<Point<2>> default_points_)
-      :
-      default_value(default_value_),
-      max_values_in_array(max_values_in_array_),
-      default_points(std::move(std::move(default_points_)))
-    {
-      this->type_name = Types::type::ValueAtPoints;
-
-      WBAssert(default_points_.size() == 0, "default points are not implemented.");
-    }
-
-    ValueAtPoints::ValueAtPoints(ValueAtPoints const &other)
-      :
-      default_value(other.default_value),
-      max_values_in_array(other.max_values_in_array),
-      default_points(other.default_points)
-    {
-      this->type_name = Types::type::ValueAtPoints;
-    }
-
-
-    ValueAtPoints::~ValueAtPoints ()
-      = default;
-
-
-    void
-    ValueAtPoints::write_schema(Parameters &prm,
-                                const std::string &name,
-                                const std::string &documentation) const
-    {
-      using namespace rapidjson;
-      prm.enter_subsection(name);
-      {
-        Document &declarations = prm.declarations;
-        const std::string base = prm.get_full_json_path();
-
-        Pointer((base + "/type").c_str()).Set(declarations,"array");
-        Pointer((base + "/additionalProperties").c_str()).Set(declarations,false);
-        Pointer((base + "/minItems").c_str()).Set(declarations,1);
-        Pointer((base + "/maxItems").c_str()).Set(declarations, max_values_in_array);
-        Pointer((base + "/description").c_str()).Set(declarations,documentation.c_str());
-
-        {
-          Pointer((base + "/items/anyOf/0/type").c_str()).Set(declarations,"number");
-          Pointer((base + "/items/anyOf/0/default value").c_str()).Set(declarations,default_value);
-
-          Pointer((base + "/items/anyOf/1/type").c_str()).Set(declarations,"array");
-          Pointer((base + "/items/anyOf/1/minItems").c_str()).Set(declarations,1);
-          Pointer((base + "/items/anyOf/1/maxItems").c_str()).Set(declarations,std::numeric_limits<unsigned int>::max());
-
-          Pointer((base + "/items/anyOf/1/items/type").c_str()).Set(declarations,"array");
-          Pointer((base + "/items/anyOf/1/items/minItems").c_str()).Set(declarations,1);
-          Pointer((base + "/items/anyOf/1/items/maxItems").c_str()).Set(declarations, max_values_in_array);
-
-          Pointer((base + "/items/anyOf/1/items/items/type").c_str()).Set(declarations,"number");
-        }
-      }
-      prm.leave_subsection();
-    }
-
-  } // namespace Types
-} // namespace WorldBuilder
-
-
diff --git a/contrib/world_builder/source/world_builder/utilities.cc.bak b/contrib/world_builder/source/world_builder/utilities.cc.bak
deleted file mode 100644
index 90ecdf099fe..00000000000
--- a/contrib/world_builder/source/world_builder/utilities.cc.bak
+++ /dev/null
@@ -1,1510 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/assert.h"
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <limits>
-#include <sstream>
-
-#ifdef WB_WITH_MPI
-// we don't need the c++ MPI wrappers
-#define OMPI_SKIP_MPICXX 1
-#define MPICH_SKIP_MPICXX
-#include <mpi.h>
-#endif
-
-#include "world_builder/nan.h"
-#include "world_builder/utilities.h"
-#include <world_builder/coordinate_system.h>
-
-
-namespace WorldBuilder
-{
-  namespace Utilities
-  {
-    bool
-    polygon_contains_point(const std::vector<Point<2> > &point_list,
-                           const Point<2> &point)
-    {
-      if (point.get_coordinate_system() == CoordinateSystem::spherical)
-        {
-          Point<2> other_point = point;
-          other_point[0] += point[0] < 0 ? 2.0 * Consts::PI : -2.0 * Consts::PI;
-
-          return (polygon_contains_point_implementation(point_list, point) ||
-                  polygon_contains_point_implementation(point_list, other_point));
-        }
-
-      return polygon_contains_point_implementation(point_list, point);
-
-    }
-
-    bool
-    polygon_contains_point_implementation(const std::vector<Point<2> > &point_list,
-                                          const Point<2> &point)
-    {
-      /**
-       * This code has been based on http://geomalgorithms.com/a03-_inclusion.html,
-       * and therefore requires the following copyright notice:
-       *
-       * Copyright 2000 softSurfer, 2012 Dan Sunday
-       * This code may be freely used and modified for any purpose
-       * providing that this copyright notice is included with it.
-       * SoftSurfer makes no warranty for this code, and cannot be held
-       * liable for any real or imagined damage resulting from its use.
-       * Users of this code must verify correctness for their application.
-       *
-       * The main functional difference between the original code and this
-       * code is that all the boundaries are considered to be inside the
-       * polygon. One should of course realize that with floating point
-       * arithmetic no guarantees can be made for the borders, but for
-       * exact arithmetic this algorithm would work (also see polygon
-       * in point test).
-       */
-      const size_t pointNo = point_list.size();
-      size_t    wn = 0;    // the  winding number counter
-      size_t   j=pointNo-1;
-
-      // loop through all edges of the polygon
-      for (size_t i=0; i<pointNo; i++)
-        {
-          // edge from V[i] to  V[i+1]
-          if (point_list[j][1] <= point[1])
-            {
-              // first check if a point is directly on a line (within epsilon)
-              if (approx(point_list[i][0],point[0]) && approx(point_list[i][1],point[1]))
-                return true;
-              // start y <= P.y
-              if (point_list[i][1] >= point[1])      // an upward crossing
-                {
-                  const double is_left = (point_list[i][0] - point_list[j][0]) * (point[1] - point_list[j][1])
-                                         - (point[0] -  point_list[j][0]) * (point_list[i][1] - point_list[j][1]);
-
-                  if ( is_left > 0 && point_list[i][1] > point[1])
-                    {
-                      // P left of  edge
-                      ++wn;            // have  a valid up intersect
-                    }
-                  else if ( std::abs(is_left) < std::numeric_limits<double>::epsilon())
-                    {
-                      // The point is exactly on the infinite line.
-                      // determine if it is on the segment
-                      const double dot_product = (point - point_list[j])*(point_list[i] - point_list[j]);
-
-                      if (dot_product >= 0)
-                        {
-                          const double squaredlength = (point_list[i] - point_list[j]).norm_square();
-
-                          if (dot_product <= squaredlength)
-                            {
-                              return true;
-                            }
-                        }
-                    }
-                }
-            }
-          else
-            {
-              // start y > P.y (no test needed)
-              if (point_list[i][1]  <= point[1])     // a downward crossing
-                {
-                  const double is_left = (point_list[i][0] - point_list[j][0]) * (point[1] - point_list[j][1])
-                                         - (point[0] -  point_list[j][0]) * (point_list[i][1] - point_list[j][1]);
-
-                  if ( is_left < 0)
-                    {
-                      // P right of  edge
-                      --wn;            // have  a valid down intersect
-                    }
-                  else if (std::abs(is_left) < std::numeric_limits<double>::epsilon())
-                    {
-                      // This code is to make sure that the boundaries are included in the polygon.
-                      // The point is exactly on the infinite line.
-                      // determine if it is on the segment
-                      const double dot_product = (point - point_list[j])*(point_list[i] - point_list[j]);
-
-                      if (dot_product >= 0)
-                        {
-                          const double squaredlength = (point_list[i] - point_list[j]).norm_square();
-
-                          if (dot_product <= squaredlength)
-                            {
-                              return true;
-                            }
-                        }
-                    }
-                }
-            }
-          j=i;
-        }
-
-      return (wn != 0);
-    }
-
-
-
-    double
-    fraction_from_ellipse_center(const Point<2> &ellipse_center,
-                                 const double semi_major_axis,
-                                 const double eccentricity,
-                                 const double theta,
-                                 const Point<2> &point)
-    {
-      const double x_rotated = (point[0] - ellipse_center[0]) * std::cos(theta) + (point[1] - ellipse_center[1])* std::sin(theta);
-      const double y_rotated = -(point[0] - ellipse_center[0]) * std::sin(theta) + (point[1] - ellipse_center[1])* std::cos(theta);
-
-      const double semi_minor_axis = semi_major_axis * std::sqrt(1 - std::pow(eccentricity, 2));
-
-      if (semi_major_axis < 10 * std::numeric_limits<double>::min()
-          || semi_minor_axis < 10 * std::numeric_limits<double>::min())
-        return false;
-
-      const double ellipse = std::pow((x_rotated), 2) / std::pow(semi_major_axis, 2)
-                             + std::pow((y_rotated), 2) / std::pow(semi_minor_axis, 2);
-
-      return ellipse;
-    }
-
-
-
-    double
-    signed_distance_to_polygon(const std::vector<Point<2> > &point_list,
-                               const Point<2> &point)
-    {
-      // If the point lies outside polygon, we give it a negative sign,
-      // inside a positive sign.
-      const double sign = polygon_contains_point(point_list, point) ? 1.0 : -1.0;
-
-      /**
-       * This code is based on http://geomalgorithms.com/a02-_lines.html#Distance-to-Infinite-Line,
-       * and therefore requires the following copyright notice:
-       *
-       * Copyright 2000 softSurfer, 2012 Dan Sunday
-       * This code may be freely used and modified for any purpose
-       * providing that this copyright notice is included with it.
-       * SoftSurfer makes no warranty for this code, and cannot be held
-       * liable for any real or imagined damage resulting from its use.
-       * Users of this code must verify correctness for their application.
-       *
-       */
-
-      const size_t n_poly_points = point_list.size();
-      WBAssertThrow(n_poly_points >= 3, "Not enough polygon points were specified.");
-
-      // Initialize a vector of distances for each point of the polygon with a very large distance
-      std::vector<double> distances(n_poly_points, 1e23);
-
-      // Create another polygon but with all points shifted 1 position to the right
-      std::vector<Point<2> > shifted_point_list(n_poly_points, Point<2>(point.get_coordinate_system()));
-      shifted_point_list[0] = point_list[n_poly_points-1];
-
-      for (size_t i = 0; i < n_poly_points-1; ++i)
-        shifted_point_list[i+1] = point_list[i];
-
-      for (size_t i = 0; i < n_poly_points; ++i)
-        {
-          // Create vector along the polygon line segment
-          const Point<2> vector_segment = shifted_point_list[i] - point_list[i];
-          // Create vector from point to the second segment point
-          const Point<2> vector_point_segment = point - point_list[i];
-
-          // Compute dot products to get angles
-          const double c1 = vector_point_segment * vector_segment;
-          const double c2 = vector_segment * vector_segment;
-
-          // point lies closer to not-shifted polygon point, but perpendicular base line lies outside segment
-          if (c1 <= 0.0)
-            distances[i] = (Point<2> (point_list[i] - point)).norm();
-          // point lies closer to shifted polygon point, but perpendicular base line lies outside segment
-          else if (c2 <= c1)
-            distances[i] = (Point<2> (shifted_point_list[i] - point)).norm();
-          // perpendicular base line lies on segment
-          else
-            {
-              const Point<2> point_on_segment = point_list[i] + (c1/c2) * vector_segment;
-              distances[i] = (Point<2> (point - point_on_segment)).norm();
-            }
-        }
-
-      // Return the minimum of the distances of the point to all polygon segments
-      return *std::min_element(distances.begin(),distances.end()) * sign;
-    }
-
-
-    std::array<double,3>
-    cartesian_to_spherical_coordinates(const Point<3> &position)
-    {
-      std::array<double,3> scoord;
-
-      scoord[0] = position.norm(); // R
-      scoord[1] = std::atan2(position[1],position[0]); // Phi/long -> The result is always between -180 and 180 degrees: [-pi,pi]
-      //if (scoord[1] < 0.0)
-      //scoord[1] += 2.0*Consts::PI; // correct phi to [0,2*pi]
-
-      //lat
-      if (scoord[0] > std::numeric_limits<double>::min())
-        scoord[2] = 0.5 * Consts::PI - std::acos(position[2]/scoord[0]);
-      else
-        scoord[2] = 0.0;
-
-      return scoord;
-    }
-
-    Point<3>
-    spherical_to_cartesian_coordinates(const std::array<double,3> &scoord)
-    {
-      const double cos_lat = scoord[0] * std::sin(0.5 * Consts::PI - scoord[2]);
-
-      return Point<3>(cos_lat * std::cos(scoord[1]), // X
-                      cos_lat * std::sin(scoord[1]), // Y
-                      scoord[0] * std::cos(0.5 * Consts::PI - scoord[2]), // Z
-                      cartesian);;
-    }
-
-
-
-    CoordinateSystem
-    string_to_coordinate_system(const std::string &coordinate_system)
-    {
-      if (coordinate_system == "cartesian")
-        return CoordinateSystem::cartesian;
-      if (coordinate_system == "spherical")
-        return CoordinateSystem::spherical;
-      WBAssertThrow(false, "Coordinate system not implemented.");
-
-      return invalid;
-    }
-
-
-    template<unsigned int dim>
-    std::array<double,dim>
-    convert_point_to_array(const Point<dim> &point_)
-    {
-      std::array<double,dim> array;
-      for (size_t i = 0; i < dim; ++i)
-        array[i] = point_[i];
-      return array;
-    }
-
-    double
-    string_to_double(const std::string &string)
-    {
-      // trim whitespace on either side of the text if necessary
-      std::string s = string;
-      while ((!s.empty()) && (s[0] == ' '))
-        s.erase(s.begin());
-      while ((!s.empty()) && (s[s.size() - 1] == ' '))
-        s.erase(s.end() - 1);
-
-      std::istringstream i(s);
-      double d;
-      char c;
-      if (!(i >> d) || i.get(c))
-        WBAssertThrow(false, "Could not convert \"" + s + "\" to a double.");
-
-      return d;
-    }
-
-    int
-    string_to_int(const std::string &string)
-    {
-      // trim whitespace on either side of the text if necessary
-      std::string s = string;
-      while ((!s.empty()) && (s[0] == ' '))
-        s.erase(s.begin());
-      while ((!s.empty()) && (s[s.size() - 1] == ' '))
-        s.erase(s.end() - 1);
-
-      std::istringstream i(s);
-      int d;
-      char c;
-      if (!(i >> d) || i.get(c))
-        WBAssertThrow(false, "Could not convert \"" + s + "\" to an int.");
-
-      return d;
-    }
-
-
-    unsigned int
-    string_to_unsigned_int(const std::string &string)
-    {
-      // trim whitespace on either side of the text if necessary
-      std::string s = string;
-      while ((!s.empty()) && (s[0] == ' '))
-        s.erase(s.begin());
-      while ((!s.empty()) && (s[s.size() - 1] == ' '))
-        s.erase(s.end() - 1);
-
-
-      std::istringstream i(s);
-      unsigned int d;
-      char c;
-      if (!(i >> d) || i.get(c))
-        WBAssertThrow(false, "Could not convert \"" + s + "\" to an unsigned int.");
-
-      return d;
-    }
-
-
-    Point<3>
-    cross_product(const Point<3> &a, const Point<3> &b)
-    {
-      WBAssert(a.get_coordinate_system() == b.get_coordinate_system(), "Trying to do a cross product of points of a different coordinate system.");
-      const double x = a[1] * b[2] - b[1] * a[2];
-      const double y = a[2] * b[0] - b[2] * a[0];
-      const double z = a[0] * b[1] - b[0] * a[1];
-      return Point<3>(x,y,z,a.get_coordinate_system());
-    }
-
-    PointDistanceFromCurvedPlanes
-    distance_point_from_curved_planes(const Point<3> &check_point, // cartesian point in cartesian and spherical system
-                                      const Objects::NaturalCoordinate &natural_coordinate, // cartesian point cartesian system, spherical point in spherical system
-                                      const Point<2> &reference_point, // in (rad) spherical coordinates in spherical system
-                                      const std::vector<Point<2> > &point_list, // in  (rad) spherical coordinates in spherical system
-                                      const std::vector<std::vector<double> > &plane_segment_lengths,
-                                      const std::vector<std::vector<Point<2> > > &plane_segment_angles,
-                                      const double start_radius,
-                                      const std::unique_ptr<CoordinateSystems::Interface> &coordinate_system,
-                                      const bool only_positive,
-                                      const Objects::BezierCurve &bezier_curve)
-    {
-      double distance = std::numeric_limits<double>::infinity();
-      double new_distance = std::numeric_limits<double>::infinity();
-      double along_plane_distance = std::numeric_limits<double>::infinity();
-      double new_along_plane_distance  = std::numeric_limits<double>::infinity();
-      double new_depth_reference_surface = std::numeric_limits<double>::infinity();
-
-      const CoordinateSystem natural_coordinate_system = coordinate_system->natural_coordinate_system();
-      const bool bool_cartesian = natural_coordinate_system == cartesian;
-
-      const std::array<double,3> &check_point_surface_2d_array = natural_coordinate.get_coordinates();
-      const Point<3> check_point_surface(bool_cartesian ? check_point_surface_2d_array[0] : start_radius,
-                                         check_point_surface_2d_array[1],
-                                         bool_cartesian ? start_radius : check_point_surface_2d_array[2],
-                                         natural_coordinate_system);
-      const Point<2> check_point_surface_2d(natural_coordinate.get_surface_coordinates(),
-                                            natural_coordinate_system);
-
-      // The section which is checked.
-      size_t section = 0;
-
-      // The 'horizontal' fraction between the points at the surface.
-      double section_fraction = 0.0;
-
-      // What segment the point on the line is in.
-      size_t segment = 0;
-
-      // The 'vertical' fraction, indicates how far in the current segment the
-      // point on the line is.
-      double segment_fraction = 0.0;
-      double total_average_angle = 0.0;
-      double depth_reference_surface = 0.0;
-
-      const DepthMethod depth_method = coordinate_system->depth_method();
-
-      size_t i_section_min_distance = 0;
-      double fraction_CPL_P1P2 = std::numeric_limits<double>::infinity();
-
-      // get an estimate for the closest point between P1 and P2.
-      //constexpr double parts = 1;
-      //constexpr double one_div_parts = 1./parts;
-      //double minimum_distance_to_reference_point = std::numeric_limits<double>::infinity();
-      //const size_t number_of_points = point_list.size();
-
-      const Objects::ClosestPointOnCurve closest_point_on_curve = bezier_curve.closest_point_on_curve_segment(check_point_surface_2d);
-      Point<2> closest_point_on_line_2d = closest_point_on_curve.point;
-
-      // We now need 3d points from this point on, so make them.
-      // The order of a Cartesian coordinate is x,y,z and the order of
-      // a spherical coordinate it radius, long, lat (in rad).
-      const Point<3> closest_point_on_line_surface(bool_cartesian ? closest_point_on_line_2d[0] : start_radius,
-                                                   bool_cartesian ? closest_point_on_line_2d[1] : closest_point_on_line_2d[0],
-                                                   bool_cartesian ? start_radius : closest_point_on_line_2d[1],
-                                                   natural_coordinate_system);
-
-      const Point<3> closest_point_on_line_cartesian(coordinate_system->natural_to_cartesian_coordinates(closest_point_on_line_surface.get_array()),cartesian);
-
-      if (!std::isnan(closest_point_on_line_2d[0]))
-        {
-          i_section_min_distance = closest_point_on_curve.index;
-          fraction_CPL_P1P2 = closest_point_on_curve.parametric_fraction;
-
-          Point<3> closest_point_on_line_bottom = closest_point_on_line_surface;
-          closest_point_on_line_bottom[bool_cartesian ? 2 : 0] = 0;
-
-          WBAssert(!std::isnan(closest_point_on_line_bottom[0])
-                   &&
-                   !std::isnan(closest_point_on_line_bottom[1])
-                   &&
-                   !std::isnan(closest_point_on_line_bottom[2]),
-                   "Internal error: The closest_point_on_line_bottom variables variable contains not a number: " << closest_point_on_line_bottom);
-
-          // Now that we have both the check point and the
-          // closest_point_on_line, we need to push them to cartesian.
-          const Point<3> closest_point_on_line_bottom_cartesian(coordinate_system->natural_to_cartesian_coordinates(closest_point_on_line_bottom.get_array()),cartesian);
-          const Point<3> check_point_surface_cartesian(coordinate_system->natural_to_cartesian_coordinates(check_point_surface.get_array()),cartesian);
-
-
-          WBAssert(!std::isnan(closest_point_on_line_bottom_cartesian[0]),
-                   "Internal error: The closest_point_on_line_bottom_cartesian[0] variable is not a number: " << closest_point_on_line_bottom_cartesian[0]);
-          WBAssert(!std::isnan(closest_point_on_line_bottom_cartesian[1]),
-                   "Internal error: The closest_point_on_line_bottom_cartesian[1] variable is not a number: " << closest_point_on_line_bottom_cartesian[1]);
-          WBAssert(!std::isnan(closest_point_on_line_bottom_cartesian[2]),
-                   "Internal error: The closest_point_on_line_bottom_cartesian[2] variable is not a number: " << closest_point_on_line_bottom_cartesian[2]);
-
-
-          // translate to original coordinates current and next section
-          const size_t original_current_section = i_section_min_distance;
-          const size_t original_next_section = original_current_section + 1;
-
-
-          // These are the mostly likely cases for the x and y axis, so initialize them to these values. They will be checked
-          // in the else statement or replaced in the if statement.
-          Point<3> y_axis = closest_point_on_line_cartesian - closest_point_on_line_bottom_cartesian;
-          Point<3> x_axis = closest_point_on_line_cartesian - check_point_surface_cartesian;
-
-          // This are accounting for corner cases.
-          // If the point to check is exactly on or below the line, we can not compute the x-axis with this method.
-          // We could use an other method where we use the two point before and after it, but we can also
-          // just nudge it into a direction, which seems to work very well.
-          if (std::fabs((check_point_surface - closest_point_on_line_surface).norm()) < 2e-14)
-            {
-              // If the point to check is on the line, we don't need to search any further, because we know the distance is zero.
-              if (std::fabs((check_point - closest_point_on_line_cartesian).norm()) > 2e-14)
-                {
-                  const Point<2> &P1(point_list[i_section_min_distance]);
-                  const Point<2> &P2(point_list[i_section_min_distance+1]);
-
-                  const Point<2> P1P2 = P2 - P1;
-                  const Point<2> unit_normal_to_plane_spherical = P1P2 / P1P2.norm();
-                  const Point<2> closest_point_on_line_plus_normal_to_plane_spherical = closest_point_on_line_2d + 1e-8 * (closest_point_on_line_2d.norm() > 1.0 ? closest_point_on_line_2d.norm() : 1.0) * unit_normal_to_plane_spherical;
-
-                  WBAssert(std::fabs(closest_point_on_line_plus_normal_to_plane_spherical.norm()) > std::numeric_limits<double>::epsilon(),
-                           "Internal error: The norm of variable 'closest_point_on_line_plus_normal_to_plane_spherical' "
-                           "is  zero, while this may not happen.");
-
-                  const Point<3> closest_point_on_line_plus_normal_to_plane_surface_spherical(bool_cartesian ? closest_point_on_line_plus_normal_to_plane_spherical[0] : start_radius,
-                                                                                              bool_cartesian ? closest_point_on_line_plus_normal_to_plane_spherical[1] : closest_point_on_line_plus_normal_to_plane_spherical[0],
-                                                                                              bool_cartesian ? start_radius : closest_point_on_line_plus_normal_to_plane_spherical[1],
-                                                                                              natural_coordinate_system);
-                  const Point<3> closest_point_on_line_plus_normal_to_plane_cartesian(coordinate_system->natural_to_cartesian_coordinates(closest_point_on_line_plus_normal_to_plane_surface_spherical.get_array()),cartesian);
-                  Point<3> normal_to_plane = closest_point_on_line_plus_normal_to_plane_cartesian - closest_point_on_line_cartesian;
-                  normal_to_plane = normal_to_plane / normal_to_plane.norm();
-
-                  // The y-axis is from the bottom/center to the closest_point_on_line,
-                  // the x-axis is 90 degrees rotated from that, so we rotate around
-                  // the line P1P2.
-                  // Todo: Assert that the norm of the axis are not equal to zero.
-                  y_axis = closest_point_on_line_cartesian - closest_point_on_line_bottom_cartesian;
-
-                  WBAssert(std::abs(y_axis.norm()) > std::numeric_limits<double>::epsilon(),
-                           "World Builder error: Cannot determine the up direction in the model. This is most likely due to the provided start radius being zero."
-                           << " Technical details: The y_axis.norm() is zero. Y_axis is " << y_axis[0] << ':' << y_axis[1] << ':' << y_axis[2]
-                           << ". closest_point_on_line_cartesian = " << closest_point_on_line_cartesian[0] << ':' << closest_point_on_line_cartesian[1] << ':' << closest_point_on_line_cartesian[2]
-                           << ", closest_point_on_line_bottom_cartesian = " << closest_point_on_line_bottom_cartesian[0] << ':' << closest_point_on_line_bottom_cartesian[1] << ':' << closest_point_on_line_bottom_cartesian[2]);
-
-                  WBAssert(!std::isnan(y_axis[0]),
-                           "Internal error: The y_axis variable is not a number: " << y_axis[0]);
-                  WBAssert(!std::isnan(y_axis[1]),
-                           "Internal error: The y_axis variable is not a number: " << y_axis[1]);
-                  WBAssert(!std::isnan(y_axis[2]),
-                           "Internal error: The y_axis variable is not a number: " << y_axis[2]);
-
-                  y_axis = y_axis / y_axis.norm();
-
-                  WBAssert(!std::isnan(y_axis[0]),
-                           "Internal error: The y_axis variable is not a number: " << y_axis[0]);
-                  WBAssert(!std::isnan(y_axis[1]),
-                           "Internal error: The y_axis variable is not a number: " << y_axis[1]);
-                  WBAssert(!std::isnan(y_axis[2]),
-                           "Internal error: The y_axis variable is not a number: " << y_axis[2]);
-
-
-                  // shorthand notation for computing the x_axis
-                  const double vx = y_axis[0];
-                  const double vy = y_axis[1];
-                  const double vz = y_axis[2];
-                  const double ux = normal_to_plane[0];
-                  const double uy = normal_to_plane[1];
-                  const double uz = normal_to_plane[2];
-
-                  x_axis = Point<3>(ux*ux*vx + ux*uy*vy - uz*vy + uy*uz*vz + uy*vz,
-                                    uy*ux*vx + uz*vx + uy*uy*vy + uy*uz*vz - ux*vz,
-                                    uz*ux*vx - uy*vx + uz*uy*vy + ux*vy + uz*uz*vz,
-                                    cartesian);
-
-                  // see on what side the line P1P2 reference point is. This is based on the determinant
-                  const Point<2> reference_p = ((closest_point_on_curve.normal-closest_point_on_line_2d)*1e2)+closest_point_on_line_2d;
-                  const double reference_on_side_of_line =  (closest_point_on_line_2d-reference_p).norm_square() < (check_point_surface_2d-reference_p).norm_square() ? -1 : 1;
-
-                  WBAssert(!std::isnan(x_axis[0]),
-                           "Internal error: The x_axis variable is not a number: " << x_axis[0]);
-                  WBAssert(!std::isnan(x_axis[1]),
-                           "Internal error: The x_axis variable is not a number: " << x_axis[1]);
-                  WBAssert(!std::isnan(x_axis[2]),
-                           "Internal error: The x_axis variable is not a number: " << x_axis[2]);
-
-                  x_axis = x_axis *(reference_on_side_of_line / x_axis.norm());
-
-                  WBAssert(!std::isnan(x_axis[0]),
-                           "Internal error: The x_axis variable is not a number: " << x_axis[0]);
-                  WBAssert(!std::isnan(x_axis[1]),
-                           "Internal error: The x_axis variable is not a number: " << x_axis[1]);
-                  WBAssert(!std::isnan(x_axis[2]),
-                           "Internal error: The x_axis variable is not a number: " << x_axis[2]);
-                }
-              else
-                {
-                  total_average_angle = plane_segment_angles[original_current_section][0][0]
-                                        + fraction_CPL_P1P2 * (plane_segment_angles[original_next_section][0][0]
-                                                               - plane_segment_angles[original_current_section][0][0]);
-
-                  PointDistanceFromCurvedPlanes return_values(natural_coordinate.get_coordinate_system());
-                  return_values.distance_from_plane = 0.0;
-                  return_values.distance_along_plane = 0.0;
-                  return_values.fraction_of_section = fraction_CPL_P1P2;
-                  return_values.fraction_of_segment = 0.0;
-                  return_values.section = i_section_min_distance;
-                  return_values.segment = 0;
-                  return_values.average_angle = total_average_angle;
-                  return_values.depth_reference_surface = 0.0;
-                  return_values.closest_trench_point = closest_point_on_line_cartesian;
-                  return return_values;
-                }
-            }
-          else
-            {
-              WBAssert(std::abs(y_axis.norm()) > std::numeric_limits<double>::epsilon(),
-                       "World Builder error: Cannot determine the up direction in the model. This is most likely due to the provided start radius being zero."
-                       << " Technical details: The y_axis.norm() is zero. Y_axis is " << y_axis
-                       << ". closest_point_on_line_cartesian = " << closest_point_on_line_cartesian
-                       << ", closest_point_on_line_bottom_cartesian = " << closest_point_on_line_bottom_cartesian);
-
-              WBAssert(!std::isnan(y_axis[0]),
-                       "Internal error: The y_axis variable is not a number: " << y_axis[0]);
-              WBAssert(!std::isnan(y_axis[1]),
-                       "Internal error: The y_axis variable is not a number: " << y_axis[1]);
-              WBAssert(!std::isnan(y_axis[2]),
-                       "Internal error: The y_axis variable is not a number: " << y_axis[2]);
-
-              y_axis = y_axis / y_axis.norm();
-
-              WBAssert(!std::isnan(y_axis[0]),
-                       "Internal error: The y_axis variable is not a number: " << y_axis[0]);
-              WBAssert(!std::isnan(y_axis[1]),
-                       "Internal error: The y_axis variable is not a number: " << y_axis[1]);
-              WBAssert(!std::isnan(y_axis[2]),
-                       "Internal error: The y_axis variable is not a number: " << y_axis[2]);
-
-
-              Point<2> check_point_surface_2d_temp = check_point_surface_2d;
-
-              if (!bool_cartesian)
-                {
-                  const double normal = std::fabs(point_list[i_section_min_distance+static_cast<size_t>((std::round(fraction_CPL_P1P2)))][0]-check_point_surface_2d[0]);
-                  const double plus   = std::fabs(point_list[i_section_min_distance+static_cast<size_t>((std::round(fraction_CPL_P1P2)))][0]-(check_point_surface_2d[0]+2*Consts::PI));
-                  const double min    = std::fabs(point_list[i_section_min_distance+static_cast<size_t>((std::round(fraction_CPL_P1P2)))][0]-(check_point_surface_2d[0]-2*Consts::PI));
-
-                  // find out whether the check point, checkpoint + 2pi or check point -2 pi is closest to the point list.
-                  if (plus < normal)
-                    {
-                      check_point_surface_2d_temp[0]+= 2*Consts::PI;
-                    }
-                  else if (min < normal)
-                    {
-                      check_point_surface_2d_temp[0]-= 2*Consts::PI;
-                    }
-                }
-
-              // check whether the check point and the reference point are on the same side, if not, change the side.
-              const Point<2> AB_normal = closest_point_on_curve.normal*closest_point_on_line_2d.distance(reference_point);//*AB.norm();
-              const Point<2> local_reference_point = AB_normal*1.+closest_point_on_line_2d;
-              const bool reference_normal_on_side_of_line =  (closest_point_on_line_2d-local_reference_point).norm_square() < (check_point_surface_2d_temp-local_reference_point).norm_square();
-              const bool reference_point_on_side_of_line =  (point_list[point_list.size()-1][0] - point_list[0][0])*(reference_point[1] - point_list[0][1]) - (reference_point[0] - point_list[0][0])*(point_list[point_list.size()-1][1] - point_list[0][1]) < 0.;
-              const double reference_on_side_of_line =  reference_normal_on_side_of_line == reference_point_on_side_of_line ? 1 : -1;
-
-              WBAssert(!std::isnan(x_axis[0]),
-                       "Internal error: The x_axis variable is not a number: " << x_axis[0]);
-              WBAssert(!std::isnan(x_axis[1]),
-                       "Internal error: The x_axis variable is not a number: " << x_axis[1]);
-              WBAssert(!std::isnan(x_axis[2]),
-                       "Internal error: The x_axis variable is not a number: " << x_axis[2]);
-
-              WBAssert(x_axis.norm() > 0.0, "x_axis norm is zero");
-
-              x_axis = x_axis *(reference_on_side_of_line / x_axis.norm());
-
-              WBAssert(!std::isnan(x_axis[0]),
-                       "Internal error: The x_axis variable is not a number: " << x_axis[0]);
-              WBAssert(!std::isnan(x_axis[1]),
-                       "Internal error: The x_axis variable is not a number: " << x_axis[1]);
-              WBAssert(!std::isnan(x_axis[2]),
-                       "Internal error: The x_axis variable is not a number: " << x_axis[2]);
-
-            }
-
-          WBAssert(!std::isnan(x_axis[0]),
-                   "Internal error: The x_axis[0] variable is not a number: " << x_axis[0] << ". Relevant values:  check_point = " << check_point << '.');
-          WBAssert(!std::isnan(x_axis[1]),
-                   "Internal error: The x_axis[1] variable is not a number: " << x_axis[1]);
-          WBAssert(!std::isnan(x_axis[2]),
-                   "Internal error: The x_axis[2] variable is not a number: " << x_axis[2]);
-
-          // now that we have the x and y axes computed, convert the 3d check point into a 2d one.
-          Point<2> check_point_2d(x_axis * (check_point - closest_point_on_line_bottom_cartesian),
-                                  y_axis * (check_point - closest_point_on_line_bottom_cartesian),
-                                  cartesian);
-
-          Point<2> begin_segment(x_axis * (closest_point_on_line_cartesian - closest_point_on_line_bottom_cartesian),
-                                 y_axis * (closest_point_on_line_cartesian - closest_point_on_line_bottom_cartesian),
-                                 cartesian);
-
-          WBAssert(!std::isnan(check_point_2d[0]),
-                   "Internal error: The check_point_2d variable is not a number: " << check_point_2d[0]);
-          WBAssert(!std::isnan(check_point_2d[1]),
-                   "Internal error: The check_point_2d variable is not a number: " << check_point_2d[1]);
-
-
-          WBAssert(!std::isnan(begin_segment[0]),
-                   "Internal error: The begin_segment variable is not a number: " << begin_segment[0]);
-          WBAssert(!std::isnan(begin_segment[1]),
-                   "Internal error: The begin_segment variable is not a number: " << begin_segment[1]);
-
-          Point<2> end_segment = begin_segment;
-
-          double total_length = 0.0;
-          double add_angle = 0.0;
-          double add_angle_correction = 0.0;
-          double average_angle = 0.0;
-          for (size_t i_segment = 0; i_segment < plane_segment_lengths[original_current_section].size(); i_segment++)
-            {
-              const size_t current_segment = i_segment;
-
-              // compute the angle between the previous begin and end if
-              // the depth method is angle_at_begin_segment_with_surface.
-              if (i_segment != 0
-                  &&
-                  (depth_method == DepthMethod::angle_at_begin_segment_with_surface
-                   ||
-                   depth_method == DepthMethod::angle_at_begin_segment_applied_to_end_segment_with_surface))
-                {
-                  double add_angle_inner = (begin_segment * end_segment) / (begin_segment.norm() * end_segment.norm());
-
-                  WBAssert(!std::isnan(add_angle_inner),
-                           "Internal error: The add_angle_inner variable is not a number: " << add_angle_inner
-                           << ". Variables: begin_segment = " << begin_segment
-                           << ", end_segment = " << end_segment
-                           << ", begin_segment * end_segment / (begin_segment.norm() * end_segment.norm()) = "
-                           << std::setprecision(32) << begin_segment * end_segment / (begin_segment.norm() * end_segment.norm())
-                           << '.');
-
-                  // there could be round of error problems here is the inner part is close to one
-                  if (add_angle_inner < 0. && add_angle_inner >= -1e-14)
-                    add_angle_inner = 0.;
-                  if (add_angle_inner > 1. && add_angle_inner <= 1.+1e-14)
-                    add_angle_inner = 1.;
-
-                  WBAssert(add_angle_inner >= 0 && add_angle_inner <= 1,
-                           "Internal error: The variable add_angle_inner is smaller than zero or larger then one,"
-                           "which causes the std::acos to return nan. If it is only a little bit larger then one, "
-                           "this is probably caused by that begin and end segment are the same and round off error. "
-                           "The value of add_angle_inner = " << add_angle_inner);
-
-                  add_angle_correction = std::acos(add_angle_inner);
-                  add_angle += add_angle_correction;
-
-                  WBAssert(!std::isnan(add_angle),
-                           "Internal error: The add_angle variable is not a number: " << add_angle
-                           << ". Variables: begin_segment = " << begin_segment
-                           << ", end_segment = " << end_segment
-                           << ", begin_segment * end_segment / (begin_segment.norm() * end_segment.norm()) = "
-                           << std::setprecision(32) << begin_segment * end_segment / (begin_segment.norm() * end_segment.norm())
-                           << ", std::acos(begin_segment * end_segment / (begin_segment.norm() * end_segment.norm())) = "
-                           << std::acos(begin_segment * end_segment / (begin_segment.norm() * end_segment.norm())));
-                }
-
-
-
-
-              begin_segment = end_segment;
-
-              WBAssert(!std::isnan(begin_segment[0]),
-                       "Internal error: The begin_segment variable is not a number: " << begin_segment[0]);
-              WBAssert(!std::isnan(begin_segment[1]),
-                       "Internal error: The begin_segment variable is not a number: " << begin_segment[1]);
-
-
-              // This interpolates different properties between P1 and P2 (the
-              // points of the plane at the surface)
-              const double degree_90_to_rad = 0.5 * Consts::PI;
-
-              WBAssert(plane_segment_angles.size() > original_next_section,
-                       "Error: original_next_section = " << original_next_section
-                       << ", and plane_segment_angles.size() = " << plane_segment_angles.size());
-
-
-              WBAssert(plane_segment_angles[original_next_section].size() > current_segment,
-                       "Error: current_segment = "  << current_segment
-                       << ", and current_segment.size() = " << plane_segment_angles[original_next_section].size());
-
-              const double interpolated_angle_top    = plane_segment_angles[original_current_section][current_segment][0]
-                                                       + fraction_CPL_P1P2 * (plane_segment_angles[original_next_section][current_segment][0]
-                                                                              - plane_segment_angles[original_current_section][current_segment][0])
-                                                       + add_angle
-                                                       + (depth_method == DepthMethod::angle_at_begin_segment_applied_to_end_segment_with_surface
-                                                          && i_segment != 0 ? -add_angle_correction: 0);
-
-              const double interpolated_angle_bottom = plane_segment_angles[original_current_section][current_segment][1]
-                                                       + fraction_CPL_P1P2 * (plane_segment_angles[original_next_section][current_segment][1]
-                                                                              - plane_segment_angles[original_current_section][current_segment][1])
-                                                       + add_angle;
-
-
-              const double interpolated_segment_length     = plane_segment_lengths[original_current_section][current_segment]
-                                                             + fraction_CPL_P1P2 * (plane_segment_lengths[original_next_section][current_segment]
-                                                                                    - plane_segment_lengths[original_current_section][current_segment]);
-
-              if (interpolated_segment_length < 1e-14)
-                continue;
-
-              WBAssert(!std::isnan(interpolated_angle_top),
-                       "Internal error: The interpolated_angle_top variable is not a number: " << interpolated_angle_top);
-
-              // We want to know where the end point of this segment is (and
-              // the start of the next segment). There are two cases which we
-              // will deal with separately. The first one is if the angle is
-              // constant. The second one is if the angle changes.
-              const double difference_in_angle_along_segment = interpolated_angle_top - interpolated_angle_bottom;
-
-              if (std::fabs(difference_in_angle_along_segment) < 1e-8)
-                {
-                  // The angle is constant. It is easy find find the end of
-                  // this segment and the distance.
-                  if (std::fabs(interpolated_segment_length) > std::numeric_limits<double>::epsilon())
-                    {
-                      end_segment[0] += interpolated_segment_length * std::sin(degree_90_to_rad - interpolated_angle_top);
-                      end_segment[1] -= interpolated_segment_length * std::cos(degree_90_to_rad - interpolated_angle_top);
-
-                      Point<2> begin_end_segment = end_segment - begin_segment;
-                      Point<2> normal_2d_plane(-begin_end_segment[0],begin_end_segment[1], cartesian);
-                      WBAssert(std::fabs(normal_2d_plane.norm()) > std::numeric_limits<double>::epsilon(), "Internal Error: normal_2d_plane.norm() is zero, which should not happen. "
-                               << "Extra info: begin_end_segment[0] = " << begin_end_segment[0]
-                               << ", begin_end_segment[1] = " << begin_end_segment[1]
-                               << ", end_segment: [" << end_segment[0] << ',' << end_segment[1] << ']'
-                               << ", begin_segment: [" << begin_segment[0] << ',' << begin_segment[1] << ']'
-                              );
-                      normal_2d_plane /= normal_2d_plane.norm();
-
-                      // Now find the distance of a point to this line.
-                      // Based on http://geomalgorithms.com/a02-_lines.html.
-                      const Point<2> BSP_ESP = end_segment - begin_segment;
-                      const Point<2> BSP_CP = check_point_2d - begin_segment;
-
-                      const double c1 = BSP_ESP * BSP_CP;
-                      const double c2 = BSP_ESP * BSP_ESP;
-
-                      if (c1 < 0 || c2 < c1)
-                        {
-                          new_distance = std::numeric_limits<double>::infinity();
-                          new_along_plane_distance = std::numeric_limits<double>::infinity();
-                          new_depth_reference_surface = std::numeric_limits<double>::infinity();
-                        }
-                      else
-                        {
-                          const Point<2> Pb = begin_segment + (c1/c2) * BSP_ESP;
-                          const double side_of_line =  (begin_segment[0] - end_segment[0]) * (check_point_2d[1] - begin_segment[1])
-                                                       - (begin_segment[1] - end_segment[1]) * (check_point_2d[0] - begin_segment[0])
-                                                       < 0 ? -1.0 : 1.0;
-
-                          new_distance = side_of_line * (check_point_2d - Pb).norm();
-                          new_along_plane_distance = (begin_segment - Pb).norm();
-                          new_depth_reference_surface = start_radius - Pb[1];
-
-                          WBAssert(!std::isnan(new_depth_reference_surface),
-                                   "new_depth_reference_surface is not a number: " << new_depth_reference_surface << ". "
-                                   << "start_radius = " << start_radius << ",Pb[1] = " << Pb[1] << ".");
-                        }
-                    }
-                }
-              else
-                {
-                  // The angle is not constant. This means that we need to
-                  // define a circle. First find the center of the circle.
-                  const double radius_angle_circle = std::fabs(interpolated_segment_length/difference_in_angle_along_segment);
-
-                  WBAssert(!std::isnan(radius_angle_circle),
-                           "Internal error: The radius_angle_circle variable is not a number: " << radius_angle_circle
-                           << ". interpolated_segment_length = " << interpolated_segment_length
-                           << ", difference_in_angle_along_segment = " << difference_in_angle_along_segment);
-
-                  const double cos_angle_top = std::cos(interpolated_angle_top);
-
-                  WBAssert(!std::isnan(cos_angle_top),
-                           "Internal error: The radius_angle_circle variable is not a number: " << cos_angle_top
-                           << ". interpolated_angle_top = " << interpolated_angle_top);
-
-                  Point<2> center_circle(cartesian);
-                  if (std::fabs(interpolated_angle_top - 0.5 * Consts::PI) < 1e-8)
-                    {
-                      // if interpolated_angle_top is 90 degrees, the tan function
-                      // is undefined (1/0). What we really want in this case is
-                      // set the center to the correct location which is x = the x
-                      //begin point + radius and y = the y begin point.
-                      center_circle[0] = difference_in_angle_along_segment > 0 ? begin_segment[0] + radius_angle_circle : begin_segment[0] - radius_angle_circle;
-                      center_circle[1] = begin_segment[1];
-                    }
-                  else if (std::fabs(interpolated_angle_top - 1.5 * Consts::PI) < 1e-8)
-                    {
-                      // if interpolated_angle_top is 270 degrees, the tan function
-                      // is undefined (-1/0). What we really want in this case is
-                      // set the center to the correct location which is x = the x
-                      //begin point - radius and y = the y begin point.
-                      center_circle[0] = difference_in_angle_along_segment > 0 ? begin_segment[0] - radius_angle_circle : begin_segment[0] + radius_angle_circle;
-                      center_circle[1] = begin_segment[1];
-                    }
-                  else
-                    {
-                      const double tan_angle_top = std::tan(interpolated_angle_top);
-
-                      WBAssert(!std::isnan(tan_angle_top),
-                               "Internal error: The tan_angle_top variable is not a number: " << tan_angle_top);
-                      const double center_circle_y = difference_in_angle_along_segment < 0 ?
-                                                     begin_segment[1] - radius_angle_circle * cos_angle_top
-                                                     : begin_segment[1] + radius_angle_circle * cos_angle_top;
-
-                      WBAssert(!std::isnan(center_circle_y),
-                               "Internal error: The center_circle_y variable is not a number: " << center_circle_y
-                               << ". begin_segment[1] = " << begin_segment[1]
-                               << ", radius_angle_circle = " << radius_angle_circle
-                               << ", cos_angle_top = " << cos_angle_top);
-
-                      // to prevent round off errors becoming dominant, we check
-                      // whether center_circle_y - begin_segment[1] should be zero.
-                      // TODO: improve this to some kind of relative difference.
-                      const double CCYBS = center_circle_y - begin_segment[1];
-
-                      WBAssert(!std::isnan(CCYBS),
-                               "Internal error: The CCYBS variable is not a number: " << CCYBS);
-
-
-
-                      center_circle[0] = begin_segment[0] + tan_angle_top * (CCYBS);
-                      center_circle[1] = center_circle_y;
-                    }
-
-                  WBAssert(!std::isnan(center_circle[0]) || !std::isnan(center_circle[1]),
-                           "Internal error: The center variable contains not a number: " << center_circle[0] << ':' << center_circle[0]);
-                  WBAssert(std::fabs((begin_segment-center_circle).norm() - std::fabs(radius_angle_circle))
-                           < 1e-8 * std::fabs((begin_segment-center_circle).norm() + std::fabs(radius_angle_circle)),
-                           "Internal error: The center of the circle is not a radius away from the begin point. " << std::endl
-                           << "The center is located at " << center_circle[0] << ':' << center_circle[1] << std::endl
-                           << "The begin point is located at " << begin_segment[0] << ':' << begin_segment[1] << std::endl
-                           << "The computed radius is " << std::fabs((begin_segment-center_circle).norm())
-                           << ", and it should be " << radius_angle_circle << '.');
-
-
-                  // Now compute the location of the end of the segment by
-                  // rotating P1 around the center_circle
-                  Point<2> BSPC = begin_segment - center_circle;
-                  const double sin_angle_diff = sin(difference_in_angle_along_segment);
-                  const double cos_angle_diff = cos(difference_in_angle_along_segment);
-                  end_segment[0] = cos_angle_diff * BSPC[0] - sin_angle_diff * BSPC[1] + center_circle[0];
-                  end_segment[1] = sin_angle_diff * BSPC[0] + cos_angle_diff * BSPC[1] + center_circle[1];
-
-
-
-                  WBAssert(std::fabs((end_segment-center_circle).norm() - std::fabs(radius_angle_circle))
-                           < 1e-8 * std::fabs((end_segment-center_circle).norm() + std::fabs(radius_angle_circle)) ,
-                           "Internal error: The center of the circle is not a radius away from the end point. " << std::endl
-                           << "The center is located at " << center_circle[0] << ':' << center_circle[1] << std::endl
-                           << "The end point is located at " << end_segment[0] << ':' << end_segment[1] << std::endl
-                           << "The computed radius is " << std::fabs((end_segment-center_circle).norm())
-                           << ", and it should be " << radius_angle_circle << '.');
-
-                  // Now check if the angle of the check point in this circle
-                  // is larger then the angle of P1 and smaller then P1 + angle
-                  // difference. If that is the case then the distance from the
-                  // plane is radius - (center - check_point).norm(). Otherwise
-                  // it is infinity.
-                  // The angle of the check point is computed with the help of
-                  // dot product. But before that we need to adjust the check
-                  // point 2d.
-                  const Point<2> CPCR = check_point_2d - center_circle;
-                  const double CPCR_norm = CPCR.norm();
-
-                  const double dot_product = CPCR * Point<2>(0, radius_angle_circle, cartesian);
-                  // If the x of the check point is larger then the x of center
-                  // the circle, the angle is more than 180 degree, but the dot
-                  // product will decrease instead of increase from 180 degrees.
-                  // To fix this we make a special case for this.
-                  // Furthermore, when the check point is at the same location as
-                  // the center of the circle, we count that point as belonging
-                  // to the top of the top segment (0 degree).
-                  double check_point_angle = std::fabs(CPCR_norm) < std::numeric_limits<double>::epsilon() ? 2.0 * Consts::PI : (check_point_2d[0] <= center_circle[0]
-                                             ? std::acos(dot_product/(CPCR_norm * radius_angle_circle))
-                                             : 2.0 * Consts::PI - std::acos(dot_product/(CPCR_norm * radius_angle_circle)));
-                  check_point_angle = difference_in_angle_along_segment >= 0 ? Consts::PI - check_point_angle : 2.0 * Consts::PI - check_point_angle;
-
-                  // In the case that it is exactly 2 * pi, bring it back to zero
-                  check_point_angle = (std::fabs(check_point_angle - 2 * Consts::PI) < 1e-14 ? 0 : check_point_angle);
-
-                  if ((difference_in_angle_along_segment > 0 && (check_point_angle <= interpolated_angle_top || std::fabs(check_point_angle - interpolated_angle_top) < 1e-12)
-                       && (check_point_angle >= interpolated_angle_bottom || std::fabs(check_point_angle - interpolated_angle_bottom) < 1e-12))
-                      || (difference_in_angle_along_segment < 0 && (check_point_angle >= interpolated_angle_top || std::fabs(check_point_angle - interpolated_angle_top) < 1e-12)
-                          && (check_point_angle <= interpolated_angle_bottom || std::fabs(check_point_angle - interpolated_angle_bottom) < 1e-12)))
-                    {
-                      new_distance = (radius_angle_circle - CPCR_norm) * (difference_in_angle_along_segment < 0 ? 1 : -1);
-                      new_along_plane_distance = (radius_angle_circle * check_point_angle - radius_angle_circle * interpolated_angle_top) * (difference_in_angle_along_segment < 0 ? 1 : -1);
-                      // compute the new depth by rotating the begin point to the check point location.
-                      new_depth_reference_surface = start_radius-(sin(check_point_angle + interpolated_angle_top) * BSPC[0] + cos(check_point_angle + interpolated_angle_top) * BSPC[1] + center_circle[1]);
-
-                      WBAssert(!std::isnan(new_depth_reference_surface),
-                               "new_depth_reference_surface is not a number: " << new_depth_reference_surface << ". "
-                               << "start_radius = " << start_radius << ", check_point_angle = " << check_point_angle << ", interpolated_angle_top = " << interpolated_angle_top
-                               << ", BSPC[0] = " << BSPC[0] << ".");
-                    }
-
-                }
-
-              // Now we need to see whether we need to update the information
-              // based on whether this segment is the closest one to the point
-              // up to now. To do this we first look whether the point falls
-              // within the bound of the segment and if it is actually closer.
-              // TODO: find out whether the fabs() are needed.
-              if (new_along_plane_distance >= -1e-10 &&
-                  new_along_plane_distance <= std::fabs(interpolated_segment_length) &&
-                  std::fabs(new_distance) < std::fabs(distance))
-                {
-                  // There are two specific cases we are concerned with. The
-                  // first case is that we want to have both the positive and
-                  // negative distances (above and below the line). The second
-                  // case is that we only want positive distances.
-                  distance = only_positive ? std::fabs(new_distance) : new_distance;
-                  along_plane_distance = new_along_plane_distance + total_length;
-                  section = i_section_min_distance;
-                  section_fraction = fraction_CPL_P1P2;
-                  segment = i_segment;
-                  segment_fraction = new_along_plane_distance / interpolated_segment_length;
-                  total_average_angle = (average_angle * total_length
-                                         + 0.5 * (interpolated_angle_top + interpolated_angle_bottom  - 2 * add_angle) * new_along_plane_distance);
-                  total_average_angle = (std::fabs(total_average_angle) < std::numeric_limits<double>::epsilon() ? 0 : total_average_angle /
-                                         (total_length + new_along_plane_distance));
-                  depth_reference_surface = new_depth_reference_surface;
-                }
-
-              // increase average angle
-              average_angle = (average_angle * total_length +
-                               0.5 * (interpolated_angle_top + interpolated_angle_bottom  - 2 * add_angle) * interpolated_segment_length);
-              average_angle = (std::fabs(average_angle) < std::numeric_limits<double>::epsilon() ? 0 : average_angle /
-                               (total_length + interpolated_segment_length));
-              // increase the total length for the next segment.
-              total_length += interpolated_segment_length;
-            }
-        }
-
-      WBAssert(!std::isnan(depth_reference_surface), "depth_reference_surface is not a number: " << depth_reference_surface << ".");
-
-      PointDistanceFromCurvedPlanes return_values(natural_coordinate.get_coordinate_system());
-      return_values.distance_from_plane = distance;
-      return_values.distance_along_plane = along_plane_distance;
-      return_values.fraction_of_section = section_fraction;
-      return_values.fraction_of_segment = segment_fraction;
-      return_values.section = section;
-      return_values.segment = segment;
-      return_values.average_angle = total_average_angle;
-      return_values.depth_reference_surface = depth_reference_surface;
-      return_values.closest_trench_point = closest_point_on_line_cartesian;
-      return return_values;
-    }
-
-    void interpolation::set_points(const std::vector<double> &y)
-    {
-      const size_t n = y.size();
-      mx_size_min = n;
-      m.resize(n);
-      for (unsigned int i = 0; i < n; ++i)
-        {
-          m[i][3] = y[i];
-        }
-
-      /**
-       * This monotone spline algorithm is based on the javascript version
-       * at https://en.wikipedia.org/wiki/Monotone_cubic_interpolation. The
-       * parameters from this algorithm prevent overshooting in the
-       * interpolation spline.
-       */
-
-      // get m_a parameter
-      m[0][2] = 0;
-
-      for (size_t i = 0; i < n-2; i++)
-        {
-          const double m0 = y[i+1]-y[i];
-          const double m1 =  y[i+2]-y[i+1];
-
-          if (m0 * m1 <= 0)
-            {
-              m[i+1][2] = 0;
-            }
-          else
-            {
-              m[i+1][2] = 2*m0*m1/(m0+m1);
-            }
-        }
-      m[n-1][2] =  y[n-1]-y[n-2];
-
-      // Get b and c coefficients
-      //m_a.resize(n);
-      //m_b.resize(n);
-      for (size_t i = 0; i < n-1; i++)
-        {
-          const double c1 = m[i][2];
-          const double m0 = y[i+1]-y[i];
-
-          const double common0 = c1 + m[i+1][2] - m0 - m0;
-          m[i][1] = (m0 - c1 - common0);
-          m[i][0] = common0;
-        }
-    }
-
-    double wrap_angle(const double angle)
-    {
-      return angle - 360.0*std::floor(angle/360.0);
-    }
-
-    double interpolate_angle_across_zero(const double angle_1,
-                                         const double angle_2,
-                                         const double fraction)
-    {
-      double theta_1 = angle_1;
-      double theta_2 = angle_2;
-      double rotation_angle;
-
-      if (std::abs(theta_2 - theta_1) > Consts::PI)
-        {
-          if (theta_2 > theta_1)
-            theta_1 += 2.*Consts::PI;
-          else
-            theta_2 += 2.*Consts::PI;
-        }
-      rotation_angle = (1-fraction) * theta_1 + fraction * theta_2;
-
-      // make sure angle is between 0 and 360 degrees
-      rotation_angle = rotation_angle - 2*Consts::PI*std::floor(rotation_angle/(2 * Consts::PI));
-
-      return rotation_angle;
-    }
-
-    std::array<double,3>
-    euler_angles_from_rotation_matrix(const std::array<std::array<double,3>,3> &rotation_matrix)
-    {
-      const double rad_to_degree = 180.0/Consts::PI;
-      std::array<double,3> euler_angles;
-      //const double s2 = std::sqrt(rotation_matrix[2][1] * rotation_matrix[2][1] + rotation_matrix[2][0] * rotation_matrix[2][0]);
-      const std::ostringstream os;
-      for (size_t i = 0; i < 3; i++)
-        for (size_t j = 0; j < 3; j++)
-          WBAssert(std::fabs(rotation_matrix[i][j]) <= 1.0,
-                   "rotation_matrix[" + std::to_string(i) + "][" + std::to_string(j) +
-                   "] is larger than one: " + std::to_string(rotation_matrix[i][j]) + ". rotation_matrix = \n"
-                   + std::to_string(rotation_matrix[0][0]) + " " + std::to_string(rotation_matrix[0][1]) + " " + std::to_string(rotation_matrix[0][2]) + "\n"
-                   + std::to_string(rotation_matrix[1][0]) + " " + std::to_string(rotation_matrix[1][1]) + " " + std::to_string(rotation_matrix[1][2]) + "\n"
-                   + std::to_string(rotation_matrix[2][0]) + " " + std::to_string(rotation_matrix[2][1]) + " " + std::to_string(rotation_matrix[2][2]));
-
-
-      const double theta = std::acos(rotation_matrix[2][2]);
-      const double phi1  = std::atan2(rotation_matrix[2][0]/-sin(theta),rotation_matrix[2][1]/-sin(theta));
-      const double phi2  = std::atan2(rotation_matrix[0][2]/-sin(theta),rotation_matrix[1][2]/sin(theta));
-
-      euler_angles[0] = wrap_angle(phi1 * rad_to_degree);
-      euler_angles[1] = wrap_angle(theta * rad_to_degree);
-      euler_angles[2] = wrap_angle(phi2 * rad_to_degree);
-
-      return euler_angles;
-    }
-
-    std::array<std::array<double,3>,3>
-    euler_angles_to_rotation_matrix(double phi1_d, double theta_d, double phi2_d)
-    {
-
-      const double degree_to_rad = Consts::PI/180.0;
-      const double phi1 = phi1_d * degree_to_rad;
-      const double theta = theta_d * degree_to_rad;
-      const double phi2 = phi2_d * degree_to_rad;
-      std::array<std::array<double,3>,3> rot_matrix;
-
-
-      rot_matrix[0][0] = cos(phi2)*cos(phi1) - cos(theta)*sin(phi1)*sin(phi2);
-      rot_matrix[0][1] = -cos(phi2)*sin(phi1) - cos(theta)*cos(phi1)*sin(phi2);
-      rot_matrix[0][2] = -sin(phi2)*sin(theta);
-
-      rot_matrix[1][0] = sin(phi2)*cos(phi1) + cos(theta)*sin(phi1)*cos(phi2);
-      rot_matrix[1][1] = -sin(phi2)*sin(phi1) + cos(theta)*cos(phi1)*cos(phi2);
-      rot_matrix[1][2] = cos(phi2)*sin(theta);
-
-      rot_matrix[2][0] = -sin(theta)*sin(phi1);
-      rot_matrix[2][1] = -sin(theta)*cos(phi1);
-      rot_matrix[2][2] = cos(theta);
-      return rot_matrix;
-    }
-
-    std::string
-    read_and_distribute_file_content(const std::string &filename)
-    {
-      std::string data_string;
-
-#ifdef WB_WITH_MPI
-      int mpi_initialized;
-      MPI_Initialized(&mpi_initialized);
-      if (mpi_initialized != 0)
-        {
-          const MPI_Comm comm = MPI_COMM_WORLD;
-          int my_rank = 0;
-          MPI_Comm_rank(comm, &my_rank);
-          if (my_rank == 0)
-            {
-              int filesize;
-              std::ifstream filestream;
-              filestream.open(filename.c_str());
-              WBAssertThrow (filestream.is_open(), std::string("Could not open file <") + filename + ">.");
-
-              // Need to convert to unsigned int, because MPI_Bcast does not support
-              // size_t or const unsigned int
-              int invalid_file_size = -1;
-
-              if (!filestream)
-                {
-                  // broadcast failure state, then throw
-                  const int ierr = MPI_Bcast(&invalid_file_size, 1, MPI_UNSIGNED, 0, comm);
-                  WBAssertThrow (ierr,
-                                 std::string("Could not open file <") + filename + ">.");
-                }
-
-              // Read data from disk
-              std::stringstream datastream;
-
-              try
-                {
-                  datastream << filestream.rdbuf();
-                }
-              catch (const std::ios::failure &)
-                {
-                  // broadcast failure state, then throw
-                  const int ierr = MPI_Bcast(&invalid_file_size, 1, MPI_UNSIGNED, 0, comm);
-                  WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
-                  WBAssertThrow (false,
-                                 std::string("Could not read file content from <") + filename + ">.");
-                }
-
-              data_string = datastream.str();
-              WBAssertThrow(static_cast<long int>(data_string.size()) < std::numeric_limits<int>::max(),
-                            "File is too large to be send with MPI.");
-              filesize = static_cast<int>(data_string.size());
-
-              // Distribute data_size and data across processes
-              int ierr = MPI_Bcast(&filesize, 1, MPI_UNSIGNED, 0, comm);
-              WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
-
-              // Receive and store data
-              ierr = MPI_Bcast(&data_string[0],
-                               filesize,
-                               MPI_CHAR,
-                               0,
-                               comm);
-              WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
-            }
-          else
-            {
-              // Prepare for receiving data
-              int filesize = 0;
-              int ierr = MPI_Bcast(&filesize, 1, MPI_UNSIGNED, 0, comm);
-              WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
-              WBAssertThrow(filesize != -1,
-                            std::string("Could not open file <") + filename + ">.");
-
-              data_string.resize(static_cast<size_t>(filesize));
-
-              // Receive and store data
-              ierr = MPI_Bcast(&data_string[0],
-                               filesize,
-                               MPI_CHAR,
-                               0,
-                               comm);
-              WBAssertThrow(ierr == 0, "MPI_Bcast failed.");
-            }
-        }
-      else
-        {
-          std::ifstream filestream;
-          filestream.open(filename.c_str());
-          if (!filestream)
-            {
-              WBAssertThrow (false,
-                             std::string("Could not open file <") + filename + ">.");
-            }
-          std::stringstream datastream;
-          datastream << filestream.rdbuf();
-          data_string = datastream.str();
-        }
-#else
-      std::ifstream filestream;
-      filestream.open(filename.c_str());
-      if (!filestream)
-        {
-          WBAssertThrow (false,
-                         std::string("Could not open file <") + filename + ">.");
-        }
-      std::stringstream datastream;
-      datastream << filestream.rdbuf();
-      data_string = datastream.str();
-#endif
-
-      return data_string;
-    }
-
-    template std::array<double,2> convert_point_to_array<2>(const Point<2> &point_);
-    template std::array<double,3> convert_point_to_array<3>(const Point<3> &point_);
-
-
-    std::vector<double>
-    calculate_ridge_distance_and_spreading(std::vector<std::vector<Point<2>>> mid_oceanic_ridges,
-                                           std::vector<std::vector<double>> mid_oceanic_spreading_velocities,
-                                           const std::unique_ptr<WorldBuilder::CoordinateSystems::Interface> &coordinate_system,
-                                           const Objects::NaturalCoordinate &position_in_natural_coordinates_at_min_depth,
-                                           const std::vector<std::vector<double>> &subducting_plate_velocities,
-                                           const std::vector<double> &ridge_migration_times)
-    {
-      const double seconds_in_year = 60.0 * 60.0 * 24.0 * 365.25;  // sec/y
-
-      double distance_ridge = std::numeric_limits<double>::max();
-      double spreading_velocity_at_ridge = 0;
-      double subducting_velocity_at_trench = 0;
-      double ridge_migration_time = 0;
-
-      // first find if the coordinate is on this side of a ridge
-      unsigned int relevant_ridge = 0;
-      const Point<2> check_point(position_in_natural_coordinates_at_min_depth.get_surface_coordinates(),
-                                 position_in_natural_coordinates_at_min_depth.get_coordinate_system());
-
-      Point<2> other_check_point = check_point;
-      if (check_point.get_coordinate_system() == CoordinateSystem::spherical)
-        other_check_point[0] += check_point[0] < 0 ? 2.0 * WorldBuilder::Consts::PI : -2.0 * WorldBuilder::Consts::PI;
-
-      // if there is only one ridge, there is no transform
-      if (mid_oceanic_ridges[0].size() > 1)
-        {
-          // There are more than one ridge, so there are transform faults
-          // Find the first which is on the same side
-          for (relevant_ridge = 0; relevant_ridge < mid_oceanic_ridges.size()-1; relevant_ridge++)
-            {
-              const Point<2> transform_point_0 = mid_oceanic_ridges[relevant_ridge+1][0];
-              const Point<2> transform_point_1 = mid_oceanic_ridges[relevant_ridge][mid_oceanic_ridges[relevant_ridge].size()-1];
-              const Point<2> reference_point   = mid_oceanic_ridges[relevant_ridge][0];
-              const bool reference_on_side_of_line = (transform_point_1[0] - transform_point_0[0])
-                                                     * (reference_point[1] - transform_point_0[1])
-                                                     - (transform_point_1[1] - transform_point_0[1])
-                                                     * (reference_point[0] - transform_point_0[0])
-                                                     < 0;
-              const bool checkpoint_on_side_of_line = (transform_point_1[0] - transform_point_0[0])
-                                                      * (check_point[1] - transform_point_0[1])
-                                                      - (transform_point_1[1] - transform_point_0[1])
-                                                      * (check_point[0] - transform_point_0[0])
-                                                      < 0;
-
-
-              if (reference_on_side_of_line == checkpoint_on_side_of_line)
-                {
-                  break;
-                }
-
-            }
-        }
-
-      for (unsigned int i_coordinate = 0; i_coordinate < mid_oceanic_ridges[relevant_ridge].size() - 1; i_coordinate++)
-        {
-          const Point<2> segment_point0 = mid_oceanic_ridges[relevant_ridge][i_coordinate];
-          const Point<2> segment_point1 = mid_oceanic_ridges[relevant_ridge][i_coordinate + 1];
-
-          const double spreading_velocity_point0 = mid_oceanic_spreading_velocities[relevant_ridge][i_coordinate];
-          const double spreading_velocity_point1 = mid_oceanic_spreading_velocities[relevant_ridge][i_coordinate + 1];
-
-          // When subducting_velocities is not input by the user, default value is 0, which
-          // results in subducting velocity == spreading_velocity. When a single value is
-          // input by the user, subducting velocity != spreading_velocity, but
-          // subducting velocity is spatially constant.
-          double subducting_velocity_point0 = subducting_plate_velocities[0][0];
-          double subducting_velocity_point1 = subducting_plate_velocities[0][0];
-
-          // When subducting_velocities is input as an array, spatial variation
-          if (subducting_plate_velocities[0].size() > 1)
-            {
-              WBAssert(subducting_plate_velocities.size() == mid_oceanic_ridges.size() && \
-                       subducting_plate_velocities[relevant_ridge].size() == mid_oceanic_ridges[relevant_ridge].size(),
-                       "subducting velocity and ridge coordinates must be the same dimension");
-              WBAssert(ridge_migration_times.size() == mid_oceanic_ridges.size(),
-                       "the times for ridge migration specified in 'spreading velocity' must be the same dimension "
-                       "as ridge coordinates.");
-              subducting_velocity_point0 = subducting_plate_velocities[relevant_ridge][i_coordinate];
-              subducting_velocity_point1 = subducting_plate_velocities[relevant_ridge][i_coordinate + 1];
-              ridge_migration_time = ridge_migration_times[relevant_ridge];
-            }
-
-          {
-            // based on http://geomalgorithms.com/a02-_lines.html
-            const Point<2> v = segment_point1 - segment_point0;
-            const Point<2> w1 = check_point - segment_point0;
-            const Point<2> w2 = other_check_point - segment_point0;
-
-            const double c1 = (w1[0] * v[0] + w1[1] * v[1]);
-            const double c = (v[0] * v[0] + v[1] * v[1]);
-            const double c2 = (w2[0] * v[0] + w2[1] * v[1]);
-
-
-            Point<2> Pb1(coordinate_system->natural_coordinate_system());
-            // This part is needed when we want to consider segments instead of lines
-            // If you want to have infinite lines, use only the else statement.
-
-            // First, compare the results from the two compare points
-            double spreading_velocity_at_ridge_pt1 = 0.0;
-            double subducting_velocity_at_trench_pt1 = 0.0;
-            double spreading_velocity_at_ridge_pt2 = 0.0;
-            double subducting_velocity_at_trench_pt2 = 0.0;
-
-            if (c1 <= 0)
-              {
-                Pb1=segment_point0;
-                spreading_velocity_at_ridge_pt1 = spreading_velocity_point0;
-                subducting_velocity_at_trench_pt1 = subducting_velocity_point0;
-              }
-            else if (c <= c1)
-              {
-                Pb1=segment_point1;
-                spreading_velocity_at_ridge_pt1 = spreading_velocity_point1;
-                subducting_velocity_at_trench_pt1 = subducting_velocity_point1;
-              }
-            else
-              {
-                Pb1=segment_point0 + (c1 / c) * v;
-                spreading_velocity_at_ridge_pt1 = spreading_velocity_point0 + (spreading_velocity_point1 - spreading_velocity_point0) * (c1 / c);
-                subducting_velocity_at_trench_pt1 = subducting_velocity_point0 + (subducting_velocity_point1 - subducting_velocity_point0) * (c1 / c);
-              }
-
-            Point<2> Pb2(coordinate_system->natural_coordinate_system());
-            if (c2 <= 0)
-              {
-                Pb2=segment_point0;
-                spreading_velocity_at_ridge_pt2 = spreading_velocity_point0;
-                subducting_velocity_at_trench_pt2 = subducting_velocity_point0;
-              }
-            else if (c <= c2)
-              {
-                Pb2=segment_point1;
-                spreading_velocity_at_ridge_pt2 = spreading_velocity_point1;
-                subducting_velocity_at_trench_pt2 = spreading_velocity_point1;
-              }
-            else
-              {
-                Pb2=segment_point0 + (c2 / c) * v;
-                spreading_velocity_at_ridge_pt2 = spreading_velocity_point0 + (spreading_velocity_point1 - spreading_velocity_point0) * (c2 / c);
-                subducting_velocity_at_trench_pt2 = subducting_velocity_point0 + (subducting_velocity_point1 - subducting_velocity_point0) * (c2 / c);
-              }
-
-            Point<3> compare_point1(coordinate_system->natural_coordinate_system());
-            Point<3> compare_point2(coordinate_system->natural_coordinate_system());
-
-            compare_point1[0] = coordinate_system->natural_coordinate_system() == cartesian ? Pb1[0] :  position_in_natural_coordinates_at_min_depth.get_depth_coordinate();
-            compare_point1[1] = coordinate_system->natural_coordinate_system() == cartesian ? Pb1[1] : Pb1[0];
-            compare_point1[2] = coordinate_system->natural_coordinate_system() == cartesian ? position_in_natural_coordinates_at_min_depth.get_depth_coordinate() : Pb1[1];
-
-            compare_point2[0] = coordinate_system->natural_coordinate_system() == cartesian ? Pb2[0] :  position_in_natural_coordinates_at_min_depth.get_depth_coordinate();
-            compare_point2[1] = coordinate_system->natural_coordinate_system() == cartesian ? Pb2[1] : Pb2[0];
-            compare_point2[2] = coordinate_system->natural_coordinate_system() == cartesian ? position_in_natural_coordinates_at_min_depth.get_depth_coordinate() : Pb2[1];
-
-            const double compare_distance1 = coordinate_system->distance_between_points_at_same_depth(Point<3>(position_in_natural_coordinates_at_min_depth.get_coordinates(),
-                                             position_in_natural_coordinates_at_min_depth.get_coordinate_system()),
-                                             compare_point1);
-
-            const double compare_distance2 = coordinate_system->distance_between_points_at_same_depth(Point<3>(position_in_natural_coordinates_at_min_depth.get_coordinates(),
-                                             position_in_natural_coordinates_at_min_depth.get_coordinate_system()),
-                                             compare_point2);
-
-            double compare_distance = compare_distance1;
-            double spreading_velocity_at_ridge_pt = spreading_velocity_at_ridge_pt1;
-            double subducting_velocity_at_trench_pt = subducting_velocity_at_trench_pt1;
-
-            // This is required in spherical coordinates to ensure that the distance
-            // returned is the shortest distance around the sphere.
-            if (compare_distance2 < compare_distance1)
-              {
-                compare_distance = compare_distance2;
-                spreading_velocity_at_ridge_pt = spreading_velocity_at_ridge_pt2;
-                subducting_velocity_at_trench_pt = subducting_velocity_at_trench_pt2;
-              }
-
-            // Then, the distance and velocities are taken from the nearest point on the ridge
-            if (i_coordinate == 0 || compare_distance < distance_ridge)
-              {
-                distance_ridge = compare_distance;
-                spreading_velocity_at_ridge = spreading_velocity_at_ridge_pt;
-                subducting_velocity_at_trench = subducting_velocity_at_trench_pt;
-              }
-          }
-        }
-      std::vector<double> result;
-      result.push_back(spreading_velocity_at_ridge / seconds_in_year); // m/s
-      result.push_back(distance_ridge);
-      result.push_back(subducting_velocity_at_trench / seconds_in_year); // m/s
-      result.push_back(ridge_migration_time);
-      return result;
-    }
-
-    // TODO: implement method for modifying the age of the slab based on ridge/trench migration.
-    std::vector<double>
-    calculate_effective_trench_and_plate_ages(std::vector<double> ridge_parameters, double distance_along_plane)
-    {
-      WBAssert(ridge_parameters.size() == 4, "Internal error: ridge_parameters have the wrong size: " << ridge_parameters.size() << " instead of 4.");
-      const double seconds_in_year = 60.0 * 60.0 * 24.0 * 365.25;  // sec/y
-      const double spreading_velocity = ridge_parameters[0] * seconds_in_year; // m/yr
-      double subducting_velocity = ridge_parameters[2] * seconds_in_year; // m/yr
-
-      if (subducting_velocity <= 0)
-        subducting_velocity = spreading_velocity;
-
-      const double age_at_trench = ridge_parameters[1] / spreading_velocity; // m/(m/y) = yr
-      const double plate_age_sec = age_at_trench * seconds_in_year; // y --> seconds
-
-      // Plate age increases with distance along the slab in the mantle
-      double effective_plate_age = plate_age_sec + (distance_along_plane / subducting_velocity) * seconds_in_year; // m/(m/y) = y(seconds_in_year)
-      WBAssertThrow(effective_plate_age >= 0, "The age of the subducting plate is less than or equal to 0. "
-                    "Effective plate age: " << effective_plate_age);
-      std::vector<double> result;
-      result.push_back(age_at_trench);
-      result.push_back(effective_plate_age);
-      return result;
-
-    }
-  } // namespace Utilities
-} // namespace WorldBuilder
-
-
-
diff --git a/contrib/world_builder/source/world_builder/world.cc.bak b/contrib/world_builder/source/world_builder/world.cc.bak
deleted file mode 100644
index 6871f29ea9c..00000000000
--- a/contrib/world_builder/source/world_builder/world.cc.bak
+++ /dev/null
@@ -1,498 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/world.h"
-
-
-#include "world_builder/config.h"
-#include "world_builder/features/subducting_plate.h"
-#include "world_builder/gravity_model/interface.h"
-#include "world_builder/nan.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/plugin_system.h"
-#include "world_builder/types/point.h"
-#include "world_builder/types/int.h"
-
-#include <iostream>
-#include <world_builder/coordinate_system.h>
-#include <world_builder/objects/distance_from_surface.h>
-
-#ifdef WB_WITH_MPI
-// we don't need the c++ MPI wrappers
-#define OMPI_SKIP_MPICXX 1
-#define MPICH_SKIP_MPICXX
-#include <mpi.h>
-#endif
-
-#ifndef NDEBUG
-#ifdef WB_USE_FP_EXCEPTIONS
-#include <cfenv>
-#endif
-#endif
-
-namespace WorldBuilder
-{
-  using namespace Utilities;
-
-  World::World(std::string filename, bool has_output_dir, const std::string &output_dir, unsigned long random_number_seed, const bool limit_debug_consistency_checks_)
-    :
-    parameters(*this),
-    surface_coord_conversions(invalid),
-    dim(NaN::ISNAN),
-    random_number_engine(random_number_seed),
-    limit_debug_consistency_checks(limit_debug_consistency_checks_)
-  {
-
-#ifndef NDEBUG
-#ifdef WB_USE_FP_EXCEPTIONS
-    // Some implementations seem to not initialize the floating point exception
-    // bits to zero. Make sure we start from a clean state.
-    feclearexcept(FE_DIVBYZERO|FE_INVALID);
-
-    // enable floating point exceptions
-    feenableexcept(FE_DIVBYZERO|FE_INVALID);
-#endif
-#endif
-
-#ifdef WB_WITH_MPI
-    int mpi_initialized;
-    MPI_Initialized(&mpi_initialized);
-    if (mpi_initialized == 0)
-      {
-        MPI_RANK = 0;
-        MPI_SIZE = 1;
-      }
-    else
-      {
-        MPI_Comm_rank(MPI_COMM_WORLD, &MPI_RANK);
-        MPI_Comm_size(MPI_COMM_WORLD, &MPI_SIZE);
-      }
-#else
-    MPI_RANK = 0;
-    MPI_SIZE = 1;
-#endif
-
-    WorldBuilder::World::declare_entries(parameters);
-
-    parameters.initialize(filename, has_output_dir, output_dir);
-
-    this->parse_entries(parameters);
-  }
-
-  World::~World()
-    = default;
-
-  void World::declare_entries(Parameters &prm)
-  {
-    prm.enter_subsection("properties");
-    {
-      prm.declare_entry("", Types::Object({"version", "features"}), "Root object");
-
-      prm.declare_entry("version", Types::String(""),"The major and minor version number for which the input file was written.");
-
-      prm.declare_entry("$schema", Types::String(""),"The optional filename or https address to a JSON schema file");
-
-      prm.declare_entry("cross section", Types::Array(Types::Point<2>(),2,2),"This is an array of two points along where the cross section is taken");
-
-      prm.declare_entry("potential mantle temperature", Types::Double(1600),
-                        "The potential temperature of the mantle at the surface in Kelvin.");
-      prm.declare_entry("surface temperature", Types::Double(293.15),
-                        "The temperature at the surface in Kelvin.");
-      prm.declare_entry("force surface temperature", Types::Bool(false),
-                        "Force the provided surface temperature to be set at the surface");
-      prm.declare_entry("thermal expansion coefficient", Types::Double(3.5e-5),
-                        "The thermal expansion coefficient in $K^{-1}$.");
-      prm.declare_entry("specific heat", Types::Double(1250),
-                        "The specific heat in $J kg^{-1} K^{-1}.$");
-      prm.declare_entry("thermal diffusivity", Types::Double(0.804e-6),
-                        "The thermal diffusivity in $m^{2} s^{-1}$.");
-
-      prm.declare_entry("maximum distance between coordinates",Types::Double(0),
-                        "This enforces a maximum distance (in degree for spherical coordinates "
-                        "or meter in cartesian coordinates) between coordinates in the model. "
-                        "If the distance is larger, extra points are added by interpolation. "
-                        "Requires interpolation to be not 'none'.");
-
-      prm.declare_entry("interpolation",Types::String("continuous monotone spline"),
-                        "What type of interpolation should be used to enforce the minimum points per "
-                        "distance parameter. Options are none, linear, monotone spline and "
-                        "continuous monotone spline interpolation.");
-
-
-      prm.declare_entry("coordinate system", Types::PluginSystem("cartesian", CoordinateSystems::Interface::declare_entries, {"model"}, false),"A coordinate system. Cartesian or spherical.");
-
-      prm.declare_entry("gravity model", Types::PluginSystem("uniform", GravityModel::Interface::declare_entries, {"model"}, false),"A gravity model for the world.");
-
-      prm.declare_entry("features", Types::PluginSystem("",Features::Interface::declare_entries, {"model"}),"A list of features.");
-
-      prm.declare_entry("random number seed", Types::Int(-1),
-                        "This allows the input of a preferred random number seed to generate random numbers."
-                        " If no input is given, this value is -1 and triggers the use of default seed = 1.");
-
-    }
-    prm.leave_subsection();
-
-  }
-
-
-  void World::parse_entries(Parameters &prm)
-  {
-    using namespace rapidjson;
-
-    /**
-     * First load the major version number in the file and check the major
-     * version number of the program.
-     */
-
-    WBAssertThrow((Version::MAJOR == "0"
-                   && prm.get<std::string>("version") == Version::MAJOR + "." + Version::MINOR)
-                  || (Version::MAJOR != "0"
-                      && prm.get<std::string>("version") == Version::MAJOR),
-                  "The major and minor version combination (for major version 0) or the major "
-                  "version (for major versions after 0) for which is input file was written "
-                  "is not the same as the version of the World Builder you are running. This means "
-                  "That there may have been incompatible changes made between the versions. \n\n"
-                  "Verify those changes and whether they affect your model. If this is not "
-                  "the case, adjust the version number in the input file. \n\nThe provided version "
-                  "number is \"" << prm.get<std::string>("version") << "\", while the used world builder "
-                  "has  (major.minor) version \"" << Version::MAJOR << "." << Version::MINOR << "\". "
-                  "If you created this file from scratch, fill set the version number to \"" <<
-                  Version::MAJOR << "." << Version::MINOR << "\" to continue. If you got the world builder "
-                  "file from somewhere, make sure that the output is what you expect it to be, because "
-                  "backwards incompatible changes may have been made to the code.");
-
-    /**
-     * Secondly load the coordinate system parameters.
-     */
-    prm.coordinate_system = prm.get_unique_pointer<CoordinateSystems::Interface>("coordinate system");
-    prm.coordinate_system->parse_entries(prm);
-
-    /**
-     * Thirdly load the gravity model parameters.
-     */
-    prm.gravity_model = prm.get_unique_pointer<GravityModel::Interface>("gravity model");
-
-    prm.enter_subsection("gravity model");
-    {
-      prm.gravity_model->parse_entries(prm);
-    }
-    prm.leave_subsection();
-
-    prm.get_unique_pointers<Features::Interface>("features",prm.features);
-
-    const bool set_cross_section = prm.check_entry("cross section");
-
-    const CoordinateSystem coordinate_system = prm.coordinate_system->natural_coordinate_system();
-
-    if (set_cross_section)
-      {
-        dim = 2;
-        const std::vector<Point<2> > cross_section_natural = prm.get_vector<Point<2> >("cross section");
-
-        WBAssertThrow(cross_section_natural.size() == 2, "The cross section should contain two points, but it contains "
-                      << cross_section.size() << " points.");
-
-        for (const auto &it : cross_section_natural)
-          cross_section.push_back(it *  (coordinate_system == spherical ? Consts::PI / 180.0 : 1.0));
-
-
-        /**
-         * pre-compute stuff for the cross section
-         */
-        surface_coord_conversions = cross_section[0]-cross_section[1];
-        surface_coord_conversions *= -1/(surface_coord_conversions.norm());
-
-
-      }
-    else
-      {
-        dim = 3;
-      }
-
-    /**
-     * Temperature parameters.
-     */
-    potential_mantle_temperature = prm.get<double>("potential mantle temperature");
-    surface_temperature = prm.get<double>("surface temperature");
-    surface_temperature = prm.get<double>("surface temperature");
-    force_surface_temperature = prm.get<bool>("force surface temperature");
-    thermal_expansion_coefficient = prm.get<double>("thermal expansion coefficient");
-    specific_heat = prm.get<double>("specific heat");
-    thermal_diffusivity = prm.get<double>("thermal diffusivity");
-
-    /**
-     * Model discretization parameters
-     */
-    maximum_distance_between_coordinates = prm.get<double>("maximum distance between coordinates");
-    interpolation = prm.get<std::string>("interpolation");
-
-    /**
-     * Local random number seed parameter
-    */
-    const int local_seed = prm.get<int>("random number seed");
-
-    if (local_seed>=0)
-      random_number_engine.seed(static_cast<unsigned int>(local_seed+MPI_RANK));
-
-    /**
-     * Now load the features. Some features use for example temperature values,
-     * so it is important that this is parsed the last.
-     */
-    prm.enter_subsection("features");
-    {
-      for (unsigned int i = 0; i < prm.features.size(); ++i)
-        {
-          prm.enter_subsection(std::to_string(i));
-          {
-            prm.features[i]->parse_entries(prm);
-          }
-          prm.leave_subsection();
-        }
-    }
-    prm.leave_subsection();
-  }
-
-
-
-  std::vector<double>
-  World::properties(const std::array<double, 2> &point,
-                    const double depth,
-                    const std::vector<std::array<unsigned int,3>> &properties) const
-  {
-    // turn it into a 3d coordinate and call the 3d temperature function
-    WBAssertThrow(dim == 2, "This function can only be called when the cross section "
-                  "variable in the world builder file has been set. Dim is "
-                  << dim << '.');
-
-    const CoordinateSystem coordinate_system = this->parameters.coordinate_system->natural_coordinate_system();
-
-    Point<2> point_natural(point[0], point[1],coordinate_system);
-    if (coordinate_system == spherical)
-      {
-        point_natural[1] = std::sqrt(point[0]*point[0]+point[1]*point[1]);
-        point_natural[0] = std::atan2(point[1],point[0]);
-      }
-
-    Point<3> coord_3d(coordinate_system);
-    if (coordinate_system == spherical)
-      {
-        coord_3d[0] = point_natural[1];
-        coord_3d[1] = cross_section[0][0] + point_natural[0] * surface_coord_conversions[0];
-        coord_3d[2] = cross_section[0][1] + point_natural[0] * surface_coord_conversions[1];
-      }
-    else
-      {
-        coord_3d[0] = cross_section[0][0] + point_natural[0] * surface_coord_conversions[0];
-        coord_3d[1] = cross_section[0][1] + point_natural[0] * surface_coord_conversions[1];
-        coord_3d[2] = point_natural[1];
-      }
-
-
-    const std::array<double, 3> point_3d_cartesian = this->parameters.coordinate_system->natural_to_cartesian_coordinates(coord_3d.get_array());
-
-    return this->properties(point_3d_cartesian, depth, properties);
-  }
-
-
-  std::vector<double>
-  World::properties(const std::array<double, 3> &point_,
-                    const double depth,
-                    const std::vector<std::array<unsigned int,3>> &properties) const
-  {
-    // We receive the cartesian points from the user.
-    const Point<3> point(point_,cartesian);
-    (void) this->limit_debug_consistency_checks;
-    WBAssert(this->limit_debug_consistency_checks || this->parameters.coordinate_system->natural_coordinate_system() == cartesian
-             || approx(depth, this->parameters.coordinate_system->max_model_depth()-sqrt(point_[0]*point_[0]+point_[1]*point_[1]+point_[2]*point_[2])),
-             "Inconsistent input. Please check whether the radius in the spherical coordinates is consistent with the radius of the planet as defined "
-             << "in the program that uses the Geodynamic World Builder. This is a debug check in GWB and can be disabled by setting "
-             << "limit_debug_consistency_checks to true. "
-             << "Depth = " << depth << ", radius = " << this->parameters.coordinate_system->max_model_depth()
-             << ", point = " << point_[0] << " " << point_[1] << " " << point_[2]
-             << ", radius-point.norm() = " << this->parameters.coordinate_system->max_model_depth()-sqrt(point_[0]*point_[0]+point_[1]*point_[1]+point_[2]*point_[2]));
-
-    const Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(point,*(this->parameters.coordinate_system));
-
-    // create output vector
-    std::vector<double> output;
-    std::vector<size_t> entry_in_output;
-    std::vector<std::array<unsigned int,3>> properties_local;
-    const double gravity_norm = this->parameters.gravity_model->gravity_norm(point);
-    for (unsigned int i_property = 0; i_property < properties.size(); ++i_property)
-      {
-        switch (properties[i_property][0])
-          {
-            case 1: // Temperature
-              if (std::fabs(depth) < 2.0 * std::numeric_limits<double>::epsilon() && force_surface_temperature)
-                {
-                  entry_in_output.emplace_back(output.size());
-                  output.emplace_back(this->surface_temperature);
-                  if (properties.size() == 1)
-                    return output;
-                }
-              else
-                {
-                  entry_in_output.emplace_back(output.size());
-                  output.emplace_back(potential_mantle_temperature * std::exp(((thermal_expansion_coefficient * gravity_norm) / specific_heat) * depth));
-                }
-              properties_local.emplace_back(properties[i_property]);
-              break;
-            case 2: // composition
-              entry_in_output.emplace_back(output.size());
-              output.emplace_back(0.);
-              properties_local.emplace_back(properties[i_property]);
-              break;
-            case 3: // grains (10 entries per grain)
-            {
-              entry_in_output.emplace_back(output.size());
-              const std::vector<double> tmp_vector(properties[i_property][2]*10,0.);
-              output.insert(output.end(), tmp_vector.begin(), tmp_vector.end());
-              properties_local.emplace_back(properties[i_property]);
-              break;
-            }
-            case 4: // tag
-            {
-              entry_in_output.emplace_back(output.size());
-              output.emplace_back(-1);
-              properties_local.emplace_back(properties[i_property]);
-              break;
-            }
-            default:
-              WBAssertThrow(false,
-                            "Internal error: Unimplemented property provided. " <<
-                            "Only temperature (1), composition (2), grains (3) or tag (4) are allowed. "
-                            "Provided property number was: " << properties[i_property][0]);
-          }
-      }
-    for (auto &&it : parameters.features)
-      {
-        it->properties(point, natural_coordinate, depth, properties_local, gravity_norm, entry_in_output, output);
-      }
-
-    return output;
-  }
-
-  double
-  World::temperature(const std::array<double,2> &point,
-                     const double depth) const
-  {
-    return properties(point, depth, {{{1,0,0}}})[0];
-  }
-
-  double
-  World::temperature(const std::array<double,2> &point,
-                     const double depth,
-                     const double /*gravity_norm*/) const
-  {
-    return properties(point, depth, {{{1,0,0}}})[0];
-  }
-
-  double
-  World::temperature(const std::array<double,3> &point,
-                     const double depth) const
-  {
-    return properties(point, depth, {{{1,0,0}}})[0];
-  }
-
-  double
-  World::temperature(const std::array<double,3> &point,
-                     const double depth,
-                     const double /*gravity_norm*/) const
-  {
-    return properties(point, depth, {{{1,0,0}}})[0];
-  }
-
-  double
-  World::composition(const std::array<double,2> &point,
-                     const double depth,
-                     const unsigned int composition_number) const
-  {
-    return properties(point, depth, {{{2,composition_number,0}}})[0];
-  }
-
-  double
-  World::composition(const std::array<double,3> &point,
-                     const double depth,
-                     const unsigned int composition_number) const
-  {
-    return properties(point, depth, {{{2,composition_number,0}}})[0];
-  }
-
-
-
-  WorldBuilder::grains
-  World::grains(const std::array<double,2> &point,
-                const double depth,
-                const unsigned int composition_number,
-                size_t number_of_grains) const
-  {
-    return WorldBuilder::grains(properties(point, depth, {{{3,composition_number,static_cast<unsigned int>(number_of_grains)}}}),static_cast<unsigned int>(number_of_grains),0);
-  }
-
-  WorldBuilder::grains
-  World::grains(const std::array<double,3> &point,
-                const double depth,
-                const unsigned int composition_number,
-                size_t number_of_grains) const
-  {
-    return WorldBuilder::grains(properties(point, depth, {{{3,composition_number,static_cast<unsigned int>(number_of_grains)}}}),static_cast<unsigned int>(number_of_grains),0);
-  }
-
-  std::mt19937 &
-  World::get_random_number_engine()
-  {
-    return random_number_engine;
-  }
-
-  Objects::PlaneDistances
-  World::distance_to_plane(const std::array<double, 3> &point_,
-                           const double depth,
-                           const std::string &name) const
-  {
-    // We receive the cartesian points from the user.
-    const Point<3> point(point_,cartesian);
-
-    WBAssert(this->limit_debug_consistency_checks || this->parameters.coordinate_system->natural_coordinate_system() == cartesian
-             || approx(depth, this->parameters.coordinate_system->max_model_depth()-sqrt(point_[0]*point_[0]+point_[1]*point_[1]+point_[2]*point_[2])),
-             "Inconsistent input. Please check whether the radius in the spherical coordinates is consistent with the radius of the planet as defined "
-             << "in the program that uses the Geodynamic World Builder. This is a debug check in GWB and can be disabled by setting "
-             << "limit_debug_consistency_checks to true. "
-             << "Depth = " << depth << ", radius = " << this->parameters.coordinate_system->max_model_depth()
-             << ", point = " << point_[0] << " " << point_[1] << " " << point_[2]
-             << ", radius-point.norm() = " << this->parameters.coordinate_system->max_model_depth()-sqrt(point_[0]*point_[0]+point_[1]*point_[1]+point_[2]*point_[2]));
-
-    const Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(point,*(this->parameters.coordinate_system));
-
-    Objects::PlaneDistances plane_distances(0.0, 0.0);
-    for (auto &&it : this->parameters.features)
-      {
-        if (it->get_name() == name)
-          {
-            plane_distances = it->distance_to_feature_plane(point, natural_coordinate, depth);
-            break;
-          }
-      }
-    return plane_distances;
-  }
-
-} // namespace WorldBuilder
-
diff --git a/contrib/world_builder/source/world_builder/wrapper_c.cc.bak b/contrib/world_builder/source/world_builder/wrapper_c.cc.bak
deleted file mode 100644
index e0b95e6e47a..00000000000
--- a/contrib/world_builder/source/world_builder/wrapper_c.cc.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/wrapper_c.h"
-
-#include "world_builder/world.h"
-
-extern "C" {
-  /**
-   * This function creates an object of the world builder and returns a pointer
-   * to it. This pointer can then be used to call the temperature and composition
-   * functions. When done call the release world function to destroy the object.
-   */
-  void create_world(void **ptr_ptr_world, const char *world_builder_file, const bool *has_output_dir_, const char *output_dir_, const unsigned long random_number_seed)
-  {
-    bool has_output_dir = false;
-
-    if (has_output_dir_ != nullptr)
-      {
-        has_output_dir = *has_output_dir_;
-      }
-
-    std::string output_dir;
-    if (output_dir_ != nullptr)
-      {
-        output_dir = *output_dir_;
-      }
-
-    WorldBuilder::World *a = new WorldBuilder::World(std::string(world_builder_file), has_output_dir, output_dir,random_number_seed);
-
-    *ptr_ptr_world = reinterpret_cast<void *>(a);
-  }
-
-
-  /**
-   * This function return the temperature at a specific location given x, z, depth and
-   * gravity.
-   */
-  void temperature_2d(void *ptr_ptr_world, double x, double z, double depth, double *temperature)
-  {
-    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
-    const std::array<double,2> position = {{x,z}};
-    *temperature = a->temperature(position,depth);
-  }
-
-
-  /**
-   * This function return the temperature at a specific location given x, y, z, depth and
-   * gravity.
-   */
-  void temperature_3d(void *ptr_ptr_world, double x, double y, double z, double depth, double *temperature)
-  {
-    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
-    const std::array<double,3> position = {{x,y,z}};
-    *temperature = a->temperature(position,depth);
-  }
-
-
-  /**
-   * This function return the composition at a specific location given x, z, depth and
-   * composition number.
-   */
-  void composition_2d(void *ptr_ptr_world, double x, double z, double depth, unsigned int composition_number, double *composition)
-  {
-    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
-    const std::array<double,2> position = {{x,z}};
-    *composition = a->composition(position,depth,composition_number);
-  }
-
-
-  /**
-   * This function return the composition at a specific location given x, y, z, depth and
-   * composition number.
-   */
-  void composition_3d(void *ptr_ptr_world, double x, double y, double z, double depth, unsigned int composition_number, double *composition)
-  {
-    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
-    const std::array<double,3> position = {{x,y,z}};
-    *composition = a->composition(position,depth,composition_number);
-  }
-
-
-  /**
-   * The destructor for the world builder class. Call this function when done with the
-   * world builder.
-   */
-  void release_world(void *ptr_ptr_world)
-  {
-    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
-    delete a;
-  }
-}
diff --git a/contrib/world_builder/source/world_builder/wrapper_cpp.cc.bak b/contrib/world_builder/source/world_builder/wrapper_cpp.cc.bak
deleted file mode 100644
index d4764ab2413..00000000000
--- a/contrib/world_builder/source/world_builder/wrapper_cpp.cc.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-  Copyright (C) 2018-2024 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-#include "world_builder/wrapper_cpp.h"
-
-#include "world_builder/world.h"
-
-using namespace WorldBuilder;
-namespace wrapper_cpp
-{
-  WorldBuilderWrapper::WorldBuilderWrapper(std::string filename, bool has_output_dir, const std::string &output_dir, const unsigned long random_number_seed)
-    : ptr_ptr_world(nullptr)
-  {
-    WorldBuilder::World *a = new WorldBuilder::World(std::move(filename), has_output_dir, output_dir, random_number_seed);
-    ptr_ptr_world = reinterpret_cast<void *>(a);
-  }
-
-
-  WorldBuilderWrapper::~WorldBuilderWrapper()
-  {
-    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
-    delete a;
-  }
-
-
-  double
-  WorldBuilderWrapper::temperature_2d(double x, double z, double depth)
-  {
-    const std::array<double,2> position = {{x,z}};
-    return reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world)->temperature(position,depth);
-  }
-
-  double
-  WorldBuilderWrapper::temperature_2d(double x, double z, double depth, double /*gravity*/)
-  {
-    return temperature_2d(x,z,depth);
-  }
-
-  double WorldBuilderWrapper::temperature_3d(double x, double y, double z, double depth)
-  {
-    const std::array<double,3> position = {{x,y,z}};
-    return reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world)->temperature(position,depth);
-  }
-
-  double WorldBuilderWrapper::temperature_3d(double x, double y, double z, double depth, double /*gravity*/)
-  {
-    return temperature_3d(x,y,z,depth);
-  }
-
-  double WorldBuilderWrapper::composition_2d(double x, double z, double depth, unsigned int composition_number)
-  {
-    const std::array<double,2> position = {{x,z}};
-    return reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world)->composition(position,depth,composition_number);
-  }
-
-  double WorldBuilderWrapper::composition_3d(double x, double y, double z, double depth, unsigned int composition_number)
-  {
-    const std::array<double,3> position = {{x,y,z}};
-    return reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world)->composition(position,depth,composition_number);
-  }
-} // namespace wrapper_cpp
diff --git a/contrib/world_builder/tests/unit_tests/bounding_box.cc.bak b/contrib/world_builder/tests/unit_tests/bounding_box.cc.bak
deleted file mode 100644
index a438f3ceb42..00000000000
--- a/contrib/world_builder/tests/unit_tests/bounding_box.cc.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-  Copyright (C) 2021 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
-
-#include "doctest/doctest.h"
-
-#include "world_builder/bounding_box.h"
-
-using namespace WorldBuilder;
-using doctest::Approx;
-
-
-TEST_CASE("bounding box 2D")
-{
-  // Check default constructor
-  const BoundingBox<2> bb1;
-  CHECK(bb1.center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
-  CHECK(BoundingBox<2>().center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
-
-  CHECK(bb1.point_inside(Point<2>(2,2.5,CoordinateSystem::cartesian)) == true);
-  const Point<2> p1 ({{1,1}}, CoordinateSystem::cartesian);
-  const Point<2> p2 ({{2,3}}, CoordinateSystem::cartesian);
-
-
-  CHECK(BoundingBox<2>().center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
-  const BoundingBox<2> bb2({p1, p2});
-  CHECK(bb2.center().distance(Point<2>(1.5,2.,CoordinateSystem::cartesian)) < 1e-12);
-
-  // Check that the function point_inside works as expected
-  CHECK(bb2.point_inside(Point<2>(1.5,2,CoordinateSystem::cartesian)) == true);
-  CHECK(bb2.point_inside(Point<2>(-1.5,2,CoordinateSystem::cartesian)) == false);
-  CHECK(bb2.point_inside(Point<2>(1.5,-2,CoordinateSystem::cartesian)) == false);
-  CHECK(bb2.point_inside(Point<2>(-1.5,-2,CoordinateSystem::cartesian)) == false);
-}
-
-
-TEST_CASE("bounding box 3D")
-{
-  // Check default constructor
-  const BoundingBox<3> bb1;
-  CHECK(bb1.center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
-  CHECK(BoundingBox<3>().center().distance(Point<2>(0,0,CoordinateSystem::cartesian)) < 1e-12);
-
-  CHECK(bb1.point_inside(Point<3>(2,2.5,2.5,CoordinateSystem::cartesian)) == true);
-
-  // Check constructor with provided points
-  const Point<3> p1 (
-  {
-    {
-      1,1,1
-    }
-  }, CoordinateSystem::cartesian);
-  const Point<3> p2 (
-  {
-    {
-      2,3,4
-    }
-  }, CoordinateSystem::cartesian);
-  const BoundingBox<3> bb2({p1, p2});
-
-  // Check the center function
-  CHECK(bb2.center().distance(Point<2>(1.5,2,CoordinateSystem::cartesian)) < 1e-12);
-
-  // Check that the function point_inside works as expected
-  CHECK(bb2.point_inside(Point<3>(1.5,2,2.5,CoordinateSystem::cartesian)) == true);
-  CHECK(bb2.point_inside(Point<3>(-1.5,2,2.5,CoordinateSystem::cartesian)) == false);
-  CHECK(bb2.point_inside(Point<3>(1.5,-2,2.5,CoordinateSystem::cartesian)) == false);
-  CHECK(bb2.point_inside(Point<3>(1.5,2,-2.5,CoordinateSystem::cartesian)) == false);
-
-}
diff --git a/contrib/world_builder/tests/unit_tests/gwb_gravity.cc.bak b/contrib/world_builder/tests/unit_tests/gwb_gravity.cc.bak
deleted file mode 100644
index c6a586a6267..00000000000
--- a/contrib/world_builder/tests/unit_tests/gwb_gravity.cc.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Copyright (C) 2021 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
-
-#include "doctest/doctest.h"
-
-#include "world_builder/config.h"
-#include "world_builder/coordinate_systems/invalid.h"
-#include "world_builder/gravity_model/uniform.h"
-#include "world_builder/parameters.h"
-#include "world_builder/point.h"
-#include "world_builder/world.h"
-
-using namespace WorldBuilder;
-using doctest::Approx;
-using doctest::Contains;
-
-TEST_CASE("Gravity uniform")
-{
-
-  const std::string file_name = Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian.wb";
-  World world(file_name);
-
-  CHECK(world.parameters.gravity_model->gravity_norm(Point<3>(10,10,10,CoordinateSystem::cartesian)) == Approx(10.));
-
-  auto vector_cartesian = world.parameters.gravity_model->gravity_vector(Point<3>(10,10,10,CoordinateSystem::cartesian));
-
-  CHECK(vector_cartesian[0] == Approx(0));
-  CHECK(vector_cartesian[1] == Approx(0));
-  CHECK(vector_cartesian[2] == Approx(-10.));
-
-
-  const std::string file_name_spherical = Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_spherical.wb";
-  World world_spherical(file_name_spherical);
-
-  auto vector_spherical = world_spherical.parameters.gravity_model->gravity_vector(Point<3>(1,2,4,CoordinateSystem::spherical));
-
-  CHECK(vector_spherical[0] == Approx(-2.1821789024));
-  CHECK(vector_spherical[1] == Approx(-4.3643578047));
-  CHECK(vector_spherical[2] == Approx(-8.7287156094));
-  CHECK(std::sqrt(vector_spherical[0]*vector_spherical[0]+
-                  vector_spherical[1]*vector_spherical[1]+
-                  vector_spherical[2]*vector_spherical[2]) == Approx(10.));
-
-  world_spherical.parameters.coordinate_system =
-    std::unique_ptr<CoordinateSystems::Interface>(new CoordinateSystems::Invalid(nullptr));
-
-  CHECK_THROWS_WITH(world_spherical.parameters.gravity_model->gravity_vector(Point<3>(1,2,4,CoordinateSystem::invalid)),
-                    Contains("Invalid coordinate system when using the gravity vector function."));
-
-}
\ No newline at end of file
diff --git a/contrib/world_builder/tests/unit_tests/kd_tree.cc.bak b/contrib/world_builder/tests/unit_tests/kd_tree.cc.bak
deleted file mode 100644
index 154144bebb0..00000000000
--- a/contrib/world_builder/tests/unit_tests/kd_tree.cc.bak
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
-
-#include "doctest/doctest.h"
-#include "world_builder/coordinate_system.h"
-#include "world_builder/kd_tree.h"
-
-#include <iostream>
-
-using namespace WorldBuilder::KDTree;
-using doctest::Approx;
-
-/**
- * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
- */
-inline void compare_node_trees(
-  const std::vector<Node> &computed,
-  const std::vector<Node> &expected)
-{
-  for (size_t i = 0; i < computed.size(); ++i)
-    {
-      CHECK(computed[i].index == expected[i].index);
-      CHECK(computed[i].x == Approx(expected[i].x));
-      CHECK(computed[i].y == Approx(expected[i].y));
-    }
-}
-
-TEST_CASE("create kd-tree: 15 nodes")
-{
-  const std::vector<Node> reference = {Node(8,2,3),Node(4,4,4),Node(9,5,2),
-                                       Node(2,1,5),Node(10,2,9),Node(5,5,8),
-                                       Node(11,6,7),Node(1,7,3),Node(12,9,2.5),
-                                       Node(6,10,2),Node(13,11.5,1),Node(3,11,4),
-                                       Node(14,8,6),Node(7,9,7),Node(15,11,8)
-                                      };
-  {
-    const std::vector<Node> nodes = {Node(1,7,3),Node(2,1,5),Node(3,11,4),
-                                     Node(4,4,4),Node(5,5,8),Node(6,10,2),
-                                     Node(7,9,7),Node(8,2,3),Node(9,5,2),
-                                     Node(10,2,9),Node(11,6,7),Node(12,9,2.5),
-                                     Node(13,11.5,1),Node(14,8,6),Node(15,11,8)
-                                    };
-
-    KDTree tree = KDTree(nodes);
-
-    tree.create_tree(0, nodes.size()-1, false);
-
-    compare_node_trees(tree.get_nodes(), reference);
-  }
-
-  {
-    // shuffle nodes
-    const std::vector<Node> nodes = {Node(2,1,5),Node(3,11,4),Node(9,5,2),
-                                     Node(4,4,4),Node(1,7,3),Node(5,5,8),
-                                     Node(7,9,7),Node(8,2,3),Node(11,6,7),
-                                     Node(10,2,9),Node(12,9,2.5),Node(14,8,6),
-                                     Node(13,11.5,1),Node(6,10,2),Node(15,11,8)
-                                    };
-
-    KDTree tree = KDTree(nodes);
-
-    tree.create_tree(0, nodes.size()-1, false);
-
-    compare_node_trees(tree.get_nodes(), reference);
-  }
-}
-
-
-TEST_CASE("create kd-tree: 6 nodes")
-{
-  const std::vector<Node> reference = {Node(4,4,2),Node(5,2,6),Node(2,7,6),
-                                       Node(1,9,2),Node(6,12,3),Node(3,11,6)
-                                      };
-  {
-    const std::vector<Node> nodes = {Node(1,9,2),Node(2,7,6),Node(3,11,6),
-                                     Node(4,4,2),Node(5,2,6),Node(6,12,3)
-                                    };
-
-    KDTree tree = KDTree(nodes);
-
-    tree.create_tree(0, nodes.size()-1, false);
-
-    compare_node_trees(tree.get_nodes(), reference);
-  }
-
-  {
-    // shuffle nodes
-    const std::vector<Node> nodes = {Node(5,2,6),Node(2,7,6),Node(1,9,2),
-                                     Node(6,12,3),Node(4,4,2),Node(3,11,6)
-                                    };
-
-    KDTree tree = KDTree(nodes);
-
-    tree.create_tree(0, nodes.size()-1, false);
-
-    compare_node_trees(tree.get_nodes(), reference);
-  }
-}
-
-
-TEST_CASE("create kd-tree: 10 nodes")
-{
-  const std::vector<Node> reference = {Node(3,2,1),Node(1,4,2),Node(4,1,4),
-                                       Node(7,3,6),Node(0,7,3),Node(5,9,2),
-                                       Node(8,11,1),Node(2,12,3),Node(9,10,5),
-                                       Node(6,11,6)
-                                      };
-  {
-    const std::vector<Node> nodes = {Node(0,7,3),Node(1,4,2),Node(2,12,3),
-                                     Node(3,2,1),Node(4,1,4),Node(5,9,2),
-                                     Node(7,3,6),Node(6,11,6),Node(9,10,5),
-                                     Node(8,11,1)
-                                    };
-
-    KDTree tree = KDTree(nodes);
-
-    tree.create_tree(0, nodes.size()-1, false);
-
-    compare_node_trees(tree.get_nodes(), reference);
-
-    // check some values
-    using namespace WorldBuilder;
-    std::vector<Point<2>> check_points = {Point<2>(7,2,CoordinateSystem::cartesian),
-                                          Point<2>(8,2,CoordinateSystem::cartesian),
-                                          Point<2>(9,2,CoordinateSystem::cartesian),
-                                          Point<2>(8,2.5001,CoordinateSystem::cartesian),
-                                          Point<2>(8,2.4999,CoordinateSystem::cartesian),
-                                          Point<2>(7,3,CoordinateSystem::cartesian),
-                                          Point<2>(11,1.5,CoordinateSystem::cartesian),
-                                          Point<2>(10,2,CoordinateSystem::cartesian),
-                                          Point<2>(12,2,CoordinateSystem::cartesian),
-                                          Point<2>(11,0.5,CoordinateSystem::cartesian),
-                                          Point<2>(9.25,1.75,CoordinateSystem::cartesian),
-                                          Point<2>(11,3.5,CoordinateSystem::cartesian),
-                                          Point<2>(10.5,4,CoordinateSystem::cartesian),
-                                          Point<2>(9.5,4,CoordinateSystem::cartesian),
-                                          Point<2>(9.5,5.5,CoordinateSystem::cartesian),
-                                          Point<2>(10.75,5.5,CoordinateSystem::cartesian),
-                                          Point<2>(11.75,5.5,CoordinateSystem::cartesian),
-                                          Point<2>(5,1,CoordinateSystem::cartesian),
-                                          Point<2>(3,1,CoordinateSystem::cartesian),
-                                          Point<2>(1,1,CoordinateSystem::cartesian),
-                                          Point<2>(2,3,CoordinateSystem::cartesian),
-                                          Point<2>(0.5,3,CoordinateSystem::cartesian),
-                                          Point<2>(0.5,5,CoordinateSystem::cartesian),
-                                          Point<2>(2,4.5,CoordinateSystem::cartesian),
-                                          Point<2>(3,5,CoordinateSystem::cartesian),
-                                          Point<2>(3,7,CoordinateSystem::cartesian)
-                                         };
-
-    std::vector<size_t> index_results = {4,5,5,4,5,4,6,5,7,6,5,7,8,8,8,9,9,1,0,0,2,2,2,2,3,3};
-
-    for (size_t i = 0; i < check_points.size(); ++i)
-      {
-        IndexDistance const index_distance = tree.find_closest_point(check_points[i]);
-
-        CHECK(index_distance.index == index_results[i]);
-      }
-
-    std::vector<std::vector<size_t> > index_distances_results =
-    {
-      {5,7,8,4,3,2,1,0},{5,7,4,3,2,1,0},{6,5,7,4,3,2,1},{5,6,7,8,4,3,2,1,0},
-      {5,6,7,8,4,3,2,1,0},{8,9,7,5,6,4,},{6,5,7,4,0,1},{6,5,7,4,3,2,1,0},
-      {6,5,7,4,3,2,1,0},{6,5,7,4,0,1},{6,5,7,4,0,1,3,2},{9,8,7,6,5,4,3,2,1,0},
-      {9,8,7,6,5,4,3,2,1,0},{8,9,7,6,5,4,3,2,1,0},{8,9,7,6,5,4,3,2,1,0},
-      {9,8,7,6,5,4,3,2,1,0},{9,8,7,6,5,4,3,2,1,0},{0,1,3,2,4},{0,1,4},{0,1,4},
-      {3,2,1,0,4},{2,3,1,0,4},{2,3,1,0,4},{3,2,1,0,4},{3,2,1,0,4},{3,2,1,0,4}
-    };
-
-    for (size_t i = 0; i < check_points.size(); ++i)
-      {
-        IndexDistances index_distances = tree.find_closest_points(check_points[i]);
-        CHECK(index_distances.min_index == index_results[i]);
-
-        for (size_t j = 0; j < index_distances.vector.size(); ++j)
-          {
-            CHECK(index_distances.vector[j].index == index_distances_results[i][j]);
-          }
-      }
-  }
-
-  {
-    // shuffle nodes
-    const std::vector<Node> nodes = {Node(3,2,1),Node(4,1,4),Node(5,9,2),
-                                     Node(0,7,3),Node(6,11,6),Node(2,12,3),
-                                     Node(7,3,6),Node(9,10,5),Node(1,4,2),
-                                     Node(8,11,1)
-                                    };
-
-    KDTree tree = KDTree(nodes);
-
-    tree.create_tree(0, nodes.size()-1, false);
-
-    compare_node_trees(tree.get_nodes(), reference);
-  }
-}
\ No newline at end of file
diff --git a/contrib/world_builder/tests/unit_tests/main.cc.bak b/contrib/world_builder/tests/unit_tests/main.cc.bak
deleted file mode 100644
index 64fe8ac9bad..00000000000
--- a/contrib/world_builder/tests/unit_tests/main.cc.bak
+++ /dev/null
@@ -1,25 +0,0 @@
-
-/*
-  Copyright (C) 2018 - 2021 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#define APPROVALS_DOCTEST // This tells Approval Tests to provide a main() - only do this in one cpp file
-#include "ApprovalTests/ApprovalTests.hpp"
-
-auto directoryDisposer = ApprovalTests::Approvals::useApprovalsSubdirectory("approval_tests");
-auto default_namer_disposer = ApprovalTests::SeparateApprovedAndReceivedDirectoriesNamer::useAsDefaultNamer();
\ No newline at end of file
diff --git a/contrib/world_builder/tests/unit_tests/unit_test_wb_glm.cc.bak b/contrib/world_builder/tests/unit_tests/unit_test_wb_glm.cc.bak
deleted file mode 100644
index f37dddd01a8..00000000000
--- a/contrib/world_builder/tests/unit_tests/unit_test_wb_glm.cc.bak
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
-  Copyright (C) 2020 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
-
-#include "doctest/doctest.h"
-
-#include "glm/glm.h"
-
-#include "world_builder/coordinate_system.h"
-#include "world_builder/utilities.h"
-
-#include <array>
-
-using namespace WorldBuilder;
-using doctest::Approx;
-
-
-/**
- * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
- */
-inline void compare_3d_arrays_approx(
-  const std::array<double,3> &computed,
-  const std::array<double,3> &expected)
-{
-  CHECK(computed.size() == expected.size());
-  for (unsigned int i=0; i< computed.size(); ++i)
-    {
-      INFO("vector index i=" << i << ": ");
-      CHECK(computed[i] == Approx(expected[i]));
-    }
-}
-
-/**
- * Compare two rotation matrices
- */
-inline void compare_rotation_matrices_approx(
-  const std::array<std::array<double,3>,3> &computed,
-  const std::array<std::array<double,3>,3> &expected)
-{
-  // sign of eigenvector is not important
-  INFO("rotation matrices are not the same: \n" <<
-       "expected = " << expected[0][0] << ' ' << expected[0][1] << ' ' << expected[0][2] << "\n" <<
-       "           " << expected[1][0] << ' ' << expected[1][1] << ' ' << expected[1][2] << "\n" <<
-       "           " << expected[2][0] << ' ' << expected[2][1] << ' ' << expected[2][2] << "\n" <<
-       "computed = " << computed[0][0] << ' ' << computed[0][1] << ' ' << computed[0][2] << "\n" <<
-       "           " << computed[1][0] << ' ' << computed[1][1] << ' ' << computed[1][2] << "\n" <<
-       "           " << computed[2][0] << ' ' << computed[2][1] << ' ' << computed[2][2] << "\n" );
-  CHECK((
-          (computed[0][0] == Approx(expected[0][0]) && computed[0][1] == Approx(expected[0][1]) && computed[0][2] == Approx(expected[0][2]) &&
-           computed[1][0] == Approx(expected[1][0]) && computed[1][1] == Approx(expected[1][1]) && computed[1][2] == Approx(expected[1][2]) &&
-           computed[2][0] == Approx(expected[2][0]) && computed[2][1] == Approx(expected[2][1]) && computed[2][2] == Approx(expected[2][2]))
-          ||
-          (computed[0][0] == Approx(-expected[0][0]) && computed[0][1] == Approx(-expected[0][1]) && computed[0][2] == Approx(-expected[0][2]) &&
-           computed[1][0] == Approx(-expected[1][0]) && computed[1][1] == Approx(-expected[1][1]) && computed[1][2] == Approx(-expected[1][2]) &&
-           computed[2][0] == Approx(-expected[2][0]) && computed[2][1] == Approx(-expected[2][1]) && computed[2][2] == Approx(-expected[2][2]))));
-}
-
-inline
-void
-compare_quaternions(
-  const glm::quaternion::quat &computed,
-  const glm::quaternion::quat &expected
-)
-{
-  CHECK(computed.w == Approx(expected.w));
-  CHECK(computed.x == Approx(expected.x));
-  CHECK(computed.y == Approx(expected.y));
-  CHECK(computed.z == Approx(expected.z));
-}
-
-TEST_CASE("glm quat basic functions")
-{
-  typedef glm::quaternion::quat QT;
-  QT q1(2,3,4,5);
-  QT const q2(6,7,8,9);
-  QT const q3(9,8,7,6);
-
-
-  QT q_res = -q1;
-  compare_quaternions(q_res, QT(-2,-3,-4,-5));
-
-  q_res = q1 + q2;
-  compare_quaternions(q_res, QT(8,10,12,14));
-
-  q_res = q2 - q1;
-  compare_quaternions(q_res, QT(-4,-4,-4,-4));
-  q_res = q3 - q1;
-  compare_quaternions(q_res, QT(-7,-5,-3,-1));
-
-
-  q_res = q1 * 2.0;
-  compare_quaternions(q_res, QT(4,6,8,10));
-  q_res = 2.0 * q1;
-  compare_quaternions(q_res, QT(4,6,8,10));
-
-
-  q_res = (2.0 * q1) / 2.0;
-  compare_quaternions(q_res, q1);
-
-  CHECK(glm::quaternion::dot(q1,q2) ==  Approx(110.0));
-  CHECK(glm::quaternion::dot(q2,q3) ==  Approx(220.0));
-  CHECK(glm::quaternion::dot(q2,-q3) ==  Approx(-220.0));
-  CHECK(glm::quaternion::dot(-q2,-q3) ==  Approx(220.0));
-
-  double res = glm::quaternion::mix(0.0,1.0,0.0);
-  CHECK(res == Approx(0.0));
-
-  res = glm::quaternion::mix(0.0,1.0,0.25);
-  CHECK(res == Approx(Approx(0.25)));
-
-  res = glm::quaternion::mix(0.0,1.0,0.5);
-  CHECK(res == Approx(0.5));
-
-  res = glm::quaternion::mix(0.0,1.0,0.75);
-  CHECK(res == Approx(0.75));
-
-  res = glm::quaternion::mix(0.0,1.0,1.0);
-  CHECK(res == Approx(1.0));
-
-
-  res = glm::quaternion::mix(1.0,0.0,0.0);
-  CHECK(res == Approx(1.0));
-
-  res = glm::quaternion::mix(1.0,0.0,0.25);
-  CHECK(res == Approx(0.75));
-
-  res = glm::quaternion::mix(1.0,0.0,0.5);
-  CHECK(res == Approx(0.5));
-
-  res = glm::quaternion::mix(1.0,0.0,0.75);
-  CHECK(res == Approx(0.25));
-
-  res = glm::quaternion::mix(1.0,0.0,1.0);
-  CHECK(res == Approx(0.0));
-
-
-  res = glm::quaternion::mix(-3.0,1.0,0.0);
-  CHECK(res == Approx(-3.0));
-
-  res = glm::quaternion::mix(-3.0,1.0,0.25);
-  CHECK(res == Approx(-2.0));
-
-  res = glm::quaternion::mix(-3.0,1.0,0.5);
-  CHECK(res == Approx(-1.0));
-
-  res = glm::quaternion::mix(-3.0,1.0,0.75);
-  CHECK(res == Approx(0.0));
-
-  res = glm::quaternion::mix(-3.0,1.0,1.0);
-  CHECK(res == Approx(1.0));
-
-}
-
-TEST_CASE("glm quat slerp functions")
-{
-  {
-    // This shows that two equal rotation matrices average in the same rotation matrix
-    const std::array<std::array<double,3>,3> rot1 = {{{{0.36,0.48,-0.8}},{{-0.8,0.6,0}}, {{0.48,0.64, 0.6}}}}; //{{normalize({{1,2,3}}),normalize({{4,5,6}}),normalize({{7,8,9}})}};
-    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
-    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot1);
-
-    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
-
-    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
-
-    auto ea1 = Utilities::euler_angles_from_rotation_matrix(rot1);
-    auto ear = Utilities::euler_angles_from_rotation_matrix(result1);
-
-    compare_rotation_matrices_approx(result1, rot1);
-    compare_3d_arrays_approx(ea1,ear);
-  }
-
-  {
-    // This shows that a very small difference in the rotation matrix causes a very small difference in the resulting rotation matrix.
-    const std::array<std::array<double,3>,3> rot1 = {{{{0.360000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
-    const std::array<std::array<double,3>,3> rot2 = {{{{0.350000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
-    const std::array<std::array<double,3>,3> expt = {{{{0.358571,0.479818,-0.800533}},{{-0.800533,0.599107,0.000627009}}, {{0.479818,0.640802, 0.599107}}}};
-
-    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
-    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot2);
-
-    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
-
-    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
-
-    compare_rotation_matrices_approx(result1, expt);
-  }
-
-  {
-    // This shows that a small difference in the rotation matrix causes a small difference in the resulting rotation matrix.
-    const std::array<std::array<double,3>,3> rot1 = {{{{0.360000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
-    const std::array<std::array<double,3>,3> rot2 = {{{{0.300000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
-    const std::array<std::array<double,3>,3> expt = {{{{0.351289,0.478886,-0.803242}},{{-0.803242,0.594555,0.00382358}}, {{0.478886,0.644888, 0.594555}}}};
-
-    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
-    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot2);
-
-    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
-
-    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
-
-    compare_rotation_matrices_approx(result1, expt);
-  }
-
-  {
-    // This shows that a small difference in the rotation matrix causes a small difference in the resulting rotation matrix.
-    const std::array<std::array<double,3>,3> rot1 = {{{{0.360000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
-    const std::array<std::array<double,3>,3> rot2 = {{{{0.300000,0.450000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
-    const std::array<std::array<double,3>,3> expt = {{{{0.35767,0.472227,-0.802856}},{{-0.7972,0.6014,0.000000000}}, {{0.481714,0.642285, 0.593783}}}};
-
-    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
-    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot2);
-
-    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
-
-    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
-
-    compare_rotation_matrices_approx(result1, expt);
-  }
-
-  {
-    // This shows that a significant difference in the rotation matrix causes a significant difference in the resulting rotation matrix.
-    const std::array<std::array<double,3>,3> rot1 = {{{{0.360000,0.480000,-0.800000}},{{-0.800000,0.600000,0.000000000}}, {{0.480000,0.640000, 0.600000}}}};
-    const std::array<std::array<double,3>,3> rot2 = {{{{0.200000,0.250000,-0.400000}},{{-0.500000,0.200000,0.300000000}}, {{0.380000,0.840000, 0.500000}}}};
-    const std::array<std::array<double,3>,3> expt = {{{{0.493495,0.403007,-0.707894}},{{-0.70133,0.664351,-0.0720395}}, {{0.414325,0.578479, 0.656215}}}};
-
-    const glm::quaternion::quat quat_current = glm::quaternion::quat_cast(rot1);
-    const glm::quaternion::quat quat_next = glm::quaternion::quat_cast(rot2);
-
-    const glm::quaternion::quat quat_average = glm::quaternion::slerp(quat_current,quat_next,0.5);
-
-    const std::array<std::array<double,3>,3> result1 = glm::quaternion::mat3_cast(quat_average);
-
-    compare_rotation_matrices_approx(result1, expt);
-  }
-}
\ No newline at end of file
diff --git a/contrib/world_builder/tests/unit_tests/unit_test_world_builder.cc.bak b/contrib/world_builder/tests/unit_tests/unit_test_world_builder.cc.bak
deleted file mode 100644
index c3fe430775a..00000000000
--- a/contrib/world_builder/tests/unit_tests/unit_test_world_builder.cc.bak
+++ /dev/null
@@ -1,7780 +0,0 @@
-/*
-  Copyright (C) 2018 - 2021 by the authors of the World Builder code.
-
-  This file is part of the World Builder.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU Lesser General Public License as published
-   by the Free Software Foundation, either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#define DOCTEST_CONFIG_SUPER_FAST_ASSERTS
-
-#include "ApprovalTests/ApprovalTests.hpp"
-#include "doctest/doctest.h"
-
-#include "world_builder/config.h"
-#include "world_builder/consts.h"
-#include "world_builder/coordinate_system.h"
-#include "world_builder/coordinate_systems/cartesian.h"
-#include "world_builder/coordinate_systems/interface.h"
-#include "world_builder/coordinate_systems/invalid.h"
-#include "world_builder/features/continental_plate.h"
-#include "world_builder/features/interface.h"
-#include "world_builder/grains.h"
-#include "world_builder/objects/natural_coordinate.h"
-#include "world_builder/objects/segment.h"
-#include "world_builder/objects/surface.h"
-#include "world_builder/parameters.h"
-#include "world_builder/point.h"
-#include "world_builder/types/array.h"
-#include "world_builder/types/bool.h"
-#include "world_builder/types/double.h"
-#include "world_builder/types/interface.h"
-#include "world_builder/types/object.h"
-#include "world_builder/types/one_of.h"
-#include "world_builder/types/plugin_system.h"
-#include "world_builder/types/point.h"
-#include "world_builder/types/segment.h"
-#include "world_builder/types/string.h"
-#include "world_builder/types/unsigned_int.h"
-#include "world_builder/types/value_at_points.h"
-#include "world_builder/utilities.h"
-#include "world_builder/world.h"
-
-
-extern "C" {
-#include "world_builder/wrapper_c.h"
-}
-#include "world_builder/wrapper_cpp.h"
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <iomanip>
-#include <iostream>
-#include <iterator>
-#include <map>
-#include <memory>
-#include <random>
-#include <cstddef>
-#include <string>
-#include <vector>
-
-namespace WorldBuilder
-{
-  namespace Features
-  {
-    namespace FaultModels
-    {
-      namespace Composition
-      {
-        class Interface;
-      }  // namespace Composition
-      namespace Grains
-      {
-        class Interface;
-      }  // namespace Grains
-      namespace Temperature
-      {
-        class Interface;
-      }  // namespace Temperature
-    }  // namespace FaultModels
-  }  // namespace Features
-}  // namespace WorldBuilder
-
-using namespace WorldBuilder;
-using doctest::Approx;
-using doctest::Contains;
-
-/**
- * normalize 3d array
- */
-inline
-std::array<double,3> normalize(std::array<double,3> array)
-{
-  const double norm = sqrt(array[0] * array[0] + array[1] * array[1] + array[2] * array[2]);
-  return {{array[0]/norm,array[1]/norm,array[2]/norm}};
-}
-
-/**
- * Compare the given two std::vector<double> entries with an epsilon (using Catch::Approx)
- */
-inline void compare_vectors_approx(
-  const std::vector<double> &computed,
-  const std::vector<double> &expected)
-{
-  CHECK(computed.size() == expected.size());
-  for (unsigned int i=0; i< computed.size(); ++i)
-    {
-      INFO("vector index i=" << i << ": ");
-      CHECK(computed[i] == Approx(expected[i]));
-    }
-}
-
-/**
- * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
- */
-inline void compare_3d_arrays_approx(
-  const std::array<double,3> &computed,
-  const std::array<double,3> &expected)
-{
-  CHECK(computed.size() == expected.size());
-  for (unsigned int i=0; i< computed.size(); ++i)
-    {
-      INFO("vector index i=" << i << ": ");
-      CHECK(computed[i] == Approx(expected[i]));
-    }
-}
-
-/**
- * Compare the given two std::vector<std::array<std::array<double,3>,3> > entries with an epsilon (using Catch::Approx)
- */
-inline void compare_vectors_array3_array3_approx(
-  const std::vector<std::array<std::array<double,3>,3> > &computed,
-  const std::vector<std::array<std::array<double,3>,3> > &expected)
-{
-  CHECK(computed.size() == expected.size());
-  for (unsigned int i=0; i< computed.size(); ++i)
-    {
-      CHECK(computed[i].size() == expected[i].size());
-      for (unsigned int j=0; j< computed[i].size(); ++j)
-        {
-          CHECK(computed[i][j].size() == expected[i][j].size());
-          for (unsigned int k=0; k< computed[i][j].size(); ++k)
-            {
-              INFO("vector index i:j:k = " << i << ':' << j << ':' << k << std::setprecision(10)
-                   << " = computed: " << computed[i][j][k] << ", expected: " <<  expected[i][j][k]
-                   << ", diff = " << computed[i][j][k] - expected[i][j][k] << ", eps = " << 1e-10);
-              CHECK(std::fabs(computed[i][j][k] - expected[i][j][k]) <= 1e-10);
-            }
-        }
-    }
-}
-
-/**
- * Compare two rotation matrices
- */
-inline void compare_rotation_matrices_approx(
-  const std::array<std::array<double,3>,3> &computed,
-  const std::array<std::array<double,3>,3> &expected)
-{
-  // sign of eigenvector is not important
-  INFO("rotation matrices are not the same: \n" <<
-       "expected = " << expected[0][0] << ' ' << expected[0][1] << ' ' << expected[0][2] << "\n" <<
-       "           " << expected[1][0] << ' ' << expected[1][1] << ' ' << expected[1][2] << "\n" <<
-       "           " << expected[2][0] << ' ' << expected[2][1] << ' ' << expected[2][2] << "\n" <<
-       "computed = " << computed[0][0] << ' ' << computed[0][1] << ' ' << computed[0][2] << "\n" <<
-       "           " << computed[1][0] << ' ' << computed[1][1] << ' ' << computed[1][2] << "\n" <<
-       "           " << computed[2][0] << ' ' << computed[2][1] << ' ' << computed[2][2] << "\n");
-  CHECK((
-          (computed[0][0] == Approx(expected[0][0]) && computed[0][1] == Approx(expected[0][1]) && computed[0][2] == Approx(expected[0][2]) &&
-           computed[1][0] == Approx(expected[1][0]) && computed[1][1] == Approx(expected[1][1]) && computed[1][2] == Approx(expected[1][2]) &&
-           computed[2][0] == Approx(expected[2][0]) && computed[2][1] == Approx(expected[2][1]) && computed[2][2] == Approx(expected[2][2]))
-          ||
-          (computed[0][0] == Approx(-expected[0][0]) && computed[0][1] == Approx(-expected[0][1]) && computed[0][2] == Approx(-expected[0][2]) &&
-           computed[1][0] == Approx(-expected[1][0]) && computed[1][1] == Approx(-expected[1][1]) && computed[1][2] == Approx(-expected[1][2]) &&
-           computed[2][0] == Approx(-expected[2][0]) && computed[2][1] == Approx(-expected[2][1]) && computed[2][2] == Approx(-expected[2][2]))));
-}
-
-
-TEST_CASE("WorldBuilder Point: Testing initialize and operators")
-{
-  std::vector<double> approval_tests;
-
-  // Test initialization of the Point class
-  Point<2> p2(cartesian);
-  Point<3> p3(cartesian);
-
-  CHECK(p2.get_array() == std::array<double,2> {{0,0}});
-  CHECK(p3.get_array() == std::array<double,3> {{0,0,0}});
-
-  const Point<2> p2_array(std::array<double,2> {{1,2}},cartesian);
-  const Point<3> p3_array(std::array<double,3> {{1,2,3}},cartesian);
-
-  CHECK(p2_array.get_array() == std::array<double,2> {{1,2}});
-  CHECK(p3_array.get_array() == std::array<double,3> {{1,2,3}});
-
-  const Point<2> &p2_point(p2_array);
-  const Point<3> &p3_point(p3_array);
-
-  CHECK(p2_point.get_array() == std::array<double,2> {{1,2}});
-  CHECK(p3_point.get_array() == std::array<double,3> {{1,2,3}});
-
-  const Point<2> p2_explicit(3,4,cartesian);
-  const Point<3> p3_explicit(4,5,6,cartesian);
-
-  CHECK(p2_explicit.get_array() == std::array<double,2> {{3,4}});
-  CHECK(p3_explicit.get_array() == std::array<double,3> {{4,5,6}});
-
-
-  // Test Point operators
-
-  // Test assign operator
-  p2 = p2_array;
-  p3 = p3_array;
-
-  CHECK(p2.get_array() == std::array<double,2> {{1,2}});
-  CHECK(p3.get_array() == std::array<double,3> {{1,2,3}});
-
-  // Test multiply operator
-  p2 = 2 * p2 * 1.0;
-  p3 = 2 * p3 * 1.0;
-
-  CHECK(p2.get_array() == std::array<double,2> {{2,4}});
-  CHECK(p3.get_array() == std::array<double,3> {{2,4,6}});
-
-  p2 *= 2;
-  p3 *= 2;
-
-  CHECK(p2.get_array() == std::array<double,2> {{4,8}});
-  CHECK(p3.get_array() == std::array<double,3> {{4,8,12}});
-
-  // Test dot operator
-  approval_tests.emplace_back(p2_array * p2_explicit);
-  approval_tests.emplace_back(p3_array * p3_explicit);
-
-  // Test add operator
-  p2 = p2 + p2;
-  p3 = p3 + p3;
-
-  CHECK(p2.get_array() == std::array<double,2> {{8,16}});
-  CHECK(p3.get_array() == std::array<double,3> {{8,16,24}});
-
-  p2 += p2;
-  p3 += p3;
-
-  CHECK(p2.get_array() == std::array<double,2> {{16,32}});
-  CHECK(p3.get_array() == std::array<double,3> {{16,32,48}});
-
-  // Test subtract operator
-  p2 = p2 - (0.5 * p2);
-  p3 = p3 - (0.5 * p3);
-
-  CHECK(p2.get_array() == std::array<double,2> {{8,16}});
-  CHECK(p3.get_array() == std::array<double,3> {{8,16,24}});
-
-  p2 -=  (0.5 * p2);
-  p3 -=  (0.5 * p3);
-
-  CHECK(p2.get_array() == std::array<double,2> {{4,8}});
-  CHECK(p3.get_array() == std::array<double,3> {{4,8,12}});
-
-  // Test coordinate system
-  //approval_tests.emplace_back(p2.get_coordinate_system());
-  //approval_tests.emplace_back(p3.get_coordinate_system());
-
-  // Test norm and norm_square
-  approval_tests.emplace_back(p2.norm_square());
-  approval_tests.emplace_back(p3.norm_square());
-
-  approval_tests.emplace_back(p2.norm());
-  approval_tests.emplace_back(p3.norm());
-
-  // Test Point utility classes
-  const std::array<double,2> an2 = Utilities::convert_point_to_array(p2_point);
-  const std::array<double,3> an3 = Utilities::convert_point_to_array(p3_point);
-
-  CHECK(an2 == std::array<double,2> {{1,2}});
-  CHECK(an3 == std::array<double,3> {{1,2,3}});
-
-  CHECK_THROWS_WITH(Point<2>(1,2,3,cartesian),Contains("Can't use the 3d constructor in 2d."));
-  CHECK_THROWS_WITH(Point<3>(1,2,cartesian),Contains("Can't use the 2d constructor in 3d."));
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-
-TEST_CASE("WorldBuilder Utilities: string to conversions")
-{
-  // Test string to number conversion
-  CHECK(Utilities::string_to_double("1") == Approx(1.0));
-  CHECK(Utilities::string_to_double(" 1 ") == Approx(1.0));
-  CHECK(Utilities::string_to_double(" 1.01 ") == Approx(1.01));
-
-  CHECK_THROWS_WITH(Utilities::string_to_double("1a"),
-                    Contains("Could not convert \"1a\" to a double."));
-  CHECK_THROWS_WITH(Utilities::string_to_double("a1"),
-                    Contains("Could not convert \"a1\" to a double."));
-  CHECK_THROWS_WITH(Utilities::string_to_double("a"),
-                    Contains("Could not convert \"a\" to a double."));
-
-  CHECK(Utilities::string_to_int("2") == Approx(2.0));
-  CHECK(Utilities::string_to_int(" 2 ") == Approx(2.0));
-
-  CHECK_THROWS_WITH(Utilities::string_to_int(" 2.02 "),
-                    Contains("Could not convert \"2.02\" to an int."));
-  CHECK_THROWS_WITH(Utilities::string_to_int("2b"),
-                    Contains("Could not convert \"2b\" to an int."));
-  CHECK_THROWS_WITH(Utilities::string_to_int("b2"),
-                    Contains("Could not convert \"b2\" to an int."));
-  CHECK_THROWS_WITH(Utilities::string_to_int("b"),
-                    Contains("Could not convert \"b\" to an int."));
-
-  CHECK(Utilities::string_to_unsigned_int("3") == Approx(3.0));
-  CHECK(Utilities::string_to_unsigned_int(" 3 ") == Approx(3.0));
-
-  CHECK_THROWS_WITH(Utilities::string_to_unsigned_int(" 3.03 "),
-                    Contains("Could not convert \"3.03\" to an unsigned int."));
-  CHECK_THROWS_WITH(Utilities::string_to_unsigned_int("3c"),
-                    Contains("Could not convert \"3c\" to an unsigned int."));
-  CHECK_THROWS_WITH(Utilities::string_to_unsigned_int("c3"),
-                    Contains("Could not convert \"c3\" to an unsigned int."));
-  CHECK_THROWS_WITH(Utilities::string_to_unsigned_int("c"),
-                    Contains("Could not convert \"c\" to an unsigned int."));
-
-  // Test point to array conversion
-  const Point<2> p2(1,2,cartesian);
-  const Point<3> p3(1,2,3,cartesian);
-
-  CHECK(Utilities::convert_point_to_array(p2) == std::array<double,2> {{1,2}});
-  CHECK(Utilities::convert_point_to_array(p3) == std::array<double,3> {{1,2,3}});
-
-  // Test coordinate system
-  CHECK(Utilities::string_to_coordinate_system("cartesian") == CoordinateSystem::cartesian);
-  CHECK(Utilities::string_to_coordinate_system("spherical") == CoordinateSystem::spherical);
-  CHECK_THROWS_WITH(Utilities::string_to_coordinate_system("other"), Contains("Coordinate system not implemented."));
-}
-
-
-TEST_CASE("WorldBuilder Utilities: interpolation")
-{
-  std::vector<double> approval_tests;
-
-  std::vector<double> x = {{0,1,2,3}};
-  std::vector<double> y = {{10,5,5,35}};
-
-  Utilities::interpolation monotone_cubic_spline;
-  monotone_cubic_spline.set_points(y);
-
-  approval_tests.emplace_back(monotone_cubic_spline(-1));
-  approval_tests.emplace_back(monotone_cubic_spline(-0.9));
-  approval_tests.emplace_back(monotone_cubic_spline(-0.7));
-  approval_tests.emplace_back(monotone_cubic_spline(-0.5));
-  approval_tests.emplace_back(monotone_cubic_spline(-0.3));
-  approval_tests.emplace_back(monotone_cubic_spline(-0.1));
-  approval_tests.emplace_back(monotone_cubic_spline(0));
-  approval_tests.emplace_back(monotone_cubic_spline(0.1));
-  approval_tests.emplace_back(monotone_cubic_spline(0.3));
-  approval_tests.emplace_back(monotone_cubic_spline(0.5));
-  approval_tests.emplace_back(monotone_cubic_spline(0.7));
-  approval_tests.emplace_back(monotone_cubic_spline(0.9));
-  approval_tests.emplace_back(monotone_cubic_spline(1));
-  approval_tests.emplace_back(monotone_cubic_spline(1.1));
-  approval_tests.emplace_back(monotone_cubic_spline(1.3));
-  approval_tests.emplace_back(monotone_cubic_spline(1.5));
-  approval_tests.emplace_back(monotone_cubic_spline(1.7));
-  approval_tests.emplace_back(monotone_cubic_spline(1.9));
-  approval_tests.emplace_back(monotone_cubic_spline(2));
-  approval_tests.emplace_back(monotone_cubic_spline(2.025));
-  approval_tests.emplace_back(monotone_cubic_spline(2.075));
-  approval_tests.emplace_back(monotone_cubic_spline(2.125));
-  approval_tests.emplace_back(monotone_cubic_spline(2.175));
-  approval_tests.emplace_back(monotone_cubic_spline(2.225));
-  approval_tests.emplace_back(monotone_cubic_spline(2.25));
-  approval_tests.emplace_back(monotone_cubic_spline(2.275));
-  approval_tests.emplace_back(monotone_cubic_spline(2.325));
-  approval_tests.emplace_back(monotone_cubic_spline(2.375));
-  approval_tests.emplace_back(monotone_cubic_spline(2.425));
-  approval_tests.emplace_back(monotone_cubic_spline(2.475));
-  approval_tests.emplace_back(monotone_cubic_spline(2.5));
-  approval_tests.emplace_back(monotone_cubic_spline(2.625));
-  approval_tests.emplace_back(monotone_cubic_spline(2.75));
-  approval_tests.emplace_back(monotone_cubic_spline(2.875));
-  approval_tests.emplace_back(monotone_cubic_spline(3));
-  approval_tests.emplace_back(monotone_cubic_spline(3.125));
-  approval_tests.emplace_back(monotone_cubic_spline(3.25));
-
-  Utilities::interpolation monotone_cubic_spline2;
-  y[1] = -5;
-  y[3] = -35;
-  monotone_cubic_spline2.set_points(y);
-  approval_tests.emplace_back(monotone_cubic_spline2(-1));
-  approval_tests.emplace_back(monotone_cubic_spline2(-0.5));
-  approval_tests.emplace_back(monotone_cubic_spline2(0));
-  approval_tests.emplace_back(monotone_cubic_spline2(0.5));
-  approval_tests.emplace_back(monotone_cubic_spline2(1));
-  approval_tests.emplace_back(monotone_cubic_spline2(1.5));
-  approval_tests.emplace_back(monotone_cubic_spline2(2));
-  approval_tests.emplace_back(monotone_cubic_spline2(2.125) == Approx(3.828125));
-  approval_tests.emplace_back(monotone_cubic_spline2(2.25));
-  approval_tests.emplace_back(monotone_cubic_spline2(2.375) == Approx(-4.140625));
-  approval_tests.emplace_back(monotone_cubic_spline2(2.5));
-  approval_tests.emplace_back(monotone_cubic_spline2(2.625));
-  approval_tests.emplace_back(monotone_cubic_spline2(2.75));
-  approval_tests.emplace_back(monotone_cubic_spline2(2.875));
-  approval_tests.emplace_back(monotone_cubic_spline2(3));
-  approval_tests.emplace_back(monotone_cubic_spline2(3.125));
-  approval_tests.emplace_back(monotone_cubic_spline2(3.25));
-
-  Utilities::interpolation monotone_cubic_spline3;
-  y[0] = 10;
-  y[1] = -5;
-  y[2] = -10;
-  y[3] = -35;
-  monotone_cubic_spline3.set_points(y);
-  approval_tests.emplace_back(monotone_cubic_spline3(-1));
-  approval_tests.emplace_back(monotone_cubic_spline3(-0.5));
-  approval_tests.emplace_back(monotone_cubic_spline3(0));
-  approval_tests.emplace_back(monotone_cubic_spline3(0.5));
-  approval_tests.emplace_back(monotone_cubic_spline3(1));
-  approval_tests.emplace_back(monotone_cubic_spline3(1.5));
-  approval_tests.emplace_back(monotone_cubic_spline3(2));
-  approval_tests.emplace_back(monotone_cubic_spline3(2.125));
-  approval_tests.emplace_back(monotone_cubic_spline3(2.25) == Approx(-13.90625));
-  approval_tests.emplace_back(monotone_cubic_spline3(2.375));
-  approval_tests.emplace_back(monotone_cubic_spline3(2.5));
-  approval_tests.emplace_back(monotone_cubic_spline3(2.625));
-  approval_tests.emplace_back(monotone_cubic_spline3(2.75));
-  approval_tests.emplace_back(monotone_cubic_spline3(2.875));
-  approval_tests.emplace_back(monotone_cubic_spline3(3));
-  approval_tests.emplace_back(monotone_cubic_spline3(3.125));
-  approval_tests.emplace_back(monotone_cubic_spline3(3.25));
-
-  // bi monotone cubic spline
-  Utilities::interpolation monotone_cubic_spline_x;
-  Utilities::interpolation monotone_cubic_spline_y;
-  x[0] = 0;
-  x[1] = 1;
-  x[2] = 2;
-  x[3] = 3;
-  y[0] = 10;
-  y[1] = 10;
-  y[2] = 5;
-  y[3] = 0;
-  monotone_cubic_spline_x.set_points(y);
-  y[0] = 0;
-  y[1] = 5;
-  y[2] = 10;
-  y[3] = 10;
-  monotone_cubic_spline_y.set_points(y);
-
-  approval_tests.emplace_back(monotone_cubic_spline_x(0));
-  approval_tests.emplace_back(monotone_cubic_spline_x(0.25));
-  approval_tests.emplace_back(monotone_cubic_spline_x(0.5));
-  approval_tests.emplace_back(monotone_cubic_spline_x(0.75));
-  approval_tests.emplace_back(monotone_cubic_spline_x(1));
-  approval_tests.emplace_back(monotone_cubic_spline_x(1.25) == Approx(9.453125));
-  approval_tests.emplace_back(monotone_cubic_spline_x(1.5));
-  approval_tests.emplace_back(monotone_cubic_spline_x(1.75));
-  approval_tests.emplace_back(monotone_cubic_spline_x(2));
-  approval_tests.emplace_back(monotone_cubic_spline_x(2.25));
-  approval_tests.emplace_back(monotone_cubic_spline_x(2.5));
-  approval_tests.emplace_back(monotone_cubic_spline_x(2.75));
-  approval_tests.emplace_back(monotone_cubic_spline_x(3));
-
-  approval_tests.emplace_back(monotone_cubic_spline_y(0));
-  approval_tests.emplace_back(monotone_cubic_spline_y(0.25));
-  approval_tests.emplace_back(monotone_cubic_spline_y(0.5));
-  approval_tests.emplace_back(monotone_cubic_spline_y(0.75) == Approx(3.515625));
-  approval_tests.emplace_back(monotone_cubic_spline_y(1));
-  approval_tests.emplace_back(monotone_cubic_spline_y(1.25));
-  approval_tests.emplace_back(monotone_cubic_spline_y(1.5));
-  approval_tests.emplace_back(monotone_cubic_spline_y(1.75) == Approx(9.453125));
-  approval_tests.emplace_back(monotone_cubic_spline_y(2));
-  approval_tests.emplace_back(monotone_cubic_spline_y(2.25));
-  approval_tests.emplace_back(monotone_cubic_spline_y(2.5));
-  approval_tests.emplace_back(monotone_cubic_spline_y(2.75));
-  approval_tests.emplace_back(monotone_cubic_spline_y(3));
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder Utilities: Point in polygon")
-{
-  std::vector<Point<2> > point_list_4_elements(4, Point<2>(cartesian));
-  point_list_4_elements[0] = Point<2>(0,0,cartesian);
-  point_list_4_elements[1] = Point<2>(5,0,cartesian);
-  point_list_4_elements[2] = Point<2>(5,5,cartesian);
-  point_list_4_elements[3] = Point<2>(0,5,cartesian);
-
-  std::vector<Point<2> > point_list_3_elements(3, Point<2>(cartesian));
-  point_list_3_elements[0] = Point<2>(10,10,cartesian);
-  point_list_3_elements[1] = Point<2>(10,15,cartesian);
-  point_list_3_elements[2] = Point<2>(15,15,cartesian);
-
-  std::vector<Point<2> > check_points(9, Point<2>(cartesian));
-  check_points[0] = Point<2>(-1,-1,cartesian);
-  check_points[1] = Point<2>(0,0,cartesian);
-  check_points[2] = Point<2>(0,5,cartesian);
-  check_points[3] = Point<2>(5,0,cartesian);
-  check_points[4] = Point<2>(5,5,cartesian);
-  check_points[5] = Point<2>(5,5.01,cartesian);
-  check_points[6] = Point<2>(1,1,cartesian);
-  check_points[7] = Point<2>(12.5,12,cartesian);
-  check_points[8] = Point<2>(11.5,12,cartesian);
-
-  std::vector<std::array<bool,2> > answers(9);
-  answers[0] = {{false,false}};
-  answers[1] = {{true,false}};
-  answers[2] = {{true,false}};
-  answers[3] = {{true,false}};
-  answers[4] = {{true,false}};
-  answers[5] = {{false,false}};
-  answers[6] = {{true,false}};
-  answers[7] = {{false,false}};
-  answers[8] = {{false,true}};
-
-  std::vector<std::array<double,2> > answers_signed_distance(9);
-  answers_signed_distance[0] = {{-std::sqrt(2), -std::sqrt(11 * 11 + 11 * 11)}};
-  answers_signed_distance[1] = {{0,-std::sqrt(10 * 10 + 10 * 10)}};
-  answers_signed_distance[2] = {{0,-std::sqrt(125)}};
-  answers_signed_distance[3] = {{0,-std::sqrt(125)}};
-  answers_signed_distance[4] = {{0,-std::sqrt(50)}};
-  answers_signed_distance[5] = {{-std::sqrt(0.01 * 0.01),-std::sqrt(5 * 5 + 4.99 * 4.99)}};
-  answers_signed_distance[6] = {{1,-std::sqrt(9 * 9 + 9 * 9)}};
-  answers_signed_distance[7] = {{-10.2591422643,-0.3535533906}};
-  answers_signed_distance[8] = {{-9.5524865873,0.3535533906}};
-
-  for (unsigned int i = 0; i < check_points.size(); ++i)
-    {
-      INFO("checking point " << i << " = (" << check_points[i][0] << ':' << check_points[i][1] << ')');
-      CHECK(Utilities::polygon_contains_point(point_list_4_elements,check_points[i]) == answers[i][0]);
-      CHECK(Utilities::polygon_contains_point(point_list_3_elements,check_points[i]) == answers[i][1]);
-      CHECK(Utilities::signed_distance_to_polygon(point_list_4_elements,check_points[i]) == Approx(answers_signed_distance[i][0]));
-      CHECK(Utilities::signed_distance_to_polygon(point_list_3_elements,check_points[i]) == Approx(answers_signed_distance[i][1]));
-    }
-
-  const std::vector<Point<2> > point_list_2_elements(2, Point<2>(cartesian));
-  CHECK_THROWS_WITH(Utilities::signed_distance_to_polygon(point_list_2_elements,check_points[0]),
-                    Contains("Not enough polygon points were specified."));
-
-  const std::vector<Point<2> > point_list_1_elements(1, Point<2>(cartesian));
-  CHECK_THROWS_WITH(Utilities::signed_distance_to_polygon(point_list_1_elements,check_points[0]),
-                    Contains("Not enough polygon points were specified."));
-
-  const std::vector<Point<2> > point_list_0_elements(0, Point<2>(cartesian));
-  CHECK_THROWS_WITH(Utilities::signed_distance_to_polygon(point_list_0_elements,check_points[0]),
-                    Contains("Not enough polygon points were specified."));
-}
-
-
-TEST_CASE("WorldBuilder Utilities: Natural Coordinate")
-{
-  std::vector<double> approval_tests;
-
-  // Cartesian
-  const std::unique_ptr<CoordinateSystems::Interface> cartesian(CoordinateSystems::Interface::create("cartesian",nullptr));
-
-  // Test the natural coordinate system
-  const Objects::NaturalCoordinate nca1(std::array<double,3> {{1,2,3}},*cartesian);
-  CHECK(nca1.get_coordinates() == std::array<double,3> {{1,2,3}});
-  CHECK(nca1.get_surface_coordinates() == std::array<double,2> {{1,2}});
-  approval_tests.emplace_back(nca1.get_depth_coordinate());
-
-  const Objects::NaturalCoordinate ncp1(Point<3>(1,2,3,CoordinateSystem::cartesian),*cartesian);
-  CHECK(ncp1.get_coordinates() == std::array<double,3> {{1,2,3}});
-  CHECK(ncp1.get_surface_coordinates() == std::array<double,2> {{1,2}});
-  approval_tests.emplace_back(ncp1.get_depth_coordinate());
-
-
-  const std::unique_ptr<CoordinateSystems::Interface> spherical(CoordinateSystems::Interface::create("spherical",nullptr));
-
-  // Test the natural coordinate system
-  const Objects::NaturalCoordinate nsa1(std::array<double,3> {{1,2,3}},*spherical);
-  std::array<double,3> nsa1_array = nsa1.get_coordinates();
-  approval_tests.emplace_back(nsa1_array[0]);
-  approval_tests.emplace_back(nsa1_array[1]);
-  approval_tests.emplace_back(nsa1_array[2]);
-  std::array<double,2> nsa1_surface_array = nsa1.get_surface_coordinates();
-  approval_tests.emplace_back(nsa1_surface_array[0]);
-  approval_tests.emplace_back(nsa1_surface_array[1]);
-  approval_tests.emplace_back(nsa1.get_depth_coordinate());
-
-
-  const Objects::NaturalCoordinate nsp1(Point<3>(1,2,3,CoordinateSystem::spherical),*spherical);
-  std::array<double,3> nsp1_array = nsp1.get_coordinates();
-  approval_tests.emplace_back(nsp1_array[0]);
-  approval_tests.emplace_back(nsp1_array[1]);
-  approval_tests.emplace_back(nsp1_array[2]);
-  std::array<double,2> nsp1_surface_array = nsp1.get_surface_coordinates();
-  approval_tests.emplace_back(nsp1_surface_array[0]);
-  approval_tests.emplace_back(nsp1_surface_array[1]);
-  approval_tests.emplace_back(nsp1.get_depth_coordinate());
-
-  // Invalid tests
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian.wb";
-  WorldBuilder::World world(file_name);
-  Parameters prm(world);
-  std::unique_ptr<CoordinateSystems::Interface> invalid(new CoordinateSystems::Invalid(nullptr));
-  invalid->parse_entries(prm);
-  Objects::NaturalCoordinate ivp1(Point<3>(1,2,3,CoordinateSystem::invalid),*invalid);
-  std::array<double,3> ivp1_array = ivp1.get_coordinates();
-  CHECK(std::isnan(ivp1_array[0]));
-  CHECK(std::isnan(ivp1_array[1]));
-  CHECK(std::isnan(ivp1_array[2]));
-  CHECK_THROWS_WITH(ivp1.get_surface_coordinates(),Contains("Coordinate system not implemented."));
-  CHECK_THROWS_WITH(ivp1.get_surface_point(),Contains("Coordinate system not implemented."));
-  CHECK_THROWS_WITH(ivp1.get_depth_coordinate(),Contains("Coordinate system not implemented."));
-  CHECK_THROWS_WITH(ivp1.get_depth_coordinate(),Contains("Coordinate system not implemented."));
-  CHECK_THROWS_WITH(ivp1.get_ref_depth_coordinate(),Contains("Coordinate system not implemented."));
-  CHECK(std::isnan(invalid->distance_between_points_at_same_depth(Point<3>(1,2,3,CoordinateSystem::invalid),
-                                                                  Point<3>(1,2,3,CoordinateSystem::invalid))));
-  approval_tests.emplace_back(invalid->depth_method());
-
-  std::array<double,3> iv_array = invalid->natural_to_cartesian_coordinates({{1,2,3}});
-  CHECK(std::isnan(iv_array[0]));
-  CHECK(std::isnan(iv_array[1]));
-  CHECK(std::isnan(iv_array[2]));
-
-  CHECK(std::isnan(invalid->max_model_depth()));
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder Utilities: Coordinate systems transformations")
-{
-  std::vector<double> approval_tests;
-
-  // Test coordinate system transformation
-  {
-    const Point<3> cartesian(3,4,5,CoordinateSystem::cartesian);
-
-    const Point<3> spherical(Utilities::cartesian_to_spherical_coordinates(Point<3>(cartesian.get_array(),CoordinateSystem::cartesian)), CoordinateSystem::spherical);
-
-    compare_vectors_approx(std::vector<double>(std::begin(spherical.get_array()), std::end(spherical.get_array())),
-    std::vector<double> {{std::sqrt(3*3+4*4+5*5),0.927295218001613,0.7853982}});
-
-    const Point<3> cartesian_back(Utilities::spherical_to_cartesian_coordinates(spherical.get_array()), CoordinateSystem::cartesian);
-
-    compare_vectors_approx(std::vector<double>(std::begin(cartesian_back.get_array()), std::end(cartesian_back.get_array())),
-    std::vector<double> {{3,4,5}});
-  }
-
-  {
-    const Point<3> cartesian(-2,-1,6,CoordinateSystem::cartesian);
-
-    const Point<3> spherical(Utilities::cartesian_to_spherical_coordinates(Point<3>(cartesian.get_array(),CoordinateSystem::cartesian)), CoordinateSystem::spherical);
-
-    compare_vectors_approx(std::vector<double>(std::begin(spherical.get_array()), std::end(spherical.get_array())),
-    std::vector<double> {{std::sqrt(2*2+1*1+6*6),-2.6779450446,1.2140629383}});
-
-    const Point<3> cartesian_back(Utilities::spherical_to_cartesian_coordinates(spherical.get_array()), CoordinateSystem::cartesian);
-
-    approval_tests.insert(approval_tests.end(), std::begin(cartesian_back.get_array()), std::end(cartesian_back.get_array()));
-  }
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-
-}
-
-TEST_CASE("WorldBuilder Utilities: cross product")
-{
-  const std::vector<double> approval_tests;
-
-  const Point<3> unit_x(1,0,0,cartesian);
-  const Point<3> unit_y(0,1,0,cartesian);
-  const Point<3> unit_z(0,0,1,cartesian);
-
-  compare_3d_arrays_approx(Utilities::cross_product(unit_x, unit_x).get_array(), std::array<double,3> {{0,0,0}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_x, unit_y).get_array(), std::array<double,3> {{0,0,1}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_x, unit_z).get_array(), std::array<double,3> {{0,-1,0}});
-
-  compare_3d_arrays_approx(Utilities::cross_product(unit_y, unit_x).get_array(), std::array<double,3> {{0,0,-1}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_y, unit_y).get_array(), std::array<double,3> {{0,0,0}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_y, unit_z).get_array(), std::array<double,3> {{1,0,0}});
-
-  compare_3d_arrays_approx(Utilities::cross_product(unit_z, unit_x).get_array(), std::array<double,3> {{0,1,0}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_z, unit_y).get_array(), std::array<double,3> {{-1,0,0}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_z, unit_z).get_array(), std::array<double,3> {{0,0,0}});
-
-
-  const double sqrt2 = sqrt(0.5);
-  const Point<3> sqrt2_x(sqrt2,0,0,cartesian);
-  const Point<3> sqrt2_y(0,sqrt2,0,cartesian);
-  const Point<3> sqrt2_z(0,0,sqrt2,cartesian);
-
-  const Point<3> unit_xy(sqrt2,sqrt2,0,cartesian);
-  const Point<3> unit_xz(sqrt2,0,sqrt2,cartesian);
-  const Point<3> unit_yz(0,sqrt2,sqrt2,cartesian);
-
-  compare_3d_arrays_approx(Utilities::cross_product(unit_xy, sqrt2_x).get_array(), std::array<double,3> {{0,0,-0.5}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_xy, sqrt2_y).get_array(), std::array<double,3> {{0,0,0.5}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_xy, sqrt2_z).get_array(), std::array<double,3> {{0.5,-0.5,0}});
-
-  compare_3d_arrays_approx(Utilities::cross_product(unit_xz, sqrt2_x).get_array(), std::array<double,3> {{0,0.5,0}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_xz, sqrt2_y).get_array(), std::array<double,3> {{-0.5,0,0.5}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_xz, sqrt2_z).get_array(), std::array<double,3> {{0,-0.5,0}});
-
-  compare_3d_arrays_approx(Utilities::cross_product(unit_yz, sqrt2_x).get_array(), std::array<double,3> {{0,0.5,-0.5}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_yz, sqrt2_y).get_array(), std::array<double,3> {{-0.5,0,0}});
-  compare_3d_arrays_approx(Utilities::cross_product(unit_yz, sqrt2_z).get_array(), std::array<double,3> {{0.5,0,0}});
-
-  const Point<3> point1(2,3,4,cartesian);
-  const Point<3> point2(5,6,7,cartesian);
-
-  compare_3d_arrays_approx(Utilities::cross_product(point1, point2).get_array(), std::array<double,3> {{-3,6,-3}});
-  compare_3d_arrays_approx(Utilities::cross_product(point2, point1).get_array(), std::array<double,3> {{3,-6,3}});
-}
-
-TEST_CASE("WorldBuilder C wrapper")
-{
-  std::vector<double> approval_tests;
-
-  // First test a world builder file with a cross section defined
-  std::string file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb1.json";
-  void *ptr_world = nullptr;
-  void **ptr_ptr_world = &ptr_world;
-  const char *world_builder_file = file.c_str();
-  bool has_output_dir = false;
-
-  create_world(ptr_ptr_world, world_builder_file, &has_output_dir, "", 1);
-
-  double temperature = 0.;
-
-  temperature_2d(*ptr_ptr_world, 1, 2, 0, &temperature);
-  approval_tests.emplace_back(temperature);
-  temperature_3d(*ptr_ptr_world, 1, 2, 3, 0, &temperature);
-  approval_tests.emplace_back(temperature);
-  temperature_2d(*ptr_ptr_world, 550e3, 0, 0, &temperature);
-  approval_tests.emplace_back(temperature);
-  temperature_3d(*ptr_ptr_world, 120e3, 500e3, 0, 0, &temperature);
-  approval_tests.emplace_back(temperature);
-
-  // Test the compositions
-  double composition = 0.0;
-
-  composition_2d(*ptr_ptr_world, 1, 2, 0, 2, &composition);
-  approval_tests.emplace_back(composition);
-  composition_3d(*ptr_ptr_world, 1, 2, 3, 0, 2, &composition);
-  approval_tests.emplace_back(composition);
-  composition_2d(*ptr_ptr_world,  550e3, 0, 0, 3, &composition);
-  approval_tests.emplace_back(composition);
-  composition_3d(*ptr_ptr_world, 120e3, 500e3, 0, 0, 3, &composition);
-  approval_tests.emplace_back(composition);
-
-  release_world(*ptr_ptr_world);
-
-  // Now test a world builder file without a cross section defined
-  file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb2.json";
-  ptr_world = nullptr;
-  ptr_ptr_world = &ptr_world;
-  const char *world_builder_file2 = file.c_str();
-  has_output_dir = false;
-
-  create_world(ptr_ptr_world, world_builder_file2, &has_output_dir, "", 1);
-
-
-  CHECK_THROWS_WITH(temperature_2d(*ptr_ptr_world, 1, 2, 0, &temperature),
-                    Contains("This function can only be called when the cross section "
-                             "variable in the world builder file has been set. Dim is 3."));
-  temperature_3d(*ptr_ptr_world, 1, 2, 3, 0, &temperature);
-  approval_tests.emplace_back(temperature);
-  temperature_3d(*ptr_ptr_world, 120e3, 500e3, 0, 0, &temperature);
-  approval_tests.emplace_back(temperature);
-
-  // Test the compositions
-  CHECK_THROWS_WITH(composition_2d(*ptr_ptr_world, 1, 2, 0, 2, &composition),
-                    Contains("This function can only be called when the cross section "
-                             "variable in the world builder file has been set. Dim is 3."));
-
-  composition_3d(*ptr_ptr_world, 1, 2, 3, 0, 2, &composition);
-  approval_tests.emplace_back(composition);
-  composition_3d(*ptr_ptr_world, 120e3, 500e3, 0, 0, 3, &composition);
-  approval_tests.emplace_back(composition);
-
-  release_world(*ptr_ptr_world);
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder CPP wrapper")
-{
-  std::vector<double> approval_tests;
-
-  // First test a world builder file with a cross section defined
-  std::string file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb1.json";
-
-  wrapper_cpp::WorldBuilderWrapper world(file);
-
-  double temperature = 0;
-
-  temperature = world.temperature_2d(1, 2, 0);
-  approval_tests.emplace_back(temperature);
-  temperature = world.temperature_3d(1, 2, 3, 0);
-  approval_tests.emplace_back(temperature);
-  temperature = world.temperature_2d(550e3, 0, 0);
-  approval_tests.emplace_back(temperature);
-  temperature = world.temperature_3d(120e3, 500e3, 0, 0);
-  approval_tests.emplace_back(temperature);
-
-  // Test the compositions
-  double composition = 0.0;
-
-  composition = world.composition_2d(1, 2, 0, 2);
-  approval_tests.emplace_back(composition);
-  composition = world.composition_3d(1, 2, 3, 0, 2);
-  approval_tests.emplace_back(composition);
-  composition = world.composition_2d(550e3, 0, 0, 3);
-  approval_tests.emplace_back(composition);
-  composition = world.composition_3d(120e3, 500e3, 0, 0, 3);
-  approval_tests.emplace_back(composition);
-
-
-  // Now test a world builder file without a cross section defined
-  file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb2.json";
-
-  wrapper_cpp::WorldBuilderWrapper world2(file);
-
-
-  CHECK_THROWS_WITH(world2.temperature_2d(1, 2, 0),
-                    Contains("This function can only be called when the cross section "
-                             "variable in the world builder file has been set. Dim is 3."));
-  temperature = world2.temperature_3d(1, 2, 3, 0);
-  approval_tests.emplace_back(temperature);
-  temperature = world2.temperature_3d(120e3, 500e3, 0, 0);
-  approval_tests.emplace_back(temperature);
-
-  // Test the compositions
-  CHECK_THROWS_WITH(world2.composition_2d(1, 2, 0, 2),
-                    Contains("This function can only be called when the cross section "
-                             "variable in the world builder file has been set. Dim is 3."));
-
-  composition = world2.composition_3d(1, 2, 3, 0, 2);
-  approval_tests.emplace_back(composition);
-  composition = world2.composition_3d(120e3, 500e3, 0, 0, 3);
-  approval_tests.emplace_back(composition);
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder interface")
-{
-
-  std::vector<grains> approval_tests_grains;
-  const std::string file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/continental_plate.wb";
-  const WorldBuilder::World world(file);
-
-  CHECK_THROWS_WITH(world.properties({{1,2,3}},1., {{{{0,0,0}}}}),Contains("Unimplemented property provided. Only "));
-  CHECK_THROWS_WITH(world.properties({{1,2,3}},1., {{{{5,0,0}}}}),Contains("Unimplemented property provided. Only "));
-
-  approval_tests_grains.emplace_back(world.grains(std::array<double,3> {{750e3,250e3,100e3}},10e3,0,3));
-  approval_tests_grains.emplace_back(world.grains(std::array<double,2> {{750e3,100e3}},10e3,0,3));
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests_grains);
-}
-
-TEST_CASE("Worldbuilder grains")
-{
-  // creat a grains object
-  const WorldBuilder::grains grains;
-
-  CHECK(grains.sizes.size() == 0);
-  CHECK(grains.rotation_matrices.size() == 0);
-}
-
-TEST_CASE("WorldBuilder World random")
-{
-  std::vector<double> approval_tests;
-
-  // The world builder uses a deterministic random number generator. This is on prorpose
-  // because even though you might want to use random numbers, the result should be
-  // reproducible. Note that when the world builder is used in for example MPI programs
-  // you should supply the world builder created each MPI process a different seed. You
-  // can use the MPI RANK for this (seed is seed + MPI_RANK). Because the generator is
-  // deterministic (known and documented algorithm), we can test the results and they
-  // should be the same even for different compilers and machines.
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_spherical.wb";
-  WorldBuilder::World world1(file_name, false, "", 1);
-  // same result as https://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine/seed
-  approval_tests.emplace_back(world1.get_random_number_engine()());
-  approval_tests.emplace_back(world1.get_random_number_engine()());
-  std::uniform_real_distribution<> dist(1.0,2.0);
-  approval_tests.emplace_back(dist(world1.get_random_number_engine()));
-  approval_tests.emplace_back(dist(world1.get_random_number_engine()));
-
-  // test whether the seed indeed changes the resuls
-  WorldBuilder::World world2(file_name, false, "", 2);
-  approval_tests.emplace_back(world2.get_random_number_engine()());
-  approval_tests.emplace_back(world2.get_random_number_engine()());
-  approval_tests.emplace_back(dist(world2.get_random_number_engine()));
-  approval_tests.emplace_back(dist(world2.get_random_number_engine()));
-
-  // Test reproducibility with the same seed.
-  WorldBuilder::World world3(file_name, false, "", 1);
-  approval_tests.emplace_back(world3.get_random_number_engine()());
-  approval_tests.emplace_back(world3.get_random_number_engine()());
-  approval_tests.emplace_back(dist(world3.get_random_number_engine()));
-  approval_tests.emplace_back(dist(world3.get_random_number_engine()));
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder Coordinate Systems: Interface")
-{
-  std::vector<double> approval_tests;
-
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_spherical.wb";
-  WorldBuilder::World world(file_name);
-
-  CHECK_THROWS_WITH(CoordinateSystems::Interface::create("!not_implemented_coordinate_system!",&world),
-                    Contains("Internal error: Plugin with name '!not_implemented_coordinate_system!' is not found. "
-                             "The size of factories is "));
-
-  std::unique_ptr<CoordinateSystems::Interface> interface(CoordinateSystems::Interface::create("cartesian",&world));
-
-  interface->declare_entries(world.parameters, "", {});
-
-  CHECK(interface->cartesian_to_natural_coordinates(std::array<double,3> {{1,2,3}}) == std::array<double,3> {{1,2,3}});
-  CHECK(interface->natural_to_cartesian_coordinates(std::array<double,3> {{1,2,3}}) == std::array<double,3> {{1,2,3}});
-
-  approval_tests.emplace_back(interface->natural_coordinate_system());
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder Coordinate Systems: Cartesian")
-{
-  std::vector<double> approval_tests;
-
-  std::unique_ptr<CoordinateSystems::Interface> cartesian(CoordinateSystems::Interface::create("cartesian",nullptr));
-
-  //todo:fix
-  //cartesian->declare_entries();
-
-  CHECK(cartesian->cartesian_to_natural_coordinates(std::array<double,3> {{1,2,3}}) == std::array<double,3> {{1,2,3}});
-  CHECK(cartesian->natural_to_cartesian_coordinates(std::array<double,3> {{1,2,3}}) == std::array<double,3> {{1,2,3}});
-
-  approval_tests.emplace_back(cartesian->natural_coordinate_system());
-
-  // distance between two points at the same depth
-  const Point<3> point_1(0.0,0.0,10.0, CoordinateSystem::cartesian);
-  const Point<3> point_2(1.0,2.0,10.0, CoordinateSystem::cartesian);
-  const Point<3> point_3(3.0,2.0,10.0, CoordinateSystem::cartesian);
-  const Point<3> point_4(3.0,3.0,10.0, CoordinateSystem::cartesian);
-
-  approval_tests.emplace_back(cartesian->distance_between_points_at_same_depth(point_1, point_2));
-  approval_tests.emplace_back(cartesian->distance_between_points_at_same_depth(point_2, point_3));
-  approval_tests.emplace_back(cartesian->distance_between_points_at_same_depth(point_2, point_4));
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder Coordinate Systems: Spherical")
-{
-  std::vector<double> approval_tests;
-
-  // TODO: make test where a cartesian wb file is loaded into a spherical coordinate system.
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_spherical.wb";
-
-  WorldBuilder::World world(file_name);
-
-  std::unique_ptr<CoordinateSystems::Interface> spherical(CoordinateSystems::Interface::create("spherical", &world));
-
-  world.parameters.enter_subsection("coordinate system");
-  {
-    world.parameters.enter_subsection("spherical");
-    {
-      spherical->declare_entries(world.parameters,"", {});
-    }
-    world.parameters.leave_subsection();
-  }
-  world.parameters.leave_subsection();
-
-  std::array<double,3> spherical_array = spherical->cartesian_to_natural_coordinates(std::array<double,3> {{1,2,3}});
-  approval_tests.emplace_back(spherical_array[0]);
-  approval_tests.emplace_back(spherical_array[1]);
-  approval_tests.emplace_back(spherical_array[2]);
-  std::array<double,3> cartesian_array = spherical->natural_to_cartesian_coordinates(std::array<double,3> {{std::sqrt(1.0 * 1.0 + 2.0 * 2.0 + 3.0 * 3.0),1.1071487178,0.9302740141}});
-  approval_tests.emplace_back(cartesian_array[0]);
-  approval_tests.emplace_back(cartesian_array[1]);
-  approval_tests.emplace_back(cartesian_array[2]);
-
-  approval_tests.emplace_back(spherical->natural_coordinate_system());
-
-  // distance between two points at the same depth
-  const double dtr = Consts::PI / 180.0;
-  // first check unit radius, this the central angle
-  const Point<3> unit_point_1(1.0, 0.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> unit_point_2(1.0, 1.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> unit_point_3(1.0, 0.0 * dtr, 1.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> unit_point_4(1.0, 1.0 * dtr, 1.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> unit_point_5(1.0, 90.0 * dtr, 90.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> unit_point_6(1.0, -90.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> unit_point_7(1.0, 90.0 * dtr, 180.0 * dtr, CoordinateSystem::spherical);
-
-  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(unit_point_1, unit_point_2));
-  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(unit_point_1, unit_point_3));
-  CHECK(spherical->distance_between_points_at_same_depth(unit_point_1, unit_point_4) ==
-        Approx(std::acos(std::sin(0) * std::sin(1*dtr) +
-                         std::cos(0) * std::cos(1*dtr) * std::cos(1*dtr))));
-  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(unit_point_1, unit_point_5));
-  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(unit_point_6, unit_point_7));
-
-  // secondly check non-unit radius
-  const Point<3> point_1(10.0, 0.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> point_2(10.0, 1.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> point_3(10.0, 0.0 * dtr, 1.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> point_4(10.0, 1.0 * dtr, 1.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> point_5(10.0, 90.0 * dtr, 90.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> point_6(10.0, -90.0 * dtr, 0.0 * dtr, CoordinateSystem::spherical);
-  const Point<3> point_7(10.0, 90.0 * dtr, 180.0 * dtr, CoordinateSystem::spherical);
-
-  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(point_1, point_2));
-  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(point_1, point_3));
-  CHECK(spherical->distance_between_points_at_same_depth(point_1, point_4) ==
-        Approx(10 * std::acos(std::sin(0) * std::sin(1*dtr) +
-                              std::cos(0) * std::cos(1*dtr) * std::cos(1*dtr))));
-  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(point_1, point_5));
-  approval_tests.emplace_back(spherical->distance_between_points_at_same_depth(point_6, point_7));
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder Features: Interface")
-{
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb1.json";
-
-  WorldBuilder::World world(file_name);
-  CHECK_THROWS_WITH(Features::Interface::create("!not_implemented_feature!", &world),
-                    Contains("Internal error: Plugin with name '!not_implemented_feature!' is not found. "
-                             "The size of factories is "));
-
-  const std::unique_ptr<Features::Interface> interface = Features::Interface::create("continental plate", &world);
-
-}
-
-TEST_CASE("WorldBuilder Features: Distance to Feature Plane")
-{
-  std::vector<double> approval_tests;
-
-  //  call the distance_to_plane to a subducting plate feature,
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_constant_angles_cartesian.wb";
-  WorldBuilder::World world1(file_name);
-  {
-    std::unique_ptr<Features::Interface> subducting_plate = Features::Interface::create("Subducting Plate", &world1);
-
-    world1.parameters.enter_subsection("features");
-    world1.parameters.enter_subsection("2");
-    subducting_plate->parse_entries(world1.parameters);
-    world1.parameters.leave_subsection();
-    world1.parameters.leave_subsection();
-    const std::array<double, 3> point1 = {{250e3,495e3,800e3}};
-    const double depth1 = 5.1e3;
-    auto plane_distances1 = world1.distance_to_plane(point1, depth1, "First subducting plate");
-    approval_tests.emplace_back(plane_distances1.get_distance_from_surface());
-    approval_tests.emplace_back(plane_distances1.get_distance_along_surface());
-    const std::array<double, 3> point2 = {{502e3,500e3,800e3}};
-    const double depth2 = 0.45e3;
-    auto plane_distances2 = world1.distance_to_plane(point2, depth2, "First subducting plate");
-    approval_tests.emplace_back(plane_distances2.get_distance_from_surface());
-    approval_tests.emplace_back(plane_distances2.get_distance_along_surface());
-    const std::array<double, 3> point3 = {{502e3,500e3,800e3}}; // point 3, shallower than point2, thus distance from plane = inf
-    const double depth3 = 0.43e3;
-    auto plane_distances3 = world1.distance_to_plane(point3, depth3, "First subducting plate");
-    approval_tests.emplace_back(plane_distances3.get_distance_from_surface());
-    approval_tests.emplace_back(plane_distances3.get_distance_along_surface());
-
-  }
-
-  // call the distance_to_plane to a fault feature.
-  const std::string file_name2 = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_constant_angles_cartesian.wb";
-  WorldBuilder::World world2(file_name2);
-  {
-    std::unique_ptr<Features::Interface> fault = Features::Interface::create("Fault", &world2);
-
-    world2.parameters.enter_subsection("features");
-    world2.parameters.enter_subsection("2");
-    fault->parse_entries(world2.parameters);
-    world2.parameters.leave_subsection();
-    world2.parameters.leave_subsection();
-    const std::array<double, 3> point1 = {{250e3,495e3,800e3}};
-    const double depth1 = 5.1e3;
-    auto plane_distances1 = world2.distance_to_plane(point1, depth1, "First fault");
-    approval_tests.emplace_back(plane_distances1.get_distance_from_surface());
-    approval_tests.emplace_back(plane_distances1.get_distance_along_surface());
-    const std::array<double, 3> point2 = {{502e3,500e3,800e3}};
-    const double depth2 = 0.45e3;
-    auto plane_distances2 = world2.distance_to_plane(point2, depth2, "First fault");
-    approval_tests.emplace_back(plane_distances2.get_distance_from_surface());
-    approval_tests.emplace_back(plane_distances2.get_distance_along_surface());
-    const std::array<double, 3> point3 = {{502e3,500e3,800e3}}; // point 3, shallower than point2, thus distance from plane = inf
-    const double depth3 = 0.43e3;
-    auto plane_distances3 = world2.distance_to_plane(point3, depth3, "First fault");
-    approval_tests.emplace_back(plane_distances3.get_distance_from_surface());
-    approval_tests.emplace_back(plane_distances3.get_distance_along_surface());
-
-    ApprovalTests::Approvals::verifyAll("Test", approval_tests);
-  }
-}
-
-
-TEST_CASE("WorldBuilder Features: Continental Plate")
-{
-  std::vector<double> approval_tests;
-  std::vector<grains> approval_tests_grains;
-
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/continental_plate.wb";
-  WorldBuilder::World world1(file_name);
-
-  // Check continental plate directly
-  {
-    std::unique_ptr<Features::Interface> continental_plate = Features::Interface::create("continental plate", &world1);
-
-    world1.parameters.enter_subsection("features");
-    world1.parameters.enter_subsection("2");
-    continental_plate->parse_entries(world1.parameters);
-    world1.parameters.leave_subsection();
-    world1.parameters.leave_subsection();
-    auto point = Point<3>(250e3,750e3,400e3,cartesian);
-    std::vector<double> vector(1,0.);
-    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
-    CHECK_THROWS_WITH(continental_plate->properties(point,nat_coord,10e3, {{{5,0,0}}},10, {0},vector),
-    Contains("Internal error: Unimplemented property provided"));
-  }
-
-  // Check continental plate through the world
-  std::array<double,3> position = {{0,0,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-
-  // the feature with composition 3
-  position = {{250e3,500e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 74e3));
-  approval_tests.emplace_back(world1.temperature(position, 76e3));
-  approval_tests.emplace_back(world1.temperature(position, 149e3));
-  approval_tests.emplace_back(world1.temperature(position, 151e3));
-  approval_tests.emplace_back(world1.temperature(position, 224e3));
-  approval_tests.emplace_back(world1.temperature(position, 226e3));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
-
-  // check grains
-  {
-    const WorldBuilder::grains grains = world1.grains(position, 0, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  // the feature with composition 2
-  position = {{1500e3,1500e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
-
-  // check grains
-  {
-    const WorldBuilder::grains grains = world1.grains(position, 0, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{250e3,1750e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
-
-  position = {{750e3,250e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
-
-  // check grains layer 1
-  {
-    const WorldBuilder::grains grains = world1.grains(position, 0, 0, 2);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  // check grains layer 2
-  {
-    const WorldBuilder::grains grains = world1.grains(position, 150e3, 0, 2);
-    approval_tests_grains.emplace_back(grains);
-
-  }
-
-  // the constant layers test
-  position = {{1500e3,250e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 1));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 249.5e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-  approval_tests.emplace_back(world1.composition(position, 0, 7));
-  approval_tests.emplace_back(world1.composition(position, 0, 8));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 0));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 1));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 2));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 3));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 4));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 5));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 6));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 7));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 8));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 0));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 5));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 6));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 7));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 8));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 0));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 1));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 2));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 3));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 4));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 5));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 6));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 7));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 8));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 0));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 5));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 6));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 7));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 8));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 8));
-
-
-  std::vector<std::string> approvals;
-  for (auto&& value : approval_tests)
-    {
-      std::stringstream s;
-      s << value;
-      approvals.emplace_back(s.str());
-    }
-  for (auto&& value : approval_tests_grains)
-    {
-      std::stringstream s;
-      s << value;
-      approvals.emplace_back(s.str());
-    }
-  ApprovalTests::Approvals::verifyAll("Test", approvals);
-}
-
-TEST_CASE("WorldBuilder Features: Mantle layer")
-{
-  std::vector<double> approval_tests;
-  std::vector<grains> approval_tests_grains;
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/mantle_layer_cartesian.wb";
-  WorldBuilder::World world1(file_name);
-
-  // Check mantle layer directly
-  {
-    std::unique_ptr<Features::Interface> mantle_layer = Features::Interface::create("mantle layer", &world1);
-
-    world1.parameters.enter_subsection("features");
-    world1.parameters.enter_subsection("2");
-    mantle_layer->parse_entries(world1.parameters);
-    world1.parameters.leave_subsection();
-    world1.parameters.leave_subsection();
-    auto point = Point<3>(250e3,750e3,400e3,cartesian);
-    std::vector<double> vector(1,0.);
-    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
-    CHECK_THROWS_WITH(mantle_layer->properties(point,nat_coord,260e3, {{{5,0,0}}},10, {0},vector),
-    Contains("Internal error: Unimplemented property provided"));
-  }
-  // Check continental plate through the world
-  std::array<double,3> position = {{0,0,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-
-  position = {{250e3,501e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0+100e3));
-  approval_tests.emplace_back(world1.temperature(position, 240e3+100e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3+100e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0+200e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 0+200e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 0+200e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 0+200e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 0+200e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 0+200e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3+200e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3+200e3, 5));
-
-  // check grains
-  {
-    const WorldBuilder::grains grains = world1.grains(position, 200e3, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{1500e3,1500e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0+150e3));
-  approval_tests.emplace_back(world1.temperature(position, 240e3+150e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3+150e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0+150e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 0+150e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 0+150e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 0+150e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 0+150e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 0+150e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3+150e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3+150e3, 5));
-
-  // check grains
-  {
-    const WorldBuilder::grains grains = world1.grains(position, 150e3, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{250e3,1750e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0+250e3));
-  approval_tests.emplace_back(world1.temperature(position, 240e3+250e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3+250e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0+250e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 0+250e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 0+250e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 0+250e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 0+250e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 0+250e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3+250e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3+250e3, 5));
-
-  position = {{750e3,250e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0+300e3));
-  approval_tests.emplace_back(world1.temperature(position, 95e3+300e3));
-  approval_tests.emplace_back(world1.temperature(position, 105e3+300e3));
-  approval_tests.emplace_back(world1.temperature(position, 145e3+300e3));
-  approval_tests.emplace_back(world1.temperature(position, 155e3+300e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3+300e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0+300e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 0+300e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 0+300e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 0+300e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 0+300e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 0+300e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 0+300e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3+300e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3+300e3, 5));
-
-  // check grains layer 1
-  {
-    const WorldBuilder::grains grains = world1.grains(position, 0+300e3, 0, 2);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  // check grains layer 2
-  {
-    const WorldBuilder::grains grains = world1.grains(position, 150e3+300e3, 0, 2);
-    approval_tests_grains.emplace_back(grains);
-
-  }
-
-  // the constant layers test
-  position = {{1500e3,250e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0+350e3));
-  approval_tests.emplace_back(world1.temperature(position, 240e3+350e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3+350e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 0+350e3, 9));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1+350e3, 9));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1+350e3, 9));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1+350e3, 9));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1+350e3, 9));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 240e3+350e3, 9));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 260e3+350e3, 9));
-
-  std::vector<std::string> approvals;
-  for (auto&& value : approval_tests)
-    {
-      std::stringstream s;
-      s << value;
-      approvals.emplace_back(s.str());
-    }
-  for (auto&& value : approval_tests_grains)
-    {
-      std::stringstream s;
-      s << value;
-      approvals.emplace_back(s.str());
-    }
-  ApprovalTests::Approvals::verifyAll("Test", approvals);
-}
-
-TEST_CASE("WorldBuilder Features: Oceanic Plate")
-{
-  std::vector<double> approval_tests;
-  std::vector<grains> approval_tests_grains;
-
-  // Cartesian
-  std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_cartesian.wb";
-  WorldBuilder::World world1(file_name);
-
-  // Check continental plate directly
-  {
-    std::unique_ptr<Features::Interface> oceanic_plate = Features::Interface::create("oceanic plate", &world1);
-
-    world1.parameters.enter_subsection("features");
-    world1.parameters.enter_subsection("2");
-    oceanic_plate->parse_entries(world1.parameters);
-    world1.parameters.leave_subsection();
-    world1.parameters.leave_subsection();
-    auto point = Point<3>(250e3,750e3,400e3,cartesian);
-    std::vector<double> vector(1,0.);
-    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
-    CHECK_THROWS_WITH(oceanic_plate->properties(point,nat_coord,10e3, {{{5,0,0}}},10, {0},vector),
-    Contains("Internal error: Unimplemented property provided"));
-  }
-
-  // Check continental plate through the world
-  // 2d
-  std::array<double,2> position_2d = {{0,0}};
-  approval_tests.emplace_back(world1.temperature(position_2d, 0));
-  approval_tests.emplace_back(world1.temperature(position_2d, 240e3));
-  approval_tests.emplace_back(world1.temperature(position_2d, 260e3));
-  approval_tests.emplace_back(world1.composition(position_2d, 0, 0));
-  approval_tests.emplace_back(world1.composition(position_2d, 0, 1));
-  approval_tests.emplace_back(world1.composition(position_2d, 0, 2));
-  approval_tests.emplace_back(world1.composition(position_2d, 0, 3));
-  approval_tests.emplace_back(world1.composition(position_2d, 0, 4));
-  approval_tests.emplace_back(world1.composition(position_2d, 0, 5));
-  approval_tests.emplace_back(world1.composition(position_2d, 0, 6));
-  // 3d
-  std::array<double,3> position = {{0,0,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  position = {{250e3,500e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  position = {{1500e3,1500e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  position = {{250e3,1750e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  position = {{750e3,250e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 195e3));
-  approval_tests.emplace_back(world1.temperature(position, 205e3));
-  approval_tests.emplace_back(world1.temperature(position, 247e3));
-  approval_tests.emplace_back(world1.temperature(position, 249e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 6));
-
-  position = {{1500e3, 0, 0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  // test symmetry
-  position = {{1600e3, 0, 0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-
-  position = {{1400e3, 0, 0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-
-  // the constant layers test
-  position = {{200e3,200e3,0}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-  approval_tests.emplace_back(world1.composition(position, 0, 7));
-  approval_tests.emplace_back(world1.composition(position, 0, 8));
-  approval_tests.emplace_back(world1.composition(position, 0, 9));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 0));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 1));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 2));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 3));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 4));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 5));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 6));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 7));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 8));
-  approval_tests.emplace_back(world1.composition(position, 75e3-1, 9));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 0));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 5));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 6));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 7));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 8));
-  approval_tests.emplace_back(world1.composition(position, 75e3+1, 9));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 0));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 1));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 2));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 3));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 4));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 5));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 6));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 7));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 8));
-  approval_tests.emplace_back(world1.composition(position, 150e3-1, 9));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 0));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 5));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 6));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 7));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 8));
-  approval_tests.emplace_back(world1.composition(position, 150e3+1, 9));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 240e3, 9));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 5));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 6));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 7));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 8));
-  approval_tests.emplace_back(world1.composition(position, 260e3, 9));
-
-  // spherical
-  file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/oceanic_plate_spherical.wb";
-  WorldBuilder::World world2(file_name);
-
-  // Check continental plate directly
-  const std::unique_ptr<Features::Interface> oceanic_plate = Features::Interface::create("oceanic plate", &world2);
-
-  // Check continental plate through the world
-  const double dtr = Consts::PI / 180.0;
-  std::unique_ptr<WorldBuilder::CoordinateSystems::Interface> &coordinate_system = world2.parameters.coordinate_system;
-
-  // 2d
-  position_2d = {{6371000,0}};
-  approval_tests.emplace_back(world2.temperature(position_2d, 0));
-  approval_tests.emplace_back(world2.composition(position_2d, 0, 0));
-  approval_tests.emplace_back(world2.composition(position_2d, 0, 1));
-  approval_tests.emplace_back(world2.composition(position_2d, 0, 2));
-  approval_tests.emplace_back(world2.composition(position_2d, 0, 3));
-  approval_tests.emplace_back(world2.composition(position_2d, 0, 4));
-  approval_tests.emplace_back(world2.composition(position_2d, 0, 5));
-  approval_tests.emplace_back(world2.composition(position_2d, 0, 6));
-
-  // 3d
-  position = {{6371000,0,0}};
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 2));
-  approval_tests.emplace_back(world2.composition(position, 0, 3));
-  approval_tests.emplace_back(world2.composition(position, 0, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 5));
-  approval_tests.emplace_back(world2.composition(position, 0, 6));
-
-  position = {{6371000, -5 * dtr,-5 * dtr}};
-  position = coordinate_system->natural_to_cartesian_coordinates(position);
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 240e3));
-  approval_tests.emplace_back(world2.temperature(position, 260e3));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 2));
-  approval_tests.emplace_back(world2.composition(position, 0, 3));
-  approval_tests.emplace_back(world2.composition(position, 0, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 5));
-  approval_tests.emplace_back(world2.composition(position, 0, 6));
-
-  position = {{6371000, 5 * dtr,-5 * dtr}};
-  position = coordinate_system->natural_to_cartesian_coordinates(position);
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 240e3));
-  approval_tests.emplace_back(world2.temperature(position, 260e3));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 2));
-  approval_tests.emplace_back(world2.composition(position, 240e3, 2));
-  approval_tests.emplace_back(world2.composition(position, 260e3, 2));
-  approval_tests.emplace_back(world2.composition(position, 0, 3));
-  approval_tests.emplace_back(world2.composition(position, 0, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 5));
-  approval_tests.emplace_back(world2.composition(position, 0, 6));
-
-  // check grains
-  {
-    const WorldBuilder::grains grains = world2.grains(position, 240e3, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{6371000, 5 * dtr,5 * dtr}};
-  position = coordinate_system->natural_to_cartesian_coordinates(position);
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 240e3));
-  approval_tests.emplace_back(world2.temperature(position, 260e3));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 2));
-  approval_tests.emplace_back(world2.composition(position, 0, 3));
-  approval_tests.emplace_back(world2.composition(position, 0, 4));
-  approval_tests.emplace_back(world2.composition(position, 240e3, 4));
-  approval_tests.emplace_back(world2.composition(position, 260e3, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 5));
-  approval_tests.emplace_back(world2.composition(position, 0, 6));
-
-  // check grains
-  {
-    const WorldBuilder::grains grains = world2.grains(position, 240e3, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{6371000, -15 * dtr, -15 * dtr}};
-  position = coordinate_system->natural_to_cartesian_coordinates(position);
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 240e3));
-  approval_tests.emplace_back(world2.temperature(position, 260e3));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 2));
-  approval_tests.emplace_back(world2.composition(position, 0, 3));
-  approval_tests.emplace_back(world2.composition(position, 0, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 5));
-  approval_tests.emplace_back(world2.composition(position, 0, 6));
-  approval_tests.emplace_back(world2.composition(position, 240e3, 5));
-  approval_tests.emplace_back(world2.composition(position, 240e3, 6));
-  approval_tests.emplace_back(world2.composition(position, 260e3, 5));
-  approval_tests.emplace_back(world2.composition(position, 260e3, 6));
-
-  // check grains layer 1
-  {
-    const WorldBuilder::grains grains = world2.grains(position, 0, 0, 2);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  // check grains layer 2
-  {
-    const WorldBuilder::grains grains = world2.grains(position, 150e3, 0, 2);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{6371000, 15 * dtr, -19 * dtr}};
-  position = coordinate_system->natural_to_cartesian_coordinates(position);
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 10));
-  approval_tests.emplace_back(world2.temperature(position, 240e3));
-  approval_tests.emplace_back(world2.temperature(position, 260e3));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 2));
-  approval_tests.emplace_back(world2.composition(position, 0, 3));
-  approval_tests.emplace_back(world2.composition(position, 0, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 5));
-  approval_tests.emplace_back(world2.composition(position, 0, 6));
-  approval_tests.emplace_back(world2.composition(position, 240e3, 6));
-  approval_tests.emplace_back(world2.composition(position, 260e3, 6));
-
-  // test symmetry
-  position = {{6371000, 16 * dtr, -19 * dtr}};
-  position = coordinate_system->natural_to_cartesian_coordinates(position);
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 10));
-  approval_tests.emplace_back(world2.temperature(position, 240e3));
-  approval_tests.emplace_back(world2.temperature(position, 260e3));
-
-  position = {{6371000, 14 * dtr, -19 * dtr}};
-  position = coordinate_system->natural_to_cartesian_coordinates(position);
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 10));
-  approval_tests.emplace_back(world2.temperature(position, 240e3));
-  approval_tests.emplace_back(world2.temperature(position, 260e3));
-
-  // test bend
-  position = {{6371000, 12.5 * dtr, -12.5 * dtr}};
-  position = coordinate_system->natural_to_cartesian_coordinates(position);
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 10));
-  approval_tests.emplace_back(world2.temperature(position, 240e3));
-  approval_tests.emplace_back(world2.temperature(position, 260e3));
-
-  std::vector<std::string> approvals;
-  for (auto&& value : approval_tests)
-    {
-      std::stringstream s;
-      s << value;
-      approvals.emplace_back(s.str());
-    }
-  for (auto&& value : approval_tests_grains)
-    {
-      std::stringstream s;
-      s << value;
-      approvals.emplace_back(s.str());
-    }
-  ApprovalTests::Approvals::verifyAll("Test", approvals);
-}
-
-TEST_CASE("WorldBuilder Features: Subducting Plate")
-{
-  std::vector<double> approval_tests;
-  std::vector<grains> approval_tests_grains;
-
-  // Cartesian
-  std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_constant_angles_cartesian.wb";
-  WorldBuilder::World world1(file_name);
-
-  // Check continental plate directly (upper case should automatically turn into lower case).
-  {
-    std::unique_ptr<Features::Interface> subducting_plate = Features::Interface::create("Subducting Plate", &world1);
-
-    world1.parameters.enter_subsection("features");
-    world1.parameters.enter_subsection("2");
-    subducting_plate->parse_entries(world1.parameters);
-    world1.parameters.leave_subsection();
-    world1.parameters.leave_subsection();
-    auto point = Point<3>(250e3,490e3,800e3,cartesian);
-    std::vector<double> vector(1,0.);
-    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
-    CHECK_THROWS_WITH(subducting_plate->properties(point,nat_coord,100000, {{{5,0,0}}},10, {0},vector),
-    Contains("Internal error: Unimplemented property provided"));
-  }
-  // Check continental plate through the world
-  std::array<double,3> position = {{0,0,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 240e3));
-  approval_tests.emplace_back(world1.temperature(position, 260e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-
-  position = {{0,150e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 1));
-  approval_tests.emplace_back(world1.temperature(position, 5));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100));
-  approval_tests.emplace_back(world1.temperature(position, 500));
-  approval_tests.emplace_back(world1.temperature(position, 1000));
-  approval_tests.emplace_back(world1.temperature(position, 5000));
-  approval_tests.emplace_back(world1.temperature(position, 10e3));
-  approval_tests.emplace_back(world1.temperature(position, 25e3));
-  approval_tests.emplace_back(world1.temperature(position, 50e3));
-  approval_tests.emplace_back(world1.temperature(position, 75e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 175e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-
-
-  position = {{10e3,150e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 1));
-  approval_tests.emplace_back(world1.temperature(position, 5));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100));
-  approval_tests.emplace_back(world1.temperature(position, 500));
-  approval_tests.emplace_back(world1.temperature(position, 1000));
-  approval_tests.emplace_back(world1.temperature(position, 5000));
-  approval_tests.emplace_back(world1.temperature(position, 10e3));
-  approval_tests.emplace_back(world1.temperature(position, 25e3));
-  approval_tests.emplace_back(world1.temperature(position, 50e3));
-  approval_tests.emplace_back(world1.temperature(position, 75e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 175e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-
-  position = {{0,160e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 1));
-  approval_tests.emplace_back(world1.temperature(position, 5));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100));
-  approval_tests.emplace_back(world1.temperature(position, 500));
-  approval_tests.emplace_back(world1.temperature(position, 1000));
-  approval_tests.emplace_back(world1.temperature(position, 5000));
-  approval_tests.emplace_back(world1.temperature(position, 10e3));
-  approval_tests.emplace_back(world1.temperature(position, 25e3));
-  approval_tests.emplace_back(world1.temperature(position, 50e3));
-  approval_tests.emplace_back(world1.temperature(position, 75e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 175e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-
-
-  position = {{750e3,175e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 1));
-  approval_tests.emplace_back(world1.temperature(position, 5));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100));
-  approval_tests.emplace_back(world1.temperature(position, 500));
-  approval_tests.emplace_back(world1.temperature(position, 1000));
-  approval_tests.emplace_back(world1.temperature(position, 5000));
-  approval_tests.emplace_back(world1.temperature(position, 10e3));
-  approval_tests.emplace_back(world1.temperature(position, 25e3));
-  approval_tests.emplace_back(world1.temperature(position, 50e3));
-  approval_tests.emplace_back(world1.temperature(position, 75e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 175e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-
-  //position = {{250e3,450e3,800e3}};
-  //approval_tests.emplace_back(world1.temperature(position, 0));
-  //approval_tests.emplace_back(world1.temperature(position, 1)); // we are in the plate for sure (colder than anywhere in the mantle)
-  //approval_tests.emplace_back(world1.temperature(position, 5)); // we are in the plate for sure (colder than anywhere in the mantle)
-  //approval_tests.emplace_back(world1.temperature(position, 10)); // we are in the plate for sure (colder than anywhere in the mantle)
-  //approval_tests.emplace_back(world1.temperature(position, 100)); // we are in the plate for sure (colder than anywhere in the mantle)
-  //approval_tests.emplace_back(world1.temperature(position, 500)); // we are in the plate for sure (colder than anywhere in the mantle)
-  //approval_tests.emplace_back(world1.temperature(position, 1000)); // we are in the plate for sure (colder than anywhere in the mantle)
-  //approval_tests.emplace_back(world1.temperature(position, 5000)); // we are in the plate for sure (colder than anywhere in the mantle)
-  //approval_tests.emplace_back(world1.temperature(position, 10e3));
-  //approval_tests.emplace_back(world1.temperature(position, 25e3));
-  //approval_tests.emplace_back(world1.temperature(position, 50e3));
-  //approval_tests.emplace_back(world1.temperature(position, 75e3));
-  //approval_tests.emplace_back(world1.temperature(position, 150e3));
-
-  position = {{250e3,488.750e3,800e3}};
-  position = {{250e3,500e3,800e3}};
-  // results strongly dependent on the summation number of the McKenzie temperature.
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 1));
-  approval_tests.emplace_back(world1.temperature(position, 5));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100));
-  approval_tests.emplace_back(world1.temperature(position, 500)); // we are in the plate for sure (colder than anywhere in the mantle)
-  approval_tests.emplace_back(world1.temperature(position, 1000)); // we are in the plate for sure (colder than anywhere in the mantle)
-  approval_tests.emplace_back(world1.temperature(position, 5000)); // we are in the plate for sure (colder than anywhere in the mantle)
-  approval_tests.emplace_back(world1.temperature(position, 10e3));
-  approval_tests.emplace_back(world1.temperature(position, 25e3));
-  approval_tests.emplace_back(world1.temperature(position, 50e3));
-  approval_tests.emplace_back(world1.temperature(position, 75e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  //approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 100e3 - 1));
-  //approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 100e3 + 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 10, 0));
-  approval_tests.emplace_back(world1.composition(position, 10, 1));
-  approval_tests.emplace_back(world1.composition(position, 10, 2));
-  approval_tests.emplace_back(world1.composition(position, 10, 3));
-  approval_tests.emplace_back(world1.composition(position, 10, 4));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 - 1, 0));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 + 1, 0));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 - 1, 1));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 + 1, 1));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 - 1, 1));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 + 1, 1));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 - 1, 2));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 + 1, 2));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 + 1, 3));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 - 1, 2));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 - 1, 3));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 + 1, 2));
-  // this comes form the first subducting plate
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 + 1, 3));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 100e3 - 1, 3));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 100e3 + 1, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  // check grains layer 1
-  {
-    WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 33e3 - 5e3, 0, 2);
-    // these are random numbers, but they should stay the same.
-    // note that the values are different from for example the continental plate since
-    // this performs a interpolation between segments of the slab.
-    approval_tests_grains.emplace_back(grains);
-
-    grains = world1.grains(position, std::sqrt(2) * 33e3 - 5e3, 1, 2);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  // check grains layer 2
-  {
-    const WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 66e3 - 1, 0, 2);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{250e3,550e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 45e3));
-  approval_tests.emplace_back(world1.temperature(position, 50e3-1));
-  approval_tests.emplace_back(world1.temperature(position, 50e3+1));
-  approval_tests.emplace_back(world1.temperature(position, 55e3));
-  approval_tests.emplace_back(world1.temperature(position, 100e3-1));
-  approval_tests.emplace_back(world1.temperature(position, 100e3+1));
-  approval_tests.emplace_back(world1.temperature(position, 101e3));
-  approval_tests.emplace_back(world1.temperature(position, 110e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 155e3));
-  approval_tests.emplace_back(world1.temperature(position, 175e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-  approval_tests.emplace_back(world1.temperature(position, 250e3));
-  approval_tests.emplace_back(world1.temperature(position, 300e3));
-
-  position = {{250e3,600e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 45e3));
-  approval_tests.emplace_back(world1.temperature(position, 50e3-1));
-  approval_tests.emplace_back(world1.temperature(position, 50e3+1));
-  approval_tests.emplace_back(world1.temperature(position, 55e3));
-  approval_tests.emplace_back(world1.temperature(position, 100e3-1));
-  approval_tests.emplace_back(world1.temperature(position, 100e3+1));
-  approval_tests.emplace_back(world1.temperature(position, 101e3));
-  approval_tests.emplace_back(world1.temperature(position, 110e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 155e3));
-  approval_tests.emplace_back(world1.temperature(position, 160e3));
-  approval_tests.emplace_back(world1.temperature(position, 165e3));
-  approval_tests.emplace_back(world1.temperature(position, 170e3));
-  approval_tests.emplace_back(world1.temperature(position, 175e3));
-  approval_tests.emplace_back(world1.temperature(position, 180e3));
-  approval_tests.emplace_back(world1.temperature(position, 185e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-  approval_tests.emplace_back(world1.temperature(position, 250e3));
-  approval_tests.emplace_back(world1.temperature(position, 300e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 10, 0));
-  approval_tests.emplace_back(world1.composition(position, 10, 1));
-  approval_tests.emplace_back(world1.composition(position, 10, 2));
-  approval_tests.emplace_back(world1.composition(position, 10, 3));
-  approval_tests.emplace_back(world1.composition(position, 100e3-1, 0));
-  approval_tests.emplace_back(world1.composition(position, 100e3-1, 1));
-  approval_tests.emplace_back(world1.composition(position, 100e3-1, 2));
-  approval_tests.emplace_back(world1.composition(position, 100e3-1, 3));
-  approval_tests.emplace_back(world1.composition(position, 100e3-1, 4));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 0));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 101e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  position = {{650e3,650e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100e3));
-  approval_tests.emplace_back(world1.temperature(position, 100e3+1));
-  approval_tests.emplace_back(world1.temperature(position, 101e3));
-  approval_tests.emplace_back(world1.temperature(position, 110e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 10, 0));
-  approval_tests.emplace_back(world1.composition(position, 10, 1));
-  approval_tests.emplace_back(world1.composition(position, 10, 2));
-  approval_tests.emplace_back(world1.composition(position, 10, 3));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 0));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 101e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  position = {{700e3,675e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100e3));
-  approval_tests.emplace_back(world1.temperature(position, 100e3+1));
-  approval_tests.emplace_back(world1.temperature(position, 101e3));
-  approval_tests.emplace_back(world1.temperature(position, 110e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 10, 0));
-  approval_tests.emplace_back(world1.composition(position, 10, 1));
-  approval_tests.emplace_back(world1.composition(position, 10, 2));
-  approval_tests.emplace_back(world1.composition(position, 10, 3));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 100e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 0));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 100e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 101e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 1));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 2));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 3));
-  approval_tests.emplace_back(world1.composition(position, 101e3+1, 4));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 150e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 0));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 1));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 2));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 3));
-  approval_tests.emplace_back(world1.composition(position, 200e3, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  position = {{700e3,155e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-  approval_tests.emplace_back(world1.temperature(position, 250e3));
-  approval_tests.emplace_back(world1.temperature(position, 300e3));
-
-  // check grains
-  {
-    {
-      // layer 1
-      const WorldBuilder::grains grains = world1.grains(position, 80e3, 0, 3);
-      approval_tests_grains.emplace_back(grains);
-    }
-
-    {
-      // layer 2
-      const WorldBuilder::grains grains = world1.grains(position, 100e3, 0, 3);
-      approval_tests_grains.emplace_back(grains);
-    }
-
-    {
-      // layer 3
-      const WorldBuilder::grains grains = world1.grains(position, 250e3, 0, 3);
-      approval_tests_grains.emplace_back(grains);
-    }
-  }
-
-
-  const std::string file_name2 = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian.wb";
-  const WorldBuilder::World world2(file_name2);
-
-  position = {{250e3,500e3,800e3}};
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.temperature(position, 1));
-  approval_tests.emplace_back(world2.composition(position, 1, 0));
-  approval_tests.emplace_back(world2.temperature(position, 1e3));
-  approval_tests.emplace_back(world2.composition(position, 1e3, 0));
-  approval_tests.emplace_back(world2.temperature(position, 10e3));
-  approval_tests.emplace_back(world2.composition(position, 10e3, 0));
-  approval_tests.emplace_back(world2.temperature(position, 20e3));
-  approval_tests.emplace_back(world2.composition(position, 20e3, 0));
-  approval_tests.emplace_back(world2.temperature(position, 40e3));
-  approval_tests.emplace_back(world2.composition(position, 40e3, 0));
-  approval_tests.emplace_back(world2.temperature(position, 60e3));
-  approval_tests.emplace_back(world2.composition(position, 60e3, 0));
-  approval_tests.emplace_back(world2.temperature(position, 80e3));
-  approval_tests.emplace_back(world2.composition(position, 80e3, 0));
-  approval_tests.emplace_back(world2.temperature(position, 100e3));
-  approval_tests.emplace_back(world2.composition(position, 100e3, 0));
-
-
-  file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian_2.wb";
-  const WorldBuilder::World world4(file_name);
-
-  position = {{250e3,500e3,800e3}};
-  approval_tests.emplace_back(world4.temperature(position, 0));
-  approval_tests.emplace_back(world4.composition(position, 0, 0));
-  approval_tests.emplace_back(world4.composition(position, 0, 1));
-  approval_tests.emplace_back(world4.composition(position, 0, 2));
-  approval_tests.emplace_back(world4.composition(position, 0, 3));
-  approval_tests.emplace_back(world4.temperature(position, 1));
-  approval_tests.emplace_back(world4.composition(position, 1, 0));
-  approval_tests.emplace_back(world4.composition(position, 1, 1));
-  approval_tests.emplace_back(world4.composition(position, 1, 2));
-  approval_tests.emplace_back(world4.composition(position, 1, 3));
-  approval_tests.emplace_back(world4.temperature(position, 1e3));
-  approval_tests.emplace_back(world4.composition(position, 1e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 1e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 1e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 1e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 10e3));
-  approval_tests.emplace_back(world4.composition(position, 10e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 10e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 10e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 10e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 20e3));
-  approval_tests.emplace_back(world4.composition(position, 20e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 20e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 20e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 20e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 30e3));
-  approval_tests.emplace_back(world4.composition(position, 30e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 30e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 30e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 30e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 35e3));
-  approval_tests.emplace_back(world4.composition(position, 35e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 35e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 35e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 35e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 40e3));
-  approval_tests.emplace_back(world4.composition(position, 40e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 40e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 40e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 40e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 45e3));
-  approval_tests.emplace_back(world4.composition(position, 45e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 45e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 45e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 45e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 50e3));
-  approval_tests.emplace_back(world4.composition(position, 50e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 50e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 50e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 50e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 60e3));
-  approval_tests.emplace_back(world4.composition(position, 60e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 60e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 60e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 60e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 80e3));
-  approval_tests.emplace_back(world4.composition(position, 80e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 80e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 80e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 80e3, 3));
-  approval_tests.emplace_back(world4.temperature(position, 100e3));
-  approval_tests.emplace_back(world4.composition(position, 100e3, 0));
-  approval_tests.emplace_back(world4.composition(position, 100e3, 1));
-  approval_tests.emplace_back(world4.composition(position, 100e3, 2));
-  approval_tests.emplace_back(world4.composition(position, 100e3, 3));
-
-
-  std::vector<std::string> approvals;
-  for (auto&& value : approval_tests)
-    {
-      std::stringstream s;
-      s << value;
-      approvals.emplace_back(s.str());
-    }
-  for (auto&& value : approval_tests_grains)
-    {
-      std::stringstream s;
-      s << value;
-      approvals.emplace_back(s.str());
-    }
-  ApprovalTests::Approvals::verifyAll("Test", approvals);
-}
-
-TEST_CASE("WorldBuilder Features: Fault")
-{
-  std::vector<double> approval_tests;
-  std::vector<grains> approval_tests_grains;
-
-  // Cartesian
-  std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_constant_angles_cartesian.wb";
-  WorldBuilder::World world1(file_name);
-
-  // Check continental plate directly (upper case should automatically turn into lower case).
-  {
-    std::unique_ptr<Features::Interface> fault = Features::Interface::create("Fault", &world1);
-
-    world1.parameters.enter_subsection("features");
-    world1.parameters.enter_subsection("2");
-    fault->parse_entries(world1.parameters);
-    world1.parameters.leave_subsection();
-    world1.parameters.leave_subsection();
-    auto point = Point<3>(50e3,230e3,800e3,cartesian);
-    std::vector<double> vector(1,0.);
-    auto nat_coord = Objects::NaturalCoordinate(point,*(world1.parameters.coordinate_system));
-    CHECK_THROWS_WITH(fault->properties(point,nat_coord,1000, {{{5,0,0}}},10, {0},vector),
-    Contains("Internal error: Unimplemented property provided"));
-  }
-
-  // Check fault plate through the world
-  std::array<double,3> position = {{0,0,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 220e3));
-  approval_tests.emplace_back(world1.temperature(position, 230e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  position = {{250e3,500e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 - 1));
-  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 + 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 10, 0));
-  approval_tests.emplace_back(world1.composition(position, 10, 1));
-  approval_tests.emplace_back(world1.composition(position, 10, 2));
-  approval_tests.emplace_back(world1.composition(position, 10, 3));
-  approval_tests.emplace_back(world1.composition(position, 10, 4));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 50e3 - 1, 3));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 50e3 - 1, 4));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 50e3 + 1, 3));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 50e3 + 1, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-  // check grains
-  {
-    WorldBuilder::grains grains = world1.grains(position, 10, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-
-    grains = world1.grains(position, 10, 1, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{50e3,230e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 1));
-  approval_tests.emplace_back(world1.temperature(position, 5));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100));
-  approval_tests.emplace_back(world1.temperature(position, 500));
-  approval_tests.emplace_back(world1.temperature(position, 1000));
-  approval_tests.emplace_back(world1.temperature(position, 5000));
-  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3/2));
-  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 - 1));
-  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 + 1));
-  approval_tests.emplace_back(world1.temperature(position, 25e3));
-  approval_tests.emplace_back(world1.temperature(position, 50e3));
-  approval_tests.emplace_back(world1.temperature(position, 75e3));
-  approval_tests.emplace_back(world1.temperature(position, 80e3));
-  approval_tests.emplace_back(world1.temperature(position, 90e3));
-  approval_tests.emplace_back(world1.temperature(position, 100e3));
-  approval_tests.emplace_back(world1.temperature(position, 150e3));
-  approval_tests.emplace_back(world1.temperature(position, 200e3));
-
-  position = {{250e3,250e3,800e3}};
-  approval_tests.emplace_back(world1.temperature(position, 0));
-  approval_tests.emplace_back(world1.temperature(position, 1));
-  approval_tests.emplace_back(world1.temperature(position, 5));
-  approval_tests.emplace_back(world1.temperature(position, 10));
-  approval_tests.emplace_back(world1.temperature(position, 100));
-  approval_tests.emplace_back(world1.temperature(position, 500));
-  approval_tests.emplace_back(world1.temperature(position, 1000));
-  approval_tests.emplace_back(world1.temperature(position, 5000));
-  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3/2));
-  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 - 1));
-  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 50e3 + 1));
-  approval_tests.emplace_back(world1.temperature(position, std::sqrt(2) * 51e3));
-  approval_tests.emplace_back(world1.composition(position, 0, 0));
-  approval_tests.emplace_back(world1.composition(position, 0, 1));
-  approval_tests.emplace_back(world1.composition(position, 0, 2));
-  approval_tests.emplace_back(world1.composition(position, 0, 3));
-  approval_tests.emplace_back(world1.composition(position, 10, 0));
-  approval_tests.emplace_back(world1.composition(position, 10, 1));
-  approval_tests.emplace_back(world1.composition(position, 10, 2));
-  approval_tests.emplace_back(world1.composition(position, 10, 3));
-
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 0));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 1));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 2));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 0));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 1));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 2));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 * 0.5 - 1, 1));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 66e3 * 0.5 + 1, 1));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 * 0.5 - 1, 2));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 * 0.5 + 1, 2));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 * 0.5 - 1, 3));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 99e3 * 0.5 + 1, 3));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 100e3 * 0.5 - 1, 3));
-  approval_tests.emplace_back(world1.composition(position, std::sqrt(2) * 100e3 * 0.5 + 1, 3));
-  approval_tests.emplace_back(world1.composition(position, 0, 4));
-  approval_tests.emplace_back(world1.composition(position, 0, 5));
-  approval_tests.emplace_back(world1.composition(position, 0, 6));
-
-
-  // check grains
-  {
-    {
-      // layer 1
-      WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 33e3 * 0.5 - 5e3, 0, 3);
-      approval_tests_grains.emplace_back(grains);
-
-      grains = world1.grains(position, std::sqrt(2) * 33e3 * 0.5 - 5e3, 1, 3);
-      approval_tests_grains.emplace_back(grains);
-    }
-
-    {
-      // layer 2
-      WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 33e3 * 0.5 + 1, 0, 3);
-      approval_tests_grains.emplace_back(grains);
-
-      grains = world1.grains(position, std::sqrt(2) * 33e3 * 0.5 + 1, 1, 3);
-      approval_tests_grains.emplace_back(grains);
-    }
-
-    {
-      // layer 3
-      const WorldBuilder::grains grains = world1.grains(position, std::sqrt(2) * 99e3 * 0.5 - 5e3, 0, 3);
-      approval_tests_grains.emplace_back(grains);
-    }
-  }
-
-
-  position = {{250e3,250e3,800e3}};
-  approval_tests.emplace_back(world1.composition(position, 1, 0));
-  approval_tests.emplace_back(world1.composition(position, 1, 1));
-  approval_tests.emplace_back(world1.composition(position, 1, 2));
-  position = {{250e3,250e3-std::sqrt(2) * 33e3 * 0.5 + 1, 800e3}};
-  approval_tests.emplace_back(world1.composition(position, 1, 0));
-  approval_tests.emplace_back(world1.composition(position, 1, 1));
-  approval_tests.emplace_back(world1.composition(position, 1, 2));
-  position = {{250e3,250e3-std::sqrt(2) * 66e3 * 0.5 + 1, 800e3}};
-  approval_tests.emplace_back(world1.composition(position, 1, 0));
-  approval_tests.emplace_back(world1.composition(position, 1, 1));
-  approval_tests.emplace_back(world1.composition(position, 1, 2));
-  position = {{250e3,250e3-std::sqrt(2) * 99e3 * 0.5 + 1, 800e3}};
-  approval_tests.emplace_back(world1.composition(position, 1, 0));
-  approval_tests.emplace_back(world1.composition(position, 1, 1));
-  approval_tests.emplace_back(world1.composition(position, 1, 2));
-  approval_tests.emplace_back(world1.composition(position, 1, 3));
-
-  const std::string file_name2 = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_constant_angles_cartesian_force_temp.wb";
-  const WorldBuilder::World world2(file_name2);
-
-  // Check fault plate through the world
-  position = {{0,0,800e3}};
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 220e3));
-  approval_tests.emplace_back(world2.temperature(position, 230e3));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 2));
-  approval_tests.emplace_back(world2.composition(position, 0, 3));
-  approval_tests.emplace_back(world2.composition(position, 0, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 5));
-  approval_tests.emplace_back(world2.composition(position, 0, 6));
-
-  position = {{250e3,500e3,800e3}};
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 10));
-  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3 - 1));
-  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3 + 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 2));
-  approval_tests.emplace_back(world2.composition(position, 0, 3));
-  approval_tests.emplace_back(world2.composition(position, 10, 0));
-  approval_tests.emplace_back(world2.composition(position, 10, 1));
-  approval_tests.emplace_back(world2.composition(position, 10, 2));
-  approval_tests.emplace_back(world1.composition(position, 10, 3));
-  approval_tests.emplace_back(world1.composition(position, 10, 4));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 50e3 - 1, 3));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 50e3 - 1, 4));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 50e3 + 1, 3));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 50e3 + 1, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 5));
-  approval_tests.emplace_back(world2.composition(position, 0, 6));
-
-
-  position = {{250e3,250e3,800e3}};
-  approval_tests.emplace_back(world2.temperature(position, 0));
-  approval_tests.emplace_back(world2.temperature(position, 1));
-  approval_tests.emplace_back(world2.temperature(position, 5));
-  approval_tests.emplace_back(world2.temperature(position, 10));
-  approval_tests.emplace_back(world2.temperature(position, 100));
-  approval_tests.emplace_back(world2.temperature(position, 500));
-  approval_tests.emplace_back(world2.temperature(position, 1000));
-  approval_tests.emplace_back(world2.temperature(position, 5000));
-  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3/2));
-  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3 - 1));
-  approval_tests.emplace_back(world2.temperature(position, std::sqrt(2) * 50e3 + 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 0));
-  approval_tests.emplace_back(world2.composition(position, 0, 1));
-  approval_tests.emplace_back(world2.composition(position, 0, 2));
-  approval_tests.emplace_back(world2.composition(position, 0, 3));
-  approval_tests.emplace_back(world2.composition(position, 10, 0));
-  approval_tests.emplace_back(world2.composition(position, 10, 1));
-  approval_tests.emplace_back(world2.composition(position, 10, 2));
-  approval_tests.emplace_back(world2.composition(position, 10, 3));
-
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 0));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 1));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 - 1, 2));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 0));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 1));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 33e3 * 0.5 + 1, 2));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 66e3 * 0.5 - 1, 1));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 66e3 * 0.5 + 1, 1));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 99e3 * 0.5 - 1, 2));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 99e3 * 0.5 + 1, 2));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 99e3 * 0.5 - 1, 3));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 99e3 * 0.5 + 1, 3));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 100e3 * 0.5 - 1, 3));
-  approval_tests.emplace_back(world2.composition(position, std::sqrt(2) * 100e3 * 0.5 + 1, 3));
-  approval_tests.emplace_back(world2.composition(position, 0, 4));
-  approval_tests.emplace_back(world2.composition(position, 0, 5));
-  approval_tests.emplace_back(world2.composition(position, 0, 6));
-
-  position = {{250e3,250e3,800e3}};
-  approval_tests.emplace_back(world2.composition(position, 1, 0));
-  approval_tests.emplace_back(world2.composition(position, 1, 1));
-  approval_tests.emplace_back(world2.composition(position, 1, 2));
-  position = {{250e3,250e3-std::sqrt(2) * 33e3 * 0.5 + 1, 800e3}};
-  approval_tests.emplace_back(world2.composition(position, 1, 0));
-  approval_tests.emplace_back(world2.composition(position, 1, 1));
-  approval_tests.emplace_back(world2.composition(position, 1, 2));
-  position = {{250e3,250e3-std::sqrt(2) * 66e3 * 0.5 + 1, 800e3}};
-  approval_tests.emplace_back(world2.composition(position, 1, 0));
-  approval_tests.emplace_back(world2.composition(position, 1, 1));
-  approval_tests.emplace_back(world2.composition(position, 1, 2));
-  position = {{250e3,250e3-std::sqrt(2) * 99e3 * 0.5 + 1, 800e3}};
-  approval_tests.emplace_back(world2.composition(position, 1, 0));
-  approval_tests.emplace_back(world2.composition(position, 1, 1));
-  approval_tests.emplace_back(world2.composition(position, 1, 2));
-  approval_tests.emplace_back(world2.composition(position, 1, 3));
-
-
-  // Cartesian
-  file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_constant_angles_cartesian_2.wb";
-  WorldBuilder::World world3(file_name);
-
-  // Check fault directly (upper case should automatically turn into lower case).
-  const std::unique_ptr<Features::Interface> continental_plate = Features::Interface::create("Fault", &world3);
-
-  // Check fault through the world
-  position = {{0,0,800e3}};
-  approval_tests.emplace_back(world3.temperature(position, 0));
-  approval_tests.emplace_back(world3.temperature(position, 240e3));
-  approval_tests.emplace_back(world3.temperature(position, 260e3));
-  approval_tests.emplace_back(world3.composition(position, 0, 0));
-  approval_tests.emplace_back(world3.composition(position, 0, 1));
-  approval_tests.emplace_back(world3.composition(position, 0, 2));
-  approval_tests.emplace_back(world3.composition(position, 0, 3));
-  approval_tests.emplace_back(world3.composition(position, 0, 4));
-  approval_tests.emplace_back(world3.composition(position, 0, 5));
-  approval_tests.emplace_back(world3.composition(position, 0, 6));
-
-  position = {{250e3,500e3,800e3}};
-  //adibatic temperature
-  approval_tests.emplace_back(world3.temperature(position, 0));
-  approval_tests.emplace_back(world3.temperature(position, 1));
-  approval_tests.emplace_back(world3.temperature(position, 5000));
-  approval_tests.emplace_back(world3.temperature(position, 10e3));
-  approval_tests.emplace_back(world3.temperature(position, 25e3));
-  approval_tests.emplace_back(world3.temperature(position, 50e3));
-  approval_tests.emplace_back(world3.temperature(position, 75e3));
-  approval_tests.emplace_back(world3.temperature(position, 150e3));
-  //approval_tests.emplace_back(world3.temperature(position, std::sqrt(2) * 100e3 - 1));
-  //approval_tests.emplace_back(world3.temperature(position, std::sqrt(2) * 100e3 + 1));
-  approval_tests.emplace_back(world3.composition(position, 0, 0));
-  approval_tests.emplace_back(world3.composition(position, 0, 1));
-  approval_tests.emplace_back(world3.composition(position, 0, 2));
-  approval_tests.emplace_back(world3.composition(position, 0, 3));
-  approval_tests.emplace_back(world3.composition(position, 0, 4));
-  approval_tests.emplace_back(world3.composition(position, 10, 0));
-  approval_tests.emplace_back(world3.composition(position, 10, 1));
-  approval_tests.emplace_back(world3.composition(position, 10, 2));
-  approval_tests.emplace_back(world3.composition(position, 10, 3));
-  approval_tests.emplace_back(world3.composition(position, 10, 4));
-  //todo: recheck these results
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 16.5e3 - 1, 0));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 16.5e3 + 1, 0));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 16.5e3 - 1, 1));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 16.5e3 + 1, 1));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 - 1, 1));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 + 1, 1));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 - 1, 2));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 + 1, 2));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 33e3 + 1, 3));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 49.5e3 - 1, 2));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 49.5e3 - 1, 3));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 49.5e3 + 1, 2));
-  // this comes form the first subducting plate
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 49.5e3 + 1, 3));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 50e3 - 1, 3));
-  approval_tests.emplace_back(world3.composition(position, std::sqrt(2) * 50e3 + 1, 3));
-  approval_tests.emplace_back(world3.composition(position, 0, 4));
-  approval_tests.emplace_back(world3.composition(position, 0, 5));
-  approval_tests.emplace_back(world3.composition(position, 0, 6));
-
-  {
-    const WorldBuilder::grains grains = world3.grains(position, std::sqrt(2) * 33e3 * 0.5 - 1, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{250e3,600e3,800e3}};
-  approval_tests.emplace_back(world3.temperature(position, 0));
-  approval_tests.emplace_back(world3.temperature(position, 10));
-  approval_tests.emplace_back(world3.temperature(position, 100e3-1));
-  approval_tests.emplace_back(world3.temperature(position, 100e3+1));
-  approval_tests.emplace_back(world3.temperature(position, 101e3));
-  approval_tests.emplace_back(world3.temperature(position, 110e3));
-  approval_tests.emplace_back(world3.temperature(position, 150e3));
-  approval_tests.emplace_back(world3.temperature(position, 200e3));
-  approval_tests.emplace_back(world3.composition(position, 0, 0));
-  approval_tests.emplace_back(world3.composition(position, 0, 1));
-  approval_tests.emplace_back(world3.composition(position, 0, 2));
-  approval_tests.emplace_back(world3.composition(position, 0, 3));
-  approval_tests.emplace_back(world3.composition(position, 10, 0));
-  approval_tests.emplace_back(world3.composition(position, 10, 1));
-  approval_tests.emplace_back(world3.composition(position, 10, 2));
-  approval_tests.emplace_back(world3.composition(position, 10, 3));
-  approval_tests.emplace_back(world3.composition(position, 100e3-1, 0));
-  approval_tests.emplace_back(world3.composition(position, 100e3-1, 1));
-  approval_tests.emplace_back(world3.composition(position, 100e3-1, 2));
-  approval_tests.emplace_back(world3.composition(position, 100e3-1, 3));
-  approval_tests.emplace_back(world3.composition(position, 100e3-1, 4));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 0));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 1));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 2));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 3));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 4));
-  approval_tests.emplace_back(world3.composition(position, 101e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 1));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 2));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 3));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 4));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 1));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 2));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 3));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 4));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 1));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 2));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 3));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 4));
-  approval_tests.emplace_back(world3.composition(position, 0, 4));
-  approval_tests.emplace_back(world3.composition(position, 0, 5));
-  approval_tests.emplace_back(world3.composition(position, 0, 6));
-
-  {
-    const WorldBuilder::grains grains = world3.grains(position, 101e3+1, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{650e3,650e3,800e3}};
-  approval_tests.emplace_back(world3.temperature(position, 0));
-  approval_tests.emplace_back(world3.temperature(position, 10));
-  approval_tests.emplace_back(world3.temperature(position, 100e3));
-  approval_tests.emplace_back(world3.temperature(position, 100e3+1));
-  approval_tests.emplace_back(world3.temperature(position, 101e3));
-  approval_tests.emplace_back(world3.temperature(position, 110e3));
-  approval_tests.emplace_back(world3.temperature(position, 150e3));
-  approval_tests.emplace_back(world3.temperature(position, 200e3));
-  approval_tests.emplace_back(world3.composition(position, 0, 0));
-  approval_tests.emplace_back(world3.composition(position, 0, 1));
-  approval_tests.emplace_back(world3.composition(position, 0, 2));
-  approval_tests.emplace_back(world3.composition(position, 0, 3));
-  approval_tests.emplace_back(world3.composition(position, 10, 0));
-  approval_tests.emplace_back(world3.composition(position, 10, 1));
-  approval_tests.emplace_back(world3.composition(position, 10, 2));
-  approval_tests.emplace_back(world3.composition(position, 10, 3));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 1));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 2));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 3));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 4));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 0));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 1));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 2));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 3));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 4));
-  approval_tests.emplace_back(world3.composition(position, 101e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 1));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 2));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 3));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 4));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 1));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 2));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 3));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 4));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 1));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 2));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 3));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 4));
-  approval_tests.emplace_back(world3.composition(position, 0, 4));
-  approval_tests.emplace_back(world3.composition(position, 0, 5));
-  approval_tests.emplace_back(world3.composition(position, 0, 6));
-
-  {
-    const WorldBuilder::grains grains = world3.grains(position, 100e3+1, 0, 3);
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  position = {{700e3,675e3,800e3}};
-  approval_tests.emplace_back(world3.temperature(position, 0));
-  approval_tests.emplace_back(world3.temperature(position, 10));
-  approval_tests.emplace_back(world3.temperature(position, 100e3));
-  approval_tests.emplace_back(world3.temperature(position, 100e3+1));
-  approval_tests.emplace_back(world3.temperature(position, 101e3));
-  approval_tests.emplace_back(world3.temperature(position, 110e3));
-  approval_tests.emplace_back(world3.temperature(position, 150e3));
-  approval_tests.emplace_back(world3.temperature(position, 200e3));
-  approval_tests.emplace_back(world3.composition(position, 0, 0));
-  approval_tests.emplace_back(world3.composition(position, 0, 1));
-  approval_tests.emplace_back(world3.composition(position, 0, 2));
-  approval_tests.emplace_back(world3.composition(position, 0, 3));
-  approval_tests.emplace_back(world3.composition(position, 10, 0));
-  approval_tests.emplace_back(world3.composition(position, 10, 1));
-  approval_tests.emplace_back(world3.composition(position, 10, 2));
-  approval_tests.emplace_back(world3.composition(position, 10, 3));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 1));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 2));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 3));
-  approval_tests.emplace_back(world3.composition(position, 100e3, 4));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 0));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 1));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 2));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 3));
-  approval_tests.emplace_back(world3.composition(position, 100e3+1, 4));
-  approval_tests.emplace_back(world3.composition(position, 101e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 1));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 2));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 3));
-  approval_tests.emplace_back(world3.composition(position, 101e3+1, 4));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 1));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 2));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 3));
-  approval_tests.emplace_back(world3.composition(position, 150e3, 4));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 0));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 1));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 2));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 3));
-  approval_tests.emplace_back(world3.composition(position, 200e3, 4));
-  approval_tests.emplace_back(world3.composition(position, 0, 4));
-  approval_tests.emplace_back(world3.composition(position, 0, 5));
-  approval_tests.emplace_back(world3.composition(position, 0, 6));
-
-  position = {{750e3,35e3,800e3}};
-  approval_tests.emplace_back(world3.temperature(position, 0));
-  approval_tests.emplace_back(world3.temperature(position, 10));
-  approval_tests.emplace_back(world3.temperature(position, 5e3));
-  approval_tests.emplace_back(world3.temperature(position, 10e3));
-  approval_tests.emplace_back(world3.temperature(position, 15e3));
-  approval_tests.emplace_back(world3.temperature(position, 20e3));
-  approval_tests.emplace_back(world3.temperature(position, 25e3));
-  approval_tests.emplace_back(world3.temperature(position, 30e3));
-  approval_tests.emplace_back(world3.temperature(position, 35e3));
-  approval_tests.emplace_back(world3.temperature(position, 40e3));
-  approval_tests.emplace_back(world3.temperature(position, 45e3));
-  approval_tests.emplace_back(world3.temperature(position, 50e3));
-  approval_tests.emplace_back(world3.temperature(position, 55e3));
-  approval_tests.emplace_back(world3.temperature(position, 60e3));
-  approval_tests.emplace_back(world3.temperature(position, 65e3));
-  approval_tests.emplace_back(world3.temperature(position, 70e3));
-  approval_tests.emplace_back(world3.temperature(position, 72.5e3));
-  approval_tests.emplace_back(world3.temperature(position, 75e3));
-  approval_tests.emplace_back(world3.temperature(position, 80e3));
-  approval_tests.emplace_back(world3.temperature(position, 85e3));
-  approval_tests.emplace_back(world3.temperature(position, 90e3));
-  approval_tests.emplace_back(world3.temperature(position, 95e3));
-  approval_tests.emplace_back(world3.temperature(position, 100e3));
-  approval_tests.emplace_back(world3.temperature(position, 105e3));
-  approval_tests.emplace_back(world3.temperature(position, 110e3));
-  approval_tests.emplace_back(world3.temperature(position, 115e3));
-  approval_tests.emplace_back(world3.temperature(position, 120e3));
-  approval_tests.emplace_back(world3.temperature(position, 125e3));
-  approval_tests.emplace_back(world3.temperature(position, 130e3));
-  approval_tests.emplace_back(world3.temperature(position, 135e3));
-  approval_tests.emplace_back(world3.temperature(position, 150e3));
-  approval_tests.emplace_back(world3.temperature(position, 160e3));
-  approval_tests.emplace_back(world3.temperature(position, 170e3));
-  approval_tests.emplace_back(world3.temperature(position, 175e3));
-  approval_tests.emplace_back(world3.temperature(position, 180e3));
-  approval_tests.emplace_back(world3.temperature(position, 190e3));
-  approval_tests.emplace_back(world3.temperature(position, 200e3));
-  approval_tests.emplace_back(world3.temperature(position, 250e3));
-  approval_tests.emplace_back(world3.temperature(position, 300e3));
-
-  // check grains layer 1
-  {
-    const WorldBuilder::grains grains = world3.grains(position, 95e3, 0, 2);
-    // these are random numbers, but they should stay the same.
-    // note that the values are different from for example the continental plate since
-    // this performs a interpolation between segments of the slab.
-    approval_tests_grains.emplace_back(grains);
-  }
-
-  // check grains layer 2 bottom (because of the randomness it will have different values.)
-  {
-    const WorldBuilder::grains grains = world3.grains(position, 150e3, 0, 2);
-    approval_tests_grains.emplace_back(grains);
-
-  }
-
-  // check grains layer 2 top
-  {
-    const WorldBuilder::grains grains = world3.grains(position, 35e3, 0, 2);
-    approval_tests_grains.emplace_back(grains);
-    //compare_vectors_approx(grains.sizes, {0.3512381923,0.6487618077});
-    //approval_tests.emplace_back(grains.sizes[0] + grains.sizes[1]);
-    //// these are random numbers, but they should stay the same.
-//
-    //std::array<std::array<double, 3>, 3> array_1 = {{{{-0.5760272563,-0.3302260164,0.7477589038}},{{-0.3927671635,-0.6904395086,-0.6074761232}},{{0.7168867103,-0.6436179481,0.26801004}}}};
-    //std::array<std::array<double, 3>, 3> array_2 = {{{{0.7622618339,-0.3280663618,0.5579689586}},{{-0.2767873192,-0.9444558064,-0.1771779043}},{{0.5851031332,-0.01938277797,-0.8107272238}}}};
-    //std::vector<std::array<std::array<double, 3>, 3> > vector_1 = {array_1,array_2};
-    //compare_vectors_array3_array3_approx(grains.rotation_matrices, vector_1);
-  }
-
-
-  file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/fault_different_angles_cartesian.wb";
-  const WorldBuilder::World world4(file_name);
-
-  position = {{250e3,501e3,800e3}};
-  approval_tests.emplace_back(world4.temperature(position, 0));
-  approval_tests.emplace_back(world4.composition(position, 0, 0));
-  approval_tests.emplace_back(world4.temperature(position, 1));
-  approval_tests.emplace_back(world4.composition(position, 1, 0));
-  approval_tests.emplace_back(world4.temperature(position, 1e3));
-  approval_tests.emplace_back(world4.composition(position, 1e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 10e3));
-  approval_tests.emplace_back(world4.composition(position, 10e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 20e3));
-  approval_tests.emplace_back(world4.composition(position, 20e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 30e3));
-  approval_tests.emplace_back(world4.composition(position, 30e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 35e3));
-  approval_tests.emplace_back(world4.composition(position, 35e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 40e3));
-  approval_tests.emplace_back(world4.composition(position, 40e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 45e3));
-  approval_tests.emplace_back(world4.composition(position, 45e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 50e3));
-  approval_tests.emplace_back(world4.composition(position, 50e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 60e3));
-  approval_tests.emplace_back(world4.composition(position, 60e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 80e3));
-  approval_tests.emplace_back(world4.composition(position, 80e3, 0));
-  approval_tests.emplace_back(world4.temperature(position, 100e3));
-  approval_tests.emplace_back(world4.composition(position, 100e3, 0));
-
-  std::vector<std::string> approvals;
-  for (auto&& value : approval_tests)
-    {
-      std::stringstream s;
-      s << value;
-      approvals.emplace_back(s.str());
-    }
-  for (auto&& value : approval_tests_grains)
-    {
-      std::stringstream s;
-      s << value << " ";
-      approvals.emplace_back(s.str());
-    }
-  ApprovalTests::Approvals::verifyAll("Test", approvals);
-}
-
-TEST_CASE("WorldBuilder Features: coordinate interpolation")
-{
-  std::vector<double> approval_tests;
-
-  {
-    const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/interpolation_monotone_spline_cartesian.wb";
-    const WorldBuilder::World world1(file_name);
-
-    std::array<double,3> position = {{374e3,875e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-    position = {{376e3,875e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-    position = {{350e3,900e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-
-    position = {{375e3,874e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-    position = {{375e3,876e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-
-
-    position = {{374e3,625e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-    position = {{376e3,625e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-    position = {{350e3,600e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-
-    position = {{375e3,624e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-    position = {{375e3,626e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 0));
-    approval_tests.emplace_back(world1.composition(position, 0, 0));
-
-
-    position = {{638e3,425e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 10));
-    approval_tests.emplace_back(world1.composition(position, 10, 0));
-    position = {{637e3,425e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 10));
-    approval_tests.emplace_back(world1.composition(position, 10, 0));
-    position = {{617.5e3,445e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 1e3));
-    approval_tests.emplace_back(world1.composition(position, 1e3, 0));
-
-    position = {{625e3,200e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 10));
-    approval_tests.emplace_back(world1.composition(position, 10, 0));
-    position = {{624e3,200e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 10));
-    approval_tests.emplace_back(world1.composition(position, 10, 0));
-    position = {{607e3,180e3,800e3}};
-    approval_tests.emplace_back(world1.temperature(position, 3e3));
-    approval_tests.emplace_back(world1.composition(position, 3e3, 0));
-  }
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-TEST_CASE("WorldBuilder Types: Double")
-{
-#define TYPE Double
-  Types::TYPE const type(1);
-  CHECK(type.default_value == Approx(1.0));
-  CHECK(type.get_type() == Types::type::TYPE);
-
-  Types::TYPE const &type_copy(type);
-  CHECK(type_copy.default_value == Approx(1.0));
-  CHECK(type_copy.get_type() == Types::type::TYPE);
-
-  Types::TYPE const type_explicit(3);
-  CHECK(type_explicit.default_value == Approx(3.0));
-  CHECK(type_explicit.get_type() == Types::type::TYPE);
-
-  const std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->default_value == Approx(3.0));
-  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
-#undef TYPE
-}
-
-/*TEST_CASE("WorldBuilder Types: UnsignedInt")
-{
-#define TYPE UnsignedInt
-  Types::TYPE type(1,"test");
-  CHECK(type.value == Approx(1.0));
-  CHECK(type.default_value == Approx(1.0));
-  CHECK(type.description == "test");
-  CHECK(type.get_type() == Types::type::TYPE);
-  Types::TYPE type_copy(type);
-  CHECK(type_copy.value == Approx(1.0));
-  CHECK(type_copy.default_value == Approx(1.0));
-  CHECK(type_copy.description == "test");
-  CHECK(type_copy.get_type() == Types::type::TYPE);
-  Types::TYPE type_explicit(2, 3, "test explicit");
-  CHECK(type_explicit.value == Approx(2.0));
-  CHECK(type_explicit.default_value == Approx(3.0));
-  CHECK(type_explicit.description == "test explicit");
-  CHECK(type_explicit.get_type() == Types::type::TYPE);
-  std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->value == Approx(2.0));
-  CHECK(type_clone_natural->default_value == Approx(3.0));
-  CHECK(type_clone_natural->description == "test explicit");
-  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
-#undef TYPE
-}*/
-
-TEST_CASE("WorldBuilder Types: String")
-{
-#define TYPE String
-  Types::TYPE const type("1","test");
-  CHECK(type.default_value == "1");
-  CHECK(type.get_type() == Types::type::TYPE);
-
-  Types::TYPE const &type_copy(type);
-  CHECK(type_copy.default_value == "1");
-  CHECK(type_copy.get_type() == Types::type::TYPE);
-
-  Types::TYPE const type_explicit("2", "3", "test explicit");
-  CHECK(type_explicit.default_value == "3");
-  CHECK(type_explicit.get_type() == Types::type::TYPE);
-
-  const std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->default_value == "3");
-  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
-#undef TYPE
-}
-
-TEST_CASE("WorldBuilder Types: Point 2d")
-{
-#define TYPE Point<2>
-  Types::TYPE type(TYPE(1,2,cartesian),"test");
-  CHECK(type.value[0] == Approx(TYPE(1,2,cartesian)[0]));
-  CHECK(type.value[1] == Approx(TYPE(1,2,cartesian)[1]));
-  CHECK(type.default_value[0] == Approx(TYPE(1,2,cartesian)[0]));
-  CHECK(type.default_value[1] == Approx(TYPE(1,2,cartesian)[1]));
-  CHECK(type.description == "test");
-  CHECK(type.get_type() == Types::type::Point2D);
-
-  Types::TYPE type_copy(type);
-  CHECK(type_copy.value[0] == Approx(TYPE(1,2,cartesian)[0]));
-  CHECK(type_copy.value[1] == Approx(TYPE(1,2,cartesian)[1]));
-  CHECK(type.default_value[0] == Approx(TYPE(1,2,cartesian)[0]));
-  CHECK(type.default_value[1] == Approx(TYPE(1,2,cartesian)[1]));
-  CHECK(type_copy.description == "test");
-  CHECK(type_copy.get_type() == Types::type::Point2D);
-
-  Types::TYPE type_explicit(TYPE(3,4,cartesian), TYPE(5,6,cartesian), "test explicit");
-  CHECK(type_explicit.value[0] == Approx(TYPE(3,4,cartesian)[0]));
-  CHECK(type_explicit.value[1] == Approx(TYPE(3,4,cartesian)[1]));
-  CHECK(type_explicit.default_value[0] == Approx(TYPE(5,6,cartesian)[0]));
-  CHECK(type_explicit.default_value[1] == Approx(TYPE(5,6,cartesian)[1]));
-  CHECK(type_explicit.description == "test explicit");
-  CHECK(type_explicit.get_type() == Types::type::Point2D);
-
-  const std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->value[0] == Approx(TYPE(3,4,cartesian)[0]));
-  CHECK(type_clone_natural->value[1] == Approx(TYPE(3,4,cartesian)[1]));
-  CHECK(type_clone_natural->default_value[0] == Approx(TYPE(5,6,cartesian)[0]));
-  CHECK(type_clone_natural->default_value[1] == Approx(TYPE(5,6,cartesian)[1]));
-  CHECK(type_clone_natural->description == "test explicit");
-  CHECK(type_clone_natural->get_type() == Types::type::Point2D);
-
-
-
-  // Test Point operators
-
-  const TYPE point_array(std::array<double,2> {{1,2}},cartesian);
-  const TYPE point_explicit(3,4,cartesian);
-
-  Types::TYPE type_point_array(point_array, point_array, "test array");
-  const Types::TYPE type_point_array_const(point_array, point_array, "test array");
-  Types::TYPE const type_point_explicit(point_explicit, point_explicit, "test array");
-
-  CHECK(type_point_array.value.get_array() == std::array<double,2> {{1,2}});
-  CHECK(type_point_explicit.value.get_array() == std::array<double,2> {{3,4}});
-
-  // Test multiply operator
-  TYPE point = 2 * type_point_array * 1.0;
-
-  CHECK(point.get_array() == std::array<double,2> {{2,4}});
-
-  // Test dot operator
-  CHECK(type_point_array * type_point_explicit == Approx(11.0));
-
-  // Test add operator
-  point = type_point_array + type_point_explicit;
-
-  CHECK(point.get_array() == std::array<double,2> {{4,6}});
-
-  // Test subtract operator
-  point = type_point_explicit - type_point_array;
-
-  CHECK(point.get_array() == std::array<double,2> {{2,2}});
-
-  // test the access operator
-  CHECK(type_point_array[0] == Approx(1.0));
-
-  type_point_array[0] = 2;
-  CHECK(type_point_array[0] == Approx(2.0));
-
-  // test the access operator
-  CHECK(type_point_array_const[0] == Approx(1.0));
-  CHECK(type_point_array_const[1] == Approx(2.0));
-
-  // Test the point output stream.
-  std::ostringstream stream;
-  stream << point_array;
-  const std::string str =  stream.str();
-  CHECK(str == "1 2");
-#undef TYPE
-}
-
-TEST_CASE("WorldBuilder Types: Point 3d")
-{
-#define TYPE Point<3>
-  Types::TYPE type(TYPE(1,2,3,cartesian),"test");
-  const double &value_0 = type.value[0];
-  CHECK(value_0 == Approx(1.0));
-  CHECK(type.value[1] == Approx(2.0));
-  CHECK(type.value[2] == Approx(3.0));
-  CHECK(type.default_value[0] == Approx(1.0));
-  CHECK(type.default_value[1] == Approx(2.0));
-  CHECK(type.default_value[2] == Approx(3.0));
-  CHECK(type.description == "test");
-  CHECK(type.get_type() == Types::type::Point3D);
-
-  Types::TYPE type_copy(type);
-  CHECK(type_copy.value[0] == Approx(1.0));
-  CHECK(type_copy.value[1] == Approx(2.0));
-  CHECK(type_copy.value[2] == Approx(3.0));
-  CHECK(type_copy.default_value[0] == Approx(1.0));
-  CHECK(type_copy.default_value[1] == Approx(2.0));
-  CHECK(type_copy.default_value[2] == Approx(3.0));
-  CHECK(type_copy.description == "test");
-  CHECK(type_copy.get_type() == Types::type::Point3D);
-
-  Types::TYPE type_explicit(TYPE(4,5,6,cartesian), TYPE(7,8,9,cartesian), "test explicit");
-  CHECK(type_explicit.value[0] == Approx(4.0));
-  CHECK(type_explicit.value[1] == Approx(5.0));
-  CHECK(type_explicit.value[2] == Approx(6.0));
-  CHECK(type_explicit.default_value[0] == Approx(7.0));
-  CHECK(type_explicit.default_value[1] == Approx(8.0));
-  CHECK(type_explicit.default_value[2] == Approx(9.0));
-  CHECK(type_explicit.description == "test explicit");
-  CHECK(type_explicit.get_type() == Types::type::Point3D);
-
-  const std::unique_ptr<Types::Interface> type_clone = type_explicit.clone();
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->value[0] == Approx(4.0));
-  CHECK(type_clone_natural->value[1] == Approx(5.0));
-  CHECK(type_clone_natural->value[2] == Approx(6.0));
-  CHECK(type_clone_natural->default_value[0] == Approx(7.0));
-  CHECK(type_clone_natural->default_value[1] == Approx(8.0));
-  CHECK(type_clone_natural->default_value[2] == Approx(9.0));
-  CHECK(type_clone_natural->description == "test explicit");
-  CHECK(type_clone_natural->get_type() == Types::type::Point3D);
-
-
-  // Test Point operators
-
-  const TYPE point_array(std::array<double,3> {{1,2,3}},cartesian);
-  const TYPE point_explicit(4,5,6,cartesian);
-
-  Types::TYPE type_point_array(point_array, point_array, "test array");
-  const Types::TYPE type_point_array_const(point_array, point_array, "test array");
-  Types::TYPE const type_point_explicit(point_explicit, point_explicit, "test array");
-
-  CHECK(type_point_array.value.get_array() == std::array<double,3> {{1,2,3}});
-  CHECK(type_point_explicit.value.get_array() == std::array<double,3> {{4,5,6}});
-
-  // Test multiply operator
-  TYPE point = 2 * type_point_array;
-
-  CHECK(point.get_array() == std::array<double,3> {{2,4,6}});
-
-  // Test multiply operator
-  point = type_point_array * 2;
-
-  CHECK(point.get_array() == std::array<double,3> {{2,4,6}});
-
-  // Test dot operator
-  CHECK(type_point_array * type_point_explicit == Approx(32.0));
-
-  // Test add operator
-  point = type_point_array + type_point_explicit;
-
-  CHECK(point.get_array() == std::array<double,3> {{5,7,9}});
-
-  // Test subtract operator
-  point = type_point_explicit - type_point_array;
-
-  CHECK(point.get_array() == std::array<double,3> {{3,3,3}});
-
-  // test the access operator
-  CHECK(type_point_array[0] == Approx(1.0));
-
-  type_point_array[0] = 2;
-  CHECK(type_point_array[0] == Approx(2.0));
-
-  // const test the access operator
-  CHECK(point_array[0] == Approx(1.0));
-
-  // test the const access operator
-  CHECK(type_point_array_const[0] == Approx(1.0));
-  CHECK(type_point_array_const[1] == Approx(2.0));
-  CHECK(type_point_array_const[2] == Approx(3.0));
-
-  // Test the point output stream.
-  std::ostringstream stream;
-  stream << point_array;
-  const std::string str =  stream.str();
-  CHECK(str == "1 2 3");
-
-#undef TYPE
-}
-/*
-TEST_CASE("WorldBuilder Types: Coordinate System")
-{
-#define TYPE CoordinateSystem
-  Types::TYPE type("1","test");
-  CHECK(type.value == nullptr);
-  CHECK(type.default_value == "1");
-  CHECK(type.description == "test");
-  CHECK(type.get_type() == Types::type::TYPE);
-  std::unique_ptr<Types::Interface> type_clone = type.clone();
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->value == nullptr);
-  CHECK(type_clone_natural->default_value == "1");
-  CHECK(type_clone_natural->description == "test");
-  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
-  // todo: test the set value function.
-#undef TYPE
-}*/
-
-// not sure how to unit test this.
-TEST_CASE("WorldBuilder Types: PluginSystem")
-{
-#define TYPE PluginSystem
-  Types::TYPE type("test", Features::ContinentalPlate::declare_entries, std::vector<std::string> {{"test required"}}, false);
-  CHECK(type.default_value == "test");
-  CHECK(type.required_entries[0] == "test required");
-  CHECK(type.allow_multiple == false);
-  CHECK(type.get_type() == Types::type::TYPE);
-
-  Types::TYPE type_copy(type);
-  CHECK(type_copy.default_value == "test");
-  CHECK(type_copy.required_entries[0] == "test required");
-  CHECK(type_copy.allow_multiple == false);
-  CHECK(type_copy.get_type() == Types::type::TYPE);
-
-  const std::unique_ptr<Types::Interface> type_clone = type_copy.clone();
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->default_value == "test");
-  CHECK(type_clone_natural->required_entries[0] == "test required");
-  CHECK(type_clone_natural->allow_multiple == false);
-  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
-
-#undef TYPE
-}
-
-
-// not sure how to unit test this.
-TEST_CASE("WorldBuilder Types: Segment Object")
-{
-#define TYPE Segment
-  const WorldBuilder::Point<2> thickness(1,2,invalid);
-  const WorldBuilder::Point<2> top_trucation(3,4,invalid);
-  const WorldBuilder::Point<2> angle(5,6,invalid);
-  Objects::TYPE<Features::FaultModels::Temperature::Interface, Features::FaultModels::Composition::Interface, Features::FaultModels::Grains::Interface>
-  type (1.0, thickness, top_trucation, angle,
-        std::vector<std::shared_ptr<Features::FaultModels::Temperature::Interface> >(),
-        std::vector<std::shared_ptr<Features::FaultModels::Composition::Interface> >(),
-        std::vector<std::shared_ptr<Features::FaultModels::Grains::Interface> >());
-  CHECK(type.value_length == Approx(1.0));
-  CHECK(type.value_thickness[0] == Approx(1.0));
-  CHECK(type.value_thickness[1] == Approx(2.0));
-  CHECK(type.value_top_truncation[0] == Approx(3.0));
-  CHECK(type.value_top_truncation[1] == Approx(4.0));
-  CHECK(type.value_angle[0] == Approx(5.0));
-  CHECK(type.value_angle[1] == Approx(6.0));
-
-  Objects::TYPE<Features::FaultModels::Temperature::Interface, Features::FaultModels::Composition::Interface, Features::FaultModels::Grains::Interface>
-  type_copy(type);
-  const double &value_length = type_copy.value_length;
-  CHECK(value_length == Approx(1.0));
-  CHECK(type_copy.value_thickness[0] == Approx(1.0));
-  CHECK(type_copy.value_thickness[1] == Approx(2.0));
-  CHECK(type_copy.value_top_truncation[0] == Approx(3.0));
-  CHECK(type_copy.value_top_truncation[1] == Approx(4.0));
-  CHECK(type_copy.value_angle[0] == Approx(5.0));
-  CHECK(type_copy.value_angle[1] == Approx(6.0));
-
-#undef TYPE
-}
-
-TEST_CASE("WorldBuilder Types: Array")
-{
-#define TYPE Array
-  Types::TYPE const type(Types::Double(0));
-  CHECK(type.inner_type == Types::type::Double);
-  CHECK(type.inner_type_ptr.get() != nullptr);
-  CHECK(type.get_type() == Types::type::TYPE);
-
-  Types::TYPE const &type_copy(type);
-  CHECK(type_copy.inner_type == Types::type::Double);
-  CHECK(type_copy.inner_type_ptr.get() != nullptr);
-  CHECK(type_copy.get_type() == Types::type::TYPE);
-
-  /*Types::TYPE type_explicit(std::vector<unsigned int> {1,2}, Types::type::Double, "array test explicit");
-  CHECK(type_explicit.inner_type == Types::type::Double);
-  CHECK(type_explicit.inner_type_ptr.get() == nullptr);
-  CHECK(type_explicit.inner_type_index.size() == 2);
-  CHECK(type_explicit.description == "array test explicit");
-  CHECK(type_explicit.get_type() == Types::type::TYPE);*/
-
-  //CHECK_THROWS_WITH(type.clone(),Contains("Error: Cloning Arrays is currently not possible."));
-  /*
-  std::unique_ptr<Types::Interface> type_clone = type_explicit.clone()
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->inner_type == Types::type::Double);
-  CHECK(type_clone_natural->inner_type_ptr.get() == nullptr);
-  CHECK(type_clone_natural->inner_type_index.size() == 2);
-  CHECK(type_clone_natural->description == "array test explicit");
-  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
-  Types::TYPE type_copy2(*type_clone_natural);
-  CHECK(type_copy2.inner_type == Types::type::Double);
-  CHECK(type_copy2.inner_type_ptr.get() == nullptr);
-  CHECK(type_copy2.inner_type_index.size() == 2);
-  CHECK(type_copy2.description == "array test explicit");
-  CHECK(type_copy2.get_type() == Types::type::TYPE);*/
-
-#undef TYPE
-}
-
-TEST_CASE("WorldBuilder Types: Object")
-{
-#define TYPE Object
-  Types::TYPE type(std::vector<std::string> {"test1","test2"},true);
-  CHECK(type.required.size() == 2);
-  CHECK(type.required[0] == "test1");
-  CHECK(type.required[1] == "test2");
-  CHECK(type.additional_properties == true);
-  CHECK(type.get_type() == Types::type::TYPE);
-
-  Types::TYPE type_copy(type);
-  CHECK(type_copy.required.size() == 2);
-  CHECK(type_copy.required[0] == "test1");
-  CHECK(type_copy.required[1] == "test2");
-  CHECK(type_copy.additional_properties == true);
-  CHECK(type_copy.get_type() == Types::type::TYPE);
-
-  const std::unique_ptr<Types::Interface> type_clone = type_copy.clone();
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->required.size() == 2);
-  CHECK(type_clone_natural->required[0] == "test1");
-  CHECK(type_clone_natural->required[1] == "test2");
-  CHECK(type_clone_natural->additional_properties == true);
-  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
-
-  Types::TYPE type_copy2(*type_clone_natural);
-  CHECK(type_copy2.required.size() == 2);
-  CHECK(type_copy2.required[0] == "test1");
-  CHECK(type_copy2.required[1] == "test2");
-  CHECK(type_copy2.additional_properties == true);
-  CHECK(type_copy2.get_type() == Types::type::TYPE);
-
-#undef TYPE
-}
-
-
-TEST_CASE("WorldBuilder Types: Bool")
-{
-#define TYPE Bool
-  Types::TYPE const type(true);
-  CHECK(type.default_value == true);
-  CHECK(type.get_type() == Types::type::TYPE);
-
-
-  Types::TYPE const &type_copy(type);
-  CHECK(type_copy.default_value == true);
-  CHECK(type_copy.get_type() == Types::type::TYPE);
-
-  const std::unique_ptr<Types::Interface> type_clone = type_copy.clone();
-  Types::TYPE *type_clone_natural = dynamic_cast<Types::TYPE *>(type_clone.get());
-  CHECK(type_clone_natural->default_value == true);
-  CHECK(type_clone_natural->get_type() == Types::type::TYPE);
-
-  Types::TYPE const type_copy2(*type_clone_natural);
-  CHECK(type_copy2.default_value == true);
-  CHECK(type_copy2.get_type() == Types::type::TYPE);
-
-#undef TYPE
-}
-
-/*
-TEST_CASE("WorldBuilder Types: print_tree")
-{
-  std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/simple_wb1.json";
-  boost::property_tree::ptree tree;
-  std::ifstream json_input_stream(file_name.c_str());
-
-  boost::property_tree::json_parser::read_json (json_input_stream, tree);
-  std::stringstream output;
-  output <<
-         "{\n"
-         "  \"version\": \"0.1\",\n"
-         "  \"coordinate system\": \n"
-         "  {\n"
-         "    \"model\": \"cartesian\"\n"
-         "   },\n"
-         "  \"cross section\": \n"
-         "  {\n"
-         "    \"\": \n"
-         "    {\n"
-         "      \"\": \"100e3\",\n"
-         "      \"\": \"100e3\"\n"
-         "     },\n"
-         "    \"\": \n"
-         "    {\n"
-         "      \"\": \"400e3\",\n"
-         "      \"\": \"500e3\"\n"
-         "     }\n"
-         "   },\n"
-         "  \"maximum distance between coordinates\": \"5\",\n"
-         "  \"features\": \n"
-         "  {\n"
-         "    \"\": \n"
-         "    {\n"
-         "      \"model\": \"continental plate\",\n"
-         "      \"name\": \"Caribbean\",\n"
-         "      \"max depth\": \"300e3\",\n"
-         "      \"coordinates\": \n"
-         "      {\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"-1e3\",\n"
-         "          \"\": \"500e3\"\n"
-         "         },\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"500e3\",\n"
-         "          \"\": \"500e3\"\n"
-         "         },\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"500e3\",\n"
-         "          \"\": \"1000e3\"\n"
-         "         },\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"-1e3\",\n"
-         "          \"\": \"1000e3\"\n"
-         "         }\n"
-         "       },\n"
-         "      \"temperature models\": \n"
-         "      {\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"model\": \"uniform\",\n"
-         "          \"min depth\": \"0\",\n"
-         "          \"max depth\": \"250e3\",\n"
-         "          \"temperature\": \"150\"\n"
-         "         }\n"
-         "       }\n"
-         "     },\n"
-         "    \"\": \n"
-         "    {\n"
-         "      \"model\": \"continental plate\",\n"
-         "      \"name\": \"Rest\",\n"
-         "      \"max depth\": \"300e3\",\n"
-         "      \"coordinates\": \n"
-         "      {\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"2000e3\",\n"
-         "          \"\": \"2000e3\"\n"
-         "         },\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"1000e3\",\n"
-         "          \"\": \"2000e3\"\n"
-         "         },\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"1000e3\",\n"
-         "          \"\": \"1000e3\"\n"
-         "         },\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"2000e3\",\n"
-         "          \"\": \"1000e3\"\n"
-         "         }\n"
-         "       },\n"
-         "      \"temperature models\": \n"
-         "      {\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"model\": \"uniform\",\n"
-         "          \"max depth\": \"250e3\",\n"
-         "          \"temperature\": \"20\"\n"
-         "         }\n"
-         "       },\n"
-         "      \"composition models\": \n"
-         "      {\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"model\": \"uniform\",\n"
-         "          \"max depth\": \"250e3\",\n"
-         "          \"compositions\": \n"
-         "          {\n"
-         "            \"\": \"2\"\n"
-         "           }\n"
-         "         }\n"
-         "       }\n"
-         "     },\n"
-         "    \"\": \n"
-         "    {\n"
-         "      \"model\": \"continental plate\",\n"
-         "      \"name\": \"Caribbean2\",\n"
-         "      \"max depth\": \"300e3\",\n"
-         "      \"coordinates\": \n"
-         "      {\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"-1e3\",\n"
-         "          \"\": \"500e3\"\n"
-         "         },\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"500e3\",\n"
-         "          \"\": \"500e3\"\n"
-         "         },\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"500e3\",\n"
-         "          \"\": \"1000e3\"\n"
-         "         },\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"\": \"-1e3\",\n"
-         "          \"\": \"1000e3\"\n"
-         "         }\n"
-         "       },\n"
-         "      \"temperature models\": \n"
-         "      {\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"model\": \"uniform\",\n"
-         "          \"min depth\": \"0\",\n"
-         "          \"max depth\": \"250e3\",\n"
-         "          \"temperature\": \"150\"\n"
-         "         }\n"
-         "       },\n"
-         "      \"composition models\": \n"
-         "      {\n"
-         "        \"\": \n"
-         "        {\n"
-         "          \"model\": \"uniform\",\n"
-         "          \"min depth\": \"0\",\n"
-         "          \"max depth\": \"250e3\",\n"
-         "          \"compositions\": \n"
-         "          {\n"
-         "            \"\": \"3\"\n"
-         "           }\n"
-         "         }\n"
-         "       }\n"
-         "     }\n"
-         "   }\n"
-         " }";
-  approval_tests.emplace_back(Utilities::print_tree(tree, 0));
-}*/
-
-TEST_CASE("WorldBuilder Parameters")
-{
-  std::vector<double> approval_tests;
-
-  // First test a world builder file with a cross section defined
-  std::string file = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/type_data.json";
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_cartesian.wb";
-  WorldBuilder::World world(file_name);
-
-  world.parse_entries(world.parameters);
-  approval_tests.emplace_back(std::isinf(world.parameters.coordinate_system->max_model_depth()));
-
-  Parameters prm(world);
-  prm.initialize(file);
-
-  world.parameters.coordinate_system.swap(prm.coordinate_system);
-
-  CHECK_THROWS_WITH(prm.get<unsigned int>("non existent unsigned int"),
-                    Contains("internal error: could not retrieve the default value at"));
-
-  CHECK(prm.get<unsigned int>("unsigned int") == 4);
-
-  CHECK_THROWS_WITH(prm.get<size_t>("non existent unsigned int"),
-                    Contains("internal error: could not retrieve the default value at"));
-
-  CHECK(prm.get<size_t>("unsigned int") == 4);
-
-
-  CHECK_THROWS_WITH(prm.get<double>("non existent double"),
-                    Contains("internal error: could not retrieve the default value at"));
-
-  CHECK(prm.get<double>("double") == Approx(1.23456e2));
-
-
-  CHECK_THROWS_WITH(prm.get<double>("string"),
-                    Contains("Could not convert values of"));
-
-  CHECK_THROWS_WITH(prm.get<std::string>("non existent string"),
-                    Contains("internal error: could not retrieve the default value at"));
-
-  CHECK(prm.get<std::string>("string") == "mystring 0");
-  prm.enter_subsection("properties");
-
-  {
-    WorldBuilder::World world_temp(file_name);
-    Parameters prm_temp(world_temp);
-    prm_temp.declare_entry("test",Types::OneOf(Types::OneOf(Types::Double(101),Types::Double(102)),Types::Double(103)),"doc");
-
-    CHECK(rapidjson::Pointer("/test/oneOf/0/oneOf/0/default value").Get(prm_temp.declarations)->GetDouble() == Approx(101.));
-    CHECK(rapidjson::Pointer("/test/oneOf/0/oneOf/1/default value").Get(prm_temp.declarations)->GetDouble() == Approx(102.));
-    CHECK(rapidjson::Pointer("/test/oneOf/1/default value").Get(prm_temp.declarations)->GetDouble() == Approx(103.));
-  }
-  prm.declare_entry("one value at points one value string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
-                    "Documentation");
-  prm.declare_entry("array value at points one value string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
-                    "Documentation");
-  prm.declare_entry("value at points set ap val string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
-                    "Documentation");
-  prm.declare_entry("value at points set ap p1 string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
-                    "Documentation");
-  prm.declare_entry("value at points set ap p2 string",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
-                    "Documentation");
-  prm.declare_entry("one value at points one value",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
-                    "Documentation");
-  prm.declare_entry("array value at points one value",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
-                    "Documentation");
-  prm.declare_entry("value at points",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
-                    "Documentation");
-  prm.declare_entry("value at points default ap",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., 2.))),
-                    "Documentation");
-  prm.declare_entry("value at array full",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., std::numeric_limits<uint64_t>::max()))),
-                    "Documentation");
-  prm.declare_entry("value at array",Types::OneOf(Types::Double(101.),Types::Array(Types::ValueAtPoints(101., std::numeric_limits<uint64_t>::max()))),
-                    "Documentation");
-  prm.declare_entry("vector for vector or double", Types::OneOf(Types::Double(-1), Types::Array(Types::Array(Types::Double(-1), 1), 1)),
-                    "Documentation");
-  prm.leave_subsection();
-  const std::vector<Point<2> > additional_points = {Point<2>(-10,-10,cartesian),Point<2>(-10,10,cartesian),
-                                                    Point<2>(10,10,cartesian),Point<2>(10,-10,cartesian)
-                                                   };
-  CHECK_THROWS_WITH(prm.get("value at points non existent",additional_points), Contains("internal error: could not retrieve"));
-  std::pair<std::vector<double>,std::vector<double>> v_at_p_one_value = prm.get("one value at points one value",additional_points);
-
-  approval_tests.emplace_back(static_cast<double>(v_at_p_one_value.first.size()));
-  approval_tests.emplace_back(static_cast<double>(v_at_p_one_value.first[0]));
-  approval_tests.emplace_back(static_cast<double>(v_at_p_one_value.second.size()));
-
-  {
-    const Objects::Surface surface(v_at_p_one_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(0,0,CoordinateSystem::cartesian)).interpolated_value);
-  }
-  std::pair<std::vector<double>,std::vector<double>> v_at_p_one_array_value = prm.get("array value at points one value",additional_points);
-
-  approval_tests.emplace_back(static_cast<double>(v_at_p_one_array_value.first.size()));
-  approval_tests.emplace_back(static_cast<double>(v_at_p_one_array_value.first[0]));
-  approval_tests.emplace_back(static_cast<double>(v_at_p_one_array_value.second.size()));
-
-  std::pair<std::vector<double>,std::vector<double>> v_at_p_full_default = prm.get("value at points",additional_points);
-
-  approval_tests.emplace_back(static_cast<double>(v_at_p_full_default.first.size()));
-  approval_tests.emplace_back(static_cast<double>(v_at_p_full_default.first[0]));
-  approval_tests.emplace_back(static_cast<double>(v_at_p_full_default.second.size()));
-
-  std::pair<std::vector<double>,std::vector<double>> v_at_p_dap = prm.get("value at points default ap",additional_points);
-
-  approval_tests.emplace_back(static_cast<double>(v_at_p_dap.first.size()));
-  approval_tests.emplace_back(v_at_p_dap.first[0]);
-  approval_tests.emplace_back(v_at_p_dap.first[1]);
-  approval_tests.emplace_back(v_at_p_dap.first[2]);
-  approval_tests.emplace_back(v_at_p_dap.first[3]);
-  approval_tests.emplace_back(v_at_p_dap.first[4]);
-  approval_tests.emplace_back(v_at_p_dap.first[5]);
-  approval_tests.emplace_back(v_at_p_dap.first[6]);
-  approval_tests.emplace_back(static_cast<double>(v_at_p_dap.second.size()));
-  approval_tests.emplace_back(v_at_p_dap.second[0]);
-  approval_tests.emplace_back(v_at_p_dap.second[1]);
-  approval_tests.emplace_back(v_at_p_dap.second[2]);
-  approval_tests.emplace_back(v_at_p_dap.second[3]);
-  approval_tests.emplace_back(v_at_p_dap.second[4]);
-  approval_tests.emplace_back(v_at_p_dap.second[5]);
-  approval_tests.emplace_back(v_at_p_dap.second[6]);
-  approval_tests.emplace_back(v_at_p_dap.second[7]);
-  approval_tests.emplace_back(v_at_p_dap.second[8]);
-  approval_tests.emplace_back(v_at_p_dap.second[9]);
-  approval_tests.emplace_back(v_at_p_dap.second[10]);
-  approval_tests.emplace_back(v_at_p_dap.second[11]);
-  approval_tests.emplace_back(v_at_p_dap.second[12]);
-  approval_tests.emplace_back(v_at_p_dap.second[13]);
-
-  {
-    const Objects::Surface surface(v_at_p_dap);
-
-    approval_tests.emplace_back(surface.local_value(Point<2>(0,0,CoordinateSystem::cartesian)).interpolated_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(0.99,1.99,CoordinateSystem::cartesian)).interpolated_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(1.01,2.01,CoordinateSystem::cartesian)).interpolated_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(0.99,0.99,CoordinateSystem::cartesian)).interpolated_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(1.01,1.01,CoordinateSystem::cartesian)).interpolated_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(2.99,3.99,CoordinateSystem::cartesian)).interpolated_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(2.01,4.01,CoordinateSystem::cartesian)).interpolated_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(-0.5,7.48,CoordinateSystem::cartesian)).interpolated_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(-1,7.6,CoordinateSystem::cartesian)).interpolated_value);
-    approval_tests.emplace_back(surface.local_value(Point<2>(-2.4,8.2,CoordinateSystem::cartesian)).interpolated_value);
-    CHECK_THROWS_WITH(surface.local_value(Point<2>(11,11,CoordinateSystem::cartesian)), Contains("The requested point was not in any triangle."));
-  }
-
-
-  CHECK_THROWS_WITH(prm.get("one value at points one value string",additional_points),
-                    Contains("Could not convert values of /one value at points one value string into a double. The provided value was \"test1\"."));
-  CHECK_THROWS_WITH(prm.get("array value at points one value string",additional_points),
-                    Contains("Could not convert values of /array value at points one value string/0/0 into a double. The provided value was \"test2\"."));
-  CHECK_THROWS_WITH(prm.get("value at points set ap val string",additional_points),
-                    Contains("Could not convert values of /value at points set ap val string/2/0 into doubles. The provided value was \"test3\"."));
-  CHECK_THROWS_WITH(prm.get("value at points set ap p1 string",additional_points),
-                    Contains("Could not convert values of /value at points set ap p1 string/3/1/0/0 into a Point<2> array, because it could not convert the 1st sub-elements into doubles. The provided value was \"test4\"."));
-  CHECK_THROWS_WITH(prm.get("value at points set ap p2 string",additional_points),
-                    Contains("Could not convert values of /value at points set ap p2 string/3/1/0/1 into a Point<2> array, because it could not convert the 2nd sub-elements into doubles. The provided value was \"test5\"."));
-
-
-  CHECK_THROWS_WITH(prm.get_vector<unsigned int>("non existent unsigned int vector"),
-                    Contains("internal error: could not retrieve the minItems value at"));
-
-  CHECK_THROWS_WITH(prm.get_vector<bool>("non existent bool vector"),
-                    Contains("internal error: could not retrieve the minItems value at"));
-
-
-  typedef std::array<double,3> array_3d;
-  CHECK_THROWS_WITH(prm.get_vector<array_3d>("vector of 3d arrays nan"),
-                    Contains("Could not convert values of /vector of 3d arrays nan/0 into doubles."));
-
-  using array_3x3 = std::array<std::array<double, 3>, 3>;
-  CHECK_THROWS_WITH(prm.get_vector<array_3x3>("vector of 3x3 arrays nan"),
-                    Contains("Could not convert values of /vector of 3x3 arrays nan/0 into doubles."));
-
-
-  using array_3x3 = std::array<std::array<double, 3>, 3>;
-  CHECK_THROWS_WITH(prm.get_vector<array_3x3>("vector of 3x3 arrays not 3x3 1"),
-                    Contains("Array 0 is supposed to be a 3x3 array, but the inner array dimensions of 0 is 2."));
-
-
-  CHECK_THROWS_WITH(prm.get_vector<array_3x3>("vector of 3x3 arrays not 3x3 2"),
-                    Contains("Array 1 is supposed to be a 3x3 array, but the outer array dimensions is 2."));
-
-
-  prm.enter_subsection("properties");
-  {
-    prm.declare_entry("now existent unsigned int vector",
-                      Types::Array(Types::UnsignedInt(1),2),
-                      "This is an array of two points along where the cross section is taken");
-  }
-  prm.leave_subsection();
-
-  std::vector<unsigned int> v_int = prm.get_vector<unsigned int>("now existent unsigned int vector");
-  approval_tests.emplace_back(static_cast<double>(v_int.size()));
-  approval_tests.emplace_back(static_cast<double>(v_int[0]));
-  approval_tests.emplace_back(static_cast<double>(v_int[1]));
-
-  v_int = prm.get_vector<unsigned int>("unsigned int array");
-  approval_tests.emplace_back(static_cast<double>(v_int.size()));
-  approval_tests.emplace_back(static_cast<double>(v_int[0]));
-  approval_tests.emplace_back(static_cast<double>(v_int[1]));
-  approval_tests.emplace_back(static_cast<double>(v_int[2]));
-
-  CHECK_THROWS_WITH(prm.get_vector<size_t>("non existent unsigned int vector"),
-                    Contains("internal error: could not retrieve the minItems value"));
-
-
-
-  std::vector<size_t> v_size_t = prm.get_vector<size_t>("now existent unsigned int vector");
-  approval_tests.emplace_back(static_cast<double>(v_size_t.size()));
-  approval_tests.emplace_back(static_cast<double>(v_size_t[0]));
-  approval_tests.emplace_back(static_cast<double>(v_size_t[1]));
-
-  v_size_t = prm.get_vector<size_t>("unsigned int array");
-  approval_tests.emplace_back(static_cast<double>(v_size_t.size()));
-  approval_tests.emplace_back(static_cast<double>(v_size_t[0]));
-  approval_tests.emplace_back(static_cast<double>(v_size_t[1]));
-  approval_tests.emplace_back(static_cast<double>(v_size_t[2]));
-
-
-  CHECK_THROWS_WITH(prm.get_vector<size_t>("non existent unsigned int vector"),
-                    Contains("internal error: could not retrieve the minItems value"));
-
-  prm.enter_subsection("properties");
-  {
-    prm.declare_entry("now existent bool vector",
-                      Types::Array(Types::Bool(true),2),
-                      "This is an array of two bools.");
-  }
-  prm.leave_subsection();
-
-  std::vector<bool> v_bool = prm.get_vector<bool>("now existent bool vector");
-  approval_tests.emplace_back(static_cast<double>(v_bool.size()));
-  approval_tests.emplace_back(static_cast<double>(v_bool[0]));
-  approval_tests.emplace_back(static_cast<double>(v_bool[1]));
-
-  v_bool = prm.get_vector<bool>("bool array");
-  approval_tests.emplace_back(static_cast<double>(v_bool.size()));
-  approval_tests.emplace_back(static_cast<double>(v_bool[0]));
-  approval_tests.emplace_back(static_cast<double>(v_bool[1]));
-  approval_tests.emplace_back(static_cast<double>(v_bool[2]));
-  approval_tests.emplace_back(static_cast<double>(v_bool[3]));
-  approval_tests.emplace_back(static_cast<double>(v_bool[4]));
-  approval_tests.emplace_back(static_cast<double>(v_bool[1]));
-
-  CHECK_THROWS_WITH(prm.get_vector<bool>("bool array nob"),
-                    Contains("IsBool()"));
-
-
-  CHECK_THROWS_WITH(prm.get_vector<double>("non existent double vector"),
-                    Contains("internal error: could not retrieve the minItems value at"));
-
-  prm.enter_subsection("properties");
-  {
-    prm.declare_entry("now existent double vector",
-                      Types::Array(Types::Double(2.4),2),
-                      "This is an array of two points along where the cross section is taken");
-  }
-  prm.leave_subsection();
-
-  std::vector<double> v_double = prm.get_vector<double>("now existent double vector");
-  approval_tests.emplace_back(static_cast<double>(v_double.size()));
-  approval_tests.emplace_back(v_double[0]);
-  approval_tests.emplace_back(v_double[1]);
-
-  CHECK_THROWS_WITH(prm.get<Point<2> >("string array"),
-                    Contains("Could not convert values of /string array into Point<2>, because it could not convert the sub-elements into doubles."));
-
-  v_double = prm.get_vector<double>("double array");
-  approval_tests.emplace_back(static_cast<double>(v_double.size()));
-  approval_tests.emplace_back(v_double[0]);
-  approval_tests.emplace_back(v_double[1]);
-  approval_tests.emplace_back(v_double[2]);
-
-  CHECK_THROWS_WITH(prm.get_vector<Point<2> >("point<2> array nan"),
-                    Contains("Could not convert values of /point<2> array nan/0 into a Point<2> array, because it could not convert the sub-elements into doubles."));
-
-  std::vector<std::array<std::array<double,3>,3> > v_3x3_array = prm.get_vector<std::array<std::array<double,3>,3> >("vector of 3x3 arrays");
-  approval_tests.emplace_back(static_cast<double>(v_3x3_array.size()));
-  approval_tests.emplace_back(v_3x3_array[0][0][0]);
-  approval_tests.emplace_back(v_3x3_array[0][0][1]);
-  approval_tests.emplace_back(v_3x3_array[0][0][2]);
-  approval_tests.emplace_back(v_3x3_array[0][1][0]);
-  approval_tests.emplace_back(v_3x3_array[0][1][1]);
-  approval_tests.emplace_back(v_3x3_array[0][1][2]);
-  approval_tests.emplace_back(v_3x3_array[0][2][0]);
-  approval_tests.emplace_back(v_3x3_array[0][2][1]);
-  approval_tests.emplace_back(v_3x3_array[0][2][2]);
-
-  approval_tests.emplace_back(v_3x3_array[1][0][0]);
-  approval_tests.emplace_back(v_3x3_array[1][0][1]);
-  approval_tests.emplace_back(v_3x3_array[1][0][2]);
-  approval_tests.emplace_back(v_3x3_array[1][1][0]);
-  approval_tests.emplace_back(v_3x3_array[1][1][1]);
-  approval_tests.emplace_back(v_3x3_array[1][1][2]);
-  approval_tests.emplace_back(v_3x3_array[1][2][0]);
-  approval_tests.emplace_back(v_3x3_array[1][2][1]);
-  approval_tests.emplace_back(v_3x3_array[1][2][2]);
-
-  std::vector<std::vector<Point<2> > > v_v_p2 = prm.get_vector<std::vector<Point<2>>>("vector of vectors of points<2>");
-  approval_tests.emplace_back(static_cast<double>(v_v_p2.size()));
-  approval_tests.emplace_back(static_cast<double>(v_v_p2[0].size()));
-  approval_tests.emplace_back(v_v_p2[0][0][0]);
-  approval_tests.emplace_back(v_v_p2[0][0][1]);
-  approval_tests.emplace_back(v_v_p2[0][1][0]);
-  approval_tests.emplace_back(v_v_p2[0][1][1]);
-
-  approval_tests.emplace_back(static_cast<double>(v_v_p2[1].size()));
-  approval_tests.emplace_back(v_v_p2[1][0][0]);
-  approval_tests.emplace_back(v_v_p2[1][0][1]);
-  approval_tests.emplace_back(v_v_p2[1][1][0]);
-  approval_tests.emplace_back(v_v_p2[1][1][1]);
-  approval_tests.emplace_back(v_v_p2[1][2][0]);
-  approval_tests.emplace_back(v_v_p2[1][2][1]);
-
-
-  CHECK_THROWS_WITH(prm.get_vector<std::vector<Point<2>>>("vector of vectors of points<2> nan"),
-                    Contains("Could not convert values of /vector of vectors of points<2> nan/1 into doubles"));
-
-
-  std::pair<std::vector<double>,std::vector<double>> value_at_array = prm.get_value_at_array("value at array full");
-  approval_tests.emplace_back(static_cast<double>(value_at_array.first.size()));
-  approval_tests.emplace_back(value_at_array.first[0]);
-  approval_tests.emplace_back(value_at_array.first[1]);
-
-  approval_tests.emplace_back(static_cast<double>(value_at_array.second.size()));
-  approval_tests.emplace_back(value_at_array.second[0]);
-  approval_tests.emplace_back(value_at_array.second[1]);
-  approval_tests.emplace_back(value_at_array.second[2]);
-  approval_tests.emplace_back(value_at_array.second[3]);
-  approval_tests.emplace_back(value_at_array.second[4]);
-
-
-  std::pair<std::vector<double>,std::vector<double>> double_value_at_array = prm.get_value_at_array("one value at points one value");
-  approval_tests.emplace_back(static_cast<double>(double_value_at_array.first.size()));
-  approval_tests.emplace_back(double_value_at_array.first[0]);
-  approval_tests.emplace_back(static_cast<double>(double_value_at_array.second.size()));
-  approval_tests.emplace_back(double_value_at_array.second[0]);
-
-  std::pair<std::vector<double>,std::vector<double>> default_value_at_array = prm.get_value_at_array("value at array");
-  approval_tests.emplace_back(static_cast<double>(default_value_at_array.first.size()));
-  approval_tests.emplace_back(default_value_at_array.first[0]);
-  approval_tests.emplace_back(static_cast<double>(default_value_at_array.second.size()));
-  approval_tests.emplace_back(default_value_at_array.second[0]);
-
-  std::vector<std::vector<double>> vector_for_vector_or_double = prm.get_vector_or_double("vector for vector or double");
-  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double.size()));
-  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0].size()));
-  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0][0]));
-  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0][1]));
-  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0][2]));
-  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[0][3]));
-
-  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[1].size()));
-  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[1][0]));
-  approval_tests.emplace_back(static_cast<double>(vector_for_vector_or_double[1][1]));
-
-  std::vector<std::vector<double>> double_for_vector_or_double = prm.get_vector_or_double("one value at points one value");
-  approval_tests.emplace_back(static_cast<double>(double_for_vector_or_double.size()));
-  approval_tests.emplace_back(static_cast<double>(double_for_vector_or_double[0].size()));
-  approval_tests.emplace_back(static_cast<double>(double_for_vector_or_double[0][0]));
-  /*CHECK_THROWS_WITH(prm.get_vector<std::string>("non existent string vector"),
-                    Contains("internal error: could not retrieve the default value at"));
-
-  std::vector<std::string> v_string = prm.get_vector<std::string>("string array");
-  approval_tests.emplace_back(v_string[0]);
-  approval_tests.emplace_back(v_string[1]);*/
-
-  //prm.load_entry("Coordinate system", false, Types::CoordinateSystem("cartesian","This determines the coordinate system"));
-
-  // Test the UnsignedInt functions
-  /*CHECK_THROWS_WITH(prm.load_entry("non existent unsigned int", true, Types::UnsignedInt(1,"description")),
-                    Contains("Entry undeclared: non existent unsigned int"));
-
-  #ifndef NDEBUG
-  CHECK_THROWS_WITH(prm.get_unsigned_int("non existent unsigned int"),
-                    Contains("Could not find entry 'non existent unsigned int' not found. Make sure it is loaded or set"));
-  #endif
-  CHECK(prm.load_entry("non existent unsigned int", false, Types::UnsignedInt(1,"description")) == false);
-  CHECK(prm.get_unsigned_int("non existent unsigned int") == Approx(1.0));
-
-  prm.set_entry("new unsigned int", Types::UnsignedInt(2,"description"));
-  CHECK(prm.get_unsigned_int("new unsigned int") == Approx(2.0));
-
-  prm.load_entry("unsigned int", true, Types::UnsignedInt(3,"description"));
-  CHECK(prm.get_unsigned_int("unsigned int") == Approx(4.0));*/
-// Todo: redo this with the new type system.
-  /*
-    // Test the Double functions
-    CHECK_THROWS_WITH(prm.load_entry("non existent double", true, Types::Double(1,"description")),
-                      Contains("Entry undeclared: non existent"));
-
-  #ifndef NDEBUG
-    CHECK_THROWS_WITH(prm.get_double("non existent double"),
-                      Contains("Could not find entry 'non existent double' not found. Make sure it is loaded or set"));
-  #endif
-    CHECK(prm.load_entry("non existent double", false, Types::Double(1,"description")) == false);
-    CHECK(prm.get_double("non existent double") == Approx(1.0));
-
-    prm.set_entry("new double", Types::Double(2,"description"));
-    CHECK(prm.get_double("new double") == Approx(2.0));
-
-    prm.load_entry("double", true, Types::Double(3,"description"));
-    CHECK(prm.get_double("double") == 1.23456e2);
-
-
-    // Test the String functions
-    CHECK_THROWS_WITH(prm.load_entry("non existent string", true, Types::String("1","description")),
-                      Contains("Entry undeclared: non existent string"));
-
-  #ifndef NDEBUG
-    CHECK_THROWS_WITH(prm.get_string("non existent string"),
-                      Contains("Could not find entry 'non existent string' not found. Make sure it is loaded or set"));
-  #endif
-    CHECK(prm.load_entry("non exitent string", false, Types::String("1","description")) == false);
-    CHECK(prm.get_string("non exitent string") == "1");
-
-    prm.set_entry("new string", Types::String("2","description"));
-    CHECK(prm.get_string("new string") == "2");
-
-    prm.load_entry("string", true, Types::String("3","description"));
-    CHECK(prm.get_string("string") == "mystring 0");
-
-    // Test the Point functions
-    CHECK_THROWS_WITH(prm.load_entry("non existent 2d Point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description")),
-                      Contains("Could not find .non existent 2d Point, while it is set as required."));
-    CHECK_THROWS_WITH(prm.load_entry("non existent 3d Point", true, Types::Point<3>(Point<3>(1,2,3,cartesian),"description")),
-                      Contains("Could not find .non existent 3d Point, while it is set as required."));
-
-  #ifndef NDEBUG
-    CHECK_THROWS_WITH(prm.get_point<2>("non existent 2d Point"),
-                      Contains("Could not find entry 'non existent 2d Point' not found. Make sure it is loaded or set"));
-    CHECK_THROWS_WITH(prm.get_point<3>("non existent 3d Point"),
-                      Contains("Could not find entry 'non existent 3d Point' not found. Make sure it is loaded or set"));
-  #endif
-
-    CHECK(prm.load_entry("non existent 2d Point", false, Types::Point<2>(Point<2>(1,2,cartesian),"description")) == false);
-    CHECK(prm.load_entry("non existent 3d Point", false, Types::Point<3>(Point<3>(1,2,3,cartesian),"description")) == false);
-
-    CHECK(prm.get_point<2>("non existent 2d Point").get_array() == std::array<double,2> {1,2});
-    CHECK(prm.get_point<3>("non existent 3d Point").get_array() == std::array<double,3> {1,2,3});
-
-    prm.set_entry("new Point 2d", Types::Point<2>(Point<2>(3,4,cartesian),"description"));
-    prm.set_entry("new Point 3d", Types::Point<3>(Point<3>(5,6,7,cartesian),"description"));
-
-    CHECK(prm.get_point<2>("new Point 2d").get_array() == std::array<double,2> {3,4});
-    CHECK(prm.get_point<3>("new Point 3d").get_array() == std::array<double,3> {5,6,7});
-
-
-    prm.load_entry("2d point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description"));
-    prm.load_entry("3d point", true, Types::Point<3>(Point<3>(3,4,5,cartesian),"description"));
-
-    CHECK(prm.get_point<2>("2d point").get_array() == std::array<double,2> {10,11});
-    CHECK(prm.get_point<3>("3d point").get_array() == std::array<double,3> {12,13,14});
-
-    // Test the Array<Types::Double> functions
-    CHECK_THROWS_WITH(prm.load_entry("non existent double array", true, Types::Array(Types::Double(1,"description"),"description")),
-                      Contains("Could not find .non existent double array, while it is set as required."));
-
-  #ifndef NDEBUG
-    CHECK_THROWS_WITH(prm.get_array("non existent double array"),
-                      Contains("Could not find entry 'non existent double array' not found. Make sure it is loaded or set"));
-  #endif
-
-    CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Double(2,"description"),"description")) == false);
-
-  #ifndef NDEBUG
-    CHECK(prm.get_array<Types::Double>("non exitent double array").size() == 1);
-    CHECK(prm.get_array<Types::Double>("non exitent double array")[0].value == Approx(2.0));
-    CHECK(prm.get_array<Types::Double>("non exitent double array")[0].description == "description");
-  #endif
-    // This is not desired behavior, but it is not implemented yet.
-
-    prm.set_entry("new double array", Types::Array(Types::Double(3,"description"),"description"));
-    std::vector<Types::Double> set_typed_double =  prm.get_array<Types::Double >("new double array");
-    approval_tests.emplace_back(set_typed_double.size());
-    // This is not desired behavior, but it is not implemented yet.
-
-    prm.load_entry("double array", true, Types::Array(Types::Double(4,"description"),"description"));
-    std::vector<Types::Double> true_loaded_typed_double =  prm.get_array<Types::Double >("double array");
-    approval_tests.emplace_back(true_loaded_typed_double.size());
-    approval_tests.emplace_back(true_loaded_typed_double[0].value);
-    approval_tests.emplace_back(true_loaded_typed_double[1].value);
-    approval_tests.emplace_back(true_loaded_typed_double[2].value);
-
-
-    // Test the Array<Types::Point<2> > functions
-    CHECK_THROWS_WITH(prm.load_entry("non existent point<2> array", true, Types::Array(Types::Point<2>(Point<2>(1,2,cartesian),"description"),"description")),
-                      Contains("Could not find .non existent point<2> array, while it is set as required."));
-
-  #ifndef NDEBUG
-    CHECK_THROWS_WITH(prm.get_array("non existent point<2> array"),
-                      Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set"));
-  #endif
-    CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<2>(Point<2>(3,4,cartesian),"description"),"description")) == false);
-
-  #ifndef NDEBUG
-    CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("non existent point<2> array"),
-                      Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set."));
-    // This is not desired behavior, but it is not implemented yet.
-  #endif
-
-    prm.set_entry("new point<2> array", Types::Array(Types::Point<2>(Point<2>(5,6,cartesian),"description"),"description"));
-    std::vector<Types::Point<2> > set_typed_point_2d = prm.get_array<Types::Point<2> >("new point<2> array");
-    approval_tests.emplace_back(set_typed_point_2d.size());
-    // This is not desired behavior, but it is not implemented yet.
-
-    prm.load_entry("point<2> array", true, Types::Array(Types::Point<2>(Point<2>(7,8,cartesian),"description"),"description"));
-    std::vector<Types::Point<2> > true_loaded_typed_point_2d =  prm.get_array<Types::Point<2> >("point<2> array");
-    approval_tests.emplace_back(true_loaded_typed_point_2d.size());
-    CHECK(true_loaded_typed_point_2d[0].value.get_array() == std::array<double,2> {10,11});
-    CHECK(true_loaded_typed_point_2d[1].value.get_array() == std::array<double,2> {12,13});
-    CHECK(true_loaded_typed_point_2d[2].value.get_array() == std::array<double,2> {14,15});
-
-
-    // Test the Array<Types::Point<3> > functions
-    CHECK_THROWS_WITH(prm.load_entry("non existent point<3> array", true, Types::Array(Types::Point<3>(Point<3>(1,2,3,cartesian),"description"),"description")),
-                      Contains("Could not find .non existent point<3> array, while it is set as required."));
-
-  #ifndef NDEBUG
-    CHECK_THROWS_WITH(prm.get_array("non existent point<3> array"),
-                      Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set"));
-  #endif
-    CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<3>(Point<3>(4,5,6,cartesian),"description"),"description")) == false);
-
-  #ifndef NDEBUG
-    CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("non existent point<3> array"),
-                      Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set."));
-    // This is not desired behavior, but it is not implemented yet.
-  #endif
-
-    prm.set_entry("new point<3> array", Types::Array(Types::Point<3>(Point<3>(7,8,9,cartesian),"description"),"description"));
-    std::vector<Types::Point<3> > set_typed_point_3d = prm.get_array<Types::Point<3> >("new point<3> array");
-    approval_tests.emplace_back(set_typed_point_3d.size());
-    // This is not desired behavior, but it is not implemented yet.
-
-    prm.load_entry("point<3> array", true, Types::Array(Types::Point<3>(Point<3>(10,11,12,cartesian),"description"),"description"));
-    std::vector<Types::Point<3> > true_loaded_typed_point_3d =  prm.get_array<Types::Point<3> >("point<3> array");
-    approval_tests.emplace_back(true_loaded_typed_point_3d.size());
-    CHECK(true_loaded_typed_point_3d[0].value.get_array() == std::array<double,3> {20,21,22});
-    CHECK(true_loaded_typed_point_3d[1].value.get_array() == std::array<double,3> {23,24,25});
-    CHECK(true_loaded_typed_point_3d[2].value.get_array() == std::array<double,3> {26,27,28});
-
-  #ifndef NDEBUG
-    CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<2> array"),
-                      Contains("Could not get point<2> array, because it is not a 2d Point."));
-    CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<3> array"),
-                      Contains("Could not get point<3> array, because it is not a 3d Point."));
-
-    CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("point<3> array"),
-                      Contains("Could not get point<3> array, because it is not a 3d Point."));
-    CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("double array"),
-                      Contains("Could not get double array, because it is not a Double."));
-
-    CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("point<2> array"),
-                      Contains("Could not get point<2> array, because it is not a 2d Point."));
-    CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("double array"),
-                      Contains("Could not get double array, because it is not a Double."));
-  #endif
-
-    // Test the enter_subsection and leave_subsection functions
-    prm.enter_subsection("subsection 1");
-    {
-      // Test the UnsignedInt functions
-      / *CHECK_THROWS_WITH(prm.load_entry("non existent unsigned int", true, Types::UnsignedInt(1,"description")),
-                        Contains("Entry undeclared: subsection 1.non existent unsigned int"));
-
-      #ifndef NDEBUG
-      CHECK_THROWS_WITH(prm.get_unsigned_int("non existent unsigned int"),
-                        Contains("Could not find entry 'non existent unsigned int' not found. Make sure it is loaded or set"));
-      #endif
-
-      CHECK(prm.load_entry("non existent unsigned int", false, Types::UnsignedInt(1,"description")) == false);
-      CHECK(prm.get_unsigned_int("non existent unsigned int") == Approx(1.0));
-
-      prm.set_entry("new unsigned int", Types::UnsignedInt(2,"description"));
-      CHECK(prm.get_unsigned_int("new unsigned int") == Approx(2.0));
-
-      prm.load_entry("unsigned int", true, Types::UnsignedInt(3,"description"));
-      CHECK(prm.get_unsigned_int("unsigned int") == Approx(5.0));* /
-
-
-      // Test the Double functions
-      CHECK_THROWS_WITH(prm.load_entry("non existent double", true, Types::Double(1,"description")),
-                        Contains("Entry undeclared: subsection 1.non existent"));
-
-  #ifndef NDEBUG
-      CHECK_THROWS_WITH(prm.get_double("non existent double"),
-                        Contains("Could not find entry 'non existent double' not found. Make sure it is loaded or set"));
-  #endif
-
-      CHECK(prm.load_entry("non existent double", false, Types::Double(2,"description")) == false);
-      CHECK(prm.get_double("non existent double") == Approx(2.0));
-
-      prm.set_entry("new double", Types::Double(3,"description"));
-      CHECK(prm.get_double("new double") == Approx(3.0));
-
-      prm.load_entry("double", true, Types::Double(4,"description"));
-      CHECK(prm.get_double("double") == 2.23456e2);
-
-
-      // Test the String functions
-      CHECK_THROWS_WITH(prm.load_entry("non existent string", true, Types::String("2","description")),
-                        Contains("Entry undeclared: subsection 1.non existent string"));
-
-  #ifndef NDEBUG
-      CHECK_THROWS_WITH(prm.get_string("non existent string"),
-                        Contains("Could not find entry 'non existent string' not found. Make sure it is loaded or set"));
-  #endif
-
-      CHECK(prm.load_entry("non exitent string", false, Types::String("3","description")) == false);
-      CHECK(prm.get_string("non exitent string") == "3");
-
-      prm.set_entry("new string", Types::String("4","description"));
-      CHECK(prm.get_string("new string") == "4");
-
-      prm.load_entry("string", true, Types::String("5","description"));
-      CHECK(prm.get_string("string") == "mystring 1");
-
-      // Test the Point functions
-      CHECK_THROWS_WITH(prm.load_entry("non existent 2d Point", true, Types::Point<2>(Point<2>(3,4,cartesian),"description")),
-                        Contains("Could not find subsection 1.non existent 2d Point, while it is set as required."));
-      CHECK_THROWS_WITH(prm.load_entry("non existent 3d Point", true, Types::Point<3>(Point<3>(4,5,6,cartesian),"description")),
-                        Contains("Could not find subsection 1.non existent 3d Point, while it is set as required."));
-
-  #ifndef NDEBUG
-      CHECK_THROWS_WITH(prm.get_point<2>("non existent 2d Point"),
-                        Contains("Could not find entry 'non existent 2d Point' not found. Make sure it is loaded or set"));
-      CHECK_THROWS_WITH(prm.get_point<3>("non existent 3d Point"),
-                        Contains("Could not find entry 'non existent 3d Point' not found. Make sure it is loaded or set"));
-  #endif
-
-      CHECK(prm.load_entry("non existent 2d Point", false, Types::Point<2>(Point<2>(3,4,cartesian),"description")) == false);
-      CHECK(prm.load_entry("non existent 3d Point", false, Types::Point<3>(Point<3>(4,5,6,cartesian),"description")) == false);
-
-      CHECK(prm.get_point<2>("non existent 2d Point").get_array() == std::array<double,2> {3,4});
-      CHECK(prm.get_point<3>("non existent 3d Point").get_array() == std::array<double,3> {4,5,6});
-
-      prm.set_entry("new Point 2d", Types::Point<2>(Point<2>(5,6,cartesian),"description"));
-      prm.set_entry("new Point 3d", Types::Point<3>(Point<3>(7,8,9,cartesian),"description"));
-
-      CHECK(prm.get_point<2>("new Point 2d").get_array() == std::array<double,2> {5,6});
-      CHECK(prm.get_point<3>("new Point 3d").get_array() == std::array<double,3> {7,8,9});
-
-
-      prm.load_entry("2d point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description"));
-      prm.load_entry("3d point", true, Types::Point<3>(Point<3>(3,4,5,cartesian),"description"));
-
-      CHECK(prm.get_point<2>("2d point").get_array() == std::array<double,2> {15,16});
-      CHECK(prm.get_point<3>("3d point").get_array() == std::array<double,3> {17,18,19});
-
-
-      // Test the Array functions
-      CHECK_THROWS_WITH(prm.load_entry("non existent double array", true, Types::Array(Types::Double(1,"description"),"description")),
-                        Contains("Could not find subsection 1.non existent double array, while it is set as required."));
-
-  #ifndef NDEBUG
-      CHECK_THROWS_WITH(prm.get_array("non existent double array"),
-                        Contains("Could not find entry 'non existent double array' not found. Make sure it is loaded or set"));
-
-      CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Double(2,"description"),"description")) == false);
-      CHECK(prm.get_array<Types::Double>("non exitent double array").size() == 1);
-      CHECK(prm.get_array<Types::Double>("non exitent double array")[0].value == Approx(2.0));
-      CHECK(prm.get_array<Types::Double>("non exitent double array")[0].description == "description");
-      // This is not desired behavior, but it is not implemented yet.
-  #endif
-
-      prm.set_entry("new double array", Types::Array(Types::Double(3,"description"),"description"));
-      std::vector<Types::Double > set_typed_double =  prm.get_array<Types::Double >("new double array");
-      approval_tests.emplace_back(set_typed_double.size());
-      // This is not desired behavior, but it is not implemented yet.
-
-      prm.load_entry("double array", true, Types::Array(Types::Double(4,"description"),"description"));
-      std::vector<Types::Double > true_loaded_typed_double =  prm.get_array<Types::Double >("double array");
-      approval_tests.emplace_back(true_loaded_typed_double.size());
-      approval_tests.emplace_back(true_loaded_typed_double[0].value);
-      approval_tests.emplace_back(true_loaded_typed_double[1].value);
-      approval_tests.emplace_back(true_loaded_typed_double[2].value);
-
-      // Test the Array<Types::Point<2> > functions
-      CHECK_THROWS_WITH(prm.load_entry("non existent point<2> array", true, Types::Array(Types::Point<2>(Point<2>(1,2,cartesian),"description"),"description")),
-                        Contains("Could not find subsection 1.non existent point<2> array, while it is set as required."));
-
-  #ifndef NDEBUG
-      CHECK_THROWS_WITH(prm.get_array("non existent point<2> array"),
-                        Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set"));
-
-      CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<2>(Point<2>(3,4,cartesian),"description"),"description")) == false);
-      CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("non existent point<2> array"),
-                        Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set."));
-      // This is not desired behavior, but it is not implemented yet.
-  #endif
-
-      prm.set_entry("new point<2> array", Types::Array(Types::Point<2>(Point<2>(5,6,cartesian),"description"),"description"));
-      std::vector<Types::Point<2> > set_typed_point_2d = prm.get_array<Types::Point<2> >("new point<2> array");
-      approval_tests.emplace_back(set_typed_point_2d.size());
-      // This is not desired behavior, but it is not implemented yet.
-
-      prm.load_entry("point<2> array", true, Types::Array(Types::Point<2>(Point<2>(7,8,cartesian),"description"),"description"));
-      std::vector<Types::Point<2> > true_loaded_typed_point_2d =  prm.get_array<Types::Point<2> >("point<2> array");
-      approval_tests.emplace_back(true_loaded_typed_point_2d.size());
-      CHECK(true_loaded_typed_point_2d[0].value.get_array() == std::array<double,2> {20,21});
-      CHECK(true_loaded_typed_point_2d[1].value.get_array() == std::array<double,2> {22,23});
-      CHECK(true_loaded_typed_point_2d[2].value.get_array() == std::array<double,2> {24,25});
-
-
-      // Test the Array<Types::Point<3> > functions
-      CHECK_THROWS_WITH(prm.load_entry("non existent point<3> array", true, Types::Array(Types::Point<3>(Point<3>(1,2,3,cartesian),"description"),"description")),
-                        Contains("Could not find subsection 1.non existent point<3> array, while it is set as required."));
-
-  #ifndef NDEBUG
-      CHECK_THROWS_WITH(prm.get_array("non existent point<3> array"),
-                        Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set"));
-
-      CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<3>(Point<3>(4,5,6,cartesian),"description"),"description")) == false);
-      CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("non existent point<3> array"),
-                        Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set."));
-      // This is not desired behavior, but it is not implemented yet.
-  #endif
-
-      prm.set_entry("new point<3> array", Types::Array(Types::Point<3>(Point<3>(7,8,9,cartesian),"description"),"description"));
-      std::vector<Types::Point<3> > set_typed_point_3d = prm.get_array<Types::Point<3> >("new point<3> array");
-      approval_tests.emplace_back(set_typed_point_3d.size());
-      // This is not desired behavior, but it is not implemented yet.
-
-      prm.load_entry("point<3> array", true, Types::Array(Types::Point<3>(Point<3>(10,11,12,cartesian),"description"),"description"));
-      std::vector<Types::Point<3> > true_loaded_typed_point_3d =  prm.get_array<Types::Point<3> >("point<3> array");
-      approval_tests.emplace_back(true_loaded_typed_point_3d.size());
-      CHECK(true_loaded_typed_point_3d[0].value.get_array() == std::array<double,3> {30,31,32});
-      CHECK(true_loaded_typed_point_3d[1].value.get_array() == std::array<double,3> {33,34,35});
-      CHECK(true_loaded_typed_point_3d[2].value.get_array() == std::array<double,3> {36,37,38});
-
-  #ifndef NDEBUG
-      CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<2> array"),
-                        Contains("Could not get subsection 1.point<2> array, because it is not a 2d Point."));
-      CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<3> array"),
-                        Contains("Could not get subsection 1.point<3> array, because it is not a 3d Point."));
-
-      CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("point<3> array"),
-                        Contains("Could not get subsection 1.point<3> array, because it is not a 3d Point."));
-      CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("double array"),
-                        Contains("Could not get subsection 1.double array, because it is not a Double."));
-
-      CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("point<2> array"),
-                        Contains("Could not get subsection 1.point<2> array, because it is not a 2d Point."));
-      CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("double array"),
-                        Contains("Could not get subsection 1.double array, because it is not a Double."));
-  #endif
-
-      prm.enter_subsection("subsection 2");
-      {
-        // Test the UnsignedInt functions
-        / *CHECK_THROWS_WITH(prm.load_entry("non existent unsigned int", true, Types::UnsignedInt(1,"description")),
-                          Contains("Entry undeclared: subsection 1.subsection 2.non existent unsigned int"));
-
-        #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.get_unsigned_int("non existent unsigned int"),
-                          Contains("Could not find entry 'non existent unsigned int' not found. Make sure it is loaded or set"));
-        #endif
-
-        CHECK(prm.load_entry("non existent unsigned int", false, Types::UnsignedInt(1,"description")) == false);
-        CHECK(prm.get_unsigned_int("non existent unsigned int") == Approx(1.0));
-
-        prm.set_entry("new unsigned int", Types::UnsignedInt(2,"description"));
-        CHECK(prm.get_unsigned_int("new unsigned int") == Approx(2.0));
-
-        prm.load_entry("unsigned int", true, Types::UnsignedInt(3,"description"));
-        CHECK(prm.get_unsigned_int("unsigned int") == Approx(6.0));* /
-
-
-        // Test the Double functions
-        CHECK_THROWS_WITH(prm.load_entry("non existent double", true, Types::Double(3,"description")),
-                          Contains("Entry undeclared: subsection 1.subsection 2.non existent"));
-
-  #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.get_double("non existent double"),
-                          Contains("Could not find entry 'non existent double' not found. Make sure it is loaded or set"));
-  #endif
-
-        CHECK(prm.load_entry("non existent double", false, Types::Double(4,"description")) == false);
-        CHECK(prm.get_double("non existent double") == Approx(4.0));
-
-        prm.set_entry("new double", Types::Double(5,"description"));
-        CHECK(prm.get_double("new double") == Approx(5.0));
-
-        prm.load_entry("double", true, Types::Double(6,"description"));
-        CHECK(prm.get_double("double") == 3.23456e2);
-
-
-        // Test the String functions
-        CHECK_THROWS_WITH(prm.load_entry("non existent string", true, Types::String("3","description")),
-                          Contains("Entry undeclared: subsection 1.subsection 2.non existent string"));
-
-  #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.get_string("non existent string"),
-                          Contains("Could not find entry 'non existent string' not found. Make sure it is loaded or set"));
-  #endif
-
-        CHECK(prm.load_entry("non exitent string", false, Types::String("4","description")) == false);
-        CHECK(prm.get_string("non exitent string") == "4");
-
-        prm.set_entry("new string", Types::String("5","description"));
-        CHECK(prm.get_string("new string") == "5");
-
-        prm.load_entry("string", true, Types::String("6","description"));
-        CHECK(prm.get_string("string") == "mystring 2");
-
-        // Test the Point functions
-
-        CHECK_THROWS_WITH(prm.load_entry("non existent 2d Point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description")),
-                          Contains("Could not find subsection 1.subsection 2.non existent 2d Point, while it is set as required."));
-        CHECK_THROWS_WITH(prm.load_entry("non existent 3d Point", true, Types::Point<3>(Point<3>(1,2,3,cartesian),"description")),
-                          Contains("Could not find subsection 1.subsection 2.non existent 3d Point, while it is set as required."));
-
-  #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.get_point<2>("non existent 2d Point"),
-                          Contains("Could not find entry 'non existent 2d Point' not found. Make sure it is loaded or set"));
-        CHECK_THROWS_WITH(prm.get_point<3>("non existent 3d Point"),
-                          Contains("Could not find entry 'non existent 3d Point' not found. Make sure it is loaded or set"));
-  #endif
-
-        CHECK(prm.load_entry("non existent 2d Point", false, Types::Point<2>(Point<2>(1,2,cartesian),"description")) == false);
-        CHECK(prm.load_entry("non existent 3d Point", false, Types::Point<3>(Point<3>(1,2,3,cartesian),"description")) == false);
-
-        CHECK(prm.get_point<2>("non existent 2d Point").get_array() == std::array<double,2> {1,2});
-        CHECK(prm.get_point<3>("non existent 3d Point").get_array() == std::array<double,3> {1,2,3});
-
-        prm.set_entry("new Point 2d", Types::Point<2>(Point<2>(3,4,cartesian),"description"));
-        prm.set_entry("new Point 3d", Types::Point<3>(Point<3>(5,6,7,cartesian),"description"));
-
-        CHECK(prm.get_point<2>("new Point 2d").get_array() == std::array<double,2> {3,4});
-        CHECK(prm.get_point<3>("new Point 3d").get_array() == std::array<double,3> {5,6,7});
-
-
-        prm.load_entry("2d point", true, Types::Point<2>(Point<2>(1,2,cartesian),"description"));
-        prm.load_entry("3d point", true, Types::Point<3>(Point<3>(3,4,5,cartesian),"description"));
-
-        CHECK(prm.get_point<2>("2d point").get_array() == std::array<double,2> {20,21});
-        CHECK(prm.get_point<3>("3d point").get_array() == std::array<double,3> {22,23,24});
-
-        // Test the Array functions
-
-        CHECK_THROWS_WITH(prm.load_entry("non existent double array", true, Types::Array(Types::Double(1,"description"),"description")),
-                          Contains("Could not find subsection 1.subsection 2.non existent double array, while it is set as required."));
-  #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.get_array("non existent double array"),
-                          Contains("Could not find entry 'non existent double array' not found. Make sure it is loaded or set"));
-  #endif
-
-        CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Double(2,"description"),"description")) == false);
-
-        CHECK(prm.get_array<Types::Double >("non exitent double array").size() == 1);
-        CHECK(prm.get_array<Types::Double >("non exitent double array")[0].value == Approx(2.0));
-        CHECK(prm.get_array<Types::Double >("non exitent double array")[0].description == "description");
-
-        prm.set_entry("new double array", Types::Array(Types::Double(3,"description"),"description"));
-        std::vector<Types::Double > set_typed_double =  prm.get_array<Types::Double >("new double array");
-        approval_tests.emplace_back(set_typed_double.size());
-        // This is not desired behavior, but it is not implemented yet.
-
-        prm.load_entry("double array", true, Types::Array(Types::Double(4,"description"),"description"));
-        std::vector<Types::Double > true_loaded_typed_double =  prm.get_array<Types::Double >("double array");
-        approval_tests.emplace_back(true_loaded_typed_double.size());
-        approval_tests.emplace_back(true_loaded_typed_double[0].value);
-        approval_tests.emplace_back(true_loaded_typed_double[1].value);
-        approval_tests.emplace_back(true_loaded_typed_double[2].value);
-
-
-        // Test the Array<Types::Point<2> > functions
-  #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.load_entry("non existent point<2> array", true, Types::Array(Types::Point<2>(Point<2>(1,2,cartesian),"description"),"description")),
-                          Contains("Could not find subsection 1.subsection 2.non existent point<2> array, while it is set as required."));
-
-        CHECK_THROWS_WITH(prm.get_array("non existent point<2> array"),
-                          Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set"));
-  #endif
-
-        CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<2>(Point<2>(3,4,cartesian),"description"),"description")) == false);
-
-  #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("non existent point<2> array"),
-                          Contains("Could not find entry 'non existent point<2> array' not found. Make sure it is loaded or set."));
-        // This is not desired behavior, but it is not implemented yet.
-  #endif
-
-        prm.set_entry("new point<2> array", Types::Array(Types::Point<2>(Point<2>(5,6,cartesian),"description"),"description"));
-        std::vector<Types::Point<2> > set_typed_point_2d = prm.get_array<Types::Point<2> >("new point<2> array");
-        approval_tests.emplace_back(set_typed_point_2d.size());
-        // This is not desired behavior, but it is not implemented yet.
-
-        prm.load_entry("point<2> array", true, Types::Array(Types::Point<2>(Point<2>(7,8,cartesian),"description"),"description"));
-        std::vector<Types::Point<2> > true_loaded_typed_point_2d =  prm.get_array<Types::Point<2> >("point<2> array");
-        approval_tests.emplace_back(true_loaded_typed_point_2d.size());
-        CHECK(true_loaded_typed_point_2d[0].value.get_array() == std::array<double,2> {40,41});
-        CHECK(true_loaded_typed_point_2d[1].value.get_array() == std::array<double,2> {42,43});
-        CHECK(true_loaded_typed_point_2d[2].value.get_array() == std::array<double,2> {44,45});
-
-
-        // Test the Array<Types::Point<3> > functions
-  #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.load_entry("non existent point<3> array", true, Types::Array(Types::Point<3>(Point<3>(1,2,3,cartesian),"description"),"description")),
-                          Contains("Could not find subsection 1.subsection 2.non existent point<3> array, while it is set as required."));
-
-        CHECK_THROWS_WITH(prm.get_array("non existent point<3> array"),
-                          Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set"));
-  #endif
-
-        CHECK(prm.load_entry("non exitent double array", false, Types::Array(Types::Point<3>(Point<3>(4,5,6,cartesian),"description"),"description")) == false);
-
-  #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("non existent point<3> array"),
-                          Contains("Could not find entry 'non existent point<3> array' not found. Make sure it is loaded or set."));
-        // This is not desired behavior, but it is not implemented yet.
-  #endif
-
-        prm.set_entry("new point<3> array", Types::Array(Types::Point<3>(Point<3>(7,8,9,cartesian),"description"),"description"));
-        std::vector<Types::Point<3> > set_typed_point_3d = prm.get_array<Types::Point<3> >("new point<3> array");
-        approval_tests.emplace_back(set_typed_point_3d.size());
-        // This is not desired behavior, but it is not implemented yet.
-
-        prm.load_entry("point<3> array", true, Types::Array(Types::Point<3>(Point<3>(10,11,12,cartesian),"description"),"description"));
-        std::vector<Types::Point<3> > true_loaded_typed_point_3d =  prm.get_array<Types::Point<3> >("point<3> array");
-        approval_tests.emplace_back(true_loaded_typed_point_3d.size());
-        CHECK(true_loaded_typed_point_3d[0].value.get_array() == std::array<double,3> {40,41,42});
-        CHECK(true_loaded_typed_point_3d[1].value.get_array() == std::array<double,3> {43,44,45});
-        CHECK(true_loaded_typed_point_3d[2].value.get_array() == std::array<double,3> {46,47,48});
-
-  #ifndef NDEBUG
-        CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<2> array"),
-                          Contains("Could not get subsection 1.subsection 2.point<2> array, because it is not a 2d Point."));
-        CHECK_THROWS_WITH(prm.get_array<Types::Double >("point<3> array"),
-                          Contains("Could not get subsection 1.subsection 2.point<3> array, because it is not a 3d Point."));
-
-        CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("point<3> array"),
-                          Contains("Could not get subsection 1.subsection 2.point<3> array, because it is not a 3d Point."));
-        CHECK_THROWS_WITH(prm.get_array<Types::Point<2> >("double array"),
-                          Contains("Could not get subsection 1.subsection 2.double array, because it is not a Double."));
-
-        CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("point<2> array"),
-                          Contains("Could not get subsection 1.subsection 2.point<2> array, because it is not a 2d Point."));
-        CHECK_THROWS_WITH(prm.get_array<Types::Point<3> >("double array"),
-                          Contains("Could not get subsection 1.subsection 2.double array, because it is not a Double."));
-  #endif
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection();
-  */
-
-  // Todo: add tests for list,feature and coordinate system.
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-
-TEST_CASE("Euler angle functions")
-{
-  const std::vector<double> approval_tests;
-
-  // note, this is only testing consistency (can it convert back and forth) and
-  // it only works for rotation matrices which are defined in the same way (z-x-z).
-  {
-    auto rot1 = Utilities::euler_angles_to_rotation_matrix(-85,340,56);
-    auto ea1 = Utilities::euler_angles_from_rotation_matrix(rot1);
-    auto rot2 = Utilities::euler_angles_to_rotation_matrix(ea1[0],ea1[1],ea1[2]);
-    compare_rotation_matrices_approx(rot2, rot1);
-    auto ea2 = Utilities::euler_angles_from_rotation_matrix(rot2);
-    compare_3d_arrays_approx(ea2,ea1);
-    auto rot3 = Utilities::euler_angles_to_rotation_matrix(ea2[0],ea2[1],ea2[2]);
-    compare_rotation_matrices_approx(rot3, rot2);
-  }
-  {
-    auto rot1 = Utilities::euler_angles_to_rotation_matrix(90,180,270);
-    auto ea1 = Utilities::euler_angles_from_rotation_matrix(rot1);
-    auto rot2 = Utilities::euler_angles_to_rotation_matrix(ea1[0],ea1[1],ea1[2]);
-    compare_rotation_matrices_approx(rot2, rot1);
-    auto ea2 = Utilities::euler_angles_from_rotation_matrix(rot2);
-    compare_3d_arrays_approx(ea2,ea1);
-    auto rot3 = Utilities::euler_angles_to_rotation_matrix(ea2[0],ea2[1],ea2[2]);
-    compare_rotation_matrices_approx(rot3, rot2);
-  }
-
-  {
-    const std::array<double,3> ea0 = {{20,30,40}};
-    auto rot0 = Utilities::euler_angles_to_rotation_matrix(20,30,40);
-    auto ea1 = Utilities::euler_angles_from_rotation_matrix(rot0);
-    compare_3d_arrays_approx(ea1,ea0);
-    auto rot2 = Utilities::euler_angles_to_rotation_matrix(ea1[0],ea1[1],ea1[2]);
-    compare_rotation_matrices_approx(rot2, rot0);
-    auto ea2 = Utilities::euler_angles_from_rotation_matrix(rot2);
-    compare_3d_arrays_approx(ea2,ea1);
-    auto rot3 = Utilities::euler_angles_to_rotation_matrix(ea2[0],ea2[1],ea2[2]);
-    compare_rotation_matrices_approx(rot3, rot2);
-  }
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("GWB Bezier curve")
-{
-
-  std::vector<Point<2>> approval_tests;
-
-  std::vector<Point<2> > coordinates;
-  coordinates.emplace_back(0,10,cartesian);
-  coordinates.emplace_back(20,10,cartesian);
-  coordinates.emplace_back(30,20,cartesian);
-
-  const Objects::BezierCurve bezier_curve(coordinates);
-
-  approval_tests.emplace_back(bezier_curve(0,-0.1));
-  approval_tests.emplace_back(bezier_curve(0,0.0));
-  approval_tests.emplace_back(bezier_curve(0,0.1));
-  approval_tests.emplace_back(bezier_curve(0,0.2));
-  approval_tests.emplace_back(bezier_curve(0,0.3));
-  approval_tests.emplace_back(bezier_curve(0,0.4));
-  approval_tests.emplace_back(bezier_curve(0,0.5));
-  approval_tests.emplace_back(bezier_curve(0,0.6));
-  approval_tests.emplace_back(bezier_curve(0,0.7));
-  approval_tests.emplace_back(bezier_curve(0,0.8));
-  approval_tests.emplace_back(bezier_curve(0,0.9));
-  approval_tests.emplace_back(bezier_curve(0,1.0));
-  approval_tests.emplace_back(bezier_curve(0,1.1));
-
-  approval_tests.emplace_back(bezier_curve(1,-0.1));
-  approval_tests.emplace_back(bezier_curve(1,0.0));
-  approval_tests.emplace_back(bezier_curve(1,0.1));
-  approval_tests.emplace_back(bezier_curve(1,0.2));
-  approval_tests.emplace_back(bezier_curve(1,0.3));
-  approval_tests.emplace_back(bezier_curve(1,0.4));
-  approval_tests.emplace_back(bezier_curve(1,0.5));
-  approval_tests.emplace_back(bezier_curve(1,0.6));
-  approval_tests.emplace_back(bezier_curve(1,0.7));
-  approval_tests.emplace_back(bezier_curve(1,0.8));
-  approval_tests.emplace_back(bezier_curve(1,0.9));
-  approval_tests.emplace_back(bezier_curve(1,1.0));
-  approval_tests.emplace_back(bezier_curve(1,1.1));
-
-
-  const Objects::BezierCurve bezier_curve_defined(coordinates,
-  {
-    0.,Consts::PI,0.
-  });
-
-  approval_tests.emplace_back(bezier_curve_defined(0,-0.1));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.0));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.1));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.2));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.3));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.4));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.5));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.6));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.7));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.8));
-  approval_tests.emplace_back(bezier_curve_defined(0,0.9));
-  approval_tests.emplace_back(bezier_curve_defined(0,1.0));
-  approval_tests.emplace_back(bezier_curve_defined(0,1.1));
-
-  approval_tests.emplace_back(bezier_curve_defined(1,-0.1));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.0));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.1));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.2));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.3));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.4));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.5));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.6));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.7));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.8));
-  approval_tests.emplace_back(bezier_curve_defined(1,0.9));
-  approval_tests.emplace_back(bezier_curve_defined(1,1.0));
-  approval_tests.emplace_back(bezier_curve_defined(1,1.1));
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-
-TEST_CASE("WorldBuilder Utilities function: distance_point_from_curved_planes cartesian part 1")
-{
-  std::vector<double> approval_tests;
-
-  const std::unique_ptr<CoordinateSystems::Interface> cartesian_system = CoordinateSystems::Interface::create("cartesian", nullptr);;
-
-  //Todo:fix
-  //cartesian_system->declare_entries();
-
-  Point<3> position(10,0,0,cartesian);
-
-  Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(position,
-                                                                             *cartesian_system);
-  Point<2> reference_point(0,0,cartesian);
-
-  std::vector<Point<2> > coordinates;
-  coordinates.emplace_back(0,10,cartesian);
-  coordinates.emplace_back(20,10,cartesian);
-
-  std::vector<std::vector<double> > slab_segment_lengths(2);
-  slab_segment_lengths[0].push_back(std::sqrt(10*10+10*10));
-  slab_segment_lengths[0].push_back(200);
-  slab_segment_lengths[1].push_back(std::sqrt(10*10+10*10));
-  slab_segment_lengths[1].push_back(200);
-
-  const double dtr = Consts::PI/180;
-  std::vector<std::vector<Point<2> > > slab_segment_angles(2);
-  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
-
-  const double starting_radius = 10;
-
-  const std::vector<double> x_list = {0.,20.};
-  const std::vector<double> y_list = {10.,10.};
-  const std::vector<Point<2> > coordinate_list_local = coordinates;
-
-  Objects::BezierCurve bezier_curve(coordinate_list_local);
-
-  approval_tests.emplace_back(bezier_curve(0,-0.1)[0]);
-  approval_tests.emplace_back(bezier_curve(0,-0.1)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.0)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.0)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.1)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.1)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.2)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.2)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.3)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.3)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.4)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.4)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.5)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.5)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.6)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.6)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.7)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.7)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.8)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.8)[1]);
-  approval_tests.emplace_back(bezier_curve(0,0.9)[0]);
-  approval_tests.emplace_back(bezier_curve(0,0.9)[1]);
-  approval_tests.emplace_back(bezier_curve(0,1.0)[0]);
-  approval_tests.emplace_back(bezier_curve(0,1.0)[1]);
-  approval_tests.emplace_back(bezier_curve(0,1.1)[0]);
-  approval_tests.emplace_back(bezier_curve(0,1.1)[1]);
-
-
-  WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
-
-
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-4); // practically zero
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-5);
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.insert( approval_tests.end(), std::begin(distance_from_planes.closest_trench_point.get_array()),
-                         std::end(distance_from_planes.closest_trench_point.get_array()));
-
-
-  // center square test 2
-  reference_point[1] = 20;
-
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
-
-  // center square test 3
-  position[1] = 20;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
-
-  // center square test 4
-  reference_point[1] = 0;
-
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
-
-  // center square test 5
-  position[1] = -10;
-  position[2] = -10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
-
-  // begin section square test 6
-  position[0] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_section) < 1e-14);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.depth_reference_surface) > 1e-12 ? distance_from_planes.depth_reference_surface : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
-
-
-  // end section square test 7
-  position[0] = 20;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
-
-  // before begin section square test 8
-  position[0] = -10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  // The old method for slabs can not provide the corners when out of bounds and returns a nan. The new method can do this,
-  // and the old method is planned to be removed.
-  //CHECK(distance_from_planes.closest_trench_point.get_array() == std::array<double,3> {{NaN::DSNAN,NaN::DSNAN,10.}});
-
-
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.insert( approval_tests.end(), std::begin(distance_from_planes.closest_trench_point.get_array()), std::end(distance_from_planes.closest_trench_point.get_array()));
-
-
-  // beyond end section square test 9
-  position[0] = 25;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  // The old method for slabs can not provide the corners when out of bounds and returns a nan. The new method can do this,
-  // and the old method is planned to be removed.
-  //CHECK(distance_from_planes.closest_trench_point.get_array() == std::array<double,3> {{NaN::DSNAN,NaN::DSNAN,10.}});
-
-
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14); // practically zero
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
-
-
-  // beyond end section square test 10
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 5;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[0]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[1]);
-  approval_tests.emplace_back(distance_from_planes.closest_trench_point.get_array()[2]);
-
-  // beyond end section square test 10 (only positive version)
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 5;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 true,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-  // beyond end section square test 11
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = -5;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-  // beyond end section square test 11 (only positive version)
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = -5;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 true,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // add coordinate
-  position[0] = 25;
-  position[1] = 0;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  coordinates.emplace_back(30,10,cartesian);
-  bezier_curve = Objects::BezierCurve(coordinates);
-
-  slab_segment_lengths.resize(3);
-  slab_segment_lengths[2].push_back(std::sqrt(10*10+10*10));
-  slab_segment_lengths[2].push_back(200);
-
-  slab_segment_angles.resize(3);
-  slab_segment_angles[2].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[2].emplace_back(45 * dtr,45 * dtr,cartesian);
-
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14); // practically zero
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-12);
-
-  // different angle
-  slab_segment_angles[0][0][0] = 22.5 * dtr;
-  slab_segment_angles[0][0][1] = 22.5 * dtr;
-  slab_segment_angles[0][1][0] = 22.5 * dtr;
-  slab_segment_angles[0][1][1] = 22.5 * dtr;
-  slab_segment_angles[1][0][0] = 22.5 * dtr;
-  slab_segment_angles[1][0][1] = 22.5 * dtr;
-  slab_segment_angles[1][1][0] = 22.5 * dtr;
-  slab_segment_angles[1][1][1] = 22.5 * dtr;
-
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 10-10*tan(22.5*dtr);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane)<1e-10);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // check interpolation 1 (in the middle of a segment with 22.5 degree and a segment with 45)
-  position[0] = 25;
-  position[1] = 0;
-  position[2] = 10-10*tan((22.5*1.5)*dtr);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // check interpolation 2 (at the end of the segment at 45 degree)
-  position[0] = 30;
-  position[1] = 0;
-  position[2] = 10-10*tan(45*dtr);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // check length interpolation with 90 degree angles for simplicity
-  // check length interpolation first segment center 1
-  slab_segment_angles[0][0][0] = 90 * dtr;
-  slab_segment_angles[0][0][1] = 90 * dtr;
-  slab_segment_angles[0][1][0] = 90 * dtr;
-  slab_segment_angles[0][1][1] = 90 * dtr;
-  slab_segment_angles[1][0][0] = 90 * dtr;
-  slab_segment_angles[1][0][1] = 90 * dtr;
-  slab_segment_angles[1][1][0] = 90 * dtr;
-  slab_segment_angles[1][1][1] = 90 * dtr;
-  slab_segment_angles[2][0][0] = 90 * dtr;
-  slab_segment_angles[2][0][1] = 90 * dtr;
-  slab_segment_angles[2][1][0] = 90 * dtr;
-  slab_segment_angles[2][1][1] = 90 * dtr;
-
-  slab_segment_lengths[0][0] = 100;
-  slab_segment_lengths[0][1] = 100;
-  slab_segment_lengths[1][0] = 100;
-  slab_segment_lengths[1][1] = 100;
-  slab_segment_lengths[2][0] = 50;
-  slab_segment_lengths[2][1] = 50;
-
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = 10-100;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // check length interpolation first segment center 2
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = 10-101;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // check length interpolation first segment center 3
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = 10-200;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-
-  // check length interpolation first segment center 4
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = 10-201;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-
-  // Now check the center of the second segment, each segment should have a length of 75.
-  // check length interpolation second segment center 1
-  position[0] = 25;
-  position[1] = 10;
-  position[2] = 10-75;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // check length interpolation second segment center 2
-  position[0] = 25;
-  position[1] = 10;
-  position[2] = 10-76;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // check length interpolation second segment center 3
-  position[0] = 25;
-  position[1] = 10;
-  position[2] = 10-150;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-
-  // check length interpolation second segment center 4
-  position[0] = 25;
-  position[1] = 10;
-  position[2] = 10-151;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // Now check the end of the second segment, each segment should have a length of 50.
-  // check length interpolation second segment center 1
-  position[0] = 30;
-  position[1] = 10;
-  position[2] = 10-50;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // check length interpolation second segment center 2
-  position[0] = 30;
-  position[1] = 10;
-  position[2] = 10-51;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // practically zero
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // check length interpolation second segment center 3
-  position[0] = 30;
-  position[1] = 10;
-  position[2] = 10-100;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-
-  // check length interpolation second segment center 4
-  position[0] = 30;
-  position[1] = 10;
-  position[2] = 10-101;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder Utilities function: distance_point_from_curved_planes cartesian part 2")
-{
-  std::vector<double> approval_tests;
-
-  const std::unique_ptr<CoordinateSystems::Interface> cartesian_system = CoordinateSystems::Interface::create("cartesian", nullptr);;
-
-  //todo: fix
-  //cartesian_system->declare_entries();
-
-  Point<3> position(10,0,0,cartesian);
-  Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(position,
-                                                                             *cartesian_system);
-  Point<2> reference_point(0,0,cartesian);
-
-  std::vector<Point<2> > coordinates;
-  coordinates.emplace_back(0,10,cartesian);
-  coordinates.emplace_back(20,10,cartesian);
-  coordinates.emplace_back(30,10,cartesian);
-
-  std::vector<std::vector<double> > slab_segment_lengths(3);
-  slab_segment_lengths[0].push_back(std::sqrt(10*10+10*10));
-  slab_segment_lengths[0].push_back(200);
-  slab_segment_lengths[1].push_back(std::sqrt(10*10+10*10));
-  slab_segment_lengths[1].push_back(200);
-  slab_segment_lengths[2].push_back(std::sqrt(10*10+10*10));
-  slab_segment_lengths[2].push_back(200);
-
-  const double dtr = Consts::PI/180;
-  std::vector<std::vector<Point<2> > > slab_segment_angles(3);
-  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[2].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[2].emplace_back(45 * dtr,45 * dtr,cartesian);
-
-  const double starting_radius = 10;
-  // Now test the curves into the depth
-  // curve test 1
-
-  slab_segment_angles[0][0][0] = 0.0 * dtr;
-  slab_segment_angles[0][0][1] = 45.0 * dtr;
-  slab_segment_angles[0][1][0] = 45.0 * dtr;
-  slab_segment_angles[0][1][1] = 90.0 * dtr;
-  slab_segment_angles[1][0][0] = 0.0 * dtr;
-  slab_segment_angles[1][0][1] = 45.0 * dtr;
-  slab_segment_angles[1][1][0] = 45.0 * dtr;
-  slab_segment_angles[1][1][1] = 90.0 * dtr;
-  slab_segment_angles[2][0][0] = 90 * dtr;
-  slab_segment_angles[2][0][1] = 90 * dtr;
-  slab_segment_angles[2][1][0] = 90 * dtr;
-  slab_segment_angles[2][1][1] = 90 * dtr;
-
-  slab_segment_lengths[0][0] = 10 * 45 * dtr;
-  slab_segment_lengths[0][1] = 10 * 45 * dtr;
-  slab_segment_lengths[1][0] = 10 * 45 * dtr;
-  slab_segment_lengths[1][1] = 10 * 45 * dtr;
-  slab_segment_lengths[2][0] = 5;
-  slab_segment_lengths[2][1] = 5;
-
-
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-
-
-  const std::vector<double> x_list = {0.,20., 30.};
-  const std::vector<double> y_list = {10.,10., 10.};
-  const std::vector<Point<2> > coordinate_list_local = coordinates;
-  const Objects::BezierCurve bezier_curve(coordinates);
-
-  WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinate_list_local,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-10);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-  // curve test 2
-  position[0] = 10;
-  position[1] = 5;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about 5 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-  // curve test 3
-  position[0] = 10;
-  position[1] = -5;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -5 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-
-  // curve test 4
-  position[0] = 10;
-  position[1] = 10 - 10 * sqrt(2)/2;
-  position[2] = 10 * sqrt(2)/2;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-  // curve test 5
-  position[0] = 10;
-  position[1] = 10 - 10 * sqrt(2);
-  position[2] = 10 * sqrt(2);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -10 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-  // curve test 6
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane)); // checked that it should be about 10 this with a drawing
-  // This is a special case where the point coincides with the center of the circle.
-  // Because all the points on the circle are equally close, we have chosen in the
-  // code to define this case as that this point belongs to the top of the top segment
-  // where the check point has angle 0. This means that the distanceAlongPlate is zero.
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-
-  // curve test 7
-  position[0] = 10;
-  position[1] = -5;
-  position[2] = -1;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-  // curve test 8
-  slab_segment_lengths[0][0] = 5 * 45 * dtr;
-  slab_segment_lengths[0][1] = 5 * 45 * dtr;
-  slab_segment_lengths[1][0] = 5 * 45 * dtr;
-  slab_segment_lengths[1][1] = 5 * 45 * dtr;
-
-  position[0] = 10;
-  position[1] = 5;
-  position[2] = 5;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-  // curve test 9
-  position[0] = 10;
-  position[1] = 10 - 5 * sqrt(2)/2;
-  position[2] = 5 + 5 * sqrt(2)/2;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-  // curve test 10
-  slab_segment_angles[0][0][0] = 0.0 * dtr;
-  slab_segment_angles[0][0][1] = 90.0 * dtr;
-  slab_segment_angles[0][1][0] = 90.0 * dtr;
-  slab_segment_angles[0][1][1] = 180.0 * dtr;
-  slab_segment_angles[1][0][0] = 0.0 * dtr;
-  slab_segment_angles[1][0][1] = 90.0 * dtr;
-  slab_segment_angles[1][1][0] = 90.0 * dtr;
-  slab_segment_angles[1][1][1] = 180.0 * dtr;
-
-  slab_segment_lengths[0][0] = 10 * 90 * dtr;
-  slab_segment_lengths[0][1] = 10 * 90 * dtr;
-  slab_segment_lengths[1][0] = 10 * 90 * dtr;
-  slab_segment_lengths[1][1] = 10 * 90 * dtr;
-
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 11
-  position[0] = 10;
-  position[1] = 10 - 10 * sqrt(2)/2;
-  position[2] = 10 * sqrt(2)/2;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 12
-  position[0] = 10;
-  position[1] = 10 - 10 * sqrt(2)/2;
-  position[2] = -10 * sqrt(2)/2;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.depth_reference_surface);
-
-
-  // curve test 13
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = -10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 14
-  slab_segment_angles[0][0][0] = 0.0 * dtr;
-  slab_segment_angles[0][0][1] = 180.0 * dtr;
-  slab_segment_angles[0][1][0] = 180.0 * dtr;
-  slab_segment_angles[0][1][1] = 270.0 * dtr;
-  slab_segment_angles[1][0][0] = 0.0 * dtr;
-  slab_segment_angles[1][0][1] = 180.0 * dtr;
-  slab_segment_angles[1][1][0] = 180.0 * dtr;
-  slab_segment_angles[1][1][1] = 270.0 * dtr;
-
-  slab_segment_lengths[0][0] = 10 * 180 * dtr;
-  slab_segment_lengths[0][1] = 10 * 90 * dtr;
-  slab_segment_lengths[1][0] = 10 * 180 * dtr;
-  slab_segment_lengths[1][1] = 10 * 90 * dtr;
-
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 15
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = -10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 16
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = -11;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -1 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 16
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = -9;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -1 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 17
-  position[0] = 10;
-  position[1] = 20;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-  // curve test 18
-  position[0] = 10;
-  position[1] = 21;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about 1 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 19
-  position[0] = 10;
-  position[1] = 19;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about 1 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-  // curve test 20
-  slab_segment_angles[0][0][0] = 0.0 * dtr;
-  slab_segment_angles[0][0][1] = 270.0 * dtr;
-  slab_segment_angles[0][1][0] = 270.0 * dtr;
-  slab_segment_angles[0][1][1] = 315.0 * dtr;
-  slab_segment_angles[1][0][0] = 0.0 * dtr;
-  slab_segment_angles[1][0][1] = 270.0 * dtr;
-  slab_segment_angles[1][1][0] = 270.0 * dtr;
-  slab_segment_angles[1][1][1] = 315.0 * dtr;
-
-  slab_segment_lengths[0][0] = 10 * 270 * dtr;
-  slab_segment_lengths[0][1] = 10 * 45 * dtr;
-  slab_segment_lengths[1][0] = 10 * 270 * dtr;
-  slab_segment_lengths[1][1] = 10 * 45 * dtr;
-
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 21
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = -10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 21
-  position[0] = 10;
-  position[1] = 20;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test 22
-  position[0] = 10;
-  position[1] = 10 + 1e-14 + 10 * sqrt(2)/2; // somehow it doesn't get the exact value here, so adding an epsiolon of 1e-14.
-  position[2] = 10 * sqrt(2)/2;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test start 45 degree 1
-  slab_segment_angles[0][0][0] = 45.0 * dtr;
-  slab_segment_angles[0][0][1] = 90.0 * dtr;
-  slab_segment_angles[0][1][0] = 90.0 * dtr;
-  slab_segment_angles[0][1][1] = 135.0 * dtr;
-  slab_segment_angles[1][0][0] = 45.0 * dtr;
-  slab_segment_angles[1][0][1] = 90.0 * dtr;
-  slab_segment_angles[1][1][0] = 90.0 * dtr;
-  slab_segment_angles[1][1][1] = 135.0 * dtr;
-
-  slab_segment_lengths[0][0] = 10 * 45 * dtr;
-  slab_segment_lengths[0][1] = 10 * 45 * dtr;
-  slab_segment_lengths[1][0] = 10 * 45 * dtr;
-  slab_segment_lengths[1][1] = 10 * 45 * dtr;
-  slab_segment_lengths[2][0] = 5;
-  slab_segment_lengths[2][1] = 5;
-
-
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about -7.3 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test change reference point 1
-  reference_point[0] = 50;
-  reference_point[1] = 50;
-
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  // checked that distanceFromPlane should be infinity (it is on the other side of the circle this with a drawing
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test change reference point 2
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be about 2.3 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test angle interpolation 1
-  reference_point[0] = 0;
-  reference_point[1] = 0;
-
-  slab_segment_angles[0][0][0] = 0.0 * dtr;
-  slab_segment_angles[0][0][1] = 180.0 * dtr;
-  slab_segment_angles[0][1][0] = 180.0 * dtr;
-  slab_segment_angles[0][1][1] = 270.0 * dtr;
-  slab_segment_angles[1][0][0] = 0.0 * dtr;
-  slab_segment_angles[1][0][1] = 90.0 * dtr;
-  slab_segment_angles[1][1][0] = 90.0 * dtr;
-  slab_segment_angles[1][1][1] = 135.0 * dtr;
-
-  slab_segment_lengths[0][0] = 10 * 135 * dtr;
-  slab_segment_lengths[0][1] = 10 * 67.5 * dtr;
-  slab_segment_lengths[1][0] = 10 * 135 * dtr;
-  slab_segment_lengths[1][1] = 10 * 67.5 * dtr;
-
-
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test reverse angle 1
-  reference_point[0] = 0;
-  reference_point[1] = 0;
-
-  slab_segment_angles[0][0][0] = 0.0 * dtr;
-  slab_segment_angles[0][0][1] = 90.0 * dtr;
-  slab_segment_angles[0][1][0] = 90.0 * dtr;
-  slab_segment_angles[0][1][1] = 0.0 * dtr;
-  slab_segment_angles[1][0][0] = 0.0 * dtr;
-  slab_segment_angles[1][0][1] = 90.0 * dtr;
-  slab_segment_angles[1][1][0] = 90.0 * dtr;
-  slab_segment_angles[1][1][1] = 0.0 * dtr;
-
-  slab_segment_lengths[0][0] = 10 * 90 * dtr;
-  slab_segment_lengths[0][1] = 10 * 90 * dtr;
-  slab_segment_lengths[1][0] = 10 * 90 * dtr;
-  slab_segment_lengths[1][1] = 10 * 90 * dtr;
-
-  position[0] = 10;
-  position[1] = 0;
-  position[2] = 0;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test reverse angle 2
-  position[0] = 10;
-  position[1] = -10;
-  position[2] = -10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test reverse angle 3
-  position[0] = 10;
-  position[1] = 10 - (20 - 10 * sqrt(2)/2);
-  position[2] = -10 * sqrt(2)/2;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test reverse angle 4
-  position[0] = 10;
-
-  double angle = 180+0.1;
-  position[1] = 10 - (20 * std::cos(0 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180));
-  position[2] = 0 * std::cos(0 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) ); // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-  // curve test reverse angle 5
-  position[0] = 10;
-  position[1] = 10 - (20 - 10 * std::cos(0.001 * Consts::PI/180));
-  position[2] = - 10 * std::sin(0.001 * Consts::PI/180);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) > 1e-12 ? distance_from_planes.distance_from_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test reverse angle 6
-  slab_segment_angles[0][0][0] = 0.0 * dtr;
-  slab_segment_angles[0][0][1] = 45.0 * dtr;
-  slab_segment_angles[0][1][0] = 45.0 * dtr;
-  slab_segment_angles[0][1][1] = 0.0 * dtr;
-  slab_segment_angles[1][0][0] = 0.0 * dtr;
-  slab_segment_angles[1][0][1] = 45.0 * dtr;
-  slab_segment_angles[1][1][0] = 45.0 * dtr;
-  slab_segment_angles[1][1][1] = 0.0 * dtr;
-
-  slab_segment_lengths[0][0] = 10 * 45 * dtr;
-  slab_segment_lengths[0][1] = 10 * 45 * dtr;
-  slab_segment_lengths[1][0] = 10 * 45 * dtr;
-  slab_segment_lengths[1][1] = 10 * 45 * dtr;
-
-  position[0] = 10;
-  position[1] = 10 - 10 * std::cos(45.000 * Consts::PI/180);
-  position[2] = 10 * std::sin(45.000 * Consts::PI/180);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-10); // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-10);
-
-  // curve test reverse angle 6
-  position[0] = 10;
-  angle = 45;
-  position[1] = 10 - (10 * std::cos((angle) * Consts::PI/180));
-  position[2] = 10 * std::sin((angle) * Consts::PI/180);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-10);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-10);
-
-  // curve test reverse angle 6
-  position[0] = 10;
-  angle = 180+45;
-  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180));
-  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-10);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-10);
-
-
-  // curve test reverse angle 7
-  position[0] = 10;
-  angle = 180+46;
-  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180));
-  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane)< 1e-10);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-
-  // curve test reverse angle 8
-  position[0] = 10;
-  angle = 180+46;
-  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180))+0.1;
-  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(fabs(distance_from_planes.distance_from_plane)); // checked that it should be small positive this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test reverse angle 9
-  position[0] = 10;
-  angle = 180+46;
-  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180))-0.1;
-  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked that it should be small negative this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // curve test reverse angle 10
-  position[0] = 10;
-  angle = 180+90;
-  position[1] = 10 - (20 * std::cos(45 * Consts::PI/180) + 10 * std::cos((angle) * Consts::PI/180));
-  position[2] = 20 * std::cos(45 * Consts::PI/180) + 10 * std::sin((angle) * Consts::PI/180);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-  // global_x_list test 1
-  // reminder, coordinates are {0,10},{20,10},{30,10}
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = 10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // global_x_list test 2
-  position[0] = 10;
-  position[1] = 10;
-  position[2] = 10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // global_x_list test 3
-  position[0] = 15;
-  position[1] = 10;
-  position[2] = 10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14); // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) < 1e-14);
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // global_x_list test 4
-  position[0] = 20;
-  position[1] = 10;
-  position[2] = 10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14); // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) < 1e-14);
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // global_x_list test 5
-  position[0] = 25;
-  position[1] = 10;
-  position[2] = 10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane)); // checked that it should be about 0 this with a drawing
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-12);
-
-
-
-  // global_x_list test 6
-  position[0] = 30;
-  position[1] = 10;
-  position[2] = 10;
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *cartesian_system);
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 cartesian_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-
-TEST_CASE("WorldBuilder Utilities function: distance_point_from_curved_planes spherical")
-{
-  std::vector<double> approval_tests;
-
-  // Because most functionality is already tested by the cartesian version
-  // of this test case, the scope of this test case is only to test whether
-  // the code which is different for the spherical case is correct.
-
-  // spherical test 1
-  const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/subducting_plate_different_angles_spherical.wb";
-  WorldBuilder::World world(file_name);
-
-  const double dtr = Consts::PI/180.0;
-  Point<3> position(10,0 * dtr,10 * dtr,spherical);
-  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
-
-  Objects::NaturalCoordinate natural_coordinate = Objects::NaturalCoordinate(position,
-                                                                             *(world.parameters.coordinate_system));
-  const Point<2> reference_point(0,0,spherical);
-
-  std::vector<Point<2> > coordinates;
-  coordinates.emplace_back(0 * dtr,10 * dtr,spherical);
-  coordinates.emplace_back(10 * dtr,10 * dtr,spherical);
-
-  std::vector<std::vector<double> > slab_segment_lengths(2);
-  slab_segment_lengths[0].push_back(std::sqrt(10*10+10*10));
-  slab_segment_lengths[0].push_back(200);
-  slab_segment_lengths[1].push_back(std::sqrt(10*10+10*10));
-  slab_segment_lengths[1].push_back(200);
-
-  //double dtr = Consts::PI/180;
-  std::vector<std::vector<Point<2> > > slab_segment_angles(2);
-  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[0].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
-  slab_segment_angles[1].emplace_back(45 * dtr,45 * dtr,cartesian);
-
-  const double starting_radius = 10;
-
-  const std::vector<double> x_list = {0.,10 * dtr};
-  const std::vector<double> y_list = {10 * dtr,10 * dtr};
-  const std::vector<Point<2> > coordinate_list_local = coordinates;
-  const Objects::BezierCurve bezier_curve(coordinates);
-
-  WorldBuilder::Utilities::PointDistanceFromCurvedPlanes distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 world.parameters.coordinate_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_section) < 1e-14);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14);
-
-
-  // spherical test 2
-  position = Point<3>(10,10 * dtr,10 * dtr,spherical);
-  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
-
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *(world.parameters.coordinate_system));
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 world.parameters.coordinate_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14); // practically zero
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) < 1e-14);
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14);
-
-
-  // spherical test 2
-  coordinates[0][0] = -10 * dtr;
-  coordinates[0][1] = 45 * dtr;
-  coordinates[1][0] = 10 * dtr;
-  coordinates[1][1] = 45 * dtr;
-  position = Point<3>(10,0 * dtr,45 * dtr,spherical);
-  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
-
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *(world.parameters.coordinate_system));
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 world.parameters.coordinate_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_from_plane));
-  approval_tests.emplace_back(std::isinf(distance_from_planes.distance_along_plane));
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14);
-
-
-// spherical test 3
-  position = Point<3>(5,0 * dtr,45 * dtr,spherical);
-  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
-  natural_coordinate = Objects::NaturalCoordinate(position,
-                                                  *(world.parameters.coordinate_system));
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 world.parameters.coordinate_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane);
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-
-  /**
-   * I can't figure out why these are not working in the new structure, although I know it has to do with the different computation of the
-   * x-axis. In this new computation of the x-axis, the direction is no longer computed as perpendicual to the line P1-P2, but instead as
-   * the line from the closest point on the line to the check point. This is more accurate for the continuous case and seems to visually
-   * work well for the non-contiuous case, with only minor changes and of which some are clear improvements and for the rest it is not clear
-   * if is not clear whether it is an improvement or not. Since the new code seems to be an improvement, I don't have the original drawings
-   * at hand, don't have the time to redo them or spend much more time on these 18 checks, I will disable the failing parts of them for now.
-   */
-
-  /*
-  // spherical test 4
-  position = Point<3>(10*sqrt(2)/2,0 * dtr,90 * dtr,spherical);
-  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
-
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 world.parameters.coordinate_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane); // checked it with a geometric drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) < 1e-14); // checked it with a geometric drawing
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) < 1e-14);
-
-
-  // spherical test 5
-  position = Point<3>(10*sqrt(2)/2,0 * dtr,0 * dtr,spherical);
-  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
-
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 world.parameters.coordinate_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_from_plane) < 1e-14);  // checked it with a geometric drawing
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // checked it with a geometric drawing
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers
-
-  // spherical curve test 1
-  // This test has not been checked analytically or with a drawing, but
-  // since the non-curved version works, and the visuals look oke, this
-  // test is used to see if this changes. Todo: Construct analytical
-  // solutions to test against.
-  slab_segment_angles[0][0][0] = 0.0 * dtr;
-  slab_segment_angles[0][0][1] = 45.0 * dtr;
-  slab_segment_angles[0][1][0] = 45.0 * dtr;
-  slab_segment_angles[0][1][1] = 0.0 * dtr;
-  slab_segment_angles[1][0][0] = 0.0 * dtr;
-  slab_segment_angles[1][0][1] = 45.0 * dtr;
-  slab_segment_angles[1][1][0] = 45.0 * dtr;
-  slab_segment_angles[1][1][1] = 0.0 * dtr;
-
-  position = Point<3>(10*sqrt(2)/2,0 * dtr,0 * dtr,spherical);
-  position = Point<3>(world.parameters.coordinate_system->natural_to_cartesian_coordinates(position.get_array()),cartesian);
-
-  distance_from_planes =
-    Utilities::distance_point_from_curved_planes(position,
-                                                 natural_coordinate,
-                                                 reference_point,
-                                                 coordinates,
-                                                 slab_segment_lengths,
-                                                 slab_segment_angles,
-                                                 starting_radius,
-                                                 world.parameters.coordinate_system,
-                                                 false,
-                                                 bezier_curve);
-
-  approval_tests.emplace_back(distance_from_planes.distance_from_plane);  // see comment at the top of the test
-  approval_tests.emplace_back(std::fabs(distance_from_planes.distance_along_plane) > 1e-12 ? distance_from_planes.distance_along_plane : 0.); // to make sure the approval test have the same characters for very small numbers // see comment at the top of the test
-  approval_tests.emplace_back(distance_from_planes.fraction_of_section);
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.section));
-  approval_tests.emplace_back(static_cast<double>(distance_from_planes.segment));
-  approval_tests.emplace_back(std::fabs(distance_from_planes.fraction_of_segment) > 1e-12 ? distance_from_planes.fraction_of_segment : 0.); // to make sure the approval test have the same characters for very small numbers*/
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder Utilities function: distance_point_from_curved_planes spherical depth methods")
-{
-  std::vector<double> approval_tests;
-
-  {
-    // starting point
-    const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/spherical_depth_method_starting_point.wb";
-    WorldBuilder::World world(file_name);
-
-    const double dtr = Consts::PI/180.0;
-    world.parse_entries(world.parameters);
-    approval_tests.emplace_back(world.parameters.coordinate_system->max_model_depth());
-    // slab goes down and up again
-    // origin
-    std::array<double,3> position = {{6371000 - 0, 0 * dtr, 0 * dtr}};
-    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
-    approval_tests.emplace_back(world.temperature(position, 0));
-    approval_tests.emplace_back(world.temperature(position, 1));
-    approval_tests.emplace_back(world.temperature(position, 200e3));
-    approval_tests.emplace_back(world.temperature(position, 210e3));
-
-    // ~330 km
-    position = {{6371000 - 0, 0 * dtr, -3 * dtr}};
-    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
-    approval_tests.emplace_back(world.temperature(position, 0));
-    approval_tests.emplace_back(world.temperature(position, 50e3));
-    approval_tests.emplace_back(world.temperature(position, 75e3));
-    approval_tests.emplace_back(world.temperature(position, 250e3));
-    approval_tests.emplace_back(world.temperature(position, 275e3));
-
-
-    // ~1100 km
-    position = {{6371000 - 0, 0 * dtr, -10 * dtr}};
-    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
-    approval_tests.emplace_back(world.temperature(position, 0));
-    approval_tests.emplace_back(world.temperature(position, 95e3));
-    approval_tests.emplace_back(world.temperature(position, 100e3));
-    approval_tests.emplace_back(world.temperature(position, 300e3));
-    approval_tests.emplace_back(world.temperature(position, 305e3));
-
-
-    // ~2200 km
-    position = {{6371000 - 0, 0 * dtr, -20 * dtr}};
-    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
-    approval_tests.emplace_back(world.temperature(position, 0));
-    approval_tests.emplace_back(world.temperature(position, 1));
-    approval_tests.emplace_back(world.temperature(position, 200e3));
-    approval_tests.emplace_back(world.temperature(position, 205e3));
-    approval_tests.emplace_back(world.temperature(position, 570e3));
-  }
-
-  {
-    // begin segment depth method
-    const std::string file_name = WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/spherical_depth_method_begin_segment.wb";
-    WorldBuilder::World world(file_name);
-
-    const double dtr = Consts::PI/180.0;
-    // origin
-    std::array<double,3> position = {{6371000 - 0, 0 * dtr, 0 * dtr}};
-    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
-    approval_tests.emplace_back(world.temperature(position, 0));
-    approval_tests.emplace_back(world.temperature(position, 1));
-    approval_tests.emplace_back(world.temperature(position, 200e3));
-    approval_tests.emplace_back(world.temperature(position, 210e3));
-
-    // ~330 km
-    position = {{6371000 - 0, 0 * dtr, -3 * dtr}};
-    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
-    approval_tests.emplace_back(world.temperature(position, 0));
-    approval_tests.emplace_back(world.temperature(position, 50e3));
-    approval_tests.emplace_back(world.temperature(position, 75e3));
-    approval_tests.emplace_back(world.temperature(position, 250e3));
-    approval_tests.emplace_back(world.temperature(position, 275e3));
-
-
-    // ~1100 km
-    position = {{6371000 - 0, 0 * dtr, -10 * dtr}};
-    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
-    approval_tests.emplace_back(world.temperature(position, 0));
-    approval_tests.emplace_back(world.temperature(position, 150e3));
-    approval_tests.emplace_back(world.temperature(position, 175e3));
-    approval_tests.emplace_back(world.temperature(position, 380e3));
-    approval_tests.emplace_back(world.temperature(position, 385e3));
-
-
-    // ~1100 km
-    position = {{6371000 - 0, 0 * dtr, -20 * dtr}};
-    position = world.parameters.coordinate_system->natural_to_cartesian_coordinates(position);
-    approval_tests.emplace_back(world.temperature(position, 0));
-    approval_tests.emplace_back(world.temperature(position, 350e3));
-    approval_tests.emplace_back(world.temperature(position, 355e3));
-    approval_tests.emplace_back(world.temperature(position, 565e3));
-    approval_tests.emplace_back(world.temperature(position, 570e3));
-  }
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder parameters: invalid 1")
-{
-
-  CHECK_THROWS_WITH(WorldBuilder::World(WorldBuilder::Data::WORLD_BUILDER_SOURCE_DIR + "/tests/data/invalid_1.wb"),
-                    Contains("Invalid keyword: additionalPropertiesInvalid schema: #/test"));
-
-}
-
-TEST_CASE("Fast sin functions")
-{
-  for (int i = -400; i < 400; i++)
-    {
-      const double angle = (WorldBuilder::Consts::PI/100.)*static_cast<double>(i);
-      CHECK(fabs(FT::sin(angle)-std::sin(angle)) < 1.2e-5);
-    }
-
-  for (int i = -400; i < 400; i++)
-    {
-      const double angle = (WorldBuilder::Consts::PI/100.)*static_cast<double>(i);
-      CHECK(fabs(FT::cos(angle)-std::cos(angle)) < 1.2e-5);
-    }
-}
-
-TEST_CASE("Fast vs slow distance function")
-{
-  std::vector<double> approval_tests;
-  const Point<2> cartesian_1(1,2, cartesian);
-  const Point<2> cartesian_2(2,3, cartesian);
-  // Should be exactly the same.
-  approval_tests.emplace_back(sqrt(cartesian_1.cheap_relative_distance_cartesian(cartesian_2)));
-
-  const Point<2> spherical_1(1,2, spherical);
-  const Point<2> spherical_2(2,3, spherical);
-  // will have an error associated with the faster sin functions.
-  CHECK(fabs(2.0 * asin(sqrt((spherical_1.cheap_relative_distance_spherical(spherical_2))))- spherical_1.distance(spherical_2)) < 3e-5);
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("Fast version of fmod")
-{
-  CHECK(FT::fmod(0,1) == Approx(std::fmod(0,1)));
-  CHECK(FT::fmod(0.2,1) == Approx(std::fmod(0.2,1)));
-  CHECK(FT::fmod(1,1) == Approx(std::fmod(1,1)));
-  CHECK(FT::fmod(5.3,2) == Approx(std::fmod(5.3,2)));
-  CHECK(FT::fmod(18.5,4.2) == Approx(std::fmod(18.5,4.2)));
-  CHECK(std::isnan(FT::fmod(1,0)));
-  //CHECK(std::isnan(std::fmod(1,0))); Return a signaling NAN (FE_INVALID is raised)
-}
-
-TEST_CASE("WorldBuilder Utilities function: calculate_ridge_distance_and_spreading")
-{
-  std::vector<double> approval_tests;
-
-  const std::unique_ptr<CoordinateSystems::Interface> cartesian_system = CoordinateSystems::Interface::create("cartesian", nullptr);;
-
-  // Ridge properties
-  const Point<2> p1a(std::array<double,2> {{200e3, -1e3}},cartesian);
-  const Point<2> p1b(std::array<double,2> {{200e3, 50e3}},cartesian);
-  const Point<2> p2a(std::array<double,2> {{50e3, 50e3}},cartesian);
-  const Point<2> p2b(std::array<double,2> {{50e3, 101e3}},cartesian);
-  const Point<2> p2c(std::array<double,2> {{100e3, 151e3}},cartesian);
-  const std::vector<Point<2>> mid_ocean_ridges_segment_1 = {p1a, p1b};
-  const std::vector<Point<2>> mid_ocean_ridges_segment_2 = {p2a, p2b, p2c};
-
-  std::vector<std::vector<Point<2>>> mid_oceanic_ridges;
-  mid_oceanic_ridges.push_back(mid_ocean_ridges_segment_1);
-  mid_oceanic_ridges.push_back(mid_ocean_ridges_segment_2);
-
-  const double mid_oceanic_spreading_velocitie_1a =  1.0;
-  const double mid_oceanic_spreading_velocitie_1b =  2.0;
-  const double mid_oceanic_spreading_velocitie_2a =  3.0;
-  const double mid_oceanic_spreading_velocitie_2b =  4.0;
-  const double mid_oceanic_spreading_velocitie_2c =  5.0;
-
-  std::vector<double> mid_oceanic_spreading_velocities_segment1 = {mid_oceanic_spreading_velocitie_1a, mid_oceanic_spreading_velocitie_1b};
-  std::vector<double> mid_oceanic_spreading_velocities_segment2 = {mid_oceanic_spreading_velocitie_2a, mid_oceanic_spreading_velocitie_2b,
-                                                                   mid_oceanic_spreading_velocitie_2c
-                                                                  };
-
-  std::vector<std::vector<double>> mid_oceanic_spreading_velocities;
-  mid_oceanic_spreading_velocities.push_back(mid_oceanic_spreading_velocities_segment1);
-  mid_oceanic_spreading_velocities.push_back(mid_oceanic_spreading_velocities_segment2);
-
-  const std::vector<std::vector<double>> subducting_plate_velocities = {{0.0}};
-  const std::vector<double> &ridge_migration_times = {0.0};
-
-  // Query point 1
-  Point<3> position_1(1e3,0,0,cartesian);
-  Objects::NaturalCoordinate position_in_natural_coordinates_1 = Objects::NaturalCoordinate(position_1,
-                                                                 *cartesian_system);
-
-  const std::vector<double> result1 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                      mid_oceanic_spreading_velocities,
-                                      cartesian_system,
-                                      position_in_natural_coordinates_1,
-                                      subducting_plate_velocities,
-                                      ridge_migration_times);
-  approval_tests.emplace_back(result1[0]); // spreading velocity at ridge
-  approval_tests.emplace_back(result1[1]); // ridge distance
-  approval_tests.emplace_back(result1[2]); // subducting velocity at trench
-  approval_tests.emplace_back(result1[3]); // ridge migration time
-
-  // Query point 2: locates outside of the ridge, current solution is to take the end point as the reference point
-  Point<3> position_2(1e3,-2e3,0,cartesian);
-  Objects::NaturalCoordinate position_in_natural_coordinates_2 = Objects::NaturalCoordinate(position_2,
-                                                                 *cartesian_system);
-
-  const std::vector<double> result2 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                      mid_oceanic_spreading_velocities,
-                                      cartesian_system,
-                                      position_in_natural_coordinates_2,
-                                      subducting_plate_velocities,
-                                      ridge_migration_times);
-  approval_tests.emplace_back(result2[0]); // spreading velocity at ridge
-  approval_tests.emplace_back(result2[1]); // ridge distance
-  approval_tests.emplace_back(result2[2]); // subducting velocity at trench
-  approval_tests.emplace_back(result2[3]); // ridge migration time
-
-  // Query point 3: the nearest point on the ridge is in the middle of p2b and p2c
-  // thus it should have intermediate velocity values
-  Point<3> position_3(50e3,151e3,0,cartesian);
-  Objects::NaturalCoordinate position_in_natural_coordinates_3 = Objects::NaturalCoordinate(position_3,
-                                                                 *cartesian_system);
-
-  const std::vector<double> result3 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                      mid_oceanic_spreading_velocities,
-                                      cartesian_system,
-                                      position_in_natural_coordinates_3,
-                                      subducting_plate_velocities,
-                                      ridge_migration_times);
-  approval_tests.emplace_back(result3[0]); // spreading velocity at ridge
-  approval_tests.emplace_back(result3[1]); // ridge distance
-  approval_tests.emplace_back(result3[2]); // subducting velocity at trench
-  approval_tests.emplace_back(result3[3]); // ridge migration time
-
-  // Query point 4: the nearest point on the ridge is in the middle of p2a and p2b
-  // thus it should have intermediate velocity values
-  Point<3> position_4(100e3,76e3,0,cartesian);
-  Objects::NaturalCoordinate position_in_natural_coordinates_4 = Objects::NaturalCoordinate(position_4,
-                                                                 *cartesian_system);
-
-  const std::vector<double> result4 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                      mid_oceanic_spreading_velocities,
-                                      cartesian_system,
-                                      position_in_natural_coordinates_4,
-                                      subducting_plate_velocities,
-                                      ridge_migration_times);
-  approval_tests.emplace_back(result4[0]); // spreading velocity at ridge
-  approval_tests.emplace_back(result4[1]); // ridge distance
-  approval_tests.emplace_back(result4[2]); // subducting velocity at trench
-  approval_tests.emplace_back(result4[3]); // ridge migration time
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-TEST_CASE("WorldBuilder Utilities function: calculate_ridge_distance_and_spreading spherical")
-{
-  std::vector<double> approval_tests;
-
-  const std::unique_ptr<CoordinateSystems::Interface> spherical_system = CoordinateSystems::Interface::create("spherical", nullptr);;
-
-  // Ridge properties
-  const Point<2> p1a(std::array<double,2> {{0.3491, -0.6981}},spherical);
-  const Point<2> p1b(std::array<double,2> {{0.3491, 0.0}},spherical);
-  const Point<2> p2a(std::array<double,2> {{0.1745, 0.0}},spherical);
-  const Point<2> p2b(std::array<double,2> {{0.1745, 0.5236}},spherical);
-  const Point<2> p2c(std::array<double,2> {{0.3491, 0.6981}},spherical);
-  const std::vector<Point<2>> mid_ocean_ridges_segment_1 = {p1a, p1b};
-  const std::vector<Point<2>> mid_ocean_ridges_segment_2 = {p2a, p2b, p2c};
-
-  std::vector<std::vector<Point<2>>> mid_oceanic_ridges;
-  mid_oceanic_ridges.push_back(mid_ocean_ridges_segment_1);
-  mid_oceanic_ridges.push_back(mid_ocean_ridges_segment_2);
-
-  const double mid_oceanic_spreading_velocitie_1a =  1.0;
-  const double mid_oceanic_spreading_velocitie_1b =  2.0;
-  const double mid_oceanic_spreading_velocitie_2a =  3.0;
-  const double mid_oceanic_spreading_velocitie_2b =  4.0;
-  const double mid_oceanic_spreading_velocitie_2c =  5.0;
-
-  std::vector<double> mid_oceanic_spreading_velocities_segment1 = {mid_oceanic_spreading_velocitie_1a, mid_oceanic_spreading_velocitie_1b};
-  std::vector<double> mid_oceanic_spreading_velocities_segment2 = {mid_oceanic_spreading_velocitie_2a, mid_oceanic_spreading_velocitie_2b,
-                                                                   mid_oceanic_spreading_velocitie_2c
-                                                                  };
-
-  std::vector<std::vector<double>> mid_oceanic_spreading_velocities;
-  mid_oceanic_spreading_velocities.push_back(mid_oceanic_spreading_velocities_segment1);
-  mid_oceanic_spreading_velocities.push_back(mid_oceanic_spreading_velocities_segment2);
-
-  const std::vector<std::vector<double>> subducting_plate_velocities = {{0.0}};
-  const std::vector<double> &ridge_migration_times = {0.0};
-
-  // Query point 1, the nearest point on the ridge is in the middle of p1a and p1b
-  Point<3> position_1(6371e3, 0.1745, -0.3491, spherical);
-  Objects::NaturalCoordinate position_in_natural_coordinates_1 = Objects::NaturalCoordinate(Utilities::spherical_to_cartesian_coordinates(position_1.get_array()),
-                                                                 *spherical_system);
-
-  const std::vector<double> result1 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                      mid_oceanic_spreading_velocities,
-                                      spherical_system,
-                                      position_in_natural_coordinates_1,
-                                      subducting_plate_velocities,
-                                      ridge_migration_times);
-  approval_tests.emplace_back(result1[0]); // spreading velocity at ridge
-  approval_tests.emplace_back(result1[1]); // ridge distance
-  approval_tests.emplace_back(result1[2]); // subducting velocity at trench
-  approval_tests.emplace_back(result1[3]); // ridge migration time
-
-  // Query point 2, the nearest point on the ridge is in the middle of p2b and p2c
-  Point<3> position_2(6371e3, 0.3491, 0.5236, spherical);
-  Objects::NaturalCoordinate position_in_natural_coordinates_2 = Objects::NaturalCoordinate(Utilities::spherical_to_cartesian_coordinates(position_2.get_array()),
-                                                                 *spherical_system);
-
-  const std::vector<double> result2 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                      mid_oceanic_spreading_velocities,
-                                      spherical_system,
-                                      position_in_natural_coordinates_2,
-                                      subducting_plate_velocities,
-                                      ridge_migration_times);
-  approval_tests.emplace_back(result2[0]); // spreading velocity at ridge
-  approval_tests.emplace_back(result2[1]); // ridge distance
-  approval_tests.emplace_back(result2[2]); // subducting velocity at trench
-  approval_tests.emplace_back(result2[3]); // ridge migration time
-
-  // Query point 3, the nearest point on the ridge is p2b, the purpose is to test a negative value of longitude
-  Point<3> position_3(6371e3, -0.1745, 0.5236, spherical);
-  Objects::NaturalCoordinate position_in_natural_coordinates_3 = Objects::NaturalCoordinate(Utilities::spherical_to_cartesian_coordinates(position_3.get_array()),
-                                                                 *spherical_system);
-
-  const std::vector<double> result3 = Utilities::calculate_ridge_distance_and_spreading(mid_oceanic_ridges,
-                                      mid_oceanic_spreading_velocities,
-                                      spherical_system,
-                                      position_in_natural_coordinates_3,
-                                      subducting_plate_velocities,
-                                      ridge_migration_times);
-  approval_tests.emplace_back(result3[0]); // spreading velocity at ridge
-  approval_tests.emplace_back(result3[1]); // ridge distance
-  approval_tests.emplace_back(result3[2]); // subducting velocity at trench
-  approval_tests.emplace_back(result3[3]); // ridge migration time
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-}
-
-
-TEST_CASE("WorldBuilder Utilities function: calculate_effective_trench_and_plate_ages")
-{
-  std::vector<double> approval_tests;
-
-  // test 1:  trivial case, spreading velocity = subducting velocity and no ridge migration
-  const std::vector<double> ridge_parameters_1 = {4.75299e-10, 1.04512e+06, 4.75299e-10, 0.0}; // m/s, m, m/s, s
-  const double distance_along_plane_1 = 1000e3;
-  std::vector<double> result1 = Utilities::calculate_effective_trench_and_plate_ages(ridge_parameters_1, distance_along_plane_1);
-
-  approval_tests.emplace_back(result1[0]); // age at trench
-  approval_tests.emplace_back(result1[1]); // effective plate age
-
-  // test 2:  2 * spreading velocity = subducting velocity and no ridge migration, trench retreating
-  std::vector<double> ridge_parameters_2 = {4.75299e-10, 1.04512e+06, 9.50598e-10, 0.0}; // m/s, m, m/s, s
-  const double distance_along_plane_2 = 1000e3;
-  std::vector<double> result2 = Utilities::calculate_effective_trench_and_plate_ages(ridge_parameters_2, distance_along_plane_2);
-
-  approval_tests.emplace_back(result2[0]); // age at trench
-  approval_tests.emplace_back(result2[1]); // effective plate age
-
-  ApprovalTests::Approvals::verifyAll("TITLE", approval_tests);
-
-  // test 3: negative subducting velocity triggers error
-  std::vector<double> ridge_parameters_3 = {4.75299e-10, 1.04512e+06, -9.50598e-10, 0.0}; // m/s, m, m/s, s
-  const double distance_along_plane_3 = 1000e3;
-  CHECK_THROWS_WITH(Utilities::calculate_effective_trench_and_plate_ages(ridge_parameters_3, distance_along_plane_3),
-                    Contains("The subducting velocity is less than 0."));
-
-  // test 4:  subducting velocity is too small, causing negative trench age at subducting initiation
-  std::vector<double> ridge_parameters_4 = {4.75299e-10, 1.04512e+06, 9.50598e-11, 0.0}; // m/s, m, m/s, s
-  const double distance_along_plane_4 = 1000e3;
-  CHECK_THROWS_WITH(Utilities::calculate_effective_trench_and_plate_ages(ridge_parameters_4, distance_along_plane_4),
-                    Contains("The age of trench at subducting initiation is less than 0. "));
-}
diff --git a/cookbooks/2d_annulus_visualization/2d_annulus_example.prm.bak b/cookbooks/2d_annulus_visualization/2d_annulus_example.prm.bak
deleted file mode 100644
index 08d1554f2b4..00000000000
--- a/cookbooks/2d_annulus_visualization/2d_annulus_example.prm.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-# This setup is a copy of
-# cookbook/onset-of-convection/onset-of-convection.prm
-# with the difference that the geometry is a 2D cylindrical
-# annulus and the initial and boundary temperatures
-# are reduced to generate a lower Rayleigh number system.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use conduction timestep                = true
-
-subsection Termination criteria
-  set Termination criteria                 = end step
-  set End step                             = 100
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Outer radius = 6371000
-    set Inner radius = 3481000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r,phi
-    set Function expression = 1600 + 10*sin(10*phi)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2000
-    set Outer temperature = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 4000
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity                     = 1e23
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set Time steps between graphical output = 5
-  end
-end
diff --git a/cookbooks/allken_et_al_2012_rift_interaction/allken.prm.bak b/cookbooks/allken_et_al_2012_rift_interaction/allken.prm.bak
deleted file mode 100644
index a42b73d30c3..00000000000
--- a/cookbooks/allken_et_al_2012_rift_interaction/allken.prm.bak
+++ /dev/null
@@ -1,155 +0,0 @@
-# Input file to replicate Allken et al, G3, 2012.
-
-#  Global parameters
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 5e6
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Stokes
-set Nonlinear solver tolerance             = 1e-4
-set Max nonlinear iterations               = 25
-set Output directory                       = output-allken_etal_2012
-set Pressure normalization                 = no
-set CFL number                             = .5
-
-# Solver settings
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-    set Stokes solver type = block AMG
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 7
-    set Y repetitions = 7
-    set Z repetitions = 1
-    set X extent      = 210e3
-    set Y extent      = 210e3
-    set Z extent      = 30e3
-  end
-end
-
-# Mesh refinement specifications.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 1
-  set Refinement fraction                = 0.5
-  set Strategy                           = strain rate
-  set Coarsening fraction                = 0
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-  set Additional tangential mesh velocity boundary indicators = left,right
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-end
-
-# Velocity boundary conditions
-# The imposed velocity produces a background strain-rate of approx. 1.51e-15.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = front,back,bottom
-  set Prescribed velocity boundary indicators = left x: function, right x:function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = cm=0.01, year=1, vel=0.5
-    set Function expression = if (x<20e3 , -vel*cm/year, vel*cm/year); 0; 0
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = noninitial_plastic_strain, plastic_strain , lower_crust
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = xL=85e3 , xR=135e3
-    set Function expression = 0; \
-                              if( (y<=50e3  && abs(x-xL)<=4e3 && z>=15e3 && z<=19e3) || \
-                                  (y>=160e3 && abs(x-xR)<=4e3 && z>=15e3 && z<=19e3),1.25,0); \
-                              if(z<=15e3, 1, 0);
-  end
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# Temperature initial conditions (isothermal)
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Densities                   = 2800
-    set Reference strain rate       = 1.51e-15
-    set Maximum viscosity           = 1.e24
-    set Minimum viscosity           = 1.e19
-    set Viscous flow law            = diffusion
-    set Grain size exponents for diffusion creep = 0.
-    set Prefactors for diffusion creep          = 5e-26,1e-50,1e-50,5e-21
-    set Activation energies for diffusion creep = 0.
-    set Activation volumes for diffusion creep  = 0.
-    set Viscosity averaging scheme  = maximum composition
-    set Angles of internal friction = 15.
-    set Cohesions                   = 20.e6
-
-    # The parameters below weaken the friction and cohesion by a
-    # a factor of 4 between plastic strain values of 0.25 and 1.25.
-    set Strain weakening mechanism                   = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals  = 0.25
-    set End plasticity strain weakening intervals    = 1.25
-    set Cohesion strain weakening factors            = 0.25
-    set Friction strain weakening factors            = 0.25
-    set Use plastic damper = true
-    set Plastic damper viscosity = 5e19
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, velocity statistics, visualization, topography
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate, named additional outputs
-    set Time between graphical output = 10e3
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-end
diff --git a/cookbooks/anisotropic_viscosity/AV_Rayleigh_Taylor.prm.bak b/cookbooks/anisotropic_viscosity/AV_Rayleigh_Taylor.prm.bak
deleted file mode 100644
index 8d4fc00b635..00000000000
--- a/cookbooks/anisotropic_viscosity/AV_Rayleigh_Taylor.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# This cookbook uses the implementation of anisotropic viscosity terms in the Stokes
-# equation. Here, it is applied to the Rayleigh-Taylor instability problem, following
-# Lev and Hager (2008) and Perry-Houts and Karlstrom (2019) and the van Keken cookbook.
-#
-
-set Additional shared libraries = ./libanisotropic_viscosity.so
-set Dimension = 2
-set CFL number                             = 0.5
-set Start time                             = 0
-set End time                               = 30
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Output directory                       = output-AV-Rayleigh-Taylor-noAV
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2 # width of the box, present in the functions of the compositional fields
-    set Y extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-# 3 compositional fields, 1 for the material, 2 for the anisotropic viscosity (AV) normals
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = gamma, ni, nj
-end
-
-subsection Material model
-  set Model name = AV material
-
-  # density is hard-coded into the AV_material.cc plugin
-  # everything else is set to 0
-
-  subsection AV
-    set Normal viscosity    = 1
-    set Shear viscosity     = 1
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926;
-    set Function expression = 0.5*(1+tanh((z-0.85-0.02*cos(2*pi*x/2))/0.02)); \
-                            (0.5*(1+tanh((z-0.85-0.02*cos(2*pi*x/2))/0.02))) > 0.8 ? sin(45*pi/180) : 0.0; \
-                            (0.5*(1+tanh((z-0.85-0.02*cos(2*pi*x/2))/0.02))) > 0.8 ? cos(45*pi/180) : 0.0;
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 6
-  set Initial adaptive refinement        = 2
-  set Strategy                           = composition
-  set Time steps between mesh refinement = 1
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics, material statistics
-
-  subsection Visualization
-    # add "named additional outputs" to the list to save the stress-strain director (AV tensor)
-    set List of output variables = compositional vector, density, viscosity, gravity, shear stress, stress, strain rate, strain rate tensor, named additional outputs
-    set Output format                 = vtu
-    set Time between graphical output = 0.5
-
-    subsection Compositional fields as vectors
-      set Names of fields = ni,nj
-      set Names of vectors = n
-    end
-  end
-end
diff --git a/cookbooks/anisotropic_viscosity/av_material.cc.bak b/cookbooks/anisotropic_viscosity/av_material.cc.bak
deleted file mode 100644
index e475d22e459..00000000000
--- a/cookbooks/anisotropic_viscosity/av_material.cc.bak
+++ /dev/null
@@ -1,831 +0,0 @@
-/*
- Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/introspection.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/plugins.h>
-#include <aspect/simulator/assemblers/interface.h>
-#include <deal.II/base/exceptions.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/patterns.h>
-#include <deal.II/base/point.h>
-#include <deal.II/base/quadrature.h>
-#include <deal.II/base/table_indices.h>
-#include <deal.II/base/tensor.h>
-#include <deal.II/fe/fe.h>
-#include <deal.II/fe/fe_update_flags.h>
-#include <deal.II/grid/tria_iterator_base.h>
-#include <array>
-#include <cmath>
-#include <functional>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include <aspect/simulator_access.h>
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/base/geometry_info.h>
-
-#include <aspect/material_model/simple.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/heating_model/shear_heating.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator/assemblers/stokes.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/postprocess/particles.h>
-
-#include <deal.II/base/symmetric_tensor.h>
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * Additional output fields for anisotropic viscosities to be added to
-     * the MaterialModel::MaterialModelOutputs structure and filled in the
-     * MaterialModel::Interface::evaluate() function.
-     */
-    template <int dim>
-    class AnisotropicViscosity : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        AnisotropicViscosity(const unsigned int n_points);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * Stress-strain "director" tensors at the given positions. This
-         * variable is used to implement anisotropic viscosity.
-         *
-         * @note The strain rate term in equation (1) of the manual will be
-         * multiplied by this tensor *and* the viscosity scalar ($\eta$), as
-         * described in the manual section titled "Constitutive laws". This
-         * variable is assigned the rank-four identity tensor by default.
-         * This leaves the isotropic constitutive law unchanged if the material
-         * model does not explicitly assign a value.
-         */
-        std::vector<SymmetricTensor<4,dim>> stress_strain_directors;
-    };
-
-    namespace
-    {
-
-
-
-      template <int dim>
-      std::vector<std::string> make_AnisotropicViscosity_additional_outputs_names()
-      {
-        std::vector<std::string> names;
-
-        for (unsigned int i = 0; i < Tensor<4,dim>::n_independent_components ; ++i)
-          {
-            TableIndices<4> indices(Tensor<4,dim>::unrolled_to_component_indices(i));
-            names.push_back("anisotropic_viscosity"+std::to_string(indices[0])+std::to_string(indices[1])+std::to_string(indices[2])+std::to_string(indices[3]));
-          }
-        return names;
-      }
-    }
-
-
-
-    template <int dim>
-    AnisotropicViscosity<dim>::AnisotropicViscosity (const unsigned int n_points)
-      :
-      NamedAdditionalMaterialOutputs<dim>(make_AnisotropicViscosity_additional_outputs_names<dim>()),
-      stress_strain_directors(n_points, dealii::identity_tensor<dim> ())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    AnisotropicViscosity<dim>::get_nth_output(const unsigned int idx) const
-    {
-      std::vector<double> output(stress_strain_directors.size());
-      for (unsigned int i = 0; i < stress_strain_directors.size() ; ++i)
-        {
-          output[i]= stress_strain_directors[i][Tensor<4,dim>::unrolled_to_component_indices(idx)];
-        }
-      return output;
-    }
-  }
-}
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    /**
-     * A class containing the functions to assemble the Stokes preconditioner.
-     */
-    template <int dim>
-    class StokesPreconditionerAnisotropicViscosity : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
-
-        /**
-         * Create AnisotropicViscosities.
-         */
-        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-    };
-
-    /**
-     * This class assembles the terms for the matrix and right-hand-side of the incompressible
-     * Stokes equation for the current cell.
-     */
-    template <int dim>
-    class StokesIncompressibleTermsAnisotropicViscosity : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
-
-        /**
-         * Create AdditionalMaterialOutputsStokesRHS if we need to do so.
-         */
-        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-    };
-
-
-
-    template <int dim>
-    void
-    StokesPreconditionerAnisotropicViscosity<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
-
-      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      // First loop over all dofs and find those that are in the Stokes system
-      // save the component (pressure and dim velocities) each belongs to.
-      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-        {
-          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-            {
-              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
-              ++i_stokes;
-            }
-          ++i;
-        }
-
-      // Loop over all quadrature points and assemble their contributions to
-      // the preconditioner matrix
-      for (unsigned int q = 0; q < n_q_points; ++q)
-        {
-          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.grads_phi_u[i_stokes] =
-                    scratch.finite_element_values[introspection.extractors
-                                                  .velocities].symmetric_gradient(i, q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection
-                                                                          .extractors.pressure].value(i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const double eta = scratch.material_model_outputs.viscosities[q];
-          const double one_over_eta = 1. / eta;
-          const SymmetricTensor<4, dim> &stress_strain_director = anisotropic_viscosity->stress_strain_directors[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-            for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
-              if (scratch.dof_component_indices[i] ==
-                  scratch.dof_component_indices[j])
-                data.local_matrix(i, j) += (2.0 * eta * (scratch.grads_phi_u[i]
-                                                         * stress_strain_director
-                                                         * scratch.grads_phi_u[j])
-                                            + one_over_eta * pressure_scaling
-                                            * pressure_scaling
-                                            * (scratch.phi_p[i]
-                                               * scratch.phi_p[j]))
-                                           * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesPreconditionerAnisotropicViscosity<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      const unsigned int n_points = outputs.viscosities.size();
-
-      if (outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesIncompressibleTermsAnisotropicViscosity<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
-      *force = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  if (scratch.rebuild_stokes_matrix)
-                    {
-                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-                    }
-                  ++i_stokes;
-                }
-              ++i;
-            }
-          // Viscosity scalar
-          const double eta = (scratch.rebuild_stokes_matrix
-                              ?
-                              scratch.material_model_outputs.viscosities[q]
-                              :
-                              numbers::signaling_nan<double>());
-
-          const SymmetricTensor<4, dim> &stress_strain_director = anisotropic_viscosity->stress_strain_directors[q];
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-
-          const double density = scratch.material_model_outputs.densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i) += (density * gravity * scratch.phi_u[i])
-                                   * JxW;
-
-              if (force != nullptr)
-                data.local_rhs(i) += (force->rhs_u[q] * scratch.phi_u[i]
-                                      + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i])
-                                     * JxW;
-
-              if (scratch.rebuild_stokes_matrix)
-                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                  {
-                    data.local_matrix(i,j) += ( eta * 2.0 * (scratch.grads_phi_u[i] * stress_strain_director * scratch.grads_phi_u[j])
-                                                // assemble \nabla p as -(p, div v):
-                                                - (pressure_scaling *
-                                                   scratch.div_phi_u[i] * scratch.phi_p[j])
-                                                // assemble the term -div(u) as -(div u, q).
-                                                // Note the negative sign to make this
-                                                // operator adjoint to the grad p term:
-                                                - (pressure_scaling *
-                                                   scratch.phi_p[i] * scratch.div_phi_u[j]))
-                                              * JxW;
-                  }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesIncompressibleTermsAnisotropicViscosity<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      const unsigned int n_points = outputs.viscosities.size();
-
-      if (outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
-        }
-
-      if (this->get_parameters().enable_additional_stokes_rhs
-          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>> (n_points));
-        }
-      Assert(!this->get_parameters().enable_additional_stokes_rhs
-             ||
-             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
-             == n_points, ExcInternalError());
-    }
-  }
-
-  namespace HeatingModel
-  {
-    template <int dim>
-    class ShearHeatingAnisotropicViscosity : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Compute the heating model outputs for this class.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * Allow the heating model to attach additional material model outputs.
-         */
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const override;
-    };
-
-
-
-    template <int dim>
-    void
-    ShearHeatingAnisotropicViscosity<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.position.size(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.strain_rate.size(),
-             ExcMessage ("The shear heating plugin needs the strain rate!"));
-
-      // Some material models provide dislocation viscosities and boundary area work fractions
-      // as additional material outputs. If they are attached, use them.
-      const ShearHeatingOutputs<dim> *shear_heating_out =
-        material_model_outputs.template get_additional_output<ShearHeatingOutputs<dim>>();
-
-      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          // If there is an anisotropic viscosity, use it to compute the correct stress
-          const SymmetricTensor<2,dim> &directed_strain_rate = ((anisotropic_viscosity != nullptr)
-                                                                ?
-                                                                anisotropic_viscosity->stress_strain_directors[q]
-                                                                * material_model_inputs.strain_rate[q]
-                                                                :
-                                                                material_model_inputs.strain_rate[q]);
-
-          const SymmetricTensor<2,dim> stress =
-            2 * material_model_outputs.viscosities[q] *
-            (this->get_material_model().is_compressible()
-             ?
-             directed_strain_rate - 1./3. * trace(directed_strain_rate) * unit_symmetric_tensor<dim>()
-             :
-             directed_strain_rate);
-
-          const SymmetricTensor<2,dim> deviatoric_strain_rate =
-            (this->get_material_model().is_compressible()
-             ?
-             material_model_inputs.strain_rate[q]
-             - 1./3. * trace(material_model_inputs.strain_rate[q]) * unit_symmetric_tensor<dim>()
-             :
-             material_model_inputs.strain_rate[q]);
-
-          heating_model_outputs.heating_source_terms[q] = stress * deviatoric_strain_rate;
-
-          // If shear heating work fractions are provided, reduce the
-          // overall heating by this amount (which is assumed to be converted into other forms of energy)
-          if (shear_heating_out != nullptr)
-            heating_model_outputs.heating_source_terms[q] *= shear_heating_out->shear_heating_work_fractions[q];
-
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    ShearHeatingAnisotropicViscosity<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const
-    {
-      const unsigned int n_points = material_model_outputs.viscosities.size();
-
-      if (material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
-        {
-          material_model_outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
-        }
-
-      this->get_material_model().create_additional_named_outputs(material_model_outputs);
-    }
-  }
-
-  namespace MaterialModel
-  {
-    // The AV material model calculates an anisotropic viscosity tensor from director vectors and the normal and shear
-    // viscosities (defined in the .prm file). In contrast to the `Anisotropic` material model, the principal directions of the
-    // tensor are not read from an input file, but instead are computed at every quadrature point. This material model is used in T independent models.
-    // All the parameters are defined below.
-    template <int dim>
-    class AV : public MaterialModel::Simple<dim>
-    {
-      public:
-        void initialize() override;
-
-        void evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
-                       MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        static void declare_parameters (ParameterHandler &prm);
-
-        void parse_parameters (ParameterHandler &prm) override;
-
-        bool is_compressible () const override;
-
-        double reference_density () const;
-
-        void create_additional_named_outputs(MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-      private:
-        double eta_N, viscosity_ratio; //normal viscosity and ratio between the shear and the normal viscosities
-        static int delta (const unsigned int i, const unsigned int j); //kronecker delta function
-        void set_assemblers(const SimulatorAccess<dim> &,
-                            Assemblers::Manager<dim> &assemblers) const;
-    };
-  }
-}
-
-namespace aspect
-{
-
-//Next session is a more evolved implementation of anisotropic viscosity in the material model based on Jonathan Perry-Houts'paper
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    AV<dim>::set_assemblers(const SimulatorAccess<dim> &,
-                            Assemblers::Manager<dim> &assemblers) const
-    {
-      for (unsigned int i=0; i<assemblers.stokes_preconditioner.size(); ++i)
-        {
-          if (Plugins::plugin_type_matches<Assemblers::StokesPreconditioner<dim>>(*(assemblers.stokes_preconditioner[i])))
-            assemblers.stokes_preconditioner[i] = std::make_unique<Assemblers::StokesPreconditionerAnisotropicViscosity<dim>> ();
-        }
-
-      for (unsigned int i=0; i<assemblers.stokes_system.size(); ++i)
-        {
-          if (Plugins::plugin_type_matches<Assemblers::StokesIncompressibleTerms<dim>>(*(assemblers.stokes_system[i])))
-            assemblers.stokes_system[i] = std::make_unique<Assemblers::StokesIncompressibleTermsAnisotropicViscosity<dim>> ();
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    AV<dim>::
-    initialize()
-    {
-      this->get_signals().set_assemblers.connect (std::bind(&AV<dim>::set_assemblers,
-                                                            std::cref(*this),
-                                                            std::placeholders::_1,
-                                                            std::placeholders::_2));
-      AssertThrow((dim==2),
-                  ExcMessage("For now the anisotropic viscosity assemblers work only in 2D"));
-
-    }
-
-
-
-    template <int dim>
-    void
-    AV<dim>::evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
-                       MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        out.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      AssertThrow((this->introspection().compositional_name_exists("gamma")),
-                  ExcMessage("AV material model only works if there is a compositional field called gamma."));
-      AssertThrow(this->introspection().compositional_name_exists("ni"),
-                  ExcMessage("AV material model only works if there is a compositional field called ni."));
-      AssertThrow(this->introspection().compositional_name_exists("nj"),
-                  ExcMessage("AV material model only works if there is a compositional field called nj."));
-      if (dim == 3)
-        AssertThrow(this->introspection().compositional_name_exists("nk"),
-                    ExcMessage("AV material model only works if there is a compositional field called nk."));
-
-      const unsigned int c_idx_gamma = this->introspection().compositional_index_for_name("gamma");
-
-      std::vector<unsigned int> c_idx_n;
-      c_idx_n.push_back (this->introspection().compositional_index_for_name("ni"));
-      c_idx_n.push_back (this->introspection().compositional_index_for_name("nj"));
-      if (dim == 3)
-        c_idx_n.push_back (this->introspection().compositional_index_for_name("nk"));
-
-      // Get the grad_u tensor, at the center of this cell, if possible.
-
-      std::vector<Tensor<2,dim>> velocity_gradients (in.n_evaluation_points());
-      if (in.current_cell.state() == IteratorState::valid)
-        {
-          std::vector<Point<dim>> quadrature_positions(in.n_evaluation_points());
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            quadrature_positions[i] = this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]);
-
-          // FEValues requires a quadrature and we provide the default quadrature
-          // as we only need to evaluate the gradients of the solution.
-          FEValues<dim> fe_values (this->get_mapping(),
-                                   this->get_fe(),
-                                   Quadrature<dim>(quadrature_positions),
-                                   update_gradients);
-          fe_values.reinit (in.current_cell);
-          fe_values[this->introspection().extractors.velocities]
-          .get_function_gradients(this->get_solution(), velocity_gradients);
-        }
-
-      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
-        {
-          out.densities[q] = (in.composition[q][c_idx_gamma] > 0.8 ? 1 : 0);
-          out.viscosities[q] = eta_N;
-          out.thermal_expansion_coefficients[q] = 0;
-          out.specific_heat[q] = 0;
-          out.thermal_conductivities[q] = 0;
-          out.compressibilities[q] = 0.0;
-          out.entropy_derivative_pressure[q] = 0.0;
-          out.entropy_derivative_temperature[q] = 0.0;
-          for (unsigned int c=0; c<in.composition[q].size(); ++c)
-            out.reaction_terms[q][c] = 0.0;
-
-          Tensor<1,dim> n;
-          for (unsigned int i=0; i<dim; ++i)
-            n[i] = in.composition[q][c_idx_n[i]];
-
-          // The computation of the viscosity tensor is only
-          // necessary after the simulator has been initialized.
-          if (this->simulator_is_past_initialization())
-            {
-              Tensor<1,dim> n_dot;
-              if (n.norm() > 0.5 && in.composition[q][c_idx_gamma] > 0.8)
-                {
-                  // Symmetric and anti-symmetric parts of grad_u
-                  const SymmetricTensor<2,dim> D = symmetrize(velocity_gradients[q]);
-                  Tensor<2,dim> W;
-                  for (unsigned int i=0; i<dim; ++i)
-                    for (unsigned int j=0; j<dim; ++j)
-                      W[i][j] = velocity_gradients[q][i][j] - D[i][j];
-
-                  for (unsigned int i=0; i<dim; ++i)
-                    {
-                      // outer summation over each value of j.
-                      for (unsigned int j=0; j<dim; ++j)
-                        {
-                          float Wn = W[i][j];
-                          for (unsigned int k=0; k<dim; ++k)
-                            {
-                              Wn -= D[k][i]*n[k]*n[j] - D[k][j]*n[k]*n[i];
-                            }
-                          n_dot[i] += Wn * n[j];
-                        }
-                    }
-
-                  // make sure that n is a unit vector. We have checked
-                  // above that n != 0.0.
-                  // handle time step 0 differently, because time step length is 0
-                  if (this->get_timestep() == 0)
-                    {
-                      n_dot = (n/n.norm())-n;
-                    }
-                  else
-                    {
-                      Tensor<1,dim> n_new = n + (n_dot * this->get_timestep());
-                      Assert (n_new.norm() != 0, ExcInternalError());
-                      n_new /= n_new.norm();
-                      n_dot = (n_new-n)/ this->get_timestep();
-                    }
-                }
-              else
-                {
-                  n_dot = 0;
-                }
-              // update  n[i] = in.composition[q][c_idx_n[i]] with adding to it n_dot*dt
-              for (unsigned int i=0; i<dim; ++i)
-                if (this->get_timestep() == 0)
-                  out.reaction_terms[q][c_idx_n[i]] = n_dot[i];
-                else
-                  out.reaction_terms[q][c_idx_n[i]] = n_dot[i] * this->get_timestep();
-
-              if (n.norm() > 0.5)
-                {
-                  n /= n.norm();
-                  SymmetricTensor<4,dim> Lambda;
-                  for (unsigned int i=0; i<dim; ++i)
-                    for (unsigned int j=0; j<dim; ++j)
-                      for (unsigned int k=0; k<dim; ++k)
-                        for (unsigned int l=0; l<dim; ++l)
-                          Lambda[i][j][k][l] = 1./2. * (n[i]*n[k]*delta(l,j)
-                                                        + n[j]*n[k]*delta(i,l)
-                                                        + n[i]*n[l]*delta(k,j)
-                                                        + n[j]*n[l]*delta(i,k))
-                                               - 2*n[i]*n[j]*n[k]*n[l];
-
-                  if (anisotropic_viscosity != nullptr)
-                    {
-                      anisotropic_viscosity->stress_strain_directors[q] =dealii::identity_tensor<dim> ()
-                                                                         - (1. - viscosity_ratio) * Lambda;
-                      SymmetricTensor<2,3> ViscoTensor;
-                      ViscoTensor[0][0]=anisotropic_viscosity->stress_strain_directors[q][0][0][0][0];
-                      ViscoTensor[0][1]=anisotropic_viscosity->stress_strain_directors[q][0][0][1][1];
-                      ViscoTensor[0][2]=anisotropic_viscosity->stress_strain_directors[q][0][0][0][1] * std::sqrt(2);
-                      ViscoTensor[1][0]=anisotropic_viscosity->stress_strain_directors[q][1][1][0][0];
-                      ViscoTensor[1][1]=anisotropic_viscosity->stress_strain_directors[q][1][1][1][1];
-                      ViscoTensor[1][2]=anisotropic_viscosity->stress_strain_directors[q][1][1][0][1] * std::sqrt(2);
-                      ViscoTensor[2][0]=anisotropic_viscosity->stress_strain_directors[q][0][1][0][0] * std::sqrt(2);
-                      ViscoTensor[2][1]=anisotropic_viscosity->stress_strain_directors[q][0][1][1][1] * std::sqrt(2);
-                      ViscoTensor[2][2]=anisotropic_viscosity->stress_strain_directors[q][0][1][0][1] * 2;
-
-                      const std::array<double,3> Viscoeigenvalues = eigenvalues(ViscoTensor);
-                      for (unsigned int i=0; i<3; ++i)
-                        {
-                          AssertThrow((Viscoeigenvalues[i]>0),
-                                      ExcMessage("Eigenvalue "+ std::to_string(i) + " of the viscosity tensor is negative at " +
-                                                 std::to_string(Viscoeigenvalues[i]) + ". This is not allowed."));
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    int
-    AV<dim>::delta (const unsigned int i,
-                    const unsigned int j)
-    {
-      return (i == j ? 1 : 0);
-    }
-
-
-
-    template <int dim>
-    bool
-    AV<dim>::is_compressible () const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    double
-    AV<dim>::reference_density () const
-    {
-      return 1.0;
-    }
-
-
-
-    template <int dim>
-    void
-    AV<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("AV");
-        {
-          eta_N = prm.get_double("Normal viscosity");
-          viscosity_ratio = prm.get_double("Shear viscosity")/eta_N;
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    AV<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("AV");
-        {
-          prm.declare_entry ("Normal viscosity", "1e-3",
-                             Patterns::Double(),
-                             "Magnitude of normal viscosity.");
-          prm.declare_entry ("Shear viscosity", "1e-4",
-                             Patterns::Double(),
-                             "Magnitude of shear viscosity.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    AV<dim>::create_additional_named_outputs(MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<AnisotropicViscosity<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
-        }
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Assemblers
-  {
-#define INSTANTIATE(dim) \
-  template class StokesPreconditioner<dim>; \
-  template class StokesIncompressibleTerms<dim>; \
-  template class StokesBoundaryTraction<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-  }
-
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(ShearHeatingAnisotropicViscosity,
-                                  "anisotropic shear heating",
-                                  "Implementation of a standard model for shear heating. "
-                                  "Adds the term: "
-                                  "$  2 \\eta \\left( \\varepsilon - \\frac{1}{3} \\text{tr} "
-                                  "\\varepsilon \\mathbf 1 \\right) : \\left( \\varepsilon - \\frac{1}{3} "
-                                  "\\text{tr} \\varepsilon \\mathbf 1 \\right)$ to the "
-                                  "right-hand side of the temperature equation.")
-  }
-
-
-
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(AV,
-                                   "AV material",
-                                   "Transverse isotropic material model.")
-  }
-}
diff --git a/cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm.bak b/cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm.bak
deleted file mode 100644
index e4a7249a52b..00000000000
--- a/cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-# Setup for convection in a 2d shell.
-# Parameters from Bunge et al, Nature, 1996.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 5e9
-set Output directory                       = output_bunge_et_al
-set CFL number                             = 1
-
-subsection Material model
-  set Model name = depth dependent
-
-  subsection Depth dependent model
-    set Base model = simple
-    set Depth dependence method = File
-    set Data directory = $ASPECT_SOURCE_DIR/cookbooks/bunge_et_al_mantle_convection/
-    set Viscosity depth file = visc_depth_a.txt
-    set Reference viscosity = 1e22
-  end
-
-  subsection Simple model
-    set Reference density             = 4500
-    set Thermal expansion coefficient = 2.5e-5
-    set Viscosity                     = 1e22
-    set Reference specific heat       = 1000
-    set Thermal conductivity          = 4
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3480000
-    set Outer radius  = 6370000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Heating model
-  set List of model names = constant heating
-
-  subsection Constant heating
-    set Radiogenic heating rate = 1e-12
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3450
-    set Outer temperature = 1060
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names      = r,phi
-    set Function constants  = A=100, B=75, C=50, D=25, pi=3.1415926536, Ri=3480e3, Ro=6370e3, Ti=3450, To=1060
-    set Function expression = (r-Ri)/(Ro-Ri)*(To-Ti)+Ti + A*sin(7*phi) + B*sin(13*phi) + C*cos(0.123*phi+pi/3) + D*cos(0.456*phi+pi/6)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-
-  #set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 5
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set List of output variables = viscosity, strain rate, density, specific heat, thermal expansivity, gravity, heating
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e7
-    set Number of zones = 100
-  end
-end
diff --git a/cookbooks/burnman/burnman.prm.bak b/cookbooks/burnman/burnman.prm.bak
deleted file mode 100644
index c67bf3be8e9..00000000000
--- a/cookbooks/burnman/burnman.prm.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-# A cookbook for using adiabatic conditions and a gravity
-# profile generated by a mineral physics toolkit and read in
-# through an ascii data file. In this example, material properties
-# are based on a Birch-Murnaghan equation of state.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 2.63e8
-set Output directory                       = output-burnman
-
-subsection Material model
-  set Model name = ascii reference profile
-  set Material averaging = harmonic average
-
-  subsection Ascii reference profile
-    set Thermal viscosity exponent = 10.0
-    set Viscosity prefactors = 1.0, 0.1, 1.0, 10.0
-
-    subsection Ascii data model
-      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-      set Data file name = example_isentrope.txt
-    end
-  end
-end
-
-# The geometry is a spherical shell with the inner and
-# outer radius of the Earth's mantle.
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Adiabatic conditions model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_isentrope.txt
-  end
-end
-
-# The gravity model reads an ascii data file that contains a gravity
-# profile consistent with the material properties computed using the
-# Birch-Murnaghan equation of state. It automatically uses the same file
-# specified in the adiabatic conditions model.
-subsection Gravity model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_isentrope.txt
-  end
-end
-
-# The model uses the anelastic liquid approximation.
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
-
-# The present-day plate velocities are imposed on the upper model
-# boundary.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:gplates
-  set Tangential velocity boundary indicators = bottom
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 273
-  end
-end
-
-# The initial temperature is an adiabatic profile, which is
-# taken from the adabatic conditions model. In this case, this is
-# is the ascii data model that loads a file containing profiles
-# corresponding to the Birch-Murnaghan equation of state.
-# In addition to the adiabatic profile, there are thermal boundary
-# layers at the sirface and the core-mantle boundary.
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Mesh refinement
-  set Refinement fraction                = 0.4
-  set Coarsening fraction                = 0.05
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 5
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Number of grouped files       = 0
-    set List of output variables      = material properties, gravity, adiabat, nonadiabatic temperature, nonadiabatic pressure
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint  = 1800
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-  end
-end
diff --git a/cookbooks/burnman/doc/adiabatic_conditions.part.prm.bak b/cookbooks/burnman/doc/adiabatic_conditions.part.prm.bak
deleted file mode 100644
index 4cadabb890d..00000000000
--- a/cookbooks/burnman/doc/adiabatic_conditions.part.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Adiabatic conditions model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = isentrope_properties.txt
-  end
-end
diff --git a/cookbooks/burnman/doc/formulation.part.prm.bak b/cookbooks/burnman/doc/formulation.part.prm.bak
deleted file mode 100644
index ed9e31a69cd..00000000000
--- a/cookbooks/burnman/doc/formulation.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
diff --git a/cookbooks/burnman/doc/formulation_ica.part.prm.bak b/cookbooks/burnman/doc/formulation_ica.part.prm.bak
deleted file mode 100644
index fb0585cd286..00000000000
--- a/cookbooks/burnman/doc/formulation_ica.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Formulation
-  set Formulation = isentropic compression
-end
diff --git a/cookbooks/burnman/doc/gravity_model.part.prm.bak b/cookbooks/burnman/doc/gravity_model.part.prm.bak
deleted file mode 100644
index ac7bc06486c..00000000000
--- a/cookbooks/burnman/doc/gravity_model.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Gravity model
-  set Model name = ascii data
-end
diff --git a/cookbooks/burnman/doc/material_model.part.prm.bak b/cookbooks/burnman/doc/material_model.part.prm.bak
deleted file mode 100644
index e741a44f895..00000000000
--- a/cookbooks/burnman/doc/material_model.part.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-subsection Material model
-  set Model name = ascii reference profile
-  set Material averaging = harmonic average
-
-  subsection Ascii data model
-    set Data file name = isentrope_properties.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-  end
-
-  subsection Ascii reference profile
-    set Thermal viscosity exponent = 10.0
-    set Viscosity prefactors = 1.0, 0.1, 1.0, 10.0
-  end
-end
diff --git a/cookbooks/burnman/doc/tala.part.prm.bak b/cookbooks/burnman/doc/tala.part.prm.bak
deleted file mode 100644
index 6b71b0fb510..00000000000
--- a/cookbooks/burnman/doc/tala.part.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-subsection Material model
-  subsection Ascii reference profile
-    set Use TALA = true
-  end
-end
diff --git a/cookbooks/christensen_yuen_phase_function/christensen_yuen_phase_function.prm.bak b/cookbooks/christensen_yuen_phase_function/christensen_yuen_phase_function.prm.bak
deleted file mode 100644
index cd508be93fd..00000000000
--- a/cookbooks/christensen_yuen_phase_function/christensen_yuen_phase_function.prm.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-# This is a setup for convection in a 2D box with a phase transition
-# in the center, and corresponds to the setup of the Boussinesq cases
-# in Christensen & Yuen 1985.
-
-set Dimension                              = 2
-set End time                               = 2e8
-set Output directory                       = christensen_yuen
-
-# We use a nonlinear solver to make sure any nonlinearity that may be
-# associated with the phase transition is resolved, and we use a large
-# value for the Maximum nonlinear iterations to make it obvious if the
-# nonlinear solver does not converge. Usually, the nonlinear solver
-# should converge within 1-5 iterations.
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 500
-set Maximum time step                      = 1e5
-set Adiabatic surface temperature = 500
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-# This model assumes the Boussinesq approximation, so it is
-# incompressible and has a constant reference density.
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# For the Boussinesq approximation, all heating terms are switched off.
-subsection Heating model
-  set List of model names =
-end
-
-# The model domain is a quadratic box.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1350000
-    set Y extent = 1350000
-  end
-end
-
-# Set the reference profile.
-# The temperature on the reference profile is 500 K, halfway between the
-# top temperature of 0 K and the bottom temperature of 1000 K.
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants = density=1000
-    set Function expression = 500; density*10*depth; density
-    set Variable names = depth
-  end
-end
-
-# This temperature initial condition resembles the one on Christensen & Yuen, 1985.
-# It has conductive boundary layers at the top and bottom, and sinusoidal
-# temperature perturbations.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants = delta=0.1, A=10, h=1350000, pi=3.1416
-    set Variable names = x,z
-    set Function expression = 500 + 500*(erfc(z/(h*delta)) - erfc((1-z/h)/delta)) + A*cos(pi*x/h)*sin(pi*z/h) + A*cos(2*pi*x/h)*sin(pi*z/h) + A*cos(pi*x/h)*sin(2*pi*z/h) + A*cos(2*pi*x/h)*sin(2*pi*z/h)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom, left, right
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# This material model uses phase functions.
-# The model in Christensen & Yuen is nondimensional, but we want to keep
-# Earth-like parameters. To achieve this, we set all material
-# properties to multiples of 10, and then control the three important
-# model parameters by setting:
-#
-# k = 2.460375e7 / Ra,                                      to control the Rayleigh number,
-# deltarho = 2 alpha rho DeltaT = 200 kg/m3,                to achieve Rb = 2Ra, as in Christensen & Yuen,
-# gamma = P * Ra/Rb * rho g h / DeltaT = P/2 * 1.35e7 Pa/K, to set the phase buoyancy parameter.
-#
-# (for a more detailed explanation, see the corresponding cookbook description in the manual).
-
-subsection Material model
-  set Model name = latent heat
-  set Material averaging = harmonic average only viscosity
-
-  subsection Latent heat
-    # All parameters in the equation of state are constant, and the mode is incompressible.
-    set Reference temperature                          = 500
-    set Reference density                              = 1000
-    set Reference specific heat                        = 1000
-    set Thermal expansion coefficient                  = 1e-4
-    set Compressibility                                = 0
-    set Thermal conductivity                           = 246.03750       # k = 2.460375e7/Ra, corresponds to Ra = 1e5
-
-    # There is one phase transition in the center of the box (at a depth of 675 km),
-    # with a width of 67.5 km (5% of the box height).
-    # It occurs at that depth if the temperature corresponds to the reference temperature (500 K);
-    # for different temperatures the depth changes according to the Clapeyron slope (-2.7 MPa/K).
-    # At the phase transition, the density increases from its reference value of 1000 kg/m^3 to
-    # 1200 kg/m^3.
-    set Define transition by depth instead of pressure = true
-    set Phase transition depths                        = 675000
-    set Phase transition widths                        = 67500
-    set Phase transition temperatures                  = 500
-    set Phase transition Clapeyron slopes              = -2700000        # gamma = P * Ra/Rb, corresponds to P = -0.4
-    set Phase transition density jumps                 = 200             # deltarho = 2 alpha rho DeltaT (Rb = 2Ra)
-    set Corresponding phase for density jump           = 0
-
-    # The viscosity is constant
-    set Viscosity                                      = 1e20
-    set Minimum viscosity                              = 1e20
-    set Maximum viscosity                              = 1e20
-    set Viscosity prefactors                           = 1,1
-    set Thermal viscosity exponent                     = 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 6
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# Stop the model run when a steady state heat flux is reached.
-# Some of the models do not reach steady state and will continue
-# until the end time is reached.
-subsection Termination criteria
-  set Termination criteria = end time, steady state heat flux
-
-  subsection Steady state heat flux
-    set Maximum relative deviation = 0.005
-    set Time in steady state = 1e7
-    set Boundary indicators = top
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 1e5
-    set List of output variables      = material properties, adiabat, strain rate
-
-    subsection Material properties
-      set List of material properties = viscosity, density
-    end
-  end
-end
diff --git a/cookbooks/christensen_yuen_phase_function/doc/material.part.prm.bak b/cookbooks/christensen_yuen_phase_function/doc/material.part.prm.bak
deleted file mode 100644
index 4c442a8a694..00000000000
--- a/cookbooks/christensen_yuen_phase_function/doc/material.part.prm.bak
+++ /dev/null
@@ -1,35 +0,0 @@
-subsection Material model
-  set Model name = latent heat
-  set Material averaging = harmonic average only viscosity
-
-  subsection Latent heat
-    # All parameters in the equation of state are constant, and the mode is incompressible.
-    set Reference temperature                          = 500
-    set Reference density                              = 1000
-    set Reference specific heat                        = 1000
-    set Thermal expansion coefficient                  = 1e-4
-    set Compressibility                                = 0
-    set Thermal conductivity                           = 246.03750       # k = 2.460375e7/Ra, corresponds to Ra = 1e5
-
-    # There is one phase transition in the center of the box (at a depth of 675 km),
-    # with a width of 67.5 km (5% of the box height).
-    # It occurs at that depth if the temperature corresponds to the reference temperature (500 K);
-    # for different temperatures the depth changes according to the Clapeyron slope (-2.7 MPa/K).
-    # At the phase transition, the density increases from its reference value of 1000 kg/m^3 to
-    # 1200 kg/m^3.
-    set Define transition by depth instead of pressure = true
-    set Phase transition depths                        = 675000
-    set Phase transition widths                        = 67500
-    set Phase transition temperatures                  = 500
-    set Phase transition Clapeyron slopes              = -2700000        # gamma = P * Ra/Rb, corresponds to P = -0.4
-    set Phase transition density jumps                 = 200             # deltarho = 2 alpha rho DeltaT (Rb = 2Ra)
-    set Corresponding phase for density jump           = 0
-
-    # The viscosity is constant
-    set Viscosity                                      = 1e20
-    set Minimum viscosity                              = 1e20
-    set Maximum viscosity                              = 1e20
-    set Viscosity prefactors                           = 1,1
-    set Thermal viscosity exponent                     = 0.0
-  end
-end
diff --git a/cookbooks/composition-reaction/composition-reaction.prm.bak b/cookbooks/composition-reaction/composition-reaction.prm.bak
deleted file mode 100644
index fe59917c746..00000000000
--- a/cookbooks/composition-reaction/composition-reaction.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-# A description of convection in a rectangular box where we prescribe
-# temporally variable boundary conditions for the velocity along the top
-# boundary. See the manual for more information.
-
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-reaction
-
-############### Parameters describing the model
-# Let us here choose again a box domain of size 2x1
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-# We then set the temperature to one at the bottom and zero
-# at the top:
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(z<0.5,1,0);0
-  end
-end
-
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-    set Density differential for compositional field 1 = -5
-    set Density differential for compositional field 2 = 5
-    set Reaction depth                = 0.2
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-    set List of output variables = density
-  end
-end
diff --git a/cookbooks/composition-reaction/doc/initial.part.prm.bak b/cookbooks/composition-reaction/doc/initial.part.prm.bak
deleted file mode 100644
index 39d359f8f51..00000000000
--- a/cookbooks/composition-reaction/doc/initial.part.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(z<0.5, 1, 0); 0
-  end
-end
diff --git a/cookbooks/composition-reaction/doc/material.part.prm.bak b/cookbooks/composition-reaction/doc/material.part.prm.bak
deleted file mode 100644
index 8f48516b3ae..00000000000
--- a/cookbooks/composition-reaction/doc/material.part.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Density differential for compositional field 1 = -5
-    set Density differential for compositional field 2 = 5
-    set Reaction depth                                 = 0.2
-  end
-end
diff --git a/cookbooks/composition_active/composition_active.prm.bak b/cookbooks/composition_active/composition_active.prm.bak
deleted file mode 100644
index 96c752b0a3d..00000000000
--- a/cookbooks/composition_active/composition_active.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-#########################################################
-# This is a variation of the composition-passive.prm file.
-# Here, we choose a higher Rayleigh number and make the
-# density depend on the compositional variable as well.
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-active
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/cookbooks/composition_active/doc/active.part.prm.bak b/cookbooks/composition_active/doc/active.part.prm.bak
deleted file mode 100644
index 0a354dd39b6..00000000000
--- a/cookbooks/composition_active/doc/active.part.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 0.1
-  end
-end
diff --git a/cookbooks/composition_active/doc/postprocess.part.prm.bak b/cookbooks/composition_active/doc/postprocess.part.prm.bak
deleted file mode 100644
index 94337847f3c..00000000000
--- a/cookbooks/composition_active/doc/postprocess.part.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/cookbooks/composition_active_particles/composition_active_particles.prm.bak b/cookbooks/composition_active_particles/composition_active_particles.prm.bak
deleted file mode 100644
index dc6b3fa1111..00000000000
--- a/cookbooks/composition_active_particles/composition_active_particles.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-#########################################################
-# This is a variation of the composition-active.prm file.
-# Here, we track compositional fields and their associated
-# density differences with a particle, rather than field,
-# based methods.
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-active-particles
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics,particles
-
-  subsection Visualization
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = vtu
-  end
-end
-
-# Here, we track compositional fields via active particle particles.
-# The initial composition assigned to the particles is 'mapped'
-# to the particles at each time step.  This property is accessed in
-# the material model through a compositional field (standard method)
-# whose values are interpolated from the particles.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = lower, upper
-  set Compositional field methods = particles, particles
-  set Mapped particle properties = lower:initial lower, upper:initial upper
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity, initial composition
-  set Interpolation scheme = cell average
-  set Update ghost particles = true
-  set Particle generator name = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 100000
-    end
-  end
-end
diff --git a/cookbooks/composition_active_particles/doc/composition.part.prm.bak b/cookbooks/composition_active_particles/doc/composition.part.prm.bak
deleted file mode 100644
index 9248b34bd3c..00000000000
--- a/cookbooks/composition_active_particles/doc/composition.part.prm.bak
+++ /dev/null
@@ -1,6 +0,0 @@
-subsection Compositional fields
-  set Number of fields            = 2
-  set Names of fields             = lower, upper
-  set Compositional field methods = particles, particles
-  set Mapped particle properties  = lower:initial lower, upper:initial upper
-end
diff --git a/cookbooks/composition_active_particles/doc/particles.part.prm.bak b/cookbooks/composition_active_particles/doc/particles.part.prm.bak
deleted file mode 100644
index d43080c8b9e..00000000000
--- a/cookbooks/composition_active_particles/doc/particles.part.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-subsection Postprocess
-  subsection Particles
-    set Time between data output  = 0
-    set Data output format        = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity, initial composition
-  set Interpolation scheme      = cell average
-  set Particle generator name   = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles         = 100000
-    end
-  end
-end
diff --git a/cookbooks/composition_passive/composition_passive.prm.bak b/cookbooks/composition_passive/composition_passive.prm.bak
deleted file mode 100644
index 1d2cb078e8f..00000000000
--- a/cookbooks/composition_passive/composition_passive.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-#########################################################
-# This is a variation of the platelike-boundary.prm file.
-# All settings are exactly the same with the exception
-# of the ones that pertain to compositional fields.
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-passive
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/cookbooks/composition_passive/doc/passive.part.prm.bak b/cookbooks/composition_passive/doc/passive.part.prm.bak
deleted file mode 100644
index cddd8c7c649..00000000000
--- a/cookbooks/composition_passive/doc/passive.part.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/cookbooks/composition_passive/doc/postprocess.part.prm.bak b/cookbooks/composition_passive/doc/postprocess.part.prm.bak
deleted file mode 100644
index f9bbf737b98..00000000000
--- a/cookbooks/composition_passive/doc/postprocess.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-end
diff --git a/cookbooks/composition_passive_particles/composition_passive_particles.prm.bak b/cookbooks/composition_passive_particles/composition_passive_particles.prm.bak
deleted file mode 100644
index e7bcbabe929..00000000000
--- a/cookbooks/composition_passive_particles/composition_passive_particles.prm.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-#########################################################
-# This is a variation of the composition-passive.prm
-# parameter file, with the exception that we also
-# advect along a set of particles and that we do not longer
-# compute temperature statistics and composition statistics
-# as part of postprocessing
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 7.2
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-passive-particles
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format       = vtu
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
-
-subsection Particles
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 1000
-    end
-  end
-end
diff --git a/cookbooks/composition_passive_particles/composition_passive_particles_properties.prm.bak b/cookbooks/composition_passive_particles/composition_passive_particles_properties.prm.bak
deleted file mode 100644
index d5f29bcf12d..00000000000
--- a/cookbooks/composition_passive_particles/composition_passive_particles_properties.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-#########################################################
-# This is a variation of the composition-passive.prm
-# parameter file, with the exception that we also
-# advect along a set of particles and that we do not longer
-# compute temperature statistics and composition statistics
-# as part of postprocessing
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-passive-particles-properties
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format       = vtu
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position, pT path
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0)
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 50000
-    end
-  end
-end
diff --git a/cookbooks/composition_passive_particles/doc/particle-properties.part.prm.bak b/cookbooks/composition_passive_particles/doc/particle-properties.part.prm.bak
deleted file mode 100644
index 51f951526e7..00000000000
--- a/cookbooks/composition_passive_particles/doc/particle-properties.part.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-subsection Postprocess
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position, pT path
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0)
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 50000
-    end
-  end
-end
diff --git a/cookbooks/composition_passive_particles/doc/particles.part.prm.bak b/cookbooks/composition_passive_particles/doc/particles.part.prm.bak
deleted file mode 100644
index 6036ea43824..00000000000
--- a/cookbooks/composition_passive_particles/doc/particles.part.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format       = vtu
-  end
-end
-
-subsection Particles
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 1000
-    end
-  end
-end
diff --git a/cookbooks/continental_extension/continental_extension.prm.bak b/cookbooks/continental_extension/continental_extension.prm.bak
deleted file mode 100644
index a0dcd80a382..00000000000
--- a/cookbooks/continental_extension/continental_extension.prm.bak
+++ /dev/null
@@ -1,314 +0,0 @@
-#### Continental Extension Cookbook
-# This cookbook is based off numerous published studies, five of which are listed below.
-# For additional information, see these publications and references therein.
-#   1. Brune, S., Heine, C., Perez-Gussinye, M., and Sobolev, S.V. (2014), Nat. Comm., v.5, n.4014,
-#      Rift migration explains continental margin asymmetry and crustal hyperextension
-#   2. Huismans, R., and Beaumont, C. (2011), Nature, v.473, p.71-75.
-#      Depth-dependent extension, two-stage breakup and cratonic underplating at rifted margins
-#   3. Naliboff, J., and Buiter, S.H. (2015), Earth Planet. Sci. Lett., v.421, p.58-67,
-#      "Rift Reactivation and migration during multiphase extension"
-#   4. Naliboff, J., Glerum, A., Sascha, S., Peron-Pinvidic, G., and Wrona, T. (2020), Geophys.
-#      Res. Lett., 47, e2019GL086611, "Development of 3‐D rift heterogeneity through fault
-#      network evolution"
-#   5. Sandiford, D., Brune, S., Glerum, A., Naliboff, J., and Whittaker, J.M. (2021), Geophys.
-#      Geochem. Geosys., 22, e2021GC009681, "Kinematics of footwall exhumation at oceanic
-#      detachment faults: Solid-block rotation and apparent unbending"
-
-####  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 5e6
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated defect correction Stokes
-set Nonlinear solver tolerance             = 1e-4
-set Max nonlinear iterations               = 100
-set CFL number                             = 0.5
-set Maximum time step                      = 20e3
-set Output directory                       = output-continental_extension
-set Pressure normalization                 = no
-
-#### Parameters describing the model
-
-# Governing equations
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# Model geometry (200x100 km, 20 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 5
-    set X extent      = 200e3
-    set Y extent      = 100e3
-  end
-end
-
-# Globally refine the mesh to 2.5 km spacing, and then
-# adaptively refine the mesh to 1.25 km spacing above y=50 km
-# and between x=40 and x=160 km. These values ensure areas
-# undergoing brittle deformation are in the high-resolution
-# region.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-  set Strategy = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function expression = if ( y>=50e3 && x>=40.e3 && x<=160.e3, 4, 3)
-  end
-end
-
-# Use the Eisenstat Walker method to automatically determine the
-# linear solver tolerance during the defect Picard iterations.
-# Adjusting the Maximum linear solver tolerance will affect how long
-# it takes to reach a solution, but not the actual value of the
-# solution.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-
-  subsection Newton solver parameters
-    set Maximum linear Stokes solver tolerance   = 1e-2
-    set Use Eisenstat Walker method for Picard iterations = true
-  end
-end
-
-# Advecting the free surface using a normal, rather than vertical,
-# projection. To reduce mesh instabilities and associated solver
-# issues when deformation becomes large, diffusion is applied to
-# the free surface at each time step.
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = top: free surface, top: diffusion
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-
-  subsection Diffusion
-    # Diffusivity term. Increasing this value will result
-    # in a smoother free surface and lower topography
-    # amplitudes.
-    set Hillslope transport coefficient = 1.e-8
-  end
-end
-
-# Velocity on boundaries characterized by functions
-# The outward velocity (x-direction) on the left and right walls is 0.25 cm/year
-# The vertical velocity at the base is 0.25 cm/year (balances outflow on sides)
-# Velocity components parallel to the base (x-velocity) and side walls (y-velocity)
-# are unconstrained (i.e. 'free').
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = v=0.0025, w=200.e3, d=100.e3
-    set Function expression = if (x < w/2 , -v, v) ; v*2*d/w
-  end
-end
-
-# Number and names of compositional fields
-# The five compositional fields represent:
-# 1. The plastic strain that accumulates over time, with the initial plastic strain removed
-# 2. The plastic strain that accumulated over time, including the initial plastic strain values
-# 3. The upper crust
-# 4. The lower crust
-# 5. The mantle lithosphere
-subsection Compositional fields
-  set Number of fields = 5
-  set Names of fields = noninitial_plastic_strain, plastic_strain, crust_upper, crust_lower, mantle_lithosphere
-end
-
-# Initial values of different compositional fields
-# The upper crust (20 km thick), lower crust (20 km thick)
-# and mantle (60 km thick) are continuous horizontal layers
-# of constant thickness. The non initial plastic strain is set
-# to 0 and the initial plastic strain is randomized between
-# 0.5 and 1.5.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0; \
-                              if(x>50.e3 && x<150.e3 && y>50.e3, 0.5 + rand_seed(1), 0); \
-                              if(y>=80.e3, 1, 0); \
-                              if(y<80.e3 && y>=60.e3, 1, 0); \
-                              if(y<60.e3, 1, 0);
-  end
-end
-
-# Composition: fixed on bottom (inflow boundary), free on sides and top
-subsection Boundary composition model
-  set Fixed composition boundary indicators = bottom
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-# Top and bottom (fixed) temperatures are consistent with the initial temperature field
-# Note that while temperatures are specified for the model sides, these values are
-# not used as the sides are not specified "Fixed temperature boundaries".  Rather,
-# these boundaries are insulating (zero net heat flux).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1613
-    set Top temperature    =  273
-  end
-end
-
-# Initial temperature field
-# Typical continental geotherm based on equations 4-6 from:
-#   D.S. Chapman (1986), "Thermal gradients in the continental crust",
-#   Geological Society of London Special Publications, v.24, p.63-70.
-# The initial constraints are:
-#   Surface Temperature  - upper crust (ts1) = 273 K
-#   Surface Heat Flow    - upper crust (qs1) = 0.055 mW/m^2
-#   Heat Production      - upper crust (A1)  = 1.00e-6 W/m^3;
-#   Heat Production      - lower crust (A2)  = 0.25e-6 W/m^3;
-#   Heat Production      - mantle (A3)       = 0.00e-6 W/m^3;
-#   Thermal Conductivity - all layers        = 2.5 (W/(m K));
-# To satisfy these constraints, the following values are required:
-#   Surface Temperature  - lower crust (ts2) = 633 K
-#                        - mantle (ts3)      = 893 K
-#   Surface Heat Flow    - lower crust (qs2) = 0.035 W/m^2;
-#                        - mantle      (qs3) = 0.030 W/m^2;
-# Note: The continental geotherm initial temperature model
-#       plugin can be used to compute an identical geotherm
-#       for the lithosphere. An example of how to use this
-#       plugin is illustrated in the test for this cookbook
-#       (tests/continental_extension.prm).
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=100e3, ts1=273, ts2=633, ts3=893, \
-                             A1=1.e-6, A2=0.25e-6, A3=0.0, \
-                             k1=2.5, k2=2.5, k3=2.5, \
-                             qs1=0.055, qs2=0.035, qs3=0.030
-    set Function expression = if( (h-y)<=20.e3, \
-                                  ts1 + (qs1/k1)*(h-y) - (A1*(h-y)*(h-y))/(2.0*k1), \
-                                  if( (h-y)>20.e3 && (h-y)<=40.e3, \
-                                      ts2 + (qs2/k2)*(h-y-20.e3) - (A2*(h-y-20.e3)*(h-y-20.e3))/(2.0*k2), \
-                                      ts3 + (qs3/k3)*(h-y-40.e3) - (A3*(h-y-40.e3)*(h-y-40.e3))/(2.0*k3) ) );
-  end
-end
-
-# Constant internal heat production values (W/m^3) for background material
-# and compositional fields.
-subsection Heating model
-  set List of model names = compositional heating
-
-  subsection Compositional heating
-    set Use compositional field for heat production averaging = 1, 0, 0, 1, 1, 1
-    set Compositional heating values = 0.0, 0.0, 0.0, 1.0e-6, 0.25e-6, 0.
-  end
-end
-
-# Material model
-# Rheology: Non-linear viscous flow and Drucker Prager Plasticity
-# Values for most rheological parameters are specified for a background material and
-# each compositional field.  Values for viscous deformation are based on dislocation
-# creep flow-laws, with distinct values for the upper crust (wet quartzite), lower
-# crust (wet anorthite) and mantle (dry olivine).  Table 1 of Naliboff and Buiter (2015),
-# Earth Planet. Sci. Lett., v.421, p. 58-67 contains values for each of these flow laws.
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Reference temperature and viscosity
-    set Reference temperature = 273
-
-    # The minimum strain-rate helps limit large viscosities values that arise
-    # as the strain-rate approaches zero.
-    # The reference strain-rate is used on the first non-linear iteration
-    # of the first time step when the velocity has not been determined yet.
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-16
-
-    # Limit the viscosity with minimum and maximum values
-    set Minimum viscosity = 1e18
-    set Maximum viscosity = 1e26
-
-    # Thermal diffusivity is adjusted to match thermal conductivities
-    # assumed in assigning the initial geotherm
-    set Define thermal conductivities = true
-    set Thermal conductivities        = 2.5
-    set Heat capacities               = 750.
-
-    # Density values of 1 are assigned to "strain" fields, which are not taken into
-    # account when computing material properties.
-    set Densities                     = 3300, 1.0, 1.0, 2700,  2900, 3300
-    set Thermal expansivities         = 2e-5
-
-    # Harmonic viscosity averaging
-    set Viscosity averaging scheme = harmonic
-
-    # Choose to have the viscosity (pre-yield) follow a dislocation
-    # diffusion or composite flow law.  Here, dislocation is selected
-    # so no need to specify diffusion creep parameters below, which are
-    # only used if "diffusion" or "composite" option is selected.
-    set Viscous flow law = dislocation
-
-    # Dislocation creep parameters for
-    # 1. Background material/mantle (dry olivine)
-    #    Hirth & Kohlstedt (2004),  Geophys. Monogr. Am. Geophys. Soc., v.138, p.83-105.
-    #    "Rheology of the upper mantle and the mantle wedge:a view from the experimentalists"
-    # 2. Upper crust (wet quartzite)
-    #    Rutter & Brodie (2004), J. Struct. Geol., v.26, p.2011-2023.
-    #    "Experimental grain size-sensitive flow of hot-pressed Brazilian quartz aggregates"
-    # 3. Lower crust and weak seed (wet anorthite)
-    #    Rybacki et al. (2006), J. Geophys. Res., v.111(B3).
-    #    "Influence of water fugacity and activation volume on the flow properties of fine-grained
-    #    anorthite aggregates"
-    # Note that the viscous pre-factors below are scaled to plane strain from unixial strain experiments.
-    # For ease of identification, fields tracking strain are assigned prefactors of 1e-50
-    set Prefactors for dislocation creep          = 6.52e-16, 1.00e-50, 1.00e-50, 8.57e-28, 7.13e-18, 6.52e-16
-    set Stress exponents for dislocation creep    =      3.5,      1.0,      1.0,      4.0,      3.0,      3.5
-    set Activation energies for dislocation creep =   530.e3,      0.0,      0.0,   223.e3,   345.e3,   530.e3
-    set Activation volumes for dislocation creep  =   18.e-6,      0.0,      0.0,      0.0,      0.0,   18.e-6
-
-    # Plasticity parameters
-    set Angles of internal friction = 30
-    set Cohesions                   = 20.e6
-
-    # The parameters below weaken the friction and cohesion by a
-    # a factor of 4 between plastic strain values of 0.5 and 1.5.
-    set Strain weakening mechanism                   = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals  = 0.5
-    set End plasticity strain weakening intervals    = 1.5
-    set Cohesion strain weakening factors            = 0.25
-    set Friction strain weakening factors            = 0.25
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, heat flux densities, heat flux statistics, mass flux statistics, matrix statistics, pressure statistics, temperature statistics, topography, velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = density, heat flux map, named additional outputs, strain rate, viscosity
-    set Output format                 = vtu
-    set Time between graphical output = 100.e3
-    set Interpolate output            = true
-  end
-end
diff --git a/cookbooks/continental_extension/doc/continental_extension_boundary_conditions.prm.bak b/cookbooks/continental_extension/doc/continental_extension_boundary_conditions.prm.bak
deleted file mode 100644
index 60422171c39..00000000000
--- a/cookbooks/continental_extension/doc/continental_extension_boundary_conditions.prm.bak
+++ /dev/null
@@ -1,36 +0,0 @@
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = v=0.0025, w=200.e3, d=100.e3
-    set Function expression = if (x < w/2 , -v, v) ; v*2*d/w
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = top: free surface, top: diffusion
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-
-  subsection Diffusion
-    set Hillslope transport coefficient = 1.e-8
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = bottom
-  set List of model names = initial composition
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1613
-    set Top temperature    =  273
-  end
-end
diff --git a/cookbooks/continental_extension/doc/continental_extension_composition.prm.bak b/cookbooks/continental_extension/doc/continental_extension_composition.prm.bak
deleted file mode 100644
index 6a119dd1b49..00000000000
--- a/cookbooks/continental_extension/doc/continental_extension_composition.prm.bak
+++ /dev/null
@@ -1,16 +0,0 @@
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = upper, lower, mantle, seed
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y>=80.e3, 1, 0); \
-                              if(y<80.e3 && y>=70.e3, 1, 0); \
-                              if(y<70.e3 && y>-100.e3,1, 0); \
-                              if(y<68.e3 && y>60.e3 && x>=198.e3 && x<=202.e3 , 1, 0);
-  end
-end
diff --git a/cookbooks/continental_extension/doc/continental_extension_geometry_mesh.prm.bak b/cookbooks/continental_extension/doc/continental_extension_geometry_mesh.prm.bak
deleted file mode 100644
index acd0ab7ee12..00000000000
--- a/cookbooks/continental_extension/doc/continental_extension_geometry_mesh.prm.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 5
-    set X extent      = 200e3
-    set Y extent      = 100e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-  set Strategy = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function expression = if ( y>=50e3 && x>=40.e3 && x<=160.e3, 4, 3)
-  end
-end
diff --git a/cookbooks/continental_extension/doc/continental_extension_material_model.prm.bak b/cookbooks/continental_extension/doc/continental_extension_material_model.prm.bak
deleted file mode 100644
index 769682e2608..00000000000
--- a/cookbooks/continental_extension/doc/continental_extension_material_model.prm.bak
+++ /dev/null
@@ -1,6 +0,0 @@
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-  end
-end
diff --git a/cookbooks/convection-box-particles/convection-box-particles.prm.bak b/cookbooks/convection-box-particles/convection-box-particles.prm.bak
deleted file mode 100644
index b4a8978e456..00000000000
--- a/cookbooks/convection-box-particles/convection-box-particles.prm.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-# A modification of the convection box cookbook using physical units
-# and particle output. See the manual for more information.
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 3e10
-set Output directory                       = output-tutorial
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 4.2e6
-    set Y extent = 3e6
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature. Note that there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field.
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation. The variables in this equation are
-# described below, and it is important to note that in many
-# cases the values correspond to other model parameters
-# defined elsewhere. As such, if these model parameters are
-# changed, the values below will also need to be adjusted.
-#   L - Model length/width
-#   D - Model depth/height
-#   T_top - Temperature at the top boundary
-#   T_bottom - Temperature at the bottom boundary
-#   p, k - values related to the small temperature perturbation
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = p=-0.01, L=4.2e6, D=3e6, pi=3.1415926536, k=1, T_top=273, T_bottom=3600
-    set Function expression = T_top + (T_bottom-T_top)*(1-(y/D) - p*cos(k*pi*x/L)*sin(pi*y/D))
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above, whereas all other
-# parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry
-# boundaries).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 3300
-    set Top temperature    = 300
-  end
-end
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all four sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc).
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 3e24
-    set Reference density             = 3000
-    set Thermal conductivity          = 4.86
-    set Thermal expansion coefficient = 2e-5
-    set Reference specific heat       = 1000
-    set Reference temperature         = 0
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 1e7 years.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, particles, basic statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e7
-    set Output format                 = vtu
-    set List of output variables      = material properties
-  end
-
-  subsection Particles
-    set Time between data output = 1e7
-    set Data output format = vtu
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
-
-subsection Particles
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1000
-    end
-  end
-end
diff --git a/cookbooks/convection-box/convection-box.prm.bak b/cookbooks/convection-box/convection-box.prm.bak
deleted file mode 100644
index dd2995dda29..00000000000
--- a/cookbooks/convection-box/convection-box.prm.bak
+++ /dev/null
@@ -1,160 +0,0 @@
-# A description of convection in a 2d box. See the manual for more information.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-set Output directory                       = output-convection-box
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature. Note that there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field.
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation. The variables in this equation are
-# described below, and it is important to note that in many
-# cases the values correspond to other model parameters
-# defined elsewhere. As such, if these model parameters are
-# changed, the values below will also need to be adjusted.
-#   L - Model length/width
-#   p, k - values related to the small temperature perturbation
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above, whereas all other
-# parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry
-# boundaries).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all four sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e4   # = Ra
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0.01
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/cookbooks/convection-box/doc/disc.part.prm.bak b/cookbooks/convection-box/doc/disc.part.prm.bak
deleted file mode 100644
index 472d365dfc9..00000000000
--- a/cookbooks/convection-box/doc/disc.part.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 3
-end
diff --git a/cookbooks/convection-box/doc/gravity.part.prm.bak b/cookbooks/convection-box/doc/gravity.part.prm.bak
deleted file mode 100644
index c4830f97d58..00000000000
--- a/cookbooks/convection-box/doc/gravity.part.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-subsection Gravity model
-  subsection Vertical
-    set Magnitude = 1e6   # = Ra
-  end
-end
diff --git a/cookbooks/convection-box/doc/refine.part.prm.bak b/cookbooks/convection-box/doc/refine.part.prm.bak
deleted file mode 100644
index 3dbcf41380f..00000000000
--- a/cookbooks/convection-box/doc/refine.part.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
diff --git a/cookbooks/convection-box/doc/refine2.part.prm.bak b/cookbooks/convection-box/doc/refine2.part.prm.bak
deleted file mode 100644
index cd704f93193..00000000000
--- a/cookbooks/convection-box/doc/refine2.part.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Additional refinement times              = 0.2, 0.3, 0.4
-  set Refinement fraction                      = 1.0
-  set Coarsening fraction                      = 0.0
-end
diff --git a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box.prm.bak b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box.prm.bak
deleted file mode 100644
index dd2995dda29..00000000000
--- a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box.prm.bak
+++ /dev/null
@@ -1,160 +0,0 @@
-# A description of convection in a 2d box. See the manual for more information.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-set Output directory                       = output-convection-box
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature. Note that there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field.
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation. The variables in this equation are
-# described below, and it is important to note that in many
-# cases the values correspond to other model parameters
-# defined elsewhere. As such, if these model parameters are
-# changed, the values below will also need to be adjusted.
-#   L - Model length/width
-#   p, k - values related to the small temperature perturbation
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above, whereas all other
-# parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry
-# boundaries).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all four sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e4   # = Ra
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0.01
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box2.prm.bak b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box2.prm.bak
deleted file mode 100644
index 4cff06a310a..00000000000
--- a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/convection-box2.prm.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-# A description of convection in a 2d box. See the manual for more information.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.1
-set Output directory                       = output-convection-box2
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature. Note that there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field.
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation. The variables in this equation are
-# described below, and it is important to note that in many
-# cases the values correspond to other model parameters
-# defined elsewhere. As such, if these model parameters are
-# changed, the values below will also need to be adjusted.
-#   L - Model length/width
-#   p, k - values related to the small temperature perturbation
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above, whereas all other
-# parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry
-# boundaries).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all four sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e4   # = Ra
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, heat flux map
-
-  subsection Visualization
-    set Time between graphical output = 0.00
-    set Output format = hdf5
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm.bak b/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm.bak
deleted file mode 100644
index 5c8302c747c..00000000000
--- a/cookbooks/convection-box/tutorial-onset-of-convection/model_input/tutorial.prm.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 1.00e10
-set Output directory                       = output-tutorial
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 4.2e6
-    set Y extent = 3e6
-  end
-end
-
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc).
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 5.099e23
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = p=-0.01, L=4.2e6, D=3e6, pi=3.1415926536, k=1, T_top=273, T_bottom=3600
-    set Function expression = T_top + (T_bottom-T_top)*(1-(y/D) - p*cos(k*pi*x/L)*sin(pi*y/D))
-  end
-end
-
-# We then also have to prescribe several other parts of the model
-# such as which boundaries actually carry a prescribed boundary
-# temperature (as described in the documentation of the `box'
-# geometry, boundaries 2 and 3 are the bottom and top boundaries)
-# whereas all other parts of the boundary are insulated (i.e.,
-# no heat flux through these boundaries; this is also often used
-# to specify symmetry boundaries).
-# subsection Model settings    OLD DEPRECATED
-#   set Fixed temperature boundary indicators   = 2,3 OLD MOVED
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all four sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-#  set Zero velocity boundary indicators       =             OLD MOVED
-#  set Prescribed velocity boundary indicators =             OLD MOVED
-#  set Tangential velocity boundary indicators = 0,1,2,3     OLD MOVED
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The final part of this section describes whether we
-# want to include adiabatic heating (from a small
-# compressibility of the medium) or from shear friction,
-# as well as the rate of internal heating. We do not
-# want to use any of these options here:
-#  set Include adiabatic heating               = false      OLD is false
-#  set Include shear heating                   = false      OLD is false
-# end
-
-
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above. (As will be seen
-# in the next section, the actual temperature prescribed here
-# at the left and right does not matter.)
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2,3
-  set Model name = box
-
-  subsection Box
-    set Bottom temperature = 3600
-    set Top temperature    = 273
-  end
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 1e7 years.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics , visualization, particles, basic statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e7
-    set Output format = vtu
-  end
-
-  subsection Particles
-    set Time between data output = 1e7
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1000
-    end
-  end
-end
diff --git a/cookbooks/convection_box_3d/convection_box_3d.prm.bak b/cookbooks/convection_box_3d/convection_box_3d.prm.bak
deleted file mode 100644
index 88e81d1c124..00000000000
--- a/cookbooks/convection_box_3d/convection_box_3d.prm.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-# A description of convection in a 3d box. See the manual for more information.
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 3
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 1.0
-set Output directory                       = output-convection_box_3d
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)*y^3
-  end
-end
-
-# Then follows a section that describes the boundary conditions for the
-# temperature. The model we choose is called 'box' and allows to set a constant
-# temperature on each of the four sides of the box geometry. In our case, we
-# choose something that is heated from below and cooled from above.
-# All other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all six sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e16   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 3
-  set Time steps between mesh refinement       = 15
-  set Additional refinement times              = 0.003
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0.0001
-  end
-end
-
-subsection Checkpointing
-  # The number of timesteps between performing checkpoints. If 0 and time
-  # between checkpoint is not specified, checkpointing will not be performed.
-  # Units: None.
-  set Steps between checkpoint = 50
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/cookbooks/convection_box_3d/doc/amr.part.prm.bak b/cookbooks/convection_box_3d/doc/amr.part.prm.bak
deleted file mode 100644
index b68e96eda57..00000000000
--- a/cookbooks/convection_box_3d/doc/amr.part.prm.bak
+++ /dev/null
@@ -1,6 +0,0 @@
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 3
-  set Time steps between mesh refinement       = 15
-  set Additional refinement times              = 0.003
-end
diff --git a/cookbooks/convection_box_3d/doc/checkpoint.part.prm.bak b/cookbooks/convection_box_3d/doc/checkpoint.part.prm.bak
deleted file mode 100644
index 595a2feeb79..00000000000
--- a/cookbooks/convection_box_3d/doc/checkpoint.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Checkpointing
-  set Steps between checkpoint = 50
-end
diff --git a/cookbooks/convection_box_3d/doc/gravity.part.prm.bak b/cookbooks/convection_box_3d/doc/gravity.part.prm.bak
deleted file mode 100644
index 4b07cb3808e..00000000000
--- a/cookbooks/convection_box_3d/doc/gravity.part.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e16   # = Ra / Thermal expansion coefficient
-  end
-end
diff --git a/cookbooks/convection_box_3d/doc/initial.part.prm.bak b/cookbooks/convection_box_3d/doc/initial.part.prm.bak
deleted file mode 100644
index 15b76c9dae8..00000000000
--- a/cookbooks/convection_box_3d/doc/initial.part.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)*y^3
-  end
-end
diff --git a/cookbooks/convection_box_3d/doc/postprocess.part.prm.bak b/cookbooks/convection_box_3d/doc/postprocess.part.prm.bak
deleted file mode 100644
index 2f592ff8cfe..00000000000
--- a/cookbooks/convection_box_3d/doc/postprocess.part.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, \
-                       heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0.0001
-  end
-end
diff --git a/cookbooks/convection_box_3d/doc/start.part.prm.bak b/cookbooks/convection_box_3d/doc/start.part.prm.bak
deleted file mode 100644
index eb4a52a204c..00000000000
--- a/cookbooks/convection_box_3d/doc/start.part.prm.bak
+++ /dev/null
@@ -1,25 +0,0 @@
-set Dimension                              = 3
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
-end
diff --git a/cookbooks/crustal_deformation/crustal_model_2D.prm.bak b/cookbooks/crustal_deformation/crustal_model_2D.prm.bak
deleted file mode 100644
index 3756ca1b7d0..00000000000
--- a/cookbooks/crustal_deformation/crustal_model_2D.prm.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-############### Global parameters
-
-set Dimension                                       = 2
-set Start time                                      = 0
-set End time                                        = 1e6
-set Use years in output instead of seconds          = true
-set Nonlinear solver scheme                         = single Advection, iterated Stokes
-
-# This model is very sensitive to the nonlinear solver tolerance,
-# results still change slightly down to a tolerance of 1e-8, but
-# require much more resources than reasonable for a cookbook.
-set Nonlinear solver tolerance                      = 2e-6
-set Max nonlinear iterations                        = 100
-set CFL number                                      = 0.5
-set Output directory                                = output-crustal_model_2D
-set Timing output frequency                         = 1
-set Pressure normalization                          = no
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions  = 5
-    set X extent  = 80e3
-    set Y extent  = 16e3
-  end
-end
-
-# Advecting the free surface vertically rather than
-# in the surface normal direction can result in a
-# more stable mesh when the deformation is large
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Surface velocity projection = vertical
-  end
-end
-
-subsection Material model
-  #  set Model name = viscoplastic
-  #  subsection Viscoplastic model
-  #    set Reference density = 2800
-  #  end
-
-  set Model name = drucker prager
-
-  subsection Drucker Prager
-    set Reference density = 2800
-
-    subsection Viscosity
-      set Minimum viscosity = 1e19
-      set Maximum viscosity = 1e25
-      set Reference strain rate = 1e-20
-      set Angle of internal friction = 30
-      set Cohesion = 20e6
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left: function, right:function, bottom:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = cm=0.01, year=1
-    set Function expression =  if (x<40e3 , 1*cm/year, -1*cm/year) ; 0
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.95
-  set Strategy                           = strain rate
-  set Coarsening fraction                = 0.05
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, error indicator, heating, partition
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block AMG
-    set Linear solver tolerance = 1e-9
-    set Number of cheap Stokes solver steps = 0
-    set Maximum number of expensive Stokes solver steps = 5000
-    set GMRES solver restart length = 200
-  end
-end
diff --git a/cookbooks/crustal_deformation/crustal_model_3D.prm.bak b/cookbooks/crustal_deformation/crustal_model_3D.prm.bak
deleted file mode 100644
index 81cebdc1e59..00000000000
--- a/cookbooks/crustal_deformation/crustal_model_3D.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-############### Global parameters
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 1e6
-set Use years in output instead of seconds = true
-set CFL number                             = .5
-set Output directory                       = output-crustal_model_3D
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-8
-set Max nonlinear iterations               = 100
-set Pressure normalization                 = no
-set Timing output frequency                = 1
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 128e3
-    set Y extent  =  96e3
-    set Z extent  =  16e3
-    set X repetitions  = 8
-    set Y repetitions  = 3
-  end
-end
-
-# Advecting the free surface vertically rather than
-# in the surface normal direction can result in a
-# more stable mesh when the deformation is large
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Surface velocity projection = vertical
-  end
-end
-
-subsection Material model
-  set Model name = drucker prager
-
-  subsection Drucker Prager
-    set Reference density = 2800
-
-    subsection Viscosity
-      set Minimum viscosity = 1e19
-      set Maximum viscosity = 1e25
-      set Reference strain rate = 1e-20
-      set Angle of internal friction = 30
-      set Cohesion = 20e6
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = front,back
-  set Prescribed velocity boundary indicators = left: function, right:function, bottom:function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = cm=0.01, year=1
-    set Function expression =  if (x<56e3 && y<=48e3 | x<72e3 && y>48e3, -1*cm/year, 1*cm/year) ; 0 ; 0
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.9
-  set Strategy                           = strain rate
-  set Coarsening fraction                = 0.05
-  set Minimum refinement level           = 2
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography, pressure statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, error indicator, partition
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-9
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_2D_part1.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_2D_part1.prm.bak
deleted file mode 100644
index 9720b54bbd6..00000000000
--- a/cookbooks/crustal_deformation/doc/crustal_model_2D_part1.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-subsection Material model
-  set Model name = drucker prager
-
-  subsection Drucker Prager
-    set Reference density = 2800
-
-    subsection Viscosity
-      set Minimum viscosity = 1e19
-      set Maximum viscosity = 1e25
-      set Reference strain rate = 1e-20
-      set Angle internal friction = 30
-      set Cohesion = 20e6
-    end
-  end
-end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_2D_part2.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_2D_part2.prm.bak
deleted file mode 100644
index b0bea70f396..00000000000
--- a/cookbooks/crustal_deformation/doc/crustal_model_2D_part2.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-subsection Boundary velocity model
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = cm=0.01, year=1
-    set Function expression =  if (x<40e3 , 1*cm/year, -1*cm/year) ; 0
-  end
-end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_2D_part3.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_2D_part3.prm.bak
deleted file mode 100644
index 9e58f845656..00000000000
--- a/cookbooks/crustal_deformation/doc/crustal_model_2D_part3.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Free surface
-  set Surface velocity projection = vertical
-end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_2D_part4.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_2D_part4.prm.bak
deleted file mode 100644
index 3f5ec4647db..00000000000
--- a/cookbooks/crustal_deformation/doc/crustal_model_2D_part4.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.95
-  set Strategy                           = strain rate
-  set Coarsening fraction                = 0.05
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-end
diff --git a/cookbooks/crustal_deformation/doc/crustal_model_3D_part1.prm.bak b/cookbooks/crustal_deformation/doc/crustal_model_3D_part1.prm.bak
deleted file mode 100644
index 8d19f6bc84a..00000000000
--- a/cookbooks/crustal_deformation/doc/crustal_model_3D_part1.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-subsection Boundary velocity model
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = cm=0.01, year=1
-    set Function expression =  if (x<56e3 && y<=48e3 | x<72e3 && y>48e3,-1*cm/year,1*cm/year);0;0
-  end
-end
diff --git a/cookbooks/fastscape_eroding_box/fastscape_eroding_box.prm.bak b/cookbooks/fastscape_eroding_box/fastscape_eroding_box.prm.bak
deleted file mode 100644
index eeadbbaae4b..00000000000
--- a/cookbooks/fastscape_eroding_box/fastscape_eroding_box.prm.bak
+++ /dev/null
@@ -1,177 +0,0 @@
-# This cookbook is used as a test to ensure that FastScape is properly working with ASPECT.
-# It consists of a 2.5 km high central mountain block that is eroded through the use of
-# hillslope diffusion and the Stream Power Law. Within ASPECT, the model is based off
-# convection-box-3d. However, it is set up in a way that nothing happens in the geodynamic model.
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 2.5e5
-set Maximum time step                      = 50000
-set Output directory                       = eroding_box
-set Pressure normalization                 = no
-set Surface pressure                       = 0
-
-# A box that has an initial 60x60 km mountain block that is 2.5 km above the initial model surface.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 125e3
-    set Y extent = 100e3
-    set Z extent = 25e3
-    set X repetitions = 5
-    set Y repetitions = 4
-  end
-
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function expression = if(y>20e3 && y<80e3 && x>32.5e3 && x<92.5e3, 2500, 0)
-    end
-  end
-end
-
-# We do not consider temperature in this setup
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = initial temperature
-end
-
-# X Set all boundaries except the top to freeslip.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, front, back, left, right
-end
-
-# Here we setup the top boundary with fastscape.
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top : fastscape
-  set Additional tangential mesh velocity boundary indicators = left, right, front, back
-
-  subsection Fastscape
-    # As the highest resolution at the surface is 4 in the mesh refinement function, we set this the same.
-    set Maximum surface refinement level = 4
-
-    # Because we only have the same level across the entire surface we set this to zero.
-    # If we had multiple resolutions, e.g. 3 different cell sizes at the surface,
-    # this would be set to 2 (number of cell sizes at surface - 1).
-    set Surface refinement difference = 0
-
-    # We set FastScape as 1 level more resolved than ASPECT's initial global surface resolution.
-    set Additional fastscape refinement = 1
-
-    # Number of FastScape timesteps we want per ASPECT timestep.
-    set Number of fastscape timesteps per aspect timestep = 5
-
-    # Set the maximum allowable FastScape time step length. If the (ASPECT time step length)/(Number of FastScape steps per ASPECT step)
-    # is greater than this value, then the number of FastScape steps per ASPECT step is automatically doubled.
-    # This is continued until the FastScape timestep length is less than this value.
-    #
-    # The units of this parameter are either years or seconds, dependent on the global parameter that
-    # determines whether an input file uses one or the other.
-    set Maximum timestep length = 10000
-
-    # Seed number for initial topography noise
-    set Fastscape seed = 1000
-
-    # Because no boundaries are periodic, no flux is prescribed, and no advection occurs in FastScape,
-    # we do not need ghost nodes.
-    set Use ghost nodes = false
-    set Vertical exaggeration = 1
-
-    # Fix all boundaries in FastScape.
-    subsection Boundary conditions
-      set Front = 1
-      set Right  = 1
-      set Back    = 1
-      set Left   = 1
-    end
-
-    # We use both the Stream Power Law (SPL) and hillslope diffusion. The bedrock deposition
-    # variable allows deposition of sediment; however, because
-    # the sediment variables are not set, they are equal to
-    # bedrock values.
-    subsection Erosional parameters
-      set Drainage area exponent = 0.4
-      set Bedrock diffusivity = 1e-2
-      set Bedrock river incision rate = 1e-4
-      set Slope exponent = 1
-      set Bedrock deposition coefficient = 1
-
-      # A negative value indicates varied flow. 10 is steepest descent, and 1 is uniform distribution.
-      set Multi-direction slope exponent = -1
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-# Dimensionless
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# We set a maximum surface refinement level of 4 using the max/minimum refinement level.
-# This will make it so that the ASPECT surface refinement is the same as what we set
-# for our maximum surface refinement level for FastScape.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 1
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = minimum refinement function, maximum refinement function
-
-  subsection Maximum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y,z
-    set Function expression = if(z>=21000, 4, 2)
-  end
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y,z
-    set Function expression = if(z>=21000, 4, 2)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set List of output variables      = strain rate
-    set Interpolate output = true
-    set Write higher order output = true
-  end
-end
diff --git a/cookbooks/finite_strain/doc/finite_strain.part.prm.bak b/cookbooks/finite_strain/doc/finite_strain.part.prm.bak
deleted file mode 100644
index 85b15281c49..00000000000
--- a/cookbooks/finite_strain/doc/finite_strain.part.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-set Additional shared libraries            = ./libfinite_strain.so
-
-subsection Material model
-  set Model name = finite strain
-
-  subsection Simple model
-    set Thermal conductivity = 4.7
-    set Reference density = 3400
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity = 5e21
-    set Thermal viscosity exponent = 7
-    set Reference temperature = 1600
-  end
-end
diff --git a/cookbooks/finite_strain/finite_strain.cc.bak b/cookbooks/finite_strain/finite_strain.cc.bak
deleted file mode 100644
index 88ba08af862..00000000000
--- a/cookbooks/finite_strain/finite_strain.cc.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class FiniteStrain : public MaterialModel::Simple<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-        void parse_parameters(ParameterHandler &prm) override;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    FiniteStrain<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // First, we use the material descriptions of the 'simple' material model to fill all of the material
-      // model outputs. Below, we will then overwrite selected properties (the reaction terms), which are
-      // needed to track the finite strain.
-      Simple<dim>::evaluate(in, out);
-
-      // We need the velocity gradient for the finite strain (they are not included in material model inputs),
-      // so we get them from the finite element.
-      if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0)
-        {
-          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+1);
-          FEValues<dim> fe_values (this->get_mapping(),
-                                   this->get_fe(),
-                                   quadrature_formula,
-                                   update_gradients);
-
-          std::vector<Tensor<2,dim>> velocity_gradients (quadrature_formula.size(), Tensor<2,dim>());
-
-          fe_values.reinit (in.current_cell);
-          fe_values[this->introspection().extractors.velocities].get_function_gradients (this->get_solution(),
-                                                                                         velocity_gradients);
-
-          // Assign the strain components to the compositional fields reaction terms.
-          // If there are too many fields, we simply fill only the first fields with the
-          // existing strain rate tensor components.
-          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
-            {
-              // Convert the compositional fields into the tensor quantity they represent.
-              const Tensor<2,dim> strain(make_array_view(&in.composition[q][0],
-                                                         &in.composition[q][0] + Tensor<2,dim>::n_independent_components));
-
-              // Compute the strain accumulated in this timestep.
-              const Tensor<2,dim> strain_increment = this->get_timestep() * (velocity_gradients[q] * strain);
-
-              // Output the strain increment component-wise to its respective compositional field's reaction terms.
-              strain_increment.unroll(&out.reaction_terms[q][0],
-                                      &out.reaction_terms[q][0] + Tensor<2,dim>::n_independent_components);
-            }
-        }
-    }
-
-
-    template <int dim>
-    void
-    FiniteStrain<dim>::
-    parse_parameters (ParameterHandler &prm)
-    {
-      Simple<dim>::parse_parameters (prm);
-
-      AssertThrow(this->n_compositional_fields() >= (Tensor<2,dim>::n_independent_components),
-                  ExcMessage("There must be at least as many compositional fields as independent components in the full "
-                             "strain rate tensor."));
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(FiniteStrain,
-                                   "finite strain",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but tracks the finite strain as compositional "
-                                   "fields. More precisely, the model assumes that the first 4 (in 2D) "
-                                   "or 9 (in 3D) compositional fields contain the components "
-                                   "of the deformation gradient tensor, $\\mathbf F$, which can "
-                                   "be polar-decomposed into the left stretching tensor "
-                                   "$\\mathbf L$ (the finite strain we are interested in), and the "
-                                   "rotation tensor $\\mathbf Q$. See the corresponding cookbook in "
-                                   "the manual for more detailed information.")
-  }
-}
diff --git a/cookbooks/finite_strain/finite_strain.prm.bak b/cookbooks/finite_strain/finite_strain.prm.bak
deleted file mode 100644
index 1347f0827c5..00000000000
--- a/cookbooks/finite_strain/finite_strain.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Model for global mantle convection with tracking of the finite strain tensor.
-
-set Additional shared libraries            = ./libfinite_strain_cookbook.so
-set Adiabatic surface temperature          = 1600
-set Maximum time step                      = 1e6
-set Dimension                              = 2
-set End time                               = 6e8
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Output directory                       = output-finite_strain
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 2780
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0;0.0;0.0;1.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 8700000
-    set Y extent = 2900000
-    set X repetitions = 3
-    set X periodic = true
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 5e8
-    set Age top boundary layer    = 3e8
-    set Amplitude                 = 0
-    set Position                  = center
-    set Radius                    = 350000
-
-    subsection Function
-      set Function expression       = 0;0;0;0
-    end
-  end
-end
-
-subsection Material model
-  set Model name = finite strain
-  set Material averaging = none
-
-  subsection Simple model
-    set Thermal conductivity = 4.7
-    set Reference density = 3400
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity = 5e21
-    set Thermal viscosity exponent = 7
-    set Reference temperature = 1600
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 6
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top,bottom
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net x translation
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics
-
-  subsection Visualization
-    set List of output variables      = nonadiabatic temperature, strain rate
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Interpolate output            = true
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint = 1800
-end
diff --git a/cookbooks/free_surface/doc/free_surface.part.prm.bak b/cookbooks/free_surface/doc/free_surface.part.prm.bak
deleted file mode 100644
index a4d60719ccb..00000000000
--- a/cookbooks/free_surface/doc/free_surface.part.prm.bak
+++ /dev/null
@@ -1,41 +0,0 @@
-set Maximum first time step                = 1e3
-set Maximum relative increase in time step = 30
-set Pressure normalization                 = no
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left, right, bottom, top
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = sqrt((x-250.e3)^2 + (y-100.e3)^2) < 25.e3 ? 200.0 : 0.0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set Time between graphical output = 1.e6
-  end
-end
diff --git a/cookbooks/free_surface/free_surface.prm.bak b/cookbooks/free_surface/free_surface.prm.bak
deleted file mode 100644
index ada080f9918..00000000000
--- a/cookbooks/free_surface/free_surface.prm.bak
+++ /dev/null
@@ -1,141 +0,0 @@
-# This is a very simple cookbook which demonstrates the use of a free surface
-# for computing surface topography. The model is a 2D box, with a rising blob
-# beneath a free surface that generates an initially increasing and then
-# decaying surface topography while its heat diffuses. We output the maximum
-# and minimum topography at every time step to document the evolution of
-# topography.
-
-set Dimension                              = 2
-set End time                               = 2e7
-set Use years in output instead of seconds = true
-set Output directory                       = output-free_surface
-
-# Free surface calculations are typically more difficult to stabilize, and tend
-# to mesh oscillations, in particular for the initial time steps. Thus, we limit
-# the initial time steps to a smaller size (1000 years, and we allow each time
-# step to only grow by 30% compared to the last one to avoid jumps in time step
-# length). We could also reduce the CFL number to decrease all time steps, but
-# that would slow down the whole model instead of just the first time steps.
-set Maximum first time step                = 1e3
-set Maximum relative increase in time step = 30
-set CFL number                             = 1.0
-
-# Pressure normalization must be set to ``no'' for free surface models, as its
-# equations are based on the assumption that the pressure is zero at the free
-# surface.
-set Pressure normalization                 = no
-
-# We can use any of the normal geometry models for free surface modeling, we
-# just need to specify further down which surface is to be the free one. We
-# here use a box model with vertical downwards gravity.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Here is the major new section for this parameter file, specifying the
-# parameters for running free surface calculations.
-subsection Mesh deformation
-  # We specify a comma delimited list of all boundaries for which the mesh will
-  # deform (the top boundary), and the method by which their deformation is
-  # determined (in this case a free surface).
-  set Mesh deformation boundary indicators = top: free surface
-
-  # We can specify the free surface stabilization parameter
-  # theta, between zero and one with 0.5 being the default.
-  # If the parameter is zero, there is no stabilization
-  # and you are likely to see a sloshing instability develop. If
-  # it is one, the surface should be the most stable, though you
-  # may find that the rates that it moves are fairly damped.
-  # See the paper describing the free surface for more details on
-  # this parameter.
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-# Here we specify that the model has free slip velocity boundary conditions for
-# the sides and bottom. We do not specify a boundary condition for the top,
-# which is equivalent to a zero stress boundary condition. This means while the
-# section above describes how the mesh deforms, this section still describes
-# how the velocity should behave at these boundaries, and only the combination
-# of prescribing the mesh to move with the velocity and allowing the velocity
-# to move through the boundary generates the effect we commonly call "free
-# surface".
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-end
-
-# We prescribe a zero boundary temperature, as we are just modeling a single
-# rising blob
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left, right, bottom, top
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
-  end
-end
-
-# Our temperature initial conditions are simply a blob of hot
-# rock in the center of the domain.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = sqrt((x-250.e3)^2 + (y-100.e3)^2) < 25.e3 ? 200.0 : 0.0
-  end
-end
-
-# A fairly standard simple material model, except we use an
-# artificially low thermal conductivity to keep our anomaly
-# from diffusing too fast.
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 1.0
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e20
-  end
-end
-
-# For simplicity we disable adaptive mesh refinement,
-# although it would significantly speed up this model
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-# We also include the topography postprocessor, which just calculates
-# the maximum and minimum topography on your free surface at
-# every time step.
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set Time between graphical output = 1.e6
-  end
-end
diff --git a/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part1.prm.bak b/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part1.prm.bak
deleted file mode 100644
index 9b69c3b729a..00000000000
--- a/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part1.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-# This model loads an additional shared library, which provides another
-# material model that is not part of the main ASPECT code, but instead
-# lies in in a subdirectory of this cookbook folder.
-set Additional shared libraries            = ./plugin/libsimpler_with_crust.so
diff --git a/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part2.prm.bak b/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part2.prm.bak
deleted file mode 100644
index 1a2d0b1f977..00000000000
--- a/cookbooks/free_surface_with_crust/doc/free_surface_with_crust.part2.prm.bak
+++ /dev/null
@@ -1,19 +0,0 @@
-# Because we load the additional shared library at the top, we here have the
-# option to choose the new material model that is described inside that library
-# called 'simpler with crust'. This model has additional input options for the
-# two layers with different viscosities and the depth of the transition between
-# the two layers.
-subsection Material model
-  set Model name = simpler with crust
-
-  subsection Simpler with crust model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 1.0
-    set Thermal expansion coefficient = 4e-5
-    set Lower viscosity               = 1.e20
-    set Upper viscosity               = 1.e23
-    set Jump height                   = 170.e3
-  end
-end
diff --git a/cookbooks/free_surface_with_crust/free_surface_with_crust.prm.bak b/cookbooks/free_surface_with_crust/free_surface_with_crust.prm.bak
deleted file mode 100644
index 1f17a9c109d..00000000000
--- a/cookbooks/free_surface_with_crust/free_surface_with_crust.prm.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-# This cookbook is an extension of the free_surface cookbook. Please see the
-# other cookbook for details about the free surface. This cookbook illustrates
-# how to use an external plugin to modify the material model, and what
-# influence a viscous crust has on the magnitude of surface topography.
-
-# This model loads an additional shared library, which provides another
-# material model that is not part of the main ASPECT code, but instead
-# lies in in a subdirectory of this cookbook folder.
-set Additional shared libraries            = ./plugin/libsimpler_with_crust.so
-set Dimension                              = 2
-set End time                               = 2e7
-set Use years in output instead of seconds = true
-set Output directory                       = output-free_surface_with_crust
-set Maximum first time step                = 1e3
-set Maximum relative increase in time step = 30
-set CFL number                             = 1.0
-set Pressure normalization                 = no
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left, right, bottom, top
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
-  end
-end
-
-# As in the free_surface cookbook our temperature initial conditions are simply
-# a blob of hot rock in the center of the domain.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = sqrt((x-250.e3)^2 + (y-100.e3)^2) < 25.e3 ? 200.0 : 0.0
-  end
-end
-
-# Because we load the additional shared library at the top, we here have the
-# option to choose the new material model that is described inside that library
-# called 'simpler with crust'. This model has additional input options for the
-# two layers with different viscosities and the depth of the transition between
-# the two layers.
-subsection Material model
-  set Model name = simpler with crust
-
-  subsection Simpler with crust model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 1.0
-    set Thermal expansion coefficient = 4e-5
-    set Lower viscosity               = 1.e20
-    set Upper viscosity               = 1.e23
-    set Jump height                   = 170.e3
-  end
-end
-
-# For simplicity we disable adaptive mesh refinement,
-# although it would significantly speed up this model
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set List of output variables = material properties
-    set Time between graphical output = 1.e6
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-end
diff --git a/cookbooks/free_surface_with_crust/plugin/simpler_with_crust.cc.bak b/cookbooks/free_surface_with_crust/plugin/simpler_with_crust.cc.bak
deleted file mode 100644
index db2922e301d..00000000000
--- a/cookbooks/free_surface_with_crust/plugin/simpler_with_crust.cc.bak
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-#include <cmath>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model similar to the "simpler" material model, but where the
-     * viscosity has two different values dependent on whether we are above or
-     * below a line at a certain z-value, i.e., representing a crustal layer.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class SimplerWithCrust : public Interface<dim>
-    {
-      public:
-        /**
-         * Return whether the model is compressible or not. This model is
-         * incompressible.
-         */
-        bool is_compressible () const override;
-
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                      typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        double reference_density;
-        double reference_temperature;
-        double eta_L;
-        double eta_U;
-        double jump_height;
-        double thermal_expansion_coefficient;
-        double reference_specific_heat;
-        double thermal_conductivity;
-    };
-
-
-
-    template <int dim>
-    bool
-    SimplerWithCrust<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    void
-    SimplerWithCrust<dim>::
-    evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-             typename Interface<dim>::MaterialModelOutputs &out ) const
-    {
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          const double z = in.position[i][1];
-
-          if (z>jump_height)
-            out.viscosities[i] = eta_U;
-          else
-            out.viscosities[i] = eta_L;
-
-          out.densities[i] = reference_density * (1.0 - thermal_expansion_coefficient * (in.temperature[i] - reference_temperature));
-          out.thermal_expansion_coefficients[i] = thermal_expansion_coefficient;
-          out.specific_heat[i] = reference_specific_heat;
-          out.thermal_conductivities[i] = thermal_conductivity;
-          out.compressibilities[i] = 0.0;
-          out.entropy_derivative_pressure[i] = 0.0;
-          out.entropy_derivative_temperature[i] = 0.0;
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    SimplerWithCrust<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simpler with crust model");
-        {
-          prm.declare_entry ("Reference density", "3300.",
-                             Patterns::Double (0.),
-                             "Reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. The reference temperature is used "
-                             "in the density formula. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Lower viscosity", "1e20",
-                             Patterns::Double (0.),
-                             "The value of the viscosity $\\eta_L$ in the lower layer. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Upper viscosity", "1e23",
-                             Patterns::Double (0.),
-                             "The value of the viscosity $\\eta_U$ in the upper layer. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Jump height", "100000.",
-                             Patterns::Double (0.),
-                             "The height at which the viscosity changes. Units: \\si{\\meter}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250.",
-                             Patterns::Double (0.),
-                             "The value of the specific heat capacity $c_p$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\alpha$. "
-                             "Units: \\si{\\per\\kelvin}.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    SimplerWithCrust<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simpler with crust model");
-        {
-          reference_density          = prm.get_double ("Reference density");
-          reference_temperature      = prm.get_double ("Reference temperature");
-          eta_L                      = prm.get_double ("Lower viscosity");
-          eta_U                      = prm.get_double ("Upper viscosity");
-          jump_height                = prm.get_double ("Jump height");
-          thermal_conductivity       = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_expansion_coefficient = prm.get_double ("Thermal expansion coefficient");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.density = NonlinearDependence::none;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SimplerWithCrust,
-                                   "simpler with crust",
-                                   "A material model that is like the ``simpler'' model but "
-                                   "has a jump in the viscosity at a specified depth.")
-  }
-}
diff --git a/cookbooks/future/mantle_setup_restart.prm.bak b/cookbooks/future/mantle_setup_restart.prm.bak
deleted file mode 100644
index 1117b749463..00000000000
--- a/cookbooks/future/mantle_setup_restart.prm.bak
+++ /dev/null
@@ -1,30 +0,0 @@
-include ./mantle_setup_start.prm
-
-set Dimension                              = 2
-set End time                               = 3e8
-set Resume computation                     = true
-set Nonlinear solver tolerance             = 1e-4
-
-subsection Melt settings
-  set Include melt transport               = true
-  set Melt scaling factor threshold        = 1e-8
-end
-
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction time step                     = 2e2
-    set Reaction time steps per advection step = 20
-  end
-end
-
-subsection Material model
-  subsection Melt boukare
-    set Melting time scale for operator splitting = 1e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 2
-  set Time steps between mesh refinement       = 3
-end
diff --git a/cookbooks/future/mantle_setup_start.prm.bak b/cookbooks/future/mantle_setup_start.prm.bak
deleted file mode 100644
index 4b733a7e240..00000000000
--- a/cookbooks/future/mantle_setup_start.prm.bak
+++ /dev/null
@@ -1,192 +0,0 @@
-# Model for melt transport within the lowermost mantle.
-# This input file runs a model without melt transport to
-# steady state, and the file mantle_setup_restart.prm
-# restarts it with melt migration enabled.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1.5e8    # run until 1.5e8, then restart with Melt scaling factor threshold = 1e-8
-set Output directory                       = output_ULVZ_2
-set Nonlinear solver scheme                = iterated IMPES
-set Max nonlinear iterations               = 20
-
-#set Resume computation = true
-set Pressure normalization                 = surface
-
-# The top of the model is 200 km above the CMB, so we have to choose the surface pressure
-# accordingly. With this value, the CMB pressure should be 136 GPa.
-set Surface pressure                       = 1.25e11
-set Adiabatic surface temperature          = 2510
-set Use conduction timestep                = true
-set Use operator splitting                 = true
-set Maximum time step                      = 1e6
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
-end
-
-# The melt scaling factor threshold controls the porosity above which melt is transported
-# in a given cell of the model. Since the value of 1e20 is never reached anywhere in the
-# model, setting the parameter to this value disables melt transport. For the restart, this
-# value is decreased to enable melt transport.
-subsection Melt settings
-  set Include melt transport               = true
-  set Melt scaling factor threshold        = 1e20
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set GMRES solver restart length = 200
-  end
-
-  subsection Operator splitting parameters
-    set Reaction time step                     = 4e3 #2e2 for the restart
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 600000
-    set Y extent = 200000
-    set X periodic = false
-    set X repetitions = 3
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 5e7
-
-    subsection Function
-      set Function expression = 0; 0.07; 0.07
-    end
-  end
-
-  subsection Function
-    set Function constants  = amplitude=500, width=50000, b=100000, x0=300000 #25000
-    set Function expression = 10 * exp(-((x-x0)*(x-x0)/(2*5000*5000)+y*y/(2*5000*5000)))
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function, porosity
-
-  subsection Function
-    set Function expression = 0; 0.07; 0.07
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       =
-  set Prescribed velocity boundary indicators =
-  set Tangential velocity boundary indicators = bottom, left, right
-end
-
-subsection Boundary temperature model
-  set Allow fixed temperature on outflow boundaries = false
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Maximal temperature = 4000
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-  set Fixed composition boundary indicators   = top
-  set Model name = initial composition
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating, latent heat melt
-
-  subsection Latent heat melt
-    set Melting entropy change = 0
-    set Retrieve entropy change from material model = true
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Material model
-  set Model name = melt boukare
-
-  subsection Melt boukare
-    set Thermal conductivity          = 8.5
-    set Reference shear viscosity     = 1e23
-    set Reference bulk viscosity      = 1e23
-    set Reference volumes             = 2.534e-05, 2.445e-05, 1.206e-05, 1.125e-05, 1.9e-5, 1.218e-05, 1.218e-05
-    set Thermal viscosity exponent    = 10
-    set Thermal bulk viscosity exponent = 10
-    set Exponential melt weakening factor    = 20
-    set Include melting and freezing  = true
-    set Melting time scale for operator splitting = 1e5
-    set Fe mantle melting temperature = 2774.5
-    set Mg mantle melting temperature = 4171.2
-    set Reference permeability        = 5e-12
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 2
-  set Time steps between mesh refinement       = 3
-  set Strategy                                 = composition threshold, minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system = cartesian
-    set Function expression = (x>285000 && x<315000) ? 7 : 4
-  end
-
-  subsection Composition threshold
-    set Compositional field thresholds = 2e-4, 1, 1
-  end
-end
-
-subsection Boundary fluid pressure model
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e6
-    set List of output variables = material properties, nonadiabatic temperature, melt fraction, melt material properties, named additional outputs
-    set Output format = vtu
-    set Interpolate output = false
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
-    end
-
-    subsection Melt material properties
-      set List of properties = compaction viscosity, permeability, fluid density
-    end
-  end
-end
-
-subsection Checkpointing
-  # The wall time between performing checkpoints. If 0, will use the
-  # checkpoint step frequency instead. Units: Seconds.
-  set Time between checkpoint  = 900
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-end
diff --git a/cookbooks/future/net_rotation.prm.bak b/cookbooks/future/net_rotation.prm.bak
deleted file mode 100644
index ed9b661979d..00000000000
--- a/cookbooks/future/net_rotation.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-# A 2d shell with free slip top and bottom boundary to demonstrate
-# net rotation removal
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1.5e9
-set Output directory                       = output-netrot
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e20
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Nullspace removal
-  # net rotation|net translation|angular momentum|translational momentum
-  set Remove nullspace = net rotation
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 5
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/cookbooks/future/periodic_box.prm.bak b/cookbooks/future/periodic_box.prm.bak
deleted file mode 100644
index b675d2d538e..00000000000
--- a/cookbooks/future/periodic_box.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-# This is a simple 2d setup that is periodic in x direction, which
-# requires removing the nullspace (here we use "net x translation")
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e9
-set Output directory                       = output-periodic_box
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = no
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 0.0
-    set Bottom temperature = 1000.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set X extent = 1.e6
-    set Y extent = 5.e5
-    set Z extent = 5.e5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e20
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 6
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.03
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 10
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net x translation
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables =
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-    set Time between graphical output = 1.e3
-  end
-end
diff --git a/cookbooks/future/radiogenic_heating.prm.bak b/cookbooks/future/radiogenic_heating.prm.bak
deleted file mode 100644
index 1d04f7d6a78..00000000000
--- a/cookbooks/future/radiogenic_heating.prm.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-############### Global parameters
-# We use a 2d setup. Since it takes some time for
-# the model to reach a steady state we set the
-# end time to approximately 2 million years.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 2e6
-set Use years in output instead of seconds = false
-set Output directory                       = output-radiogenic_heating
-
-subsection Heating model
-  set List of model names = constant heating
-
-  subsection Constant heating
-    set Radiogenic heating rate = 1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-############### Boundary conditions
-# We only fix the temperature at the upper boundary, the other boundaries
-# are isolating.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# To guarantuee a steady downward flow, we fix the velocity
-# at the top and bottom, and set it to free slip on the sides.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Function expression = 0;-1
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 0.0
-    set Thermal expansion coefficient                  = 0.0
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 1e4
-    set List of output variables      = density
-  end
-end
diff --git a/cookbooks/future/radiogenic_heating_function.prm.bak b/cookbooks/future/radiogenic_heating_function.prm.bak
deleted file mode 100644
index 57b8d692dac..00000000000
--- a/cookbooks/future/radiogenic_heating_function.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-############### Global parameters
-# We use a 2d setup. Since it takes some time for
-# the model to reach a steady state we set the
-# end time to approximately 2 million years.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 3e6
-set Use years in output instead of seconds = false
-set Output directory                       = output-radiogenic_heating_function
-
-# As we only want to look at the effects of radiogenic heating, this one
-# is the only active heating plugin.
-subsection Heating model
-  set List of model names = function
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = length=1000000
-    set Function expression = if(t<2e6,x / length, 0.0)
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-############### Boundary conditions
-# We only fix the temperature at the upper boundary, the other boundaries
-# are isolating.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# To guarantuee a steady downward flow, we fix the velocity
-# at the top and bottom, and set it to free slip on the sides.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Function expression = 0;-1
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 0.0
-    set Thermal expansion coefficient                  = 0.0
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 1e4
-    set List of output variables      = density
-  end
-end
diff --git a/cookbooks/future/sphere.prm.bak b/cookbooks/future/sphere.prm.bak
deleted file mode 100644
index c12f5efbbe0..00000000000
--- a/cookbooks/future/sphere.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# A simple setup for convection in a sphere
-# manual for more information.
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 5.0e8
-set Output directory                       = output-sphere
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e20
-  end
-end
-
-subsection Geometry model
-  set Model name = sphere
-
-  subsection Sphere
-    set Radius  = 1250000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = top: 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if( sqrt( (x-5.e5)^2 + (y-5.e5)^2) < 1.e5, 0, 100)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial linear
-
-  subsection Radial linear
-    set Magnitude at bottom = 0.0
-    set Magnitude at surface = 4.5
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 5
-  set Initial adaptive refinement        = 2
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-end
diff --git a/cookbooks/geomio/doc/geomIO.prm.bak b/cookbooks/geomio/doc/geomIO.prm.bak
deleted file mode 100644
index 3ac91a8771b..00000000000
--- a/cookbooks/geomio/doc/geomIO.prm.bak
+++ /dev/null
@@ -1,40 +0,0 @@
-subsection Geometry model
-  set Model name = box
-
-  # The extents of the box is the same as the width
-  # and height of the drawing in px
-  # (an A4 page = 7350x10500 px).
-  subsection Box
-    set X extent = 7350
-    set Y extent = 10500
-  end
-end
-
-# We need one compositional field that will be assigned
-# the values read in from the ascii data plugin.
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-# We use the ascii data plugin to read in the file created with geomIO.
-subsection Initial composition model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = jelly.txt
-  end
-end
-
-# We refine the mesh where compositional gradients are
-# high, i.e. at the boundary between the different phases
-# assigned to the compositional field through the initial
-# condition.
-subsection Mesh refinement
-  set Refinement fraction                      = 0.99
-  set Coarsening fraction                      = 0
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 4
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = composition
-end
diff --git a/cookbooks/geomio/geomIO.prm.bak b/cookbooks/geomio/geomIO.prm.bak
deleted file mode 100644
index 96034af10f6..00000000000
--- a/cookbooks/geomio/geomIO.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# A model using the ascii data plugin to read in a file
-# generated by geomIO.
-# See the manual for more information.
-
-set Output directory                       = output-geomIO
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  # The extents of the box in m is the same as the width
-  # and height of the drawing in px
-  # (an A4 page = 7350x10500 px).
-  subsection Box
-    set X extent = 7350
-    set Y extent = 10500
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-# We need one compositional field that will be assigned
-# the values read in from the ascii data plugin.
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-# We use the ascii data plugin to read in the file created with geomIO.
-subsection Initial composition model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = jelly.txt
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = box
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-# We refine the mesh where compositional gradients are
-# high, i.e. at the boundary between the different phases
-# assigned to the compositional field through the initial
-# condition.
-subsection Mesh refinement
-  set Refinement fraction                      = 0.99
-  set Coarsening fraction                      = 0
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 4
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = composition
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0.01
-  end
-end
diff --git a/cookbooks/global_melt/doc/global_melt.prm.bak b/cookbooks/global_melt/doc/global_melt.prm.bak
deleted file mode 100644
index 5c82d601395..00000000000
--- a/cookbooks/global_melt/doc/global_melt.prm.bak
+++ /dev/null
@@ -1,248 +0,0 @@
-# Cookbook for a global-scale 2D box mantle convection model
-# with melt migration.
-# In this file we will go through all of the steps that are
-# required for adding melting and melt transport to a mantle
-# convection simulation.
-
-# For models with melt migration, there is a nonlinear coupling between
-# the Stokes system, the temperature, and the advection equation for the
-# porosity (several material properties, such as the viscosities and the
-# permeability depend nonlinearly on the porosity; and changes in temperature
-# determine how much material is melting or freezing).
-# Because of that, we use a nonlinear solver scheme ('iterated Advection and Stokes')
-# that iterates between all of these equations, and we have to set its
-# solver tolerance and the maximum number of iterations separately from
-# the linear solver parameters.
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 20
-set Nonlinear solver tolerance             = 1e-5
-
-# In addition, melting and freezing normally happens on a much faster
-# time scale than the flow of melt, so we want to decouple the advection
-# of melt (and temperature) and the melting process itself. To do that,
-# we use the operator splitting scheme, and define that for every
-# advection time step, we want to do at least 10 reaction time steps.
-# If these time steps would be larger than 10,000 years, we will do
-# more reaction time steps (so that reaction time step size never exceeds
-# 10,000 years). Here, we also specify the Stokes linear solver tolerance
-# and maximum number of cheap Stokes solver steps to improve the nonlinear
-# convergence behavior.
-set Use operator splitting                     = true
-
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction time step                     = 1e4
-    set Reaction time steps per advection step = 10
-  end
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 100
-  end
-end
-
-subsection Melt settings
-  # In addition, we now also specify in the model settings that we want to
-  # run a model with melt transport.
-  set Include melt transport                  = true
-end
-
-##################### Settings for melt transport ########################
-
-# In models with melt transport, we always need a compositional field with
-# the name 'porosity'. Only the field with that name will be advected with
-# the melt velocity, all other compositional fields will continue to work
-# as before. Material models will typically query for the field with the
-# name porosity to compute all melt material properties.
-# In addition, the 'melt global' material model also requires a field with the
-# name 'peridotite'. This field is used to track how much material has been
-# molten at each point of the model, so it tracks the information how the
-# composition of the rock changes due to partial melting events (sometimes
-# also called depletion). This is important, because usually less melt is
-# generated for a given temperature and pressure if the rock has undergone
-# melting before. Typically, material properties like the density are also
-# different for more or less depleted material.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-##################### Initial conditions ########################
-
-# Now that our model uses compositional fields, we also need initial
-# conditions for the composition.
-# We use the function plugin to set both fields to zero at the beginning
-# of the model run.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0; 0
-    set Variable names      = x,y
-  end
-end
-
-##################### Boundary conditions ########################
-
-# We again choose the initial composition as boundary condition
-# for all compositional fields.
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Models with melt transport also need an additional boundary condition:
-# the gradient of the fluid pressure at the model boundaries. This boundary
-# condition indirectly also prescribes boundary conditions for the melt velocity,
-# as the melt velocity is related to the fluid pressure gradient via Darcy's law.
-# If we choose the fluid pressure gradient = solid density * gravity, melt will
-# flow in and out of the model (even if the solid can not flow out) according to
-# the dynamic fluid pressure in the model. Conversely, if we choose the
-# fluid pressure gradient = fluid density * gravity, melt will flow in or out
-# with the same velocity as the solid (so for a closed boundary, no melt will
-# flow in or out). This is what we choose as our boundary condition here.
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-##################### Material properties ########################
-
-# In addition to the material properties for the solid rock,
-# we also have to specify properties for the melt.
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    # First we describe the parameters for the solid, in the same way
-    # we did in the model without melt transport
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Thermal expansion coefficient     = 2e-5
-    set Reference shear viscosity         = 5e21
-    set Thermal viscosity exponent        = 7
-    set Reference temperature             = 1600
-    set Solid compressibility             = 4.2e-12
-
-    # The melt usually has a different (lower) density than the solid.
-    set Reference melt density            = 3000
-
-    # The permeability describes how well the pores of a porous material
-    # are connected (and hence how fast melt can flow through the rock).
-    # It is computed as the product of the reference value given here
-    # and the porosity cubed. This means that the lower the porosity is
-    # the more difficult it is for the melt to flow.
-    set Reference permeability            = 1e-8
-
-    # The bulk viscosity describes the resistance of the rock to dilation
-    # and compaction. Melt can only flow into a region that had no melt
-    # before if the matrix of the solid rock expands, so this parameter
-    # also limits how fast melt can flow upwards.
-    # The bulk viscosity is computed as the reference value given here times
-    # a term that scales with one over the porosity. This means that for zero
-    # porosity, the rock can not dilate/compact any more, which is the same
-    # behavior that we have for solid mantle convection.
-    set Reference bulk viscosity          = 1e19
-
-    # In dependence of how much melt is present, we also weaken the shear
-    # viscosity: The more melt is present, the weaker the rock gets.
-    # This scaling is exponential, following the relation
-    # viscosity ~ exp(-alpha * phi),
-    # where alpha is the parameter given here, and phi is the porosity.
-    set Exponential melt weakening factor = 10
-
-    # In the same way the shear viscosity is reduced with increasing temperature,
-    # we also prescribe the temperature-dependence of the bulk viscosity.
-    set Thermal bulk viscosity exponent   = 7
-
-    # Analogous to the compressibility of the solid rock, we also define a
-    # comressibility for the melt (which is generally higher than for the solid).
-    # As we do not want our compressibility to depend on depth, we set the
-    # pressure derivative to zero.
-    set Melt compressibility              = 1.25e-11
-    set Melt bulk modulus derivative      = 0.0
-
-    # Finally, we prescribe the viscosity of the melt, which is used in Darcy's
-    # law. The lower this viscosity, the faster melt can flow.
-    set Reference melt viscosity          = 1
-
-    # change the density contrast of depleted material (in kg/m^3)
-    set Depletion density change          = -200.0
-
-    # How much melt has been generated and subsequently extracted from a particular
-    # volume of rock (how 'depleted' that volume of rock is) usually changes the
-    # solidus. The more the material has been molten already, the less melt will be
-    # generated afterwards for the same pressure and temperature conditions. We
-    # model this using a simplified, linear relationship, saying that to melt 100%
-    # of the rock the temperature has to be 200 K higher than to melt it initially.
-    set Depletion solidus change          = 200
-
-    # We also have to determine how fast melting and freezing should happen.
-    # Here, we choose a time scale of 10,000 years, which is a relatively long time
-    # (or in other words, slow melting rate), but because this is a global model
-    # and the time steps are big, it should be sufficient.
-    set Melting time scale for operator splitting = 1e4
-  end
-end
-
-##################### Mesh refinement #########################
-
-# For the model with melt migration, we use adaptive refinement.
-# We make use of two different refinement criteria: we set a minimum of 5 global
-# refinements everywhere in the model (which is the same resolution as for the
-# model without melt), and we refine in regions where melt is present, to be
-# precise, everywhere where the porosity is bigger than 1e-6.
-# We adapt the mesh every 5 time steps.
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 2
-  set Initial global refinement                = 5
-  set Strategy                                 = composition threshold, minimum refinement function, boundary
-  set Time steps between mesh refinement       = 5
-
-  # minimum of 5 global refinements
-  subsection Minimum refinement function
-    set Function expression = 5
-  end
-
-  # refine where the porosity is bigger than 1e-6
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-6,1.0
-  end
-
-  # refine at top and bottom boundary
-  subsection Boundary
-    set Boundary refinement indicators = top, bottom
-  end
-end
-
-##################### Postprocessing ########################
-
-# In addition to the visualization output, we select a number
-# of postprocessors that allow us to compute some statistics
-# about the output (to see how much the model without and the
-# model with melt migration differ), and in particular we use
-# the "depth average" postprocessor that will allow us to plot
-# depth-averaged model quantities over time.
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, depth average
-
-  # For the model with melt migration, also add a visualization
-  # postprocessor that computes the material properties relevant
-  # to migration (permeability, viscosity of the melt, etc.).
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt material properties
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
diff --git a/cookbooks/global_melt/doc/global_no_melt.prm.bak b/cookbooks/global_melt/doc/global_no_melt.prm.bak
deleted file mode 100644
index c6c5eaad18b..00000000000
--- a/cookbooks/global_melt/doc/global_no_melt.prm.bak
+++ /dev/null
@@ -1,211 +0,0 @@
-# Model setup for mantle convection in a 2D box without melting.
-# This file is used as a starting point for a cookbook that
-# explains how to add melting and melt transport to a mantle
-# convection simulation.
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 1600
-set Maximum time step                      = 1e6
-set Output directory                       = output-global_no_melt
-set Use years in output instead of seconds = true
-
-# The end time of the simulation. Because we want to see how upwellings
-# and downwellings evolve over time, and if differences develop between
-# the model with and without melt migration, we set the end time to 200 Ma.
-set End time                               = 2e8
-
-# We choose a stricter than default linear Stokes solver tolerance,
-# to be consistent with the global_melt cookbook.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 100
-  end
-end
-
-# We prescribe free-slip boundary conditions on all
-# sides.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-# We also choose relatively large values for the stabilization parameters:
-# The model resolution is very coarse (in order for this model to run in a
-# short time), so we want to make sure that no temperature over- and
-# undershoots will develop. In a model with melting this would be
-# particularly problematic, as large amounts of melt could be generated
-# by temperature spikes, and we want to be consistent between the model
-# with and without melt transport.
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.5
-    set cR    = 1
-  end
-end
-
-##################### Initial conditions ########################
-
-# We choose an adiabatic temperature profile as initial condition,
-# with conductive temperature profiles in the top and bottom boundary
-# layers, which were computed using a half space cooling model.
-# The cold top boundary layer corresponds to an age of 70 Ma,
-# and the hot top boundary layer corresponds to an age of 700 Ma.
-# A small temperature perturbation is added at the bottom of the
-# domain. To make the model asymmetric, we place it in a distance of
-# x = 2900 km from the left boundary.
-# Temperatures from both initial temperature models we specify are
-# added (by default).
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 7e8
-    set Age top boundary layer    = 7e7
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-
-  subsection Function
-    set Function constants        = r=350000, amplitude=50
-    set Function expression       = if((x-2900000)*(x-2900000)+y*y<r,amplitude,0)
-  end
-end
-
-##################### Boundary conditions ########################
-
-# As boundary conditions for the temperature, we just use the
-# initial conditions again. This temperature is applied as a prescribed
-# temperature at the top and bottom boundary.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3900
-  end
-end
-
-##################### Model geometry ########################
-
-# The model geometry is a box with an aspect ratio of 3,
-# extending to the base of the mantle in vertical direction.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 8700000
-    set Y extent = 2900000
-    set X repetitions = 3
-  end
-end
-
-################ Gravity and material properties ##################
-
-# The model has a constant gravity.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We use the melt global material model, which is one of the
-# material models that works with melt transport, as it also
-# specifies the material properties needed for melt migration,
-# such as the permeability, the melt density and the melt
-# viscosity.
-# It also works without melt transport, and in this case these
-# properties are not used, so we do not have to specify them
-# here.
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Thermal expansion coefficient     = 2e-5
-    set Reference shear viscosity         = 5e21
-    set Thermal viscosity exponent        = 7
-    set Reference temperature             = 1600
-    set Solid compressibility             = 4.2e-12
-  end
-end
-
-##################### Mesh refinement #########################
-
-# For the model without melt migration, we do not have to use
-# mesh adaptivity, because time- and length scales of material
-# motion does do not vary a lot across the model, and a global
-# resolution of 5 is sufficient to capture the behavior of
-# upwellings and downwellings. We nevertheless want to refine
-# the mesh near the top and bottom boundaries where large
-# thermal gradients occur.
-subsection Mesh refinement
-  set Initial adaptive refinement              = 2
-  set Initial global refinement                = 5
-  set Strategy                                 = minimum refinement function, boundary
-  set Time steps between mesh refinement       = 0
-
-  # minimum of 5 global refinements
-  subsection Minimum refinement function
-    set Function expression = 5
-  end
-
-  # refine at top and bottom boundary
-  subsection Boundary
-    set Boundary refinement indicators = top, bottom
-  end
-end
-
-# As the model is compressible and has an adiabatic temperature profile, we include
-# adiabatic heating in the list of heating models.
-# To make this model as simple as possible, we do not include shear heating (although
-# usually, adiabatic heating and shear heating should always be used together).
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-##################### Postprocessing ########################
-
-# In addition to the visualization output, we select a number
-# of postprocessors that allow us to compute some statistics
-# about the output (to see how much the model without and the
-# model with melt migration differ), and in particular we use
-# the "depth average" postprocessor that will allow us to plot
-# depth-averaged model quantities over time.
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, melt statistics, depth average
-
-  # For the model without melt migration, we only compute the
-  # equilibrium melt fraction in dependence of temperature and
-  # pressure. This is done as a postprocessing step, by adding
-  # "melt fraction" to the list of material properties in the
-  # corresponding visualization postprocessor.
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 6e5
-
-    subsection Material properties
-      set List of material properties = density, viscosity, melt fraction
-    end
-  end
-
-  subsection Depth average
-    set Number of zones = 12
-    set Time between graphical output = 6e5
-  end
-end
-
-# We write a checkpoint approximately every half an hour,
-# so that we are able to restart the computation from that
-# point.
-subsection Checkpointing
-  set Time between checkpoint = 1700
-end
diff --git a/cookbooks/global_melt/global_melt.prm.bak b/cookbooks/global_melt/global_melt.prm.bak
deleted file mode 100644
index 91db6ee9ea4..00000000000
--- a/cookbooks/global_melt/global_melt.prm.bak
+++ /dev/null
@@ -1,371 +0,0 @@
-# Cookbook for a global-scale 2D box mantle convection model
-# with melt migration.
-# In this file we will go through all of the steps that are
-# required for adding melting and melt transport to a mantle
-# convection simulation.
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 1600
-set Maximum time step                      = 1e6
-set Output directory                       = output-global_melt
-set Use years in output instead of seconds = true
-
-# For models with melt migration, there is a nonlinear coupling between
-# the Stokes system, the temperature, and the advection equation for the
-# porosity (several material properties, such as the viscosities and the
-# permeability depend nonlinearly on the porosity; and changes in temperature
-# determine how much material is melting or freezing).
-# Because of that, we use a nonlinear solver scheme ('iterated Advection and Stokes')
-# that iterates between all of these equations, and we have to set its
-# solver tolerance and the maximum number of iterations separately from
-# the linear solver parameters.
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 20
-set Nonlinear solver tolerance             = 1e-5
-
-# In addition, melting and freezing normally happens on a much faster
-# time scale than the flow of melt, so we want to decouple the advection
-# of melt (and temperature) and the melting process itself. To do that,
-# we use the operator splitting scheme, and define that for every
-# advection time step, we want to do at least 10 reaction time steps.
-# If these time steps would be larger than 10,000 years, we will do
-# more reaction time steps (so that reaction time step size never exceeds
-# 10,000 years). Here, we also specify the Stokes linear solver tolerance
-# and maximum number of cheap Stokes solver steps to improve the nonlinear
-# convergence behavior.
-set Use operator splitting                     = true
-
-# The end time of the simulation. Because we want to see how upwellings
-# and downwellings evolve over time, and if differences develop between
-# the model with and without melt migration, we set the end time to 200 Ma.
-set End time                               = 2e8
-
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction time step                     = 1e4
-    set Reaction time steps per advection step = 10
-  end
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 100
-  end
-end
-
-# We prescribe free-slip boundary conditions on all sides.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Melt settings
-  # In addition, we now also specify in the model settings that we want to
-  # run a model with melt transport.
-  set Include melt transport                  = true
-end
-
-##################### Settings for melt transport ########################
-
-# In models with melt transport, we always need a compositional field with
-# the name 'porosity'. Only the field with that name will be advected with
-# the melt velocity, all other compositional fields will continue to work
-# as before. Material models will typically query for the field with the
-# name porosity to compute all melt material properties.
-# In addition, the 'melt global' material model also requires a field with the
-# name 'peridotite'. This field is used to track how much material has been
-# molten at each point of the model, so it tracks the information how the
-# composition of the rock changes due to partial melting events (sometimes
-# also called depletion). This is important, because usually less melt is
-# generated for a given temperature and pressure if the rock has undergone
-# melting before. Typically, material properties like the density are also
-# different for more or less depleted material.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Discretization
-  # We also choose relatively large values for the stabilization parameters:
-  # The model resolution is very coarse (in order for this model to run in a
-  # short time), so we want to make sure that no temperature over- and
-  # undershoots will develop. In a model with melting this would be
-  # particularly problematic, as large amounts of melt could be generated
-  # by temperature spikes.
-  # However, note that in an application model with a higher resolution,
-  # we would choose much smaller values for the stabilization parameters.
-  subsection Stabilization parameters
-    set beta  = 0.5
-    set cR    = 1
-  end
-end
-
-##################### Initial conditions ########################
-
-# We choose an adiabatic temperature profile as initial condition,
-# with conductive temperature profiles in the top and bottom boundary
-# layers, which were computed using a half space cooling model.
-# The cold top boundary layer corresponds to an age of 70 Ma,
-# and the hot top boundary layer corresponds to an age of 700 Ma.
-# A small temperature perturbation is added at the bottom of the
-# domain. To make the model asymmetric, we place it in a distance of
-# x = 2900 km from the left boundary.
-# Temperatures from both initial temperature models we specify are
-# added (by default).
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 7e8
-    set Age top boundary layer    = 7e7
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-
-  subsection Function
-    set Function constants        = r=350000, amplitude=50
-    set Function expression       = if((x-2900000)*(x-2900000)+y*y<r,amplitude,0)
-  end
-end
-
-# Now that our model uses compositional fields, we also need initial
-# conditions for the composition.
-# We use the function plugin to set both fields to zero at the beginning
-# of the model run.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0; 0
-    set Variable names      = x,y
-  end
-end
-
-##################### Boundary conditions ########################
-
-# As boundary conditions for the temperature, we just use the
-# initial conditions again. This temperature is applied as a prescribed
-# temperature at the top and bottom boundary, as specified above.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3900
-  end
-end
-
-# We again choose the initial composition as boundary condition
-# for all compositional fields.
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Models with melt transport also need an additional boundary condition:
-# the gradient of the fluid pressure at the model boundaries. This boundary
-# condition indirectly also prescribes boundary conditions for the melt velocity,
-# as the melt velocity is related to the fluid pressure gradient via Darcy's law.
-# If we choose the fluid pressure gradient = solid density * gravity, melt will
-# flow in and out of the model (even if the solid can not flow out) according to
-# the dynamic fluid pressure in the model. Conversely, if we choose the
-# fluid pressure gradient = fluid density * gravity, melt will flow in or out
-# with the same velocity as the solid (so for a closed boundary, no melt will
-# flow in or out). This is what we choose as our boundary condition here.
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-##################### Model geometry ########################
-
-# The model geometry is a box with an aspect ratio of 3,
-# extending to the base of the mantle in vertical direction.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 8700000
-    set Y extent = 2900000
-    set X repetitions = 3
-  end
-end
-
-################ Gravity and material properties ##################
-
-# The model has a constant gravity.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We use the melt global material model, which is one of the
-# material models that works with melt transport, as it also
-# specifies the material properties needed for melt migration,
-# such as the permeability, the melt density and the melt
-# viscosity.
-# In addition to the material properties for the solid rock,
-# we also have to specify properties for the melt.
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    # First we describe the parameters for the solid, in the same way
-    # we did in the model without melt transport
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Thermal expansion coefficient     = 2e-5
-    set Reference shear viscosity         = 5e21
-    set Thermal viscosity exponent        = 7
-    set Reference temperature             = 1600
-    set Solid compressibility             = 4.2e-12
-
-    # The melt usually has a different (lower) density than the solid.
-    set Reference melt density            = 3000
-
-    # The permeability describes how well the pores of a porous material
-    # are connected (and hence how fast melt can flow through the rock).
-    # It is computed as the product of the reference value given here
-    # and the porosity cubed. This means that the lower the porosity is
-    # the more difficult it is for the melt to flow.
-    set Reference permeability            = 1e-8
-
-    # The bulk viscosity describes the resistance of the rock to dilation
-    # and compaction. Melt can only flow into a region that had no melt
-    # before if the matrix of the solid rock expands, so this parameter
-    # also limits how fast melt can flow upwards.
-    # The bulk viscosity is computed as the reference value given here times
-    # a term that scales with one over the porosity. This means that for zero
-    # porosity, the rock can not dilate/compact any more, which is the same
-    # behavior that we have for solid mantle convection.
-    set Reference bulk viscosity          = 1e19
-
-    # In dependence of how much melt is present, we also weaken the shear
-    # viscosity: The more melt is present, the weaker the rock gets.
-    # This scaling is exponential, following the relation
-    # viscosity ~ exp(-alpha * phi),
-    # where alpha is the parameter given here, and phi is the porosity.
-    set Exponential melt weakening factor = 10
-
-    # In the same way the shear viscosity is reduced with increasing temperature,
-    # we also prescribe the temperature-dependence of the bulk viscosity.
-    set Thermal bulk viscosity exponent   = 7
-
-    # Analogous to the compressibility of the solid rock, we also define a
-    # comressibility for the melt (which is generally higher than for the solid).
-    # As we do not want our compressibility to depend on depth, we set the
-    # pressure derivative to zero.
-    set Melt compressibility              = 1.25e-11
-    set Melt bulk modulus derivative      = 0.0
-
-    # Finally, we prescribe the viscosity of the melt, which is used in Darcy's
-    # law. The lower this viscosity, the faster melt can flow.
-    set Reference melt viscosity          = 1
-
-    # change the density contrast of depleted material (in kg/m^3)
-    set Depletion density change          = -200.0
-
-    # How much melt has been generated and subsequently extracted from a particular
-    # volume of rock (how 'depleted' that volume of rock is) usually changes the
-    # solidus. The more the material has been molten already, the less melt will be
-    # generated afterwards for the same pressure and temperature conditions. We
-    # model this using a simplified, linear relationship, saying that to melt 100%
-    # of the rock the temperature has to be 200 K higher than to melt it initially.
-    set Depletion solidus change          = 200
-
-    # We also have to determine how fast melting and freezing should happen.
-    # Here, we choose a time scale of 10,000 years, which is a relatively long time
-    # (or in other words, slow melting rate), but because this is a global model
-    # and the time steps are big, it should be sufficient.
-    set Melting time scale for operator splitting = 1e4
-  end
-end
-
-##################### Mesh refinement #########################
-
-# For the model with melt migration, we use adaptive refinement.
-# We make use of two different refinement criteria: we set a minimum of 5 global
-# refinements everywhere in the model (which is the same resolution as for the
-# model without melt), and we refine in regions where melt is present, to be
-# precise, everywhere where the porosity is bigger than 1e-6.
-# We adapt the mesh every 5 time steps.
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 2
-  set Initial global refinement                = 5
-  set Strategy                                 = composition threshold, minimum refinement function, boundary
-  set Time steps between mesh refinement       = 5
-
-  # minimum of 5 global refinements
-  subsection Minimum refinement function
-    set Function expression = 5
-  end
-
-  # refine where the porosity is bigger than 1e-6
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-6,1.0
-  end
-
-  # refine at top and bottom boundary
-  subsection Boundary
-    set Boundary refinement indicators = top, bottom
-  end
-end
-
-# As the model is compressible and has an adiabatic temperature profile, we include
-# adiabatic heating in the list of heating models.
-# To make this model as simple as possible, we do not include shear heating (although
-# usually, adiabatic heating and shear heating should always be used together).
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-##################### Postprocessing ########################
-
-# In addition to the visualization output, we select a number
-# of postprocessors that allow us to compute some statistics
-# about the output (to see how much the model without and the
-# model with melt migration differ), and in particular we use
-# the "depth average" postprocessor that will allow us to plot
-# depth-averaged model quantities over time.
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, depth average
-
-  # For the model with melt migration, also add a visualization
-  # postprocessor that computes the material properties relevant
-  # to migration (permeability, viscosity of the melt, etc.).
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 6e5
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-
-  subsection Depth average
-    set Number of zones = 12
-    set Time between graphical output = 6e5
-  end
-end
-
-# We write a checkpoint approximately every half an hour,
-# so that we are able to restart the computation from that
-# point.
-subsection Checkpointing
-  set Time between checkpoint = 1700
-end
diff --git a/cookbooks/global_melt/global_no_melt.prm.bak b/cookbooks/global_melt/global_no_melt.prm.bak
deleted file mode 100644
index c6c5eaad18b..00000000000
--- a/cookbooks/global_melt/global_no_melt.prm.bak
+++ /dev/null
@@ -1,211 +0,0 @@
-# Model setup for mantle convection in a 2D box without melting.
-# This file is used as a starting point for a cookbook that
-# explains how to add melting and melt transport to a mantle
-# convection simulation.
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 1600
-set Maximum time step                      = 1e6
-set Output directory                       = output-global_no_melt
-set Use years in output instead of seconds = true
-
-# The end time of the simulation. Because we want to see how upwellings
-# and downwellings evolve over time, and if differences develop between
-# the model with and without melt migration, we set the end time to 200 Ma.
-set End time                               = 2e8
-
-# We choose a stricter than default linear Stokes solver tolerance,
-# to be consistent with the global_melt cookbook.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 100
-  end
-end
-
-# We prescribe free-slip boundary conditions on all
-# sides.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-# We also choose relatively large values for the stabilization parameters:
-# The model resolution is very coarse (in order for this model to run in a
-# short time), so we want to make sure that no temperature over- and
-# undershoots will develop. In a model with melting this would be
-# particularly problematic, as large amounts of melt could be generated
-# by temperature spikes, and we want to be consistent between the model
-# with and without melt transport.
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.5
-    set cR    = 1
-  end
-end
-
-##################### Initial conditions ########################
-
-# We choose an adiabatic temperature profile as initial condition,
-# with conductive temperature profiles in the top and bottom boundary
-# layers, which were computed using a half space cooling model.
-# The cold top boundary layer corresponds to an age of 70 Ma,
-# and the hot top boundary layer corresponds to an age of 700 Ma.
-# A small temperature perturbation is added at the bottom of the
-# domain. To make the model asymmetric, we place it in a distance of
-# x = 2900 km from the left boundary.
-# Temperatures from both initial temperature models we specify are
-# added (by default).
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 7e8
-    set Age top boundary layer    = 7e7
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-
-  subsection Function
-    set Function constants        = r=350000, amplitude=50
-    set Function expression       = if((x-2900000)*(x-2900000)+y*y<r,amplitude,0)
-  end
-end
-
-##################### Boundary conditions ########################
-
-# As boundary conditions for the temperature, we just use the
-# initial conditions again. This temperature is applied as a prescribed
-# temperature at the top and bottom boundary.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3900
-  end
-end
-
-##################### Model geometry ########################
-
-# The model geometry is a box with an aspect ratio of 3,
-# extending to the base of the mantle in vertical direction.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 8700000
-    set Y extent = 2900000
-    set X repetitions = 3
-  end
-end
-
-################ Gravity and material properties ##################
-
-# The model has a constant gravity.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We use the melt global material model, which is one of the
-# material models that works with melt transport, as it also
-# specifies the material properties needed for melt migration,
-# such as the permeability, the melt density and the melt
-# viscosity.
-# It also works without melt transport, and in this case these
-# properties are not used, so we do not have to specify them
-# here.
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Thermal expansion coefficient     = 2e-5
-    set Reference shear viscosity         = 5e21
-    set Thermal viscosity exponent        = 7
-    set Reference temperature             = 1600
-    set Solid compressibility             = 4.2e-12
-  end
-end
-
-##################### Mesh refinement #########################
-
-# For the model without melt migration, we do not have to use
-# mesh adaptivity, because time- and length scales of material
-# motion does do not vary a lot across the model, and a global
-# resolution of 5 is sufficient to capture the behavior of
-# upwellings and downwellings. We nevertheless want to refine
-# the mesh near the top and bottom boundaries where large
-# thermal gradients occur.
-subsection Mesh refinement
-  set Initial adaptive refinement              = 2
-  set Initial global refinement                = 5
-  set Strategy                                 = minimum refinement function, boundary
-  set Time steps between mesh refinement       = 0
-
-  # minimum of 5 global refinements
-  subsection Minimum refinement function
-    set Function expression = 5
-  end
-
-  # refine at top and bottom boundary
-  subsection Boundary
-    set Boundary refinement indicators = top, bottom
-  end
-end
-
-# As the model is compressible and has an adiabatic temperature profile, we include
-# adiabatic heating in the list of heating models.
-# To make this model as simple as possible, we do not include shear heating (although
-# usually, adiabatic heating and shear heating should always be used together).
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-##################### Postprocessing ########################
-
-# In addition to the visualization output, we select a number
-# of postprocessors that allow us to compute some statistics
-# about the output (to see how much the model without and the
-# model with melt migration differ), and in particular we use
-# the "depth average" postprocessor that will allow us to plot
-# depth-averaged model quantities over time.
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, melt statistics, depth average
-
-  # For the model without melt migration, we only compute the
-  # equilibrium melt fraction in dependence of temperature and
-  # pressure. This is done as a postprocessing step, by adding
-  # "melt fraction" to the list of material properties in the
-  # corresponding visualization postprocessor.
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 6e5
-
-    subsection Material properties
-      set List of material properties = density, viscosity, melt fraction
-    end
-  end
-
-  subsection Depth average
-    set Number of zones = 12
-    set Time between graphical output = 6e5
-  end
-end
-
-# We write a checkpoint approximately every half an hour,
-# so that we are able to restart the computation from that
-# point.
-subsection Checkpointing
-  set Time between checkpoint = 1700
-end
diff --git a/cookbooks/gplates/doc/gplates.part.prm.bak b/cookbooks/gplates/doc/gplates.part.prm.bak
deleted file mode 100644
index 4f3d01aa47b..00000000000
--- a/cookbooks/gplates/doc/gplates.part.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:gplates
-  set Tangential velocity boundary indicators = bottom
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-    set Lithosphere thickness = 660000
-  end
-end
diff --git a/cookbooks/gplates/doc/slice1.part.prm.bak b/cookbooks/gplates/doc/slice1.part.prm.bak
deleted file mode 100644
index e6bacc4fdf1..00000000000
--- a/cookbooks/gplates/doc/slice1.part.prm.bak
+++ /dev/null
@@ -1,2 +0,0 @@
-set Point one = 3.1416,0.0
-set Point two = 1.5708,0.0
diff --git a/cookbooks/gplates/doc/slice2.part.prm.bak b/cookbooks/gplates/doc/slice2.part.prm.bak
deleted file mode 100644
index 9c267db6583..00000000000
--- a/cookbooks/gplates/doc/slice2.part.prm.bak
+++ /dev/null
@@ -1,2 +0,0 @@
-set Point one = 3.1416,1.5708
-set Point two = 1.5708,1.5708
diff --git a/cookbooks/gplates/gplates_2d.prm.bak b/cookbooks/gplates/gplates_2d.prm.bak
deleted file mode 100644
index e74c9637741..00000000000
--- a/cookbooks/gplates/gplates_2d.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# A simple setup for for using the GPlates interface in a 2d shell. See the
-# manual for more information.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 3e8
-set Output directory                       = output-gplates-2d
-set Adiabatic surface temperature          = 1600
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e22
-    set Thermal viscosity exponent    = 5.0
-    set Reference temperature         = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:gplates
-  set Tangential velocity boundary indicators = bottom
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-    set Lithosphere thickness = 660000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/cookbooks/gplates/gplates_3d.prm.bak b/cookbooks/gplates/gplates_3d.prm.bak
deleted file mode 100644
index 8616ed8d640..00000000000
--- a/cookbooks/gplates/gplates_3d.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# A simple setup for for using the GPlates interface in a 3d shell.
-# This model has more than 1 million unknowns, so you will most likely want to
-# compile aspect in release mode, and run this model on a powerful machine.
-# See the manual for more information.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 3e8
-set Output directory                       = output-gplates-3d
-set Adiabatic surface temperature          = 1600
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e22
-    set Thermal viscosity exponent    = 5.0
-    set Reference temperature         = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:gplates
-  set Tangential velocity boundary indicators = bottom
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Lithosphere thickness = 660000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/cookbooks/grain_size_ridge/doc/fields.part.prm.bak b/cookbooks/grain_size_ridge/doc/fields.part.prm.bak
deleted file mode 100644
index bd288470d8a..00000000000
--- a/cookbooks/grain_size_ridge/doc/fields.part.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-# Our only compositional field is the grain size, and we use particles
-# to track it. In order for the grain size to not just be tracked, but
-# to evolve over time depending on the temperature and deformation in
-# the model, we select ``grain_size'' as the mapped particle property
-# for the grain_size compositional field.
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = grain_size
-  set Compositional field methods = particles
-  set Mapped particle properties = grain_size:grain_size
-end
diff --git a/cookbooks/grain_size_ridge/doc/material_model.part.prm.bak b/cookbooks/grain_size_ridge/doc/material_model.part.prm.bak
deleted file mode 100644
index 11e48c186b3..00000000000
--- a/cookbooks/grain_size_ridge/doc/material_model.part.prm.bak
+++ /dev/null
@@ -1,48 +0,0 @@
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    # Diffusion creep has a prefactor, a temperature dependence defined by the
-    # activation energy, a pressure dependence defined by the activation volume
-    # and a grain size dependence. We take the activation energy from Hirth &
-    # Kohlstedt, 2003, and pick the prefactor and activation volume so that we
-    # get a reasonable upper mantle viscosity profile and a balance between
-    # diffusion and dislocation creep.
-    set Diffusion creep prefactor                   = 5e-15
-    set Diffusion activation energy                 = 3.75e5
-    set Diffusion activation volume                 = 4e-6
-    set Diffusion creep grain size exponent         = 3
-
-    # Dislocation creep has a prefactor, a temperature dependence defined by the
-    # activation energy, a pressure dependence defined by the activation volume
-    # and a strain-rate dependence defined by the exponent. We take the activation
-    # energy and volume from Hirth & Kohlstedt, 2003, and pick the prefactor so
-    # that we get a reasonable upper mantle viscosity and a balance between
-    # diffusion and dislocation creep.
-    set Dislocation creep prefactor                 = 1e-15
-    set Dislocation activation energy               = 5.3e5
-    set Dislocation activation volume               = 1.4e-5
-    set Dislocation creep exponent                  = 3.5
-    set Dislocation viscosity iteration number      = 10000
-
-    # Grain size is reduced when work is being done by dislocation creep.
-    # Here, 10% of this work goes into reducing the grain size rather than
-    # into shear heating.
-    # Grain size increases with a rate controlled by the grain growth
-    # constant and a temperature-depndence defined by the activation
-    # energy. By setting the activation volume to zero, we disable the
-    # pressure-dependence of grain growth.
-    # The parameter values are taken from Dannberg et al., 2017, G-cubed,
-    # with the parameters being based on Faul and Jackson, 2007.
-    set Work fraction for boundary area change      = 0.1
-    set Grain growth rate constant                  = 1.92e-10
-    set Grain growth activation energy              = 4e5
-    set Grain growth activation volume              = 0
-
-    # Viscosity is cut off at a minimum value of 10^16 Pa s
-    # and a maximum value of 10^23 Pa s.
-    set Maximum viscosity                           = 1e23
-    set Minimum viscosity                           = 1e16
-    set Maximum temperature dependence of viscosity = 1e8
-  end
-end
diff --git a/cookbooks/grain_size_ridge/doc/particles.part.prm.bak b/cookbooks/grain_size_ridge/doc/particles.part.prm.bak
deleted file mode 100644
index a4c606fe089..00000000000
--- a/cookbooks/grain_size_ridge/doc/particles.part.prm.bak
+++ /dev/null
@@ -1,30 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics, mass flux statistics, particles
-
-  subsection Particles
-    set Time between data output = 1e6
-  end
-end
-
-# We use particles to advect the grain size.
-subsection Particles
-  set Interpolation scheme = bilinear least squares
-  set List of particle properties = grain size
-  set Load balancing strategy = remove and add particles
-  set Minimum particles per cell = 40
-  set Maximum particles per cell = 640
-  set Integration scheme = rk2
-  set Update ghost particles = true
-
-  subsection Interpolator
-    subsection Bilinear least squares
-      set Use linear least squares limiter = true
-    end
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 500000
-    end
-  end
-end
diff --git a/cookbooks/grain_size_ridge/grain_size_ridge.prm.bak b/cookbooks/grain_size_ridge/grain_size_ridge.prm.bak
deleted file mode 100644
index 5e483ec0382..00000000000
--- a/cookbooks/grain_size_ridge/grain_size_ridge.prm.bak
+++ /dev/null
@@ -1,310 +0,0 @@
-# This is a model of an oceanic plate moving away from a mid-ocean ridge.
-# The rheology is grain-size dependent and the grain size evolves over
-# time, being tracked on particles. Eventually, small-scale convection
-# develops at the base of the lithosphere as it increases in age.
-
-# We want to run the model for 200 Myrs.
-set End time                               = 2e8
-set Output directory                       = grain-size-ridge
-set Dimension                              = 2
-
-# We set the average pressure at the surface to 0.
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1623
-
-# Because the problem is strongly nonlinear (the viscosity depends on
-# temperature, grain size, pressure and velocity), we use a solver scheme
-# that iterates over all equations being solved. We use a large number
-# of maximum nonlinear iterations to make sure that this nonlinear solver
-# converges every time step (although the model generally only needs 2-3
-# nonlinear iterations).
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 50
-
-# Because the grain size may be far from equilibrium in the first time
-# step, we choose a short time step in the beginning to make sure the
-# nonlinear solver converges. We then allow the time step size to
-# gradually increase by 10% in each step.
-set CFL number                             = 1
-set Maximum first time step                = 500
-set Maximum relative increase in time step = 10
-
-# We use the geometric multigrid solver, but because this is a difficult
-# linear problem to solve with a large viscosity contrast, we increase the
-# number of cheap iterations and the restart length to make sure it
-# converges.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set GMRES solver restart length = 200
-    set Number of cheap Stokes solver steps = 5000
-    set Stokes solver type = block GMG
-  end
-end
-
-# The model is a box with a width of 4000 km and a depth of 410 km.
-# The number of X and Y repetitions determine the shape of the coarsest
-# mesh cells (that will then be refined adaptively) relative to the
-# shape of the box. To achieve an aspect ratio of approximately one
-# for the cells, we choose more X than Y repetitions.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 4000000
-    set Y extent  = 410000
-    set X repetitions = 10
-    set Y repetitions = 1
-  end
-end
-
-# Since we model an oceanic plate moving away from the ridge axis (which
-# is in the top left corner of the model), we prescribed the plate velocity
-# of 5 cm/yr at the surface. At the bottom, we prescribed zero horizontal
-# flow, representing the mantle below. On the right boundary, we prescribe
-# the flow in horizontal direction, gradually changing it from the plate
-# velocity in the uppermost 100 km to a zero velocity at the base of the
-# model. The left boundary (ridge axis) is closed and a free slip boundary.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left
-  set Prescribed velocity boundary indicators = top: function, bottom x:function, right x:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y>310000,0.05,0.05*y/310000); 0
-  end
-end
-
-# We prescribe a boundary traction in vertical direction at the bottom and
-# and right boundaries, setting it to the lithostatic pressure to allow
-# for free in- and outflow of material.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right y:initial lithostatic pressure, bottom y:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Number of integration points = 1000
-    set Representative point         = 2000000,0
-  end
-end
-
-# The initial temperature follows an adiabatic profile with a cold
-# boundary layer added at the surface. Since we model a plate moving away
-# from a ridge with 5 cm/yr, we pick an according age for this boundary
-# layer (increasing from the ridge on the left towards the right as the
-# plate gets older.
-# We additionally add a small temperature perturbation near the ridge
-# to reduce the viscosity below the ridge axis where strong deformation
-# occurs due to our boundary conditions (material has to flow upwards
-# beneath the ridge axis and horizontally towards the right at the
-# surface).
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    set Age bottom boundary layer   = 0.0
-    set Top boundary layer age model = function
-
-    subsection Age function
-      set Function expression = 0.01 + x / 0.05
-    end
-  end
-
-  subsection Function
-    set Function constants  = DeltaT = 300, b = 0, width = 10000, c=410000
-    set Function expression = DeltaT * exp(-((x-b)*(x-b)+(y-c)*(y-c))/(2*width*width))
-    set Variable names      = x,y
-  end
-end
-
-# The temperature at the boundary is taken from the initial conditions.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom, right
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 1623
-  end
-end
-
-# Our only compositional field is the grain size, and we use particles
-# to track it. In order for the grain size to not just be tracked, but
-# to evolve over time depending on the temperature and deformation in
-# the model, we select ``grain_size'' as the mapped particle property
-# for the grain_size compositional field.
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = grain_size
-  set Compositional field methods = particles
-  set Mapped particle properties = grain_size:grain_size
-end
-
-# We set the initial grain size to 5 mm, with a reduction at the ridge
-# axis, again to allow for easy deformation there.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = DeltaC = -29e-4, b = 0, width = 30000, c=397000
-    set Function expression = 5e-3 + DeltaC * exp(-((x-b)*(x-b)+(y-c)*(y-c))/(2*width*width))
-    set Variable names      = x,y
-  end
-end
-
-# The composition at the boundary is taken from the initial conditions.
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = bottom, right
-  set List of model names = initial composition
-end
-
-# We use the grain size material model, which implements the equations
-# for grain size evolution.
-subsection Material model
-  # Because we use the GMG solver, we need to average the viscosity.
-  set Material averaging = project to Q1 only viscosity
-  set Model name = grain size
-
-  subsection Grain size model
-    # We use typical upper-mantle material properties.
-    set Reference density                         = 3300
-    set Reference specific heat                   = 1200
-    set Thermal expansion coefficient             = 3.3e-5
-
-    # Diffusion creep has a prefactor, a temperature dependence defined by the
-    # activation energy, a pressure dependence defined by the activation volume
-    # and a grain size dependence. We take the activation energy from Hirth &
-    # Kohlstedt, 2003, and pick the prefactor and activation volume so that we
-    # get a reasonable upper mantle viscosity profile and a balance between
-    # diffusion and dislocation creep.
-    set Diffusion creep prefactor                   = 5e-15
-    set Diffusion activation energy                 = 3.75e5
-    set Diffusion activation volume                 = 4e-6
-    set Diffusion creep grain size exponent         = 3
-
-    # Dislocation creep has a prefactor, a temperature dependence defined by the
-    # activation energy, a pressure dependence defined by the activation volume
-    # and a strain-rate dependence defined by the exponent. We take the activation
-    # energy and volume from Hirth & Kohlstedt, 2003, and pick the prefactor so
-    # that we get a reasonable upper mantle viscosity and a balance between
-    # diffusion and dislocation creep.
-    set Dislocation creep prefactor                 = 1e-15
-    set Dislocation activation energy               = 5.3e5
-    set Dislocation activation volume               = 1.4e-5
-    set Dislocation creep exponent                  = 3.5
-    set Dislocation viscosity iteration number      = 10000
-
-    # Grain size is reduced when work is being done by dislocation creep.
-    # Here, 10% of this work goes into reducing the grain size rather than
-    # into shear heating.
-    # Grain size increases with a rate controlled by the grain growth
-    # constant and a temperature-depndence defined by the activation
-    # energy. By setting the activation volume to zero, we disable the
-    # pressure-dependence of grain growth.
-    # The parameter values are taken from Dannberg et al., 2017, G-cubed,
-    # with the parameters being based on Faul and Jackson, 2007.
-    set Work fraction for boundary area change      = 0.1
-    set Grain growth rate constant                  = 1.92e-10
-    set Grain growth activation energy              = 4e5
-    set Grain growth activation volume              = 0
-
-    # Viscosity is cut off at a minimum value of 10^16 Pa s
-    # and a maximum value of 10^23 Pa s.
-    set Maximum viscosity                           = 1e23
-    set Minimum viscosity                           = 1e16
-    set Maximum temperature dependence of viscosity = 1e8
-  end
-end
-
-# The gravity points downward and is set to 10.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# We need a high resolution in locations where strong gradients
-# in grain size/viscosity occur, which is within the cold plate.
-# We therefore refine the mesh for low nonadiabatic temperatures.
-subsection Mesh refinement
-  set Time steps between mesh refinement = 5
-  set Initial global refinement = 5
-  set Initial adaptive refinement = 1
-  set Strategy = nonadiabatic temperature threshold
-  set Skip solvers on initial refinement = true
-  set Minimum refinement level = 5
-
-  subsection Nonadiabatic temperature threshold
-    set Temperature anomaly type = negative only
-    set Threshold = 25
-  end
-end
-
-# The model includes shear (dissipation) heating and adiabatic heating.
-subsection Heating model
-  set List of model names = shear heating, adiabatic heating
-end
-
-# We use a discontinuous discretization to interpolate from the particles
-# to the mesh because the bilinear least squares interpolator can lead to
-# jumps of the composition at cell boundaries.
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-# Below, we describe the variables we want to include in the graphical output.
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics, mass flux statistics, particles
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate, melt fraction, named additional outputs
-    set Point-wise stress and strain  = true
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity
-    end
-  end
-
-  subsection Particles
-    set Time between data output = 1e6
-  end
-end
-
-# Every 10 minutes (600 seconds) we write a restart file that could be used to
-# restart a simulation.
-subsection Checkpointing
-  set Time between checkpoint = 600
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-end
-
-# We use particles to advect the grain size.
-subsection Particles
-  set Interpolation scheme = bilinear least squares
-  set List of particle properties = grain size
-  set Load balancing strategy = remove and add particles
-  set Minimum particles per cell = 40
-  set Maximum particles per cell = 640
-  set Integration scheme = rk2
-  set Update ghost particles = true
-
-  subsection Interpolator
-    subsection Bilinear least squares
-      set Use linear least squares limiter = true
-    end
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 500000
-    end
-  end
-end
diff --git a/cookbooks/heat_flow/heat-flow-plume.prm.bak b/cookbooks/heat_flow/heat-flow-plume.prm.bak
deleted file mode 100644
index 3da16ffb5ea..00000000000
--- a/cookbooks/heat_flow/heat-flow-plume.prm.bak
+++ /dev/null
@@ -1,154 +0,0 @@
-# A model of a plume arriving at the base of a plate.
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1e7
-set Use years in output instead of seconds = true
-set Output directory                       = output-heat-flow-plume
-set Adiabatic surface temperature          = 1600
-set Maximum time step                      = 1e6
-
-############### Parameters describing the model
-# Let us choose a box domain (400 km wide and 200 km in depth)
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 400000
-    set Y extent = 200000
-    set X repetitions = 2
-  end
-end
-
-# In order to allow plume material to flow in with the
-# temperature selected in the initial temperature section,
-# we apply the initial temperature as the boundary temperature.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Maximal temperature = 1600
-    set Minimal temperature = 293
-  end
-end
-
-# In this model we want material to be able to (1) flow in freely
-# through the base, (2) flow freely in the horizontal direction
-# through the left and right walls where the vertical velocity is 0,
-# and (3) have a velocity of zero at the top boundary. This is
-# achieved through a combination of velocity and pressure boundary
-# conditions, where only the vertical (y) component of the velocity
-# is set to 0 on the left and right walls, while the x and y velocity
-# are both set to zero on the top boundary.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left y: function, right y:function, top:function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 0;0
-  end
-end
-
-# We allow inflow and outflow at the model base by setting the traction
-# boundary condition to the initial lithostatic pressure. On the left
-# and right boundaries, the x component of the  boundary traction is
-# also set to the initial lithostatic pressure, which enables horizontal
-# inflow and outflow.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = bottom:initial lithostatic pressure,right x:initial lithostatic pressure, left x:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Representative point = 0,0
-    set Number of integration points = 1000
-  end
-end
-
-# We then choose a vertical gravity model.
-subsection Gravity model
-  set Model name = vertical
-end
-
-# The initial temperature is set to the value of the
-# Adiabatic surface temperature, in this case 1600 K,
-# but with a cold boundary layer at the surface and a
-# hot thermal anomaly at the base of the model
-# representing a plume. The age of the cold top
-# boundary layer determines its thickness.
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    # This is the age of the top boundary layer in years.
-    set Age top boundary layer = 1
-  end
-
-  # The constant DeltaT determines the amplitude of the temperature anomaly,
-  # which is a 2d Gaussian located at the center of the bottom boundary.
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = DeltaT=0
-    set Function expression = DeltaT * exp(-((z*z)+(x-200000)*(x-200000))/(5e8))
-  end
-end
-
-# This model uses the composition reaction material model,
-# where most material properties are constant, except for the
-# viscosity and the density, which depend on temperature as
-# expressed by the Thermal viscosity exponent and the
-# Thermal expansion coefficient. At the Reference temperature,
-# the viscosity equals the value set with the Viscosity
-# parameter.
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 2e19
-    set Thermal viscosity exponent    = 10.0
-    set Reference temperature         = 1600
-  end
-end
-
-# This part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed.
-# Here, the mesh is designed to be finer at the surface than at
-# the bottom of the model to better capture the conductive cooling
-# of the plates. It initially undergoes two global refinements and
-# four adaptive refinements in the first time step, but is not
-# refined further (i.e., it remains static) throughout the model
-# run. The adaptive refinements use the minimum refinement function
-# to increase the resolution towards the model surface in a
-# piece-wise fashion at depths of 7 and 30 kilometers.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 4
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Variable names = depth, z
-    set Function expression = if(depth<7000,6,if(depth<30000,5,4))
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, heat flux densities
-
-  subsection Visualization
-    set Time between graphical output = 1e5
-    set List of output variables = material properties, heat flux map, vertical heat flux
-
-    subsection Material properties
-      set List of material properties = density, thermal expansivity, specific heat, viscosity, thermal conductivity
-    end
-  end
-end
diff --git a/cookbooks/heat_flow/heat-flow-terms.prm.bak b/cookbooks/heat_flow/heat-flow-terms.prm.bak
deleted file mode 100644
index 68173b55a29..00000000000
--- a/cookbooks/heat_flow/heat-flow-terms.prm.bak
+++ /dev/null
@@ -1,40 +0,0 @@
-include $ASPECT_SOURCE_DIR/cookbooks/heat_flow/heat-flow.prm
-
-
-# This is a copy of the heat-flow cookbook, modified to include
-# radiogenic heat production and shear heating, and to output
-# the different heating terms in a visualization postprocessor.
-
-set Output directory                       = output-heat-flow-terms
-
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 1e-4
-
-    # Changig the viscosity changes the shear heating.
-    set Viscosity                     = 3e21
-  end
-end
-
-# This is a new section specifying the heating terms
-subsection Heating model
-  set List of model names = function, shear heating
-
-  # Radiogenic heat production. Changing the variable
-  # Hcrust in the equation below changes the heat
-  # production rate in the crust.
-  subsection Function
-    set Variable names = x,y,t
-    set Function expression = if(y>93000, Hcrust, Hmantle)
-    set Function constants = Hcrust=2e-8, Hmantle=7.38e-12
-  end
-end
-
-subsection Postprocess
-  subsection Visualization
-    set List of output variables = density, heat flux map, vertical heat flux, heating, viscosity
-  end
-end
diff --git a/cookbooks/heat_flow/heat-flow.prm.bak b/cookbooks/heat_flow/heat-flow.prm.bak
deleted file mode 100644
index 1f7cb70d9cc..00000000000
--- a/cookbooks/heat_flow/heat-flow.prm.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-# A model of spreading at a mid-ocean ridge.
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 5e6
-set Use years in output instead of seconds = true
-set Output directory                       = output-heat-flow
-
-############### Parameters describing the model
-# Let us choose a box domain (400 km wide and 100 km in depth)
-# where we fix the temperature at the bottom and top,
-# allow inflow from the bottom and outflow on the left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 400000
-    set Y extent = 100000
-    set X repetitions = 4
-    set Box origin X coordinate = -200000
-  end
-end
-
-# We fix the temperature at the top, representing the Earth's
-# surface, and at the bottom, where material flows in and we
-# need to prescribe what temperature this material should
-# have (in this case, 1600 K).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1600
-    set Top temperature    = 293
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center of a mid-ocean ridge. The horizontal component of
-# the velocity is presribed on both side boundaries to
-# cause flow away from the spreading center, while the
-# vertical component of the velocity is allowed to evolve
-# freely based on the pressure in the model. The bottom
-# boundary is left open so that material can flow in.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x:function, right x:function, top: function
-
-  subsection Function
-    set Variable names      = x,z
-
-    # We can choose a (half-)spreading rate by changing the value of v (in cm/year)
-    # This value should be somewhere between 1 and 10 (cm/yr).
-    set Function constants  = v=5, cm_per_year=0.01
-    set Function expression = if(x>0, v * cm_per_year, -v * cm_per_year); 0
-  end
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = left y:initial lithostatic pressure, right y:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Representative point = 0,0
-    set Number of integration points = 1000
-  end
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature as a constant (being equivalent to a
-# plate age of 0).
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# The initial temperature is set to a constant value that
-# corresponds to the temperature of the sublithospheric
-# mantle throughout the model, but subsequently cools
-# over time.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1600
-  end
-end
-
-# This model uses the composition reaction material model,
-# where most material properties are constant. Here, only
-# the density depends on temperature as expressed by the
-# Thermal expansion coefficient.
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1e23
-  end
-end
-
-# This part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed.
-# Here, the mesh is designed to be finer at the surface than at
-# the bottom of the model to better capture the conductive cooling
-# of the plates. It initially undergoes two global refinements and
-# four adaptive refinements in the first time step, but is not
-# refined further (i.e., it remains static) throughout the model
-# run. The adaptive refinements use the minimum refinement function
-# to increase the resolution towards the model surface in a
-# piece-wise fashion at depths of 7, 30, and 45 kilometers.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 4
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Variable names = depth, w
-    set Function expression = if(depth<7000,6,if(depth<30000,5,if(depth<45000,4,3)))
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e5
-    set List of output variables = material properties, heat flux map, vertical heat flux
-
-    subsection Material properties
-      set List of material properties = density, specific heat, thermal conductivity
-    end
-  end
-end
diff --git a/cookbooks/inclusions/ellipse_pure_shear.prm.bak b/cookbooks/inclusions/ellipse_pure_shear.prm.bak
deleted file mode 100644
index 2944de60745..00000000000
--- a/cookbooks/inclusions/ellipse_pure_shear.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-include ellipse_ref.prm
-
-set Output directory                       = output-ellipse-pure-shear
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function, top y: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = v=0.5
-    set Function expression = if (x<0.5,v,-v) ; if (y<0.5,-v,v)
-  end
-end
diff --git a/cookbooks/inclusions/ellipse_pure_shear_nonlinear.prm.bak b/cookbooks/inclusions/ellipse_pure_shear_nonlinear.prm.bak
deleted file mode 100644
index 0f8d409324b..00000000000
--- a/cookbooks/inclusions/ellipse_pure_shear_nonlinear.prm.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = output-ellipse-pure-shear-NL
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = true
-end
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-############### Parameters describing the compositional field
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = a=0.2, b=0.1, phi=0.52359877559
-    set Function expression = if( ( (x-.5)*cos(phi)+(y-.5)*sin(phi))^2/a^2 + \
-                                  ( (x-.5)*sin(phi)-(y-.5)*cos(phi))^2/b^2 < 1, 1, 0)
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 3
-  set Initial global refinement          = 7
-  set Refinement fraction                = 0.75
-  set Strategy                           = velocity, composition
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function, top y: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = v=0.5
-    set Function expression = if (x<0.5,v,-v) ; if (y<0.5,-v,v)
-  end
-end
-
-################################################3
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Reference temperature and viscosity
-    set Reference temperature = 273
-
-    # The minimum strain-rate helps limit large viscosities values that arise
-    # as the strain-rate approaches zero.
-    # The reference strain-rate is used on the first non-linear iteration
-    # of the first time step when the velocity has not been determined yet.
-    set Minimum strain rate   = 1.e-2
-    set Reference strain rate = 1.
-
-    # Limit the viscosity with minimum and maximum values
-    set Minimum viscosity = 1e-3
-    set Maximum viscosity = 1e3
-    set Densities              = 1
-    set Thermal expansivities  = 0
-    set Viscosity averaging scheme = harmonic
-    set Viscous flow law = dislocation
-
-    #matrix inclusion
-    set Prefactors for dislocation creep          = 0.5, 500
-    set Stress exponents for dislocation creep    =   1,      1
-    set Activation energies for dislocation creep =   0,      0
-    set Activation volumes for dislocation creep  =   0,      0
-
-    # Plasticity parameters
-    set Cohesions = 1e50
-  end
-end
diff --git a/cookbooks/inclusions/ellipse_ref.prm.bak b/cookbooks/inclusions/ellipse_ref.prm.bak
deleted file mode 100644
index d59e09701d8..00000000000
--- a/cookbooks/inclusions/ellipse_ref.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Pressure normalization                 = volume
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = true
-end
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Reference density = 1
-    set Viscosity         = 1
-    set Density differential for compositional field 1 = 1
-    set Composition viscosity prefactor = 0.001
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = a=0.2, b=0.1, phi=0.52359877559
-    set Function expression = if( ( (x-.5)*cos(phi)+(y-.5)*sin(phi))^2/a^2 + \
-                                  ( (x-.5)*sin(phi)-(y-.5)*cos(phi))^2/b^2 < 1, 1, 0)
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 3
-  set Initial global refinement          = 7
-  set Refinement fraction                = 0.75
-  set Strategy                           = velocity, composition
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate
-  end
-end
diff --git a/cookbooks/inclusions/ellipse_simple_shear.prm.bak b/cookbooks/inclusions/ellipse_simple_shear.prm.bak
deleted file mode 100644
index 14d8f083175..00000000000
--- a/cookbooks/inclusions/ellipse_simple_shear.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-include ellipse_ref.prm
-
-set Output directory                       = output-ellipse-simple-shear
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left y: function, right y:function, bottom: function, top: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = v=0.5
-    set Function expression = if (y<0.5,-v,+v) ; 0
-  end
-end
diff --git a/cookbooks/inclusions/rectangle_pure_shear.prm.bak b/cookbooks/inclusions/rectangle_pure_shear.prm.bak
deleted file mode 100644
index 7e5d4ab1e2f..00000000000
--- a/cookbooks/inclusions/rectangle_pure_shear.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-include rectangle_ref.prm
-
-set Output directory = output-rectangle-pure-shear
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: function, right x:function, bottom y:function, top y: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = v=0.5
-    set Function expression = if (x<0.5,v,-v) ; if (y<0.5,-v,v)
-  end
-end
diff --git a/cookbooks/inclusions/rectangle_ref.prm.bak b/cookbooks/inclusions/rectangle_ref.prm.bak
deleted file mode 100644
index d287d3db6f5..00000000000
--- a/cookbooks/inclusions/rectangle_ref.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Pressure normalization                 = volume
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = true
-end
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Reference density = 1
-    set Viscosity         = 1
-    set Density differential for compositional field 1 = 1
-    set Composition viscosity prefactor = 1000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = a=0.2, b=0.1, phi=1.0471975512
-    set Function expression = if( abs( (x-.5)*cos(phi)+(y-.5)*sin(phi))<a &&  \
-                                  abs( (x-.5)*sin(phi)-(y-.5)*cos(phi))<b, 1, 0)
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 3
-  set Initial global refinement   = 7
-  set Refinement fraction         = 0.75
-  set Strategy                    = velocity, composition
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate
-  end
-end
diff --git a/cookbooks/inclusions/rectangle_simple_shear.prm.bak b/cookbooks/inclusions/rectangle_simple_shear.prm.bak
deleted file mode 100644
index a3a246edc64..00000000000
--- a/cookbooks/inclusions/rectangle_simple_shear.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-include rectangle_ref.prm
-
-set Output directory = output-rectangle-simple-shear
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left y: function, right y:function, bottom: function, top: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = v=0.5
-    set Function expression = if (y<0.5,-v,+v) ; 0
-  end
-end
diff --git a/cookbooks/initial-condition-S20RTS/S20RTS.prm.bak b/cookbooks/initial-condition-S20RTS/S20RTS.prm.bak
deleted file mode 100644
index b3a8c60264a..00000000000
--- a/cookbooks/initial-condition-S20RTS/S20RTS.prm.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-# A description of convection in a 3d spherical shell with
-# a prescribed initial condition based on the shear wave
-# velocity model S20RTS.
-
-# Define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 3
-
-# Specify the time you want to let the model run for in
-# years and the output directory. Here we only calculate
-# the instantaneous solution.
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Output directory                       = output-S20RTS
-
-# The following variables describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain. The 'Surface pressure' and
-# 'Adiabatic surface temperature' are used to compute
-# the adiabatic reference profile.
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-# Here we specify the residual tolerance for the linear solver.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-4
-  end
-end
-
-# Here we specify the geometry of the domain, which is
-# a spherical shell with inner radius of 3481km and
-# outer radius of 6371km
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6371000
-  end
-end
-
-# This section specifies the temperature at the boundary of
-# the domain. Here we set the temperature to be constant,
-# but different from the reference temperature to approximate
-# boundary layers.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2000
-    set Outer temperature = 1000
-  end
-end
-
-# This section describes the gravity field, which is pointing
-# towards the Earth's center with the same magnitude of 10 m/s^2
-# everywhere
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-# This section prescribes the initial condition in the temperature
-# field, which is chosen as a scaled version of the S20RTS shear
-# wave velocity model (Ritsema et al., 2000). S20RTS is defined
-# by spherical harmonics up to degree 20 that are radially interpolated
-# with a cubic spline.
-subsection Initial temperature model
-  set Model name = S40RTS perturbation
-
-  subsection S40RTS perturbation
-    # The two input options here are S20RTS or the higher resolution
-    # S40RTS (Ritsema et al., 2011). One can choose to remove the
-    # degree 0 from these files so that the depth average value
-    # is zero.
-    set Initial condition file name       = S20RTS.sph
-    set Remove degree 0 from perturbation = false
-
-    # The following parameters determine the scaling from shear wave
-    # velocity perturbation to temperature differences. We chose the
-    # scaling to density perturbation as 0.15
-    set Vs to density scaling             = 0.15
-    set Thermal expansion coefficient in initial temperature scaling = 3e-5
-
-    # This specifies the background temperature to which we add the
-    # temperature difference.
-    set Reference temperature             = 1600
-  end
-end
-
-# The material model is based on the simple material model, which assumes
-# a constant density, and other parameters as stated below.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                 = 3300
-    set Viscosity                         = 1e21
-    set Thermal expansion coefficient     = 3e-5
-    set Reference temperature             = 1600
-    set Thermal conductivity              = 4.125
-    set Reference specific heat           = 1250
-  end
-end
-
-# For this calculation we only do 2 global refinement steps. This resolution
-# is too low to fully resolve the mantle flow, however it does capture
-# the main features.
-subsection Mesh refinement
-  set Time steps between mesh refinement = 0
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 0
-end
-
-# We assume free slip at the inner and outer boundary
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom
-end
-
-# We output the density, velocity, dynamic topography, geoid and heat flux density
-# for plotting.
-subsection Postprocess
-  set List of postprocessors = geoid, velocity statistics, heat flux map, heat flux statistics, dynamic topography, visualization, basic statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set List of output variables      = geoid, dynamic topography, heat flux map, density,viscosity, gravity
-    set Time between graphical output = 0
-    set Number of grouped files       = 1
-
-    # We only have dirichlet boundaries with tangential velocities, so we can
-    # increase the output resolution as described in the documentation of the 'heat
-    # flux map' postprocessor.
-    subsection Heat flux map
-      set Output point wise heat flux = true
-    end
-  end
-
-  subsection Geoid
-    set Also output the gravity anomaly  = true
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
diff --git a/cookbooks/initial-condition-S20RTS/doc/S20RTS.part.prm.bak b/cookbooks/initial-condition-S20RTS/doc/S20RTS.part.prm.bak
deleted file mode 100644
index dbee188cd78..00000000000
--- a/cookbooks/initial-condition-S20RTS/doc/S20RTS.part.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-subsection Initial temperature model
-  set Model name = S40RTS perturbation
-
-  subsection S40RTS perturbation
-    set Data directory                    = $ASPECT_SOURCE_DIR/data/initial-temperature/S40RTS/
-    set Initial condition file name       = S20RTS.sph
-    set Spline knots depth file name      = Spline_knots.txt
-    set Remove degree 0 from perturbation = false
-    set Vs to density scaling             = 0.15
-    set Thermal expansion coefficient in initial temperature scaling = 3e-5
-    set Reference temperature             = 1600
-  end
-end
diff --git a/cookbooks/inner_core_convection/doc/inner_core_traction.part.1.prm.bak b/cookbooks/inner_core_convection/doc/inner_core_traction.part.1.prm.bak
deleted file mode 100644
index cb9f622c835..00000000000
--- a/cookbooks/inner_core_convection/doc/inner_core_traction.part.1.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-subsection Material model
-  set Model name = inner core material
-
-  # The 'inner core material' model also contains a function that
-  # represents the resistance to melting/freezing at the inner core
-  # boundary.
-  # For P-->infinity, the boundary is a free slip boundary, and for
-  # P-->0, the boundary is an open boundary (with zero normal stress).
-  subsection Inner core
-    subsection Phase change resistance function
-      set Variable names      = x,y,z
-      set Function expression = 1e-2     # <-- P
-    end
-  end
-end
diff --git a/cookbooks/inner_core_convection/doc/inner_core_traction.part.2.prm.bak b/cookbooks/inner_core_convection/doc/inner_core_traction.part.2.prm.bak
deleted file mode 100644
index 2bde3180a1e..00000000000
--- a/cookbooks/inner_core_convection/doc/inner_core_traction.part.2.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# The gravity has its maximum value at the boundary of inner and
-# outer core, and decreases approximately linearly to zero towards
-# the center of the core.
-# The Rayleigh number used in the model is given by the magnitude
-# of the gravity at the inner core/outer core boundary.
-subsection Gravity model
-  set Model name = radial linear
-
-  subsection Radial linear
-    set Magnitude at bottom = 0.0
-    set Magnitude at surface = 2     # <-- Ra
-  end
-end
diff --git a/cookbooks/inner_core_convection/doc/inner_core_traction.part.3.prm.bak b/cookbooks/inner_core_convection/doc/inner_core_traction.part.3.prm.bak
deleted file mode 100644
index 79342416a60..00000000000
--- a/cookbooks/inner_core_convection/doc/inner_core_traction.part.3.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-subsection Mesh refinement
-  set Initial global refinement          = 4  #this may be more expensive, and should be run on a cluster.
-  set Initial adaptive refinement        = 1
-  set Strategy                           = minimum refinement function
-  set Time steps between mesh refinement = 0
-
-  subsection Minimum refinement function
-    set Variable names = depth, phi, theta
-    set Function expression = if(depth>0.1,if(depth>0.2,2,5),6)
-  end
-end
diff --git a/cookbooks/inner_core_convection/inner_core_assembly.cc.bak b/cookbooks/inner_core_convection/inner_core_assembly.cc.bak
deleted file mode 100644
index 8cd7a42d249..00000000000
--- a/cookbooks/inner_core_convection/inner_core_assembly.cc.bak
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/simulator.h>
-#include <aspect/simulator/assemblers/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-#include "inner_core_convection.cc"
-
-namespace aspect
-{
-  /**
-   * A new assembler class that implements boundary conditions for the
-   * normal stress and the normal velocity that take into account the
-   * rate of phase change (melting/freezing) at the inner-outer core
-   * boundary. The model is based on Deguen, Alboussiere, and Cardin
-   * (2013), Thermal convection in Earth's inner core with phase change
-   * at its boundary. GJI, 194, 1310-133.
-   *
-   * The mechanical boundary conditions for the inner core are
-   * tangential stress-free and continuity of the normal stress at the
-   * inner-outer core boundary. For the non-dimensional equations, that
-   * means that we can define a 'phase change number' $\mathcal{P}$ so
-   * that the normal stress at the boundary is $-\mathcal{P} u_r$ with
-   * the radial velocity $u_r$. This number characterizes the resistance
-   * to phase change at the boundary, with $\mathcal{P}\rightarrow\infty$
-   * corresponding to infinitely slow melting/freezing (free slip
-   * boundary), and $\mathcal{P}\rightarrow0$ corresponding to
-   * instantaneous melting/freezing (zero normal stress, open boundary).
-   *
-   * In the weak form, this results in boundary conditions of the form
-   * of a surface integral:
-   * $$\int_S \mathcal{P} (\mathbf u \cdot \mathbf n) (\mathbf v \cdot \mathbf n) dS,$$,
-   * with the normal vector $\mathbf n$.
-   *
-   * The function value of $\mathcal{P}$ is taken from the inner core
-   * material model.
-   */
-  template <int dim>
-  class PhaseBoundaryAssembler :
-    public aspect::Assemblers::Interface<dim>,
-    public SimulatorAccess<dim>
-  {
-
-    public:
-
-      void
-      execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-               internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override
-      {
-        internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-        internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-        const Introspection<dim> &introspection = this->introspection();
-        const FiniteElement<dim> &fe            = this->get_fe();
-        const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-        const unsigned int n_q_points           = scratch.face_finite_element_values.n_quadrature_points;
-
-        //assemble force terms for the matrix for all boundary faces
-        if (scratch.cell->face(scratch.face_number)->at_boundary())
-          {
-            scratch.face_finite_element_values.reinit (scratch.cell, scratch.face_number);
-
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                const double P = Plugins::get_plugin_as_type<const MaterialModel::InnerCore<dim>>
-                                 (this->get_material_model()).resistance_to_phase_change
-                                 .value(scratch.material_model_inputs.position[q]);
-
-                for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-                  {
-                    if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                      {
-                        scratch.phi_u[i_stokes] = scratch.face_finite_element_values[introspection
-                                                                                     .extractors.velocities].value(i, q);
-                        ++i_stokes;
-                      }
-                    ++i;
-                  }
-
-                const Tensor<1,dim> normal_vector = scratch.face_finite_element_values.normal_vector(q);
-                const double JxW = scratch.face_finite_element_values.JxW(q);
-
-                // boundary term: P*u*n*v*n*JxW(q)
-                for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-                  for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                    data.local_matrix(i,j) += P *
-                                              scratch.phi_u[i] *
-                                              normal_vector *
-                                              scratch.phi_u[j] *
-                                              normal_vector *
-                                              JxW;
-              }
-          }
-      }
-  };
-
-  template <int dim>
-  void set_assemblers_phase_boundary(const SimulatorAccess<dim> &simulator_access,
-                                     Assemblers::Manager<dim> &assemblers)
-  {
-    AssertThrow (Plugins::plugin_type_matches<const MaterialModel::InnerCore<dim>>
-                 (simulator_access.get_material_model()),
-                 ExcMessage ("The phase boundary assembler can only be used with the "
-                             "material model 'inner core material'!"));
-
-    assemblers.stokes_system_on_boundary_face.push_back (std::make_unique<PhaseBoundaryAssembler<dim>>());
-  }
-}
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  signals.set_assemblers.connect (&aspect::set_assemblers_phase_boundary<dim>);
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/cookbooks/inner_core_convection/inner_core_convection.cc.bak b/cookbooks/inner_core_convection/inner_core_convection.cc.bak
deleted file mode 100644
index 69aded1aab9..00000000000
--- a/cookbooks/inner_core_convection/inner_core_convection.cc.bak
+++ /dev/null
@@ -1,488 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/gravity_model/radial.h>
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class InnerCore : public MaterialModel::Simple<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        InnerCore ();
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the boundary values will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * A function object representing resistance to phase change at the
-         * inner core boundary as a function the position (and, optionally,
-         * the model time).
-         */
-        Functions::ParsedFunction<dim> resistance_to_phase_change;
-
-      private:
-        /**
-         * Parameters related to the phase transition.
-         */
-        double transition_radius;
-        double transition_width;
-        double transition_temperature;
-        double transition_clapeyron_slope;
-        double transition_density_change;
-        bool compute_quadratic_pressure_profile;
-
-        /**
-         * A function object representing the hydrostatic pressure in the
-         * inner core as a function of radius. This is needed to compute
-         * the depth of phase transitions.
-         * Note that we can not simply use the adiabatic pressure here,
-         * as the equations are solved for the dynamic pressure, and the
-         * adiabatic conditions are used as initial guess for the solution.
-         */
-        Functions::ParsedFunction<1> hydrostatic_pressure_profile;
-
-        /**
-         * Percentage of material that has already undergone the phase
-         * transition to the higher-pressure material.
-         */
-        double
-        phase_function (const Point<dim> &position,
-                        const double temperature) const;
-
-        /**
-         * Hydrostatic pressure profile.
-         */
-        double
-        hydrostatic_pressure (const double radius) const;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    InnerCore<dim>::InnerCore ()
-      :
-      resistance_to_phase_change (1),
-      hydrostatic_pressure_profile (1)
-    {}
-
-    template <int dim>
-    double
-    InnerCore<dim>::
-    phase_function (const Point<dim> &position,
-                    const double temperature) const
-    {
-      // We need to convert the depth to pressure,
-      // keeping in mind that for this model, the pressure is only the dynamic pressure,
-      // so we have to get the hydrostatic pressure explicitly as an input.
-      const double radius = this->get_geometry_model().maximal_depth() - this->get_geometry_model().depth(position);
-      Assert(radius >= 0,
-             ExcMessage("There is a point in the model where the depth is larger "
-                        "than the maximal depth of this geometry."));
-
-      const double pressure_deviation = hydrostatic_pressure(radius) - hydrostatic_pressure(transition_radius);
-
-      double depth_deviation = transition_radius - radius;
-      if (std::fabs(pressure_deviation) > 100.0 * std::numeric_limits<double>::epsilon()
-          * (std::fabs(hydrostatic_pressure(radius)) + std::fabs(hydrostatic_pressure(transition_radius)))/2)
-        depth_deviation *= (1.0 - transition_clapeyron_slope * (temperature - transition_temperature) / pressure_deviation);
-
-      double phase_func;
-      // use delta function for width = 0
-      if (transition_width == 0)
-        phase_func = (depth_deviation > 0) ? 1 : 0;
-      else
-        phase_func = 0.5 * (1.0 + std::tanh(depth_deviation / transition_width));
-      return phase_func;
-    }
-
-
-    template <int dim>
-    double
-    InnerCore<dim>::
-    hydrostatic_pressure (const double radius) const
-    {
-      if (compute_quadratic_pressure_profile)
-        {
-          // Compute a quadratic hydrostatic pressure profile, based on a linear gravity model.
-          AssertThrow (Plugins::plugin_type_matches<const GravityModel::RadialLinear<dim>>(this->get_gravity_model()),
-                       ExcMessage ("Automatic computation of the hydrostatic pressure profile is "
-                                   "only implemented for the 'radial linear' gravity model."));
-
-          const double max_radius = this->get_geometry_model().maximal_depth();
-          const Point<dim> surface_point = this->get_geometry_model().representative_point(0);
-          const double gravity_magnitude = this->get_gravity_model().gravity_vector(surface_point).norm();
-
-          // The gravity is zero in the center of the Earth, and we assume the density to be constant and equal to 1.
-          // We fix the surface pressure to 0 (and we are only interested in pressure differences anyway).
-          return gravity_magnitude * 0.5 * (1.0 - std::pow(radius/max_radius,2));
-        }
-      else
-        return hydrostatic_pressure_profile.value(Point<1>(radius));
-    }
-
-
-    template <int dim>
-    void
-    InnerCore<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // First, we use the material descriptions of the 'simple' material model to fill all of the material
-      // model outputs. Below, we will then overwrite selected properties (the specific heat) to make the
-      // product of density and specific heat a constant.
-      Simple<dim>::evaluate(in, out);
-
-      // We want the right-hand side of the momentum equation to be (- Ra T gravity) and
-      // density * cp to be 1
-      for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
-        {
-          out.densities[q] = - out.thermal_expansion_coefficients[q] * in.temperature[q]
-                             + phase_function (in.position[q], in.temperature[q]) * transition_density_change;
-          if (std::abs(out.densities[q]) > 0.0)
-            out.specific_heat[q] /= out.densities[q];
-        }
-    }
-
-
-    template <int dim>
-    void
-    InnerCore<dim>::update()
-    {
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        resistance_to_phase_change.set_time (this->get_time() / year_in_seconds);
-      else
-        resistance_to_phase_change.set_time (this->get_time());
-
-      if (this->convert_output_to_years())
-        hydrostatic_pressure_profile.set_time (this->get_time() / year_in_seconds);
-      else
-        hydrostatic_pressure_profile.set_time (this->get_time());
-    }
-
-
-    template <int dim>
-    void
-    InnerCore<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      Simple<dim>::declare_parameters (prm);
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Inner core");
-        {
-          prm.enter_subsection("Phase change resistance function");
-          {
-            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-          }
-          prm.leave_subsection();
-
-          prm.enter_subsection("Hydrostatic pressure function");
-          {
-            Functions::ParsedFunction<1>::declare_parameters (prm, 1);
-          }
-          prm.leave_subsection();
-
-          prm.declare_entry ("Phase transition radius", "0.0",
-                             Patterns::Double (0),
-                             "The distance from the center of the Earth where the phase "
-                             "transition occurs. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Phase transition width", "0.0",
-                             Patterns::Double (0),
-                             "The width of the phase transition. The argument of the phase function "
-                             "is scaled with this value, leading to a jump between phases "
-                             "for a value of zero and a gradual transition for larger values. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Phase transition temperature", "0.0",
-                             Patterns::Double (0),
-                             "The temperature at which the phase transition occurs in the depth "
-                             "given by the 'Phase transition depth' parameter.  Higher or lower "
-                             "temperatures lead to phase transition occurring in shallower or greater "
-                             "depths, depending on the Clapeyron slope given in 'Phase transition "
-                             "Clapeyron slope'. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Phase transition Clapeyron slope", "0.0",
-                             Patterns::Double (),
-                             "The Clapeyron slope of the phase transition. A positive "
-                             "Clapeyron slope indicates that the phase transition will occur in "
-                             "a greater depth if the temperature is higher than the one given in "
-                             "Phase transition temperatures (and in a smaller depth if the "
-                             "temperature is smaller than the one given in Phase transition temperatures). "
-                             "For negative Clapeyron slopes, the effect is in the opposite direction. "
-                             "Units: Pa/K.");
-          prm.declare_entry ("Phase transition density change", "0.0",
-                             Patterns::Double (),
-                             "The density change that occurs across the phase transition. "
-                             "A positive value means that the density increases with depth. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Compute quadratic pressure profile from gravity", "true",
-                             Patterns::Bool (),
-                             "Whether to automatically compute the hydrostatic pressure profile "
-                             "(that is used to compute the location of phase transitions) from "
-                             "the magnitude of the gravity, assuming a linear gravity profile "
-                             "and a constant density (if true), or to use the function that is "
-                             "given in 'Hydrostatic pressure function' (if false).");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    InnerCore<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      Simple<dim>::parse_parameters (prm);
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Inner core");
-        {
-          prm.enter_subsection("Phase change resistance function");
-          try
-            {
-              resistance_to_phase_change.parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Phase boundary model.Function'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-          prm.leave_subsection();
-
-          prm.enter_subsection("Hydrostatic pressure function");
-          try
-            {
-              hydrostatic_pressure_profile.parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Hydrostatic pressure model.Function'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-          prm.leave_subsection();
-
-          transition_radius          = prm.get_double ("Phase transition radius");
-          transition_width           = prm.get_double ("Phase transition width");
-          transition_temperature     = prm.get_double ("Phase transition temperature");
-          transition_clapeyron_slope = prm.get_double ("Phase transition Clapeyron slope");
-          transition_density_change  = prm.get_double ("Phase transition density change");
-          compute_quadratic_pressure_profile = prm.get_bool ("Compute quadratic pressure profile from gravity");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a constant radiogenic heating rate.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class ConstantCoreHeating : public Interface<dim>
-    {
-      public:
-        /**
-         * Return the heating terms. For the current class, this
-         * function obviously simply returns a constant value.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        double radiogenic_heating_rate;
-    };
-  }
-}
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    ConstantCoreHeating<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &/*material_model_inputs*/,
-              const MaterialModel::MaterialModelOutputs<dim> &/*material_model_outputs*/,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          // return a constant value
-          heating_model_outputs.heating_source_terms[q] = radiogenic_heating_rate;
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    ConstantCoreHeating<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Constant core heating");
-        {
-          prm.declare_entry ("Radiogenic heating rate", "0e0",
-                             Patterns::Double (0),
-                             "The specific rate of heating due to radioactive decay (or other bulk sources "
-                             "you may want to describe). This parameter corresponds to the variable "
-                             "$H$ in the temperature equation stated in the manual, and the heating "
-                             "term is $\\rho H$. Units: W/kg.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ConstantCoreHeating<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Constant core heating");
-        {
-          radiogenic_heating_rate    = prm.get_double ("Radiogenic heating rate");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(InnerCore,
-                                   "inner core material",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but has a constant $\rho c_p$, "
-                                   "and implements a function that characterizes the "
-                                   "resistance to melting/freezing at the inner core "
-                                   "boundary.")
-  }
-
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(ConstantCoreHeating,
-                                  "constant core heating",
-                                  "Implementation of a model in which the heating "
-                                  "rate is constant.")
-  }
-}
diff --git a/cookbooks/inner_core_convection/inner_core_traction.prm.bak b/cookbooks/inner_core_convection/inner_core_traction.prm.bak
deleted file mode 100644
index 215f28bc066..00000000000
--- a/cookbooks/inner_core_convection/inner_core_traction.prm.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-# A simple setup for convection the inner core. See the
-# manual, Section Cookbooks/Geophysical setups/Inner core convection
-# for more information. Changing the Rayleigh number Ra
-# and the resistance to phase change P will change the mode
-# of inner core convection between translation, plume convection
-# or no convection.
-#
-# Setup and equations are given in: Deguen, Alboussiere,
-# and Cardin (2013), Thermal convection in Earth’s inner core
-# with phase change at its boundary. GJI, 194, 1310-133.
-
-set Additional shared libraries            = ./libinner_core_convection.so
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set End time                               = 1.5e9
-set Output directory                       = output-inner_core_traction
-
-# The equations are non-dimensionalized, and all of the
-# material properties are constant and set to one, except
-# for the density, which scales with temperature.
-subsection Material model
-  set Model name = inner core material
-
-  subsection Simple model
-    set Reference density             = 0
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-
-  # The 'inner core material' model also contains a function that
-  # represents the resistance to melting/freezing at the inner core
-  # boundary.
-  # This phase boundary model combines a prescribed a normal
-  # velocity and normal stress. The relation between the two scales
-  # with the phase change number P, which is given in the 'Function
-  # expression'.
-  # For P-->infinity, the boundary is a free slip boundary, and for
-  # P-->0, the boundary is an open boundary (with zero normal stress).
-
-  # For time dependence, the variable names have to have dim+1 entries,
-  # and the last variable will be the time
-  subsection Inner core
-    subsection Phase change resistance function
-      set Variable names      = x,y,z
-      set Function expression = 1e-2     # <-- P
-    end
-  end
-end
-
-# The inner core is a sphere, and the non-dimensional radius
-# is 1.
-subsection Geometry model
-  set Model name = sphere
-
-  subsection Sphere
-    set Radius  = 1
-  end
-end
-
-# We use a new boundary condition at the surface, which takes
-# into account the effect of melting/freezing of material at
-# the boundary of inner and outer core, and which is implemented
-# in the shared library.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = surface: zero traction
-end
-
-# We use a constant radiogenic heating rate.
-subsection Heating model
-  set List of model names = constant core heating
-
-  subsection Constant core heating
-    set Radiogenic heating rate = 6
-  end
-end
-
-# The (potential) temperature is set to zero at the outer boundary.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = surface
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 0.1
-    set Outer temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-# The gravity has its maximum value at the boundary of inner and
-# outer core, and decreases approximately linearly to zero towards
-# the center of the core.
-# The Rayleigh number used in the model is given by the magnitude
-# of the gravity at the inner core/outer core boundary.
-subsection Gravity model
-  set Model name = radial linear
-
-  subsection Radial linear
-    set Magnitude at bottom = 0.0
-    set Magnitude at surface = 2     # <-- Ra
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 0
-  set Strategy                           = minimum refinement function
-  set Time steps between mesh refinement = 0
-
-  subsection Minimum refinement function
-    set Variable names = depth, phi, theta
-    set Function expression = if(depth>0.1,if(depth>0.2,2,5),6)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Number of grouped files       = 0
-    set List of output variables      = strain rate, gravity, density, specific heat, heating
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-      set Stokes solver type = block AMG
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc.bak b/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc.bak
deleted file mode 100644
index c77565c10c5..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc.bak
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "composition_trms_statistics.h"
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    CompositionTrmsStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the temperature element alone.
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      std::vector<double> temperature_values(n_q_points);
-      std::vector<double> compositional_values(n_q_points);
-
-      std::vector<double> local_temperature_square_integral (this->n_compositional_fields());
-      std::vector<double> local_area_integral (this->n_compositional_fields());
-      double local_total_temperature_square_integral = 0.;
-      double local_total_area_integral = 0.;
-      const double kelvin_to_celsius = 273.15;
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit(cell);
-
-            fe_values[this->introspection().extractors.temperature].get_function_values(this->get_solution(),
-                                                                                        temperature_values);
-
-            // Loop over the quadrature points to get the temperature and area
-            // integral for the whole domain.
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                local_total_temperature_square_integral += (((temperature_values[q]-kelvin_to_celsius) *
-                                                             (temperature_values[q]-kelvin_to_celsius)) * fe_values.JxW(q));
-                local_total_area_integral += fe_values.JxW(q);
-              }
-
-            // For each field, loop over the quadrature points to get the temperature
-            // and area per field.
-            for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-              {
-                fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
-                    compositional_values);
-
-                for (unsigned int q = 0; q < n_q_points; ++q)
-                  {
-                    if (compositional_values[q] >= 0.5)
-                      {
-                        local_temperature_square_integral[c] += (((temperature_values[q]-kelvin_to_celsius) *
-                                                                  (temperature_values[q]-kelvin_to_celsius)) * fe_values.JxW(q));
-                        local_area_integral[c] += fe_values.JxW(q);
-                      }
-                  }
-              }
-          }
-
-      std::vector<double> global_temperature_square_integral (local_temperature_square_integral.size());
-      Utilities::MPI::sum (local_temperature_square_integral, this->get_mpi_communicator(), global_temperature_square_integral);
-      std::vector<double> global_area_integral (local_area_integral.size());
-      Utilities::MPI::sum (local_area_integral, this->get_mpi_communicator(), global_area_integral);
-      const double global_total_temperature_square_integral = Utilities::MPI::sum(local_total_temperature_square_integral, this->get_mpi_communicator());
-      const double global_total_area_integral = Utilities::MPI::sum(local_total_area_integral, this->get_mpi_communicator());
-
-      // compute the RMS temperature for each compositional field and for the selected compositional fields combined
-      std::vector<double> Trms_per_composition(local_area_integral.size());
-      double temperature_square_integral_selected_fields = 0., area_integral_selected_fields = 0.;
-
-      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-        {
-          Trms_per_composition[c] = std::sqrt(global_temperature_square_integral[c]) /
-                                    std::sqrt(global_area_integral[c]);
-
-          const std::vector<std::string>::iterator selected_field_it = std::find(selected_fields.begin(), selected_fields.end(), this->introspection().name_for_compositional_index(c));
-          if (selected_field_it != selected_fields.end())
-            {
-              temperature_square_integral_selected_fields += global_temperature_square_integral[c];
-              area_integral_selected_fields += global_area_integral[c];
-            }
-        }
-
-      const double Trms_selected_fields = std::sqrt(temperature_square_integral_selected_fields) / std::sqrt(area_integral_selected_fields);
-
-      // compute the RMS temperature over the whole domain
-      const double Trms_whole_domain = std::sqrt(global_total_temperature_square_integral) / std::sqrt(global_total_area_integral);
-
-      // finally produce something for the statistics file
-      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-        {
-          statistics.add_value("RMS temperature (C) for composition " + this->introspection().name_for_compositional_index(c),
-                               Trms_per_composition[c]);
-
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          const std::string columns[] = {"RMS temperature (C) for composition " + this->introspection().name_for_compositional_index(c)};
-
-          for (unsigned int i = 0; i < sizeof(columns) / sizeof(columns[0]); ++i)
-            {
-              statistics.set_precision(columns[i], 8);
-              statistics.set_scientific(columns[i], true);
-            }
-        }
-
-      // Also output the RMS temperature for the selected fields
-      statistics.add_value("RMS temperature (C) for the selected fields",
-                           Trms_selected_fields);
-
-      const std::string column = {"RMS temperature (C) for the selected fields"};
-
-      statistics.set_precision(column, 8);
-      statistics.set_scientific(column, true);
-
-      // Also output the RMS temperature for the whole domain
-      statistics.add_value("RMS temperature (C) for the whole domain",
-                           Trms_whole_domain);
-
-      const std::string column_whole_domain = {"RMS temperature (C) for the whole domain"};
-
-      statistics.set_precision(column_whole_domain, 8);
-      statistics.set_scientific(column_whole_domain, true);
-
-      std::ostringstream output;
-      output.precision(4);
-
-      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-        {
-          output << Trms_per_composition[c]
-                 << " C";
-          output << " // ";
-        }
-      output << Trms_selected_fields << " C // ";
-      output << Trms_whole_domain << " C";
-
-      return std::pair<std::string, std::string>("RMS temperature for compositions, combined selected fields and whole domain:",
-                                                 output.str());
-    }
-
-
-
-    template <int dim>
-    void CompositionTrmsStatistics<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Composition RMS temperature statistics");
-        {
-          prm.declare_entry("Names of selected compositional fields", "",
-                            Patterns::List(Patterns::Anything()),
-                            "A list of names for each of the compositional fields that "
-                            "you want to compute the combined RMS temperature for.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void CompositionTrmsStatistics<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Composition RMS temperature statistics");
-        {
-          selected_fields = Utilities::split_string_list(prm.get("Names of selected compositional fields"));
-
-          AssertThrow((selected_fields.size() > 0) &&
-                      (selected_fields.size() <= this->n_compositional_fields()),
-                      ExcMessage("The length of the list of names for the compositional "
-                                 "fields for which the RMS temperature is to be summed must be larger than zero "
-                                 "and smaller or equal to the number of compositional fields."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(CompositionTrmsStatistics,
-                                  "composition RMS temperature statistics",
-                                  "A postprocessor that computes the root-mean-square (RMS) temperature "
-                                  "over the area spanned by each compositional field (i.e. where "
-                                  "the field values are larger or equal to 0.5). It also computes the RMS "
-                                  "temperature over the summed area of a list of fields given by the user, "
-                                  "and over the whole domain.")
-  }
-}
diff --git a/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.h.bak b/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.h.bak
deleted file mode 100644
index bcf1f80503c..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.h.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_composition_trms_statistics_h
-#define _aspect_postprocess_composition_trms_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes the root mean square temperature
-     * over the area spanned by each of the compositional fields.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class CompositionTrmsStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution to compute the root-mean-square temperature per compositional field.
-         **/
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static void
-        declare_parameters(ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters(ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        std::vector<std::string> selected_fields;
-    };
-  }
-}
-
-
-#endif
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_compositions.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_compositions.prm.bak
deleted file mode 100644
index de24a7eeb08..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_compositions.prm.bak
+++ /dev/null
@@ -1,39 +0,0 @@
-# We fix composition on the right boundary,
-# because we have inflow there.
-subsection Boundary composition model
-  set Fixed composition boundary indicators = right
-  set List of model names                   = initial composition
-end
-
-# The overriding plate (OP) and subducting plate (SP)
-# are each divided into three different layers:
-# a layer of Bulk Oceanic Composition (BOC),
-# a layer of Serpentinized HarzBurgite (SHB),
-# and a "thermal layer".
-
-subsection Compositional fields
-  set Number of fields = 7
-  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = Ax=1475600.0, Az=670000.0, \
-                              Bx=1500000.0, Bz=670000.0, \
-                              Cx=1358500.0, Cz=588000.0, \
-                              Dx=1382900.0, Dz=588000.0, \
-                              Ex=1530000.0, Ez=560000.0, \
-                              Fz=663000.0, Gz=662000.0, \
-                              Hz=631000.0, Iz=630000.0
-    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
-                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
-                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
-                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
-                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
-                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
-                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
-    set Variable names      = x,z
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_materialmodel.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_materialmodel.prm.bak
deleted file mode 100644
index 8f4b35a90d9..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_materialmodel.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature         = 0.0
-    set Viscosity averaging scheme    = maximum composition
-
-    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
-    set Densities                     = 3200.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0
-    set Thermal conductivities        = 1
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_meshrefinement.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_meshrefinement.prm.bak
deleted file mode 100644
index 5ec090c8d17..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_meshrefinement.prm.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-# The maximum refinement level will be 6+4 levels,
-# corresponding to a maximum resolution of ~700 m.
-subsection Mesh refinement
-  set Initial adaptive refinement              = 4
-  set Initial global refinement                = 6
-  set Minimum refinement level                 = 6
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = plus
-  set Coarsening fraction                      = 0.01
-  set Refinement fraction                      = 0.95
-  set Run postprocessors on initial refinement = false
-  set Skip solvers on initial refinement       = true
-  set Skip setup initial conditions on initial refinement = true
-  set Strategy                                 = minimum refinement function, viscosity
-  set Time steps between mesh refinement       = 16
-
-  subsection Minimum refinement function
-    set Coordinate system = depth
-    set Variable names = x,z,t
-    set Function constants = vel=150e3, L=100e3, crust=10e3
-    set Function expression = if(x<crust,10,if(x<L,9,if(x<vel,8,6)))
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm.bak
deleted file mode 100644
index 13f6305edf3..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_postprocessing.prm.bak
+++ /dev/null
@@ -1,16 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, trench location
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, strain rate, error indicator
-    set Time between graphical output = 5e5
-  end
-
-  subsection Trench location
-    set Name of trench compositional field = BOC_OP
-  end
-
-  subsection Composition velocity statistics
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_velocity.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case1_velocity.prm.bak
deleted file mode 100644
index ffe1ab8e9b9..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case1_velocity.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom, top
-  set Prescribed velocity boundary indicators = right x:function
-
-  subsection Function
-    set Function constants  = cm=100.0
-    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
-                                 if(z>560000.0, -5.0/cm, \
-                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
-                              0
-    set Variable names      = x,z
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_materialmodel.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_materialmodel.prm.bak
deleted file mode 100644
index 4b4372e4618..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_materialmodel.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature         = 473.15
-    set Densities                     = 3200.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0
-    set Thermal expansivities         = 0
-    set Thermal conductivities        = 183.33,2.5,2.5,2.5,2.5,2.5,2.5,2.5
-    set Heat capacities               = 1250.0,750.0,750.0,750.0,750.0,1250.0,1250.0,750.0
-    set Viscosity averaging scheme    = maximum composition
-    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm.bak
deleted file mode 100644
index 97f6121cceb..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_postprocessing.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
-
-  subsection Composition velocity statistics
-    #Sum the velocities of the fields that make up the subducting plate.
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-
-  subsection Trench location
-    set Name of trench compositional field = BOC_OP
-  end
-
-  subsection Isotherm depth
-    set Isotherm value = 1073.15
-  end
-
-  subsection Composition RMS temperature statistics
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_temperatures.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_temperatures.prm.bak
deleted file mode 100644
index e6c69a04bf0..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case2a_temperatures.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# We include a shared library with a customized initial temperature plugin and the required isotherm depth, composition RMS temperature, and trench location postprocessors.
-set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/libsubduction_plate_cooling.so
-
-# We fix temperature on the top and bottom,
-# as well as on the right boundary because
-# we have inflow through the latter.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 0
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = subduction plate cooling
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/doc/Case2b_materialmodel.prm.bak b/cookbooks/kinematically_driven_subduction_2d/doc/Case2b_materialmodel.prm.bak
deleted file mode 100644
index a97345679f2..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/doc/Case2b_materialmodel.prm.bak
+++ /dev/null
@@ -1,25 +0,0 @@
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    # The benchmark uses two different reference temperatures for the compositions:
-    # 1573.15 K for the asthenosphere, thermal_OP and thermal_SP, and 473.15 K for
-    # the rest of the compositions.
-    # As ASPECT only allows for one reference temperature, we have instead adapted
-    # the reference density for the mantle compositions. To do this, we took the initial
-    # temperature and the midpoint depth of the layers and equated the density equation
-    # using the benchmark reference density rho_0_1 (3200 kg/m3) and temperature T_0_1 (1573.15 K), and
-    # the density equation using the 473.15 K reference temperature to obtain the new reference density rho_0_2.
-    # For the left thermal layer, the initial temperature at the midpoint is 1355 K, so
-    # new reference density can be derived as follows:
-    # rho_0_1 * (1 - alpha * (T - T_0_1)) = rho_0_2 * (1 - alpha * (T - T_0_2)),
-    # 3200 * (1 - 2.5e-5 * (1355 - 1573.15)) = rho_0_2 * (1 - 2.5e-5 * (1355 - 473.15))
-    # rho_0_2 = 3290.66.
-    set Reference temperature         = 473.15
-    set Densities                     = 3290.66,3000.0,3000.0,3250.0,3250.0,3290.66,3290.66,3200.0
-
-    # Compared to Case 2a, thermal expansivity is no longer zero and therefore temperature
-    # feeds into the density and therefore the Stokes equations
-    set Thermal expansivities         = 2.5e-5
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc.bak b/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc.bak
deleted file mode 100644
index 9e37fd89bd1..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "isotherm_depth.h"
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    IsothermDepth<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the temperature element alone.
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      std::vector<Point<dim>> position_values(n_q_points);
-      std::vector<double> temperature_values(n_q_points);
-
-      double local_isotherm_depth = 0.0;
-      const double max_depth = this->get_geometry_model().maximal_depth();
-      const double dT = 1.1;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-
-            fe_values.reinit (cell);
-
-            position_values = fe_values.get_quadrature_points();
-
-            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
-                                                                                         temperature_values);
-
-            for (unsigned int i=0; i<n_q_points; ++i)
-              {
-                // Calculate the biggest depth per processor
-                if (temperature_values[i] > (isotherm_value - dT) && temperature_values[i] < (isotherm_value + dT) &&
-                    (max_depth - position_values[i][dim-1]) > local_isotherm_depth)
-                  {
-                    local_isotherm_depth = max_depth - position_values[i][dim-1];
-                  }
-              }
-          }
-
-      // compute the maximum depth over all processors
-      const  double isotherm_depth =
-        Utilities::MPI::max (local_isotherm_depth, this->get_mpi_communicator());
-
-      statistics.add_value ("Isotherm depth [m]", isotherm_depth);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      {
-        const char *columns[] = { "Isotherm depth [m]"
-                                };
-        for (unsigned int i=0; i<sizeof(columns)/sizeof(columns[0]); ++i)
-          {
-            statistics.set_precision (columns[i], 8);
-            statistics.set_scientific (columns[i], true);
-          }
-      }
-
-      std::ostringstream output;
-      output.precision(4);
-      output << isotherm_depth
-             << " m ";
-      return std::pair<std::string, std::string> ("Isotherm depth [m]:",
-                                                  output.str());
-    }
-
-
-
-    template <int dim>
-    void IsothermDepth<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Isotherm depth");
-        {
-          prm.declare_entry("Isotherm value", "1573",
-                            Patterns::Double(0),
-                            "The temperature value of the isotherm "
-                            "which maximum depth is tracked. Unit: [K].");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void IsothermDepth<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Isotherm depth");
-        {
-          isotherm_value = prm.get_double("Isotherm value");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(IsothermDepth,
-                                  "isotherm depth",
-                                  "A postprocessor that computes the maximum depth "
-                                  "of a user-given isotherm.")
-  }
-}
diff --git a/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.h.bak b/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.h.bak
deleted file mode 100644
index 7553b24b75b..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/isotherm_depth.h.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_isotherm_depth_h
-#define _aspect_postprocess_isotherm_depth_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the deepest point of the last composition.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class IsothermDepth : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution to find the deepest point of a user-specified isotherm.
-         **/
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static void
-        declare_parameters(ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters(ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        double isotherm_value;
-    };
-  }
-}
-
-
-#endif
diff --git a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm.bak b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm.bak
deleted file mode 100644
index ba095e61c31..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case1.prm.bak
+++ /dev/null
@@ -1,202 +0,0 @@
-# This cookbook models oceanic subduction in a 2d
-# box of 3000 x 670 km.
-# The subducting plate is driven by inflow boundary
-# conditions on the top part of the right boundary,
-# while a balancing outflow is prescribed underneath.
-# Only density and viscosity differ per composition.
-# High resolution is required to sufficiently resolve the weak zone
-# between the subducting and overriding plate, and consequently
-# 100 MPI processes are required.
-
-# We include a shared library for the trench location postprocessor.
-set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/libsubduction_plate_cooling.so
-
-# 2D
-set Dimension                              = 2
-
-# Run for 15 My
-set Start time                             = 0
-set End time                               = 15.01e6
-set CFL number                             = 0.5
-set Use years in output instead of seconds = true
-
-# Linear solver
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = output-Case1
-set Adiabatic surface temperature          = 0
-
-# We fix composition on the right boundary,
-# because we have inflow there.
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = right
-  set List of model names = initial composition
-end
-
-# We fix temperature on the top and bottom,
-# as well as on the right boundary because
-# we have inflow through the latter.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 0
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom, top
-  set Prescribed velocity boundary indicators = right x:function
-
-  subsection Function
-    set Function constants  = cm=100.0 #*3600.0*24.0*365.25
-    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
-                                 if(z>560000.0, -5.0/cm, \
-                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
-                              0
-    set Variable names      = x,z
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 200
-  set Time between checkpoint  = 0
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature         = 0.0
-    set Viscosity averaging scheme    = maximum composition
-
-    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
-    set Densities                     = 3200.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0
-    set Thermal conductivities        = 1
-  end
-end
-
-# The overriding plate (OP) and subducting plate (SP)
-# are each divided into three different layers:
-# a layer of Bulk Oceanic Composition (BOC),
-# a layer of Serpentinized HarzBurgite (SHB),
-# and a "thermal layer".
-
-subsection Compositional fields
-  set Number of fields = 7
-  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = Ax=1475600.0, Az=670000.0, \
-                              Bx=1500000.0, Bz=670000.0, \
-                              Cx=1358500.0, Cz=588000.0, \
-                              Dx=1382900.0, Dz=588000.0, \
-                              Ex=1530000.0, Ez=560000.0, \
-                              Fz=663000.0, Gz=662000.0, \
-                              Hz=631000.0, Iz=630000.0
-    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
-                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
-                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
-                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
-                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
-                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
-                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
-    set Variable names      = x,z
-  end
-end
-
-subsection Discretization
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent   = 3000e3
-    set Y extent   = 670e3
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We ignore any temperature effects
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0
-    set Variable names      = x,y,t
-  end
-end
-
-# The maximum refinement level will be 6+4 levels,
-# corresponding to a maximum resolution of ~700 m.
-subsection Mesh refinement
-  set Initial adaptive refinement              = 4
-  set Initial global refinement                = 6
-  set Minimum refinement level                 = 6
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = plus
-  set Coarsening fraction                      = 0.01
-  set Refinement fraction                      = 0.95
-  set Run postprocessors on initial refinement = false
-  set Skip solvers on initial refinement       = true
-  set Skip setup initial conditions on initial refinement = true
-  set Strategy                                 = minimum refinement function, viscosity
-  set Time steps between mesh refinement       = 16
-
-  subsection Minimum refinement function
-    set Coordinate system = depth
-    set Variable names = x,z,t
-    set Function constants = vel=150e3, L=100e3, crust=10e3
-    set Function expression = if(x<crust,10,if(x<L,9,if(x<vel,8,6)))
-  end
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, trench location
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, strain rate, error indicator
-    set Time between graphical output = 5e5
-  end
-
-  subsection Trench location
-    set Name of trench compositional field = BOC_OP
-  end
-
-  subsection Composition velocity statistics
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end time
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm.bak b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm.bak
deleted file mode 100644
index b7c767ab9e4..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# This cookbook models oceanic subduction in a 2d
-# box of 3000 x 670 km.
-# The subducting plate is driven by inflow boundary
-# conditions on the top part of the right boundary,
-# while a balancing outflow is prescribed underneath.
-# Only density and viscosity differ per composition.
-# Building on case 1, an initial temperature field
-# based on the plate cooling model and
-# a mantle adiabatic gradient of 0.25 degrees/km
-# is prescribed, but temperature still does not affect
-# the material parameters.
-# High resolution is required to sufficiently resolve the weak zone
-# between the subducting and overriding plate, and consequently
-# 100 MPI processes are required.
-# We include a shared library for the initial temperature plugin and the isotherm depth, composition RMS temperature, and trench location postprocessors.
-set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/libsubduction_plate_cooling.so
-
-# 2D
-set Dimension                              = 2
-
-# Reuse parts of case 1
-include kinematically_driven_subduction_2d_case1.prm
-
-set Output directory                       = output-Case2a
-
-# We fix temperature on the top and bottom
-# as well as on the right boundary because
-# we have inflow through the latter.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, right
-  set List of model names = initial temperature
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature         = 473.15
-
-    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-    set Thermal conductivities        = 183.33,2.5,2.5,2.5,2.5,2.5,2.5,2.5
-    set Heat capacities               = 1250.0,750.0,750.0,750.0,750.0,1250.0,1250.0,750.0
-    set Thermal expansivities         = 0
-  end
-end
-
-# The overriding plate (OP) and subducting plate (SP)
-# are each divided into three different layers:
-# a layer of Bulk Oceanic Composition (BOC),
-# a layer of Serpentinized HarzBurgite (SHB),
-# and a "thermal layer".
-subsection Compositional fields
-  set Number of fields = 7
-  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = Ax=1475600.0, Az=670000.0, \
-                              Bx=1500000.0, Bz=670000.0, \
-                              Cx=1358500.0, Cz=588000.0, \
-                              Dx=1382900.0, Dz=588000.0, \
-                              Ex=1530000.0, Ez=560000.0, \
-                              Fz=663000.0, Gz=662000.0, \
-                              Hz=631000.0, Iz=630000.0
-    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
-                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
-                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
-                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
-                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
-                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
-                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
-    set Variable names      = x,z
-  end
-end
-
-# The initial temperature is prescribed through a plugin
-# and uses the plate cooling model for the temperature in both
-# plates (the plates have different ages) and an adiabatic
-# gradient of 0.25 degrees per km in the sublithospheric
-# mantle.
-subsection Initial temperature model
-  set List of model names = subduction plate cooling
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
-
-  subsection Composition velocity statistics
-    #Sum the velocities of the fields that make up the subducting plate.
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-
-  subsection Trench location
-    set Name of trench compositional field = BOC_OP
-  end
-
-  subsection Isotherm depth
-    set Isotherm value = 1073.15
-  end
-
-  subsection Composition RMS temperature statistics
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2b.prm.bak b/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2b.prm.bak
deleted file mode 100644
index 648bb11dc00..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2b.prm.bak
+++ /dev/null
@@ -1,38 +0,0 @@
-# This setup is a modification of the file
-# kinematically_driven_subduction_2d_case2a.prm
-# to include temperature-dependent density.
-set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/libsubduction_plate_cooling.so
-
-# 2D
-set Dimension                              = 2
-
-# Reuse parts of case 2a
-include $ASPECT_SOURCE_DIR/cookbooks/kinematically_driven_subduction_2d/kinematically_driven_subduction_2d_case2a.prm
-
-set Output directory                       = output-Case2b
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    # The benchmark uses two different reference temperatures for the compositions:
-    # 1573.15 K for the asthenosphere, thermal_OP and thermal_SP, and 473.15 K for
-    # the rest of the compositions.
-    # As ASPECT only allows for one reference temperature, we have instead adapted
-    # the reference density for the mantle compositions. To do this, we took the initial
-    # temperature and the midpoint depth of the layers and equated the density equation
-    # using the benchmark reference density rho_0_1 (3200 kg/m3) and temperature T_0_1 (1573.15 K), and
-    # the density equation using the 473.15 K reference temperature to obtain the new reference density rho_0_2.
-    # For the left thermal layer, the initial temperature at the midpoint is 1355 K, so
-    # new reference density can be derived as follows:
-    # rho_0_1 * (1 - alpha * (T - T_0_1)) = rho_0_2 * (1 - alpha * (T - T_0_2)),
-    # 3200 * (1 - 2.5e-5 * (1355 - 1573.15)) = rho_0_2 * (1 - 2.5e-5 * (1355 - 473.15))
-    # rho_0_2 = 3290.66.
-    set Reference temperature         = 473.15
-    set Densities                     = 3290.66,3000.0,3000.0,3250.0,3250.0,3290.66,3290.66,3200.0
-
-    # Compared to Case 2a, thermal expansivity is no longer zero and therefore temperature
-    # feeds into the density and therefore the Stokes equations
-    set Thermal expansivities         = 2.5e-5
-  end
-end
diff --git a/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc.bak b/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc.bak
deleted file mode 100644
index 27c7789308c..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "subduction_plate_cooling.h"
-#include <aspect/geometry_model/box.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    double
-    SubductionPlateCooling<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // This initial condition only makes sense if the geometry is a
-      // box. Throw an error if that is not the case.
-      AssertThrow(Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
-                  ExcMessage("Subduction plate cooling initial temperature is not implemented "
-                             "for any other geometry model than a box. ") );
-
-      // Model domain is 3000 x 670 km.
-      // Geometry constants:
-      // surface temperature
-      const double Ts=273.15;
-      // temperature at the base of the plates
-      const double Tm = 1573.15;
-      // the base of the subducting plate at 110 km depth
-      const double y70 = -110000.0;
-      // the base of the overriding plate at 82 km depth
-      const double y40 = -82000.0;
-      // thermal diffusivity
-      const double kappa = 1.0e-6;
-      // the age of the subducting plate
-      const double t70 = 70e6 * year_in_seconds;
-      // the age of the overriding plate
-      const double t40 = 40e6 * year_in_seconds;
-
-      // the temperature to return
-      double temperature = 0.;
-
-      // Calculate the temperature in the portions of the model domain.
-      // overriding plate + subduction interface
-      if (position[0] < 1500000.0)
-        {
-          // lithosphere
-          if (position[1] >= 588000.0)
-            temperature=Ts+(Tm-Ts)*( ((position[1]-670000.0)/y40) + (2.0/numbers::PI)*(std::exp((-kappa*numbers::PI*numbers::PI*t40)/(y40*y40))*std::sin(numbers::PI*(position[1]-670000.0)/y40) +
-                                                                                       0.5*std::exp((-kappa*2.0*2.0*numbers::PI*numbers::PI*t40)/(y40*y40))*std::sin(2.0*numbers::PI*(position[1]-670000.0)/y40)));
-          // sublithospheric mantle
-          else
-            temperature=-0.25*(position[1]/1000.0)+1720.15;
-        }
-      // subducting plate
-      else
-        {
-          // lithosphere
-          if (position[1] >= 560000.0)
-            temperature=Ts+(Tm-Ts)*( ((position[1]-670000.0)/y70) + (2.0/numbers::PI)*(std::exp((-kappa*numbers::PI*numbers::PI*t70)/(y70*y70))*std::sin(numbers::PI*(position[1]-670000.0)/y70) +
-                                                                                       0.5*std::exp((-kappa*2.0*2.0*numbers::PI*numbers::PI*t70)/(y70*y70))*std::sin(2.0*numbers::PI*(position[1]-670000.0)/y70)));
-          // sublithospheric mantle
-          else
-            temperature=-0.25*(position[1]/1000.0)+1713.15;
-        }
-      return temperature;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(SubductionPlateCooling,
-                                              "subduction plate cooling",
-                                              "An initial temperature field as specified in Quinquis (2014) "
-                                              "using the plate cooling model to prescribe temperatures "
-                                              "for an overriding and a subducting plate. ")
-  }
-}
diff --git a/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.h.bak b/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.h.bak
deleted file mode 100644
index 511abb2eb57..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.h.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_subduction_plate_cooling_h
-#define _aspect_initial_temperature_subduction_plate_cooling_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that prescribes the initial temperature field according to the plate cooling model
-     * and plate geometries implemented in Quinquis (2014).
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class SubductionPlateCooling : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-    };
-  }
-}
-
-#endif
diff --git a/cookbooks/kinematically_driven_subduction_2d/trench_location.cc.bak b/cookbooks/kinematically_driven_subduction_2d/trench_location.cc.bak
deleted file mode 100644
index c0d283ca959..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/trench_location.cc.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "trench_location.h"
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    TrenchLocation<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the compositional element alone.
-      AssertThrow(this->introspection().n_compositional_fields > 0,
-                  ExcMessage("This postprocessor cannot be used without compositional fields."));
-      const Quadrature<dim - 1> &quadrature_formula = this->introspection().face_quadratures.compositional_fields;
-
-      FEFaceValues<dim>
-      fe_face_values(this->get_mapping(),
-                     this->get_fe(),
-                     quadrature_formula,
-                     update_values |
-                     update_quadrature_points |
-                     update_JxW_values);
-
-      const unsigned int n_q_points = fe_face_values.n_quadrature_points;
-
-      // Vector to store the values of the field that defines the trench.
-      std::vector<double> compositional_values_trench(n_q_points);
-      // Vector to store the positions of the quadrature points.
-      std::vector<Point<dim>> position_values(n_q_points);
-      // For each process, find the right most occurrence of the trench field.
-      double local_trench_location = 0.;
-
-      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-      // For cells with a face along the domain surface, compute the trench location
-      // by looping over these cells and if the trench field is present at a location
-      // further right than the current local_trench_location, set the local_trench_location
-      // to this new x-coordinate.
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          for (const unsigned int f : cell->face_indices())
-            if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
-              {
-                fe_face_values.reinit(cell,f);
-
-                position_values = fe_face_values.get_quadrature_points();
-
-                fe_face_values[this->introspection().extractors.compositional_fields[selected_field]].get_function_values(this->get_solution(), compositional_values_trench);
-
-                // Calculate the rightmost occurrence of the selected field per processor.
-                // A field is counted as present when its value is equal or higher than 0.5.
-                for (unsigned int q = 0; q < n_q_points; ++q)
-                  {
-                    if (compositional_values_trench[q] >= 0.5 && position_values[q][0] > local_trench_location)
-                      {
-                        local_trench_location = position_values[q][0];
-                      }
-                  }
-              }
-
-      // compute the rightmost point over all processors
-      const  double global_trench_location =
-        Utilities::MPI::max (local_trench_location, this->get_mpi_communicator());
-
-      statistics.add_value ("Trench location [m]", global_trench_location);
-
-      // also make sure that the other columns filled by the this object
-      // all show up with sufficient accuracy and in scientific notation
-      {
-        const char *columns[] = { "Trench location [m]"
-                                };
-        for (unsigned int i=0; i<sizeof(columns)/sizeof(columns[0]); ++i)
-          {
-            statistics.set_precision (columns[i], 8);
-            statistics.set_scientific (columns[i], true);
-          }
-      }
-
-      std::ostringstream output;
-      output.precision(4);
-      output << global_trench_location
-             << " m";
-      return std::pair<std::string, std::string> ("Trench location [m]:",
-                                                  output.str());
-    }
-
-    template <int dim>
-    void TrenchLocation<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Trench location");
-        {
-          prm.declare_entry("Name of trench compositional field", "",
-                            Patterns::Anything(),
-                            "The name of the trench compositional field that "
-                            "you want to compute the rightmost position for.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void TrenchLocation<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Trench location");
-        {
-          selected_field = this->introspection().compositional_index_for_name(prm.get("Name of trench compositional field"));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(TrenchLocation,
-                                  "trench location",
-                                  "A postprocessor that computes the trench location at the domain surface, "
-                                  "i.e., the rightmost point of a given compositional field at the surface.")
-  }
-}
diff --git a/cookbooks/kinematically_driven_subduction_2d/trench_location.h.bak b/cookbooks/kinematically_driven_subduction_2d/trench_location.h.bak
deleted file mode 100644
index 49f7a64b40d..00000000000
--- a/cookbooks/kinematically_driven_subduction_2d/trench_location.h.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_trench_location_h
-#define _aspect_postprocess_trench_location_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that tracks the most left position of a certain compositional field.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class TrenchLocation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for the most left coordinate of the user-specified compositional field
-         * along the surface of the domain.
-         **/
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static void
-        declare_parameters(ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters(ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        unsigned int selected_field;
-    };
-  }
-}
-
-
-#endif
diff --git a/cookbooks/latent-heat/doc/material.part.prm.bak b/cookbooks/latent-heat/doc/material.part.prm.bak
deleted file mode 100644
index 32723b2f727..00000000000
--- a/cookbooks/latent-heat/doc/material.part.prm.bak
+++ /dev/null
@@ -1,41 +0,0 @@
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    # The change of density across the phase transition. Together with the
-    # Clapeyron slope, this is what determines the entropy change.
-    set Phase transition density jumps                 = 115.6
-    set Corresponding phase for density jump           = 0
-
-    # If the temperature is equal to the phase transition temperature, the
-    # phase transition will occur at the phase transition depth. However,
-    # if the temperature deviates from this value, the Clapeyron slope
-    # determines how much the pressure (and depth) of the phase boundary
-    # changes. Here, the phase transition will be in the middle of the box
-    # for T=T1.
-    set Phase transition depths                        = 500000
-    set Phase transition temperatures                  = 1000
-    set Phase transition Clapeyron slopes              = 1e7
-
-    # We set the width of the phase transition to 5 km. You may want to
-    # change this parameter to see how latent heating depends on the width
-    # of the phase transition.
-    set Phase transition widths                        = 5000
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 2.38
-
-    # We set the thermal expansion amd the compressibility to zero, so that
-    # all temperature (and density) changes are caused by advection, diffusion
-    # and latent heating.
-    set Thermal expansion coefficient                  = 0.0
-    set Compressibility                                = 0.0
-
-    # Viscosity is constant.
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 8.44e21
-    set Viscosity prefactors                           = 1.0, 1.0
-    set Composition viscosity prefactor                = 1.0
-  end
-end
diff --git a/cookbooks/latent-heat/latent-heat.prm.bak b/cookbooks/latent-heat/latent-heat.prm.bak
deleted file mode 100644
index b8b6bc2299c..00000000000
--- a/cookbooks/latent-heat/latent-heat.prm.bak
+++ /dev/null
@@ -1,145 +0,0 @@
-############### Global parameters
-# We use a 2d setup. Since it takes some time for
-# the model to reach a steady state we set the
-# end time to approximately 15 billion years.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 5e17
-set Use years in output instead of seconds = false
-set Output directory                       = output-latent-heat
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Heating model
-  # As we only want to look at the effects of latent heating, we disable all
-  # the other heating terms.
-  set List of model names =  latent heat
-end
-
-############### Boundary conditions
-# We only fix the temperature at the upper boundary, the other boundaries
-# are isolating.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# To guarantuee a steady downward flow, we fix the velocity
-# at the top and bottom, and set it to free slip on the sides.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Function expression = 0;-2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0e3
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    # The change of density across the phase transition. Together with the
-    # Clapeyron slope, this is what determines the entropy change.
-    set Phase transition density jumps                 = 115.6
-    set Corresponding phase for density jump           = 0
-
-    # If the temperature is equal to the phase transition temperature, the
-    # phase transition will occur at the phase transition depth. However,
-    # if the temperature deviates from this value, the Clapeyron slope
-    # determines how much the pressure (and depth) of the phase boundary
-    # changes. Here, the phase transition will be in the middle of the box
-    # for T=T1.
-    set Phase transition depths                        = 500000
-    set Phase transition temperatures                  = 1000
-    set Phase transition Clapeyron slopes              = 1e7
-
-    # We set the width of the phase transition to 5 km. You may want to
-    # change this parameter to see how latent heating depends on the width
-    # of the phase transition.
-    set Phase transition widths                        = 5000
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 2.38
-
-    # We set the thermal expansion amd the compressibility to zero, so that
-    # all temperature (and density) changes are caused by advection, diffusion
-    # and latent heating.
-    set Thermal expansion coefficient                  = 0.0
-    set Compressibility                                = 0.0
-
-    # Viscosity is constant.
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 8.44e21
-    set Viscosity prefactors                           = 1.0, 1.0
-    set Composition viscosity prefactor                = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 7
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 5e17
-    set List of output variables      = density
-  end
-end
diff --git a/cookbooks/lower_crustal_flow/lower_crustal_flow_obstacle.prm.bak b/cookbooks/lower_crustal_flow/lower_crustal_flow_obstacle.prm.bak
deleted file mode 100644
index 3136dab8c9b..00000000000
--- a/cookbooks/lower_crustal_flow/lower_crustal_flow_obstacle.prm.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-# A simple setup for a lower crustal flow around an obstacle in 3D based on Clark et al, GJI, 2005.
-
-############### Global parameters
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Output directory                       = output-lower-crustal-flow-obstacle
-set Pressure normalization                 = volume
-set Timing output frequency                = 0
-
-############### Parameters of the linear solver
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-    set Maximum number of expensive Stokes solver steps = 3000
-    set Stokes solver type = block GMG
-  end
-end
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1200e3
-    set Y extent  = 600e3
-    set Z extent  = 15e3
-    set X repetitions  = 10
-    set Y repetitions  = 5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-# first  material is lower crust
-# second material is obstacle
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = a=200e3
-    set Function expression = if ((x-600e3)^2+(y)^2 < a^2,1,0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Viscosity = 2e18
-    set Density differential for compositional field 1 = 10
-    set Composition viscosity prefactor = 1000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = front,back
-  set Zero velocity boundary indicators = bottom,top
-  set Prescribed velocity boundary indicators = left: function, right:function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = cm=0.01, year=1 , b=7.5e3
-    set Function expression =  8*cm/year*(1-((z-b)/b)^2) ; 0 ; 0
-  end
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Strategy                           = composition
-  set Initial adaptive refinement        = 0
-  set Refinement fraction                = 0.9
-  set Coarsening fraction                = 0.
-  set Minimum refinement level           = 1
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, pressure statistics
-
-  subsection Visualization
-    set Output format = vtu
-    set List of output variables = density, viscosity, strain rate
-    set Time between graphical output = 0
-  end
-end
diff --git a/cookbooks/magnetic_stripes/magnetic_stripes.cc.bak b/cookbooks/magnetic_stripes/magnetic_stripes.cc.bak
deleted file mode 100644
index 5a3cd1340f2..00000000000
--- a/cookbooks/magnetic_stripes/magnetic_stripes.cc.bak
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/composition_reaction.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class MagneticStripes : public MaterialModel::CompositionReaction<dim>
-    {
-      public:
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        static void declare_parameters (ParameterHandler &prm);
-        void parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        std::vector<double> reversal_times;
-    };
-
-
-    template <int dim>
-    void
-    MagneticStripes<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      CompositionReaction<dim>::evaluate(in, out);
-
-      int magnetic_orientation = 1;
-      if (this->simulator_is_past_initialization())
-        for (unsigned int i=0; i < reversal_times.size(); ++i)
-          if (this->get_time() < reversal_times[i])
-            {
-              // magnetic orientation is either 1 (normal) or -1 (reverse)
-              magnetic_orientation = -2 * (i % 2) + 1;
-              break;
-            }
-
-      for (unsigned int i=0; i < in.position.size(); ++i)
-        {
-          const double depth = this->get_geometry_model().depth(in.position[i]);
-          const double reaction_depth = 7000.0;
-
-          for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-            {
-              // Magnetic lineations are only generated when material approaches the surface,
-              // i.e. above the reaction depth and when the velocity is predominantly upwards.
-              if (depth < reaction_depth && in.velocity[i][1] > std::abs(in.velocity[i][0]))
-                out.reaction_terms[i][c] = -in.composition[i][0] + magnetic_orientation;
-              else
-                out.reaction_terms[i][c] = 0.0;
-            }
-        }
-    }
-
-    template <int dim>
-    void
-    MagneticStripes<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Magnetic stripes model");
-        {
-          CompositionReaction<dim>::declare_parameters (prm);
-
-          prm.declare_entry ("Reversal times", "5.0, 5.0, 2.0, 2.0, 2.092, 2.419, 2.419",
-                             Patterns::List(Patterns::Double(0)),
-                             "Reversal times of the magnetic field."
-                             "Units: yr or s, depending on the ``Use years "
-                             "in output instead of seconds'' parameter.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    MagneticStripes<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Magnetic stripes model");
-        {
-          CompositionReaction<dim>::parse_parameters (prm);
-
-          reversal_times = Utilities::string_to_double (Utilities::split_string_list(prm.get ("Reversal times")));
-          std::sort (reversal_times.begin(), reversal_times.end());
-
-          if (this->get_parameters().convert_to_years == true)
-            for (unsigned int i=0; i<reversal_times.size(); ++i)
-              reversal_times[i] *= constants::year_in_seconds;
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(MagneticStripes,
-                                   "magnetic stripes",
-                                   "A simple material model that is like the 'composition "
-                                   "reaction' model, but with a different reaction term. "
-                                   "In areas above a depth of 7 km and with a velocity that "
-                                   "does not diverge from vertically upwards by more than 45 "
-                                   "degrees, the first compositional field used in the model "
-                                   "is set to either one or minus one. The sign depends on a "
-                                   "list of reversal times that is passed to the material "
-                                   "model as an input. Before the 1st, 3rd, 5th, ... entry, "
-                                   "the sign is positive (magnetic normal orientation), and "
-                                   "before the 2nd, 4th, 6th, ... entry, the sign is negative "
-                                   "(magnetic reverse orientation). List entries are sorted "
-                                   "automatically in ascending order.")
-  }
-}
diff --git a/cookbooks/magnetic_stripes/magnetic_stripes.prm.bak b/cookbooks/magnetic_stripes/magnetic_stripes.prm.bak
deleted file mode 100644
index 4dc64baec60..00000000000
--- a/cookbooks/magnetic_stripes/magnetic_stripes.prm.bak
+++ /dev/null
@@ -1,241 +0,0 @@
-# A model of a mid-ocean ridge that shows how magnetic lineations
-# are created on the seafloor as the magnetic field changes its
-# orientation over time.
-
-
-set Additional shared libraries = ./libmagnetic_stripes.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 83.5e6
-set Use years in output instead of seconds = true
-set Output directory                       = output-magnetic-stripes
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-    set Global composition maximum = 1
-    set Global composition minimum = -1
-  end
-end
-
-############### Parameters describing the model
-# Let us here choose again a box domain (400 km wide and 100 km in depth)
-# where we fix the temperature at the bottom and top,
-# allow inflow from the bottom and outflow on the left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 400000
-    set Y extent = 100000
-    set X repetitions = 4
-    set Box origin X coordinate = -200000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1600
-    set Top temperature    = 293
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center of a mid-ocean ridge.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x:function, right x:function, top: function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = v=1, cm_per_year=0.02
-    set Function expression = if(x>0, v * cm_per_year, -v * cm_per_year); 0
-  end
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = left y:initial lithostatic pressure, right y:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Representative point = 0,0
-    set Number of integration points = 1000
-  end
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature as a constant (being equivalent to a
-# plate age of 0).
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1600
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 0
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = bottom
-  set Model name = initial composition
-end
-
-subsection Material model
-  set Model name = magnetic stripes
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1e23
-  end
-
-  subsection Magnetic stripes model
-    set Reversal times = \
-8.350E+07, 8.272E+07, \
-8.251E+07, 8.243E+07, \
-8.173E+07, 8.155E+07, \
-8.136E+07, 8.135E+07, \
-8.092E+07, 8.046E+07, \
-8.039E+07, 8.028E+07, \
-8.017E+07, 7.992E+07, \
-7.932E+07, 7.921E+07, \
-7.902E+07, 7.888E+07, \
-7.870E+07, 7.861E+07, \
-7.852E+07, 7.827E+07, \
-7.761E+07, 7.736E+07, \
-7.723E+07, 7.693E+07, \
-7.657E+07, 7.641E+07, \
-7.637E+07, 7.633E+07, \
-7.616E+07, 7.613E+07, \
-7.607E+07, 7.594E+07, \
-7.585E+07, 7.543E+07, \
-7.528E+07, 7.524E+07, \
-7.480E+07, 7.448E+07, \
-7.427E+07, 7.419E+07, \
-7.392E+07, 7.386E+07, \
-7.376E+07, 7.362E+07, \
-7.358E+07, 7.255E+07, \
-7.245E+07, 7.240E+07, \
-7.202E+07, 7.197E+07, \
-7.157E+07, 7.142E+07, \
-7.132E+07, 7.110E+07, \
-7.082E+07, 7.079E+07, \
-7.073E+07, 7.068E+07, \
-7.051E+07, 7.036E+07, \
-7.020E+07, 6.999E+07, \
-6.980E+07, 6.942E+07, \
-6.932E+07, 6.889E+07, \
-6.870E+07, 6.861E+07, \
-6.847E+07, 6.835E+07, \
-6.749E+07, 6.721E+07, \
-6.717E+07, 6.701E+07, \
-6.694E+07, 6.677E+07, \
-6.622E+07, 6.589E+07, \
-6.522E+07, 6.472E+07, \
-6.445E+07, 6.337E+07, \
-6.298E+07, 6.278E+07, \
-6.250E+07, 6.218E+07, \
-6.173E+07, 6.164E+07, \
-6.135E+07, 6.125E+07, \
-6.104E+07, 6.101E+07, \
-6.091E+07, 6.075E+07, \
-6.070E+07, 6.043E+07, \
-6.015E+07, 5.997E+07, \
-5.982E+07, 5.970E+07, \
-5.950E+07, 5.938E+07, \
-5.877E+07, 5.872E+07, \
-5.867E+07, 5.832E+07, \
-5.800E+07, 5.785E+07, \
-5.768E+07, 5.755E+07, \
-5.751E+07, 5.695E+07, \
-5.647E+07, 5.553E+07, \
-5.522E+07, 5.499E+07, \
-5.492E+07, 5.476E+07, \
-5.410E+07, 5.384E+07, \
-5.374E+07, 5.340E+07, \
-5.302E+07, 5.256E+07, \
-5.044E+07, 4.996E+07, \
-4.885E+07, 4.856E+07, \
-4.816E+07, 4.797E+07, \
-4.782E+07, 4.716E+07, \
-4.688E+07, 4.603E+07, \
-4.590E+07, 4.565E+07, \
-4.558E+07, 4.539E+07, \
-4.507E+07, 4.395E+07, \
-4.387E+07, 4.337E+07, \
-4.224E+07, 4.198E+07, \
-4.096E+07, 3.971E+07, \
-3.724E+07, 3.559E+07, \
-3.446E+07, 3.379E+07, \
-3.272E+07, 3.255E+07, \
-3.245E+07, 3.176E+07, \
-3.114E+07, 3.084E+07, \
-3.074E+07, 3.070E+07, \
-3.060E+07, 3.015E+07, \
-2.760E+07, 2.711E+07, \
-2.595E+07, 2.559E+07, \
-2.258E+07, 2.222E+07, \
-2.100E+07, 1.987E+07, \
-1.952E+07, 1.876E+07, \
-1.792E+07, 1.589E+07, \
-1.577E+07, 1.476E+07, \
-1.243E+07, 1.216E+07, \
-1.191E+07, 1.050E+07, \
-1.021E+07, 1.013E+07, \
-9.881E+06, 4.425E+06, \
-5.000E+05
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 4
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Variable names = depth, w
-    set Function expression = if(depth<7000,7,if(depth<10000,6,if(depth<30000,5,if(depth<45000,4,3))))
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e5
-    set List of output variables = density, heat flux map, vertical heat flux
-  end
-end
diff --git a/cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm.bak b/cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm.bak
deleted file mode 100644
index 786751a5b6b..00000000000
--- a/cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm.bak
+++ /dev/null
@@ -1,210 +0,0 @@
-# input file for model R of van der Wiel et al., 2024.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e9
-set Output directory                       = output-mantle-convection-annulus
-set World builder file                     = $ASPECT_SOURCE_DIR/cookbooks/mantle_convection_with_continents_in_annulus/world.wb
-set CFL number                             = 0.7
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 10
-set Nonlinear solver tolerance             = 1e-4
-set Timing output frequency                = 10
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 5000
-    set Maximum number of expensive Stokes solver steps = 0
-    set Linear solver tolerance = 1e-6
-  end
-end
-
-subsection Formulation
-  set Formulation = isentropic compression
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = 1_mantle, 3_continent
-  set Compositional field methods = particles, particles
-  set Mapped particle properties = 1_mantle: initial 1_mantle, 3_continent: initial 3_continent
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-subsection Material model
-  set Model name = compositing
-  set Material averaging = harmonic average only viscosity
-
-  subsection Visco Plastic
-    set Reference temperature = 1600
-    set Minimum viscosity     = 1e20
-    set Maximum viscosity     = 6e24
-    set Viscous flow law      = composite
-    set Minimum strain rate   = 1e-22
-    set Reference strain rate = 1e-15
-    set Heat capacities       = background: 1250, 1_mantle: 1250 | 1250 | 1250 , 3_continent: 1250
-    set Prefactors for dislocation creep          =  background:6.51e-16 ,  1_mantle: 6.51e-16| 8.51e-16 | 6.51e-16  ,  3_continent:6.51e-28
-    set Stress exponents for dislocation creep    =  background:1        ,  1_mantle: 3       | 3        | 1         ,  3_continent:       1
-    set Activation energies for dislocation creep =  background:540e3    ,  1_mantle: 500e3   | 500e3    | 530e3     ,  3_continent:   540e3
-    set Activation volumes for dislocation creep  =  background:18e-6    ,  1_mantle: 1.3e-5  | 1.3e-5   | 1.3e-5    ,  3_continent:   18e-6
-    set Prefactors for diffusion creep            =  background:6e-18    ,  1_mantle: 6e-17   | 9e-17    | 1e-18     ,  3_continent:   6e-20
-    set Grain size exponents for diffusion creep  =  background:1        ,  1_mantle: 1       | 1        | 3         ,  3_continent:       1
-    set Activation energies for diffusion creep   =  background:166e3    ,  1_mantle: 150e3   | 155e3    | 150e3     ,  3_continent:   166e3
-    set Activation volumes for diffusion creep    =  background:6.34e-7  ,  1_mantle: 6.34e-7 | 14.34e-7 | 12.34e-7  ,  3_continent: 6.34e-7
-    set Densities                                 =  background:3300     ,  1_mantle: 3300    | 3500     | 3800      ,  3_continent:    2900
-    set Grain size                                 =   1
-    set Angles of internal friction                =   1.43373998 , 1.43373998  , 30
-    set Cohesions                                  =   7e6        , 4e6,1e7
-    set Phase transition depths                        = 1_mantle: 410000 | 660000
-    set Phase transition temperatures                  = 1_mantle:   1700 | 1900
-    set Phase transition Clapeyron slopes              = 1_mantle:    3e6 | -2.5e6
-    set Phase transition widths                        = 1_mantle: 50000  | 50000
-    set Use adiabatic pressure in creep viscosity = true
-    set Constant viscosity prefactors                   = 1, 1, 1
-  end
-
-  subsection Latent heat
-    # The change of density across the phase transition. Together with the
-    # Clapeyron slope, this is what determines the entropy change.
-    set Phase transition density jumps                 = 273, 341
-    set Corresponding phase for density jump           = 1, 1
-
-    # If the temperature is equal to the phase transition temperature, the
-    # phase transition will occur at the phase transition depth. However,
-    # if the temperature deviates from this value, the Clapeyron slope
-    # determines how much the pressure (and depth) of the phase boundary
-    # changes. Here, the phase transition will be in the middle of the box
-    # for T=T1.
-    set Phase transition depths                        = 1_mantle: 410000 | 660000
-    set Phase transition temperatures                  = 1_mantle:   1700 | 1900
-    set Phase transition Clapeyron slopes              = 1_mantle:    3e6 | -2.5e6
-    set Phase transition widths                        = 1_mantle:  50000 | 50000
-    set Reference specific heat                        = 1250
-    set Thermal conductivity                           = 6
-    set Thermal expansion coefficient                  = 3e-5
-    set Viscosity prefactors                           = 1,1,1
-    set Density differential for compositional field 1 = 400
-    set Reference density                              = 2916
-  end
-
-  subsection Compositing
-    set Viscosity = visco plastic
-    set Density = latent heat
-    set Thermal expansion coefficient = latent heat
-    set Specific heat = latent heat
-    set Thermal conductivity = latent heat
-    set Compressibility = latent heat
-    set Entropy derivative pressure = latent heat
-    set Entropy derivative temperature = latent heat
-    set Reaction terms = latent heat
-  end
-end
-
-subsection Initial composition model
-  set Model name = world builder
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3480000
-    set Outer radius = 6370000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, outer
-end
-
-subsection Heating model
-  set List of model names = latent heat, adiabatic heating, constant heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-
-  subsection Constant heating
-    set Radiogenic heating rate = 5.44e-12
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = outer, inner
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Outer temperature = 300
-    set Inner temperature = 3700
-  end
-end
-
-subsection Initial temperature model
-  set Model name = world builder
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement       = 3
-  set Initial adaptive refinement     = 4
-  set Strategy                        = minimum refinement function, viscosity, velocity
-  set Time steps between mesh refinement = 1
-
-  subsection Minimum refinement function
-    set Coordinate system = spherical
-    set Function expression = if(r>6000e3, 6, if(r>5000e3,5,3))
-    set Variable names = r,phi,t
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, visualization, heat flux statistics, depth average, particles, Stokes residual, basic statistics, mobility statistics
-
-  subsection Global statistics
-    set Write statistics for each nonlinear iteration = true
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-    set Number of zones = 100
-  end
-
-  subsection Visualization
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set List of output variables = density, viscosity, strain rate, stress, temperature anomaly, spherical velocity components, adiabat, heat flux map, heating, vertical heat flux
-  end
-
-  subsection Particles
-    set Time between data output      = 1e6
-    set Data output format            = ascii, vtu
-    set Number of grouped files       = 1
-    set Write in background thread    = true
-  end
-end
-
-subsection Particles
-  set List of particle properties   = position, velocity, initial composition, pT path, initial position
-  set Update ghost particles        = true
-  set Particle generator name       = reference cell
-  set Load balancing strategy       = remove and add particles
-  set Minimum particles per cell    = 80
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 4
-    end
-  end
-end
diff --git a/cookbooks/mid_ocean_ridge/doc/boundary_conditions.part.prm.bak b/cookbooks/mid_ocean_ridge/doc/boundary_conditions.part.prm.bak
deleted file mode 100644
index 2033c6387d3..00000000000
--- a/cookbooks/mid_ocean_ridge/doc/boundary_conditions.part.prm.bak
+++ /dev/null
@@ -1,34 +0,0 @@
-##################### Velocity ########################
-
-# To model the divergent velocitiy field of a mid-ocean ridge, we prescribe
-# the plate velocity (pointing away from the ridge) at the top boundary.
-# We use a closed boundary with free slip conditions as the left boundary, which
-# marks the ridge axis and also acts as a center line for our model, so that
-# material can not cross this boundary.
-# We prescribe the velocity at the top boundary using a function:
-# At the ridge axis, the velocity is zero, at a distance of 10 km from the ridge
-# axis or more, the rigid plate uniformly moves away from the ridge with a constant
-# speed, and close to the ridge we interpolate between these two conditions.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function
-  set Tangential velocity boundary indicators = left
-
-  subsection Function
-    # We choose a half-spreading rate of u0=3cm/yr.
-    set Function constants  = u0=0.03, x0=10000
-    set Variable names      = x,z
-    set Function expression = if(x<x0,(1-(x/x0-1)*(x/x0-1))*u0,u0); 0
-  end
-end
-
-# We prescribe the lithostatic pressure as a boundary traction on
-# the bottom and right side of the model, so that material can flow in and out
-# according to the flow induced by the moving plate.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    # We calculate the pressure profile at the right model boundary.
-    set Representative point         = 105000, 70000
-  end
-end
diff --git a/cookbooks/mid_ocean_ridge/doc/compaction_length.part.prm.bak b/cookbooks/mid_ocean_ridge/doc/compaction_length.part.prm.bak
deleted file mode 100644
index 6bd66a77358..00000000000
--- a/cookbooks/mid_ocean_ridge/doc/compaction_length.part.prm.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.5
-  set Refinement fraction                      = 0.5
-
-  # Note that we allow for more adaptive refinements than before, as only cells
-  # with a small compaction length will be marked for refinement (as opposed to
-  # all melt cells), and we want to properly resolve the compaction length.
-  set Initial adaptive refinement              = 3
-  set Initial global refinement                = 4
-  set Strategy                                 = minimum refinement function, compaction length
-  set Time steps between mesh refinement       = 5
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Function expression = 4
-    set Variable names      = x,y
-  end
-
-  # We want the cells to be 8 times smaller than the compaction length.
-  subsection Compaction length
-    set Mesh cells per compaction length = 8.0
-  end
-end
diff --git a/cookbooks/mid_ocean_ridge/doc/melting_and_freezing.part.prm.bak b/cookbooks/mid_ocean_ridge/doc/melting_and_freezing.part.prm.bak
deleted file mode 100644
index 4d9a34719b3..00000000000
--- a/cookbooks/mid_ocean_ridge/doc/melting_and_freezing.part.prm.bak
+++ /dev/null
@@ -1,38 +0,0 @@
-##################### Melting and freezing ########################
-
-# Because the model includes reactions that might be on a faster time scale
-# than the time step of the model (melting and the freezing of melt), we use
-# the operator splitting scheme.
-set Use operator splitting                     = true
-
-subsection Solver parameters
-  subsection Operator splitting parameters
-    # We choose the size of the reaction time step as 200 years, small enough
-    # so that it can accurately model melting and freezing.
-    set Reaction time step                     = 2e2
-
-    # Additionally, we always want to do at least 10 operator splitting time
-    # steps in each model time step, to accurately compute the reactions.
-    set Reaction time steps per advection step = 10
-  end
-end
-
-# We use the melt simple material model that includes melting and freezing of
-# melt for an average mantle composition that is characteristic for a mid-ocean
-# ridge setting, and mainly use its default parameters.
-# In particular, we have to define how fast melting and freezing should be.
-# We assume that both reactions happen on a time scale of 200 years (or a rate
-# of 5e-3/year), which should be substantially shorter than the time step size,
-# so that the melt fraction will always be close to equilibrium.
-# As the model includes melting and freezing, we do not have to extract any melt.
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Reference permeability = 1e-7
-    set Melt extraction depth = 0.0
-    set Freezing rate         = 0.005
-    set Melting time scale for operator splitting = 2e2
-  end
-end
diff --git a/cookbooks/mid_ocean_ridge/doc/mesh_refinement.part.prm.bak b/cookbooks/mid_ocean_ridge/doc/mesh_refinement.part.prm.bak
deleted file mode 100644
index b8dca956331..00000000000
--- a/cookbooks/mid_ocean_ridge/doc/mesh_refinement.part.prm.bak
+++ /dev/null
@@ -1,28 +0,0 @@
-##################### Mesh refinement #########################
-
-# We use adaptive mesh refinement to increase the resolution in regions where
-# melt is present, and otherwise use a uniform grid.
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.5
-  set Refinement fraction                      = 0.5
-
-  # A refinement level of 5 (4 global + 1 adaptive refinements) corresponds to
-  # a cell size of approximately 1 km.
-  set Initial adaptive refinement              = 1
-  set Initial global refinement                = 4
-  set Strategy                                 = minimum refinement function, composition threshold
-  set Time steps between mesh refinement       = 5
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Function expression = 4
-    set Variable names      = x,y
-  end
-
-  # We use a very small refinement threshold for the porosity to make sure that
-  # all cells where the two-phase flow equations are solved (melt cells) have
-  # the higher resolution.
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-6, 1.0
-  end
-end
diff --git a/cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm.bak b/cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm.bak
deleted file mode 100644
index f6975188a3d..00000000000
--- a/cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm.bak
+++ /dev/null
@@ -1,254 +0,0 @@
-# 2d model for melting and melt transport at a mid-ocean ridge.
-# As the flow at mid-ocean ridges can be assumed to be roughly symmetric
-# with respect to the ridge axis in the center, we only model one half
-# of the ridge.
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 1570
-
-# Because our model includes melt transport, it is nonlinear and we have to
-# use an iterative solver scheme, that iterates between solving the temperature
-# composition and Stokes equations.
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = output-mid_ocean_ridge
-
-# The end time of the simulation. We want to run the model until it reaches
-# steady state, which is after approximately 6 million years.
-set End time                               = 8e6
-
-##################### Melting and freezing ########################
-
-# Because the model includes reactions that might be on a faster time scale
-# than the time step of the model (melting and the freezing of melt), we use
-# the operator splitting scheme.
-set Use operator splitting                     = true
-
-subsection Solver parameters
-  # Because this model includes strong localized viscosity contrasts we
-  # increase the robustness of the solver at the cost of memory consumption.
-  subsection Stokes solver parameters
-    set GMRES solver restart length = 200
-  end
-end
-
-# We use the melt simple material model that includes melting and freezing of
-# melt for an average mantle composition that is characteristic for a mid-ocean
-# ridge setting, and mainly use its default parameters.
-# In particular, we have to define how fast melting and freezing should be.
-# We assume that both reactions happen on a time scale of 200 years (or a rate
-# of 5e-3/year), which should be substantially shorter than the time step size,
-# so that the melt fraction will always be close to equilibrium.
-# As the model includes melting and freezing, we do not have to extract any melt.
-# We also slightly reduce the dependence of shear viscosity on the melt
-# fraction, because the model is relatively coarse and would otherwise develop
-# velocity oscillations in the region of highest melt content.
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Reference permeability = 1e-7
-    set Melt extraction depth = 0.0
-    set Freezing rate         = 0.005
-    set Melting time scale for operator splitting = 2e2
-    set Exponential melt weakening factor = 20
-  end
-end
-
-##################### Model geometry ########################
-
-# Our model geometry is a box of 105x70 km. This guarantees that inflowing
-# material is solid, and will start to melt within the model domain.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent      = 105000
-    set Y extent      = 70000
-
-    # To keep the aspect ratio of our elements close to one, we chose the
-    # coarse mesh is such a way that it has more elements in X than in Y
-    # direction, in the same ratio as the aspect ratio of the model.
-    set X repetitions = 3
-    set Y repetitions = 2
-  end
-end
-
-# The gravity is constant and points downward.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-##################### Velocity ########################
-
-# To model the divergent velocitiy field of a mid-ocean ridge, we prescribe
-# the plate velocity (pointing away from the ridge) at the top boundary.
-# We use a closed boundary with free slip conditions as the left boundary, which
-# marks the ridge axis and also acts as a center line for our model, so that
-# material can not cross this boundary.
-# We prescribe the velocity at the top boundary using a function:
-# At the ridge axis, the velocity is zero, at a distance of 10 km from the ridge
-# axis or more, the rigid plate uniformly moves away from the ridge with a constant
-# speed, and close to the ridge we interpolate between these two conditions.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function
-  set Tangential velocity boundary indicators = left
-
-  subsection Function
-    # We choose a half-spreading rate of u0=3cm/yr.
-    set Function constants  = u0=0.03, x0=10000
-    set Variable names      = x,z
-    set Function expression = if(x<x0,(1-(x/x0-1)*(x/x0-1))*u0,u0); 0
-  end
-end
-
-# We prescribe the lithostatic pressure as a boundary traction on
-# the bottom and right side of the model, so that material can flow in and out
-# according to the flow induced by the moving plate.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    # We calculate the pressure profile at the right model boundary.
-    set Representative point         = 105000, 70000
-  end
-end
-
-##################### Temperature ########################
-
-# As initial temperature, we choose an adiabatic profile with boundary layers at the
-# top and the bottom. We make the top boundary layer very old (100 Ma) so that in the
-# beginning, the material is still solid and the porosity is zero.
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 1e8
-    set Age bottom boundary layer   = 1e5
-    set Amplitude                   = 0
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-end
-
-# We choose a constant temperature at the top and bottom of the domain.
-# In particular, the bottom boundary temperature will control the steady state
-# temperature profile, and we choose a potential temperature of 1570 K (1300 °C).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 293
-    set Bottom temperature = 1570
-  end
-end
-
-# We want to include latent heat of melting and freezing in the model, as it is
-# an essential process for the temperature evolution, but as the model domain
-# is quite small and this is a simple model, we do not include any other sources
-# of heat.
-subsection Heating model
-  set List of model names = latent heat
-end
-
-# Melt moves with a different velocity than the solid, and transports energy,
-# so we include this process in the model.
-subsection Melt settings
-  # We want to solve the McKenzie Equations to track the flow of melt.
-  set Include melt transport = true
-  set Heat advection by melt = true
-end
-
-##################### Composition ########################
-
-# We need two compositional fields: The porosity field to track the motion of
-# melt, and the peridotite field to track the depletion of material, which is
-# changed by the melting and freezing reactions.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-# We set both fields to zero at the start of the model: The material is solid
-# (zero porosity) and has the average mantle composition (zero depletion).
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0; 0
-    set Variable names      = x,y
-  end
-end
-
-# The boundary conditions (which are relevant for material inflowing at the
-# bottom boundary of the model) are the same as the initial conditions.
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = bottom
-  set List of model names = initial composition
-end
-
-##################### Mesh refinement #########################
-
-# We use adaptive mesh refinement to increase the resolution in regions where
-# melt is present, and otherwise use a uniform grid.
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.5
-  set Refinement fraction                      = 0.5
-
-  # A refinement level of 5 (4 global + 1 adaptive refinements) corresponds to
-  # a cell size of approximately 1 km.
-  set Initial adaptive refinement              = 1
-  set Initial global refinement                = 4
-  set Strategy                                 = minimum refinement function, composition threshold
-  set Time steps between mesh refinement       = 5
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Function expression = 4
-    set Variable names      = x,y
-  end
-
-  # We use a very small refinement threshold for the porosity to make sure that
-  # all cells where the two-phase flow equations are solved (melt cells) have
-  # the higher resolution.
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-6, 1.0
-  end
-end
-
-##################### Postprocessing ########################
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics
-
-  # We mainly want to look at material properties of the solid and the melt.
-  subsection Visualization
-    set List of output variables      = material properties, melt material properties, melt fraction
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-
-    # To see in which cells melt transport is modelled, it can be useful to look
-    # at the property 'is melt cell', so we include it in the output. In addition,
-    # we always visualize the compaction pressure 'p_c' if this postprocessor is
-    # used.
-    subsection Melt material properties
-      set List of properties = compaction viscosity, permeability, fluid density, is melt cell
-    end
-  end
-end
-
-# We write a checkpoint every 100 time steps, so that we are able to restart
-# the computation from that point.
-subsection Checkpointing
-  set Steps between checkpoint = 100
-end
diff --git a/cookbooks/morency_doin_2004/doc/morency_doin.part.prm.bak b/cookbooks/morency_doin_2004/doc/morency_doin.part.prm.bak
deleted file mode 100644
index b4b29815824..00000000000
--- a/cookbooks/morency_doin_2004/doc/morency_doin.part.prm.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent      = 3000e3
-    set Y extent      = 750e3
-    set X repetitions = 4
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields  = upper_crust, lower_crust
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = if(y>=725e3,1,0);if((y<725e3&y>700e3),1,0)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=750e3, w=3000e3, mantleT=1350 # deg C
-    set Function expression = \
-      if( y < 100e3, \
-        (100e3-y)/100e3*(1600-mantleT)+mantleT+293, \
-        if(y>650e3, \
-          (h-y)/(100e3)*mantleT+293, \
-          mantleT+293))
-  end
-end
-
-subsection Material model
-  set Model name = Morency and Doin
-
-  subsection Morency and Doin
-    set Densities = 3300,2920,2920
-    set Activation energies = 500,320,320
-    set Coefficient of yield stress increase with depth = 0.25
-    set Thermal expansivities = 3.5e-5
-    set Stress exponents for viscous rheology = 3
-    set Stress exponents for plastic rheology = 30
-    set Thermal diffusivity = 0.8e-6
-    set Heat capacity = 1.25e3
-    set Activation volume = 6.4e-6
-    set Reference strain rate = 6.4e-16
-    set Preexponential constant for viscous rheology law = 7e11 ## Value used in paper is 1.24e14
-    set Cohesive strength of rocks at the surface = 117
-    set Reference temperature = 293
-    set Minimum strain rate = 5e-19                             ## Value used in paper is 1.4e-20
-  end
-end
diff --git a/cookbooks/morency_doin_2004/morency_doin.cc.bak b/cookbooks/morency_doin_2004/morency_doin.cc.bak
deleted file mode 100644
index de787747673..00000000000
--- a/cookbooks/morency_doin_2004/morency_doin.cc.bak
+++ /dev/null
@@ -1,302 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "morency_doin.h"
-#include <aspect/geometry_model/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    MorencyDoin<dim>::
-    evaluate(const MaterialModelInputs<dim> &in,
-             MaterialModelOutputs<dim> &out) const
-    {
-      const double R = 8.32; // J mol-1 K-1
-      const double g = 9.8; // m s-2
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const Point<dim> position = in.position[i];
-          const double temperature = in.temperature[i];
-          const std::vector<double> composition = in.composition[i];
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(composition);
-
-          SymmetricTensor<2,dim> strain_rate;
-          if (in.requests_property(MaterialProperties::viscosity))
-            strain_rate = in.strain_rate[i];
-
-          const double depth = this->get_geometry_model().depth(position); // Units: \\si{\\meter}
-
-          // Calculate viscosity
-          {
-            double activation_energy = 0.0;
-            for (unsigned int j=0; j < volume_fractions.size(); ++j)
-              activation_energy += volume_fractions[j] * activation_energies[j] * 1e3; // Converted to J/mol to make units work
-            double nv = 0.0;
-            for (unsigned int j=0; j < volume_fractions.size(); ++j)
-              nv += volume_fractions[j] * nvs[j];
-            double np = 0.0;
-            for (unsigned int j=0; j < volume_fractions.size(); ++j)
-              np += volume_fractions[j] * nps[j];
-
-            const double tauy = tau_0 + gamma*densities[0]*g*depth;
-
-            /**
-             * Note: The actual second invariant of strain rate is defined as $e_{00}e_{11} - e_{01}^2$,
-             * (maybe times 1/2 depending on the convention) where e is the second order strain rate
-             * tensor. The function used here reflects the equations defined in (Morency and Doin, 2004)
-             * but is otherwise unjustified. Use at your own risk.
-             */
-            const double e2inv = std::sqrt((strain_rate[0][0]*strain_rate[0][0] + strain_rate[0][1]*strain_rate[0][1])/2.0);
-
-            const double edot = std::sqrt(std::pow(e2inv,2) + std::pow(min_strain_rate,2));
-
-            // Calculate 1/(v_eff^v) and 1/(v_eff^p)
-            double one_over_veffv = 0.0;
-            if (temperature != 0.0)
-              one_over_veffv = 1.0 / (B * std::pow(edot/ref_strain_rate, -1.0+1.0/nv))
-                               * std::exp(-(activation_energy+activation_volume*densities[0]*g*depth)/(nv*R*temperature));
-            const double one_over_veffp = 1.0 / (tauy * (std::pow(edot, -1.0+1.0/np) / std::pow(ref_strain_rate, 1.0/np)));
-            // Effective viscosity = harmonic mean of diffusion and dislocation creep.
-            // = (1/(v_eff^v) + 1/(v_eff^p))^-1
-            const double veff = std::pow((one_over_veffv + one_over_veffp), -1.0);
-
-            out.viscosities[i] = veff;
-          }
-
-          // Calculate density
-          {
-            double density = 0.0;
-            for (unsigned int j=0; j < volume_fractions.size(); ++j)
-              {
-                // not strictly correct if thermal expansivities are different, since we are interpreting
-                // these compositions as volume fractions, but the error introduced should not be too bad.
-                const double temperature_factor = (1.0 - thermal_expansivities[j] * (temperature - reference_T));
-                density += volume_fractions[j] * densities[j] * temperature_factor;
-              }
-            out.densities[i] = density;
-          }
-
-          // Thermal expansion coefficients at the given positions.
-          double thermal_expansivity = 0.0;
-          for (unsigned int j=0; j < volume_fractions.size(); ++j)
-            thermal_expansivity += volume_fractions[j] * thermal_expansivities[j];
-          out.thermal_expansion_coefficients[i] = thermal_expansivity;
-          // Specific heat at the given positions.
-          out.specific_heat[i] = heat_capacity;
-          // Thermal conductivity at the given positions.
-          out.thermal_conductivities[i] = thermal_diffusivity * heat_capacity * out.densities[i];
-          // Compressibility at the given positions.
-          // The compressibility is given as
-          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
-          out.compressibilities[i] = 0.0;
-          // Pressure derivative of entropy at the given positions.
-          out.entropy_derivative_pressure[i] = 0.0;
-          // Temperature derivative of entropy at the given positions.
-          out.entropy_derivative_temperature[i] = 0.0;
-          // Change in composition due to chemical reactions at the
-          // given positions. The term reaction_terms[i][c] is the
-          // change in compositional field c at point i.
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-    template <int dim>
-    bool
-    MorencyDoin<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    MorencyDoin<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Morency and Doin");
-        {
-          prm.declare_entry ("Densities", "3300.",
-                             Patterns::List(Patterns::Double(0.)),
-                             "List of densities, $\\rho$, for background mantle and compositional fields,"
-                             "for a total of N+1 values, where N is the number of compositional fields."
-                             "If only one value is given, then all use the same value. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}");
-          prm.declare_entry ("Activation energies", "500.",
-                             Patterns::List(Patterns::Double(0.)),
-                             "List of activation energies, $E_a$, for background mantle and compositional fields,"
-                             "for a total of N+1 values, where N is the number of compositional fields."
-                             "If only one value is given, then all use the same value.  Units: \\si{\\kilo\\joule\\per\\mole}");
-          prm.declare_entry ("Thermal expansivities", "3.5e-5",
-                             Patterns::List(Patterns::Double(0.)),
-                             "List of thermal expansivities for background mantle and compositional fields,"
-                             "for a total of N+1 values, where N is the number of compositional fields."
-                             "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}");
-          prm.declare_entry ("Stress exponents for viscous rheology", "3.",
-                             Patterns::List(Patterns::Double(0.)),
-                             "List of stress exponents, $n_v$, for background mantle and compositional fields,"
-                             "for a total of N+1 values, where N is the number of compositional fields."
-                             "If only one value is given, then all use the same value.  Units: None");
-          prm.declare_entry ("Stress exponents for plastic rheology", "30.",
-                             Patterns::List(Patterns::Double(0.)),
-                             "List of stress exponents, $n_p$, for background mantle and compositional fields,"
-                             "for a total of N+1 values, where N is the number of compositional fields."
-                             "If only one value is given, then all use the same value.  Units: None");
-          prm.declare_entry ("Thermal diffusivity", "0.8e-6", Patterns::Double(0),
-                             "Units: \\si{\\meter\\squared\\per\\second}");
-          prm.declare_entry ("Heat capacity", "1.25e3", Patterns::Double(0),
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}");
-          prm.declare_entry ("Activation volume", "6.4e-6", Patterns::Double(0), "($V_a$). Units: \\si{\\meter\\cubed\\per\\mole}");
-          prm.declare_entry ("Reference strain rate", "6.4e-16", Patterns::Double(0), "($\\dot{\\epsilon}_\\text{ref}$). Units: \\si{\\per\\second}");
-          prm.declare_entry ("Preexponential constant for viscous rheology law", "1.24e14", Patterns::Double(0.), "($B$). Units: None");
-          prm.declare_entry ("Coefficient of yield stress increase with depth", "0.25", Patterns::Double(0.), "($\\gamma$). Units: None");
-          prm.declare_entry ("Cohesive strength of rocks at the surface", "117.", Patterns::Double(0.), "($\\tau_0$). Units: \\si{\\pascal}");
-          prm.declare_entry ("Reference temperature", "293.", Patterns::Double(0.), "For calculating density by thermal expansivity. Units: \\si{\\kelvin}");
-          prm.declare_entry ("Minimum strain rate", "1.4e-20", Patterns::Double(0.), "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    MorencyDoin<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // increment by one for background:
-      const unsigned int n_fields = this->n_compositional_fields() + 1;
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Morency and Doin");
-        {
-          gamma = prm.get_double("Coefficient of yield stress increase with depth");
-          thermal_diffusivity = prm.get_double("Thermal diffusivity");
-          heat_capacity = prm.get_double("Heat capacity");
-          activation_volume = prm.get_double("Activation volume");
-          ref_strain_rate = prm.get_double("Reference strain rate");
-          B = prm.get_double("Preexponential constant for viscous rheology law");
-          tau_0 = prm.get_double ("Cohesive strength of rocks at the surface");
-          min_strain_rate = prm.get_double("Minimum strain rate");
-          reference_T = prm.get_double("Reference temperature");
-
-          std::vector<double> x_values;
-
-          // Parse densities
-          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Densities")));
-          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
-                      ExcMessage("Length of density list must be either one, or n_compositional_fields+1"));
-          if (x_values.size() == 1)
-            densities.assign( n_fields , x_values[0]);
-          else
-            densities = x_values;
-
-          // Parse activation energies
-          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Activation energies")));
-          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
-                      ExcMessage("Length of activation energy list must be either one, or n_compositional_fields+1"));
-          if (x_values.size() == 1)
-            activation_energies.assign( n_fields , x_values[0] );
-          else
-            activation_energies = x_values;
-
-          // Parse thermal expansivities
-          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Thermal expansivities")));
-          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
-                      ExcMessage("Length of thermal expansivity list must be either one, or n_compositional_fields+1"));
-          if (x_values.size() == 1)
-            thermal_expansivities.assign( n_fields , x_values[0]);
-          else
-            thermal_expansivities = x_values;
-
-          // Parse stress exponents
-          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Stress exponents for viscous rheology")));
-          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
-                      ExcMessage("Length of nv list must be either one, or n_compositional_fields+1"));
-          if (x_values.size() == 1)
-            nvs.assign( n_fields , x_values[0]);
-          else
-            nvs = x_values;
-          x_values = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Stress exponents for plastic rheology")));
-          AssertThrow(x_values.size() == 1u || (x_values.size() == n_fields),
-                      ExcMessage("Length of np list must be either one, or n_compositional_fields+1"));
-          if (x_values.size() == 1)
-            nps.assign( n_fields , x_values[0]);
-          else
-            nps = x_values;
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(MorencyDoin,
-                                   "Morency and Doin",
-                                   "An implementation of the visco-plastic rheology described by Morency "
-                                   "and Doin in \\cite{MD04}. Compositional fields can each be assigned individual "
-                                   "activation energies, reference densities, thermal expansivities, and "
-                                   "stress exponents. The effective viscosity is defined as "
-                                   "\\[v_\\text{eff} = \\left(\\frac{1}{v_\\text{eff}^v}+\\frac{1}{v_\\text{eff}^p}\\right)^{-1}\\] "
-                                   "where "
-                                   "\\[v_\\text{eff}^v = B \\left(\\frac{\\dot{\\epsilon}}{\\dot{\\epsilon}_\\text{ref}} "
-                                   "\\right)^{-1+1/n_v} exp\\left(\\frac{E_a +V_a \\rho_m g z}{n_v R T}\\right) \\] "
-                                   "\\[v_\\text{eff}^p = (\\tau_0 + \\gamma \\rho_m g z) \\left( \\frac{\\dot{\\epsilon}^{-1+1/n_p}} "
-                                   "{\\dot{\\epsilon}_\\text{ref}^{1/n_p}} \\right) \\] "
-                                   "where $B$ is a scaling constant; $\\dot{\\epsilon}$ is defined as "
-                                   "the quadratic sum of the second invariant of the strain rate tensor and "
-                                   "a minimum strain rate, $\\dot{\\epsilon}_0$; $\\dot{\\epsilon}_\\text{ref}$ "
-                                   "is a reference strain rate; $n_v$, and $n_p$ are stress exponents; $E_a$ "
-                                   "is the activation energy; $V_a$ is the activation volume; $\\rho_m$ is the "
-                                   "mantle density; $R$ is the gas constant; $T$ is temperature; $\\tau_0$ is "
-                                   "the cohesive strength of rocks at the surface; $\\gamma$ is a coefficient "
-                                   "of yield stress increase with depth; and $z$ is depth. "
-                                   "\n\n"
-                                   "\\note{Morency and Doin define the second invariant of the strain "
-                                   "rate in a nonstandard way (see \\cite{MD04}. The formulation in the paper is given as "
-                                   "$\\epsilon_{II} = \\sqrt{\\frac{1}{2} (\\epsilon_{11}^2 +"
-                                   "\\epsilon_{12}^2)}$ where $\\epsilon$ is the strain rate tensor. "
-                                   "For consistency, that is also the formulation implemented in this material model.}"
-                                   "\n\n"
-                                   "The value for the components of this formula and additional parameters are "
-                                   "read from the parameter file in subsection 'Material model/Morency and Doin'.")
-  }
-}
diff --git a/cookbooks/morency_doin_2004/morency_doin.h.bak b/cookbooks/morency_doin_2004/morency_doin.h.bak
deleted file mode 100644
index 11c0b6cd534..00000000000
--- a/cookbooks/morency_doin_2004/morency_doin.h.bak
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_morency_doin_h
-#define _aspect_material_model_morency_doin_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <deal.II/base/parameter_handler.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model based on the rheology described in (Morency and Doin,
-     * 2004): Brittle-ductile rheology with a viscosity strongly depending on
-     * temperature and composition. Using pseudo-brittle rheology limits the
-     * strength of the lithosphere at low temperature.
-     *
-     * The effective viscosity is defined as the harmonic mean of two stress-
-     * dependent viscosity functions: a simple temperature/pressure-dependent,
-     * non-Newtonian viscosity, and a more strongly stress-dependent,
-     * "plastic" viscosity.
-     *
-     * @f[ v_{eff}^v = B \left(\frac{\dot{\varepsilon}}{\dot{\varepsilon}_{ref}}\right)^{-1+1/n_v}
-     * exp\left(\frac{E_a +V_a \rho_m g z}{n_v R T}\right) @f]
-     * @f[ v_{eff}^p = (\tau_0 + \gamma \rho_m g z) \left( \frac{\dot{\varepsilon}^{-1+1/n_p}}
-     * {\dot{\varepsilon}_{ref}^{1/n_p}} \right) @f]
-     * @f[ v_{eff} = \left(\frac{1}{v_{eff}^v}+\frac{1}{v_{eff}^p}\right)^{-1} @f]
-     *
-     * Where $v_{eff}$ is the effective viscosity, $B$ is a scaling constant,
-     * $\dot{\varepsilon}$ is related to the second invariant of the strain
-     * rate tensor, $\dot{\varepsilon}_{ref}$ is a reference strain rate,
-     * $n_v$ and $n_p$ are stress exponents, $E_a$ is the activation energy,
-     * $V_a$ is the activation volume, $\rho_m$ is the mantle density, $R$ is
-     * the gas constant, $T$ is temperature, $\tau_0$ is the cohesive
-     * strength of rocks at the surface, $\gamma$ is a coefficient of yield
-     * stress increase with depth, and $z$ is depth.
-     *
-     * Several model parameters (reference densities, activation energies,
-     * thermal expansivities, and stress exponents-- both viscous and plastic)
-     * can be defined per-compositional field. If a list of values is given
-     * for any of these parameters, the weighted sum of the values based on
-     * volume fractions of the compositional fields is used in their place. If
-     * only one value is given for any of these parameters, all compositions
-     * are assigned the same value. The first value in the list is the value
-     * assigned to "background mantle" (regions where the sum of the
-     * compositional fields is < 1.0).
-     *
-     * For more on the material model and its applications, see: Morency, C.,
-     * and M‐P. Doin. "Numerical simulations of the mantle lithosphere
-     * delamination." Journal of Geophysical Research: Solid Earth
-     * (1978–2012) 109.B3 (2004)
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class MorencyDoin : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Evaluate material properties.
-         */
-        void evaluate(const MaterialModelInputs<dim> &in,
-                      MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        std::vector<double> densities;
-        std::vector<double> activation_energies;
-        std::vector<double> thermal_expansivities;
-        std::vector<double> nvs; // Stress exponent, viscous rheology
-        std::vector<double> nps;//Stress exponent, plastic rheology
-        double thermal_diffusivity;
-        double gamma; // Coefficient of yield stress increase with depth
-        double heat_capacity;
-        double activation_volume;
-        double ref_strain_rate;
-        double B; // Preexponential constant in the viscous rheology law B
-        double tau_0; // cohesive strength of rocks at the surface
-        double reference_T;
-        double min_strain_rate;
-    };
-
-  }
-}
-
-#endif
diff --git a/cookbooks/morency_doin_2004/morency_doin.prm.bak b/cookbooks/morency_doin_2004/morency_doin.prm.bak
deleted file mode 100644
index 40880818d7c..00000000000
--- a/cookbooks/morency_doin_2004/morency_doin.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-set Dimension = 2
-set Maximum time step = 1e4
-set Nonlinear solver scheme = iterated Advection and Stokes
-set Output directory = output-morency_doin
-set Additional shared libraries            = ./libmorency_doin.so
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent      = 3000e3
-    set Y extent      = 750e3
-    set X repetitions = 4
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom, left, right
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields  = upper_crust, lower_crust
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = if(y>=725e3,1,0);if((y<725e3&y>700e3),1,0)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=750e3, w=3000e3, mantleT=1350 # deg C
-    set Function expression = \
-      if( y < 100e3, \
-        (100e3-y)/100e3*(1600-mantleT)+mantleT+293, \
-        if(y>650e3, \
-          (h-y)/(100e3)*mantleT+293, \
-          mantleT+293))
-  end
-end
-
-subsection Material model
-  set Model name = Morency and Doin
-
-  subsection Morency and Doin
-    set Densities = 3300,2920,2920
-    set Activation energies = 500,320,320
-    set Coefficient of yield stress increase with depth = 0.25
-    set Thermal expansivities = 3.5e-5
-    set Stress exponents for viscous rheology = 3
-    set Stress exponents for plastic rheology = 30
-    set Thermal diffusivity = 0.8e-6
-    set Heat capacity = 1.25e3
-    set Activation volume = 6.4e-6
-    set Reference strain rate = 6.4e-16
-    set Preexponential constant for viscous rheology law = 7e11 ## Value used in paper is 1.24e14
-    set Cohesive strength of rocks at the surface = 117
-    set Reference temperature = 293
-    set Minimum strain rate = 5e-19                             ## Value used in paper is 1.4e-20
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = initial temperature
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Mesh refinement
-  set Initial global refinement                 = 5
-  set Initial adaptive refinement               = 3
-  set Strategy                                  = minimum refinement function
-
-  subsection Minimum refinement function
-    set Variable names = d,ignored
-    set Function expression = if(d<100e3,8,5)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Number of zones = 500
-    set Output format = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-      set Stokes solver type = block AMG
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 0
-end
diff --git a/cookbooks/multicomponent_steinberger/doc/comp.field.prm.bak b/cookbooks/multicomponent_steinberger/doc/comp.field.prm.bak
deleted file mode 100644
index bbefd054421..00000000000
--- a/cookbooks/multicomponent_steinberger/doc/comp.field.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields  = basalt_fraction
-  set Types of fields  = chemical composition
-end
diff --git a/cookbooks/multicomponent_steinberger/doc/comp.setup.prm.bak b/cookbooks/multicomponent_steinberger/doc/comp.setup.prm.bak
deleted file mode 100644
index 6e2f96548cd..00000000000
--- a/cookbooks/multicomponent_steinberger/doc/comp.setup.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system   = cartesian
-    set Variable names      = x, y
-    set Function constants  = a=2744.3e3, size=400e3, k=-7e-7, c=2.9367
-    set Function expression = ( (sqrt(x^2+y^2)>=3981.e3 && (x-a)^2+(y-a)^2<=size^2) ? (0.15) : \
-                              (sqrt(x^2+y^2)<3981.e3 && sqrt(x^2+y^2)>=3481.e3) ? \
-                              (c+k*sqrt(x^2+y^2)) : (0) )
-  end
-end
diff --git a/cookbooks/multicomponent_steinberger/doc/conductivity.setup.prm.bak b/cookbooks/multicomponent_steinberger/doc/conductivity.setup.prm.bak
deleted file mode 100644
index d13e458712c..00000000000
--- a/cookbooks/multicomponent_steinberger/doc/conductivity.setup.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Thermal conductivity formulation = p-T-dependent
-  end
-end
diff --git a/cookbooks/multicomponent_steinberger/doc/lookup.part.prm.bak b/cookbooks/multicomponent_steinberger/doc/lookup.part.prm.bak
deleted file mode 100644
index 2b260351220..00000000000
--- a/cookbooks/multicomponent_steinberger/doc/lookup.part.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names              = pyr_MS95_with_volume_fractions_lo_res.dat, \
-                                           morb_G13_with_volume_fractions_lo_res.dat\
-  end
-  end
-end
diff --git a/cookbooks/multicomponent_steinberger/doc/temperature.setup.prm.bak b/cookbooks/multicomponent_steinberger/doc/temperature.setup.prm.bak
deleted file mode 100644
index 0a93b17b41d..00000000000
--- a/cookbooks/multicomponent_steinberger/doc/temperature.setup.prm.bak
+++ /dev/null
@@ -1,26 +0,0 @@
-subsection Initial temperature model
-  set List of model operators = add
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-    set Age bottom boundary layer = 7e8
-
-    subsection Function
-      set Function constants  = k=-7e-7, c=2.9367
-      set Variable names      = x, y
-
-      # if Number of fields = 2, there should be two function expressions
-      set Function expression = (sqrt(x^2+y^2)<3981.e3 ? c+k*sqrt(x^2+y^2) : 0 )
-    end
-  end
-
-  subsection Function
-    set Coordinate system   = cartesian
-    set Variable names      = x, y
-    set Function constants  = Tex=450, a=2744.3e3, size=400e3, Tb=3550, Tab=2663.3, age=2.208e16, kappa=1.16e-6,
-    set Function expression = ( ((x-a)^2+(y-a)^2<=size^2) ? \
-                               ( max(Tex - (Tb-Tab)*erfc( (-3481e3 + sqrt(x^2+y^2)) /2/sqrt(kappa*age) ),0) ) : \
-                              (0) )
-  end
-end
diff --git a/cookbooks/multicomponent_steinberger/steinberger_thermochemical_plume.prm.bak b/cookbooks/multicomponent_steinberger/steinberger_thermochemical_plume.prm.bak
deleted file mode 100644
index 1a8508145cd..00000000000
--- a/cookbooks/multicomponent_steinberger/steinberger_thermochemical_plume.prm.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-# This is a cookbook of modeling a thermochemical plumes using the  multicomponent
-# Steinberger material model. The model setup is similar to Dannberg and Sobolev (2015).
-
-set Output directory                       = output-multicomponent-steinberger
-set CFL number                             = 1.0
-set End time                               = 3e8
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-set Maximum first time step                = 1.e4
-
-# Multiple composition setup
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields  = basalt_fraction
-  set Types of fields  = chemical composition
-end
-
-# Prescribe the initial composition.
-# The setup is similar to Supplementary Figure 2b (Dannberg and Sobolev, 2015)
-# The constants used in the function:
-# a = coordinate of the center of the circular compositional anomaly
-# size = radius of the compositional anomaly
-# k, c = slope and intercept determine the fraction of eclogite change with depth
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system   = cartesian
-    set Variable names      = x, y
-    set Function constants  = a=2744.3e3, size=400e3, k=-7e-7, c=2.9367
-    set Function expression = ( (sqrt(x^2+y^2)>=3981.e3 && (x-a)^2+(y-a)^2<=size^2) ? (0.15) : \
-                              (sqrt(x^2+y^2)<3981.e3 && sqrt(x^2+y^2)>=3481.e3) ? \
-                  (c+k*sqrt(x^2+y^2)) : (0) )
-  end
-end
-
-# The Material model setup is similar to "steinberger.prm" except we have
-# N+1 material file for N compositional fields. The material files are ordered as
-# "background, field#1, field#2, ..."
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names              = pyr_MS95_with_volume_fractions_lo_res.dat, \
-             morb_G13_with_volume_fractions_lo_res.dat
-    set Lateral viscosity file name      = temp-viscosity-prefactor.txt
-    set Radial viscosity file name       = radial-visc-simple.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-
-    # We are using default pressure-temperature dependent thermal conductivity.
-    set Thermal conductivity formulation = p-T-dependent
-
-    # You must set this to false to avoid step-wise viscosity inherited
-    # from the reference profile "radial-visc-simple.txt".
-    set Use lateral average temperature for viscosity = false
-  end
-end
-
-# Prescribe the initial temperature.
-# Here we are using half-space cooling model to set up a 50 Ma top boundary
-# layer and a 700 Ma bottom boundary layer. The setup of the plume excess
-# temperature is similar to Supplementary Figure 2a (Dannberg and Sobolev, 2015)
-# and is described by the function. All the expressions in the boundary
-# temperature model and the function are added to the adiabatic temperature
-# profile because we set the model operators as "add". You can also use
-# "subtract, minimum, maximum, replace if valid".
-
-# The constants used in the function:
-#  Tex = plume excess temperature
-#  Tb = bottom temperature
-#  Tab = the adiabatic bottom temperature, should be consistent with the
-#       adiabatic surfacetemperature of the model.
-#  age = must be consistent with the "Age bottom boundary layer" in seconds
-#  kappa = should be consistent with the characteristic Cp, rho, and k around
-#        the CMB
-subsection Initial temperature model
-  set List of model operators = add
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-    set Age bottom boundary layer = 7e8
-
-    subsection Function
-      set Function constants  = k=-7e-7, c=2.9367
-      set Variable names      = x, y
-
-      # if Number of fields = 2, there should be two function expressions
-      set Function expression = (sqrt(x^2+y^2)<3981.e3 ? c+k*sqrt(x^2+y^2) : 0 )
-    end
-  end
-
-  subsection Function
-    set Coordinate system   = cartesian
-    set Variable names      = x, y
-    set Function constants  = Tex=450, a=2744.3e3, size=400e3, Tb=3550, Tab=2663.3, age=2.208e16, kappa=1.16e-6,
-    set Function expression = ( ((x-a)^2+(y-a)^2<=size^2) ? \
-                 ( max(Tex - (Tb-Tab)*erfc( (-3481e3 + sqrt(x^2+y^2)) /2/sqrt(kappa*age) ),0) ) : \
-            (0) )
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 3550
-    set Outer temperature = 288
-  end
-end
-
-# generate visualization and statistic files.
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set List of output variables      = depth, material properties, named additional outputs
-    set Time between graphical output = 5e6
-
-    subsection Material properties
-      set List of material properties   = viscosity, density, specific heat, thermal conductivity, thermal expansivity, compressibility
-    end
-  end
-end
-
-# other model setup
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-# Free slip on all boundaries.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom, left, right
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 7
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 1
-end
diff --git a/cookbooks/muparser_temperature_example/doc/check-initial-condition.part.prm.bak b/cookbooks/muparser_temperature_example/doc/check-initial-condition.part.prm.bak
deleted file mode 100644
index ab4d227ca29..00000000000
--- a/cookbooks/muparser_temperature_example/doc/check-initial-condition.part.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# Dimension, end-time (years) and output directory
-# Only does zeroth time-step to show that initial condition works
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-
-# If you have a large model or a model with large viscosity variation and you
-# want to run the 0th timestep more quickly in order to just check in the initial
-# condition (IC), you can set these solver tolerance values to larger numbers, but
-# this means the solution will not be converged.
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance            = 1e-6 # can set to 1e-3 for checking IC
-  end
-end
diff --git a/cookbooks/muparser_temperature_example/doc/mesh-refinement.part.prm.bak b/cookbooks/muparser_temperature_example/doc/mesh-refinement.part.prm.bak
deleted file mode 100644
index aba6e56348e..00000000000
--- a/cookbooks/muparser_temperature_example/doc/mesh-refinement.part.prm.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-# Refine the upper 150 km of the mesh so lithosphere structure is resolved.
-# Function expression asks if the depth is less than the lithosphere depth and
-# then refinement level = 7, else refinement level = 0.
-# Note, the minimum refinement level for the lower 850 km of the mesh would be
-# coarser than the initial one level of global refinement. This would then lead
-# to coarsening in the future.
-# To avoid this, you may want to set this 'else' value to the same as the number
-# of initial global refinement steps.
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Minimum refinement level           = 3
-  set Initial adaptive refinement        = 4
-  set Time steps between mesh refinement = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function constants  = ymax=1.e6, lith=1.5e5
-    set Function expression = ((ymax-y<=lith) ? 7 : 0)
-  end
-end
diff --git a/cookbooks/muparser_temperature_example/doc/repetitions.part.prm.bak b/cookbooks/muparser_temperature_example/doc/repetitions.part.prm.bak
deleted file mode 100644
index 1e5c71fa33f..00000000000
--- a/cookbooks/muparser_temperature_example/doc/repetitions.part.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-# Want a 2D box 5000 km wide by 1000 km deep (5e6 x 1e6  meters)
-# The variable repetitions divides the whole domain into 5 boxes (1000 x 1000 km)
-# as the 0th level mesh refinement: this is needed so elements are squares
-# and not elongated rectangles.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 5e6
-    set Y extent = 1e6
-    set X repetitions = 5
-    set Y repetitions = 1
-  end
-end
diff --git a/cookbooks/muparser_temperature_example/doc/temperature.part.prm.bak b/cookbooks/muparser_temperature_example/doc/temperature.part.prm.bak
deleted file mode 100644
index caee45dfda6..00000000000
--- a/cookbooks/muparser_temperature_example/doc/temperature.part.prm.bak
+++ /dev/null
@@ -1,39 +0,0 @@
-# Half-space cooling model increasing with age from x>0 to xtr
-# For x>xtr, half-space cooling model with a fixed age.
-# Note, we use 1-erfc instead of erf because the muparser in dealii
-# only knows about erfc. Also, we need to use ymax-y since y=0 at the
-# bottom of the box.
-# vsub is the velocity of the subducting plate in m/s
-# (x/vsub is the age of the subducting plate)
-# ageop is the age of the overriding plate in seconds.
-# Tm is the mantle temperature, Ts is the surface temperature in kelvin
-# kappa is the thermal diffusivity (m^2/s)
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = ymax=1.0e6, xtrm=2.200e6, vsub=7.927e-10, \
-                               ageop=9.46e14, Tm=1673, Ts=273, kappa=1e-6
-    set Function expression = (((x>0.0) && (x<=xtrm)) ? \
-                                 (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*(x/vsub)))))) : \
-                                 (x>xtrm) ? \
-                                  (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*ageop))))) :\
-                                  (Tm) )
-  end
-end
-
-# Set boundary types and values for temperature
-# Default is zero-flux (keep for sidewalls),
-# so only need set top and bottom to fixed temperature
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1673
-    set Top temperature    = 273
-  end
-end
diff --git a/cookbooks/muparser_temperature_example/muparser-temperature-example.prm.bak b/cookbooks/muparser_temperature_example/muparser-temperature-example.prm.bak
deleted file mode 100644
index 0571836ca36..00000000000
--- a/cookbooks/muparser_temperature_example/muparser-temperature-example.prm.bak
+++ /dev/null
@@ -1,159 +0,0 @@
-# Basic parameter file for using a function expression to define the
-# initial temperature structure using (? : ) syntax for if-else conditions.
-# 2D, Dimensional, Boussinesq, Simple Material Model
-
-# Dimension, end-time (years) and output directory
-# Only does zeroth time-step to show that initial condition works
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output-muparser-temperature-example
-
-# Parameters Related to the Solver and Pressure Normalization
-
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Even when using the Boussinesq approximation you need to set this parameter
-# because this will be the temperature used to calculate the reference density
-# used in the advection equation (even if a separate reference temperature is
-# specified by the material model)
-
-set Adiabatic surface temperature          = 273 # K
-
-# If you have a large model or a model with large viscosity variation and you
-# want to run the 0th timestep more quickly in order to just check in the initial
-# condition (IC), you can set these solver tolerance values to larger numbers, but
-# this means the solution will not be converged.
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance            = 1e-6 # can set to 1e-3 for checking IC
-  end
-end
-
-# The following is equivalent to the Boussinesq approximation
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-# Want a 2D box 5000 km wide by 1000 km deep (5e6 x 1e6 meters).
-# The variable repetitions divides the whole domain into 5 boxes (1000 x 1000 km)
-# as the 0th level mesh refinement: this is needed so elements are squares
-# and not elongated rectangles.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 5e6
-    set Y extent = 1e6
-    set X repetitions = 5
-    set Y repetitions = 1
-  end
-end
-
-# Refine the upper 150 km of the mesh so lithosphere structure is resolved.
-# Function expression asks if the depth is less than the lithosphere depth and
-# then refinement level = 7, else refinement level = 0.
-# Note, the minimum refinement level for the lower 850 km of the mesh would be
-# coarser than the initial one level of global refinement. This would then lead
-# to coarsening in the future.
-# To avoid this, you may want to set this 'else' value to the same as the number
-# of initial global refinement steps.
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Minimum refinement level           = 3
-  set Initial adaptive refinement        = 4
-  set Time steps between mesh refinement = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function constants  = ymax=1e6,lith=1.5e5
-    set Function expression = ((ymax-y<=lith) ? 7 : 0)
-  end
-end
-
-# Half-space cooling model increasing with age from x>0 to xtrm
-# For x>xtrm, half-space cooling model with a fixed age.
-# Note, we use 1-erfc instead of erf because the muparser in dealii
-# only knows about erfc. Also, we need to use ymax-y since y=0 at the
-# bottom of the box.
-# vsub is the velocity of the subducting plate in m/s
-# (x/vsub is the age of the subducting plate)
-# ageop is the age of the overriding plate in seconds.
-# Tm is the mantle temperature, Ts is the surface temperature in kelvin
-# kappa is the thermal diffusivity (m^2/s)
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = ymax=1.0e6, xtrm=2.200e6, vsub=7.927e-10, \
-                               ageop=9.46e14, Tm=1673, Ts=273, kappa=1e-6
-    set Function expression = (((x>0.0) && (x<=xtrm)) ? \
-                                 (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*(x/vsub)))))) : \
-                                 (x>xtrm) ? \
-                                  (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*ageop))))) :\
-                                  (Tm) )
-  end
-end
-
-# Set boundary types and values for temperature
-# Default is zero-flux (keep for sidewalls), so only need set top and bottom to fixed temperature
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1673
-    set Top temperature    = 273
-  end
-end
-
-# Free-slip on all sides (tangential velocity V-perp=0, dV/dn=0)
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300  # kg/m^3
-    set Reference specific heat       = 1250  # J/kg/K
-    set Reference temperature         = 273   # K
-    set Thermal conductivity          = 4.125 # W/m/K
-    set Thermal expansion coefficient = 2e-5  # 1/K
-    set Viscosity                     = 1e21  # Pa s
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics
-
-  subsection Visualization
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-end
diff --git a/cookbooks/onset_of_convection/onset_of_convection.prm.bak b/cookbooks/onset_of_convection/onset_of_convection.prm.bak
deleted file mode 100644
index 1278a31764d..00000000000
--- a/cookbooks/onset_of_convection/onset_of_convection.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# This setup is a copy of the
-# benchmarks/onset-of-convection/convection-box-base.prm
-# contributed by Max Rudolph, with the difference that
-# parameter values are specified explicitly in the input file
-# (rather than through an ipython notebook).
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use conduction timestep                = true
-
-subsection Termination criteria
-  set Termination criteria                 = end step
-  set End step                             = 100
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9.424777e6 # pi * 3e6
-    set Y extent = 3e6
-    set X repetitions = 3
-    set Y repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=1, L=9.424777e6, H=3.0e6, pi=3.1415926536, k=2
-    set Function expression = 2500 * (1.0-z/H) - p*cos(k*pi*x/L)*sin(pi*z/H)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 2500
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 4000
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity                     = 1e23
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set Time steps between graphical output = 5
-  end
-end
diff --git a/cookbooks/platelike-boundary/doc/boundary.part.prm.bak b/cookbooks/platelike-boundary/doc/boundary.part.prm.bak
deleted file mode 100644
index 250d9e69271..00000000000
--- a/cookbooks/platelike-boundary/doc/boundary.part.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
diff --git a/cookbooks/platelike-boundary/doc/platelike.prm.bak b/cookbooks/platelike-boundary/doc/platelike.prm.bak
deleted file mode 100644
index 27250340f5e..00000000000
--- a/cookbooks/platelike-boundary/doc/platelike.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20
-set Use years in output instead of seconds = false
-set Output directory                       = output-platelike-boundary
-
-############### Parameters describing the model
-# Let us here choose again a box domain of size 2x1
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-# We then set the temperature to one at the bottom and zero
-# at the top:
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/cookbooks/platelike-boundary/platelike-boundary.prm.bak b/cookbooks/platelike-boundary/platelike-boundary.prm.bak
deleted file mode 100644
index b89539d9600..00000000000
--- a/cookbooks/platelike-boundary/platelike-boundary.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# A description of convection in a rectangular box where we prescribe
-# temporally variable boundary conditions for the velocity along the top
-# boundary. See the manual for more information.
-
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20
-set Use years in output instead of seconds = false
-set Output directory                       = output-platelike-boundary
-
-############### Parameters describing the model
-# Let us here choose again a box domain of size 2x1
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-# We then set the temperature to one at the bottom and zero
-# at the top:
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/cookbooks/plume_2D_chunk/opening_angle_45degrees.prm.bak b/cookbooks/plume_2D_chunk/opening_angle_45degrees.prm.bak
deleted file mode 100644
index b627610d078..00000000000
--- a/cookbooks/plume_2D_chunk/opening_angle_45degrees.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-include ./plume2D.prm
-
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 45
-    set Chunk maximum longitude = 90
-  end
-end
diff --git a/cookbooks/plume_2D_chunk/opening_angle_90degrees.prm.bak b/cookbooks/plume_2D_chunk/opening_angle_90degrees.prm.bak
deleted file mode 100644
index 3b0b3a38693..00000000000
--- a/cookbooks/plume_2D_chunk/opening_angle_90degrees.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-include ./plume2D.prm
-
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-  end
-end
diff --git a/cookbooks/plume_2D_chunk/plume2D.prm.bak b/cookbooks/plume_2D_chunk/plume2D.prm.bak
deleted file mode 100644
index 658c90f0ceb..00000000000
--- a/cookbooks/plume_2D_chunk/plume2D.prm.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-# A simple setup for a plume in a 2D chunk based on Kellogg \& King, EPSL 148 (1997).
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 200e9
-set Output directory                       = output_plume2D
-set Maximum time step                      = 5e7
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Reference temperature and viscosity
-    set Reference temperature = 273
-
-    # Limit the viscosity with maximum=1000*eta0
-    set Minimum viscosity = 1.25e23
-    set Maximum viscosity = 1.25e26
-
-    # Thermal diffusivity is adjusted to match thermal conductivities
-    # assumed in assigning the initial geotherm
-    set Thermal diffusivities =  5.5e-7
-    set Heat capacities       =  1250.
-    set Densities             =  3250
-    set Thermal expansivities =  3e-5
-    set Viscous flow law      = diffusion
-    set Activation volumes for diffusion creep  = 0
-    set Grain size = 1
-
-    # isoviscous
-    set Prefactors for diffusion creep          = 4e-24
-    set Activation energies for diffusion creep = 0
-
-    # Plasticity parameters - irrelevant
-    # set to very high value so that it is not used
-    set Cohesions = 1e15
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3480000
-    set Chunk outer radius = 6371000
-    set Chunk minimum longitude = 67.5
-    set Chunk maximum longitude = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-# temperature is set to 273K at the top, i.e. for r>4e6
-# where 4e6 is an arbitrary radius value falling between
-# the CMB and the surface. If r<4e6 then we wish to prescribe
-# a temperature on the bottom surface: since phi=0 at the
-# equator (i.e. x-axis) then the patch is defined by 7pi/16<phi<pi/2.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r, phi
-    set Function constants = pi=3.1415926536
-    set Function expression = if (r>4e6,273,if(phi>7*pi/16,3273,2773))
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1023
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 5
-  set Initial adaptive refinement        = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, vertical heat flux
-    set Output format                 = vtu
-    set Time between graphical output = 10e7
-    set Number of grouped files       = 0
-  end
-end
diff --git a/cookbooks/plume_2D_chunk/strongly_temperature_dependent.prm.bak b/cookbooks/plume_2D_chunk/strongly_temperature_dependent.prm.bak
deleted file mode 100644
index cf2eb62f09c..00000000000
--- a/cookbooks/plume_2D_chunk/strongly_temperature_dependent.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-include ./plume2D.prm
-
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Prefactors for diffusion creep          = 6.26e-23
-    set Activation energies for diffusion creep = 74829.6
-  end
-end
diff --git a/cookbooks/plume_2D_chunk/weakly_temperature_dependent.prm.bak b/cookbooks/plume_2D_chunk/weakly_temperature_dependent.prm.bak
deleted file mode 100644
index 67f974244e9..00000000000
--- a/cookbooks/plume_2D_chunk/weakly_temperature_dependent.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-include ./plume2D.prm
-
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Prefactors for diffusion creep          = 5.05e-24
-    set Activation energies for diffusion creep = 6317.6
-  end
-end
diff --git a/cookbooks/prescribed_velocity/circle.prm.bak b/cookbooks/prescribed_velocity/circle.prm.bak
deleted file mode 100644
index 2de956d989b..00000000000
--- a/cookbooks/prescribed_velocity/circle.prm.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-## First we set up a unit length box model with uniform everything.
-set Dimension   = 2
-set End time    = 0
-set Output directory = output-circle
-
-# Load the signal library.
-set Additional shared libraries = ./libprescribed_velocity.so
-
-## Turn prescribed velocities on
-set Prescribe internal velocities = true
-
-subsection Geometry model
-  set Model name = box
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top, bottom, left, right
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 7
-  set Initial adaptive refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-end
-
-subsection Prescribed velocities
-  subsection Indicator function
-    set Variable names = x,y,t
-
-    # Return where to prescribe u_x; u_y; u_z
-    # (last one only used if dimension = 3)
-    # 1 if velocity should be prescribed, 0 otherwise
-    set Function expression = if((x-.5)^2+(y-.5)^2<.125,1,0); \
-                                if((x-.5)^2+(y-.5)^2<.125,1,0)
-  end
-
-  subsection Velocity function
-    set Variable names = x,y,t
-
-    # Return u_x; u_y; u_z (u_z only used if in 3d)
-    set Function expression = 1;1
-  end
-end
diff --git a/cookbooks/prescribed_velocity/corner_flow.prm.bak b/cookbooks/prescribed_velocity/corner_flow.prm.bak
deleted file mode 100644
index 1ad5cef1405..00000000000
--- a/cookbooks/prescribed_velocity/corner_flow.prm.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-## First we set up a unit length box model with uniform everything.
-set Dimension   = 2
-set End time    = 0
-
-# Load the signal library.
-set Additional shared libraries = ./libprescribed_velocity.so
-set Output directory = output-corner_flow
-
-## Turn prescribed velocities on
-set Prescribe internal velocities = true
-
-subsection Geometry model
-  set Model name = box
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 7
-  set Initial adaptive refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-end
-
-subsection Prescribed velocities
-  subsection Indicator function
-    set Variable names = x,y,t
-
-    # Return where to prescribe u_x; u_y; u_z
-    # (last one only used if dimension = 3)
-    # 1 if velocity should be prescribed, 0 otherwise
-    set Function expression = if(((x>.1)&(x<.9))&(abs(x-(1-y))<.01),1,0); \
-                                if(((x>.1)&(x<.9))&(abs(x-(1-y))<.01),1,0)
-  end
-
-  subsection Velocity function
-    set Variable names = x,y,t
-
-    # Return u_x; u_y; u_z (u_z only used if in 3d)
-    set Function expression = 1;-1
-  end
-end
diff --git a/cookbooks/prescribed_velocity/doc/minimal.prm.bak b/cookbooks/prescribed_velocity/doc/minimal.prm.bak
deleted file mode 100644
index 22583cc03a0..00000000000
--- a/cookbooks/prescribed_velocity/doc/minimal.prm.bak
+++ /dev/null
@@ -1,24 +0,0 @@
-# Load the signal library.
-set Additional shared libraries = ./libprescribed_velocity.so
-
-## Turn prescribed velocities on
-set Prescribe internal velocities = true
-
-subsection Prescribed velocities
-  subsection Indicator function
-    set Variable names = x,y,t
-
-    # Return where to prescribe u_x; u_y; u_z
-    # (last one only used if dimension = 3)
-    # 1 if velocity should be prescribed, 0 otherwise
-    set Function expression = if((x-.5)^2+(y-.5)^2<.125,1,0); \
-                                if((x-.5)^2+(y-.5)^2<.125,1,0)
-  end
-
-  subsection Velocity function
-    set Variable names = x,y,t
-
-    # Return u_x; u_y; u_z (u_z only used if in 3d)
-    set Function expression = 1;-1
-  end
-end
diff --git a/cookbooks/prescribed_velocity/prescribed_velocity.cc.bak b/cookbooks/prescribed_velocity/prescribed_velocity.cc.bak
deleted file mode 100644
index 5f93f95d584..00000000000
--- a/cookbooks/prescribed_velocity/prescribed_velocity.cc.bak
+++ /dev/null
@@ -1,301 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/parsed_function.h>
-#include <deal.II/fe/fe_values.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/parameters.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  // Global variables (to be set by parameters)
-  bool prescribe_internal_velocities;
-
-  // Because we do not initially know what dimension we're in, we need
-  // function parser objects for both 2d and 3d.
-  Functions::ParsedFunction<2> prescribed_velocity_indicator_function_2d (2);
-  Functions::ParsedFunction<3> prescribed_velocity_indicator_function_3d (3);
-  Functions::ParsedFunction<2> prescribed_velocity_function_2d (2);
-  Functions::ParsedFunction<3> prescribed_velocity_function_3d (3);
-
-
-
-  /**
-   * Declare additional parameters.
-   */
-  void declare_parameters(const unsigned int dim,
-                          ParameterHandler &prm)
-  {
-    prm.declare_entry ("Prescribe internal velocities", "false",
-                       Patterns::Bool (),
-                       "Whether or not to use any prescribed internal velocities. "
-                       "Locations in which to prescribe velocities are defined "
-                       "in section ``Prescribed velocities/Indicator function'' "
-                       "and the velocities are defined in section ``Prescribed "
-                       "velocities/Velocity function''. Indicators are evaluated "
-                       "at the center of each cell, and all DOFs associated with "
-                       "the specified velocity component at the indicated cells "
-                       "are constrained."
-                      );
-
-    prm.enter_subsection ("Prescribed velocities");
-    {
-      prm.enter_subsection ("Indicator function");
-      {
-        if (dim == 2)
-          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
-        else
-          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
-      }
-      prm.leave_subsection ();
-
-      prm.enter_subsection ("Velocity function");
-      {
-        if (dim == 2)
-          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
-        else
-          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
-      }
-      prm.leave_subsection ();
-    }
-    prm.leave_subsection ();
-  }
-
-
-
-  template <int dim>
-  void parse_parameters(const Parameters<dim> &,
-                        ParameterHandler &prm)
-  {
-    prescribe_internal_velocities = prm.get_bool ("Prescribe internal velocities");
-    prm.enter_subsection ("Prescribed velocities");
-    {
-      prm.enter_subsection("Indicator function");
-      {
-        try
-          {
-            if (dim == 2)
-              prescribed_velocity_indicator_function_2d.parse_parameters (prm);
-            else
-              prescribed_velocity_indicator_function_3d.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Prescribed velocities.Indicator function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'";
-            throw;
-          }
-      }
-      prm.leave_subsection();
-
-      prm.enter_subsection("Velocity function");
-      {
-        try
-          {
-            if (dim == 2)
-              prescribed_velocity_function_2d.parse_parameters (prm);
-            else
-              prescribed_velocity_function_3d.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Prescribed velocities.Velocity function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'";
-            throw;
-          }
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection ();
-  }
-
-
-
-  /**
-   * A set of helper functions that either return the point passed to it (if
-   * the current dimension is the same) or return a dummy value (otherwise).
-   */
-  namespace
-  {
-    const Point<2> as_2d(const Point<3> &/*p*/)
-    {
-      return Point<2>();
-    }
-
-    const Point<2> &as_2d(const Point<2> &p)
-    {
-      return p;
-    }
-
-    const Point<3> as_3d(const Point<2> &/*p*/)
-    {
-      return Point<3>();
-    }
-
-    const Point<3> &as_3d(const Point<3> &p)
-    {
-      return p;
-    }
-
-  }
-
-
-
-  /**
-   * This function is called by a signal which is triggered after the other constraints
-   * have been calculated. This enables us to define additional constraints in the mass
-   * matrix on any arbitrary degree of freedom in the model space.
-   */
-  template <int dim>
-  void constrain_internal_velocities (const SimulatorAccess<dim> &simulator_access,
-                                      AffineConstraints<double> &current_constraints)
-  {
-    if (prescribe_internal_velocities)
-      {
-        const Parameters<dim> &parameters = simulator_access.get_parameters();
-        const std::vector<Point<dim>> points = aspect::Utilities::get_unit_support_points(simulator_access);
-        const Quadrature<dim> quadrature (points);
-        FEValues<dim> fe_values (simulator_access.get_fe(), quadrature, update_quadrature_points);
-
-        // Loop over all cells
-        for (const auto &cell : simulator_access.get_dof_handler().active_cell_iterators())
-          if (!cell->is_artificial())
-            {
-              fe_values.reinit (cell);
-              std::vector<types::global_dof_index> local_dof_indices(simulator_access.get_fe().dofs_per_cell);
-              cell->get_dof_indices (local_dof_indices);
-
-              for (unsigned int q=0; q<quadrature.size(); q++)
-                // If it's okay to constrain this DOF
-                if (current_constraints.can_store_line(local_dof_indices[q]) &&
-                    !current_constraints.is_constrained(local_dof_indices[q]))
-                  {
-                    // Get the velocity component index
-                    const unsigned int c_idx =
-                      simulator_access.get_fe().system_to_component_index(q).first;
-
-                    // If we're on one of the velocity DOFs
-                    if ((c_idx >=
-                         simulator_access.introspection().component_indices.velocities[0])
-                        &&
-                        (c_idx <=
-                         simulator_access.introspection().component_indices.velocities[dim-1]))
-                      {
-                        // Which velocity component is this DOF associated with?
-                        const unsigned int component_direction
-                          = (c_idx
-                             - simulator_access.introspection().component_indices.velocities[0]);
-
-                        // we get time passed as seconds (always) but may want
-                        // to reinterpret it in years
-                        double time = simulator_access.get_time();
-                        if (simulator_access.convert_output_to_years())
-                          time /= year_in_seconds;
-
-                        prescribed_velocity_indicator_function_2d.set_time (time);
-                        prescribed_velocity_indicator_function_3d.set_time (time);
-                        prescribed_velocity_function_2d.set_time (time);
-                        prescribed_velocity_function_3d.set_time (time);
-
-                        const Point<dim> p = fe_values.quadrature_point(q);
-
-                        // Because we defined and parsed our parameter
-                        // file differently for 2d and 3d we need to
-                        // be sure to query the correct object for
-                        // function values. The function parser
-                        // objects expect points of a certain
-                        // dimension, but Point p will be compiled for
-                        // both 2d and 3d, so we need to do some trickery
-                        // to make this compile.
-                        double indicator, u_i;
-                        if (dim == 2)
-                          {
-                            indicator = prescribed_velocity_indicator_function_2d.value
-                                        (as_2d(p),
-                                         component_direction);
-                            u_i       = prescribed_velocity_function_2d.value
-                                        (as_2d(p),
-                                         component_direction);
-                          }
-                        else
-                          {
-                            indicator = prescribed_velocity_indicator_function_3d.value
-                                        (as_3d(p),
-                                         component_direction);
-                            u_i       = prescribed_velocity_function_3d.value
-                                        (as_3d(p),
-                                         component_direction);
-                          }
-
-                        if (indicator > 0.5)
-                          {
-                            // Add a constraint of the form dof[q] = u_i
-                            // to the list of constraints.
-                            current_constraints.add_line (local_dof_indices[q]);
-                            // When using a defect correction solver, the constraints should only be set on
-                            // nonlinear iteration 0.
-                            if (
-                              (parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::no_Advection_iterated_defect_correction_Stokes &&
-                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::single_Advection_iterated_defect_correction_Stokes &&
-                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::iterated_Advection_and_defect_correction_Stokes &&
-                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::iterated_Advection_and_Newton_Stokes &&
-                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes ) ||
-                              simulator_access.get_nonlinear_iteration() == 0
-                            )
-                              {
-                                current_constraints.set_inhomogeneity (local_dof_indices[q], u_i);
-                              }
-                          }
-                      }
-                  }
-            }
-      }
-  }
-
-  // Connect declare_parameters and parse_parameters to appropriate signals.
-  void parameter_connector ()
-  {
-    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
-    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
-
-    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
-    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
-  }
-
-  // Connect constraints function to correct signal.
-  template <int dim>
-  void signal_connector (SimulatorSignals<dim> &signals)
-  {
-    signals.post_constraints_creation.connect (&constrain_internal_velocities<dim>);
-  }
-
-  // Tell ASPECT to send signals to the connector functions
-  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
-  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
-}
diff --git a/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.0.out.bak b/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.0.out.bak
deleted file mode 100644
index e4b8e68491c..00000000000
--- a/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.0.out.bak
+++ /dev/null
@@ -1,2 +0,0 @@
-# Load the signal library.
-set Additional shared libraries = ./libprescribed_velocity_ascii_data.so
diff --git a/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.1.out.bak b/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.1.out.bak
deleted file mode 100644
index 1c6dc373bfb..00000000000
--- a/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.1.out.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# Turn prescribed velocities on
-set Prescribe internal velocities = true
-
-# Use the Ascii data plugin to read in the prescribed velocity ASCII file
-# In this cookbook, we use the initial composition file.
-subsection Prescribed velocities
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
-    set Data file name       = aspect_name_initial_composition.txt
-  end
-
-  subsection Velocity function
-    set Variable names = x,y,t
-
-    # Return u_x; u_y; u_z (u_z only used if in 3d)
-    set Function expression = 0;0
-  end
-end
diff --git a/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.2.out.bak b/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.2.out.bak
deleted file mode 100644
index f82ce39d5ad..00000000000
--- a/cookbooks/prescribed_velocity_ascii_data/doc/prescribed_velocity_ascii_data.prm.2.out.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
-    set Data file name       = aspect_name_initial_temperature.txt
-  end
-end
diff --git a/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.cc.bak b/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.cc.bak
deleted file mode 100644
index 80feb22cb17..00000000000
--- a/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.cc.bak
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/parsed_function.h>
-#include <deal.II/fe/fe_values.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/initial_composition/ascii_data.h>
-#include <aspect/parameters.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  // Global variables (to be set by parameters)
-  bool prescribe_internal_velocities;
-  bool prescribed_velocity_ascii_file_loaded;
-
-  // Because we do not initially know what dimension we're in, we need
-  // function parser objects for both 2d and 3d.
-
-  aspect::Utilities::AsciiDataBase<2> prescribed_velocity_data_file_2d;
-  aspect::Utilities::AsciiDataBase<3> prescribed_velocity_data_file_3d;
-
-  aspect::Utilities::StructuredDataLookup<2> prescribed_velocity_field_data_2d(1, 1.);
-  aspect::Utilities::StructuredDataLookup<3> prescribed_velocity_field_data_3d(1, 1.);
-
-  Functions::ParsedFunction<2> prescribed_velocity_function_2d (2);
-  Functions::ParsedFunction<3> prescribed_velocity_function_3d (3);
-
-
-
-  /**
-   * Declare additional parameters.
-   */
-  void declare_parameters(const unsigned int dim,
-                          ParameterHandler &prm)
-  {
-    prm.declare_entry ("Prescribe internal velocities", "false",
-                       Patterns::Bool (),
-                       "Whether or not to use any prescribed internal velocities. "
-                       "Locations in which to prescribe velocities are defined "
-                       "in section ``Prescribed velocities/Indicator function'' "
-                       "and the velocities are defined in section ``Prescribed "
-                       "velocities/Velocity function''. Indicators are evaluated "
-                       "at the center of each cell, and all DOFs associated with "
-                       "the specified velocity component at the indicated cells "
-                       "are constrained."
-                      );
-
-    prm.enter_subsection ("Prescribed velocities");
-    {
-      {
-        if (dim == 2)
-          prescribed_velocity_data_file_2d.declare_parameters(prm, "./", "prescribed_velocities.txt", "Ascii data model");
-        else
-          prescribed_velocity_data_file_3d.declare_parameters(prm, "./", "prescribed_velocities.txt", "Ascii data model");
-      }
-
-      prm.enter_subsection ("Velocity function");
-      {
-        if (dim == 2)
-          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
-        else
-          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
-      }
-      prm.leave_subsection ();
-    }
-    prm.leave_subsection ();
-  }
-
-
-
-  template <int dim>
-  void parse_parameters(const Parameters<dim> &,
-                        ParameterHandler &prm)
-  {
-    prescribe_internal_velocities = prm.get_bool ("Prescribe internal velocities");
-    prm.enter_subsection ("Prescribed velocities");
-    {
-      {
-        if (dim == 2)
-          prescribed_velocity_data_file_2d.parse_parameters(prm, "Ascii data model");
-        else
-          prescribed_velocity_data_file_3d.parse_parameters(prm, "Ascii data model");
-      }
-
-      prm.enter_subsection("Velocity function");
-      {
-        try
-          {
-            if (dim == 2)
-              prescribed_velocity_function_2d.parse_parameters (prm);
-            else
-              prescribed_velocity_function_3d.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Prescribed velocities.Velocity function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'";
-            throw;
-          }
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection ();
-
-    prescribed_velocity_ascii_file_loaded = false;
-  }
-
-
-
-  /**
-   * A set of helper functions that either return the point passed to it (if
-   * the current dimension is the same) or return a dummy value (otherwise).
-   */
-  namespace
-  {
-    Point<2> as_2d(const Point<3> &/*p*/)
-    {
-      Assert (false, ExcInternalError());
-      return Point<2>();
-    }
-
-    Point<2> as_2d(const Point<2> &p)
-    {
-      return p;
-    }
-
-    Point<3> as_3d(const Point<2> &/*p*/)
-    {
-      Assert (false, ExcInternalError());
-      return Point<3>();
-    }
-
-    Point<3> as_3d(const Point<3> &p)
-    {
-      return p;
-    }
-
-  }
-
-
-
-  /**
-   * This function is called by a signal which is triggered after the other constraints
-   * have been calculated. This enables us to define additional constraints in the mass
-   * matrix on any arbitrary degree of freedom in the model space.
-   */
-  template <int dim>
-  void constrain_internal_velocities (const SimulatorAccess<dim> &simulator_access,
-                                      AffineConstraints<double> &current_constraints)
-  {
-    if (!prescribed_velocity_ascii_file_loaded)
-      {
-        if (dim == 2)
-          {
-            const std::string filename = prescribed_velocity_data_file_2d.data_directory + prescribed_velocity_data_file_2d.data_file_name;
-            prescribed_velocity_field_data_2d.load_file(filename, simulator_access.get_mpi_communicator());
-
-            std::cout << "Loaded 2D prescribed velocity ascii file" << std::endl;
-          }
-        else
-          {
-            const std::string filename = prescribed_velocity_data_file_3d.data_directory + prescribed_velocity_data_file_3d.data_file_name;
-            prescribed_velocity_field_data_3d.load_file(filename, simulator_access.get_mpi_communicator());
-
-            std::cout << "Loaded 3D prescribed velocity ascii file" << std::endl;
-          }
-        prescribed_velocity_ascii_file_loaded = true;
-      }
-
-    if (prescribe_internal_velocities)
-      {
-        const Parameters<dim> &parameters = simulator_access.get_parameters();
-        const std::vector<Point<dim>> points = aspect::Utilities::get_unit_support_points(simulator_access);
-        const Quadrature<dim> quadrature (points);
-        FEValues<dim> fe_values (simulator_access.get_fe(), quadrature, update_quadrature_points);
-        typename DoFHandler<dim>::active_cell_iterator cell;
-
-        // Loop over all cells
-        for (const auto &cell : simulator_access.get_dof_handler().active_cell_iterators())
-          if (! cell->is_artificial())
-            {
-              fe_values.reinit (cell);
-              std::vector<types::global_dof_index> local_dof_indices(simulator_access.get_fe().dofs_per_cell);
-              cell->get_dof_indices (local_dof_indices);
-
-              // we get time passed as seconds (always) but may want
-              // to reinterpret it in years
-              double time = simulator_access.get_time();
-              if (simulator_access.convert_output_to_years())
-                time /= year_in_seconds;
-
-              prescribed_velocity_function_2d.set_time (time);
-              prescribed_velocity_function_3d.set_time (time);
-
-              for (unsigned int q=0; q<quadrature.size(); ++q)
-                // If it's okay to constrain this DOF
-                if (current_constraints.can_store_line(local_dof_indices[q]) &&
-                    !current_constraints.is_constrained(local_dof_indices[q]))
-                  {
-                    // Get the velocity component index
-                    const unsigned int c_idx =
-                      simulator_access.get_fe().system_to_component_index(q).first;
-
-                    // If we're on one of the velocity DOFs
-                    if ((c_idx >=
-                         simulator_access.introspection().component_indices.velocities[0])
-                        &&
-                        (c_idx <=
-                         simulator_access.introspection().component_indices.velocities[dim-1]))
-                      {
-                        // Which velocity component is this DOF associated with?
-                        const unsigned int component_direction
-                          = (c_idx
-                             - simulator_access.introspection().component_indices.velocities[0]);
-
-                        const Point<dim> p = fe_values.quadrature_point(q);
-
-                        // Because we defined and parsed our parameter
-                        // file differently for 2d and 3d we need to
-                        // be sure to query the correct object for
-                        // function values. The function parser
-                        // objects expect points of a certain
-                        // dimension, but Point p will be compiled for
-                        // both 2d and 3d, so we need to do some trickery
-                        // to make this compile.
-                        double indicator, u_i;
-                        if (dim == 2)
-                          {
-                            indicator = prescribed_velocity_field_data_2d.get_data(as_2d(p),0);
-                            u_i       = prescribed_velocity_function_2d.value
-                                        (as_2d(p),
-                                         component_direction);
-                          }
-                        else
-                          {
-                            indicator = prescribed_velocity_field_data_3d.get_data(as_3d(p),0);
-                            u_i       = prescribed_velocity_function_3d.value
-                                        (as_3d(p),
-                                         component_direction);
-                          }
-
-                        if (indicator > 0.5)
-                          {
-                            // Add a constraint of the form dof[q] = u_i
-                            // to the list of constraints.
-                            current_constraints.add_line (local_dof_indices[q]);
-                            // When using a defect correction solver, the constraints should only be set on
-                            // nonlinear iteration 0.
-                            if (
-                              (parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::no_Advection_iterated_defect_correction_Stokes &&
-                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::single_Advection_iterated_defect_correction_Stokes &&
-                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::iterated_Advection_and_defect_correction_Stokes &&
-                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::iterated_Advection_and_Newton_Stokes &&
-                               parameters.nonlinear_solver!=Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes ) ||
-                              simulator_access.get_nonlinear_iteration() == 0
-                            )
-                              {
-                                current_constraints.set_inhomogeneity (local_dof_indices[q], u_i);
-                              }
-                          }
-                      }
-                  }
-            }
-      }
-  }
-
-  // Connect declare_parameters and parse_parameters to appropriate signals.
-  void parameter_connector ()
-  {
-    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
-    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
-
-    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
-    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
-  }
-
-  // Connect constraints function to correct signal.
-  template <int dim>
-  void signal_connector (SimulatorSignals<dim> &signals)
-  {
-    signals.post_constraints_creation.connect (&constrain_internal_velocities<dim>);
-  }
-
-  // Tell ASPECT to send signals to the connector functions
-  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
-  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
-}
diff --git a/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.prm.bak b/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.prm.bak
deleted file mode 100644
index ee0efe59bc1..00000000000
--- a/cookbooks/prescribed_velocity_ascii_data/prescribed_velocity_ascii_data.prm.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-# Before running this cookbook, you must first compile the shared library
-# (with cmake . && make) and also run the local python file
-# (python make_ascii_files_from_png.py)
-
-
-## First we set the dimension
-set Dimension   = 2
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1500
-set CFL number                             = 1.0
-set End time                               = 1e7
-set Maximum time step                      = 1e5
-set Resume computation                     = false
-set Pressure normalization = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Output directory = output-prescribed_velocity_ascii_data
-
-# Load the signal library.
-set Additional shared libraries = ./libprescribed_velocity_ascii_data.so
-
-# Turn prescribed velocities on
-set Prescribe internal velocities = true
-
-subsection Discretization
-  # The polynomial degree to use for the velocity variables in the Stokes
-  # system. Units: None.
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-
-  # Whether to use a Stokes discretization that is locally conservative at the
-  # expense of a larger number of degrees of freedom (true), or to go with a
-  # cheaper discretization that does not locally conserve mass, although it is
-  # globally conservative (false).
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  # The extents of the box in km is the same as the width
-  # and height of the drawing
-  subsection Box
-    set X extent = 799000
-    set Y extent = 499000
-    set X repetitions = 192
-    set Y repetitions = 120
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# We need one compositional field that will be assigned
-# the values read in from the ascii data plugin.
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
-    set Data file name       = aspect_name_initial_composition.txt
-  end
-end
-
-# Use the Ascii data plugin to read in the prescribed velocity ASCII file
-# In this cookbook, we use the initial composition file.
-subsection Prescribed velocities
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
-    set Data file name       = aspect_name_initial_composition.txt
-  end
-
-  subsection Velocity function
-    set Variable names = x,y,t
-
-    # Return u_x; u_y; u_z (u_z only used if in 3d)
-    set Function expression = 0;0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/cookbooks/prescribed_velocity_ascii_data/
-    set Data file name       = aspect_name_initial_temperature.txt
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top, bottom, left, right
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature = 0.0
-    set Densities = 3300
-    set Specific heats = 2500
-    set Thermal conductivities = 4.7
-    set Thermal expansivities = 6e-5
-    set Viscosities = 1.e19
-    set Viscosity averaging scheme = arithmetic
-  end
-end
-
-# this plugin really doesn't like mesh refinement yet...
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = strain rate, composition, temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = true
-    set Time between graphical output = 1
-    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-  end
-end
diff --git a/cookbooks/shell_3d_postprocess/doc/shell_3d_postprocess.part.prm.bak b/cookbooks/shell_3d_postprocess/doc/shell_3d_postprocess.part.prm.bak
deleted file mode 100644
index f11a192f75a..00000000000
--- a/cookbooks/shell_3d_postprocess/doc/shell_3d_postprocess.part.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = velocity statistics, dynamic topography, visualization, basic statistics, geoid
-
-  subsection Visualization
-    set Output format                 = vtu
-    set List of output variables      = geoid, dynamic topography, density, viscosity, gravity
-    set Number of grouped files       = 1
-  end
-end
diff --git a/cookbooks/shell_3d_postprocess/shell_3d_postprocess.prm.bak b/cookbooks/shell_3d_postprocess/shell_3d_postprocess.prm.bak
deleted file mode 100644
index c7685effbe4..00000000000
--- a/cookbooks/shell_3d_postprocess/shell_3d_postprocess.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# A description of convection in a 3d spherical shell with
-# a prescribed initial condition based on a harmonic
-# perturbation
-
-# Define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 3
-
-# Specify the time you want to let the model run for in
-# years and the output directory. Here we only calculate
-# the instantaneous solution.
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Output directory                       = output-shell_3d_postprocess
-
-# The following variables describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Here we specify the geometry of the domain, which is
-# a spherical shell with inner radius of 3481km and
-# outer radius of 6371km
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6371000
-  end
-end
-
-# This section specifies the temperature at the boundary of
-# the domain. Here we set the temperature to be constant at
-# bottom and top.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom,top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2000
-    set Outer temperature = 1000
-  end
-end
-
-# This section describes the gravity field, which is pointing
-# towards the Earth's center with the same magnitude of 10 m/s^2
-# everywhere
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-# This section prescribes the initial condition in the temperature
-# field, which is chosen as a degree n=4, l=2 perturbation
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Lateral wave number one     = 4
-    set Lateral wave number two     = 2
-    set Magnitude                   = 500
-    set Reference temperature       = 1600
-  end
-end
-
-# The material model is based on the simple material model, which assumes
-# a constant density, and other parameters as stated below.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                 = 3300
-    set Viscosity                         = 1e21
-    set Thermal expansion coefficient     = 3e-5
-    set Reference temperature             = 1600
-    set Thermal conductivity              = 4.125
-    set Reference specific heat           = 1250
-  end
-end
-
-# For this calculation we only do 2 global refinement steps. This resolution
-# is too low to fully resolve the mantle flow, however it does capture
-# the main features.
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 0
-end
-
-# We assume free slip at the inner and outer boundary
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom,top
-end
-
-# We output the density, velocity, dynamic topography and geoid anomalies
-subsection Postprocess
-  set List of postprocessors = velocity statistics, dynamic topography, visualization, basic statistics, geoid
-
-  subsection Visualization
-    set Output format                 = vtu
-    set List of output variables      = geoid, dynamic topography, density, viscosity, gravity
-    set Number of grouped files       = 1
-  end
-end
diff --git a/cookbooks/shell_simple_2d/doc/shearheat.part.prm.bak b/cookbooks/shell_simple_2d/doc/shearheat.part.prm.bak
deleted file mode 100644
index 333f2ea44d1..00000000000
--- a/cookbooks/shell_simple_2d/doc/shearheat.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Heating model
-  set List of model names =
-end
diff --git a/cookbooks/shell_simple_2d/doc/shell.prm.bak b/cookbooks/shell_simple_2d/doc/shell.prm.bak
deleted file mode 100644
index cb189517d7b..00000000000
--- a/cookbooks/shell_simple_2d/doc/shell.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1.5e9
-set Output directory                       = output-shell_simple_2d
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer, left, right
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 5
-  set Initial adaptive refinement        = 4
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, \
-                               heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/cookbooks/shell_simple_2d/shell_simple_2d.prm.bak b/cookbooks/shell_simple_2d/shell_simple_2d.prm.bak
deleted file mode 100644
index bb20fef1fb7..00000000000
--- a/cookbooks/shell_simple_2d/shell_simple_2d.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# A simple setup for convection in a quarter of a 2d shell. See the
-# manual for more information.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1.5e9
-set Output directory                       = output-shell_simple_2d
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average only viscosity
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom
-  set Tangential velocity boundary indicators = top, left, right
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 5
-  set Initial adaptive refinement        = 4
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/cookbooks/shell_simple_2d_smoothing/doc/shell_simple_2d_smoothing.part.prm.bak b/cookbooks/shell_simple_2d_smoothing/doc/shell_simple_2d_smoothing.part.prm.bak
deleted file mode 100644
index db5ffdbc80c..00000000000
--- a/cookbooks/shell_simple_2d_smoothing/doc/shell_simple_2d_smoothing.part.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-subsection Discretization
-  set Temperature polynomial degree = 2
-
-  subsection Stabilization parameters
-    set Use artificial viscosity smoothing = true
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(sqrt(x*x+y*y)<4000000,1,0)
-  end
-end
diff --git a/cookbooks/shell_simple_2d_smoothing/shell_simple_2d_smoothing.prm.bak b/cookbooks/shell_simple_2d_smoothing/shell_simple_2d_smoothing.prm.bak
deleted file mode 100644
index 99903b5d2c4..00000000000
--- a/cookbooks/shell_simple_2d_smoothing/shell_simple_2d_smoothing.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# An extension of the 2d shell simple cookbook that is used to show the
-# benefits of using the artificial viscosity smoothing feature. See the
-# manual for more information.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 1.5e16
-set Output directory                       = output-shell_simple_2d_smoothing
-
-subsection Discretization
-  set Temperature polynomial degree = 2
-
-  subsection Stabilization parameters
-    set Use artificial viscosity smoothing = true
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(sqrt(x*x+y*y)<4000000,1,0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom
-  set Tangential velocity boundary indicators = top, left, right
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 6
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 115
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/cookbooks/shell_simple_3d/doc/amr.part.prm.bak b/cookbooks/shell_simple_3d/doc/amr.part.prm.bak
deleted file mode 100644
index eec6a37b436..00000000000
--- a/cookbooks/shell_simple_3d/doc/amr.part.prm.bak
+++ /dev/null
@@ -1,6 +0,0 @@
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 3
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
diff --git a/cookbooks/shell_simple_3d/doc/checkpoint.part.prm.bak b/cookbooks/shell_simple_3d/doc/checkpoint.part.prm.bak
deleted file mode 100644
index 595a2feeb79..00000000000
--- a/cookbooks/shell_simple_3d/doc/checkpoint.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Checkpointing
-  set Steps between checkpoint = 50
-end
diff --git a/cookbooks/shell_simple_3d/doc/part1.part.prm.bak b/cookbooks/shell_simple_3d/doc/part1.part.prm.bak
deleted file mode 100644
index 18a2f7b7edf..00000000000
--- a/cookbooks/shell_simple_3d/doc/part1.part.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1.5e9
-set Output directory                       = output-shell_simple_3d
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
diff --git a/cookbooks/shell_simple_3d/doc/part2.part.prm.bak b/cookbooks/shell_simple_3d/doc/part2.part.prm.bak
deleted file mode 100644
index 6ab568f2f99..00000000000
--- a/cookbooks/shell_simple_3d/doc/part2.part.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer
-end
diff --git a/cookbooks/shell_simple_3d/doc/part3.part.prm.bak b/cookbooks/shell_simple_3d/doc/part3.part.prm.bak
deleted file mode 100644
index 0a9933ad22e..00000000000
--- a/cookbooks/shell_simple_3d/doc/part3.part.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1973
-    set Outer temperature = 973
-  end
-end
diff --git a/cookbooks/shell_simple_3d/doc/part4.part.prm.bak b/cookbooks/shell_simple_3d/doc/part4.part.prm.bak
deleted file mode 100644
index 3080dc59b3e..00000000000
--- a/cookbooks/shell_simple_3d/doc/part4.part.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1473
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
diff --git a/cookbooks/shell_simple_3d/doc/postprocess.part.prm.bak b/cookbooks/shell_simple_3d/doc/postprocess.part.prm.bak
deleted file mode 100644
index 1538ade53e3..00000000000
--- a/cookbooks/shell_simple_3d/doc/postprocess.part.prm.bak
+++ /dev/null
@@ -1,16 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, \
-                temperature statistics, heat flux statistics, \
-          depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 1
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1.5e6
-    set Output format                 = vtu
-  end
-end
diff --git a/cookbooks/shell_simple_3d/shell_simple_3d.prm.bak b/cookbooks/shell_simple_3d/shell_simple_3d.prm.bak
deleted file mode 100644
index 756c25ce7f3..00000000000
--- a/cookbooks/shell_simple_3d/shell_simple_3d.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-# A simple setup for convection in a 3d shell. See the
-# manual for more information.
-
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1.5e9
-set Output directory                       = output-shell_simple_3d
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1973
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.473e3
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 3
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 1
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1.5e6
-    set Output format                 = vtu
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 50
-end
diff --git a/cookbooks/sinker-with-averaging/doc/conservative.prm.bak b/cookbooks/sinker-with-averaging/doc/conservative.prm.bak
deleted file mode 100644
index be1f44bba29..00000000000
--- a/cookbooks/sinker-with-averaging/doc/conservative.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Discretization
-  set Use locally conservative discretization = true
-end
diff --git a/cookbooks/sinker-with-averaging/doc/full.prm.bak b/cookbooks/sinker-with-averaging/doc/full.prm.bak
deleted file mode 100644
index fbe58455e1b..00000000000
--- a/cookbooks/sinker-with-averaging/doc/full.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output_sinker-with-averaging
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = none
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 6
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
diff --git a/cookbooks/sinker-with-averaging/doc/harmonic.prm.bak b/cookbooks/sinker-with-averaging/doc/harmonic.prm.bak
deleted file mode 100644
index 7cad0231baf..00000000000
--- a/cookbooks/sinker-with-averaging/doc/harmonic.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/cookbooks/sinker-with-averaging/sinker-with-averaging.prm.bak b/cookbooks/sinker-with-averaging/sinker-with-averaging.prm.bak
deleted file mode 100644
index e11a84c2755..00000000000
--- a/cookbooks/sinker-with-averaging/sinker-with-averaging.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output-sinker-with-averaging
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name                        = simple
-  set Material averaging                = none
-
-  subsection Simple model
-    set Reference density               = 1
-    set Viscosity                       = 1
-    set Thermal expansion coefficient   = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 6
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
diff --git a/cookbooks/steinberger/doc/geometry.part.prm.bak b/cookbooks/steinberger/doc/geometry.part.prm.bak
deleted file mode 100644
index 9d29fe02553..00000000000
--- a/cookbooks/steinberger/doc/geometry.part.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-    set Phi periodic = true
-  end
-end
diff --git a/cookbooks/steinberger/doc/lookup.part.prm.bak b/cookbooks/steinberger/doc/lookup.part.prm.bak
deleted file mode 100644
index e8d3aade1b7..00000000000
--- a/cookbooks/steinberger/doc/lookup.part.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-subsection Material model
-  set Model name = Steinberger
-
-  # Parameters controlling the equation of state.
-  subsection Steinberger model
-    set Data directory         = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names    = pyr-ringwood88.txt
-    set Bilinear interpolation = true
-    set Latent heat            = false
-  end
-end
diff --git a/cookbooks/steinberger/doc/nullspace.part.prm.bak b/cookbooks/steinberger/doc/nullspace.part.prm.bak
deleted file mode 100644
index fc64ac917eb..00000000000
--- a/cookbooks/steinberger/doc/nullspace.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
diff --git a/cookbooks/steinberger/doc/projected_density.part.prm.bak b/cookbooks/steinberger/doc/projected_density.part.prm.bak
deleted file mode 100644
index a80f7e617ca..00000000000
--- a/cookbooks/steinberger/doc/projected_density.part.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields  = density_field
-  set Types of fields = density
-  set Compositional field methods = prescribed field
-end
diff --git a/cookbooks/steinberger/doc/rheology.part.prm.bak b/cookbooks/steinberger/doc/rheology.part.prm.bak
deleted file mode 100644
index d01af634ea1..00000000000
--- a/cookbooks/steinberger/doc/rheology.part.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-subsection Material model
-  # Parameters controlling the rheology.
-  subsection Steinberger model
-    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
-    set Radial viscosity file name                    = radial-visc-simple.txt
-    set Use lateral average temperature for viscosity = false
-    set Maximum lateral viscosity variation           = 1e3
-    set Maximum viscosity                             = 5e23
-    set Minimum viscosity                             = 1e20
-  end
-end
diff --git a/cookbooks/steinberger/doc/rheology2.part.prm.bak b/cookbooks/steinberger/doc/rheology2.part.prm.bak
deleted file mode 100644
index ea3ad01b6db..00000000000
--- a/cookbooks/steinberger/doc/rheology2.part.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-subsection Material model
-  subsection Steinberger model
-    set Radial viscosity file name                    = radial-visc-continuous.txt
-  end
-end
diff --git a/cookbooks/steinberger/steinberger.prm.bak b/cookbooks/steinberger/steinberger.prm.bak
deleted file mode 100644
index cdd7266c2c0..00000000000
--- a/cookbooks/steinberger/steinberger.prm.bak
+++ /dev/null
@@ -1,215 +0,0 @@
-# This is a cookbook for a convection model with realistic material properties.
-# Specifically, it uses material properties read in from a look-up table
-# computed with mineral physics software and the projected density approximation.
-# It is a quarter of a spherical shell and uses periodic boundary conditions.
-
-set Dimension                              = 2
-set End time                               = 3e8
-set Adiabatic surface temperature          = 1613.0
-set Output directory                       = output-steinberger
-
-# Because the model is compressible, we use a nonlinear solver.
-# We here choose a tolerance of 1e-3 to limit model runtime, but in a
-# research application one would test what tolerance would be required
-# to obtain a sufficiently accurate solution, and 1e-3 is a quite large
-# value.
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-3
-
-# We run a 2d convection model in a quarter of a spherical shell.
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-    set Phi periodic = true
-  end
-end
-
-# Both the top and bottom boundaries allow for free slip.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom
-end
-
-# Because the model has periodic side boundary conditions and free
-# slip at top and bottom, there is a rotational nullspace. We fix this
-# by setting the net rotation to zero.
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-# We use the gravity model from PREM.
-subsection Gravity model
-  set Model name = ascii data
-end
-
-# The temperature is prescribed at the top and bottom boundaries.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3773
-    set Outer temperature = 273
-  end
-end
-
-# The initial temperature model consists of an adiabatic profile,
-# thermal boundary layers at the surface and the core-mantle boundary,
-# and a small harmonic perturbation to initiate convection.
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Function
-    set Coordinate system   = spherical
-    set Variable names      = r, phi
-    set Function constants  = r0 = 3481000, r1 = 6371000
-    set Function expression = 30 * sin((r-r0)/(r1-r0)*pi)*sin(16*phi) + 20 * sin(2*(r-r0)/(r1-r0)*pi)*sin(12*phi)
-  end
-
-  subsection Adiabatic
-    set Age top boundary layer = 1e8
-    set Age bottom boundary layer = 1e8
-  end
-end
-
-# The model uses the Steinberger material model, which uses a viscosity
-# profile constrained by mineral physics and the geoid, and which can read
-# in material properties from a look-up table.
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    # This data directory contains the files for the viscosity profile,
-    # the lateral viscosity variations due to temperature, and all
-    # material files containing look-up tables computed by mineral physics
-    # software providing density, thermal expansivity and specific heat.
-    set Data directory                                = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
-    set Material file names                           = pyr-ringwood88.txt
-    set Radial viscosity file name                    = radial-visc-simple.txt
-
-    # Because of the resolution in this cookbook we limit the lateral viscosity
-    # variations to three orders of magnitude in both directions (for a total of
-    # six orders of magnitude). We then additionally limit the overall viscosity
-    # between 1e20 Pa s and 5e23 Pa s. This allows the features of the flow field
-    # to be resolved. In the Earth, we would expect higher viscosities in the
-    # lithosphere and lower viscosities in plumes and near the core-mantle boundary.
-    # In addition, this model only accounts for diffusion creep, so the
-    # lithosphere has a high viscosity and forms a stagnant lid on top of the
-    # model. In order to have more realistic subduction in a model like this,
-    # one would have to either prescribe plate velocities at the surface
-    # (forcing plates to subduct) or take into account plastic yielding (so that
-    # the lithosphere can break).
-    set Maximum lateral viscosity variation           = 1e3
-    set Maximum viscosity                             = 5e23
-    set Minimum viscosity                             = 1e20
-
-    # We base our viscosity profile on the adiabat computed based on the
-    # material properties used in the model rather than the laterally
-    # averaged temperature.
-    set Use lateral average temperature for viscosity = false
-
-    # We do not want to include latent heat in our model, mainly because it
-    # can lead to a lot of numerical problems. In a research application, a
-    # model like this should include latent heat. In that case, the formatting
-    # of the look-up table determines if this parameter needs to be set to true
-    # or false. If the look-up table contains the effective thermal expansivity
-    # and specific heat, which includes the effect of phase transformations,
-    # then this parameter still needs to be set to false, because latent heat is
-    # already included automatically when using the properties from the look-up
-    # table. If the look-up table contains thermal expansivity and specific heat
-    # without the effect of phase transitions, then this parameters can be set
-    # to true to compute latent heat effects based on the pressure and
-    # temperature derivatives of the specific enthalpy (using the approach of
-    # Nakagawa et al., 2009).
-    set Latent heat                                   = false
-  end
-end
-
-# Our material model is compressible and includes the temperature gradient
-# caused by adiabatic heating. Consequently, we include both adiabatic heating
-# and shear heating.
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-# Since our model is compressible, the most accurate way to solve the mass
-# conservation equation implemented in ASPECT is to use the 'projected density
-# approximation'. This way, ASPECT will compute the density gradients in the
-# mass conservation directly from the density field (interpolated onto the
-# finite element grid) rather than approximating it with a reference profile
-# or temperature/pressure derivatives of the density. The temperature equation
-# uses the real density (rather than a reference profile) as well.
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
-
-# In order to use the projected density approximation, the model needs a
-# compositional field that the density values can be interpolated on. Here, this
-# field is called 'density_field'. We assign the field the type 'density', so
-# that ASPECT knows that this is the field it should use to compute the density
-# gradient required to solve the equations. ASPECT does not need to solve an
-# equation for this field, it only needs to interpolate the density values onto
-# it. This is covered by the compositional field method 'prescribed field'.
-# For fields of this type, the material model provides the values that should be
-# interpolated onto the field.
-subsection Compositional fields
-  set Number of fields                   = 1
-  set Names of fields                    = density_field
-  set Types of fields                    = density
-  set Compositional field methods        = prescribed field
-end
-
-# We refine the mesh near the boundaries, and where temperature variations are
-# large. In addition, we make sure that in the transition zone, where both the
-# viscosity and the density change a lot, we use the highest refinement level.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.95
-  set Coarsening fraction                = 0.05
-  set Strategy                           = temperature, boundary, minimum refinement function
-  set Time steps between mesh refinement = 5
-
-  subsection Boundary
-    set Boundary refinement indicators = top, bottom
-  end
-
-  subsection Minimum refinement function
-    set Coordinate system   = depth
-    set Variable names      = depth, phi
-    set Function expression = if(depth<700000, 6, 5)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs
-    set Time between graphical output = 1e6
-  end
-end
-
-# This model is compressible and has moderately strong viscosity variations.
-# To make sure the Stokes solver converges, we increase the GMRES solver restart
-# length. This takes more time for each iteration, but the solver usually
-# converges within fewer iterations. We also increase the number of cheap Stokes
-# solver steps because the cheap solver can often already solve the problem, and
-# it is quicker than the expensive solver.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set GMRES solver restart length = 200
-    set Number of cheap Stokes solver steps = 500
-  end
-end
-
-# We also write out checkpoints in case we want to restart the simulation.
-subsection Checkpointing
-  set Steps between checkpoint = 10
-end
diff --git a/cookbooks/stokes/doc/stokeslaw.prm.bak b/cookbooks/stokes/doc/stokeslaw.prm.bak
deleted file mode 100644
index 8b31c9a9958..00000000000
--- a/cookbooks/stokes/doc/stokeslaw.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Output directory                       = output-stokes
-
-############### Parameters describing the model
-# The setup is a 3d box with edge length 2890000 in which
-# all 6 sides have free slip boundary conditions. Because
-# the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2890000
-    set Y extent  = 2890000
-    set Z extent  = 2890000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Viscosity                     = 1e22
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# This, however, is the more important part: We need to describe
-# the compositional field and its influence on the density
-# function. The following blocks say that we want to
-# advect a single compositional field and that we give it an
-# initial value that is zero outside a sphere of radius
-# r=200000m and centered at the point (p,p,p) with
-# p=1445000 (which is half the diameter of the box) and one inside.
-# The last block re-opens the material model and sets the
-# density differential per unit change in compositional field to
-# 100.
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = r=200000,p=1445000
-    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 4
-  set Initial global refinement          = 4
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity
-  end
-end
diff --git a/cookbooks/stokes/stokes.prm.bak b/cookbooks/stokes/stokes.prm.bak
deleted file mode 100644
index 2f441647282..00000000000
--- a/cookbooks/stokes/stokes.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-# A description of the Stokes benchmark for which an analytic solution
-# is available. See the manual for more information.
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Output directory                       = output-stokes
-
-############### Parameters describing the model
-# The setup is a 3d box with edge length 2890000 in which
-# all 6 sides have free slip boundary conditions. Because
-# the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2890000
-    set Y extent  = 2890000
-    set Z extent  = 2890000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Viscosity                     = 1e22
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# This, however, is the more important part: We need to describe
-# the compositional field and its influence on the density
-# function. The following blocks say that we want to
-# advect a single compositional field and that we give it an
-# initial value that is zero outside a sphere of radius
-# r=200000m and centered at the point (p,p,p) with
-# p=1445000 (which is half the diameter of the box) and one inside.
-# The last block re-opens the material model and sets the
-# density differential per unit change in compositional field to
-# 100.
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = r=2e5, p=1.445e6
-    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 4
-  set Initial global refinement          = 4
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity
-  end
-end
diff --git a/cookbooks/subduction_initiation/subduction_initiation.prm.base.bak b/cookbooks/subduction_initiation/subduction_initiation.prm.base.bak
deleted file mode 100644
index dac596f3a7a..00000000000
--- a/cookbooks/subduction_initiation/subduction_initiation.prm.base.bak
+++ /dev/null
@@ -1,51 +0,0 @@
-# Parameter file for replicating Matsumoto & Tomoda 1983
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 50e6
-set Use years in output instead of seconds = true
-set CFL number                             = 0.25
-set Pressure normalization                 = surface
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 400e3
-    set Y extent  = 180e3
-    set X repetitions = 2
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement   = 2
-  set Initial global refinement     = 5
-  set Refinement fraction           = 0.9
-  set Strategy                      = composition
-  set Coarsening fraction           = 0
-end
diff --git a/cookbooks/subduction_initiation/subduction_initiation_compositional_fields.prm.bak b/cookbooks/subduction_initiation/subduction_initiation_compositional_fields.prm.bak
deleted file mode 100644
index c4bd2e3bd3b..00000000000
--- a/cookbooks/subduction_initiation/subduction_initiation_compositional_fields.prm.bak
+++ /dev/null
@@ -1,50 +0,0 @@
-# Parameter file for replicating Matsumoto & Tomoda 1983
-
-include subduction_initiation.prm.base
-
-set Output directory                       = output-subduction-initiation-comp
-
-#materials are:
-# asthenosphere left,
-# asthenosphere right,
-# lithosphere left,
-# lithosphere right,
-# water.
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities = 3200, 3200, 3300, 3300, 1030
-    set Viscosities = 1e21, 1e21, 1e22, 1e22, 1e18
-    set Viscosity averaging scheme = harmonic
-    set Thermal expansivities = 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = L0=300e3, H=180e3
-    set Function expression = if((x>=L0 && y<H-18e3),1,0) ;\
-                              if((x<=L0 && y>H-60e3 && y<=H-10e3),1,0) ;\
-                              if((x>=L0 && y>=H-18e3 && y<=H-8e3),1,0) ;\
-                              if((x<=L0 && y>H-10e3) || (x>=L0 && y>H-8e3),1,0)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics, pressure statistics, material statistics, global statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate
-    set Time between graphical output = 0
-    set Interpolate output = false
-  end
-end
diff --git a/cookbooks/subduction_initiation/subduction_initiation_particle_in_cell.prm.bak b/cookbooks/subduction_initiation/subduction_initiation_particle_in_cell.prm.bak
deleted file mode 100644
index e6abe384d17..00000000000
--- a/cookbooks/subduction_initiation/subduction_initiation_particle_in_cell.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# Parameter file for replicating Matsumoto & Tomoda 1983
-
-include subduction_initiation.prm.base
-
-set Output directory                       = output-subduction-initiation-pic
-
-subsection Material model
-  set Model name = multicomponent
-  set Material averaging = harmonic average
-
-  subsection Multicomponent
-    set Densities = 0, 3200, 3200, 3300, 3300, 1030
-    set Viscosities = 1e30, 1e21, 1e21, 1e22, 1e22, 1e18
-    set Viscosity averaging scheme = harmonic
-    set Thermal expansivities = 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 5
-  set Names of fields = asth_left, asth_right, left_lith, right_lith, water
-  set Compositional field methods = particles, particles, particles, particles, particles
-  set Mapped particle properties = asth_left:initial asth_left, asth_right:initial asth_right, left_lith:initial left_lith, right_lith:initial right_lith, water: initial water
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = L0=300e3
-    set Function expression = if((x<=L0 && y<=120e3),1,0) ;\
-                              if((x>=L0 && y<162e3),1,0) ;\
-                              if((x<=L0 && y>120e3 && y<=170e3),1,0) ;\
-                              if((x>=L0 && y>=162e3 && y<=172e3),1,0) ;\
-                              if((x<=L0 && y>170e3) || (x>=L0 && y>172e3),1,0)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics, pressure statistics, material statistics, global statistics, particles
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate
-    set Time between graphical output = 0
-    set Interpolate output = false
-  end
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format       = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition, velocity
-  set Particle generator name = random uniform
-  set Interpolation scheme = cell average
-  set Update ghost particles = true
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles      = 350000
-    end
-  end
-end
diff --git a/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm.bak b/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
deleted file mode 100644
index 6258c76a5b1..00000000000
--- a/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
+++ /dev/null
@@ -1,303 +0,0 @@
-# This cookbook simulates a kinematically-driven 2D subduction system containing
-# distinct lithologies for the mantle wedge and subducting sediment,
-# mid-ocean ridge basalt (MORB), gabbro, peridotite. Lithologies within the slab
-# are prescribed to an initial hydration state after a period of equilibration, and
-# subsequently dehydrate as they subduct. This cookbook utlizes the existing melt framework
-# within ASPECT which governs the mechanical coupling of a solid and fluid phase (see
-# https://doi.org/10.1093/gji/ggw329) but introduces solid-volatile reactions
-# that are governed by an approximation
-# published by Tian et al., 2019 (https://doi.org/10.1029/2019GC008488).
-# In detail, the model simulates the upper 20 km of a subducting slab with a dip
-# of 45 degrees and a convergence rate of 5 cm/yr. The Cartesian box is rotated
-# such that the x-axis aligns with the slab surface and the y-axis is orthogonal
-# to the slab surface, while gravity is imposed at an angle of 45 degrees. A surface pressure
-# of 1 GPa is imposed to account for the model simulating a portion of the slab
-# that is already subducted. For stability, the slab first subducts for 100 kyr before
-# the hydration is added, and the slab surface temperature diffuses to the mantle over
-# 10 km perpendicular to the slab surface. From the slab surface to the base of the model,
-# the composition is comprised of a 5 km thick layer of sediment with 3 wt% water,
-# below is a 7 km thick layer of MORB with 2 wt% water, and below that is an
-# 8 km thick layer of gabbro with 1 wt% water.
-
-set Adiabatic surface temperature              = 1600
-set Nonlinear solver scheme                    = iterated Advection and Stokes
-
-# We choose a low number of iterations and less restrictive nonlinear solver tolerance
-# for model efficiency. During the initial pulse of dehydration (for 3 time steps),
-# solvers do not quite converge to 1e-4, but achieve the convergence criteria for the
-# rest of the model run time. For a production model, a tolerance of at least 1e-5
-# should be selected. Reaching these tolerances may require on the order of
-# 50-100 nonlinear iterations, and the maximum number of nonlinear iterations
-# will need to be increased accordingly.
-set Max nonlinear iterations                   = 25
-set Nonlinear solver tolerance                 = 1e-4
-set Dimension                                  = 2
-set End time                                   = 2e6
-
-# Set the 'Surface pressure' to 1 GPa to simulate a slab that is at depth.
-set Surface pressure                           = 1e9
-set Maximum time step                          = 1000
-set Use operator splitting                     = true
-set Output directory                           = output_coupled_two_phase_tian_parameterization_kinematic_slab
-
-# Checkpoint the model so that a restart can be done if needed.
-subsection Checkpointing
-  set Steps between checkpoint = 20
-end
-
-subsection Discretization
-  # We choose relatively large values for the stabilization parameters:
-  # However, note that in an application model with a higher resolution,
-  # we would choose much smaller values for the stabilization parameters.
-  subsection Stabilization parameters
-    set beta  = 0.5
-    set cR    = 1
-  end
-end
-
-subsection Solver parameters
-  # Set a stricter linear solver tolerance to ensure convergence
-  subsection Stokes solver parameters
-    set Linear solver tolerance             = 1e-10
-    set Number of cheap Stokes solver steps = 1000
-  end
-end
-
-# Initialize the compositional fields. When using the tian approximation
-# Fluid-solid reaction scheme in the Reactive Fluid Transport material
-# model, the fields 'porosity', 'bound_fluid', 'peridotite', 'gabbro',
-# 'MORB', and 'sediment' are all required compositional fields. This is
-# because they are all treated as special fields by the material model.
-# The 4 lithologies ('sediment', 'MORB', 'gabbro', 'peridotite') are used
-# to determine the equilibrium wt% of water that can be incorporated into
-# the corresponding lithology at the model P-T conditions. Free fluid
-# ('porosity') is then partitioned into/out of the solid depending on the
-# current wt% water within the lithology ('bound_fluid'), and how much 'porosity'
-# is present.
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields = porosity, bound_fluid, peridotite, gabbro, MORB, sediment
-  set Compositional field methods = field, field, field, field, field, field
-end
-
-# Initially, the interior of the model is just the periodite mantle.
-# The composition (4 lithologies, porosity, bound_fluid)
-# evolves through the composition boundary conditions specified below.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0; 0; 1; 0; 0; 0
-  end
-end
-
-# The slab begins at the left most boundary, at first consisting solely of dry
-# lithologic layers. After 100 kyr, the incoming sediment is hydrated
-# (initial_bound_) variablesto 3 wt% water, MORB to 2 wt% water, and gabbro
-# to 1 wt% water.
-subsection Boundary composition model
-  set Fixed composition boundary indicators         = left
-  set List of model names                           = function
-
-  subsection Function
-    set Function constants  = initial_porosity=0, initial_bound_sediment=0.03, initial_bound_MORB=0.02, initial_bound_gabbro=0.01, \
-                              sediment_min=0, sediment_max=5e3, MORB_min=5e3, MORB_max=12e3, gabbro_min=12e3, gabbro_max=20e3, \
-                              onset_time=100e3, slab_thickness=20e3
-    set Function expression = initial_porosity; \
-                              if( t<=onset_time, 0, \
-                                  if( (y<=slab_thickness - sediment_min) & (y>slab_thickness - sediment_max), initial_bound_sediment, \
-                                      if( (y<=slab_thickness - MORB_min) & (y>slab_thickness - MORB_max), initial_bound_MORB, \
-                                          if( (y<=slab_thickness - gabbro_min) & (y>slab_thickness - gabbro_max), initial_bound_gabbro, 0.0) \
-                                        ) \
-                                    ) \
-                                ); \
-                              if(y>slab_thickness, 1, 0); \
-                              if(y<=8e3, 1, 0); \
-                              if(y>8e3 & y<=15e3, 1, 0); \
-                              if(y>15e3 & y<=slab_thickness, 1, 0)
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent      = 100e3
-    set Y extent      = 100e3
-    set Y repetitions = 2
-    set X repetitions = 2
-  end
-end
-
-# Refine the mesh globally from 50 km to 3.125 km resolution through four global refinements.
-# Next, adaptively refine the mesh as a function of the porosity.
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 1
-  set Initial global refinement                = 4
-  set Strategy                                 = composition threshold, minimum refinement function
-  set Time steps between mesh refinement       = 2
-
-  # Minimum of 4 global refinements
-  subsection Minimum refinement function
-    set Function expression = 4
-  end
-
-  # Refine where the porosity is bigger than 1e-6. Other compositions
-  # are set to 1e50 to ensure that we do not refine based on these
-  # compositions.
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-6, 1e50, 1e50, 1e50, 1e50, 1e50
-  end
-end
-
-# Impose a gravity vector at an angle of 45 degrees. This
-# accounts for the fact that the slab is subducting with a dip
-# of 45 degrees and the x-axis of our model aligns parallel to the
-# slab surface.
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = angle=0.7071067811865476
-    set Function expression = 9.81*angle; -9.81*angle
-  end
-end
-
-# Initial temperature is a constant value of 1500 K
-# The temperature field evolves through the imposed boundary conditions
-# outlined below.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function constants  = Tmantle=1500
-    set Function expression = Tmantle
-  end
-end
-
-# Fix the temperature on the left boundary to ensure that
-# the incoming slab is always colder than the mantle. The
-# temperature is unconstrained on other boundaries.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = left
-  set List of model names                     = function
-
-  subsection Function
-    set Coordinate system                     = cartesian
-    set Variable names                        = x,y
-    set Function constants                    = Tmantle=1500, Tslab=600, slab_thickness=20e3
-    set Function expression                   = if(y<=slab_thickness, Tslab - 200*y/slab_thickness, Tmantle)
-  end
-end
-
-subsection Material model
-  set Model name                                        = reactive fluid transport
-  set Material averaging                                = harmonic average only viscosity
-
-  # Use the reactive fluid transport model composited with the visco plastic material model.
-  # We use the tian approximation method for the solid-fluid reactions, and place a maximum
-  # wt% water on the 4 lithologies. We choose fluid properties appropriate for water, and
-  # set the Fluid reaction time scale for operator splitting to be 50 kyr. This parameter
-  # controls the timescales for the dehydration/hydration reactions, and decreasing this value
-  # will tend to make convergence more difficult since fluids will be released from the solid
-  # phase more rapidly, increasing compaction pressure gradients. An important parameter that
-  # can help inform model stability is the compaction length, which is defined as:
-  # sqrt((eta_c + 4/3*eta_s) * k/eta_f)
-  # Where k is the permeability, and eta_c, eta_s, and eta_f are the compaction viscosity,
-  # shear viscosity, and fluid viscosity respectively. Ensuring that the mesh can resolve the
-  # compaction length will aid in convergence. The compaction length for this problem at the
-  # reference permeability (1e-6), the minimum shear viscosity (1e19 Pa s), and a compaction
-  # viscosity of 1e19 Pa s results in a compaction length of ~4.8 km. Our mesh has a maximum
-  # resolution of ~1.6 km^2, meaning that the compaction length scales are adequately resolved.
-  subsection Reactive Fluid Transport Model
-    set Base model                                       = visco plastic
-    set Reference fluid density                          = 1000 # density of water
-    set Shear to bulk viscosity ratio                    = 0.1
-    set Reference fluid viscosity                        = 1
-    set Reference permeability                           = 1e-6
-    set Exponential fluid weakening factor               = 30
-    set Fluid compressibility                            = 0
-    set Fluid reaction time scale for operator splitting = 5e4
-    set Fluid-solid reaction scheme                      = tian approximation
-
-    # We limit the bound water in the gabbro, MORB, and sediment to their initial
-    # values to encourage water to hydrate the overlying mantle. The polynomials defined
-    # in Tian et al., 2019 also reach very large values at low P-T conditions, and so limiting
-    # the weight percent to reasonable values is recommended.
-    set Maximum weight percent water in peridotite       = 2
-    set Maximum weight percent water in gabbro           = 1
-    set Maximum weight percent water in MORB             = 2
-    set Maximum weight percent water in sediment         = 3
-  end
-
-  subsection Visco Plastic
-    # Use the composite flow law to simulate dislocation and diffusion creep
-    # of dry olivine with the parameters from Hirth & Kohlstaedt 2004 (10.1029/138GM06).
-    # This will be inconsistent with the physical state of the model (the solid is hydrated),
-    # but ongoing work will introduce a more self-consistent coupling between the hydration
-    # state and the rheology.
-    set Viscosity averaging scheme                      = harmonic
-    set Viscous flow law                                = composite
-    set Prefactors for diffusion creep                  = 4.5e-15
-    set Stress exponents for diffusion creep            = 1.0
-    set Activation energies for diffusion creep         = 375e3
-    set Activation volumes for diffusion creep          = 8.2e-6
-    set Prefactors for dislocation creep                = 7.4e-15
-    set Stress exponents for dislocation creep          = 3.5
-    set Activation energies for dislocation creep       = 530e3
-    set Activation volumes for dislocation creep        = 14e-6
-    set Angles of internal friction                     = 0
-    set Cohesions                                       = 1e50
-
-    # Limit the minimum and maximum viscosity to four orders of
-    # magnitude to improve solver convergence behavior.
-    set Minimum viscosity                               = 1e19
-    set Maximum viscosity                               = 1e23
-  end
-end
-
-# Define the velocity on all boundaries such that the velocity is 5 cm/yr on the bottom
-# boundary and the left/right boundaries from 0<=y<=20 km (slab). For y>20 km, the velocity
-# linearly decreases from 5 cm/yr to 2 cm/yr, approximating corner flow and the decreasing
-# viscous coupling of the mantle wedge with distance from the slab surface.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left: function, bottom: function, top: function, right: function
-
-  subsection Function
-    set Coordinate system   = cartesian
-    set Function constants  = basal_v = 0.05, top_v = 0.02, slab_depth = 20e3, ymax = 100e3
-    set Variable names      = x, y
-    set Function expression = if(y<=slab_depth, 0.05, 0.05 - (basal_v - top_v) * (y - slab_depth) / (ymax - slab_depth)); 0
-  end
-end
-
-# To fully couple the solid-fluid phases, Include melt transport must be set to true. The reactive
-# fluid transport model and the tian approximation can still be used when Include melt transport is
-# set to false, but this does not fully couple the solid-fluid phases. The uncoupled case is
-# presented in the investigated in the other .prm file in this cookbook.
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-# Output every 50 kyr, and visualize the melt material properties which allows us to look at the
-# compaction viscosities and compaction pressures.
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties, melt fraction
-    set Output format                 = vtu
-    set Time between graphical output = 5e4
-    set Interpolate output            = true
-    set Number of grouped files       = 0
-
-    subsection Melt material properties
-      set List of properties          = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
diff --git a/cookbooks/tian_parameterization_kinematic_slab/uncoupled-two-phase-tian-parameterization-kinematic-slab.prm.bak b/cookbooks/tian_parameterization_kinematic_slab/uncoupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
deleted file mode 100644
index 5cccb864ff4..00000000000
--- a/cookbooks/tian_parameterization_kinematic_slab/uncoupled-two-phase-tian-parameterization-kinematic-slab.prm.bak
+++ /dev/null
@@ -1,36 +0,0 @@
-# This input file creates a model with the same setup as the model generated by
-# coupled-two-phase-tian-parameterization-kinematic-slab.prm, with the only difference
-# being that the solid-fluid reactions in this parameter file are not fully coupled.
-# Instead, the fluid is advected only with the Darcy velocity. See
-# coupled-two-phase-tian-parameterization-kinematic-slab.prm for more details on the model
-# setup.
-
-include $ASPECT_SOURCE_DIR/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm
-
-set Output directory = output_uncoupled_two_phase_tian_parameterization_kinematic_slab
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    # As the system of equations being solved is simpler, the linear solver tolerance can be reduced
-    # to improve efficiency. Note that in production models this value should be tested and decreased
-    # until it no longer has an effect on the model results when using the "iterated Advection and Stokes"
-    set Linear solver tolerance             = 1e-8
-    set Number of cheap Stokes solver steps = 1000
-  end
-end
-
-subsection Compositional fields
-  set Compositional field methods = darcy field, field, field, field, field, field
-end
-
-subsection Melt settings
-  set Include melt transport = false
-end
-
-subsection Postprocess
-  set List of postprocessors     = visualization, composition statistics, velocity statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, thermal expansivity, melt fraction
-  end
-end
diff --git a/cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm.bak b/cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm.bak
deleted file mode 100644
index a8defb6d961..00000000000
--- a/cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm.bak
+++ /dev/null
@@ -1,246 +0,0 @@
-# This cookbook demonstrates how we can set up instantaneous mantle flow models
-# using available geophysical constraints. To avoid large computational cost,
-# this model is a 2D spherical shell with imposed plate boundaries and driven
-# by mantle forces arising from observed mantle heterogeneity.
-# The generated mantle flow field at the surface can be compared with the observed
-# surface deformation and the fit can be used to constrain the physical state
-# of the mantle.
-# We define plate boundaries and cratons using WorldBuilder.
-
-set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/plugins/libtomography_based_plate_motions.release.so
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Output directory                       = 2D-slice-with-faults-cratons
-set World builder file                     = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/world_builder_smac_cratons_faults_2D.json
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Start time                             = 0
-set End time                               = 0
-set Adiabatic surface temperature          = 1573.0
-
-# We use matrix-free solver and geometric multigrid preconditioner
-# to reduce memory consumption.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                         = 1e-4
-    set Stokes solver type                              = block GMG
-    set Number of cheap Stokes solver steps             = 500
-    set GMRES solver restart length                     = 400
-    set Maximum number of expensive Stokes solver steps = 0
-    set Use full A block as preconditioner              = true
-    set Linear solver A block tolerance                 = 1e-2
-  end
-end
-
-# The reference profile uses hydrostatic equations to define adiabatic pressure
-# and temperatures. The difference with existing compute profile plugin is that this
-# plugin uses reference densities from PREM below a certain depth defined by the
-# uppermost mantle thickness parameter to compute the adiabatic conditions.
-subsection Adiabatic conditions model
-  set Model name = reference profile
-
-  subsection Reference profile
-    subsection Ascii data model
-      set Data directory = $ASPECT_SOURCE_DIR/data/1D_reference_profiles/
-      set Data file name = prem.txt
-    end
-  end
-end
-
-# We use the spherical shell geometry using the real Earth radius values.
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6371000
-  end
-end
-
-# We use adaptive refinement to better resolve the plate boundaries and
-# the near-surface heterogeneity
-subsection Mesh refinement
-  set Initial adaptive refinement = 1
-  set Initial global refinement = 4
-  set Strategy = minimum refinement function
-  set Skip solvers on initial refinement = true
-
-  subsection Minimum refinement function
-    set Variable names = depth, y
-    set Function expression = if (depth < 350000, 5, 4)
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields = grain_size, Vp, Vs, vs_anomaly, faults, continents
-  set Compositional field methods = static, static, static, static, static, static
-end
-
-# We use world builder to define the complex geometery of plate boundaries ("faults")
-# and cratons ("continents") in our model.
-subsection Initial composition model
-  set List of model names = ascii data, world builder
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
-    set Data file name = LLNL_model_cropped_cratons_faults.txt.gz
-    set Slice dataset in 2D plane = true
-  end
-
-  subsection World builder
-    set List of relevant compositions = faults, continents
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-# We set the net rotation of the velocities at the surface to zero.
-# This is useful for comparison with the observed GPS velocities in the no
-# net rotation frame.
-subsection Nullspace removal
-  set Remove nullspace = net surface rotation
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3700
-    set Outer temperature = 273
-  end
-end
-
-# We set initial temperatures purely from an ASCII data file.
-# The only reason we also activate the adiabatic boundary plugin is that it
-# allows us to to read a dataset of lithospheric thicknesses that we use to
-# determine reference density, thermal expansivity, and compressibility.
-subsection Initial temperature model
-  set List of model names = ascii data, adiabatic boundary
-  set List of model operators = maximum
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
-    set Data file name = upper_mantle_TM1_2D.txt
-  end
-
-  subsection Adiabatic boundary
-    set Data directory = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
-    set Data file name = LAB_CAM2016_2D.txt
-    set Adiabatic temperature gradient = 0
-    set Isotherm temperature = 274
-    set Surface temperature = 273
-  end
-end
-
-# We do not solve for the temperature field and instead prescribe temperatures
-# in our material model using the initial temperature distribution and
-# temperatures computed from the input tomography data.
-subsection Temperature field
-  set Temperature method = prescribed field
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-# The material model uses diffusion/dislocation creep with prefactors, activation
-# energies and volumes for each major mantle phase chosen to facilitate combined
-# diffusion/dislocation creep in the upper mantle and transition zone, and diffusion
-# creep as the dominant deformation mechanism in the lower mantle.
-subsection Material model
-  set Model name         = tomography based plate motions
-  set Material averaging = harmonic average only viscosity
-
-  subsection Tomography based plate motions model
-    set Average specific grain boundary energy      = 1.0,1.0,1.0,1.0
-    set Use equilibrium grain size                  = false
-    set Minimum viscosity                           = 1e19
-    set Maximum viscosity                           = 1e24
-    set Diffusion activation energy                 = 375000,231000,270000,299000
-    set Diffusion activation volume                 = 6e-6,6e-6,6e-6,2e-6
-    set Diffusion creep exponent                    = 1.0,1.0,1.0,1.0
-    set Diffusion creep grain size exponent         = 3,3,3,3
-    set Diffusion creep prefactor                   = 1.25E-015,6.12E-019,2.94E-017,5.4E-022
-    set Dislocation activation energy               = 530000,530000,530000,530000
-    set Dislocation activation volume               = 1.40E-005,1.70E-005,1.70E-005,0.0
-    set Dislocation creep exponent                  = 3.5,3.5,3.5,3.5
-    set Dislocation creep prefactor                 = 8.33E-015,2.05e-12,2.05e-19,1.e-40 #1e-100, 1e-100, 1e-100, 1e-100
-    set Geometric constant                          = 3,3,3,3
-    set Grain growth activation energy              = 400000,662000,414000,299000
-    set Grain growth activation volume              = 0.0,0.0,0.0,1.5e-6
-    set Grain growth exponent                       = 3,3,4.5,5.0
-    set Grain growth rate constant                  = 1.92e-10,3.02e-4,7.63e-22,5.00E-026
-    set Work fraction for boundary area change      = 0.1,0.1,0.1,0.1
-    set Reference compressibility                   = 4e-12
-    set Reference density                           = 3400
-    set Reference specific heat                     = 1200
-    set Thermal conductivity                        = 4
-    set Thermal expansion coefficient               = 2.0e-5
-    set Maximum temperature dependence of viscosity = 1e6
-    set Phase transition Clapeyron slopes           = 0,0,0
-    set Phase transition depths                     = 410000,520000,660000
-    set Phase transition temperatures               = 1950,1950,1950
-    set Phase transition widths                     = 0,0,0
-    set Reciprocal required strain                  = 10
-    set Recrystallized grain size                   = 0.0,0.0,1e-4
-    set Uppermost mantle thickness                  = 300000
-
-    # The following parameters govern whether we want to scale the laterally
-    # averaged viscosity to a reference profile, and the location of that
-    # profile.
-    set Use depth dependent viscosity               = true
-
-    # This tells us how we want to scale the input Vs anomalies to compute density/temperature
-    # anomalies. By default, the model uses a constant scaling factor, but in this cookbook we use
-    # depth-dependent scaling factors taken from input ascii files.
-    set Use depth dependent density scaling         = true
-    set Use depth dependent temperature scaling     = true
-    set Use faults                                  = true
-    set Use cratons                                 = true
-    set Asthenosphere viscosity                     = 1e20
-    set Fault viscosity                             = 1e19
-
-    subsection Ascii data model
-      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/viscosity_profiles/
-      set Data file name                            = steinberger_source-1.txt
-    end
-
-    subsection Density velocity scaling
-      set Data file name                            = rho_vs_scaling.txt
-    end
-
-    subsection Temperature velocity scaling
-      set Data file name                            = dT_vs_scaling.txt
-    end
-
-    subsection Thermal expansivity profile
-      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
-      set Data file name                            = thermal_expansivity_steinberger_calderwood.txt
-    end
-
-    subsection Crustal depths
-      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
-      set Data file name                            = crustal_structure_2D.txt
-    end
-  end
-end
-
-subsection Formulation
-  set Mass conservation = reference density profile
-end
-
-subsection Postprocess
-  set List of postprocessors         = boundary velocity residual statistics, velocity boundary statistics, visualization, heat flux statistics, depth average
-
-  subsection Visualization
-    set List of output variables     = adiabat, material properties, gravity, nonadiabatic temperature, heat flux map, strain rate, boundary velocity residual, named additional outputs
-    set Output format  = vtu
-  end
-end
diff --git a/cookbooks/tomography_based_plate_motions/doc/tomography_based_plate_motions.part.prm.bak b/cookbooks/tomography_based_plate_motions/doc/tomography_based_plate_motions.part.prm.bak
deleted file mode 100644
index 74f5416bbeb..00000000000
--- a/cookbooks/tomography_based_plate_motions/doc/tomography_based_plate_motions.part.prm.bak
+++ /dev/null
@@ -1,53 +0,0 @@
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields = grain_size, Vp, Vs, vs_anomaly, faults, continents
-  set Compositional field methods = static, static, static, static, static, static
-end
-
-subsection Initial composition model
-  set List of model names = ascii data, world builder
-
-  subsection Ascii data model
-    set Data directory = ../../input_data/
-    set Data file name = LLNL_model_cropped_cratons_faults.txt.gz
-    set Slice dataset in 2D plane = true
-  end
-
-  subsection World builder
-    set List of relevant compositions = faults, continents
-  end
-end
-
-subsection Temperature field
-  set Temperature method = prescribed field
-end
-
-subsection Material model
-  set Model name         = tomography based plate motions
-  set Material averaging = harmonic average only viscosity
-
-  subsection Tomography based plate motions model
-    set Uppermost mantle thickness                  = 300000
-    set Use depth dependent viscosity               = true
-    set Use depth dependent density scaling         = true
-    set Use depth dependent temperature scaling     = true
-    set Use faults                                  = true
-    set Fault viscosity                             = 1e19
-    set Use cratons                                 = true
-    set Craton viscosity                            = 1e25
-    set Asthenosphere viscosity                     = 1e20
-
-    subsection Ascii data model
-      set Data directory                            = ../../input_data/viscosity_profiles/
-      set Data file name                            = steinberger_source-1.txt
-    end
-
-    subsection Density velocity scaling
-      set Data file name                            = rho_vs_scaling.txt
-    end
-
-    subsection Temperature velocity scaling
-      set Data file name                            = dT_vs_scaling.txt
-    end
-  end
-end
diff --git a/cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc.bak b/cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc.bak
deleted file mode 100644
index ee4ef975af3..00000000000
--- a/cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc.bak
+++ /dev/null
@@ -1,457 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include "reference_profile.h"
-#include "tomography_based_plate_motions.h"
-#include <aspect/gravity_model/interface.h>
-#include <aspect/initial_composition/interface.h>
-
-#include <deal.II/base/signaling_nan.h>
-
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    template <int dim>
-    ReferenceProfile<dim>::ReferenceProfile()
-      :
-      initialized(false),
-      surface_condition_function(2)
-    {}
-
-
-
-    template <int dim>
-    void
-    ReferenceProfile<dim>::update()
-    {
-      if (use_surface_condition_function)
-        {
-          initialized = false;
-          surface_condition_function.set_time(this->get_time());
-          initialize();
-        }
-    }
-
-
-    template <int dim>
-    void
-    ReferenceProfile<dim>::initialize()
-    {
-      if (initialized)
-        return;
-
-      reference_profile.initialize(this->get_mpi_communicator());
-      density_index = reference_profile.get_column_index_from_name("density");
-
-      temperatures.resize(n_points, numbers::signaling_nan<double>());
-      pressures.resize(n_points, numbers::signaling_nan<double>());
-      densities.resize(n_points, numbers::signaling_nan<double>());
-
-      delta_z = this->get_geometry_model().maximal_depth() / (n_points-1);
-
-      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
-
-      // Constant properties on the reference profile
-      in.strain_rate.resize(0);
-      in.velocity[0] = Tensor <1,dim> ();
-      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties;
-
-      // Check whether gravity is pointing up / out or down / in. In the normal case it should
-      // point down / in and therefore gravity should be positive, leading to increasing
-      // adiabatic pressures and temperatures with depth. In some cases it will point up / out
-      // (e.g. for backward advection), in which case the pressures and temperatures should
-      // decrease with depth and therefore gravity has to be negative in the following equations.
-      const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(this->get_geometry_model().representative_point(0));
-      const Point<dim> point_surf = this->get_geometry_model().representative_point(0);
-      const Point<dim> point_bot = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
-      const int gravity_direction =  (g * (point_bot - point_surf) >= 0) ?
-                                     1 :
-                                     -1;
-
-      // We want to use different values for the densities in the uppermost vs the lower part of the mantle.
-      double uppermost_mantle_thickness = 0.0;
-      if (Plugins::plugin_type_matches<const MaterialModel::TomographyBasedPlateMotions<dim>>(this->get_material_model()))
-        {
-          const MaterialModel::TomographyBasedPlateMotions<dim> &material_model
-            = Plugins::get_plugin_as_type<const MaterialModel::TomographyBasedPlateMotions<dim>> (this->get_material_model());
-
-          uppermost_mantle_thickness = material_model.get_depth_of_base_of_uppermost_mantle();
-        }
-
-
-      // now integrate downward using the explicit Euler method for simplicity
-      //
-      // note: p'(z) = rho(p,T) * |g|
-      //       T'(z) = alpha |g| T / C_p
-      for (unsigned int i=0; i<n_points; ++i)
-        {
-          // use material properties calculated at i-1
-          // The first column in the input ascii file is the radius from the center of the Earth,
-          // therefore we convert the depths to the radial values in the get_data_component().
-          const double current_depth = double(i)/double(n_points-1)*this->get_geometry_model().maximal_depth();
-          const double outer_radius = this->get_geometry_model().representative_point(0.).norm();
-
-          double density = reference_profile.get_data_component(Point<1>(outer_radius - current_depth),density_index);
-
-          if (i==0)
-            {
-              if (!use_surface_condition_function)
-                {
-                  pressures[0] = this->get_surface_pressure();
-                  temperatures[0] = this->get_adiabatic_surface_temperature();
-                }
-              else
-                {
-                  pressures[0] = surface_condition_function.value(Point<1>(0.0),0);
-                  temperatures[0] = surface_condition_function.value(Point<1>(0.0),1);
-                }
-            }
-          else
-            {
-              // We only want to use the PREM densities in the part of the model that also
-              // uses seismic velocities to determine the densities. Otherwise, use the density
-              // computed by the material model.
-              if (current_depth < uppermost_mantle_thickness)
-                density = out.densities[0];
-
-              const double alpha = out.thermal_expansion_coefficients[0];
-              // Handle the case that cp is zero (happens in simple Stokes test problems like sol_cx). By setting
-              // 1/cp = 0.0 we will have a constant temperature profile with depth.
-              const double one_over_cp = (out.specific_heat[0]>0.0) ? 1.0/out.specific_heat[0] : 0.0;
-              // get the magnitude of gravity. we assume
-              // that gravity always points along the depth direction. this
-              // may not strictly be true always but is likely a good enough
-              // approximation here.
-              const double gravity = gravity_direction * this->get_gravity_model().gravity_vector(in.position[0]).norm();
-
-              pressures[i] = pressures[i-1] + density * gravity * delta_z;
-              temperatures[i] = (this->include_adiabatic_heating())
-                                ?
-                                temperatures[i-1] * (1 + alpha * gravity * delta_z * one_over_cp)
-                                :
-                                temperatures[0];
-            }
-
-          const Point<dim> representative_point = this->get_geometry_model().representative_point (current_depth);
-          const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(representative_point);
-
-          in.position[0] = representative_point;
-          in.temperature[0] = temperatures[i];
-          in.pressure[0] = pressures[i];
-
-          // we approximate the pressure gradient by extrapolating the values
-          // from the two points above
-          if (i>0)
-            in.pressure_gradient[0] = g/(g.norm() != 0.0 ? g.norm() : 1.0)
-                                      * (pressures[i] - pressures[i-1]) / delta_z;
-          else
-            in.pressure_gradient[0] = Tensor <1,dim> ();
-
-          if (reference_composition == initial_composition)
-            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-              in.composition[0][c] = this->get_initial_composition_manager().initial_composition(representative_point, c);
-          else if (reference_composition == reference_function)
-            {
-              const double depth = this->get_geometry_model().depth(representative_point);
-              const Point<1> p(depth);
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                in.composition[0][c] = composition_function->value(p, c);
-            }
-          else
-            AssertThrow(false,ExcNotImplemented());
-
-          densities[i] = density;
-
-          this->get_material_model().evaluate(in, out);
-
-          // Make sure we get the first point of the profile right. We can only assign the correct
-          // value after the material model has been evaluated.
-          if (current_depth < uppermost_mantle_thickness && i==0)
-            densities[i] = out.densities[0];
-        }
-
-      if (gravity_direction == 1 && this->get_surface_pressure() >= 0)
-        {
-          Assert (*std::min_element (pressures.begin(), pressures.end()) >=
-                  -std::numeric_limits<double>::epsilon() * pressures.size(),
-                  ExcMessage("Adiabatic ReferenceProfile encountered a negative pressure of "
-                             + dealii::Utilities::to_string(*std::min_element (pressures.begin(), pressures.end()))));
-        }
-      else if (gravity_direction == -1 && this->get_surface_pressure() <= 0)
-        {
-          Assert (*std::max_element (pressures.begin(), pressures.end()) <=
-                  std::numeric_limits<double>::epsilon() * pressures.size(),
-                  ExcMessage("Adiabatic ReferenceProfile encountered a positive pressure of "
-                             + dealii::Utilities::to_string(*std::max_element (pressures.begin(), pressures.end()))));
-        }
-
-      Assert (*std::min_element (temperatures.begin(), temperatures.end()) >=
-              -std::numeric_limits<double>::epsilon() * temperatures.size(),
-              ExcMessage("Adiabatic ReferenceProfile encountered a negative temperature."));
-
-
-      initialized = true;
-    }
-
-
-
-    template <int dim>
-    bool
-    ReferenceProfile<dim>::is_initialized() const
-    {
-      return initialized;
-    }
-
-
-
-    template <int dim>
-    double ReferenceProfile<dim>::pressure (const Point<dim> &p) const
-    {
-      return get_property(p,pressures);
-    }
-
-
-
-    template <int dim>
-    double ReferenceProfile<dim>::temperature (const Point<dim> &p) const
-    {
-      return get_property(p,temperatures);
-    }
-
-
-
-    template <int dim>
-    double ReferenceProfile<dim>::density (const Point<dim> &p) const
-    {
-      return get_property(p,densities);
-    }
-
-
-
-    template <int dim>
-    double ReferenceProfile<dim>::density_derivative (const Point<dim> &p) const
-    {
-      const double z = this->get_geometry_model().depth(p);
-
-      if (z >= this->get_geometry_model().maximal_depth())
-        {
-          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
-                  ExcInternalError());
-          return (densities.back() - densities[densities.size()-2]) / delta_z;
-        }
-
-      if (z < 0)
-        {
-          Assert (z >= -delta_z, ExcInternalError());
-          return (densities[1] - densities.front()) / delta_z;
-        }
-
-      // if z/delta_z is within [k-eps, k+eps] of a whole number k, round it down to k-1
-      const unsigned int i = static_cast<unsigned int>((z/delta_z) * (1. - 2. * std::numeric_limits<double>::epsilon()));
-      Assert (i < densities.size() - 1, ExcInternalError());
-
-      return (densities[i+1]-densities[i])/delta_z;
-    }
-
-
-
-    template <int dim>
-    double ReferenceProfile<dim>::get_property (const Point<dim> &p,
-                                                const std::vector<double> &property) const
-    {
-      const double z = this->get_geometry_model().depth(p);
-
-      if (z >= this->get_geometry_model().maximal_depth())
-        {
-          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
-                  ExcInternalError());
-          return property.back();
-        }
-
-      if (z <= 0)
-        {
-          Assert (z >= -delta_z, ExcInternalError());
-          return property.front();
-        }
-
-      const double floating_index = z/delta_z;
-      const unsigned int i = static_cast<unsigned int>(floating_index);
-
-      // If p is close to an existing value use that one. This prevents
-      // asking for values at i+1 while initializing i+1 (when p is at the
-      // depth of index i).
-      if (std::abs(floating_index-std::floor(floating_index+0.5)) < 1e-6)
-        return property[i];
-
-      Assert (i+1 < property.size(), ExcInternalError());
-
-      // now do the linear interpolation
-      const double d = floating_index - i;
-      Assert ((d>=0) && (d<=1), ExcInternalError());
-
-      return d*property[i+1] + (1.-d)*property[i];
-    }
-
-
-
-
-    template <int dim>
-    void
-    ReferenceProfile<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        prm.enter_subsection("Reference profile");
-        {
-          Functions::ParsedFunction<1>::declare_parameters (prm, 1);
-          prm.declare_entry("Composition reference profile","initial composition",
-                            Patterns::Selection("initial composition|function"),
-                            "Select how the reference profile for composition "
-                            "is computed. This profile is used to evaluate the "
-                            "material model, when computing the pressure and "
-                            "temperature profile.");
-          prm.declare_entry ("Number of points", "1000",
-                             Patterns::Integer (5),
-                             "The number of points we use to compute the adiabatic "
-                             "profile. The higher the number of points, the more accurate "
-                             "the downward integration from the adiabatic surface "
-                             "temperature will be.");
-          prm.declare_entry ("Use surface condition function", "false",
-                             Patterns::Bool(),
-                             "Whether to use the 'Surface condition function' to determine surface "
-                             "conditions, or the 'Adiabatic surface temperature' and 'Surface pressure' "
-                             "parameters. If this is set to true the reference profile is updated "
-                             "every timestep. The function expression of the function should be "
-                             "independent of space, but can depend on time 't'. The function must "
-                             "return two components, the first one being reference surface pressure, "
-                             "the second one being reference surface temperature.");
-
-          prm.enter_subsection("Surface condition function");
-          {
-            Functions::ParsedFunction<1>::declare_parameters (prm, 2);
-          }
-          prm.leave_subsection();
-
-
-          Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                            "$ASPECT_SOURCE_DIR/tests/adiabatic-conditions/ascii-data/test/",
-                                                            "");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    ReferenceProfile<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        prm.enter_subsection("Reference profile");
-        {
-          const std::string composition_profile = prm.get("Composition reference profile");
-
-          if (composition_profile == "initial composition")
-            reference_composition = initial_composition;
-          else if (composition_profile == "function")
-            reference_composition = reference_function;
-          else
-            AssertThrow(false, ExcNotImplemented());
-
-          if ((this->n_compositional_fields() > 0) && (reference_composition == reference_function))
-            {
-              composition_function
-                = std::make_unique<Functions::ParsedFunction<1>>(this->n_compositional_fields());
-              try
-                {
-                  composition_function->parse_parameters (prm);
-                }
-              catch (...)
-                {
-                  std::cerr << "ERROR: FunctionParser failed to parse\n"
-                            << "\t'Adiabatic conditions model.compute profile'\n"
-                            << "with expression\n"
-                            << "\t'" << prm.get("Function expression") << "'"
-                            << "More information about the cause of the parse error \n"
-                            << "is shown below.\n";
-                  throw;
-                }
-            }
-
-          n_points = prm.get_integer ("Number of points");
-          use_surface_condition_function = prm.get_bool("Use surface condition function");
-          if (use_surface_condition_function)
-            {
-              prm.enter_subsection("Surface condition function");
-              try
-                {
-                  surface_condition_function.parse_parameters (prm);
-                }
-              catch (...)
-                {
-                  std::cerr << "ERROR: FunctionParser failed to parse\n"
-                            << "\t'Adiabatic conditions model.Initial profile.Surface condition function'\n"
-                            << "with expression\n"
-                            << "\t'" << prm.get("Function expression") << "'"
-                            << "More information about the cause of the parse error \n"
-                            << "is shown below.\n";
-                  throw;
-                }
-
-              prm.leave_subsection();
-            }
-
-          reference_profile.parse_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(ReferenceProfile,
-                                               "reference profile",
-                                               "A model in which the adiabatic profile is "
-                                               "calculated by solving the hydrostatic equations for "
-                                               "pressure and temperature in depth. "
-                                               "The gravity is assumed to be in depth direction "
-                                               "and the composition is either given by the initial "
-                                               "composition at reference points or computed "
-                                               "as a reference depth-function. "
-                                               "All material parameters are computed by the "
-                                               "material model plugin. The surface conditions are "
-                                               "either constant or changing over time as prescribed "
-                                               "by a user-provided function.")
-  }
-}
diff --git a/cookbooks/tomography_based_plate_motions/plugins/reference_profile.h.bak b/cookbooks/tomography_based_plate_motions/plugins/reference_profile.h.bak
deleted file mode 100644
index 9208fe70c82..00000000000
--- a/cookbooks/tomography_based_plate_motions/plugins/reference_profile.h.bak
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_cookbooks_tomography_based_plate_motions_reference_profile_h
-#define _aspect_cookbooks_tomography_based_plate_motions_reference_profile_h
-
-
-#include <aspect/adiabatic_conditions/interface.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    using namespace dealii;
-
-    /**
-     * A model similar to the compute profile model
-     * in which the adiabatic profile is
-     * calculated by solving the hydrostatic equations for
-     * pressure and temperature in depth.
-     * The difference is that we use densities from
-     * an input reference profile to be consistent
-     * with the reference seismic profile against which
-     * the tomography model is generated.
-     * In regions where we do not use tomography model,
-     * the reference densities come from the material model.
-     * The gravity is assumed to be in depth direction
-     * and the composition is either given by the initial
-     * composition at reference points or computed
-     * as a reference depth-function.
-     * All material parameters are computed by the
-     * material model plugin. The surface conditions are
-     * either constant or changing over time as prescribed
-     * by an user-provided function.
-     */
-    template <int dim>
-    class ReferenceProfile : public Interface<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        ReferenceProfile ();
-
-        /**
-         * Initialization function. Because this function is called after
-         * initializing the SimulatorAccess, all of the necessary information
-         * is available to calculate the adiabatic profile. It computes the
-         * adiabatic conditions along a vertical transect of the geometry
-         * based on the given material model and other quantities.
-         */
-        void initialize () override;
-
-        /**
-         * Update function. By default does nothing, but if a time-dependent
-         * surface condition function is used, this will reinitialize the
-         * adiabatic profile with the current conditions.
-         */
-        void update () override;
-
-        /**
-         * Some plugins need to know whether the adiabatic conditions are
-         * already calculated. This is for example the case for the simple
-         * compressible material model, which uses the adiabatic temperature
-         * as reference temperature to calculate the density. For the
-         * calculation of the adiabatic conditions this functionality is
-         * simply switched off, because we are always on the reference
-         * profile. This way the plugin behaves differently at initialization
-         * time of the adiabatic conditions and during the main model run.
-         */
-        bool is_initialized() const override;
-
-        /**
-         * Return the adiabatic temperature at a given point of the domain.
-         */
-        double temperature (const Point<dim> &p) const override;
-
-        /**
-         * Return the adiabatic pressure at a given point of the domain.
-         */
-        double pressure (const Point<dim> &p) const override;
-
-        /**
-         * Return the reference density at a given point of the domain.
-         */
-        double density (const Point<dim> &p) const override;
-
-        /**
-         * Return the derivative of the density with respect to depth
-         * at the given point @p p.
-         */
-        double density_derivative (const Point<dim> &p) const override;
-
-        /**
-         * Declare the parameters for the input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * Whether the adiabatic conditions are already calculated. This is
-         * important for plugins that are used by the adiabatic conditions but
-         * also depend on the adiabatic conditions. This way they can behave
-         * differently in initialization and model run.
-         */
-        bool initialized;
-
-        /**
-         * Number of points at which we compute the adiabatic values.
-         */
-        unsigned int n_points;
-
-        /**
-         * Vectors of values of temperatures, pressures and densities on a transect into
-         * depth at which we have computed them. The public member functions
-         * of this class interpolate linearly between these points.
-         */
-        std::vector<double> temperatures;
-        std::vector<double> pressures;
-        std::vector<double> densities;
-
-        /**
-         * Interval spacing between each two data points in the tables above
-         * with regard to the depth coordinate.
-         */
-        double delta_z;
-
-        /**
-         * An enum describing the different options to compute the reference
-         * profile for composition.
-         */
-        enum CompositionProfile
-        {
-          initial_composition,
-          reference_function
-        };
-
-        /**
-         * Selected option to compute the reference profile for composition.
-         */
-        CompositionProfile reference_composition;
-
-        /**
-         * Function object that computes the reference composition profile
-         * if the reference_composition variable is set to function.
-         */
-        std::unique_ptr<Functions::ParsedFunction<1>> composition_function;
-
-        /**
-         * Whether to use the surface_conditions_function to determine surface
-         * conditions, or the adiabatic_surface_temperature and surface_pressure
-         * parameters. If this is set to true the reference profile is updated
-         * every timestep.
-         */
-        bool use_surface_condition_function;
-
-        /**
-         * ParsedFunction: If provided in the inpute file it prescribes
-         * (surface pressure(t), surface temperature(t)).
-         */
-        Functions::ParsedFunction<1> surface_condition_function;
-
-        /**
-         * Internal helper function. Returns the reference property at a
-         * given point of the domain.
-         */
-        double get_property (const Point<dim> &p,
-                             const std::vector<double> &property) const;
-
-
-        /**
-         * A reference profile for density and seismic velocities.
-         */
-        Utilities::AsciiDataProfile<dim> reference_profile;
-
-        /**
-         * The column index of the density column in the reference profile file.
-         */
-        unsigned int density_index;
-    };
-  }
-}
-
-
-#endif
diff --git a/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc.bak b/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc.bak
deleted file mode 100644
index d3c61e9a379..00000000000
--- a/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc.bak
+++ /dev/null
@@ -1,1726 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "tomography_based_plate_motions.h"
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/initial_temperature/adiabatic_boundary.h>
-#include <aspect/simulator_signals.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/signaling_nan.h>
-
-#include <iostream>
-
-using namespace dealii;
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace
-    {
-      /**
-       * Additional output fields for the viscosity prior to scaling to be added to
-       * the MaterialModel::MaterialModelOutputs structure and filled in the
-       * MaterialModel::Interface::evaluate() function.
-       */
-      template <int dim>
-      class UnscaledViscosityAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
-      {
-        public:
-          UnscaledViscosityAdditionalOutputs(const unsigned int n_points)
-            : NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1, "unscaled_viscosity"),
-                                                  n_points)
-          {}
-      };
-
-      /**
-       * Additional output fields for the the material type, describing if we are in the
-       * crust/lithosphere/asthenosphere/lower mantle.
-       */
-      template <int dim>
-      class MaterialTypeAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
-      {
-        public:
-          MaterialTypeAdditionalOutputs(const unsigned int n_points)
-            : NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1, "material_type"),
-                                                  n_points)
-          {}
-      };
-    }
-  }
-
-
-  namespace internal
-  {
-    namespace
-    {
-      template <int dim>
-      class FunctorDepthAverageUnscaledViscosity: public internal::FunctorBase<dim>
-      {
-        public:
-          FunctorDepthAverageUnscaledViscosity()
-          {}
-
-          bool need_material_properties() const override
-          {
-            return true;
-          }
-
-          void
-          create_additional_material_model_outputs (const unsigned int n_points,
-                                                    MaterialModel::MaterialModelOutputs<dim> &outputs) const override
-          {
-            if (outputs.template get_additional_output<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>() == nullptr)
-              {
-                outputs.additional_outputs.push_back(
-                  std::make_unique<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>> (n_points));
-              }
-          }
-
-          void operator()(const MaterialModel::MaterialModelInputs<dim> &,
-                          const MaterialModel::MaterialModelOutputs<dim> &out,
-                          const FEValues<dim> &,
-                          const LinearAlgebra::BlockVector &,
-                          std::vector<double> &output) override
-          {
-            const MaterialModel::UnscaledViscosityAdditionalOutputs<dim> *unscaled_viscosity_outputs
-              = out.template get_additional_output<const MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>();
-
-            Assert(unscaled_viscosity_outputs != nullptr,ExcInternalError());
-
-            for (unsigned int q=0; q<output.size(); ++q)
-              output[q] = unscaled_viscosity_outputs->output_values[0][q];
-          }
-      };
-    }
-  }
-
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    TomographyBasedPlateMotions<dim>::initialize()
-    {
-      // Get reference viscosity profile from the ascii data
-      if (use_depth_dependent_viscosity)
-        reference_viscosity_coordinates = reference_viscosity_profile->get_interpolation_point_coordinates();
-
-      // Get column index for density scaling
-      if (use_depth_dependent_rho_vs)
-        {
-          rho_vs_depth_profile.initialize(this->get_mpi_communicator());
-          density_scaling_index = rho_vs_depth_profile.get_column_index_from_name("density_scaling");
-        }
-
-      if (use_depth_dependent_thermal_expansivity)
-        {
-          thermal_expansivity_profile.initialize(this->get_mpi_communicator());
-          thermal_expansivity_column_index = thermal_expansivity_profile.get_column_index_from_name("thermal_expansivity");
-        }
-
-      if (use_depth_dependent_dT_vs)
-        {
-          dT_vs_depth_profile.initialize(this->get_mpi_communicator());
-          temperature_scaling_index = dT_vs_depth_profile.get_column_index_from_name("temperature_scaling");
-        }
-
-      // Get column for crustal depths
-      std::set<types::boundary_id> surface_boundary_set;
-      surface_boundary_set.insert(this->get_geometry_model().translate_symbolic_boundary_name_to_id("top"));
-      crustal_boundary_depth.initialize(surface_boundary_set, 1);
-
-      // The update() function updates the profile that stores the laterally averaged viscosity.
-      // This is needed to compute the viscosity in the material model (since the viscosities are rescaled
-      // so that the lateral average matches the reference profile). Since the viscosity depends on both
-      // temperature and velocity, we want to update the lateral average profile after each temperature
-      // and Stokes solve.
-      this->get_signals().post_stokes_solver.connect([&](const SimulatorAccess<dim> &,
-                                                         const unsigned int ,
-                                                         const unsigned int ,
-                                                         const SolverControl &,
-                                                         const SolverControl &)
-      {
-        this->update();
-      });
-
-      this->get_signals().post_advection_solver.connect([&](const SimulatorAccess<dim> &,
-                                                            const unsigned int ,
-                                                            const unsigned int ,
-                                                            const SolverControl &)
-      {
-        this->update();
-      });
-
-      n_material_data = material_file_names.size();
-      for (unsigned i = 0; i < n_material_data; i++)
-        {
-          if (material_file_format == perplex)
-            material_lookup.emplace_back(std::make_shared<MaterialUtilities::Lookup::PerplexReader>
-                                         (data_directory+material_file_names[i],
-                                          /*use_bilinear_interpolation*/ true,
-                                          this->get_mpi_communicator()));
-          else if (material_file_format == hefesto)
-            material_lookup.emplace_back(std::make_shared<MaterialUtilities::Lookup::HeFESToReader>
-                                         (data_directory+material_file_names[i],
-                                          data_directory+derivatives_file_names[i],
-                                          /*use_bilinear_interpolation*/ true,
-                                          this->get_mpi_communicator()));
-          else
-            AssertThrow (false, ExcNotImplemented());
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    TomographyBasedPlateMotions<dim>::update()
-    {
-      if (use_depth_dependent_viscosity)
-        {
-          std::vector<std::unique_ptr<internal::FunctorBase<dim>>> lateral_averaging_properties;
-          lateral_averaging_properties.emplace_back(std::make_unique<internal::FunctorDepthAverageUnscaledViscosity<dim>>());
-
-          std::vector<std::vector<double>> averages =
-            this->get_lateral_averaging().compute_lateral_averages(reference_viscosity_coordinates,
-                                                                   lateral_averaging_properties);
-
-          average_viscosity_profile = std::move(averages[0]);
-
-          for (const auto &lateral_viscosity_average: average_viscosity_profile)
-            AssertThrow(numbers::is_finite(lateral_viscosity_average),
-                        ExcMessage("In computing depth averages, there is at"
-                                   " least one depth band that does not have"
-                                   " any quadrature points in it."
-                                   " Consider reducing number of depth layers"
-                                   " for averaging."));
-        }
-    }
-
-
-
-    template <int dim>
-    std::pair<double, unsigned int>
-    TomographyBasedPlateMotions<dim>::get_reference_viscosity (const double depth) const
-    {
-      // Make maximal depth slightly larger to ensure depth < maximal_depth
-      const double maximal_depth = this->get_geometry_model().maximal_depth() *
-                                   (1.0+std::numeric_limits<double>::epsilon());
-      (void) maximal_depth;
-
-      Assert(depth < maximal_depth, ExcInternalError());
-      Assert(depth > -maximal_depth*std::numeric_limits<double>::epsilon(), ExcInternalError());
-
-      unsigned int depth_index;
-      if (depth < reference_viscosity_coordinates.front())
-        {
-          depth_index = 0;
-        }
-      else if (depth > reference_viscosity_coordinates.back())
-        {
-          depth_index = reference_viscosity_coordinates.size() - 1;
-        }
-      else
-        {
-          depth_index = std::distance(reference_viscosity_coordinates.begin(),
-                                      std::lower_bound(reference_viscosity_coordinates.begin(),
-                                                       reference_viscosity_coordinates.end(),
-                                                       depth));
-        }
-      if (depth_index > 0)
-        --depth_index;
-
-      // When evaluating reference viscosity, evaluate at the next lower depth that is stored
-      // in the reference profile instead of the actual depth. This makes the profile piecewise
-      // constant. This will be specific to the viscosity profile used (and ignore the entry with
-      // the largest depth in the profile).
-      double reference_viscosity = reference_viscosity_profile->compute_viscosity(reference_viscosity_coordinates.at(depth_index));
-
-      // By default, ashtenosphere_viscosity is set to the second layer in the reference profile.
-      if (depth_index == 1)
-        reference_viscosity = asthenosphere_viscosity;
-
-      return std::make_pair (reference_viscosity, depth_index);
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::get_depth_of_base_of_uppermost_mantle () const
-    {
-      return depth_to_base_of_uppermost_mantle;
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::compute_viscosity_scaling (const double depth) const
-    {
-      Assert(average_viscosity_profile.size() != 0,
-             ExcMessage("The average viscosity profile has not yet been computed. "
-                        "Unable to scale viscosities"));
-
-      const std::pair<double, unsigned int> reference_viscosity_and_depth_index = get_reference_viscosity (depth);
-
-      const double average_viscosity = std::pow(10, average_viscosity_profile[reference_viscosity_and_depth_index.second]);
-
-      return reference_viscosity_and_depth_index.first / average_viscosity;
-    }
-
-
-
-    template <int dim>
-    void
-    TomographyBasedPlateMotions<dim>::compute_equilibrium_grain_size(const typename Interface<dim>::MaterialModelInputs &in,
-                                                                     typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
-      DislocationViscosityOutputs<dim> *disl_viscosities_out = out.template get_additional_output<DislocationViscosityOutputs<dim>>();
-
-      UnscaledViscosityAdditionalOutputs<dim> *unscaled_viscosity_out =
-        out.template get_additional_output<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>();
-
-      const InitialTemperature::AdiabaticBoundary<dim> &adiabatic_boundary =
-        initial_temperature_manager->template get_matching_initial_temperature_model<InitialTemperature::AdiabaticBoundary<dim>>();
-
-      const unsigned int surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("outer");
-
-      const unsigned int grain_size_index = this->introspection().compositional_index_for_name("grain_size");
-
-      const unsigned int craton_index = (use_cratons)
-                                        ?
-                                        this->introspection().compositional_index_for_name("continents")
-                                        :
-                                        numbers::invalid_unsigned_int;
-
-      unsigned int ridge_index  = numbers::invalid_unsigned_int;
-      unsigned int trench_index = numbers::invalid_unsigned_int;
-      unsigned int fault_index  = numbers::invalid_unsigned_int;
-
-      if (use_faults)
-        {
-          if (use_varying_fault_viscosity)
-            {
-              ridge_index  = this->introspection().compositional_index_for_name("ridges");
-              trench_index = this->introspection().compositional_index_for_name("trenches");
-            }
-          else
-            fault_index  = this->introspection().compositional_index_for_name("faults");
-        }
-
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          const double depth = this->get_geometry_model().depth(in.position[i]);
-
-          // Use the adiabatic pressure instead of the real one, because of oscillations
-          const double pressure = (this->get_adiabatic_conditions().is_initialized())
-                                  ?
-                                  this->get_adiabatic_conditions().pressure(in.position[i])
-                                  :
-                                  in.pressure[i];
-
-          Assert(pressure >= 0.0,
-                 ExcMessage("Pressure has to be non-negative for the viscosity computation. Instead it is: "
-                            + std::to_string(pressure)));
-
-          double lithosphere_thickness = 100.e3;
-          // Get variable lithosphere using an adiabatic boundary ascii file
-          // Only use ascii data boundary file if not using a constant thickness for lithosphere
-          if (this->get_adiabatic_conditions().is_initialized() && !use_constant_lithosphere_thickness)
-            lithosphere_thickness = adiabatic_boundary.get_data_component(surface_boundary_id, in.position[i], 0);
-
-          const unsigned int phase_index = get_phase_index(in.position[i], in.temperature[i], pressure);
-
-          // Computed according to equation (7) in Dannberg et al., 2016, using the paleowattmeter grain size.
-          // Austin and Evans (2007): Paleowattmeters: A scaling relation for dynamically recrystallized grain size. Geology 35, 343-346.
-          const double prefactor = geometric_constant[phase_index] * grain_boundary_energy[phase_index] * grain_growth_rate_constant[phase_index]
-                                   / (boundary_area_change_work_fraction[phase_index] * grain_growth_exponent[phase_index]);
-          const double exponential = std::exp(- (grain_growth_activation_energy[phase_index] + pressure * grain_growth_activation_volume[phase_index])
-                                              / (constants::gas_constant * in.temperature[i]));
-
-          // get the dislocation viscosity to compute the dislocation strain rate
-          // If we do not have the strain rate yet, set it to a low value.
-          // TODO: make minimum strain rate an input parameter
-          const SymmetricTensor<2,dim> shear_strain_rate = in.strain_rate[i] - 1./dim * trace(in.strain_rate[i]) * unit_symmetric_tensor<dim>();
-          const double second_strain_rate_invariant = std::sqrt(std::abs(second_invariant(shear_strain_rate)));
-
-          // TODO: if we update the interface of the diffusion_viscosity and dislocation_viscosity functions,
-          // we don't need this vector anymore
-          std::vector<double> composition (in.composition[i]);
-          double grain_size = in.composition[i][grain_size_index];
-          grain_size = std::max(min_grain_size, grain_size);
-
-          // Only consider dislocation creep and equilibrium grain size if we have a sufficient strain rate
-          if (std::abs(second_strain_rate_invariant > 1e-30))
-            {
-              unsigned int j = 0;
-              double old_grain_size = 0.0;
-
-              // because the diffusion viscosity depends on the grain size itself, and we need it to compute the dislocation strain rate,
-              // we have to iterate in the computation of the equilibrium grain size
-              while ((std::abs((grain_size-old_grain_size) / grain_size) > dislocation_viscosity_iteration_threshold)
-                     && (j < dislocation_viscosity_iteration_number))
-                {
-                  composition[grain_size_index] = std::max(min_grain_size, grain_size);
-                  const double diff_viscosity = diffusion_viscosity(in.temperature[i], pressure, composition, in.strain_rate[i], in.position[i]);
-                  const double disl_viscosity = dislocation_viscosity(in.temperature[i], pressure, composition, in.strain_rate[i], in.position[i], diff_viscosity);
-
-                  if (disl_viscosities_out != nullptr)
-                    {
-                      disl_viscosities_out->diffusion_viscosities[i] = diff_viscosity;
-                      disl_viscosities_out->dislocation_viscosities[i] = std::min(std::max(min_eta,disl_viscosity),1e30);
-                    }
-
-                  out.viscosities[i] = diff_viscosity * disl_viscosity / (disl_viscosity + diff_viscosity);
-
-                  Assert(out.viscosities[i] > 0.0,
-                         ExcMessage("Negative viscosity is not allowed. Current viscosity is: " + std::to_string(out.viscosities[i])));
-
-                  // This follows from Equation (S25 - S30)
-                  const double dislocation_strain_rate_invariant = second_strain_rate_invariant
-                                                                   * out.viscosities[i] / disl_viscosity;
-                  const double stress_term = 4.0 * out.viscosities[i] * second_strain_rate_invariant * dislocation_strain_rate_invariant;
-
-                  old_grain_size = grain_size;
-
-                  if (equilibrate_grain_size)
-                    grain_size = 0.9 * old_grain_size + 0.1 * std::pow(prefactor/stress_term * exponential,1./(1+grain_growth_exponent[phase_index]));
-
-                  ++j;
-                }
-            }
-          else
-            {
-              out.viscosities[i] = diffusion_viscosity(in.temperature[i], pressure, composition, in.strain_rate[i], in.position[i]);
-
-              if (disl_viscosities_out != nullptr)
-                {
-                  disl_viscosities_out->diffusion_viscosities[i] = out.viscosities[i];
-                  disl_viscosities_out->dislocation_viscosities[i] = 1e30;
-                }
-            }
-
-          if (unscaled_viscosity_out != nullptr)
-            unscaled_viscosity_out->output_values[0][i] = std::log10(out.viscosities[i]);
-
-          if (use_depth_dependent_viscosity)
-            {
-              const double viscosity_scaling_below_this_depth = 60e3;
-
-              // Scale viscosity so that laterally averaged viscosity == reference viscosity profile
-              // Only scale if average viscosity is already available and we are below a specified depth.
-              if (average_viscosity_profile.size() != 0 && depth > viscosity_scaling_below_this_depth)
-                out.viscosities[i] *= compute_viscosity_scaling(this->get_geometry_model().depth(in.position[i]));
-            }
-
-          // We assume a constant lithospheric viscosity if using constant thickness lithosphere
-          // based on Tutu et al., (2018).
-          if (use_constant_lithosphere_thickness && depth <= lithosphere_thickness)
-            out.viscosities[i] = 1e24;
-
-          // Ensure we respect viscosity bounds
-          out.viscosities[i] = std::min(std::max(min_eta, out.viscosities[i]),max_eta);
-
-          // This represents the viscosity with respect to which we want to define cratons/faults.
-          const double background_viscosity_log = std::log10(out.viscosities[i]);
-
-          // If using faults, use the composition value to compute the viscosity instead
-          // We extend the faults to depths 40 km more than the lithospheric depths because otherwise
-          // faults do not extend through the lithosphere in our high-resolution models.
-          if (use_faults)
-            {
-              if (use_varying_fault_viscosity)
-                {
-                  if (in.composition[i][ridge_index] > 0. && depth <= lithosphere_thickness + 40e3)
-                    out.viscosities[i] = std::pow(10,
-                                                  std::log10(ridge_viscosity) * in.composition[i][ridge_index]
-                                                  + background_viscosity_log * (1. - in.composition[i][ridge_index]));
-                  if (in.composition[i][trench_index] > 0. && depth <= lithosphere_thickness + 40e3)
-                    out.viscosities[i] = std::pow(10,
-                                                  std::log10(trench_viscosity) * in.composition[i][trench_index]
-                                                  + background_viscosity_log * (1. - in.composition[i][trench_index]));
-                }
-
-              else
-                {
-                  if (in.composition[i][fault_index] > 0. && depth <= lithosphere_thickness + 40e3)
-                    out.viscosities[i] = std::pow(10,
-                                                  std::log10(fault_viscosity) * in.composition[i][fault_index]
-                                                  + background_viscosity_log * (1. - in.composition[i][fault_index]));
-                }
-            }
-
-          // If using cratons, use the composition value to compute the viscosity instead. The cratons in the
-          // compositional field extend until 300 km (Becker 2006, Miller and Becker, 2012), we assume that the
-          // cratonic keels are stiffer than the surrounding lithosphere
-          if (use_cratons && in.composition[i][craton_index] > 0. && depth <= lithosphere_thickness)
-            {
-              out.viscosities[i] = std::pow(10,
-                                            std::log10(craton_viscosity) * in.composition[i][craton_index]
-                                            + background_viscosity_log * (1. - in.composition[i][craton_index]));
-            }
-
-          Assert(out.viscosities[i] > 0,
-                 ExcMessage("Viscosity has to be positive. Instead it is: " + std::to_string(out.viscosities[i])));
-
-          // Fill the prescribed outputs for grain size and assign faults to a prescribed field for diffusion.
-          if (prescribed_field_out != nullptr)
-            for (unsigned int c=0; c<composition.size(); ++c)
-              {
-                if (c == grain_size_index)
-                  prescribed_field_out->prescribed_field_outputs[i][c] = std::max(min_grain_size, grain_size);
-                else if (c == fault_index)
-                  prescribed_field_out->prescribed_field_outputs[i][c] = in.composition[i][fault_index];
-                else
-                  prescribed_field_out->prescribed_field_outputs[i][c] = 0.;
-              }
-
-          if (this->get_nonlinear_iteration() == 0 && use_depth_dependent_viscosity)
-            out.viscosities[i] = get_reference_viscosity(depth).first;
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::
-    phase_function (const Point<dim> &position,
-                    const double temperature,
-                    const double pressure,
-                    const unsigned int phase) const
-    {
-      Assert(phase < transition_depths.size(),
-             ExcMessage("Error: Phase index is too large. This phase index does not exist!"));
-
-      // if we already have the adiabatic conditions, we can use them
-      if (this->get_adiabatic_conditions().is_initialized())
-        {
-          // first, get the pressure at which the phase transition occurs normally
-          const Point<dim,double> transition_point = this->get_geometry_model().representative_point(transition_depths[phase]);
-          const double transition_pressure = this->get_adiabatic_conditions().pressure(transition_point);
-
-          // then calculate the deviation from the transition point (both in temperature
-          // and in pressure)
-          const double pressure_deviation = pressure - transition_pressure
-                                            - transition_slopes[phase] * (temperature - transition_temperatures[phase]);
-
-          // last, calculate the percentage of material that has undergone the transition
-          return (pressure_deviation > 0) ? 1 : 0;
-        }
-
-      // if we do not have the adiabatic conditions, we have to use the depth instead
-      // this is less precise, because we do not have the exact pressure gradient, instead we use pressure/depth
-      // (this is for calculating e.g. the density in the adiabatic profile)
-      else
-        {
-          const double depth = this->get_geometry_model().depth(position);
-          const double depth_deviation = (pressure > 0
-                                          ?
-                                          depth - transition_depths[phase]
-                                          - transition_slopes[phase] * (depth / pressure) * (temperature - transition_temperatures[phase])
-                                          :
-                                          depth - transition_depths[phase]
-                                          - transition_slopes[phase] / (this->get_gravity_model().gravity_vector(position).norm() * reference_rho)
-                                          * (temperature - transition_temperatures[phase]));
-
-          return (depth_deviation > 0) ? 1 : 0;
-        }
-    }
-
-
-
-    template <int dim>
-    unsigned int
-    TomographyBasedPlateMotions<dim>::
-    get_phase_index (const Point<dim> &position,
-                     const double temperature,
-                     const double pressure) const
-    {
-      Assert(grain_growth_activation_energy.size()>0,
-             ExcMessage("Error: No grain evolution parameters are given!"));
-
-      unsigned int phase_index = 0;
-      if (transition_depths.size()>0)
-        if (phase_function(position, temperature, pressure, transition_depths.size()-1) == 1)
-          phase_index = transition_depths.size();
-
-      for (unsigned int j=1; j<transition_depths.size(); ++j)
-        if (phase_function(position, temperature, pressure, j) != phase_function(position, temperature, pressure, j-1))
-          phase_index = j;
-
-      return phase_index;
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::
-    diffusion_viscosity (const double                  temperature,
-                         const double                  pressure,
-                         const std::vector<double>    &composition,
-                         const SymmetricTensor<2,dim> &strain_rate,
-                         const Point<dim>             &position) const
-    {
-      const SymmetricTensor<2,dim> shear_strain_rate = strain_rate - 1./dim * trace(strain_rate) * unit_symmetric_tensor<dim>();
-      const double second_strain_rate_invariant = std::sqrt(std::abs(second_invariant(shear_strain_rate)));
-
-      const double grain_size = composition[this->introspection().compositional_index_for_name("grain_size")];
-
-      // Currently this will never be called without adiabatic_conditions initialized, but just in case
-      const double adiabatic_pressure = this->get_adiabatic_conditions().is_initialized()
-                                        ?
-                                        this->get_adiabatic_conditions().pressure(position)
-                                        :
-                                        pressure;
-
-      // find out in which phase we are
-      const unsigned int phase_index = get_phase_index(position, temperature, adiabatic_pressure);
-
-      Assert(temperature > 0.0,
-             ExcMessage("Temperature has to be positive for diffusion creep. Instead it is: " + std::to_string(temperature)));
-      Assert(pressure >= 0.0,
-             ExcMessage("Adiabatic pressure has to be non-negative for diffusion creep. Instead it is: " + std::to_string(adiabatic_pressure)));
-
-      double energy_term = std::exp((diffusion_activation_energy[phase_index] + diffusion_activation_volume[phase_index] * adiabatic_pressure)
-                                    / (diffusion_creep_exponent[phase_index] * constants::gas_constant * temperature));
-
-      Assert(energy_term > 0.0,
-             ExcMessage("Energy term has to be positive for diffusion creep. Instead it is: " + std::to_string(energy_term)));
-
-      // If the adiabatic profile is already calculated we can use it to limit
-      // variations in viscosity due to temperature.
-      if (this->get_adiabatic_conditions().is_initialized())
-        {
-          const double adiabatic_temperature = this->get_adiabatic_conditions().temperature(position);
-          Assert(adiabatic_temperature > 0.0,
-                 ExcMessage("Adiabatic temperature has to be positive for diffusion creep. Instead it is: " + std::to_string(adiabatic_temperature)));
-
-          const double adiabatic_energy_term
-            = std::exp((diffusion_activation_energy[phase_index] + diffusion_activation_volume[phase_index] * adiabatic_pressure)
-                       / (diffusion_creep_exponent[phase_index] * constants::gas_constant * adiabatic_temperature));
-
-          Assert(adiabatic_energy_term > 0.0,
-                 ExcMessage("Adiabatic energy term has to be positive for diffusion creep. Instead it is: " + std::to_string(adiabatic_energy_term)));
-
-          const double temperature_dependence = energy_term / adiabatic_energy_term;
-          if (temperature_dependence > max_temperature_dependence_of_eta)
-            energy_term = adiabatic_energy_term * max_temperature_dependence_of_eta;
-          if (temperature_dependence < 1.0 / max_temperature_dependence_of_eta)
-            energy_term = adiabatic_energy_term / max_temperature_dependence_of_eta;
-        }
-
-      const double strain_rate_dependence = (1.0 - diffusion_creep_exponent[phase_index]) / diffusion_creep_exponent[phase_index];
-
-      const double diffusion_viscosity = std::pow(diffusion_creep_prefactor[phase_index],-1.0/diffusion_creep_exponent[phase_index])
-                                         * std::pow(second_strain_rate_invariant,strain_rate_dependence)
-                                         * std::pow(grain_size, diffusion_creep_grain_size_exponent[phase_index]/diffusion_creep_exponent[phase_index])
-                                         * energy_term;
-
-      Assert(diffusion_viscosity > 0.0,
-             ExcMessage("Diffusion viscosity has to be positive. Instead it is: " + std::to_string(diffusion_viscosity)));
-
-      return diffusion_viscosity;
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::
-    dislocation_viscosity (const double      temperature,
-                           const double      pressure,
-                           const std::vector<double> &composition,
-                           const SymmetricTensor<2,dim> &strain_rate,
-                           const Point<dim> &position,
-                           const double viscosity_guess) const
-    {
-      const double diff_viscosity = diffusion_viscosity(temperature,pressure,composition,strain_rate,position);
-
-      // If we do not have the strain rate yet, set it to a low value.
-      // TODO: make minimum strain rate an input parameter
-      const SymmetricTensor<2,dim> shear_strain_rate = strain_rate - 1./dim * trace(strain_rate) * unit_symmetric_tensor<dim>();
-      const double second_strain_rate_invariant = std::max(std::sqrt(std::abs(second_invariant(shear_strain_rate))),1e-30);
-
-      // Start the iteration with the full strain rate
-      double dis_viscosity = viscosity_guess;
-      if (viscosity_guess == 0)
-        dis_viscosity = dislocation_viscosity_fixed_strain_rate(temperature,pressure,second_strain_rate_invariant,position);
-
-      double dis_viscosity_old = 0;
-      unsigned int i = 0;
-      while ((std::abs((dis_viscosity-dis_viscosity_old) / dis_viscosity) > dislocation_viscosity_iteration_threshold)
-             && (i < dislocation_viscosity_iteration_number))
-        {
-          const double dislocation_strain_rate = diff_viscosity / (diff_viscosity + dis_viscosity) * second_strain_rate_invariant;
-          dis_viscosity_old = dis_viscosity;
-          dis_viscosity = dislocation_viscosity_fixed_strain_rate(temperature,
-                                                                  pressure,
-                                                                  dislocation_strain_rate,
-                                                                  position);
-
-          Assert(dis_viscosity > 0.0,
-                 ExcMessage("Encountered negative dislocation viscosity in iteration " + std::to_string(i) +
-                            ". Dislocation viscosity is: " + std::to_string(dis_viscosity)));
-          ++i;
-        }
-
-      Assert(i<dislocation_viscosity_iteration_number,ExcInternalError());
-
-      return dis_viscosity;
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::
-    dislocation_viscosity_fixed_strain_rate (const double      temperature,
-                                             const double      pressure,
-                                             const double      second_strain_rate_invariant,
-                                             const Point<dim> &position) const
-    {
-      Assert(temperature > 0.0,
-             ExcMessage("Temperature has to be positive for dislocation creep. Instead it is: " + std::to_string(temperature)));
-      Assert(pressure >= 0.0,
-             ExcMessage("Pressure has to be non-negative for dislocation creep. Instead it is: " + std::to_string(pressure)));
-
-      // find out in which phase we are
-      const unsigned int phase_index = get_phase_index(position, temperature, pressure);
-
-      double energy_term = std::exp((dislocation_activation_energy[phase_index] + dislocation_activation_volume[phase_index] * pressure)
-                                    / (dislocation_creep_exponent[phase_index] * constants::gas_constant * temperature));
-
-      Assert(energy_term > 0.0,
-             ExcMessage("Energy term has to be positive for dislocation creep. Instead it is: " + std::to_string(energy_term)));
-
-      // If we are past the initialization of the adiabatic profile, use it to
-      // limit viscosity variations due to temperature.
-      if (this->get_adiabatic_conditions().is_initialized())
-        {
-          const double adiabatic_energy_term
-            = exp((dislocation_activation_energy[phase_index] + dislocation_activation_volume[phase_index] * pressure)
-                  / (dislocation_creep_exponent[phase_index] * constants::gas_constant * this->get_adiabatic_conditions().temperature(position)));
-
-          Assert(adiabatic_energy_term > 0.0,
-                 ExcMessage("Adiabatic energy term has to be positive for dislocation creep. Instead it is: " + std::to_string(adiabatic_energy_term)));
-
-          const double temperature_dependence = energy_term / adiabatic_energy_term;
-          if (temperature_dependence > max_temperature_dependence_of_eta)
-            energy_term = adiabatic_energy_term * max_temperature_dependence_of_eta;
-          if (temperature_dependence < 1.0 / max_temperature_dependence_of_eta)
-            energy_term = adiabatic_energy_term / max_temperature_dependence_of_eta;
-        }
-
-      const double strain_rate_dependence = (1.0 - dislocation_creep_exponent[phase_index]) / dislocation_creep_exponent[phase_index];
-
-      const double dislocation_viscosity = std::pow(dislocation_creep_prefactor[phase_index],-1.0/dislocation_creep_exponent[phase_index])
-                                           * std::pow(second_strain_rate_invariant,strain_rate_dependence)
-                                           * energy_term;
-
-      Assert(dislocation_viscosity > 0.0,
-             ExcMessage("Dislocation viscosity has to be positive. Instead it is: " + std::to_string(dislocation_viscosity)));
-
-      return dislocation_viscosity;
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::
-    seismic_Vp (const double      temperature,
-                const double      pressure,
-                const std::vector<double> &compositional_fields,
-                const Point<dim> &/*position*/) const
-    {
-      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
-                   ExcMessage("Currently only compressible models are supported."));
-
-      if (n_material_data == 1)
-        return material_lookup[0]->seismic_Vp(temperature,pressure);
-      else
-        {
-          double vp = 0.0;
-          for (unsigned i = 0; i < n_material_data; i++)
-            vp += compositional_fields[i] * material_lookup[i]->seismic_Vp(temperature,pressure);
-          return vp;
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::
-    seismic_Vs (const double      temperature,
-                const double      pressure,
-                const std::vector<double> &compositional_fields,
-                const Point<dim> &/*position*/) const
-    {
-      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
-                   ExcMessage("Currently only compressible models are supported."));
-
-      if (n_material_data == 1)
-        return material_lookup[0]->seismic_Vs(temperature,pressure);
-      else
-        {
-          double vs = 0.0;
-          for (unsigned i = 0; i < n_material_data; i++)
-            vs += compositional_fields[i] * material_lookup[i]->seismic_Vs(temperature,pressure);
-          return vs;
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::
-    density (const double temperature,
-             const double pressure,
-             const std::vector<double> &compositional_fields, /*composition*/
-             const Point<dim> &) const
-    {
-      double rho = 0.0;
-      if (n_material_data == 1)
-        {
-          return material_lookup[0]->density(temperature,pressure);
-        }
-      else
-        {
-          for (unsigned i = 0; i < n_material_data; i++)
-            rho += compositional_fields[i] * material_lookup[i]->density(temperature,pressure);
-          return rho;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    TomographyBasedPlateMotions<dim>::
-    is_compressible () const
-    {
-      return (reference_compressibility != 0)
-             || use_table_properties;
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::
-    compressibility (const double temperature,
-                     const double pressure,
-                     const std::vector<double> &compositional_fields,
-                     const Point<dim> &position) const
-    {
-      double dRhodp = 0.0;
-      if (n_material_data == 1)
-        dRhodp = material_lookup[0]->dRhodp(temperature,pressure);
-      else
-        {
-          for (unsigned i = 0; i < n_material_data; i++)
-            dRhodp += compositional_fields[i] * material_lookup[i]->dRhodp(temperature,pressure);
-        }
-      const double rho = density(temperature,pressure,compositional_fields,position);
-      return (1/rho)*dRhodp;
-    }
-
-
-
-    template <int dim>
-    double
-    TomographyBasedPlateMotions<dim>::
-    thermal_expansivity (const double temperature,
-                         const double pressure,
-                         const std::vector<double> &compositional_fields,
-                         const Point<dim> &) const
-    {
-      if (n_material_data == 1)
-        return material_lookup[0]->thermal_expansivity(temperature,pressure);
-      else
-        {
-          double alpha = 0.0;
-          for (unsigned i = 0; i < n_material_data; i++)
-            alpha += compositional_fields[i] * material_lookup[i]->thermal_expansivity(temperature,pressure);
-          return alpha;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    TomographyBasedPlateMotions<dim>::
-    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      // Determine some properties that are constant for all points
-      const unsigned int vs_anomaly_index = this->introspection().compositional_index_for_name("vs_anomaly");
-      const unsigned int surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("outer");
-
-      const unsigned int craton_index = (use_cratons)
-                                        ?
-                                        this->introspection().compositional_index_for_name("continents")
-                                        :
-                                        numbers::invalid_unsigned_int;
-
-      if (initial_temperature_manager == nullptr)
-        const_cast<std::shared_ptr<const aspect::InitialTemperature::Manager<dim>>&>(initial_temperature_manager)
-          = this->get_initial_temperature_manager_pointer();
-
-      const InitialTemperature::AdiabaticBoundary<dim> &adiabatic_boundary =
-        initial_temperature_manager->template get_matching_initial_temperature_model<InitialTemperature::AdiabaticBoundary<dim>>();
-
-      // This function will fill the outputs for grain size, viscosity, and dislocation viscosity
-      if (in.requests_property(MaterialProperties::viscosity))
-        compute_equilibrium_grain_size(in, out);
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          // Use the adiabatic pressure instead of the real one, because of oscillations
-          const double pressure = (this->get_adiabatic_conditions().is_initialized())
-                                  ?
-                                  this->get_adiabatic_conditions().pressure(in.position[i])
-                                  :
-                                  in.pressure[i];
-
-          out.thermal_conductivities[i] = k_value;
-          out.specific_heat[i] = reference_specific_heat;
-
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-
-          const double depth = this->get_geometry_model().depth(in.position[i]);
-          const double delta_log_vs = in.composition[i][vs_anomaly_index];
-
-          // For computing the adiabatic conditions, we want to use the temperature it hands
-          // over as input. Once the adiabatic conditions are computed, we want to use the
-          // temperature based on seismic tomography and the input temperature model.
-          double new_temperature = in.temperature[i];
-
-          // For the adiabatic conditions, assume a characteristic crustal and lithosphere thickness.
-          double crustal_thickness = 40000.;
-          double lithosphere_thickness = 100000.;
-
-          if (this->get_adiabatic_conditions().is_initialized())
-            {
-              // Get variable lithosphere and crustal depths using an adiabatic boundary ascii file
-              lithosphere_thickness = adiabatic_boundary.get_data_component(surface_boundary_id, in.position[i], 0);
-              crustal_thickness = crustal_boundary_depth.get_data_component(surface_boundary_id, in.position[i], 0);
-
-              if (use_constant_lithosphere_thickness)
-                lithosphere_thickness = 100e3;
-
-              // This variable stores the seismic tomography based temperatures
-              double mantle_temperature;
-
-              // This does not work when it is called before the adiabatic conditions are initialized, because
-              // the AsciiDataBoundary plugin needs the time, which is not yet initialized at that point.
-              const double initial_temperature = initial_temperature_manager->initial_temperature(in.position[i]);
-              const double reference_temperature = this->get_adiabatic_conditions().temperature(in.position[i]);
-
-              if (use_depth_dependent_dT_vs)
-                {
-                  // We use the dlnvs/dT profile from Steinberger and Calderwood (2006). The values in profile are in units 1/K .
-                  mantle_temperature = reference_temperature +
-                                       delta_log_vs * dT_vs_depth_profile.get_data_component(Point<1>(depth), temperature_scaling_index);
-                }
-
-              else
-                {
-                  // compute the temperature below the asthenosphere using the parameters given in the table by Becker (2006).
-                  mantle_temperature = reference_temperature + delta_log_vs * -4.2 * 1785.;
-                }
-
-              const double sigmoid_width = 2.e4;
-              const double sigmoid = 1.0 / (1.0 + std::exp( (depth_to_base_of_uppermost_mantle - depth)/sigmoid_width));
-
-              new_temperature = initial_temperature + (mantle_temperature - initial_temperature) * sigmoid;
-            }
-
-          if (PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>())
-            prescribed_temperature_out->prescribed_temperature_outputs[i] = new_temperature;
-
-          if (use_table_properties)
-            {
-              // fill seismic velocities outputs if they exist
-              if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
-                {
-                  seismic_out->vp[i] = seismic_Vp(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
-                  seismic_out->vs[i] = seismic_Vs(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
-                }
-
-              out.densities[i] = density(new_temperature, pressure, in.composition[i], in.position[i]);
-              out.thermal_expansion_coefficients[i] = thermal_expansivity(new_temperature, pressure, in.composition[i], in.position[i]);
-              out.compressibilities[i] = compressibility(new_temperature, pressure, in.composition[i], in.position[i]);
-            }
-          else
-            {
-              // Temperature and density of the upper part of the mantle are computed separately,
-              // based on Tutu et al. (2018).
-              double deltaT  = new_temperature - 293.;
-
-              unsigned int material_type = 0;
-
-              // Density computation
-              if (depth <= crustal_thickness)
-                {
-                  out.thermal_expansion_coefficients[i] = 2.7e-5;
-                  out.compressibilities[i] = 1./6.3e10;
-                  out.densities[i] = 2.85e3 * (1. - out.thermal_expansion_coefficients[i] * deltaT
-                                               + pressure * out.compressibilities[i]);
-                  material_type = 1;
-                }
-              else if (depth > crustal_thickness && depth <= lithosphere_thickness)
-                {
-                  out.thermal_expansion_coefficients[i] = 3.e-5;
-                  out.compressibilities[i] = 1./12.2e10;
-
-                  // Use adiabatic density increase when using constant lithosphere, Tutu et al., (2018)
-                  if (use_constant_lithosphere_thickness)
-                    deltaT = this->get_adiabatic_conditions().temperature(in.position[i]) - 293;
-
-                  out.densities[i] = 3.27e3 * (1. - out.thermal_expansion_coefficients[i] * deltaT
-                                               + pressure * out.compressibilities[i]);
-                  material_type = 2;
-
-                  if (use_cratons)
-                    {
-                      // Density increase along adiabatic profile
-                      const double craton_density = 3.27e3 * ( 1. - out.thermal_expansion_coefficients[i] *
-                                                               (this->get_adiabatic_conditions().temperature(in.position[i]) - 293)
-                                                               + pressure * out.compressibilities[i]);
-
-                      out.densities[i] = craton_density * in.composition[i][craton_index] +
-                                         out.densities[i] * (1. - in.composition[i][craton_index]);
-                    }
-                }
-              else if (depth > lithosphere_thickness && depth <= depth_to_base_of_uppermost_mantle)
-                {
-                  out.thermal_expansion_coefficients[i] = 3.e-5;
-                  out.compressibilities[i] = 1./12.2e10;
-                  out.densities[i] = 3.3e3 * (1. - out.thermal_expansion_coefficients[i] * deltaT
-                                              + pressure * out.compressibilities[i]);
-                  material_type = 3;
-                }
-              else
-                {
-                  // Densities below 300 km are computed using the scaling relationship from the velocity anomalies
-                  double density_vs_scaling;
-                  if (use_depth_dependent_rho_vs)
-                    density_vs_scaling = rho_vs_depth_profile.get_data_component(Point<1>(depth), density_scaling_index);
-                  else
-                    // Values from Becker (2006), GJI
-                    density_vs_scaling = 0.15;
-
-                  double density_anomaly = delta_log_vs * density_vs_scaling;
-
-                  if (!this->get_adiabatic_conditions().is_initialized())
-                    density_anomaly = 0;
-
-                  // We only want to use the reference densities in the part of the model that also
-                  // uses seismic velocities to determine the densities. Otherwise, use the density
-                  // computed by the material model.
-                  const double reference_density = this->get_adiabatic_conditions().is_initialized()
-                                                   ?
-                                                   this->get_adiabatic_conditions().density(in.position[i])
-                                                   :
-                                                   reference_rho;
-
-                  out.densities[i] = reference_density * (1. + density_anomaly);
-
-                  if (use_depth_dependent_thermal_expansivity)
-                    out.thermal_expansion_coefficients[i] = thermal_expansivity_profile.get_data_component(Point<1>(depth), thermal_expansivity_column_index);
-                  else
-                    out.thermal_expansion_coefficients[i] = thermal_alpha;
-
-                  out.compressibilities[i] = reference_compressibility;
-
-                  material_type = 4;
-                }
-
-              if (MaterialTypeAdditionalOutputs<dim> *material_type_out = out.template get_additional_output<MaterialTypeAdditionalOutputs<dim>>())
-                material_type_out->output_values[0][i] = material_type;
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    TomographyBasedPlateMotions<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Tomography based plate motions model");
-        {
-          prm.declare_entry ("Reference density", "3300",
-                             Patterns::Double (0),
-                             "The reference density $\\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference temperature", "293",
-                             Patterns::Double (0),
-                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250",
-                             Patterns::Double (0),
-                             "The value of the specific heat $cp$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                             Patterns::Double (0),
-                             "The value of the thermal expansion coefficient $\\alpha$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Reference compressibility", "4e-12",
-                             Patterns::Double (0),
-                             "The value of the reference compressibility. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("Phase transition depths", "",
-                             Patterns::List (Patterns::Double(0)),
-                             "A list of depths where phase transitions occur. Values must "
-                             "monotonically increase. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Phase transition temperatures", "",
-                             Patterns::List (Patterns::Double(0)),
-                             "A list of temperatures where phase transitions occur. Higher or lower "
-                             "temperatures lead to phase transition occurring in smaller or greater "
-                             "depths than given in Phase transition depths, depending on the "
-                             "Clapeyron slope given in Phase transition Clapeyron slopes. "
-                             "List must have the same number of entries as Phase transition depths. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Phase transition widths", "",
-                             Patterns::List (Patterns::Double(0)),
-                             "A list of widths for each phase transition. This is only use to specify "
-                             "the region where the recrystallized grain size is assigned after material "
-                             "has crossed a phase transition and should accordingly be chosen similar "
-                             "to the maximum cell width expected at the phase transition."
-                             "List must have the same number of entries as Phase transition depths. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Phase transition Clapeyron slopes", "",
-                             Patterns::List (Patterns::Double()),
-                             "A list of Clapeyron slopes for each phase transition. A positive "
-                             "Clapeyron slope indicates that the phase transition will occur in "
-                             "a greater depth, if the temperature is higher than the one given in "
-                             "Phase transition temperatures and in a smaller depth, if the "
-                             "temperature is smaller than the one given in Phase transition temperatures. "
-                             "For negative slopes the other way round. "
-                             "List must have the same number of entries as Phase transition depths. "
-                             "Units: \\si{\\pascal\\per\\kelvin}.");
-          prm.declare_entry ("Grain growth activation energy", "3.5e5",
-                             Patterns::List (Patterns::Double(0)),
-                             "The activation energy for grain growth $E_g$. "
-                             "Units: \\si{\\joule\\per\\mole}.");
-          prm.declare_entry ("Grain growth activation volume", "8e-6",
-                             Patterns::List (Patterns::Double(0)),
-                             "The activation volume for grain growth $V_g$. "
-                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
-          prm.declare_entry ("Grain growth exponent", "3",
-                             Patterns::List (Patterns::Double(0)),
-                             "The exponent of the grain growth law $p_g$. This is an experimentally determined "
-                             "grain growth constant. "
-                             "Units: none.");
-          prm.declare_entry ("Grain growth rate constant", "1.5e-5",
-                             Patterns::List (Patterns::Double(0)),
-                             "The prefactor for the Ostwald ripening grain growth law $G_0$. "
-                             "This is dependent on water content, which is assumed to be "
-                             "50 H/$10^6$ Si for the default value. "
-                             "Units: \\si{\\meter}$^{p_g}$\\si{\\per\\second}.");
-          prm.declare_entry ("Minimum grain size", "5e-6",
-                             Patterns::Double(0),
-                             "The minimum allowable grain size. The grain size will be limited to be "
-                             "larger than this value. This can be used to damp out oscillations, or "
-                             "to limit the viscosity variation due to grain size. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Reciprocal required strain", "10",
-                             Patterns::List (Patterns::Double(0)),
-                             "This parameter ($\\lambda$) gives an estimate of the strain necessary "
-                             "to achieve a new grain size. ");
-          prm.declare_entry ("Recrystallized grain size", "",
-                             Patterns::List (Patterns::Double(0)),
-                             "The grain size $d_{ph}$ to that a phase will be reduced to when crossing a phase transition. "
-                             "When set to zero, grain size will not be reduced. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Use equilibrium grain size", "true",
-                             Patterns::Bool (),
-                             "A flag indicating whether the computation should use the equilibrium grain size "
-                             "when computing the viscosity (if true), or use a constant grain size instead (if "
-                             "false).");
-          prm.declare_entry ("Average specific grain boundary energy", "1.0",
-                             Patterns::List (Patterns::Double(0)),
-                             "The average specific grain boundary energy $\\gamma$. "
-                             "Units: \\si{\\joule\\per\\meter\\squared}.");
-          prm.declare_entry ("Work fraction for boundary area change", "0.1",
-                             Patterns::List (Patterns::Double(0)),
-                             "The fraction $\\chi$ of work done by dislocation creep to change the grain boundary area. "
-                             "Units: \\si{\\joule\\per\\meter\\squared}.");
-          prm.declare_entry ("Geometric constant", "3",
-                             Patterns::List (Patterns::Double(0)),
-                             "The geometric constant $c$ used in the paleowattmeter grain size reduction law. "
-                             "Units: none.");
-          prm.declare_entry ("Dislocation viscosity iteration threshold", "1e-3",
-                             Patterns::Double(0),
-                             "We need to perform an iteration inside the computation "
-                             "of the dislocation viscosity, because it depends on the "
-                             "dislocation strain rate, which depends on the dislocation "
-                             "viscosity itself. This number determines the termination "
-                             "accuracy, i.e. if the dislocation viscosity changes by less "
-                             "than this factor we terminate the iteration.");
-          prm.declare_entry ("Dislocation viscosity iteration number", "100",
-                             Patterns::Integer(0),
-                             "We need to perform an iteration inside the computation "
-                             "of the dislocation viscosity, because it depends on the "
-                             "dislocation strain rate, which depends on the dislocation "
-                             "viscosity itself. This number determines the maximum "
-                             "number of iterations that are performed. ");
-          prm.declare_entry ("Dislocation creep exponent", "3.5",
-                             Patterns::List (Patterns::Double(0)),
-                             "The power-law exponent $n_{dis}$ for dislocation creep. "
-                             "Units: none.");
-          prm.declare_entry ("Dislocation activation energy", "4.8e5",
-                             Patterns::List (Patterns::Double(0)),
-                             "The activation energy for dislocation creep $E_{dis}$. "
-                             "Units: \\si{\\joule\\per\\mole}.");
-          prm.declare_entry ("Dislocation activation volume", "1.1e-5",
-                             Patterns::List (Patterns::Double(0)),
-                             "The activation volume for dislocation creep $V_{dis}$. "
-                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
-          prm.declare_entry ("Dislocation creep prefactor", "4.5e-15",
-                             Patterns::List (Patterns::Double(0)),
-                             "The prefactor for the dislocation creep law $A_{dis}$. "
-                             "Units: \\si{\\pascal}$^{-n_{dis}}$\\si{\\per\\second}.");
-          prm.declare_entry ("Diffusion creep exponent", "1",
-                             Patterns::List (Patterns::Double(0)),
-                             "The power-law exponent $n_{diff}$ for diffusion creep. "
-                             "Units: none.");
-          prm.declare_entry ("Diffusion activation energy", "3.35e5",
-                             Patterns::List (Patterns::Double(0)),
-                             "The activation energy for diffusion creep $E_{diff}$. "
-                             "Units: \\si{\\joule\\per\\mole}.");
-          prm.declare_entry ("Diffusion activation volume", "4e-6",
-                             Patterns::List (Patterns::Double(0)),
-                             "The activation volume for diffusion creep $V_{diff}$. "
-                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
-          prm.declare_entry ("Diffusion creep prefactor", "7.4e-15",
-                             Patterns::List (Patterns::Double(0)),
-                             "The prefactor for the diffusion creep law $A_{diff}$. "
-                             "Units: \\si{\\meter}$^{p_{diff}}$\\si{\\pascal}$^{-n_{diff}}$\\si{\\per\\second}.");
-          prm.declare_entry ("Diffusion creep grain size exponent", "3",
-                             Patterns::List (Patterns::Double(0)),
-                             "The diffusion creep grain size exponent $p_{diff}$ that determines the "
-                             "dependence of viscosity on grain size. "
-                             "Units: none.");
-          prm.declare_entry ("Maximum temperature dependence of viscosity", "100",
-                             Patterns::Double (1.0),
-                             "The factor by which viscosity at adiabatic temperature and ambient temperature "
-                             "are allowed to differ (a value of x means that the viscosity can be x times higher "
-                             "or x times lower compared to the value at adiabatic temperature. This parameter "
-                             "is introduced to limit local viscosity contrasts, but still allow for a widely "
-                             "varying viscosity over the whole mantle range. "
-                             "Units: none.");
-          prm.declare_entry ("Minimum viscosity", "1e18",
-                             Patterns::Double (0),
-                             "The minimum viscosity that is allowed in the whole model domain. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Maximum viscosity", "1e26",
-                             Patterns::Double (0),
-                             "The maximum viscosity that is allowed in the whole model domain. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/steinberger/",
-                             Patterns::DirectoryName (),
-                             "The path to the model data. The path may also include the special "
-                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                             "in which the ASPECT source files were located when ASPECT was "
-                             "compiled. This interpretation allows, for example, to reference "
-                             "files located in the 'data/' subdirectory of ASPECT. ");
-          prm.declare_entry ("Material file names", "pyr-ringwood88.txt",
-                             Patterns::List (Patterns::Anything()),
-                             "The file names of the material data. "
-                             "List with as many components as active "
-                             "compositional fields (material data is assumed to "
-                             "be in order with the ordering of the fields). ");
-          prm.declare_entry ("Derivatives file names", "",
-                             Patterns::List (Patterns::Anything()),
-                             "The file names of the enthalpy derivatives data. "
-                             "List with as many components as active "
-                             "compositional fields (material data is assumed to "
-                             "be in order with the ordering of the fields). ");
-          prm.declare_entry ("Use table properties", "false",
-                             Patterns::Bool(),
-                             "This parameter determines whether to use the table properties "
-                             "also for density, thermal expansivity and specific heat. "
-                             "If false the properties are generated as in the "
-                             "simple compressible plugin.");
-          prm.declare_entry ("Material file format", "perplex",
-                             Patterns::Selection ("perplex|hefesto"),
-                             "The material file format to be read in the property "
-                             "tables.");
-          prm.declare_entry ("Use depth dependent viscosity", "false",
-                             Patterns::Bool (),
-                             "This parameter value determines if we want to use the layered depth dependent "
-                             "rheology, which is input as an ascii data file.");
-          prm.declare_entry ("Use faults", "false",
-                             Patterns::Bool (),
-                             "This parameter value determines if we want to use the faults/plate boundaries as "
-                             "a composition field, currently input as a world builder file.");
-          prm.declare_entry ("Fault viscosity", "1e20",
-                             Patterns::Double(0),
-                             "This parameter value determines the viscosity of faults or plate boundaries. "
-                             "We would want to have weak faults/plate boundaries relative to the surrounding "
-                             "lithosphere. "
-                             "Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Asthenosphere viscosity", "2.4e20",
-                             Patterns::Double(0),
-                             "This parameter value determines the asthenosphere layer in the reference file. "
-                             "Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Use cratons", "false",
-                             Patterns::Bool (),
-                             "This parameter value determines if we want to use cratons as viscous and neutrally "
-                             "buoyant composition field, currently input as a world builder file.");
-          prm.declare_entry ("Craton viscosity", "1e25",
-                             Patterns::Double(0),
-                             "This parameter value determines the viscosity of cratons. We would want to have "
-                             "strong cratons relative to the surrounding lithosphere."
-                             "Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Use depth dependent density scaling", "false",
-                             Patterns::Bool (),
-                             "This parameter value determines if we want to use depth-dependent scaling files "
-                             "for computing the density from seismic velocities (if true) or use a constant "
-                             "value (if false).");
-          prm.declare_entry ("Use thermal expansivity profile", "true",
-                             Patterns::Bool (),
-                             "This parameter determines if we use a depth-dependent thermal expansivity read "
-                             "from a data file (if true), or if we use the constant reference value given by "
-                             "the 'Thermal expansion coefficient' (if false). In the case that material "
-                             "properties are read from a look-up table, as determined by the input parameter "
-                             "'Use table properties', this value is irrelevant and will be ignored.");
-          prm.declare_entry ("Uppermost mantle thickness", "300000",
-                             Patterns::Double (0),
-                             "The depth of the base of the uppermost mantle, which marks the transition between "
-                             "using the temperature model of Tutu et al. (above) and derived from seismic "
-                             "tomography (below). "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Use depth dependent temperature scaling", "false",
-                             Patterns::Bool (),
-                             "This parameter value determines if we want to use a depth-dependent scaling read "
-                             "in from a data file for computing the temperature from seismic velocities (if true) "
-                             "or use a constant value (if false).");
-          prm.declare_entry ("Use varying fault viscosity", "false",
-                             Patterns::Bool (),
-                             "This parameter value determines if we want to use different viscosities for ridges "
-                             "and trenches. We think that ridges are already weakened by the high temperatures "
-                             "and by prescribing additional weak zones, we are making plates surrounded by ridges "
-                             "faster than observed.");
-          prm.declare_entry ("Use constant lithosphere thickness", "false",
-                             Patterns::Bool (),
-                             "This parameter value determines if we want to a lithosphere with a constant thickness. "
-                             "We can evaluate the effects of lithospheric thickness variations on the surface plate "
-                             "motions using this. Currently, this parameter sets the lithosphere to a constant "
-                             "thickness of 100 km.");
-          // Varying fault parameters
-          prm.enter_subsection("Varying fault viscosity");
-          {
-            prm.declare_entry ("Ridge viscosity", "1e22",
-                               Patterns::Double(0),
-                               "This parameter value determines the viscosity of faults at the ridges. "
-                               "Units: \\si{\\pascal\\second}");
-            prm.declare_entry ("Trench viscosity", "1e20",
-                               Patterns::Double(0),
-                               "This parameter value determines the viscosity of faults at the trenches. "
-                               "Units: \\si{\\pascal\\second}");
-          }
-          prm.leave_subsection();
-          // Depth-dependent viscosity parameters
-          Rheology::AsciiDepthProfile<dim>::declare_parameters(prm);
-
-          // Depth-dependent density scaling parameters
-          Utilities::AsciiDataBase<dim>::declare_parameters(prm, "$ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/", "rho_vs_scaling.txt",
-                                                            "Density velocity scaling");
-
-          // Depth-dependent density scaling parameters
-          Utilities::AsciiDataBase<dim>::declare_parameters(prm, "$ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/", "dT_vs_scaling.txt",
-                                                            "Temperature velocity scaling");
-
-          // Depth-dependent thermal expansivity parameters
-          Utilities::AsciiDataBase<dim>::declare_parameters(prm, "$ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/",
-                                                            "thermal_expansivity_steinberger_calderwood.txt", "Thermal expansivity profile");
-
-          // Crustal boundary depths parameters
-          Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,  "$ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/",
-                                                                "crustal_structure.txt", "Crustal depths");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    TomographyBasedPlateMotions<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      AssertThrow (this->introspection().compositional_name_exists("grain_size"),
-                   ExcMessage("The 'grain size' material model only works if a compositional "
-                              "field with name 'grain_size' is present. Please use another material "
-                              "model or add such a field."));
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Tomography based plate motions model");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          k_value                    = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-          reference_compressibility  = prm.get_double ("Reference compressibility");
-
-
-          transition_depths         = Utilities::string_to_double
-                                      (Utilities::split_string_list(prm.get ("Phase transition depths")));
-          transition_temperatures   = Utilities::string_to_double
-                                      (Utilities::split_string_list(prm.get ("Phase transition temperatures")));
-          transition_slopes         = Utilities::string_to_double
-                                      (Utilities::split_string_list(prm.get ("Phase transition Clapeyron slopes")));
-          recrystallized_grain_size = Utilities::string_to_double
-                                      (Utilities::split_string_list(prm.get ("Recrystallized grain size")));
-          transition_widths         = Utilities::string_to_double
-                                      (Utilities::split_string_list(prm.get ("Phase transition widths")));
-
-          if (transition_temperatures.size() != transition_depths.size() ||
-              transition_slopes.size() != transition_depths.size() ||
-              transition_widths.size() != transition_depths.size() ||
-              recrystallized_grain_size.size() != transition_depths.size() )
-            AssertThrow(false,
-                        ExcMessage("Error: At least one list that gives input parameters for the phase transitions has the wrong size."));
-
-          if (transition_depths.size()>1)
-            for (unsigned int i=0; i<transition_depths.size()-2; ++i)
-              AssertThrow(transition_depths[i]<transition_depths[i+1],
-                          ExcMessage("Error: Phase transition depths have to be sorted in ascending order!"));
-
-          // grain evolution parameters
-          grain_growth_activation_energy        = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Grain growth activation energy")));
-          grain_growth_activation_volume        = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Grain growth activation volume")));
-          grain_growth_rate_constant            = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Grain growth rate constant")));
-          grain_growth_exponent                 = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Grain growth exponent")));
-          min_grain_size                        = prm.get_double("Minimum grain size");
-          reciprocal_required_strain            = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Reciprocal required strain")));
-          equilibrate_grain_size                = prm.get_bool ("Use equilibrium grain size");
-
-          grain_boundary_energy                 = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Average specific grain boundary energy")));
-          boundary_area_change_work_fraction    = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Work fraction for boundary area change")));
-          geometric_constant                    = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Geometric constant")));
-
-          // rheology parameters
-          dislocation_viscosity_iteration_threshold = prm.get_double("Dislocation viscosity iteration threshold");
-          dislocation_viscosity_iteration_number = prm.get_integer("Dislocation viscosity iteration number");
-          dislocation_creep_exponent            = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Dislocation creep exponent")));
-          dislocation_activation_energy         = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Dislocation activation energy")));
-          dislocation_activation_volume         = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Dislocation activation volume")));
-          dislocation_creep_prefactor           = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Dislocation creep prefactor")));
-          diffusion_creep_exponent              = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion creep exponent")));
-          diffusion_activation_energy           = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion activation energy")));
-          diffusion_activation_volume           = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion activation volume")));
-          diffusion_creep_prefactor             = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion creep prefactor")));
-          diffusion_creep_grain_size_exponent   = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion creep grain size exponent")));
-          max_temperature_dependence_of_eta     = prm.get_double ("Maximum temperature dependence of viscosity");
-          min_eta                               = prm.get_double ("Minimum viscosity");
-          max_eta                               = prm.get_double ("Maximum viscosity");
-
-          if (grain_growth_activation_energy.size() != grain_growth_activation_volume.size() ||
-              grain_growth_activation_energy.size() != grain_growth_rate_constant.size() ||
-              grain_growth_activation_energy.size() != grain_growth_exponent.size() ||
-              grain_growth_activation_energy.size() != dislocation_creep_exponent.size() ||
-              grain_growth_activation_energy.size() != dislocation_activation_energy.size() ||
-              grain_growth_activation_energy.size() != dislocation_activation_volume.size() ||
-              grain_growth_activation_energy.size() != dislocation_creep_prefactor.size() ||
-              grain_growth_activation_energy.size() != diffusion_creep_exponent.size() ||
-              grain_growth_activation_energy.size() != diffusion_activation_energy.size() ||
-              grain_growth_activation_energy.size() != diffusion_activation_volume.size() ||
-              grain_growth_activation_energy.size() != diffusion_creep_prefactor.size() ||
-              grain_growth_activation_energy.size() != diffusion_creep_grain_size_exponent.size() )
-            AssertThrow(false,
-                        ExcMessage("Error: The lists of grain size evolution and flow law parameters "
-                                   "need to have the same length!"));
-
-          if (equilibrate_grain_size)
-            {
-              if (grain_growth_activation_energy.size() != grain_boundary_energy.size() ||
-                  grain_growth_activation_energy.size() != boundary_area_change_work_fraction.size() ||
-                  grain_growth_activation_energy.size() != geometric_constant.size() )
-                AssertThrow(false,
-                            ExcMessage("Error: One of the lists of grain size evolution parameters "
-                                       "given for the paleowattmeter does not have the correct length!"));
-            }
-
-          AssertThrow(grain_growth_activation_energy.size() == transition_depths.size()+1,
-                      ExcMessage("Error: The lists of grain size evolution and flow law parameters need to "
-                                 "have exactly one more entry than the number of phase transitions "
-                                 "(which is defined by the length of the lists of phase transition depths, ...)!"));
-
-          // parameters for reading in tables with material properties
-          data_directory        = prm.get ("Data directory");
-          {
-            const std::string subst_text = "$ASPECT_SOURCE_DIR";
-            std::string::size_type position;
-            while (position = data_directory.find (subst_text),  position!=std::string::npos)
-              data_directory.replace (data_directory.begin()+position,
-                                      data_directory.begin()+position+subst_text.size(),
-                                      ASPECT_SOURCE_DIR);
-          }
-          material_file_names  = Utilities::split_string_list
-                                 (prm.get ("Material file names"));
-          derivatives_file_names = Utilities::split_string_list
-                                   (prm.get ("Derivatives file names"));
-
-          use_table_properties                    = prm.get_bool ("Use table properties");
-          use_depth_dependent_viscosity           = prm.get_bool ("Use depth dependent viscosity");
-          use_faults                              = prm.get_bool ("Use faults");
-          use_cratons                             = prm.get_bool ("Use cratons");
-          craton_viscosity                        = prm.get_double("Craton viscosity");
-          use_depth_dependent_rho_vs              = prm.get_bool ("Use depth dependent density scaling");
-          use_depth_dependent_dT_vs               = prm.get_bool ("Use depth dependent temperature scaling");
-          use_depth_dependent_thermal_expansivity = prm.get_bool ("Use thermal expansivity profile");
-          depth_to_base_of_uppermost_mantle       = prm.get_double ("Uppermost mantle thickness");
-          fault_viscosity                         = prm.get_double ("Fault viscosity");
-          asthenosphere_viscosity                 = prm.get_double ("Asthenosphere viscosity");
-          use_varying_fault_viscosity             = prm.get_bool ("Use varying fault viscosity");
-          use_constant_lithosphere_thickness      = prm.get_bool("Use constant lithosphere thickness");
-
-          if (use_varying_fault_viscosity)
-            AssertThrow (use_faults,
-                         ExcMessage("Variable viscosity along ridges and trenches can only be incorporated "
-                                    "if we are using faults in our model."));
-
-          prm.enter_subsection("Varying fault viscosity");
-          {
-            ridge_viscosity                         = prm.get_double ("Ridge viscosity");
-            trench_viscosity                        = prm.get_double ("Trench viscosity");
-          }
-          prm.leave_subsection();
-
-          // Parse all depth-dependent parameters
-          if (use_depth_dependent_viscosity)
-            {
-              reference_viscosity_profile = std::make_unique<Rheology::AsciiDepthProfile<dim>>();
-              reference_viscosity_profile->initialize_simulator (this->get_simulator());
-              reference_viscosity_profile->parse_parameters(prm);
-              reference_viscosity_profile->initialize();
-            }
-
-          if (use_depth_dependent_rho_vs)
-            rho_vs_depth_profile.parse_parameters(prm, "Density velocity scaling");
-
-          if (use_depth_dependent_thermal_expansivity)
-            thermal_expansivity_profile.parse_parameters(prm, "Thermal expansivity profile");
-
-          if (use_depth_dependent_dT_vs)
-            dT_vs_depth_profile.parse_parameters(prm, "Temperature velocity scaling");
-
-          crustal_boundary_depth.initialize_simulator (this->get_simulator());
-          crustal_boundary_depth.parse_parameters(prm, "Crustal depths");
-
-          // Make sure the grain size field comes after all potential material
-          // data fields. Otherwise our material model calculation uses the
-          // wrong compositional fields.
-          if (use_table_properties && material_file_names.size() > 1)
-            {
-              AssertThrow(this->introspection().compositional_index_for_name("grain_size") >= material_file_names.size(),
-                          ExcMessage("The compositional fields indicating the major element composition need to be first in the "
-                                     "list of compositional fields, but the grain size field seems to have a lower index than the number "
-                                     "of provided data files. This is likely inconsistent. Please check the number of provided data "
-                                     "files and the order of compositional fields."));
-            }
-
-          if (prm.get ("Material file format") == "perplex")
-            material_file_format = perplex;
-          else if (prm.get ("Material file format") == "hefesto")
-            material_file_format = hefesto;
-          else
-            AssertThrow (false, ExcNotImplemented());
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-
-      // Declare dependencies on solution variables
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-
-      this->model_dependence.viscosity = NonlinearDependence::temperature
-                                         | NonlinearDependence::pressure
-                                         | NonlinearDependence::strain_rate
-                                         | NonlinearDependence::compositional_fields;
-
-      this->model_dependence.density = NonlinearDependence::none;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-
-      if (use_table_properties)
-        {
-          this->model_dependence.density |= NonlinearDependence::temperature
-                                            | NonlinearDependence::pressure
-                                            | NonlinearDependence::compositional_fields;
-          this->model_dependence.compressibility = NonlinearDependence::temperature
-                                                   | NonlinearDependence::pressure
-                                                   | NonlinearDependence::compositional_fields;
-          this->model_dependence.specific_heat = NonlinearDependence::temperature
-                                                 | NonlinearDependence::pressure
-                                                 | NonlinearDependence::compositional_fields;
-        }
-      else
-        {
-          if (thermal_alpha != 0)
-            this->model_dependence.density |=NonlinearDependence::temperature;
-          if (reference_compressibility != 0)
-            this->model_dependence.density |=NonlinearDependence::pressure;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    TomographyBasedPlateMotions<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // These properties are useful as output, but will also be used by the
-      // heating model to reduce shear heating by the amount of work done to
-      // reduce grain size.
-      if (out.template get_additional_output<DislocationViscosityOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.viscosities.size();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::DislocationViscosityOutputs<dim>> (n_points));
-        }
-
-      // We need the prescribed field outputs to interpolate the grain size onto a compositional field.
-      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.viscosities.size();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points, this->n_compositional_fields()));
-        }
-
-      // These properties are only output properties. But we should only create them if they are filled.
-      if (use_table_properties
-          && out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.viscosities.size();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
-        }
-
-      if (this->get_parameters().temperature_method == Parameters<dim>::AdvectionFieldMethod::prescribed_field &&
-          out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.viscosities.size();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>> (n_points));
-        }
-
-      // We need additional field outputs for the unscaled viscosity
-      if (out.template get_additional_output<UnscaledViscosityAdditionalOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.viscosities.size();
-          out.additional_outputs.push_back(
-            std::make_unique<UnscaledViscosityAdditionalOutputs<dim>> (n_points));
-        }
-
-      if (out.template get_additional_output<MaterialTypeAdditionalOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.viscosities.size();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialTypeAdditionalOutputs<dim>> (n_points));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(TomographyBasedPlateMotions,
-                                   "tomography based plate motions",
-                                   "A material model that relies on compositional "
-                                   "fields that correspond to the average grain sizes of a "
-                                   "mineral phase and source terms that determine the grain "
-                                   "size evolution in terms of the strain rate, "
-                                   "temperature, phase transitions, and the creep regime. "
-                                   "This material model only works if a compositional field "
-                                   "named 'grain_size' is present. "
-                                   "In the diffusion creep regime, the viscosity depends "
-                                   "on this grain size field. "
-                                   "We use the grain size evolution laws described in \\cite{Behn2009}. "
-                                   "Other material parameters are either prescribed similar "
-                                   "to the 'simple' material model, or read from data files "
-                                   "that were generated by the Perplex or Hefesto software. "
-                                   "This material model is described in more detail in "
-                                   "\\citet{dannberg2017}.")
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace
-    {
-
-#define INSTANTIATE(dim) \
-  template class UnscaledViscosityAdditionalOutputs<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.h.bak b/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.h.bak
deleted file mode 100644
index 6846e88afe1..00000000000
--- a/cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.h.bak
+++ /dev/null
@@ -1,513 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_cookbooks_tomography_based_plate_motions_h
-#define _aspect_cookbooks_tomography_based_plate_motions_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/lateral_averaging.h>
-#include <aspect/material_model/grain_size.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/rheology/ascii_depth_profile.h>
-#include <array>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-
-    /**
-     * A material model to set up mantle flow models based on
-     * an input tomography model and a temperature model.
-     * The viscosity is computed based on dislocation and diffusion
-     * creep with lateral averages scaled to a reference viscosity
-     * profile.
-     * This material model only works if a compositional field
-     * named 'grain_size' is present. In the diffusion
-     * creep regime, the viscosity depends on this grain size.
-     * The model allows the user to prescribe different viscosity at
-     * fault boundaries and in continental regions at locations defined
-     * by the the compositional field 'faults' or 'cratons', respectively.
-     * The material model also allows the option to compute and use
-     * equilibrium grain size following paleowattmeter approximation
-     * by Austin and Evans, (2007), Paleowattmeters: "A scaling relation for
-     * dynamically recrystallized grain size", Geology, 35, 343.
-     * Other material parameters are either based on (1) an input tomography
-     * model and scaling profiles between temperature/density relative to
-     * the seismic velocity anomalies or a temperature model and constant
-     * thermal expansivities and compressibilities relative to a reference
-     * temperature, as done in Osei Tutu et al., (2018): "Evaluating the influence
-     * of plate boundary friction and mantle viscosity on plate velocities",
-     * Geochem. Geophys. Geosyst., 19 (3), 642–666, or (2) prescribed similar to
-     * the 'simple' material model, or (3) read from data files
-     * that were generated by the Perplex or Hefesto software. The material model
-     * is described in more detail in Dannberg, J., Z. Eilon, U. Faul,
-     * R. Gassmöller, P. Moulik, and R. Myhill (2017): "The importance of
-     * grain size to mantle dynamics and seismological observations",
-     * Geochem. Geophys. Geosyst., 18, 3034–3061, doi:10.1002/2017GC006944.,
-     * and in Saxena, A., Dannberg J., Gassmöller, Fraters, M., Heister, T., & Styron, (2023):
-     * "High-resolution mantle flow models reveal importance of plate boundary geometry and slab pull
-     * forces on generating tectonic plate motions", J. Geophys. Research.:Solid Earth,
-     * 128, e2022JB025877.
-
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class TomographyBasedPlateMotions : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. Loads the material data and sets up
-         * pointers. Gets the reference viscosity profile from a file.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Compute the laterally averaged viscosity
-         */
-        void
-        update() override;
-
-        /**
-         * Compute the reference viscosity against which the viscosities in the model
-         * are scaled. The reference viscosity is from a depth-dependent ascii profile and
-         * the function returns as the second parameter in the pair the support point in
-         * that profile that has the next smaller depth value than the input parameter
-         * @p depth.
-         */
-        std::pair<double, unsigned int>
-        get_reference_viscosity (const double depth) const;
-
-        /**
-         * Return the depth of the base of the uppermost mantle. Below that depth,
-         * material properties are based on seismic tomography. Above that depth, material
-         * properties are computed based on the model of Tutu et al., 2018.
-         */
-        double
-        get_depth_of_base_of_uppermost_mantle () const;
-
-        /**
-         * Compute the scaling factors for each depth layer such that the laterally
-         * averaged viscosiy in that layer is the same as the reference vicosity.
-         */
-        double
-        compute_viscosity_scaling (const double depth) const;
-
-        /**
-         * Return whether the model is compressible or not.
-         */
-        bool
-        is_compressible () const override;
-
-        void
-        evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                 typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-        /**
-         * @}
-         */
-
-      protected:
-        double reference_rho;
-        double thermal_alpha;
-        double reference_specific_heat;
-
-        /**
-         * The constant compressibility.
-         */
-        double reference_compressibility;
-
-        /**
-         * The thermal conductivity.
-         */
-        double k_value;
-
-        /**
-         * Parameters controlling the grain size evolution.
-         */
-        std::vector<double> grain_growth_activation_energy;
-        std::vector<double> grain_growth_activation_volume;
-        std::vector<double> grain_growth_rate_constant;
-        std::vector<double> grain_growth_exponent;
-        double              minimum_grain_size;
-        std::vector<double> reciprocal_required_strain;
-        std::vector<double> recrystallized_grain_size;
-        bool                equilibrate_grain_size;
-
-        /**
-         * Parameters controlling the dynamic grain recrystallization.
-         * (following paleowattmeter as described in Austin, N. J., & Evans, B.
-         * (2007). Paleowattmeters: A scaling relation for dynamically
-         * recrystallized grain size. Geology, 35(4), 343-346.).
-         */
-        std::vector<double> grain_boundary_energy;
-        std::vector<double> boundary_area_change_work_fraction;
-        std::vector<double> geometric_constant;
-
-        /**
-         * Parameters controlling the viscosity.
-         */
-        double dislocation_viscosity_iteration_threshold;
-        unsigned int dislocation_viscosity_iteration_number;
-        std::vector<double> dislocation_creep_exponent;
-        std::vector<double> dislocation_activation_energy;
-        std::vector<double> dislocation_activation_volume;
-        std::vector<double> dislocation_creep_prefactor;
-        std::vector<double> diffusion_creep_exponent;
-        std::vector<double> diffusion_activation_energy;
-        std::vector<double> diffusion_activation_volume;
-        std::vector<double> diffusion_creep_prefactor;
-        std::vector<double> diffusion_creep_grain_size_exponent;
-
-        /**
-         * Reference viscosity profile coordinates, and the corresponding viscosity.
-         */
-        std::vector<double> reference_viscosity_coordinates;
-        std::unique_ptr<Rheology::AsciiDepthProfile<dim>> reference_viscosity_profile;
-
-        /**
-         * A reference profile for density scaling.
-         */
-        Utilities::AsciiDataProfile<dim> rho_vs_depth_profile;
-
-        /**
-         * The column indices of the density scaling column in the ascii profile file.
-         */
-        unsigned int density_scaling_index;
-
-
-        /**
-         * A reference profile for the thermal expansivity.
-         */
-        Utilities::AsciiDataProfile<dim> thermal_expansivity_profile;
-        unsigned int thermal_expansivity_column_index;
-
-        /**
-         * A reference profile for temperatura scaling. Values are from Steinberger and
-         * Calderwood, 2006.
-         */
-        Utilities::AsciiDataProfile<dim> dT_vs_depth_profile;
-
-        /**
-         * The column indices of the density scaling column in the ascii profile file.
-         */
-        unsigned int temperature_scaling_index;
-
-        /**
-         * An object of ascii data boundary to input crustal depths.
-         */
-        Utilities::AsciiDataBoundary<dim> crustal_boundary_depth;
-
-        /**
-         * A depth-profile of the laterally averaged viscosity in each layer
-         * in the current model. Can be used to compare (and potentially scale)
-         * the computed viscosity to the reference profile.
-         */
-        std::vector<double> average_viscosity_profile;
-
-        /**
-         * Variable returned  to determine if the evaluate () function is called and
-         * viscosities are computed. Initially, it is set to false and then updated
-         * to true in the update () function.
-         */
-        bool initialized;
-
-        /**
-         * Because of the nonlinear nature of this material model many
-         * parameters need to be kept within bounds to ensure stability of the
-         * solution. These bounds can be adjusted as input parameters.
-         */
-        double max_temperature_dependence_of_eta;
-        double min_eta;
-        double max_eta;
-        double min_specific_heat;
-        double max_specific_heat;
-        double min_thermal_expansivity;
-        double max_thermal_expansivity;
-        unsigned int max_latent_heat_substeps;
-        double min_grain_size;
-
-        double diffusion_viscosity (const double      temperature,
-                                    const double      pressure,
-                                    const std::vector<double>    &compositional_fields,
-                                    const SymmetricTensor<2,dim> &strain_rate,
-                                    const Point<dim> &position) const;
-
-        /**
-         * Compute the equilibrium grain size for a given temperature and
-         * pressure.
-         * This computation is based on the rate of grain size growth
-         * (Ostwald ripening) or reduction (due to dynamic recrystallization
-         * and phase transformations) in dependence on temperature, pressure,
-         * strain rate, mineral phase and creep regime.
-         * We use the grain size growth laws as for example described
-         * in Behn, M. D., Hirth, G., & Elsenbeck, J. R. (2009). Implications
-         * of grain size evolution on the seismic structure of the oceanic
-         * upper mantle. Earth and Planetary Science Letters, 282(1), 178-189.
-         *
-         * For the rate of grain size reduction due to dynamic crystallization,
-         * we use paleowattmeter approximation (Austins and
-         * Evans, 2007).
-         */
-        void compute_equilibrium_grain_size (const typename Interface<dim>::MaterialModelInputs &in,
-                                             typename Interface<dim>::MaterialModelOutputs      &out) const;
-
-        /**
-         * This function calculates the dislocation viscosity. For this purpose
-         * we need the dislocation component of the strain rate, which we can
-         * only compute by knowing the dislocation viscosity. Therefore, we
-         * iteratively solve for the dislocation viscosity and update the
-         * dislocation strain rate in each iteration using the new value
-         * obtained for the dislocation viscosity. The iteration is started
-         * with a dislocation viscosity calculated for the whole strain rate
-         * unless a guess for the viscosity is provided, which can reduce the
-         * number of iterations significantly.
-         */
-        double dislocation_viscosity (const double                  temperature,
-                                      const double                  pressure,
-                                      const std::vector<double>    &compositional_fields,
-                                      const SymmetricTensor<2,dim> &strain_rate,
-                                      const Point<dim>             &position,
-                                      const double                  viscosity_guess = 0) const;
-
-        /**
-         * This function calculates the dislocation viscosity for a given
-         * dislocation strain rate.
-         */
-        double dislocation_viscosity_fixed_strain_rate (const double      temperature,
-                                                        const double      pressure,
-                                                        const double      second_strain_rate_invariant,
-                                                        const Point<dim> &position) const;
-
-        double density (const double temperature,
-                        const double pressure,
-                        const std::vector<double> &compositional_fields,
-                        const Point<dim> &position) const;
-
-        /**
-         * The column indices of the density column in the reference profile file.
-         */
-        unsigned int density_index;
-
-        double compressibility (const double temperature,
-                                const double pressure,
-                                const std::vector<double> &compositional_fields,
-                                const Point<dim> &position) const;
-
-        double thermal_expansivity (const double temperature,
-                                    const double pressure,
-                                    const std::vector<double> &compositional_fields,
-                                    const Point<dim> &position) const;
-
-        /**
-         * Returns the p-wave velocity as calculated by HeFESTo.
-         */
-        double seismic_Vp (const double      temperature,
-                           const double      pressure,
-                           const std::vector<double> &compositional_fields,
-                           const Point<dim> &position) const;
-
-        /**
-         * Returns the s-wave velocity as calculated by HeFESTo.
-         */
-        double seismic_Vs (const double      temperature,
-                           const double      pressure,
-                           const std::vector<double> &compositional_fields,
-                           const Point<dim> &position) const;
-
-        /**
-         * Function that defines the phase transition interface
-         * (0 above, 1 below the phase transition). This is done
-         * individually for each transition and summed up in the end.
-         */
-        double
-        phase_function (const Point<dim> &position,
-                        const double temperature,
-                        const double pressure,
-                        const unsigned int phase) const;
-
-        /**
-         * Function that returns the phase for a given
-         * position, temperature, pressure and compositional
-         * field index.
-         */
-        unsigned int
-        get_phase_index (const Point<dim> &position,
-                         const double temperature,
-                         const double pressure) const;
-
-
-        /**
-         * Lists of depth, width, and Clapeyron slopes for the different phase
-         * transitions and in which phase they occur.
-         */
-        std::vector<double> transition_depths;
-        std::vector<double> transition_temperatures;
-        std::vector<double> transition_slopes;
-        std::vector<double> transition_widths;
-
-
-        /**
-         * The following variables are properties of the material files
-         * we read in.
-         */
-        std::string data_directory;
-        std::vector<std::string> material_file_names;
-        std::vector<std::string> derivatives_file_names;
-        unsigned int n_material_data;
-        bool use_table_properties;
-
-        /**
-         * Parameter value that determines whether to read the viscosity with depth
-         * from an ascii data file.
-        */
-        bool use_depth_dependent_viscosity;
-
-        /**
-         * Parameter value that determines whether to read the density scaling with depth
-         * from an ascii data file.
-        */
-        bool use_depth_dependent_rho_vs;
-
-        /**
-         * Parameter value that determines whether to read the thermal expansivity
-         * from an ascii data file.
-        */
-        bool use_depth_dependent_thermal_expansivity;
-
-        /**
-         * Parameter value that determines whether to read the temperature scaling with depth
-         * from an ascii data file.
-        */
-        bool use_depth_dependent_dT_vs;
-
-        /**
-         * Parameter that determines if faults or plate boundaries are used as another
-         * compositional field.
-         */
-        bool use_faults;
-
-        /**
-         * Parameter that determines the viscosity of faults or plate boundaries.
-         */
-        double fault_viscosity;
-
-        /**
-         * Parameter that determines if ridges or trenches have different viscosities
-         */
-        bool use_varying_fault_viscosity;
-
-        /**
-         * Parameter that determines if lithospheric depths vary or not
-         */
-        bool use_constant_lithosphere_thickness;
-
-        /**
-         * Parameter that determines the viscosity of faults at ridges.
-         */
-        double ridge_viscosity;
-
-        /**
-         * Parameter that determines the viscosity of faults at trenches.
-         */
-        double trench_viscosity;
-
-        /**
-         * Parameter that determines the asthenosphere viscosity. By default, use
-         * the value from the Steinberger & Calderwood reference viscosity profile.
-         */
-        double asthenosphere_viscosity;
-
-        /**
-         * Parameter that determines if we want to use viscous and neutrally buoyant cratons as
-         * another compositional field.
-         */
-        bool use_cratons;
-
-        /**
-         * Parameter that determines the viscosity for cratons.
-         */
-        double craton_viscosity;
-
-        /**
-         * Approximate lithosphere thickness used to separate the regions of
-         * temperature derived from seismic tomography and linear temperature
-         * gradient.
-        */
-        double lithosphere_thickness;
-
-        /**
-         * Parameter used to describe the uppermost mantle based on Tutu (2018).
-         */
-        double depth_to_base_of_uppermost_mantle;
-
-        /**
-         * The format of the provided material files. Currently we support
-         * the PERPLEX and HeFESTo data formats.
-         */
-        enum formats
-        {
-          perplex,
-          hefesto
-        } material_file_format;
-
-        /**
-         * List of pointers to objects that read and process data we get from
-         * material data files. There is one pointer/object per compositional
-         * field provided.
-         */
-        std::vector<std::shared_ptr<MaterialModel::MaterialUtilities::Lookup::MaterialLookup>> material_lookup;
-
-        /**
-        * A shared pointer to the initial temperature object
-        * that ensures that the current object can continue
-        * to access the initial composition object beyond the
-        * first time step.
-        */
-        std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature_manager;
-    };
-
-  }
-}
-
-#endif
diff --git a/cookbooks/transform_fault_behn_2007/doc/material.part.prm.bak b/cookbooks/transform_fault_behn_2007/doc/material.part.prm.bak
deleted file mode 100644
index 28c51d6c0ca..00000000000
--- a/cookbooks/transform_fault_behn_2007/doc/material.part.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 1573.15
-    set Heat capacities       = 1000
-    set Densities             = 3300           # Value from Behn et al., 2007
-    set Thermal expansivities = 0              # Thermal buoyancy is ignored in Behn et al., 2007
-    set Define thermal conductivities = true
-    set Thermal conductivities        = 3.5
-  end
-end
diff --git a/cookbooks/transform_fault_behn_2007/doc/temperature.part.prm.bak b/cookbooks/transform_fault_behn_2007/doc/temperature.part.prm.bak
deleted file mode 100644
index 3cfa8800283..00000000000
--- a/cookbooks/transform_fault_behn_2007/doc/temperature.part.prm.bak
+++ /dev/null
@@ -1,28 +0,0 @@
-# We use the Geodynamic World Builder to create the initial temperature.
-# Therefore, we have to specify the location of the GWB input file
-# that we want to use. The file we use here is located in the cookbooks
-# folder of the GWB repository. See the corresponding tutorial in the
-# Geodynamic World Builder on how to create this file.
-set World builder file = $ASPECT_SOURCE_DIR/contrib/world_builder/cookbooks/3d_cartesian_transform_fault/3d_cartesian_transform_fault.wb
-
-# Note that the adiabatic surface temperature should be consistent with the
-# value assumed in the GWB input file, given in the parameter 'potential
-# mantle temperature'.
-set Adiabatic surface temperature          = 1573.15
-
-# The initial temperature comes form the Geodynamic World Builder.
-subsection Initial temperature model
-  set List of model names = world builder
-end
-
-# We prescribe the surface temperature at the top and the mantle potential temperature
-# at the bottom.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 273.15
-    set Bottom temperature = 1573.15
-  end
-end
diff --git a/cookbooks/transform_fault_behn_2007/temperature_dependent.prm.bak b/cookbooks/transform_fault_behn_2007/temperature_dependent.prm.bak
deleted file mode 100644
index f4791b31f2d..00000000000
--- a/cookbooks/transform_fault_behn_2007/temperature_dependent.prm.bak
+++ /dev/null
@@ -1,24 +0,0 @@
-# This is a model of a mid-ocean ridge with a transform fault,
-# specifically, it is a model that reproduces the setup of Behn et
-# al., 2007: Thermal structure of oceanic transform faults.
-# This input file covers case 2 from that publication (with a
-# temperature-dependent viscosity).
-
-include ./transform_fault_behn_2007.prm
-
-set World builder file = $ASPECT_SOURCE_DIR/contrib/world_builder/cookbooks/3d_cartesian_transform_fault/3d_cartesian_transform_fault.wb
-set Output directory = transform-fault-behn-2007-temperature-dependent
-set Dimension        = 3
-
-# In case 2, viscosity is temperature-dependent with an
-# activation energy of 250 kJ/mol. We also need to scale the
-# prefactor to account for the different formulation of the
-# diffusion creep flow law.
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Prefactors for diffusion creep          = 9.99479239e-12
-    set Activation energies for diffusion creep = 250e3
-  end
-end
diff --git a/cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm.bak b/cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm.bak
deleted file mode 100644
index d2e8a8f2aa7..00000000000
--- a/cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm.bak
+++ /dev/null
@@ -1,203 +0,0 @@
-# This is a model of a mid-ocean ridge with a transform fault,
-# specifically, it is a model that reproduces the setup of Behn et
-# al., 2007: Thermal structure of oceanic transform faults.
-# This input file covers case 1 from that publication (with a
-# constant viscosity).
-
-# We use the Geodynamic World Builder to create the initial temperature.
-# Therefore, we have to specify the location of the GWB input file
-# that we want to use. The file we use here is located in the cookbooks
-# folder of the GWB repository. See the corresponding tutorial in the
-# Geodynamic World Builder on how to create this file.
-set World builder file = $ASPECT_SOURCE_DIR/contrib/world_builder/cookbooks/3d_cartesian_transform_fault/3d_cartesian_transform_fault.wb
-
-# We run the model for 10 million years.
-set End time                               = 1e7
-set Output directory                       = transform-fault-behn-2007
-set Dimension                              = 3
-
-# We set the average pressure at the surface to 0.
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Note that the adiabatic surface temperature should be consistent with the
-# value assumed in the GWB input file, given in the parameter 'potential
-# mantle temperature'.
-set Adiabatic surface temperature          = 1573.15
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 50
-
-# We use the geometric multigrid solver, but because this is a difficult
-# linear problem to solve with a large viscosity contrast, we increase the
-# number of cheap iterations and the restart length to make sure it
-# converges.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set GMRES solver restart length = 200
-    set Number of cheap Stokes solver steps = 5000
-    set Stokes solver type = block GMG
-  end
-end
-
-# The model is a box with a width of 250 x 100 km and a depth of 100 km.
-# The number of X, Y and Z repetitions determine the shape of the coarsest
-# mesh cells (that will then be refined adaptively) relative to the
-# shape of the box. To achieve an aspect ratio of approximately one
-# for the cells, we choose more X than Y and Z repetitions.
-# Note that the geometry should be consistent with the geometry assumed in
-# in the GWB input file. Specifically, that means making sure that the
-# whole model domain lies inside the area prescribed by the coordinates
-# of the oceanic plate feature given in the GWB input file.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 250000
-    set Y extent  = 100000
-    set Z extent  = 100000
-    set X repetitions = 5
-    set Y repetitions = 2
-    set Z repetitions = 2
-  end
-end
-
-# Since we model an oceanic plate moving away from the ridge axis, we
-# prescribe the plate velocity of 3 cm/yr at the surface. Depending on
-# the side of the transform fault we are on, the velocity points either
-# in negative or positive x direction.
-# As per Behn et al., 2007: The base of the model is stress free.
-# Symmetric boundary conditions are imposed on the sides of the model space
-# parallel to the spreading direction, and the boundaries perpendicular to
-# spreading are open to convective flux (we prescribe the lithostatic
-# pressure).
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = front, back
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Function constants  = spreading_rate=0.03
-    set Variable names      = x,y,z
-    set Function expression = if(x<50000 || (x<200000 && y<50000), -spreading_rate, spreading_rate); 0; 0
-  end
-end
-
-# We prescribe a boundary traction in vertical direction at the bottom and
-# and right boundaries, setting it to the lithostatic pressure to allow
-# for free in- and outflow of material.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right:initial lithostatic pressure, left:initial lithostatic pressure, bottom:initial lithostatic pressure
-
-  # We choose the representative point at 125 km from the ridge, which
-  # is in the middle between the distance of the old (200 km) and young
-  # (50 km) ridge segment at each side.
-  subsection Initial lithostatic pressure
-    set Number of integration points = 1000
-    set Representative point         = 175000,0,0
-  end
-end
-
-# The initial temperature comes form the Geodynamic World Builder.
-subsection Initial temperature model
-  set List of model names = world builder
-end
-
-# We prescribe the surface temperature at the top and the mantle potential temperature
-# at the bottom.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 273.15
-    set Bottom temperature = 1573.15
-  end
-end
-
-subsection Material model
-  # Because we use the GMG solver, we need to average the viscosity.
-  set Material averaging = project to Q1 only viscosity
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Reference temperature and viscosity
-    set Reference temperature = 1573.15
-
-    # Limit the viscosity. The maximum value is 1e23 Pa s as given in
-    # Behn et al. 2007. The minimum value should never be reached, since
-    # the viscosity should never drop below the reference value of
-    # 1e19 Pa s.
-    set Minimum viscosity = 1e18
-    set Maximum viscosity = 1e23
-    set Heat capacities       = 1000
-    set Densities             = 3300           # Value from Behn et al., 2007
-    set Thermal expansivities = 0              # Thermal buoyancy is ignored in Behn et al., 2007
-    set Define thermal conductivities = true
-    set Thermal conductivities        = 3.5
-    set Viscous flow law      = diffusion
-    set Activation volumes for diffusion creep  = 0
-    set Grain size            = 1
-
-    # The reference viscosity is 1e19 Pa s, and viscosity does
-    # not depend on pressure.
-    # Case 1 in Behn et al. (2007) has a constant viscosity as used here.
-    set Prefactors for diffusion creep          = 5e-20
-    set Activation energies for diffusion creep = 0
-
-    # Plasticity parameters - irrelevant
-    # set to very high value so that it is not used
-    set Cohesions = 1e15
-  end
-end
-
-# The gravity points downward and is set to 10.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# The highest resolution in Behn et al is 3.75 km near the transform fault.
-# The coarse cells have a size of 50 km, which corresponds to 4 global
-# refinements.
-subsection Mesh refinement
-  set Time steps between mesh refinement = 0
-  set Initial global refinement = 4
-  set Initial adaptive refinement = 0          # For a higher resolution near the transform fault, set this to 2
-  set Strategy = minimum refinement function
-  set Skip solvers on initial refinement = true
-  set Minimum refinement level = 4
-
-  # Using initial adpative refinements 2 would allow for an increased
-  # resolution near the transform faults.
-  subsection Minimum refinement function
-    set Coordinate system = cartesian
-    set Function expression = if((x<60000 && x>40000 && y>45000 && z>70000) || (x<210000 && x>190000 && y<=55000 && z>70000) || ((x>40000 && x<210000 && y>40000 && y<60000 && z>70000)), 6, 4)
-    set Variable names = x,y,z
-  end
-end
-
-# The model does not include any heating terms.
-subsection Heating model
-  set List of model names =
-end
-
-# Below, we describe the variables we want to include in the graphical output.
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, mass flux statistics
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt fraction
-    set Point-wise stress and strain  = true
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set Time between graphical output = 1e5
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, thermal conductivity
-    end
-  end
-end
diff --git a/cookbooks/van-keken-vof/doc/amr.part.prm.bak b/cookbooks/van-keken-vof/doc/amr.part.prm.bak
deleted file mode 100644
index 5dab825f0a7..00000000000
--- a/cookbooks/van-keken-vof/doc/amr.part.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = volume of fluid interface
-  set Initial global refinement          = 6
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
diff --git a/cookbooks/van-keken-vof/doc/main.part.prm.bak b/cookbooks/van-keken-vof/doc/main.part.prm.bak
deleted file mode 100644
index 27ad1a66648..00000000000
--- a/cookbooks/van-keken-vof/doc/main.part.prm.bak
+++ /dev/null
@@ -1,19 +0,0 @@
-subsection Compositional fields
-  set Number of fields = 1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Initial composition model
-  set Model name = function
-  set Volume of fluid initialization type = C_1:level set
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.2+0.02*cos(pi*x/0.9142)-z
-  end
-end
diff --git a/cookbooks/van-keken-vof/doc/postprocess.part.prm.bak b/cookbooks/van-keken-vof/doc/postprocess.part.prm.bak
deleted file mode 100644
index 7783beaae07..00000000000
--- a/cookbooks/van-keken-vof/doc/postprocess.part.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set List of output variables      = volume of fluid values
-    set Output format                 = vtu
-    set Time between graphical output = 100
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/cookbooks/van-keken-vof/doc/variation.part.prm.bak b/cookbooks/van-keken-vof/doc/variation.part.prm.bak
deleted file mode 100644
index 7a9ef22da72..00000000000
--- a/cookbooks/van-keken-vof/doc/variation.part.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-subsection Initial composition model
-  set Model name = function
-  set Volume of fluid initialization type = C_1:level set
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926, a=0.02
-    set Function expression = 0.2+a*cos(pi*x/0.9142)-z
-  end
-end
diff --git a/cookbooks/van-keken-vof/van-keken-vof.prm.bak b/cookbooks/van-keken-vof/van-keken-vof.prm.bak
deleted file mode 100644
index 8ad9be7a63e..00000000000
--- a/cookbooks/van-keken-vof/van-keken-vof.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# A description of the van Keken et al. thermochemical composition benchmark. See the manual for more
-# information.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 2000
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output-van-keken-vof
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Initial composition model
-  set Model name = function
-  set Volume of fluid initialization type = C_1:level set
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression  =  0.2+0.02*cos(pi*x/0.9142)-z
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = volume of fluid interface
-  set Initial global refinement          = 6
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics
-
-  subsection Visualization
-    set List of output variables      = volume of fluid values
-    set Output format                 = vtu
-    set Time between graphical output = 100
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/cookbooks/van-keken/doc/main.part.prm.bak b/cookbooks/van-keken/doc/main.part.prm.bak
deleted file mode 100644
index d63eb35aab1..00000000000
--- a/cookbooks/van-keken/doc/main.part.prm.bak
+++ /dev/null
@@ -1,19 +0,0 @@
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.14159
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-end
diff --git a/cookbooks/van-keken/doc/postprocess.part.prm.bak b/cookbooks/van-keken/doc/postprocess.part.prm.bak
deleted file mode 100644
index 3c96e051be4..00000000000
--- a/cookbooks/van-keken/doc/postprocess.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Postprocess
-  set List of postprocessors = velocity statistics
-end
diff --git a/cookbooks/van-keken/doc/smooth.part.prm.bak b/cookbooks/van-keken/doc/smooth.part.prm.bak
deleted file mode 100644
index 055cc6480b4..00000000000
--- a/cookbooks/van-keken/doc/smooth.part.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.14159
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
diff --git a/cookbooks/van-keken/van-keken-discontinuous.prm.bak b/cookbooks/van-keken/van-keken-discontinuous.prm.bak
deleted file mode 100644
index 407f2a4cf9a..00000000000
--- a/cookbooks/van-keken/van-keken-discontinuous.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# A description of the van Keken et al. benchmark. See the manual for more
-# information.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 2000
-set Use years in output instead of seconds = false
-set CFL number                             = 1.0
-set Output directory                       = output-van-keken-discontinuous
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 7
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 100
-  end
-end
diff --git a/cookbooks/van-keken/van-keken-smooth.prm.bak b/cookbooks/van-keken/van-keken-smooth.prm.bak
deleted file mode 100644
index 1bf4eb236a3..00000000000
--- a/cookbooks/van-keken/van-keken-smooth.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 2000
-set Use years in output instead of seconds = false
-set CFL number                             = 1.0
-set Output directory                       = output-van-keken-smooth
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 7
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 100
-  end
-end
diff --git a/cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc.bak b/cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc.bak
deleted file mode 100644
index b0236866b0f..00000000000
--- a/cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc.bak
+++ /dev/null
@@ -1,367 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <deal.II/grid/manifold_lib.h>
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/grid_tools.h>
-#include <aspect/utilities.h>
-#include <deal.II/dofs/dof_tools.h>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    using namespace dealii;
-
-    /**
-     * A geometry model based on the 2D Cartesian van Keken 2008 subduction
-     * benchmark. A custom mesh that is better suited to deal with
-     * the unique constraints of this benchmark is necessary to obtain a
-     * continuous pressure field.
-     *
-     * Because this mesh is highly specific, many of these functions are
-     * present only because of the way that we need to interface with the
-     * GeometryModel class, but they return nothing.
-     */
-
-    template <int dim>
-    class vanKeken : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        vanKeken();
-
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         */
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
-
-        double length_scale () const override;
-
-        /**
-         * Return the depth that corresponds to the given
-         * position. The documentation of the base class (see
-         * GeometryModel::Interface::depth()) describes in detail how
-         * "depth" is interpreted in general.
-         */
-        double depth(const Point<dim> &position) const override;
-
-
-        double height_above_reference_surface(const Point<dim> &position) const override;
-
-        /**
-         * @copydoc Interface<dim>::representative_point()
-         */
-        Point<dim> representative_point(const double depth) const override;
-
-        /**
-         * @copydoc Interface<dim>::maximal_depth()
-         */
-        double maximal_depth() const override;
-
-        /**
-         * Return the set of boundary indicators that are used by this model.
-         * This information is used to determine what boundary indicators can
-         * be used in the input file.
-         */
-        std::set<types::boundary_id>
-        get_used_boundary_indicators () const override;
-
-        /**
-         * Return symbolic names for all boundary components. Their names are
-         * described in the documentation of this plugin, at the bottom of the
-         * .cc file.
-         */
-        std::map<std::string,types::boundary_id>
-        get_symbolic_boundary_names_map () const override;
-
-        /**
-         * Return whether the given point lies within the domain specified
-         * by the geometry. This function does not take into account
-         * initial or dynamic surface topography.
-         */
-        bool
-        point_is_in_domain(const Point<dim> &point) const override;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is,
-         * which in this case is cartesian.
-         */
-        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
-
-        /**
-         * Declare the parameters this class takes through input files. However,
-         * for this geometry there are no parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * Again, there are no parameters to be declared for this class.
-         */
-        void
-        parse_parameters (ParameterHandler &) override;
-    };
-
-
-
-    template <int dim>
-    vanKeken<dim>::vanKeken()
-    {}
-
-    template <>
-    void
-    vanKeken<2>::
-    create_coarse_mesh (parallel::distributed::Triangulation<2> &coarse_grid) const
-    {
-      const std::vector<Point<2>> vertices =
-      {
-        //   0            1             2             3             4
-        {0.0, 0.0}, {50e3, 0.0}, {330e3, 0.0}, {600e3, 0.0}, {660e3, 0.0},
-        //   5              6               7               8               9
-        {0.0, 300e3}, {50e3, 300e3}, {233e3, 183e3}, {330e3, 270e3}, {660e3, 270e3},
-        //    10             11            12              13
-        {50e3, 550e3}, {660e3, 550e3}, {0.0, 600e3}, {660e3, 600e3}
-      };
-
-      // Next, we have to define the cells and the vertices they contain.
-      const std::vector<std::array<int, GeometryInfo<2>::vertices_per_cell>>
-      cell_vertices =
-      {
-        {{0, 1, 5, 6}},
-        {{8, 9, 10, 11}},
-        {{10, 11, 12, 13}},
-        {{1, 2, 6, 7}},
-        {{2, 3, 7, 8}},
-        {{3, 4, 8, 9}},
-        {{5, 6, 12, 10}},
-        {{6, 7, 10, 8}}
-      };
-
-      std::vector<CellData<2>> cells(cell_vertices.size(), CellData<2>());
-      for (unsigned int i = 0; i < cell_vertices.size(); ++i)
-        {
-          for (unsigned int j = 0; j < cell_vertices[i].size(); ++j)
-            cells[i].vertices[j] = cell_vertices[i][j];
-          cells[i].material_id = 0;
-        }
-
-      // Here we define the boundaries and the corresponding boundary id
-      // explicitly, based on the vertices that lie on them
-      SubCellData subcell_data;
-      subcell_data.boundary_lines.resize(10);
-
-      subcell_data.boundary_lines[0].vertices = {0,1};
-      subcell_data.boundary_lines[0].boundary_id = 0;
-
-      subcell_data.boundary_lines[1].vertices = {1,2};
-      subcell_data.boundary_lines[1].boundary_id = 0;
-
-      subcell_data.boundary_lines[2].vertices = {2,3};
-      subcell_data.boundary_lines[2].boundary_id = 0;
-
-      subcell_data.boundary_lines[3].vertices = {3,4};
-      subcell_data.boundary_lines[3].boundary_id = 0;
-
-      subcell_data.boundary_lines[4].vertices = {4,9};
-      subcell_data.boundary_lines[4].boundary_id = 3;
-
-      subcell_data.boundary_lines[5].vertices = {9,11};
-      subcell_data.boundary_lines[5].boundary_id = 3;
-
-      subcell_data.boundary_lines[6].vertices = {11,13};
-      subcell_data.boundary_lines[6].boundary_id = 3;
-
-      subcell_data.boundary_lines[7].vertices = {13,12};
-      subcell_data.boundary_lines[7].boundary_id = 1;
-
-      subcell_data.boundary_lines[8].vertices = {12,5};
-      subcell_data.boundary_lines[8].boundary_id = 2;
-
-      subcell_data.boundary_lines[9].vertices = {5,0};
-      subcell_data.boundary_lines[9].boundary_id = 2;
-
-      GridTools::consistently_order_cells(cells);
-
-      // Then create the actual mesh:
-      coarse_grid.create_triangulation(vertices, cells, subcell_data);
-    }
-
-
-    // Not allow to be 3D
-    template <>
-    void
-    vanKeken<3>::
-    create_coarse_mesh (parallel::distributed::Triangulation<3> &) const
-    {
-      Assert (false, ExcNotImplemented());
-    }
-
-
-    template <int dim>
-    std::set<types::boundary_id>
-    vanKeken<dim>::
-    get_used_boundary_indicators () const
-    {
-      std::set<types::boundary_id> s;
-      for (unsigned int i=0; i<2*dim; ++i)
-        s.insert (i);
-      return s;
-    }
-
-
-
-    template <>
-    std::map<std::string,types::boundary_id>
-    vanKeken<2>::
-    get_symbolic_boundary_names_map () const
-    {
-      static const std::pair<std::string,types::boundary_id> mapping[]
-        = { std::pair<std::string,types::boundary_id> ("bottom", 0),
-            std::pair<std::string,types::boundary_id> ("top", 1),
-            std::pair<std::string,types::boundary_id> ("left",  2),
-            std::pair<std::string,types::boundary_id> ("right", 3)
-          };
-      return std::map<std::string,types::boundary_id> (std::begin(mapping),
-                                                       std::end(mapping));
-    }
-
-    template <>
-    std::map<std::string,types::boundary_id>
-    vanKeken<3>::
-    get_symbolic_boundary_names_map () const
-    {
-      Assert (false, ExcNotImplemented());
-      std::map<std::string,types::boundary_id> empty;
-      return empty;
-    }
-
-
-
-    template <int dim>
-    double
-    vanKeken<dim>::
-    length_scale () const
-    {
-      return 1e4;
-    }
-
-    template <int dim>
-    double
-    vanKeken<dim>::depth(const Point<dim> &position) const
-    {
-      // Get the surface x (,y) point
-      Point<dim-1> surface_point;
-      for (unsigned int d=0; d<dim-1; ++d)
-        surface_point[d] = position[d];
-
-      Assert(dim==2, ExcNotImplemented());
-      const double y_extent = 600e3;
-      const double d = y_extent - (position(dim-1));
-      return std::min (std::max (d, 0.), maximal_depth());
-    }
-
-
-
-    template <int dim>
-    double
-    vanKeken<dim>::height_above_reference_surface(const Point<dim> &) const
-    {
-      return 0.0;
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    vanKeken<dim>::representative_point(const double depth) const
-    {
-      Point<dim> p;
-      p(dim-1) = depth;
-      return p;
-    }
-
-
-
-    template <int dim>
-    double
-    vanKeken<dim>::maximal_depth() const
-    {
-      return 600e3;
-    }
-
-
-
-    template <int dim>
-    bool
-    vanKeken<dim>::point_is_in_domain(const Point<dim> &) const
-    {
-      return true;
-    }
-
-
-    template <int dim>
-    aspect::Utilities::Coordinates::CoordinateSystem
-    vanKeken<dim>::natural_coordinate_system() const
-    {
-      return aspect::Utilities::Coordinates::CoordinateSystem::cartesian;
-    }
-
-
-
-    template <int dim>
-    void
-    vanKeken<dim>::declare_parameters (ParameterHandler &)
-    {}
-
-
-
-    template <int dim>
-    void
-    vanKeken<dim>::parse_parameters (ParameterHandler &)
-    {}
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    ASPECT_REGISTER_GEOMETRY_MODEL(vanKeken,
-                                   "vanKeken box",
-                                   "A specialized geometry model used for the van Keken 2008 "
-                                   "corner flow style subduction benchmark. While the geometry "
-                                   "described by this plugin is just a square, a mesh consisting of non-square cells "
-                                   "is required to allow the boundaries of the mesh to lie along "
-                                   "the slab-mantle wedge interface, which allows the pressure "
-                                   "solution to be continuous."
-                                  )
-  }
-}
diff --git a/cookbooks/vankeken_subduction/vankeken_corner_flow.prm.bak b/cookbooks/vankeken_subduction/vankeken_corner_flow.prm.bak
deleted file mode 100644
index 67f8fb1fdfc..00000000000
--- a/cookbooks/vankeken_subduction/vankeken_corner_flow.prm.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-# This is a cookbook which aims to replicate the corner flow style subduction outlined
-# in van Keken et al., 2008. In this cookbook, a slab with a thermal age of 50 Myr is
-# subducted beneath a 50 km thick overriding plate at a constant dip of 45 degrees. The
-# velocity is prescribed to be 5 cm/yr in the subducting plate, and 0 in the overriding
-# plate. Due to these constraints, and the way that ASPECT usually generates a mesh,
-# a custom mesh is used to prevent an ill-posed pressure solution at the triple point
-# intersection between the mantle wedge, overriding plate, and down going plate.
-
-# Load the prescribed velocity and pressure library
-set Additional shared libraries            = ./plugin/libvankeken_subduction.so
-set Dimension                              = 2
-set Output directory                       = vankeken-output
-set Use years in output instead of seconds = true
-set Pressure normalization                 = no
-set Surface pressure                       = 0
-set Use conduction timestep                = true
-set End time                               = 3.4e8
-set Resume computation                     = false
-set Adiabatic surface temperature          = 1600
-
-# Turn prescribed velocities on, this is necessary for the subducting
-# and overriding plates.
-set Prescribe internal velocities = true
-
-# Solver parameters
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type                              = block AMG
-    set Maximum number of expensive Stokes solver steps = 1000
-  end
-end
-
-# q2q1 discretization
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-  set Use locally conservative discretization = false
-end
-
-# Incompressible
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# Use the specialized geometry model for this cookbook
-subsection Geometry model
-  set Model name = vanKeken box
-end
-
-# Checkpoint every 200 steps
-subsection Checkpointing
-  set Steps between checkpoint = 200
-end
-
-# Prescribe a half space cooling model on the left boundary and in the overriding plate
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y,t
-
-    # H is the model Y extent, Hl is the overriding plate thickness, TS is the surface temperature
-    # T0 is the temperature at the base of the slab
-    set Function constants = H=6.0e5, Hl=5.0e4, TS=273.0, T0=1573.0, kappa=0.7272e-6, t50=1.5778463e15
-    set Function expression = if(x<=(H-y),TS+(T0-TS)*(1.0-erfc( (H-y)/(2.0*sqrt(kappa*t50))) ), \
-                              if(x>(H-y) & y>(H-Hl), TS+(T0-TS)*(H-y)/Hl, \
-                                T0 ) )
-  end
-end
-
-# Bottom and right boundary is open
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = bottom:zero traction
-end
-
-# Keep the temperature fixed on the left, top and right boundaries
-subsection Boundary temperature model
-  set List of model names                           = initial temperature
-  set Fixed temperature boundary indicators         = top, left, right
-end
-
-# Prescribe a velocity of 5 cm/yr on the left boundary, 0 on the top
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left: function, top:function
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = H=6.01e5, v=0.035355339
-    set Function expression = if( x<=(H-y), v, 0.0) ; \
-                              if( x<=(H-y),-v, 0.0 )
-  end
-end
-
-# No gravity
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.
-  end
-end
-
-# Use the visco plastic material model and specify and isoviscous material with
-# a viscosiy of 1e20 Pa s
-subsection Material model
-  set Model name         = simpler
-
-  subsection Simpler model
-    set Reference density             = 3300.0
-    set Thermal expansion coefficient = 0.000035
-    set Thermal conductivity          = 3.0
-    set Viscosity                     = 1e20
-    set Reference specific heat       = 1250.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Run postprocessors on initial refinement = true
-  set Refinement fraction                      = 1.0
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Prescribed velocities
-  subsection Indicator function
-    set Variable names = x,y,t
-
-    # Return where to prescribe u_x; u_y
-    # 1 if velocity should be prescribed, 0 otherwise
-
-    set Function constants  = H=6.0e5, W=6.6e5, de=100
-    set Function expression = if( abs(H-y-x)<=de | (y>=601e3 - x  & y>=550e3), 1, 0); \
-                              if( abs(H-y-x)<=de | (y>=601e3 - x  & y>=550e3), 1, 0)
-  end
-
-  subsection Velocity function
-    set Variable names = x,y,t
-
-    # Return the prescribed u_x; u_y;
-    set Function constants  = H=6.0e5, W=6.6e5, de=100, v=0.035355339, s2yr=31557600
-    set Function expression = if(abs(H-y-x)<=de, v/s2yr, 0.0); \
-                              if(abs(H-y-x)<=de, -v/s2yr, 0.0)
-  end
-end
-
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, velocity statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, stress second invariant, heat flux map, depth
-    set Output format = vtu
-    set Interpolate output = true
-    set Time between graphical output = 1e7
-  end
-end
diff --git a/cookbooks/visualizing_phase_diagram/doc/harzburgite.prm.bak b/cookbooks/visualizing_phase_diagram/doc/harzburgite.prm.bak
deleted file mode 100644
index 42ac5feb2bc..00000000000
--- a/cookbooks/visualizing_phase_diagram/doc/harzburgite.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-# initial composition model
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Function expression = 1.0  # change this to one
-  end
-end
diff --git a/cookbooks/visualizing_phase_diagram/doc/material_model.prm.bak b/cookbooks/visualizing_phase_diagram/doc/material_model.prm.bak
deleted file mode 100644
index a25c3ad00d5..00000000000
--- a/cookbooks/visualizing_phase_diagram/doc/material_model.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Maximum viscosity = 1e24
-    set Phase transition depths = background:410e3|520e3|560e3|670e3|670e3|670e3|670e3, spharz: 410e3|520e3|560e3|670e3|670e3|670e3|670e3
-    set Phase transition widths = background:5e3|5e3|5e3|5e3|5e3|5e3|5e3, spharz: 5e3|5e3|5e3|5e3|5e3|5e3|5e3
-    set Phase transition temperatures = background:1662.0|1662.0|1662.0|1662.0|1662.0|1662.0|1662.0, spharz: 1662.0|1662.0|1662.0|1662.0|1662.0|1662.0|1662.0
-    set Phase transition Clapeyron slopes = background:4e6|4.1e6|4e6|-2e6|4e6|-3.1e6|1.3e6, spharz: 4e6|4.1e6|4e6|-2e6|4e6|-3.1e6|1.3e6
-    set Densities = 3300.0
-    set Heat capacities = background: 3300.0|3394.4|3442.1|3453.2|3617.6|3691.5|3774.7|3929.1, spharz: 3235.0|3372.3|3441.7|3441.7|3680.8|3717.8|3759.4|3836.6
-    set Thermal expansivities = 0.0
-  end
-end
diff --git a/cookbooks/visualizing_phase_diagram/doc/steinberg.prm.bak b/cookbooks/visualizing_phase_diagram/doc/steinberg.prm.bak
deleted file mode 100644
index 3c01f3bd620..00000000000
--- a/cookbooks/visualizing_phase_diagram/doc/steinberg.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                                = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
-    set Material file names                           = pyr-ringwood88.txt
-    set Radial viscosity file name                    = radial-visc.txt
-    set Maximum lateral viscosity variation           = 1e2
-    set Maximum viscosity                             = 1e23
-    set Minimum viscosity                             = 1e19
-    set Use lateral average temperature for viscosity = true
-    set Number lateral average bands                  = 10
-    set Bilinear interpolation                        = true
-    set Latent heat                                   = false
-  end
-end
diff --git a/cookbooks/visualizing_phase_diagram/visualizing_phase_diagram.prm.bak b/cookbooks/visualizing_phase_diagram/visualizing_phase_diagram.prm.bak
deleted file mode 100644
index dd7743d98ff..00000000000
--- a/cookbooks/visualizing_phase_diagram/visualizing_phase_diagram.prm.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-# This prm file is used to generate a phase diagram.
-# This could be useful for densities, viscosities in a material model.
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Adiabatic surface temperature          = 1673.0
-set Output directory                       = output
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme = no Advection, no Stokes
-
-# Model geometry
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 50
-    set Y repetitions = 50
-    set X extent      = 800e3
-    set Y extent      = 800e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = left, right
-  set List of model names = box
-
-  subsection Box
-    set Left temperature   = 273
-    set Right temperature  = 2273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y
-    set Function constants = XMAX=800e3, Tl=273.0, Tr=2273
-    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
-  end
-end
-
-# Uncomment this part for Steinberger model and pyrolitic lookup table
-#subsection Material model
-#  set Model name = Steinberger
-#  subsection Steinberger model
-#    set Data directory                                = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-#    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
-#    set Material file names                           = pyr-ringwood88.txt
-#    set Radial viscosity file name                    = radial-visc.txt
-#
-#    set Maximum lateral viscosity variation           = 1e2
-#    set Maximum viscosity                             = 1e23
-#    set Minimum viscosity                             = 1e19
-#
-#    set Use lateral average temperature for viscosity = true
-#    set Number lateral average bands                  = 10
-#
-#    set Bilinear interpolation                        = true
-#    set Latent heat                                   = false
-#  end
-#end
-
-# Comment the following 3 sections for steinberg model and pyrolitic lookup table
-# Fields of composition
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = spharz
-  set Compositional field methods = field
-end
-
-# Initial composition model
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Function expression = 0.0
-  end
-end
-
-# Value for material model
-# Set Densities to a constant value and thermal expansivity to 0.0 to have a constant pressure gradient
-# Set Values of Heat capacities to values of reference densities of pyrolitic phases
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Maximum viscosity = 1e24
-    set Phase transition depths = background:410e3|520e3|560e3|670e3|670e3|670e3|670e3, spharz: 410e3|520e3|560e3|670e3|670e3|670e3|670e3
-    set Phase transition widths = background:5e3|5e3|5e3|5e3|5e3|5e3|5e3, spharz: 5e3|5e3|5e3|5e3|5e3|5e3|5e3
-    set Phase transition temperatures = background:1662.0|1662.0|1662.0|1662.0|1662.0|1662.0|1662.0, spharz: 1662.0|1662.0|1662.0|1662.0|1662.0|1662.0|1662.0
-    set Phase transition Clapeyron slopes = background:4e6|4.1e6|4e6|-2e6|4e6|-3.1e6|1.3e6, spharz: 4e6|4.1e6|4e6|-2e6|4e6|-3.1e6|1.3e6
-    set Densities = 3300.0
-    set Heat capacities = background: 3300.0|3394.4|3442.1|3453.2|3617.6|3691.5|3774.7|3929.1, spharz: 3235.0|3372.3|3441.7|3441.7|3680.8|3717.8|3759.4|3836.6
-    set Thermal expansivities = 0.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom, left, right
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format                 = vtu
-    set List of output variables      = density, thermal expansivity, specific heat
-    set Time between graphical output = 0e6
-  end
-end
diff --git a/doc/logo/logo.prm.bak b/doc/logo/logo.prm.bak
deleted file mode 100644
index 6ce430cd233..00000000000
--- a/doc/logo/logo.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-# A simple setup for convection in a 2d shell.
-# This model was used to generate ASPECT's logo, which can be recreated using
-# the ASPECT version and dependencies specified below, and using the paraview
-# state file and the output file in output/ and ParaView version 5.8.1.
-# Alternatively the docker image gassmoeller/aspect-logo contains this version
-# of ASPECT as a precompiled binary.  The docker image can be rebuild from the
-# Dockerfile in this path.
-#
-# To recreate the output in paraview, load the state, adjust the file paths,
-# and create a screenshot without the mesh with 4x the suggested resolution on
-# a 1080p screen (6160 x 3176 px) and with a transparent background.
-# For the mesh output disable the background, enable the mesh, and create a
-# screenshot with 2x the suggested resolution on a 1080p screen (3080 x 1588
-# px). Then crop the resulting figures to content and use in the .svg.
-#
-#-----------------------------------------------------------------------------
-#-- This is ASPECT, the Advanced Solver for Problems in Earth's ConvecTion.
-#--     . version 2.2.0-pre (master, 148bb56fe)
-#--     . using deal.II 9.0.1
-#--     .       with 32 bit indices and vectorization level 1 (128 bits)
-#--     . using Trilinos 12.10.1
-#--     . using p4est 2.0.0
-#--     . running in OPTIMIZED mode
-#--     . running with 6 MPI processes
-#-----------------------------------------------------------------------------
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Output directory                       = output-logo
-set Use conduction timestep                = true
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 2e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6371000
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = \
-      top: 273, bottom: 4273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1973
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 2
-  set Refinement fraction                = 0.6
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 3
-  set Minimum refinement level = 3
-end
-
-# We increase the solver tolerance to speed things up
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-3
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 6.51092e8
-    set Number of grouped files       = 1
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria = end step
-  set End step = 1430
-end
diff --git a/doc/manual/cookbooks/overview/doc/boundary-conditions.part.prm.bak b/doc/manual/cookbooks/overview/doc/boundary-conditions.part.prm.bak
deleted file mode 100644
index e48524ae495..00000000000
--- a/doc/manual/cookbooks/overview/doc/boundary-conditions.part.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
diff --git a/doc/manual/cookbooks/overview/doc/dim.part.prm.bak b/doc/manual/cookbooks/overview/doc/dim.part.prm.bak
deleted file mode 100644
index 03df82cc72b..00000000000
--- a/doc/manual/cookbooks/overview/doc/dim.part.prm.bak
+++ /dev/null
@@ -1 +0,0 @@
-set Dimension                     = 2
diff --git a/doc/manual/cookbooks/overview/doc/geometry.part.prm.bak b/doc/manual/cookbooks/overview/doc/geometry.part.prm.bak
deleted file mode 100644
index 2e755469d64..00000000000
--- a/doc/manual/cookbooks/overview/doc/geometry.part.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-set Dimension = 2
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
diff --git a/doc/manual/cookbooks/overview/doc/gmg-average.part.prm.bak b/doc/manual/cookbooks/overview/doc/gmg-average.part.prm.bak
deleted file mode 100644
index 7cad0231baf..00000000000
--- a/doc/manual/cookbooks/overview/doc/gmg-average.part.prm.bak
+++ /dev/null
@@ -1,3 +0,0 @@
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/doc/manual/cookbooks/overview/doc/gmg-enable.part.prm.bak b/doc/manual/cookbooks/overview/doc/gmg-enable.part.prm.bak
deleted file mode 100644
index e4097ad02cc..00000000000
--- a/doc/manual/cookbooks/overview/doc/gmg-enable.part.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/doc/manual/cookbooks/overview/doc/simple.prm.bak b/doc/manual/cookbooks/overview/doc/simple.prm.bak
deleted file mode 100644
index b5eec069e06..00000000000
--- a/doc/manual/cookbooks/overview/doc/simple.prm.bak
+++ /dev/null
@@ -1,16 +0,0 @@
-set Dimension                     = 2
-set End time                      = 1.5e9
-set Output directory              = output
-
-subsection Geometry model
-  set Model name                  = spherical shell
-end
-
-subsection Mesh refinement
-  set Initial global refinement   = 4
-  set Initial adaptive refinement = 1
-end
-
-subsection Postprocess
-  set List of postprocessors      = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-end
diff --git a/doc/manual/cookbooks/overview/doc/structure.part.prm.bak b/doc/manual/cookbooks/overview/doc/structure.part.prm.bak
deleted file mode 100644
index 08f98273467..00000000000
--- a/doc/manual/cookbooks/overview/doc/structure.part.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-set Dimension                     = 2
-set Resume computation            = false
-set End time                      = 1e10
-set CFL number                    = 1.0
-set Output directory              = output
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 1
-  set Initial global refinement   = 4
-end
-
-subsection Material model
-  set Model name                  = simple
-
-  subsection Simple model
-    set Reference density         = 3300
-    set Reference temperature     = 293
-    set Viscosity                 = 5e24
-  end
-end
diff --git a/doc/manual/empty.prm.bak b/doc/manual/empty.prm.bak
deleted file mode 100644
index b24c465d5e6..00000000000
--- a/doc/manual/empty.prm.bak
+++ /dev/null
@@ -1,32 +0,0 @@
-# this nearly empty .prm is used to generate parameters.tex
-# by running aspect.
-# sadly we need to set a few where there are no default values:
-
-set End time = 0.0
-
-subsection Geometry model
-  set Model name = box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = left, right, bottom, top
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/include/aspect/adiabatic_conditions/ascii_data.h.bak b/include/aspect/adiabatic_conditions/ascii_data.h.bak
deleted file mode 100644
index fc9ca54d8e2..00000000000
--- a/include/aspect/adiabatic_conditions/ascii_data.h.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_adiabatic_conditions_ascii_data_h
-#define _aspect_adiabatic_conditions_ascii_data_h
-
-
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/point.h>
-
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    using namespace dealii;
-
-    /**
-     * A simple class that reads adiabatic conditions from a file.
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataProfile<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. Because this function is called after
-         * initializing the SimulatorAccess, all of the necessary information
-         * is available to calculate the adiabatic profile. It computes the
-         * adiabatic conditions along a vertical transect of the geometry
-         * based on the given material model and other quantities.
-         */
-        void initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataProfile<dim>::initialize;
-
-        /**
-         * Some plugins need to know whether the adiabatic conditions are
-         * already calculated. This is for example the case for the simple
-         * compressible material model, which uses the adiabatic temperature
-         * as reference temperature to calculate the density. For the
-         * calculation of the adiabatic conditions this functionality is
-         * simply switched off, because we are always on the reference
-         * profile. This way the plugin behaves differently at initialization
-         * time of the adiabatic conditions and during the main model run.
-         */
-        bool is_initialized() const override;
-
-        /**
-         * Return the adiabatic temperature at a given point of the domain.
-         */
-        double temperature (const Point<dim> &p) const override;
-
-        /**
-         * Return the adiabatic pressure at a given point of the domain.
-         */
-        double pressure (const Point<dim> &p) const override;
-
-        /**
-         * Return the reference density at a given point of the domain.
-         */
-        double density (const Point<dim> &p) const override;
-
-        /**
-         * Return the derivative of the density with respect to depth
-         * at the given point @p p.
-         */
-        double density_derivative (const Point<dim> &p) const override;
-
-        /**
-         * Declare the parameters for the input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler  &prm);
-
-        /**
-         * Read the parameters from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * Whether the adiabatic conditions are already calculated. This is
-         * important for plugins that are used by the adiabatic conditions but
-         * also depend on the adiabatic conditions. This way they can behave
-         * differently in initialization and model run.
-         */
-        bool initialized;
-
-        /**
-         * The column indices of the temperature, pressure, and density column
-         * in the data file.
-         */
-        unsigned int temperature_index;
-        unsigned int pressure_index;
-        unsigned int density_index;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/adiabatic_conditions/compute_entropy_profile.h.bak b/include/aspect/adiabatic_conditions/compute_entropy_profile.h.bak
deleted file mode 100644
index 77d6d7a4dc5..00000000000
--- a/include/aspect/adiabatic_conditions/compute_entropy_profile.h.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_adiabatic_conditions_compute_entropy_profile_h
-#define _aspect_adiabatic_conditions_compute_entropy_profile_h
-
-
-#include <aspect/adiabatic_conditions/interface.h>
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    using namespace dealii;
-
-    /**
-     * A model in which the adiabatic profile is
-     * calculated by solving the hydrostatic equations for
-     * pressure and entropy in depth.
-     * Of course the entropy along an adiabat is constant.
-     * This plugin requires the material model to provide an
-     * additional output object of type PrescribedTemperatureOutputs.
-     * It also requires that there is a compositional field named
-     * 'entropy' that represents the entropy of the material.
-     */
-    template <int dim>
-    class ComputeEntropyProfile : public Interface<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        ComputeEntropyProfile ();
-
-        /**
-         * Initialization function. Because this function is called after
-         * initializing the SimulatorAccess, all of the necessary information
-         * is available to calculate the adiabatic profile. It computes the
-         * adiabatic conditions along a vertical transect of the geometry
-         * based on the given material model and other quantities.
-         */
-        void initialize () override;
-
-        /**
-         * Some plugins need to know whether the adiabatic conditions are
-         * already calculated. This is for example the case for the simple
-         * compressible material model, which uses the adiabatic temperature
-         * as reference temperature to calculate the density. For the
-         * calculation of the adiabatic conditions this functionality is
-         * simply switched off, because we are always on the reference
-         * profile. This way the plugin behaves differently at initialization
-         * time of the adiabatic conditions and during the main model run.
-         */
-        bool is_initialized() const override;
-
-        /**
-         * Return the adiabatic temperature at a given point of the domain.
-         */
-        double temperature (const Point<dim> &p) const override;
-
-        /**
-         * Return the adiabatic pressure at a given point of the domain.
-         */
-        double pressure (const Point<dim> &p) const override;
-
-        /**
-         * Return the reference density at a given point of the domain.
-         */
-        double density (const Point<dim> &p) const override;
-
-        /**
-         * Return the derivative of the density with respect to depth
-         * at the given point @p p.
-         */
-        double density_derivative (const Point<dim> &p) const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Whether the adiabatic conditions are already calculated. This is
-         * important for plugins that are used by the adiabatic conditions but
-         * also depend on the adiabatic conditions. This way they can behave
-         * differently in initialization and model run.
-         */
-        bool initialized;
-
-        /**
-         * Number of points at which we compute the adiabatic values.
-         */
-        unsigned int n_points;
-
-        /**
-         * Starting entropy for the profile.
-         */
-        double surface_entropy;
-
-        /**
-         * Vectors of values of temperatures and pressures on a transect into
-         * depth at which we have computed them. The public member functions
-         * of this class interpolate linearly between these points.
-         */
-        std::vector<double> temperatures;
-        std::vector<double> pressures;
-        std::vector<double> densities;
-
-        /**
-         * Interval spacing between each two data points in the tables above
-         * with regard to the depth coordinate.
-         */
-        double delta_z;
-
-        /**
-         * Internal helper function. Returns the reference property at a
-         * given point of the domain.
-         */
-        double get_property (const Point<dim> &p,
-                             const std::vector<double> &property) const;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/adiabatic_conditions/compute_profile.h.bak b/include/aspect/adiabatic_conditions/compute_profile.h.bak
deleted file mode 100644
index d0d2f01e76b..00000000000
--- a/include/aspect/adiabatic_conditions/compute_profile.h.bak
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_adiabatic_conditions_compute_profile_h
-#define _aspect_adiabatic_conditions_compute_profile_h
-
-
-#include <aspect/adiabatic_conditions/interface.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    using namespace dealii;
-
-    /**
-     * A model in which the adiabatic profile is calculated by solving the
-     * hydrostatic equations for pressure and temperature in depth. The
-     * gravity is assumed to be in depth direction and the composition is
-     * either given by the initial composition at reference points or computed
-     * as a reference depth-function. All material parameters are computed by
-     * the material model plugin. The surface conditions are either constant
-     * or changing over time as prescribed by an user-provided function.
-     */
-    template <int dim>
-    class ComputeProfile : public Interface<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        ComputeProfile ();
-
-        /**
-         * Initialization function. Because this function is called after
-         * initializing the SimulatorAccess, all of the necessary information
-         * is available to calculate the adiabatic profile. It computes the
-         * adiabatic conditions along a vertical transect of the geometry
-         * based on the given material model and other quantities.
-         */
-        void initialize () override;
-
-        /**
-         * Update function. By default does nothing, but if a time-dependent
-         * surface condition function is used, this will reinitialize the
-         * adiabatic profile with the current conditions.
-         */
-        void update () override;
-
-        /**
-         * Some plugins need to know whether the adiabatic conditions are
-         * already calculated. This is for example the case for the simple
-         * compressible material model, which uses the adiabatic temperature
-         * as reference temperature to calculate the density. For the
-         * calculation of the adiabatic conditions this functionality is
-         * simply switched off, because we are always on the reference
-         * profile. This way the plugin behaves differently at initialization
-         * time of the adiabatic conditions and during the main model run.
-         */
-        bool is_initialized() const override;
-
-        /**
-         * Return the adiabatic temperature at a given point of the domain.
-         */
-        double temperature (const Point<dim> &p) const override;
-
-        /**
-         * Return the adiabatic pressure at a given point of the domain.
-         */
-        double pressure (const Point<dim> &p) const override;
-
-        /**
-         * Return the reference density at a given point of the domain.
-         */
-        double density (const Point<dim> &p) const override;
-
-        /**
-         * Return the derivative of the density with respect to depth
-         * at the given point @p p.
-         */
-        double density_derivative (const Point<dim> &p) const override;
-
-        /**
-         * Declare the parameters for the input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * Whether the adiabatic conditions are already calculated. This is
-         * important for plugins that are used by the adiabatic conditions but
-         * also depend on the adiabatic conditions. This way they can behave
-         * differently in initialization and model run.
-         */
-        bool initialized;
-
-        /**
-         * Number of points at which we compute the adiabatic values.
-         */
-        unsigned int n_points;
-
-        /**
-         * Vectors of values of temperatures and pressures on a transect into
-         * depth at which we have computed them. The public member functions
-         * of this class interpolate linearly between these points.
-         */
-        std::vector<double> temperatures;
-        std::vector<double> pressures;
-        std::vector<double> densities;
-
-        /**
-         * Interval spacing between each two data points in the tables above
-         * with regard to the depth coordinate.
-         */
-        double delta_z;
-
-        /**
-         * An enum describing the different options to compute the reference
-         * profile for composition.
-         */
-        enum CompositionProfile
-        {
-          initial_composition,
-          reference_function
-        };
-
-        /**
-         * Selected option to compute the reference profile for composition.
-         */
-        CompositionProfile reference_composition;
-
-        /**
-         * Function object that computes the reference composition profile
-         * if the reference_composition variable is set to function.
-         */
-        std::unique_ptr<Functions::ParsedFunction<1>> composition_function;
-
-        /**
-         * Whether to use the surface_conditions_function to determine surface
-         * conditions, or the adiabatic_surface_temperature and surface_pressure
-         * parameters. If this is set to true the reference profile is updated
-         * every timestep.
-         */
-        bool use_surface_condition_function;
-
-        /**
-         * ParsedFunction: If provided in the input file it prescribes
-         * (surface pressure(t), surface temperature(t)).
-         */
-        Functions::ParsedFunction<1> surface_condition_function;
-
-        /**
-         * A shared pointer to the initial composition object
-         * that ensures that the current object can continue
-         * to access the initial composition object beyond the
-         * first time step.
-         */
-        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition_manager;
-
-        /**
-         * Internal helper function. Returns the reference property at a
-         * given point of the domain.
-         */
-        double get_property (const Point<dim> &p,
-                             const std::vector<double> &property) const;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/adiabatic_conditions/function.h.bak b/include/aspect/adiabatic_conditions/function.h.bak
deleted file mode 100644
index e124766473d..00000000000
--- a/include/aspect/adiabatic_conditions/function.h.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_adiabatic_conditions_function_h
-#define _aspect_adiabatic_conditions_function_h
-
-
-#include <aspect/adiabatic_conditions/interface.h>
-#include <deal.II/base/point.h>
-#include <deal.II/base/parsed_function.h>
-
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    using namespace dealii;
-
-    /**
-     * A simple class that sets the adiabatic conditions based on given
-     * a given function with three components: temperature, pressure, density.
-     */
-    template <int dim>
-    class Function : public Interface<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        Function ();
-
-        /**
-         * Initialization function.
-         */
-        void initialize () override;
-
-        /**
-         * Some plugins need to know whether the adiabatic conditions are
-         * already calculated, this is always true for the Function class.
-         */
-        bool is_initialized() const override;
-
-        /**
-         * Return the adiabatic temperature at a given point of the domain.
-         */
-        double temperature (const Point<dim> &p) const override;
-
-
-        /**
-         * Return the adiabatic pressure at a given point of the domain.
-         */
-        double pressure (const Point<dim> &p) const override;
-
-        /**
-         * Return the reference_density at a given point of the domain.
-         */
-        double density (const Point<dim> &p) const override;
-
-        /**
-         * Return the derivative of the density with respect to depth
-         * at the given point @p p.
-         */
-        double density_derivative (const Point<dim> &p) const override;
-
-        /**
-         * Declare the parameters for the input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * ParsedFunction: depth->(temperature, pressure, density)
-         */
-        Functions::ParsedFunction<1> function;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/adiabatic_conditions/interface.h.bak b/include/aspect/adiabatic_conditions/interface.h.bak
deleted file mode 100644
index 6f662e0bd9b..00000000000
--- a/include/aspect/adiabatic_conditions/interface.h.bak
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
-  Copyright (C) 2013 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_adiabatic_conditions_interface_h
-#define _aspect_adiabatic_conditions_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/distributed/tria.h>
-
-
-namespace aspect
-{
-  /**
-   * A namespace for the definition of things that have to do with describing
-   * the calculation of a reference adiabatic profile.
-   *
-   * @ingroup AdiabaticConditions
-   */
-  namespace AdiabaticConditions
-  {
-    using namespace dealii;
-
-    /**
-     * Base class for classes that describe adiabatic conditions,
-     * i.e. that starts at the top of the domain and integrate
-     * pressure and temperature as we go down into depth. There are
-     * several ways to do this (time-dependent or constant, using
-     * laterally averaged values or a reference profile), therefore we
-     * allow for user written plugins.
-     *
-     * @ingroup AdiabaticConditions
-     */
-    template <int dim>
-    class Interface: public SimulatorAccess<dim>, public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Some plugins need to know whether the adiabatic conditions are
-         * already calculated. Namely all plugins that are needed to create
-         * the adiabatic conditions but themselves depend on the adiabatic
-         * profile. Utilizing this function they may behave differently on
-         * initialization of the adiabatic conditions and at model runtime.
-         */
-        virtual
-        bool
-        is_initialized () const = 0;
-
-        /**
-         * Return the adiabatic temperature at a given point of the domain.
-         */
-        virtual
-        double temperature (const Point<dim> &p) const = 0;
-
-        /**
-         * Return the adiabatic pressure at a given point of the domain.
-         */
-        virtual
-        double pressure (const Point<dim> &p) const = 0;
-
-        /**
-         * Return the reference_density at a given point of the domain.
-         */
-        virtual
-        double density (const Point<dim> &p) const = 0;
-
-        /**
-         * Return the derivative of the density with respect to depth
-         * at the given point @p p.
-         */
-        virtual
-        double density_derivative (const Point<dim> &p) const = 0;
-
-        /**
-         * Return the adiabatic temperature profile as a vector of values
-         * corresponding to increasing depth.
-         *
-         * @param values The output vector of depth averaged values. The
-         * function takes the pre-existing size of this vector as the number
-         * of depth slices.
-         *
-         * @deprecated: This function is deprecated.
-         * Use the function temperature() for specific positions instead.
-         */
-        DEAL_II_DEPRECATED
-        virtual
-        void get_adiabatic_temperature_profile(std::vector<double> &values) const;
-
-        /**
-         * Like get_adiabatic_temperature_profile() but for the pressure.
-         *
-         * @deprecated: This function is deprecated.
-         * Use the function pressure() for specific positions instead.
-         */
-        DEAL_II_DEPRECATED
-        virtual
-        void get_adiabatic_pressure_profile(std::vector<double> &values) const;
-
-        /**
-         * Like get_adiabatic_temperature_profile() but for the density.
-         *
-         * @deprecated: This function is deprecated.
-         * Use the function density() for specific positions instead.
-         */
-        DEAL_II_DEPRECATED
-        virtual
-        void get_adiabatic_density_profile(std::vector<double> &values) const;
-
-        /**
-         * Like get_adiabatic_temperature_profile() but for the density derivative.
-         *
-         * @deprecated: This function is deprecated.
-         * Use the function density_derivative() for specific positions instead.
-         */
-        DEAL_II_DEPRECATED
-        virtual
-        void get_adiabatic_density_derivative_profile(std::vector<double> &values) const;
-    };
-
-
-    /**
-     * Register a adiabatic conditions model so that it can be selected from
-     * the parameter file.
-     *
-     * @param name A string that identifies the adiabatic conditions model
-     * @param description A text description of what this model does and that
-     * will be listed in the documentation of the parameter file.
-     * @param declare_parameters_function A pointer to a function that can be
-     * used to declare the parameters that this model wants to read from input
-     * files.
-     * @param factory_function A pointer to a function that can create an
-     * object of this adiabatic conditions model.
-     *
-     * @ingroup AdiabaticConditions
-     */
-    template <int dim>
-    void
-    register_adiabatic_conditions (const std::string &name,
-                                   const std::string &description,
-                                   void (*declare_parameters_function) (ParameterHandler &),
-                                   std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-    /**
-     * A function that given the name of a model returns a pointer to an
-     * object that describes it. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The model object returned is not yet initialized and has not read its
-     * runtime parameters yet.
-     *
-     * @ingroup AdiabaticConditions
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_adiabatic_conditions (ParameterHandler &prm);
-
-
-    /**
-     * Declare the runtime parameters of the registered adiabatic conditions
-     * model.
-     *
-     * @ingroup AdiabaticConditions
-     */
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm);
-
-
-    /**
-     * For the current plugin subsystem, write a connection graph of all of the
-     * plugins we know about, in the format that the
-     * programs dot and neato understand. This allows for a visualization of
-     * how all of the plugins that ASPECT knows about are interconnected, and
-     * connect to other parts of the ASPECT code.
-     *
-     * @param output_stream The stream to write the output to.
-     */
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &output_stream);
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a adiabatic conditions model, register it with the functions that
-     * can declare their parameters and create these objects.
-     *
-     * @ingroup AdiabaticConditions
-     */
-#define ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(classname, name, description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::AdiabaticConditions::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::AdiabaticConditions::register_adiabatic_conditions<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::AdiabaticConditions::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::AdiabaticConditions::register_adiabatic_conditions<3>, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_composition/ascii_data.h.bak b/include/aspect/boundary_composition/ascii_data.h.bak
deleted file mode 100644
index cfa883422fe..00000000000
--- a/include/aspect/boundary_composition/ascii_data.h.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_composition_ascii_data_h
-#define _aspect_boundary_composition_ascii_data_h
-
-#include <aspect/boundary_composition/interface.h>
-
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements prescribed boundary conditions determined from
-     * a AsciiData input file.
-     *
-     * @ingroup BoundaryCompositions
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataBoundary<dim>::initialize;
-
-        /**
-         * A function that is called at the beginning of each time step. For
-         * the current plugin, this function loads the next data files if
-         * necessary and outputs a warning if the end of the set of data files
-         * is reached.
-         */
-        void
-        update () override;
-
-        /**
-         * Return the boundary composition as a function of position. For the
-         * current class, this function returns value from the text files.
-         *
-         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
-         */
-        double
-        boundary_composition (const types::boundary_id boundary_indicator,
-                              const Point<dim> &position,
-                              const unsigned int compositional_field) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_composition/box.h.bak b/include/aspect/boundary_composition/box.h.bak
deleted file mode 100644
index 3e5ea1f3a55..00000000000
--- a/include/aspect/boundary_composition/box.h.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_composition_box_h
-#define _aspect_boundary_composition_box_h
-
-#include <aspect/boundary_composition/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    /**
-     * A class that implements a composition boundary condition for a box
-     * geometry.
-     *
-     * @ingroup BoundaryCompositions
-     */
-    template <int dim>
-    class Box : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * This function returns user-defined constant compositions at the
-         * boundaries.
-         *
-         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
-         */
-        double boundary_composition (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position,
-                                     const unsigned int compositional_field) const override;
-
-        /**
-         * This function performs some basic sanity checks on the parameter
-         * values previously read from the input file.
-         */
-        void initialize () override;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary compositions.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The values of the various composition variables on each of the
-         * 2*dim boundaries of the box.
-         */
-        std::vector<double> composition_values[2*dim];
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_composition/function.h.bak b/include/aspect/boundary_composition/function.h.bak
deleted file mode 100644
index 89040ac4563..00000000000
--- a/include/aspect/boundary_composition/function.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_composition_function_h
-#define _aspect_boundary_composition_function_h
-
-#include <aspect/boundary_composition/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements boundary composition based on a functional
-     * description provided in the input file.
-     *
-     * @ingroup BoundaryCompositions
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the boundary composition as a function of position and time.
-         *
-         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
-         */
-        double boundary_composition (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position,
-                                     const unsigned int compositional_field) const override;
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the boundary values will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        void update () override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the compositional fields.
-         */
-        std::unique_ptr<Functions::ParsedFunction<dim>> function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_composition/initial_composition.h.bak b/include/aspect/boundary_composition/initial_composition.h.bak
deleted file mode 100644
index a40fe81135d..00000000000
--- a/include/aspect/boundary_composition/initial_composition.h.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2013 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_composition_initial_composition_h
-#define _aspect_boundary_composition_initial_composition_h
-
-#include <aspect/initial_composition/interface.h>
-#include <aspect/boundary_composition/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    /**
-     * A class that implements a composition boundary condition for a
-     * spherical shell geometry in which the composition at the inner and
-     * outer surfaces (i.e. at the core-mantle and the
-     * mantle-lithosphere/atmosphere boundaries) are constant.
-     *
-     * @ingroup BoundaryCompositions
-     */
-    template <int dim>
-    class InitialComposition : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run.
-         *
-         * This specific function makes sure that the objects that describe
-         * initial conditions remain available throughout the run of the
-         * program.
-         */
-        void
-        initialize () override;
-
-        /**
-         * This function returns the boundary compositions that are defined
-         * by the initial conditions.
-         *
-         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
-         */
-        double boundary_composition (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position,
-                                     const unsigned int compositional_field) const override;
-
-        /**
-         * Return the minimal composition on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         */
-        virtual
-        double minimal_composition (const std::set<types::boundary_id> &fixed_boundary_ids) const;
-
-        /**
-         * Return the maximal composition on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         */
-        virtual
-        double maximal_composition (const std::set<types::boundary_id> &fixed_boundary_ids) const;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary compositions.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Compositions at the inner and outer boundaries.
-         */
-        double min_composition;
-        double max_composition;
-
-        /**
-         * A shared pointer to the initial composition object
-         * that ensures that the current object can continue
-         * to access the initial composition object beyond the
-         * first time step.
-         */
-        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_composition/interface.h.bak b/include/aspect/boundary_composition/interface.h.bak
deleted file mode 100644
index 1d3e2213ad8..00000000000
--- a/include/aspect/boundary_composition/interface.h.bak
+++ /dev/null
@@ -1,323 +0,0 @@
-/*
-  Copyright (C) 2013 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_composition_interface_h
-#define _aspect_boundary_composition_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/distributed/tria.h>
-
-#include <boost/core/demangle.hpp>
-#include <typeinfo>
-
-
-namespace aspect
-{
-  /**
-   * A namespace for the definition of things that have to do with describing
-   * the boundary values for the composition.
-   *
-   * @ingroup BoundaryCompositions
-   */
-  namespace BoundaryComposition
-  {
-    using namespace dealii;
-
-    /**
-     * Base class for classes that describe composition boundary values.
-     *
-     * @ingroup BoundaryCompositions
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Return the composition that is to hold at a particular position on
-         * the boundary of the domain.
-         *
-         * @param boundary_indicator The boundary indicator of the part of the
-         * boundary of the domain on which the point is located at which we
-         * are requesting the composition.
-         * @param position The position of the point at which we ask for the
-         * composition.
-         * @param compositional_field The index of the compositional field
-         * between 0 and @p parameters.n_compositional_fields.
-         * @return Boundary value of the compositional field @p
-         * compositional_field at the position @p position.
-         */
-        virtual
-        double
-        boundary_composition (const types::boundary_id boundary_indicator,
-                              const Point<dim> &position,
-                              const unsigned int compositional_field) const = 0;
-    };
-
-    /**
-     * A class that manages all boundary composition objects.
-     *
-     * @ingroup BoundaryCompositions
-     */
-    template <int dim>
-    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Destructor. Made virtual since this class has virtual member
-         * functions.
-         */
-        ~Manager () override;
-
-        /**
-         * A function that is called at the beginning of each time step and
-         * calls the corresponding functions of all created plugins.
-         *
-         * The point of this function is to allow complex boundary composition
-         * models to do an initialization step once at the beginning of each
-         * time step. An example would be a model that needs to call an
-         * external program to compute the composition change at a boundary.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters of all known boundary composition plugins, as
-         * well as the ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which boundary composition objects will be created;
-         * then let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * A function that calls the boundary_composition functions of all the
-         * individual boundary composition objects and uses the stored operators
-         * to combine them.
-         */
-        double
-        boundary_composition (const types::boundary_id boundary_indicator,
-                              const Point<dim> &position,
-                              const unsigned int compositional_field) const;
-
-        /**
-         * A function that is used to register boundary composition objects in such
-         * a way that the Manager can deal with all of them without having to
-         * know them by name. This allows the files in which individual
-         * plugins are implemented to register these plugins, rather than also
-         * having to modify the Manager class by adding the new boundary
-         * composition plugin class.
-         *
-         * @param name A string that identifies the boundary composition model
-         * @param description A text description of what this model does and that
-         * will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that can be
-         * used to declare the parameters that this boundary composition model
-         * wants to read from input files.
-         * @param factory_function A pointer to a function that can create an
-         * object of this boundary composition model.
-         */
-        static
-        void
-        register_boundary_composition (const std::string &name,
-                                       const std::string &description,
-                                       void (*declare_parameters_function) (ParameterHandler &),
-                                       std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-
-        /**
-         * Return a list of names of all boundary composition models currently
-         * used in the computation, as specified in the input file.
-         */
-        const std::vector<std::string> &
-        get_active_boundary_composition_names () const;
-
-        /**
-         * Return a list of pointers to all boundary composition models
-         * currently used in the computation, as specified in the input file.
-         */
-        const std::list<std::unique_ptr<Interface<dim>>> &
-        get_active_boundary_composition_conditions () const;
-
-        /**
-         * Go through the list of all boundary composition models that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename BoundaryCompositionType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryCompositionType>::value>>
-        bool
-        has_matching_boundary_composition_model () const;
-
-        /**
-         * Go through the list of all boundary composition models that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no boundary composition model is active that matches the given type,
-         * throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename BoundaryCompositionType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryCompositionType>::value>>
-        const BoundaryCompositionType &
-        get_matching_boundary_composition_model () const;
-
-        /*
-         * Return a set of boundary indicators for which boundary
-         * compositions are prescribed.
-         */
-        const std::set<types::boundary_id> &
-        get_fixed_composition_boundary_indicators() const;
-
-        /*
-         * Return whether Dirichlet boundary conditions will be applied
-         * on parts of the boundaries where material flows out.
-         */
-        bool
-        allows_fixed_composition_on_outflow_boundaries() const;
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcBoundaryCompositionNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered boundary composition objects.");
-      private:
-        /**
-         * A list of names of boundary composition objects that have been requested
-         * in the parameter file.
-         */
-        std::vector<std::string> model_names;
-
-        /**
-         * A list of enums of boundary composition operators that have been
-         * requested in the parameter file. Each name is associated
-         * with a model_name, and is used to modify the composition
-         * boundary with the values from the current plugin.
-         */
-        std::vector<aspect::Utilities::Operator> model_operators;
-
-        /**
-         * A set of boundary ids on which the boundary_composition_objects
-         * will be applied.
-         */
-        std::set<types::boundary_id> fixed_composition_boundary_indicators;
-
-        /**
-         * Whether we allow the composition to be fixed on parts of the boundary
-         * where material flows out of the domain.
-         */
-        bool allow_fixed_composition_on_outflow_boundaries;
-    };
-
-
-
-    template <int dim>
-    template <typename BoundaryCompositionType, typename>
-    inline
-    bool
-    Manager<dim>::has_matching_boundary_composition_model () const
-    {
-      return this->template has_matching_plugin_object<BoundaryCompositionType>();
-    }
-
-
-
-    template <int dim>
-    template <typename BoundaryCompositionType, typename>
-    inline
-    const BoundaryCompositionType &
-    Manager<dim>::get_matching_boundary_composition_model () const
-    {
-      return this->template get_matching_plugin_object<BoundaryCompositionType>();
-    }
-
-
-
-    /**
-     * Return a string that consists of the names of boundary composition models that can
-     * be selected. These names are separated by a vertical line '|' so
-     * that the string can be an input to the deal.II classes
-     * Patterns::Selection or Patterns::MultipleSelection.
-     */
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ();
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a boundary composition model, register it with the functions that
-     * can declare their parameters and create these objects.
-     *
-     * @ingroup BoundaryCompositions
-     */
-#define ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(classname, name, description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryComposition::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::BoundaryComposition::Manager<2>::register_boundary_composition, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryComposition::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::BoundaryComposition::Manager<3>::register_boundary_composition, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_composition/spherical_constant.h.bak b/include/aspect/boundary_composition/spherical_constant.h.bak
deleted file mode 100644
index f43e75347fc..00000000000
--- a/include/aspect/boundary_composition/spherical_constant.h.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_composition_spherical_constant_h
-#define _aspect_boundary_composition_spherical_constant_h
-
-#include <aspect/boundary_composition/interface.h>
-
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    /**
-     * A class that implements a composition boundary condition for a
-     * spherical shell geometry in which the composition at the inner and
-     * outer surfaces (i.e. at the core-mantle and the
-     * mantle-lithosphere/atmosphere boundaries) are constant.
-     * This class works for the sphere, spherical shell,
-     * chunk and ellipsoidal chunk geometries.
-     *
-     * @ingroup BoundaryCompositions
-     */
-    template <int dim>
-    class SphericalConstant : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialize some variables.
-        */
-        void
-        initialize() override;
-
-        /**
-         * This function returns the constant compositions read from the
-         * parameter file for the inner and outer boundaries.
-         *
-         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
-         */
-        double boundary_composition (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position,
-                                     const unsigned int compositional_field) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary compositions.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Compositions at the inner and outer boundaries.
-         */
-        std::vector<double> inner_composition;
-        std::vector<double> outer_composition;
-
-        /**
-         * Boundary indicators for the inner and outer boundaries.
-         */
-        types::boundary_id inner_boundary_indicator;
-        types::boundary_id outer_boundary_indicator;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_composition/two_merged_boxes.h.bak b/include/aspect/boundary_composition/two_merged_boxes.h.bak
deleted file mode 100644
index 2044061e5b2..00000000000
--- a/include/aspect/boundary_composition/two_merged_boxes.h.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_composition_two_merged_boxes_h
-#define _aspect_boundary_composition_two_merged_boxes_h
-
-#include <aspect/boundary_composition/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    /**
-     * A class that implements a composition boundary condition for a
-     * box geometry with additional boundary indicators for the
-     * lithospheric part of the left and right (and front and back in 3D) boundaries.
-     *
-     * @ingroup BoundaryCompositions
-     */
-    template <int dim>
-    class TwoMergedBoxes : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * This function returns constant compositions at the boundaries.
-         *
-         * @copydoc aspect::BoundaryComposition::Interface::boundary_composition()
-         */
-        double boundary_composition (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position,
-                                     const unsigned int compositional_field) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary compositions.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * This function performs some basic sanity checks on the parameter
-         * values previously read from the input file.
-         */
-        void initialize () override;
-
-      private:
-        /**
-         * The values of the various composition variables on each of the
-         * 2*dim+2*(dim-1) boundaries of the box.
-         */
-        std::vector<double> composition_values[2*dim+2*(dim-1)];
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_fluid_pressure/density.h.bak b/include/aspect/boundary_fluid_pressure/density.h.bak
deleted file mode 100644
index 49df8a34b65..00000000000
--- a/include/aspect/boundary_fluid_pressure/density.h.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_fluid_pressure_density_h
-#define _aspect_boundary_fluid_pressure_density_h
-
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace BoundaryFluidPressure
-  {
-    /**
-     * A class that implements simple fluid pressure boundary conditions
-     * based on the fluid or solid density from the material model.
-     *
-     * The fluid pressure gradient can either be set to
-     * $\rho_s \textbf{g}$ (solid density times gravity) or to
-     * $\rho_f \textbf{g}$ (fluid density times gravity).
-     *
-     * @ingroup BoundaryFluidPressures
-     */
-    template <int dim>
-    class Density : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * @copydoc Interface::fluid_pressure_gradient
-         */
-        void fluid_pressure_gradient (
-          const types::boundary_id boundary_indicator,
-          const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-          const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-          const std::vector<Tensor<1,dim>> &normal_vectors,
-          std::vector<double> &fluid_pressure_gradient_outputs
-        ) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Identify which density to use to compute the fluid pressure
-         * gradient at the model boundary.
-         */
-        struct DensityFormulation
-        {
-          enum Kind
-          {
-            solid_density,
-            fluid_density,
-            average_density
-          };
-        };
-
-        typename DensityFormulation::Kind density_formulation;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_fluid_pressure/interface.h.bak b/include/aspect/boundary_fluid_pressure/interface.h.bak
deleted file mode 100644
index 0ef7bc96a95..00000000000
--- a/include/aspect/boundary_fluid_pressure/interface.h.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_fluid_pressure_interface_h
-#define _aspect_boundary_fluid_pressure_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/material_model/interface.h>
-
-namespace aspect
-{
-  /**
-   * A namespace for the definition of things that have to do with describing
-   * the boundary values for fluid pressure for computations with melt
-   * transport.
-   *
-   * @ingroup BoundaryFluidPressures
-   */
-  namespace BoundaryFluidPressure
-  {
-    using namespace dealii;
-
-    /**
-     * Base class
-     *
-     * @ingroup BoundaryFluidPressures
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Compute the component of the gradient of the fluid pressure
-         * in the direction normal to a boundary for a list of quadrature
-         * points.
-         *
-         * The return value can typically contain @p material_model_outputs.fluid_densities[q]
-         * or @p material_model_outputs.densities[q], multiplied by the gravity vector
-         * and dotted with the normal.
-         * If the solid density is used, fluid is only flowing in or out due to differences in
-         * dynamic pressure, if the fluid density is used, melt flows in with the same velocity
-         * as inflowing solid material.
-         *
-         * @param boundary_indicator The boundary indicator of the part of the
-         * boundary of the domain on which the point is located at which we
-         * are requesting the fluid pressure gradients.
-         * @param material_model_inputs The material property inputs.
-         * @param material_model_outputs The material property outputs.
-         * @param normal_vectors A normal vector for each point.
-         * @param fluid_pressure_gradient_outputs Result to be filled.
-         */
-        virtual
-        void fluid_pressure_gradient (
-          const types::boundary_id boundary_indicator,
-          const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-          const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-          const std::vector<Tensor<1,dim>> &normal_vectors,
-          std::vector<double> &fluid_pressure_gradient_outputs
-        ) const = 0;
-    };
-
-
-    /**
-     * Register a fluid pressure boundary model so that it can be selected from
-     * the parameter file.
-     *
-     * @param name A string that identifies the fluid pressure boundary model
-     * @param description A text description of what this model does and that
-     * will be listed in the documentation of the parameter file.
-     * @param declare_parameters_function A pointer to a function that can be
-     * used to declare the parameters that this fluid pressure boundary model
-     * wants to read from input files.
-     * @param factory_function A pointer to a function that can create an
-     * object of this fluid pressure boundary model.
-     *
-     * @ingroup BoundaryFluidPressures
-     */
-    template <int dim>
-    void
-    register_boundary_fluid_pressure (const std::string &name,
-                                      const std::string &description,
-                                      void (*declare_parameters_function) (ParameterHandler &),
-                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-    /**
-     * A function that given the name of a model returns a pointer to an
-     * object that describes it. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The model object returned is not yet initialized and has not
-     * read its runtime parameters yet.
-     *
-     * @ingroup BoundaryFluidPressures
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_boundary_fluid_pressure (ParameterHandler &prm);
-
-
-    /**
-     * Declare the runtime parameters of the registered fluid pressure boundary
-     * models.
-     *
-     * @ingroup BoundaryFluidPressures
-     */
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm);
-
-
-    /**
-     * For the current plugin subsystem, write a connection graph of all of the
-     * plugins we know about, in the format that the
-     * programs dot and neato understand. This allows for a visualization of
-     * how all of the plugins that ASPECT knows about are interconnected, and
-     * connect to other parts of the ASPECT code.
-     *
-     * @param output_stream The stream to write the output to.
-     */
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &output_stream);
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a fluid pressure boundary model, register it with the functions that
-     * can declare their parameters and create these objects.
-     *
-     * @ingroup BoundaryFluidPressures
-     */
-#define ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(classname, name, description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryFluidPressure::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::BoundaryFluidPressure::register_boundary_fluid_pressure<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryFluidPressure::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::BoundaryFluidPressure::register_boundary_fluid_pressure<3>, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_heat_flux/function.h.bak b/include/aspect/boundary_heat_flux/function.h.bak
deleted file mode 100644
index ee10be8d535..00000000000
--- a/include/aspect/boundary_heat_flux/function.h.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_heat_flux_function_h
-#define _aspect_boundary_heat_flux_function_h
-
-#include <aspect/boundary_heat_flux/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace BoundaryHeatFlux
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements heat flux boundary conditions based on a
-     * functional description provided in the input file.
-     *
-     * @ingroup BoundaryHeatFlux
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the boundary heat flux as a function of position.
-         */
-        std::vector<Tensor<1,dim>>
-        heat_flux (const types::boundary_id boundary_indicator,
-                   const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                   const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                   const std::vector<Tensor<1,dim>> &normal_vectors) const override;
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the boundary values will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        void update () override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the boundary heat flux.
-         */
-        Functions::ParsedFunction<dim> boundary_heat_flux_function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_heat_flux/interface.h.bak b/include/aspect/boundary_heat_flux/interface.h.bak
deleted file mode 100644
index 79fe574da6f..00000000000
--- a/include/aspect/boundary_heat_flux/interface.h.bak
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_heat_flux_interface_h
-#define _aspect_boundary_heat_flux_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/material_model/interface.h>
-
-namespace aspect
-{
-  /**
-   * A namespace for the definition of things that have to do with describing
-   * the boundary heat flux values.
-   *
-   * @ingroup BoundaryHeatFlux
-   */
-  namespace BoundaryHeatFlux
-  {
-    using namespace dealii;
-
-    /**
-     * Base class
-     *
-     * @ingroup BoundaryHeatFlux
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Compute the heat flux for a list of quadrature points.
-         *
-         * The return value would typically be computed as the product of the thermal
-         * conductivity @p material_model_outputs.thermal_conductivities[q] and the
-         * temperature gradient at the boundary.
-         *
-         * @param boundary_indicator The boundary indicator of the part of the
-         * boundary of the domain on which the point is located at which we
-         * are requesting the fluid pressure gradients.
-         * @param material_model_inputs The material property inputs.
-         * @param material_model_outputs The material property outputs.
-         * @param normal_vectors The normal vector at each quadrature point.
-         * @return A vector of heat flux vectors at the evaluation points.
-         */
-        virtual
-        std::vector<Tensor<1,dim>>
-        heat_flux (const types::boundary_id boundary_indicator,
-                   const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                   const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                   const std::vector<Tensor<1,dim>> &normal_vectors) const = 0;
-    };
-
-
-    /**
-     * Register a boundary heat flux model so that it can be selected from
-     * the parameter file.
-     *
-     * @param name A string that identifies the fluid pressure boundary model
-     * @param description A text description of what this model does and that
-     * will be listed in the documentation of the parameter file.
-     * @param declare_parameters_function A pointer to a function that can be
-     * used to declare the parameters that this boundary heat flux model
-     * wants to read from input files.
-     * @param factory_function A pointer to a function that can create an
-     * object of this boundary heat flux model.
-     *
-     * @ingroup BoundaryHeatFlux
-     */
-    template <int dim>
-    void
-    register_boundary_heat_flux (const std::string &name,
-                                 const std::string &description,
-                                 void (*declare_parameters_function) (ParameterHandler &),
-                                 std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-    /**
-     * A function that given the name of a model returns a pointer to an
-     * object that describes it. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The model object returned is not yet initialized and has not
-     * read its runtime parameters yet.
-     *
-     * @ingroup BoundaryHeatFlux
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_boundary_heat_flux (ParameterHandler &prm);
-
-
-    /**
-     * Declare the runtime parameters of the registered boundary heat flux
-     * models.
-     *
-     * @ingroup BoundaryHeatFlux
-     */
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm);
-
-
-    /**
-     * For the current plugin subsystem, write a connection graph of all of the
-     * plugins we know about, in the format that the
-     * programs dot and neato understand. This allows for a visualization of
-     * how all of the plugins that ASPECT knows about are interconnected, and
-     * connect to other parts of the ASPECT code.
-     *
-     * @param output_stream The stream to write the output to.
-     */
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &output_stream);
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a boundary heat flux model, register it with the functions that
-     * can declare their parameters and create these objects.
-     *
-     * @ingroup BoundaryHeatFlux
-     */
-#define ASPECT_REGISTER_BOUNDARY_HEAT_FLUX_MODEL(classname, name, description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_BOUNDARY_HEAT_FLUX_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryHeatFlux::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::BoundaryHeatFlux::register_boundary_heat_flux<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryHeatFlux::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::BoundaryHeatFlux::register_boundary_heat_flux<3>, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_temperature/ascii_data.h.bak b/include/aspect/boundary_temperature/ascii_data.h.bak
deleted file mode 100644
index a71860d79b3..00000000000
--- a/include/aspect/boundary_temperature/ascii_data.h.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_temperature_ascii_data_h
-#define _aspect_boundary_temperature_ascii_data_h
-
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements prescribed data boundary conditions determined
-     * from a AsciiData input file.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataBoundary<dim>::initialize;
-
-        /**
-         * A function that is called at the beginning of each time step. For
-         * the current plugin, this function loads the next data files if
-         * necessary and outputs a warning if the end of the set of data files
-         * is reached.
-         */
-        void update () override;
-
-        /**
-         * Return the boundary temperature as a function of position. For the
-         * current class, this function returns value from the text files.
-         *
-         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
-         */
-        double
-        boundary_temperature (const types::boundary_id boundary_indicator,
-                              const Point<dim> &position) const override;
-
-        /**
-         * Return the minimal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Return the maximal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_temperature/box.h.bak b/include/aspect/boundary_temperature/box.h.bak
deleted file mode 100644
index 425c98d3fbf..00000000000
--- a/include/aspect/boundary_temperature/box.h.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_temperature_box_h
-#define _aspect_boundary_temperature_box_h
-
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    /**
-     * A class that implements a temperature boundary condition for a box
-     * geometry.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class Box : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * This function returns user-defined constant temperatures at the
-         * boundaries.
-         *
-         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
-         */
-        double boundary_temperature (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position) const override;
-
-        /**
-         * Return the minimal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Return the maximal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary temperatures.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        double temperature_[2*dim];
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_temperature/constant.h.bak b/include/aspect/boundary_temperature/constant.h.bak
deleted file mode 100644
index 36afaeedd3e..00000000000
--- a/include/aspect/boundary_temperature/constant.h.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_temperature_constant_h
-#define _aspect_boundary_temperature_constant_h
-
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <map>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    /**
-     * A class that implements a temperature boundary condition for an
-     * arbitrary geometry, where it returns a constant value for a given
-     * boundary indicator. Takes an ordered list of temperatures, where the
-     * position in the list corresponds to the indicator for that temperature.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class Constant : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * This function returns user-defined constant temperatures at the
-         * boundaries of arbitrary geometries.
-         *
-         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
-         */
-        double boundary_temperature (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position) const override;
-
-        /**
-         * Return the minimal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Return the maximal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary temperatures.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Temperatures at the boundaries.
-         */
-        std::map<types::boundary_id, double> boundary_temperatures;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_temperature/dynamic_core.h.bak b/include/aspect/boundary_temperature/dynamic_core.h.bak
deleted file mode 100644
index ff27245121d..00000000000
--- a/include/aspect/boundary_temperature/dynamic_core.h.bak
+++ /dev/null
@@ -1,517 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_boundary_temperature_dynamic_core_h
-#define _aspect_boundary_temperature_dynamic_core_h
-
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-
-    /**
-     * Data structure for core energy balance calculation
-     */
-    namespace internal
-    {
-      struct CoreData
-      {
-        /**
-         * Energy for specific heat, radioactive heating, gravitational contribution,
-         * adiabatic contribution, and latent heat. These variables are updated each time step.
-         */
-        double Qs,Qr,Qg,Qk,Ql;
-
-        /**
-         * Entropy for specific heat, radioactive heating, gravitational contribution,
-         * adiabatic contribution, latent heat, and heat solution. These entropy terms are not
-         * used for solving the core evolution. However, the total excess entropy
-         * (dE = Es*dT/dt+Er+El*dR/dt+Eg*dR/dt+Eh*dR/dt-Ek) is useful to determine the core is active or not.
-         * For dE>0, the core is likely to be active and generating magnetic field. These variables are updated each time step as well.
-         */
-        double Es,Er,Eg,Ek,El,Eh;
-
-        /**
-         * Parameters for core evolution
-         * Ri     inner core radius
-         * Ti     core-mantle boundary (CMB) temperature
-         * Xi     light component concentration in liquid core
-         */
-        double Ri,Ti,Xi;
-
-        /**
-         * Core-mantle boundary heat flux (Q) and core radioactive heating rate (H)
-         */
-        double Q,H;
-
-        /**
-         * Time step for core energy balance solver
-         */
-        double dt;
-
-        /**
-         * The changing rate of inner core radius, CMB temperature, and light component
-         * concentration.
-         */
-        double dR_dt,dT_dt,dX_dt;
-
-        /**
-         * Other energy source into the core
-         */
-        double Q_OES;
-
-        bool is_initialized;
-      };
-    }
-
-
-    /**
-     * A class that implements a temperature boundary condition for a spherical
-     * shell geometry in which the temperature at the outer surfaces are constant
-     * and the core-mantle boundaries (CMB) temperature is calculated by core energy balance.
-     * The formulation of the core energy balance is from \cite NPB+04 .
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class DynamicCore : public Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor
-         */
-        DynamicCore();
-
-        /**
-         * Return the temperature that is to hold at a particular location on the
-         * boundary of the domain. This function returns the temperatures
-         * at the inner and outer boundaries.
-         *
-         * @param boundary_indicator The boundary indicator of the part of the boundary
-         *   of the domain on which the point is located at which we are requesting the
-         *   temperature.
-         * @param location The location of the point at which we ask for the temperature.
-         */
-        double  boundary_temperature (const types::boundary_id            boundary_indicator,
-                                      const Point<dim>                    &location) const override;
-
-        /**
-         * Return the minimal temperature on that part of the boundary
-         * on which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Return the maximal temperature on that part of the boundary
-         * on which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         * This class declares the inner and outer boundary temperatures.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter
-         * file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * This function update the core-mantle boundary (CMB) temperature by
-         * the core energy balance solver using the core-mantle boundary heat flux.
-         */
-        void update() override;
-
-        /**
-         * Pass core data to other modules
-         */
-        const internal::CoreData &
-        get_core_data() const;
-
-        /**
-         * Check if other energy source in the core is in use. The 'other energy source' is used for external core energy source.
-         * For example if someone want to test the early lunar core powered by precession
-         * (Dwyer, C. A., et al. (2011). "A long-lived lunar dynamo driven by continuous mechanical stirring." Nature 479(7372): 212-214.)
-         */
-        bool
-        is_OES_used() const;
-
-
-      private:
-
-        /**
-         * Data for core energy balance
-         * it get updated each time step.
-         */
-        internal::CoreData core_data;
-
-        /**
-         * Temperature at the inner boundary.
-         */
-        double inner_temperature;
-
-        /**
-         * Temperatures at the outer boundaries.
-         */
-        double outer_temperature;
-
-        /**
-         * Initial CMB temperature changing rate
-         */
-        double init_dT_dt;
-
-        /**
-         * Initial inner core radius changing rate
-         */
-        double init_dR_dt;
-
-        /**
-         * Initial light composition changing rate
-         */
-        double init_dX_dt;
-
-        /**
-         * Flag for determining the initial call for update().
-         */
-        bool is_first_call;
-
-        /**
-         * Core radius
-         */
-        double Rc;
-
-        /**
-         * (Heat capacity) * density
-         */
-        double CpRho;
-
-        /**
-         * Initial light composition concentration
-         */
-        double X_init;
-
-        /**
-         * Partition coefficient of the light element
-         */
-        double Delta;
-
-        /**
-         * Gravitational acceleration
-         */
-        double g;
-
-        /**
-         * Pressure at the core mantle boundary
-         */
-        double P_CMB;
-
-        /**
-         * Pressure at the center of the core
-         */
-        double P_Core;
-
-        /**
-         * Parameters for core solidus following:
-         * if not dependent on composition
-         *   Tm(p)= Tm0*(1-Theta)*(1+Tm1*p+Tm2*p^2)
-         * if depend on composition X
-         *   Tm(p)= Tm0*(1-Theta*X)*(1+Tm1*p+Tm2*p^2)
-         */
-        double Tm0;
-        double Tm1;
-        double Tm2;
-        double Theta;
-        bool composition_dependency;
-
-        /**
-         * If using the Fe-FeS system solidus from Buono & Walker (2011) instead.
-         */
-        bool use_bw11;
-
-        //Variables for formulation of \cite NPB+04
-        /**
-         * Compressibility at zero pressure
-         */
-        double K0;
-
-        /**
-         * Thermal expansivity
-         */
-        double Alpha;
-
-        /**
-         * Density at zero pressure
-         */
-        double Rho_0;
-
-        /**
-         * Density at the center of the planet
-         */
-        double Rho_cen;
-
-        /**
-         * Latent heat of fusion
-         */
-        double Lh;
-
-        /**
-         * Heat of reaction
-         */
-        double Rh;
-
-        /**
-         * Compositional expansion coefficient
-         */
-        double Beta_c;
-
-        /**
-         * Heat conductivity of the core
-         */
-        double k_c;
-
-        /**
-         * Heat capacity
-         */
-        double Cp;
-
-        /**
-         * Number of radioheating element in core
-         */
-        unsigned int n_radioheating_elements;
-
-        /**
-         * Heating rates of different elements
-         */
-        std::vector<double> heating_rate;
-
-        /**
-         * Half life of different elements
-         */
-        std::vector<double> half_life;
-
-        /**
-         * Initial concentration of different elements
-         */
-        std::vector<double> initial_concentration;
-
-        /**
-         * Two length scales in \cite NPB+04 .
-         */
-        double L;
-        double D;
-
-        /**
-         * Mass of the core
-         */
-        double Mc;
-
-        /**
-         * Max iterations for the core energy balance solver.
-         */
-        int max_steps;
-
-        /**
-         * Temperature correction value for adiabatic
-         */
-        double dTa;
-
-        /**
-         * Other energy source into the core, e.g. the mechanical stirring of the moon.
-         */
-        std::string name_OES;
-        struct str_data_OES
-        {
-          double t;
-          double w;
-        };
-        std::vector<struct str_data_OES> data_OES;
-        void read_data_OES();
-        double get_OES(double t) const;
-
-
-
-        /**
-         * Solve core energy balance for each time step.
-         * When solving the change in core-mantle boundary temperature T, inner core radius R, and
-         *    light component (e.g. S, O, Si) composition X, the following relations has to be respected:
-         * 1. At the inner core boundary the adiabatic temperature should be equal to solidus temperature
-         * 2. The following energy production rate should be balanced in core:
-         *    Heat flux at core-mantle boundary         Q
-         *    Specific heat                             Qs*dT/dt
-         *    Radioactive heating                       Qr
-         *    Gravitational contribution                Qg*dR/dt
-         *    Latent heat                               Ql*dR/dt
-         *    So that         Q+Qs*dT/dt+Qr+Qg*dR/dt*Ql*dR/dt=0
-         * 3. The light component composition X depends on inner core radius (See function get_X() ),
-         *    and core solidus may dependent on X as well.
-         *    This becomes a small nonlinear problem. Directly iterate through the above three equations doesn't
-         *    converge well. Alternatively we solve the inner core radius by bisection method.
-         *    A single solution between fully liquid and fully solid core is expected. Otherwise this function will throw exception and terminate.
-         *
-         *    At Earth core condition, a inner core is forming at the center of the Earth and surrounded by a liquid outer core.
-         *    However, the core solidus is influenced by light components (e.g. S) and its slope is very closed to core adiabatic. So there is an alternative
-         *    scenario that the crystallization happens first at the core mantle boundary instead of at the center, which is called a 'snowing core'
-         *    (Stewart, A. J., et al. (2007). "Mars: a new core-crystallization regime." Science 316(5829): 1323-1325.). This also
-         *    provides a valid solution for the solver. So the returning bool is set to true for normal core, and false for 'snowing core'.
-         *    TODO: The current code is only able to treat normal core scenario, treating 'snowing core' scenario may be possible and could be added.
-         */
-        bool solve_time_step(double &X, double &T, double &R);
-
-        /**
-         * Compute the difference between solidus and adiabatic at inner
-         * core boundary for a given inner core radius.
-         */
-        double get_dT(double r) const;
-
-        /**
-         * Use energy balance to calculate core mantle boundary temperature
-         * with a given inner core radius.
-         */
-        double get_Tc(double r) const;
-
-        /**
-         * Get the solidus temperature at inner core boundary
-         * with a given inner core radius.
-         */
-        double get_Ts(double r) const;
-
-        /**
-         * Compute the core solidus at certain pressure
-         */
-        double get_solidus(double X,double p) const;
-
-        /**
-         * Get initial inner core radius with given initial core mantle temperature.
-         */
-        double get_initial_Ri(double T);
-
-        /**
-         * Get the light composition concentration in the outer core from given
-         * inner core radius r
-         */
-        double get_X(double r) const;
-
-        /**
-         * Compute the mass inside certain radius within the core_data.
-         */
-        double get_Mass(double r) const;
-
-        /**
-         * Calculate Sn(B,R), referring to \cite NPB+04 .
-         */
-        double fun_Sn(double B,double R,double n) const;
-
-        /**
-         * Calculate density at given r
-         */
-        double get_Rho(double r) const;
-
-        /**
-         * Calculate gravitational acceleration at given r
-         */
-        double get_g(double r) const;
-
-        /**
-         * Calculate the core temperature at given r
-         * Tc is the temperature at CMB
-         */
-        double get_T(double Tc, double r) const;
-
-        /**
-         * Calculate pressure at given r
-         */
-        double get_Pressure(double r) const;
-
-        /**
-         * Calculate the gravitational potential at given r
-         */
-        double get_gravity_potential(double r) const;
-
-        /**
-         * Calculate energy and entropy change rate factor (regarding the core
-         * cooling rated Tc/dt) Qs and Es with given core-mantle boundary (CMB)
-         * temperature Tc
-         */
-        void get_specific_heating(double Tc, double &Qs,double &Es);
-
-        /**
-         * Calculate energy and entropy change rate factor (regarding the
-         * radioactive heating rate H) Qr and Er with given CMB temperature Tc
-         */
-        void get_radio_heating(double Tc, double &Qr, double &Er);
-
-        /**
-         * Calculate energy and entropy change rate factor (regarding the inner core
-         * growth rate dR/dt) Qg and Eg with given Tc(CMB temperature), r(inner core
-         * radius), X(light composition concentration)
-         */
-        void get_gravity_heating(double Tc, double r,double X,double &Qg,double &Eg);
-
-        /**
-         * Calculate energy and entropy change rate factor (regarding the core
-         * cooling rate Tc/dt) Qk and Ek with given Tc(CMB temperature)
-         */
-        void get_adiabatic_heating(double Tc, double &Ek, double &Qk);
-
-        /**
-         * Calculate energy and entropy change rate factor (regarding the inner core
-         * growth rate dR/dt) Ql and El with given Tc(CMB temperature), r(inner core
-         * radius)
-         */
-        void get_latent_heating(double Tc, double r, double &El, double &Ql);
-
-        /**
-         * Calculate entropy of heat of solution Eh
-         */
-        void get_heat_solution(double Tc, double r, double X, double &Eh);
-
-        /**
-         * return radio heating rate at certain time
-         */
-        double get_radioheating_rate() const;
-
-        /**
-         * Update the data for core dynamic simulation, the data will be used
-         * in the next timestep and for postprocess.
-         */
-        void update_core_data();
-
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_temperature/function.h.bak b/include/aspect/boundary_temperature/function.h.bak
deleted file mode 100644
index d5bc2e49f84..00000000000
--- a/include/aspect/boundary_temperature/function.h.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_temperature_function_h
-#define _aspect_boundary_temperature_function_h
-
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements boundary temperature based on a functional
-     * description provided in the input file.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Function ();
-
-        /**
-         * Return the boundary temperature as a function of position and time.
-         *
-         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
-         */
-        double
-        boundary_temperature (const types::boundary_id boundary_indicator,
-                              const Point<dim> &position) const override;
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the boundary values will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        void update () override;
-
-        /**
-         * Return the minimal temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Return the maximal temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the temperature.
-         */
-        Functions::ParsedFunction<dim> boundary_temperature_function;
-
-        /**
-         * Temperatures at the inner and outer boundaries.
-         */
-        double min_temperature;
-        double max_temperature;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_temperature/initial_temperature.h.bak b/include/aspect/boundary_temperature/initial_temperature.h.bak
deleted file mode 100644
index 2d6bf322ae3..00000000000
--- a/include/aspect/boundary_temperature/initial_temperature.h.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_temperature_initial_temperature_h
-#define _aspect_boundary_temperature_initial_temperature_h
-
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    /**
-     * A class that implements a temperature boundary condition for an
-     * arbitrary geometry in which the temperature at the boundaries are the
-     * same as in the initial conditions.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class InitialTemperature : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run.
-         *
-         * This specific function makes sure that the objects that describe
-         * initial conditions remain available throughout the run of the
-         * program.
-         */
-        void
-        initialize () override;
-
-        /**
-         * This function returns the boundary temperatures that are defined
-         * by the initial conditions.
-         *
-         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
-         */
-        double boundary_temperature (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position) const override;
-
-        /**
-         * Return the minimal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Return the maximal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary temperatures.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Temperatures at the inner and outer boundaries.
-         */
-        double min_temperature;
-        double max_temperature;
-
-        /**
-         * A shared pointer to the initial temperature object
-         * that ensures that the current object can continue
-         * to access the initial temperature object beyond the
-         * first time step.
-         */
-        std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_temperature/interface.h.bak b/include/aspect/boundary_temperature/interface.h.bak
deleted file mode 100644
index 7b694b5f515..00000000000
--- a/include/aspect/boundary_temperature/interface.h.bak
+++ /dev/null
@@ -1,355 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_temperature_interface_h
-#define _aspect_boundary_temperature_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/distributed/tria.h>
-
-#include <boost/core/demangle.hpp>
-#include <typeinfo>
-
-
-namespace aspect
-{
-  template <int dim> class SimulatorAccess;
-
-  /**
-   * A namespace for the definition of things that have to do with describing
-   * the boundary values for the temperature.
-   *
-   * @ingroup BoundaryTemperatures
-   */
-  namespace BoundaryTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * Base class for classes that describe temperature boundary values.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Return the temperature that is to hold at a particular position on
-         * the boundary of the domain.
-         *
-         * @param boundary_indicator The boundary indicator of the part of the
-         * boundary of the domain on which the point is located at which we
-         * are requesting the temperature.
-         * @param position The position of the point at which we ask for the
-         * temperature.
-         *
-         * @return Boundary temperature at position @p position.
-         */
-        virtual
-        double boundary_temperature (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position) const = 0;
-
-        /**
-         * Return the minimal temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        virtual
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids
-                                    = std::set<types::boundary_id>()) const = 0;
-
-        /**
-         * Return the maximal temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        virtual
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids
-                                    = std::set<types::boundary_id>()) const = 0;
-    };
-
-
-    /**
-     * A class that manages all boundary temperature objects.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Destructor. Made virtual since this class has virtual member
-         * functions.
-         */
-        ~Manager () override;
-
-        /**
-         * A function that is called at the beginning of each time step and
-         * calls the corresponding functions of all created plugins.
-         *
-         * The point of this function is to allow complex boundary temperature
-         * models to do an initialization step once at the beginning of each
-         * time step. An example would be a model that needs to call an
-         * external program to compute the temperature change at a boundary.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters of all known boundary temperature plugins, as
-         * well as the ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which boundary temperature objects will be created;
-         * then let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * A function that calls the boundary_temperature functions of all the
-         * individual boundary temperature objects and uses the stored operators
-         * to combine them.
-         */
-        double
-        boundary_temperature (const types::boundary_id boundary_indicator,
-                              const Point<dim> &position) const;
-
-        /**
-         * Return the minimal temperature of all selected plugins on that
-         * part of the boundary on which Dirichlet conditions are posed.
-         */
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids
-                                    = std::set<types::boundary_id>()) const;
-
-        /**
-         * Return the maximal temperature of all selected plugins on that
-         * part of the boundary on which Dirichlet conditions are posed.
-         */
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids
-                                    = std::set<types::boundary_id>()) const;
-
-        /**
-         * A function that is used to register boundary temperature objects in such
-         * a way that the Manager can deal with all of them without having to
-         * know them by name. This allows the files in which individual
-         * plugins are implemented to register these plugins, rather than also
-         * having to modify the Manager class by adding the new boundary
-         * temperature plugin class.
-         *
-         * @param name A string that identifies the boundary temperature model
-         * @param description A text description of what this model does and that
-         * will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that can be
-         * used to declare the parameters that this boundary temperature model
-         * wants to read from input files.
-         * @param factory_function A pointer to a function that can create an
-         * object of this boundary temperature model.
-         */
-        static
-        void
-        register_boundary_temperature (const std::string &name,
-                                       const std::string &description,
-                                       void (*declare_parameters_function) (ParameterHandler &),
-                                       std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-
-        /**
-         * Return a list of names of all boundary temperature models currently
-         * used in the computation, as specified in the input file.
-         */
-        const std::vector<std::string> &
-        get_active_boundary_temperature_names () const;
-
-        /**
-         * Return a list of pointers to all boundary temperature models
-         * currently used in the computation, as specified in the input file.
-         */
-        const std::list<std::unique_ptr<Interface<dim>>> &
-        get_active_boundary_temperature_conditions () const;
-
-        /**
-         * Go through the list of all boundary temperature models that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename BoundaryTemperatureType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryTemperatureType>::value>>
-        bool
-        has_matching_boundary_temperature_model () const;
-
-        /**
-         * Go through the list of all boundary temperature models that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no boundary temperature model is active that matches the given type,
-         * throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename BoundaryTemperatureType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryTemperatureType>::value>>
-        const BoundaryTemperatureType &
-        get_matching_boundary_temperature_model () const;
-
-        /*
-         * Return a set of boundary indicators for which boundary
-         * temperatures are prescribed.
-         */
-        const std::set<types::boundary_id> &
-        get_fixed_temperature_boundary_indicators() const;
-
-        /*
-         * Return whether Dirichlet boundary conditions will be applied
-         * on parts of the boundaries where material flows out.
-         */
-        bool
-        allows_fixed_temperature_on_outflow_boundaries() const;
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcBoundaryTemperatureNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered boundary temperature objects.");
-      private:
-        /**
-         * A list of names of boundary temperature objects that have been requested
-         * in the parameter file.
-         */
-        std::vector<std::string> model_names;
-
-        /**
-         * A list of enums of boundary temperature operators that have been
-         * requested in the parameter file. Each name is associated
-         * with a model_name, and is used to modify the temperature
-         * boundary with the values from the current plugin.
-         */
-        std::vector<aspect::Utilities::Operator> model_operators;
-
-        /**
-         * A set of boundary ids on which the boundary_temperature_objects
-         * will be applied.
-         */
-        std::set<types::boundary_id> fixed_temperature_boundary_indicators;
-
-        /**
-         * Whether we allow the temperature to be fixed on parts of the boundary
-         * where material flows out of the domain.
-         */
-        bool allow_fixed_temperature_on_outflow_boundaries;
-    };
-
-
-
-    template <int dim>
-    template <typename BoundaryTemperatureType, typename>
-    inline
-    bool
-    Manager<dim>::has_matching_boundary_temperature_model () const
-    {
-      return this->template has_matching_plugin_object<BoundaryTemperatureType>();
-    }
-
-
-    template <int dim>
-    template <typename BoundaryTemperatureType, typename>
-    inline
-    const BoundaryTemperatureType &
-    Manager<dim>::get_matching_boundary_temperature_model () const
-    {
-      return this->template get_matching_plugin_object<BoundaryTemperatureType>();
-    }
-
-
-    /**
-     * Return a string that consists of the names of boundary temperature models that can
-     * be selected. These names are separated by a vertical line '|' so
-     * that the string can be an input to the deal.II classes
-     * Patterns::Selection or Patterns::MultipleSelection.
-     */
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ();
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a boundary temperature model, register it with the functions that
-     * can declare their parameters and create these objects.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-#define ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(classname, name, description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryTemperature::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::BoundaryTemperature::Manager<2>::register_boundary_temperature, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryTemperature::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::BoundaryTemperature::Manager<3>::register_boundary_temperature, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_temperature/spherical_constant.h.bak b/include/aspect/boundary_temperature/spherical_constant.h.bak
deleted file mode 100644
index 5ff209a774f..00000000000
--- a/include/aspect/boundary_temperature/spherical_constant.h.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_temperature_spherical_constant_h
-#define _aspect_boundary_temperature_spherical_constant_h
-
-#include <aspect/boundary_temperature/interface.h>
-
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    /**
-     * A class that implements a temperature boundary condition for a
-     * spherical shell geometry in which the temperature at the inner and
-     * outer surfaces (i.e. at the core-mantle and the
-     * mantle-lithosphere/atmosphere boundaries) are constant.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class SphericalConstant : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-        * Initialize some variables.
-        */
-        void
-        initialize() override;
-
-        /**
-         * This function returns the constant compositions read from the
-         * parameter file for the inner and outer boundaries.
-         *
-         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
-         */
-        double boundary_temperature (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position) const override;
-
-        /**
-         * Return the minimal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Return the maximal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary temperatures.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Temperatures at the inner and outer boundaries.
-         */
-        double inner_temperature;
-        double outer_temperature;
-
-        /**
-         * The boundary indicator for the inner and outer boundaries.
-         */
-        types::boundary_id inner_boundary_indicator;
-        types::boundary_id outer_boundary_indicator;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_temperature/two_merged_boxes.h.bak b/include/aspect/boundary_temperature/two_merged_boxes.h.bak
deleted file mode 100644
index bbbac87ca35..00000000000
--- a/include/aspect/boundary_temperature/two_merged_boxes.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_temperature_two_merged_boxes_h
-#define _aspect_boundary_temperature_two_merged_boxes_h
-
-#include <aspect/boundary_temperature/interface.h>
-
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    /**
-     * A class that implements a temperature boundary condition for a
-     * box geometry with additional boundary indicators for the
-     * lithospheric part of left and right (and front and back in 3D) boundaries.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class TwoMergedBoxes : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * This function returns constant compositions at the boundaries.
-         *
-         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
-         */
-        double boundary_temperature (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position) const override;
-
-        /**
-         * Return the minimal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Return the maximal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary temperatures.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The values of the various temperature variables on each of the
-         * 2*dim+2*(dim-1) boundaries of the box.
-         */
-        double temperature_values[2*dim+2*(dim-1)];
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_traction/ascii_data.h.bak b/include/aspect/boundary_traction/ascii_data.h.bak
deleted file mode 100644
index f6a3b095bd3..00000000000
--- a/include/aspect/boundary_traction/ascii_data.h.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_traction_ascii_data_h
-#define _aspect_boundary_traction_ascii_data_h
-
-#include <aspect/boundary_traction/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements prescribed traction boundary conditions determined
-     * from pressures given in an AsciiData input file.
-     *
-     * @ingroup BoundaryTractions
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataBoundary<dim>::initialize;
-
-        /**
-         * Return the boundary traction as a function of position. The
-         * (outward) normal vector to the domain is also provided as
-         * a second argument.
-         */
-        Tensor<1,dim>
-        boundary_traction (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position,
-                           const Tensor<1,dim> &normal_vector) const override;
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the boundary values will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        std::set<types::boundary_id> boundary_ids;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_traction/function.h.bak b/include/aspect/boundary_traction/function.h.bak
deleted file mode 100644
index bcb2648bd54..00000000000
--- a/include/aspect/boundary_traction/function.h.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_traction_function_h
-#define _aspect_boundary_traction_function_h
-
-#include <aspect/boundary_traction/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements traction boundary conditions based on a
-     * functional description provided in the input file.
-     *
-     * @ingroup BoundaryTractions
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Function ();
-
-        /**
-         * Return the boundary traction as a function of position. The
-         * (outward) normal vector to the domain is also provided as
-         * a second argument.
-         */
-        Tensor<1,dim>
-        boundary_traction (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position,
-                           const Tensor<1,dim> &normal_vector) const override;
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the boundary values will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the components of the traction.
-         */
-        Functions::ParsedFunction<dim> boundary_traction_function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-
-        /**
-         * Whether to specify traction in x, y, z components, or
-         * r, phi, theta components.
-         */
-        bool use_spherical_unit_vectors;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_traction/initial_lithostatic_pressure.h.bak b/include/aspect/boundary_traction/initial_lithostatic_pressure.h.bak
deleted file mode 100644
index e68df505956..00000000000
--- a/include/aspect/boundary_traction/initial_lithostatic_pressure.h.bak
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_traction_initial_lithospheric_pressure_h
-#define _aspect_boundary_traction_initial_lithospheric_pressure_h
-
-#include <aspect/boundary_traction/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements traction boundary conditions by prescribing
-     * the lithostatic pressure as the normal traction component.
-     *
-     * @ingroup BoundaryTractions
-     */
-    template <int dim>
-    class InitialLithostaticPressure : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Initialization function. Because this function is called after
-         * initializing the SimulatorAccess, all of the necessary information
-         * is available to calculate the pressure profile based on the initial
-         * temperature and pressure conditions.
-         */
-        void initialize () override;
-
-
-        /**
-         * Return the boundary traction as a function of position. The
-         * (outward) normal vector to the domain is also provided as
-         * a second argument.
-         */
-        Tensor<1,dim>
-        boundary_traction (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position,
-                           const Tensor<1,dim> &normal_vector) const override;
-
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * The number of integration points.
-         */
-        unsigned int n_points;
-
-        /**
-         * Depth interval spacing between each two data points in the pressure profile.
-         */
-        double delta_z;
-
-        /*
-         * The user-specified point where to calculate the pressure profile.
-         * The vertical coordinate/radius is ignored.
-         */
-        Point<dim> representative_point;
-
-        /**
-         * The computed lithostatic pressure profile.
-         */
-        std::vector<double> pressure;
-
-        /**
-         * Return the lithostatic pressure at a given point of the domain
-         * based on depth interpolation between computed pressure values.
-         */
-        double interpolate_pressure (const Point<dim> &p) const;
-
-        /**
-         * The id of the bottom boundary.
-         */
-        types::boundary_id bottom_boundary_id;
-
-        /**
-         * Whether or not to prescribe the
-         * largest pressure in the lithostatic pressure
-         * profile at the bottom boundary independent of
-         * actual depth.
-         */
-        bool prescribe_constant_pressure_at_bottom_boundary;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_traction/interface.h.bak b/include/aspect/boundary_traction/interface.h.bak
deleted file mode 100644
index cb6cf8c524b..00000000000
--- a/include/aspect/boundary_traction/interface.h.bak
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_traction_interface_h
-#define _aspect_boundary_traction_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/point.h>
-#include <deal.II/base/parameter_handler.h>
-
-namespace aspect
-{
-  /**
-   * A namespace in which we define everything that has to do with defining
-   * traction boundary conditions for the Stokes equations.
-   *
-   * @ingroup BoundaryTractions
-   */
-  namespace BoundaryTraction
-  {
-    using namespace dealii;
-
-    /**
-     * A base class for parameterizations of traction boundary conditions.
-     *
-     * @ingroup BoundaryTractions
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Return the traction that is to hold at a particular position on
-         * the boundary of the domain.
-         *
-         * @param boundary_indicator The boundary indicator of the part of the
-         * boundary of the domain on which the point is located at which we
-         * are requesting the traction.
-         * @param position The position of the point at which we ask for the
-         * traction.
-         * @param normal_vector The (outward) normal vector to the boundary
-         * of the domain.
-         *
-         * @return Boundary traction at position @p position.
-         */
-        virtual
-        Tensor<1,dim>
-        boundary_traction (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position,
-                           const Tensor<1,dim> &normal_vector) const = 0;
-    };
-
-    template <int dim>
-    class Manager : public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Destructor. Made virtual since this class has virtual member
-         * functions.
-         */
-        ~Manager () override;
-
-        /**
-         * A function that is called at the beginning of each time step and
-         * calls the corresponding functions of all created plugins.
-         *
-         * The point of this function is to allow complex boundary traction
-         * models to do an initialization step once at the beginning of each
-         * time step. An example would be a model that needs to call an
-         * external program to compute the traction change at a boundary.
-         */
-        virtual
-        void
-        update ();
-
-        /**
-         * A function that calls the boundary_traction functions of all the
-         * individual boundary traction objects and uses the stored operators
-         * to combine them.
-         */
-        Tensor<1,dim>
-        boundary_traction (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position,
-                           const Tensor<1,dim> &normal_vector) const;
-
-        /**
-           * Return the names of all prescribed boundary traction models currently
-           * used in the computation as specified in the input file. The function
-           * returns a map between a boundary identifier and a pair. The
-           * first part of the pair is a string that represents the prescribed
-           * traction components on this boundary (e.g. y, xz, or xyz) and the
-           * second part is a vector of strings that represent the names of
-           * boundary traction plugins for this boundary.
-           * If there are no prescribed boundary traction plugins
-           * for a particular boundary, this boundary identifier will not appear
-           * in the map.
-           */
-        const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> &
-        get_active_boundary_traction_names () const;
-
-        /**
-         * Return pointers to all boundary traction models
-         * currently used in the computation, as specified in the input file.
-         * The function returns a map between a boundary identifier and a vector
-         * of unique pointers that represent the names of prescribed traction
-         * boundary models for this boundary. If there are no prescribed
-         * boundary traction plugins for a particular boundary this boundary
-         * identifier will not appear in the map.
-         */
-        const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryTraction::Interface<dim>>>> &
-        get_active_boundary_traction_conditions () const;
-
-        /**
-         * Declare the parameters of all known boundary traction plugins, as
-         * well as the ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which boundary traction objects will be created;
-         * then let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm);
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcBoundaryTractionNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered boundary traction objects.");
-
-        /**
-        * Register a traction boundary conditions model so that it can be
-        * selected from the parameter file.
-        *
-        * @param name A string that identifies the traction boundary conditions
-        * model
-        * @param description A text description of what this model does and that
-        * will be listed in the documentation of the parameter file.
-        * @param declare_parameters_function A pointer to a function that can be
-        * used to declare the parameters that this traction boundary conditions
-        * model wants to read from input files.
-        * @param factory_function A pointer to a function that can create an
-        * object of this traction boundary conditions model.
-        *
-        * @ingroup BoundaryTractions
-        */
-        static
-        void
-        register_boundary_traction (const std::string &name,
-                                    const std::string &description,
-                                    void (*declare_parameters_function) (ParameterHandler &),
-                                    std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-      private:
-        /**
-         * A list of boundary traction objects that have been requested in the
-         * parameter file.
-         */
-        std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryTraction::Interface<dim>>>> boundary_traction_objects;
-
-        /**
-         * Map from boundary id to a pair
-         * ("components", list of "traction boundary type"),
-         * where components is of the format "[x][y][z]" and the traction type is
-         * mapped to one of the plugins of traction boundary conditions (e.g.
-         * "function"). If the components string is empty, it is assumed the
-         * plugins are used for all components.
-         */
-        std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> boundary_traction_indicators;
-
-    };
-
-    /**
-     * A function that given the name of a model returns a pointer to an
-     * object that describes it. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The model object returned is not yet initialized and has not
-     * read its runtime parameters yet.
-     *
-     * @ingroup BoundaryTractions
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_boundary_traction (const std::string &name);
-
-    /**
-     * Return a list of names of all implemented boundary traction models,
-     * separated by '|' so that it can be used in an object of type
-     * Patterns::Selection.
-     */
-    template <int dim>
-    std::string
-    get_names ();
-
-    /**
-     * Declare the runtime parameters of the registered traction boundary
-     * conditions models.
-     *
-     * @ingroup BoundaryTractions
-     */
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm);
-
-
-    /**
-     * For the current plugin subsystem, write a connection graph of all of the
-     * plugins we know about, in the format that the
-     * programs dot and neato understand. This allows for a visualization of
-     * how all of the plugins that ASPECT knows about are interconnected, and
-     * connect to other parts of the ASPECT code.
-     *
-     * @param output_stream The stream to write the output to.
-     */
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &output_stream);
-
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a traction boundary conditions model, register it with the
-     * functions that can declare their parameters and create these objects.
-     *
-     * @ingroup BoundaryTractions
-     */
-#define ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryTraction::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::BoundaryTraction::Manager<2>::register_boundary_traction, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryTraction::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::BoundaryTraction::Manager<3>::register_boundary_traction, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_traction/zero_traction.h.bak b/include/aspect/boundary_traction/zero_traction.h.bak
deleted file mode 100644
index d3aba4229d1..00000000000
--- a/include/aspect/boundary_traction/zero_traction.h.bak
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_traction_zero_traction_h
-#define _aspect_boundary_traction_zero_traction_h
-
-#include <aspect/boundary_traction/interface.h>
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements zero traction boundary conditions. This
-     * is equivalent to an open boundary condition in domains where
-     * hydrostatic pressure is irrelevant.
-     *
-     * @ingroup BoundaryTractions
-     */
-    template <int dim>
-    class ZeroTraction : public Interface<dim>
-    {
-      public:
-        /**
-         * Return the boundary traction as a function of position. The
-         * (outward) normal vector to the domain is also provided as
-         * a second argument.
-         *
-         * For the current class, this function obviously simply returns a zero
-         * tensor.
-         */
-        Tensor<1,dim>
-        boundary_traction (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position,
-                           const Tensor<1,dim> &normal_vector) const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_velocity/ascii_data.h.bak b/include/aspect/boundary_velocity/ascii_data.h.bak
deleted file mode 100644
index bc262ac86a4..00000000000
--- a/include/aspect/boundary_velocity/ascii_data.h.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_velocity_ascii_data_h
-#define _aspect_boundary_velocity_ascii_data_h
-
-#include <aspect/boundary_velocity/interface.h>
-
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements prescribed velocity boundary conditions
-     * determined from a AsciiData input file.
-     *
-     * @ingroup BoundaryVelocities
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataBoundary<dim>::initialize;
-
-        /**
-         * A function that is called at the beginning of each time step. For
-         * the current plugin, this function loads the next data files if
-         * necessary and outputs a warning if the end of the set of data files
-         * is reached.
-         */
-        void
-        update () override;
-
-        /**
-         * Return the boundary velocity as a function of position. For the
-         * current class, this function returns value from the text files.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position) const override;
-
-        // avoid -Woverloaded-virtual warning until the deprecated function
-        // is removed from the interface:
-        using Interface<dim>::boundary_velocity;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-      private:
-        std::set<types::boundary_id> boundary_ids;
-
-        /**
-         * Whether to specify velocity in x, y, z components, or
-         * r, phi, theta components.
-         */
-        bool use_spherical_unit_vectors;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_velocity/function.h.bak b/include/aspect/boundary_velocity/function.h.bak
deleted file mode 100644
index 940840de66d..00000000000
--- a/include/aspect/boundary_velocity/function.h.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_velocity_function_h
-#define _aspect_boundary_velocity_function_h
-
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements velocity boundary conditions based on a
-     * functional description provided in the input file.
-     *
-     * @ingroup BoundaryVelocities
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Function ();
-
-        /**
-         * Return the boundary velocity as a function of position. For the
-         * current class, this function obviously simply returns a zero
-         * tensor.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position) const override;
-
-        // avoid -Woverloaded-virtual warning until the deprecated function
-        // is removed from the interface:
-        using Interface<dim>::boundary_velocity;
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the boundary values will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the components of the velocity.
-         */
-        Functions::ParsedFunction<dim> boundary_velocity_function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-
-        /**
-         * Whether to specify velocity in x, y, z components, or
-         * r, phi, theta components.
-         */
-        bool use_spherical_unit_vectors;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_velocity/gplates.h.bak b/include/aspect/boundary_velocity/gplates.h.bak
deleted file mode 100644
index 7860576b75f..00000000000
--- a/include/aspect/boundary_velocity/gplates.h.bak
+++ /dev/null
@@ -1,347 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_velocity_gplates_h
-#define _aspect_boundary_velocity_gplates_h
-
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <array>
-#include <deal.II/base/function_lib.h>
-
-
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    using namespace dealii;
-
-    namespace internal
-    {
-      /**
-       * GPlatesLookup handles all kinds of tasks around looking up a certain
-       * velocity boundary condition from a gplates .gpml file.
-       */
-      template <int dim>
-      class GPlatesLookup
-      {
-        public:
-
-          /**
-           * Initialize all members and calculates any necessary rotation
-           * parameters for a 2D model.
-           */
-          GPlatesLookup(const Tensor<1,2> &surface_point_one,
-                        const Tensor<1,2> &surface_point_two);
-
-          /**
-           * Outputs the GPlates module information at model start.
-           */
-          std::string
-          screen_output(const Tensor<1,2> &surface_point_one,
-                        const Tensor<1,2> &surface_point_two) const;
-
-          /**
-           * Loads a gplates .gpml velocity file. Throws an exception if the
-           * file does not exist.
-           */
-          void load_file(const std::string &filename,
-                         const MPI_Comm comm);
-
-          /**
-           * Returns the computed surface velocity in cartesian coordinates.
-           * Takes as input the position. Actual velocity interpolation is
-           * performed in spherical coordinates.
-           *
-           * @param position The current position to compute velocity
-           */
-          Tensor<1,dim> surface_velocity(const Point<dim> &position) const;
-
-        private:
-          /**
-           * Interpolation functions to access the velocities.
-           */
-          std::array<std::unique_ptr<Functions::InterpolatedUniformGridData<2>>, 2> velocities;
-
-          /**
-           * Distances between adjacent point in the Lat/Long grid
-           */
-          double delta_phi, delta_theta;
-
-          /**
-           * The matrix, which describes the rotation by which a 2D model
-           * needs to be transformed to a plane that contains the origin and
-           * the two user prescribed points. Is not necessary and therefore
-           * not used for 3D models.
-           */
-          Tensor<2,3> rotation_matrix;
-
-          /**
-           * A function that returns the corresponding paraview angles for a
-           * rotation described by a rotation matrix. These differ from the
-           * usually used euler angles by assuming a rotation around the
-           * coordinate axes in the order y-x-z (instead of the often used
-           * z-x-z)
-           */
-          std::array<double,3>
-          angles_from_matrix (const Tensor<2,3> &rotation_matrix) const;
-
-          /**
-           * A function that returns the corresponding rotation axis/angle for
-           * a rotation described by a rotation matrix.
-           */
-          double
-          rotation_axis_from_matrix (Tensor<1,3> &rotation_axis,
-                                     const Tensor<2,3> &rotation_matrix) const;
-
-          /**
-           * Convert a tensor of rank 1 and dimension in to rank 1 and
-           * dimension out. If $out < in$ the last elements will be discarded,
-           * if $out > in$ zeroes will be appended to fill the tensor.
-           */
-          template <int in, int out>
-          Tensor<1,out> convert_tensor (const Tensor<1,in> &old_tensor) const;
-
-          /**
-           * Return the cartesian coordinates of a spherical surface position
-           * defined by theta (polar angle, not geographical latitude) and
-           * phi.
-           */
-          Tensor<1,3>
-          cartesian_surface_coordinates(const Tensor<1,3> &sposition) const;
-
-          /**
-           * This function looks up the north- and east-velocities at a given
-           * position and converts them to cartesian velocities.
-           */
-          Tensor<1,dim>
-          cartesian_velocity_at_surface_point(const std::array<double,3> &spherical_point) const;
-
-          /**
-           * Returns cartesian velocities calculated from surface velocities
-           * and position in spherical coordinates
-           *
-           * @param s_velocities Surface velocities in spherical coordinates
-           * (theta, phi)
-           * @param s_position Position in spherical coordinates
-           * (radius,phi,theta)
-           */
-          Tensor<1,3> sphere_to_cart_velocity(const Tensor<1,2> &s_velocities,
-                                              const std::array<double,3> &s_position) const;
-
-          /**
-           * Check whether the gpml file was created by GPlates1.4 or later.
-           * We need to know this, because the mesh has changed its longitude
-           * origin from 0 to -180 degrees and we need to correct for this.
-           */
-          bool
-          gplates_1_4_or_higher(const boost::property_tree::ptree &pt) const;
-      };
-    }
-
-    /**
-     * A class that implements prescribed velocity boundary conditions
-     * determined from GPlates input files. The interpolation in time is
-     * performed between two objects of the GPlatesLookup class.
-     *
-     * @ingroup BoundaryVelocities
-     */
-    template <int dim>
-    class GPlates : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        GPlates ();
-
-        /**
-         * Return the boundary velocity as a function of position. For the
-         * current class, this function returns value from gplates.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position) const override;
-
-        // avoid -Woverloaded-virtual warning until the deprecated function
-        // is removed from the interface:
-        using Interface<dim>::boundary_velocity;
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        /**
-         * A function that is called at the beginning of each time step. For
-         * the current plugin, this function loads the next velocity files if
-         * necessary and outputs a warning if the end of the set of velocity
-         * files is reached.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A variable that stores the currently used data file of a series. It
-         * gets updated if necessary by update().
-         */
-        int current_file_number;
-
-        /**
-         * Time from which on the data file with number 'First data file
-         * number' is used as boundary condition. Previous to this time, 0 is
-         * returned for every field. Depending on the setting of the global
-         * 'Use years in output instead of seconds' flag in the input file,
-         * this number is either interpreted as seconds or as years."
-         */
-        double first_data_file_model_time;
-
-        /**
-         * Number of the first data file to be loaded when the model time is
-         * larger than 'First data file model time'.
-         */
-        int first_data_file_number;
-
-        /**
-         * In some cases the boundary files are not numbered in increasing but
-         * in decreasing order (e.g. 'Ma BP'). If this flag is set to 'True'
-         * the plugin will first load the file with the number 'First data
-         * file number' and decrease the file number during the model run.
-         */
-        bool decreasing_file_order;
-
-        /**
-         * Time in model units (depends on other model inputs) between two
-         * velocity files.
-         */
-        double data_file_time_step;
-
-        /**
-         * Weight between velocity file n and n+1 while the current time is
-         * between the two values t(n) and t(n+1).
-         */
-        double time_weight;
-
-        /**
-         * State whether we have time_dependent boundary conditions. Switched
-         * off after finding no more velocity files to suppress attempts to read
-         * in new files.
-         */
-        bool time_dependent;
-
-        /**
-         * Directory in which the gplates velocity files are present.
-         */
-        std::string data_directory;
-
-        /**
-         * First part of filename of velocity files. The files have to have
-         * the pattern velocity_file_name.n.gpml where n is the number of the
-         * current timestep (starts from 0).
-         */
-        std::string velocity_file_name;
-
-        /**
-         * Scale the velocity boundary condition by a scalar factor.
-         */
-        double velocity_scaling_factor;
-
-        /**
-         * Two user defined points that prescribe the plane from which the 2D
-         * model takes the velocity boundary condition. One can think of this,
-         * as if the model is lying in this plane although no actual model
-         * coordinate is changed. The strings need to have the format "a,b"
-         * where a and b are doubles and define theta and phi on a sphere.
-         */
-        std::string point1;
-        std::string point2;
-
-        /**
-         * Parsed user input of point1 and point2
-         */
-        Tensor<1,2> pointone;
-        Tensor<1,2> pointtwo;
-
-        /**
-         * Determines the depth of the lithosphere. The user might want to apply
-         * the GPlates velocities not only at the surface of the model, but also
-         * in the whole lithosphere. At every side boundary point with a depth
-         * smaller than this value (and thus being located in the lithosphere),
-         * the surface velocity will be described.
-         */
-        double lithosphere_thickness;
-
-        /**
-         * Pointer to an object that reads and processes data we get from
-         * gplates files.
-         */
-        std::unique_ptr<internal::GPlatesLookup<dim>> lookup;
-
-        /**
-         * Pointer to an object that reads and processes data we get from
-         * gplates files. This saves the previous data time step.
-         */
-        std::unique_ptr<internal::GPlatesLookup<dim>> old_lookup;
-
-        /**
-         * Handles the update of the velocity data in lookup. The input
-         * parameter makes sure that both velocity files (n and n+1) can be
-         * reloaded if the model time step is larger than the velocity file
-         * time step.
-         */
-        void
-        update_data (const bool load_both_files);
-
-        /**
-         * Handles settings and user notification in case the time-dependent
-         * part of the boundary condition is over.
-         */
-        void
-        end_time_dependence ();
-
-        /**
-         * Create a filename out of the name template.
-         */
-        std::string
-        create_filename (const int timestep) const;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_velocity/interface.h.bak b/include/aspect/boundary_velocity/interface.h.bak
deleted file mode 100644
index e81c6e6cdfd..00000000000
--- a/include/aspect/boundary_velocity/interface.h.bak
+++ /dev/null
@@ -1,349 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_velocity_interface_h
-#define _aspect_boundary_velocity_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/simulator_access.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/point.h>
-#include <deal.II/base/parameter_handler.h>
-
-#include <boost/core/demangle.hpp>
-#include <typeinfo>
-
-
-namespace aspect
-{
-  /**
-   * A namespace in which we define everything that has to do with defining
-   * the velocity boundary conditions.
-   *
-   * @ingroup BoundaryVelocities
-   */
-  namespace BoundaryVelocity
-  {
-    using namespace dealii;
-
-    /**
-     * A base class for parameterizations of velocity boundary conditions.
-     *
-     * @ingroup BoundaryVelocities
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Return the velocity that is to hold at a particular position on
-         * the boundary of the domain.
-         *
-         * @param boundary_indicator The boundary indicator of the part of the
-         * boundary of the domain on which the point is located at which we
-         * are requesting the velocity.
-         * @param position The position of the point at which we ask for the
-         * velocity.
-         *
-         * @return Boundary velocity at position @p position.
-         */
-        virtual
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position) const = 0;
-    };
-
-    /**
-     * A class that manages all boundary velocity objects.
-     *
-     * @ingroup BoundaryVelocities
-     */
-    template <int dim>
-    class Manager : public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Destructor. Made virtual since this class has virtual member
-         * functions.
-         */
-        ~Manager () override;
-
-        /**
-         * A function that is called at the beginning of each time step and
-         * calls the corresponding functions of all created plugins.
-         *
-         * The point of this function is to allow complex boundary velocity
-         * models to do an initialization step once at the beginning of each
-         * time step. An example would be a model that needs to call an
-         * external program to compute the velocity change at a boundary.
-         */
-        virtual
-        void
-        update ();
-
-        /**
-         * A function that calls the boundary_velocity functions of all the
-         * individual boundary velocity objects and uses the stored operators
-         * to combine them.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position) const;
-
-        /**
-         * A function that is used to register boundary velocity objects in such
-         * a way that the Manager can deal with all of them without having to
-         * know them by name. This allows the files in which individual
-         * plugins are implemented to register these plugins, rather than also
-         * having to modify the Manager class by adding the new boundary
-         * velocity plugin class.
-         *
-         * @param name A string that identifies the boundary velocity model
-         * @param description A text description of what this model does and that
-         * will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that can be
-         * used to declare the parameters that this boundary velocity model
-         * wants to read from input files.
-         * @param factory_function A pointer to a function that can create an
-         * object of this boundary velocity model.
-         */
-        static
-        void
-        register_boundary_velocity (const std::string &name,
-                                    const std::string &description,
-                                    void (*declare_parameters_function) (ParameterHandler &),
-                                    std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-
-        /**
-         * Return the names of all prescribed boundary velocity models currently
-         * used in the computation as specified in the input file. The function
-         * returns a map between a boundary identifier and a pair. The
-         * first part of the pair is a string that represents the prescribed
-         * velocity components on this boundary (e.g. y, xz, or xyz) and the
-         * second part is a vector of strings that represent the names of
-         * boundary velocity plugins for this boundary.
-         * If there are no prescribed boundary velocity plugins
-         * for a particular boundary, this boundary identifier will not appear
-         * in the map.
-         */
-        const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> &
-        get_active_boundary_velocity_names () const;
-
-        /**
-         * Return pointers to all boundary velocity models
-         * currently used in the computation, as specified in the input file.
-         * The function returns a map between a boundary identifier and a vector
-         * of unique pointers that represent the names of prescribed velocity
-         * boundary models for this boundary. If there are no prescribed
-         * boundary velocity plugins for a particular boundary this boundary
-         * identifier will not appear in the map.
-         */
-        const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>> &
-        get_active_boundary_velocity_conditions () const;
-
-        /**
-         * Return a list of boundary ids on which the velocity is prescribed
-         * to be zero (no-slip).
-         */
-        const std::set<types::boundary_id> &
-        get_zero_boundary_velocity_indicators () const;
-
-        /**
-         * Return a list of boundary ids on which the velocity is prescribed
-         * to be tangential (free-slip).
-         */
-        const std::set<types::boundary_id> &
-        get_tangential_boundary_velocity_indicators () const;
-
-        /**
-         * Declare the parameters of all known boundary velocity plugins, as
-         * well as the ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which boundary velocity objects will be created;
-         * then let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm);
-
-        /**
-         * Go through the list of all boundary velocity models that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename BoundaryVelocityType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryVelocityType>::value>>
-        bool
-        has_matching_boundary_velocity_model () const;
-
-        /**
-         * Go through the list of all boundary velocity models that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no boundary velocity model is active that matches the given type,
-         * throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename BoundaryVelocityType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,BoundaryVelocityType>::value>>
-        const BoundaryVelocityType &
-        get_matching_boundary_velocity_model () const;
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcBoundaryVelocityNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered boundary velocity objects.");
-      private:
-        /**
-         * A list of boundary velocity objects that have been requested in the
-         * parameter file.
-         */
-        std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>> boundary_velocity_objects;
-
-        /**
-         * Map from boundary id to a pair
-         * ("components", list of "velocity boundary type"),
-         * where components is of the format "[x][y][z]" and the velocity type is
-         * mapped to one of the plugins of velocity boundary conditions (e.g.
-         * "function"). If the components string is empty, it is assumed the
-         * plugins are used for all components.
-         */
-        std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> boundary_velocity_indicators;
-
-        /**
-         * A set of boundary indicators, on which velocities are prescribed to
-         * zero (no-slip).
-         */
-        std::set<types::boundary_id> zero_velocity_boundary_indicators;
-
-        /**
-         * A set of boundary indicators, on which velocities are prescribed to
-         * be tangential (free-slip).
-         */
-        std::set<types::boundary_id> tangential_velocity_boundary_indicators;
-    };
-
-
-
-    template <int dim>
-    template <typename BoundaryVelocityType, typename>
-    inline
-    bool
-    Manager<dim>::has_matching_boundary_velocity_model () const
-    {
-      for (const auto &boundary : boundary_velocity_objects)
-        for (const auto &p : boundary.second)
-          if (Plugins::plugin_type_matches<BoundaryVelocityType>(*p))
-            return true;
-      return false;
-    }
-
-
-    template <int dim>
-    template <typename BoundaryVelocityType, typename>
-    inline
-    const BoundaryVelocityType &
-    Manager<dim>::get_matching_boundary_velocity_model () const
-    {
-      AssertThrow(has_matching_boundary_velocity_model<BoundaryVelocityType> (),
-                  ExcMessage("You asked BoundaryVelocity::Manager::get_boundary_velocity_model() for a "
-                             "boundary velocity model of type <" + boost::core::demangle(typeid(BoundaryVelocityType).name()) + "> "
-                             "that could not be found in the current model. Activate this "
-                             "boundary velocity model in the input file."));
-
-      for (const auto &boundary : boundary_velocity_objects)
-        for (const auto &p : boundary)
-          if (Plugins::plugin_type_matches<BoundaryVelocityType>(*p))
-            return Plugins::get_plugin_as_type<BoundaryVelocityType>(*p);
-
-      // We will never get here, because we had the Assert above. Just to avoid warnings.
-      return Plugins::get_plugin_as_type<BoundaryVelocityType>(**(boundary_velocity_objects.begin()));
-    }
-
-
-    /**
-     * Return a string that consists of the names of boundary velocity models that can
-     * be selected. These names are separated by a vertical line '|' so
-     * that the string can be an input to the deal.II classes
-     * Patterns::Selection or Patterns::MultipleSelection.
-     */
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ();
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a boundary velocity model, register it with the functions that
-     * can declare their parameters and create these objects.
-     *
-     * @ingroup BoundaryVelocities
-     */
-#define ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(classname, name, description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryVelocity::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::BoundaryVelocity::Manager<2>::register_boundary_velocity, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::BoundaryVelocity::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::BoundaryVelocity::Manager<3>::register_boundary_velocity, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/boundary_velocity/zero_velocity.h.bak b/include/aspect/boundary_velocity/zero_velocity.h.bak
deleted file mode 100644
index 03ddb3f6e86..00000000000
--- a/include/aspect/boundary_velocity/zero_velocity.h.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_boundary_velocity_zero_velocity_h
-#define _aspect_boundary_velocity_zero_velocity_h
-
-#include <aspect/boundary_velocity/interface.h>
-
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements zero velocity (stick) boundary conditions.
-     *
-     * @ingroup BoundaryVelocities
-     */
-    template <int dim>
-    class ZeroVelocity : public Interface<dim>
-    {
-      public:
-        /**
-         * Return the boundary velocity as a function of position. For the
-         * current class, this function obviously simply returns a zero
-         * tensor.
-         */
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position) const override;
-
-        // avoid -Woverloaded-virtual warning until the deprecated function
-        // is removed from the interface:
-        using Interface<dim>::boundary_velocity;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/citation_info.h.bak b/include/aspect/citation_info.h.bak
deleted file mode 100644
index 1514f29b101..00000000000
--- a/include/aspect/citation_info.h.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_citation_info_h
-#define _aspect_citation_info_h
-
-#include <string>
-#include <iostream>
-
-/**
- * A namespace to provide information to the user about stuff to cite.
- */
-namespace CitationInfo
-{
-  /**
-   * Get the URL in the format "citing.html?(parameters)" that describes how to
-   * cite ASPECT based on the current model you are running.
-   */
-  const std::string get_url_part ();
-
-  /**
-   * Add the paper identified by the given id to the currently used list of
-   * papers. See citing.html for the list of ids. For specific features inside
-   * ASPECT that have associated publications, call this function if the
-   * feature is used in the current computation. For example, if the
-   * computation requires melt migration, call <tt>add("melt")</tt>.
-   */
-  void add (const std::string &id);
-
-  /**
-   * Print the info text containing the citation info into the given
-   * stream.
-   */
-  template <class Stream>
-  void print_info_block (Stream &stream)
-  {
-    stream << "-----------------------------------------------------------------------------\n"
-           << "-- For information on how to cite ASPECT, see:\n"
-           << "--   https://aspect.geodynamics.org/" << get_url_part() << "\n"
-           << "-----------------------------------------------------------------------------"
-           << std::endl;
-  }
-}
-
-#endif
diff --git a/include/aspect/compat.h.bak b/include/aspect/compat.h.bak
deleted file mode 100644
index 3ff1642ae4c..00000000000
--- a/include/aspect/compat.h.bak
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_compat_h
-#define _aspect_compat_h
-
-#include <aspect/global.h>
-// C++11 related includes.
-#include <array>
-#include <functional>
-#include <memory>
-
-namespace big_mpi
-{
-
-  using dealii::Utilities::MPI::broadcast;
-
-}
-
-// deal.II 9.6 introduces the new MGTransferMF class as a replacement
-// for MGTransferMatrixFree. Instead of putting an ifdef in every place,
-// do this in one central location:
-#if !DEAL_II_VERSION_GTE(9,6,0)
-#include <deal.II/multigrid/mg_transfer_matrix_free.h>
-namespace dealii
-{
-  template <int dim, class NumberType>
-  using MGTransferMF = MGTransferMatrixFree<dim,NumberType>;
-}
-#endif
-
-
-
-// deal.II versions up to 9.5 had a poorly designed interface of the
-// SphericalManifold class that made it impossible for us to use.
-// This file thus contains a copy of it.
-#if !DEAL_II_VERSION_GTE(9,6,0)
-
-#include <deal.II/grid/manifold.h>
-#include <deal.II/grid/manifold_lib.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  /**
-   * The deal.II class SphericalManifold has a design flaw that made it
-   * impossible to derive from the class. This is fixed post-9.5,
-   * see https://github.com/dealii/dealii/pull/16242 and
-   * https://github.com/dealii/dealii/pull/16248, but we can't
-   * use deal.II 9.5 and earlier for this class. The current class
-   * here is therefore a copy of the fixed class.
-   */
-  template <int dim, int spacedim = dim>
-  class SphericalManifold : public Manifold<dim, spacedim>
-  {
-    public:
-      /**
-       * Constructor.
-       *
-       * @param[in] center The center of the coordinate system. Defaults to the
-       * origin.
-       */
-      SphericalManifold(const Point<spacedim> center = Point<spacedim>());
-
-      /**
-       * Make a clone of this Manifold object.
-       */
-      virtual std::unique_ptr<Manifold<dim, spacedim>>
-      clone() const override;
-
-      /**
-       * Given any two points in space, first project them on the surface
-       * of a sphere with unit radius, then connect them with a geodesic
-       * and find the intermediate point, and finally rescale the final
-       * radius so that the resulting one is the convex combination of the
-       * starting radii.
-       */
-      virtual Point<spacedim>
-      get_intermediate_point(const Point<spacedim> &p1,
-                             const Point<spacedim> &p2,
-                             const double           w) const override;
-
-      /**
-       * Compute the derivative of the get_intermediate_point() function
-       * with parameter w equal to zero.
-       */
-      virtual Tensor<1, spacedim>
-      get_tangent_vector(const Point<spacedim> &x1,
-                         const Point<spacedim> &x2) const override;
-
-      /**
-       * @copydoc Manifold::normal_vector()
-       */
-      virtual Tensor<1, spacedim>
-      normal_vector(
-        const typename Triangulation<dim, spacedim>::face_iterator &face,
-        const Point<spacedim> &p) const override;
-
-      /**
-       * Compute the normal vectors to the boundary at each vertex.
-       */
-      virtual void
-      get_normals_at_vertices(
-        const typename Triangulation<dim, spacedim>::face_iterator &face,
-        typename Manifold<dim, spacedim>::FaceVertexNormals &face_vertex_normals)
-      const override;
-
-      /**
-       * Compute a new set of points that interpolate between the given points @p
-       * surrounding_points. @p weights is a table with as many columns as @p
-       * surrounding_points.size(). The number of rows in @p weights must match
-       * the length of @p new_points.
-       *
-       * This function is optimized to perform on a collection
-       * of new points, by collecting operations that are not dependent on the
-       * weights outside of the loop over all new points.
-       *
-       * The implementation does not allow for @p surrounding_points and
-       * @p new_points to point to the same array, so make sure to pass different
-       * objects into the function.
-       */
-      virtual void
-      get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
-                     const Table<2, double>                 &weights,
-                     ArrayView<Point<spacedim>> new_points) const override;
-
-      /**
-       * Return a point on the spherical manifold which is intermediate
-       * with respect to the surrounding points.
-       */
-      virtual Point<spacedim>
-      get_new_point(const ArrayView<const Point<spacedim>> &vertices,
-                    const ArrayView<const double>          &weights) const override;
-
-      /**
-       * The center of the spherical coordinate system.
-       */
-      const Point<spacedim> center;
-
-    private:
-      /**
-       * Return a point on the spherical manifold which is intermediate
-       * with respect to the surrounding points. This function uses a linear
-       * average of the directions to find an estimated point. It returns a pair
-       * of radius and direction from the center point to the candidate point.
-       */
-      std::pair<double, Tensor<1, spacedim>>
-      guess_new_point(const ArrayView<const Tensor<1, spacedim>> &directions,
-                      const ArrayView<const double>              &distances,
-                      const ArrayView<const double>              &weights) const;
-
-      /**
-       * This function provides an internal implementation of the get_new_points()
-       * interface.
-       *
-       * It computes a new set of points that interpolate between the given points
-       * @p
-       * surrounding_points. @p weights is an array view with as many entries as @p
-       * surrounding_points.size() times @p new_points.size().
-       *
-       * This function is optimized to perform on a collection
-       * of new points, by collecting operations that are not dependent on the
-       * weights outside of the loop over all new points.
-       *
-       * The implementation does not allow for @p surrounding_points and
-       * @p new_points to point to the same array, so make sure to pass different
-       * objects into the function.
-       */
-      void
-      do_get_new_points(const ArrayView<const Point<spacedim>> &surrounding_points,
-                        const ArrayView<const double>          &weights,
-                        ArrayView<Point<spacedim>>              new_points) const;
-
-      /**
-       * A manifold description to be used for get_new_point in 2d.
-       */
-      const PolarManifold<spacedim> polar_manifold;
-  };
-}
-
-#else
-
-// For sufficiently new deal.II versions, we can use the deal.II class, but to
-// avoid name clashes, we have to import the class into namespace aspect. Once
-// we rely on these sufficiently new versions of deal.II, we can not only remove
-// the code above, but also the following lines, and in all places where we
-// reference 'aspect::SphericalManifold' simply use 'SphericalManifold' instead
-// (which then refers to the deal.II class).
-
-#include <deal.II/grid/manifold_lib.h>
-namespace aspect
-{
-  using dealii::SphericalManifold;
-}
-
-#endif
-
-#endif
diff --git a/include/aspect/coordinate_systems.h.bak b/include/aspect/coordinate_systems.h.bak
deleted file mode 100644
index 6e4b5748cff..00000000000
--- a/include/aspect/coordinate_systems.h.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_coordinate_systems_h
-#define _aspect_coordinate_systems_h
-
-namespace aspect
-{
-  namespace Utilities
-  {
-    namespace Coordinates
-    {
-      /**
-       * This enum lists available coordinate systems that can be used for
-       * the function variables. Allowed values are 'cartesian',
-       * 'spherical', and 'depth'. 'spherical' coordinates follow: r, phi
-       * (2D) or r, phi, theta (3D); where r is radius, phi is longitude,
-       * and theta is the polar angle (colatitude). The 'depth' is a
-       * one-dimensional coordinate system in which only the distance
-       * below the 'top' surface (depth) as defined by each geometry model,
-       * is used.
-       */
-      enum CoordinateSystem
-      {
-        depth,
-        cartesian,
-        spherical,
-        ellipsoidal,
-        invalid
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/fe_variable_collection.h.bak b/include/aspect/fe_variable_collection.h.bak
deleted file mode 100644
index f98de32db12..00000000000
--- a/include/aspect/fe_variable_collection.h.bak
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_fe_variable_system_h
-#define _aspect_fe_variable_system_h
-
-#include <aspect/global.h>
-#include <deal.II/fe/component_mask.h>
-#include <deal.II/fe/fe_values_extractors.h>
-#include <deal.II/fe/fe.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  /**
-   * A structure to describe everything necessary to define a single variable
-   * of the finite element system in isolation. It groups the FiniteElement<dim> with other
-   * information like a name and the block structure used in linear systems. A
-   * std::vector of these structs will be converted into an ordered collection of
-   * objects of type FEVariable represented by FEVariableCollection to form the
-   * finite element system.
-   *
-   * Blocks are used to extract or solve for certain variables separately or
-   * in block based preconditioners.  As an example, in a Stokes problem one
-   * might want velocity and pressure in a single block (for use with a direct
-   * solver), or one block for all velocity components and a second block for
-   * the pressure (for a Schur complement-based preconditioner), or separate
-   * blocks for pressure and each velocity component.
-   */
-  template <int dim>
-  struct VariableDeclaration
-  {
-    /**
-     * Constructor.
-     *
-     * @param name A user-friendly and unique string representation of the variable.
-     *
-     * @param fe The FiniteElement class to use. Currently, this needs to be a scalar
-     * finite element class (with exactly one component).
-     *
-     * @param multiplicity Number of copies of the @p fe to create.
-     *
-     * @param n_blocks Number of blocks this variable represents inside the
-     * linear system. A value of 0 will add the next variable (in the std::vector<VariableDeclaration>
-     * that is used to construct the FEVariableCollection) to the current
-     * block, while 1 will put the next variable into a new block. A value
-     * that is equal to the number of components will create a block for each
-     * component.
-     */
-    VariableDeclaration(const std::string &name,
-                        const std::shared_ptr<FiniteElement<dim>> &fe,
-                        const unsigned int multiplicity,
-                        const unsigned int n_blocks);
-
-    /**
-     * Default constructor.
-     */
-    VariableDeclaration();
-
-    /**
-     * Return the total number of components of this variable.
-     */
-    unsigned int n_components() const;
-
-    /**
-     * Name of the variable used in FEVariableCollection to identify it.
-     */
-    std::string name;
-
-    /**
-     * The FiniteElement space.
-     */
-    std::shared_ptr<FiniteElement<dim>> fe;
-
-    /**
-     * The multiplicity used in FESystem: how many copies of @p fe are there?
-     */
-    unsigned int multiplicity;
-
-    /**
-     * Number of linear algebra blocks occupied by this variable. See
-     * constructor for details.
-     */
-    unsigned int n_blocks;
-  };
-
-  /**
-   * Struct to represent a variable as part of a FEVariableCollection. Constructed
-   * from an instance of VariableDeclaration<dim> but contains additional
-   * information that can be queried.
-   */
-  template <int dim>
-  struct FEVariable: public VariableDeclaration<dim>
-  {
-      /**
-       * Initialize this variable as part of a FESystem with the given
-       * indices for @p component, @p block, and @p base.
-       */
-      FEVariable(const VariableDeclaration<dim> &fe_variable,
-                 const unsigned int component_index,
-                 const unsigned int block_index,
-                 const unsigned int base_index);
-
-      /**
-       * The first component index of this variable within the
-       * FEVariableCollection.
-       */
-      unsigned int first_component_index;
-
-      /**
-       * The index of the block of the linear system this variable is
-       * placed in (within the FEVariableCollection).
-       */
-      unsigned int block_index;
-      /**
-       * This index represents the how-manyth variable this is in the
-       * FEVariableCollection and consequently the FESystem, so the
-       *
-       */
-      unsigned int base_index;
-
-      /**
-       * The component mask of this variable.
-       */
-      ComponentMask component_mask;
-
-      /**
-       * Return a scalar FeValuesExtractor if this variable is scalar.
-       */
-      const FEValuesExtractors::Scalar &extractor_scalar() const;
-
-      /**
-       * Return a vector FeValuesExtractor if this variable is a vector.
-       */
-      const FEValuesExtractors::Vector &extractor_vector() const;
-
-    private:
-      /**
-       * Stores the object returned by extractor_scalar().
-       */
-      FEValuesExtractors::Scalar scalar_extractor;
-
-      /**
-       * Stores the object returned by extractor_vector().
-       */
-      FEValuesExtractors::Vector vector_extractor;
-  };
-
-
-  /**
-   * A class that represents a collection of variables (of type FEVariable) to
-   * form a Finite Element system.  A dealii::FESystem can be constructed
-   * from it using get_fes() and get_multiplicities().  Other information
-   * contained in this class on top of FESystem are names, and the block
-   * structure for linear systems.
-   */
-  template <int dim>
-  class FEVariableCollection
-  {
-    public:
-      /**
-       * Construct an empty object.
-       */
-      FEVariableCollection();
-
-      /**
-       * Construct object from a vector of variables (identical to calling
-       * initialize()).
-       */
-      FEVariableCollection(const std::vector<VariableDeclaration<dim>> &variable_definitions);
-
-      /**
-       * Fill this object with the given list of @p variables.
-       */
-      void initialize(const std::vector<VariableDeclaration<dim>> &variable_definitions);
-
-      /**
-       * Return the variable with name @p name. Throws an exception if this
-       * variable does not exist. If more than one variable with the same name
-       * exists, return the first one. Use variables_with_name() if you want
-       * to access all of them.
-       */
-      const FEVariable<dim> &variable(const std::string &name) const;
-
-      /**
-       * Return a vector of pointers of all variables with name @p name.
-       */
-      std::vector<const FEVariable<dim>*> variables_with_name(const std::string &name) const;
-
-      /**
-       * Returns true if the variable with @p name exists in the list of
-       * variables.
-       */
-      bool variable_exists(const std::string &name) const;
-
-      /**
-       * Return the list of all variables.
-       */
-      const std::vector<FEVariable<dim>> &get_variables() const;
-
-      /**
-       * Return the total number of components in the system.
-       */
-      unsigned int n_components() const;
-
-      /**
-       * Return the total number of block of the system.
-       */
-      unsigned int n_blocks() const;
-
-      /**
-       * Return the vector of finite element spaces used for the construction
-       * of the FESystem.
-       */
-      const std::vector<const FiniteElement<dim> *> &get_fes() const;
-
-      /**
-       * Return the vector of multiplicities used for the construction of the
-       * FESystem.
-       */
-      const std::vector<unsigned int> &get_multiplicities() const;
-
-      /**
-       * Return a variable that describes for each vector component which
-       * vector block it corresponds to.
-       */
-      const std::vector<unsigned int> &get_components_to_blocks() const;
-
-    protected:
-      /**
-       * A std::vector that contains a collection of variables.
-       */
-      std::vector<FEVariable<dim>> variables;
-
-      /**
-       * Total number of components of all variables, returned by n_components().
-       */
-      unsigned int n_components_;
-
-      /**
-       * Total number of blocks of all variables, returned by n_blocks().
-       */
-      unsigned int n_blocks_;
-
-      /**
-       * Data to be used in the FESystem constructor. The get_fes() function
-       * returns a reference to this array.
-       *
-       * The pointers stored in this area are not owned by the current object,
-       * but are instead pointers to the finite elements owned by the elements
-       * of the `variables` array. As a consequence, we do not need to
-       * explicitly manage the deallocation of these pointers.
-       */
-      std::vector<const FiniteElement<dim> *> fes;
-
-      /**
-       * Data to be used in the FESystem constructor, returned by
-       * get_multiplicities().
-       */
-      std::vector<unsigned int> multiplicities;
-
-      /**
-       * Mapping from component to block, returned by get_components_to_blocks().
-       */
-      std::vector<unsigned int> components_to_blocks;
-  };
-
-} // namespace aspect
-
-#endif
diff --git a/include/aspect/geometry_model/box.h.bak b/include/aspect/geometry_model/box.h.bak
deleted file mode 100644
index de695292bf5..00000000000
--- a/include/aspect/geometry_model/box.h.bak
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_box_h
-#define _aspect_geometry_model_box_h
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes a box geometry of certain width, height, and
-     * depth (in 3d), and, possibly, topography.
-     */
-    template <int dim>
-    class Box : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run and after
-         * the SimulatorAccess (if applicable) is initialized.
-         */
-        void initialize () override;
-
-        /**
-         * Add initial topography to the mesh.
-         */
-        void topography (typename parallel::distributed::Triangulation<dim> &grid) const;
-
-        /**
-         * Relocate the vertical coordinate of the given point based on
-         * the topography at the surface specified by the initial topography
-         * model.
-         */
-        Point<dim> add_topography (const Point<dim> &x_y_z) const;
-
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         */
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
-
-        /**
-         * Return a point that denotes the size of the box in each dimension
-         * of the domain.
-         */
-        virtual
-        Point<dim> get_extents () const;
-
-        /**
-         * Return an integer array that denotes the number of repetitions of
-         * the box's coarse mesh.
-         */
-        const std::array<unsigned int, dim> &
-        get_repetitions () const;
-
-        /**
-         * Return a point that denotes the lower left corner of the box
-         * domain.
-         */
-        virtual
-        Point<dim> get_origin () const;
-
-        /**
-         * Return the typical length scale one would expect of features in
-         * this geometry, assuming realistic parameters.
-         *
-         * We return 1/100th of the diameter of the box.
-         */
-        double length_scale () const override;
-
-
-        /**
-         * Return the depth that corresponds to the given
-         * position. The documentation of the base class (see
-         * GeometryModel::Interface::depth()) describes in detail how
-         * "depth" is interpreted in general.
-         *
-         * Computing a depth requires a geometry model to define a
-         * "vertical" direction. The current class considers the
-         * $(0,1)^T$ vector in 2d (and the $(0,0,1)^T$ vector in 3d)
-         * as vertical and considers the "top" boundary as the
-         * surface. In almost all cases one will use a gravity model
-         * that also matches these definitions.
-         *
-         * Note that the depth is calculated with respect to the
-         * surface without initial topography.
-         */
-        double depth(const Point<dim> &position) const override;
-
-        /**
-         * Return the height of the given position relative to
-         * the initial box height.
-         */
-        double height_above_reference_surface(const Point<dim> &position) const override;
-
-        /**
-         * @copydoc Interface::representative_point()
-         */
-        Point<dim> representative_point(const double depth) const override;
-
-        /**
-         * @copydoc Interface::maximal_depth()
-         */
-        double maximal_depth() const override;
-
-        /**
-         * Return the set of boundary indicators that are used by this model.
-         * This information is used to determine what boundary indicators can
-         * be used in the input file.
-         *
-         * The box model uses boundary indicators zero through 2*dim-1, with
-         * the first two being the faces perpendicular to the x-axis, the next
-         * two perpendicular to the y-axis, etc.
-         */
-        std::set<types::boundary_id>
-        get_used_boundary_indicators () const override;
-
-        /**
-         * Return a mapping from symbolic names of each part of the boundary
-         * to the corresponding boundary indicator. This allows users to
-         * specify *names*, not just *numbers* in their input files when
-         * describing which parts of the boundary have to satisfy which
-         * boundary conditions.
-         *
-         * This geometry returns the map <code>{{"left"->0}, {"right"->1},
-         * {"bottom"->2}, {"top"->3}}</code> in 2d, and <code>{{"left"->0},
-         * {"right"->1}, {"front"->2}, {"back"->3}, {"bottom"->4},
-         * {"top"->5}}</code> in 3d.
-         */
-        std::map<std::string,types::boundary_id>
-        get_symbolic_boundary_names_map () const override;
-
-        /**
-         * Return the set of periodic boundaries as described in the input
-         * file.
-         */
-        std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
-        get_periodic_boundary_pairs () const override;
-
-        /**
-         * @copydoc Interface::adjust_positions_for_periodicity
-         *
-         * Apply a translation to all points outside of the domain
-         * to account for periodicity.
-         */
-        void
-        adjust_positions_for_periodicity (Point<dim> &position,
-                                          const ArrayView<Point<dim>> &connected_positions = {},
-                                          const ArrayView<Tensor<1, dim>> &connected_velocities = {}) const override;
-
-        /**
-         * @copydoc Interface::has_curved_elements()
-         *
-         * A box has only straight boundaries and cells, so return false.
-         */
-        bool
-        has_curved_elements() const override;
-
-        /**
-         * Return whether the given point lies within the domain specified
-         * by the geometry. This function does not take into account
-         * initial or dynamic surface topography.
-         */
-        bool
-        point_is_in_domain(const Point<dim> &point) const override;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is,
-         * which for a box is Cartesian.
-         */
-        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a box
-         * the results is unchanged and is (x,z) in 2d or (x,y,z) in 3d.
-         */
-        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A pointer to the initial topography model.
-         */
-        InitialTopographyModel::Interface<dim> *topo_model;
-
-        /**
-         * Extent of the box in x-, y-, and z-direction (in 3d).
-         */
-        Point<dim> extents;
-
-        /**
-         * Origin of the box in x, y, and z (in 3d) coordinates.
-         */
-        Point<dim> box_origin;
-
-        /**
-         * Flag whether the box is periodic in the x-, y-, and z-direction.
-         */
-        std::array<bool, dim> periodic;
-
-        /**
-         * The number of cells in each coordinate direction.
-         */
-        std::array<unsigned int, dim> repetitions;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/chunk.h.bak b/include/aspect/geometry_model/chunk.h.bak
deleted file mode 100644
index ed34f5801f3..00000000000
--- a/include/aspect/geometry_model/chunk.h.bak
+++ /dev/null
@@ -1,428 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_chunk_h
-#define _aspect_geometry_model_chunk_h
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/compat.h>
-
-#include <deal.II/grid/manifold.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/grid/grid_out.h>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    using namespace dealii;
-
-    namespace internal
-    {
-      /**
-       * ChunkGeometry is a class that implements the interface of
-       * ChartManifold. The function push_forward takes a point
-       * in the reference (radius,lon,lat) domain and transforms
-       * it into real space (cartesian). The inverse function
-       * pull_back reverses this operation.
-       * The push_forward_gradient provides derivatives of the
-       * reference coordinates to the real space coordinates,
-       * which are used in computing normal vectors.
-       * The transformations can include topography added
-       * to the initially radially symmetric mesh.
-       */
-      template <int dim>
-      class ChunkGeometry : public ChartManifold<dim,dim>
-      {
-        public:
-          /**
-           * Constructor
-           */
-          ChunkGeometry(const InitialTopographyModel::Interface<dim> &topography,
-                        const double min_longitude,
-                        const double min_radius,
-                        const double max_depth);
-
-          /**
-           * Copy constructor
-           */
-          ChunkGeometry(const ChunkGeometry &other) = default;
-
-          /**
-           * This function receives a point in cartesian coordinates x, y and z,
-           * including initial prescribed topography and returns
-           * radius, longitude, latitude without topography.
-           */
-          Point<dim>
-          pull_back(const Point<dim> &space_point) const override;
-
-          /**
-           * This function receives a point in spherical coordinates
-           * radius, longitude, latitude and returns cartesian
-           * coordinates x, y and z, including any initially prescribed
-           * topography.
-           */
-          Point<dim>
-          push_forward(const Point<dim> &chart_point) const override;
-
-          /**
-           * This function provides the derivatives of the push_forward
-           * function to the spherical coordinates, which are needed
-           * in the computation of vectors tangential to the domain boundaries.
-           */
-          DerivativeForm<1, dim, dim>
-          push_forward_gradient(const Point<dim> &chart_point) const override;
-
-          /**
-           * This function receives a point in cartesian coordinates x, y and z,
-           * and returns radius, longitude, latitude.
-           */
-          Point<dim>
-          pull_back_sphere(const Point<dim> &space_point) const;
-
-          /**
-           * This function receives a point in spherical coordinates
-           * radius, longitude, latitude and returns cartesian
-           * coordinates x, y and z.
-           */
-          Point<dim>
-          push_forward_sphere(const Point<dim> &chart_point) const;
-
-          /**
-           * Return the (normalized) normal vector at the point @p p.
-           */
-          virtual Tensor<1, dim>
-          normal_vector(
-            const typename Triangulation<dim>::face_iterator &face,
-            const Point<dim> &p) const override;
-
-          /**
-           * This function computes the outer radius of the domain
-           * at the longitude (and latitude) of the given point
-           * (given in cartesian coordinates), i.e. the unperturbed
-           * outer radius + the topography.
-           */
-          double
-          get_radius(const Point<dim> &space_point) const;
-
-          /**
-           * Return a copy of this manifold.
-           */
-          std::unique_ptr<Manifold<dim,dim>>
-          clone() const override;
-
-        private:
-          /**
-           * A pointer to the topography model.
-           */
-          const InitialTopographyModel::Interface<dim> *topo;
-
-          /**
-           * The minimum longitude of the domain.
-           */
-          double point1_lon;
-
-          /**
-           * The inner radius of the domain.
-           */
-          double inner_radius;
-
-          /**
-           * The maximum depth not taking into account
-           * topography (outer radius minus inner radius).
-           */
-          double max_depth;
-
-          /**
-           * This function removes the initial topography from a
-           * given point in spherical coordinates R+topo, lon, lat.
-           * I.e. it returns R, lon, lat.
-           */
-          virtual
-          Point<dim>
-          pull_back_topo(const Point<dim> &space_point) const;
-
-          /**
-           * This function adds the initial topography to a
-           * given point in spherical coordinates R, lon, lat.
-           * I.e. it returns R+topo, lon, lat.
-           */
-          virtual
-          Point<dim>
-          push_forward_topo(const Point<dim> &chart_point) const;
-      };
-    }
-
-    /**
-     * A geometry model class that describes a chunk of a spherical shell.
-     * In 2D, this class simulates a sector with inner and outer radius, and
-     * minimum and maximum longitude. Longitude increases anticlockwise
-     * from the positive x-axis, as per the mathematical convention of phi.
-     * In 3D, the class simulates a chunk of a sphere, bounded by arbitrary
-     * lines of longitude, latitude and radius. Boundary indicator names are
-     * west, east, south, north, inner and outer.
-     *
-     * The parameters that describe this geometry and that are read from the
-     * input file are the inner and outer radii of the shell, the minimum
-     * and maximum longitude, minimum and maximum longitude, and the
-     * number of cells initialized in each dimension.
-     *
-     * Initial topography can be added through a radial displacement of the
-     * mesh nodes.
-     */
-    template <int dim>
-    class Chunk : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run and after
-         * the SimulatorAccess (if applicable) is initialized.
-         * This function calls the initialize function of the manifold
-         * with a pointer to the initial topography model obtained
-         * from SimulatorAccess.
-         */
-        void initialize () override;
-
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         */
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
-
-
-        /**
-         * Return the set of boundary indicators that are used by this model.
-         * This information is used to determine what boundary indicators can
-         * be used in the input file.
-         *
-         * The chunk model uses boundary indicators zero through 2*dim-1, with
-         * the first two being the faces perpendicular to the radius of the shell,
-         * the next two along lines of longitude and, in 3d, the next two
-         * along lines of latitude.
-         */
-        std::set<types::boundary_id>
-        get_used_boundary_indicators () const override;
-
-        /**
-         * Return a mapping from symbolic names of each part of the boundary
-         * to the corresponding boundary indicator. This allows users to
-         * specify *names*, not just *numbers* in their input files when
-         * describing which parts of the boundary have to satisfy which
-         * boundary conditions.
-         *
-         * This geometry returns the map <code>{{"bottom"->0}, {"top"->1},
-         * {"west"->2}, {"east"->3}}</code> in 2d, and <code>{{"bottom"->0},
-         * {"top"->1}, {"west"->2}, {"east"->3}, {"south"->4},
-         * {"north"->5}}</code> in 3d.
-         */
-        std::map<std::string,types::boundary_id>
-        get_symbolic_boundary_names_map () const override;
-
-
-        /**
-         * Return the typical length scale one would expect of features in
-         * this geometry, assuming realistic parameters.
-         *
-         * As described in the first ASPECT paper, a length scale of
-         * 10km = 1e4m works well for the pressure scaling for earth
-         * sized spherical shells. use a length scale that
-         * yields this value for the R0,R1 corresponding to earth
-         * but otherwise scales like (R1-R0)
-         */
-        double length_scale () const override;
-
-        /**
-         * Return the depth that corresponds to the given
-         * position. The documentation of the base class (see
-         * GeometryModel::Interface::depth()) describes in detail how
-         * "depth" is interpreted in general.
-         *
-         * Computing a depth requires a geometry model to define a
-         * "vertical" direction. The current class considers the
-         * radial vector away from the origin as vertical and
-         * considers the "top" boundary as the surface. In almost
-         * all cases one will use a gravity model that also matches
-         * these definitions.
-         */
-        double depth(const Point<dim> &position) const override;
-
-        /**
-         * Return the height of the given position relative to the outer
-         * radius.
-         */
-        double height_above_reference_surface(const Point<dim> &position) const override;
-
-        /**
-         * @copydoc Interface::representative_point()
-         */
-        Point<dim> representative_point(const double depth) const override;
-
-        /**
-         * Return the longitude at the western edge of the chunk measured in
-         * radians.
-         */
-        virtual
-        double west_longitude() const;
-
-        /**
-         * Return the longitude at the eastern edge of the chunk measured in
-         * radians.
-         */
-        virtual
-        double east_longitude() const;
-
-        /**
-         * Return the longitude range of the chunk measured in radians.
-         */
-        virtual
-        double longitude_range() const;
-
-        /**
-         * Return the latitude at the southern edge of the chunk measured in
-         * radians from the equator.
-         */
-        virtual
-        double south_latitude() const;
-
-        /**
-         * Return the latitude at the northern edge of the chunk measured in
-         * radians from the equator.
-         */
-        virtual
-        double north_latitude() const;
-
-        /**
-         * Return the latitude range of the chunk measured in radians
-         */
-        virtual
-        double latitude_range() const;
-
-        /**
-         * Return the maximum depth from the surface of the model measured in
-         * meters.
-         */
-        double maximal_depth() const override;
-
-        /**
-         * Return the inner radius of the chunk measured in meters.
-         */
-        virtual
-        double inner_radius() const;
-
-        /**
-         * Return the outer radius of the chunk measured in meters.
-         */
-        virtual
-        double outer_radius() const;
-
-
-        /**
-         * @copydoc Interface::has_curved_elements()
-         *
-         * A chunk has curved boundaries and cells, so return true.
-         */
-        bool
-        has_curved_elements() const override;
-
-        /**
-         * Return whether the given point lies within the domain specified
-         * by the geometry. This function does not take into account
-         * initial or dynamic surface topography.
-         */
-        bool
-        point_is_in_domain(const Point<dim> &point) const override;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is,
-         * which for a chunk is Spherical.
-         */
-        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a chunk
-         * this is (radius, longitude) in 2d and (radius, longitude, latitude) in 3d.
-         */
-        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Minimum longitude-depth or
-         * longitude-latitude-depth point
-         */
-        Point<dim> point1;
-
-        /**
-         * Maximum longitude-depth or
-         * longitude-latitude-depth point
-         */
-        Point<dim> point2;
-
-        /**
-         * The number of cells in each coordinate direction
-         */
-        std::array<unsigned int, dim> repetitions;
-
-        /**
-         * An object that describes the geometry. This pointer is
-         * initialized in the initialize() function, and serves as the manifold
-         * object that the triangulation is later given in create_coarse_mesh()
-         * where the triangulation clones it.
-         *
-         * The object is marked as 'const' to make it clear that it should not
-         * be modified once created. That is because the triangulation copies it,
-         * and modifying the current object will not have any impact on the
-         * manifold used by the triangulation.
-         */
-        std::unique_ptr<const internal::ChunkGeometry<dim>> manifold;
-
-        /**
-         * Give a symbolic name to the manifold id to be used by this class.
-         */
-        static const types::manifold_id my_manifold_id = 15;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/ellipsoidal_chunk.h.bak b/include/aspect/geometry_model/ellipsoidal_chunk.h.bak
deleted file mode 100644
index 516162ddfad..00000000000
--- a/include/aspect/geometry_model/ellipsoidal_chunk.h.bak
+++ /dev/null
@@ -1,346 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_ellipsoidal_chunk_h
-#define _aspect_geometry_model_ellipsoidal_chunk_h
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <deal.II/grid/manifold.h>
-
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    using namespace dealii;
-
-    namespace internal
-    {
-      /**
-       * A class which describes the manifold.
-       */
-      template <int dim>
-      class EllipsoidalChunkGeometry : public ChartManifold<dim,3,3>
-      {
-        public:
-          /**
-           * Constructor
-           */
-          EllipsoidalChunkGeometry(const InitialTopographyModel::Interface<dim> &topography,
-                                   const double para_semi_major_axis_a,
-                                   const double para_eccentricity,
-                                   const double para_semi_minor_axis_b,
-                                   const double para_bottom_depth,
-                                   const std::vector<Point<2>> &para_corners);
-
-          /**
-           * Copy constructor
-           */
-          EllipsoidalChunkGeometry(const EllipsoidalChunkGeometry &other) = default;
-
-          /**
-           * The deal.ii pull back function in 3d. This function receives
-           * cartesian points x,y and z and returns spherical/ellipsoidal
-           * coordinates phi, theta and depth, also accounting for the
-           * topography.
-           */
-          Point<3>
-          pull_back(const Point<3> &space_point) const override;
-
-          /**
-           * The deal.ii pull back function in 2d. This function should
-           * not be used, until the TODO in the cc file has been fixed.
-           */
-          virtual
-          Point<2>
-          pull_back(const Point<2> &space_point) const;
-
-          /**
-           * The deal.ii push forward function in 3d. This function receives
-           * spherical/ellipsoidal coordinates phi, theta and depth and
-           * returns cartesian points x,y and z, also accounting for the
-           * topography.
-           */
-          Point<3>
-          push_forward(const Point<3> &chart_point) const override;
-
-          /**
-           * This function does the actual pull back from the ellipsoid.
-           * For the equation details, please see deal.ii step 53.
-           */
-          Point<3> pull_back_ellipsoid (const Point<3> &x, const double semi_major_axis_a, const double eccentricity) const;
-
-          /**
-           * This function does the actual push forward to the ellipsoid.
-           * For the equation details, please see deal.ii step 53.
-           */
-          Point<3> push_forward_ellipsoid (const Point<3> &phi_theta_d, const double semi_major_axis_a, const double eccentricity) const;
-
-          /**
-           * Return a copy of this manifold.
-           */
-          std::unique_ptr<Manifold<dim,3>>
-          clone() const override;
-
-        private:
-          /**
-           * This function adds topography to the cartesian coordinates.
-           * For the equation details, please see deal.ii step 53.
-           */
-          Point<3> push_forward_topography (const Point<3> &phi_theta_d_hat) const;
-
-          /**
-           * This function removes topography from the cartesian coordinates.
-           * For the equation details, please see deal.ii step 53.
-           */
-          Point<3> pull_back_topography (const Point<3> &phi_theta_d) const;
-
-          /**
-           * A pointer to the topography model.
-           */
-          const InitialTopographyModel::Interface<dim> *topography;
-
-          const double semi_major_axis_a;
-          const double eccentricity;
-          const double semi_minor_axis_b;
-          const double bottom_depth;
-          const std::vector<Point<2>> corners;
-      };
-    }
-
-    /**
-     * A class that describes a geometry for an ellipsoid such as the WGS84 model of the earth.
-     *
-     * This geometry model implements a (3d) ellipsoidal chunk geometry where two of the axis have
-     * the same length. The ellipsoidal chunk can be a non-coordinate parallel part of the ellipsoid.
-     *
-     * @author This plugin is a joined effort of Menno Fraters, D. Sarah Stamps and Wolfgang Bangerth
-     */
-    template <int dim>
-    class EllipsoidalChunk : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialize function
-         */
-        void
-        initialize () override;
-
-
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         */
-        void
-        create_coarse_mesh(parallel::distributed::Triangulation<dim> &coarse_grid) const override;
-
-        /**
-         * Return the typical length scale one would expect of features in this geometry,
-         * assuming realistic parameters.
-         */
-        double
-        length_scale() const override;
-
-        /**
-         * Return the depth that corresponds to the given
-         * position. The documentation of the base class (see
-         * GeometryModel::Interface::depth()) describes in detail how
-         * "depth" is interpreted in general.
-         *
-         * Computing a depth requires a geometry model to define a
-         * "vertical" direction. The current class considers the
-         * radial vector away from the origin as vertical and
-         * considers the "outer" boundary as the "surface". In almost
-         * all cases one will use a gravity model that also matches
-         * these definitions.
-         */
-        double
-        depth(const Point<dim> &position) const override;
-
-        /**
-         * Placeholder for a function returning the height of the given
-         * position relative to the reference model surface.
-         */
-        double
-        height_above_reference_surface(const Point<dim> &position) const override;
-
-        /**
-         * Returns a point in the center of the domain.
-         */
-        Point<dim>
-        representative_point(const double depth) const override;
-
-        /**
-         * Return whether the given point lies within the domain specified
-         * by the geometry. This function does not take into account
-         * initial or dynamic surface topography.
-         */
-        bool
-        point_is_in_domain(const Point<dim> &point) const override;
-
-        /**
-         * Returns the bottom depth which was used to create the geometry and
-         * which is defined by the depth parameter.
-         */
-        double
-        maximal_depth() const override;
-
-        /**
-         * Return the set of boundary indicators that are used by this model. This
-         * information is used to determine what boundary indicators can be used in
-         * the input file.
-         *
-         * The box model uses boundary indicators zero through 2*dim-1, with the first
-         * two being the faces perpendicular to the x-axis, the next two perpendicular
-         * to the y-axis, etc.
-         */
-        std::set<types::boundary_id>
-        get_used_boundary_indicators() const override;
-
-        /**
-         * Set symbolic names for boundaries (mrtf)
-         */
-        std::map<std::string,types::boundary_id>
-        get_symbolic_boundary_names_map() const override;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is,
-         * which for a Ellipsoidal chunk is Ellipsoidal.
-         */
-        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a
-         * ellipsoidal chunk this is (radius, longitude) in 2d and (radius,
-         * longitude, latitude) in 3d. Note that internally the coordinates are
-         * stored in longitude, latitude, depth.
-         */
-        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters(ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter
-         * file.
-         */
-        void
-        parse_parameters(ParameterHandler &prm) override;
-
-        /**
-         * Calculate radius at current position.
-         */
-        double
-        get_radius(const Point<dim> &position) const;
-
-        /**
-         * Retrieve the semi minor axis b value.
-         */
-        double
-        get_semi_minor_axis_b() const;
-
-        /**
-         * Retrieve the semi major axis a value.
-         */
-        double
-        get_semi_major_axis_a() const;
-
-
-        /**
-         * Retrieve the value of the eccentricity.
-         */
-        double
-        get_eccentricity() const;
-
-
-        /**
-         * Retrieve the corners used to create the ellipsoid. This variable
-         * contains four vectors with each two elements. Each set of two
-         * elements represents a longitude and latitude value. The four
-         * vectors represent respectively the point in the North-East,
-         * North-West, South-West and South-East.
-         */
-        const std::vector<Point<2>> &
-        get_corners() const;
-
-
-        /**
-         * Retrieve the manifold object.
-         */
-        internal::EllipsoidalChunkGeometry<dim>
-        get_manifold() const;
-
-      private:
-        // Declare variables for reading in coordinates of the region of interest.
-        std::vector<Point<2>> corners;
-        double semi_major_axis_a;
-        double eccentricity;
-        double semi_minor_axis_b;
-        double rot_para_to_para_angle;
-        double para_to_rect_angle;
-        double rotation_longitude;
-        double rotation_latitude;
-        double bottom_depth;
-        double westLongitude;
-        double eastLongitude;
-        double northLatitude;
-        double southLatitude;
-        // Declare variables for subdividing
-        unsigned int EW_subdiv;
-        unsigned int NS_subdiv;
-        unsigned int depth_subdiv;
-
-
-
-        /**
-         * An object that describes the geometry. This pointer is
-         * initialized in the initialize() function, and serves as the manifold
-         * object that the triangulation is later given in create_coarse_mesh()
-         * where the triangulation clones it.
-         *
-         * The object is marked as 'const' to make it clear that it should not
-         * be modified once created. That is because the triangulation copies it,
-         * and modifying the current object will not have any impact on the
-         * manifold used by the triangulation.
-         */
-        std::unique_ptr<const internal::EllipsoidalChunkGeometry<dim>>   manifold;
-
-        void
-        set_boundary_ids(parallel::distributed::Triangulation<dim> &coarse_grid) const;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/ascii_data.h.bak b/include/aspect/geometry_model/initial_topography_model/ascii_data.h.bak
deleted file mode 100644
index 8481e1c29e7..00000000000
--- a/include/aspect/geometry_model/initial_topography_model/ascii_data.h.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_initial_topography_model_ascii_data_h
-#define _aspect_geometry_model_initial_topography_model_ascii_data_h
-
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements topography determined
-     * from an AsciiData input file.
-     *
-     * @ingroup InitialTopographyModel
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Sets the boundary id of the surface boundary.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataBoundary<dim>::initialize;
-
-
-        /**
-         * Return the surface topography as a function of position along the surface.
-         * For the current class, this function returns a value from the text files.
-         *
-         * @copydoc aspect::InitialTopographyModel::Interface::value()
-         */
-        double
-        value (const Point<dim-1> &surface_point) const override;
-
-        /**
-         * Return the maximum value of the elevation.
-         */
-        double max_topography () const override;
-
-        /**
-         * Return the gradient of the surface topography for a given position
-         * along the surface.
-         */
-        Tensor<1,dim-1>
-        vector_gradient(const Point<dim> &p) const;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        types::boundary_id surface_boundary_id;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/function.h.bak b/include/aspect/geometry_model/initial_topography_model/function.h.bak
deleted file mode 100644
index 7b7421e0e00..00000000000
--- a/include/aspect/geometry_model/initial_topography_model/function.h.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_initial_topography_model_function_h
-#define _aspect_geometry_model_initial_topography_model_function_h
-
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements initial topography based
-     * on a user-defined function..
-     *
-     * @ingroup InitialTopographyModels
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Function ();
-
-        /**
-         * Return the value of the initial topography as a function
-         * of surface position.
-         */
-        double
-        value (const Point<dim-1> &p) const override;
-
-        /**
-         * Return the maximum value of the elevation.
-         */
-        double max_topography () const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * The maximum value the topography can take.
-         */
-        double max_topo;
-
-        /**
-         * A function object representing the topography.
-         */
-        Functions::ParsedFunction<dim> initial_topography_function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/interface.h.bak b/include/aspect/geometry_model/initial_topography_model/interface.h.bak
deleted file mode 100644
index f964b77f585..00000000000
--- a/include/aspect/geometry_model/initial_topography_model/interface.h.bak
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_initial_topography_model_interface_h
-#define _aspect_geometry_model_initial_topography_model_interface_h
-
-#include <aspect/plugins.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/point.h>
-
-#include <set>
-
-
-namespace aspect
-{
-  /**
-   * A namespace for the definition of properties of the initial topography.
-   * This includes mainly the storage and retrieval of the initial topography.
-   * The retrieval is done through the value function, which requires a point
-   * of size dim-1, and it returns a double which represents the elevation.
-   *
-   * @ingroup InitialTopographyModels
-   */
-  namespace InitialTopographyModel
-  {
-    using namespace dealii;
-
-    /**
-     * Base class for classes that describe particular initial topographies
-     * for the domain.
-     *
-     * @ingroup InitialTopographyModels
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Return the value of the elevation at the given surface point.
-         *
-         * Note that different geometry models use different conventions for
-         * how they describe surface points. In general, the models use
-         * their own "natural" coordinate system. For example, box-type
-         * geometry models will generally provide points as x-y coordinates
-         * on the surface, whereas spherical-type geometry models will generally
-         * provide surface points in spherical coordinates.
-         */
-        virtual
-        double value (const Point<dim-1> &surface_point) const = 0;
-
-        /**
-         * Return the maximum value of the elevation.
-         */
-        virtual
-        double max_topography () const = 0;
-    };
-
-
-
-    /**
-     * Register a initial topography model so that it can be selected from the parameter
-     * file.
-     *
-     * @param name A string that identifies the initial topography model
-     * @param description A text description of what this model does and that
-     * will be listed in the documentation of the parameter file.
-     * @param declare_parameters_function A pointer to a function that can be
-     * used to declare the parameters that this initial topography model wants
-     * to read from input files.
-     * @param factory_function A pointer to a function that can create an
-     * object of this initial topography model.
-     *
-     * @ingroup InitialTopographyModels
-     */
-    template <int dim>
-    void
-    register_initial_topography_model (const std::string &name,
-                                       const std::string &description,
-                                       void (*declare_parameters_function) (ParameterHandler &),
-                                       std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-    /**
-     * A function that given the name of a model returns a pointer to an
-     * object that describes it. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The initial topography model will also be asked to read its runtime
-     * parameters already.
-     *
-     * @ingroup InitialTopographyModels
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_initial_topography_model (ParameterHandler &prm);
-
-
-    /**
-     * Declare the runtime parameters of the registered initial topography
-     * models.
-     *
-     * @ingroup InitialTopographyModels
-     */
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm);
-
-
-    /**
-     * For the current plugin subsystem, write a connection graph of all of the
-     * plugins we know about, in the format that the
-     * programs dot and neato understand. This allows for a visualization of
-     * how all of the plugins that ASPECT knows about are interconnected, and
-     * connect to other parts of the ASPECT code.
-     *
-     * @param output_stream The stream to write the output to.
-     */
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &output_stream);
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a initial topography model, register it with the functions that
-     * can declare their parameters and create these objects.
-     *
-     * @ingroup InitialTopographyModels
-     */
-#define ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::InitialTopographyModel::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::InitialTopographyModel::register_initial_topography_model<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::InitialTopographyModel::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::InitialTopographyModel::register_initial_topography_model<3>, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/prm_polygon.h.bak b/include/aspect/geometry_model/initial_topography_model/prm_polygon.h.bak
deleted file mode 100644
index 51364d75e96..00000000000
--- a/include/aspect/geometry_model/initial_topography_model/prm_polygon.h.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_initial_topography_prm_polygon_h
-#define _aspect_geometry_model_initial_topography_prm_polygon_h
-
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-
-
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes an initial topography for the geometry model,
-     * by defining a set of polygons on the surface from the prm file. It
-     * sets the elevation in each polygon to a constant value.
-     */
-    template <int dim>
-    class PrmPolygon : public Interface<dim>
-    {
-      public:
-        /**
-         * Return the value of the topography for a point.
-         */
-        double value (const Point<dim-1> &p) const override;
-
-        /**
-         * Return the maximum value of the elevation.
-         */
-        double max_topography () const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The values of the topography are stored in a vector.
-         */
-        std::vector<double> topography_values;
-
-        /**
-         * The maximum topography in this model
-         */
-        double maximum_topography;
-
-        /**
-         * The polygons and their points are stored in this vector.
-         */
-        std::vector<std::vector<Point<2>>> point_lists;
-
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/initial_topography_model/zero_topography.h.bak b/include/aspect/geometry_model/initial_topography_model/zero_topography.h.bak
deleted file mode 100644
index ce4fad60819..00000000000
--- a/include/aspect/geometry_model/initial_topography_model/zero_topography.h.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_initial_topography_model_zero_topography_h
-#define _aspect_geometry_model_initial_topography_model_zero_topography_h
-
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements zero initial topography.
-     *
-     * @ingroup InitialTopographyModels
-     */
-    template <int dim>
-    class ZeroTopography : public Interface<dim>
-    {
-      public:
-        /**
-         * Return the value of the initial topography as a function of position.
-         *
-         * For the current class, this function obviously simply returns a zero
-         * value.
-         */
-        double
-        value (const Point<dim-1> &p) const override;
-
-        /**
-         * Return the maximum value of the elevation.
-         */
-        double max_topography () const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/interface.h.bak b/include/aspect/geometry_model/interface.h.bak
deleted file mode 100644
index a5ca7653044..00000000000
--- a/include/aspect/geometry_model/interface.h.bak
+++ /dev/null
@@ -1,447 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_interface_h
-#define _aspect_geometry_model_interface_h
-
-#include <aspect/plugins.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/distributed/tria.h>
-#include <array>
-#include <aspect/utilities.h>
-#include <aspect/coordinate_systems.h>
-
-#include <set>
-
-
-namespace aspect
-{
-  /**
-   * A namespace for the definition of properties of the geometry. This
-   * primarily includes the definition of the shape of the domain (e.g.
-   * whether it is a full spherical shell, a quadrant/octant, a description of
-   * the geoid, etc. The classes and functions of this namespace also describe
-   * which kinds of boundary conditions hold on the different parts of the
-   * boundary of the geometry.
-   *
-   * @ingroup GeometryModels
-   */
-  namespace GeometryModel
-  {
-    using namespace dealii;
-
-    /**
-     * Base class for classes that describe particular geometries for the
-     * domain. These classes must also be able to create coarse meshes and
-     * describe what kinds of boundary conditions hold where.
-     *
-     * @ingroup GeometryModels
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         */
-        virtual
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const = 0;
-
-        /**
-         * Return the typical length scale one would expect of features in
-         * this geometry, assuming realistic parameters.
-         *
-         * The result of this function is used in computing the scaling factor
-         * for the pressure in the Stokes equation. There, the scaling factor
-         * is chosen as the ratio of the reference viscosity divided by the
-         * length scale. As an example, in the step-32 tutorial program we
-         * have determined that a suitable length scale for scaling is 10km,
-         * in a domain that is 12,000km across. This length scale suitably
-         * matches the order of magnitude for the diameter of plumes in the
-         * earth.
-         */
-        virtual
-        double length_scale () const = 0;
-
-        /**
-         * Return the depth that corresponds to the given position. The
-         * returned value is between 0 and maximal_depth(), where points
-         * with a zero depth correspond to the "surface" of the model.
-         *
-         * Computing a depth requires a geometry model to define a
-         * "vertical" direction. For example, the Box model considers
-         * the $(0,1)^T$ vector in 2d (and the $(0,0,1)^T$ vector in
-         * 3d) as vertical and considers the "top" boundary as the
-         * "surface". Similarly, the spherical shell takes the radial
-         * vector as "vertical" and the outer boundary as "surface".
-         * In most cases, how geometry models define "vertical" and
-         * "surface" will be intuitive and obvious. In almost all
-         * cases one will use a gravity model that also matches these
-         * definitions.
-         *
-         * @note Implementations of this function in derived classes can
-         * only compute the depth with regard to the <i>reference
-         * configuration</i> of the geometry, i.e., the geometry initially
-         * created. If you are using a dynamic topography in your models
-         * that changes in every time step, or if you apply initial
-         * topography to your model, then the <i>actual</i> depth
-         * of a point with regard to this dynamic topography will not
-         * match the value this function returns. This is so because
-         * computing the actual depth is difficult: In parallel computations,
-         * the processor on which you want to evaluate the depth of a point
-         * may know nothing about the displacement of the surface anywhere
-         * if it happens to store only interior cells. Furthermore, it is
-         * not even clear what "depth" one would compute in such situations:
-         * The distance to the closest surface point? The vertical distance
-         * to the surface point directly above? Or the length of the line
-         * from the given point to a surface point that is locally always
-         * parallel to the gravity vector? For all of these reasons, this
-         * function simply returns the geometric vertical depth of a point
-         * in the known and fixed reference geometry, to the reference
-         * surface that defines what zero depth is.
-         */
-        virtual
-        double depth(const Point<dim> &position) const = 0;
-
-        /**
-         * Return the height of the given position relative to the reference
-         * surface of the model. Positive returned value means that the point
-         * is above (i.e., farther from the center of the model) the reference
-         * surface, negative value means that the point is below the the
-         * reference surface.
-         *
-         * Same limitations as for the depth function, apply here.
-         */
-        virtual
-        double height_above_reference_surface(const Point<dim> &position) const = 0;
-
-        /**
-         * Converts a Cartesian Point into another coordinate system and returns it
-         * as a NaturalCoordinate.
-         */
-
-        Utilities::NaturalCoordinate<dim>
-        cartesian_to_other_coordinates(const Point<dim> &position,
-                                       const Utilities::Coordinates::CoordinateSystem &coordinate_system) const;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is.
-         */
-        virtual
-        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const = 0;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a box
-         * this will  be (x,z) in 2d or (x,y,z) in 3d, and for a spheroid geometry
-         * model it  will be (radius, longitude) in 2d and (radius, longitude,
-         * latitude) in 3d.
-         */
-        virtual
-        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        virtual
-        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const;
-
-        /**
-         * Returns a representative point for a given depth. Such a point must
-         * lie inside the domain for sure (assuming the given depth is valid),
-         * but it is not important where exactly in the domain it is. A good
-         * choice would be on a middle axis, for example.
-         *
-         * The function is used, for example, in computing an initial
-         * adiabatic profile. For this, we need to be able to query the
-         * density as a function of (adiabatic) pressure and temperature.
-         * However, the functions returning the density from the material
-         * model also depend on location. Since we are interested only in
-         * computing a depth-dependent adiabatic profile without lateral
-         * variation, we need to be able to query the density at
-         * "representative points" at given depths, without caring too much
-         * where exactly that is -- but at points that we know for sure are
-         * inside the domain.
-         */
-        virtual
-        Point<dim> representative_point(const double depth) const = 0;
-
-        /**
-         * Returns the maximal depth of this geometry. For a definition of
-         * how "depth" is to be interpreted, see the documentation of the
-         * depth() member function. In particular, the maximal depth of a
-         * geometry model only represents the depth computed with regard
-         * to some reference configuration, ignoring any dynamic or initial
-         * topography.
-         */
-        virtual
-        double maximal_depth() const = 0;
-
-
-        /**
-         * Return the set of boundary indicators that are used by this model.
-         * This information is used to determine what boundary indicators can
-         * be used in the input file.
-         */
-        virtual
-        std::set<types::boundary_id>
-        get_used_boundary_indicators () const = 0;
-
-        /**
-         * Return a mapping from symbolic names of each part of the boundary
-         * to the corresponding boundary indicator. This allows users to
-         * specify *names*, not just *numbers* in their input files when
-         * describing which parts of the boundary have to satisfy which
-         * boundary conditions.
-         *
-         * An example would be that the "box" geometry returns a map of the
-         * form <code>{{"left"->0}, {"right"->1}, {"bottom"->2},
-         * {"top"->3}}</code> in 2d.
-         *
-         * The default implementation of this function returns an empty map.
-         * This still allows the use of a geometry model that does not
-         * implement this function but forces the user to identify parts of
-         * the boundary by their boundary indicator number, rather than using
-         * a symbolic name.
-         *
-         * @note Names may contain spaces and numbers, but they may not
-         * contain special characters and they should not equal the text
-         * representation of numbers (e.g., a name "10" is ill-advised).
-         *
-         * @note Since in practice boundary indicators can be provided either
-         * via number or symbolic name, the mapping from something given in
-         * the input is not entirely trivial -- in particular, because a
-         * function also has to do some error checking that a given string in
-         * fact matches any known boundary indicator. To this end, use
-         * GeometryModel::translate_boundary_indicator() and
-         * GeometryModel::translate_boundary_indicators().
-         *
-         * @return A map from symbolic names to boundary indicators. The map
-         * should provide a symbolic name for each used boundary indicator as
-         * returned by get_user_boundary_indicators(). In the end, however, a
-         * geometry model may define multiple symbolic names for the same
-         * boundary or not define any.
-         */
-        virtual
-        std::map<std::string,types::boundary_id>
-        get_symbolic_boundary_names_map () const;
-
-        /**
-         * For a given name of a boundary component, translate it to its
-         * numeric value -- either by using one of the symbolic values in the
-         * mapping that derived classes provide through the
-         * get_symbolic_boundary_names_map() function, or by converting its
-         * string representation into a number.
-         *
-         * @param name A name or number (as string). Leading and trailing
-         * spaces are removed from this string.
-         * @return A boundary indicator number corresponding to the given
-         * name. If the name does not represent either a symbolic name or a
-         * number, this function will throw an exception of type std::string
-         * that explains the error.
-         */
-        types::boundary_id
-        translate_symbolic_boundary_name_to_id (const std::string &name) const;
-
-        /**
-         * For each one of the given names of boundary components, translate
-         * it to its numeric value -- either by using one of the symbolic
-         * values in the mapping that derived classes provide through the
-         * get_symbolic_boundary_names_map() function, or by converting its
-         * string representation into a number.
-         *
-         * @param names A list of names or numbers (as strings). Leading and
-         * trailing spaces are removed from the strings.
-         * @return A list of boundary indicator numbers corresponding to the
-         * given list of names. If one of the given names does not represent
-         * either a symbolic name or a number, this function will throw an
-         * exception of type std::string that explains the error.
-         */
-        std::vector<types::boundary_id>
-        translate_symbolic_boundary_names_to_ids (const std::vector<std::string> &names) const;
-
-        /**
-         * Given a boundary indicator, try and see whether this geometry model
-         * provides a symbolic name for it. If the geometry model does not
-         * provide a symbolic name, return the empty string.
-         *
-         * @param boundary_id The boundary indicator to be translated.
-         * @return A string representation for this boundary indicator, if one
-         * is available.
-         */
-        std::string
-        translate_id_to_symbol_name (const types::boundary_id boundary_id) const;
-
-        /**
-         * Returns a set of periodic boundary pairs.  The elements of the set
-         * are a pair of boundary ids and a cartesian unit direction each. The
-         * base class returns an empty set, so this does nothing unless you
-         * specifically use a geometry model with periodic boundary conditions
-         */
-        virtual
-        std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
-        get_periodic_boundary_pairs () const;
-
-        /**
-         * Adjust positions to be inside the domain considering periodic boundary conditions.
-         *
-         * This function checks if @p position is outside the domain and if it could
-         * have reasonably crossed a periodic boundary. If so, it will adjust the position
-         * as described by the periodic boundary (e.g. a translation in a box, or a rotation
-         * in a spherical shell). Afterwards, if it adjusted @p position, it will also adjust
-         * all locations given in @p connected_positions (if any where given) and all
-         * velocities given in @p connected_velocities in the same way.
-         * Adjusting both of these allows to adjust related temporary variables,
-         * e.g. the intermediate results of an ordinary differential equation solver
-         * that are used to compute differences/directions between points. The reason
-         * positions and velocities have to be treated separately is that some geometries
-         * have to adjust them differently across a periodic boundary, e.g. a box has
-         * to translate positions but not velocities, while a spherical shell has to
-         * translate positions (by rotation around the center) and rotate velocities.
-         *
-         * This function does not check that the position after the adjustment is inside the
-         * domain; to check this is the responsibility of the calling function.
-         * A common application of this function are particles that crossed a periodic boundary.
-         */
-        virtual
-        void
-        adjust_positions_for_periodicity (Point<dim> &position,
-                                          const ArrayView<Point<dim>> &connected_positions = {},
-                                          const ArrayView<Tensor<1,dim>> &connected_velocities = {}) const;
-
-        /**
-         * If true, the geometry contains cells with boundaries that are not
-         * straight and have a deal.II boundary object attached to it. If the
-         * return value is @p false, certain operation can be optimized.The
-         * default implementation of this function will return @p true.
-         */
-        virtual
-        bool
-        has_curved_elements() const;
-
-        /**
-         * If true, the queried point (in Cartesian coordinates)
-         * lies in the domain specified by the geometry.
-         */
-        virtual
-        bool
-        point_is_in_domain(const Point<dim> &p) const = 0;
-
-        /**
-         * Collects periodic boundary constraints for the given geometry
-         * and @p dof_handler, which will be added to the existing @p constraints.
-         * The default implementation creates cartesian periodic boundary conditions
-         * for all periodic boundary indicators.
-         */
-        virtual
-        void
-        make_periodicity_constraints(const DoFHandler<dim> &dof_handler,
-                                     AffineConstraints<double> &constraints) const;
-    };
-
-
-
-    /**
-     * Register a geometry model so that it can be selected from the parameter
-     * file.
-     *
-     * @param name A string that identifies the geometry model
-     * @param description A text description of what this model does and that
-     * will be listed in the documentation of the parameter file.
-     * @param declare_parameters_function A pointer to a function that can be
-     * used to declare the parameters that this geometry model wants to read
-     * from input files.
-     * @param factory_function A pointer to a function that can create an
-     * object of this geometry model.
-     *
-     * @ingroup GeometryModels
-     */
-    template <int dim>
-    void
-    register_geometry_model (const std::string &name,
-                             const std::string &description,
-                             void (*declare_parameters_function) (ParameterHandler &),
-                             std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-    /**
-     * A function that given the name of a model returns a pointer to an
-     * object that describes it. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The geometry model will also be asked to read its runtime parameters
-     * already.
-     *
-     * @ingroup GeometryModels
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_geometry_model (ParameterHandler &prm);
-
-    /**
-     * Declare the runtime parameters of the registered geometry models.
-     *
-     * @ingroup GeometryModels
-     */
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm);
-
-    /**
-     * For the current plugin subsystem, write a connection graph of all of the
-     * plugins we know about, in the format that the
-     * programs dot and neato understand. This allows for a visualization of
-     * how all of the plugins that ASPECT knows about are interconnected, and
-     * connect to other parts of the ASPECT code.
-     *
-     * @param output_stream The stream to write the output to.
-     */
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &output_stream);
-
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a geometry model, register it with the functions that can declare
-     * their parameters and create these objects.
-     *
-     * @ingroup GeometryModels
-     */
-#define ASPECT_REGISTER_GEOMETRY_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_GEOMETRY_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::GeometryModel::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::GeometryModel::register_geometry_model<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::GeometryModel::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::GeometryModel::register_geometry_model<3>, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/sphere.h.bak b/include/aspect/geometry_model/sphere.h.bak
deleted file mode 100644
index e3e51c74ed5..00000000000
--- a/include/aspect/geometry_model/sphere.h.bak
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#ifndef _aspect_geometry_model_sphere_h
-#define _aspect_geometry_model_sphere_h
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class Sphere : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Sphere() = default;
-
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         */
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
-
-        /**
-         * Return the typical length scale one would expect of features in
-         * this geometry, assuming realistic parameters.
-         *
-         * As discussed in the step-32 tutorial program, an appropriate length
-         * scale for this geometry is 10km, so we return $10^4$ here.
-         */
-        double length_scale () const override;
-
-        /**
-         * Return the depth that corresponds to the given
-         * position. The documentation of the base class (see
-         * GeometryModel::Interface::depth()) describes in detail how
-         * "depth" is interpreted in general.
-         *
-         * Computing a depth requires a geometry model to define a
-         * "vertical" direction. The current class considers the
-         * radial vector away from the origin as vertical and
-         * considers the "outer" boundary as the "surface". In almost
-         * all cases one will use a gravity model that also matches
-         * these definitions.
-         */
-        double depth(const Point<dim> &position) const override;
-
-        /**
-         * Return the height of the given position relative to
-         * the radius of the sphere.
-         */
-        double height_above_reference_surface(const Point<dim> &position) const override;
-
-        /**
-         * @copydoc Interface<dim>::representative_point()
-         */
-        Point<dim> representative_point(const double depth) const override;
-
-        /**
-         * @copydoc Interface<dim>::maximal_depth()
-         */
-        double maximal_depth() const override;
-
-        /**
-         * Return the set of boundary indicators that are used by this model.
-         * This information is used to determine what boundary indicators can
-         * be used in the input file.
-         *
-         * The sphere model only has one boundary, with indicator zero.
-         */
-        std::set<types::boundary_id>
-        get_used_boundary_indicators () const override;
-
-        /**
-         * Return symbolic names for all boundary components. Their names are
-         * described in the documentation of this plugin, at the bottom of the
-         * .cc file.
-         */
-        std::map<std::string,types::boundary_id>
-        get_symbolic_boundary_names_map () const override;
-
-        /**
-         * @copydoc Interface::has_curved_elements()
-         *
-         * Return true because we have a curved boundary.
-         */
-        bool
-        has_curved_elements() const override;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is,
-         * which for a sphere is Spherical.
-         */
-        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
-
-        /**
-         * Return whether the given point lies within the domain specified
-         * by the geometry. This function does not take into account
-         * initial or dynamic surface topography.
-         */
-        bool
-        point_is_in_domain(const Point<dim> &point) const override;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a sphere
-         * this is (radius, longitude) in 2d and (radius, longitude, latitude) in 3d.
-         */
-        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
-
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Return the radius of the sphere.
-         */
-        double
-        radius () const;
-
-      private:
-        /**
-         * Radius of the sphere
-         */
-        double R;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/spherical_shell.h.bak b/include/aspect/geometry_model/spherical_shell.h.bak
deleted file mode 100644
index c2286088a31..00000000000
--- a/include/aspect/geometry_model/spherical_shell.h.bak
+++ /dev/null
@@ -1,454 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_spherical_shell_h
-#define _aspect_geometry_model_spherical_shell_h
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    using namespace dealii;
-
-    namespace internal
-    {
-      /**
-       * A description of a manifold that describes a spherical shell with overlaid
-       * topography.
-       */
-      template <int dim>
-      class SphericalManifoldWithTopography : public aspect::SphericalManifold<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          SphericalManifoldWithTopography(const InitialTopographyModel::Interface<dim> &topography,
-                                          const double inner_radius,
-                                          const double outer_radius);
-
-          /**
-           * Copy constructor.
-           */
-          SphericalManifoldWithTopography(const SphericalManifoldWithTopography<dim> &) = default;
-
-          /**
-           * Make a clone of this Manifold object.
-           */
-          virtual std::unique_ptr<Manifold<dim, dim>>
-          clone() const override;
-
-          /**
-           * Given a point in the undeformed spherical geometry, push it forward to the
-           * corresponding point in the sphere with surface topography.
-           */
-          Point<dim>
-          push_forward_from_sphere (const Point<dim> &p) const;
-
-          /**
-           * Given a point in the deformed spherical geometry with topography, pull it
-           * back to the corresponding point in the undeformed sphere.
-           */
-          Point<dim>
-          pull_back_to_sphere (const Point<dim> &p) const;
-
-          /**
-           * Given any two points in space, first project them on the surface
-           * of a sphere with unit radius, then connect them with a geodesic
-           * and find the intermediate point, and finally rescale the final
-           * radius so that the resulting one is the convex combination of the
-           * starting radii.
-           */
-          virtual Point<dim>
-          get_intermediate_point(const Point<dim> &p1,
-                                 const Point<dim> &p2,
-                                 const double      w) const override;
-
-          /**
-           * Compute the derivative of the get_intermediate_point() function
-           * with parameter w equal to zero.
-           */
-          virtual Tensor<1, dim>
-          get_tangent_vector(const Point<dim> &x1,
-                             const Point<dim> &x2) const override;
-
-          /**
-           * @copydoc Manifold::normal_vector()
-           *
-           * We fudge here, but for a good reason. What the function is supposed
-           * to compute is the normal vector to the surface. This *should* be the
-           * normal to the surface with topography, but instead we return the
-           * normal to the undeformed surface -- i.e., the radial direction. This
-           * is, in particular, used to compute no-flux boundary conditions,
-           * for which we want to impose a boundary
-           * condition that allows for plate-like motion -- that is, we need
-           * to allow *horizontal motion*, even if that is not tangential to
-           * the surface along the slopes of mountains or ocean trenches. Using
-           * the radial direction, i.e., the normal vector to the undeformed surface
-           * (= a radial vector) allows for exactly this.
-           */
-          virtual Tensor<1, dim>
-          normal_vector(
-            const typename Triangulation<dim, dim>::face_iterator &face,
-            const Point<dim> &p) const override;
-
-          /**
-           * Compute the normal vectors to the boundary at each vertex.
-           */
-          virtual void
-          get_normals_at_vertices(
-            const typename Triangulation<dim, dim>::face_iterator &face,
-            typename Manifold<dim, dim>::FaceVertexNormals &face_vertex_normals)
-          const override;
-
-
-          /**
-           * Compute a new set of points that interpolate between the given points @p
-           * surrounding_points. @p weights is a table with as many columns as @p
-           * surrounding_points.size(). The number of rows in @p weights must match
-           * the length of @p new_points.
-           *
-           * This function is optimized to perform on a collection
-           * of new points, by collecting operations that are not dependent on the
-           * weights outside of the loop over all new points.
-           *
-           * The implementation does not allow for @p surrounding_points and
-           * @p new_points to point to the same array, so make sure to pass different
-           * objects into the function.
-           */
-          virtual void
-          get_new_points(const ArrayView<const Point<dim>> &surrounding_points,
-                         const Table<2, double>                 &weights,
-                         ArrayView<Point<dim>> new_points) const override;
-
-          /**
-           * Return a point on the spherical manifold which is intermediate
-           * with respect to the surrounding points.
-           */
-          virtual Point<dim>
-          get_new_point(const ArrayView<const Point<dim>> &vertices,
-                        const ArrayView<const double>          &weights) const override;
-
-        private:
-          /**
-           * A pointer to the topography model.
-           */
-          const InitialTopographyModel::Interface<dim> *topo;
-
-          /**
-           * Inner and outer radii of the spherical shell.
-           */
-          const double R0, R1;
-
-          /**
-           * Return the topography of the surface directly above the point given
-           * by the coordinates stored in the argument.
-           */
-          double topography_for_point (const Point<dim> &x_y_z) const;
-      };
-
-    }
-
-    /**
-     * A class that describes the geometry as a spherical shell. To be more
-     * precise, at least in 2d this class can also simulate just a sector of
-     * the spherical shell geometry, in particular a half ring and a quarter
-     * ring.
-     *
-     * The parameters that describe this geometry and that are read from the
-     * input file are the inner and outer radii of the shell and the opening
-     * angle of the section of the shell we want to build.
-     */
-    template <int dim>
-    class SphericalShell : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        SphericalShell() = default;
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run and after
-         * the SimulatorAccess (if applicable) is initialized.
-         * This function calls the initialize function of the manifold
-         * with a pointer to the initial topography model obtained
-         * from SimulatorAccess.
-         */
-        void initialize () override;
-
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         */
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
-
-        /**
-         * Return the typical length scale one would expect of features in
-         * this geometry, assuming realistic parameters.
-         *
-         * As discussed in the step-32 tutorial program, an appropriate length
-         * scale for this geometry is 10km, so we return $10^4$ here.
-         */
-        double length_scale () const override;
-
-        /**
-         * Return the depth that corresponds to the given
-         * position. The documentation of the base class (see
-         * GeometryModel::Interface::depth()) describes in detail how
-         * "depth" is interpreted in general.
-         *
-         * Computing a depth requires a geometry model to define a
-         * "vertical" direction. The current class considers the
-         * radial vector away from the origin as vertical and
-         * considers the "outer" boundary as the "surface". In almost
-         * all cases one will use a gravity model that also matches
-         * these definitions.
-         */
-        double depth(const Point<dim> &position) const override;
-
-        /**
-         * Return the height of the given position relative to
-         * the outer radius of the shell.
-         */
-        double height_above_reference_surface(const Point<dim> &position) const override;
-
-        /**
-         * @copydoc Interface<dim>::representative_point()
-         */
-        Point<dim> representative_point(const double depth) const override;
-
-        /**
-         * @copydoc Interface<dim>::maximal_depth()
-         */
-        double maximal_depth() const override;
-
-        /**
-         * Return the set of boundary indicators that are used by this model.
-         * This information is used to determine what boundary indicators can
-         * be used in the input file.
-         *
-         * The spherical shell may be generated as per in the original code
-         * (with respect to the inner and outer radius, and an initial number
-         * of cells along circumference) or following a custom mesh scheme:
-         * list of radial values or number of slices. A surface mesh is first
-         * generated and refined as desired, before it is extruded radially.
-         * A list of radial values subdivides the spherical shell at specified
-         * radii. The number of slices subdivides the spherical shell into N
-         * slices of equal thickness. The custom spherical shell only works
-         * with an opening angle of 360 degrees.
-         *
-         * The spherical shell model uses boundary indicators zero and one,
-         * with zero corresponding to the inner surface and one corresponding
-         * to the outer surface. In 2d, if the geometry is only a slice of the
-         * shell, boundary indicators 2 and 3 indicate the left and right
-         * radial bounding lines.
-         */
-        std::set<types::boundary_id>
-        get_used_boundary_indicators () const override;
-
-        /**
-         * Return symbolic names for all boundary components. Their names are
-         * described in the documentation of this plugin, at the bottom of the
-         * .cc file.
-         */
-        std::map<std::string,types::boundary_id>
-        get_symbolic_boundary_names_map () const override;
-
-        /**
-         * Return the set of periodic boundaries as described in the input
-         * file.
-         */
-        std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
-        get_periodic_boundary_pairs () const override;
-
-        /**
-         * @copydoc Interface::adjust_positions_for_periodicity
-         *
-         * Apply a rotation to all points outside of the domain
-         * to account for periodicity.
-         */
-        void
-        adjust_positions_for_periodicity (Point<dim> &position,
-                                          const ArrayView<Point<dim>> &connected_positions = {},
-                                          const ArrayView<Tensor<1, dim>> &connected_velocities = {}) const override;
-
-        /**
-         * @copydoc Interface::has_curved_elements()
-         *
-         * Return true because we have a curved boundary.
-         */
-        bool
-        has_curved_elements() const override;
-
-        /**
-         * Return whether the given point lies within the domain specified
-         * by the geometry. This function does not take into account
-         * initial or dynamic surface topography.
-         */
-        bool
-        point_is_in_domain(const Point<dim> &point) const override;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is,
-         * which for a spherical shell is Spherical.
-         */
-        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a spherical shell
-         * this is (radius, longitude) in 2d and (radius, longitude, latitude) in 3d.
-         */
-        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
-
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Return the inner radius of the shell.
-         */
-        double
-        inner_radius () const;
-
-        /**
-         * Return the outer radius of the shell.
-         */
-        double
-        outer_radius () const;
-
-        /**
-         * Return the opening angle of the shell sector.
-         */
-        double
-        opening_angle () const;
-
-        /**
-         * Collects periodic boundaries constraints for the given geometry,
-         * which will be added to the existing @p constraints.
-         */
-        void
-        make_periodicity_constraints(const DoFHandler<dim> &dof_handler,
-                                     AffineConstraints<double> &constraints) const override;
-
-      private:
-        /**
-         * Specify the radial subdivision of the spherical shell
-         * mesh.
-         */
-        enum CustomMeshRadialSubdivision
-        {
-          none,
-          list,
-          slices
-        } custom_mesh;
-
-        /**
-         * Initial surface refinement for the custom mesh cases.
-         */
-        unsigned int initial_lateral_refinement;
-
-        /**
-         * Initial surface refinement for the custom mesh cases.
-         */
-        unsigned int n_slices;
-
-        /**
-         * List of radial values for the list custom mesh.
-         */
-        std::vector<double> R_values_list;
-
-        /**
-         * Inner and outer radii of the spherical shell.
-         */
-        double R0, R1;
-
-        /**
-         * Opening angle of the section of the shell that we simulate.
-         */
-        double phi;
-
-        /**
-         * Number of tangential mesh cells in the initial, coarse mesh.
-         */
-        int n_cells_along_circumference;
-
-        /**
-         * Set the manifold ids on all cells (also boundaries) before
-         * refinement to generate well shaped cells.
-         */
-        void set_manifold_ids (parallel::distributed::Triangulation<dim> &triangulation) const;
-
-        /**
-         * Flag whether the 2D quarter shell is periodic in phi.
-         */
-        bool periodic;
-
-        /**
-         * An object that describes the geometry. This pointer is
-         * initialized in the initialize() function, and serves as the manifold
-         * object that the triangulation is later given in create_coarse_mesh()
-         * where the triangulation clones it.
-         *
-         * The object is marked as 'const' to make it clear that it should not
-         * be modified once created. That is because the triangulation copies it,
-         * and modifying the current object will not have any impact on the
-         * manifold used by the triangulation.
-         */
-        std::unique_ptr<const internal::SphericalManifoldWithTopography<dim>> manifold;
-
-        /**
-         * Give a symbolic name to the manifold id to be used by this class.
-         */
-        static const types::manifold_id my_manifold_id = 99;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/two_merged_boxes.h.bak b/include/aspect/geometry_model/two_merged_boxes.h.bak
deleted file mode 100644
index bfcc53789fd..00000000000
--- a/include/aspect/geometry_model/two_merged_boxes.h.bak
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_two_merged_boxes_h
-#define _aspect_geometry_model_two_merged_boxes_h
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes a box geometry of certain width, height, and
-     * depth (in 3d) and adds two (four in 3D) additional boundary indicators
-     * for the lithospheric part of the vertical boundaries.
-     */
-    template <int dim>
-    class TwoMergedBoxes : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         */
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
-
-        /**
-         * Return a point that denotes the size of the box in each dimension
-         * of the domain.
-         */
-        Point<dim> get_extents () const;
-
-        /**
-         * Return a point that denotes the lower left corner of the box
-         * domain.
-         */
-        Point<dim> get_origin () const;
-
-        /**
-         * Return the typical length scale one would expect of features in
-         * this geometry, assuming realistic parameters.
-         *
-         * We return 1/100th of the X extent of the box.
-         */
-        double length_scale () const override;
-
-        /**
-         * Return the depth that corresponds to the given
-         * position. The documentation of the base class (see
-         * GeometryModel::Interface::depth()) describes in detail how
-         * "depth" is interpreted in general.
-         *
-         * Computing a depth requires a geometry model to define a
-         * "vertical" direction. The current class considers the
-         * $(0,1)^T$ vector in 2d (and the $(0,0,1)^T$ vector in 3d)
-         * as vertical and considers the "top" boundary as the
-         * "surface". In almost all cases one will use a gravity model
-         * that also matches these definitions.
-         */
-        double depth(const Point<dim> &position) const override;
-
-        /**
-         * Return the height of the given position relative to
-         * the initial box height.
-         */
-        double height_above_reference_surface(const Point<dim> &position) const override;
-
-        /**
-         * @copydoc Interface<dim>::representative_point()
-         */
-        Point<dim> representative_point(const double depth) const override;
-
-        /**
-         * @copydoc Interface<dim>::maximal_depth()
-         */
-        double maximal_depth() const override;
-
-        /**
-         * Return the set of boundary indicators that are used by this model.
-         * This information is used to determine what boundary indicators can
-         * be used in the input file.
-         *
-         * This box model uses boundary indicators zero through 2*dim+2*(dim-1)-1, with
-         * the first two being the faces perpendicular to the x-axis and the next
-         * two perpendicular to the y-axis. In 2D, the next two are perpendicular to
-         * the x-axis again. In 3D, two sets of two
-         * are added for the boundaries parallel to the z-axis.
-         */
-        std::set<types::boundary_id>
-        get_used_boundary_indicators () const override;
-
-        /**
-         * Return a mapping from symbolic names of each part of the boundary
-         * to the corresponding boundary indicator. This allows users to
-         * specify *names*, not just *numbers* in their input files when
-         * describing which parts of the boundary have to satisfy which
-         * boundary conditions.
-         *
-         * This geometry returns the map <code>{{"left"->0}, {"right"->1},
-         * {"bottom"->2}, {"top"->3}, {"left lithosphere"->4},
-         * {"right lithosphere"->5}}</code> in 2d, and <code>{{"left"->0},
-         * {"right"->1}, {"front"->2}, {"back"->3}, {"bottom"->4},
-         * {"top"->5}, {"left lithosphere"->6}, {"right lithosphere"->7},
-         * {"front lithosphere"->8}, {"back lithosphere"->9}}</code> in 3d.
-         */
-        std::map<std::string,types::boundary_id>
-        get_symbolic_boundary_names_map () const override;
-
-        /**
-         * Return the set of periodic boundaries as described in the input
-         * file.
-         */
-        std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
-        get_periodic_boundary_pairs () const override;
-
-        /**
-         * @copydoc Interface::adjust_positions_for_periodicity
-         *
-         * Apply a translation to all points outside of the domain
-         * to account for periodicity.
-         */
-        void
-        adjust_positions_for_periodicity (Point<dim> &position,
-                                          const ArrayView<Point<dim>> &connected_positions = {},
-                                          const ArrayView<Tensor<1, dim>> &connected_velocities = {}) const override;
-
-        /**
-         * @copydoc Interface::has_curved_elements()
-         *
-         * A box has only straight boundaries and cells, so return false.
-         */
-        bool
-        has_curved_elements() const override;
-
-        /**
-         * Return whether the given point lies within the domain specified
-         * by the geometry. This function does not take into account
-         * initial or dynamic surface topography.
-         */
-        bool
-        point_is_in_domain(const Point<dim> &point) const override;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is,
-         * which for two merged boxes is Cartesian.
-         */
-        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a box
-         * the results is unchanged and is (x,z) in 2d or (x,y,z) in 3d.
-         */
-        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Whether to make the grid by gluing together two boxes, or just
-         * use one chunk to make the grid. Using two grids glued together
-         * is a safer option, since it forces the boundary conditions
-         * to be always applied to the same depth, but one unified grid allows
-         * for a more flexible usage of the adaptive refinement.
-         */
-        bool use_merged_grids;
-
-        /**
-         * Extent of the whole model domain in x-, y-, and z-direction (in 3d).
-         */
-        Point<dim> extents;
-
-        /**
-         * Extent of the lower box in x-, y-, and z-direction (in 3d).
-         */
-        Point<dim> lower_extents;
-
-        /**
-         * Origin of the lower box in x, y, and z (in 3d) coordinates.
-         */
-        Point<dim> lower_box_origin;
-
-        /**
-         * Extent of the upper box in x-, y-, and z-direction (in 3d).
-         */
-        Point<dim> upper_extents;
-
-        /**
-         * Origin of the upper box in x, y, and z (in 3d) coordinates.
-         */
-        Point<dim> upper_box_origin;
-
-        /**
-         * Flag whether the whole domain is periodic in the x-, y-, and z-directions,
-         * the x- and y- (in 3d) direction in the lithosphere.
-         */
-        bool periodic[dim+dim-1];
-
-        /**
-         * The number of cells in each coordinate direction for the lower box.
-         */
-        std::array<unsigned int, dim> lower_repetitions;
-
-        /**
-         * The number of cells in each coordinate direction for the upper box.
-         */
-        std::array<unsigned int, dim> upper_repetitions;
-
-        /**
-         * The height where the lithospheric part of the vertical boundary begins
-         * (so in positive z-direction).
-         */
-        double height_lith;
-
-        /**
-         * Bind boundary indicators to child cells after each mesh refinement round.
-         */
-        void
-        set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/geometry_model/two_merged_chunks.h.bak b/include/aspect/geometry_model/two_merged_chunks.h.bak
deleted file mode 100644
index 3c5eacd15cc..00000000000
--- a/include/aspect/geometry_model/two_merged_chunks.h.bak
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_geometry_model_two_merged_chunks_h
-#define _aspect_geometry_model_two_merged_chunks_h
-
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/compat.h>
-
-#include <deal.II/grid/manifold.h>
-#include <deal.II/base/function_lib.h>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    using namespace dealii;
-
-
-    /**
-     * A geometry model class that describes a chunk of a spherical shell,
-     * but with two boundary indicators per side boundary. This allows
-     * for specifying two different types of boundary conditions on the
-     * side boundaries, for example prescribed plate motions along
-     * the edge of the lithosphere and an open boundary underneath.
-     * In 2D, this class simulates a sector with inner and outer radius, and
-     * minimum and maximum longitude. Longitude increases anticlockwise
-     * from the positive x-axis, as per the mathematical convention of phi.
-     * In 3D, the class simulates a chunk of a sphere, bounded by arbitrary
-     * lines of longitude, latitude and radius. Boundary indicator names are
-     * lowerwest, upperwest, lowereast, uppereast, lowersouth, uppersouth,
-     * lowernorth, uppernorth, bottom and top.
-     *
-     * The parameters that describe this geometry and that are read from the
-     * input file are the inner, outer and middle boundary radius of the shell,
-     * the minimum and maximum longitude, minimum and maximum longitude, and the
-     * number of cells initialized in each dimension. In the radial direction,
-     * this number should be specified for both the lower and the upper part of
-     * the chunk (with their boundary lying at the middle boundary radius).
-     *
-     * Initial topography can be added through a radial displacement of the
-     * mesh nodes.
-     */
-    template <int dim>
-    class TwoMergedChunks : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run and after
-         * the SimulatorAccess (if applicable) is initialized.
-         * This function calls the initialize function of the manifold
-         * with a pointer to the initial topography model obtained
-         * from SimulatorAccess.
-         */
-        void initialize () override;
-
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         */
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const override;
-
-        /**
-         * Return the set of boundary indicators that are used by this model.
-         * This information is used to determine what boundary indicators can
-         * be used in the input file.
-         *
-         * The chunk model uses boundary indicators zero through 2*dim+2*(dim-1)-1, with
-         * the first two being the faces perpendicular to the radius of the shell,
-         * the next four along lines of longitude and, in 3d, the next four
-         * along lines of latitude.
-         */
-        std::set<types::boundary_id>
-        get_used_boundary_indicators () const override;
-
-        /**
-         * Return a mapping from symbolic names of each part of the boundary
-         * to the corresponding boundary indicator. This allows users to
-         * specify *names*, not just *numbers* in their input files when
-         * describing which parts of the boundary have to satisfy which
-         * boundary conditions.
-         */
-        std::map<std::string,types::boundary_id>
-        get_symbolic_boundary_names_map () const override;
-
-        /**
-         * Return the typical length scale one would expect of features in
-         * this geometry, assuming realistic parameters.
-         *
-         * As described in the first ASPECT paper, a length scale of
-         * 10km = 1e4m works well for the pressure scaling for earth
-         * sized spherical shells. use a length scale that
-         * yields this value for the R0,R1 corresponding to earth
-         * but otherwise scales like (R1-R0)
-         */
-        double length_scale () const override;
-
-        /**
-         * Return the depth that corresponds to the given
-         * position. The documentation of the base class (see
-         * GeometryModel::Interface::depth()) describes in detail how
-         * "depth" is interpreted in general.
-         *
-         * Computing a depth requires a geometry model to define a
-         * "vertical" direction. The current class considers the
-         * radial vector away from the origin as vertical and
-         * considers the "top" boundary as the surface. In almost
-         * all cases one will use a gravity model that also matches
-         * these definitions.
-         */
-        double depth(const Point<dim> &position) const override;
-
-        /**
-         * Return the height of the given position relative to the outer
-         * radius.
-         */
-        double height_above_reference_surface(const Point<dim> &position) const override;
-
-        /**
-         * @copydoc Interface::representative_point()
-         */
-        Point<dim> representative_point(const double depth) const override;
-
-        /**
-         * Return the longitude at the western edge of the chunk measured in
-         * radians.
-         */
-        virtual
-        double west_longitude() const;
-
-        /**
-         * Return the longitude at the eastern edge of the chunk measured in
-         * radians.
-         */
-        virtual
-        double east_longitude() const;
-
-        /**
-         * Return the longitude range of the chunk measured in radians.
-         */
-        virtual
-        double longitude_range() const;
-
-        /**
-         * Return the latitude at the southern edge of the chunk measured in
-         * radians from the equator.
-         */
-        virtual
-        double south_latitude() const;
-
-        /**
-         * Return the latitude at the northern edge of the chunk measured in
-         * radians from the equator.
-         */
-        virtual
-        double north_latitude() const;
-
-        /**
-         * Return the latitude range of the chunk measured in radians
-         */
-        virtual
-        double latitude_range() const;
-
-        /**
-         * Return the maximum depth from the surface of the model measured in
-         * meters.
-         */
-        double maximal_depth() const override;
-
-        /**
-         * Return the inner radius of the chunk measured in meters.
-         */
-        virtual
-        double inner_radius() const;
-
-        /**
-         * Return the outer radius of the chunk measured in meters.
-         */
-        virtual
-        double outer_radius() const;
-
-
-        /**
-         * @copydoc Interface::has_curved_elements()
-         *
-         * A chunk has curved boundaries and cells, so return true.
-         */
-        bool
-        has_curved_elements() const override;
-
-        /**
-         * Return whether the given point lies within the domain specified
-         * by the geometry. This function does not take into account
-         * initial or dynamic surface topography.
-         */
-        bool
-        point_is_in_domain(const Point<dim> &point) const override;
-
-        /**
-         * Returns what the natural coordinate system for this geometry model is,
-         * which for a chunk is Spherical.
-         */
-        aspect::Utilities::Coordinates::CoordinateSystem natural_coordinate_system() const override;
-
-        /**
-         * Takes the Cartesian points (x,z or x,y,z) and returns standardized
-         * coordinates which are most 'natural' to the geometry model. For a chunk
-         * this is (radius, longitude) in 2d and (radius, longitude, latitude) in 3d.
-         */
-        std::array<double,dim> cartesian_to_natural_coordinates(const Point<dim> &position) const override;
-
-        /**
-         * Undoes the action of cartesian_to_natural_coordinates, and turns the
-         * coordinate system which is most 'natural' to the geometry model into
-         * Cartesian coordinates.
-         */
-        Point<dim> natural_to_cartesian_coordinates(const std::array<double,dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Whether to make the grid by gluing together two chunks, or just
-         * use one chunk to make the grid. Using two grids glued together
-         * is a safer option, since it forces the boundary conditions
-         * to be always applied to the same depth, but one unified grid allows
-         * for a more flexible usage of the adaptive refinement.
-         */
-        bool use_merged_grids;
-
-        /**
-         * Minimum longitude-depth (2D) or
-         * longitude-latitude-depth (3D) point
-         * of the entire merged chunk.
-         */
-        Point<dim> point1;
-
-        /**
-         * Maximum longitude-depth (2D) or
-         * longitude-latitude-depth (3D) point
-         * of the entire merged chunk.
-         */
-        Point<dim> point2;
-
-        /**
-         * Minimum longitude-depth (2D) or
-         * longitude-latitude-depth (3D) point
-         * for the upper chunk.
-         */
-        Point<dim> point3;
-
-        /**
-         * Maximum longitude-depth (2D) or
-         * longitude-latitude-depth (3D) point
-         * for the lower chunk.
-         */
-        Point<dim> point4;
-
-        /**
-         * The number of cells in each coordinate direction
-         * for the lower and upper chunk.
-         */
-        std::array<unsigned int, dim> lower_repetitions;
-        std::array<unsigned int, dim> upper_repetitions;
-
-        /**
-         * An object that describes the geometry. This pointer is
-         * initialized in the initialize() function, and serves as the manifold
-         * object that the triangulation is later given in create_coarse_mesh()
-         * where the triangulation clones it.
-         *
-         * The object is marked as 'const' to make it clear that it should not
-         * be modified once created. That is because the triangulation copies it,
-         * and modifying the current object will not have any impact on the
-         * manifold used by the triangulation.
-         */
-        std::unique_ptr<const internal::ChunkGeometry<dim>> manifold;
-
-        /**
-         * Give a symbolic name to the manifold id to be used by this class.
-         */
-        static const types::manifold_id my_manifold_id = 15;
-
-        /**
-         * Bind boundary indicators to child cells after each mesh refinement round.
-         */
-        void set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/global.h.bak b/include/aspect/global.h.bak
deleted file mode 100644
index c2de354a27a..00000000000
--- a/include/aspect/global.h.bak
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_global_h
-#define _aspect_global_h
-
-#include <aspect/config.h>
-
-#include <deal.II/base/mpi.h>
-
-DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-
-#include <deal.II/lac/generic_linear_algebra.h>
-
-#include <boost/archive/binary_oarchive.hpp>
-#include <boost/archive/binary_iarchive.hpp>
-
-DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-
-
-#include <aspect/compat.h>
-
-namespace aspect
-{
-  /**
-   * The following are a set of global constants which may be used by ASPECT:
-   * (for sources of data and values used by ASPECT, see source/global.cc)
-   */
-  namespace constants
-  {
-    /**
-     * Number of seconds in a year [s]
-     */
-    constexpr double year_in_seconds = 60*60*24*365.2425;
-
-    /**
-     * Zero degrees Celsius to Kelvin [K]
-     */
-    constexpr double celsius_to_kelvin = 273.15;
-
-    /**
-     * Convert angles in degree to radians.
-     */
-    constexpr double degree_to_radians = dealii::numbers::PI / 180.;
-
-    /**
-     * Convert angles in radians to degrees.
-     */
-    constexpr double radians_to_degree = 180. / dealii::numbers::PI;
-
-    /**
-     * Gas constant (also known as R) [J K^-1 mol^-1]
-     */
-    constexpr double gas_constant = 8.3144621;
-    /**
-     * Avogadro's constant [mol^-1]
-     */
-    constexpr double avogadro = 6.02214129e23;
-    /**
-     * Gravitational constant [m^3 kg^-1 s^-2]
-     * Value: 6.67430(15)E-11 (standard uncertainty in parenthesis)
-     * Source: 2018 CODATA Value: Newtonian constants of gravitation.
-     *         The NIST Reference on Constants, Units, and Uncertainty.
-     *         NIST. 20 May 2019.
-     */
-    constexpr double big_g = 6.67430e-11;
-
-    /**
-     * Constants for Earth:
-     */
-    namespace earth
-    {
-
-      /**
-       * Masses are taken from Yoder (1995)
-       */
-      namespace masses
-      {
-        /**
-         * Planet mass [kg]
-         */
-        constexpr double planet = 5.9736e24;
-        /**
-         * Mass of the whole core [kg]
-         */
-        constexpr double core = 1.932e24;
-        /**
-         * Mass of the mantle [kg]
-         */
-        constexpr double mantle = 4.043e24;
-      }
-
-      /**
-       * Earth structure radii taken from the IASP91 model
-       */
-      namespace iasp91_radii
-      {
-        /**
-         * Inner core radius [m], equivalent of 5150 km depth
-         */
-        constexpr double inner_core = 1.2171e6;
-        /**
-         * Inner core radius [m], equivalent of 2889 km depth
-         */
-        constexpr double core = 3.482e6;
-        /**
-         * Lower mantle radius [m], equivalent of 660 km depth
-         */
-        constexpr double lower_mantle = 5.711e6;
-        /**
-         * Radius [m], equivalent of 5150 km depth
-         */
-        constexpr double planet = 6.371e6;
-      }
-
-      /**
-       * Gravity values taken from the PREM (Dziewonski and Anderson, 1981)
-       */
-      namespace prem_gravity
-      {
-        /**
-         * Inner core boundary gravity [ms^-2]
-         */
-        constexpr double icb = 4.4002;
-        /**
-         * Core-mantle boundary gravity [ms^-2]
-         */
-        constexpr double cmb = 10.6823;
-        /**
-         * Upper-lower mantle boundary gravity [ms^-2]
-         */
-        constexpr double ulmb = 10.0143;
-        /**
-         * Surface gravity [ms^-2]
-         */
-        constexpr double surface = 9.8156;
-      }
-
-      /**
-       * NIST "Standard gravity" (average gravitational acceleration at surface
-       * [ms^-2]
-       */
-      constexpr double surface_gravity = 9.80665;
-    }
-
-    /**
-     * Constants for Mars
-     */
-    namespace mars
-    {
-      /**
-       * Mars structure radii
-       */
-      namespace radii
-      {
-        /**
-         * Planetary radius from Seidermann et al., 2007 [m]
-         */
-        constexpr double planet = 3.3895e6;
-        /**
-         * Core radius from Rivoldini et al., 2011 [m]
-         */
-        constexpr double core = 1.794e6;
-      }
-      /**
-       * Surface gravity from Lodders et al., 1998 [ms^-2]
-       */
-      constexpr double surface_gravity = 3.711;
-    }
-  }
-
-  /**
-   * Number of seconds in a year [s] (deprecated)
-   */
-  using constants::year_in_seconds;
-
-
-  /**
-   * A typedef that denotes the BOOST stream type for reading data during
-   * serialization. The type chosen here is a binary archive which we
-   * subsequently will have to un-compress.
-   */
-  using iarchive = boost::archive::binary_iarchive;
-
-  /**
-   * A typedef that denotes the BOOST stream type for writing data during
-   * serialization. The type chosen here is a binary archive which we compress
-   * before writing it into a file.
-   */
-  using oarchive = boost::archive::binary_oarchive;
-
-  /**
-   * A class we throw in exceptions in parallel jobs and that we can silently
-   * treat in main(). We do this, for example, in read_parameters() where each
-   * processor would otherwise throw the same exception and every processor
-   * would produce a tangle of output that is impenetrable in large parallel
-   * jobs. The same situation happens if a linear solver fails. Rather, we
-   * make processor 0 throw the real exception and every other processor
-   * converts the exception it wants to throw to an object of the current type
-   * -- which is caught in main() but doesn't produce any output (because
-   * processor 0 will already produce the output).
-   */
-  class QuietException {};
-
-
-  /**
-   * A namespace that contains typedefs for classes used in the linear algebra
-   * description.
-   */
-  namespace LinearAlgebra
-  {
-    /**
-     * Typedef for the vector type used.
-     */
-    using Vector = dealii::TrilinosWrappers::MPI::Vector;
-
-    /**
-     * Typedef for the type used to describe vectors that consist of multiple
-     * blocks.
-     */
-    using BlockVector = dealii::TrilinosWrappers::MPI::BlockVector;
-
-    /**
-     * Typedef for the sparse matrix type used.
-     */
-    using SparseMatrix = dealii::TrilinosWrappers::SparseMatrix;
-
-    /**
-     * Typedef for the type used to describe sparse matrices that consist of
-     * multiple blocks.
-     */
-    using BlockSparseMatrix = dealii::TrilinosWrappers::BlockSparseMatrix;
-
-    /**
-     * Typedef for the base class for all preconditioners.
-     */
-    using PreconditionBase = dealii::TrilinosWrappers::PreconditionBase;
-
-    /**
-     * Typedef for the AMG preconditioner type used for the top left block of
-     * the Stokes matrix.
-     */
-    using PreconditionAMG = dealii::TrilinosWrappers::PreconditionAMG;
-
-    /**
-     * Typedef for the Incomplete Cholesky preconditioner used for other
-     * blocks of the system matrix.
-     */
-    using PreconditionIC = dealii::TrilinosWrappers::PreconditionIC;
-
-    /**
-     * Typedef for the Incomplete LU decomposition preconditioner used for
-     * other blocks of the system matrix.
-     */
-    using PreconditionILU = dealii::TrilinosWrappers::PreconditionILU;
-
-    /**
-     * Typedef for the Jacobi preconditioner used for free surface velocity
-     * projection.
-     */
-    using PreconditionJacobi = dealii::TrilinosWrappers::PreconditionJacobi;
-
-    /**
-     * Typedef for the block compressed sparsity pattern type.
-     */
-    using BlockDynamicSparsityPattern = dealii::TrilinosWrappers::BlockSparsityPattern;
-
-    /**
-     * Typedef for the compressed sparsity pattern type.
-     */
-    using DynamicSparsityPattern = dealii::TrilinosWrappers::SparsityPattern;
-  }
-}
-
-
-/**
- * Print a header into the given stream that will be written both to screen
- * and to the log file and that provides basic information about what is
- * running, with how many processes, and using which linear algebra library.
- */
-template <class Stream>
-void print_aspect_header(Stream &stream);
-
-/**
- * A macro that is used in instantiating the ASPECT classes and functions for
- * both 2d and 3d. Call this macro with the name of another macro that when
- * called with a single integer argument instantiates the respective classes
- * in the given space dimension.
- */
-#define ASPECT_INSTANTIATE(INSTANTIATIONS) \
-  INSTANTIATIONS(2) \
-  INSTANTIATIONS(3)
-
-#endif
diff --git a/include/aspect/gravity_model/ascii_data.h.bak b/include/aspect/gravity_model/ascii_data.h.bak
deleted file mode 100644
index 1c1d407bd6a..00000000000
--- a/include/aspect/gravity_model/ascii_data.h.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_gravity_model_ascii_data_h
-#define _aspect_gravity_model_ascii_data_h
-
-#include <aspect/gravity_model/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace GravityModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a gravity description based on
-     * an AsciiData input file.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataProfile<dim>, public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataProfile<dim>::initialize;
-
-        /**
-         * Return the gravity as a function of position.
-         */
-        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Object containing the data profile.
-         */
-        std::unique_ptr<aspect::Utilities::StructuredDataLookup<1>> profile;
-
-        /**
-         * The column index of the gravity column in the data file.
-         */
-        unsigned int gravity_index;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/gravity_model/function.h.bak b/include/aspect/gravity_model/function.h.bak
deleted file mode 100644
index 16119d1166f..00000000000
--- a/include/aspect/gravity_model/function.h.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-  Copyright (C) 2014 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_gravity_model_function_h
-#define _aspect_gravity_model_function_h
-
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace GravityModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements gravity based on a functional description
-     * provided in the input file.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Function ();
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the gravity will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        void update () override;
-
-        /**
-         * Return the gravity vector as a function of position.
-         */
-        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the gravity.
-         */
-        Functions::ParsedFunction<dim> function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/gravity_model/interface.h.bak b/include/aspect/gravity_model/interface.h.bak
deleted file mode 100644
index a370ebb5e5f..00000000000
--- a/include/aspect/gravity_model/interface.h.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_gravity_model_interface_h
-#define _aspect_gravity_model_interface_h
-
-#include <aspect/plugins.h>
-#include <deal.II/base/point.h>
-#include <deal.II/base/parameter_handler.h>
-
-namespace aspect
-{
-  /**
-   * A namespace in which we define everything that has to do with modeling
-   * gravity.
-   *
-   * @ingroup GravityModels
-   */
-  namespace GravityModel
-  {
-    using namespace dealii;
-
-    /**
-     * A base class for parameterizations of gravity models.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Return the gravity vector as a function of position.
-         */
-        virtual Tensor<1,dim> gravity_vector (const Point<dim> &position) const = 0;
-    };
-
-
-
-
-    /**
-     * Register a gravity model so that it can be selected from the parameter
-     * file.
-     *
-     * @param name A string that identifies the gravity model
-     * @param description A text description of what this model does and that
-     * will be listed in the documentation of the parameter file.
-     * @param declare_parameters_function A pointer to a function that can be
-     * used to declare the parameters that this gravity model wants to read
-     * from input files.
-     * @param factory_function A pointer to a function that can create an
-     * object of this gravity model.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    void
-    register_gravity_model (const std::string &name,
-                            const std::string &description,
-                            void (*declare_parameters_function) (ParameterHandler &),
-                            std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-    /**
-     * A function that given the name of a model returns a pointer to an
-     * object that describes it. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The model object returned is not yet initialized and has not read its
-     * runtime parameters yet.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_gravity_model (ParameterHandler &prm);
-
-
-    /**
-     * Declare the runtime parameters of the registered gravity models.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm);
-
-
-    /**
-     * For the current plugin subsystem, write a connection graph of all of the
-     * plugins we know about, in the format that the
-     * programs dot and neato understand. This allows for a visualization of
-     * how all of the plugins that ASPECT knows about are interconnected, and
-     * connect to other parts of the ASPECT code.
-     *
-     * @param output_stream The stream to write the output to.
-     */
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &output_stream);
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a gravity model, register it with the functions that can declare
-     * their parameters and create these objects.
-     *
-     * @ingroup GravityModels
-     */
-#define ASPECT_REGISTER_GRAVITY_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_GRAVITY_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::GravityModel::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::GravityModel::register_gravity_model<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::GravityModel::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::GravityModel::register_gravity_model<3>, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/gravity_model/radial.h.bak b/include/aspect/gravity_model/radial.h.bak
deleted file mode 100644
index df05abe5ce9..00000000000
--- a/include/aspect/gravity_model/radial.h.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_gravity_model_radial_h
-#define _aspect_gravity_model_radial_h
-
-#include <aspect/simulator_access.h>
-#include <aspect/gravity_model/interface.h>
-
-namespace aspect
-{
-  namespace GravityModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes gravity as a radial vector of constant
-     * magnitude. The magnitude's value is read from the input file.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    class RadialConstant : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the gravity vector as a function of position.
-         */
-        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Magnitude of the gravity vector.
-         */
-        double magnitude;
-    };
-
-
-    /**
-     * This model has been removed due to its misleading name. The available
-     * AsciiData gravity model (using default parameters) is much more
-     * earth-like, since it uses the gravity profile used in the construction
-     * of the Preliminary Reference Earth Model (PREM, Dziewonski and Anderson,
-     * 1981).
-     *
-     * This is the model used and discussed in the step-32 tutorial program of
-     * deal.II.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    class RadialEarthLike : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization.
-         */
-        void initialize() override;
-
-        /**
-         * Return the gravity vector as a function of position.
-         */
-        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
-    };
-
-
-    /**
-     * A class that describes gravity as a radial vector of linearly
-     * changing magnitude with depth.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    class RadialLinear : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the gravity vector as a function of position.
-         */
-        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Magnitude of the gravity vector at the surface, m/s^2
-         */
-        double magnitude_at_surface;
-
-        /**
-         * Magnitude of the gravity vector at the bottom, m/s^2.
-         * 'Bottom' means at the maximum depth of the provided geometry, for
-         * a full sphere this means the center.
-         */
-        double magnitude_at_bottom;
-
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/gravity_model/vertical.h.bak b/include/aspect/gravity_model/vertical.h.bak
deleted file mode 100644
index 95d834ad3be..00000000000
--- a/include/aspect/gravity_model/vertical.h.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_gravity_model_vertical_h
-#define _aspect_gravity_model_vertical_h
-
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace GravityModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes gravity as a vector of constant magnitude
-     * pointing vertically down.
-     *
-     * @ingroup GravityModels
-     */
-    template <int dim>
-    class Vertical : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the gravity vector as a function of position.
-         */
-        Tensor<1,dim> gravity_vector (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Magnitude of the gravity vector.
-         */
-        double gravity_magnitude;
-
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/heating_model/adiabatic_heating.h.bak b/include/aspect/heating_model/adiabatic_heating.h.bak
deleted file mode 100644
index bd8588b3a49..00000000000
--- a/include/aspect/heating_model/adiabatic_heating.h.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_heating_model_adiabatic_heating_h
-#define _aspect_heating_model_adiabatic_heating_h
-
-#include <aspect/heating_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a standard adiabatic heating rate.
-     *
-     * This adds the term from adiabatic compression heating
-     *    $ \alpha T (\mathbf u \cdot \nabla p) $
-     * where we use the definition of
-     *    $ \alpha = - \frac{1}{\rho} \frac{\partial \rho}{\partial T} $
-     * Note: this term is often simplified using the relationship
-     *    $ \rho \mathbf g = - \nabla p $
-     * to yield
-     *    $ - \alpha \rho T (\mathbf u \cdot \mathbf g) $
-     *
-     * The user can specify if the simplification should be used
-     * by setting the corresponding flag in the input file.
-     * Also see the Equations section in the manual.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class AdiabaticHeating : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Returns whether we compute a simplified adiabatic heating term by
-         * neglecting dynamic pressure effects. I.e. we use
-         *     $ \alpha T (\mathbf u \cdot \nabla p) $
-         * as adiabatic heating term if this function returns false, and
-         *    $ - \alpha \rho T (\mathbf u \cdot \mathbf g) $
-         * if it returns true.
-         */
-        bool
-        use_simplified_adiabatic_heating() const;
-
-        /**
-         * Compute the heating model outputs for this class.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-      private:
-        bool simplified_adiabatic_heating;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/adiabatic_heating_of_melt.h.bak b/include/aspect/heating_model/adiabatic_heating_of_melt.h.bak
deleted file mode 100644
index d992018020e..00000000000
--- a/include/aspect/heating_model/adiabatic_heating_of_melt.h.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_heating_model_adiabatic_heating_of_melt_h
-#define _aspect_heating_model_adiabatic_heating_of_melt_h
-
-#include <aspect/heating_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a standard adiabatic heating rate
-     * for partially molten material.
-     *
-     * This adds the term from adiabatic compression heating
-     *    $ \alpha T (-\phi \mathbf u_s \cdot \nabla p)
-     *    + \alpha T (\phi \mathbf u_f \cdot \nabla p)$
-     * where we use the definition of
-     *    $ \alpha = - \frac{1}{\rho} \frac{\partial \rho}{\partial T} $
-     * Note: this term is often simplified using the relationship
-     *    $ \rho \mathbf g = - \nabla p $
-     * to yield
-     *    $ \alpha \rho_s T (\phi \mathbf u_s \cdot \mathbf g)
-     *    - \alpha \rho_f T (\phi \mathbf u_f \cdot \mathbf g) $
-     *
-     * The user can specify if the simplification should be used
-     * by setting the corresponding flag in the input file.
-     * Also see the Equations section in the manual.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class AdiabaticHeatingMelt : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Compute the heating model outputs for this class.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Allow the heating model to attach additional material model outputs.
-         */
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-
-        /**
-         * Allow the heating model to attach additional material model inputs it needs.
-         */
-        void
-        create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &inputs) const override;
-
-        /**
-         * @}
-         */
-
-      private:
-        bool simplified_adiabatic_heating;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/compositional_heating.h.bak b/include/aspect/heating_model/compositional_heating.h.bak
deleted file mode 100644
index 5d1a8c6dde1..00000000000
--- a/include/aspect/heating_model/compositional_heating.h.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2017 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_heating_model_compositional_heating_h
-#define _aspect_heating_model_compositional_heating_h
-
-#include <aspect/simulator_access.h>
-#include <aspect/heating_model/interface.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a heating model where each compositional field
-     * is assigned a user-defined internal heating value.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class CompositionalHeating : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the magnitude of heat production arising from values assigned
-         * to each compositional field.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Magnitude of heat production for each compositional field
-         */
-        std::vector<double> heating_values;
-
-        /**
-         * A vector with as many entries as compositional fields.
-         * If the entry for a particular field is true the field is considered
-         * during the averaging of heat production rates, if not the field is
-         * ignored. This is useful if some compositional fields
-         * are used to track properties like finite strain that should not
-         * contribute to heat production.
-         */
-        std::vector<bool> fields_used_in_heat_production_averaging;
-
-        /**
-         * Similar to fields_used_in_heat_production_averaging, except it
-         * determines whether to include the background field in the heat
-         * production computation.
-         */
-        bool use_background_field_for_heat_production_averaging;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/constant_heating.h.bak b/include/aspect/heating_model/constant_heating.h.bak
deleted file mode 100644
index 8eaa75402be..00000000000
--- a/include/aspect/heating_model/constant_heating.h.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_heating_model_constant_heating_h
-#define _aspect_heating_model_constant_heating_h
-
-#include <aspect/heating_model/interface.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a constant radiogenic heating rate.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class ConstantHeating : public Interface<dim>
-    {
-      public:
-        /**
-         * Return the heating terms. For the current class, this
-         * function obviously simply returns a constant value.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-      private:
-        double radiogenic_heating_rate;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/function.h.bak b/include/aspect/heating_model/function.h.bak
deleted file mode 100644
index 360677b3679..00000000000
--- a/include/aspect/heating_model/function.h.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_heating_model_function_h
-#define _aspect_heating_model_function_h
-
-#include <aspect/simulator_access.h>
-#include <aspect/heating_model/interface.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a heating model based on a functional
-     * description provided in the input file.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Function ();
-
-        /**
-         * Return the specific heating rate as calculated by the function
-         * object.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * allow the model to do whatever necessary. In this case the time of
-         * the function object is updated.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the components of the velocity.
-         */
-        Functions::ParsedFunction<dim> heating_model_function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/interface.h.bak b/include/aspect/heating_model/interface.h.bak
deleted file mode 100644
index d40d83d0ec9..00000000000
--- a/include/aspect/heating_model/interface.h.bak
+++ /dev/null
@@ -1,384 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_heating_model_interface_h
-#define _aspect_heating_model_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/point.h>
-#include <deal.II/base/parameter_handler.h>
-
-#include <boost/core/demangle.hpp>
-#include <typeinfo>
-
-
-namespace aspect
-{
-  template <int dim> class SimulatorAccess;
-  /**
-   * A namespace in which we define everything that has to do with defining
-   * the heating model.
-   *
-   * @ingroup HeatingModels
-   */
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A data structure with the output field of the
-     * HeatingModel::Interface::evaluate() function. The vectors are the
-     * values at the different positions given by
-     * MaterialModelInputs::position.
-     */
-    struct HeatingModelOutputs
-    {
-      /**
-       * Constructor. Initialize the various arrays of this structure with the
-       * given number of quadrature points and (finite element) components.
-       *
-       * @param n_points The number of quadrature points for which input
-       * quantities will be provided.
-       * @param n_comp The number of vector quantities (in the order in which
-       * the Introspection class reports them) for which input will be
-       * provided.
-       */
-      HeatingModelOutputs (const unsigned int n_points,
-                           const unsigned int n_comp);
-
-      /**
-       * All source terms of the temperature equation that represent a
-       * continuous process leading to a rate of change in temperature
-       * at the given position. This includes shear heating, adiabatic
-       * heating, radiogenic heat production, or any other heating rates
-       * on the right hand side of the energy equation.
-       */
-      std::vector<double> heating_source_terms;
-
-      /**
-       * The source terms of the temperature equation that represent
-       * fast changes in temperature (compared to the advection time
-       * scale), for example due to reactions, at the given position.
-       * On the advection time scale, these reactions might look like
-       * instantaneous changes in temperatures. This includes for example
-       * latent heat of melt.
-       *
-       * These reaction rates are only used in the operator_splitting nonlinear
-       * solver scheme, which allows it to solve reactions of compositional
-       * fields and temperature decoupled from the advection, and using a
-       * different time step size.
-       * In this case, they are used in addition to (and independent from) any
-       * heating_source_terms that a heating model defines, which are assembled
-       * as usual. For any other solver scheme, these values are ignored.
-       *
-       * In contrast to the heating source terms, these terms are actual changes
-       * in temperature (units K/s or K/yr) rather than changes in energy.
-       */
-      std::vector<double> rates_of_temperature_change;
-
-      /**
-       * Left hand side contribution of latent heat; this is added to the
-       * $\rho C_p$ term on the left hand side of the energy equation.
-       */
-      std::vector<double> lhs_latent_heat_terms;
-
-      /**
-       * Reset function. Resets all of the values in the heating model
-       * outputs to their uninitialized values (NaN for the source and latent
-       * heat terms, 0 for the rates of temperature change).
-       */
-      void
-      reset ();
-    };
-
-    /**
-     * A base class for parameterizations of heating models.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Function to compute the heating terms in @p heating_model_outputs
-         * given the inputs in @p material_model_inputs and the outputs of the
-         * material model in @p material_model_outputs.
-         * All parts of the @p heating_model_outputs structure have to be
-         * filled, heating_source_terms with the value of the heating rate and
-         * lhs_latent_heat_terms with the part of the latent heat that depends
-         * on the temperature change (and thus ends up on the left hand side of
-         * the temperature equation) at each quadrature point as defined in
-         * @p material_model_inputs, setting them to zero if they are not to
-         * be used in the computation.
-         */
-        virtual
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const = 0;
-
-        /**
-         * Allow the heating model to attach additional material model outputs.
-         * The default implementation of this function does not add any
-         * outputs. Consequently, derived classes do not have to overload
-         * this function if they do not need any additional outputs.
-         */
-        virtual
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const;
-
-        /**
-         * Allow the heating model to attach additional material model inputs
-         * it needs. The default implementation of this function does not add any
-         * inputs. Consequently, derived classes do not have to overload
-         * this function if they do not need any additional inputs.
-         */
-        virtual
-        void
-        create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &inputs) const;
-    };
-
-
-    /**
-     * A class that manages all objects that provide functionality to the
-     * heating models.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Returns true if the adiabatic heating plugin is found in the
-         * list of active heating models.
-         */
-        bool
-        adiabatic_heating_enabled() const;
-
-        /**
-         * Returns true if the shear heating plugin is found in the
-         * list of active heating models.
-         */
-        bool
-        shear_heating_enabled() const;
-
-        /**
-         * Declare the parameters of all known heating plugins, as
-         * well as of ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which heating model objects will be created; then
-         * let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * A function that calls the evaluate function of all the individual
-         * heating models and adds up the values of the individual heating
-         * model outputs.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const;
-
-        /**
-         * Allow the heating model plugins to attach additional material model
-         * inputs and outputs by looping over all registered plugins and calling
-         * their respective member functions.
-         */
-        virtual
-        void
-        create_additional_material_model_inputs_and_outputs(MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                                                            MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const;
-
-
-        /**
-         * A function that is used to register heating model objects in such
-         * a way that the Manager can deal with all of them without having to
-         * know them by name. This allows the files in which individual
-         * plugins are implemented to register these plugins, rather than also
-         * having to modify the Manager class by adding the new heating plugin
-         * class.
-         *
-         * @param name A string that identifies the heating model
-         * @param description A text description of what this model does and that
-         * will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that can be
-         * used to declare the parameters that this heating model wants to read
-         * from input files.
-         * @param factory_function A pointer to a function that can create an
-         * object of this heating model.
-         *
-         * @ingroup HeatingModels
-         */
-        static
-        void
-        register_heating_model (const std::string &name,
-                                const std::string &description,
-                                void (*declare_parameters_function) (ParameterHandler &),
-                                std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-
-        /**
-         * Return a list of names of all heating models currently used in the
-         * computation, as specified in the input file.
-         */
-        const std::vector<std::string> &
-        get_active_heating_model_names () const;
-
-        /**
-         * Return a list of pointers to all heating models currently used in the
-         * computation, as specified in the input file.
-         */
-        const std::list<std::unique_ptr<Interface<dim>>> &
-        get_active_heating_models () const;
-
-        /**
-         * Go through the list of all heating models that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename HeatingModelType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,HeatingModelType>::value>>
-        bool
-        has_matching_heating_model () const;
-
-        /**
-         * Go through the list of all heating models that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no heating model is active that matches the given type,
-         * throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename HeatingModelType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,HeatingModelType>::value>>
-        const HeatingModelType &
-        get_matching_heating_model () const;
-
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcHeatingModelNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered heating model objects.");
-      private:
-        /**
-         * A list of names of heating model objects that have been requested
-         * in the parameter file.
-         */
-        std::vector<std::string> model_names;
-    };
-
-
-
-    template <int dim>
-    template <typename HeatingModelType, typename>
-    inline
-    bool
-    Manager<dim>::has_matching_heating_model () const
-    {
-      return this->template has_matching_plugin_object<HeatingModelType>();
-    }
-
-
-    template <int dim>
-    template <typename HeatingModelType, typename>
-    inline
-    const HeatingModelType &
-    Manager<dim>::get_matching_heating_model () const
-    {
-      return this->template get_matching_plugin_object<HeatingModelType>();
-    }
-
-
-    /**
-     * Return a string that consists of the names of heating models that can
-     * be selected. These names are separated by a vertical line '|' so
-     * that the string can be an input to the deal.II classes
-     * Patterns::Selection or Patterns::MultipleSelection.
-     */
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ();
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a heating model, register it with the
-     * aspect::HeatingModel::Manager class.
-     *
-     * @ingroup HeatingModels
-     */
-#define ASPECT_REGISTER_HEATING_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_HEATING_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::HeatingModel::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::HeatingModel::Manager<2>::register_heating_model, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::HeatingModel::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::HeatingModel::Manager<3>::register_heating_model, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/latent_heat.h.bak b/include/aspect/heating_model/latent_heat.h.bak
deleted file mode 100644
index 2761cccfae6..00000000000
--- a/include/aspect/heating_model/latent_heat.h.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_heating_model_latent_heat_h
-#define _aspect_heating_model_latent_heat_h
-
-#include <aspect/heating_model/interface.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a standard formulation of latent heat.
-     * This includes a left hand side and a right hand side term:
-     *
-     * The left hand side is
-     *   $ -\rho T \frac{\partial S}{\partial T} \frac{D T}{D t}$
-     * so that we can add
-     *   $ -\rho T \frac{\partial S}{\partial T} $
-     * to the $\rho C_p$ term.
-     *
-     * The right-hand side term from latent heating is
-     *   $\frac{\partial S}{\partial p} T \rho (u \dot \nabla p)$.
-     *
-     * T, u, and p are the solutions from the previous time step or
-     * are extrapolated from there, depending on what is provided
-     * in the input arguments of this function.
-     *
-     * Formulation modified after Christensen, Ulrich R. & Yuen,
-     * David A.: Layered convection induced by phase transitions,
-     * Journal of Geophysical Research: Solid Earth (1985).
-     *
-     * Also see the Equations section in the manual.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class LatentHeat : public Interface<dim>
-    {
-      public:
-        /**
-         * Compute the heating model outputs for this class.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/latent_heat_melt.h.bak b/include/aspect/heating_model/latent_heat_melt.h.bak
deleted file mode 100644
index 272771e2b82..00000000000
--- a/include/aspect/heating_model/latent_heat_melt.h.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_heating_model_latent_heat_melt_h
-#define _aspect_heating_model_latent_heat_melt_h
-
-#include <aspect/heating_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a standard formulation of latent heat
-     * of melting. This assumes that there is a compositional field
-     * called porosity, and it uses the reaction term of this field
-     * (the fraction of material that melted in the current time step)
-     * multiplied by a constant entropy change for melting 100%
-     * of the material as source term of the heating model.
-     * The left-hand side term is zero.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class LatentHeatMelt : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Compute the heating model outputs for this class.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-        virtual
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-
-      private:
-        // entropy change upon melting
-        double melting_entropy_change;
-        bool   retrieve_entropy_change_from_material_model;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/radioactive_decay.h.bak b/include/aspect/heating_model/radioactive_decay.h.bak
deleted file mode 100644
index d4bf222225a..00000000000
--- a/include/aspect/heating_model/radioactive_decay.h.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_heating_model_radioactive_decay_h
-#define _aspect_heating_model_radioactive_decay_h
-
-#include <aspect/simulator_access.h>
-#include <aspect/heating_model/interface.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a heating model based on radioactive decay.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class RadioactiveDecay : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        RadioactiveDecay ();
-
-        /**
-         * Return the specific heating rate as calculated by radioactive
-         * decay.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * Number of radio active heating elements.
-         */
-        unsigned int                   n_radio_heating_elements;
-
-        /**
-         * Store the half life of different elements.
-         */
-        std::vector<double>            half_decay_times;
-
-        /**
-         * Store the unit heating rate of different elements.
-         */
-        std::vector<double>            radioactive_heating_rates;
-
-        /**
-         * Store the initial concentration in the crust.
-         */
-        std::vector<double>            radioactive_initial_concentrations_crust;
-
-        /**
-         * Store the initial concentration in the mantle.
-         */
-        std::vector<double>            radioactive_initial_concentrations_mantle;
-
-        /**
-         * Whether crust defined by composition or depth
-         */
-        bool                           is_crust_defined_by_composition;
-
-        /**
-         * Depth of the crust.
-         */
-        double                         crust_depth;
-
-        /**
-         * Composition number of crust.
-         */
-        unsigned int                   crust_composition_num;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/shear_heating.h.bak b/include/aspect/heating_model/shear_heating.h.bak
deleted file mode 100644
index ee9cd7bf53c..00000000000
--- a/include/aspect/heating_model/shear_heating.h.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_heating_model_shear_heating_h
-#define _aspect_heating_model_shear_heating_h
-
-#include <aspect/heating_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/rheology/drucker_prager.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a standard shear heating rate.
-     *
-     * Add the term
-     *    $  2 \eta \left( \varepsilon - \frac{1}{3} \text{tr}
-     *       \varepsilon \mathbf 1 \right) : \left( \varepsilon - \frac{1}{3}
-     *       \text{tr} \varepsilon \mathbf 1 \right) $
-     *
-     * Also see the Equations section in the manual.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class ShearHeating : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Compute the heating model outputs for this class.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * Allow the heating model to attach additional material model outputs.
-         */
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Parameters used for limiting the stress being used in the shear
-         * heating computation. To prevent shear heating from becoming
-         * unrealistically high, a Drucker-Prager yield criterion as given
-         * in the DruckerPrager rheology model can be used to define a
-         * maximum stress computed from the given cohesion and friction
-         * angle.
-         */
-        bool limit_stress;
-        double cohesion;
-        double friction_angle;
-        MaterialModel::Rheology::DruckerPrager<dim> drucker_prager_plasticity;
-    };
-
-
-    /**
-     * Additional output fields for the shear heating computation
-     * to be added to the MaterialModel::MaterialModelOutputs structure
-     * and filled in the MaterialModel::evaluate() function.
-     */
-    template <int dim>
-    class ShearHeatingOutputs : public MaterialModel::NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        ShearHeatingOutputs(const unsigned int n_points);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * The fraction of the deformation work that is released as shear heating
-         * rather than being converted into other forms of energy (such as, for
-         * example, surface energy of grains). If it is set to 1, all deformation
-         * work will go into shear heating.
-         */
-        std::vector<double> shear_heating_work_fractions;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/heating_model/shear_heating_with_melt.h.bak b/include/aspect/heating_model/shear_heating_with_melt.h.bak
deleted file mode 100644
index 01e1847ae56..00000000000
--- a/include/aspect/heating_model/shear_heating_with_melt.h.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_heating_model_shear_heating_with_melt_h
-#define _aspect_heating_model_shear_heating_with_melt_h
-
-#include <aspect/heating_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a standard shear heating rate for dissipation
-     * heating of partially molten material.
-     *
-     * Add the term
-     *    $   \xi \left( \nabla \cdot \mathbf u_s \right)^2 $,
-     * which corresponds to bulk (compression) heating,
-     * and the term
-     *    $   \frac{\eta_f \phi^2}{k_{\phi}} \left( \mathbf u_f - \mathbf u_s \right)^2 $,
-     * which corresponds to heating due to melt segregation.
-     * Both terms are heating source terms, and the left-hand side term is zero.
-     *
-     * Also see the Equations section in the manual.
-     *
-     * @ingroup HeatingModels
-     */
-    template <int dim>
-    class ShearHeatingMelt : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Compute the heating model outputs for this class.
-         */
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const override;
-
-        /**
-         * Allow the heating model to attach additional material model outputs.
-         */
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &) const override;
-
-        /**
-         * Allow the heating model to attach additional material model inputs it needs.
-         */
-        void
-        create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &) const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_composition/adiabatic_density.h.bak b/include/aspect/initial_composition/adiabatic_density.h.bak
deleted file mode 100644
index 9229a7c753c..00000000000
--- a/include/aspect/initial_composition/adiabatic_density.h.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_composition_adiabatic_density_h
-#define _aspect_initial_composition_adiabatic_density_h
-
-#include <aspect/initial_composition/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements initial conditions for the compositional fields
-     * based on the adiabatic density profile. Note that only the field
-     * of the type 'density' will be filled, for all other fields
-     * this plugin returns 0.0.
-     *
-     * @ingroup InitialCompositionModels
-     */
-    template <int dim>
-    class AdiabaticDensity : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the initial composition as the adiabatic density at this
-         * point.
-         */
-        double initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_composition/ascii_data.h.bak b/include/aspect/initial_composition/ascii_data.h.bak
deleted file mode 100644
index 0a75b0af38d..00000000000
--- a/include/aspect/initial_composition/ascii_data.h.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_composition_ascii_data_h
-#define _aspect_initial_composition_ascii_data_h
-
-#include <aspect/initial_composition/interface.h>
-
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements the prescribed compositional fields determined
-     * from a AsciiData input file.
-     *
-     * @ingroup InitialCompositionModels
-     */
-    template <int dim>
-    class AsciiData : public Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the initial composition as a function of position. For the
-         * current class, this function returns value from the text files.
-         */
-        double
-        initial_composition (const Point<dim> &position,
-                             const unsigned int n_comp) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The dataset that contains the initial composition.
-         */
-        std::unique_ptr<Utilities::AsciiDataInitial<dim>> ascii_data_initial;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_composition/ascii_data_layered.h.bak b/include/aspect/initial_composition/ascii_data_layered.h.bak
deleted file mode 100644
index 064e3cda15a..00000000000
--- a/include/aspect/initial_composition/ascii_data_layered.h.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_composition_ascii_data_layered_h
-#define _aspect_initial_composition_ascii_data_layered_h
-
-#include <aspect/initial_composition/interface.h>
-
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements prescribed compositional fields determined from
-     * AsciiData input files. Each file defines a layer boundary as a grid of points.
-     *
-     * @ingroup InitialCompositionModels
-     */
-    template <int dim>
-    class AsciiDataLayered : public Interface<dim>, public Utilities::AsciiDataLayered<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiDataLayered ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataLayered<dim>::initialize;
-
-        /**
-         * Return the initial composition as a function of position. For the
-         * current class, this function returns value from the text files.
-         */
-        double
-        initial_composition (const Point<dim> &position,
-                             const unsigned int n_comp) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_composition/entropy_table_lookup.h.bak b/include/aspect/initial_composition/entropy_table_lookup.h.bak
deleted file mode 100644
index fed4a58a985..00000000000
--- a/include/aspect/initial_composition/entropy_table_lookup.h.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_composition_entropy_table_lookup_h
-#define _aspect_initial_composition_entropy_table_lookup_h
-
-#include <aspect/initial_composition/interface.h>
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements initial conditions for the entropy field
-     * Note that this plugin only
-     * works if there is a compositional field called 'entropy'.
-     * All compositional fields except entropy are not changed by this plugin.
-     *
-     * @ingroup InitialCompositionModels
-     */
-    template <int dim>
-    class EntropyTableLookUp : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialize the plugin.
-         */
-        void initialize () override;
-
-        /**
-         * Return the initial composition as a function of position and number
-         * of compositional field.
-         */
-        double initial_composition (const Point<dim> &position,
-                                    const unsigned int compositional_index) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Information about the location of data files.
-         */
-        std::string data_directory;
-        std::string material_file_name;
-
-        /**
-         * Index of the entropy in the compositional fields
-         */
-        unsigned entropy_index;
-
-        /**
-         * A shared pointer to the initial temperature object
-         * that ensures that the current object can continue
-         * to access the initial temperature object beyond the
-         * first time step.
-         */
-        std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature_manager;
-
-        /**
-         * A shared pointer to the initial composition object
-         * that ensures that the current object can continue
-         * to access the initial composition object beyond the
-         * first time step.
-         */
-        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition_manager;
-
-        /**
-         * Pointer to the StructuredDataLookup object that holds the material data.
-         */
-        std::unique_ptr<Utilities::StructuredDataLookup<2>> material_lookup;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_composition/function.h.bak b/include/aspect/initial_composition/function.h.bak
deleted file mode 100644
index 15d0ffc7170..00000000000
--- a/include/aspect/initial_composition/function.h.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_composition_function_h
-#define _aspect_initial_composition_function_h
-
-#include <aspect/initial_composition/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements initial conditions for the compositional fields
-     * based on a functional description provided in the input file.
-     *
-     * @ingroup InitialCompositionModels
-     */
-    template <int dim>
-    class Function : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the initial composition as a function of position and number
-         * of compositional field.
-         */
-        double initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the compositional fields.
-         */
-        std::unique_ptr<Functions::ParsedFunction<dim>> function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_composition/interface.h.bak b/include/aspect/initial_composition/interface.h.bak
deleted file mode 100644
index 96a1f5df87c..00000000000
--- a/include/aspect/initial_composition/interface.h.bak
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_composition_interface_h
-#define _aspect_initial_composition_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/point.h>
-#include <deal.II/base/parameter_handler.h>
-
-#include <boost/core/demangle.hpp>
-#include <typeinfo>
-
-
-namespace aspect
-{
-  template <int dim> class SimulatorAccess;
-
-  /**
-   * A namespace in which we define everything that has to do with defining
-   * the initial composition.
-   *
-   * @ingroup InitialCompositions
-   */
-  namespace InitialComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A base class for parameterizations of initial conditions.
-     *
-     * @ingroup InitialCompositions
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Return the initial composition as a function of position.
-         */
-        virtual
-        double initial_composition (const Point<dim> &position, const unsigned int n_comp) const = 0;
-    };
-
-
-
-    /**
-     * A class that manages all initial composition objects.
-     *
-     * @ingroup InitialCompositions
-     */
-    template <int dim>
-    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Destructor. Made virtual since this class has virtual member
-         * functions.
-         */
-        ~Manager () override;
-
-        /**
-         * Update function. Called once at the beginning of a timestep to
-         * update all plugin objects.
-         */
-        void update () override;
-
-        /**
-         * Declare the parameters of all known initial composition plugins, as
-         * well as of ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which initial composition objects will be created;
-         * then let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * A function that calls the initial_composition functions of all
-         * individual initial composition objects for the composition given
-         * by @p n_comp, and adds up the values of the
-         * individual calls.
-         */
-        double
-        initial_composition (const Point<dim> &position,
-                             const unsigned int n_comp) const;
-
-        /**
-         * A function that is used to register initial composition objects in
-         * such a way that the Manager can deal with all of them without having
-         * to know them by name. This allows the files in which individual
-         * plugins are implemented to register these plugins, rather than also
-         * having to modify the Manager class by adding the new initial
-         * composition plugin class.
-         *
-         * @param name A string that identifies the initial composition model
-         * @param description A text description of what this model does and that
-         * will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that can be
-         * used to declare the parameters that this initial composition model
-         * wants to read from input files.
-         * @param factory_function A pointer to a function that can create an
-         * object of this initial composition model.
-         */
-        static
-        void
-        register_initial_composition (const std::string &name,
-                                      const std::string &description,
-                                      void (*declare_parameters_function) (ParameterHandler &),
-                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-
-        /**
-         * Return a list of names of all initial composition models currently
-         * used in the computation, as specified in the input file.
-         */
-        const std::vector<std::string> &
-        get_active_initial_composition_names () const;
-
-        /**
-         * Return a list of pointers to all initial composition models
-         * currently used in the computation, as specified in the input file.
-         */
-        const std::list<std::unique_ptr<Interface<dim>>> &
-        get_active_initial_composition_conditions () const;
-
-        /**
-         * Go through the list of all initial composition models that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename InitialCompositionType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,InitialCompositionType>::value>>
-        bool
-        has_matching_initial_composition_model () const;
-
-        /**
-         * Go through the list of all initial composition models that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no initial composition model is active that matches the given type,
-         * throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename InitialCompositionType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,InitialCompositionType>::value>>
-        const InitialCompositionType &
-        get_matching_initial_composition_model () const;
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcInitialCompositionNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered initial composition objects.");
-      private:
-        /**
-         * A list of names of initial composition objects that have been requested
-         * in the parameter file.
-         */
-        std::vector<std::string> model_names;
-
-        /**
-         * A list of enums of initial composition operators that have been
-         * requested in the parameter file. Each entry is used to modify the
-         * initial compositional field with the values from the associated plugin
-         * in model_names.
-         */
-        std::vector<aspect::Utilities::Operator> model_operators;
-    };
-
-
-
-    template <int dim>
-    template <typename InitialCompositionType, typename>
-    inline
-    bool
-    Manager<dim>::has_matching_initial_composition_model () const
-    {
-      return this->template has_matching_plugin_object<InitialCompositionType>();
-    }
-
-
-    template <int dim>
-    template <typename InitialCompositionType, typename>
-    inline
-    const InitialCompositionType &
-    Manager<dim>::get_matching_initial_composition_model () const
-    {
-      return this->template get_matching_plugin_object<InitialCompositionType>();
-    }
-
-
-    /**
-     * Return a string that consists of the names of initial composition models that can
-     * be selected. These names are separated by a vertical line '|' so
-     * that the string can be an input to the deal.II classes
-     * Patterns::Selection or Patterns::MultipleSelection.
-     *
-     * @ingroup InitialCompositions
-     */
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ();
-
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a initial composition model, register it with the functions that can
-     * declare their parameters and create these objects.
-     *
-     * @ingroup InitialCompositions
-     */
-#define ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::InitialComposition::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::InitialComposition::Manager<2>::register_initial_composition, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::InitialComposition::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::InitialComposition::Manager<3>::register_initial_composition, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_composition/porosity.h.bak b/include/aspect/initial_composition/porosity.h.bak
deleted file mode 100644
index ea9b6709951..00000000000
--- a/include/aspect/initial_composition/porosity.h.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_composition_porosity_h
-#define _aspect_initial_composition_porosity_h
-
-#include <aspect/initial_composition/interface.h>
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements initial conditions for the porosity field
-     * by computing the equilibrium melt fraction for the given initial
-     * condition and reference pressure profile. Note that this plugin only
-     * works if there is a compositional field called 'porosity', and the
-     * used material model implements the 'MeltFractionModel' interface.
-     * All compositional fields except porosity are not changed by this plugin.
-     *
-     * @ingroup InitialCompositionModels
-     */
-    template <int dim>
-    class Porosity : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialize the plugin.
-         */
-        void initialize () override;
-
-        /**
-         * Return the initial composition as a function of position and number
-         * of compositional field.
-         */
-        double initial_composition (const Point<dim> &position,
-                                    const unsigned int compositional_index) const override;
-
-      private:
-        /**
-         * A shared pointer to the initial temperature object
-         * that ensures that the current object can continue
-         * to access the initial temperature object beyond the
-         * first time step.
-         */
-        std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature_manager;
-
-        /**
-         * A shared pointer to the initial composition object
-         * that ensures that the current object can continue
-         * to access the initial composition object beyond the
-         * first time step.
-         */
-        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition_manager;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_composition/slab_model.h.bak b/include/aspect/initial_composition/slab_model.h.bak
deleted file mode 100644
index 6750c5f9055..00000000000
--- a/include/aspect/initial_composition/slab_model.h.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_composition_slab_model_h
-#define _aspect_initial_composition_slab_model_h
-
-#include <aspect/initial_composition/interface.h>
-
-#include <aspect/simulator_access.h>
-#include <aspect/structured_data.h>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements subducted slab geometries as a compositional
-     * field determined from an input file. The file defines the depth to
-     * the top of the slab and the slab thickness.
-     *
-     * An example model that is included is Slab2 described in
-     * Hayes, G. P., Moore, G. L., Portner, D. E., Hearne, M., Flamme, H., Furtney, M.,
-     * & Smoczyk, G. M. (2018). Slab2, a comprehensive subduction zone geometry model.
-     * Science, 362(6410), 58-61.
-     *
-     * @ingroup InitialCompositionModels
-     */
-    template <int dim>
-    class SlabModel : public Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the initial composition as a function of position. For the
-         * current class, this function returns 1.0 inside subducted slabs and 0.0 outside.
-         */
-        double
-        initial_composition (const Point<dim> &position,
-                             const unsigned int n_comp) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-        * A function that returns the slab_boundary object to allow access
-        * in other places.
-        */
-        const Utilities::AsciiDataBoundary<dim> &get_slab_boundary() const;
-
-      private:
-        /**
-         * An object of ascii data boundary to input subducted slab depths
-         * and thicknesses.
-         */
-        Utilities::AsciiDataBoundary<dim> slab_boundary;
-
-        /**
-         * Cache the surface boundary id to avoid unnecessary lookups.
-         */
-        types::boundary_id surface_boundary_id;
-
-        /**
-         * Cache the compositional field index that corresponds to
-         * the slab composition to avoid unnecessary lookups.
-         */
-        unsigned int slab_index;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_composition/world_builder.h.bak b/include/aspect/initial_composition/world_builder.h.bak
deleted file mode 100644
index 144e18ff530..00000000000
--- a/include/aspect/initial_composition/world_builder.h.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_initial_composition_world_builder_h
-#define _aspect_initial_composition_world_builder_h
-
-#include <aspect/global.h>
-
-#ifdef ASPECT_WITH_WORLD_BUILDER
-
-#include <aspect/initial_composition/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace WorldBuilder
-{
-  class World;
-}
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements initial conditions for the compositional fields
-     * based on a functional description provided in the input file through the
-     * World builder.
-     *
-     * @ingroup InitialCompositionModels
-     */
-    template <int dim>
-    class WorldBuilder : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run and after
-         * the SimulatorAccess (if applicable) is initialized.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the initial composition as a function of position and number
-         * of compositional field.
-         */
-        double initial_composition (const Point<dim> &position, const unsigned int n_comp) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A vector that specifies for each compositional field index if the world builder
-         * should be evaluated for this compositional field.
-         */
-        std::vector<bool> relevant_compositions;
-
-        /**
-         * A pointer to the WorldBuilder object. Keeping this pointer ensures
-         * that the object doesn't go away while we still need it.
-         */
-        std::shared_ptr<const ::WorldBuilder::World> world_builder;
-    };
-  }
-}
-
-#endif
-#endif
diff --git a/include/aspect/initial_temperature/S40RTS_perturbation.h.bak b/include/aspect/initial_temperature/S40RTS_perturbation.h.bak
deleted file mode 100644
index fa9bf8f7328..00000000000
--- a/include/aspect/initial_temperature/S40RTS_perturbation.h.bak
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_S40RTS_perturbation_h
-#define _aspect_initial_temperature_S40RTS_perturbation_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    namespace internal
-    {
-      namespace S40RTS
-      {
-        class SphericalHarmonicsLookup
-        {
-          public:
-            SphericalHarmonicsLookup(const std::string &filename,
-                                     const MPI_Comm comm);
-
-            /// Declare a function that returns the cosine coefficients
-            const std::vector<double> &
-            cos_coeffs() const;
-
-            /// Declare a function that returns the sine coefficients
-            const std::vector<double> &
-            sin_coeffs() const;
-
-            unsigned int maxdegree() const;
-
-          private:
-            unsigned int order;
-            std::vector<double> a_lm;
-            std::vector<double> b_lm;
-        };
-
-        class SplineDepthsLookup
-        {
-          public:
-            SplineDepthsLookup(const std::string &filename,
-                               const MPI_Comm comm);
-
-            const std::vector<double> &
-            spline_depths() const;
-
-          private:
-            std::vector<double> depths;
-        };
-      }
-    }
-
-    template <int dim>
-    class PatchOnS40RTS;
-
-
-    /**
-     * A class that describes a perturbed initial temperature field for a
-     * spherical shell geometry model. The perturbation is based on the S20RTS
-     * / S40RTS global shear wave velocity model by Ritsema et al.
-     * http://www.earth.lsa.umich.edu/~jritsema/research.html
-     *
-     * @ingroup InitialTemperatures
-     */
-
-    template <int dim>
-    class S40RTSPerturbation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        S40RTSPerturbation ();
-
-        /**
-         * Initialization function. Loads the material data and sets up
-         * pointers.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the Vs as a function of position.
-         */
-        virtual
-        double get_Vs (const Point<dim> &position) const;
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * An enum to describe which method should be chosen to scale vs to density.
-         */
-        enum VsToDensityMethod
-        {
-          file,
-          constant
-        };
-
-        /**
-         * Currently chosen source for vs to density scaling.
-         */
-        VsToDensityMethod vs_to_density_method;
-
-        /**
-         * File directory and names
-         */
-        std::string data_directory;
-        std::string spline_depth_file_name;
-
-        /**
-         * This parameter allows setting the input file for the shear-wave
-         * perturbation. Options so far are S20RTS.sph and S40RTS.sph. For
-         * S40RTS there are different versions available that differ by the
-         * degree of damping in the seismic inversion. These models could be
-         * downloaded and used as well.
-         */
-        std::string harmonics_coeffs_file_name;
-
-        /**
-         * The parameters below describe the perturbation of shear wave
-         * velocity into a temperatures perturbation. The first parameter is
-         * constant so far but could be made depth dependent as constraint by
-         * e.g. Forte, A.M. & Woodward, R.L., 1997. Seismic-geodynamic
-         * constraints on three- dimensional structure, vertical flow, and
-         * heat transfer in the mantle, J. Geophys. Res. 102 (B8),
-         * 17,981-17,994.
-         * The last parameter is a depth down to which heterogeneities are
-         * zeroed out.
-         */
-        double vs_to_density_constant;
-        double thermal_alpha;
-        double no_perturbation_depth;
-
-        /**
-         * This parameter allows to remove the degree 0 component of the shear
-         * wave velocity perturbation, which guarantees that average
-         * temperature at a certain depth is the background temperature.
-         */
-        bool zero_out_degree_0;
-
-        /**
-         * This parameter allows to use a lower maximum degree when reading
-         * the spherical harmonic data file.
-         */
-        bool lower_max_degree;
-
-        /**
-         * The maximum degree the users specify, which is only valid when
-         * "lower_max_degree" is set to true.
-         */
-        unsigned int specified_max_degree;
-
-        /**
-         * This parameter gives the reference temperature, which will be
-         * perturbed. In the compressional case the background temperature
-         * will be the adiabat.
-         */
-        double reference_temperature;
-
-        /**
-         * Pointer to an object that reads and processes the spherical
-         * harmonics coefficients
-         */
-        std::unique_ptr<internal::S40RTS::SphericalHarmonicsLookup> spherical_harmonics_lookup;
-
-        /**
-         * Pointer to an object that reads and processes the depths for the
-         * spline knot points.
-         */
-        std::unique_ptr<internal::S40RTS::SplineDepthsLookup> spline_depths_lookup;
-
-        /**
-         * Object containing the data profile.
-         */
-        aspect::Utilities::AsciiDataProfile<dim> profile;
-
-        /**
-         * The column index of the vs to density scaling in the data file
-         */
-        unsigned int vs_to_density_index;
-
-        /**
-         * Whether to use the thermal expansion coefficient from the material model
-         */
-        bool use_material_model_thermal_alpha;
-
-        template <int dim2> friend class PatchOnS40RTS;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/initial_temperature/SAVANI_perturbation.h.bak b/include/aspect/initial_temperature/SAVANI_perturbation.h.bak
deleted file mode 100644
index ec5c4a22905..00000000000
--- a/include/aspect/initial_temperature/SAVANI_perturbation.h.bak
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_SAVANI_perturbation_h
-#define _aspect_initial_temperature_SAVANI_perturbation_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    namespace internal
-    {
-      namespace SAVANI
-      {
-        class SphericalHarmonicsLookup;
-        class SplineDepthsLookup;
-      }
-    }
-
-    /**
-     * A class that describes a perturbed initial temperature field for a
-     * spherical shell geometry model. The perturbation is based on the SAVANI
-     * global shear wave velocity model by Auer et al.
-     * http://n.ethz.ch/~auerl/research.html
-     *
-     * @ingroup InitialTemperatures
-     */
-
-    template <int dim>
-    class SAVANIPerturbation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        SAVANIPerturbation ();
-
-
-        /**
-         * Initialization function. Loads the material data and sets up
-         * pointers.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the Vs as a function of position.
-         */
-        //TODO
-        virtual
-        double get_Vs (const Point<dim> &position) const;
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-      private:
-
-        /**
-         * An enum to describe which method should be chosen to scale vs to density.
-         */
-        enum VsToDensityMethod
-        {
-          file,
-          constant
-        };
-
-        /**
-         * Currently chosen source for vs to density scaling.
-         */
-        VsToDensityMethod vs_to_density_method;
-
-        /**
-         * File directory and names
-         */
-        std::string data_directory;
-        std::string spline_depth_file_name;
-
-        /**
-         * This parameter allows setting the input file for the SAVANI global
-         * shear-wave perturbation.
-         */
-        std::string harmonics_coeffs_file_name;
-
-        /**
-         * The parameters below describe the perturbation of shear wave
-         * velocity into a temperatures perturbation. The first parameter is
-         * constant so far but could be made depth dependent as constraint by
-         * e.g. Forte, A.M. & Woodward, R.L., 1997. Seismic-geodynamic
-         * constraints on three- dimensional structure, vertical flow, and
-         * heat transfer in the mantle, J. Geophys. Res. 102 (B8),
-         * 17,981-17,994.
-         * The last parameter is a depth down to which heterogeneities are
-         * zeroed out.
-         */
-        double vs_to_density_constant;
-        double thermal_alpha;
-        double no_perturbation_depth;
-
-        /**
-         * This parameter allows to remove the degree 0 component of the shear
-         * wave velocity perturbation, which guarantees that average
-         * temperature at a certain depth is the background temperature.
-         */
-        bool zero_out_degree_0;
-
-        /**
-         * This parameter allows to use a lower maximum degree when reading
-         * the spherical harmonic data file.
-         */
-        bool lower_max_degree;
-
-        /**
-         * The maximum degree the users specify, which is only valid when
-         * "lower_max_degree" is set to true.
-         */
-        unsigned int specified_max_degree;
-
-        /**
-         * This parameter gives the reference temperature, which will be
-         * perturbed. In the compressional case the background temperature
-         * will be the adiabat.
-         */
-        double reference_temperature;
-
-        /**
-         * Pointer to an object that reads and processes the spherical
-         * harmonics coefficients
-         */
-        std::unique_ptr<internal::SAVANI::SphericalHarmonicsLookup> spherical_harmonics_lookup;
-
-        /**
-         * Pointer to an object that reads and processes the depths for the
-         * spline knot points.
-         */
-        std::unique_ptr<internal::SAVANI::SplineDepthsLookup> spline_depths_lookup;
-
-        /**
-         * Object containing the data profile.
-         */
-        aspect::Utilities::AsciiDataProfile<dim> profile;
-
-        /**
-         * The column index of the vs to density scaling in the data file
-         */
-        unsigned int vs_to_density_index;
-
-        /**
-         * Whether to use the thermal expansion coefficient from the material model
-         */
-        bool use_material_model_thermal_alpha;
-
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/initial_temperature/adiabatic.h.bak b/include/aspect/initial_temperature/adiabatic.h.bak
deleted file mode 100644
index 766ba7b786e..00000000000
--- a/include/aspect/initial_temperature/adiabatic.h.bak
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
-  Copyright (C) 2012 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_adiabatic_h
-#define _aspect_initial_temperature_adiabatic_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A namespace for selecting how to determine the age of a
-     * boundary layer. Current options are:
-     *
-     *  'constant': A constant age independent of position.
-     *  'ascii_data': Age is specified in an ascii data file.
-     *  'function': Age is specified as a function in the input file.
-     */
-    namespace BoundaryLayerAgeModel
-    {
-      enum Kind
-      {
-        constant,
-        ascii_data,
-        function
-      };
-
-      /**
-       * Read the lithosphere age model from the parameter file,
-       * using the parameter name given in @p parameter_name, and return the
-       * enum that corresponds to this operation.
-       */
-      BoundaryLayerAgeModel::Kind
-      parse (const std::string &parameter_name,
-             const ParameterHandler &prm);
-    }
-
-    /**
-     * A class that implements adiabatic initial conditions for the
-     * temperature field and, optional, upper and lower thermal boundary
-     * layers calculated using the half-space cooling model. The age of the
-     * boundary layers are input parameters.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class Adiabatic : public Interface<dim>, public Utilities::AsciiDataBoundary<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Adiabatic ();
-
-        void initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataBoundary<dim>::initialize;
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The boundary identifier representing the 'surface' boundary as
-         * reported by the geometry model.
-         */
-        types::boundary_id surface_boundary_id;
-
-        /**
-         * Age of the upper thermal boundary layer at the surface of the
-         * model. If set to zero, no boundary layer will be present in the
-         * model.
-         */
-        double age_top_boundary_layer;
-
-        /* Age of the lower thermal boundary layer. */
-        double age_bottom_boundary_layer;
-
-        /**
-         * Radius (in m) of the initial temperature perturbation at the bottom
-         * of the model domain.
-         */
-        double radius;
-        /**
-         * Amplitude (in K) of the initial temperature perturbation at the
-         * bottom of the model domain.
-         */
-        double amplitude;
-        /*
-         * Position of the initial temperature perturbation (in the
-         * center or at the boundary of the model domain).
-         */
-        std::string perturbation_position;
-
-        /*
-         * Deviation from adiabaticity in a subadiabatic mantle
-         * temperature profile. 0 for an adiabatic temperature
-         * profile.
-         */
-        double subadiabaticity;
-
-        /**
-         * Age model to use for the top boundary layer.
-         */
-        BoundaryLayerAgeModel::Kind top_boundary_layer_age_model;
-
-        /*
-         * Whether to use the half space cooling model, or the plate cooling
-         * model
-         */
-        std::string cooling_model;
-
-        /*
-         * Depth to the base of the lithosphere for plate cooling model, in m
-         */
-        double lithosphere_thickness;
-
-        /**
-         * A function object representing the compositional fields that will
-         * be used as a reference profile for calculating the thermal
-         * diffusivity. The function depends only on depth.
-         */
-        std::unique_ptr<Functions::ParsedFunction<1>> function;
-
-        /**
-         * A function object representing the age of the top boundary layer.
-         */
-        Functions::ParsedFunction<dim> age_function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-
-        /**
-         * Compute the top boundary layer age at the given position.
-         */
-        double top_boundary_layer_age(const Point<dim> &position) const;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_temperature/adiabatic_boundary.h.bak b/include/aspect/initial_temperature/adiabatic_boundary.h.bak
deleted file mode 100644
index 02c6b0c5669..00000000000
--- a/include/aspect/initial_temperature/adiabatic_boundary.h.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-  Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_initial_temperature_adiabatic_boundary_h
-#define _aspect_initial_temperature_adiabatic_boundary_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that computes an initial temperature field based
-     * on a user-defined adiabatic boundary. It discretizes the model domain into
-     * two regions separated by an isotherm boundary below which
-     * the temperature increases adiabatically. Above the
-     * user-defined isotherm boundary the temperature linearly
-     * increases from a surface temperature (273.15 K or 0 degree C)
-     * to the isotherm (1673.15 K or 1400 degree C). The user
-     * defines the location of the isotherm boundary with an ascii
-     * data file with the format defined in the ASPECT manual.
-     *
-     * This plugin is developed by Tahiry Rajaonarison, Emmanuel Njinju, and D. Sarah Stamps.
-     */
-    template <int dim>
-    class AdiabaticBoundary : public Interface<dim>, public Utilities::AsciiDataBoundary<dim>
-    {
-      public:
-
-        /**
-         * Constructor.
-         */
-        AdiabaticBoundary ();
-
-        void initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataBoundary<dim>::initialize;
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters that this class needs.
-         */
-        static
-        void declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters above from the parameter file.
-         */
-        void parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        double isotherm_temperature;
-        double surface_temperature;
-        double temperature_gradient;
-        types::boundary_id surface_boundary_id;
-
-    };
-  }
-}
-#endif
diff --git a/include/aspect/initial_temperature/ascii_data.h.bak b/include/aspect/initial_temperature/ascii_data.h.bak
deleted file mode 100644
index e568cfe53ed..00000000000
--- a/include/aspect/initial_temperature/ascii_data.h.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_ascii_data_h
-#define _aspect_initial_temperature_ascii_data_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a prescribed temperature field determined from
-     * a AsciiData input file.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataInitial<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataInitial<dim>::initialize;
-
-        /**
-         * Return the boundary temperature as a function of position. For the
-         * current class, this function returns value from the text files.
-         */
-        double
-        initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_temperature/ascii_data_layered.h.bak b/include/aspect/initial_temperature/ascii_data_layered.h.bak
deleted file mode 100644
index ccb5157ab13..00000000000
--- a/include/aspect/initial_temperature/ascii_data_layered.h.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_ascii_data_layered_h
-#define _aspect_initial_temperature_ascii_data_layered_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements an initial temperature field determined from
-     * AsciiData input files. Each file defines an isotherm as a grid of points.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class AsciiDataLayered : public Utilities::AsciiDataLayered<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiDataLayered ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataLayered<dim>::initialize;
-
-        /**
-         * Return the initial temperature as a function of position. For the
-         * current class, this function returns value from the text files.
-         */
-        double
-        initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_temperature/ascii_profile.h.bak b/include/aspect/initial_temperature/ascii_profile.h.bak
deleted file mode 100644
index 337605de662..00000000000
--- a/include/aspect/initial_temperature/ascii_profile.h.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_ascii_profile_h
-#define _aspect_initial_temperature_ascii_profile_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/point.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a prescribed temperature field determined from
-     * a AsciiDataProfile input file.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class AsciiProfile : public Utilities::AsciiDataProfile<dim>, public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        AsciiProfile ();
-
-        /**
-         * Initialization function.
-         */
-        void initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataProfile<dim>::initialize;
-
-        /**
-         * Return the temperature at a given point of the domain.
-         */
-        double initial_temperature (const Point<dim> &p) const override;
-
-        /**
-         * Declare the parameters for the input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler  &prm);
-
-        /**
-         * Read the parameters from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * The column index of the temperature in the data file.
-         */
-        unsigned int temperature_index;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_temperature/box.h.bak b/include/aspect/initial_temperature/box.h.bak
deleted file mode 100644
index 7f9462e17d6..00000000000
--- a/include/aspect/initial_temperature/box.h.bak
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_box_h
-#define _aspect_initial_temperature_box_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes a perturbed initial temperature field for a box
-     * geometry.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class PerturbedBox : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-    };
-
-    /**
-     * A class that describes an opposing poles initial temperature field for
-     * a box geometry.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class PolarBox : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-    };
-
-    /**
-     * A field that describes a fractal initial temperature field
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class MandelBox : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-    };
-
-    /**
-     * A class that describes a shaped inclusion initial temperature field for
-     * a box geometry.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class InclusionShapeBox : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature(const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        std::string inclusion_shape;
-        std::string inclusion_gradient;
-        double radius;
-        double ambient_temperature;
-        double inclusion_temperature;
-        double center_x;
-        double center_y;
-        double center_z;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/initial_temperature/continental_geotherm.h.bak b/include/aspect/initial_temperature/continental_geotherm.h.bak
deleted file mode 100644
index ef4af29d0b4..00000000000
--- a/include/aspect/initial_temperature/continental_geotherm.h.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_initial_temperature_continental_geotherm_h
-#define _aspect_initial_temperature_continental_geotherm_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-
-    /**
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class ContinentalGeotherm : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        ContinentalGeotherm ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the initial temperature as a function of depth,
-         * based on the solution of the steady-state heat conduction
-         * differential equation.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Surface temperature
-         */
-        double T0;
-
-        /**
-         * Value of the isotherm defining the
-         * Lithosphere-Asthenosphere boundary.
-         */
-        double LAB_isotherm;
-
-        /**
-         * Vector for the thicknesses of the compositional fields
-         * representing the layers 'upper_crust', 'lower_crust' and 'lithospheric_mantle'.
-         */
-        std::vector<double> thicknesses;
-
-        /**
-         * Vector for the heat production rates of the different
-         * compositional fields, read from parameter file.
-         */
-        std::vector<double> heat_productivities;
-
-        /**
-         * Vector for the thermal conductivities of the different
-         * compositional fields, read from parameter file.
-         */
-        std::vector<double> conductivities;
-
-        /**
-         * Vector for the densities of the different compositional
-         * fields, read from parameter file.
-         */
-        std::vector<double> densities;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_temperature/function.h.bak b/include/aspect/initial_temperature/function.h.bak
deleted file mode 100644
index 65f9891f69b..00000000000
--- a/include/aspect/initial_temperature/function.h.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_function_h
-#define _aspect_initial_temperature_function_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements temperature initial conditions based on a
-     * functional description provided in the input file.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Function ();
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the temperature.
-         */
-        Functions::ParsedFunction<dim> function;
-
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_temperature/harmonic_perturbation.h.bak b/include/aspect/initial_temperature/harmonic_perturbation.h.bak
deleted file mode 100644
index ae58ff944c6..00000000000
--- a/include/aspect/initial_temperature/harmonic_perturbation.h.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_harmonic_perturbation_h
-#define _aspect_initial_temperature_harmonic_perturbation_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes a perturbed initially constant temperature field
-     * for any geometry model or dimension in shape of a harmonic function.
-     * For 3D spherical shell models this is achieved by using spherical
-     * harmonics, in any other case sine function are scaled to fit the model
-     * geometry.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class HarmonicPerturbation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-      private:
-
-        /**
-         * The radial/depth wave number of the harmonic perturbation. All wave
-         * number variables are in fact twice the wave number in a
-         * mathematical sense. This allows the user to prescribe a single
-         * up-/downswing or half periods.
-         */
-        int vertical_wave_number;
-
-        /**
-         * The lateral wave number  of the harmonic perturbation in the first
-         * dimension. This is the only lateral wave number in 2D and equals
-         * the degree of the spherical harmonics in a 3D spherical shell.
-         */
-        int lateral_wave_number_1;
-
-        /**
-         * The lateral wave number of the harmonic perturbation in the second
-         * dimension. This is not used in 2D and equals the order of the
-         * spherical harmonics in a 3D spherical shell.
-         */
-        int lateral_wave_number_2;
-
-        /**
-         * The maximal magnitude of the harmonic perturbation.
-         */
-        double magnitude;
-
-        /**
-         * The background temperature the harmonic perturbation is applied on
-         * in an incompressible material model. In case of a compressible
-         * material model the perturbation is applied on top of an adiabatic
-         * profile and this variable is not used at all.
-         */
-        double reference_temperature;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/initial_temperature/interface.h.bak b/include/aspect/initial_temperature/interface.h.bak
deleted file mode 100644
index 9b726ab4f4d..00000000000
--- a/include/aspect/initial_temperature/interface.h.bak
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_interface_h
-#define _aspect_initial_temperature_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/point.h>
-#include <deal.II/base/parameter_handler.h>
-
-#include <boost/core/demangle.hpp>
-#include <typeinfo>
-
-
-namespace aspect
-{
-  template <int dim> class SimulatorAccess;
-
-  /**
-   * A namespace in which we define everything that has to do with defining
-   * the initial conditions.
-   *
-   * @ingroup InitialTemperatures
-   */
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A base class for parameterizations of initial conditions.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        virtual
-        double initial_temperature (const Point<dim> &position) const = 0;
-    };
-
-
-    /**
-     * A class that manages all initial condition objects.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Destructor. Made virtual since this class has virtual member
-         * functions.
-         */
-        ~Manager () override;
-
-        /**
-         * Update function. Called once at the beginning of a timestep to
-         * update all plugin objects.
-        */
-        void
-        update() override;
-
-        /**
-         * Declare the parameters of all known initial conditions plugins, as
-         * well as of ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which initial conditions objects will be created; then
-         * let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * A function that calls the initial_temperature functions of all the
-         * individual initial condition objects and adds up the values of the
-         * individual calls.
-         */
-        double
-        initial_temperature (const Point<dim> &position) const;
-
-        /**
-         * A function that is used to register initial temperature objects in such
-         * a way that the Manager can deal with all of them without having to
-         * know them by name. This allows the files in which individual
-         * plugins are implemented to register these plugins, rather than also
-         * having to modify the Manager class by adding the new initial
-         * temperature plugin class.
-         *
-         * @param name A string that identifies the initial temperature model
-         * @param description A text description of what this model does and that
-         * will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that can be
-         * used to declare the parameters that this initial temperature model
-         * wants to read from input files.
-         * @param factory_function A pointer to a function that can create an
-         * object of this initial temperature model.
-         */
-        static
-        void
-        register_initial_temperature (const std::string &name,
-                                      const std::string &description,
-                                      void (*declare_parameters_function) (ParameterHandler &),
-                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-
-        /**
-         * Return a list of names of all initial temperature models currently
-         * used in the computation, as specified in the input file.
-         */
-        const std::vector<std::string> &
-        get_active_initial_temperature_names () const;
-
-        /**
-         * Return a list of pointers to all initial temperature models
-         * currently used in the computation, as specified in the input file.
-         */
-        const std::list<std::unique_ptr<Interface<dim>>> &
-        get_active_initial_temperature_conditions () const;
-
-        /**
-         * Go through the list of all initial temperature models that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename InitialTemperatureType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,InitialTemperatureType>::value>>
-        bool
-        has_matching_initial_temperature_model () const;
-
-        /**
-         * Go through the list of all initial temperature models that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no initial temperature model is active that matches the given type,
-         * throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename InitialTemperatureType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,InitialTemperatureType>::value>>
-        const InitialTemperatureType &
-        get_matching_initial_temperature_model () const;
-
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcInitialTemperatureNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered initial temperature objects.");
-      private:
-        /**
-         * A list of names of initial temperature objects that have been requested
-         * in the parameter file.
-         */
-        std::vector<std::string> model_names;
-
-        /**
-         * A list of enums of initial temperature operators that have been
-         * requested in the parameter file. Each entry is used to modify the
-         * initial temperature field with the values from the associated plugin
-         * in model_names.
-         */
-        std::vector<aspect::Utilities::Operator> model_operators;
-    };
-
-
-
-    template <int dim>
-    template <typename InitialTemperatureType, typename>
-    inline
-    bool
-    Manager<dim>::has_matching_initial_temperature_model () const
-    {
-      return this->template has_matching_plugin_object<InitialTemperatureType>();
-    }
-
-
-    template <int dim>
-    template <typename InitialTemperatureType, typename>
-    inline
-    const InitialTemperatureType &
-    Manager<dim>::get_matching_initial_temperature_model () const
-    {
-      return this->template get_matching_plugin_object<InitialTemperatureType>();
-    }
-
-
-    /**
-     * Return a string that consists of the names of initial temperature models that can
-     * be selected. These names are separated by a vertical line '|' so
-     * that the string can be an input to the deal.II classes
-     * Patterns::Selection or Patterns::MultipleSelection.
-     */
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ();
-
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a initial conditions model, register it with the functions that can
-     * declare their parameters and create these objects.
-     *
-     * @ingroup InitialTemperatures
-     */
-#define ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::InitialTemperature::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::InitialTemperature::Manager<2>::register_initial_temperature, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::InitialTemperature::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::InitialTemperature::Manager<3>::register_initial_temperature, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_temperature/lithosphere_mask.h.bak b/include/aspect/initial_temperature/lithosphere_mask.h.bak
deleted file mode 100644
index db5442d0efa..00000000000
--- a/include/aspect/initial_temperature/lithosphere_mask.h.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_lithosphere_mask_h
-#define _aspect_initial_temperature_lithosphere_mask_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    namespace LABDepth
-    {
-      template <int dim>
-      class LABDepthLookup : public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Empty Constructor.
-           */
-          LABDepthLookup ();
-
-          /**
-           * Initialization function. This function is called once at the
-           * beginning of the program. Checks preconditions.
-           */
-          void
-          initialize ();
-
-          /**
-           * Return LAB depth as a function of position (latitude and longitude). This
-           * function returns either a constant value or values from a text file,
-           * depending on the input parameters. Text files are read in
-           * two dimensions so the third column (depth) is treated as data.
-           */
-          double
-          get_lab_depth (const Point<dim> &position) const;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-        private:
-          /**
-           * Reads in file containing input data.
-           */
-          Utilities::StructuredDataLookup<2> lab_depths;
-
-          /**
-           * Directory in which the LAB depth file is present.
-           */
-          std::string data_directory;
-
-          /**
-           * File name of the LAB depth file.
-           */
-          std::string LAB_file_name;
-
-          /**
-           * An enum to describe where the LAB depth is coming from.
-           */
-          enum LABDepthSource
-          {
-            Value,
-            File
-          };
-
-          /**
-           * Currently chosen source for the LAB depth.
-           */
-          LABDepthSource LAB_depth_source;
-
-          /**
-           * This parameter gives the maximum depth of the lithosphere. The
-           * model returns nans below this depth. This parameter is only used if LAB
-           * depth source is set to 'Value'.
-           */
-          double max_depth;
-      };
-    }
-
-    /**
-     * A class that implements a constant reference temperature
-     * above a specified depth and nans below the specified depth.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class LithosphereMask : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the initial temperature as a function of position. For the
-         * current class, this function uses the given lithosphere temperature
-         * above the lithosphere-asthenosphere boundary and nans below.
-         */
-        double
-        initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * This parameter gives the initial temperature set within the lithosphere.
-         */
-        double lithosphere_temperature;
-
-        /**
-         *
-         */
-        LABDepth::LABDepthLookup<dim> lab_depth_lookup;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/initial_temperature/patch_on_S40RTS.h.bak b/include/aspect/initial_temperature/patch_on_S40RTS.h.bak
deleted file mode 100644
index 45b26fdf57d..00000000000
--- a/include/aspect/initial_temperature/patch_on_S40RTS.h.bak
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_patch_on_S40RTS_h
-#define _aspect_initial_temperature_patch_on_S40RTS_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/initial_temperature/S40RTS_perturbation.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a prescribed temperature field determined from
-     * an upper mantle Vs model (input as an ascii file) above a specified depth
-     * and S40RTS below the specified depth.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class PatchOnS40RTS : public Utilities::AsciiDataInitial<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        PatchOnS40RTS ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataInitial<dim>::initialize;
-
-        /**
-         * Return Vs as a function of position. For the
-         * current class, this function returns value from the text files.
-         */
-        double
-        ascii_grid_vs (const Point<dim> &position) const;
-
-        /**
-         * This parameter gives the maximum depth of the Vs ascii grid. The
-         * model will read in Vs from S40RTS below this depth.
-         */
-        double max_grid_depth;
-
-        /**
-         * This parameter gives the range (above maximum grid depth) over which to smooth.
-         * Smoothing is done with a depth weighted combination of the values in the ascii grid and S40RTS
-         * at each point.
-         */
-        double smoothing_length_scale;
-
-        /**
-         * Return the initial temperature as a function of position. For the
-         * current class, this function calculates temperature from ascii grid Vs data
-         * above max_grid_depth and S40RTS Vs data below max_grid_depth.
-         */
-        double
-        initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Declare a member variable of type S40RTSPerturbation that allows us to call
-         * functions from S40RTS_perturbation.cc.
-         */
-        S40RTSPerturbation<dim> s40rts;
-
-        /**
-         * This parameter is the depth down to which shear wave perturbations are
-         * zeroed out.
-         */
-        double no_perturbation_depth_patch;
-
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_temperature/prescribed_temperature.h.bak b/include/aspect/initial_temperature/prescribed_temperature.h.bak
deleted file mode 100644
index d117b3cf8a6..00000000000
--- a/include/aspect/initial_temperature/prescribed_temperature.h.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
-  Copyright (C) 2012 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_prescribed_temperature_h
-#define _aspect_initial_prescribed_temperature_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class sets the initial temperature to the precribed temperature
-     * outputs computed by the material model.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class PrescribedTemperature : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run.
-         *
-         * This specific function makes sure that the objects that describe
-         * initial conditions remain available throughout the run of the
-         * program.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-      private:
-        /**
-         * A shared pointer to the initial composition object
-         * that ensures that the current object can continue
-         * to access the initial composition object beyond the
-         * first time step.
-         */
-        std::shared_ptr<const aspect::InitialComposition::Manager<dim>> initial_composition;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/initial_temperature/random_gaussian_perturbation.h.bak b/include/aspect/initial_temperature/random_gaussian_perturbation.h.bak
deleted file mode 100644
index bbc9df3bfa6..00000000000
--- a/include/aspect/initial_temperature/random_gaussian_perturbation.h.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_random_gaussian_perturbation_h
-#define _aspect_initial_temperature_random_gaussian_perturbation_h
-
-#include <aspect/initial_temperature/interface.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes a perturbation to a zero temperature field
-     * by placing several Gaussians with a given magnitude and width at
-     * random locations throughout the model domain.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class RandomGaussianPerturbation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program and computes the locations and
-         * magnitudes of all perturbations.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-      private:
-
-        /**
-         * The number of the random Gaussian perturbations.
-         */
-        unsigned int n_perturbations;
-
-        /**
-         * The maximal magnitude of the random Gaussian perturbations.
-         */
-        double max_magnitude;
-
-        /**
-         * The width of the random Gaussian perturbations.
-         */
-        double width;
-
-        /**
-         * Vectors that store all (random) locations and magnitudes of
-         * the perturbations.
-         */
-        std::vector<Point<dim>> perturbation_centers;
-        std::vector<double> perturbation_magnitudes;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/initial_temperature/spherical_shell.h.bak b/include/aspect/initial_temperature/spherical_shell.h.bak
deleted file mode 100644
index 8f620e24532..00000000000
--- a/include/aspect/initial_temperature/spherical_shell.h.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_initial_temperature_spherical_shell_h
-#define _aspect_initial_temperature_spherical_shell_h
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that describes a perturbed initial temperature field for the
-     * spherical shell.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class SphericalHexagonalPerturbation : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The angular mode is the number of perturbations to apply to the
-         * spherical shell. Historically, this was permanently set to 6 (hence
-         * the class name SphericalHexagonalPerturbation) The default is 6 in
-         * order to provide backwards compatibility.
-         */
-        unsigned int angular_mode;
-
-        /**
-         * The rotation offset describes the number of degrees to rotate the
-         * perturbation counterclockwise. Setting the rotation offset to 0
-         * will cause one of the perturbations to point north/up. Rotation
-         * offset is set to -45 degrees by default in order to provide
-         * backwards compatibility.
-         */
-        double rotation_offset;
-
-        /**
-         * Outer radius.
-         */
-        double R1;
-
-    };
-
-
-    /**
-     * A class that describes a perturbed initial temperature field for the
-     * spherical shell.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class SphericalGaussianPerturbation : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Constructor.
-         */
-        SphericalGaussianPerturbation();
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        double angle;
-        double depth;
-        double amplitude;
-        double sigma;
-        double sign;
-        unsigned int npoint;
-
-        std::vector<double> radial_position;
-        std::vector<double> geotherm;
-
-        /**
-         * Inner radius.
-         */
-        double R0;
-
-        /**
-         * Outer radius.
-         */
-        double R1;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/initial_temperature/world_builder.h.bak b/include/aspect/initial_temperature/world_builder.h.bak
deleted file mode 100644
index b275e2e5388..00000000000
--- a/include/aspect/initial_temperature/world_builder.h.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_initial_temperature_world_builder_h
-#define _aspect_initial_temperature_world_builder_h
-
-#include <aspect/global.h>
-
-#ifdef ASPECT_WITH_WORLD_BUILDER
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace WorldBuilder
-{
-  class World;
-}
-
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements temperature initial conditions based on a
-     * functional description provided in the input file through the
-     * World builder.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class WorldBuilder : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        WorldBuilder ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run and after
-         * the SimulatorAccess (if applicable) is initialized.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-      private:
-        /**
-         * A pointer to the WorldBuilder object. Keeping this pointer ensures
-         * that the object doesn't go away while we still need it.
-         */
-        std::shared_ptr<const ::WorldBuilder::World> world_builder;
-    };
-  }
-}
-
-#endif
-#endif
diff --git a/include/aspect/introspection.h.bak b/include/aspect/introspection.h.bak
deleted file mode 100644
index 9ce0167be3a..00000000000
--- a/include/aspect/introspection.h.bak
+++ /dev/null
@@ -1,676 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_introspection_h
-#define _aspect_introspection_h
-
-#include <deal.II/base/index_set.h>
-#include <deal.II/base/quadrature.h>
-#include <deal.II/fe/component_mask.h>
-#include <deal.II/fe/fe_values_extractors.h>
-#include <deal.II/fe/fe.h>
-
-#include <aspect/fe_variable_collection.h>
-#include <aspect/parameters.h>
-
-#include <map>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  /**
-   * Helper function to construct the default list of variables to use
-   * based on the given set of @p parameters.
-   */
-  template <int dim>
-  std::vector<VariableDeclaration<dim>>
-  construct_default_variables (const Parameters<dim> &parameters);
-
-
-  /**
-   * A data structure containing a description of each compositional field.
-   * At present, this structure only includes the field type
-   * (i.e., whether it is of type chemical composition, porosity, etc.).
-   */
-  struct CompositionalFieldDescription
-  {
-    /**
-     * This enum lists available compositional field types.
-     */
-    enum Type
-    {
-      chemical_composition = 0,
-      stress = 1,
-      strain = 2,
-      grain_size = 3,
-      porosity = 4,
-      density = 5,
-      entropy = 6,
-      generic = 7,
-      unspecified = 8
-    } type;
-
-    /**
-     * The number of different types defined in Type.
-    */
-    constexpr static unsigned int n_types = 9;
-
-    /**
-     * This function translates an input string into the
-     * available enum options for the type of compositional field.
-     */
-    static
-    Type
-    parse_type(const std::string &input)
-    {
-      if (input == "chemical composition")
-        return CompositionalFieldDescription::chemical_composition;
-      else if (input == "stress")
-        return CompositionalFieldDescription::stress;
-      else if (input == "strain")
-        return CompositionalFieldDescription::strain;
-      else if (input == "grain size")
-        return CompositionalFieldDescription::grain_size;
-      else if (input == "porosity")
-        return CompositionalFieldDescription::porosity;
-      else if (input == "density")
-        return CompositionalFieldDescription::density;
-      else if (input == "entropy")
-        return CompositionalFieldDescription::entropy;
-      else if (input == "generic")
-        return CompositionalFieldDescription::generic;
-      else if (input == "unspecified")
-        return CompositionalFieldDescription::unspecified;
-      else
-        AssertThrow(false, ExcNotImplemented());
-
-      return CompositionalFieldDescription::Type();
-    }
-  };
-
-  /**
-   * The introspection class provides information about the simulation as a
-   * whole. In particular, it provides symbolic names for things like the
-   * velocity, pressure and other variables, along with their corresponding
-   * vector and scalar FEValues extractors, component masks, etc.
-   *
-   * The purpose of this class is primarily to provide these symbolic names so
-   * that we do not have to use implicit knowledge about the ordering of
-   * variables (e.g., earlier versions of ASPECT had many places where we
-   * built a scalar FEValues extractor at component 'dim' since that is where
-   * we knew that the pressure lies in the finite element; this kind of
-   * implicit knowledge is no longer necessary with the Introspection class).
-   * The Introspection class is used both by the Simulator class itself, but
-   * is also exported to plugins via the SimulatorAccess class.
-   *
-   * @ingroup Simulator
-   */
-  template <int dim>
-  struct Introspection: public FEVariableCollection<dim>
-  {
-    public:
-      /**
-       * Constructor.
-       */
-      Introspection (const std::vector<VariableDeclaration<dim>> &variables,
-                     const Parameters<dim> &parameters);
-
-      /**
-       * Destructor.
-       */
-      ~Introspection ();
-
-
-
-      /**
-       * @name Things that are independent of the current mesh
-       * @{
-       */
-
-      /**
-       * The number of vector components used by the finite element
-       * description of this problem. It equals $d+2+n_c$ where $d$ is the
-       * dimension and equals the number of velocity components, and $n_c$ is
-       * the number of advected (compositional) fields. The remaining
-       * components are the scalar pressure and temperature fields.
-       */
-      const unsigned int n_components;
-
-      /**
-       * The number of compositional fields.
-       */
-      const unsigned int n_compositional_fields;
-
-      /**
-       * A variable that holds whether the temperature field should use a
-       * discontinuous discretization.
-       */
-      const bool use_discontinuous_temperature_discretization;
-
-      /**
-       * A variable that holds whether the composition field(s) should use a
-       * discontinuous discretization.
-       */
-      const std::vector<bool> use_discontinuous_composition_discretization;
-
-      /**
-       * A structure that enumerates the vector components of the finite
-       * element that correspond to each of the variables in this problem.
-       */
-      struct ComponentIndices
-      {
-        unsigned int       velocities[dim];
-        unsigned int       pressure;
-        unsigned int       temperature;
-        std::vector<unsigned int> compositional_fields;
-      };
-      /**
-       * A variable that enumerates the vector components of the finite
-       * element that correspond to each of the variables in this problem.
-       */
-      const ComponentIndices component_indices;
-
-      /**
-       * The number of vector blocks. This equals $3+n_c$ where, in comparison
-       * to the n_components field, the velocity components form a single
-       * block.
-       */
-      const unsigned int n_blocks;
-
-      /**
-       * A structure that enumerates the vector blocks of the finite element
-       * that correspond to each of the variables in this problem.
-       */
-      struct BlockIndices
-      {
-        unsigned int       velocities;
-        unsigned int       pressure;
-        unsigned int       temperature;
-        std::vector<unsigned int> compositional_fields;
-
-        /**
-         * This variable contains the block for each compositional field
-         * where the matrix/sparsity pattern is copied from when we need to
-         * (temporarily) create a matrix. This way, we only need to store a
-         * single sparsity pattern and reuse it for all compositional fields
-         * (assuming they have an identical FiniteElement).
-         */
-        std::vector<unsigned int> compositional_field_sparsity_pattern;
-      };
-
-      /**
-       * A variable that enumerates the vector blocks of the finite element
-       * that correspond to each of the variables in this problem.
-       */
-      const BlockIndices block_indices;
-
-      /**
-       * A structure that contains FEValues extractors for every block of the
-       * finite element used in the overall description.
-       */
-      struct Extractors
-      {
-        Extractors (const ComponentIndices &component_indices);
-
-        const FEValuesExtractors::Vector              velocities;
-        const FEValuesExtractors::Scalar              pressure;
-        const FEValuesExtractors::Scalar              temperature;
-        const std::vector<FEValuesExtractors::Scalar> compositional_fields;
-      };
-
-      /**
-       * A variable that contains extractors for every block of the finite
-       * element used in the overall description.
-       */
-      const Extractors extractors;
-
-      /**
-       * A structure that enumerates the base elements of the finite element
-       * that correspond to each of the variables in this problem.
-       *
-       * The indices here can be used to access the dealii::FiniteElement
-       * that describes the given variable. We support different finite
-       * elements for compositional fields, but we try to reuse the same
-       * element if possible.
-       */
-      struct BaseElements
-      {
-        unsigned int              velocities;
-        unsigned int              pressure;
-        unsigned int              temperature;
-        std::vector<unsigned int> compositional_fields;
-      };
-
-      /**
-       * A variable that enumerates the base elements of the finite element
-       * that correspond to each of the variables in this problem.
-       */
-      const BaseElements base_elements;
-
-      /**
-       * A structure that contains the polynomial degree of the finite element
-       * that correspond to each of the variables in this problem.
-       *
-       * If there are compositional fields, they are all discretized with the
-       * same polynomial degree and, consequently, we only need a single integer.
-       */
-      struct PolynomialDegree
-      {
-        unsigned int       velocities;
-        unsigned int       temperature;
-        unsigned int       compositional_fields;
-      };
-
-      /**
-       * A variable that enumerates the polynomial degree of the finite element
-       * that correspond to each of the variables in this problem.
-       */
-      const PolynomialDegree polynomial_degree;
-
-      /**
-       * A structure that contains appropriate quadrature formulas for the
-       * finite elements that correspond to each of the variables in this problem,
-       * as well as for the complete system (the `system` variable).
-       *
-       * If there are compositional fields, they are all discretized with the
-       * same polynomial degree and, consequently, we only need a single formula.
-       *
-       * The quadrature formulas provided here are chosen such that the
-       * compute integrals with sufficient accuracy. For hypercube cells,
-       * this means in particular that they are of Gauss type with a
-       * number of Gauss points per coordinate direction that is one larger than
-       * the polynomial degree of the finite element per direction. For
-       * example, when using quadratic elements for the velocity, the
-       * corresponding quadrature formula will have three Gauss points per
-       * direction. If the mesh is based on triangles or tetrahedra, the
-       * quadrature formula is not of tensor-product Gauss type, but the
-       * corresponding analog for simplex cells.
-       */
-      struct Quadratures
-      {
-        Quadrature<dim>       velocities;
-        Quadrature<dim>       pressure;
-        Quadrature<dim>       temperature;
-        Quadrature<dim>       compositional_fields;
-        Quadrature<dim>       system;
-      };
-
-      /**
-       * A variable that enumerates the polynomial degree of the finite element
-       * that correspond to each of the variables in this problem.
-       */
-      const Quadratures quadratures;
-
-      /**
-       * A structure that contains appropriate face quadrature formulas for the
-       * finite elements that correspond to each of the variables in this problem,
-       * as well as for the complete system (the `system` variable).
-       *
-       * This structure corresponds to the Quadratures structure above, but for
-       * face integration.
-       */
-      struct FaceQuadratures
-      {
-        Quadrature<dim-1>       velocities;
-        Quadrature<dim-1>       pressure;
-        Quadrature<dim-1>       temperature;
-        Quadrature<dim-1>       compositional_fields;
-        Quadrature<dim-1>       system;
-      };
-
-      /**
-       * A variable that enumerates the polynomial degree of the finite element
-       * that correspond to each of the variables in this problem.
-       */
-      const FaceQuadratures face_quadratures;
-
-      /**
-       * A structure that contains component masks for each of the variables
-       * in this problem. Component masks are a deal.II concept, see the
-       * deal.II glossary.
-       */
-      struct ComponentMasks
-      {
-        ComponentMasks (const FEVariableCollection<dim> &fevs, const Introspection<dim>::ComponentIndices &indices);
-
-        ComponentMask              velocities;
-        ComponentMask              pressure;
-        ComponentMask              temperature;
-        std::vector<ComponentMask> compositional_fields;
-      };
-
-      /**
-       * A variable that contains component masks for each of the variables in
-       * this problem. Component masks are a deal.II concept, see the deal.II
-       * glossary.
-       */
-      const ComponentMasks component_masks;
-
-      /**
-       * @}
-       */
-
-      /**
-       * @name Things that depend on the current mesh
-       * @{
-       */
-      /**
-       * A variable that describes how many of the degrees of freedom on the
-       * current mesh belong to each of the n_blocks blocks of the finite
-       * element.
-       */
-      std::vector<types::global_dof_index> system_dofs_per_block;
-
-      /**
-       * A structure that contains index sets describing which of the globally
-       * enumerated degrees of freedom are owned by or are relevant to the
-       * current processor in a parallel computation.
-       */
-      struct IndexSets
-      {
-        /**
-         * An index set that indicates which (among all) degrees of freedom
-         * are relevant to the current processor. See the deal.II
-         * documentation for the definition of the term "locally relevant
-         * degrees of freedom".
-         */
-        IndexSet system_relevant_set;
-
-        /**
-         * A collection of index sets that for each of the vector blocks of
-         * this finite element represents the global indices of the degrees of
-         * freedom owned by this processor. The n_blocks elements of this
-         * array form a mutually exclusive decomposition of the index set
-         * containing all locally owned degrees of freedom.
-         */
-        std::vector<IndexSet> system_partitioning;
-
-        /**
-         * A collection of index sets that for each of the vector blocks of
-         * this finite element represents the global indices of the degrees of
-         * freedom are relevant to this processor. The n_blocks elements of
-         * this array form a mutually exclusive decomposition of the index set
-         * containing all locally relevant degrees of freedom, i.e., of the
-         * system_relevant_set index set.
-         */
-        std::vector<IndexSet> system_relevant_partitioning;
-
-        /**
-         * A collection of index sets for each vector block of the Stokes
-         * system (velocity and pressure). This variable contains the first
-         * two elements of system_partitioning.
-         */
-        std::vector<IndexSet> stokes_partitioning;
-
-        /**
-         * Pressure unknowns that are locally owned. This IndexSet is needed
-         * if velocity and pressure end up in the same block and is used for
-         * pressure scaling and in make_pressure_rhs_compatible(). If melt
-         * transport is enabled, this field is unused and not filled.
-         */
-        IndexSet locally_owned_pressure_dofs;
-
-        /**
-         * Fluid and compaction pressure unknowns that are locally owned. Only
-         * valid if melt transport is enabled.
-         */
-        IndexSet locally_owned_melt_pressure_dofs;
-
-        /**
-         * Fluid pressure unknowns that are locally owned. Only valid if melt
-         * transport is enabled.
-         */
-        IndexSet locally_owned_fluid_pressure_dofs;
-      };
-
-      /**
-       * A variable that contains index sets describing which of the globally
-       * enumerated degrees of freedom are owned by the current processor in a
-       * parallel computation.
-       */
-      IndexSets index_sets;
-
-      /**
-       * A variable that contains the field method for the temperature field
-       * and is used to determine how to solve it when solving a timestep.
-       */
-      typename Parameters<dim>::AdvectionFieldMethod::Kind temperature_method;
-
-      /**
-       * A vector that contains a field method for every compositional
-       * field and is used to determine how to solve a particular field when
-       * solving a timestep.
-       */
-      std::vector<typename Parameters<dim>::AdvectionFieldMethod::Kind> compositional_field_methods;
-
-      /**
-       * @}
-       */
-
-      /**
-       * Return a vector that contains the base element indices of the deal.II FiniteElement
-       * that are used for compositional fields. Note that compositional fields can share the
-       * same base element, so this vector can (and usually will) be smaller than the number
-       * of compositional fields. The function get_compositional_field_indices_with_base_element()
-       * can be used to translate from base element index to all compositional field indices
-       * using the specified base element.
-       * If several fields are the finite element type (same degree and both continuous or both
-       * discontinuous), they share base elements. If you have no compositional fields, the
-       * vector returned has length 0. If all compositional fields have the same finite element
-       * space, the length is 1.
-       */
-      const std::vector<unsigned int> &
-      get_composition_base_element_indices() const;
-
-      /**
-       * Return a vector with all compositional field indices that belong to a given
-       * base element index as returned by get_composition_base_element_indices().
-       * The indices returned are therefore between 0 and n_compositional_fields-1.
-       * If you have a single compositional field, this function returns {0} when passing
-       * in base_element_index=0.
-       */
-      const std::vector<unsigned int> &
-      get_compositional_field_indices_with_base_element(const unsigned int base_element_index) const;
-
-      /**
-       * A function that gets the name of a compositional field as an input
-       * parameter and returns its index. If the name is not found, an
-       * exception is thrown.
-       *
-       * @param name The name of compositional field (as specified in the
-       * input file)
-       */
-      unsigned int
-      compositional_index_for_name (const std::string &name) const;
-
-      /**
-       * A function that gets the index of a compositional field as an input
-       * parameter and returns its name.
-       *
-       * @param index The index of compositional field
-       */
-      std::string
-      name_for_compositional_index (const unsigned int index) const;
-
-      /**
-       * A function that returns the full list of compositional field names.
-       */
-      const std::vector<std::string> &
-      get_composition_names () const;
-
-      /**
-       * A function that returns the full vector of compositional
-       * field descriptions.
-       */
-      const std::vector<CompositionalFieldDescription> &
-      get_composition_descriptions () const;
-
-      /**
-       * A function that returns the names of
-       * compositional fields that correspond to chemical compositions.
-       *
-       * This function is shorthand for
-       * get_names_for_fields_of_type(CompositionalFieldDescription::chemical_composition).
-       */
-      const std::vector<std::string> &
-      chemical_composition_field_names () const;
-
-      /**
-       * A function that returns the indices of
-       * compositional fields that correspond to chemical compositions.
-       *
-       * This function is shorthand for
-       * get_indices_for_fields_of_type(CompositionalFieldDescription::chemical_composition).
-       */
-      const std::vector<unsigned int> &
-      chemical_composition_field_indices () const;
-
-      /**
-       * A function that returns the number of
-       * compositional fields that correspond to chemical compositions.
-       *
-       * This function is shorthand for
-       * get_number_of_fields_of_type(CompositionalFieldDescription::chemical_composition).
-       */
-      unsigned int
-      n_chemical_composition_fields () const;
-
-      /**
-       * A function that gets the type of a compositional field as an input
-       * parameter and returns if any compositional field of that type is
-       * used in this simulation.
-       *
-       * @param type The type of compositional field (as specified in the
-       * input file)
-       */
-      bool
-      composition_type_exists (const CompositionalFieldDescription::Type &type) const;
-
-      /**
-       * A function that gets the type of a compositional field as an input
-       * parameter and returns the index of the first compositional field of
-       * this type used in this simulation. If no such field is found, the
-       * function returns the number of compositional fields.
-       *
-       * @param type The type of compositional field (as specified in the
-       * input file)
-       */
-      unsigned int
-      find_composition_type (const CompositionalFieldDescription::Type &type) const;
-
-      /**
-       * A function that gets the name of a compositional field as an input
-       * parameter and returns if the compositional field is used in this
-       * simulation.
-       *
-       * @param name The name of compositional field (as specified in the
-       * input file)
-       */
-      bool
-      compositional_name_exists (const std::string &name) const;
-
-      /**
-       * Get the indices of the compositional fields which are of a
-       * particular type (chemical composition, porosity, etc.).
-       */
-      const std::vector<unsigned int> &
-      get_indices_for_fields_of_type (const CompositionalFieldDescription::Type &type) const;
-
-      /**
-       * Get the names of the compositional fields which are of a
-       * particular type (chemical composition, porosity, etc.).
-       */
-      const std::vector<std::string> &
-      get_names_for_fields_of_type (const CompositionalFieldDescription::Type &type) const;
-
-      /**
-       * Get the number of compositional fields which are of a
-       * particular type (chemical composition, porosity, etc.).
-       */
-      unsigned int
-      get_number_of_fields_of_type (const CompositionalFieldDescription::Type &type) const;
-
-      /**
-       * A function that gets a component index as an input
-       * parameter and returns if the component is one of the stokes system
-       * (i.e. if it is the pressure or one of the velocity components).
-       *
-       * @param component_index The component index to check.
-       */
-      bool
-      is_stokes_component (const unsigned int component_index) const;
-
-      /**
-       * A function that gets a component index as an input
-       * parameter and returns if the component is one of the
-       * compositional fields.
-       *
-       * @param component_index The component index to check.
-       */
-      bool
-      is_composition_component (const unsigned int component_index) const;
-
-    private:
-      /**
-       * A vector that stores the names of the compositional fields that will
-       * be used in the simulation.
-       */
-      std::vector<std::string> composition_names;
-
-      /**
-       * A vector that stores descriptions of each compositional field,
-       * including its type (i.e. whether the compositional field corresponds
-       * to chemical composition, porosity etc.).
-       */
-      std::vector<CompositionalFieldDescription> composition_descriptions;
-
-      /**
-       * A vector of vectors of composition names that stores the
-       * names of the compositional fields corresponding to each field type
-       * given in CompositionalFieldDescription.
-       */
-      std::vector<std::vector<std::string>> composition_names_for_type;
-
-      /**
-       * A vector of vectors of composition indices that stores the
-       * indices of the compositional fields corresponding to each field type
-       * given in CompositionalFieldDescription.
-       */
-      std::vector<std::vector<unsigned int>> composition_indices_for_type;
-
-      /**
-       * List of base element indices used by compositional fields. Cached
-       * result returned by get_composition_base_element_indices().
-       */
-      std::vector<unsigned int> composition_base_element_indices;
-
-      /**
-       * Map base_element_index to list of compositional field indices that use
-       * that base element. Cached result returned by
-       * get_compositional_field_indices_with_base_element();
-       */
-      std::map<unsigned int, std::vector<unsigned int>> compositional_field_indices_with_base_element;
-  };
-}
-
-
-#endif
diff --git a/include/aspect/lateral_averaging.h.bak b/include/aspect/lateral_averaging.h.bak
deleted file mode 100644
index d18d38a9a6c..00000000000
--- a/include/aspect/lateral_averaging.h.bak
+++ /dev/null
@@ -1,326 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_lateral_averaging_h
-#define _aspect_lateral_averaging_h
-
-#include <aspect/simulator_access.h>
-
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace internal
-  {
-    /**
-     * This is the base class for all the functors implemented. Each is
-     * used to compute one of the properties that will be laterally
-     * averaged. The point of the base class is to allow handing over
-     * a variable of type
-     * <code> std::vector<std::unique_ptr<FunctorBase<dim>>> </code> to the
-     * LateralAveraging::get_averages() function.
-     */
-    template <int dim>
-    class FunctorBase
-    {
-      public:
-        /**
-         * operator() will have @p in and @p out filled out if @p true. By default
-         * returns false.
-         */
-        virtual
-        bool
-        need_material_properties() const;
-
-        /**
-         * If this functor needs additional material model outputs create them
-         * in here. By default, this does nothing.
-         */
-        virtual
-        void
-        create_additional_material_model_outputs (const unsigned int n_points,
-                                                  MaterialModel::MaterialModelOutputs<dim> &outputs) const;
-
-        /**
-         * Called once at the beginning of compute_lateral_averages() to setup
-         * internal data structures with the number of quadrature points.
-         */
-        virtual
-        void
-        setup(const unsigned int q_points);
-
-        /**
-         * This takes @p in material model inputs and @p out outputs (which are filled
-         * if need_material_properties() == true), an initialized FEValues
-         * object for a cell, and the current solution vector as inputs.
-         * Functions in derived classes should then evaluate the desired quantity
-         * and return the results in the output vector, which is q_points long.
-         */
-        virtual
-        void
-        operator()(const MaterialModel::MaterialModelInputs<dim> &in,
-                   const MaterialModel::MaterialModelOutputs<dim> &out,
-                   const FEValues<dim> &fe_values,
-                   const LinearAlgebra::BlockVector &solution,
-                   std::vector<double> &output) = 0;
-
-        /**
-         * Provide an (empty) virtual destructor.
-         */
-        virtual
-        ~FunctorBase();
-    };
-  }
-
-  /**
-   * LateralAveraging is a class that performs various averaging operations
-   * on the solution.  The functions of this class take a vector as an argument.
-   * The model is divided into depth slices where the number of slices is the
-   * length of the output vector. Each function averages a specific quantity
-   * (as specified by their name), and that quantity is averaged laterally
-   * for each depth slice.
-   *
-   * Plugins may access the LateralAveraging plugin through the SimulatorAccess
-   * function get_lateral_averaging(), and then query that for the desired
-   * averaged quantity.
-   *
-   * @ingroup Simulator
-   */
-  template <int dim>
-  class LateralAveraging : public SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * @deprecated: This function is deprecated and only maintained for backward compatibility.
-       * Use the function compute_lateral_averages() with the same arguments instead.
-       */
-      DEAL_II_DEPRECATED
-      std::vector<std::vector<double>>
-      get_averages(const unsigned int n_slices,
-                   const std::vector<std::string> &property_names) const;
-
-      /**
-       * Return a depth profile of lateral averages of the selected
-       * @p property_names. This function is a convenience interface for
-       * the other functions of the same name and is more efficient for
-       * multiple properties than calling multiple of the single property functions
-       * sequentially. This version of the function creates @p n_slices
-       * equidistant depth slices to compute averages in.
-       *
-       * @param n_slices The number of equidistant depth slices
-       * to perform the averaging in.
-       * @param property_names Names of the available quantities to average.
-       * Check the implementation of this function for available names.
-       * @return The output vector of laterally averaged values. Each vector
-       * has the same size of @p n_slices, and there are
-       * as many vectors returned as names in @p property_names.
-       */
-      std::vector<std::vector<double>>
-      compute_lateral_averages(const unsigned int n_slices,
-                               const std::vector<std::string> &property_names) const;
-
-      /**
-       * Return a depth profile of lateral averages of the selected
-       * @p property_names. This function is a convenience interface for
-       * the other functions of the same name and is more efficient for
-       * multiple properties than calling multiple of the single property
-       * functions sequentially. This version of the function uses @p depth_bounds
-       * to determine the upper and lower boundary of each depth slice,
-       * and returns one averaged value per slice (= one less than the
-       * number of depth bounds).
-       *
-       * @param depth_bounds The boundaries of the depth slices to compute
-       * averages in. It is expected to be a vector of monotonically increasing
-       * depth values with consecutive entries representing the minimum and
-       * maximum depth of each depth slice. All depths smaller than
-       * entry 0 or larger than the last entry are ignored, and depths
-       * between entries 0 and 1 fall into depth slice 0, and so on.
-       * @param property_names Names of the available quantities to average.
-       * Check the implementation of this function for available names.
-       * @return The output vector of laterally averaged values. The length
-       * of each vector is one less than the number of @p depth_bounds,
-       * and there are as many vectors returned as names in @p property_names.
-       */
-      std::vector<std::vector<double>>
-      compute_lateral_averages(const std::vector<double> &depth_bounds,
-                               const std::vector<std::string> &property_names) const;
-
-      /**
-       * Return a depth profile of lateral averages. This function is the
-       * low-level implementation for the other functions of the same name
-       * and is more efficient for multiple properties than calling multiple
-       * of the single property functions sequentially. This version of the
-       * function uses @p depth_bounds to determine the upper and lower
-       * boundary of each depth slice, and returns one averaged value per slice
-       * (= one less than the number of depth bounds).
-       * The vector of functors @p functors must contain one or more
-       * objects of classes that are derived from FunctorBase and are used to
-       * fill the values vectors. All of the other functions in this class use
-       * this low-level implementation for the actual computation.
-       * Using this function allows to provide user-defined functors to average
-       * properties not already implemented (e.g. to average additional
-       * material model outputs).
-       *
-       * @param depth_bounds The boundaries of the depth slices to compute
-       * averages in. It is expected to be a vector of monotonically increasing
-       * depth values with consecutive entries representing the minimum and
-       * maximum depth of each depth slice. All depths smaller than
-       * entry 0 or larger than the last entry are ignored, and depths
-       * between entries 0 and 1 fall into depth slice 0, and so on.
-       * @param functors Instances of a class derived from FunctorBase
-       * that are used to compute the averaged properties.
-       * @return The output vectors of depth averaged values. The
-       * function returns one vector of doubles per property and uses
-       * @p depth_bounds to determine the depth extents of each slice.
-       * Each returned vector has the same size (one entry less than
-       * the number of @p depth_bounds).
-       */
-      std::vector<std::vector<double>>
-      compute_lateral_averages(const std::vector<double> &depth_bounds,
-                               std::vector<std::unique_ptr<internal::FunctorBase<dim>>> &functors) const;
-
-      /**
-       * Fill the argument with a set of lateral averages of the current
-       * temperature field. The function fills a vector that contains average
-       * field values over slices of the domain of same depth.
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_temperature_averages(std::vector<double> &values) const;
-
-      /**
-       * Fill the argument with a set of lateral averages of the current
-       * compositional fields.
-       *
-       * @param composition_index The index of the compositional field whose
-       * matrix we want to assemble (0 <= composition_index < number of
-       * compositional fields in this problem).
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_composition_averages(const unsigned int composition_index,
-                               std::vector<double> &values) const;
-
-      /**
-       * Compute a lateral average of the current viscosity.
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_viscosity_averages(std::vector<double> &values) const;
-
-      /**
-       * Compute a lateral average of the log10 of the current viscosity.
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_log_viscosity_averages(std::vector<double> &values) const;
-
-      /**
-       * Compute a lateral average of the current velocity magnitude.
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_velocity_magnitude_averages(std::vector<double> &values) const;
-
-      /**
-       * Compute a lateral average of the current sinking velocity.
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_sinking_velocity_averages(std::vector<double> &values) const;
-
-      /**
-       * Compute a lateral average of the current rising velocity.
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_rising_velocity_averages(std::vector<double> &values) const;
-
-      /**
-       * Compute a lateral average of the seismic shear wave speed: Vs.
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_Vs_averages(std::vector<double> &values) const;
-
-      /**
-       * Compute a lateral average of the seismic pressure wave speed: Vp.
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_Vp_averages(std::vector<double> &values) const;
-
-      /**
-       * Compute a lateral average of the vertical heat flux, with the sign
-       * convention of positive heat flux when it flows upwards.
-       *
-       * @param values The output vector of laterally averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void
-      get_vertical_heat_flux_averages(std::vector<double> &values) const;
-
-      /**
-       * Compute a lateral average of the vertical mass flux. Note that
-       * while get_vertical_heat_flux_averages() computes the average
-       * vertical heat flux (positive or negative), this function computes
-       * the average of the total mass flux through a certain layer
-       * (both down- and upward motion counted positively).
-       *
-       * @param values The output vector of laterally averaged values.
-       */
-      void
-      get_vertical_mass_flux_averages(std::vector<double> &values) const;
-  };
-}
-
-
-#endif
diff --git a/include/aspect/material_model/ascii_reference_profile.h.bak b/include/aspect/material_model/ascii_reference_profile.h.bak
deleted file mode 100644
index b04a689640c..00000000000
--- a/include/aspect/material_model/ascii_reference_profile.h.bak
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_model_ascii_reference_profile_h
-#define _aspect_model_ascii_reference_profile_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that reads in a reference profile from an ascii file
-     * and computes properties based on this profile.
-     *
-     * The viscosity is computed as
-     * \f[
-     * \eta(z,T) = \eta_r(z) \eta_0 \exp\left(-A \frac{T - T_\text{adi}}{T_\text{adi}}\right)."
-     * \f]
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class AsciiReferenceProfile : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize variables.
-         */
-        AsciiReferenceProfile ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run and after
-         * the SimulatorAccess (if applicable) is initialized.
-         */
-        void
-        initialize () override;
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-        /**
-         * Add the named outputs for seismic velocities.
-         */
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-      private:
-        /**
-         * Use truncated anelastic approximation?
-         */
-        bool tala;
-
-        /**
-         * The reference viscosity
-         */
-        double viscosity;
-
-        /**
-         * The constant $A$ in the temperature dependence of viscosity
-         * $\exp\left(-A \frac{T - T_\text{adi}}{T_\text{adi}}\right).$
-         */
-        double thermal_viscosity_exponent;
-
-        /**
-         * A list of constants that make up the piece-wise constant function
-         * $\eta_r(z)$, which determines the depth dependence of viscosity,
-         * and is multiplied with the reference viscosity and the
-         * temperature dependence to compute the viscosity $\eta(z,T)$.
-         */
-        std::vector<double> viscosity_prefactors;
-
-        /**
-         * A list of depths that determine the locations of the jumps in
-         * the piece-wise constant function $\eta_r(z)$, which describes the
-         * depth dependence of viscosity.
-         */
-        std::vector<double> transition_depths;
-
-        double thermal_conductivity;
-
-        /**
-         * Object containing the data profile.
-         */
-        aspect::Utilities::AsciiDataProfile<dim> profile;
-
-        /**
-         * The column indices of the temperature, pressure, and density column
-         * in the data file.
-         */
-        unsigned int density_index;
-        unsigned int thermal_expansivity_index;
-        unsigned int specific_heat_index;
-        unsigned int compressibility_index;
-
-        /**
-         * The column indices of the seismic velocities and their temperature
-         * derivatives columns in the data file.
-         */
-        unsigned int seismic_vp_index;
-        unsigned int seismic_vs_index;
-        unsigned int seismic_dvp_dT_index;
-        unsigned int seismic_dvs_dT_index;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/averaging.h.bak b/include/aspect/material_model/averaging.h.bak
deleted file mode 100644
index d6d4431ff42..00000000000
--- a/include/aspect/material_model/averaging.h.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_averaging_h
-#define _aspect_material_model_averaging_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * An enum to define what kind of averaging operations are implemented.
-     * These are:
-     *
-     * - No averaging, i.e., leave the values as they were provided by the
-     * material model.
-     *
-     * - Arithmetic averaging: Set the values of each output quantity at
-     * every quadrature point to \f[ \bar x = \frac 1Q \sum_{q=1}^Q x_q \f]
-     * where $x_q$ are the values at the $Q$ quadrature points.
-     *
-     * - Harmonic averaging: Set the values of each output quantity at every
-     * quadrature point to \f[ \bar x = \left(\frac 1Q \sum_{q=1}^Q
-     * \frac{1}{x_q}\right)^{-1} \f] where $x_q$ are the values at the $Q$
-     * quadrature points.
-     *
-     * - Geometric averaging: Set the values of each output quantity at
-     * every quadrature point to \f[ \bar x = \left(\prod_{q=1}^Q
-     * x_q\right)^{1/Q} \f] where $x_q$ are the values at the $Q$ quadrature
-     * points.
-     *
-     * - Pick largest: Set the values of each output quantity at every
-     * quadrature point to \f[ \bar x = \max_{1\le q\le Q} x_q \f] where $x_q$
-     * are the values at the $Q$ quadrature points.
-     *
-     * - Log average: Set the values of each output quantity at every
-     * quadrature point to \f[ \bar x = {10}^{\frac 1Q \sum_{q=1}^Q \log_{10}
-     * x_q} \f] where $x_q$ are the values at the $Q$ quadrature points.
-     *
-     * - NWD Arithmetic averaging: Set the values of each output quantity at
-     * every quadrature point to \f[ \bar x = \frac {\sum_{q=1}^Q W_q * x_q}
-     * {\sum_{q=1}^Q W_q} \f] where $x_q$ are the values and $w$ the weights
-     * at the $Q$ quadrature points.
-     *
-     * - NWD Harmonic averaging: Set the values of each output quantity at every
-     * quadrature point to \f[ \bar x = \frac{\sum_{q=1}^Q w_q }{ \sum_{q=1}^Q
-     * \frac{w_q}{x_q}} \f] where $x_q$ are the values and $w$ the weights at
-     * the $Q$ quadrature points.
-     *
-     * - NWD Geometric averaging: Set the values of each output quantity at
-     * every quadrature point to \f[ \bar x = \frac{ \sum_{q=1}^Q w_q x_q}
-     * {\sum_{q=1}^Q w_q} \f] where $x_q$ are the values and $w$ the weights
-     * at the $Q$ quadrature points.
-     */
-    enum AveragingOperation
-    {
-      none,
-      arithmetic_average,
-      harmonic_average,
-      geometric_average,
-      pick_largest,
-      log_average,
-      nwd_arithmetic_average,
-      nwd_harmonic_average,
-      nwd_geometric_average
-    };
-
-    /**
-     * A material model that applies an average of the quadrature points in a cell  to
-     * a ''base model'' chosen from any of the other available material models.
-     * @ingroup MaterialModels
-     */
-
-    template <int dim>
-    class Averaging : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void
-        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
-                  typename Interface<dim>::MaterialModelOutputs &out) const override;
-        /**
-         * Method to declare parameters related to depth-dependent model
-         */
-        static void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Method to parse parameters related to depth-dependent model
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Method that indicates whether material is compressible. Depth dependent model is compressible
-         * if and only if base model is compressible.
-         */
-        bool is_compressible () const override;
-
-
-
-      private:
-
-        /**
-         * Parse a string representing one of the options returned by
-         * get_averaging_operation_names(), and return the corresponding
-         * AveragingOperation value.
-         */
-        AveragingOperation
-        parse_averaging_operation_name (const std::string &s);
-
-        /**
-         * Given the averaging @p operation, a description of where the
-         * quadrature points are located on the given cell, and a mapping,
-         * perform this operation on all elements of the @p values structure.
-         */
-        void
-        average (const AveragingOperation averaging_operation,
-                 const std::vector<Point<dim>>    &position,
-                 std::vector<double>           &values_out) const;
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * The bell shape limit variable stores the maximum extend of the bell
-         * shape for the Normalized Weighed Distance (NWD) averages.
-         */
-        double bell_shape_limit;
-        /**
-         * The averaging operation variable stores the chosen averaging
-         * operation.
-         */
-        AveragingOperation averaging_operation;
-        /**
-         * Pointer to the material model used as the base model
-         */
-        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/compositing.h.bak b/include/aspect/material_model/compositing.h.bak
deleted file mode 100644
index 8f9b30a7f1d..00000000000
--- a/include/aspect/material_model/compositing.h.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_compositing_h
-#define _aspect_material_model_compositing_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <map>
-#include <vector>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Property
-    {
-      /**
-       * An enum to define what material properties are available.
-       */
-      enum MaterialProperty
-      {
-        viscosity,
-        density,
-        thermal_expansion_coefficient,
-        specific_heat,
-        thermal_conductivity,
-        compressibility,
-        entropy_derivative_pressure,
-        entropy_derivative_temperature,
-        reaction_terms
-      };
-    }
-
-    /**
-     * A material model that selects properties from other
-     * (non-compositing) material models.
-     *
-     * @ingroup MaterialModels
-     */
-
-    template <int dim>
-    class Compositing : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * @copydoc MaterialModel::Interface::initialize()
-         */
-        void
-        initialize () override;
-
-        /**
-         * @copydoc MaterialModel::Interface::evaluate()
-         */
-        void
-        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
-                  typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * If this material model can produce additional named outputs
-         * that are derived from NamedAdditionalOutputs, create them in here.
-         */
-        void
-        create_additional_named_outputs (typename Interface<dim>::MaterialModelOutputs &outputs) const override;
-
-        /**
-         * @copydoc MaterialModel::Interface::declare_parameters()
-         */
-        static void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * @copydoc MaterialModel::Interface::parse_parameters()
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @copydoc MaterialModel::Interface::is_compressible()
-         *
-         * Returns value from material model providing compressibility.
-         */
-        bool is_compressible () const override;
-
-
-
-      private:
-        /**
-         * Copy desired properties from material model outputs
-         * produced by another material model,
-         *
-         * @param model_index Internal index for pointer to the material model evaluated
-         * @param base_output Properties generated by the material model specified
-         * @param out MaterialModelOutputs to be used.
-         */
-        void
-        copy_required_properties(const unsigned int model_index,
-                                 const typename Interface<dim>::MaterialModelOutputs &base_output,
-                                 typename Interface<dim>::MaterialModelOutputs &out) const;
-
-        /**
-         * Map specifying which material model is responsible for a
-         * property.
-         */
-        std::map<Property::MaterialProperty, unsigned int> model_property_map;
-
-        /**
-         * Names of and pointers to the material models used for
-         * compositing.
-         */
-        std::vector<std::string>                             model_names;
-        std::vector<std::unique_ptr<Interface<dim>>> models;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/composition_reaction.h.bak b/include/aspect/material_model/composition_reaction.h.bak
deleted file mode 100644
index 81a83dd7815..00000000000
--- a/include/aspect/material_model/composition_reaction.h.bak
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_composition_reaction_h
-#define _aspect_material_model_composition_reaction_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that consists of globally constant values for all
-     * material parameters except that the density decays linearly with the
-     * temperature.
-     *
-     * The model is considered incompressible, following the definition
-     * described in Interface::is_compressible. This is essentially the
-     * material model used in the step-32 tutorial program.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class CompositionReaction : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate material properties.
-         */
-        void evaluate(const MaterialModelInputs<dim> &in,
-                      MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-        /**
-         * Create additional outputs
-         */
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-      private:
-        double reference_T;
-        double eta;
-        double composition_viscosity_prefactor_1;
-        double composition_viscosity_prefactor_2;
-        double thermal_viscosity_exponent;
-
-        /**
-         * The thermal conductivity.
-         */
-        double k_value;
-
-        EquationOfState::LinearizedIncompressible<dim> equation_of_state;
-
-        /**
-         * Above this depth the compositional fields react: The first field
-         * gets converted to the second field.
-         */
-        double reaction_depth;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/depth_dependent.h.bak b/include/aspect/material_model/depth_dependent.h.bak
deleted file mode 100644
index 0613ef53d9e..00000000000
--- a/include/aspect/material_model/depth_dependent.h.bak
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
-  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_depth_dependent_h
-#define _aspect_material_model_depth_dependent_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/rheology/ascii_depth_profile.h>
-
-#include <deal.II/base/function_lib.h>
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that applies a depth-dependent viscosity to a ''base model''
-     * chosen from any of the other available material models. This depth-dependent
-     * material model allows the user to specify a depth-dependent reference viscosity
-     * either through a parsed function, lists of depth and viscosity values, or a file.
-     * The current implementation only allows for depth-dependence of viscosity - all
-     * other properties are derived from the base model.
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class DepthDependent : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialize the base model at the beginning of the run.
-         */
-        void initialize() override;
-
-        /**
-         * Update the base model and viscosity function at the beginning of
-         * each timestep.
-         */
-        void update() override;
-
-        /**
-         * Method that indicates whether material is compressible. Depth dependent model is compressible
-         * if and only if base model is compressible.
-         */
-        bool is_compressible () const override;
-
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void
-        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
-                  typename Interface<dim>::MaterialModelOutputs &out) const override;
-        /**
-         * Method to declare parameters related to depth-dependent model
-         */
-        static void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Method to parse parameters related to depth-dependent model
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-      private:
-        /**
-         * An enum to describe where the depth dependency of the viscosity is coming from.
-         */
-        enum ViscositySource
-        {
-          function,
-          file,
-          list,
-          none
-        };
-
-        /**
-         * The viscosity that will be used as a reference for computing the depth-dependent
-         * prefactor.
-         */
-        double reference_viscosity;
-
-        /**
-         * Currently chosen source for the viscosity.
-         */
-        ViscositySource viscosity_source;
-
-        /**
-         * Data structures to store depth and viscosity lookup tables as well as interpolating
-         * function to calculate viscosity for File Depth dependence method
-         */
-        std::unique_ptr<Functions::InterpolatedTensorProductGridData<1>> viscosity_file_function;
-
-        /**
-         * Function to calculate depth-dependent multiplicative prefactor to be applied
-         * to base model viscosity.
-         */
-        double
-        calculate_depth_dependent_prefactor(const double &depth) const;
-
-        /**
-         * Values of depth specified by the user if using the depth dependence method 'list'
-         */
-        std::vector<double> depth_values;
-        std::vector<double> viscosity_values;
-
-        /**
-         * Parsed function that specifies viscosity depth-dependence when using the 'function'
-         * method.
-         */
-        Functions::ParsedFunction<1> viscosity_function;
-
-        /**
-         * Pointer to the material model used as the base model
-         */
-        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
-
-        /**
-         * Pointer to the rheology model used for depth-dependence from an
-         * ascii file
-         */
-        std::unique_ptr<Rheology::AsciiDepthProfile<dim>> depth_dependent_rheology;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/diffusion_dislocation.h.bak b/include/aspect/material_model/diffusion_dislocation.h.bak
deleted file mode 100644
index 61a420891ad..00000000000
--- a/include/aspect/material_model/diffusion_dislocation.h.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_diffusion_dislocation_h
-#define _aspect_material_model_diffusion_dislocation_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/rheology/diffusion_dislocation.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model based on a viscous rheology including diffusion and
-     * dislocation creep.
-     *
-     * The effective viscosity is defined as the harmonic mean of the two
-     * effective viscosity functions describing diffusion and dislocation creep:
-     * @f[
-     *   v_\text{eff} = \left( \frac{1}{v_\text{eff}^\text{diff}} + \frac{1}{v_\text{eff}^\text{dis}} \right)^{-1}
-     * @f]
-     * where
-     * @f[
-     *   v_\text{eff}^\text{diff} = A_\text{diff}^{-1} \exp\left(\frac{E_\text{diff} + PV_\text{diff}}{RT}\right),
-     * @f]
-     * and
-     * @f[
-     *   v_\text{eff}^\text{dis} =  A_\text{dis}^{\frac{-1}{n_\text{dis}}} \dot{\varepsilon}^{\frac{1-n}{n}}
-     *                        \exp\left(\frac{E_\text{diff} + PV_\text{diff}}{n_\text{dis}RT}\right)
-     * @f]
-     * where $\dot{\varepsilon}$ is the second invariant of the strain rate tensor,
-     * $A_i$ are prefactors where $i$ corresponds to diffusion or dislocation creep,
-     * $E_i$ are the activation energies, $V_i$ are the activation volumes,
-     * $\rho_m$ is the mantle density, $R$ is the gas constant,
-     * $T$ is temperature, and $P$ is pressure.
-     *
-     * Several model parameters (reference densities, thermal expansivities
-     * and rheology parameters) can be defined per-compositional field.
-     * For each material parameter the user supplies a comma delimited list of
-     * length N+1, where N is the number of compositional fields.  The
-     * additional field corresponds to the value for background mantle.  They
-     * should be ordered ``background, composition1, composition2...''
-     *
-     * If a list of values is given for the density and thermal expansivity,
-     * the volume weighted sum of the values of each of the compositional fields
-     * is used in their place, for example
-     * $\rho = \sum \left( \rho_i V_i \right)$
-     *
-     * The individual output viscosities for each compositional field are
-     * also averaged. The user can choose from a range of options for this
-     * viscosity averaging. If only one value is given for any of these parameters,
-     * all compositions are assigned the same value.
-     * The first value in the list is the value assigned to "background mantle"
-     * (regions where the sum of the compositional fields is < 1.0).
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class DiffusionDislocation : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the
-         * continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         *
-         * This material model is incompressible.
-         */
-        bool is_compressible () const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Object for computing viscous creep viscosities.
-         */
-        Rheology::DiffusionDislocation<dim> diffusion_dislocation;
-
-        double reference_T;
-
-        double thermal_diffusivity;
-        double heat_capacity;
-
-        std::vector<double> densities;
-        std::vector<double> thermal_expansivities;
-
-        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
-
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/drucker_prager.h.bak b/include/aspect/material_model/drucker_prager.h.bak
deleted file mode 100644
index 8cb0fe5581d..00000000000
--- a/include/aspect/material_model/drucker_prager.h.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_drucker_prager_h
-#define _aspect_material_model_drucker_prager_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/rheology/drucker_prager.h>
-#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that consists of globally constant values for all
-     * material parameters except density and viscosity.
-     *
-     * The model is considered incompressible, following the definition
-     * described in Interface::is_compressible.
-     *
-     * The viscosity is computed according to the Drucker Prager frictional
-     * plasticity criterion based on a user-defined internal angle of friction $\phi$
-     * and cohesion $C$. In 3D:
-     * $\sigma_y = \frac{6 C \cos(\phi)}{\sqrt{3} (3+\sin(\phi))} +
-     * \frac{6 P \sin(\phi)}{\sqrt{3} (3+\sin(\phi))}$,
-     * where $P$ is the pressure.
-     * See for example Zienkiewicz, O. C., Humpheson, C. and Lewis, R. W. (1975),
-     * G&eacute;otechnique 25, No. 4, 671-689.
-     * With this formulation we circumscribe instead of inscribe the Mohr Coulomb
-     * yield surface.
-     * In 2D the Drucker Prager yield surface is the same
-     * as the Mohr Coulomb surface:
-     * $\sigma_y = P \sin(\phi) + C \cos(\phi)$.
-     * Note that in 2D for $\phi=0$, these criteria
-     * revert to the von Mises criterion (no pressure dependence).
-     * See for example Thieulot, C. (2011), PEPI 188, 47-68.
-     *
-     * Note that we enforce the pressure to be positive in the computation of
-     * the yield strength by replacing it with
-     * a zero value whenever it is negative to prevent negative
-     * yield strengths and viscosities.
-     * We then use the computed yield strength to scale back the viscosity on
-     * to the yield surface using the Viscosity Rescaling Method described in
-     * Kachanov, L. M. (2004), Fundamentals of the Theory of Plasticity,
-     * Dover Publications, Inc.
-     *
-     * To avoid numerically unfavourably large (or even negative) viscosity ranges,
-     * we cut off the viscosity with a user-defined minimum and maximum viscosity:
-     * $\eta_eff = \frac{1}{\frac{1}{\eta_min + \eta}+\\
-     * \frac{1}{\eta_max}}$.
-     *
-     * Note that this model uses the formulation that assumes an incompressible
-     * medium despite the fact that the density follows the law
-     * $\rho(T)=\rho_0(1-\beta(T-T_{\text{ref}}))$.
-     *
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class DruckerPrager : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-
-        double reference_T;
-        double thermal_conductivities;
-
-        EquationOfState::LinearizedIncompressible<dim> equation_of_state;
-
-        /*
-         * Objects for computing plastic stresses, viscosities, and additional outputs
-         */
-        Rheology::DruckerPrager<dim> drucker_prager_plasticity;
-
-        /**
-         * The angle of internal friction
-         */
-        double angle_of_internal_friction;
-
-        /**
-         * The cohesion
-         */
-        double cohesion;
-
-        /**
-         * The applied viscosity bounds
-         */
-        double minimum_viscosity;
-        double maximum_viscosity;
-
-        /**
-         * The reference strain rate used as a first estimate
-         */
-        double reference_strain_rate;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/entropy_model.h.bak b/include/aspect/material_model/entropy_model.h.bak
deleted file mode 100644
index c245055e8b8..00000000000
--- a/include/aspect/material_model/entropy_model.h.bak
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_entropy_model_h
-#define _aspect_material_model_entropy_model_h
-
-#include <aspect/material_model/interface.h>
-
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/rheology/ascii_depth_profile.h>
-#include <aspect/material_model/rheology/drucker_prager.h>
-#include <aspect/material_model/steinberger.h>
-#include <aspect/material_model/utilities.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-    /**
-     * A material model that is designed to use pressure and entropy (rather
-     * than pressure and temperature) as independent variables. It will look up
-     * all material properties in a data table for a given pressure and
-     * entropy, and will additionally provide an additional output object of
-     * type PrescribedTemperatureOutputs filled with the temperature, and
-     * an additional output object of type PrescribedFieldOutput filled with
-     * the densities (necessary for the projected density approximation of
-     * the Stokes equation).
-     * @ingroup MaterialModels
-     */
-
-    template <int dim>
-    class EntropyModel: public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. Loads the material data and sets up
-         * pointers.
-         */
-        void
-        initialize () override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void
-        evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                 MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-        /**
-         * Creates additional output objects of
-         * type PrescribedTemperatureOutputs filled with the temperature
-         * (necessary for solving the entropy equation), and
-         * an additional output object of type PrescribedFieldOutput filled with
-         * the densities (necessary for the projected density approximation of
-         * the Stokes equation). Also creates SeismicAdditionalOutputs for
-         * postprocessing purposes.
-         */
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-      private:
-
-        double angle_of_internal_friction;
-        double cohesion;
-
-        /**
-         * Minimum/Maximum viscosity and lateral viscosity variations.
-         */
-        double min_eta;
-        double max_eta;
-        double max_lateral_eta_variation;
-
-        /**
-         * The value for thermal conductivity. It can be a constant
-         * for the whole domain, or P-T dependent.
-         */
-        double thermal_conductivity_value;
-        double thermal_conductivity (const double temperature,
-                                     const double pressure,
-                                     const Point<dim> &position) const;
-
-        enum ConductivityFormulation
-        {
-          constant,
-          p_T_dependent
-        } conductivity_formulation;
-
-        /**
-         * Parameters for the temperature- and pressure dependence of the
-         * thermal conductivity.
-         */
-        std::vector<double> conductivity_transition_depths;
-        std::vector<double> reference_thermal_conductivities;
-        std::vector<double> conductivity_pressure_dependencies;
-        std::vector<double> conductivity_reference_temperatures;
-        std::vector<double> conductivity_exponents;
-        std::vector<double> saturation_scaling;
-        double maximum_conductivity;
-
-        /**
-         * Information about the location of data files.
-         */
-        std::string data_directory;
-        std::vector<std::string> material_file_names;
-        std::string lateral_viscosity_file_name;
-
-        /**
-         * List of pointers to the EntropyReader that reads in material data for
-         * given entropy and pressure. There is one pointer/object per lookup file.
-         */
-        std::vector<std::unique_ptr<MaterialUtilities::Lookup::EntropyReader>> entropy_reader;
-
-        /**
-         * Pointer to an object that reads and processes data for the lateral
-         * temperature dependency of viscosity.
-         */
-        std::unique_ptr<internal::LateralViscosityLookup> lateral_viscosity_prefactor_lookup;
-
-        /**
-         * Objects for computing plastic stresses, viscosities, and additional outputs
-         */
-        Rheology::DruckerPrager<dim> drucker_prager_plasticity;
-
-        /**
-         * Pointer to the rheology model used for depth-dependence from an
-         * ascii file
-         */
-        std::unique_ptr<Rheology::AsciiDepthProfile<dim>> depth_dependent_rheology;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/equation_of_state/interface.h.bak b/include/aspect/material_model/equation_of_state/interface.h.bak
deleted file mode 100644
index eee4c557502..00000000000
--- a/include/aspect/material_model/equation_of_state/interface.h.bak
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_equation_of_state_interface_h
-#define _aspect_material_model_equation_of_state_interface_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/material_model/interface.h>
-
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A data structure containing output fields that can be filled by the
-     * evaluate() function of an EquationOfState model. It contains those
-     * properties of the MaterialModelOutputs that are connected to the
-     * equation of state (or the thermodynamic properties). Output values
-     * are computed separately for each composition and phase.
-     *
-     * Accordingly, the vectors are the values for each compositional field
-     * and individual phase at one specific location.
-     */
-    template <int dim>
-    struct EquationOfStateOutputs
-    {
-      /**
-       * Constructor. Initialize the various arrays of this structure with the
-       * given number of compositions and phases.
-       *
-       * @param n_individual_compositions_and_phases The number of vector quantities
-       * for which input will be provided, and outputs should be filled. Note that this
-       * number does not have to be the number of compositions, it can be smaller (if
-       * some compositional fields do not represent volumetric compositions, but tracked
-       * quantities like strain) or larger (if there is a background field, or some
-       * compositions have several high-pressure phases). It is the responsibility
-       * of the material model and equation of state object to interpret the
-       * entries consistently.
-       */
-      EquationOfStateOutputs (const unsigned int n_individual_compositions_and_phases);
-
-      /**
-       * Density values for each composition and phase.
-       */
-      std::vector<double> densities;
-
-      /**
-       * Thermal expansion coefficients for each composition and phase. It is defined
-       * as $\alpha = - \frac{1}{\rho} \frac{\partial\rho}{\partial T}$
-       */
-      std::vector<double> thermal_expansion_coefficients;
-
-      /**
-       * Specific heat for each composition and phase.
-       */
-      std::vector<double> specific_heat_capacities;
-
-      /**
-       * Compressibility for each composition and phase. The compressibility is defined
-       * as $\kappa = \frac{1}{\rho} \frac{\partial\rho}{\partial p}$.
-       */
-      std::vector<double> compressibilities;
-
-      /**
-       * The product of the change of entropy $\Delta S$ at a phase transition
-       * and the derivative of the phase function $X=X(p,T,\mathfrak c,\mathbf
-       * x)$ with regard to pressure for each composition and phase.
-       */
-      std::vector<double> entropy_derivative_pressure;
-
-      /**
-       * The product of (minus) the change of entropy $-\Delta S$ at a phase
-       * transition and the derivative of the phase function
-       * $X=X(p,T,\mathfrak c,\mathbf x)$ with regard to temperature for
-       * each composition and phase.
-       */
-      std::vector<double> entropy_derivative_temperature;
-    };
-
-
-
-    /**
-     * This function takes the output of an equation of state @p eos_outputs_all_phases,
-     * which contains the data for all compositions and all of their phases at the
-     * current conditions and uses a PhaseFunction object @p phase_function to compute
-     * the effective value of equation of state properties for each individual composition.
-     * Essentially it computes which phase is stable at the current conditions
-     * (described in @p phase_in) and fills the equation of state output @p eos_outputs with
-     * the properties of these stable phases.
-     * @p eos_outputs now only contains as many entries as volumetric compositions (potentially
-     * plus one for the background field, if the input @p eos_outputs_all_phases contained
-     * one and the phase function contained one as well).
-     */
-    template <int dim>
-    void
-    phase_average_equation_of_state_outputs(const EquationOfStateOutputs<dim> &eos_outputs_all_phases,
-                                            const std::vector<double> &phase_function_values,
-                                            const std::vector<unsigned int> &n_phase_transitions_per_composition,
-                                            EquationOfStateOutputs<dim> &eos_outputs);
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/equation_of_state/linearized_incompressible.h.bak b/include/aspect/material_model/equation_of_state/linearized_incompressible.h.bak
deleted file mode 100644
index 5b1a4c0ffa7..00000000000
--- a/include/aspect/material_model/equation_of_state/linearized_incompressible.h.bak
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_equation_of_state_linearized_incompressible_h
-#define _aspect_material_model_equation_of_state_linearized_incompressible_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-      using namespace dealii;
-
-      /**
-       * A simplified, incompressible equation of state where the density depends linearly
-       * on temperature and composition, using the equation
-       * $\rho(p,T,\mathfrak c) = \left(1-\alpha (T-T_0)\right)\rho_0 + \sum_i \Delta\rho_i \; \mathfrak c_i.$ "
-       * There is no pressure-dependence of the density, and all other material properties
-       * relating to the equation of state are assumed to be constant and identical for each
-       * composition.
-       */
-      template <int dim>
-      class LinearizedIncompressible
-      {
-        public:
-          /**
-           * A function that computes the output of the equation of state @p out
-           * for all compositions, given the inputs in @p in and an index @p q.
-           * More specifically, the inputs structure MaterialModelInputs contains
-           * a number of vectors, one for each input property, containing the
-           * material model inputs at a number of different locations. The equation
-           * of state model only evaluates one location (for each function call),
-           * and the index q determines which entry of each of these vectors of
-           * inputs is used.
-           * Using these inputs, the equation of state outputs are computed
-           * individually for each composition given in the inputs, and the outputs
-           * structure is filled with the equation of state outputs, which contain a
-           * number of vectors, one for each output property, with each vector
-           * containing the separate outputs for each composition.
-           */
-          void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                        const unsigned int q,
-                        MaterialModel::EquationOfStateOutputs<dim> &out) const;
-
-          /**
-           * Return whether the model is compressible or not. Incompressibility
-           * does not necessarily imply that the density is constant; rather, it
-           * may still depend on temperature or pressure. In the current
-           * context, compressibility means whether we should solve the continuity
-           * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-           * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-           */
-          bool is_compressible () const;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           * The optional parameter @p n_compositions determines the maximum
-           * number of compositions the equation of state is set up with,
-           * in other words, how many compositional fields influence the
-           * density.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm,
-                              const unsigned int n_compositions = 0);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           * The optional parameter @p n_compositions determines the maximum
-           * number of compositions the equation of state is set up with,
-           * and should have the same value as the parameter with the same
-           * name in the declare_parameters() function.
-           */
-          void
-          parse_parameters (ParameterHandler &prm,
-                            const unsigned int n_compositions = 0);
-
-
-        private:
-          /**
-           * The reference density $\rho_0$ used in the computation of the density.
-           */
-          double reference_rho;
-
-          /**
-           * The reference temperature $T_0$ used in the computation of the density.
-           */
-          double reference_T;
-
-          /**
-           * The constant thermal expansivity $\alpha$ used in the computation of the density.
-           */
-          double thermal_alpha;
-
-          /**
-           * The constant specific heat.
-           */
-          double reference_specific_heat;
-
-          /**
-           * The maximum number of compositions that densities will be computed for, and,
-           * accordingly, the maximum number of compositions the equation of state can be
-           * evaluated with.
-           */
-          unsigned int maximum_number_of_compositions;
-
-          /**
-           * The density difference $\Delta\rho_i$ between each composition $\mathfrak c_i$
-           * and the background.
-           */
-          std::vector<double> compositional_delta_rhos;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/equation_of_state/multicomponent_compressible.h.bak b/include/aspect/material_model/equation_of_state/multicomponent_compressible.h.bak
deleted file mode 100644
index 33c54d2ec23..00000000000
--- a/include/aspect/material_model/equation_of_state/multicomponent_compressible.h.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_equation_of_state_multicomponent_compressible_h
-#define _aspect_material_model_equation_of_state_multicomponent_compressible_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-      using namespace dealii;
-
-      /**
-       * A compressible equation of state that is intended for use with multiple compositional
-       * fields. For each material property, the user supplies a comma delimited list of
-       * length N+1, where N is the number of compositional fields used in the computation.
-       * The first entry corresponds to the "background" (which is also why there are N+1 entries).
-       *
-       * If a single value is given, then all the compositional fields are given
-       * that value. Other lengths of lists are not allowed. The material parameters
-       * for each compositional field are calculated self-consistently,
-       * assuming a constant pressure derivative of the isothermal bulk modulus ($K_T'$)
-       * at the reference temperature (i.e. a Murnaghan equation of state),
-       * a constant ratio of the thermal expansivity ($\alpha$) and
-       * isothermal compressibility ($\beta_T$), and a constant isochoric
-       * specific heat $C_v$. This leads to the following expressions for the material
-       * properties of each material:
-       *
-       * $\rho(p,T) = \rho_0 f^{1/K_T'}$
-       * $C_p(p,T) = C_v + (\alpha T \frac{\alpha}{\beta} f^{-1-(1/K_T')} / \rho_0)$
-       * $\alpha(p, T) = \alpha_0/f$
-       * $\beta_T(p, T) = \beta_0/f$
-       * $f = (1 + (p - \frac{\alpha}{\beta}(T-T_0)) K_T' \beta)$.
-       *
-       * where $\rho$ is the density and $C_p$ is the isobaric heat capacity.
-       * $f$ is a scaling factor for $\alpha$ and $\beta_T$.
-       */
-      template <int dim>
-      class MulticomponentCompressible :  public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * A function that computes the output of the equation of state @p out
-           * for all compositions, given the inputs in @p in and an index q that
-           * determines which entry of the vector of inputs is used.
-           */
-          void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                        const unsigned int q,
-                        MaterialModel::EquationOfStateOutputs<dim> &out) const;
-
-          /**
-           * Return whether the model is compressible or not. Incompressibility
-           * does not necessarily imply that the density is constant; rather, it
-           * may still depend on temperature or pressure. In the current
-           * context, compressibility means whether we should solve the continuity
-           * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-           * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-           * This model is compressible.
-           */
-          bool is_compressible () const;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           * The optional parameter @p n_compositions determines the maximum
-           * number of compositions the equation of state is set up with,
-           * in other words, how many compositional fields influence the
-           * density.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           * The optional parameter @p n_compositions determines the maximum
-           * number of compositions the equation of state is set up with,
-           * and should have the same value as the parameter with the same
-           * name in the declare_parameters() function.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-          /**
-           * Vector for reference_densities, read from parameter file .
-           */
-          std::vector<double> reference_densities;
-
-        private:
-          /**
-           * Vector for reference temperatures, read from parameter file .
-           */
-          std::vector<double> reference_temperatures;
-
-          /**
-           * Vector for reference compressibilities, read from parameter file.
-           */
-          std::vector<double> reference_isothermal_compressibilities;
-
-          /**
-           * Vector for isothermal bulk modulus pressure derivatives, read from parameter file.
-           */
-          std::vector<double> isothermal_bulk_modulus_pressure_derivatives;
-
-          /**
-           * Vector for reference thermal expansivities, read from parameter file.
-           */
-          std::vector<double> reference_thermal_expansivities;
-
-          /**
-           * Vector for isochoric specific heats, read from parameter file.
-           */
-          std::vector<double> isochoric_specific_heats;
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/equation_of_state/multicomponent_incompressible.h.bak b/include/aspect/material_model/equation_of_state/multicomponent_incompressible.h.bak
deleted file mode 100644
index 793c509b218..00000000000
--- a/include/aspect/material_model/equation_of_state/multicomponent_incompressible.h.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_equation_of_state_multicomponent_incompressible_h
-#define _aspect_material_model_equation_of_state_multicomponent_incompressible_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-      using namespace dealii;
-
-      /**
-       * An incompressible equation of state that is intended for use with multiple compositional
-       * fields and potentially phases. For each material property, the user supplies a comma
-       * delimited list of length N+P+1, where N is the number of compositional fields used in
-       * the computation, P is the total number of phase transitions.
-       * The first entry corresponds to the "background" (which is also why there are N+P+1 entries).
-       *
-       * If a single value is given, then all the compositional fields and phases are given
-       * that value. Other lengths of lists are not allowed. For a given
-       * compositional field and phase the material parameters are treated as constant,
-       * except density, which varies linearly with temperature according to the equation:
-       *
-       * $\rho(p,T,\mathfrak c) = \left(1-\alpha_i (T-T_0)\right) \rho_0(\mathfrak c_i).$
-       *
-       * There is no pressure-dependence of the density.
-       */
-      template <int dim>
-      class MulticomponentIncompressible :  public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * A function that computes the output of the equation of state @p out
-           * for all compositions and phases, given the inputs in @p in and an
-           * index input_index that determines which entry of the vector of inputs is used.
-           */
-          void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                        const unsigned int input_index,
-                        MaterialModel::EquationOfStateOutputs<dim> &out) const;
-
-          /**
-           * Return whether the model is compressible or not. Incompressibility
-           * does not necessarily imply that the density is constant; rather, it
-           * may still depend on temperature or pressure. In the current
-           * context, compressibility means whether we should solve the continuity
-           * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-           * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-           */
-          bool is_compressible () const;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           * The optional parameter @p default_thermal_expansion determines
-           * the default value of the thermal expansivity used in the
-           * equation of state.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm,
-                              const double default_thermal_expansion = 3.5e-5);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           * If @p expected_n_phases_per_composition points to a vector of
-           * unsigned integers this is considered the number of phases
-           * for each compositional field and will be checked against the parsed
-           * parameters.
-           */
-          void
-          parse_parameters (ParameterHandler &prm,
-                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
-
-        private:
-          /**
-           * Vector of reference densities $\rho_0$ with one entry per composition and phase plus one
-           * for the background field.
-           */
-          std::vector<double> densities;
-
-          /**
-           * The reference temperature $T_0$ used in the computation of the density.
-           * All components use the same reference temperature.
-           */
-          double reference_T;
-
-          /**
-           * Vector of thermal expansivities with one entry per composition and phase plus one
-           * for the background field.
-           */
-          std::vector<double> thermal_expansivities;
-
-          /**
-           * Vector of specific heat capacities with one entry per composition and phase plus one
-           * for the background field.
-           */
-          std::vector<double> specific_heats;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/equation_of_state/thermodynamic_table_lookup.h.bak b/include/aspect/material_model/equation_of_state/thermodynamic_table_lookup.h.bak
deleted file mode 100644
index 2e798906904..00000000000
--- a/include/aspect/material_model/equation_of_state/thermodynamic_table_lookup.h.bak
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_equation_of_state_thermodynamic_table_lookup_h
-#define _aspect_material_model_equation_of_state_thermodynamic_table_lookup_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-      using namespace dealii;
-
-      /**
-       * An equation of state class that reads thermodynamic properties
-       * from pressure-temperature tables in input files. These input files
-       * can be created using codes such as Perple_X or HeFESTo.
-       */
-      template <int dim>
-      class ThermodynamicTableLookup : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Initialization function. Loads the material data and sets up
-           * pointers.
-           */
-          void
-          initialize ();
-
-          /**
-           * Returns the number of lookups
-           */
-          virtual unsigned int number_of_lookups() const;
-
-          /**
-           * Return whether the model is compressible or not.  Incompressibility
-           * does not necessarily imply that the density is constant; rather, it
-           * may still depend on temperature or pressure. In the current
-           * context, compressibility means whether we should solve the continuity
-           * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-           * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-           */
-          bool is_compressible () const;
-
-          /**
-           * Function to compute the thermodynamic properties in @p out given the
-           * inputs in @p in over all evaluation points.
-           * This function also fills the mass_fraction and volume_fraction vectors.
-           */
-          void
-          evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                   std::vector<MaterialModel::EquationOfStateOutputs<dim>> &eos_outputs) const;
-
-          /**
-           * Function to fill the seismic velocity and phase volume additional outputs
-           */
-          void
-          fill_additional_outputs(const MaterialModel::MaterialModelInputs<dim> &in,
-                                  const std::vector<std::vector<double>> &volume_fractions,
-                                  MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-          void
-          create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-          const MaterialModel::MaterialUtilities::Lookup::MaterialLookup &
-          get_material_lookup (unsigned int lookup_index) const;
-
-
-        private:
-          unsigned int n_material_lookups;
-          bool use_bilinear_interpolation;
-          bool latent_heat;
-
-          /**
-           * Information about the location of data files.
-           */
-          std::string data_directory;
-          std::vector<std::string> material_file_names;
-          std::vector<std::string> derivatives_file_names;
-
-          /**
-           * The maximum number of substeps over the temperature pressure range
-           * to calculate the averaged enthalpy gradient over a cell
-           */
-          unsigned int max_latent_heat_substeps;
-
-          /**
-           * The format of the provided material files. Currently we support
-           * the Perple_X and HeFESTo data formats.
-           */
-          enum formats
-          {
-            perplex,
-            hefesto
-          } material_file_format;
-
-          /**
-           * List of pointers to objects that read and process data we get from
-           * material data files. There is one pointer/object per lookup file.
-           */
-          std::vector<std::unique_ptr<MaterialModel::MaterialUtilities::Lookup::MaterialLookup>> material_lookup;
-
-          /**
-           * Vector of strings containing the names of the unique phases in all the material lookups.
-           */
-          std::vector<std::string> unique_phase_names;
-
-          /**
-           * Vector of vector of unsigned ints which constitutes mappings
-           * between lookup phase name vectors and unique_phase_names.
-           * The element unique_phase_indices[i][j] contains the
-           * index of phase name j from lookup i as it is found in unique_phase_names.
-           */
-          std::vector<std::vector<unsigned int>> unique_phase_indices;
-
-          /**
-           * Vector of strings containing the names of the dominant phases in all the material lookups.
-           * In case the lookup table contains one string with the dominant phase rather than separate
-           * columns with volume fraction for each phase, this vector will be used instead of the
-           * unique_phase_names vector above.
-           */
-          std::vector<std::string> list_of_dominant_phases;
-
-          /**
-           * Each lookup table reads in their own dominant phases and assigns indices based
-           * on all phases in that particular lookup. Since a model can have more than one
-           * lookup, it might have more phases than present in each lookup. We want to output
-           * unique/consistent indices for each phase, so we have to convert the indices of a phase
-           * in the individual lookup to the index in the global list of phases. This vector
-           * of vectors of unsigned int stores the global index for each lookup (so there are
-           * as many inner vectors as lookups, and each one stores the indices for an individual
-           * lookup, to be filled in the initialize function).
-           *
-           * In case the lookup table contains one string with the dominant phase rather than separate
-           * columns with volume fraction for each phase, this vector will be used instead of the
-           * unique_phase_indices vector above.
-           */
-          std::vector<std::vector<unsigned int>> global_index_of_lookup_phase;
-
-          /**
-           * Compute the specific heat and thermal expansivity using the pressure
-           * and temperature derivatives of the specific enthalpy.
-           * This evaluation incorporates the effects of latent heat production.
-           */
-          void evaluate_thermal_enthalpy_derivatives(const MaterialModel::MaterialModelInputs<dim> &in,
-                                                     std::vector<MaterialModel::EquationOfStateOutputs<dim>> &eos_outputs) const;
-
-          /**
-           * Returns the cell-wise averaged enthalpy derivatives for the evaluate
-           * function and postprocessors. The function returns two pairs, the
-           * first one represents the temperature derivative, the second one the
-           * pressure derivative. The first member of each pair is the derivative,
-           * the second one the number of vertex combinations the function could
-           * use to compute the derivative. The second member is useful to handle
-           * the case no suitable combination of vertices could be found (e.g.
-           * if the temperature and pressure on all vertices of the current
-           * cell is identical.
-           */
-          std::array<std::pair<double, unsigned int>,2>
-          enthalpy_derivatives (const typename Interface<dim>::MaterialModelInputs &in) const;
-
-          void fill_seismic_velocities (const MaterialModel::MaterialModelInputs<dim> &in,
-                                        const std::vector<double> &composite_densities,
-                                        const std::vector<std::vector<double>> &volume_fractions,
-                                        SeismicAdditionalOutputs<dim> *seismic_out) const;
-
-          /**
-           * This function uses the MaterialModelInputs &in to fill the output_values
-           * of the phase_volume_fractions_out output object with the volume
-           * fractions of each of the unique phases at each of the evaluation points.
-           * These volume fractions are obtained from the Perple_X- or HeFESTo-derived
-           * pressure-temperature lookup tables.
-           * The filled output_values object is a vector of vector<double>;
-           * the outer vector is expected to have a size that equals the number
-           * of unique phases, the inner vector is expected to have a size that
-           * equals the number of evaluation points.
-           */
-          void fill_phase_volume_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                                            const std::vector<std::vector<double>> &volume_fractions,
-                                            NamedAdditionalMaterialOutputs<dim> *phase_volume_fractions_out) const;
-
-          /**
-           * This function uses the MaterialModelInputs &in to fill the output_values
-           * of the dominant_phases_out output object with the index of the
-           * dominant phase at each of the evaluation points.
-           * The phases are obtained from the Perple_X- or HeFESTo-derived
-           * pressure-temperature lookup tables.
-           * The filled output_values object is a vector of vector<unsigned int>;
-           * the outer vector is expected to have a size of 1, the inner vector is
-           * expected to have a size that equals the number of evaluation points.
-           */
-          void fill_dominant_phases (const MaterialModel::MaterialModelInputs<dim> &in,
-                                     const std::vector<std::vector<double>> &volume_fractions,
-                                     PhaseOutputs<dim> &dominant_phases_out) const;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/grain_size.h.bak b/include/aspect/material_model/grain_size.h.bak
deleted file mode 100644
index 6aed6159ddc..00000000000
--- a/include/aspect/material_model/grain_size.h.bak
+++ /dev/null
@@ -1,490 +0,0 @@
-/*
-  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_model_grain_size_h
-#define _aspect_model_grain_size_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/rheology/drucker_prager.h>
-
-#include <deal.II/matrix_free/fe_point_evaluation.h>
-#include <deal.II/sundials/arkode.h>
-
-#include <array>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * Additional output fields for the dislocation viscosity parameters
-     * to be added to the MaterialModel::MaterialModelOutputs structure
-     * and filled in the MaterialModel::GrainSize::evaluate() function.
-     */
-    template <int dim>
-    class DislocationViscosityOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        DislocationViscosityOutputs(const unsigned int n_points);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * Dislocation viscosities at the evaluation points passed to
-         * the instance of MaterialModel::Interface::evaluate() that fills
-         * the current object.
-         */
-        std::vector<double> dislocation_viscosities;
-
-        /**
-         * Diffusion viscosities at the evaluation points passed to
-         * the instance of MaterialModel::Interface::evaluate() that fills
-         * the current object.
-         */
-        std::vector<double> diffusion_viscosities;
-    };
-
-
-
-    /**
-     * A material model that relies on compositional fields that stand for
-     * average grain sizes of a mineral phase and source terms for them that
-     * determine the grain size evolution in dependence of the strain rate,
-     * temperature, phase transitions, and the creep regime.
-     * This material model only works if a compositional field
-     * named 'grain_size' is present. In the diffusion
-     * creep regime, the viscosity depends on this grain size. We use the grain
-     * size evolution laws described in Behn et al., 2009. Implications of grain
-     * size evolution on the seismic structure of the oceanic upper mantle, Earth
-     * Planet. Sci. Letters, 282, 178–189. Other material parameters are either
-     * prescribed similar to the 'simple' material model, or read from data files
-     * that were generated by the Perplex or Hefesto software. The material model
-     * is described in more detail in Dannberg, J., Z. Eilon, U. Faul,
-     * R. Gassmöller, P. Moulik, and R. Myhill (2017), The importance of
-     * grain size to mantle dynamics and seismological observations,
-     * Geochem. Geophys. Geosyst., 18, 3034–3061, doi:10.1002/2017GC006944.,
-     * which is the canonical reference for this material model.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class GrainSize : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. Loads the material data and sets up
-         * pointers.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-
-        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                      typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @}
-         */
-
-        /**
-         * Returns the enthalpy as calculated by HeFESTo.
-         */
-        double enthalpy (const double      temperature,
-                         const double      pressure,
-                         const std::vector<double> &compositional_fields,
-                         const Point<dim> &position) const;
-
-        /**
-         * Returns the cell-wise averaged enthalpy derivatives for the evaluate
-         * function and postprocessors. The function returns two pairs, the
-         * first one represents the temperature derivative, the second one the
-         * pressure derivative. The first member of each pair is the derivative,
-         * the second one the number of vertex combinations the function could
-         * use to compute the derivative. The second member is useful to handle
-         * the case no suitable combination of vertices could be found (e.g.
-         * if the temperature and pressure on all vertices of the current
-         * cell is identical.
-         */
-        std::array<std::pair<double, unsigned int>,2>
-        enthalpy_derivative (const typename Interface<dim>::MaterialModelInputs &in) const;
-
-      protected:
-        double reference_rho;
-        double reference_T;
-        double eta;
-        double thermal_alpha;
-        double reference_specific_heat;
-
-        /**
-         * The constant compressibility.
-         */
-        double reference_compressibility;
-
-        /**
-         * The thermal conductivity.
-         */
-        double k_value;
-
-        /**
-         * The index of the compositional field that represents the grain size.
-         */
-        unsigned int grain_size_index;
-
-        /**
-         * Parameters controlling the grain size evolution.
-         */
-        std::vector<double> grain_growth_activation_energy;
-        std::vector<double> grain_growth_activation_volume;
-        std::vector<double> grain_growth_rate_constant;
-        std::vector<double> grain_growth_exponent;
-        double              minimum_grain_size;
-        std::vector<double> reciprocal_required_strain;
-        std::vector<double> recrystallized_grain_size;
-
-        /**
-         * Parameters controlling the dynamic grain recrystallization.
-         */
-        std::vector<double> grain_boundary_energy;
-        std::vector<double> boundary_area_change_work_fraction;
-        std::vector<double> geometric_constant;
-
-        /**
-          * A struct that contains information about which
-          * formulation of grain size evolution should be used.
-          */
-        struct Formulation
-        {
-          /**
-           * This enum lists available options that
-           * determine the equations being used for grain size evolution.
-           *
-           * We currently support three approaches:
-           *
-           * 'paleowattmeter':
-           * Austin, N. J., & Evans, B. (2007). Paleowattmeters: A scaling
-           * relation for dynamically recrystallized grain size. Geology, 354), 343-346.).
-           *
-           * 'paleopiezometer':
-           * Hall, C. E., Parmentier, E. M. (2003). Influence of grain size
-           * evolution on convective instability. Geochemistry, Geophysics,
-           * Geosystems, 4(3).
-           *
-           * 'pinned_grain_damage':
-           * Mulyukova, E., & Bercovici, D. (2018). Collapse of passive margins
-           * by lithospheric damage and plunging grain size. Earth and Planetary
-           * Science Letters, 484, 341-352.
-           */
-          enum Kind
-          {
-            paleowattmeter,
-            paleopiezometer,
-            pinned_grain_damage
-          };
-
-          /**
-           * This function translates an input string into the
-           * available enum options.
-           */
-          static
-          Kind
-          parse(const std::string &input)
-          {
-            if (input == "paleowattmeter")
-              return Formulation::paleowattmeter;
-            else if (input == "paleopiezometer")
-              return Formulation::paleopiezometer;
-            else if (input == "pinned grain damage")
-              return Formulation::pinned_grain_damage;
-            else
-              AssertThrow(false, ExcNotImplemented());
-
-            return Formulation::Kind();
-          }
-        };
-
-        /**
-         * A variable that records the formulation of how to evolve grain size.
-         * See the type of this variable for a description of available options.
-        */
-        typename Formulation::Kind grain_size_evolution_formulation;
-
-        /**
-        * This function returns the fraction of shear heating energy partitioned
-        * into grain damage using the implementation by Mulyukova and Bercovici (2018)
-        * Collapse of passive margins by lithospheric damage
-        * and plunging grain size. Earth and Planetary Science Letters, 484, 341-352.
-        */
-        double  compute_partitioning_fraction (const double temperature) const;
-
-        /**
-         * Parameters controlling the partitioning of energy
-         * into grain damage in the pinned state.
-         */
-        double grain_size_reduction_work_fraction_exponent;
-        double minimum_grain_size_reduction_work_fraction;
-        double maximum_grain_size_reduction_work_fraction;
-        double temperature_minimum_partitioning_power;
-        double temperature_maximum_partitioning_power;
-
-        /**
-         * Functions and parameters controlling conversion from interface roughness to grain size,
-         * used in pinned state formulation of grain damage. This conversion depends on the
-         * proportion of the two mineral phases.
-         *
-         * A detailed description of this approach can be found in Appendix H.1, in Equation (8) in
-         * the main manuscript, and in equation (F.28) of Bercovici, David, and Yanick Ricard (2012).
-         * Mechanisms for the generation of plate tectonics by two-phase grain-damage
-         * and pinning. Physics of the Earth and Planetary Interiors 202 (2012): 27-55.
-         */
-        double phase_distribution;
-
-        /**
-         * The factor used to convert roughness into the equivalent mean grain
-         * size for a given volume fraction of a mineral in the two-phase damage model.
-        */
-        double roughness_to_grain_size;
-
-        /**
-         * Parameters controlling the viscosity.
-         */
-        double dislocation_viscosity_iteration_threshold;
-        unsigned int dislocation_viscosity_iteration_number;
-        std::vector<double> dislocation_creep_exponent;
-        std::vector<double> dislocation_activation_energy;
-        std::vector<double> dislocation_activation_volume;
-        std::vector<double> dislocation_creep_prefactor;
-        std::vector<double> diffusion_creep_exponent;
-        std::vector<double> diffusion_activation_energy;
-        std::vector<double> diffusion_activation_volume;
-        std::vector<double> diffusion_creep_prefactor;
-        std::vector<double> diffusion_creep_grain_size_exponent;
-
-        /**
-         * Because of the nonlinear nature of this material model many
-         * parameters need to be kept within bounds to ensure stability of the
-         * solution. These bounds can be adjusted as input parameters.
-         */
-        double max_temperature_dependence_of_eta;
-        double min_eta;
-        double max_eta;
-        double min_specific_heat;
-        double max_specific_heat;
-        double min_thermal_expansivity;
-        double max_thermal_expansivity;
-        unsigned int max_latent_heat_substeps;
-        double min_grain_size;
-
-        double diffusion_viscosity (const double temperature,
-                                    const double adiabatic_temperature,
-                                    const double adiabatic_pressure,
-                                    const double grain_size,
-                                    const double second_strain_rate_invariant,
-                                    const unsigned int phase_index) const;
-
-        /**
-         * This function calculates the dislocation viscosity. For this purpose
-         * we need the dislocation component of the strain rate, which we can
-         * only compute by knowing the dislocation viscosity. Therefore, we
-         * iteratively solve for the dislocation viscosity and update the
-         * dislocation strain rate in each iteration using the new value
-         * obtained for the dislocation viscosity. The iteration is started
-         * with a dislocation viscosity calculated for the whole strain rate
-         * unless a guess for the viscosity is provided, which can reduce the
-         * number of iterations significantly.
-         */
-        double dislocation_viscosity (const double temperature,
-                                      const double adiabatic_temperature,
-                                      const double adiabatic_pressure,
-                                      const SymmetricTensor<2,dim> &strain_rate,
-                                      const unsigned int phase_index,
-                                      const double diffusion_viscosity,
-                                      const double viscosity_guess = 0) const;
-
-        double density (const double temperature,
-                        const double pressure,
-                        const std::vector<double> &compositional_fields,
-                        const Point<dim> &position) const;
-
-        double compressibility (const double temperature,
-                                const double pressure,
-                                const std::vector<double> &compositional_fields,
-                                const Point<dim> &position) const;
-
-        double specific_heat (const double temperature,
-                              const double pressure,
-                              const std::vector<double> &compositional_fields,
-                              const Point<dim> &position) const;
-
-        double thermal_expansion_coefficient (const double      temperature,
-                                              const double      pressure,
-                                              const std::vector<double> &compositional_fields,
-                                              const Point<dim> &position) const;
-
-        /**
-         * Returns the p-wave velocity as calculated by HeFESTo.
-         */
-        double seismic_Vp (const double      temperature,
-                           const double      pressure,
-                           const std::vector<double> &compositional_fields,
-                           const Point<dim> &position) const;
-
-        /**
-         * Returns the s-wave velocity as calculated by HeFESTo.
-         */
-        double seismic_Vs (const double      temperature,
-                           const double      pressure,
-                           const std::vector<double> &compositional_fields,
-                           const Point<dim> &position) const;
-
-        /**
-         * Rate of grain size growth (Ostwald ripening) or reduction
-         * (due to dynamic recrystallization and phase transformations)
-         * in dependence on temperature, pressure, strain rate, mineral
-         * phase and creep regime.
-         * We use the grain size growth laws as for example described
-         * in Behn, M. D., Hirth, G., & Elsenbeck, J. R. (2009). Implications
-         * of grain size evolution on the seismic structure of the oceanic
-         * upper mantle. Earth and Planetary Science Letters, 282(1), 178-189.
-         *
-         * For the rate of grain size reduction due to dynamic crystallization
-         * there is the choice between the paleowattmeter (Austins and
-         * Evans, 2007) and the paleopiezometer (Hall and Parmentier, 2003)
-         * as described in the parameter use_paleowattmeter.
-         */
-        std::vector<std::vector<double>>
-        grain_size_change (const typename Interface<dim>::MaterialModelInputs &in,
-                           const std::vector<double>                          &adiabatic_pressure,
-                           const std::vector<unsigned int>                    &phase_indices) const;
-
-        /**
-         * Function that returns the phase for a given
-         * temperature, depth, pressure, and density gradient
-         * (which are all contained in the @p in argument).
-         * Because the function returns just the dominant
-         * phase, phase transitions are discrete in this
-         * material model (they have a zero width).
-         */
-        unsigned int
-        get_phase_index (const MaterialUtilities::PhaseFunctionInputs<dim> &in) const;
-
-
-        /**
-         * Number of phase transitions for the one chemical composition used in this model.
-         */
-        unsigned int n_phase_transitions;
-
-        /**
-         * Object that handles phase transitions.
-         * Allows it to compute the phase function for each individual phase
-         * transition in the model, given the temperature, pressure, depth,
-         * and density gradient.
-         */
-        MaterialUtilities::PhaseFunction<dim> phase_function;
-
-
-        /**
-         * The following variables are properties of the material files
-         * we read in.
-         */
-        std::string datadirectory;
-        std::vector<std::string> material_file_names;
-        std::vector<std::string> derivatives_file_names;
-        unsigned int n_material_data;
-        bool use_table_properties;
-        bool use_enthalpy;
-        bool use_bilinear_interpolation;
-
-
-        /**
-         * The format of the provided material files. Currently we support
-         * the PERPLEX and HeFESTo data formats.
-         */
-        enum formats
-        {
-          perplex,
-          hefesto
-        } material_file_format;
-
-        /**
-         * List of pointers to objects that read and process data we get from
-         * material data files. There is one pointer/object per compositional
-         * field provided.
-         */
-        std::vector<std::unique_ptr<MaterialModel::MaterialUtilities::Lookup::MaterialLookup>> material_lookup;
-
-        /**
-         * We cache the evaluators that are necessary to evaluate the temperature
-         * and pressure at the vertices of the current cell.
-         * By caching the evaluators, we can avoid recreating them
-         * every time we need them.
-         */
-        mutable std::unique_ptr<FEPointEvaluation<1, dim>> temperature_evaluator;
-        mutable std::unique_ptr<FEPointEvaluation<1, dim>> pressure_evaluator;
-
-      private:
-        /*
-         * Object for computing plastic stresses, viscosities, and additional outputs,
-         * as well as an object for the required input parameters.
-         */
-        bool enable_drucker_prager_rheology;
-        bool use_adiabatic_pressure_for_yielding;
-        Rheology::DruckerPrager<dim> drucker_prager_plasticity;
-        Rheology::DruckerPragerParameters drucker_prager_parameters;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/interface.h.bak b/include/aspect/material_model/interface.h.bak
deleted file mode 100644
index 34b97c11bbd..00000000000
--- a/include/aspect/material_model/interface.h.bak
+++ /dev/null
@@ -1,1534 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_interface_h
-#define _aspect_material_model_interface_h
-
-#include <aspect/global.h>
-#include <aspect/plugins.h>
-#include <aspect/material_model/utilities.h>
-
-#include <deal.II/base/point.h>
-#include <deal.II/base/quadrature.h>
-#include <deal.II/base/symmetric_tensor.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/fe/mapping.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/component_mask.h>
-#include <deal.II/numerics/data_postprocessor.h>
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  template <int dim>
-  struct Introspection;
-
-
-  /**
-   * A namespace in which we define everything that has to do with modeling
-   * convecting material, including descriptions of material parameters such
-   * as viscosities, densities, etc.
-   *
-   * @ingroup MaterialModels
-   */
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A namespace whose enum members are used in querying the nonlinear
-     * dependence of physical parameters on other solution variables.
-     */
-    namespace NonlinearDependence
-    {
-      /**
-       *
-       * An enum whose members are used in querying the nonlinear dependence
-       * of physical parameters on other solution variables.
-       *
-       * The values of this enum are used in the
-       * NonlinearDependence::model_dependence, queried by get_model_dependence()
-       * to see if a coefficient like the viscosity, depends on the
-       * temperature, pressure, strain rate, or compositional field value.
-       * Because the values of the enum are chosen so that they represent
-       * single bits in an integer, the result here is a number that can be
-       * represented in base-2 as 101 (the number 100=4 for the strain rate and
-       * 001=1 for the temperature).
-       *
-       * To query nonlinear dependence of a coefficient on any other variable,
-       * you can use
-       * @code
-       *   material_model.get_model_dependence();
-       * @endcode
-       * and compare the result to NonlinearDependence::Dependence::Variable.
-       */
-      enum Dependence
-      {
-        uninitialized        = 0,
-
-        none                 = 1,
-        temperature          = 2,
-        pressure             = 4,
-        strain_rate          = 8,
-        compositional_fields = 16,
-
-        any_variable         = temperature | pressure | strain_rate | compositional_fields
-      };
-
-
-      /**
-       * Provide an operator that or's two Dependence variables.
-       */
-      inline Dependence operator | (const Dependence d1,
-                                    const Dependence d2)
-      {
-        return Dependence(static_cast<int>(d1) | static_cast<int>(d2));
-      }
-
-      inline Dependence operator |= (Dependence &d1,
-                                     const Dependence d2)
-      {
-        d1 = (d1 | d2);
-        return d1;
-      }
-
-      /**
-       * A structure that, for every output variable of a material model,
-       * describes which input variable it depends on.
-       */
-      struct ModelDependence
-      {
-        /**
-         * A field that describes which input variable the viscosity
-         * of a material model depends on.
-         */
-        Dependence viscosity;
-
-        /**
-         * A field that describes which input variable the density
-         * of a material model depends on.
-         */
-        Dependence density;
-
-        /**
-         * A field that describes which input variable the compressibility
-         * of a material model depends on.
-         */
-        Dependence compressibility;
-
-        /**
-         * A field that describes which input variable the specific heat
-         * of a material model depends on.
-         */
-        Dependence specific_heat;
-
-        /**
-         * A field that describes which input variable the thermal conductivity
-         * of a material model depends on.
-         */
-        Dependence thermal_conductivity;
-
-        /**
-         * Default constructor. Sets all dependencies to invalid values in
-         * order to ensure that material models really correctly specify
-         * which input variables their output variables depend on.
-         */
-        ModelDependence ();
-      };
-
-      /**
-       * Return whether the given argument @p dependence identifies a single
-       * variable (e.g., the pressure, the temperature, etc) or a combination
-       * of variables. Technically, this corresponds to the question of
-       * whether there is exactly one bit set in the argument.
-       *
-       * @return true if yes, false otherwise.
-       */
-      bool
-      identifies_single_variable(const Dependence dependence);
-    }
-
-    /**
-     * A namespace whose enum members are used in querying which material
-     * properties should be computed.
-     */
-    namespace MaterialProperties
-    {
-      /**
-       * An enum whose members identify material model output
-       * properties.
-       *
-       * Because the values of the enum are chosen so that they represent
-       * single bits in an integer, the result here is a number that can be
-       * represented in base-2 as 110 (the number 100=4 for the density and
-       * 010=2 for the viscosity).
-       */
-      enum Property
-      {
-        uninitialized                  = 0,
-
-        none                           = 1,
-        viscosity                      = 2,
-        density                        = 4,
-        thermal_expansion_coefficient  = 8,
-        specific_heat                  = 16,
-        thermal_conductivity           = 32,
-        compressibility                = 64,
-        entropy_derivative_pressure    = 128,
-        entropy_derivative_temperature = 256,
-        reaction_terms                 = 512,
-        reaction_rates                 = 1024,
-        additional_outputs             = 2048,
-
-        equation_of_state_properties   = density |
-                                         thermal_expansion_coefficient |
-                                         specific_heat |
-                                         compressibility |
-                                         entropy_derivative_pressure |
-                                         entropy_derivative_temperature,
-        all_properties                 = equation_of_state_properties |
-                                         viscosity |
-                                         thermal_conductivity |
-                                         reaction_terms |
-                                         reaction_rates |
-                                         additional_outputs
-      };
-
-      /**
-       * Provide an operator that or's two Property variables. This allows to
-       * combine more than one property in a single variable.
-       */
-      inline Property operator | (const Property d1,
-                                  const Property d2)
-      {
-        return Property(static_cast<int>(d1) | static_cast<int>(d2));
-      }
-
-      inline Property operator |= (Property &d1,
-                                   const Property d2)
-      {
-        return (d1 | d2);
-      }
-    }
-
-
-    // Forward declaration:
-    template <int dim>
-    class AdditionalMaterialInputs;
-
-    /**
-     * A data structure with all inputs for the
-     * MaterialModel::Interface::evaluate() method. The vectors all have the
-     * same length and refer to different evaluation points (given in
-     * #position).
-     */
-    template <int dim>
-    class MaterialModelInputs
-    {
-      public:
-        /**
-         * Constructor. Initialize the various arrays of this structure with the
-         * given number of quadrature points and (finite element) components.
-         *
-         * @param n_points The number of quadrature points for which input
-         * quantities will be provided.
-         * @param n_comp The number of vector quantities (in the order in which
-         * the Introspection class reports them) for which input will be
-         * provided.
-         */
-        MaterialModelInputs(const unsigned int n_points,
-                            const unsigned int n_comp);
-
-        /**
-         * Constructor. Initialize the arrays of the structure with the number
-         * of points in the `input_data` structure, and fills them appropriately.
-         *
-         * @param input_data The data used to populate the material model input quantities.
-         * @param introspection A reference to the simulator introspection object.
-         * @param compute_strain_rate If set to `true`, then the object that
-         *   is currently created will also store the strain rates at all evaluation
-         *   points. This is an expensive operation. If set to `false`, then the
-         *   `strain_rate` array is going to be empty, and strain rates are not
-         *   evaluated. As a consequence, strain rates are then also not
-         *   available to functions that take this MaterialModelInputs
-         *   object as input, for example to compute strain rate-dependent
-         *   viscosities.
-         */
-        MaterialModelInputs(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            const Introspection<dim> &introspection,
-                            const bool compute_strain_rate = true);
-
-
-        /**
-         * Constructor. Initializes the various arrays of this
-         * structure with the FEValues and introspection objects and
-         * the solution_vector. This constructor calls the function
-         * reinit to populate the newly created arrays.
-         *
-         * @param fe_values An FEValuesBase object used to evaluate the finite elements.
-         * @param cell The currently active cell for the fe_values object.
-         * @param introspection A reference to the simulator introspection object.
-         * @param solution_vector The finite element vector from which to construct the inputs.
-         * @param compute_strain_rate If set to `true`, then the object that
-         *   is currently created will also store the strain rates at all evaluation
-         *   points. This is an expensive operation. If set to `false`, then the
-         *   `strain_rate` array is going to be empty, and strain rates are not
-         *   evaluated. As a consequence, strain rates are then also not
-         *   available to functions that take this MaterialModelInputs
-         *   object as input, for example to compute strain rate-dependent
-         *   viscosities.
-         */
-        MaterialModelInputs(const FEValuesBase<dim,dim> &fe_values,
-                            const typename DoFHandler<dim>::active_cell_iterator &cell,
-                            const Introspection<dim> &introspection,
-                            const LinearAlgebra::BlockVector &solution_vector,
-                            const bool compute_strain_rate = true);
-
-        /**
-         * Copy constructor. This constructor copies all data members of the
-         * source object except for the additional input data (of type
-         * AdditionalMaterialInputs) pointers, stored in the
-         * `source.additional_inputs` member variable.
-         *
-         * This is because these pointers can not be copied (they
-         * are unique to the @p source object). Since they can also not
-         * be recreated without the original code that created these objects
-         * in the first place, this constructor throws an exception if the
-         * @p source object had any additional input data objects
-         * associated with it.
-         */
-        MaterialModelInputs (const MaterialModelInputs &source);
-
-        /**
-         * Move constructor. This constructor simply moves all members.
-         */
-        MaterialModelInputs (MaterialModelInputs &&)  noexcept = default;
-
-        /**
-         * Copy operator. Copying these objects is expensive and
-         * consequently prohibited
-         */
-        MaterialModelInputs &operator= (const MaterialModelInputs &source) = delete;
-
-        /**
-         * Move operator.
-         */
-        MaterialModelInputs &operator= (MaterialModelInputs &&) = default;
-
-        /**
-         * Function to re-initialize and populate the pre-existing arrays
-         * created by the constructor MaterialModelInputs. The arguments here
-         * have the same meaning as in the constructor of this class.
-         */
-        void reinit(const FEValuesBase<dim,dim>                          &fe_values,
-                    const typename DoFHandler<dim>::active_cell_iterator &cell,
-                    const Introspection<dim>                             &introspection,
-                    const LinearAlgebra::BlockVector                     &solution_vector,
-                    const bool                                            compute_strain_rate = true);
-
-        /**
-         * Function that returns the number of points at which
-         * the material model is to be evaluated.
-         */
-        unsigned int n_evaluation_points() const;
-
-        /**
-         * Function that returns if the caller requests an evaluation
-         * of the handed over @p property. This is optional, because calculating
-         * some properties can be more expensive than the other material
-         * model properties and not all are needed for all applications.
-         */
-        bool requests_property(const MaterialProperties::Property &property) const;
-
-        /**
-         * Vector with global positions where the material has to be evaluated
-         * in evaluate().
-         */
-        std::vector<Point<dim>> position;
-
-        /**
-         * Temperature values at the points given in the #position vector.
-         */
-        std::vector<double> temperature;
-
-        /**
-         * Pressure values at the points given in the #position vector.
-         */
-        std::vector<double> pressure;
-
-        /**
-         * Pressure gradients at the points given in the #position vector.
-         * This is important for the heating models.
-         */
-        std::vector<Tensor<1,dim>> pressure_gradient;
-
-        /**
-         * Velocity values at the points given in the #position vector.
-         * This value is mostly important in the case of determining
-         * whether material crossed a certain region (e.g. a phase boundary).
-         * The timestep that is needed for this check can be requested from
-         * SimulatorAccess.
-         */
-        std::vector<Tensor<1,dim>> velocity;
-
-        /**
-         * Values of the compositional fields at the points given in the
-         * #position vector: composition[i][c] is the compositional field c at
-         * point i.
-         */
-        std::vector<std::vector<double>> composition;
-
-        /**
-         * Strain rate at the points given in the #position vector. Only the
-         * viscosity may depend on these values. This std::vector can be set to
-         * size 0 if the viscosity is not needed.
-         *
-         * @note The strain rate is computed as $\varepsilon(\mathbf u)=\frac 12
-         * (\nabla \mathbf u + \nabla \mathbf u^T)$, regardless of whether the
-         * model is compressible or not. This is relevant since in some other
-         * contexts, the strain rate in the compressible case is computed as
-         * $\varepsilon(\mathbf u)=\frac 12 (\nabla \mathbf u + \nabla \mathbf
-         * u^T) - \frac 13 \nabla \cdot \mathbf u \mathbf 1$.
-         */
-        std::vector<SymmetricTensor<2,dim>> strain_rate;
-
-        /**
-         * Optional cell object that contains these quadrature
-         * points. This allows for evaluating properties at the cell vertices
-         * and interpolating to the quadrature points, or to query the cell for
-         * material ids, neighbors, or other information that is not available
-         * solely from the locations. Note that not all calling functions will
-         * set this cell iterator. In these cases it will be an invalid iterator
-         * constructed using the default constructor, so make sure that your
-         * material model either fails
-         * with a proper error message, or provides an alternative calculation for
-         * these cases. You can detect this with
-         * @code
-         * if (in.current_cell.state() == IteratorState::valid)
-         * @endcode
-         */
-        typename DoFHandler<dim>::active_cell_iterator current_cell;
-
-        /**
-         * A member variable that stores which properties the material model
-         * should compute. You can check specific properties using
-         * the requests_property function and usually do not need to access
-         * this variable directly. For documentation on the internal storage
-         * of this variable see the documentation for MaterialProperties::Property.
-         */
-        MaterialProperties::Property requested_properties;
-
-        /**
-         * Given an additional material model input class as explicitly specified
-         * template argument, returns a pointer to this additional material model
-         * input object if it is used in the current simulation. Ownership
-         * of the pointed-to object remains with the current object.
-         *
-         * If the input does not exist, i.e., if there is no additional input
-         * object of the specified type, then a null pointer is returned.
-         */
-        template <class AdditionalInputType>
-        AdditionalInputType *get_additional_input();
-
-        /**
-         * A version of the previous function that is used when the object
-         * being queried is `const`.
-         */
-        template <class AdditionalInputType>
-        const AdditionalInputType *get_additional_input() const;
-
-        /**
-         * Vector of shared pointers to additional material model input
-         * objects that can be added to MaterialModelInputs. By default,
-         * no inputs are added.
-         */
-        std::vector<std::unique_ptr<AdditionalMaterialInputs<dim>>> additional_inputs;
-    };
-
-
-    // Forward declaration:
-    template <int dim>
-    class AdditionalMaterialOutputs;
-
-
-    /**
-     * A data structure with the output field of the
-     * MaterialModel::Interface::evaluate() function. The vectors are the
-     * values at the different positions given by
-     * MaterialModelInputs::position.
-     */
-    template <int dim>
-    class MaterialModelOutputs
-    {
-      public:
-        /**
-         * Constructor. Initialize the various arrays of this structure with the
-         * given number of quadrature points and (finite element) components.
-         *
-         * @param n_points The number of quadrature points for which input
-         * quantities will be provided.
-         * @param n_comp The number of vector quantities (in the order in which
-         * the Introspection class reports them) for which input will be
-         * provided.
-         */
-        MaterialModelOutputs (const unsigned int n_points,
-                              const unsigned int n_comp);
-
-        /**
-         * Copy constructor. This constructor copies all data members of the
-         * source object except for the additional output data (of type
-         * AdditionalMaterialOutputs) pointers, stored in the
-         * `source.additional_outputs` member variable.
-         *
-         * This is because these pointers can not be copied (they
-         * are unique to the @p source object). Since they can also not
-         * be recreated without the original code that created these objects
-         * in the first place, this constructor throws an exception if the
-         * @p source object had any additional output data objects
-         * associated with it.
-         */
-        MaterialModelOutputs (const MaterialModelOutputs &source);
-
-        /**
-         * Move constructor. This constructor simply moves all members.
-         */
-        MaterialModelOutputs (MaterialModelOutputs &&)  noexcept = default;
-
-        /**
-         * Copy operator. Copying these objects is expensive, and consequently
-         * prohibited.
-         */
-        MaterialModelOutputs &operator= (const MaterialModelOutputs &source) = delete;
-
-        /**
-         * Move operator.
-         */
-        MaterialModelOutputs &operator= (MaterialModelOutputs &&)  noexcept = default;
-
-        /**
-         * Function that returns the number of points at which
-         * the material model is to be evaluated.
-         */
-        unsigned int n_evaluation_points() const;
-
-        /**
-         * Viscosity $\eta$ values at the given positions.
-         */
-        std::vector<double> viscosities;
-
-        /**
-         * Density values at the given positions.
-         */
-        std::vector<double> densities;
-
-        /**
-         * Thermal expansion coefficients at the given positions. It is defined
-         * as $\alpha = - \frac{1}{\rho} \frac{\partial\rho}{\partial T}$
-         */
-        std::vector<double> thermal_expansion_coefficients;
-
-        /**
-         * Specific heat at the given positions.
-         */
-        std::vector<double> specific_heat;
-
-        /**
-         * Thermal conductivity at the given positions.
-         */
-        std::vector<double> thermal_conductivities;
-
-        /**
-         * Compressibility at the given positions. The compressibility is defined
-         * as $\kappa = \frac{1}{\rho} \frac{\partial\rho}{\partial p}$.
-         */
-        std::vector<double> compressibilities;
-
-        /**
-         * The product of the change of entropy $\Delta S$ at a phase transition
-         * and the derivative of the phase function $X=X(p,T,\mathfrak c,\mathbf
-         * x)$ with regard to pressure at the given positions.
-         */
-        std::vector<double> entropy_derivative_pressure;
-
-        /**
-         * The product of (minus) the change of entropy $-\Delta S$ at a phase
-         * transition and the derivative of the phase function
-         * $X=X(p,T,\mathfrak c,\mathbf x)$ with regard to temperature at the
-         * given positions.
-         */
-        std::vector<double> entropy_derivative_temperature;
-
-        /**
-         * Change in composition due to chemical reactions at the given
-         * positions. The term reaction_terms[i][c] is the change in
-         * compositional field c at point i.
-         *
-         * The mental model behind prescribing actual changes in composition
-         * rather than reaction rates is that we assume that there is always an
-         * equilibrium between the compositional fields (because the time scale
-         * of reactions is normally much shorter than that of convection), so
-         * the quantity returned by this function is an actual change in the
-         * amount of material, which is added to or subtracted from the current
-         * value of the compositional field, and NOT a reaction rate. The idea
-         * is, that in dependence of temperature, pressure, position and the
-         * compositional fields themselves an equilibrium can be calculated, and
-         * the difference between the current value and the equilibrium can be
-         * added to the respective compositional field.
-         *
-         * For mass conservation it should ALWAYS be checked that what is
-         * subtracted from one field is added to another field (and the other
-         * way round) and that one never subtracts more than the actual value of
-         * a field (so it does not get negative).
-         *
-         * This function has a default implementation that sets the reaction
-         * term to zero (assuming no reactions).
-         *
-         * @note In cases where one has slow chemical reactions (or cases where
-         * compositional fields are used to track quantities different than
-         * actual compositions, for example accumulated strains in damage
-         * models), models are formulated as differential equations with right
-         * hand sides, not as instantaneous equations. In such cases, the
-         * reaction terms (i.e., the incremental additions to the previous
-         * state) are usually of the form reaction rate times time step size. To
-         * implement something like this, derive your material model from
-         * SimulatorAccess so you can query the time step used by the simulator
-         * in order to compute the reaction increment.
-         */
-        std::vector<std::vector<double>> reaction_terms;
-
-        /**
-         * Vector of shared pointers to additional material model output
-         * objects that can then be added to MaterialModelOutputs. By default,
-         * no outputs are added.
-         */
-        std::vector<std::unique_ptr<AdditionalMaterialOutputs<dim>>> additional_outputs;
-
-        /**
-         * Given an additional material model output class as explicitly specified
-         * template argument, returns a pointer to this additional material model
-         * output object if it is used in the current simulation.
-         * The output can then be filled in the MaterialModels::Interface::evaluate()
-         * function. If the output does not exist, a null pointer is returned.
-         */
-        template <class AdditionalOutputType>
-        AdditionalOutputType *get_additional_output();
-
-        /**
-         * Constant version of get_additional_output() returning a const pointer.
-         */
-        template <class AdditionalOutputType>
-        const AdditionalOutputType *get_additional_output() const;
-
-        /**
-         * Steal the additional outputs from @p other. The destination (@p
-         * this), is expected to currently have no additional outputs.
-         */
-        void move_additional_outputs_from(MaterialModelOutputs<dim> &other);
-    };
-
-
-
-    /**
-     * A namespace in which we define how material model outputs should be
-     * averaged on each cell.
-     *
-     * Material models compute output quantities such as the viscosity, the
-     * density, etc, based on pressures, temperatures, composition, and
-     * location at every quadrature point. For some models, these values vary
-     * drastically from quadrature point to quadrature point, and this creates
-     * difficulties both for the stability of the discretization as well as
-     * for the linear solvers. Some of this can be ameliorated by averaging
-     * values on every cell, although this of course reduces the ideal
-     * convergence order. This namespace defines the means to achieve such
-     * averaging.
-     */
-    namespace MaterialAveraging
-    {
-      /**
-       * An enum to define what kind of averaging operations are implemented.
-       * These are:
-       *
-       * - No averaging, i.e., leave the values as they were provided by the
-       * material model.
-       *
-       * - Arithmetic averaging: Set the values of each output quantity at
-       * every quadrature point to \f[ \bar x = \frac 1Q \sum_{q=1}^Q x_q \f]
-       * where $x_q$ are the values at the $Q$ quadrature points.
-       *
-       * - Harmonic averaging: Set the values of each output quantity at every
-       * quadrature point to \f[ \bar x = \left(\frac 1Q \sum_{q=1}^Q
-       * \frac{1}{x_q}\right)^{-1} \f] where $x_q$ are the values at the $Q$
-       * quadrature points.
-       *
-       * - Geometric averaging: Set the values of each output quantity at
-       * every quadrature point to \f[ \bar x = \left(\prod_{q=1}^Q
-       * x_q\right)^{1/Q} \f] where $x_q$ are the values at the $Q$ quadrature
-       * points.
-       *
-       * - Pick largest: Set the values of each output quantity at every
-       * quadrature point to \f[ \bar x = \max_{1\le q\le Q} x_q \f] where
-       * $x_q$ are the values at the $Q$ quadrature points.
-       *
-       * - Project to $Q_1$: This operation takes the values at the quadrature
-       * points and computes the best bi- or trilinear approximation for them.
-       * In other words, it projects the values into the $Q_1$ finite element
-       * space. It then re-evaluate this projection at the quadrature points.
-       *
-       * - Log average: Set the values of each output quantity at every
-       * quadrature point to \f[ \bar x = {10}^{\frac 1Q \sum_{q=1}^Q \log_{10} x_q} \f]
-       * where $x_q$ are the values at the $Q$ quadrature points.
-       *
-       * - Harmonic average only viscosity, Geometric  average only viscosity
-       * and project to Q1 only viscosity: Like harmonic averaging, geometric
-       * averaging and project to Q1, but only applied to the viscosity.
-       */
-      enum AveragingOperation
-      {
-        none,
-        arithmetic_average,
-        harmonic_average,
-        geometric_average,
-        pick_largest,
-        project_to_Q1,
-        log_average,
-        harmonic_average_only_viscosity,
-        geometric_average_only_viscosity,
-        project_to_Q1_only_viscosity,
-        default_averaging
-      };
-
-
-      /**
-       * Return a string that represents the various averaging options laid
-       * out above and that can be used in the declaration of an input
-       * parameter. The options are separated by "|" so that they can be used
-       * in a dealii::Patterns::Selection argument.
-       */
-      std::string get_averaging_operation_names ();
-
-      /**
-       * Parse a string representing one of the options returned by
-       * get_averaging_operation_names(), and return the corresponding
-       * AveragingOperation value.
-       */
-      AveragingOperation parse_averaging_operation_name (const std::string &s);
-
-      /**
-       * Given the averaging @p operation, a description of where the
-       * quadrature points are located on the given cell, and a mapping,
-       * perform this operation on all elements of the @p values structure.
-       */
-      template <int dim>
-      void average (const AveragingOperation operation,
-                    const typename DoFHandler<dim>::active_cell_iterator &cell,
-                    const Quadrature<dim>         &quadrature_formula,
-                    const Mapping<dim>            &mapping,
-                    const MaterialProperties::Property &requested_properties,
-                    MaterialModelOutputs<dim>     &values_out);
-
-      /**
-       * Do the requested averaging operation for one array. The
-       * projection matrix argument is only used if the operation
-       * chosen is project_to_Q1
-       */
-      void average_property (const AveragingOperation  operation,
-                             const FullMatrix<double>      &projection_matrix,
-                             const FullMatrix<double>      &expansion_matrix,
-                             std::vector<double>           &values_out);
-    }
-
-
-    /**
-     * Some material and heating models need more than just the basic material
-     * model inputs defined in the MaterialModel::MaterialModelInputs
-     * class. These additions are either for more complicated physics
-     * than the basic flow model usually solved by ASPECT (for example
-     * to support the melt migration functionality), or other derived
-     * quantities.
-     *
-     * Rather than litter the MaterialModelInputs class with additional
-     * fields that are not universally used, we use a mechanism by
-     * which MaterialModelInputs can store a set of pointers to
-     * "additional" input objects that store information such as
-     * mentioned above. These pointers are all to objects whose types
-     * are derived from the current class.
-     *
-     * The format of the additional quantities defined in derived classes
-     * should be the same as for MaterialModel::MaterialModelInputs.
-     */
-    template <int dim>
-    class AdditionalMaterialInputs
-    {
-      public:
-        /**
-         * Destructor. This destructor is made `virtual` to ensure that
-         * derived classes can be accessed via a pointer-to-base-class.
-         */
-        virtual ~AdditionalMaterialInputs() = default;
-
-        /**
-         * Fill the additional inputs. Each additional input
-         * has to implement their own version of this function.
-         */
-        virtual void
-        fill (const LinearAlgebra::BlockVector &solution,
-              const FEValuesBase<dim>          &fe_values,
-              const Introspection<dim>         &introspection) = 0;
-    };
-
-
-    /**
-     * Some material models can compute more than just the basic material
-     * coefficients defined in the MaterialModel::MaterialModelOutputs
-     * class. These additions are either for more complicated physics
-     * than the basic flow model usually solved by ASPECT (for example
-     * to support the melt migration functionality), or other derived
-     * quantities that are not coefficients in any of the equations
-     * ASPECT solves but that may be of interest for visualization
-     * (for example seismic velocities).
-     *
-     * Rather than litter the MaterialModelOutputs class with additional
-     * fields that are not universally used, we use a mechanism by
-     * which MaterialModelOutputs can store a set of pointers to
-     * "additional" output objects that store information such as
-     * mentioned above. These pointers are all to objects whose types
-     * are derived from the current class.
-     *
-     * If an implementation of the MaterialModel::Interface::evaluate()
-     * in a class derived from MaterialModel::Interface encounters
-     * a MaterialModelOutputs object that has these pointers set
-     * (and if it recognizes the type of the object pointed to),
-     * it should fill this set of additional output quantities.
-     *
-     * The format of the additional quantities defined in derived classes
-     * should be the same as for MaterialModel::MaterialModelOutputs.
-     */
-    template <int dim>
-    class AdditionalMaterialOutputs
-    {
-      public:
-        /**
-         * Destructor. Made virtual to enable storing pointers to this
-         * base class.
-         */
-        virtual ~AdditionalMaterialOutputs() = default;
-
-        virtual void average (const MaterialAveraging::AveragingOperation /*operation*/,
-                              const FullMatrix<double>  &/*projection_matrix*/,
-                              const FullMatrix<double>  &/*expansion_matrix*/)
-        {}
-    };
-
-
-    /**
-     * Some material models can compute things that are not used anywhere
-     * in the physics modules of ASPECT, but that may be of interest for
-     * visualization purposes. An example would be a material model that can
-     * compute seismic velocities -- these are irrelevant to the rest of
-     * ASPECT, but would be nice to have for postprocessing.
-     *
-     * This class is a base class for material models to provide this kind
-     * of information. It follows the scheme laid out by
-     * AdditionalMaterialModelOutputs but also provides an interface by which
-     * consumers of these objects (e.g., the
-     * Postprocess::Visualization::NamedAdditionalOutputs class) can query the
-     * names and values material models have put into these additional
-     * outputs. (Because every material model can decide by itself which --
-     * if any -- additional outputs it produces, there are no standard
-     * names. Consequently, the material models have to describe what
-     * values and how many values they can produce.)
-     *
-     * This class is then this base class for additional named material model outputs
-     * to be added to the MaterialModel::MaterialModelOutputs structure.
-     */
-    template <int dim>
-    class NamedAdditionalMaterialOutputs : public AdditionalMaterialOutputs<dim>
-    {
-      public:
-        /**
-         * Base constructor.
-         *
-         * @param output_names A list of names for the additional output variables
-         *   this object will store. The length of the list also indicates
-         *   how many additional output variables objects of derived classes
-         *   will store.
-         */
-        NamedAdditionalMaterialOutputs(const std::vector<std::string> &output_names);
-
-        /**
-         * Constructor for case where outputs are stored for a number of points.
-         *
-         * @param output_names A list of names for the additional output variables
-         *   this object will store. The length of the list also indicates
-         *   how many additional output variables objects of derived classes
-         *   will store.
-         * @param n_points The number of points for which to store each of the
-         *   output variables.
-         */
-        NamedAdditionalMaterialOutputs(const std::vector<std::string> &output_names,
-                                       const unsigned int n_points);
-
-        /**
-         * Destructor.
-         */
-        ~NamedAdditionalMaterialOutputs() override;
-
-        /**
-         * Return a reference to the vector of names of the additional
-         * outputs.
-         */
-        const std::vector<std::string> &get_names() const;
-
-        /**
-         * Given an index as input argument, return a reference the to vector of
-         * values of the additional output with that index.
-         */
-        virtual std::vector<double> get_nth_output(const unsigned int idx) const;
-
-        void average (const MaterialAveraging::AveragingOperation /*operation*/,
-                      const FullMatrix<double>  &/*projection_matrix*/,
-                      const FullMatrix<double>  &/*expansion_matrix*/) override
-        {}
-
-
-        /**
-         * Values for the outputs at a set of evaluation points
-         * output_values[i][j] is the value of output i at point j.
-         */
-        std::vector<std::vector<double>> output_values;
-
-      private:
-        const std::vector<std::string> names;
-    };
-
-
-    /**
-     * Additional output fields for the seismic velocities to be added to
-     * the MaterialModel::MaterialModelOutputs structure and filled in the
-     * MaterialModel::Interface::evaluate() function.
-     */
-    template <int dim>
-    class SeismicAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        SeismicAdditionalOutputs(const unsigned int n_points);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * Seismic s-wave velocities at the evaluation points passed to
-         * the instance of MaterialModel::Interface::evaluate() that fills
-         * the current object.
-         */
-        std::vector<double> vs;
-
-        /**
-         * Seismic p-wave velocities at the evaluation points passed to
-         * the instance of MaterialModel::Interface::evaluate() that fills
-         * the current object.
-         */
-        std::vector<double> vp;
-    };
-
-
-    /**
-     * Additional output fields for reaction rates to be added to
-     * the MaterialModel::MaterialModelOutputs structure and filled in the
-     * MaterialModel::Interface::evaluate() function.
-     *
-     * These reaction rates are only used if the "operator splitting" solver scheme
-     * option is enabled, which decouples the reactions between compositional
-     * fields from the advection, so that different time step sizes can be used.
-     * In this case, the reaction rates are used in addition to (and independent
-     * from) any reaction_terms that a material model defines, which are assembled
-     * as usual.
-     * By default, the reaction rates are initialized with quiet_NaNs, and if
-     * "operator splitting" is not enabled, these values are not used, and they
-     * are expected to either remain at that value, or to not be created at all.
-     *
-     * In contrast to the reaction_terms, which are actual changes in composition
-     * rather than reaction rates, and assume equilibrium between the compositional
-     * fields, the reaction_rates defined here allow for reaction processes that
-     * happen on shorter time scales than the advection, and disequilibrium reactions.
-     */
-    template <int dim>
-    class ReactionRateOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        ReactionRateOutputs (const unsigned int n_points,
-                             const unsigned int n_comp);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * Reaction rates for all compositional fields at the evaluation points
-         * that are passed to the instance of MaterialModel::Interface::evaluate()
-         * that fills the current object.
-         * reaction_rates[q][c] is the reaction rate at the evaluation point q
-         * for the compositional field with the index c.
-         */
-        std::vector<std::vector<double>> reaction_rates;
-    };
-
-
-
-    /**
-     * Additional output fields for the phase with the largest fraction
-     * to be added to the MaterialModel::MaterialModelOutputs structure
-     * and filled in the MaterialModel::evaluate() function.
-     */
-    template <int dim>
-    class PhaseOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        PhaseOutputs(const unsigned int n_points);
-    };
-
-
-
-    /**
-     * Additional output fields for prescribed field outputs to be added to
-     * the MaterialModel::MaterialModelOutputs structure and filled in the
-     * MaterialModel::Interface::evaluate() function.
-     *
-     * This structure is used if for one of the compositional fields employed
-     * by a simulation, the advection scheme "prescribed field" is selected.
-     * (See Parameters::AdvectionFieldMethod for more information.)
-     * Then, while updating the compositional field, a structure of this
-     * type is created, given to the material model, and the material model
-     * outputs will finally be interpolated onto the corresponding
-     * compositional field.
-     *
-     * @note This structure always has as many prescribed field
-     * outputs as there are compositional fields, even if not all of them
-     * are using the "prescribed field" method. It is the responsibility
-     * of the individual material models to fill the correct entries.
-     */
-    template <int dim>
-    class PrescribedFieldOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        PrescribedFieldOutputs (const unsigned int n_points,
-                                const unsigned int n_comp);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * Prescribed field outputs for all compositional fields at the evaluation points
-         * that are passed to the instance of MaterialModel::Interface::evaluate()
-         * that fills the current object.
-         * prescribed_field_outputs[q][c] is the prescribed field output at the evaluation point q
-         * for the compositional field with the index c.
-         */
-        std::vector<std::vector<double>> prescribed_field_outputs;
-    };
-
-    /**
-     * Additional output fields for prescribed temperature outputs to be added to
-     * the MaterialModel::MaterialModelOutputs structure and filled in the
-     * MaterialModel::Interface::evaluate() function.
-     *
-     * This structure is used if the temperature field is solved using the
-     * advection scheme "prescribed field".
-     * (See Parameters::AdvectionFieldMethod for more information.)
-     * Then, while updating the temperature field, a structure of this
-     * type is created, given to the material model, and the material model
-     * outputs will finally be interpolated onto the
-     * temperature field.
-     */
-    template <int dim>
-    class PrescribedTemperatureOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        PrescribedTemperatureOutputs (const unsigned int n_points);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * Prescribed field outputs for the temperature field at the evaluation points
-         * that are passed to the instance of MaterialModel::Interface::evaluate()
-         * that fills the current object.
-         * prescribed_temperature_outputs[q] is the prescribed field output at the evaluation point q
-         * for the temperature.
-         */
-        std::vector<double> prescribed_temperature_outputs;
-    };
-
-    /**
-     * A class for additional output fields to be added to the RHS of the
-     * Stokes system, which can be attached to the
-     * MaterialModel::MaterialModelOutputs structure and filled in the
-     * MaterialModel::Interface::evaluate() function.
-     */
-    template <int dim>
-    class AdditionalMaterialOutputsStokesRHS: public AdditionalMaterialOutputs<dim>
-    {
-      public:
-        AdditionalMaterialOutputsStokesRHS(const unsigned int n_points)
-          : rhs_u(n_points), rhs_p(n_points), rhs_melt_pc(n_points)
-        {}
-
-        ~AdditionalMaterialOutputsStokesRHS() override
-          = default;
-
-        void average (const MaterialAveraging::AveragingOperation /*operation*/,
-                      const FullMatrix<double>  &/*projection_matrix*/,
-                      const FullMatrix<double>  &/*expansion_matrix*/) override
-        {
-          // TODO: not implemented
-        }
-
-        /**
-         * Force tensor on the right-hand side for the conservation of
-         * momentum equation (first part of the Stokes equation) in each
-         * quadrature point.
-         */
-        std::vector<Tensor<1,dim>> rhs_u;
-
-        /**
-         * Force value for the conservation of mass equation (second Stokes
-         * equation) in each quadrature point.
-         */
-        std::vector<double> rhs_p;
-
-        /**
-         * Force for the compaction pressure equation (when using melt
-         * transport) in each quadrature point.
-         */
-        std::vector<double> rhs_melt_pc;
-    };
-
-
-
-    /**
-     * An AdditionalOutput that allows prescribing a dilation applied to the
-     * Stokes solution.
-     *
-     * This is typically used in a MaterialModel to add dilation when plastic
-     * failure occurs as motivated by ChoiPeterson2015. If this output
-     * (denoted by R below) is present and enable_prescribed_dilation==true
-     * the following terms will be assembled:
-     *
-     * 1) $\int - (R,q)$ to the conservation of mass equation, creating
-     *    $-(div u,q) = -(R,q)$.
-     * 2) $\int - 2.0 / 3.0 * eta * (R, div v)$ to the RHS of the momentum
-     *    equation (if the model is incompressible), otherwise this term is
-     *    already present on the left side.
-     */
-    template <int dim>
-    class PrescribedPlasticDilation : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        /**
-         * Constructor
-         */
-        explicit PrescribedPlasticDilation (const unsigned int n_points);
-
-        /**
-         * Function for NamedAdditionalMaterialOutputs interface
-         */
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * A scalar value per evaluation point that specifies the prescribed dilation
-         * in that point.
-         */
-        std::vector<double> dilation;
-    };
-
-
-
-    /**
-     * A class for an elastic force term to be added to the RHS of the
-     * Stokes system, which can be attached to the
-     * MaterialModel::MaterialModelOutputs structure and filled in the
-     * MaterialModel::Interface::evaluate() function.
-     */
-    template <int dim>
-    class ElasticOutputs: public AdditionalMaterialOutputs<dim>
-    {
-      public:
-        ElasticOutputs(const unsigned int n_points)
-          : elastic_force(n_points, numbers::signaling_nan<SymmetricTensor<2,dim>>())
-          , viscoelastic_strain_rate(n_points, numbers::signaling_nan<SymmetricTensor<2,dim>>())
-        {}
-
-        ~ElasticOutputs() override
-          = default;
-
-        void average (const MaterialAveraging::AveragingOperation operation,
-                      const FullMatrix<double>  &/*projection_matrix*/,
-                      const FullMatrix<double>  &/*expansion_matrix*/) override
-        {
-          AssertThrow(operation == MaterialAveraging::AveragingOperation::none,ExcNotImplemented());
-          return;
-        }
-
-        /**
-         * Force tensor (elastic terms) on the right-hand side for the conservation of
-         * momentum equation (first part of the Stokes equation) in each
-         * quadrature point.
-         */
-        std::vector<SymmetricTensor<2,dim>> elastic_force;
-
-        /**
-         * Strain rate tensor that includes the contribution of elastic shear, which is
-         * required by the Newton solver.
-         */
-        std::vector<SymmetricTensor<2,dim>> viscoelastic_strain_rate;
-    };
-
-
-
-    /**
-     * Additional output fields for the enthalpy change upon melting or
-     * freezing to be added to the MaterialModel::MaterialModelOutputs
-     * structure and filled in the MaterialModel::Interface::evaluate()
-     * function.
-     * These outputs are needed in heating models that compute the latent
-     * heat of melting/freezing based on the material properties in the
-     * material models (which is required for thermodynamically consistent
-     * models).
-     */
-    template <int dim>
-    class EnthalpyOutputs : public AdditionalMaterialOutputs<dim>
-    {
-      public:
-        EnthalpyOutputs(const unsigned int n_points)
-          : enthalpies_of_fusion(n_points, numbers::signaling_nan<double>())
-        {}
-
-        virtual ~EnthalpyOutputs()
-          = default;
-
-        void average (const MaterialAveraging::AveragingOperation operation,
-                      const FullMatrix<double>  &/*projection_matrix*/,
-                      const FullMatrix<double>  &/*expansion_matrix*/) override
-        {
-          AssertThrow(operation == MaterialAveraging::AveragingOperation::none,ExcNotImplemented());
-          return;
-        }
-
-        /**
-         * Enthalpies of fusion, describing the amount of heat required to
-         * melt/solidify the material. These values are used when computing
-         * latent heat effects.
-         */
-        std::vector<double> enthalpies_of_fusion;
-    };
-
-
-
-    /**
-     * A base class for parameterizations of material models. Classes derived
-     * from this class will need to implement functions that provide material
-     * parameters such as the viscosity, density, etc, typically as a function
-     * of position, temperature and pressure at that location.
-     *
-     * Implementing a material model requires you to override evaluate() and fill the output
-     * argument struct instead of implementing the functions viscosity(),
-     * density(), etc.. In this case, all other functions are being ignored.
-     *
-     * In all cases, model_dependence values, is_compressible()
-     * need to be implemented.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * A typedef to import the MaterialModelInputs name into the current
-         * class. This typedef primarily exists as a backward compatibility
-         * measure given that the referenced structure used to be a member of
-         * the current class.
-         */
-        using MaterialModelInputs = MaterialModel::MaterialModelInputs<dim>;
-
-        /**
-         * A typedef to import the MaterialModelOutputs name into the current
-         * class. This typedef primarily exists as a backward compatibility
-         * measure given that the referenced structure used to be a member of
-         * the current class.
-         */
-        using MaterialModelOutputs = MaterialModel::MaterialModelOutputs<dim>;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return a structure that describes how each of the model's
-         * output variables (such as viscosity, density, etc) depend
-         * on the input variables pressure, temperature, strain rate,
-         * and compositional fields.
-         */
-        const NonlinearDependence::ModelDependence &
-        get_model_dependence () const;
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the
-         * continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        virtual bool is_compressible () const = 0;
-        /**
-         * @}
-         */
-
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        virtual
-        void evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
-                       MaterialModel::MaterialModelOutputs<dim> &out) const = 0;
-
-        /**
-         * If this material model can produce additional named outputs
-         * that are derived from NamedAdditionalOutputs, create them in here.
-         * By default, this does nothing.
-         */
-        virtual
-        void
-        create_additional_named_outputs (MaterialModelOutputs &outputs) const;
-
-
-        /**
-         * Fill the additional material model inputs that have been attached
-         * by the individual heating or material models in the
-         * create_additional_material_model_inputs function.
-         * This is done by looping over all material model inputs that have
-         * been created and calling their respective member functions.
-         */
-        virtual
-        void
-        fill_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &input,
-                                              const LinearAlgebra::BlockVector        &solution,
-                                              const FEValuesBase<dim>                 &fe_values,
-                                              const Introspection<dim>                &introspection) const;
-
-      protected:
-        /**
-         * A structure that describes how each of the model's
-         * output variables (such as viscosity, density, etc) depend
-         * on the input variables pressure, temperature, strain rate,
-         * and compositional fields.
-         *
-         * The constructor of this class calls the default
-         * constructor of this member variable which in turn
-         * initializes the object to invalid values. Derived classes
-         * then need to fill it either in their constructor (if they
-         * already know the correct dependencies at that time) or
-         * at the end of their parse_parameter() functions where
-         * they know the correct material parameters they will
-         * use.
-         */
-        NonlinearDependence::ModelDependence model_dependence;
-    };
-
-    /**
-     * Register a material model so that it can be selected from the parameter
-     * file.
-     *
-     * @param name A string that identifies the material model
-     * @param description A text description of what this model does and that
-     * will be listed in the documentation of the parameter file.
-     * @param declare_parameters_function A pointer to a function that can be
-     * used to declare the parameters that this material model wants to read
-     * from input files.
-     * @param factory_function A pointer to a function that can create an
-     * object of this material model.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    void
-    register_material_model (const std::string &name,
-                             const std::string &description,
-                             void (*declare_parameters_function) (ParameterHandler &),
-                             std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-    /**
-     * A function that given the name of a model returns a pointer to an
-     * object that describes it. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The material model object returned is not yet initialized and has not
-     * read its runtime parameters yet.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_material_model (const std::string &model_name);
-
-
-    /**
-     * A function that reads the name of a model from the parameter object
-     * and then returns a pointer to an
-     * object that describes this model. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The material model object returned is not yet initialized and has not
-     * read its runtime parameters yet.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_material_model (ParameterHandler &prm);
-
-
-    /**
-     * Return a string that consists of the names of material models that can
-     * be selected. These names are separated by a vertical line '|' so
-     * that the string can be an input to the deal.II classes
-     * Patterns::Selection or Patterns::MultipleSelection.
-     */
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ();
-
-
-    /**
-     * Declare the runtime parameters of the registered material models.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm);
-
-
-
-    /**
-     * For the current plugin subsystem, write a connection graph of all of the
-     * plugins we know about, in the format that the
-     * programs dot and neato understand. This allows for a visualization of
-     * how all of the plugins that ASPECT knows about are interconnected, and
-     * connect to other parts of the ASPECT code.
-     *
-     * @param output_stream The stream to write the output to.
-     */
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &output_stream);
-
-
-
-// --------------------- template function definitions ----------------------------------
-
-    template <int dim>
-    template <class AdditionalInputType>
-    AdditionalInputType *MaterialModelInputs<dim>::get_additional_input()
-    {
-      for (unsigned int i=0; i<additional_inputs.size(); ++i)
-        {
-          AdditionalInputType *result = dynamic_cast<AdditionalInputType *> (additional_inputs[i].get());
-          if (result)
-            return result;
-        }
-      return nullptr;
-    }
-
-
-    template <int dim>
-    template <class AdditionalInputType>
-    const AdditionalInputType *MaterialModelInputs<dim>::get_additional_input() const
-    {
-      for (unsigned int i=0; i<additional_inputs.size(); ++i)
-        {
-          const AdditionalInputType *result = dynamic_cast<const AdditionalInputType *> (additional_inputs[i].get());
-          if (result)
-            return result;
-        }
-      return nullptr;
-    }
-
-
-    template <int dim>
-    template <class AdditionalOutputType>
-    AdditionalOutputType *MaterialModelOutputs<dim>::get_additional_output()
-    {
-      for (unsigned int i=0; i<additional_outputs.size(); ++i)
-        {
-          AdditionalOutputType *result = dynamic_cast<AdditionalOutputType *> (additional_outputs[i].get());
-          if (result)
-            return result;
-        }
-      return nullptr;
-    }
-
-
-    template <int dim>
-    template <class AdditionalOutputType>
-    const AdditionalOutputType *MaterialModelOutputs<dim>::get_additional_output() const
-    {
-      for (unsigned int i=0; i<additional_outputs.size(); ++i)
-        {
-          const AdditionalOutputType *result = dynamic_cast<const AdditionalOutputType *> (additional_outputs[i].get());
-          if (result)
-            return result;
-        }
-      return nullptr;
-    }
-
-
-    template <int dim>
-    void MaterialModelOutputs<dim>::move_additional_outputs_from(MaterialModelOutputs<dim> &other)
-    {
-      Assert(this->additional_outputs.empty(), ExcMessage("Destination of move needs to be empty!"));
-      this->additional_outputs = std::move(other.additional_outputs);
-    }
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a material model, register it with the functions that can declare
-     * their parameters and create these objects.
-     *
-     * @ingroup MaterialModels
-     */
-#define ASPECT_REGISTER_MATERIAL_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_MATERIAL_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::MaterialModel::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::MaterialModel::register_material_model<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::MaterialModel::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::MaterialModel::register_material_model<3>, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/material_model/latent_heat.h.bak b/include/aspect/material_model/latent_heat.h.bak
deleted file mode 100644
index 2646a5bc2e8..00000000000
--- a/include/aspect/material_model/latent_heat.h.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-  Copyright (C) 2013 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_latent_heat_h
-#define _aspect_material_model_latent_heat_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that implements a standard approximation of the latent
-     * heat terms following Christensen \& Yuen, 1986. The change of entropy
-     * is calculated as $Delta S = \gamma \frac{\Delta\rho}{\rho^2}$ with the
-     * Clapeyron slope $\gamma$ and the density change $\Delta\rho$ of the
-     * phase transition being input parameters. This model employs an analytic
-     * phase function in the form $X=\frac{1}{2} \left( 1 + \tanh \left( \frac{\Delta
-     * p}{\Delta p_0} \right) \right)$ with $\Delta p = p - p_transition -
-     * \gamma \left( T - T_transition \right)$ and $\Delta p_0$ being the
-     * pressure difference over the width of the phase transition (specified
-     * as input parameter).
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class LatentHeat : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Evaluate material properties.
-         */
-        void evaluate(const MaterialModelInputs<dim> &in,
-                      MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        double reference_rho;
-        double reference_T;
-        double eta;
-        double composition_viscosity_prefactor;
-        double thermal_viscosity_exponent;
-        double thermal_alpha;
-        double reference_specific_heat;
-        double reference_compressibility;
-        double maximum_viscosity;
-        double minimum_viscosity;
-
-        /**
-         * The thermal conductivity.
-         */
-        double k_value;
-
-        double compositional_delta_rho;
-
-        // list of depth (or pressure), width and Clapeyron slopes
-        // for the different phase transitions
-        std::vector<double> density_jumps;
-        std::vector<int> transition_phases;
-        std::vector<double> phase_prefactors;
-
-        MaterialUtilities::PhaseFunction<dim> phase_function;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/latent_heat_melt.h.bak b/include/aspect/material_model/latent_heat_melt.h.bak
deleted file mode 100644
index 71770705bc7..00000000000
--- a/include/aspect/material_model/latent_heat_melt.h.bak
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
-  Copyright (C) 2013 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_latent_heat_melt_h
-#define _aspect_material_model_latent_heat_melt_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/melt.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that implements latent heat of melting for two
-     * materials: peridotite and pyroxenite. The density and thermal
-     * expansivity depend on the melt fraction.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class LatentHeatMelt : public MaterialModel::Interface<dim>,
-      public MaterialModel::MeltFractionModel<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                             std::vector<double> &melt_fractions) const override;
-
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        double reference_rho;
-        double reference_T;
-        double eta;
-        double composition_viscosity_prefactor;
-        double thermal_viscosity_exponent;
-        double thermal_alpha;
-        double melt_thermal_alpha;
-        double reference_specific_heat;
-        double reference_compressibility;
-
-        /**
-         * The thermal conductivity.
-         */
-        double k_value;
-
-        double compositional_delta_rho;
-
-        /**
-         * Parameters for anhydrous melting of peridotite after Katz, 2003
-         */
-
-        // for the solidus temperature
-        double A1;   // °C
-        double A2; // °C/Pa
-        double A3; // °C/(Pa^2)
-
-        // for the lherzolite liquidus temperature
-        double B1;   // °C
-        double B2;   // °C/Pa
-        double B3; // °C/(Pa^2)
-
-        // for the liquidus temperature
-        double C1;   // °C
-        double C2;  // °C/Pa
-        double C3; // °C/(Pa^2)
-
-        // for the reaction coefficient of pyroxene
-        double r1;     // cpx/melt
-        double r2;     // cpx/melt/GPa
-        double M_cpx;  // mass fraction of pyroxene
-
-        // melt fraction exponent
-        double beta;
-
-        // entropy change upon melting
-        double peridotite_melting_entropy_change;
-
-        /**
-         * Parameters for melting of pyroxenite after Sobolev et al., 2011
-         */
-
-        // for the melting temperature
-        double D1;    // °C
-        double D2;  // °C/Pa
-        double D3; // °C/(Pa^2)
-        // for the melt-fraction dependence of productivity
-        double E1;
-        double E2;
-
-        // for the maximum melt fraction of pyroxenite
-        double F_px_max;
-
-        // the relative density of molten material (compared to solid)
-        double relative_melt_density;
-
-        double pyroxenite_melting_entropy_change;
-
-        /**
-         * Percentage of material that is molten. Melting model after Katz,
-         * 2003 (for peridotite) and Sobolev et al., 2011 (for pyroxenite)
-         */
-        virtual
-        double
-        melt_fraction (const double temperature,
-                       const double pressure,
-                       const std::vector<double> &compositional_fields,
-                       const Point<dim> &position) const;
-
-        virtual
-        double
-        peridotite_melt_fraction (const double temperature,
-                                  const double pressure,
-                                  const std::vector<double> &compositional_fields,
-                                  const Point<dim> &position) const;
-
-        virtual
-        double
-        pyroxenite_melt_fraction (const double temperature,
-                                  const double pressure,
-                                  const std::vector<double> &compositional_fields,
-                                  const Point<dim> &position) const;
-
-        double
-        entropy_derivative ( const double temperature,
-                             const double pressure,
-                             const std::vector<double> &compositional_fields,
-                             const Point<dim> &position,
-                             const NonlinearDependence::Dependence dependence) const;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/melt_boukare.h.bak b/include/aspect/material_model/melt_boukare.h.bak
deleted file mode 100644
index 145fad241fb..00000000000
--- a/include/aspect/material_model/melt_boukare.h.bak
+++ /dev/null
@@ -1,355 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_melt_boukare_h
-#define _aspect_material_model_melt_boukare_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/melt.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * Additional output fields for the melt boukare material model.
-     */
-    template <int dim>
-    class BoukareOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        BoukareOutputs(const unsigned int n_points);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * Bulk composition of the material.
-         */
-        std::vector<double> bulk_composition;
-        std::vector<double> molar_volatiles_in_melt;
-    };
-
-    /**
-     * A material model that implements a simplified version of the melting
-     * model of Boukare et al. (https://doi.org/10.1002/2015JB011929) for the
-     * lowermost mantle. The model parameterizes the composition (which includes
-     * the components MgO, FeO and SiO2) as a mixture between two endmembers
-     * (one iron-bearing and one magnesium-bearing). The equation of state
-     * considers three phases: bridgmanite, ferropericlase, and melt (each with
-     * their individual compositions).
-     * More details can be found in Dannberg, J., Myhill, R., Gassmöller, R.,
-     * & Cottaar, S. (2021). The morphology, evolution and seismic visibility
-     * of partial melt at the core–mantle boundary: implications for ULVZs.
-     * Geophysical Journal International, 227(2), 1028-1059.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class MeltBoukare : public MaterialModel::MeltInterface<dim>,
-      public MaterialModel::MeltFractionModel<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. Computes endmember properties.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Return whether the model is compressible or not. In this model,
-         * both the melt and solid are compressible.
-         */
-        bool is_compressible () const override;
-
-        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                      typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * Compute the equilibrium melt fractions for the given input conditions.
-         * @p in and @p melt_fractions need to have the same size.
-         *
-         * @param in Object that contains the current conditions.
-         * @param melt_fractions Vector of doubles that is filled with the
-         * equilibrium melt fraction for each given input conditions.
-         */
-        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                             std::vector<double> &melt_fractions) const override;
-
-        /**
-         * @name Reference quantities
-         * @{
-         */
-        double reference_darcy_coefficient () const override;
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-      private:
-        // Thermodynamic parameters of the endmember components in the equation of state,
-        // needed to compute their material properties.
-        std::vector<std::string> endmember_names;
-        std::vector<double> molar_masses;
-        std::vector<double> number_of_atoms;
-        std::vector<double> reference_volumes;
-        std::vector<double> reference_thermal_expansivities;
-        std::vector<double> reference_bulk_moduli;
-        std::vector<double> bulk_modulus_pressure_derivatives;
-        std::vector<double> bulk_modulus_second_pressure_derivatives;
-        std::vector<double> Einstein_temperatures;
-        std::vector<double> reference_enthalpies;
-        std::vector<double> reference_entropies;
-        std::vector<double> reference_specific_heats;
-        std::vector<double> specific_heat_linear_coefficients;
-        std::vector<double> specific_heat_second_coefficients;
-        std::vector<double> specific_heat_third_coefficients;
-
-        std::vector<double> tait_parameters_a;
-        std::vector<double> tait_parameters_b;
-        std::vector<double> tait_parameters_c;
-
-        // Reference conditions for computing the material properties in the equation of state.
-        double reference_temperature;
-        double reference_pressure;
-
-        // Rheological properties.
-        double eta_0;
-        double xi_0;
-        double eta_f;
-        double thermal_viscosity_exponent;
-        double thermal_bulk_viscosity_exponent;
-        double alpha_phi;
-
-        // Transport properties that are not computed from the equation of state.
-        double thermal_conductivity;
-        double reference_permeability;
-
-        // Parameters controlling melting and solidification of melt.
-        bool include_melting_and_freezing;
-        double melting_time_scale;
-
-        // Parameters defining the molar composition of the two endmember compositions we use
-        // in the melting model.
-        const double molar_MgO_in_Mg_mantle_endmember = 0.581;
-        const double molar_SiO2_in_Mg_mantle_endmember = 0.419;
-        const double molar_FeO_in_Fe_mantle_endmember = 0.908;
-        const double molar_SiO2_in_Fe_mantle_endmember = 0.092;
-
-        // Parameters describing the melting properties of the two endmembers of the melting model.
-        const double melting_reference_pressure = 120.e9;
-
-        // reference melting temperature for Fe and Mg mantle endmember at the reference pressure
-        double Fe_mantle_melting_temperature;
-        double Mg_mantle_melting_temperature;
-
-        // molar entropy change of melting in J/mol K
-        const double Fe_mantle_melting_entropy = 33.77;
-        const double Mg_mantle_melting_entropy = 34.33;
-
-        // molar volume change of melting of solid Fe and Mg mantle endmember in m3/mol
-        const double Fe_mantle_melting_volume = 1.51e-07;
-        const double Mg_mantle_melting_volume = 9.29e-08;
-
-        // Number of moles of atoms mixing on pseudosite in mantle lattice (empirical model fitting the full Boukare model).
-        double Fe_number_of_moles;
-        double Mg_number_of_moles;
-
-        // Indices for the endmembers in the equation of state.
-        unsigned int febdg_idx;
-        unsigned int mgbdg_idx;
-        unsigned int wus_idx;
-        unsigned int per_idx;
-        unsigned int femelt_idx;
-        unsigned int mgmelt_idx;
-
-
-        // Parameter describing if an endmember in the equation of state is solid or molten.
-        struct EndmemberState
-        {
-          enum Kind
-          {
-            solid,
-            melt
-          };
-        };
-
-        std::vector<typename EndmemberState::Kind> endmember_states;
-
-
-        // Material properties of the different endmembers of the equation of state.
-        struct EndmemberProperties
-        {
-          /**
-           * Constructor. Initialize the various arrays of this structure with the
-           * given number of endmembers.
-           */
-          EndmemberProperties(const unsigned int n_endmembers);
-
-          std::vector<double> volumes;
-          std::vector<double> gibbs_energies;
-          std::vector<double> entropies;
-          std::vector<double> thermal_expansivities;
-          std::vector<double> bulk_moduli;
-          std::vector<double> heat_capacities;
-        };
-
-
-        /**
-         * Fill the endmember properties at a single point.
-         */
-        virtual
-        void
-        fill_endmember_properties (const typename Interface<dim>::MaterialModelInputs &in,
-                                   const unsigned int q,
-                                   EndmemberProperties &properties) const;
-
-
-        /**
-         * Calculate the Einstein thermal energy of an endmember component.
-         */
-        virtual
-        double
-        endmember_thermal_energy (const double temperature,
-                                  const unsigned int endmember_index) const;
-
-
-        /**
-         * Calculate the heat capacity of an endmember component.
-         */
-        virtual
-        double
-        endmember_molar_heat_capacity (const double temperature,
-                                       const unsigned int endmember_index) const;
-
-        /**
-         * Calculate the thermal pressure of an endmember component.
-         */
-        virtual
-        double
-        endmember_thermal_pressure (const double temperature,
-                                    const unsigned int endmember_index) const;
-
-        /**
-         * Calculate the thermal addition to the standard state enthalpy of an endmember component
-         * at the reference pressure.
-         */
-        virtual
-        double
-        endmember_enthalpy_thermal_addition (const double temperature,
-                                             const unsigned int endmember_index) const;
-
-        /**
-         * Calculate the thermal addition to the standard state enttropy of an endmember component
-         * at the reference pressure.
-         */
-        virtual
-        double
-        endmember_entropy_thermal_addition (const double temperature,
-                                            const unsigned int endmember_index) const;
-
-
-        /**
-         * Convert from the mole fraction of iron in the solid and melt to the mole fraction of iron
-         * and magnesium in each of the two solid phases, bridgmanite and ferropericlase, and the melt
-         * phase. In addition, compute the molar fraction of bridgmanite in the solid.
-         */
-        virtual
-        void
-        convert_composition_to_fraction_of_endmembers (const double temperature,
-                                                       const double molar_Fe_in_solid,
-                                                       const double molar_Fe_in_melt,
-                                                       const std::vector<double> &endmember_gibbs_energies,
-                                                       std::vector<double> &endmember_mole_fractions_per_phase,
-                                                       double &molar_bridgmanite_in_solid) const;
-
-
-        /**
-         * Compute the molar fraction of melt from the volume fraction of melt (the porosity).
-         * This requires knowing the densities of both solid and melt, which can be computed
-         * from the fractions and material properties of the component endmembers.
-         */
-        virtual
-        double
-        compute_melt_molar_fraction (const double porosity,
-                                     const double bridgmanite_molar_fraction_in_solid,
-                                     EndmemberProperties &properties,
-                                     const std::vector<double> &endmember_mole_fractions_per_phase) const;
-
-
-        /**
-         * Make sure that when the property @p value is updated by adding @p change_of_value,
-         * the new value is between zero and one. Otherwise, throw an error message.
-         */
-        virtual
-        double
-        assert_update_is_within_0_and_1 (const double value,
-                                         const double change_of_value) const;
-
-
-        /**
-         * Compute the equilibrium melt fraction for a given @p temperature, @p pressure,
-         * and @p bulk_composition and the corresponding composition of melt and solid. The
-         * melting model is based on Phipps Morgan, Jason. "Thermodynamics of pressure release
-         * melting of a veined plum pudding mantle." Geochemistry, Geophysics, Geosystems 2.4
-         * (2001), and additionally includes volatiles.
-         */
-        virtual
-        double
-        melt_fraction (const double temperature,
-                       const double pressure,
-                       const double bulk_composition,
-                       double &molar_volatiles_in_melt,
-                       double &solid_composition,
-                       double &melt_composition) const;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/melt_global.h.bak b/include/aspect/material_model/melt_global.h.bak
deleted file mode 100644
index cc2da5af596..00000000000
--- a/include/aspect/material_model/melt_global.h.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_melt_global_h
-#define _aspect_material_model_melt_global_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/postprocess/melt_statistics.h>
-#include <aspect/melt.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that implements a simple formulation of the
-     * material parameters required for the modeling of melt transport
-     * in a global model, including a source term for the porosity according
-     * a simplified linear melting model.
-     *
-     * The model is considered incompressible, following the definition
-     * described in Interface::is_compressible.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class MeltGlobal : public MaterialModel::MeltInterface<dim>,
-      public MaterialModel::MeltFractionModel<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-
-        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                      typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * Compute the equilibrium melt fractions for the given input conditions.
-         * @p in and @p melt_fractions need to have the same size.
-         *
-         * @param in Object that contains the current conditions.
-         * @param melt_fractions Vector of doubles that is filled with the
-         * equilibrium melt fraction for each given input conditions.
-         */
-        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                             std::vector<double> &melt_fractions) const override;
-
-        /**
-         * @name Reference quantities
-         * @{
-         */
-        double reference_darcy_coefficient () const override;
-
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-      private:
-        double reference_rho_s;
-        double reference_rho_f;
-        double reference_T;
-        double eta_0;
-        double xi_0;
-        double eta_f;
-        double thermal_viscosity_exponent;
-        double thermal_bulk_viscosity_exponent;
-        double thermal_expansivity;
-        double reference_specific_heat;
-        double thermal_conductivity;
-        double reference_permeability;
-        double alpha_phi;
-        double depletion_density_change;
-        double depletion_solidus_change;
-        double pressure_solidus_change;
-        double surface_solidus;
-        double compressibility;
-        double melt_compressibility;
-        bool include_melting_and_freezing;
-        double melting_time_scale;
-        double alpha_depletion;
-        double delta_eta_depletion_max;
-
-        // entropy change upon melting
-        double peridotite_melting_entropy_change;
-
-        virtual
-        double
-        melt_fraction (const double temperature,
-                       const double pressure,
-                       const double depletion) const;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/melt_simple.h.bak b/include/aspect/material_model/melt_simple.h.bak
deleted file mode 100644
index 0d30c32c9ee..00000000000
--- a/include/aspect/material_model/melt_simple.h.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_melt_simple_h
-#define _aspect_material_model_melt_simple_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/postprocess/melt_statistics.h>
-#include <aspect/melt.h>
-#include <aspect/material_model/reaction_model/katz2003_mantle_melting.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that implements a simple formulation of the
-     * material parameters required for the modeling of melt transport,
-     * including a source term for the porosity according to the melting
-     * model for dry peridotite of Katz, 2003. This also includes a
-     * computation of the latent heat of melting (if the latent heat
-     * heating model is active).
-     *
-     * Most of the material properties are constant, except for the shear,
-     * compaction and melt viscosities and the permeability, which depend on
-     * the porosity; and the solid and melt densities, which depend on
-     * temperature and pressure.
-     *
-     * The model is compressible (following the definition described in
-     * Interface::is_compressible) only if this is specified in the input file,
-     * and contains compressibility for both solid and melt.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class MeltSimple : public MaterialModel::MeltInterface<dim>,
-      public MaterialModel::MeltFractionModel<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run and after
-         * the SimulatorAccess (if applicable) is initialized.
-         */
-        void
-        initialize () override;
-
-        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                      typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                             std::vector<double> &melt_fractions) const override;
-
-        /**
-         * @name Reference quantities
-         * @{
-         */
-        double reference_darcy_coefficient () const override;
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-      private:
-        bool model_is_compressible;
-        double thermal_expansivity;
-        double eta_0;
-        double reference_specific_heat;
-        double thermal_conductivity;
-        double compressibility;
-        double thermal_viscosity_exponent;
-        double reference_T;
-        double depletion_density_change;
-        double reference_rho_solid;
-
-
-
-        /*
-        * Object for computing the melt parameters
-        */
-        ReactionModel::Katz2003MantleMelting<dim> katz2003_model;
-
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/modified_tait.h.bak b/include/aspect/material_model/modified_tait.h.bak
deleted file mode 100644
index c889f06370b..00000000000
--- a/include/aspect/material_model/modified_tait.h.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_modified_tait_h
-#define _aspect_material_model_modified_tait_h
-
-#include <deal.II/base/function_lib.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A compressible material model that implements the thermal modified Tait
-     * equation of state as written in the paper of Holland and Powell, 2011
-     * "An improved and extended internally consistent thermodynamic dataset
-     * for phases of petrological interest, involving a new equation of state
-     * for solids".
-     *
-     * Constant values are used for the thermal conductivity and viscosity.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class ModifiedTait : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-
-      public:
-        /**
-         * Evaluate material properties.
-         */
-        void evaluate(const MaterialModelInputs<dim> &in,
-                      MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         * This model is compressible.
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-      private:
-        /**
-         * The Tait parameters
-         */
-        double tait_a, tait_b, tait_c;
-
-        /**
-         * The reference pressure
-         */
-        double reference_pressure;
-
-        /**
-         * The reference temperature
-         */
-        double reference_temperature;
-
-        /**
-         * The reference density
-         */
-        double reference_rho;
-
-        /**
-         * The reference isothermal bulk modulus
-         */
-        double reference_isothermal_bulk_modulus;
-
-        /**
-         * The reference K'
-         * (first pressure derivative of the isothermal bulk modulus)
-         */
-        double reference_Kprime;
-
-        /**
-         * The reference K''
-         * (second pressure derivative of the isothermal bulk modulus)
-         */
-        double Kdprime_0;
-
-        /**
-         * The reference thermal expansivity
-         */
-        double reference_thermal_expansivity;
-
-        /**
-         * The Einstein temperature
-         */
-        double einstein_temperature;
-
-        /**
-         * Parsed function that specifies the specific heat at P0 when using the Function
-         * method.
-         */
-        Functions::ParsedFunction<1> reference_heat_capacity_function;
-
-        /**
-         * The constant viscosity
-         */
-        double eta;
-
-        /**
-         * The constant thermal conductivity.
-         */
-        double k_value;
-
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/multicomponent.h.bak b/include/aspect/material_model/multicomponent.h.bak
deleted file mode 100644
index 49524bf31e1..00000000000
--- a/include/aspect/material_model/multicomponent.h.bak
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
-  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_multicomponent_h
-#define _aspect_material_model_multicomponent_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/equation_of_state/multicomponent_incompressible.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * An incompressible material model which is intended for use with multiple
-     * compositional fields. Each compositional field is meant to be a single
-     * rock type, where the value of the field at a point is interpreted to be
-     * a volume fraction of that rock type.  If the sum of the compositional field
-     * volume fractions is less than one, then the remainder of the volume is
-     * assumed to be ``background mantle''.  If the sum of the compositional
-     * field volume fractions is greater than one, then they are renormalized
-     * to sum to one and there is no background mantle.
-     *
-     * For each material parameter the user supplies a comma delimited list of
-     * length N+1, where N is the number of compositional fields.  The
-     * additional field corresponds to the value for background mantle.  They
-     * should be ordered ``background, composition1, composition2...''
-     *
-     * If a single value is given, then all the compositional fields are given
-     * that value. Other lengths of lists are not allowed.  For a given
-     * compositional field the material parameters are treated as constant,
-     * except density, which varies linearly with temperature according to the
-     * thermal expansivity.
-     *
-     * When more than one field is present at a point, they are averaged
-     * arithmetically. An exception is viscosity, which may be averaged
-     * arithmetically, harmonically, geometrically, or by selecting the
-     * viscosity of the composition with the greatest volume fraction.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class Multicomponent : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * This model is not compressible, so this returns false.
-         */
-        bool is_compressible () const override;
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-      private:
-        /**
-         * Reference temperature for thermal expansion.  All components use
-         * the same reference_T.
-         */
-        double reference_T;
-
-        /**
-         * Enumeration for selecting which viscosity averaging scheme to use.
-         */
-        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
-
-        /**
-         * Vector for field viscosities, read from parameter file.
-         */
-        std::vector<double> viscosities;
-
-        /**
-         * Vector for field thermal conductivities, read from parameter file.
-         */
-        std::vector<double> thermal_conductivities;
-
-        EquationOfState::MulticomponentIncompressible<dim> equation_of_state;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/multicomponent_compressible.h.bak b/include/aspect/material_model/multicomponent_compressible.h.bak
deleted file mode 100644
index 9198a5ea8b4..00000000000
--- a/include/aspect/material_model/multicomponent_compressible.h.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
-  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_multicomponent_compressible_h
-#define _aspect_material_model_multicomponent_compressible_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/equation_of_state/multicomponent_compressible.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model which is intended for use with multiple compositional
-     * fields. Each compositional field is meant to be a single rock type,
-     * where the value of the field at a point is interpreted to be the
-     * mass fraction of that rock type. If the sum of the compositional field
-     * mass fractions is less than one, then the remainder of the mass is
-     * assumed to be ``background mantle''.  If the sum of the compositional
-     * field mass fractions is greater than one, then they are renormalized
-     * to sum to one and there is no background mantle.
-     *
-     * For each material parameter the user supplies a comma delimited list of
-     * length N+1, where N is the number of compositional fields.  The
-     * additional field corresponds to the value for background mantle.  They
-     * should be ordered ``background, composition1, composition2...''
-     *
-     * If a single value is given, then all the compositional fields are given
-     * that value. Other lengths of lists are not allowed.  The material
-     * parameters for each compositional field are derived from the
-     * multicomponent compressible equation of state, and are pressure and
-     * temperature dependent.
-     *
-     * When more than one field is present at a point, they are either averaged
-     * self-consistently (for equation of state properties) or arithmetically
-     * (for thermal conductivity). For the special case of viscosity, the user
-     * may select from a variety of averaging schemes:
-     * arithmetic, harmonic, geometric, or by selecting the
-     * viscosity of the composition with the greatest volume fraction.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class MulticomponentCompressible : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * This model is compressible, so this returns true.
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        /**
-         * Enumeration for selecting which viscosity averaging scheme to use.
-         */
-        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
-
-        /**
-         * Vector for field viscosities, read from parameter file.
-         */
-        std::vector<double> viscosities;
-
-        /**
-         * Vector for field thermal conductivities, read from parameter file.
-         */
-        std::vector<double> thermal_conductivities;
-
-        EquationOfState::MulticomponentCompressible<dim> equation_of_state;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/nondimensional.h.bak b/include/aspect/material_model/nondimensional.h.bak
deleted file mode 100644
index 3dcf1482c19..00000000000
--- a/include/aspect/material_model/nondimensional.h.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_material_model_nondimensional_h
-#define _aspect_material_model_nondimensional_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model for incompressible (using the Boussinesq approximation)
-     * and compressible computations (with ALA or TALA) for a nondimensionalized
-     * problem. The viscosity is (optionally) depth and temperature dependent.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class Nondimensional : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Initialize.
-         */
-        void initialize () override;
-
-        /**
-         * Evaluate the material model.
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        /**
-         * Use truncated anelastic approximation?
-         */
-        bool tala;
-
-        /**
-         * Are we using ALA/TALA or BA? (determined by the choice of Di)
-         */
-        bool compressible;
-
-        /**
-         * Parameter describing the temperature prefactor of viscosity.
-         */
-        double exponential_viscosity_temperature_prefactor;
-
-        /**
-         * Parameter describing the depth prefactor of viscosity.
-         */
-        double exponential_viscosity_depth_prefactor;
-
-        /**
-         * The surface density.
-         */
-        double reference_rho;
-
-        /**
-         * The nondimensional numbers (Dissipation number,
-         * Rayleigh number, Grueneisen parameter).
-         */
-        double Di, Ra, gamma;
-
-        /**
-         * The constant specific heat
-         */
-        double reference_specific_heat;
-
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/perplex_lookup.h.bak b/include/aspect/material_model/perplex_lookup.h.bak
deleted file mode 100644
index 5054a36f822..00000000000
--- a/include/aspect/material_model/perplex_lookup.h.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_perplex_lookup_h
-#define _aspect_material_model_perplex_lookup_h
-
-#include <aspect/material_model/interface.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that calls the thermodynamic software PerpleX
-     * in order to evaluate material properties at a given point, namely
-     * the density, heat capacity, thermal expansivity and compressibility.
-     * The viscosity and thermal conductivity are globally constant.
-     *
-     * The usual PerpleX input files are required in the working directory:
-     * an endmember dataset file, solution model dataset file and
-     * option file. The path to a PerpleX input file must be given by
-     * the user in the ASPECT parameter file; this file may be in any
-     * directory. PerpleX output files will be written to the same
-     * directory.
-     *
-     * Compositional fields are used to define the bulk composition at
-     * each point. These compositional fields correspond to the
-     * components as given in the PerpleX input file. The order of
-     * components is preserved.
-     *
-     * This model requires PerpleX. A script to download and setup the
-     * required files can be found in contrib/perplex. If the default
-     * installation directory is not changed, cmake will automatically
-     * find the required files during creation of the ASPECT build files.
-     * See ./contrib/perplex/README.md
-     *
-     * WARNING: This model is extremely slow because there are many
-     * redundant calls to evaluate the material properties;
-     * it serves only as a proof of concept.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class PerpleXLookup : public Interface<dim>
-    {
-      public:
-        /**
-         * Initialization function. Loads the material data and sets up
-         * pointers.
-         */
-        void
-        initialize () override;
-
-        bool is_compressible () const override;
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-
-      private:
-        std::string perplex_file_name;
-        double eta;
-        double k_value;
-        double min_temperature;
-        double max_temperature;
-        double min_pressure;
-        double max_pressure;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/prescribed_viscosity.h.bak b/include/aspect/material_model/prescribed_viscosity.h.bak
deleted file mode 100644
index 321949d3b9b..00000000000
--- a/include/aspect/material_model/prescribed_viscosity.h.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_prescribed_viscosity_h
-#define _aspect_material_model_prescribed_viscosity_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <deal.II/base/parsed_function.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that applies a viscosity to a ''base model'' chosen from any of
-     * the other available material models. This prescribed viscosity material model
-     * allows the user to specify a function which describes where the viscosity should be
-     * prescribed and a second function which describes the viscosity in that region.
-     * This material model requires a base model which prescribes the viscosity and the
-     * other material parameters in the rest of the model.
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class PrescribedViscosity : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialize the base model at the beginning of the run.
-         */
-        void initialize() override;
-
-        /**
-         * Update the base model and viscosity function at the beginning of
-         * each timestep.
-         */
-        void update() override;
-
-        /**
-         * Compute the material properties by evaluating the base model and
-         * then overwrite the viscosity according to the viscosity function
-         * in the locations set by the indicator function.
-         */
-        void
-        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
-                  typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * Method to declare parameters related to prescribed viscosity model
-         */
-        static void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Method to parse parameters related to prescribed viscosity model
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Method that indicates whether material is compressible. Prescribed viscosity model is compressible
-         * if and only if base model is compressible.
-         */
-        bool is_compressible () const override;
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-      private:
-
-        /**
-         * Parsed function that specifies where the viscosity is prescribed.
-         */
-        Functions::ParsedFunction<dim> prescribed_viscosity_indicator_function;
-
-        /**
-         * Parsed function that specifies what the viscosity is set to in the
-         * prescribed regions.
-         */
-        Functions::ParsedFunction<dim> prescribed_viscosity_function;
-
-        /**
-         * Pointer to the material model used as the base model
-         */
-        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/reaction_model/katz2003_mantle_melting.h.bak b/include/aspect/material_model/reaction_model/katz2003_mantle_melting.h.bak
deleted file mode 100644
index b5bf2bd066c..00000000000
--- a/include/aspect/material_model/reaction_model/katz2003_mantle_melting.h.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_reaction_melt_katz2003_mantle_melting_h
-#define _aspect_material_reaction_melt_katz2003_mantle_melting_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/postprocess/melt_statistics.h>
-#include <aspect/melt.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace ReactionModel
-    {
-
-      /**
-      * A melt model that calculates melt fraction and entropy change
-      * according to the melting model for dry peridotite of Katz, 2003.
-      * This also includes a computation of the latent heat of melting (if the latent heat
-      * heating model is active).
-      *
-      * These functions can be used in the calculation of melting and melt transport
-      * in the melt_simple material model and can be extended to other material models
-      *
-      * @ingroup ReactionModel
-      */
-      template <int dim>
-      class Katz2003MantleMelting : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          // constructor
-          Katz2003MantleMelting();
-
-          /**
-          * Declare the parameters this function takes through input files.
-          */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-
-          /**
-           * Percentage of material that is molten for a given @p temperature and
-           * @p pressure (assuming equilibrium conditions). Melting model after Katz,
-           * 2003, for dry peridotite.
-           */
-          double
-          melt_fraction (const double temperature,
-                         const double pressure) const;
-
-          /**
-          * Compute the change in entropy due to melting for a given @p temperature
-          * and @p pressure, and under the assumption that a fraction
-          * @p maximum_melt_fraction of the material has already been molten
-          * previously. The entropy change is computed with respect to temperature
-          * or pressure, depending on @p dependence.
-          * This is needed to calculate the latent heat of melt.
-          */
-          double
-          entropy_change (const double temperature,
-                          const double pressure,
-                          const double maximum_melt_fraction,
-                          const NonlinearDependence::Dependence dependence) const;
-
-
-          /**
-           * Compute all the reaction rate variables needed for a reactive transport model based on the
-           * Katz 2003 formulation. Takes the material model inputs @p in to compute the material model outputs @p out.
-           * This function mainly fills the reaction_rate_out object but populates out.reaction_terms,
-           * out.entropy_derivative_pressure and entropy_derivative_temperature
-          */
-          void calculate_reaction_rate_outputs(const typename Interface<dim>::MaterialModelInputs &in,
-                                               typename Interface<dim>::MaterialModelOutputs &out) const;
-
-          /**
-           * Compute all the fluid variables needed for a reactive transport model based on the
-           * Katz 2003 formulation. This function fills melt outputs, the out object should already contain
-           * outputs for the solid and this function uses the inputs @p in and the solid outputs @p out
-           * to fill MeltOutputs. Solid outputs such as out.Thermal_expansion_coefficients are expected
-           * to have already been computed when this function is called. Solid viscosities are also modified
-           * in the out object here because the presence of melt weakens the material.
-          */
-          void calculate_fluid_outputs(const typename Interface<dim>::MaterialModelInputs &in,
-                                       typename Interface<dim>::MaterialModelOutputs &out,
-                                       const double reference_T) const;
-
-
-          double reference_darcy_coefficient () const;
-
-        private:
-          /**
-          * Parameters for anhydrous melting of peridotite after Katz, 2003
-          */
-
-          double reference_rho_fluid;
-          double xi_0;
-          double viscosity_fluid;
-          double thermal_bulk_viscosity_exponent;
-          double alpha_phi;
-          double extraction_depth;
-          double melt_compressibility;
-          double melt_bulk_modulus_derivative;
-          double depletion_solidus_change;
-          bool fractional_melting;
-          double freezing_rate;
-          double melting_time_scale;
-          double reference_permeability;
-
-          // for the solidus temperature
-          double A1;   // °C
-          double A2; // °C/Pa
-          double A3; // °C/(Pa^2)
-
-          // for the lherzolite liquidus temperature
-          double B1;   // °C
-          double B2;   // °C/Pa
-          double B3; // °C/(Pa^2)
-
-          // for the liquidus temperature
-          double C1;   // °C
-          double C2;  // °C/Pa
-          double C3; // °C/(Pa^2)
-
-          // for the reaction coefficient of pyroxene
-          double r1;     // cpx/melt
-          double r2;     // cpx/melt/GPa
-          double M_cpx;  // mass fraction of pyroxene
-
-          // melt fraction exponent
-          double beta;
-
-          // entropy change upon melting
-          double peridotite_melting_entropy_change;
-      };
-    }
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/reactive_fluid_transport.h.bak b/include/aspect/material_model/reactive_fluid_transport.h.bak
deleted file mode 100644
index 245f2e0eb2c..00000000000
--- a/include/aspect/material_model/reactive_fluid_transport.h.bak
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_reactive_fluid_transport_h
-#define _aspect_material_model_reactive_fluid_transport_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/melt.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <aspect/melt.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/material_model/reaction_model/katz2003_mantle_melting.h>
-
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-    /**
-     * A material model that simulates both fluid-rock interactions
-     * and the advection of fluids. It is designed to be composited with another material
-     * model that computes the solid material properties.
-     * @ingroup MaterialModels
-     */
-
-    template <int dim>
-    class ReactiveFluidTransport : public MaterialModel::MeltInterface<dim>, public MaterialModel::MeltFractionModel<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * @copydoc MaterialModel::Interface::is_compressible()
-         *
-         * Returns value from material model providing compressibility.
-         */
-        bool is_compressible () const override;
-
-        /**
-         * @name Reference quantities
-         * @{
-         */
-        virtual double reference_darcy_coefficient () const override;
-
-
-        /**
-         * Compute the maximum allowed bound water content at the input
-         * pressure and temperature conditions. This is used to determine
-         * how free water interacts with the solid phase.
-         * @param in Object that contains the current conditions.
-         * @param q unsigned int from 0-3 indexing which rock phase the equilbrium
-         * bound water content is being calculated for
-         */
-        std::vector<double> tian_equilibrium_bound_water_content(const MaterialModel::MaterialModelInputs<dim> &in,
-                                                                 unsigned int q) const;
-
-        /**
-         * Compute the free fluid fraction that can be present in the material based on the
-         * fluid content of the material and the fluid solubility for the given input conditions.
-         * @p in and @p melt_fractions need to have the same size.
-         *
-         * @param in Object that contains the current conditions.
-         * @param melt_fractions Vector of doubles that is filled with the
-         * allowable free fluid fraction for each given input conditions.
-         */
-        virtual void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                                     std::vector<double> &melt_fractions) const override;
-
-        /**
-         * Initialize the base model at the beginning of the model run
-         * @copydoc MaterialModel::Interface::initialize()
-         */
-        void
-        initialize () override;
-
-        /**
-         * Update the base model at the beginning of each timestep.
-         */
-        void update() override;
-
-        /**
-         * @copydoc MaterialModel::Interface::evaluate()
-         */
-        void
-        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
-                  typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * @copydoc MaterialModel::Interface::declare_parameters()
-         */
-        static void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * @copydoc MaterialModel::Interface::parse_parameters()
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * If this material model can produce additional named outputs
-         * that are derived from NamedAdditionalOutputs, create them in here.
-         */
-        virtual
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-      private:
-
-        /**
-         * Pointer to the material model used as the base model
-         */
-        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
-
-        // Variables that describe the properties of the fluid, i.e. its density,
-        // viscosity, and compressibility.
-        // Properties of the solid are defined in the base model.
-        double reference_rho_f;
-        double eta_f;
-        double fluid_compressibility;
-
-        // Material properties governing the transport of the fluid with respect
-        // to the solid, i.e., the bulk viscosity (relative to the shear viscosity),
-        // the permeability, and how much the solid viscosity changes in the presence
-        // of fluids.
-        double shear_to_bulk_viscosity_ratio;
-        double min_compaction_visc;
-        double max_compaction_visc;
-        double reference_permeability;
-        double alpha_phi;
-        double reference_T;
-
-        // Time scale for fluid release and absorption.
-        double fluid_reaction_time_scale;
-
-        // The maximum water content for each of the 4 rock types in the tian approximation
-        // method. These are important for keeping the polynomial bounded within reasonable
-        // values.
-        double tian_max_peridotite_water;
-        double tian_max_gabbro_water;
-        double tian_max_MORB_water;
-        double tian_max_sediment_water;
-
-        // The following coefficients are taken from a publication from Tian et al., 2019, and can be found
-        // in Table 3 (Gabbro), Table B1 (MORB), Table B2 (Sediments) and Table B3 (peridotite).
-        // LR refers to the effective enthalpy change for devolatilization reactions,
-        // csat is the saturated mass fraction of water in the solid, and Td is the
-        // onset temperature of devolatilization for water.
-        std::vector<double> LR_peridotite_poly_coeffs {-19.0609, 168.983, -630.032, 1281.84, -1543.14, 1111.88, -459.142, 95.4143, 1.97246};
-        std::vector<double> csat_peridotite_poly_coeffs {0.00115628, 2.42179};
-        std::vector<double> Td_peridotite_poly_coeffs {-15.4627, 94.9716, 636.603};
-
-        std::vector<double> LR_gabbro_poly_coeffs {-1.81745, 7.67198, -10.8507, 5.09329, 8.14519};
-        std::vector<double> csat_gabbro_poly_coeffs {-0.0176673, 0.0893044, 1.52732};
-        std::vector<double> Td_gabbro_poly_coeffs {-1.72277, 20.5898, 637.517};
-
-        std::vector<double> LR_MORB_poly_coeffs {-1.78177, 7.50871, -10.4840, 5.19725, 7.96365};
-        std::vector<double> csat_MORB_poly_coeffs {0.0102725, -0.115390, 0.324452, 1.41588};
-        std::vector<double> Td_MORB_poly_coeffs {-3.81280, 22.7809, 638.049};
-
-        std::vector<double> LR_sediment_poly_coeffs {-2.03283, 10.8186, -21.2119, 18.3351, -6.48711, 8.32459};
-        std::vector<double> csat_sediment_poly_coeffs {-0.150662, 0.301807, 1.01867};
-        std::vector<double> Td_sediment_poly_coeffs {2.83277, -24.7593, 85.9090, 524.898};
-
-        // The polynomials breakdown above certain pressures, 10 GPa for peridotite, 26 GPa for gabbro, 16 GPa for MORB,
-        // and 50 GPa for sediment. These cutoff pressures were determined by extending the pressure range in Tian et al. (2019)
-        // and observing where the maximum allowed water contents jump towards infinite values.
-        const std::vector<double> pressure_cutoffs {10, 26, 16, 50};
-
-        std::vector<std::vector<double>> devolatilization_enthalpy_changes {LR_peridotite_poly_coeffs, LR_gabbro_poly_coeffs, \
-                                                                             LR_MORB_poly_coeffs, LR_sediment_poly_coeffs
-                                                                            };
-
-        std::vector<std::vector<double>> water_mass_fractions {csat_peridotite_poly_coeffs, csat_gabbro_poly_coeffs, \
-                                                                csat_MORB_poly_coeffs, csat_sediment_poly_coeffs
-                                                               };
-
-        std::vector<std::vector<double>> devolatilization_onset_temperatures {Td_peridotite_poly_coeffs, Td_gabbro_poly_coeffs, \
-                                                                               Td_MORB_poly_coeffs, Td_sediment_poly_coeffs
-                                                                              };
-
-        /*
-        * Object for computing Katz 2003 melt parameters
-        */
-        ReactionModel::Katz2003MantleMelting<dim> katz2003_model;
-
-        /**
-         * Enumeration for selecting which type of scheme to use for
-         * reactions between fluids and solids. The available
-         * reaction models are described below.
-         *
-         * The no reaction model does not include any reactions
-         * between the solid and fluid phases. As a result,
-         * there is no exchange between the bound fluid and porosity
-         * compositional fields. However, the values of each field
-         * may vary through the model evolution through advection
-         * from their initial configurations.
-         *
-         * The zero solubility model describes a scenario where the
-         * solid cannot accommodate any fluid (i.e., zero solubility).
-         * The fluid volume fraction in equilibrium with the solid
-         * at any point (stored in the melt_fractions vector) is
-         * equal to the sum of the bound fluid content and porosity,
-         * with the latter determined by the assigned initial
-         * porosity, fluid boundary conditions, and fluid
-         * transport through the model. Significantly, this reaction
-         * model is thus assuming that the bound water fraction is a
-         * volume fraction (i.e., since porosity is always a volume
-         * fraction). This latter assumption also requires the selected
-         * base model to be incompressible, as otherwise the advection
-         * equation would only be valid for mass and not volume
-         * fractions.
-         *
-         * The tian approximation model implements parametrized phase
-         * diagrams from Tian et al., 2019 G3, https://doi.org/10.1029/2019GC008488
-         * and calculates the fluid-solid reactions for four different rock types:
-         * sediments, MORB, gabbro and peridotite. This is achieved by calculating the
-         * maximum allowed bound water content for each composition at the current
-         * Pressure-Temperature conditions, and releasing bound water as free water if:
-         * (maximum bound water content < current bound water content)
-         * or incorporating free water (if present) into the solid phase as bound water:
-         * maximum bound water content > current bound water content
-         * This model requires that 4 compositional fields named after the 4 different rock
-         * types exist in the input file.
-         *
-         * The Katz2003 model implements anhydrous the mantle melting model from
-         * Katz et. al., 2003 G3, doi:10.1029/2002GC000433.
-         */
-        enum ReactionScheme
-        {
-          no_reaction,
-          zero_solubility,
-          tian_approximation,
-          katz2003
-        }
-        fluid_solid_reaction_scheme;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/replace_lithosphere_viscosity.h.bak b/include/aspect/material_model/replace_lithosphere_viscosity.h.bak
deleted file mode 100644
index e7ac2fd94b6..00000000000
--- a/include/aspect/material_model/replace_lithosphere_viscosity.h.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_replace_lithosphere_viscosity_h
-#define _aspect_material_model_replace_lithosphere_viscosity_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-#include <aspect/initial_temperature/lithosphere_mask.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that applies a given constant viscosity in the lithosphere.
-     * Viscosity below this is taken from a ''base model'' chosen from any of the
-     * other available material models. The 'replace lithosphere viscosity'
-     * material model allows the user to specify the depth of the lithosphere-asthenosphere
-     * boundary either as one value or as a file. All other properties are derived
-     * from the base model.
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class ReplaceLithosphereViscosity : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Initialize the base model at the beginning of the run.
-         */
-        void initialize() override;
-
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void
-        evaluate (const typename Interface<dim>::MaterialModelInputs &in,
-                  typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        /**
-         * Method to declare parameters related to replace lithosphere viscosity model
-         */
-        static void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Method to parse parameters related to replace lithosphere viscosity model
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Method that indicates whether material is compressible. Replace lithosphere viscosity model is compressible
-         * if and only if base model is compressible.
-         */
-        bool is_compressible () const override;
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-      private:
-
-        /**
-         * This parameter gives the viscosity set within the lithosphere.
-         */
-        double lithosphere_viscosity;
-
-
-        /**
-         * Pointer to the material model used as the base model
-         */
-        std::unique_ptr<MaterialModel::Interface<dim>> base_model;
-
-
-        InitialTemperature::LABDepth::LABDepthLookup<dim> lab_depth_lookup;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/rheology/ascii_depth_profile.h.bak b/include/aspect/material_model/rheology/ascii_depth_profile.h.bak
deleted file mode 100644
index 1655724499e..00000000000
--- a/include/aspect/material_model/rheology/ascii_depth_profile.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2020 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_material_model_rheology_ascii_depth_profile_h
-#define _aspect_material_model_rheology_ascii_depth_profile_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/point.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-
-      /**
-       * A class that implements a prescribed viscosity with depth determined from
-       * an AsciiDataProfile input file.
-       *
-       * @ingroup Rheology
-       */
-      template <int dim>
-      class AsciiDepthProfile : public Utilities::AsciiDataProfile<dim> , public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor. Initialize variables.
-           */
-          AsciiDepthProfile ();
-
-          /**
-           * Initialization function.
-           */
-          void initialize ();
-
-          // avoid -Woverloaded-virtual:
-          using Utilities::AsciiDataProfile<dim>::initialize;
-
-          /**
-           * Return the viscosity at a given point of the domain.
-           */
-          double compute_viscosity (const double depth) const;
-
-          /**
-           * Declare the parameters for the input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler  &prm,
-                              const std::string &subsection_name = "Ascii data model");
-
-          /**
-           * Read the parameters from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm,
-                            const std::string &subsection_name = "Ascii data model");
-
-        private:
-
-          /**
-           * The column index of the viscosity in the data file.
-           */
-          unsigned int viscosity_index;
-      };
-    }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/material_model/rheology/composite_visco_plastic.h.bak b/include/aspect/material_model/rheology/composite_visco_plastic.h.bak
deleted file mode 100644
index 265660e8c27..00000000000
--- a/include/aspect/material_model/rheology/composite_visco_plastic.h.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_composite_visco_plastic_h
-#define _aspect_material_model_rheology_composite_visco_plastic_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/material_model/rheology/diffusion_creep.h>
-#include <aspect/material_model/rheology/dislocation_creep.h>
-#include <aspect/material_model/rheology/peierls_creep.h>
-#include <aspect/material_model/rheology/drucker_prager.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-
-      template <int dim>
-      class CompositeViscoPlastic : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          CompositeViscoPlastic();
-
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           * If @p expected_n_phases_per_composition points to a vector of
-           * unsigned integers this is considered the number of phases
-           * for each compositional field and will be checked against the parsed
-           * parameters.
-           */
-          void
-          parse_parameters (ParameterHandler &prm,
-                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
-
-          /**
-           * Compute the viscosity based on the composite viscous creep law.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          double
-          compute_viscosity (const double pressure,
-                             const double temperature,
-                             const std::vector<double> &volume_fractions,
-                             const SymmetricTensor<2,dim> &strain_rate,
-                             std::vector<double> &partial_strain_rates,
-                             const std::vector<double> &phase_function_values = std::vector<double>(),
-                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the compositional field viscosity
-           * based on the composite viscous creep law.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          double
-          compute_composition_viscosity (const double pressure,
-                                         const double temperature,
-                                         const unsigned int composition,
-                                         const SymmetricTensor<2,dim> &strain_rate,
-                                         std::vector<double> &partial_strain_rates,
-                                         const std::vector<double> &phase_function_values = std::vector<double>(),
-                                         const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the strain rate and first stress derivative
-           * as a function of stress based on the composite viscous creep law.
-           */
-          std::pair<double, double>
-          compute_strain_rate_and_derivative (const double creep_stress,
-                                              const double pressure,
-                                              const double temperature,
-                                              const DiffusionCreepParameters diffusion_creep_parameters,
-                                              const DislocationCreepParameters dislocation_creep_parameters,
-                                              const PeierlsCreepParameters peierls_creep_parameters,
-                                              const DruckerPragerParameters drucker_prager_parameters) const;
-
-        private:
-
-          /**
-           * Whether to use different deformation mechanisms
-           */
-          bool use_diffusion_creep;
-          bool use_dislocation_creep;
-          bool use_peierls_creep;
-          bool use_drucker_prager;
-
-          /**
-           * Pointers to objects for computing deformation mechanism
-           * strain rates and effective viscosities.
-           */
-          std::unique_ptr<Rheology::DiffusionCreep<dim>> diffusion_creep;
-          std::unique_ptr<Rheology::DislocationCreep<dim>> dislocation_creep;
-          std::unique_ptr<Rheology::PeierlsCreep<dim>> peierls_creep;
-          std::unique_ptr<Rheology::DruckerPrager<dim>> drucker_prager;
-
-          DruckerPragerParameters drucker_prager_parameters;
-
-          unsigned int number_of_compositions;
-          double minimum_viscosity;
-          double maximum_viscosity;
-
-          double min_strain_rate;
-          double strain_rate_residual_threshold;
-          unsigned int stress_max_iteration_number;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/compositional_viscosity_prefactors.h.bak b/include/aspect/material_model/rheology/compositional_viscosity_prefactors.h.bak
deleted file mode 100644
index 970084c4a2e..00000000000
--- a/include/aspect/material_model/rheology/compositional_viscosity_prefactors.h.bak
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_compositional_viscosity_prefactors_h
-#define _aspect_material_model_rheology_compositional_viscosity_prefactors_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      /**
-       * A class that handles multiplication of viscosity for a given compositional
-       * field. The multiplication factors for each composition (viscosity
-       * prefactors) are also declared, parsed, and in some cases calculated in this class.
-       */
-      template <int dim>
-      class CompositionalViscosityPrefactors : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          CompositionalViscosityPrefactors();
-
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-          // The flow laws that can be
-          // currently modified.
-          enum ModifiedFlowLaws
-          {
-            diffusion,
-            dislocation
-          } modified_flow_laws;
-
-          /**
-           * Compute the viscosity.
-           */
-          double
-          compute_viscosity (const MaterialModel::MaterialModelInputs<dim> &in,
-                             const double base_viscosity,
-                             const unsigned int composition_index,
-                             const unsigned int q,
-                             const ModifiedFlowLaws &modified_flow_laws) const;
-
-        private:
-          /**
-           * The viscosity prefactors or terms used to calculate the viscosity
-           * prefactors, which are read in from the input file by the
-           * parse_parameters() function. Users can choose between different schemes.
-           * none: no viscosity change
-           * hk04_olivine_hydration: calculate the viscosity change due to hydrogen
-           * incorporation into olivine using Hirth & Kohlstaedt 2004 10.1029/138GM06.
-           * This method requires a composition called 'bound_fluid' which tracks the wt%
-           * water in the solid, which is used to compute an atomic ratio of H/Si ppm
-           * assuming 90 mol% forsterite and 10 mol% fayalite, and finally calculates
-           * a water fugacity.
-           * The prefactor for a given compositional field is multiplied with a
-           * base_viscosity value provided by the material model, which is then returned
-           * to the material model.
-           */
-          enum ViscosityPrefactorScheme
-          {
-            none,
-            hk04_olivine_hydration,
-          } viscosity_prefactor_scheme;
-
-          // Initialize variables for the water fugacity calculation, from HK04
-          std::vector<double> diffusion_water_fugacity_exponents;
-          std::vector<double> dislocation_water_fugacity_exponents;
-          std::vector<double> minimum_mass_fraction_water_for_dry_creep;
-
-          // From Hirth & Kohlstaedt 2004, equation 6
-          const double A_H2O = 2.6e-5; // 1/Pa
-          const double activation_energy_H2O = 40e3; // J/mol/K
-          const double activation_volume_H2O = 10e-6; // m^3/mol
-
-          // We calculate the molar mass of olivine using the molar mass of fayalite (0.20379 kg/mol)
-          // and the molar mass of forsterite (0.140693 kg/mol), and a mole fraction of 90% forsterite
-          // in olivine.
-          const double molar_mass_olivine = 0.1470027; // kg/mol
-          const double molar_mass_H2O = 0.01801528; // kg/mol
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/constant_viscosity.h.bak b/include/aspect/material_model/rheology/constant_viscosity.h.bak
deleted file mode 100644
index 987209b35c1..00000000000
--- a/include/aspect/material_model/rheology/constant_viscosity.h.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
-  Copyright (C) 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_constant_viscosity_h
-#define _aspect_material_model_rheology_constant_viscosity_h
-
-#include <aspect/global.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      class ConstantViscosity
-      {
-        public:
-          /**
-           * Constructor. Initializes viscosity to NaN.
-           */
-          ConstantViscosity();
-
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm,
-                              const double default_viscosity = 1e21);
-
-          /**
-           * Read the parameters from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-          /**
-           * Compute the viscosity, in this case just a constant.
-           */
-          double
-          compute_viscosity () const;
-
-        private:
-          /**
-           * The constant viscosity that defines this rheology. It
-           * is read from the input file by the parse_parameters()
-           * function.
-           */
-          double viscosity;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/constant_viscosity_prefactors.h.bak b/include/aspect/material_model/rheology/constant_viscosity_prefactors.h.bak
deleted file mode 100644
index 1ecc37aad36..00000000000
--- a/include/aspect/material_model/rheology/constant_viscosity_prefactors.h.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-  Copyright (C) 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_constant_viscosity_prefactors_h
-#define _aspect_material_model_rheology_constant_viscosity_prefactors_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      /**
-       * A class that handles multiplication of viscosity for a given compositional
-       * field. The multiplication factors for each composition (constant viscosity
-       * prefactors) are also declared and parsed in this class.
-       */
-      template <int dim>
-      class ConstantViscosityPrefactors : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ConstantViscosityPrefactors();
-
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-          /**
-           * Compute the viscosity.
-           */
-          double
-          compute_viscosity (const double base_viscosity,
-                             const unsigned int composition_index) const;
-
-        private:
-          /**
-           * The constant viscosity prefactors, which are read in
-           * from the input file by the parse_parameters() function.
-           * The total number of prefactors will be equal to one
-           * plus the number of compositional fields. The prefactor
-           * for a given compositional field is multiplied with a
-           * base_viscosity value provided by the material model, which
-           * is then returned to the material model.
-           */
-          std::vector<double> constant_viscosity_prefactors;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/diffusion_creep.h.bak b/include/aspect/material_model/rheology/diffusion_creep.h.bak
deleted file mode 100644
index 5146a371806..00000000000
--- a/include/aspect/material_model/rheology/diffusion_creep.h.bak
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_diffusion_creep_h
-#define _aspect_material_model_rheology_diffusion_creep_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      /**
-       * Data structure for diffusion creep parameters.
-       */
-      struct DiffusionCreepParameters
-      {
-        /**
-         * The diffusion creep prefactor, activation energy, activation volume
-         * and grain size exponent.
-         */
-        double prefactor;
-        double activation_energy;
-        double activation_volume;
-        double stress_exponent;
-        double grain_size_exponent;
-
-        /**
-         * Constructor. Initializes all values to NaN.
-         */
-        DiffusionCreepParameters();
-      };
-
-      template <int dim>
-      class DiffusionCreep : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          DiffusionCreep();
-
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           * If @p expected_n_phases_per_composition points to a vector of
-           * unsigned integers this is considered the number of phases
-           * for each compositional field and will be checked against the parsed
-           * parameters.
-           */
-          void
-          parse_parameters (ParameterHandler &prm,
-                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
-
-
-          /**
-           * Compute the creep parameters for the diffusion creep law.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          const DiffusionCreepParameters
-          compute_creep_parameters (const unsigned int composition,
-                                    const std::vector<double> &phase_function_values = std::vector<double>(),
-                                    const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the viscosity based on the diffusion creep law.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          double
-          compute_viscosity (const double pressure,
-                             const double temperature,
-                             const unsigned int composition,
-                             const std::vector<double> &phase_function_values = std::vector<double>(),
-                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the strain rate and first stress derivative as a function
-           * of stress based on the diffusion creep law.
-           */
-          std::pair<double, double>
-          compute_strain_rate_and_derivative (const double stress,
-                                              const double pressure,
-                                              const double temperature,
-                                              const DiffusionCreepParameters creep_parameters) const;
-
-          /**
-           * Compute the logarithm of strain rate and first derivative with respect to
-           * the logarithm of the stress based on the diffusion creep law.
-           */
-          std::pair<double, double>
-          compute_log_strain_rate_and_derivative (const double log_stress,
-                                                  const double pressure,
-                                                  const double temperature,
-                                                  const DiffusionCreepParameters creep_parameters) const;
-
-        private:
-
-          /**
-           * List of diffusion creep prefactors A.
-           */
-          std::vector<double> prefactors_diffusion;
-
-          /**
-           * List of diffusion creep stress exponents n (usually = 1).
-           */
-          std::vector<double> stress_exponents_diffusion;
-
-          /**
-           * List of diffusion creep grain size exponents m.
-           */
-          std::vector<double> grain_size_exponents_diffusion;
-
-          /**
-           * List of diffusion creep activation energies E.
-           */
-          std::vector<double> activation_energies_diffusion;
-
-          /**
-           * List of diffusion creep activation volumes V.
-           */
-          std::vector<double> activation_volumes_diffusion;
-
-          /**
-           * Diffusion creep grain size d.
-           */
-          double grain_size;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/diffusion_dislocation.h.bak b/include/aspect/material_model/rheology/diffusion_dislocation.h.bak
deleted file mode 100644
index 49315dda652..00000000000
--- a/include/aspect/material_model/rheology/diffusion_dislocation.h.bak
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
-  Copyright (C) 2011 - 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_diffusion_dislocation_h
-#define _aspect_material_model_rheology_diffusion_dislocation_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/rheology/diffusion_creep.h>
-#include <aspect/material_model/rheology/dislocation_creep.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      /**
-       * A viscous rheology including diffusion and dislocation creep.
-       *
-       * The effective viscosity is defined as the harmonic mean of the two
-       * effective viscosity functions describing diffusion and dislocation creep:
-       * @f[
-       *   v_\text{eff} = \left( \frac{1}{v_\text{eff}^\text{diff}} + \frac{1}{v_\text{eff}^\text{dis}} \right)^{-1}
-       * @f]
-       * where
-       * @f[
-       *   v_\text{eff}^\text{diff} = A_\text{diff}^{-1} \exp\left(\frac{E_\text{diff} + PV_\text{diff}}{RT}\right),
-       * @f]
-       * and
-       * @f[
-       *   v_\text{eff}^\text{dis} =  A_\text{dis}^{\frac{-1}{n_\text{dis}}} \dot{\varepsilon}^{\frac{1-n}{n}}
-       *                        \exp\left(\frac{E_\text{diff} + PV_\text{diff}}{n_\text{dis}RT}\right)
-       * @f]
-       * where $\dot{\varepsilon}$ is the second invariant of the strain rate tensor,
-       * $A_i$ are prefactors where $i$ corresponds to diffusion or dislocation creep,
-       * $E_i$ are the activation energies, $V_i$ are the activation volumes,
-       * $\rho_m$ is the mantle density, $R$ is the gas constant,
-       * $T$ is temperature, and $P$ is pressure.
-       *
-       * Rheological parameters can be defined per-compositional field.
-       * For each material parameter the user supplies a comma delimited list of
-       * length N+1, where N is the number of compositional fields.  The
-       * additional field corresponds to the value for background mantle.  They
-       * should be ordered ``background, composition1, composition2...''
-       *
-       * The individual output viscosities for each compositional field are
-       * averaged. The user can choose from a range of options for this
-       * viscosity averaging. If only one value is given for any of these parameters,
-       * all compositions are assigned the same value.
-       * The first value in the list is the value assigned to "background mantle"
-       * (regions where the sum of the compositional fields is < 1.0).
-       */
-      template <int dim>
-      class DiffusionDislocation : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          DiffusionDislocation();
-
-          /**
-           * Calculate the viscosities for each compositional field
-           * assuming that each composition experiences the same strain rate.
-           */
-          std::vector<double>
-          calculate_isostrain_viscosities ( const double pressure,
-                                            const double temperature,
-                                            const SymmetricTensor<2,dim> &strain_rate) const;
-
-          /**
-           * Compute the viscosity based on the composite viscous creep law,
-           * averaging over all compositional fields according to their
-           * volume fractions.
-           */
-          double
-          compute_viscosity (const double pressure,
-                             const double temperature,
-                             const std::vector<double> &volume_fractions,
-                             const SymmetricTensor<2,dim> &strain_rate) const;
-
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          void
-          parse_parameters (ParameterHandler &prm);
-
-        private:
-          /**
-           * Objects for computing viscous creep viscosities.
-           */
-          Rheology::DiffusionCreep<dim> diffusion_creep;
-          Rheology::DislocationCreep<dim> dislocation_creep;
-
-          /**
-           * Defining a minimum strain rate stabilizes the viscosity calculation,
-           * which involves a division by the strain rate. Units: 1/s.
-           */
-          double min_strain_rate;
-          double minimum_viscosity;
-          double maximum_viscosity;
-
-          double log_strain_rate_residual_threshold;
-          unsigned int stress_max_iteration_number;
-
-          double grain_size;
-          unsigned int n_chemical_composition_fields;
-
-          MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
-
-      };
-
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/dislocation_creep.h.bak b/include/aspect/material_model/rheology/dislocation_creep.h.bak
deleted file mode 100644
index a655183450a..00000000000
--- a/include/aspect/material_model/rheology/dislocation_creep.h.bak
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_dislocation_creep_h
-#define _aspect_material_model_rheology_dislocation_creep_h
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      /**
-       * Data structure for dislocation creep parameters.
-       */
-      struct DislocationCreepParameters
-      {
-        /**
-         * The dislocation creep prefactor, activation energy, activation volume
-         * and stress exponent.
-         */
-        double prefactor;
-        double activation_energy;
-        double activation_volume;
-        double stress_exponent;
-
-        /**
-         * Constructor. Initializes all values to NaN.
-         */
-        DislocationCreepParameters();
-      };
-
-      template <int dim>
-      class DislocationCreep : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          DislocationCreep();
-
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           * If @p expected_n_phases_per_composition points to a vector of
-           * unsigned integers this is considered the number of phases
-           * for each compositional field and will be checked against the parsed
-           * parameters.
-           */
-          void
-          parse_parameters (ParameterHandler &prm,
-                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
-
-          /**
-           * Compute the creep parameters for the dislocation creep law.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          const DislocationCreepParameters
-          compute_creep_parameters (const unsigned int composition,
-                                    const std::vector<double> &phase_function_values = std::vector<double>(),
-                                    const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the viscosity based on the dislocation creep law.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          double
-          compute_viscosity (const double strain_rate,
-                             const double pressure,
-                             const double temperature,
-                             const unsigned int composition,
-                             const std::vector<double> &phase_function_values = std::vector<double>(),
-                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the strain rate and first stress derivative
-           * as a function of stress based on the dislocation creep law.
-           */
-          std::pair<double, double>
-          compute_strain_rate_and_derivative (const double stress,
-                                              const double pressure,
-                                              const double temperature,
-                                              const DislocationCreepParameters creep_parameters) const;
-
-          /**
-           * Compute the logarithm of strain rate and first derivative with respect to
-           * the logarithm of the stress based on the dislocation creep law.
-           */
-          std::pair<double, double>
-          compute_log_strain_rate_and_derivative (const double log_stress,
-                                                  const double pressure,
-                                                  const double temperature,
-                                                  const DislocationCreepParameters creep_parameters) const;
-
-        private:
-
-          /**
-           * List of dislocation creep prefactors A.
-           */
-          std::vector<double> prefactors_dislocation;
-
-          /**
-           * List of dislocation creep stress exponents n.
-           */
-          std::vector<double> stress_exponents_dislocation;
-
-          /**
-           * List of dislocation creep activation energies E.
-           */
-          std::vector<double> activation_energies_dislocation;
-
-          /**
-           * List of dislocation creep activation volumes V.
-           */
-          std::vector<double> activation_volumes_dislocation;
-
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/drucker_prager.h.bak b/include/aspect/material_model/rheology/drucker_prager.h.bak
deleted file mode 100644
index d787f070357..00000000000
--- a/include/aspect/material_model/rheology/drucker_prager.h.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_drucker_prager_h
-#define _aspect_material_model_rheology_drucker_prager_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-
-#include <aspect/material_model/utilities.h>
-#include <aspect/simulator_access.h>
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      /**
-       * A data structure with all input file parameters relevant to
-       * Drucker-Prager plasticity.
-       */
-      struct DruckerPragerParameters
-      {
-        /**
-         * Internal friction angle (phi) for the current composition and phase
-         */
-        double angle_internal_friction;
-
-        /**
-         * Cohesion for the current composition and phase
-         */
-        double cohesion;
-
-        /**
-         * Limit maximum yield stress from drucker prager yield criterion.
-         */
-        double max_yield_stress;
-
-        /**
-         * Constructor. Initializes all values to NaN.
-         */
-        DruckerPragerParameters();
-      };
-
-      template <int dim>
-      class DruckerPrager : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          DruckerPrager();
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           * If @p expected_n_phases_per_composition points to a vector of
-           * unsigned integers, this is considered the number of phases
-           * for each compositional field (plus possibly a background field)
-           * and this number will be checked against the parsed parameters.
-           *
-           * @param [in] prm The ParameterHandler to read from.
-           * @param expected_n_phases_per_composition Optional list of number of phases.
-           */
-          void
-          parse_parameters (ParameterHandler &prm,
-                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
-
-          /**
-           * Compute the parameters for the Drucker Prager plasticity.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          const DruckerPragerParameters
-          compute_drucker_prager_parameters (const unsigned int composition,
-                                             const std::vector<double> &phase_function_values = std::vector<double>(),
-                                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the plastic yield stress based on the Drucker Prager yield criterion.
-           */
-          double
-          compute_yield_stress (const double cohesion,
-                                const double angle_internal_friction,
-                                const double pressure,
-                                const double max_yield_stress) const;
-
-          /**
-           * Compute the apparent viscosity using the yield stress and effective strain rate.
-           * If the non_yielding_viscosity is not infinite
-           * (i.e., if there are other rheological elements accommodating strain), the returned
-           * value is the effective composite viscosity, not the pure "plastic" viscosity.
-           */
-          double
-          compute_viscosity (const double cohesion,
-                             const double angle_internal_friction,
-                             const double pressure,
-                             const double effective_strain_rate,
-                             const double max_yield_stress,
-                             const double non_yielding_viscosity = std::numeric_limits<double>::infinity()) const;
-
-          /**
-           * Compute the strain rate and first stress derivative
-           * as a function of stress based on the damped Drucker-Prager flow law.
-           */
-          std::pair<double, double>
-          compute_strain_rate_and_derivative (const double stress,
-                                              const double pressure,
-                                              const DruckerPragerParameters p) const;
-
-          /**
-           * Compute the derivative of the plastic viscosity with respect to pressure.
-           */
-          double
-          compute_derivative (const double angle_internal_friction,
-                              const double effective_strain_rate) const;
-
-        private:
-
-          std::vector<double> angles_internal_friction;
-          std::vector<double> cohesions;
-          double max_yield_stress;
-
-          /**
-           * Whether to add a plastic damper in the computation
-           * of the drucker prager plastic viscosity.
-           */
-          bool use_plastic_damper;
-
-          /**
-           * Viscosity of a damper used to stabilize plasticity
-           */
-          double damper_viscosity;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/elasticity.h.bak b/include/aspect/material_model/rheology/elasticity.h.bak
deleted file mode 100644
index f3f3698c8f6..00000000000
--- a/include/aspect/material_model/rheology/elasticity.h.bak
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
-  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_elasticity_h
-#define _aspect_material_model_rheology_elasticity_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/matrix_free/fe_point_evaluation.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * Additional output fields for the elastic shear modulus to be added to
-     * the MaterialModel::MaterialModelOutputs structure and filled in the
-     * MaterialModel::Interface::evaluate() function.
-     */
-    template <int dim>
-    class ElasticAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        explicit ElasticAdditionalOutputs(const unsigned int n_points);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * Elastic shear moduli at the evaluation points passed to
-         * the instance of MaterialModel::Interface::evaluate() that fills
-         * the current object.
-         */
-        std::vector<double> elastic_shear_moduli;
-    };
-
-
-
-    namespace Rheology
-    {
-      template <int dim>
-      class Elasticity : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-          /**
-           * Create the additional material model outputs object that contains the
-           * elastic shear moduli.
-           */
-          void
-          create_elastic_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-          /**
-           * Given the stress of the previous time step in the material model inputs @p in,
-           * the elastic shear moduli @p average_elastic_shear_moduli a each point,
-           * and the (viscous) viscosities given in the material model outputs object @p out,
-           * fill an additional material model outputs objects with the elastic force terms.
-           */
-          void
-          fill_elastic_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
-                                const std::vector<double> &average_elastic_shear_moduli,
-                                MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-          /**
-           * Given the stress of the previous time step in the material model inputs @p in,
-           * the elastic shear moduli @p average_elastic_shear_moduli a each point,
-           * and the (viscous) viscosities given in the material model outputs object @p out,
-           * compute an update to the elastic stresses and use it to fill the reaction terms
-           * material model output property.
-           */
-          void
-          fill_reaction_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
-                                 const std::vector<double> &average_elastic_shear_moduli,
-                                 MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-          /**
-           * Return the values of the elastic shear moduli for each composition used in the
-           * rheology model.
-           */
-          const std::vector<double> &
-          get_elastic_shear_moduli () const;
-
-          /**
-           * Calculates the effective elastic viscosity (this is the equivalent viscosity of
-           * a material which was unstressed at the end of the previous timestep).
-           */
-          double
-          calculate_elastic_viscosity (const double shear_modulus) const;
-
-          /**
-           * Given the (viscous or visco-plastic) viscosity and the shear modulus, compute the viscoelastic
-           * viscosity (eqn 28 in Moresi et al., 2003, J. Comp. Phys.).
-           */
-          double
-          calculate_viscoelastic_viscosity (const double viscosity,
-                                            const double shear_modulus) const;
-
-          /**
-           * Calculate the effective deviatoric strain rate tensor,
-           * which equals the true deviatoric strain rate plus
-           * a fictional strain rate which would arise from stored elastic stresses.
-           * In ASPECT, this additional strain rate is
-           * supported by a fictional body force.
-           * This formulation allows the use of an isotropic effective viscosity
-           * by ensuring that the resulting strain rate tensor is equal to the
-           * total current stress tensor multiplied by a scalar.
-           */
-          SymmetricTensor<2,dim>
-          calculate_viscoelastic_strain_rate (const SymmetricTensor<2,dim> &strain_rate,
-                                              const SymmetricTensor<2,dim> &stored_stress,
-                                              const double shear_modulus) const;
-
-          /**
-           * Compute the elastic time step.
-           */
-          double
-          elastic_timestep () const;
-
-        private:
-          /**
-           * Viscosity of a damper used to stabilize elasticity.
-           * A value of 0 Pas is equivalent to not using a damper.
-           */
-          double elastic_damper_viscosity;
-
-          /**
-           * Vector for field elastic shear moduli, read from parameter file.
-           */
-          std::vector<double> elastic_shear_moduli;
-
-          /**
-           * Bool indicating whether to use a fixed material time scale in the
-           * viscoelastic rheology for all time steps (if true) or to use the
-           * actual (variable) advection time step of the model (if false). Read
-           * from parameter file.
-           */
-          bool use_fixed_elastic_time_step;
-
-          /**
-           * Double for fixed elastic time step value, read from parameter file
-           */
-          double fixed_elastic_time_step;
-
-          /**
-           * A stabilization factor for the elastic stresses that influences how
-           * fast elastic stresses adjust to deformation. 1.0 is equivalent to no
-           * stabilization, and infinity is equivalent to not applying elastic
-           * stresses at all. The factor is multiplied with the computational
-           * time step to create a time scale.
-           */
-          double stabilization_time_scale_factor;
-
-          /**
-           * We cache the evaluator that is necessary to evaluate the old velocity
-           * gradients. They are required to compute the elastic stresses, but
-           * are not provided by the material model.
-           * By caching the evaluator, we can avoid recreating it every time we
-           * need it.
-           */
-          mutable std::unique_ptr<FEPointEvaluation<dim, dim>> evaluator;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/frank_kamenetskii.h.bak b/include/aspect/material_model/rheology/frank_kamenetskii.h.bak
deleted file mode 100644
index a63e3c9d53b..00000000000
--- a/include/aspect/material_model/rheology/frank_kamenetskii.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_frank_kamenetskii_h
-#define _aspect_material_model_rheology_frank_kamenetskii_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      /**
-       * A class that computes a Frank-Kamenetskii viscosity approximation
-       * of the form:
-       * viscosity = A * exp(E * 0.5 * (1.0-(T/ref_T)) + F * (P-ref_P)/(rho*g*h))
-       * A: prefactor of viscosity, E: adjusted viscosity ratio,
-       * ref_T: reference temperature, T: temperature. F: prefactor of pressure,
-       * ref_P: reference pressure, rho: density, g: gravity, h, model depth
-       *
-       * Refer to Noack and Breuer, 2013, GJI. doi: 10.1093/gji/ggt248 Eq. 2.10 for reference.
-       */
-
-      template <int dim>
-      class FrankKamenetskii : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          FrankKamenetskii();
-
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-          /**
-           * Compute the viscosity based on the Frank-Kamenetskii approximation.
-           */
-          double
-          compute_viscosity (const double temperature,
-                             const unsigned int composition,
-                             const double pressure = std::numeric_limits<double>::infinity(),
-                             const double density = std::numeric_limits<double>::infinity(),
-                             const double gravity = std::numeric_limits<double>::infinity()) const;
-
-        private:
-          /**
-           * List of Frank-Kamenetskii viscosity ratios (E).
-           */
-          std::vector<double> viscosity_ratios_frank_kamenetskii;
-
-          /**
-           * List of Frank-Kamenetskii prefactors (A).
-           */
-          std::vector<double> prefactors_frank_kamenetskii;
-
-          /**
-           * List of Frank-Kamenetskii pressure prefactors (F).
-           */
-          std::vector<double> pressure_prefactors_frank_kamenetskii;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/friction_models.h.bak b/include/aspect/material_model/rheology/friction_models.h.bak
deleted file mode 100644
index fb23ef023a4..00000000000
--- a/include/aspect/material_model/rheology/friction_models.h.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_friction_models_h
-#define _aspect_material_model_rheology_friction_models_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <deal.II/base/parsed_function.h>
-#include <aspect/utilities.h>
-
-#include <aspect/material_model/rheology/drucker_prager.h>
-#include <deal.II/fe/component_mask.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-    namespace Rheology
-    {
-      /**
-       * Enumeration for selecting which type of friction dependence to use.
-       *
-       * For the type 'static friction', the user-supplied internal angle of friction is used.
-       *
-       * For the type 'dynamic friction', the friction angle is rate dependent following
-       * Equation 13 from \\cite{van_dinther_seismic_2013}.
-       */
-      enum FrictionMechanism
-      {
-        static_friction,
-        dynamic_friction,
-        function
-      };
-
-      template <int dim>
-      class FrictionModels : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-          /**
-           * A function that computes the new friction angle when it is not independent.
-           * Given a volume fraction with the index and a vector of all compositional
-           * fields, it returns the newly calculated friction angle.
-           */
-          double
-          compute_friction_angle(const double current_edot_ii,
-                                 const unsigned int volume_fraction_index,
-                                 const double static_friction_angle,
-                                 const Point<dim> &position) const;
-
-          /**
-           * A function that returns the selected type of friction dependence.
-           */
-          FrictionMechanism
-          get_friction_mechanism () const;
-
-        private:
-          /**
-           * Select the mechanism to be used for the friction dependence.
-           * Possible options: static friction | dynamic friction | function
-           */
-          FrictionMechanism friction_mechanism;
-
-          /**
-           * Dynamic friction input parameters
-           */
-
-          /**
-           * Dynamic angles of internal friction that are used at high strain rates.
-           */
-          std::vector<double> dynamic_angles_of_internal_friction;
-
-          /**
-           * The characteristic strain rate value at which the angle of friction is taken as
-           * the mean of the dynamic and the static angle of friction. When the effective
-           * strain rate in a cell is very high the dynamic angle of friction is taken, when
-           * it is very low the static angle of internal friction is chosen.
-           */
-          double dynamic_characteristic_strain_rate;
-
-          /**
-           * An exponential factor in the equation for the calculation of the friction angle
-           * to make the transition between static and dynamic friction angle more smooth or
-           * more step-like.
-           */
-          double dynamic_friction_smoothness_exponent;
-
-          /**
-           * Parsed functions that specify the friction angle which must be
-           * given in the input file using the function method.
-           */
-          std::unique_ptr<Functions::ParsedFunction<dim>> friction_function;
-
-          /**
-           * The coordinate representation to evaluate the function for the friction angle.
-           * Possible choices are depth, cartesian and spherical.
-           */
-          Utilities::Coordinates::CoordinateSystem coordinate_system_friction_function;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/peierls_creep.h.bak b/include/aspect/material_model/rheology/peierls_creep.h.bak
deleted file mode 100644
index a63f863ebaf..00000000000
--- a/include/aspect/material_model/rheology/peierls_creep.h.bak
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_peierls_creep_h
-#define _aspect_material_model_rheology_peierls_creep_h
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      /**
-       * Data structure for Peierls creep parameters.
-       */
-      struct PeierlsCreepParameters
-      {
-        /**
-         * The Peierls creep prefactor, stress exponent, activation energy,
-         * activation volume, Peierls stress, glide parameters p and q
-         * and fitting parameter,
-         */
-        double prefactor;
-        double stress_exponent;
-        double activation_energy;
-        double activation_volume;
-        double peierls_stress;
-        double glide_parameter_p;
-        double glide_parameter_q;
-        double fitting_parameter;
-        double stress_cutoff;
-
-        /**
-         * Constructor. Initializes all values to NaN.
-         */
-        PeierlsCreepParameters();
-      };
-
-      /**
-       * Peierls creep is a low temperature, high stress viscous deformation mechanism.
-       * Crystal deformation occurs through dislocation glide, which requires high stresses.
-       * It is considered an important deformation mechanism in the lithosphere and subducting
-       * slabs (Kumamoto et al., 2017, Science Advances). The approximate form of the Peierls
-       * flow law used here is based on a derivation from Kameyama et al., 1999, Earth and
-       * Planetary Science Letters.
-       */
-      template <int dim>
-      class PeierlsCreep : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          PeierlsCreep();
-
-          /**
-           * Compute the creep parameters for the Peierls creep law.
-           */
-          const PeierlsCreepParameters
-          compute_creep_parameters (const unsigned int composition,
-                                    const std::vector<double> &phase_function_values = std::vector<double>(),
-                                    const std::vector<unsigned int> &n_phases_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters from the parameter file.
-           * If @p expected_n_phases_per_composition points to a vector of
-           * unsigned integers this is considered the number of phases
-           * for each compositional field and will be checked against the parsed
-           * parameters.
-           */
-          void
-          parse_parameters (ParameterHandler &prm,
-                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
-
-          /**
-           * Compute the viscosity based on the approximate Peierls creep flow law.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          double
-          compute_approximate_viscosity (const double strain_rate,
-                                         const double pressure,
-                                         const double temperature,
-                                         const unsigned int composition,
-                                         const std::vector<double> &phase_function_values = std::vector<double>(),
-                                         const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the viscosity based on the exact Peierls creep flow law.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          double
-          compute_exact_viscosity (const double strain_rate,
-                                   const double pressure,
-                                   const double temperature,
-                                   const unsigned int composition,
-                                   const std::vector<double> &phase_function_values = std::vector<double>(),
-                                   const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the viscosity based on the selected Peierls creep flow law.
-           * This function uses either the compute_approximate_viscosity
-           * or the compute_exact_viscosity function.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          double
-          compute_viscosity (const double strain_rate,
-                             const double pressure,
-                             const double temperature,
-                             const unsigned int composition,
-                             const std::vector<double> &phase_function_values = std::vector<double>(),
-                             const std::vector<unsigned int> &n_phase_transitions_per_composition = std::vector<unsigned int>()) const;
-
-          /**
-           * Compute the strain rate and first stress derivative
-           * as a function of stress based on the approximate Peierls creep law.
-           */
-          std::pair<double, double>
-          compute_approximate_strain_rate_and_derivative (const double stress,
-                                                          const double pressure,
-                                                          const double temperature,
-                                                          const PeierlsCreepParameters creep_parameters) const;
-
-          /**
-           * Compute the strain rate and first stress derivative
-           * as a function of stress based on the exact Peierls creep law.
-           */
-          std::pair<double, double>
-          compute_exact_strain_rate_and_derivative (const double stress,
-                                                    const double pressure,
-                                                    const double temperature,
-                                                    const PeierlsCreepParameters creep_parameters) const;
-
-          /**
-           * Compute the natural logarithm of the strain rate norm and its first
-           * derivative with respect to the natural logarithm of the stress norm
-           * based on the exact Peierls creep law.
-           */
-          std::pair<double, double>
-          compute_exact_log_strain_rate_and_derivative (const double log_stress,
-                                                        const double pressure,
-                                                        const double temperature,
-                                                        const PeierlsCreepParameters creep_parameters) const;
-
-          /**
-           * Compute the strain rate and first stress derivative
-           * as a function of stress based on the selected Peierls creep law.
-           * This function uses either the
-           * compute_approximate_strain_rate_and_derivative
-           * or the compute_exact_strain_rate_and_derivative function.
-           */
-          std::pair<double, double>
-          compute_strain_rate_and_derivative (const double stress,
-                                              const double pressure,
-                                              const double temperature,
-                                              const PeierlsCreepParameters creep_parameters) const;
-
-        private:
-          /**
-           * Enumeration for selecting which type of Peierls creep flow law to use.
-           * The options are currently "exact" (which requires a Newton-Raphson iteration
-           * in compute_viscosity) and "viscosity_approximation", which
-           * uses a simplified expression where the strain rate has a power law dependence
-           * on the stress (so that the equation can be directly inverted for viscosity).
-           * This approximation requires specifying one fitting parameter (gamma) to
-           * obtain the best fit in the expected stress range for a given problem
-           * (gamma = stress / peierls_stress). The derivation for this approximation
-           * (derived by Magali Billen) can be found at:
-           * https://ucdavis.app.box.com/s/cl5mwhkjeabol4otrdukfcdwfvg9me4w/file/705438695737.
-           */
-          enum PeierlsCreepScheme
-          {
-            viscosity_approximation,
-            exact
-          } peierls_creep_flow_law;
-
-          /**
-           * List of Peierls creep prefactors (A).
-           */
-          std::vector<double> prefactors;
-
-          /**
-           * List of Peierls creep stress exponents (n).
-           */
-          std::vector<double> stress_exponents;
-
-          /**
-           * List of Peierls creep activation energies (E).
-           */
-          std::vector<double> activation_energies;
-
-          /**
-           * List of Peierls creep activation volumes (V).
-           */
-          std::vector<double> activation_volumes;
-
-          /**
-           * List of Peierls stresses (sigma_p).
-           */
-          std::vector<double> peierls_stresses;
-
-          /**
-           * List of Peierls fitting parameters (gamma).
-           */
-          std::vector<double> fitting_parameters;
-
-          /**
-           * List of the first Peierls parameter related
-           * to dislocation glide (p).
-           */
-          std::vector<double> glide_parameters_p;
-
-          /**
-           * List of the second Peierls parameter related
-           * to dislocation glide (q).
-           */
-          std::vector<double> glide_parameters_q;
-
-          std::vector<double> stress_cutoffs;
-
-          /**
-           * A parameter determines whether a strict cutoff
-           * on the stress is applied to the Peierls creep
-          */
-          bool apply_strict_cutoff;
-
-          /**
-           * Parameters governing the iteration for the exact
-           * Peierls viscosity.
-           */
-          double strain_rate_residual_threshold;
-          unsigned int stress_max_iteration_number;
-
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/strain_dependent.h.bak b/include/aspect/material_model/rheology/strain_dependent.h.bak
deleted file mode 100644
index 3e23c658077..00000000000
--- a/include/aspect/material_model/rheology/strain_dependent.h.bak
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
-  Copyright (C) 2019 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_strain_dependent_h
-#define _aspect_material_model_rheology_strain_dependent_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-#include<deal.II/fe/component_mask.h>
-#include <deal.II/matrix_free/fe_point_evaluation.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace Rheology
-    {
-      /**
-       * Enumeration for selecting which type of weakening mechanism to use.
-       * For none, no strain weakening occurs.
-       * Otherwise, the material can be weakened based on the second
-       * invariant of the full finite strain tensor, the total accumulated
-       * strain, or the plastic strain and viscous strain can be tracked
-       * separately and used only for the corresponding (plastic or viscous)
-       * part of the viscosity computation.
-       */
-      enum WeakeningMechanism
-      {
-        none,
-        finite_strain_tensor,
-        total_strain,
-        plastic_weakening_with_plastic_strain_only,
-        plastic_weakening_with_total_strain_only,
-        plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain,
-        viscous_weakening_with_viscous_strain_only
-      };
-
-      /**
-       * Enumeration for selecting which type of healing mechanism to use.
-       * For the case no healing, no strain healing occurs.
-       * Otherwise, the strain is healed (reduced) as a function of temperature,
-       * a user defined healing time scale and additional parameters.
-       * Future models could consider strain healing formulations that are a function
-       * of time, deformation rate, or other parameters.
-       */
-      enum HealingMechanism
-      {
-        no_healing,
-        temperature_dependent
-      };
-
-      template <int dim>
-      class StrainDependent : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-          /**
-           * A function that computes by how much the rheologic parameters change
-           * if strain weakening is applied. Given a vector @p composition of all
-           * fields, it returns reduction factors for the cohesion, friction angle
-           * and the prefactor of the viscous flow law(s) for the compositional
-           * field with index @p j. The reason all fields are passed is that
-           * the weakening factors can depend on the values of fields that track
-           * different measures of previously applied strain.
-           */
-          std::array<double, 3>
-          compute_strain_weakening_factors(const std::vector<double> &composition,
-                                           const unsigned int j) const;
-
-          /**
-           * @deprecated: Deprecated version of the function of the same
-           * name described above.
-          */
-          DEAL_II_DEPRECATED
-          std::array<double, 3>
-          compute_strain_weakening_factors(const unsigned int j,
-                                           const std::vector<double> &composition) const;
-
-          /**
-           * A function that alters the viscous weakening factor based on the
-           * temperature field.
-           */
-          std::array<double, 3>
-          apply_temperature_dependence_to_strain_weakening_factors(const std::array<double, 3> &weakening_factors,
-                                                                   const double temperature,
-                                                                   const unsigned int j) const;
-
-          /**
-           * A function that computes the strain healing (reduction in accumulated strain)
-           */
-          double
-          calculate_strain_healing (const MaterialModel::MaterialModelInputs<dim> &in,
-                                    const unsigned int j) const;
-
-          /**
-           * A function that computes by how much the cohesion and internal friction
-           * angle for a given compositional field are weakened under the influence
-           * of a given strain.
-           */
-          std::pair<double, double>
-          calculate_plastic_weakening (const double strain_ii,
-                                       const unsigned int j) const;
-
-          /**
-           * A function that computes by how much the diffusion and dislocation
-           * prefactors for a given compositional field are weakened under the
-           * influence of a given strain.
-           */
-          double
-          calculate_viscous_weakening (const double strain_ii,
-                                       const unsigned int j) const;
-
-          /**
-           * Whether to use the temperature-activated viscous strain weakening.
-          */
-          bool use_temperature_activated_strain_softening;
-
-          /**
-           * A function that fills the reaction terms for the finite strain tensor in
-           * MaterialModelOutputs object that is handed over. It assumes the first
-           * component of the finite strain tensor is named 's11' and all other
-           * components follow this compositional field.
-           */
-          void compute_finite_strain_reaction_terms (const MaterialModel::MaterialModelInputs<dim> &in,
-                                                     MaterialModel::MaterialModelOutputs<dim> &out) const;
-          /**
-           * A function that fills the reaction terms for the finite strain invariant(s) in
-           * MaterialModelOutputs object that is handed over.
-           */
-          void fill_reaction_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
-                                      const int i,
-                                      const double min_strain_rate,
-                                      const bool plastic_yielding,
-                                      MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-          /**
-           * A function that returns a ComponentMask, which indicates that components
-           * associated with strain should be excluded during the volume fraction computation.
-           */
-          ComponentMask get_strain_composition_mask() const;
-
-          /**
-           * A function that returns the selected type of strain weakening mechanism.
-           */
-          WeakeningMechanism
-          get_weakening_mechanism () const;
-
-          /**
-           * A function that returns the selected type of strain healing mechanism.
-           */
-          HealingMechanism
-          get_healing_mechanism () const;
-
-        private:
-
-          WeakeningMechanism weakening_mechanism;
-
-          HealingMechanism healing_mechanism;
-
-          /**
-           * The start of the strain interval (plastic or total strain)
-           * within which cohesion and angle of friction should be weakened.
-           */
-          std::vector<double> start_plastic_strain_weakening_intervals;
-
-          /**
-           * The end of the strain interval (plastic or total strain)
-           * within which cohesion and angle of friction should be weakened.
-           */
-          std::vector<double> end_plastic_strain_weakening_intervals;
-
-          /**
-           * The factor specifying the amount of weakening of the
-           * cohesion over the prescribed strain interval (plastic or total strain).
-           */
-          std::vector<double> cohesion_strain_weakening_factors;
-
-          /**
-           * The factor specifying the amount of weakening of the
-           * internal friction angles over the prescribed strain interval
-           * (plastic or total strain).
-           */
-          std::vector<double> friction_strain_weakening_factors;
-
-          /**
-           * The start of the strain interval (viscous or total strain)
-           * within which cohesion and angle of friction should be weakened.
-           */
-          std::vector<double> start_viscous_strain_weakening_intervals;
-
-          /**
-           * The end of the strain interval (viscous or total strain)
-           * within which cohesion and angle of friction should be weakened.
-           */
-          std::vector<double> end_viscous_strain_weakening_intervals;
-
-          /**
-           * The factor specifying the amount of weakening over
-           * the prescribed strain interval (viscous or total strain).
-           */
-          std::vector<double> viscous_strain_weakening_factors;
-
-          /**
-           * The four temperatures that parameterize the temperature-activated strain softening.
-           * These can be different for each compositional field.
-           * ------            -------- 1
-           *       \          /
-           *        \        /
-           *         \______/ _ _ _ _ _ viscous_weakening_factor[2]
-           *
-           * ----------------------------> T
-           *     T0  T1   T2  T3
-           */
-          std::vector<double> viscous_strain_weakening_T0;
-          std::vector<double> viscous_strain_weakening_T1;
-          std::vector<double> viscous_strain_weakening_T2;
-          std::vector<double> viscous_strain_weakening_T3;
-
-          /**
-           * The healing rate used in the temperature dependent strain healing model.
-           */
-          double strain_healing_temperature_dependent_recovery_rate;
-
-          /**
-           * A prefactor of viscosity used in the strain healing calculation.
-           */
-          double strain_healing_temperature_dependent_prefactor;
-
-          /**
-           * We cache the evaluators that are necessary to evaluate the velocity
-           * gradients and compositions.
-           * By caching the evaluator, we can avoid recreating them
-           * every time we need it.
-           */
-          mutable std::unique_ptr<FEPointEvaluation<dim, dim>> evaluator;
-          mutable std::vector<std::unique_ptr<FEPointEvaluation<1, dim>>> composition_evaluators;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/rheology/visco_plastic.h.bak b/include/aspect/material_model/rheology/visco_plastic.h.bak
deleted file mode 100644
index e4f6b171102..00000000000
--- a/include/aspect/material_model/rheology/visco_plastic.h.bak
+++ /dev/null
@@ -1,339 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_rheology_visco_plastic_h
-#define _aspect_material_model_rheology_visco_plastic_h
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/material_model/rheology/strain_dependent.h>
-#include <aspect/material_model/rheology/friction_models.h>
-#include <aspect/material_model/rheology/diffusion_creep.h>
-#include <aspect/material_model/rheology/dislocation_creep.h>
-#include <aspect/material_model/rheology/frank_kamenetskii.h>
-#include <aspect/material_model/rheology/peierls_creep.h>
-#include <aspect/material_model/rheology/constant_viscosity_prefactors.h>
-#include <aspect/material_model/rheology/compositional_viscosity_prefactors.h>
-#include <aspect/material_model/rheology/drucker_prager.h>
-#include <aspect/material_model/rheology/elasticity.h>
-#include <aspect/simulator_access.h>
-
-#include<deal.II/fe/component_mask.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * Additional output fields for the plastic parameters weakened (or hardened)
-     * by strain to be added to the MaterialModel::MaterialModelOutputs structure
-     * and filled in the MaterialModel::Interface::evaluate() function.
-     */
-    template <int dim>
-    class PlasticAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        PlasticAdditionalOutputs(const unsigned int n_points);
-
-        std::vector<double> get_nth_output(const unsigned int idx) const override;
-
-        /**
-         * Cohesions at the evaluation points passed to
-         * the instance of MaterialModel::Interface::evaluate() that fills
-         * the current object.
-         */
-        std::vector<double> cohesions;
-
-        /**
-         * Internal angles of friction at the evaluation points passed to
-         * the instance of MaterialModel::Interface::evaluate() that fills
-         * the current object.
-         */
-        std::vector<double> friction_angles;
-
-        /**
-         * The plastic yield stress.
-         */
-        std::vector<double> yield_stresses;
-
-        /**
-         * The area where the viscous stress exceeds the plastic yield stress,
-         * and viscosity is rescaled back to the yield envelope.
-         */
-        std::vector<double> yielding;
-
-    };
-
-    /**
-     * A data structure with the output of calculate_isostrain_viscosities.
-     */
-    struct IsostrainViscosities
-    {
-      /**
-       * The composition viscosity.
-       */
-      std::vector<double> composition_viscosities;
-
-      /**
-       * The composition yielding.
-       */
-      std::vector<bool> composition_yielding;
-
-      /**
-       * The current friction angle.
-       */
-      std::vector<double> current_friction_angles;
-
-      /**
-       * The current cohesion.
-       */
-      std::vector<double> current_cohesions;
-    };
-
-    namespace Rheology
-    {
-
-      template <int dim>
-      class ViscoPlastic : public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ViscoPlastic();
-
-          /**
-           * This function calculates viscosities assuming that all the compositional fields
-           * experience the same strain rate (isostrain).
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          IsostrainViscosities
-          calculate_isostrain_viscosities ( const MaterialModel::MaterialModelInputs<dim> &in,
-                                            const unsigned int i,
-                                            const std::vector<double> &volume_fractions,
-                                            const std::vector<double> &phase_function_values = std::vector<double>(),
-                                            const std::vector<unsigned int> &n_phase_transitions_per_composition =
-                                              std::vector<unsigned int>()) const;
-
-          /**
-           * A function that fills the viscosity derivatives in the
-           * MaterialModelOutputs object that is handed over, if they exist.
-           * Does nothing otherwise.
-           * If @p n_phase_transitions_per_composition points to a vector of
-           * unsigned integers this is considered the number of phase transitions
-           * for each compositional field and viscosity will be first computed on
-           * each phase and then averaged for each compositional field.
-           */
-          void compute_viscosity_derivatives(const unsigned int point_index,
-                                             const std::vector<double> &volume_fractions,
-                                             const std::vector<double> &composition_viscosities,
-                                             const MaterialModel::MaterialModelInputs<dim> &in,
-                                             MaterialModel::MaterialModelOutputs<dim> &out,
-                                             const std::vector<double> &phase_function_values = std::vector<double>(),
-                                             const std::vector<unsigned int> &n_phase_transitions_per_composition =
-                                               std::vector<unsigned int>()) const;
-
-          /**
-           * A function that returns a ComponentMask that represents all compositional
-           * fields that should be considered 'volumetric', that is representing a
-           * physical proportion of the material, e.g. volume fraction of peridotite
-           * (as opposed to non-volumetric quantities like the amount of finite-strain).
-           */
-          ComponentMask get_volumetric_composition_mask() const;
-
-          /**
-           * Declare the parameters this function takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           * If @p expected_n_phases_per_composition points to a vector of
-           * unsigned integers this is considered the number of phases
-           * for each compositional field and will be checked against the parsed
-           * parameters.
-           */
-          void
-          parse_parameters (ParameterHandler &prm,
-                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition = nullptr);
-
-          /**
-           * Create the additional material model outputs object that contains the
-           * plastic outputs.
-           */
-          void
-          create_plastic_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-          /**
-           * A function that fills the plastic additional output in the
-           * MaterialModelOutputs object that is handed over, if it exists.
-           * Does nothing otherwise.
-           */
-          void fill_plastic_outputs(const unsigned int point_index,
-                                    const std::vector<double> &volume_fractions,
-                                    const bool plastic_yielding,
-                                    const MaterialModel::MaterialModelInputs<dim> &in,
-                                    MaterialModel::MaterialModelOutputs<dim> &out,
-                                    const IsostrainViscosities &isostrain_viscosities) const;
-
-          /**
-           * Minimum strain rate used to stabilize the strain rate dependent rheology.
-           */
-          double min_strain_rate;
-
-          /**
-           * Enumeration for selecting which viscosity averaging scheme to use.
-           */
-          MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
-
-          /**
-           * Object for computing the strain dependence of the rheology model.
-           */
-          Rheology::StrainDependent<dim> strain_rheology;
-
-          /**
-           * Object for computing the friction dependence of the rheology model.
-           */
-          Rheology::FrictionModels<dim> friction_models;
-
-          /**
-           * Object for computing viscoelastic viscosities and stresses.
-           */
-          Rheology::Elasticity<dim> elastic_rheology;
-
-
-        private:
-
-          /**
-           * Reference strain rate for the first non-linear iteration
-           * in the first time step.
-           */
-          double ref_strain_rate;
-
-          /**
-           * Minimum and maximum viscosities used to improve the
-           * stability of the rheology model.
-           * These parameters contain one value per composition and phase (potentially the same value).
-           */
-          std::vector<double> minimum_viscosity;
-          std::vector<double> maximum_viscosity;
-
-          /**
-           * Enumeration for selecting which type of viscous flow law to use.
-           * Select between diffusion, dislocation, frank_kamenetskii or composite.
-           */
-          enum ViscosityScheme
-          {
-            diffusion,
-            dislocation,
-            frank_kamenetskii,
-            composite
-          } viscous_flow_law;
-
-          /**
-           * Enumeration for selecting which type of yield mechanism to use.
-           * Select between Drucker Prager and stress limiter.
-           */
-          enum YieldScheme
-          {
-            stress_limiter,
-            drucker_prager
-          } yield_mechanism;
-
-          /**
-           * Whether to allow negative pressures to be used in the computation
-           * of plastic yield stresses and viscosities. If false, the minimum
-           * pressure in the plasticity formulation will be set to zero.
-           */
-          bool allow_negative_pressures_in_plasticity;
-
-          /**
-           * Whether to use the adiabatic pressure instead of the full pressure (default)
-           * when calculating creep (diffusion, dislocation, and peierls) viscosity.
-           * This may be helpful in models where the full pressure has an unusually
-           * large negative value arising from large negative dynamic pressure,
-           * resulting in solver convergence issue and in some cases a viscosity
-           * of zero.
-           */
-          bool use_adiabatic_pressure_in_creep;
-
-          /**
-           * List of exponents controlling the behavior of the stress limiter
-           * yielding mechanism.
-           */
-          std::vector<double> exponents_stress_limiter;
-
-          /**
-           * Temperature gradient added to temperature used in the flow law.
-           */
-          double adiabatic_temperature_gradient_for_viscosity;
-
-          /**
-           * Objects for computing viscous creep viscosities.
-           */
-          Rheology::DiffusionCreep<dim> diffusion_creep;
-          Rheology::DislocationCreep<dim> dislocation_creep;
-          std::unique_ptr<Rheology::FrankKamenetskii<dim>> frank_kamenetskii_rheology;
-
-          /**
-           * Whether to include Peierls creep in the constitutive formulation.
-           */
-          bool use_peierls_creep;
-
-          /**
-           * Object for computing Peierls creep viscosities.
-           */
-          std::unique_ptr<Rheology::PeierlsCreep<dim>> peierls_creep;
-
-          /**
-           * Object for computing the viscosity multiplied by a constant prefactor.
-           * This multiplication step is done just prior to calculating the effective
-           * viscoelastic viscosity or plastic viscosity.
-           */
-          Rheology::ConstantViscosityPrefactors<dim> constant_viscosity_prefactors;
-
-          /**
-           * Object for computing the viscosity multiplied by a given prefactor term.
-           */
-          Rheology::CompositionalViscosityPrefactors<dim> compositional_viscosity_prefactors;
-
-          /*
-           * Object for computing plastic stresses, viscosities, and additional outputs
-           */
-          Rheology::DruckerPrager<dim> drucker_prager_plasticity;
-
-          /*
-           * Input parameters for the drucker prager plasticity.
-           */
-          Rheology::DruckerPragerParameters drucker_prager_parameters;
-
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/material_model/simple.h.bak b/include/aspect/material_model/simple.h.bak
deleted file mode 100644
index e266b0d0302..00000000000
--- a/include/aspect/material_model/simple.h.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_simple_h
-#define _aspect_material_model_simple_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that consists of globally constant values for all
-     * material parameters except density and viscosity.
-     *
-     * The model is considered incompressible, following the definition
-     * described in Interface::is_compressible. This is essentially the
-     * material model used in the step-32 tutorial program.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class Simple : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-      private:
-        double reference_T;
-        double eta;
-        double composition_viscosity_prefactor;
-        double thermal_viscosity_exponent;
-        double maximum_thermal_prefactor;
-        double minimum_thermal_prefactor;
-
-        /**
-         * The thermal conductivity.
-         */
-        double k_value;
-
-        EquationOfState::LinearizedIncompressible<dim> equation_of_state;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/simple_compressible.h.bak b/include/aspect/material_model/simple_compressible.h.bak
deleted file mode 100644
index 1658b3b147c..00000000000
--- a/include/aspect/material_model/simple_compressible.h.bak
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_simple_compressible_h
-#define _aspect_material_model_simple_compressible_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/rheology/constant_viscosity.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that consists of globally constant values for the
-     * viscosity, thermal conductivity, thermal expansivity
-     * and compressibility. The density decays linearly with the
-     * temperature and increases exponentially with pressure.
-     *
-     * The formulation for the density assumes that the compressibility
-     * provided by the user is the adiabatic compressibility ($\beta_S$).
-     * The thermal expansivity and isentropic compressibility implied by
-     * the pressure and temperature dependence are equal to the
-     * user-defined constant values only along the reference isentrope, and
-     * there is also an implicit pressure dependence to the heat capacity
-     * $C_p$ via Maxwell's relations.
-     *
-     * The model is considered incompressible or compressible, depending on
-     * the compressibility.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class SimpleCompressible : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate material properties.
-         */
-        void evaluate(const MaterialModelInputs<dim> &in,
-                      MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-      private:
-        /**
-         * The reference density
-         */
-        double reference_rho;
-
-        /**
-         * The constant thermal expansivity
-         */
-        double thermal_alpha;
-
-        /**
-         * The constant specific heat
-         */
-        double reference_specific_heat;
-
-        /**
-         * The constant compressibility.
-         */
-        double reference_compressibility;
-
-        /**
-         * The constant thermal conductivity.
-         */
-        double k_value;
-
-        /**
-         * The constant rheology model.
-         */
-        Rheology::ConstantViscosity constant_rheology;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/simpler.h.bak b/include/aspect/material_model/simpler.h.bak
deleted file mode 100644
index f2f89c8aa02..00000000000
--- a/include/aspect/material_model/simpler.h.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_simpler_h
-#define _aspect_material_model_simpler_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/rheology/constant_viscosity.h>
-#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that consists of globally constant values for all
-     * material parameters except the density, which depends linearly on the
-     * temperature. The model is considered incompressible.
-     *
-     * This material model implements what the "Simple" model was originally
-     * intended to do, before it got too complicated.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class Simpler : public Interface<dim>
-    {
-      public:
-
-        bool is_compressible () const override;
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * @}
-         */
-
-      private:
-        double k_value;
-
-        Rheology::ConstantViscosity constant_rheology;
-        EquationOfState::LinearizedIncompressible<dim> equation_of_state;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/steinberger.h.bak b/include/aspect/material_model/steinberger.h.bak
deleted file mode 100644
index f57aa7747be..00000000000
--- a/include/aspect/material_model/steinberger.h.bak
+++ /dev/null
@@ -1,335 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_steinberger_h
-#define _aspect_material_model_steinberger_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/equation_of_state/thermodynamic_table_lookup.h>
-
-#include <aspect/simulator_access.h>
-#include <deal.II/fe/component_mask.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    namespace internal
-    {
-      /**
-       * A class that reads in a text file that contains the
-       * temperature-dependency of viscosity for a set of equidistant depth
-       * layers. See
-       * the data/material-model/steinberger directory for an example data
-       * file.
-       * The class can return the value for a given depth.
-       */
-      class LateralViscosityLookup
-      {
-        public:
-          /**
-           * Read in a file.
-           */
-          LateralViscosityLookup(const std::string &filename,
-                                 const MPI_Comm comm);
-
-          /**
-           * Returns a temperature-dependency for a given depth.
-           */
-          double lateral_viscosity(double depth) const;
-
-          /**
-           * Number of depth slices of the read file.
-           */
-          int get_nslices() const;
-        private:
-          /**
-           * Stored values
-           */
-          std::vector<double> values;
-
-          /**
-           * Stored bounds an depths.
-           */
-          double min_depth;
-          double delta_depth;
-          double max_depth;
-      };
-
-      /**
-       * A class that reads in a text file that contains the
-       * viscosity for a set of equidistant depth layers. See
-       * the data/material-model/steinberger directory for an example data
-       * file.
-       * The class can return the value for a given depth.
-       */
-      class RadialViscosityLookup
-      {
-        public:
-          /**
-           * Constructor. Reads in the given file.
-           */
-          RadialViscosityLookup(const std::string &filename,
-                                const MPI_Comm comm);
-
-          /**
-           * Return the viscosity for a given depth.
-           */
-          double radial_viscosity(double depth) const;
-
-        private:
-          /**
-           * Stored data values.
-           */
-          std::vector<double> values;
-
-          /**
-           * Depth bounds for the read in values.
-           */
-          double min_depth;
-          double delta_depth;
-          double max_depth;
-      };
-    }
-
-    /**
-     * A variable viscosity material model that reads the essential values of
-     * coefficients from tables in input files.
-     *
-     * The viscosity of this model is based on the paper
-     * Steinberger & Calderwood 2006: "Models of large-scale viscous flow in the
-     * Earth's mantle with constraints from mineral physics and surface
-     * observations". The thermal conductivity is constant and the other
-     * parameters are provided via lookup tables from the software PERPLEX.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class Steinberger: public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialization function. Loads the material data and sets up
-         * pointers.
-         */
-        void
-        initialize () override;
-
-        /**
-         * Called at the beginning of each time step and allows the material
-         * model to update internal data structures.
-         */
-        void update() override;
-
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        virtual double viscosity (const double                  temperature,
-                                  const double                  pressure,
-                                  const std::vector<double>    &compositional_fields,
-                                  const SymmetricTensor<2,dim> &strain_rate,
-                                  const Point<dim>             &position) const;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void
-        evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                 MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-      private:
-        /**
-         * Compute the pressure- and temperature-dependent thermal
-         * conductivity either as a constant value, or based on the
-         * equation given in Stackhouse et al., 2015: First-principles
-         * calculations of the lattice thermal conductivity of the
-         * lower mantle, or based on the equation given in Tosi et al.,
-         * 2013: Mantle dynamics with pressure- and temperature-dependent
-         * thermal expansivity and conductivity.
-         */
-        double thermal_conductivity (const double temperature,
-                                     const double pressure,
-                                     const Point<dim> &position) const;
-
-        /**
-         * Whether the compositional fields representing mass fractions
-         * should be normalized to one when computing their fractions
-         * (if false), or whether there is an additional composition
-         * (the background field) that is not represented by a
-         * compositional field, and makes up the remaining fraction of
-         * material if the compositional fields add up to less than one
-         * at any given location (if true).
-         */
-        bool has_background_field;
-
-        /**
-         * Pointer to a composition mask, which is meant to be filled with
-         * one entry per compositional field that determines if this
-         * field is considered to represent a mass fractions (if the entry
-         * is set to true) or not (if set to false). This is needed for
-         * averaging of material properties.
-         */
-        std::unique_ptr<ComponentMask> composition_mask;
-
-        /**
-         * The thermodynamic lookup equation of state.
-         */
-        EquationOfState::ThermodynamicTableLookup<dim> equation_of_state;
-
-        /**
-         * Boolean describing whether to use the lateral average temperature
-         * for computing the viscosity, rather than the temperature
-         * on the reference adiabat.
-         */
-        bool use_lateral_average_temperature;
-
-        /**
-         * The value of the thermal conductivity if a constant thermal
-         * conductivity is used for the whole domain.
-         */
-        double thermal_conductivity_value;
-
-        /**
-         * Enumeration for selecting which type of conductivity law to use.
-         */
-        enum ConductivityFormulation
-        {
-          constant,
-          p_T_dependent
-        } conductivity_formulation;
-
-        /**
-         * Parameters for the temperature- and pressure dependence of the
-         * thermal conductivity.
-         */
-        std::vector<double> conductivity_transition_depths;
-        std::vector<double> reference_thermal_conductivities;
-        std::vector<double> conductivity_pressure_dependencies;
-        std::vector<double> conductivity_reference_temperatures;
-        std::vector<double> conductivity_exponents;
-        std::vector<double> saturation_scaling;
-        double maximum_conductivity;
-
-        /**
-         * Compositional prefactors with which to multiply the reference viscosity.
-         * Volume fractions are used to weight the prefactors according to the
-         * assigned viscosity averaging scheme.
-         */
-        std::vector<double> viscosity_prefactors;
-        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging_scheme;
-
-        /**
-         * Information about lateral temperature averages.
-         */
-        std::vector<double> average_temperature;
-        unsigned int n_lateral_slices;
-
-        /**
-         * Minimum and maximum allowed viscosity, as well as the maximum allowed
-         * viscosity variation compared to the average radial viscosity.
-         */
-        double min_eta;
-        double max_eta;
-        double max_lateral_eta_variation;
-
-        /**
-         * Information about the location of data files.
-         */
-        std::string data_directory;
-        std::string radial_viscosity_file_name;
-        std::string lateral_viscosity_file_name;
-
-        /**
-         * Pointer to an object that reads and processes data for the lateral
-         * temperature dependency of viscosity.
-         */
-        std::unique_ptr<internal::LateralViscosityLookup> lateral_viscosity_lookup;
-
-        /**
-         * Pointer to an object that reads and processes data for the radial
-         * viscosity profile.
-         */
-        std::unique_ptr<internal::RadialViscosityLookup> radial_viscosity_lookup;
-
-        /**
-         * A function that fills the prescribed additional outputs in the
-         * MaterialModelOutputs object that is handed over, if it exists,
-         * in this case, densities for the projected density approximation.
-         * Does nothing otherwise.
-         */
-        void fill_prescribed_outputs (const unsigned int i,
-                                      const std::vector<double> &volume_fractions,
-                                      const MaterialModel::MaterialModelInputs<dim> &in,
-                                      MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/utilities.h.bak b/include/aspect/material_model/utilities.h.bak
deleted file mode 100644
index c65828f7b19..00000000000
--- a/include/aspect/material_model/utilities.h.bak
+++ /dev/null
@@ -1,680 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_utilities_h
-#define _aspect_material_model_utilities_h
-
-#include <aspect/global.h>
-#include <deal.II/base/point.h>
-#include <deal.II/base/symmetric_tensor.h>
-#include <deal.II/fe/component_mask.h>
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-namespace aspect
-{
-  template <int dim> class SimulatorAccess;
-  namespace Utilities
-  {
-    using namespace dealii;
-    using namespace dealii::Utilities;
-
-    template <int dim>
-    class StructuredDataLookup;
-  }
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim> class MaterialModelOutputs;
-    template <int dim> struct EquationOfStateOutputs;
-
-    /**
-     * A namespace in which we define utility functions that
-     * might be used in many different places in the material
-     * model to prevent code duplication.
-     */
-    namespace MaterialUtilities
-    {
-      namespace Lookup
-      {
-        /**
-         * A base class that can be used to look up material data from an external
-         * data source (e.g. a table in a file). The class consists of data members
-         * and functions to access this data, but it does not contain the functions
-         * to read this data, which has to be implemented in a derived class.
-         */
-        class MaterialLookup
-        {
-          public:
-
-            double
-            specific_heat(const double temperature,
-                          const double pressure) const;
-
-            double
-            density(const double temperature,
-                    const double pressure) const;
-
-            double
-            thermal_expansivity(const double temperature,
-                                const double pressure) const;
-
-            double
-            seismic_Vp(const double temperature,
-                       const double pressure) const;
-
-            double
-            seismic_Vs(const double temperature,
-                       const double pressure) const;
-
-            double
-            enthalpy(const double temperature,
-                     const double pressure) const;
-
-            /**
-             * Computes the derivative of enthalpy for temperature, using the
-             * resolution of the read-in table to compute a finite-difference
-             * approximation of the derivative.
-             */
-            double
-            dHdT (const double temperature,
-                  const double pressure) const;
-
-            /**
-             * Computes the derivative of enthalpy for pressure, using the
-             * resolution of the read-in table to compute a finite-difference
-             * approximation of the derivative.
-             */
-            double
-            dHdp (const double temperature,
-                  const double pressure) const;
-
-            /**
-             * Compute the enthalpy derivatives for temperature and pressure
-             * given a set of temperature and pressure points, which will be
-             * used as support points for the finite difference scheme. This
-             * is useful to not 'miss' phase transitions that are not resolved in
-             * the dHdT and dHdp functions. The third argument represents
-             * the number of substeps taken to compute this average. A number
-             * larger than one means the temperature-pressure range that is spanned
-             * by the first two input arguments is separated into @p n_substeps
-             * equally spaced pressure-temperature steps, the derivatives are
-             * computed for each substep and then averaged.
-             */
-            std::array<std::pair<double, unsigned int>,2>
-            enthalpy_derivatives(const std::vector<double> &temperatures,
-                                 const std::vector<double> &pressures,
-                                 const unsigned int n_substeps = 1) const;
-
-            double
-            dRhodp (const double temperature,
-                    const double pressure) const;
-
-            /**
-             * Returns the index that indicates the phase with the largest volume
-             * fraction at a given temperature and pressure.
-             */
-            unsigned int
-            dominant_phase (const double temperature,
-                            const double pressure) const;
-
-            /**
-             * Returns whether a lookup has a column that indicates which is the
-             * phase with the largest volume fraction is this material.
-             */
-            bool
-            has_dominant_phase() const;
-
-            /**
-             * Returns a vector of all the column names in the lookup file
-             * that start with the character string vol_fraction_
-             */
-            std::vector<std::string>
-            phase_volume_column_names() const;
-
-            /**
-             * Returns the volume fraction of the phase_idth phase
-             * at a given temperature and pressure.
-             */
-            double
-            phase_volume_fraction(const int phase_id,
-                                  const double temperature,
-                                  const double pressure) const;
-
-            /**
-             * Returns the size of the data tables in pressure (first entry)
-             * and temperature (second entry) dimensions.
-             */
-            std::array<double,2>
-            get_pT_steps() const;
-
-
-            /**
-             * Get the list of names of all of the dominant phases
-             * in a given lookup table as given by the phase column.
-             * The names of the phases are stored in the order they
-             * first appear in the table.
-             */
-            const std::vector<std::string> &
-            get_dominant_phase_names() const;
-
-          protected:
-            /**
-             * Access that data value of the property that is stored in table
-             * @p values at pressure @p pressure and temperature @p temperature.
-             * @p interpol controls whether to perform linear interpolation
-             * between the closest data points, or simply use the closest point
-             * value.
-             */
-            double
-            value (const double temperature,
-                   const double pressure,
-                   const Table<2, double> &values,
-                   const bool interpol) const;
-
-            /**
-             * Access that data value of the property that is stored in table
-             * @p values at pressure @p pressure and temperature @p temperature
-             * using the closest point value.
-             */
-            unsigned int
-            value (const double temperature,
-                   const double pressure,
-                   const Table<2, unsigned int> &values) const;
-
-            /**
-             * Find the position in a data table given a temperature.
-             */
-            double get_nT(const double temperature) const;
-
-            /**
-             * Find the position in a data table given a pressure.
-             */
-            double get_np(const double pressure) const;
-
-            dealii::Table<2,double> density_values;
-            dealii::Table<2,double> thermal_expansivity_values;
-            dealii::Table<2,double> specific_heat_values;
-            dealii::Table<2,double> vp_values;
-            dealii::Table<2,double> vs_values;
-            dealii::Table<2,double> enthalpy_values;
-            dealii::Table<2,unsigned int> dominant_phase_indices;
-
-            /**
-             * The vector of column names corresponding to each phase,
-             * and a vector of tables containing the volume fractions of
-             * each phase at a given temperature and pressure.
-             * The ordering of both vectors is the same.
-             */
-            std::vector<std::string> phase_column_names;
-            std::vector<dealii::Table<2,double>> phase_volume_fractions;
-
-            double delta_press;
-            double min_press;
-            double max_press;
-            double delta_temp;
-            double min_temp;
-            double max_temp;
-            unsigned int n_temperature;
-            unsigned int n_pressure;
-            unsigned int n_phases;
-            unsigned int n_columns;
-            bool interpolation;
-            bool has_dominant_phase_column;
-            std::vector<std::string> dominant_phase_names;
-        };
-
-        /**
-         * An implementation of the above base class that reads in files created
-         * by the HeFESTo software.
-         */
-        class HeFESToReader : public MaterialLookup
-        {
-          public:
-            HeFESToReader(const std::string &material_filename,
-                          const std::string &derivatives_filename,
-                          const bool interpol,
-                          const MPI_Comm comm);
-        };
-
-        /**
-         * An implementation of the above base class that reads in files created
-         * by the Perplex software.
-         */
-        class PerplexReader : public MaterialLookup
-        {
-          public:
-            PerplexReader(const std::string &filename,
-                          const bool interpol,
-                          const MPI_Comm comm);
-        };
-
-        /**
-        * This class reads in an entropy-pressure material table and looks up material
-        * properties for the given entropy and pressure.
-        */
-        class EntropyReader
-        {
-          public:
-
-            /**
-             * Read the table.
-             */
-            void
-            initialize(const MPI_Comm comm,
-                       const std::string &data_directory,
-                       const std::string &material_file_name);
-
-            /**
-             * Returns the specific heat for a given entropy and pressure.
-             */
-            double
-            specific_heat(const double entropy,
-                          const double pressure) const;
-
-            /**
-             * Returns the density for a given entropy and pressure.
-             */
-            double
-            density(const double entropy,
-                    const double pressure) const;
-
-            /**
-             * Returns the thermal_expansivity for a given entropy and pressure.
-             */
-            double
-            thermal_expansivity(const double entropy,
-                                const double pressure) const;
-
-            /**
-             * Returns the temperature for a given entropy and pressure.
-             */
-            double
-            temperature(const double entropy,
-                        const double pressure) const;
-
-            /**
-             * Returns the seismic p wave velocity for a given entropy and pressure.
-             */
-            double
-            seismic_vp(const double entropy,
-                       const double pressure) const;
-
-            /**
-             * Returns the seismic s wave velocity for a given entropy and pressure.
-             */
-            double
-            seismic_vs(const double entropy,
-                       const double pressure) const;
-
-            /**
-             * Returns density gradient for a given entropy and pressure.
-             */
-            Tensor<1, 2>
-            density_gradient(const double entropy,
-                             const double pressure) const;
-
-          private:
-            /**
-             * The StructuredDataLookup object that stores the material data.
-             */
-            std::unique_ptr<Utilities::StructuredDataLookup<2>> material_lookup;
-        };
-      }
-
-      /**
-       * For multicomponent material models: Given a vector of compositional
-       * field values of length N, of which M indices correspond to mass or
-       * volume fractions, this function returns a vector of fractions
-       * of length M+1, corresponding to the fraction of a ``background
-       * material'' as the first entry, and fractions for each of the input
-       * fields as the following entries. The returned vector will sum to one.
-       * If the sum of the compositional_fields is greater than
-       * one, we assume that there is no background field (i.e., that field value
-       * is zero). Otherwise, the difference between the sum of the compositional
-       * fields and 1.0 is assumed to be the amount of the background field.
-       * This function makes no assumptions about the units of the
-       * compositional field values; for example, they could correspond to
-       * mass or volume fractions.
-       */
-      std::vector<double>
-      compute_only_composition_fractions(const std::vector<double> &compositional_fields,
-                                         const std::vector<unsigned int> &indices_to_use);
-
-      /**
-       * For multicomponent material models: Given a vector of compositional
-       * field values of length N, this function returns a vector of fractions
-       * of length N+1, corresponding to the fraction of a ``background
-       * material'' as the first entry, and fractions for each of the input
-       * fields as the following entries. The returned vector will sum to one.
-       * If the sum of the compositional_fields is greater than
-       * one, we assume that there is no background field (i.e., that field value
-       * is zero). Otherwise, the difference between the sum of the compositional
-       * fields and 1.0 is assumed to be the amount of the background field.
-       * Optionally, one can input a component mask that determines which of the
-       * compositional fields to use during the computation (e.g. because
-       * some fields contain unrelated quantities (like strain,
-       * porosity, or trace elements). By default, all fields are included.
-       * This function makes no assumptions about the units of the
-       * compositional field values; for example, they could correspond to
-       * mass or volume fractions.
-       */
-      std::vector<double>
-      compute_composition_fractions(const std::vector<double> &compositional_fields,
-                                    const ComponentMask &field_mask = ComponentMask());
-
-      /**
-       * See compute_composition_fractions() for the documentation of this function.
-       * @deprecated: This function is deprecated. Please use compute_composition_fractions() instead.
-       */
-      DEAL_II_DEPRECATED
-      std::vector<double>
-      compute_volume_fractions(const std::vector<double> &compositional_fields,
-                               const ComponentMask &field_mask = ComponentMask());
-
-      /**
-       * Given a vector of component masses,
-       * and another of the corresponding densities, calculate the volumes
-       * of each component. If return_as_fraction is true, the returned vector
-       * will sum to one. If the input vectors have a length of one, the
-       * returned volume fraction is one.
-       */
-      std::vector<double>
-      compute_volumes_from_masses(const std::vector<double> &masses,
-                                  const std::vector<double> &densities,
-                                  const bool return_as_fraction);
-
-      /**
-       * For multicomponent material models:
-       * Enumeration for selecting which averaging scheme to use when
-       * averaging the properties of different compositional fields.
-       * Select between harmonic, arithmetic, geometric, and
-       * maximum_composition. The max composition scheme simply uses the
-       * viscosity of whichever field has the highest volume fraction.
-       */
-      enum CompositionalAveragingOperation
-      {
-        harmonic,
-        arithmetic,
-        geometric,
-        maximum_composition
-      };
-
-
-
-      /**
-       * Read the compositional averaging operation from the parameter file,
-       * using the parameter name given in @p parameter_name, and return the
-       * enum that corresponds to this operation.
-       */
-      CompositionalAveragingOperation
-      parse_compositional_averaging_operation (const std::string &parameter_name,
-                                               const ParameterHandler &prm);
-
-
-
-      /**
-       * For multicomponent material models:
-       * Material models compute output quantities such as the viscosity, the
-       * density, etc. For some models, these values depend strongly on the
-       * composition, and more than one compositional field might have nonzero
-       * values at a given quadrature point. This means that properties have to
-       * be averaged based on the fractions of each compositional field present.
-       * This function performs this type of averaging. The averaging is based
-       * on the choice in @p average_type. Averaging is conducted over the
-       * compositional fields given in @p volume_fractions. This means that
-       * @p volume_fractions and @p parameter_values have to have the same size,
-       * which would typically be the number of compositional fields used in the
-       * simulation (with the potential addition of a background field, in case
-       * the composition does not add up to 1). However, one might not want to
-       * average over all fields, as in some cases compositional fields do not
-       * represent a rock type, but other tracked quantities like the finite
-       * strain, so the implementation is independent of the number of entries in
-       * @p volume_fractions.
-       */
-      double average_value (const std::vector<double> &volume_fractions,
-                            const std::vector<double> &parameter_values,
-                            const CompositionalAveragingOperation &average_type);
-
-
-
-      /**
-       * This function computes averages of multicomponent thermodynamic properties
-       * that are stored in a vector of EquationOfStateOutputs.
-       * Each @p eos_outputs contains the thermodynamic properties for
-       * all materials at a given evaluation point.
-       * The averaged properties are:
-       * density, isothermal compressibility, thermal_expansivity,
-       * the specific entropy derivatives with respect to pressure and temperature
-       * and the specific heat capacity. The first three of these properties
-       * are averaged by volume fraction, and the second three
-       * (the specific properties) are averaged by mass fraction.
-       * These averages are used to fill the corresponding attributes of
-       * a MaterialModelOutputs object.
-       */
-      template <int dim>
-      void
-      fill_averaged_equation_of_state_outputs(const EquationOfStateOutputs<dim> &eos_outputs,
-                                              const std::vector<double> &mass_fractions,
-                                              const std::vector<double> &volume_fractions,
-                                              const unsigned int i,
-                                              MaterialModelOutputs<dim> &out);
-
-
-
-      /**
-       * Utilities for material models with multiple phases
-       */
-      namespace PhaseUtilities
-      {
-        /**
-         * Enumeration for selecting which averaging scheme to use when
-         * averaging the properties of different phases.
-         * Select between arithmetic and logarithmic.
-         */
-        enum PhaseAveragingOperation
-        {
-          arithmetic,
-          logarithmic
-        };
-      }
-
-      /**
-       * Material models compute output quantities such as the viscosity, the
-       * density, etc. For some models, these values may depend on the phase in
-       * addition to the composition, and more than one phase field might have
-       * nonzero values at a given quadrature point. This means that properties
-       * for each composition have to be averaged based on the fractions of each
-       * phase field present. This function performs this type of averaging.
-       * The averaging is based on the choice in @p operation. Averaging is conducted
-       * over the phase functions given in @p phase_function_values, with
-       * @p parameter_values containing values of all individual phases. Unlike the average_value
-       * function defined for compositions, averaging in this function is calculated based
-       * on phase functions and the change of variables on the trajectory of phase boundaries.
-       * Thus on a single phase boundary, values of variables change gradually from one phase
-       * to the other. The values of the phase function used to average the properties varies
-       * between 0 and 1.
-       */
-      double phase_average_value (const std::vector<double> &phase_function_values,
-                                  const std::vector<unsigned int> &n_phase_transitions_per_composition,
-                                  const std::vector<double> &parameter_values,
-                                  const unsigned int composition_index,
-                                  const PhaseUtilities::PhaseAveragingOperation operation = PhaseUtilities::arithmetic);
-
-
-
-      /**
-       * A data structure with all inputs for the
-       * PhaseFunction::phase_function_value() and
-       * PhaseFunction::phase_function_derivative() method.
-       */
-      template <int dim>
-      struct PhaseFunctionInputs
-      {
-        /**
-         * Constructor. Initializes the various variables of this
-         * structure with the input values.
-         */
-        PhaseFunctionInputs(const double temperature,
-                            const double pressure,
-                            const double depth,
-                            const double pressure_depth_derivative,
-                            const unsigned int phase_index);
-
-        double temperature;
-        double pressure;
-        double depth;
-        double pressure_depth_derivative;
-
-        /**
-         * This parameter determines which phase function of all the stored
-         * functions to compute. Phase functions are numbered consecutively,
-         * starting at 0 and the interpretation of their output is up to the
-         * calling side. For example the first phase function could be used to
-         * indicate a viscosity jump in the first compositional field,
-         * while the second function indicates a density jump in all
-         * compositions. None of this is known to the PhaseFunction object,
-         * which only has information that there are two phase functions
-         * and what their properties are.
-         */
-        unsigned int phase_index;
-      };
-
-      /**
-       * A class that bundles functionality to compute the values and
-       * derivatives of phase functions. The class can handle arbitrary
-       * numbers of phase transitions, but the calling side has to determine
-       * how to use the return values of this object (e.g. in terms of
-       * density or viscosity).
-       */
-      template <int dim>
-      class PhaseFunction: public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Percentage of material that has already undergone the phase
-           * transition to the higher-pressure material (this is done
-           * individually for each transition and summed up in the end)
-           */
-          double compute_value (const PhaseFunctionInputs<dim> &in) const;
-
-          /**
-           * Return the derivative of the phase function with respect to
-           * pressure.
-           */
-          double compute_derivative (const PhaseFunctionInputs<dim> &in) const;
-
-          /**
-           * Return the total number of phase transitions.
-           */
-          unsigned int n_phase_transitions () const;
-
-          /**
-           * Return the total number of phases.
-           */
-          unsigned int n_phases () const;
-
-          /**
-           * Return the Clapeyron slope (dp/dT of the transition) for
-           * phase transition number @p phase_index.
-           */
-          double get_transition_slope (const unsigned int phase_index) const;
-
-          /**
-           * Return the depth for phase transition number @p phase_index.
-           */
-          double get_transition_depth (const unsigned int phase_index) const;
-
-          /**
-           * Return how many phase transitions there are for each composition.
-           */
-          const std::vector<unsigned int> &
-          n_phase_transitions_for_each_composition () const;
-
-          /**
-           * Return how many phases there are for each composition.
-           */
-          const std::vector<unsigned int> &
-          n_phases_for_each_composition () const;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           * Note that this class does not declare its own subsection,
-           * i.e. the parameters will be declared in the subsection that
-           * was active before calling this function.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           * Note that this class does not declare its own subsection,
-           * i.e. the parameters will be parsed from the subsection that
-           * was active before calling this function.
-           */
-          void
-          parse_parameters (ParameterHandler &prm);
-
-
-        private:
-          /**
-           * List of depth (or pressure), width, Clapeyron slopes and
-           * limits of temperature for the different phase transitions
-           */
-          std::vector<double> transition_depths;
-          std::vector<double> transition_pressures;
-          std::vector<double> transition_temperatures;
-          std::vector<double> transition_widths;
-          std::vector<double> transition_pressure_widths;
-          std::vector<double> transition_slopes;
-          std::vector<double> transition_temperature_upper_limits;
-          std::vector<double> transition_temperature_lower_limits;
-
-          /**
-           * Whether to define the phase transitions based on depth, or pressure.
-           * Based on this parameter, either transition_depths and transition_width,
-           * or transition_pressures and transition_pressure_widths determine the
-           * depth of the phase transition.
-           */
-          bool use_depth_instead_of_pressure;
-
-          /**
-           * A vector that stores how many phase transitions there are for each compositional field.
-           */
-          std::unique_ptr<std::vector<unsigned int>> n_phase_transitions_per_composition;
-
-          /**
-           * A vector that stores how many phases there are for each compositional field.
-           */
-          std::vector<unsigned int> n_phases_per_composition;
-
-          /**
-           * Total number of phases over all compositional fields
-           */
-          unsigned int n_phases_total;
-      };
-    }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/material_model/visco_plastic.h.bak b/include/aspect/material_model/visco_plastic.h.bak
deleted file mode 100644
index 9ba9bf9fa67..00000000000
--- a/include/aspect/material_model/visco_plastic.h.bak
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_visco_plastic_h
-#define _aspect_material_model_visco_plastic_h
-
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/equation_of_state/multicomponent_incompressible.h>
-#include <aspect/material_model/rheology/visco_plastic.h>
-
-#include<deal.II/fe/component_mask.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model combining viscous and plastic deformation, with
-     * the option to also include viscoelastic deformation.
-     *
-     * Viscous deformation is defined by a viscous flow law describing
-     * dislocation and diffusion creep:
-     *   $ v = \frac{1}{2}   A^{-\frac{1}{n}} d^{\frac{m}{n}}
-     *               \dot{\varepsilon}_{ii}^{\frac{1-n}{n}}
-     *               \exp\left(\frac{E + PV}{nRT}\right) $
-     * where
-     *   where $A$ is the prefactor, $n$ is the stress exponent,
-     *   $\dot{\varepsilon}_{ii}$ is the square root of the deviatoric
-     *   strain rate tensor second invariant, $d$ is grain size,
-     *   $m$ is the grain size exponent, $E$ is activation energy,
-     *   $V$ is activation volume, $P$ is pressure, $R$ is the gas
-     *   exponent and $T$ is temperature.
-     *
-     * One may select to use the diffusion ($v_{diff}$; $n=1$, $m!=0$),
-     * dislocation ($v_{disl}$, $n>1$, $m=0$) or composite
-     * $\frac{v_{diff}v_{disl}}{v_{diff}+v_{disl}}$ equation form.
-     *
-     * Viscous stress is limited by plastic deformation, which follows
-     * a Drucker Prager yield criterion:
-     *  $\sigma_y = C\cos(\phi) + P\sin(\phi)$  (2D)
-     * or in 3D
-     *  $\sigma_y = \frac{6C\cos(\phi) + 2P\sin(\phi)}{\sqrt{3}(3+\sin(\phi))}$
-     * where
-     *   $\sigma_y$ is the yield stress, $C$ is cohesion, $phi$ is the angle
-     *   of internal friction and $P$ is pressure.
-     * If the viscous stress ($2v{\varepsilon}_{ii})$) exceeds the yield
-     * stress ($\sigma_{y}$), the viscosity is rescaled back to the yield
-     * surface: $v_{y}=\sigma_{y}/(2{\varepsilon}_{ii})$
-     *
-     * When included, the viscoelastic rheology takes into account the elastic shear
-     * strength (e.g., shear modulus), while the tensile and volumetric
-     * strength (e.g., Young's and bulk modulus) are not considered. The model
-     * is incompressible and allows specifying an arbitrary number of
-     * compositional fields, where each field represents a different rock type
-     * or component of the viscoelastic stress tensor. The symmetric stress tensor in
-     * 2D and 3D, respectively, contains 3 or 6 components. The compositional fields
-     * representing these components must be named and listed in a very specific
-     * format, which is designed to minimize mislabeling stress tensor components
-     * as distinct 'compositional rock types' (or vice versa). For 2D models,
-     * the first three compositional fields must be labeled ve_stress_xx, ve_stress_yy
-     * and ve_stress_xy. In 3D, the first six compositional fields must be labeled
-     * ve_stress_xx, ve_stress_yy, ve_stress_zz, ve_stress_xy, ve_stress_xz, ve_stress_yz.
-     *
-     * Combining this viscoelasticity implementation with non-linear viscous flow
-     * and plasticity produces a constitutive relationship commonly referred to
-     * as partial elastoviscoplastic (e.g., pEVP) in the geodynamics community.
-     * While extensively discussed and applied within the geodynamics literature,
-     * notable references include:
-     * Moresi et al. (2003), J. Comp. Phys., v. 184, p. 476-497.
-     * Gerya and Yuen (2007), Phys. Earth. Planet. Inter., v. 163, p. 83-105.
-     * Gerya (2010), Introduction to Numerical Geodynamic Modeling.
-     * Kaus (2010), Tectonophysics, v. 484, p. 36-47.
-     * Choi et al. (2013), J. Geophys. Res., v. 118, p. 2429-2444.
-     * Keller et al. (2013), Geophys. J. Int., v. 195, p. 1406-1442.
-     *
-     * The overview below directly follows Moresi et al. (2003) eqns. 23-32.
-     * However, an important distinction between this material model and
-     * the studies above is the use of compositional fields, rather than
-     * particles, to track individual components of the viscoelastic stress
-     * tensor. The material model will be updated when an option to track
-     * and calculate viscoelastic stresses with particles is implemented.
-     * Moresi et al. (2003) begins (eqn. 23) by writing the deviatoric
-     * rate of deformation ($\hat{D}$) as the sum of elastic
-     * ($\hat{D_{e}}$) and viscous ($\hat{D_{v}}$) components:
-     * $\hat{D} = \hat{D_{e}} + \hat{D_{v}}$.
-     * These terms further decompose into
-     * $\hat{D_{v}} = \frac{\tau}{2\eta}$ and
-     * $\hat{D_{e}} = \frac{\overset{\triangledown}{\tau}}{2\mu}$, where
-     * $\tau$ is the viscous deviatoric stress, $\eta$ is the shear viscosity,
-     * $\mu$ is the shear modulus and $\overset{\triangledown}{\tau}$ is the
-     * Jaumann corotational stress rate. If plasticity is included the
-     * deviatoric rate of deformation may be written as:
-     * $\hat{D} = \hat{D_{e}} + \hat{D_{v}} + \hat{D_{p}}$, where $\hat{D_{p}}$
-     * is the plastic component. As defined in the second paragraph, $\hat{D_{p}}$
-     * decomposes to $\frac{\tau_{y}}{2\eta_{y}}$, where $\tau_{y}$ is the yield
-     * stress and $\eta_{y}$ is the viscosity rescaled to the yield surface.
-     *
-     * Above, the Jaumann corotational stress rate (eqn. 24) from the elastic
-     * component contains the time derivative of the deviatoric stress ($\dot{\tau}$)
-     * and terms that  account for material spin (e.g., rotation) due to advection:
-     * $\overset{\triangledown}{\tau} = \dot{\tau} + {\tau}W -W\tau$.
-     * Above, $W$ is the material spin tensor (eqn. 25):
-     * $W_{ij} = \frac{1}{2} \left (\frac{\partial V_{i}}{\partial x_{j}} -
-     * \frac{\partial V_{j}}{\partial x_{i}} \right )$.
-     *
-     * The Jaumann stress-rate can also be approximated using terms from the time
-     * at the previous time step ($t$) and current time step ($t + \Delta t^{e}$):
-     * $\smash[t]{\overset{\triangledown}{\tau}}^{t + \Delta t^{e}} \approx
-     * \frac{\tau^{t + \Delta t^{e} - \tau^{t}}}{\Delta t^{e}} -
-     * W^{t}\tau^{t} + \tau^{t}W^{t}$.
-     * In this material model, the size of the time step above ($\Delta t^{e}$)
-     * can be specified as the numerical time step size or an independent fixed time
-     * step. If the latter case is selected, the user has an option to apply a
-     * stress averaging scheme to account for the differences between the numerical
-     * and fixed elastic time step (eqn. 32). If one selects to use a fixed elastic time
-     * step throughout the model run, an equal numerical and elastic time step can be
-     * achieved by using CFL and maximum time step values that restrict the numerical
-     * time step to the fixed elastic time step.
-     *
-     * The formulation above allows rewriting the total rate of deformation (eqn. 29) as
-     * $\tau^{t + \Delta t^{e}} = \eta_{eff} \left (
-     * 2\hat{D}^{t + \triangle t^{e}} + \frac{\tau^{t}}{\mu \Delta t^{e}} +
-     * \frac{W^{t}\tau^{t} - \tau^{t}W^{t}}{\mu}  \right )$.
-     *
-     * The effective viscosity (eqn. 28) is a function of the viscosity ($\eta$),
-     * elastic time step size ($\Delta t^{e}$) and shear relaxation time
-     * ($ \alpha = \frac{\eta}{\mu} $):
-     * $\eta_{eff} = \eta \frac{\Delta t^{e}}{\Delta t^{e} + \alpha}$
-     * The magnitude of the shear modulus thus controls how much the effective
-     * viscosity is reduced relative to the initial viscosity.
-     *
-     * Elastic effects are introduced into the governing Stokes equations through
-     * an elastic force term (eqn. 30) using stresses from the previous time step:
-     * $F^{e,t} = -\frac{\eta_{eff}}{\mu \Delta t^{e}} \tau^{t}$.
-     * This force term is added onto the right-hand side force vector in the
-     * system of equations.
-     *
-     * Several model parameters (reference densities, thermal expansivities
-     * thermal diffusivities, heat capacities and rheology parameters) can
-     * be defined per-compositional field.
-     * For each material parameter the user supplies a comma delimited list of
-     * length N+1, where N is the number of compositional fields.  The
-     * additional field corresponds to the value for background material.  They
-     * should be ordered ``background, composition1, composition2...''
-     *
-     * If a list of values is given for the density, thermal expansivity,
-     * thermal diffusivity and heat capacity, the volume weighted sum of the
-     * values of each of the compositional fields is used in their place,
-     * for example $\rho = \sum \left( \rho_i V_i \right)$
-     *
-     * The individual output viscosities for each compositional field are
-     * also averaged. The user can choose from a range of options for this
-     * viscosity averaging. If only one value is given for any of these parameters,
-     * all compositions are assigned the same value.
-     * The first value in the list is the value assigned to "background material"
-     * (regions where the sum of the compositional fields is < 1.0).
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class ViscoPlastic : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         *
-         * This material model is incompressible.
-         */
-        bool is_compressible () const override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        double get_min_strain_rate() const;
-
-        /**
-         * A function that returns whether the material is plastically yielding at
-         * the given pressure, temperature, composition, and strain rate.
-         *
-         * @deprecated: Use the other function with this name instead, which allows
-         * to pass in more general input variables.
-         */
-        DEAL_II_DEPRECATED
-        bool
-        is_yielding (const double pressure,
-                     const double temperature,
-                     const std::vector<double> &composition,
-                     const SymmetricTensor<2,dim> &strain_rate) const;
-
-        /**
-         * A function that returns whether the material is plastically
-         * yielding at the given input variables (pressure, temperature,
-         * composition, strain rate, and so on).
-         */
-        bool
-        is_yielding (const MaterialModelInputs<dim> &in) const;
-
-      private:
-
-        /**
-         * Pointer to the object used to compute the rheological properties.
-         * In this case, the rheology in question is visco(elasto)plastic. The
-         * object contains functions for parameter declaration and parsing,
-         * and further functions that calculate viscosity and viscosity
-         * derivatives. It also contains functions that create and fill
-         * additional material model outputs, specifically plastic outputs.
-         * The rheology itself is a composite rheology, and so the object
-         * contains further objects and/or pointers to objects that provide
-         * functions and parameters for all subordinate rheologies.
-         */
-        std::unique_ptr<Rheology::ViscoPlastic<dim>> rheology;
-
-        std::vector<double> thermal_diffusivities;
-
-        /**
-         * Whether to use user-defined thermal conductivities instead of thermal diffusivities.
-         */
-        bool define_conductivities;
-
-        std::vector<double> thermal_conductivities;
-
-        /**
-         * Number of phase transitions for each chemical composition (including the background field).
-         */
-        std::vector<unsigned int> n_phase_transitions_for_each_chemical_composition;
-
-        /**
-         * Total number of phases.
-         */
-        unsigned int n_phases;
-
-        /**
-         * Object for computing the equation of state.
-         */
-        EquationOfState::MulticomponentIncompressible<dim> equation_of_state;
-
-        /**
-         * Object that handles phase transitions.
-         */
-        MaterialUtilities::PhaseFunction<dim> phase_function;
-
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/material_model/viscoelastic.h.bak b/include/aspect/material_model/viscoelastic.h.bak
deleted file mode 100644
index 7003201e0e7..00000000000
--- a/include/aspect/material_model/viscoelastic.h.bak
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
-  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_viscoelastic_h
-#define _aspect_material_model_viscoelastic_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/rheology/elasticity.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/equation_of_state/multicomponent_incompressible.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * An implementation of a simple linear viscoelastic rheology that only
-     * includes the deviatoric components of elasticity. Specifically, the
-     * viscoelastic rheology only takes into account the elastic shear
-     * strength (e.g., shear modulus), while the tensile and volumetric
-     * strength (e.g., Young's and bulk modulus) are not considered. The model
-     * is incompressible and allows specifying an arbitrary number of
-     * compositional fields, where each field represents a different rock type
-     * or component of the viscoelastic stress tensor. The stress tensor in 2D
-     * and 3D, respectively, contains 3 or 6 components. The compositional fields
-     * representing these components must be named and listed in a very specific
-     * format, which is designed to minimize mislabeling stress tensor components
-     * as distinct 'compositional rock types' (or vice versa). For 2D models,
-     * the first three compositional fields must be labeled ve_stress_xx, ve_stress_yy
-     * and ve_stress_xy. In 3D, the first six compositional fields must be labeled
-     * ve_stress_xx, ve_stress_yy, ve_stress_zz, ve_stress_xy, ve_stress_xz, ve_stress_yz.
-     *
-     * Expanding the model to include non-linear viscous flow (e.g.,
-     * diffusion/dislocation creep) and plasticity would produce a constitutive
-     * relationship commonly referred to as partial elastoviscoplastic
-     * (e.g., pEVP) in the geodynamics community. While extensively discussed
-     * and applied within the geodynamics literature, notable references include:
-     * Moresi et al. (2003), J. Comp. Phys., v. 184, p. 476-497.
-     * Gerya and Yuen (2007), Phys. Earth. Planet. Inter., v. 163, p. 83-105.
-     * Gerya (2010), Introduction to Numerical Geodynamic Modeling.
-     * Kaus (2010), Tectonophysics, v. 484, p. 36-47.
-     * Choi et al. (2013), J. Geophys. Res., v. 118, p. 2429-2444.
-     * Keller et al. (2013), Geophys. J. Int., v. 195, p. 1406-1442.
-     *
-     * The overview below directly follows Moresi et al. (2003) eqns. 23-32.
-     * However, an important distinction between this material model and
-     * the studies above is the use of compositional fields, rather than
-     * particles, to track individual components of the viscoelastic stress
-     * tensor. The material model will be updated when an option to track
-     * and calculate viscoelastic stresses with particles is implemented.
-     *
-     * Moresi et al. (2003) begins (eqn. 23) by writing the deviatoric
-     * rate of deformation ($\hat{D}$) as the sum of elastic
-     * ($\hat{D_{e}}$) and viscous ($\hat{D_{v}}$) components:
-     * $\hat{D} = \hat{D_{e}} + \hat{D_{v}}$.
-     * These terms further decompose into
-     * $\hat{D_{v}} = \frac{\tau}{2\eta}$ and
-     * $\hat{D_{e}} = \frac{\overset{\nabla}{\tau}}{2\mu}$, where
-     * $\tau$ is the viscous deviatoric stress, $\eta$ is the shear viscosity,
-     * $\mu$ is the shear modulus and $\overset{\nabla}{\tau}$ is the
-     * Jaumann corotational stress rate. This later term (eqn. 24) contains the
-     * time derivative of the deviatoric stress ($\dot{\tau}$) and terms that
-     * account for material spin (e.g., rotation) due to advection:
-     * $\overset{\nabla}{\tau} = \dot{\tau} + {\tau}W -W\tau$.
-     * Above, $W$ is the material spin tensor (eqn. 25):
-     * $W_{ij} = \frac{1}{2} \left (\frac{\partial V_{i}}{\partial x_{j}} -
-     * \frac{\partial V_{j}}{\partial x_{i}} \right )$.
-     *
-     * The Jaumann stress-rate can also be approximated using terms from the time
-     * at the previous time step ($t$) and current time step ($t + \Delta t^{e}$):
-     * $\smash[t]{\overset{\nabla}{\tau}}^{t + \Delta t^{e}} \approx
-     * \frac{\tau^{t + \Delta t^{e} - \tau^{t}}}{\Delta t^{e}} -
-     * W^{t}\tau^{t} + \tau^{t}W^{t}$.
-     * In this material model, the size of the time step above ($\Delta t^{e}$)
-     * can be specified as the numerical time step size or an independent fixed time
-     * step. If the latter case is a selected, the user has an option to apply a
-     * stress averaging scheme to account for the differences between the numerical
-     * and fixed elastic time step (eqn. 32). If one selects to use a fixed elastic time
-     * step throughout the model run, this can still be achieved by using CFL and
-     * maximum time step values that restrict the numerical time step to a specific time.
-     *
-     * The formulation above allows rewriting the total rate of deformation (eqn. 29) as
-     * $\tau^{t + \Delta t^{e}} = \eta_{eff} \left (
-     * 2\hat{D}^{t + \triangle t^{e}} + \frac{\tau^{t}}{\mu \Delta t^{e}} +
-     * \frac{W^{t}\tau^{t} - \tau^{t}W^{t}}{\mu}  \right )$.
-     *
-     * The effective viscosity (eqn. 28) is a function of the viscosity ($\eta$),
-     * elastic time step size ($\Delta t^{e}$) and shear relaxation time
-     * ($ \alpha = \frac{\eta}{\mu} $):
-     * $\eta_{eff} = \eta \frac{\Delta t^{e}}{\Delta t^{e} + \alpha}$
-     * The magnitude of the shear modulus thus controls how much the effective
-     * viscosity is reduced relative to the initial viscosity.
-     *
-     * Elastic effects are introduced into the governing stokes equations through
-     * an elastic force term (eqn. 30) using stresses from the previous time step:
-     * $F^{e,t} = -\frac{\eta_{eff}}{\mu \Delta t^{e}} \tau^{t}$.
-     * This force term is added onto the right-hand side force vector in the
-     * system of equations.
-     *
-     * The value of each compositional field representing distinct
-     * rock types at a point is interpreted to be a volume fraction of that
-     * rock type. If the sum of the compositional field volume fractions is
-     * less than one, then the remainder of the volume is assumed to be
-     * 'background material'.
-     *
-     * Several model parameters (densities, elastic shear moduli,
-     * thermal expansivities, thermal conductivies, specific heats) can
-     * be defined per-compositional field. For each material parameter the
-     * user supplies a comma delimited list of length N+1, where N is the
-     * number of compositional fields. The additional field corresponds to
-     * the value for background material. They should be ordered
-     * ``background, composition1, composition2...''. However, the first 3 (2D)
-     * or 6 (3D) composition fields correspond to components of the elastic
-     * stress tensor and their material values will not contribute to the volume
-     * fractions. If a single value is given, then all the compositional fields
-     * are given that value. Other lengths of lists are not allowed. For a given
-     * compositional field the material parameters are treated as constant,
-     * except density, which varies linearly with temperature according to the
-     * thermal expansivity.
-     *
-     * When more than one compositional field is present at a point, they are
-     * averaged arithmetically. An exception is viscosity, which may be averaged
-     * arithmetically, harmonically, geometrically, or by selecting the
-     * viscosity of the composition with the greatest volume fraction.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class Viscoelastic : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Function to compute the material properties in @p out given the
-         * inputs in @p in.
-         */
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * This model is not compressible, so this returns false.
-         */
-        bool is_compressible () const override;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-
-      private:
-        /**
-         * Enumeration for selecting which viscosity averaging scheme to use.
-         */
-        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
-
-        EquationOfState::MulticomponentIncompressible<dim> equation_of_state;
-
-        /**
-         * Vector for field viscosities, read from parameter file.
-         */
-        std::vector<double> viscosities;
-
-        /**
-         * Vector for field thermal conductivities, read from parameter file.
-         */
-        std::vector<double> thermal_conductivities;
-
-        Rheology::Elasticity<dim> elastic_rheology;
-    };
-
-  }
-}
-
-#endif
diff --git a/include/aspect/melt.h.bak b/include/aspect/melt.h.bak
deleted file mode 100644
index 9db3a27b005..00000000000
--- a/include/aspect/melt.h.bak
+++ /dev/null
@@ -1,571 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _aspect_melt_h
-#define _aspect_melt_h
-
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace MaterialModel
-  {
-    /**
-     * The MeltInputs provide the compaction pressures and
-     * melt (fluid) velocities, so that they can be used as
-     * additional inputs in heating or material models.
-     */
-    template <int dim>
-    class MeltInputs : public AdditionalMaterialInputs<dim>
-    {
-      public:
-        /**
-         * Constructor. When the MeltInputs are created,
-         * all properties are initialized with signalingNaNs.
-         * This means that individual heating or material models
-         * can all attach the plugins they need, and in a later
-         * step they will all be filled together (using the fill
-         * function).
-         */
-        MeltInputs (const unsigned int n_points);
-
-        /**
-         * Compaction pressure values $p_c$ at the given positions.
-         */
-        std::vector<double> compaction_pressures;
-
-        /**
-         * An approximation for the fluid (melt) velocities
-         * at the given positions.
-         */
-        std::vector<Tensor<1,dim>> fluid_velocities;
-
-        /**
-         * Fill the compaction pressures and fluid velocities.
-         */
-        void fill (const LinearAlgebra::BlockVector &solution,
-                   const FEValuesBase<dim>          &fe_values,
-                   const Introspection<dim>         &introspection) override;
-    };
-
-    template <int dim>
-    class MeltOutputs : public AdditionalMaterialOutputs<dim>
-    {
-      public:
-        MeltOutputs (const unsigned int n_points,
-                     const unsigned int /*n_comp*/)
-        {
-          compaction_viscosities.resize(n_points);
-          fluid_viscosities.resize(n_points);
-          permeabilities.resize(n_points);
-          fluid_densities.resize(n_points);
-          fluid_density_gradients.resize(n_points, Tensor<1,dim>());
-        }
-
-        /**
-         * Compaction viscosity values $\xi$ at the given positions.
-         * This parameter describes the resistance of the solid matrix
-         * in a two-phase simulation to dilation and compaction.
-         */
-        std::vector<double> compaction_viscosities;
-
-        /**
-         * Fluid (melt) viscosity values $\eta_f$ at the given positions.
-         */
-        std::vector<double> fluid_viscosities;
-
-        /**
-         * Permeability values $k$ at the given positions.
-         */
-        std::vector<double> permeabilities;
-
-        /**
-         * Fluid (melt) density values $\rho_f$ at the given positions.
-         */
-        std::vector<double> fluid_densities;
-
-        /**
-         * An approximation for the fluid (melt) density gradients
-         * $\nabla \rho_f$ at the given positions. These values are
-         * required for compressible models to describe volume changes
-         * of melt in dependence of pressure, temperature etc.
-         */
-        std::vector<Tensor<1,dim>> fluid_density_gradients;
-
-        /**
-         * Do the requested averaging operation for the melt outputs.
-         * The projection matrix argument is only used if the operation
-         * chosen is project_to_Q1.
-         */
-        void average (const MaterialAveraging::AveragingOperation operation,
-                      const FullMatrix<double>  &projection_matrix,
-                      const FullMatrix<double>  &expansion_matrix) override;
-    };
-
-    /**
-     * Base class for material models that implement a melt fraction function.
-     * This is used to compute some statistics about the melt fraction.
-     *
-     * This class is used as a "mix-in" class: Concrete material models will
-     * be derived from MaterialModel::Interface (and consequently have to
-     * implement the `virtual` functions of that class) *and also* from the
-     * current class (and consequently have to implement the `virtual` function
-     * of the current class). The inheritance from MaterialModel::Interface is
-     * typically via the MaterialModel::MeltInterface intermediate class.
-     */
-    template <int dim>
-    class MeltFractionModel
-    {
-      public:
-        /**
-         * Destructor. Does nothing but is virtual so that derived classes
-         * destructors are also virtual.
-         */
-        virtual ~MeltFractionModel () = default;
-
-        /**
-         * Compute the equilibrium melt fractions for the given input conditions.
-         * @p in and @p melt_fractions need to have the same size.
-         *
-         * @param in Object that contains the current conditions.
-         * @param melt_fractions Vector of doubles that is filled with the
-         * equilibrium melt fraction for each given input conditions.
-         */
-        virtual void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                                     std::vector<double> &melt_fractions) const = 0;
-
-        /**
-         * Return whether an object provided as argument is of a class that is
-         * derived from the current MeltFractionModel class. (Many of these models
-         * will be derived from MaterialModel::Interface and *also* be derived
-         * from MeltFractionModel; only the latter derivation is of interest to
-         * this function.
-         */
-        template <typename ModelType>
-        static
-        bool is_melt_fraction_model (const ModelType &model_object);
-
-        /**
-         * Return a reference to the MeltFractionModel base class of
-         * the object. This function will throw an exception unless
-         * is_melt_fraction_model() returns `true` for the given argument.
-         */
-        template <typename ModelType>
-        static
-        const MeltFractionModel<dim> &
-        as_melt_fraction_model (const ModelType &model_object);
-    };
-
-
-
-    template <int dim>
-    template <typename ModelType>
-    inline
-    bool
-    MeltFractionModel<dim>::is_melt_fraction_model (const ModelType &model_object)
-    {
-      return (dynamic_cast<const MeltFractionModel<dim>*>(&model_object)
-              != nullptr);
-    }
-
-
-    template <int dim>
-    template <typename ModelType>
-    inline
-    const MeltFractionModel<dim> &
-    MeltFractionModel<dim>::as_melt_fraction_model (const ModelType &model_object)
-    {
-      Assert (is_melt_fraction_model(model_object) == true,
-              ExcMessage ("This function can only be called for model objects "
-                          "whose types are derived from MeltFractionModel."));
-
-      return dynamic_cast<const MeltFractionModel<dim>&>(model_object);
-    }
-
-
-
-    /**
-     * Base class for material models to be used with melt transport enabled.
-     */
-    template <int dim>
-    class MeltInterface: public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * Reference value for the Darcy coefficient, which is defined as
-         * permeability divided by fluid viscosity. Units: m^2/Pa/s.
-         */
-        virtual double reference_darcy_coefficient () const = 0;
-
-        /**
-         * Returns the cell-averaged and cut-off value of p_c_scale,
-         * the factor we use to rescale the compaction pressure and to
-         * decide if a cell is a melt cell.
-         * The last input argument @p consider_is_melt_cell determines if
-         * this computation takes into account if a cell is a "melt cell".
-         * Melt cells are cells where we solve the melt transport equations,
-         * as indicated by the entries stored in the is_melt_cell vector of
-         * the melt handler. In case @p consider_is_melt_cell is set to true,
-         * this function returns a value of zero if the cell is not a melt cell.
-         * If @p consider_is_melt_cell is set to false the computation
-         * disregards the information about which cells are melt cells,
-         * and computes p_c_scale from the cell-averaged Darcy coefficient
-         * for all cells. This is needed for example when we want to update
-         * the is_melt_cell vector and need to find out which cells should be
-         * marked as melt cells.
-         */
-        double p_c_scale (const MaterialModel::MaterialModelInputs<dim> &inputs,
-                          const MaterialModel::MaterialModelOutputs<dim> &outputs,
-                          const MeltHandler<dim> &melt_handler,
-                          const bool consider_is_melt_cell) const;
-    };
-
-
-  }
-
-
-
-  namespace Assemblers
-  {
-    /**
-     * A base class for the definition of assemblers that implement the linear
-     * system terms for the *melt* migration compressible or incompressible
-     * equations.
-     */
-    template <int dim>
-    class MeltInterface : public aspect::Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Attach melt outputs. Since most melt assemblers require the
-         * melt material model properties they are created in this base class
-         * already.
-         */
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-    };
-
-    /**
-     * Compute the integrals for the preconditioner for the Stokes system in
-     * the case of melt migration on a single cell.
-     */
-    template <int dim>
-    class MeltStokesPreconditioner : public MeltInterface<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * Compute the integrals for the Stokes matrix and right hand side in
-     * the case of melt migration on a single cell.
-     */
-    template <int dim>
-    class MeltStokesSystem : public MeltInterface<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-
-    /**
-     * Compute the boundary integrals for the Stokes right hand side in
-     * the case of melt migration on a single cell. These boundary terms
-     * are used to describe Neumann boundary conditions for the fluid pressure.
-     */
-    template <int dim>
-    class MeltStokesSystemBoundary : public MeltInterface<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * Compute the integrals for the Advection system matrix and right hand side in
-     * the case of melt migration on a single cell.
-     */
-    template <int dim>
-    class MeltAdvectionSystem : public MeltInterface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-
-        /**
-         * Compute the residual of the advection system on a single cell in
-         * the case of melt migration.
-         */
-        std::vector<double>
-        compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
-    };
-
-    /**
-     * Integrate the local fluid pressure shape functions on a single cell
-     * for models with melt migration, so that they can later be used to do
-     * the pressure right-hand side compatibility modification.
-     */
-    template <int dim>
-    class MeltPressureRHSCompatibilityModification : public MeltInterface<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * Assemble traction boundary condition terms for models with melt.
-     */
-    template <int dim>
-    class MeltBoundaryTraction : public MeltInterface<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-  }
-
-
-  namespace Melt
-  {
-    template <int dim>
-    struct Parameters
-    {
-      /**
-       * Declare additional parameters that are needed in models with
-       * melt transport.
-       */
-      static void declare_parameters (ParameterHandler &prm);
-
-      /**
-       * Parse additional parameters that are needed in models with
-       * melt transport.
-       *
-       * This has to be called before edit_finite_element_variables,
-       * so that the finite elements that are used for the additional melt
-       * variables can be specified in the input file and are parsed before
-       * the introspection object is created.
-       */
-      void parse_parameters (ParameterHandler &prm);
-
-      /**
-       * The factor by how much the Darcy coefficient K_D in a cell can be smaller than
-       * the reference Darcy coefficient for this cell still to be considered a melt cell
-       * (for which the melt transport equations are solved). If the Darcy coefficient
-       * is smaller than the product of this value and the reference Dracy coefficient,
-       * the cell is not considered a melt cell and the Stokes system without melt
-       * transport is solved instead. In practice, this means that all terms in the
-       * assembly related to the migration of melt are set to zero, and the compaction
-       * pressure degrees of freedom are constrained to be zero.
-       */
-      double melt_scaling_factor_threshold;
-
-      /**
-       * Whether to use a porosity weighted average of the melt and solid velocity
-       * to advect heat in the temperature equation or not. If this is set to true,
-       * additional terms are assembled on the left-hand side of the temperature
-       * advection equation in models with melt migration.
-       * If this is set to false, only the solid velocity is used (as in models
-       * without melt migration).
-       */
-      bool heat_advection_by_melt;
-
-      /**
-       * Whether to use a discontinuous element for the compaction pressure or not.
-       */
-      bool use_discontinuous_p_c;
-
-      /**
-       * Whether to cell-wise average the material properties that are used to
-       * compute the melt velocity or not. Note that the melt velocity is computed
-       * as the sum of the solid velocity and the phase separation flux (difference
-       * between melt and solid velocity). If this parameter is set to true,
-       * material properties in the computation of the phase separation flux will
-       * be averaged cell-wise.
-       */
-      bool average_melt_velocity;
-    };
-  }
-
-
-  /**
-   * Class that contains all runtime parameters and other helper functions
-   * related to melt transport. A global instance can be retrieved with
-   * SimulatorAccess<dim>::get_melt_handler(), but keep in mind that it only
-   * exists if parameters.include_melt_transport is true.
-   */
-  template <int dim>
-  class MeltHandler: public SimulatorAccess<dim>
-  {
-    public:
-      MeltHandler(ParameterHandler &prm);
-
-      /**
-       * Create an additional material model output object that contains
-       * the additional output variables needed in simulation with melt transport,
-       * and attaches a pointer to it to the corresponding vector in the
-       * MaterialModel::MaterialModelOutputs structure.
-       */
-      static void create_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output);
-
-      /**
-       * Add the additional variables we need in simulations with melt
-       * migration to the list of variables, which will be used later
-       * to set up the introspection object.
-       */
-      void edit_finite_element_variables(const Parameters<dim> &parameters,
-                                         std::vector<VariableDeclaration<dim>> &variables);
-
-      /**
-       * Determine, based on the run-time parameters of the current simulation,
-       * which functions need to be called in order to assemble linear systems,
-       * matrices, and right hand side vectors.
-       */
-      void set_assemblers (Assemblers::Manager<dim> &assemblers) const;
-
-
-      /**
-       * Initialize function. This is mainly to check that the melt transport
-       * parameters chosen in the input file are consistent with the rest of
-       * the options. We can not do this in the parse_parameters function,
-       * as we do not have simulator access at that point.
-       */
-      void initialize() const;
-
-      /**
-       * Setup SimulatorAccess for the plugins related to melt transport.
-       */
-      void initialize_simulator (const Simulator<dim> &simulator_object) override;
-
-      /**
-       * Compute fluid velocity and solid pressure in this ghosted solution vector.
-       * The fluid velocity is computed by solving a mass matrix problem, and the
-       * solid pressure is computed algebraically.
-       *
-       * @param system_matrix The system matrix with an already set up sparsity
-       * pattern that will be used by this function to compute the melt variables.
-       * @param solution The existing solution vector that contains the values
-       * for porosity, compaction pressure, fluid pressure and solid velocity
-       * obtained by solving the Stokes and advection system, and that will be
-       * updated with the computed values for fluid velocity and solid pressure.
-       * @param system_rhs The right-hand side vector that will be used by
-       * this function to compute the melt variables.
-       */
-      void compute_melt_variables(LinearAlgebra::BlockSparseMatrix &system_matrix,
-                                  LinearAlgebra::BlockVector &solution,
-                                  LinearAlgebra::BlockVector &system_rhs);
-
-      /**
-       * Return whether this object refers to the porosity field.
-       */
-      bool is_porosity (const typename Simulator<dim>::AdvectionField &advection_field) const;
-
-      /**
-       * Apply free surface stabilization to a cell of the system matrix when melt
-       * transport is used in the computation. Called during assembly of the system matrix.
-       */
-      void apply_free_surface_stabilization_with_melt (const double free_surface_theta,
-                                                       const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                                       internal::Assembly::Scratch::StokesSystem<dim>       &scratch,
-                                                       internal::Assembly::CopyData::StokesSystem<dim>      &data) const;
-
-      /**
-       * Constrain the compaction pressure to zero in all cells that are not
-       * "melt cells" (cells where the porosity is above a given threshold).
-       * This reverts the system of equations we solve back to the Stokes
-       * system without melt transport for these cells.
-       */
-      void add_current_constraints(AffineConstraints<double> &constraints);
-
-      /**
-       * Returns the entry of the private variable is_melt_cell_vector for the
-       * cell given in the input, describing if we have melt transport in this
-       * cell or not.
-       */
-      bool is_melt_cell(const typename DoFHandler<dim>::active_cell_iterator &cell) const;
-
-      /**
-       * Given the Darcy coefficient @p K_D as computed by the material model,
-       * limit the coefficient to a minimum value (computed as the K_D
-       * variation threshold given in the input file times the reference Darcy
-       * coefficient) in melt cells and return this value. If @p is_melt_cell
-       * is false, return zero.
-       */
-      double limited_darcy_coefficient(const double K_D,
-                                       const bool is_melt_cell) const;
-
-      /**
-       * Return a pointer to the boundary fluid pressure.
-       */
-      const BoundaryFluidPressure::Interface<dim> &
-      get_boundary_fluid_pressure () const;
-
-      /**
-       * The object that stores the run-time parameters that control the how the
-       * melt transport equations are solved.
-       */
-      Melt::Parameters<dim> melt_parameters;
-
-    private:
-      /**
-       * Store a pointer to the fluid pressure boundary plugin, so that the
-       * initialization can be done together with the other objects related to melt
-       * transport.
-       */
-      const std::unique_ptr<aspect::BoundaryFluidPressure::Interface<dim>> boundary_fluid_pressure;
-
-      /**
-       * is_melt_cell_vector[cell->active_cell_index()] says whether we want to
-       * solve the melt transport equations (as opposed to the Stokes equations without
-       * melt) in this cell or not. The value is set to true or false based on the
-       * porosity in the cell (only cells where the porosity is above a threshold are
-       * considered melt cells).
-       */
-      std::vector<bool> is_melt_cell_vector;
-
-      /**
-       * Constraint object. We need to save the current constraints at the
-       * start of every time step so that we can add the melt constraints,
-       * which depend on the solution of the porosity field, later after
-       * we have computed this solution.
-       */
-      AffineConstraints<double> current_constraints;
-
-  };
-
-}
-
-#endif
diff --git a/include/aspect/mesh_deformation/ascii_data.h.bak b/include/aspect/mesh_deformation/ascii_data.h.bak
deleted file mode 100644
index 2b49c54566d..00000000000
--- a/include/aspect/mesh_deformation/ascii_data.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_deformation_ascii_data_h
-#define _aspect_mesh_deformation_ascii_data_h
-
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements initial topography determined
-     * from an AsciiData input file.
-     *
-     * @ingroup InitialTopographyModel
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataBoundary<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Sets the boundary id of the surface boundary.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataBoundary<dim>::initialize;
-
-        /**
-         * Return the surface topography as a function of position along the surface.
-         * For the current class, this function returns a value from the text files.
-         *
-         * @copydoc aspect::InitialTopographyModel::Interface::value()
-         */
-        Tensor<1,dim>
-        compute_initial_deformation_on_boundary(const types::boundary_id boundary_indicator,
-                                                const Point<dim> &position) const override;
-
-        /**
-         * Returns whether or not the plugin requires surface stabilization
-         */
-        bool needs_surface_stabilization () const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        types::boundary_id surface_boundary_id;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/mesh_deformation/diffusion.h.bak b/include/aspect/mesh_deformation/diffusion.h.bak
deleted file mode 100644
index 4459211f10c..00000000000
--- a/include/aspect/mesh_deformation/diffusion.h.bak
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_deformation_diffusion_h
-#define _aspect_mesh_deformation_diffusion_h
-
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-
-  namespace MeshDeformation
-  {
-    /**
-     * A plugin that computes the deformation of surface
-     * vertices according to the solution of a dim-1 diffusion
-     * problem.
-     */
-    template <int dim>
-    class Diffusion : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        Diffusion();
-
-        /**
-         * Initialize function, which sets the start time and
-         * start timestep of diffusion.
-         */
-        void initialize() override;
-
-        /**
-         * The update function sets the current time and determines
-         * whether diffusion should be applied in this timestep.
-         */
-        void update() override;
-
-
-
-        /**
-         * A function that creates constraints for the velocity of certain mesh
-         * vertices (e.g. the surface vertices) for a specific boundary.
-         * The calling class will respect
-         * these constraints when computing the new vertex positions.
-         */
-        void
-        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                 AffineConstraints<double> &mesh_velocity_constraints,
-                                                 const std::set<types::boundary_id> &boundary_id) const override;
-
-        /**
-         * Returns whether or not the plugin requires surface stabilization
-         */
-        bool needs_surface_stabilization () const override;
-
-        /**
-         * Declare parameters for the diffusion of the surface.
-         */
-        static
-        void declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Parse parameters for the diffusion of the surface.
-         */
-        void parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Compute the surface velocity from a difference
-         * in surface height given by the solution of
-         * the hillslope diffusion problem.
-         */
-        void diffuse_boundary (const DoFHandler<dim> &free_surface_dof_handler,
-                               const IndexSet &mesh_locally_owned,
-                               const IndexSet &mesh_locally_relevant,
-                               LinearAlgebra::Vector &output,
-                               const std::set<types::boundary_id> &boundary_id) const;
-
-        /**
-         * Check that the size of the next time step is not larger than the conduction
-         * timestep based on the mesh size and the diffusivity on each cell along the
-         * surface. The computed time step has to satisfy the CFL
-         * number chosen in the input parameter file on each cell of the mesh.
-         */
-        void check_diffusion_time_step (const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                        const std::set<types::boundary_id> &boundary_ids) const;
-
-        /**
-         * The hillslope transport coefficient or diffusivity [m2/s]
-         * used in the hillslope diffusion of the deformed
-         * surface.
-         */
-        double diffusivity;
-
-        /**
-         * Maximum number of steps between the application of diffusion.
-         */
-        unsigned int timesteps_between_diffusion;
-
-        /**
-         * Whether or not in the current timestep, diffusion
-         * should be applied.
-         */
-        bool apply_diffusion;
-
-        /**
-         * Boundaries along which the mesh is allowed to move tangentially
-         * despite of the Stokes velocity boundary conditions.
-         */
-        std::set<types::boundary_id> additional_tangential_mesh_boundary_indicators;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/mesh_deformation/fastscape.h.bak b/include/aspect/mesh_deformation/fastscape.h.bak
deleted file mode 100644
index f087d987365..00000000000
--- a/include/aspect/mesh_deformation/fastscape.h.bak
+++ /dev/null
@@ -1,597 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_mesh_deformation_fastscape_h
-#define _aspect_mesh_deformation_fastscape_h
-
-#include <aspect/global.h>
-
-#ifdef ASPECT_WITH_FASTSCAPE
-
-#include <aspect/mesh_deformation/interface.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace MeshDeformation
-  {
-    /**
-     * A plugin that utilizes the landscape evolution code FastScape
-     * to deform the ASPECT boundary through advection, uplift,
-     * hillslope diffusion, sediment deposition, marine diffusion,
-     * and the stream power law, which describes river incision.
-     *
-     */
-    template <int dim>
-    class FastScape : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialize variables for FastScape.
-         */
-        virtual void initialize () override;
-
-        /**
-         * Destructor for FastScape.
-         */
-        ~FastScape() override;
-
-        /**
-          * A function that creates constraints for the velocity of certain mesh
-          * vertices (e.g. the surface vertices) for a specific boundary.
-          * The calling class will respect
-          * these constraints when computing the new vertex positions.
-          */
-        virtual
-        void
-        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                 AffineConstraints<double> &mesh_velocity_constraints,
-                                                 const std::set<types::boundary_id> &boundary_id) const override;
-
-        /**
-         * Returns whether or not the plugin requires surface stabilization
-         */
-        bool needs_surface_stabilization () const override;
-
-        /**
-         * Declare parameters for the FastScape plugin.
-         */
-        static
-        void declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Parse parameters for the FastScape plugin.
-         */
-        void parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Function used to set the FastScape ghost nodes. FastScape boundaries are
-         * not uplifted or periodic for advection and diffusion. By using a layer
-         * of extra nodes in the FastScape model, we can avoid seeing FastScape boundary
-         * effects within ASPECT. Similarly, we can use these nodes to have fully
-         * periodic boundaries, where we check the flow direction and update the FastScape
-         * ghost nodes, and the nodes one layer inward (boundary nodes in ASPECT) to match
-         * the parameters on the other side (vx, vy, vz, h). This is done every ASPECT timestep
-         * before running FastScape.
-         */
-        void set_ghost_nodes(std::vector<double> &elevation,
-                             std::vector<double> &velocity_x,
-                             std::vector<double> &velocity_y,
-                             std::vector<double> &velocity_z,
-                             const double &fastscape_timestep_in_years,
-                             const bool init) const;
-
-        /**
-         * Function to determine whether the current index is a ghost node
-         */
-        bool is_ghost_node(const unsigned int &index,
-                           const bool &exclude_boundaries) const;
-
-        /**
-         * Function to fill the Fastscape arrays (height and velocities) with the data received from ASPECT in the correct index order.
-         */
-        void fill_fastscape_arrays(std::vector<double> &elevation,
-                                   std::vector<double> &bedrock_transport_coefficient_array,
-                                   std::vector<double> &bedrock_river_incision_rate_array,
-                                   std::vector<double> &velocity_x,
-                                   std::vector<double> &velocity_y,
-                                   std::vector<double> &velocity_z,
-                                   std::vector<std::vector<double>> &temporary_variables) const;
-
-        /**
-         * Function to get the ASPECT topography and velocities at the surface, and an index for transferring these to FastScape.
-         */
-        std::vector<std::vector<double>> get_aspect_values() const;
-
-        /**
-         * Function to initialize or restart FastScape
-         */
-        void initialize_fastscape(std::vector<double> &elevation,
-                                  std::vector<double> &basement,
-                                  std::vector<double> &bedrock_transport_coefficient_array,
-                                  std::vector<double> &bedrock_river_incision_rate_array,
-                                  std::vector<double> &silt_fraction) const;
-
-        /**
-         * Execute FastScape
-         */
-        void execute_fastscape(std::vector<double> &elevation,
-                               std::vector<double> &extra_vtk_field,
-                               std::vector<double> &velocity_x,
-                               std::vector<double> &velocity_y,
-                               std::vector<double> &velocity_z,
-                               const double &fastscape_timestep_in_years,
-                               const unsigned int &fastscape_iterations) const;
-
-        /**
-         * Function to apply orographic (mountain related, e.g., wind or elevation)
-         * controls to the FastScape model.
-         */
-        void apply_orographic_controls(const std::vector<double> &elevation,
-                                       std::vector<double> &bedrock_river_incision_rate_array,
-                                       std::vector<double> &bedrock_transport_coefficient_array) const;
-
-        /**
-         * Fill velocity data table to be interpolated back onto the ASPECT mesh.
-         */
-        Table<dim,double> fill_data_table(std::vector<double> &values,
-                                          TableIndices<dim> &size_idx,
-                                          const unsigned int &fastscape_nx,
-                                          const unsigned int &fastscape_ny) const;
-
-        /**
-         * Read data from file for restarting.
-         */
-        void read_restart_files(std::vector<double> &elevation,
-                                std::vector<double> &basement,
-                                std::vector<double> &silt_fraction) const;
-
-        /**
-         * Save data to file for restarting.
-         */
-        void save_restart_files(const std::vector<double> &elevation,
-                                std::vector<double> &basement,
-                                std::vector<double> &silt_fraction) const;
-
-        /**
-         * Suggestion for the number of FastScape steps to run for every ASPECT timestep,
-         * where the FastScape timestep is determined by ASPECT_timestep_length divided by
-         * this parameter.
-         */
-        unsigned int fastscape_steps_per_aspect_step;
-
-        /**
-         * Maximum timestep allowed for FastScape, if the suggested timestep exceeds this
-         * limit it is repeatedly divided by 2 until the final timestep is smaller than this parameter.
-         */
-        double maximum_fastscape_timestep;
-
-        /**
-         * Check whether FastScape needs to be restarted. This is used as
-         * a mutable bool because we determine whether the model is being resumed in
-         * initialize(), and then after reinitializing FastScape we change it to false
-         * so it does not initialize FastScape again in future timesteps.
-         * TODO: There is probably a better way to do this, and restarts should be rolled into
-         * the general ASPECT restart.
-         */
-        mutable bool restart;
-
-        /**
-         * FastScape cell size in X.
-         */
-        double fastscape_dx;
-
-        /**
-         * FastScape cell size in Y.
-         */
-        double fastscape_dy;
-
-        /**
-         * FastScape X extent (ASPECT X extent + 2*dx for ghost nodes).
-         */
-        double fastscape_x_extent;
-
-        /**
-         * Fastscape Y extent (ASPECT Y extent + 2*dy for ghost nodes).
-         */
-        double fastscape_y_extent;
-
-        /**
-         * User set FastScape Y extent for a 2D ASPECT model.
-         */
-        double fastscape_y_extent_2d;
-
-        /**
-         * Number of x points in FastScape array.
-         */
-        unsigned int fastscape_nx;
-
-        /**
-         * Number of y points in FastScape array.
-         */
-        unsigned int fastscape_ny;
-
-        /**
-         * Vertical exaggeration in FastScape visualization.
-         */
-        double vexp;
-
-        /**
-         * How many levels FastScape should be refined above the maximum ASPECT surface resolution.
-         */
-        unsigned int additional_refinement_levels;
-
-        /**
-         * Maximum expected refinement level at ASPECT's surface.
-         * This and resolution_difference are required to properly transfer node data from
-         * ASPECT to FastScape.
-         */
-        unsigned int maximum_surface_refinement_level;
-
-        /**
-         * Difference in refinement levels expected at the ASPECT surface,
-         * where this would be set to 2 if 3 refinement levels are set at the surface.
-         * This and surface_resolution are required to properly transfer node data from
-         * ASPECT to FastScape.
-         *
-         * TODO: Should this be kept this way, or make it so the input is the expected levels
-         * of refinement at the surface, and we can subtract one within the code? Also,
-         * it would be good to find a way to check these are correct, because they are a
-         * common source of errors.
-         */
-        unsigned int surface_refinement_difference;
-
-        /**
-         * If set to true, the FastScape surface is averaged along Y and returned
-         * to ASPECT. If set to false, the center slice of the FastScape model is
-         * returned to ASPECT.
-         */
-        bool average_out_of_plane_surface_topography;
-
-        /**
-         * Seed number for initial topography noise in FastScape.
-         */
-        int fastscape_seed;
-
-        /**
-         * Variable to hold ASPECT domain extents.
-         */
-        std::array<std::pair<double,double>,dim> grid_extent;
-
-        /**
-         * Table for interpolating FastScape surface velocities back to ASPECT.
-         */
-        std::array<unsigned int, dim> table_intervals;
-
-        /**
-         * Whether or not to use the ghost nodes.
-         */
-        bool use_ghost_nodes;
-
-        /**
-         * Magnitude (m) of the initial noise applied to FastScape.
-         * Applied as either a + or - value to the topography
-         * such that the total difference can be up to 2*noise_elevation.
-         */
-        double noise_elevation;
-
-        /**
-         * Sediment rain in m/yr, added as a flat increase to the FastScape surface
-         * in the marine domain every ASPECT timestep before running FastScape.
-         */
-        std::vector<double> sediment_rain_rates;
-
-        /**
-         * Time at which each interval of sediment_rain_rates is active. Should contain
-         * one less value than sediment_rain_rates, assuming that sediment_rain_rates[0]
-         * is applied from model time 0 until sediment_rain_times[0].
-         */
-        std::vector<double> sediment_rain_times;
-
-        /**
-        * Flag for having FastScape advect/uplift the surface. If the free surface is used
-        * in conjunction with FastScape, this can be set to false, then FastScape will only
-        * apply erosion/deposition to the surface and not advect or uplift it.
-        */
-        bool fastscape_advection_uplift;
-
-        /**
-         * Node tolerance for how close a ASPECT node must be to the FastScape node
-         * for the value to be transferred. This is only necessary if use_v is set to 0
-         * and the free surface is used to advect the surface with a normal projection, or
-         * if there is a surface refinement level difference leading to excess interpolation
-         * points in areas of high ASPECT resolution.
-         */
-        double node_tolerance;
-
-        /**
-          * Interval between the generation of graphical output. This parameter
-          * is read from the input file and consequently is not part of the
-          * state that needs to be saved and restored.
-          */
-        double output_interval;
-
-        /**
-          * A time (in seconds) at which the last graphical output was supposed
-          * to be produced. Used to check for the next necessary output time.
-          */
-        mutable double last_output_time;
-
-        /**
-         * @name Fastscape boundary conditions
-         * @{
-         */
-
-        /**
-         * FastScape bottom boundary condition that determines topography at the FastScape bottom boundary.
-         * Where 1 represents a fixed height boundary (though this can still be uplifted through uplift velocities), and 0 a
-         * reflective boundary. When two opposing boundaries are reflective (e.g., top and bottom are both zero), then the boundaries
-         * become cyclic.
-         */
-        unsigned int bottom;
-
-        /**
-         * FastScape top boundary condition that determines topography at the FastScape top boundary.
-         * Where 1 represents a fixed height boundary (though this can still be uplifted through uplift velocities), and 0 a
-         * reflective boundary. When two opposing boundaries are reflective (e.g., top and bottom are both zero), then the boundaries
-         * become cyclic.
-         */
-        unsigned int top;
-
-        /**
-         * FastScape right boundary condition that determines topography at the FastScape right boundary.
-         * Where 1 represents a fixed height boundary (though this can still be uplifted through uplift velocities), and 0 a
-         * reflective boundary. When two opposing boundaries are reflective (e.g., left and right are both zero), then the boundaries
-         * become cyclic.
-         */
-        unsigned int right;
-
-        /**
-         * FastScape left boundary condition that determines topography at the FastScape left boundary.
-         * Where 1 represents a fixed height boundary (though this can still be uplifted through uplift velocities), and 0 a
-         * reflective boundary. When two opposing boundaries are reflective (e.g., left and right are both zero), then the boundaries
-         * become cyclic.
-         */
-        unsigned int left;
-
-        /**
-         * Parameters that set the FastScape boundaries periodic even though the ghost nodes are set 'fixed'
-         */
-        bool topbottom_ghost_nodes_periodic;
-        bool leftright_ghost_nodes_periodic;
-
-        /**
-         * Integer that holds the full boundary conditions sent to FastScape (e.g., 1111).
-         */
-        unsigned int fastscape_boundary_conditions;
-
-        /**
-         * Prescribed flux per unit length into the model through the bottom boundary (m^2/yr).
-         */
-        double bottom_flux;
-
-        /**
-         * Prescribed flux per unit length into the model through the top boundary (m^2/yr).
-         */
-        double top_flux;
-
-        /**
-         * Prescribed flux per unit length into the model through the right boundary (m^2/yr).
-         */
-        double right_flux;
-
-        /**
-         * Prescribed flux per unit length into the model through the left boundary (m^2/yr).
-         */
-        double left_flux;
-        /**
-           * @}
-         */
-
-        /**
-         * @name FastScape subaerial erosional parameters
-         * @{
-         */
-
-        /**
-         * Drainage area exponent for the stream power law. ($m$ variable in FastScape surface equation.)
-         */
-        double drainage_area_exponent_m;
-
-        /**
-         * Slope exponent for the stream power law. ($n$ variable in FastScape surface equation.)
-         */
-        double slope_exponent_n;
-
-        /**
-         * Slope exponent for multi-direction flow, where 0 is uniform, and 10 is steepest descent. (-1 varies with slope.)
-         * ($p$ variable in FastScape surface equation.)
-         */
-        double slope_exponent_p;
-
-        /**
-         * Bedrock deposition coefficient. Higher values deposit more sediment
-         * inside the domain. ($G$ variable in FastScape surface equation.)
-         */
-        double bedrock_deposition_g;
-
-        /**
-         * Sediment deposition coefficient. Higher values deposit more sediment inside the domain.
-         * When set to -1 this is identical to the bedrock value.
-         * ($G$ variable in FastScape surface equation applied to sediment.)
-         */
-        double sediment_deposition_g;
-
-        /**
-         * Bedrock river incision rate for the stream power law.
-         * (meters^(1-2m)/yr, $kf$ variable in FastScape surface equation.)
-         */
-        double bedrock_river_incision_rate;
-
-        /**
-         * Sediment river incision rate for the stream power law (meters^(1-2m)/yr).
-         * When set to -1 this is identical to the bedrock value.
-         * ($kf$ variable in FastScape surface equation applied to sediment.)
-         */
-        double sediment_river_incision_rate;
-
-        /**
-         * Bedrock transport coefficient for hillslope diffusion (m^2/yr, kd in FastScape surface equation.)
-         */
-        double bedrock_transport_coefficient;
-
-        /**
-         * Sediment transport coefficient for hillslope diffusion (m^2/yr). When set to -1 this is
-         * identical to the bedrock value.
-         * (kd in FastScape surface equation applied to sediment).
-         */
-        double sediment_transport_coefficient;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Fastscape marine parameters
-         * @{
-         */
-
-        /**
-         * Fastscape sea level (m), set relative to the ASPECT surface where
-         * a sea level of zero will represent the initial maximum unperturbed
-         * Y (2D) or Z (3D) extent of the ASPECT domain. A negative value of
-         * the sea level means the sea level lies below the initial unperturbed
-         * top boundary of the domain.
-         */
-        double sea_level;
-
-        /**
-         * Parameters to set an extra erosional base level
-         * on the ghost nodes that differs from sea level.
-         */
-        bool use_fixed_erosional_base;
-
-        /**
-         * Height of the extra erosional base level.
-         */
-        double h_erosional_base;
-
-        /**
-         * Surface porosity for sand.
-         */
-        double sand_surface_porosity;
-
-        /**
-         * Surface porosity for silt.
-         */
-        double silt_surface_porosity;
-
-        /**
-         * Sands e-folding depth for exponential porosity law (m).
-         */
-        double sand_efold_depth;
-
-        /**
-         * Silts e-folding depth for exponential porosity law (m).
-         */
-        double silt_efold_depth;
-
-        /**
-         * Sand-silt ratio
-         */
-        double sand_silt_ratio;
-
-        /**
-         * Averaging depth/thickness for sand-silt equation (m).
-         */
-        double sand_silt_averaging_depth;
-
-        /**
-         * Sand marine transport coefficient. (marine diffusion, m^2/yr.)
-         */
-        double sand_transport_coefficient;
-
-        /**
-         * Silt marine transport coefficient. (marine diffusion, m^2/yr.)
-         */
-        double silt_transport_coefficient;
-
-        /**
-         * Flag to use the marine component of FastScape.
-         */
-        bool use_marine_component;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Orographic parameters
-         * @{
-         */
-
-        /**
-         * Set a flat height (m) after which the flat_erosional_factor
-         * is applied to the bedrock river incision rate and transport coefficient.
-         */
-        int flat_elevation;
-
-        /**
-         * Set the height (m) after which the model will track the ridge line
-         * and based on the wind direction will apply the wind_barrier_erosional_factor
-         * to the bedrock river incision rate and transport coefficient.
-         */
-        int wind_barrier_elevation;
-
-        /**
-         * Wind direction for wind_barrier_erosional_factor.
-         */
-        unsigned int wind_direction;
-
-        /**
-         * Factor to multiply the bedrock river incision rate and transport coefficient by depending on them
-         * flat_elevation.
-         */
-        double flat_erosional_factor;
-
-        /**
-         * Factor to multiply the bedrock river incision rate and transport coefficient by depending on them
-         * wind_barrier_elevation and wind direction.
-         */
-        double wind_barrier_erosional_factor;
-
-        /**
-         * Flag to stack both orographic controls.
-         */
-        bool stack_controls;
-
-        /**
-         * Flag to use orographic controls.
-         */
-        bool use_orographic_controls;
-        /**
-         * @}
-         */
-    };
-  }
-}
-
-#endif
-#endif
diff --git a/include/aspect/mesh_deformation/free_surface.h.bak b/include/aspect/mesh_deformation/free_surface.h.bak
deleted file mode 100644
index 7cb6c1fd631..00000000000
--- a/include/aspect/mesh_deformation/free_surface.h.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_deformation_free_surface_h
-#define _aspect_mesh_deformation_free_surface_h
-
-#include <aspect/mesh_deformation/interface.h>
-
-#include <aspect/simulator_access.h>
-#include <aspect/simulator/assemblers/interface.h>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace MeshDeformation
-  {
-    /**
-     * A plugin that computes the deformation of surface
-     * vertices according to the solution of the flow problem.
-     * In particular this means if the surface of the domain is
-     * left open to flow, this flow will carry the mesh with it.
-     */
-    template <int dim>
-    class FreeSurface : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialize function, which connects the set_assemblers function
-         * to the appropriate Simulator signal.
-         */
-        void initialize() override;
-
-        /**
-         * Called by Simulator::set_assemblers() to allow the FreeSurface plugin
-         * to register its assembler.
-         */
-        void set_assemblers(const SimulatorAccess<dim> &simulator_access,
-                            aspect::Assemblers::Manager<dim> &assemblers) const;
-
-
-        /**
-         * A function that creates constraints for the velocity of certain mesh
-         * vertices (e.g. the surface vertices) for a specific boundary.
-         * The calling class will respect
-         * these constraints when computing the new vertex positions.
-         */
-        void
-        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                 AffineConstraints<double> &mesh_velocity_constraints,
-                                                 const std::set<types::boundary_id> &boundary_id) const override;
-
-        /**
-         * Returns whether or not the plugin requires surface stabilization
-         */
-        bool needs_surface_stabilization () const override;
-
-        /**
-         * Declare parameters for the free surface handling.
-         */
-        static
-        void declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Parse parameters for the free surface handling.
-         */
-        void parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Project the Stokes velocity solution onto the
-         * free surface. Called by make_constraints()
-         */
-        void project_velocity_onto_boundary (const DoFHandler<dim> &free_surface_dof_handler,
-                                             const IndexSet &mesh_locally_owned,
-                                             const IndexSet &mesh_locally_relevant,
-                                             LinearAlgebra::Vector &output) const;
-
-        /**
-         * A struct for holding information about how to advect the free surface.
-         */
-        struct SurfaceAdvection
-        {
-          enum Direction { normal, vertical };
-        };
-
-        /**
-         * Stores whether to advect the free surface in the normal direction
-         * or the direction of the local vertical.
-         */
-        typename SurfaceAdvection::Direction advection_direction;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/mesh_deformation/function.h.bak b/include/aspect/mesh_deformation/function.h.bak
deleted file mode 100644
index 7f2d29a5258..00000000000
--- a/include/aspect/mesh_deformation/function.h.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_deformation_boundary_function_h
-#define _aspect_mesh_deformation_boundary_function_h
-
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace MeshDeformation
-  {
-    template <int dim>
-    class BoundaryFunction : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        BoundaryFunction();
-
-        /**
-         *
-         */
-        void update() override;
-
-        /**
-         * A function that creates constraints for the velocity of certain mesh
-         * vertices (e.g. the surface vertices) for a specific boundary.
-         * The calling class will respect
-         * these constraints when computing the new vertex positions.
-         */
-        void
-        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                 AffineConstraints<double> &mesh_velocity_constraints,
-                                                 const std::set<types::boundary_id> &boundary_id) const override;
-
-        /**
-         * Returns whether or not the plugin requires surface stabilization
-         */
-        bool needs_surface_stabilization () const override;
-
-        /**
-         * Declare parameters for the free surface handling.
-         */
-        static
-        void declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Parse parameters for the free surface handling.
-         */
-        void parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the mesh deformation.
-         */
-        Functions::ParsedFunction<dim> function;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/mesh_deformation/interface.h.bak b/include/aspect/mesh_deformation/interface.h.bak
deleted file mode 100644
index 210b61651d5..00000000000
--- a/include/aspect/mesh_deformation/interface.h.bak
+++ /dev/null
@@ -1,649 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_deformation_interface_h
-#define _aspect_mesh_deformation_interface_h
-
-#include <aspect/plugins.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <deal.II/fe/fe_system.h>
-#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/lac/affine_constraints.h>
-#include <deal.II/base/index_set.h>
-#include <deal.II/base/mg_level_object.h>
-#include <deal.II/lac/la_parallel_vector.h>
-#include <deal.II/multigrid/mg_constrained_dofs.h>
-#include <deal.II/multigrid/mg_transfer_matrix_free.h>
-#include <deal.II/multigrid/mg_transfer_global_coarsening.templates.h>
-#include <aspect/simulator/assemblers/interface.h>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace Assemblers
-  {
-    /**
-     * Apply stabilization to a cell of the system matrix. The
-     * stabilization is only added to cells on a free surface. The
-     * scheme is based on that of Kaus et. al., 2010. Called during
-     * assembly of the system matrix.
-     */
-    template <int dim>
-    class ApplyStabilization: public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        ApplyStabilization(const double stabilization_theta);
-
-        void
-        execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
-                 internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
-
-      private:
-        /**
-         * Stabilization parameter for the free surface. Should be between
-         * zero and one. A value of zero means no stabilization. See Kaus
-         * et. al. 2010 for more details.
-         */
-        const double free_surface_theta;
-    };
-  }
-
-  template <int dim> class Simulator;
-
-  /**
-   * A namespace that contains everything that is related to the deformation
-   * of the mesh vertices over time.
-   */
-  namespace MeshDeformation
-  {
-    /**
-     * A base class for mesh deformation plugins. Each derived class should
-     * implement a function that determines the deformation velocity for certain
-     * mesh vertices and store them in a AffineConstraints<double> object. The velocities
-     * for all non-constrained vertices will be computed by solving a Laplace
-     * problem with the given constraints.
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * A function that will be called to check whether stabilization is needed.
-         */
-        virtual bool needs_surface_stabilization() const;
-
-
-        /**
-         * A function that returns the initial deformation of points on the
-         * boundary (e.g. the surface vertices). @p position is the undeformed
-         * position and this function is expected to return the
-         * displacement vector of this position. The default implementation
-         * returns a zero displacement (= no initial deformation).
-         */
-        virtual
-        Tensor<1,dim>
-        compute_initial_deformation_on_boundary(const types::boundary_id boundary_indicator,
-                                                const Point<dim> &position) const;
-
-        /**
-         * A function that creates constraints for the velocity of certain mesh
-         * vertices (e.g. the surface vertices) for a specific set of boundaries.
-         * The calling class will respect
-         * these constraints when computing the new vertex positions.
-         * The default implementation creates no constraints.
-         */
-        virtual
-        void
-        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                 AffineConstraints<double> &mesh_velocity_constraints,
-                                                 const std::set<types::boundary_id> &boundary_id) const;
-    };
-
-
-
-    /**
-     * The MeshDeformationHandler that handles the motion
-     * of the surface, the internal nodes and computes the
-     * Arbitrary-Lagrangian-Eulerian correction terms.
-     */
-    template <int dim>
-    class MeshDeformationHandler: public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Initialize the mesh deformation handler, allowing it to read in
-         * relevant parameters as well as giving it a reference to the
-         * Simulator that owns it, since it needs to make fairly extensive
-         * changes to the internals of the simulator.
-         */
-        MeshDeformationHandler(Simulator<dim> &simulator);
-
-        /**
-         * Destructor for the mesh deformation handler.
-         */
-        ~MeshDeformationHandler() override;
-
-        /**
-         * Initialization function of the MeshDeformationHandler.
-         *
-         * The default implementation of this function does nothing.
-         */
-        void initialize();
-
-        /**
-         * Called by Simulator::set_assemblers() to allow the FreeSurface plugin
-         * to register its assembler.
-         */
-        void set_assemblers(const SimulatorAccess<dim> &simulator_access,
-                            aspect::Assemblers::Manager<dim> &assemblers) const;
-
-        /**
-         * Update function of the MeshDeformationHandler. This function
-         * allows the individual mesh deformation objects to update.
-         */
-        void update();
-
-        /**
-         * The main execution step for the mesh deformation implementation. This
-         * computes the motion of the surface, moves the boundary nodes
-         * accordingly, redistributes the internal nodes in order to
-         * preserve mesh regularity, and calculates the
-         * Arbitrary-Lagrangian-Eulerian correction terms for advected quantities.
-         */
-        void execute();
-
-        /**
-         * Allocates and sets up the members of the MeshDeformationHandler. This
-         * is called by Simulator<dim>::setup_dofs()
-         */
-        void setup_dofs();
-
-        /**
-         * Declare parameters for the mesh deformation handling.
-         */
-        static
-        void declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Parse parameters for the mesh deformation handling.
-         */
-        void parse_parameters (ParameterHandler &prm);
-
-        /**
-         * A function that is used to register mesh deformation objects in such
-         * a way that the Manager can deal with all of them without having to
-         * know them by name. This allows the files in which individual
-         * plugins are implemented to register these plugins, rather than also
-         * having to modify the Manager class by adding the new initial
-         * mesh deformation plugin class.
-         *
-         * @param name A string that identifies the mesh deformation model
-         * @param description A text description of what this model does and that
-         * will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that can be
-         * used to declare the parameters that this mesh deformation model
-         * wants to read from input files.
-         * @param factory_function A pointer to a function that can create an
-         * object of this mesh deformation model.
-         */
-        static
-        void
-        register_mesh_deformation
-        (const std::string &name,
-         const std::string &description,
-         void (*declare_parameters_function) (ParameterHandler &),
-         std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-        /**
-         * Return a map of boundary indicators to the names of all mesh deformation models currently
-         * used in the computation, as specified in the input file.
-         */
-        const std::map<types::boundary_id, std::vector<std::string>> &
-        get_active_mesh_deformation_names () const;
-
-        /**
-         * Return a map of boundary indicators to vectors of pointers to all mesh deformation models
-         * currently used in the computation, as specified in the input file.
-         */
-        const std::map<types::boundary_id,std::vector<std::unique_ptr<Interface<dim>>>> &
-        get_active_mesh_deformation_models () const;
-
-        /**
-         * Return a set of all the indicators of boundaries with
-         * mesh deformation objects on them.
-         */
-        const std::set<types::boundary_id> &
-        get_active_mesh_deformation_boundary_indicators () const;
-
-        /**
-         * Return a set of all the indicators of boundaries that
-         * require surface stabilization.
-         */
-        const std::set<types::boundary_id> &
-        get_boundary_indicators_requiring_stabilization () const;
-
-        /**
-         * Return the boundary id of the surface that has a free surface
-         * mesh deformation object. If no free surface is used,
-         * an empty set is returned.
-         */
-        const std::set<types::boundary_id> &
-        get_free_surface_boundary_indicators () const;
-
-        /**
-         * Return the stabilization parameter for the free surface.
-         */
-        double get_free_surface_theta () const;
-
-        /**
-         * Return the initial topography stored on
-         * the Q1 finite element that describes the mesh geometry.
-         * Note that a topography is set for all mesh nodes,
-         * but only the values of surface boundary nodes are correct.
-         * The internal nodes get the same initial topography as the
-         * corresponding surface node. In other words, there is
-         * no decrease of the initial topography with depth.
-         * However, only the topography stored at the surface nodes
-         * is taken into account in the diffusion plugin that
-         * uses this function. TODO Once all initial_topography
-         * is prescribed through initial_mesh_deformation, this
-         * function can be removed.
-         */
-        const LinearAlgebra::Vector &
-        get_initial_topography () const;
-
-        /**
-         * Return the mesh displacements based on the mesh deformation
-         * DoFHandler you can access with get_mesh_deformation_dof_handler().
-         */
-        const LinearAlgebra::Vector &
-        get_mesh_displacements () const;
-
-        /**
-         * Return the DoFHandler used to represent the mesh deformation space.
-         */
-        const DoFHandler<dim> &
-        get_mesh_deformation_dof_handler () const;
-
-        /**
-         * Go through the list of all mesh deformation objects that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename MeshDeformationType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,MeshDeformationType>::value>>
-        bool
-        has_matching_mesh_deformation_object () const;
-
-        /**
-         * Go through the list of all mesh deformation objects that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no mesh deformation object is active that matches the given type,
-         * throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename MeshDeformationType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,MeshDeformationType>::value>>
-        const MeshDeformationType &
-        get_matching_mesh_deformation_object () const;
-
-
-        /**
-         * If multilevel solvers are used, we need a mapping on each multigrid level. These
-         * are automatically updated by this handler class and can be accessed with this
-         * method.
-         */
-        const Mapping<dim> &
-        get_level_mapping(const unsigned int level) const;
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcMeshDeformationNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered mesh deformation objects.");
-
-      private:
-        /**
-         * Compute the initial constraints for the mesh displacement
-         * on the boundaries of the domain.  This is used on the mesh
-         * deformation boundaries to describe a displacement (initial
-         * topography) to be used during the simulation. The
-         * displacement is given by the active deformation plugins.
-         */
-        void make_initial_constraints ();
-
-        /**
-         * Compute the constraints for the mesh velocity on the
-         * boundaries of the domain.  On the mesh deformation
-         * boundaries, the velocity is given by the active deformation
-         * plugins.
-         *
-         * Velocities on free-slip boundaries are constrained to be
-         * tangential to those boundaries. Velocities on no-slip
-         * boundaries are set to be zero. If a no-slip boundary is
-         * marked as additional tangential, then velocities are
-         * constrained as tangential.
-         */
-        void make_constraints ();
-
-        /**
-         * Solve vector Laplacian equation for internal mesh displacements and update
-         * the current displacement vector based on the solution.
-         */
-        void compute_mesh_displacements ();
-
-        /**
-         * Solve vector Laplacian equation using GMG for internal mesh displacements and update
-         * the current displacement vector based on the solution.
-         */
-        void compute_mesh_displacements_gmg ();
-
-        /**
-         * Set up the vector with initial displacements of the mesh
-         * due to the initial topography, as supplied by the initial
-         * topography plugin based on the surface coordinates of the
-         * mesh nodes. We set all entries to the initial topography
-         * based on its surface coordinates, i.e. the initial topography
-         * is not corrected for depth from the surface as it is
-         * for the initial mesh deformation. TODO this is ok for now,
-         * because the surface diffusion plugin only cares about the
-         * initial topography at the surface, but it would be more correct if it
-         * sets the initial topography to the actual initial distortion of
-         * the mesh cells. When all initial_topography plugins are converted
-         * to the new initial_mesh_deformation functionality, this function
-         * can be removed.
-         */
-        void set_initial_topography ();
-
-        /**
-         * Calculate the velocity of the mesh for ALE corrections.
-         */
-        void interpolate_mesh_velocity ();
-
-        /**
-         * Update the mesh deformation for the multigrid levels.
-         */
-        void update_multilevel_deformation ();
-
-        /**
-         * Reference to the Simulator object to which a MeshDeformationHandler
-         * instance belongs.
-         */
-        Simulator<dim> &sim;
-
-        /**
-         * Finite element for the mesh deformation implementation, which is
-         * used for tracking mesh deformation.
-         */
-        const FESystem<dim> mesh_deformation_fe;
-
-        /**
-         * DoFHandler for the mesh deformation implementation.
-         */
-        DoFHandler<dim> mesh_deformation_dof_handler;
-
-        /**
-         * BlockVector which stores the mesh velocity in the
-         * Stokes finite element space.
-         * This is used for ALE corrections.
-         */
-        LinearAlgebra::BlockVector mesh_velocity;
-
-        /**
-         * Vector for storing the positions of the mesh vertices. This
-         * is used for calculating the mapping from the reference cell to
-         * the position of the cell in the deformed mesh. This must be
-         * redistributed upon mesh refinement.
-         */
-        LinearAlgebra::Vector mesh_displacements;
-
-        /**
-         * mesh_displacements from the last time step.
-         */
-        LinearAlgebra::Vector old_mesh_displacements;
-
-        /**
-         * Vector for storing the positions of the mesh vertices at the initial timestep.
-         * This must be redistributed upon mesh refinement.
-         * We need to store the initial topography because it is not taken
-         * into account into the mesh displacements used by the MappingQ1Eulerian.
-         * The current mesh displacements plus the initial topography provide
-         * the actual topography at any time.
-         */
-        LinearAlgebra::Vector initial_topography;
-
-        /**
-         * Vector for storing the mesh velocity in the mesh deformation finite
-         * element space, which is, in general, not the same finite element
-         * space as the Stokes system. This is used for interpolating
-         * the mesh velocity in the mesh deformation finite element space onto
-         * the velocity in the Stokes finite element space, which is then
-         * used for making the ALE correction in the advection equations.
-         */
-        LinearAlgebra::Vector fs_mesh_velocity;
-
-        /**
-         * IndexSet for the locally owned DoFs for the mesh system
-         */
-        IndexSet mesh_locally_owned;
-
-        /**
-         * IndexSet for the locally relevant DoFs for the mesh system
-         */
-        IndexSet mesh_locally_relevant;
-
-        /**
-         * Storage for the mesh velocity constraints for solving the
-         * elliptic problem.
-         */
-        AffineConstraints<double> mesh_velocity_constraints;
-
-        /**
-         * Storage for the mesh vertex constraints for keeping the mesh conforming
-         * upon redistribution.
-         */
-        AffineConstraints<double> mesh_vertex_constraints;
-
-        /**
-         * A map of boundary ids to mesh deformation objects that have been requested
-         * in the parameter file.
-         */
-        std::map<types::boundary_id,std::vector<std::unique_ptr<Interface<dim>>>> mesh_deformation_objects;
-
-        /**
-         * Map from boundary id to a vector of names representing
-         * mesh deformation objects.
-         */
-        std::map<types::boundary_id, std::vector<std::string>> mesh_deformation_object_names;
-
-        /**
-         * The set of boundary indicators for which mesh deformation
-         * objects are set and that therefore can deform over time as
-         * prescribed in the mesh_deformation_objects.
-         */
-        std::set<types::boundary_id> prescribed_mesh_deformation_boundary_indicators;
-
-        /**
-         * A set of boundary indicators that denote those boundaries that are
-         * allowed to move their mesh tangential to the boundary.
-         */
-        std::set<types::boundary_id> tangential_mesh_deformation_boundary_indicators;
-
-        /**
-         * A set of boundary indicators, on which mesh deformation is prescribed to
-         * be zero (fixed boundaries that never move). All boundaries except those
-         * in prescribed_mesh_deformation_boundary_indicators and
-         * tangential_mesh_deformation_boundary_indicators are in this set.
-         */
-        std::set<types::boundary_id> zero_mesh_deformation_boundary_indicators;
-
-        /**
-         * The boundary indicator(s) of the free surface(s). This is the
-         * subset of prescribed_mesh_deformation_boundary_indicators for which
-         * the 'free surface' plugin was selected.
-         */
-        std::set<types::boundary_id> free_surface_boundary_indicators;
-
-        /**
-         * The set of boundary indicators for which the mesh deformation
-         * objects need surface stabilization.
-         */
-        std::set<types::boundary_id> boundary_indicators_requiring_stabilization;
-
-        bool include_initial_topography;
-
-        /**
-         * Stabilization parameter for the free surface. Should be between
-         * zero and one. A value of zero means no stabilization.  See Kaus
-         * et. al. 2010 for more details.
-         */
-        double surface_theta;
-
-        /**
-         * If required, store a mapping for each multigrid level.
-         */
-        MGLevelObject<std::unique_ptr<Mapping<dim>>> level_mappings;
-
-        /**
-         * One vector on each multigrid level for the mesh displacement used in the mapping.
-         */
-        MGLevelObject<dealii::LinearAlgebra::distributed::Vector<double>> level_displacements;
-
-        /**
-         * Multigrid transfer operator for the displacements
-         */
-        MGTransferMF<dim, double> mg_transfer;
-
-        /**
-         * Multigrid level constraints for the displacements
-         */
-        MGConstrainedDoFs mg_constrained_dofs;
-
-        friend class Simulator<dim>;
-        friend class SimulatorAccess<dim>;
-    };
-
-
-
-    template <int dim>
-    template <typename MeshDeformationType, typename>
-    inline
-    bool
-    MeshDeformationHandler<dim>::has_matching_mesh_deformation_object () const
-    {
-      for (const auto &object_iterator : mesh_deformation_objects)
-        for (const auto &p : object_iterator.second)
-          if (Plugins::plugin_type_matches<MeshDeformationType>(*p))
-            return true;
-
-      return false;
-    }
-
-
-
-    template <int dim>
-    template <typename MeshDeformationType, typename>
-    inline
-    const MeshDeformationType &
-    MeshDeformationHandler<dim>::get_matching_mesh_deformation_object () const
-    {
-      AssertThrow(has_matching_mesh_deformation_object<MeshDeformationType> (),
-                  ExcMessage("You asked MeshDeformation::MeshDeformationHandler::get_matching_mesh_deformation_object() for a "
-                             "mesh deformation object of type <" + boost::core::demangle(typeid(MeshDeformationType).name()) + "> "
-                             "that could not be found in the current model. Activate this "
-                             "mesh deformation in the input file."));
-
-      for (const auto &object_iterator : mesh_deformation_objects)
-        for (const auto &p : object_iterator.second)
-          if (Plugins::plugin_type_matches<MeshDeformationType>(*p))
-            return Plugins::get_plugin_as_type<MeshDeformationType>(*p);
-
-      // We will never get here, because we had the Assert above. Just to avoid warnings.
-      typename std::vector<std::unique_ptr<Interface<dim>>>::const_iterator mesh_def;
-      return Plugins::get_plugin_as_type<MeshDeformationType>(*(*mesh_def));
-
-    }
-
-
-    /**
-     * Return a string that consists of the names of mesh deformation models that can
-     * be selected. These names are separated by a vertical line '|' so
-     * that the string can be an input to the deal.II classes
-     * Patterns::Selection or Patterns::MultipleSelection.
-     */
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ();
-
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a mesh deformation model, register it with the functions that can
-     * declare their parameters and create these objects.
-     *
-     * @ingroup MeshDeformations
-     */
-#define ASPECT_REGISTER_MESH_DEFORMATION_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_MESH_DEFORMATION_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::MeshDeformation::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::MeshDeformation::MeshDeformationHandler<2>::register_mesh_deformation, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::MeshDeformation::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::MeshDeformation::MeshDeformationHandler<3>::register_mesh_deformation, \
-                                name, description); \
-  }
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/artificial_viscosity.h.bak b/include/aspect/mesh_refinement/artificial_viscosity.h.bak
deleted file mode 100644
index 7a1ef789a3b..00000000000
--- a/include/aspect/mesh_refinement/artificial_viscosity.h.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_artificial_viscosity_h
-#define _aspect_mesh_refinement_artificial_viscosity_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on the
-     * artificial viscosity of the temperature or compositional fields.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class ArtificialViscosity : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * @copydoc Interface<dim>::execute()
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * Scaling factor for the temperature indicator.
-         */
-        double temperature_scaling_factor;
-
-        /**
-         * The scaling factors for each compositional field.
-         */
-        std::vector<double> composition_scaling_factors;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/boundary.h.bak b/include/aspect/mesh_refinement/boundary.h.bak
deleted file mode 100644
index b74aa534652..00000000000
--- a/include/aspect/mesh_refinement/boundary.h.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_boundary_h
-#define _aspect_mesh_refinement_boundary_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion that refines the
-     * mesh on selected boundaries. This is useful for cases where one wants
-     * to accurately model processes at a boundary.  Frequently, there are
-     * also strong temperature or compositional gradients at boundaries, so
-     * this refinement criterion can be redundant.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Boundary : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A set of boundary indicators marked for refinement
-         */
-        std::set<types::boundary_id> boundary_refinement_indicators;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/compaction_length.h.bak b/include/aspect/mesh_refinement/compaction_length.h.bak
deleted file mode 100644
index 60199d3d1fd..00000000000
--- a/include/aspect/mesh_refinement/compaction_length.h.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_compaction_length_h
-#define _aspect_mesh_refinement_compaction_length_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on the
-     * compaction length, a typical length scale in models with melt
-     * migration. The user can specify a desired ratio between the
-     * compaction length and the size of the mesh cells, and every cell
-     * where this ratio is smaller than specified is marked for refinement.
-     * This means that there will always be a given (minimum) number of
-     * mesh cells per compaction length.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class CompactionLength : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * After cells have been marked for coarsening/refinement, apply
-         * additional criteria independent of the error estimate.
-         */
-        void
-        tag_additional_cells () const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The desired ratio between compaction length and size of the mesh cells,
-         * in other words, how many cells the mesh should have per compaction length.
-         */
-        double cells_per_compaction_length;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/composition.h.bak b/include/aspect/mesh_refinement/composition.h.bak
deleted file mode 100644
index 05e100701fa..00000000000
--- a/include/aspect/mesh_refinement/composition.h.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_composition_h
-#define _aspect_mesh_refinement_composition_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on the
-     * compositional fields (if available).
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Composition : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The scaling factors that should be applied to the individual
-         * refinement indicators before merging.
-         */
-        std::vector<double> composition_scaling_factors;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/composition_approximate_gradient.h.bak b/include/aspect/mesh_refinement/composition_approximate_gradient.h.bak
deleted file mode 100644
index 357560ff0e9..00000000000
--- a/include/aspect/mesh_refinement/composition_approximate_gradient.h.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_composition_approximate_gradient_h
-#define _aspect_mesh_refinement_composition_approximate_gradient_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on
-     * the approximated gradient of the compositional fields (if available).
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class CompositionApproximateGradient : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The scaling factors that should be applied to the individual
-         * refinement indicators before merging.
-         */
-        std::vector<double> composition_scaling_factors;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/composition_gradient.h.bak b/include/aspect/mesh_refinement/composition_gradient.h.bak
deleted file mode 100644
index dae9c4daf06..00000000000
--- a/include/aspect/mesh_refinement/composition_gradient.h.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_composition_gradient_h
-#define _aspect_mesh_refinement_composition_gradient_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on the
-     * gradient of the compositional fields (if available).
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class CompositionGradient : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The scaling factors that should be applied to the individual
-         * refinement indicators before merging.
-         */
-        std::vector<double> composition_scaling_factors;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/composition_threshold.h.bak b/include/aspect/mesh_refinement/composition_threshold.h.bak
deleted file mode 100644
index 159112ba6df..00000000000
--- a/include/aspect/mesh_refinement/composition_threshold.h.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_composition_threshold_h
-#define _aspect_mesh_refinement_composition_threshold_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on the
-     * absolute value of the compositional fields. Every cell that contains a
-     * value exceeding a threshold given in the input file is marked for
-     * refinement.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class CompositionThreshold : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * After cells have been marked for coarsening/refinement, apply
-         * additional criteria independent of the error estimate.
-         */
-        void
-        tag_additional_cells () const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The thresholds that should be used for the individual
-         * compositional fields.
-         */
-        std::vector<double> composition_thresholds;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/density.h.bak b/include/aspect/mesh_refinement/density.h.bak
deleted file mode 100644
index 3e326927d1e..00000000000
--- a/include/aspect/mesh_refinement/density.h.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_density_h
-#define _aspect_mesh_refinement_density_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on a field
-     * representing the density $\rho$ as a spatially variable function and
-     * that we compute from the solution vector (assuming the density actually
-     * depends on the solution).
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Density : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/interface.h.bak b/include/aspect/mesh_refinement/interface.h.bak
deleted file mode 100644
index 69b2a480d14..00000000000
--- a/include/aspect/mesh_refinement/interface.h.bak
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_interface_h
-#define _aspect_mesh_refinement_interface_h
-
-#include <aspect/global.h>
-#include <aspect/plugins.h>
-#include <aspect/simulator_access.h>
-
-#include <memory>
-#include <deal.II/base/table_handler.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/distributed/tria.h>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim> class Simulator;
-  template <int dim> class SimulatorAccess;
-
-
-  /**
-   * A namespace for everything to do with the decision on how to refine the
-   * mesh every few time steps.
-   *
-   * @ingroup MeshRefinement
-   */
-  namespace MeshRefinement
-  {
-
-    /**
-     * This class declares the public interface of mesh refinement plugins.
-     * Plugins have two different ways to influence adaptive refinement (and
-     * can make use of either or both):
-     *
-     * First, execute() allows the plugin to specify weights for individual
-     * cells that are then used to coarsen and refine (where larger numbers
-     * indicate a larger error).
-     *
-     * Second, after cells get flagged for coarsening and refinement (using
-     * the first approach), tag_additional_cells() is executed for each
-     * plugin. Here the plugin is free to set or clear coarsen and refine
-     * flags on any cell.
-     *
-     * Access to the data of the simulator is granted by the @p protected
-     * member functions of the SimulatorAccess class, i.e., classes
-     * implementing this interface will in general want to derive from both
-     * this Interface class as well as from the SimulatorAccess class.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion. The default implementation
-         * sets all the error indicators to zero.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        virtual
-        void
-        execute (Vector<float> &error_indicators) const;
-
-        /**
-         * After cells have been marked for coarsening/refinement, apply
-         * additional criteria independent of the error estimate. The default
-         * implementation does nothing.
-         *
-         * This function is also called during the initial global refinement
-         * cycle. At this point you do not have access to solutions,
-         * DoFHandlers, or finite element spaces. You can check if this is the
-         * case by querying this->get_dof_handler().n_dofs() == 0.
-         */
-        virtual
-        void
-        tag_additional_cells () const;
-    };
-
-
-
-
-
-
-    /**
-     * A class that manages all objects that provide functionality to refine
-     * meshes.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Destructor. Made virtual since this class has virtual member
-         * functions.
-         */
-        ~Manager () override;
-
-        /**
-         * Update all of the mesh refinement objects that have been requested
-         * in the input file. Individual mesh refinement objects may choose to
-         * implement an update function to modify object variables once per
-         * time step.
-         */
-        void
-        update () override;
-
-        /**
-         * Execute all of the mesh refinement objects that have been requested
-         * in the input file. The error indicators are then each individually
-         * normalized and merged according to the operation specified in the
-         * input file (e.g., via a plus, a maximum operation, etc).
-         */
-        virtual
-        void
-        execute (Vector<float> &error_indicators) const;
-
-        /**
-         * Apply additional refinement criteria independent of the error
-         * estimate for all of the mesh refinement objects that have been
-         * requested in the input file.
-         */
-        virtual
-        void
-        tag_additional_cells () const;
-
-        /**
-         * Declare the parameters of all known mesh refinement plugins, as
-         * well as of ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which mesh refinement objects will be created; then
-         * let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Go through the list of all mesh refinement strategies that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename MeshRefinementType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,MeshRefinementType>::value>>
-        bool
-        has_matching_mesh_refinement_strategy () const;
-
-        /**
-         * Go through the list of all mesh refinement strategies that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no mesh refinement strategy is active that matches the
-         * given type, throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename MeshRefinementType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,MeshRefinementType>::value>>
-        const MeshRefinementType &
-        get_matching_mesh_refinement_strategy () const;
-
-        /**
-         * A function that is used to register mesh refinement objects in such
-         * a way that the Manager can deal with all of them without having to
-         * know them by name. This allows the files in which individual
-         * plugins are implemented to register these plugins, rather than also
-         * having to modify the Manager class by adding the new mesh
-         * refinement class.
-         *
-         * @param name The name under which this plugin is to be called in
-         * parameter files.
-         * @param description A text description of what this model does and
-         * that will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that
-         * declares the parameters for this plugin.
-         * @param factory_function A pointer to a function that creates such a
-         * mesh refinement object and returns a pointer to it.
-         */
-        static
-        void
-        register_mesh_refinement_criterion (const std::string &name,
-                                            const std::string &description,
-                                            void (*declare_parameters_function) (ParameterHandler &),
-                                            std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcMeshRefinementNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered mesh refinement objects.");
-      private:
-        /**
-         * An enum that describes the different ways in which we can merge the
-         * results of multiple mesh refinement criteria.
-         */
-        enum MergeOperation
-        { plus, max };
-
-        /**
-         * How to merge the results of multiple mesh refinement criteria.
-         */
-        MergeOperation merge_operation;
-
-        /**
-         * Whether to normalize the individual refinement indicators to the
-         * range $[0,1]$ before merging.
-         */
-        bool normalize_criteria;
-
-        /**
-         * The scaling factors that should be applied to the individual
-         * refinement indicators before merging.
-         */
-        std::vector<double> scaling_factors;
-    };
-
-
-
-    template <int dim>
-    template <typename MeshRefinementType, typename>
-    inline
-    bool
-    Manager<dim>::has_matching_mesh_refinement_strategy () const
-    {
-      return this->template has_matching_plugin_object<MeshRefinementType>();
-    }
-
-
-
-    template <int dim>
-    template <typename MeshRefinementType, typename>
-    inline
-    const MeshRefinementType &
-    Manager<dim>::get_matching_mesh_refinement_strategy () const
-    {
-      return this->template get_matching_plugin_object<MeshRefinementType>();
-    }
-
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a mesh refinement object, register it with the
-     * aspect::MeshRefinement::Manager class.
-     *
-     * @ingroup MeshRefinement
-     */
-#define ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_MESH_REFINEMENT_CRITERION_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::MeshRefinement::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::MeshRefinement::Manager<2>::register_mesh_refinement_criterion, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::MeshRefinement::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::MeshRefinement::Manager<3>::register_mesh_refinement_criterion, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/mesh_refinement/isosurfaces.h.bak b/include/aspect/mesh_refinement/isosurfaces.h.bak
deleted file mode 100644
index 452474bb62c..00000000000
--- a/include/aspect/mesh_refinement/isosurfaces.h.bak
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
-  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_mesh_refinement_isosurfaces_h
-#define _aspect_mesh_refinement_isosurfaces_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    namespace internal
-    {
-      enum class PropertyType
-      {
-        Temperature,
-        Composition
-      };
-
-      struct Property
-      {
-        public:
-          /**
-           * Constructor. Converts a property name into a structure containing a property type
-           * and an index. If the property contains multiple items (e.g. the property compositional field has a
-           * field index) the index referring to the particular item of that property is stored in the variable index.
-           * @param property_name The name of a property, which can be Temperature for the temperature field or
-           * the name of a compositional field listed in the parameter available_compositions.
-           * @param available_compositions A list of names of the available compositional fields.
-           */
-          Property(const std::string &property_name,
-                   const std::vector<std::string> &available_compositions);
-
-          /**
-           * The Property type of the property
-           */
-          PropertyType type;
-
-          /**
-           * An index, in case the property type contains multiple values. This is
-           * currently only used for storing which compositional field the property
-           * corresponds to.
-           */
-          unsigned int index;
-      };
-
-      struct Isosurface
-      {
-        public:
-          /**
-           * Checks whether the provided values are between the min and max value for the
-           * set properties of the isosurface. This function assumes that the order of the
-           * provided @p values matches the order in which the properties are stored.
-           *
-           * This function assumes that @p values and all the vectors in isosurfaces already
-           * have the same length.
-           */
-          bool are_all_values_in_range(const std::vector<double> &values) const;
-
-          std::vector<double> min_values;
-          std::vector<double> max_values;
-          int min_refinement;
-          int max_refinement;
-          std::vector<Property> properties;
-      };
-
-    }
-
-    /**
-     * A class that implements an Isosurfaces mesh refinement plugin. This
-     * plugin allows for setting a minimum and a maximum refinement level in
-     * a part of the model domain where a variable/property (e.g. Temperature)
-     * is between two values (e.g. two isotherms of 274K and 1600K). This is
-     * currently implemented for temperature and compositions.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Isosurfaces : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * At the beginning of each time step, update the time for the
-         * ParsedFunction.
-         */
-        void
-        update () override;
-
-        /**
-         * After cells have been marked for coarsening/refinement, apply
-         * additional criteria independent of the error estimate.
-         *
-         */
-        void
-        tag_additional_cells () const override;
-
-        /**
-         * Declare the parameters this class takes from input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-      private:
-        /**
-         * A vector of the isosurfaces used by this class.
-         */
-        std::vector<internal::Isosurface> isosurfaces;
-
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/maximum_refinement_function.h.bak b/include/aspect/mesh_refinement/maximum_refinement_function.h.bak
deleted file mode 100644
index 4728cec3b83..00000000000
--- a/include/aspect/mesh_refinement/maximum_refinement_function.h.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_mesh_refinement_maximum_refinement_function_h
-#define _aspect_mesh_refinement_maximum_refinement_function_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a maximum refinement level based on a
-     * functional description provided in the input file.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class MaximumRefinementFunction : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * At the beginning of each time step, update the time for the
-         * ParsedFunction.
-         */
-        void
-        update () override;
-
-        /**
-         * After cells have been marked for coarsening/refinement, apply
-         * additional criteria independent of the error estimate.
-         *
-         */
-        void
-        tag_additional_cells () const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-
-        /**
-         * A function object representing the maximum refinement level. The
-         * function always depends on 3 variables, although in the case of the
-         * 'depth' coordinate system only the first is used to evaluate the
-         * function.
-         */
-        Functions::ParsedFunction<dim> max_refinement_level;
-
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/minimum_refinement_function.h.bak b/include/aspect/mesh_refinement/minimum_refinement_function.h.bak
deleted file mode 100644
index c7e82d266b2..00000000000
--- a/include/aspect/mesh_refinement/minimum_refinement_function.h.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_mesh_refinement_minimum_refinement_function_h
-#define _aspect_mesh_refinement_minimum_refinement_function_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a minimum refinement level based on a
-     * functional description provided in the input file.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class MinimumRefinementFunction : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * At the beginning of each time step, update the time for the
-         * ParsedFunction.
-         */
-        void
-        update () override;
-
-        /**
-         * After cells have been marked for coarsening/refinement, apply
-         * additional criteria independent of the error estimate.
-         *
-         */
-        void
-        tag_additional_cells () const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The coordinate representation to evaluate the function. Possible
-         * choices are depth, cartesian and spherical.
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-
-        /**
-         * A function object representing the minimum refinement level. The
-         * function always depends on 3 variables, although in the case of the
-         * 'depth' coordinate system only the first is used to evaluate the
-         * function.
-         */
-        Functions::ParsedFunction<dim> min_refinement_level;
-
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/nonadiabatic_temperature.h.bak b/include/aspect/mesh_refinement/nonadiabatic_temperature.h.bak
deleted file mode 100644
index 2e60b9809aa..00000000000
--- a/include/aspect/mesh_refinement/nonadiabatic_temperature.h.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_nonadiabatic_temperature_h
-#define _aspect_mesh_refinement_nonadiabatic_temperature_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on the excess
-     * temperature (difference between temperature and adiabatic temperature).
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class NonadiabaticTemperature : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/nonadiabatic_temperature_threshold.h.bak b/include/aspect/mesh_refinement/nonadiabatic_temperature_threshold.h.bak
deleted file mode 100644
index fcdf35846bc..00000000000
--- a/include/aspect/mesh_refinement/nonadiabatic_temperature_threshold.h.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_nonadiabatic_temperature_threshold_h
-#define _aspect_mesh_refinement_nonadiabatic_temperature_threshold_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on the
-     * nonadiabatic temperature. Every cell that contains a value
-     * exceeding a threshold given in the input file is marked for
-     * refinement.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class NonadiabaticTemperatureThreshold : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * After cells have been marked for coarsening/refinement, apply
-         * additional criteria independent of the error estimate.
-         */
-        void
-        tag_additional_cells () const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The thresholds that should be used for the nonadiabatic
-         * temperature.
-         */
-        double threshold;
-
-        /**
-         * What type of temperature anomaly should be considered when
-         * evaluating against the threshold: Only negative anomalies
-         * (subadiabatic temperatures), only positive anomalies
-         * (superadiabatic temperatures) or the absolute value of the
-         * nonadiabatic temperature.
-         */
-        enum anomaly
-        {
-          negative_only,
-          positive_only,
-          absolute_value
-        } temperature_anomaly_type;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/particle_density.h.bak b/include/aspect/mesh_refinement/particle_density.h.bak
deleted file mode 100644
index 8c8b6ab39f9..00000000000
--- a/include/aspect/mesh_refinement/particle_density.h.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_particle_density_h
-#define _aspect_mesh_refinement_particle_density_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A mesh refinement criterion that computes
-     * refinement indicators based on the density
-     * of particles. In practice this plugin
-     * equilibrates the number of particles per cell,
-     * leading to fine cells in high particle density regions
-     * and coarse cells in low particle density regions.
-     * This plugin is mostly useful for models with inhomogeneous
-     * particle density, e.g. when tracking an initial interface
-     * with a high particle density, or when the spatial particle
-     * density denotes the region of interest. Additionally, this
-     * plugin tends to balance the computational load between
-     * processes in parallel computations, because the particle
-     * and mesh density is more aligned.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class ParticleDensity : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/slope.h.bak b/include/aspect/mesh_refinement/slope.h.bak
deleted file mode 100644
index bdc7cce5690..00000000000
--- a/include/aspect/mesh_refinement/slope.h.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_slope_h
-#define _aspect_mesh_refinement_slope_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion that refines the
-     * mesh with a deforming surface.  Specifically, it calculates the slope of the
-     * surface by comparing the local normal and gravity vectors.
-     * Cells with steeper slopes get refined. This is useful for cases where
-     * there is steep topography which needs to be tracked better.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Slope : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/strain_rate.h.bak b/include/aspect/mesh_refinement/strain_rate.h.bak
deleted file mode 100644
index 0ae2a83c6b9..00000000000
--- a/include/aspect/mesh_refinement/strain_rate.h.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_strain_rate_h
-#define _aspect_mesh_refinement_strain_rate_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on
-     * the strain rate field.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class StrainRate : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/temperature.h.bak b/include/aspect/mesh_refinement/temperature.h.bak
deleted file mode 100644
index 33b7edb1e05..00000000000
--- a/include/aspect/mesh_refinement/temperature.h.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_temperature_h
-#define _aspect_mesh_refinement_temperature_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on the
-     * temperature field.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Temperature : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/thermal_energy_density.h.bak b/include/aspect/mesh_refinement/thermal_energy_density.h.bak
deleted file mode 100644
index 98c7fc9c10c..00000000000
--- a/include/aspect/mesh_refinement/thermal_energy_density.h.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_thermal_energy_density_h
-#define _aspect_mesh_refinement_thermal_energy_density_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on a field
-     * representing the energy density $\rho c_P T$ as a spatially variable
-     * function and that we compute from the solution vector.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class ThermalEnergyDensity : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/topography.h.bak b/include/aspect/mesh_refinement/topography.h.bak
deleted file mode 100644
index b5ec954826f..00000000000
--- a/include/aspect/mesh_refinement/topography.h.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_topography_h
-#define _aspect_mesh_refinement_topography_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion that refines the
-     * mesh in the uppermost nodes. This is useful for cases where one wants
-     * to accurately model processes at of close to the surface of the model.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Topography : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/velocity.h.bak b/include/aspect/mesh_refinement/velocity.h.bak
deleted file mode 100644
index 4e4b3dc73ed..00000000000
--- a/include/aspect/mesh_refinement/velocity.h.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_velocity_h
-#define _aspect_mesh_refinement_velocity_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on the
-     * velocity field.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Velocity : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/viscosity.h.bak b/include/aspect/mesh_refinement/viscosity.h.bak
deleted file mode 100644
index cf30f892b15..00000000000
--- a/include/aspect/mesh_refinement/viscosity.h.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-  Copyright (C) 2013 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_viscosity_h
-#define _aspect_mesh_refinement_viscosity_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion based on a field
-     * representing the viscosity $\eta$ as a spatially variable function and
-     * that we compute from the solution vector (assuming the viscosity
-     * actually depends on the solution).
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class Viscosity : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute this mesh refinement criterion.
-         *
-         * @param[out] error_indicators A vector that for every active cell of
-         * the current mesh (which may be a partition of a distributed mesh)
-         * provides an error indicator. This vector will already have the
-         * correct size when the function is called.
-         */
-        void
-        execute (Vector<float> &error_indicators) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/mesh_refinement/volume_of_fluid_interface.h.bak b/include/aspect/mesh_refinement/volume_of_fluid_interface.h.bak
deleted file mode 100644
index 1e906fc517b..00000000000
--- a/include/aspect/mesh_refinement/volume_of_fluid_interface.h.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019-2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_mesh_refinement_volume_of_fluid_interface_h
-#define _aspect_mesh_refinement_volume_of_fluid_interface_h
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    /**
-     * A class that implements a mesh refinement criterion that refines the
-     * mesh near boundaries for the volume of fluid interface tracking algorithm.
-     *
-     * @ingroup MeshRefinement
-     */
-    template <int dim>
-    class VolumeOfFluidInterface: public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Mark large unrefined neighboring cells for refinement and prevent
-         * coarsening
-         */
-        void
-        tag_additional_cells() const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * If true, flag cells for coarsening if they are not flagged for refinement
-         */
-        bool strict_coarsening;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/newton.h.bak b/include/aspect/newton.h.bak
deleted file mode 100644
index f7e4fc70c46..00000000000
--- a/include/aspect/newton.h.bak
+++ /dev/null
@@ -1,358 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _aspect_newton_h
-#define _aspect_newton_h
-
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace MaterialModel
-  {
-    /**
-     * This class holds the derivatives for the Newton solver.
-     */
-    template <int dim>
-    class MaterialModelDerivatives : public AdditionalMaterialOutputs<dim>
-    {
-      public:
-        /**
-         * Constructor. Initialize the various arrays of this structure with the
-         * given number of quadrature points.
-         */
-        MaterialModelDerivatives (const unsigned int n_points);
-
-        /**
-         * The derivatives of the viscosities with respect to pressure.
-         */
-        std::vector<double> viscosity_derivative_wrt_pressure;
-
-        /**
-         * The derivatives of the viscosities with respect to strain rate.
-         */
-        std::vector<SymmetricTensor<2,dim>> viscosity_derivative_wrt_strain_rate;
-
-        /**
-         * The weights used for calculating the averages of viscosity
-         * derivatives when material averaging is applied.
-         */
-        std::vector<double> viscosity_derivative_averaging_weights;
-    };
-  }
-
-
-  namespace Newton
-  {
-    struct Parameters
-    {
-
-      /**
-       * This enum describes the type of stabilization is used
-       * for the Newton solver. None represents no stabilization,
-       * SPD represent that the resulting matrix is made Symmetric
-       * Positive Definite, symmetric represents that the matrix is
-       * only symmetrized, and PD represents that we do the same as
-       * what we do for SPD, but without the symmetrization.
-       */
-      enum Stabilization
-      {
-        none = 0,
-        symmetric = 1,
-        PD = 2,
-        SPD = symmetric | PD
-      };
-
-
-      /**
-       * A binary 'or' operator that concatenates a set of stabilization
-       * flags by returning an object that combines the bits set in each
-       * of the two arguments.
-       */
-      friend
-      Stabilization
-      operator| (const Stabilization a,
-                 const Stabilization b)
-      {
-        return static_cast<Stabilization>(
-                 static_cast<int>(a) | static_cast<int>(b));
-      }
-
-
-      /**
-       * A binary 'and' operator that takes the intersection of two sets
-       * of stabilization flags by returning an object that selects those bits
-       * that are set in both of the two arguments.
-       */
-      friend
-      Stabilization
-      operator& (const Stabilization a,
-                 const Stabilization b)
-      {
-        return static_cast<Stabilization>(
-                 static_cast<int>(a) & static_cast<int>(b));
-      }
-
-
-      /**
-       * Declare additional parameters that are needed for the Newton.
-       * solver.
-       */
-      static void declare_parameters (ParameterHandler &prm);
-
-      /**
-       * Parse additional parameters that are needed for the Newton.
-       * solver.
-       */
-      void parse_parameters (ParameterHandler &prm);
-
-      /**
-       * A scaling factor used for scaling the
-       * derivative part of the Newton Stokes solver in the assembly.
-       *
-       * The exact Newton matrix consists of the Stokes matrix plus a term
-       * that results from the linearization of the material coefficients.
-       * The scaling factor multiplies these additional terms. In a full
-       * Newton method, it would be equal to one, but it can be chosen
-       * smaller in cases where the resulting linear system has undesirable
-       * properties.
-       *
-       * If the scaling factor is zero, the resulting matrix is simply the
-       * Stokes matrix, and the resulting scheme is a defect correction
-       * (i.e., Picard iteration).
-       */
-      double              newton_derivative_scaling_factor;
-
-      Stabilization       preconditioner_stabilization;
-      Stabilization       velocity_block_stabilization;
-
-      /**
-       * Whether to use the Newton failsafe or not. If the failsafe is used, a failure
-       * of the linear solver is caught and we try to solve it again with both the
-       * preconditioner and the velocity block being stabilized with the SPD stabilization.
-       */
-      bool                use_Newton_failsafe;
-
-      /**
-       * The nonlinear tolerance at which to switch the
-       * nonlinear solver from defect correction Picard to
-       * Newton.
-       */
-      double              nonlinear_switch_tolerance;
-
-      bool                use_Eisenstat_Walker_method_for_Picard_iterations;
-      unsigned int        max_pre_newton_nonlinear_iterations;
-      unsigned int        max_newton_line_search_iterations;
-      bool                use_newton_residual_scaling_method;
-      double              maximum_linear_stokes_solver_tolerance;
-      double              SPD_safety_factor;
-    };
-
-
-    /**
-     * Get a std::string describing the stabilization type used for the
-     * preconditioner.
-     */
-    std::string
-    to_string(const Newton::Parameters::Stabilization preconditioner_stabilization);
-  }
-
-
-
-  /**
-   * A class that supports the functionality of the Newton solver.
-   */
-  template <int dim>
-  class NewtonHandler : public SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Determine, based on the run-time parameters of the current simulation,
-       * which functions need to be called in order to assemble linear systems,
-       * matrices, and right hand side vectors.
-       */
-      void set_assemblers (Assemblers::Manager<dim> &assemblers) const;
-
-      /**
-       * Create an additional material model output object that contains
-       * the additional output variables (the derivatives) needed for the
-       * Newton solver.
-       */
-      static void create_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output);
-
-      /**
-       * The object that stores the run-time parameters that control the Newton
-       * method.
-       */
-      Newton::Parameters parameters;
-  };
-
-
-  namespace Assemblers
-  {
-    /**
-     * A base class for the definition of assemblers that implement the linear
-     * system terms for the NewtonStokes solver scheme.
-     */
-    template <int dim>
-    class NewtonInterface : public aspect::Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Attach Newton outputs. Since most Newton assemblers require the
-         * material model derivatives they are created in this base class
-         * already.
-         */
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-    };
-
-    /**
-     * This class assembles the terms of the Newton Stokes preconditioner matrix for the current cell.
-     */
-    template <int dim>
-    class NewtonStokesPreconditioner : public NewtonInterface<dim>
-    {
-      public:
-        void
-        execute (internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                 internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-
-        /**
-         * Create additional material models outputs for computing viscoelastic strain rate when
-         * elasticity is enabled.
-         */
-        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-    };
-
-    /**
-     * This class assembles the terms for the matrix and right-hand-side of the incompressible
-     * Newton Stokes system for the current cell.
-     */
-    template <int dim>
-    class NewtonStokesIncompressibleTerms : public NewtonInterface<dim>
-    {
-      public:
-        void
-        execute (internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                 internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-
-        /**
-         * Create additional material models outputs for assembly of derivatives or adding additional
-         * terms to the right hand side of the Stokes equations. The latter could include viscoelastic
-         * forces or other user-defined values calculated within the material model.
-         */
-        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-    };
-
-    /**
-     * This class assembles the term that arises in the viscosity term of the Newton Stokes matrix for
-     * compressible models, because the divergence of the velocity is not longer zero.
-     */
-    template <int dim>
-    class NewtonStokesCompressibleStrainRateViscosityTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the right-hand-side term of the Newton Stokes system
-     * that is caused by the compressibility in the mass conservation equation.
-     * This function approximates this term as
-     * $- \nabla \mathbf{u} = \frac{1}{\rho} \frac{\partial rho}{\partial z} \frac{\mathbf{g}}{||\mathbf{g}||} \cdot \mathbf{u}$
-     */
-    template <int dim>
-    class NewtonStokesReferenceDensityCompressibilityTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the compressibility term of the Newton Stokes system
-     * that is caused by the compressibility in the mass conservation equation.
-     * It includes this term implicitly in the matrix,
-     * which is therefore not longer symmetric.
-     * This function approximates this term as
-     * $ - \nabla \mathbf{u} - \frac{1}{\rho} \frac{\partial rho}{\partial z} \frac{\mathbf{g}}{||\mathbf{g}||} \cdot \mathbf{u} = 0$
-     */
-    template <int dim>
-    class NewtonStokesImplicitReferenceDensityCompressibilityTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the right-hand-side term of the Newton Stokes system
-     * that is caused by the compressibility in the mass conservation equation.
-     * This function approximates this term as
-     * $ - \nabla \mathbf{u} = \frac{1}{\rho} \frac{\partial rho}{\partial p} \rho \mathbf{g} \cdot \mathbf{u}$
-     */
-    template <int dim>
-    class NewtonStokesIsentropicCompressionTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the right-hand-side term of the Stokes equation
-     * that is caused by the variable density in the mass conservation equation.
-     * This class approximates this term as
-     * $ - \nabla \cdot \mathbf{u} = \frac{1}{\rho} \frac{\partial \rho}{\partial t} + \frac{1}{\rho} \nabla \rho \cdot \mathbf{u}$
-     * where the right-hand side velocity is explicitly taken from the last timestep,
-     * and the density is taken from a compositional field of the type 'density'.
-     */
-    template <int dim>
-    class NewtonStokesProjectedDensityFieldTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/parameters.h.bak b/include/aspect/parameters.h.bak
deleted file mode 100644
index 4890ac4c987..00000000000
--- a/include/aspect/parameters.h.bak
+++ /dev/null
@@ -1,802 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_parameters_h
-#define _aspect_parameters_h
-
-#include <deal.II/base/parameter_handler.h>
-
-#include <aspect/global.h>
-#include <aspect/material_model/interface.h>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  struct CompositionalFieldDescription;
-
-  // forward declaration:
-  namespace GeometryModel
-  {
-    template <int dim>
-    class Interface;
-  }
-
-  /**
-   * A structure that holds run-time parameters. These parameters are all
-   * declared for the ParameterHandler class in the declare_parameters()
-   * member function, and read in the parse_parameters() function.
-   *
-   * Each of the member variables of this class corresponds to a parameter
-   * declared for the ParameterHandler class. Rather than duplicating the
-   * documentation of each of these parameters for the member variables here,
-   * please refer to the documentation of run-time parameters in the ASPECT
-   * manual for more information.
-   *
-   * @ingroup Simulator
-   */
-  template <int dim>
-  struct Parameters
-  {
-
-    /**
-     * A structure that contains enum values that identify the nonlinear
-     * solver in use.
-     */
-    struct NonlinearSolver
-    {
-      enum Kind
-      {
-        single_Advection_single_Stokes,
-        iterated_Advection_and_Stokes,
-        single_Advection_iterated_Stokes,
-        no_Advection_iterated_Stokes,
-        no_Advection_single_Stokes,
-        no_Advection_iterated_defect_correction_Stokes,
-        single_Advection_iterated_defect_correction_Stokes,
-        iterated_Advection_and_defect_correction_Stokes,
-        iterated_Advection_and_Newton_Stokes,
-        single_Advection_iterated_Newton_Stokes,
-        single_Advection_no_Stokes,
-        first_timestep_only_single_Stokes,
-        no_Advection_no_Stokes
-      };
-    };
-
-    static
-    bool
-    is_defect_correction(const typename NonlinearSolver::Kind &input)
-    {
-      return input == NonlinearSolver::iterated_Advection_and_Newton_Stokes ||
-             input == NonlinearSolver::single_Advection_iterated_Newton_Stokes ||
-             input == NonlinearSolver::no_Advection_iterated_defect_correction_Stokes ||
-             input == NonlinearSolver::single_Advection_iterated_defect_correction_Stokes ||
-             input == NonlinearSolver::iterated_Advection_and_defect_correction_Stokes
-             ?
-             true
-             :
-             false;
-    }
-
-    /**
-     * @brief The NullspaceRemoval struct
-     */
-    struct NullspaceRemoval
-    {
-      enum Kind
-      {
-        none = 0,
-        net_translation_x = 0x1,
-        net_translation_y = 0x2,
-        net_translation_z = 0x4,
-        net_translation   = 0x1+0x2+0x4,
-        linear_momentum_x = 0x8,
-        linear_momentum_y = 0x10,
-        linear_momentum_z = 0x20,
-        linear_momentum   = linear_momentum_x+linear_momentum_y+linear_momentum_z,
-        net_rotation      = 0x40,
-        angular_momentum  = 0x80,
-        net_surface_rotation = 0x100,
-        any_translation = net_translation+linear_momentum,
-        any_rotation = net_rotation+angular_momentum+net_surface_rotation,
-      };
-    };
-
-    /**
-     * A struct that describes the available methods to solve
-     * advected fields. This type is at the moment only used to determine how
-     * to advect each compositional field -- or what else to do with it if
-     * it doesn't satisfy an advection equation, for example if the
-     * compositional field just contains data interpolated from
-     * particles in each time step (`particles`) or if it contains
-     * data interpolated from other sources such as material outputs
-     * (`prescribed_field`), neither of which is further advected.
-     */
-    struct AdvectionFieldMethod
-    {
-      enum Kind
-      {
-        fem_field,
-        particles,
-        volume_of_fluid,
-        static_field,
-        fem_melt_field,
-        fem_darcy_field,
-        prescribed_field,
-        prescribed_field_with_diffusion
-      };
-    };
-
-    /**
-     * A struct that contains information about which
-     * formulation of the basic equations should be solved,
-     * i.e. which terms to consider, which terms to neglect, and
-     * which to simplify in different ways.
-     */
-    struct Formulation
-    {
-      /**
-       * This enum lists available formulations that
-       * determine the combined approximations made in
-       * all solved equations. 'Custom' allows to set
-       * approximations individually for single equations.
-       */
-      enum Kind
-      {
-        boussinesq_approximation,
-        anelastic_liquid_approximation,
-        isentropic_compression,
-        custom
-      };
-
-      /**
-       * This function translates an input string into the
-       * available enum options.
-       */
-      static
-      Kind
-      parse(const std::string &input)
-      {
-        if (input == "isentropic compression")
-          return Formulation::isentropic_compression;
-        else if (input == "anelastic liquid approximation")
-          return Formulation::anelastic_liquid_approximation;
-        else if (input == "Boussinesq approximation")
-          return Formulation::boussinesq_approximation;
-        else if (input == "custom")
-          return Formulation::custom;
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        return Formulation::Kind();
-      }
-
-      /**
-       * This struct contains information about the approximation
-       * made to the term containing the gradient of the density
-       * in the mass conservation equation. The different possible
-       * ways to approximate this term are described in the manual.
-       */
-      struct MassConservation
-      {
-        /**
-         * This enum lists available approximations to the
-         * density gradient term of the mass conservation equation.
-         */
-        enum Kind
-        {
-          isentropic_compression,
-          hydrostatic_compression,
-          reference_density_profile,
-          implicit_reference_density_profile,
-          incompressible,
-          projected_density_field,
-          ask_material_model
-        };
-
-        /**
-         * This function translates an input string into the
-         * available enum options.
-         */
-        static Kind
-        parse(const std::string &input)
-        {
-          if (input == "isentropic compression")
-            return Formulation::MassConservation::isentropic_compression;
-          else if (input == "hydrostatic compression")
-            return Formulation::MassConservation::hydrostatic_compression;
-          else if (input == "reference density profile")
-            return Formulation::MassConservation::reference_density_profile;
-          else if (input == "implicit reference density profile")
-            return Formulation::MassConservation::implicit_reference_density_profile;
-          else if (input == "incompressible")
-            return Formulation::MassConservation::incompressible;
-          else if (input == "projected density field")
-            return Formulation::MassConservation::projected_density_field;
-          else if (input == "ask material model")
-            return Formulation::MassConservation::ask_material_model;
-          else
-            AssertThrow(false, ExcNotImplemented());
-
-          return Formulation::MassConservation::Kind();
-        }
-      };
-
-      /**
-       * This struct contains information about the approximation
-       * made to temperature equation. The different possible
-       * ways to approximate this term are described in the manual.
-       */
-      struct TemperatureEquation
-      {
-        /**
-         * This enum lists available approximations to the
-         * density in the temperature equation.
-         */
-        enum Kind
-        {
-          real_density,
-          reference_density_profile
-        };
-
-        /**
-         * This function translates an input string into the
-         * available enum options.
-         */
-        static
-        Kind
-        parse(const std::string &input)
-        {
-          if (input == "real density")
-            return Formulation::TemperatureEquation::real_density;
-          else if (input == "reference density profile")
-            return Formulation::TemperatureEquation::reference_density_profile;
-          else
-            AssertThrow(false, ExcNotImplemented());
-
-          return Formulation::TemperatureEquation::Kind();
-        }
-      };
-    };
-
-    /**
-     * A struct to provide the setting for "Stabilization method"
-     */
-    struct AdvectionStabilizationMethod
-    {
-      enum Kind
-      {
-        entropy_viscosity,
-        supg
-      };
-
-      /**
-       * This function translates an input string into the
-       * available enum options.
-       */
-      static
-      Kind
-      parse(const std::string &input)
-      {
-        if (input == "entropy viscosity")
-          return entropy_viscosity;
-        else if (input == "SUPG")
-          return supg;
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        return Kind();
-      }
-
-      static std::string get_options_string()
-      {
-        return "entropy viscosity|SUPG";
-      }
-    };
-
-    /**
-     * A struct to provide the different choices of limiters for
-     * the discontinuous Galerkin method.
-     */
-    struct DGLimiterType
-    {
-      enum Kind
-      {
-        bound_preserving,
-        WENO,
-        none
-      };
-
-      static
-      Kind
-      parse(const std::string &input)
-      {
-        if (input == "bound preserving")
-          return bound_preserving;
-        else if (input == "WENO")
-          return WENO;
-        else if (input == "none")
-          return none;
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        return Kind();
-      }
-
-      static const std::string pattern()
-      {
-        return "bound preserving|WENO|none";
-      }
-    };
-
-    /**
-     * This enum represents the different choices for the linear solver
-     * for the Stoke system. See @p stokes_solver_type.
-     */
-    struct StokesSolverType
-    {
-      enum Kind
-      {
-        block_amg,
-        direct_solver,
-        block_gmg,
-        default_solver
-      };
-
-      static const std::string pattern()
-      {
-        return "default solver|block AMG|direct solver|block GMG";
-      }
-
-      static Kind
-      parse(const std::string &input)
-      {
-        if (input == "block AMG")
-          return block_amg;
-        else if (input == "direct solver")
-          return direct_solver;
-        else if (input == "block GMG")
-          return block_gmg;
-        else if (input == "default solver")
-          return default_solver;
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        return Kind();
-      }
-    };
-
-    /**
-     * This enum represents the different choices for the Krylov method
-     * used in the cheap GMG Stokes solve.
-     */
-    struct StokesKrylovType
-    {
-      enum Kind
-      {
-        gmres,
-        idr_s
-      };
-
-      static const std::string pattern()
-      {
-        return "GMRES|IDR(s)";
-      }
-
-      static Kind
-      parse(const std::string &input)
-      {
-        if (input == "GMRES")
-          return gmres;
-        else if (input == "IDR(s)")
-          return idr_s;
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        return Kind();
-      }
-    };
-
-    /**
-     * This enum represents the different choices for the reaction solver.
-     * See @p reaction_solver_type.
-     */
-    struct ReactionSolverType
-    {
-      enum Kind
-      {
-        ARKode,
-        fixed_step
-      };
-
-      static const std::string pattern()
-      {
-        return "ARKode|fixed step";
-      }
-
-      static Kind
-      parse(const std::string &input)
-      {
-        if (input == "ARKode")
-          return ARKode;
-        else if (input == "fixed step")
-          return fixed_step;
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        return Kind();
-      }
-    };
-
-    /**
-     * Use the struct aspect::CompositionalFieldDescription
-     */
-    using CompositionalFieldDescription DEAL_II_DEPRECATED = aspect::CompositionalFieldDescription;
-
-    /**
-     * Constructor. Fills the values of member functions from the given
-     * parameter object.
-     *
-     * @param prm The parameter object that has previously been filled with
-     * content by reading an input file.
-     *
-     * @param mpi_communicator The MPI communicator we will use for this
-     * simulation. We need this when calling parse_parameters() so that we can
-     * verify some of the input arguments.
-     */
-    Parameters (ParameterHandler &prm,
-                const MPI_Comm mpi_communicator);
-
-    /**
-     * Declare the run-time parameters this class takes, and call the
-     * respective <code>declare_parameters</code> functions of the namespaces
-     * that describe geometries, material models, etc.
-     *
-     * @param prm The object in which the run-time parameters are to be
-     * declared.
-     */
-    static
-    void declare_parameters (ParameterHandler &prm);
-
-    /**
-     * Read run-time parameters from an object that has previously parsed an
-     * input file. This reads all parameters that do not require knowledge of
-     * the geometry model we use. There is a separate function
-     * parse_geometry_dependent_parameters() that is called as soon as the
-     * geometry object has been created and that can translate between the
-     * symbolic names for boundary components that the geometry model
-     * publishes and the boundary indicators used internally.
-     *
-     * @param prm The object from which to obtain the run-time parameters.
-     *
-     * @param mpi_communicator The MPI communicator we will use for this
-     * simulation. We need this when calling parse_parameters() so that we can
-     * verify some of the input arguments.
-     */
-    void parse_parameters (ParameterHandler &prm,
-                           const MPI_Comm mpi_communicator);
-
-    /**
-     * Read those run-time parameters from a ParameterHandler object that
-     * depend on knowing which geometry object we use. This function
-     * complements parse_parameters() but is only called once the geometry
-     * object has been created. This function is separate because we allow the
-     * use of symbolic names in defining which boundary components have which
-     * boundary conditions, and the names one can specify there are not
-     * available until after the geometry object has been created.
-     *
-     * This function is called from the GeometryModel::create_geometry()
-     * function.
-     *
-     * @param prm The object from which to obtain the run-time parameters.
-     * @param geometry_model The geometry model that provides boundary names
-     * etc.
-     */
-    void parse_geometry_dependent_parameters (ParameterHandler &prm,
-                                              const GeometryModel::Interface<dim> &geometry_model);
-
-    /**
-     * @name Global parameters
-     * @{
-     */
-    typename NonlinearSolver::Kind nonlinear_solver;
-
-    typename AdvectionStabilizationMethod::Kind advection_stabilization_method;
-    double                         nonlinear_tolerance;
-    bool                           resume_computation;
-    double                         start_time;
-    double                         end_time;
-    double                         CFL_number;
-    double                         maximum_time_step;
-    double                         maximum_relative_increase_time_step;
-    double                         maximum_first_time_step;
-    bool                           use_artificial_viscosity_smoothing;
-    bool                           use_conduction_timestep;
-    bool                           convert_to_years;
-    std::string                    output_directory;
-    double                         surface_pressure;
-    double                         adiabatic_surface_temperature;
-    unsigned int                   timing_output_frequency;
-    unsigned int                   max_nonlinear_iterations;
-    unsigned int                   max_nonlinear_iterations_in_prerefinement;
-    bool                           use_operator_splitting;
-    std::string                    world_builder_file;
-
-    /**
-     * @}
-     */
-
-    /**
-     * @name section: Solver parameters
-     * @{
-     */
-    double                         temperature_solver_tolerance;
-    double                         composition_solver_tolerance;
-
-    // subsection: Advection solver parameters
-    unsigned int                   advection_gmres_restart_length;
-
-    // subsection: Stokes solver parameters
-    bool                           use_direct_stokes_solver;
-    bool                           use_bfbt;
-    typename StokesSolverType::Kind stokes_solver_type;
-    typename StokesKrylovType::Kind stokes_krylov_type;
-    unsigned int                    idr_s_parameter;
-
-    double                         linear_stokes_solver_tolerance;
-    unsigned int                   n_cheap_stokes_solver_steps;
-    unsigned int                   n_expensive_stokes_solver_steps;
-    double                         linear_solver_A_block_tolerance;
-    bool                           use_full_A_block_preconditioner;
-    bool                           force_nonsymmetric_A_block_solver;
-    double                         linear_solver_S_block_tolerance;
-    unsigned int                   stokes_gmres_restart_length;
-
-    // subsection: AMG parameters
-    std::string                    AMG_smoother_type;
-    unsigned int                   AMG_smoother_sweeps;
-    double                         AMG_aggregation_threshold;
-    bool                           AMG_output_details;
-
-    // subsection: Operator splitting parameters
-    typename ReactionSolverType::Kind reaction_solver_type;
-    double                         ARKode_relative_tolerance;
-    double                         reaction_time_step;
-    unsigned int                   reaction_steps_per_advection_step;
-
-    // subsection: Diffusion solver parameters
-    double                         diffusion_length_scale;
-
-    /**
-     * @}
-     */
-
-    /**
-     * @name Formulation settings
-     * @{
-     */
-
-    /**
-     * This variable determines which of the several ways to formulate the
-     * equations ASPECT will solve.
-     * Common formulations are the Boussinesq or Anelastic Liquid
-     * Approximations (BA, ALA). ASPECT's original formulation is termed
-     * 'isentropic compression'. 'Custom' allows
-     * to set the approximations individually per equation.
-     */
-    typename Formulation::Kind formulation;
-
-    /**
-     * Determines how to formulate the mass conservation equation in ASPECT.
-     * Common approximations are 'incompressible' or 'reference density profile'.
-     * ASPECT's original formulation is termed 'isentropic compression'. See the
-     * manual for more details about the individual terms.
-     */
-    typename Formulation::MassConservation::Kind formulation_mass_conservation;
-
-    /**
-     * Determines how to formulate the density in the temperature equation
-     * in ASPECT. Possible approximations are 'reference density profile' or
-     * 'real density'.
-     */
-    typename Formulation::TemperatureEquation::Kind formulation_temperature_equation;
-
-    /**
-     * This variable determines whether additional terms related to elastic forces
-     * are added to the Stokes equation.
-     */
-    bool                           enable_elasticity;
-
-    /**
-     * @}
-     */
-
-    /**
-     * @name Parameters that have to do with terms in the model
-     * @{
-     */
-    bool                           include_melt_transport;
-    bool                           enable_additional_stokes_rhs;
-    bool                           enable_prescribed_dilation;
-
-    /**
-     * Map from boundary id to a pair "components", "traction boundary type",
-     * where components is of the format "[x][y][z]" and the traction type is
-     * mapped to one of the plugins of traction boundary conditions (e.g.
-     * "function")
-     */
-    std::map<types::boundary_id, std::pair<std::string,std::string>> prescribed_traction_boundary_indicators;
-
-    /**
-     * A set of boundary ids on which the boundary_heat_flux objects
-     * will be applied.
-     */
-    std::set<types::boundary_id> fixed_heat_flux_boundary_indicators;
-
-    /**
-     * Selection of operations to perform to remove nullspace from velocity
-     * field.
-     */
-    typename NullspaceRemoval::Kind nullspace_removal;
-    /**
-     * @}
-     */
-
-    /**
-     * @name Parameters that have to do with mesh refinement
-     * @{
-     */
-    unsigned int                   initial_global_refinement;
-    unsigned int                   initial_adaptive_refinement;
-    double                         refinement_fraction;
-    double                         coarsening_fraction;
-    bool                           adapt_by_fraction_of_cells;
-    unsigned int                   min_grid_level;
-    std::vector<double>            additional_refinement_times;
-    unsigned int                   adaptive_refinement_interval;
-    bool                           skip_solvers_on_initial_refinement;
-    bool                           skip_setup_initial_conditions_on_initial_refinement;
-    bool                           run_postprocessors_on_initial_refinement;
-    bool                           run_postprocessors_on_nonlinear_iterations;
-    /**
-     * @}
-     */
-
-    /**
-     * @name Parameters that have to do with the stabilization of transport
-     * equations
-     * @{
-     */
-    unsigned int                   stabilization_alpha;
-    std::vector<double>            stabilization_c_R;
-    std::vector<double>            stabilization_beta;
-    double                         stabilization_gamma;
-    double                         discontinuous_penalty;
-    typename DGLimiterType::Kind   limiter_for_discontinuous_temperature_solution;
-    std::vector<typename DGLimiterType::Kind> limiter_for_discontinuous_composition_solution;
-    double                         global_temperature_max_preset;
-    double                         global_temperature_min_preset;
-    std::vector<double>            global_composition_max_preset;
-    std::vector<double>            global_composition_min_preset;
-    double                         temperature_KXRCF_indicator_threshold;
-    std::vector<double>            composition_KXRCF_indicator_threshold;
-    double                         WENO_linear_weight;
-
-    std::vector<std::string>       compositional_fields_with_disabled_boundary_entropy_viscosity;
-    /**
-     * @}
-     */
-
-    /**
-     * @name Parameters that have to do with checkpointing
-     * @{
-     */
-    int                            checkpoint_time_secs;
-    int                            checkpoint_steps;
-    /**
-     * @}
-     */
-
-    /**
-     * @name Parameters that have to do with spatial discretizations
-     * @{
-     */
-    unsigned int                   stokes_velocity_degree;
-    bool                           use_locally_conservative_discretization;
-    bool                           use_equal_order_interpolation_for_stokes;
-    bool                           use_discontinuous_temperature_discretization;
-    std::vector<bool>              use_discontinuous_composition_discretization;
-    bool                           have_discontinuous_composition_discretization;
-    unsigned int                   temperature_degree;
-    unsigned int                   composition_degree;
-    std::string                    pressure_normalization;
-    MaterialModel::MaterialAveraging::AveragingOperation material_averaging;
-
-    /**
-     * @}
-     */
-
-    /**
-     * @name Parameters that have to do with the temperature field
-     * @{
-     */
-
-    typename AdvectionFieldMethod::Kind temperature_method;
-
-    /**
-     * @}
-     */
-
-    /**
-     * @name Parameters that have to do with compositional fields
-     * @{
-     */
-    unsigned int                   n_compositional_fields;
-    std::vector<std::string>       names_of_compositional_fields;
-    std::vector<aspect::CompositionalFieldDescription>  composition_descriptions;
-    unsigned int                   n_chemical_compositions;
-    std::vector<unsigned int>      chemical_composition_indices;
-
-    /**
-     * A vector that contains the advection field method for every compositional
-     * field. Consequently the vector has n_compositional_fields entries.
-     */
-    std::vector<typename AdvectionFieldMethod::Kind> compositional_field_methods;
-
-    /**
-     * Map from compositional index to a pair "particle property", "component",
-     * where particle property is a string that can be mapped to one of the
-     * particle property plugins.
-     * Component denotes which component of the particle property is to be
-     * mapped in case there are several. Therefore, it is optional to specify
-     * the component and it is of the format "[0][1][2]". In case no component
-     * is specified it defaults to 0.
-     */
-    std::map<unsigned int, std::pair<std::string,unsigned int>> mapped_particle_properties;
-
-    std::vector<unsigned int>      normalized_fields;
-    /**
-     * @}
-     */
-    /**
-     * @name Parameters that have to do with mesh deformation
-     * @{
-     */
-    bool                           mesh_deformation_enabled;
-    /**
-     * @}
-     */
-
-    /**
-     * @name Parameters that have to do with volume of fluid calculations
-     * @{
-     */
-    bool                           volume_of_fluid_tracking_enabled;
-    /**
-     * @}
-     */
-
-
-  };
-
-}
-#endif
diff --git a/include/aspect/particle/generator/ascii_file.h.bak b/include/aspect/particle/generator/ascii_file.h.bak
deleted file mode 100644
index 035ef0a7d24..00000000000
--- a/include/aspect/particle/generator/ascii_file.h.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_generator_ascii_file_h
-#define _aspect_particle_generator_ascii_file_h
-
-#include <aspect/particle/generator/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      /**
-       * Generate a distribution of particles that is determined by the
-       * coordinates given in an ascii data file.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      class AsciiFile : public Interface<dim>
-      {
-        public:
-          /**
-           * Reads in a file and generate a set of particles at the prescribed
-           * positions.
-           *
-           * @param [in,out] particle_handler The particle handler into which
-           * the generated particles should be inserted.
-           */
-          void
-          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
-
-          // avoid -Woverloaded-virtual
-          // TODO: remove this using directive once the following deprecated
-          // function in the interface class has been removed:
-          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
-          using Generator::Interface<dim>::generate_particles;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          std::string data_directory;
-          std::string data_filename;
-      };
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/generator/interface.h.bak b/include/aspect/particle/generator/interface.h.bak
deleted file mode 100644
index 13508fa1c41..00000000000
--- a/include/aspect/particle/generator/interface.h.bak
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_generator_interface_h
-#define _aspect_particle_generator_interface_h
-
-#include <aspect/particle/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/particles/particle.h>
-#include <deal.II/particles/generators.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/exceptions.h>
-
-#include <random>
-
-#include <map>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    /**
-     * A namespace in which we define everything that has to do with defining
-     * the particle generation.
-     *
-     * @ingroup ParticleGenerators
-     */
-    namespace Generator
-    {
-      using namespace dealii::Particles;
-      using dealii::Particles::Particle;
-
-      /**
-       * Exception denoting a division by zero.
-       */
-      DeclExceptionMsg (ExcParticlePointNotInDomain,
-                        "You requested to generate a particle at a position that "
-                        "is not owned by this process, therefore the "
-                        "Particle::Generator::Interface::generate_particle() function "
-                        "refused to create it. You can circumvent this error message "
-                        "by catching the ExcParticlePointNotInDomain exception and "
-                        "do whatever you think is appropriate in this case.");
-
-      /**
-       * Abstract base class used for classes that generate particles.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      class Interface : public SimulatorAccess<dim>, public ParticleInterfaceBase
-      {
-        public:
-          virtual
-          void
-          initialize () override;
-
-          /**
-           * Generate particles. Every derived class
-           * has to decide on the method and number of particles to generate,
-           * for example using input parameters declared in their
-           * declare_parameters and parse_parameters functions. This function
-           * should generate the particles and associate them to their according
-           * cells by inserting them into a multimap between cell and particle.
-           * This map becomes very large if the particle count per process
-           * is large, so we hand it over by reference instead of returning
-           * the multimap.
-           *
-           * @param [in,out] particles A multimap between cells and their
-           * particles. This map will be filled in this function.
-           */
-          DEAL_II_DEPRECATED
-          virtual
-          void
-          generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles);
-
-          /**
-           * Generate particles. Every derived class
-           * has to decide on the method and number of particles to generate,
-           * for example using input parameters declared in their
-           * declare_parameters and parse_parameters functions. This function
-           * should generate the particles and insert them into @p particle_handler
-           * by calling its respective functions.
-           *
-           * @param [in,out] particle_handler The particle handler into which
-           * the generated particles should be inserted.
-           */
-          virtual
-          void
-          generate_particles(Particles::ParticleHandler<dim> &particle_handler);
-
-          /**
-           * Generate one particle in the given cell. This function's main purpose
-           * is to provide functionality to fill up cells with too few particles
-           * after refinement. Of course it can also be utilized by derived classes
-           * to generate the initial particle distribution.
-           */
-          std::pair<Particles::internal::LevelInd,Particle<dim>>
-          generate_particle (const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell,
-                             const types::particle_index id);
-
-        protected:
-          /**
-           * Generate a particle at the specified position and with the
-           * specified id. Many derived classes use this functionality,
-           * therefore it is implemented here to avoid duplication.
-           * In case the position is not in the local domain this function
-           * throws an exception of type ExcParticlePointNotInDomain, which
-           * can be caught in the calling plugin.
-           *
-           * @deprecated: This function uses an old return type and is deprecated.
-           * Use the insert_particle_at_position() function below instead.
-           */
-          DEAL_II_DEPRECATED
-          std::pair<Particles::internal::LevelInd,Particle<dim>>
-          generate_particle(const Point<dim> &position,
-                            const types::particle_index id) const;
-
-          /**
-           * Generate a particle at the specified position and with the
-           * specified id and insert it into the @p particle_handler.
-           * Many derived classes use this functionality,
-           * therefore it is implemented here to avoid duplication.
-           * In case the position is not in the local domain this function
-           * throws an exception of type ExcParticlePointNotInDomain, which
-           * can be caught in the calling plugin. Note that since the cell
-           * in which the particle is generated is not known, it has to be
-           * found, which is an expensive operation.
-           *
-           * @param position Position of the particle.
-           * @param id The id of the particle.
-           * @param particle_handler The particle handler into which the particle
-           * should be inserted.
-           *
-           * @return An iterator to the inserted particle. If the position was
-           * not in the local domain, an iterator to particle_handler.end() is
-           * returned.
-           */
-          Particles::ParticleIterator<dim>
-          insert_particle_at_position(const Point<dim> &position,
-                                      const types::particle_index id,
-                                      Particles::ParticleHandler<dim> &particle_handler) const;
-
-          /**
-           * Random number generator. For reproducibility of tests it is
-           * initialized in the constructor with a constant.
-           */
-          std::mt19937            random_number_generator;
-      };
-
-      /**
-       * Register a particle generator so that it can be selected from
-       * the parameter file.
-       *
-       * @param name A string that identifies the particle generator
-       * @param description A text description of what this generator does and that
-       * will be listed in the documentation of the parameter file.
-       * @param declare_parameters_function A pointer to a function that can be
-       * used to declare the parameters that this particle generator wants to read
-       * from input files.
-       * @param factory_function A pointer to a function that can create an
-       * object of this particle generator.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      void
-      register_particle_generator (const std::string &name,
-                                   const std::string &description,
-                                   void (*declare_parameters_function) (ParameterHandler &),
-                                   std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-      /**
-       * A function that given the name of a model returns a pointer to an
-       * object that describes it. Ownership of the pointer is transferred to
-       * the caller.
-       *
-       * The model object returned is not yet initialized and has not
-       * read its runtime parameters yet.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      std::unique_ptr<Interface<dim>>
-      create_particle_generator (ParameterHandler &prm);
-
-      /**
-       * Declare the runtime parameters of the registered particle generators.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      void
-      declare_parameters (ParameterHandler &prm);
-
-
-      /**
-       * For the current plugin subsystem, write a connection graph of all of the
-       * plugins we know about, in the format that the
-       * programs dot and neato understand. This allows for a visualization of
-       * how all of the plugins that ASPECT knows about are interconnected, and
-       * connect to other parts of the ASPECT code.
-       *
-       * @param output_stream The stream to write the output to.
-       */
-      template <int dim>
-      void
-      write_plugin_graph (std::ostream &output_stream);
-
-
-      /**
-       * Given a class name, a name, and a description for the parameter file
-       * for a particle generator, register it with the functions that
-       * can declare their parameters and create these objects.
-       *
-       * @ingroup ParticleGenerators
-       */
-#define ASPECT_REGISTER_PARTICLE_GENERATOR(classname, name, description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_PARTICLE_GENERATOR_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Generator::Interface<2>,classname<2 >> \
-    dummy_ ## classname ## _2d (&aspect::Particle::Generator::register_particle_generator<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Generator::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::Particle::Generator::register_particle_generator<3>, \
-                                name, description); \
-  }
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/generator/probability_density_function.h.bak b/include/aspect/particle/generator/probability_density_function.h.bak
deleted file mode 100644
index 5fa3cafd224..00000000000
--- a/include/aspect/particle/generator/probability_density_function.h.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_generator_probability_density_function_h
-#define _aspect_particle_generator_probability_density_function_h
-
-#include <aspect/particle/generator/interface.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      /**
-       * Exception
-       */
-      template <int dim>
-      DeclException1 (ProbabilityFunctionNegative,
-                      Point<dim>,
-                      << "Your probability density function in the particle generator "
-                      "returned a negative probability density for the following position: "
-                      << arg1 << ". Please check your function expression.");
-
-
-      /**
-       * Generates a random distribution of particles over the simulation
-       * domain. The particle density is determined by a user-defined
-       * probability density function in the parameter file. This is done using
-       * a "roulette wheel" style selection. Every cell is weighted by the value
-       * of the provided function at its center multiplied with the cell
-       * volume. Then a map between the accumulated cell weight
-       * and the cell index of the current cell is constructed. Consequently,
-       * a random number between zero and the global integral of the
-       * probability density function uniquely defines one particular cell.
-       * Afterwards, every process generates n_global_particles random numbers,
-       * but only generates a particle if it is the owner of the active cell
-       * that is associated with this random number.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      class ProbabilityDensityFunction : public Interface<dim>
-      {
-        public:
-          /**
-           * Generate a set of particles in the given
-           * particle handler. The particle density is set by an analytically
-           * prescribed density function that is set as an input parameter.
-           *
-           * @param [in,out] particle_handler The particle handler into which
-           * the generated particles should be inserted.
-           */
-          void
-          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
-
-          // avoid -Woverloaded-virtual
-          // TODO: remove this using directive once the following deprecated
-          // function in the interface class has been removed:
-          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
-          using Generator::Interface<dim>::generate_particles;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Number of particles to create
-           */
-          types::particle_index n_particles;
-
-          /**
-           * If true, particle numbers per cell are calculated randomly
-           * according to their respective probability density. If false,
-           * first determine how many particles each cell should have based
-           * on the integral of the density over each of the cells, and then
-           * once we know how many particles we want on each cell, choose their
-           * locations randomly within each cell.
-           */
-          bool random_cell_selection;
-
-          /**
-           * The seed for the random number generator that controls the
-           * particle generation.
-           */
-          unsigned int random_number_seed;
-
-          /**
-           * A function object representing the particle location probability
-           * density.
-           */
-          Functions::ParsedFunction<dim> function;
-      };
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/generator/quadrature_points.h.bak b/include/aspect/particle/generator/quadrature_points.h.bak
deleted file mode 100644
index bbf6ad5882a..00000000000
--- a/include/aspect/particle/generator/quadrature_points.h.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_generator_quadrature_points_h
-#define _aspect_particle_generator_quadrature_points_h
-
-#include <aspect/particle/generator/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      /**
-       * Generates particles at the quadrature points of each active cell of the triangulation.
-       * Here, Gauss quadrature of degree, (velocity_degree + 1), is used similarly to the assembly of the
-       * Stokes matrix.
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      class QuadraturePoints : public Interface<dim>
-      {
-        public:
-          /**
-           * Generates particles at the quadrature points of each active cell of the triangulation.
-           * Here, Gauss quadrature of degree, (velocity_degree + 1), is used similarly to the assembly of the
-           * Stokes matrix.
-           *
-           * @param [in,out] particle_handler The particle handler into which
-           * the generated particles should be inserted.
-           */
-          void
-          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
-
-          // avoid -Woverloaded-virtual
-          // TODO: remove this using directive once the following deprecated
-          // function in the interface class has been removed:
-          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
-          using Generator::Interface<dim>::generate_particles;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/generator/random_uniform.h.bak b/include/aspect/particle/generator/random_uniform.h.bak
deleted file mode 100644
index a69fab590d1..00000000000
--- a/include/aspect/particle/generator/random_uniform.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_generator_random_uniform_h
-#define _aspect_particle_generator_random_uniform_h
-
-#include <aspect/particle/generator/probability_density_function.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      /**
-       * Generate random uniform distribution of particles over entire simulation domain.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      class RandomUniform : public Interface<dim>
-      {
-        public:
-          /**
-           * Generate a set of particles in the given
-           * particle handler. The particles are generated
-           * with a uniform density in the whole domain.
-           *
-           * @param [in,out] particle_handler The particle handler into which
-           * the generated particles should be inserted.
-           */
-          void
-          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
-
-          // avoid -Woverloaded-virtual
-          // TODO: remove this using directive once the following deprecated
-          // function in the interface class has been removed:
-          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
-          using Generator::Interface<dim>::generate_particles;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Number of particles to create
-           */
-          types::particle_index n_particles;
-
-          /**
-           * If true, particle numbers per cell are calculated randomly
-           * according to their respective probability density. If false,
-           * first determine how many particles each cell should have based
-           * on the integral of the density over each of the cells, and then
-           * once we know how many particles we want on each cell, choose their
-           * locations randomly within each cell.
-           */
-          bool random_cell_selection;
-
-          /**
-           * The seed for the random number generator that controls the
-           * particle generation.
-           */
-          unsigned int random_number_seed;
-      };
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/generator/reference_cell.h.bak b/include/aspect/particle/generator/reference_cell.h.bak
deleted file mode 100644
index 2721c62e4de..00000000000
--- a/include/aspect/particle/generator/reference_cell.h.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_generator_reference_cell_h
-#define _aspect_particle_generator_reference_cell_h
-
-#include <aspect/particle/generator/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      /**
-       * Generate a uniform distribution of particles in the unit cell and transforms
-       * each of the particles back to real region in the model domain.
-       * Uniform here means the particles will be generated with
-       * an equal spacing in each spatial dimension.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      class ReferenceCell : public Interface<dim>
-      {
-        public:
-          /**
-           * Generate a uniform distribution of particles in the unit cell and transforms
-           * each of the particles back to real region in the model domain.
-           * Uniform here means the particles will be generated with
-           * an equal spacing in each spatial dimension.
-           *
-           * @param [in,out] particle_handler The particle handler into which
-           * the generated particles should be inserted.
-           */
-          void
-          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
-
-          // avoid -Woverloaded-virtual
-          // TODO: remove this using directive once the following deprecated
-          // function in the interface class has been removed:
-          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
-          using Generator::Interface<dim>::generate_particles;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Calculates particle position in the unit cell.
-           *
-           * @return A vector container of points each of size dim.
-           */
-          std::vector<Point<dim>> generate_particle_positions_in_unit_cell();
-
-          /**
-           * Number of particles to create for each spatial dimension as
-           * specified within the parameter file.
-           */
-          std::vector<unsigned int> number_of_particles;
-      };
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/generator/uniform_box.h.bak b/include/aspect/particle/generator/uniform_box.h.bak
deleted file mode 100644
index 1ba743d6675..00000000000
--- a/include/aspect/particle/generator/uniform_box.h.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_generator_uniform_box_h
-#define _aspect_particle_generator_uniform_box_h
-
-#include <aspect/particle/generator/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      /**
-       * Generate a uniform distribution of particles in a box region in the
-       * model domain. Uniform here means the particles will be generated with
-       * an equal spacing in each spatial dimension. Note that in order
-       * to produce a regular distribution the number of generated
-       * particles might not exactly match the one specified in the
-       * input file.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      class UniformBox : public Interface<dim>
-      {
-        public:
-          /**
-           * Generate a uniformly randomly distributed set of particles in a
-           * box-like subdomain of the global domain.
-           *
-           * @param [in,out] particle_handler The particle handler into which
-           * the generated particles should be inserted.
-           */
-          void
-          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
-
-          // avoid -Woverloaded-virtual
-          // TODO: remove this using directive once the following deprecated
-          // function in the interface class has been removed:
-          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
-          using Generator::Interface<dim>::generate_particles;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Number of initial particles to create.
-           */
-          types::particle_index n_particles;
-
-          /**
-           * The minimum coordinates of the particle region, i.e. one corner of
-           * the n-dimensional box region in which particles are generated.
-           */
-          Point<dim> P_min;
-
-          /**
-           * The maximum coordinates of the particle region, i.e. the opposite
-           * corner of the n-dimensional box region in which particles are
-           * generated.
-           */
-          Point<dim> P_max;
-      };
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/generator/uniform_radial.h.bak b/include/aspect/particle/generator/uniform_radial.h.bak
deleted file mode 100644
index b403b950674..00000000000
--- a/include/aspect/particle/generator/uniform_radial.h.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_generator_uniform_radial_h
-#define _aspect_particle_generator_uniform_radial_h
-
-#include <aspect/particle/generator/interface.h>
-
-#include <array>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      using namespace dealii;
-
-      /**
-       * Generate a uniform radial distribution of particles over the entire
-       * simulation domain. Uniform here means
-       * the particles will be generated with an equal spacing in
-       * each spherical spatial dimension, i.e. the particles are
-       * created at coordinates that increase linearly with equal
-       * spacing in radius, colatitude and longitude around a
-       * certain center point. Note that in order
-       * to produce a regular distribution the number of generated
-       * particles might not exactly match the one specified in the
-       * input file.
-       *
-       * @ingroup ParticleGenerators
-       */
-      template <int dim>
-      class UniformRadial : public Interface<dim>
-      {
-        public:
-          /**
-           * Generate a uniformly distributed set of particles in a
-           * circular or spherical subdomain of the global domain.
-           *
-           * @param [in,out] particle_handler The particle handler into which
-           * the generated particles should be inserted.
-           */
-          void
-          generate_particles(Particles::ParticleHandler<dim> &particle_handler) override;
-
-          // avoid -Woverloaded-virtual
-          // TODO: remove this using directive once the following deprecated
-          // function in the interface class has been removed:
-          // generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &particles)
-          using Generator::Interface<dim>::generate_particles;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-
-          /**
-           * The minimum spherical coordinates of the particle region, i.e.
-           * the first radius, colatitude and longitude from the given
-           * center position P_center where particles are generated.
-           */
-          std::array<double,dim> P_min;
-
-          /**
-           * The maximum spherical coordinates of the particle region, i.e.
-           * the last radius, colatitude and longitude from the given
-           * center position P_center where particles are generated.
-           */
-          std::array<double,dim> P_max;
-
-          /**
-           * The center of the particle region. Defaults to the origin.
-           */
-          Point<dim> P_center;
-
-          /**
-           * The number of radial layers of particles that will be generated.
-           * In particular this parameter determines the radial spacing between
-           * particle layers as Pmax[0] - P_min[0] / radial_layers.
-           */
-          unsigned int radial_layers;
-
-          /**
-           * Number of particles to create in total. To preserve the equal
-           * spacing (in spherical coordinates) between particles, the number
-           * of actually generated
-           * particles can differ slightly from this number.
-           */
-          types::particle_index n_particles;
-      };
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/integrator/euler.h.bak b/include/aspect/particle/integrator/euler.h.bak
deleted file mode 100644
index ad93cb6febc..00000000000
--- a/include/aspect/particle/integrator/euler.h.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_integrator_euler_h
-#define _aspect_particle_integrator_euler_h
-
-#include <aspect/particle/integrator/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      /**
-       * Explicit Euler scheme integrator.
-       * This requires only one step per integration, and doesn't involve any
-       * additional integration steps (it is a one-step method), therefore
-       * no data needs to be stored between subsequent steps.
-       *
-       * @ingroup ParticleIntegrators
-       */
-      template <int dim>
-      class Euler : public Interface<dim>, public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Perform an integration step of moving the particles of one cell
-           * by the specified timestep dt. This function implements an explicit
-           * Euler integration scheme.
-           *
-           * @param [in] begin_particle An iterator to the first particle to be moved.
-           * @param [in] end_particle An iterator to the last particle to be moved.
-           * @param [in] old_velocities The velocities at t_n, i.e. before the
-           * particle movement, for all particles between @p begin_particle
-           * and @p end_particle at their current position.
-           * @param [in] velocities The velocities at the particle positions
-           * at t_{n+1}, i.e. after the particle movement. Note that this is
-           * the velocity at the old positions, but at the new time. It is the
-           * responsibility of this function to compute the new location of
-           * the particles.
-           * @param [in] dt The length of the integration timestep.
-           */
-          void
-          local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
-                               const std::vector<Tensor<1,dim>> &old_velocities,
-                               const std::vector<Tensor<1,dim>> &velocities,
-                               const double dt) override;
-
-          /**
-           * Return a list of boolean values indicating which solution vectors
-           * are required for the integration. The first entry indicates if
-           * the particle integrator requires the solution vector at the old
-           * old time (k-1), the second entry indicates if the particle integrator
-           * requires the solution vector at the old time (k), and the third entry
-           * indicates if the particle integrator requires the solution vector
-           * at the new time (k+1).
-           *
-           * The forward Euler integrator only requires the solution vector at the
-           * old time (k), and consequently returns `{false, true, false}`.
-          */
-          std::array<bool, 3> required_solution_vectors() const override;
-
-          /**
-           * We need to tell the property manager how many intermediate properties this integrator requires,
-           * so that it can allocate sufficient space for each particle. However, the integrator is not
-           * created at the time the property manager is set up and we can not reverse the order of creation,
-           * because the integrator needs to know where to store its properties, which requires the property manager
-           * to be finished setting up properties. Luckily the number of properties is constant, so we can make it
-           * a static property of this class. Therefore, the property manager can access this variable even
-           * before any object is constructed.
-           *
-           * The forward Euler integrator does not need any intermediate storage space.
-           */
-          static const unsigned int n_integrator_properties = 0;
-      };
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/integrator/interface.h.bak b/include/aspect/particle/integrator/interface.h.bak
deleted file mode 100644
index dab8f945625..00000000000
--- a/include/aspect/particle/integrator/interface.h.bak
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_integrator_interface_h
-#define _aspect_particle_integrator_interface_h
-
-#include <aspect/particle/interface.h>
-#include <aspect/global.h>
-
-#include <deal.II/particles/particle.h>
-#include <deal.II/particles/particle_handler.h>
-#include <deal.II/base/parameter_handler.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      using namespace dealii;
-      using namespace dealii::Particles;
-
-      /**
-       * An abstract class defining virtual methods for performing integration
-       * of particle paths through the simulation velocity field.
-       *
-       * @ingroup ParticleIntegrators
-       */
-      template <int dim>
-      class Interface : public ParticleInterfaceBase
-      {
-        public:
-          /**
-           * Perform an integration step of moving the particles of one cell
-           * by the specified timestep dt. Implementations of this function
-           * must update the particle location. Between calls to this function
-           * the velocity at the updated particle positions is evaluated and
-           * passed as input argument during the next call.
-           *
-           * @param [in] begin_particle An iterator to the first particle to be moved.
-           * @param [in] end_particle An iterator to the last particle to be moved.
-           * @param [in] old_velocities The velocities at t_n, i.e. before the
-           * particle movement, for all particles between @p begin_particle
-           * and @p end_particle at their current position.
-           * @param [in] velocities The velocities at the particle positions
-           * at t_{n+1}, i.e. after the particle movement. Note that this is
-           * the velocity at the old positions, but at the new time. It is the
-           * responsibility of this function to compute the new location of
-           * the particles.
-           * @param [in] dt The length of the integration timestep.
-           */
-          virtual
-          void
-          local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
-                               const std::vector<Tensor<1,dim>> &old_velocities,
-                               const std::vector<Tensor<1,dim>> &velocities,
-                               const double dt) = 0;
-
-          /**
-           * This function is called at the end of every integration step.
-           * In case of multi-step integrators it signals the beginning of a
-           * new integration step. The default implementation always returns
-           * false, which is ok for single-step integration methods.
-           *
-           * @return This function returns true if the integrator requires
-           * another integration step. The particle world will continue
-           * to start new integration steps until this function returns false.
-           */
-          virtual bool new_integration_step();
-
-          /**
-           * Return data length of the integration related data required for
-           * communication in terms of number of bytes. When data about
-           * particles is transported from one processor to another, or stored
-           * on disk for snapshots, integrators get the chance to store
-           * whatever information they need with each particle. This function
-           * returns how many pieces of additional information a concrete
-           * integrator class needs to store for each particle.
-           *
-           * @return The number of bytes required to store the relevant
-           * integrator data for one particle.
-           */
-          virtual std::size_t get_data_size() const;
-
-          /**
-           * Return a list of boolean values indicating which solution vectors
-           * are required for the integration. The first entry indicates if
-           * the particle integrator requires the solution vector at the old
-           * old time (k-1), the second entry indicates if the particle integrator
-           * requires the solution vector at the old time (k), and the third entry
-           * indicates if the particle integrator requires the solution vector
-           * at the new time (k+1).
-          */
-          virtual std::array<bool, 3> required_solution_vectors() const = 0;
-
-          /**
-           * Read integration related data for a particle specified by particle_id
-           * from the data array. This function is called after transferring
-           * a particle to the local domain during an integration step.
-           *
-           * @param [in] data A pointer into the data array. The pointer
-           * marks the position where this function starts reading.
-           * @param [in] particle An iterator pointing to the particle to read
-           * the data for.
-           * @return The updated position of the pointer into the data array.
-           * The return value is @p data advanced by get_data_size() bytes.
-           */
-          virtual
-          const void *
-          read_data(const typename ParticleHandler<dim>::particle_iterator &particle,
-                    const void *data);
-
-          /**
-           * Write integration related data to a vector for a particle
-           * specified by particle_id. This function is called in cases where
-           * particles leave the local domain during an integration step to
-           * transfer this data to another process.
-           *
-           * @param [in] particle An iterator pointing to the particle to
-           * write the data for.
-           * @param [in] data A pointer into the array of integrator data.
-           * @return The updated position of the pointer into the data array.
-           * The return value is @p data advanced by get_data_size() bytes.
-           */
-          virtual
-          void *
-          write_data(const typename ParticleHandler<dim>::particle_iterator &particle,
-                     void *data) const;
-      };
-
-
-      /**
-       * Return a list of names (separated by '|') of possible integrator
-       * classes for particles.
-       */
-      std::string
-      integrator_object_names ();
-
-
-      /**
-       * Register a particle integrator so that it can be selected from
-       * the parameter file.
-       *
-       * @param name A string that identifies the particle integrator
-       * @param description A text description of what this integrator does and that
-       * will be listed in the documentation of the parameter file.
-       * @param declare_parameters_function A pointer to a function that can be
-       * used to declare the parameters that this particle integrator wants to read
-       * from input files.
-       * @param factory_function A pointer to a function that can create an
-       * object of this particle integrator.
-       *
-       * @ingroup ParticleIntegrators
-       */
-      template <int dim>
-      void
-      register_particle_integrator (const std::string &name,
-                                    const std::string &description,
-                                    void (*declare_parameters_function) (ParameterHandler &),
-                                    std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-      /**
-       * A function that given the name of a model returns a pointer to an
-       * object that describes it. Ownership of the pointer is transferred to
-       * the caller.
-       *
-       * The model object returned is not yet initialized and has not
-       * read its runtime parameters yet.
-       *
-       * @ingroup ParticleIntegrators
-       */
-      template <int dim>
-      std::unique_ptr<Interface<dim>>
-      create_particle_integrator (ParameterHandler &prm);
-
-
-      /**
-       * Declare the runtime parameters of the registered particle integrators.
-       *
-       * @ingroup ParticleIntegrators
-       */
-      template <int dim>
-      void
-      declare_parameters (ParameterHandler &prm);
-
-
-      /**
-       * For the current plugin subsystem, write a connection graph of all of the
-       * plugins we know about, in the format that the
-       * programs dot and neato understand. This allows for a visualization of
-       * how all of the plugins that ASPECT knows about are interconnected, and
-       * connect to other parts of the ASPECT code.
-       *
-       * @param output_stream The stream to write the output to.
-       */
-      template <int dim>
-      void
-      write_plugin_graph (std::ostream &output_stream);
-
-      /**
-       * Given a class name, a name, and a description for the parameter file
-       * for a particle integrator, register it with the functions that
-       * can declare their parameters and create these objects.
-       *
-       * @ingroup ParticleIntegrators
-       */
-#define ASPECT_REGISTER_PARTICLE_INTEGRATOR(classname, name, description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_PARTICLE_INTEGRATOR_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Integrator::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::Particle::Integrator::register_particle_integrator<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Integrator::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::Particle::Integrator::register_particle_integrator<3>, \
-                                name, description); \
-  }
-    }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/particle/integrator/rk_2.h.bak b/include/aspect/particle/integrator/rk_2.h.bak
deleted file mode 100644
index 2a307def6d8..00000000000
--- a/include/aspect/particle/integrator/rk_2.h.bak
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_integrator_rk_2_h
-#define _aspect_particle_integrator_rk_2_h
-
-#include <aspect/particle/integrator/interface.h>
-
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      /**
-       * Runge Kutta second order integrator.
-       * This scheme requires storing the original location in the particle properties.
-       *
-       * @ingroup ParticleIntegrators
-       */
-      template <int dim>
-      class RK2 : public Interface<dim>, public SimulatorAccess<dim>
-      {
-        public:
-          RK2();
-
-          /**
-           * Look up where the RK2 data is stored. Done once and cached to
-           * avoid repeated lookups.
-           */
-          void
-          initialize () override;
-
-          /**
-           * Perform an integration step of moving the particles of one cell
-           * by the specified timestep dt. This function implements a
-           * second-order accurate Runge-Kutta integration scheme.
-           *
-           * @param [in] begin_particle An iterator to the first particle to be moved.
-           * @param [in] end_particle An iterator to the last particle to be moved.
-           * @param [in] old_velocities The velocities at t_n, i.e. before the
-           * particle movement, for all particles between @p begin_particle
-           * and @p end_particle at their current position.
-           * @param [in] velocities The velocities at the particle positions
-           * at t_{n+1}, i.e. after the particle movement. Note that this is
-           * the velocity at the old positions, but at the new time. It is the
-           * responsibility of this function to compute the new location of
-           * the particles.
-           * @param [in] dt The length of the integration timestep.
-           */
-          void
-          local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
-                               const std::vector<Tensor<1,dim>> &old_velocities,
-                               const std::vector<Tensor<1,dim>> &velocities,
-                               const double dt) override;
-
-          /**
-           * This function is called at the end of every integration step.
-           * For the current class it will either increment the step variable
-           * and return true to request another integration step, or reset the
-           * step variable to 0 and return false if we are already in step 2.
-           *
-           * @return This function returns true if the integrator requires
-           * another integration step. The particle integration will continue
-           * to start new integration steps until this function returns false.
-           */
-          bool new_integration_step() override;
-
-          /**
-           * Return a list of boolean values indicating which solution vectors
-           * are required for the integration. The first entry indicates if
-           * the particle integrator requires the solution vector at the old
-           * old time (k-1), the second entry indicates if the particle integrator
-           * requires the solution vector at the old time (k), and the third entry
-           * indicates if the particle integrator requires the solution vector
-           * at the new time (k+1).
-           *
-           * The RK2 integrator requires the solution vector at the
-           * old time (k) for the first integration step, and the solution
-           * vector at both the old and new time for the second integration step
-           * (if higher_order_in_time is set to true).
-           */
-          std::array<bool, 3> required_solution_vectors() const override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-          /**
-           * We need to tell the property manager how many intermediate properties this integrator requires,
-           * so that it can allocate sufficient space for each particle. However, the integrator is not
-           * created at the time the property manager is set up and we can not reverse the order of creation,
-           * because the integrator needs to know where to store its properties, which requires the property manager
-           * to be finished setting up properties. Luckily the number of properties is constant, so we can make it
-           * a static property of this class. Therefore, the property manager can access this variable even
-           * before any object is constructed.
-           *
-           * The Runge-Kutta 2 integrator requires a single point with dim components.
-           */
-          static const unsigned int n_integrator_properties = dim;
-
-        private:
-          /**
-           * The current integration step, i.e for RK2 a number that is either
-           * 0 or 1.
-           */
-          unsigned int integrator_substep;
-
-          /**
-           * The location of the RK2 data that is stored in the particle properties.
-           */
-          unsigned int property_index_old_location;
-
-          /**
-           * Whether to evaluate old and current velocity to compute a solution
-           * that is higher order accurate in time.
-           */
-          bool higher_order_in_time;
-      };
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/integrator/rk_4.h.bak b/include/aspect/particle/integrator/rk_4.h.bak
deleted file mode 100644
index ae27e8446bc..00000000000
--- a/include/aspect/particle/integrator/rk_4.h.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_integrator_rk_4_h
-#define _aspect_particle_integrator_rk_4_h
-
-#include <aspect/particle/integrator/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      /**
-       * Runge Kutta fourth order integrator. This scheme requires
-       * storing the original location and intermediate k1, k2, k3
-       * values in the particle properties.
-       *
-       * @ingroup ParticleIntegrators
-       */
-      template <int dim>
-      class RK4 : public Interface<dim>, public SimulatorAccess<dim>
-      {
-        public:
-          RK4();
-
-          /**
-           * Look up where the RK4 data is stored. Done once and cached to
-           * avoid repeated lookups.
-           */
-          void
-          initialize () override;
-
-          /**
-           * Perform an integration step of moving the particles of one cell
-           * by the specified timestep dt. This class implements a Runge-Kutta
-           * integration scheme that is fourth order accurate
-           * in space.
-           *
-           * @param [in] begin_particle An iterator to the first particle to be moved.
-           * @param [in] end_particle An iterator to the last particle to be moved.
-           * @param [in] old_velocities The velocities at t_n, i.e. before the
-           * particle movement, for all particles between @p begin_particle
-           * and @p end_particle at their current position.
-           * @param [in] velocities The velocities at the particle positions
-           * at t_{n+1}, i.e. after the particle movement. Note that this is
-           * the velocity at the old positions, but at the new time. It is the
-           * responsibility of this function to compute the new location of
-           * the particles.
-           * @param [in] dt The length of the integration timestep.
-           */
-          void
-          local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
-                               const std::vector<Tensor<1,dim>> &old_velocities,
-                               const std::vector<Tensor<1,dim>> &velocities,
-                               const double dt) override;
-
-          /**
-           * This function is called at the end of every integration step.
-           * For the current class it will either increment the step variable
-           * and return true to request another integration step, or reset the
-           * step variable to 0 and return false if we are already in step 4.
-           *
-           * @return This function returns true if the integrator requires
-           * another integration step. The particle integration will continue
-           * to start new integration steps until this function returns false.
-           */
-          bool new_integration_step() override;
-
-          /**
-           * Return a list of boolean values indicating which solution vectors
-           * are required for the integration. The first entry indicates if
-           * the particle integrator requires the solution vector at the old
-           * old time (k-1), the second entry indicates if the particle integrator
-           * requires the solution vector at the old time (k), and the third entry
-           * indicates if the particle integrator requires the solution vector
-           * at the new time (k+1).
-           *
-           * The RK4 integrator requires the solution vector at the
-           * old time (k) for the first integration step, the solution
-           * vector at both the old and new time for the second
-           * and third integration steps and the solution vector at the
-           * new time (k+1) for the fourth integration step.
-           */
-          std::array<bool, 3> required_solution_vectors() const override;
-
-          /**
-           * We need to tell the property manager how many intermediate properties this integrator requires,
-           * so that it can allocate sufficient space for each particle. However, the integrator is not
-           * created at the time the property manager is set up and we can not reverse the order of creation,
-           * because the integrator needs to know where to store its properties, which requires the property manager
-           * to be finished setting up properties. Luckily the number of properties is constant, so we can make it
-           * a static property of this class. Therefore, the property manager can access this variable even
-           * before any object is constructed.
-           *
-           * The Runge-Kutta 4 integrator requires 4 tensors with dim components each.
-           */
-          static const unsigned int n_integrator_properties = 4*dim;
-
-        private:
-          /**
-           * The current integration step, i.e. for RK4 a number between 0
-           * and 3.
-           */
-          unsigned int integrator_substep;
-
-          /**
-           * The location of the 4 RK4 data fields stored in the particle properties.
-           */
-          std::array<unsigned int,4> property_indices;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/interface.h.bak b/include/aspect/particle/interface.h.bak
deleted file mode 100644
index 04ab2a319ba..00000000000
--- a/include/aspect/particle/interface.h.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_interface_h
-#define _aspect_particle_interface_h
-
-#include <aspect/plugins.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    /**
-     * A base class defining methods and member variables
-     * shared along all the particle plugins. This includes the generator,
-     * integrator, interpolator and the property classes.
-     *
-     * @ingroup Particle
-     */
-    class ParticleInterfaceBase : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * @brief Set which particle world the plugin belongs to.
-         *
-         * @param particle_world_index The index of the particle world this plugin belongs to.
-         */
-        void set_particle_world_index(unsigned int particle_world_index);
-
-        /**
-         * @brief Gets which particle world the plugin belong to.
-         */
-        unsigned int get_particle_world_index() const;
-
-      private:
-        /**
-         * Stores the index to the particle world, to which the plugin belongs.
-         */
-        unsigned int particle_world_index;
-    };
-
-  }
-}
-
-
-#endif
diff --git a/include/aspect/particle/interpolator/bilinear_least_squares.h.bak b/include/aspect/particle/interpolator/bilinear_least_squares.h.bak
deleted file mode 100644
index fb4f34b640d..00000000000
--- a/include/aspect/particle/interpolator/bilinear_least_squares.h.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_interpolator_bilinear_least_squares_h
-#define _aspect_particle_interpolator_bilinear_least_squares_h
-
-#include <aspect/particle/interpolator/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <aspect/particle/interpolator/cell_average.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      /**
-       * Evaluate the properties of all particles of the given cell
-       * using a least squares projection onto the set of bilinear
-       * (or, in 3d, trilinear) functions.
-       *
-       * @ingroup ParticleInterpolators
-       */
-      template <int dim>
-      class BilinearLeastSquares : public Interface<dim>, public aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Return the cell-wise evaluated properties of the bilinear least squares function at the positions.
-           */
-          std::vector<std::vector<double>>
-          properties_at_points(const ParticleHandler<dim> &particle_handler,
-                               const std::vector<Point<dim>> &positions,
-                               const ComponentMask &selected_properties,
-                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
-
-          // avoid -Woverloaded-virtual:
-          using Interface<dim>::properties_at_points;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * A component mask that determines whether a limiting scheme is
-           * used for each interpolated property. The limiting scheme
-           * prevents overshoot and undershoot of interpolated particle
-           * properties based on the local max and min of the particle
-           * properties in that cell (i.e. the interpolated properties
-           * will never exxceed the max and min of the properties on the particles).
-           */
-          ComponentMask use_linear_least_squares_limiter;
-
-          /**
-           * A component mask that determines whether a boundary condition
-           * can be extrapolated for use in the limiting scheme. If boundary
-           * extrapolation is enabled for a given property index, then the
-           * limiter should be as well. Boundary extrapolation should help
-           * the accuracy of properties that are smooth, although it can allow
-           * undershoots and overshoots to occur if used with characteristic
-           * functions or functions with discontinuities near a model boundary.
-           */
-          ComponentMask use_boundary_extrapolation;
-
-          /**
-           * Fallback method if there are too few particles in a cell to
-           * perform a bilinear least squares interpolation.
-           */
-          Interpolator::CellAverage<dim> fallback_interpolator;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/interpolator/cell_average.h.bak b/include/aspect/particle/interpolator/cell_average.h.bak
deleted file mode 100644
index 38bdcb2fd98..00000000000
--- a/include/aspect/particle/interpolator/cell_average.h.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_interpolator_cell_average_h
-#define _aspect_particle_interpolator_cell_average_h
-
-#include <aspect/particle/interpolator/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      /**
-       * Return the averaged properties of all particles on the given cell.
-       *
-       * @ingroup ParticleInterpolators
-       */
-      template <int dim>
-      class CellAverage : public Interface<dim>, public aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Return the cell-wise averaged properties of all particles of the cell containing the
-           * given positions.
-           */
-          std::vector<std::vector<double>>
-          properties_at_points(const ParticleHandler<dim> &particle_handler,
-                               const std::vector<Point<dim>> &positions,
-                               const ComponentMask &selected_properties,
-                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
-
-          // avoid -Woverloaded-virtual:
-          using Interface<dim>::properties_at_points;
-
-          /**
-           * @copydoc Interface<dim>::declare_parameters()
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * @copydoc Interface<dim>::parse_parameters()
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * By default, every cell needs to contain particles to use this interpolator
-           * plugin. If this parameter is set to true, cells are allowed to have no particles,
-           * in which case the interpolator will return 0 for the cell's properties.
-           */
-          bool allow_cells_without_particles;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/interpolator/harmonic_average.h.bak b/include/aspect/particle/interpolator/harmonic_average.h.bak
deleted file mode 100644
index 78effa04340..00000000000
--- a/include/aspect/particle/interpolator/harmonic_average.h.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_interpolator_harmonic_average_h
-#define _aspect_particle_interpolator_harmonic_average_h
-
-#include <aspect/particle/interpolator/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      /**
-       * Return the harmonic averaged properties of all particles on the given cell.
-       *
-       * @ingroup ParticleInterpolators
-       */
-      template <int dim>
-      class HarmonicAverage : public Interface<dim>, public aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Return the cell-wise harmonic averaged properties of all particles of the cell containing the
-           * given positions.
-           */
-          std::vector<std::vector<double>>
-          properties_at_points(const ParticleHandler<dim> &particle_handler,
-                               const std::vector<Point<dim>> &positions,
-                               const ComponentMask &selected_properties,
-                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
-
-          // avoid -Woverloaded-virtual:
-          using Interface<dim>::properties_at_points;
-
-          /**
-           * @copydoc Interface<dim>::declare_parameters()
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * @copydoc Interface<dim>::parse_parameters()
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * By default, every cell needs to contain particles to use this interpolator
-           * plugin. If this parameter is set to true, cells are allowed to have no particles,
-           * in which case the interpolator will return 0 for the cell's properties.
-           */
-          bool allow_cells_without_particles;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/interpolator/interface.h.bak b/include/aspect/particle/interpolator/interface.h.bak
deleted file mode 100644
index 6d52b743356..00000000000
--- a/include/aspect/particle/interpolator/interface.h.bak
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_interpolator_interface_h
-#define _aspect_particle_interpolator_interface_h
-
-#include <aspect/particle/interface.h>
-#include <aspect/global.h>
-
-#include <deal.II/particles/particle.h>
-#include <deal.II/particles/particle_handler.h>
-#include <deal.II/base/point.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/distributed/tria.h>
-#include <deal.II/fe/component_mask.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      using namespace dealii;
-      using namespace dealii::Particles;
-
-      /**
-       * An abstract class defining virtual methods for performing
-       * interpolation of particle properties to arbitrary points.
-       *
-       * @ingroup ParticleInterpolators
-       */
-      template <int dim>
-      class Interface : public ParticleInterfaceBase
-      {
-        public:
-          /**
-           * Perform an interpolation of the properties of the particles in
-           * this cell onto a vector of positions in this cell.
-           * Implementations of this function must return a vector of a vector
-           * of doubles with as many entries as positions in @p positions.
-           * Each entry is a vector with as many entries as there are  particle
-           * properties in this computation.
-           * All in @p selected_properties selected components
-           * will be filled with computed properties, all other components
-           * are not filled (or filled with invalid values).
-           *
-           * @param [in] particle_handler Reference to the particle handler
-           * that allows accessing the particles in the domain.
-           * @param [in] positions The vector of positions where the properties
-           * should be evaluated.
-           * @param [in] selected_properties A component mask that determines
-           * which particle properties are interpolated in this function.
-           * @param [in] cell An iterator to the cell containing the
-           * positions.
-           * @return A vector with as many entries as @p positions. Each entry
-           * is a vector of interpolated particle properties at this position.
-           * This property vector has as many entries as there are particle
-           * properties, however entries that have not been selected in
-           * @p selected_properties are filled with signalling NaNs.
-           */
-          virtual
-          std::vector<std::vector<double>>
-          properties_at_points(const ParticleHandler<dim> &particle_handler,
-                               const std::vector<Point<dim>> &positions,
-                               const ComponentMask &selected_properties,
-                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const = 0;
-      };
-
-
-      /**
-       * Return a list of names (separated by '|') of possible interpolator
-       * classes for particles.
-       */
-      std::string
-      interpolator_object_names ();
-
-
-      /**
-       * Register a particle interpolator so that it can be selected from
-       * the parameter file.
-       *
-       * @param name A string that identifies the particle interpolator
-       * @param description A text description of what this interpolator does and that
-       * will be listed in the documentation of the parameter file.
-       * @param declare_parameters_function A pointer to a function that can be
-       * used to declare the parameters that this particle interpolator wants to read
-       * from input files.
-       * @param factory_function A pointer to a function that can create an
-       * object of this particle interpolator.
-       *
-       * @ingroup ParticleInterpolators
-       */
-      template <int dim>
-      void
-      register_particle_interpolator (const std::string &name,
-                                      const std::string &description,
-                                      void (*declare_parameters_function) (ParameterHandler &),
-                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-      /**
-       * A function that given the name of a model returns a pointer to an
-       * object that describes it. Ownership of the pointer is transferred to
-       * the caller.
-       *
-       * The model object returned is not yet initialized and has not
-       * read its runtime parameters yet.
-       *
-       * @ingroup ParticleInterpolators
-       */
-      template <int dim>
-      std::unique_ptr<Interface<dim>>
-      create_particle_interpolator (ParameterHandler &prm);
-
-
-      /**
-       * Declare the runtime parameters of the registered particle interpolators.
-       *
-       * @ingroup ParticleInterpolators
-       */
-      template <int dim>
-      void
-      declare_parameters (ParameterHandler &prm);
-
-
-      /**
-       * For the current plugin subsystem, write a connection graph of all of the
-       * plugins we know about, in the format that the
-       * programs dot and neato understand. This allows for a visualization of
-       * how all of the plugins that ASPECT knows about are interconnected, and
-       * connect to other parts of the ASPECT code.
-       *
-       * @param output_stream The stream to write the output to.
-       */
-      template <int dim>
-      void
-      write_plugin_graph (std::ostream &output_stream);
-
-      /**
-       * Given a class name, a name, and a description for the parameter file
-       * for a particle interpolator, register it with the functions that
-       * can declare their parameters and create these objects.
-       *
-       * @ingroup ParticleInterpolators
-       */
-#define ASPECT_REGISTER_PARTICLE_INTERPOLATOR(classname, name, description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_PARTICLE_INTERPOLATOR_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Interpolator::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::Particle::Interpolator::register_particle_interpolator<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Interpolator::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::Particle::Interpolator::register_particle_interpolator<3>, \
-                                name, description); \
-  }
-    }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/particle/interpolator/nearest_neighbor.h.bak b/include/aspect/particle/interpolator/nearest_neighbor.h.bak
deleted file mode 100644
index feacd4d12f6..00000000000
--- a/include/aspect/particle/interpolator/nearest_neighbor.h.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_interpolator_nearest_neighbor_h
-#define _aspect_particle_interpolator_nearest_neighbor_h
-
-#include <aspect/particle/interpolator/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      /**
-       * Return the properties of the nearest particle within the current cell, or
-       * in a neighboring cell if this one is empty.
-       *
-       * @ingroup ParticleInterpolators
-       */
-      template <int dim>
-      class NearestNeighbor : public Interface<dim>, public aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Return the properties of the particles nearest to the given positions within the same cell,
-           * or adjacent cells if none is present in same cell.
-           */
-          std::vector<std::vector<double>>
-          properties_at_points(const ParticleHandler<dim> &particle_handler,
-                               const std::vector<Point<dim>> &positions,
-                               const ComponentMask &selected_properties,
-                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
-
-          // avoid -Woverloaded-virtual:
-          using Interface<dim>::properties_at_points;
-
-          /**
-           * @copydoc Interface<dim>::declare_parameters()
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * @copydoc Interface<dim>::parse_parameters()
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * By default, every cell needs to contain particles to use this interpolator
-           * plugin. If this parameter is set to true, cells are allowed to have no particles,
-           * in which case the interpolator will return 0 for the cell's properties.
-           */
-          bool allow_cells_without_particles;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/interpolator/quadratic_least_squares.h.bak b/include/aspect/particle/interpolator/quadratic_least_squares.h.bak
deleted file mode 100644
index 416c705b122..00000000000
--- a/include/aspect/particle/interpolator/quadratic_least_squares.h.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- Copyright (C) 2019 - 2022-2020 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_interpolator_quadratic_least_squares_h
-#define _aspect_particle_interpolator_quadratic_least_squares_h
-
-#include <aspect/particle/interpolator/interface.h>
-#include <aspect/particle/interpolator/cell_average.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      /**
-       * Return the properties of all particles of the given cell by using a least squares
-       * projection onto the space of quadratic functions.
-       * For more details on the implementation and properties of this plugin see:
-       * Mack Gregory and Elbridge Gerry Puckett (2020),
-       * "Improving the Accuracy and Efficiency of Hybrid Finite
-       * Element / Particle-In-Cell Methods for Modeling Geologic Processes",
-       * Abstract Submission ID# 743654
-       * https://agu.confex.com/agu/fm20/prelim.cgi/Paper/743654
-       * Session: A002 - Addressing Challenges for the Next Generation of Earth System Models
-       * Submitted to 2020 AGU Fall Meeting, San Francisco, CA Dec. 7-11, 2020
-       *
-       * @ingroup ParticleInterpolators
-       */
-      template <int dim>
-      class QuadraticLeastSquares : public Interface<dim>, public aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Return the cell-wise evaluated properties of the quadratic least squares function at the positions.
-           */
-          std::vector<std::vector<double>>
-          properties_at_points(const ParticleHandler<dim> &particle_handler,
-                               const std::vector<Point<dim>> &positions,
-                               const ComponentMask &selected_properties,
-                               const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const override;
-
-          // avoid -Woverloaded-virtual:
-          using Interface<dim>::properties_at_points;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Use the cell average interpolator in case the quadratic least
-           * squares interpolator fails due to a lack of particles.
-           */
-          Interpolator::CellAverage<dim> fallback_interpolator;
-
-          /**
-           * Enables a limiting scheme that prevents overshoot and
-           * undershoot of interpolated particles based upon the range
-           * of property values found in the area of the cell.
-           */
-          ComponentMask use_quadratic_least_squares_limiter;
-
-          /**
-           * Enables a linear extrapolation of boundary values for the limiting scheme
-           */
-          ComponentMask use_boundary_extrapolation;
-
-          /**
-           * Calculate the value of the interpolation function at a given position
-           */
-          double evaluate_interpolation_function(const Vector<double> &coefficients, const Point<dim> &position) const;
-
-          /**
-           * Update the bounds of where the plane reaches by checking whether each of the critical points
-           * are in the cell and evauating their value.
-           */
-          std::pair<double, double> get_interpolation_bounds(const dealii::Vector<double> &coefficients) const;
-
-          /*
-           * Find all points that may contain the minimum or maximum values of the interpolation in the cell.
-           */
-          std::vector<dealii::Point<dim>> get_critical_points(const dealii::Vector<double> &coefficients) const;
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/composition.h.bak b/include/aspect/particle/property/composition.h.bak
deleted file mode 100644
index a115a811e3a..00000000000
--- a/include/aspect/particle/property/composition.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_composition_h
-#define _aspect_particle_property_composition_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * Implementation of a plugin in which the particle
-       * property is defined by the compositional fields in
-       * the model. This can be used to track solid composition
-       * evolution over time.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class Composition : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties over time.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * The pressure and temperature need the values of their variables.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/cpo_bingham_average.h.bak b/include/aspect/particle/property/cpo_bingham_average.h.bak
deleted file mode 100644
index a2ffd097350..00000000000
--- a/include/aspect/particle/property/cpo_bingham_average.h.bak
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- Copyright (C) 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_cpo_bingham_average_h
-#define _aspect_particle_property_cpo_bingham_average_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/particle/property/crystal_preferred_orientation.h>
-#include <aspect/simulator_access.h>
-
-#include <array>
-#include <random>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-
-      /**
-       * Computes the Bingham average of the CPO particle properties.
-       * See https://courses.eas.ualberta.ca/eas421/lecturepages/orientation.html for more info.
-       *
-       * The layout of the data vector per particle is the following (note that for this plugin the following dim's are always 3):
-       * 1 averaged a axis of olivine       -> 3 (dim) doubles, starts at:
-       *                                         data_position + 1,
-       * 2 eigenvalues of a axis of olivine -> 3 (dim) doubles, starts at:
-       *                                         data_position + 4,
-       * 3 averaged b axis of olivine       -> 3 (dim) doubles, starts at:
-       *                                         data_position + 7,
-       * 4 eigenvalues of b axis of olivine -> 3 (dim) doubles, starts at:
-       *                                         data_position + 10,
-       * 5 averaged c axis of olivine       -> 3 (dim) doubles, starts at:
-       *                                         data_position + 13,
-       * 6 eigenvalues of c axis of olivine -> 3 (dim) doubles, starts at:
-       *                                         data_position + 16,
-       * 7 averaged a axis of enstatite       -> 3 (dim) doubles, starts at:
-       *                                          data_position + 19,
-       * 8 eigenvalues of a axis of enstatite -> 3 (dim) doubles, starts at:
-       *                                          data_position + 22,
-       * 9 averaged a axis of enstatite       -> 3 (dim) doubles, starts at:
-       *                                          data_position + 25,
-       * 10 eigenvalues of a axis of enstatite -> 3 (dim) doubles, starts at:
-       *                                          data_position + 28,
-       * 11 averaged a axis of enstatite       -> 3 (dim) doubles, starts at:
-       *                                          data_position + 31,
-       * 12 eigenvalues of a axis of enstatite -> 3 (dim) doubles, starts at:
-       *                                          data_position + 34,
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class CpoBinghamAverage : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * constructor
-           */
-          CpoBinghamAverage() = default;
-
-          /**
-           * Initialization function. This function is called once at the
-           * beginning of the program after parse_parameters is run.
-           */
-          void
-          initialize () override;
-
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * Update function. This function is called every time an update is
-           * request by need_update() for every particle for every property.
-           * It is obvious that
-           * this function is called a lot, so its code should be efficient.
-           * The interface provides a default implementation that does nothing,
-           * therefore derived plugins that do not require an update do not
-           * need to implement this function.
-           *
-           * @param [in] data_position An unsigned integer that denotes which
-           * component of the particle property vector is associated with the
-           * current property. For properties that own several components it
-           * denotes the first component of this property, all other components
-           * fill consecutive entries in the @p particle_properties vector.
-           *
-           * @param [in] solution The values of the solution variables at the
-           * current particle position.
-           *
-           * @param [in] gradients The gradients of the solution variables at
-           * the current particle position.
-           *
-           * @param [in,out] particle The particle that is updated within
-           * the call of this function. The particle location can be accessed
-           * using particle->get_location() and its properties using
-           * particle->get_properties().
-           */
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties every time step.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * The integrated strains needs the gradients of the velocity.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-          /**
-           * Computes the Bingham average. This is a way to average directions. The method comes from
-           * https://courses.eas.ualberta.ca/eas421/lecturepages/orientation.html, where it is explained
-           * with the anology that each vector/pole has a weight on a sphere. This method allows to find
-           * the moment of inertia for spinning that sphere. Here we just use it to get three averaged
-           * axis associated with the densest clustering of points for each axis. the a to c axis vectors
-           * are stored in the first to last array respectively.
-           */
-          std::array<std::array<double,6>,3>
-          compute_bingham_average(std::vector<Tensor<2,3>> matrices) const;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * stores the position of the cpo data in the particle property vector
-           */
-          unsigned int cpo_data_position;
-
-          /**
-           * A pointer to the crystal preferred orientation particle property.
-           * Avoids repeated searches for that property.
-           */
-          std::unique_ptr<const Particle::Property::CrystalPreferredOrientation<dim>> cpo_particle_property;
-
-          /**
-           * Random number generator. For reproducibility of tests it is
-           * initialized in the constructor with a constant plus the MPI rank.
-           */
-          mutable std::mt19937 random_number_generator;
-
-          /**
-           * the random number generator seed used to initialize the random number generator.
-           */
-          unsigned int random_number_seed;
-
-          /**
-           * Number of grains
-           */
-          unsigned int n_grains;
-
-          /**
-           * Number of minerals
-           */
-          unsigned int n_minerals;
-
-          /**
-           * when doing the random draw volume weighting, this sets how many samples are taken.
-           */
-          unsigned int n_samples;
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/cpo_elastic_tensor.h.bak b/include/aspect/particle/property/cpo_elastic_tensor.h.bak
deleted file mode 100644
index 1b7cc82a201..00000000000
--- a/include/aspect/particle/property/cpo_elastic_tensor.h.bak
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- Copyright (C) 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_cpo_elastic_tensor_h
-#define _aspect_particle_property_cpo_elastic_tensor_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/particle/property/crystal_preferred_orientation.h>
-#include <aspect/simulator_access.h>
-#include <array>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-
-      /**
-       * Computes the elastic tensor $C_{ijkl}$ based on the cpo in both olivine
-       * and enstatite. It uses a Voigt average.
-       *
-       * The layout of the data vector per particle is the following (note that
-       * for this plugin the following dims are always 3):
-       * 1 unrolled tensor -> 3x3x3x3 (dim*dim*dim*dim) doubles, starts at:
-       *                                   data_position
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class CpoElasticTensor : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor
-           */
-          CpoElasticTensor();
-
-          /**
-           * Initialization function. This function is called once at the
-           * beginning of the program after parse_parameters is run.
-           */
-          void
-          initialize () override;
-
-          /**
-           * This implements the Voigt averaging as described in the equation at the
-           * bottom of page 385 in Mainprice (1990, doi: 10.1016/0098-3004(90)90072-2):
-           * $C^V_{ijkl} = \sum^S_l F_s \sum^{N_s}_l C_{ijkl}/N_s$, where $F_s$ is the
-           * grain size, $N_s$ is the number of grains and $C_{ijkl}$ is the elastic
-           * tensor. This elastic tensor is computed by the equation above in
-           * Mainprice (1990): $C_{ijkl} = R_{ip} R_{jg} R_{kr} R_{is} C_{pgrs}$, where
-           * R_{ij} is the cpo orientation matrix.
-           */
-          SymmetricTensor<2,6>
-          voigt_average_elastic_tensor (const Particle::Property::CrystalPreferredOrientation<dim> &cpo_particle_property,
-                                        const unsigned int cpo_data_position,
-                                        const ArrayView<double> &data) const;
-
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * Update function. This function is called every time an update is
-           * request by need_update() for every particle for every property.
-           * It is obvious that
-           * this function is called a lot, so its code should be efficient.
-           * The interface provides a default implementation that does nothing,
-           * therefore derived plugins that do not require an update do not
-           * need to implement this function.
-           *
-           * @param [in] data_position An unsigned integer that denotes which
-           * component of the particle property vector is associated with the
-           * current property. For properties that own several components it
-           * denotes the first component of this property, all other components
-           * fill consecutive entries in the @p particle_properties vector.
-           *
-           * @param [in] solution The values of the solution variables at the
-           * current particle position.
-           *
-           * @param [in] gradients The gradients of the solution variables at
-           * the current particle position.
-           *
-           * @param [in,out] particle The particle that is updated within
-           * the call of this function. The particle location can be accessed
-           * using particle->get_location() and its properties using
-           * particle->get_properties().
-           */
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This function tells the particle manager that
-           * we need to update particle properties every time step.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * For example, the strains needs the gradients of the velocity.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-          /**
-           * returns the elastic tensor from the particle data
-           */
-          static
-          SymmetricTensor<2,6>
-          get_elastic_tensor(unsigned int cpo_index,
-                             const ArrayView<double> &data);
-
-          /**
-           * Stores the elastic tensor into the particle data array
-           */
-          static
-          void
-          set_elastic_tensor(unsigned int cpo_data_position,
-                             const ArrayView<double> &data,
-                             const SymmetricTensor<2,6> &elastic_tensor);
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Parses the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * The position of the cpo in the particle data array.
-           */
-          unsigned int cpo_data_position;
-
-          /**
-           * The stiffness tensors for olivine and enstatite.
-           * Todo: generalize this into a vector.
-           */
-          SymmetricTensor<2,6> stiffness_matrix_olivine;
-          SymmetricTensor<2,6> stiffness_matrix_enstatite;
-
-          /**
-           * The number of grains per particle.
-           */
-          unsigned int n_grains;
-
-          /**
-           * The number of minerals per particle.
-           */
-          unsigned int n_minerals;
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/crystal_preferred_orientation.h.bak b/include/aspect/particle/property/crystal_preferred_orientation.h.bak
deleted file mode 100644
index 1c10dcc087b..00000000000
--- a/include/aspect/particle/property/crystal_preferred_orientation.h.bak
+++ /dev/null
@@ -1,649 +0,0 @@
-/*
- Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_cpo_h
-#define _aspect_particle_property_cpo_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-#include <array>
-
-DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-#include <boost/random.hpp>
-DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * @brief The type of deformation used by the CPO code.
-       *
-       * passive: Only to be used with the spin tensor CPO Derivative algorithm.
-       * olivine_a_fabric to olivine_e_fabric: Only to be used with the D-Rex CPO Derivative algorithm.
-       *  Sets the deformation type of the mineral to a Olivine A-E Fabric, which influences the relative strength of the slip planes. See table 1 in Fraters and Billen (2021).
-       * enstatite: Only to be used with the D-Rex CPO Derivative algorithm. Sets the deformation type of the mineral to a enstatite Fabric, which influences the relative strength of the slip planes.
-       */
-      enum class DeformationType
-      {
-        passive, olivine_a_fabric, olivine_b_fabric, olivine_c_fabric, olivine_d_fabric, olivine_e_fabric, enstatite
-      };
-
-
-      /**
-       * @brief The type of deformation selector used by the CPO code.
-       *
-       * The selector is a input parameter and it can either set a deformation type directly or determine the deformation type through an algorithm.
-       * The deformation type selector is used to determine/select the deformation type. It can be a fixed deformation type, for example,
-       * by setting it to olivine_a_fabric, or it can be dynamically chosen, which is what the olivine_karato_2008 option does.
-       *
-       * passive: Only to be used with the spin tensor CPO Derivative algorithm.
-       * olivine_a_fabric to olivine_e_fabric: Only to be used with the D-Rex CPO Derivative algorithm.
-       *  Sets the deformation type of the mineral to a Olivine A-E Fabric, which influences the relative strength of the slip planes. See table 1 in Fraters and Billen (2021).
-       * enstatite: Only to be used with the D-Rex CPO Derivative algorithm. Sets the deformation type of the mineral to a enstatite Fabric, which influences the relative strength of the slip planes.
-       * olivine_karato_2008: Only to be used with the D-Rex CPO Derivative algorithm. Sets the deformation type of the mineral to a olivine fabric based on the table in Karato 2008.
-       */
-      enum class DeformationTypeSelector
-      {
-        passive, olivine_a_fabric, olivine_b_fabric, olivine_c_fabric, olivine_d_fabric, olivine_e_fabric, enstatite, olivine_karato_2008
-      };
-
-      /**
-       * @brief The type of Advection method used to advect the CPO properties.
-       */
-      enum class AdvectionMethod
-      {
-        forward_euler, backward_euler
-      };
-
-      /**
-       * @brief The algorithm used to compute the derivatives of the grain size and rotation matrix used in the advection.
-       *
-       * spin_tensor: Rotates the CPO properties soly with the rotation of the particle itself.
-       * drex_2004: Rotates the CPO properties based on the D-Rex 2004 algorithm.
-       */
-      enum class CPODerivativeAlgorithm
-      {
-        spin_tensor, drex_2004
-      };
-
-      /**
-       * @brief An enum used to determine how the initial grain sizes and orientations are set for all particles
-       *
-       * uniform_grains_and_random_uniform_rotations: all particles are set to a uniform grain-size of 1/n_grains
-       * world_builder: all particle grain-sizes and orientations are set by the world builder.
-       */
-      enum class CPOInitialGrainsModel
-      {
-        uniform_grains_and_random_uniform_rotations, world_builder
-      };
-
-      /**
-       * The plugin manages and computes the evolution of Lattice/Crystal Preferred Orientations (LPO/CPO)
-       * on particles. Each ASPECT particle represents many grains. Each grain is assigned a size and a orientation
-       * matrix. This allows tracking the LPO evolution with kinematic polycrystal CPO evolution models such
-       * as D-Rex (Kaminski and Ribe, 2001; ́Kaminski et al., 2004).
-       *
-       * This plugin stores M minerals and for each mineral it stores N grains. The total amount of memory stored is 2
-       * doubles per mineral plus 10 doubles per grain, resulting in a total memory of M * (2 + N * 10) . The layout of
-       * the data stored is the following (note that for this plugin the following dims are always 3):
-       * 1. M minerals times
-       *    1.1  Mineral deformation type   -> 1 double, at location
-       *                                      => 0 + mineral_i * (n_grains * 10 + 2)
-       *    2.1. Mineral volume fraction    -> 1 double, at location
-       *                                      => 1 + mineral_i * (n_grains * 10 + 2)
-       *    2.2. N grains times:
-       *         2.1. volume fraction grain -> 1 double, at location:
-       *                                      => 2 + grain_i * 10 + mineral_i * (n_grains * 10 + 2)
-       *         2.2. rotation_matrix grain -> 9 (Tensor<2,dim>::n_independent_components) doubles, starts at:
-       *                                      => 3 + grain_i * 10 + mineral_i * (n_grains * 10 + 2)
-       *
-       * Last used data entry is n_minerals * (n_grains * 10 + 2).
-       *
-       * We store the same number of grains for all minerals (e.g. olivine and enstatite
-       * grains), although their volume fractions may not be the same. This is because we need a minimum number
-       * of grains per tracer to perform reliable statistics on it. This minimum should be the same for all
-       * minerals.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class CrystalPreferredOrientation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor
-           */
-          CrystalPreferredOrientation() = default;
-
-          /**
-           * Initialization function. This function is called once at the
-           * beginning of the program after parse_parameters is run.
-           */
-          void
-          initialize () override;
-
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * Update function. This function is called every time an update is
-           * request by need_update() for every particle for every property.
-           * It is obvious that
-           * this function is called a lot, so its code should be efficient.
-           * The interface provides a default implementation that does nothing,
-           * therefore derived plugins that do not require an update do not
-           * need to implement this function.
-           *
-           * @param [in] data_position An unsigned integer that denotes which
-           * component of the particle property vector is associated with the
-           * current property. For properties that own several components it
-           * denotes the first component of this property, all other components
-           * fill consecutive entries in the @p particle_properties vector.
-           *
-           * @param [in] solution The values of the solution variables at the
-           * current particle position.
-           *
-           * @param [in] gradients The gradients of the solution variables at
-           * the current particle position.
-           *
-           * @param [in,out] particle The particle that is updated within
-           * the call of this function. The particle location can be accessed
-           * using particle->get_location() and its properties using
-           * particle->get_properties().
-           */
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties every time step.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * The CPO of late particles is initialized by interpolating from existing particles.
-           */
-          InitializationModeForLateParticles
-          late_initialization_mode () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * The integrated strains needs the gradients of the velocity.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-          /**
-           * @brief Computes the volume fraction and grain orientation derivatives of all the grains of a mineral.
-           *
-           * @param cpo_index The location where the CPO data starts in the data array.
-           * @param data The data array containing the CPO data.
-           * @param mineral_i The mineral for which to compute the derivatives for.
-           * @param strain_rate_3d The 3D strain rate at the location where the derivative is requested.
-           * @param velocity_gradient_tensor The velocity gradient tensor at the location where the derivative is requested.
-           * @param position the location for which the derivative is requested.
-           * @param temperature The temperature at the location where the derivative is requested.
-           * @param pressure The pressure at the location where the derivative is requested.
-           * @param velocity The veloicty at the location where the derivative is requested.
-           * @param compositions The compositios at the location where the derivative is requested.
-           * @param strain_rate The strain-rate at the location where the derivative is requested.
-           * @param deviatoric_strain_rate The deviatoric strain-rate at the location where the derivative is requested.
-           * @param water_content The water content at the location where the derivative is requested.
-           */
-          std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
-          compute_derivatives(const unsigned int cpo_index,
-                              const ArrayView<double> &data,
-                              const unsigned int mineral_i,
-                              const SymmetricTensor<2,3> &strain_rate_3d,
-                              const Tensor<2,3> &velocity_gradient_tensor,
-                              const Point<dim> &position,
-                              const double temperature,
-                              const double pressure,
-                              const Tensor<1,dim> &velocity,
-                              const std::vector<double> &compositions,
-                              const SymmetricTensor<2,dim> &strain_rate,
-                              const SymmetricTensor<2,dim> &deviatoric_strain_rate,
-                              const double water_content) const;
-
-          /**
-           * @brief Computes the CPO derivatives with the D-Rex 2004 algorithm.
-           *
-           * @param cpo_index The location where the CPO data starts in the data array.
-           * @param data The data array containing the CPO data.
-           * @param mineral_i The mineral for which to compute the derivatives for.
-           * @param strain_rate_3d The 3D strain rate
-           * @param velocity_gradient_tensor The velocity gradient tensor
-           * @param ref_resolved_shear_stress Represent one value per slip plane.
-           * The planes are ordered from weakest to strongest with relative values,
-           * where the inactive plane is infinity strong. So it is a measure of strength
-           * on each slip plane.
-           * @param prevent_nondimensionalization Prevent nondimensializing values internally.
-           * Only for unit testing purposes.
-           */
-          std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
-          compute_derivatives_drex_2004(const unsigned int cpo_index,
-                                        const ArrayView<double> &data,
-                                        const unsigned int mineral_i,
-                                        const SymmetricTensor<2,3> &strain_rate_3d,
-                                        const Tensor<2,3> &velocity_gradient_tensor,
-                                        const std::array<double,4> ref_resolved_shear_stress,
-                                        const bool prevent_nondimensionalization = false) const;
-
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-          /**
-           * Return the number of grains per particle
-           */
-          unsigned int
-          get_number_of_grains() const;
-
-          /**
-           * Return the number of minerals per particle
-           */
-          unsigned int
-          get_number_of_minerals() const;
-
-          /**
-           * @brief Determines the deformation type from the deformation type selector.
-           * If the provided @p deformation_type_selector is a specific deformation type,
-           * the function will simply return the corresponding deformation type. However,
-           * if the @p deformation_type_selector is an algorithm to determine the current
-           * deformation type (e.g. based on measured lab data or analytical models), then
-           * the function computes the appropriate deformation type at the given conditions
-           * and returns the compute deformation type.
-           */
-          DeformationType
-          determine_deformation_type(const DeformationTypeSelector deformation_type_selector,
-                                     const Point<dim> &position,
-                                     const double temperature,
-                                     const double pressure,
-                                     const Tensor<1,dim> &velocity,
-                                     const std::vector<double> &compositions,
-                                     const SymmetricTensor<2,dim> &strain_rate,
-                                     const SymmetricTensor<2,dim> &deviatoric_strain_rate,
-                                     const double water_content) const;
-
-          /**
-           * @brief Computes the deformation type given the stress and water content according to the
-           * table in Karato 2008.
-           */
-          DeformationType
-          determine_deformation_type_karato_2008(const double stress,
-                                                 const double water_content) const;
-
-          /**
-           * @brief Computes the reference resolved shear stress (RRSS) based on the selected deformation type.
-           *
-           * The inactive plane should theoretically be infinitely strong, but this is nummerically not desirable,
-           * so an optional max_value can be set to indicate an inactive plane.
-           *
-           * It is currently designed to return the relative strength of the slip planes for olivine, which are are 4,
-           * but this could be generalized.
-           */
-          std::array<double,4>
-          reference_resolved_shear_stress_from_deformation_type(DeformationType deformation_type,
-                                                                double max_value = 1e60) const;
-
-          /**
-           * @brief Returns the value in the data array representing the deformation type.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i The mineral to get the value of the deformation type for.
-           */
-          inline
-          DeformationType get_deformation_type(const unsigned int cpo_data_position,
-                                               const ArrayView<double> &data,
-                                               const unsigned int mineral_i) const
-          {
-            return static_cast<DeformationType>(data[cpo_data_position + 0 + mineral_i * (n_grains * 10 + 2)]);
-          }
-
-          /**
-           * @brief Sets the value in the data array representing the deformation type.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i The mineral to set the value deformation type for.
-           * @param deformation_type The value of the deformation type to set.
-           */
-          inline
-          void set_deformation_type(const unsigned int cpo_data_position,
-                                    const ArrayView<double> &data,
-                                    const unsigned int mineral_i,
-                                    const DeformationType deformation_type) const
-          {
-            data[cpo_data_position + 0 + mineral_i * (n_grains * 10 + 2)] = static_cast<double>(deformation_type);
-          }
-
-          /**
-           * @brief Returns the value in the data array representing the volume fraction of a mineral.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i The mineral to get the value of the volume fraction of a mineral for.
-           */
-          inline
-          double get_volume_fraction_mineral(const unsigned int cpo_data_position,
-                                             const ArrayView<double> &data,
-                                             const unsigned int mineral_i) const
-          {
-            return data[cpo_data_position + 1 + mineral_i *(n_grains * 10 + 2)];
-          }
-
-          /**
-           * @brief Sets the value in the data array representing the volume fraction of a mineral.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i The mineral to set the value of the volume fraction of a mineral for.
-           * @param volume_fraction_mineral The value of the volume fraction of a mineral to set.
-           */
-          inline
-          void set_volume_fraction_mineral(const unsigned int cpo_data_position,
-                                           const ArrayView<double> &data,
-                                           const unsigned int mineral_i,
-                                           const double volume_fraction_mineral) const
-          {
-            data[cpo_data_position + 1 + mineral_i *(n_grains * 10 + 2)] = volume_fraction_mineral;
-          }
-
-          /**
-           * @brief Returns the value in the data array representing the volume fraction of a grain.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i The mineral to get the value of the volume fraction of a grain for.
-           * @param grain_i The grain to get the value of the volume fraction of.
-           */
-          inline
-          double get_volume_fractions_grains(const unsigned int cpo_data_position,
-                                             const ArrayView<const double> &data,
-                                             const unsigned int mineral_i,
-                                             const unsigned int grain_i) const
-          {
-            return data[cpo_data_position + 2 + grain_i * 10 + mineral_i * (n_grains * 10 + 2)];
-          }
-
-          /**
-           * @brief Sets the value in the data array representing the volume fraction of a grain.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i The mineral to set the value of the volume fraction of a grain for.
-           * @param grain_i The grain to set the value of the volume fraction of.
-           * @param volume_fractions_grains The value of the volume fraction of a grain to set.
-           */
-          inline
-          void set_volume_fractions_grains(const unsigned int cpo_data_position,
-                                           const ArrayView<double> &data,
-                                           const unsigned int mineral_i,
-                                           const unsigned int grain_i,
-                                           const double volume_fractions_grains) const
-          {
-            data[cpo_data_position + 2 + grain_i * 10 + mineral_i * (n_grains * 10 + 2)] = volume_fractions_grains;
-          }
-
-          /**
-           * @brief Gets the rotation matrix for a grain in a mineral.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i The mineral to get the value of the rotation matrix of a grain for.
-           * @param grain_i The grain to get the value of the rotation matrix of.
-           * @return Tensor<2,3> The rotation matrix of a grain in a mineral
-           */
-          inline
-          Tensor<2,3> get_rotation_matrix_grains(const unsigned int cpo_data_position,
-                                                 const ArrayView<const double> &data,
-                                                 const unsigned int mineral_i,
-                                                 const unsigned int grain_i) const
-          {
-            Tensor<2,3> rotation_matrix;
-            for (unsigned int i = 0; i < Tensor<2,3>::n_independent_components ; ++i)
-              {
-                const dealii::TableIndices<2> index = Tensor<2,3>::unrolled_to_component_indices(i);
-                rotation_matrix[index] = data[cpo_data_position + 3 + grain_i * 10 + mineral_i * (n_grains * 10 + 2) + i];
-              }
-            return rotation_matrix;
-          }
-
-          /**
-           * @brief Sets the rotation matrix for a grain in a mineral.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i The mineral to set the value of the rotation matrix of a grain for.
-           * @param grain_i The grain to get the value of the rotation matrix of.
-           * @param rotation_matrix The rotation matrix to set for the grain in the mineral.
-           */
-          inline
-          void set_rotation_matrix_grains(const unsigned int cpo_data_position,
-                                          const ArrayView<double> &data,
-                                          const unsigned int mineral_i,
-                                          const unsigned int grain_i,
-                                          const Tensor<2,3> &rotation_matrix) const
-          {
-            for (unsigned int i = 0; i < Tensor<2,3>::n_independent_components ; ++i)
-              {
-                const dealii::TableIndices<2> index = Tensor<2,3>::unrolled_to_component_indices(i);
-                data[cpo_data_position + 3 + grain_i * 10 + mineral_i * (n_grains * 10 + 2) + i] = rotation_matrix[index];
-              }
-          }
-
-
-        private:
-          /**
-           * Computes a random rotation matrix.
-           */
-          void
-          compute_random_rotation_matrix(Tensor<2,3> &rotation_matrix) const;
-
-          /**
-           * @brief Updates the volume fractions and rotation matrices with a Forward Euler scheme.
-           *
-           * Updates the volume fractions and rotation matrices with a Forward Euler scheme:
-           * $x_t = x_{t-1} + dt * x_{t-1} * \frac{dx_t}{dt}$. The function returns the sum of
-           * the new volume fractions.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i Which mineral to advect for.
-           * @param dt The time step used for the advection step
-           * @param derivatives A pair containing the derivatives for the volume fractions and
-           * orientations respectively.
-           * @return double The sum of all volume fractions.
-           */
-          double
-          advect_forward_euler(const unsigned int cpo_data_position,
-                               const ArrayView<double> &data,
-                               const unsigned int mineral_i,
-                               const double dt,
-                               const std::pair<std::vector<double>, std::vector<Tensor<2,3>>> &derivatives) const;
-
-          /**
-           * @brief Updates the volume fractions and rotation matrices with a Backward Euler scheme.
-           *
-           * Updates the volume fractions and rotation matrices with a Backward Euler scheme:
-           * $x_t = x_{t-1} + dt * x_{t-1} * \frac{dx_t}{dt}$. The function returns the sum of
-           * the new volume fractions.
-           *
-           * @param cpo_data_position The starting index/position of the cpo data in the particle data vector.
-           * @param data The particle data vector.
-           * @param mineral_i Which mineral to advect for.
-           * @param dt The time step used for the advection step
-           * @param derivatives A pair containing the derivatives for the volume fractions and
-           * orientations respectively.
-           * @return double The sum of all volume fractions.
-           */
-          double
-          advect_backward_euler(const unsigned int cpo_data_position,
-                                const ArrayView<double> &data,
-                                const unsigned int mineral_i,
-                                const double dt,
-                                const std::pair<std::vector<double>, std::vector<Tensor<2,3>>> &derivatives) const;
-
-
-          /**
-           * Computes and returns the volume fraction and grain orientation derivatives such that
-           * the grains stay the same size and the orientations rotating passively with the particle.
-           *
-           * @param velocity_gradient_tensor is the velocity gradient tensor at the location of the particle.
-           */
-          std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
-          compute_derivatives_spin_tensor(const Tensor<2,3> &velocity_gradient_tensor) const;
-
-          /**
-           * Random number generator used for initialization of particles
-           */
-          mutable boost::mt19937 random_number_generator;
-          unsigned int random_number_seed;
-
-          unsigned int n_grains;
-
-          unsigned int n_minerals;
-
-          /**
-           * The index of the water composition.
-           */
-          unsigned int water_index;
-
-          /**
-           * A vector containing the deformation type selectors provided by the user.
-           * Should be one of the following: "Olivine: Karato 2008", "Olivine: A-fabric",
-           * "Olivine: B-fabric", "Olivine: C-fabric", "Olivine: D-fabric", "Olivine: E-fabric",
-           * "Enstatite" or "Passive".
-           */
-          std::vector<DeformationTypeSelector> deformation_type_selector;
-
-          /**
-           * Store the volume fraction for each mineral.
-           */
-          std::vector<double> volume_fractions_minerals;
-
-          /**
-           * Advection method for particle properties
-           */
-          AdvectionMethod advection_method;
-
-          /**
-           * What algorithm to use to compute the derivatives
-           */
-          CPODerivativeAlgorithm cpo_derivative_algorithm;
-
-          /**
-           * This value determines the tolerance used for the Backward Euler and
-           * Crank-Nicolson iterations.
-           */
-          double property_advection_tolerance;
-
-          /**
-           * This value determines the the maximum number of iterations used for the
-           * Backward Euler and Crank-Nicolson iterations.
-           */
-          unsigned int property_advection_max_iterations;
-
-          /**
-           * @name D-Rex variables
-           */
-          /** @{ */
-          /**
-           * Stress exponent
-           */
-          double stress_exponent;
-
-          /**
-           * efficiency of nucleation parameter.
-           * lambda_m in equation 8 of Kaminski et al. (2004, Geophys. J. Int)
-           */
-          double nucleation_efficiency;
-
-          /**
-           * An exponent described in equation 10 of Kaminski and Ribe (2001, EPSL)
-           */
-          double exponent_p;
-
-          /**
-           * The Dimensionless Grain Boundary Sliding (GBS) threshold.
-           * This is a grain size threshold below which grain deform by GBS and
-           * become strain-free grains.
-           */
-          double threshold_GBS;
-
-          /**
-           * Dimensionless grain boundary mobility as described by equation 14
-           * in Kaminski and Ribe (2001, EPSL).
-           */
-          double mobility;
-
-          /**
-           * Sets which type of initial grain model is used to create the gain sizes and orientations
-           */
-          CPOInitialGrainsModel initial_grains_model;
-
-          /** @} */
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/elastic_stress.h.bak b/include/aspect/particle/property/elastic_stress.h.bak
deleted file mode 100644
index d4d70d7da7f..00000000000
--- a/include/aspect/particle/property/elastic_stress.h.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_elastic_stress_h
-#define _aspect_particle_property_elastic_stress_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that calculates the viscoelastic stress a particle
-       * has accumulated through time.
-       * The implementation of this property is equivalent to the implementation
-       * for compositional fields that is described in the viscoelastic material
-       * model and elastic stress rheology module.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class ElasticStress : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ElasticStress ();
-
-          void initialize () override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::initialize_one_particle_property()
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::need_update()
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::get_needed_update_flags()
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::get_property_information()
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-        private:
-          /**
-           * Objects that are used to compute the particle property. Since the
-           * object is expensive to create and is needed often it is kept as a
-           * member variable. Because it is changed inside a const member function
-           * (update_particle_property) it has to be mutable, but since it is
-           * only used inside that function and always set before being used
-           * that is not a problem. This implementation is not thread safe,
-           * but it is currently not used in a threaded context.
-           */
-          mutable MaterialModel::MaterialModelInputs<dim> material_inputs;
-          mutable MaterialModel::MaterialModelOutputs<dim> material_outputs;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/elastic_tensor_decomposition.h.bak b/include/aspect/particle/property/elastic_tensor_decomposition.h.bak
deleted file mode 100644
index 76ec5a314e0..00000000000
--- a/include/aspect/particle/property/elastic_tensor_decomposition.h.bak
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- Copyright (C) 2023 by the authors of the ASPECT code.
- This file is part of ASPECT.
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_elastic_tensor_decomposition_h
-#define _aspect_particle_property_elastic_tensor_decomposition_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      namespace Utilities
-      {
-        /**
-         * Return an even permutation based on an index. This is an internal
-         * utilities function, also used by the unit tester.
-         */
-        std::array<unsigned int, 3>
-        indexed_even_permutation(const unsigned int index);
-
-        /**
-         * Computes the Voigt stiffness tensor from the elastic tensor.
-         * The Voigt stiffness tensor (see Browaeys and Chevrot, 2004)
-         * defines the stress needed to cause an isotropic strain in the
-         * material.
-         */
-        SymmetricTensor<2,3>
-        compute_voigt_stiffness_tensor(const SymmetricTensor<2,6> &elastic_tensor);
-
-        /**
-         * Computes the dilatation stiffness tensor from the elastic tensor
-         * The dilatational stiffness tensor (see Browaeys and Chevrot, 2004)
-         * defines the stress to cause isotropic dilatation in the material.
-         */
-        SymmetricTensor<2,3>
-        compute_dilatation_stiffness_tensor(const SymmetricTensor<2,6> &elastic_tensor);
-
-        /**
-         * Computes the Symmetry Cartesian Coordinate System (SCCS).
-         *
-         * This is based on Browaeys and Chevrot (2004), GJI (doi: 10.1111/j.1365-246X.2004.024115.x),
-         * which states at the end of paragraph 3.3 that "... an important property of an orthogonal projection
-         * is that the distance between a vector $X$ and its orthogonal projection $X_H = p(X)$ on a given
-         * subspace is minimum. These two features ensure that the decomposition is optimal once a 3-D Cartesian
-         * coordinate system is chosen.". The other property they talk about is that "The space of elastic
-         * vectors has a finite dimension [...], i.e. using a different norm from eq. 2.3 will change distances
-         * but not the resulting decomposition.".
-         *
-         * With the three SCCS directions, the elastic tensor can be decomposed into the different
-         * symmetries in those three SCCS direction, that is, triclinic, monoclinic, orthorhombic,
-         * tetragonal, hexagonal, and isotropic (Browaeys & Chevrot, 2004).
-         *
-         * The dilatation_stiffness_tensor defines the stress to cause isotropic dilatation in the material.
-         * The voigt_stiffness_tensor defines the stress needed to cause an isotropic strain in the material
-         */
-        Tensor<2,3> compute_unpermutated_SCCS(const SymmetricTensor<2,3> &dilatation_stiffness_tensor,
-                                              const SymmetricTensor<2,3> &voigt_stiffness_tensor);
-
-        /**
-         * Uses the Symmetry Cartesian Coordinate System (SCCS) to try the different permutations to
-         * determine what is the best projection.
-         * This is based on Browaeys and Chevrot (2004), GJI (doi: 10.1111/j.1365-246X.2004.024115.x),
-         * which states at the end of paragraph 3.3 that "... an important property of an orthogonal projection
-         * is that the distance between a vector $X$ and its orthogonal projection $X_H = p(X)$ on a given
-         * subspace is minimum. These two features ensure that the decomposition is optimal once a 3-D Cartesian
-         * coordinate system is chosen.". The other property they talk about is that "The space of elastic
-         * vectors has a finite dimension [...], i.e. using a different norm from eq. 2.3 will change distances
-         * but not the resulting decomposition.".
-         */
-        std::array<std::array<double,3>,7>
-        compute_elastic_tensor_SCCS_decompositions(
-          const Tensor<2,3> &unpermutated_SCCS,
-          const SymmetricTensor<2,6> &elastic_matrix);
-
-
-        /**
-         * The tensors below can be used to project matrices to different symmetries.
-         * See Browaeys and Chevrot, 2004.
-         */
-        static const SymmetricTensor<2,21> projection_matrix_triclinic_to_monoclinic(
-          Tensor<2,21>(
-        {
-          {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
-          {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
-          {0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
-          {0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
-          {0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
-          {0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
-          {0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
-          {0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
-          {0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
-          {0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0},
-          {0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0},
-          {0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0},
-          {0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0},
-          {0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0},
-          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0},
-          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0},
-          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0},
-          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0},
-          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
-          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0},
-          {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
-        })
-        );
-        static const SymmetricTensor<2,9> projection_matrix_monoclinic_to_orthorhombic(
-          Tensor<2,9>(
-        {
-          {1,0,0,0,0,0,0,0,0},
-          {0,1,0,0,0,0,0,0,0},
-          {0,0,1,0,0,0,0,0,0},
-          {0,0,0,1,0,0,0,0,0},
-          {0,0,0,0,1,0,0,0,0},
-          {0,0,0,0,0,1,0,0,0},
-          {0,0,0,0,0,0,1,0,0},
-          {0,0,0,0,0,0,0,1,0},
-          {0,0,0,0,0,0,0,0,1}
-        })
-        );
-        static const SymmetricTensor<2,9> projection_matrix_orthorhombic_to_tetragonal(
-          Tensor<2,9>(
-        {
-          {0.5,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
-          {0.5,0.5,0.0,0.0,0.0,0.0,0.0,0.0,0.0},
-          {0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0},
-          {0.0,0.0,0.0,0.5,0.5,0.0,0.0,0.0,0.0},
-          {0.0,0.0,0.0,0.5,0.5,0.0,0.0,0.0,0.0},
-          {0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0},
-          {0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.5,0.0},
-          {0.0,0.0,0.0,0.0,0.0,0.0,0.5,0.5,0.0},
-          {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0}
-        })
-        );
-        static const SymmetricTensor<2,9> projection_matrix_tetragonal_to_hexagonal(
-          Tensor<2,9>(
-        {
-          {3./8.           , 3./8.           , 0.0, 0.0, 0.0, 1./(4.*sqrt(2.))  , 0.0, 0.0, 1./4.            },
-          {3./8.           , 3./8.           , 0.0, 0.0, 0.0, 1./(4.*sqrt(2.))  , 0.0, 0.0, 1./4.            },
-          {0.0             , 0.0             , 1.0, 0.0, 0.0, 0.0               , 0.0, 0.0, 0.0              },
-          {0.0             , 0.0             , 0.0, 0.5, 0.5, 0.0               , 0.0, 0.0, 0.0              },
-          {0.0             , 0.0             , 0.0, 0.5, 0.5, 0.0               , 0.0, 0.0, 0.0              },
-          {1./(4.*sqrt(2.)), 1./(4.*sqrt(2.)), 0.0, 0.0, 0.0, 3./4.             , 0.0, 0.0, -1./(2.*sqrt(2.))},
-          {0.0             , 0.0             , 0.0, 0.0, 0.0, 0.0               , 0.5, 0.5, 0.0              },
-          {0.0             , 0.0             , 0.0, 0.0, 0.0, 0.0               , 0.5, 0.5, 0.0              },
-          {1./4.           , 1./4.           , 0.0, 0.0, 0.0, -1./(2.*sqrt(2.)) , 0.0, 0.0, 0.5              }
-        })
-        );
-        static const SymmetricTensor<2,9> projection_matrix_hexagonal_to_isotropic(
-          Tensor<2,9>(
-        {
-          {3./15.      , 3./15.      , 3./15.      , sqrt(2.)/15. , sqrt(2.)/15. , sqrt(2.)/15. , 2./15.       , 2./15.       , 2./15.        },
-          {3./15.      , 3./15.      , 3./15.      , sqrt(2.)/15. , sqrt(2.)/15. , sqrt(2.)/15. , 2./15.       , 2./15.       , 2./15.        },
-          {3./15.      , 3./15.      , 3./15.      , sqrt(2.)/15. , sqrt(2.)/15. , sqrt(2.)/15. , 2./15.       , 2./15.       , 2./15.        },
-          {sqrt(2.)/15., sqrt(2.)/15., sqrt(2.)/15., 4./15.       , 4./15.       , 4./15.       , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15. },
-          {sqrt(2.)/15., sqrt(2.)/15., sqrt(2.)/15., 4./15.       , 4./15.       , 4./15.       , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15. },
-          {sqrt(2.)/15., sqrt(2.)/15., sqrt(2.)/15., 4./15.       , 4./15.       , 4./15.       , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15. },
-          {2./15.      , 2./15.      , 2./15.      , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15., 1./5.        , 1./5.        , 1./5.         },
-          {2./15.      , 2./15.      , 2./15.      , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15., 1./5.        , 1./5.        , 1./5.         },
-          {2./15.      , 2./15.      , 2./15.      , -sqrt(2.)/15., -sqrt(2.)/15., -sqrt(2.)/15., 1./5.        , 1./5.        , 1./5.         }
-        })
-        );
-      }
-
-      /**
-       * Computes several properties of a elastic tensor stored on a particle.
-       * These include the eigenvectors and conversions between different forms of 4th order tensors.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class ElasticTensorDecomposition : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor
-           */
-          ElasticTensorDecomposition() = default;
-
-          /**
-           * Initialization function. This function is called once at the
-           * beginning of the program after parse_parameters is run.
-           */
-          void
-          initialize () override;
-
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * Update function. This function is called every time an update is
-           * request by need_update() for every particle for every property.
-           * It is obvious that
-           * this function is called a lot, so its code should be efficient.
-           * The interface provides a default implementation that does nothing,
-           * therefore derived plugins that do not require an update do not
-           * need to implement this function.
-           *
-           * @param [in] data_position An unsigned integer that denotes which
-           * component of the particle property vector is associated with the
-           * current property. For properties that own several components it
-           * denotes the first component of this property, all other components
-           * fill consecutive entries in the @p particle_properties vector.
-           *
-           * @param [in] solution The values of the solution variables at the
-           * current particle position.
-           *
-           * @param [in] gradients The gradients of the solution variables at
-           * the current particle position.
-           *
-           * @param [in,out] particle The particle that is updated within
-           * the call of this function. The particle location can be accessed
-           * using particle->get_location() and its properties using
-           * particle->get_properties().
-           */
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This function tells the particle manager that
-           * we need to update particle properties.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-        private:
-          unsigned int cpo_elastic_tensor_data_position;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/function.h.bak b/include/aspect/particle/property/function.h.bak
deleted file mode 100644
index f45d52de16c..00000000000
--- a/include/aspect/particle/property/function.h.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_function_h
-#define _aspect_particle_property_function_h
-
-#include <aspect/particle/property/interface.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that initializes particle properties based on a
-       * functional description provided in the input file.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class Function : public Interface<dim>
-      {
-        public:
-          Function();
-
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * A function object representing the particle property.
-           */
-          std::unique_ptr<Functions::ParsedFunction<dim>> function;
-
-          /**
-           * A private variable that stores the number of particle property
-           * function components.
-           */
-          unsigned int n_components;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/grain_size.h.bak b/include/aspect/particle/property/grain_size.h.bak
deleted file mode 100644
index bdfa42aac07..00000000000
--- a/include/aspect/particle/property/grain_size.h.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_grain_size_h
-#define _aspect_particle_property_grain_size_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that calculates the evolving grain size of a particle.
-       * The implementation of this property is equivalent to the implementation
-       * for compositional fields that is described in the grain_size material
-       * model.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class GrainSize : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          GrainSize ();
-
-          /**
-           * Initialize variables that stay constant
-           * during a model.
-           */
-          void initialize () override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::initialize_one_particle_property()
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_properties()
-           */
-          void
-          update_particle_properties (const unsigned int data_position,
-                                      const std::vector<Vector<double>> &solution,
-                                      const std::vector<std::vector<Tensor<1,dim>>> &gradients,
-                                      typename ParticleHandler<dim>::particle_iterator_range &particles) const override;
-
-          /**
-           * Returns an enum, which determines how this particle property is
-           * initialized for particles that are created later than the initial
-           * particle generation. For this property the value of
-           * generated particles is interpolated from existing particles, unless
-           * the particle is in a boundary cell that has a Dirichlet boundary
-           * condition, in which case it uses the boundary condition value.
-           */
-          InitializationModeForLateParticles
-          late_initialization_mode () const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::need_update()
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::get_needed_update_flags()
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::get_property_information()
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-        private:
-          /**
-           * Objects that are used to compute the particle property. Since the
-           * object is expensive to create and is needed often it is kept as a
-           * member variable. Because it is changed inside a const member function
-           * (update_particle_property) it has to be mutable, but since it is
-           * only used inside that function and always set before being used
-           * that is not a problem. This implementation is not thread safe,
-           * but it is currently not used in a threaded context.
-           */
-          mutable MaterialModel::MaterialModelInputs<dim> material_inputs;
-          mutable MaterialModel::MaterialModelOutputs<dim> material_outputs;
-
-          /**
-           * The index of the compositional field that stores the grain size.
-           */
-          unsigned int grain_size_index;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/initial_composition.h.bak b/include/aspect/particle/property/initial_composition.h.bak
deleted file mode 100644
index e59b2c67ca1..00000000000
--- a/include/aspect/particle/property/initial_composition.h.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_initial_composition_h
-#define _aspect_particle_property_initial_composition_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that initializes particle properties based on a
-       * functional description provided in the input file.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class InitialComposition : public Interface<dim>, public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * Returns an enum, which determines how this particle property is
-           * initialized for particles that are created later than the initial
-           * particle generation. For this property the value of
-           * generated particles is interpolated from existing particles, unless
-           * the particle is in a boundary cell that has a Dirichlet boundary
-           * condition, in which case it uses the boundary condition value.
-           */
-          InitializationModeForLateParticles
-          late_initialization_mode () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/initial_position.h.bak b/include/aspect/particle/property/initial_position.h.bak
deleted file mode 100644
index d9d86d9862b..00000000000
--- a/include/aspect/particle/property/initial_position.h.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_initial_position_h
-#define _aspect_particle_property_initial_position_h
-
-#include <aspect/particle/property/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that initializes particle properties based on the
-       * initial position of the particles.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class InitialPosition : public Interface<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/integrated_strain.h.bak b/include/aspect/particle/property/integrated_strain.h.bak
deleted file mode 100644
index e773dd9089f..00000000000
--- a/include/aspect/particle/property/integrated_strain.h.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_integrated_strain_h
-#define _aspect_particle_property_integrated_strain_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that integrates the finite strain that a particle has
-       * experienced.
-       * The implementation of this property is equivalent to the implementation
-       * for compositional fields that is described in the cookbook
-       * finite_strain <code>cookbooks/finite_strain/finite_strain.cc</code>.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class IntegratedStrain : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties every time step.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * The integrated strains needs the gradients of the velocity.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/integrated_strain_invariant.h.bak b/include/aspect/particle/property/integrated_strain_invariant.h.bak
deleted file mode 100644
index 5ef0c8e78d9..00000000000
--- a/include/aspect/particle/property/integrated_strain_invariant.h.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_integrated_strain_invariant_h
-#define _aspect_particle_property_integrated_strain_invariant_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that calculates the finite strain invariant a particle has
-       * experienced. The implementation of this property is equivalent to the
-       * implementation for compositional fields that is located in the plugin
-       * <code>benchmarks/buiter_et_al_2008_jgr/plugin/finite_strain_invariant.cc</code>.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class IntegratedStrainInvariant : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties every time step.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * The integrated strains needs the gradients of the velocity.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/interface.h.bak b/include/aspect/particle/property/interface.h.bak
deleted file mode 100644
index 9d943da535a..00000000000
--- a/include/aspect/particle/property/interface.h.bak
+++ /dev/null
@@ -1,816 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_interface_h
-#define _aspect_particle_property_interface_h
-
-#include <aspect/particle/interface.h>
-#include <aspect/global.h>
-
-#include <aspect/particle/interpolator/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/particles/particle.h>
-#include <deal.II/particles/particle_handler.h>
-#include <deal.II/particles/property_pool.h>
-#include <deal.II/fe/fe_update_flags.h>
-
-#include <memory>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      using namespace dealii::Particles;
-
-      /**
-       * This class is used to store all the necessary information to translate
-       * between the data structure of the particle properties (a flat vector of
-       * doubles) and the semantic meaning of these properties. It contains
-       * information about the three layers of particle property information:
-       *
-       * By 'property plugins' we mean each separate class that is derived from
-       * aspect::Particle::Property::Interface<dim>, and that is selected in
-       * the input file. This means in any model there are as many property
-       * plugins as entries in the 'List of particle properties' input parameter.
-       *
-       * Each plugin can create one or more 'property fields'. Property fields
-       * are interpreted as distinctly named particle properties. Most plugins
-       * contain only one field, but some group distinctly named properties
-       * into groups, such as the 'InitialComposition' plugin, which creates
-       * one property field per compositional field and names the property
-       * fields according to the compositional field names. When writing particle
-       * data to output files each 'property field' will be written into a
-       * separate output field.
-       *
-       * Last each field can contain several 'property components'
-       * if it represents a vector or tensor property. These components can
-       * not be named individually, but it is still important to be able to
-       * know how many components belong to a particular field.
-       *
-       * Information that is often required by other algorithms is for example
-       * the number of components (= number of doubles in the property vector)
-       * of a particle field or plugin, and its position within the particle
-       * property vector. All of this information might be required within
-       * loops over all fields, or for a specific field either identified by
-       * its index, or by its name.
-       *
-       * @ingroup ParticleProperties
-       */
-      class ParticlePropertyInformation
-      {
-        public:
-          /**
-           * Empty default constructor.
-           */
-          ParticlePropertyInformation();
-
-          /**
-           * Constructor. Initialize the various arrays of this structure with the
-           * given property information collected from the individual plugins.
-           *
-           * @p property_information A vector that contains one vector per
-           * property plugin. Each of these vectors contains one or more pairs
-           * that represent a property field name and the number of components
-           * for this field. The input argument can be constructed by
-           * concatenating the output of the
-           * Particle::Property::Interface<dim>::get_property_information()
-           * functions of all property plugins.
-           */
-          ParticlePropertyInformation(const std::vector<std::vector<std::pair<std::string,unsigned int>>> &property_information);
-
-          /**
-           * Checks if the particle property specified by @p name exists
-           * in this model.
-           */
-          bool
-          fieldname_exists(const std::string &name) const;
-
-          /**
-           * Get the field index of the particle property specified by @p name.
-           */
-          unsigned int
-          get_field_index_by_name(const std::string &name) const;
-
-          /**
-           * Get the field index of the particle property specified by @p name.
-           */
-          std::string
-          get_field_name_by_index(const unsigned int field_index) const;
-
-          /**
-           * Get the data position of the first component of the particle
-           * property specified by @p name in the property vector of a particle.
-           */
-          unsigned int
-          get_position_by_field_name(const std::string &name) const;
-
-          /**
-           * Get the number of components of the particle property specified
-           * by @p name.
-           */
-          unsigned int
-          get_components_by_field_name(const std::string &name) const;
-
-          /**
-           * Get the data position of the first component of the particle
-           * property specified by @p field_index in the property vector
-           * of a particle.
-           */
-          unsigned int
-          get_position_by_field_index(const unsigned int field_index) const;
-
-          /**
-           * Get the number of components of the particle property specified
-           * by @p field_index.
-           */
-          unsigned int
-          get_components_by_field_index(const unsigned int field_index) const;
-
-          /**
-           * Get the data position of the first component of the particle
-           * property specified by @p plugin_index in the property vector
-           * of a particle.
-           */
-          unsigned int
-          get_position_by_plugin_index(const unsigned int plugin_index) const;
-
-          /**
-           * Get the number of components of the particle property specified
-           * by @p plugin_index.
-           */
-          unsigned int
-          get_components_by_plugin_index(const unsigned int plugin_index) const;
-
-          /**
-           * Get the number of fields of the particle property specified
-           * by @p plugin_index.
-           */
-          unsigned int
-          get_fields_by_plugin_index(const unsigned int plugin_index) const;
-
-
-          /**
-           * Return the number of active particle property plugins.
-           */
-          unsigned int
-          n_plugins() const;
-
-          /**
-           * Return the number of active particle property fields.
-           */
-          unsigned int
-          n_fields() const;
-
-          /**
-           * Return the number of active particle property components.
-           */
-          unsigned int
-          n_components() const;
-
-        private:
-          /**
-           * A vector of all property field names.
-           */
-          std::vector<std::string> field_names;
-
-          /**
-           * A vector containing the number of components per property field.
-           */
-          std::vector<unsigned int> components_per_field;
-
-          /**
-           * A vector containing the position index of the first data component
-           * of each field in the property vector of every particle.
-           */
-          std::vector<unsigned int> position_per_field;
-
-          /**
-           * A vector containing the number of property fields per property
-           * plugin.
-           */
-          std::vector<unsigned int> fields_per_plugin;
-
-          /**
-           * A vector containing the number of components per property plugin.
-           */
-          std::vector<unsigned int> components_per_plugin;
-
-          /**
-           * A vector containing the position index of the first data component
-           * of each plugin in the property vector of every particle.
-           */
-          std::vector<unsigned int> position_per_plugin;
-
-          /**
-           * The number of doubles needed to represent a particle's
-           * additional properties.
-           */
-          unsigned int number_of_components;
-
-          /**
-           * The number of distinctly named particle property fields.
-           */
-          unsigned int number_of_fields;
-
-          /**
-           * The number of active particle property plugins.
-           */
-          unsigned int number_of_plugins;
-      };
-
-      enum UpdateTimeFlags
-      {
-        /**
-         * Never update the initially set properties. This is the default
-         * behavior, which is sufficient for particle properties that are
-         * set at the beginning of the model and constant for the whole
-         * simulation time.
-         */
-        update_never,
-        /**
-         * Update the particle properties before every output. This is
-         * sufficient for all passive particle properties that depend on the
-         * current solution, like the current velocity or pressure.
-         */
-        update_output_step,
-        /**
-         * Update the particle properties every nonlinear iteration. This is only necessary
-         * if the properties at the output time depend on some sort of time
-         * integration of solution properties or time varying particle
-         * properties are used while solving the model problem.
-         */
-        update_time_step
-      };
-
-      /**
-       * This enum controls how to initialize the properties of particles that
-       * have been added later than the initial particle creation, e.g. to
-       * improve the load balance or to prevent empty cells.
-       */
-      enum InitializationModeForLateParticles
-      {
-        /**
-         * Initialize the particle as if it were created at the beginning of
-         * the model at its current position with the current solution.
-         */
-        initialize,
-        /**
-         * Use the interpolated properties of the surrounding particles as
-         * calculated by the selected interpolator.
-         */
-        interpolate,
-        /**
-         * Use the interpolated properties of the surrounding particles as
-         * calculated by the selected interpolator except for particles in
-         * boundary cells. These will use the boundary condition of the
-         * compositional fields instead. This mode only makes sense for
-         * properties that are associated with compositional fields through
-         * the parameter 'Compositional fields/Mapped particle properties'.
-         */
-        interpolate_respect_boundary,
-        /**
-         * Initialize the particle properties to zero. If the property is
-         * updated over time its update function is called as usual, if not
-         * the property will remain zero throughout the model run.
-         */
-        initialize_to_zero
-      };
-
-      /**
-       * Interface provides an example of how to extend the Particle class to
-       * include related particle data. This allows users to attach
-       * scalars/vectors/tensors/etc to particles and ensure they are
-       * transmitted correctly over MPI and written to output files.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class Interface : public ParticleInterfaceBase
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          virtual
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const;
-
-          /**
-           * Update function. This function is called every time an update is
-           * requested by need_update() for every cell for every property.
-           * It is expected to update the properties of all particles in the
-           * given range @p particles, which are all in one cell.
-           * It is obvious that
-           * this function is called a lot, so its code should be efficient.
-           * The interface provides a default implementation that does nothing,
-           * therefore derived plugins that do not require an update do not
-           * need to implement this function.
-           *
-           * @param [in] data_position An unsigned integer that denotes which
-           * component of each particle property vector is associated with the
-           * current property. For properties that own several components it
-           * denotes the first component of this property, all other components
-           * fill consecutive entries in the properties vector.
-           *
-           * @param [in] solution A vector of values of the solution variables
-           * at the given particle positions.
-           *
-           * @param [in] gradients A vector of gradients of the solution
-           * variables at the given particle positions.
-           *
-           * @param [in,out] particles The particles that are to be updated
-           * within this function.
-           */
-          virtual
-          void
-          update_particle_properties (const unsigned int data_position,
-                                      const std::vector<Vector<double>> &solution,
-                                      const std::vector<std::vector<Tensor<1,dim>>> &gradients,
-                                      typename ParticleHandler<dim>::particle_iterator_range &particles) const;
-
-          /**
-           * Update function. This function is called every time an update is
-           * request by need_update() for every particle for every property.
-           * It is obvious that
-           * this function is called a lot, so its code should be efficient.
-           * The interface provides a default implementation that does nothing,
-           * therefore derived plugins that do not require an update do not
-           * need to implement this function.
-           *
-           * @param [in] data_position An unsigned integer that denotes which
-           * component of the particle property vector is associated with the
-           * current property. For properties that own several components it
-           * denotes the first component of this property, all other components
-           * fill consecutive entries in the @p particle_properties vector.
-           *
-           * @param [in] solution The values of the solution variables at the
-           * current particle position.
-           *
-           * @param [in] gradients The gradients of the solution variables at
-           * the current particle position.
-           *
-           * @param [in,out] particle The particle that is updated within
-           * the call of this function. The particle location can be accessed
-           * using particle->get_location() and its properties using
-           * particle->get_properties().
-           *
-           * @deprecated Use update_particle_properties() instead.
-           */
-          DEAL_II_DEPRECATED
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const;
-
-
-          /**
-           * Returns an enum, which determines at what times particle properties
-           * are updated. The default implementation returns update_never, which
-           * signals that particle properties should never be updated.
-           * See the documentation of UpdateTimeFlags for a list of possible
-           * values and examples for their use. Every
-           * plugin that implements this function should return the value
-           * appropriate for its purpose, unless it does not need any update,
-           * which is the default. This option saves considerable computation
-           * time in cases, when no plugin needs to update particle properties
-           * over time.
-           */
-          virtual
-          UpdateTimeFlags
-          need_update () const;
-
-          /**
-           * Return which data has to be provided to update all properties.
-           * Note that particle properties can only ask for update_default
-           * (no data), update_values (solution values), and update_gradients
-           * (solution gradients). All other update flags will have no effect.
-           *
-           * @return The necessary update flags for this particle property.
-           */
-          virtual
-          UpdateFlags
-          get_needed_update_flags () const;
-
-          /**
-           * Returns an enum, which determines how this particle property is
-           * initialized for particles that are created later than the initial
-           * particle generation, e.g. to balance the particle load or prevent
-           * empty cells. The default implementation returns
-           * interpolate, which will use the particle interpolator to
-           * set the new particle properties to a value that is interpolated
-           * from the other particles in the cell.
-           * See the documentation of InitializationModeForLateParticles for a
-           * list of possible values and examples for their use. Every
-           * plugin that implements this function should return the value
-           * appropriate for its purpose, unless it wants to use the default
-           * value.
-           */
-          virtual
-          InitializationModeForLateParticles
-          late_initialization_mode () const;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires. Derived classes need to implement this
-           * function.
-           *
-           * The purpose of this function is to return a vector of pairs of a
-           * property name and the number of components associated with this
-           * name (e.g. 1 for scalar properties,
-           * n for n-dimensional vectors).
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          virtual
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const = 0;
-      };
-
-      /**
-       * A particle property that provides storage space for
-       * the properties that particle integrators need to
-       * store. This is an internal property that is not
-       * intended for use outside of the particle integrators
-       * and that will not be written to output files.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class IntegratorProperties : public Interface<dim>
-      {
-        public:
-          /**
-           * Initialization function. Since these properties are set and used
-           * by the integrator this function only resizes them to the correct
-           * size, but does not need to do any initialization.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires. This depends on the chosen integration scheme.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-          /**
-           * Read the parameters this class needs to determine which integrator is used,
-           * and therefore how many properties to reserve.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * The number of integrator properties to store. This variable is initialized in
-           * parse_parameters().
-           */
-          unsigned int n_integrator_properties;
-      };
-
-
-
-      /**
-       * Manager class of properties - This class sets the data of the
-       * collection of particles and updates it over time if requested by the
-       * user selected properties.
-       */
-      template <int dim>
-      class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Empty constructor for Manager
-           */
-          Manager ();
-
-          /**
-           * Destructor for Manager
-           */
-          ~Manager () override;
-
-          /**
-           * Initialization function. This function is called once at the
-           * beginning of the program after parse_parameters is run.
-           */
-          void
-          initialize () override;
-
-          /**
-           * Update function. This function is called once at the
-           * beginning of each timestep.
-           */
-          void
-          update () override;
-
-          /**
-           * Initialization function for particle properties. This function is
-           * called once for each of the particles of a particle
-           * collection after it was created.
-           */
-          void
-          initialize_one_particle (typename ParticleHandler<dim>::particle_iterator &particle) const;
-
-          /**
-           * Initialization function for particle properties. This function is
-           * called once for each of the particles of a particle
-           * collection that were created later than the initial particle
-           * generation.
-           */
-          std::vector<double>
-          initialize_late_particle (const Point<dim> &particle_location,
-                                    const ParticleHandler<dim> &particle_handler,
-                                    const Interpolator::Interface<dim> &interpolator,
-                                    const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell = typename parallel::distributed::Triangulation<dim>::active_cell_iterator()) const;
-
-          /**
-           * Update function for particle properties. This function is
-           * called once every time step for every cell.
-           *
-           * @param particles The particles that are to be updated within
-           * this function.
-           * @param solution The values of the solution variables at the
-           * given particle positions.
-           * @param gradients The gradients of the solution variables at
-           * the given particle positions.
-           */
-          void
-          update_particles (typename ParticleHandler<dim>::particle_iterator_range &particles,
-                            const std::vector<Vector<double>> &solution,
-                            const std::vector<std::vector<Tensor<1,dim>>> &gradients) const;
-
-          /**
-           * Returns an enum, which denotes at what time this class needs to
-           * update particle properties. The result of this class is a
-           * combination of the need_update() functions of all individual
-           * properties that are selected. More precise, it will choose to
-           * update the particle properties as often as the plugin that needs the
-           * most frequent update option requires. This saves considerable
-           * computation time, e.g. in cases when no plugin needs to update particle
-           * properties over time, because the solution does not need to be
-           * evaluated in this case.
-           */
-          UpdateTimeFlags
-          need_update () const;
-
-          /**
-           * Return which data has to be provided to update all properties.
-           * Note that particle properties can only ask for update_default
-           * (no data), update_values (solution values), and update_gradients
-           * (solution gradients). All other update flags will have no effect.
-           */
-          UpdateFlags
-          get_needed_update_flags () const;
-
-          /**
-           * Checks if the particle plugin specified by @p name exists
-           * in this model.
-           */
-          bool
-          plugin_name_exists(const std::string &name) const;
-
-          /**
-           * Checks if the particle property plugin specified by @p first
-           * is executed before another particle property plugin specified
-           * by @p second.
-           *
-           * Throws an assert when one of the plugin names does not
-           * exist. You can use the function plugin_name_exists() to
-           * check in advance whether a plugin exists
-           */
-          bool
-          check_plugin_order(const std::string &first, const std::string &second) const;
-
-          /**
-           * Get the plugin index of the particle plugin specified by @p name.
-           */
-          unsigned int get_plugin_index_by_name(const std::string &name) const;
-
-          /**
-           * Go through the list of all particle properties that have been selected
-           * in the input file (and are consequently currently active) and return
-           * true if one of them has the desired type specified by the template
-           * argument.
-           *
-           * This function can only be called if the given template type (the first template
-           * argument) is a class derived from the Interface class in this namespace.
-           */
-          template <typename ParticlePropertyType,
-                    typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,ParticlePropertyType>::value>>
-          bool
-          has_matching_property () const;
-
-          /**
-           * Go through the list of all particle properties that have been selected
-           * in the input file (and are consequently currently active) and see
-           * if one of them has the type specified by the template
-           * argument or can be cast to that type. If so, return a reference
-           * to it. If no property is active that matches the given type,
-           * throw an exception.
-           *
-           * This function can only be called if the given template type (the first template
-           * argument) is a class derived from the Interface class in this namespace.
-           */
-          template <typename ParticlePropertyType,
-                    typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,ParticlePropertyType>::value>>
-          const ParticlePropertyType &
-          get_matching_property () const;
-
-          /**
-           * Get the number of components required to represent this particle's
-           * properties.
-           *
-           * @return Number of doubles required to represent this particle's
-           * additional properties.
-           */
-          unsigned int
-          get_n_property_components () const;
-
-          /**
-           * Get the size in number of bytes required to represent this
-           * particle's properties for communication. This is essentially the
-           * space needed for the property components plus the space for the
-           * particle position and the space needed for its ID.
-           *
-           * @return Number of bytes required to represent this particle.
-           */
-          std::size_t
-          get_particle_size () const;
-
-          /**
-           * Get the names and number of components of particle properties.
-           *
-           * @return A vector of pairs for each property name and the
-           * corresponding number of components attached to particles.
-           */
-          const ParticlePropertyInformation &
-          get_data_info() const;
-
-          /**
-           * Get the position of the property specified by name in the property
-           * vector of the particles.
-           *
-           * @deprecated This function will be replaced by
-           * ParticlePropertyInformation::get_position_by_field_name(name)
-           */
-          DEAL_II_DEPRECATED
-          unsigned int
-          get_property_component_by_name(const std::string &name) const;
-
-          /**
-           * A function that is used to register particle property
-           * objects in such a way that the Manager can deal with all of them
-           * without having to know them by name. This allows the files in which
-           * individual properties are implemented to register these
-           * properties, rather than also having to modify the Manager class
-           * by adding the new properties class.
-           *
-           * @param name The name under which this particle property
-           * is to be called in parameter files.
-           * @param description A text description of what this particle property
-           *  does and that will be listed in the documentation of the
-           * parameter file.
-           * @param declare_parameters_function A pointer to a function that
-           * declares the parameters for this property.
-           * @param factory_function A pointer to a function that creates such a
-           * property object and returns a pointer to it.
-           */
-          static
-          void
-          register_particle_property (const std::string &name,
-                                      const std::string &description,
-                                      void (*declare_parameters_function) (ParameterHandler &),
-                                      std::unique_ptr<Property::Interface<dim>> (*factory_function) ());
-
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-          /**
-           * @brief Set the particle world index for all particle properties
-           *
-           * @param particle_world_index The index of the particle world.
-           */
-          void set_particle_world_index(unsigned int particle_world_index);
-
-          /**
-           * For the current plugin subsystem, write a connection graph of all of the
-           * plugins we know about, in the format that the
-           * programs dot and neato understand. This allows for a visualization of
-           * how all of the plugins that ASPECT knows about are interconnected, and
-           * connect to other parts of the ASPECT code.
-           *
-           * @param output_stream The stream to write the output to.
-           */
-          static
-          void
-          write_plugin_graph (std::ostream &output_stream);
-
-        private:
-          /**
-           * Stores the names of the plugins which are present
-           * in the order they are executed.
-           */
-          std::vector<std::string> plugin_names;
-
-          /**
-           * A class that stores all information about the particle properties,
-           * their association with property plugins and their storage pattern.
-           */
-          ParticlePropertyInformation property_information;
-      };
-
-      /* -------------------------- inline and template functions ---------------------- */
-
-
-      template <int dim>
-      template <typename ParticlePropertyType, typename>
-      inline
-      bool
-      Manager<dim>::has_matching_property () const
-      {
-        return this->template has_matching_plugin_object<ParticlePropertyType>();
-      }
-
-
-      template <int dim>
-      template <typename ParticlePropertyType, typename>
-      inline
-      const ParticlePropertyType &
-      Manager<dim>::get_matching_property () const
-      {
-        return this->template get_matching_plugin_object<ParticlePropertyType>();
-      }
-
-
-      /**
-       * Given a class name, a name, and a description for the parameter file for
-       * a particle property, register it with the aspect::Particle:: class.
-       *
-       * @ingroup Particle
-       */
-#define ASPECT_REGISTER_PARTICLE_PROPERTY(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_PARTICLE_PROPERTY_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Property::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::Particle::Property::Manager<2>::register_particle_property, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Property::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::Particle::Property::Manager<3>::register_particle_property, \
-                                name, description); \
-  }
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/melt_particle.h.bak b/include/aspect/particle/property/melt_particle.h.bak
deleted file mode 100644
index 52a8ce8efbf..00000000000
--- a/include/aspect/particle/property/melt_particle.h.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_melt_particle_h
-#define _aspect_particle_property_melt_particle_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * Implementation of a plugin in which the particle
-       * property is defined as presence of melt above the
-       * melt transport threshold. This property is set
-       * to 0 if melt is not present and set to 1 if melt
-       * is present.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class MeltParticle : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties over time.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * The pressure and temperature need the values of their variables.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          double threshold_for_melt_presence;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/pT_path.h.bak b/include/aspect/particle/property/pT_path.h.bak
deleted file mode 100644
index 6c6331a883a..00000000000
--- a/include/aspect/particle/property/pT_path.h.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_pT_path_h
-#define _aspect_particle_property_pT_path_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * Implementation of a plugin in which the particle
-       * property is defined as the current pressure and
-       * temperature at this position. This can be used
-       * to generate pressure-temperature paths of
-       * material points over time.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class PTPath : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * beginning of the program after parse_parameters is run.
-           *
-           * This specific function makes sure that the objects that describe
-           * initial conditions remain available throughout the run of the
-           * program.
-           */
-          void
-          initialize () override;
-
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties over time.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * The pressure and temperature need the values of their variables.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-        private:
-          /**
-           * A shared pointer to the initial temperature object
-           * that ensures that the current object can continue
-           * to access the initial temperature object beyond the
-           * first time step.
-           */
-          std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/position.h.bak b/include/aspect/particle/property/position.h.bak
deleted file mode 100644
index 67f24247df6..00000000000
--- a/include/aspect/particle/property/position.h.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_position_h
-#define _aspect_particle_property_position_h
-
-#include <aspect/particle/property/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that sets particle properties to the current position.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class Position : public Interface<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties over time.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/reference_position.h.bak b/include/aspect/particle/property/reference_position.h.bak
deleted file mode 100644
index 0de6a35f06b..00000000000
--- a/include/aspect/particle/property/reference_position.h.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_reference_position_h
-#define _aspect_particle_property_reference_position_h
-
-#include <aspect/particle/property/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that sets particle properties to the current position.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class ReferencePosition : public Interface<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle reference position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties over time.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/strain_rate.h.bak b/include/aspect/particle/property/strain_rate.h.bak
deleted file mode 100644
index d8c7460757d..00000000000
--- a/include/aspect/particle/property/strain_rate.h.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_strain_rate_h
-#define _aspect_particle_property_strain_rate_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that saves the time evolution of strain rate onto the particles.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class StrainRate : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties over time.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * The velocity particle property needs the values of the velocity
-           * solution.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/velocity.h.bak b/include/aspect/particle/property/velocity.h.bak
deleted file mode 100644
index 70d710430bd..00000000000
--- a/include/aspect/particle/property/velocity.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_velocity_h
-#define _aspect_particle_property_velocity_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that sets particle properties to the current velocity.
-       *
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class Velocity : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Initialization function. This function is called once at the
-           * creation of every particle for every property to initialize its
-           * value.
-           *
-           * @param [in] position The current particle position.
-           * @param [in,out] particle_properties The properties of the particle
-           * that is initialized within the call of this function. The purpose
-           * of this function should be to extend this vector by a number of
-           * properties.
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * This implementation tells the particle manager that
-           * we need to update particle properties over time.
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * Return which data has to be provided to update the property.
-           * The velocity particle property needs the values of the velocity
-           * solution.
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Set up the information about the names and number of components
-           * this property requires.
-           *
-           * @return A vector that contains pairs of the property names and the
-           * number of components this property plugin defines.
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/property/viscoplastic_strain_invariants.h.bak b/include/aspect/particle/property/viscoplastic_strain_invariants.h.bak
deleted file mode 100644
index d7a9c18da85..00000000000
--- a/include/aspect/particle/property/viscoplastic_strain_invariants.h.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_property_viscoplastic_strain_invariant_h
-#define _aspect_particle_property_viscoplastic_strain_invariant_h
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/visco_plastic.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      /**
-       * A class that calculates the finite strain invariant a particle has
-       * experienced and assigns it to either the plastic and/or viscous strain field based
-       * on whether the material is plastically yielding, or the total strain field
-       * used in the visco plastic material model. The implementation of this property
-       * is equivalent to the implementation for compositional fields that is located in
-       * the plugin <code>benchmarks/buiter_et_al_2008_jgr/plugin/finite_strain_invariant.cc</code>,
-       * and is effectively the same as what the visco plastic material model uses for compositional fields.
-       * @ingroup ParticleProperties
-       */
-      template <int dim>
-      class ViscoPlasticStrainInvariant : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ViscoPlasticStrainInvariant ();
-
-          void initialize () override;
-
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::initialize_one_particle_property()
-           */
-          void
-          initialize_one_particle_property (const Point<dim> &position,
-                                            std::vector<double> &particle_properties) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::update_particle_property()
-           */
-          virtual
-          void
-          update_particle_property (const unsigned int data_position,
-                                    const Vector<double> &solution,
-                                    const std::vector<Tensor<1,dim>> &gradients,
-                                    typename ParticleHandler<dim>::particle_iterator &particle) const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::need_update()
-           */
-          UpdateTimeFlags
-          need_update () const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::get_needed_update_flags()
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * @copydoc aspect::Particle::Property::Interface::get_property_information()
-           */
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const override;
-
-        private:
-          unsigned int n_components;
-
-          /**
-           * An object that is used to compute the particle property. Since the
-           * object is expensive to create and is needed often it is kept as a
-           * member variable. Because it is changed inside a const member function
-           * (update_particle_property) it has to be mutable, but since it is
-           * only used inside that function and always set before being used
-           * that is not a problem. This implementation is not thread safe,
-           * but it is currently not used in a threaded context.
-           */
-          mutable MaterialModel::MaterialModelInputs<dim> material_inputs;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/particle/world.h.bak b/include/aspect/particle/world.h.bak
deleted file mode 100644
index ad5578d3b3e..00000000000
--- a/include/aspect/particle/world.h.bak
+++ /dev/null
@@ -1,531 +0,0 @@
-/*
- Copyright (C) 2012 - 2021 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_particle_world_h
-#define _aspect_particle_world_h
-
-#include <aspect/global.h>
-
-#include <deal.II/particles/particle.h>
-#include <deal.II/particles/particle_accessor.h>
-#include <deal.II/particles/particle_iterator.h>
-#include <deal.II/particles/particle_handler.h>
-#include <deal.II/particles/property_pool.h>
-
-#include <deal.II/matrix_free/fe_point_evaluation.h>
-
-#include <aspect/particle/generator/interface.h>
-#include <aspect/particle/integrator/interface.h>
-#include <aspect/particle/interpolator/interface.h>
-#include <aspect/particle/property/interface.h>
-
-#include <aspect/simulator_access.h>
-#include <aspect/simulator_signals.h>
-
-#include <deal.II/base/timer.h>
-#include <deal.II/base/array_view.h>
-
-#include <boost/serialization/unique_ptr.hpp>
-
-namespace aspect
-{
-  template <int dim>
-  struct SimulatorSignals;
-
-  namespace Particle
-  {
-    using namespace dealii;
-    using namespace dealii::Particles;
-
-    namespace Generator
-    {
-      template <int dim>
-      class Interface;
-    }
-
-
-    namespace Property
-    {
-      template <int dim>
-      class Manager;
-    }
-
-    namespace internal
-    {
-      /**
-       * This class evaluates the solution vector at arbitrary positions inside a cell.
-       * This base class only provides the interface for SolutionEvaluatorsImplementation.
-       * See there for more details.
-       */
-      template <int dim>
-      class SolutionEvaluators
-      {
-        public:
-          /**
-           * virtual Destructor.
-           */
-          virtual ~SolutionEvaluators() = default;
-
-          /**
-           * Reinitialize all variables to evaluate the given solution for the given cell
-           * and the given positions. The update flags control if only the solution or
-           * also the gradients should be evaluated.
-           * If other flags are set an assertion is triggered.
-           */
-          virtual void
-          reinit(const typename DoFHandler<dim>::active_cell_iterator &cell,
-                 const ArrayView<Point<dim>> &positions,
-                 const ArrayView<double> &solution_values,
-                 const UpdateFlags update_flags) = 0;
-
-          /**
-           * Fill @p solution with all solution components at the given @p evaluation_point. Note
-           * that this function only works after a successful call to reinit(),
-           * because this function only returns the results of the computation that
-           * happened in reinit().
-           */
-          virtual void get_solution(const unsigned int evaluation_point,
-                                    Vector<double> &solution) = 0;
-
-          /**
-           * Fill @p gradients with all solution gradients at the given @p evaluation_point. Note
-           * that this function only works after a successful call to reinit(),
-           * because this function only returns the results of the computation that
-           * happened in reinit().
-           */
-          virtual void get_gradients(const unsigned int evaluation_point,
-                                     std::vector<Tensor<1, dim>> &gradients) = 0;
-
-          /**
-           * Return the evaluator for velocity or fluid velocity. This is the only
-           * information necessary for advecting particles.
-           */
-          virtual FEPointEvaluation<dim, dim> &
-          get_velocity_or_fluid_velocity_evaluator(const bool use_fluid_velocity) = 0;
-
-          /**
-           * Return the cached mapping information.
-           */
-          virtual NonMatching::MappingInfo<dim> &
-          get_mapping_info() = 0;
-      };
-
-      /**
-       * A function to create a pointer to a SolutionEvaluators object.
-       */
-      template <int dim>
-      std::unique_ptr<internal::SolutionEvaluators<dim>>
-      construct_solution_evaluators(const SimulatorAccess<dim> &simulator_access,
-                                    const UpdateFlags update_flags);
-    }
-
-    /**
-     * This class manages the storage and handling of particles. It provides
-     * interfaces to generate and store particles, functions to initialize,
-     * update and advect them, and ways to retrieve information about the
-     * particles. The implementation of most of these methods is outsourced
-     * to different plugin systems, this class is mostly concerned with
-     * managing the interactions of the different systems with the code
-     * outside the particle world.
-     *
-     * @ingroup Particle
-     */
-    template <int dim>
-    class World : public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Default World constructor.
-         */
-        World();
-
-        /**
-         * Default World destructor.
-         */
-        ~World() override;
-
-        /**
-         * Initialize the particle world.
-         */
-        void initialize();
-
-        /**
-         * Update the particle world.
-        */
-        void update();
-
-        /**
-         * Get the particle property manager for this particle world.
-         *
-         * @return The property manager for this world.
-         */
-        const Property::Manager<dim> &
-        get_property_manager() const;
-
-        /**
-         * Get the const particle handler for this particle world.
-         *
-         * @return The particle handler for this world.
-         */
-        const Particles::ParticleHandler<dim> &
-        get_particle_handler() const;
-
-        /**
-         * Get the particle handler for this particle world.
-         * There is no get_particles() function in the deal.II
-         * ParticleHandler, so we get and set the positions
-         * of the particles. These getter/setter functions are
-         * not const, and neither are the calling functions,
-         * but the existing get_particle_handler is.
-         * Therefore this non-const function is added.
-         *
-         * @return The particle handler for this world.
-         */
-        Particles::ParticleHandler<dim> &
-        get_particle_handler();
-
-        /**
-         * Copy the state of particle handler @p from_particle_handler into the
-         * particle handler @p to_particle_handler. This will copy
-         * all particles and properties and leave @p to_particle_handler
-         * as an identical copy of @p from_particle_handler, assuming it
-         * was set up by this particle world class. This means we assume
-         * @p from_particle_handler uses the same triangulation and
-         * particle properties as are used in this model. Existing
-         * particles in @p to_particle_handler are deleted.
-         *
-         * This function is expensive as it has to duplicate all data
-         * in @p from_particle_handler, and insert it into @p to_particle_handler,
-         * which may be a significant amount of data. However, it can
-         * be useful to save the state of a particle
-         * collection at a certain point in time and reset this
-         * state later under certain conditions, for example if
-         * a timestep has to be undone and repeated.
-         */
-        void copy_particle_handler (const Particles::ParticleHandler<dim> &from_particle_handler,
-                                    Particles::ParticleHandler<dim> &to_particle_handler) const;
-
-        /**
-         * @brief Stores a copy of the particle handler in particle_handler_backup. This copy can be
-         * used to restore the position and properties of the particles for example after advection
-         * solver iterations of the iterated advection scheme or when a timestep has to be repeated.
-         */
-        void backup_particles ();
-
-        /**
-         * @brief Restores the particle handler particle_handler based on the copy
-         * in particle_handler_backup. This restores the position and properties of the particles
-         * to those in the copy and can be used for example after advection solver iterations
-         * of the iterated advection scheme or when a timestep has to be repeated.
-         */
-        void restore_particles ();
-
-
-        /**
-         * Do initial logic for handling pre-refinement steps
-         */
-        void setup_initial_state ();
-
-        /**
-         * Get the particle interpolator for this particle world.
-         *
-         * @return The interpolator for this world.
-         */
-        const Interpolator::Interface<dim> &
-        get_interpolator() const;
-
-        /**
-         * Initialize the particle properties.
-         */
-        void generate_particles();
-        /**
-         * Initialize the particle properties.
-         */
-        void initialize_particles();
-
-        /**
-         * Advance particles by the old timestep using the current
-         * integration scheme. This accounts for the fact that the particles
-         * are actually still at their old positions and the current timestep
-         * length is already updated for the next step at the time this
-         * function is called.
-         */
-        void advance_timestep();
-
-        /**
-         * Return the total number of particles in the simulation. This
-         * function is useful for monitoring how many particles have been
-         * lost by falling out of the domain. Note that this function does
-         * not compute the number of particles, because that is an expensive
-         * global MPI operation. Instead it returns the number, which is
-         * updated internally every time it might change by a call to
-         * update_n_global_particles().
-         *
-         * @return Total number of particles in simulation.
-         */
-        types::particle_index n_global_particles() const;
-
-        /**
-         * This callback function is registered within Simulator by the
-         * constructor of this class and will be
-         * called from Simulator during construction. It allows to attach slot
-         * functions to the provided SimulatorSignals. This world will register
-         * the register_store_callback_function() and
-         * register_load_callback_function() to the
-         * pre_refinement_store_user_data signal and the
-         * post_refinement_load_user_data signal respectively.
-         */
-        void
-        connect_to_signals(aspect::SimulatorSignals<dim> &signals);
-
-        /**
-         * Called by listener functions from Triangulation for every cell
-         * before a refinement step. A weight is attached to every cell
-         * depending on the number of contained particles.
-         */
-#if DEAL_II_VERSION_GTE(9,6,0)
-        unsigned int
-        cell_weight(const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
-                    const CellStatus status);
-#else
-        unsigned int
-        cell_weight(const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
-                    const typename parallel::distributed::Triangulation<dim>::CellStatus status);
-#endif
-
-        /**
-         * Update the particle properties if necessary.
-         */
-        void update_particles();
-
-        /**
-         * Serialize the contents of this class.
-         */
-        template <class Archive>
-        void serialize (Archive &ar, const unsigned int version);
-
-        /**
-         * Save the state of the object.
-         */
-        virtual
-        void
-        save (std::ostringstream &os) const;
-
-        /**
-         * Restore the state of the object.
-         */
-        virtual
-        void
-        load (std::istringstream &is);
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         *
-         * @param world_index Parse the parameters for the Particle world with this index.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm, const unsigned int world_index);
-
-      private:
-        struct ParticleLoadBalancing
-        {
-          enum Kind
-          {
-            no_balancing = 0x0,
-            remove_particles = 0x1,
-            add_particles = 0x2,
-            repartition = 0x4,
-            remove_and_add_particles = remove_particles | add_particles
-          };
-        };
-
-        /**
-         * Generation scheme for creating particles in this world
-         */
-        std::unique_ptr<Generator::Interface<dim>> generator;
-
-        /**
-         * Integration scheme for moving particles in this world
-         */
-        std::unique_ptr<Integrator::Interface<dim>> integrator;
-
-        /**
-         * Interpolation scheme for moving particles in this world
-         */
-        std::unique_ptr<Interpolator::Interface<dim>> interpolator;
-
-        /**
-         * Particle handler object that is responsible for storing and
-         * managing the internal particle structures.
-         */
-        std::unique_ptr<Particles::ParticleHandler<dim>> particle_handler;
-
-        /**
-         * Particle handler object that is responsible for storing and
-         * managing the internal particle structures before starting nonlinear iterations
-         * such that the particle position and properties can be restored after
-         * each outer advection iteration.
-         */
-        Particles::ParticleHandler<dim> particle_handler_backup;
-
-        /**
-         * The property manager stores information about the additional
-         * particle properties and handles the initialization and update of
-         * these properties.
-         */
-        std::unique_ptr<Property::Manager<dim>> property_manager;
-
-        /**
-         * Strategy for particle load balancing.
-         */
-        typename ParticleLoadBalancing::Kind particle_load_balancing;
-
-        /**
-         * Lower limit for particle number per cell. This limit is
-         * useful for adaptive meshes to prevent fine cells from being empty
-         * of particles. It will be checked and enforced after mesh
-         * refinement and after particle movement. If there are
-         * n_number_of_particles < min_particles_per_cell
-         * particles in one cell then
-         * min_particles_per_cell - n_number_of_particles particles are
-         * generated and randomly placed in this cell. If the particles carry
-         * properties the individual property plugins control how the
-         * properties of the new particles are initialized.
-         */
-        unsigned int min_particles_per_cell;
-
-        /**
-         * Upper limit for particle number per cell. This limit is
-         * useful for adaptive meshes to prevent coarse cells from slowing down
-         * the whole model. It will be checked and enforced after mesh
-         * refinement, after MPI transfer of particles and after particle
-         * movement. If there are
-         * n_number_of_particles > max_particles_per_cell
-         * particles in one cell then
-         * n_number_of_particles - max_particles_per_cell
-         * particles in this cell are randomly chosen and destroyed.
-         */
-        unsigned int max_particles_per_cell;
-
-        /**
-         * The computational cost of a single particle. This is an input
-         * parameter that is set during initialization and is only used if the
-         * particle load balancing strategy 'repartition' is used. This value
-         * determines how costly the computation of a single particle is compared
-         * to the computation of a whole cell, which is arbitrarily defined
-         * to represent a cost of 1000.
-         */
-        unsigned int particle_weight;
-
-        /**
-         * Some particle interpolation algorithms require knowledge
-         * about particles in neighboring cells. To allow this,
-         * particles in ghost cells need to be exchanged between the
-         * processes neighboring this cell. This parameter determines
-         * whether this transport is happening.
-         */
-        bool update_ghost_particles;
-
-        /**
-         * Get a map between subdomain id and the neighbor index. In other words
-         * the returned map answers the question: Given a subdomain id, which
-         * neighbor of the current processor's domain (in terms of a contiguous
-         * number from 0 to n_neighbors) owns this subdomain?
-         */
-        std::map<types::subdomain_id, unsigned int>
-        get_subdomain_id_to_neighbor_map() const;
-
-        /**
-         * Apply the bounds for the maximum and minimum number of particles
-         * per cell, if the appropriate @p particle_load_balancing strategy
-         * has been selected.
-         */
-        void
-        apply_particle_per_cell_bounds();
-
-        /**
-         * Advect the particle positions by one integration step. Needs to be
-         * called until integrator->continue() returns false.
-         */
-        void advect_particles();
-
-        /**
-         * Initialize the particle properties of one cell.
-         */
-        void
-        local_initialize_particles(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                                   const typename ParticleHandler<dim>::particle_iterator &end_particle);
-
-        /**
-         * Update the particle properties of one cell.
-         */
-        void
-        local_update_particles(const typename DoFHandler<dim>::active_cell_iterator &cell,
-                               internal::SolutionEvaluators<dim> &evaluators);
-
-        /**
-         * Advect the particles of one cell. Performs only one step for
-         * multi-step integrators. Needs to be called until integrator->continue()
-         * evaluates to false. Particles that moved out of their old cell
-         * during this advection step are removed from the local multimap and
-         * stored in @p particles_out_of_cell for further treatment (sorting
-         * them into the new cell).
-         */
-        void
-        local_advect_particles(const typename DoFHandler<dim>::active_cell_iterator &cell,
-                               const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                               const typename ParticleHandler<dim>::particle_iterator &end_particle,
-                               internal::SolutionEvaluators<dim> &evaluators);
-
-        /**
-         * This function registers the necessary functions to the
-         * @p signals that the @p particle_handler needs to know about.
-         */
-        void
-        connect_particle_handler_signals(aspect::SimulatorSignals<dim> &signals,
-                                         ParticleHandler<dim> &particle_handler,
-                                         const bool connect_to_checkpoint_signals = true) const;
-    };
-
-    /* -------------------------- inline and template functions ---------------------- */
-
-    template <int dim>
-    template <class Archive>
-    void World<dim>::serialize (Archive &ar, const unsigned int)
-    {
-      // Note that although Boost claims to handle serialization of pointers
-      // correctly, at least for the case of unique_ptr it seems to not work.
-      // It works correctly when archiving the content of the pointer instead.
-      ar
-      &(*particle_handler)
-      ;
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/plugins.h.bak b/include/aspect/plugins.h.bak
deleted file mode 100644
index 86d77fc9f1e..00000000000
--- a/include/aspect/plugins.h.bak
+++ /dev/null
@@ -1,808 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_plugins_h
-#define _aspect_plugins_h
-
-#include <aspect/global.h>
-
-#include <deal.II/base/utilities.h>
-#include <deal.II/base/parameter_handler.h>
-#include <tuple>
-#include <deal.II/base/exceptions.h>
-
-#include <boost/core/demangle.hpp>
-
-#include <string>
-#include <list>
-#include <set>
-#include <map>
-#include <iostream>
-#include <typeinfo>
-#include <type_traits>
-
-
-namespace aspect
-{
-  template <int dim> class SimulatorAccess;
-
-  namespace Plugins
-  {
-    using namespace dealii;
-
-    /**
-     * This function returns if a given plugin (e.g. a material model returned
-     * from SimulatorAccess::get_material_model() ) matches a certain plugin
-     * type (e.g. MaterialModel::Simple). This check is needed, because often
-     * it is only possible to get a reference to an Interface, not the actual
-     * plugin type, but the actual plugin type might be important. For example
-     * a radial gravity model might only be implemented for spherical geometry
-     * models, and would want to check if the current geometry is in fact a
-     * spherical shell.
-     *
-     * This function can only be called with types that correspond to the same
-     * plugin system. In other words, the type of the plugin has to either be
-     * derived from the type of the object being tested, or they have to both
-     * be derived from a common base class. This function is not appropriate
-     * to check whether a class `TestType` derived from an interface base
-     * class is *also* derived from a second base class `PluginType`. For these
-     * cases, use a `dynamic_cast`.
-     */
-    template <typename TestType, typename PluginType,
-              typename = typename std::enable_if_t<std::is_base_of<PluginType,TestType>::value>>
-    inline
-    bool
-    plugin_type_matches (const PluginType &object)
-    {
-      return (dynamic_cast<const TestType *> (&object) != nullptr);
-    }
-
-    /**
-     * This function converts a reference to a type (in particular a reference
-     * to an interface class) into a reference to a different type (in
-     * particular a plugin class). This allows accessing members of the plugin
-     * that are not specified in the interface class. Note that you should
-     * first check if the plugin type is actually convertible by calling
-     * plugin_matches_type() before calling this function. If the plugin is
-     * not convertible this function throws an exception.
-     *
-     * This function can only be called with types that correspond to the same
-     * plugin system. In other words, the type of the plugin has to either be
-     * derived from the type of the object being tested, or they have to both
-     * be derived from a common base class. This function is not appropriate
-     * to convert references to classes whether a class `TestType` derived
-     * from an interface base class is *also* derived from a second base
-     * class `PluginType`. For these cases, use a `dynamic_cast`.
-     */
-    template <typename TestType, typename PluginType,
-              typename = typename std::enable_if_t<std::is_base_of<PluginType,TestType>::value>>
-    inline
-    TestType &
-    get_plugin_as_type (PluginType &object)
-    {
-      AssertThrow(plugin_type_matches<TestType>(object),
-                  ExcMessage("You have requested to convert a plugin of type <"
-                             + boost::core::demangle(typeid(PluginType).name())
-                             + "> into type <"
-                             + boost::core::demangle(typeid(TestType).name()) +
-                             ">, but this cast cannot be performed."));
-
-      // We can safely dereference the pointer, because we checked above that
-      // the object is actually of type TestType, and so the result
-      // is not a nullptr.
-      return *dynamic_cast<TestType *> (&object);
-    }
-  }
-
-  namespace Plugins
-  {
-    using namespace dealii;
-
-
-    /**
-     * A base class for all plugin systems. The class ensures that a
-     * common set of functions is declared as `virtual` (namely, the
-     * destructor, `initialize()`, `update()`, and
-     * `parse_parameters()`) and implemented with empty bodies so that
-     * derived interface classes do not have to declare these
-     * functions themselves. Furthermore, the class provides an empty,
-     * `static` function `declare_parameters()` that derived classes
-     * can re-implement to declare their parameters.
-     */
-    class InterfaceBase
-    {
-      public:
-        /**
-         * Destructor. Made virtual to enforce that derived classes also have
-         * virtual destructors.
-         */
-        virtual ~InterfaceBase() = default;
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters() is run and after
-         * the SimulatorAccess (if applicable) is initialized.
-         *
-         * The default implementation of this function does nothing, but
-         * plugins that derive from this class (via the <code>Interface</code>
-         * classes of their respective plugin systems) may overload it
-         * if they want something to happen upon startup of the
-         * Simulator object to which the plugin contributes.
-         */
-        virtual
-        void
-        initialize ();
-
-        /**
-         * A function that is called at the beginning of each time step.
-         *
-         * The default implementation of this function does nothing, but
-         * plugins that derive from this class (via the <code>Interface</code>
-         * classes of their respective plugin systems) may overload it
-         * if they want something to happen upon startup of the
-         * Simulator object to which the plugin contributes.
-         */
-        virtual
-        void
-        update ();
-
-        /**
-         * Declare the parameters the plugin takes through input files. The
-         * default implementation of this function does not describe any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters. On
-         * the other hand, most plugins do have run-time parameters, and
-         * they may then overload this function.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * The default implementation of this function does not read any
-         * parameters. Consequently, derived classes do not have to overload
-         * this function if they do not take any runtime parameters. On
-         * the other hand, most plugins do have run-time parameters, and
-         * they may then overload this function.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-    };
-
-
-
-    /**
-     * A base class for "plugin manager" classes. Plugin manager classes are
-     * used in places where one can legitimately use more than one plugin of
-     * a certain kind. For example, while there can only ever be one geometry
-     * (and consequently, the Simulator class only stores a single object of
-     * type derived from GeometryModels::Interface), one can have many different
-     * postprocessor objects at the same time. In these circumstances, the
-     * Simulator class stores a Postprocess::Manager object that internally
-     * stores zero or more objects of type derived from Postprocess::Interface.
-     * Since there are many places inside ASPECT where we need these "plugin
-     * manager" classes, the current class provides some common functionality
-     * to all of these classes.
-     *
-     * The class takes as template argument the type of the derived
-     * class's interface type. Since a manager is always also a plugin
-     * (to the Simulator class) itself, the current class is derived from
-     * the `InterfaceBase` class as well.
-     */
-    template <typename InterfaceType>
-    class ManagerBase : public InterfaceBase
-    {
-      public:
-        /**
-         * A function that is called at the beginning of each time step,
-         * calling the update function of the individual heating models.
-         */
-        void
-        update () override;
-
-        /**
-         * Go through the list of all plugins that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename PluginType,
-                  typename = typename std::enable_if_t<std::is_base_of<InterfaceType,PluginType>::value>>
-        bool
-        has_matching_plugin_object () const;
-
-        /**
-         * Go through the list of all plugins that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no postprocessor is active that matches the given type,
-         * throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename PluginType,
-                  typename = typename std::enable_if_t<std::is_base_of<InterfaceType,PluginType>::value>>
-        const PluginType &
-        get_matching_plugin_object () const;
-
-      protected:
-        /**
-         * A list of plugin objects that have been requested in the
-         * parameter file.
-         */
-        std::list<std::unique_ptr<InterfaceType>> plugin_objects;
-    };
-
-
-    template <typename InterfaceType>
-    void ManagerBase<InterfaceType>::update()
-    {
-      for (const auto &plugin : plugin_objects)
-        {
-          plugin->update();
-        }
-    }
-
-
-    template <typename InterfaceType>
-    template <typename PluginType, typename>
-    inline
-    bool
-    ManagerBase<InterfaceType>::has_matching_plugin_object () const
-    {
-      for (const auto &p : plugin_objects)
-        if (Plugins::plugin_type_matches<PluginType>(*p))
-          return true;
-      return false;
-    }
-
-
-    template <typename InterfaceType>
-    template <typename PluginType, typename>
-    inline
-    const PluginType &
-    ManagerBase<InterfaceType>::get_matching_plugin_object () const
-    {
-      AssertThrow(has_matching_plugin_object<PluginType> (),
-                  ExcMessage("You asked the object managing a collection of plugins for a "
-                             "plugin object of type <" + boost::core::demangle(typeid(PluginType).name()) + "> "
-                             "that could not be found in the current model. You need to "
-                             "activate this plugin in the input file for it to be "
-                             "available."));
-
-      for (const auto &p : plugin_objects)
-        if (Plugins::plugin_type_matches<PluginType>(*p))
-          return Plugins::get_plugin_as_type<PluginType>(*p);
-
-      // We will never get here, because we had the Assert above. Just to avoid warnings.
-      return Plugins::get_plugin_as_type<PluginType>(**(plugin_objects.begin()));
-    }
-  }
-
-  namespace internal
-  {
-    /**
-     * A namespace for the definition of classes that have to do with the
-     * plugin architecture of ASPECT.
-     */
-    namespace Plugins
-    {
-      using namespace dealii;
-
-
-
-      /**
-       * An internal class that is used in the definition of the
-       * ASPECT_REGISTER_* macros. Given a registration function, a classname,
-       * a description of what it does, and a name for the parameter file, it
-       * registers the model with the proper authorities.
-       *
-       * The registration happens in the constructor. The typical use case of
-       * this function is thus the creation of a dummy object in some
-       * otherwise unused namespace.
-       */
-      template <typename InterfaceClass,
-                typename ModelClass>
-      struct RegisterHelper
-      {
-        /**
-         * Constructor. Given a pointer to a registration function and name
-         * and description of the class, this constructor registers the class
-         * passed as second template argument.
-         */
-        RegisterHelper (void (*register_function) (const std::string &,
-                                                   const std::string &,
-                                                   void ( *)(ParameterHandler &),
-                                                   std::unique_ptr<InterfaceClass> ( *)()),
-                        const char *name,
-                        const char *description)
-        {
-          register_function (name,
-                             description,
-                             &ModelClass::declare_parameters,
-                             &factory);
-        }
-
-        /**
-         * A factory object that just creates object of the type registered by
-         * this class.
-         */
-        static
-        std::unique_ptr<InterfaceClass> factory ()
-        {
-          return std::make_unique<ModelClass>();
-        }
-      };
-
-
-      /**
-       * A class that stores a list of registered plugins for the given
-       * interface type.
-       */
-      template <typename InterfaceClass>
-      struct PluginList
-      {
-        /**
-         * A type describing everything we need to know about a plugin.
-         *
-         * The entries in the tuple are:
-         * - The name by which it can be selected.
-         * - A description of this plugin that will show up in the
-         *   documentation in the parameter file.
-         * - A function that can declare the run-time parameters this
-         *   plugin takes from the parameter file.
-         * - A function that can produce objects of this plugin type.
-         */
-        using PluginInfo
-        = std::tuple<std::string,
-        std::string,
-        void ( *) (ParameterHandler &),
-        std::unique_ptr<InterfaceClass>( *) ()>;
-
-        /**
-         * A pointer to a list of all registered plugins.
-         *
-         * The object is a pointer rather than an object for the following
-         * reason: objects with static initializers (such as =0) are
-         * initialized before any objects for which one needs to run
-         * constructors. Consequently, we can be sure that this pointer is set
-         * to zero before we ever try to register a postprocessor, and
-         * consequently whenever we run Manager::register_postprocessor, we
-         * need not worry whether we try to add something to this list before
-         * the lists's constructor has successfully run
-         */
-        static std::list<PluginInfo> *plugins;
-
-        /**
-         * Destructor.
-         */
-        ~PluginList ();
-
-        /**
-         * Register a plugin by name, description, parameter declaration
-         * function, and factory function. See the discussion for the
-         * PluginInfo type above for more information on their meaning.
-         */
-        static
-        void register_plugin (const std::string &name,
-                              const std::string &description,
-                              void (*declare_parameters_function) (ParameterHandler &),
-                              std::unique_ptr<InterfaceClass> (*factory_function) ());
-
-        /**
-         * Generate a list of names of the registered plugins separated by '|'
-         * so that they can be taken as the input for Patterns::Selection.
-         *
-         * To make it easier to visually scan through the list of plugins,
-         * names are sorted alphabetically.
-         */
-        static
-        std::string get_pattern_of_names ();
-
-        /**
-         * Return a string that describes all registered plugins using the
-         * descriptions that have been provided at the time of registration.
-         *
-         * To make it easier to visually scan through the list of plugins,
-         * names are sorted alphabetically.
-         */
-        static
-        std::string get_description_string ();
-
-        /**
-         * Let all registered plugins define their parameters.
-         */
-        static
-        void declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Given the name of one plugin, create a corresponding object and
-         * return a pointer to it. The second argument provides a hint where
-         * this function was called from, to be printed in case there is an
-         * error.
-         *
-         * Ownership of the object is handed over to the caller of this
-         * function.
-         */
-        static
-        std::unique_ptr<InterfaceClass>
-        create_plugin (const std::string  &name,
-                       const std::string &documentation);
-
-        /**
-         * Given the name of one plugin, create a corresponding object and
-         * return a pointer to it. The second argument provides a hint where
-         * this function was called from, to be printed in case there is an
-         * error. Before returning, let the newly created object read its
-         * run-time parameters from the parameter object.
-         *
-         * Ownership of the object is handed over to the caller of this
-         * function.
-         */
-        static
-        std::unique_ptr<InterfaceClass>
-        create_plugin (const std::string  &name,
-                       const std::string &documentation,
-                       ParameterHandler &prm);
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param plugin_system_name The name to be used for the current
-         *   plugin system. This name will be used for the "Interface"
-         *   class to which all plugins connect.
-         * @param output_stream The stream to write the output to.
-         * @param attachment_point The point to which a plugin subsystem
-         *   feeds information. By default, this is the Simulator class,
-         *   but some plugin systems (most notably the visualization
-         *   postprocessors, which feeds to one of the postprocessor
-         *   classes) hook into other places. If other than the
-         *   "Simulator" default, the attachment point should be of
-         *   the form <code>typeid(ClassName).name()</code> as this is
-         *   the form used by this function to identify nodes in the
-         *   plugin graph.
-         */
-        static
-        void
-        write_plugin_graph (const std::string &plugin_system_name,
-                            std::ostream      &output_stream,
-                            const std::string &attachment_point = "Simulator");
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcUnknownPlugin,
-                        std::string,
-                        << "Can't create a plugin of name <" << arg1
-                        << "> because such a plugin hasn't been declared.");
-      };
-
-
-      /* ------------------------ template and inline functions --------------------- */
-
-      template <typename InterfaceClass>
-      PluginList<InterfaceClass>::
-      ~PluginList ()
-      {
-        // if any plugins have been registered, then delete
-        // the list
-        if (plugins != nullptr)
-          delete plugins;
-        plugins = nullptr;
-      }
-
-
-
-      template <typename InterfaceClass>
-      void
-      PluginList<InterfaceClass>::
-      register_plugin (const std::string &name,
-                       const std::string &description,
-                       void (*declare_parameters_function) (ParameterHandler &),
-                       std::unique_ptr<InterfaceClass> (*factory_function) ())
-      {
-        // see if this is the first time we get into this
-        // function and if so initialize the static member variable
-        if (plugins == nullptr)
-          plugins = new std::list<PluginInfo>();
-
-        // verify that the same name has not previously been
-        // used to register a plugin, since we would then no
-        // longer be able to identify the plugin
-        for (const auto &p : *plugins)
-          {
-            Assert (std::get<0>(p) != name,
-                    ExcMessage ("A plugin with name <" + name + "> has "
-                                "already been registered!"));
-            (void)p;
-          }
-
-
-        // now add one record to the list
-        plugins->emplace_back (name,
-                               description,
-                               declare_parameters_function,
-                               factory_function);
-      }
-
-
-
-      template <typename InterfaceClass>
-      std::string
-      PluginList<InterfaceClass>::
-      get_pattern_of_names ()
-      {
-        Assert (plugins != nullptr,
-                ExcMessage ("No plugins registered!?"));
-
-        // get all names and put them into a data structure that keeps
-        // them sorted
-        std::set<std::string> names;
-        for (typename std::list<PluginInfo>::const_iterator
-             p = plugins->begin();
-             p != plugins->end(); ++p)
-          names.insert (std::get<0>(*p));
-
-        // now create a pattern from all of these sorted names
-        std::string pattern_of_names;
-        for (const auto &name : names)
-          {
-            if (pattern_of_names.size() > 0)
-              pattern_of_names += "|";
-            pattern_of_names += name;
-          }
-
-        return pattern_of_names;
-      }
-
-
-
-      template <typename InterfaceClass>
-      std::string
-      PluginList<InterfaceClass>::
-      get_description_string ()
-      {
-        std::string description;
-
-        // get all names_and_descriptions and put them into a data structure that keeps
-        // them sorted
-        std::map<std::string,std::string> names_and_descriptions;
-        for (typename std::list<PluginInfo>::const_iterator
-             p = plugins->begin();
-             p != plugins->end(); ++p)
-          names_and_descriptions[std::get<0>(*p)] = std::get<1>(*p);
-
-        // then output it all
-        std::map<std::string,std::string>::const_iterator
-        p = names_and_descriptions.begin();
-        while (true)
-          {
-            // write the name and
-            // description of the
-            // parameter
-            description += "`";
-            description += p->first;
-            description += "': ";
-            description += p->second;
-
-            // increment the pointer
-            // by one. if we are not
-            // at the end yet then
-            // add an empty line
-            ++p;
-            if (p != names_and_descriptions.end())
-              description += "\n\n";
-            else
-              break;
-          }
-
-        return description;
-      }
-
-
-
-
-      template <typename InterfaceClass>
-      void
-      PluginList<InterfaceClass>::
-      declare_parameters (ParameterHandler &prm)
-      {
-        Assert (plugins != nullptr,
-                ExcMessage ("No postprocessors registered!?"));
-
-        for (typename std::list<PluginInfo>::const_iterator
-             p = plugins->begin();
-             p != plugins->end(); ++p)
-          (std::get<2>(*p))(prm);
-      }
-
-
-
-      template <typename InterfaceClass>
-      std::unique_ptr<InterfaceClass>
-      PluginList<InterfaceClass>::
-      create_plugin (const std::string &name,
-                     const std::string &documentation)
-      {
-        (void)documentation;
-        Assert (plugins != nullptr,
-                ExcMessage ("No postprocessors registered!?"));
-        AssertThrow (name != "unspecified",
-                     ExcMessage(std::string("A plugin must have a name!\n\n"
-                                            "This function was asked to create a plugin but no name for the "
-                                            "plugin was provided. This may be due to the fact that you did not "
-                                            "explicitly specify a name for this plugin in your input file and "
-                                            "ASPECT does not provide a default for this kind of plugin, for "
-                                            "example because no generally useful plugin exists. An example "
-                                            "is that there is no default geometry: You need to explicitly "
-                                            "provide one in the input file, and it seems like you have not "
-                                            "done so.\n\n"
-                                            "To find out which kind of plugin this function tries to create, "
-                                            "take a look at the backtrace of this error message.\n\n"
-                                            "The place that called this function also provided as "
-                                            "additional information this:\n\n"
-                                            "   <")
-                                + documentation + ">"));
-
-        for (typename std::list<PluginInfo>::const_iterator p = plugins->begin();
-             p != plugins->end(); ++p)
-          if (std::get<0>(*p) == name)
-            {
-              std::unique_ptr<InterfaceClass> i = std::get<3>(*p)();
-              return i;
-            }
-
-        AssertThrow (false, ExcUnknownPlugin(name));
-        return nullptr;
-      }
-
-
-
-      template <typename InterfaceClass>
-      std::unique_ptr<InterfaceClass>
-      PluginList<InterfaceClass>::
-      create_plugin (const std::string &name,
-                     const std::string &documentation,
-                     ParameterHandler  &prm)
-      {
-        std::unique_ptr<InterfaceClass> i = create_plugin(name, documentation);
-        i->parse_parameters (prm);
-        return i;
-      }
-
-
-
-      template <typename InterfaceClass>
-      void
-      PluginList<InterfaceClass>::
-      write_plugin_graph (const std::string &plugin_system_name,
-                          std::ostream      &output_stream,
-                          const std::string &attachment_point)
-      {
-        // first output a graph node for the interface class as the central
-        // hub of this plugin system, plotted as a square.
-        //
-        // we use the typeid name of the interface class to label
-        // nodes within this plugin system, as they are unique among
-        // all other plugin systems
-        output_stream << std::string(typeid(InterfaceClass).name())
-                      << " [label=\""
-                      << plugin_system_name
-                      << "\", height=.8,width=.8,shape=\"rect\",fillcolor=\"green\"]"
-                      << std::endl;
-
-        // then output the graph nodes for each plugin, with links to the
-        // interface class and, as appropriate, from the SimulatorAccess class
-        //
-        // we would like to establish a predictable order of output here, but
-        // plugins self-register via static global variables, and their
-        // initialization order is not deterministic. consequently, let us
-        // loop over all plugins first and put pointers to them into a
-        // map with deterministic keys. as key, we use the declared name
-        // of the plugin by which it is referred in the .prm file
-        std::map<std::string, typename std::list<PluginInfo>::const_iterator>
-        plugin_map;
-        for (typename std::list<PluginInfo>::const_iterator p = plugins->begin();
-             p != plugins->end(); ++p)
-          plugin_map[std::get<0>(*p)] = p;
-
-        // now output the information sorted by the plugin names
-        for (typename std::map<std::string, typename std::list<PluginInfo>::const_iterator>::const_iterator
-             p = plugin_map.begin();
-             p != plugin_map.end(); ++p)
-          {
-            // take the name of the plugin and split it into strings of
-            // 15 characters at most; then combine them
-            // again using \n to make dot/neato show these parts of
-            // the name on separate lines
-            const std::vector<std::string> plugin_label_parts
-              = dealii::Utilities::break_text_into_lines(p->first, 15);
-            Assert (plugin_label_parts.size()>0, ExcInternalError());
-            std::string plugin_name = plugin_label_parts[0];
-            for (unsigned int i=1; i<plugin_label_parts.size(); ++i)
-              plugin_name += "\\n" + plugin_label_parts[i];
-
-            // next create a (symbolic) node name for this plugin. because
-            // each plugin corresponds to a particular class, use the mangled
-            // name of the class
-            std::unique_ptr<InterfaceClass> instance (create_plugin (p->first, ""));
-            const std::string node_name = typeid(*instance).name();
-
-            // then output the whole shebang describing this node
-            output_stream << node_name
-                          << " [label=\""
-                          << plugin_name
-                          << "\", height=.8,width=.8,shape=\"circle\",fillcolor=\"lightblue\"];"
-                          << std::endl;
-
-            // next build connections from this plugin to the
-            // interface class
-            output_stream << node_name
-                          << " -> "
-                          << std::string(typeid(InterfaceClass).name())
-                          << " [len=3, weight=50]"
-                          << ';'
-                          << std::endl;
-
-            // finally see if this plugin is derived from
-            // SimulatorAccess; if so, draw an arrow from SimulatorAccess
-            // also to the plugin's name
-            if (dynamic_cast<const SimulatorAccess<2>*>(instance.get()) != nullptr
-                ||
-                dynamic_cast<const SimulatorAccess<3>*>(instance.get()) != nullptr)
-              output_stream << "SimulatorAccess"
-                            << " -> "
-                            << node_name
-                            << " [style=\"dotted\", arrowhead=\"empty\", constraint=false, color=\"gray\", len=20, weight=0.1];"
-                            << std::endl;
-          }
-
-        // as a last step, also draw a connection from the interface class
-        // to the Simulator class, or whatever the calling function indicates
-        // as the attachment point
-        output_stream << std::string(typeid(InterfaceClass).name())
-                      << " -> "
-                      << attachment_point
-                      << " [len=15, weight=50]"
-                      << ';'
-                      << std::endl;
-
-        // end it with an empty line to make things easier to
-        // read when looking over stuff visually
-        output_stream << std::endl;
-      }
-    }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/ODE_statistics.h.bak b/include/aspect/postprocess/ODE_statistics.h.bak
deleted file mode 100644
index ea04ec501e0..00000000000
--- a/include/aspect/postprocess/ODE_statistics.h.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_ODE_statistics_h
-#define _aspect_postprocess_ODE_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes statistics about the ODEs solved in ASPECT.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class ODEStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Connect the callback functions to the respective signals.
-         */
-        void initialize() override;
-
-        /**
-         * Write the ODE statistics into the statistics file.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-      private:
-        /**
-         * This function clears all the saved solver information that is
-         * stored in this class. It is executed every time the output is
-         * written into the statistics object.
-         */
-        void
-        clear_data();
-
-        /**
-         * Callback function that is connected to the post_ARKode_solve
-         * signal to store the solver history.
-         */
-        void
-        store_ODE_solver_history(const unsigned int iteration_count);
-
-        /**
-          * Variables that store the ODE solver history of the current
-          * timestep, until they are written into the statistics object
-          * upon the call to execute(). They are cleared after writing
-          * the content.
-          */
-        unsigned int total_iteration_count;
-        unsigned int number_of_solves;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/basic_statistics.h.bak b/include/aspect/postprocess/basic_statistics.h.bak
deleted file mode 100644
index 5ddc6b16e41..00000000000
--- a/include/aspect/postprocess/basic_statistics.h.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_basic_statistics_h
-#define _aspect_postprocess_basic_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that outputs some simplified statistics
-     * like the Rayleigh number and other quantities that only
-     * make sense in certain model setups. The output is written
-     * after completing initial adaptive refinement steps.
-     * The postprocessor assumes a point at the surface at the adiabatic
-     * surface temperature and pressure is a reasonable reference condition
-     * for computing these properties. Furthermore, the Rayleigh
-     * number is computed using the model depth (i.e. not the
-     * radius of the Earth), as we need a definition that is geometry
-     * independent. Take care when comparing these values to published
-     * studies and make sure they use the same definitions.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class BasicStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some general statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/boundary_densities.h.bak b/include/aspect/postprocess/boundary_densities.h.bak
deleted file mode 100644
index e422a4de3b9..00000000000
--- a/include/aspect/postprocess/boundary_densities.h.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_boundary_densities_h
-#define _aspect_postprocess_boundary_densities_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes the laterally averaged density
-     * at the top and bottom boundaries of the solution.  This is useful
-     * for calculating the geoid at those surfaces.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class BoundaryDensities : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for laterally averaged density at the top
-         * and bottom of the domain.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Query the density at the top surface
-         */
-        double density_at_top() const;
-
-        /**
-         * Query the density at the bottom surface
-         */
-        double density_at_bottom() const;
-
-      private:
-
-        /**
-         * Density at the top of the domain.
-         * Filled when execute() is called.
-         */
-        double top_density;
-
-        /**
-         * Density at the bottom of the domain.
-         * Filled when execute() is called.
-         */
-        double bottom_density;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/boundary_pressures.h.bak b/include/aspect/postprocess/boundary_pressures.h.bak
deleted file mode 100644
index decca391fae..00000000000
--- a/include/aspect/postprocess/boundary_pressures.h.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_boundary_pressures_h
-#define _aspect_postprocess_boundary_pressures_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes the laterally averaged pressure
-     * at the top and bottom boundaries of the solution.  This is useful
-     * for calculating the dynamic topography at those surfaces.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class BoundaryPressures : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for the laterally averaged pressure at
-         * the top and bottom of the domain.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Query the pressure at the top surface
-         */
-        double pressure_at_top() const;
-
-        /**
-         * Query the pressure at the bottom surface
-         */
-        double pressure_at_bottom() const;
-
-      private:
-
-        /**
-         * Pressure at the top of the domain.
-         * Filled when execute() is called.
-         */
-        double top_pressure;
-
-        /**
-         * Pressure at the bottom of the domain.
-         * Filled when execute() is called.
-         */
-        double bottom_pressure;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/boundary_strain_rate_residual_statistics.h.bak b/include/aspect/postprocess/boundary_strain_rate_residual_statistics.h.bak
deleted file mode 100644
index 1931f32ab3a..00000000000
--- a/include/aspect/postprocess/boundary_strain_rate_residual_statistics.h.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_postprocess_boundary_strain_rate_residual_statistics_h
-#define _aspect_postprocess_boundary_strain_rate_residual_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the residual of the second invariant of the strain
-     * rate at the top surface. The residual is calculated as the difference between the second invariant of
-     * the modeled strain rate and a data file containing the second invariant of strain rate observations.
-     *
-     * @ingroup Postprocessing
-     */
-
-    template <int dim>
-    class BoundaryStrainRateResidualStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * This function reads the specified input surface strain rate data files as an ascii data file.
-         */
-        void initialize () override;
-
-        /**
-         * This function returns the reference surface strain rate read from the data file at the given point @p p.
-         */
-        double
-        get_data_surface_strain_rate (const Point<dim> &p) const;
-
-        /**
-         * Evaluate the solution to compute statistics about the residual of the second invariant of strain rate
-         * residual at the top boundary.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Pointer to the structured data containing the surface strain rate.
-         */
-        std::unique_ptr<Utilities::StructuredDataLookup<dim>> strain_rate_data_lookup;
-
-        /**
-         * Directory in which the input data files are present.
-         */
-        std::string data_directory;
-
-        /**
-         * Filename of the input ascii data file containing the surface strain rate components.
-         */
-        std::string data_file_name;
-
-        /**
-         * Scale the input data by a scalar factor. Can be used to transform
-         * the unit of the data (if they are not specified in SI units (/s or
-         * /yr depending on the "Use years in output instead of seconds"
-         * parameter).
-         */
-        double scale_factor;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/boundary_velocity_residual_statistics.h.bak b/include/aspect/postprocess/boundary_velocity_residual_statistics.h.bak
deleted file mode 100644
index 2c8873beae6..00000000000
--- a/include/aspect/postprocess/boundary_velocity_residual_statistics.h.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_postprocess_boundary_velocity_residual_statistics_h
-#define _aspect_postprocess_boundary_velocity_residual_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/boundary_velocity/gplates.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the velocity residual at the top surface.
-     * The velocity residual is calculated as the difference between the modeled velocities and
-     * input data velocities (GPlates model or ascii data).
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class BoundaryVelocityResidualStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * This function reads the specified input velocity data files, i.e., either an ascii data file or
-         * a file from the GPlates model.
-         */
-        void initialize () override;
-
-        /**
-         * This function returns the input data velocity, (GPlates model or ascii data)
-         * value at a point.  This function is called from execute() function.
-         */
-        Tensor<1,dim>
-        get_data_velocity (const Point<dim> &p) const;
-
-        /**
-         * Evaluate the solution statistics for some velocity residual at the top boundary.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Determines if the input ascii data file has velocity components in
-         * spherical, i.e., (r, phi, theta) or in cartesian, i.e., (x, y, z)
-         * coordinate system.
-         */
-        bool use_spherical_unit_vectors;
-
-        /**
-         * Determines if the model velocities are compared against ascii data
-         * files, or a gplates model.
-         */
-        bool use_ascii_data;
-
-        /**
-         * Pointer to the gplates boundary velocity model
-         */
-        std::unique_ptr<BoundaryVelocity::internal::GPlatesLookup<dim>> gplates_lookup;
-
-        /**
-         * Pointer to the structured data
-         */
-        std::unique_ptr<Utilities::StructuredDataLookup<dim>> data_lookup;
-
-        /**
-         * Directory in which the input data files, i.e., GPlates model or ascii data
-         * are present.
-         */
-        std::string data_directory;
-
-        /**
-         * Filename of the input Gplates model or ascii data file. For GPlates, the file names
-         * can contain the specifiers %s and/or %c (in this order), meaning the name of the
-         * boundary and the number of the data file time step.
-         */
-        std::string data_file_name;
-
-        /**
-         * Scale the input data by a scalar factor. Can be used to transform
-         * the unit of the data (if they are not specified in SI units (m/s or
-         * m/yr depending on the "Use years in output instead of seconds"
-         * parameter).
-         */
-        double scale_factor;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/command.h.bak b/include/aspect/postprocess/command.h.bak
deleted file mode 100644
index f354c890cba..00000000000
--- a/include/aspect/postprocess/command.h.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_command_h
-#define _aspect_postprocess_command_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <cstdlib>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that runs a shell command at the end of each time step.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class Command : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Declare new parameters
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Parse parameters
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Execute the command
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-      private:
-        std::string command;
-        bool terminate_on_failure;
-        bool on_all_processes;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/composition_statistics.h.bak b/include/aspect/postprocess/composition_statistics.h.bak
deleted file mode 100644
index 6f815ca96b0..00000000000
--- a/include/aspect/postprocess/composition_statistics.h.bak
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_composition_statistics_h
-#define _aspect_postprocess_composition_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the compositional
-     * fields, if any.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class CompositionStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some temperature statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/composition_velocity_statistics.h.bak b/include/aspect/postprocess/composition_velocity_statistics.h.bak
deleted file mode 100644
index c9e68b32173..00000000000
--- a/include/aspect/postprocess/composition_velocity_statistics.h.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_composition_velocity_statistics_h
-#define _aspect_postprocess_composition_velocity_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes the root mean square velocity
-     * over the area spanned by each of the compositional fields.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class CompositionVelocityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution to compute the RMS velocity for each composition.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static void
-        declare_parameters(ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters(ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        std::vector<std::string> selected_fields;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/core_statistics.h.bak b/include/aspect/postprocess/core_statistics.h.bak
deleted file mode 100644
index 8dc7e84dc5c..00000000000
--- a/include/aspect/postprocess/core_statistics.h.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_core_statistics_h
-#define _aspect_postprocess_core_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/boundary_temperature/dynamic_core.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the dynamic core.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class CoreStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        CoreStatistics ();
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Evaluate statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Export core data stored in this object. Doing this only because the boundary
-         * temperature doesn't allowed to store restart data there. So we store the data needed
-         * for restart here and exported to boundary temperature object if required.
-         */
-        const BoundaryTemperature::internal::CoreData &
-        get_core_data() const;
-
-        /**
-         * Serialize the contents of this class as far as they are not read
-         * from input parameter files.
-         */
-        template <class Archive>
-        void serialize (Archive &ar, const unsigned int version);
-
-        /**
-         * Save the state of this object.
-         */
-        void save (std::map<std::string, std::string> &status_strings) const override;
-
-        /**
-         * Restore the state of the object.
-         */
-        void load (const std::map<std::string, std::string> &status_strings) override;
-
-      private:
-        /**
-         * Controls whether output the total excess entropy or the individual entropy terms
-         * (i.e. entropy for specific heat, radioactive heating, gravitational contribution,
-         * and adiabatic contribution).
-         */
-        bool   excess_entropy_only;
-
-        /**
-         * Stores the core data from boundary temperature.
-         */
-        struct  BoundaryTemperature::internal::CoreData core_data;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/crystal_preferred_orientation.h.bak b/include/aspect/postprocess/crystal_preferred_orientation.h.bak
deleted file mode 100644
index 554f8f744af..00000000000
--- a/include/aspect/postprocess/crystal_preferred_orientation.h.bak
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
- Copyright (C) 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_postprocess_crystal_preferred_orientation_h
-#define _aspect_postprocess_crystal_preferred_orientation_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/particle/world.h>
-
-#include <aspect/simulator_access.h>
-
-#include <deal.II/particles/particle_handler.h>
-#include <deal.II/base/data_out_base.h>
-#include <tuple>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    /**
-     * A Postprocessor that writes out CPO specific particle data.
-     * It can write out the CPO data as it is stored (raw) and/or as a
-     * random draw volume weighted representation. The latter one
-     * is recommended for plotting against real data. For both representations
-     * the specific output fields and their order can be set.
-     */
-    template <int dim>
-    class CrystalPreferredOrientation : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        CrystalPreferredOrientation();
-
-        /**
-         * Destructor.
-         */
-        ~CrystalPreferredOrientation();
-
-
-        /**
-         * Initialize function.
-         */
-        void initialize () override;
-
-        /**
-         * A Postprocessor that writes out CPO specific particle data.
-         * It can write out the CPO data as it is stored (raw) and/or as a
-         * random draw volume weighted representation. The latter one
-         * is recommended for plotting against real data. For both representations
-         * the specific output fields and their order can be set.
-         */
-        std::pair<std::string,std::string> execute (TableHandler &statistics) override;
-
-        /**
-         * This function ensures that the particle postprocessor is run before
-         * this postprocessor.
-         */
-        std::list<std::string>
-        required_other_postprocessors () const override;
-
-        /**
-        * Declare the parameters this class takes through input files.
-        */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-
-        /**
-         * Stores the simulation end time, so that it always produces output
-         * at the last timestep.
-         */
-        double end_time;
-
-        /**
-         * Enums specifying what information to write:
-         *
-         * VolumeFraction: Write the volume fraction
-         * RotationMatrix: Write the whole rotation matrix of a grain (in deal.ii order)
-         * EulerAngles: Write out the Z-X-Z Euler angle of a grain
-         * not_found: Error enum, the requested output was not found
-         */
-        enum class Output
-        {
-          VolumeFraction, RotationMatrix, EulerAngles, not_found
-        };
-
-        /**
-         * Converts a string to an Output enum.
-         */
-        Output string_to_output_enum(const std::string &string);
-
-        /**
-         * Random number generator used for random draw volume weighting.
-         */
-        mutable std::mt19937 random_number_generator;
-
-        /**
-         * Random number generator seed used to initialize the random number generator.
-         */
-        unsigned int random_number_seed;
-
-        /**
-         * Interval between output (in years if appropriate simulation
-         * parameter is set, otherwise seconds)
-         */
-        double output_interval;
-
-        /**
-         * Records time for next output to occur
-         */
-        double last_output_time;
-
-        /**
-         * Set the time output was supposed to be written. In the simplest
-         * case, this is the previous last output time plus the interval, but
-         * in general we'd like to ensure that it is the largest supposed
-         * output time, which is smaller than the current time, to avoid
-         * falling behind with last_output_time and having to catch up once
-         * the time step becomes larger. This is done after every output.
-         */
-        void set_last_output_time (const double current_time);
-
-        /**
-         * Consecutively counted number indicating the how-manyth time we will
-         * create output the next time we get to it.
-         */
-        unsigned int output_file_number;
-
-        /**
-         * Graphical output format.
-         */
-        std::vector<std::string> output_formats;
-
-        /**
-         * A list of pairs (time, pvtu_filename) that have so far been written
-         * and that we will pass to DataOutInterface::write_pvd_record
-         * to create a main file that can make the association
-         * between simulation time and corresponding file name (this
-         * is done because there is no way to store the simulation
-         * time inside the .pvtu or .vtu files).
-         */
-        std::vector<std::pair<double,std::string>> times_and_pvtu_file_names;
-
-        /**
-         * A corresponding variable that we use for the .visit files created
-         * by DataOutInterface::write_visit_record. The second part of a
-         * pair contains all files that together form a time step.
-         */
-        std::vector<std::pair<double,std::vector<std::string>>> times_and_vtu_file_names;
-
-        /**
-         * A list of list of filenames, sorted by timestep, that correspond to
-         * what has been created as output. This is used to create a main
-         * .visit file for the entire simulation.
-         */
-        std::vector<std::vector<std::string>> output_file_names_by_timestep;
-
-        /**
-         * A set of data related to XDMF file sections describing the HDF5
-         * heavy data files created. These contain things such as the
-         * dimensions and names of data written at all steps during the
-         * simulation.
-         */
-        std::vector<XDMFEntry>  xdmf_entries;
-
-        /**
-         * VTU file output supports grouping files from several CPUs into one
-         * file using MPI I/O when writing on a parallel filesystem. 0 means
-         * no grouping (and no parallel I/O). 1 will generate one big file
-         * containing the whole solution.
-         */
-        unsigned int group_files;
-
-        /**
-         * On large clusters it can be advantageous to first write the
-         * output to a temporary file on a local file system and later
-         * move this file to a network file system. If this variable is
-         * set to a non-empty string it will be interpreted as a temporary
-         * storage location.
-         */
-        std::string temporary_output_location;
-
-        /**
-         * File operations can potentially take a long time, blocking the
-         * progress of the rest of the model run. Setting this variable to
-         * 'true' moves this process into a background thread, while the
-         * rest of the model continues.
-         */
-        bool write_in_background_thread;
-
-        /**
-         * Handle to a thread that is used to write main file data in the
-         * background. The writer() function runs on this background thread.
-         */
-        std::thread background_thread_main;
-
-        /**
-         * What "raw" CPO data to write out.
-         */
-        std::vector<std::pair<unsigned int,Output>> write_raw_cpo;
-
-        /**
-         * Whether computing raw Euler angles is needed.
-         */
-        bool compute_raw_euler_angles;
-
-        /**
-         * Handle to a thread that is used to write content file data in the
-         * background. The writer() function runs on this background thread.
-         */
-        std::thread background_thread_content_raw;
-
-        /**
-         * What "draw volume weighted" CPO data to write out. Draw volume weighted means
-         * the grain properties (size and rotation) are put in a list sorted based by volume
-         * and picked randomly, with large volumes having a higher chance of being picked.
-         */
-        std::vector<std::pair<unsigned int,Output>> write_draw_volume_weighted_cpo;
-
-        /**
-         * Whether computing weighted A matrix is needed.
-         */
-        bool compute_weighted_rotation_matrix;
-
-        /**
-         * Handle to a thread that is used to write content file data in the
-         * background. The writer() function runs on this background thread.
-         */
-        std::thread background_thread_content_draw_volume_weighting;
-
-        /**
-         * Whether to compress the raw and weighed cpo data output files with zlib.
-         */
-        bool compress_cpo_data_files;
-
-        /**
-         * A function that writes the text in the second argument to a file
-         * with the name given in the first argument. The function is run on a
-         * separate thread to allow computations to continue even though
-         * writing data is still continuing. The function takes over ownership
-         * of these arguments and deletes them at the end of its work.
-         */
-        static
-        void writer (const std::string &filename,
-                     const std::string &temporary_filename,
-                     const std::string &file_contents,
-                     const bool compress_contents);
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/depth_average.h.bak b/include/aspect/postprocess/depth_average.h.bak
deleted file mode 100644
index f8fa3dc5f0f..00000000000
--- a/include/aspect/postprocess/depth_average.h.bak
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_depth_average_h
-#define _aspect_postprocess_depth_average_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/data_out_base.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that generates depth average output in periodic
-     * intervals or every time step.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class DepthAverage : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        DepthAverage ();
-
-        /**
-         * Evaluate the solution and compute the requested depth averages.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Save the state of this object.
-         */
-        void save (std::map<std::string, std::string> &status_strings) const override;
-
-        /**
-         * Restore the state of the object.
-         */
-        void load (const std::map<std::string, std::string> &status_strings) override;
-
-        /**
-         * Serialize the contents of this class as far as they are not read
-         * from input parameter files.
-         */
-        template <class Archive>
-        void serialize (Archive &ar, const unsigned int version);
-
-      private:
-        /**
-         * Interval between the generation of output in seconds. This parameter is read
-         * from the input file and consequently is not part of the state that
-         * needs to be saved and restored.
-         */
-        double output_interval;
-
-        /**
-         * A time (in seconds) the last output has been produced.
-         */
-        double last_output_time;
-
-        /**
-         * The formats in which to produce graphical output. This also
-         * determines the extension of the file names to which to write.
-         */
-        std::vector<std::string> output_formats;
-
-        /**
-         * Number of zones in depth direction over which we are supposed to
-         * average.
-         */
-        unsigned int n_depth_zones;
-
-        /**
-         * The boundaries of the depth zones.
-         * This vector contains exactly n_depth_zones + 1 entries,
-         * and entries i and i+1 represent the lower and upper depth bound
-         * of zone i.
-         */
-        std::vector<double> depth_bounds;
-
-        /**
-         * List of the quantities to calculate for each depth zone.
-         */
-        std::vector<std::string> variables;
-
-        /**
-         * A structure for a single time step record.
-         */
-        struct DataPoint
-        {
-          double time;
-          std::vector<std::vector<double>> values;
-
-          template <class Archive>
-          void serialize (Archive &ar, const unsigned int version);
-        };
-
-        /**
-         * An array of all the past values
-         */
-        std::vector<DataPoint> entries;
-
-        /**
-         * Set the time output was supposed to be written. In the simplest
-         * case, this is the previous last output time plus the interval, but
-         * in general we'd like to ensure that it is the largest supposed
-         * output time, which is smaller than the current time, to avoid
-         * falling behind with last_output_time and having to catch up once
-         * the time step becomes larger. This is done after every output.
-         */
-        void set_last_output_time (const double current_time);
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/domain_volume_statistics.h.bak b/include/aspect/postprocess/domain_volume_statistics.h.bak
deleted file mode 100644
index 5912863fa66..00000000000
--- a/include/aspect/postprocess/domain_volume_statistics.h.bak
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_domain_volume_statistics_h
-#define _aspect_postprocess_domain_volume_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes the total area (2D) or volume (3D)
-     * of the computational domain.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class DomainVolume : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some mass_flux statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/dynamic_topography.h.bak b/include/aspect/postprocess/dynamic_topography.h.bak
deleted file mode 100644
index a9f218cd3fe..00000000000
--- a/include/aspect/postprocess/dynamic_topography.h.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_surface_topography_h
-#define _aspect_postprocess_surface_topography_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes dynamic topography at the top and bottom of the domain.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class DynamicTopography : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for the dynamic topography.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Return the topography vector as calculated by the consistent
-         * boundary flux (CBF) formulation.
-         * The velocity components store the surface-normal traction,
-         * and the temperature component stores the dynamic topography
-         * computed from that traction.
-         */
-        const LinearAlgebra::BlockVector &
-        topography_vector() const;
-
-        /**
-         * Return the cell-wise topography vector as calculated by the CBF formulation,
-         * where indices of the vector correspond to cell indices.
-         * This vector is considerably smaller than the full topography vector returned
-         * by topography_vector(), and is useful for text output and visualization.
-         */
-        const Vector<float> &
-        cellwise_topography() const;
-
-        /**
-         * Register the other postprocessor that we need: BoundaryPressures
-         */
-        std::list<std::string>
-        required_other_postprocessors() const override;
-
-        /**
-         * Parse the parameters for the postprocessor.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Declare the parameters for the postprocessor.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-      private:
-        /**
-         * Output the dynamic topography solution to
-         * a file for a given boundary id. All the values
-         * in @p position_and_topography are written to a file
-         * with a file name determined by @p boundary_id.
-         */
-        void output_to_file(const types::boundary_id boundary_id,
-                            const std::vector<std::pair<Point<dim>, double>> &position_and_topography);
-
-        /**
-         * A vector which stores the surface stress values calculated
-         * by the postprocessor.
-         */
-        LinearAlgebra::BlockVector topo_vector;
-
-        /**
-         * A vector which stores the surface stress values calculated
-         * at the midpoint of each surface cell face. This can be
-         * given to a visualization postprocessor to output dynamic topography.
-         */
-        Vector<float> visualization_values;
-
-        /**
-         * A parameter that allows users to set the density value
-         * above the top surface.
-         */
-        double density_above;
-
-        /**
-         * A parameter that allows users to set the density value
-         * below the bottom surface.
-         */
-        double density_below;
-
-        /**
-         * Whether to output the surface topography.
-         */
-        bool output_surface;
-
-        /**
-         * Whether to output the bottom topography.
-         */
-        bool output_bottom;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/entropy_viscosity_statistics.h.bak b/include/aspect/postprocess/entropy_viscosity_statistics.h.bak
deleted file mode 100644
index 17d0f002cf1..00000000000
--- a/include/aspect/postprocess/entropy_viscosity_statistics.h.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-  Copyright (C) 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_entropy_viscosity_statistics_h
-#define _aspect_postprocess_entropy_viscosity_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    /**
-     * A postprocessor that computes the maximum and volume averaged
-     * entropy viscosity stabilization for the temperature equation.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class EntropyViscosityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some entropy viscosity stabilization statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/geoid.h.bak b/include/aspect/postprocess/geoid.h.bak
deleted file mode 100644
index cecc6cad96e..00000000000
--- a/include/aspect/postprocess/geoid.h.bak
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _aspect_postprocess_geoid_h
-#define _aspect_postprocess_geoid_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    /**
-     * A postprocessor that computes the geoid anomaly at the surface.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class Geoid : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for the geoid in spherical harmonics and then transfer it to grid output.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Register with the simulator the other postprocessors that we need
-         * (namely: dynamic topography).
-         */
-        std::list<std::string>
-        required_other_postprocessors() const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Find if the top or bottom boundaries are free surfaces.
-         */
-        void initialize() override;
-
-        /**
-         * Evaluate the geoid solution at a point. The evaluation point
-         * must be outside of the model domain, and it must be called
-         * after execute().
-         */
-        double
-        evaluate (const Point<dim> &) const;
-
-      private:
-        /**
-         * Parameters to set the maximum and minimum degree when computing geoid from spherical harmonics
-         */
-        unsigned int max_degree;
-        unsigned int min_degree;
-
-        /**
-         * A parameter to control whether to output the data in geographical coordinates.
-         * If true, output the data in longitudes and latitudes; if false, output data in x y z.
-         */
-        bool output_in_lat_lon;
-
-        /**
-         * A parameter to control whether to output the spherical harmonic coefficients of the geoid anomaly
-         */
-        bool output_geoid_anomaly_SH_coes;
-
-        /**
-         * A parameter to control whether to output the spherical harmonic coefficients of the surface topography contribution
-         */
-        bool output_surface_topo_contribution_SH_coes;
-
-        /**
-         * A parameter to control whether to output the spherical harmonic coefficients of the CMB topography contribution
-         */
-        bool output_CMB_topo_contribution_SH_coes;
-
-        /**
-         * A parameter to control whether to output the spherical harmonic coefficients of the density anomaly
-         */
-        bool output_density_anomaly_contribution_SH_coes;
-
-        /**
-         * A parameter to control whether to output the free-air gravity anomaly
-         */
-        bool output_gravity_anomaly;
-
-        /**
-         * Parameters to set the density value out of the surface and CMB boundary
-         */
-        double density_above;
-        double density_below;
-
-        /**
-         * A parameter to control whether to include the surface topography contribution on geoid
-         */
-        bool include_surface_topo_contribution;
-
-        /**
-         * A parameter to control whether to include the CMB topography contribution on geoid
-         */
-        bool include_CMB_topo_contribution;
-
-        /**
-         * A parameter to specify if the top boundary is an active free surface
-         */
-        bool use_free_surface_topography;
-
-        /**
-         * A parameter to specify if the bottom boundary is an active free surface
-         */
-        bool use_free_CMB_topography;
-
-        /**
-         * Function to compute the real spherical harmonic coefficients (cos and sin part) from min degree to max degree
-         * The input spherical_function is a vector of vectors.
-         * The inner vector stores theta, phi, spherical infinitesimal, and function value on a spherical surface.
-         * The outer vector stores the inner vector associated with each quadrature point on a spherical surface.
-         */
-        std::pair<std::vector<double>,std::vector<double>>
-        to_spherical_harmonic_coefficients(const std::vector<std::vector<double>> &spherical_function) const;
-
-        /**
-         * Function to compute the density contribution in spherical harmonic expansion throughout the mantle
-         * The input outer radius is needed to evaluate the density integral contribution of whole model domain at the surface
-         * This function returns a pair containing real spherical harmonics of density integral (cos and sin part) from min degree to max degree.
-         */
-        std::pair<std::vector<double>,std::vector<double>>
-        density_contribution (const double &outer_radius) const;
-
-        /**
-         * Function to compute the surface and CMB topography contribution in spherical harmonic expansion
-         * The input inner and outer radius are used to calculate spherical infinitesimal area, i.e., sin(theta)*d_theta*d_phi
-         * associated with each quadrature point on surface and bottom respectively.
-         * This function returns a pair containing surface and CMB topography's real spherical harmonic coefficients (cos and sin part)
-         * from min degree to max degree. The surface and CMB average density are also included as the first single element of each subpair respectively.
-         * The topography is based on the dynamic topography postprocessor in case of no free surface,
-         * and based on the real surface from the geometry model in case of a free surface.
-         */
-        std::pair<std::pair<double, std::pair<std::vector<double>,std::vector<double>>>, std::pair<double, std::pair<std::vector<double>,std::vector<double>>>>
-        topography_contribution(const double &outer_radius,
-                                const double &inner_radius) const;
-
-        /**
-         * A vector to store the cosine terms of the geoid anomaly spherical harmonic coefficients.
-         */
-        std::vector<double> geoid_coecos;
-        /**
-         * A vector to store the sine terms of the geoid anomaly spherical harmonic coefficients.
-         */
-        std::vector<double> geoid_coesin;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/global_statistics.h.bak b/include/aspect/postprocess/global_statistics.h.bak
deleted file mode 100644
index 9e643447dad..00000000000
--- a/include/aspect/postprocess/global_statistics.h.bak
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
-  Copyright (C) 2017 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_global_statistics_h
-#define _aspect_postprocess_global_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/lac/solver_control.h>
-
-namespace aspect
-{
-
-  namespace Postprocess
-  {
-    /**
-     * A postprocessor that outputs all the global statistics
-     * information, e.g. the time of the simulation, the timestep
-     * number, number of degrees of freedom and solver iterations
-     * for each timestep. The postprocessor can output different
-     * formats, the first printing one line in the statistics file
-     * per nonlinear solver iteration (if a nonlinear solver scheme
-     * is selected). The second prints one line per timestep,
-     * summing the information about all nonlinear iterations in
-     * this line. Note that this postprocessor is always active
-     * independent on whether or not it is selected in the
-     * parameter file.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class GlobalStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Connect the callback functions to the respective signals.
-         */
-        void initialize() override;
-
-        /**
-         * Write all global statistics columns into the statistics object.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-
-      private:
-        /**
-         * Write global statistics such as the time step number and the
-         * number of degrees of freedom into the statistics object.
-         */
-        void
-        generate_global_statistics(TableHandler &statistics);
-
-        /**
-         * This function clears all the saved solver information that is
-         * stored in this class. It is executed every time the output is
-         * written into the statistics object, but also after each initial
-         * refinement step, in case it is not written (to avoid summing
-         * information across different refinement steps).
-         */
-        void
-        clear_data();
-
-        /**
-         * Callback function that is connected to the post_stokes_solver
-         * signal to store the solver history.
-         */
-        void
-        store_stokes_solver_history(const unsigned int number_S_iterations,
-                                    const unsigned int number_A_iterations,
-                                    const SolverControl &solver_control_cheap,
-                                    const SolverControl &solver_control_expensive);
-
-        /**
-         * Callback function that is connected to the post_advection_solver
-         * signal to store the solver history.
-         */
-        void
-        store_advection_solver_history(const bool solved_temperature_field,
-                                       const unsigned int compositional_index,
-                                       const SolverControl &solver_control);
-
-        /**
-         * Variables that store the Stokes solver history of the current
-         * timestep, until they are written into the statistics object
-         * upon the call to execute(). They are cleared after writing
-         * the content.
-         */
-        std::vector<unsigned int> list_of_S_iterations;
-        std::vector<unsigned int> list_of_A_iterations;
-        std::vector<unsigned int> stokes_iterations_cheap;
-        std::vector<unsigned int> stokes_iterations_expensive;
-
-        /**
-         * A container that stores the advection solver history of the current
-         * timestep, until it is written into the statistics object
-         * upon the call to execute(). It is cleared after writing
-         * the content. The vector contains pairs, which consist
-         * of a column name (for the temperature or one of the
-         * compositional fields), and a vector of SolverControl
-         * objects (one per nonlinear iteration for this particular
-         * field). This layout allows storing varying numbers of
-         * nonlinear iterations for temperature and compositional fields
-         * (if any nonlinear solver scheme would implement that at
-         * some point).
-         */
-        std::vector<std::pair<std::string, std::vector<unsigned int>>> advection_iterations;
-
-        /**
-         * Whether to put every nonlinear iteration into a separate
-         * line in the statistics file or to only output one line
-         * per time step.
-         */
-        bool one_line_per_iteration;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/gravity_point_values.h.bak b/include/aspect/postprocess/gravity_point_values.h.bak
deleted file mode 100644
index 463a30adeb3..00000000000
--- a/include/aspect/postprocess/gravity_point_values.h.bak
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
-  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_gravity_point_values_h
-#define _aspect_postprocess_gravity_point_values_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes gravity, gravity anomalies, gravity potential and
-     * gravity gradients for a set of points (e.g. satellites) in or above the model
-     * surface for a user-defined range of latitudes, longitudes and radius, or a list
-     * of point coordinates. Spherical coordinates in the output file are radius,
-     * colatitude and colongitude. Gravity is here based on the density distribution
-     * from the material model (and non adiabatic). This means that the density may
-     * come directly from an ascii file. This postprocessor also computes theoretical
-     * gravity and its derivatives, which corresponds to the analytical solution of gravity
-     * in the same geometry but filled with a reference density. The reference density
-     * is also used to determine the density difference for computing gravity anomalies.
-     * Thus one must carefully evaluate the meaning of the gravity anomaly output,
-     * because the solution may not reflect the actual gravity anomaly (due to
-     * differences in the assumed reference density). One way to guarantee correct
-     * gravity anomalies is to subtract the gravity of a certain point from the average
-     * gravity on the map. Another way is to directly use density anomalies for this
-     * postprocessor.
-     * The average- minimum- and maximum gravity acceleration and potential are written
-     * into the statistics file.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class GravityPointValues : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        GravityPointValues ();
-
-        /**
-         * @copydoc Interface::initialize().
-         */
-        void initialize() override;
-
-        /**
-         * Specify the creation of output_gravity.txt.
-         */
-        std::pair<std::string,std::string> execute (TableHandler &) override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Serialize the contents of this class as far as they are not read
-         * from input parameter files.
-         */
-        template <class Archive>
-        void serialize (Archive &ar, const unsigned int version);
-
-        /**
-         * Save the state of this object.
-         */
-        void save (std::map<std::string, std::string> &status_strings) const override;
-
-        /**
-         * Restore the state of the object.
-         */
-        void load (const std::map<std::string, std::string> &status_strings) override;
-
-      private:
-        /**
-         * Interval between the generation of gravity output.
-         */
-        double output_interval;
-
-        /**
-         * A time (in seconds) at which the last graphical output was supposed
-         * to be produced. Used to check for the next necessary output time.
-         */
-        double last_output_time;
-
-        /**
-         * Maximum number of steps between the generation of gravity output.
-         */
-        unsigned int maximum_timesteps_between_outputs;
-
-        /**
-         * Timestep at which the last gravity output was produced
-         * Used to check for the next necessary output time.
-         */
-        unsigned int last_output_timestep;
-
-        /**
-         * Consecutively counted number indicating the how-manyth time we will
-         * create output the next time we get to it.
-         */
-        unsigned int output_file_number;
-
-        /**
-         * end_time is taken from parameter file. It is used to tell the
-         * postprocessor to write gravity output at the end time.
-         */
-        double end_time;
-
-        /**
-         * Set the time output was supposed to be written. In the simplest
-         * case, this is the previous last output time plus the interval, but
-         * in general we'd like to ensure that it is the largest supposed
-         * output time, which is smaller than the current time, to avoid
-         * falling behind with last_output_time and having to catch up once
-         * the time step becomes larger. This is done after every output.
-         */
-        void set_last_output_time (const double current_time);
-
-        /**
-         * Set the precision of the gravity acceleration, potential and gradients
-         * in the gravity output and statistics file.
-         */
-        unsigned int precision;
-
-        /**
-         * Quadrature degree increase over the velocity element degree may be required when
-         * gravity is calculated near the surface or inside the model. An increase in the
-         * quadrature element adds accuracy to the gravity solution from noise due to the
-         * model grid.
-         */
-        unsigned int quadrature_degree_increase;
-
-        /**
-         * Parameter for the fibonacci spiral sampling scheme:
-         */
-        unsigned int n_points_spiral;
-
-        /**
-         * Parameter for the map and fibonacci spiral sampling scheme:
-         * Gravity may be calculated for a sets of points along the radius (e.g. depth
-         * profile) between a minimum and maximum radius. Number of points along the radius
-         * is specified with n_points_radius.
-         */
-        unsigned int n_points_radius;
-
-        /**
-         * Parameter for the map sampling scheme:
-         * Gravity may be calculated for a sets of points along the longitude (e.g. satellite
-         * mapping) between a minimum and maximum longitude. Number of points along the
-         * longitude is specified with n_points_longitude.
-         */
-        unsigned int n_points_longitude;
-
-        /**
-         * Parameter for the map sampling scheme:
-         * Gravity may be calculated for a sets of points along the latitude (e.g. satellite
-         * mapping) between a minimum and maximum latitude. Number of points along the
-         * latitude is specified with n_points_latitude.
-         */
-        unsigned int n_points_latitude;
-
-        /**
-         * Parameter for the map and fibonacci spiral sampling scheme:
-         * Prescribe a minimum radius for a sampling coverage at a specific height.
-         * May be set in- or outside the model domain.
-         */
-        double minimum_radius;
-
-        /**
-         * Parameter for the map and fibonacci spiral sampling scheme:
-         * Maximum radius for the radius range.
-         * May be set in- or outside the model domain.
-         * No need to specify maximum_radius if n_points_radius is 1.
-         */
-        double maximum_radius;
-
-        /**
-         * Parameter for the map sampling scheme:
-         * Minimum longitude for longitude range.
-         */
-        double minimum_colongitude;
-
-        /**
-         * Parameter for the map sampling scheme:
-         * Maximum longitude for the longitude range.
-         * No need to specify maximum_longitude if n_points_longitude is 1.
-         */
-        double maximum_colongitude;
-
-        /**
-         * Parameter for the map sampling scheme:
-         * Minimum latitude for the latitude range.
-         */
-        double minimum_colatitude;
-
-        /**
-         * Parameter for the map sampling scheme:
-         * Maximum latitude for the latitude range.
-         * No need to specify maximum_latitude if n_points_latitude is 1.
-         */
-        double maximum_colatitude;
-
-        /**
-         * A reference density is required for two purposes:
-         * 1) benchmark the gravity postprocessor with computing analytically gravity
-         * acceleration and gradients in the domain filled with a constant density.
-         * 2) calculate the density difference of the density given by the material
-         * model and a constant density, in order to compute gravity anomalies.
-         */
-        double reference_density;
-
-        /**
-         * Specify the sampling scheme determining if gravity calculation is performed.
-         */
-        enum SamplingScheme
-        {
-          map,
-          fibonacci_spiral,
-          list_of_points
-        } sampling_scheme;
-
-        /**
-         * Parameter for the list of points sampling scheme:
-         * List of radius coordinates for the list of points sampling scheme.
-         * Must follow the same order as the lists of longitude and latitude.
-         */
-        std::vector<double> radius_list;
-
-        /**
-         * Parameter for the list of points sampling scheme:
-         * List of longitude coordinates for the list of points sampling scheme.
-         * Must follow the same order as the lists of radius and latitude.
-         */
-        std::vector<double> longitude_list;
-
-        /**
-         * Parameter for the list of points sampling scheme:
-         * List of latitude coordinates for the list of points sampling scheme.
-         * Must follow the same order as the lists of longitude and longitude.
-         */
-        std::vector<double> latitude_list;
-
-        // ------------ the following variables are not set from parameters,
-        //              but are instead computed up front from input
-        //              parameters and other parts of the overall model
-        double model_outer_radius;
-        double model_inner_radius;
-
-        /**
-         * The positions of all satellite positions in spherical and
-         * Cartesian coordinate systems.
-         */
-        std::vector<std::array<double,dim>> satellite_positions_spherical;
-        std::vector<Point<dim>>             satellite_positions_cartesian;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/heat_flux_densities.h.bak b/include/aspect/postprocess/heat_flux_densities.h.bak
deleted file mode 100644
index 4167c75b2fa..00000000000
--- a/include/aspect/postprocess/heat_flux_densities.h.bak
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_heat_flux_densities_h
-#define _aspect_postprocess_heat_flux_densities_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes average heat flux densities for each
-     * boundary.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class HeatFluxDensities : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/heat_flux_map.h.bak b/include/aspect/postprocess/heat_flux_map.h.bak
deleted file mode 100644
index 84477eddbbb..00000000000
--- a/include/aspect/postprocess/heat_flux_map.h.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_heat_flux_map_h
-#define _aspect_postprocess_heat_flux_map_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace internal
-    {
-      /**
-       * Compute the heat flux for boundaries with prescribed temperature (Dirichlet
-       * boundary conditions) using the consistent boundary flux method. The method
-       * is described in
-       *
-       * Gresho, P. M., Lee, R. L., Sani, R. L., Maslanik, M. K., & Eaton, B. E. (1987).
-       * The consistent Galerkin FEM for computing derived boundary quantities in thermal and or fluids
-       * problems. International Journal for Numerical Methods in Fluids, 7(4), 371-394.
-       *
-       * In summary, the method solves the temperature equation again on the boundary faces, with known
-       * temperatures and solving for the boundary fluxes that satisfy the equation. Since the
-       * equation is only formed on the faces and it can be solved using only diagonal matrices,
-       * the computation is cheap. Conceptually simpler methods like evaluating the temperature
-       * gradient on the face are significantly less accurate.
-       *
-       * The function returns a solution vector, which contains the heat flux in the temperature
-       * block of the vector.
-       */
-      template <int dim>
-      LinearAlgebra::BlockVector
-      compute_dirichlet_boundary_heat_flux_solution_vector (const SimulatorAccess<dim> &simulator_access);
-
-      /**
-       * This function computes the combined heat flux through each boundary face (conductive + advective).
-       * For reflecting boundaries the conductive heat flux is 0, for boundaries with prescribed heat flux
-       * (inhomogeneous Neumann boundary conditions) it is simply the integral of the prescribed heat flux over
-       * the face, and for boundaries with non-tangential velocities the advective heat flux is computed as
-       * the integral over the advective heat flux density.
-       * For boundaries with prescribed temperature (Dirichlet boundary conditions) the heat flux
-       * is computed using the compute_dirichlet_boundary_heat_flux_solution_vector() function.
-       *
-       * The function returns a vector with as many entries as active cells. For each locally owned
-       * cell it contains a vector with one entry per face. Each of these entries contains a pair
-       * of doubles, containing the combined heat flux (first entry) and face area (second entry).
-       * This function is a helper function that unifies the complex heat flux computation necessary
-       * for several postprocessors.
-       */
-      template <int dim>
-      std::vector<std::vector<std::pair<double, double>>>
-      compute_heat_flux_through_boundary_faces (const SimulatorAccess<dim> &simulator_access);
-    }
-
-    /**
-     * A postprocessor that computes the point-wise heat flux density through the boundaries.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class HeatFluxMap : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for the heat flux.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-      private:
-        /**
-         * Output the heat flux density for the boundary determined
-         * by @p boundary_id to a file. The heat flux density is
-         * handed over in the vector @p heat_flux_and_area. This vector
-         * is expected to be of the structure described for the return value
-         * of the function compute_heat_flux_through_boundary_faces() and
-         * only the values at the faces of the given @p boundary_id are
-         * written to the file.
-         */
-        void output_to_file(const types::boundary_id boundary_id,
-                            const std::vector<std::vector<std::pair<double, double>>> &heat_flux_and_area);
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/heat_flux_statistics.h.bak b/include/aspect/postprocess/heat_flux_statistics.h.bak
deleted file mode 100644
index fb9e7ee6983..00000000000
--- a/include/aspect/postprocess/heat_flux_statistics.h.bak
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_heat_flux_statistics_h
-#define _aspect_postprocess_heat_flux_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the heat_flux.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class HeatFluxStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some heat_flux statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/heating_statistics.h.bak b/include/aspect/postprocess/heating_statistics.h.bak
deleted file mode 100644
index 77fa48fd012..00000000000
--- a/include/aspect/postprocess/heating_statistics.h.bak
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_postprocess_heating_statistics_h
-#define _aspect_postprocess_heating_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the
-     * heating rate. This includes all of the heating processes
-     * specified in the parameter file, i.e. shear heating,
-     * adiabatic heating and radiogenic heat production.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class HeatingStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some heating rate statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/interface.h.bak b/include/aspect/postprocess/interface.h.bak
deleted file mode 100644
index 623d4facf62..00000000000
--- a/include/aspect/postprocess/interface.h.bak
+++ /dev/null
@@ -1,380 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_interface_h
-#define _aspect_postprocess_interface_h
-
-#include <aspect/global.h>
-#include <aspect/plugins.h>
-#include <aspect/simulator_access.h>
-
-#include <memory>
-#include <deal.II/base/table_handler.h>
-#include <deal.II/base/parameter_handler.h>
-
-#include <boost/serialization/split_member.hpp>
-#include <boost/core/demangle.hpp>
-
-#include <typeinfo>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim> class Simulator;
-  template <int dim> class SimulatorAccess;
-
-
-  /**
-   * A namespace for everything to do with postprocessing solutions every time
-   * step or every few time steps.
-   *
-   * @ingroup Postprocessing
-   */
-  namespace Postprocess
-  {
-
-    /**
-     * This class declares the public interface of postprocessors.
-     * Postprocessors must implement a function that can be called at the end
-     * of each time step to evaluate the current solution, as well as
-     * functions that save the state of the object and restore it (for
-     * checkpoint/restart capabilities).
-     *
-     * Access to the data of the simulator is granted by the @p protected
-     * member functions of the SimulatorAccess class, i.e., classes
-     * implementing this interface will in general want to derive from both
-     * this Interface class as well as from the SimulatorAccess class.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Execute this postprocessor. Derived classes will implement this
-         * function to do whatever they want to do to evaluate the solution at
-         * the current time step.
-         *
-         * @param[in,out] statistics An object that contains statistics that
-         * are collected throughout the simulation and that will be written to
-         * an output file at the end of each time step. Postprocessors may
-         * deposit data in these tables for later visualization or further
-         * processing.
-         *
-         * @return A pair of strings that will be printed to the screen after
-         * running the postprocessor in two columns; typically the first
-         * column contains a description of what the data is and the second
-         * contains a numerical value of this data. If there is nothing to
-         * print, simply return two empty strings.
-         */
-        virtual
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) = 0;
-
-        /**
-         * A function that is used to indicate to the postprocessor manager which
-         * other postprocessor(s) the current one depends upon. The returned
-         * list contains the names (as strings, as you would write them in
-         * the input file) of the postprocessors it requires. The manager
-         * will ensure that these postprocessors are indeed used, even if
-         * they were not explicitly listed in the input file, and are indeed
-         * run <i>before</i> this postprocessor every time they are executed.
-         *
-         * The default implementation of this function returns an empty list.
-         *
-         * @note This mechanism is intended to support postprocessors that
-         * do not want to recompute information that other postprocessors
-         * already compute (or could compute, if they were run -- which
-         * we can ensure using the current function). To do so, a postprocessor
-         * of course needs to be able to access these other postprocessors.
-         * This can be done by deriving your postprocessor from
-         * SimulatorAccess, and then using the
-         * SimulatorAccess::get_postprocess_manager::get_matching_postprocessor
-         * function.
-         */
-        virtual
-        std::list<std::string>
-        required_other_postprocessors () const;
-
-        /**
-         * Save the state of this object to the argument given to this
-         * function. This function is in support of checkpoint/restart
-         * functionality.
-         *
-         * Derived classes can implement this function and should store their
-         * state in a string that is deposited under a key in the map through
-         * which the respective class can later find the status again when the
-         * program is restarted. A legitimate key to store data under is
-         * <code>typeid(*this).name()</code>. It is up to derived classes to
-         * decide how they want to encode their state.
-         *
-         * The default implementation of this function does nothing, i.e., it
-         * represents a stateless object for which nothing needs to be stored
-         * at checkpoint time and nothing needs to be restored at restart
-         * time.
-         *
-         * @param[in,out] status_strings The object into which implementations
-         * in derived classes can place their status under a key that they can
-         * use to retrieve the data.
-         */
-        virtual
-        void save (std::map<std::string, std::string> &status_strings) const;
-
-        /**
-         * Restore the state of the object by looking up a description of the
-         * state in the passed argument under the same key under which it was
-         * previously stored.
-         *
-         * The default implementation does nothing.
-         *
-         * @param[in] status_strings The object from which the status will be
-         * restored by looking up the value for a key specific to this derived
-         * class.
-         */
-        virtual
-        void load (const std::map<std::string, std::string> &status_strings);
-    };
-
-
-
-
-
-
-    /**
-     * A class that manages all objects that provide functionality to
-     * postprocess solutions. It declares run time parameters for input files,
-     * reads their values from such an input file, manages a list of all
-     * postprocessors selected in the input file, and upon request through the
-     * execute() function calls them in turn.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute all of the postprocessor objects that have been requested
-         * in the input file. These objects also fill the contents of the
-         * statistics object.
-         *
-         * The function returns a concatenation of the text returned by the
-         * individual postprocessors.
-         */
-        std::list<std::pair<std::string,std::string>>
-        execute (TableHandler &statistics);
-
-        /**
-         * Go through the list of all postprocessors that have been selected
-         * in the input file (and are consequently currently active) and return
-         * true if one of them has the desired type specified by the template
-         * argument.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename PostprocessorType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,PostprocessorType>::value>>
-        bool
-        has_matching_postprocessor () const;
-
-        /**
-         * Go through the list of all postprocessors that have been selected
-         * in the input file (and are consequently currently active) and see
-         * if one of them has the type specified by the template
-         * argument or can be cast to that type. If so, return a reference
-         * to it. If no postprocessor is active that matches the given type,
-         * throw an exception.
-         *
-         * This function can only be called if the given template type (the first template
-         * argument) is a class derived from the Interface class in this namespace.
-         */
-        template <typename PostprocessorType,
-                  typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,PostprocessorType>::value>>
-        const PostprocessorType &
-        get_matching_postprocessor () const;
-
-        /**
-         * Declare the parameters of all known postprocessors, as well as of
-         * ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which postprocessor objects will be created; then
-         * let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Write the data of this object to a stream for the purpose of
-         * serialization.
-         */
-        template <class Archive>
-        void save (Archive &ar,
-                   const unsigned int version) const;
-
-        /**
-         * Read the data of this object from a stream for the purpose of
-         * serialization.
-         */
-        template <class Archive>
-        void load (Archive &ar,
-                   const unsigned int version);
-
-        BOOST_SERIALIZATION_SPLIT_MEMBER()
-
-
-        /**
-         * A function that is used to register postprocessor objects in such a
-         * way that the Manager can deal with all of them without having to
-         * know them by name. This allows the files in which individual
-         * postprocessors are implement to register these postprocessors,
-         * rather than also having to modify the Manager class by adding the
-         * new postprocessor class.
-         *
-         * @param name The name under which this postprocessor is to be called
-         * in parameter files.
-         * @param description A text description of what this model does and
-         * that will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that
-         * declares the parameters for this postprocessor.
-         * @param factory_function A pointer to a function that creates such a
-         * postprocessor object and returns a pointer to it.
-         */
-        static
-        void
-        register_postprocessor (const std::string &name,
-                                const std::string &description,
-                                void (*declare_parameters_function) (ParameterHandler &),
-                                std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcPostprocessorNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered postprocessors.");
-    };
-
-
-    /* -------------------------- inline and template functions ---------------------- */
-
-    template <int dim>
-    template <class Archive>
-    void Manager<dim>::save (Archive &ar,
-                             const unsigned int) const
-    {
-      // let all the postprocessors save their data in a map and then
-      // serialize that
-      std::map<std::string,std::string> saved_text;
-      for (const auto &p : this->plugin_objects)
-        p->save (saved_text);
-
-      ar &saved_text;
-    }
-
-
-    template <int dim>
-    template <class Archive>
-    void Manager<dim>::load (Archive &ar,
-                             const unsigned int)
-    {
-      // get the map back out of the stream; then let the postprocessors
-      // that we currently have get their data from there. note that this
-      // may not be the same set of postprocessors we had when we saved
-      // their data
-      std::map<std::string,std::string> saved_text;
-      ar &saved_text;
-
-      for (auto &p : this->plugin_objects)
-        p->load (saved_text);
-    }
-
-
-
-    template <int dim>
-    template <typename PostprocessorType, typename>
-    inline
-    bool
-    Manager<dim>::has_matching_postprocessor () const
-    {
-      return this->template has_matching_plugin_object<PostprocessorType>();
-    }
-
-
-
-    template <int dim>
-    template <typename PostprocessorType, typename>
-    inline
-    const PostprocessorType &
-    Manager<dim>::get_matching_postprocessor () const
-    {
-      return this->template get_matching_plugin_object<PostprocessorType>();
-    }
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a postprocessor, register it with the aspect::Postprocess::Manager
-     * class.
-     *
-     * @ingroup Postprocessing
-     */
-#define ASPECT_REGISTER_POSTPROCESSOR(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_POSTPROCESSOR_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::Postprocess::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::Postprocess::Manager<2>::register_postprocessor, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::Postprocess::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::Postprocess::Manager<3>::register_postprocessor, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/load_balance_statistics.h.bak b/include/aspect/postprocess/load_balance_statistics.h.bak
deleted file mode 100644
index 43ff120abd5..00000000000
--- a/include/aspect/postprocess/load_balance_statistics.h.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-  Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_load_balance_statistics_h
-#define _aspect_postprocess_load_balance_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes statistics about
-     * the distribution of cells, and if present particles
-     * across subdomains.
-     *
-     * In particular, it computes maximal, average and
-     * minimal number of cells across all ranks.
-     * If there are particles it also computes the
-     * maximal, average, and minimum number of particles across
-     * all ranks, and maximal, average, and minimal ratio
-     * between local number of particles and local number
-     * of cells across all processes. All of these numbers
-     * can be useful to assess the load balance between
-     * different MPI ranks, as the difference between the
-     * minimal and maximal load should be as small as
-     * possible.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class LoadBalanceStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Compute load balance statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/mass_flux_statistics.h.bak b/include/aspect/postprocess/mass_flux_statistics.h.bak
deleted file mode 100644
index a0c7a1cb18f..00000000000
--- a/include/aspect/postprocess/mass_flux_statistics.h.bak
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_mass_flux_statistics_h
-#define _aspect_postprocess_mass_flux_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the material_flux
-     * in and out of boundaries.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class MassFluxStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some mass_flux statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/material_statistics.h.bak b/include/aspect/postprocess/material_statistics.h.bak
deleted file mode 100644
index b63d214d5a5..00000000000
--- a/include/aspect/postprocess/material_statistics.h.bak
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-  Copyright (C) 2018 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_material_statistics_h
-#define _aspect_postprocess_material_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the
-     * material properties, in particular average density,
-     * average viscosity and total mass.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class MaterialStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some material property statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/matrix_statistics.h.bak b/include/aspect/postprocess/matrix_statistics.h.bak
deleted file mode 100644
index d317c00f87f..00000000000
--- a/include/aspect/postprocess/matrix_statistics.h.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_matrix_statistics_h
-#define _aspect_postprocess_matrix_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the matrices
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class MatrixStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Compute matrix statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/max_depth_field.h.bak b/include/aspect/postprocess/max_depth_field.h.bak
deleted file mode 100644
index 07b6808a879..00000000000
--- a/include/aspect/postprocess/max_depth_field.h.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-  Copyright (C) 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_max_depth_field_h
-#define _aspect_postprocess_max_depth_field_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    /**
-     * A postprocessor that computes the deepest point of the given composition.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class MaxDepthField : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for the biggest depth of the
-         * compositional field indicated by the user.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/melt_statistics.h.bak b/include/aspect/postprocess/melt_statistics.h.bak
deleted file mode 100644
index dd1daf88da4..00000000000
--- a/include/aspect/postprocess/melt_statistics.h.bak
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_postprocess_melt_statistics_h
-#define _aspect_postprocess_melt_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the
-     * melt fraction. This only works for material models that
-     * are derived from MaterialModel::MeltFractionModel and
-     * implement their own
-     * MaterialModel::MeltFractionModel::melt_fraction function.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class MeltStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the melt fraction in the material model.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/memory_statistics.h.bak b/include/aspect/postprocess/memory_statistics.h.bak
deleted file mode 100644
index f3f62f48dea..00000000000
--- a/include/aspect/postprocess/memory_statistics.h.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _aspect_postprocess_memory_statistics_h
-#define _aspect_postprocess_memory_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the memory consumption.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class MemoryStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Calculate some statistics about the memory.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        bool output_vmpeak;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/mobility_statistics.h.bak b/include/aspect/postprocess/mobility_statistics.h.bak
deleted file mode 100644
index d6ff4e11598..00000000000
--- a/include/aspect/postprocess/mobility_statistics.h.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_mobility_statistics_h
-#define _aspect_postprocess_mobility_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about mobility following Tackley (2000) and Lourenco et al. (2020)
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class MobilityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some mobility statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/particle_count_statistics.h.bak b/include/aspect/postprocess/particle_count_statistics.h.bak
deleted file mode 100644
index 7b5dd94c9d5..00000000000
--- a/include/aspect/postprocess/particle_count_statistics.h.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_particle_count_statistics_h
-#define _aspect_postprocess_particle_count_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the distribution
-     * of particles, if possible.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class ParticleCountStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some particle statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Let the postprocessor manager know about the other postprocessors
-         * this one depends on. Specifically, the particles postprocessor.
-         */
-        std::list<std::string>
-        required_other_postprocessors() const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/particles.h.bak b/include/aspect/postprocess/particles.h.bak
deleted file mode 100644
index 3a05da0d581..00000000000
--- a/include/aspect/postprocess/particles.h.bak
+++ /dev/null
@@ -1,319 +0,0 @@
-/*
- Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_postprocess_particle_h
-#define _aspect_postprocess_particle_h
-
-#include <aspect/postprocess/interface.h>
-
-#include <aspect/simulator_access.h>
-#include <aspect/particle/property/interface.h>
-
-#include <deal.II/particles/particle_handler.h>
-#include <deal.II/base/data_out_base.h>
-
-#include <thread>
-#include <tuple>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace internal
-    {
-      /**
-       * This class is responsible for writing the particle data into a format that can
-       * be written by deal.II, in particular a list of 'patches' that contain one
-       * particle per patch. The base class DataOutInterface is templated with a
-       * dimension of zero (the dimension of the particle / point), and a space dimension
-       * of dim (the dimension in which this zero-dimensional particle lives).
-       */
-      template <int dim>
-      class ParticleOutput : public dealii::DataOutInterface<0,dim>
-      {
-        public:
-          /**
-           * This function prepares the data for writing. It reads the data from @p particle_handler and their
-           * property information from @p property_information, and builds a list of patches that is stored
-           * internally until the destructor is called. This function needs to be called before one of the
-           * write function of the base class can be called to write the output data.
-           */
-          void build_patches(const Particles::ParticleHandler<dim> &particle_handler,
-                             const aspect::Particle::Property::ParticlePropertyInformation &property_information,
-                             const std::vector<std::string> &exclude_output_properties,
-                             const bool only_group_3d_vectors);
-
-        private:
-          /**
-           * Implementation of the corresponding function of the base class.
-           */
-          const std::vector<DataOutBase::Patch<0,dim>> &
-          get_patches () const override;
-
-          /**
-           * Implementation of the corresponding function of the base class.
-           */
-          std::vector<std::string>
-          get_dataset_names () const override;
-
-          /**
-           * Implementation of the corresponding function of the base class.
-           */
-          std::vector<
-          std::tuple<unsigned int,
-              unsigned int,
-              std::string,
-              DataComponentInterpretation::DataComponentInterpretation>>
-              get_nonscalar_data_ranges () const override;
-
-          /**
-           * Output information that is filled by build_patches() and
-           * written by the write function of the base class.
-           */
-          std::vector<DataOutBase::Patch<0,dim>> patches;
-
-          /**
-           * A list of field names for all data components stored in patches.
-           */
-          std::vector<std::string> dataset_names;
-
-          /**
-           * Store which of the data fields are vectors.
-           */
-          std::vector<
-          std::tuple<unsigned int,
-              unsigned int,
-              std::string,
-              DataComponentInterpretation::DataComponentInterpretation>>
-              vector_datasets;
-      };
-    }
-
-    /**
-     * A Postprocessor that creates particles, which follow the
-     * velocity field of the simulation. The particles can be generated
-     * and propagated in various ways and they can carry a number of
-     * constant or time-varying properties. The postprocessor can write
-     * output positions and properties of all particles at chosen intervals,
-     * although this is not mandatory. It also allows other parts of the
-     * code to query the particles for information.
-     */
-    template <int dim>
-    class Particles : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Particles();
-
-        /**
-         * Destructor.
-         */
-        ~Particles() override;
-
-        /**
-         * Execute this postprocessor. Derived classes will implement this
-         * function to do whatever they want to do to evaluate the solution at
-         * the current time step.
-         *
-         * @param[in,out] statistics An object that contains statistics that
-         * are collected throughout the simulation and that will be written to
-         * an output file at the end of each time step. Postprocessors may
-         * deposit data in these tables for later visualization or further
-         * processing.
-         *
-         * @return A pair of strings that will be printed to the screen after
-         * running the postprocessor in two columns; typically the first
-         * column contains a description of what the data is and the second
-         * contains a numerical value of this data. If there is nothing to
-         * print, simply return two empty strings.
-         */
-        std::pair<std::string,std::string> execute (TableHandler &statistics) override;
-
-        /**
-         * Save the state of this object.
-         */
-        void save (std::map<std::string, std::string> &status_strings) const override;
-
-        /**
-         * Restore the state of the object.
-         */
-        void load (const std::map<std::string, std::string> &status_strings) override;
-
-        /**
-         * Serialize the contents of this class as far as they are not read
-         * from input parameter files.
-         */
-        template <class Archive>
-        void serialize (Archive &ar, const unsigned int version);
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Interval between output (in years if appropriate simulation
-         * parameter is set, otherwise seconds)
-         */
-        double output_interval;
-
-        /**
-         * Records time for next output to occur
-         */
-        double last_output_time;
-
-        /**
-         * Set the time output was supposed to be written. In the simplest
-         * case, this is the previous last output time plus the interval, but
-         * in general we'd like to ensure that it is the largest supposed
-         * output time, which is smaller than the current time, to avoid
-         * falling behind with last_output_time and having to catch up once
-         * the time step becomes larger. This is done after every output.
-         */
-        void set_last_output_time (const double current_time);
-
-        /**
-         * Consecutively counted number indicating the how-manyth time we will
-         * create output the next time we get to it.
-         */
-        unsigned int output_file_number;
-
-        /**
-         * Graphical output format.
-         */
-        std::vector<std::string> output_formats;
-
-        /**
-         * A list of pairs (time, pvtu_filename) that have so far been written
-         * and that we will pass to DataOutInterface::write_pvd_record
-         * to create a description file that can make the association
-         * between simulation time and corresponding file name (this
-         * is done because there is no way to store the simulation
-         * time inside the .pvtu or .vtu files).
-         */
-        std::vector<std::pair<double,std::string>> times_and_pvtu_file_names;
-
-        /**
-         * A corresponding variable that we use for the .visit files created
-         * by DataOutInterface::write_visit_record. The second part of a
-         * pair contains all files that together form a time step.
-         */
-        std::vector<std::pair<double,std::vector<std::string>>> times_and_vtu_file_names;
-
-        /**
-         * A list of list of filenames, sorted by timestep, that correspond to
-         * what has been created as output. This is used to create a descriptive
-         * .visit file for the entire simulation.
-         */
-        std::vector<std::vector<std::string>> output_file_names_by_timestep;
-
-        /**
-         * A set of data related to XDMF file sections describing the HDF5
-         * heavy data files created. These contain things such as the
-         * dimensions and names of data written at all steps during the
-         * simulation.
-         */
-        std::vector<XDMFEntry>  xdmf_entries;
-
-        /**
-         * VTU file output supports grouping files from several CPUs into one
-         * file using MPI I/O when writing on a parallel filesystem. 0 means
-         * no grouping (and no parallel I/O). 1 will generate one big file
-         * containing the whole solution.
-         */
-        unsigned int group_files;
-
-        /**
-         * On large clusters it can be advantageous to first write the
-         * output to a temporary file on a local file system and later
-         * move this file to a network file system. If this variable is
-         * set to a non-empty string it will be interpreted as a temporary
-         * storage location.
-         */
-        std::string temporary_output_location;
-
-        /**
-         * File operations can potentially take a long time, blocking the
-         * progress of the rest of the model run. Setting this variable to
-         * 'true' moves this process into a background thread, while the
-         * rest of the model continues.
-         */
-        bool write_in_background_thread;
-
-        /**
-         * Handle to a thread that is used to write data in the background.
-         * The writer() function runs on this background thread.
-         */
-        std::thread background_thread;
-
-        /**
-         * Stores the particle property fields which are excluded from output
-         * to the visualization file.
-         */
-        std::vector<std::string> exclude_output_properties;
-
-        /**
-         * A function that writes the text in the second argument to a file
-         * with the name given in the first argument. The function is run on a
-         * separate thread to allow computations to continue even though
-         * writing data is still continuing. The function takes over ownership
-         * of these arguments and deletes them at the end of its work.
-         */
-        static
-        void writer (const std::string &filename,
-                     const std::string &temporary_filename,
-                     const std::string &file_contents);
-
-        /**
-         * Write the various descriptive record files. These files are used by
-         * visualization programs to identify which of the output files in a
-         * directory, possibly one file written by each processor, belong to a
-         * single time step and/or form the different time steps of a
-         * simulation. For Paraview, this is a <code>.pvtu</code> file per
-         * time step and a <code>.pvd</code> for all time steps. For VisIt it
-         * is a <code>.visit</code> file per time step and one for all time
-         * steps.
-         *
-         * @param data_out The DataOut object that was used to write the
-         * solutions.
-         * @param solution_file_prefix The stem of the filename to be written.
-         * @param filenames List of filenames for the current output from all
-         * processors.
-         */
-        void write_description_files (const internal::ParticleOutput<dim> &data_out,
-                                      const std::string &solution_file_prefix,
-                                      const std::vector<std::string> &filenames);
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/point_values.h.bak b/include/aspect/postprocess/point_values.h.bak
deleted file mode 100644
index 61b61fc887a..00000000000
--- a/include/aspect/postprocess/point_values.h.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_point_values_h
-#define _aspect_postprocess_point_values_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/data_out_base.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that evaluates the solution vector at individual
-     * points.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class PointValues : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor
-         */
-        PointValues ();
-
-        /**
-         * Evaluate the solution and determine the values at the
-         * selected points.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Save the state of this object.
-         */
-        void save (std::map<std::string, std::string> &status_strings) const override;
-
-        /**
-         * Restore the state of the object.
-         */
-        void load (const std::map<std::string, std::string> &status_strings) override;
-
-        /**
-         * Serialize the contents of this class as far as they are not read
-         * from input parameter files.
-         */
-        template <class Archive>
-        void serialize (Archive &ar, const unsigned int version);
-
-      private:
-        /**
-         * Set the time output was supposed to be written. In the simplest
-         * case, this is the previous last output time plus the interval, but
-         * in general we'd like to ensure that it is the largest supposed
-         * output time, which is smaller than the current time, to avoid
-         * falling behind with last_output_time and having to catch up once
-         * the time step becomes larger. This is done after every output.
-         */
-        void set_last_output_time (const double current_time);
-
-        /**
-         * Interval between the generation of output in seconds.
-         */
-        double output_interval;
-
-        /**
-         * A time (in seconds) the last output has been produced.
-         */
-        double last_output_time;
-
-        /**
-         * Vector of Points representing the points where the solution is to be evaluated
-         * that can be used by VectorTools.
-         */
-        std::vector<Point<dim>> evaluation_points_cartesian;
-        /**
-         * The values of the solution at the evaluation points.
-         */
-        std::vector<std::pair<double, std::vector<Vector<double>>>> point_values;
-        /**
-         * Whether or not to interpret the evaluation points in the input file
-         * as natural coordinates or not.
-         */
-        bool use_natural_coordinates;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/pressure_statistics.h.bak b/include/aspect/postprocess/pressure_statistics.h.bak
deleted file mode 100644
index b05c892ffc3..00000000000
--- a/include/aspect/postprocess/pressure_statistics.h.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_pressure_statistics_h
-#define _aspect_postprocess_pressure_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the pressure.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class PressureStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some pressure statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/rotation_statistics.h.bak b/include/aspect/postprocess/rotation_statistics.h.bak
deleted file mode 100644
index 031fc0e30ea..00000000000
--- a/include/aspect/postprocess/rotation_statistics.h.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_rotation_statistics_h
-#define _aspect_postprocess_rotation_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the rotational
-     * velocity of the model (i.e. integrated net rotation and angular momentum).
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class RotationStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some velocity statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Whether to use a constant density of one for the computation of the
-         * angular momentum and moment of inertia. This is an approximation
-         * that assumes that the 'volumetric' rotation is equal to the 'mass'
-         * rotation. If this parameter is true this postprocessor computes
-         * 'net rotation' instead of 'angular momentum'.
-         */
-        bool use_constant_density;
-
-        /**
-         * Whether to write the full moment of inertia tensor into the
-         * statistics output instead of its norm for the current rotation
-         * axis. This is a second-order symmetric tensor with
-         * 6 components in 3D. In 2D this option has no effect, because
-         * the rotation axis is fixed and thus it is always a scalar.
-         */
-        bool output_full_tensor;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/sea_level.h.bak b/include/aspect/postprocess/sea_level.h.bak
deleted file mode 100644
index 4efe24fbc48..00000000000
--- a/include/aspect/postprocess/sea_level.h.bak
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_sea_level_h
-#define _aspect_postprocess_sea_level_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that outputs the sea level to file. The sea level is based
-     * on the ice heights input data, the solid Earth topography input data for
-     * defining the ocean basin, the geoid displacement from the geoid postprocessor,
-     * and the free surface topography from the geometry model. The sea level
-     * postprocessor requires a 3D spherical shell geometry with a free surface.
-     * The sea level computation is based on \\cite{Martinec2018}.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class SeaLevel : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Sets up structured data lookup for topography and ice height input data.
-         */
-        void initialize() override;
-
-        /**
-         * Output non-uniform sea level change [m] to file.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Evaluate the total surface pressure from ice and water loading at
-         * a point at the top surface of the domain. While the function will
-         * return pressure values for any location, it will always assume the
-         * volume between the point and the sea level is filled with water or ice,
-         * therefore calling this function for positions inside the domain will result
-         * in unrealistic pressure values.
-         */
-        double
-        compute_total_surface_pressure(const Point<dim> &position) const;
-
-        /**
-         * Register with the simulator the other postprocessors that we need
-         * (namely: geoid).
-         */
-        std::list<std::string>
-        required_other_postprocessors() const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Save the state of this object.
-         */
-        void save (std::map<std::string, std::string> &status_strings) const override;
-
-        /**
-         * Restore the state of the object.
-         */
-        void load (const std::map<std::string, std::string> &status_strings) override;
-
-        /**
-         * Serialize the contents of this class as far as they are not read
-         * from input parameter files.
-         */
-        template <class Archive>
-        void serialize (Archive &ar, const unsigned int version);
-
-      private:
-        /**
-         * Function to determine non-uniform sea level change for any given location.
-         * This is a local computation that makes use of the computed sea level offset,
-         * so make sure to call compute_sea_level_offset() before calling this function.
-         */
-        double
-        compute_nonuniform_sea_level_change(const Point<dim> &position) const;
-
-        /**
-         * Function to determine the global sea level offset.
-         */
-        double
-        compute_sea_level_offset();
-
-        /**
-         * Information about the location of topography data files.
-         */
-        std::string data_directory_topography;
-        std::string data_file_name_topography;
-
-        /**
-         * Information about the location of ice height data files.
-         */
-        std::string data_directory_ice_height;
-        std::string data_file_name_ice_height;
-
-        /**
-         * Pointer to the StructuredDataLookup object that holds the topography and ice height data.
-         */
-        std::unique_ptr<Utilities::StructuredDataLookup<2>> topography_lookup;
-        std::unique_ptr<Utilities::StructuredDataLookup<2>> ice_height_lookup;
-
-        /**
-         * The density of water.
-         */
-        double density_water;
-
-        /**
-         * The density of ice.
-         */
-        double density_ice;
-
-        /**
-         * The global sea level offset.
-         */
-        double sea_level_offset;
-
-        /**
-         * Whether or not to produce text files with sea level values.
-         */
-        bool write_to_file;
-
-        /**
-         * Interval between the generation of text output. This parameter
-         * is read from the input file and consequently is not part of the
-         * state that needs to be saved and restored.
-         */
-        double output_interval;
-
-        /**
-         * A time (in seconds) at which the last text output was supposed
-         * to be produced. Used to check for the next necessary output time.
-         */
-        double last_output_time;
-
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/spherical_velocity_statistics.h.bak b/include/aspect/postprocess/spherical_velocity_statistics.h.bak
deleted file mode 100644
index 16fa2efb7ac..00000000000
--- a/include/aspect/postprocess/spherical_velocity_statistics.h.bak
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_postprocess_spherical_velocity_statistics_h
-#define _aspect_postprocess_spherical_velocity_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the radial and
-     * tangential components of the velocity in spherical/cylindrical models.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class SphericalVelocityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some velocity statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/stokes_residual.h.bak b/include/aspect/postprocess/stokes_residual.h.bak
deleted file mode 100644
index 3890824e104..00000000000
--- a/include/aspect/postprocess/stokes_residual.h.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_stokes_residual_h
-#define _aspect_postprocess_stokes_residual_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/data_out_base.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that outputs Stokes residuals to a file stokes_residuals.txt.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class StokesResidual : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        StokesResidual ();
-
-        /**
-         * This attaches to the Stokes solver signal.
-         */
-        void initialize() override;
-
-        /**
-         * Generate the output file.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Save the state of this object.
-         */
-        void save (std::map<std::string, std::string> &status_strings) const override;
-
-        /**
-         * Restore the state of the object.
-         */
-        void load (const std::map<std::string, std::string> &status_strings) override;
-
-        /**
-         * Serialize the contents of this class as far as they are not read
-         * from input parameter files.
-         */
-        template <class Archive>
-        void serialize (Archive &ar, const unsigned int version);
-
-      private:
-        /**
-         * A structure for a single time step record.
-         */
-        struct DataPoint
-        {
-          double time;
-          unsigned int solve_index;
-          std::vector<double> values;
-
-          template <class Archive>
-          void serialize (Archive &ar, const unsigned int version);
-        };
-
-        /**
-         * Callback function to collect the data.
-         */
-        void stokes_solver_callback (const SolverControl &solver_control_cheap,
-                                     const SolverControl &solver_control_expensive);
-
-        /**
-         * An array of all the past values
-         */
-        std::vector<DataPoint> entries;
-
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/temperature_statistics.h.bak b/include/aspect/postprocess/temperature_statistics.h.bak
deleted file mode 100644
index b059802482a..00000000000
--- a/include/aspect/postprocess/temperature_statistics.h.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_temperature_statistics_h
-#define _aspect_postprocess_temperature_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the temperature.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class TemperatureStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some temperature statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/topography.h.bak b/include/aspect/postprocess/topography.h.bak
deleted file mode 100644
index 46f29389c9a..00000000000
--- a/include/aspect/postprocess/topography.h.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_topography_h
-#define _aspect_postprocess_topography_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that outputs the surface topography to file.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class Topography : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Output topography [m] to file
-         */
-        std::pair<std::string,std::string> execute (TableHandler &statistics) override;
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-        /**
-         * @}
-         */
-
-      private:
-        /**
-         * Whether or not to produce text files with topography values
-         */
-        bool write_to_file;
-
-        /**
-         * Interval between the generation of text output. This parameter
-         * is read from the input file and consequently is not part of the
-         * state that needs to be saved and restored.
-         */
-        double output_interval;
-
-        /**
-         * A time (in seconds) at which the last text output was supposed
-         * to be produced. Used to check for the next necessary output time.
-         */
-        double last_output_time;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/velocity_boundary_statistics.h.bak b/include/aspect/postprocess/velocity_boundary_statistics.h.bak
deleted file mode 100644
index 3c6ec0496ba..00000000000
--- a/include/aspect/postprocess/velocity_boundary_statistics.h.bak
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-  Copyright (C) 2014 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_postprocess_velocity_boundary_statistics_h
-#define _aspect_postprocess_velocity_boundary_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the velocity at
-     * different parts of the boundary.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class VelocityBoundaryStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some velocity boundary statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/velocity_statistics.h.bak b/include/aspect/postprocess/velocity_statistics.h.bak
deleted file mode 100644
index 0fff1d21e95..00000000000
--- a/include/aspect/postprocess/velocity_statistics.h.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_velocity_statistics_h
-#define _aspect_postprocess_velocity_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the velocity.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class VelocityStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some velocity statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/viscous_dissipation_statistics.h.bak b/include/aspect/postprocess/viscous_dissipation_statistics.h.bak
deleted file mode 100644
index 575b3d58070..00000000000
--- a/include/aspect/postprocess/viscous_dissipation_statistics.h.bak
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021-2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_viscous_dissipation_statistics_h
-#define _aspect_postprocess_viscous_dissipation_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes the viscous dissipation over the area
-     * spanned by each compositional field and over the whole domain.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class ViscousDissipationStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution to compute the viscous dissipation
-         * per compositional field and over the whole domain.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/visualization.h.bak b/include/aspect/postprocess/visualization.h.bak
deleted file mode 100644
index f483e78ae99..00000000000
--- a/include/aspect/postprocess/visualization.h.bak
+++ /dev/null
@@ -1,747 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_h
-#define _aspect_postprocess_visualization_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/plugins.h>
-
-#include <deal.II/base/thread_management.h>
-#include <deal.II/numerics/data_postprocessor.h>
-#include <deal.II/base/data_out_base.h>
-#include <deal.II/numerics/data_out.h>
-
-#include <thread>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * Compute the arithmetic average over q for each m of the variable quantities[q](m).
-       */
-      inline void average_quantities(std::vector<Vector<double>> &quantities)
-      {
-        const unsigned int N = quantities.size();
-        const unsigned int M = quantities[0].size();
-        for (unsigned int m=0; m<M; ++m)
-          {
-            double sum = 0;
-            for (unsigned int q=0; q<N; ++q)
-              sum += quantities[q](m);
-
-            const double average = sum/N;
-            for (unsigned int q=0; q<N; ++q)
-              quantities[q](m) = average;
-          }
-      }
-
-      /**
-       * This class declares the public interface of visualization
-       * postprocessors. Visualization postprocessors are used to compute
-       * derived data, e.g. wave speeds, friction heating terms, etc, to be
-       * put into graphical output files. They are plugins for the
-       * aspect::Postprocess::Visualization class.
-       *
-       * Classes derived from this type must implement the functions that save
-       * the state of the object and restore it (for checkpoint/restart
-       * capabilities) as well as functions that declare and read parameters.
-       * However, this class also already provides default implementations of
-       * these functions that simply do nothing. This is appropriate for
-       * objects that are stateless, as is commonly the case for visualization
-       * postprocessors.
-       *
-       * Access to the data of the simulator is granted by the @p protected
-       * member functions of the SimulatorAccess class, i.e., classes
-       * implementing this interface will in general want to derive from both
-       * this Interface class as well as from the SimulatorAccess class.
-       *
-       * <h3> How visualization plugins work </h3>
-       *
-       * There are two ways in which visualization plugins can work to get
-       * data from a simulation into an output file:
-       * <ul>
-       * <li> Classes derived from this class can also derive from the deal.II
-       * class DataPostprocessor or any of the classes like
-       * DataPostprocessorScalar or DataPostprocessorVector. These classes can
-       * be thought of as filters: DataOut will call a function in them for
-       * every cell and this function will transform the values or gradients
-       * of the solution and other information such as the location of
-       * quadrature points into the desired quantity to output. A typical case
-       * would be if the quantity $g(x)$ you want to output can be written as
-       * a function $g(x) = G(u(x),\nabla u(x), x, ...)$ in a point-wise sense
-       * where $u(x)$ is the value of the solution vector (i.e., the
-       * velocities, pressure, temperature, etc) at an evaluation point. In
-       * the context of this program an example would be to output the density
-       * of the medium as a spatially variable function since this is a
-       * quantity that for realistic media depends point-wise on the values of
-       * the solution.
-       *
-       * Using this way of describing a visualization postprocessor will yield
-       * a class  that would then have the following base classes:
-       * - aspect::Postprocess::VisualizationPostprocessors::Interface
-       * - aspect::SimulatorAccess
-       * - dealii::DataPostprocessor or any of the other ones listed above
-       *
-       * <li> The second possibility is for a class to not derive from
-       * dealii::DataPostprocessor but instead from the CellDataVectorCreator
-       * class. In this case, a visualization postprocessor would generate and
-       * return a vector that consists of one element per cell. The intent of
-       * this option is to output quantities that are not point-wise functions
-       * of the solution but instead can only be computed as integrals or
-       * other functionals on a per-cell basis. A typical case would be error
-       * estimators that do depend on the solution but not in a point-wise
-       * sense; rather, they yield one value per cell of the mesh. See the
-       * documentation of the CellDataVectorCreator class for more
-       * information.
-       * </ul>
-       * @ingroup Postprocessing
-       * @ingroup Visualization
-       */
-      template <int dim>
-      class Interface : public Plugins::InterfaceBase
-      {
-        public:
-          /**
-           * Constructor. The constructor takes as argument the physical
-           * units of the quantity (scalar or vector-valued) computed by
-           * derived classes. The empty string, "", refers to an unknown
-           * or nonexistent unit.
-           *
-           * If a visualization postprocessor generates more than one
-           * output component, and if the different components have different
-           * physical units, then they should be separated by commas. If
-           * the different components have the same physical units, these units
-           * need to be specified only once and will apply to all components.
-           *
-           * There are cases where the physical units can only be determined
-           * at a time later than when this constructor is called. An example
-           * is when a velocity is output as either `m/s` or `m/year`,
-           * depending on some run-time parameter. In those cases, derived
-           * classes should simply pass in an empty string to this constructor
-           * and instead overload the get_physical_units() function.
-           */
-          explicit Interface (const std::string &physical_units = "");
-
-          /**
-           * Return the string representation of the physical units that a
-           * derived class has provided to the constructor of this class.
-           *
-           * As mentioned in the documentation of the constructor, there are
-           * cases where a derived class doesn't know the physical units yet
-           * that correspond to what is being output at the time the
-           * constructor is called. In that case, the derived class can
-           * overload this function and return the correct units when the
-           * visualization postprocessor is executed.
-           */
-          virtual
-          std::string
-          get_physical_units () const;
-
-          /**
-           * A function that is used to indicate to the postprocessor manager which
-           * other postprocessor(s) the current one depends upon. The returned
-           * list contains the names (as strings, as you would write them in
-           * the input file) of the postprocessors it requires. The manager
-           * will ensure that these postprocessors are indeed used, even if
-           * they were not explicitly listed in the input file, and are indeed
-           * run <i>before</i> this postprocessor every time they are executed.
-           *
-           * The postprocessors you can nominate here are of the general
-           * postprocessor class, not visualization postprocessors.
-           *
-           * The default implementation of this function returns an empty list.
-           */
-          virtual
-          std::list<std::string>
-          required_other_postprocessors () const;
-
-          /**
-           * Save the state of this object to the argument given to this
-           * function. This function is in support of checkpoint/restart
-           * functionality.
-           *
-           * Derived classes can implement this function and should store
-           * their state in a string that is deposited under a key in the map
-           * through which the respective class can later find the status
-           * again when the program is restarted. A legitimate key to store
-           * data under is <code>typeid(*this).name()</code>. It is up to
-           * derived classes to decide how they want to encode their state.
-           *
-           * The default implementation of this function does nothing, i.e.,
-           * it represents a stateless object for which nothing needs to be
-           * stored at checkpoint time and nothing needs to be restored at
-           * restart time.
-           *
-           * @param[in,out] status_strings The object into which
-           * implementations in derived classes can place their status under a
-           * key that they can use to retrieve the data.
-           */
-          virtual
-          void save (std::map<std::string, std::string> &status_strings) const;
-
-          /**
-           * Restore the state of the object by looking up a description of
-           * the state in the passed argument under the same key under which
-           * it was previously stored.
-           *
-           * The default implementation does nothing.
-           *
-           * @param[in] status_strings The object from which the status will
-           * be restored by looking up the value for a key specific to this
-           * derived class.
-           */
-          virtual
-          void load (const std::map<std::string, std::string> &status_strings);
-
-        private:
-          /**
-           * The physical units encoded by this visualization postprocessor.
-           */
-          const std::string physical_units;
-      };
-
-
-
-      /**
-       * As explained in the documentation of the Interface class, the second
-       * kind of visualization plugin is one that wants to generate cell-wise
-       * data. Classes derived from this class need to implement a function
-       * execute() that computes these cell-wise values and return a pair of
-       * values where the first one indicates the name of a variable and the
-       * second one is a vector with one entry per cell. This class is the
-       * interface that such plugins have to implement.
-       *
-       * @ingroup Postprocessing
-       * @ingroup Visualization
-       */
-      template <int dim>
-      class CellDataVectorCreator : public Interface<dim>
-      {
-        public:
-          /**
-           * Constructor. The constructor takes as argument the physical
-           * units of the quantity (scalar or vector-valued) computed by
-           * derived classes.
-           */
-          explicit CellDataVectorCreator (const std::string &physical_units = "");
-
-          /**
-           * Destructor.
-           */
-          ~CellDataVectorCreator ()  override = default;
-
-          /**
-           * The function classes have to implement that want to output
-           * cell-wise data.
-           *
-           * @return A pair of values with the following meaning:
-           * - The first element provides the name by which this data should
-           *   be written to the output file.
-           * - The second element is a pointer to a vector with one element
-           *   per active cell on the current processor. Elements corresponding
-           *   to active cells that are either artificial or ghost cells (in
-           *   deal.II language, see the deal.II glossary)
-           *   will be ignored but must nevertheless exist in the returned
-           *   vector.
-           * While implementations of this function must create this
-           * vector, ownership is taken over by the caller of this function
-           * and the caller will take care of destroying the vector pointed
-           * to.
-           */
-          virtual
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute () const = 0;
-      };
-
-
-      /**
-       * This class is a tag class: If a visualization postprocessor is derived
-       * from it, then this is interpreted as saying that the class will only
-       * be used to generate graphical output on the surface of the model,
-       * rather than for the entire domain.
-       */
-      template <int dim>
-      class SurfaceOnlyVisualization
-      {
-        public:
-          /**
-           * Destructor. Made `virtual` to ensure that it is possible to
-           * test whether a derived class is derived from this class via
-           * a `dynamic_cast`.
-           */
-          virtual
-          ~SurfaceOnlyVisualization () = default;
-      };
-    }
-
-
-    /**
-     * A postprocessor that generates graphical output in periodic intervals
-     * or every time step. The time interval between generating graphical
-     * output is obtained from the parameter file.
-     *
-     * While this class acts as a plugin, i.e. as a postprocessor that can be
-     * registered with the postprocessing manager class
-     * aspect::Postprocess::Manager, this class at the same time also acts as
-     * a manager for plugins itself, namely for classes derived from the
-     * VisualizationPostprocessors::Interface class that are used to output
-     * different aspects of the solution, such as for example a computed
-     * seismic wave speed from temperature, velocity and pressure.
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class Visualization : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Visualization ();
-
-        /**
-         * Generate graphical output from the current solution.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-
-        /**
-         * Update any temporary information needed by the visualization postprocessor.
-         */
-        void
-        update () override;
-
-        /**
-         * A function that is used to register visualization postprocessor
-         * objects in such a way that the Manager can deal with all of them
-         * without having to know them by name. This allows the files in which
-         * individual postprocessors are implement to register these
-         * postprocessors, rather than also having to modify the Manage class
-         * by adding the new postprocessor class.
-         *
-         * @param name The name under which this visualization postprocessor
-         * is to be called in parameter files.
-         * @param description A text description of what this visualization
-         * plugin does and that will be listed in the documentation of the
-         * parameter file.
-         * @param declare_parameters_function A pointer to a function that
-         * declares the parameters for this postprocessor.
-         * @param factory_function A pointer to a function that creates such a
-         * postprocessor object and returns a pointer to it.
-         */
-        static
-        void
-        register_visualization_postprocessor (const std::string &name,
-                                              const std::string &description,
-                                              void (*declare_parameters_function) (ParameterHandler &),
-                                              std::unique_ptr<VisualizationPostprocessors::Interface<dim>>(*factory_function) ());
-
-        /**
-         * A function that is used to indicate to the postprocessor manager which
-         * other postprocessor(s) the current one depends upon.
-         *
-         * For the current class, we simply loop over all of the visualization
-         * postprocessors and collect what they want.
-         */
-        std::list<std::string>
-        required_other_postprocessors () const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * Save the state of this object.
-         */
-        void save (std::map<std::string, std::string> &status_strings) const override;
-
-        /**
-         * Restore the state of the object.
-         */
-        void load (const std::map<std::string, std::string> &status_strings) override;
-
-        /**
-         * Serialize the contents of this class as far as they are not read
-         * from input parameter files.
-         */
-        template <class Archive>
-        void serialize (Archive &ar, const unsigned int version);
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-        /**
-         * Return the value of the parameter @p pointwise_stress_and_strain
-         * that is controlled by the parameter "Point-wise stress and strain".
-         */
-        bool output_pointwise_stress_and_strain() const;
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcPostprocessorNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered postprocessors.");
-
-      private:
-        /**
-         * Interval between the generation of graphical output. This parameter
-         * is read from the input file and consequently is not part of the
-         * state that needs to be saved and restored.
-         */
-        double output_interval;
-
-        /**
-         * A time (in seconds) at which the last graphical output was supposed
-         * to be produced. Used to check for the next necessary output time.
-         */
-        double last_output_time;
-
-        /**
-         * Maximum number of steps between the generation of graphical output.
-         * This parameter
-         * is read from the input file and consequently is not part of the
-         * state that needs to be saved and restored.
-         */
-        unsigned int maximum_timesteps_between_outputs;
-
-        /**
-         * Timestep at which the last graphical output was produced
-         * Used to check for the next necessary output time.
-         */
-        unsigned int last_output_timestep;
-
-        /**
-         * Consecutively counted number indicating the how-manyth time we will
-         * create output the next time we get to it.
-         */
-        unsigned int output_file_number;
-
-        /**
-         * Graphical output format.
-         */
-        std::string output_format;
-
-        /**
-         * VTU file output supports grouping files from several CPUs into one
-         * file using MPI I/O when writing on a parallel filesystem. 0 means
-         * no grouping (and no parallel I/O). 1 will generate one big file
-         * containing the whole solution.
-         */
-        unsigned int group_files;
-
-        /**
-         * On large clusters it can be advantageous to first write the
-         * output to a temporary file on a local file system and later
-         * move this file to a network file system. If this variable is
-         * set to a non-empty string it will be interpreted as a temporary
-         * storage location.
-         */
-        std::string temporary_output_location;
-
-        /**
-         * deal.II offers the possibility to linearly interpolate output
-         * fields of higher order elements to a finer resolution. This
-         * somewhat compensates the fact that most visualization software only
-         * offers linear interpolation between grid points and therefore the
-         * output file is a very coarse representation of the actual solution
-         * field. Activating this option increases the spatial resolution in
-         * each dimension by a factor equal to the polynomial degree used for
-         * the velocity finite element (usually 2).
-         */
-        bool interpolate_output;
-
-        /**
-         * deal.II offers the possibility to filter duplicate vertices in HDF5
-         * output files. This merges the vertices of adjacent cells and
-         * therefore saves disk space, but misrepresents discontinuous
-         * output properties. Activating this function reduces the disk space
-         * by about a factor of $2^{dim}$ for hdf5 output.
-         */
-        bool filter_output;
-
-        /**
-         * If true, return quantities related to stresses and strain with
-         * point-wise values. Otherwise the values will be averaged on each
-         * cell.
-         */
-        bool pointwise_stress_and_strain;
-
-        /**
-         * deal.II offers the possibility to write vtu files with higher order
-         * representations of the output data. This means each cell will correctly
-         * show the higher order representation of the output data instead of the
-         * linear interpolation between vertices that ParaView and VisIt usually show.
-         * Note that activating this option is safe and recommended, but requires that
-         * (i) ``Output format'' is set to ``vtu'', (ii) ``Interpolate output'' is
-         * set to true, (iii) you use a sufficiently new version of Paraview
-         * or VisIt to read the files (Paraview version 5.5 or newer, and VisIt version
-         * to be determined), and (iv) you use deal.II version 9.1.0 or newer.
-         */
-        bool write_higher_order_output;
-
-        /**
-         * For mesh deformation computations ASPECT uses an
-         * Arbitrary-Lagrangian-Eulerian formulation to handle deforming the
-         * domain, so the mesh has its own velocity field. This may be
-         * written as an output field by setting output_mesh_velocity to true.
-         */
-        bool output_mesh_velocity;
-
-        /**
-         * For mesh deformation computations ASPECT uses an
-         * Arbitrary-Lagrangian-Eulerian formulation to handle deforming the domain, so the mesh
-         * has a field that determines the displacement from the reference
-         * configuration. This may be written as an output field by setting
-         * this flag to true.
-         */
-        bool output_mesh_displacement;
-
-        /**
-         * For mesh deformation computations ASPECT uses an
-         * Arbitrary-Lagrangian-Eulerian formulation to handle deforming the domain, and we output the
-         * mesh in its deformed state by default. If this flag is set to true,
-         * the mesh is written undeformed.
-         */
-        bool output_undeformed_mesh;
-
-        /**
-         * Whether or not ASPECT should also generate output for the base variables
-         * velocity, (fluid pressure and velocity), pressure, temperature
-         * and the compositional fields on the surface of the mesh.
-         * The mesh surface includes all boundaries of the domain.
-         */
-        bool output_base_variables_on_mesh_surface;
-
-        /**
-         * File operations can potentially take a long time, blocking the
-         * progress of the rest of the model run. Setting this variable to
-         * 'true' moves this process into a background thread, while the
-         * rest of the model continues.
-         */
-        bool write_in_background_thread;
-
-        /**
-         * Set the time output was supposed to be written. In the simplest
-         * case, this is the previous last output time plus the interval, but
-         * in general we'd like to ensure that it is the largest supposed
-         * output time, which is smaller than the current time, to avoid
-         * falling behind with last_output_time and having to catch up once
-         * the time step becomes larger. This is done after every output.
-         */
-        void set_last_output_time (const double current_time);
-
-        /**
-         * Record that the mesh changed. This helps some output writers avoid
-         * writing the same mesh multiple times.
-         */
-        void mesh_changed_signal ();
-
-        /**
-         * A function that writes the text in the second argument to a file
-         * with the name given in the first argument. The function is run on a
-         * separate thread to allow computations to continue even though
-         * writing data is still continuing.
-         */
-        static
-        void writer (const std::string &filename,
-                     const std::string &temporary_filename,
-                     const std::string &file_contents);
-
-        /**
-         * A list of postprocessor objects that have been requested in the
-         * parameter file.
-         */
-        std::list<std::unique_ptr<VisualizationPostprocessors::Interface<dim>>> postprocessors;
-
-        /**
-         * A structure that keeps some history about past output operations.
-         * These variables are grouped into a structure because we need them
-         * twice: Once for the cell output case (via DataOut) and once for
-         * surface output (via DataOutFaces).
-         */
-        struct OutputHistory
-        {
-          /**
-           * Constructor
-           */
-          OutputHistory ();
-
-          /**
-           * Destructor. Makes sure that any background thread that may still be
-           * running writing data to disk finishes before the current object is
-           * fully destroyed.
-           */
-          ~OutputHistory ();
-
-          /**
-           * Serialize the contents of this class as far as they are not read
-           * from input parameter files.
-           */
-          template <class Archive>
-          void serialize (Archive &ar, const unsigned int version);
-
-          /**
-           * Whether the mesh changed since the last time we produced cell-based
-           * output.
-           */
-          bool mesh_changed;
-
-          /**
-           * The most recent name of the mesh file, used to avoid redundant mesh
-           * output.
-           */
-          std::string last_mesh_file_name;
-
-          /**
-           * A list of pairs (time, pvtu_filename) that have so far been written
-           * and that we will pass to DataOutInterface::write_pvd_record to
-           * create a description file that can make the association between
-           * simulation time and corresponding file name (this is done because
-           * there is no way to store the simulation time inside the .pvtu or
-           * .vtu files).
-           */
-          std::vector<std::pair<double,std::string>> times_and_pvtu_names;
-
-          /**
-           * A list of list of filenames, sorted by timestep, that correspond to
-           * what has been created as output. This is used to create a descriptive
-           * .visit file for the entire simulation.
-           */
-          std::vector<std::vector<std::string>> output_file_names_by_timestep;
-
-          /**
-           * A set of data related to XDMF file sections describing the HDF5
-           * heavy data files created. These contain things such as the
-           * dimensions and names of data written at all steps during the
-           * simulation.
-           */
-          std::vector<XDMFEntry>  xdmf_entries;
-
-          /**
-           * Handle to a thread that is used to write data in the background.
-           * The writer() function runs on this background thread when outputting
-           * data for the `data_out` object.
-           */
-          std::thread background_thread;
-        };
-
-        /**
-         * Information about the history of writing graphical
-         * output for cells (via DataOut).
-         */
-        OutputHistory cell_output_history;
-
-        /**
-         * Information about the history of writing graphical
-         * output for faces (via DataOutFaces).
-         */
-        OutputHistory face_output_history;
-
-        /**
-         * Write the various descriptive record files. These files are used by
-         * visualization programs to identify which of the output files in a
-         * directory, possibly one file written by each processor, belong to a
-         * single time step and/or form the different time steps of a
-         * simulation. For Paraview, this is a <code>.pvtu</code> file per
-         * time step and a <code>.pvd</code> for all time steps. For VisIt it
-         * is a <code>.visit</code> file per time step and one for all time
-         * steps.
-         *
-         * @param data_out The DataOut object that was used to write the
-         * solutions.
-         * @param solution_file_prefix The stem of the filename to be written.
-         * @param filenames List of filenames for the current output from all
-         * processors.
-         * @param output_history The OutputHistory object to fill.
-         */
-        template <typename DataOutType>
-        void write_description_files (const DataOutType &data_out,
-                                      const std::string &solution_file_prefix,
-                                      const std::vector<std::string> &filenames,
-                                      OutputHistory                  &output_history) const;
-
-
-        /**
-         * A function, called from the execute() function, that takes a
-         * DataOut object, does some preliminary work with it, and then
-         * writes the result out to files via the writer() function (in the
-         * case of VTU output) or through the XDMF facilities.
-         *
-         * The function returns the base name of the output files produced,
-         * which can then be used for the statistics file and screen output.
-         */
-        template <typename DataOutType>
-        std::string write_data_out_data(DataOutType   &data_out,
-                                        OutputHistory &output_history,
-                                        const std::map<std::string,std::string> &visualization_field_names_and_units) const;
-    };
-  }
-
-
-  /**
-   * Given a class name, a name, and a description for the parameter file for
-   * a postprocessor, register it with the aspect::Postprocess::Manager class.
-   *
-   * @ingroup Postprocessing
-   */
-#define ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::Postprocess::VisualizationPostprocessors::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::Postprocess::Visualization<2>::register_visualization_postprocessor, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::Postprocess::VisualizationPostprocessors::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::Postprocess::Visualization<3>::register_visualization_postprocessor, \
-                                name, description); \
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/visualization/ISA_rotation_timescale.h.bak b/include/aspect/postprocess/visualization/ISA_rotation_timescale.h.bak
deleted file mode 100644
index 5c4790c8703..00000000000
--- a/include/aspect/postprocess/visualization/ISA_rotation_timescale.h.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_ISA_rotation_timescale_h
-#define _aspect_postprocess_visualization_ISA_rotation_timescale_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * This postprocessor calculates and outputs the timescale for the rotation
-       * of grains toward the infinite strain axis. Kaminski and Ribe (2002, Gcubed)
-       * call this quantity $\tau_{ISA}$, and define it as
-       * $\tau_{ISA} \approx \frac{1}{\dot{\epsilon}}$
-       * where $\dot{\epsilon}$ is the largest eigenvalue of the strain rate tensor.
-       * It can be used, along with the grain lag angle
-       * ($\Theta$), to calculate the grain orientation lag parameter (GOL).
-       * GOL is not calculated within ASPECT
-       * right now because it is proportional to the spatial gradient of theta, but in the
-       * future that calculation could be implemented in a material model with CopyOutputs
-       * (once they exist). For more thoughts on that, see the documentation for the
-       * grain lag angle postprocessor.
-       */
-      template <int dim>
-      class ISARotationTimescale: public CellDataVectorCreator<dim>, public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ISARotationTimescale();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute() const override;
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/adiabat.h.bak b/include/aspect/postprocess/visualization/adiabat.h.bak
deleted file mode 100644
index 90bf7e6634b..00000000000
--- a/include/aspect/postprocess/visualization/adiabat.h.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_adiabat_h
-#define _aspect_postprocess_visualization_adiabat_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that outputs adiabatic
-       * temperature, pressure, density, and density derivative.
-       */
-      template <int dim>
-      class Adiabat
-        : public DataPostprocessor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          Adiabat ();
-
-          std::vector<std::string>
-          get_names () const override;
-
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/artificial_viscosity.h.bak b/include/aspect/postprocess/visualization/artificial_viscosity.h.bak
deleted file mode 100644
index 40d088828f1..00000000000
--- a/include/aspect/postprocess/visualization/artificial_viscosity.h.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_artificial_viscosity_h
-#define _aspect_postprocess_visualization_artificial_viscosity_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived that implements a function that provides the
-       * artificial viscosity for the temperature equation on each cell for
-       * graphical output.
-       */
-      template <int dim>
-      class ArtificialViscosity : public CellDataVectorCreator<dim>,
-        public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ArtificialViscosity();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute () const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/artificial_viscosity_composition.h.bak b/include/aspect/postprocess/visualization/artificial_viscosity_composition.h.bak
deleted file mode 100644
index 047a2024f53..00000000000
--- a/include/aspect/postprocess/visualization/artificial_viscosity_composition.h.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_artificial_viscosity_composition_h
-#define _aspect_postprocess_visualization_artificial_viscosity_composition_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived that implements a function that provides the
-       * artificial viscosity for a given composition on each cell for
-       * graphical output.
-       */
-      template <int dim>
-      class ArtificialViscosityComposition : public CellDataVectorCreator<dim>,
-        public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ArtificialViscosityComposition();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute () const override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * A parameter that tells us for which compositional field the
-           * artificial viscosity should be visualized.
-           */
-          int compositional_field;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/boundary_indicator.h.bak b/include/aspect/postprocess/visualization/boundary_indicator.h.bak
deleted file mode 100644
index 7ae400a50c8..00000000000
--- a/include/aspect/postprocess/visualization/boundary_indicator.h.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_boundary_indicator_h
-#define _aspect_postprocess_visualization_boundary_indicator_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from CellDataVectorCreator that takes an output
-       * vector and computes a variable that represents the boundary
-       * indicator of the triangulation's cells' faces.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class BoundaryIndicator
-        : public CellDataVectorCreator<dim>,
-          public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          BoundaryIndicator();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute () const override;
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/boundary_strain_rate_residual.h.bak b/include/aspect/postprocess/visualization/boundary_strain_rate_residual.h.bak
deleted file mode 100644
index d0319a81bf4..00000000000
--- a/include/aspect/postprocess/visualization/boundary_strain_rate_residual.h.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_boundary_strain_rate_residual_h
-#define _aspect_postprocess_visualization_boundary_strain_rate_residual_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      using namespace dealii;
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the residual between
-       * the a reference strain rate dataset and the strain rate computed for the model domain.
-       * We only compute the residual between the second invariant of the strain rate
-       * and therefore, the input data is an ascii data file with columns corresponding
-       * to coordinates and one data column representing the second invariant of the strain rate.
-       *
-       * This quantity only makes sense at the surface of the domain.
-       * Thus, the value is set to zero in all the cells inside of the domain.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class BoundaryStrainRateResidual
-        : public DataPostprocessorScalar<dim>,
-          public SurfaceOnlyVisualization<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          BoundaryStrainRateResidual ();
-
-          /**
-           * Evaluate the strain rate residual for each component at the top face of the current cell
-           * if it lies at the surface boundary.
-           *
-           * @copydoc DataPostprocessorTensor<dim>::evaluate_vector_field()
-           */
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * Let the postprocessor manager know about the other postprocessors
-           * this one depends on. Specifically, the boundary strain rate residual statistics postprocessor.
-           */
-          std::list<std::string>
-          required_other_postprocessors() const override;
-
-          std::string
-          get_physical_units () const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/boundary_velocity_residual.h.bak b/include/aspect/postprocess/visualization/boundary_velocity_residual.h.bak
deleted file mode 100644
index 9847498f7e9..00000000000
--- a/include/aspect/postprocess/visualization/boundary_velocity_residual.h.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_boundary_velocity_residual_h
-#define _aspect_postprocess_visualization_boundary_velocity_residual_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      using namespace dealii;
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the velocity residual between
-       * the input velocity data and the velocity computed for the model domain.
-       * The input velocity could either be an ascii data file or a file generated
-       * by  the GPlates model.
-       * This quantity only makes sense at the surface of the domain.
-       * Thus, the value is set to zero in all the cells inside of the domain.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class BoundaryVelocityResidual
-        : public DataPostprocessorVector<dim>,
-          public SurfaceOnlyVisualization<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          BoundaryVelocityResidual ();
-
-          /**
-           * Evaluate the velocity residual for the current cell.
-           *
-           * @copydoc DataPostprocessorVector<dim>::evaluate_vector_field()
-           */
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * Let the postprocessor manager know about the other postprocessors
-           * this one depends on. Specifically, the boundary velocity residual statistics postprocessor.
-           */
-          std::list<std::string>
-          required_other_postprocessors() const override;
-
-          std::string
-          get_physical_units () const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/compositional_vector.h.bak b/include/aspect/postprocess/visualization/compositional_vector.h.bak
deleted file mode 100644
index 6b04b35cec7..00000000000
--- a/include/aspect/postprocess/visualization/compositional_vector.h.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_compositional_vector_h
-#define _aspect_postprocess_visualization_compositional_vector_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that can output sets of dim
-       * compositional fields as vectors.
-       */
-      template <int dim>
-      class CompositionalVector
-        : public DataPostprocessor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          CompositionalVector ();
-
-          std::vector<std::string>
-          get_names () const override;
-
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Names of vector fields.
-           */
-          std::vector<std::string> vector_names;
-
-          /**
-           * Stores sets of compositional field indices to
-           * be visualized together as vector fields.
-           */
-          std::vector<std::vector<unsigned int>> sets;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/depth.h.bak b/include/aspect/postprocess/visualization/depth.h.bak
deleted file mode 100644
index 46ad19f5d2a..00000000000
--- a/include/aspect/postprocess/visualization/depth.h.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_depth_h
-#define _aspect_postprocess_visualization_depth_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that outputs the depth
-       * according to the geometry model.
-       */
-      template <int dim>
-      class Depth
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          Depth ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/dynamic_topography.h.bak b/include/aspect/postprocess/visualization/dynamic_topography.h.bak
deleted file mode 100644
index be84ab848b3..00000000000
--- a/include/aspect/postprocess/visualization/dynamic_topography.h.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_dynamic_topography_h
-#define _aspect_postprocess_visualization_dynamic_topography_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessorScalar that computes a
-       * variable that represents the dynamic topography. This
-       * quantity, strictly speaking, only makes sense at the surface
-       * of the domain.  Thus, the value is set to zero in all the
-       * cells inside of the domain. Consider using the
-       * SurfaceDynamicTopography to only output the dynamic
-       * topography at the boundary of the domain.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class DynamicTopography
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          DynamicTopography();
-
-          /**
-           * Evaluate the dynamic topography for the current cell.
-           *
-           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
-           */
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * Register the other postprocessor that we need: DynamicTopography
-           */
-          std::list<std::string>
-          required_other_postprocessors() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/error_indicator.h.bak b/include/aspect/postprocess/visualization/error_indicator.h.bak
deleted file mode 100644
index a649ba071b3..00000000000
--- a/include/aspect/postprocess/visualization/error_indicator.h.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_error_indicator_h
-#define _aspect_postprocess_visualization_error_indicator_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived that implements a function that provides the computed
-       * mesh refinement/error indicators for graphical output.
-       */
-      template <int dim>
-      class ErrorIndicator : public CellDataVectorCreator<dim>,
-        public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ErrorIndicator();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute () const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/geoid.h.bak b/include/aspect/postprocess/visualization/geoid.h.bak
deleted file mode 100644
index 8bde86ac743..00000000000
--- a/include/aspect/postprocess/visualization/geoid.h.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_geoid_h
-#define _aspect_postprocess_visualization_geoid_h
-
-#include <aspect/simulator_access.h>
-#include <aspect/postprocess/visualization.h>
-#include <aspect/postprocess/geoid.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessorScalar that computes a variable
-       * that represents the geoid topography. This quantity, strictly
-       * speaking, only makes sense at the surface of the domain. Thus, the
-       * value is set to zero in all the cells inside of the domain.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class Geoid
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          Geoid();
-
-          /**
-           * Initialization function. This function is called once at the
-           * beginning of the program after parse_parameters is run and after
-           * the SimulatorAccess (if applicable) is initialized.
-           */
-          void
-          initialize () override;
-
-          /**
-           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
-           */
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-
-          /**
-           * Let the postprocessor manager know about the other postprocessors
-           * this one depends on. Specifically, the Geoid postprocessor.
-           */
-          std::list<std::string>
-          required_other_postprocessors() const override;
-
-        private:
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/grain_lag_angle.h.bak b/include/aspect/postprocess/visualization/grain_lag_angle.h.bak
deleted file mode 100644
index 8d5d5eb2204..00000000000
--- a/include/aspect/postprocess/visualization/grain_lag_angle.h.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_grain_lag_angle_h
-#define _aspect_postprocess_visualization_grain_lag_angle_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-
-      /**
-       * This postprocessor calculates and outputs the angle between the ~infinite
-       * strain axis and the velocity. Kaminski & Ribe (2002, Gcubed) call this quantity
-       * $\Theta$ and define it as
-       * $\Theta = \cos^{-1}(\hat{u}\cdot\hat{e})$
-       * where $\hat{u}=\vec{u}/|{u}|$, $\vec{u}$ is the local flow velocity, and
-       * $\hat{e}$ is the local infinite strain axis, which we calculate as the
-       * first eigenvector of the "left stretch" tensor.
-       * $\Theta$ can be used to calculate the grain orientation lag parameter (GOL).
-       * Calculating GOL also requires the ISA rotation timescale ($\tau_{ISA}$).
-       * GOL is not calculated within ASPECT
-       * right now because it is proportional to the spatial gradient of $\Theta$, but in the
-       * future that calculation could be implemented in a material model with CopyOutputs
-       * (once they exist). By tracking $\Theta$ as a CopyOutput (ie, a compositional field
-       * holding a calculated value that gets copied over instead of solved for), the spatial
-       * gradient of $\Theta$ could be calculated for the previous timestep by obtaining the
-       * old solution for the input material model. That gradient, and also the time derivative
-       * of $\Theta$, could then be used to calculate GOL at the previous timestep; $\Theta$ could
-       * be updated at the current timestep; and both quantities could be stored in CopyOutputs
-       * to step forward in time. Basically, the calculation of GOL would have to lag one
-       * timestep behind the other quantities in order to get the gradients, but we're
-       * often interested in GOL in a steady-state flow anyway.
-       */
-      template <int dim>
-      class GrainLagAngle: public CellDataVectorCreator<dim>, public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          GrainLagAngle();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute() const override;
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/gravity.h.bak b/include/aspect/postprocess/visualization/gravity.h.bak
deleted file mode 100644
index c58fb4ac5ff..00000000000
--- a/include/aspect/postprocess/visualization/gravity.h.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_gravity_h
-#define _aspect_postprocess_visualization_gravity_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessorVector that outputs the gravity
-       * as a vector field.
-       */
-      template <int dim>
-      class Gravity
-        : public DataPostprocessorVector<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          Gravity ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/heat_flux_map.h.bak b/include/aspect/postprocess/visualization/heat_flux_map.h.bak
deleted file mode 100644
index 8797826b787..00000000000
--- a/include/aspect/postprocess/visualization/heat_flux_map.h.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_heat_flux_map_h
-#define _aspect_postprocess_visualization_heat_flux_map_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A postprocessor that computes the heat flux density through the top and bottom boundaries.
-       *
-       * @ingroup Postprocessing
-       */
-      template <int dim>
-      class HeatFluxMap
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          HeatFluxMap();
-
-          /**
-           * Fill the temporary storage variables with the
-           * heat flux for the current time step.
-           *
-           * @copydoc Interface<dim>::update()
-           */
-          void update() override;
-
-          /**
-           * Compute the heat flux for the given input cell.
-           *
-           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
-           */
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * @copydoc Interface<dim>::declare_parameters()
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * @copydoc Interface<dim>::parse_parameters()
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * A flag that determines whether to use the point-wise
-           * heat flux calculation or the cell-wise averaged calculation.
-           */
-          bool output_point_wise_heat_flux;
-
-          /**
-           * A temporary storage place for the point-wise heat flux
-           * solution. Only initialized and used if output_point_wise_heat_flux
-           * is set to true.
-           */
-          LinearAlgebra::BlockVector heat_flux_density_solution;
-
-          /**
-           * A temporary storage place for the cell-wise heat flux
-           * solution. Only initialized and used if output_point_wise_heat_flux
-           * is set to false.
-           */
-          std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area;
-      };
-    }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/postprocess/visualization/heating.h.bak b/include/aspect/postprocess/visualization/heating.h.bak
deleted file mode 100644
index ca4e2550253..00000000000
--- a/include/aspect/postprocess/visualization/heating.h.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_heating_h
-#define _aspect_postprocess_visualization_heating_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes several scalar variables that represent the heating
-       * model outputs for every point. The list of written variables
-       * corresponds to the heating models that are used in the computation
-       * as specified in the 'Heating model' subsection in the input file.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class Heating
-        : public DataPostprocessor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          Heating ();
-
-          std::vector<std::string>
-          get_names () const override;
-
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/kxrcf_indicator.h.bak b/include/aspect/postprocess/visualization/kxrcf_indicator.h.bak
deleted file mode 100644
index bcd4022612d..00000000000
--- a/include/aspect/postprocess/visualization/kxrcf_indicator.h.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_kxrcf_indicator_h
-#define _aspect_postprocess_visualization_kxrcf_indicator_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived that implements a function that provides the
-       * KXRCF indicator for a given advection field on each cell for
-       * graphical output.
-       */
-      template <int dim>
-      class KXRCFIndicator : public CellDataVectorCreator<dim>,
-        public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          KXRCFIndicator();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute () const override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * A parameter that tells us for which advection field the
-           * KXRCF indicator should be visualized.
-           */
-          unsigned int field_index;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/material_properties.h.bak b/include/aspect/postprocess/visualization/material_properties.h.bak
deleted file mode 100644
index 5d1f91159a8..00000000000
--- a/include/aspect/postprocess/visualization/material_properties.h.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_material_properties_h
-#define _aspect_postprocess_visualization_material_properties_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes several scalar variables that represent the material
-       * model outputs for every point. The list of written variables can be
-       * chosen as input parameter. The principal functionality of this class
-       * is already implemented in some other visualization plugins, the
-       * purpose of this plugin is to efficiently compute all the wanted
-       * parameters in one call to the material model.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class MaterialProperties
-        : public DataPostprocessor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          MaterialProperties ();
-
-          std::vector<std::string>
-          get_names () const override;
-
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          std::vector<std::string> property_names;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h.bak b/include/aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h.bak
deleted file mode 100644
index 2d178f54af6..00000000000
--- a/include/aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_maximum_horizontal_compressive_stress_h
-#define _aspect_postprocess_visualization_maximum_horizontal_compressive_stress_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class that computes a field of horizontal vectors that
-       * represent the direction of maximal horizontal compressive
-       * stress. For an exact definition, see the documentation of
-       * this plugin in the manual.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class MaximumHorizontalCompressiveStress
-        : public DataPostprocessor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          MaximumHorizontalCompressiveStress();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * Return the vector of strings describing the names of the computed
-           * quantities. Given the purpose of this class, this is a vector
-           * with entries all equal to the name of the plugin.
-           */
-          std::vector<std::string> get_names () const override;
-
-          /**
-           * This functions returns information about how the individual
-           * components of output files that consist of more than one data set
-           * are to be interpreted. The returned value is
-           * DataComponentInterpretation::component_is_scalar repeated
-           * SymmetricTensor::n_independent_components times. (These
-           * components should really be part of a symmetric tensor, but
-           * deal.II does not allow marking components as such.)
-           */
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-          /**
-           * Return which data has to be provided to compute the derived
-           * quantities. The flags returned here are the ones passed to the
-           * constructor of this class.
-           */
-          UpdateFlags get_needed_update_flags () const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/melt.h.bak b/include/aspect/postprocess/visualization/melt.h.bak
deleted file mode 100644
index e44f1537923..00000000000
--- a/include/aspect/postprocess/visualization/melt.h.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_melt_h
-#define _aspect_postprocess_visualization_melt_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_out.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that outputs melt related
-       * properties of the material model.
-       */
-      template <int dim>
-      class MeltMaterialProperties
-        : public DataPostprocessor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          MeltMaterialProperties ();
-
-          std::vector<std::string>
-          get_names () const override;
-
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const  override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          std::vector<std::string> property_names;
-      };
-
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/melt_fraction.h.bak b/include/aspect/postprocess/visualization/melt_fraction.h.bak
deleted file mode 100644
index 8dd561cea61..00000000000
--- a/include/aspect/postprocess/visualization/melt_fraction.h.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-  Copyright (C) 2013 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_melt_fraction_h
-#define _aspect_postprocess_visualization_melt_fraction_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the melt fraction at every
-       * point.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class MeltFraction
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          MeltFraction ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Parameters for anhydrous melting of peridotite after Katz, 2003
-           */
-
-          // for the solidus temperature
-          double A1;   // °C
-          double A2; // °C/Pa
-          double A3; // °C/(Pa^2)
-
-          // for the lherzolite liquidus temperature
-          double B1;   // °C
-          double B2;   // °C/Pa
-          double B3; // °C/(Pa^2)
-
-          // for the liquidus temperature
-          double C1;   // °C
-          double C2;  // °C/Pa
-          double C3; // °C/(Pa^2)
-
-          // for the reaction coefficient of pyroxene
-          double r1;     // cpx/melt
-          double r2;     // cpx/melt/GPa
-          double M_cpx;  // mass fraction of pyroxenite
-
-          // melt fraction exponent
-          double beta;
-
-          /**
-           * Parameters for melting of pyroxenite after Sobolev et al., 2011
-           */
-
-          // for the melting temperature
-          double D1;    // °C
-          double D2;  // °C/Pa
-          double D3; // °C/(Pa^2)
-
-          // for the melt-fraction dependence of productivity
-          double E1;
-          double E2;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/named_additional_outputs.h.bak b/include/aspect/postprocess/visualization/named_additional_outputs.h.bak
deleted file mode 100644
index dcfb5f08681..00000000000
--- a/include/aspect/postprocess/visualization/named_additional_outputs.h.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Copyright (C) 2014 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_named_additional_outputs_h
-#define _aspect_postprocess_visualization_named_additional_outputs_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that generates visualization
-       * output for all additional material outputs that are derived
-       * from the 'NamedAdditionalMaterialOutputs' base class if the are
-       * filled in the evaluate function of the material model used in the
-       * computation.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class NamedAdditionalOutputs
-        : public DataPostprocessor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          NamedAdditionalOutputs ();
-
-          void
-          initialize () override;
-
-          std::vector<std::string>
-          get_names () const override;
-
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-        private:
-          std::vector<std::string> property_names;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/nonadiabatic_pressure.h.bak b/include/aspect/postprocess/visualization/nonadiabatic_pressure.h.bak
deleted file mode 100644
index c9d282fc51c..00000000000
--- a/include/aspect/postprocess/visualization/nonadiabatic_pressure.h.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_nonadiabatic_pressure_h
-#define _aspect_postprocess_visualization_nonadiabatic_pressure_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the non-adiabatic part of the
-       * pressure every point.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class NonadiabaticPressure
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          NonadiabaticPressure ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/nonadiabatic_temperature.h.bak b/include/aspect/postprocess/visualization/nonadiabatic_temperature.h.bak
deleted file mode 100644
index b71d32a5727..00000000000
--- a/include/aspect/postprocess/visualization/nonadiabatic_temperature.h.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_nonadiabatic_temperature_h
-#define _aspect_postprocess_visualization_nonadiabatic_temperature_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the non-adiabatic part of the
-       * temperature at every point.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class NonadiabaticTemperature
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          NonadiabaticTemperature ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/particle_count.h.bak b/include/aspect/postprocess/visualization/particle_count.h.bak
deleted file mode 100644
index a64a5ae8baf..00000000000
--- a/include/aspect/postprocess/visualization/particle_count.h.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_particle_count_h
-#define _aspect_postprocess_visualization_particle_count_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from CellDataVectorCreator that takes an output
-       * vector and computes a variable that represents the number of particles
-       * in each cell.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class ParticleCount
-        : public CellDataVectorCreator<dim>,
-          public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ParticleCount();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute () const override;
-
-          /**
-           * Let the postprocessor manager know about the other postprocessors
-           * this one depends on. Specifically, the particles postprocessor.
-           */
-          std::list<std::string>
-          required_other_postprocessors() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/partition.h.bak b/include/aspect/postprocess/visualization/partition.h.bak
deleted file mode 100644
index 30527e66be5..00000000000
--- a/include/aspect/postprocess/visualization/partition.h.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_partition_h
-#define _aspect_postprocess_visualization_partition_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes puts the number of
-       * the parallel process (i.e., the partition number) for each cell into
-       * the output file.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class Partition
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          Partition ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/principal_stress.h.bak b/include/aspect/postprocess/visualization/principal_stress.h.bak
deleted file mode 100644
index 5e2c24a5b21..00000000000
--- a/include/aspect/postprocess/visualization/principal_stress.h.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-  Copyright (C) 2020 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_principal_stress_h
-#define _aspect_postprocess_visualization_principal_stress_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that outputs the principal
-       * stress values and directions, i.e., the eigenvalues and eigenvectors
-       * of the stress tensor (or optionally of the deviatoric stress tensor).
-       */
-      template <int dim>
-      class PrincipalStress
-        : public DataPostprocessor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          PrincipalStress ();
-
-          std::vector<std::string>
-          get_names () const override;
-
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Whether to use the deviatoric stress tensor instead of the full stress
-           * tensor to compute principal directions and values.
-           */
-          bool use_deviatoric_stress;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/seismic_anomalies.h.bak b/include/aspect/postprocess/visualization/seismic_anomalies.h.bak
deleted file mode 100644
index ac482026cb5..00000000000
--- a/include/aspect/postprocess/visualization/seismic_anomalies.h.bak
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_seismic_anomalies_h
-#define _aspect_postprocess_visualization_seismic_anomalies_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived that implements a function that provides the computed
-       * computed seismic anomaly in $V_s$ for graphical output.
-       */
-      template <int dim>
-      class SeismicVsAnomaly
-        :
-        public CellDataVectorCreator<dim>,
-        public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          SeismicVsAnomaly();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute () const override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-
-          /**
-           * Scheme chosen to define the average seismic velocity as a
-           * function of depth. Reference profile evaluates the material model
-           * using the P-T profile defined by the reference adiabatic
-           * conditions and the lateral average option calculates the average
-           * velocity within a number n_slices of depth slices.
-           */
-          enum VelocityScheme
-          {
-            reference_profile,
-            lateral_average
-          } average_velocity_scheme;
-
-          /**
-           * Number of depth slices used to define average
-           * seismic shear wave velocities from which anomalies
-           * are calculated.
-           */
-          unsigned int n_slices;
-      };
-
-
-
-      /**
-       * A class derived that implements a function that provides the computed
-       * computed seismic anomaly in $V_p$ for graphical output.
-       */
-      template <int dim>
-      class SeismicVpAnomaly
-        :
-        public CellDataVectorCreator<dim>,
-        public SimulatorAccess<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          SeismicVpAnomaly();
-
-          /**
-           * @copydoc CellDataVectorCreator<dim>::execute()
-           */
-          std::pair<std::string, std::unique_ptr<Vector<float>>>
-          execute () const override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-
-          /**
-           * Scheme chosen to define the average seismic velocity as a
-           * function of depth. Reference profile evaluates the material model
-           * using the P-T profile defined by the reference adiabatic
-           * conditions and the lateral average option calculates the average
-           * velocity within a number n_slices of depth slices.
-           */
-          enum VelocityScheme
-          {
-            reference_profile,
-            lateral_average
-          } average_velocity_scheme;
-
-          /**
-           * Number of depth slices used to define average
-           * seismic compressional wave velocities from which anomalies
-           * are calculated.
-           */
-          unsigned int n_slices;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/shear_stress.h.bak b/include/aspect/postprocess/visualization/shear_stress.h.bak
deleted file mode 100644
index 460ba60ade4..00000000000
--- a/include/aspect/postprocess/visualization/shear_stress.h.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_shear_stress_h
-#define _aspect_postprocess_visualization_shear_stress_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the 3 or 6 independent
-       * components (in 2d and 3d, respectively) of the shear stress tensor at
-       * every point. The shear stress is defined as $2 \eta
-       * (\varepsilon(\mathbf u) - \tfrac 13 \textrm{trace}\
-       * \varepsilon(\mathbf u) \mathbf 1) = 2\eta (\varepsilon(\mathbf u) -
-       * \frac 13 (\nabla \cdot \mathbf u) \mathbf I)$ and differs from the
-       * full stress by the absence of the pressure.  The second term in the
-       * difference is zero if the model is incompressible.
-       * If elasticity is used, the elastic contribution is being accounted for.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class ShearStress
-        : public DataPostprocessorTensor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          ShearStress ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/spd_factor.h.bak b/include/aspect/postprocess/visualization/spd_factor.h.bak
deleted file mode 100644
index a001d55120c..00000000000
--- a/include/aspect/postprocess/visualization/spd_factor.h.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2017 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_spd_factor_h
-#define _aspect_postprocess_visualization_spd_factor_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the spd factor at every point.
-       * The spd factor is a factor which scales a part of the Jacobian used
-       * for the Newton solver to make sure that the Jacobian remains positive
-       * definite.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class SPD_Factor
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          SPD_Factor ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/spherical_velocity_components.h.bak b/include/aspect/postprocess/visualization/spherical_velocity_components.h.bak
deleted file mode 100644
index e3d0749157d..00000000000
--- a/include/aspect/postprocess/visualization/spherical_velocity_components.h.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_spherical_velocity_components_h
-#define _aspect_postprocess_visualization_spherical_velocity_components_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      class SphericalVelocityComponents
-        : public DataPostprocessorVector<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          SphericalVelocityComponents ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * Return the vector of strings describing the names of the computed
-           * quantities. Given the purpose of this class, this is a vector
-           * with entries all equal to the name of the plugin.
-           */
-          std::vector<std::string> get_names () const override;
-
-          /**
-           * This functions returns information about how the individual
-           * components of output files that consist of more than one data set
-           * are to be interpreted. The returned value is
-           * DataComponentInterpretation::component_is_scalar repeated
-           * SymmetricTensor::n_independent_components times. (These
-           * components should really be part of a symmetric tensor, but
-           * deal.II does not allow marking components as such.)
-           */
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-          std::string
-          get_physical_units () const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/strain_rate.h.bak b/include/aspect/postprocess/visualization/strain_rate.h.bak
deleted file mode 100644
index 72668cb4228..00000000000
--- a/include/aspect/postprocess/visualization/strain_rate.h.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_strain_rate_h
-#define _aspect_postprocess_visualization_strain_rate_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the strain rate at every
-       * point. The scalar strain rate is defined as $\sqrt{ (\varepsilon -
-       * \tfrac 13 \textrm{trace}\ \varepsilon \mathbf 1) : \varepsilon -
-       * \tfrac 13 \textrm{trace}\ \varepsilon \mathbf 1}$.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class StrainRate
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          StrainRate ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/strain_rate_tensor.h.bak b/include/aspect/postprocess/visualization/strain_rate_tensor.h.bak
deleted file mode 100644
index bdfed78dd4c..00000000000
--- a/include/aspect/postprocess/visualization/strain_rate_tensor.h.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_strain_rate_tensor_h
-#define _aspect_postprocess_visualization_strain_rate_tensor_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the 4 or 9
-       * components (in 2d and 3d, respectively) of the strain rate tensor at every
-       * point.
-       * The strain rate is defined as $\varepsilon(\mathbf u)$ in the incompressible
-       * case and as $\varepsilon(\mathbf u)
-       * - \tfrac 13 (\textrm{trace}\ \varepsilon(\mathbf u)) \mathbf I$
-       * in the compressible case.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class StrainRateTensor
-        : public DataPostprocessorTensor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          StrainRateTensor ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-#endif
diff --git a/include/aspect/postprocess/visualization/stress.h.bak b/include/aspect/postprocess/visualization/stress.h.bak
deleted file mode 100644
index ae4ea386b81..00000000000
--- a/include/aspect/postprocess/visualization/stress.h.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_stress_h
-#define _aspect_postprocess_visualization_stress_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the 3 or 6 independent
-       * components (in 2d and 3d, respectively) of the stress tensor at every
-       * point. The stress is defined as $2 \eta (\varepsilon(\mathbf u)
-       * - \tfrac 13 \textrm{trace}\ \varepsilon(\mathbf u) \mathbf 1) +pI =
-       * 2\eta (\varepsilon(\mathbf u) - \frac 13 (\nabla \cdot \mathbf u)
-       * \mathbf I) + pI$.  The second term in the parentheses is zero if the
-       * model is incompressible.
-       * If elasticity is used, the elastic contribution is being accounted for.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class Stress
-        : public DataPostprocessorTensor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          Stress ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/stress_second_invariant.h.bak b/include/aspect/postprocess/visualization/stress_second_invariant.h.bak
deleted file mode 100644
index 458e7f4b1e2..00000000000
--- a/include/aspect/postprocess/visualization/stress_second_invariant.h.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_postprocess_visualization_stress_second_invariant_h
-#define _aspect_postprocess_visualization_stress_second_invariant_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the second moment invariant
-       * of the deviatoric stress.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class StressSecondInvariant
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          StressSecondInvariant ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/surface_dynamic_topography.h.bak b/include/aspect/postprocess/visualization/surface_dynamic_topography.h.bak
deleted file mode 100644
index eca7bd7e1bc..00000000000
--- a/include/aspect/postprocess/visualization/surface_dynamic_topography.h.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_surface_dynamic_topography_h
-#define _aspect_postprocess_visualization_surface_dynamic_topography_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessorScalar that computes a
-       * variable that represents the dynamic topography, and outputs
-       * it on all boundary faces.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class SurfaceDynamicTopography
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>,
-          public SurfaceOnlyVisualization<dim>
-      {
-        public:
-          SurfaceDynamicTopography();
-
-          /**
-           * Evaluate the dynamic topography for the current cell.
-           *
-           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
-           */
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * Register the other postprocessor that we need: DynamicTopography
-           */
-          std::list<std::string>
-          required_other_postprocessors() const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/surface_elevation.h.bak b/include/aspect/postprocess/visualization/surface_elevation.h.bak
deleted file mode 100644
index db80cca4cd2..00000000000
--- a/include/aspect/postprocess/visualization/surface_elevation.h.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_surface_elevation_h
-#define _aspect_postprocess_visualization_surface_elevation_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessorScalar that computes a
-       * variable that represents the elevation of points on the ``top''
-       * surface relative to the geometry's undeformed state, and outputs
-       * it on boundary faces. On boundary faces not marked as ``top'',
-       * this class outputs a zero elevation.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class SurfaceElevation
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>,
-          public SurfaceOnlyVisualization<dim>
-      {
-        public:
-          SurfaceElevation();
-
-          /**
-           * Evaluate the dynamic topography for the current cell.
-           *
-           * @copydoc DataPostprocessorScalar<dim>::evaluate_vector_field()
-           */
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/surface_strain_rate_tensor.h.bak b/include/aspect/postprocess/visualization/surface_strain_rate_tensor.h.bak
deleted file mode 100644
index 15e5dfbd5c2..00000000000
--- a/include/aspect/postprocess/visualization/surface_strain_rate_tensor.h.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_surface_strain_rate_tensor_h
-#define _aspect_postprocess_visualization_surface_strain_rate_tensor_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the 4 or 9
-       * components (in 2d and 3d, respectively) of the strain rate tensor at every
-       * point of the surface of the domain.
-       * The strain rate is defined as $\varepsilon(\mathbf u)$ in the incompressible
-       * case and as $\varepsilon(\mathbf u)
-       * - \tfrac 13 (\textrm{trace}\ \varepsilon(\mathbf u)) \mathbf I$
-       * in the compressible case.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class SurfaceStrainRateTensor
-        : public DataPostprocessorTensor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>,
-          public SurfaceOnlyVisualization<dim>
-      {
-        public:
-          SurfaceStrainRateTensor ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/surface_stress.h.bak b/include/aspect/postprocess/visualization/surface_stress.h.bak
deleted file mode 100644
index 878c01d9351..00000000000
--- a/include/aspect/postprocess/visualization/surface_stress.h.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_surface_stress_h
-#define _aspect_postprocess_visualization_surface_stress_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the 3 or 6 independent
-       * components (in 2d and 3d, respectively) of the stress tensor at every
-       * point of the surface of the domain.
-       * The stress is defined as $2 \eta (\varepsilon(\mathbf u)
-       * - \tfrac 13 \textrm{trace}\ \varepsilon(\mathbf u) \mathbf 1) +pI =
-       * 2\eta (\varepsilon(\mathbf u) - \frac 13 (\nabla \cdot \mathbf u)
-       * \mathbf I) + pI$.  The second term in the parentheses is zero if the
-       * model is incompressible. If elasticity is used, its contribution
-       * is accounted for.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class SurfaceStress
-        : public DataPostprocessorTensor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>,
-          public SurfaceOnlyVisualization<dim>
-      {
-        public:
-          /**
-           * Constructor.
-           */
-          SurfaceStress ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/temperature_anomaly.h.bak b/include/aspect/postprocess/visualization/temperature_anomaly.h.bak
deleted file mode 100644
index bc00e09d94f..00000000000
--- a/include/aspect/postprocess/visualization/temperature_anomaly.h.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_temperature_anomaly_h
-#define _aspect_postprocess_visualization_temperature_anomaly_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that outputs the temperature
-       * anomaly (temperature-depth average of temperature).
-       */
-      template <int dim>
-      class TemperatureAnomaly
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          TemperatureAnomaly ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          void
-          update () override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Number of slices to use when computing depth average of temperature.
-           */
-          unsigned int n_slices;
-          /**
-           * Vector of temperature depth average values, padded to include two ghost values
-           * above and below the surface and bottom of the domain to allow interpolation at
-           * all depths.
-           */
-          std::vector<double> padded_temperature_depth_average;
-          /**
-           * Whether to extrapolate temperatures above/below the first/last depth-average slice
-           * or, alternatively, interpolate above the center of the first slice using the surface
-           * temperature or below the last slice using the bottom temperature.
-           */
-          bool extrapolate_surface;
-          bool extrapolate_bottom;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/vertical_heat_flux.h.bak b/include/aspect/postprocess/visualization/vertical_heat_flux.h.bak
deleted file mode 100644
index d1c00c694db..00000000000
--- a/include/aspect/postprocess/visualization/vertical_heat_flux.h.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_vertical_heat_flux_h
-#define _aspect_postprocess_visualization_vertical_heat_flux_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/numerics/data_postprocessor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the density at every point.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class VerticalHeatFlux
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          /**
-           * Constructor
-           */
-          VerticalHeatFlux ();
-
-          /**
-           * Evaluate the vertical heat flux for the current cell.
-           */
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/volume_of_fluid_values.h.bak b/include/aspect/postprocess/visualization/volume_of_fluid_values.h.bak
deleted file mode 100644
index bd9225431a5..00000000000
--- a/include/aspect/postprocess/visualization/volume_of_fluid_values.h.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_visualization_volume_of_fluid_values_h
-#define _aspect_postprocess_visualization_volume_of_fluid_values_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * Plugin to output volume fractions and reconstructed interface data
-       * from the Volume of Fluid Interface Tracking data.
-       */
-      template <int dim>
-      class VolumeOfFluidValues
-        : public DataPostprocessor<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          /**
-           * Standard constructor
-           */
-          VolumeOfFluidValues ();
-
-          /**
-           * Get the list of names for the components that will be produced by
-           * this postprocessor
-           */
-          std::vector<std::string>
-          get_names () const override;
-
-          /**
-           * Get the list of component interpretations for the components that
-           * will be produced by this postprocessor
-           */
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override;
-
-          /**
-           * Get required update flags
-           */
-          UpdateFlags
-          get_needed_update_flags () const override;
-
-          /**
-           * Produce that data based on provided solution data
-           */
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-
-          /**
-           * Declare the parameters this class takes through input files.
-           */
-          static
-          void
-          declare_parameters (ParameterHandler &prm);
-
-          /**
-           * Read the parameters this class declares from the parameter file.
-           */
-          void
-          parse_parameters (ParameterHandler &prm) override;
-
-        private:
-          /**
-           * Stored list of names for the produced components
-           */
-          std::vector<std::string> volume_of_fluid_names;
-
-          /**
-           * Stored list of interpretations for produced components
-           */
-          std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretations;
-
-          /**
-           * If true, the data output will include a field that has the
-           * reconstructed fluid interface as the zero contour
-           */
-          bool include_contour;
-
-          /**
-           * If true, the data output will include the normal vector for the reconstructed interface
-           */
-          bool include_normal;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/visualization/volumetric_strain_rate.h.bak b/include/aspect/postprocess/visualization/volumetric_strain_rate.h.bak
deleted file mode 100644
index 4ceafefbd76..00000000000
--- a/include/aspect/postprocess/visualization/volumetric_strain_rate.h.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2017 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_volumetric_strain_rate_h
-#define _aspect_postprocess_volumetric_strain_rate_h
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      /**
-       * A class derived from DataPostprocessor that takes an output vector
-       * and computes a variable that represents the volumetric strain rate at every
-       * point. The volumetric strain rate is defined as the divergence of the velocity
-       * (or the trace of the strain rate tensor):
-       * $\nabla\cdot\mathbf u = \textrm{div}\; \mathbf u = \textrm{trace}\; \varepsilon(\mathbf u)$.
-       *
-       * The member functions are all implementations of those declared in the
-       * base class. See there for their meaning.
-       */
-      template <int dim>
-      class VolumetricStrainRate
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          VolumetricStrainRate ();
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override;
-      };
-    }
-  }
-}
-
-#endif
diff --git a/include/aspect/postprocess/volume_of_fluid_statistics.h.bak b/include/aspect/postprocess/volume_of_fluid_statistics.h.bak
deleted file mode 100644
index d7c04b867ff..00000000000
--- a/include/aspect/postprocess/volume_of_fluid_statistics.h.bak
+++ /dev/null
@@ -1,53 +0,0 @@
-
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_postprocess_volume_of_fluid_statistics_h
-#define _aspect_postprocess_volume_of_fluid_statistics_h
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    /**
-     * A postprocessor that computes some statistics about the volume of fluid fields
-     *
-     * @ingroup Postprocessing
-     */
-    template <int dim>
-    class VolumeOfFluidStatistics : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate the solution for some velocity statistics.
-         */
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/prescribed_stokes_solution/ascii_data.h.bak b/include/aspect/prescribed_stokes_solution/ascii_data.h.bak
deleted file mode 100644
index c8311aa71be..00000000000
--- a/include/aspect/prescribed_stokes_solution/ascii_data.h.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_prescribed_stokes_solution_ascii_data_h
-#define _aspect_prescribed_stokes_solution_ascii_data_h
-
-#include <aspect/prescribed_stokes_solution/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a prescribed velocity field determined from
-     * a AsciiData input file.
-     *
-     * @ingroup PrescribedStokesSolution
-     */
-    template <int dim>
-    class AsciiData : public Utilities::AsciiDataInitial<dim>, public Interface<dim>
-    {
-      public:
-        /**
-         * Empty Constructor.
-         */
-        AsciiData ();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        void
-        initialize () override;
-
-        // avoid -Woverloaded-virtual:
-        using Utilities::AsciiDataInitial<dim>::initialize;
-
-        /**
-         * For the current class, this function returns value from the text
-         * files.
-         */
-        void
-        stokes_solution (const Point<dim> &position, Vector<double> &value) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/prescribed_stokes_solution/circle.h.bak b/include/aspect/prescribed_stokes_solution/circle.h.bak
deleted file mode 100644
index 5e350d14d6c..00000000000
--- a/include/aspect/prescribed_stokes_solution/circle.h.bak
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_prescribed_stokes_solution_circle_h
-#define _aspect_prescribed_stokes_solution_circle_h
-
-#include <aspect/prescribed_stokes_solution/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a circular, divergence-free flow field
-     * around the origin of the coordinate system.
-     *
-     * @ingroup PrescribedStokesSolution
-     */
-    template <int dim>
-    class Circle : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        void stokes_solution (const Point<dim> &p, Vector<double> &value) const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/prescribed_stokes_solution/function.h.bak b/include/aspect/prescribed_stokes_solution/function.h.bak
deleted file mode 100644
index 355a6eb6eea..00000000000
--- a/include/aspect/prescribed_stokes_solution/function.h.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_prescribed_stokes_solution_function_h
-#define _aspect_prescribed_stokes_solution_function_h
-
-#include <aspect/prescribed_stokes_solution/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements velocity and pressure solutions based on a
-     * functional description provided in the input file.
-     *
-     * @ingroup PrescribedStokesSolution
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Function ();
-
-        /**
-         * Return the velocity and pressure as a function of position.
-         */
-        void
-        stokes_solution (const Point<dim> &position, Vector<double> &value) const override;
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the velocity and
-         * pressure values will next be evaluated. For the current class,
-         * the function passes to the parsed function what the current time is.
-         */
-        void
-        update () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * A function object representing the components of the velocity.
-         */
-        Functions::ParsedFunction<dim> prescribed_velocity_function;
-        /**
-         * A function object representing the pressure.
-         */
-        Functions::ParsedFunction<dim> prescribed_pressure_function;
-        /**
-         * A function object representing the fluid pressure (in models with melt transport).
-         */
-        Functions::ParsedFunction<dim> prescribed_fluid_pressure_function;
-        /**
-         * A function object representing the compaction pressure (in models with melt transport).
-         */
-        Functions::ParsedFunction<dim> prescribed_compaction_pressure_function;
-        /**
-         * A function object representing the components of the fluid velocity (in models with melt transport).
-         */
-        Functions::ParsedFunction<dim> prescribed_fluid_velocity_function;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/prescribed_stokes_solution/interface.h.bak b/include/aspect/prescribed_stokes_solution/interface.h.bak
deleted file mode 100644
index 6d4f41421fa..00000000000
--- a/include/aspect/prescribed_stokes_solution/interface.h.bak
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#ifndef _aspect_prescribed_stokes_solution_interface_h
-#define _aspect_prescribed_stokes_solution_interface_h
-
-#include <aspect/plugins.h>
-
-#include <deal.II/base/point.h>
-#include <deal.II/base/parameter_handler.h>
-
-#include <deal.II/base/function.h>
-
-namespace aspect
-{
-  /**
-   * A namespace in which we define everything that has to do with defining
-   * the prescribed Stokes solution.
-   *
-   * @ingroup PrescribedStokesSolution
-   */
-  namespace PrescribedStokesSolution
-  {
-    using namespace dealii;
-
-    /**
-     * This plugin allows the user to prescribe a Stokes solution and can be
-     * thought of as velocity and pressure's equivalent of the initial
-     * conditions plugin.
-     *
-     * Note: This can only be used if the nonlinear solver scheme is
-     * `single Advection, no Stokes'.
-     *
-     * @ingroup PrescribedStokesSolution
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Given a position @p p, fill in desired velocity and pressure at
-         * that point into @p value, which will have dim+1 components. In @p
-         * value, the velocity components come first, followed by the pressure
-         * component.
-         */
-        virtual
-        void stokes_solution (const Point<dim> &p, Vector<double> &value) const = 0;
-    };
-
-
-
-
-    /**
-     * Register initial prescribed Stokes solution model so that it can be
-     * selected from the parameter file.
-     *
-     * @param name A string that identifies the prescribed Stokes solution
-     * model
-     * @param description A text description of what this model does and that
-     * will be listed in the documentation of the parameter file.
-     * @param declare_parameters_function A pointer to a function that can be
-     * used to declare the parameters that this prescribed Stokes solution
-     * model wants to read from input files.
-     * @param factory_function A pointer to a function that can create an
-     * object of this prescribed Stokes solution model.
-     *
-     * @ingroup PrescribedStokesSolution
-     */
-    template <int dim>
-    void
-    register_prescribed_stokes_solution_model (const std::string &name,
-                                               const std::string &description,
-                                               void (*declare_parameters_function) (ParameterHandler &),
-                                               std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-    /**
-     * A function that given the name of a model returns a pointer to an
-     * object that describes it. Ownership of the pointer is transferred to
-     * the caller.
-     *
-     * The model object returned is not yet initialized and has not read its
-     * runtime parameters yet.
-     *
-     * @ingroup PrescribedStokesSolution
-     */
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_prescribed_stokes_solution (ParameterHandler &prm);
-
-
-    /**
-     * Declare the runtime parameters of the registered prescribed Stokes
-     * solution models.
-     *
-     * @ingroup PrescribedStokesSolution
-     */
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm);
-
-
-    /**
-     * For the current plugin subsystem, write a connection graph of all of the
-     * plugins we know about, in the format that the
-     * programs dot and neato understand. This allows for a visualization of
-     * how all of the plugins that ASPECT knows about are interconnected, and
-     * connect to other parts of the ASPECT code.
-     *
-     * @param output_stream The stream to write the output to.
-     */
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &output_stream);
-
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a prescribed Stokes solution model, register it with the functions
-     * that can declare their parameters and create these objects.
-     *
-     * @ingroup PrescribedStokesSolution
-     */
-#define ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::PrescribedStokesSolution::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::PrescribedStokesSolution::register_prescribed_stokes_solution_model<2>, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::PrescribedStokesSolution::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::PrescribedStokesSolution::register_prescribed_stokes_solution_model<3>, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/simulator.h.bak b/include/aspect/simulator.h.bak
deleted file mode 100644
index 0c7fbd1630f..00000000000
--- a/include/aspect/simulator.h.bak
+++ /dev/null
@@ -1,2203 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_simulator_h
-#define _aspect_simulator_h
-
-#include <deal.II/base/timer.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/conditional_ostream.h>
-#include <deal.II/base/symmetric_tensor.h>
-
-DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-
-#include <deal.II/lac/affine_constraints.h>
-
-#include <deal.II/distributed/tria.h>
-
-#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/dofs/dof_tools.h>
-
-#include <deal.II/fe/fe_system.h>
-#include <deal.II/fe/mapping.h>
-#include <deal.II/base/tensor_function.h>
-
-DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-#include <aspect/lateral_averaging.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/boundary_heat_flux/interface.h>
-#include <aspect/boundary_composition/interface.h>
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/initial_composition/interface.h>
-#include <aspect/prescribed_stokes_solution/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/boundary_traction/interface.h>
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/time_stepping/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/particle/world.h>
-
-#include <boost/iostreams/tee.hpp>
-#include <boost/iostreams/stream.hpp>
-
-#include <memory>
-#include <thread>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim>
-  class MeltHandler;
-
-  template <int dim>
-  class NewtonHandler;
-
-  template <int dim>
-  class StokesMatrixFreeHandler;
-
-  template <int dim, int velocity_degree>
-  class StokesMatrixFreeHandlerImplementation;
-
-  namespace MeshDeformation
-  {
-    template <int dim>
-    class MeshDeformationHandler;
-  }
-
-  template <int dim>
-  class VolumeOfFluidHandler;
-
-  namespace internal
-  {
-    namespace Assembly
-    {
-      namespace Scratch
-      {
-        template <int dim>      struct StokesPreconditioner;
-        template <int dim>      struct StokesSystem;
-        template <int dim>      struct AdvectionSystem;
-      }
-
-      namespace CopyData
-      {
-        template <int dim>      struct StokesPreconditioner;
-        template <int dim>      struct StokesSystem;
-        template <int dim>      struct AdvectionSystem;
-      }
-    }
-  }
-
-  namespace Assemblers
-  {
-    template <int dim>      class Interface;
-    template <int dim>      class Manager;
-  }
-
-  struct DefectCorrectionResiduals
-  {
-    double initial_residual;
-    double velocity_residual;
-    double pressure_residual;
-    double residual;
-    double residual_old;
-    double switch_initial_residual;
-    double newton_residual_for_derivative_scaling_factor;
-    std::pair<double,double> stokes_residuals;
-  };
-
-  /**
-   * A data structure with all properties relevant to compute angular momentum and rotation.
-   */
-  template <int dim>
-  struct RotationProperties
-  {
-    RotationProperties()
-      :
-      scalar_moment_of_inertia(numbers::signaling_nan<double>()),
-      scalar_angular_momentum(numbers::signaling_nan<double>()),
-      scalar_rotation(numbers::signaling_nan<double>()),
-      tensor_moment_of_inertia(numbers::signaling_nan<SymmetricTensor<2,dim>>()),
-      tensor_angular_momentum(numbers::signaling_nan<Tensor<1,dim>>()),
-      tensor_rotation(numbers::signaling_nan<Tensor<1,dim>>())
-    {};
-
-    /**
-     * Scalar properties for the two-dimensional case
-     * with a fixed rotation axis (z).
-     */
-    double scalar_moment_of_inertia;
-    double scalar_angular_momentum;
-    double scalar_rotation;
-
-    /**
-     * Tensor properties for the three-dimensional case.
-     */
-    SymmetricTensor<2,dim> tensor_moment_of_inertia;
-    Tensor<1,dim> tensor_angular_momentum;
-    Tensor<1,dim> tensor_rotation;
-  };
-
-  /**
-   * This is the main class of ASPECT. It implements the overall simulation
-   * algorithm using the numerical methods discussed in the papers and manuals
-   * that accompany ASPECT.
-   *
-   * @ingroup Simulator
-   */
-  template <int dim>
-  class Simulator
-  {
-    public:
-      /**
-       * Constructor.
-       *
-       * @param mpi_communicator The MPI communicator on which this class is
-       * to work. The class creates a clone of the actual communicator to make
-       * its communications private from the rest of the world.
-       *
-       * @param prm The run-time parameter object from which this class
-       * obtains its settings.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      Simulator (const MPI_Comm mpi_communicator,
-                 ParameterHandler &prm);
-
-      /**
-       * Destructor. Destroy what needs to be destroyed after waiting for all
-       * threads that may still be doing something in the background.
-       */
-      ~Simulator ();
-
-      /**
-       * Declare the run-time parameters this class takes, and call the
-       * respective <code>declare_parameters</code> functions of the
-       * namespaces that describe geometries, material models, etc.
-       *
-       * @param prm The object in which the run-time parameters are to be
-       * declared.
-       *
-       * This function is implemented in
-       * <code>source/simulator/parameters.cc</code>.
-       */
-      static
-      void declare_parameters (ParameterHandler &prm);
-
-      /**
-       * The function that runs the overall algorithm. It contains the loop
-       * over all time steps as well as the logic of what to do when before
-       * the loop starts and within the time loop.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void run ();
-
-      /**
-       * Write a connection graph of all of the plugins we know about, in the
-       * format that the programs dot and neato understand. This allows for a
-       * visualization of how all of the plugins that ASPECT knows about are
-       * interconnected, and connect to other parts of the ASPECT code.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       *
-       * @param output_stream The stream to write the output to.
-       */
-      void
-      write_plugin_graph (std::ostream &output_stream) const;
-
-      /**
-       * Import Nonlinear Solver type.
-       */
-      using NonlinearSolver = typename Parameters<dim>::NonlinearSolver;
-
-      /**
-       * Import nullspace removal type.
-       */
-      using NullspaceRemoval = typename Parameters<dim>::NullspaceRemoval;
-
-
-      /**
-       * A structure that is used as an argument to functions that can work on
-       * both the temperature and the compositional variables and that need to
-       * be told which one of the two, as well as on which of the
-       * compositional variables.
-       */
-      struct AdvectionField
-      {
-        /**
-         * An enum indicating whether the identified variable is the
-         * temperature or one of the compositional fields.
-         */
-        enum FieldType { temperature_field, compositional_field };
-
-        /**
-         * A variable indicating whether the identified variable is the
-         * temperature or one of the compositional fields.
-         */
-        const FieldType    field_type;
-
-        /**
-         * A variable identifying which of the compositional fields is
-         * selected. This variable is meaningless if the temperature is
-         * selected.
-         */
-        const unsigned int compositional_variable;
-
-        /**
-         * Constructor.
-         * @param field_type Determines whether this variable should select
-         * the temperature field or a compositional field.
-         * @param compositional_variable The number of the compositional field
-         * if the first argument in fact chooses a compositional variable.
-         * Meaningless if the first argument equals temperature.
-         *
-         * This function is implemented in
-         * <code>source/simulator/helper_functions.cc</code>.
-         */
-        AdvectionField (const FieldType field_type,
-                        const unsigned int compositional_variable = numbers::invalid_unsigned_int);
-
-        /**
-         * A static function that creates an object identifying the
-         * temperature.
-         *
-         * This function is implemented in
-         * <code>source/simulator/helper_functions.cc</code>.
-         */
-        static
-        AdvectionField temperature ();
-
-        /**
-         * A static function that creates an object identifying given
-         * compositional field.
-         *
-         * This function is implemented in
-         * <code>source/simulator/helper_functions.cc</code>.
-         */
-        static
-        AdvectionField composition (const unsigned int compositional_variable);
-
-        /**
-         * Return whether this object refers to the temperature field.
-         */
-        bool
-        is_temperature () const;
-
-        /**
-         * Return whether this object refers to a field discretized by
-         * discontinuous finite elements.
-         */
-        bool
-        is_discontinuous (const Introspection<dim> &introspection) const;
-
-        /**
-         * Return the method that is used to solve the advection of this field
-         * (i.e. 'fem_field', 'particles').
-         */
-        typename Parameters<dim>::AdvectionFieldMethod::Kind
-        advection_method (const Introspection<dim> &introspection) const;
-
-        /**
-         * Look up the component index for this temperature or compositional
-         * field. See Introspection::component_indices for more information.
-         */
-        unsigned int component_index(const Introspection<dim> &introspection) const;
-
-        /**
-         * Look up the block index for this temperature or compositional
-         * field. See Introspection::block_indices for more information.
-         */
-        unsigned int block_index(const Introspection<dim> &introspection) const;
-
-        /**
-         * Look up the block index where the sparsity pattern for this field
-         * is stored. This can be different than block_index() as several fields
-         * can use the same pattern (typically in the first compositional field
-         * if all fields are compatible). See Introspection::block_indices
-         * for more information.
-         */
-        unsigned int sparsity_pattern_block_index(const Introspection<dim> &introspection) const;
-
-        /**
-         * Returns an index that runs from 0 (temperature field) to n (nth
-         * compositional field), and uniquely identifies the current advection
-         * field among the list of all advection fields. Can be used to index
-         * vectors that contain entries for all advection fields.
-         */
-        unsigned int field_index() const;
-
-        /**
-         * Look up the base element within the larger composite finite element
-         * we used for everything, for this temperature or compositional field
-         * See Introspection::base_elements for more information.
-         */
-        unsigned int base_element(const Introspection<dim> &introspection) const;
-
-        /**
-         * Return the FEValues scalar extractor for this temperature
-         * or compositional field.
-         * This function is implemented in
-         * <code>source/simulator/helper_functions.cc</code>.
-         */
-        FEValuesExtractors::Scalar scalar_extractor(const Introspection<dim> &introspection) const;
-
-        /**
-         * Look up the polynomial degree order for this temperature or compositional
-         * field. See Introspection::polynomial_degree for more information.
-         */
-        unsigned int polynomial_degree(const Introspection<dim> &introspection) const;
-      };
-
-    private:
-
-      /**
-       * A member variable that tracks whether we are completely done
-       * with initialization and have started the time loop. This
-       * variable needs to be the first one that is initialized in
-       * the constructor, so that its value correctly tracks the
-       * status of the overall object. As a consequence, it has to
-       * be the first one declared in this class.
-       *
-       * The variable is set to @p true just before we start the time
-       * stepping loop, but may be temporarily reset to @p false
-       * if, for example, we are during the initial mesh refinement
-       * steps where we start the time loop, but then go back to
-       * initialization steps (mesh refinement, interpolation of initial
-       * conditions, etc.) before re-starting the time loop.
-       *
-       * This variable is queried by
-       * SimulatorAccess::simulator_is_past_initialization().
-       */
-      bool simulator_is_past_initialization;
-
-      /**
-       * A class that is empty but that can be used as a member variable and
-       * whose constructor will be run in the order in which the member
-       * variables are initialized. Because this class has a constructor that
-       * takes a function object that it will execute whenever the member
-       * variable is initialized, this allows running arbitrary actions in
-       * between member variable initializers, for example if some member
-       * variable is partially initialized at point A within the member
-       * variable initializer list, its initialization can only be finalized
-       * after point B (because it depends on what another member variable
-       * decides to do), but needs to be finished by point C within the member
-       * initialization. In such a case, one may have a member variable of the
-       * current time placed in the list of member variables such that it is
-       * initialized at point B, and then initialize it using a function
-       * object that performs the finalization of initialization.
-       */
-      struct IntermediaryConstructorAction
-      {
-        IntermediaryConstructorAction (const std::function<void ()> &action);
-      };
-
-      /**
-       * @name Top-level functions in the overall flow of the numerical
-       * algorithm
-       * @{
-       */
-
-      /**
-       * The function that sets up the DoFHandler objects, It also sets up the
-       * various partitioners and computes those constraints on the Stokes
-       * variable and temperature that are the same between all time steps.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void setup_dofs ();
-
-      /**
-       * This function initializes the variables of the introspection object.
-       * It is called by setup_dofs() right after distributing degrees of
-       * freedom since this is when all of the information is available.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void setup_introspection ();
-
-      /**
-       * A function that is responsible for initializing the
-       * temperature/compositional field before the first time step. The
-       * temperature field then serves as the temperature from which the
-       * velocity is computed during the first time step, and is subsequently
-       * overwritten by the temperature field one gets by advancing by one
-       * time step.
-       *
-       * This function is implemented in
-       * <code>source/simulator/initial_conditions.cc</code>.
-       */
-      void set_initial_temperature_and_compositional_fields ();
-
-      /**
-       * A function that initializes the pressure variable before the first
-       * time step. It does so by either interpolating (for continuous
-       * pressure finite elements) or projecting (for discontinuous elements)
-       * the adiabatic pressure computed from the material model.
-       *
-       * Note that the pressure so set is overwritten by the pressure in fact
-       * computed during the first time step. We need this function, however,
-       * so that the evaluation of pressure-dependent coefficients (e.g.
-       * pressure dependent densities or thermal coefficients) during the
-       * first time step has some useful pressure to start with.
-       *
-       * This function is implemented in
-       * <code>source/simulator/initial_conditions.cc</code>.
-       */
-      void compute_initial_pressure_field ();
-
-      /**
-       * Fill the given @p constraints with constraints coming from the velocity boundary
-       * conditions that do not change over time. This function is used by
-       * setup_dofs();
-       */
-      void compute_initial_velocity_boundary_constraints (AffineConstraints<double> &constraints);
-
-      /**
-       * Fill the given @p constraints with constraints coming from the velocity boundary
-       * conditions that do can change over time. This function is used by
-       * compute_current_constraints().
-       */
-      void compute_current_velocity_boundary_constraints (AffineConstraints<double> &constraints);
-
-      /**
-       * Given the 'constraints' member that contains all constraints that are
-       * independent of the time (e.g., hanging node constraints, tangential
-       * flow constraints, etc), copy it over to 'current_constraints' and add
-       * to the latter all constraints that do depend on time such as
-       * temperature or velocity Dirichlet boundary conditions. This function
-       * is therefore called at the beginning of every time step in
-       * start_timestep(), but also when setting up the initial values.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void compute_current_constraints ();
-
-      /**
-       * Compute the factor by which we scale the second of
-       * the Stokes equations (the "pressure scaling factor").
-       * We compute the factor by taking the logarithmic
-       * average of the viscosities we find on the cells in
-       * this domain and dividing this average by a reference
-       * length scale provided by the used geometry model.
-       *
-       * This function returns the pressure scaling variable.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      double compute_pressure_scaling_factor () const;
-
-      /**
-       * Do some housekeeping at the beginning of each time step. This
-       * includes generating some screen output, adding some information to
-       * the statistics file, and interpolating time-dependent boundary
-       * conditions specific to this particular time step (the time
-       * independent boundary conditions, for example for hanging nodes or for
-       * tangential flow, are computed only once per mesh in setup_dofs()).
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void start_timestep ();
-
-      /**
-       * Do the various steps necessary to assemble and solve the things
-       * necessary in each time step.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void solve_timestep ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * If `single Advection, single Stokes' is selected as the nonlinear solver scheme,
-       * no nonlinear iterations are done, and the temperature, compositional fields and
-       * Stokes equations are solved exactly once per time step, one after the other.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_single_advection_single_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `no Advection, iterated Stokes' scheme only solves the Stokes system and
-       * ignores compositions and the temperature equation (careful, the material
-       * model must not depend on the temperature; mostly useful for
-       * Stokes benchmarks).
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_no_advection_iterated_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `no Advection, single Stokes' scheme only solves the Stokes system and
-       * ignores compositions and the temperature equation.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_no_advection_single_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `first timestep only, single Stokes' scheme only solves the Stokes system,
-       * for the initial timestep. This results in a `steady state' velocity field for
-       * particle calculations.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_first_timestep_only_single_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `iterated Advection and Stokes' scheme iterates
-       * by alternating the solution of the temperature, composition and Stokes systems.
-       * This is essentially a type of Picard iterations for the whole
-       * system of equations.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_iterated_advection_and_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `single Advection, iterated Stokes' scheme solves the temperature and
-       * composition equations once at the beginning of each time step
-       * and then iterates out the solution of the Stokes equation using
-       * Picard iterations.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_single_advection_iterated_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `no Advection, iterated defect correction Stokes' scheme
-       * does not solve the temperature and composition equations
-       * but only iterates out the solution of the Stokes
-       * equation using Defect Correction (DC) Picard iterations.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_no_advection_iterated_defect_correction_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `single Advection, iterated defect correction Stokes' scheme
-       * solves the temperature and composition equations once at the beginning
-       * of each time step and then iterates out the solution of the Stokes
-       * equation using Defect Correction (DC) Picard iterations.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_single_advection_iterated_defect_correction_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `iterated Advection and defect correction Stokes' scheme
-       * iterates over both the temperature and composition equations
-       * and the Stokes equations at the same time. The Stokes equation
-       * is iterated out using the Defect Correction (DC) form of the
-       * Picard iterations.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_iterated_advection_and_defect_correction_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `iterated Advection and Newton Stokes' scheme iterates over solving the temperature,
-       * composition, and Stokes equations just like `iterated Advection and Stokes', but
-       * for the Stokes system it is able to switch from a defect correction form of
-       * Picard iterations to Newton iterations after a certain tolerance or
-       * number of iterations is reached. This can greatly improve the
-       * convergence rate for particularly nonlinear viscosities.
-       *
-       * @param use_newton_iterations Sets whether this function should only use defect
-       * correction iterations (use_newton_iterations = false) or also use Newton iterations
-       * (use_newton_iterations = true).
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_iterated_advection_and_newton_stokes (bool use_newton_iterations);
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `single Advection, iterated Newton Stokes' scheme solves the temperature and
-       * composition equations once at the beginning of each time step
-       * and then iterates out the solution of the Stokes equation using Newton iterations.
-       * For the Stokes system it is able to switch from a defect correction form of
-       * Picard iterations to Newton iterations after a certain tolerance or
-       * number of iterations is reached. This can greatly improve the
-       * convergence rate for particularly nonlinear viscosities.
-       *
-       * @param use_newton_iterations Sets whether this function should only use defect
-       * correction iterations (use_newton_iterations = false) or also use Newton iterations
-       * (use_newton_iterations = true).
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_single_advection_and_iterated_newton_stokes (bool use_newton_iterations);
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `single Advection, no Stokes' scheme only solves the temperature and other
-       * advection systems and instead of solving for the Stokes system,
-       * a prescribed velocity and pressure is used."
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_single_advection_no_stokes ();
-
-      /**
-       * This function implements one scheme for the various
-       * steps necessary to assemble and solve the nonlinear problem.
-       *
-       * The `no Advection, no Stokes' scheme skips solving the temperature,
-       * composition and Stokes equations, which permits to go directly to
-       * postprocessing after setting up the initial condition.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void solve_no_advection_no_stokes ();
-
-      /**
-       * Initiate the assembly of the Stokes preconditioner matrix via
-       * assemble_stokes_preconditioner(), then set up the data structures to
-       * actually build a preconditioner from this matrix.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void build_stokes_preconditioner ();
-
-      /**
-       * Initialize the preconditioner for the advection equation of field
-       * index.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void build_advection_preconditioner (const AdvectionField &advection_field,
-                                           aspect::LinearAlgebra::PreconditionILU &preconditioner,
-                                           const double diagonal_strengthening);
-
-      /**
-       * Initiate the assembly of the Stokes matrix and right hand side.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void assemble_stokes_system ();
-
-      /**
-       * Assemble and solve the temperature equation.
-       * This function returns the residual after solving.
-       *
-       * If the `residual` argument is not a `nullptr`, the function computes
-       * the residual and puts it into this variable. The function returns
-       * the current residual divided by the initial residual given as the
-       * first argument. The two arguments may point to the same variable,
-       * in which case the function first computes the residual and at
-       * the end scales that residual by itself, thus returning 1.0.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      double assemble_and_solve_temperature (const double &initial_residual = 0,
-                                             double *residual = nullptr);
-
-      /**
-       * Solve the composition equations with whatever method is selected
-       * (fields or particles). This function returns the residuals for
-       * all fields after solving.
-       *
-       * If the `residual` argument is not a `nullptr`, the function computes
-       * the residual and puts it into this variable. The function returns
-       * the current residual divided by the initial residual given as the
-       * first argument. The two arguments may point to the same variable,
-       * in which case the function first computes the residual and at
-       * the end scales that residual by itself, thus returning 1.0.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      std::vector<double> assemble_and_solve_composition (const std::vector<double> &initial_residual = {},
-                                                          std::vector<double> *residual = nullptr);
-
-      /**
-       * Assemble and solve the Stokes equation.
-       * This function returns the nonlinear residual after solving.
-       *
-       * If the `residual` argument is not a `nullptr`, the function computes
-       * the residual and puts it into this variable. The function returns
-       * the current residual divided by the initial residual given as the
-       * first argument. The two arguments may point to the same variable,
-       * in which case the function first computes the residual and at
-       * the end scales that residual by itself, thus returning 1.0.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      double assemble_and_solve_stokes (const double &initial_nonlinear_residual = 0,
-                                        double *nonlinear_residual = nullptr);
-
-      /**
-       * Do one step of the defect correction form of the Stokes equation;
-       * i.e., assemble and solve the defect correction equations.
-       * This function takes a structure of DefectCorrectionResiduals which
-       * contains information about different residuals. The information in
-       * this structure is updated by this function. The parameter use_picard
-       * forces the use of the defect correction Picard iteration, if set to 'true' no
-       * Newton derivatives are added to the matrix.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver_schemes.cc</code>.
-       */
-      void do_one_defect_correction_Stokes_step(DefectCorrectionResiduals &dcr,
-                                                const bool use_picard);
-
-      /**
-       * Initiate the assembly of one advection matrix and right hand side and
-       * build a preconditioner for the matrix.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void assemble_advection_system (const AdvectionField &advection_field);
-
-      /**
-       * Solve one block of the temperature/composition linear system.
-       * Return the initial nonlinear residual, i.e., if the linear system to
-       * be solved is $Ax=b$, then return $\|Ax_0-b\|$ where $x_0$ is the
-       * initial guess for the solution variable and is taken from the
-       * current_linearization_point member variable.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver.cc</code>.
-       */
-      double solve_advection (const AdvectionField &advection_field);
-
-      /**
-       * Interpolate a particular particle property to the solution field.
-       *
-       * @deprecated: Use interpolate_particle_property_vector() instead.
-       */
-      DEAL_II_DEPRECATED
-      void interpolate_particle_properties (const AdvectionField &advection_field);
-
-      /**
-       * Interpolate the corresponding particle properties into the given
-       * @p advection_fields solution fields.
-       */
-      void interpolate_particle_properties (const std::vector<AdvectionField> &advection_fields);
-
-      /**
-       * Solve the Stokes linear system.
-       *
-       * The function returns two pieces of information as a pair of doubles:
-       * - The initial nonlinear residual, i.e., if the linear system to be
-       *   solved is $Ax_{k+1}=b$, then we use $\|Ax_k-b\|$ where $x_k$ is the
-       *   initial guess for the solution variable and is taken from
-       *   the @p current_linearization_point member variable. For the
-       *   purpose of this function, this residual is computed
-       *   only from the velocity and pressure equations (i.e., for the 2x2 block
-       *   system involving the velocity and pressure variables). A rationale
-       *   for why this number is computed is given below.
-       * - The final linear residual, i.e., if the linear system to be
-       *   solved is $Ax_{k+1}=b$, then we use $\|Ax_{k+1}-b\|$ where $x_{k+1}$
-       *   is the solution just computed. If we use a direct solver to compute
-       *   the solution of the linear system, then this linear residual is of
-       *   course zero (or at least quite close to it) and the function just
-       *   returns a zero value without even attempting to compute the actual
-       *   value. On the other hand, if the function uses an iterative solver,
-       *   then the value of the final linear residual is related to the
-       *   tolerance with which we solve the linear system and generally
-       *   indicates how accurately or inaccurately the linear system has been
-       *   solved.
-       *
-       * The two values are used in nonlinear solver schemes to assess how
-       * accurate the solution was before the current solve (for the first
-       * element of the returned pair) and how accurately the next iteration
-       * will have to be solved (for the second element of the pair) when using
-       * the Eisenstat-Walker method.
-       *
-       * @note If this function is called from a nonlinear solver -- e.g., the
-       * `single Advection, iterated Stokes', or the
-       * `iterated Advection and Stokes' solvers schemes --, then the
-       * @p current_linearization_point is the solution of the previous
-       * iteration (or the solution extrapolated from the previous time
-       * steps, if this is the first nonlinear iteration). Let us call
-       * this solution $x_k$ as above, where $x$ is a two-component
-       * block vector that consists of velocity and pressure. This function
-       * then assumes that we have already built the system matrix $A_k=A(x_k)$
-       * and $F_k=F(x_k)$, both linearized around the previous solution. The
-       * function solves the linear system $A_k x_{k+1} = F_k$ for the
-       * solution $x_{k+1}$. If the linear system were solved exactly, then
-       * that would imply that the <i>linear residual</i>
-       * $\|A_k x_{k+1} - F_k\|$ were zero, or at least small. In other words,
-       * its size does not tell us anything about how accurately we have
-       * solved the nonlinear system. On the other hand, the <i>nonlinear
-       * residual</i> $\|A_k x_k - F_k\|$ tells us something about how
-       * accurately the previous guess $x_k$ already solved the nonlinear
-       * system. Consequently, this is what this function returns. (In some
-       * sense, this is not really what we are interested in: it tells us
-       * how accurate the solution <i>already</i> was, and if it was already
-       * pretty accurate, then we may not want to actually solve for
-       * $x_{k+1}$. But, this would require that this function receives a
-       * tolerance so that it can bail out early without actually solving
-       * for $x_{k+1}$ if the tolerance is already reached. This function does
-       * not actually do that -- in some sense, one may argue that if we have
-       * already built the matrix and right hand side, we may as well solve
-       * with them, whether or not the solution was already good. If it
-       * happens to have been good already, then it will be even better after
-       * the solve. If it was not good enough yet, then we have to solve
-       * anyway.) In contrast to all of this, if we are using a Newton
-       * solver, then $x_{k+1}$ is actually the Newton <i>update</i>
-       * vector, for which we have no initial guess other than the zero
-       * vector. In this case, the function simply returns $\|F_k\|$ as the
-       * first element of the pair, where $F_k=F(x_k)$ is the residual
-       * vector for the previous solution $x_k$.
-       *
-       * This function is implemented in
-       * <code>source/simulator/solver.cc</code>.
-       */
-      std::pair<double,double>
-      solve_stokes ();
-
-      /**
-       * Solve the Stokes system using a block preconditioner and GMG.
-       */
-      std::pair<double,double>
-      solve_stokes_block_gmg ();
-
-      /**
-       * This function is called at the end of every time step. It runs all
-       * the postprocessors that have been listed in the input parameter file
-       * (see the manual) in turn. In particular, this usually includes
-       * generating graphical output every few time steps.
-       *
-       * The function also updates the statistics output file at the end of
-       * each time step.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void postprocess ();
-
-      /**
-       * Refine the mesh according to error indicators calculated by
-       * compute_refinement_criterion(), set up all necessary data structures
-       * on this new mesh, and interpolate the old solutions onto the new
-       * mesh.
-       *
-       * @param[in] max_grid_level The maximum refinement level of the mesh.
-       * This is the sum of the initial global refinement and the initial
-       * adaptive refinement (as provided by the user in the input file) and
-       * in addition it gets increased by one at each additional refinement
-       * time.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void refine_mesh (const unsigned int max_grid_level);
-
-      /**
-       * @}
-       */
-
-      /**
-       * @name Functions used in saving the state of the program and
-       * restarting from a saved state
-       * @{
-       */
-      /**
-       * Save the state of this program to a set of files in the output
-       * directory. In reality, however, only some variables are stored (in
-       * particular the mesh, the solution vectors, etc) whereas others can
-       * either be re-generated (matrices, DoFHandler objects, etc) or are
-       * read from the input parameter file. See the manual for more
-       * information.
-       *
-       * This function is implemented in
-       * <code>source/simulator/checkpoint_restart.cc</code>.
-       */
-      void create_snapshot();
-
-      /**
-       * Restore the state of this program from a set of files in the output
-       * directory. In reality, however, only some variables are stored (in
-       * particular the mesh, the solution vectors, etc) whereas others can
-       * either be re-generated (matrices, DoFHandler objects, etc) or are
-       * read from the input parameter file. See the manual for more
-       * information. This function only restores those variables that can
-       * neither be re-generated from other information nor are read from the
-       * input parameter file.
-       *
-       * This function is implemented in
-       * <code>source/simulator/checkpoint_restart.cc</code>.
-       */
-      void resume_from_snapshot();
-
-      /**
-       * Save a number of variables using BOOST serialization mechanism.
-       *
-       * This function is implemented in
-       * <code>source/simulator/checkpoint_restart.cc</code>.
-       */
-      template <class Archive>
-      void serialize (Archive &ar, const unsigned int version);
-      /**
-       * @}
-       */
-
-      /**
-       * @name Functions used in setting up linear systems
-       * @{
-       */
-      /**
-       * Determine which of the components of our finite-element
-       * system couple to each other. Depending on which equations
-       * are solved and which solver is used this varies widely.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      Table<2,DoFTools::Coupling>
-      setup_system_matrix_coupling () const;
-
-      /**
-       * Set up the size and structure of the matrix used to store the
-       * elements of the linear system.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void setup_system_matrix (const std::vector<IndexSet> &system_partitioning);
-
-      /**
-       * Set up the size and structure of the matrix used to store the
-       * elements of the matrix that is used to build the
-       * preconditioner for the system. This matrix is only used for
-       * the Stokes system, so while it has the size of the whole
-       * system, it only has entries in the velocity and pressure
-       * blocks.
-       *
-       * This function is implemented in
-       * <code>source/simulator/core.cc</code>.
-       */
-      void setup_system_preconditioner (const std::vector<IndexSet> &system_partitioning);
-
-      /**
-       * @}
-       */
-
-      /**
-       * @name Functions, classes, and variables used in the assembly of linear systems
-       * @{
-       */
-
-      /**
-       * A member variable that stores, for the current simulation, what
-       * functions need to be called in order to assemble linear systems,
-       * matrices, and right hand side vectors.
-       *
-       * One would probably want this variable to just be a member of type
-       * Assemblers::Manager<dim>, but this requires that
-       * this type is declared in the current scope, and that would require
-       * including <simulator/assemblers/interface.h> which we don't want because it's big.
-       * Consequently, we just store a pointer to such an object, and create
-       * the object pointed to at the top of set_assemblers().
-       */
-      std::unique_ptr<Assemblers::Manager<dim>> assemblers;
-
-      /**
-       * Determine, based on the run-time parameters of the current simulation,
-       * which functions need to be called in order to assemble linear systems,
-       * matrices, and right hand side vectors.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void set_assemblers ();
-
-      /**
-       * Determine, based on the run-time parameters of the current simulation,
-       * which functions need to be called in order to assemble linear systems,
-       * matrices, and right hand side vectors for the advection. This function
-       * is used by both the default full Stokes solver and the Newton solvers,
-       * but not by the two-phase flow solver.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void set_advection_assemblers ();
-
-      /**
-       * Determine, based on the run-time parameters of the current simulation,
-       * which functions need to be called in order to assemble linear systems,
-       * matrices, and right hand side vectors for the default full Stokes solver
-       * i.e. without considering two-phase flow, or Newton solvers.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void set_stokes_assemblers ();
-
-      /**
-       * Initiate the assembly of the preconditioner for the Stokes system.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void assemble_stokes_preconditioner ();
-
-      /**
-       * Compute the integrals for the preconditioner for the Stokes system on
-       * a single cell.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void
-      local_assemble_stokes_preconditioner (const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                            internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch,
-                                            internal::Assembly::CopyData::StokesPreconditioner<dim> &data);
-
-      /**
-       * Copy the contribution to the preconditioner for the Stokes system
-       * from a single cell into the global matrix that stores these elements.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void
-      copy_local_to_global_stokes_preconditioner (const internal::Assembly::CopyData::StokesPreconditioner<dim> &data);
-
-      /**
-       * Compute the integrals for the Stokes matrix and right hand side on a
-       * single cell.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void
-      local_assemble_stokes_system (const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                    internal::Assembly::Scratch::StokesSystem<dim>  &scratch,
-                                    internal::Assembly::CopyData::StokesSystem<dim> &data);
-
-      /**
-       * Copy the contribution to the Stokes system from a single cell into
-       * the global matrix that stores these elements.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void
-      copy_local_to_global_stokes_system (const internal::Assembly::CopyData::StokesSystem<dim> &data);
-
-      /**
-       * Compute the integrals for one advection matrix and right hand side on
-       * the faces of a single cell.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void
-      local_assemble_advection_face_terms(const AdvectionField &advection_field,
-                                          const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                          internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
-                                          internal::Assembly::CopyData::AdvectionSystem<dim> &data);
-      /**
-       * Compute the integrals for one advection matrix and right hand side on
-       * a single cell.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void
-      local_assemble_advection_system (const AdvectionField &advection_field,
-                                       const Vector<double>           &viscosity_per_cell,
-                                       const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                       internal::Assembly::Scratch::AdvectionSystem<dim>  &scratch,
-                                       internal::Assembly::CopyData::AdvectionSystem<dim> &data);
-
-      /**
-       * Copy the contribution to the advection system from a single cell into
-       * the global matrix that stores these elements.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void
-      copy_local_to_global_advection_system (const AdvectionField &advection_field,
-                                             const internal::Assembly::CopyData::AdvectionSystem<dim> &data);
-
-      /**
-       * @}
-       */
-
-      /**
-       * @name Helper functions
-       * @{
-       */
-      /**
-       * This routine adjusts the second block of the right hand side of a
-       * Stokes system  (containing the term that comes from compressibility,
-       * so that the system becomes compatible: $0=\int div u = \int g$. The
-       * vector to adjust is given as the argument of this function. This
-       * function makes use of the helper vector
-       * pressure_shape_function_integrals that contains $h_i=(q_i,1)$ with
-       * the pressure functions $q_i$ and we adjust the right hand side $g$ by
-       * $h_i \int g / |\Omega|$.
-       *
-       * The purpose of this function is described in the second paper on the
-       * numerical methods in ASPECT.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void make_pressure_rhs_compatible(LinearAlgebra::BlockVector &vector);
-
-      /**
-       * Fills a vector with the artificial viscosity for the temperature or
-       * composition on each local cell.
-       * @param viscosity_per_cell Output vector
-       * @param advection_field Determines whether this variable should select
-       * the temperature field or a compositional field.
-       * @param skip_interior_cells A boolean flag. If set to true the function
-       * will only compute the artificial viscosity in cells at boundaries.
-       */
-      template <typename T>
-      void get_artificial_viscosity (Vector<T> &viscosity_per_cell,
-                                     const AdvectionField &advection_field,
-                                     const bool skip_interior_cells = false) const;
-
-      /**
-       * Compute the seismic shear wave speed, Vs anomaly per element. we
-       * compute the anomaly by computing a smoothed (over 200 km or so)
-       * laterally averaged temperature profile and associated seismic
-       * velocity that is then subtracted from the seismic velocity at the
-       * current pressure temperature conditions
-       *
-       * @param values The output vector of depth averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void compute_Vs_anomaly(Vector<float> &values) const;
-
-      /**
-       * Compute the seismic pressure wave speed, Vp anomaly per element. we
-       * compute the anomaly by computing a smoothed (over 200 km or so)
-       * laterally averaged temperature profile and associated seismic
-       * velocity that is then subtracted from the seismic velocity at the
-       * current pressure temperature conditions
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       *
-       * @param values The output vector of depth averaged values. The
-       * function takes the pre-existing size of this vector as the number of
-       * depth slices.
-       */
-      void compute_Vp_anomaly(Vector<float> &values) const;
-
-      /**
-       * Adjust the pressure variable (which is only determined up to
-       * a constant by the equations, though its value may enter
-       * traction boundary conditions) by adding a constant to it in
-       * such a way that the pressure on the surface or within the
-       * entire volume has a known average value. The point of this
-       * function is that the pressure that results from solving the
-       * linear system may not coincide with what we think of as the
-       * "physical pressure"; in particular, we typically think of the
-       * pressure as zero (on average) along the surface because it is
-       * the sum of the hydrostatic and dynamic pressure, where the
-       * former is thought of as zero along the surface. This function
-       * therefore converts from the "mathematical" pressure to the
-       * "physical" pressure so that all following postprocessing
-       * steps can use the latter.
-       *
-       * In the case of the surface average, whether a face is part of
-       * the surface is determined by asking whether its depth of its
-       * midpoint (as determined by the geometry model) is less than
-       * 1/3*1/sqrt(dim-1)*diameter of the face. For reasonably curved
-       * boundaries, this rules out side faces that are perpendicular
-       * to the surface boundary but includes those faces that are
-       * along the boundary even if the real boundary is curved.
-       *
-       * Whether the pressure should be normalized based on the
-       * surface or volume average is decided by a parameter in the
-       * input file.
-       *
-       * @note This function is called after setting the initial
-       * pressure field in compute_initial_pressure_field() and at the end
-       * of solve_stokes(). This makes sense because these are exactly the
-       * places where the pressure is modified or re-computed.
-       *
-       * @return This function returns the pressure adjustment by value.
-       * This is so that its negative can later be used again in
-       * denormalize_pressure().
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      double normalize_pressure(LinearAlgebra::BlockVector &vector) const;
-
-      /**
-       * Invert the action of the normalize_pressure() function above. This
-       * means that we move from a pressure that satisfies the pressure
-       * normalization (e.g., has a zero average pressure, or a zero average
-       * surface pressure) to one that does not actually satisfy this
-       * normalization, and this doesn't seem to make sense because we are
-       * not interested in such a pressure.
-       *
-       * Indeed, this function is only called at the very beginning of
-       * solve_stokes() before we compute the initial (linear) residual
-       * of the linear system $Ax=b$ that corresponds to the Stokes system,
-       * where $x$ is the variable for which the pressure is adjusted
-       * back to the "wrong" form. Because stokes_system() calls
-       * normalize_pressure() at the end of its operations, no such
-       * "wrong" pressure ever escapes the realm of solve_stokes(). The
-       * "wrong" pressure is then used for two purposes in that function:
-       * (i) To compute the initial Stokes residual, which makes sense
-       * because it can only be zero (if we solved the same linear system
-       * twice) if we re-use the exact same pressure as we got from the
-       * previous solve -- i.e., before we called normalize_pressure()
-       * at the end of the solve. (ii) To initialize the solution vector
-       * before calling the GMRES solver, which also makes sense because
-       * the best guess vector for GMRES is the one that had previously
-       * come out of GMRES, namely the one on which we later called
-       * normalize_pressure().
-       *
-       * This function modifies @p vector in-place. In some cases, we need
-       * locally_relevant values of the pressure. To avoid creating a new vector
-       * and transferring data, this function uses a second vector with relevant
-       * dofs (@p relevant_vector) for accessing these pressure values. Both
-       * @p vector and @p relevant_vector are expected to already contain
-       * the correct pressure values.
-       *
-       * @note The adjustment made in this function is done using the
-       * negative of the @p pressure_adjustment function argument that
-       * would typically have been computed and returned by the
-       * normalize_pressure() function. This value is typically stored in
-       * the member variable @p last_pressure_normalization_adjustment,
-       * but the current function doesn't read this variable but instead
-       * gets the adjustment variable from the given argument.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void denormalize_pressure(const double                      pressure_adjustment,
-                                LinearAlgebra::BlockVector       &vector,
-                                const LinearAlgebra::BlockVector &relevant_vector) const;
-
-      /**
-       * Apply the bound preserving limiter to the discontinuous Galerkin solutions:
-       * i.e., given two fixed upper and lower bound [min, max], after applying the limiter,
-       * the discontinuous Galerkin solution will stay in the prescribed bounds.
-       *
-       * This function is implemented in
-       * <code>source/simulator/limiters.cc</code>.
-       */
-      void apply_BP_limiter_to_dg_solutions (const AdvectionField &advection_field);
-
-      /**
-       * Apply the WENO limiter to the discontinuous Galerkin solutions.
-       * WENO is short for Weighted Essentially Non-Oscillatory, which is
-       * a class of high-resolution schemes used in the numerical solution
-       * of hyperbolic conservation laws. The basic idea of WENO limiter is
-       * to replace the solution in troubled cells (cells with oscillation)
-       * by a polynomial reconstruction that takes the neighbor cells into
-       * account. The WENO scheme implemented in the program is a simple
-       * variant proposed by Zhong and Shu, 2013.
-       *
-       * This function is implemented in
-       * <code>source/simulator/limiters.cc</code>.
-       */
-      void apply_WENO_limiter_to_dg_solutions (const AdvectionField &advection_field);
-
-      /**
-       * Fills a vector with the KXRCF indicator for a given advection field
-       * on each local cell. The KXRCF indicator is a metric of discontinuity
-       * for hyperbolic conservation laws. Cells with high KXRCF values are
-       * identified as "troubled cells" and will be smoothed by the WENO limiter.
-       *
-       * This function is implemented in
-       * <code>source/simulator/limiters.cc</code>.
-       */
-      template <typename T>
-      void compute_KXRCF_indicators(Vector<T> &KXRCF_indicators,
-                                    const AdvectionField &advection_field) const;
-
-      /**
-       * Compute the reactions in case of operator splitting:
-       * Using the current solution vector, this function makes a number of time
-       * steps determined by the size of the reaction time step, and solves a
-       * system of coupled ordinary differential equations for the reactions between
-       * compositional fields and temperature in each of them. To do that, is uses
-       * the reaction rates outputs from the material and heating models used in
-       * the computation. The solution vector is then updated with the new values
-       * of temperature and composition after the reactions.
-       *
-       * As the ordinary differential equation in any given point is independent
-       * from the solution at all other points, we do not have to assemble a matrix,
-       * but just need to loop over all node locations for the temperature and
-       * compositional fields and compute the update to the solution.
-       *
-       * The function also updates the old solution vectors with the reaction update
-       * so that the advection time stepping scheme will have the correct field terms
-       * for the right-hand side when assembling the advection system.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void compute_reactions ();
-
-      /**
-       * Update the indicated block of the solution vector with the
-       * corresponding block of the handed over @p distributed_vector. Also
-       * update reaction_vector with the corresponding block of @p
-       * distributed_reaction_vector.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void update_solution_vectors_with_reaction_results (const unsigned int block_index,
-                                                          const LinearAlgebra::BlockVector &distributed_vector,
-                                                          const LinearAlgebra::BlockVector &distributed_reaction_vector);
-
-      /**
-       * Initialize the current linearization point vector from the old
-       * solution vector(s). Depending on the time of the call this
-       * can be simply a copy of the solution of the last timestep,
-       * or a linear extrapolation of old and old_old timestep to
-       * the new timestep.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void initialize_current_linearization_point ();
-
-      /**
-       * Interpolate material model outputs onto an advection field (temperature
-       * or composition). For the field identified by the AdvectionField @p adv_field, this function
-       * asks the material model to fill a MaterialModel::MaterialModelOutputs
-       * object that has an attached MaterialModel::PrescribedFieldOutputs
-       * "additional outputs" object (for composition) or an attached
-       * MaterialModel::PrescribedTemperatureOutputs (for temperature).
-       * The MaterialModel::MaterialModelInputs
-       * object passed to the material model then contains the support points of
-       * the advection field, thereby allowing the outputs to be
-       * interpolated to the finite element space and consequently into the
-       * solution vector.
-       * This is useful for advection fields whose advection mode is set
-       * to Parameters::AdvectionFieldMethod::prescribed_field or
-       * Parameters::AdvectionFieldMethod::prescribed_field_with_diffusion.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void interpolate_material_output_into_advection_field (const AdvectionField &adv_field);
-
-
-      /**
-       * Interpolate the given function onto the velocity FE space and write
-       * it into the given vector.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void interpolate_onto_velocity_system(const TensorFunction<1,dim> &func,
-                                            LinearAlgebra::Vector &vec);
-
-
-      /**
-       * Add constraints to the given @p constraints object that are required
-       * for unique solvability of the velocity block based on the nullspace
-       * removal settings.
-       *
-       * This method will add a zero Dirichlet constraint for the first
-       * velocity unknown in the domain for each velocity component, which is
-       * later being processed for translational or linear momentum removal.
-       * This avoids breakdowns of the linear solvers that otherwise occurred
-       * in some instances.
-       *
-       * @note: Rotational modes are currently not handled and don't appear to
-       * require constraints so far.
-       */
-      void setup_nullspace_constraints(AffineConstraints<double> &constraints);
-
-
-      /**
-       * Eliminate the nullspace of the velocity in the given vector. Both
-       * vectors are expected to contain the up to date data.
-       *
-       * @param relevant_dst locally relevant vector for the whole FE, will be
-       * filled at the end.
-       * @param tmp_distributed_stokes only contains velocity and pressure.
-       *
-       * This function is implemented in
-       * <code>source/simulator/nullspace.cc</code>.
-       */
-      void remove_nullspace(LinearAlgebra::BlockVector &relevant_dst,
-                            LinearAlgebra::BlockVector &tmp_distributed_stokes);
-
-      /**
-       * Compute the angular momentum and other rotation properties
-       * of the velocities in the given solution vector.
-       *
-       * @param use_constant_density determines whether to use a constant
-       * density (which corresponds to computing a net rotation instead of net
-       * angular momentum).
-       * @param solution Solution vector to compute the properties for.
-       * @param limit_to_top_faces allows to only compute the net angular momentum
-       * (or net rotation) of the top surface.
-       *
-       * This function is implemented in
-       * <code>source/simulator/nullspace.cc</code>.
-       */
-      RotationProperties<dim>
-      compute_net_angular_momentum(const bool use_constant_density,
-                                   const LinearAlgebra::BlockVector &solution,
-                                   const bool limit_to_top_faces = false) const;
-
-      /**
-       * Remove the angular momentum of the given vector
-       *
-       * @param use_constant_density determines whether to use a constant
-       * density (which corresponds to removing a net rotation instead of net
-       * angular momentum).
-       * @param relevant_dst locally relevant vector for the whole FE, will be
-       * filled at the end.
-       * @param tmp_distributed_stokes only contains velocity and pressure.
-       * @param limit_to_top_faces allows to only remove the net angular momentum
-       * (or net rotation) of the top surface. This can be useful to compare surface
-       * motions against plate reconstructions in no net rotation reference frames.
-       *
-       * This function is implemented in
-       * <code>source/simulator/nullspace.cc</code>.
-       */
-      void remove_net_angular_momentum( const bool use_constant_density,
-                                        LinearAlgebra::BlockVector &relevant_dst,
-                                        LinearAlgebra::BlockVector &tmp_distributed_stokes,
-                                        const bool limit_to_top_faces = false);
-
-      /**
-       * Offset the boundary id of all faces located on an outflow boundary
-       * by a fixed value given by the input parameter @p boundary_id_offset.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void replace_outflow_boundary_ids(const unsigned int boundary_id_offset);
-
-      /**
-       * Undo the offset of the boundary ids done in replace_outflow_boundary_ids
-       * by resetting all boundary ids to their original value.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void restore_outflow_boundary_ids(const unsigned int boundary_id_offset);
-
-      /**
-       * Remove the linear momentum of the given vector
-       *
-       * @param use_constant_density determines whether to use a constant
-       * density (which corresponds to removing a net translation instead of
-       * net linear momentum).
-       * @param relevant_dst locally relevant vector for the whole FE, will be
-       * filled at the end.
-       * @param tmp_distributed_stokes only contains velocity and pressure.
-       *
-       * This function is implemented in
-       * <code>source/simulator/nullspace.cc</code>.
-       */
-      void remove_net_linear_momentum( const bool use_constant_density,
-                                       LinearAlgebra::BlockVector &relevant_dst,
-                                       LinearAlgebra::BlockVector &tmp_distributed_stokes);
-
-      /**
-       * Compute the maximal velocity throughout the domain. This is needed to
-       * compute the size of the time step.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      double get_maximal_velocity (const LinearAlgebra::BlockVector &solution) const;
-
-      /**
-       * Compute the variation (i.e., the difference between maximal and
-       * minimal value) of the entropy $(T-\bar T)^2$ where $\bar T$ is the
-       * average temperature throughout the domain given as argument to this
-       * function.
-       *
-       * This function is used in computing the artificial diffusion
-       * stabilization term.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      double get_entropy_variation (const double average_field,
-                                    const AdvectionField &advection_field) const;
-
-      /**
-       * Compute the minimal and maximal temperature throughout the domain from
-       * a solution vector extrapolated from the previous time steps. This is
-       * needed to compute the artificial diffusion stabilization terms.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      std::pair<double,double>
-      get_extrapolated_advection_field_range (const AdvectionField &advection_field) const;
-
-      /**
-       * Exchange coarsen/refinement flags set between processors so that
-       * we have the correct settings on all ghost cells.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       *
-       */
-      void exchange_refinement_flags();
-
-
-      /**
-       * Check if timing output should be written in this timestep, and if so
-       * write it.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       *
-       */
-      void maybe_write_timing_output () const;
-
-      /**
-       * Check if a checkpoint should be written in this timestep. If so create
-       * one. Returns whether a checkpoint was written.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      bool maybe_write_checkpoint (const time_t last_checkpoint_time,
-                                   const bool force_writing_checkpoint);
-
-      /**
-       * Check if we should do an initial refinement cycle in this timestep.
-       * This will only be checked in timestep 0, afterwards the variable
-       * pre_refinement_step variable is invalidated, and this function will
-       * return without doing refinement.
-       * An initial refinement cycle is different from a regular one,
-       * because time is not increased. Instead the same timestep is solved
-       * using the new mesh.
-       * Therefore, only output timing information and postprocessor output
-       * if required in the input file. But always output statistics (to have
-       * a history of the number of cells in the statistics file).
-       * This function returns whether an initial refinement was done.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      bool maybe_do_initial_refinement (const unsigned int max_refinement_level);
-
-      /**
-       * Check if refinement is requested in this timestep. If so: Refine mesh.
-       * The @p max_refinement_level might be increased from this time on
-       * if this is an additional refinement cycle.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void maybe_refine_mesh (const double new_time_step,
-                              unsigned int &max_refinement_level);
-
-      /**
-       * Advance the current time by the given @p step_size and update the
-       * solution vectors as needed.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void advance_time (const double step_size);
-
-      /**
-       * Compute the artificial diffusion coefficient value on a cell given
-       * the values and gradients of the solution passed as arguments.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      double
-      compute_viscosity(internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
-                        const double                        global_u_infty,
-                        const double                        global_field_variation,
-                        const double                        average_field,
-                        const double                        global_entropy_variation,
-                        const double                        cell_diameter,
-                        const AdvectionField     &advection_field) const;
-
-      /**
-       * Compute the residual of one advection equation to be used for the
-       * artificial diffusion coefficient value on a cell given the values and
-       * gradients of the solution passed as arguments.
-       *
-       * This function is implemented in
-       * <code>source/simulator/assembly.cc</code>.
-       */
-      void
-      compute_advection_system_residual(internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
-                                        const double                        average_field,
-                                        const AdvectionField               &advection_field,
-                                        double                             &max_residual,
-                                        double                             &max_velocity,
-                                        double                             &max_density,
-                                        double                             &max_specific_heat,
-                                        double                             &conductivity) const;
-
-      /**
-       * Return whether the Stokes matrix depends on the values of the
-       * solution at the previous time step. This is the case is the
-       * coefficients that appear in the matrix (i.e., the viscosity and, in
-       * the case of a compressible model, the density) depend on the
-       * solution.
-       *
-       * This function exists to ensure that the Stokes matrix is rebuilt in
-       * time steps where it may have changed, while we want to save the
-       * effort of rebuilding it whenever we don't need to.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      bool
-      stokes_matrix_depends_on_solution () const;
-
-      /**
-       * Return whether to the best of our knowledge the A block of the
-       * Stokes system is symmetric. This is the case for most models, except
-       * if additional non-symmetric terms are added by special assemblers
-       * (e.g., the free surface stabilization term).
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-      */
-      bool
-      stokes_A_block_is_symmetric () const;
-
-      /**
-       * This function checks that the user-selected formulations of the
-       * equations are consistent with the other inputs. If an incorrect
-       * selection is detected it throws an exception. It for example assures that
-       * correct heating terms are selected, and the material model supports
-       * the selection of the mass conservation formulation (e.g. incompressible)).
-       * If the parameter 'parameters.formulation' is set to 'custom'
-       * it only ensures very basic consistency.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void
-      check_consistency_of_formulation ();
-
-      /**
-      * This function checks if the default solver and/or material
-      * averaging were selected and if so, determines the appropriate
-      * solver and/or averaging option.
-      */
-      void
-      select_default_solver_and_averaging ();
-
-      /**
-       * This function checks that the user-selected boundary conditions do not
-       * contain contradictions. If an incorrect selection is detected it
-       * throws an exception. This for example assures that not both velocity
-       * and traction boundary conditions are prescribed at the same boundary,
-       * and that no boundary temperatures are prescribed at a periodic boundary.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void
-      check_consistency_of_boundary_conditions () const;
-
-      /**
-       * Computes the initial Newton residual.
-       */
-      double
-      compute_initial_newton_residual (const LinearAlgebra::BlockVector &linearized_stokes_initial_guess);
-
-      /**
-       * This function computes the Eisenstat Walker linear tolerance used for the Newton iterations
-       * in the `iterated Advection and Newton Stokes' and `single Advection, iterated Newton Stokes' solver schemes.
-       * The Eisenstat and Walker (1996) method is used for determining the linear tolerance of
-       * the iteration after the first iteration. The paper gives two preferred choices of computing
-       * this tolerance. Both choices are implemented here with the suggested parameter values and
-       * safeguards.
-       */
-      double
-      compute_Eisenstat_Walker_linear_tolerance(const bool EisenstatWalkerChoiceOne,
-                                                const double maximum_linear_stokes_solver_tolerance,
-                                                const double linear_stokes_solver_tolerance,
-                                                const double stokes_residual,
-                                                const double newton_residual,
-                                                const double newton_residual_old);
-
-      /**
-       * This function is called at the end of each time step and writes the
-       * statistics object that contains data like the current time, the
-       * number of linear solver iterations, and whatever the postprocessors
-       * have generated, to disk.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      void output_statistics();
-
-      /**
-       * This routine computes the initial (nonlinear) Stokes residual that is
-       * needed as a convergence criterion in models with solver schemes that do
-       * nonlinear iterations. We calculate it in the same way as the tolerance for the linear
-       * solver, using the norm of the pressure RHS for the pressure part and a
-       * residual with zero velocity for the velocity part to get the part of
-       * the RHS not balanced by the static pressure.
-       *
-       * This function is implemented in
-       * <code>source/simulator/helper_functions.cc</code>.
-       */
-      double
-      compute_initial_stokes_residual();
-
-      /**
-       * @}
-       */
-
-      /**
-       * @name Variables that have to do with input, output, parallel
-       * communication and interfacing with other parts of the program.
-       * @{
-       */
-      Parameters<dim>                     parameters;
-
-      /**
-       * Unique pointer for an instance of the MeltHandler. This way,
-       * if we do not need the machinery for doing melt stuff, we do
-       * not even allocate it.
-       */
-      std::unique_ptr<MeltHandler<dim>> melt_handler;
-
-      /**
-       * Unique pointer for an instance of the NewtonHandler. This way,
-       * if we do not need the machinery for doing Newton stuff, we do
-       * not even allocate it.
-       */
-      std::unique_ptr<NewtonHandler<dim>> newton_handler;
-
-      SimulatorSignals<dim>               signals;
-
-      const IntermediaryConstructorAction post_signal_creation;
-
-      /**
-       * Unique pointer for an instance of the VolumeOfFluidHandler. This way,
-       * if we do not need the machinery for doing volume_of_fluid stuff, we do
-       * not even allocate it.
-       *
-       * Located here due to needing signals access
-       */
-      std::unique_ptr<VolumeOfFluidHandler<dim>> volume_of_fluid_handler;
-
-      Introspection<dim>                  introspection;
-
-
-      MPI_Comm                            mpi_communicator;
-
-      /**
-       * This stream will log into the file output/log.txt (used automatically
-       * by pcout).
-       */
-      std::ofstream log_file_stream;
-
-      using TeeDevice = boost::iostreams::tee_device<std::ostream, std::ofstream>;
-      using TeeStream = boost::iostreams::stream<TeeDevice>;
-
-      TeeDevice iostream_tee_device;
-      TeeStream iostream_tee_stream;
-
-      /**
-       * Output stream for logging information. Will only output on processor
-       * 0.
-       */
-      ConditionalOStream                  pcout;
-
-      /**
-       * An object that stores a bunch of statistics such as the number of
-       * linear solver iterations, the time corresponding to each time step,
-       * etc, as well as whatever the various postprocessors want to put into
-       * it.
-       *
-       * This variable is written to disk after every time step, by the
-       * Simulator::output_statistics() function.
-       */
-      TableHandler                        statistics;
-
-      /**
-       * The following two variables keep track which parts of the statistics
-       * object have already been written. This is because the TableHandler
-       * class has no way to keep track what it has already written, and so
-       * we can not just append the last row of the table to the output
-       * file. Rather, we keep track how many bytes we already wrote,
-       * and a hash of what they contained, and if these so-many bytes have
-       * not changed between the previous and current write operation, then
-       * we only open the file in 'append' mode to add the new bytes from the
-       * last row. If what we would write now has changed from what we wrote
-       * back then in the first so-many bytes (e.g., because column widths of
-       * the table have changed), then we just replace the previous file by
-       * the current table contents in their entirety.
-       */
-      std::size_t                         statistics_last_write_size;
-      std::size_t                         statistics_last_hash;
-
-      mutable TimerOutput                 computing_timer;
-
-      /**
-       * A timer used to track the current wall time since the
-       * last snapshot (or since the program started).
-       */
-      Timer wall_timer;
-
-      /**
-       * The total wall time that has elapsed up to the last snapshot
-       * that was created.
-       */
-      double total_walltime_until_last_snapshot;
-
-      /**
-       * In output_statistics(), where we output the statistics object above,
-       * we do the actual writing on a separate thread. This variable is the
-       * handle we get for this thread so that we can wait for it to finish,
-       * either if we want to write the statistics object for the next thread,
-       * or if we want to terminate altogether.
-       */
-      std::thread                         output_statistics_thread;
-
-      /**
-       * @}
-       */
-
-      /**
-       * @name Variables that describe the physical setup of the problem
-       * @{
-       */
-      const std::unique_ptr<InitialTopographyModel::Interface<dim>>          initial_topography_model;
-      const std::unique_ptr<GeometryModel::Interface<dim>>                   geometry_model;
-      const IntermediaryConstructorAction                                    post_geometry_model_creation_action;
-      const std::unique_ptr<MaterialModel::Interface<dim>>                   material_model;
-      const std::unique_ptr<GravityModel::Interface<dim>>                    gravity_model;
-      BoundaryTemperature::Manager<dim>                                      boundary_temperature_manager;
-      BoundaryComposition::Manager<dim>                                      boundary_composition_manager;
-      const std::unique_ptr<PrescribedStokesSolution::Interface<dim>>        prescribed_stokes_solution;
-
-      /**
-       * The following two variables are pointers to objects that describe
-       * the initial temperature and composition values. The Simulator
-       * class itself releases these pointers once they are no longer
-       * needed, somewhere during the first time step once it is known
-       * that they are no longer needed. However, plugins can have their
-       * own shared pointers to these objects, and the lifetime of the
-       * objects pointed to is then until the last of these plugins
-       * gets deleted.
-       */
-      std::shared_ptr<InitialTemperature::Manager<dim>>                      initial_temperature_manager;
-      std::shared_ptr<InitialComposition::Manager<dim>>                      initial_composition_manager;
-
-      const std::unique_ptr<AdiabaticConditions::Interface<dim>>             adiabatic_conditions;
-#ifdef ASPECT_WITH_WORLD_BUILDER
-      /**
-       * A pointer to the WorldBuilder object. Like the
-       * `initial_temperature_manager` and
-       * `initial_composition_manager` objects above, the Simulator
-       * object itself releases this pointer at the end of the
-       * initialization process (right after releasing the
-       * two mentioned initial condition objects). If a part of
-       * the plugin system still needs the world builder object
-       * after this point, it needs to keep its own shared pointer
-       * to it.
-       */
-      std::shared_ptr<WorldBuilder::World>                                   world_builder;
-#endif
-      BoundaryVelocity::Manager<dim>                                         boundary_velocity_manager;
-      BoundaryTraction::Manager<dim>                                         boundary_traction_manager;
-      const std::unique_ptr<BoundaryHeatFlux::Interface<dim>>                boundary_heat_flux;
-
-      /**
-       * The world holding the particles
-       */
-      std::vector<std::unique_ptr<Particle::World<dim>>> particle_worlds;
-
-      /**
-       * @}
-       */
-      /**
-       * @name Variables that describe the time discretization
-       * @{
-       */
-      double                                                    time;
-      double                                                    time_step;
-      double                                                    old_time_step;
-      unsigned int                                              timestep_number;
-      unsigned int                                              pre_refinement_step;
-      unsigned int                                              nonlinear_iteration;
-      /**
-       * @}
-       */
-
-      /**
-       * @name Variables related to simulation time stepping
-       * @{
-       */
-      TimeStepping::Manager<dim>                                time_stepping_manager;
-      /**
-       * @}
-       */
-
-      /**
-       * @name Variables for doing lateral averaging
-       * @{
-       */
-      LateralAveraging<dim>                                     lateral_averaging;
-      /**
-       * @}
-       */
-
-      /**
-       * @name Variables that describe the spatial discretization
-       * @{
-       */
-      parallel::distributed::Triangulation<dim>                 triangulation;
-      double                                                    global_Omega_diameter;
-      double                                                    global_volume;
-
-      MeshRefinement::Manager<dim>                              mesh_refinement_manager;
-      HeatingModel::Manager<dim>                                heating_model_manager;
-
-      /**
-       * Pointer to the Mapping object used by the finite elements when
-       * going from the reference cell to the cell in the computational
-       * domain. We use a pointer since different mapping objects may
-       * be useful. In particular, when the mesh is deformable we use
-       * a MappingQ1Eulerian object to describe the mesh deformation,
-       * swapping it in for the original MappingQ or MappingCartesian object.
-       */
-      std::unique_ptr<Mapping<dim>>                            mapping;
-
-      const FESystem<dim>                                       finite_element;
-
-      DoFHandler<dim>                                           dof_handler;
-
-      Postprocess::Manager<dim>                                 postprocess_manager;
-
-      /**
-       * Constraint objects. The first of these describes all constraints that
-       * are not time dependent (e.g., hanging nodes, no-normal-flux
-       * constraints), whereas the second one is initialized at the top of
-       * every time step by copying from the first and then adding to it
-       * constraints that are time dependent (e.g., time dependent velocity or
-       * temperature boundary conditions).
-       *
-       * 'constraints' is computed in setup_dofs(), 'current_constraints' is
-       * done in compute_current_constraints().
-       */
-      AffineConstraints<double>                                          constraints;
-      AffineConstraints<double>                                          current_constraints;
-
-      /**
-       * A place to store the latest correction computed by normalize_pressure().
-       * We store this so we can undo the correction in denormalize_pressure().
-       */
-      double                                                    last_pressure_normalization_adjustment;
-
-      /**
-       * Scaling factor for the pressure as explained in the
-       * Kronbichler/Heister/Bangerth paper to ensure that the linear system
-       * that results from the Stokes equations is well conditioned.
-       */
-      double                                                    pressure_scaling;
-
-      /**
-       * A variable that determines whether we need to do the correction of
-       * the Stokes right hand side vector to ensure that the average
-       * divergence is zero. This is necessary for compressible models, but
-       * only if there are no in/outflow boundaries.
-       */
-      bool                           do_pressure_rhs_compatibility_modification;
-
-      /**
-       * @}
-       */
-
-
-      /**
-       * @name Variables that describe the linear systems and solution vectors
-       * @{
-       */
-
-      /**
-       * An object that contains the entries of the system matrix. It
-       * has a size equal to the total number of degrees of freedom,
-       * but since we typically do not solve for all variables at
-       * once, the content of the matrix at any given time is only
-       * appropriate for the part of the system we are currently
-       * solving.
-       */
-      LinearAlgebra::BlockSparseMatrix                          system_matrix;
-
-      /**
-       * This vector is used for the weighted BFBT preconditioner. It
-       * stores the inverted lumped velocity mass matrix.
-      */
-      LinearAlgebra::BlockVector                                inverse_lumped_mass_matrix;
-
-      /**
-       * An object that contains the entries of preconditioner
-       * matrices for the system matrix. It has a size equal to the
-       * total number of degrees of freedom, but is only used for the
-       * Stokes system (that's the only part of the system where we
-       * use a matrix for preconditioning that is different from the
-       * matrix we solve). Consequently, the blocks in rows and
-       * columns corresponding to temperature or compositional fields
-       * are left empty when building the sparsity pattern of this
-       * matrix in the Simulator::setup_system_preconditioner()
-       * function.
-       */
-      LinearAlgebra::BlockSparseMatrix                          system_preconditioner_matrix;
-
-      LinearAlgebra::BlockVector                                solution;
-      LinearAlgebra::BlockVector                                old_solution;
-      LinearAlgebra::BlockVector                                old_old_solution;
-      LinearAlgebra::BlockVector                                system_rhs;
-
-      LinearAlgebra::BlockVector                                current_linearization_point;
-
-      // only used if is_compressible()
-      LinearAlgebra::BlockVector                                pressure_shape_function_integrals;
-
-      // only used if operator split is enabled
-      LinearAlgebra::BlockVector                                operator_split_reaction_vector;
-
-
-
-      std::unique_ptr<LinearAlgebra::PreconditionAMG>           Amg_preconditioner;
-      std::unique_ptr<LinearAlgebra::PreconditionBase>          Mp_preconditioner;
-
-      bool                                                      rebuild_sparsity_and_matrices;
-      bool                                                      rebuild_stokes_matrix;
-      bool                                                      assemble_newton_stokes_matrix;
-      bool                                                      assemble_newton_stokes_system;
-      bool                                                      rebuild_stokes_preconditioner;
-
-      /**
-       * @}
-       */
-
-    private:
-
-      /**
-       * Unique pointer for an instance of the MeshDeformationHandler. this way,
-       * if we do not need the machinery for doing mesh deformation stuff, we do
-       * not even allocate it.
-       */
-      std::unique_ptr<MeshDeformation::MeshDeformationHandler<dim>> mesh_deformation;
-
-      /**
-       * Unique pointer for the matrix-free Stokes solver
-       */
-      std::unique_ptr<StokesMatrixFreeHandler<dim>> stokes_matrix_free;
-
-      friend class boost::serialization::access;
-      friend class SimulatorAccess<dim>;
-      friend class MeshDeformation::MeshDeformationHandler<dim>;   // MeshDeformationHandler needs access to the internals of the Simulator
-      friend class VolumeOfFluidHandler<dim>; // VolumeOfFluidHandler needs access to the internals of the Simulator
-      friend class StokesMatrixFreeHandler<dim>;
-      template <int dimension, int velocity_degree>
-      friend class StokesMatrixFreeHandlerImplementation;
-      friend struct Parameters<dim>;
-  };
-}
-
-
-#endif
diff --git a/include/aspect/simulator/assemblers/advection.h.bak b/include/aspect/simulator/assemblers/advection.h.bak
deleted file mode 100644
index cfc5a5edd10..00000000000
--- a/include/aspect/simulator/assemblers/advection.h.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_simulator_assemblers_advection_h
-#define _aspect_simulator_assemblers_advection_h
-
-
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    /**
-     * This class assembles the terms for the matrix and right-hand-side of the advection
-     * equation for the current cell.
-     */
-    template <int dim>
-    class AdvectionSystem : public Assemblers::Interface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-
-        std::vector<double>
-        compute_residual(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base) const override;
-    };
-
-    template <int dim>
-    class DarcySystem : public Assemblers::Interface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-
-        std::vector<double>
-        compute_residual(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base) const override;
-
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-    };
-
-    /**
-     * This class assembles the terms for the matrix and right-hand-side equation for the
-     * current cell in case we only want to solve the diffusion equation.
-     */
-    template <int dim>
-    class DiffusionSystem : public Assemblers::Interface<dim>, public Assemblers::AdvectionStabilizationInterface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-
-        std::vector<double>
-        compute_residual(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base) const override;
-
-        virtual
-        std::vector<double>
-        advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
-
-        virtual
-        std::vector<double>
-        diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const override;
-    };
-
-    /**
-     * This class assembles the face terms for the right-hand-side of the
-     * advection equation for a face at the boundary of the domain where
-     * Neumann boundary conditions are used (which allow to prescribe a heat flux).
-     */
-    template <int dim>
-    class AdvectionSystemBoundaryHeatFlux : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the face terms for the matrix and right-hand-side of
-     * the discontinuous advection equation for a face at the boundary of the domain.
-     */
-    template <int dim>
-    class AdvectionSystemBoundaryFace : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the face terms for the matrix and right-hand-side of
-     * the discontinuous advection equation for a face in the interior of the domain.
-     */
-    template <int dim>
-    class AdvectionSystemInteriorFace : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/simulator/assemblers/interface.h.bak b/include/aspect/simulator/assemblers/interface.h.bak
deleted file mode 100644
index fa918170c0e..00000000000
--- a/include/aspect/simulator/assemblers/interface.h.bak
+++ /dev/null
@@ -1,818 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_simulator_assemblers_interface_h
-#define _aspect_simulator_assemblers_interface_h
-
-#include <aspect/global.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/material_model/interface.h>
-
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim>
-  class Simulator;
-
-  struct AdvectionField;
-
-  /**
-   * A namespace that is used for internal scratch objects, i.e. objects that define
-   * the inputs and outputs for the individual assembler objects. The different classes
-   * are provided for the different systems of equations, and the inputs are filled
-   * by the <code>local_assemble_...</code> functions in <code>assembly.cc</code>,
-   * before being handed over to the assemblers.
-   */
-  namespace internal
-  {
-    namespace Assembly
-    {
-      namespace Scratch
-      {
-        /**
-         * Scratch objects are used to store information about a cell that is
-         * necessary for assembling matrix and right hand side terms for this
-         * cell. The ScratchBase class acts as a empty base class for
-         * individual scratch objects for the different equations.
-         */
-        template <int dim>
-        struct ScratchBase
-        {
-          ScratchBase()
-            :
-            cell(),
-            face_number(numbers::invalid_unsigned_int)
-          {}
-
-          ScratchBase(const ScratchBase &scratch)
-            :
-            cell(scratch.cell),
-            face_number(scratch.face_number)
-          {}
-
-          virtual ~ScratchBase ()  = default;
-
-          /**
-           * Cell object on which we currently operate.
-           */
-          typename DoFHandler<dim>::active_cell_iterator cell;
-
-          /**
-           * The number of the face object with respect to the current
-           * cell on which we operate. If we currently
-           * operate on a cell, this member is set to
-           * numbers::invalid_unsigned_int.
-           */
-          unsigned face_number;
-        };
-
-        /**
-         * A scratch object to store all necessary information to assemble
-         * the Stokes preconditioner terms.
-         */
-        template <int dim>
-        struct StokesPreconditioner: public ScratchBase<dim>
-        {
-          StokesPreconditioner (const FiniteElement<dim> &finite_element,
-                                const Quadrature<dim>    &quadrature,
-                                const Mapping<dim>       &mapping,
-                                const UpdateFlags         update_flags,
-                                const unsigned int        n_compositional_fields,
-                                const unsigned int        stokes_dofs_per_cell,
-                                const bool                add_compaction_pressure,
-                                const bool                rebuild_matrix,
-                                const bool                use_bfbt);
-          StokesPreconditioner (const StokesPreconditioner &scratch);
-
-          ~StokesPreconditioner () override;
-
-          FEValues<dim> finite_element_values;
-
-          void reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref);
-
-          std::vector<types::global_dof_index> local_dof_indices;
-          std::vector<unsigned int>            dof_component_indices;
-          std::vector<SymmetricTensor<2,dim>> grads_phi_u;
-          std::vector<double>                  div_phi_u;
-          std::vector<double>                  phi_p;
-          std::vector<Tensor<1,dim>>           phi_u;
-          std::vector<double>                  phi_p_c;
-          std::vector<Tensor<1,dim>>          grad_phi_p;
-
-          /**
-           * Material model inputs and outputs computed at the current
-           * linearization point.
-           */
-          MaterialModel::MaterialModelInputs<dim> material_model_inputs;
-          MaterialModel::MaterialModelOutputs<dim> material_model_outputs;
-
-          /**
-           * Whether the Stokes matrix should be rebuild during this
-           * assembly. If the matrix does not change, assembling the right
-           * hand side is sufficient.
-           */
-          const bool rebuild_stokes_matrix;
-        };
-
-
-
-        /**
-         * A scratch object to store all necessary information to assemble
-         * the terms in the Stokes equations.
-         * We derive the StokesSystem scratch class from the
-         * StokesPreconditioner class, because all the objects that
-         * are necessary for the assembly of the preconditioner are also
-         * needed for the actual system matrix and right hand side, plus some
-         * extra data that we need for the time stepping and traction boundaries
-         * on the right hand side.
-         */
-        template <int dim>
-        struct StokesSystem : public StokesPreconditioner<dim>
-        {
-          StokesSystem (const FiniteElement<dim> &finite_element,
-                        const Mapping<dim>       &mapping,
-                        const Quadrature<dim>    &quadrature,
-                        const Quadrature<dim-1>  &face_quadrature,
-                        const UpdateFlags         update_flags,
-                        const UpdateFlags         face_update_flags,
-                        const unsigned int        n_compositional_fields,
-                        const unsigned int        stokes_dofs_per_cell,
-                        const bool                add_compaction_pressure,
-                        const bool                use_reference_density_profile,
-                        const bool                rebuild_stokes_matrix,
-                        const bool                rebuild_newton_stokes_matrix,
-                        const bool                use_bfbt);
-
-          StokesSystem (const StokesSystem<dim> &scratch);
-
-          FEFaceValues<dim> face_finite_element_values;
-
-          using StokesPreconditioner<dim>::reinit;
-
-          void reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref,
-                       const unsigned face_number_ref);
-
-          std::vector<Tensor<1,dim>>          phi_u;
-          std::vector<Tensor<1,dim>>          velocity_values;
-          std::vector<double>                  velocity_divergence;
-          std::vector<Tensor<1,dim>>          temperature_gradients;
-
-          /**
-           * Material model inputs and outputs computed at the current
-           * linearization point.
-           *
-           * In contrast to the variables above, the following two
-           * variables are used in the assembly at quadrature points
-           * on faces, not on cells.
-           */
-          MaterialModel::MaterialModelInputs<dim> face_material_model_inputs;
-          MaterialModel::MaterialModelOutputs<dim> face_material_model_outputs;
-
-          /**
-           * In some approximations of the Stokes equations the density used
-           * for the mass conservation (/continuity) equation is some form
-           * of reference density, while the density used for calculating
-           * the buoyancy force is the full density. In case such a formulation
-           * is used the reference density (and its derivative in depth
-           * direction) is queried from the adiabatic conditions plugin
-           * and is stored in these variables.
-           */
-          std::vector<double> reference_densities;
-          std::vector<double> reference_densities_depth_derivative;
-
-          /**
-           * Whether the Newton solver Stokes matrix should be rebuild during
-           * this assembly. If the matrix does not change, assembling the right
-           * hand side is sufficient.
-           */
-          const bool rebuild_newton_stokes_matrix;
-        };
-
-
-
-        /**
-         * A scratch object to store all necessary information to assemble
-         * the terms in the advection equations.
-         */
-        template <int dim>
-        struct AdvectionSystem: public ScratchBase<dim>
-        {
-          AdvectionSystem (const FiniteElement<dim> &finite_element,
-                           const FiniteElement<dim> &advection_element,
-                           const Mapping<dim>       &mapping,
-                           const Quadrature<dim>    &quadrature,
-                           const Quadrature<dim-1>  &face_quadrature,
-                           const UpdateFlags         update_flags,
-                           const UpdateFlags         face_update_flags,
-                           const unsigned int        n_compositional_fields,
-                           const typename Simulator<dim>::AdvectionField     &field);
-          AdvectionSystem (const AdvectionSystem &scratch);
-
-          FEValues<dim> finite_element_values;
-
-          void reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref);
-
-          std::unique_ptr<FEFaceValues<dim>>    face_finite_element_values;
-          std::unique_ptr<FEFaceValues<dim>>    neighbor_face_finite_element_values;
-          std::unique_ptr<FESubfaceValues<dim>> subface_finite_element_values;
-
-          std::vector<types::global_dof_index>   local_dof_indices;
-
-          /**
-           * Variables describing the values and gradients of the
-           * shape functions at the quadrature points, as they are
-           * used in the advection assembly function. note that the sizes
-           * of these arrays are equal to the number of shape functions
-           * corresponding to the currently advected field (and not all of the
-           * existing fields), and that they are also correspondingly indexed.
-           */
-          std::vector<double>         phi_field;
-          std::vector<Tensor<1,dim>> grad_phi_field;
-          std::vector<double>         laplacian_phi_field;
-          std::vector<double>         face_phi_field;
-          std::vector<Tensor<1,dim>> face_grad_phi_field;
-          std::vector<double>         neighbor_face_phi_field;
-          std::vector<Tensor<1,dim>> neighbor_face_grad_phi_field;
-
-          std::vector<Tensor<1,dim>> old_velocity_values;
-          std::vector<Tensor<1,dim>> old_old_velocity_values;
-
-          std::vector<double>         old_pressure;
-          std::vector<double>         old_old_pressure;
-          std::vector<Tensor<1,dim>> old_pressure_gradients;
-          std::vector<Tensor<1,dim>> old_old_pressure_gradients;
-
-          std::vector<SymmetricTensor<2,dim>> old_strain_rates;
-          std::vector<SymmetricTensor<2,dim>> old_old_strain_rates;
-
-          std::vector<double>         old_temperature_values;
-          std::vector<double>         old_old_temperature_values;
-
-          std::vector<double>         old_field_values;
-          std::vector<double>         old_old_field_values;
-          std::vector<Tensor<1,dim>> old_field_grads;
-          std::vector<Tensor<1,dim>> old_old_field_grads;
-          std::vector<double>         old_field_laplacians;
-          std::vector<double>         old_old_field_laplacians;
-
-          std::vector<std::vector<double>> old_composition_values;
-          std::vector<std::vector<double>> old_old_composition_values;
-
-          std::vector<double>         current_temperature_values;
-          std::vector<Tensor<1,dim>> current_velocity_values;
-          std::vector<Tensor<1,dim>> face_current_velocity_values;
-          std::vector<Tensor<1,dim>> mesh_velocity_values;
-          std::vector<Tensor<1,dim>> face_mesh_velocity_values;
-
-          std::vector<SymmetricTensor<2,dim>> current_strain_rates;
-          std::vector<std::vector<double>> current_composition_values;
-          std::vector<double>         current_velocity_divergences;
-
-          /**
-           * Material model inputs and outputs computed at the current
-           * linearization point.
-           */
-          MaterialModel::MaterialModelInputs<dim> material_model_inputs;
-          MaterialModel::MaterialModelOutputs<dim> material_model_outputs;
-
-          MaterialModel::MaterialModelInputs<dim> face_material_model_inputs;
-          MaterialModel::MaterialModelOutputs<dim> face_material_model_outputs;
-
-          MaterialModel::MaterialModelInputs<dim> neighbor_face_material_model_inputs;
-          MaterialModel::MaterialModelOutputs<dim> neighbor_face_material_model_outputs;
-
-          /**
-           * Heating model outputs computed at the quadrature points of the
-           * current cell at the time of the current linearization point.
-           * As explained in the class documentation of
-           * HeatingModel::HeatingModelOutputs each term contains the sum of all
-           * enabled heating mechanism contributions.
-           */
-          HeatingModel::HeatingModelOutputs heating_model_outputs;
-          HeatingModel::HeatingModelOutputs face_heating_model_outputs;
-          HeatingModel::HeatingModelOutputs neighbor_face_heating_model_outputs;
-
-          /**
-           * This pointer contains a struct that can be used to identify the
-           * advection field that is currently assembled. It can be used to
-           * determine between temperature and the available compositional
-           * fields. See the documentation of the AdvectionField class for
-           * more details.
-           */
-          const typename Simulator<dim>::AdvectionField *advection_field;
-
-          /**
-           * The amount of entropy viscosity that should be applied to the
-           * current cell to stabilize the solution of the advection system.
-           */
-          double artificial_viscosity;
-        };
-      }
-
-
-
-      /**
-       * The CopyData arrays are similar to the Scratch arrays except they are
-       * meant as containers for the output of assembler objects. They provide a
-       * constructor and some data objects for local matrix, local vectors and
-       * the relation between local and global degrees of freedom (a.k.a.
-       * <code>local_dof_indices</code>). After all assemblers are finished
-       * the objects contain the local contributions of a particular cell to
-       * the global matrix and right hand side. This copy data object is then
-       * handed over to one of the <code>copy_local_to_global...</code>
-       * functions in assembly.cc that copy their content to the global matrix
-       * and right hand side vector.
-       */
-      namespace CopyData
-      {
-        /**
-         * The base class is empty and only allows us to hand over pointers
-         * or references of a generic type and later cast them to their actual
-         * derived class.
-         */
-        template <int dim>
-        struct CopyDataBase
-        {
-          virtual ~CopyDataBase () = default;
-        };
-
-        /**
-         * The Stokes preconditioner object only requires the bare minimum of
-         * copy data objects. Matrix contributions and degrees of freedom this
-         * cell corresponds to.
-         */
-        template <int dim>
-        struct StokesPreconditioner: public CopyDataBase<dim>
-        {
-          StokesPreconditioner (const unsigned int stokes_dofs_per_cell);
-
-          StokesPreconditioner (const StokesPreconditioner &data);
-
-          ~StokesPreconditioner () override = default;
-          StokesPreconditioner<dim> &operator= (const StokesPreconditioner<dim> &data) = default;
-
-          FullMatrix<double> local_matrix;
-          Vector<double> local_inverse_lumped_mass_matrix;
-          std::vector<types::global_dof_index> local_dof_indices;
-
-          /**
-           * Extract the values listed in @p all_dof_indices only if
-           * it corresponds to the Stokes component and copy it to the variable
-           * local_dof_indices declared above in the same class as this function
-          */
-          void extract_stokes_dof_indices(const std::vector<types::global_dof_index> &all_dof_indices,
-                                          const Introspection<dim>                   &introspection,
-                                          const FiniteElement<dim>                   &finite_element);
-        };
-
-        /**
-         * Similar to the scratch object the Stokes system requires all
-         * data from the Stokes preconditioner copy data class, plus some
-         * extras like the right hand side contribution.
-         */
-        template <int dim>
-        struct StokesSystem : public StokesPreconditioner<dim>
-        {
-          StokesSystem (const unsigned int        stokes_dofs_per_cell,
-                        const bool                do_pressure_rhs_compatibility_modification);
-          StokesSystem (const StokesSystem<dim> &data);
-
-          ~StokesSystem () override = default;
-          StokesSystem<dim> &operator= (const StokesSystem<dim> &data) = default;
-
-          Vector<double> local_rhs;
-          Vector<double> local_pressure_shape_function_integrals;
-        };
-
-        /**
-         * Additionally to the Stokes system the Advection system copy data
-         * object also needs to keep track of contributions across faces
-         * (mostly for discontinuous elements that contain DG terms).
-         */
-        template <int dim>
-        struct AdvectionSystem: public CopyDataBase<dim>
-        {
-          /**
-           * Constructor.
-           *
-           * @param finite_element The element that describes the field for
-           *    which we are trying to assemble a linear system. <b>Not</b>
-           *    the global finite element.
-           * @param field_is_discontinuous If true, the field is a DG element.
-           */
-          AdvectionSystem (const FiniteElement<dim> &finite_element,
-                           const bool                field_is_discontinuous);
-
-          /**
-           * Local contributions to the global matrix
-           * that correspond only to the variables listed in local_dof_indices
-           */
-          FullMatrix<double>          local_matrix;
-
-          /**
-           * Local contributions to the global matrix from the face terms in the
-           * discontinuous Galerkin method. These arrays are of a length sufficient
-           * to hold one matrix for each possible face or subface of the cell.
-           * The discontinuous Galerkin bilinear form contains terms arising from
-           * internal (to the cell) values and external (to the cell) values.
-           * `_int_ext` and `_ext_int` hold the terms arising from the pairing
-           * between a cell and its neighbor, while `_ext_ext` is the pairing
-           * of the neighbor's dofs with themselves. In the continuous
-           * Galerkin case, these are unused, and set to size zero.
-           */
-          std::vector<FullMatrix<double>>         local_matrices_int_ext;
-          std::vector<FullMatrix<double>>         local_matrices_ext_int;
-          std::vector<FullMatrix<double>>         local_matrices_ext_ext;
-
-          /**
-           * Local contributions to the right hand side
-           * that correspond only to the variables listed in local_dof_indices
-           */
-          Vector<double>              local_rhs;
-
-          /**
-           * Denotes which face matrices have actually been assembled in the DG field
-           * assembly. Entries for matrices not used (for example, those corresponding
-           * to non-existent subfaces; or faces being assembled by the neighboring cell)
-           * are set to false.
-           */
-          std::vector<bool>               assembled_matrices;
-
-          /**
-           * Indices of those degrees of freedom that actually correspond
-           * to the temperature or compositional field. since this structure
-           * is used to represent just contributions to the advection
-           * systems, there will be no contributions to other parts of the
-           * system and consequently, we do not need to list here indices
-           * that correspond to velocity or pressure degrees (or, in fact
-           * any other variable outside the block we are currently considering)
-           */
-          std::vector<types::global_dof_index>   local_dof_indices;
-
-          /**
-           * Indices of the degrees of freedom corresponding to the temperature
-           * or composition field on all possible neighboring cells. This is used
-           * in the discontinuous Galerkin method. The outer array has a
-           * length sufficient to hold one element for each possible face
-           * and sub-face of the current cell. The object is not used
-           * and has size zero if in the continuous Galerkin case.
-           */
-          std::vector<std::vector<types::global_dof_index>>   neighbor_dof_indices;
-        };
-      }
-    }
-  }
-
-  /**
-   * A namespace for the definition of assemblers for the various terms in the
-   * linear systems ASPECT solves.
-   */
-  namespace Assemblers
-  {
-
-    /**
-     * For a reference cell (which is typically obtained by asking the finite
-     * element to be used), determine how many interface matrices are needed.
-     * Since interface matrices are needed for as many neighbors as each
-     * cell can have, this is the number of faces for the given reference cell
-     * times the number of children each of these faces can have. This
-     * accommodates the fact that the neighbors of a cell can all be refined,
-     * though they can only be refined once.
-     */
-    unsigned int
-    n_interface_matrices (const ReferenceCell &reference_cell);
-
-    /**
-     * For a given reference cell, and a given face we are currently
-     * assembling on, return which element of an array of size
-     * `n_interface_matrices(reference_cell)` to use.
-     */
-    unsigned int
-    nth_interface_matrix (const ReferenceCell &reference_cell,
-                          const unsigned int face);
-
-    /**
-     * For a given reference cell, and a given face and sub-face we are
-     * currently assembling on, return which element of an array of size
-     * `n_interface_matrices(reference_cell)` to use.
-     */
-    unsigned int
-    nth_interface_matrix (const ReferenceCell &reference_cell,
-                          const unsigned int face,
-                          const unsigned int sub_face);
-
-    /**
-     * A base class for objects that implement assembly
-     * operations.
-     *
-     * The point of this class is primarily so that we can store
-     * pointers to such objects in a list. The objects are created
-     * in Simulator::set_assemblers() and destroyed in the destructor of
-     * the Simulator object. Derived classes of this base class usually
-     * handle groups of terms in the equations that are
-     * logically connected (such as all terms in the Stokes equations that
-     * appear independent on the selected compressibility formulation). This
-     * way selecting a certain set of assembler objects effectively controls
-     * which equation is solved.
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Execute this assembler object. This function performs the primary work
-         * of an assembler. More precisely, it uses information for the current
-         * cell that is stored in @p scratch (like the material properties on
-         * this cell and the position of quadrature points) and computes the
-         * matrix and right hand side contributions for a set of terms for
-         * the given cell. These contributions are stored in @p data. Note, that
-         * the data in @p scratch and @p data is shared between all active
-         * assemblers so that each assembler should only add contributions to
-         * @p data, not overwrite entries in the matrix. After all assemblers
-         * have finished, the final content of @p data is distributed into the
-         * global matrix and right hand side vector.
-         */
-        virtual
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim> &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const = 0;
-
-        /**
-         * This function gets called if a MaterialModelOutputs is created
-         * and allows the assembler to attach AdditionalOutputs. The
-         * function might be called more than once for a
-         * MaterialModelOutput, so it is recommended to check if
-         * get_additional_output() returns an instance before adding a new
-         * one to the additional_outputs vector. By default this function does
-         * not create additional outputs.
-         *
-         * Material models, through functions derived from
-         * MaterialModel::Interface::evaluate(), put their computed material
-         * parameters into a structure of type MaterialModel::MaterialModelOutputs.
-         * By default, material models will compute those parameters that
-         * correspond to the member variables of that structure. However,
-         * there are situations where parts of the simulator need additional
-         * pieces of information; a typical example would be the use of a
-         * Newton scheme that also requires the computation of <i>derivatives</i>
-         * of material parameters with respect to pressure, temperature, and
-         * possibly other variables.
-         *
-         * The computation of such additional information is controlled by
-         * the presence of a collection of pointers in
-         * MaterialModel::MaterialModelOutputs that point to additional
-         * objects. Whether or not one needs these additional objects depends
-         * on what assemblers are selected, or what postprocessing one
-         * wants to compute. For the purpose of assembly, the current
-         * function creates the additional objects (such as the one that stores
-         * derivatives) and adds pointers to them to the collection, based on
-         * what this assembler class requires. This function is always called
-         * before the material model is evaluated and execute() is called.
-         * This ensures the additional material model output is available when
-         * execute() is called.
-         */
-        virtual
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &) const;
-
-        /**
-         * A required function for objects that implement the assembly of terms
-         * in an equation that requires the computation of residuals
-         * (in particular the advection equation in ASPECT).
-         * Just like the assemblers itself, the residual
-         * that we use to compute the necessary entropy viscosity depend on the
-         * equation (i.e. which terms are actually included in the
-         * equation). Thus different objects compute different residuals (i.e.
-         * the residual for a melt advection equation looks different from the
-         * residual for a passive compositional field).
-         * For assemblers for the Stokes system, an implementation of this
-         * function is not necessary.
-         */
-        virtual
-        std::vector<double>
-        compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &) const;
-    };
-
-
-
-    /**
-     * A base class for objects that implement assembly
-     * operations for advection-diffusion problems.
-     *
-     * This class implements functions that provide information
-     * for stabilization mechanisms.
-     */
-    template <int dim>
-    class AdvectionStabilizationInterface
-    {
-      public:
-        virtual ~AdvectionStabilizationInterface ();
-
-        /**
-         * This function returns a representative prefactor for the advection
-         * term of the equation for each quadrature point of the current cell.
-         * In the non-dimensional case this is simply 1.0, but for other
-         * quantities like temperature it is computed using physical units
-         * (like density and specific heat capacity).
-         * This information is useful for algorithms that depend on the
-         * magnitude of individual terms, like stabilization methods.
-         */
-        virtual
-        std::vector<double>
-        advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const;
-
-        /**
-         * This function returns a representative conductivity for the
-         * diffusion part of the equation for each quadrature point of the
-         * current cell. For the pure advection case this factor is 0.0, but
-         * for other quantities like temperature it is
-         * computed using physical units (like thermal conductivity).  This
-         * information is useful for algorithms depending on the magnitude of
-         * individual terms, like stabilization methods.
-         */
-        virtual
-        std::vector<double>
-        diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const;
-    };
-
-
-
-    /**
-     * A class that owns member variables representing
-     * all assemblers that need to be called when
-     * assembling right hand side vectors, matrices, or complete linear
-     * systems. We use this approach in order to support the following
-     * cases:
-     * - Assembling different formulations: When assembling either the
-     *   full equations or only the Boussinesq approximation (to give just
-     *   two examples), one needs different terms. This could be achieved
-     *   using a large number of <code>switch</code> or <code>if</code>
-     *   statements in the code, or one could encapsulate each equation
-     *   or approximation into a collection of assemblers for this particular
-     *   purpose. The approach chosen here in essence allows the
-     *   implementation of each set of equations in its own scope, and we
-     *   then just need to store a pointer to the object that
-     *   assembles the Stokes system (for example) for the selected
-     *   approximation. The pointer to this function is stored in the
-     *   appropriate member variable of this class.
-     * - Sometimes, we want to assemble a number of terms that build on
-     *   each other. An example is the addition of free boundary terms
-     *   to the Stokes matrix. Rather than having to "know" in one
-     *   place about all of the terms that need to be assembled,
-     *   we simply add the function that computes these terms as
-     *   another object to the appropriate set of assemblers declared
-     *   in this class.
-     */
-    template <int dim>
-    class Manager
-    {
-      public:
-
-        /**
-         * Reset the state of the manager and remove all Assemblers.
-         */
-        void reset ();
-
-        /**
-         * A vector of pointers containing all assemblers for the Stokes preconditioner.
-         * These assemblers are called once per cell.
-         */
-        std::vector<std::unique_ptr<Assemblers::Interface<dim>>> stokes_preconditioner;
-
-        /**
-         * A vector of pointers containing all assemblers that compute
-         * cell contributions for the Stokes system.
-         * These assemblers are called once per cell.
-         */
-        std::vector<std::unique_ptr<Assemblers::Interface<dim>>> stokes_system;
-
-        /**
-         * A vector of pointers containing all assemblers that compute face
-         * contributions for the Stokes system. These assemblers are called
-         * once per face at a boundary with the properly initialized inputs,
-         * therefore they allow terms that only exist on boundary faces (e.g.
-         * traction boundary conditions).
-         */
-        std::vector<std::unique_ptr<Assemblers::Interface<dim>>> stokes_system_on_boundary_face;
-
-        /**
-         * A vector of vectors of pointers containing a list of all assemblers
-         * for each individual advection system.
-         * These assemblers are called once per cell.
-         */
-        std::vector<std::vector<std::unique_ptr<Assemblers::Interface<dim>>>> advection_system;
-
-        /**
-         * A vector of vectors of pointers containing a list of all assemblers
-         * for the individual advection systems that compute face contributions
-         * at boundaries. These assemblers are called once per boundary face with
-         * the properly initialized inputs, therefore they allow terms that only
-         * exist on boundary faces (e.g. flux boundary conditions).
-         */
-        std::vector<std::vector<std::unique_ptr<Assemblers::Interface<dim>>>> advection_system_on_boundary_face;
-
-        /**
-         * A vector of vectors of pointers containing a list of all assemblers
-         * for the individual advection systems that compute face contributions
-         * on faces between cells. These assemblers are called once per interior
-         * face with the properly initialized inputs, therefore they allow terms
-         * that only exist on interior faces (e.g. DG penalty terms).
-         */
-        std::vector<std::vector<std::unique_ptr<Assemblers::Interface<dim>>>> advection_system_on_interior_face;
-
-        /**
-         * A structure that describes what information an assembler function
-         * (listed as one of the assembler objects above) may need to operate.
-         *
-         * There are a number of pieces of information that are always
-         * assumed to be needed. For example, the Stokes and advection
-         * assemblers will always need to have access to the material
-         * model outputs. But the Stokes assembler may or may not need
-         * access to material model outputs for quadrature points on faces.
-         *
-         * These properties are all preset in a conservative way
-         * (i.e., disabled) in the constructor of this class, but can
-         * be enabled in Simulator::set_assemblers() when adding
-         * individual assemblers. Functions such as
-         * Simulator::local_assemble_stokes_preconditioner(),
-         * Simulator::local_assemble_stokes_system() will then query
-         * these flags to determine whether something has to be
-         * initialized for at least one of the assemblers they call.
-         */
-        struct Properties
-        {
-          /**
-           * Constructor. Disable all properties as described in the
-           * class documentation.
-           */
-          Properties ();
-
-          /**
-           * Whether or not at least one of the active assembler objects for
-           * a certain equation requires the initialization and re-computation
-           * of a MaterialModelOutputs object for each face. This
-           * property is only relevant to assemblers that operate on
-           * faces.
-           */
-          bool need_face_material_model_data;
-
-          /**
-           * Whether or not at least one of the active assembler objects for
-           * a certain equation requires the evaluation of the FEFaceValues
-           * object. This is different from need_face_material_model_data,
-           * because an assembler might assemble terms that do not require
-           * material model outputs.
-           */
-          bool need_face_finite_element_evaluation;
-
-          /**
-           * Whether or not at least one of the active assembler objects for
-           * a certain equation requires the computation of the viscosity.
-           */
-          bool need_viscosity;
-
-          /**
-           * A list of FEValues UpdateFlags that are necessary for
-           * a given operation. Assembler objects may add to this list
-           * as necessary; it will be initialized with a set of
-           * "default" flags that will always be set.
-           */
-          UpdateFlags needed_update_flags;
-        };
-
-        /**
-         * Lists of properties for the various equations we want to assemble.
-         * These property lists are set in Simulator::set_assemblers()
-         * where we add individual functions to the vectors of assembler
-         * objects above.
-         */
-        Properties stokes_preconditioner_assembler_properties;
-        Properties stokes_system_assembler_properties;
-        Properties stokes_system_assembler_on_boundary_face_properties;
-        std::vector<Properties> advection_system_assembler_properties;
-        std::vector<Properties> advection_system_assembler_on_face_properties;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/simulator/assemblers/stokes.h.bak b/include/aspect/simulator/assemblers/stokes.h.bak
deleted file mode 100644
index 6ffe27fd8f3..00000000000
--- a/include/aspect/simulator/assemblers/stokes.h.bak
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_simulator_assemblers_stokes_h
-#define _aspect_simulator_assemblers_stokes_h
-
-
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    /**
-     * A class containing the functions to assemble the Stokes preconditioner.
-     */
-    template <int dim>
-    class StokesPreconditioner : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * A class containing the functions to assemble the compressible adjustment
-     * to the Stokes preconditioner.
-     */
-    template <int dim>
-    class StokesCompressiblePreconditioner : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the terms for the matrix and right-hand-side of the incompressible
-     * Stokes equation for the current cell.
-     */
-    template <int dim>
-    class StokesIncompressibleTerms : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-
-        /**
-         * Create AdditionalMaterialOutputsStokesRHS if we need to do so.
-         */
-        void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const override;
-    };
-
-    /**
-     * This class assembles the term that arises in the viscosity term of Stokes matrix for
-     * compressible models, because the divergence of the velocity is not longer zero.
-     */
-    template <int dim>
-    class StokesCompressibleStrainRateViscosityTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the compressibility term of the Stokes equation
-     * that is caused by the compressibility in the mass conservation equation.
-     * It uses an approximation that involves the reference density profile, and
-     * includes this term explicitly in the right-hand side vector to preserve
-     * the symmetry of the matrix.
-     * This class approximates this term as
-     * $- \nabla \cdot \mathbf{u} = \frac{1}{\rho^{\ast}} \frac{\partial rho}{\partial z} \frac{\mathbf{g}}{||\mathbf{g}||} \cdot \mathbf{u}$
-     */
-    template <int dim>
-    class StokesReferenceDensityCompressibilityTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the compressibility term of the Stokes equation
-     * that is caused by the compressibility in the mass conservation equation.
-     * It uses an approximation that involves the reference density profile, and
-     * includes this term implicitly in the matrix,
-     * which is therefore not longer symmetric.
-     * This class approximates this term as
-     * $ - \nabla \cdot \mathbf{u} - \frac{1}{\rho^{\ast}} \frac{\partial rho{^\ast}}{\partial z} \frac{\mathbf{g}}{||\mathbf{g}||} \cdot \mathbf{u} = 0$
-     */
-    template <int dim>
-    class StokesImplicitReferenceDensityCompressibilityTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the right-hand-side term of the Stokes equation
-     * that is caused by the compressibility in the mass conservation equation.
-     * This class approximates this term as
-     * $ - \nabla \cdot \mathbf{u} = \kappa \rho \mathbf{g} \cdot \mathbf{u}$
-     * where $\kappa$ is the compressibility provided by the material model,
-     * which is frequently computed as
-     * $\kappa = \frac{1}{\rho} \frac{\partial rho}{\partial p}$.
-     */
-    template <int dim>
-    class StokesIsentropicCompressionTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the right-hand-side term of the Stokes equation
-     * that is caused by the variable density in the mass conservation equation.
-     * This class approximates this term as
-     * $ - \nabla \cdot \mathbf{u} = \frac{1}{\rho} \frac{\partial \rho}{\partial t} + \frac{1}{\rho} \nabla \rho \cdot \mathbf{u}$
-     * where the right-hand side velocity is explicitly taken from the last timestep,
-     * and the density is taken from a compositional field of the type 'density'.
-     */
-    template <int dim>
-    class StokesProjectedDensityFieldTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const override;
-    };
-
-
-    /**
-     * This class assembles the right-hand-side term of the Stokes equation
-     * that is caused by the compression based on the changes in (hydrostatic)
-     * pressure and temperature in the mass conservation equation.
-     *
-     * This class approximates this term as
-     * $ -\nabla \cdot \mathbf{u} = \left( \kappa \rho \textbf{g} - \alpha \nabla T \right) \cdot \textbf{u}$
-     *
-     * where $\frac{1}{\rho} \frac{\partial \rho}{\partial p} = \kappa$ is the compressibility,
-     * $- \frac{1}{\rho}\frac{\partial \rho}{\partial T} = \alpha$ is the thermal expansion coefficient,
-     * and both are defined in the material model.
-     */
-    template <int dim>
-    class StokesHydrostaticCompressionTerm : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class assembles the right-hand-side terms that are used to weakly
-     * prescribe the boundary tractions.
-     */
-    template <int dim>
-    class StokesBoundaryTraction : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-
-    /**
-     * This class computes the local pressure shape function integrals that
-     * are later used to make the Stokes equations compatible to its right hand
-     * side. For more information why this is necessary see Section 3.2.2 of
-     * Heister et al. (2017), "High Accuracy Mantle Convection Simulation
-     * through Modern Numerical Methods. II: Realistic Models and Problems."
-     */
-    template <int dim>
-    class StokesPressureRHSCompatibilityModification : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const override;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/simulator_access.h.bak b/include/aspect/simulator_access.h.bak
deleted file mode 100644
index 999a22a6980..00000000000
--- a/include/aspect/simulator_access.h.bak
+++ /dev/null
@@ -1,1002 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_simulator_access_h
-#define _aspect_simulator_access_h
-
-#include <aspect/global.h>
-#include <aspect/parameters.h>
-#include <aspect/introspection.h>
-
-#include <deal.II/base/table_handler.h>
-#include <deal.II/base/timer.h>
-#include <deal.II/base/conditional_ostream.h>
-#include <deal.II/distributed/tria.h>
-#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/fe/fe.h>
-#include <deal.II/fe/mapping_q.h>
-#include <deal.II/lac/affine_constraints.h>
-
-namespace WorldBuilder
-{
-  class World;
-}
-
-namespace aspect
-{
-  using namespace dealii;
-
-  // forward declarations:
-  template <int dim> class Simulator;
-  template <int dim> struct SimulatorSignals;
-  template <int dim> class LateralAveraging;
-  template <int dim> struct RotationProperties;
-
-  namespace GravityModel
-  {
-    template <int dim> class Interface;
-  }
-
-  namespace HeatingModel
-  {
-    template <int dim> class Manager;
-  }
-
-  namespace MaterialModel
-  {
-    template <int dim> class Interface;
-  }
-
-  namespace InitialTemperature
-  {
-    template <int dim> class Manager;
-    template <int dim> class Interface;
-  }
-
-  namespace BoundaryTemperature
-  {
-    template <int dim> class Manager;
-    template <int dim> class Interface;
-  }
-
-  namespace BoundaryHeatFlux
-  {
-    template <int dim> class Interface;
-  }
-
-  namespace BoundaryComposition
-  {
-    template <int dim> class Manager;
-    template <int dim> class Interface;
-  }
-
-  namespace BoundaryTraction
-  {
-    template <int dim> class Manager;
-    template <int dim> class Interface;
-  }
-
-  namespace BoundaryVelocity
-  {
-    template <int dim> class Manager;
-    template <int dim> class Interface;
-  }
-
-  namespace InitialComposition
-  {
-    template <int dim> class Manager;
-    template <int dim> class Interface;
-  }
-
-  namespace InitialTopographyModel
-  {
-    template <int dim> class Interface;
-  }
-
-  namespace MeshRefinement
-  {
-    template <int dim> class Manager;
-  }
-
-  namespace AdiabaticConditions
-  {
-    template <int dim> class Interface;
-  }
-
-  namespace Postprocess
-  {
-    template <int dim> class Manager;
-  }
-
-  template <int dim> class MeltHandler;
-  template <int dim> class VolumeOfFluidHandler;
-
-  namespace MeshDeformation
-  {
-    template <int dim> class MeshDeformationHandler;
-  }
-
-  template <int dim> class NewtonHandler;
-
-  template <int dim> class StokesMatrixFreeHandler;
-
-  namespace Particle
-  {
-    template <int dim> class World;
-  }
-
-  namespace TimeStepping
-  {
-    template <int dim> class Manager;
-  }
-
-  /**
-   * SimulatorAccess is a base class for different plugins like postprocessors.
-   * It provides access to the various variables of the main class that
-   * plugins may want to use in their evaluations, such as solution vectors,
-   * the current time, time step sizes, material models, or the triangulations
-   * and DoFHandlers that correspond to solutions.
-   *
-   * This class is the interface between plugins and the main simulator class.
-   * Using this insulation layer, the plugins need not know anything about the
-   * internal details of the simulation class.
-   *
-   * Every Postprocessor is required to derive from SimulatorAccess. It is
-   * optional for other plugins like MaterialModel, GravityModel, etc..
-   *
-   * Since the functions providing access to details of the simulator class
-   * are meant to be used only by derived classes of this class (rather than
-   * becoming part of the public interface of these classes), the functions of
-   * this class are made @p protected.
-   *
-   * @ingroup Simulator
-   */
-  template <int dim>
-  class SimulatorAccess
-  {
-    public:
-      /**
-       * Default constructor. Initialize the SimulatorAccess object without
-       * a reference to a particular Simulator object. You will later have
-       * to call initialize() to provide this reference to the Simulator
-       * object.
-       */
-      SimulatorAccess ();
-
-      /**
-       * Create a SimulatorAccess object that is already initialized for
-       * a particular Simulator.
-       */
-      SimulatorAccess (const Simulator<dim> &simulator_object);
-
-      /**
-       * Destructor. Does nothing but is virtual so that derived classes
-       * destructors are also virtual.
-       */
-      virtual ~SimulatorAccess () = default;
-
-      /**
-       * Initialize this class for a given simulator. This function is marked
-       * as virtual so that derived classes can do something upon
-       * initialization as well, for example look up and cache data; derived
-       * classes should call this function from the base class as well,
-       * however.
-       *
-       * @param simulator_object A reference to the main simulator object.
-       */
-      virtual void initialize_simulator (const Simulator<dim> &simulator_object);
-
-      /** @name Accessing variables that identify overall properties of the simulator */
-      /** @{ */
-
-      /**
-       * Return a reference to an introspection object that describes overall
-       * properties of the simulator. In particular, it provides symbolic
-       * names for extractors and component masks for each variable, etc, and
-       * thereby reduces the need for implicit knowledge throughout the code
-       * base.
-       */
-      const Introspection<dim> &
-      introspection () const;
-
-      /**
-       * Return a reference to the Simulator itself. Note that you can not
-       * access any members or functions of the Simulator. This function
-       * exists so that any class with SimulatorAccess can create other
-       * objects with SimulatorAccess (because initializing them requires a
-       * reference to the Simulator).
-       */
-      const Simulator<dim> &
-      get_simulator () const;
-
-      /**
-       * Return a reference to the parameters object that describes all run-time
-       * parameters used in the current simulation.
-       */
-      const Parameters<dim> &
-      get_parameters () const;
-
-      /**
-       * Get Access to the structure containing the signals of the simulator.
-       */
-      SimulatorSignals<dim> &
-      get_signals() const;
-
-      /**
-       * Return the MPI communicator for this simulation.
-       */
-      MPI_Comm
-      get_mpi_communicator () const;
-
-      /**
-       * Return the timer object for this simulation. Since the timer is
-       * mutable in the Simulator class, this allows plugins to define their
-       * own sections in the timer to measure the time spent in sections of
-       * their code.
-       */
-      TimerOutput &
-      get_computing_timer () const;
-
-      /**
-       * Return a reference to the stream object that only outputs something
-       * on one processor in a parallel program and simply ignores output put
-       * into it on all other processors.
-       */
-      const ConditionalOStream &
-      get_pcout () const;
-
-      /**
-       * Return the current simulation time in seconds.
-       */
-      double get_time () const;
-
-      /**
-       * Return the size of the current time step.
-       */
-      double
-      get_timestep () const;
-
-      /**
-       * Return the size of the last time step.
-       */
-      double
-      get_old_timestep () const;
-
-      /**
-       * Return the current number of a time step.
-       */
-      unsigned int
-      get_timestep_number () const;
-
-      /**
-       * Return a reference to the manager of the time stepping strategies.
-       * This can then be used, for example, to check whether a checkpoint needs to
-       * be made upon termination.
-       */
-      const TimeStepping::Manager<dim> &
-      get_timestepping_manager() const;
-
-      /**
-       * Return the current nonlinear iteration number of a time step.
-       */
-      unsigned int
-      get_nonlinear_iteration () const;
-
-      /**
-       * Return a reference to the triangulation in use by the simulator
-       * object.
-       */
-      const parallel::distributed::Triangulation<dim> &
-      get_triangulation () const;
-
-      /**
-       * Return the global volume of the computational domain.
-       */
-      double
-      get_volume () const;
-
-      /**
-       * Return a reference to the mapping used to describe the boundary of
-       * the domain.
-       */
-      const Mapping<dim> &
-      get_mapping () const;
-
-      /**
-       * Return the directory specified in the input parameter file to be the
-       * place where output files are to be placed. The string is terminated
-       * by a directory separator (i.e., '/').
-       */
-      std::string
-      get_output_directory () const;
-
-      /**
-       * Return whether we use the adiabatic heating term.
-       */
-      bool
-      include_adiabatic_heating () const;
-
-      /**
-       * Return whether we use the latent heat term.
-       */
-      bool
-      include_latent_heat () const;
-
-      /**
-       * Return whether we solve the equations for melt transport.
-       */
-      bool
-      include_melt_transport () const;
-
-      /**
-       * Return the stokes velocity degree.
-       */
-      int
-      get_stokes_velocity_degree () const;
-
-      /**
-       * Return the adiabatic surface temperature.
-       */
-      double
-      get_adiabatic_surface_temperature () const;
-
-      /**
-       * Return the adiabatic surface pressure.
-       */
-      double
-      get_surface_pressure () const;
-
-      /**
-       * Return whether things like velocities should be converted from the
-       * seconds in the MKS system to years. The value of this flag is set by
-       * the corresponding entry in the input parameter file.
-       */
-      bool
-      convert_output_to_years () const;
-
-      /**
-       * Return the number of the current pre refinement step.
-       * This can be useful for plugins that want to function differently in
-       * the initial adaptive refinements and later on.
-       * This will be not initialized before Simulator<dim>::run() is called.
-       * It iterates upward from 0 to parameters.initial_adaptive_refinement
-       * during the initial adaptive refinement steps, and equals
-       * std::numeric_limits<unsigned int>::max() afterwards.
-       */
-      unsigned int
-      get_pre_refinement_step () const;
-
-      /**
-       * Return the number of compositional fields specified in the input
-       * parameter file that will be advected along with the flow field.
-       */
-      unsigned int
-      n_compositional_fields () const;
-
-      /**
-       * Return the simulation end time in seconds.
-       */
-      double
-      get_end_time () const;
-
-      /**
-       * Compute the error indicators in the same way they are normally used
-       * for mesh refinement. The mesh is not refined when doing so, but the
-       * indicators can be used when generating graphical output to check why
-       * mesh refinement is proceeding as it is.
-       */
-      void
-      get_refinement_criteria(Vector<float> &estimated_error_per_cell) const;
-
-      /**
-       * Returns the entropy viscosity on each locally owned cell as it is
-       * used to stabilize the temperature equation.
-       *
-       * @param viscosity_per_cell Output vector with as many entries as
-       * active cells. Each entry corresponding to a locally owned active
-       * cell index will contain the artificial viscosity for this cell.
-       * @param skip_interior_cells A boolean flag. If set to true the function
-       * will only compute the artificial viscosity in cells at boundaries.
-       */
-      void
-      get_artificial_viscosity(Vector<float> &viscosity_per_cell,
-                               const bool skip_interior_cells = false) const;
-
-      /**
-       * Returns the entropy viscosity on each locally owned cell as it is
-       * used to stabilize the composition equation.
-       */
-      void
-      get_artificial_viscosity_composition(Vector<float> &viscosity_per_cell,
-                                           const unsigned int compositional_variable) const;
-
-      /**
-       * Compute the KXRCF indicator on each locally owned cell for a specific
-       * advection field.
-       */
-      void
-      compute_KXRCF_indicators(Vector<float> &KXRCF_indicators,
-                               const unsigned int field_index) const;
-      /** @} */
-
-
-      /** @name Accessing variables that identify the solution of the problem */
-      /** @{ */
-
-      /**
-       * Return a reference to the vector that has the current linearization
-       * point of the entire system, i.e. the velocity and pressure variables
-       * as well as the temperature and compositional fields. This vector is
-       * associated with the DoFHandler object returned by get_dof_handler().
-       * This vector is only different from the one returned by get_solution()
-       * during the solver phase.
-       *
-       * @note In general the vector is a distributed vector; however, it
-       * contains ghost elements for all locally relevant degrees of freedom.
-       */
-      const LinearAlgebra::BlockVector &
-      get_current_linearization_point () const;
-
-      /**
-       * Return a reference to the vector that has the current solution of the
-       * entire system, i.e. the velocity and pressure variables as well as
-       * the temperature and compositional fields.
-       * This vector is associated with the DoFHandler object returned by
-       * get_dof_handler().
-       *
-       * @note In general the vector is a distributed vector; however, it
-       * contains ghost elements for all locally relevant degrees of freedom.
-       */
-      const LinearAlgebra::BlockVector &
-      get_solution () const;
-
-      /**
-       * Return a reference to the vector that has the solution of the entire
-       * system at the previous time step. This vector is associated with the
-       * DoFHandler object returned by get_stokes_dof_handler().
-       *
-       * @note In general the vector is a distributed vector; however, it
-       * contains ghost elements for all locally relevant degrees of freedom.
-       */
-      const LinearAlgebra::BlockVector &
-      get_old_solution () const;
-
-      /**
-       * Return a reference to the vector that has the solution of the entire
-       * system at the second-to-last time step. This vector is associated with the
-       * DoFHandler object returned by get_stokes_dof_handler().
-       *
-       * @note In general the vector is a distributed vector; however, it
-       * contains ghost elements for all locally relevant degrees of freedom.
-       */
-      const LinearAlgebra::BlockVector &
-      get_old_old_solution () const;
-
-      /**
-       * Return a reference to the vector that has the reactions computed by the
-       * operator splitting scheme in the current time step.
-       *
-       * @note In general the vector is a distributed vector; however, it
-       * contains ghost elements for all locally relevant degrees of freedom.
-       */
-      const LinearAlgebra::BlockVector &
-      get_reaction_vector () const;
-
-      /**
-       * Return a reference to the vector that has the mesh velocity for
-       * simulations with mesh deformation.
-       *
-       * @note In general the vector is a distributed vector; however, it
-       * contains ghost elements for all locally relevant degrees of freedom.
-       */
-      const LinearAlgebra::BlockVector &
-      get_mesh_velocity () const;
-
-      /**
-       * Return a reference to the DoFHandler that is used to discretize the
-       * variables at the current time step.
-       */
-      const DoFHandler<dim> &
-      get_dof_handler () const;
-
-      /**
-       * Return a reference to the finite element that is
-       * used to discretize the variables at the current time step.
-       * This is the finite element for the entire, coupled problem, i.e.,
-       * it contains sub-elements for velocity, pressure, temperature and all
-       * other variables in this problem (e.g., compositional variables, if
-       * used in this simulation).
-       */
-      const FiniteElement<dim> &
-      get_fe () const;
-
-      /**
-       * Return a reference to the system matrix at the current time step.
-       */
-      const LinearAlgebra::BlockSparseMatrix &
-      get_system_matrix () const;
-
-      /**
-       * Return a reference to the system preconditioner matrix at the current time step.
-       */
-      const LinearAlgebra::BlockSparseMatrix &
-      get_system_preconditioner_matrix () const;
-
-      /** @} */
-
-
-      /** @name Accessing variables that identify aspects of the simulation */
-      /** @{ */
-
-      /**
-       * Return a pointer to the material model to access functions like
-       * density().
-       */
-      const MaterialModel::Interface<dim> &
-      get_material_model () const;
-
-      /**
-       * Return a pointer to the gravity model description.
-       */
-      const GravityModel::Interface<dim> &
-      get_gravity_model () const;
-
-      /**
-       * Return a pointer to the initial topography model.
-       */
-      const InitialTopographyModel::Interface<dim> &
-      get_initial_topography_model () const;
-
-      /**
-       * Return a pointer to the geometry model.
-       */
-      const GeometryModel::Interface<dim> &
-      get_geometry_model () const;
-
-
-      /**
-       * Return a pointer to the object that describes the adiabatic
-       * conditions.
-       */
-      const AdiabaticConditions::Interface<dim> &
-      get_adiabatic_conditions () const;
-
-      /**
-       * Return whether the current model has a boundary temperature object
-       * set. This is useful because a simulation does not actually have to
-       * declare any boundary temperature model, for example if all
-       * boundaries are insulating. In such cases, there is no
-       * boundary temperature model that can provide, for example,
-       * a minimal and maximal temperature on the boundary.
-       */
-      bool has_boundary_temperature () const;
-
-      /**
-       * Return an reference to the manager of the boundary temperature models.
-       * This can then, for example, be used to get the names of the initial temperature
-       * models used in a computation, or to compute the initial temperature
-       * for a given position.
-       */
-      const BoundaryTemperature::Manager<dim> &
-      get_boundary_temperature_manager () const;
-
-      /**
-       * Return a reference to the object that describes heat flux
-       * boundary conditions.
-       */
-      const BoundaryHeatFlux::Interface<dim> &
-      get_boundary_heat_flux () const;
-
-      /**
-       * Return whether the current model has a boundary composition object
-       * set. This is useful because a simulation does not actually have to
-       * declare any boundary composition model, for example if all
-       * boundaries are reflecting. In such cases, there is no
-       * boundary composition model.
-       */
-      bool has_boundary_composition () const;
-
-      /**
-       * Return an reference to the manager of the boundary composition models.
-       * This can then, for example, be used to get the names of the boundary composition
-       * models used in a computation, or to compute the boundary composition
-       * for a given position.
-       */
-      const BoundaryComposition::Manager<dim> &
-      get_boundary_composition_manager () const;
-
-      /**
-      * Return an reference to the manager of the boundary traction models.
-      * This can then, for example, be used to get the names of the boundary traction
-      * models used in a computation, or to compute the boundary traction
-      * for a given position.
-      */
-      const BoundaryTraction::Manager<dim> &
-      get_boundary_traction_manager () const;
-
-      /**
-       * Return a reference to the manager of the initial temperature models.
-       * This can then, for example, be used to get the names of the initial temperature
-       * models used in a computation, or to compute the initial temperature
-       * for a given position.
-       *
-       * While the Simulator class creates a shared pointer to an initial
-       * temperature manager before the first time step, it releases
-       * the pointer once it no longer needs access to the initial
-       * compositions. As a consequence, you can only call this function
-       * during the first time step.
-       *
-       * If the Simulator's shared pointer were the only
-       * one that points to the initial temperature manager object, that
-       * would also destroy the object pointed to. However, plugin classes
-       * can have member variables that are *also* shared pointers to
-       * these manager objects, and if you initialize such a shared
-       * pointer from the result of this function -- typically in the
-       * `initialize()` function of a plugin class -- then the Simulator
-       * giving up its shared pointer does not actually destroy the
-       * manager object but extends its lifetime until the last plugin
-       * that has a pointer to it is destroyed itself. As a consequence,
-       * if you need access to the initial temperature in a plugin, you
-       * will need to keep a shared pointer to it around for as long
-       * as you need it.
-       */
-      std::shared_ptr<const InitialTemperature::Manager<dim>>
-      get_initial_temperature_manager_pointer () const;
-
-      /**
-       * Return a reference to the manager of the initial temperature model.
-       * This can then, for example, be used to get the names of the initial temperature
-       * models used in a computation.
-       *
-       * While the Simulator class creates a shared pointer to an initial
-       * temperature manager before the first time step, it releases
-       * the pointer once it no longer needs access to the initial
-       * temperature. As a consequence, you can only call this function
-       * during the first time step. If a plugin needs access to the initial
-       * temperature at a later time, it has to store its own shared
-       * pointer to that object, and that is what can be achieved using
-       * the get_initial_temperature_manager_pointer() function above.
-       */
-      const InitialTemperature::Manager<dim> &
-      get_initial_temperature_manager () const;
-
-      /**
-       * Return a pointer to the manager of the initial composition model.
-       * This can then, for example, be used to get the names of the initial composition
-       * models used in a computation.
-       *
-       * While the Simulator class creates a shared pointer to an initial
-       * composition manager before the first time step, it releases
-       * the pointer once it no longer needs access to the initial
-       * compositions. As a consequence, you can only call this function
-       * during the first time step.
-       *
-       * If the Simulator's shared pointer were the only
-       * one that points to the initial composition manager object, that
-       * would also destroy the object pointed to. However, plugin classes
-       * can have member variables that are *also* shared pointers to
-       * these manager objects, and if you initialize such a shared
-       * pointer from the result of this function -- typically in the
-       * `initialize()` function of a plugin class -- then the Simulator
-       * giving up its shared pointer does not actually destroy the
-       * manager object but extends its lifetime until the last plugin
-       * that has a pointer to it is destroyed itself. As a consequence,
-       * if you need access to the initial compositions in a plugin, you
-       * will need to keep a shared pointer to it around for as long
-       * as you need it.
-       */
-      std::shared_ptr<const InitialComposition::Manager<dim>>
-      get_initial_composition_manager_pointer () const;
-
-      /**
-       * Return a reference to the manager of the initial composition model.
-       * This can then, for example, be used to get the names of the initial composition
-       * models used in a computation.
-       *
-       * While the Simulator class creates a shared pointer to an initial
-       * composition manager before the first time step, it releases
-       * the pointer once it no longer needs access to the initial
-       * compositions. As a consequence, you can only call this function
-       * during the first time step. If a plugin needs access to the initial
-       * composition at a later time, it has to store its own shared
-       * pointer to that object, and that is what can be achieved using
-       * the get_initial_composition_manager_pointer() function above.
-       */
-      const InitialComposition::Manager<dim> &
-      get_initial_composition_manager () const;
-
-      /**
-       * Return a set of boundary indicators that describes which of the
-       * boundaries have a fixed temperature.
-       */
-      const std::set<types::boundary_id> &
-      get_fixed_temperature_boundary_indicators () const;
-
-      /**
-       * Return a set of boundary indicators that describes which of the
-       * boundaries have a fixed heat flux.
-       */
-      const std::set<types::boundary_id> &
-      get_fixed_heat_flux_boundary_indicators () const;
-
-      /**
-       * Return a set of boundary indicators that describes which of the
-       * boundaries have a fixed composition.
-       */
-      const std::set<types::boundary_id> &
-      get_fixed_composition_boundary_indicators () const;
-
-      /**
-       * Return a set of boundary indicators that describes which of the
-       * boundaries have a mesh deformation boundary condition. Note that
-       * it does not specify which boundaries have which mesh deformation
-       * condition, only which boundaries have a mesh deformation condition.
-       */
-      const std::set<types::boundary_id> &
-      get_mesh_deformation_boundary_indicators () const;
-
-      /**
-       * Return an reference to the manager of the boundary velocity models.
-       * This can then, for example, be used to get the names of the boundary velocity
-       * models used in a computation, or to compute the boundary velocity
-       * for a given position.
-       */
-      const BoundaryVelocity::Manager<dim> &
-      get_boundary_velocity_manager () const;
-
-      /**
-       * Return a pointer to the manager of the heating model.
-       * This can then, for example, be used to get the names of the heating models
-       * used in a computation.
-       */
-      const HeatingModel::Manager<dim> &
-      get_heating_model_manager () const;
-
-      /**
-       * Return a reference to the manager of the mesh refinement strategies.
-       * this can then, for example, be used to get the names of the active refinement
-       * strategies for such purposes as confirming that a particular one has
-       * been included.
-       */
-      const MeshRefinement::Manager<dim> &
-      get_mesh_refinement_manager () const;
-
-      /**
-       * Return a reference to the melt handler.
-       */
-      const MeltHandler<dim> &
-      get_melt_handler () const;
-
-      /**
-       * Return a reference to the VolumeOfFluid handler.
-       */
-      const VolumeOfFluidHandler<dim> &
-      get_volume_of_fluid_handler () const;
-
-      /**
-       * Return a reference to the Newton handler that controls the Newton
-       * iteration to resolve nonlinearities.
-       */
-      const NewtonHandler<dim> &
-      get_newton_handler () const;
-
-#ifdef ASPECT_WITH_WORLD_BUILDER
-      /**
-       * Return a reference to the world builder that controls the setup of
-       * initial conditions.
-       *
-       * This call will only succeed if ASPECT was configured to use
-       * the WorldBuilder.
-       *
-       * While the Simulator class creates a shared pointer to a
-       * WorldBuilder object before the first time step, it releases
-       * the pointer once it no longer needs access to the initial
-       * conditions. As a consequence, you can only call this function
-       * during the first time step. If a plugin needs access to the object
-       * so returned at a later time, it has to store its own shared
-       * pointer to that object, and that is what can be achieved using
-       * the get_world_builder_pointer() function below.
-       */
-      const WorldBuilder::World &
-      get_world_builder () const;
-
-      /**
-       * This function is to get_world_builder() what
-       * get_initial_temperature_manager_pointer() is to
-       * the get_initial_temperature_manager() function: It returns a
-       * shared pointer so that objects that still need access to the
-       * WorldBuilder object after the Simulator class has released
-       * it, can extend the lifetime of the object pointed to by
-       * keeping a shared pointer to it.
-       */
-      std::shared_ptr<const WorldBuilder::World>
-      get_world_builder_pointer () const;
-#endif
-      /**
-       * Return a reference to the mesh deformation handler. This function will
-       * throw an exception if mesh deformation is not activated.
-       */
-      const MeshDeformation::MeshDeformationHandler<dim> &
-      get_mesh_deformation_handler () const;
-
-      /**
-       * Return a reference to the lateral averaging object owned
-       * by the simulator, which can be used to query lateral averages
-       * of various quantities at depth slices.
-       */
-      const LateralAveraging<dim> &
-      get_lateral_averaging () const;
-
-      /**
-       * Return a pointer to the object that describes the DoF
-       * constraints for the time step we are currently solving.
-       */
-      const AffineConstraints<double> &
-      get_current_constraints () const;
-
-      /**
-       * Return whether the Simulator object has been completely initialized
-       * and has started to run its time stepping loop.
-       *
-       * This function is useful to determine in a plugin whether some
-       * of the information one can query about the Simulator can be trusted
-       * because it has already been set up completely. For example,
-       * while the Simulator is being
-       * set up, plugins may already have access to it via the current
-       * SimulatorAccess object, but data such as the current time, the
-       * time step number, etc, may all still be in a state that is not
-       * reliable since it may not have been initialized at that time. (As
-       * an example, at the very beginning of the Simulator object's existence,
-       * the time step number is set to numbers::invalid_unsigned_int, and
-       * only when the time step loop is started is it set to a valid
-       * value). Similar examples are that at some point the Simulator
-       * sets the solution vector to the correct size, but only at a later
-       * time (though before the time stepping starts), the *contents* of
-       * the solution vector are set based on the initial conditions
-       * specified in the input file.
-       *
-       * Only when this function returns @p true is all of the information
-       * returned by the SimulatorAccess object reliable and correct.
-       *
-       * @note This function returns @p true starting with the moment where the
-       *   Simulator starts the time stepping loop. However, it may
-       *   temporarily revert to returning @p false if, for example,
-       *   the Simulator does the initial mesh refinement steps where
-       *   it starts the time loop, but then goes back to
-       *   initialization steps (mesh refinement, interpolation of initial
-       *   conditions, etc.) before re-starting the time loop.
-       */
-      bool simulator_is_past_initialization () const;
-
-      /**
-       * Return the value used for rescaling the pressure in the linear
-       * solver.
-       */
-      double
-      get_pressure_scaling () const;
-
-      /**
-       * Return whether we need to apply a compatibility modification
-       * to the pressure right hand side. See documentation of
-       * Simulator<dim>::do_pressure_rhs_compatibility_modification for more
-       * information.
-       */
-      bool
-      pressure_rhs_needs_compatibility_modification() const;
-
-      /**
-       * Return whether the model uses a prescribed Stokes solution.
-       */
-      bool
-      model_has_prescribed_stokes_solution () const;
-
-      /**
-       * A convenience function that copies the values of the compositional
-       * fields at the quadrature point q given as input parameter to the
-       * output vector composition_values_at_q_point.
-       */
-      static
-      void
-      get_composition_values_at_q_point (const std::vector<std::vector<double>> &composition_values,
-                                         const unsigned int                      q,
-                                         std::vector<double>                    &composition_values_at_q_point);
-
-      /**
-       * Return a writable reference to the statistics object into which
-       * you can store additional data that then shows up in the
-       * <code>output_dir/statistics</code> file.
-       *
-       * Postprocessor objects get a reference to this object automatically
-       * when called, but other plugins may not. They do not usually
-       * produce output anyway, but through this function they can still
-       * record information as necessary.
-       * @return
-       */
-      TableHandler &get_statistics_object() const;
-
-      /**
-       * Return a reference to the melt handler.
-       */
-      const Postprocess::Manager<dim> &
-      get_postprocess_manager () const;
-
-      /**
-       * Returns whether there is at least one particle world.
-       */
-      unsigned int
-      n_particle_worlds() const;
-
-      /**
-       * Returns a const reference to a single particle world, in case anyone
-       * wants to query something about particles.
-       */
-      const Particle::World<dim> &
-      get_particle_world(const unsigned int particle_world_index) const;
-
-      /**
-       * Returns a reference to a single particle world, in case anyone wants to
-       * change something within the particle world. Use with care, usually
-       * you want to only let the functions within the particle subsystem
-       * change member variables of the particle world.
-       */
-      Particle::World<dim> &
-      get_particle_world(const unsigned int particle_world_index);
-
-      /**
-       * Return true if using the block GMG Stokes solver.
-       */
-      bool is_stokes_matrix_free();
-
-      /**
-       * Return a reference to the StokesMatrixFreeHandler that controls the
-       * matrix-free Stokes solver.
-       */
-      const StokesMatrixFreeHandler<dim> &
-      get_stokes_matrix_free () const;
-
-      /**
-       * Compute the angular momentum and other rotation properties
-       * of the velocities in the given solution vector.
-       *
-       * @param use_constant_density determines whether to use a constant
-       * density (which corresponds to computing a net rotation instead of net
-       * angular momentum).
-       * @param solution Solution vector to compute the properties for.
-       * @param limit_to_top_faces allows to only compute the net angular momentum
-       * (or net rotation) of the top surface.
-       */
-      RotationProperties<dim>
-      compute_net_angular_momentum(const bool use_constant_density,
-                                   const LinearAlgebra::BlockVector &solution,
-                                   const bool limit_to_top_faces = false) const;
-
-      /** @} */
-
-    private:
-      /**
-       * A pointer to the simulator object to which we want to get access.
-       */
-      const Simulator<dim> *simulator;
-  };
-}
-
-
-#endif
diff --git a/include/aspect/simulator_signals.h.bak b/include/aspect/simulator_signals.h.bak
deleted file mode 100644
index dea23bd94be..00000000000
--- a/include/aspect/simulator_signals.h.bak
+++ /dev/null
@@ -1,420 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_simulator_signals_h
-#define _aspect_simulator_signals_h
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-#include <aspect/parameters.h>
-
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/numerics/data_out.h>
-
-#include <boost/signals2.hpp>
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    template <int dim>
-    class Manager;
-
-    template <int dim>
-    class Interface;
-  }
-
-  /**
-   * A class that collects the definition of signals that can be triggered
-   * at different points in a computation. A signal is in essence an event
-   * that is triggered whenever the program passes a certain point in a
-   * computation. Parties interested in any of these signals can attach
-   * "slots" to a signal. A slot is, in essence, a function that is called
-   * whenever the signal is triggered. Multiple slots (or none) can be
-   * attached to the same signal. To be as general as possible, slots are
-   * not actually just pointers to functions, but std::function objects
-   * that have a certain signature. Consequently, they can have much more
-   * complicated types than just function pointers, such as objects with
-   * an <code>operator()</code> or lambda functions.
-   *
-   * The documentation of each of the signals below indicates when
-   * exactly it is called.
-   *
-   * @ingroup Simulator
-   */
-  template <int dim>
-  struct SimulatorSignals
-  {
-    /**
-     * A signal that is called before the list of finite element variables is
-     * used to construct the Introspection class.
-     *
-     * The functions (slots) that can attach to this signal need to
-     * take one argument: A std::vector of VariableDeclaration<dim>
-     * representing the collection of finite element variables,
-     * that can be modified and will be used to construct the
-     * final finite element system later.
-     */
-    boost::signals2::signal<void (std::vector<VariableDeclaration<dim>> &)>
-    edit_finite_element_variables;
-
-    /**
-     * A signal that is called before setting up the initial conditions.
-     *
-     * The functions (slots) that can attach to this signal need to take one
-     * argument: A SimulatorAccess object that describes the simulator.
-     */
-    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_set_initial_state;
-
-    /**
-     * A signal that is called after setting up the initial conditions.
-     *
-     * The functions (slots) that can attach to this signal need to take one
-     * argument: A SimulatorAccess object that describes the simulator.
-     */
-    boost::signals2::signal<void (const SimulatorAccess<dim> &)>  post_set_initial_state;
-
-    /**
-     * A signal that is called at the beginning of each time step.
-     *
-     * The functions (slots) that can attach to this signal need to take one
-     * argument: A SimulatorAccess object that describes the simulator.
-     */
-    boost::signals2::signal<void (const SimulatorAccess<dim> &)>  start_timestep;
-
-    /**
-     * A signal that is called at the end of setting up the
-     * constraints for the current time step. This allows to add
-     * more constraints on degrees of freedom, for example to fix
-     * the velocity at certain points.
-     *
-     * The functions (slots) that can attach to this signal need to
-     * take two arguments: A SimulatorAccess object that
-     * describes the simulator to act on, and an (output)
-     * argument that indicates the constraints to be computed.
-     */
-    boost::signals2::signal<void (const SimulatorAccess<dim> &,
-                                  AffineConstraints<double> &)>  post_constraints_creation;
-
-    /**
-     * A signal that is called at the start of setup_dofs(). This allows for
-     * editing of the parameters struct on the fly (such as changing boundary
-     * conditions) to give ASPECT different behavior in mid-run than it
-     * otherwise would have.
-     *
-     * The functions that connect to this signal must take two arguments, a
-     * SimulatorAccess object that describes the simulator, and an object of
-     * type aspect::Parameters<dim>, which is the current parameters object
-     * that the simulator is working with.
-     */
-    boost::signals2::signal<void (const SimulatorAccess<dim> &,
-                                  Parameters<dim> &parameters)>  edit_parameters_pre_setup_dofs;
-
-    /**
-     * A signal that is called before every mesh_refinement. This signal
-     * allows for registering functions that store data that is related to
-     * mesh cells and needs to be transferred with the cells during the
-     * repartitioning.
-     *
-     * The functions that connect to this signal must take a reference to a
-     * parallel::distributed::Triangulation object as argument. This argument
-     * will point to the triangulation used by the Simulator class.
-     */
-    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_refinement_store_user_data;
-
-    /**
-     * A signal that is called after every mesh_refinement.  This signal
-     * allows for registering functions that load data related to mesh cells
-     * and that was transferred with the cells during the repartitioning.
-     *
-     * The functions that connect to this signal must take a reference to a
-     * parallel::distributed::Triangulation object as argument. This argument
-     * will point to the triangulation used by the Simulator class.
-     */
-    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  post_refinement_load_user_data;
-
-    /**
-     * A signal that is called before the computation of tangential boundary
-     * conditions for which normal vectors are needed, i.e. calls to the
-     * compute_no_normal_flux_constraints function for both the
-     * velocity variable in the main simulator and the mesh velocity
-     * variable in models with mesh deformation.
-     *
-     * The functions that connect to this signal must take a reference
-     * to a parallel::distributed::Triangulation object as
-     * argument. This argument will point to the triangulation used by
-     * the Simulator class.
-     */
-    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_compute_no_normal_flux_constraints;
-
-    /**
-     * A signal that is called after the computation of tangential boundary
-     * conditions for which normal vectors are needed, i.e. calls to the
-     * compute_no_normal_flux_constraints function for both the
-     * velocity variable in the main simulator and the mesh velocity
-     * variable in models with mesh deformation.
-     *
-     * The functions that connect to this signal must take a reference
-     * to a parallel::distributed::Triangulation object as
-     * argument. This argument will point to the triangulation used by
-     * the Simulator class.
-     */
-    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  post_compute_no_normal_flux_constraints;
-
-    /**
-     * A signal that is called before the creation of every checkpoint.  This
-     * signal allows for registering functions that store data related to mesh
-     * cells.
-     *
-     * The functions that connect to this signal must take a reference to a
-     * parallel::distributed::Triangulation object as argument. This argument
-     * will point to the triangulation used by the Simulator class.
-     */
-    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_checkpoint_store_user_data;
-
-    /**
-     * A signal that is called after resuming from a checkpoint.  This signal
-     * allows for registering functions that load data related to mesh cells
-     * that was previously stored in the checkpoint.  Note that before calling
-     * Triangulation::notify_ready_to_unpack() the function needs to call
-     * register_attach_data() with the appropriate arguments to restore the
-     * state of the triangulation.
-     *
-     * The functions that connect to this signal must take a reference to a
-     * parallel::distributed::Triangulation object as argument. This argument
-     * will point to the triangulation used by the Simulator class.
-     */
-    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  post_resume_load_user_data;
-
-    /**
-     * This signal is called whenever the pressure scaling is computed, see
-     * Simulator::compute_pressure_scaling_factor(), and allows inspection
-     * and/or modification of the computed factor.
-     *
-     * The argument @p pressure_scaling contains the computed pressure scaling (the ratio
-     * of the reference viscosity @p reference_viscosity computed by averaging
-     * the viscosity in the domain and the length scale @p length_scale reported
-     * by the geometry model). The return value of this functions will replace
-     * the computed value, therefore no changes are made if you return the value
-     * @p pressure_scaling.
-     */
-    boost::signals2::signal<double (const double pressure_scaling, const double reference_viscosity, const double length_scale)>  modify_pressure_scaling;
-
-    /**
-     * A signal that is called at the beginning of the program. It
-     * gives user extensions the ability to declare additional
-     * parameters via the provided argument. User extensions connected to
-     * this signal will likely also want to connect to the
-     * parse_additional_parameters signal.
-     *
-     * The first argument to functions that connect to this signal
-     * denotes the dimension in which ASPECT will be run. Functions
-     * connected to this signal can declare additional runtime
-     * parameters in the second argument.
-     */
-    static boost::signals2::signal<void (const unsigned int aspect_dim,
-                                         ParameterHandler &prm)>  declare_additional_parameters;
-
-    /**
-     * A signal that is called at the beginning of the program, after reading
-     * the input file. It gives user extensions the ability to read additional
-     * parameters from the provided argument. The first argument indicates an
-     * object that represents all of the other parameters (that have already
-     * been parsed at this point).
-     *
-     * User extensions connected to this signal will likely also want to
-     * connect to the declare_additional_parameters signal.
-     */
-    static boost::signals2::signal<void (const Parameters<dim> &,
-                                         ParameterHandler &)>  parse_additional_parameters;
-
-    /**
-     * A signal that is triggered when the iterative Stokes solver (either
-     * matrix-based or matrix-free) is done. The signal is not called when
-     * using a direct solver because the kind of information passed on by this
-     * signal does not exist when using a direct solver.
-     *
-     * Arguments to this signal are a reference to the SimulatorAccess, the number of
-     * preconditioner inner solver iterations for the $S$ and $A$ block of the
-     * system, and two information objects that contain information
-     * about the success of the solve, the number of outer GMRES iterations
-     * and the residual history for the cheap and expensive solver phase.
-     */
-    boost::signals2::signal<void (const SimulatorAccess<dim> &,
-                                  const unsigned int number_S_iterations,
-                                  const unsigned int number_A_iterations,
-                                  const SolverControl &solver_control_cheap,
-                                  const SolverControl &solver_control_expensive)> post_stokes_solver;
-
-    /**
-     * A signal that is triggered when the iterative advection solver is done.
-     * Arguments are a reference to the SimulatorAccess, a bool indicating
-     * whether the temperature field or a compositional field was solved,
-     * a composition index that describes which compositional field
-     * was solved, and an information object that contains information
-     * about the number of iterations and history of residuals.
-     */
-    boost::signals2::signal<void (const SimulatorAccess<dim> &,
-                                  const bool solved_temperature_field,
-                                  const unsigned int compositional_index,
-                                  const SolverControl &solver_control)> post_advection_solver;
-
-    /**
-     * A signal that is triggered when the nonlinear solver scheme is done.
-     * The signal parameter is an object that contains information
-     * about the final state (failure/success), number of
-     * iterations and history of residuals of the nonlinear solver.
-     * If there is no nonlinear solver (only a single solve), the
-     * SolverControl object will report a successful state, a single iteration
-     * and a remaining residual of zero.
-     */
-    boost::signals2::signal<void (const SolverControl &)> post_nonlinear_solver;
-
-    /**
-     * A signal that is triggered when ARKode is done solving an ODE.
-     * Arguments are a reference to the SimulatorAccess and
-     * an iteration count describing how many iterations ARKode required
-     * to solve the ODE.
-     */
-    boost::signals2::signal<void (const SimulatorAccess<dim> &,
-                                  const unsigned int iteration_count)> post_ARKode_solve;
-
-    /**
-     * A signal that is triggered when mesh deformation has occurred.
-     * The arguments to this signal is a reference to the SimulatorAccess
-     * object.
-     */
-    boost::signals2::signal<void (const SimulatorAccess<dim> &)> post_mesh_deformation;
-
-    /**
-     * A signal that is triggered at the end of the set_assemblers() function that
-     * allows modification of the assembly objects active in this simulation.
-     */
-    boost::signals2::signal<void (const SimulatorAccess<dim> &,
-                                  aspect::Assemblers::Manager<dim> &)>
-    set_assemblers;
-
-    /**
-    * A signal that is called before the build_patches() function is called during
-    * the creation of the visualization output. This signal
-    * allows for registering functions that take a DataOut object and can for example
-    * be used to select only certain cells of the mesh to be built into patches through
-    * calling the DataOut member function set_cell_selection().
-    */
-    boost::signals2::signal<void (DataOut<dim> &)>  pre_data_out_build_patches;
-  };
-
-
-  // Explain to the compiler that we instantiate this class elsewhere, along
-  // with its static members. This is necessary to avoid warnings by some
-  // compilers.
-  extern template struct SimulatorSignals<2>;
-  extern template
-  boost::signals2::signal<void (const unsigned int aspect_dim, ParameterHandler &prm)>
-  SimulatorSignals<2>::declare_additional_parameters;
-  extern template
-  boost::signals2::signal<void (const Parameters<2> &, ParameterHandler &)>
-  SimulatorSignals<2>::parse_additional_parameters;
-
-  extern template struct SimulatorSignals<3>;
-  extern template
-  boost::signals2::signal<void (const unsigned int aspect_dim, ParameterHandler &prm)>
-  SimulatorSignals<3>::declare_additional_parameters;
-  extern template
-  boost::signals2::signal<void (const Parameters<3> &, ParameterHandler &)>
-  SimulatorSignals<3>::parse_additional_parameters;
-
-
-  namespace internals
-  {
-    /**
-     * A namespace for some internal functions that have to do with how plugins
-     * can register their slots with signals.
-     */
-    namespace SimulatorSignals
-    {
-      /**
-       * Two functions that (in 2d and 3d) put a user-provided function onto a list
-       * of functions that the Simulator object will later go through when
-       * letting plugins connect their slots to signals.
-       */
-      void register_connector_function_2d (const std::function<void (aspect::SimulatorSignals<2> &)> &connector);
-      void register_connector_function_3d (const std::function<void (aspect::SimulatorSignals<3> &)> &connector);
-
-      /**
-       * A function that is called by the Simulator object and that goes
-       * through the list (with the corresponding dimension) created by the
-       * previous pair of functions and call each of the user-provided
-       * connector functions to let them register their slots with the
-       * corresponding signals.
-       */
-      template <int dim>
-      void call_connector_functions (aspect::SimulatorSignals<dim> &signals);
-    }
-  }
-
-
-  /**
-   * A macro that is used in user-provided plugins to register a function that
-   * is called at the beginning of a simulation by a Simulator object. When called,
-   * the provided function will receive a SimulatorSignals object that contains
-   * signals to which one can subscribe.
-   *
-   * For technical reasons, the macro takes two arguments denoting functions for the
-   * 2d and 3d cases. These can, for example, be the names of 2d and 3d
-   * instantiations of the same template function.
-   */
-#define ASPECT_REGISTER_SIGNALS_CONNECTOR(connector_function_2d,connector_function_3d) \
-  namespace ASPECT_REGISTER_SIGNALS_CONNECTOR \
-  { \
-    struct dummy_do_register \
-    {          \
-      dummy_do_register () \
-      { \
-        aspect::internals::SimulatorSignals::register_connector_function_2d (connector_function_2d); \
-        aspect::internals::SimulatorSignals::register_connector_function_3d (connector_function_3d); \
-      } \
-    } dummy_variable; \
-  }
-
-
-  /**
-   * A macro that is used to register a function that can be used to connect user
-   * extension functions to the parameter-related signals declared in SimulatorSignals.
-   *
-   * In essence, this function simply registers a (global) function that is called
-   * at the beginning of the program and that can be used to connect parameter
-   * declaration and parsing functions to the signals listed above.
-   */
-#define ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(connector_function) \
-  namespace ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR_ ## connector_function \
-  { \
-    struct dummy_do_register_ ## connector_function \
-    { \
-      dummy_do_register_ ## connector_function () \
-      {                \
-        connector_function (); \
-      }          \
-    } dummy_variable_ ## classname; \
-  }
-
-}
-#endif
diff --git a/include/aspect/stokes_matrix_free.h.bak b/include/aspect/stokes_matrix_free.h.bak
deleted file mode 100644
index e90f857cc4a..00000000000
--- a/include/aspect/stokes_matrix_free.h.bak
+++ /dev/null
@@ -1,702 +0,0 @@
-/*
-  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_stokes_matrix_free_h
-#define _aspect_stokes_matrix_free_h
-
-#include <aspect/global.h>
-
-#include <aspect/simulator.h>
-
-#include <deal.II/matrix_free/matrix_free.h>
-#include <deal.II/matrix_free/operators.h>
-#include <deal.II/matrix_free/fe_evaluation.h>
-
-#include <deal.II/multigrid/mg_constrained_dofs.h>
-#include <deal.II/multigrid/multigrid.h>
-#include <deal.II/multigrid/mg_transfer_matrix_free.h>
-#include <deal.II/multigrid/mg_transfer_global_coarsening.templates.h>
-#include <deal.II/multigrid/mg_tools.h>
-#include <deal.II/multigrid/mg_coarse.h>
-#include <deal.II/multigrid/mg_smoother.h>
-#include <deal.II/multigrid/mg_matrix.h>
-
-#include <deal.II/lac/vector.h>
-#include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/la_parallel_vector.h>
-#include <deal.II/lac/la_parallel_block_vector.h>
-
-/**
- * Typedef for the number type for the multigrid operators. Can be either float or double.
- */
-using GMGNumberType = double;
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace internal
-  {
-    /**
-     * Matrix-free operators must use deal.II defined vectors, while the rest of the ASPECT
-     * software is based on Trilinos vectors. Here we define functions which copy between the
-     * vector types.
-     */
-    namespace ChangeVectorTypes
-    {
-      void import(TrilinosWrappers::MPI::Vector &out,
-                  const dealii::LinearAlgebra::ReadWriteVector<double> &rwv,
-                  const VectorOperation::values                 operation);
-
-      void copy(TrilinosWrappers::MPI::Vector &out,
-                const dealii::LinearAlgebra::distributed::Vector<double> &in);
-
-      void copy(dealii::LinearAlgebra::distributed::Vector<double> &out,
-                const TrilinosWrappers::MPI::Vector &in);
-
-      void copy(TrilinosWrappers::MPI::BlockVector &out,
-                const dealii::LinearAlgebra::distributed::BlockVector<double> &in);
-
-      void copy(dealii::LinearAlgebra::distributed::BlockVector<double> &out,
-                const TrilinosWrappers::MPI::BlockVector &in);
-    }
-  }
-
-  /**
-   * This namespace contains all matrix-free operators used in the Stokes solver.
-   */
-  namespace MatrixFreeStokesOperators
-  {
-
-    /**
-     * This struct stores the data for the current linear operator that is required to perform
-     * matrix-vector products.
-     *
-     * The members of type Table<2, VectorizedArray<X>> contain values
-     * of type X, grouped by cell batch using the VectorizedArray. The
-     * table is indexed by the index of the cell batch and quadrature
-     * point index.  In other words, you can access the value by
-     * <tt>table(cell_batch_index, q_index)[cell_index]</tt>
-     */
-    template <int dim, typename number>
-    struct OperatorCellData
-    {
-      /**
-       * Information on the compressibility of the flow.
-       */
-      bool is_compressible;
-
-      /**
-       * Pressure scaling constant.
-       */
-      double pressure_scaling;
-
-      /**
-       * If true, Newton terms are part of the operator.
-       */
-      bool enable_newton_derivatives;
-
-      /**
-       * Symmetrize the Newton system when it's true (i.e., the
-       * stabilization is symmetric or SPD).
-       */
-      bool symmetrize_newton_system;
-
-      /**
-       * If true, apply the stabilization on free surface faces.
-       */
-      bool apply_stabilization_free_surface_faces;
-
-      /**
-       * Table which stores viscosity values for each cell.
-       *
-       * If the second dimension is of size 1, the viscosity is
-       * assumed to be constant per cell.
-       */
-      Table<2, VectorizedArray<number>> viscosity;
-
-      /**
-       * Table which stores the strain rate for each cell to be used
-       * for the Newton terms.
-       */
-      Table<2, SymmetricTensor<2, dim, VectorizedArray<number>>> strain_rate_table;
-
-      /**
-       * Table which stores the product of the following three
-       * variables: viscosity derivative with respect to pressure,
-       * the Newton derivative scaling factor, and the averaging weight.
-       */
-      Table<2, VectorizedArray<number>> newton_factor_wrt_pressure_table;
-
-      /**
-       * Table which stores the product of the following four
-       * variables: viscosity derivative with respect to strain rate,
-       * newton derivative scaling factor, alpha, and the averaging
-       * weight. Here alpha is the spd factor when the stabilization
-       * is PD or SPD, otherwise, it is 1.
-       */
-      Table<2, SymmetricTensor<2, dim, VectorizedArray<number>>>
-      newton_factor_wrt_strain_rate_table;
-
-      /**
-       * Table which stores the product of the pressure perturbation
-       * and the normalized gravity. The size is n_face_boundary * n_face_q_points,
-       * but only those on the free surface are computed and stored.
-       */
-      Table<2, Tensor<1, dim, VectorizedArray<number>>> free_surface_stabilization_term_table;
-
-      /**
-       * Boundary indicators of those boundaries with a free surface.
-       */
-      std::set<types::boundary_id> free_surface_boundary_indicators;
-
-      /**
-       * Determine an estimate for the memory consumption (in bytes) of this
-       * object.
-       */
-      std::size_t
-      memory_consumption() const;
-
-      /**
-       * Reset the object and free all memory
-       */
-      void clear();
-    };
-
-    /**
-     * Operator for the entire Stokes block.
-     */
-    template <int dim, int degree_v, typename number>
-    class StokesOperator
-      : public MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::BlockVector<number>>
-    {
-      public:
-
-        /**
-         * Constructor.
-         */
-        StokesOperator ();
-
-        /**
-         * Reset object.
-         */
-        void clear () override;
-
-        /**
-         * Pass in a reference to the problem data.
-         */
-        void set_cell_data (const OperatorCellData<dim,number> &data);
-
-        /**
-         * Computes the diagonal of the matrix. Since matrix-free operators have not access
-         * to matrix elements, we must apply the matrix-free operator to the unit vectors to
-         * recover the diagonal.
-         */
-        void compute_diagonal () override;
-
-      private:
-
-        /**
-         * Performs the application of the matrix-free operator. This function is called by
-         * vmult() functions MatrixFreeOperators::Base.
-         */
-        void apply_add (dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
-                        const dealii::LinearAlgebra::distributed::BlockVector<number> &src) const override;
-
-        /**
-         * Defines the application of the cell matrix.
-         */
-        void local_apply (const dealii::MatrixFree<dim, number> &data,
-                          dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
-                          const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
-                          const std::pair<unsigned int, unsigned int> &cell_range) const;
-
-        /**
-         * This function doesn't do anything, it's created to use the matrixfree loop.
-         */
-        void local_apply_face (const dealii::MatrixFree<dim, number> &data,
-                               dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
-                               const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
-                               const std::pair<unsigned int, unsigned int> &face_range) const;
-
-        /**
-         * Apply the stabilization on free surface faces.
-         */
-        void local_apply_boundary_face (const dealii::MatrixFree<dim, number> &data,
-                                        dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
-                                        const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
-                                        const std::pair<unsigned int, unsigned int> &face_range) const;
-
-        /**
-         * A pointer to the current cell data that contains viscosity and other required parameters per cell.
-         */
-        const OperatorCellData<dim,number> *cell_data;
-    };
-
-    /**
-     * Operator for the pressure mass matrix used in the block preconditioner
-     */
-    template <int dim, int degree_p, typename number>
-    class MassMatrixOperator
-      : public MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::Vector<number>>
-    {
-      public:
-
-        /**
-         * Constructor
-         */
-        MassMatrixOperator ();
-
-        /**
-         * Reset the object.
-         */
-        void clear () override;
-
-        /**
-         * Pass in a reference to the problem data.
-         */
-        void set_cell_data (const OperatorCellData<dim,number> &data);
-
-        /**
-         * Computes the diagonal of the matrix. Since matrix-free operators have not access
-         * to matrix elements, we must apply the matrix-free operator to the unit vectors to
-         * recover the diagonal.
-         */
-        void compute_diagonal () override;
-
-      private:
-
-        /**
-         * Performs the application of the matrix-free operator. This function is called by
-         * vmult() functions MatrixFreeOperators::Base.
-         */
-        void apply_add (dealii::LinearAlgebra::distributed::Vector<number> &dst,
-                        const dealii::LinearAlgebra::distributed::Vector<number> &src) const override;
-
-        /**
-         * Defines the application of the cell matrix.
-         */
-        void local_apply (const dealii::MatrixFree<dim, number> &data,
-                          dealii::LinearAlgebra::distributed::Vector<number> &dst,
-                          const dealii::LinearAlgebra::distributed::Vector<number> &src,
-                          const std::pair<unsigned int, unsigned int> &cell_range) const;
-
-
-        /**
-         * Computes the diagonal contribution from a cell matrix.
-         */
-        void local_compute_diagonal (const MatrixFree<dim,number>                     &data,
-                                     dealii::LinearAlgebra::distributed::Vector<number>  &dst,
-                                     const unsigned int                               &dummy,
-                                     const std::pair<unsigned int,unsigned int>       &cell_range) const;
-
-        /**
-         * A pointer to the current cell data that contains viscosity and other required parameters per cell.
-         */
-        const OperatorCellData<dim,number> *cell_data;
-    };
-
-    /**
-     * Operator for the A block of the Stokes matrix. The same class is used for both
-     * active and level mesh operators.
-     */
-    template <int dim, int degree_v, typename number>
-    class ABlockOperator
-      : public MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::Vector<number>>
-    {
-      public:
-
-        /**
-         * Constructor
-         */
-        ABlockOperator ();
-
-        /**
-         * Reset the operator.
-         */
-        void clear () override;
-
-        /**
-         * Pass in a reference to the problem data.
-         */
-        void set_cell_data (const OperatorCellData<dim,number> &data);
-
-        /**
-         * Computes the diagonal of the matrix. Since matrix-free operators have not access
-         * to matrix elements, we must apply the matrix-free operator to the unit vectors to
-         * recover the diagonal.
-         */
-        void compute_diagonal () override;
-
-        /**
-         * Manually set the diagonal inside the matrix-free object. This function is needed
-         * when using tangential constraints as the function compute_diagonal() cannot handle
-         * non-Dirichlet boundary conditions.
-         */
-        void set_diagonal (const dealii::LinearAlgebra::distributed::Vector<number> &diag);
-
-      private:
-        /**
-         * Defines the inner-most operator on a single cell batch with
-         * the loop over quadrature points.
-         */
-        void inner_cell_operation(FEEvaluation<dim,
-                                  degree_v,
-                                  degree_v+1,
-                                  dim,
-                                  number> &velocity) const;
-
-        /**
-         * Defines the operation on a single cell batch including
-         * load/store and calls inner_cell_operation().
-         */
-        void cell_operation(FEEvaluation<dim,
-                            degree_v,
-                            degree_v+1,
-                            dim,
-                            number> &velocity) const;
-
-        /**
-         * Performs the application of the matrix-free operator. This
-         * function is called by vmult() functions
-         * MatrixFreeOperators::Base.
-         */
-        void apply_add (dealii::LinearAlgebra::distributed::Vector<number> &dst,
-                        const dealii::LinearAlgebra::distributed::Vector<number> &src) const override;
-
-        /**
-         * Defines the application of the cell matrix.
-         */
-        void local_apply (const dealii::MatrixFree<dim, number> &data,
-                          dealii::LinearAlgebra::distributed::Vector<number> &dst,
-                          const dealii::LinearAlgebra::distributed::Vector<number> &src,
-                          const std::pair<unsigned int, unsigned int> &cell_range) const;
-
-        /**
-         * A pointer to the current cell data that contains viscosity and other required parameters per cell.
-         */
-        const OperatorCellData<dim,number> *cell_data;
-    };
-  }
-
-  /**
-   * Base class for the matrix free GMG solver for the Stokes system. The
-   * actual implementation is found inside StokesMatrixFreeHandlerImplementation below.
-   */
-  template <int dim>
-  class StokesMatrixFreeHandler
-  {
-    public:
-      /**
-       * virtual Destructor.
-       */
-      virtual ~StokesMatrixFreeHandler() = default;
-
-      /**
-       * Solves the Stokes linear system matrix-free. This is called
-       * by Simulator<dim>::solve_stokes().
-       */
-      virtual std::pair<double,double> solve()=0;
-
-      /**
-       * Allocates and sets up the members of the StokesMatrixFreeHandler. This
-       * is called by Simulator<dim>::setup_dofs()
-       */
-      virtual void setup_dofs()=0;
-
-      /**
-       * Perform various tasks to update the linear system to solve
-       * for. Note that we are not assembling a matrix (as this is a
-       * matrix-free algorithm), but we are evaluating the material
-       * model and storing the information necessary for a later call
-       * to solve().
-       */
-      virtual void assemble()=0;
-
-      /**
-       * Computes and sets the diagonal for both the mass matrix
-       * operator and the A-block operators on each level for the
-       * purpose of smoothing inside the multigrid v-cycle.
-       */
-      virtual void build_preconditioner()=0;
-
-      /**
-       * Declare parameters.
-       */
-      static
-      void declare_parameters (ParameterHandler &prm);
-
-      /**
-       * Return a reference to the DoFHandler that is used for velocity in
-       * the block GMG solver.
-       */
-      virtual const DoFHandler<dim> &
-      get_dof_handler_v () const = 0;
-
-      /**
-       * Return a reference to the DoFHandler that is used for pressure in
-       * the block GMG solver.
-       */
-      virtual const DoFHandler<dim> &
-      get_dof_handler_p () const = 0;
-
-      /**
-       * Return a reference to the DoFHandler that is used for the coefficient
-       * projection in the block GMG solver.
-       */
-      virtual const DoFHandler<dim> &
-      get_dof_handler_projection () const = 0;
-
-      /**
-       * Return a pointer to the object that describes the velocity DoF
-       * constraints for the block GMG Stokes solver.
-       */
-      virtual const AffineConstraints<double> &
-      get_constraints_v () const = 0;
-
-      /**
-       * Return a pointer to the object that describes the pressure DoF
-       * constraints for the block GMG Stokes solver.
-       */
-      virtual const AffineConstraints<double> &
-      get_constraints_p () const = 0;
-
-      /**
-       * Return a pointer to the MGTransfer object used for the A block
-       * of the block GMG Stokes solver.
-       */
-      virtual const MGTransferMF<dim,GMGNumberType> &
-      get_mg_transfer_A () const = 0;
-
-      /**
-       * Return a pointer to the MGTransfer object used for the Schur
-       * complement block of the block GMG Stokes solver.
-       */
-      virtual const MGTransferMF<dim,GMGNumberType> &
-      get_mg_transfer_S () const = 0;
-
-      /**
-       * Return the memory consumption in bytes that are used to store
-       * equation data like viscosity to be able to apply the operators.
-       */
-      virtual std::size_t get_cell_data_memory_consumption() const = 0;
-  };
-
-  /**
-   * Main class of the Matrix-free method. Here are all the functions for
-   * setup, assembly and solving the Stokes system.
-   *
-   * We need to derive from StokesMatrixFreeHandler to be able to introduce a
-   * second template argument for the degree of the Stokes finite
-   * element. This way, the main simulator does not need to know about the
-   * degree by using a pointer to the base class and we can pick the desired
-   * velocity degree at runtime.
-   */
-  template <int dim, int velocity_degree>
-  class StokesMatrixFreeHandlerImplementation: public StokesMatrixFreeHandler<dim>
-  {
-    public:
-      /**
-       * Initialize this class, allowing it to read in
-       * relevant parameters as well as giving it a reference to the
-       * Simulator that owns it, since it needs to make fairly extensive
-       * changes to the internals of the simulator.
-       */
-      StokesMatrixFreeHandlerImplementation(Simulator<dim> &, ParameterHandler &prm);
-
-      /**
-       * Destructor.
-       */
-      ~StokesMatrixFreeHandlerImplementation() override = default;
-
-      /**
-       * Solves the Stokes linear system matrix-free. This is called
-       * by Simulator<dim>::solve_stokes().
-       */
-      std::pair<double,double> solve() override;
-
-      /**
-       * Allocates and sets up the members of the StokesMatrixFreeHandler. This
-       * is called by Simulator<dim>::setup_dofs()
-       */
-      void setup_dofs() override;
-
-      /**
-       * Perform various tasks to update the linear system to solve
-       * for. Note that we are not assembling a matrix (as this is a
-       * matrix-free algorithm), but we are evaluating the material
-       * model and storing the information necessary for a later call
-       * to solve().
-       */
-      void assemble() override;
-
-      /**
-       * Computes and sets the diagonal for both the mass matrix operator and the A-block
-       * operators on each level for the purpose of smoothing inside the multigrid v-cycle.
-       */
-      void build_preconditioner() override;
-
-      /**
-       * Declare parameters. (No actual parameters at the moment).
-       */
-      static
-      void declare_parameters (ParameterHandler &prm);
-
-      /**
-       * Return a reference to the DoFHandler that is used for velocity in
-       * the block GMG solver.
-       */
-      const DoFHandler<dim> &
-      get_dof_handler_v () const override;
-
-      /**
-       * Return a reference to the DoFHandler that is used for pressure in
-       * the block GMG solver.
-       */
-      const DoFHandler<dim> &
-      get_dof_handler_p () const override;
-
-      /**
-       * Return a reference to the DoFHandler that is used for the coefficient
-       * projection in the block GMG solver.
-       */
-      const DoFHandler<dim> &
-      get_dof_handler_projection () const override;
-
-      /**
-       * Return a pointer to the object that describes the velocity DoF
-       * constraints for the block GMG Stokes solver.
-       */
-      const AffineConstraints<double> &
-      get_constraints_v () const override;
-
-      /**
-       * Return a pointer to the object that describes the pressure DoF
-       * constraints for the block GMG Stokes solver.
-       */
-      const AffineConstraints<double> &
-      get_constraints_p () const override;
-
-      /**
-       * Return a pointer to the MGTransfer object used for the A block
-       * of the block GMG Stokes solver.
-       */
-      const MGTransferMF<dim,GMGNumberType> &
-      get_mg_transfer_A () const override;
-
-      /**
-       * Return a pointer to the MGTransfer object used for the Schur
-       * complement block of the block GMG Stokes solver.
-       */
-      const MGTransferMF<dim,GMGNumberType> &
-      get_mg_transfer_S () const override;
-
-
-      /**
-       * Return the memory consumption in bytes that are used to store
-       * equation data like viscosity to be able to apply the operators.
-       */
-      std::size_t get_cell_data_memory_consumption() const override;
-
-    private:
-      /**
-       * Parse parameters.
-       */
-      void parse_parameters (ParameterHandler &prm);
-
-      /**
-       * Evaluate the MaterialModel to query information like the viscosity and
-       * project this viscosity to the multigrid hierarchy. Also queries
-       * other parameters like pressure scaling.
-       */
-      void evaluate_material_model();
-
-      /**
-       * Add correction to system RHS for non-zero boundary condition. See description in
-       * StokesMatrixFreeHandler::correct_stokes_rhs() for more information.
-       */
-      void correct_stokes_rhs();
-
-
-      Simulator<dim> &sim;
-
-      bool print_details;
-
-      /**
-       * If true, it will time the key components of this matrix-free implementation, such as
-       * vmult of different matrices, solver IDR with the cheap preconditioner, etc.
-       */
-      bool do_timings;
-
-      /**
-       * The max/min of the evaluated viscosities.
-       */
-      double minimum_viscosity;
-      double maximum_viscosity;
-
-      DoFHandler<dim> dof_handler_v;
-      DoFHandler<dim> dof_handler_p;
-      DoFHandler<dim> dof_handler_projection;
-
-      FESystem<dim> fe_v;
-      FESystem<dim> fe_p;
-      FESystem<dim> fe_projection;
-
-      /**
-       * Store the data for the Stokes operator (viscosity, etc.) for the active cells.
-       */
-      MatrixFreeStokesOperators::OperatorCellData<dim, GMGNumberType> active_cell_data;
-
-      /**
-       * Store the data for the Stokes operator (viscosity, etc.) for each multigrid level.
-       */
-      MGLevelObject<MatrixFreeStokesOperators::OperatorCellData<dim, GMGNumberType>> level_cell_data;
-
-      using StokesMatrixType = MatrixFreeStokesOperators::StokesOperator<dim,velocity_degree,double>;
-      using SchurComplementMatrixType = MatrixFreeStokesOperators::MassMatrixOperator<dim,velocity_degree-1,double>;
-      using ABlockMatrixType = MatrixFreeStokesOperators::ABlockOperator<dim,velocity_degree,double>;
-
-      using GMGSchurComplementMatrixType = MatrixFreeStokesOperators::MassMatrixOperator<dim,velocity_degree-1,GMGNumberType>;
-      using GMGABlockMatrixType = MatrixFreeStokesOperators::ABlockOperator<dim,velocity_degree,GMGNumberType>;
-
-      StokesMatrixType stokes_matrix;
-      ABlockMatrixType A_block_matrix;
-      SchurComplementMatrixType Schur_complement_block_matrix;
-
-      AffineConstraints<double> constraints_v;
-      AffineConstraints<double> constraints_p;
-
-      MGLevelObject<GMGABlockMatrixType> mg_matrices_A_block;
-      MGLevelObject<GMGSchurComplementMatrixType> mg_matrices_Schur_complement;
-
-      MGConstrainedDoFs mg_constrained_dofs_A_block;
-      MGConstrainedDoFs mg_constrained_dofs_Schur_complement;
-      MGConstrainedDoFs mg_constrained_dofs_projection;
-
-      MGTransferMF<dim,GMGNumberType> mg_transfer_A_block;
-      MGTransferMF<dim,GMGNumberType> mg_transfer_Schur_complement;
-
-      std::vector<std::shared_ptr<MatrixFree<dim,double>>> matrix_free_objects;
-  };
-}
-
-
-#endif
diff --git a/include/aspect/structured_data.h.bak b/include/aspect/structured_data.h.bak
deleted file mode 100644
index cc569e1c2a2..00000000000
--- a/include/aspect/structured_data.h.bak
+++ /dev/null
@@ -1,778 +0,0 @@
-/*
-  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_structured_data_h
-#define _aspect_structured_data_h
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-
-#include <array>
-
-namespace aspect
-{
-  namespace Utilities
-  {
-    using namespace dealii;
-
-    /**
-     * StructuredDataLookup (formerly AsciiDataLookup) represents structured
-     * data that can be read from files including in ascii format.
-     *
-     * For ascii files the files need to be formatted as follows:
-     * Note the required format of the input data: The first lines may contain
-     * any number of comments if they begin with '#', but one of these lines
-     * needs to contain the number of grid points in each dimension as for
-     * example '# POINTS: 3 3'. The comments can optionally be followed by a
-     * single line, which does not start with '#', containing the names of
-     * the data columns.
-     * The order of the following data columns has to be
-     * 'coordinates data' with @p dim coordinate columns and @p components
-     * data columns. Note that the data in the input files need to be sorted
-     * in a specific order: the first coordinate needs to ascend first,
-     * followed by the second and so on in order to assign the correct data to
-     * the prescribed coordinates. The coordinates do not need to be
-     * equidistant.
-     */
-    template <int dim>
-    class StructuredDataLookup
-    {
-      public:
-        /**
-         * Constructor that explicitly prescribes the number of data columns
-         * in the data file. If a list of data components is provided in the
-         * data file it is checked that the length of this list is consistent
-         * with this number of components. This constructor is mostly provided
-         * for backwards compatibility. Not prescribing the number of components
-         * and instead reading them from the input file allows for more
-         * flexible files.
-         */
-        StructuredDataLookup(const unsigned int n_components,
-                             const double scale_factor);
-
-        /**
-         * This constructor relies on the list of column names at the beginning
-         * of the model file to determine the number of data components,
-         * therefore when using this constructor it is necessary to provide
-         * this list in the first uncommented line of the data file.
-         */
-        explicit StructuredDataLookup(const double scale_factor);
-
-        /**
-         * Replace the data stored in this class by the data given to this function.
-         *
-         * @note This is a manual way to fill the data. Consider load_file() if your data
-         * is stored in a txt/csv file.
-         *
-         * The data consists of @p n_components (implicitly given by the size of @p column_names)
-         * specified at @p coordinate_values[d] points in each of the dim coordinate directions @p d.
-         *
-         * The data in @p data_table consists of a Table for each of the @p n_components components.
-         *
-         * The `coordinate_values` and `data_table` arguments are rvalue references,
-         * and the function will move the data so provided into another storage
-         * location. In other words, after the call, the variables passed as the
-         * second and third arguments may be empty or otherwise altered.
-         *
-         * This class
-         * is able to share data between processes located on the same
-         * machine if the last argument `root_process` is
-         * set to anything other than `numbers::invalid_unsigned_int`. Then only the
-         * indicated root process within the given MPI communicator needs to
-         * pass in valid arguments whereas on all other processes the values
-         * of `column_names`, `coordinate_values`, and `data_table` are
-         * ignored. Instead, the indicated root process will make sure that
-         * the other processes obtain valid data, for example by sharing
-         * data tables in shared memory spaces. This reduces both the
-         * computational effort in reading data from disk and parsing it on
-         * all processes, and can vastly reduce the amount of memory required
-         * on machines where many processor cores have access to shared memory
-         * resources.
-         *
-         * If `root_process` equals `numbers::invalid_unsigned_int`, then
-         * every process needs to pass data for all arguments and the
-         * `mpi_communicator` argument is ignored.
-         */
-        void reinit(const std::vector<std::string> &column_names,
-                    std::vector<std::vector<double>> &&coordinate_values,
-                    std::vector<Table<dim,double>> &&data_table,
-                    const MPI_Comm mpi_communicator = MPI_COMM_SELF,
-                    const unsigned int root_process = numbers::invalid_unsigned_int);
-
-        /**
-         * Loads a data text file replacing the current data.
-         *
-         * Throws an exception if the file does not
-         * exist, if the data file format is incorrect, or if the file data
-         * like the number and names of columns change (if this class contains
-         * existing data for example when used with a collection of ascii files
-         * changing over the simulation time).
-         *
-         * This function supports normal text / ASCII files that can optionally
-         * be compressed using .gz. If the given filename is a URL and libDAB
-         * support is enabled, the data is downloaded and parsed from the ASCII
-         * data received.
-         *
-         * This function uses the given MPI communicator to only load the data on
-         * rank 0 and broadcasting the information to all other ranks.
-         */
-        void
-        load_ascii(const std::string &filename,
-                   const MPI_Comm communicator);
-
-        /**
-         * Fill the current object with data read from a NetCDF file
-         * with filename @p filename. This call will fail if ASPECT is not
-         * configured with NetCDF support.
-         *
-         * @p data_column_names specifies the list of data columns to load (in the specified order). If
-         * an empty vector is passed, all columns will be loaded.
-         */
-        void
-        load_netcdf(const std::string &filename, const std::vector<std::string> &data_column_names = {});
-
-
-        /**
-         * Loads data from a file replacing the current data.
-         *
-         * Throws an exception if the file does not
-         * exist, if the data file format is incorrect, or if the file data
-         * like the number and names of columns change (if this class contains
-         * existing data for example when used with a collection of ascii files
-         * changing over the simulation time).
-         *
-         * The following formats are currently supported:
-         * - ASCII files (typically ending in .txt)
-         * - gzip compressed ASCII files (ending in .gz)
-         * - URLs starting with "http" (handled by libDAB)
-         */
-        void
-        load_file(const std::string &filename,
-                  const MPI_Comm communicator);
-
-        /**
-         * Returns the computed data (velocity, temperature, etc. - according
-         * to the used plugin) in Cartesian coordinates.
-         *
-         * @param position The current position to compute the data (velocity,
-         * temperature, etc.)
-         * @param component The index (starting at 0) of the data column to be
-         * returned. The index is therefore less than the number of data
-         * columns in the data file (or specified in the constructor).
-         */
-        double
-        get_data(const Point<dim> &position,
-                 const unsigned int component) const;
-
-        /**
-         * Returns the gradient of the function based on the bilinear
-         * interpolation of the data (velocity, temperature, etc. - according
-         * to the used plugin) in Cartesian coordinates.
-         *
-         * @param position The current position to compute the data (velocity,
-         * temperature, etc.)
-         * @param component The index of the data column to be returned.
-         */
-        Tensor<1,dim>
-        get_gradients(const Point<dim> &position,
-                      const unsigned int component);
-
-        /**
-         * Returns a vector that contains the names of all data columns in the
-         * order of their appearance in the data file (and their order in the
-         * memory data table). Returns an empty vector if no names are provided
-         * or the file is not read in yet.
-         */
-        std::vector<std::string>
-        get_column_names() const;
-
-        /**
-         * Returns whether the stored coordinates are equidistant. If
-         * coordinates are equidistant the lookup is more efficient. Returns
-         * false if no coordinates are loaded at the moment.
-         */
-        bool
-        has_equidistant_coordinates() const;
-
-        /**
-         * Returns the coordinates of the interpolation points at which data is
-         * stored. This function can be used to determine the number of data
-         * points in each of the coordinate directions, or to query
-         * data only at exactly the positions at which they are available (avoiding
-         * interpolation).
-         *
-         * @param dimension The spatial direction for which to return the data
-         * coordinates, e.g. 0 for $x$-direction, 1 for $y$-direction, or equivalent
-         * values if your data coordinates are other dimensions such as
-         * temperature, pressure.
-         */
-        const std::vector<double> &
-        get_interpolation_point_coordinates(const unsigned int dimension) const;
-
-        /**
-         * Returns the column index of a column with the given name
-         * @p column_name. Throws an exception if no such
-         * column exists or no names were provided in the file.
-         */
-        unsigned int
-        get_column_index_from_name(const std::string &column_name) const;
-
-        /**
-         * Returns a string that contains the name of the column with index
-         * @p column_index. Throws an exception if no such
-         * column exists or no name was provided in the file.
-         */
-        std::string
-        get_column_name_from_index(const unsigned int column_index) const;
-
-        /**
-         * Return the maximum value of the component values.
-         */
-        double get_maximum_component_value(const unsigned int component) const;
-
-      private:
-        /**
-         * The number of data components read in (=columns in the data file).
-         */
-        unsigned int n_components;
-
-        /**
-         * The names of the data components in the columns of the read file.
-         * Does not contain any strings if none are provided in the first
-         * uncommented line of the file.
-         */
-        std::vector<std::string> data_component_names;
-
-        /**
-         * Interpolation functions to access the data.
-         * Either InterpolatedUniformGridData or InterpolatedTensorProductGridData;
-         * the type is determined from the grid specified in the data file.
-         */
-        std::vector<std::unique_ptr<Function<dim>>> data;
-
-        /**
-         * The coordinate values in each direction as specified in the data file.
-         */
-        std::array<std::vector<double>,dim> coordinate_values;
-
-        /**
-         * The maximum value of each component
-         */
-        std::vector<double> maximum_component_value;
-
-        /**
-         * Number of points in the data grid as specified in the data file.
-         */
-        TableIndices<dim> table_points;
-
-        /**
-         * Scales the data boundary condition by a scalar factor. Can be used
-         * to transform the unit of the data.
-         */
-        const double scale_factor;
-
-        /**
-         * Stores whether the coordinate values are equidistant or not,
-         * this determines the type of data function stored.
-         */
-        bool coordinate_values_are_equidistant;
-
-        /**
-         * Computes the table indices given the size @p sizes of the
-         * entry with index @p idx.
-         */
-        TableIndices<dim>
-        compute_table_indices(const TableIndices<dim> &sizes, const std::size_t idx) const;
-
-    };
-
-    /**
-     * AsciDataBase is a generic plugin used for declaring and reading the
-     * parameters from the parameter file.
-     */
-    template <int dim>
-    class AsciiDataBase
-    {
-      public:
-        /**
-         * Constructor
-         */
-        AsciiDataBase();
-
-        /**
-         * Declare the parameters all derived classes take from input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler  &prm,
-                            const std::string &default_directory,
-                            const std::string &default_filename,
-                            const std::string &subsection_name = "Ascii data model");
-
-        /**
-         * Read the parameters from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm,
-                          const std::string &subsection_name = "Ascii data model");
-
-        /**
-         * Directory in which the data files are present.
-         */
-        std::string data_directory;
-
-        /**
-         * Filename of data file. The file names can contain the specifiers %s
-         * and/or %c (in this order), meaning the name of the boundary and the
-         * number of the data file time step.
-         */
-        std::string data_file_name;
-
-        /**
-         * Scale the data by a scalar factor. Can be used to transform the
-         * unit of the data (if they are not specified in SI units (m/s or
-         * m/yr depending on the "Use years in output instead of seconds"
-         * parameter).
-         */
-        double scale_factor;
-    };
-
-    /**
-     * A base class that implements boundary conditions determined from a
-     * AsciiData input file.
-     */
-    template <int dim>
-    class AsciiDataBoundary : public Utilities::AsciiDataBase<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor
-         */
-        AsciiDataBoundary();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        virtual
-        void
-        initialize (const std::set<types::boundary_id> &boundary_ids,
-                    const unsigned int components);
-
-        /**
-         * A function that is called at the beginning of each time step. For
-         * the current plugin, this function loads the next data files if
-         * necessary and outputs a warning if the end of the set of data files
-         * is reached.
-         */
-        void
-        update();
-
-        /**
-         * Returns the data component at the given position.
-         */
-        double
-        get_data_component (const types::boundary_id             boundary_indicator,
-                            const Point<dim>                    &position,
-                            const unsigned int                   component) const;
-
-        /**
-         * Returns the maximum value of the given data component.
-         */
-        double
-        get_maximum_component_value (const types::boundary_id boundary_indicator,
-                                     const unsigned int       component) const;
-
-        /**
-         * Return the gradients of the parameters from the parameter file.
-         */
-        Tensor<1,dim-1>
-        vector_gradient(const types::boundary_id boundary_indicator,
-                        const Point<dim>        &p,
-                        const unsigned int       component) const;
-
-        /**
-         * Declare the parameters all derived classes take from input files.
-         *
-         * @param prm The parameter handler in which the parameters are declared.
-         * @param default_directory The default value for the data directory parameter.
-         * @param default_filename The default value for the filename parameter.
-         * @param subsection_name The name of the parameter file subsection all
-         * parameters will be declared in. The function will enter this subsection,
-         * declare all parameters, then leave this subsection, to return @p prm in
-         * the same subsection it was in before.
-         * @param declare_time_dependent_parameters Whether to declare the parameter
-         * that are only needed for time dependent AsciiDataBoundary objects. If
-         * the caller already knows time dependence is not supported for the current
-         * application, disabling this parameter avoids introducing these parameters
-         * to the parameter handler.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler  &prm,
-                            const std::string &default_directory,
-                            const std::string &default_filename,
-                            const std::string &subsection_name = "Ascii data model",
-                            const bool declare_time_dependent_parameters = true);
-
-        /**
-         * Read the parameters from the parameter file.
-         *
-         * @param prm The parameter handler from which the parameters are parsed.
-         * @param subsection_name The name of the parameter file subsection all
-         * parameters will be parsed from. The function will enter this subsection,
-         * parse all parameters, then leave this subsection, to return @p prm in
-         * the same subsection it was in before.
-         * @param parse_time_dependent_parameters Whether to parse the parameter
-         * that are only needed for time dependent AsciiDataBoundary objects. This
-         * parameter always needs to be set to the same value that was handed over
-         * to declare_parameters().
-         */
-        void
-        parse_parameters (ParameterHandler &prm,
-                          const std::string &subsection_name = "Ascii data model",
-                          const bool parse_time_dependent_parameters = true);
-
-      protected:
-        /**
-         * A variable that stores the currently used data file of a series. It
-         * gets updated if necessary by update().
-         */
-        int current_file_number;
-
-        /**
-         * Number of the first data file to be loaded when the model time is
-         * larger than 'First data file model time'.
-         */
-        int first_data_file_number;
-
-        /**
-         * In some cases the boundary files are not numbered in increasing but
-         * in decreasing order (e.g. 'Ma BP'). If this flag is set to 'True'
-         * the plugin will first load the file with the number 'First data
-         * file number' and decrease the file number during the model run.
-         */
-        bool decreasing_file_order;
-
-        /**
-         * Time in model units (depends on other model inputs) between two
-         * data files.
-         */
-        double data_file_time_step;
-
-        /**
-         * Weight between data file n and n+1 while the current time is
-         * between the two values t(n) and t(n+1).
-         */
-        double time_weight;
-
-        /**
-         * State whether we have time_dependent boundary conditions. Switched
-         * off after finding no more data files to suppress attempts to read
-         * in new files.
-         */
-        bool time_dependent;
-
-        /**
-         * Map between the boundary id and an object that reads and processes
-         * data we get from text files.
-         */
-        std::map<types::boundary_id,
-            std::unique_ptr<aspect::Utilities::StructuredDataLookup<dim-1>>> lookups;
-
-        /**
-         * Map between the boundary id and the old data objects.
-         */
-        std::map<types::boundary_id,
-            std::unique_ptr<aspect::Utilities::StructuredDataLookup<dim-1>>> old_lookups;
-
-        /**
-         * Handles the update of the data in lookup.
-         */
-        void
-        update_data (const types::boundary_id boundary_id,
-                     const bool reload_both_files);
-
-        /**
-         * Handles settings and user notification in case the time-dependent
-         * part of the boundary condition is over.
-         */
-        void
-        end_time_dependence ();
-
-        /**
-         * Create a filename out of the name template.
-         */
-        std::string
-        create_filename (const int filenumber,
-                         const types::boundary_id boundary_id) const;
-    };
-
-
-
-    /**
-     * A base class that implements initial conditions determined from a
-     * AsciiData input file.
-     */
-    template <int dim>
-    class AsciiDataInitial : public Utilities::AsciiDataBase<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor
-         */
-        AsciiDataInitial();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        virtual
-        void
-        initialize (const unsigned int components);
-
-
-        /**
-         * Returns the data component at the given position.
-         */
-        double
-        get_data_component (const Point<dim> &position,
-                            const unsigned int component) const;
-
-        /**
-         * Declare the parameters all derived classes take from input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler  &prm,
-                            const std::string &default_directory,
-                            const std::string &default_filename,
-                            const std::string &subsection_name = "Ascii data model");
-
-        /**
-         * Read the parameters from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm,
-                          const std::string &subsection_name = "Ascii data model");
-
-      protected:
-        /**
-         * Pointer to an object that reads and processes data we get from text
-         * files.
-         */
-        std::unique_ptr<aspect::Utilities::StructuredDataLookup<dim>> lookup;
-
-        /**
-         * Pointer to an object that reads and processes data we get from text
-         * files if the current model is a slice of the input file (e.g. a 2D
-         * model and a 3D data file).
-         */
-        std::unique_ptr<aspect::Utilities::StructuredDataLookup<3>> slice_lookup;
-
-        /**
-         * Whether to use a dataset that has the same spatial dimensions as
-         * the model or not. If true only a 2D slice of a 3D dataset is used.
-         */
-        bool slice_data;
-
-        /**
-         * The matrix that describes the rotation by which a 2D model
-         * needs to be transformed to a plane that contains the origin and
-         * the two prescribed points given in the input.
-         */
-        Tensor<2,3> rotation_matrix;
-    };
-
-
-    /**
-     * A base class that implements conditions determined from a
-     * layered AsciiData input file.
-     */
-    template <int dim>
-    class AsciiDataLayered : public Utilities::AsciiDataBase<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor
-         */
-        AsciiDataLayered();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        virtual
-        void
-        initialize (const unsigned int components);
-
-
-        /**
-         * Returns the data component at the given position.
-         */
-        double
-        get_data_component (const Point<dim> &position,
-                            const unsigned int component) const;
-
-
-        /**
-         * Declare the parameters all derived classes take from input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler  &prm,
-                            const std::string &default_directory,
-                            const std::string &default_filename,
-                            const std::string &subsection_name = "Ascii data model");
-
-        /**
-         * Read the parameters from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm,
-                          const std::string &subsection_name = "Ascii data model");
-
-      protected:
-        /**
-         * Pointer to an object that reads and processes data we get from text
-         * files.
-         */
-        std::vector<std::unique_ptr<aspect::Utilities::StructuredDataLookup<dim-1>>> lookups;
-
-      private:
-
-        /**
-         * Directory in which the data files are present.
-         */
-        std::string data_directory;
-
-        /**
-         * Filenames of data files.
-         */
-        std::vector<std::string> data_file_names;
-
-        /**
-         * Number of layer boundaries in the model.
-         */
-        unsigned int number_of_layer_boundaries;
-
-        /**
-         * Interpolation scheme for profile averaging.
-         */
-        std::string interpolation_scheme;
-
-
-    };
-
-
-    /**
-     * A base class that reads in a data profile and provides its values.
-     */
-    template <int dim>
-    class AsciiDataProfile : public Utilities::AsciiDataBase<dim>
-    {
-      public:
-        /**
-         * Constructor
-         */
-        AsciiDataProfile();
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program. Checks preconditions.
-         */
-        virtual
-        void
-        initialize (const MPI_Comm communicator);
-
-
-        /**
-         * Returns the data component at the given position.
-         */
-        double
-        get_data_component (const Point<1>                      &position,
-                            const unsigned int                   component) const;
-
-        /**
-         * Returns a vector that contains the names of all data columns in the
-         * order of their appearance in the data file (and their order in the
-         * memory data table). Returns an empty vector if no names are provided
-         * or the file is not read in yet.
-         */
-        std::vector<std::string>
-        get_column_names() const;
-
-        /**
-         * Returns the coordinates of the interpolation points at which data is
-         * stored. This function can be used to determine the number of data
-         * points in each of the coordinate directions, or to query
-         * data only at exactly the positions at which they are available (avoiding
-         * interpolation).
-         *
-         * Because this class represents a one-dimensional profile, the returned
-         * values correspond to the values of the sole coordinate of the
-         * interpolation points, in contrast to the
-         * StructuredDataLookup::get_interpolation_point_coordinates()
-         * function that takes an integer argument indicating which coordinate
-         * is to be selected.
-         */
-        const std::vector<double> &
-        get_interpolation_point_coordinates() const;
-
-        /**
-         * Returns the column index of a column with the given name
-         * @p column_name. Throws an exception if no such
-         * column exists or no names were provided in the file.
-         */
-        unsigned int
-        get_column_index_from_name(const std::string &column_name) const;
-
-        /**
-         * Returns the column index of a column with the given name
-         * @p column_name. Returns an invalid unsigned int if no such
-         * column exists or no names were provided in the file.
-         */
-        unsigned int
-        maybe_get_column_index_from_name(const std::string &column_name) const;
-
-        /**
-         * Returns a string that contains the name of the column with index
-         * @p column_index. Returns an empty string if no such
-         * column exists or no name was provided in the file.
-         */
-        std::string
-        get_column_name_from_index(const unsigned int column_index) const;
-      protected:
-        /**
-         * Pointer to an object that reads and processes data we get from text
-         * files.
-         */
-        std::unique_ptr<aspect::Utilities::StructuredDataLookup<1>> lookup;
-    };
-
-
-
-    template <int dim>
-    using AsciiDataLookup DEAL_II_DEPRECATED = StructuredDataLookup<dim>;
-  }
-}
-
-#endif
diff --git a/include/aspect/termination_criteria/end_step.h.bak b/include/aspect/termination_criteria/end_step.h.bak
deleted file mode 100644
index 24b3e0570af..00000000000
--- a/include/aspect/termination_criteria/end_step.h.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_termination_criteria_end_step_h
-#define _aspect_termination_criteria_end_step_h
-
-#include <aspect/termination_criteria/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-
-    /**
-     * A class that terminates the simulation when a specified end timestep is
-     * reached.
-     *
-     * @ingroup TerminationCriteria
-     */
-    template <int dim>
-    class EndStep : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate this termination criterion.
-         *
-         * @return Whether to terminate the simulation (true) or continue
-         * (false).
-         */
-        bool
-        execute () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        unsigned int end_step;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/termination_criteria/end_time.h.bak b/include/aspect/termination_criteria/end_time.h.bak
deleted file mode 100644
index 9205bdae7d7..00000000000
--- a/include/aspect/termination_criteria/end_time.h.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_termination_criteria_end_time_h
-#define _aspect_termination_criteria_end_time_h
-
-#include <aspect/termination_criteria/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-
-    /**
-     * A class that terminates the simulation when a specified end time is
-     * reached.
-     *
-     * @ingroup TerminationCriteria
-     */
-    template <int dim>
-    class EndTime : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Check this termination criterion and possibly reduce time step size
-         */
-        double check_for_last_time_step (const double time_step) const override;
-
-        /**
-         * Evaluate this termination criterion.
-         *
-         * @return Whether to terminate the simulation (true) or continue
-         * (false).
-         */
-        bool
-        execute () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        double end_time;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/termination_criteria/end_walltime.h.bak b/include/aspect/termination_criteria/end_walltime.h.bak
deleted file mode 100644
index c8c1076cf1b..00000000000
--- a/include/aspect/termination_criteria/end_walltime.h.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019- 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_termination_criteria_end_walltime_h
-#define _aspect_termination_criteria_end_walltime_h
-
-#include <aspect/termination_criteria/interface.h>
-#include <aspect/simulator.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-
-    /**
-     * A class that terminates the simulation when a specified end time is
-     * reached.
-     *
-     * @ingroup TerminationCriteria
-     */
-    template <int dim>
-    class EndWalltime : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Evaluate this termination criterion.
-         *
-         * @return Whether to terminate the simulation (true) or continue
-         * (false).
-         */
-        bool
-        execute () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The maximum walltime duration in seconds. The program will be terminated
-         * once this value is reached.
-         */
-        unsigned int walltime_duration;
-
-        /**
-         * The start_walltime is not stored into checkpoint, so it will get reset at restart.
-         * Make start_walltime as a static variable that it gets initialized pretty much
-         * right away as the program starts, rather than several seconds in once we get
-         * to creating the plugin. It gives better estimate of the actual start time.
-         */
-        static std::time_t start_walltime;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/termination_criteria/interface.h.bak b/include/aspect/termination_criteria/interface.h.bak
deleted file mode 100644
index 8306819eab6..00000000000
--- a/include/aspect/termination_criteria/interface.h.bak
+++ /dev/null
@@ -1,244 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_termination_criteria_interface_h
-#define _aspect_termination_criteria_interface_h
-
-#include <aspect/global.h>
-#include <aspect/plugins.h>
-
-#include <memory>
-#include <deal.II/base/parameter_handler.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim> class Simulator;
-
-
-  /**
-   * A namespace for everything to do with determining criteria for
-   * terminating the simulation gracefully. This does not include termination
-   * due to errors.
-   *
-   * @ingroup TerminationCriteria
-   */
-  namespace TerminationCriteria
-  {
-
-    /**
-     * This class declares the public interface of termination criteria
-     * plugins. These plugins must implement a function that can be called
-     * each time step to determine if specific criteria have been met that
-     * mean the simulation should be ended gracefully.
-     *
-     * Access to the data of the simulator is granted by the @p protected
-     * member functions of the SimulatorAccess class, i.e., classes
-     * implementing this interface will in general want to derive from both
-     * this Interface class as well as from the SimulatorAccess class if they
-     * need to find out about the state of the simulation.
-     *
-     * @ingroup TerminationCriteria
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Execute evaluation of the termination criterion.
-         *
-         * @return Whether to terminate the simulation (true) or continue
-         * (false).
-         *
-         * @note For some kinds of termination plugins, it may be difficult to
-         * ensure that all processors come to the same conclusion. An example
-         * is one that terminates the simulation after a certain amount of CPU
-         * time has expired, and this may be different from MPI process to MPI
-         * process. To avoid difficult to deal with situations, the plugin
-         * manager only requires that a single processor returns
-         * <code>true</code> for a given plugin to record that the plugin
-         * wants to terminate the simulation, even if the other processors
-         * return false.
-         */
-        virtual
-        bool
-        execute () = 0;
-
-        /**
-         * Check for last time step and if so reduce the time step to user
-         * specified end time
-         *
-         * @return Reduced or current time step size
-         *
-         * @note A reduced time step size may be returned for the last time
-         * step. For all other time steps, the current time step size
-         * (provided as argument) will be returned. The returned time step
-         * size will be greater than zero, and less than or equal to the given
-         * argument put into this function.
-         */
-        virtual double check_for_last_time_step (const double time_step) const;
-    };
-
-
-
-
-
-
-    /**
-     * A class that manages all objects that provide functionality to specify
-     * termination criteria.
-     *
-     * @ingroup TerminationCriteria
-     */
-    template <int dim>
-    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Execute all of the termination criteria objects that have been
-         * requested in the input file.
-         *
-         * The function returns a bool indicating whether the simulation should be
-         * terminated.
-         *
-         * To avoid undefined situations, this function only requires that a
-         * single processor's termination request comes back positive for a
-         * given plugin. In other words, for each plugin selected, not all
-         * processors need to return the same value: if only one of the says
-         * that the simulation should be terminated, then this is enough.
-         */
-        virtual
-        bool
-        execute () const;
-
-        /**
-         * Check all of the termination criteria objects that have been
-         * requested in the input file for criteria regarding last time step
-         * and if so get the minimum of these values.
-         *
-         * @return Reduced or current time step size
-         *
-         * @note A reduced time step size may be returned for the last time
-         * step. For all other time steps, the current time step size
-         * (provided as argument) will be returned. The returned time step
-         * size will be greater than zero, and less than or equal to the given
-         * argument put into this function.
-         */
-        double check_for_last_time_step (const double time_step) const;
-
-        /**
-         * Declare the parameters of all known termination criteria plugins,
-         * as well as of ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which termination criteria objects will be created;
-         * then let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * A function that is used to register termination criteria objects in
-         * such a way that the Manager can deal with all of them without
-         * having to know them by name. This allows the files in which
-         * individual plugins are implement to register these plugins, rather
-         * than also having to modify the Manager class by adding the new
-         * termination criteria class.
-         *
-         * @param name The name under which this plugin is to be called in
-         * parameter files.
-         * @param description A text description of what this model does and
-         * that will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that
-         * declares the parameters for this plugin.
-         * @param factory_function A pointer to a function that creates such a
-         * termination criterion object and returns a pointer to it.
-         */
-        static
-        void
-        register_termination_criterion (const std::string &name,
-                                        const std::string &description,
-                                        void (*declare_parameters_function) (ParameterHandler &),
-                                        std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-        /**
-         * Exception.
-         */
-        DeclException1 (ExcTerminationCriteriaNameNotFound,
-                        std::string,
-                        << "Could not find entry <"
-                        << arg1
-                        << "> among the names of registered termination criteria objects.");
-      private:
-        /**
-         * A list of names corresponding to the termination criteria in the
-         * termination_objects.
-         */
-        std::list<std::string>                       termination_obj_names;
-    };
-
-
-
-    /**
-     * Given a class name, a name, and a description for the parameter file
-     * for a termination criterion object, register it with the
-     * aspect::TerminationCriteria::Manager class.
-     *
-     * @ingroup TerminationCriteria
-     */
-#define ASPECT_REGISTER_TERMINATION_CRITERION(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_TERMINATION_CRITERION_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::TerminationCriteria::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::TerminationCriteria::Manager<2>::register_termination_criterion, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::TerminationCriteria::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::TerminationCriteria::Manager<3>::register_termination_criterion, \
-                                name, description); \
-  }
-  }
-}
-
-
-#endif
diff --git a/include/aspect/termination_criteria/steady_heat_flux.h.bak b/include/aspect/termination_criteria/steady_heat_flux.h.bak
deleted file mode 100644
index 88f3cd3d782..00000000000
--- a/include/aspect/termination_criteria/steady_heat_flux.h.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_termination_criteria_steady_heat_flux_h
-#define _aspect_termination_criteria_steady_heat_flux_h
-
-#include <aspect/termination_criteria/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    /**
-     * A class that implements a termination criterion based on the steady state
-     * of the average heat flux.
-     *
-     * @ingroup TerminationCriteria
-     */
-    template <int dim>
-    class SteadyHeatFlux : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate this termination criterion.
-         *
-         * @return Whether to terminate the simulation (true) or continue
-         * (false).
-         */
-        bool
-        execute () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The minimum length of simulation time that the system
-         * should be in steady state before termination.
-         */
-        double necessary_time_in_steady_state;
-
-        /**
-         * The maximum relative deviation of the heat flux in recent
-         * simulation time for the system to be considered in steady state.
-         */
-        double allowed_relative_deviation;
-
-        /**
-         * A set of boundary ids on which the average heat flux will be
-         * computed.
-         */
-        std::set<types::boundary_id> boundary_indicators;
-
-        /**
-         * A list of pairs (time, heat flux) that we have computed at
-         * previous time steps. This is used to determine when we have reached
-         * steady state.
-         */
-        std::list<std::pair<double, double>>   time_heat_flux;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/termination_criteria/steady_rms_velocity.h.bak b/include/aspect/termination_criteria/steady_rms_velocity.h.bak
deleted file mode 100644
index 00a23c9e132..00000000000
--- a/include/aspect/termination_criteria/steady_rms_velocity.h.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_termination_criteria_steady_rms_velocity_h
-#define _aspect_termination_criteria_steady_rms_velocity_h
-
-#include <aspect/termination_criteria/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-
-    /**
-     * A class that implements a termination criterion based on steady state
-     * of the root mean square of the velocity field.
-     *
-     * @ingroup TerminationCriteria
-     */
-    template <int dim>
-    class SteadyRMSVelocity : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate this termination criterion.
-         *
-         * @return Whether to terminate the simulation (true) or continue
-         * (false).
-         */
-        bool
-        execute () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        double                                  time_length;
-        double                                  relative_deviation;
-
-        /**
-         * A list of pairs (time, rms_velocity) that we have computed at
-         * previous time steps. This is used to determine when we have reached
-         * steady state.
-         */
-        std::list<std::pair<double, double>>   time_rmsvel;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/termination_criteria/steady_temperature.h.bak b/include/aspect/termination_criteria/steady_temperature.h.bak
deleted file mode 100644
index 922df3795ab..00000000000
--- a/include/aspect/termination_criteria/steady_temperature.h.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-  Copyright (C) 2019 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_termination_criteria_steady_temperature_h
-#define _aspect_termination_criteria_steady_temperature_h
-
-#include <aspect/termination_criteria/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    /**
-     * A class that implements a termination criterion based on the steady state
-     * of the average temperature.
-     *
-     * @ingroup TerminationCriteria
-     */
-    template <int dim>
-    class SteadyTemperature : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate this termination criterion.
-         *
-         * @return Whether to terminate the simulation (true) or continue
-         * (false).
-         */
-        bool
-        execute () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        double                                  necessary_time_in_steady_state;
-        double                                  allowed_relative_deviation;
-
-        /**
-         * A list of pairs (time, temperature) that we have computed at
-         * previous time steps. This is used to determine when we have reached
-         * steady state.
-         */
-        std::list<std::pair<double, double>>   time_temperature;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/termination_criteria/user_request.h.bak b/include/aspect/termination_criteria/user_request.h.bak
deleted file mode 100644
index 245ad1926e3..00000000000
--- a/include/aspect/termination_criteria/user_request.h.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_termination_criteria_user_request_h
-#define _aspect_termination_criteria_user_request_h
-
-#include <aspect/termination_criteria/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-
-    /**
-     * A class that terminates the simulation when a specified file appears in
-     * the working directory. This allows the user to gracefully exit the
-     * simulation at any time.
-     *
-     * @ingroup TerminationCriteria
-     */
-    template <int dim>
-    class UserRequest : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Evaluate this termination criterion.
-         *
-         * @return Whether to terminate the simulation (true) or continue
-         * (false).
-         */
-        bool
-        execute () override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        std::string             filename_to_test;
-    };
-  }
-}
-
-#endif
diff --git a/include/aspect/time_stepping/conduction_time_step.h.bak b/include/aspect/time_stepping/conduction_time_step.h.bak
deleted file mode 100644
index 38101bca10e..00000000000
--- a/include/aspect/time_stepping/conduction_time_step.h.bak
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_time_stepping_conduction_time_step_h
-#define _aspect_time_stepping_conduction_time_step_h
-
-#include <aspect/time_stepping/interface.h>
-
-
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    using namespace dealii;
-
-    /**
-     * Compute the conduction time step based on the current solution and
-     * return this as the time step.
-     *
-     * @ingroup TimeStepping
-     */
-    template <int dim>
-    class ConductionTimeStep : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        ConductionTimeStep () = default;
-
-
-        /**
-         * @copydoc aspect::TimeStepping::Interface<dim>::execute()
-         */
-        double
-        execute() override;
-
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/time_stepping/convection_time_step.h.bak b/include/aspect/time_stepping/convection_time_step.h.bak
deleted file mode 100644
index fa18a9032e2..00000000000
--- a/include/aspect/time_stepping/convection_time_step.h.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2014 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_time_stepping_convection_time_step_h
-#define _aspect_time_stepping_convection_time_step_h
-
-#include <aspect/time_stepping/interface.h>
-
-
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    using namespace dealii;
-
-    /**
-     * Compute the convection time step based on the current solution and
-     * return it.
-     *
-     * @ingroup TimeStepping
-     */
-    template <int dim>
-    class ConvectionTimeStep : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        ConvectionTimeStep () = default;
-
-
-        /**
-         * @copydoc aspect::TimeStepping::Interface<dim>::execute()
-         */
-        double
-        execute() override;
-
-      private:
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/time_stepping/function.h.bak b/include/aspect/time_stepping/function.h.bak
deleted file mode 100644
index 0a1608f0674..00000000000
--- a/include/aspect/time_stepping/function.h.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_time_stepping_function_h
-#define _aspect_time_stepping_function_h
-
-#include <aspect/time_stepping/interface.h>
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a time stepping plugin on a function
-     * description provided in the input file.
-     *
-     * @ingroup TimeStepping
-     */
-    template <int dim>
-    class Function : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Function () = default;
-
-        /**
-         * The main execute() function.
-         */
-        double
-        execute() override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * The function object.
-         */
-        Functions::ParsedFunction<1> function;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/time_stepping/interface.h.bak b/include/aspect/time_stepping/interface.h.bak
deleted file mode 100644
index a59a5728341..00000000000
--- a/include/aspect/time_stepping/interface.h.bak
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
-  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _aspect_time_stepping_interface_h
-#define _aspect_time_stepping_interface_h
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-#include <aspect/termination_criteria/interface.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  /**
-   * A namespace containing all class related to the time stepping plugin system.
-   */
-  namespace TimeStepping
-  {
-
-    /**
-     * This enum describes the possible reactions by the time stepping plugins after the
-     * computation of each time step.
-     *
-     * Note: the ordering of the options is crucial, as the Manager will use the minimum
-     * of the values given by all active plugins as the reaction to take. This means the
-     * first entry has highest priority.
-     */
-    enum class Reaction
-    {
-      /**
-       * Initiate mesh refinement and go back in time to repeat the last timestep.
-       */
-      refine_and_repeat_step,
-      /**
-       * Go back in time to repeat the last timestep.
-       */
-      repeat_step,
-      /**
-       * Initiate mesh refinement and continue to the next timestep.
-       */
-      refine_and_advance,
-      /**
-       * Continue to the next timestep. The default action to take.
-       */
-      advance
-    };
-
-    /**
-     * Information passed to Interface::determine_reaction with information
-     * about the time step.
-     */
-    struct TimeStepInfo
-    {
-      /**
-       * The proposed time step size for the next step as computed by querying
-       * plugins and applying other logic.
-       */
-      double next_time_step_size;
-
-      /**
-       * If true, a termination criterion decided to shorten the time step
-       * size.
-       */
-      bool reduced_by_termination_plugin;
-    };
-
-    /**
-     * A base class for parameterizations of the time stepping models.
-     *
-     * @ingroup TimeStepping
-     */
-    template <int dim>
-    class Interface : public Plugins::InterfaceBase
-    {
-      public:
-        /**
-         * Execute the logic of the plugin.
-         *
-         * This is called after every time step to determine
-         * a) What to do (advance, repeat, etc.), see the Reaction enum.
-         * b) What timestep size to use.
-         *
-         */
-        virtual
-        double
-        execute() = 0;
-
-        /**
-         * Determine what we want with the simulation to happen next: advance,
-         * repeat, refinement, etc.. The second return value is the time step
-         * size to take in case the plugin requests a repeated time step.
-         *
-         * The argument @p info contains information like the step size that
-         * would be taken in this time step (determined as the minimum of the
-         * return value of execute() from all plugins).
-         *
-         * The default implementation of this function will always advance
-         * to the next time step.
-         */
-        virtual
-        std::pair<Reaction, double>
-        determine_reaction(const TimeStepInfo &info);
-    };
-
-
-    /**
-     * A class to handle computation of the next time step (as desired by the user) and
-     * checking if the simulation is finished.
-     */
-    template <int dim>
-    class Manager : public Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Override initialize_simulator() so that we can also initialize the contained
-         * termination_manager.
-         */
-        void initialize_simulator (const Simulator<dim> &simulator_object) override;
-
-
-        /**
-         * Update the current state and determine what needs to happen based on the
-         * last computed solution (see functions below). This computes the size of
-         * the next time step potentially taking into account the current solution
-         * (convection time step, conduction time step), settings from parameters,
-         * and termination criteria (to hit the end time exactly).
-         */
-        void
-        update() override;
-
-        /**
-         * Return the next step size as computed from update().
-         */
-        double get_next_time_step_size() const;
-
-        /**
-         * If true, a plugin requested to redo the last computed time step. Updated
-         * when calling update().
-         */
-        bool should_repeat_time_step() const;
-
-        /**
-         * If true, execute a mesh refinement step now (potentially before repeating
-         * the current time step).
-         */
-        bool should_refine_mesh() const;
-
-        /**
-         * If true, the simulator should perform a checkpoint before terminating.
-         */
-        bool need_checkpoint_on_terminate() const;
-
-        /**
-         * Check if the simulation is ready to terminate successfully.
-         */
-        bool should_simulation_terminate_now() const;
-
-        /**
-         * Declare the parameters of all known termination criteria plugins,
-         * as well as of ones this class has itself.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         * This determines which termination criteria objects will be created;
-         * then let these objects read their parameters as well.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-        /**
-         * For the current plugin subsystem, write a connection graph of all of the
-         * plugins we know about, in the format that the
-         * programs dot and neato understand. This allows for a visualization of
-         * how all of the plugins that ASPECT knows about are interconnected, and
-         * connect to other parts of the ASPECT code.
-         *
-         * @param output_stream The stream to write the output to.
-         */
-        static
-        void
-        write_plugin_graph (std::ostream &output_stream);
-
-
-        /**
-         * A function that is used to register time stepping model objects in such
-         * a way that the Manager can deal with all of them without having to
-         * know them by name. This allows the files in which individual
-         * plugins are implemented to register these plugins, rather than also
-         * having to modify the Manager class by adding the new plugin class.
-         *
-         * @param name A string that identifies the model
-         * @param description A text description of what this model does and that
-         * will be listed in the documentation of the parameter file.
-         * @param declare_parameters_function A pointer to a function that can be
-         * used to declare the parameters that this model wants to read
-         * from input files.
-         * @param factory_function A pointer to a function that can create an
-         * object of this model.
-         *
-         * @ingroup TimeStepping
-         */
-        static
-        void
-        register_time_stepping_model (const std::string &name,
-                                      const std::string &description,
-                                      void (*declare_parameters_function) (ParameterHandler &),
-                                      std::unique_ptr<Interface<dim>> (*factory_function) ());
-
-      private:
-
-        /**
-         * The current Reaction computed by update().
-         */
-        Reaction current_reaction;
-
-        /**
-         * The next time step size computed by update().
-         */
-        double next_time_step_size;
-
-        /**
-         * The minimum time step size specified by the user (in seconds).
-         */
-        double minimum_time_step_size;
-
-        /**
-         * Whether to do a final checkpoint before termination. This is
-         * specified in the parameters.
-         */
-        bool do_checkpoint_on_terminate;
-
-        /**
-         * The termination manager keeps track of the termination plugins and we use
-         * it to determine the time_step size in the final time step.
-         */
-        TerminationCriteria::Manager<dim> termination_manager;
-    };
-
-    /**
-     * Given a class name, a name, and a description for the parameter file, register it with the
-     * aspect::TimeStepping::Manager class.
-     *
-     * @ingroup TimeStepping
-     */
-#define ASPECT_REGISTER_TIME_STEPPING_MODEL(classname,name,description) \
-  template class classname<2>; \
-  template class classname<3>; \
-  namespace ASPECT_REGISTER_TIME_STEPPING_MODEL_ ## classname \
-  { \
-    aspect::internal::Plugins::RegisterHelper<aspect::TimeStepping::Interface<2>,classname<2>> \
-    dummy_ ## classname ## _2d (&aspect::TimeStepping::Manager<2>::register_time_stepping_model, \
-                                name, description); \
-    aspect::internal::Plugins::RegisterHelper<aspect::TimeStepping::Interface<3>,classname<3>> \
-    dummy_ ## classname ## _3d (&aspect::TimeStepping::Manager<3>::register_time_stepping_model, \
-                                name, description); \
-  }
-
-  }
-}
-
-#endif
diff --git a/include/aspect/time_stepping/repeat_on_cutback.h.bak b/include/aspect/time_stepping/repeat_on_cutback.h.bak
deleted file mode 100644
index 624e2b90cea..00000000000
--- a/include/aspect/time_stepping/repeat_on_cutback.h.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_time_stepping_repeat_on_cutback_h
-#define _aspect_time_stepping_repeat_on_cutback_h
-
-#include <aspect/time_stepping/interface.h>
-
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements a time stepping plugin to repeat a time step if the
-     * next time step is significantly smaller than the last step.
-     *
-     * @ingroup TimeStepping
-     */
-    template <int dim>
-    class RepeatOnCutback : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        RepeatOnCutback () = default;
-
-        /**
-         * @copydoc aspect::TimeStepping::Interface<dim>::execute()
-         */
-        double
-        execute() override;
-
-        /**
-         * The main execute() function.
-         */
-        std::pair<Reaction, double>
-        determine_reaction(const TimeStepInfo &info) override;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Parameter to determine how much smaller the time step should be
-         * repeated as.
-         */
-        double cut_back_amount;
-
-        /**
-         * Parameter that controls when to repeat a time step. If the newly
-         * computed step size is smaller than the last step size multiplied by
-         * this factor, the step is repeated.
-         */
-        double repeat_threshold;
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/utilities.h.bak b/include/aspect/utilities.h.bak
deleted file mode 100644
index 68ed43c9d5b..00000000000
--- a/include/aspect/utilities.h.bak
+++ /dev/null
@@ -1,1392 +0,0 @@
-/*
-  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_utilities_h
-#define _aspect_utilities_h
-
-#include <aspect/global.h>
-
-#include <array>
-#include <random>
-#include <deal.II/base/point.h>
-#include <deal.II/base/conditional_ostream.h>
-#include <deal.II/base/table_indices.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/fe/component_mask.h>
-
-#include <aspect/coordinate_systems.h>
-#include <aspect/structured_data.h>
-
-
-
-namespace aspect
-{
-  template <int dim> class SimulatorAccess;
-
-  namespace GeometryModel
-  {
-    template <int dim> class Interface;
-  }
-
-  /**
-   * A namespace for utility functions that might be used in many different
-   * places to prevent code duplication.
-   */
-  namespace Utilities
-  {
-    using namespace dealii;
-    using namespace dealii::Utilities;
-
-
-    /**
-     * Given an array @p values, consider three cases:
-     * - If it has size @p N, return the original array.
-     * - If it has size one, return an array of size @p N where all
-     *   elements are equal to the one element of @p value.
-     * - If it has any other size, throw an exception that uses
-     *   @p id_text as an identifying string.
-     *
-     * This function is typically used for parameter lists that can either
-     * contain different values for each of a set of objects (e.g., for
-     * each compositional field), or contain a single value that is then
-     * used for each object.
-     */
-    template <typename T>
-    std::vector<T>
-    possibly_extend_from_1_to_N (const std::vector<T> &values,
-                                 const unsigned int N,
-                                 const std::string &id_text);
-
-    namespace MapParsing
-    {
-      /**
-       * A struct that bundles all the available options for
-       * parse_map_to_double_array().
-       */
-      struct Options
-      {
-        /* A list of valid key names that are allowed
-         * to appear in the map. If this list is empty
-         * it is assumed to be equal to the list of
-         * required keys. If this list is longer than
-         * list_of_required_keys, every key that is
-         * allowed but not required will be ignored when
-         * parsing the map.
-         */
-        std::vector<std::string> list_of_allowed_keys;
-
-        /* A list of valid key names that are required
-         * to appear in the map. Only these keys will be
-         * parsed into the map structure and the order of
-         * these keys determines the order of entries
-         * in the output vector.
-         */
-        std::vector<std::string> list_of_required_keys;
-
-        /*
-         * A name that identifies the type of input property (e.g. 'density', 'viscosity')
-         * that is being parsed by this function. This name is used in generating
-         * error messages if the map does not conform to the expected format.
-         */
-        std::string property_name;
-
-        /*
-         * If true, allow multiple values
-         * for each key. If false only allow a single value per key. In either
-         * case each key is only allowed to appear once. Multiple values
-         * for a key are delimited by a "|" character, as in
-         * "key1: value1|value2|value3, key2: value1|value2".
-         */
-        bool allow_multiple_values_per_key;
-
-        /*
-         * Whether to allow for some keys in list_of_required_keys to be
-         * not set to any values, i.e. they do not appear at all.
-         * This also allows a completely empty map.
-         */
-        bool allow_missing_keys;
-
-        /*
-         * Whether to store the number of values
-         * per key in n_values_per_key while creating
-         * the map. This vector can be later accessed
-         * and used (for example) to check that subsequent calls to
-         * parse other input parameters have the same
-         * structure.
-         */
-        bool store_values_per_key;
-
-        /*
-         * Whether to check the number of values
-         * per key in the map against values stored
-         * in n_values_per_key. This allows to
-         * check that subsequent calls to
-         * parse other input parameters have the same
-         * structure.
-         */
-        bool check_values_per_key;
-
-        /*
-         * A vector of unsigned
-         * integers that is used by store_values_per_key and
-         * check_values_per_key to either store the current map
-         * structure or check the map structure against an existing
-         * map. This parameter is only used if either of these
-         * two parameters are set to true
-         */
-        std::vector<unsigned int> n_values_per_key;
-
-        /**
-         * Delete the default constructor, because we want to ensure that
-         * at least the required options are always set.
-         */
-        Options() = delete;
-
-        /**
-         * A constructor for options that only sets the required
-         * parameters and leaves all other parameters at their default values.
-         * By default the @p list_of_required_keys will be used as both
-         * the list of allowed and list of required keys. In other words
-         * exactly these keys and no other keys are allowed to appear
-         * in the input and all of the keys have to be specified and will
-         * be included in the output. For a documentation of the parameters
-         * see the documentation of the member variables of this class.
-         */
-        Options(const std::vector<std::string> &list_of_required_keys,
-                const std::string &property_name)
-          :
-          list_of_allowed_keys(list_of_required_keys),
-          list_of_required_keys(list_of_required_keys),
-          property_name(property_name),
-          allow_multiple_values_per_key(false),
-          allow_missing_keys(false),
-          store_values_per_key(false),
-          check_values_per_key(false),
-          n_values_per_key()
-        {}
-      };
-
-      /**
-       * This function takes a string argument that is interpreted as a map
-       * of the form "key1 : value1, key2 : value2, etc", and then parses
-       * it to return a vector of these values. The parsing and output
-       * is controlled by @p options, which provides control over which keys
-       * (and how many) are allowed and required, whether multiple values
-       * per keys are allowed, whether the structure of the map is recorded
-       * while parsing, or checked against an existing structure and some other
-       * options. See the documentation of MapParsing::Options for available
-       * settings.
-       *
-       * @param[in] input_string The string representation of the map
-       *   to be parsed.
-       * @param[in] options An object of type MapParsing::Options() that contains
-       *   the parsing options that are considered by this function. See the
-       *   documentation of Options() for the available settings.
-       *
-       * @return A vector of values that are parsed from the @p input_string according
-       *   to the provided @p options and is sorted according to the member variable
-       *   list_of_required_keys inside @p options.
-       *   If multiple values per key are allowed, the vector contains first all
-       *   values for key 1, then all values for key 2 and so forth. Using the
-       *   n_values_per_key vector inside @p options allows the caller to
-       *   associate entries in the returned vector with specific keys.
-       */
-      std::vector<double>
-      parse_map_to_double_array(const std::string &input_string,
-                                Options &options);
-    }
-
-    /**
-     * This function takes a string argument that is interpreted as a map
-     * of the form "key1 : value1, key2 : value2, etc", and then parses
-     * it to return a vector of these values where the values are ordered
-     * in the same order as a given set of keys. If @p allow_multiple_values_per_key
-     * is set to 'true' it also allows entries of the form
-     * "key1: value1|value2|value3, etc", in which case the returned
-     * vector will have more entries than the provided
-     * @p list_of_keys.
-     *
-     * This function also considers a number of special cases:
-     * - If the input string consists of only a comma separated
-     *   set of values "value1, value2, value3, ..." (i.e., without
-     *   the "keyx :" part), then the input string is interpreted
-     *   as if it had had the form "key1 : value1, key2 : value2, ..."
-     *   where "key1", "key2", ... are exactly the keys provided by the
-     *   @p list_of_keys in the same order as provided. In this situation,
-     *   if a background field is required, the background value is
-     *   assigned to the first element of the output vector. This form only
-     *   allows a single value per key.
-     * - Whether or not a background field is required depends on
-     *   @p expects_background_field. Requiring a background field
-     *   inserts "background" into the @p list_of_keys as the first entry
-     *   in the list. Some calling functions (like some material models)
-     *   require values for background fields, while others may not
-     *   need background values.
-     * - Two special keys are recognized:
-     *      all --> Assign the associated value to all fields.
-     *              Only one key is allowed in this case.
-     *      background --> Assign associated value to the background.
-     *
-     * @param[in] key_value_map The string representation of the map
-     *   to be parsed.
-     * @param[in] list_of_keys A list of N valid key names that are allowed
-     *   to appear in the map. The order of these keys determines the order
-     *   of values that are returned by this function.
-     * @param[in] expects_background_field If true, expect N+1 values and allow
-     *   setting of the background using the key "background".
-     * @param[in] property_name A name that identifies the type of property
-     *   that is being parsed by this function and that is used in generating
-     *   error messages if the map does not conform to the expected format.
-     * @param [in] allow_multiple_values_per_key If true allow having multiple values
-     *   for each key. If false only allow a single value per key. In either
-     *   case each key is only allowed to appear once.
-     * @param [in,out] n_values_per_key A pointer to a vector of unsigned
-     *   integers. If no pointer is handed over nothing happens. If a pointer
-     *   to an empty vector is handed over, the vector
-     *   is resized with as many components as
-     *   keys (+1 if there is a background field). Each value then stores
-     *   how many values were found for this key. The sum over all
-     *   entries is the length of the return value of this function.
-     *   If a pointer to an existing vector with one or more entries is
-     *   handed over (e.g. a n_values_per_key vector created by a
-     *   previous call to this function) then this vector is used as
-     *   expected structure of the input parameter, and it is checked that
-     *   @p key_value_map fulfills this structure. This can be used to assert
-     *   that several input parameters prescribe the same number of values
-     *   to each key.
-     * @param [in] allow_missing_keys Whether to allow that some keys are
-     *   not set to any values, i.e. they do not appear at all in the
-     *   @p key_value_map. This also allows a completely empty map.
-     *
-     * @return A vector of values that are parsed from the map, provided
-     *   in the order in which the keys appear in the @p list_of_keys argument.
-     *   If multiple values per key are allowed, the vector contains first all
-     *   values for key 1, then all values for key 2 and so forth. Using the
-     *   @p n_values_per_key vector allows the caller to associate entries in the
-     *   returned vector with specific keys.
-     *
-     * @deprecated: This function is deprecated in favor of the more general
-     *   Utilities::MapParsing::parse_map_to_double_array() function. Please
-     *   use the other function instead.
-     */
-    std::vector<double>
-    parse_map_to_double_array (const std::string &key_value_map,
-                               const std::vector<std::string> &list_of_keys,
-                               const bool expects_background_field,
-                               const std::string &property_name,
-                               const bool allow_multiple_values_per_key = false,
-                               const std::unique_ptr<std::vector<unsigned int>> &n_values_per_key = nullptr,
-                               const bool allow_missing_keys = false);
-
-    /**
-     * This function takes a string argument that is assumed to represent
-     * an input table, in which each row is separated by
-     * semicolons, and each column separated by commas. The function
-     * returns the parsed entries as a table. In addition this function
-     * utilizes the possibly_extend_from_1_to_N() function to accept
-     * inputs with only a single column/row, which will be extended
-     * to @p n_rows or @p n_columns respectively, to allow abbreviating
-     * the input string (e.g. you can provide a single value instead of
-     * n_rows by n_columns identical values). This function can for example
-     * be used by material models to read densities for different
-     * compositions and different phases for each composition.
-     */
-    template <typename T>
-    Table<2,T>
-    parse_input_table (const std::string &input_string,
-                       const unsigned int n_rows,
-                       const unsigned int n_columns,
-                       const std::string &property_name);
-
-    /**
-     * Given a vector @p var_declarations expand any entries of the form
-     * vector(str) or tensor(str) to sublists with component names of the form
-     * str_x, str_y, str_z or str_xx, str_xy... for the correct dimension
-     * value.
-     *
-     * This function is to be used for expanding lists of variable names where
-     * one or more such variable is actually intended to be a list of
-     * components.
-     *
-     * Returns the generated list of variable names
-     */
-    template <int dim>
-    std::vector<std::string>
-    expand_dimensional_variable_names (const std::vector<std::string> &var_declarations);
-
-    /**
-     * Returns an IndexSet that contains all locally active DoFs that belong to
-     * the given component_mask.
-     *
-     * This function should be moved into deal.II at some point.
-     */
-    template <int dim>
-    IndexSet extract_locally_active_dofs_with_component(const DoFHandler<dim> &dof_handler,
-                                                        const ComponentMask &component_mask);
-
-    /**
-     * This function retrieves the unit support points (in the unit cell) for the current element.
-     * The DGP element used when 'set Use locally conservative discretization = true' does not
-     * have support points. If these elements are in use, a fictitious support point at the cell
-     * center is returned for each shape function that corresponds to the pressure variable,
-     * whereas the support points for the velocity are correct. The fictitious points don't matter
-     * because we only use this function when interpolating the velocity variable, and ignore the
-     * evaluation at the pressure support points.
-     */
-    template <int dim>
-    std::vector<Point<dim>> get_unit_support_points(const SimulatorAccess<dim> &simulator_access);
-
-
-
-    /**
-     * Given a point @p point, find out if any of the MPI
-     * processes own the cell in which this point lies. If
-     * not, the point lies outside the @p triangulation.
-     */
-    template <int dim>
-    bool
-    point_is_in_triangulation(const Mapping<dim> &mapping,
-                              const parallel::distributed::Triangulation<dim> &triangulation,
-                              const Point<dim> &point,
-                              const MPI_Comm mpi_communicator);
-
-
-    namespace Coordinates
-    {
-
-      /**
-       * Returns distance from the Earth's center, latitude and longitude from a
-       * given ECEF Cartesian coordinates that account for ellipsoidal shape of
-       * the Earth with WGS84 parameters.
-       */
-      template <int dim>
-      std::array<double,dim>
-      WGS84_coordinates(const dealii::Point<dim> &position);
-
-      /**
-       * Returns spherical coordinates of a Cartesian point. If `dim==3`, then
-       * the returned array contains the three values radius, phi, and theta
-       * (polar angle). In other words, the two angles correspond to longitude
-       * and *colatitude* (instead of latitude). If `dim==2`, then theta is omitted.
-       * The longitude Phi is always considered in the interval $[0,2\pi]$. Note
-       * that that implies that input files that use spherical coordinates also
-       * have to provide data using this convention, rather than providing their
-       * data from $-\pi$ (=180 degrees west) to $+\pi$ (=180 degrees east).
-       */
-      template <int dim>
-      std::array<double,dim>
-      cartesian_to_spherical_coordinates(const dealii::Point<dim> &position);
-
-      /**
-       * Return the Cartesian point of a spherical position defined by radius,
-       * phi and theta (polar angle). If the dimension is set to 2 theta is
-       * omitted.
-       */
-      template <int dim>
-      dealii::Point<dim>
-      spherical_to_cartesian_coordinates(const std::array<double,dim> &scoord);
-
-      /**
-       * Given a vector defined in the radius, phi and theta directions, return
-       * a vector defined in Cartesian coordinates. If the dimension is set to 2
-       * theta is omitted. Position is given as a Point in Cartesian coordinates.
-       */
-      template <int dim>
-      Tensor<1,dim>
-      spherical_to_cartesian_vector(const Tensor<1,dim> &spherical_vector,
-                                    const dealii::Point<dim> &position);
-
-
-      /**
-       * Returns ellipsoidal coordinates of a Cartesian point. The returned array
-       * is filled with phi, theta and radius.
-       *
-       */
-      template <int dim>
-      std::array<double,3>
-      cartesian_to_ellipsoidal_coordinates(const dealii::Point<3> &position,
-                                           const double semi_major_axis_a,
-                                           const double eccentricity);
-
-      /**
-       * Return the Cartesian point of a ellipsoidal position defined by phi,
-       * theta and radius.
-       */
-      template <int dim>
-      dealii::Point<3>
-      ellipsoidal_to_cartesian_coordinates(const std::array<double,3> &phi_theta_d,
-                                           const double semi_major_axis_a,
-                                           const double eccentricity);
-
-
-      /**
-       * A function that takes a string representation of the name of a
-       * coordinate system (as represented by the CoordinateSystem enum)
-       * and returns the corresponding value.
-       */
-      CoordinateSystem
-      string_to_coordinate_system (const std::string &);
-    }
-
-
-    /**
-     * Given a 2d point and a list of points which form a polygon, computes if the point
-     * falls within the polygon.
-     */
-    template <int dim>
-    bool
-    polygon_contains_point(const std::vector<Point<2>> &point_list,
-                           const dealii::Point<2> &point);
-
-    /**
-     * Given a 2d point and a list of points which form a polygon, compute the smallest
-     * distance of the point to the polygon. The sign is negative for points outside of
-     * the polygon and positive for points inside the polygon.
-     */
-    template <int dim>
-    double
-    signed_distance_to_polygon(const std::vector<Point<2>> &point_list,
-                               const dealii::Point<2> &point);
-
-
-    /**
-     * Given a 2d point and a list of two points that define a line, compute the smallest
-     * distance of the point to the line segment. When the point's perpendicular
-     * base does not lie on the line segment, the smallest distance to the segment's end
-     * points is calculated.
-     */
-    double
-    distance_to_line(const std::array<dealii::Point<2>,2> &point_list,
-                     const dealii::Point<2> &point);
-
-    /**
-     * Given a vector @p v in @p dim dimensional space, return a set
-     * of (dim-1) vectors that are orthogonal to @p v and to each
-     * other. The length of each of these vectors equals that of the original
-     * vector @p v to ensure that the resulting set of vectors
-     * represents a well-conditioned basis.
-     */
-    template <int dim>
-    std::array<Tensor<1,dim>,dim-1>
-    orthogonal_vectors (const Tensor<1,dim> &v);
-
-    /**
-     * A function that returns the corresponding euler angles for a
-     * rotation described by rotation axis and angle.
-     */
-    Tensor<2,3>
-    rotation_matrix_from_axis (const Tensor<1,3> &rotation_axis,
-                               const double rotation_angle);
-
-    /**
-     * Compute the 3d rotation matrix that describes the rotation of a
-     * plane defined by the two points @p point_one and @p point_two
-     * onto the x-y-plane in a way that the vector from the origin to
-     * point_one points into the (0,1,0) direction after the rotation.
-     */
-    Tensor<2,3>
-    compute_rotation_matrix_for_slice (const Tensor<1,3> &point_one,
-                                       const Tensor<1,3> &point_two);
-
-    /**
-     * A function for evaluating real spherical harmonics. It takes the degree (l)
-     * and the order (m) of the spherical harmonic, where $l \geq 0$ and $0 \leq m \leq l$.
-     * It also takes the colatitude (theta) and longitude (phi), which are in
-     * radians.
-     *
-     * There are an unfortunate number of normalization conventions in existence
-     * for spherical harmonics. Here we use fully normalized spherical harmonics
-     * including the Condon-Shortley phase. This corresponds to the definitions
-     * given in equations B.72 and B.99-B.102 in Dahlen and Tromp (1998, ISBN: 9780691001241).
-     * The functional form of the real spherical harmonic is given by
-     *
-     * \f[
-     *    Y_{lm}(\theta, \phi) = \sqrt{2} X_{l \left| m \right| }(\theta) \cos m \phi \qquad \mathrm{if} \qquad -l \le m < 0
-     * \f]
-     * \f[
-     *    Y_{lm}(\theta, \phi) = X_{l 0 }(\theta) \qquad \mathrm{if} \qquad m = 0
-     * \f]
-     * \f[
-     *    Y_{lm}(\theta, \phi) = \sqrt{2} X_{lm}(\theta) \sin m \phi \qquad \mathrm{if}  \qquad 0< m \le m
-     * \f]
-     * where $X_{lm}( \theta )$ is an associated Legendre function.
-     *
-     * In practice it is often convenient to compute the sine ($-l \le m < 0$) and cosine ($0 < m \le l$)
-     * variants of the real spherical harmonic at the same time. That is the approach taken
-     * here, where we return a pair of numbers, the first corresponding the cosine part and the
-     * second corresponding to the sine part. Given this, it is no longer necessary to distinguish
-     * between positive and negative $m$, so this function only accepts $ m \ge 0$.
-     * For $m = 0$, there is only one part, which is stored in the first entry of the pair.
-     *
-     * @note This function uses the Boost spherical harmonics implementation internally,
-     * which is not designed for very high order (> 100) spherical harmonics computation.
-     * If you use spherical harmonics of a high order be sure to confirm the accuracy first.
-     * For more information, see:
-     * http://www.boost.org/doc/libs/1_49_0/libs/math/doc/sf_and_dist/html/math_toolkit/special/sf_poly/sph_harm.html
-     */
-    std::pair<double,double> real_spherical_harmonic( unsigned int l, // degree
-                                                      unsigned int m, // order
-                                                      double theta,   // colatitude (radians)
-                                                      double phi );   // longitude (radians)
-
-    /**
-     * A struct to enable numerical output with a comma as thousands separator
-     */
-    struct ThousandSep : std::numpunct<char>
-    {
-      protected:
-        char do_thousands_sep() const override
-        {
-          return ',';
-        }
-
-        std::string do_grouping() const override
-        {
-          return "\003";  // groups of 3 digits (this string is in octal format)
-        }
-
-    };
-
-    /**
-     * Checks whether a file named @p filename exists and is readable.
-     *
-     * Note: This function performs file access on all MPI ranks that
-     * call it. Only use this function if
-     * the file access is performed on all MPI ranks
-     * and on a reasonably fast file system.
-     *
-     * @return True if the file exists and is readable on all MPI ranks
-     * that call this function.
-     * @param filename File to check existence
-     */
-    bool fexists(const std::string &filename);
-
-    /**
-     * Check whether a file named @p filename exists and is readable
-     * on MPI rank 0. Then, broadcast the result to all MPI ranks.
-     *
-     * Note that in contrast to the other fexists() function, this function
-     * only checks for the existence of the file on a single process.
-     * This is useful to avoid overloading the file system and is sufficient
-     * if the subsequent file access is also only performed on MPI rank 0.
-     *
-     * @return True if the file exists and is readable on MPI rank 0.
-     * @param filename File to check existence
-     * @param comm MPI communicator to use.
-     */
-    bool fexists(const std::string &filename,
-                 const MPI_Comm comm);
-
-    /**
-     * Checks to see if the user is trying to use data from a url.
-     *
-     * @param filename File to check
-     */
-    bool filename_is_url(const std::string &filename);
-
-    /**
-     * Reads the content of the ascii file @p filename on process 0 and
-     * distributes the content by MPI_Bcast to all processes. The function
-     * returns the content of the file on all processes. The purpose of this
-     * function is to reduce parallel file access to a single file access on
-     * process 0.
-     *
-     * @param [in] filename The name of the ascii file to load. If the
-     *  file name ends in `.gz`, then the function assumes that the file
-     *  has been compressed using gzip; it then reads and uncompresses the file
-     *  before distributing it. If the file name is a URL (starting with either
-     *  `http://`, `https://`, or `file://`), and if ASPECT has been configured
-     *  with libDAP, then the file is read from that location via libDAP
-     *  and the returned string is an ASCII data representation of what was
-     *  obtained this way.
-     * @param [in] comm The MPI communicator in which the content is
-     * distributed.
-     * @return A string which contains the data in @p filename.
-     */
-    std::string
-    read_and_distribute_file_content(const std::string &filename,
-                                     const MPI_Comm comm);
-
-    /**
-     * Collect the content of @p file_content using MPI_Gather to process 0.
-     * Then write the content to the file @p filename on process 0.
-     * The purpose of this function is to reduce parallel file access to
-     * process 0. Note that this function assumes that the content from
-     * all processes fits into the memory of process 0.
-     *
-     * @param [in] filename The name of the file to write.
-     * @param [in] file_content The content that should be written to file.
-     * @param [in] comm The MPI communicator from which the content is
-     * collected.
-     */
-    void
-    collect_and_write_file_content(const std::string &filename,
-                                   const std::string &file_content,
-                                   const MPI_Comm comm);
-
-    /**
-     * Creates a path as if created by the shell command "mkdir -p", therefore
-     * generating directories from the highest to the lowest level if they are
-     * not already existing.
-     *
-     * @param pathname String that contains the path to create. '/' is used as
-     * directory separator.
-     * @param mode Permissions (mode bits) of the created directories. See the
-     * documentation of the chmod() command for more information.
-     * @return The function returns the error value of the last mkdir call
-     * inside. It returns zero on success. See the man page of mkdir() for
-     * more information.
-     */
-    int
-    mkdirp(std::string pathname, const mode_t mode = 0755);
-
-    /**
-     * Create directory @p pathname, optionally printing a message.
-     *
-     * @param pathname String that contains path to create. '/' is used as
-     * directory separator.
-     * @param comm MPI communicator, used to limit creation of directory to
-     * processor 0.
-     * @param silent Print a nicely formatted message on processor 0 if set
-     * to true.
-     */
-    void create_directory(const std::string &pathname,
-                          const MPI_Comm comm,
-                          bool silent);
-
-    /**
-     * A namespace defining the cubic spline interpolation that can be used
-     * between different spherical layers in the mantle.
-     */
-    namespace tk
-    {
-      /**
-       * Class for cubic spline interpolation
-       */
-      class spline
-      {
-        public:
-          /**
-           * Initialize the spline.
-           *
-           * @param x X coordinates of interpolation points.
-           * @param y Values in the interpolation points.
-           * @param cubic_spline Whether to construct a cubic spline or just do linear interpolation
-           * @param monotone_spline Whether the cubic spline should be a monotone cubic spline.
-           * Requires cubic_spline to be set to true.
-           */
-          void set_points(const std::vector<double> &x,
-                          const std::vector<double> &y,
-                          const bool cubic_spline = true,
-                          const bool monotone_spline = false);
-          /**
-           * Evaluate spline at point @p x.
-           */
-          double operator() (double x) const;
-
-        private:
-          /**
-           * x coordinates of points
-           */
-          std::vector<double> m_x;
-
-          /**
-           * interpolation parameters
-           * \[
-           * f(x) = a*(x-x_i)^3 + b*(x-x_i)^2 + c*(x-x_i) + y_i
-           * \]
-           */
-          std::vector<double> m_a, m_b, m_c, m_y;
-      };
-    }
-
-    /**
-     * Extract the compositional values at a single quadrature point with
-     * index @p q from @p composition_values, which is indexed by
-     * compositional index and quadrature point, and write them into @p
-     * composition_values_at_q_point. In other words,
-     * this extracts @p composition_values[i][q] for all @p i.
-     */
-    inline
-    void
-    extract_composition_values_at_q_point (const std::vector<std::vector<double>> &composition_values,
-                                           const unsigned int q,
-                                           std::vector<double> &composition_values_at_q_point);
-
-    /**
-     * Replace the string <tt>\$ASPECT_SOURCE_DIR</tt> in @p location by the current
-     * source directory of ASPECT and return the resulting string.
-     */
-    std::string
-    expand_ASPECT_SOURCE_DIR (const std::string &location);
-
-    /**
-     * Given a string @p s, return it in the form ' ("s")' if nonempty.
-     * Otherwise just return the empty string itself.
-     */
-    std::string parenthesize_if_nonempty (const std::string &s);
-
-    /**
-     * Given a string @p s, convert it to a boolean value.
-     */
-    bool
-    string_to_bool(const std::string &s);
-
-    /**
-     * Given a vector of strings @p s, convert it to a vector of boolean values.
-     */
-    std::vector<bool>
-    string_to_bool(const std::vector<std::string> &s);
-
-    /**
-     * Given a string @p s, convert it to an unsigned int.
-     */
-    unsigned int
-    string_to_unsigned_int(const std::string &s);
-
-    /**
-     * Given a vector of strings @p s, convert it to a vector of unsigned int values.
-     */
-    std::vector<unsigned int>
-    string_to_unsigned_int(const std::vector<std::string> &s);
-
-    /**
-     * Returns if a vector of strings @p strings only contains unique
-     * entries.
-     */
-    bool has_unique_entries (const std::vector<std::string> &strings);
-
-
-
-    /**
-     * This function computes the weighted average $\bar y$ of $y_i$  for a weighted p norm. This
-     * leads for a general p to:
-     * $\bar y = \left(\frac{\sum_{i=1}^k w_i y_i^p}{\sum_{i=1}^k w_i}\right)^{\frac{1}{p}}$.
-     * When p = 0 we take the geometric average:
-     * $\bar y = \exp\left(\frac{\sum_{i=1}^k w_i \log\left(y_i\right)}{\sum_{i=1}^k w_i}\right)$,
-     * and when $p \le -1000$ or $p \ge 1000$ we take the minimum and maximum norm respectively.
-     * This means that the smallest and largest value is respectively taken taken.
-     *
-     * This function has been set up to be very tolerant to strange values, such as negative weights.
-     * The only things we require in for the general p is that the sum of the weights and the sum of
-     * the weights times the values to the power p may not be smaller or equal to zero. Furthermore,
-     * when a value is zero, the exponent is smaller then one and the correspondent weight is non-zero,
-     * this corresponds to no resistance in a parallel system. This means that this 'path' will be followed,
-     * and we return zero.
-     *
-     * The implemented special cases (which are minimum (p <= -1000), harmonic average (p = -1), geometric
-     * average (p = 0), arithmetic average (p = 1), quadratic average (RMS) (p = 2), cubic average (p = 3)
-     * and maximum (p >= 1000) ) is, except for the harmonic and quadratic averages even more tolerant of
-     * negative values, because they only require the sum of weights to be non-zero.
-     */
-    double weighted_p_norm_average (const std::vector<double> &weights,
-                                    const std::vector<double> &values,
-                                    const double p);
-
-
-    /**
-     * This function computes the derivative ($\frac{\partial\bar y}{\partial x}$) of an average
-     * of the values $y_i(x)$ with regard to $x$, using $\frac{\partial y_i(x)}{\partial x}$.
-     * This leads for a general p to:
-     * $\frac{\partial\bar y}{\partial x} =
-     * \frac{1}{p}\left(\frac{\sum_{i=1}^k w_i y_i^p}{\sum_{i=1}^k w_i}\right)^{\frac{1}{p}-1}
-     * \frac{\sum_{i=1}^k w_i p y_i^{p-1} y'_i}{\sum_{i=1}^k w_i}$.
-     * When p = 0 we take the geometric average as a reference, which results in:
-     * $\frac{\partial\bar y}{\partial x} =
-     * \exp\left(\frac{\sum_{i=1}^k w_i \log\left(y_i\right)}{\sum_{i=1}^k w_i}\right)
-     * \frac{\sum_{i=1}^k\frac{w_i y'_i}{y_i}}{\sum_{i=1}^k w_i}$
-     * and when $p \le -1000$ or $p \ge 1000$ we take the min and max norm respectively.
-     * This means that the derivative is taken which has the min/max value.
-     *
-     * This function has, like the function weighted_p_norm_average been set up to be very tolerant to
-     * strange values, such as negative weights. The only things we require in for the general p is that
-     * the sum of the weights and the sum of the weights times the values to the power p may not be smaller
-     * or equal to zero. Furthermore, when a value is zero, the exponent is smaller then one and the
-     * correspondent weight is non-zero, this corresponds to no resistance in a parallel system. This means
-     * that this 'path' will be followed, and we return the corresponding derivative.
-     *
-     * The implemented special cases (which are minimum (p <= -1000), harmonic average (p = -1), geometric
-     * average (p = 0), arithmetic average (p = 1), and maximum (p >= 1000) ) is, except for the harmonic
-     * average even more tolerant of negative values, because they only require the sum of weights to be non-zero.
-     */
-    template <typename T>
-    T derivative_of_weighted_p_norm_average (const double averaged_parameter,
-                                             const std::vector<double> &weights,
-                                             const std::vector<double> &values,
-                                             const std::vector<T> &derivatives,
-                                             const double p);
-    /**
-     * This function computes a factor which can be used to make sure that the
-     * Jacobian remains positive definite.
-     *
-     * The goal of this function is to find a factor $\alpha$ so that
-     * $2\eta(\varepsilon(\mathbf u)) I \otimes I +  \alpha\left[a \otimes b + b \otimes a\right]$ remains a
-     * positive definite rank-4 tensor (i.e., a positive definite operator mapping
-     * rank-2 tensors to rank-2 tensors). By definition, the whole operator
-     * is symmetric. In the definition above, $a=\varepsilon(\mathbf u)$ is the @p strain_rate
-     * and $b=\frac{\partial\eta(\varepsilon(\mathbf u),p)}{\partial \varepsilon}$ is the derivative of the viscosity
-     * with respect to the strain rate and is given by @p dviscosities_dstrain_rate. Since the viscosity $\eta$
-     * must be positive, there is always a value of $\alpha$ (possibly small) so that the result is a positive
-     * definite operator. In the best case, we want to choose $\alpha=1$ because that corresponds to the full Newton step,
-     * and so the function never returns anything larger than one.
-     *
-     * One can do some algebra to determine what the optimal factor is. We did
-     * this in the Newton paper (Fraters et al., Geophysical Journal
-     * International, 2019) where we derived a factor of
-     * $\frac{2\eta(\varepsilon(\mathbf u))}{\left[1-\frac{b:a}{\|a\| \|b\|} \right]^2\|a\|\|b\|}$,
-     * which we reset to a maximum of one, and if it is smaller then one,
-     * a safety_factor scales the value to make sure that 1-alpha won't get to
-     * close to zero. However, as later pointed out by Yimin Jin, the computation
-     * is wrong, see https://github.com/geodynamics/aspect/issues/5555. Instead,
-     * the function now computes the factor as
-     * $(2 \eta) / (a:b + b:a)$, again capped at a maximal value of 1,
-     * and using a safety factor from below.
-     *
-     * In practice, $a$ and $b$ are almost always parallel to each other,
-     * and $a:b + b:a = 2a:b$, in which case one can drop the factor
-     * of $2$ everywhere in the computations.
-     */
-    template <int dim>
-    double compute_spd_factor(const double eta,
-                              const SymmetricTensor<2,dim> &strain_rate,
-                              const SymmetricTensor<2,dim> &dviscosities_dstrain_rate,
-                              const double SPD_safety_factor);
-
-    /**
-     * Converts an array of size dim to a Point of size dim.
-     */
-    template <int dim>
-    Point<dim> convert_array_to_point(const std::array<double,dim> &array);
-
-    /**
-     * Converts a Point of size dim to an array of size dim.
-     */
-    template <int dim>
-    std::array<double,dim> convert_point_to_array(const Point<dim> &point);
-
-    /**
-     * A class that represents a binary operator between two doubles. The type of
-     * operation is specified on construction time, and can be checked later
-     * by using the operator ==. The operator () executes the operation on two
-     * double parameters and returns the result. This class is helpful for
-     * user specified operations that are not known at compile time.
-     */
-    class Operator
-    {
-      public:
-        /**
-         * An enum of supported operations.
-         */
-        enum operation
-        {
-          uninitialized,
-          add,
-          subtract,
-          minimum,
-          maximum,
-          replace_if_valid
-        };
-
-        /**
-         * The default constructor creates an invalid operation that will fail
-         * if ever executed.
-         */
-        Operator();
-
-        /**
-         * Construct the selected operator.
-         */
-        Operator(const operation op);
-
-        /**
-         * Execute the selected operation with the given parameters and
-         * return the result.
-         */
-        double operator() (const double x, const double y) const;
-
-        /**
-         * Return the comparison result between the current operation and
-         * the one provided as argument.
-         */
-        bool operator== (const operation op) const;
-
-      private:
-        /**
-         * The selected operation of this object.
-         */
-        operation op;
-    };
-
-    /**
-     * Create a vector of operator objects out of a list of strings. Each
-     * entry in the list must match one of the allowed operations.
-     */
-    std::vector<Operator> create_model_operator_list(const std::vector<std::string> &operator_names);
-
-    /**
-     * Create a string of model operators for use in declare_parameters
-     */
-    const std::string get_model_operator_options();
-
-    /**
-     * A function that returns a SymmetricTensor, whose entries are zero, except for
-     * the k'th component, which is set to one. If k is not on the main diagonal the
-     * resulting tensor is symmetrized.
-     */
-    template <int dim>
-    SymmetricTensor<2,dim> nth_basis_for_symmetric_tensors (const unsigned int k);
-
-    /**
-     * A class that represents a point in a chosen coordinate system.
-     */
-    template <int dim>
-    class NaturalCoordinate
-    {
-      public:
-        /**
-         * Constructor based on providing the geometry model as a pointer.
-         */
-        NaturalCoordinate(Point<dim> &position,
-                          const GeometryModel::Interface<dim> &geometry_model);
-
-        /**
-         * Constructor based on providing the coordinates and associated
-         * coordinate system.
-         */
-        NaturalCoordinate(const std::array<double, dim> &coord,
-                          const Utilities::Coordinates::CoordinateSystem &coord_system);
-
-        /**
-         * Returns the coordinates in the given coordinate system, which may
-         * not be Cartesian.
-         */
-        std::array<double,dim> &get_coordinates();
-
-        /**
-         * Returns the coordinates in the given coordinate system, which may
-         * not be Cartesian.
-         */
-        const std::array<double,dim> &get_coordinates() const;
-
-        /**
-         * The coordinate that represents the 'surface' directions in the
-         * chosen coordinate system.
-         */
-        std::array<double,dim-1> get_surface_coordinates() const;
-
-        /**
-         * The coordinate that represents the 'depth' direction in the chosen
-         * coordinate system.
-         */
-        double get_depth_coordinate() const;
-
-      private:
-        /**
-         * An enum which stores the coordinate system of this natural
-         * point
-         */
-        Utilities::Coordinates::CoordinateSystem coordinate_system;
-
-        /**
-         * An array which stores the coordinates in the coordinates system
-         */
-        std::array<double,dim> coordinates;
-    };
-
-
-    /**
-     * Compute the cellwise projection of component @p component_index of @p function to the finite element space
-     * described by @p dof_handler.
-     *
-     * @param[in] mapping The mapping object to use.
-     * @param[in] dof_handler The DoFHandler the describes the finite element space to
-     * project into and that corresponds to @p vec_result.
-     * @param[in] component_index The component index of the @p dof_handler for which
-     * the projection is being performed. This component should be described by
-     * a DG finite element.
-     * @param[in] quadrature  The quadrature formula to use to evaluate @p function on each cell.
-     * @param[in] function The function to project into the finite element space.
-     * This function should store the value of the function at the points described
-     * by the 2nd argument into the 3rd argument as an std::vector<double>
-     * of size quadrature.size().
-     * @param[out] vec_result The output vector where the projected function will be
-     * stored in.
-     */
-    template <int dim, typename VectorType>
-    void
-    project_cellwise(const Mapping<dim>                                        &mapping,
-                     const DoFHandler<dim>                                     &dof_handler,
-                     const unsigned int                                         component_index,
-                     const Quadrature<dim>                                     &quadrature,
-                     const std::function<void(
-                       const typename DoFHandler<dim>::active_cell_iterator &,
-                       const std::vector<Point<dim>> &,
-                       std::vector<double> &)>                                 &function,
-                     VectorType                                                &vec_result);
-
-    /**
-     * Throw an exception that a linear solver failed with some helpful information for the user.
-     * This function is needed because we have multiple solvers that all require similar treatment
-     * and we would like to keep the output consistent. If the optional parameter
-     * @p output_filename is given, the solver history is additionally written to this file.
-     *
-     * @p solver_name A name that identifies the solver and appears in the error message.
-     * @p function_name The name of the function that used the solver (to identify where in the code
-     *   a solver failed).
-     * @p solver_controls One or more solver controls that describe the history of the solver(s)
-     *   that failed. The reason the function takes multiple controls is we sometimes use
-     *   multi-stage solvers, e.g. we try a cheap solver first, and use an expensive solver if the
-     *   cheap solver fails.
-     * @p exc The exception that was thrown by the solver when it failed, containing additional
-     *   information about what happened.
-     * @p mpi_communicator The MPI Communicator of the problem.
-     * @p output_filename An optional file name into which (if present) the solver history will
-     *   be written.
-     *
-     * @return This function never returns normally. It always exits via an exception, either
-     *   of type ExcMessage (on rank 0 of the parallel computation) or QuietException (on all
-     *   other ranks).
-     */
-    void throw_linear_solver_failure_exception(const std::string &solver_name,
-                                               const std::string &function_name,
-                                               const std::vector<SolverControl> &solver_controls,
-                                               const std::exception &exc,
-                                               const MPI_Comm mpi_communicator,
-                                               const std::string &output_filename = "");
-
-    /**
-     * Conversion object where one can provide a function that returns
-     * a tensor for the velocity at a given point and it returns something
-     * that matches the dealii::Function interface with a number of output
-     * components equal to the number of components of the finite element
-     * in use.
-     */
-    template <int dim>
-    class VectorFunctionFromVelocityFunctionObject : public Function<dim>
-    {
-      public:
-        /**
-         * Given a function object that takes a Point and returns a Tensor<1,dim>,
-         * convert this into an object that matches the Function@<dim@>
-         * interface.
-         *
-         * @param n_components total number of components of the finite element system.
-         * @param function_object The function that will form one component
-         *     of the resulting Function object.
-         */
-        VectorFunctionFromVelocityFunctionObject (const unsigned int n_components,
-                                                  const std::function<Tensor<1,dim> (const Point<dim> &)> &function_object);
-
-        /**
-         * Return the value of the
-         * function at the given
-         * point. Returns the value the
-         * function given to the constructor
-         * produces for this point.
-         */
-        double value (const Point<dim>   &p,
-                      const unsigned int  component = 0) const override;
-
-        /**
-         * Return all components of a
-         * vector-valued function at a
-         * given point.
-         *
-         * <tt>values</tt> shall have the right
-         * size beforehand,
-         * i.e. #n_components.
-         */
-        void vector_value (const Point<dim>   &p,
-                           Vector<double>     &values) const override;
-
-      private:
-        /**
-         * The function object which we call when this class's value() or
-         * value_list() functions are called.
-         */
-        const std::function<Tensor<1,dim> (const Point<dim> &)> function_object;
-    };
-
-    /**
-     * Create and return a permutation vector which can be used by the
-     * apply_permutation() function to put the vector in sorted order.
-     *
-     * @param vector vector to sort
-     */
-    template <typename T>
-    inline
-    std::vector<std::size_t>
-    compute_sorting_permutation(const std::vector<T> &vector);
-
-    /**
-     * Applies a permutation vector to another vector and return the resulting vector.
-     *
-     * @param vector vector to sort
-     * @param permutation_vector The permutation vector used to sort the input vector.
-     * @return The permuted input vector.
-     */
-    template <typename T>
-    inline
-    std::vector<T>
-    apply_permutation(
-      const std::vector<T> &vector,
-      const std::vector<std::size_t> &permutation_vector);
-
-    /**
-     * Get volume weighted rotation matrices, using random draws to convert
-     * to a discrete number of orientations, weighted by volume.
-     * The input is a vector of volume fractions and a vector of rotation matrices.
-     * The vectors need to have the same length.
-     *
-     * @param volume_fractions a vector of doubles representing the volume fraction of each grain
-     * @param rotation_matrices a vector of 2nd order 3D tensors representing the rotation matrix of each grain
-     * @param n_output_matrices The number of rotation matrices which are output by this function. This can be
-     * different from the number of entries in the volume fraction and rotation matrices vectors.
-     * @param random_number_generator a reference to a mt19937 random number generator.
-     */
-    std::vector<Tensor<2,3>>
-    rotation_matrices_random_draw_volume_weighting(const std::vector<double> &volume_fractions,
-                                                   const std::vector<Tensor<2,3>> &rotation_matrices,
-                                                   const unsigned int n_output_matrices,
-                                                   std::mt19937 &random_number_generator);
-
-    /**
-    * Wraps angle between 0 and 360 degrees.
-    */
-    double wrap_angle(const double angle);
-
-    /**
-     * Compute Z-X-Z Euler angles (https://en.wikipedia.org/wiki/Euler_angles) from rotation matrix.
-     * The Z-X-Z indicates the order of axis rotations to generate the Euler angles.
-     */
-    std::array<double,3> zxz_euler_angles_from_rotation_matrix(const Tensor<2,3> &rotation_matrix);
-
-    /**
-     * Compute rotation matrix from Z-X-Z Euler angles (https://en.wikipedia.org/wiki/Euler_angles)
-     * The Z-X-Z indicates the order of axis axis rotations to generate the Euler angles.
-     */
-    Tensor<2,3> zxz_euler_angles_to_rotation_matrix(const double phi1,
-                                                    const double theta,
-                                                    const double phi2);
-
-  }
-}
-
-
-// inline implementations:
-#ifndef DOXYGEN
-namespace aspect
-{
-  namespace Utilities
-  {
-
-    template <typename T>
-    inline
-    std::vector<T>
-    possibly_extend_from_1_to_N (const std::vector<T> &values,
-                                 const unsigned int N,
-                                 const std::string &id_text)
-    {
-      if (values.size() == 1)
-        {
-          return std::vector<T> (N, values[0]);
-        }
-      else if (values.size() == N)
-        {
-          return values;
-        }
-      else
-        {
-          // Non-specified behavior
-          AssertThrow(false,
-                      ExcMessage("Length of " + id_text + " list must be " +
-                                 "either one or " + Utilities::to_string(N) +
-                                 ". Currently it is " + Utilities::to_string(values.size()) + "."));
-        }
-
-      // This should never happen, but return an empty vector so the compiler
-      // will be happy
-      return std::vector<T> ();
-    }
-
-    inline
-    void
-    extract_composition_values_at_q_point (const std::vector<std::vector<double>> &composition_values,
-                                           const unsigned int q,
-                                           std::vector<double> &composition_values_at_q_point)
-    {
-      Assert(q<composition_values.size(), ExcInternalError());
-      Assert(composition_values_at_q_point.size() > 0,
-             ExcInternalError());
-
-      for (unsigned int k=0; k < composition_values_at_q_point.size(); ++k)
-        {
-          Assert(composition_values[k].size() == composition_values_at_q_point.size(),
-                 ExcInternalError());
-          composition_values_at_q_point[k] = composition_values[k][q];
-        }
-    }
-
-    template <typename T>
-    inline
-    std::vector<std::size_t>
-    compute_sorting_permutation(const std::vector<T> &vector)
-    {
-      std::vector<std::size_t> p(vector.size());
-      std::iota(p.begin(), p.end(), 0);
-      std::sort(p.begin(), p.end(),
-                [&](std::size_t i, std::size_t j)
-      {
-        return vector[i] < vector[j];
-      });
-      return p;
-    }
-
-    template <typename T>
-    inline
-    std::vector<T>
-    apply_permutation(
-      const std::vector<T> &vector,
-      const std::vector<std::size_t> &permutation_vector)
-    {
-      std::vector<T> sorted_vec(vector.size());
-      std::transform(permutation_vector.begin(), permutation_vector.end(), sorted_vec.begin(),
-                     [&](std::size_t i)
-      {
-        return vector[i];
-      });
-      return sorted_vec;
-    }
-
-    /**
-     * Contains utility functions related to tensors.
-     */
-    namespace Tensors
-    {
-      /**
-       * Convert a series of doubles to a SymmetricTensor of the same size.
-       * The input is expected to be ordered according to the
-       * SymmetricTensor::unrolled_to_component_indices() function.
-       */
-      template <int dim, class Iterator>
-      inline
-      SymmetricTensor<2,dim>
-      to_symmetric_tensor(const Iterator begin,
-                          const Iterator end)
-      {
-        AssertDimension(std::distance(begin, end), (SymmetricTensor<2,dim>::n_independent_components));
-        (void) end;
-
-        SymmetricTensor<2,dim> output;
-
-        Iterator next = begin;
-        for (unsigned int i=0; i < SymmetricTensor<2,dim>::n_independent_components; ++i, ++next)
-          output[SymmetricTensor<2,dim>::unrolled_to_component_indices(i)] = *next;
-
-        return output;
-      }
-
-      /**
-       * Unroll a SymmetricTensor into a series of doubles. The output is ordered
-       * according to the SymmetricTensor::unrolled_to_component_indices() function.
-       */
-      template <int dim, class Iterator>
-      inline
-      void
-      unroll_symmetric_tensor_into_array(const SymmetricTensor<2,dim> &tensor,
-                                         const Iterator begin,
-                                         const Iterator end)
-      {
-        AssertDimension(std::distance(begin, end), (SymmetricTensor<2,dim>::n_independent_components));
-        (void) end;
-
-        Iterator next = begin;
-        for (unsigned int i=0; i < SymmetricTensor<2,dim>::n_independent_components; ++i, ++next)
-          *next = tensor[SymmetricTensor<2,dim>::unrolled_to_component_indices(i)];
-      }
-
-      /**
-       * Rotate a 3D 4th order tensor representing the full stiffnexx matrix using a 3D 2nd order rotation tensor
-       */
-      SymmetricTensor<4,3>
-      rotate_full_stiffness_tensor(const Tensor<2,3> &rotation_tensor, const SymmetricTensor<4,3> &input_tensor);
-
-      /**
-       * Rotate a 6x6 voigt stiffness matrix using a 2nd order Voigt stiffness tensor.
-       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
-       */
-      SymmetricTensor<2,6>
-      rotate_voigt_stiffness_matrix(const Tensor<2,3> &rotation_tensor, const SymmetricTensor<2,6> &input_tensor);
-
-      /**
-       * Transform a 4th order full stiffness tensor into a 6x6 Voigt stiffness matrix.
-       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
-       */
-      SymmetricTensor<2,6>
-      to_voigt_stiffness_matrix(const SymmetricTensor<4,3> &input_tensor);
-
-      /**
-       * Transform a 6x6 Voigt stiffness matrix into a 4th order full stiffness tensor.
-       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
-       */
-      SymmetricTensor<4,3>
-      to_full_stiffness_tensor(const SymmetricTensor<2,6> &input_tensor);
-
-      /**
-       * Form a 21D voigt stiffness vector from a 6x6 Voigt stiffness matrix.
-       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
-       */
-      Tensor<1,21>
-      to_voigt_stiffness_vector(const SymmetricTensor<2,6> &input_tensor);
-
-      /**
-       * Form a 21D voigt stiffness vector from a 6x6 Voigt stiffness matrix.
-       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
-       */
-      SymmetricTensor<2,6>
-      to_voigt_stiffness_matrix(const Tensor<1,21> &input_tensor);
-
-      /**
-       * Transform a 4th order full stiffness tensor into a 21D Voigt stiffness vector.
-       * See https://en.wikipedia.org/wiki/Voigt_notation for more info on the Voigt notation.
-       */
-      Tensor<1,21>
-      to_voigt_stiffness_vector(const SymmetricTensor<4,3> &input);
-
-
-      /**
-       * Return the Levi-Civita tensor, also called a permutation or "totally antisymmetric" tensor.
-       * See https://en.wikipedia.org/wiki/Levi-Civita_symbol for a definition.
-       */
-      template <int dim>
-      const Tensor<dim,dim> &levi_civita();
-
-      // Declare the existence of a specialization:
-      template <>
-      const Tensor<3,3> &levi_civita<3>();
-    }
-
-  }
-}
-#endif
-
-#endif
diff --git a/include/aspect/volume_of_fluid/assembly.h.bak b/include/aspect/volume_of_fluid/assembly.h.bak
deleted file mode 100644
index bc212c798e2..00000000000
--- a/include/aspect/volume_of_fluid/assembly.h.bak
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file doc/COPYING.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_volume_of_fluid_assembly_h
-#define _aspect_volume_of_fluid_assembly_h
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim>
-  class Simulator;
-
-  template <int dim>
-  struct VolumeOfFluidField;
-
-  namespace internal
-  {
-    namespace Assembly
-    {
-      namespace Scratch
-      {
-        /**
-         * Standard scratch data structure for matrix assembly
-         */
-        template <int dim>
-        struct VolumeOfFluidSystem
-        {
-          VolumeOfFluidSystem (const FiniteElement<dim> &finite_element,
-                               const FiniteElement<dim> &volume_of_fluid_element,
-                               const Mapping<dim>       &mapping,
-                               const Quadrature<dim>    &quadrature,
-                               const Quadrature<dim-1>  &face_quadrature);
-
-          VolumeOfFluidSystem (const VolumeOfFluidSystem &scratch);
-
-          /**
-           * Add a defaulted assignment operator because relying on it
-           * implicitly is deprecated.
-           */
-          VolumeOfFluidSystem &operator=(const VolumeOfFluidSystem &) = default;
-
-          FEValues<dim>          finite_element_values;
-          FEValues<dim>          neighbor_finite_element_values;
-          FEFaceValues<dim>      face_finite_element_values;
-          FEFaceValues<dim>      neighbor_face_finite_element_values;
-          FESubfaceValues<dim>   subface_finite_element_values;
-
-          std::vector<types::global_dof_index>   local_dof_indices;
-
-          // Field for exact cell volume (needed in some of the face flux calculations)
-          double volume;
-
-          /**
-           * Variables describing the values of the shape functions at the
-           * quadrature points, as they are used in the advection assembly
-           * function. note that the sizes of these arrays are equal to the
-           * number of shape functions corresponding to a single VolumeOfFluid field (and
-           * not of all VolumeOfFluid fields!), and that they are also correspondingly
-           * indexed.
-           */
-          std::vector<double>         phi_field;
-          std::vector<double>         face_phi_field;
-
-          std::vector<double>         old_field_values;
-          /* Vector for interface normal in the unit cell */
-          std::vector<Tensor<1,dim>> cell_i_n_values;
-          /* "Distance" from cell center to interface as d value for the interface in the form $\vec{n}\cdot\vec{x}=d$ */
-          std::vector<double>         cell_i_d_values;
-
-          std::vector<Tensor<1,dim>> face_current_velocity_values;
-          std::vector<Tensor<1,dim>> face_old_velocity_values;
-          std::vector<Tensor<1,dim>> face_old_old_velocity_values;
-
-          std::vector<double>         neighbor_old_values;
-          /* Vector for interface normal in the unit cell */
-          std::vector<Tensor<1,dim>> neighbor_i_n_values;
-          /* "Distance" from cell center to interface as d value for the interface in the form $\vec{n}\cdot\vec{x}=d$ */
-          std::vector<double>         neighbor_i_d_values;
-        };
-      }
-
-      namespace CopyData
-      {
-        /**
-         * Standard copy data structure for matrix assembly
-         */
-        template <int dim>
-        struct VolumeOfFluidSystem
-        {
-          /**
-           * Constructor.
-           * @param finite_element The element that describes the field for which we
-           *    are trying to assemble a linear system. <b>Not</b> the global finite
-           *    element.
-           */
-          VolumeOfFluidSystem(const FiniteElement<dim> &finite_element);
-          VolumeOfFluidSystem(const VolumeOfFluidSystem &data);
-
-          /**
-           * Add a defaulted assignment operator because relying on it
-           * implicitly is deprecated.
-           */
-          VolumeOfFluidSystem &operator=(const VolumeOfFluidSystem &) = default;
-
-          /**
-           * Local contributions to the global matrix and right hand side
-           * that correspond only to the variables listed in local_dof_indices
-           */
-          FullMatrix<double>          local_matrix;
-          Vector<double>              local_rhs;
-
-          /**
-           * Local contributions to the global rhs from the face terms in the
-           * discontinuous Galerkin interpretation of the VolumeOfFluid method.
-           *
-           * The array has a length sufficient to hold one element for each
-           * possible face and sub-face of a cell.
-           */
-          std::vector<Vector<double>> local_face_rhs;
-          std::vector<FullMatrix<double>> local_face_matrices_ext_ext;
-
-          /**
-           * Denotes which face's rhs have actually been assembled in the DG
-           * field assembly. Entries not used (for example, those corresponding
-           * to non-existent subfaces; or faces being assembled by the
-           * neighboring cell) are set to false.
-           *
-           * The array has a length sufficient to hold one element for each
-           * possible face and sub-face of a cell.
-           */
-          std::vector<bool> face_contributions_mask;
-
-          /**
-           * Indices of those degrees of freedom that actually correspond to
-           * the volume_of_fluid field. Since this structure is used to represent just
-           * contributions to the volume_of_fluid systems, there will be no contributions
-           * to other parts of the system and consequently, we do not need to
-           * list here indices that correspond to velocity or pressure degrees
-           * (or, in fact any other variable outside the block we are currently
-           * considering)
-           */
-          std::vector<types::global_dof_index>   local_dof_indices;
-
-          /**
-           * Indices of the degrees of freedom corresponding to the volume_of_fluid field
-           * on all possible neighboring cells. This is used in the
-           * discontinuous Galerkin interpretation of the VolumeOfFluid method.
-           *
-           * The array has a length sufficient to hold one element for each
-           * possible face and sub-face of a cell.
-           */
-          std::vector<std::vector<types::global_dof_index>> neighbor_dof_indices;
-        };
-      }
-    }
-  }
-
-  namespace Assemblers
-  {
-
-    /**
-     * Class to hold VolumeOfFluid assembly logic, as analogous to that used in the main simulator.
-     */
-    template <int dim>
-    class VolumeOfFluidAssembler : public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Do setup and assembly on internal quadrature points and dispatch to
-         * other functions for face assembly
-         */
-        void local_assemble_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
-                                                    const unsigned int calc_dir,
-                                                    const bool update_from_old,
-                                                    const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                                    internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
-                                                    internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const;
-
-        /**
-         * Do assembly for cell faces on the boundary
-         */
-        void local_assemble_boundary_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
-                                                                  const bool update_from_old,
-                                                                  const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                                                  const unsigned int face_no,
-                                                                  internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
-                                                                  internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const;
-
-        /**
-         * Function for assembling face fluxes for VolumeOfFluid system.
-         */
-        void local_assemble_internal_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
-                                                                  const bool update_from_old,
-                                                                  const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                                                  const unsigned int face_no,
-                                                                  internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
-                                                                  internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const;
-
-        /**
-         * Set volume fraction threshold for use in assembly
-         */
-        void set_volume_fraction_threshold(const double value);
-    };
-  }
-}
-
-
-#endif
diff --git a/include/aspect/volume_of_fluid/field.h.bak b/include/aspect/volume_of_fluid/field.h.bak
deleted file mode 100644
index da88e97ec28..00000000000
--- a/include/aspect/volume_of_fluid/field.h.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_volume_of_fluid_field_h
-#define _aspect_volume_of_fluid_field_h
-
-#include <aspect/fe_variable_collection.h>
-
-using namespace dealii;
-
-namespace aspect
-{
-  namespace VolumeOfFluid
-  {
-    /**
-     * A structure that contains enum values that identify type of input data
-     * to allow robust use of sub-mesh scale input that remain valid over
-     * multiple mesh sizes.
-     */
-    struct VolumeOfFluidInputType
-    {
-      enum Kind
-      {
-        /**
-         * Input data is a value between 0 and 1 at all points.
-         */
-        composition,
-        /**
-         * Input data is an interface defined by a signed distance level set
-         * with positive value indicating fluid presence. IE the function has
-         * gradient 1 almost everywhere, is positive where the fluid is, and is
-         * zero on the fluid interface
-         */
-        level_set
-      };
-    };
-  }
-
-  /**
-   * Structure to package the relevant data (both state and cached) in a single
-   * location for access.
-   */
-  template <int dim>
-  struct VolumeOfFluidField
-  {
-    /**
-     * Initialize the structure with FEVariables to hold the required
-     * information that must be available on all cells.
-     */
-    VolumeOfFluidField(const FEVariable<dim> &volume_fraction,
-                       const FEVariable<dim> &reconstruction,
-                       const FEVariable<dim> &level_set,
-                       const unsigned int composition_index);
-
-    /**
-     * Field to hold the current volume fraction.
-     */
-    const FEVariable<dim> &volume_fraction;
-
-    /**
-     * Field to hold the cached interface reconstruction.
-     */
-    const FEVariable<dim> &reconstruction;
-
-    /**
-     * Field to expose reconstructed interface as a zero-contour to output in
-     * visualization plugin.
-     */
-    const FEVariable<dim> &level_set;
-
-    /**
-     * Field index of the associated composition field
-     */
-    const unsigned int composition_index;
-
-  };
-}
-
-#endif
diff --git a/include/aspect/volume_of_fluid/handler.h.bak b/include/aspect/volume_of_fluid/handler.h.bak
deleted file mode 100644
index 56be01c21f6..00000000000
--- a/include/aspect/volume_of_fluid/handler.h.bak
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_volume_of_fluid_handler_h
-#define _aspect_volume_of_fluid_handler_h
-
-#include <aspect/simulator.h>
-#include <aspect/simulator_access.h>
-#include <aspect/volume_of_fluid/field.h>
-#include <aspect/volume_of_fluid/assembly.h>
-
-#include <boost/serialization/map.hpp>
-
-using namespace dealii;
-
-namespace aspect
-{
-  /**
-   * A member class that isolates the functions and variables that deal
-   * with the Volume of Fluid implementation. If Volume of Fluid interface
-   * tracking is not active, there is no instantiation of this class at
-   * all.
-   */
-  template <int dim>
-  class VolumeOfFluidHandler : public SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Standard initial constructor
-       */
-      VolumeOfFluidHandler(Simulator<dim> &simulator, ParameterHandler &prm);
-
-      /**
-       * Add the Volume of Fluid field declaration to the list to be included
-       * in the solution vector.
-       */
-      void edit_finite_element_variables (std::vector<VariableDeclaration<dim>> &vars);
-
-      /**
-       * Declare the parameters this class takes through input files.
-       */
-      static
-      void declare_parameters (ParameterHandler &prm);
-
-      /**
-       * Read the parameters this class declares from the parameter file.
-       */
-      void parse_parameters (ParameterHandler &prm);
-
-      /**
-       * Get the number of volume of fluid fields in current model
-       */
-      unsigned int get_n_fields() const;
-
-      /**
-       * Get the name of volume of fluid field with index i
-       */
-      const std::string name_for_field_index(unsigned int i) const;
-
-      /**
-       * Get the structure containing the variable locations for the volume of
-       * fluid field with index i.
-       */
-      const VolumeOfFluidField<dim> &field_struct_for_field_index(unsigned int i) const;
-
-      /**
-       * Get threshold for volume fraction
-       */
-      double get_volume_fraction_threshold() const;
-
-      /**
-       * Get the local index (within vof fields) for the named composition/volume of fluid field
-       */
-      unsigned int field_index_for_name(const std::string &fieldname) const;
-
-      /**
-       * Do necessary internal initialization that is dependent on having the
-       * simulator and Finite Element initialized.
-       */
-      void initialize (ParameterHandler &prm);
-
-      /**
-       * Do initialization routine for all volume of fluid fields
-       */
-      void set_initial_volume_fractions ();
-
-      /**
-       * Initialize specified field based on a composition field initial condition
-       */
-      void initialize_from_composition_field (const VolumeOfFluidField<dim> &field);
-
-      /**
-       * Initialize specified field based on a level set initial condition
-       */
-      void initialize_from_level_set (const VolumeOfFluidField<dim> &field);
-
-      /**
-       * Do interface reconstruction for specified field and cache result in solution vector
-       */
-      void update_volume_of_fluid_normals (const VolumeOfFluidField<dim> &field,
-                                           LinearAlgebra::BlockVector &solution);
-
-      /**
-       * Use current interface reconstruction to produce a composition field
-       * approximation that is bilinear on the unit cell and write that field
-       * to the specified AdvectionField
-       */
-      void update_volume_of_fluid_composition (const typename Simulator<dim>::AdvectionField &composition_field,
-                                               const VolumeOfFluidField<dim> &volume_of_fluid_field,
-                                               LinearAlgebra::BlockVector &solution);
-
-      /**
-       * Do single timestep update, includes logic for doing Strang split update
-       */
-      void do_volume_of_fluid_update (const typename Simulator<dim>::AdvectionField &advection_field);
-
-      /**
-       * Assemble matrix and RHS for the specified field and dimension
-       * (calculation_dim).  If update_from_old_solution is true, the initial
-       * values for this update step are in old_solution, otherwise the values
-       * in solution are used. This allows a clean restart of the split update
-       * from the last timestep if necessary without requiring the overhead of
-       * copying the data.
-       */
-      void assemble_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
-                                            const unsigned int calculation_dim,
-                                            const bool update_from_old_solution);
-
-      /**
-       * Solve the diagonal matrix assembled in assemble_volume_of_fluid_system for the
-       * specified field.
-       */
-      void solve_volume_of_fluid_system (const VolumeOfFluidField<dim> &field);
-
-
-    private:
-      /**
-       * Parent simulator
-       */
-      Simulator<dim> &sim;
-
-      /**
-       * Function to copy assembled data to final system. Requires access to
-       * the full matrix, so must be in this class.
-       */
-      void copy_local_to_global_volume_of_fluid_system (const internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data);
-
-      /**
-       * Assembler object used for doing the matrix and RHS assembly
-       */
-      Assemblers::VolumeOfFluidAssembler<dim> assembler;
-
-      /**
-       * Number of volume of fluid fields to calculate for
-       */
-      unsigned int n_volume_of_fluid_fields;
-
-      /**
-       * Structures containing the locations of the associated state data for
-       * each volume of fluid field.
-       */
-      std::vector<VolumeOfFluidField<dim>> data;
-
-      /**
-       * Volume fraction threshold for the reconstruction and advection
-       * algorithms indicating minimum relevant volume fraction.
-       */
-      double volume_fraction_threshold;
-
-      /**
-       * Tolerance to use for the Newton iteration in the reconstruction step
-       */
-      static constexpr double volume_of_fluid_reconstruct_epsilon = 1e-13;
-
-      /**
-       * Tolerance to use for the matrix solve in the timestep update
-       */
-      double volume_of_fluid_solver_tolerance;
-
-      /**
-       * Number of samples in each dimension to use during the Volume of Fluid
-       * initialization, for a total of $n_init_samples^dim$ points sampled
-       */
-      unsigned int n_init_samples;
-
-      /**
-       * Vector of human readable names for the volume of fluid fields,
-       * obtained from the associated composition field name
-       */
-      std::vector<std::string> volume_of_fluid_field_names;
-
-      /**
-       * Map relating the index of a Volume of Fluid based composition field to the index of the corresponding Volume of Fluid field.
-       */
-      std::map<unsigned int, unsigned int> volume_of_fluid_composition_map_index;
-
-      /**
-       * Methods to use when initializing the volume of fluid fields.  Must be
-       * held here as all access to the actual methods for composition
-       * initialization is handled by the manager.
-       */
-      std::vector<VolumeOfFluid::VolumeOfFluidInputType::Kind> initialization_data_type;
-
-      friend class Simulator<dim>;
-  };
-
-}
-
-#endif
diff --git a/include/aspect/volume_of_fluid/utilities.h.bak b/include/aspect/volume_of_fluid/utilities.h.bak
deleted file mode 100644
index bb04f2a64d4..00000000000
--- a/include/aspect/volume_of_fluid/utilities.h.bak
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- Copyright (C) 2016 - 2020-2018 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file doc/COPYING.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _aspect_volume_of_fluid_utilities_h
-#define _aspect_volume_of_fluid_utilities_h
-
-#include <deal.II/base/point.h>
-
-#include <aspect/global.h>
-
-namespace aspect
-{
-  namespace VolumeOfFluid
-  {
-    namespace Utilities
-    {
-      using namespace dealii;
-
-      /**
-       * Function to calculate volume fraction contained by indicator function
-       * H(d-normal*(x'-x_{cen}')) on the [0, 1]^dim unit cell where x_{cen} is
-       * the unit cell center.
-       *
-       * Currently only works assuming constant Jacobian determinant.
-       */
-      double compute_fluid_fraction (const Tensor<1, 2> normal,
-                                     const double d);
-      double compute_fluid_fraction (const Tensor<1, 3> normal,
-                                     const double d);
-
-      /**
-       * Function to calculate required value of d to obtain given volume
-       * fraction for indicator function H(d-normal*(x'-x_{cen}')) on the [0,
-       * 1]^dim unit cell where x_{cen} is the unit cell center.
-       *
-       * Currently only works assuming constant Jacobian determinant.
-       */
-      double compute_interface_location (const Tensor<1, 2> normal,
-                                         const double volume_fraction);
-      double compute_interface_location (const Tensor<1, 3> normal,
-                                         const double volume_fraction);
-
-      /**
-       * Obtain values at points for a polynomial function that is equivalent to
-       * the Heaviside function $H(d-normal*xhat)$ on the unit cell when
-       * integrated against polynomials of up to the specified degree.
-       *
-       * Currently works for degree <=1
-       *
-       * @param degree Maximum degree for exact integration
-       * @param normal Interface normal vector, pointed away from the included region
-       * @param d Interface parameter specifying location of interface in unit cell
-       * @param points Locations to evaluate the constructed polynomial
-       * @param values Values of the constructed polynomial at the specified points
-       */
-      void xFEM_Heaviside(const unsigned int degree,
-                          const Tensor<1, 2> normal,
-                          const double d,
-                          const std::vector<Point<2>> &points,
-                          std::vector<double> &values);
-      void xFEM_Heaviside(const unsigned int degree,
-                          const Tensor<1, 3> normal,
-                          const double d,
-                          const std::vector<Point<3>> &points,
-                          std::vector<double> &values);
-
-      /**
-       * Obtain values at points for a polynomial function that is equivalent to
-       * the function $\frac{d}{dd}H(d-normal*xhat)$ on the unit cell when
-       * integrated against polynomials of up to the specified degree.
-       *
-       * Currently works for degree <=1
-       *
-       * @param degree Maximum degree for exact integration
-       * @param normal Interface normal vector, pointed away from the included region
-       * @param d Interface parameter specifying location of interface in unit cell
-       * @param points Locations to evaluate the constructed polynomial
-       * @param values Values of the constructed polynomial at the specified points
-       */
-      void xFEM_Heaviside_derivative_d(const unsigned int degree,
-                                       const Tensor<1, 2> normal,
-                                       const double d,
-                                       const std::vector<Point<2>> &points,
-                                       std::vector<double> &values);
-      void xFEM_Heaviside_derivative_d(const unsigned int degree,
-                                       const Tensor<1, 3> normal,
-                                       const double d,
-                                       const std::vector<Point<3>> &points,
-                                       std::vector<double> &values);
-
-
-      /**
-       * Function to do Newton iteration calculation of correct d for a given
-       * normal to get volume_fraction from xFEM_Heaviside integrated against the given
-       * weights.
-       *
-       * @param degree Maximum degree for exact integration
-       * @param normal Interface normal vector, pointed away from the included region
-       * @param volume_fraction Cell volume fraction in physical space - used for target value for integration
-       * @param vol Cell volume in physical space - used for target value for integration
-       * @param epsilon Tolerance for Newton iteration
-       * @param points Quadrature points to use for update
-       * @param weights JxW values to use for quadrature
-       */
-      template <int dim>
-      double compute_interface_location_newton(const unsigned int degree,
-                                               const Tensor<1, dim, double> normal,
-                                               const double volume_fraction,
-                                               const double vol,
-                                               const double epsilon,
-                                               const std::vector<Point<dim>> &points,
-                                               const std::vector<double> &weights);
-
-      /**
-       * Function to calculate volume contained by indicator function
-       * $H(d-normal*(x'-x_{cen}'))$ on the $[0, 1]^dim$ unit cell where
-       * $x_{cen}$ is the unit cell center, using a polynomial mapping of
-       * degree up to "degree".
-       *
-       * @param degree Maximum degree for exact integration
-       * @param normal Interface normal vector, pointed away from the included region
-       * @param d Interface parameter specifying location of interface in unit cell by distance from cell center
-       * @param points Quadrature points to use for update
-       * @param weights JxW values to use for quadrature
-       */
-      template <int dim>
-      double compute_fluid_volume(const unsigned int degree,
-                                  const Tensor<1, dim, double> normal,
-                                  const double d,
-                                  const std::vector<Point<dim>> &points,
-                                  const std::vector<double> &weights);
-
-      /**
-       * Function to calculate flux volume fraction based on a method of
-       * characteristics approximation of the interface on the cell's face over
-       * the timestep. Calculation assumes an approximation to the interface of the form
-       * $H(d-normal*(x'-x_{face center})-time_direction_derivative*t')$ where
-       * $t'$ is in terms of a "unit timestep".
-       *
-       * @param compute_direction Dimension of unit cell we are currently computing along
-       * @param time_direction_derivative Approximated gradient in time for the "level set" describing the interface.
-       * @param interface_normal_in_cell The normal vector for the current interface reconstruction in the computing cell.
-       * @param d_at_face_center The correct d value to for the interface description on the face we are computing for.
-       */
-      template <int dim>
-      double calculate_volume_flux (const unsigned int compute_direction,
-                                    const double time_direction_derivative,
-                                    const Tensor<1, dim, double> interface_normal_in_cell,
-                                    const double d_at_face_center);
-    }
-  }
-}
-
-#endif
diff --git a/source/adiabatic_conditions/ascii_data.cc.bak b/source/adiabatic_conditions/ascii_data.cc.bak
deleted file mode 100644
index b472abd43b3..00000000000
--- a/source/adiabatic_conditions/ascii_data.cc.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-  Copyright (C) 2016 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/adiabatic_conditions/ascii_data.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData()
-      :
-      initialized(false),
-      temperature_index(numbers::invalid_unsigned_int),
-      pressure_index(numbers::invalid_unsigned_int),
-      density_index(numbers::invalid_unsigned_int)
-    {}
-
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      if (initialized)
-        return;
-
-      this->initialize(this->get_mpi_communicator());
-      temperature_index = this->get_column_index_from_name("temperature");
-      pressure_index = this->get_column_index_from_name("pressure");
-      density_index = this->get_column_index_from_name("density");
-
-      initialized = true;
-    }
-
-
-
-    template <int dim>
-    bool
-    AsciiData<dim>::is_initialized() const
-    {
-      return initialized;
-    }
-
-
-
-    template <int dim>
-    double AsciiData<dim>::pressure (const Point<dim> &p) const
-    {
-      const double depth = this->get_geometry_model().depth(p);
-      return this->get_data_component(Point<1>(depth),pressure_index);
-    }
-
-
-
-    template <int dim>
-    double AsciiData<dim>::temperature (const Point<dim> &p) const
-    {
-      const double depth = this->get_geometry_model().depth(p);
-      return this->get_data_component(Point<1>(depth),temperature_index);
-    }
-
-
-
-    template <int dim>
-    double AsciiData<dim>::density (const Point<dim> &p) const
-    {
-      const double depth = this->get_geometry_model().depth(p);
-      return this->get_data_component(Point<1>(depth),density_index);
-    }
-
-
-
-    template <int dim>
-    double AsciiData<dim>::density_derivative (const Point<dim> &p) const
-    {
-      const double depth = this->get_geometry_model().depth(p);
-      const double eps = std::sqrt(std::numeric_limits<double>::epsilon()) * this->get_geometry_model().maximal_depth();
-      return (this->get_data_component(Point<1>(depth+eps),density_index)
-              -
-              this->get_data_component(Point<1>(depth),density_index))
-             /
-             eps;
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                          "$ASPECT_SOURCE_DIR/tests/adiabatic-conditions/ascii-data/test/",
-                                                          "");
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        Utilities::AsciiDataBase<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(AsciiData,
-                                               "ascii data",
-                                               "A model in which the adiabatic profile is "
-                                               "read from a file that describes the reference "
-                                               "state. Note the required format of the "
-                                               "input data: The first lines may contain any number of comments "
-                                               "if they begin with `#', but one of these lines needs to "
-                                               "contain the number of points in the reference state as "
-                                               "for example `# POINTS: 3'. "
-                                               "Following the comment lines there has to be a single line "
-                                               "containing the names of all data columns, separated by arbitrarily "
-                                               "many spaces. Column names are not allowed to contain spaces. "
-                                               "The file can contain unnecessary columns, but for this plugin it "
-                                               "needs to at least provide columns named `temperature', `pressure', "
-                                               "and `density'. "
-                                               "Note that the data lines in the file need to be sorted in order "
-                                               "of increasing depth from 0 to the maximal depth in the model "
-                                               "domain. Points in the model that are outside of the provided "
-                                               "depth range will be assigned the maximum or minimum depth values, "
-                                               "respectively. Points do not need to be equidistant, "
-                                               "but the computation of properties is optimized in speed "
-                                               "if they are.")
-  }
-}
diff --git a/source/adiabatic_conditions/compute_entropy_profile.cc.bak b/source/adiabatic_conditions/compute_entropy_profile.cc.bak
deleted file mode 100644
index ab2f7a072ad..00000000000
--- a/source/adiabatic_conditions/compute_entropy_profile.cc.bak
+++ /dev/null
@@ -1,315 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/adiabatic_conditions/compute_entropy_profile.h>
-#include <aspect/gravity_model/interface.h>
-
-#include <deal.II/base/signaling_nan.h>
-
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    template <int dim>
-    ComputeEntropyProfile<dim>::ComputeEntropyProfile()
-      :
-      initialized(false)
-    {}
-
-
-
-    template <int dim>
-    void
-    ComputeEntropyProfile<dim>::initialize()
-    {
-      if (initialized)
-        return;
-
-      temperatures.resize(n_points, numbers::signaling_nan<double>());
-      pressures.resize(n_points, numbers::signaling_nan<double>());
-      densities.resize(n_points, numbers::signaling_nan<double>());
-
-      delta_z = this->get_geometry_model().maximal_depth() / (n_points-1);
-
-      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
-      this->get_material_model().create_additional_named_outputs (out);
-
-      MaterialModel::PrescribedTemperatureOutputs<dim> *prescribed_temperature_out
-        = out.template get_additional_output<MaterialModel::PrescribedTemperatureOutputs<dim>>();
-
-      // check if the material model computes prescribed temperature outputs
-      AssertThrow(prescribed_temperature_out != nullptr,
-                  ExcMessage("The material model you use does not provide "
-                             "PrescribedTemperatureOutputs, which is required "
-                             "for this adiabatic conditions plugin."));
-
-      const std::vector<unsigned int> entropy_indices = this->introspection().get_indices_for_fields_of_type(CompositionalFieldDescription::entropy);
-      // TODO : need to make it work for more than one field
-      AssertThrow(entropy_indices.size() >= 1,
-                  ExcMessage("The 'compute entropy' adiabatic conditions plugin "
-                             "requires at least one field of type 'entropy'."));
-
-      // Constant properties on the reference profile
-      // We only need the material model to compute the density
-      in.requested_properties = MaterialModel::MaterialProperties::density | MaterialModel::MaterialProperties::additional_outputs;
-      in.velocity[0] = Tensor <1,dim> ();
-      // The entropy along an adiabat is constant (equals the surface entropy)
-      // When there is more than one entropy field, we use the background field to compute the adiabatic profile
-      // TODO : provide more ways to specify compositional fields like in compute_profile.cc
-      for (unsigned int i=0; i < this->n_compositional_fields(); ++i)
-        in.composition[0][i] = 0;
-
-      in.composition[0][entropy_indices[0]] = surface_entropy;
-
-      // Check whether gravity is pointing up / out or down / in. In the normal case it should
-      // point down / in and therefore gravity should be positive, leading to increasing
-      // adiabatic pressures and temperatures with depth. In some cases it will point up / out
-      // (e.g. for backward advection), in which case the pressures and temperatures should
-      // decrease with depth and therefore gravity has to be negative in the following equations.
-      const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(this->get_geometry_model().representative_point(0));
-      const Point<dim> point_surf = this->get_geometry_model().representative_point(0);
-      const Point<dim> point_bot = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
-      const int gravity_direction =  (g * (point_bot - point_surf) >= 0) ?
-                                     1 :
-                                     -1;
-
-      // now integrate downward using the explicit Euler method for simplicity
-      //
-      // note: p'(z) = rho(p,T) * |g|
-      //       T(z) = look up for reference entropy and current p(z)
-      for (unsigned int i=0; i<n_points; ++i)
-        {
-          if (i==0)
-            {
-              pressures[0] = this->get_surface_pressure();
-            }
-          else
-            {
-              // use material properties calculated at i-1
-              const double density = out.densities[0];
-              // get the magnitude of gravity. we assume
-              // that gravity always points along the depth direction. this
-              // may not strictly be true always but is likely a good enough
-              // approximation here.
-              const double gravity = gravity_direction * this->get_gravity_model().gravity_vector(in.position[0]).norm();
-
-              pressures[i] = pressures[i-1] + density * gravity * delta_z;
-            }
-
-          const double z = static_cast<double>(i)/static_cast<double>(n_points-1)*this->get_geometry_model().maximal_depth();
-          const Point<dim> representative_point = this->get_geometry_model().representative_point (z);
-
-          in.position[0] = representative_point;
-          in.pressure[0] = pressures[i];
-          this->get_material_model().evaluate(in, out);
-
-          densities[i] = out.densities[0];
-          temperatures[i] = prescribed_temperature_out->prescribed_temperature_outputs[0];
-        }
-
-      if (gravity_direction == 1 && this->get_surface_pressure() >= 0)
-        {
-          Assert (*std::min_element (pressures.begin(), pressures.end()) >=
-                  -std::numeric_limits<double>::epsilon() * pressures.size(),
-                  ExcMessage("Adiabatic ComputeProfile encountered a negative pressure of "
-                             + dealii::Utilities::to_string(*std::min_element (pressures.begin(), pressures.end()))));
-        }
-      else if (gravity_direction == -1 && this->get_surface_pressure() <= 0)
-        {
-          Assert (*std::max_element (pressures.begin(), pressures.end()) <=
-                  std::numeric_limits<double>::epsilon() * pressures.size(),
-                  ExcMessage("Adiabatic ComputeProfile encountered a positive pressure of "
-                             + dealii::Utilities::to_string(*std::max_element (pressures.begin(), pressures.end()))));
-        }
-
-      Assert (*std::min_element (temperatures.begin(), temperatures.end()) >=
-              -std::numeric_limits<double>::epsilon() * temperatures.size(),
-              ExcMessage("Adiabatic ComputeProfile encountered a negative temperature."));
-
-
-      initialized = true;
-    }
-
-
-
-    template <int dim>
-    bool
-    ComputeEntropyProfile<dim>::is_initialized() const
-    {
-      return initialized;
-    }
-
-
-
-    template <int dim>
-    double ComputeEntropyProfile<dim>::pressure (const Point<dim> &p) const
-    {
-      return get_property(p,pressures);
-    }
-
-
-
-    template <int dim>
-    double ComputeEntropyProfile<dim>::temperature (const Point<dim> &p) const
-    {
-      return get_property(p,temperatures);
-    }
-
-
-
-    template <int dim>
-    double ComputeEntropyProfile<dim>::density (const Point<dim> &p) const
-    {
-      return get_property(p,densities);
-    }
-
-
-
-    template <int dim>
-    double ComputeEntropyProfile<dim>::density_derivative (const Point<dim> &p) const
-    {
-      const double z = this->get_geometry_model().depth(p);
-
-      if (z >= this->get_geometry_model().maximal_depth())
-        {
-          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
-                  ExcInternalError());
-          return (densities.back() - densities[densities.size()-2]) / delta_z;
-        }
-
-      if (z < 0)
-        {
-          Assert (z >= -delta_z, ExcInternalError());
-          return (densities[1] - densities.front()) / delta_z;
-        }
-
-      // if z/delta_z is within [k-eps, k+eps] of a whole number k, round it down to k-1
-      const unsigned int i = static_cast<unsigned int>((z/delta_z) * (1. - 2. * std::numeric_limits<double>::epsilon()));
-      Assert (i < densities.size() - 1, ExcInternalError());
-
-      return (densities[i+1]-densities[i])/delta_z;
-    }
-
-
-
-    template <int dim>
-    double ComputeEntropyProfile<dim>::get_property (const Point<dim> &p,
-                                                     const std::vector<double> &property) const
-    {
-      const double z = this->get_geometry_model().depth(p);
-
-      if (z >= this->get_geometry_model().maximal_depth())
-        {
-          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
-                  ExcInternalError());
-          return property.back();
-        }
-
-      if (z <= 0)
-        {
-          Assert (z >= -delta_z, ExcInternalError());
-          return property.front();
-        }
-
-      const double floating_index = z/delta_z;
-      const unsigned int i = static_cast<unsigned int>(floating_index);
-
-      // If p is close to an existing value use that one. This prevents
-      // asking for values at i+1 while initializing i+1 (when p is at the
-      // depth of index i).
-      if (std::abs(floating_index-std::floor(floating_index+0.5)) < 1e-6)
-        return property[i];
-
-      Assert (i+1 < property.size(), ExcInternalError());
-
-      // now do the linear interpolation
-      const double d = floating_index - i;
-      Assert ((d>=0) && (d<=1), ExcInternalError());
-
-      return d*property[i+1] + (1.-d)*property[i];
-    }
-
-
-
-
-    template <int dim>
-    void
-    ComputeEntropyProfile<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        prm.enter_subsection("Compute entropy profile");
-        {
-          prm.declare_entry ("Number of points", "1000",
-                             Patterns::Integer (5),
-                             "The number of points we use to compute the adiabatic "
-                             "profile. The higher the number of points, the more accurate "
-                             "the downward integration from the adiabatic surface "
-                             "conditions will be.");
-
-          prm.declare_entry ("Surface entropy", "0",
-                             Patterns::Double(),
-                             "The surface entropy for the profile.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    ComputeEntropyProfile<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        prm.enter_subsection("Compute entropy profile");
-        {
-          n_points = prm.get_integer ("Number of points");
-          surface_entropy = prm.get_double ("Surface entropy");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(ComputeEntropyProfile,
-                                               "compute entropy profile",
-                                               "A model in which the adiabatic profile is "
-                                               "calculated by solving the hydrostatic equations for "
-                                               "pressure and entropy in depth. "
-                                               "Of course the entropy along an adiabat is constant. "
-                                               "This plugin requires the material model to provide an "
-                                               "additional output object of type PrescribedTemperatureOutputs. "
-                                               "It also requires that there is a compositional field of type "
-                                               "'entropy' that represents the entropy of the material.")
-  }
-}
diff --git a/source/adiabatic_conditions/compute_profile.cc.bak b/source/adiabatic_conditions/compute_profile.cc.bak
deleted file mode 100644
index 5ef8d23bc22..00000000000
--- a/source/adiabatic_conditions/compute_profile.cc.bak
+++ /dev/null
@@ -1,427 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/adiabatic_conditions/compute_profile.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/initial_composition/interface.h>
-
-#include <deal.II/base/signaling_nan.h>
-
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    template <int dim>
-    ComputeProfile<dim>::ComputeProfile()
-      :
-      initialized(false),
-      surface_condition_function(2)
-    {}
-
-
-
-    template <int dim>
-    void
-    ComputeProfile<dim>::update()
-    {
-      if (use_surface_condition_function)
-        {
-          initialized = false;
-          surface_condition_function.set_time(this->get_time());
-          initialize();
-        }
-    }
-
-
-    template <int dim>
-    void
-    ComputeProfile<dim>::initialize()
-    {
-      if (initialized)
-        return;
-
-      // The simulator only keeps the initial conditions around for
-      // the first time step. As a consequence, we have to save a
-      // shared pointer to that object ourselves the first time we get
-      // here.
-      if ((reference_composition == initial_composition)
-          &&
-          (initial_composition_manager == nullptr))
-        initial_composition_manager = this->get_initial_composition_manager_pointer();
-
-      temperatures.resize(n_points, numbers::signaling_nan<double>());
-      pressures.resize(n_points, numbers::signaling_nan<double>());
-      densities.resize(n_points, numbers::signaling_nan<double>());
-
-      delta_z = this->get_geometry_model().maximal_depth() / (n_points-1);
-
-      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
-
-      // Constant properties on the reference profile
-      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties;
-      in.velocity[0] = Tensor <1,dim> ();
-
-      // Check whether gravity is pointing up / out or down / in. In the normal case it should
-      // point down / in and therefore gravity should be positive, leading to increasing
-      // adiabatic pressures and temperatures with depth. In some cases it will point up / out
-      // (e.g. for backward advection), in which case the pressures and temperatures should
-      // decrease with depth and therefore gravity has to be negative in the following equations.
-      const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(this->get_geometry_model().representative_point(0));
-      const Point<dim> point_surf = this->get_geometry_model().representative_point(0);
-      const Point<dim> point_bot = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
-      const int gravity_direction =  (g * (point_bot - point_surf) >= 0) ?
-                                     1 :
-                                     -1;
-
-      // now integrate downward using the explicit Euler method for simplicity
-      //
-      // note: p'(z) = rho(p,T) * |g|
-      //       T'(z) = alpha |g| T / C_p
-      for (unsigned int i=0; i<n_points; ++i)
-        {
-          if (i==0)
-            {
-              if (!use_surface_condition_function)
-                {
-                  pressures[0] = this->get_surface_pressure();
-                  temperatures[0] = this->get_adiabatic_surface_temperature();
-                }
-              else
-                {
-                  pressures[0] = surface_condition_function.value(Point<1>(0.0),0);
-                  temperatures[0] = surface_condition_function.value(Point<1>(0.0),1);
-                }
-            }
-          else
-            {
-              // use material properties calculated at i-1
-              const double density = out.densities[0];
-              const double alpha = out.thermal_expansion_coefficients[0];
-              // Handle the case that cp is zero (happens in simple Stokes test problems like sol_cx). By setting
-              // 1/cp = 0.0 we will have a constant temperature profile with depth.
-              const double one_over_cp = (out.specific_heat[0]>0.0) ? 1.0/out.specific_heat[0] : 0.0;
-              // get the magnitude of gravity. we assume
-              // that gravity always points along the depth direction. this
-              // may not strictly be true always but is likely a good enough
-              // approximation here.
-              const double gravity = gravity_direction * this->get_gravity_model().gravity_vector(in.position[0]).norm();
-
-              pressures[i] = pressures[i-1] + density * gravity * delta_z;
-              temperatures[i] = (this->include_adiabatic_heating())
-                                ?
-                                temperatures[i-1] * (1 + alpha * gravity * delta_z * one_over_cp)
-                                :
-                                temperatures[0];
-            }
-
-          const double z = static_cast<double>(i)/static_cast<double>(n_points-1)*this->get_geometry_model().maximal_depth();
-          const Point<dim> representative_point = this->get_geometry_model().representative_point (z);
-          const Tensor <1,dim> g = this->get_gravity_model().gravity_vector(representative_point);
-
-          in.position[0] = representative_point;
-          in.temperature[0] = temperatures[i];
-          in.pressure[0] = pressures[i];
-
-          // we approximate the pressure gradient by extrapolating the values
-          // from the two points above
-          if (i>0)
-            in.pressure_gradient[0] = g/(g.norm() != 0.0 ? g.norm() : 1.0)
-                                      * (pressures[i] - pressures[i-1]) / delta_z;
-          else
-            in.pressure_gradient[0] = Tensor <1,dim> ();
-
-          if (reference_composition == initial_composition)
-            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-              in.composition[0][c] = initial_composition_manager->initial_composition(representative_point, c);
-          else if (reference_composition == reference_function)
-            {
-              const double depth = this->get_geometry_model().depth(representative_point);
-              const Point<1> p(depth);
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                in.composition[0][c] = composition_function->value(p, c);
-            }
-          else
-            AssertThrow(false,ExcNotImplemented());
-
-          this->get_material_model().evaluate(in, out);
-
-          densities[i] = out.densities[0];
-        }
-
-      if (gravity_direction == 1 && this->get_surface_pressure() >= 0)
-        {
-          Assert (*std::min_element (pressures.begin(), pressures.end()) >=
-                  -std::numeric_limits<double>::epsilon() * pressures.size(),
-                  ExcMessage("Adiabatic ComputeProfile encountered a negative pressure of "
-                             + dealii::Utilities::to_string(*std::min_element (pressures.begin(), pressures.end()))));
-        }
-      else if (gravity_direction == -1 && this->get_surface_pressure() <= 0)
-        {
-          Assert (*std::max_element (pressures.begin(), pressures.end()) <=
-                  std::numeric_limits<double>::epsilon() * pressures.size(),
-                  ExcMessage("Adiabatic ComputeProfile encountered a positive pressure of "
-                             + dealii::Utilities::to_string(*std::max_element (pressures.begin(), pressures.end()))));
-        }
-
-      Assert (*std::min_element (temperatures.begin(), temperatures.end()) >=
-              -std::numeric_limits<double>::epsilon() * temperatures.size(),
-              ExcMessage("Adiabatic ComputeProfile encountered a negative temperature."));
-
-
-      initialized = true;
-    }
-
-
-
-    template <int dim>
-    bool
-    ComputeProfile<dim>::is_initialized() const
-    {
-      return initialized;
-    }
-
-
-
-    template <int dim>
-    double ComputeProfile<dim>::pressure (const Point<dim> &p) const
-    {
-      return get_property(p,pressures);
-    }
-
-
-
-    template <int dim>
-    double ComputeProfile<dim>::temperature (const Point<dim> &p) const
-    {
-      return get_property(p,temperatures);
-    }
-
-
-
-    template <int dim>
-    double ComputeProfile<dim>::density (const Point<dim> &p) const
-    {
-      return get_property(p,densities);
-    }
-
-
-
-    template <int dim>
-    double ComputeProfile<dim>::density_derivative (const Point<dim> &p) const
-    {
-      const double z = this->get_geometry_model().depth(p);
-
-      if (z >= this->get_geometry_model().maximal_depth())
-        {
-          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
-                  ExcInternalError());
-          return (densities.back() - densities[densities.size()-2]) / delta_z;
-        }
-
-      if (z < 0)
-        {
-          Assert (z >= -delta_z, ExcInternalError());
-          return (densities[1] - densities.front()) / delta_z;
-        }
-
-      // if z/delta_z is within [k-eps, k+eps] of a whole number k, round it down to k-1
-      const unsigned int i = static_cast<unsigned int>((z/delta_z) * (1. - 2. * std::numeric_limits<double>::epsilon()));
-      Assert (i < densities.size() - 1, ExcInternalError());
-
-      return (densities[i+1]-densities[i])/delta_z;
-    }
-
-
-
-    template <int dim>
-    double ComputeProfile<dim>::get_property (const Point<dim> &p,
-                                              const std::vector<double> &property) const
-    {
-      const double z = this->get_geometry_model().depth(p);
-
-      if (z >= this->get_geometry_model().maximal_depth())
-        {
-          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
-                  ExcInternalError());
-          return property.back();
-        }
-
-      if (z <= 0)
-        {
-          Assert (z >= -delta_z, ExcInternalError());
-          return property.front();
-        }
-
-      const double floating_index = z/delta_z;
-      const unsigned int i = static_cast<unsigned int>(floating_index);
-
-      // If p is close to an existing value use that one. This prevents
-      // asking for values at i+1 while initializing i+1 (when p is at the
-      // depth of index i).
-      if (std::abs(floating_index-std::floor(floating_index+0.5)) < 1e-6)
-        return property[i];
-
-      Assert (i+1 < property.size(), ExcInternalError());
-
-      // now do the linear interpolation
-      const double d = floating_index - i;
-      Assert ((d>=0) && (d<=1), ExcInternalError());
-
-      return d*property[i+1] + (1.-d)*property[i];
-    }
-
-
-
-
-    template <int dim>
-    void
-    ComputeProfile<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        prm.enter_subsection("Compute profile");
-        {
-          Functions::ParsedFunction<1>::declare_parameters (prm, 1);
-          prm.declare_entry("Composition reference profile","initial composition",
-                            Patterns::Selection("initial composition|function"),
-                            "Select how the reference profile for composition "
-                            "is computed. This profile is used to evaluate the "
-                            "material model, when computing the pressure and "
-                            "temperature profile.");
-          prm.declare_entry ("Number of points", "1000",
-                             Patterns::Integer (5),
-                             "The number of points we use to compute the adiabatic "
-                             "profile. The higher the number of points, the more accurate "
-                             "the downward integration from the adiabatic surface "
-                             "temperature will be.");
-          prm.declare_entry ("Use surface condition function", "false",
-                             Patterns::Bool(),
-                             "Whether to use the 'Surface condition function' to determine surface "
-                             "conditions, or the 'Adiabatic surface temperature' and 'Surface pressure' "
-                             "parameters. If this is set to true the reference profile is updated "
-                             "every timestep. The function expression of the function should be "
-                             "independent of space, but can depend on time 't'. The function must "
-                             "return two components, the first one being reference surface pressure, "
-                             "the second one being reference surface temperature.");
-
-          prm.enter_subsection("Surface condition function");
-          {
-            Functions::ParsedFunction<1>::declare_parameters (prm, 2);
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ComputeProfile<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        prm.enter_subsection("Compute profile");
-        {
-          const std::string composition_profile = prm.get("Composition reference profile");
-
-          if (composition_profile == "initial composition")
-            reference_composition = initial_composition;
-          else if (composition_profile == "function")
-            reference_composition = reference_function;
-          else
-            AssertThrow(false, ExcNotImplemented());
-
-          if ((this->n_compositional_fields() > 0) && (reference_composition == reference_function))
-            {
-              composition_function
-                = std::make_unique<Functions::ParsedFunction<1>>(this->n_compositional_fields());
-              try
-                {
-                  composition_function->parse_parameters (prm);
-                }
-              catch (...)
-                {
-                  std::cerr << "ERROR: FunctionParser failed to parse\n"
-                            << "\t'Adiabatic conditions model.compute profile'\n"
-                            << "with expression\n"
-                            << "\t'" << prm.get("Function expression") << "'"
-                            << "More information about the cause of the parse error \n"
-                            << "is shown below.\n";
-                  throw;
-                }
-            }
-
-          n_points = prm.get_integer ("Number of points");
-          use_surface_condition_function = prm.get_bool("Use surface condition function");
-          if (use_surface_condition_function)
-            {
-              prm.enter_subsection("Surface condition function");
-              try
-                {
-                  surface_condition_function.parse_parameters (prm);
-                }
-              catch (...)
-                {
-                  std::cerr << "ERROR: FunctionParser failed to parse\n"
-                            << "\t'Adiabatic conditions model.Initial profile.Surface condition function'\n"
-                            << "with expression\n"
-                            << "\t'" << prm.get("Function expression") << "'"
-                            << "More information about the cause of the parse error \n"
-                            << "is shown below.\n";
-                  throw;
-                }
-              prm.leave_subsection();
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(ComputeProfile,
-                                               "compute profile",
-                                               "A model in which the adiabatic profile is "
-                                               "calculated by solving the hydrostatic equations for "
-                                               "pressure and temperature in depth. "
-                                               "The gravity is assumed to be in depth direction "
-                                               "and the composition is either given by the initial "
-                                               "composition at reference points or computed "
-                                               "as a reference depth-function. "
-                                               "All material parameters are computed by the "
-                                               "material model plugin. The surface conditions are "
-                                               "either constant or changing over time as prescribed "
-                                               "by a user-provided function.")
-  }
-}
diff --git a/source/adiabatic_conditions/function.cc.bak b/source/adiabatic_conditions/function.cc.bak
deleted file mode 100644
index ddad051d8b6..00000000000
--- a/source/adiabatic_conditions/function.cc.bak
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
-  Copyright (C) 2016 - 2017 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/adiabatic_conditions/function.h>
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    template <int dim>
-    Function<dim>::Function()
-      : function (3)
-    {}
-
-    template <int dim>
-    void
-    Function<dim>::initialize()
-    {
-    }
-
-    template <int dim>
-    bool
-    Function<dim>::is_initialized() const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    double Function<dim>::pressure (const Point<dim> &p) const
-    {
-      const double z = this->get_geometry_model().depth(p);
-      return function.value(Point<1>(z), 1);
-    }
-
-
-
-    template <int dim>
-    double Function<dim>::temperature (const Point<dim> &p) const
-    {
-      const double z = this->get_geometry_model().depth(p);
-      return function.value(Point<1>(z), 0);
-    }
-
-    template <int dim>
-    double Function<dim>::density (const Point<dim> &p) const
-    {
-      const double z = this->get_geometry_model().depth(p);
-      return function.value(Point<1>(z), 2);
-    }
-
-
-
-    template <int dim>
-    double Function<dim>::density_derivative (const Point<dim> &p) const
-    {
-      // TODO: better eps or make it a user input
-      const double z = this->get_geometry_model().depth(p);
-      const double z2 = z + (1.e6 * std::numeric_limits<double>::epsilon())
-                        * this->get_geometry_model().maximal_depth();
-      return (function.value(Point<1>(z), 2)
-              - function.value(Point<1>(z2), 2))/(z-z2);
-    }
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        prm.enter_subsection("Function");
-        Functions::ParsedFunction<1>::declare_parameters (prm, 3);
-        prm.declare_entry("Function expression","0.0; 0.0; 1.0",
-                          Patterns::Anything(),
-                          "Expression for the adiabatic temperature, "
-                          "pressure, and density separated by "
-                          "semicolons as a function of `depth'.");
-        prm.declare_entry("Variable names","depth");
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Adiabatic conditions model");
-      {
-        prm.enter_subsection("Function");
-        try
-          {
-            function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Adiabatic conditions model.Function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    ASPECT_REGISTER_ADIABATIC_CONDITIONS_MODEL(Function,
-                                               "function",
-                                               "A model in which the adiabatic profile is "
-                                               "specified by a user defined function. The "
-                                               "supplied function has to contain "
-                                               "temperature, pressure, and density as a function "
-                                               "of depth in this order.")
-  }
-}
diff --git a/source/adiabatic_conditions/interface.cc.bak b/source/adiabatic_conditions/interface.cc.bak
deleted file mode 100644
index 05619b509a0..00000000000
--- a/source/adiabatic_conditions/interface.cc.bak
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace AdiabaticConditions
-  {
-    template <int dim>
-    void Interface<dim>::get_adiabatic_temperature_profile(std::vector<double> &values) const
-    {
-      const unsigned int num_slices = values.size();
-      const double max_depth = this->get_geometry_model().maximal_depth();
-      AssertThrow(num_slices > 1, ExcInternalError());
-
-      for (unsigned int n = 0 ; n < num_slices; ++n)
-        {
-          const double depth = n * max_depth / (num_slices-1);
-          const Point<dim> p = this->get_geometry_model().representative_point(depth);
-          values[n] = temperature(p);
-        }
-    }
-
-
-    template <int dim>
-    void Interface<dim>::get_adiabatic_pressure_profile(std::vector<double> &values) const
-    {
-      const unsigned int num_slices = values.size();
-      const double max_depth = this->get_geometry_model().maximal_depth();
-      AssertThrow(num_slices > 1, ExcInternalError());
-
-      for (unsigned int n = 0 ; n < num_slices; ++n)
-        {
-          const double depth = n * max_depth / (num_slices-1);
-          const Point<dim> p = this->get_geometry_model().representative_point(depth);
-          values[n] = pressure(p);
-        }
-    }
-
-    template <int dim>
-    void Interface<dim>::get_adiabatic_density_profile(std::vector<double> &values) const
-    {
-      const unsigned int num_slices = values.size();
-      const double max_depth = this->get_geometry_model().maximal_depth();
-      AssertThrow(num_slices > 1, ExcInternalError());
-
-      for (unsigned int n = 0 ; n < num_slices; ++n)
-        {
-          const double depth = n * max_depth / (num_slices-1);
-          const Point<dim> p = this->get_geometry_model().representative_point(depth);
-          values[n] = density(p);
-        }
-    }
-
-    template <int dim>
-    void Interface<dim>::get_adiabatic_density_derivative_profile(std::vector<double> &values) const
-    {
-      const unsigned int num_slices = values.size();
-      const double max_depth = this->get_geometry_model().maximal_depth();
-      AssertThrow(num_slices > 1, ExcInternalError());
-
-      for (unsigned int n = 0 ; n < num_slices; ++n)
-        {
-          const double depth = n * max_depth / (num_slices-1);
-          const Point<dim> p = this->get_geometry_model().representative_point(depth);
-          values[n] = density_derivative(p);
-        }
-    }
-
-
-// -------------------------------- Deal with registering models and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    register_adiabatic_conditions (const std::string &name,
-                                   const std::string &description,
-                                   void (*declare_parameters_function) (ParameterHandler &),
-                                   std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_adiabatic_conditions (ParameterHandler &prm)
-    {
-      std::string model_name;
-      prm.enter_subsection ("Adiabatic conditions model");
-      {
-        model_name = prm.get ("Model name");
-      }
-      prm.leave_subsection ();
-
-      std::unique_ptr<Interface<dim>>plugin = std::get<dim>(registered_plugins).create_plugin (model_name,
-                                               "Adiabatic Conditions model::Model name");
-
-      return plugin;
-
-    }
-
-
-
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm)
-    {
-      // declare the entry in the parameter file
-      prm.enter_subsection ("Adiabatic conditions model");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry ("Model name", "compute profile",
-                           Patterns::Selection (pattern_of_names),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Adiabatic conditions interface",
-                                                            out);
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<AdiabaticConditions::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<AdiabaticConditions::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<AdiabaticConditions::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<AdiabaticConditions::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace AdiabaticConditions
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_adiabatic_conditions<dim> (const std::string &, \
-                                      const std::string &, \
-                                      void ( *) (ParameterHandler &), \
-                                      std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_adiabatic_conditions<dim> (ParameterHandler &prm);
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/boundary_composition/ascii_data.cc.bak b/source/boundary_composition/ascii_data.cc.bak
deleted file mode 100644
index 69c9d179284..00000000000
--- a/source/boundary_composition/ascii_data.cc.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_composition/ascii_data.h>
-
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      = default;
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      Utilities::AsciiDataBoundary<dim>::initialize(this->get_fixed_composition_boundary_indicators(),
-                                                    this->n_compositional_fields());
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::update ()
-    {
-      Interface<dim>::update ();
-
-      Utilities::AsciiDataBoundary<dim>::update();
-    }
-
-
-    template <int dim>
-    double
-    AsciiData<dim>::
-    boundary_composition (const types::boundary_id boundary_indicator,
-                          const Point<dim> &position,
-                          const unsigned int compositional_field) const
-    {
-      return Utilities::AsciiDataBoundary<dim>::get_data_component(boundary_indicator,
-                                                                   position,
-                                                                   compositional_field);
-    }
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
-                                                              "$ASPECT_SOURCE_DIR/data/boundary-composition/ascii-data/test/",
-                                                              "box_2d_%s.%d.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(AsciiData,
-                                               "ascii data",
-                                               "Implementation of a model in which the boundary "
-                                               "composition is derived from files containing data "
-                                               "in ascii format. Note the required format of the "
-                                               "input data: The first lines may contain any number of comments "
-                                               "if they begin with `#', but one of these lines needs to "
-                                               "contain the number of grid points in each dimension as "
-                                               "for example `# POINTS: 3 3'. "
-                                               "The order of the data columns "
-                                               "has to be `x', `composition1', `composition2', "
-                                               "etc. in a 2d model and "
-                                               "`x', `y', `composition1', `composition2', "
-                                               "etc., in a 3d model, according "
-                                               "to the number of compositional fields, which means that "
-                                               "there has to be a single column "
-                                               "for every composition in the model. "
-                                               "Note that the data in the input "
-                                               "files need to be sorted in a specific order: "
-                                               "the first coordinate needs to ascend first, "
-                                               "followed by the second in order to "
-                                               "assign the correct data to the prescribed coordinates."
-                                               "If you use a spherical model, "
-                                               "then the assumed grid changes. `x' will be replaced by "
-                                               "the radial distance of the point to the bottom of the model, "
-                                               "`y' by the azimuth angle and `z' by the polar angle measured "
-                                               "positive from the north pole. The grid will be assumed to be "
-                                               "a latitude-longitude grid. Note that the order "
-                                               "of spherical coordinates is `r', `phi', `theta' "
-                                               "and not `r', `theta', `phi', since this allows "
-                                               "for dimension independent expressions.")
-  }
-}
diff --git a/source/boundary_composition/box.cc.bak b/source/boundary_composition/box.cc.bak
deleted file mode 100644
index 1dd7d357f1e..00000000000
--- a/source/boundary_composition/box.cc.bak
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_composition/box.h>
-#include <aspect/geometry_model/box.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-// ------------------------------ Box -------------------
-
-    template <int dim>
-    double
-    Box<dim>::
-    boundary_composition (const types::boundary_id boundary_indicator,
-                          const Point<dim> &/*position*/,
-                          const unsigned int compositional_field) const
-    {
-      Assert (boundary_indicator<2*dim, ExcMessage ("The given boundary indicator needs to be less than 2*dimension.."));
-      return composition_values[boundary_indicator][compositional_field];
-    }
-
-    template <int dim>
-    void
-    Box<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Box");
-        {
-          prm.declare_entry ("Left composition", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the left boundary (at minimal $x$-value). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          prm.declare_entry ("Right composition", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the right boundary (at maximal $x$-value). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          prm.declare_entry ("Bottom composition", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the bottom boundary (at minimal $y$-value in 2d, or minimal "
-                             "$z$-value in 3d). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          prm.declare_entry ("Top composition", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the top boundary (at maximal $y$-value in 2d, or maximal "
-                             "$z$-value in 3d). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          if (dim==3)
-            {
-              prm.declare_entry ("Front composition", "",
-                                 Patterns::List(Patterns::Double ()),
-                                 "A comma separated list of composition boundary values "
-                                 "at the front boundary (at minimum $y$-value). This list must have as many "
-                                 "entries as there are compositional fields. Units: none.");
-              prm.declare_entry ("Back composition", "",
-                                 Patterns::List(Patterns::Double ()),
-                                 "A comma separated list of composition boundary values "
-                                 "at the back boundary (at maximum $y$-value). This list must have as many "
-                                 "entries as there are compositional fields. Units: none.");
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    Box<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Box");
-        {
-          switch (dim)
-            {
-              case 2:
-                composition_values[0] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition")));
-                composition_values[1] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition")));
-                composition_values[2] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Bottom composition")));
-                composition_values[3] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Top composition")));
-                break;
-
-              case 3:
-                composition_values[0] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition")));
-                composition_values[1] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition")));
-                composition_values[2] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Front composition")));
-                composition_values[3] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Back composition")));
-                composition_values[4] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Bottom composition")));
-                composition_values[5] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Top composition")));
-                break;
-
-              default:
-                Assert (false, ExcNotImplemented());
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-
-    template <int dim>
-    void
-    Box<dim>::initialize()
-    {
-      // verify that the geometry is a box since only for this geometry
-      // do we know for sure what boundary indicators it uses and what they mean
-      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
-                   ExcMessage ("This boundary model is only implemented if the geometry is "
-                               "a box."));
-
-      // Verify that each of the lists for boundary values
-      // has the requisite number of elements if it is in the set
-      // of prescribed boundary indicators.
-      for (unsigned int f=0; f<2*dim; ++f)
-        if (this->get_boundary_composition_manager().get_fixed_composition_boundary_indicators().count(f) != 0)
-          AssertThrow (composition_values[f].size() == this->n_compositional_fields(),
-                       ExcMessage (std::string("The specification of boundary composition values for the `box' model "
-                                               "requires as many values on each face of the box as there are compositional "
-                                               "fields. However, for face ")
-                                   +
-                                   Utilities::int_to_string(f)
-                                   +
-                                   ", the input file specifies "
-                                   +
-                                   Utilities::int_to_string(composition_values[f].size())
-                                   +
-                                   " values even though there are "
-                                   +
-                                   Utilities::int_to_string(this->n_compositional_fields())
-                                   +
-                                   " compositional fields."));
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(Box,
-                                               "box",
-                                               "A model in which the composition is chosen constant on "
-                                               "the sides of a box which are selected by the parameters "
-                                               "Left/Right/Top/Bottom/Front/Back composition")
-  }
-}
diff --git a/source/boundary_composition/function.cc.bak b/source/boundary_composition/function.cc.bak
deleted file mode 100644
index 2c8a172dc51..00000000000
--- a/source/boundary_composition/function.cc.bak
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_composition/function.h>
-#include <aspect/utilities.h>
-#include <aspect/global.h>
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-
-    template <int dim>
-    double
-    Function<dim>::
-    boundary_composition (const types::boundary_id /*boundary_indicator*/,
-                          const Point<dim> &position,
-                          const unsigned int compositional_field) const
-    {
-      const Utilities::NaturalCoordinate<dim> point =
-        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
-      return function->value(Utilities::convert_array_to_point<dim>(point.get_coordinates()), compositional_field);
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::update()
-    {
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        function->set_time (this->get_time() / year_in_seconds);
-      else
-        function->set_time (this->get_time());
-    }
-
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Function");
-        {
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are 'cartesian', 'spherical', and 'depth'. "
-                             "'spherical' coordinates are interpreted as r,phi "
-                             "or r,phi,theta in 2d/3d respectively with theta "
-                             "being the polar angle. 'depth' will create a "
-                             "function, in which only the first parameter is "
-                             "non-zero, which is interpreted to be the depth of "
-                             "the point.");
-
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Function");
-        {
-          coordinate_system = ::aspect::Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-
-          try
-            {
-              function
-                = std::make_unique<Functions::ParsedFunction<dim>>(this->n_compositional_fields());
-              function->parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Boundary composition model.Function'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(Function,
-                                               "function",
-                                               "Implementation of a model in which the boundary "
-                                               "composition is given in terms of an explicit formula "
-                                               "that is elaborated in the parameters in section "
-                                               "``Boundary composition model|Function''. "
-                                               "\n\n"
-                                               "Since the symbol $t$ indicating time "
-                                               "may appear in the formulas for the prescribed "
-                                               "composition, it is interpreted as having units "
-                                               "seconds unless the global input parameter ``Use "
-                                               "years in output instead of seconds'' is set, in "
-                                               "which case we interpret the formula expressions "
-                                               "as having units year."
-                                               "\n\n"
-                                               "The format of these "
-                                               "functions follows the syntax understood by the "
-                                               "muparser library, see "
-                                               "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-  }
-}
diff --git a/source/boundary_composition/initial_composition.cc.bak b/source/boundary_composition/initial_composition.cc.bak
deleted file mode 100644
index 1e96a2d761f..00000000000
--- a/source/boundary_composition/initial_composition.cc.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_composition/initial_composition.h>
-#include <aspect/initial_composition/interface.h>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-// ------------------------------ InitialComposition -------------------
-
-    template <int dim>
-    void
-    InitialComposition<dim>::initialize()
-    {
-      // Make sure we keep track of the initial composition manager and
-      // that it continues to live beyond the time when the simulator
-      // class releases its pointer to it.
-      initial_composition = this->get_initial_composition_manager_pointer();
-    }
-
-
-
-    template <int dim>
-    double
-    InitialComposition<dim>::
-    boundary_composition (const types::boundary_id /*boundary_indicator*/,
-                          const Point<dim> &position,
-                          const unsigned int compositional_field) const
-    {
-      return initial_composition->initial_composition(position, compositional_field);
-    }
-
-
-    template <int dim>
-    double
-    InitialComposition<dim>::
-    minimal_composition (const std::set<types::boundary_id> &) const
-    {
-      return min_composition;
-    }
-
-
-
-    template <int dim>
-    double
-    InitialComposition<dim>::
-    maximal_composition (const std::set<types::boundary_id> &) const
-    {
-      return max_composition;
-    }
-
-
-
-    template <int dim>
-    void
-    InitialComposition<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Initial composition");
-        {
-          prm.declare_entry ("Minimal composition", "0.",
-                             Patterns::Double (),
-                             "Minimal composition. Units: none.");
-          prm.declare_entry ("Maximal composition", "1.",
-                             Patterns::Double (),
-                             "Maximal composition. Units: none.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    InitialComposition<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Initial composition");
-        {
-          min_composition = prm.get_double ("Minimal composition");
-          max_composition = prm.get_double ("Maximal composition");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(InitialComposition,
-                                               "initial composition",
-                                               "A model in which the composition at the boundary "
-                                               "is chosen to be the same as given in the initial "
-                                               "conditions."
-                                               "\n\n"
-                                               "Because this class simply takes what the initial "
-                                               "composition had described, this class can not "
-                                               "know certain pieces of information such as the "
-                                               "minimal and maximal composition on the boundary. "
-                                               "For operations that require this, for example in "
-                                               "post-processing, this boundary composition model "
-                                               "must therefore be told what the minimal and "
-                                               "maximal values on the boundary are. This is done "
-                                               "using parameters set in section ``Boundary composition model/Initial composition''.")
-  }
-}
diff --git a/source/boundary_composition/interface.cc.bak b/source/boundary_composition/interface.cc.bak
deleted file mode 100644
index 91719a1e34f..00000000000
--- a/source/boundary_composition/interface.cc.bak
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_composition/interface.h>
-
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/exceptions.h>
-#include <deal.II/base/signaling_nan.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    // ------------------------------ Manager -----------------------------
-    // -------------------------------- Deal with registering boundary_composition models and automating
-    // -------------------------------- their setup and selection at run time
-
-    template <int dim>
-    Manager<dim>::~Manager()
-      = default;
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::update ()
-    {
-      for (auto &p : this->plugin_objects)
-        p->update();
-    }
-
-
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_boundary_composition (const std::string &name,
-                                                 const std::string &description,
-                                                 void (*declare_parameters_function) (ParameterHandler &),
-                                                 std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // find out which plugins are requested and the various other
-      // parameters we declare here
-      prm.enter_subsection ("Boundary composition model");
-      {
-        model_names
-          = Utilities::split_string_list(prm.get("List of model names"));
-
-        AssertThrow(Utilities::has_unique_entries(model_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Boundary composition model/List of model names' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-
-        const std::string model_name = prm.get ("Model name");
-
-        AssertThrow (model_name == "unspecified" || model_names.size() == 0,
-                     ExcMessage ("The parameter 'Model name' is only used for reasons"
-                                 "of backwards compatibility and can not be used together with "
-                                 "the new functionality 'List of model names'. Please add your "
-                                 "boundary composition model to the list instead."));
-
-        if (!(model_name == "unspecified"))
-          model_names.push_back(model_name);
-
-        // create operator list
-        std::vector<std::string> model_operator_names =
-          Utilities::possibly_extend_from_1_to_N (Utilities::split_string_list(prm.get("List of model operators")),
-                                                  model_names.size(),
-                                                  "List of model operators");
-        model_operators = Utilities::create_model_operator_list(model_operator_names);
-
-        try
-          {
-            const std::vector<types::boundary_id> x_fixed_composition_boundary_indicators
-              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids (Utilities::split_string_list
-                                                                                     (prm.get ("Fixed composition boundary indicators")));
-            fixed_composition_boundary_indicators
-              = std::set<types::boundary_id> (x_fixed_composition_boundary_indicators.begin(),
-                                              x_fixed_composition_boundary_indicators.end());
-
-            // If model names have been set, but no boundaries on which to use them,
-            // ignore the set values, do not create objects that are never used.
-            if (fixed_composition_boundary_indicators.size() == 0)
-              {
-                model_names.clear();
-                model_operators.clear();
-              }
-          }
-        catch (const std::string &error)
-          {
-            AssertThrow (false, ExcMessage ("While parsing the entry <Model settings/Fixed composition "
-                                            "boundary indicators>, there was an error. Specifically, "
-                                            "the conversion function complained as follows:\n\n"
-                                            + error));
-          }
-
-        if (prm.get ("Allow fixed composition on outflow boundaries") == "true")
-          allow_fixed_composition_on_outflow_boundaries = true;
-        else if (prm.get ("Allow fixed composition on outflow boundaries") == "false")
-          allow_fixed_composition_on_outflow_boundaries = false;
-        else if (prm.get ("Allow fixed composition on outflow boundaries") == "false for models without melt")
-          allow_fixed_composition_on_outflow_boundaries = this->get_parameters().include_melt_transport;
-        else
-          AssertThrow(false, ExcMessage("'Allow fixed composition on outflow boundaries' "
-                                        "must be set to 'true' or 'false', or to its default value."));
-      }
-      prm.leave_subsection ();
-
-      // go through the list, create objects and let them parse
-      // their own parameters
-      for (auto &model_name : model_names)
-        {
-          // create boundary composition objects
-          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
-                                          (std::get<dim>(registered_plugins)
-                                           .create_plugin (model_name,
-                                                           "Boundary composition::Model names")));
-
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(this->plugin_objects.back().get()))
-            sim->initialize_simulator (this->get_simulator());
-
-          this->plugin_objects.back()->parse_parameters (prm);
-          this->plugin_objects.back()->initialize ();
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    Manager<dim>::boundary_composition (const types::boundary_id boundary_indicator,
-                                        const Point<dim> &position,
-                                        const unsigned int compositional_field) const
-    {
-      double composition = 0.0;
-
-      auto p = this->plugin_objects.begin();
-      for (unsigned int i=0; i<this->plugin_objects.size(); ++p, ++i)
-        composition = model_operators[i](composition,
-                                         (*p)->boundary_composition(boundary_indicator,
-                                                                    position,
-                                                                    compositional_field));
-
-      return composition;
-    }
-
-
-
-    template <int dim>
-    const std::vector<std::string> &
-    Manager<dim>::get_active_boundary_composition_names () const
-    {
-      return model_names;
-    }
-
-
-    template <int dim>
-    const std::list<std::unique_ptr<Interface<dim>>> &
-    Manager<dim>::get_active_boundary_composition_conditions () const
-    {
-      return this->plugin_objects;
-    }
-
-
-
-    template <int dim>
-    const std::set<types::boundary_id> &
-    Manager<dim>::get_fixed_composition_boundary_indicators() const
-    {
-      return fixed_composition_boundary_indicators;
-    }
-
-
-
-    template <int dim>
-    bool
-    Manager<dim>::allows_fixed_composition_on_outflow_boundaries() const
-    {
-      return allow_fixed_composition_on_outflow_boundaries;
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // declare the entry in the parameter file
-      prm.enter_subsection ("Boundary composition model");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry("List of model names",
-                          "",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma-separated list of boundary composition models that "
-                          "will be used to initialize the composition. "
-                          "These plugins are loaded in the order given, and modify the "
-                          "existing composition field via the operators listed "
-                          "in 'List of model operators'.\n\n"
-                          "The following boundary composition models are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-
-        prm.declare_entry("List of model operators", "add",
-                          Patterns::MultipleSelection(Utilities::get_model_operator_options()),
-                          "A comma-separated list of operators that "
-                          "will be used to append the listed composition models onto "
-                          "the previous models. If only one operator is given, "
-                          "the same operator is applied to all models.");
-
-        prm.declare_entry ("Model name", "unspecified",
-                           Patterns::Selection (pattern_of_names+"|unspecified"),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string()
-                           + "\n\n" +
-                           "\\textbf{Warning}: This parameter provides an old and "
-                           "deprecated way of specifying "
-                           "boundary composition models and shouldn't be used. "
-                           "Please use 'List of model names' instead.");
-
-        prm.declare_entry ("Fixed composition boundary indicators", "",
-                           Patterns::List (Patterns::Anything()),
-                           "A comma separated list of names denoting those boundaries "
-                           "on which the composition is fixed and described by the "
-                           "boundary composition object selected in its own section "
-                           "of this input file. All boundary indicators used by the geometry "
-                           "but not explicitly listed here will end up with no-flux "
-                           "(insulating) boundary conditions."
-                           "\n\n"
-                           "The names of the boundaries listed here can either be "
-                           "numbers (in which case they correspond to the numerical "
-                           "boundary indicators assigned by the geometry object), or they "
-                           "can correspond to any of the symbolic names the geometry object "
-                           "may have provided for each part of the boundary. You may want "
-                           "to compare this with the documentation of the geometry model you "
-                           "use in your model."
-                           "\n\n"
-                           "This parameter only describes which boundaries have a fixed "
-                           "composition, but not what composition should hold on these "
-                           "boundaries. The latter piece of information needs to be "
-                           "implemented in a plugin in the BoundaryComposition "
-                           "group, unless an existing implementation in this group "
-                           "already provides what you want.");
-        prm.declare_entry ("Allow fixed composition on outflow boundaries", "false for models without melt",
-                           Patterns::Selection("true|false|false for models without melt"),
-                           "When the composition is fixed on a given boundary as determined "
-                           "by the list of 'Fixed composition boundary indicators', there "
-                           "might be parts of the boundary where material flows out and "
-                           "one may want to prescribe the composition only on those parts of "
-                           "the boundary where there is inflow. This parameter determines "
-                           "if compositions are only prescribed at these inflow parts of the "
-                           "boundary (if false) or everywhere on a given boundary, independent "
-                           "of the flow direction (if true). By default, this parameter is set "
-                           "to false, except in models with melt transport (see below). "
-                           "Note that in this context, `fixed' refers to the fact that these "
-                           "are the boundary indicators where Dirichlet boundary conditions are "
-                           "applied, and does not imply that the boundary composition is "
-                           "time-independent. "
-                           "\n\n"
-                           "Mathematically speaking, the compositional fields satisfy an "
-                           "advection equation that has no diffusion. For this equation, one "
-                           "can only impose Dirichlet boundary conditions (i.e., prescribe a "
-                           "fixed compositional field value at the boundary) at those boundaries "
-                           "where material flows in. This would correspond to the ``false'' "
-                           "setting of this parameter, which is correspondingly the default. "
-                           "On the other hand, on a finite dimensional discretization such as "
-                           "the one one obtains from the finite element method, it is possible "
-                           "to also prescribe values on outflow boundaries, even though this may "
-                           "make no physical sense. This would then correspond to the ``true'' "
-                           "setting of this parameter. Note however that this parameter is only "
-                           "taken into account for the continuous field method and is not "
-                           "applied to the Discontinuous Galerkin (DG) field method. "
-                           "\n\n"
-                           "A warning for models with melt transport: In models with fluid flow, "
-                           "some compositional fields (in particular the porosity) might be "
-                           "transported with the fluid velocity, and would need to set the "
-                           "constraints based on the fluid velocity. However, this is currently "
-                           "not possible, because we reuse the same matrix for all compositional "
-                           "fields, and therefore can not use different constraints for different "
-                           "fields. Consequently, we set this parameter to true by default in "
-                           "models where melt transport is enabled. Be aware that if you change "
-                           "this default setting, you will not use the melt velocity, but the solid "
-                           "velocity to determine on which parts of the boundaries there is outflow.");
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary composition interface",
-                                                            out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryComposition::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryComposition::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryComposition::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryComposition::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace BoundaryComposition
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/boundary_composition/spherical_constant.cc.bak b/source/boundary_composition/spherical_constant.cc.bak
deleted file mode 100644
index 7c9694813d0..00000000000
--- a/source/boundary_composition/spherical_constant.cc.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
-  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <deal.II/base/signaling_nan.h>
-#include <aspect/boundary_composition/spherical_constant.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    template <int dim>
-    void
-    SphericalConstant<dim>::
-    initialize ()
-    {
-      // verify that the geometry is supported by this plugin
-      AssertThrow ( Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) ||
-                    Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()) ||
-                    Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()) ||
-                    Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()),
-                    ExcMessage ("This boundary model is only implemented if the geometry is "
-                                "one of the spherical geometries."));
-
-      // no inner boundary in a full sphere
-      if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()))
-        inner_boundary_indicator = numbers::invalid_unsigned_int;
-      else
-        inner_boundary_indicator = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
-
-      outer_boundary_indicator = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-    }
-
-
-
-    template <int dim>
-    double
-    SphericalConstant<dim>::
-    boundary_composition (const types::boundary_id boundary_indicator,
-                          const Point<dim> &/*position*/,
-                          const unsigned int compositional_field) const
-    {
-      if (boundary_indicator == outer_boundary_indicator)
-        return outer_composition[compositional_field];
-      else if (boundary_indicator == inner_boundary_indicator)
-        return inner_composition[compositional_field];
-      else
-        AssertThrow (false,
-                     ExcMessage ("Unknown boundary indicator for geometry model. "
-                                 "The given boundary should be ``top'' or ``bottom''."));
-
-      return numbers::signaling_nan<double>();
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalConstant<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Spherical constant");
-        {
-          prm.declare_entry ("Outer composition", "0.",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the top boundary (at maximal radius). This list must have "
-                             "one entry or as many entries as there are compositional fields. "
-                             "Units: none.");
-          prm.declare_entry ("Inner composition", "1.",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the bottom boundary (at minimal radius). This list must have "
-                             "one entry or as many entries as there are compositional fields. "
-                             "Units: none.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    SphericalConstant<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      const unsigned int n_compositional_fields = this->n_compositional_fields();
-
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Spherical constant");
-        {
-          inner_composition = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Inner composition"))),
-                                                                      n_compositional_fields,
-                                                                      "Inner boundary composition values");
-
-          outer_composition = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Outer composition"))),
-                                                                      n_compositional_fields,
-                                                                      "Outer boundary composition values");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(SphericalConstant,
-                                               "spherical constant",
-                                               "A model in which the composition is chosen constant on "
-                                               "the inner and outer boundaries of a sphere, spherical "
-                                               "shell, chunk or ellipsoidal chunk. "
-                                               "Parameters are read from subsection 'Spherical constant'.")
-  }
-}
diff --git a/source/boundary_composition/two_merged_boxes.cc.bak b/source/boundary_composition/two_merged_boxes.cc.bak
deleted file mode 100644
index 78ab9d5119e..00000000000
--- a/source/boundary_composition/two_merged_boxes.cc.bak
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_composition/two_merged_boxes.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-
-    template <int dim>
-    double
-    TwoMergedBoxes<dim>::
-    boundary_composition (const types::boundary_id boundary_indicator,
-                          const Point<dim> &/*position*/,
-                          const unsigned int compositional_field) const
-    {
-      Assert (boundary_indicator<2*dim+2*(dim-1), ExcMessage ("The given boundary indicator needs to be less than 2*dimension+2*(dim-1)."));
-
-      return composition_values[boundary_indicator][compositional_field];
-    }
-
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Box with lithosphere boundary indicators");
-        {
-          prm.declare_entry ("Left composition", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the left boundary (at minimal $x$-value). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          prm.declare_entry ("Right composition", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the right boundary (at maximal $x$-value). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          prm.declare_entry ("Left composition lithosphere", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the left boundary (at minimal $x$-value). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          prm.declare_entry ("Right composition lithosphere", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the right boundary (at maximal $x$-value). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          prm.declare_entry ("Bottom composition", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the bottom boundary (at minimal $y$-value in 2d, or minimal "
-                             "$z$-value in 3d). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          prm.declare_entry ("Top composition", "",
-                             Patterns::List(Patterns::Double ()),
-                             "A comma separated list of composition boundary values "
-                             "at the top boundary (at maximal $y$-value in 2d, or maximal "
-                             "$z$-value in 3d). This list must have as many "
-                             "entries as there are compositional fields. Units: none.");
-          if (dim==3)
-            {
-              prm.declare_entry ("Front composition", "",
-                                 Patterns::List(Patterns::Double ()),
-                                 "A comma separated list of composition boundary values "
-                                 "at the front boundary (at minimal $y$-value). This list must have as many "
-                                 "entries as there are compositional fields. Units: none.");
-              prm.declare_entry ("Back composition", "",
-                                 Patterns::List(Patterns::Double ()),
-                                 "A comma separated list of composition boundary values "
-                                 "at the back boundary (at maximal $y$-value). This list must have as many "
-                                 "entries as there are compositional fields. Units: none.");
-              prm.declare_entry ("Front composition lithosphere", "",
-                                 Patterns::List(Patterns::Double ()),
-                                 "A comma separated list of composition boundary values "
-                                 "at the front lithosphere boundary (at minimal $y$-value). This list must have as many "
-                                 "entries as there are compositional fields. Units: none.");
-              prm.declare_entry ("Back composition lithosphere", "",
-                                 Patterns::List(Patterns::Double ()),
-                                 "A comma separated list of composition boundary values "
-                                 "at the back lithosphere boundary (at maximal $y$-value). This list must have as many "
-                                 "entries as there are compositional fields. Units: none.");
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary composition model");
-      {
-        prm.enter_subsection("Box with lithosphere boundary indicators");
-        {
-          switch (dim)
-            {
-              case 2:
-                composition_values[0] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition")));
-                composition_values[1] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition")));
-                composition_values[2] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Bottom composition")));
-                composition_values[3] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Top composition")));
-                composition_values[4] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition lithosphere")));
-                composition_values[5] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition lithosphere")));
-                break;
-
-              case 3:
-                composition_values[0] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition")));
-                composition_values[1] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition")));
-                composition_values[2] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Front composition")));
-                composition_values[3] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Back composition")));
-                composition_values[4] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Bottom composition")));
-                composition_values[5] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Top composition")));
-                composition_values[6] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Left composition lithosphere")));
-                composition_values[7] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Right composition lithosphere")));
-                composition_values[8] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Front composition lithosphere")));
-                composition_values[9] = Utilities::string_to_double(Utilities::split_string_list(prm.get ("Back composition lithosphere")));
-                break;
-
-              default:
-                Assert (false, ExcNotImplemented());
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::initialize()
-    {
-      // verify that the geometry is a box since only for this geometry
-      // do we know for sure what boundary indicators it uses and what they mean
-      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
-                   ExcMessage ("This boundary model is only useful if the geometry is "
-                               "a box with additional lithosphere boundary indicators."));
-
-      // verify that each of the lists for boundary values
-      // has the requisite number of elements
-      for (unsigned int f=0; f<2*dim+2*(dim-1); ++f)
-        AssertThrow (composition_values[f].size() == this->n_compositional_fields(),
-                     ExcMessage (std::string("The specification of boundary composition values for the `box with "
-                                             "lithosphere boundary indicators' model "
-                                             "requires as many values for each boundary indicator the box as there "
-                                             "are compositional "
-                                             "fields. However, for boundary indicator ")
-                                 +
-                                 Utilities::int_to_string(f)
-                                 +
-                                 ", the input file specifies "
-                                 +
-                                 Utilities::int_to_string(composition_values[f].size())
-                                 +
-                                 " values even though there are "
-                                 +
-                                 Utilities::int_to_string(this->n_compositional_fields())
-                                 +
-                                 " compositional fields."));
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryComposition
-  {
-    ASPECT_REGISTER_BOUNDARY_COMPOSITION_MODEL(TwoMergedBoxes,
-                                               "box with lithosphere boundary indicators",
-                                               "A model in which the composition is chosen constant on "
-                                               "all the sides of a box. Additional boundary indicators "
-                                               "are added to the lithospheric parts of the vertical boundaries. "
-                                               "This model is to be used with the 'Two Merged Boxes' Geometry Model.")
-  }
-}
diff --git a/source/boundary_fluid_pressure/density.cc.bak b/source/boundary_fluid_pressure/density.cc.bak
deleted file mode 100644
index c22e157c99f..00000000000
--- a/source/boundary_fluid_pressure/density.cc.bak
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_fluid_pressure/density.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/melt.h>
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryFluidPressure
-  {
-
-    template <int dim>
-    void
-    Density<dim>::
-    fluid_pressure_gradient (
-      const types::boundary_id /*boundary_indicator*/,
-      const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-      const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-      const std::vector<Tensor<1,dim>> &normal_vectors,
-      std::vector<double> &fluid_pressure_gradient_outputs
-    ) const
-    {
-      const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-      Assert(melt_outputs!=nullptr, ExcMessage("Error, MeltOutputs are missing in fluid_pressure_gradient()"));
-      for (unsigned int q=0; q<fluid_pressure_gradient_outputs.size(); ++q)
-        {
-          const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(material_model_inputs.position[q]);
-
-          switch (density_formulation)
-            {
-              case DensityFormulation::solid_density:
-              {
-                fluid_pressure_gradient_outputs[q] = (material_model_outputs.densities[q] * gravity) * normal_vectors[q];
-                break;
-              }
-
-              case DensityFormulation::fluid_density:
-              {
-                fluid_pressure_gradient_outputs[q] = (melt_outputs->fluid_densities[q] * gravity) * normal_vectors[q];
-                break;
-              }
-
-              case DensityFormulation::average_density:
-              {
-                const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-                const double phi =  material_model_inputs.composition[q][porosity_idx];
-                fluid_pressure_gradient_outputs[q] = ((1.0 - phi) * material_model_outputs.densities[q] * gravity
-                                                      + phi * melt_outputs->fluid_densities[q] * gravity)
-                                                     * normal_vectors[q];
-                break;
-              }
-
-              default:
-                Assert (false, ExcNotImplemented());
-            }
-        }
-    }
-
-    template <int dim>
-    void
-    Density<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary fluid pressure model");
-      {
-        prm.enter_subsection("Density");
-        {
-          prm.declare_entry ("Density formulation", "solid density",
-                             Patterns::Selection ("solid density|fluid density|average density"),
-                             "The density formulation used to compute the fluid pressure gradient "
-                             "at the model boundary."
-                             "\n\n"
-                             "`solid density' prescribes the gradient of the fluid pressure as "
-                             "solid density times gravity (which is the lithostatic "
-                             "pressure) and leads to approximately the same pressure in "
-                             "the melt as in the solid, so that fluid is only flowing "
-                             "in or out due to differences in dynamic pressure."
-                             "\n\n"
-                             "`fluid density' prescribes the gradient of the fluid pressure as "
-                             "fluid density times gravity and causes melt to flow in "
-                             "with the same velocity as inflowing solid material, "
-                             "or no melt flowing in or out if the solid velocity "
-                             "normal to the boundary is zero."
-                             "\n\n"
-                             "'average density' prescribes the gradient of the fluid pressure as "
-                             "the averaged fluid and solid density times gravity "
-                             "(which is a better approximation for the lithostatic "
-                             "pressure than just the solid density) and leads to approximately the same pressure in "
-                             "the melt as in the solid, so that fluid is only flowing "
-                             "in or out due to differences in dynamic pressure.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    Density<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary fluid pressure model");
-      {
-        prm.enter_subsection("Density");
-        {
-          if (prm.get ("Density formulation") == "solid density")
-            density_formulation = DensityFormulation::solid_density;
-          else if (prm.get ("Density formulation") == "fluid density")
-            density_formulation = DensityFormulation::fluid_density;
-          else if (prm.get ("Density formulation") == "average density")
-            density_formulation = DensityFormulation::average_density;
-          else
-            AssertThrow (false, ExcNotImplemented());
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryFluidPressure
-  {
-    ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(Density,
-                                                  "density",
-                                                  "A plugin that prescribes the fluid pressure gradient at "
-                                                  "the boundary based on fluid/solid density from the material "
-                                                  "model.")
-  }
-}
diff --git a/source/boundary_fluid_pressure/interface.cc.bak b/source/boundary_fluid_pressure/interface.cc.bak
deleted file mode 100644
index f14832e9278..00000000000
--- a/source/boundary_fluid_pressure/interface.cc.bak
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace BoundaryFluidPressure
-  {
-// -------------------------------- Deal with registering models and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    register_boundary_fluid_pressure (const std::string &name,
-                                      const std::string &description,
-                                      void (*declare_parameters_function) (ParameterHandler &),
-                                      std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_boundary_fluid_pressure (ParameterHandler &prm)
-    {
-      std::string model_name;
-      prm.enter_subsection ("Boundary fluid pressure model");
-      {
-        model_name = prm.get ("Plugin name");
-      }
-      prm.leave_subsection ();
-
-      return std::get<dim>(registered_plugins).create_plugin (model_name,
-                                                              "Boundary fluid pressure model::Plugin name");
-    }
-
-
-
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Boundary fluid pressure model");
-      const std::string pattern_of_names
-        = std::get<dim>(registered_plugins).get_pattern_of_names ();
-      prm.declare_entry ("Plugin name", "density",
-                         Patterns::Selection (pattern_of_names),
-                         "Select one of the following plugins:\n\n"
-                         +
-                         std::get<dim>(registered_plugins).get_description_string());
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary fluid pressure interface",
-                                                            out);
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryFluidPressure::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryFluidPressure::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryFluidPressure::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryFluidPressure::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace BoundaryFluidPressure
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_boundary_fluid_pressure<dim> (const std::string &, \
-                                         const std::string &, \
-                                         void ( *) (ParameterHandler &), \
-                                         std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_boundary_fluid_pressure<dim> (ParameterHandler &prm);
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/boundary_heat_flux/function.cc.bak b/source/boundary_heat_flux/function.cc.bak
deleted file mode 100644
index 3d7e49fc576..00000000000
--- a/source/boundary_heat_flux/function.cc.bak
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_heat_flux/function.h>
-#include <aspect/global.h>
-#include <aspect/geometry_model/interface.h>
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace BoundaryHeatFlux
-  {
-    template <int dim>
-    std::vector<Tensor<1,dim>>
-    Function<dim>::
-    heat_flux (const types::boundary_id /*boundary_indicator*/,
-               const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-               const MaterialModel::MaterialModelOutputs<dim> &/*material_model_outputs*/,
-               const std::vector<Tensor<1,dim>> &normal_vectors) const
-    {
-      const unsigned int n_evaluation_points = material_model_inputs.n_evaluation_points();
-      std::vector<Tensor<1,dim>> heat_flux(normal_vectors);
-
-      for (unsigned int i=0; i<n_evaluation_points; ++i)
-        {
-          const Point<dim> position = material_model_inputs.position[i];
-          if (coordinate_system == Utilities::Coordinates::cartesian)
-            {
-              heat_flux[i] *= boundary_heat_flux_function.value(position);
-            }
-          else if (coordinate_system == Utilities::Coordinates::spherical)
-            {
-              const std::array<double,dim> spherical_coordinates =
-                aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
-              Point<dim> point;
-
-              for (unsigned int d=0; d<dim; ++d)
-                point[d] = spherical_coordinates[d];
-
-              heat_flux[i] *= boundary_heat_flux_function.value(point);
-            }
-          else if (coordinate_system == Utilities::Coordinates::depth)
-            {
-              const double depth = this->get_geometry_model().depth(position);
-              Point<dim> point;
-              point(0) = depth;
-
-              heat_flux[i] *= boundary_heat_flux_function.value(point);
-            }
-          else
-            {
-              AssertThrow(false, ExcNotImplemented());
-            }
-        }
-
-      return heat_flux;
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::update()
-    {
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        boundary_heat_flux_function.set_time (this->get_time() / year_in_seconds);
-      else
-        boundary_heat_flux_function.set_time (this->get_time());
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary heat flux model");
-      {
-        prm.enter_subsection("Function");
-        {
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle. `depth' "
-                             "will create a function, in which only the first "
-                             "parameter is non-zero, which is interpreted to "
-                             "be the depth of the point.");
-
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary heat flux model");
-      {
-        prm.enter_subsection("Function");
-        {
-          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-        }
-        try
-          {
-            boundary_heat_flux_function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Boundary heat flux model.Function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryHeatFlux
-  {
-    ASPECT_REGISTER_BOUNDARY_HEAT_FLUX_MODEL(Function,
-                                             "function",
-                                             "Implementation of a model in which the boundary "
-                                             "heat flux is given in terms of an explicit formula "
-                                             "that is elaborated in the parameters in section "
-                                             "``Boundary heat flux model|Function''. The format of these "
-                                             "functions follows the syntax understood by the "
-                                             "muparser library, see "
-                                             "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`."
-                                             "\n\n"
-                                             "The formula you describe in the mentioned "
-                                             "section is a scalar value for the heat flux that is assumed "
-                                             "to be the flux normal to the boundary, and that has the unit "
-                                             "W/(m$^2$) (in 3d) or W/m (in 2d). Negative fluxes are "
-                                             "interpreted as the flow of heat into the domain, and positive "
-                                             "fluxes are interpreted as heat flowing out of the domain."
-                                             "\n\n"
-                                             "The symbol $t$ indicating time that "
-                                             "may appear in the formulas for the prescribed "
-                                             "heat flux is interpreted as having units "
-                                             "seconds unless the global parameter ``Use "
-                                             "years in output instead of seconds'' has "
-                                             "been set.")
-  }
-}
diff --git a/source/boundary_heat_flux/interface.cc.bak b/source/boundary_heat_flux/interface.cc.bak
deleted file mode 100644
index db736384b2a..00000000000
--- a/source/boundary_heat_flux/interface.cc.bak
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_heat_flux/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace BoundaryHeatFlux
-  {
-// -------------------------------- Deal with registering models and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    register_boundary_heat_flux (const std::string &name,
-                                 const std::string &description,
-                                 void (*declare_parameters_function) (ParameterHandler &),
-                                 std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_boundary_heat_flux (ParameterHandler &prm)
-    {
-      std::string model_name;
-      prm.enter_subsection ("Boundary heat flux model");
-      {
-        model_name = prm.get ("Model name");
-      }
-      prm.leave_subsection ();
-
-      return std::get<dim>(registered_plugins).create_plugin (model_name,
-                                                              "Boundary heat flux model::Model name");
-    }
-
-
-
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Boundary heat flux model");
-      const std::string pattern_of_names
-        = std::get<dim>(registered_plugins).get_pattern_of_names ();
-      prm.declare_entry ("Model name", "function",
-                         Patterns::Selection (pattern_of_names),
-                         "Select one of the following plugins:\n\n"
-                         +
-                         std::get<dim>(registered_plugins).get_description_string());
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary heat flux interface",
-                                                            out);
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryHeatFlux::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryHeatFlux::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryHeatFlux::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryHeatFlux::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace BoundaryHeatFlux
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_boundary_heat_flux<dim> (const std::string &, \
-                                    const std::string &, \
-                                    void ( *) (ParameterHandler &), \
-                                    std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_boundary_heat_flux<dim> (ParameterHandler &prm);
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/boundary_temperature/ascii_data.cc.bak b/source/boundary_temperature/ascii_data.cc.bak
deleted file mode 100644
index 5e3737ed89f..00000000000
--- a/source/boundary_temperature/ascii_data.cc.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_temperature/ascii_data.h>
-
-#include <deal.II/base/parameter_handler.h>
-
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      Utilities::AsciiDataBoundary<dim>::initialize(this->get_fixed_temperature_boundary_indicators(),
-                                                    1);
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::update ()
-    {
-      Interface<dim>::update ();
-      Utilities::AsciiDataBoundary<dim>::update();
-    }
-
-
-    template <int dim>
-    double
-    AsciiData<dim>::boundary_temperature (const types::boundary_id boundary_indicator,
-                                          const Point<dim> &position) const
-    {
-      return Utilities::AsciiDataBoundary<dim>::get_data_component(boundary_indicator,
-                                                                   position,
-                                                                   0);
-    }
-
-
-    template <int dim>
-    double
-    AsciiData<dim>::minimal_temperature (const std::set<types::boundary_id> &) const
-    {
-      return 0;
-    }
-
-
-    template <int dim>
-    double
-    AsciiData<dim>::maximal_temperature (const std::set<types::boundary_id> &) const
-    {
-      return 0;
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
-                                                              "$ASPECT_SOURCE_DIR/data/boundary-temperature/ascii-data/test/",
-                                                              "box_2d_%s.%d.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(AsciiData,
-                                               "ascii data",
-                                               "Implementation of a model in which the boundary "
-                                               "data is derived from files containing data "
-                                               "in ascii format. Note the required format of the "
-                                               "input data: The first lines may contain any number of comments "
-                                               "if they begin with `#', but one of these lines needs to "
-                                               "contain the number of grid points in each dimension as "
-                                               "for example `# POINTS: 3 3'. "
-                                               "The order of the data columns "
-                                               "has to be `x', `Temperature [K]' in a 2d model and "
-                                               " `x', `y', `Temperature [K]' in a 3d model, which means that "
-                                               "there has to be a single column "
-                                               "containing the temperature. "
-                                               "Note that the data in the input "
-                                               "files need to be sorted in a specific order: "
-                                               "the first coordinate needs to ascend first, "
-                                               "followed by the second in order to "
-                                               "assign the correct data to the prescribed coordinates. "
-                                               "If you use a spherical model, "
-                                               "then the assumed grid changes. `x' will be replaced by "
-                                               "the radial distance of the point to the bottom of the model, "
-                                               "`y' by the azimuth angle and `z' by the polar angle measured "
-                                               "positive from the north pole. The grid will be assumed to be "
-                                               "a latitude-longitude grid. Note that the order "
-                                               "of spherical coordinates is `r', `phi', `theta' "
-                                               "and not `r', `theta', `phi', since this allows "
-                                               "for dimension independent expressions.")
-  }
-}
diff --git a/source/boundary_temperature/box.cc.bak b/source/boundary_temperature/box.cc.bak
deleted file mode 100644
index f1899243c66..00000000000
--- a/source/boundary_temperature/box.cc.bak
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/box.h>
-#include <aspect/geometry_model/box.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-// ------------------------------ Box -------------------
-
-    template <int dim>
-    double
-    Box<dim>::
-    boundary_temperature (const types::boundary_id boundary_indicator,
-                          const Point<dim> &/*position*/) const
-    {
-      Assert (boundary_indicator<2*dim, ExcMessage ("Given boundary indicator needs to be less than 2*dimension."));
-      return temperature_[boundary_indicator];
-    }
-
-
-    template <int dim>
-    double
-    Box<dim>::
-    minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
-    {
-      if (fixed_boundary_ids.empty())
-        return *std::min_element(temperature_, temperature_+2*dim);
-      else
-        {
-          double min = maximal_temperature(fixed_boundary_ids);
-          for (const auto id : fixed_boundary_ids)
-            min = std::min(min,temperature_[id]);
-          return min;
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    Box<dim>::
-    maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
-    {
-      if (fixed_boundary_ids.empty())
-        return *std::max_element(temperature_, temperature_+2*dim);
-      else
-        {
-          double max = std::numeric_limits<double>::lowest();
-          for (const auto id : fixed_boundary_ids)
-            max = std::max(max,temperature_[id]);
-          return max;
-        }
-    }
-
-    template <int dim>
-    void
-    Box<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Box");
-        {
-          prm.declare_entry ("Left temperature", "1.",
-                             Patterns::Double (),
-                             "Temperature at the left boundary (at minimal $x$-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Right temperature", "0.",
-                             Patterns::Double (),
-                             "Temperature at the right boundary (at maximal $x$-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Bottom temperature", "0.",
-                             Patterns::Double (),
-                             "Temperature at the bottom boundary (at minimal $z$-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Top temperature", "0.",
-                             Patterns::Double (),
-                             "Temperature at the top boundary (at maximal $x$-value). Units: \\si{\\kelvin}.");
-          if (dim==3)
-            {
-              prm.declare_entry ("Front temperature", "0.",
-                                 Patterns::Double (),
-                                 "Temperature at the front boundary (at minimal $y$-value). Units: \\si{\\kelvin}.");
-              prm.declare_entry ("Back temperature", "0.",
-                                 Patterns::Double (),
-                                 "Temperature at the back boundary (at maximal $y$-value). Units: \\si{\\kelvin}.");
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    Box<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Box");
-        {
-          switch (dim)
-            {
-              case 2:
-                temperature_[0] = prm.get_double ("Left temperature");
-                temperature_[1] = prm.get_double ("Right temperature");
-                temperature_[2] = prm.get_double ("Bottom temperature");
-                temperature_[3] = prm.get_double ("Top temperature");
-                break;
-
-              case 3:
-                temperature_[0] = prm.get_double ("Left temperature");
-                temperature_[1] = prm.get_double ("Right temperature");
-                temperature_[2] = prm.get_double ("Front temperature");
-                temperature_[3] = prm.get_double ("Back temperature");
-                temperature_[4] = prm.get_double ("Bottom temperature");
-                temperature_[5] = prm.get_double ("Top temperature");
-                break;
-
-              default:
-                Assert (false, ExcNotImplemented());
-            }
-
-          // verify that the geometry is a box since only for this geometry
-          // do we know for sure what boundary indicators it uses and what they mean
-          AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
-                       ExcMessage ("This boundary model is only implemented if the geometry is "
-                                   "a box."));
-
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box,
-                                               "box",
-                                               "A model in which the temperature is chosen constant on "
-                                               "the sides of a box which are selected by the parameters "
-                                               "Left/Right/Top/Bottom/Front/Back temperature")
-  }
-}
diff --git a/source/boundary_temperature/constant.cc.bak b/source/boundary_temperature/constant.cc.bak
deleted file mode 100644
index 442eee8a480..00000000000
--- a/source/boundary_temperature/constant.cc.bak
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/constant.h>
-
-#include <deal.II/base/utilities.h>
-#include <deal.II/base/signaling_nan.h>
-
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-// ------------------------------ Constant -------------------
-
-    template <int dim>
-    double
-    Constant<dim>::
-    boundary_temperature (const types::boundary_id boundary_indicator,
-                          const Point<dim> &/*position*/) const
-    {
-      const std::map<types::boundary_id, double>::const_iterator it = boundary_temperatures.find(boundary_indicator);
-      if (it != boundary_temperatures.end())
-        return it->second;
-      else
-        {
-          Assert (false,
-                  ExcMessage ("Unknown boundary indicator with number <" + Utilities::int_to_string(boundary_indicator) + ">. "
-                              "You may not have specified the temperature for this boundary indicator "
-                              "in the input file."));
-          return numbers::signaling_nan<double>();
-        }
-    }
-
-
-    template <int dim>
-    double
-    Constant<dim>::
-    minimal_temperature (const std::set<types::boundary_id> &) const
-    {
-      std::map<types::boundary_id, double>::const_iterator it = boundary_temperatures.begin();
-      double min = it->second;
-      ++it;
-
-      for ( ; it != boundary_temperatures.end(); ++it)
-        if ( it->second < min )
-          min = it->second;
-
-      return min;
-    }
-
-
-
-    template <int dim>
-    double
-    Constant<dim>::
-    maximal_temperature (const std::set<types::boundary_id> &) const
-    {
-      std::map<types::boundary_id, double>::const_iterator it = boundary_temperatures.begin();
-      double max = it->second;
-      ++it;
-
-      for ( ; it != boundary_temperatures.end(); ++it)
-        if ( it->second > max )
-          max = it->second;
-
-      return max;
-    }
-
-
-
-    template <int dim>
-    void
-    Constant<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Constant");
-        {
-          prm.declare_entry ("Boundary indicator to temperature mappings", "",
-                             Patterns::Map (Patterns::Anything(),
-                                            Patterns::Double()),
-                             "A comma separated list of mappings between boundary "
-                             "indicators and the temperature associated with the "
-                             "boundary indicators. The format for this list is "
-                             "``indicator1 : value1, indicator2 : value2, ...'', "
-                             "where each indicator is a valid boundary indicator "
-                             "(either a number or the symbolic name of a boundary as provided "
-                             "by the geometry model) "
-                             "and each value is the temperature of that boundary." );
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    Constant<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Constant");
-        {
-          // get the list of mappings
-          const std::vector<std::string> x_boundary_temperatures
-            = Utilities::split_string_list(prm.get ("Boundary indicator to temperature mappings"));
-
-
-          for (const auto &boundary_id_string : x_boundary_temperatures)
-            {
-              // each entry has the format (white space is optional):
-              // <id> : <value (might have spaces)>
-              const std::vector<std::string> parts = Utilities::split_string_list (boundary_id_string, ':');
-
-              AssertThrow (parts.size() == 2,
-                           ExcMessage (std::string("Invalid entry trying to describe boundary "
-                                                   "temperatures. Each entry needs to have the form "
-                                                   "<boundary_id : name>, "
-                                                   "but there is an entry of the form <") + boundary_id_string + ">"));
-
-              types::boundary_id boundary_id;
-              try
-                {
-                  boundary_id
-                    = this->get_geometry_model().translate_symbolic_boundary_name_to_id (parts[0]);
-                }
-              catch (const std::string &error)
-                {
-                  AssertThrow (false, ExcMessage ("While parsing the entry <Boundary temperature model/Constant>, "
-                                                  "there was an error. Specifically, "
-                                                  "the conversion function complained as follows:\n\n"
-                                                  + error));
-                }
-
-              AssertThrow((this->get_fixed_temperature_boundary_indicators().find(boundary_id) != this->get_fixed_temperature_boundary_indicators().end()),
-                          ExcMessage ("You have indicated a temperature mapping for "
-                                      "boundary indicator " + parts[0] + ", but that "
-                                      "indicator isn't in the "
-                                      "list of Fixed temperature boundary indicators."));
-
-              AssertThrow (boundary_temperatures.find(boundary_id) == boundary_temperatures.end(),
-                           ExcMessage ("Boundary indicator <" + Utilities::int_to_string(boundary_id) +
-                                       "> appears more than once in the list of indicators "
-                                       "for constant temperature boundary conditions."));
-
-              boundary_temperatures[boundary_id] = Utilities::string_to_double (parts[1]);
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Constant,
-                                               "constant",
-                                               "A model in which the temperature is chosen constant on "
-                                               "a given boundary indicator.  Parameters are read from the "
-                                               "subsection 'Constant'.")
-  }
-}
diff --git a/source/boundary_temperature/dynamic_core.cc.bak b/source/boundary_temperature/dynamic_core.cc.bak
deleted file mode 100644
index f38bbbae653..00000000000
--- a/source/boundary_temperature/dynamic_core.cc.bak
+++ /dev/null
@@ -1,986 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/boundary_temperature/dynamic_core.h>
-#include <aspect/postprocess/core_statistics.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/simulator_access.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/mpi.h>
-#include <deal.II/base/exceptions.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    boundary_temperature (const types::boundary_id            boundary_indicator,
-                          const Point<dim>                    &/*location*/) const
-    {
-      switch (boundary_indicator)
-        {
-          case 0:
-            return inner_temperature;
-          case 1:
-            return outer_temperature;
-          default:
-            Assert (false, ExcMessage ("Unknown boundary indicator."));
-            return std::numeric_limits<double>::quiet_NaN();
-        }
-    }
-
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    minimal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
-    {
-      return std::min (inner_temperature, outer_temperature);
-    }
-
-
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    maximal_temperature (const std::set<types::boundary_id> &/*fixed_boundary_ids*/) const
-    {
-      return std::max (inner_temperature, outer_temperature);
-    }
-
-
-
-    template <int dim>
-    void
-    DynamicCore<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Dynamic core");
-        {
-          prm.declare_entry ("Outer temperature", "0.",
-                             Patterns::Double (),
-                             "Temperature at the outer boundary (lithosphere water/air). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Inner temperature", "6000.",
-                             Patterns::Double (),
-                             "Temperature at the inner boundary (core mantle boundary) at the "
-                             "beginning. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("dT over dt", "0.",
-                             Patterns::Double (),
-                             "Initial CMB temperature changing rate. "
-                             "Units: \\si{\\kelvin}/year.");
-          prm.declare_entry ("dR over dt", "0.",
-                             Patterns::Double (),
-                             "Initial inner core radius changing rate. "
-                             "Units: \\si{\\kilo\\meter}/year.");
-          prm.declare_entry ("dX over dt", "0.",
-                             Patterns::Double (),
-                             "Initial light composition changing rate. "
-                             "Units: 1/year.");
-          prm.declare_entry ("Core density", "12.5e3",
-                             Patterns::Double (),
-                             "Density of the core. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Gravity acceleration", "9.8",
-                             Patterns::Double (),
-                             "Gravitation acceleration at CMB. "
-                             "Units: \\si{\\meter\\per\\second\\squared}.");
-          prm.declare_entry ("CMB pressure", "0.14e12",
-                             Patterns::Double (),
-                             "Pressure at CMB. Units: \\si{\\pascal}.");
-          prm.declare_entry ("Initial light composition", "0.01",
-                             Patterns::Double (0.),
-                             "Initial light composition (eg. S,O) concentration "
-                             "in weight fraction.");
-          prm.declare_entry ("Max iteration", "30000",
-                             Patterns::Integer (0),
-                             "The max iterations for nonlinear core energy solver.");
-          prm.declare_entry ("Core heat capacity", "840.",
-                             Patterns::Double (0.),
-                             "Heat capacity of the core. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("K0", "4.111e11",
-                             Patterns::Double (0.),
-                             "Core compressibility at zero pressure. "
-                             "See \\cite{NPB+04} for more details.");
-          prm.declare_entry ("Rho0", "7.019e3",
-                             Patterns::Double (0.),
-                             "Core density at zero pressure. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}. "
-                             "See \\cite{NPB+04} for more details.");
-          prm.declare_entry ("Alpha", "1.35e-5",
-                             Patterns::Double (0.),
-                             "Core thermal expansivity. Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Lh", "750e3",
-                             Patterns::Double (0.),
-                             "The latent heat of core freeze. "
-                             "Units: \\si{\\joule\\per\\kilogram}.");
-          prm.declare_entry ("Rh","-27.7e6",
-                             Patterns::Double (),
-                             "The heat of reaction. "
-                             "Units: \\si{\\joule\\per\\kilogram}.");
-          prm.declare_entry ("Beta composition", "1.1",
-                             Patterns::Double (0.),
-                             "Compositional expansion coefficient $Beta_c$. "
-                             "See \\cite{NPB+04} for more details.");
-          prm.declare_entry ("Delta","0.5",
-                             Patterns::Double (0., 1.),
-                             "Partition coefficient of the light element.");
-          prm.declare_entry ("Core conductivity", "60.",
-                             Patterns::Double (0.),
-                             "Core heat conductivity $k_c$. Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.enter_subsection("Geotherm parameters");
-          {
-            prm.declare_entry ("Tm0","1695.",
-                               Patterns::Double (0.),
-                               "Melting curve (\\cite{NPB+04} eq. (40)) parameter Tm0. Units: \\si{\\kelvin}.");
-            prm.declare_entry ("Tm1","10.9",
-                               Patterns::Double (),
-                               "Melting curve (\\cite{NPB+04} eq. (40)) parameter Tm1. "
-                               "Units: \\si{\\per\\tera\\pascal}.");
-            prm.declare_entry ("Tm2","-8.0",
-                               Patterns::Double (),
-                               "Melting curve (\\cite{NPB+04} eq. (40)) parameter Tm2. "
-                               "Units: \\si{\\per\\tera\\pascal\\squared}.");
-            prm.declare_entry ("Theta","0.11",
-                               Patterns::Double (),
-                               "Melting curve (\\cite{NPB+04} eq. (40)) parameter Theta.");
-            prm.declare_entry ("Composition dependency","true",
-                               Patterns::Bool (),
-                               "If melting curve dependent on composition.");
-            prm.declare_entry ("Use BW11","false",
-                               Patterns::Bool (),
-                               "If using the Fe-FeS system solidus from Buono \\& Walker (2011) instead.");
-          }
-          prm.leave_subsection ();
-
-          prm.enter_subsection("Radioactive heat source");
-          {
-            prm.declare_entry ("Number of radioactive heating elements","0",
-                               Patterns::Integer (0),
-                               "Number of different radioactive heating elements in core");
-            prm.declare_entry ("Heating rates","",
-                               Patterns::List (Patterns::Double ()),
-                               "Heating rates of different elements (W/kg)");
-            prm.declare_entry ("Half life times","",
-                               Patterns::List (Patterns::Double ()),
-                               "Half decay times of different elements (Ga)");
-            prm.declare_entry ("Initial concentrations","",
-                               Patterns::List (Patterns::Double ()),
-                               "Initial concentrations of different elements (ppm)");
-          }
-          prm.leave_subsection ();
-
-          prm.enter_subsection("Other energy source");
-          {
-            prm.declare_entry ("File name","",
-                               Patterns::Anything(),
-                               "Data file name for other energy source into the core. "
-                               "The 'other energy source' is used for external core energy source."
-                               "For example if someone want to test the early lunar core powered by precession "
-                               "(Dwyer, C. A., et al. (2011). A long-lived lunar dynamo driven by continuous mechanical stirring. Nature 479(7372): 212-214.)"
-                               "Format [Time(Gyr)   Energy rate(W)]");
-          }
-          prm.leave_subsection ();
-
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    DynamicCore<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Dynamic core");
-        {
-          // verify that the geometry is in fact a spherical shell since only
-          // for this geometry do we know for sure what boundary indicators it
-          // uses and what they mean
-          AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()),
-                       ExcMessage ("This boundary model is only implemented if the geometry is "
-                                   "a spherical shell."));
-
-          inner_temperature = prm.get_double ("Inner temperature");
-          outer_temperature = prm.get_double ("Outer temperature");
-          init_dT_dt        = prm.get_double ("dT over dt") / year_in_seconds;
-          init_dR_dt        = prm.get_double ("dR over dt") / year_in_seconds * 1.e3;
-          init_dX_dt        = prm.get_double ("dX over dt") / year_in_seconds;
-          Rho_cen           = prm.get_double ("Core density");
-          g                 = prm.get_double ("Gravity acceleration");
-          P_CMB             = prm.get_double ("CMB pressure");
-          X_init            = prm.get_double ("Initial light composition");
-          max_steps         = prm.get_integer ("Max iteration");
-          Cp                = prm.get_double ("Core heat capacity");
-          CpRho             = Cp*Rho_cen;
-
-          //\cite{NPB+04}
-          K0                = prm.get_double ("K0");
-          Alpha             = prm.get_double ("Alpha");
-          Rho_0             = prm.get_double ("Rho0");
-          Lh                = prm.get_double ("Lh");
-          Beta_c            = prm.get_double ("Beta composition");
-          k_c               = prm.get_double ("Core conductivity");
-          Delta             = prm.get_double ("Delta");
-          Rh                = prm.get_double ("Rh");
-
-          prm.enter_subsection("Geotherm parameters");
-          {
-            Tm0           =  prm.get_double ("Tm0");
-            Tm1           =  prm.get_double ("Tm1");
-            Tm2           =  prm.get_double ("Tm2");
-            Theta         =  prm.get_double ("Theta");
-            composition_dependency
-              =  prm.get_bool("Composition dependency");
-            use_bw11      =  prm.get_bool("Use BW11");
-          }
-          prm.leave_subsection ();
-
-          prm.enter_subsection("Radioactive heat source");
-          {
-            n_radioheating_elements = prm.get_integer ("Number of radioactive heating elements");
-            heating_rate = Utilities::string_to_double
-                           (Utilities::split_string_list
-                            (prm.get("Heating rates")));
-            AssertThrow(n_radioheating_elements==heating_rate.size(),
-                        ExcMessage("Number of heating rate entities does not match "
-                                   "the number of radioactive elements."));
-            half_life = Utilities::string_to_double
-                        (Utilities::split_string_list
-                         (prm.get("Half life times")));
-            AssertThrow(n_radioheating_elements==half_life.size(),
-                        ExcMessage("Number of half life time entities does not match "
-                                   "the number of radioactive elements."));
-            initial_concentration = Utilities::string_to_double
-                                    (Utilities::split_string_list
-                                     (prm.get("Initial concentrations")));
-            AssertThrow(n_radioheating_elements==initial_concentration.size(),
-                        ExcMessage("Number of initial concentration entities does not match "
-                                   "the number of radioactive elements."));
-          }
-          prm.leave_subsection ();
-
-          prm.enter_subsection("Other energy source");
-          {
-            name_OES = prm.get("File name");
-          }
-          prm.leave_subsection ();
-
-          L=sqrt(3*K0*(log(Rho_cen/Rho_0)+1)/(2*M_PI*constants::big_g*Rho_0*Rho_cen));
-          D=sqrt(3*Cp/(2*M_PI*Alpha*Rho_cen*constants::big_g));
-
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-    template <int dim>
-    void
-    DynamicCore<dim>::read_data_OES()
-    {
-      data_OES.clear();
-      if (name_OES.size()==0)
-        return;
-      std::istringstream in(Utilities::read_and_distribute_file_content(name_OES,
-                                                                        this->get_mpi_communicator()));
-      if (in.good())
-        {
-          str_data_OES data_read;
-          std::string line;
-          while (!in.eof())
-            {
-              std::getline(in, line);
-              if (sscanf(line.data(), "%le\t%le\n", &data_read.t, &data_read.w)==2)
-                data_OES.push_back(data_read);
-            }
-        }
-      if (data_OES.size()!=0)
-        this->get_pcout() << "Other energy source is in use ( "
-                          << data_OES.size()
-                          << " data points is read)."
-                          << std::endl;
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::get_OES(double t) const
-    {
-      // The core evolution is quite slow, so the time units used here is billion years.
-      t/=1.e9*year_in_seconds;
-      double w=0.;
-      for (unsigned i=1; i<data_OES.size(); ++i)
-        {
-          if (t>=data_OES[i-1].t && t<data_OES[i].t )
-            {
-              w = data_OES[i-1].w + ( t - data_OES[i-1].t)
-                  /(data_OES[i].t - data_OES[i-1].t)
-                  *(data_OES[i].w - data_OES[i-1].w);
-              break;
-            }
-        }
-      return w;
-    }
-
-    template <int dim>
-    DynamicCore<dim>::DynamicCore()
-    {
-      is_first_call = true;
-      core_data.is_initialized = false;
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::get_initial_Ri(double T)
-    {
-      double r0=0.,
-             r1=Rc;
-      double dT0=get_T(T,r0)-get_solidus(get_X(r0),get_Pressure(r0)),
-             dT1=get_T(T,r1)-get_solidus(get_X(r1),get_Pressure(r1));
-      if (dT0<=0. && dT1<=0.)
-        return Rc;
-      if (dT0>=0. && dT1>=0.)
-        return 0.;
-      for (int i=0; i<max_steps; ++i)
-        {
-          double rm=(r0+r1)/2.,
-                 dTm=get_T(T,rm)-get_solidus(get_X(rm),get_Pressure(rm));
-          if (dTm==0.)
-            return rm;
-          if (dTm*dT0<0.)
-            {
-              r1=rm;
-              continue;
-            }
-          if (dTm*dT1<0.)
-            {
-              r0=rm;
-              continue;
-            }
-        }
-      if (dT0>0 && dT1<0)
-        {
-          // Snowing core
-          AssertThrow(false, ExcMessage("[Dynamic core] You had a 'Snowing Core' (i.e., core is freezing from CMB), "
-                                        "the treatment is not available at the moment."));
-        }
-      return (r0+r1)/2.;
-    }
-
-    template <int dim>
-    bool
-    DynamicCore<dim>::solve_time_step(double &X, double &T, double &R)
-    {
-      // Well solving the change in core-mantle boundary temperature T, inner core radius R, and
-      //    light component (e.g. S, O, Si) composition X, the following relations has to be respected:
-      // 1. At the inner core boundary the adiabatic temperature should be equal to solidus temperature
-      // 2. The following energy production rate should be balanced in core:
-      //    Heat flux at core-mantle boundary         Q
-      //    Specific heat                             Qs*dT/dt
-      //    Radioactive heating                       Qr
-      //    Gravitational contribution                Qg*dR/dt
-      //    Latent heat                               Ql*dR/dt
-      //    So that         Q+Qs*dT/dt+Qr+Qg*dR/dt*Ql*dR/dt=0
-      // 3. The light component composition X depends on inner core radius (See function get_X() ),
-      //    and core solidus may dependent on X as well
-      // This becomes a small nonlinear problem. Directly iterate through the above three system doesn't
-      // converge well. Alternatively we solve the inner core radius by bisection method.
-
-      int steps=1;
-      double R_0,R_1,R_2;
-      // dT is the temperature difference between adiabatic and solidus at
-      // inner-outer core boundary. If dT=0 then we found our solution.
-      double dT0,dT1,dT2;
-      R_0 = 0.;
-      R_1 = core_data.Ri;
-      R_2 = Rc;
-      dT0 = get_dT(R_0);
-      dT1 = get_dT(R_1);
-      dT2 = get_dT(R_2);
-
-      if (dT0 >= 0. && dT2 >= 0.)
-        {
-          // Fully molten core
-          R_1 = R_0;
-          dT1 = 0;
-        }
-      else if (dT2 <= 0. && dT0 <= 0. )
-        {
-          //Completely solid core
-          R_1 = R_2;
-          dT1 = 0;
-        }
-      else while (!(dT1==0 || steps>max_steps))
-          {
-            // If solution is out of the interval, then something is wrong.
-            if (dT0*dT2>0)
-              {
-                this->get_pcout()<<"Step: "<<steps<<std::endl
-                                 <<" R=["<<R_0/1e3<<","<<R_2/1e3<<"]"<<"(km)"
-                                 <<" dT0="<<dT0<<", dT2="<<dT2<<std::endl
-                                 <<"Q_CMB="<<core_data.Q<<std::endl
-                                 <<"Warning: Solution for inner core radius can not be found! Mid-point is used."<<std::endl;
-                AssertThrow(dT0*dT2<=0,ExcMessage("No single solution for inner core!"));
-              }
-            else if (dT0*dT1<0.)
-              {
-                R_2 = R_1;
-                dT2 = dT1;
-              }
-            else if (dT2*dT1<0.)
-              {
-                R_0 = R_1;
-                dT0 = dT1;
-              }
-            R_1 = (R_0 + R_2) / 2.;
-            dT1 = get_dT(R_1);
-            ++steps;
-          }
-
-      // Calculate new R,T,X
-      R = R_1;
-      T = get_Tc(R);
-      X = get_X(R);
-
-      if (dT0<0. && dT2>0.)
-        {
-          // Normal solution
-          return true;
-        }
-      else if (dT0>0. && dT2<0.)
-        {
-          // Snowing core solution
-          return false;
-        }
-      else
-        {
-          // No solution found.
-          this->get_pcout()<<"[Dynamic core] Step: "<<steps<<std::endl
-                           <<" R=["<<R_0/1e3<<","<<R_2/1e3<<"]"<<"(km)"
-                           <<" dT0="<<dT0<<", dT2="<<dT2<<std::endl
-                           <<"Q_CMB="<<core_data.Q<<std::endl;
-          AssertThrow(false, ExcMessage("[Dynamic core] No inner core radius solution found!"));
-        }
-
-      return false;
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::get_Tc(double r) const
-    {
-      // Using all Q values from last step.
-      // Qs & Qr is constant, while Qg & Ql depends on inner core radius Ri
-      // TODO: Use mid-point value for Q values.
-      return core_data.Ti - ( (core_data.Q + core_data.Qr + core_data.Q_OES) * core_data.dt
-                              + (core_data.Qg + core_data.Ql)*(r-core_data.Ri)
-                            ) / core_data.Qs;
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::get_Ts(double r) const
-    {
-      return get_solidus(get_X(r),get_Pressure(r));
-    }
-
-
-    template <int dim>
-    double
-    DynamicCore<dim>::get_dT(double r) const
-    {
-      return get_T(get_Tc(r),r) - get_Ts(r);
-    }
-
-    template <int dim>
-    void
-    DynamicCore<dim>::update_core_data()
-    {
-      get_specific_heating(core_data.Ti,core_data.Qs,core_data.Es);
-      get_radio_heating(core_data.Ti,core_data.Qr,core_data.Er);
-      get_gravity_heating(core_data.Ti,core_data.Ri,core_data.Xi,core_data.Qg,core_data.Eg);
-      get_adiabatic_heating(core_data.Ti,core_data.Ek,core_data.Qk);
-      get_latent_heating(core_data.Ti,core_data.Ri,core_data.El,core_data.Ql);
-      get_heat_solution(core_data.Ti,core_data.Ri,core_data.Xi,core_data.Eh);
-    }
-
-    template <int dim>
-    const internal::CoreData &
-    DynamicCore<dim>::get_core_data() const
-    {
-      return core_data;
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::get_solidus(double X,double p) const
-    {
-      if (use_bw11)
-        {
-          // Change from weight percent to mole percent.
-          double x,x0=32./88.;
-          if (X<x0)
-            x=56.*X/(32.*(1.-X));
-          else
-            x=1.;
-          // Change from Pa to GPa
-          p*=1e-9;
-          // Fe-FeS system solidus by Buono & Walker (2011)
-          return (-2.4724*p*p*p*p + 28.025*p*p*p + 9.1404*p*p + 581.71*p + 3394.8) * x*x*x*x
-                 +( 1.7978*p*p*p*p - 6.7881*p*p*p - 197.69*p*p - 271.69*p - 8219.5) * x*x*x
-                 +(-0.1702*p*p*p*p - 9.3959*p*p*p + 163.53*p*p - 319.35*p + 5698.6) * x*x
-                 +(-0.2308*p*p*p*p + 7.1000*p*p*p - 64.118*p*p + 105.98*p - 1621.9) * x
-                 +( 0.2302*p*p*p*p - 5.3688*p*p*p + 38.124*p*p - 46.681*p + 1813.8);
-
-        }
-      else
-        {
-          if (composition_dependency)
-            return (Tm0*(1-Theta*X)*(1+Tm1*p+Tm2*pow(p,2)));
-          else
-            return (Tm0*(1-Theta)*(1+Tm1*p+Tm2*pow(p,2)));
-        }
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::get_X(double r) const
-    {
-      double xi_3=pow(r/Rc,3);
-      return X_init/(1-xi_3+Delta*xi_3);
-    }
-
-    template <int dim>
-    void
-    DynamicCore<dim>::update()
-    {
-      core_data.dt    = this->get_timestep();
-      core_data.H     = get_radioheating_rate();
-
-      // It's a bit tricky here.
-      // Didn't use the initialize() function instead because the postprocess is initialized after boundary temperature.
-      // It is not available at the time initialize() function of boundary temperature is called.
-      if (is_first_call==true)
-        {
-          AssertThrow(this->get_postprocess_manager().template has_matching_postprocessor<const Postprocess::CoreStatistics<dim>>(),
-                      ExcMessage ("Dynamic core boundary condition has to work with dynamic core statistics postprocessor."));
-
-          const Postprocess::CoreStatistics<dim> &core_statistics
-            = this->get_postprocess_manager().template get_matching_postprocessor<const Postprocess::CoreStatistics<dim>>();
-          // The restart data is stored in 'core statistics' postprocessor.
-          // If restart from checkpoint, extract data from there.
-          core_data = core_statistics.get_core_data();
-
-          // Read data of other energy source
-          read_data_OES();
-
-          const GeometryModel::SphericalShell<dim> &spherical_shell_geometry =
-            Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
-
-          Rc=spherical_shell_geometry.inner_radius();
-          Mc=get_Mass(Rc);
-          P_Core=get_Pressure(0);
-
-          // If the material model is incompressible, we have to get correction for the real core temperature
-          if (this->get_adiabatic_conditions().is_initialized() && !this->get_material_model().is_compressible())
-            {
-              Point<dim> p1;
-              p1(0) = spherical_shell_geometry.inner_radius();
-              dTa   = this->get_adiabatic_conditions().temperature(p1)
-                      - this->get_adiabatic_surface_temperature();
-            }
-          else
-            dTa   = 0.;
-
-          // Setup initial core data from prm input.
-          // If resumed from checkpoint, core_data is read from postprocess instead of set from prm file.
-          // (The boundary_temperature doesn't seem to support restart/resume, the data has to passed and
-          // stored in the postprocessor 'core statistics')
-          if (!core_data.is_initialized)
-            {
-              core_data.Ti=inner_temperature + dTa;
-              core_data.Ri = get_initial_Ri(core_data.Ti);
-              core_data.Xi = get_X(core_data.Ri);
-
-              core_data.Q=0.;
-              core_data.dt=0.;
-              core_data.dT_dt=init_dT_dt;
-              core_data.dR_dt=init_dR_dt;
-              core_data.dX_dt=init_dX_dt;
-              update_core_data();
-              core_data.is_initialized = true;
-              std::stringstream output;
-              output<<std::setiosflags(std::ios::left)
-                    <<"   Dynamic core initialized as:"<<std::endl
-                    <<"     "<<std::setw(15)<<"Tc(K)"<<std::setw(15)<<"Ri(km)"<<std::setw(15)<<"Xi"
-                    <<std::setw(15)<<"dT/dt(K/year)"<<std::setw(15)<<"dR/dt(km/year)"<<std::setw(15)<<"dX/dt(1/year)"<<std::endl
-                    <<"     "<<std::setprecision(6)<<std::setw(15)<<inner_temperature<<std::setw(15)<<core_data.Ri/1.e3<<std::setw(15)<<core_data.Xi
-                    <<std::setw(15)<<core_data.dT_dt *year_in_seconds<<std::setw(15)<<core_data.dR_dt/1.e3 *year_in_seconds
-                    <<std::setw(15)<<core_data.dX_dt *year_in_seconds<<std::endl;
-              this->get_pcout() << output.str();
-            }
-          is_first_call = false;
-        }
-
-      // Calculate core mantle boundary heat flow
-      {
-        const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.temperature;
-        FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                          this->get_fe(),
-                                          quadrature_formula,
-                                          update_gradients      | update_values |
-                                          update_normal_vectors |
-                                          update_quadrature_points       | update_JxW_values);
-
-        std::vector<Tensor<1,dim>> temperature_gradients (quadrature_formula.size());
-        std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-
-        //std::map<types::boundary_id, double> local_boundary_fluxes;
-        double local_CMB_flux   = 0.;
-        double local_CMB_area   = 0.;
-
-        types::boundary_id CMB_id = 0;
-
-        typename MaterialModel::Interface<dim>::MaterialModelInputs in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-        typename MaterialModel::Interface<dim>::MaterialModelOutputs out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-        // Do not request viscosity or reaction rates
-        in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties |
-                                  MaterialModel::MaterialProperties::thermal_conductivity;
-
-        // for every surface face on which it makes sense to compute a
-        // heat flux and that is owned by this processor,
-        // integrate the normal heat flux given by the formula
-        //   j =  - k * n . grad T
-        //
-        // for the spherical shell geometry, note that for the inner boundary,
-        // the normal vector points *into* the core, i.e. we compute the flux
-        // *out* of the mantle, not into it. we fix this when we add the local
-        // contribution to the global flux
-
-        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned())
-            for (const unsigned int f : cell->face_indices())
-              if (cell->at_boundary(f))
-                if (cell->face(f)->boundary_id() == CMB_id)
-                  {
-                    fe_face_values.reinit (cell, f);
-
-                    in.reinit(fe_face_values, cell, this->introspection(), this->get_solution());
-
-                    fe_face_values[this->introspection().extractors.temperature].get_function_gradients (this->get_solution(),
-                        temperature_gradients);
-
-                    this->get_material_model().evaluate(in, out);
-
-
-                    double local_normal_flux = 0;
-                    double local_face_area   = 0;
-                    for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                      {
-                        const double thermal_conductivity
-                          = out.thermal_conductivities[q];
-                        double adiabatic_flux=0.;
-                        if (this->get_material_model().is_compressible()==false)
-                          {
-                            const double alpha = out.thermal_expansion_coefficients[q];
-                            const double cp = out.specific_heat[0];
-                            const double gravity = this->get_gravity_model().gravity_vector(in.position[q]).norm();
-                            if (cell->face(f)->boundary_id()==0)
-                              adiabatic_flux = - alpha * gravity / cp;
-                            else if (cell->face(f)->boundary_id()==1)
-                              adiabatic_flux = alpha * gravity / cp;
-                          }
-
-                        local_normal_flux += -thermal_conductivity *
-                                             (temperature_gradients[q] * fe_face_values.normal_vector(q)
-                                              + adiabatic_flux) * fe_face_values.JxW(q);
-                        local_face_area   += fe_face_values.JxW(q);
-
-                      }
-                    local_CMB_flux += local_normal_flux;
-                    local_CMB_area += local_face_area;
-                  }
-        // now communicate to get the global values
-        double global_CMB_flux;
-        double global_CMB_area;
-        global_CMB_flux = Utilities::MPI::sum (local_CMB_flux, this->get_mpi_communicator());
-        global_CMB_area = Utilities::MPI::sum (local_CMB_area, this->get_mpi_communicator());
-
-        // Using area averaged heat-flux density times core mantle boundary area to calculate total heat-flux on the 3d sphere.
-        // By doing this, using dynamic core evolution with geometry other than 3d spherical shell becomes possible.
-        double average_CMB_heatflux_density = global_CMB_flux / global_CMB_area;
-        core_data.Q = average_CMB_heatflux_density * 4. * M_PI * Rc * Rc;
-      }
-
-      core_data.Q_OES = get_OES(this->get_time());
-
-      if ((core_data.Q + core_data.Q_OES) * core_data.dt!=0.)
-        {
-          double X1,R1=core_data.Ri,T1;
-          solve_time_step(X1,T1,R1);
-          if (core_data.dt!=0)
-            {
-              core_data.dR_dt=(R1-core_data.Ri)/core_data.dt;
-              core_data.dT_dt=(T1-core_data.Ti)/core_data.dt;
-              core_data.dX_dt=(X1-core_data.Xi)/core_data.dt;
-            }
-          else
-            {
-              core_data.dR_dt=0.;
-              core_data.dT_dt=0.;
-              core_data.dX_dt=0.;
-            }
-          core_data.Xi=X1;
-          core_data.Ri=R1;
-          core_data.Ti=T1;
-        }
-
-      inner_temperature = core_data.Ti - dTa;
-      update_core_data();
-      if ((core_data.Q + core_data.Q_OES + core_data.Qr) * core_data.dt!=0.)
-        {
-          std::stringstream output;
-          output<<std::setiosflags(std::ios::left)
-                <<"   Dynamic core data updated."<<std::endl
-                <<"     "<<std::setw(15)<<"Tc(K)"<<std::setw(15)<<"Ri(km)"<<std::setw(15)<<"Xi"
-                <<std::setw(15)<<"dT/dt(K/year)"<<std::setw(15)<<"dR/dt(km/year)"<<std::setw(15)<<"dX/dt(1/year)"<<std::endl
-                <<"     "<<std::setprecision(6)<<std::setw(15)<<inner_temperature<<std::setw(15)<<core_data.Ri/1.e3<<std::setw(15)<<core_data.Xi
-                <<std::setw(15)<<core_data.dT_dt *year_in_seconds<<std::setw(15)<<core_data.dR_dt/1.e3 *year_in_seconds
-                <<std::setw(15)<<core_data.dX_dt *year_in_seconds<<std::endl;
-          this->get_pcout() << output.str();
-        }
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    get_Mass(double r) const
-    {
-      return 4.*M_PI*Rho_cen*(-pow(L,2)/2.*r*exp(-pow(r/L,2))+pow(L,3)/4.*sqrt(M_PI)*erf(r/L));
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    fun_Sn(double B,double R,double n) const
-    {
-      double S=R/(2.*sqrt(M_PI));
-      for (unsigned i=1; i<=n; ++i)
-        S+=B/sqrt(M_PI)*exp(-pow(i,2)/4.)/i*sinh(i*R/B);
-      return S;
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    get_Pressure(double r) const
-    {
-      return P_CMB-(4*M_PI*constants::big_g*pow(Rho_cen,2))/3
-             *((3*pow(r,2)/10.-pow(L,2)/5)*exp(-pow(r/L,2))
-               -(3*pow(Rc,2)/10-pow(L,2)/5)*exp(-pow(Rc/L,2)));
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    get_Rho(double r) const
-    {
-      return Rho_cen*exp(-pow(r/L,2));
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    get_g(double r) const
-    {
-      return (4*M_PI/3)*constants::big_g*Rho_cen*r*(1-3*pow(r,2)/(5*pow(L,2)));
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    get_T(double Tc,double r) const
-    {
-      return Tc*exp((pow(Rc,2)-pow(r,2))/pow(D,2));
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    get_gravity_potential(double r) const
-    {
-      return 2./3.*M_PI*constants::big_g*Rho_cen*(pow(r,2)*(1.-3.*pow(r,2)
-                                                            /(10.*pow(L,2)))-pow(Rc,2)*(1.-3.*pow(Rc,2)/(10.*pow(L,2))));
-    }
-
-    template <int dim>
-    void
-    DynamicCore<dim>::
-    get_specific_heating(double Tc, double &Qs,double &Es)
-    {
-      double A=sqrt(1./(pow(L,-2)+pow(D,-2)));
-      double Is=4.*M_PI*get_T(Tc,0.)*Rho_cen*(-pow(A,2)*Rc/2.*exp(-pow(Rc/A,2))+pow(A,3)*sqrt(M_PI)/4.*erf(Rc/A));
-
-      Qs=-Cp/Tc*Is;
-      Es=Cp/Tc*(Mc-Is/Tc);
-    }
-
-    template <int dim>
-    void
-    DynamicCore<dim>::
-    get_radio_heating(double Tc, double &Qr, double &Er)
-    {
-      double B,It;
-      if (D>L)
-        {
-          B=sqrt(1/(1/pow(L,2)-1/pow(D,2)));
-          It=4*M_PI*Rho_cen/get_T(Tc,0)*(-pow(B,2)*Rc/2*exp(-pow(Rc/B,2))+pow(B,3)/sqrt(M_PI)/4*erf(Rc/B));
-        }
-      else
-        {
-          B=sqrt(1/(pow(D,-2)-pow(L,-2)));
-          It=4*M_PI*Rho_cen/get_T(Tc,0)*(pow(B,2)*Rc/2*exp(pow(Rc/B,2))-pow(B,2)*fun_Sn(B,Rc,100)/2);
-        }
-      Qr=Mc*core_data.H;
-      Er=(Mc/Tc-It)*core_data.H;
-
-    }
-
-    template <int dim>
-    void
-    DynamicCore<dim>::
-    get_heat_solution(double Tc, double r, double X,double &Eh)
-    {
-      double B,It;
-      if (D>L)
-        {
-          B=sqrt(1/(1/pow(L,2)-1/pow(D,2)));
-          It=4*M_PI*Rho_cen/get_T(Tc,0)*(-pow(B,2)*Rc/2*exp(-pow(Rc/B,2))+pow(B,3)/sqrt(M_PI)/4*erf(Rc/B));
-          It-=4*M_PI*Rho_cen/get_T(Tc,0)*(-pow(B,2)*r/2*exp(-pow(r/B,2))+pow(B,3)/sqrt(M_PI)/4*erf(r/B));
-        }
-      else
-        {
-          B=sqrt(1/(pow(D,-2)-pow(L,-2)));
-          It=4*M_PI*Rho_cen/get_T(Tc,0)*(pow(B,2)*Rc/2*exp(pow(Rc/B,2))-pow(B,2)*fun_Sn(B,Rc,100)/2);
-          It-=4*M_PI*Rho_cen/get_T(Tc,0)*(pow(B,2)*r/2*exp(pow(r/B,2))-pow(B,2)*fun_Sn(B,r,100)/2);
-        }
-      double Cc=4*M_PI*pow(r,2)*get_Rho(r)*X/(Mc-get_Mass(r));
-      Eh=Rh*(It-(Mc-get_Mass(r))/get_T(Tc,r))*Cc;
-    }
-
-    template <int dim>
-    void
-    DynamicCore<dim>::
-    get_gravity_heating(double Tc, double r,double X,double &Qg,double &Eg)
-    {
-      double Cc=4*M_PI*pow(r,2)*get_Rho(r)*X/(Mc-get_Mass(r));
-      double C_2=3./16.*pow(L,2)-0.5*pow(Rc,2)*(1.-3./10.*pow(Rc/L,2));
-      if (r==Rc)
-        Qg=0.;
-      else
-        Qg=(8./3.*pow(M_PI*Rho_cen,2)*constants::big_g*(
-              ((3./20.*pow(Rc,5)-pow(L,2)*pow(Rc,3)/8.-C_2*pow(L,2)*Rc)*exp(-pow(Rc/L,2))
-               +C_2/2.*pow(L,3)*sqrt(M_PI)*erf(Rc/L))
-              -((3./20.*pow(r,5)-pow(L,2)*pow(r,3)/8.-C_2*pow(L,2)*r)*exp(-pow(r/L,2))
-                +C_2/2.*pow(L,3)*sqrt(M_PI)*erf(r/L)))
-            -(Mc-get_Mass(r))*get_gravity_potential(r))*Beta_c*Cc;
-      Eg=Qg/Tc;
-
-    }
-
-    template <int dim>
-    void
-    DynamicCore<dim>::
-    get_adiabatic_heating(double Tc, double &Ek, double &Qk)
-    {
-      Ek=16*M_PI*k_c*pow(Rc,5)/5/pow(D,4);
-      Qk=8*M_PI*pow(Rc,3)*k_c*Tc/pow(D,2);
-    }
-    template <int dim>
-    void
-    DynamicCore<dim>::
-    get_latent_heating(double Tc, double r, double &El, double &Ql)
-    {
-      Ql=4.*M_PI*pow(r,2)*Lh*get_Rho(r);
-      El=Ql*(get_T(Tc,r)-Tc)/(Tc*get_T(Tc,r));
-    }
-
-    template <int dim>
-    double
-    DynamicCore<dim>::
-    get_radioheating_rate() const
-    {
-      double time=this->get_time()+0.5*this->get_timestep();
-      double Ht=0;
-      for (unsigned i=0; i<n_radioheating_elements; ++i)
-        Ht+=heating_rate[i]*initial_concentration[i]*1e-6*pow(0.5,time/half_life[i]/year_in_seconds/1e9);
-      return Ht;
-    }
-
-    template <int dim>
-    bool
-    DynamicCore<dim>::
-    is_OES_used() const
-    {
-      if (data_OES.size()>0)
-        return true;
-      else
-        return false;
-    }
-  }
-
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(DynamicCore,
-                                               "dynamic core",
-                                               "This is a boundary temperature model working only with spherical "
-                                               "shell geometry and core statistics postprocessor. The temperature "
-                                               "at the top is constant, and the core mantle boundary temperature "
-                                               "is dynamically evolving through time by calculating the heat flux "
-                                               "into the core and solving the core energy balance. The formulation "
-                                               "is mainly following \\cite{NPB+04}, and the plugin is used in "
-                                               "Zhang et al. [2016]. The energy of core cooling and freeing of the "
-                                               "inner core is included in the plugin. However, current plugin can not "
-                                               "deal with the energy balance if the core is in the `snowing core' regime "
-                                               "(i.e., the core solidifies from the top instead of bottom)."
-                                              )
-  }
-}
diff --git a/source/boundary_temperature/function.cc.bak b/source/boundary_temperature/function.cc.bak
deleted file mode 100644
index 886715dcb0e..00000000000
--- a/source/boundary_temperature/function.cc.bak
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/function.h>
-#include <aspect/utilities.h>
-#include <aspect/global.h>
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    template <int dim>
-    Function<dim>::Function ()
-      :
-      boundary_temperature_function (1)
-    {}
-
-
-
-    template <int dim>
-    double
-    Function<dim>::
-    boundary_temperature (const types::boundary_id /*boundary_indicator*/,
-                          const Point<dim> &position) const
-    {
-      const Utilities::NaturalCoordinate<dim> point =
-        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
-      return boundary_temperature_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::update()
-    {
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        boundary_temperature_function.set_time (this->get_time() / year_in_seconds);
-      else
-        boundary_temperature_function.set_time (this->get_time());
-    }
-
-
-
-    template <int dim>
-    double
-    Function<dim>::
-    minimal_temperature (const std::set<types::boundary_id> &) const
-    {
-      return min_temperature;
-    }
-
-
-
-    template <int dim>
-    double
-    Function<dim>::
-    maximal_temperature (const std::set<types::boundary_id> &) const
-    {
-      return max_temperature;
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Function");
-        {
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle. `depth' "
-                             "will create a function, in which only the first "
-                             "parameter is non-zero, which is interpreted to "
-                             "be the depth of the point.");
-
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-
-          prm.declare_entry ("Minimal temperature", "273.",
-                             Patterns::Double (),
-                             "Minimal temperature. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Maximal temperature", "3773.",
-                             Patterns::Double (),
-                             "Maximal temperature. Units: \\si{\\kelvin}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Function");
-        {
-          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-
-          try
-            {
-              boundary_temperature_function.parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Boundary temperature model.Function'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-          min_temperature = prm.get_double ("Minimal temperature");
-          max_temperature = prm.get_double ("Maximal temperature");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Function,
-                                               "function",
-                                               "Implementation of a model in which the boundary "
-                                               "temperature is given in terms of an explicit formula "
-                                               "that is elaborated in the parameters in section "
-                                               "``Boundary temperature model|Function''. "
-                                               "\n\n"
-                                               "Since the symbol $t$ indicating time "
-                                               "may appear in the formulas for the prescribed "
-                                               "temperatures, it is interpreted as having units "
-                                               "seconds unless the global input parameter ``Use "
-                                               "years in output instead of seconds'' is set, in "
-                                               "which case we interpret the formula expressions "
-                                               "as having units year."
-                                               "\n\n"
-                                               "Because this class simply takes what the "
-                                               "function calculates, this class can not "
-                                               "know certain pieces of information such as the "
-                                               "minimal and maximal temperature on the boundary. "
-                                               "For operations that require this, for example in "
-                                               "post-processing, this boundary temperature model "
-                                               "must therefore be told what the minimal and "
-                                               "maximal values on the boundary are. This is done "
-                                               "using parameters set in section ``Boundary temperature model/Initial temperature''."
-                                               "\n\n"
-                                               "The format of these "
-                                               "functions follows the syntax understood by the "
-                                               "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-  }
-}
diff --git a/source/boundary_temperature/initial_temperature.cc.bak b/source/boundary_temperature/initial_temperature.cc.bak
deleted file mode 100644
index 87fb480f1ca..00000000000
--- a/source/boundary_temperature/initial_temperature.cc.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/initial_temperature.h>
-#include <aspect/initial_temperature/interface.h>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-// ------------------------------ InitialTemperature -------------------
-
-    template <int dim>
-    void
-    InitialTemperature<dim>::initialize()
-    {
-      // Make sure we keep track of the initial temperature manager and
-      // that it continues to live beyond the time when the simulator
-      // class releases its pointer to it.
-      initial_temperature = this->get_initial_temperature_manager_pointer();
-    }
-
-
-
-    template <int dim>
-    double
-    InitialTemperature<dim>::
-    boundary_temperature (const types::boundary_id,
-                          const Point<dim> &position) const
-    {
-      return initial_temperature->initial_temperature(position);
-    }
-
-
-    template <int dim>
-    double
-    InitialTemperature<dim>::
-    minimal_temperature (const std::set<types::boundary_id> &) const
-    {
-      return min_temperature;
-    }
-
-
-
-    template <int dim>
-    double
-    InitialTemperature<dim>::
-    maximal_temperature (const std::set<types::boundary_id> &) const
-    {
-      return max_temperature;
-    }
-
-
-
-    template <int dim>
-    void
-    InitialTemperature<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Initial temperature");
-        {
-          prm.declare_entry ("Minimal temperature", "0.",
-                             Patterns::Double (),
-                             "Minimal temperature. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Maximal temperature", "3773.",
-                             Patterns::Double (),
-                             "Maximal temperature. Units: \\si{\\kelvin}.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    InitialTemperature<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Initial temperature");
-        {
-          min_temperature = prm.get_double ("Minimal temperature");
-          max_temperature = prm.get_double ("Maximal temperature");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(InitialTemperature,
-                                               "initial temperature",
-                                               "A model in which the temperature at the boundary "
-                                               "is chosen to be the same as given in the initial "
-                                               "conditions."
-                                               "\n\n"
-                                               "Because this class simply takes what the initial "
-                                               "temperature had described, this class can not "
-                                               "know certain pieces of information such as the "
-                                               "minimal and maximal temperature on the boundary. "
-                                               "For operations that require this, for example in "
-                                               "post-processing, this boundary temperature model "
-                                               "must therefore be told what the minimal and "
-                                               "maximal values on the boundary are. This is done "
-                                               "using parameters set in section ``Boundary temperature model/Initial temperature''.")
-  }
-}
diff --git a/source/boundary_temperature/interface.cc.bak b/source/boundary_temperature/interface.cc.bak
deleted file mode 100644
index f42bf0826c3..00000000000
--- a/source/boundary_temperature/interface.cc.bak
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <aspect/utilities.h>
-
-#include <deal.II/base/exceptions.h>
-#include <deal.II/base/signaling_nan.h>
-
-#include <list>
-#include <tuple>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    // ------------------------------ Manager -----------------------------
-    // -------------------------------- Deal with registering boundary_temperature models and automating
-    // -------------------------------- their setup and selection at run time
-
-    template <int dim>
-    Manager<dim>::~Manager()
-      = default;
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::update ()
-    {
-      for (auto &p : this->plugin_objects)
-        p->update();
-    }
-
-
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_boundary_temperature (const std::string &name,
-                                                 const std::string &description,
-                                                 void (*declare_parameters_function) (ParameterHandler &),
-                                                 std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // find out which plugins are requested and the various other
-      // parameters we declare here
-      prm.enter_subsection ("Boundary temperature model");
-      {
-        model_names
-          = Utilities::split_string_list(prm.get("List of model names"));
-
-        AssertThrow(Utilities::has_unique_entries(model_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Boundary temperature model/List of model names' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-
-        const std::string model_name = prm.get ("Model name");
-
-        AssertThrow (model_name == "unspecified" || model_names.size() == 0,
-                     ExcMessage ("The parameter 'Model name' is only used for reasons"
-                                 "of backwards compatibility and can not be used together with "
-                                 "the new functionality 'List of model names'. Please add your "
-                                 "boundary temperature model to the list instead."));
-
-        if (!(model_name == "unspecified"))
-          model_names.push_back(model_name);
-
-        // create operator list
-        std::vector<std::string> model_operator_names =
-          Utilities::possibly_extend_from_1_to_N (Utilities::split_string_list(prm.get("List of model operators")),
-                                                  model_names.size(),
-                                                  "List of model operators");
-        model_operators = Utilities::create_model_operator_list(model_operator_names);
-
-        try
-          {
-            const std::vector<types::boundary_id> x_fixed_temperature_boundary_indicators
-              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
-                                                                                    (prm.get ("Fixed temperature boundary indicators")));
-            fixed_temperature_boundary_indicators
-              = std::set<types::boundary_id> (x_fixed_temperature_boundary_indicators.begin(),
-                                              x_fixed_temperature_boundary_indicators.end());
-
-            // If no fixed temperature boundary indicators have been set, there should be no model_names chosen either.
-            // If that is indeed the case, clear the model_operators vector. Otherwise, raise an exception.
-            if (fixed_temperature_boundary_indicators.size() == 0)
-              {
-                AssertThrow(model_names.size() == 0,
-                            ExcMessage ("You have indicated that you wish to apply a boundary temperature "
-                                        "model, but the <Fixed temperature boundary indicators> parameter "
-                                        "is empty. Please use this parameter to specify the boundaries "
-                                        "on which the model(s) should be applied."));
-
-                model_operators.clear();
-              }
-          }
-        catch (const std::string &error)
-          {
-            AssertThrow (false, ExcMessage ("While parsing the entry <Model settings/Fixed temperature "
-                                            "boundary indicators>, there was an error. Specifically, "
-                                            "the conversion function complained as follows:\n\n"
-                                            + error));
-          }
-
-        allow_fixed_temperature_on_outflow_boundaries = prm.get_bool ("Allow fixed temperature on outflow boundaries");
-      }
-      prm.leave_subsection ();
-
-      // go through the list, create objects and let them parse
-      // their own parameters
-      for (auto &model_name : model_names)
-        {
-          // create boundary temperature objects
-          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
-                                          (std::get<dim>(registered_plugins)
-                                           .create_plugin (model_name,
-                                                           "Boundary temperature::Model names")));
-
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(this->plugin_objects.back().get()))
-            sim->initialize_simulator (this->get_simulator());
-
-          this->plugin_objects.back()->parse_parameters (prm);
-          this->plugin_objects.back()->initialize ();
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    Manager<dim>::boundary_temperature (const types::boundary_id boundary_indicator,
-                                        const Point<dim> &position) const
-    {
-      double temperature = 0.0;
-
-      auto p = this->plugin_objects.begin();
-      for (unsigned int i=0; i<this->plugin_objects.size(); ++p, ++i)
-        temperature = model_operators[i](temperature,
-                                         (*p)->boundary_temperature(boundary_indicator,
-                                                                    position));
-
-      return temperature;
-    }
-
-
-
-    template <int dim>
-    double
-    Manager<dim>::minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
-    {
-      double temperature = std::numeric_limits<double>::max();
-
-      for (const auto &p : this->plugin_objects)
-        temperature = std::min(temperature,
-                               p->minimal_temperature(fixed_boundary_ids));
-
-      return temperature;
-    }
-
-
-
-    template <int dim>
-    double
-    Manager<dim>::maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
-    {
-      double temperature = 0.0;
-
-      for (const auto &p : this->plugin_objects)
-        temperature = std::max(temperature,
-                               p->maximal_temperature(fixed_boundary_ids));
-
-      return temperature;
-    }
-
-
-
-    template <int dim>
-    const std::vector<std::string> &
-    Manager<dim>::get_active_boundary_temperature_names () const
-    {
-      return model_names;
-    }
-
-
-    template <int dim>
-    const std::list<std::unique_ptr<Interface<dim>>> &
-    Manager<dim>::get_active_boundary_temperature_conditions () const
-    {
-      return this->plugin_objects;
-    }
-
-
-
-    template <int dim>
-    const std::set<types::boundary_id> &
-    Manager<dim>::get_fixed_temperature_boundary_indicators() const
-    {
-      return fixed_temperature_boundary_indicators;
-    }
-
-
-
-    template <int dim>
-    bool
-    Manager<dim>::allows_fixed_temperature_on_outflow_boundaries() const
-    {
-      return allow_fixed_temperature_on_outflow_boundaries;
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // declare the entry in the parameter file
-      prm.enter_subsection ("Boundary temperature model");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry("List of model names",
-                          "",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma-separated list of boundary temperature models that "
-                          "will be used to initialize the temperature. "
-                          "These plugins are loaded in the order given, and modify the "
-                          "existing temperature field via the operators listed "
-                          "in 'List of model operators'.\n\n"
-                          "The following boundary temperature models are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-
-        prm.declare_entry("List of model operators", "add",
-                          Patterns::MultipleSelection(Utilities::get_model_operator_options()),
-                          "A comma-separated list of operators that "
-                          "will be used to append the listed temperature models onto "
-                          "the previous models. If only one operator is given, "
-                          "the same operator is applied to all models.");
-
-        prm.declare_entry ("Model name", "unspecified",
-                           Patterns::Selection (pattern_of_names+"|unspecified"),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string()
-                           + "\n\n" +
-                           "\\textbf{Warning}: This parameter provides an old and "
-                           "deprecated way of specifying "
-                           "boundary temperature models and shouldn't be used. "
-                           "Please use 'List of model names' instead.");
-
-        prm.declare_entry ("Fixed temperature boundary indicators", "",
-                           Patterns::List (Patterns::Anything()),
-                           "A comma separated list of names denoting those boundaries "
-                           "on which the temperature is fixed and described by the "
-                           "boundary temperature object selected in the 'List of model names' "
-                           "parameter. All boundary indicators used by the geometry "
-                           "but not explicitly listed here will end up with no-flux "
-                           "(insulating) boundary conditions, or, if they are listed in the "
-                           "'Fixed heat flux boundary indicators', with Neumann boundary "
-                           "conditions."
-                           "\n\n"
-                           "The names of the boundaries listed here can either be "
-                           "numbers (in which case they correspond to the numerical "
-                           "boundary indicators assigned by the geometry object), or they "
-                           "can correspond to any of the symbolic names the geometry object "
-                           "may have provided for each part of the boundary. You may want "
-                           "to compare this with the documentation of the geometry model you "
-                           "use in your model."
-                           "\n\n"
-                           "This parameter only describes which boundaries have a fixed "
-                           "temperature, but not what temperature should hold on these "
-                           "boundaries. The latter piece of information needs to be "
-                           "implemented in a plugin in the BoundaryTemperature "
-                           "group, unless an existing implementation in this group "
-                           "already provides what you want.");
-        prm.declare_entry ("Allow fixed temperature on outflow boundaries", "true",
-                           Patterns::Bool (),
-                           "When the temperature is fixed on a given boundary as determined "
-                           "by the list of 'Fixed temperature boundary indicators', there "
-                           "might be parts of the boundary where material flows out and "
-                           "one may want to prescribe the temperature only on the parts of "
-                           "the boundary where there is inflow. This parameter determines "
-                           "if temperatures are only prescribed at these inflow parts of the "
-                           "boundary (if false) or everywhere on a given boundary, independent "
-                           "of the flow direction (if true)."
-                           "Note that in this context, `fixed' refers to the fact that these "
-                           "are the boundary indicators where Dirichlet boundary conditions are "
-                           "applied, and does not imply that the boundary temperature is "
-                           "time-independent. "
-                           "\n\n"
-                           "Mathematically speaking, the temperature satisfies an "
-                           "advection-diffusion equation. For this type of equation, one can "
-                           "prescribe the temperature even on outflow boundaries as long as the "
-                           "diffusion coefficient is nonzero. This would correspond to the "
-                           "``true'' setting of this parameter, which is correspondingly the "
-                           "default. In practice, however, this would only make physical sense "
-                           "if the diffusion coefficient is actually quite large to prevent "
-                           "the creation of a boundary layer. "
-                           "In addition, if there is no diffusion, one can only impose "
-                           "Dirichlet boundary conditions (i.e., prescribe a fixed temperature "
-                           "value at the boundary) at those boundaries where material flows in. "
-                           "This would correspond to the ``false'' setting of this parameter.");
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary temperature interface",
-                                                            out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryTemperature::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryTemperature::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryTemperature::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryTemperature::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace BoundaryTemperature
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/boundary_temperature/spherical_constant.cc.bak b/source/boundary_temperature/spherical_constant.cc.bak
deleted file mode 100644
index 782788c322d..00000000000
--- a/source/boundary_temperature/spherical_constant.cc.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <deal.II/base/signaling_nan.h>
-#include <aspect/boundary_temperature/spherical_constant.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    template <int dim>
-    void
-    SphericalConstant<dim>::
-    initialize ()
-    {
-      // verify that the geometry is supported by this plugin
-      AssertThrow ( Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) ||
-                    Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()) ||
-                    Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()) ||
-                    Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()),
-                    ExcMessage ("This boundary model is only implemented if the geometry is "
-                                "one of the spherical geometries."));
-
-      // no inner boundary in a full sphere
-      if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()))
-        inner_boundary_indicator = numbers::invalid_unsigned_int;
-      else
-        inner_boundary_indicator = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
-
-      outer_boundary_indicator = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-    }
-
-
-
-    template <int dim>
-    double
-    SphericalConstant<dim>::
-    boundary_temperature (const types::boundary_id boundary_indicator,
-                          const Point<dim> &) const
-    {
-      if (boundary_indicator == outer_boundary_indicator)
-        return outer_temperature;
-      else if (boundary_indicator == inner_boundary_indicator)
-        return inner_temperature;
-      else
-        AssertThrow (false,
-                     ExcMessage ("Unknown boundary indicator for geometry model. "
-                                 "The given boundary should be ``top'' or ``bottom''."));
-
-      return numbers::signaling_nan<double>();
-    }
-
-
-
-    template <int dim>
-    double
-    SphericalConstant<dim>::
-    minimal_temperature (const std::set<types::boundary_id> &) const
-    {
-      return std::min (inner_temperature, outer_temperature);
-    }
-
-
-
-    template <int dim>
-    double
-    SphericalConstant<dim>::
-    maximal_temperature (const std::set<types::boundary_id> &) const
-    {
-      return std::max (inner_temperature, outer_temperature);
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalConstant<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Spherical constant");
-        {
-          prm.declare_entry ("Outer temperature", "0.",
-                             Patterns::Double (),
-                             "Temperature at the outer boundary (lithosphere water/air). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Inner temperature", "6000.",
-                             Patterns::Double (),
-                             "Temperature at the inner boundary (core mantle boundary). Units: \\si{\\kelvin}.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalConstant<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Spherical constant");
-        {
-          inner_temperature = prm.get_double ("Inner temperature");
-          outer_temperature = prm.get_double ("Outer temperature");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(SphericalConstant,
-                                               "spherical constant",
-                                               "A model in which the temperature is chosen constant on "
-                                               "the inner and outer boundaries of a spherical shell, ellipsoidal "
-                                               "chunk or chunk. "
-                                               "Parameters are read from subsection 'Spherical constant'.")
-  }
-}
diff --git a/source/boundary_temperature/two_merged_boxes.cc.bak b/source/boundary_temperature/two_merged_boxes.cc.bak
deleted file mode 100644
index 8167dc0b253..00000000000
--- a/source/boundary_temperature/two_merged_boxes.cc.bak
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/two_merged_boxes.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-
-    template <int dim>
-    double
-    TwoMergedBoxes<dim>::
-    boundary_temperature (const types::boundary_id boundary_indicator,
-                          const Point<dim> &) const
-    {
-      Assert (boundary_indicator<2*dim+2*(dim-1), ExcMessage ("Given boundary indicator needs to be less than 2*dimension+2*(dimension-1)."));
-
-      return temperature_values[boundary_indicator];
-    }
-
-
-    template <int dim>
-    double
-    TwoMergedBoxes<dim>::
-    minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
-    {
-      if (fixed_boundary_ids.empty())
-        return *std::min_element(temperature_values, temperature_values+2*dim+2*(dim-1));
-      else
-        {
-          double min = maximal_temperature(fixed_boundary_ids);
-          for (const auto p : fixed_boundary_ids)
-            min = std::min(min,temperature_values[p]);
-          return min;
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedBoxes<dim>::
-    maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
-    {
-      if (fixed_boundary_ids.empty())
-        return *std::max_element(temperature_values, temperature_values+2*dim+2*(dim-1));
-      else
-        {
-          double max = std::numeric_limits<double>::lowest();
-          for (const auto p : fixed_boundary_ids)
-            max = std::max(max,temperature_values[p]);
-          return max;
-        }
-    }
-
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Box with lithosphere boundary indicators");
-        {
-          prm.declare_entry ("Left temperature", "1.",
-                             Patterns::Double (),
-                             "Temperature at the left boundary (at minimal $x$-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Right temperature", "0.",
-                             Patterns::Double (),
-                             "Temperature at the right boundary (at maximal $x$-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Bottom temperature", "0.",
-                             Patterns::Double (),
-                             "Temperature at the bottom boundary (at minimal $z$-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Top temperature", "0.",
-                             Patterns::Double (),
-                             "Temperature at the top boundary (at maximal $x$-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Left temperature lithosphere", "0.",
-                             Patterns::Double (),
-                             "Temperature at the additional left lithosphere boundary (specified by user in Geometry Model). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Right temperature lithosphere", "0.",
-                             Patterns::Double (),
-                             "Temperature at the additional right lithosphere boundary (specified by user in Geometry Model). Units: \\si{\\kelvin}.");
-          if (dim==3)
-            {
-              prm.declare_entry ("Front temperature", "0.",
-                                 Patterns::Double (),
-                                 "Temperature at the front boundary (at minimal $y$-value). Units: \\si{\\kelvin}.");
-              prm.declare_entry ("Back temperature", "0.",
-                                 Patterns::Double (),
-                                 "Temperature at the back boundary (at maximal $y$-value). Units: \\si{\\kelvin}.");
-              prm.declare_entry ("Front temperature lithosphere", "0.",
-                                 Patterns::Double (),
-                                 "Temperature at the additional front lithosphere boundary (at minimal $y$-value). Units: \\si{\\kelvin}.");
-              prm.declare_entry ("Back temperature lithosphere", "0.",
-                                 Patterns::Double (),
-                                 "Temperature at the additional back lithosphere boundary (at maximal $y$-value). Units: \\si{\\kelvin}.");
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Box with lithosphere boundary indicators");
-        {
-          // verify that the geometry is a box since only for this geometry
-          // do we know for sure what boundary indicators it uses and what they mean
-          AssertThrow (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
-                       ExcMessage ("This boundary model is only useful if the geometry is "
-                                   "a box with additional boundary indicators."));
-
-          switch (dim)
-            {
-              case 2:
-                temperature_values[0] = prm.get_double ("Left temperature");
-                temperature_values[1] = prm.get_double ("Right temperature");
-                temperature_values[2] = prm.get_double ("Bottom temperature");
-                temperature_values[3] = prm.get_double ("Top temperature");
-                temperature_values[4] = prm.get_double ("Left temperature lithosphere");
-                temperature_values[5] = prm.get_double ("Right temperature lithosphere");
-                break;
-
-              case 3:
-                temperature_values[0] = prm.get_double ("Left temperature");
-                temperature_values[1] = prm.get_double ("Right temperature");
-                temperature_values[2] = prm.get_double ("Front temperature");
-                temperature_values[3] = prm.get_double ("Back temperature");
-                temperature_values[4] = prm.get_double ("Bottom temperature");
-                temperature_values[5] = prm.get_double ("Top temperature");
-                temperature_values[6] = prm.get_double ("Left temperature lithosphere");
-                temperature_values[7] = prm.get_double ("Right temperature lithosphere");
-                temperature_values[8] = prm.get_double ("Front temperature lithosphere");
-                temperature_values[9] = prm.get_double ("Back temperature lithosphere");
-                break;
-
-              default:
-                Assert (false, ExcNotImplemented());
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(TwoMergedBoxes,
-                                               "box with lithosphere boundary indicators",
-                                               "A model in which the temperature is chosen constant on "
-                                               "all the sides of a box. Additional boundary indicators "
-                                               "are added to the lithospheric parts of the vertical boundaries. "
-                                               "This model is to be used with the 'Two Merged Boxes' Geometry Model.")
-  }
-}
diff --git a/source/boundary_traction/ascii_data.cc.bak b/source/boundary_traction/ascii_data.cc.bak
deleted file mode 100644
index 60c293d13f7..00000000000
--- a/source/boundary_traction/ascii_data.cc.bak
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_traction/ascii_data.h>
-#include <aspect/global.h>
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      for (const auto &bv : this->get_boundary_traction_manager().get_active_boundary_traction_conditions())
-        {
-          for (const auto &plugin : bv.second)
-            if (plugin.get() == this)
-              boundary_ids.insert(bv.first);
-        }
-      AssertThrow(*(boundary_ids.begin()) != numbers::invalid_boundary_id,
-                  ExcMessage("Did not find the boundary indicator for the traction ascii data plugin."));
-
-      Utilities::AsciiDataBoundary<dim>::initialize(boundary_ids,
-                                                    1);
-    }
-
-
-    template <int dim>
-    Tensor<1,dim>
-    AsciiData<dim>::
-    boundary_traction (const types::boundary_id boundary_indicator,
-                       const Point<dim> &position,
-                       const Tensor<1,dim> &normal_vector) const
-    {
-      const double pressure = Utilities::AsciiDataBoundary<dim>::get_data_component(boundary_indicator,
-                                                                                    position,
-                                                                                    0);
-      return -pressure * normal_vector;
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::update()
-    {
-      Interface<dim>::update ();
-      Utilities::AsciiDataBoundary<dim>::update();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary traction model");
-      {
-        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
-                                                              "$ASPECT_SOURCE_DIR/data/boundary-traction/ascii-data/test/",
-                                                              "box_2d_%s.%d.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary traction model");
-      {
-        Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(AsciiData,
-                                            "ascii data",
-                                            "Implementation of a model in which the boundary "
-                                            "traction is derived from files containing pressure data "
-                                            "in ascii format. The pressure given in the data file is "
-                                            "applied as traction normal to the surface of a given boundary, "
-                                            "pointing inwards. Note the required format of the "
-                                            "input data: The first lines may contain any number of comments "
-                                            "if they begin with `#', but one of these lines needs to "
-                                            "contain the number of grid points in each dimension as "
-                                            "for example `# POINTS: 3 3'. "
-                                            "The order of the data columns "
-                                            "has to be `x', `Pressure [Pa]' in a 2d model and "
-                                            " `x', `y', `Pressure [Pa]' in a 3d model, which means that "
-                                            "there has to be a single column "
-                                            "containing the pressure. "
-                                            "Note that the data in the input "
-                                            "files need to be sorted in a specific order: "
-                                            "the first coordinate needs to ascend first, "
-                                            "followed by the second in order to "
-                                            "assign the correct data to the prescribed coordinates. "
-                                            "If you use a spherical model, "
-                                            "then the data will still be handled as Cartesian, "
-                                            "however the assumed grid changes. `x' will be replaced by "
-                                            "the radial distance of the point to the bottom of the model, "
-                                            "`y' by the azimuth angle and `z' by the polar angle measured "
-                                            "positive from the north pole. The grid will be assumed to be "
-                                            "a latitude-longitude grid. Note that the order "
-                                            "of spherical coordinates is `r', `phi', `theta' "
-                                            "and not `r', `theta', `phi', since this allows "
-                                            "for dimension independent expressions.")
-  }
-}
diff --git a/source/boundary_traction/function.cc.bak b/source/boundary_traction/function.cc.bak
deleted file mode 100644
index 82c3ab75e77..00000000000
--- a/source/boundary_traction/function.cc.bak
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_traction/function.h>
-#include <aspect/utilities.h>
-#include <aspect/global.h>
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    template <int dim>
-    Function<dim>::Function ()
-      :
-      boundary_traction_function (dim)
-    {}
-
-
-
-    template <int dim>
-    Tensor<1,dim>
-    Function<dim>::
-    boundary_traction (const types::boundary_id,
-                       const Point<dim> &position,
-                       const Tensor<1,dim> &) const
-    {
-      Tensor<1,dim> traction;
-      Utilities::NaturalCoordinate<dim> point =
-        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
-      for (unsigned int d=0; d<dim; ++d)
-        traction[d] = boundary_traction_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()),d);
-      if (use_spherical_unit_vectors)
-        traction = Utilities::Coordinates::spherical_to_cartesian_vector(traction, position);
-
-      return traction;
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::update()
-    {
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        boundary_traction_function.set_time (this->get_time() / year_in_seconds);
-      else
-        boundary_traction_function.set_time (this->get_time());
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary traction model");
-      {
-        prm.enter_subsection("Function");
-        {
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle. `depth' "
-                             "will create a function, in which only the first "
-                             "parameter is non-zero, which is interpreted to "
-                             "be the depth of the point.");
-          prm.declare_entry ("Use spherical unit vectors", "false",
-                             Patterns::Bool (),
-                             "Specify traction as $r$, $\\phi$, and $\\theta$ components "
-                             "instead of $x$, $y$, and $z$. Positive tractions point up, east, "
-                             "and north (in 3d) or out and clockwise (in 2d). "
-                             "This setting only makes sense for spherical geometries.");
-
-          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary traction model");
-      {
-        prm.enter_subsection("Function");
-        {
-          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-          use_spherical_unit_vectors = prm.get_bool("Use spherical unit vectors");
-          if (use_spherical_unit_vectors)
-            AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
-                         ExcMessage ("Spherical unit vectors should not be used "
-                                     "when geometry model is not spherical."));
-        }
-        try
-          {
-            boundary_traction_function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Boundary traction model.Function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(Function,
-                                            "function",
-                                            "Implementation of a model in which the boundary "
-                                            "traction is given in terms of an explicit formula "
-                                            "that is elaborated in the parameters in section "
-                                            "``Boundary traction model|Function''. "
-                                            "\n\n"
-                                            "The formula you describe in the mentioned "
-                                            "section is a semicolon separated list of traction components "
-                                            "for each of the $d$ components of the traction vector. "
-                                            "These $d$ formulas are interpreted as having units "
-                                            "Pa.")
-  }
-}
diff --git a/source/boundary_traction/initial_lithostatic_pressure.cc.bak b/source/boundary_traction/initial_lithostatic_pressure.cc.bak
deleted file mode 100644
index 985ca78071e..00000000000
--- a/source/boundary_traction/initial_lithostatic_pressure.cc.bak
+++ /dev/null
@@ -1,442 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_traction/initial_lithostatic_pressure.h>
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/initial_composition/interface.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <array>
-
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/two_merged_chunks.h>
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-
-    template <int dim>
-    void
-    InitialLithostaticPressure<dim>::initialize()
-    {
-      // Ensure the initial lithostatic pressure traction boundary conditions are used,
-      // and register for which boundary indicators these conditions are set.
-      std::set<types::boundary_id> traction_bi;
-      for (const auto &p : this->get_boundary_traction_manager().get_active_boundary_traction_conditions())
-        {
-          for (const auto &plugin : p.second)
-            if (plugin.get() == this)
-              traction_bi.insert(p.first);
-        }
-      AssertThrow(*(traction_bi.begin()) != numbers::invalid_boundary_id,
-                  ExcMessage("Did not find any boundary indicators for the initial lithostatic pressure plugin."));
-
-      // Determine whether traction boundary conditions are only set on the bottom
-      // boundary and initial topography is applied.
-      bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
-      if (!Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()) &&
-          traction_bi.size() == 1 &&
-          *traction_bi.begin() == bottom_boundary_id)
-        prescribe_constant_pressure_at_bottom_boundary = true;
-      else
-        prescribe_constant_pressure_at_bottom_boundary = false;
-
-      // The below is adapted from adiabatic_conditions/initial_profile.cc,
-      // but we use the initial temperature and composition and only calculate
-      // a pressure profile with depth.
-
-      // The number of compositional fields
-      const unsigned int n_compositional_fields = this->n_compositional_fields();
-
-      // The pressure at the surface
-      pressure[0]    = this->get_surface_pressure();
-
-      // For spherical(-like) domains, modify the representative point:
-      // go from degrees to radians...
-      std::array<double, dim> spherical_representative_point;
-      for (unsigned int d=0; d<dim; ++d)
-        spherical_representative_point[d] = representative_point[d];
-      spherical_representative_point[1] *= constants::degree_to_radians;
-      // and go from latitude to colatitude.
-      if (dim == 3)
-        {
-          spherical_representative_point[2] = 90.0 - spherical_representative_point[2];
-          spherical_representative_point[2] *= constants::degree_to_radians;
-        }
-
-      // Check that the representative point lies in the domain.
-      AssertThrow(((this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian) ?
-                   (this->get_geometry_model().point_is_in_domain(representative_point)) :
-                   (this->get_geometry_model().point_is_in_domain(Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_representative_point)))),
-                  ExcMessage("The reference point does not lie with the domain."));
-
-      // Set the radius of the representative point to the surface radius for spherical domains
-      // or set the vertical coordinate to the surface value for box domains.
-      // Also get the depth extent without including initial topography, and the vertical coordinate
-      // of the bottom boundary (radius for spherical and z-coordinate for Cartesian domains).
-      double depth_extent = 0.;
-      if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()))
-        {
-          spherical_representative_point[0] = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()).outer_radius();
-          // Spherical shell cannot include initial topography
-          depth_extent =  Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()).maximal_depth();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
-        {
-          // Does not include initial topography
-          spherical_representative_point[0] =  Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>(this->get_geometry_model()).outer_radius();
-          depth_extent = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>(this->get_geometry_model()).maximal_depth();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedChunks<dim>> (this->get_geometry_model()))
-        {
-          // Does not include initial topography
-          spherical_representative_point[0] =  Plugins::get_plugin_as_type<const GeometryModel::TwoMergedChunks<dim>>(this->get_geometry_model()).outer_radius();
-          depth_extent = Plugins::get_plugin_as_type<const GeometryModel::TwoMergedChunks<dim>>(this->get_geometry_model()).maximal_depth();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::EllipsoidalChunk<dim> &gm = Plugins::get_plugin_as_type<const GeometryModel::EllipsoidalChunk<dim>> (this->get_geometry_model());
-          // TODO
-          // If the eccentricity of the EllipsoidalChunk is non-zero, the radius can vary along a boundary,
-          // but the maximal depth is the same everywhere and we could calculate a representative pressure
-          // profile. However, it requires some extra logic with ellipsoidal
-          // coordinates, so for now we only allow eccentricity zero.
-          // Using the EllipsoidalChunk with eccentricity zero can still be useful,
-          // because the domain can be non-coordinate parallel.
-          AssertThrow(gm.get_eccentricity() == 0.0, ExcMessage("This initial lithospheric pressure plugin cannot be used with a non-zero eccentricity. "));
-
-          spherical_representative_point[0] = gm.get_semi_major_axis_a();
-          // Does not include initial topography
-          depth_extent = gm.maximal_depth();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()))
-        {
-          AssertThrow(false, ExcMessage("Using the initial lithospheric pressure plugin does not make sense for a Sphere geometry."));
-          spherical_representative_point[0] =  Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>>(this->get_geometry_model()).radius();
-          // Cannot include initial topography. Radius and maximum depth are the same.
-          depth_extent = spherical_representative_point[0];
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()))
-        {
-          representative_point[dim-1]=  Plugins::get_plugin_as_type<const GeometryModel::Box<dim>>(this->get_geometry_model()).get_extents()[dim-1];
-          // Maximal_depth includes the maximum topography, while we need the topography at the
-          // representative point. Therefore, we only get the undeformed (uniform) depth.
-          depth_extent = representative_point[dim-1] - Plugins::get_plugin_as_type<const GeometryModel::Box<dim>>(this->get_geometry_model()).get_origin()[dim-1];
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
-        {
-          representative_point[dim-1]=  Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()).get_extents()[dim-1];
-          // Maximal_depth includes the maximum topography, while we need the topography at the
-          // representative point. Therefore, we only get the undeformed (uniform) depth.
-          depth_extent = representative_point[dim-1] - Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()).get_origin()[dim-1];
-        }
-      else
-        AssertThrow(false, ExcNotImplemented());
-
-      // If present, retrieve initial topography at the reference point.
-      double topo = 0.;
-      if (!Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()))
-        {
-          // Get the surface x (,y) point
-          Point<dim-1> surface_point;
-          for (unsigned int d=0; d<dim-1; d++)
-            {
-              if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian)
-                surface_point[d] = representative_point[d];
-              else
-                surface_point[d] = spherical_representative_point[d];
-
-            }
-          const InitialTopographyModel::Interface<dim> *topo_model = const_cast<InitialTopographyModel::Interface<dim>*>(&this->get_initial_topography_model());
-          topo = topo_model->value(surface_point);
-        }
-
-      // The spacing of the depth profile at the location of the representative point.
-      delta_z = (depth_extent + topo) / (n_points-1);
-
-      // Set up the input for the density function of the material model.
-      typename MaterialModel::Interface<dim>::MaterialModelInputs in(1, n_compositional_fields);
-      typename MaterialModel::Interface<dim>::MaterialModelOutputs out(1, n_compositional_fields);
-      in.requested_properties = MaterialModel::MaterialProperties::density;
-
-      // Where to calculate the density
-      // for Cartesian domains
-      if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()) ||
-          Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
-        in.position[0] = representative_point;
-      // and for spherical domains
-      else
-        in.position[0] = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_representative_point);
-
-      // We need the initial temperature at this point
-      in.temperature[0] = this->get_initial_temperature_manager().initial_temperature(in.position[0]);
-
-      // and the surface pressure.
-      in.pressure[0] = pressure[0];
-
-      // Then the compositions at this point.
-      for (unsigned int c=0; c<n_compositional_fields; ++c)
-        in.composition[0][c] = this->get_initial_composition_manager().initial_composition(in.position[0], c);
-
-      // Hopefully the material model won't needed in.strain_rate, we
-      // leave it as NaNs.
-
-      // We set all entries of the velocity vector to zero since this is the lithostatic case.
-      in.velocity[0] = Tensor<1,dim> ();
-
-      // Evaluate the material model to get the density.
-      this->get_material_model().evaluate(in, out);
-      const double density0 = out.densities[0];
-
-      // Get the magnitude of gravity. We assume
-      // that gravity always points along the depth direction. This
-      // may not strictly be true always but is likely a good enough
-      // approximation here.
-      const double gravity0 = this->get_gravity_model().gravity_vector(in.position[0]).norm();
-
-      // Now integrate pressure downward using trapezoidal integration
-      // p'(z) = rho(p,c,T) * |g| * delta_z
-      double sum = delta_z * 0.5 * density0 * gravity0;
-
-      for (unsigned int i=1; i<n_points; ++i)
-        {
-          AssertThrow (i < pressure.size(), ExcMessage(std::string("The current index ")
-                                                       + dealii::Utilities::int_to_string(i)
-                                                       + std::string(" is bigger than the size of the pressure vector ")
-                                                       + dealii::Utilities::int_to_string(pressure.size())));
-
-          // Where to calculate the density:
-          // for Cartesian domains
-          if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()) ||
-              Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
-            {
-              // decrease z coordinate with depth increment
-              representative_point[dim-1] -= delta_z;
-              in.position[0] = representative_point;
-            }
-          // and for spherical domains
-          else
-            {
-              // decrease radius with depth increment
-              spherical_representative_point[0] -= delta_z;
-              in.position[0] = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_representative_point);
-            }
-
-          // Retrieve the initial temperature at this point.
-          in.temperature[0] = this->get_initial_temperature_manager().initial_temperature(in.position[0]);
-          // and use the previous pressure
-          in.pressure[0] = pressure[i-1];
-
-          // Retrieve the compositions at this point.
-          for (unsigned int c=0; c<n_compositional_fields; ++c)
-            in.composition[0][c] = this->get_initial_composition_manager().initial_composition(in.position[0], c);
-
-          // We set all entries of the velocity vector to zero since this is the lithostatic case.
-          in.velocity[0] = Tensor<1,dim> ();
-
-          // Evaluate the material model to get the density at the current point.
-          this->get_material_model().evaluate(in, out);
-          const double density = out.densities[0];
-
-          // Get the magnitude of gravity.
-          const double gravity = this->get_gravity_model().gravity_vector(in.position[0]).norm();
-
-          // Trapezoid integration
-          pressure[i] = sum + delta_z * 0.5 * density * gravity;
-          sum += delta_z * density * gravity;
-        }
-
-      Assert (*std::min_element (pressure.begin(), pressure.end()) >=
-              -std::numeric_limits<double>::epsilon() * pressure.size(),
-              ExcInternalError());
-
-    }
-
-    template <int dim>
-    Tensor<1,dim>
-    InitialLithostaticPressure<dim>::
-    boundary_traction (const types::boundary_id boundary_indicator,
-                       const Point<dim> &position,
-                       const Tensor<1,dim> &normal_vector) const
-    {
-      // We want to set the normal component to the vertical boundary
-      // to the lithostatic pressure, the rest of the traction
-      // components are left set to zero. We get the lithostatic pressure
-      // from a linear interpolation of the calculated profile,
-      // unless boundary traction is only applied to the bottom boundary
-      // and initial topography is included.
-      // In that case we return the deepest pressure of the pressure
-      // profile directly. Otherwise, points on the bottom boundary
-      // with horizontal coordinates other than the reference point
-      // will not have a depth equal to the deepest depth of the profile.
-      Tensor<1, dim> traction;
-      if (prescribe_constant_pressure_at_bottom_boundary && boundary_indicator == bottom_boundary_id)
-        traction = -pressure.back() * normal_vector;
-      else
-        traction = -interpolate_pressure(position) * normal_vector;
-
-      return traction;
-    }
-
-    template <int dim>
-    double
-    InitialLithostaticPressure<dim>::
-    interpolate_pressure (const Point<dim> &p) const
-    {
-      // The depth at which we need the pressure.
-      const double z = this->get_geometry_model().depth(p);
-
-      // Check that depth does not exceed the maximal depth.
-      if (z >= this->get_geometry_model().maximal_depth())
-        {
-          Assert (z <= this->get_geometry_model().maximal_depth() + delta_z,
-                  ExcInternalError());
-          // Return deepest (last) pressure
-          return pressure.back();
-        }
-
-      const unsigned int i = static_cast<unsigned int>(z/delta_z);
-      // If mesh deformation is allowed, the depth can become
-      // negative. However, the returned depth is capped at 0
-      // by the geometry models and thus always positive.
-      Assert ((z/delta_z) >= 0, ExcInternalError());
-      Assert (i+1 < pressure.size(), ExcInternalError());
-
-      // Now do the linear interpolation.
-      const double d=1.0+i-z/delta_z;
-      Assert ((d>=0) && (d<=1), ExcInternalError());
-
-      return d*pressure[i]+(1-d)*pressure[i+1];
-    }
-
-
-    template <int dim>
-    void
-    InitialLithostaticPressure<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary traction model");
-      {
-        prm.enter_subsection("Initial lithostatic pressure");
-        {
-          prm.declare_entry ("Representative point", "",
-                             Patterns::List(Patterns::Double()),
-                             "The point where the pressure profile will be calculated. "
-                             "Cartesian coordinates $(x,y,z)$ when geometry is a box, otherwise enter radius, "
-                             "longitude, and in 3d latitude. Note that the coordinate related to the depth "
-                             "($y$ in 2d Cartesian, $z$ in 3d Cartesian and radius in spherical coordinates) is "
-                             "not used. "
-                             "Units: \\si{\\meter} or degrees.");
-          prm.declare_entry("Number of integration points", "1000",
-                            Patterns::Integer(0),
-                            "The number of integration points over which we integrate the lithostatic pressure "
-                            "downwards.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    InitialLithostaticPressure<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      unsigned int refinement;
-      prm.enter_subsection("Mesh refinement");
-      {
-        refinement = prm.get_integer("Initial adaptive refinement") + prm.get_integer("Initial global refinement");
-      }
-      prm.leave_subsection();
-
-      prm.enter_subsection("Boundary traction model");
-      {
-        prm.enter_subsection("Initial lithostatic pressure");
-        {
-          // The representative point where to calculate the depth profile.
-          const std::vector<double> rep_point =
-            dealii::Utilities::string_to_double(dealii::Utilities::split_string_list(prm.get("Representative point")));
-          AssertThrow(rep_point.size() == dim, ExcMessage("Representative point does not have the right dimensions."));
-          for (unsigned int d = 0; d<dim; ++d)
-            representative_point[d] = rep_point[d];
-          n_points = prm.get_integer("Number of integration points");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Check that we have enough integration points for this mesh.
-      AssertThrow(std::pow(2.0,refinement) <= n_points, ExcMessage("Not enough integration points for this resolution."));
-
-      pressure.resize(n_points,-1);
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(InitialLithostaticPressure,
-                                            "initial lithostatic pressure",
-                                            "Implementation of a model in which the boundary "
-                                            "traction is given in terms of a normal traction component "
-                                            "set to the lithostatic pressure "
-                                            "calculated according to the parameters in section "
-                                            "``Boundary traction model|Lithostatic pressure''. "
-                                            "\n\n"
-                                            "The lithostatic pressure is calculated by integrating "
-                                            "the pressure downward based on the initial composition "
-                                            "and temperature along the user-specified depth profile. "
-                                            "The user-specified profile is given in terms of a point "
-                                            "in Cartesian coordinates for box geometries and "
-                                            "in spherical coordinates for all "
-                                            "other geometries (radius, longitude, latitude), and "
-                                            "the number of integration points. "
-                                            "The lateral coordinates of the point are used to calculate "
-                                            "the lithostatic pressure profile with depth. This means that "
-                                            "the depth coordinate is not used. "
-                                            "Note that when initial topography is included, the initial "
-                                            "topography at the user-provided representative point is used "
-                                            "to compute the profile. If at other points the (initial) topography "
-                                            "is higher, the behavior of this plugin at later timesteps depends "
-                                            "on the domain geometry. The depth returned by the geometry model "
-                                            "does (box geometries) or does not (spherical "
-                                            "geometries) include the initial topography. This depth is used "
-                                            "to interpolate between the points of the reference pressure profile. "
-                                            "Depths outside the reference profile get returned the pressure value "
-                                            "of the closest profile depth. When only the bottom boundary is "
-                                            "prescribed initial lithostatic pressure, the pressure value of "
-                                            "the deepest depth of the profile is returned. "
-                                            "\n\n"
-                                            "Gravity is expected to point along the depth direction. ")
-  }
-}
diff --git a/source/boundary_traction/interface.cc.bak b/source/boundary_traction/interface.cc.bak
deleted file mode 100644
index fcfbd167fb5..00000000000
--- a/source/boundary_traction/interface.cc.bak
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_traction/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    template <int dim>
-    Manager<dim>::~Manager()
-      = default;
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::update ()
-    {
-      for (const auto &boundary : boundary_traction_objects)
-        for (const auto &p : boundary.second)
-          p->update();
-    }
-
-
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-    template <int dim>
-    void
-    Manager<dim>::register_boundary_traction (const std::string &name,
-                                              const std::string &description,
-                                              void (*declare_parameters_function) (ParameterHandler &),
-                                              std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-    template <int dim>
-    Tensor<1,dim>
-    Manager<dim>::boundary_traction (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position,
-                                     const Tensor<1,dim> &normal_vector) const
-    {
-      typename std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryTraction::Interface<dim>>>>::const_iterator boundary_plugins =
-        boundary_traction_objects.find(boundary_indicator);
-
-      Assert(boundary_plugins != boundary_traction_objects.end(),
-             ExcMessage("The boundary traction manager class was asked for the "
-                        "boundary traction at a boundary that contains no active "
-                        "boundary traction plugin."));
-
-      Tensor<1,dim> traction = Tensor<1,dim>();
-
-      for (const auto &plugin : boundary_plugins->second)
-        traction += plugin->boundary_traction(boundary_indicator,
-                                              position,normal_vector);
-
-      return traction;
-    }
-
-
-
-    template <int dim>
-    const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> &
-    Manager<dim>::get_active_boundary_traction_names () const
-    {
-      return boundary_traction_indicators;
-    }
-
-
-
-    template <int dim>
-    const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryTraction::Interface<dim>>>> &
-    Manager<dim>::get_active_boundary_traction_conditions () const
-    {
-      return boundary_traction_objects;
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Boundary traction model");
-      {
-        prm.declare_entry ("Prescribed traction boundary indicators", "",
-                           Patterns::Map (Patterns::Anything(),
-                                          Patterns::Selection(std::get<dim>(registered_plugins).get_pattern_of_names ())),
-                           "A comma separated list denoting those boundaries "
-                           "on which the traction is prescribed, i.e., where unknown "
-                           "external forces act to prescribe a particular traction. This is "
-                           "often used to prescribe a traction that equals that of "
-                           "overlying plates."
-                           "\n\n"
-                           "The format of valid entries for this parameter is that of a map "
-                           "given as ``key1 [selector]: value1, key2 [selector]: value2, key3: value3, ...'' where "
-                           "each key must be a valid boundary indicator (which is either an "
-                           "integer or the symbolic name the geometry model in use may have "
-                           "provided for this part of the boundary) "
-                           "and each value must be one of the currently implemented boundary "
-                           "traction models. ``selector'' is an optional string given as a subset "
-                           "of the letters `xyz' that allows you to apply the boundary conditions "
-                           "only to the components listed. As an example, '1 y: function' applies "
-                           "the type `function' to the y component on boundary 1. Without a selector "
-                           "it will affect all components of the traction."
-                           "\n\n"
-                           "Note that traction should be given in N/m^2. "
-
-                           "The following boundary traction models are available:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Boundary traction model");
-      {
-        // find out which plugins are requested and the various other
-        // parameters we declare here
-        const std::vector<std::string> x_boundary_traction_indicators
-          = Utilities::split_string_list(prm.get("Prescribed traction boundary indicators"));
-
-        for (const auto &p : x_boundary_traction_indicators)
-          {
-            // each entry has the format (white space is optional):
-            // <id> [x][y][z] : <value (might have spaces)>
-            //
-            // first tease apart the two halves
-            const std::vector<std::string> split_parts = Utilities::split_string_list (p, ':');
-            AssertThrow (split_parts.size() == 2,
-                         ExcMessage ("The format for prescribed traction boundary indicators "
-                                     "requires that each entry has the form `"
-                                     "<id> [x][y][z] : <value>', but there does not "
-                                     "appear to be a colon in the entry <"
-                                     + p
-                                     + ">."));
-
-            // the easy part: get the value
-            const std::string &value = split_parts[1];
-
-            // now for the rest. since we don't know whether there is a
-            // component selector, start reading at the end and subtracting
-            // letters x, y and z
-            std::string key_and_comp = split_parts[0];
-            std::string comp;
-            while ((key_and_comp.size()>0) &&
-                   ((key_and_comp[key_and_comp.size()-1] == 'x')
-                    ||
-                    (key_and_comp[key_and_comp.size()-1] == 'y')
-                    ||
-                    ((key_and_comp[key_and_comp.size()-1] == 'z') && (dim==3))))
-              {
-                comp += key_and_comp[key_and_comp.size()-1];
-                key_and_comp.erase (--key_and_comp.end());
-              }
-
-            // we've stopped reading component selectors now. there are three
-            // possibilities:
-            // - no characters are left. this means that key_and_comp only
-            //   consisted of a single word that only consisted of 'x', 'y'
-            //   and 'z's. then this would have been a mistake to classify
-            //   as a component selector, and we better undo it
-            // - the last character of key_and_comp is not a whitespace. this
-            //   means that the last word in key_and_comp ended in an 'x', 'y'
-            //   or 'z', but this was not meant to be a component selector.
-            //   in that case, put these characters back.
-            // - otherwise, we split successfully. eat spaces that may be at
-            //   the end of key_and_comp to get key
-            if (key_and_comp.size() == 0)
-              key_and_comp.swap (comp);
-            else if (key_and_comp[key_and_comp.size()-1] != ' ')
-              {
-                key_and_comp += comp;
-                comp = "";
-              }
-            else
-              {
-                while ((key_and_comp.size()>0) && (key_and_comp[key_and_comp.size()-1] == ' '))
-                  key_and_comp.erase (--key_and_comp.end());
-              }
-
-            // finally, try to translate the key into a boundary_id. then
-            // make sure we haven't seen it yet
-            types::boundary_id boundary_id;
-            try
-              {
-                boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id(key_and_comp);
-              }
-            catch (const std::string &error)
-              {
-                AssertThrow (false, ExcMessage ("While parsing the entry <Boundary traction model/Prescribed "
-                                                "traction indicators>, there was an error. Specifically, "
-                                                "the conversion function complained as follows:\n\n"
-                                                + error));
-              }
-
-            if (boundary_traction_indicators.find(boundary_id) != boundary_traction_indicators.end())
-              {
-                Assert(boundary_traction_indicators[boundary_id].first == comp,
-                       ExcMessage("Different traction plugins for the same boundary have to have the same component selector. "
-                                  "This was not the case for boundary: " + key_and_comp +
-                                  ", for plugin: " + value + ", with component selector: " + comp));
-
-                // finally, put it into the list
-                boundary_traction_indicators[boundary_id].second.push_back(value);
-              }
-            else
-              {
-                boundary_traction_indicators[boundary_id] = std::make_pair(comp,std::vector<std::string>(1,value));
-              }
-          }
-      }
-      prm.leave_subsection();
-
-      // go through the list, create objects and let them parse
-      // their own parameters
-      for (const auto &boundary_id : boundary_traction_indicators)
-        {
-          for (const auto &name : boundary_id.second.second)
-            {
-              boundary_traction_objects[boundary_id.first].push_back(
-                std::unique_ptr<Interface<dim>> (std::get<dim>(registered_plugins)
-                                                  .create_plugin (name,
-                                                                  "Boundary traction::Model names")));
-
-              if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(boundary_traction_objects[boundary_id.first].back().get()))
-                sim->initialize_simulator (this->get_simulator());
-
-              boundary_traction_objects[boundary_id.first].back()->parse_parameters (prm);
-              boundary_traction_objects[boundary_id.first].back()->initialize ();
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary traction interface",
-                                                            out);
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryTraction::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryTraction::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryTraction::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryTraction::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace BoundaryTraction
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>; \
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/boundary_traction/zero_traction.cc.bak b/source/boundary_traction/zero_traction.cc.bak
deleted file mode 100644
index 3d4fb01e953..00000000000
--- a/source/boundary_traction/zero_traction.cc.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_traction/zero_traction.h>
-
-
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    template <int dim>
-    Tensor<1,dim>
-    ZeroTraction<dim>::
-    boundary_traction (const types::boundary_id,
-                       const Point<dim> &,
-                       const Tensor<1,dim> &) const
-    {
-      // return a zero tensor regardless of position
-      return Tensor<1,dim>();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTraction
-  {
-    ASPECT_REGISTER_BOUNDARY_TRACTION_MODEL(ZeroTraction,
-                                            "zero traction",
-                                            "Implementation of a model in which the boundary "
-                                            "traction is zero. This is commonly referred to as "
-                                            "an ``open boundary condition'', indicating that "
-                                            "the material experiences no forces in response to "
-                                            "what might exist on the other side of the boundary. "
-                                            "However, this is only true in the case where "
-                                            "hydrostatic pressure is not relevant. If hydrostatic "
-                                            "pressure is not negligible, for example at the sides "
-                                            "of a regional model, the material at the other side "
-                                            "of the boundary does exceed a force, namely the "
-                                            "force normal to the boundary induced by the "
-                                            "hydrostatic pressure.")
-  }
-}
diff --git a/source/boundary_velocity/ascii_data.cc.bak b/source/boundary_velocity/ascii_data.cc.bak
deleted file mode 100644
index 5e0843075e1..00000000000
--- a/source/boundary_velocity/ascii_data.cc.bak
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_velocity/ascii_data.h>
-
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      for (const auto &p : this->get_boundary_velocity_manager().get_active_boundary_velocity_conditions())
-        {
-          for (const auto &plugin : p.second)
-            if (plugin.get() == this)
-              boundary_ids.insert(p.first);
-        }
-      AssertThrow(*(boundary_ids.begin()) != numbers::invalid_boundary_id,
-                  ExcMessage("Did not find the boundary indicator for the prescribed data plugin."));
-
-      Utilities::AsciiDataBoundary<dim>::initialize(boundary_ids,
-                                                    dim);
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::update ()
-    {
-      Interface<dim>::update ();
-
-      Utilities::AsciiDataBoundary<dim>::update();
-    }
-
-
-    template <int dim>
-    Tensor<1,dim>
-    AsciiData<dim>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<dim> &position) const
-    {
-      Tensor<1,dim> velocity;
-      for (unsigned int i = 0; i < dim; ++i)
-        velocity[i] = Utilities::AsciiDataBoundary<dim>::get_data_component(*(boundary_ids.begin()),
-                                                                            position,
-                                                                            i);
-      if (use_spherical_unit_vectors)
-        velocity = Utilities::Coordinates::spherical_to_cartesian_vector(velocity, position);
-
-      return velocity;
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary velocity model");
-      {
-        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
-                                                              "$ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/",
-                                                              "box_2d_%s.%d.txt");
-        prm.enter_subsection("Ascii data model");
-        {
-          prm.declare_entry ("Use spherical unit vectors", "false",
-                             Patterns::Bool (),
-                             "Specify velocity as r, phi, and theta components "
-                             "instead of x, y, and z. Positive velocities point up, east, "
-                             "and north (in 3d) or out and clockwise (in 2d). "
-                             "This setting only makes sense for spherical geometries."
-                            );
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary velocity model");
-      {
-        Utilities::AsciiDataBoundary<dim>::parse_parameters(prm);
-
-        if (this->convert_output_to_years() == true)
-          {
-            this->scale_factor               /= year_in_seconds;
-          }
-        prm.enter_subsection("Ascii data model");
-        {
-          use_spherical_unit_vectors = prm.get_bool("Use spherical unit vectors");
-          if (use_spherical_unit_vectors)
-            AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
-                         ExcMessage ("Spherical unit vectors should not be used "
-                                     "when geometry model is not spherical."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(AsciiData,
-                                            "ascii data",
-                                            "Implementation of a model in which the boundary "
-                                            "velocity is derived from files containing data "
-                                            "in ascii format. Note the required format of the "
-                                            "input data: The first lines may contain any number of comments "
-                                            "if they begin with `#', but one of these lines needs to "
-                                            "contain the number of grid points in each dimension as "
-                                            "for example `# POINTS: 3 3'. "
-                                            "The order of the data columns "
-                                            "has to be `x', `velocity${}_x$', `velocity${}_y$' in a 2d model "
-                                            "or `x', `y', `velocity${}_x$', `velocity${}_y$', "
-                                            "`velocity${}_z$' in a 3d model. "
-                                            "Note that the data in the input "
-                                            "files need to be sorted in a specific order: "
-                                            "the first coordinate needs to ascend first, "
-                                            "followed by the second in order to "
-                                            "assign the correct data to the prescribed coordinates."
-                                            "If you use a spherical model, "
-                                            "then the assumed grid changes. `x' will be replaced by "
-                                            "the radial distance of the point to the bottom of the model, "
-                                            "`y' by the azimuth angle and `z' by the polar angle measured "
-                                            "positive from the north pole. The grid will be assumed to be "
-                                            "a latitude-longitude grid. Note that the order "
-                                            "of spherical coordinates is `r', `phi', `theta' "
-                                            "and not `r', `theta', `phi', since this allows "
-                                            "for dimension independent expressions. "
-                                            "Velocities can be specified using cartesian "
-                                            "(by default) or spherical unit vectors. "
-                                            "No matter which geometry model is chosen, "
-                                            "the unit of the velocities is assumed to be "
-                                            "m/s or m/yr depending on the `Use years in output "
-                                            "instead of seconds' flag. If you provide velocities "
-                                            "in cm/yr, set the `Scale factor' option to 0.01.")
-  }
-}
diff --git a/source/boundary_velocity/function.cc.bak b/source/boundary_velocity/function.cc.bak
deleted file mode 100644
index 201d814e28c..00000000000
--- a/source/boundary_velocity/function.cc.bak
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_velocity/function.h>
-#include <aspect/utilities.h>
-#include <aspect/global.h>
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    template <int dim>
-    Function<dim>::Function ()
-      :
-      boundary_velocity_function (dim)
-    {}
-
-
-
-    template <int dim>
-    Tensor<1,dim>
-    Function<dim>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<dim> &position) const
-    {
-      Tensor<1,dim> velocity;
-
-      const Utilities::NaturalCoordinate<dim> point =
-        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
-
-      for (unsigned int d=0; d<dim; ++d)
-        velocity[d] = boundary_velocity_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()), d);
-
-      if (use_spherical_unit_vectors)
-        velocity = Utilities::Coordinates::spherical_to_cartesian_vector(velocity, position);
-
-      // ASPECT always wants things in MKS system. however, as described
-      // in the documentation of this class, we interpret the formulas
-      // given to this plugin as meters per year if the global flag
-      // for using years instead of seconds is given. so if someone
-      // write "5" in their parameter file and sets the flag, then this
-      // means "5 meters/year" and we need to convert it to the ASPECT
-      // time system by dividing by the number of seconds per year
-      // to get MKS units
-      if (this->convert_output_to_years())
-        return velocity / year_in_seconds;
-      else
-        return velocity;
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::update()
-    {
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        boundary_velocity_function.set_time (this->get_time() / year_in_seconds);
-      else
-        boundary_velocity_function.set_time (this->get_time());
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary velocity model");
-      {
-        prm.enter_subsection("Function");
-        {
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle. `depth' "
-                             "will create a function, in which only the first "
-                             "parameter is non-zero, which is interpreted to "
-                             "be the depth of the point.");
-          prm.declare_entry ("Use spherical unit vectors", "false",
-                             Patterns::Bool (),
-                             "Specify velocity as $r$, $\\phi$, and $\\theta$ components "
-                             "instead of $x$, $y$, and $z$. Positive velocities point up, east, "
-                             "and north (in 3d) or out and clockwise (in 2d). "
-                             "This setting only makes sense for spherical geometries.");
-
-          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary velocity model");
-      {
-        prm.enter_subsection("Function");
-        {
-          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-          use_spherical_unit_vectors = prm.get_bool("Use spherical unit vectors");
-          if (use_spherical_unit_vectors)
-            AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
-                         ExcMessage ("Spherical unit vectors should not be used "
-                                     "when geometry model is not spherical."));
-        }
-        try
-          {
-            boundary_velocity_function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Boundary velocity model.Function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(Function,
-                                            "function",
-                                            "Implementation of a model in which the boundary "
-                                            "velocity is given in terms of an explicit formula "
-                                            "that is elaborated in the parameters in section "
-                                            "``Boundary velocity model|Function''. The format of these "
-                                            "functions follows the syntax understood by the "
-                                            "muparser library, see "
-                                            "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`."
-                                            "\n\n"
-                                            "The formula you describe in the mentioned "
-                                            "section is a semicolon separated list of velocities "
-                                            "for each of the $d$ components of the velocity vector. "
-                                            "These $d$ formulas are interpreted as having units "
-                                            "m/s, unless the global input parameter ``Use "
-                                            "years in output instead of seconds'' is set, in "
-                                            "which case we interpret the formula expressions "
-                                            "as having units m/year."
-                                            "\n\n"
-                                            "Likewise, since the symbol $t$ indicating time "
-                                            "may appear in the formulas for the prescribed "
-                                            "velocities, it is interpreted as having units "
-                                            "seconds unless the global parameter above has "
-                                            "been set.")
-  }
-}
diff --git a/source/boundary_velocity/gplates.cc.bak b/source/boundary_velocity/gplates.cc.bak
deleted file mode 100644
index a77b5d4f281..00000000000
--- a/source/boundary_velocity/gplates.cc.bak
+++ /dev/null
@@ -1,870 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_velocity/gplates.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/utilities.h>
-#include <deal.II/base/table.h>
-
-#include <boost/property_tree/xml_parser.hpp>
-#include <boost/property_tree/ptree.hpp>
-
-
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    namespace internal
-    {
-      template <int dim>
-      GPlatesLookup<dim>::GPlatesLookup(const Tensor<1,2> &surface_point_one,
-                                        const Tensor<1,2> &surface_point_two)
-      {
-        // get the Cartesian coordinates of the points the 2d model will lie in
-        // this computation is done also for 3d since it is not expensive and the
-        // template dim is currently not used here. Could be changed.
-        const Tensor<1,3> point_one = cartesian_surface_coordinates(convert_tensor<2,3>(surface_point_one));
-        const Tensor<1,3> point_two = cartesian_surface_coordinates(convert_tensor<2,3>(surface_point_two));
-
-        rotation_matrix = Utilities::compute_rotation_matrix_for_slice(point_one, point_two);
-      }
-
-
-
-      template <int dim>
-      std::string
-      GPlatesLookup<dim>::screen_output(const Tensor<1,2> &surface_point_one,
-                                        const Tensor<1,2> &surface_point_two) const
-      {
-        const Tensor<1,3> point_one = cartesian_surface_coordinates(convert_tensor<2,3>(surface_point_one));
-        const Tensor<1,3> point_two = cartesian_surface_coordinates(convert_tensor<2,3>(surface_point_two));
-
-        std::ostringstream output;
-
-        output << std::setprecision (3) << std::setw(3) << std::fixed << std::endl
-               << "   Setting up GPlates boundary velocity plugin."  << std::endl
-               << std::endl;
-        if (dim == 2)
-          {
-            Tensor<1,3> rotation_axis;
-            const double rotation_angle = rotation_axis_from_matrix(rotation_axis,rotation_matrix);
-
-            std::array<double,3> angles = angles_from_matrix(rotation_matrix);
-            std::array<double,3> back_angles = angles_from_matrix(transpose(rotation_matrix));
-
-            output << "   Input point 1 spherical coordinates: " << surface_point_one  << std::endl
-                   << "   Input point 1 normalized cartesian coordinates: " << point_one  << std::endl
-                   << "   Input point 1 rotated model coordinates: " << transpose(rotation_matrix) * point_one  << std::endl
-                   << "   Input point 2 spherical coordinates: " << surface_point_two  << std::endl
-                   << "   Input point 2 normalized cartesian coordinates: " << point_two  << std::endl
-                   << "   Input point 2 rotated model coordinates: " << transpose(rotation_matrix) * point_two << std::endl
-                   << std::endl <<  std::setprecision(2)
-                   << "   Model will be rotated by " << -rotation_angle *constants::radians_to_degree
-                   << " degrees around axis " << rotation_axis << std::endl
-                   << "   The ParaView rotation angles are: " << angles[0] << ' ' << angles [1] << ' ' << angles[2] << std::endl
-                   << "   The inverse ParaView rotation angles are: " << back_angles[0] << ' ' << back_angles [1] << ' ' << back_angles[2]
-
-                   << std::endl;
-          }
-
-        return output.str();
-      }
-
-
-
-      template <int dim>
-      void
-      GPlatesLookup<dim>::load_file(const std::string &filename,
-                                    const MPI_Comm comm)
-      {
-        // Read data from disk and distribute among processes
-        std::istringstream filecontent(
-          Utilities::read_and_distribute_file_content(filename, comm));
-
-        boost::property_tree::ptree pt;
-
-        // populate tree structure pt
-        read_xml(filecontent, pt);
-
-        const unsigned int n_points = pt.get_child("gpml:FeatureCollection.gml:featureMember.gpml:VelocityField.gml:domainSet.gml:MultiPoint").size();
-
-        // These formulas look magic, but they are the proper solution to the equation:
-        // n_points = n_theta * n_phi with n_phi = 2 * (n_theta - 1)
-        // From the XML information we only know n_points, but need n_theta
-        // and n_phi to properly size the arrays and get the grip point positions
-        const double dn_theta = 0.5 + std::sqrt(0.25 + n_points/2);
-        const unsigned int n_theta = static_cast<unsigned int> (dn_theta);
-        const unsigned int n_phi = static_cast<unsigned int> (2 * (dn_theta - 1));
-
-        AssertThrow(dn_theta - n_theta <= 1e-5,
-                    ExcMessage("The velocity file has a grid structure that is not readable. Please refer to the manual for a proper grid structure."));
-
-        delta_theta =   numbers::PI / (n_theta-1);
-        delta_phi   = 2*numbers::PI / n_phi;
-
-        /**
-         * Two tables (one for the theta and one for the phi component)
-         * which contain the velocities at every point.
-         * velocity_values[0] is the table for the theta component, whereas
-         * velocity_values[1] is the table for the phi component.
-         */
-        Table<2,double> velocity_values[2] = {Table<2,double>(n_theta,n_phi+1), Table<2,double>(n_theta,n_phi+1)};
-
-        std::string velos = pt.get<std::string>("gpml:FeatureCollection.gml:featureMember.gpml:VelocityField.gml:rangeSet.gml:DataBlock.gml:tupleList");
-        std::stringstream in(velos, std::ios::in);
-        AssertThrow (in,
-                     ExcMessage (std::string("Could not find velocities. Is file native gpml format for velocities?")));
-
-        // The lat-lon mesh has changed its starting longitude in gplates1.4
-        // correct for this while reading in the velocity data
-        unsigned int longitude_correction = 0;
-        if (gplates_1_4_or_higher(pt))
-          longitude_correction = n_phi/2;
-
-        unsigned int i = 0;
-        char sep;
-        Tensor<1,2> spherical_velocities;
-
-        while (in >> spherical_velocities[0] >> sep >> spherical_velocities[1])
-          {
-            const double cmyr_si = 0.01/year_in_seconds;
-
-            const unsigned int idx_theta = i / n_phi;
-            const unsigned int idx_phi = (i + longitude_correction) % n_phi;
-
-            velocity_values[0][idx_theta][idx_phi]= spherical_velocities[0] * cmyr_si;
-            velocity_values[1][idx_theta][idx_phi]= spherical_velocities[1] * cmyr_si;
-
-            ++i;
-          }
-
-        // Pad the longitude data with values for phi == 2*pi (== 0),
-        // this simplifies interpolation later.
-        for (unsigned int i=0; i<n_theta; ++i)
-          {
-            velocity_values[0][i][n_phi] = velocity_values[0][i][0];
-            velocity_values[1][i][n_phi] = velocity_values[1][i][0];
-          }
-
-        // number of intervals in the direction of theta and phi
-        std::array<unsigned int,2> table_intervals;
-        table_intervals[0] = n_theta - 1;
-        table_intervals[1] = n_phi;
-
-        // Min and Max coordinates in data file
-        std::array<std::pair<double,double>,2> grid_extent;
-
-        // min and max extent of the grid in the direction of theta and phi (whole spheres in GPlates)
-        // polar angle theta: from 0° to 180°(PI)
-        grid_extent[0].first = 0;
-        grid_extent[0].second = numbers::PI;
-        // azimuthal angle phi: from 0° to 360°(2*PI)
-        grid_extent[1].first = 0;
-        grid_extent[1].second = 2 * numbers::PI;
-
-        for (unsigned int i = 0; i < 2; ++i)
-          {
-            velocities[i]
-              = std::make_unique<Functions::InterpolatedUniformGridData<2>> (grid_extent,
-                                                                              table_intervals,
-                                                                              velocity_values[i]);
-          }
-
-        AssertThrow(i == n_points,
-                    ExcMessage (std::string("Number of read in points does not match number of points in file. File corrupted?")));
-      }
-
-
-
-      template <int dim>
-      Tensor<1,dim>
-      GPlatesLookup<dim>::surface_velocity(const Point<dim> &position) const
-      {
-        const Point<3> internal_position ((dim == 2)
-                                          ?
-                                          rotation_matrix * convert_tensor<dim,3>(position)
-                                          :
-                                          convert_tensor<dim,3>(position));
-
-        // transform internal_position in spherical coordinates
-        std::array<double,3> spherical_point =
-          Utilities::Coordinates::cartesian_to_spherical_coordinates(internal_position);
-
-        Tensor<1,dim> output_boundary_velocity;
-        // Handle all points that are not close to the poles
-        if ((spherical_point[2] >= delta_theta) && (spherical_point[2] <= numbers::PI - delta_theta))
-          {
-            output_boundary_velocity = cartesian_velocity_at_surface_point(spherical_point);
-          }
-
-        // The longitude of data points at the poles is set to zero (according to the internal
-        // GPlates routine). Because we interpolate velocities before converting them to the
-        // cartesian coordinate system, we need to evaluate them twice: First at the poles,
-        // and then at the latitude of the first data point that is not at the poles.
-        // Afterwards we average the two velocities to the real position.
-        else if (spherical_point[2] < delta_theta)
-          {
-            const double theta = spherical_point[2];
-            spherical_point[2] = delta_theta;
-            const Tensor<1,dim> first_velocity = cartesian_velocity_at_surface_point(spherical_point);
-
-            spherical_point[1] = 0.0;
-            spherical_point[2] = 0.0;
-            const Tensor<1,dim> polar_velocity = cartesian_velocity_at_surface_point(spherical_point);
-
-            output_boundary_velocity = (theta / delta_theta) * first_velocity
-                                       + (1.0 - theta / delta_theta) * polar_velocity;
-          }
-        else if (spherical_point[2] > numbers::PI - delta_theta)
-          {
-            const double theta = spherical_point[2];
-            spherical_point[2] = numbers::PI - delta_theta;
-            const Tensor<1,dim> first_velocity = cartesian_velocity_at_surface_point(spherical_point);
-
-            spherical_point[1] = 0.0;
-            spherical_point[2] = numbers::PI;
-            const Tensor<1,dim> polar_velocity = cartesian_velocity_at_surface_point(spherical_point);
-
-            output_boundary_velocity = ((numbers::PI - theta) / delta_theta) * first_velocity
-                                       + (1.0 - (numbers::PI - theta) / delta_theta) * polar_velocity;
-          }
-        else
-          Assert(false,ExcInternalError());
-
-        return output_boundary_velocity;
-      }
-
-
-
-      template <int dim>
-      Tensor<1,dim>
-      GPlatesLookup<dim>::cartesian_velocity_at_surface_point(const std::array<double,3> &spherical_point) const
-      {
-        // Re-sort the components of the spherical position from [r,phi,theta] to [theta, phi]
-        const Point<2> lookup_coordinates(spherical_point[2],spherical_point[1]);
-
-        // Main work, interpolate velocity at this point
-        Tensor<1,2> interpolated_velocity;
-
-        for (unsigned int i = 0; i < 2; ++i)
-          interpolated_velocity[i] = velocities[i]->value(lookup_coordinates);
-
-        // Transform interpolated_velocity in cartesian coordinates
-        const Tensor<1,3> interpolated_velocity_in_cart = sphere_to_cart_velocity(interpolated_velocity,spherical_point);
-
-        // Convert_tensor conveniently also handles the projection to the 2d plane by
-        // omitting the z-component of velocity (since the 2d model lies in the x-y plane).
-        const Tensor<1,dim> output_boundary_velocity = (dim == 2)
-                                                       ?
-                                                       convert_tensor<3,dim>(transpose(rotation_matrix) * interpolated_velocity_in_cart)
-                                                       :
-                                                       convert_tensor<3,dim>(interpolated_velocity_in_cart);
-
-        return output_boundary_velocity;
-      }
-
-
-
-      template <int dim>
-      Tensor<1,3>
-      GPlatesLookup<dim>::cartesian_surface_coordinates(const Tensor<1,3> &sposition) const
-      {
-        Tensor<1,3> ccoord;
-
-        ccoord[0] = std::sin(sposition[0]) * std::cos(sposition[1]); // X
-        ccoord[1] = std::sin(sposition[0]) * std::sin(sposition[1]); // Y
-        ccoord[2] = std::cos(sposition[0]); // Z
-        return ccoord;
-      }
-
-
-
-      template <int dim>
-      Tensor<1,3>
-      GPlatesLookup<dim>::sphere_to_cart_velocity(const Tensor<1,2> &s_velocities, const std::array<double,3> &s_position) const
-      {
-        Tensor<1,3> velocity;
-
-        velocity[0] = std::cos(s_position[2]) * std::cos(s_position[1]) * s_velocities[0]
-                      - 1.0 * std::sin(s_position[1]) * s_velocities[1];
-        velocity[1] = std::cos(s_position[2]) * std::sin(s_position[1]) * s_velocities[0]
-                      + std::cos(s_position[1]) * s_velocities[1];
-        velocity[2] = -1.0 * std::sin(s_position[2]) * s_velocities[0];
-
-        return velocity;
-      }
-
-
-
-      template <int dim>
-      double
-      GPlatesLookup<dim>::rotation_axis_from_matrix (Tensor<1,3> &rotation_axis,
-                                                     const Tensor<2,3> &rotation_matrix) const
-      {
-        double rotation_angle = std::acos(0.5 * (rotation_matrix[0][0] + rotation_matrix[1][1] + rotation_matrix[2][2] - 1));
-
-        if (rotation_angle > std::numeric_limits<double>::min())
-          {
-            rotation_axis[0] = (rotation_matrix[2][1] - rotation_matrix[1][2]) / (2*std::sin(rotation_angle));
-            rotation_axis[1] = (rotation_matrix[0][2] - rotation_matrix[2][0]) / (2*std::sin(rotation_angle));
-            rotation_axis[2] = (rotation_matrix[1][0] - rotation_matrix[0][1]) / (2*std::sin(rotation_angle));
-          }
-        else
-          {
-            rotation_axis[0] = 0.0;
-            rotation_axis[1] = 0.0;
-            rotation_axis[2] = 1.0;
-          }
-
-        return rotation_angle;
-      }
-
-
-
-      template <int dim>
-      std::array<double,3>
-      GPlatesLookup<dim>::angles_from_matrix(const Tensor<2,3> &rotation_matrix) const
-      {
-        std::array<double,3> orientation;
-
-        /*
-         * The following code is part of the VTK project and copied here for
-         * compatibility to the paraview rotation formalism. It is protected by
-         * the following license:
-         *
-         *
-         * Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
-         * All rights reserved.
-         *
-         * Redistribution and use in source and binary forms, with or without
-         * modification, are permitted under certain conditions. See
-         * http://www.kitware.com/Copyright.htm for details.
-
-         * This software is distributed WITHOUT ANY WARRANTY; without even
-         * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-         * PURPOSE.  See the above copyright notice for more information.
-         *
-         *
-         * The original code in the VTK-6.0.0 source folder is found in:
-         * /Common/Transforms/vtkTransform.cxx in the function GetOrientation()
-         *
-         */
-
-        // first rotate about y axis
-        const double x2 = rotation_matrix[2][0];
-        const double y2 = rotation_matrix[2][1];
-        const double z2 = rotation_matrix[2][2];
-
-        const double x3 = rotation_matrix[1][0];
-        const double y3 = rotation_matrix[1][1];
-        const double z3 = rotation_matrix[1][2];
-
-        double d1 = sqrt(x2*x2 + z2*z2);
-
-        double cosTheta, sinTheta;
-        if (d1 < std::numeric_limits<double>::min())
-          {
-            cosTheta = 1.0;
-            sinTheta = 0.0;
-          }
-        else
-          {
-            cosTheta = z2/d1;
-            sinTheta = x2/d1;
-          }
-
-        double theta = atan2(sinTheta, cosTheta);
-        orientation[1] = - theta * constants::radians_to_degree;
-
-        // now rotate about x axis
-        double d = sqrt(x2*x2 + y2*y2 + z2*z2);
-
-        double sinPhi, cosPhi;
-        if (d < std::numeric_limits<double>::min())
-          {
-            sinPhi = 0.0;
-            cosPhi = 1.0;
-          }
-        else if (d1 < std::numeric_limits<double>::min())
-          {
-            sinPhi = y2/d;
-            cosPhi = z2/d;
-          }
-        else
-          {
-            sinPhi = y2/d;
-            cosPhi = (x2*x2 + z2*z2)/(d1*d);
-          }
-
-        double phi = atan2(sinPhi, cosPhi);
-        orientation[0] = phi * constants::radians_to_degree;
-
-        // finally, rotate about z
-        double x3p = x3*cosTheta - z3*sinTheta;
-        double y3p = - sinPhi*sinTheta*x3 + cosPhi*y3 - sinPhi*cosTheta*z3;
-        double d2 = sqrt(x3p*x3p + y3p*y3p);
-
-        double cosAlpha, sinAlpha;
-        if (d2 < std::numeric_limits<double>::min())
-          {
-            cosAlpha = 1.0;
-            sinAlpha = 0.0;
-          }
-        else
-          {
-            cosAlpha = y3p/d2;
-            sinAlpha = x3p/d2;
-          }
-
-        double alpha = atan2(sinAlpha, cosAlpha);
-        orientation[2] = alpha * constants::radians_to_degree;
-        return orientation;
-      }
-
-
-
-      template <int dim>
-      template <int in, int out>
-      Tensor<1,out>
-      GPlatesLookup<dim>::convert_tensor (const Tensor<1,in> &old_tensor) const
-      {
-        Tensor<1,out> new_tensor;
-        for (unsigned int i = 0; i < out; ++i)
-          if (i < in) new_tensor[i] = old_tensor[i];
-          else new_tensor[i] = 0.0;
-
-        return new_tensor;
-      }
-
-
-
-      template <int dim>
-      bool
-      GPlatesLookup<dim>::gplates_1_4_or_higher(const boost::property_tree::ptree &pt) const
-      {
-        const std::string gpml_version = pt.get<std::string>("gpml:FeatureCollection.<xmlattr>.gpml:version");
-        const std::vector<std::string> string_versions = dealii::Utilities::split_string_list(gpml_version,'.');
-        const std::vector<int> int_versions = dealii::Utilities::string_to_int(string_versions);
-
-        const int gplates_1_3_version[3] = {1,6,322};
-
-        for (unsigned int i = 0; i < int_versions.size(); ++i)
-          {
-            if (int_versions[i] > gplates_1_3_version[i])
-              return true;
-            if (int_versions[i] < gplates_1_3_version[i])
-              return false;
-          }
-
-        return false;
-      }
-    }
-
-
-
-    template <int dim>
-    GPlates<dim>::GPlates ()
-      :
-      current_file_number(0),
-      first_data_file_model_time(0.0),
-      first_data_file_number(0),
-      decreasing_file_order(false),
-      data_file_time_step(0.0),
-      time_weight(0.0),
-      time_dependent(true),
-      point1("0.0,0.0"),
-      point2("0.0,0.0"),
-      lithosphere_thickness(0.0),
-      lookup(),
-      old_lookup()
-    {}
-
-
-
-    template <int dim>
-    void
-    GPlates<dim>::initialize ()
-    {
-      char sep;
-
-      std::stringstream streampoint(point1);
-      streampoint >> pointone[0] >> sep >> pointone[1];
-
-      std::stringstream streampoint2(point2);
-      streampoint2 >> pointtwo[0] >> sep >> pointtwo[1];
-
-      if (dim == 2)
-        Assert (pointone != pointtwo,
-                ExcMessage ("To define a plane for the 2d model the two assigned points "
-                            "may not be equal."));
-
-      AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
-                   ExcMessage ("This gplates plugin can only be used when the "
-                               "preferred coordinate system of the geometry model is spherical "
-                               "(e.g. spherical shell, chunk, sphere)."));
-
-      lookup = std::make_unique<internal::GPlatesLookup<dim>>(pointone, pointtwo);
-      old_lookup = std::make_unique<internal::GPlatesLookup<dim>>(pointone, pointtwo);
-
-      // display the GPlates module information at model start.
-      this->get_pcout() << lookup->screen_output(pointone, pointtwo);
-
-      // Set the first file number and load the first files
-      current_file_number = first_data_file_number;
-
-      const int next_file_number =
-        (decreasing_file_order)
-        ?
-        (current_file_number - 1)
-        :
-        (current_file_number + 1);
-
-      this->get_pcout() << std::endl << "   Loading GPlates data boundary file "
-                        << create_filename (current_file_number) << '.' << std::endl << std::endl;
-
-      const std::string filename (create_filename (current_file_number));
-      if (Utilities::fexists(filename, this->get_mpi_communicator()))
-        lookup->load_file(filename,this->get_mpi_communicator());
-      else
-        AssertThrow(false,
-                    ExcMessage (std::string("GPlates data file <")
-                                +
-                                filename
-                                +
-                                "> not found!"));
-
-      // If the boundary condition is constant, switch off time_dependence
-      // immediately. If not, also load the second file for interpolation.
-      // This catches the case that many files are present, but the
-      // parameter file requests a single file.
-      if (create_filename (current_file_number) == create_filename (current_file_number+1))
-        {
-          end_time_dependence ();
-        }
-      else
-        {
-          const std::string filename (create_filename (next_file_number));
-          this->get_pcout() << std::endl << "   Loading GPlates data boundary file "
-                            << filename << '.' << std::endl << std::endl;
-          if (Utilities::fexists(filename, this->get_mpi_communicator()))
-            {
-              lookup.swap(old_lookup);
-              lookup->load_file(filename,this->get_mpi_communicator());
-            }
-          else
-            end_time_dependence ();
-        }
-    }
-
-
-
-    template <int dim>
-    std::string
-    GPlates<dim>::create_filename (const int timestep) const
-    {
-      std::string templ = data_directory+velocity_file_name;
-      const int size = templ.length();
-      std::vector<char> buffer(size+10);
-      snprintf (buffer.data(), size + 10, templ.c_str(), timestep);
-      std::string str_filename (buffer.data());
-      return str_filename;
-    }
-
-
-
-    template <int dim>
-    void
-    GPlates<dim>::update ()
-    {
-      const double time_since_start = this->get_time() - first_data_file_model_time;
-
-      if (time_dependent && (time_since_start >= 0.0))
-        {
-          const int time_steps_since_start = static_cast<int> (time_since_start / data_file_time_step);
-
-          // whether we need to update our data files. This looks so complicated
-          // because we need to catch increasing and decreasing file orders and all
-          // possible first_data_file_model_times and first_data_file_numbers.
-          const bool need_update = time_steps_since_start
-                                   > std::abs(current_file_number - first_data_file_number);
-
-          if (need_update)
-            {
-              // The last file, which was tried to be loaded was
-              // number current_file_number +/- 1, because current_file_number
-              // is the file older than the current model time
-              const int old_file_number =
-                (decreasing_file_order)
-                ?
-                (current_file_number - 1)
-                :
-                (current_file_number + 1);
-
-              // Calculate new file_number
-              current_file_number =
-                (decreasing_file_order)
-                ?
-                (first_data_file_number - time_steps_since_start)
-                :
-                (first_data_file_number + time_steps_since_start);
-
-              const bool load_both_files = std::abs(current_file_number - old_file_number) >= 1;
-
-              update_data(load_both_files);
-            }
-
-          time_weight = (time_since_start / data_file_time_step)
-                        - std::abs(current_file_number - first_data_file_number);
-
-          Assert ((0 <= time_weight) && (time_weight <= 1),
-                  ExcMessage (
-                    "Error in set_current_time. Time_weight has to be in [0,1]"));
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    GPlates<dim>::update_data (const bool load_both_files)
-    {
-      // If the time step was large enough to move forward more
-      // then one data file we need to load both current files
-      // to stay accurate in interpolation
-      if (load_both_files)
-        {
-          const std::string filename (create_filename (current_file_number));
-          this->get_pcout() << std::endl << "   Loading GPlates data boundary file "
-                            << filename << '.' << std::endl << std::endl;
-          if (Utilities::fexists(filename, this->get_mpi_communicator()))
-            {
-              lookup.swap(old_lookup);
-              lookup->load_file(filename,this->get_mpi_communicator());
-            }
-
-          // If loading current_time_step failed, end time dependent part with old_file_number.
-          else
-            end_time_dependence ();
-        }
-
-      // Now load the next data file. This part is the main purpose of this function.
-      const int next_file_number =
-        (decreasing_file_order) ?
-        current_file_number - 1
-        :
-        current_file_number + 1;
-
-      const std::string filename (create_filename (next_file_number));
-      this->get_pcout() << std::endl << "   Loading GPlates data boundary file "
-                        << filename << '.' << std::endl << std::endl;
-      if (Utilities::fexists(filename, this->get_mpi_communicator()))
-        {
-          lookup.swap(old_lookup);
-          lookup->load_file(filename,this->get_mpi_communicator());
-        }
-
-      // If next file does not exist, end time dependent part with current_time_step.
-      else
-        end_time_dependence ();
-    }
-
-
-
-    template <int dim>
-    void
-    GPlates<dim>::end_time_dependence ()
-    {
-      // no longer consider the problem time dependent from here on out
-      // this cancels all attempts to read files at the next time steps
-      time_dependent = false;
-      // Give warning if first processor
-      this->get_pcout() << std::endl
-                        << "   Loading new gplates velocity file did not succeed." << std::endl
-                        << "   Assuming constant boundary conditions for rest of model run."
-                        << std::endl << std::endl;
-    }
-
-
-
-    template <int dim>
-    Tensor<1,dim>
-    GPlates<dim>::
-    boundary_velocity (const types::boundary_id /*boundary_indicator*/,
-                       const Point<dim> &position) const
-    {
-      // We compare the depth of the current point to the lithosphere thickness.
-      // The depth is calculated using squares, sums, square-roots and differences
-      // of large numbers, and we possibly end up with a very small number close to
-      // the surface, thus rounding errors can get quite large. We therefore
-      // compare the depth to lithosphere_thickness plus a magic number, which we
-      // choose as 1e-7 times the maximal model depth, because we safely assume no
-      // model will have more than 1e7 quadrature points in depth direction.
-      // Without the magic number it may unintentionally happen that the GPlates
-      // velocities are not prescribed at every point on the surface.
-      const double magic_number = 1e-7 * this->get_geometry_model().maximal_depth();
-
-      if ((this->get_time() - first_data_file_model_time >= 0.0) && (this->get_geometry_model().depth(position) <= lithosphere_thickness + magic_number))
-        {
-          const Tensor<1,dim> data = velocity_scaling_factor * lookup->surface_velocity(position);
-
-          if (!time_dependent)
-            return data;
-
-          const Tensor<1,dim> old_data = velocity_scaling_factor * old_lookup->surface_velocity(position);
-
-          return time_weight * data + (1 - time_weight) * old_data;
-        }
-      else
-        return Tensor<1,dim>();
-    }
-
-
-
-    template <int dim>
-    void
-    GPlates<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Boundary velocity model");
-      {
-        prm.enter_subsection ("GPlates model");
-        {
-          prm.declare_entry ("Data directory",
-                             "$ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/",
-                             Patterns::DirectoryName (),
-                             "The name of a directory that contains the model data. This path "
-                             "may either be absolute (if starting with a '/') or relative to "
-                             "the current directory. The path may also include the special "
-                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                             "in which the ASPECT source files were located when ASPECT was "
-                             "compiled. This interpretation allows, for example, to reference "
-                             "files located in the `data/' subdirectory of ASPECT. ");
-          prm.declare_entry ("Velocity file name", "phi.%d",
-                             Patterns::Anything (),
-                             "The file name of the material data. Provide file in format: "
-                             "(Velocity file name).\\%d.gpml where \\%d is any sprintf integer "
-                             "qualifier, specifying the format of the current file number.");
-          prm.declare_entry ("First data file model time", "0.",
-                             Patterns::Double (0.),
-                             "Time from which on the velocity file with number 'First velocity "
-                             "file number' is used as boundary condition. Previous to this "
-                             "time, a no-slip boundary condition is assumed. Depending on the setting "
-                             "of the global 'Use years in output instead of seconds' flag "
-                             "in the input file, this number is either interpreted as seconds or as years.");
-          prm.declare_entry ("First data file number", "0",
-                             Patterns::Integer (),
-                             "Number of the first velocity file to be loaded when the model time "
-                             "is larger than 'First velocity file model time'.");
-          prm.declare_entry ("Decreasing file order", "false",
-                             Patterns::Bool (),
-                             "In some cases the boundary files are not numbered in increasing "
-                             "but in decreasing order (e.g. 'Ma BP'). If this flag is set to "
-                             "'True' the plugin will first load the file with the number "
-                             "'First velocity file number' and decrease the file number during "
-                             "the model run.");
-          prm.declare_entry ("Data file time step", "1e6",
-                             Patterns::Double (0.),
-                             "Time step between following velocity files. "
-                             "Depending on the setting of the global 'Use years in output instead of seconds' flag "
-                             "in the input file, this number is either interpreted as seconds or as years. "
-                             "The default is one million, i.e., either one million seconds or one million years.");
-          prm.declare_entry ("Scale factor", "1.",
-                             Patterns::Double (),
-                             "Scalar factor, which is applied to the boundary velocity. "
-                             "You might want to use this to scale the velocities to a "
-                             "reference model (e.g. with free-slip boundary) or another "
-                             "plate reconstruction.");
-          prm.declare_entry ("Point one", "1.570796,0.0",
-                             Patterns::Anything (),
-                             "Point that determines the plane in which a 2d model lies in. Has to be in the format `a,b' where a and b are theta (polar angle) and "
-                             "phi in radians. This value is not utilized in 3d geometries, and can therefore be set to the default or any user-defined quantity.");
-          prm.declare_entry ("Point two", "1.570796,1.570796",
-                             Patterns::Anything (),
-                             "Point that determines the plane in which a 2d model lies in. Has to be in the format `a,b' where a and b are theta (polar angle) and "
-                             "phi in radians. This value is not utilized in 3d geometries, and can therefore be set to the default or any user-defined quantity.");
-          prm.declare_entry ("Lithosphere thickness", "100000.",
-                             Patterns::Double (0.),
-                             "Determines the depth of the lithosphere, so that the GPlates velocities can be applied at the sides of the model "
-                             "as well as at the surface.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    GPlates<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary velocity model");
-      {
-        prm.enter_subsection("GPlates model");
-        {
-          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-
-          velocity_file_name         = prm.get        ("Velocity file name");
-          data_file_time_step        = prm.get_double ("Data file time step");
-          first_data_file_model_time = prm.get_double ("First data file model time");
-          first_data_file_number     = prm.get_integer("First data file number");
-          decreasing_file_order      = prm.get_bool   ("Decreasing file order");
-          velocity_scaling_factor    = prm.get_double ("Scale factor");
-          point1                     = prm.get        ("Point one");
-          point2                     = prm.get        ("Point two");
-          lithosphere_thickness      = prm.get_double ("Lithosphere thickness");
-
-          if (this->convert_output_to_years())
-            {
-              data_file_time_step        *= year_in_seconds;
-              first_data_file_model_time *= year_in_seconds;
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    namespace internal
-    {
-#define INSTANTIATE(dim) \
-  template class GPlatesLookup<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(GPlates,
-                                            "gplates",
-                                            "Implementation of a model in which the boundary "
-                                            "velocity is derived from files that are generated "
-                                            "by the GPlates program.")
-  }
-}
diff --git a/source/boundary_velocity/interface.cc.bak b/source/boundary_velocity/interface.cc.bak
deleted file mode 100644
index 1c63df61c8f..00000000000
--- a/source/boundary_velocity/interface.cc.bak
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    // ------------------------------ Manager -----------------------------
-    // -------------------------------- Deal with registering boundary_velocity models and automating
-    // -------------------------------- their setup and selection at run time
-
-    template <int dim>
-    Manager<dim>::~Manager()
-      = default;
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::update ()
-    {
-      for (const auto &boundary : boundary_velocity_objects)
-        for (const auto &p : boundary.second)
-          p->update();
-    }
-
-
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_boundary_velocity (const std::string &name,
-                                              const std::string &description,
-                                              void (*declare_parameters_function) (ParameterHandler &),
-                                              std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-
-    template <int dim>
-    Tensor<1,dim>
-    Manager<dim>::boundary_velocity (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position) const
-    {
-      typename std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>>::const_iterator boundary_plugins =
-        boundary_velocity_objects.find(boundary_indicator);
-
-      Assert(boundary_plugins != boundary_velocity_objects.end(),
-             ExcMessage("The boundary velocity manager class was asked for the "
-                        "boundary velocity at a boundary that contains no active "
-                        "boundary velocity plugin."));
-
-      Tensor<1,dim> velocity = Tensor<1,dim>();
-
-      for (const auto &plugin : boundary_plugins->second)
-        velocity += plugin->boundary_velocity(boundary_indicator,
-                                              position);
-
-      return velocity;
-    }
-
-
-
-    template <int dim>
-    const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>> &
-    Manager<dim>::get_active_boundary_velocity_names () const
-    {
-      return boundary_velocity_indicators;
-    }
-
-
-
-    template <int dim>
-    const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>> &
-    Manager<dim>::get_active_boundary_velocity_conditions () const
-    {
-      return boundary_velocity_objects;
-    }
-
-
-
-    template <int dim>
-    const std::set<types::boundary_id> &
-    Manager<dim>::get_zero_boundary_velocity_indicators () const
-    {
-      return zero_velocity_boundary_indicators;
-    }
-
-
-
-    template <int dim>
-    const std::set<types::boundary_id> &
-    Manager<dim>::get_tangential_boundary_velocity_indicators () const
-    {
-      return tangential_velocity_boundary_indicators;
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Boundary velocity model");
-      {
-        prm.declare_entry ("Prescribed velocity boundary indicators", "",
-                           Patterns::Map (Patterns::Anything(),
-                                          Patterns::Selection(std::get<dim>(registered_plugins).get_pattern_of_names ())),
-                           "A comma separated list denoting those boundaries "
-                           "on which the velocity is prescribed, i.e., where unknown "
-                           "external forces act to prescribe a particular velocity. This is "
-                           "often used to prescribe a velocity that equals that of "
-                           "overlying plates."
-                           "\n\n"
-                           "The format of valid entries for this parameter is that of a map "
-                           "given as ``key1 [selector]: value1, key2 [selector]: value2, key3: value3, ...'' where "
-                           "each key must be a valid boundary indicator (which is either an "
-                           "integer or the symbolic name the geometry model in use may have "
-                           "provided for this part of the boundary) "
-                           "and each value must be one of the currently implemented boundary "
-                           "velocity models. ``selector'' is an optional string given as a subset "
-                           "of the letters `xyz' that allows you to apply the boundary conditions "
-                           "only to the components listed. As an example, '1 y: function' applies "
-                           "the type `function' to the y component on boundary 1. Without a selector "
-                           "it will affect all components of the velocity."
-                           "\n\n"
-                           "Note that the no-slip boundary condition is "
-                           "a special case of the current one where the prescribed velocity "
-                           "happens to be zero. It can thus be implemented by indicating that "
-                           "a particular boundary is part of the ones selected "
-                           "using the current parameter and using ``zero velocity'' as "
-                           "the boundary values. Alternatively, you can simply list the "
-                           "part of the boundary on which the velocity is to be zero with "
-                           "the parameter ``Zero velocity boundary indicator'' in the "
-                           "current parameter section."
-                           "\n\n"
-                           "Note that when ``Use years in output instead of seconds'' is set "
-                           "to true, velocity should be given in m/yr. "
-                           "The following boundary velocity models are available:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-        prm.declare_entry ("Zero velocity boundary indicators", "",
-                           Patterns::List (Patterns::Anything()),
-                           "A comma separated list of names denoting those boundaries "
-                           "on which the velocity is zero."
-                           "\n\n"
-                           "The names of the boundaries listed here can either by "
-                           "numbers (in which case they correspond to the numerical "
-                           "boundary indicators assigned by the geometry object), or they "
-                           "can correspond to any of the symbolic names the geometry object "
-                           "may have provided for each part of the boundary. You may want "
-                           "to compare this with the documentation of the geometry model you "
-                           "use in your model.");
-        prm.declare_entry ("Tangential velocity boundary indicators", "",
-                           Patterns::List (Patterns::Anything()),
-                           "A comma separated list of names denoting those boundaries "
-                           "on which the velocity is tangential and unrestrained, i.e., free-slip where "
-                           "no external forces act to prescribe a particular tangential "
-                           "velocity (although there is a force that requires the flow to "
-                           "be tangential)."
-                           "\n\n"
-                           "The names of the boundaries listed here can either by "
-                           "numbers (in which case they correspond to the numerical "
-                           "boundary indicators assigned by the geometry object), or they "
-                           "can correspond to any of the symbolic names the geometry object "
-                           "may have provided for each part of the boundary. You may want "
-                           "to compare this with the documentation of the geometry model you "
-                           "use in your model.");
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Boundary velocity model");
-      {
-        try
-          {
-            const std::vector<types::boundary_id> x_zero_velocity_boundary_indicators
-              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
-                                                                                    (prm.get ("Zero velocity boundary indicators")));
-            zero_velocity_boundary_indicators
-              = std::set<types::boundary_id> (x_zero_velocity_boundary_indicators.begin(),
-                                              x_zero_velocity_boundary_indicators.end());
-          }
-        catch (const std::string &error)
-          {
-            AssertThrow (false, ExcMessage ("While parsing the entry <Boundary velocity model/Zero velocity "
-                                            "boundary indicators>, there was an error. Specifically, "
-                                            "the conversion function complained as follows:\n\n"
-                                            + error));
-          }
-
-        try
-          {
-            const std::vector<types::boundary_id> x_tangential_velocity_boundary_indicators
-              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
-                                                                                    (prm.get ("Tangential velocity boundary indicators")));
-            tangential_velocity_boundary_indicators
-              = std::set<types::boundary_id> (x_tangential_velocity_boundary_indicators.begin(),
-                                              x_tangential_velocity_boundary_indicators.end());
-          }
-        catch (const std::string &error)
-          {
-            AssertThrow (false, ExcMessage ("While parsing the entry <Boundary velocity model/Tangential velocity "
-                                            "boundary indicators>, there was an error. Specifically, "
-                                            "the conversion function complained as follows:\n\n"
-                                            + error));
-          }
-
-        // find out which plugins are requested and the various other
-        // parameters we declare here
-        const std::vector<std::string> x_boundary_velocity_indicators
-          = Utilities::split_string_list(prm.get("Prescribed velocity boundary indicators"));
-
-        for (const auto &p : x_boundary_velocity_indicators)
-          {
-            // each entry has the format (white space is optional):
-            // <id> [x][y][z] : <value (might have spaces)>
-            //
-            // first tease apart the two halves
-            const std::vector<std::string> split_parts = Utilities::split_string_list (p, ':');
-            AssertThrow (split_parts.size() == 2,
-                         ExcMessage ("The format for prescribed velocity boundary indicators "
-                                     "requires that each entry has the form `"
-                                     "<id> [x][y][z] : <value>', but there does not "
-                                     "appear to be a colon in the entry <"
-                                     + p
-                                     + ">."));
-
-            // the easy part: get the value
-            const std::string &value = split_parts[1];
-
-            // now for the rest. since we don't know whether there is a
-            // component selector, start reading at the end and subtracting
-            // letters x, y and z
-            std::string key_and_comp = split_parts[0];
-            std::string comp;
-            while ((key_and_comp.size()>0) &&
-                   ((key_and_comp[key_and_comp.size()-1] == 'x')
-                    ||
-                    (key_and_comp[key_and_comp.size()-1] == 'y')
-                    ||
-                    ((key_and_comp[key_and_comp.size()-1] == 'z') && (dim==3))))
-              {
-                comp += key_and_comp[key_and_comp.size()-1];
-                key_and_comp.erase (--key_and_comp.end());
-              }
-
-            // we've stopped reading component selectors now. there are three
-            // possibilities:
-            // - no characters are left. this means that key_and_comp only
-            //   consisted of a single word that only consisted of 'x', 'y'
-            //   and 'z's. then this would have been a mistake to classify
-            //   as a component selector, and we better undo it
-            // - the last character of key_and_comp is not a whitespace. this
-            //   means that the last word in key_and_comp ended in an 'x', 'y'
-            //   or 'z', but this was not meant to be a component selector.
-            //   in that case, put these characters back.
-            // - otherwise, we split successfully. eat spaces that may be at
-            //   the end of key_and_comp to get key
-            if (key_and_comp.size() == 0)
-              key_and_comp.swap (comp);
-            else if (key_and_comp[key_and_comp.size()-1] != ' ')
-              {
-                key_and_comp += comp;
-                comp = "";
-              }
-            else
-              {
-                while ((key_and_comp.size()>0) && (key_and_comp[key_and_comp.size()-1] == ' '))
-                  key_and_comp.erase (--key_and_comp.end());
-              }
-
-            // finally, try to translate the key into a boundary_id. then
-            // make sure we haven't seen it yet
-            types::boundary_id boundary_id;
-            try
-              {
-                boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id(key_and_comp);
-              }
-            catch (const std::string &error)
-              {
-                AssertThrow (false, ExcMessage ("While parsing the entry <Boundary velocity model/Prescribed "
-                                                "velocity indicators>, there was an error. Specifically, "
-                                                "the conversion function complained as follows:\n\n"
-                                                + error));
-              }
-
-            if (boundary_velocity_indicators.find(boundary_id) != boundary_velocity_indicators.end())
-              {
-                Assert(boundary_velocity_indicators[boundary_id].first == comp,
-                       ExcMessage("Different velocity plugins for the same boundary have to have the same component selector. "
-                                  "This was not the case for boundary: " + key_and_comp +
-                                  ", for plugin: " + value + ", with component selector: " + comp));
-
-                // finally, put it into the list
-                boundary_velocity_indicators[boundary_id].second.push_back(value);
-              }
-            else
-              {
-                boundary_velocity_indicators[boundary_id] = std::make_pair(comp,std::vector<std::string>(1,value));
-              }
-          }
-      }
-      prm.leave_subsection();
-
-      // go through the list, create objects and let them parse
-      // their own parameters
-      for (const auto &boundary_id : boundary_velocity_indicators)
-        {
-          for (const auto &name : boundary_id.second.second)
-            {
-              boundary_velocity_objects[boundary_id.first].push_back(
-                std::unique_ptr<Interface<dim>> (std::get<dim>(registered_plugins)
-                                                  .create_plugin (name,
-                                                                  "Boundary velocity::Model names")));
-
-              if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(boundary_velocity_objects[boundary_id.first].back().get()))
-                sim->initialize_simulator (this->get_simulator());
-
-              boundary_velocity_objects[boundary_id.first].back()->parse_parameters (prm);
-              boundary_velocity_objects[boundary_id.first].back()->initialize ();
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Boundary velocity interface",
-                                                            out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryVelocity::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryVelocity::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<BoundaryVelocity::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<BoundaryVelocity::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace BoundaryVelocity
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/boundary_velocity/zero_velocity.cc.bak b/source/boundary_velocity/zero_velocity.cc.bak
deleted file mode 100644
index 23b58e8e952..00000000000
--- a/source/boundary_velocity/zero_velocity.cc.bak
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_velocity/zero_velocity.h>
-
-
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    template <int dim>
-    Tensor<1,dim>
-    ZeroVelocity<dim>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<dim> &) const
-    {
-      // return a zero tensor regardless of position
-      return Tensor<1,dim>();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryVelocity
-  {
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(ZeroVelocity,
-                                            "zero velocity",
-                                            "Implementation of a model in which the boundary "
-                                            "velocity is zero. This is commonly referred to as "
-                                            "a ``stick boundary condition'', indicating that "
-                                            "the material ``sticks'' to the material on the "
-                                            "other side of the boundary.")
-  }
-}
diff --git a/source/citation_info.cc.bak b/source/citation_info.cc.bak
deleted file mode 100644
index f047bab8f9a..00000000000
--- a/source/citation_info.cc.bak
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-  Copyright (C) 2017 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/citation_info.h>
-#include <aspect/revision.h>
-
-#include <iostream>
-#include <set>
-
-namespace CitationInfo
-{
-  std::set<std::string> citation_ids;
-
-  const std::string get_url_part ()
-  {
-    // version:
-    std::string url = "citing.html?ver=";
-    url += ASPECT_PACKAGE_VERSION;
-
-    // all ids:
-    for (const auto &id : citation_ids)
-      url += "&" + id + "=1";
-
-    // sha1:
-    url += "&sha=";
-    url += ASPECT_GIT_SHORTREV;
-
-    // src:
-    url += "&src=code";
-
-    return url;
-  }
-
-  void add (const std::string &id)
-  {
-    citation_ids.insert(id);
-  }
-}
diff --git a/source/compat.cc.bak b/source/compat.cc.bak
deleted file mode 100644
index bb71563d160..00000000000
--- a/source/compat.cc.bak
+++ /dev/null
@@ -1,800 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/compat.h>
-
-// deal.II versions up to 9.5 had a poorly designed interface of the
-// SphericalManifold class that made it impossible for us to use.
-// This file thus contains a copy of it.
-#if !DEAL_II_VERSION_GTE(9,6,0)
-
-namespace aspect
-{
-  namespace
-  {
-    template <int dim, int spacedim>
-    bool
-    spherical_face_is_horizontal(
-      const typename Triangulation<dim, spacedim>::face_iterator &face,
-      const Point<spacedim>                                      &manifold_center)
-    {
-      // We test whether a face is horizontal by checking that the vertices
-      // all have roughly the same distance from the center: If the
-      // maximum deviation for the distances from the vertices to the
-      // center is less than 1.e-5 of the distance between vertices (as
-      // measured by the minimum distance from any of the other vertices
-      // to the first vertex), then we call this a horizontal face.
-      constexpr unsigned int n_vertices =
-        GeometryInfo<spacedim>::vertices_per_face;
-      std::array<double, n_vertices>     sqr_distances_to_center;
-      std::array<double, n_vertices - 1> sqr_distances_to_first_vertex;
-      sqr_distances_to_center[0] =
-        (face->vertex(0) - manifold_center).norm_square();
-      for (unsigned int i = 1; i < n_vertices; ++i)
-        {
-          sqr_distances_to_center[i] =
-            (face->vertex(i) - manifold_center).norm_square();
-          sqr_distances_to_first_vertex[i - 1] =
-            (face->vertex(i) - face->vertex(0)).norm_square();
-        }
-      const auto minmax_sqr_distance =
-        std::minmax_element(sqr_distances_to_center.begin(),
-                            sqr_distances_to_center.end());
-      const auto min_sqr_distance_to_first_vertex =
-        std::min_element(sqr_distances_to_first_vertex.begin(),
-                         sqr_distances_to_first_vertex.end());
-
-      return (*minmax_sqr_distance.second - *minmax_sqr_distance.first <
-              1.e-10 * *min_sqr_distance_to_first_vertex);
-    }
-  } // namespace
-
-
-  // ============================================================
-  // SphericalManifold
-  // ============================================================
-
-  template <int dim, int spacedim>
-  SphericalManifold<dim, spacedim>::SphericalManifold(
-    const Point<spacedim> center)
-    : center(center)
-    , polar_manifold(center)
-  {}
-
-
-
-  template <int dim, int spacedim>
-  std::unique_ptr<Manifold<dim, spacedim>>
-  SphericalManifold<dim, spacedim>::clone() const
-  {
-    return std::make_unique<SphericalManifold<dim, spacedim>>(*this);
-  }
-
-
-
-  template <int dim, int spacedim>
-  Point<spacedim>
-  SphericalManifold<dim, spacedim>::get_intermediate_point(
-    const Point<spacedim> &p1,
-    const Point<spacedim> &p2,
-    const double           w) const
-  {
-    const double tol = 1e-10;
-
-    if ((p1 - p2).norm_square() < tol * tol || std::abs(w) < tol)
-      return p1;
-    else if (std::abs(w - 1.0) < tol)
-      return p2;
-
-    // If the points are one dimensional then there is no need for anything but
-    // a linear combination.
-    if (spacedim == 1)
-      return Point<spacedim>(w * p2 + (1 - w) * p1);
-
-    const Tensor<1, spacedim> v1 = p1 - center;
-    const Tensor<1, spacedim> v2 = p2 - center;
-    const double              r1 = v1.norm();
-    const double              r2 = v2.norm();
-
-    Assert(r1 > tol && r2 > tol,
-           ExcMessage("p1 and p2 cannot coincide with the center."));
-
-    const Tensor<1, spacedim> e1 = v1 / r1;
-    const Tensor<1, spacedim> e2 = v2 / r2;
-
-    // Find the cosine of the angle gamma described by v1 and v2.
-    const double cosgamma = e1 * e2;
-
-    // Points are collinear with the center (allow for 8*eps as a tolerance)
-    if (cosgamma < -1 + 8. * std::numeric_limits<double>::epsilon())
-      return center;
-
-    // Points are along a line, in which case e1 and e2 are essentially the same.
-    if (cosgamma > 1 - 8. * std::numeric_limits<double>::epsilon())
-      return Point<spacedim>(center + w * v2 + (1 - w) * v1);
-
-    // Find the angle sigma that corresponds to arclength equal to w. acos
-    // should never be undefined because we have ruled out the two special cases
-    // above.
-    const double sigma = w * std::acos(cosgamma);
-
-    // Normal to v1 in the plane described by v1,v2,and the origin.
-    // Since p1 and p2 do not coincide n is not zero and well defined.
-    Tensor<1, spacedim> n      = v2 - (v2 * e1) * e1;
-    const double        n_norm = n.norm();
-    Assert(n_norm > 0,
-           ExcInternalError("n should be different from the null vector. "
-                            "Probably, this means v1==v2 or v2==0."));
-
-    n /= n_norm;
-
-    // Find the point Q along O,v1 such that
-    // P1,V,P2 has measure sigma.
-    const Tensor<1, spacedim> P = std::cos(sigma) * e1 + std::sin(sigma) * n;
-
-    // Project this point on the manifold.
-    return Point<spacedim>(center + (w * r2 + (1.0 - w) * r1) * P);
-  }
-
-
-
-  template <int dim, int spacedim>
-  Tensor<1, spacedim>
-  SphericalManifold<dim, spacedim>::get_tangent_vector(
-    const Point<spacedim> &p1,
-    const Point<spacedim> &p2) const
-  {
-    const double tol = 1e-10;
-    (void)tol;
-
-    Assert(p1 != p2, ExcMessage("p1 and p2 should not concide."));
-
-    const Tensor<1, spacedim> v1 = p1 - center;
-    const Tensor<1, spacedim> v2 = p2 - center;
-    const double              r1 = v1.norm();
-    const double              r2 = v2.norm();
-
-    Assert(r1 > tol, ExcMessage("p1 cannot coincide with the center."));
-
-    Assert(r2 > tol, ExcMessage("p2 cannot coincide with the center."));
-
-    const Tensor<1, spacedim> e1 = v1 / r1;
-    const Tensor<1, spacedim> e2 = v2 / r2;
-
-    // Find the cosine of the angle gamma described by v1 and v2.
-    const double cosgamma = e1 * e2;
-
-    Assert(cosgamma > -1 + 8. * std::numeric_limits<double>::epsilon(),
-           ExcMessage("p1 and p2 cannot lie on the same diameter and be opposite "
-                      "respect to the center."));
-
-    if (cosgamma > 1 - 8. * std::numeric_limits<double>::epsilon())
-      return v2 - v1;
-
-    // Normal to v1 in the plane described by v1,v2,and the origin.
-    // Since p1 and p2 do not coincide n is not zero and well defined.
-    Tensor<1, spacedim> n      = v2 - (v2 * e1) * e1;
-    const double        n_norm = n.norm();
-    Assert(n_norm > 0,
-           ExcInternalError("n should be different from the null vector. "
-                            "Probably, this means v1==v2 or v2==0."));
-
-    n /= n_norm;
-
-    // this is the derivative of the geodesic in get_intermediate_point
-    // derived with respect to w and inserting w=0.
-    const double gamma = std::acos(cosgamma);
-    return (r2 - r1) * e1 + r1 * gamma * n;
-  }
-
-
-
-  template <int dim, int spacedim>
-  Tensor<1, spacedim>
-  SphericalManifold<dim, spacedim>::normal_vector(
-    const typename Triangulation<dim, spacedim>::face_iterator &face,
-    const Point<spacedim>                                      &p) const
-  {
-    // Let us first test whether we are on a "horizontal" face
-    // (tangential to the sphere).  In this case, the normal vector is
-    // easy to compute since it is proportional to the vector from the
-    // center to the point 'p'.
-    if (spherical_face_is_horizontal<dim, spacedim>(face, center))
-      {
-        // So, if this is a "horizontal" face, then just compute the normal
-        // vector as the one from the center to the point 'p', adequately
-        // scaled.
-        const Tensor<1, spacedim> unnormalized_spherical_normal = p - center;
-        const Tensor<1, spacedim> normalized_spherical_normal =
-          unnormalized_spherical_normal / unnormalized_spherical_normal.norm();
-        return normalized_spherical_normal;
-      }
-    else
-      // If it is not a horizontal face, just use the machinery of the
-      // base class.
-      return Manifold<dim, spacedim>::normal_vector(face, p);
-
-    return Tensor<1, spacedim>();
-  }
-
-
-
-  template <>
-  void
-  SphericalManifold<1, 1>::get_normals_at_vertices(
-    const Triangulation<1>::face_iterator &,
-    Manifold<1, 1>::FaceVertexNormals &) const
-  {
-    Assert(false, ExcImpossibleInDim(1));
-  }
-
-
-
-  template <>
-  void
-  SphericalManifold<1, 2>::get_normals_at_vertices(
-    const Triangulation<1, 2>::face_iterator &,
-    Manifold<1, 2>::FaceVertexNormals &) const
-  {
-    Assert(false, ExcImpossibleInDim(1));
-  }
-
-
-
-  template <int dim, int spacedim>
-  void
-  SphericalManifold<dim, spacedim>::get_normals_at_vertices(
-    const typename Triangulation<dim, spacedim>::face_iterator &face,
-    typename Manifold<dim, spacedim>::FaceVertexNormals &face_vertex_normals)
-  const
-  {
-    // Let us first test whether we are on a "horizontal" face
-    // (tangential to the sphere).  In this case, the normal vector is
-    // easy to compute since it is proportional to the vector from the
-    // center to the point 'p'.
-    if (spherical_face_is_horizontal<dim, spacedim>(face, center))
-      {
-        // So, if this is a "horizontal" face, then just compute the normal
-        // vector as the one from the center to the point 'p', adequately
-        // scaled.
-        for (unsigned int vertex = 0;
-             vertex < GeometryInfo<spacedim>::vertices_per_face;
-             ++vertex)
-          face_vertex_normals[vertex] = face->vertex(vertex) - center;
-      }
-    else
-      Manifold<dim, spacedim>::get_normals_at_vertices(face, face_vertex_normals);
-  }
-
-
-
-  template <int dim, int spacedim>
-  void
-  SphericalManifold<dim, spacedim>::get_new_points(
-    const ArrayView<const Point<spacedim>> &surrounding_points,
-    const Table<2, double>                 &weights,
-    ArrayView<Point<spacedim>>              new_points) const
-  {
-    AssertDimension(new_points.size(), weights.size(0));
-    AssertDimension(surrounding_points.size(), weights.size(1));
-
-    do_get_new_points(surrounding_points, make_array_view(weights), new_points);
-
-    return;
-  }
-
-
-
-  template <int dim, int spacedim>
-  Point<spacedim>
-  SphericalManifold<dim, spacedim>::get_new_point(
-    const ArrayView<const Point<spacedim>> &vertices,
-    const ArrayView<const double>          &weights) const
-  {
-    // To avoid duplicating all of the logic in get_new_points, simply call it
-    // for one position.
-    Point<spacedim> new_point;
-    do_get_new_points(vertices,
-                      weights,
-                      make_array_view(&new_point, &new_point + 1));
-
-    return new_point;
-  }
-
-
-
-  namespace internal
-  {
-    // Rotate a given unit vector u around the axis dir
-    // where the angle is given by the length of dir.
-    // This is the exponential map for a sphere.
-    Tensor<1, 3>
-    apply_exponential_map(const Tensor<1, 3> &u, const Tensor<1, 3> &dir)
-    {
-      const double theta = dir.norm();
-      if (theta < 1.e-10)
-        {
-          return u;
-        }
-      else
-        {
-          const Tensor<1, 3> dirUnit = dir / theta;
-          const Tensor<1, 3> tmp =
-            std::cos(theta) * u + std::sin(theta) * dirUnit;
-          return tmp / tmp.norm();
-        }
-    }
-
-
-    // Returns the direction to go from v to u
-    // projected to the plane perpendicular to the unit vector v.
-    // This one is more stable when u and v are nearly equal.
-    Tensor<1, 3>
-    projected_direction(const Tensor<1, 3> &u, const Tensor<1, 3> &v)
-    {
-      Tensor<1, 3> ans = u - v;
-      ans -= (ans * v) * v;
-      return ans; // ans = (u-v) - ((u-v)*v)*v
-    }
-
-
-    // helper function to compute a vector orthogonal to a given one.
-    // does nothing unless spacedim == 3.
-    template <int spacedim>
-    Point<spacedim>
-    compute_normal(const Tensor<1, spacedim> & /*vector*/,
-                   bool /*normalize*/ = false)
-    {
-      return {};
-    }
-
-    Point<3>
-    compute_normal(const Tensor<1, 3> &vector, bool normalize = false)
-    {
-      Assert(vector.norm_square() != 0.,
-             ExcMessage("The direction parameter must not be zero!"));
-      Point<3> normal;
-      if (std::abs(vector[0]) >= std::abs(vector[1]) &&
-          std::abs(vector[0]) >= std::abs(vector[2]))
-        {
-          normal[1] = -1.;
-          normal[2] = -1.;
-          normal[0] = (vector[1] + vector[2]) / vector[0];
-        }
-      else if (std::abs(vector[1]) >= std::abs(vector[0]) &&
-               std::abs(vector[1]) >= std::abs(vector[2]))
-        {
-          normal[0] = -1.;
-          normal[2] = -1.;
-          normal[1] = (vector[0] + vector[2]) / vector[1];
-        }
-      else
-        {
-          normal[0] = -1.;
-          normal[1] = -1.;
-          normal[2] = (vector[0] + vector[1]) / vector[2];
-        }
-      if (normalize)
-        normal /= normal.norm();
-      return normal;
-    }
-
-
-    namespace SphericalManifold
-    {
-      namespace
-      {
-        template <int spacedim>
-        Point<spacedim>
-        do_get_new_point(
-          const ArrayView<const Tensor<1, spacedim>> & /*directions*/,
-          const ArrayView<const double> & /*distances*/,
-          const ArrayView<const double> & /*weights*/,
-          const Point<spacedim> & /*candidate_point*/)
-        {
-          Assert(false, ExcNotImplemented());
-          return {};
-        }
-
-        template <>
-        Point<3>
-        do_get_new_point(const ArrayView<const Tensor<1, 3>> &directions,
-                         const ArrayView<const double>       &distances,
-                         const ArrayView<const double>       &weights,
-                         const Point<3>                      &candidate_point)
-        {
-          (void)distances;
-
-          AssertDimension(directions.size(), distances.size());
-          AssertDimension(directions.size(), weights.size());
-
-          Point<3>           candidate       = candidate_point;
-          const unsigned int n_merged_points = directions.size();
-          const double       tolerance       = 1e-10;
-          const int          max_iterations  = 10;
-
-          {
-            // If the candidate happens to coincide with a normalized
-            // direction, we return it. Otherwise, the Hessian would be singular.
-            for (unsigned int i = 0; i < n_merged_points; ++i)
-              {
-                const double squared_distance =
-                  (candidate - directions[i]).norm_square();
-                if (squared_distance < tolerance * tolerance)
-                  return candidate;
-              }
-
-            // check if we only have two points now, in which case we can use the
-            // get_intermediate_point function
-            if (n_merged_points == 2)
-              {
-                static const dealii::SphericalManifold<3, 3> unit_manifold;
-                Assert(std::abs(weights[0] + weights[1] - 1.0) < 1e-13,
-                       ExcMessage("Weights do not sum up to 1"));
-                const Point<3> intermediate =
-                  unit_manifold.get_intermediate_point(Point<3>(directions[0]),
-                                                       Point<3>(directions[1]),
-                                                       weights[1]);
-                return intermediate;
-              }
-
-            Tensor<1, 3> vPerp;
-            Tensor<2, 2> Hessian;
-            Tensor<1, 2> gradient;
-            Tensor<1, 2> gradlocal;
-
-            // On success we exit the loop early.
-            // Otherwise, we just take the result after max_iterations steps.
-            for (unsigned int i = 0; i < max_iterations; ++i)
-              {
-                // Step 2a: Find new descent direction
-
-                // Get local basis for the estimate candidate
-                const Tensor<1, 3> Clocalx = internal::compute_normal(candidate);
-                const Tensor<1, 3> Clocaly = cross_product_3d(candidate, Clocalx);
-
-                // For each vertices vector, compute the tangent vector from
-                // candidate towards the vertices vector -- its length is the
-                // spherical length from candidate to the vertices vector. Then
-                // compute its contribution to the Hessian.
-                gradient = 0.;
-                Hessian  = 0.;
-                for (unsigned int i = 0; i < n_merged_points; ++i)
-                  if (std::abs(weights[i]) > 1.e-15)
-                    {
-                      vPerp =
-                        internal::projected_direction(directions[i], candidate);
-                      const double sinthetaSq = vPerp.norm_square();
-                      const double sintheta   = std::sqrt(sinthetaSq);
-                      if (sintheta < tolerance)
-                        {
-                          Hessian[0][0] += weights[i];
-                          Hessian[1][1] += weights[i];
-                        }
-                      else
-                        {
-                          const double costheta = (directions[i]) * candidate;
-                          const double theta    = std::atan2(sintheta, costheta);
-                          const double sincthetaInv = theta / sintheta;
-
-                          const double cosphi = vPerp * Clocalx;
-                          const double sinphi = vPerp * Clocaly;
-
-                          gradlocal[0] = cosphi;
-                          gradlocal[1] = sinphi;
-                          gradient += (weights[i] * sincthetaInv) * gradlocal;
-
-                          const double wt       = weights[i] / sinthetaSq;
-                          const double sinphiSq = sinphi * sinphi;
-                          const double cosphiSq = cosphi * cosphi;
-                          const double tt       = sincthetaInv * costheta;
-                          const double offdiag =
-                            cosphi * sinphi * wt * (1.0 - tt);
-                          Hessian[0][0] += wt * (cosphiSq + tt * sinphiSq);
-                          Hessian[0][1] += offdiag;
-                          Hessian[1][0] += offdiag;
-                          Hessian[1][1] += wt * (sinphiSq + tt * cosphiSq);
-                        }
-                    }
-
-                Assert(determinant(Hessian) > tolerance, ExcInternalError());
-
-                const Tensor<2, 2> inverse_Hessian = invert(Hessian);
-
-                const Tensor<1, 2> xDisplocal = inverse_Hessian * gradient;
-                const Tensor<1, 3> xDisp =
-                  xDisplocal[0] * Clocalx + xDisplocal[1] * Clocaly;
-
-                // Step 2b: rotate candidate in direction xDisp for a new
-                // candidate.
-                const Point<3> candidateOld = candidate;
-                candidate =
-                  Point<3>(internal::apply_exponential_map(candidate, xDisp));
-
-                // Step 2c: return the new candidate if we didn't move
-                if ((candidate - candidateOld).norm_square() <
-                    tolerance * tolerance)
-                  break;
-              }
-          }
-          return candidate;
-        }
-      } // namespace
-    }   // namespace SphericalManifold
-  } // namespace internal
-
-
-
-  template <int dim, int spacedim>
-  void
-  SphericalManifold<dim, spacedim>::do_get_new_points(
-    const ArrayView<const Point<spacedim>> &surrounding_points,
-    const ArrayView<const double>          &weights,
-    ArrayView<Point<spacedim>>              new_points) const
-  {
-    AssertDimension(weights.size(),
-                    new_points.size() * surrounding_points.size());
-    const unsigned int weight_rows    = new_points.size();
-    const unsigned int weight_columns = surrounding_points.size();
-
-    if (surrounding_points.size() == 2)
-      {
-        for (unsigned int row = 0; row < weight_rows; ++row)
-          new_points[row] =
-            SphericalManifold<dim, spacedim>::get_intermediate_point(surrounding_points[0],
-                                                                     surrounding_points[1],
-                                                                     weights[row * weight_columns + 1]);
-        return;
-      }
-
-    boost::container::small_vector<std::pair<double, Tensor<1, spacedim>>, 100>
-    new_candidates(new_points.size());
-    boost::container::small_vector<Tensor<1, spacedim>, 100> directions(
-      surrounding_points.size(), Point<spacedim>());
-    boost::container::small_vector<double, 100> distances(
-      surrounding_points.size(), 0.0);
-    double max_distance = 0.;
-    for (unsigned int i = 0; i < surrounding_points.size(); ++i)
-      {
-        directions[i] = surrounding_points[i] - center;
-        distances[i]  = directions[i].norm();
-
-        if (distances[i] != 0.)
-          directions[i] /= distances[i];
-        else
-          Assert(false,
-                 ExcMessage("One of the vertices coincides with the center. "
-                            "This is not allowed!"));
-
-        // Check if an estimate is good enough,
-        // this is often the case for sufficiently refined meshes.
-        for (unsigned int k = 0; k < i; ++k)
-          {
-            const double squared_distance =
-              (directions[i] - directions[k]).norm_square();
-            max_distance = std::max(max_distance, squared_distance);
-          }
-      }
-
-    // Step 1: Check for some special cases, create simple linear guesses
-    // otherwise.
-    const double                              tolerance = 1e-10;
-    boost::container::small_vector<bool, 100> accurate_point_was_found(
-      new_points.size(), false);
-    const ArrayView<const Tensor<1, spacedim>> array_directions =
-      make_array_view(directions.begin(), directions.end());
-    const ArrayView<const double> array_distances =
-      make_array_view(distances.begin(), distances.end());
-    for (unsigned int row = 0; row < weight_rows; ++row)
-      {
-        new_candidates[row] =
-          guess_new_point(array_directions,
-                          array_distances,
-                          ArrayView<const double>(&weights[row * weight_columns],
-                                                  weight_columns));
-
-        // If the candidate is the center, mark it as found to avoid entering
-        // the Newton iteration in step 2, which would crash.
-        if (new_candidates[row].first == 0.0)
-          {
-            new_points[row]               = center;
-            accurate_point_was_found[row] = true;
-            continue;
-          }
-
-        // If not in 3d, just use the implementation from PolarManifold
-        // after we verified that the candidate is not the center.
-        if (spacedim < 3)
-          new_points[row] = polar_manifold.get_new_point(
-                              surrounding_points,
-                              ArrayView<const double>(&weights[row * weight_columns],
-                                                      weight_columns));
-      }
-
-    // In this case, we treated the case that the candidate is the center and
-    // obtained the new locations from the PolarManifold object otherwise.
-    if (spacedim < 3)
-      return;
-    else
-      {
-        // If all the points are close to each other, we expect the estimate to
-        // be good enough. This tolerance was chosen such that the first iteration
-        // for a at least three time refined HyperShell mesh with radii .5 and 1.
-        // doesn't already succeed.
-        if (max_distance < 2e-2)
-          {
-            for (unsigned int row = 0; row < weight_rows; ++row)
-              new_points[row] =
-                center + new_candidates[row].first * new_candidates[row].second;
-
-            return;
-          }
-
-        // Step 2:
-        // Do more expensive Newton-style iterations to improve the estimate.
-
-        // Search for duplicate directions and merge them to minimize the cost of
-        // the get_new_point function call below.
-        boost::container::small_vector<double, 1000> merged_weights(
-          weights.size());
-        boost::container::small_vector<Tensor<1, spacedim>, 100>
-        merged_directions(surrounding_points.size(), Point<spacedim>());
-        boost::container::small_vector<double, 100> merged_distances(
-          surrounding_points.size(), 0.0);
-
-        unsigned int n_unique_directions = 0;
-        for (unsigned int i = 0; i < surrounding_points.size(); ++i)
-          {
-            bool found_duplicate = false;
-
-            // This inner loop is of $O(N^2)$ complexity, but
-            // surrounding_points.size() is usually at most 8 points large.
-            for (unsigned int j = 0; j < n_unique_directions; ++j)
-              {
-                const double squared_distance =
-                  (directions[i] - directions[j]).norm_square();
-                if (!found_duplicate && squared_distance < 1e-28)
-                  {
-                    found_duplicate = true;
-                    for (unsigned int row = 0; row < weight_rows; ++row)
-                      merged_weights[row * weight_columns + j] +=
-                        weights[row * weight_columns + i];
-                  }
-              }
-
-            if (found_duplicate == false)
-              {
-                merged_directions[n_unique_directions] = directions[i];
-                merged_distances[n_unique_directions]  = distances[i];
-                for (unsigned int row = 0; row < weight_rows; ++row)
-                  merged_weights[row * weight_columns + n_unique_directions] =
-                    weights[row * weight_columns + i];
-
-                ++n_unique_directions;
-              }
-          }
-
-        // Search for duplicate weight rows and merge them to minimize the cost of
-        // the get_new_point function call below.
-        boost::container::small_vector<unsigned int, 100> merged_weights_index(
-          new_points.size(), numbers::invalid_unsigned_int);
-        for (unsigned int row = 0; row < weight_rows; ++row)
-          {
-            for (unsigned int existing_row = 0; existing_row < row;
-                 ++existing_row)
-              {
-                bool identical_weights = true;
-
-                for (unsigned int weight_index = 0;
-                     weight_index < n_unique_directions;
-                     ++weight_index)
-                  if (std::abs(
-                        merged_weights[row * weight_columns + weight_index] -
-                        merged_weights[existing_row * weight_columns +
-                                       weight_index]) > tolerance)
-                    {
-                      identical_weights = false;
-                      break;
-                    }
-
-                if (identical_weights)
-                  {
-                    merged_weights_index[row] = existing_row;
-                    break;
-                  }
-              }
-          }
-
-        // Note that we only use the n_unique_directions first entries in the
-        // ArrayView
-        const ArrayView<const Tensor<1, spacedim>> array_merged_directions =
-          make_array_view(merged_directions.begin(),
-                          merged_directions.begin() + n_unique_directions);
-        const ArrayView<const double> array_merged_distances =
-          make_array_view(merged_distances.begin(),
-                          merged_distances.begin() + n_unique_directions);
-
-        for (unsigned int row = 0; row < weight_rows; ++row)
-          if (!accurate_point_was_found[row])
-            {
-              if (merged_weights_index[row] == numbers::invalid_unsigned_int)
-                {
-                  const ArrayView<const double> array_merged_weights(
-                    &merged_weights[row * weight_columns], n_unique_directions);
-                  new_candidates[row].second =
-                    internal::SphericalManifold::do_get_new_point(
-                      array_merged_directions,
-                      array_merged_distances,
-                      array_merged_weights,
-                      Point<spacedim>(new_candidates[row].second));
-                }
-              else
-                new_candidates[row].second =
-                  new_candidates[merged_weights_index[row]].second;
-
-              new_points[row] =
-                center + new_candidates[row].first * new_candidates[row].second;
-            }
-      }
-  }
-
-
-
-  template <int dim, int spacedim>
-  std::pair<double, Tensor<1, spacedim>>
-  SphericalManifold<dim, spacedim>::guess_new_point(
-    const ArrayView<const Tensor<1, spacedim>> &directions,
-    const ArrayView<const double>              &distances,
-    const ArrayView<const double>              &weights) const
-  {
-    const double        tolerance = 1e-10;
-    double              rho       = 0.;
-    Tensor<1, spacedim> candidate;
-
-    // Perform a simple average ...
-    double total_weights = 0.;
-    for (unsigned int i = 0; i < directions.size(); ++i)
-      {
-        // if one weight is one, return its direction
-        if (std::abs(1 - weights[i]) < tolerance)
-          return std::make_pair(distances[i], directions[i]);
-
-        rho += distances[i] * weights[i];
-        candidate += directions[i] * weights[i];
-        total_weights += weights[i];
-      }
-
-    // ... and normalize if the candidate is different from the origin.
-    const double norm = candidate.norm();
-    if (norm == 0.)
-      return std::make_pair(0.0, Point<spacedim>());
-    candidate /= norm;
-    rho /= total_weights;
-
-    return std::make_pair(rho, candidate);
-  }
-
-
-  template class SphericalManifold<2>;
-  template class SphericalManifold<3>;
-}
-
-#endif
diff --git a/source/fe_variable_collection.cc.bak b/source/fe_variable_collection.cc.bak
deleted file mode 100644
index ef8b9030d77..00000000000
--- a/source/fe_variable_collection.cc.bak
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/global.h>
-#include <aspect/fe_variable_collection.h>
-
-namespace aspect
-{
-
-
-
-  template <int dim>
-  VariableDeclaration<dim>::VariableDeclaration(const std::string &name,
-                                                const std::shared_ptr<FiniteElement<dim>> &fe,
-                                                const unsigned int multiplicity,
-                                                const unsigned int n_blocks)
-    : name(name),
-      fe(fe),
-      multiplicity(multiplicity),
-      n_blocks(n_blocks)
-  {
-    // TODO: non-scalar FEs are not tested and can not be split into >1 block in general
-    Assert(fe->n_components() == 1, ExcNotImplemented());
-
-    Assert(n_blocks == 0
-           || n_blocks == 1
-           || n_blocks == n_components(),
-           ExcMessage("A Variable can only have 0, 1, or n_components() number of blocks."));
-  }
-
-  template <int dim>
-  VariableDeclaration<dim>::VariableDeclaration()
-    = default;
-
-  template <int dim>
-  unsigned int
-  VariableDeclaration<dim>::n_components() const
-  {
-    return fe->n_components() * multiplicity;
-  }
-
-
-  template <int dim>
-  FEVariable<dim>::FEVariable(const VariableDeclaration<dim> &fe_variable,
-                              const unsigned int component_index,
-                              const unsigned int block_index,
-                              const unsigned int base_index)
-    : VariableDeclaration<dim> (fe_variable),
-      first_component_index (component_index),
-      block_index (block_index),
-      base_index (base_index),
-      scalar_extractor ( (this->n_components()==1) ? component_index : -1),
-      vector_extractor ( (this->n_components()==dim) ? component_index : -1)
-  {}
-
-
-
-  template <int dim>
-  const FEValuesExtractors::Scalar &
-  FEVariable<dim>::extractor_scalar() const
-  {
-    Assert(this->n_components()==1,
-           ExcMessage("You cannot ask for the scalar extractor of a non-scalar variable."));
-    return scalar_extractor;
-  }
-
-
-
-  template <int dim>
-  const FEValuesExtractors::Vector &
-  FEVariable<dim>::extractor_vector() const
-  {
-    Assert(this->n_components()==dim,
-           ExcMessage("You cannot ask for the vector extractor of a variable that is not a vector."));
-    return vector_extractor;
-  }
-
-
-
-  template <int dim>
-  FEVariableCollection<dim>::FEVariableCollection()
-    = default;
-
-
-
-  template <int dim>
-  FEVariableCollection<dim>::FEVariableCollection(const std::vector<VariableDeclaration<dim>> &variable_definitions)
-  {
-    initialize(variable_definitions);
-  }
-
-
-
-  template <int dim>
-  void
-  FEVariableCollection<dim>::initialize(const std::vector<VariableDeclaration<dim>> &variable_definitions)
-  {
-    variables.clear();
-    variables.reserve(variable_definitions.size());
-
-    unsigned int component_index = 0;
-    unsigned int block_index = 0;
-
-    for (unsigned int i=0; i<variable_definitions.size(); ++i)
-      {
-        variables.push_back(FEVariable<dim>(variable_definitions[i],
-                                            component_index, block_index, i));
-        component_index+= variables[i].n_components();
-        block_index += variables[i].n_blocks;
-      }
-
-    Assert(variables.back().n_blocks != 0
-           || variables.back().n_components() == 0,
-           ExcMessage("The last variable needs to have >0 blocks."));
-
-    n_components_ = component_index;
-    n_blocks_ = block_index;
-
-    fes.resize(variables.size());
-    multiplicities.resize(variables.size());
-    for (unsigned int i=0; i<variables.size(); ++i)
-      {
-        fes[i] = variables[i].fe.get();
-        multiplicities[i] = variables[i].multiplicity;
-        variables[i].component_mask = ComponentMask(n_components_, false);
-        for (unsigned int c=0; c<variables[i].n_components(); ++c)
-          variables[i].component_mask.set(c+variables[i].first_component_index, true);
-      }
-
-    components_to_blocks.clear();
-    for (unsigned int i=0; i<variables.size(); ++i)
-      {
-        for (unsigned int c=0; c<variables[i].n_components(); ++c)
-          components_to_blocks.push_back(variables[i].block_index
-                                         + ((variables[i].n_blocks>1)?c:0));
-      }
-    Assert(components_to_blocks.size() == n_components(), ExcInternalError());
-
-    Assert(fes.size() == variables.size(), ExcInternalError());
-    Assert(multiplicities.size() == variables.size(), ExcInternalError());
-  }
-
-
-
-  template <int dim>
-  const FEVariable<dim> &
-  FEVariableCollection<dim>::variable(const std::string &name) const
-  {
-    for (unsigned int i=0; i<variables.size(); ++i)
-      if (variables[i].name == name)
-        return variables[i];
-
-    Assert(false, ExcMessage("Variable '" + name + "' not found!"));
-    return *(variables.end()); // reference invalid iterator here
-  }
-
-
-
-  template <int dim>
-  std::vector<const FEVariable<dim>*>
-  FEVariableCollection<dim>::variables_with_name(const std::string &name) const
-  {
-    std::vector<const FEVariable<dim>*> result;
-    for (unsigned int i=0; i<variables.size(); ++i)
-      if (variables[i].name == name)
-        result.emplace_back(&variables[i]);
-
-    return result;
-  }
-
-
-
-  template <int dim>
-  bool
-  FEVariableCollection<dim>::variable_exists(const std::string &name) const
-  {
-    for (unsigned int i=0; i<variables.size(); ++i)
-      if (variables[i].name == name)
-        return true;
-
-    return false;
-  }
-
-
-
-  template <int dim>
-  const std::vector<FEVariable<dim>> &
-  FEVariableCollection<dim>::get_variables() const
-  {
-    return variables;
-  }
-
-
-
-  template <int dim>
-  unsigned int
-  FEVariableCollection<dim>::n_components() const
-  {
-    return n_components_;
-  }
-
-
-
-  template <int dim>
-  unsigned int
-  FEVariableCollection<dim>::n_blocks() const
-  {
-    return n_blocks_;
-  }
-
-
-
-  template <int dim>
-  const std::vector<const FiniteElement<dim> *> &
-  FEVariableCollection<dim>::get_fes() const
-  {
-    return fes;
-  }
-
-
-  template <int dim>
-  const std::vector<unsigned int> &
-  FEVariableCollection<dim>::get_multiplicities() const
-  {
-    return multiplicities;
-  }
-
-
-  template <int dim>
-  const std::vector<unsigned int> &
-  FEVariableCollection<dim>::get_components_to_blocks() const
-  {
-    return components_to_blocks;
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template struct VariableDeclaration<dim>; \
-  template struct FEVariable<dim>; \
-  template class FEVariableCollection<dim>;
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/geometry_model/box.cc.bak b/source/geometry_model/box.cc.bak
deleted file mode 100644
index 882efeb7e68..00000000000
--- a/source/geometry_model/box.cc.bak
+++ /dev/null
@@ -1,524 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/tria_accessor.h>
-#include <deal.II/grid/grid_tools.h>
-
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    template <int dim>
-    void
-    Box<dim>::initialize ()
-    {
-      // Get pointer to initial topography model
-      topo_model = const_cast<InitialTopographyModel::Interface<dim>*>(&this->get_initial_topography_model());
-
-      // Check that initial topography is required.
-      // If so, connect the initial topography function
-      // to the right signals: It should be applied after
-      // the final initial adaptive refinement and after a restart.
-      if (Plugins::plugin_type_matches<InitialTopographyModel::ZeroTopography<dim>>(*topo_model) == false)
-        {
-          this->get_signals().pre_set_initial_state.connect(
-            [&](typename parallel::distributed::Triangulation<dim> &tria)
-          {
-            this->topography(tria);
-          }
-          );
-          this->get_signals().post_resume_load_user_data.connect(
-            [&](typename parallel::distributed::Triangulation<dim> &tria)
-          {
-            this->topography(tria);
-          }
-          );
-        }
-    }
-
-
-    template <int dim>
-    void
-    Box<dim>::
-    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
-    {
-      const std::vector<unsigned int> rep_vec(repetitions.begin(), repetitions.end());
-      GridGenerator::subdivided_hyper_rectangle (coarse_grid,
-                                                 rep_vec,
-                                                 box_origin,
-                                                 box_origin+extents,
-                                                 true);
-
-      // Tell p4est about the periodicity of the mesh.
-      std::vector<GridTools::PeriodicFacePair<typename parallel::distributed::Triangulation<dim>::cell_iterator>>
-      periodicity_vector;
-      for (int i=0; i<dim; ++i)
-        if (periodic[i])
-          GridTools::collect_periodic_faces
-          ( coarse_grid, /*b_id1*/ 2*i, /*b_id2*/ 2*i+1,
-            /*direction*/ i, periodicity_vector);
-
-      if (periodicity_vector.size() > 0)
-        coarse_grid.add_periodicity (periodicity_vector);
-    }
-
-    template <int dim>
-    void
-    Box<dim>::
-    topography (typename parallel::distributed::Triangulation<dim> &grid) const
-    {
-      // Here we provide GridTools with the function to displace vertices
-      // in the vertical direction by an amount specified by the initial topography model
-      GridTools::transform(
-        [&](const Point<dim> &p) -> Point<dim>
-      {
-        return this->add_topography(p);
-      },
-      grid);
-
-      this->get_pcout() << "   Added initial topography to grid" << std::endl << std::endl;
-    }
-
-
-    template <int dim>
-    Point<dim>
-    Box<dim>::
-    add_topography (const Point<dim> &x_y_z) const
-    {
-      // Get the surface x (,y) point
-      Point<dim-1> surface_point;
-      for (unsigned int d=0; d<dim-1; ++d)
-        surface_point[d] = x_y_z[d];
-
-      // Get the surface topography at this point
-      const double topo = topo_model->value(surface_point);
-
-      // Compute the displacement of the z coordinate
-      const double ztopo = (x_y_z[dim-1] - box_origin[dim-1]) / extents[dim-1] * topo;
-
-      // Compute the new point
-      Point<dim> x_y_ztopo = x_y_z;
-      x_y_ztopo[dim-1] += ztopo;
-
-      return x_y_ztopo;
-    }
-
-
-    template <int dim>
-    std::set<types::boundary_id>
-    Box<dim>::
-    get_used_boundary_indicators () const
-    {
-      // boundary indicators are zero through 2*dim-1
-      std::set<types::boundary_id> s;
-      for (unsigned int i=0; i<2*dim; ++i)
-        s.insert (i);
-      return s;
-    }
-
-
-    template <int dim>
-    std::map<std::string,types::boundary_id>
-    Box<dim>::
-    get_symbolic_boundary_names_map () const
-    {
-      switch (dim)
-        {
-          case 2:
-          {
-            return
-            {
-              {"left",   0},
-              {"right",  1},
-              {"bottom", 2},
-              {"top",    3}
-            };
-          }
-
-          case 3:
-          {
-            return
-            {
-              {"left",   0},
-              {"right",  1},
-              {"front",  2},
-              {"back",   3},
-              {"bottom", 4},
-              {"top",    5}
-
-            };
-          }
-        }
-
-      Assert (false, ExcNotImplemented());
-      return {};
-    }
-
-
-    template <int dim>
-    std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
-    Box<dim>::
-    get_periodic_boundary_pairs () const
-    {
-      std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>> periodic_boundaries;
-      for ( unsigned int i=0; i<dim; ++i)
-        if (periodic[i])
-          periodic_boundaries.insert( std::make_pair( std::pair<types::boundary_id, types::boundary_id>(2*i, 2*i+1), i) );
-      return periodic_boundaries;
-    }
-
-
-
-    template <int dim>
-    void
-    Box<dim>::adjust_positions_for_periodicity (Point<dim> &position,
-                                                const ArrayView<Point<dim>> &connected_positions,
-                                                const ArrayView<Tensor<1, dim>> &/*connected_velocities*/) const
-    {
-      for (unsigned int i = 0; i < dim; ++i)
-        if (periodic[i])
-          {
-            if (position[i] < box_origin[i])
-              {
-                position[i] += extents[i];
-                for (auto &connected_position: connected_positions)
-                  connected_position[i] += extents[i];
-              }
-            else if (position[i] > box_origin[i] + extents[i])
-              {
-                position[i] -= extents[i];
-                for (auto &connected_position: connected_positions)
-                  connected_position[i] -= extents[i];
-              }
-          }
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    Box<dim>::get_extents () const
-    {
-      return extents;
-    }
-
-    template <int dim>
-    const std::array<unsigned int, dim> &
-    Box<dim>::get_repetitions () const
-    {
-      return repetitions;
-    }
-
-    template <int dim>
-    Point<dim>
-    Box<dim>::get_origin () const
-    {
-      return box_origin;
-    }
-
-    template <int dim>
-    double
-    Box<dim>::
-    length_scale () const
-    {
-      return 0.01*extents[0];
-    }
-
-
-    template <int dim>
-    double
-    Box<dim>::depth(const Point<dim> &position) const
-    {
-      // Get the surface x (,y) point
-      Point<dim-1> surface_point;
-      for (unsigned int d=0; d<dim-1; ++d)
-        surface_point[d] = position[d];
-
-      // Get the surface topography at this point
-      const double topo = topo_model->value(surface_point);
-
-      const double d = extents[dim-1] + topo - (position(dim-1)-box_origin[dim-1]);
-      return std::min (std::max (d, 0.), maximal_depth());
-    }
-
-
-    template <int dim>
-    double
-    Box<dim>::height_above_reference_surface(const Point<dim> &position) const
-    {
-      return (position(dim-1)-box_origin[dim-1]) - extents[dim-1];
-    }
-
-
-    template <int dim>
-    Point<dim>
-    Box<dim>::representative_point(const double depth) const
-    {
-      Assert (depth >= 0,
-              ExcMessage ("Given depth must be positive or zero."));
-      Assert (depth <= maximal_depth(),
-              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
-
-      // choose a point on the center axis of the domain (without topography)
-      Point<dim> p = extents/2+box_origin;
-
-      // We need a dim-1 point to get the topo value.
-      Point<dim-1> surface_point;
-      for (unsigned int d=0; d<dim-1; ++d)
-        surface_point[d] = p[d];
-
-      const double topo = topo_model->value(surface_point);
-      p[dim-1] = extents[dim-1]+box_origin[dim-1]-depth+topo;
-
-      return p;
-    }
-
-
-    template <int dim>
-    double
-    Box<dim>::maximal_depth() const
-    {
-      return extents[dim-1] + topo_model->max_topography();
-    }
-
-    template <int dim>
-    bool
-    Box<dim>::has_curved_elements() const
-    {
-      return false;
-    }
-
-    template <int dim>
-    bool
-    Box<dim>::point_is_in_domain(const Point<dim> &point) const
-    {
-      // If mesh deformation is enabled, we have to loop over all the current
-      // grid cells to see if the given point lies in the domain.
-      // If mesh deformation is not enabled, or has not happened yet,
-      // we can use the global extents of the model domain with or without
-      // initial topography instead.
-      // This function only checks if the given point lies in the domain
-      // in its current shape at the current time. It can be called before
-      // mesh deformation is applied in the first timestep (e.g., by the boundary
-      // traction plugins), and therefore there is no guarantee
-      // that the point will still lie in the domain after initial mesh deformation.
-      if (this->get_parameters().mesh_deformation_enabled &&
-          this->simulator_is_past_initialization())
-        {
-          return Utilities::point_is_in_triangulation<dim>(this->get_mapping(),
-                                                           this->get_triangulation(),
-                                                           point,
-                                                           this->get_mpi_communicator());
-        }
-      // Without mesh deformation enabled, it is much cheaper to check whether the point lies in the domain.
-      else
-        {
-          // The maximal extents of the unperturbed box domain.
-          Point<dim> max_point = extents+box_origin;
-
-          // If mesh deformation is not enabled, but initial topography
-          // was/will be applied to the mesh, include this topography in the
-          // extent of the domain.
-          if (!Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()))
-            {
-              // Get the surface x (,y) point
-              Point<dim-1> surface_point;
-              for (unsigned int d=0; d<dim-1; ++d)
-                surface_point[d] = point[d];
-
-              // Get the surface topography at this point
-              const double topo = topo_model->value(surface_point);
-              max_point[dim-1] += topo;
-            }
-
-          // Check whether point lies within the min/max coordinates of the domain including initial topography.
-          for (unsigned int d = 0; d < dim; ++d)
-            if (point[d] > max_point[d]+std::numeric_limits<double>::epsilon()*extents[d] ||
-                point[d] < box_origin[d]-std::numeric_limits<double>::epsilon()*extents[d])
-              return false;
-
-          return true;
-        }
-    }
-
-    template <int dim>
-    std::array<double,dim>
-    Box<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
-    {
-      std::array<double,dim> position_array;
-      for (unsigned int i = 0; i < dim; ++i)
-        position_array[i] = position_point(i);
-
-      return position_array;
-    }
-
-
-    template <int dim>
-    aspect::Utilities::Coordinates::CoordinateSystem
-    Box<dim>::natural_coordinate_system() const
-    {
-      return aspect::Utilities::Coordinates::CoordinateSystem::cartesian;
-    }
-
-
-    template <int dim>
-    Point<dim>
-    Box<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position_tensor) const
-    {
-      Point<dim> position_point;
-      for (unsigned int i = 0; i < dim; ++i)
-        position_point[i] = position_tensor[i];
-
-      return position_point;
-    }
-
-
-    template <int dim>
-    void
-    Box<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Box");
-        {
-          prm.declare_entry ("X extent", "1.",
-                             Patterns::Double (0.),
-                             "Extent of the box in x-direction. Units: \\si{\\meter}.");
-          prm.declare_entry ("Y extent", "1.",
-                             Patterns::Double (0.),
-                             "Extent of the box in y-direction. Units: \\si{\\meter}.");
-          prm.declare_entry ("Z extent", "1.",
-                             Patterns::Double (0.),
-                             "Extent of the box in z-direction. This value is ignored "
-                             "if the simulation is in 2d. Units: \\si{\\meter}.");
-
-          prm.declare_entry ("Box origin X coordinate", "0.",
-                             Patterns::Double (),
-                             "X coordinate of box origin. Units: \\si{\\meter}.");
-          prm.declare_entry ("Box origin Y coordinate", "0.",
-                             Patterns::Double (),
-                             "Y coordinate of box origin. Units: \\si{\\meter}.");
-          prm.declare_entry ("Box origin Z coordinate", "0.",
-                             Patterns::Double (),
-                             "Z coordinate of box origin. This value is ignored "
-                             "if the simulation is in 2d. Units: \\si{\\meter}.");
-
-          prm.declare_entry ("X repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in X direction.");
-          prm.declare_entry ("Y repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in Y direction.");
-          prm.declare_entry ("Z repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in Z direction.");
-
-          prm.declare_entry ("X periodic", "false",
-                             Patterns::Bool (),
-                             "Whether the box should be periodic in X direction");
-          prm.declare_entry ("Y periodic", "false",
-                             Patterns::Bool (),
-                             "Whether the box should be periodic in Y direction");
-          prm.declare_entry ("Z periodic", "false",
-                             Patterns::Bool (),
-                             "Whether the box should be periodic in Z direction");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Box<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Box");
-        {
-          box_origin[0] = prm.get_double ("Box origin X coordinate");
-          extents[0] = prm.get_double ("X extent");
-          periodic[0] = prm.get_bool ("X periodic");
-          repetitions[0] = prm.get_integer ("X repetitions");
-
-          if (dim >= 2)
-            {
-              box_origin[1] = prm.get_double ("Box origin Y coordinate");
-              extents[1] = prm.get_double ("Y extent");
-              periodic[1] = prm.get_bool ("Y periodic");
-              repetitions[1] = prm.get_integer ("Y repetitions");
-            }
-
-          if (dim >= 3)
-            {
-              // Use dim-1 instead of 2 to avoid compiler warning in 2d:
-              box_origin[dim-1] = prm.get_double ("Box origin Z coordinate");
-              extents[dim-1] = prm.get_double ("Z extent");
-              periodic[dim-1] = prm.get_bool ("Z periodic");
-              repetitions[dim-1] = prm.get_integer ("Z repetitions");
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    ASPECT_REGISTER_GEOMETRY_MODEL(Box,
-                                   "box",
-                                   "A box geometry parallel to the coordinate directions. "
-                                   "The extent of the box in each coordinate direction "
-                                   "is set in the parameter file. The box geometry labels its "
-                                   "2*dim sides as follows: in 2d, boundary indicators 0 through 3 "
-                                   "denote the left, right, bottom and top boundaries; in 3d, boundary "
-                                   "indicators 0 through 5 indicate left, right, front, back, bottom "
-                                   "and top boundaries (see also the documentation of the deal.II class "
-                                   "``ReferenceCell''). You can also use symbolic names ``left'', ``right'', "
-                                   "etc., to refer to these boundaries in input files. "
-                                   "It is also possible to add initial topography to the box model. Note however that "
-                                   "this is done after the last initial adaptive refinement cycle. "
-                                   "Also, initial topography is supposed to be small, as it is not taken into account "
-                                   "when depth or a representative point is computed. ")
-
-
-  }
-}
diff --git a/source/geometry_model/chunk.cc.bak b/source/geometry_model/chunk.cc.bak
deleted file mode 100644
index b81fbeb7ad3..00000000000
--- a/source/geometry_model/chunk.cc.bak
+++ /dev/null
@@ -1,949 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-#include <aspect/geometry_model/initial_topography_model/ascii_data.h>
-
-#include <aspect/simulator_signals.h>
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/tria_accessor.h>
-#include <deal.II/grid/grid_tools.h>
-#include <deal.II/grid/tria.h>
-
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    namespace internal
-    {
-      template <int dim>
-      ChunkGeometry<dim>::ChunkGeometry(const InitialTopographyModel::Interface<dim> &topo,
-                                        const double min_longitude,
-                                        const double min_radius,
-                                        const double max_depth)
-        :
-        topo (&topo),
-        point1_lon(min_longitude),
-        inner_radius(min_radius),
-        max_depth(max_depth)
-      {}
-
-
-
-      template <int dim>
-      DerivativeForm<1,dim,dim>
-      ChunkGeometry<dim>::
-      push_forward_gradient(const Point<dim> &chart_point) const
-      {
-        const double R = chart_point[0]; // Radius
-
-        Assert (R > 0.0, ExcMessage("Negative radius for given point."));
-
-        Tensor<2,dim> DX;
-
-        // We only have access to the topography gradients
-        // (dtopo/dphi and dtopo/dtheta) for the AsciiData
-        // initial topography model. We assume 0.0 otherwise;
-        // while this is valid for the ZeroTopography model,
-        // this will result in incorrect gradients for
-        // other initial topography models. Hence only AsciiData
-        // and ZeroTopography are allowed for now in Chunk<dim>::initialize().
-        Tensor<1,dim-1> topo_derivatives;
-        if (const InitialTopographyModel::AsciiData<dim> *itm = dynamic_cast<const InitialTopographyModel::AsciiData<dim> *> (topo))
-          topo_derivatives = itm->vector_gradient(push_forward_sphere(chart_point));
-        else if (dynamic_cast<const InitialTopographyModel::ZeroTopography<dim> *> (topo))
-          {
-            // Gradient is zero (which it is already initialized to from before)
-          }
-        else
-          Assert (false, ExcNotImplemented());
-
-        // Construct surface point in lon(,lat) coordinates
-        Point<dim-1> surface_point;
-        for (unsigned int d=0; d<dim-1; ++d)
-          surface_point[d] = chart_point[d+1];
-
-        // Convert latitude to colatitude
-        if (dim == 3)
-          surface_point[1] = 0.5*numbers::PI - surface_point[1];
-
-        // get the maximum topography at the surface point
-        const double d_topo = topo->value(surface_point);
-
-        // get the spherical point including topography
-        const Point<dim> topo_point = push_forward_topo(chart_point);
-        const double R_topo = topo_point[0];
-        const double phi_topo = topo_point[1];
-
-        // The derivatives of topo_point to chart_point
-        Tensor<2, dim> Dtopo;
-        // The derivatives of the cartesian point to chart_point
-        DerivativeForm<1, dim, dim> Dtotal;
-
-
-        switch (dim)
-          {
-            case 2:
-            {
-              // R_topo = R + topo(phi) * ((R-R_0)/(R_1-R_0)) = R + topo(phi) * ((R-R_0)/max_depth)
-              // phi_topo = phi
-              //dR_topo/dR
-              Dtopo[0][0] = (d_topo / max_depth) + 1.;
-              //dR_topo/dphi = dR_topo/dtopo * dtopo/dphi
-              Dtopo[0][1] = (R-inner_radius)/max_depth * topo_derivatives[0];
-              //dphi_topo/dR
-              Dtopo[1][0] = 0.;
-              //dphi_topo/dphi
-              Dtopo[1][1] = 1.;
-
-              //dx/dR_topo
-              DX[0][0] =           std::cos(phi_topo);
-              //dx/dphi_topo
-              DX[0][1] = -R_topo * std::sin(phi_topo);
-              //dy/dR_topo
-              DX[1][0] =           std::sin(phi_topo);
-              //dy/dphi_topo
-              DX[1][1] =  R_topo * std::cos(phi_topo);
-
-              break;
-            }
-            case 3:
-            {
-              // R_topo = R + topo(phi,theta) * ((R-R_0)/(R_1-R_0))
-              // phi_topo = phi
-              // theta_topo = theta
-              //dR_topo/dR
-              Dtopo[0][0] = (d_topo / max_depth) + 1.;
-              //dR_topo/dphi
-              Dtopo[0][1] = (R - inner_radius) / max_depth * topo_derivatives[0];
-              //dR_topo/dtheta
-              Dtopo[0][2] = (R - inner_radius) / max_depth * topo_derivatives[1];
-              //dphi_topo/dR
-              Dtopo[1][0] = 0.;
-              //dphi_topo/dphi
-              Dtopo[1][1] = 1.;
-              //dphi_topo/dtheta
-              Dtopo[1][2] = 0.;
-              //dtheta_topo/dR
-              Dtopo[2][0] = 0.;
-              //dtheta_topo/dphi
-              Dtopo[2][1] = 0.;
-              //dtheta_topo/dtheta
-              Dtopo[2][2] = 1.;
-
-              const double theta_topo = topo_point[2];
-
-              // The derivatives of the cartesian points to topo_point
-              DX[0][0] =      std::cos(theta_topo) * std::cos(phi_topo);
-              DX[0][1] = -R_topo * std::cos(theta_topo) * std::sin(phi_topo);
-              DX[0][2] = -R_topo * std::sin(theta_topo) * std::cos(phi_topo); //reorder
-              DX[1][0] =      std::cos(theta_topo) * std::sin(phi_topo);
-              DX[1][1] =  R_topo * std::cos(theta_topo) * std::cos(phi_topo);
-              DX[1][2] = -R_topo * std::sin(theta_topo) * std::sin(phi_topo);
-              DX[2][0] =      std::sin(theta_topo);
-              DX[2][1] = 0;
-              DX[2][2] =  R_topo * std::cos(theta_topo);
-
-              break;
-            }
-            default:
-              Assert (false, ExcNotImplemented ());
-          }
-
-        Dtotal = DerivativeForm<1,dim,dim>(DX * Dtopo);
-
-        return Dtotal;
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      ChunkGeometry<dim>::
-      push_forward(const Point<dim> &r_phi_theta) const
-      {
-        // Only take into account topography when we're not using the ZeroTopography plugin
-        if (dynamic_cast<const InitialTopographyModel::ZeroTopography<dim>*>(topo) != nullptr)
-          return push_forward_sphere(r_phi_theta);
-        else
-          return push_forward_sphere(push_forward_topo(r_phi_theta));
-
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      ChunkGeometry<dim>::
-      pull_back(const Point<dim> &x_y_z) const
-      {
-        // Only take into account topography when we're not using the ZeroTopography plugin
-        if (dynamic_cast<const InitialTopographyModel::ZeroTopography<dim>*>(topo) != nullptr)
-          return pull_back_sphere(x_y_z);
-        else
-          return pull_back_topo(pull_back_sphere(x_y_z));
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      ChunkGeometry<dim>::
-      push_forward_sphere(const Point<dim> &input_vertex) const
-      {
-        Point<dim> output_vertex;
-        switch (dim)
-          {
-            case 2:
-            {
-              output_vertex[0] = input_vertex[0]*std::cos(input_vertex[1]); // x=rcosphi
-              output_vertex[1] = input_vertex[0]*std::sin(input_vertex[1]); // z=rsinphi
-              break;
-            }
-            case 3:
-            {
-              output_vertex[0] = input_vertex[0]*std::cos(input_vertex[2])*std::cos(input_vertex[1]); // x=rsinthetacosphi
-              output_vertex[1] = input_vertex[0]*std::cos(input_vertex[2])*std::sin(input_vertex[1]); // y=rsinthetasinphi
-              output_vertex[2] = input_vertex[0]*std::sin(input_vertex[2]); // z=rcostheta
-              break;
-            }
-            default:
-              Assert (false, ExcNotImplemented ());
-          }
-        return output_vertex;
-      }
-
-
-
-      template <int dim>
-      Tensor<1, dim>
-      ChunkGeometry<dim>::
-      normal_vector(const typename Triangulation<dim>::face_iterator &face,
-                    const Point<dim> &p) const
-      {
-        // Let us first test whether we are on a "horizontal" face
-        // (tangential to the sphere).  In this case, the normal vector is
-        // easy to compute since it is proportional to the vector from the
-        // center to the point 'p'.
-        //
-        // We test whether a face is horizontal by checking that the vertices
-        // all have roughly the same distance from the center: If the
-        // maximum deviation for the distances from the vertices to the
-        // center is less than 1.e-5 of the distance between vertices (as
-        // measured by the minimum distance from any of the other vertices
-        // to the first vertex), then we call this a horizontal face.
-        constexpr unsigned int max_n_vertices_per_face = (dim==2 ? 2 : 4);
-        std::array<double, max_n_vertices_per_face>     distances_to_center {};
-        std::array<double, max_n_vertices_per_face - 1> distances_to_first_vertex {};
-        distances_to_center[0] = face->vertex(0).norm_square();
-        for (unsigned int i = 1; i < face->n_vertices(); ++i)
-          {
-            AssertIndexRange (i, distances_to_center.size());
-            AssertIndexRange (i-1, distances_to_first_vertex.size());
-
-            distances_to_center[i] = face->vertex(i).norm_square();
-            distances_to_first_vertex[i - 1] =
-              (face->vertex(i) - face->vertex(0)).norm_square();
-          }
-        const auto minmax_distance =
-          std::minmax_element(distances_to_center.begin(),
-                              distances_to_center.begin()+face->n_vertices());
-        const auto min_distance_to_first_vertex =
-          std::min_element(distances_to_first_vertex.begin(),
-                           distances_to_first_vertex.begin()+face->n_vertices()-1);
-
-        // So, if this is a "horizontal" face, then just compute the normal
-        // vector as the one from the center to the point 'p', adequately
-        // scaled.
-        if (*minmax_distance.second - *minmax_distance.first <
-            1.e-10 * *min_distance_to_first_vertex)
-          {
-            const Tensor<1, dim> unnormalized_spherical_normal = p;
-            const Tensor<1, dim> normalized_spherical_normal =
-              unnormalized_spherical_normal / unnormalized_spherical_normal.norm();
-            return normalized_spherical_normal;
-          }
-
-        // If it is not a horizontal face, just use the machinery of the
-        // base class.
-        return Manifold<dim>::normal_vector(face, p);
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      ChunkGeometry<dim>::
-      pull_back_sphere(const Point<dim> &v) const
-      {
-        Point<dim> output_vertex;
-        switch (dim)
-          {
-            case 2:
-            {
-              output_vertex[1] = std::atan2(v[1], v[0]);
-              output_vertex[0] = v.norm();
-
-              // We must guarantee that all returned points have a longitude coordinate
-              // value that is larger than (or equal to) the longitude of point1.
-              // For example:
-              // If the domain runs from longitude -10 to 200 degrees,
-              // atan2 will also return a negative value (-180 to -160) for the points
-              // with longitude 180 to 200. These values must be corrected
-              // so that they are larger than the minimum longitude value of -10,
-              // by adding 360 degrees.
-              // A 100*epsilon ensures we catch all cases.
-              if (output_vertex[1] < 0.0)
-                if (output_vertex[1] < point1_lon - 100 * std::abs(point1_lon)*std::numeric_limits<double>::epsilon())
-                  output_vertex[1] += 2.0 * numbers::PI;
-              break;
-            }
-            case 3:
-            {
-              const double radius=v.norm();
-              output_vertex[0] = radius;
-              output_vertex[1] = std::atan2(v[1], v[0]);
-              // See 2d case
-              if (output_vertex[1] < 0.0)
-                if (output_vertex[1] < point1_lon - 100 * std::abs(point1_lon)*std::numeric_limits<double>::epsilon())
-                  output_vertex[1] += 2.0 * numbers::PI;
-              output_vertex[2] = std::asin(v[2]/radius);
-              break;
-            }
-            default:
-              Assert (false, ExcNotImplemented ());
-          }
-        return output_vertex;
-      }
-
-
-
-      template <int dim>
-      std::unique_ptr<Manifold<dim,dim>>
-      ChunkGeometry<dim>::
-      clone() const
-      {
-        return std::make_unique<ChunkGeometry>(*this);
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      ChunkGeometry<dim>::
-      push_forward_topo(const Point<dim> &r_phi_theta) const
-      {
-        // the radius of the current point without topography
-        const double radius = r_phi_theta[0];
-
-        // Grab lon,lat coordinates
-        Point<dim-1> surface_point;
-        for (unsigned int d=0; d<dim-1; ++d)
-          surface_point[d] = r_phi_theta[d+1];
-
-        // While throughout ASPECT we use co-latitude as a convention when
-        // representing points in spherical coordinates (see for example
-        // the Utilities::Coordinates::cartesian_to_spherical_coordinates()
-        // function), the current class uses latitude in its pull back and
-        // push forward functions. As a consequence, the argument provided
-        // to this function has latitude as one coordinate (at least in 3d).
-        // On the other hand, the InitialTopography::Interface::value()
-        // function expects colatitude (=standard form spherical coordinates)
-        // for geometry models that are (parts of) spherical objects.
-        //
-        // So do the conversion:
-        if (dim == 3)
-          surface_point[1] = 0.5*numbers::PI - surface_point[1];
-
-        // Then query the topography at this point:
-        const double topography = topo->value(surface_point);
-
-        // adjust the radius based on the radius of the point
-        // through a linear interpolation between 0 at max depth and
-        // "topography" at the surface
-        const double topo_radius = std::max(inner_radius,radius + (radius-inner_radius)/max_depth*topography);
-
-        // return the point with adjusted radius
-        Point<dim> topo_r_phi_theta = r_phi_theta;
-        topo_r_phi_theta[0] = topo_radius;
-
-        return topo_r_phi_theta;
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      ChunkGeometry<dim>::
-      pull_back_topo(const Point<dim> &topo_r_phi_theta) const
-      {
-        // the radius of the point with topography
-        const double topo_radius = topo_r_phi_theta[0];
-
-        // Grab lon,lat coordinates
-        Point<dim-1> surface_point;
-        for (unsigned int d=0; d<dim-1; ++d)
-          surface_point[d] = topo_r_phi_theta[d+1];
-
-        // While throughout ASPECT we use co-latitude as a convention when
-        // representing points in spherical coordinates (see for example
-        // the Utilities::Coordinates::cartesian_to_spherical_coordinates()
-        // function), the current class uses latitude in its pull back and
-        // push forward functions. As a consequence, the argument provided
-        // to this function has latitude as one coordinate (at least in 3d).
-        // On the other hand, the InitialTopography::Interface::value()
-        // function expects colatitude (=standard form spherical coordinates)
-        // for geometry models that are (parts of) spherical objects.
-        //
-        // So do the conversion:
-        if (dim == 3)
-          surface_point[1] = 0.5*numbers::PI - surface_point[1];
-
-        // Then query the topography at this point:
-        const double topography = topo->value(surface_point);
-
-        // remove the topography (which scales with radius)
-        const double radius = std::max(inner_radius,
-                                       (topo_radius*max_depth+inner_radius*topography)/(max_depth+topography));
-
-        // return the point without topography
-        Point<dim> r_phi_theta = topo_r_phi_theta;
-        r_phi_theta[0] = radius;
-
-        return r_phi_theta;
-      }
-
-
-
-      template <int dim>
-      double
-      ChunkGeometry<dim>::
-      get_radius(const Point<dim> &x_y_z) const
-      {
-        const Point<dim> r_phi_theta = pull_back(x_y_z);
-        Point<dim-1> surface_point;
-        for (unsigned int d=0; d<dim-1; ++d)
-          surface_point[d] = r_phi_theta[d+1];
-        // Convert latitude to colatitude
-        if (dim == 3)
-          surface_point[1] = 0.5*numbers::PI - surface_point[1];
-        const double topography = topo->value(surface_point);
-
-        // return the outer radius at this phi, theta point including topography
-        return topography + inner_radius + max_depth;
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    Chunk<dim>::initialize ()
-    {
-      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()) ||
-                  Plugins::plugin_type_matches<const InitialTopographyModel::AsciiData<dim>>(this->get_initial_topography_model()),
-                  ExcMessage("At the moment, only the Zero or AsciiData initial topography model can be used with the Chunk geometry model."));
-
-      manifold = std::make_unique<internal::ChunkGeometry<dim>>(this->get_initial_topography_model(),
-                                                                 point1[1],
-                                                                 point1[0],
-                                                                 point2[0]-point1[0]);
-    }
-
-
-    template <int dim>
-    void
-    Chunk<dim>::
-    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
-    {
-      // First create a box in Cartesian coordinates:
-      const std::vector<unsigned int> rep_vec(repetitions.begin(), repetitions.end());
-      GridGenerator::subdivided_hyper_rectangle (coarse_grid,
-                                                 rep_vec,
-                                                 point1,
-                                                 point2,
-                                                 true);
-
-      // Then transform this box into a spherical chunk (possibly with
-      // topography -- the 'manifold' has that built in):
-      GridTools::transform (
-        [&](const Point<dim> &p) -> Point<dim>
-      {
-        return manifold->push_forward(p);
-      },
-      coarse_grid);
-
-      // Deal with a curved mesh by assigning a manifold. We arbitrarily
-      // choose manifold_id 15 for this.
-      coarse_grid.set_manifold (my_manifold_id, *manifold);
-      for (const auto &cell : coarse_grid.active_cell_iterators())
-        cell->set_all_manifold_ids (my_manifold_id);
-    }
-
-
-
-    template <int dim>
-    std::set<types::boundary_id>
-    Chunk<dim>::
-    get_used_boundary_indicators () const
-    {
-      // boundary indicators are zero through 2*dim-1
-      std::set<types::boundary_id> s;
-      for (unsigned int i=0; i<2*dim; ++i)
-        s.insert (i);
-      return s;
-    }
-
-
-
-    template <int dim>
-    std::map<std::string,types::boundary_id>
-    Chunk<dim>::
-    get_symbolic_boundary_names_map () const
-    {
-      switch (dim)
-        {
-          case 2:
-          {
-            return
-            {
-              {"bottom", 0},
-              {"top",    1},
-              {"west",   2},
-              {"east",   3}
-            };
-          }
-
-          case 3:
-          {
-            return
-            {
-              {"bottom", 0},
-              {"top",    1},
-              {"west",   2},
-              {"east",   3},
-              {"south",  4},
-              {"north",  5}
-            };
-          }
-        }
-
-      Assert (false, ExcNotImplemented());
-      return {};
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::
-    length_scale () const
-    {
-      // As described in the first ASPECT paper, a length scale of
-      // 10km = 1e4m works well for the pressure scaling for earth
-      // sized spherical shells. use a length scale that
-      // yields this value for the R0,R1 corresponding to earth
-      // but otherwise scales like (R1-R0)
-      return 1e4 * maximal_depth() / (6336000.-3481000.);
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::depth(const Point<dim> &position) const
-    {
-      // depth is defined wrt the reference surface point2[0]
-      // negative depth is not allowed
-      return std::max (0., std::min (point2[0]-position.norm(), maximal_depth()));
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::height_above_reference_surface(const Point<dim> &position) const
-    {
-      return position.norm()-point2[0];
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    Chunk<dim>::representative_point(const double depth) const
-    {
-      Assert (depth >= 0,
-              ExcMessage ("Given depth must be positive or zero."));
-      Assert (depth <= maximal_depth(),
-              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
-
-      // Choose a point at the mean longitude (and latitude)
-      Point<dim> p = 0.5*(point2+point1);
-      // at a depth beneath the top surface
-      p[0] = point2[0]-depth;
-
-      // Now convert to Cartesian coordinates. This ignores the surface topography,
-      // but that is as documented.
-      return manifold->push_forward_sphere(p);
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::west_longitude () const
-    {
-      return point1[1];
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::east_longitude () const
-    {
-      return point2[1];
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::longitude_range () const
-    {
-      return point2[1] - point1[1];
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::south_latitude () const
-    {
-      if (dim == 3)
-        return point1[2];
-      else
-        return 0;
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::north_latitude () const
-    {
-      if (dim==3)
-        return point2[2];
-      else
-        return 0;
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::latitude_range () const
-    {
-      if (dim==3)
-        return point2[2] - point1[2];
-      else
-        return 0;
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::maximal_depth() const
-    {
-      // The depth is defined as relative to a reference surface (without
-      // topography) and since we don't apply topography on the CMB,
-      // the maximal depth really is the formula below, unless one applies a
-      // topography that is always strictly below zero (i.e., where the
-      // actual surface lies strictly below the reference surface).
-      return point2[0]-point1[0];
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::inner_radius () const
-    {
-      return point1[0];
-    }
-
-
-
-    template <int dim>
-    double
-    Chunk<dim>::outer_radius () const
-    {
-      return point2[0];
-    }
-
-
-
-    template <int dim>
-    bool
-    Chunk<dim>::has_curved_elements() const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    bool
-    Chunk<dim>::point_is_in_domain(const Point<dim> &point) const
-    {
-      // If mesh deformation is enabled, we have to loop over all the current
-      // grid cells to see if the given point lies in the domain.
-      // If mesh deformation is not enabled, or has not happened yet,
-      // we can use the global extents of the model domain with or without
-      // initial topography instead.
-      // This function only checks if the given point lies in the domain
-      // in its current shape at the current time. It can be called before
-      // mesh deformation is applied in the first timestep (e.g., by the boundary
-      // traction plugins), and therefore there is no guarantee
-      // that the point will still lie in the domain after initial mesh deformation.
-      if (this->get_parameters().mesh_deformation_enabled &&
-          this->simulator_is_past_initialization())
-        {
-          return Utilities::point_is_in_triangulation(this->get_mapping(), this->get_triangulation(), point, this->get_mpi_communicator());
-        }
-      // Without mesh deformation enabled, it is much cheaper to check whether the point lies in the domain.
-      else
-        {
-          const Point<dim> spherical_point = manifold->pull_back(point);
-
-          for (unsigned int d = 0; d < dim; ++d)
-            if (spherical_point[d] > point2[d]+std::numeric_limits<double>::epsilon()*std::abs(point2[d]) ||
-                spherical_point[d] < point1[d]-std::numeric_limits<double>::epsilon()*std::abs(point2[d]))
-              return false;
-
-          return true;
-        }
-    }
-
-
-
-    template <int dim>
-    std::array<double,dim>
-    Chunk<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
-    {
-      // The chunk manifold uses (radius, longitude, latitude).
-      // This is exactly what we need.
-
-      // Ignore the topography to avoid a loop when calling the
-      // AsciiDataBoundary for topography which uses this function....
-      const Point<dim> transformed_point = manifold->pull_back_sphere(position_point);
-      std::array<double,dim> position_array;
-      for (unsigned int i = 0; i < dim; ++i)
-        position_array[i] = transformed_point(i);
-
-      // Internally, the Chunk geometry uses longitudes in the range -pi...pi,
-      // and that is what pull_back_sphere() produces. But externally, we need
-      // to use 0...2*pi to match what Utilities::Coordinates::cartesian_to_spherical_coordinates()
-      // returns, for example, and what we document the AsciiBoundaryData class
-      // wants to see from input files.
-      if (position_array[1] < 0)
-        position_array[1] += 2*numbers::PI;
-
-      return position_array;
-    }
-
-
-
-    template <int dim>
-    aspect::Utilities::Coordinates::CoordinateSystem
-    Chunk<dim>::natural_coordinate_system() const
-    {
-      // TODO This will give problems somewhere down the line
-      // if geometry models are asked for their coordinate system,
-      // chunk returns spherical and then Utilitiess::Coordinates::cartesian_to_spherical
-      // is used
-      return aspect::Utilities::Coordinates::CoordinateSystem::spherical;
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    Chunk<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position_tensor) const
-    {
-      // Ignore the topography to avoid a loop when calling the
-      // AsciiDataBoundary for topography which uses this function....
-      Point<dim> position_point;
-      for (unsigned int i = 0; i < dim; ++i)
-        position_point[i] = position_tensor[i];
-      const Point<dim> transformed_point = manifold->push_forward_sphere(position_point);
-
-      return transformed_point;
-    }
-
-
-
-    template <int dim>
-    void
-    Chunk<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Chunk");
-        {
-          prm.declare_entry ("Chunk inner radius", "0.",
-                             Patterns::Double (0.),
-                             "Radius at the bottom surface of the chunk. Units: \\si{\\meter}.");
-          prm.declare_entry ("Chunk outer radius", "1.",
-                             Patterns::Double (0.),
-                             "Radius at the top surface of the chunk. Units: \\si{\\meter}.");
-
-          prm.declare_entry ("Chunk minimum longitude", "0.",
-                             Patterns::Double (-180., 360.), // enables crossing of either hemisphere
-                             "Minimum longitude of the chunk. Units: degrees.");
-          prm.declare_entry ("Chunk maximum longitude", "1.",
-                             Patterns::Double (-180., 360.), // enables crossing of either hemisphere
-                             "Maximum longitude of the chunk. Units: degrees.");
-
-          prm.declare_entry ("Chunk minimum latitude", "0.",
-                             Patterns::Double (-90., 90.),
-                             "Minimum latitude of the chunk. This value is ignored "
-                             "if the simulation is in 2d. Units: degrees.");
-          prm.declare_entry ("Chunk maximum latitude", "1.",
-                             Patterns::Double (-90., 90.),
-                             "Maximum latitude of the chunk. This value is ignored "
-                             "if the simulation is in 2d. Units: degrees.");
-
-          prm.declare_entry ("Radius repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in radius.");
-          prm.declare_entry ("Longitude repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in longitude.");
-          prm.declare_entry ("Latitude repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in latitude. This value is ignored "
-                             "if the simulation is in 2d");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Chunk<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Chunk");
-        {
-          point1[0] = prm.get_double ("Chunk inner radius");
-          point2[0] = prm.get_double ("Chunk outer radius");
-          repetitions[0] = prm.get_integer ("Radius repetitions");
-          point1[1] = prm.get_double ("Chunk minimum longitude") * constants::degree_to_radians;
-          point2[1] = prm.get_double ("Chunk maximum longitude") * constants::degree_to_radians;
-          repetitions[1] = prm.get_integer ("Longitude repetitions");
-
-          AssertThrow (point1[0] < point2[0],
-                       ExcMessage ("Inner radius must be less than outer radius."));
-          AssertThrow (point1[1] < point2[1],
-                       ExcMessage ("Minimum longitude must be less than maximum longitude."));
-          AssertThrow (point2[1] - point1[1] < 2.*numbers::PI,
-                       ExcMessage ("Maximum - minimum longitude should be less than 360 degrees."));
-
-          if (dim == 3)
-            {
-              point1[2] = prm.get_double ("Chunk minimum latitude") * constants::degree_to_radians;
-              point2[2] = prm.get_double ("Chunk maximum latitude") * constants::degree_to_radians;
-              repetitions[2] = prm.get_integer ("Latitude repetitions");
-
-              AssertThrow (point1[2] < point2[2],
-                           ExcMessage ("Minimum latitude must be less than maximum latitude."));
-              AssertThrow (point1[2] > -0.5*numbers::PI,
-                           ExcMessage ("Minimum latitude needs to be larger than -90 degrees."));
-              AssertThrow (point2[2] < 0.5*numbers::PI,
-                           ExcMessage ("Maximum latitude needs to be less than 90 degrees."));
-            }
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    namespace internal
-    {
-#define INSTANTIATE(dim) \
-  template class ChunkGeometry<dim>;
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-
-    ASPECT_REGISTER_GEOMETRY_MODEL(Chunk,
-                                   "chunk",
-                                   "A geometry which can be described as a chunk of a spherical shell, "
-                                   "bounded by lines of longitude, latitude and radius. "
-                                   "The minimum and maximum longitude, latitude (if in 3d) and depth of the chunk "
-                                   "is set in the parameter file. The chunk geometry labels its "
-                                   "2*dim sides as follows: ``west'' and ``east'': minimum and maximum "
-                                   "longitude, ``south'' and ``north'': minimum and maximum latitude, "
-                                   "``inner'' and ``outer'': minimum and maximum radii. "
-                                   "\n\n"
-                                   "The dimensions of the model are specified by parameters "
-                                   "of the following form: "
-                                   "Chunk (minimum || maximum) (longitude || latitude): "
-                                   "edges of geographical quadrangle (in degrees)"
-                                   "Chunk (inner || outer) radius: Radii at bottom and top of chunk"
-                                   "(Longitude || Latitude || Radius) repetitions: "
-                                   "number of cells in each coordinate direction."
-                                   "\n\n"
-                                   "When used in 2d, this geometry does not imply the use of "
-                                   "a spherical coordinate system. Indeed, "
-                                   "in 2d the geometry is simply a sector of an annulus in a Cartesian "
-                                   "coordinate system and consequently would correspond to "
-                                   "a sector of a cross section of the fluid filled space between two "
-                                   "infinite cylinders where one has made the assumption that "
-                                   "the velocity in direction of the cylinder axes is zero. "
-                                   "This is consistent with the definition of what we consider "
-                                   "the two-dimension case given in "
-                                   "Section~\\ref{sec:methods:2d-models}. "
-                                   "It is also possible to add initial topography to the chunk geometry, "
-                                   "based on an ascii data file. ")
-  }
-}
diff --git a/source/geometry_model/ellipsoidal_chunk.cc.bak b/source/geometry_model/ellipsoidal_chunk.cc.bak
deleted file mode 100644
index 94200b97708..00000000000
--- a/source/geometry_model/ellipsoidal_chunk.cc.bak
+++ /dev/null
@@ -1,833 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-#include <aspect/utilities.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/tria_accessor.h>
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/grid_tools.h>
-#include <boost/lexical_cast.hpp>
-#include <aspect/compat.h>
-
-
-/**
- * This geometry model implements an (3d) ellipsoidal_chunk geometry which can be non-coordinate parallel.
- * @author This plugin is a joint effort of Menno Fraters, D Sarah Stamps and Wolfgang Bangerth
- */
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    namespace
-    {
-      template <int dim>
-      void
-      set_manifold_ids(Triangulation<dim> &triangulation)
-      {
-        for (const auto &cell : triangulation.active_cell_iterators())
-          cell->set_all_manifold_ids (15);
-      }
-
-      template <int dim>
-      void
-      clear_manifold_ids(Triangulation<dim> &triangulation)
-      {
-        for (const auto &cell : triangulation.active_cell_iterators())
-          cell->set_all_manifold_ids (numbers::flat_manifold_id);
-      }
-    }
-
-
-    namespace internal
-    {
-      /*
-       * the EllipsoidalChunkGeometry class
-       */
-
-      // Constructor
-      template <int dim>
-      EllipsoidalChunkGeometry<dim>::EllipsoidalChunkGeometry(const InitialTopographyModel::Interface<dim> &topo,
-                                                              const double para_semi_major_axis_a,
-                                                              const double para_eccentricity,
-                                                              const double para_semi_minor_axis_b,
-                                                              const double para_bottom_depth,
-                                                              const std::vector<Point<2>> &para_corners)
-        :
-        topography (&topo),
-        semi_major_axis_a (para_semi_major_axis_a),
-        eccentricity (para_eccentricity),
-        semi_minor_axis_b (para_semi_minor_axis_b),
-        bottom_depth (para_bottom_depth),
-        corners (para_corners)
-      {
-        AssertThrow (dim == 3, ExcMessage("This manifold can currently only be used in 3d."));
-      }
-
-
-
-      template <int dim>
-      Point<3>
-      EllipsoidalChunkGeometry<dim>::push_forward_ellipsoid(const Point<3> &phi_theta_d, const double semi_major_axis_a, const double eccentricity) const
-      {
-        // The following converts phi, theta and negative depth to x, y, z
-        // Depth is measured perpendicular to the ellipsoid surface
-        // (i.e. along a vector which does not generally pass through the origin)
-        // Expressions can be found in Ellipsoidal and Cartesian Coordinates Conversion
-        // Subirana, Zornoza and Hernandez-Pajares, 2011:
-        // https://gssc.esa.int/navipedia/index.php/Ellipsoidal_and_Cartesian_Coordinates_Conversion
-
-        const double phi   = phi_theta_d[0]; // Longitude in radians
-        const double theta = phi_theta_d[1]; // Latitude in radians
-        const double d     = phi_theta_d[2]; // The negative depth (a depth of 10 meters is -10)
-
-        const double R_bar = semi_major_axis_a / std::sqrt(1 - (eccentricity * eccentricity *
-                                                                std::sin(theta) * std::sin(theta))); // radius of curvature of the prime vertical
-
-        return Point<3> ((R_bar + d) * std::cos(phi) * std::cos(theta),
-                         (R_bar + d) * std::sin(phi) * std::cos(theta),
-                         ((1 - eccentricity * eccentricity) * R_bar + d) * std::sin(theta));
-      }
-
-      template <int dim>
-      Point<3>
-      EllipsoidalChunkGeometry<dim>::pull_back_ellipsoid(const Point<3> &x, const double semi_major_axis_a, const double eccentricity) const
-      {
-        // The following converts x, y, z to phi, theta and negative depth
-        // Depth is measured perpendicular to the ellipsoid surface
-        // (i.e. along a vector which does not generally pass through the origin)
-        // Expressions can be found in Ellipsoidal and Cartesian Coordinates Conversion
-        // Subirana, Zornoza and Hernandez-Pajares, 2011:
-        // https://gssc.esa.int/navipedia/index.php/Ellipsoidal_and_Cartesian_Coordinates_Conversion
-
-        const double R      = semi_major_axis_a; // semi-major axis
-        const double b      = R * std::sqrt(1 - eccentricity * eccentricity); // semi-minor axis
-        const double p      = std::sqrt(x(0) * x(0) + x(1) * x(1)); // distance from origin projected onto x-y plane
-        const double th     = std::atan2(R * x(2), b * p); // starting guess for theta
-        const double phi    = std::atan2(x(1), x(0)); // azimuth (geodetic longitude)
-        const double theta  = std::atan2(x(2) + (R * R - b * b) / b * std::pow(std::sin(th),3),
-                                         (p - (eccentricity * eccentricity * R  * std::pow(std::cos(th),3)))); // first iterate for theta
-        const double R_bar  = R / (std::sqrt(1 - eccentricity * eccentricity * std::sin(theta) * std::sin(theta))); // first iterate for R_bar
-
-        Point<3> phi_theta_d;
-        phi_theta_d[0] = phi;
-
-        phi_theta_d[1] = theta;
-        phi_theta_d[2] = p / std::cos(theta) - R_bar; // first iterate for d
-        return phi_theta_d;
-      }
-
-      template <int dim>
-      Point<3>
-      EllipsoidalChunkGeometry<dim>::push_forward_topography(const Point<3> &phi_theta_d_hat) const
-      {
-        const double d_hat = phi_theta_d_hat[2]; // long, lat, depth
-        Point<dim-1> phi_theta;
-        if (dim == 3)
-          phi_theta = Point<dim-1>(phi_theta_d_hat[0] * constants::radians_to_degree,phi_theta_d_hat[1] * constants::radians_to_degree);
-        const double h = topography != nullptr ? topography->value(phi_theta) : 0;
-        const double d = d_hat + (d_hat + bottom_depth)/bottom_depth*h;
-        const Point<3> phi_theta_d (phi_theta_d_hat[0],
-                                    phi_theta_d_hat[1],
-                                    d);
-        return phi_theta_d;
-      }
-
-      template <int dim>
-      Point<3>
-      EllipsoidalChunkGeometry<dim>::pull_back_topography(const Point<3> &phi_theta_d) const
-      {
-        const double d = phi_theta_d[2];
-        Point<dim-1> phi_theta;
-        if (dim == 3)
-          phi_theta = Point<dim-1>(phi_theta_d[0] * constants::radians_to_degree,
-                                   phi_theta_d[1] * constants::radians_to_degree);
-        const double h = topography != nullptr ? topography->value(phi_theta) : 0;
-        const double d_hat = bottom_depth * (d-h)/(bottom_depth+h);
-        const Point<3> phi_theta_d_hat (phi_theta_d[0],
-                                        phi_theta_d[1],
-                                        d_hat);
-        return phi_theta_d_hat;
-      }
-
-      /**
-       * TODO: These functions (pull back and push forward) should be changed that they always
-       * take and return 3d points, because 2d points make no sense for an ellipsoid, even with
-       * a 2d triangulation. To do this correctly we need to add the spacedim to the triangulation
-       * in ASPECT. What is now presented is just a temporary fix to get access to the pull back
-       * function from outside. The push forward function can't be fixed in this way, because
-       * it is used by a bind statement.
-       */
-      template <int dim>
-      Point<3>
-      EllipsoidalChunkGeometry<dim>::pull_back(const Point<3> &space_point) const
-      {
-        return pull_back_topography(pull_back_ellipsoid (space_point, semi_major_axis_a, eccentricity));
-
-      }
-
-      template <int dim>
-      Point<2>
-      EllipsoidalChunkGeometry<dim>::pull_back(const Point<2> &space_point) const
-      {
-        return space_point;
-
-      }
-
-      template <int dim>
-      Point<3>
-      EllipsoidalChunkGeometry<dim>::push_forward(const Point<3> &chart_point) const
-      {
-        return push_forward_ellipsoid (push_forward_topography(chart_point), semi_major_axis_a, eccentricity);
-      }
-
-      template <int dim>
-      std::unique_ptr<Manifold<dim,3>>
-      EllipsoidalChunkGeometry<dim>::clone() const
-      {
-        return std::make_unique<EllipsoidalChunkGeometry>(*this);
-      }
-    }
-
-    template <int dim>
-    void
-    EllipsoidalChunk<dim>::initialize()
-    {
-      manifold = std::make_unique<internal::EllipsoidalChunkGeometry<dim>>(this->get_initial_topography_model(),
-                                                                            semi_major_axis_a,
-                                                                            eccentricity,
-                                                                            semi_minor_axis_b,
-                                                                            bottom_depth,
-                                                                            corners);
-    }
-
-
-
-    template <>
-    void
-    EllipsoidalChunk<3>::create_coarse_mesh(parallel::distributed::Triangulation<3> &coarse_grid) const
-    {
-      const int dim = 3;
-
-      // Generate parallelepiped grid with one point (point 0) at (0,0,0) and the
-      // other corners (respectively corner 1,2 and 4) placed relative to that point.
-      const Point<3> corner_points[dim] = {Point<dim>((corners[1][0]-corners[0][0])*constants::degree_to_radians,
-                                                      (corners[1][1]-corners[0][1])*constants::degree_to_radians,
-                                                      0),
-                                           Point<dim>((corners[3][0]-corners[0][0])*constants::degree_to_radians,
-                                                      (corners[3][1]-corners[0][1])*constants::degree_to_radians,
-                                                      0),
-                                           Point<dim>(0,
-                                                      0,
-                                                      bottom_depth)
-                                          };
-      const unsigned int  subdivisions[dim] = {EW_subdiv, NS_subdiv, depth_subdiv};
-
-      GridGenerator::subdivided_parallelepiped (coarse_grid, subdivisions, corner_points, true);
-
-      // Shift the grid point at (0,0,0) (and the rest of the
-      // points with it) to the correct location at corner[0] at a
-      // negative depth.
-      const Point<3> base_point(corners[0][0] * constants::degree_to_radians,
-                                corners[0][1] * constants::degree_to_radians,
-                                -bottom_depth);
-      GridTools::shift(base_point,coarse_grid);
-
-      // Transform to the ellipsoid surface
-      GridTools::transform (
-        [&](const Point<dim> &x) -> Point<dim>
-      {
-        return manifold->push_forward(x);
-      },
-      coarse_grid);
-
-      // Also attach the real manifold to slot 15 (arbitrarily chosen).
-      // We won't use it during regular operation, but we set manifold_ids for
-      // all cells, faces and edges immediately before refinement and
-      // clear it again afterwards
-      coarse_grid.set_manifold (15, *manifold);
-
-      coarse_grid.signals.pre_refinement.connect (
-        [&] {set_manifold_ids(coarse_grid);});
-      coarse_grid.signals.post_refinement.connect (
-        [&] {clear_manifold_ids(coarse_grid);});
-      coarse_grid.signals.post_refinement.connect (
-        [&] {this->set_boundary_ids(coarse_grid);});
-    }
-
-    template <int dim>
-    void
-    EllipsoidalChunk<dim>::create_coarse_mesh(parallel::distributed::Triangulation<dim> &/*coarse_grid*/) const
-    {
-      Assert(false, ExcNotImplemented());
-    }
-
-    template <int dim>
-    void
-    EllipsoidalChunk<dim>::set_boundary_ids(parallel::distributed::Triangulation<dim> &coarse_grid) const
-    {
-      // set all boundary indicators. we want the edges to be curved
-      // as well. for this, it matters in which order we call
-      // set_all_boundary_indicators() -- we have to do it last for
-      // the inner and outer boundary, which conveniently is what
-      // happens in the following loop
-      for (const auto &cell : coarse_grid.active_cell_iterators())
-        for (const unsigned int f : cell->face_indices())
-          if (cell->face(f)->at_boundary())
-            cell->face(f)->set_boundary_id(f);
-    }
-
-    template <int dim>
-    std::set<types::boundary_id>
-    EllipsoidalChunk<dim>::get_used_boundary_indicators() const
-    {
-      // boundary indicators are zero through 2*dim-1
-      std::set<types::boundary_id> s;
-      for (unsigned int i = 0; i < 2 * dim; ++i)
-        s.insert(i);
-      return s;
-    }
-
-    template <int dim>
-    std::map<std::string,types::boundary_id>
-    EllipsoidalChunk<dim>::
-    get_symbolic_boundary_names_map () const
-    {
-      switch (dim)
-        {
-          case 2:
-          {
-            return
-            {
-              {"east",   0},
-              {"west",   1},
-              {"bottom", 2},
-              {"top",    3}
-            };
-          }
-
-          case 3:
-          {
-            return
-            {
-              {"east",   0},
-              {"west",   1},
-              {"north",  2},
-              {"south",  3},
-              {"bottom", 4},
-              {"top",    5}
-            };
-          }
-        }
-
-      Assert (false, ExcNotImplemented());
-      return {};
-    }
-
-    template <int dim>
-    void
-    EllipsoidalChunk<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Ellipsoidal chunk");
-        {
-          prm.declare_entry("NE corner",
-                            "",
-                            Patterns::Anything(),
-                            "Longitude:latitude in degrees of the North-East corner point of model region."
-                            "The North-East direction is positive. If one of the three corners is not provided "
-                            "the missing corner value will be calculated so all faces are parallel.");
-          prm.declare_entry("NW corner",
-                            "",
-                            Patterns::Anything(),
-                            "Longitude:latitude in degrees of the North-West corner point of model region. "
-                            "The North-East direction is positive. If one of the three corners is not provided "
-                            "the missing corner value will be calculated so all faces are parallel.");
-          prm.declare_entry("SW corner",
-                            "",
-                            Patterns::Anything(),
-                            "Longitude:latitude in degrees of the South-West corner point of model region. "
-                            "The North-East direction is positive. If one of the three corners is not provided "
-                            "the missing corner value will be calculated so all faces are parallel.");
-          prm.declare_entry("SE corner",
-                            "",
-                            Patterns::Anything(),
-                            "Longitude:latitude in degrees of the South-East corner point of model region. "
-                            "The North-East direction is positive. If one of the three corners is not provided "
-                            "the missing corner value will be calculated so all faces are parallel.");
-          prm.declare_entry("Depth",
-                            "500000.0",
-                            Patterns::Double(0.),
-                            "Bottom depth of model region.");
-          prm.declare_entry("Semi-major axis",
-                            "6378137.0",
-                            Patterns::Double(0.),
-                            "The semi-major axis (a) of an ellipsoid. This is the radius for a sphere (eccentricity=0). Default WGS84 semi-major axis.");
-          prm.declare_entry("Eccentricity",
-                            "8.1819190842622e-2",
-                            Patterns::Double(0.),
-                            "Eccentricity of the ellipsoid. Zero is a perfect sphere, default (8.1819190842622e-2) is WGS84.");
-          prm.declare_entry("East-West subdivisions",
-                            "1",
-                            Patterns::Integer(0),
-                            "The number of subdivisions of the coarse (initial) mesh in the East-West direction.");
-          prm.declare_entry("North-South subdivisions",
-                            "1",
-                            Patterns::Integer(0),
-                            "The number of subdivisions of the coarse (initial) mesh in the North-South direction.");
-          prm.declare_entry("Depth subdivisions",
-                            "1",
-                            Patterns::Integer(0),
-                            "The number of subdivisions of the coarse (initial) mesh in depth.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    EllipsoidalChunk<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      AssertThrow (dim == 3, ExcMessage("This geometry can currently only be used in 3d."));
-
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Ellipsoidal chunk");
-        {
-          // Get latitude and longitudes defining region of interest from
-          // the parameter file.
-          corners.resize(4);
-          std::string NEcorner = prm.get("NE corner");
-          std::string NWcorner = prm.get("NW corner");
-          std::string SWcorner = prm.get("SW corner");
-          std::string SEcorner = prm.get("SE corner");
-
-          // make a list of what corners are present and check that there should be one or two corner missing,
-          // otherwise throw an exception
-          std::vector<bool> present(4,true);
-          unsigned int missing = 0;
-          if (NEcorner == "")
-            {
-              ++missing;
-              present[0] = false;
-            }
-          if (NWcorner == "")
-            {
-              ++missing;
-              present[1] = false;
-            }
-          if (SWcorner == "")
-            {
-              ++missing;
-              present[2] = false;
-            }
-          if (SEcorner == "")
-            {
-              ++missing;
-              present[3] = false;
-            }
-
-          AssertThrow (missing != 0,
-                       ExcMessage ("Only two or three of the four corner points should be provided."));
-          AssertThrow (missing == 1 || missing == 2,
-                       ExcMessage ("Please provide two or three corner points."));
-
-          std::vector<double> temp;
-
-          if (present[0])
-            {
-              temp = Utilities::string_to_double(Utilities::split_string_list(NEcorner,':'));
-              AssertThrow (temp.size() == 2, ExcMessage ("Two coordinates should be given for the NE-corner (longitude:latitude)."));
-              corners[0] = Point<2>(temp[0],temp[1]);
-            }
-          else
-            corners[0]= Point<2>();
-
-          if (present[1])
-            {
-              temp = Utilities::string_to_double(Utilities::split_string_list(NWcorner,':'));
-              AssertThrow (temp.size() == 2, ExcMessage ("Two coordinates should be given for the NW-corner (longitude:latitude)."));
-              corners[1] = Point<2>(temp[0],temp[1]);
-            }
-          else
-            corners[1]= Point<2>();
-
-          if (present[2])
-            {
-              temp = Utilities::string_to_double(Utilities::split_string_list(SWcorner,':'));
-              AssertThrow (temp.size() == 2, ExcMessage ("Two coordinates should be given for the SW-corner (longitude:latitude)."));
-              corners[2] = Point<2>(temp[0],temp[1]);
-            }
-          else
-            corners[2]= Point<2>();
-
-          if (present[3])
-            {
-              temp = Utilities::string_to_double(Utilities::split_string_list(SEcorner,':'));
-              AssertThrow (temp.size() == 2, ExcMessage ("Two coordinates should be given for the SE-corner (longitude:latitude)."));
-              corners[3] = Point<2>(temp[0],temp[1]);
-            }
-          else
-            corners[3]= Point<2>();
-
-
-          bottom_depth = prm.get_double("Depth");
-          semi_major_axis_a = prm.get_double("Semi-major axis");
-          eccentricity = prm.get_double("Eccentricity");
-          semi_minor_axis_b = std::sqrt((1 - pow(eccentricity,2.)) * pow(semi_major_axis_a,2.));
-          EW_subdiv = prm.get_integer("East-West subdivisions");
-          NS_subdiv = prm.get_integer("North-South subdivisions");
-          depth_subdiv = prm.get_integer("Depth subdivisions");
-
-          // Check whether the corners of the rectangle are really placed correctly
-          if (present[0] == true && present[1] == true)
-            {
-              AssertThrow (corners[0][0] >= corners[1][0],
-                           ExcMessage ("The longitude of the NE corner (" + boost::lexical_cast<std::string>(corners[0][0]) + ") cannot be smaller than the longitude of the NW corner (" + boost::lexical_cast<std::string>(corners[1][0]) + ")."));
-            }
-          if (present[0] == true && present[3] == true)
-            {
-              AssertThrow (corners[0][1] >= corners[3][1],
-                           ExcMessage ("The latitude of the NE (" + boost::lexical_cast<std::string>(corners[0][1]) + ") corner cannot be smaller than the latitude of the SE corner (" + boost::lexical_cast<std::string>(corners[3][1]) + ")."));
-            }
-          if (present[2] == true && present[3] == true)
-            {
-              AssertThrow (corners[2][0] <= corners[3][0],
-                           ExcMessage ("The longitude of the SW (" + boost::lexical_cast<std::string>(corners[2][0]) + ") corner cannot be larger than the longitude of the SE corner (" + boost::lexical_cast<std::string>(corners[3][0]) + ")."));
-            }
-          if (present[2] == true && present[1] == true)
-            {
-              AssertThrow (corners[2][1] <= corners[1][1],
-                           ExcMessage ("The latitude of the SW corner (" + boost::lexical_cast<std::string>(corners[2][1]) + ") cannot be larger than the latitude of the NW corner (" + boost::lexical_cast<std::string>(corners[1][1]) + ")."));
-            }
-          if (missing == 2)
-            {
-              AssertThrow ((present[0] == true && present[2] == true) || (present[1] == true && present[3] == true),
-                           ExcMessage ("Please provide two opposing corners."));
-
-              if (present[0] == true && present[2] == true)
-                AssertThrow (corners[0][0] > corners[2][0] && corners[0][1] > corners[2][1],
-                             ExcMessage ("The Northeast corner (" + boost::lexical_cast<std::string>(corners[0][0]) + ":"  + boost::lexical_cast<std::string>(corners[0][1]) + ") must be strictly north and east of the Southwest corner (" + boost::lexical_cast<std::string>(corners[2][0]) + ":"  + boost::lexical_cast<std::string>(corners[2][1]) + ") when only two points are given."));
-
-              if (present[1] == true && present[3] == true)
-                AssertThrow (corners[1][0] < corners[3][0] && corners[1][1] > corners[3][1],
-                             ExcMessage ("The Northwest corner (" + boost::lexical_cast<std::string>(corners[1][0]) + ":"  + boost::lexical_cast<std::string>(corners[1][1]) + ") must be strictly north and west of the Southeast corner (" + boost::lexical_cast<std::string>(corners[3][0]) + ":"  + boost::lexical_cast<std::string>(corners[3][1]) + ") when only two points are given."));
-            }
-
-
-          // If one or two of the corners is not provided, calculate it.
-          if (missing == 1)
-            {
-              for (unsigned int i = 0; i <= 3; ++i)
-                {
-                  // find the corner which is missing, if there is one
-                  if (present[i] == false)
-                    {
-                      // find the location of this corner
-                      // the values for the values is:
-                      // [i] = [i+1] + ([i+3] - [i+2])
-                      unsigned int ip = i + 1;
-                      unsigned int ipp = i + 2;
-                      unsigned int ippp = i + 3;
-
-                      if (ip > 3)
-                        ip -= 4;
-                      if (ipp > 3)
-                        ipp -= 4;
-                      if (ippp > 3)
-                        ippp -=4;
-
-                      corners[i] = corners[ip];
-                      corners[i][0] = corners[ip][0] + (corners[ippp][0] - corners[ipp][0]);
-                      corners[i][1] = corners[ip][1] + (corners[ippp][1] - corners[ipp][1]);
-                    }
-                }
-            }
-          else if (missing == 2)
-            {
-              // find the location of this corner
-              if (present[0] == false)
-                {
-                  corners[0] = corners[1];
-                  corners[2] = corners[3];
-                  corners[0][0] = corners[3][0];
-                  corners[2][0] = corners[1][0];
-                }
-              else
-                {
-                  corners[1] = corners[0];
-                  corners[3] = corners[2];
-                  corners[1][0] = corners[2][0];
-                  corners[3][0] = corners[0][0];
-                }
-            }
-          // Check that the calculated corners also obey the rules for the location of the corners.
-          Assert (corners[0][0] >= corners[1][0],
-                  ExcMessage ("The longitude of the NE corner (" + boost::lexical_cast<std::string>(corners[0][0]) + ") cannot be smaller than the longitude of the NW corner (" + boost::lexical_cast<std::string>(corners[1][0]) + "). This is an internal check, if you see this please contact the developer."));
-
-          Assert (corners[0][1] >= corners[3][1],
-                  ExcMessage ("The latitude of the NE (" + boost::lexical_cast<std::string>(corners[0][1]) + ") corner cannot be smaller than the latitude of the SE corner (" + boost::lexical_cast<std::string>(corners[3][1]) + "). This is an internal check, if you see this please contact the developer."));
-
-          Assert (corners[2][0] <= corners[3][0],
-                  ExcMessage ("The longitude of the SW (" + boost::lexical_cast<std::string>(corners[2][0]) + ") corner cannot be larger than the longitude of the SE corner (" + boost::lexical_cast<std::string>(corners[3][0]) + "). This is an internal check, if you see this please contact the developer."));
-
-          Assert (corners[2][1] <= corners[1][1],
-                  ExcMessage ("The latitude of the SW corner (" + boost::lexical_cast<std::string>(corners[2][1]) + ") cannot be larger than the latitude of the NW corner (" + boost::lexical_cast<std::string>(corners[1][1]) + "). This is an internal check, if you see this please contact the developer."));
-
-          westLongitude = corners[2][0];
-          eastLongitude = corners[0][0];
-          northLatitude = corners[0][1];
-          southLatitude = corners[2][1];
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    double
-    EllipsoidalChunk<dim>::depth(const Point<dim> &position) const
-    {
-      return std::max(std::min(-manifold->pull_back(position)[dim-1], maximal_depth()), 0.0);
-    }
-
-    template <int dim>
-    double
-    EllipsoidalChunk<dim>::height_above_reference_surface(const Point<dim> &/*position*/) const
-    {
-      AssertThrow(false, ExcMessage("Function height_above_reference_surface is not yet implemented "
-                                    "for the ellipsoidal chunk geometry model. "
-                                    "Consider using a box, spherical shell, or chunk.") );
-      return numbers::signaling_nan<double>();
-    }
-
-
-    template <int dim>
-    double
-    EllipsoidalChunk<dim>::maximal_depth() const
-    {
-      return bottom_depth;
-    }
-
-    template <int dim>
-    double
-    EllipsoidalChunk<dim>::get_radius(const Point<dim> &position) const
-    {
-      const Point<dim> long_lat_depth = manifold->pull_back(position);
-      return semi_major_axis_a / (std::sqrt(1 - eccentricity * eccentricity * std::sin(long_lat_depth[1]) * std::sin(long_lat_depth[1])));
-    }
-
-    template <int dim>
-    double
-    EllipsoidalChunk<dim>::get_eccentricity() const
-    {
-      return eccentricity;
-    }
-
-    template <int dim>
-    const std::vector<Point<2>> &
-    EllipsoidalChunk<dim>::get_corners() const
-    {
-      return corners;
-    }
-
-    template <int dim>
-    double
-    EllipsoidalChunk<dim>::get_semi_minor_axis_b() const
-    {
-      return semi_minor_axis_b;
-    }
-
-    template <int dim>
-    double
-    EllipsoidalChunk<dim>::get_semi_major_axis_a() const
-    {
-      return semi_major_axis_a;
-    }
-
-
-    template <int dim>
-    double
-    EllipsoidalChunk<dim>::length_scale() const
-    {
-      // As described in the first ASPECT paper, a length scale of
-      // 10km = 1e4m works well for the pressure scaling for earth
-      // sized spherical shells. use a length scale that
-      // yields this value for the R0,R1 corresponding to earth
-      // but otherwise scales like (R1-R0)
-      return 1e4 * maximal_depth() / (6336000.-3481000.);
-    }
-
-    template <int dim>
-    Point<dim>
-    EllipsoidalChunk<dim>::representative_point(const double /*depth*/) const
-    {
-      return Point<dim>();
-    }
-
-    template <>
-    Point<3>
-    EllipsoidalChunk<3>::representative_point(const double depth) const
-    {
-      const int dim = 3;
-      Assert(depth >= 0, ExcMessage("Given depth must be positive or zero."));
-      Assert(depth <= maximal_depth(),
-             ExcMessage("Given depth must be less than or equal to the maximal depth of this geometry."));
-
-      // Choose a point on the center axis of the domain
-      Point<dim> p = Point<3>((eastLongitude + westLongitude) * 0.5 * constants::degree_to_radians,
-                              (southLatitude + northLatitude) * 0.5 * constants::degree_to_radians,
-                              -depth);
-
-      return manifold->push_forward(p);
-    }
-
-
-    template <int dim>
-    bool
-    EllipsoidalChunk<dim>::point_is_in_domain(const Point<dim> &point) const
-    {
-      AssertThrow(!this->get_parameters().mesh_deformation_enabled ||
-                  this->get_timestep_number() == 0,
-                  ExcMessage("After displacement of the mesh, this function can no longer be used to determine whether a point lies in the domain or not."));
-
-      // dim = 3
-      const Point<dim> ellipsoidal_point = manifold->pull_back(point);
-
-      // compare deflection from the ellipsoid surface
-      if (ellipsoidal_point[dim-1] > 0.0+std::numeric_limits<double>::epsilon()*bottom_depth ||
-          -ellipsoidal_point[dim-1] > bottom_depth+std::numeric_limits<double>::epsilon()*bottom_depth)
-        return false;
-
-      // compare lon/lat
-      if (!Utilities::polygon_contains_point<dim>(corners, Point<2>(ellipsoidal_point[0]*constants::radians_to_degree,ellipsoidal_point[1]*constants::radians_to_degree)))
-        return false;
-
-      return true;
-    }
-
-    template <int dim>
-    std::array<double,dim>
-    EllipsoidalChunk<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
-    {
-      // the chunk manifold works internally with a vector with longitude, latitude, depth.
-      // We need to output radius, longitude, latitude to be consistent.
-      // Ignore the topography by calling pull_back_ellipsoid to avoid a loop when calling the
-      // AsciiDataBoundary for topography which uses this function....
-      Point<3> cartesian_point;
-      for (unsigned int d=0; d<dim; ++d)
-        cartesian_point[d] = position_point[d];
-
-      Point<3> transformed_point = manifold->pull_back_ellipsoid(cartesian_point, semi_major_axis_a, eccentricity);
-
-      const double radius =  semi_major_axis_a /
-                             (std::sqrt(1 - eccentricity * eccentricity * std::sin(transformed_point[1]) * std::sin(transformed_point[1])));
-      std::array<double,dim> position_array;
-      position_array[0] = radius + transformed_point(2);
-      position_array[1] = transformed_point(0);
-      position_array[2] = transformed_point(1);
-
-      return position_array;
-    }
-
-
-    template <int dim>
-    aspect::Utilities::Coordinates::CoordinateSystem
-    EllipsoidalChunk<dim>::natural_coordinate_system() const
-    {
-      return aspect::Utilities::Coordinates::CoordinateSystem::ellipsoidal;
-    }
-
-
-    template <>
-    Point<3>
-    EllipsoidalChunk<3>::natural_to_cartesian_coordinates(const std::array<double,3> &position_tensor) const
-    {
-      // We receive radius, longitude, latitude and we need to turn it first back into
-      // longitude, latitude, depth for internal use, and push_forward to cartesian coordinates.
-      // Ignore the topography by calling push_forward_ellipsoid to avoid a loop when calling the
-      // AsciiDataBoundary for topography which uses this function....
-      Point<3> position_point;
-      position_point(0) = position_tensor[1];
-      position_point(1) = position_tensor[2];
-
-      const double radius = semi_major_axis_a / (std::sqrt(1 - eccentricity * eccentricity * std::sin(position_point(1)) * std::sin(position_point(1))));
-      position_point(2) = position_tensor[0] - radius;
-
-      Point<3> transformed_point = manifold->push_forward_ellipsoid(position_point, semi_major_axis_a, eccentricity);
-      return transformed_point;
-    }
-
-
-    template <>
-    Point<2>
-    EllipsoidalChunk<2>::natural_to_cartesian_coordinates(const std::array<double,2> &/*position_tensor*/) const
-    {
-      Assert(false, ExcMessage("This geometry model doesn't support 2d."));
-      return {};
-    }
-
-  }
-}
-
-template <int dim>
-typename aspect::GeometryModel::internal::EllipsoidalChunkGeometry<dim>
-aspect::GeometryModel::EllipsoidalChunk<dim>::get_manifold() const
-{
-  return *manifold;
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    namespace internal
-    {
-#define INSTANTIATE(dim) \
-  template class EllipsoidalChunkGeometry<dim>;
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-
-    ASPECT_REGISTER_GEOMETRY_MODEL(EllipsoidalChunk,
-                                   "ellipsoidal chunk",
-                                   "A 3d chunk geometry that accounts for Earth's ellipticity (default assuming the "
-                                   "WGS84 ellipsoid definition) which can be defined in non-coordinate directions. "
-                                   "In the description of the ellipsoidal chunk, two of the ellipsoidal axes have the "
-                                   "same length so that there is only a semi-major axis and a semi-minor axis. "
-                                   "The user has two options for creating an ellipsoidal chunk geometry: 1) by defining "
-                                   "two opposing points (SW and NE or NW and SE) a coordinate parallel ellipsoidal "
-                                   "chunk geometry will be created. 2) by defining three points a non-coordinate "
-                                   "parallel ellipsoidal chunk will be created. The points are defined in the input "
-                                   "file by longitude:latitude. It is also possible to define additional subdivisions "
-                                   "of the mesh in each direction. The boundary of the domain is formed by linear "
-                                   "interpolation in longitude-latitude space between adjacent points "
-                                   "(i.e. $[lon, lat](f) = [lon1 \\cdot f + lon2 \\cdot(1-f), lat1 \\cdot f + lat2 \\cdot (1-f)]$, "
-                                   "where f is a value between 0 and 1). Faces of the model are defined as "
-                                   "0, west; 1,east; 2, south; 3, north; 4, inner; 5, outer.\n\n"
-                                   "This geometry model supports initial topography for deforming the initial mesh.")
-  }
-}
diff --git a/source/geometry_model/initial_topography_model/ascii_data.cc.bak b/source/geometry_model/initial_topography_model/ascii_data.cc.bak
deleted file mode 100644
index 121128a23ba..00000000000
--- a/source/geometry_model/initial_topography_model/ascii_data.cc.bak
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/geometry_model/initial_topography_model/ascii_data.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/chunk.h>
-
-#include <deal.II/base/parameter_handler.h>
-#include <array>
-
-
-
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      :
-      surface_boundary_id(1)
-    {}
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-      Utilities::AsciiDataBoundary<dim>::initialize({surface_boundary_id},
-                                                    1);
-    }
-
-
-    template <int dim>
-    double
-    AsciiData<dim>::value (const Point<dim-1> &surface_point) const
-    {
-      // In a first step, create a global 'dim'-dimensional point that we can pass to the
-      // function expression as input -- because the function is a dim-dimensional
-      // function.
-      //
-      // Different geometry models pass the surface point in in different ways.
-      // In the following, we will first normalize the input to a dim-dimensional
-      // point with a dummy vertical/radial coordinate that, one would hope,
-      // the AsciiDataBoundary class will then simply ignore.
-      Point<dim> global_point;
-      if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()) ||
-          Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
-        {
-          for (unsigned int d=0; d<dim-1; ++d)
-            global_point[d] = surface_point[d];
-
-          // Now for the vertical component:
-          global_point[dim-1] = 0;
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()) ||
-               Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()) ||
-               Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
-        {
-          // AsciiDataBoundary always expects to get the input
-          // parameters for its functions in Cartesian
-          // coordinates. The get_data_component function then changes
-          // the coordinate system, or more precisely it asks the
-          // geometry model to convert the point into its natural
-          // coordinate system, before doing the table lookup.
-          //
-          // This is of course all not very efficient (TODO: Think
-          // about a better scheme), but the first step then needs to
-          // be to convert what we have into Cartesian coordinates...
-          std::array<double, dim> point;
-          point[0] = 6371000.0;
-          for (unsigned int d=0; d<dim-1; ++d)
-            point[d+1] = surface_point[d];
-
-          global_point = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(point);
-        }
-      else
-        AssertThrow(false, ExcNotImplemented());
-
-      const double topo = this->Utilities::AsciiDataBoundary<dim>::get_data_component(surface_boundary_id,
-                                                                                      global_point,
-                                                                                      0);
-
-      return topo;
-    }
-
-
-
-    template <int dim>
-    Tensor<1,dim-1>
-    AsciiData<dim>::vector_gradient(const Point<dim> &point) const
-    {
-      return Utilities::AsciiDataBoundary<dim>::vector_gradient(surface_boundary_id, point,0);
-    }
-
-
-
-    template <int dim>
-    double
-    AsciiData<dim>::max_topography () const
-    {
-      return Utilities::AsciiDataBoundary<dim>::get_maximum_component_value(surface_boundary_id,0);
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Initial topography model");
-        {
-          Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                            "$ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/",
-                                                            "box_2d_%s.0.txt");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Initial topography model");
-        {
-          Utilities::AsciiDataBase<dim>::parse_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(AsciiData,
-                                             "ascii data",
-                                             "Implementation of a model in which the surface "
-                                             "topography is derived from a file containing data "
-                                             "in ascii format. The following geometry models "
-                                             "are currently supported: box, chunk. "
-                                             "Note the required format of the "
-                                             "input data: The first lines may contain any number of comments "
-                                             "if they begin with `#', but one of these lines needs to "
-                                             "contain the number of grid points in each dimension as "
-                                             "for example `# POINTS: 3 3'. "
-                                             "The order of the data columns "
-                                             "has to be `x', `Topography [m]' in a 2d model and "
-                                             " `x', `y', `Topography [m]' in a 3d model, which means that "
-                                             "there has to be a single column "
-                                             "containing the topography. "
-                                             "Note that the data in the input "
-                                             "file needs to be sorted in a specific order: "
-                                             "the first coordinate needs to ascend first, "
-                                             "followed by the second in order to "
-                                             "assign the correct data to the prescribed coordinates. "
-                                             "If you use a spherical model, "
-                                             "then the assumed grid changes. "
-                                             "`x' will be replaced by the azimuth angle (longitude) "
-                                             "in radians (between zero and $2\\pi$, not between $-\\pi$ "
-                                             "corresponding to 180 degrees west, and $+\\pi$ corresponding "
-                                             "to 180 degrees east), "
-                                             "and `y' by the polar angle in radians (between $0$ and $\\pi$) measured "
-                                             "positive from the north pole. The grid will be assumed to be "
-                                             "a longitude-colatitude grid. Note that the order "
-                                             "of spherical coordinates is `phi', `theta' "
-                                             "and not `theta', `phi', since this allows "
-                                             "for dimension independent expressions.")
-  }
-}
diff --git a/source/geometry_model/initial_topography_model/function.cc.bak b/source/geometry_model/initial_topography_model/function.cc.bak
deleted file mode 100644
index 39b15e95768..00000000000
--- a/source/geometry_model/initial_topography_model/function.cc.bak
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/initial_topography_model/function.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/chunk.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    template <int dim>
-    Function<dim>::Function ()
-      :
-      max_topo(0),
-      initial_topography_function (1),
-      coordinate_system(Utilities::Coordinates::CoordinateSystem::cartesian)
-    {}
-
-
-
-    template <int dim>
-    double
-    Function<dim>::
-    value (const Point<dim-1> &surface_point) const
-    {
-      // In a first step, create a global 'dim'-dimensional point that we can pass to the
-      // function expression as input -- because the function is a dim-dimensional
-      // function.
-      //
-      // Different geometry models pass the surface point in in different ways.
-      // In the following, we will first normalize the input to a dim-dimensional
-      // point with a dummy vertical/radial coordinate that, one would hope,
-      // the function expression will then simply ignore.
-      Point<dim> global_point;
-
-      if (Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
-          Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
-        {
-          for (unsigned int d=0; d<dim-1; ++d)
-            global_point[d] = surface_point[d];
-
-          // Now for the vertical component:
-          global_point[dim-1] = 0;
-
-          // The point as it is would have to be translated into a different
-          // coordinate system if that was requested in the input file.
-          // This is not currently implemented.
-          Assert (coordinate_system == Utilities::Coordinates::CoordinateSystem::cartesian,
-                  ExcNotImplemented());
-        }
-      else if (Plugins::plugin_type_matches<GeometryModel::Sphere<dim>>(this->get_geometry_model()) ||
-               Plugins::plugin_type_matches<GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) ||
-               Plugins::plugin_type_matches<GeometryModel::Chunk<dim>>(this->get_geometry_model()) )
-        {
-          std::array<double, dim> point;
-          point[0] = 6371000.0;
-          for (unsigned int d=0; d<dim-1; ++d)
-            point[d+1] = surface_point[d];
-
-          global_point = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(point);
-
-          // The point as it is would have to be translated into a different
-          // coordinate system (or, perhaps, better just left in the spherical
-          // coordinates we received) if that was requested in the input file.
-          // This is not currently implemented.
-          Assert (coordinate_system == Utilities::Coordinates::CoordinateSystem::cartesian,
-                  ExcNotImplemented());
-        }
-      else
-        AssertThrow(false, ExcNotImplemented());
-
-      const double topo = initial_topography_function.value(global_point);
-
-      return topo;
-    }
-
-
-    template <int dim>
-    double
-    Function<dim>::
-    max_topography () const
-    {
-      return max_topo;
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Initial topography model");
-        {
-          prm.enter_subsection("Function");
-          {
-            prm.declare_entry ("Maximum topography value", "2000.",
-                               Patterns::Double (0.),
-                               "The maximum value the topography given by "
-                               "the function can take. ");
-            prm.declare_entry ("Coordinate system", "cartesian",
-                               Patterns::Selection ("cartesian|spherical"),
-                               "A selection that determines the assumed coordinate "
-                               "system for the function variables. Allowed values "
-                               "are `cartesian' and `spherical'. `spherical' coordinates "
-                               "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                               "respectively with theta being the polar angle. ");
-
-            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Initial topography model");
-        {
-          prm.enter_subsection("Function");
-          {
-            coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-          }
-          max_topo = prm.get_double("Maximum topography value");
-          try
-            {
-              initial_topography_function.parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Boundary traction model.Function'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(Function,
-                                             "function",
-                                             "Implementation of a model in which the initial topography "
-                                             "is described by a function in Cartesian or spherical coordinates. ")
-  }
-}
diff --git a/source/geometry_model/initial_topography_model/interface.cc.bak b/source/geometry_model/initial_topography_model/interface.cc.bak
deleted file mode 100644
index f056b45c7f0..00000000000
--- a/source/geometry_model/initial_topography_model/interface.cc.bak
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-#include <list>
-
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-// -------------------------------- Deal with registering initial topography models and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      internal::Plugins::PluginList<Interface<2>>,
-      internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    register_initial_topography_model (const std::string &name,
-                                       const std::string &description,
-                                       void (*declare_parameters_function) (ParameterHandler &),
-                                       std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_initial_topography_model (ParameterHandler &prm)
-    {
-      std::string model_name;
-      prm.enter_subsection ("Geometry model");
-      {
-        prm.enter_subsection ("Initial topography model");
-        {
-          model_name = prm.get ("Model name");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      // If one sets the model name to an empty string in the input file,
-      // ParameterHandler produces an error while reading the file. However,
-      // if one omits specifying any model name at all (not even setting it to
-      // the empty string) then the value we get here is the empty string. If
-      // we don't catch this case here, we end up with awkward downstream
-      // errors because the value obviously does not conform to the Pattern.
-      AssertThrow(model_name != "unspecified",
-                  ExcMessage("You need to select a Initial topography model "
-                             "(`set Model name' in `subsection Initial topography model')."));
-
-      return std::get<dim>(registered_plugins).create_plugin (model_name,
-                                                              "Initial topography model::model name",
-                                                              prm);
-    }
-
-
-
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm)
-    {
-      // declare the entry in the parameter file
-      prm.enter_subsection ("Geometry model");
-      {
-        prm.enter_subsection ("Initial topography model");
-        {
-          const std::string pattern_of_names
-            = std::get<dim>(registered_plugins).get_pattern_of_names ();
-          prm.declare_entry ("Model name", "zero topography",
-                             Patterns::Selection (pattern_of_names),
-                             "Select one of the following models:\n\n"
-                             +
-                             std::get<dim>(registered_plugins).get_description_string());
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Initial topography interface",
-                                                            out);
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<InitialTopographyModel::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<InitialTopographyModel::Interface<2>>::plugins = nullptr;
-
-      template <>
-      std::list<internal::Plugins::PluginList<InitialTopographyModel::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<InitialTopographyModel::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace InitialTopographyModel
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_initial_topography_model<dim> (const std::string &, \
-                                          const std::string &, \
-                                          void ( *) (ParameterHandler &), \
-                                          std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_initial_topography_model<dim> (ParameterHandler &prm);
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/geometry_model/initial_topography_model/prm_polygon.cc.bak b/source/geometry_model/initial_topography_model/prm_polygon.cc.bak
deleted file mode 100644
index 6de5df06e5c..00000000000
--- a/source/geometry_model/initial_topography_model/prm_polygon.cc.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/geometry_model/initial_topography_model/prm_polygon.h>
-#include <aspect/utilities.h>
-#include <boost/lexical_cast.hpp>
-
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    template <int dim>
-    double
-    PrmPolygon<dim>::
-    value (const Point<dim-1> &p) const
-    {
-      const Point<2> p1 = (dim == 2 ? Point<2>(p[0],0) : Point<2>(p[0],p[1]));
-
-      /**
-       * We go through the loop in the reverse order, because we
-       * want the last entry in the list to prescribe the value.
-       */
-      for (unsigned int i = point_lists.size(); i > 0; i--)
-        {
-          if (aspect::Utilities::polygon_contains_point<dim>(point_lists[i-1],p1))
-            {
-              return topography_values[i-1];
-            }
-        }
-
-      // Point is not in any of the polygons. Return zero.
-      return 0;
-    }
-
-
-
-    template <int dim>
-    double
-    PrmPolygon<dim>::
-    max_topography () const
-    {
-      return maximum_topography;
-    }
-
-
-
-    template <int dim>
-    void
-    PrmPolygon<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Initial topography model");
-        {
-          prm.enter_subsection("Prm polygon");
-          {
-            prm.declare_entry("Topography parameters",
-                              "",
-                              Patterns::Anything(),
-                              "Set the topography height and the polygon which should be set to that height. "
-                              "The format is : \"The topography height \textgreater The point list describing "
-                              "a polygon \\& The next topography height \textgreater the next point list "
-                              "describing a polygon.\" The format for the point list describing the polygon is "
-                              "\"x1,y1;x2,y2\". For example for two triangular areas of 100 and -100 meters high "
-                              "set: '100 \textgreater 0,0;5,5;0,10 \\& -100 \textgreater 10,10;10,15;20,15'. "
-                              "Units of the height are always in meters. The units of the coordinates are "
-                              "dependent on the geometry model. In the box model they are in meters, in the "
-                              "chunks they are in degrees, etc. Please refer to the manual of the individual "
-                              "geometry model to so see how the topography is implemented.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    PrmPolygon<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Initial topography model");
-        {
-          prm.enter_subsection("Prm polygon");
-          {
-            /**
-             * we need to fill the point lists and topography values. They
-             * are stored in the Topography subsection in the Topography parameter.
-             */
-            maximum_topography = std::numeric_limits<double>::lowest();
-            const std::string temptopo = prm.get("Topography parameters");
-            const std::vector<std::string> temp_topographies = Utilities::split_string_list(temptopo,'&');
-            const unsigned int temp_topographies_size = temp_topographies.size();
-
-            topography_values.resize(temp_topographies_size,0);
-            point_lists.resize(temp_topographies_size);
-            for (unsigned int i_topo = 0; i_topo < temp_topographies_size; ++i_topo)
-              {
-                const std::vector<std::string> temp_topography = Utilities::split_string_list(temp_topographies[i_topo],'>');
-                Assert(temp_topography.size() == 2,ExcMessage ("The given line '" + temp_topographies[i_topo]
-                                                               + "' is not correct. It consists of "
-                                                               + boost::lexical_cast<std::string>(temp_topography.size())
-                                                               + " parts separated by >, but it should only contain "
-                                                               "two parts: the height and the list of point coordinates,"
-                                                               " separated by a >.'"));
-
-                topography_values[i_topo] = Utilities::string_to_double(temp_topography[0]);
-                maximum_topography = std::max(topography_values[i_topo],maximum_topography);
-
-                const std::vector<std::string> temp_coordinates = Utilities::split_string_list(temp_topography[1],';');
-                const unsigned int temp_coordinate_size = temp_coordinates.size();
-                point_lists[i_topo].resize(temp_coordinate_size);
-                for (unsigned int i_coord = 0; i_coord < temp_coordinate_size; ++i_coord)
-                  {
-                    const std::vector<double> temp_point = Utilities::string_to_double(Utilities::split_string_list(temp_coordinates[i_coord],','));
-                    Assert(temp_point.size() == 2,ExcMessage ("The given coordinate '" + temp_coordinates[i_coord] + "' is not correct. "
-                                                              "It consists of " + boost::lexical_cast<std::string>(temp_topography.size())
-                                                              + " parts separated by :, but it should only contain 2 parts: "
-                                                              "the two coordinates of the polygon points, separated by a ','."));
-
-
-                    point_lists[i_topo][i_coord] = Point<2>(temp_point[0], temp_point[1]);
-                  }
-
-              }
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(PrmPolygon,
-                                             "prm polygon",
-                                             "An initial topography model that defines the initial topography "
-                                             "as constant inside each of a set of polygonal parts of the "
-                                             "surface. The polygons, and their associated surface elevation, "
-                                             "are defined in the `Geometry model/Initial topography/Prm polygon' "
-                                             "section.")
-  }
-}
diff --git a/source/geometry_model/initial_topography_model/zero_topography.cc.bak b/source/geometry_model/initial_topography_model/zero_topography.cc.bak
deleted file mode 100644
index 3ed908aad28..00000000000
--- a/source/geometry_model/initial_topography_model/zero_topography.cc.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-
-
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    template <int dim>
-    double
-    ZeroTopography<dim>::
-    value (const Point<dim-1> &/*p*/) const
-    {
-      // return a zero value regardless of position
-      return 0.0;
-    }
-
-    template <int dim>
-    double
-    ZeroTopography<dim>::
-    max_topography () const
-    {
-      return 0;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTopographyModel
-  {
-    ASPECT_REGISTER_INITIAL_TOPOGRAPHY_MODEL(ZeroTopography,
-                                             "zero topography",
-                                             "Implementation of a model in which the initial topography "
-                                             "is zero. ")
-  }
-}
diff --git a/source/geometry_model/interface.cc.bak b/source/geometry_model/interface.cc.bak
deleted file mode 100644
index 0f977683d3b..00000000000
--- a/source/geometry_model/interface.cc.bak
+++ /dev/null
@@ -1,368 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/base/utilities.h>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    template <int dim>
-    std::map<std::string,types::boundary_id>
-    Interface<dim>::get_symbolic_boundary_names_map() const
-    {
-      // return an empty map in the base class
-      return {};
-    }
-
-
-
-    template <int dim>
-    std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
-    Interface<dim>::get_periodic_boundary_pairs() const
-    {
-      // return an empty set in the base class
-      return {};
-    }
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::adjust_positions_for_periodicity (Point<dim> &/*position*/,
-                                                      const ArrayView<Point<dim>> &/*connected_positions*/,
-                                                      const ArrayView<Tensor<1, dim>> &/*connected_velocities*/) const
-    {
-      AssertThrow(false,
-                  ExcMessage("Positions cannot be adjusted for periodicity in the chosen geometry model."));
-      return;
-    }
-
-
-
-    template <int dim>
-    bool
-    Interface<dim>::has_curved_elements() const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    std::array<double,dim>
-    Interface<dim>::cartesian_to_natural_coordinates(const Point<dim> &) const
-    {
-      Assert (false,
-              ExcMessage ("The cartesian_to_natural_coordinates function has "
-                          "not been implemented in this geometry model."));
-      return {};
-    }
-
-
-    template <int dim>
-    Utilities::NaturalCoordinate<dim>
-    Interface<dim>::cartesian_to_other_coordinates(const Point<dim> &position,
-                                                   const Utilities::Coordinates::CoordinateSystem &coordinate_system) const
-    {
-      std::array<double, dim> other_coord;
-      switch (coordinate_system)
-        {
-          case Utilities::Coordinates::cartesian:
-            other_coord = Utilities::convert_point_to_array(position);
-            break;
-
-          case Utilities::Coordinates::spherical:
-            other_coord = Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
-            break;
-
-          case Utilities::Coordinates::depth:
-            other_coord[0] = depth(position);
-            break;
-
-          case Utilities::Coordinates::ellipsoidal:
-          default:
-            AssertThrow(false, ExcNotImplemented());
-        }
-
-      return Utilities::NaturalCoordinate<dim>(other_coord, coordinate_system);
-    }
-
-    template <int dim>
-    Point<dim>
-    Interface<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &) const
-    {
-      Assert (false,
-              ExcMessage ("The natural_to_cartesian_coordinates function has "
-                          "not been implemented in this geometry model."));
-      return Point<dim>();
-    }
-
-
-    /* --------- functions to translate between symbolic and numeric boundary indicators ------ */
-
-    namespace
-    {
-      types::boundary_id
-      translate_boundary_indicator (const std::string &name_,
-                                    const std::map<std::string,types::boundary_id> &boundary_names_mapping)
-      {
-        // trim whitespace on either side of the name if necessary
-        std::string name = name_;
-        while ((name.size() > 0) && (name[0] == ' '))
-          name.erase (name.begin());
-        while ((name.size() > 0) && (name[name.size()-1] == ' '))
-          name.erase (name.end()-1);
-
-        // backwards compatibility (rename boundaries to all use "top" and "bottom"
-        if (name == "surface" || name == "outer")
-          name = "top";
-        else if (name == "inner")
-          name = "bottom";
-
-        // see if the given name is a symbolic one
-        if (boundary_names_mapping.find (name) != boundary_names_mapping.end())
-          return boundary_names_mapping.find(name)->second;
-        else
-          return dealii::Utilities::string_to_int(name);
-      }
-
-
-      std::vector<types::boundary_id>
-      translate_boundary_indicators (const std::vector<std::string> &names,
-                                     const std::map<std::string,types::boundary_id> &boundary_names_mapping)
-      {
-        std::vector<types::boundary_id> results;
-        results.reserve(names.size());
-        for (const auto &name : names)
-          results.push_back (translate_boundary_indicator(name, boundary_names_mapping));
-
-        return results;
-      }
-    }
-
-
-    template <int dim>
-    types::boundary_id
-    Interface<dim>::
-    translate_symbolic_boundary_name_to_id (const std::string &name) const
-    {
-      return translate_boundary_indicator(name, get_symbolic_boundary_names_map());
-    }
-
-
-
-    template <int dim>
-    std::vector<types::boundary_id>
-    Interface<dim>::
-    translate_symbolic_boundary_names_to_ids (const std::vector<std::string> &names) const
-    {
-      return translate_boundary_indicators(names, get_symbolic_boundary_names_map());
-    }
-
-
-    template <int dim>
-    std::string
-    Interface<dim>::
-    translate_id_to_symbol_name(const types::boundary_id boundary_id) const
-    {
-      const std::map<std::string,types::boundary_id> mapping = get_symbolic_boundary_names_map();
-
-      // loop over all entries in the map, and set 'name' to the key if the
-      // value matches the given 'boundary_id'. if 'name' has already been
-      // set, then this means that we had previously already found it -- i.e.,
-      // that it is in the map at least twice. produce an error in that case.
-      std::string name;
-      for (const auto &p : mapping)
-        if (p.second == boundary_id)
-          {
-            Assert (name == "",
-                    ExcMessage ("This geometry model appears to provide multiple "
-                                "names for the boundary with indicator <" +
-                                Utilities::int_to_string (boundary_id) + ">."));
-            name = p.first;
-          }
-
-      return name;
-    }
-
-
-// -------------------------------- Deal with registering geometry models and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    register_geometry_model (const std::string &name,
-                             const std::string &description,
-                             void (*declare_parameters_function) (ParameterHandler &),
-                             std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_geometry_model (ParameterHandler &prm)
-    {
-      std::string model_name;
-      prm.enter_subsection ("Geometry model");
-      {
-        model_name = prm.get ("Model name");
-      }
-      prm.leave_subsection ();
-
-      // If one sets the model name to an empty string in the input file,
-      // ParameterHandler produces an error while reading the file. However,
-      // if one omits specifying any model name at all (not even setting it to
-      // the empty string) then the value we get here is the empty string. If
-      // we don't catch this case here, we end up with awkward downstream
-      // errors because the value obviously does not conform to the Pattern.
-      AssertThrow(model_name != "unspecified",
-                  ExcMessage("You need to select a Geometry model "
-                             "(`set Model name' in `subsection Geometry model')."));
-
-      return std::get<dim>(registered_plugins).create_plugin (model_name,
-                                                              "Geometry model::model name",
-                                                              prm);
-    }
-
-
-
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm)
-    {
-      // declare the entry in the parameter file
-      prm.enter_subsection ("Geometry model");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-        prm.declare_entry ("Model name", "unspecified",
-                           Patterns::Selection (pattern_of_names+"|unspecified"),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Geometry model interface",
-                                                            out);
-    }
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::make_periodicity_constraints(const DoFHandler<dim> &dof_handler,
-                                                 AffineConstraints<double> &constraints) const
-    {
-      using periodic_boundary_set
-        = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
-      periodic_boundary_set pbs = get_periodic_boundary_pairs();
-
-      for (const auto &pb : pbs)
-        {
-          DoFTools::make_periodicity_constraints(dof_handler,
-                                                 pb.first.first,  // first boundary id
-                                                 pb.first.second, // second boundary id
-                                                 pb.second,       // cartesian direction for translational symmetry
-                                                 constraints);
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<GeometryModel::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<GeometryModel::Interface<2>>::plugins = nullptr;
-
-      template <>
-      std::list<internal::Plugins::PluginList<GeometryModel::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<GeometryModel::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace GeometryModel
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_geometry_model<dim> (const std::string &, \
-                                const std::string &, \
-                                void ( *) (ParameterHandler &), \
-                                std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_geometry_model<dim> (ParameterHandler &prm);
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/geometry_model/sphere.cc.bak b/source/geometry_model/sphere.cc.bak
deleted file mode 100644
index 08420710357..00000000000
--- a/source/geometry_model/sphere.cc.bak
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/manifold_lib.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    template <int dim>
-    void
-    Sphere<dim>::
-    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
-    {
-      GridGenerator::hyper_ball (coarse_grid,
-                                 Point<dim>(),
-                                 R);
-
-      coarse_grid.set_manifold(0, SphericalManifold<dim>());
-      coarse_grid.set_all_manifold_ids_on_boundary(0);
-    }
-
-
-    template <int dim>
-    std::set<types::boundary_id>
-    Sphere<dim>::
-    get_used_boundary_indicators () const
-    {
-      const types::boundary_id s[] = { 0 };
-      return std::set<types::boundary_id>(std::begin(s), std::end(s));
-    }
-
-
-    template <int dim>
-    std::map<std::string,types::boundary_id>
-    Sphere<dim>::
-    get_symbolic_boundary_names_map () const
-    {
-      return {{"top", 0}};
-    }
-
-
-    template <int dim>
-    double
-    Sphere<dim>::
-    length_scale () const
-    {
-      // as described in the first ASPECT paper, a length scale of
-      // 10km = 1e4m works well for the pressure scaling for earth
-      // sized spherical shells. use a length scale that
-      // yields this value for the R0,R1 corresponding to earth
-      // but otherwise scales like (R1-R0)
-      return 1e4 * maximal_depth() / (6336000.-3481000.);
-    }
-
-
-
-    template <int dim>
-    double
-    Sphere<dim>::depth(const Point<dim> &position) const
-    {
-      return std::min (std::max (R-position.norm(), 0.), maximal_depth());
-    }
-
-    template <int dim>
-    double
-    Sphere<dim>::height_above_reference_surface(const Point<dim> &position) const
-    {
-      return position.norm()-radius();
-    }
-
-
-    template <int dim>
-    Point<dim>
-    Sphere<dim>::representative_point(const double depth) const
-    {
-      Point<dim> p;
-      p(dim-1) = std::min (std::max(R - depth, 0.), maximal_depth());
-      return p;
-    }
-
-
-
-    template <int dim>
-    double
-    Sphere<dim>::maximal_depth() const
-    {
-      return R;
-    }
-
-    template <int dim>
-    double Sphere<dim>::radius () const
-    {
-      return R;
-    }
-
-    template <int dim>
-    bool
-    Sphere<dim>::has_curved_elements () const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    bool
-    Sphere<dim>::point_is_in_domain(const Point<dim> &point) const
-    {
-      AssertThrow(!this->get_parameters().mesh_deformation_enabled ||
-                  this->get_timestep_number() == 0,
-                  ExcMessage("After displacement of the mesh, this function can no longer be used to determine whether a point lies in the domain or not."));
-
-      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()),
-                  ExcMessage("After adding topography, this function can no longer be used to determine whether a point lies in the domain or not."));
-
-      const double radius = point.norm();
-
-      if (radius > R+std::numeric_limits<double>::epsilon()*R)
-        return false;
-
-      return true;
-    }
-
-
-
-    template <int dim>
-    std::array<double,dim>
-    Sphere<dim>::cartesian_to_natural_coordinates(const Point<dim> &position) const
-    {
-      return Utilities::Coordinates::cartesian_to_spherical_coordinates<dim>(position);
-    }
-
-
-
-    template <int dim>
-    aspect::Utilities::Coordinates::CoordinateSystem
-    Sphere<dim>::natural_coordinate_system() const
-    {
-      return aspect::Utilities::Coordinates::CoordinateSystem::spherical;
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    Sphere<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position) const
-    {
-      return Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(position);
-    }
-
-
-
-    template <int dim>
-    void
-    Sphere<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Sphere");
-        {
-          prm.declare_entry ("Radius", "6371000.",
-                             Patterns::Double (0.),
-                             "Radius of the sphere. Units: \\si{\\meter}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Sphere<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Sphere");
-        {
-          R            = prm.get_double ("Radius");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    ASPECT_REGISTER_GEOMETRY_MODEL(Sphere,
-                                   "sphere",
-                                   "A geometry model for a sphere with a user specified "
-                                   "radius. This geometry has only a single boundary, so "
-                                   "the only valid boundary indicator to "
-                                   "specify in input files is ``0''. It can also be "
-                                   "referenced by the symbolic name ``surface'' in "
-                                   "input files."
-                                   "\n\n"
-                                   "Despite the name, this geometry does not imply the use of "
-                                   "a spherical coordinate system when used in 2d. Indeed, "
-                                   "in 2d the geometry is simply a circle in a Cartesian "
-                                   "coordinate system and consequently would correspond to "
-                                   "a cross section of the fluid filled interior of an "
-                                   "infinite cylinder where one has made the assumption that "
-                                   "the velocity in direction of the cylinder axes is zero. "
-                                   "This is consistent with the definition of what we consider "
-                                   "the two-dimension case given in "
-                                   "Section~\\ref{sec:methods:2d-models}.")
-  }
-}
diff --git a/source/geometry_model/spherical_shell.cc.bak b/source/geometry_model/spherical_shell.cc.bak
deleted file mode 100644
index 0f06e10d786..00000000000
--- a/source/geometry_model/spherical_shell.cc.bak
+++ /dev/null
@@ -1,1074 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-
-#include <aspect/compat.h>
-
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/grid_tools.h>
-#include <deal.II/grid/manifold_lib.h>
-#include <aspect/utilities.h>
-#include <deal.II/dofs/dof_tools.h>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    namespace
-    {
-      void append_face_to_subcell_data(SubCellData &subcell_data, const CellData<1> &face)
-      {
-        subcell_data.boundary_lines.push_back(face);
-      }
-
-
-
-      void append_face_to_subcell_data(SubCellData &subcell_data, const CellData<2> &face)
-      {
-        subcell_data.boundary_quads.push_back(face);
-      }
-    }
-
-
-    namespace internal
-    {
-      template <int dim>
-      SphericalManifoldWithTopography<dim>::
-      SphericalManifoldWithTopography(const InitialTopographyModel::Interface<dim> &topography,
-                                      const double inner_radius,
-                                      const double outer_radius)
-        :
-        SphericalManifold<dim>(Point<dim>()),
-        topo (&topography),
-        R0 (inner_radius),
-        R1 (outer_radius)
-      {}
-
-
-      template <int dim>
-      std::unique_ptr<Manifold<dim, dim>>
-      SphericalManifoldWithTopography<dim>::clone() const
-      {
-        return std::make_unique<SphericalManifoldWithTopography<dim>>(*this);
-      }
-
-
-
-      template <int dim>
-      double
-      SphericalManifoldWithTopography<dim>::
-      topography_for_point(const Point<dim> &x_y_z) const
-      {
-        if (dynamic_cast<const InitialTopographyModel::ZeroTopography<dim>*>(topo) != nullptr)
-          return 0;
-        else
-          {
-            Assert (dim==3, ExcNotImplemented());
-
-            // The natural coordinate system of the sphere geometry is r/phi/theta.
-            // This is what we need to query the topography with. So start by
-            // converting into this coordinate system
-            const std::array<double, dim> r_phi_theta = Utilities::Coordinates::cartesian_to_spherical_coordinates(x_y_z);
-
-            // Grab lon,lat coordinates
-            Point<dim-1> surface_point;
-            for (unsigned int d=0; d<dim-1; ++d)
-              surface_point[d] = r_phi_theta[d+1];
-            return topo->value(surface_point);
-          }
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      SphericalManifoldWithTopography<dim>::
-      push_forward_from_sphere(const Point<dim> &p) const
-      {
-        const double topography = topography_for_point(p);
-
-        // We can short-circuit the computations here if the topography
-        // is zero.
-        if (topography == 0)
-          return p;
-        else
-          {
-            // For the case with (non-zero) topography, we have to project
-            // the point out/inward.
-
-            // We start from the undeformed sphere. So the current radius must be
-            // between R0 and R1. Check this, with a slight tolerance to account
-            // for the fact that our mesh is not *completely* spherical.
-            const double r = p.norm();
-            Assert (r>=R0*0.99, ExcInternalError());
-            Assert (r<=R1*1.01, ExcInternalError());
-
-            // Then we need to stretch the point p outward by a factor that is
-            // zero at the core-mantle boundary and results in the right topography
-            // at the top.
-            //
-            // The stretching factor is relative to the distance from the core
-            // mantle boundary.
-            const double cmb_stretching_factor = (R1+topography-R0)/(R1-R0);
-
-            // From this we can compute what the desired radius is going to be, and
-            // scale the given point accordingly:
-            const double new_radius = (r-R0)*cmb_stretching_factor + R0;
-            return p * (new_radius/r);
-          }
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      SphericalManifoldWithTopography<dim>::
-      pull_back_to_sphere(const Point<dim> &p) const
-      {
-        const double topography = topography_for_point(p);
-
-        // We can short-circuit the computations here if the topography
-        // is zero.
-        if (topography == 0)
-          return p;
-        else
-          {
-            // For the case with (non-zero) topography, we have to project
-            // the point in/outward.
-
-            // We start from the deformed sphere. So the current radius must be
-            // between R0 and R1+topography. Check this, with a slight tolerance
-            // to account for the fact that our mesh is not *completely* spherical.
-            const double r = p.norm();
-            Assert (r>=R0*0.99, ExcInternalError());
-            Assert (r<=(R1+topography)*1.01, ExcInternalError());
-
-            // Then we need to stretch(=shrink) the point p outward by a factor that is
-            // zero at the core-mantle boundary and results in the right topography
-            // at the top.
-            const double cmb_stretching_factor = (R1-R0)/(R1+topography-R0);
-
-            // From this we can compute what the desired radius is going to be, and
-            // scale the given point accordingly:
-            const double new_radius = (r-R0)*cmb_stretching_factor + R0;
-            return p * (new_radius/r);
-          }
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      SphericalManifoldWithTopography<dim>::
-      get_intermediate_point(const Point<dim> &p1,
-                             const Point<dim> &p2,
-                             const double      w) const
-      {
-        return
-          push_forward_from_sphere
-          (SphericalManifold<dim>::get_intermediate_point (pull_back_to_sphere(p1),
-                                                           pull_back_to_sphere(p2), w));
-      }
-
-
-
-      template <int dim>
-      Tensor<1, dim>
-      SphericalManifoldWithTopography<dim>::
-      get_tangent_vector(const Point<dim> &x1,
-                         const Point<dim> &x2) const
-      {
-        // TODO: Deal with pull back and push forward
-        return SphericalManifold<dim>::get_tangent_vector (x1, x2);
-      }
-
-
-
-      template <int dim>
-      Tensor<1, dim>
-      SphericalManifoldWithTopography<dim>::
-      normal_vector(const typename Triangulation<dim, dim>::face_iterator &face,
-                    const Point<dim> &p) const
-      {
-        // We calculate radial, rather than *normal*, vectors here if a face is
-        // at the boundary. This is as described in the documentation of this
-        // function.
-
-        // TODO: Add an input parameter that determines whether we use this
-        //   or the "geometrically correct" behavior.
-        return SphericalManifold<dim>::normal_vector (face, p);
-      }
-
-
-
-      template <int dim>
-      void
-      SphericalManifoldWithTopography<dim>::
-      get_normals_at_vertices(
-        const typename Triangulation<dim, dim>::face_iterator &face,
-        typename Manifold<dim, dim>::FaceVertexNormals &face_vertex_normals) const
-      {
-        // TODO: Deal with pull back and push forward
-        SphericalManifold<dim>::get_normals_at_vertices(face, face_vertex_normals);
-      }
-
-
-
-      template <int dim>
-      void
-      SphericalManifoldWithTopography<dim>::
-      get_new_points(const ArrayView<const Point<dim>> &surrounding_points,
-                     const Table<2, double>            &weights,
-                     ArrayView<Point<dim>>              new_points) const
-      {
-        // First compute the points in the untransformed coordinate system
-        // without surface topography:
-        std::vector<Point<dim>> untransformed_points;
-        untransformed_points.reserve(surrounding_points.size());
-        for (const Point<dim> &p : surrounding_points)
-          untransformed_points.emplace_back (pull_back_to_sphere(p));
-
-        // Call the function in the base class:
-        SphericalManifold<dim>::get_new_points(untransformed_points, weights, new_points);
-
-        // Since the function in the base class returned its information
-        // in a writable array, we can in-place push forward to the deformed
-        // sphere with topography:
-        for (Point<dim> &p : new_points)
-          p = push_forward_from_sphere(p);
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      SphericalManifoldWithTopography<dim>::
-      get_new_point(const ArrayView<const Point<dim>> &surrounding_points,
-                    const ArrayView<const double>          &weights) const
-      {
-        // First compute the points in the untransformed coordinate system
-        // without surface topography:
-        std::vector<Point<dim>> untransformed_points;
-        untransformed_points.reserve(surrounding_points.size());
-        for (const Point<dim> &p : surrounding_points)
-          untransformed_points.emplace_back (pull_back_to_sphere(p));
-
-        // Call the function in the base class, and transform the
-        // returned value:
-        return push_forward_from_sphere(SphericalManifold<dim>::get_new_point(untransformed_points,
-                                                                              weights));
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalShell<dim>::initialize ()
-    {
-      manifold = std::make_unique<internal::SphericalManifoldWithTopography<dim>>(this->get_initial_topography_model(),
-                                                                                   R0, R1);
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalShell<dim>::
-    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
-    {
-      AssertThrow (phi == 360 || phi == 90 || ((phi == 180) && (dim == 2)),
-                   ExcMessage ("The only opening angles that are allowed for "
-                               "this geometry are 90, 180, and 360 in 2d; "
-                               "and 90 and 360 in 3d."));
-
-      // Custom mesh extrusion is only implemented for full spherical shells
-      // for now, so check that custom mesh schemes are only being used when
-      // the opening angle is 360 degrees.
-      AssertThrow (phi == 360 || (custom_mesh == none),
-                   ExcMessage ("The only opening angle that is allowed for "
-                               "this geometry with a custom mesh is 360."));
-
-      if (phi == 360)
-        {
-          if (custom_mesh == none)
-            {
-              // If we are not using a custom mesh scheme, the mesh is generated
-              // as per the original code.
-              GridGenerator::hyper_shell (coarse_grid,
-                                          Point<dim>(),
-                                          R0,
-                                          R1,
-                                          (n_cells_along_circumference == 0
-                                           ?
-                                           // automatic choice that leads to reasonable
-                                           // meshes with the typical aspect ratio of
-                                           // the Earth
-                                           (dim==3 ? 96 : 12)
-                                           :
-                                           // user choice
-                                           n_cells_along_circumference),
-                                          true);
-            }
-          else
-            {
-              Assert(custom_mesh == slices || custom_mesh == list, ExcNotImplemented());
-              // If we are using a custom mesh scheme, we need to create
-              // a new triangulation to extrude (this will be a 1D line in
-              // 2d space, or a 2d surface in 3d space).
-              Triangulation<dim-1,dim> sphere_mesh;
-              GridGenerator::hyper_sphere (sphere_mesh);
-              sphere_mesh.refine_global (initial_lateral_refinement);
-
-              // Calculate the number of R_values wrt custom mesh scheme
-              unsigned int n_R_values;
-              if (custom_mesh == slices)
-                n_R_values = n_slices+1;
-              else
-                n_R_values = R_values_list.size()+2;
-
-              // Allocate R_values wrt the number of slices
-              std::vector<double> R_values (n_R_values);
-              if (custom_mesh == slices)
-                {
-                  for (unsigned int s=0; s<n_R_values; ++s)
-                    R_values[s] = R0 + (R1-R0)/n_slices * s;
-                }
-              if (custom_mesh == list)
-                {
-                  R_values[0] = R0;
-                  R_values[n_R_values-1] = R1;
-                  for (unsigned int s=1; s<(n_R_values-1); ++s)
-                    R_values[s] = R_values_list[s-1];
-                }
-              std::vector<Point<dim>>    points(R_values.size() * sphere_mesh.n_vertices());
-
-
-              // Copy the array of points as many times as there will be slices,
-              // one slice at a time. The z-axis value are defined in slices_coordinates
-              for (unsigned int point_layer = 0; point_layer < R_values.size(); ++point_layer)
-                {
-                  for (unsigned int vertex_n = 0; vertex_n < sphere_mesh.n_vertices();
-                       ++vertex_n)
-                    {
-                      const Point<dim> vertex = sphere_mesh.get_vertices()[vertex_n];
-                      points[point_layer * sphere_mesh.n_vertices() + vertex_n] =
-                        vertex * R_values[point_layer];
-                    }
-                }
-
-              // Then create the cells of each of the slices, one stack at a
-              // time
-              std::vector<CellData<dim>> cells;
-              cells.reserve((R_values.size() - 1) * sphere_mesh.n_active_cells());
-
-              SubCellData               subcell_data;
-
-              for (const auto &cell : sphere_mesh.active_cell_iterators())
-                {
-                  for (unsigned int cell_layer = 0; cell_layer < R_values.size() - 1; ++cell_layer)
-                    {
-                      CellData<dim> this_cell;
-                      for (const unsigned int vertex_n : cell->vertex_indices())
-                        {
-                          this_cell.vertices[vertex_n] =
-                            cell->vertex_index(vertex_n) + cell_layer * sphere_mesh.n_vertices();
-                          this_cell.vertices[vertex_n + cell->n_vertices()] =
-                            cell->vertex_index(vertex_n) +
-                            (cell_layer + 1) * sphere_mesh.n_vertices();
-                        }
-
-                      this_cell.material_id = cell->material_id();
-
-
-                      Assert(GridTools::cell_measure (points, this_cell.vertices) > 0, ExcInternalError());
-
-                      cells.push_back(this_cell);
-
-                      // Mark the bottom face of the cell as boundary 0 if we are in
-                      // the bottom layer of cells
-                      if (cell_layer == 0)
-                        {
-                          CellData<dim-1> face;
-                          for (const unsigned int vertex_n : cell->vertex_indices())
-                            face.vertices[vertex_n] =
-                              cell->vertex_index(vertex_n) + cell_layer * sphere_mesh.n_vertices();
-                          face.boundary_id = 0;
-
-                          append_face_to_subcell_data(subcell_data, face);
-                        }
-
-                      // Mark the top face of the cell as boundary 1 if we are in
-                      // the top layer of cells
-                      if (cell_layer == R_values.size()-2)
-                        {
-                          CellData<dim-1> face;
-                          for (const unsigned int vertex_n : cell->vertex_indices())
-                            face.vertices[vertex_n] =
-                              cell->vertex_index(vertex_n) +
-                              (cell_layer + 1) * sphere_mesh.n_vertices();
-                          face.boundary_id = 1;
-
-                          append_face_to_subcell_data(subcell_data, face);
-                        }
-
-                    }
-                }
-
-              // Then create the actual mesh:
-              GridTools::consistently_order_cells (cells);
-              coarse_grid.create_triangulation(points, cells, subcell_data);
-            }
-        }
-      else if (phi == 90)
-        {
-          GridGenerator::quarter_hyper_shell (coarse_grid,
-                                              Point<dim>(),
-                                              R0,
-                                              R1,
-                                              0,
-                                              true);
-
-          if (periodic)
-            {
-              // Tell p4est about the periodicity of the mesh.
-              std::vector<GridTools::PeriodicFacePair<typename parallel::distributed::Triangulation<dim>::cell_iterator>>
-              matched_pairs;
-              FullMatrix<double> rotation_matrix(dim);
-              rotation_matrix[0][1] = 1.;
-              rotation_matrix[1][0] = -1.;
-
-              GridTools::collect_periodic_faces(coarse_grid, /*b_id1*/ 2, /*b_id2*/ 3,
-                                                /*direction*/ 1, matched_pairs,
-                                                Tensor<1, dim>(), rotation_matrix);
-
-              if (matched_pairs.size() > 0)
-                coarse_grid.add_periodicity (matched_pairs);
-            }
-        }
-      else if (phi == 180)
-        {
-          GridGenerator::half_hyper_shell (coarse_grid,
-                                           Point<dim>(),
-                                           R0,
-                                           R1,
-                                           0,
-                                           true);
-        }
-      else
-        {
-          Assert (false, ExcInternalError());
-        }
-
-      // Then add the topography to the mesh by moving all vertices from the
-      // undeformed sphere to the sphere with topography:
-      GridTools::transform (
-        [&](const Point<dim> &p) -> Point<dim>
-      {
-        return manifold->push_forward_from_sphere(p);
-      },
-      coarse_grid);
-
-      // Use a manifold description for all cells. Use manifold_id 99 in order
-      // not to step on the boundary indicators used below.
-      coarse_grid.set_manifold (my_manifold_id, *manifold);
-      set_manifold_ids(coarse_grid);
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalShell<dim>::set_manifold_ids (parallel::distributed::Triangulation<dim> &triangulation) const
-    {
-      for (const auto &cell : triangulation.active_cell_iterators())
-        cell->set_all_manifold_ids (my_manifold_id);
-    }
-
-
-
-    template <int dim>
-    std::set<types::boundary_id>
-    SphericalShell<dim>::
-    get_used_boundary_indicators () const
-    {
-      // Follow what is described in the documentation of this class.
-      // see the documentation of the various GridGenerator::*hyper_shell
-      // functions for a description of which boundary indicators are
-      // set and how they correlate to what's used below
-      if (phi == 360)
-        {
-          const types::boundary_id s[] = { 0, 1 };
-          return std::set<types::boundary_id>(std::begin(s), std::end(s));
-        }
-      else if (phi == 90 && dim == 3)
-        {
-          const types::boundary_id s[] = { 0, 1, 2, 3, 4};
-          return std::set<types::boundary_id>(std::begin(s), std::end(s));
-        }
-      else
-        {
-          const types::boundary_id s[] = { 0, 1, 2, 3 };
-          return std::set<types::boundary_id>(std::begin(s), std::end(s));
-        }
-    }
-
-
-
-    template <int dim>
-    std::map<std::string,types::boundary_id>
-    SphericalShell<dim>::
-    get_symbolic_boundary_names_map () const
-    {
-      switch (dim)
-        {
-          case 2:
-          {
-            static const std::pair<std::string,types::boundary_id> mapping[]
-            = { {"bottom", 0},
-              {"top", 1},
-              {"left",  2},
-              {"right", 3}
-            };
-
-            if (phi == 360)
-              return std::map<std::string,types::boundary_id> (std::begin(mapping),
-                                                               std::begin(mapping)+2);
-            else
-              return std::map<std::string,types::boundary_id> (std::begin(mapping),
-                                                               std::begin(mapping)+4);
-          }
-
-          case 3:
-          {
-            if (phi == 360)
-              {
-                return
-                {
-                  {"bottom", 0},
-                  {"top",    1}
-                };
-              }
-            else if (phi == 90)
-              {
-                return
-                {
-                  {"bottom", 0},
-                  {"top",    1},
-                  {"east",   2},
-                  {"west",   3},
-                  {"south",  4}
-                };
-              }
-            else
-              Assert (false, ExcNotImplemented());
-          }
-        }
-
-      Assert (false, ExcNotImplemented());
-      return {};
-    }
-
-
-
-    template <int dim>
-    std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
-    SphericalShell<dim>::
-    get_periodic_boundary_pairs () const
-    {
-      std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>> periodic_boundaries;
-      if (periodic)
-        {
-          periodic_boundaries.insert( std::make_pair( std::pair<types::boundary_id, types::boundary_id>(2, 3), 1) );
-        }
-      return periodic_boundaries;
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalShell<dim>::adjust_positions_for_periodicity (Point<dim> &position,
-                                                           const ArrayView<Point<dim>> &connected_positions,
-                                                           const ArrayView<Tensor<1, dim>> &connected_velocities) const
-    {
-      AssertThrow(dim == 2,
-                  ExcMessage("Periodic boundaries currently "
-                             "only work with 2d spherical shell."));
-      AssertThrow(phi == 90,
-                  ExcMessage("Periodic boundaries currently "
-                             "only work with 90 degree opening angle in spherical shell."));
-
-      if (periodic)
-        {
-          // define a rotation matrix for the new position depending on the boundary
-          Tensor<2,dim> rotation_matrix;
-
-          if (position[0] < 0.)
-            {
-              rotation_matrix[0][1] = 1.;
-              rotation_matrix[1][0] = -1.;
-            }
-          else if (position[1] < 0.)
-            {
-              rotation_matrix[0][1] = -1.;
-              rotation_matrix[1][0] = 1.;
-            }
-          else
-            return;
-
-          position = rotation_matrix * position;
-
-          for (auto &connected_position: connected_positions)
-            connected_position = rotation_matrix * connected_position;
-
-          for (auto &connected_velocity: connected_velocities)
-            connected_velocity = rotation_matrix * connected_velocity;
-        }
-
-      return;
-    }
-
-
-
-    template <int dim>
-    double
-    SphericalShell<dim>::
-    length_scale () const
-    {
-      // As described in the first ASPECT paper, a length scale of
-      // 10km = 1e4m works well for the pressure scaling for earth
-      // sized spherical shells. So use a formulation that yields this
-      // value for the R0,R1 corresponding to earth, and that more
-      // generally scales with (R1-R0), which we can get by calling
-      // maximal_depth(). In essence, the factor in front of the call
-      // to maximal_depth() is just a magic number that has turned out
-      // to work well.
-      return (1e4 / (6336000.-3481000.)) * maximal_depth();
-    }
-
-
-
-    template <int dim>
-    double
-    SphericalShell<dim>::depth(const Point<dim> &position) const
-    {
-      return std::min (std::max (R1-position.norm(), 0.), maximal_depth());
-    }
-
-
-
-    template <int dim>
-    double
-    SphericalShell<dim>::height_above_reference_surface(const Point<dim> &position) const
-    {
-      return position.norm()-R1;
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    SphericalShell<dim>::representative_point(const double depth) const
-    {
-      Assert (depth >= 0,
-              ExcMessage ("Given depth must be positive or zero."));
-      Assert (depth <= maximal_depth(),
-              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
-
-      // Choose a point along the axes toward the north pole, at the
-      // requested depth.
-      Point<dim> p;
-      p[dim-1] = std::min (std::max(R1 - depth, R0), R1);
-
-      // Return this point. This ignores the surface topography,
-      // but that is as documented.
-      return p;
-    }
-
-
-
-    template <int dim>
-    double
-    SphericalShell<dim>::maximal_depth() const
-    {
-      // The depth is defined as relative to a reference surface (without
-      // topography) and since we don't apply topography on the CMB,
-      // the maximal depth really is R1-R0 unless one applies a
-      // topography that is always strictly below zero (i.e., where the
-      // actual surface lies strictly below the reference surface).
-      return R1-R0;
-    }
-
-
-
-    template <int dim>
-    double SphericalShell<dim>::inner_radius () const
-    {
-      return R0;
-    }
-
-
-
-    template <int dim>
-    double SphericalShell<dim>::outer_radius () const
-    {
-      return R1;
-    }
-
-
-
-    template <int dim>
-    double SphericalShell<dim>::opening_angle () const
-    {
-      return phi;
-    }
-
-
-
-    template <int dim>
-    bool
-    SphericalShell<dim>::has_curved_elements () const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    bool
-    SphericalShell<dim>::point_is_in_domain(const Point<dim> &point) const
-    {
-      AssertThrow(!this->get_parameters().mesh_deformation_enabled ||
-                  this->simulator_is_past_initialization() == false,
-                  ExcMessage("After displacement of the free surface, this function can no longer be used to determine whether a point lies in the domain or not."));
-
-      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()),
-                  ExcMessage("After adding topography, this function can no longer be used to determine whether a point lies in the domain or not."));
-
-      const std::array<double, dim> spherical_point = Utilities::Coordinates::cartesian_to_spherical_coordinates(point);
-
-      std::array<double, dim> point1, point2;
-      point1[0] = R0;
-      point2[0] = R1;
-      point1[1] = 0.0;
-      point2[1] = phi * constants::degree_to_radians;
-      if (dim == 3)
-        {
-          point1[2] = 0.0;
-
-          if (phi == 90.0)
-            // Octant
-            point2[2] = 0.5 * numbers::PI;
-          else
-            // Full shell
-            point2[2] = numbers::PI;
-        }
-
-      for (unsigned int d = 0; d < dim; ++d)
-        if (spherical_point[d] > point2[d]+std::numeric_limits<double>::epsilon()*std::abs(point2[d]) ||
-            spherical_point[d] < point1[d]-std::numeric_limits<double>::epsilon()*std::abs(point2[d]))
-          return false;
-
-      // TODO: Take into account topography
-
-      return true;
-    }
-
-
-
-    template <int dim>
-    std::array<double,dim>
-    SphericalShell<dim>::cartesian_to_natural_coordinates(const Point<dim> &position) const
-    {
-      // TODO: Take into account topography
-      return Utilities::Coordinates::cartesian_to_spherical_coordinates<dim>(position);
-    }
-
-
-
-    template <int dim>
-    aspect::Utilities::Coordinates::CoordinateSystem
-    SphericalShell<dim>::natural_coordinate_system() const
-    {
-      return aspect::Utilities::Coordinates::CoordinateSystem::spherical;
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    SphericalShell<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position) const
-    {
-      // TODO: Take into account topography
-      return Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(position);
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalShell<dim>::make_periodicity_constraints(const DoFHandler<dim> &dof_handler,
-                                                      AffineConstraints<double> &constraints) const
-    {
-      if (periodic)
-        {
-          std::vector<GridTools::PeriodicFacePair<typename DoFHandler<dim>::cell_iterator>>
-          matched_pairs;
-          FullMatrix<double> rotation_matrix(dim);
-          rotation_matrix[0][1] = 1.;
-          rotation_matrix[1][0] = -1.;
-
-          GridTools::collect_periodic_faces(dof_handler, /*b_id1*/ 2, /*b_id2*/ 3,
-                                            /*direction*/ 1, matched_pairs,
-                                            Tensor<1, dim>(), rotation_matrix);
-
-          DoFTools::make_periodicity_constraints<dim,dim,double>(matched_pairs,
-                                                                 constraints,
-                                                                 ComponentMask(),
-          {0},
-          1.);
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalShell<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Spherical shell");
-        {
-          prm.declare_entry ("Custom mesh subdivision", "none",
-                             Patterns::Selection ("none|list of radial values|number of slices"),
-                             "Choose how the spherical shell mesh is generated. "
-                             "By default, a coarse mesh is generated with respect to the "
-                             "inner and outer radius, and an initial number of cells along "
-                             "circumference. "
-                             "In the other cases, a surface mesh is first generated and "
-                             "refined as desired, before it is extruded radially following "
-                             "the specified subdivision scheme.");
-          prm.declare_entry ("List of radial values", "",
-                             Patterns::List(Patterns::Double ()),
-                             "List of radial values for the custom mesh scheme. Units: "
-                             "$\\si{m}$. "
-                             "A list of radial values subdivides the spherical shell at "
-                             "specified radii. The list must be strictly ascending, and "
-                             "the first value must be greater than the inner radius "
-                             "while the last must be less than the outer radius.");
-          prm.declare_entry ("Number of slices", "1",
-                             Patterns::Integer (1),
-                             "Number of slices for the custom mesh subdivision scheme. "
-                             "The number of slices subdivides the spherical shell into N "
-                             "slices of equal thickness. Must be greater than 0.");
-          prm.declare_entry ("Initial lateral refinement", "0",
-                             Patterns::Integer (0),
-                             "Initial lateral refinement for the custom mesh subdivision "
-                             "schemes."
-                             "The number of refinement steps performed on the initial "
-                             "coarse surface mesh, before the surface is extruded "
-                             "radially. This parameter allows the user more control "
-                             "over the ratio between radial and lateral refinement of "
-                             "the mesh.");
-          prm.declare_entry ("Inner radius", "3481000.",  // 6371-2890 in km
-                             Patterns::Double (0.),
-                             "Inner radius of the spherical shell. Units: \\si{\\meter}."
-                             "\n\n"
-                             ":::{note}\n"
-                             "The default value of 3,481,000 m equals the "
-                             "radius of a sphere with equal volume as Earth (i.e., "
-                             "6371 km) minus the average depth of the core-mantle "
-                             "boundary (i.e., 2890 km).\n"
-                             ":::");
-          prm.declare_entry ("Outer radius", "6336000.",  // 6371-35 in km
-                             Patterns::Double (0.),
-                             "Outer radius of the spherical shell. Units: \\si{\\meter}."
-                             "\n\n"
-                             ":::{note}\n"
-                             "The default value of 6,336,000 m equals the "
-                             "radius of a sphere with equal volume as Earth (i.e., "
-                             "6371 km) minus the average depth of the mantle-crust "
-                             "interface (i.e., 35 km).\n"
-                             ":::");
-          prm.declare_entry ("Opening angle", "360.",
-                             Patterns::Double (0., 360.),
-                             "Opening angle in degrees of the section of the shell "
-                             "that we want to build. "
-                             "The only opening angles that are allowed for "
-                             "this geometry are 90, 180, and 360 in 2d; "
-                             "and 90 and 360 in 3d. "
-                             "Units: degrees.");
-          prm.declare_entry ("Cells along circumference", "0",
-                             Patterns::Integer (0),
-                             "The number of cells in circumferential direction that are "
-                             "created in the coarse mesh in 2d. If zero, this number "
-                             "is chosen automatically in a way that produces meshes "
-                             "in which cells have a reasonable aspect ratio for models "
-                             "in which the depth of the mantle is roughly that of the "
-                             "Earth. For planets with much shallower mantles and larger "
-                             "cores, you may want to chose a larger number to avoid "
-                             "cells that are elongated in tangential and compressed in "
-                             "radial direction."
-                             "\n\n"
-                             "In 3d, the number of cells is computed differently and does "
-                             "not have an easy interpretation. Valid values for this parameter "
-                             "in 3d are 0 (let this class choose), 6, 12 and 96. "
-                             "Other possible values may be discussed in the documentation "
-                             "of the deal.II function GridGenerator::hyper_shell. "
-                             "The parameter is best left at its default in 3d."
-                             "\n\n"
-                             "In either case, this parameter is ignored unless the opening "
-                             "angle of the domain is 360 degrees. This parameter is also "
-                             "ignored when using a custom mesh subdivision scheme.");
-          prm.declare_entry ("Phi periodic", "false",
-                             Patterns::Bool (),
-                             "Whether the shell should be periodic in the phi direction.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalShell<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Spherical shell");
-        {
-          R0  = prm.get_double ("Inner radius");
-          R1  = prm.get_double ("Outer radius");
-          phi = prm.get_double ("Opening angle");
-          n_cells_along_circumference = prm.get_integer ("Cells along circumference");
-          initial_lateral_refinement = prm.get_integer ("Initial lateral refinement");
-          R_values_list = Utilities::string_to_double(Utilities::split_string_list(prm.get("List of radial values")));
-          n_slices = prm.get_integer ("Number of slices");
-
-          if (prm.get ("Custom mesh subdivision") == "none")
-            custom_mesh = none;
-          else if (prm.get ("Custom mesh subdivision") == "list of radial values")
-            custom_mesh = list;
-          else if (prm.get ("Custom mesh subdivision") == "number of slices")
-            custom_mesh = slices;
-          else
-            AssertThrow (false, ExcMessage ("Not a valid custom mesh subdivision scheme."));
-
-          // Check that inner radius is less than outer radius
-          AssertThrow (R0 < R1,
-                       ExcMessage ("Inner radius must be less than outer radius."));
-
-          // If we are using list of radial values for a custom mesh
-          if (custom_mesh == list)
-            {
-              // Check that list is in ascending order
-              for (unsigned int i = 1; i < R_values_list.size(); ++i)
-                AssertThrow(R_values_list[i] > R_values_list[i-1],
-                            ExcMessage("Radial values must be strictly ascending"));
-              // Check that first value is not smaller than the inner radius
-              AssertThrow(R_values_list[1] > R0,
-                          ExcMessage("First value in List of radial values must be greater than inner radius"));
-              // Check that last layer is not larger than the outer radius
-              AssertThrow( *(R_values_list.end()-1) < R1,
-                           ExcMessage("Last value in List of radial values must be less than outer radius"));
-            }
-
-
-          // If we are extruding the mesh according to a number of slices
-          if (custom_mesh == slices)
-            {
-              AssertThrow (n_slices > 0, ExcMessage("You must set a positive number of slices for extrusion"));
-            }
-
-          periodic = prm.get_bool ("Phi periodic");
-          if (periodic)
-            {
-              AssertThrow (dim == 2,  ExcMessage("Periodic boundaries in the spherical shell are only supported for 2d models."));
-              AssertThrow (phi == 90, ExcMessage("Periodic boundaries in the spherical shell are only supported for an opening angle of 90 degrees."));
-            }
-
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    ASPECT_REGISTER_GEOMETRY_MODEL(SphericalShell,
-                                   "spherical shell",
-                                   "A geometry representing a spherical shell or a piece of it. "
-                                   "Inner and outer radii are read from the parameter file "
-                                   "in subsection 'Spherical shell'."
-                                   "\n\n"
-                                   "The spherical shell may be generated as per the original "
-                                   "code (with respect to the inner and outer radius, and an "
-                                   "initial number of cells along circumference) or following "
-                                   "a custom mesh scheme: list of radial values or number of "
-                                   "slices. A surface mesh is first generated and refined as "
-                                   "desired, before it is extruded radially. A list of radial "
-                                   "values subdivides the spherical shell at specified radii. "
-                                   "The number of slices subdivides the spherical shell into N "
-                                   "slices of equal thickness. The custom spherical shell only "
-                                   "works with an opening angle of 360 degrees."
-                                   "\n\n"
-                                   "Despite the name, this geometry does not imply the use of "
-                                   "a spherical coordinate system when used in 2d. Indeed, "
-                                   "in 2d the geometry is simply an annulus in a Cartesian "
-                                   "coordinate system and consequently would correspond to "
-                                   "a cross section of the fluid filled space between two "
-                                   "infinite cylinders where one has made the assumption that "
-                                   "the velocity in direction of the cylinder axes is zero. "
-                                   "This is consistent with the definition of what we consider "
-                                   "the two-dimension case given in "
-                                   "Section~\\ref{sec:methods:2d-models}."
-                                   "\n\n"
-                                   "The model assigns boundary indicators as follows: In 2d, "
-                                   "inner and outer boundaries get boundary indicators zero "
-                                   "and one, and if the opening angle set in the input file "
-                                   "is less than 360, then left and right boundaries are "
-                                   "assigned indicators two and three. These boundaries can "
-                                   "also be referenced using the symbolic names `inner', `outer' "
-                                   "and (if applicable) `left', `right'."
-                                   "\n\n"
-                                   "In 3d, inner and "
-                                   "outer indicators are treated as in 2d. If the opening "
-                                   "angle is chosen as 90 degrees, i.e., the domain is the "
-                                   "intersection of a spherical shell and the first octant, "
-                                   "then indicator 2 is at the face $x=0$, 3 at $y=0$, "
-                                   "and 4 at $z=0$. These last three boundaries can then also "
-                                   "be referred to as `east', `west' and `south' symbolically "
-                                   "in input files.")
-  }
-}
diff --git a/source/geometry_model/two_merged_boxes.cc.bak b/source/geometry_model/two_merged_boxes.cc.bak
deleted file mode 100644
index fad3973b171..00000000000
--- a/source/geometry_model/two_merged_boxes.cc.bak
+++ /dev/null
@@ -1,570 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/tria_accessor.h>
-#include <deal.II/grid/grid_tools.h>
-
-#include <functional>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::
-    set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const
-    {
-      // iterate over all active cells and (re)set the boundary indicators
-      for (const auto &cell : triangulation.active_cell_iterators())
-        {
-          // first set the default boundary indicators
-          for (const unsigned int f : cell->face_indices())
-            if (cell->face(f)->at_boundary())
-              cell->face(f)->set_boundary_id (f);
-
-          // Then for individual faces set the boundary indicators in specific ways:
-          if (cell->face(0)->at_boundary())
-            // set the lithospheric part of the left boundary to indicator 2*dim
-            if (cell->face(0)->vertex(cell->face(0)->n_vertices()-1)[dim-1] > height_lith)
-              cell->face(0)->set_boundary_id (2*dim);
-
-          if (cell->face(1)->at_boundary())
-            // set the lithospheric part of the right boundary to indicator 2*dim+1
-            if (cell->face(1)->vertex(cell->face(1)->n_vertices()-1)[dim-1] > height_lith)
-              cell->face(1)->set_boundary_id (2*dim+1);
-
-          if (dim==3)
-            {
-              // set the lithospheric part of the front boundary to indicator 2*dim+2
-              if (cell->face(2)->at_boundary())
-                if (cell->face(2)->vertex(cell->face(2)->n_vertices()-1)[dim-1] > height_lith)
-                  cell->face(2)->set_boundary_id (2*dim+2);
-
-              // set the lithospheric part of the back boundary to indicator 2*dim+3
-              if (cell->face(3)->at_boundary())
-                if (cell->face(3)->vertex(cell->face(3)->n_vertices()-1)[dim-1] > height_lith)
-                  cell->face(3)->set_boundary_id (2*dim+3);
-            }
-        }
-    }
-
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::
-    create_coarse_mesh (parallel::distributed::Triangulation<dim> &total_coarse_grid) const
-    {
-      std::vector<unsigned int> lower_rep_vec(lower_repetitions.begin(), lower_repetitions.end());
-      if (use_merged_grids)
-        {
-          std::vector<unsigned int> upper_rep_vec(upper_repetitions.begin(), upper_repetitions.end());
-
-          // the two triangulations that will be merged
-          Triangulation<dim> lower_coarse_grid;
-          Triangulation<dim> upper_coarse_grid;
-
-          // create lower_coarse_grid mesh
-          GridGenerator::subdivided_hyper_rectangle (lower_coarse_grid,
-                                                     lower_rep_vec,
-                                                     lower_box_origin,
-                                                     lower_box_origin+lower_extents,
-                                                     false);
-
-          // create upper_coarse_grid mesh
-          GridGenerator::subdivided_hyper_rectangle (upper_coarse_grid,
-                                                     upper_rep_vec,
-                                                     upper_box_origin,
-                                                     upper_box_origin+upper_extents,
-                                                     false);
-
-          // merge the lower and upper mesh into one total_coarse_grid.
-          // now we have at least two cells
-          GridGenerator::merge_triangulations(lower_coarse_grid,
-                                              upper_coarse_grid,
-                                              total_coarse_grid);
-        }
-      else
-        {
-          GridGenerator::subdivided_hyper_rectangle (total_coarse_grid,
-                                                     lower_rep_vec,
-                                                     lower_box_origin,
-                                                     upper_box_origin+upper_extents,
-                                                     false);
-        }
-
-      // set the boundary indicators
-      set_boundary_indicators(total_coarse_grid);
-
-      // tell p4est about the periodicity of the mesh.
-      std::vector<GridTools::PeriodicFacePair<typename parallel::distributed::Triangulation<dim>::cell_iterator>>
-      periodicity_vector;
-      for (int i=0; i<dim+dim-1; ++i)
-        {
-          if (periodic[i])
-            GridTools::collect_periodic_faces
-            (total_coarse_grid, /*b_id1*/ 2*i, /*b_id2*/ 2*i+1,
-             /*direction*/ i%dim, periodicity_vector);
-        }
-      if (periodicity_vector.size() > 0)
-        total_coarse_grid.add_periodicity (periodicity_vector);
-
-      // make sure the right boundary indicators are set after refinement
-      // through the function set_boundary_indicators above
-      total_coarse_grid.signals.post_refinement.connect (
-        [&]()
-      {
-        this->set_boundary_indicators(total_coarse_grid);
-      });
-    }
-
-
-    template <int dim>
-    std::set<types::boundary_id>
-    TwoMergedBoxes<dim>::
-    get_used_boundary_indicators () const
-    {
-      // boundary indicators are zero through 2*dim+2*(dim-1)-1
-      std::set<types::boundary_id> s;
-      for (unsigned int i=0; i<2*dim+2*(dim-1); ++i)
-        s.insert (i);
-      return s;
-    }
-
-
-
-    template <int dim>
-    std::map<std::string,types::boundary_id>
-    TwoMergedBoxes<dim>::
-    get_symbolic_boundary_names_map () const
-    {
-      switch (dim)
-        {
-          case 2:
-          {
-            return
-            {
-              {"left",   0},
-              {"right",  1},
-              {"bottom", 2},
-              {"top",    3},
-              {"left lithosphere", 4},
-              {"right lithosphere",5}
-            };
-          }
-
-          case 3:
-          {
-            return
-            {
-              {"left",   0},
-              {"right",  1},
-              {"front",  2},
-              {"back",   3},
-              {"bottom", 4},
-              {"top",    5},
-              {"left lithosphere",  6},
-              {"right lithosphere", 7},
-              {"front lithosphere", 8},
-              {"back lithosphere",  9}
-            };
-          }
-        }
-
-      Assert (false, ExcNotImplemented());
-      return {};
-    }
-
-
-
-    template <int dim>
-    std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>
-    TwoMergedBoxes<dim>::
-    get_periodic_boundary_pairs () const
-    {
-      std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>> periodic_boundaries;
-      for ( unsigned int i=0; i<dim+dim-1; ++i)
-        if (periodic[i])
-          {
-            const unsigned int direction = i>=dim ? i-dim : i;
-            periodic_boundaries.insert( std::make_pair( std::pair<types::boundary_id, types::boundary_id>(2*i, 2*i+1), direction) );
-          }
-      return periodic_boundaries;
-    }
-
-
-
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::adjust_positions_for_periodicity (Point<dim> &position,
-                                                           const ArrayView<Point<dim>> &connected_positions,
-                                                           const ArrayView<Tensor<1, dim>> &/*connected_velocities*/) const
-    {
-      for (unsigned int i = 0; i < dim; ++i)
-        if (periodic[i])
-          {
-            if (position[i] < lower_box_origin[i])
-              {
-                position[i] += extents[i];
-                for (auto &connected_position: connected_positions)
-                  connected_position[i] += extents[i];
-              }
-            else if (position[i] > lower_box_origin[i] + extents[i])
-              {
-                position[i] -= extents[i];
-                for (auto &connected_position: connected_positions)
-                  connected_position[i] -= extents[i];
-              }
-          }
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    TwoMergedBoxes<dim>::get_extents () const
-    {
-      return extents;
-    }
-
-    template <int dim>
-    Point<dim>
-    TwoMergedBoxes<dim>::get_origin () const
-    {
-      return lower_box_origin;
-    }
-
-    template <int dim>
-    double
-    TwoMergedBoxes<dim>::
-    length_scale () const
-    {
-      return 0.01*extents[0];
-    }
-
-
-    template <int dim>
-    double
-    TwoMergedBoxes<dim>::depth(const Point<dim> &position) const
-    {
-      const double d = maximal_depth()-(position(dim-1)-lower_box_origin[dim-1]);
-      return std::min (std::max (d, 0.), maximal_depth());
-    }
-
-
-    template <int dim>
-    double
-    TwoMergedBoxes<dim>::height_above_reference_surface(const Point<dim> &position) const
-    {
-      return (position(dim-1)-lower_box_origin[dim-1]) - extents[dim-1];
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    TwoMergedBoxes<dim>::representative_point(const double depth) const
-    {
-      Assert (depth >= 0,
-              ExcMessage ("Given depth must be positive or zero."));
-      Assert (depth <= maximal_depth(),
-              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
-
-      // choose a point on the center axis of the domain
-      Point<dim> p = extents/2+lower_box_origin;
-      p[dim-1] = extents[dim-1]+lower_box_origin[dim-1]-depth;
-
-      return p;
-    }
-
-
-    template <int dim>
-    double
-    TwoMergedBoxes<dim>::maximal_depth() const
-    {
-      return extents[dim-1];
-    }
-
-    template <int dim>
-    bool
-    TwoMergedBoxes<dim>::has_curved_elements() const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    bool
-    TwoMergedBoxes<dim>::point_is_in_domain(const Point<dim> &point) const
-    {
-      AssertThrow(!this->get_parameters().mesh_deformation_enabled == 0 ||
-                  this->simulator_is_past_initialization() == false,
-                  ExcMessage("After displacement of the mesh, this function can no longer be used to determine whether a point lies in the domain or not."));
-
-      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()),
-                  ExcMessage("After adding topography, this function can no longer be used to determine whether a point lies in the domain or not."));
-
-      for (unsigned int d = 0; d < dim; ++d)
-        if (point[d] > extents[d]+lower_box_origin[d]+std::numeric_limits<double>::epsilon()*extents[d] ||
-            point[d] < lower_box_origin[d]-std::numeric_limits<double>::epsilon()*extents[d])
-          return false;
-
-      return true;
-    }
-
-
-    template <int dim>
-    aspect::Utilities::Coordinates::CoordinateSystem
-    TwoMergedBoxes<dim>::natural_coordinate_system() const
-    {
-      return aspect::Utilities::Coordinates::CoordinateSystem::cartesian;
-    }
-
-
-    template <int dim>
-    std::array<double,dim>
-    TwoMergedBoxes<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
-    {
-      std::array<double,dim> position_array;
-      for (unsigned int i = 0; i < dim; ++i)
-        position_array[i] = position_point(i);
-
-      return position_array;
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    TwoMergedBoxes<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position_tensor) const
-    {
-      Point<dim> position_point;
-      for (unsigned int i = 0; i < dim; ++i)
-        position_point[i] = position_tensor[i];
-
-      return position_point;
-    }
-
-
-
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Box with lithosphere boundary indicators");
-        {
-          prm.declare_entry ("Lithospheric thickness", "0.2",
-                             Patterns::Double (0.),
-                             "The thickness of the lithosphere used to create "
-                             "additional boundary indicators to set specific "
-                             "boundary conditions for the lithosphere. ");
-
-          // Total box extents
-          prm.declare_entry ("X extent", "1.",
-                             Patterns::Double (0.),
-                             "Extent of the box in x-direction. Units: \\si{\\meter}.");
-          prm.declare_entry ("Y extent", "1.",
-                             Patterns::Double (0.),
-                             "Extent of the box in y-direction. Units: \\si{\\meter}.");
-          prm.declare_entry ("Z extent", "1.",
-                             Patterns::Double (0.),
-                             "Extent of the box in z-direction. This value is ignored "
-                             "if the simulation is in 2d. Units: \\si{\\meter}.");
-
-          // Total box origin
-          prm.declare_entry ("Box origin X coordinate", "0.",
-                             Patterns::Double (),
-                             "X coordinate of box origin. Units: \\si{\\meter}.");
-          prm.declare_entry ("Box origin Y coordinate", "0.",
-                             Patterns::Double (),
-                             "Y coordinate of box origin. Units: \\si{\\meter}.");
-          prm.declare_entry ("Box origin Z coordinate", "0.",
-                             Patterns::Double (),
-                             "Z coordinate of box origin. This value is ignored "
-                             "if the simulation is in 2d. Units: \\si{\\meter}.");
-
-          // Lower box repetitions
-          prm.declare_entry ("X repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in X direction of the lower box. "
-                             "The same number of repetitions will be used in the upper box.");
-          prm.declare_entry ("Y repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in Y direction of the lower box. If the simulation "
-                             "is in 3d, the same number of repetitions will be used in the upper box.");
-          prm.declare_entry ("Z repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in Z direction of the lower box. "
-                             "This value is ignored if the simulation is in 2d.");
-
-          // Upper box repetitions
-          prm.declare_entry ("Y repetitions lithosphere", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in Y direction in the lithosphere. "
-                             "This value is ignored if the simulation is in 3d.");
-          prm.declare_entry ("Z repetitions lithosphere", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in Z direction in the lithosphere. "
-                             "This value is ignored if the simulation is in 2d.");
-
-          // Whole box periodicity
-          prm.declare_entry ("X periodic", "false",
-                             Patterns::Bool (),
-                             "Whether the box should be periodic in X direction.");
-          prm.declare_entry ("Y periodic", "false",
-                             Patterns::Bool (),
-                             "Whether the box should be periodic in Y direction.");
-          prm.declare_entry ("Z periodic", "false",
-                             Patterns::Bool (),
-                             "Whether the box should be periodic in Z direction. "
-                             "This value is ignored if the simulation is in 2d.");
-          prm.declare_entry ("X periodic lithosphere", "false",
-                             Patterns::Bool (),
-                             "Whether the box should be periodic in X direction in the lithosphere.");
-          prm.declare_entry ("Y periodic lithosphere", "false",
-                             Patterns::Bool (),
-                             "Whether the box should be periodic in Y direction in the lithosphere. "
-                             "This value is ignored if the simulation is in 2d. ");
-
-          // grid creation parameters
-          prm.declare_entry ("Use merged grids", "true",
-                             Patterns::Bool (),
-                             "Whether to make the grid by gluing together two boxes, or just "
-                             "use one chunk to make the grid. Using two grids glued together "
-                             "is a safer option, since it forces the boundary conditions "
-                             "to be always applied to the same depth, but using one grid allows "
-                             "for a more flexible usage of the adaptive refinement. Note that if "
-                             "there is no cell boundary exactly on the boundary between the lithosphere "
-                             "and the mantle, the velocity boundary will not be exactly at that depth. "
-                             "Therefore, using a merged grid is generally recommended over using one grid."
-                             "When using one grid, the parameter for lower repetitions is used and the upper "
-                             "repetitions are ignored.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    TwoMergedBoxes<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Box with lithosphere boundary indicators");
-        {
-          const double thickness_lith = prm.get_double("Lithospheric thickness");
-
-          extents[0]           = prm.get_double ("X extent");
-          lower_extents[0]     = extents[0];
-          upper_extents[0]     = extents[0];
-          lower_box_origin[0]  = prm.get_double ("Box origin X coordinate");
-          upper_box_origin[0]  = lower_box_origin[0];
-          periodic[0]          = prm.get_bool ("X periodic");
-          periodic[dim]        = prm.get_bool ("X periodic lithosphere");
-          // to match the two triangulations, it is required that the
-          // number of horizontal repetitions are the same
-          lower_repetitions[0] = prm.get_integer ("X repetitions");
-          upper_repetitions[0] = lower_repetitions[0];
-
-          extents[1]           = prm.get_double ("Y extent");
-          lower_box_origin[1]  = prm.get_double ("Box origin Y coordinate");
-          periodic[1]          = prm.get_bool ("Y periodic");
-          lower_repetitions[1] = prm.get_integer ("Y repetitions");
-
-          if (dim == 2)
-            {
-              lower_extents[1]     = extents[1] - thickness_lith;
-              upper_extents[1]     = thickness_lith;
-              upper_box_origin[1]  = lower_box_origin[1] + lower_extents[1];
-              upper_repetitions[1] = prm.get_integer ("Y repetitions lithosphere");
-            }
-
-          if (dim == 3)
-            {
-              lower_extents[1]     = extents[1];
-              upper_extents[1]     = extents[1];
-              upper_box_origin[1]  = lower_box_origin[1];
-              periodic[dim+1]      = prm.get_bool ("Y periodic lithosphere");
-              // to match the two triangulations, it is required that the
-              // number of horizontal repetitions are the same
-              upper_repetitions[1] = lower_repetitions[1];
-              extents[2]           = prm.get_double ("Z extent");
-              lower_extents[2]     = extents[2] - thickness_lith;
-              upper_extents[2]     = thickness_lith;
-              lower_box_origin[2]  = prm.get_double ("Box origin Z coordinate");
-              upper_box_origin[2]  = lower_box_origin[2] + lower_extents[2];
-              periodic[2]          = prm.get_bool ("Z periodic");
-              lower_repetitions[2] = prm.get_integer ("Z repetitions");
-              upper_repetitions[2] = prm.get_integer ("Z repetitions lithosphere");
-            }
-
-          height_lith = upper_box_origin[dim-1];
-          use_merged_grids = prm.get_bool ("Use merged grids");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    ASPECT_REGISTER_GEOMETRY_MODEL(TwoMergedBoxes,
-                                   "box with lithosphere boundary indicators",
-                                   "A box geometry parallel to the coordinate directions. "
-                                   "The extent of the box in each coordinate direction "
-                                   "is set in the parameter file. This geometry model labels its "
-                                   "sides with 2*dim+2*(dim-1) boundary indicators: in 2d, boundary indicators 0 through 3 "
-                                   "denote the left, right, bottom and top boundaries, while indicators"
-                                   "4 and 5 denote the upper part of the left and right vertical boundary, "
-                                   "respectively. In 3d, boundary "
-                                   "indicators 0 through 5 indicate left, right, front, back, bottom "
-                                   "and top boundaries (see also the documentation of the deal.II class "
-                                   "``ReferenceCell''), while indicators 6, 7, 8 and 9 denote the left, "
-                                   "right, front and back upper parts of the vertical boundaries, respectively. "
-                                   "You can also use symbolic names ``left'', ``right'', "
-                                   "``left lithosphere'', etc., to refer to these boundaries in input files."
-                                   "\n\n"
-                                   "Note that for a given ``Global refinement level'' and no user-specified "
-                                   "``Repetitions'', the lithosphere part of the mesh will be more refined. "
-                                   "\n\n"
-                                   "The additional boundary indicators for the lithosphere allow for "
-                                   "selecting boundary conditions for the "
-                                   "lithosphere different from those for the underlying mantle. "
-                                   "An example application of this geometry is to prescribe a velocity on "
-                                   "the lithospheric plates, but use open boundary conditions underneath. ")
-  }
-}
diff --git a/source/geometry_model/two_merged_chunks.cc.bak b/source/geometry_model/two_merged_chunks.cc.bak
deleted file mode 100644
index 1c120768195..00000000000
--- a/source/geometry_model/two_merged_chunks.cc.bak
+++ /dev/null
@@ -1,635 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/geometry_model/two_merged_chunks.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-#include <aspect/geometry_model/initial_topography_model/ascii_data.h>
-
-#include <aspect/simulator_signals.h>
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/tria_accessor.h>
-#include <deal.II/grid/grid_tools.h>
-#include <deal.II/grid/tria.h>
-
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    template <int dim>
-    void
-    TwoMergedChunks<dim>::initialize ()
-    {
-      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()) ||
-                  Plugins::plugin_type_matches<const InitialTopographyModel::AsciiData<dim>>(this->get_initial_topography_model()),
-                  ExcMessage("At the moment, only the Zero or AsciiData initial topography model can be used with the TwoMergedChunks geometry model."));
-
-      manifold = std::make_unique<internal::ChunkGeometry<dim>>(this->get_initial_topography_model(),
-                                                                 point1[1],
-                                                                 point1[0],
-                                                                 point2[0]-point1[0]);
-    }
-
-
-
-    template <int dim>
-    void
-    TwoMergedChunks<dim>::
-    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
-    {
-      if (use_merged_grids)
-        {
-          // The two triangulations that will be merged into coarse_grid.
-          Triangulation<dim> lower_coarse_grid;
-          Triangulation<dim> upper_coarse_grid;
-
-          const std::vector<unsigned int> lower_rep_vec(lower_repetitions.begin(), lower_repetitions.end());
-          const std::vector<unsigned int> upper_rep_vec(upper_repetitions.begin(), upper_repetitions.end());
-
-          // Create the lower box.
-          GridGenerator::subdivided_hyper_rectangle (lower_coarse_grid,
-                                                     lower_rep_vec,
-                                                     point1,
-                                                     point4,
-                                                     false);
-
-          // Create the upper box.
-          GridGenerator::subdivided_hyper_rectangle (upper_coarse_grid,
-                                                     upper_rep_vec,
-                                                     point3,
-                                                     point2,
-                                                     false);
-
-          // Merge the lower and upper mesh into one coarse_grid.
-          // Now we have at least two cells.
-          GridGenerator::merge_triangulations(lower_coarse_grid,
-                                              upper_coarse_grid,
-                                              coarse_grid);
-        }
-      else
-        {
-          const std::vector<unsigned int> lower_rep_vec(lower_repetitions.begin(), lower_repetitions.end());
-          GridGenerator::subdivided_hyper_rectangle (coarse_grid,
-                                                     lower_rep_vec,
-                                                     point1,
-                                                     point2,
-                                                     false);
-
-        }
-
-      // Transform box into spherical chunk
-      GridTools::transform (
-        [&](const Point<dim> &p) -> Point<dim>
-      {
-        return manifold->push_forward(p);
-      },
-      coarse_grid);
-
-      // Deal with a curved mesh by assigning a manifold. We arbitrarily
-      // choose manifold_id 15 for this.
-      coarse_grid.set_manifold (my_manifold_id, *manifold);
-      for (const auto &cell : coarse_grid.active_cell_iterators())
-        cell->set_all_manifold_ids (my_manifold_id);
-
-      // Set the boundary indicators.
-      set_boundary_indicators(coarse_grid);
-      // Make sure the right boundary indicators are set after refinement
-      // through the function set_boundary_indicators above.
-      coarse_grid.signals.post_refinement.connect (
-        [&]()
-      {
-        this->set_boundary_indicators(coarse_grid);
-      });
-    }
-
-
-
-    template <int dim>
-    void
-    TwoMergedChunks<dim>::
-    set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const
-    {
-      // Iterate over all active cells and (re)set the boundary indicators.
-      for (typename Triangulation<dim>::active_cell_iterator
-           cell = triangulation.begin_active();
-           cell != triangulation.end();
-           ++cell)
-        {
-          // First set the default boundary indicators.
-          for (const unsigned int f : cell->face_indices())
-            if (cell->face(f)->at_boundary())
-              cell->face(f)->set_boundary_id (f);
-
-          if (cell->face(3)->at_boundary())
-            // Set the upper part of the eastern boundary to indicator 2*dim+1
-            // by comparing the radius of the face's center point with the
-            // minimum radius of the upper radius.
-            if (cell->face(3)->center(true).norm() > point3[0])
-              cell->face(3)->set_boundary_id(2 * dim + 1);
-
-          if (cell->face(2)->at_boundary())
-            // Set the upper part of the western boundary to indicator 2*dim
-            // by comparing the radius of the face's center point with the
-            // minimum radius of the upper radius.
-            if (cell->face(2)->center(true).norm() > point3[0])
-              cell->face(2)->set_boundary_id (2*dim);
-
-          if (dim==3)
-            {
-              // Set the upper part of the southern boundary to indicator 2*dim+2.
-              if (cell->face(4)->at_boundary())
-                if ((cell->vertex(cell->face(4)->n_vertices()-1).norm() + cell->vertex(0).norm()) / 2.0 > point3[0])
-                  cell->face(4)->set_boundary_id (2*dim+2);
-
-              // Set the upper part of the northern boundary to indicator 2*dim+3.
-              if (cell->face(5)->at_boundary())
-                if ((cell->vertex((cell->face(5)->n_vertices()-1)/2).norm()  + cell->vertex(0).norm()) / 2.0 > point3[0])
-                  cell->face(5)->set_boundary_id (2*dim+3);
-            }
-
-        }
-    }
-
-
-
-    template <int dim>
-    std::set<types::boundary_id>
-    TwoMergedChunks<dim>::
-    get_used_boundary_indicators () const
-    {
-      // boundary indicators are zero through 2*dim+2*(dim-1)-1
-      std::set<types::boundary_id> s;
-      for (unsigned int i=0; i<2*dim+2*(dim-1); ++i)
-        s.insert (i);
-      return s;
-    }
-
-
-
-    template <int dim>
-    std::map<std::string,types::boundary_id>
-    TwoMergedChunks<dim>::
-    get_symbolic_boundary_names_map () const
-    {
-      switch (dim)
-        {
-          case 2:
-          {
-            return
-            {
-              {"bottom",     0},
-              {"top",        1},
-              {"lowerwest",  2},
-              {"lowereast",  3},
-              {"uppereast",  4},
-              {"upperwest",  5}
-            };
-          }
-
-          case 3:
-          {
-            return
-            {
-              {"bottom",     0},
-              {"top",        1},
-              {"lowerwest",  2},
-              {"lowereast",  3},
-              {"lowersouth", 4},
-              {"lowernorth", 5},
-              {"upperwest",  6},
-              {"uppereast",  7},
-              {"uppersouth", 8},
-              {"uppernorth", 9}
-            };
-          }
-        }
-
-      Assert (false, ExcNotImplemented());
-      return {};
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::
-    length_scale () const
-    {
-      // As described in the first ASPECT paper, a length scale of
-      // 10km = 1e4m works well for the pressure scaling for earth
-      // sized spherical shells. use a length scale that
-      // yields this value for the R0,R1 corresponding to earth
-      // but otherwise scales like (R1-R0)
-      return 1e4 * maximal_depth() / (6336000.-3481000.);
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::depth(const Point<dim> &position) const
-    {
-      // depth is defined wrt the reference surface point2[0]
-      // negative depth is not allowed
-      return std::max (0., std::min (point2[0]-position.norm(), maximal_depth()));
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::height_above_reference_surface(const Point<dim> &position) const
-    {
-      return position.norm()-point2[0];
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    TwoMergedChunks<dim>::representative_point(const double depth) const
-    {
-      Assert (depth >= 0,
-              ExcMessage ("Given depth must be positive or zero."));
-      Assert (depth <= maximal_depth(),
-              ExcMessage ("Given depth must be less than or equal to the maximal depth of this geometry."));
-
-      // Choose a point at the mean longitude (and latitude)
-      Point<dim> p = 0.5*(point2+point1);
-      // at a depth beneath the top surface
-      p[0] = point2[0]-depth;
-
-      // Now convert to Cartesian coordinates
-      return manifold->push_forward_sphere(p);
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::west_longitude () const
-    {
-      return point1[1];
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::east_longitude () const
-    {
-      return point2[1];
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::longitude_range () const
-    {
-      return point2[1] - point1[1];
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::south_latitude () const
-    {
-      if (dim == 3)
-        return point1[2];
-      else
-        return 0;
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::north_latitude () const
-    {
-      if (dim==3)
-        return point2[2];
-      else
-        return 0;
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::latitude_range () const
-    {
-      if (dim==3)
-        return point2[2] - point1[2];
-      else
-        return 0;
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::maximal_depth() const
-    {
-      return point2[0]-point1[0];
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::inner_radius () const
-    {
-      return point1[0];
-    }
-
-
-
-    template <int dim>
-    double
-    TwoMergedChunks<dim>::outer_radius () const
-    {
-      return point2[0];
-    }
-
-
-
-    template <int dim>
-    bool
-    TwoMergedChunks<dim>::has_curved_elements() const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    bool
-    TwoMergedChunks<dim>::point_is_in_domain(const Point<dim> &point) const
-    {
-      AssertThrow(!this->get_parameters().mesh_deformation_enabled ||
-                  // we are still before the first time step has started
-                  this->get_timestep_number() == 0 ||
-                  this->get_timestep_number() == numbers::invalid_unsigned_int,
-                  ExcMessage("After displacement of the mesh, this function can no longer be used to determine whether a point lies in the domain or not."));
-
-      AssertThrow(Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()),
-                  ExcMessage("After adding topography, this function can no longer be used to determine whether a point lies in the domain or not."));
-
-      const Point<dim> spherical_point = manifold->pull_back(point);
-
-      for (unsigned int d = 0; d < dim; ++d)
-        if (spherical_point[d] > point2[d]+std::numeric_limits<double>::epsilon()*std::abs(point2[d]) ||
-            spherical_point[d] < point1[d]-std::numeric_limits<double>::epsilon()*std::abs(point2[d]))
-          return false;
-
-      return true;
-    }
-
-
-
-    template <int dim>
-    std::array<double,dim>
-    TwoMergedChunks<dim>::cartesian_to_natural_coordinates(const Point<dim> &position_point) const
-    {
-      // the chunk manifold has a order of radius, longitude, latitude.
-      // This is exactly what we need.
-      // Ignore the topography to avoid a loop when calling the
-      // AsciiDataBoundary for topography which uses this function....
-      const Point<dim> transformed_point = manifold->pull_back_sphere(position_point);
-      std::array<double,dim> position_array;
-      for (unsigned int i = 0; i < dim; ++i)
-        position_array[i] = transformed_point(i);
-
-      return position_array;
-    }
-
-
-
-    template <int dim>
-    aspect::Utilities::Coordinates::CoordinateSystem
-    TwoMergedChunks<dim>::natural_coordinate_system() const
-    {
-      // TODO This will give problems somewhere down the line
-      // if geometry models are asked for their coordinate system,
-      // chunk returns spherical and then Utilities::Coordinates::cartesian_to_spherical
-      // is used
-      return aspect::Utilities::Coordinates::CoordinateSystem::spherical;
-    }
-
-
-
-    template <int dim>
-    Point<dim>
-    TwoMergedChunks<dim>::natural_to_cartesian_coordinates(const std::array<double,dim> &position_tensor) const
-    {
-      // Ignore the topography to avoid a loop when calling the
-      // AsciiDataBoundary for topography which uses this function....
-      Point<dim> position_point;
-      for (unsigned int i = 0; i < dim; ++i)
-        position_point[i] = position_tensor[i];
-      const Point<dim> transformed_point = manifold->push_forward_sphere(position_point);
-
-      return transformed_point;
-    }
-
-
-
-    template <int dim>
-    void
-    TwoMergedChunks<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Chunk with lithosphere boundary indicators");
-        {
-          prm.declare_entry ("Chunk inner radius", "0.",
-                             Patterns::Double (0.),
-                             "Radius at the bottom surface of the chunk. Units: \\si{\\meter}.");
-          prm.declare_entry ("Chunk outer radius", "1.",
-                             Patterns::Double (0.),
-                             "Radius at the top surface of the chunk. Units: \\si{\\meter}.");
-          prm.declare_entry ("Chunk middle boundary radius", "1",
-                             Patterns::Double (0),
-                             "Radius at the top surface of the lower chunk, "
-                             "where it merges with the upper chunk. Units: \\si{\\meter}.");
-
-          prm.declare_entry ("Chunk minimum longitude", "0.",
-                             Patterns::Double (-180., 360.), // enables crossing of either hemisphere
-                             "Minimum longitude of the chunk. Units: degrees.");
-          prm.declare_entry ("Chunk maximum longitude", "1.",
-                             Patterns::Double (-180., 360.), // enables crossing of either hemisphere
-                             "Maximum longitude of the chunk. Units: degrees.");
-
-          prm.declare_entry ("Chunk minimum latitude", "0.",
-                             Patterns::Double (-90., 90.),
-                             "Minimum latitude of the chunk. This value is ignored "
-                             "if the simulation is in 2d. Units: degrees.");
-          prm.declare_entry ("Chunk maximum latitude", "1.",
-                             Patterns::Double (-90., 90.),
-                             "Maximum latitude of the chunk. This value is ignored "
-                             "if the simulation is in 2d. Units: degrees.");
-
-          prm.declare_entry ("Outer chunk radius repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in radial direction for the upper chunk.");
-          prm.declare_entry ("Inner chunk radius repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in radial direction for the lower chunk.");
-          prm.declare_entry ("Longitude repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in longitude.");
-          prm.declare_entry ("Latitude repetitions", "1",
-                             Patterns::Integer (1),
-                             "Number of cells in latitude. This value is ignored "
-                             "if the simulation is in 2d");
-
-          prm.declare_entry ("Use merged grids", "true",
-                             Patterns::Bool (),
-                             "Whether to make the grid by gluing together two boxes, or just "
-                             "use one chunk to make the grid. Using two grids glued together "
-                             "is a safer option, since it forces the boundary conditions "
-                             "to be always applied to the same depth, but using one grid allows "
-                             "for a more flexible usage of the adaptive refinement. Note that if "
-                             "there is no cell boundary exactly on the boundary between the lithosphere "
-                             "and the mantle, the velocity boundary will not be exactly at that depth. "
-                             "Therefore, using a merged "
-                             "grid is generally recommended over using one grid. "
-                             "When using one grid, the parameter for lower repetitions is used and the upper "
-                             "repetitions are ignored.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    TwoMergedChunks<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Chunk with lithosphere boundary indicators");
-        {
-          point1[0] = prm.get_double("Chunk inner radius");
-          point2[0] = prm.get_double("Chunk outer radius");
-          point3[0] = prm.get_double("Chunk middle boundary radius");
-          point4[0] = point3[0];
-          lower_repetitions[0] = prm.get_integer("Inner chunk radius repetitions");
-          upper_repetitions[0] = prm.get_integer("Outer chunk radius repetitions");
-          point1[1] = prm.get_double("Chunk minimum longitude") * constants::degree_to_radians;
-          point2[1] = prm.get_double("Chunk maximum longitude") * constants::degree_to_radians;
-          point3[1] = point1[1];
-          point4[1] = point2[1];
-          lower_repetitions[1] = prm.get_integer("Longitude repetitions");
-          upper_repetitions[1] = lower_repetitions[1];
-
-          AssertThrow(point1[0] < point2[0],
-                      ExcMessage("Inner radius must be less than outer radius."));
-          AssertThrow(point1[1] < point2[1],
-                      ExcMessage("Minimum longitude must be less than maximum longitude."));
-          AssertThrow(point2[1] - point1[1] < 2. * numbers::PI,
-                      ExcMessage("Maximum - minimum longitude should be less than 360 degrees."));
-          AssertThrow(point3[0] < point2[0],
-                      ExcMessage("Middle boundary radius must be less than outer radius."));
-
-          if (dim == 3)
-            {
-              point1[2] = prm.get_double ("Chunk minimum latitude") * constants::degree_to_radians;
-              point2[2] = prm.get_double ("Chunk maximum latitude") * constants::degree_to_radians;
-              point3[2] = point1[2];
-              point4[2] = point2[2];
-              lower_repetitions[2] = prm.get_integer ("Latitude repetitions");
-              upper_repetitions[2] = lower_repetitions[2];
-
-              AssertThrow (point1[2] < point2[2],
-                           ExcMessage ("Minimum latitude must be less than maximum latitude."));
-              AssertThrow (point1[2] > -0.5*numbers::PI,
-                           ExcMessage ("Minimum latitude needs to be larger than -90 degrees."));
-              AssertThrow (point2[2] < 0.5*numbers::PI,
-                           ExcMessage ("Maximum latitude needs to be less than 90 degrees."));
-            }
-          use_merged_grids = prm.get_bool ("Use merged grids");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    ASPECT_REGISTER_GEOMETRY_MODEL(TwoMergedChunks,
-                                   "chunk with lithosphere boundary indicators",
-                                   "A geometry which can be described as a chunk of a spherical shell, "
-                                   "bounded by lines of longitude, latitude and radius. "
-                                   "The side boundaries have two boundary indicators, so the user "
-                                   "can prescribe different boundary conditions on these boundaries. "
-                                   "The minimum and maximum longitude, (latitude) and depth of the chunk "
-                                   "are set in the parameter file. The chunk geometry labels its "
-                                   "2*dim+2*(dim-1) sides as follows: ``lowerwest'' and ``lowereast'': "
-                                   "minimum and maximum longitude of the lower part of the east and west "
-                                   "side boundaries, ``upperwest'' and ``uppereast'': "
-                                   "minimum and maximum longitude of the upper part of the east and west "
-                                   "side boundaries, ``lowersouth'' and ``lowernorth'': "
-                                   "minimum and maximum latitude of the lower part of the south and north "
-                                   "side boundaries, ``uppersouth'' and ``uppernorth'': "
-                                   "minimum and maximum latitude of the upper part of the south and north "
-                                   "side boundaries, "
-                                   "\n\n"
-                                   "The dimensions of the model are specified by parameters "
-                                   "of the following form: "
-                                   "Chunk (minimum | maximum) (longitude | latitude): "
-                                   "edges of geographical quadrangle (in degrees). "
-                                   "Chunk (inner | outer | middle boundary) radius: Radii at bottom and top of chunk "
-                                   "and the radius at which the lower boundary indicator along a side "
-                                   "boundary transitions into the upper boundary indicator. "
-                                   "(Longitude | Latitude) repetitions: "
-                                   "number of cells in each coordinate direction."
-                                   "(Inner | Outer) chunk radius repetitions: "
-                                   "number of cells in the radial coordinate direction for the lower part "
-                                   "of the domain (up to the Middle boundary radius) and for the upper part "
-                                   "of the domain. "
-                                   "\n\n"
-                                   "When used in 2d, this geometry does not imply the use of "
-                                   "a spherical coordinate system. Indeed, "
-                                   "in 2d the geometry is simply a sector of an annulus in a Cartesian "
-                                   "coordinate system and consequently would correspond to "
-                                   "a sector of a cross section of the fluid filled space between two "
-                                   "infinite cylinders where one has made the assumption that "
-                                   "the velocity in direction of the cylinder axes is zero. "
-                                   "This is consistent with the definition of what we consider "
-                                   "the two-dimension case given in "
-                                   "Section~\\ref{sec:methods:2d-models}. "
-                                   "It is also possible to add initial topography to the chunk geometry, "
-                                   "based on an ascii data file. ")
-  }
-}
diff --git a/source/global.cc.bak b/source/global.cc.bak
deleted file mode 100644
index e3d9292375a..00000000000
--- a/source/global.cc.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/revision.h>
-
-#include <deal.II/base/multithread_info.h>
-#include <deal.II/base/revision.h>
-#include <deal.II/base/vectorization.h>
-
-#ifdef ASPECT_WITH_WORLD_BUILDER
-#include <world_builder/config.h>
-#endif
-
-#include <cstring>
-
-
-
-template <class Stream>
-void print_aspect_header(Stream &stream)
-{
-  const int n_tasks = dealii::Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD);
-
-  stream << "-----------------------------------------------------------------------------\n"
-         << "--                             This is ASPECT                              --\n"
-         << "-- The Advanced Solver for Planetary Evolution, Convection, and Tectonics. --\n"
-         << "-----------------------------------------------------------------------------\n"
-         << "--     . version " << ASPECT_PACKAGE_VERSION;
-  if (strcmp(ASPECT_GIT_BRANCH,"") != 0)
-    stream << " (" << ASPECT_GIT_BRANCH << ", " << ASPECT_GIT_SHORTREV << ")\n";
-  else
-    stream << "\n";
-
-  stream << "--     . using deal.II " << DEAL_II_PACKAGE_VERSION;
-  if (strcmp(DEAL_II_GIT_BRANCH,"") != 0)
-    stream << " (" << DEAL_II_GIT_BRANCH << ", " << DEAL_II_GIT_SHORTREV << ')';
-  stream << "\n";
-  stream << "--     .       with "
-#ifdef DEAL_II_WITH_64BIT_INDICES
-         << "64"
-#else
-         << "32"
-#endif
-         << " bit indices\n";
-
-  const unsigned int n_vectorization_doubles = dealii::VectorizedArray<double>::size();
-  const unsigned int n_vectorization_bits = 8 * sizeof(double) * n_vectorization_doubles;
-  const std::string vectorization_level = dealii::Utilities::System::get_current_vectorization_level();
-
-  stream << "--     .       with vectorization level ";
-  stream << DEAL_II_COMPILER_VECTORIZATION_LEVEL
-         << " (" << vectorization_level << ", "
-         << n_vectorization_doubles << " doubles, "
-         << n_vectorization_bits << " bits)\n";
-
-  stream << "--     . using Trilinos "
-         << DEAL_II_TRILINOS_VERSION_MAJOR    << '.'
-         << DEAL_II_TRILINOS_VERSION_MINOR    << '.'
-         << DEAL_II_TRILINOS_VERSION_SUBMINOR << '\n';
-  stream << "--     . using p4est "
-         << DEAL_II_P4EST_VERSION_MAJOR << '.'
-         << DEAL_II_P4EST_VERSION_MINOR << '.'
-         << DEAL_II_P4EST_VERSION_SUBMINOR << '\n';
-
-#ifdef ASPECT_WITH_WORLD_BUILDER
-  stream << "--     . using Geodynamic World Builder "
-         << WORLD_BUILDER_VERSION_MAJOR << '.'
-         << WORLD_BUILDER_VERSION_MINOR << '.'
-         << WORLD_BUILDER_VERSION_PATCH;
-
-  if (WorldBuilder::Version::GIT_SHA1 != "")
-    stream << " (" << WorldBuilder::Version::GIT_BRANCH << ", " << WorldBuilder::Version::GIT_SHA1.substr(0,9) << ')';
-
-  stream << '\n';
-#endif
-
-#ifdef DEBUG
-  stream << "--     . running in DEBUG mode\n"
-#else
-  stream << "--     . running in OPTIMIZED mode\n"
-#endif
-         << "--     . running with " << n_tasks << " MPI process" << (n_tasks == 1 ? "\n" : "es\n");
-
-  const int n_threads =
-    dealii::MultithreadInfo::n_threads();
-  if (n_threads>1)
-    stream << "--     . using " << n_threads << " threads " << (n_tasks == 1 ? "\n" : "each\n");
-
-  stream << "-----------------------------------------------------------------------------\n"
-         << std::endl;
-}
-
-template void print_aspect_header<std::ostream> (std::ostream &stream);
-template void print_aspect_header<std::ofstream> (std::ofstream &stream);
diff --git a/source/gravity_model/ascii_data.cc.bak b/source/gravity_model/ascii_data.cc.bak
deleted file mode 100644
index 0bea4da69a3..00000000000
--- a/source/gravity_model/ascii_data.cc.bak
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-  Copyright (C) 2016 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/gravity_model/ascii_data.h>
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace GravityModel
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      :
-      gravity_index(numbers::invalid_unsigned_int)
-    {}
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      this->initialize(this->get_mpi_communicator());
-      gravity_index = this->get_column_index_from_name("gravity");
-    }
-
-
-    template <int dim>
-    Tensor<1,dim>
-    AsciiData<dim>::
-    gravity_vector (const Point<dim> &position) const
-    {
-      const double depth = this->get_geometry_model().depth(position);
-      const double magnitude = this->get_data_component(Point<1>(depth),gravity_index);
-
-      // in dependence of what the geometry model is, gravity points in a different direction
-      if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical ||
-          this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::ellipsoidal)
-        return - magnitude * position/position.norm();
-      else if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::cartesian)
-        {
-          Tensor<1,dim> g;
-          g[dim-1] = -magnitude;
-          return g;
-        }
-      else
-        AssertThrow (false,
-                     ExcMessage ("Not a valid geometry model for the gravity model"
-                                 "ascii data."));
-      return Tensor<1,dim>();
-    }
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // we use the same file that is used for the adiabatic conditions model,
-      // as it also contains gravity
-      prm.enter_subsection("Gravity model");
-      {
-        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                          "$ASPECT_SOURCE_DIR/data/gravity-model/",
-                                                          "prem.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Gravity model");
-      {
-        Utilities::AsciiDataBase<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GravityModel
-  {
-    ASPECT_REGISTER_GRAVITY_MODEL(AsciiData,
-                                  "ascii data",
-                                  "Gravity is read from a file that describes the reference "
-                                  "state. The default profile follows the preliminary "
-                                  "reference Earth model (PREM, Dziewonski and Anderson, 1981). "
-                                  "Note the required format of the "
-                                  "input data: The first lines may contain any number of comments "
-                                  "if they begin with `#', but one of these lines needs to "
-                                  "contain the number of points in the reference state as "
-                                  "for example `# POINTS: 3'. "
-                                  "Following the comment lines there has to be a single line "
-                                  "containing the names of all data columns, separated by arbitrarily "
-                                  "many spaces. Column names are not allowed to contain spaces. "
-                                  "The file can contain unnecessary columns, but for this plugin it "
-                                  "needs to at least provide a column named `gravity'. "
-                                  "Note that the data lines in the file need to be sorted in order "
-                                  "of increasing depth from 0 to the maximal depth in the model "
-                                  "domain. Points in the model that are outside of the provided "
-                                  "depth range will be assigned the maximum or minimum depth values, "
-                                  "respectively. Points do not need to be equidistant, "
-                                  "but the computation of properties is optimized in speed "
-                                  "if they are.")
-  }
-}
diff --git a/source/gravity_model/function.cc.bak b/source/gravity_model/function.cc.bak
deleted file mode 100644
index a3c31bef2bd..00000000000
--- a/source/gravity_model/function.cc.bak
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/gravity_model/function.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <iostream>
-
-namespace aspect
-{
-  namespace GravityModel
-  {
-    template <int dim>
-    Function<dim>::Function ()
-      :
-      function (dim)
-    {}
-
-    template <int dim>
-    Tensor<1,dim>
-    Function<dim>::
-    gravity_vector (const Point<dim> &position) const
-    {
-      Tensor<1,dim> gravity;
-      const Utilities::NaturalCoordinate<dim> point =
-        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
-      const Point<dim> point_in_coordinate_system = Utilities::convert_array_to_point<dim>(point.get_coordinates());
-      for (unsigned int d=0; d<dim; ++d)
-        gravity[d] = function.value(point_in_coordinate_system,d);
-      return gravity;
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::update()
-    {
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        function.set_time (this->get_time() / year_in_seconds);
-      else
-        function.set_time (this->get_time());
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Gravity model");
-      {
-        prm.enter_subsection("Function");
-        {
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle. `depth' "
-                             "will create a function, in which only the first "
-                             "parameter is non-zero, which is interpreted to "
-                             "be the depth of the point.");
-
-          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Gravity model");
-      {
-        prm.enter_subsection("Function");
-        {
-          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-        }
-        try
-          {
-            function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Gravity Model.Function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GravityModel
-  {
-    ASPECT_REGISTER_GRAVITY_MODEL(Function,
-                                  "function",
-                                  "Gravity is given in terms of an explicit formula "
-                                  "that is elaborated in the parameters in section "
-                                  "``Gravity model|Function''. The format of these "
-                                  "functions follows the syntax understood by the "
-                                  "muparser library, see "
-                                  "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-  }
-}
diff --git a/source/gravity_model/interface.cc.bak b/source/gravity_model/interface.cc.bak
deleted file mode 100644
index c657036a514..00000000000
--- a/source/gravity_model/interface.cc.bak
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace GravityModel
-  {
-// -------------------------------- Deal with registering gravity models and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    register_gravity_model (const std::string &name,
-                            const std::string &description,
-                            void (*declare_parameters_function) (ParameterHandler &),
-                            std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_gravity_model (ParameterHandler &prm)
-    {
-      std::string model_name;
-      prm.enter_subsection ("Gravity model");
-      {
-        model_name = prm.get ("Model name");
-      }
-      prm.leave_subsection ();
-
-      // If one sets the model name to an empty string in the input file,
-      // ParameterHandler produces an error while reading the file. However,
-      // if one omits specifying any model name at all (not even setting it to
-      // the empty string) then the value we get here is the empty string. If
-      // we don't catch this case here, we end up with awkward downstream
-      // errors because the value obviously does not conform to the Pattern.
-      AssertThrow(model_name != "unspecified",
-                  ExcMessage("You need to select a Gravity model "
-                             "(`set Model name' in `subsection Gravity model')."));
-
-      return std::get<dim>(registered_plugins).create_plugin (model_name,
-                                                              "Gravity model::Model name");
-    }
-
-
-
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm)
-    {
-      // declare the entry in the parameter file
-      prm.enter_subsection ("Gravity model");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-        prm.declare_entry ("Model name", "unspecified",
-                           Patterns::Selection (pattern_of_names+"|unspecified"),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Gravity model interface",
-                                                            out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<GravityModel::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<GravityModel::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<GravityModel::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<GravityModel::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace GravityModel
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_gravity_model<dim> (const std::string &, \
-                               const std::string &, \
-                               void ( *) (ParameterHandler &), \
-                               std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_gravity_model<dim> (ParameterHandler &prm);
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/gravity_model/radial.cc.bak b/source/gravity_model/radial.cc.bak
deleted file mode 100644
index 86b59a38141..00000000000
--- a/source/gravity_model/radial.cc.bak
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
-  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/gravity_model/radial.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/tensor.h>
-
-namespace aspect
-{
-  namespace GravityModel
-  {
-// ------------------------------ RadialConstant -------------------
-    template <int dim>
-    Tensor<1,dim>
-    RadialConstant<dim>::gravity_vector (const Point<dim> &p) const
-    {
-      if (p.norm() == 0.0)
-        return Tensor<1,dim>();
-
-      const double r = p.norm();
-      return -magnitude * p/r;
-    }
-
-
-
-    template <int dim>
-    void
-    RadialConstant<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Gravity model");
-      {
-        prm.enter_subsection("Radial constant");
-        {
-          prm.declare_entry ("Magnitude", "9.81",
-                             Patterns::Double (),
-                             "Magnitude of the gravity vector in $m/s^2$. For positive values "
-                             "the direction is radially inward towards the center of the earth.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    RadialConstant<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Gravity model");
-      {
-        prm.enter_subsection("Radial constant");
-        {
-          magnitude = prm.get_double ("Magnitude");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical ||
-                   this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::ellipsoidal,
-                   ExcMessage ("Gravity model 'radial constant' should not be used with geometry models that "
-                               "do not have either a spherical or ellipsoidal natural coordinate system."));
-    }
-
-// ------------------------------ RadialEarthLike -------------------
-
-    template <int dim>
-    void
-    RadialEarthLike<dim>::initialize ()
-    {
-      AssertThrow(false,
-                  ExcMessage("The 'radial earth-like' gravity model has been removed "
-                             "due to its misleading name. The available AsciiData gravity "
-                             "model (using default parameters) is much more earth-like, since "
-                             "it uses the gravity profile used in the construction of the "
-                             "Preliminary Reference Earth Model (PREM, Dziewonski and Anderson, "
-                             "1981). Use the 'ascii data' model instead of 'radial earth-like'."));
-    }
-
-
-
-    template <int dim>
-    Tensor<1,dim>
-    RadialEarthLike<dim>::gravity_vector (const Point<dim> &/*p*/) const
-    {
-      // We should never get here, because of the assertion in initialize().
-      AssertThrow(false,ExcInternalError());
-      return Tensor<1,dim>();
-    }
-
-
-// ----------------------------- RadialLinear ----------------------
-
-
-    template <int dim>
-    Tensor<1,dim>
-    RadialLinear<dim>::gravity_vector (const Point<dim> &p) const
-    {
-      if (p.norm() == 0.0)
-        return Tensor<1,dim>();
-
-      const double depth = this->get_geometry_model().depth(p);
-      const double maximal_depth = this->get_geometry_model().maximal_depth();
-
-      return  (-magnitude_at_surface * (1.0 - depth/maximal_depth)
-               -magnitude_at_bottom  * (depth/maximal_depth))
-              * p/p.norm();
-    }
-
-
-    template <int dim>
-    void
-    RadialLinear<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Gravity model");
-      {
-        prm.enter_subsection("Radial linear");
-        {
-          prm.declare_entry ("Magnitude at surface", "9.8",
-                             Patterns::Double (),
-                             "Magnitude of the radial gravity vector "
-                             "at the surface of the domain. "
-                             "Units: \\si{\\meter\\per\\second\\squared}.");
-          prm.declare_entry ("Magnitude at bottom", "10.7",
-                             Patterns::Double (),
-                             "Magnitude of the radial gravity vector "
-                             "at the bottom of the domain. `Bottom' means the"
-                             "maximum depth in the chosen geometry, and for "
-                             "example represents the core-mantle boundary in "
-                             "the case of the `spherical shell' geometry model, "
-                             "and the center in the case of the `sphere' "
-                             "geometry model. Units: \\si{\\meter\\per\\second\\squared}.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    RadialLinear<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Gravity model");
-      {
-        prm.enter_subsection("Radial linear");
-        {
-          magnitude_at_surface = prm.get_double ("Magnitude at surface");
-          magnitude_at_bottom = prm.get_double ("Magnitude at bottom");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical ||
-                   this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::ellipsoidal,
-                   ExcMessage ("Gravity model 'radial linear' should not be used with geometry models that "
-                               "do not have either a spherical or ellipsoidal natural coordinate system."));
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GravityModel
-  {
-    ASPECT_REGISTER_GRAVITY_MODEL(RadialConstant,
-                                  "radial constant",
-                                  "A gravity model in which the gravity has a constant magnitude "
-                                  "and the direction is radial (pointing inward if the value "
-                                  "is positive). The magnitude is read from the parameter "
-                                  "file in subsection 'Radial constant'.")
-
-    ASPECT_REGISTER_GRAVITY_MODEL(RadialEarthLike,
-                                  "radial earth-like",
-                                  "This plugin has been removed due to its misleading name. "
-                                  "The included profile was hard-coded and was less earth-like "
-                                  "than the `ascii data' plugin, which uses the profile "
-                                  "of the Preliminary Reference Earth Model (PREM). Use `ascii data' "
-                                  "instead of `radial earth-like'.")
-
-    ASPECT_REGISTER_GRAVITY_MODEL(RadialLinear,
-                                  "radial linear",
-                                  "A gravity model which is radial (pointing inward if the gravity "
-                                  "is positive) and the magnitude changes linearly with depth. The "
-                                  "magnitude of gravity at the surface and bottom is read from the "
-                                  "input file in a section ``Gravity model/Radial linear''.")
-  }
-}
diff --git a/source/gravity_model/vertical.cc.bak b/source/gravity_model/vertical.cc.bak
deleted file mode 100644
index df7c1898222..00000000000
--- a/source/gravity_model/vertical.cc.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/gravity_model/vertical.h>
-
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/tensor.h>
-
-namespace aspect
-{
-  namespace GravityModel
-  {
-    template <int dim>
-    Tensor<1,dim>
-    Vertical<dim>::gravity_vector (const Point<dim> &) const
-    {
-      Tensor<1,dim> g;
-      g[dim-1] = -gravity_magnitude;
-      return g;
-    }
-
-
-
-    template <int dim>
-    void
-    Vertical<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Gravity model");
-      {
-        prm.enter_subsection("Vertical");
-        {
-          prm.declare_entry ("Magnitude", "1.",
-                             Patterns::Double (),
-                             "Value of the gravity vector in $m/s^2$ directed "
-                             "along negative y (2d) or z (3d) axis (if the magnitude "
-                             "is positive.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-
-    template <int dim>
-    void
-    Vertical<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Gravity model");
-      {
-        prm.enter_subsection("Vertical");
-        {
-          gravity_magnitude = prm.get_double ("Magnitude");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::cartesian,
-                   ExcMessage ("Gravity model 'vertical' should not be used with geometry models that "
-                               "do not have a Cartesian natural coordinate system."));
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GravityModel
-  {
-    ASPECT_REGISTER_GRAVITY_MODEL(Vertical,
-                                  "vertical",
-                                  "A gravity model in which the gravity direction is vertical (pointing "
-                                  "downward for positive values) and at a constant magnitude by default "
-                                  "equal to one.")
-  }
-}
diff --git a/source/heating_model/adiabatic_heating.cc.bak b/source/heating_model/adiabatic_heating.cc.bak
deleted file mode 100644
index 6b4f3936e34..00000000000
--- a/source/heating_model/adiabatic_heating.cc.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/heating_model/adiabatic_heating.h>
-#include <aspect/gravity_model/interface.h>
-
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    bool
-    AdiabaticHeating<dim>::use_simplified_adiabatic_heating() const
-    {
-      return simplified_adiabatic_heating;
-    }
-
-    template <int dim>
-    void
-    AdiabaticHeating<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          if (!simplified_adiabatic_heating)
-            heating_model_outputs.heating_source_terms[q] = (material_model_inputs.velocity[q] * material_model_inputs.pressure_gradient[q])
-                                                            * material_model_outputs.thermal_expansion_coefficients[q]
-                                                            * material_model_inputs.temperature[q];
-          else
-            heating_model_outputs.heating_source_terms[q] = (material_model_inputs.velocity[q]
-                                                             * this->get_gravity_model().gravity_vector(material_model_inputs.position[q]))
-                                                            * material_model_outputs.thermal_expansion_coefficients[q]
-                                                            * material_model_inputs.temperature[q]
-                                                            * material_model_outputs.densities[q];
-
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-    template <int dim>
-    void
-    AdiabaticHeating<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Adiabatic heating");
-        {
-          prm.declare_entry ("Use simplified adiabatic heating", "false",
-                             Patterns::Bool (),
-                             "A flag indicating whether the adiabatic heating should be simplified "
-                             "from $\\alpha T (\\mathbf u \\cdot \\nabla p)$ to "
-                             "$ \\alpha \\rho T (\\mathbf u \\cdot \\mathbf g) $.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    AdiabaticHeating<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Adiabatic heating");
-        {
-          simplified_adiabatic_heating = prm.get_bool ("Use simplified adiabatic heating");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(AdiabaticHeating,
-                                  "adiabatic heating",
-                                  "Implementation of a standard and a simplified model of "
-                                  "adiabatic heating.")
-  }
-}
diff --git a/source/heating_model/adiabatic_heating_of_melt.cc.bak b/source/heating_model/adiabatic_heating_of_melt.cc.bak
deleted file mode 100644
index 7b5c333206f..00000000000
--- a/source/heating_model/adiabatic_heating_of_melt.cc.bak
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/heating_model/adiabatic_heating_of_melt.h>
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-#include <deal.II/numerics/fe_field_function.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    AdiabaticHeatingMelt<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      AssertThrow(this->include_melt_transport(),
-                  ExcMessage ("Heating model Adiabatic heating with melt only works if melt transport is enabled."));
-
-      // get the melt velocity
-      const MaterialModel::MeltInputs<dim> *melt_in = material_model_inputs.template get_additional_input<MaterialModel::MeltInputs<dim>>();
-      AssertThrow(melt_in != nullptr,
-                  ExcMessage ("Need MeltInputs from the material model for adiabatic heating with melt!"));
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          const double porosity = material_model_inputs.composition[q][this->introspection().compositional_index_for_name("porosity")];
-
-          if (!simplified_adiabatic_heating)
-            heating_model_outputs.heating_source_terms[q] = ((-porosity * material_model_inputs.velocity[q] + porosity * melt_in->fluid_velocities[q])
-                                                             * material_model_inputs.pressure_gradient[q])
-                                                            * material_model_outputs.thermal_expansion_coefficients[q]
-                                                            * material_model_inputs.temperature[q];
-          else
-            {
-              const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-              Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for adiabatic heating with melt."));
-
-              heating_model_outputs.heating_source_terms[q] = (-porosity * material_model_inputs.velocity[q]
-                                                               * this->get_gravity_model().gravity_vector(material_model_inputs.position[q]))
-                                                              * material_model_outputs.thermal_expansion_coefficients[q]
-                                                              * material_model_inputs.temperature[q]
-                                                              * material_model_outputs.densities[q]
-                                                              +
-                                                              ((porosity * melt_in->fluid_velocities[q])
-                                                               * this->get_gravity_model().gravity_vector(material_model_inputs.position[q]))
-                                                              * material_model_outputs.thermal_expansion_coefficients[q]
-                                                              * material_model_inputs.temperature[q]
-                                                              * melt_outputs->fluid_densities[q];
-            }
-
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-    template <int dim>
-    void
-    AdiabaticHeatingMelt<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Adiabatic heating of melt");
-        {
-          prm.declare_entry ("Use simplified adiabatic heating", "false",
-                             Patterns::Bool (),
-                             "A flag indicating whether the adiabatic heating should be simplified "
-                             "from $\\alpha T (\\mathbf u \\cdot \\nabla p)$ to "
-                             "$ \\alpha \\rho T (\\mathbf u \\cdot \\mathbf g) $.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    AdiabaticHeatingMelt<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Adiabatic heating of melt");
-        {
-          simplified_adiabatic_heating = prm.get_bool ("Use simplified adiabatic heating");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    AdiabaticHeatingMelt<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output) const
-    {
-      MeltHandler<dim>::create_material_model_outputs(output);
-    }
-
-
-
-    template <int dim>
-    void
-    AdiabaticHeatingMelt<dim>::
-    create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &inputs) const
-    {
-      // we need the melt inputs for this adiabatic heating of melt
-      if (inputs.template get_additional_input<MaterialModel::MeltInputs<dim>>() == nullptr)
-        inputs.additional_inputs.emplace_back(
-          std::make_unique<MaterialModel::MeltInputs<dim>> (inputs.n_evaluation_points()));
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(AdiabaticHeatingMelt,
-                                  "adiabatic heating of melt",
-                                  "Implementation of a standard and a simplified model of "
-                                  "adiabatic heating of melt. The full model implements the "
-                                  "heating term \n"
-                                  "$\\alpha T (-\\phi \\mathbf u_s \\cdot \\nabla p) "
-                                  "+ \\alpha T (\\phi \\mathbf u_f \\cdot \\nabla p)$.\n"
-                                  "For full adiabatic heating, "
-                                  "this has to be used in combination with the heating model "
-                                  "`adiabatic heating' to also include adiabatic heating for "
-                                  "the solid part, and the full heating term is then "
-                                  "$\\alpha T ((1-\\phi) \\mathbf u_s \\cdot \\nabla p) "
-                                  "+ \\alpha T (\\phi \\mathbf u_f \\cdot \\nabla p)$.")
-  }
-}
diff --git a/source/heating_model/compositional_heating.cc.bak b/source/heating_model/compositional_heating.cc.bak
deleted file mode 100644
index 85bc7700c26..00000000000
--- a/source/heating_model/compositional_heating.cc.bak
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
-  Copyright (C) 2017 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/heating_model/compositional_heating.h>
-#include <aspect/utilities.h>
-#include <aspect/global.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    CompositionalHeating<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &/*material_model_outputs*/,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      for (unsigned int q = 0; q < heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          // Compute compositional volume fractions
-          const std::vector<double> volume_fractions = MaterialModel::MaterialUtilities::compute_composition_fractions(material_model_inputs.composition[q],
-                                                       ComponentMask(fields_used_in_heat_production_averaging));
-
-          // Calculate average compositional heat production
-          double compositional_heat_production = 0.;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            if (c>0 || use_background_field_for_heat_production_averaging)
-              compositional_heat_production += volume_fractions[c] * heating_values[c];
-
-          heating_model_outputs.heating_source_terms[q] = compositional_heat_production;
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-    template <int dim>
-    void
-    CompositionalHeating<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Compositional heating");
-        {
-          prm.declare_entry("Compositional heating values","0.",
-                            Patterns::List (Patterns::Double(0.)),
-                            "List of heat production per unit volume values for "
-                            "background and compositional fields, for a total of "
-                            "N+1 values, where the first value corresponds to the "
-                            "background material, and N is the number of compositional fields. "
-                            "Units: \\si{\\watt\\per\\meter\\cubed}.");
-          prm.declare_entry ("Use compositional field for heat production averaging", "1",
-                             Patterns::List(Patterns::Integer(0,1)),
-                             "A list of integers with as many entries as compositional fields plus one. "
-                             "The first entry corresponds to the background material, each following "
-                             "entry corresponds to a particular compositional field. If the entry for "
-                             "a field is '1' this field is considered during the computation of volume "
-                             "fractions, if it is '0' the field is ignored. This is useful "
-                             "if some compositional fields are used to track properties like "
-                             "finite strain that should not contribute to heat production. The first "
-                             "entry determines whether the background field contributes to heat production "
-                             "or not (essentially similar to setting its 'Compositional heating values' to "
-                             "zero, but included for consistency in the length of the input lists).");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    CompositionalHeating<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // increment by one for background:
-      const unsigned int n_fields = this->n_compositional_fields() + 1;
-
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Compositional heating");
-        {
-          const std::vector<int> used_fields = Utilities::possibly_extend_from_1_to_N (
-                                                 Utilities::string_to_int(
-                                                   Utilities::split_string_list(
-                                                     prm.get("Use compositional field for heat production averaging"))),
-                                                 n_fields,
-                                                 "Use compositional field for heat production averaging");
-
-          use_background_field_for_heat_production_averaging = static_cast<bool>(used_fields[0]);
-
-          fields_used_in_heat_production_averaging.resize(this->n_compositional_fields());
-          for (unsigned int i=0; i<fields_used_in_heat_production_averaging.size(); ++i)
-            fields_used_in_heat_production_averaging[i] = static_cast<bool>(used_fields[i+1]);
-
-          heating_values = Utilities::possibly_extend_from_1_to_N (
-                             Utilities::string_to_double(
-                               Utilities::split_string_list(
-                                 prm.get("Compositional heating values"))),
-                             n_fields,
-                             "Compositional heating values");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(CompositionalHeating,
-                                  "compositional heating",
-                                  "Implementation of a model in which magnitude of internal heat production "
-                                  "is determined from fixed values assigned to each compositional "
-                                  "field. These values are interpreted as having units "
-                                  "\\si{\\watt\\per\\meter\\cubed}.")
-  }
-}
diff --git a/source/heating_model/constant_heating.cc.bak b/source/heating_model/constant_heating.cc.bak
deleted file mode 100644
index f6b87d3d9cb..00000000000
--- a/source/heating_model/constant_heating.cc.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/heating_model/constant_heating.h>
-
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    ConstantHeating<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &/*material_model_inputs*/,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          // return a constant value
-          heating_model_outputs.heating_source_terms[q] = radiogenic_heating_rate
-                                                          * material_model_outputs.densities[q];
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    ConstantHeating<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Constant heating");
-        {
-          prm.declare_entry ("Radiogenic heating rate", "0.",
-                             Patterns::Double (0.),
-                             "The specific rate of heating due to radioactive decay (or other bulk sources "
-                             "you may want to describe). This parameter corresponds to the variable "
-                             "$H$ in the temperature equation stated in the manual, and the heating "
-                             "term is $\\rho H$. Units: W/kg.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ConstantHeating<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Constant heating");
-        {
-          radiogenic_heating_rate    = prm.get_double ("Radiogenic heating rate");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(ConstantHeating,
-                                  "constant heating",
-                                  "Implementation of a model in which the heating "
-                                  "rate is constant.")
-  }
-}
diff --git a/source/heating_model/function.cc.bak b/source/heating_model/function.cc.bak
deleted file mode 100644
index dd7f833e2e0..00000000000
--- a/source/heating_model/function.cc.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
-  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/heating_model/function.h>
-
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    Function<dim>::Function ()
-      :
-      heating_model_function (1)
-    {}
-
-
-    template <int dim>
-    void
-    Function<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          // convert the position into the selected coordinate system
-          const Point<dim> position = material_model_inputs.position[q];
-          const Utilities::NaturalCoordinate<dim> point =
-            this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
-
-          // then compute the heating function value at this position
-          heating_model_outputs.heating_source_terms[q] = heating_model_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()))
-                                                          * material_model_outputs.densities[q];
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::update ()
-    {
-      const double time = this->get_time();
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        heating_model_function.set_time (time / year_in_seconds);
-      else
-        heating_model_function.set_time (time);
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Function");
-        {
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle. `depth' "
-                             "will create a function, in which only the first "
-                             "parameter is non-zero, which is interpreted to "
-                             "be the depth of the point.");
-
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Function");
-        {
-          try
-            {
-              heating_model_function.parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Heating model.Function'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-
-          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(Function,
-                                  "function",
-                                  "Implementation of a model in which the heating "
-                                  "rate is given in terms of an explicit formula "
-                                  "that is elaborated in the parameters in section "
-                                  "``Heating model|Function''. The format of these "
-                                  "functions follows the syntax understood by the "
-                                  "muparser library, see "
-                                  "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`."
-                                  "\n\n"
-                                  "The formula is interpreted as having units "
-                                  "W/kg."
-                                  "\n\n"
-                                  "Since the symbol $t$ indicating time "
-                                  "may appear in the formulas for the heating rate"
-                                  ", it is interpreted as having units "
-                                  "seconds unless the global parameter ``Use "
-                                  "years in output instead of seconds'' is set.")
-  }
-}
diff --git a/source/heating_model/interface.cc.bak b/source/heating_model/interface.cc.bak
deleted file mode 100644
index ac0fff5b29e..00000000000
--- a/source/heating_model/interface.cc.bak
+++ /dev/null
@@ -1,324 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/heating_model/adiabatic_heating.h>
-#include <aspect/heating_model/shear_heating.h>
-
-#include <deal.II/base/exceptions.h>
-#include <deal.II/base/signaling_nan.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    Interface<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> & /*outputs*/) const
-    {}
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::
-    create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> & /*inputs*/) const
-    {}
-
-
-    // ------------------------------ Manager -----------------------------
-
-
-
-    template <int dim>
-    bool
-    Manager<dim>::adiabatic_heating_enabled() const
-    {
-      return has_matching_heating_model<HeatingModel::AdiabaticHeating<dim>>() ;
-    }
-
-
-
-    template <int dim>
-    bool
-    Manager<dim>::shear_heating_enabled() const
-    {
-      return has_matching_heating_model<HeatingModel::ShearHeating<dim>>() ;
-    }
-
-
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_heating_model (const std::string &name,
-                                          const std::string &description,
-                                          void (*declare_parameters_function) (ParameterHandler &),
-                                          std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // find out which plugins are requested and the various other
-      // parameters we declare here
-      prm.enter_subsection ("Heating model");
-      {
-        model_names
-          = Utilities::split_string_list(prm.get("List of model names"));
-
-        AssertThrow(Utilities::has_unique_entries(model_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Heating model/List of model names' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-      }
-      prm.leave_subsection ();
-
-      // go through the list, create objects and let them parse
-      // their own parameters
-      for (auto &model_name : model_names)
-        {
-          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
-                                          (std::get<dim>(registered_plugins)
-                                           .create_plugin (model_name,
-                                                           "Heating model::Model names")));
-
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
-            sim->initialize_simulator (this->get_simulator());
-
-          this->plugin_objects.back()->parse_parameters (prm);
-          this->plugin_objects.back()->initialize ();
-        }
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                            const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                            HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      // Initialize all outputs to zero, because heating_model_outputs is
-      // often reused in loops over all cells
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          heating_model_outputs.heating_source_terms[q] = 0.0;
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-          heating_model_outputs.rates_of_temperature_change[q] = 0.0;
-        }
-
-      HeatingModel::HeatingModelOutputs individual_heating_outputs(material_model_inputs.n_evaluation_points(),
-                                                                   this->n_compositional_fields());
-
-      const MaterialModel::ReactionRateOutputs<dim> *reaction_rate_outputs
-        = material_model_outputs.template get_additional_output<MaterialModel::ReactionRateOutputs<dim>>();
-
-      for (const auto &heating_model : this->plugin_objects)
-        {
-          heating_model->evaluate(material_model_inputs, material_model_outputs, individual_heating_outputs);
-          for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-            {
-              heating_model_outputs.heating_source_terms[q] += individual_heating_outputs.heating_source_terms[q];
-              heating_model_outputs.lhs_latent_heat_terms[q] += individual_heating_outputs.lhs_latent_heat_terms[q];
-
-              if (!this->get_parameters().use_operator_splitting)
-                Assert(individual_heating_outputs.rates_of_temperature_change[q] == 0.0,
-                       ExcMessage("Rates of temperature change heating model outputs have to be zero "
-                                  "if the model does not use operator splitting."));
-              heating_model_outputs.rates_of_temperature_change[q] += individual_heating_outputs.rates_of_temperature_change[q];
-            }
-          individual_heating_outputs.reset();
-        }
-
-      // If the heating model does not get the reaction rate outputs, it can not correctly compute
-      // the rates of temperature change. To make sure these (incorrect) values are never used anywhere,
-      // overwrite them with signaling_NaNs.
-      if (reaction_rate_outputs == nullptr)
-        for (double &q : heating_model_outputs.rates_of_temperature_change)
-          q = numbers::signaling_nan<double>();
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::
-    create_additional_material_model_inputs_and_outputs(MaterialModel::MaterialModelInputs<dim>  &material_model_inputs,
-                                                        MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const
-    {
-      for (const auto &heating_model : this->plugin_objects)
-        {
-          heating_model->create_additional_material_model_inputs(material_model_inputs);
-        }
-
-      for (const auto &heating_model : this->plugin_objects)
-        {
-          heating_model->create_additional_material_model_outputs(material_model_outputs);
-        }
-    }
-
-
-
-    template <int dim>
-    const std::vector<std::string> &
-    Manager<dim>::get_active_heating_model_names () const
-    {
-      return model_names;
-    }
-
-
-    template <int dim>
-    const std::list<std::unique_ptr<Interface<dim>>> &
-    Manager<dim>::get_active_heating_models () const
-    {
-      return this->plugin_objects;
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // declare the actual entry in the parameter file
-      prm.enter_subsection ("Heating model");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry("List of model names",
-                          "",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma separated list of heating models that "
-                          "will be used to calculate the heating terms in the energy "
-                          "equation. The results of each of these criteria, i.e., "
-                          "the heating source terms and the latent heat terms for the "
-                          "left hand side will be added.\n\n"
-                          "The following heating models are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Heating model interface",
-                                                            out);
-    }
-
-
-
-    HeatingModelOutputs::HeatingModelOutputs(const unsigned int n_points,
-                                             const unsigned int)
-      :
-      heating_source_terms(n_points,numbers::signaling_nan<double>()),
-      // initialize the reaction terms with zeroes because they are not filled
-      // in all heating models
-      rates_of_temperature_change(n_points,0.0),
-      lhs_latent_heat_terms(n_points,numbers::signaling_nan<double>())
-    {
-    }
-
-
-
-    void
-    HeatingModelOutputs::reset()
-    {
-      for (unsigned int q=0; q<heating_source_terms.size(); ++q)
-        {
-          heating_source_terms[q] = numbers::signaling_nan<double>();
-          lhs_latent_heat_terms[q] = numbers::signaling_nan<double>();
-          rates_of_temperature_change[q] = 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ()
-    {
-      return std::get<dim>(registered_plugins).get_pattern_of_names ();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<HeatingModel::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<HeatingModel::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<HeatingModel::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<HeatingModel::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace HeatingModel
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>; \
-  \
-  template \
-  std::string \
-  get_valid_model_names_pattern<dim> ();
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/heating_model/latent_heat.cc.bak b/source/heating_model/latent_heat.cc.bak
deleted file mode 100644
index 40e56610f0c..00000000000
--- a/source/heating_model/latent_heat.cc.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/heating_model/latent_heat.h>
-
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    LatentHeat<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          heating_model_outputs.heating_source_terms[q] = material_model_inputs.temperature[q]
-                                                          * material_model_outputs.densities[q]
-                                                          * material_model_outputs.entropy_derivative_pressure[q]
-                                                          * (material_model_inputs.velocity[q] * material_model_inputs.pressure_gradient[q]);
-
-          heating_model_outputs.lhs_latent_heat_terms[q] = - material_model_outputs.densities[q]
-                                                           * material_model_inputs.temperature[q]
-                                                           * material_model_outputs.entropy_derivative_temperature[q];
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(LatentHeat,
-                                  "latent heat",
-                                  "Implementation of a standard model for latent heat.")
-  }
-}
diff --git a/source/heating_model/latent_heat_melt.cc.bak b/source/heating_model/latent_heat_melt.cc.bak
deleted file mode 100644
index 1a69ed21502..00000000000
--- a/source/heating_model/latent_heat_melt.cc.bak
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/heating_model/latent_heat_melt.h>
-#include <aspect/material_model/interface.h>
-
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    LatentHeatMelt<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      const bool use_operator_split = (this->get_parameters().use_operator_splitting);
-
-      const MaterialModel::ReactionRateOutputs<dim> *reaction_rate_out
-        = material_model_outputs.template get_additional_output<MaterialModel::ReactionRateOutputs<dim>>();
-
-      const MaterialModel::EnthalpyOutputs<dim> *enthalpy_out
-        = material_model_outputs.template get_additional_output<MaterialModel::EnthalpyOutputs<dim>>();
-
-      double enthalpy_change;
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          heating_model_outputs.heating_source_terms[q] = 0.0;
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-          heating_model_outputs.rates_of_temperature_change[q] = 0.0;
-
-          // Determine if the change of energy should come from the material model
-          if (retrieve_entropy_change_from_material_model && enthalpy_out)
-            enthalpy_change = - enthalpy_out->enthalpies_of_fusion[q];
-          else
-            enthalpy_change = melting_entropy_change * material_model_inputs.temperature[q];
-
-          if (this->introspection().compositional_name_exists("porosity") &&  this->get_timestep_number() > 0)
-            {
-              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-              double melting_rate = 0.0;
-
-              if (!use_operator_split)
-                {
-                  // with melt migration the reaction term is a mass reaction rate,
-                  // without melt migration, the reaction term is a constant value in terms of volume,
-                  // and we have to scale it to the correct units
-                  if (this->include_melt_transport())
-                    melting_rate = material_model_outputs.reaction_terms[q][porosity_idx];
-                  else
-                    melting_rate = material_model_outputs.reaction_terms[q][porosity_idx]
-                                   * material_model_outputs.densities[q] / this->get_timestep();
-
-                  heating_model_outputs.heating_source_terms[q] = enthalpy_change * melting_rate;
-                }
-              else if (use_operator_split && reaction_rate_out != nullptr)
-                {
-                  // if operator splitting is used in the model, we have to use the reaction rates from the
-                  // material model outputs instead of the reaction terms
-                  AssertThrow (std::isfinite(reaction_rate_out->reaction_rates[q][porosity_idx]),
-                               ExcMessage ("You are trying to use reaction rate outputs from the material "
-                                           "model to compute the latent heat of melt in an operator splitting solver scheme, "
-                                           "but the material model you use does not actually fill these reaction rate outputs."));
-
-                  // with melt migration the reaction term is a mass reaction rate,
-                  // without melt migration, the reaction term is a rate of change of the compositional field,
-                  // and we have to scale it to the same units to compute the rate of temperature change
-                  melting_rate = reaction_rate_out->reaction_rates[q][porosity_idx];
-
-                  // if operator splitting is used in the model, we want the heating rates due to latent heat of melt
-                  // to be part of the reactions (not the advection) in the operator split, and they are changes
-                  // in temperature rather than changes in energy
-                  heating_model_outputs.rates_of_temperature_change[q] = enthalpy_change
-                                                                         * melting_rate
-                                                                         / material_model_outputs.specific_heat[q];
-                }
-              else if (use_operator_split && reaction_rate_out == nullptr)
-                {
-                  // if operator plit is used, but the reaction rate outputs are not there,
-                  // fill the rates of temperature change with NaNs, so that an error is thrown
-                  // if they are used anywhere
-                  heating_model_outputs.rates_of_temperature_change[q] = std::numeric_limits<double>::quiet_NaN();
-                }
-            }
-        }
-    }
-
-    template <int dim>
-    void
-    LatentHeatMelt<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Latent heat melt");
-        {
-          prm.declare_entry ("Melting entropy change", "-300.",
-                             Patterns::Double (),
-                             "The entropy change for the phase transition "
-                             "from solid to melt. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Retrieve entropy change from material model", "false",
-                             Patterns::Bool (),
-                             "Instead of using the entropy change given in the "
-                             "'Melting entropy change' query the EnthalpyAdditionalOutputs "
-                             "in the material model to compute the entropy change for the "
-                             "phase transition from solid to melt."
-                             "Units: $J/(kg K)$.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    LatentHeatMelt<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Latent heat melt");
-        {
-          melting_entropy_change = prm.get_double ("Melting entropy change");
-          retrieve_entropy_change_from_material_model = prm.get_bool ("Retrieve entropy change from material model");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    LatentHeatMelt<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      if (this->include_melt_transport() && retrieve_entropy_change_from_material_model
-          && outputs.template get_additional_output<MaterialModel::EnthalpyOutputs<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::EnthalpyOutputs<dim>> (outputs.n_evaluation_points()));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(LatentHeatMelt,
-                                  "latent heat melt",
-                                  "Implementation of a standard model for latent heat "
-                                  "of melting. This assumes that there is a compositional field "
-                                  "called porosity, and it uses the reaction term of this field "
-                                  "(the fraction of material that melted in the current time step) "
-                                  "multiplied by a constant entropy change for melting all "
-                                  "of the material as source term of the heating model.\n"
-                                  "If there is no field called porosity, the heating terms are 0.")
-  }
-}
diff --git a/source/heating_model/radioactive_decay.cc.bak b/source/heating_model/radioactive_decay.cc.bak
deleted file mode 100644
index 4fc3403c495..00000000000
--- a/source/heating_model/radioactive_decay.cc.bak
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/heating_model/radioactive_decay.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/global.h>
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    RadioactiveDecay<dim>::RadioactiveDecay ()
-      = default;
-
-
-    template <int dim>
-    void
-    RadioactiveDecay<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      if (is_crust_defined_by_composition)
-        {
-          AssertThrow(crust_composition_num < material_model_inputs.composition[0].size(),
-                      ExcMessage("The composition number of crust is larger than number of composition fields."));
-        }
-
-      for (unsigned int q = 0; q < heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          double timedependent_radioactive_heating_rates = 0;
-
-          if (n_radio_heating_elements != 0)
-            {
-              double crust_fraction = 0;
-
-              if (is_crust_defined_by_composition)
-                {
-                  crust_fraction = material_model_inputs.composition[q][crust_composition_num];
-
-                  if (crust_fraction < 0.0)
-                    crust_fraction = 0;
-                  if (crust_fraction > 1.0)
-                    crust_fraction = 1;
-                }
-              else if ((this->get_geometry_model()).depth(material_model_inputs.position[q]) < crust_depth)
-                crust_fraction = 1;
-
-              for (unsigned element = 0; element < n_radio_heating_elements; ++element)
-                {
-                  timedependent_radioactive_heating_rates += radioactive_heating_rates[element]
-                                                             * (radioactive_initial_concentrations_mantle[element] * (1-crust_fraction)
-                                                                + radioactive_initial_concentrations_crust[element] * crust_fraction)
-                                                             * std::pow(0.5,this->get_time()/half_decay_times[element]);
-                }
-            }
-
-          heating_model_outputs.heating_source_terms[q] = timedependent_radioactive_heating_rates
-                                                          * material_model_outputs.densities[q];
-
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-    template <int dim>
-    void
-    RadioactiveDecay<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Radioactive decay");
-        {
-          prm.declare_entry("Number of elements","0",
-                            Patterns::Integer(0),
-                            "Number of radioactive elements");
-          prm.declare_entry("Heating rates","",
-                            Patterns::List (Patterns::Double ()),
-                            "Heating rates of different elements (W/kg)");
-          prm.declare_entry("Half decay times","",
-                            Patterns::List (Patterns::Double (0.)),
-                            "Half decay times. Units: (Seconds), or "
-                            "(Years) if set `use years instead of seconds'.");
-          prm.declare_entry("Initial concentrations crust","",
-                            Patterns::List (Patterns::Double (0.)),
-                            "Initial concentrations of different elements (ppm)");
-          prm.declare_entry("Initial concentrations mantle","",
-                            Patterns::List (Patterns::Double (0.)),
-                            "Initial concentrations of different elements (ppm)");
-          prm.declare_entry("Crust defined by composition","false",
-                            Patterns::Bool(),
-                            "Whether crust defined by composition or depth");
-          prm.declare_entry("Crust depth","0.",
-                            Patterns::Double(),
-                            "Depth of the crust when crust if defined by depth. "
-                            "Units: \\si{\\meter}.");
-          prm.declare_entry("Crust composition number","0",
-                            Patterns::Integer(0),
-                            "Which composition field should be treated as crust");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    RadioactiveDecay<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Radioactive decay");
-        {
-
-          n_radio_heating_elements  = prm.get_integer ("Number of elements");
-
-          radioactive_heating_rates = Utilities::string_to_double
-                                      (Utilities::split_string_list
-                                       (prm.get("Heating rates")));
-
-          half_decay_times          = Utilities::string_to_double
-                                      (Utilities::split_string_list
-                                       (prm.get("Half decay times")));
-
-          radioactive_initial_concentrations_crust  = Utilities::string_to_double
-                                                      (Utilities::split_string_list
-                                                       (prm.get("Initial concentrations crust")));
-
-          radioactive_initial_concentrations_mantle = Utilities::string_to_double
-                                                      (Utilities::split_string_list
-                                                       (prm.get("Initial concentrations mantle")));
-
-          is_crust_defined_by_composition = prm.get_bool    ("Crust defined by composition");
-          crust_depth                     = prm.get_double  ("Crust depth");
-          crust_composition_num           = prm.get_integer ("Crust composition number");
-
-
-          AssertThrow(radioactive_heating_rates.size() == n_radio_heating_elements,
-                      ExcMessage("Number of heating rate entities does not match "
-                                 "the number of radioactive elements."));
-          AssertThrow(half_decay_times.size() == n_radio_heating_elements,
-                      ExcMessage("Number of half decay time entities does not match "
-                                 "the number of radioactive elements."));
-          AssertThrow(radioactive_initial_concentrations_crust.size() == n_radio_heating_elements,
-                      ExcMessage("Number of initial concentration entities in crust "
-                                 "does not match the number of radioactive elements."));
-          AssertThrow(radioactive_initial_concentrations_mantle.size() == n_radio_heating_elements,
-                      ExcMessage("Number of initial concentration entities in mantle "
-                                 "does not match the number of radioactive elements."));
-
-          // if we get half_decay_times passed as years convert it to seconds
-          if (this->convert_output_to_years())
-            for (unsigned int i = 0; i < n_radio_heating_elements; ++i)
-              half_decay_times[i] *= year_in_seconds;
-
-          // Convert ppm to SI concentrations
-          for (unsigned int i = 0; i < n_radio_heating_elements; ++i)
-            {
-              radioactive_initial_concentrations_crust[i] *= 1e-6;
-              radioactive_initial_concentrations_mantle[i] *= 1e-6;
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(RadioactiveDecay,
-                                  "radioactive decay",
-                                  "Implementation of a model in which the internal "
-                                  "heating rate is radioactive decaying in the following rule:\n"
-                                  "\\[(\\text{initial concentration})\\cdot 0.5^{\\text{time}/(\\text{half life})}\\]\n"
-                                  "The crust and mantle can have different concentrations, and the crust can be "
-                                  "defined either by depth or by a certain compositional field.\n"
-                                  "The formula is interpreted as having units W/kg.")
-  }
-}
diff --git a/source/heating_model/shear_heating.cc.bak b/source/heating_model/shear_heating.cc.bak
deleted file mode 100644
index 153ffbfe601..00000000000
--- a/source/heating_model/shear_heating.cc.bak
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/heating_model/shear_heating.h>
-
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    ShearHeating<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      // Check if the material model has additional outputs relevant for the shear heating.
-      const ShearHeatingOutputs<dim> *shear_heating_out =
-        material_model_outputs.template get_additional_output<ShearHeatingOutputs<dim>>();
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          const SymmetricTensor<2,dim> deviatoric_strain_rate =
-            (this->get_material_model().is_compressible()
-             ?
-             material_model_inputs.strain_rate[q]
-             - 1./3. * trace(material_model_inputs.strain_rate[q]) * unit_symmetric_tensor<dim>()
-             :
-             material_model_inputs.strain_rate[q]);
-
-          SymmetricTensor<2,dim> stress = 2 * material_model_outputs.viscosities[q] * deviatoric_strain_rate;
-
-          if (limit_stress)
-            {
-              // Compute yield stress.
-              const double pressure = std::max(material_model_inputs.pressure[q], 0.0);
-              const double yield_stress = drucker_prager_plasticity.compute_yield_stress(cohesion,
-                                                                                         friction_angle,
-                                                                                         pressure,
-                                                                                         std::numeric_limits<double>::max());
-
-              // Scale the stress accordingly.
-              const double deviatoric_stress = 2 * material_model_outputs.viscosities[q] * std::sqrt(std::fabs(second_invariant(deviatoric_strain_rate)));
-              double scaling_factor = 1.0;
-              if (deviatoric_stress > 0.0)
-                scaling_factor = std::min(yield_stress / deviatoric_stress, 1.0);
-
-              stress *= scaling_factor;
-            }
-
-          heating_model_outputs.heating_source_terms[q] = stress * deviatoric_strain_rate;
-
-          // If shear heating work fractions are provided, reduce the
-          // overall heating by this amount (which is assumed to be converted into other forms of energy)
-          if (shear_heating_out != nullptr)
-            {
-              heating_model_outputs.heating_source_terms[q] *= shear_heating_out->shear_heating_work_fractions[q];
-            }
-
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-    template <int dim>
-    void
-    ShearHeating<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Shear heating");
-        {
-          prm.declare_entry ("Limit stress contribution to shear heating", "false",
-                             Patterns::Bool (),
-                             "In models with prescribed boundary velocities, stresses can become "
-                             "unrealistically large. Using these large stresses when calculating "
-                             "the amount of shear heating would then lead to an unreasonable "
-                             "increase in temperature. This parameter indicates if the stress being "
-                             "used to compute the amount of shear heating should be limited based on "
-                             "a Drucker-Prager yield criterion with the cohesion given by the "
-                             "'Cohesion for maximum shear stress' parameter and the friction angle "
-                             "given by the 'Friction angle for maximum shear stress' parameter.");
-          prm.declare_entry ("Cohesion for maximum shear stress", "2e7",
-                             Patterns::Double (0),
-                             "Cohesion for maximum shear stress that should be used for the computation "
-                             "of shear heating. It can be useful to limit the shear stress "
-                             "in models where velocities are prescribed, and actual stresses "
-                             "in the Earth would be lower than the stresses introduced by the "
-                             "boundary conditions. Only used if 'Limit stress contribution to shear heating' "
-                             "is true. "
-                             "Units: Pa.");
-          prm.declare_entry ("Friction angle for maximum shear stress", "0",
-                             Patterns::Double (0),
-                             "Friction angle for maximum shear stress that should be used for the computation "
-                             "of shear heating. It can be useful to limit the shear stress "
-                             "in models where velocities are prescribed, and actual stresses "
-                             "in the Earth would be lower than the stresses introduced by the "
-                             "boundary conditions. Only used if 'Limit stress contribution to shear heating' "
-                             "is true. "
-                             "Units: none.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ShearHeating<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Shear heating");
-        {
-          limit_stress = prm.get_bool ("Limit stress contribution to shear heating");
-          cohesion = prm.get_double ("Cohesion for maximum shear stress");
-          friction_angle = prm.get_double ("Friction angle for maximum shear stress");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-
-    template <int dim>
-    void
-    ShearHeating<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const
-    {
-      this->get_material_model().create_additional_named_outputs(material_model_outputs);
-    }
-
-
-
-    template <int dim>
-    ShearHeatingOutputs<dim>::ShearHeatingOutputs (const unsigned int n_points)
-      :
-      MaterialModel::NamedAdditionalMaterialOutputs<dim>({"shear_heating_work_fraction"}),
-                  shear_heating_work_fractions(n_points, numbers::signaling_nan<double>())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    ShearHeatingOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      (void) idx;
-      AssertIndexRange (idx, 1);
-
-      return shear_heating_work_fractions;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(ShearHeating,
-                                  "shear heating",
-                                  "Implementation of a standard model for shear heating. "
-                                  "Adds the term: "
-                                  "$  2 \\eta \\left( \\varepsilon - \\frac{1}{3} \\text{tr} "
-                                  "\\varepsilon \\mathbf 1 \\right) : \\left( \\varepsilon - \\frac{1}{3} "
-                                  "\\text{tr} \\varepsilon \\mathbf 1 \\right)$ to the "
-                                  "right-hand side of the temperature equation.")
-
-#define INSTANTIATE(dim) \
-  template class ShearHeatingOutputs<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/heating_model/shear_heating_with_melt.cc.bak b/source/heating_model/shear_heating_with_melt.cc.bak
deleted file mode 100644
index 9f0dd11a508..00000000000
--- a/source/heating_model/shear_heating_with_melt.cc.bak
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/heating_model/shear_heating_with_melt.h>
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-#include <deal.II/numerics/fe_field_function.h>
-
-
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    template <int dim>
-    void
-    ShearHeatingMelt<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.n_evaluation_points(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      Assert(this->introspection().compositional_name_exists("porosity"),
-             ExcMessage("Heating model shear heating with melt only works if there "
-                        "is a compositional field called porosity."));
-
-      // get the melt velocity
-      const MaterialModel::MeltInputs<dim> *melt_in = material_model_inputs.template get_additional_input<MaterialModel::MeltInputs<dim>>();
-      AssertThrow(melt_in != nullptr,
-                  ExcMessage ("Need MeltInputs from the material model for shear heating with melt!"));
-
-      bool is_melt_cell = false;
-      if (material_model_inputs.current_cell.state() == IteratorState::valid)
-        is_melt_cell = this->get_melt_handler().is_melt_cell(material_model_inputs.current_cell);
-
-      const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-      Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for shear heating with melt."));
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          const double porosity = material_model_inputs.composition[q][this->introspection().compositional_index_for_name("porosity")];
-
-          if (is_melt_cell)
-            heating_model_outputs.heating_source_terms[q] = melt_outputs->compaction_viscosities[q]
-                                                            * pow(trace(material_model_inputs.strain_rate[q]),2)
-                                                            +
-                                                            (melt_outputs->permeabilities[q] > 0
-                                                             ?
-                                                             melt_outputs->fluid_viscosities[q] * porosity * porosity
-                                                             / melt_outputs->permeabilities[q]
-                                                             * (melt_in->fluid_velocities[q] - material_model_inputs.velocity[q])
-                                                             * (melt_in->fluid_velocities[q] - material_model_inputs.velocity[q])
-                                                             :
-                                                             0.0);
-          else
-            heating_model_outputs.heating_source_terms[q] = 0.0;
-
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-
-    template <int dim>
-    void
-    ShearHeatingMelt<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output) const
-    {
-      MeltHandler<dim>::create_material_model_outputs(output);
-    }
-
-
-
-    template <int dim>
-    void
-    ShearHeatingMelt<dim>::
-    create_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &inputs) const
-    {
-      // we need the melt inputs for this shear heating of melt
-      if (inputs.template get_additional_input<MaterialModel::MeltInputs<dim>>() == nullptr)
-        inputs.additional_inputs.emplace_back(
-          std::make_unique<MaterialModel::MeltInputs<dim>> (inputs.n_evaluation_points()));
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(ShearHeatingMelt,
-                                  "shear heating with melt",
-                                  "Implementation of a standard model for shear heating "
-                                  "of migrating melt, including bulk (compression) heating "
-                                  "$\\xi \\left( \\nabla \\cdot \\mathbf u_s \\right)^2 $ "
-                                  "and heating due to melt segregation "
-                                  "$\\frac{\\eta_f \\phi^2}{k} \\left( \\mathbf u_f - \\mathbf u_s \\right)^2 $. "
-                                  "For full shear heating, "
-                                  "this has to be used in combination with the heating model "
-                                  "shear heating to also include shear heating for "
-                                  "the solid part.")
-  }
-}
diff --git a/source/initial_composition/adiabatic_density.cc.bak b/source/initial_composition/adiabatic_density.cc.bak
deleted file mode 100644
index 64c3af31dc5..00000000000
--- a/source/initial_composition/adiabatic_density.cc.bak
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_composition/adiabatic_density.h>
-
-#include <aspect/adiabatic_conditions/interface.h>
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    template <int dim>
-    double
-    AdiabaticDensity<dim>::
-    initial_composition (const Point<dim> &position, const unsigned int n_comp) const
-    {
-      if (n_comp == this->introspection().find_composition_type(CompositionalFieldDescription::density))
-        return this->get_adiabatic_conditions().density(position);
-
-      return 0.0;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(AdiabaticDensity,
-                                              "adiabatic density",
-                                              "Specify the initial composition as the adiabatic reference density at "
-                                              "each position. Note that only the field of the type 'density' "
-                                              "will be filled. For all other fields this plugin returns 0.0.")
-  }
-}
diff --git a/source/initial_composition/ascii_data.cc.bak b/source/initial_composition/ascii_data.cc.bak
deleted file mode 100644
index 49448b30dfd..00000000000
--- a/source/initial_composition/ascii_data.cc.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/initial_composition/ascii_data.h>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      ascii_data_initial->initialize(this->n_compositional_fields());
-    }
-
-
-    template <int dim>
-    double
-    AsciiData<dim>::
-    initial_composition (const Point<dim> &position,
-                         const unsigned int n_comp) const
-    {
-      return ascii_data_initial->get_data_component(position,n_comp);
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        Utilities::AsciiDataInitial<dim>::declare_parameters(prm,
-                                                             "$ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/",
-                                                             "box_2d.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        ascii_data_initial = std::make_unique<Utilities::AsciiDataInitial<dim>>();
-        ascii_data_initial->initialize_simulator(this->get_simulator());
-        ascii_data_initial->parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(AsciiData,
-                                              "ascii data",
-                                              "Implementation of a model in which the initial "
-                                              "composition is derived from files containing data "
-                                              "in ascii format. Note the required format of the "
-                                              "input data: The first lines may contain any number of comments "
-                                              "if they begin with `#', but one of these lines needs to "
-                                              "contain the number of grid points in each dimension as "
-                                              "for example `# POINTS: 3 3'. "
-                                              "The order of the data columns "
-                                              "has to be `x', `y', `composition1', `composition2', "
-                                              "etc. in a 2d model and `x', `y', `z', `composition1', "
-                                              "`composition2', etc. in a 3d model, according "
-                                              "to the number of compositional fields, which means that "
-                                              "there has to be a single column "
-                                              "for every composition in the model."
-                                              "Note that the data in the input "
-                                              "files need to be sorted in a specific order: "
-                                              "the first coordinate needs to ascend first, "
-                                              "followed by the second and the third at last in order to "
-                                              "assign the correct data to the prescribed coordinates. "
-                                              "If you use a spherical model, "
-                                              "then the assumed grid changes. `x' will be replaced by "
-                                              "the radial distance of the point to the bottom of the model, "
-                                              "`y' by the azimuth angle and `z' by the polar angle measured "
-                                              "positive from the north pole. The grid will be assumed to be "
-                                              "a latitude-longitude grid. Note that the order "
-                                              "of spherical coordinates is `r', `phi', `theta' "
-                                              "and not `r', `theta', `phi', since this allows "
-                                              "for dimension independent expressions.")
-  }
-}
diff --git a/source/initial_composition/ascii_data_layered.cc.bak b/source/initial_composition/ascii_data_layered.cc.bak
deleted file mode 100644
index 6834f403f1a..00000000000
--- a/source/initial_composition/ascii_data_layered.cc.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/initial_composition/ascii_data_layered.h>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    template <int dim>
-    AsciiDataLayered<dim>::AsciiDataLayered ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiDataLayered<dim>::initialize ()
-    {
-      // First additional field is the layer depth, so we need one additional non-compositional field
-      Utilities::AsciiDataLayered<dim>::initialize(this->n_compositional_fields() + 1);
-    }
-
-
-    template <int dim>
-    double
-    AsciiDataLayered<dim>::
-    initial_composition (const Point<dim> &position,
-                         const unsigned int n_comp) const
-    {
-
-      // First additional field is the layer depth, so we need the data component from the n_comp+1th column
-      return Utilities::AsciiDataLayered<dim>::get_data_component(position,n_comp + 1);
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataLayered<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        Utilities::AsciiDataLayered<dim>::declare_parameters(prm,
-                                                             "$ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/",
-                                                             "initial_composition_top_mantle_box_3d.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataLayered<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        Utilities::AsciiDataLayered<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(AsciiDataLayered,
-                                              "ascii data layered",
-                                              "Implementation of a model in which the initial "
-                                              "composition is derived from files containing data "
-                                              "in ascii format. Each file defines a surface on which "
-                                              "compositional fields are defined. "
-                                              "Between the surfaces, the fields can be chosen to be "
-                                              "constant (with a value defined by the nearest shallower "
-                                              "surface), or linearly interpolated between surfaces. "
-                                              "Note the required format of the input ascii data file: "
-                                              "The first lines may contain any number of comments "
-                                              "if they begin with `#', but one of these lines needs to "
-                                              "contain the number of grid points in each dimension as "
-                                              "for example `# POINTS: 3 3'. "
-                                              "The order of the data columns "
-                                              "has to be `x', `y', `composition1', `composition2' etc. "
-                                              "in a 2d model and `x', `y', `z', `composition1', "
-                                              "`composition2' etc. in a 3d model; i.e. "
-                                              "the columns before the compositional field always contains "
-                                              "the position of the surface along the vertical direction. "
-                                              "The first column needs to ascend first, "
-                                              "followed by the second in order to assign the correct data "
-                                              "to the prescribed coordinates. If you use a spherical model, "
-                                              "then the assumed grid changes. `x' will be replaced by the "
-                                              "azimuth angle and `y' (if 3d) by the polar angle measured "
-                                              "positive from the north pole. The last column will be the "
-                                              "distance of the point from the origin "
-                                              "(i.e. radial position). The grid in this case will be "
-                                              "a latitude-longitude grid. Note that the order "
-                                              "of spherical coordinates in 3d is `phi', `theta', `r', `T'"
-                                              "and not `theta', `phi', `r', `T' as this is "
-                                              "more consistent with other ASPECT plugins. Outside of the "
-                                              "region defined by the grid, the plugin will use the value "
-                                              "at the edge of the region.")
-  }
-}
diff --git a/source/initial_composition/entropy_table_lookup.cc.bak b/source/initial_composition/entropy_table_lookup.cc.bak
deleted file mode 100644
index b388942cf44..00000000000
--- a/source/initial_composition/entropy_table_lookup.cc.bak
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_composition/entropy_table_lookup.h>
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    template <int dim>
-    void
-    EntropyTableLookUp<dim>::initialize()
-    {
-      AssertThrow (this->introspection().compositional_name_exists("entropy"),
-                   ExcMessage("The 'entropy table lookup' initial composition requires the existence of a compositional field "
-                              "named 'entropy'. This field does not exist."));
-
-      // Make sure we keep track of the initial temperature manager and
-      // that it continues to live beyond the time when the simulator
-      // class releases its pointer to it.
-      initial_temperature_manager = this->get_initial_temperature_manager_pointer();
-
-      // Make sure we keep track of the initial composition manager and
-      // that it continues to live beyond the time when the simulator
-      // class releases its pointer to it.
-      initial_composition_manager = this->get_initial_composition_manager_pointer();
-
-      entropy_index = this->introspection().compositional_index_for_name("entropy");
-
-      material_lookup = std::make_unique<Utilities::StructuredDataLookup<2>>(7,1.0);
-      material_lookup->load_file(data_directory+material_file_name,
-                                 this->get_mpi_communicator());
-    }
-
-
-    template <int dim>
-    double
-    EntropyTableLookUp<dim>::
-    initial_composition (const Point<dim> &position,
-                         const unsigned int compositional_index) const
-    {
-      if (compositional_index == entropy_index)
-        {
-          const double temperature = initial_temperature_manager->initial_temperature(position);
-          const double pressure = this->get_adiabatic_conditions().pressure(position);
-
-          // Convert pressure from Pa to bar, bar is used in the table.
-          Point<2> temperature_pressure(temperature, pressure / 1.e5);
-
-          const double entropy = material_lookup->get_data(temperature_pressure, 0);
-
-          return entropy;
-        }
-      return 0.0;
-    }
-
-    template <int dim>
-    void
-    EntropyTableLookUp<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Entropy table lookup");
-        {
-          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/",
-                             Patterns::DirectoryName (),
-                             "The path to the model data. The path may also include the special "
-                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                             "in which the ASPECT source files were located when ASPECT was "
-                             "compiled. This interpretation allows, for example, to reference "
-                             "files located in the `data/' subdirectory of ASPECT.");
-          prm.declare_entry ("Material file name", "material_table_temperature_pressure.txt",
-                             Patterns::List (Patterns::Anything()),
-                             "The file name of the material data.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    EntropyTableLookUp<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Entropy table lookup");
-        {
-          data_directory              = Utilities::expand_ASPECT_SOURCE_DIR(prm.get("Data directory"));
-          material_file_name          = prm.get("Material file name");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(EntropyTableLookUp,
-                                              "entropy table lookup",
-                                              "A class that implements initial conditions for the entropy field "
-                                              "by converting the initial temperature field through a look up table. "
-                                              "Note that this plugin only works if there is a compositional field "
-                                              "called `entropy', and an additional look up table that can convert "
-                                              "pressure and temperature to entropy. "
-                                              "For all compositional fields except entropy this plugin returns 0.0, "
-                                              "and they are therefore not changed as long as the default `add' "
-                                              "operator is selected for this plugin.")
-  }
-}
diff --git a/source/initial_composition/function.cc.bak b/source/initial_composition/function.cc.bak
deleted file mode 100644
index 731a0ecd80c..00000000000
--- a/source/initial_composition/function.cc.bak
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_composition/function.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-
-    template <int dim>
-    double
-    Function<dim>::
-    initial_composition (const Point<dim> &position, const unsigned int n_comp) const
-    {
-      const Utilities::NaturalCoordinate<dim> point =
-        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
-
-      return function->value(Utilities::convert_array_to_point<dim>(point.get_coordinates()),n_comp);
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Function");
-        {
-          /**
-           * Choose the coordinates to evaluate the maximum refinement level
-           * function. The function can be declared in dependence of depth,
-           * cartesian coordinates or spherical coordinates. Note that the order
-           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
-           * this allows for dimension independent expressions.
-           */
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle. `depth' "
-                             "will create a function, in which only the first "
-                             "parameter is non-zero, which is interpreted to "
-                             "be the depth of the point.");
-
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("Function");
-        {
-          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-        }
-
-        try
-          {
-            function
-              = std::make_unique<Functions::ParsedFunction<dim>>(this->n_compositional_fields());
-            function->parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Initial composition model.Function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'\n"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(Function,
-                                              "function",
-                                              "Specify the composition in terms of an explicit formula. The format of these "
-                                              "functions follows the syntax understood by the "
-                                              "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-  }
-}
diff --git a/source/initial_composition/interface.cc.bak b/source/initial_composition/interface.cc.bak
deleted file mode 100644
index cf2a64b8e42..00000000000
--- a/source/initial_composition/interface.cc.bak
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/initial_composition/interface.h>
-
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    // ------------------------------ Manager -----------------------------
-    // ------------------------------ Deal with registering initial composition models and automating
-    // ------------------------------ their setup and selection at run time
-
-    template <int dim>
-    Manager<dim>::~Manager()
-      = default;
-
-
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_initial_composition (const std::string &name,
-                                                const std::string &description,
-                                                void (*declare_parameters_function) (ParameterHandler &),
-                                                std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // find out which plugins are requested and the various other
-      // parameters we declare here
-      prm.enter_subsection ("Initial composition model");
-      {
-        model_names
-          = Utilities::split_string_list(prm.get("List of model names"));
-
-        AssertThrow(Utilities::has_unique_entries(model_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Initial composition model/List of model names' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-
-        const std::string model_name = prm.get ("Model name");
-
-        AssertThrow (model_name == "unspecified" || model_names.size() == 0,
-                     ExcMessage ("The parameter 'Model name' is only used for reasons"
-                                 "of backwards compatibility and can not be used together with "
-                                 "the new functionality 'List of model names'. Please add your "
-                                 "initial composition model to the list instead."));
-
-        if (!(model_name == "unspecified"))
-          model_names.push_back(model_name);
-
-        // create operator list
-        const std::vector<std::string> model_operator_names =
-          Utilities::possibly_extend_from_1_to_N (Utilities::split_string_list(prm.get("List of model operators")),
-                                                  model_names.size(),
-                                                  "List of model operators");
-        model_operators = Utilities::create_model_operator_list(model_operator_names);
-
-      }
-      prm.leave_subsection ();
-
-      if (model_names.size() > 0)
-        AssertThrow(this->n_compositional_fields() > 0,
-                    ExcMessage("A plugin for the initial composition condition was specified, but there "
-                               "is no compositional field. This can lead to errors within the initialization of "
-                               "the initial composition plugin and is therefore not supported. Please remove "
-                               "the initial composition plugin or add a compositional field."));
-
-      // go through the list, create objects and let them parse
-      // their own parameters
-      for (const auto &model_name : model_names)
-        {
-          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
-                                          (std::get<dim>(registered_plugins)
-                                           .create_plugin (model_name,
-                                                           "Initial composition model::Model names")));
-
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
-            sim->initialize_simulator (this->get_simulator());
-
-          this->plugin_objects.back()->parse_parameters (prm);
-          this->plugin_objects.back()->initialize ();
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::update()
-    {
-      for (auto &initial_composition_object : this->plugin_objects)
-        initial_composition_object->update();
-    }
-
-
-
-    template <int dim>
-    double
-    Manager<dim>::initial_composition (const Point<dim> &position,
-                                       const unsigned int n_comp) const
-    {
-      double composition = 0.0;
-      int i = 0;
-
-      for (const auto &initial_composition_object : this->plugin_objects)
-        {
-          composition = model_operators[i](composition,
-                                           initial_composition_object->initial_composition(position,n_comp));
-          ++i;
-        }
-
-      return composition;
-    }
-
-
-    template <int dim>
-    const std::vector<std::string> &
-    Manager<dim>::get_active_initial_composition_names () const
-    {
-      return model_names;
-    }
-
-
-    template <int dim>
-    const std::list<std::unique_ptr<Interface<dim>>> &
-    Manager<dim>::get_active_initial_composition_conditions () const
-    {
-      return this->plugin_objects;
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // declare the entry in the parameter file
-      prm.enter_subsection ("Initial composition model");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry("List of model names",
-                          "",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma-separated list of initial composition models that "
-                          "together describe the initial composition field. "
-                          "These plugins are loaded in the order given, and modify the "
-                          "existing composition field via the operators listed "
-                          "in 'List of model operators'.\n\n"
-                          "The following composition models are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-
-        prm.declare_entry("List of model operators", "add",
-                          Patterns::MultipleSelection(Utilities::get_model_operator_options()),
-                          "A comma-separated list of operators that "
-                          "will be used to append the listed composition models onto "
-                          "the previous models. If only one operator is given, "
-                          "the same operator is applied to all models.");
-
-        prm.declare_entry ("Model name", "unspecified",
-                           Patterns::Selection (pattern_of_names+"|unspecified"),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string()
-                           + "\n\n" +
-                           "\\textbf{Warning}: This parameter provides an old and "
-                           "deprecated way of specifying "
-                           "initial composition models and shouldn't be used. "
-                           "Please use 'List of model names' instead.");
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ()
-    {
-      return std::get<dim>(registered_plugins).get_pattern_of_names ();
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Initial composition interface",
-                                                            out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<InitialComposition::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<InitialComposition::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<InitialComposition::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<InitialComposition::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace InitialComposition
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>; \
-  \
-  template \
-  std::string \
-  get_valid_model_names_pattern<dim> ();
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/initial_composition/porosity.cc.bak b/source/initial_composition/porosity.cc.bak
deleted file mode 100644
index 566e1d497e1..00000000000
--- a/source/initial_composition/porosity.cc.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_composition/porosity.h>
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/melt.h>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    template <int dim>
-    void
-    Porosity<dim>::initialize()
-    {
-      // Make sure we keep track of the initial temperature manager and
-      // that it continues to live beyond the time when the simulator
-      // class releases its pointer to it.
-      initial_temperature_manager = this->get_initial_temperature_manager_pointer();
-
-      // Make sure we keep track of the initial composition manager and
-      // that it continues to live beyond the time when the simulator
-      // class releases its pointer to it.
-      initial_composition_manager = this->get_initial_composition_manager_pointer();
-    }
-
-
-
-    template <int dim>
-    double
-    Porosity<dim>::
-    initial_composition (const Point<dim> &position,
-                         const unsigned int compositional_index) const
-    {
-      AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                  ExcMessage("The initial composition plugin `porosity' did not find a "
-                             "compositional field called `porosity' to initialize. Please add a "
-                             "compositional field with this name."));
-
-      AssertThrow(MaterialModel::MeltFractionModel<dim>::is_melt_fraction_model(this->get_material_model()),
-                  ExcMessage("The used material model is not derived from the 'MeltFractionModel' class, "
-                             "and therefore does not support computing equilibrium melt fractions. "
-                             "This is incompatible with the `porosity' "
-                             "initial composition plugin, which needs to compute these melt fractions."));
-
-      const unsigned int porosity_index = this->introspection().compositional_index_for_name("porosity");
-      if (compositional_index == porosity_index)
-        {
-          MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
-
-          in.position[0] = position;
-          in.temperature[0] = initial_temperature_manager->initial_temperature(position);
-          in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
-          in.pressure_gradient[0] = 0.0;
-          in.velocity[0] = 0.0;
-
-          // Use the initial composition, except for the porosity, to prevent
-          // infinite recursion
-          for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
-            if (i != porosity_index)
-              in.composition[0][i] = initial_composition_manager->initial_composition(position,i);
-            else
-              in.composition[0][i] = 0.0;
-
-          in.strain_rate[0] = SymmetricTensor<2,dim>();
-
-          std::vector<double> melt_fraction(1);
-
-          MaterialModel::MeltFractionModel<dim>::as_melt_fraction_model(this->get_material_model())
-          .melt_fractions(in, melt_fraction);
-
-          return melt_fraction[0];
-        }
-      return 0.0;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(Porosity,
-                                              "porosity",
-                                              "A class that implements initial conditions for the porosity field "
-                                              "by computing the equilibrium melt fraction for the given initial "
-                                              "condition and reference pressure profile. Note that this plugin only "
-                                              "works if there is a compositional field called `porosity', and the "
-                                              "used material model implements the 'MeltFractionModel' interface. "
-                                              "For all compositional fields except porosity this plugin returns 0.0, "
-                                              "and they are therefore not changed as long as the default `add' "
-                                              "operator is selected for this plugin.")
-  }
-}
diff --git a/source/initial_composition/slab_model.cc.bak b/source/initial_composition/slab_model.cc.bak
deleted file mode 100644
index e3a6e8cf0dd..00000000000
--- a/source/initial_composition/slab_model.cc.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/initial_composition/slab_model.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    template <int dim>
-    void
-    SlabModel<dim>::initialize ()
-    {
-      AssertThrow(this->introspection().compositional_name_exists("slabs"),
-                  ExcMessage("The initial composition plugin `slab model' did not find a "
-                             "compositional field called `slabs' to initialize. Please add a "
-                             "compositional field with this name."));
-
-      slab_index = this->introspection().compositional_index_for_name("slabs");
-
-      // The input slabs are defined from the surface of the model
-      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-      // The two columns correspond to slabs depth and thickness
-      slab_boundary.initialize({surface_boundary_id}, 2);
-    }
-
-
-    template <int dim>
-    double
-    SlabModel<dim>::
-    initial_composition (const Point<dim> &position,
-                         const unsigned int compositional_index) const
-    {
-      if (compositional_index != slab_index)
-        return 0.0;
-
-      // The first data column corresponds to the slab depth and the second column to the slab thickness.
-      // 'Slab depth' stands for the depth of the upper surface of the slab, 'Slab thickness'
-      // for the vertical distance between upper and lower surface.
-      const double slab_depth     = slab_boundary.get_data_component(surface_boundary_id, position, 0);
-      const double slab_thickness = slab_boundary.get_data_component(surface_boundary_id, position, 1);
-
-      // Return 0.0 if there is no slab in this location in the data. No slab is encoded in
-      // the data file as a slab thickness of 0.0 and/or a depth larger than the depth of
-      // the domain.
-      if (slab_thickness == 0.0 ||
-          slab_depth > this->get_geometry_model().maximal_depth())
-        return 0.0;
-
-      // Return 1.0 if we are inside the depth range of the slab.
-      // We use a semi-closed interval so that a slab thickness of 0.0
-      // means no slab exists.
-      const double depth = this->get_geometry_model().depth(position);
-      if ((depth >= slab_depth) && (depth < slab_depth + slab_thickness))
-        return 1.0;
-
-      return 0.0;
-    }
-
-
-    template <int dim>
-    const Utilities::AsciiDataBoundary<dim> &
-    SlabModel<dim>::get_slab_boundary () const
-    {
-      return slab_boundary;
-    }
-
-
-    template <int dim>
-    void
-    SlabModel<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
-                                                              "$ASPECT_SOURCE_DIR/data/initial-composition/slab-model/",
-                                                              "shell_3d.txt",
-                                                              "Slab model",
-                                                              /*time dependent = */ false);
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    SlabModel<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        slab_boundary.initialize_simulator (this->get_simulator());
-        slab_boundary.parse_parameters(prm, "Slab model", /*time dependent = */ false);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(SlabModel,
-                                              "slab model",
-                                              "An initial composition model that implements subducted "
-                                              "slab geometries as a compositional field determined from "
-                                              "an input file. The file defines the depth to the top of "
-                                              "the slab and the slab thickness. "
-                                              "The computed compositional value is 1 within the slabs "
-                                              "and zero elsewhere. "
-                                              "An example model that is included is Slab2 described in "
-                                              "Hayes, G. P., Moore, G. L., Portner, D. E., Hearne, M., "
-                                              "Flamme, H., Furtney, M., \\& Smoczyk, G. M. (2018). Slab2, "
-                                              "a comprehensive subduction zone geometry model. Science, "
-                                              "362(6410), 58-61. The script to convert the Slab2 model "
-                                              "into an aspect input data file is available in the directory "
-                                              "data/initial-composition/slab-model/. Please note that "
-                                              "Slab2 and the example data file assume spherical geometry "
-                                              "(latitude, longitude coordinates), however, that is not "
-                                              "necessary for this plugin, data files in "
-                                              "Cartesian coordinates will work with box geometries.")
-  }
-}
diff --git a/source/initial_composition/world_builder.cc.bak b/source/initial_composition/world_builder.cc.bak
deleted file mode 100644
index 16695d0841f..00000000000
--- a/source/initial_composition/world_builder.cc.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/global.h>
-
-#ifdef ASPECT_WITH_WORLD_BUILDER
-#include <aspect/initial_composition/world_builder.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/citation_info.h>
-
-#include <world_builder/world.h>
-
-
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    template <int dim>
-    void
-    WorldBuilder<dim>::
-    initialize()
-    {
-      CitationInfo::add("GWB");
-      world_builder = this->get_world_builder_pointer();
-    }
-
-
-
-    template <int dim>
-    double
-    WorldBuilder<dim>::
-    initial_composition (const Point<dim> &position, const unsigned int n_comp) const
-    {
-      if (relevant_compositions[n_comp] == true)
-        return world_builder->composition(Utilities::convert_point_to_array(position),
-                                          -this->get_geometry_model().height_above_reference_surface(position),
-                                          n_comp);
-
-      return 0.0;
-    }
-
-
-
-    template <int dim>
-    void
-    WorldBuilder<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("World builder");
-        {
-          prm.declare_entry ("List of relevant compositions", "",
-                             Patterns::Anything(),
-                             "A list of names of compositional fields for "
-                             "which to determine the initial composition using "
-                             "the World Builder. As World Builder evaluations can "
-                             "be expensive, this parameter allows to only evaluate "
-                             "the fields that are relevant. This plugin returns 0.0 "
-                             "for all compositions that are not selected in the list. "
-                             "By default the list is empty and the world builder is "
-                             "evaluated for all compositional fields.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    WorldBuilder<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial composition model");
-      {
-        prm.enter_subsection("World builder");
-        {
-          const std::vector<std::string> composition_names = Utilities::split_string_list(prm.get("List of relevant compositions"));
-
-          relevant_compositions.resize(this->n_compositional_fields(),false);
-
-          if (composition_names.size() == 0)
-            for (unsigned int i=0; i<this->n_compositional_fields(); ++i)
-              relevant_compositions[i] = true;
-
-          for (const auto &composition_name: composition_names)
-            {
-              AssertThrow(this->introspection().compositional_name_exists (composition_name),
-                          ExcMessage("All fields in \"List of relevant compositions\" must match names of compositional "
-                                     "fields as assigned in the \"Compositional fields/Names of fields\" parameter."));
-
-              relevant_compositions[this->introspection().compositional_index_for_name(composition_name)] = true;
-            }
-        }
-
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialComposition
-  {
-    ASPECT_REGISTER_INITIAL_COMPOSITION_MODEL(WorldBuilder,
-                                              "world builder",
-                                              "Specify the initial composition through the World Builder. "
-                                              "More information on the World Builder can be found at "
-                                              "\\url{https://geodynamicworldbuilder.github.io}. "
-                                              "Make sure to specify the location of the World Builder file "
-                                              "in the parameter 'World builder file'. It is possible to use "
-                                              "the World Builder only for selected compositional fields by "
-                                              "specifying the parameter 'List of relevant compositions'.")
-  }
-}
-#endif
diff --git a/source/initial_temperature/S40RTS_perturbation.cc.bak b/source/initial_temperature/S40RTS_perturbation.cc.bak
deleted file mode 100644
index 013c2d83be1..00000000000
--- a/source/initial_temperature/S40RTS_perturbation.cc.bak
+++ /dev/null
@@ -1,530 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/S40RTS_perturbation.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-#include <aspect/initial_composition/interface.h>
-#include <aspect/material_model/interface.h>
-#include <array>
-
-#include <boost/lexical_cast.hpp>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    namespace internal
-    {
-      namespace S40RTS
-      {
-        // Read in the spherical harmonics that are located in data/initial-temperature/S40RTS
-        // and were downloaded from http://www.earth.lsa.umich.edu/~jritsema/research.html
-        // Ritsema et al. choose real sine and cosine coefficients that follow the normalization
-        // by Dahlen & Tromp, Theoretical Global Seismology (equations B.58 and B.99).
-
-        // NOTE: There is a factor of sqrt(2) difference between the standard orthonormalized
-        // spherical harmonics used by Dahlen & Tromp and that used for S40RTS (see PR # 966).
-        // This might need adjusting if this code is used to read in spherical harmonic
-        // based tomography models that aren't S40RTS or S20RTS.
-
-        SphericalHarmonicsLookup::
-        SphericalHarmonicsLookup(const std::string &filename,
-                                 const MPI_Comm comm)
-        {
-          std::string temp;
-          // Read data from disk and distribute among processes
-          std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
-
-          in >> order;
-          std::getline(in,temp);  // throw away the rest of the line
-
-          const unsigned int num_splines = 21;
-          const unsigned int maxnumber = num_splines * (order+1)*(order+1);
-
-          // read in all coefficients as a single data vector
-          std::vector<double> coeffs(maxnumber,0.0);
-
-          for (unsigned int i=0; i<maxnumber; ++i)
-            {
-              in >> coeffs[i];
-            }
-
-          // reorder the coefficients into sin and cos coefficients. a_lm will be the cos coefficients
-          // and b_lm the sin coefficients.
-          unsigned int ind = 0;
-
-          a_lm.reserve(maxnumber);
-          b_lm.reserve(maxnumber);
-          for (unsigned int j=0; j<num_splines; ++j)
-            for (unsigned int i=0; i<order+1; ++i)
-              {
-                a_lm.push_back(coeffs[ind]);
-                b_lm.push_back(0.0);
-                ++ind;
-
-                unsigned int ind_degree = 0;
-                while (ind_degree < i)
-                  {
-                    a_lm.push_back(coeffs[ind]);
-                    ++ind;
-                    b_lm.push_back(coeffs[ind]);
-                    ++ind;
-                    ++ind_degree;
-                  }
-              }
-        }
-
-        // Declare a function that returns the cosine coefficients
-        const std::vector<double> &
-        SphericalHarmonicsLookup::cos_coeffs() const
-        {
-          return a_lm;
-        }
-
-        // Declare a function that returns the sine coefficients
-        const std::vector<double> &
-        SphericalHarmonicsLookup::sin_coeffs() const
-        {
-          return b_lm;
-        }
-
-        unsigned int
-        SphericalHarmonicsLookup::maxdegree() const
-        {
-          return order;
-        }
-
-        // Read in the knot points for the spline interpolation. They are located in data/
-        // initial-temperature/S40RTS and were taken from the plotting script
-        // lib/libS20/splhsetup.f which is part of the plotting package downloadable at
-        // http://www.earth.lsa.umich.edu/~jritsema/research.html
-        SplineDepthsLookup::SplineDepthsLookup(const std::string &filename,
-                                               const MPI_Comm comm)
-        {
-          std::string temp;
-          // Read data from disk and distribute among processes
-          std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
-
-          std::getline(in,temp);  // throw away the rest of the line
-          std::getline(in,temp);  // throw away the rest of the line
-
-          // This is fixed for this tomography model
-          const unsigned int num_splines = 21;
-
-          depths.resize(num_splines);
-          for (unsigned int i=0; i<num_splines; ++i)
-            {
-              in >> depths[i];
-            }
-        }
-
-        const std::vector<double> &
-        SplineDepthsLookup::spline_depths() const
-        {
-          return depths;
-        }
-      }
-    }
-
-
-    template <int dim>
-    S40RTSPerturbation<dim>::S40RTSPerturbation()
-      :
-      vs_to_density_index(numbers::invalid_unsigned_int)
-    {}
-
-    template <int dim>
-    void
-    S40RTSPerturbation<dim>::initialize()
-    {
-      spherical_harmonics_lookup
-        = std::make_unique<internal::S40RTS::SphericalHarmonicsLookup>(data_directory+harmonics_coeffs_file_name,
-                                                                       this->get_mpi_communicator());
-      spline_depths_lookup
-        = std::make_unique<internal::S40RTS::SplineDepthsLookup>(data_directory+spline_depth_file_name,
-                                                                 this->get_mpi_communicator());
-
-      if (vs_to_density_method == file)
-        {
-          profile.initialize(this->get_mpi_communicator());
-          vs_to_density_index = profile.get_column_index_from_name("vs_to_density");
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    S40RTSPerturbation<dim>::
-    get_Vs (const Point<dim> &position) const
-    {
-      // get the max degree from the input data file (20 or 40)
-      const unsigned int max_degree_data_file = spherical_harmonics_lookup->maxdegree();
-
-      // set the max degree used for the calculation to the max degree from the input data file as default
-      unsigned int max_degree_to_use = max_degree_data_file;
-
-      // lower the maximum degree of the calculation if needed
-      if (lower_max_degree)
-        {
-          AssertThrow(specified_max_degree <= max_degree_data_file, ExcMessage("Specifying a maximum degree higher than the degree of spherical harmonic data is not allowed"));
-          max_degree_to_use = specified_max_degree;
-        }
-
-      // This tomography model is parameterized by 21 layers
-      const unsigned int num_spline_knots = 21;
-
-      // get the spherical harmonics coefficients
-      const std::vector<double> &a_lm = spherical_harmonics_lookup->cos_coeffs();
-      const std::vector<double> &b_lm = spherical_harmonics_lookup->sin_coeffs();
-
-      // get spline knots and rescale them from [-1 1] to [CMB Moho]
-      const std::vector<double> &r = spline_depths_lookup->spline_depths();
-      const double rmoho = 6346e3;
-      const double rcmb = 3480e3;
-      std::vector<double> depth_values(num_spline_knots, 0);
-
-      for (unsigned int i = 0; i<num_spline_knots; ++i)
-        depth_values[i] = rcmb+(rmoho-rcmb)*0.5*(r[i]+1.);
-
-      // convert coordinates from [x,y,z] to [r, phi, theta]
-      std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
-
-      // Evaluate the spherical harmonics at this position. Since they are the
-      // same for all depth splines, do it once to avoid multiple evaluations.
-      // NOTE: there is apparently a factor of sqrt(2) difference
-      // between the standard orthonormalized spherical harmonics
-      // and those used for S40RTS (see PR # 966)
-      std::vector<std::vector<double>> cosine_components(max_degree_to_use+1, std::vector<double>(max_degree_to_use+1, 0.0));
-      std::vector<std::vector<double>> sine_components(max_degree_to_use+1, std::vector<double>(max_degree_to_use+1, 0.0));
-
-      for (unsigned int degree_l = 0; degree_l < max_degree_to_use+1; ++degree_l)
-        {
-          for (unsigned int order_m = 0; order_m < degree_l+1; ++order_m)
-            {
-              const double phi = scoord[1];
-              const double theta = (dim == 3) ? scoord[2] : numbers::PI_2;
-              const std::pair<double,double> sph_harm_vals =
-                Utilities::real_spherical_harmonic(degree_l, order_m, theta, phi);
-
-              cosine_components[degree_l][order_m] = sph_harm_vals.first;
-              sine_components[degree_l][order_m] = sph_harm_vals.second;
-            }
-        }
-
-      // iterate over all degrees and orders at each depth and sum them all up.
-      std::vector<double> spline_values(num_spline_knots, 0.);
-      double prefact;
-      unsigned int ind = 0;
-
-      for (unsigned int depth_interp = 0; depth_interp < num_spline_knots; ++depth_interp)
-        {
-          for (unsigned int degree_l = 0; degree_l < max_degree_to_use+1; ++degree_l)
-            {
-              for (unsigned int order_m = 0; order_m < degree_l+1; ++order_m)
-                {
-                  if (degree_l == 0)
-                    prefact = (zero_out_degree_0
-                               ?
-                               0.
-                               :
-                               1.);
-                  else if (order_m != 0)
-                    // this removes the sqrt(2) factor difference in normalization (see PR # 966)
-                    prefact = 1./sqrt(2.);
-                  else
-                    prefact = 1.0;
-
-                  spline_values[depth_interp] += prefact * (a_lm[ind] * cosine_components[degree_l][order_m]
-                                                            + b_lm[ind] * sine_components[degree_l][order_m]);
-
-                  ++ind;
-                }
-            }
-          // Skip the higher degree spherical harminic coefficients per layer if a lower max degree is used.
-          // The formula below will calculate the total number of the spherical harmonic coefficients from
-          // the degree at max_degree_to_use+1 to the degree at max_degree_data_file.
-          // The formula below will be zero if the spherical harmonics are summed up to the degree at max_degree_data_file.
-          ind += (max_degree_to_use+max_degree_data_file+3)*(max_degree_data_file-max_degree_to_use)/2;
-        }
-
-      // We need to reorder the spline_values because the coefficients are given from
-      // the surface down to the CMB and the interpolation knots range from the CMB up to
-      // the surface.
-      std::vector<double> spline_values_inv(num_spline_knots,0);
-      for (unsigned int i=0; i<num_spline_knots; ++i)
-        spline_values_inv[i] = spline_values[num_spline_knots-1 - i];
-
-      // The boundary condition for the cubic spline interpolation is that the function is linear
-      // at the boundary (i.e. Moho and CMB). Values outside the range are linearly
-      // extrapolated.
-      aspect::Utilities::tk::spline s;
-      s.set_points(depth_values, spline_values_inv);
-
-      // Return value of Vs perturbation at specific depth
-      return s(scoord[0]);
-    }
-
-
-    template <int dim>
-    double
-    S40RTSPerturbation<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-
-      // use either the user-input reference temperature as background temperature
-      // (incompressible model) or the adiabatic temperature profile (compressible model)
-      const double background_temperature = this->get_material_model().is_compressible() ?
-                                            this->get_adiabatic_conditions().temperature(position) :
-                                            reference_temperature;
-
-      //Read in Vs perturbation data using function above
-      const double perturbation = get_Vs (position);
-
-
-      // Get the vs to density conversion
-      const double depth = this->get_geometry_model().depth(position);
-
-      double vs_to_density = 0.0;
-      if (vs_to_density_method == file)
-        vs_to_density = profile.get_data_component(Point<1>(depth), vs_to_density_index);
-      else if (vs_to_density_method == constant)
-        vs_to_density = vs_to_density_constant;
-      else
-        // we shouldn't get here but instead should already have been
-        // kicked out by the assertion in the parse_parameters()
-        // function
-        Assert (false, ExcNotImplemented());
-
-      // scale the perturbation in seismic velocity into a density perturbation
-      // vs_to_density is an input parameter
-      const double density_perturbation = vs_to_density * perturbation;
-
-      double temperature_perturbation;
-      if (depth > no_perturbation_depth)
-        {
-          // scale the density perturbation into a temperature perturbation
-          // see if we need to ask material model for the thermal expansion coefficient
-          if (use_material_model_thermal_alpha)
-            {
-              MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
-              MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
-              in.position[0] = position;
-              in.temperature[0] = background_temperature;
-              in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
-              in.velocity[0] = Tensor<1,dim> ();
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                in.composition[0][c] = this->get_initial_composition_manager().initial_composition(position, c);
-              in.requested_properties = MaterialModel::MaterialProperties::thermal_expansion_coefficient;
-
-              this->get_material_model().evaluate(in, out);
-
-              temperature_perturbation = -1./(out.thermal_expansion_coefficients[0]) * density_perturbation;
-            }
-          else
-            temperature_perturbation = -1./thermal_alpha * density_perturbation;
-        }
-      else
-        // set heterogeneity to zero down to a specified depth
-        temperature_perturbation = 0.0;
-
-      // add the temperature perturbation to the background temperature
-      return background_temperature + temperature_perturbation;
-    }
-
-
-    template <int dim>
-    void
-    S40RTSPerturbation<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("S40RTS perturbation");
-        {
-          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/initial-temperature/S40RTS/",
-                             Patterns::DirectoryName (),
-                             "The path to the model data. ");
-          prm.declare_entry ("Initial condition file name", "S40RTS.sph",
-                             Patterns::Anything(),
-                             "The file name of the spherical harmonics coefficients "
-                             "from Ritsema et al.");
-          prm.declare_entry ("Spline knots depth file name", "Spline_knots.txt",
-                             Patterns::Anything(),
-                             "The file name of the spline knot locations from "
-                             "Ritsema et al.");
-          prm.declare_entry ("Vs to density scaling method", "constant",
-                             Patterns::Selection("file|constant"),
-                             "Method that is used to specify how the vs-to-density scaling varies "
-                             "with depth.");
-          prm.declare_entry ("Vs to density scaling", "0.25",
-                             Patterns::Double (0.),
-                             "This parameter specifies how the perturbation in shear wave velocity "
-                             "as prescribed by S20RTS or S40RTS is scaled into a density perturbation. "
-                             "See the general description of this model for more detailed information.");
-          prm.declare_entry ("Thermal expansion coefficient in initial temperature scaling", "2e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\beta$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Use thermal expansion coefficient from material model", "false",
-                             Patterns::Bool (),
-                             "Option to take the thermal expansion coefficient from the "
-                             "material model instead of from what is specified in this "
-                             "section.");
-          prm.declare_entry ("Remove degree 0 from perturbation","true",
-                             Patterns::Bool (),
-                             "Option to remove the degree zero component from the perturbation, "
-                             "which will ensure that the laterally averaged temperature for a fixed "
-                             "depth is equal to the background temperature.");
-          prm.declare_entry ("Reference temperature", "1600.0",
-                             Patterns::Double (0.),
-                             "The reference temperature that is perturbed by the spherical "
-                             "harmonic functions. Only used in incompressible models.");
-          prm.declare_entry ("Remove temperature heterogeneity down to specified depth",
-                             boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
-                             Patterns::Double (),
-                             "This will set the heterogeneity prescribed by S20RTS or S40RTS to zero "
-                             "down to the specified depth (in meters). Note that your resolution has "
-                             "to be adequate to capture this cutoff. For example if you specify a depth "
-                             "of 660km, but your closest spherical depth layers are only at 500km and "
-                             "750km (due to a coarse resolution) it will only zero out heterogeneities "
-                             "down to 500km. Similar caution has to be taken when using adaptive meshing.");
-          prm.declare_entry ("Specify a lower maximum degree","false",
-                             Patterns::Bool (),
-                             "Option to use a lower maximum degree when reading the data file of spherical "
-                             "harmonic coefficients. This is probably used for the faster tests or when the "
-                             "users only want to see the spherical harmonic pattern up to a certain degree.");
-          prm.declare_entry ("Maximum degree","20",
-                             Patterns::Integer (0),
-                             "The maximum degree the users specify when reading the data file of spherical harmonic "
-                             "coefficients, which must be smaller than the maximum degree the data file stored. "
-                             "This parameter will be used only if 'Specify a lower maximum degree' is set to true.");
-
-          aspect::Utilities::AsciiDataProfile<dim>::declare_parameters(prm,
-                                                                       "$ASPECT_SOURCE_DIR/data/initial-temperature/S40RTS/",
-                                                                       "vs_to_density_Steinberger.txt",
-                                                                       "Ascii data vs to density model");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    S40RTSPerturbation<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("S40RTS perturbation");
-        {
-          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-
-          if ((data_directory.size() > 0) && (data_directory[data_directory.size()-1] != '/'))
-            data_directory += "/";
-          harmonics_coeffs_file_name = prm.get ("Initial condition file name");
-          spline_depth_file_name  = prm.get ("Spline knots depth file name");
-          vs_to_density_constant           = prm.get_double ("Vs to density scaling");
-          thermal_alpha           = prm.get_double ("Thermal expansion coefficient in initial temperature scaling");
-          use_material_model_thermal_alpha = prm.get_bool ("Use thermal expansion coefficient from material model");
-          zero_out_degree_0       = prm.get_bool ("Remove degree 0 from perturbation");
-          reference_temperature   = prm.get_double ("Reference temperature");
-          no_perturbation_depth   = prm.get_double ("Remove temperature heterogeneity down to specified depth");
-          lower_max_degree         = prm.get_bool ("Specify a lower maximum degree");
-          specified_max_degree               = prm.get_integer ("Maximum degree");
-
-          if (prm.get("Vs to density scaling method") == "file")
-            vs_to_density_method = file;
-          else if (prm.get("Vs to density scaling method") == "constant")
-            vs_to_density_method = constant;
-          else
-            {
-              AssertThrow(false, ExcMessage("Unknown method for vs to density scaling."));
-            }
-
-          profile.parse_parameters(prm,"Ascii data vs to density model");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(S40RTSPerturbation,
-                                              "S40RTS perturbation",
-                                              "An initial temperature field in which the temperature "
-                                              "is perturbed following the S20RTS or S40RTS shear wave "
-                                              "velocity model by Ritsema and others, which can be downloaded "
-                                              "here \\url{http://www.earth.lsa.umich.edu/~jritsema/research.html}. "
-                                              "Information on the vs model can be found in Ritsema, J., Deuss, "
-                                              "A., van Heijst, H.J. \\& Woodhouse, J.H., 2011. S40RTS: a "
-                                              "degree-40 shear-velocity model for the mantle from new Rayleigh "
-                                              "wave dispersion, teleseismic traveltime and normal-mode "
-                                              "splitting function measurements, Geophys. J. Int. 184, 1223-1236. "
-                                              "The scaling between the shear wave perturbation and the "
-                                              "density perturbation can be constant and set by the user with the "
-                                              "'Vs to density scaling' parameter or depth-dependent and "
-                                              "read in from a file. To convert density the user can specify "
-                                              "the 'Thermal expansion coefficient in initial temperature scaling' "
-                                              "parameter. The scaling is as follows: $\\delta \\ln \\rho "
-                                              "(r,\\theta,\\phi) = \\xi \\cdot \\delta \\ln v_s(r,\\theta, "
-                                              "\\phi)$ and $\\delta T(r,\\theta,\\phi) = - \\frac{1}{\\alpha} "
-                                              "\\delta \\ln \\rho(r,\\theta,\\phi)$. $\\xi$ is the `vs to "
-                                              "density scaling' parameter and $\\alpha$ is the 'Thermal "
-                                              "expansion coefficient in initial temperature scaling' "
-                                              "parameter. The temperature perturbation is added to an "
-                                              "otherwise constant temperature (incompressible model) or "
-                                              "adiabatic reference profile (compressible model). If a depth "
-                                              "is specified in 'Remove temperature heterogeneity down to "
-                                              "specified depth', there is no temperature perturbation "
-                                              "prescribed down to that depth."
-                                              "\n"
-                                              "Note the required file format if the vs to density scaling is read in "
-                                              "from a file: The first lines may contain any number of comments "
-                                              "if they begin with '#', but one of these lines needs to "
-                                              "contain the number of points in the reference state as "
-                                              "for example '# POINTS: 3'. "
-                                              "Following the comment lines there has to be a single line "
-                                              "containing the names of all data columns, separated by arbitrarily "
-                                              "many spaces. Column names are not allowed to contain spaces. "
-                                              "The file can contain unnecessary columns, but for this plugin it "
-                                              "needs to at least provide the columns named `depth' and "
-                                              "`vs\\_to\\_density'. "
-                                              "Note that the data lines in the file need to be sorted in order "
-                                              "of increasing depth from 0 to the maximal depth in the model "
-                                              "domain. Points in the model that are outside of the provided "
-                                              "depth range will be assigned the maximum or minimum depth values, "
-                                              "respectively. Points do not need to be equidistant, "
-                                              "but the computation of properties is optimized in speed "
-                                              "if they are."
-                                              "\n"
-                                              "If the plugin is used in 2d it will use an equatorial "
-                                              "slice of the seismic tomography model.")
-  }
-}
diff --git a/source/initial_temperature/SAVANI_perturbation.cc.bak b/source/initial_temperature/SAVANI_perturbation.cc.bak
deleted file mode 100644
index ce8881cbb66..00000000000
--- a/source/initial_temperature/SAVANI_perturbation.cc.bak
+++ /dev/null
@@ -1,537 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/SAVANI_perturbation.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-#include <aspect/initial_composition/interface.h>
-#include <aspect/material_model/interface.h>
-#include <array>
-
-#include <boost/lexical_cast.hpp>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    namespace internal
-    {
-      namespace SAVANI
-      {
-        // Read in the spherical harmonics that are located in data/initial-temperature/SAVANI
-        // and were downloaded from http://n.ethz.ch/~auerl/research.html
-        // choose real sine and cosine coefficients that follow the normalization
-        // by Dahlen & Tromp, Theoretical Global Seismology (equations B.58 and B.99).
-
-        class SphericalHarmonicsLookup
-        {
-          public:
-            SphericalHarmonicsLookup(const std::string &filename,
-                                     const MPI_Comm comm)
-            {
-              std::string temp;
-              // Read data from disk and distribute among processes
-              std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
-
-              in >> order;
-              std::getline(in,temp);  // throw away the rest of the line
-
-              const unsigned int num_layers = 28;
-
-              // read in all coefficients as a single data vector
-              std::vector<double> coeffs;
-              for (unsigned int i=0; i<num_layers; ++i)
-                {
-                  for (unsigned int j=0; j<(order+1)*(order+2); ++j)
-                    {
-                      double new_val;
-                      in >> new_val;
-                      coeffs.push_back(0.01*new_val);
-                    }
-                  std::getline(in,temp);
-                }
-
-              // reorder the coefficients into sin and cos coefficients. a_lm will be the cos coefficients
-              // and b_lm the sin coefficients.
-              unsigned int ind = 0;
-
-              for (unsigned int j=0; j<num_layers; ++j)
-                for (unsigned int i=0; i<order+1; ++i)
-                  {
-                    unsigned int ind_degree = 0;
-                    while (ind_degree <= i)
-                      {
-                        a_lm.push_back(coeffs[ind]);
-                        ++ind;
-                        b_lm.push_back(coeffs[ind]);
-                        ++ind;
-                        ++ind_degree;
-                      }
-                  }
-            }
-
-            // Declare a function that returns the cosine coefficients
-            const std::vector<double> &cos_coeffs() const
-            {
-              return a_lm;
-            }
-
-            // Declare a function that returns the sine coefficients
-            const std::vector<double> &sin_coeffs() const
-            {
-              return b_lm;
-            }
-
-            unsigned int maxdegree()
-            {
-              return order;
-            }
-
-          private:
-            unsigned int order;
-            std::vector<double> a_lm;
-            std::vector<double> b_lm;
-
-        };
-
-        // Read in the knot points for the spline interpolation. They are located in data/
-        // initial-temperature/SAVANI and were taken from the 28 spherical layers of SAVANI
-        // tomography model by a matlab script convert_to_knots.m located in the same directory.
-        class SplineDepthsLookup
-        {
-          public:
-            SplineDepthsLookup(const std::string &filename,
-                               const MPI_Comm comm)
-            {
-              std::string temp;
-              // Read data from disk and distribute among processes
-              std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
-
-              std::getline(in,temp);  // throw away the rest of the line
-              std::getline(in,temp);  // throw away the rest of the line
-
-              const unsigned int num_splines = 28;
-              depths.resize(num_splines);
-              for (unsigned int i=0; i<num_splines; ++i)
-                {
-                  in >> depths[i];
-                }
-            }
-
-            const std::vector<double> &spline_depths() const
-            {
-              return depths;
-            }
-
-          private:
-            std::vector<double> depths;
-        };
-      }
-    }
-
-    template <int dim>
-    SAVANIPerturbation<dim>::SAVANIPerturbation()
-      :
-      vs_to_density_index(numbers::invalid_unsigned_int)
-    {}
-
-
-    template <int dim>
-    void
-    SAVANIPerturbation<dim>::initialize()
-    {
-      spherical_harmonics_lookup
-        = std::make_unique<internal::SAVANI::SphericalHarmonicsLookup>(data_directory+harmonics_coeffs_file_name,
-                                                                       this->get_mpi_communicator());
-      spline_depths_lookup
-        = std::make_unique<internal::SAVANI::SplineDepthsLookup>(data_directory+spline_depth_file_name,
-                                                                 this->get_mpi_communicator());
-
-      if (vs_to_density_method == file)
-        {
-          profile.initialize(this->get_mpi_communicator());
-          vs_to_density_index = profile.get_column_index_from_name("vs_to_density");
-        }
-
-    }
-
-
-    template <>
-    double
-    SAVANIPerturbation<2>::
-    initial_temperature (const Point<2> &) const
-    {
-      // we shouldn't get here but instead should already have been
-      // kicked out by the assertion in the parse_parameters()
-      // function
-      Assert (false, ExcNotImplemented());
-      return 0;
-    }
-
-    template <>
-    double
-    SAVANIPerturbation<2>::
-    get_Vs (const Point<2> &/*position*/) const
-    {
-      Assert (false, ExcNotImplemented());
-      return 0;
-    }
-
-    template <>
-    double
-    SAVANIPerturbation<3>::
-    get_Vs (const Point<3> &position) const
-    {
-      const unsigned int dim = 3;
-
-      // get the max degree from the input data file (60)
-      const unsigned int max_degree_data_file = spherical_harmonics_lookup->maxdegree();
-
-      // set the max degree used for the calculation to the max degree from the input data file as default
-      unsigned int max_degree_to_use = max_degree_data_file;
-
-      // lower the maximum degree of the calculation if needed
-      if (lower_max_degree)
-        {
-          AssertThrow(specified_max_degree <= max_degree_data_file, ExcMessage("Specifying a maximum degree higher than the degree of spherical harmonic data is not allowed"));
-          max_degree_to_use = specified_max_degree;
-        }
-
-      const int num_spline_knots = 28; // The tomography models are parameterized by 28 layers
-
-      // get the spherical harmonics coefficients
-      const std::vector<double> &a_lm = spherical_harmonics_lookup->cos_coeffs();
-      const std::vector<double> &b_lm = spherical_harmonics_lookup->sin_coeffs();
-
-      // get spline knots and rescale them from [-1 1], i.e., CMB to Moho.
-      const std::vector<double> &r = spline_depths_lookup->spline_depths();
-      const double rmoho = 6346e3;
-      const double rcmb = 3480e3;
-      std::vector<double> depth_values(num_spline_knots, 0.);
-
-      for (unsigned int i = 0; i<num_spline_knots; ++i)
-        depth_values[i] = rcmb+(rmoho-rcmb)*0.5*(r[i]+1.);
-
-      // convert coordinates from [x,y,z] to [r, phi, theta]
-      std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
-
-      // Evaluate the spherical harmonics at this position. Since they are the
-      // same for all depth splines, do it once to avoid multiple evaluations.
-      std::vector<std::vector<double>> cosine_components(max_degree_to_use+1, std::vector<double>(max_degree_to_use+1, 0.0));
-      std::vector<std::vector<double>> sine_components(max_degree_to_use+1, std::vector<double>(max_degree_to_use+1, 0.0));
-
-      for (unsigned int degree_l = 0; degree_l < max_degree_to_use+1; ++degree_l)
-        {
-          for (unsigned int order_m = 0; order_m < degree_l+1; ++order_m)
-            {
-              const std::pair<double,double> sph_harm_vals = Utilities::real_spherical_harmonic( degree_l, order_m, scoord[2], scoord[1] );
-              cosine_components[degree_l][order_m] = sph_harm_vals.first;
-              sine_components[degree_l][order_m] = sph_harm_vals.second;
-            }
-        }
-
-      // iterate over all degrees and orders at each depth and sum them all up.
-      std::vector<double> spline_values(num_spline_knots, 0.);
-      double prefact;
-      unsigned int ind = 0;
-
-      for (unsigned int depth_interp = 0; depth_interp < num_spline_knots; ++depth_interp)
-        {
-          for (unsigned int degree_l = 0; degree_l < max_degree_to_use+1; ++degree_l)
-            {
-              for (unsigned int order_m = 0; order_m < degree_l+1; ++order_m)
-                {
-                  // normalization after Dahlen and Tromp, 1986, Appendix B.6
-                  if (degree_l == 0)
-                    prefact = (zero_out_degree_0
-                               ?
-                               0.
-                               :
-                               1.);
-                  else
-                    prefact = 1.0;
-
-                  spline_values[depth_interp] += prefact * (a_lm[ind] * cosine_components[degree_l][order_m]
-                                                            + b_lm[ind] * sine_components[degree_l][order_m]);
-
-                  ++ind;
-                }
-            }
-          // Skip the higher degree spherical harminic coefficients per layer if a lower max degree is used.
-          // The formula below will calculate the total number of the spherical harmonic coefficients from
-          // the degree at max_degree_to_use+1 to the degree at max_degree_data_file.
-          // The formula below will be zero if the spherical harmonics are summed up to the degree at max_degree_data_file.
-          ind += (max_degree_to_use+max_degree_data_file+3)*(max_degree_data_file-max_degree_to_use)/2;
-        }
-
-
-      // The boundary condition for the cubic spline interpolation is that the function is linear
-      // at the boundary (i.e. Moho and CMB). Values outside the range are linearly
-      // extrapolated.
-      aspect::Utilities::tk::spline s;
-      s.set_points(depth_values, spline_values);
-
-      // Get value at specific depth
-      return s(scoord[0]);
-
-    }
-
-
-    template <>
-    double
-    SAVANIPerturbation<3>::
-    initial_temperature (const Point<3> &position) const
-    {
-      // use either the user-input reference temperature as background temperature
-      // (incompressible model) or the adiabatic temperature profile (compressible model)
-      const double background_temperature = this->get_material_model().is_compressible() ?
-                                            this->get_adiabatic_conditions().temperature(position) :
-                                            reference_temperature;
-
-      //Read in Vs perturbation data using function above
-      const double perturbation = get_Vs (position);
-
-      // Get the vs to density conversion
-      const double depth = this->get_geometry_model().depth(position);
-
-      double vs_to_density = 0.0;
-      if (vs_to_density_method == file)
-        vs_to_density = profile.get_data_component(Point<1>(depth), vs_to_density_index);
-      else if (vs_to_density_method == constant)
-        vs_to_density = vs_to_density_constant;
-      else
-        // we shouldn't get here but instead should already have been
-        // kicked out by the assertion in the parse_parameters()
-        // function
-        Assert (false, ExcNotImplemented());
-
-      // scale the perturbation in seismic velocity into a density perturbation
-      // vs_to_density is an input parameter
-      const double density_perturbation = vs_to_density * perturbation;
-
-      double temperature_perturbation;
-      if (depth > no_perturbation_depth)
-        {
-          // scale the density perturbation into a temperature perturbation
-          // see if we need to ask material model for the thermal expansion coefficient
-          if (use_material_model_thermal_alpha)
-            {
-              MaterialModel::MaterialModelInputs<3> in(1, this->n_compositional_fields());
-              MaterialModel::MaterialModelOutputs<3> out(1, this->n_compositional_fields());
-              in.position[0] = position;
-              in.temperature[0] = background_temperature;
-              in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
-              in.velocity[0] = Tensor<1,3> ();
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                in.composition[0][c] = this->get_initial_composition_manager().initial_composition(position, c);
-              in.requested_properties = MaterialModel::MaterialProperties::thermal_expansion_coefficient;
-
-              this->get_material_model().evaluate(in, out);
-
-              temperature_perturbation = -1./(out.thermal_expansion_coefficients[0]) * density_perturbation;
-            }
-          else
-            temperature_perturbation = -1./thermal_alpha * density_perturbation;
-        }
-      else
-        // set heterogeneity to zero down to a specified depth
-        temperature_perturbation = 0.0;
-
-      // add the temperature perturbation to the background temperature
-      return background_temperature + temperature_perturbation;
-    }
-
-
-    template <int dim>
-    void
-    SAVANIPerturbation<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("SAVANI perturbation");
-        {
-          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/initial-temperature/SAVANI/",
-                             Patterns::DirectoryName (),
-                             "The path to the model data.");
-          prm.declare_entry ("Initial condition file name", "savani.dlnvs.60.m.ab",
-                             Patterns::Anything(),
-                             "The file name of the spherical harmonics coefficients "
-                             "from Auer et al.");
-          prm.declare_entry ("Spline knots depth file name", "Spline_knots.txt",
-                             Patterns::Anything(),
-                             "The file name of the spline knots taken from the 28 spherical layers "
-                             "of SAVANI tomography model.");
-          prm.declare_entry ("Vs to density scaling method", "constant",
-                             Patterns::Selection("file|constant"),
-                             "Method that is used to specify how the vs-to-density scaling varies "
-                             "with depth.");
-          prm.declare_entry ("Vs to density scaling", "0.25",
-                             Patterns::Double (0.),
-                             "This parameter specifies how the perturbation in shear wave velocity "
-                             "as prescribed by SAVANI is scaled into a density perturbation. "
-                             "See the general description of this model for more detailed information.");
-          prm.declare_entry ("Thermal expansion coefficient in initial temperature scaling", "2e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\beta$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Use thermal expansion coefficient from material model", "false",
-                             Patterns::Bool (),
-                             "Option to take the thermal expansion coefficient from the "
-                             "material model instead of from what is specified in this "
-                             "section.");
-          prm.declare_entry ("Remove degree 0 from perturbation","true",
-                             Patterns::Bool (),
-                             "Option to remove the degree zero component from the perturbation, "
-                             "which will ensure that the laterally averaged temperature for a fixed "
-                             "depth is equal to the background temperature.");
-          prm.declare_entry ("Reference temperature", "1600.0",
-                             Patterns::Double (0.),
-                             "The reference temperature that is perturbed by the spherical "
-                             "harmonic functions. Only used in incompressible models.");
-          prm.declare_entry ("Remove temperature heterogeneity down to specified depth",
-                             boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
-                             Patterns::Double (),
-                             "This will set the heterogeneity prescribed by SAVANI to zero "
-                             "down to the specified depth (in meters). Note that your resolution has "
-                             "to be adequate to capture this cutoff. For example if you specify a depth "
-                             "of 660km, but your closest spherical depth layers are only at 500km and "
-                             "750km (due to a coarse resolution) it will only zero out heterogeneities "
-                             "down to 500km. Similar caution has to be taken when using adaptive meshing.");
-          prm.declare_entry ("Specify a lower maximum degree","false",
-                             Patterns::Bool (),
-                             "Option to use a lower maximum degree when reading the data file of spherical "
-                             "harmonic coefficients. This is probably used for the faster tests or when the "
-                             "users only want to see the spherical harmonic pattern up to a certain degree.");
-          prm.declare_entry ("Maximum degree","20",
-                             Patterns::Integer (0),
-                             "The maximum degree the users specify when reading the data file of spherical harmonic "
-                             "coefficients, which must be smaller than the maximum degree the data file stored. "
-                             "This parameter will be used only if 'Specify a lower maximum degree' is set to true.");
-          aspect::Utilities::AsciiDataProfile<dim>::declare_parameters(prm,
-                                                                       "$ASPECT_SOURCE_DIR/data/initial-temperature/S40RTS/",
-                                                                       "vs_to_density_Steinberger.txt",
-                                                                       "Ascii data vs to density model");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    SAVANIPerturbation<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      AssertThrow (dim == 3,
-                   ExcMessage ("The 'SAVANI perturbation' model for the initial "
-                               "temperature is only available for 3d computations."));
-
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("SAVANI perturbation");
-        {
-          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-          if ((data_directory.size() > 0) && (data_directory[data_directory.size()-1] != '/'))
-            data_directory += "/";
-          harmonics_coeffs_file_name = prm.get ("Initial condition file name");
-          spline_depth_file_name  = prm.get ("Spline knots depth file name");
-          vs_to_density_constant           = prm.get_double ("Vs to density scaling");
-          thermal_alpha           = prm.get_double ("Thermal expansion coefficient in initial temperature scaling");
-          use_material_model_thermal_alpha = prm.get_bool ("Use thermal expansion coefficient from material model");
-          zero_out_degree_0       = prm.get_bool ("Remove degree 0 from perturbation");
-          reference_temperature   = prm.get_double ("Reference temperature");
-          no_perturbation_depth   = prm.get_double ("Remove temperature heterogeneity down to specified depth");
-          lower_max_degree         = prm.get_bool ("Specify a lower maximum degree");
-          specified_max_degree               = prm.get_integer ("Maximum degree");
-
-          if (prm.get("Vs to density scaling method") == "file")
-            vs_to_density_method = file;
-          else if (prm.get("Vs to density scaling method") == "constant")
-            vs_to_density_method = constant;
-          else
-            {
-              AssertThrow(false, ExcMessage("Unknown method for vs to density scaling."));
-            }
-
-          profile.parse_parameters(prm,"Ascii data vs to density model");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(SAVANIPerturbation,
-                                              "SAVANI perturbation",
-                                              "An initial temperature field in which the temperature "
-                                              "is perturbed following the SAVANI shear wave "
-                                              "velocity model by Auer and others, which can be downloaded "
-                                              "here \\url{http://n.ethz.ch/~auerl/savani.tar.bz2}. "
-                                              "Information on the vs model can be found in Auer, L., Boschi, "
-                                              "L., Becker, T.W., Nissen-Meyer, T. \\& Giardini, D., 2014. "
-                                              "Savani: A variable resolution whole-mantle model of anisotropic "
-                                              "shear velocity variations based on multiple data sets. Journal "
-                                              "of Geophysical Research: Solid Earth 119.4 (2014): 3006-3034. "
-                                              "The scaling between the shear wave perturbation and the "
-                                              "density perturbation can be constant and set by the user with the "
-                                              "'Vs to density scaling' parameter or depth-dependent and "
-                                              "read in from a file. To convert density the user can specify "
-                                              "the 'Thermal expansion coefficient in initial temperature scaling' "
-                                              "parameter. The scaling is as follows: $\\delta \\ln \\rho "
-                                              "(r,\\theta,\\phi) = \\xi \\cdot \\delta \\ln v_s(r,\\theta, "
-                                              "\\phi)$ and $\\delta T(r,\\theta,\\phi) = - \\frac{1}{\\alpha} "
-                                              "\\delta \\ln \\rho(r,\\theta,\\phi)$. $\\xi$ is the `vs to "
-                                              "density scaling' parameter and $\\alpha$ is the 'Thermal "
-                                              "expansion coefficient in initial temperature scaling' "
-                                              "parameter. The temperature perturbation is added to an "
-                                              "otherwise constant temperature (incompressible model) or "
-                                              "adiabatic reference profile (compressible model).If a depth "
-                                              "is specified in 'Remove temperature heterogeneity down to "
-                                              "specified depth', there is no temperature perturbation "
-                                              "prescribed down to that depth."
-                                              "\n"
-                                              "Note the required file format if the vs to density scaling is read in "
-                                              "from a file: The first lines may contain any number of comments "
-                                              "if they begin with '#', but one of these lines needs to "
-                                              "contain the number of points in the reference state as "
-                                              "for example '# POINTS: 3'. "
-                                              "Following the comment lines there has to be a single line "
-                                              "containing the names of all data columns, separated by arbitrarily "
-                                              "many spaces. Column names are not allowed to contain spaces. "
-                                              "The file can contain unnecessary columns, but for this plugin it "
-                                              "needs to at least provide the columns named `depth' and "
-                                              "`vs\\_to\\_density'. "
-                                              "Note that the data lines in the file need to be sorted in order "
-                                              "of increasing depth from 0 to the maximal depth in the model "
-                                              "domain. Points in the model that are outside of the provided "
-                                              "depth range will be assigned the maximum or minimum depth values, "
-                                              "respectively. Points do not need to be equidistant, "
-                                              "but the computation of properties is optimized in speed "
-                                              "if they are.")
-  }
-}
diff --git a/source/initial_temperature/adiabatic.cc.bak b/source/initial_temperature/adiabatic.cc.bak
deleted file mode 100644
index 948475d1cc6..00000000000
--- a/source/initial_temperature/adiabatic.cc.bak
+++ /dev/null
@@ -1,572 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/adiabatic.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/chunk.h>
-
-#include <cmath>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    namespace BoundaryLayerAgeModel
-    {
-      BoundaryLayerAgeModel::Kind
-      parse (const std::string &parameter_name,
-             const ParameterHandler &prm)
-      {
-        BoundaryLayerAgeModel::Kind age_model;
-        if (prm.get (parameter_name) == "constant")
-          age_model = constant;
-        else if (prm.get (parameter_name) == "function")
-          age_model = function;
-        else if (prm.get (parameter_name) == "ascii data")
-          age_model = ascii_data;
-        else
-          {
-            AssertThrow(false, ExcMessage("Not a valid boundary layer age model."));
-
-            // We will never get here, but we have to return something
-            // so the compiler does not complain
-            return constant;
-          }
-
-        return age_model;
-      }
-    }
-
-    template <int dim>
-    Adiabatic<dim>::Adiabatic ()
-      :
-      surface_boundary_id(numbers::invalid_unsigned_int)
-    {}
-
-
-
-    template <int dim>
-    void
-    Adiabatic<dim>::initialize ()
-    {
-      if (top_boundary_layer_age_model == BoundaryLayerAgeModel::ascii_data)
-        {
-          // Find the boundary indicator that represents the surface
-          surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-          // The input ascii table contains one data column (LAB depths(m)) in addition to the coordinate columns.
-          Utilities::AsciiDataBoundary<dim>::initialize({surface_boundary_id},
-                                                        1);
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    Adiabatic<dim>::
-    top_boundary_layer_age (const Point<dim> &position) const
-    {
-      // Top boundary layer age in seconds
-      double age_top = 0.0;
-
-      if (top_boundary_layer_age_model == BoundaryLayerAgeModel::ascii_data)
-        {
-          // The input ascii contains the age of the seafloor. User must provide ages in seconds
-          age_top = Utilities::AsciiDataBoundary<dim>::get_data_component(surface_boundary_id,
-                                                                          position,
-                                                                          0);
-        }
-      else if (top_boundary_layer_age_model == BoundaryLayerAgeModel::constant)
-        {
-          age_top =    (this->convert_output_to_years()
-                        ?
-                        age_top_boundary_layer * year_in_seconds
-                        :
-                        age_top_boundary_layer);
-        }
-      else if (top_boundary_layer_age_model == BoundaryLayerAgeModel::function)
-        {
-          Utilities::NaturalCoordinate<dim> point =
-            this->get_geometry_model().cartesian_to_other_coordinates(position,
-                                                                      coordinate_system);
-
-          age_top = age_function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
-          if (this->convert_output_to_years())
-            age_top *= year_in_seconds;
-        }
-      else
-        {
-          Assert(false, ExcMessage("Unknown top boundary layer age model."));
-        }
-
-      return age_top;
-    }
-
-
-    template <int dim>
-    double
-    Adiabatic<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-
-      const double age_top = top_boundary_layer_age(position);
-      const double age_bottom = (this->convert_output_to_years() ? age_bottom_boundary_layer * year_in_seconds
-                                 : age_bottom_boundary_layer);
-
-      // First, get the temperature of the adiabatic profile at a representative
-      // point at the top and bottom boundary of the model
-      // if adiabatic heating is switched off, assume a constant profile
-      const Point<dim> surface_point = this->get_geometry_model().representative_point(0.0);
-      const Point<dim> bottom_point = this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth());
-      const double adiabatic_surface_temperature = this->get_adiabatic_conditions().temperature(surface_point);
-      const double adiabatic_bottom_temperature = (this->include_adiabatic_heating())
-                                                  ?
-                                                  this->get_adiabatic_conditions().temperature(bottom_point)
-                                                  :
-                                                  adiabatic_surface_temperature;
-
-      // then, get the temperature at the top and bottom boundary of the model
-      // if no boundary temperature is prescribed simply use the adiabatic.
-      // This implementation assumes that the top and bottom boundaries have
-      // prescribed temperatures and minimal_temperature() returns the value
-      // at the surface and maximal_temperature() the value at the bottom.
-      const double T_surface = (this->has_boundary_temperature()
-                                ?
-                                this->get_boundary_temperature_manager().minimal_temperature(
-                                  this->get_fixed_temperature_boundary_indicators())
-                                :
-                                adiabatic_surface_temperature);
-      const double T_bottom = (this->has_boundary_temperature()
-                               ?
-                               this->get_boundary_temperature_manager().maximal_temperature(
-                                 this->get_fixed_temperature_boundary_indicators())
-                               :
-                               adiabatic_bottom_temperature);
-      const double depth = this->get_geometry_model().depth(position);
-
-      // look up material properties
-      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
-
-      // compute the adiabat by referring to the Adiabatic conditions model
-      in.position[0] = position;
-      in.temperature[0] = this->get_adiabatic_conditions().temperature(position);
-      in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
-      in.velocity[0] = Tensor<1,dim> ();
-      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-        in.composition[0][c] = function->value(Point<1>(depth),c);
-      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties |
-                                MaterialModel::MaterialProperties::thermal_conductivity;
-      this->get_material_model().evaluate(in, out);
-
-      const double kappa = ( (this->get_parameters().formulation_temperature_equation ==
-                              Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-                             ?
-                             out.thermal_conductivities[0] /
-                             (this->get_adiabatic_conditions().density(in.position[0]) * out.specific_heat[0])
-                             :
-                             out.thermal_conductivities[0] / (out.densities[0] * out.specific_heat[0])
-                           );
-
-      double surface_cooling_temperature = 0;
-      double bottom_heating_temperature = 0;
-
-      if (cooling_model == "half-space cooling")
-        {
-          if (age_top > 0.0 || age_bottom > 0.0)
-            AssertThrow (kappa > 0.0,
-                         ExcMessage ("The thermal diffusivity needs to be larger than zero "
-                                     "for computing thermal boundary layers with the half-space "
-                                     "cooling model."));
-
-          // analytical solution for the thermal boundary layer from half-space cooling model
-          surface_cooling_temperature = age_top > 0.0 ?
-                                        (T_surface - adiabatic_surface_temperature) *
-                                        erfc(this->get_geometry_model().depth(position) /
-                                             (2 * sqrt(kappa * age_top)))
-                                        : 0.0;
-          bottom_heating_temperature = (age_bottom > 0.0 && this->get_adiabatic_conditions().is_initialized()) ?
-                                       (T_bottom - adiabatic_bottom_temperature + subadiabaticity)
-                                       * erfc((this->get_geometry_model().maximal_depth()
-                                               - this->get_geometry_model().depth(position)) /
-                                              (2 * sqrt(kappa * age_bottom)))
-                                       : 0.0;
-        }
-
-      if (cooling_model == "plate cooling")
-        {
-          if (depth > lithosphere_thickness)
-            {
-              surface_cooling_temperature = 0;
-            }
-          else
-            {
-              const double exponential = -kappa * std::pow(numbers::PI, 2) * age_top / std::pow(lithosphere_thickness, 2);
-              double sum_terms = 0.;
-              for (unsigned int n=1; n<11; ++n)
-                {
-                  const auto dn = static_cast<double>(n);
-                  sum_terms += 1./dn * std::exp(dn * dn * exponential) * std::sin(dn * depth * numbers::PI / lithosphere_thickness);
-                  surface_cooling_temperature = T_surface - adiabatic_surface_temperature + (adiabatic_surface_temperature - T_surface) * (depth / lithosphere_thickness + 2 / numbers::PI * sum_terms);
-                }
-            }
-        }
-
-      // set the initial temperature perturbation
-      // first: get the center of the perturbation, then check the distance to the
-      // evaluation point. the center is supposed to lie at the center of the bottom
-      // surface.
-      Point<dim> mid_point;
-      if (perturbation_position == "center")
-        {
-          if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()))
-            {
-              const GeometryModel::SphericalShell<dim> &shell_geometry_model =
-                Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
-
-              const double inner_radius = shell_geometry_model.inner_radius();
-              const double half_opening_angle = constants::degree_to_radians * 0.5 * shell_geometry_model.opening_angle();
-              if (dim==2)
-                {
-                  // choose the center of the perturbation at half angle along the inner radius
-                  mid_point(0) = inner_radius * std::sin(half_opening_angle),
-                  mid_point(1) = inner_radius * std::cos(half_opening_angle);
-                }
-              else if (dim==3)
-                {
-                  // if the opening angle is 90 degrees (an eighth of a full spherical
-                  // shell, then choose the point on the inner surface along the first
-                  // diagonal
-                  if (shell_geometry_model.opening_angle() == 90)
-                    {
-                      mid_point(0) = inner_radius*std::sqrt(1./3),
-                      mid_point(1) = inner_radius*std::sqrt(1./3),
-                      mid_point(2) = inner_radius*std::sqrt(1./3);
-                    }
-                  else
-                    {
-                      // otherwise do the same as in 2d
-                      mid_point(0) = inner_radius * std::sin(half_opening_angle) * std::cos(half_opening_angle),
-                      mid_point(1) = inner_radius * std::sin(half_opening_angle) * std::sin(half_opening_angle),
-                      mid_point(2) = inner_radius * std::cos(half_opening_angle);
-                    }
-                }
-            }
-          else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()))
-            {
-              const GeometryModel::Chunk<dim> &chunk_geometry_model =
-                Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>> (this->get_geometry_model());
-
-              const double inner_radius = chunk_geometry_model.inner_radius();
-
-              const double west_longitude = chunk_geometry_model.west_longitude(); // in radians
-              const double longitude_range = chunk_geometry_model.longitude_range(); // in radians
-              const double longitude_midpoint = west_longitude + 0.5 * longitude_range;
-
-              if (dim==2)
-                {
-                  // choose the center of the perturbation at half angle along the inner radius
-                  mid_point(0) = inner_radius * std::cos(longitude_midpoint),
-                  mid_point(1) = inner_radius * std::sin(longitude_midpoint);
-                }
-              else if (dim==3)
-                {
-
-                  const double south_latitude = chunk_geometry_model.south_latitude(); // in radians
-                  const double latitude_range = chunk_geometry_model.latitude_range(); // in radians
-                  const double latitude_midpoint = south_latitude + 0.5 * latitude_range;
-                  mid_point(0) = inner_radius * std::cos(latitude_midpoint) * std::cos(longitude_midpoint);
-                  mid_point(1) = inner_radius * std::cos(latitude_midpoint) * std::sin(longitude_midpoint);
-                  mid_point(2) = inner_radius * std::sin(latitude_midpoint);
-                }
-            }
-          else if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()))
-            {
-              const GeometryModel::Box<dim> &box_geometry_model =
-                Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
-
-              // for the box geometry, choose a point at the center of the bottom face.
-              // (note that the loop only runs over the first dim-1 coordinates, leaving
-              // the depth variable at zero)
-              mid_point = box_geometry_model.get_origin();
-              for (unsigned int i=0; i<dim-1; ++i)
-                mid_point(i) += 0.5 * box_geometry_model.get_extents()[i];
-            }
-          else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
-            {
-              const GeometryModel::TwoMergedBoxes<dim> &two_merged_boxes_geometry_model =
-                Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model());
-
-              // for the box geometry, choose a point at the center of the bottom face.
-              // (note that the loop only runs over the first dim-1 coordinates, leaving
-              // the depth variable at zero)
-              mid_point = two_merged_boxes_geometry_model.get_origin();
-              for (unsigned int i=0; i<dim-1; ++i)
-                mid_point(i) += 0.5 * two_merged_boxes_geometry_model.get_extents()[i];
-            }
-          else
-            AssertThrow (false,
-                         ExcMessage ("Not a valid geometry model for the initial temperature model"
-                                     "adiabatic."));
-        }
-
-      const double perturbation = (mid_point.distance(position) < radius) ? amplitude
-                                  : 0.0;
-
-
-      // add the subadiabaticity
-      const double zero_depth = 0.174;
-      const double nondimensional_depth = (this->get_geometry_model().depth(position) / this->get_geometry_model().maximal_depth() - zero_depth)
-                                          / (1.0 - zero_depth);
-      double subadiabatic_T = 0.0;
-      if (nondimensional_depth > 0)
-        subadiabatic_T = -subadiabaticity * nondimensional_depth * nondimensional_depth;
-
-      // If adiabatic heating is disabled, apply all perturbations to
-      // constant adiabatic surface temperature instead of adiabatic profile.
-      const double temperature_profile = (this->include_adiabatic_heating())
-                                         ?
-                                         this->get_adiabatic_conditions().temperature(position)
-                                         :
-                                         adiabatic_surface_temperature;
-
-      // return sum of the adiabatic profile, the boundary layer temperatures and the initial
-      // temperature perturbation.
-      return temperature_profile + surface_cooling_temperature
-             + (perturbation > 0.0 ? std::max(bottom_heating_temperature + subadiabatic_T,perturbation)
-                : bottom_heating_temperature + subadiabatic_T);
-    }
-
-    template <int dim>
-    void
-    Adiabatic<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                          "$ASPECT_SOURCE_DIR/data/initial-temperature/adiabatic/",
-                                                          "adiabatic.txt",
-                                                          "Adiabatic");
-        prm.enter_subsection("Adiabatic");
-        {
-          prm.declare_entry ("Age top boundary layer", "0.",
-                             Patterns::Double (0.),
-                             "The age of the upper thermal boundary layer, used for the calculation "
-                             "of the half-space cooling model temperature. Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-          prm.declare_entry ("Age bottom boundary layer", "0.",
-                             Patterns::Double (0.),
-                             "The age of the lower thermal boundary layer, used for the calculation "
-                             "of the half-space cooling model temperature. Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-          prm.declare_entry ("Radius", "0.",
-                             Patterns::Double (0.),
-                             "The Radius (in m) of the initial spherical temperature perturbation "
-                             "at the bottom of the model domain.");
-          prm.declare_entry ("Amplitude", "0.",
-                             Patterns::Double (0.),
-                             "The amplitude (in K) of the initial spherical temperature perturbation "
-                             "at the bottom of the model domain. This perturbation will be added to "
-                             "the adiabatic temperature profile, but not to the bottom thermal "
-                             "boundary layer. Instead, the maximum of the perturbation and the bottom "
-                             "boundary layer temperature will be used.");
-          prm.declare_entry ("Position", "center",
-                             Patterns::Selection ("center"),
-                             "Where the initial temperature perturbation should be placed. If `center' is "
-                             "given, then the perturbation will be centered along a `midpoint' of some "
-                             "sort of the bottom boundary. For example, in the case of a box geometry, "
-                             "this is the center of the bottom face; in the case of a spherical shell "
-                             "geometry, it is along the inner surface halfway between the bounding "
-                             "radial lines.");
-          prm.declare_entry ("Subadiabaticity", "0.",
-                             Patterns::Double (0.),
-                             "If this value is larger than 0, the initial temperature profile will "
-                             "not be adiabatic, but subadiabatic. This value gives the maximal "
-                             "deviation from adiabaticity. Set to 0 for an adiabatic temperature "
-                             "profile. Units: \\si{\\kelvin}.\n\n"
-                             "The function object in the Function subsection "
-                             "represents the compositional fields that will be used as a reference "
-                             "profile for calculating the thermal diffusivity. "
-                             "This function is one-dimensional and depends only on depth. The format of this "
-                             "functions follows the syntax understood by the "
-                             "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.");
-          prm.declare_entry ("Top boundary layer age model", "constant",
-                             Patterns::Selection ("constant|function|ascii data"),
-                             "How to define the age of the top thermal boundary layer. "
-                             "Options are: 'constant' for a constant age specified by the "
-                             "parameter 'Age top boundary layer'; 'function' for an analytical "
-                             "function describing the age as specified in the subsection "
-                             "'Age function'; and 'ascii data' to use an 'ascii data' file "
-                             "specified by the parameter 'Data file name'.");
-          prm.declare_entry ("Cooling model", "half-space cooling",
-                             Patterns::Selection ("half-space cooling|plate cooling"),
-                             "Whether to use the half space cooling model or the plate cooling model");
-          prm.declare_entry ("Lithosphere thickness", "125e3",
-                             Patterns::Double (0.),
-                             "Thickness of the lithosphere for plate cooling model. \\si{\\m}");
-
-          prm.enter_subsection("Function");
-          {
-            Functions::ParsedFunction<1>::declare_parameters (prm, 1);
-          }
-          prm.leave_subsection();
-
-          prm.enter_subsection("Age function");
-          {
-            /**
-             * Choose the coordinates to evaluate the age
-             * function. The function can be declared in dependence of depth,
-             * cartesian coordinates or spherical coordinates. Note that the order
-             * of spherical coordinates is r,phi,theta and not r,theta,phi, since
-             * this allows for dimension independent expressions.
-             */
-            prm.declare_entry ("Coordinate system", "cartesian",
-                               Patterns::Selection ("cartesian|spherical"),
-                               "A selection that determines the assumed coordinate "
-                               "system for the function variables. Allowed values "
-                               "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                               "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                               "respectively with theta being the polar angle. `depth' "
-                               "will create a function, in which only the first "
-                               "parameter is non-zero, which is interpreted to "
-                               "be the depth of the point.");
-
-            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    Adiabatic<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // we need to get the number of compositional fields here to
-      // initialize the function parser. unfortunately, we can't get it
-      // via SimulatorAccess from the simulator itself because at the
-      // current point the SimulatorAccess hasn't been initialized
-      // yet. so get it from the parameter file directly.
-      prm.enter_subsection ("Compositional fields");
-      const unsigned int n_compositional_fields = prm.get_integer ("Number of fields");
-      prm.leave_subsection ();
-
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataBase<dim>::parse_parameters(prm, "Adiabatic");
-
-        prm.enter_subsection("Adiabatic");
-        {
-          top_boundary_layer_age_model = BoundaryLayerAgeModel::parse("Top boundary layer age model",
-                                                                      prm);
-
-          age_top_boundary_layer = prm.get_double ("Age top boundary layer");
-          age_bottom_boundary_layer = prm.get_double ("Age bottom boundary layer");
-
-          radius = prm.get_double ("Radius");
-          amplitude = prm.get_double ("Amplitude");
-          perturbation_position = prm.get("Position");
-
-          subadiabaticity = prm.get_double ("Subadiabaticity");
-
-          cooling_model = prm.get ("Cooling model");
-          lithosphere_thickness = prm.get_double ("Lithosphere thickness");
-
-          if (n_compositional_fields > 0)
-            {
-              prm.enter_subsection("Function");
-              try
-                {
-                  function
-                    = std::make_unique<Functions::ParsedFunction<1>>(n_compositional_fields);
-                  function->parse_parameters (prm);
-                }
-              catch (...)
-                {
-                  std::cerr << "ERROR: FunctionParser failed to parse\n"
-                            << "\t'Initial temperature model.Adiabatic.Function'\n"
-                            << "with expression\n"
-                            << "\t'" << prm.get("Function expression") << "'"
-                            << "More information about the cause of the parse error \n"
-                            << "is shown below.\n";
-                  throw;
-                }
-
-              prm.leave_subsection();
-            }
-
-          prm.enter_subsection("Age function");
-          {
-            coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-          }
-          try
-            {
-              age_function.parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Initial temperature model.Adiabatic.Age Function'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-
-          prm.leave_subsection();
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(Adiabatic,
-                                              "adiabatic",
-                                              "Temperature is prescribed as an adiabatic "
-                                              "profile with upper and lower thermal boundary layers, "
-                                              "whose ages are given as input parameters. "
-                                              "Note that this plugin uses the 'Adiabatic conditions model' "
-                                              "to compute the adiabat. Thus, the results depend on variables "
-                                              "defined outside of this specific subsection; "
-                                              "e.g. the globally defined 'Adiabatic surface temperature', "
-                                              "and the variables defined in the 'Material model' section "
-                                              "including densities, heat capacities and thermal expansivities.")
-  }
-}
diff --git a/source/initial_temperature/adiabatic_boundary.cc.bak b/source/initial_temperature/adiabatic_boundary.cc.bak
deleted file mode 100644
index c9c5e2f17c8..00000000000
--- a/source/initial_temperature/adiabatic_boundary.cc.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/adiabatic_boundary.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/utilities.h>
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    AdiabaticBoundary<dim>::AdiabaticBoundary ()
-      :
-      surface_boundary_id(numbers::invalid_unsigned_int)
-    {}
-
-    template <int dim>
-    void
-    AdiabaticBoundary<dim>::initialize ()
-    {
-      // Find the boundary indicator that represents the surface
-      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-      std::set<types::boundary_id> surface_boundary_set;
-      surface_boundary_set.insert(surface_boundary_id);
-
-      // The input ascii table contains one data column (LAB depths(m)) in addition to the coordinate columns.
-      Utilities::AsciiDataBoundary<dim>::initialize(surface_boundary_set,
-                                                    1);
-    }
-
-    template <int dim>
-    double
-    AdiabaticBoundary<dim>::initial_temperature (const Point<dim> &position) const
-    {
-      const double depth = this->get_geometry_model().depth(position);
-      const double isotherm_depth              =
-        Utilities::AsciiDataBoundary<dim>::get_data_component(surface_boundary_id, position, 0);
-      if (depth > isotherm_depth)
-        return isotherm_temperature + (depth - isotherm_depth) * temperature_gradient;
-      else
-        return surface_temperature + (depth/isotherm_depth) * (isotherm_temperature - surface_temperature);
-    }
-
-    template <int dim>
-    void
-    AdiabaticBoundary<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                          "$ASPECT_SOURCE_DIR/data/initial-temperature/adiabatic-boundary/",
-                                                          "adiabatic_boundary.txt",
-                                                          "Adiabatic boundary");
-        prm.enter_subsection("Adiabatic boundary");
-        {
-          prm.declare_entry ("Isotherm temperature", "1673.15",
-                             Patterns::Double (0.),
-                             "The value of the isothermal boundary temperature. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Surface temperature", "273.15",
-                             Patterns::Double (0.),
-                             "The value of the surface temperature. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Adiabatic temperature gradient", "0.0005",
-                             Patterns::Double (0.),
-                             "The value of the adiabatic temperature gradient. "
-                             "Units: \\si{\\kelvin\\per\\meter}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    AdiabaticBoundary<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataBase<dim>::parse_parameters(prm,"Adiabatic boundary");
-
-        prm.enter_subsection("Adiabatic boundary");
-        {
-          isotherm_temperature = prm.get_double("Isotherm temperature");
-          surface_temperature  = prm.get_double("Surface temperature");
-          temperature_gradient = prm.get_double("Adiabatic temperature gradient");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AdiabaticBoundary,
-                                              "adiabatic boundary",
-                                              "An initial temperature condition that allows for discretizing "
-                                              "the model domain into two layers separated by a user-defined "
-                                              "isothermal boundary. The user includes an input ascii data file "
-                                              "that is formatted as 3 columns of `longitude(radians)', "
-                                              "`colatitude(radians)', and `isotherm depth(meters)', where `isotherm depth' represents the depth "
-                                              "of an initial temperature of 1673.15 K (by default). "
-                                              "The first lines in the data file may contain any number of comments if they begin "
-                                              "with `#', but one of these lines needs to contain the number of grid points "
-                                              "in each dimension as for example `# POINTS: 69 121'. Note that the coordinates need "
-                                              "to be sorted in a specific order: the `longitude' coordinate needs to ascend first, "
-                                              "followed by the `colatitude' coordinate in order to assign the correct data (isotherm depth) to the "
-                                              "prescribed coordinates. "
-                                              "The temperature is defined from the surface (273.15 K) to the isotherm depth (1673.15 K) "
-                                              "as a linear gradient. Below the isotherm depth the temperature increases "
-                                              "approximately adiabatically (0.0005 K per meter). "
-                                              "This plugin should work for all geometry models, but is currently only tested for spherical models.")
-  }
-}
diff --git a/source/initial_temperature/ascii_data.cc.bak b/source/initial_temperature/ascii_data.cc.bak
deleted file mode 100644
index 3af027f8b17..00000000000
--- a/source/initial_temperature/ascii_data.cc.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/initial_temperature/ascii_data.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      Utilities::AsciiDataInitial<dim>::initialize(1);
-    }
-
-
-    template <int dim>
-    double
-    AsciiData<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      return Utilities::AsciiDataInitial<dim>::get_data_component(position,0);
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataInitial<dim>::declare_parameters(prm,
-                                                             "$ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/",
-                                                             "box_2d.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataInitial<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AsciiData,
-                                              "ascii data",
-                                              "Implementation of a model in which the initial "
-                                              "temperature is derived from files containing data "
-                                              "in ascii format. Note the required format of the "
-                                              "input data: The first lines may contain any number of comments "
-                                              "if they begin with `#', but one of these lines needs to "
-                                              "contain the number of grid points in each dimension as "
-                                              "for example `# POINTS: 3 3'. "
-                                              "The order of the data columns "
-                                              "has to be `x', `y', `Temperature [K]' in a 2d model and "
-                                              " `x', `y', `z', `Temperature [K]' in a 3d model, which means that "
-                                              "there has to be a single column "
-                                              "containing the temperature. "
-                                              "Note that the data in the input "
-                                              "files need to be sorted in a specific order: "
-                                              "the first coordinate needs to ascend first, "
-                                              "followed by the second and the third at last in order to "
-                                              "assign the correct data to the prescribed coordinates. "
-                                              "If you use a spherical model, "
-                                              "then the assumed grid changes. `x' will be replaced by "
-                                              "the radial distance of the point to the bottom of the model, "
-                                              "`y' by the azimuth angle and `z' by the polar angle measured "
-                                              "positive from the north pole. The grid will be assumed to be "
-                                              "a latitude-longitude grid. Note that the order "
-                                              "of spherical coordinates is `r', `phi', `theta' "
-                                              "and not `r', `theta', `phi', since this allows "
-                                              "for dimension independent expressions.")
-  }
-}
diff --git a/source/initial_temperature/ascii_data_layered.cc.bak b/source/initial_temperature/ascii_data_layered.cc.bak
deleted file mode 100644
index 10d687f8821..00000000000
--- a/source/initial_temperature/ascii_data_layered.cc.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/initial_temperature/ascii_data_layered.h>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    AsciiDataLayered<dim>::AsciiDataLayered ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiDataLayered<dim>::initialize ()
-    {
-      // The ascii data layered class has dim-1 spatial columns
-      // (which provide the horizontal coordinates of the layer).
-      // We need another 2 columns; the first for the depth
-      // of the layer at the given horizontal coordinates,
-      // and the second for temperature (for cases where
-      // temperature varies across the layer).
-      Utilities::AsciiDataLayered<dim>::initialize(2);
-    }
-
-
-    template <int dim>
-    double
-    AsciiDataLayered<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // This is where we get the initial temperature
-      return Utilities::AsciiDataLayered<dim>::get_data_component(position,1);
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataLayered<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataLayered<dim>::declare_parameters(prm,
-                                                             "$ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/",
-                                                             "initial_isotherm_500K_box_3d.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataLayered<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataLayered<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AsciiDataLayered,
-                                              "ascii data layered",
-                                              "Implementation of a model in which the initial "
-                                              "temperature is derived from files containing data "
-                                              "in ascii format. Each file defines a surface on which "
-                                              "temperature is defined. "
-                                              "Between the surfaces, the temperatures can be chosen to be "
-                                              "constant (with a value defined by the nearest shallower "
-                                              "surface), or linearly interpolated between surfaces. "
-                                              "Note the required format of the input ascii data file: "
-                                              "The first lines may contain any number of comments "
-                                              "if they begin with `#', but one of these lines needs to "
-                                              "contain the number of grid points in each dimension as "
-                                              "for example `# POINTS: 3 3'. "
-                                              "The order of the data columns "
-                                              "has to be `x', `y', `Temperature [K]' in a 2d model and "
-                                              "`x', `y', `z', `Temperature [K]' in a 3d model; i.e. "
-                                              "the last two columns always contain the position of the "
-                                              "isotherm along the vertical direction, and the temperature "
-                                              "at that point. The first column needs to ascend first, "
-                                              "followed by the second in order to assign the correct data "
-                                              "to the prescribed coordinates. If you use a spherical model, "
-                                              "then the assumed grid changes. `x' will be replaced by the "
-                                              "azimuth angle and `y' (if 3d) by the polar angle measured "
-                                              "positive from the north pole. The last column will be the "
-                                              "distance of the point from the origin "
-                                              "(i.e. radial position). The grid in this case will be "
-                                              "a latitude-longitude grid. Note that the order "
-                                              "of spherical coordinates in 3d is `phi', `theta', `r', `T'"
-                                              "and not `theta', `phi', `r', `T' as this is "
-                                              "more consistent with other ASPECT plugins. Outside of the "
-                                              "region defined by the grid, the plugin will use the value "
-                                              "at the edge of the region.")
-  }
-}
diff --git a/source/initial_temperature/ascii_profile.cc.bak b/source/initial_temperature/ascii_profile.cc.bak
deleted file mode 100644
index 49091c317c4..00000000000
--- a/source/initial_temperature/ascii_profile.cc.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/initial_temperature/ascii_profile.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    AsciiProfile<dim>::AsciiProfile ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiProfile<dim>::initialize ()
-    {
-      this->initialize(this->get_mpi_communicator());
-      temperature_index = this->get_column_index_from_name("temperature");
-    }
-
-
-
-    template <int dim>
-    double AsciiProfile<dim>::initial_temperature (const Point<dim> &p) const
-    {
-      const double depth = this->get_geometry_model().depth(p);
-      return this->get_data_component(Point<1>(depth),temperature_index);
-    }
-
-
-    template <int dim>
-    void
-    AsciiProfile<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                          "$ASPECT_SOURCE_DIR/data/initial-temperature/ascii-profile/tests/",
-                                                          "simple_test.txt",
-                                                          "Ascii profile");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiProfile<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        Utilities::AsciiDataBase<dim>::parse_parameters(prm,
-                                                        "Ascii profile");
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(AsciiProfile,
-                                              "ascii profile",
-                                              "Implementation of a model in which the initial temperature is "
-                                              "read from a file that provides these values as a function of "
-                                              "depth. Note the required format of the input data: The first "
-                                              "lines may contain any number of comments if they begin with "
-                                              "`#', but one of these lines needs to contain the number of "
-                                              "points in the temperature profile, for example `# POINTS: 10'. "
-                                              "Following the comment lines, there has to be a single line "
-                                              "containing the names of all data columns, separated by arbitrarily "
-                                              "many spaces. Column names are not allowed to contain spaces. "
-                                              "The file can contain unnecessary columns, but for this plugin it "
-                                              "needs to at least provide columns named `depth' and"
-                                              "`temperature'."
-                                              "Note that the data lines in the file need to be sorted in order "
-                                              "of increasing depth from 0 to the maximal depth in the model "
-                                              "domain. Points in the model that are outside of the provided "
-                                              "depth range will be assigned the maximum or minimum depth values, "
-                                              "respectively. Points do not need to be equidistant, "
-                                              "but the computation of properties is optimized in speed "
-                                              "if they are.")
-  }
-}
diff --git a/source/initial_temperature/box.cc.bak b/source/initial_temperature/box.cc.bak
deleted file mode 100644
index bdf58376da9..00000000000
--- a/source/initial_temperature/box.cc.bak
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
-  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/box.h>
-#include <aspect/geometry_model/box.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    double
-    PerturbedBox<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // this initial condition only makes sense if the geometry is a
-      // Box. verify that it is indeed
-      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
-                   ExcMessage ("This initial condition can only be used if the geometry "
-                               "is a box."));
-
-      const GeometryModel::Box<dim> &geometry
-        = Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
-
-      double perturbation = 1;
-      for (unsigned int d=0; d<dim; ++d)
-        perturbation *= std::sin(numbers::PI*(position[d]-geometry.get_origin()[d])/geometry.get_extents()[d]);
-      return 1 + perturbation/10;
-    }
-
-    template <int dim>
-    double
-    PolarBox<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // this initial condition only makes sense if the geometry is a
-      // Box. verify that it is indeed
-      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
-                   ExcMessage ("This initial condition can only be used if the geometry "
-                               "is a box."));
-
-      const GeometryModel::Box<dim> &geometry
-        = Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
-
-      Point<dim> temporary1, temporary2;
-      for (int d=0; d<dim; ++d)
-        {
-          temporary1[d]=geometry.get_extents()[d]*0.625+geometry.get_origin()[d];
-          temporary2[d]=geometry.get_extents()[d]*0.375+geometry.get_origin()[d];
-        }
-
-      return 1+(1/exp(position.distance(temporary2)) - 1/exp(position.distance(temporary1)));
-    }
-
-    template <int dim>
-    double
-    MandelBox<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // this initial condition only makes sense if the geometry is a
-      // box. verify that it is indeed
-      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
-                   ExcMessage ("This initial condition can only be used if the geometry "
-                               "is a box."));
-
-      const GeometryModel::Box<dim> &geometry
-        = Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
-
-      double perturbation, ratio;
-      Point<dim> center;
-      ratio = center[0] = geometry.get_extents()[0]*0.66;
-      center[1] = geometry.get_extents()[1]*0.5;
-      if (center[1] < ratio)
-        ratio = center[1];
-
-      double zx = (position[0] - geometry.get_origin()[0] - center[0])/ratio;
-      double zy = (position[1] - geometry.get_origin()[1] - center[1])/ratio;
-      double x = zx;
-      double y = zy;
-
-      for (perturbation = 0; perturbation < 50 && (Point<2>(x,y)).norm() <= 2; ++perturbation)
-        {
-          x = x*x - y*y + zx;
-          y = 2 * x*y + zy;
-        }
-      return perturbation / 50;
-    }
-
-
-
-    template <int dim>
-    double
-    InclusionShapeBox<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // this initial condition only makes sense if the geometry is a
-      // box. verify that it is indeed
-      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
-                   ExcMessage ("This initial condition can only be used if the geometry "
-                               "is a box."));
-
-      double perturbation = 0;
-      Point<dim> center;
-      for (int d=0; d<dim; ++d)
-        center[d] = (Point<3>(center_x,center_y,center_z))[d];
-
-      if (inclusion_shape == "square")
-        {
-          if (inclusion_gradient == "gaussian")
-            {
-              perturbation = inclusion_temperature - ambient_temperature;
-              for (int d=0; d<dim; ++d)
-                perturbation *= exp(-8*pow(position.distance(center)/radius, 2));
-            }
-          else if (inclusion_gradient == "linear")
-            {
-              double x = position[0] - center[0];
-              double y = position[1] - center[1];
-              if ( x <= y && x >= -y)
-                perturbation = radius - y;
-              else if (x <= y && x <= -y)
-                perturbation = radius + x;
-              else if (x >= y && x >= -y)
-                perturbation = radius - x;
-              else if (x >= y && x <= -y)
-                perturbation = radius + y;
-              perturbation *= (inclusion_temperature - ambient_temperature) / radius;
-            }
-          else if (inclusion_gradient == "constant")
-            {
-              perturbation = inclusion_temperature - ambient_temperature;
-            }
-          for (int d = 0; d < dim; ++d)
-            if (abs (center[d] - position[d]) > radius)
-              perturbation = 0;
-        }
-      else if (inclusion_shape == "circle")
-        {
-          if (inclusion_gradient == "gaussian")
-            {
-              perturbation = inclusion_temperature - ambient_temperature;
-              perturbation *= exp(-pow(position.distance(center),2) / (2 * pow((radius / 4), 2))) / (2 * radius);
-            }
-          else if (inclusion_gradient == "linear")
-            {
-              perturbation = ((radius - position.distance(center)) / radius) * (inclusion_temperature - ambient_temperature);
-            }
-          else if (inclusion_gradient == "constant")
-            {
-              perturbation = inclusion_temperature - ambient_temperature;
-            }
-          if (position.distance(center) > radius)
-            perturbation = 0;
-        }
-
-      return ambient_temperature + perturbation;
-    }
-
-    template <int dim>
-    void
-    InclusionShapeBox<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection ("Inclusion shape perturbation");
-        {
-          prm.declare_entry("Inclusion shape", "circle",
-                            Patterns::Selection("square|circle"),
-                            "The shape of the inclusion to be generated.");
-          prm.declare_entry("Inclusion gradient", "constant",
-                            Patterns::Selection("gaussian|linear|constant"),
-                            "The gradient of the inclusion to be generated.");
-          prm.declare_entry("Shape radius", "1.0",
-                            Patterns::Double (0.),
-                            "The radius of the inclusion to be generated. For "
-                            "shapes with no radius (e.g. square), this will "
-                            "be the width, and for shapes with no width, this "
-                            "gives a general guideline for the size of the shape.");
-          prm.declare_entry("Ambient temperature", "1.0",
-                            Patterns::Double (),
-                            "The background temperature for the temperature field.");
-          prm.declare_entry("Inclusion temperature", "0.0",
-                            Patterns::Double (),
-                            "The temperature of the inclusion shape. This is only "
-                            "the true temperature in the case of the constant "
-                            "gradient. In all other cases, it gives one endpoint "
-                            "of the temperature gradient for the shape.");
-          prm.declare_entry("Center X", "0.5",
-                            Patterns::Double (),
-                            "The X coordinate for the center of the shape.");
-          prm.declare_entry("Center Y", "0.5",
-                            Patterns::Double (),
-                            "The Y coordinate for the center of the shape.");
-          prm.declare_entry("Center Z", "0.5",
-                            Patterns::Double (),
-                            "The Z coordinate for the center of the shape. This "
-                            "is only necessary for three-dimensional fields.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-    template <int dim>
-    void
-    InclusionShapeBox<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Inclusion shape perturbation");
-        {
-          inclusion_shape = prm.get ("Inclusion shape");
-          inclusion_gradient = prm.get ("Inclusion gradient");
-          radius = prm.get_double ("Shape radius");
-          ambient_temperature = prm.get_double ("Ambient temperature");
-          inclusion_temperature = prm.get_double ("Inclusion temperature");
-          center_x = prm.get_double ("Center X");
-          center_y = prm.get_double ("Center Y");
-          center_z = prm.get_double ("Center Z");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(PerturbedBox,
-                                              "perturbed box",
-                                              "An initial temperature field in which the temperature "
-                                              "is perturbed slightly from an otherwise constant value "
-                                              "equal to one. The perturbation is chosen in such a way "
-                                              "that the initial temperature is constant to one along "
-                                              "the entire boundary.")
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(PolarBox,
-                                              "polar box",
-                                              "An initial temperature field in which the temperature "
-                                              "is perturbed slightly from an otherwise constant value "
-                                              "equal to one. The perturbation is such that there are "
-                                              "two poles on opposing corners of the box. ")
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(InclusionShapeBox,
-                                              "inclusion shape perturbation",
-                                              "An initial temperature field in which there is an "
-                                              "inclusion in a constant-temperature box field. The size, "
-                                              "shape, gradient, position, and temperature of the "
-                                              "inclusion are defined by parameters.")
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(MandelBox,
-                                              "mandelbox",
-                                              "Fractal-shaped temperature field.")
-  }
-}
diff --git a/source/initial_temperature/continental_geotherm.cc.bak b/source/initial_temperature/continental_geotherm.cc.bak
deleted file mode 100644
index 59c5b4bf941..00000000000
--- a/source/initial_temperature/continental_geotherm.cc.bak
+++ /dev/null
@@ -1,269 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/continental_geotherm.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/material_model/visco_plastic.h>
-#include <aspect/heating_model/interface.h>
-
-#include <cmath>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    ContinentalGeotherm<dim>::ContinentalGeotherm ()
-      = default;
-
-
-    template <int dim>
-    void
-    ContinentalGeotherm<dim>::
-    initialize ()
-    {
-      // Check that the required radioactive heating model ("compositional heating") is used
-      const std::vector<std::string> &heating_models = this->get_heating_model_manager().get_active_heating_model_names();
-      AssertThrow(std::find(heating_models.begin(), heating_models.end(), "compositional heating") != heating_models.end(),
-                  ExcMessage("The continental geotherm initial temperature plugin requires the compositional heating plugin."));
-
-      // Check that the required material model ("visco plastic") is used
-      AssertThrow(Plugins::plugin_type_matches<MaterialModel::ViscoPlastic<dim>>(this->get_material_model()),
-                  ExcMessage("The continental geotherm initial temperature plugin requires the viscoplastic material model plugin."));
-    }
-
-
-    template <int dim>
-    double
-    ContinentalGeotherm<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // Get the depth of the point with respect to the reference surface.
-      const double depth = this->get_geometry_model().depth(position);
-
-      // Compute some constants to calculate the temperatures T1 and T2 at the interfaces
-      // between the layers upper crust/lower crust (depth y=h1) and lower crust/lithospheric mantle (depth y=h1+h2).
-      // T1 = (ab + k2/h2 cdb) / (1 - k2^2/h2^2 db)
-      // T2 = (c + k2/h2 T1) d
-      // These derivations are based on the assumption that at the boundary between
-      // the layers, the heat flows of the two layers are equal, so
-      // at y=h1, q1(h1)=q2(h2)=k1 dT1/dy|h1 = k2 dT2/dy|h2 etc.
-      const double a = 0.5*densities[0]*heat_productivities[0]*thicknesses[0] + 0.5*densities[1]*heat_productivities[1]*thicknesses[1] + conductivities[0]/thicknesses[0]*T0;
-      const double b = 1./(conductivities[0]/thicknesses[0]+conductivities[1]/thicknesses[1]);
-      const double c = 0.5*densities[1]*heat_productivities[1]*thicknesses[1] + conductivities[2]/thicknesses[2]*LAB_isotherm;
-      const double d = 1./(conductivities[1]/thicknesses[1]+conductivities[2]/thicknesses[2]);
-
-      // Temperature at boundary between layer 1 and 2
-      const double T1 = (a*b + conductivities[1]/thicknesses[1]*c*d*b) / (1.-(conductivities[1]*conductivities[1])/(thicknesses[1]*thicknesses[1])*d*b);
-      // Temperature at boundary between layer 2 and 3
-      const double T2 = (c + conductivities[1]/thicknesses[1]*T1) * d;
-
-      // Temperature in layer 1
-      if (depth <= thicknesses[0])
-        return -0.5*densities[0]*heat_productivities[0]/conductivities[0]*std::pow(depth,2) + (0.5*densities[0]*heat_productivities[0]*thicknesses[0]/conductivities[0] + (T1-T0)/thicknesses[0])*depth + T0;
-      // Temperature in layer 2
-      else if (depth <= thicknesses[0]+thicknesses[1])
-        return -0.5*densities[1]*heat_productivities[1]/conductivities[1]*std::pow(depth-thicknesses[0],2.) + (0.5*densities[1]*heat_productivities[1]*thicknesses[1]/conductivities[1] + (T2-T1)/thicknesses[1])*(depth-thicknesses[0]) + T1;
-      // Temperature in layer 3
-      else if (depth <= thicknesses[0]+thicknesses[1]+thicknesses[2])
-        return (LAB_isotherm-T2)/thicknesses[2] *(depth-thicknesses[0]-thicknesses[1]) + T2;
-      // Return an unrealistically high temperature if we're below the lithosphere.
-      // This way we can combine the continental geotherm with an adiabatic profile from the input file
-      // using the "minimum" operator on the "List of initial temperature models"
-      else
-        return std::numeric_limits<double>::max();
-    }
-
-
-
-    template <int dim>
-    void
-    ContinentalGeotherm<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Continental geotherm");
-        {
-          prm.declare_entry ("Layer thicknesses", "30000.",
-                             Patterns::List(Patterns::Double(0.)),
-                             "List of the 3 thicknesses of the lithospheric layers "
-                             "'upper\\_crust', 'lower\\_crust' and 'mantle\\_lithosphere'. "
-                             "If only one thickness is given, then the same thickness is used "
-                             "for all layers. Units: \\si{meter}.");
-          prm.declare_entry ("Surface temperature", "273.15",
-                             Patterns::Double (0.),
-                             "The value of the surface temperature. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Lithosphere-Asthenosphere boundary isotherm", "1673.15",
-                             Patterns::Double (0.),
-                             "The value of the isotherm that is assumed at the Lithosphere-"
-                             "Asthenosphere boundary. Units: \\si{\\kelvin}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ContinentalGeotherm<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      unsigned int n_fields = 0;
-      prm.enter_subsection ("Compositional fields");
-      {
-        n_fields = prm.get_integer ("Number of fields");
-      }
-      prm.leave_subsection();
-
-
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Continental geotherm");
-        {
-          LAB_isotherm = prm.get_double ("Lithosphere-Asthenosphere boundary isotherm");
-          T0 = prm.get_double ("Surface temperature");
-          thicknesses = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Layer thicknesses"))),
-                                                                3,
-                                                                "Layer thicknesses");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-
-      // Retrieve the indices of the fields that represent the lithospheric layers.
-      AssertThrow(this->introspection().compositional_name_exists("upper_crust"),ExcMessage("We need a compositional field called 'upper_crust' representing the upper crust."));
-      AssertThrow(this->introspection().compositional_name_exists("lower_crust"),ExcMessage("We need a compositional field called 'lower_crust' representing the lower crust."));
-      AssertThrow(this->introspection().compositional_name_exists("lithospheric_mantle"),ExcMessage("We need a compositional field called 'lithospheric_mantle' representing the lithospheric part of the mantle."));
-
-      // For now, we assume a 3-layer system with an upper crust, lower crust and lithospheric mantle
-      const unsigned int id_upper_crust = this->introspection().compositional_index_for_name("upper_crust");
-      const unsigned int id_lower_crust = this->introspection().compositional_index_for_name("lower_crust");
-      const unsigned int id_lithospheric_mantle = this->introspection().compositional_index_for_name("lithospheric_mantle");
-
-      // Retrieve other material properties set in different sections such that there
-      // is no need to set them twice.
-
-      prm.enter_subsection("Heating model");
-      {
-        prm.enter_subsection("Compositional heating");
-        {
-          // The heating model compositional heating prefixes an entry for the background material
-          const std::vector<double> temp_heat_productivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Compositional heating values"))),
-                                                               n_fields+1,
-                                                               "Compositional heating values");
-          // This sets the heat productivity in W/m3 units
-          heat_productivities.push_back(temp_heat_productivities[id_upper_crust+1]);
-          heat_productivities.push_back(temp_heat_productivities[id_lower_crust+1]);
-          heat_productivities.push_back(temp_heat_productivities[id_lithospheric_mantle+1]);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Visco Plastic");
-        {
-          // The material model viscoplastic prefixes an entry for the background material, hence n_fields+1
-          const std::vector<double> temp_densities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Densities"))),
-                                                     n_fields+1,
-                                                     "Densities");
-          const std::vector<double> temp_thermal_diffusivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal diffusivities"))),
-                                                                 n_fields+1,
-                                                                 "Thermal diffusivities");
-          const std::vector<double> temp_heat_capacities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Heat capacities"))),
-                                                           n_fields+1,
-                                                           "Heat capacities");
-
-          // The material model viscoplastic prefixes an entry for the background material, hence id+1
-          densities.push_back(temp_densities[id_upper_crust+1]);
-          densities.push_back(temp_densities[id_lower_crust+1]);
-          densities.push_back(temp_densities[id_lithospheric_mantle+1]);
-
-          // Thermal diffusivity kappa = k/(rho*cp), so thermal conductivity k = kappa*rho*cp.
-          // The densities are already in the right order, so we don't need to use the compositional
-          // field ids.
-          conductivities.push_back(temp_thermal_diffusivities[id_upper_crust+1] * densities[0] * temp_heat_capacities[id_upper_crust+1]);
-          conductivities.push_back(temp_thermal_diffusivities[id_lower_crust+1] * densities[1] * temp_heat_capacities[id_lower_crust+1]);
-          conductivities.push_back(temp_thermal_diffusivities[id_lithospheric_mantle+1] * densities[2] * temp_heat_capacities[id_lithospheric_mantle+1]);
-
-          // To obtain the radioactive heating rate in W/kg, we divide the volumetric heating rate by density
-          AssertThrow(heat_productivities.size() == 3 && densities.size() == 3 && conductivities.size() == 3,
-                      ExcMessage("The entries for density, conductivity and heat production do not match with the expected number of layers (3)."));
-
-          for (unsigned int i = 0; i<3; ++i)
-            heat_productivities[i] /= densities[i];
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-
-
-}
-
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(ContinentalGeotherm,
-                                              "continental geotherm",
-                                              "This is a temperature initial condition that "
-                                              "computes a continental geotherm based on the solution of the "
-                                              "steady-state conductive equation $k\\frac{d^2 T}{dy^2}+\\rho H = 0$ "
-                                              "as described in e.g. Turcotte and Schubert, "
-                                              "Ch. 4.6, or Chapman (1986). As boundary conditions, we take the surface temperature and "
-                                              "the temperature of the Lithosphere-Asthenosphere Boundary (LAB). "
-                                              "\n"
-                                              "The geotherm is computed for a homogeneous lithosphere "
-                                              "composed of an upper crust, lower crust and mantle layer. "
-                                              "The crustal layers are assumed to have a constant radioactive heating, "
-                                              "and all layers are assumed to have a constant thermal conductivity. "
-                                              "Layer thicknesses, surface temperature and LAB temperature "
-                                              "should be specified by the user. "
-                                              "For consistency, the density, heat production and thermal "
-                                              "conductivity of each layer are read from the visco plastic material model "
-                                              "and the compositional heating model. "
-                                              "\n"
-                                              "For any depths below the depth of the LAB, a unrealistically high "
-                                              "temperature is returned, such that this plugin can be combined with "
-                                              "another temperature plugin through the 'minimum' operator. "
-                                              "\n"
-                                              "Note that the current implementation only works for a 3-layer lithosphere, "
-                                              "even though in principle the heat conduction equation can be solved "
-                                              "for any number of layers. The naming of the compositional fields "
-                                              "that represent the layers is also very specific, namely `upper\\_crust', "
-                                              "`lower\\_crust', and `lithospheric\\_mantle'. "
-                                              "\n"
-                                              "Make sure the top and bottom temperatures of the lithosphere "
-                                              "agree with temperatures set in for example the temperature "
-                                              "boundary conditions.")
-  }
-}
diff --git a/source/initial_temperature/function.cc.bak b/source/initial_temperature/function.cc.bak
deleted file mode 100644
index a02205ca056..00000000000
--- a/source/initial_temperature/function.cc.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/function.h>
-#include <aspect/utilities.h>
-#include <aspect/global.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <iostream>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    Function<dim>::Function ()
-      :
-      function (1)
-    {}
-
-    template <int dim>
-    double
-    Function<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      const Utilities::NaturalCoordinate<dim> point =
-        this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system);
-
-      return function.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
-    }
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Function");
-        {
-          /**
-           * Choose the coordinates to evaluate the maximum refinement level
-           * function. The function can be declared in dependence of depth,
-           * cartesian coordinates or spherical coordinates. Note that the order
-           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
-           * this allows for dimension independent expressions.
-           */
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle. `depth' "
-                             "will create a function, in which only the first "
-                             "parameter is non-zero, which is interpreted to "
-                             "be the depth of the point.");
-
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Function");
-        {
-          coordinate_system = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-        }
-
-        try
-          {
-            function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Initial temperature model.Function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(Function,
-                                              "function",
-                                              "Specify the initial temperature in terms of an "
-                                              "explicit formula. The format of these "
-                                              "functions follows the syntax understood by the "
-                                              "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-  }
-}
diff --git a/source/initial_temperature/harmonic_perturbation.cc.bak b/source/initial_temperature/harmonic_perturbation.cc.bak
deleted file mode 100644
index ee78cf82bfe..00000000000
--- a/source/initial_temperature/harmonic_perturbation.cc.bak
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/harmonic_perturbation.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    double
-    HarmonicPerturbation<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-
-      // use either the user-input reference temperature as background temperature
-      // (incompressible model) or the adiabatic temperature profile (compressible model)
-      const double background_temperature = this->include_adiabatic_heating() ?
-                                            this->get_adiabatic_conditions().temperature(position) :
-                                            reference_temperature;
-
-      // s = fraction of the way from
-      // the inner to the outer
-      // boundary; 0<=s<=1
-      const double s = this->get_geometry_model().depth(position) / this->get_geometry_model().maximal_depth();
-
-      const double depth_perturbation = std::sin(vertical_wave_number*s*numbers::PI);
-
-
-      double lateral_perturbation = 0.0;
-
-      if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::SphericalShell<dim> &spherical_geometry_model =
-            Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
-
-          // In case of spherical shell calculate spherical coordinates
-          const std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
-
-          if (dim==2)
-            {
-              // Use a sine as lateral perturbation that is scaled to the opening angle of the geometry.
-              // This way the perturbation is always 0 at the model boundaries.
-              const double opening_angle = spherical_geometry_model.opening_angle() * constants::degree_to_radians;
-              lateral_perturbation = std::sin(lateral_wave_number_1*scoord[1]*numbers::PI/opening_angle);
-            }
-
-          else if (dim==3)
-            {
-              // Spherical harmonics are only defined for order <= degree
-              // and degree >= 0. Verify that it is indeed.
-              Assert ( std::abs(lateral_wave_number_2) <= lateral_wave_number_1,
-                       ExcMessage ("Spherical harmonics can only be computed for "
-                                   "order <= degree."));
-              Assert ( lateral_wave_number_1 >= 0,
-                       ExcMessage ("Spherical harmonics can only be computed for "
-                                   "degree >= 0."));
-              // use a spherical harmonic function as lateral perturbation
-              std::pair<double,double> sph_harm_vals = Utilities::real_spherical_harmonic( lateral_wave_number_1, lateral_wave_number_2, scoord[2], scoord[1] );
-              // For historical reasons, this initial conditions module used an unnormalized real spherical harmonic.
-              // Here we denormalize the return value of real_spherical_harmonic to keep the original behavior.
-              lateral_perturbation = sph_harm_vals.first / ( lateral_wave_number_2 == 0 ? 1.0 : std::sqrt(2.) );
-            }
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::Chunk<dim> &chunk_geometry_model =
-            Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>> (this->get_geometry_model());
-
-          AssertThrow (dim == 2,
-                       ExcMessage ("Harmonic perturbation only implemented in 2d for chunk geometry"));
-
-          // In case of chunk calculate spherical coordinates
-          const std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
-
-          // Use a sine as lateral perturbation that is scaled to the opening angle of the geometry.
-          // This way the perturbation is always 0 at the model boundaries.
-          const double opening_angle = chunk_geometry_model.longitude_range(); // in radians
-          const double start_angle = chunk_geometry_model.west_longitude(); // in radians
-          lateral_perturbation = std::sin((lateral_wave_number_1*(scoord[1]-start_angle))*numbers::PI/opening_angle);
-
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::Box<dim> &box_geometry_model =
-            Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
-
-          // In case of Box model use a sine as lateral perturbation
-          // that is scaled to the extent of the geometry.
-          // This way the perturbation is always 0 at the model borders.
-          const Point<dim> extent = box_geometry_model.get_extents();
-
-          if (dim==2)
-            {
-              lateral_perturbation = std::sin(lateral_wave_number_1*position(0)*numbers::PI/extent(0));
-            }
-          else if (dim==3)
-            {
-              lateral_perturbation = std::sin(lateral_wave_number_1*position(0)*numbers::PI/extent(0))
-                                     * std::sin(lateral_wave_number_2*position(1)*numbers::PI/extent(1));
-            }
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::TwoMergedBoxes<dim> &two_merged_boxes_geometry_model =
-            Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model());
-
-          // In case of Box model use a sine as lateral perturbation
-          // that is scaled to the extent of the geometry.
-          // This way the perturbation is always 0 at the model borders.
-          const Point<dim> extent = two_merged_boxes_geometry_model.get_extents();
-
-          if (dim==2)
-            {
-              lateral_perturbation = std::sin(lateral_wave_number_1*position(0)*numbers::PI/extent(0));
-            }
-          else if (dim==3)
-            {
-              lateral_perturbation = std::sin(lateral_wave_number_1*position(0)*numbers::PI/extent(0))
-                                     * std::sin(lateral_wave_number_2*position(1)*numbers::PI/extent(1));
-            }
-        }
-      else
-        AssertThrow (false,
-                     ExcMessage ("Not a valid geometry model for the initial conditions model "
-                                 "harmonic perturbation."));
-
-      return background_temperature + magnitude * depth_perturbation * lateral_perturbation;
-    }
-
-    template <int dim>
-    void
-    HarmonicPerturbation<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Harmonic perturbation");
-        {
-          prm.declare_entry ("Vertical wave number", "1",
-                             Patterns::Integer (),
-                             "Doubled radial wave number of the harmonic perturbation. "
-                             " One equals half of a sine period over the model domain. "
-                             " This allows for single up-/downswings. Negative numbers "
-                             " reverse the sign of the perturbation.");
-          prm.declare_entry ("Lateral wave number one", "3",
-                             Patterns::Integer (),
-                             "Doubled first lateral wave number of the harmonic perturbation. "
-                             "Equals the spherical harmonic degree in 3d spherical shells. "
-                             "In all other cases one equals half of a sine period over "
-                             "the model domain. This allows for single up-/downswings. "
-                             "Negative numbers reverse the sign of the perturbation but are "
-                             "not allowed for the spherical harmonic case.");
-          prm.declare_entry ("Lateral wave number two", "2",
-                             Patterns::Integer (),
-                             "Doubled second lateral wave number of the harmonic perturbation. "
-                             "Equals the spherical harmonic order in 3d spherical shells. "
-                             "In all other cases one equals half of a sine period over "
-                             "the model domain. This allows for single up-/downswings. "
-                             "Negative numbers reverse the sign of the perturbation.");
-          prm.declare_entry ("Magnitude", "1.0",
-                             Patterns::Double (0.),
-                             "The magnitude of the Harmonic perturbation.");
-          prm.declare_entry ("Reference temperature", "1600.0",
-                             Patterns::Double (0.),
-                             "The reference temperature that is perturbed by the "
-                             "harmonic function. Only used in incompressible models.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    HarmonicPerturbation<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Harmonic perturbation");
-        {
-          vertical_wave_number = prm.get_integer ("Vertical wave number");
-          lateral_wave_number_1 = prm.get_integer ("Lateral wave number one");
-          lateral_wave_number_2 = prm.get_integer ("Lateral wave number two");
-          magnitude = prm.get_double ("Magnitude");
-          reference_temperature = prm.get_double ("Reference temperature");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(HarmonicPerturbation,
-                                              "harmonic perturbation",
-                                              "An initial temperature field in which the temperature "
-                                              "is perturbed following a harmonic function (spherical "
-                                              "harmonic or sine depending on geometry and dimension) "
-                                              "in lateral and radial direction from an otherwise "
-                                              "constant temperature (incompressible model) or adiabatic "
-                                              "reference profile (compressible model).")
-  }
-}
diff --git a/source/initial_temperature/interface.cc.bak b/source/initial_temperature/interface.cc.bak
deleted file mode 100644
index c747b7197b8..00000000000
--- a/source/initial_temperature/interface.cc.bak
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/initial_temperature/interface.h>
-
-#include <deal.II/base/exceptions.h>
-#include <tuple>
-
-#include <list>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    // ------------------------------ Manager -----------------------------
-    // -------------------------------- Deal with registering initial_temperature models and automating
-    // -------------------------------- their setup and selection at run time
-
-    template <int dim>
-    Manager<dim>::~Manager()
-      = default;
-
-
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_initial_temperature (const std::string &name,
-                                                const std::string &description,
-                                                void (*declare_parameters_function) (ParameterHandler &),
-                                                std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // find out which plugins are requested and the various other
-      // parameters we declare here
-      prm.enter_subsection ("Initial temperature model");
-      {
-        model_names
-          = Utilities::split_string_list(prm.get("List of model names"));
-
-        AssertThrow(Utilities::has_unique_entries(model_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Initial temperature model/List of model names' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-
-        const std::string model_name = prm.get ("Model name");
-
-        AssertThrow (model_name == "unspecified" || model_names.size() == 0,
-                     ExcMessage ("The parameter 'Model name' is only used for reasons"
-                                 "of backwards compatibility and can not be used together with "
-                                 "the new functionality 'List of model names'. Please add your "
-                                 "initial temperature model to the list instead."));
-
-        if (!(model_name == "unspecified"))
-          model_names.push_back(model_name);
-
-        // create operator list
-        const std::vector<std::string> model_operator_names =
-          Utilities::possibly_extend_from_1_to_N (Utilities::split_string_list(prm.get("List of model operators")),
-                                                  model_names.size(),
-                                                  "List of model operators");
-        model_operators = Utilities::create_model_operator_list(model_operator_names);
-      }
-      prm.leave_subsection ();
-
-      // go through the list, create objects and let them parse
-      // their own parameters
-      for (auto &model_name : model_names)
-        {
-          // create initial temperature objects
-          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
-                                          (std::get<dim>(registered_plugins)
-                                           .create_plugin (model_name,
-                                                           "Initial temperature model::Model names")));
-
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
-            sim->initialize_simulator (this->get_simulator());
-
-          this->plugin_objects.back()->parse_parameters (prm);
-          this->plugin_objects.back()->initialize ();
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::update()
-    {
-      for (auto &initial_temperature_object : this->plugin_objects)
-        initial_temperature_object->update();
-    }
-
-
-
-    template <int dim>
-    double
-    Manager<dim>::initial_temperature (const Point<dim> &position) const
-    {
-      double temperature = 0.0;
-      int i = 0;
-
-      for (const auto &initial_temperature_object : this->plugin_objects)
-        {
-          temperature = model_operators[i](temperature,
-                                           initial_temperature_object->initial_temperature(position));
-          ++i;
-        }
-      return temperature;
-    }
-
-
-    template <int dim>
-    const std::vector<std::string> &
-    Manager<dim>::get_active_initial_temperature_names () const
-    {
-      return model_names;
-    }
-
-
-    template <int dim>
-    const std::list<std::unique_ptr<Interface<dim>>> &
-    Manager<dim>::get_active_initial_temperature_conditions () const
-    {
-      return this->plugin_objects;
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // declare the entry in the parameter file
-      prm.enter_subsection ("Initial temperature model");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry("List of model names",
-                          "",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma-separated list of initial temperature models that "
-                          "will be used to initialize the temperature. "
-                          "These plugins are loaded in the order given, and modify the "
-                          "existing temperature field via the operators listed "
-                          "in 'List of model operators'.\n\n"
-                          "The following initial temperature models are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-
-        prm.declare_entry("List of model operators", "add",
-                          Patterns::MultipleSelection(Utilities::get_model_operator_options()),
-                          "A comma-separated list of operators that "
-                          "will be used to append the listed temperature models onto "
-                          "the previous models. If only one operator is given, "
-                          "the same operator is applied to all models.");
-
-        prm.declare_entry ("Model name", "unspecified",
-                           Patterns::Selection (pattern_of_names+"|unspecified"),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string()
-                           + "\n\n" +
-                           "\\textbf{Warning}: This parameter provides an old and "
-                           "deprecated way of specifying "
-                           "initial temperature models and shouldn't be used. "
-                           "Please use 'List of model names' instead.");
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ()
-    {
-      return std::get<dim>(registered_plugins).get_pattern_of_names ();
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Initial temperature interface",
-                                                            out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<InitialTemperature::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<InitialTemperature::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<InitialTemperature::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<InitialTemperature::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace InitialTemperature
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>; \
-  \
-  template \
-  std::string \
-  get_valid_model_names_pattern<dim> ();
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/initial_temperature/lithosphere_mask.cc.bak b/source/initial_temperature/lithosphere_mask.cc.bak
deleted file mode 100644
index e1101048d37..00000000000
--- a/source/initial_temperature/lithosphere_mask.cc.bak
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/initial_temperature/lithosphere_mask.h>
-#include <aspect/utilities.h>
-#include <limits>
-#include <aspect/geometry_model/interface.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    namespace LABDepth
-    {
-      template <int dim>
-      LABDepthLookup<dim>::LABDepthLookup ()
-        :
-        lab_depths(1, 1.0)
-      {}
-
-
-
-      template <int dim>
-      void
-      LABDepthLookup<dim>::initialize ()
-      {
-        if (LAB_depth_source == File)
-          {
-            const std::string filename = data_directory+LAB_file_name;
-            this->get_pcout() << "   Loading Ascii data lookup file " << filename << '.' << std::endl;
-
-            lab_depths.load_file(filename,this->get_mpi_communicator());
-          }
-      }
-
-
-
-      template <int dim>
-      double
-      LABDepthLookup<dim>::get_lab_depth (const Point<dim> &position) const
-      {
-        if (LAB_depth_source == File)
-          {
-            //Get spherical coordinates for model
-            Assert (dim == 3, ExcNotImplemented());
-            std::array<double,dim> scoord      = Utilities::Coordinates::cartesian_to_spherical_coordinates<dim>(position);
-            const double phi = scoord[1];
-            const double theta = scoord[2 % dim]; // work-around to compile without warnings for dim==2
-            const Point<2> phi_theta (phi, theta);
-
-            //Get lab depth for specific phi and theta
-            const double lab_depth = lab_depths.get_data(phi_theta,0);
-            return lab_depth;
-          }
-
-        else if (LAB_depth_source == Value)
-          {
-            return max_depth;
-          }
-        else
-          {
-            Assert( false, ExcMessage("Invalid method for depth specification method") );
-            return 0.0;
-          }
-
-        return 0.0;
-      }
-
-
-
-      template <int dim>
-      void
-      LABDepthLookup<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Depth specification method", "Value",
-                           Patterns::Selection("File|Value"),
-                           "Method that is used to specify the depth of the lithosphere-asthenosphere boundary.");
-        prm.declare_entry ("Maximum lithosphere depth", "200000.0",
-                           Patterns::Double (0.),"Units: \\si{\\meter}."
-                           "The maximum depth of the lithosphere. The model will be "
-                           "NaNs below this depth.");
-        prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/initial-temperature/lithosphere-mask/",
-                           Patterns::DirectoryName (),
-                           "The path to the LAB depth data file");
-        prm.declare_entry ("LAB depth filename",
-                           "LAB_CAM2016.txt",
-                           Patterns::FileName (),
-                           "File from which the lithosphere-asthenosphere boundary depth data is read.");
-      }
-
-      template <int dim>
-      void
-      LABDepthLookup<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        if ( prm.get("Depth specification method") == "File" )
-          {
-            LAB_depth_source = File;
-            data_directory = Utilities::expand_ASPECT_SOURCE_DIR (prm.get("Data directory"));
-            LAB_file_name = prm.get("LAB depth filename");
-          }
-        else if ( prm.get("Depth specification method") == "Value" )
-          {
-            LAB_depth_source = Value;
-            max_depth = prm.get_double ("Maximum lithosphere depth");
-          }
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    LithosphereMask<dim>::initialize ()
-    {
-      lab_depth_lookup.initialize();
-    }
-
-
-
-    template <int dim>
-    double
-    LithosphereMask<dim>::initial_temperature (const Point<dim> &position) const
-    {
-      double temperature;
-      const double depth = this->SimulatorAccess<dim>::get_geometry_model().depth(position);
-      const double lab_depth = lab_depth_lookup.get_lab_depth(position);
-
-      if (depth <= lab_depth)
-        temperature = lithosphere_temperature;
-      else
-        temperature = std::numeric_limits<double>::quiet_NaN();
-
-      return temperature;
-    }
-
-    template <int dim>
-    void
-    LithosphereMask<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection ("Lithosphere Mask");
-        {
-          LABDepth::LABDepthLookup<dim>::declare_parameters(prm);
-
-          prm.declare_entry ("Lithosphere temperature", "1600.",
-                             Patterns::Double (0.),
-                             "The initial temperature within lithosphere, applied above"
-                             "the maximum lithosphere depth.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    LithosphereMask<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      AssertThrow (dim == 3,
-                   ExcMessage ("The 'Lithosphere mask' model for the initial "
-                               "temperature is only available for 3d computations."));
-
-      prm.enter_subsection("Initial temperature model");
-      {
-        prm.enter_subsection ("Lithosphere Mask");
-        {
-          lab_depth_lookup.initialize_simulator(this->get_simulator());
-          lab_depth_lookup.parse_parameters(prm);
-          lithosphere_temperature = prm.get_double ("Lithosphere temperature");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template class LABDepth::LABDepthLookup<2>;
-    template class LABDepth::LABDepthLookup<3>;
-
-
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(LithosphereMask,
-                                              "lithosphere mask",
-                                              "Implementation of a model in which the initial "
-                                              "temperature is set to a specified lithosphere temperature above the "
-                                              "lithosphere-asthenosphere boundary (specified by an ascii file "
-                                              "or maximum lithosphere depth value). Below this the initial temperature is set as "
-                                              "NaN.  Note the required format of the input data file: The first lines may "
-                                              "contain any number of comments if they begin with '#', but one of these lines "
-                                              "needs to contain the number of grid points in each dimension as for example "
-                                              "'# POINTS: 3 3'. For a spherical model, the order of the data columns has to be "
-                                              "'phi', 'theta', 'depth (m)', where phi is the azimuth angle and theta is the "
-                                              "polar angle measured positive from the north pole. This plug-in can be combined "
-                                              "with another using the 'replace if valid' operator. ")
-  }
-}
diff --git a/source/initial_temperature/patch_on_S40RTS.cc.bak b/source/initial_temperature/patch_on_S40RTS.cc.bak
deleted file mode 100644
index 185cc74d950..00000000000
--- a/source/initial_temperature/patch_on_S40RTS.cc.bak
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/initial_temperature/patch_on_S40RTS.h>
-#include <aspect/utilities.h>
-
-#include <boost/lexical_cast.hpp>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    PatchOnS40RTS<dim>::PatchOnS40RTS ()
-      = default;
-
-
-    template <int dim>
-    void
-    PatchOnS40RTS<dim>::initialize ()
-    {
-      this->Utilities::AsciiDataInitial<dim>::initialize(1);
-    }
-
-
-    template <int dim>
-    double
-    PatchOnS40RTS<dim>::
-    ascii_grid_vs (const Point<dim> &position) const
-    {
-      const double vs_perturbation = Utilities::AsciiDataInitial<dim>::get_data_component(position,0);
-      return vs_perturbation;
-    }
-
-
-    template <int dim>
-    double
-    PatchOnS40RTS<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      const double depth = this->get_geometry_model().depth(position);
-
-      double vs_perturbation;
-      if (depth <= max_grid_depth - smoothing_length_scale)
-        {
-          vs_perturbation = ascii_grid_vs(position);
-        }
-      //add smoothing between the two models
-      else if (depth > max_grid_depth - smoothing_length_scale && depth < max_grid_depth)
-        {
-          const double scale_factor = (depth-(max_grid_depth-smoothing_length_scale))/smoothing_length_scale;
-          vs_perturbation = s40rts.get_Vs(position)*(scale_factor) + ascii_grid_vs(position)*(1.0-scale_factor);
-        }
-      else
-        {
-          vs_perturbation = s40rts.get_Vs(position);
-        }
-
-      // use either the user-input reference temperature as background temperature
-      // (incompressible model) or the adiabatic temperature profile (compressible model)
-      const double background_temperature = this->get_material_model().is_compressible() ?
-                                            this->get_adiabatic_conditions().temperature(position) :
-                                            s40rts.reference_temperature;
-
-      // get the Vs to density conversion
-      double vs_to_density = 0.0;
-      if (s40rts.vs_to_density_method == s40rts.file)
-        vs_to_density = s40rts.profile.get_data_component(Point<1>(depth), s40rts.vs_to_density_index);
-      else if (s40rts.vs_to_density_method == s40rts.constant)
-        vs_to_density = s40rts.vs_to_density_constant;
-      else
-        // we shouldn't get here but instead should already have been
-        // kicked out when declaring the parameter, as the pattern won't match ("file|constant")
-        Assert(false, ExcMessage("Unknown method for vs to density scaling."));
-
-      // scale the perturbation in seismic velocity into a density perturbation
-      // vs_to_density is read in from input file
-      const double density_perturbation = vs_to_density * vs_perturbation;
-      double temperature_perturbation;
-      if (depth > no_perturbation_depth_patch)
-        // scale the density perturbation into a temperature perturbation
-        temperature_perturbation =  -1./s40rts.thermal_alpha * density_perturbation;
-      else
-        // set heterogeneity to zero down to a specified depth
-        temperature_perturbation = 0.0;
-
-      return background_temperature + temperature_perturbation;
-    }
-
-    template <int dim>
-    void
-    PatchOnS40RTS<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection ("Patch on S40RTS");
-        {
-          prm.declare_entry ("Maximum grid depth", "700000.0",
-                             Patterns::Double (0.),
-                             "The maximum depth of the Vs ascii grid. The model will read in  "
-                             "Vs from S40RTS below this depth.");
-          prm.declare_entry ("Smoothing length scale", "200000.0",
-                             Patterns::Double (0.),
-                             "The depth range (above maximum grid depth) over which to smooth. "
-                             "The boundary is smoothed using a depth weighted combination of Vs "
-                             "values from the ascii grid and S40RTS at each point in the region of smoothing.");
-          prm.declare_entry ("Remove temperature heterogeneity down to specified depth",
-                             boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
-                             Patterns::Double (),
-                             "This will set the heterogeneity prescribed by the Vs ascii grid and S40RTS to zero "
-                             "down to the specified depth (in meters). Note that your resolution has "
-                             "to be adequate to capture this cutoff. For example if you specify a depth "
-                             "of 660km, but your closest spherical depth layers are only at 500km and "
-                             "750km (due to a coarse resolution) it will only zero out heterogeneities "
-                             "down to 500km. Similar caution has to be taken when using adaptive meshing.");
-
-          Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                            "$ASPECT_SOURCE_DIR/data/initial-temperature/patch-on-S40RTS/test/",
-                                                            "upper_shell_3d.txt");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    PatchOnS40RTS<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Initial temperature model");
-      {
-        prm.enter_subsection ("Patch on S40RTS");
-        {
-          max_grid_depth           = prm.get_double ("Maximum grid depth");
-          smoothing_length_scale   = prm.get_double ("Smoothing length scale");
-          no_perturbation_depth_patch   = prm.get_double ("Remove temperature heterogeneity down to specified depth");
-
-          Utilities::AsciiDataBase<dim>::parse_parameters(prm);
-
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      s40rts.initialize_simulator (this->get_simulator());
-      s40rts.parse_parameters(prm);
-      s40rts.initialize();
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(PatchOnS40RTS,
-                                              "patch on S40RTS",
-                                              "Implementation of a model in which the initial "
-                                              "temperature is derived from a file containing shear wave velocity perturbations "
-                                              "in ascii format (e.g. a high resolution upper mantle tomography) "
-                                              "combined with S40RTS. Note the required format of the "
-                                              "input ascii input data: The first lines may contain any number of comments "
-                                              "if they begin with '#', but one of these lines needs to "
-                                              "contain the number of grid points in each dimension as "
-                                              "for example '# POINTS: 3 3 3'. "
-                                              "The order of the data columns has to be "
-                                              " `x', `y', `z', 'Vs Perturbation' in a 3d model, which means that "
-                                              "there has to be a single column "
-                                              "containing the temperature. "
-                                              "Note that the data in the input "
-                                              "files need to be sorted in a specific order: "
-                                              "the first coordinate needs to ascend first, "
-                                              "followed by the second and the third at last in order to "
-                                              "assign the correct data to the prescribed coordinates. "
-                                              "In the spherical model data will be handled as Cartesian, "
-                                              "however, `x' will be replaced by "
-                                              "the radial distance of the point to the bottom of the model, "
-                                              "`y' by the azimuth angle and `z' by the polar angle measured "
-                                              "positive from the north pole. The grid will be assumed to be "
-                                              "a latitude-longitude grid. Note that the order "
-                                              "of spherical coordinates is `r', `phi', `theta' "
-                                              "and not `r', `theta', `phi', since this allows "
-                                              "for dimension independent expressions. "
-                                              "See S40RTS documentation for details on input parameters in the "
-                                              "S40RTS perturbation subsection. "
-                                              "The boundary between the two tomography models is smoothed using a depth weighted "
-                                              "combination of Vs values within the region of smoothing. ")
-  }
-}
diff --git a/source/initial_temperature/prescribed_temperature.cc.bak b/source/initial_temperature/prescribed_temperature.cc.bak
deleted file mode 100644
index 7b5e5149a88..00000000000
--- a/source/initial_temperature/prescribed_temperature.cc.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/prescribed_temperature.h>
-
-#include <aspect/initial_composition/interface.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    void
-    PrescribedTemperature<dim>::initialize()
-    {
-      // Make sure we keep track of the initial composition manager and
-      // that it continues to live beyond the time when the simulator
-      // class releases its pointer to it.
-      initial_composition = this->get_initial_composition_manager_pointer();
-    }
-
-
-    template <int dim>
-    double
-    PrescribedTemperature<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // Evaluate the material model to get the temperature
-      MaterialModel::MaterialModelInputs<dim> in(1, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
-
-      in.position[0] = position;
-      in.temperature[0] = this->get_adiabatic_conditions().temperature(position);
-      in.pressure[0] = this->get_adiabatic_conditions().pressure(position);
-      in.velocity[0] = Tensor<1,dim> ();
-
-      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-        in.composition[0][c] = initial_composition->initial_composition(position, c);
-
-      in.strain_rate.resize(0);
-
-      this->get_material_model().create_additional_named_outputs(out);
-      this->get_material_model().evaluate(in, out);
-
-      // set up variable to interpolate prescribed field outputs onto temperature field
-      double temperature = in.temperature[0];
-      if (MaterialModel::PrescribedTemperatureOutputs<dim> *prescribed_temperature_out
-          = out.template get_additional_output<MaterialModel::PrescribedTemperatureOutputs<dim>>())
-        {
-          temperature = prescribed_temperature_out->prescribed_temperature_outputs[0];
-        }
-      else
-        AssertThrow (false,
-                     ExcMessage ("The material model needs to compute precribed temperature outputs, "
-                                 "otherwise the initial temperature can not be set to the prescribed "
-                                 "temperature."));
-
-      return temperature;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(PrescribedTemperature,
-                                              "prescribed temperature",
-                                              "This model fixes the initial temperature to the prescribed "
-                                              "temperature outputs computed by the material model. This only "
-                                              "works if the material model implements prescribed temperature "
-                                              "outputs.")
-  }
-}
diff --git a/source/initial_temperature/random_gaussian_perturbation.cc.bak b/source/initial_temperature/random_gaussian_perturbation.cc.bak
deleted file mode 100644
index 528caf247d3..00000000000
--- a/source/initial_temperature/random_gaussian_perturbation.cc.bak
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/random_gaussian_perturbation.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/simulator_access.h>
-
-#include <random>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    void
-    RandomGaussianPerturbation<dim>::initialize ()
-    {
-      // Get dimension of the model from the geometry model.
-      Point<dim> min_coordinates;
-      Point<dim> max_coordinates;
-
-      perturbation_centers.resize(n_perturbations);
-      perturbation_magnitudes.resize(n_perturbations);
-
-      if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::SphericalShell<dim> &spherical_geometry_model =
-            Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
-
-          for (unsigned int d=0; d<dim; ++d)
-            {
-              min_coordinates[d] = -spherical_geometry_model.outer_radius();
-              max_coordinates[d] = spherical_geometry_model.outer_radius();
-            }
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::Sphere<dim> &sphere_geometry_model =
-            Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>> (this->get_geometry_model());
-
-          for (unsigned int d=0; d<dim; ++d)
-            {
-              min_coordinates[d] = -sphere_geometry_model.radius();
-              max_coordinates[d] = sphere_geometry_model.radius();
-            }
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::Chunk<dim> &chunk_geometry_model =
-            Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>> (this->get_geometry_model());
-
-          for (unsigned int d=0; d<dim; ++d)
-            {
-              min_coordinates[d] = -chunk_geometry_model.outer_radius();
-              max_coordinates[d] = chunk_geometry_model.outer_radius();
-            }
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::Box<dim> &box_geometry_model =
-            Plugins::get_plugin_as_type<const GeometryModel::Box<dim>> (this->get_geometry_model());
-
-          min_coordinates = box_geometry_model.get_origin();
-          max_coordinates = min_coordinates + box_geometry_model.get_extents();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()))
-        {
-          const GeometryModel::TwoMergedBoxes<dim> &two_merged_boxes_geometry_model =
-            Plugins::get_plugin_as_type<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model());
-
-          min_coordinates = two_merged_boxes_geometry_model.get_origin();
-          max_coordinates = min_coordinates + two_merged_boxes_geometry_model.get_extents();
-        }
-      else
-        AssertThrow (false,
-                     ExcMessage ("Not a valid geometry model for the initial conditions model "
-                                 "'random Gaussian perturbation'."));
-
-      // Initialize random locations of perturbations and check they are in the model domain.
-      // Use a fixed number as seed for random generator.
-      // This is important if we run the code on more than 1 processor.
-      std::mt19937 generator(1);
-      std::uniform_real_distribution<double> random_location(0.0,1.0);
-      std::uniform_real_distribution<double> random_magnitude(-max_magnitude, max_magnitude);
-
-      for (unsigned int n=0; n<n_perturbations; ++n)
-        {
-          do
-            {
-              for (unsigned int d=0; d<dim; ++d)
-                perturbation_centers[n][d] = min_coordinates[d] + random_location(generator) * (max_coordinates[d] - min_coordinates[d]);
-            }
-          while (!this->get_geometry_model().point_is_in_domain(perturbation_centers[n]));
-
-          perturbation_magnitudes[n] = random_magnitude(generator);
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    RandomGaussianPerturbation<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      double temperature_perturbation = 0;
-      for (unsigned int n=0; n<n_perturbations; ++n)
-        {
-          const double distance_square = position.distance_square(perturbation_centers[n]);
-          const double exponent = distance_square / (2.*width*width);
-
-          temperature_perturbation += perturbation_magnitudes[n] * std::exp(-exponent);
-        }
-
-      return temperature_perturbation;
-    }
-
-
-
-    template <int dim>
-    void
-    RandomGaussianPerturbation<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Random Gaussian perturbation");
-        {
-          prm.declare_entry ("Number of perturbations", "100",
-                             Patterns::Integer (),
-                             "Total number of perturbations to be introduced into the model. "
-                             "Perturbations will be placed at random locations within the "
-                             "model domain.");
-          prm.declare_entry ("Maximum magnitude", "25.0",
-                             Patterns::Double (0.),
-                             "The maximum magnitude of the Gaussian perturbation. For each "
-                             "perturbation, a random magnitude between plus and minus the "
-                             "maximum magnitude will be chosen. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Width", "1000.0",
-                             Patterns::Double (0.),
-                             "The Gaussian RMS width of the perturbations. "
-                             "Units: \\si{\\meter}.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-
-    template <int dim>
-    void
-    RandomGaussianPerturbation<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Random Gaussian perturbation");
-        {
-          n_perturbations = prm.get_integer ("Number of perturbations");
-          max_magnitude = prm.get_double ("Maximum magnitude");
-          width = prm.get_double ("Width");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(RandomGaussianPerturbation,
-                                              "random Gaussian perturbation",
-                                              "An initial temperature field in which the temperature "
-                                              "is perturbed from a temperature of zero following a "
-                                              "given number of Gaussian perturbations placed randomly "
-                                              "throughout the model domain. The number, width, and "
-                                              "maximum magnitude of the perturbations can be chosen "
-                                              "as model parameters. "
-                                              "This plugin is meant to be used in combination with "
-                                              "another initial temperature model that determines the "
-                                              "background temperature (such as the 'function' or the "
-                                              "'adiabatic' plugin) using the 'add' operator to combine "
-                                              "them.")
-  }
-}
diff --git a/source/initial_temperature/spherical_shell.cc.bak b/source/initial_temperature/spherical_shell.cc.bak
deleted file mode 100644
index 4a43ef19b92..00000000000
--- a/source/initial_temperature/spherical_shell.cc.bak
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <deal.II/base/signaling_nan.h>
-#include <aspect/initial_temperature/spherical_shell.h>
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-#include <cstring>
-
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    double
-    SphericalHexagonalPerturbation<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // s = fraction of the way from the inner to the outer boundary; 0<=s<=1
-      const double s = this->get_geometry_model().depth(position)
-                       / this->get_geometry_model().maximal_depth();
-
-      /* now compute an angular variation of the linear temperature field by
-         stretching the variable s appropriately. note that the following
-         formula leaves the end points s=0 and s=1 fixed, but stretches the
-         region in between depending on the angle phi=atan2(x,y).
-
-         For a plot, see
-         http://www.wolframalpha.com/input/?i=plot+%28%282*sqrt%28x^2%2By^2%29-1%29%2B0.2*%282*sqrt%28x^2%2By^2%29-1%29*%281-%282*sqrt%28x^2%2By^2%29-1%29%29*sin%286*atan2%28x%2Cy%29%29%29%2C+x%3D-1+to+1%2C+y%3D-1+to+1
-      */
-      const double scale = ((dim==3)
-                            ?
-                            std::max(0.0,
-                                     std::cos(numbers::PI * std::fabs(position(2)/R1)))
-                            :
-                            1.0);
-      const double phi   = std::atan2(position(0),position(1));
-      const double s_mod = s
-                           +
-                           0.2 * s * (1-s) * std::sin(angular_mode*phi + (90 + 2*rotation_offset) * constants::degree_to_radians ) * scale;
-
-      // Check that a boundary temperature is prescribed
-      AssertThrow (this->has_boundary_temperature(),
-                   ExcMessage ("This initial condition can only be used if a boundary "
-                               "temperature is prescribed."));
-
-      return (this->get_boundary_temperature_manager().maximal_temperature()*(s_mod)
-              +
-              this->get_boundary_temperature_manager().minimal_temperature()*(1-s_mod));
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalHexagonalPerturbation<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Spherical hexagonal perturbation");
-        {
-
-          prm.declare_entry ("Angular mode", "6",
-                             Patterns::Integer (),
-                             "The number of convection cells with which to perturb the system.");
-
-          prm.declare_entry  ("Rotation offset", "-45.",
-                              Patterns::Double (),
-                              "Amount of clockwise rotation in degrees to apply to "
-                              "the perturbations. Default is set to -45 in order "
-                              "to provide backwards compatibility.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalHexagonalPerturbation<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Spherical hexagonal perturbation");
-        {
-          angular_mode = prm.get_integer ("Angular mode");
-          rotation_offset = prm.get_double  ("Rotation offset");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      // This initial condition only makes sense if the geometry is derived from
-      // a spherical model (i.e. a sphere, spherical shell or chunk)
-      if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()))
-        {
-          R1 = Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>>
-               (this->get_geometry_model()).radius();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()))
-        {
-          R1 = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
-               (this->get_geometry_model()).outer_radius();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()))
-        {
-          R1 = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
-               (this->get_geometry_model()).outer_radius();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()))
-        {
-          const auto &gm = Plugins::get_plugin_as_type<const GeometryModel::EllipsoidalChunk<dim>>
-                           (this->get_geometry_model());
-          // TODO
-          // If the eccentricity of the EllipsoidalChunk is non-zero, the radius can vary along a boundary,
-          // but the maximal depth is the same everywhere and we could calculate a representative pressure
-          // profile. However, it requires some extra logic with ellipsoidal
-          // coordinates, so for now we only allow eccentricity zero.
-          // Using the EllipsoidalChunk with eccentricity zero can still be useful,
-          // because the domain can be non-coordinate parallel.
-
-          AssertThrow(gm.get_eccentricity() == 0.0,
-                      ExcNotImplemented("This plugin cannot be used with a non-zero eccentricity. "));
-
-          R1 = gm.get_semi_major_axis_a();
-        }
-      else
-        {
-          Assert (false, ExcMessage ("This initial condition can only be used if the geometry "
-                                     "is a sphere, a spherical shell, a chunk or an "
-                                     "ellipsoidal chunk."));
-          R1 = numbers::signaling_nan<double>();
-        }
-    }
-
-
-
-    template <int dim>
-    SphericalGaussianPerturbation<dim>::
-    SphericalGaussianPerturbation()
-    {
-
-      // Note that the values we read in here have reasonable default values
-      geotherm.resize(4);
-      radial_position.resize(4);
-      geotherm[0] = 1e0;
-      geotherm[1] = 0.75057142857142856;
-      geotherm[2] = 0.32199999999999995;
-      geotherm[3] = 0.0;
-      radial_position[0] =  0e0-1e-3;
-      radial_position[1] =  0.16666666666666666;
-      radial_position[2] =  0.83333333333333337;
-      radial_position[3] =  1e0+1e-3;
-
-
-    }
-
-    template <int dim>
-    double
-    SphericalGaussianPerturbation<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      // Check that a boundary temperature is prescribed
-      AssertThrow (this->has_boundary_temperature(),
-                   ExcMessage ("This initial condition can only be used if a boundary "
-                               "temperature is prescribed."));
-
-      const double dT = this->get_boundary_temperature_manager().maximal_temperature()
-                        - this->get_boundary_temperature_manager().minimal_temperature();
-      const double T0 = this->get_boundary_temperature_manager().maximal_temperature()/dT;
-      const double T1 = this->get_boundary_temperature_manager().minimal_temperature()/dT;
-      const double h = R1-R0;
-
-      // s = fraction of the way from
-      // the inner to the outer
-      // boundary; 0<=s<=1
-      const double r = position.norm();
-      const double s = (r-R0)/h;
-
-      const double scale=R1/(R1 - R0);
-      const float eps = 1e-4;
-
-      int indx = -1;
-      for (unsigned int i=0; i<3; ++i)
-        {
-          if ((radial_position[i] - s) < eps && (radial_position[i+1] - s) > eps)
-            {
-              indx = i;
-              break;
-            }
-        }
-      Assert (indx >= 0, ExcInternalError());
-      Assert (indx < 3,  ExcInternalError());
-      int indx1 = indx + 1;
-      const float dx = radial_position[indx1] - radial_position[indx];
-      const float dy = geotherm[indx1] - geotherm[indx];
-
-      const double InterpolVal = (( dx > 0.5*eps)
-                                  ?
-                                  // linear interpolation
-                                  std::max(geotherm[3],geotherm[indx] + (s-radial_position[indx]) * (dy/dx))
-                                  :
-                                  // evaluate the point in the discontinuity
-                                  0.5*( geotherm[indx] + geotherm[indx1] ));
-
-      const double x = (scale - this->depth)*std::cos(angle);
-      const double y = (scale - this->depth)*std::sin(angle);
-      const double Perturbation = (sign * amplitude *
-                                   std::exp( -( std::pow((position(0)*scale/R1-x),2)
-                                                +
-                                                std::pow((position(1)*scale/R1-y),2) ) / sigma));
-
-      if (r > R1 - 1e-6*R1 || InterpolVal + Perturbation < T1)
-        return T1*dT;
-      else if (r < R0 + 1e-6*R0 || InterpolVal + Perturbation > T0 )
-        return T0*dT;
-      else
-        return (InterpolVal + Perturbation)*dT;
-    }
-
-
-
-    template <int dim>
-    void
-    SphericalGaussianPerturbation<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Spherical gaussian perturbation");
-        {
-          prm.declare_entry ("Angle", "0.",
-                             Patterns::Double (0.),
-                             "The angle where the center of the perturbation is placed.");
-          prm.declare_entry ("Non-dimensional depth", "0.7",
-                             Patterns::Double (0.),
-                             "The non-dimensional radial distance where the center of the "
-                             "perturbation is placed.");
-          prm.declare_entry ("Amplitude", "0.01",
-                             Patterns::Double (0.),
-                             "The amplitude of the perturbation.");
-          prm.declare_entry ("Sigma", "0.2",
-                             Patterns::Double (0.),
-                             "The standard deviation of the Gaussian perturbation.");
-          prm.declare_entry ("Sign", "1.",
-                             Patterns::Double (),
-                             "The sign of the perturbation.");
-          prm.declare_entry ("Filename for initial geotherm table", "initial-geotherm-table",
-                             Patterns::FileName(),
-                             "The file from which the initial geotherm table is to be read. "
-                             "The format of the file is defined by what is read in "
-                             "source/initial\\_temperature/spherical\\_shell.cc.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-    template <int dim>
-    void
-    SphericalGaussianPerturbation<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Spherical gaussian perturbation");
-        {
-          angle = prm.get_double ("Angle");
-          depth = prm.get_double ("Non-dimensional depth");
-          amplitude  = prm.get_double ("Amplitude");
-          sigma  = prm.get_double ("Sigma");
-          sign  = prm.get_double ("Sign");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      // This initial condition only makes sense if the geometry is derived from
-      // a spherical model
-      // (i.e. a sphere, spherical shell, chunk or ellipsoidal chunk with zero ellipticity)
-
-      if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()))
-        {
-          R0 = 0.;
-          R1 = Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>>
-               (this->get_geometry_model()).radius();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()))
-        {
-          R0 = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
-               (this->get_geometry_model()).inner_radius();
-          R1 = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
-               (this->get_geometry_model()).outer_radius();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>>(this->get_geometry_model()))
-        {
-          R0 = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
-               (this->get_geometry_model()).inner_radius();
-          R1 = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
-               (this->get_geometry_model()).outer_radius();
-        }
-
-      else if (Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()))
-        {
-
-          // TODO
-          // If the eccentricity of the EllipsoidalChunk is non-zero, the radius can vary along a boundary,
-          // but the maximal depth is the same everywhere and we could calculate a representative pressure
-          // profile. However, it requires some extra logic with ellipsoidal
-          // coordinates, so for now we only allow eccentricity zero.
-          // Using the EllipsoidalChunk with eccentricity zero can still be useful,
-          // because the domain can be non-coordinate parallel.
-
-          const auto &gm = Plugins::get_plugin_as_type<const GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model());
-
-          AssertThrow(gm.get_eccentricity() == 0.0,
-                      ExcNotImplemented("This plugin cannot be used with a non-zero eccentricity. "));
-
-          R0 = gm.get_semi_major_axis_a() - gm.maximal_depth();
-          R1 = gm.get_semi_major_axis_a();
-        }
-      else
-        {
-          Assert (false, ExcMessage ("This initial condition can only be used if the geometry "
-                                     "is a sphere, a spherical shell, a chunk or an "
-                                     "ellipsoidal chunk."));
-
-          R0 = numbers::signaling_nan<double>();
-          R1 = numbers::signaling_nan<double>();
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(SphericalHexagonalPerturbation,
-                                              "spherical hexagonal perturbation",
-                                              "An initial temperature field in which the temperature "
-                                              "is perturbed following an $N$-fold pattern in a specified "
-                                              "direction from an otherwise spherically symmetric "
-                                              "state. The class's name comes from previous versions "
-                                              "when the only option was $N=6$.")
-
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(SphericalGaussianPerturbation,
-                                              "spherical gaussian perturbation",
-                                              "An initial temperature field in which the temperature "
-                                              "is perturbed by a single Gaussian added to an "
-                                              "otherwise spherically symmetric state. Additional "
-                                              "parameters are read from the parameter file in subsection "
-                                              "'Spherical gaussian perturbation'.")
-  }
-}
diff --git a/source/initial_temperature/world_builder.cc.bak b/source/initial_temperature/world_builder.cc.bak
deleted file mode 100644
index ae1f5eac2c4..00000000000
--- a/source/initial_temperature/world_builder.cc.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/global.h>
-
-#ifdef ASPECT_WITH_WORLD_BUILDER
-#include <world_builder/config.h>
-#include <aspect/initial_temperature/world_builder.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/citation_info.h>
-
-#include <world_builder/world.h>
-
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    template <int dim>
-    WorldBuilder<dim>::WorldBuilder ()
-      = default;
-
-    template <int dim>
-    void
-    WorldBuilder<dim>::
-    initialize()
-    {
-      CitationInfo::add("GWB");
-      world_builder = this->get_world_builder_pointer();
-    }
-
-
-    template <int dim>
-    double
-    WorldBuilder<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-#if WORLD_BUILDER_VERSION_MAJOR > 0 || WORLD_BUILDER_VERSION_MINOR >= 5
-      return world_builder->temperature(Utilities::convert_point_to_array(position),
-                                        -this->get_geometry_model().height_above_reference_surface(position));
-#else
-
-      return world_builder->temperature(Utilities::convert_point_to_array(position),
-                                        -this->get_geometry_model().height_above_reference_surface(position),
-                                        this->get_gravity_model().gravity_vector(position).norm());
-#endif
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(WorldBuilder,
-                                              "world builder",
-                                              "Specify the initial temperature through the World Builder. "
-                                              "More information on the World Builder can be found at "
-                                              "\\url{https://geodynamicworldbuilder.github.io}. "
-                                              "Make sure to specify the location of the World Builder file "
-                                              "in the parameter 'World builder file'.")
-  }
-}
-#endif
diff --git a/source/main.cc.bak b/source/main.cc.bak
deleted file mode 100644
index 77b38b6890c..00000000000
--- a/source/main.cc.bak
+++ /dev/null
@@ -1,892 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/utilities.h>
-#include <deal.II/base/mpi.h>
-#include <deal.II/base/multithread_info.h>
-#include <deal.II/base/revision.h>
-#include <csignal>
-#include <string>
-#include <thread>
-#include <regex>
-
-#ifdef DEBUG
-#ifdef ASPECT_USE_FP_EXCEPTIONS
-#include <cfenv>
-#endif
-#endif
-
-#if ASPECT_USE_SHARED_LIBS==1
-#  include <dlfcn.h>
-#  ifdef ASPECT_HAVE_LINK_H
-#    include <link.h>
-#  endif
-#endif
-
-// This define has to be in exactly one translation unit and sets up the catch testing framework
-#define CATCH_CONFIG_RUNNER
-
-// work-around for clang 6 error:
-// "error: no member named 'uncaught_exceptions' in namespace 'std'"
-// see https://github.com/catchorg/Catch2/issues/1201
-#define CATCH_INTERNAL_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS
-#define CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS
-
-#include <catch.hpp>
-
-
-// get the value of a particular parameter from the contents of the input
-// file. return an empty string if not found
-std::string
-get_last_value_of_parameter(const std::string &parameters,
-                            const std::string &parameter_name)
-{
-  std::string return_value;
-
-  std::istringstream x_file(parameters);
-  while (x_file)
-    {
-      // Get one line and then match a regex to it that matches the parameter
-      // we are looking for. Before we do that, strip spaces from the front
-      // and back of the line:
-      std::string line;
-      std::getline(x_file, line);
-
-      while ((line.size() > 0) && (line[0] == ' ' || line[0] == '\t'))
-        line.erase(0, 1);
-      while ((line.size() > 0)
-             && (line[line.size() - 1] == ' ' || line[line.size() - 1] == '\t'))
-        line.erase(line.size() - 1, std::string::npos);
-
-      std::match_results<std::string::const_iterator> matches;
-      const std::string regex = "set[ \t]+" + parameter_name + "[ \t]*=[ \t]*(.*)";
-      if (std::regex_match(line, matches, std::regex(regex)))
-        {
-          // Since the line as a whole matched, the 'matches' variable needs to
-          // contain two entries: [0] denotes the whole string, and [1] the
-          // one that was matched by the '(.*)' expression.
-          Assert (matches.size() == 2, dealii::ExcInternalError());
-          return_value = std::string(matches[1].first, matches[1].second);
-        }
-    }
-
-  return return_value;
-}
-
-
-// Extract the dimension in which to run ASPECT from the
-// the contents of the parameter file. This is something that
-// we need to do before processing the parameter file since we
-// need to know whether to use the dim=2 or dim=3 instantiation
-// of the main classes.
-//
-// This function is essentially the first part of ASPECT to look at the input
-// file, so if something is wrong with it, this is the place to generate good
-// error messages.
-unsigned int
-get_dimension(const std::string &parameters)
-{
-  const std::string dimension = get_last_value_of_parameter(parameters, "Dimension");
-  if (dimension.size() > 0)
-    {
-      // A common problem is that people have .prm files that were generated
-      // on Windows, but then run this on Linux where the line endings are
-      // different. This is pernicious because it means that the conversion
-      // of a string such as "2\r" to an integer fails, but if we print
-      // this string, it comes out completely garbled because it contains
-      // a carriage-return without a newline -- so the error message looks
-      // like this:
-      //
-      //    >.  While reading the dimension from the input file, ASPECT found a string that can not be converted to an integer: <2
-      //
-      // Note how the end of the error message overwrites the beginning
-      // of the line.
-      //
-      // To avoid this kind of error, specifically test up front that the
-      // text in question does not contain '\r' characters. If we are on
-      // linux, then this kind of character would means that the line endings
-      // are wrong. On the other hand, if we are on windows, then the
-      // getline command we have used in finding 'dimension' would have
-      // filtered it out. So its presence points to a problem.
-
-      AssertThrow (dimension.find('\r') == std::string::npos,
-                   dealii::ExcMessage ("It appears that your input file uses Windows-style "
-                                       "line endings ('\\r\\n') but you are running on a system where "
-                                       "the C++ run time environment expects input files to have "
-                                       "Unix-style line endings ('\\n'). You need to convert your "
-                                       "input file to use the correct line endings before running "
-                                       "ASPECT with it."));
-      try
-        {
-          return dealii::Utilities::string_to_int (dimension);
-        }
-      catch (...)
-        {
-          AssertThrow (false,
-                       dealii::ExcMessage("While reading the dimension from the input file, "
-                                          "ASPECT found a string that can not be converted to "
-                                          "an integer: <" + dimension + ">."));
-          return 0; // we should never get here.
-        }
-    }
-  else
-    return 2;
-}
-
-
-
-#if ASPECT_USE_SHARED_LIBS==1
-
-#ifdef ASPECT_HAVE_LINK_H
-// collect the names of the shared libraries linked to by this program. this
-// function is a callback for the dl_iterate_phdr() function we call below
-int get_names_of_shared_libs (struct dl_phdr_info *info,
-                              size_t,
-                              void *data)
-{
-  reinterpret_cast<std::set<std::string>*>(data)->insert (info->dlpi_name);
-  return 0;
-}
-#endif
-
-
-// make sure the list of shared libraries we currently link with
-// has deal.II only once
-void validate_shared_lib_list (const bool before_loading_shared_libs)
-{
-#ifdef ASPECT_HAVE_LINK_H
-  // get the list of all shared libs we currently link against
-  std::set<std::string> shared_lib_names;
-  dl_iterate_phdr(get_names_of_shared_libs, &shared_lib_names);
-
-  // find everything that is interesting
-  std::set<std::string> dealii_shared_lib_names;
-  for (const auto &p : shared_lib_names)
-    if (p.find ("libdeal_II") != std::string::npos ||
-        p.find ("libdeal.ii") != std::string::npos)
-      dealii_shared_lib_names.insert (p);
-
-  // produce an error if we load deal.II more than once
-  if (dealii_shared_lib_names.size() != 1)
-    {
-      std::ostringstream error;
-      error << "........................................................\n"
-            << "ASPECT currently links against different versions of the\n"
-            << "deal.II library, namely the ones at these locations:\n";
-      for (const auto &p : dealii_shared_lib_names)
-        error << "  " << p << '\n';
-      error << "This can not work.\n\n";
-
-      if (before_loading_shared_libs)
-        error << "Since this is happening already before opening additional\n"
-              << "shared libraries, this means that something must have gone\n"
-              << "wrong when you configured deal.II and/or ASPECT. Please\n"
-              << "contact the forum for help.\n";
-      else
-        error << "Since this is happening after opening additional shared\n"
-              << "library plugins, this likely means that you have compiled\n"
-              << "ASPECT in release mode and the plugin in debug mode, or the\n"
-              << "other way around. Please re-compile the plugin in the same\n"
-              << "mode as ASPECT.\n";
-
-      error << "........................................................\n";
-
-      // if not success, then throw an exception: ExcMessage on processor 0,
-      // QuietException on the others
-      if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
-        {
-          AssertThrow (false, dealii::ExcMessage (error.str()));
-        }
-      else
-        throw aspect::QuietException();
-    }
-#else
-  // simply mark the argument as read, to avoid compiler warnings
-  (void)before_loading_shared_libs;
-#endif
-}
-
-
-#endif
-
-
-// retrieve a list of shared libraries from the parameter file and
-// dlopen them so that we can load plugins declared in them
-void possibly_load_shared_libs (const std::string &parameters)
-{
-  using namespace dealii;
-
-
-  const std::string shared_libs
-    = get_last_value_of_parameter(parameters,
-                                  "Additional shared libraries");
-  if (shared_libs.size() > 0)
-    {
-#if ASPECT_USE_SHARED_LIBS==1
-      // check up front whether the list of shared libraries is internally
-      // consistent or whether we link, for whatever reason, with both the
-      // debug and release versions of deal.II
-      validate_shared_lib_list (true);
-
-      const std::vector<std::string>
-      shared_libs_list = Utilities::split_string_list (shared_libs);
-
-      for (const auto &shared_lib : shared_libs_list)
-        {
-          // The user can specify lib{target}.so, lib{target}.debug.so, or lib{target}.release.so but
-          // we need to load the correct file depending on our compilation mode. We will try to make
-          // it work regardless of what the users specified:
-          std::string filename = shared_lib;
-
-          auto delete_if_ends_with = [](std::string &a, const std::string &b)
-          {
-            if (a.size()<b.size())
-              return;
-            if (0==a.compare(a.size()-b.size(), b.size(), b))
-              a.erase(a.size()-b.size(), std::string::npos);
-          };
-
-          delete_if_ends_with(filename, ".debug.so");
-          delete_if_ends_with(filename, ".release.so");
-          delete_if_ends_with(filename, ".so");
-
-#ifdef DEBUG
-          filename.append(".debug.so");
-#else
-          filename.append(".release.so");
-#endif
-
-          if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
-            std::cout << "Loading shared library <"
-                      << filename
-                      << '>' << std::endl;
-
-
-          void *handle = dlopen (filename.c_str(), RTLD_LAZY);
-          AssertThrow (handle != nullptr,
-                       ExcMessage (std::string("Could not successfully load shared library <")
-                                   + filename + ">. The operating system reports "
-                                   + "that the error is this: <"
-                                   + dlerror() +
-                                   ">. Did you call 'cmake' and then compile "
-                                   "the plugin library you are trying to load, and did "
-                                   "you check the spelling of the library's name? "
-                                   "Are you running ASPECT in a directory so that the path "
-                                   "to the library in question is as specified in the "
-                                   ".prm file?"));
-
-          // check again whether the list of shared libraries is
-          // internally consistent or whether we link with both the
-          // debug and release versions of deal.II. this may happen if
-          // the plugin was compiled against the debug version of
-          // deal.II but aspect itself against the release version, or
-          // the other way around
-          validate_shared_lib_list (false);
-
-          // on systems where we can detect that both libdeal_II.so and
-          // libdeal_II.g.so is loaded, the test above function above will
-          // throw an exception and we will terminate. on the other hand, on
-          // systems where we can't detect this we should at least mitigate
-          // some of the ill effects -- in particular, make sure that
-          // deallog is set to use the desired output depth since otherwise
-          // we get lots of output from the linear solvers
-          deallog.depth_console(0);
-        }
-
-      if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
-        std::cout << std::endl;
-#else
-      if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
-        {
-          std::cerr << std::endl << std::endl
-                    << "----------------------------------------------------"
-                    << std::endl;
-          std::cerr << "You can not load plugins through additional shared libraries " << std::endl
-                    << "on systems where you link ASPECT as a static executable."
-                    << std::endl
-                    << "----------------------------------------------------"
-                    << std::endl;
-        }
-      std::exit (1);
-#endif
-    }
-}
-
-
-/**
- * Read until we reach the end of the given stream, and return the contents
- * so obtained in a std::string object that contains the individual
- * lines read separated by `\n` characters.
- */
-std::string
-read_until_end (std::istream &input)
-{
-  std::string result;
-  while (input)
-    {
-      std::string line;
-      std::getline(input, line);
-
-      result += line + '\n';
-    }
-  return result;
-}
-
-
-
-/**
- * Take the name of a parameter file and return all parameters in that file
- * as a string. If @p parameter_file_name is "--" read the parameters from
- * std::cin instead.
- */
-std::string
-read_parameter_file(const std::string &parameter_file_name,
-                    MPI_Comm comm)
-{
-  using namespace dealii;
-
-  std::string input_as_string;
-  const bool i_am_proc_0 = (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0);
-
-  if (parameter_file_name != "--")
-    {
-      if (i_am_proc_0 == true &&
-          aspect::Utilities::fexists(parameter_file_name) == false &&
-          (parameter_file_name=="parameter-file.prm"
-           || parameter_file_name=="parameter_file.prm"))
-        {
-          std::cerr << "***          You should not take everything literally!          ***\n"
-                    << "*** Please pass the name of an existing parameter file instead. ***" << std::endl;
-          exit(1);
-        }
-
-      input_as_string = aspect::Utilities::read_and_distribute_file_content(parameter_file_name, comm);
-    }
-  else
-    {
-      // As stated in the help string, treat "--" as special: as is common
-      // on unix, treat it as a way to read input from stdin.
-      // Unfortunately, if you do
-      //    echo "abc" | mpirun -np 4 ./aspect
-      // then only MPI process 0 gets the data. so we have to
-      // read it there, then broadcast it to the other processors
-      if (i_am_proc_0)
-        {
-          input_as_string = read_until_end (std::cin);
-          int size = input_as_string.size()+1;
-          int ierr = MPI_Bcast (&size,
-                                1,
-                                MPI_INT,
-                                /*root=*/0, MPI_COMM_WORLD);
-          AssertThrowMPI(ierr);
-          ierr = MPI_Bcast (const_cast<char *>(input_as_string.c_str()),
-                            size,
-                            MPI_CHAR,
-                            /*root=*/0, MPI_COMM_WORLD);
-          AssertThrowMPI(ierr);
-        }
-      else
-        {
-          // on this side, read what processor zero has broadcast about
-          // the size of the input file. then create a buffer to put the
-          // text in, get it from processor 0, and copy it to
-          // input_as_string
-          int size;
-          int ierr = MPI_Bcast (&size, 1,
-                                MPI_INT,
-                                /*root=*/0, MPI_COMM_WORLD);
-          AssertThrowMPI(ierr);
-
-          std::vector<char> p (size);
-          ierr = MPI_Bcast (p.data(), size,
-                            MPI_CHAR,
-                            /*root=*/0, MPI_COMM_WORLD);
-          AssertThrowMPI(ierr);
-          input_as_string = p.data();
-        }
-    }
-
-  return input_as_string;
-}
-
-
-
-/**
- * Let ParameterHandler parse the input file, here given as a string.
- * Since ParameterHandler unconditionally writes to the screen when it
- * finds something it doesn't like, we get massive amounts of output
- * in parallel computations since every processor writes the same
- * stuff to screen. To avoid this, let processor 0 parse the input
- * first and, if necessary, produce its output. Only if this
- * succeeds, also let the other processors read their input.
- *
- * In case of an error, we need to abort all processors without them
- * having read their data. This is done by throwing an exception of the
- * special class aspect::QuietException that we can catch in main() and terminate
- * the program quietly without generating other output.
- */
-void
-parse_parameters (const std::string &input_as_string,
-                  dealii::ParameterHandler  &prm)
-{
-  // try reading on processor 0
-  bool success = true;
-  if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
-    try
-      {
-        prm.parse_input_from_string(input_as_string);
-      }
-    catch (const dealii::ExceptionBase &e)
-      {
-        success = false;
-        e.print_info(std::cerr);
-        std::cerr << std::endl;
-      }
-
-
-  // broadcast the result. we'd like to do this with a bool
-  // data type but MPI_C_BOOL is not part of old MPI standards.
-  // so, do the broadcast in integers
-  {
-    int isuccess = (success ? 1 : 0);
-    const int ierr = MPI_Bcast (&isuccess, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    AssertThrowMPI(ierr);
-    success = (isuccess == 1);
-  }
-
-  // if not success, then throw an exception: ExcMessage on processor 0,
-  // QuietException on the others
-  if (success == false)
-    {
-      if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
-        {
-          AssertThrow(false, dealii::ExcMessage ("Invalid input parameter file."));
-        }
-      else
-        throw aspect::QuietException();
-    }
-
-  // otherwise, processor 0 was ok reading the data, so we can expect the
-  // other processors will be ok as well
-  if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) != 0)
-    {
-      prm.parse_input_from_string(input_as_string);
-    }
-}
-
-
-
-/**
- * Print help text
- */
-void print_help()
-{
-  std::cout << "Usage: ./aspect [args] <parameter_file.prm>   (to read from an input file)\n"
-            << "    or ./aspect [args] --                     (to read parameters from stdin)\n"
-            << std::endl;
-  std::cout << "    optional arguments [args]:\n"
-            << "       -h, --help             (for this usage help)\n"
-            << "       -v, --version          (for information about library versions)\n"
-            << "       -j, --threads          (to use multi-threading)\n"
-            << "       --output-json          (print parameters in JSON format to standard output and exit)\n"
-            << "       --output-xml           (print parameters in XML format to standard output and exit)\n"
-            << "       --output-plugin-graph  (write a representation of all plugins to standard output and exit)\n"
-            << "       --validate             (parse parameter file and exit or report errors)\n"
-            << "       --test                 (run the unit tests from unit_tests/, run --test -h for more info)\n"
-            << std::endl;
-}
-
-
-
-// hook into SIGABRT/SIGFPE and kill off the program
-void signal_handler(int signal)
-{
-  if (signal == SIGABRT)
-    {
-      std::cerr << "SIGABRT received\n";
-    }
-  else if (signal == SIGFPE)
-    {
-      std::cerr << "SIGFPE received\n";
-    }
-  else
-    {
-      std::cerr << "Unexpected signal " << signal << " received\n";
-    }
-
-  // Kill the program without performing any other cleanup, which would likely
-  // lead to a deadlock.
-  std::_Exit(EXIT_FAILURE);
-}
-
-
-
-template <int dim>
-void
-run_simulator(const std::string &raw_input_as_string,
-              const std::string &input_as_string,
-              const bool output_json,
-              const bool output_xml,
-              const bool output_plugin_graph,
-              const bool validate_only)
-{
-  using namespace dealii;
-
-  ParameterHandler prm;
-  const bool i_am_proc_0 = (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0);
-  aspect::Simulator<dim>::declare_parameters(prm);
-
-  if (validate_only)
-    {
-      try
-        {
-          parse_parameters (input_as_string, prm);
-        }
-      catch (...)
-        {
-          throw aspect::QuietException();
-        }
-      if (i_am_proc_0)
-        std::cout << "The provided parameter file is valid."
-                  "\n\n"
-                  "Note: This validation only checks parameter file syntax errors, like typos\n"
-                  "in keywords or parameter names, and that each parameter value satisfies a\n"
-                  "basic check by itself. However, it may miss more nuanced errors that\n"
-                  "are only checked when the model actually begins running. In particular,\n"
-                  "checks that involve two or more parameters can not be verified at this\n"
-                  "stage of an ASPECT run. Examples for such errors that can not already\n"
-                  "be reported here are: (i) That every boundary is assigned exactly one type\n"
-                  "of boundary condition; (ii) that parameters that take a list with values for\n"
-                  "each composition field receive a list of the correct size."
-                  << std::endl;
-      return;
-    }
-
-  parse_parameters (input_as_string, prm);
-
-  if (output_json)
-    {
-      if (i_am_proc_0)
-        prm.print_parameters(std::cout, ParameterHandler::JSON);
-    }
-  else if (output_xml)
-    {
-      if (i_am_proc_0)
-        prm.print_parameters(std::cout, ParameterHandler::XML);
-    }
-  else if (output_plugin_graph)
-    {
-      aspect::Simulator<dim> simulator(MPI_COMM_WORLD, prm);
-      if (i_am_proc_0)
-        simulator.write_plugin_graph (std::cout);
-    }
-  else
-    {
-      aspect::Simulator<dim> simulator(MPI_COMM_WORLD, prm);
-      if (i_am_proc_0)
-        {
-          // write create output/original.prm containing exactly what we got
-          // started with:
-          std::string output_directory = prm.get ("Output directory");
-          if (output_directory.size() == 0)
-            output_directory = "./";
-          else if (output_directory[output_directory.size()-1] != '/')
-            output_directory += "/";
-
-          std::ofstream file(output_directory + "original.prm");
-          file << raw_input_as_string;
-        }
-
-      simulator.run();
-    }
-}
-
-
-
-int main (int argc, char *argv[])
-{
-  using namespace dealii;
-
-#ifdef DEBUG
-#ifdef ASPECT_USE_FP_EXCEPTIONS
-  // Some implementations seem to not initialize the floating point exception
-  // bits to zero. Make sure we start from a clean state.
-  feclearexcept(FE_DIVBYZERO|FE_INVALID);
-
-  // enable floating point exceptions
-  feenableexcept(FE_DIVBYZERO|FE_INVALID);
-#endif
-#endif
-
-  std::string prm_name = "";
-  bool output_json         = false;
-  bool output_xml          = false;
-  bool output_plugin_graph = false;
-  bool output_version      = false;
-  bool output_help         = false;
-  bool use_threads         = false;
-  bool run_unittests       = false;
-  bool validate_only       = false;
-  int current_argument = 1;
-
-  // Loop over all command line arguments. Handle a number of special ones
-  // starting with a dash, and then take the first non-special one as the
-  // name of the input file. We will later check that there are no further
-  // arguments left after that.
-  while (current_argument<argc)
-    {
-      const std::string arg = argv[current_argument];
-      ++current_argument;
-      if (arg == "--output-json")
-        {
-          output_json = true;
-        }
-      else if (arg == "--output-xml")
-        {
-          output_xml = true;
-        }
-      else if (arg == "--output-plugin-graph")
-        {
-          output_plugin_graph = true;
-        }
-      else if (arg=="-h" || arg =="--help")
-        {
-          output_help = true;
-        }
-      else if (arg=="-v" || arg =="--version")
-        {
-          output_version = true;
-        }
-      else if (arg=="-j" || arg =="--threads")
-        {
-          use_threads = true;
-        }
-      else if (arg == "--test")
-        {
-          run_unittests = true;
-          break;
-        }
-      else if (arg == "--validate")
-        {
-          validate_only = true;
-        }
-      else
-        {
-          // Not a special argument, so we assume that this is the .prm
-          // filename (or "--"). We can now break out of this loop because
-          // we are not going to parse arguments passed after the filename.
-          prm_name = arg;
-          break;
-        }
-    }
-
-  // There might be remaining arguments for PETSc, only hand those over to
-  // the MPI initialization, but not the ones we parsed above.
-  int n_remaining_arguments = argc - current_argument;
-  char **remaining_arguments = (n_remaining_arguments > 0) ? &argv[current_argument] : nullptr;
-
-  try
-    {
-      // Note: we initialize this class inside the try/catch block and not
-      // before, so that the destructor of this instance can react if we are
-      // currently unwinding the stack if an unhandled exception is being
-      // thrown to avoid MPI deadlocks.
-      Utilities::MPI::MPI_InitFinalize mpi_initialization(n_remaining_arguments,
-                                                          remaining_arguments,
-                                                          (use_threads ?
-                                                           numbers::invalid_unsigned_int :
-                                                           1));
-
-      if (run_unittests)
-        {
-          // Construct new_argc, new_argv from argc, argv for catch without
-          // the "--test" arg, so we can control catch from the command
-          // line. It turns out catch needs argv[0] to be the executable name
-          // so we can not use remaining_arguments from above.
-          int new_argc = n_remaining_arguments + 1;
-          std::vector<char *> args; // use to construct a new argv of type char **
-          args.emplace_back(argv[0]);
-          for (int i=0; i<n_remaining_arguments; ++i)
-            args.emplace_back(argv[i+current_argument]);
-          char **new_argv = args.data();
-
-          // Finally run catch
-          return Catch::Session().run(new_argc, new_argv);
-        }
-
-
-      deallog.depth_console(0);
-
-      const bool i_am_proc_0 = (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0);
-
-      if (i_am_proc_0)
-        {
-          // Output header, except for a clean output for xml or plugin graph
-          if (!output_xml && !output_json && !output_plugin_graph && !validate_only)
-            print_aspect_header(std::cout);
-
-          if (output_help)
-            print_help();
-
-          // If only help or version is requested, we are done.
-          if (output_help || output_version)
-            return 0;
-        }
-      else
-        {
-          // If only help or version is requested, we are done.
-          if (output_help || output_version)
-            return 0;
-
-          // We hook into the abort handler on ranks != 0 to avoid an MPI
-          // deadlock. The deal.II library will call std::abort() when an
-          // Assert is triggered, which can lead to a deadlock because it
-          // runs the things that are associated with atexit() which may
-          // itself trigger MPI communication. The same happens for other
-          // signals we may trigger, such as floating point exceptions
-          // (SIGFPE).
-          //
-          // We work around this by immediately calling _Exit in the
-          // signal handler and thus aborting the program without running
-          // cleanup functions set via atexit(). This is only necessary on
-          // rank != 0 for some reason.
-          std::signal(SIGABRT, signal_handler);
-          std::signal(SIGFPE, signal_handler);
-        }
-
-      // If no parameter given or somebody gave additional parameters,
-      // show help and exit.
-      if ((prm_name == "") || (current_argument < argc))
-        {
-          if (i_am_proc_0)
-            print_help();
-          return 0;
-        }
-
-      // See where to read input from, then do the reading and
-      // put the contents of the input into a string.
-      const std::string raw_input_as_string = read_parameter_file(prm_name, MPI_COMM_WORLD);
-
-      // Replace $ASPECT_SOURCE_DIR in the input so that include statements
-      // like "include $ASPECT_SOURCE_DIR/tests/bla.prm" work.
-      const std::string input_as_string = aspect::Utilities::expand_ASPECT_SOURCE_DIR(raw_input_as_string);
-
-      // Determine the dimension we want to work in. the default
-      // is 2, but if we find a line of the kind "set Dimension = ..."
-      // then the last such line wins.
-      const unsigned int dim = get_dimension(input_as_string);
-
-      // Do the same with lines potentially indicating shared libs to
-      // be loaded. These shared libs could contain additional module
-      // instantiations for geometries, etc, that would then be
-      // available as part of the possible parameters of the input
-      // file, so they need to be loaded before we even start processing
-      // the parameter file.
-      possibly_load_shared_libs (input_as_string);
-
-      // Now switch between the templates that start the model for 2d or 3d.
-      switch (dim)
-        {
-          case 2:
-          {
-            run_simulator<2>(raw_input_as_string,input_as_string,output_json,output_xml,output_plugin_graph,validate_only);
-            break;
-          }
-          case 3:
-          {
-            run_simulator<3>(raw_input_as_string,input_as_string,output_json,output_xml,output_plugin_graph,validate_only);
-            break;
-          }
-          default:
-            AssertThrow((dim >= 2) && (dim <= 3),
-                        ExcMessage ("ASPECT can only be run in 2d and 3d but a "
-                                    "different space dimension is given in the parameter file."));
-        }
-    }
-  catch (ExceptionBase &exc)
-    {
-      // report name of the deal.II exception:
-      std::cerr << std::endl << std::endl
-                << "----------------------------------------------------"
-                << std::endl;
-      std::cerr << "Exception '" << exc.get_exc_name() << "'"
-                << " on rank " << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                << " on processing: " << std::endl
-                << exc.what() << std::endl
-                << "Aborting!" << std::endl
-                << "----------------------------------------------------"
-                << std::endl;
-
-      MPI_Abort(MPI_COMM_WORLD, 1);
-      return 1;
-    }
-  catch (std::exception &exc)
-    {
-      std::cerr << std::endl << std::endl
-                << "----------------------------------------------------"
-                << std::endl;
-      std::cerr << "Exception"
-                << " on rank " << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                << " on processing: " << std::endl
-                << exc.what() << std::endl
-                << "Aborting!" << std::endl
-                << "----------------------------------------------------"
-                << std::endl;
-
-      MPI_Abort(MPI_COMM_WORLD, 1);
-      return 1;
-    }
-  catch (aspect::QuietException &)
-    {
-      // Quietly treat an exception used on processors other than root
-      // when we already know that processor 0 will generate an
-      // exception. We do this to avoid creating too much (duplicate)
-      // screen output. Note that QuietException is not derived from
-      // std::exception, so the order of this and the previous 'catch'
-      // block does not matter.
-      //
-      // Sleep a few seconds before aborting. This allows text output from
-      // other ranks to be printed before the MPI implementation might kill
-      // the computation.
-      std::this_thread::sleep_for(std::chrono::seconds(5));
-
-      MPI_Abort(MPI_COMM_WORLD, 1);
-      return 1;
-    }
-  catch (...)
-    {
-      std::cerr << std::endl << std::endl
-                << "----------------------------------------------------"
-                << std::endl;
-      std::cerr << "Unknown exception!" << std::endl
-                << "Aborting!" << std::endl
-                << "----------------------------------------------------"
-                << std::endl;
-
-      MPI_Abort(MPI_COMM_WORLD, 1);
-      return 1;
-    }
-
-  return 0;
-}
diff --git a/source/material_model/ascii_reference_profile.cc.bak b/source/material_model/ascii_reference_profile.cc.bak
deleted file mode 100644
index d43d40df713..00000000000
--- a/source/material_model/ascii_reference_profile.cc.bak
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/ascii_reference_profile.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    AsciiReferenceProfile<dim>::AsciiReferenceProfile()
-      :
-      density_index(numbers::invalid_unsigned_int),
-      thermal_expansivity_index(numbers::invalid_unsigned_int),
-      specific_heat_index(numbers::invalid_unsigned_int),
-      compressibility_index(numbers::invalid_unsigned_int),
-      seismic_vp_index(numbers::invalid_unsigned_int),
-      seismic_vs_index(numbers::invalid_unsigned_int),
-      seismic_dvp_dT_index(numbers::invalid_unsigned_int),
-      seismic_dvs_dT_index(numbers::invalid_unsigned_int)
-    {}
-
-    template <int dim>
-    void
-    AsciiReferenceProfile<dim>::initialize ()
-    {
-      profile.initialize(this->get_mpi_communicator());
-
-      density_index = profile.get_column_index_from_name("density");
-      thermal_expansivity_index = profile.get_column_index_from_name("thermal_expansivity");
-      specific_heat_index = profile.get_column_index_from_name("specific_heat");
-      compressibility_index = profile.get_column_index_from_name("compressibility");
-
-      // these are only optional entries in the data file, read them in if they exist,
-      // but keep the invalid unsigned int entry if the columns do not exist
-      // the strings have to be all lower case for the lookup class to find them
-      seismic_vp_index = profile.maybe_get_column_index_from_name("seismic_vp");
-      seismic_vs_index = profile.maybe_get_column_index_from_name("seismic_vs");
-      seismic_dvp_dT_index = profile.maybe_get_column_index_from_name("seismic_dvp_dt");
-      seismic_dvs_dT_index = profile.maybe_get_column_index_from_name("seismic_dvs_dt");
-    }
-
-    template <int dim>
-    void
-    AsciiReferenceProfile<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const Point<dim> position = in.position[i];
-          const double temperature_deviation = in.temperature[i] - this->get_adiabatic_conditions().temperature(position);
-          const double pressure_deviation = in.pressure[i] - this->get_adiabatic_conditions().pressure(position);
-
-          const double depth = this->get_geometry_model().depth(position);
-          const Point<1> profile_position(depth);
-
-          double visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*temperature_deviation/this->get_adiabatic_conditions().temperature(position)),1e3),1e-3);
-          if (std::isnan(visc_temperature_dependence))
-            visc_temperature_dependence = 1.0;
-
-          double visc_depth_dependence = viscosity_prefactors[0];
-          for (unsigned int j=0; j < transition_depths.size(); ++j)
-            {
-              if (depth>transition_depths[j])
-                visc_depth_dependence = viscosity_prefactors[j+1];
-            }
-
-          out.viscosities[i] = viscosity * visc_temperature_dependence * visc_depth_dependence;
-
-          out.thermal_conductivities[i] = thermal_conductivity;
-
-          out.thermal_expansion_coefficients[i] = profile.get_data_component(profile_position,thermal_expansivity_index);
-          out.specific_heat[i] = profile.get_data_component(profile_position,specific_heat_index);
-          out.compressibilities[i] = profile.get_data_component(profile_position,compressibility_index);
-
-          out.densities[i] = profile.get_data_component(profile_position,density_index)
-                             * (1.0 - out.thermal_expansion_coefficients[i] * temperature_deviation)
-                             * (tala ? 1.0 : (1.0 + out.compressibilities[i] * pressure_deviation));
-
-          out.entropy_derivative_pressure[i] = 0.0;
-          out.entropy_derivative_temperature[i] = 0.0;
-
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-
-          // fill seismic velocities outputs if they exist
-          if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
-            {
-              if (seismic_vp_index != numbers::invalid_unsigned_int)
-                seismic_out->vp[i] = profile.get_data_component(profile_position,seismic_vp_index);
-              if (seismic_vs_index != numbers::invalid_unsigned_int)
-                seismic_out->vs[i] = profile.get_data_component(profile_position,seismic_vs_index);
-              if (seismic_dvp_dT_index != numbers::invalid_unsigned_int)
-                seismic_out->vp[i] += profile.get_data_component(profile_position,seismic_dvp_dT_index)
-                                      * temperature_deviation;
-              if (seismic_dvs_dT_index != numbers::invalid_unsigned_int)
-                seismic_out->vs[i] += profile.get_data_component(profile_position,seismic_dvs_dT_index)
-                                      * temperature_deviation;
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    AsciiReferenceProfile<dim>::
-    is_compressible () const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiReferenceProfile<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Ascii reference profile");
-        {
-          prm.declare_entry ("Thermal conductivity", "4.0",
-                             Patterns::Double (0.),
-                             "Reference conductivity");
-          prm.declare_entry ("Viscosity", "1e21",
-                             Patterns::Double (0.),
-                             "Viscosity");
-          prm.declare_entry ("Use TALA", "false",
-                             Patterns::Bool (),
-                             "Whether to use the TALA instead of the ALA "
-                             "approximation.");
-          prm.declare_entry ("Thermal viscosity exponent", "0.",
-                             Patterns::Double (0.),
-                             "The temperature dependence of viscosity. Dimensionless exponent.");
-          prm.declare_entry ("Transition depths", "1.5e5, 4.1e5, 6.6e5",
-                             Patterns::List (Patterns::Double(0.)),
-                             "A list of depths where the viscosity changes. Values must "
-                             "monotonically increase. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Viscosity prefactors", "10., 0.1, 1., 10.",
-                             Patterns::List (Patterns::Double(0.)),
-                             "A list of prefactors for the viscosity that determine the viscosity "
-                             "profile. Each prefactor is applied in a depth range specified by the "
-                             "list of `Transition depths', i.e. the first prefactor is applied above "
-                             "the first transition depth, the second one between the first and second "
-                             "transition depth, and so on. "
-                             "To compute the viscosity profile, this prefactor is multiplied by the "
-                             "reference viscosity specified through the parameter `Viscosity'. "
-                             "List must have one more entry than Transition depths. "
-                             "Units: non-dimensional.");
-
-          aspect::Utilities::AsciiDataProfile<dim>::declare_parameters(prm,
-                                                                       "$ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/",
-                                                                       "");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiReferenceProfile<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Ascii reference profile");
-        {
-          tala                 = prm.get_bool ("Use TALA");
-          thermal_conductivity = prm.get_double ("Thermal conductivity");
-          viscosity            = prm.get_double ("Viscosity");
-          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
-          transition_depths    = Utilities::string_to_double
-                                 (Utilities::split_string_list(prm.get ("Transition depths")));
-          viscosity_prefactors = Utilities::string_to_double
-                                 (Utilities::split_string_list(prm.get ("Viscosity prefactors")));
-
-          // make sure to check against the depth lists for size errors, since using depth
-          if (viscosity_prefactors.size() != transition_depths.size()+1)
-            AssertThrow(false, ExcMessage("Error: The list of Viscosity prefactors needs to have exactly "
-                                          "one more entry than the list of Transition depths. "));
-
-          profile.parse_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.density = NonlinearDependence::pressure | NonlinearDependence::temperature;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiReferenceProfile<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr
-          && seismic_vp_index != numbers::invalid_unsigned_int
-          && seismic_vs_index != numbers::invalid_unsigned_int)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(AsciiReferenceProfile,
-                                   "ascii reference profile",
-                                   "A material model that reads in a reference "
-                                   "state for density, thermal expansivity, compressibility "
-                                   "and specific heat from a text file. "
-                                   "\n"
-                                   "Note the required format of the "
-                                   "input data: The first lines may contain any number of comments "
-                                   "if they begin with `#', but one of these lines needs to "
-                                   "contain the number of points in the reference state as "
-                                   "for example `# POINTS: 3'. "
-                                   "Following the comment lines there has to be a single line "
-                                   "containing the names of all data columns, separated by arbitrarily "
-                                   "many spaces. Column names are not allowed to contain spaces. "
-                                   "The file can contain unnecessary columns, but for this plugin it "
-                                   "needs to at least provide the columns named `density', "
-                                   "`thermal\\_expansivity', `specific\\_heat', and `compressibility'. "
-                                   "Note that the data lines in the file need to be sorted in order "
-                                   "of increasing depth from 0 to the maximal depth in the model "
-                                   "domain. Points in the model that are outside of the provided "
-                                   "depth range will be assigned the maximum or minimum depth values, "
-                                   "respectively. Points do not need to be equidistant, "
-                                   "but the computation of properties is optimized in speed "
-                                   "if they are."
-                                   "\n"
-                                   "\n"
-                                   "The viscosity $\\eta$ is computed as "
-                                   "$\\eta(z,T) = \\eta_r(z) \\eta_0 \\exp\\left(-A \\frac{T - T_{\\text{adi}}}{T_{\\text{adi}}}\\right)$, "
-                                   "where $\\eta_r(z)$ is the depth-dependence, which is a "
-                                   "piecewise constant function computed according to the "
-                                   "list of ``Viscosity prefactors'' and ``Transition depths'', "
-                                   "$\\eta_0$ is the reference viscosity specified by the parameter ``Viscosity'' "
-                                   "and $A$ describes the dependence on temperature and corresponds to "
-                                   "the parameter ``Thermal viscosity exponent''.")
-  }
-}
diff --git a/source/material_model/averaging.cc.bak b/source/material_model/averaging.cc.bak
deleted file mode 100644
index d9ad5a02ea4..00000000000
--- a/source/material_model/averaging.cc.bak
+++ /dev/null
@@ -1,464 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <array>
-#include <aspect/material_model/averaging.h>
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    AveragingOperation
-    Averaging<dim>::parse_averaging_operation_name (const std::string &s)
-    {
-      if (s == "none")
-        return none;
-      else if (s == "arithmetic average")
-        return arithmetic_average;
-      else if (s == "harmonic average")
-        return harmonic_average;
-      else if (s == "geometric average")
-        return geometric_average;
-      else if (s == "pick largest")
-        return pick_largest;
-      else if (s == "log average")
-        return log_average;
-      else if (s == "nwd arithmetic average")
-        return nwd_arithmetic_average;
-      else if (s == "nwd harmonic average")
-        return nwd_harmonic_average;
-      else if (s == "nwd geometric average")
-        return nwd_geometric_average;
-      else
-        AssertThrow (false,
-                     ExcMessage ("The value <" + s + "> for a material "
-                                 "averaging operation is not one of the "
-                                 "valid values."));
-
-      return none;
-    }
-
-    // Do the requested averaging operation for one array.
-    template <int dim>
-    void
-    Averaging<dim>::average (const AveragingOperation averaging_operation,
-                             const std::vector<Point<dim>>    &position,
-                             std::vector<double>           &values_out) const
-    {
-      // if an output field has not been filled (because it was
-      // not requested), then simply do nothing -- no harm no foul
-      if (values_out.size() == 0)
-        return;
-
-      const unsigned int N = values_out.size();
-
-      // alfad is a constant which is dependent on the dimension and is used to define the shape of the bell shape.
-      const double alfad = (dim == 2 ? 5/(numbers::PI * bell_shape_limit * bell_shape_limit) : 106/(numbers::PI * bell_shape_limit * bell_shape_limit * bell_shape_limit));
-
-      // perform the requested averaging
-      switch (averaging_operation)
-        {
-          case none:
-          {
-            break;
-          }
-          case arithmetic_average:
-          {
-            double sum = 0;
-            for (unsigned int i=0; i<N; ++i)
-              sum += values_out[i];
-
-            const double average = sum/N;
-            for (unsigned int i=0; i<N; ++i)
-              values_out[i] = average;
-            break;
-          }
-          case harmonic_average:
-          {
-            // if one of the values is zero, the average is 0.0
-            for (unsigned int i=0; i<N; ++i)
-              if (values_out[i] == 0.0)
-                {
-                  for (unsigned int j=0; j<N; ++j)
-                    values_out[j] = 0.0;
-                  return;
-                }
-
-            double sum = 0;
-            for (unsigned int i=0; i<N; ++i)
-              sum += 1./values_out[i];
-
-            const double average = 1./(sum/N);
-            for (unsigned int i=0; i<N; ++i)
-              values_out[i] = average;
-            break;
-          }
-          case geometric_average:
-          {
-            double prod = 1;
-            for (unsigned int i=0; i<N; ++i)
-              {
-                Assert (values_out[i] >= 0,
-                        ExcMessage ("Computing the geometric average "
-                                    "only makes sense for non-negative "
-                                    "quantities."));
-                prod *= values_out[i];
-              }
-
-            const double average = std::pow (prod, 1./N);
-            for (unsigned int i=0; i<N; ++i)
-              values_out[i] = average;
-            break;
-          }
-          case pick_largest:
-          {
-            double max = std::numeric_limits<double>::lowest();
-            for (unsigned int i=0; i<N; ++i)
-              max = std::max(max, values_out[i]);
-
-            for (unsigned int i=0; i<N; ++i)
-              values_out[i] = max;
-            break;
-          }
-          case log_average:
-          {
-            double sum = 0;
-            for (unsigned int i=0; i<N; ++i)
-              {
-                Assert (values_out[i] >= 0,
-                        ExcMessage ("Computing the log average "
-                                    "only makes sense for non-negative "
-                                    "quantities."));
-                sum += std::log10(values_out[i]);
-              }
-            const double log_value_average = std::pow (10.,sum/N);
-            for (unsigned int i=0; i<N; ++i)
-              values_out[i] = log_value_average;
-            break;
-          }
-          case nwd_arithmetic_average:
-          {
-            // initialize variables
-            double sum_value = 0;
-            double sum_weights = 0;
-            std::vector<double> temp_values(N,0);
-
-            // determine the maximum distance between all the points
-            double max_distance = 0;
-            for (unsigned int i=0; i<N; ++i)
-              {
-                for (unsigned int j=0; j<N; ++j)
-                  {
-                    max_distance = std::max (max_distance, position[i].distance(position[j]));
-                  }
-              }
-
-            // apply the averaging to the values
-            for (unsigned int i=0; i<N; ++i)
-              {
-                sum_value = 0;
-                sum_weights = 0;
-
-                for (unsigned int j=0; j<N; ++j)
-                  {
-                    const double distance = position[i].distance(position[j])/max_distance;
-                    double weight = alfad * ((1 + 3 * (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)));
-                    if (distance / bell_shape_limit > 1)
-                      weight = 0;
-                    sum_value += weight * values_out[j];
-                    sum_weights += weight;
-                  }
-
-                const double average = sum_value / sum_weights;
-
-                temp_values[i] = average;
-              };
-            for (unsigned int i = 0; i<N; ++i)
-              {
-                values_out[i] = temp_values[i];
-              }
-            break;
-          }
-          case nwd_harmonic_average:
-          {
-            // if one of the values is zero, the average is 0.0
-            for (unsigned int i=0; i<N; ++i)
-              if (values_out[i] == 0.0)
-                {
-                  for (unsigned int j=0; j<N; ++j)
-                    values_out[j] = 0.0;
-                  return;
-                }
-
-            // initialize variables
-            double sum_value = 0;
-            double sum_weights = 0;
-            std::vector<double> temp_values(N,0);
-
-            // determine the maximum distance between all the points
-            double max_distance = 0;
-            for (unsigned int i=0; i<N; ++i)
-              {
-                for (unsigned int j=0; j<N; ++j)
-                  {
-                    max_distance = std::max (max_distance, position[i].distance(position[j]));
-                  }
-              }
-
-            // apply the averaging to the values
-            for (unsigned int i=0; i<N; ++i)
-              {
-                sum_value = 0;
-                sum_weights = 0;
-
-                for (unsigned int j=0; j<N; ++j)
-                  {
-                    const double distance = position[i].distance(position[j])/max_distance;
-                    double weight = alfad * ((1 + 3 * (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)));
-                    if (distance > bell_shape_limit )
-                      weight = 0;
-                    if (values_out[j] != 0)
-                      {
-                        sum_value += weight / values_out[j];
-                      }
-                    sum_weights += weight;
-                  }
-                const double average = sum_weights / sum_value;
-
-                temp_values[i] = average;
-              };
-            for (unsigned int i = 0; i<N; ++i)
-              {
-                values_out[i] = temp_values[i];
-              }
-            break;
-          }
-          case nwd_geometric_average:
-          {
-            // initialize variables
-            double sum_value = 0;
-            double sum_weights = 0;
-            std::vector<double> temp_values(N,0);
-
-            // determine the maximum distance between all the points
-            double max_distance = 0;
-            for (unsigned int i=0; i<N; ++i)
-              {
-                for (unsigned int j=0; j<N; ++j)
-                  {
-                    max_distance = std::max (max_distance, position[i].distance(position[j]));
-                  }
-              }
-
-            // apply the averaging to the values
-            for (unsigned int i=0; i<N; ++i)
-              {
-                sum_value = 0;
-                sum_weights = 0;
-
-                Assert (values_out[i] >= 0,
-                        ExcMessage ("Computing the geometric average "
-                                    "only makes sense for non-negative "
-                                    "quantities."));
-
-                for (unsigned int j=0; j<N; ++j)
-                  {
-
-                    const double distance = position[i].distance(position[j])/max_distance;
-                    double weight = alfad * ((1 + 3 * (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)) * (1 - (distance / bell_shape_limit)));
-
-                    // the weight beyond the bell shape limit should always be zero.
-                    if (distance > bell_shape_limit )
-                      weight = 0;
-
-                    /**
-                     * If the value is zero to begin with the log of that value will return nan.
-                     * To prevent this from happening nothing is added to sum_value in this case.
-                     */
-                    if (values_out[j] != 0)
-                      {
-                        sum_value += weight*log(values_out[j]);
-                      }
-
-                    sum_weights += weight;
-
-                  }
-                const double average = std::exp (sum_value/sum_weights);
-
-
-                temp_values[i] = average;
-              };
-            for (unsigned int i = 0; i<N; ++i)
-              {
-                values_out[i] = temp_values[i];
-              }
-            break;
-          }
-          default:
-          {
-            AssertThrow (false,
-                         ExcMessage ("This averaging operation is not implemented."));
-          }
-        }
-    }
-
-    template <int dim>
-    void
-    Averaging<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                             typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      // fill variable out with the results form the base material model
-      base_model -> evaluate(in,out);
-
-      /**
-       * Check if the size of the densities (and thereby all the other vectors) is larger
-       * than one. Averaging over one or zero points does not make a difference anyway,
-       * and the normalized weighted distance averaging schemes need the distance between
-       * the points and can not handle a distance of zero.
-       */
-      if (out.n_evaluation_points() > 1)
-        {
-          /* Average the base model values based on the chosen average */
-          average (averaging_operation,in.position,out.viscosities);
-          average (averaging_operation,in.position,out.densities);
-          average (averaging_operation,in.position,out.thermal_expansion_coefficients);
-          average (averaging_operation,in.position,out.specific_heat);
-          average (averaging_operation,in.position,out.thermal_conductivities);
-          average (averaging_operation,in.position,out.compressibilities);
-          average (averaging_operation,in.position,out.entropy_derivative_pressure);
-          average (averaging_operation,in.position,out.entropy_derivative_temperature);
-        }
-    }
-
-    template <int dim>
-    void
-    Averaging<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Averaging");
-        {
-          prm.declare_entry("Base model","simple",
-                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
-                            "The name of a material model that will be modified by an "
-                            "averaging operation. Valid values for this parameter "
-                            "are the names of models that are also valid for the "
-                            "``Material models/Model name'' parameter. See the documentation for "
-                            "that for more information.");
-          prm.declare_entry ("Averaging operation", "none",
-                             Patterns::Selection ("none|arithmetic average|harmonic average|geometric average|pick largest|log average|nwd arithmetic average|nwd harmonic average|nwd geometric average"),
-                             "Choose the averaging operation to use.");
-          prm.declare_entry ("Bell shape limit", "1.",
-                             Patterns::Double(0.),
-                             "The limit normalized distance between 0 and 1 where the bell shape becomes zero. See the manual for a more information.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    Averaging<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Averaging");
-        {
-          Assert( prm.get("Base model") != "averaging",
-                  ExcMessage("You may not use ``averaging'' as the base model for "
-                             "a averaging model.") );
-
-          // create the base model and initialize its SimulatorAccess base
-          // class; it will get a chance to read its parameters below after we
-          // leave the current section
-          base_model = create_material_model<dim>(prm.get("Base model"));
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
-            sim->initialize_simulator (this->get_simulator());
-
-          averaging_operation = Averaging<dim>::parse_averaging_operation_name(prm.get ("Averaging operation"));
-          bell_shape_limit = prm.get_double ("Bell shape limit");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      /* After parsing the parameters for averaging, it is essential to parse
-      parameters related to the base model. */
-      base_model->parse_parameters(prm);
-      this->model_dependence = base_model->get_model_dependence();
-    }
-
-    template <int dim>
-    bool
-    Averaging<dim>::
-    is_compressible () const
-    {
-      return base_model->is_compressible();
-    }
-
-    template <int dim>
-    void
-    Averaging<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      base_model->create_additional_named_outputs(out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Averaging,
-                                   "averaging",
-                                   "The ``averaging'' Material model applies an averaging of the quadrature points "
-                                   "within a cell. The values to average are supplied by any of the other available "
-                                   "material models. In other words, it is a ``compositing material model''. "
-                                   "Parameters related to the average model are read from a subsection "
-                                   "``Material model/Averaging''."
-                                   "\n\n"
-                                   "The user must specify a ``Base model'' from which material properties are "
-                                   "derived. Furthermore an averaging operation must be selected, where the "
-                                   "Choice should be from the list none|arithmetic average|harmonic average|"
-                                   "geometric average|pick largest|log average|NWD arithmetic average|NWD harmonic average"
-                                   "|NWD geometric average."
-                                   "\n\n"
-                                   "NWD stands for Normalized Weighed Distance. The models with this in front "
-                                   "of their name work with a weighed average, which means each quadrature point "
-                                   "requires an individual weight. The weight is determined by the distance, where "
-                                   "the exact relation is determined by a bell shaped curve. A bell shaped curve is "
-                                   "a continuous function which is one at its maximum and exactly zero at and beyond "
-                                   "its limit. This bell shaped curve is spanned around each quadrature point to "
-                                   "determine the weighting map for each quadrature point. The used bell shape comes "
-                                   "from Lucy (1977). The distance is normalized so the largest distance becomes one. "
-                                   "This means that if variable ''Bell shape limit'' is exactly one, the farthest "
-                                   "quadrature point is just on the limit and its weight will be exactly zero. In "
-                                   "this plugin it is not implemented as larger and equal than the limit, but larger "
-                                   "than, to ensure the quadrature point at distance zero is always included."
-                                  )
-  }
-}
diff --git a/source/material_model/compositing.cc.bak b/source/material_model/compositing.cc.bak
deleted file mode 100644
index c091017a1be..00000000000
--- a/source/material_model/compositing.cc.bak
+++ /dev/null
@@ -1,259 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/compositing.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Property
-    {
-      namespace
-      {
-        const std::pair<std::string, MaterialProperty> property_map_pairs[]
-        =
-        {
-          {"Viscosity", viscosity},
-          {"Density", density},
-          {"Thermal expansion coefficient", thermal_expansion_coefficient},
-          {"Specific heat", specific_heat},
-          {"Thermal conductivity", thermal_conductivity},
-          {"Compressibility", compressibility},
-          {"Entropy derivative pressure", entropy_derivative_pressure},
-          {"Entropy derivative temperature", entropy_derivative_temperature},
-          {"Reaction terms", reaction_terms}
-        };
-
-
-        const std::map<std::string, MaterialProperty>
-        property_map (std::begin(property_map_pairs),
-                      std::end(property_map_pairs));
-      }
-    }
-
-
-    template <int dim>
-    void
-    Compositing<dim>::copy_required_properties(const unsigned int model_index,
-                                               const typename Interface<dim>::MaterialModelOutputs &base_output,
-                                               typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      if (model_property_map.find(Property::viscosity)->second == model_index)
-        out.viscosities = base_output.viscosities;
-      if (model_property_map.find(Property::density)->second == model_index)
-        out.densities = base_output.densities;
-      if (model_property_map.find(Property::thermal_expansion_coefficient)->second == model_index)
-        out.thermal_expansion_coefficients = base_output.thermal_expansion_coefficients;
-      if (model_property_map.find(Property::specific_heat)->second == model_index)
-        out.specific_heat = base_output.specific_heat;
-      if (model_property_map.find(Property::thermal_conductivity)->second == model_index)
-        out.thermal_conductivities = base_output.thermal_conductivities;
-      if (model_property_map.find(Property::compressibility)->second == model_index)
-        out.compressibilities = base_output.compressibilities;
-      if (model_property_map.find(Property::entropy_derivative_pressure)->second == model_index)
-        out.entropy_derivative_pressure = base_output.entropy_derivative_pressure;
-      if (model_property_map.find(Property::entropy_derivative_temperature)->second == model_index)
-        out.entropy_derivative_temperature = base_output.entropy_derivative_temperature;
-      if (model_property_map.find(Property::reaction_terms)->second == model_index)
-        out.reaction_terms = base_output.reaction_terms;
-    }
-
-
-
-    template <int dim>
-    void
-    Compositing<dim>::initialize ()
-    {
-      // initialize all models
-      for (auto &model : models)
-        model->initialize();
-    }
-
-
-    template <int dim>
-    void
-    Compositing<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                               typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      typename Interface<dim>::MaterialModelOutputs base_output(out.n_evaluation_points(),
-                                                                this->introspection().n_compositional_fields);
-
-      // Move the additional outputs to base_output so that our models can fill them if desired:
-      base_output.move_additional_outputs_from(out);
-
-      for (unsigned int i=0; i<models.size(); ++i)
-        {
-          models[i]->evaluate(in, base_output);
-          copy_required_properties(i, base_output, out);
-        }
-
-      // Finally, we move the additional outputs back into place:
-      out.move_additional_outputs_from(base_output);
-    }
-
-
-
-    template <int dim>
-    void
-    Compositing<dim>::
-    create_additional_named_outputs (typename Interface<dim>::MaterialModelOutputs &outputs) const
-    {
-      for (unsigned int i=0; i<models.size(); ++i)
-        {
-          models[i]->create_additional_named_outputs(outputs);
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Compositing<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Compositing");
-        {
-          std::map<std::string, Property::MaterialProperty>::const_iterator prop_it = Property::property_map.begin();
-          for (; prop_it != Property::property_map.end(); ++prop_it)
-            {
-              prm.declare_entry(prop_it->first, "unspecified",
-                                Patterns::Selection(
-                                  MaterialModel::get_valid_model_names_pattern<dim>()+"|unspecified"
-                                ),
-                                "Material model to use for " + prop_it->first +". Valid values for this "
-                                "parameter are the names of models that are also valid for the "
-                                "``Material models/Model name'' parameter. See the documentation for "
-                                "that for more information.");
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Compositing<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Compositing");
-        {
-          model_names.clear();
-          std::map<std::string, Property::MaterialProperty>::const_iterator prop_it = Property::property_map.begin();
-          for (; prop_it != Property::property_map.end(); ++prop_it)
-            {
-              const Property::MaterialProperty prop = prop_it->second;
-              const std::string model_name = prm.get(prop_it->first);
-
-              AssertThrow(model_name != "averaging",
-                          ExcMessage("You may not use ``averaging'' as the base model for the "
-                                     + prop_it->first +" property of a compositing material model."));
-              AssertThrow(model_name != "compositing",
-                          ExcMessage("You may not use ``compositing'' as the base model for the "
-                                     + prop_it->first +" property of a compositing material model."));
-
-              // see if we've encountered this base model before. If not,
-              // otherwise put it into a new slot. otherwise
-              // record its number for the current coefficient.
-              std::vector<std::string>::iterator model_position
-                = std::find(model_names.begin(), model_names.end(), model_name);
-              if ( model_position == model_names.end() )
-                {
-                  model_property_map[prop] = model_names.size();
-                  model_names.push_back(model_name);
-                }
-              else
-                model_property_map[prop] = std::distance(model_names.begin(), model_position);
-            }
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // create the models and initialize their SimulatorAccess base
-      // After parsing the parameters for averaging, it is essential to parse
-      // parameters related to the base models
-      models.resize(model_names.size());
-      for (unsigned int i=0; i<model_names.size(); ++i)
-        {
-          models[i] = create_material_model<dim>(model_names[i]);
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(models[i].get()))
-            sim->initialize_simulator (this->get_simulator());
-          models[i]->parse_parameters(prm);
-          // All models will need to compute all quantities, so do so
-          this->model_dependence.viscosity |= models[i]->get_model_dependence().viscosity;
-          this->model_dependence.density |= models[i]->get_model_dependence().density;
-          this->model_dependence.compressibility |= models[i]->get_model_dependence().compressibility;
-          this->model_dependence.specific_heat |= models[i]->get_model_dependence().specific_heat;
-          this->model_dependence.thermal_conductivity |= models[i]->get_model_dependence().thermal_conductivity;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    Compositing<dim>::
-    is_compressible () const
-    {
-      const unsigned int ind = model_property_map.find(Property::compressibility)->second;
-      return models[ind]->is_compressible();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Compositing,
-                                   "compositing",
-                                   "The ``compositing'' Material model selects material model properties from a "
-                                   "given set of other material models, and is intended to make mixing different "
-                                   "material models easier. This is useful, for example, when wanting to "
-                                   "use the melting parameterization of the ``melt simple'' model (which has "
-                                   "a relatively simple viscosity model that only allows for a "
-                                   "temperature- but not strain rate-dependent viscosity) with a more "
-                                   "realistic viscosity model such as that provided by the "
-                                   "``diffusion dislocation'' model."
-                                   "\n\n"
-                                   "Specifically, this material model works by allowing to specify "
-                                   "the name of another material model for each coefficient that material "
-                                   "models are asked for (such as the viscosity, density, etc.). Whenever "
-                                   "the material model is asked for the values of coefficients, it then "
-                                   "evaluates all of the ``base models'' that were listed for the various "
-                                   "coefficients, and copies the values returned by these base models "
-                                   "into the output structure."
-                                   "\n\n"
-                                   "The implementation of this material model is somewhat expensive "
-                                   "because it has to evaluate all material coefficients of all underlying "
-                                   "material models. Consequently, if performance of assembly and postprocessing "
-                                   "is important, then implementing a separate material model is "
-                                   "a better choice than using this material model."
-                                  )
-  }
-}
diff --git a/source/material_model/composition_reaction.cc.bak b/source/material_model/composition_reaction.cc.bak
deleted file mode 100644
index 71f4fdd01ce..00000000000
--- a/source/material_model/composition_reaction.cc.bak
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/composition_reaction.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    CompositionReaction<dim>::
-    evaluate(const MaterialModelInputs<dim> &in,
-             MaterialModelOutputs<dim> &out) const
-    {
-      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
-
-      // The Composition reaction model has up to two compositional fields (plus one background field)
-      // that can influence the density
-      const unsigned int n_compositions_for_eos = std::min(this->n_compositional_fields()+1, 3u);
-      EquationOfStateOutputs<dim> eos_outputs (n_compositions_for_eos);
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double temperature = in.temperature[i];
-          const std::vector<double> &composition = in.composition[i];
-          const double delta_temp = temperature-reference_T;
-          double temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/reference_T),1e2),1e-2);
-
-          if (std::isnan(temperature_dependence))
-            temperature_dependence = 1.0;
-
-          switch (composition.size())
-            {
-              case 0:
-                out.viscosities[i] = temperature_dependence * eta;
-                break;
-              case 1:
-                // geometric interpolation
-                out.viscosities[i] = (pow(10, ((1-composition[0]) * log10(eta*temperature_dependence)
-                                               + composition[0] * log10(eta*composition_viscosity_prefactor_1*temperature_dependence))));
-                break;
-              default:
-                out.viscosities[i] = (pow(10, ((1 - 0.5*composition[0] - 0.5*composition[1]) * log10(eta*temperature_dependence)
-                                               + 0.5 * composition[0] * log10(eta*composition_viscosity_prefactor_1*temperature_dependence)
-                                               + 0.5 * composition[1] * log10(eta*composition_viscosity_prefactor_2*temperature_dependence))));
-                break;
-            }
-
-          equation_of_state.evaluate(in, i, eos_outputs);
-
-          std::vector<double> volume_fractions (n_compositions_for_eos, 1.0);
-          for (unsigned int c=0; c<n_compositions_for_eos-1; ++c)
-            {
-              volume_fractions[c+1] = std::max(0.0, in.composition[i][c]);
-              volume_fractions[0] -= volume_fractions[c+1];
-            }
-
-          out.densities[i] = MaterialUtilities::average_value(volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
-
-
-          const double depth = this->get_geometry_model().depth(in.position[i]);
-          for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-            {
-              double delta_C = 0.0;
-              switch (c)
-                {
-                  case 0:
-                    if (depth < reaction_depth) delta_C = -composition[0];
-                    break;
-                  case 1:
-                    if (depth < reaction_depth) delta_C = composition[0];
-                    break;
-                  default:
-                    delta_C = 0.0;
-                    break;
-                }
-              out.reaction_terms[i][c] = delta_C;
-
-              // Fill reaction rate outputs instead of the reaction terms if we use operator splitting
-              // (and then set the latter to zero).
-              if (this->get_parameters().use_operator_splitting)
-                {
-                  if (reaction_rate_out != nullptr)
-                    reaction_rate_out->reaction_rates[i][c] = (this->get_timestep_number() > 0
-                                                               ?
-                                                               out.reaction_terms[i][c] / this->get_timestep()
-                                                               :
-                                                               0.0);
-                  out.reaction_terms[i][c] = 0.0;
-                }
-            }
-
-          out.thermal_expansion_coefficients[i] = eos_outputs.thermal_expansion_coefficients[0];
-          out.specific_heat[i] = eos_outputs.specific_heat_capacities[0];
-          out.thermal_conductivities[i] = k_value;
-          out.compressibilities[i] = eos_outputs.compressibilities[0];
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    CompositionReaction<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    void
-    CompositionReaction<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Composition reaction model");
-        {
-          EquationOfState::LinearizedIncompressible<dim>::declare_parameters (prm, 2);
-
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Viscosity", "5e24",
-                             Patterns::Double (0.),
-                             "The value of the constant viscosity. Units: \\si{\\kilogram\\per\\meter\\per\\second}.");
-          prm.declare_entry ("Composition viscosity prefactor 1", "1.0",
-                             Patterns::Double (0.),
-                             "A linear dependency of viscosity on the first compositional field. "
-                             "Dimensionless prefactor. With a value of 1.0 (the default) the "
-                             "viscosity does not depend on the composition.");
-          prm.declare_entry ("Composition viscosity prefactor 2", "1.0",
-                             Patterns::Double (0.),
-                             "A linear dependency of viscosity on the second compositional field. "
-                             "Dimensionless prefactor. With a value of 1.0 (the default) the "
-                             "viscosity does not depend on the composition.");
-          prm.declare_entry ("Thermal viscosity exponent", "0.0",
-                             Patterns::Double (0.),
-                             "The temperature dependence of viscosity. Dimensionless exponent.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reaction depth", "0.",
-                             Patterns::Double (0.),
-                             "Above this depth the compositional fields react: "
-                             "The first field gets converted to the second field. "
-                             "Units: \\si{\\meter}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    CompositionReaction<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Composition reaction model");
-        {
-          equation_of_state.parse_parameters (prm, 2);
-
-          reference_T                = prm.get_double ("Reference temperature");
-          eta                        = prm.get_double ("Viscosity");
-          composition_viscosity_prefactor_1 = prm.get_double ("Composition viscosity prefactor 1");
-          composition_viscosity_prefactor_2 = prm.get_double ("Composition viscosity prefactor 2");
-          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
-          k_value                    = prm.get_double ("Thermal conductivity");
-          reaction_depth             = prm.get_double ("Reaction depth");
-
-          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
-            AssertThrow(false, ExcMessage("Error: Material model composition reaction with Thermal viscosity exponent can not have reference_T=0."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-
-      if (thermal_viscosity_exponent != 0)
-        this->model_dependence.viscosity |= NonlinearDependence::temperature;
-      if ((composition_viscosity_prefactor_1 != 1.0) ||
-          (composition_viscosity_prefactor_2 != 1.0))
-        this->model_dependence.viscosity |= NonlinearDependence::compositional_fields;
-    }
-
-
-    template <int dim>
-    void
-    CompositionReaction<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (this->get_parameters().use_operator_splitting
-          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points,
-                                                                        this->n_compositional_fields()));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(CompositionReaction,
-                                   "composition reaction",
-                                   "A material model that behaves in the same way as "
-                                   "the simple material model, but includes two compositional "
-                                   "fields and a reaction between them. Above a depth given "
-                                   "in the input file, the first fields gets converted to the "
-                                   "second field. ")
-  }
-}
diff --git a/source/material_model/depth_dependent.cc.bak b/source/material_model/depth_dependent.cc.bak
deleted file mode 100644
index 9efd80cd564..00000000000
--- a/source/material_model/depth_dependent.cc.bak
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/depth_dependent.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <boost/lexical_cast.hpp>
-
-#include <limits>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    DepthDependent<dim>::initialize()
-    {
-      base_model->initialize();
-    }
-
-
-
-    template <int dim>
-    void
-    DepthDependent<dim>::update()
-    {
-      base_model->update();
-
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        viscosity_function.set_time (this->get_time() / year_in_seconds);
-      else
-        viscosity_function.set_time (this->get_time());
-    }
-
-
-
-    template <int dim>
-    bool
-    DepthDependent<dim>::
-    is_compressible () const
-    {
-      return base_model->is_compressible();
-    }
-
-
-
-    template <int dim>
-    double
-    DepthDependent<dim>::calculate_depth_dependent_prefactor(const double &depth) const
-    {
-      if (viscosity_source == file)
-        {
-          return depth_dependent_rheology->compute_viscosity(depth) / reference_viscosity;
-        }
-      else if (viscosity_source == function)
-        {
-          const Point<1> dpoint(depth);
-          const double viscosity = viscosity_function.value(dpoint);
-          Assert (viscosity > 0.0, ExcMessage("Viscosity depth function should be larger than zero"));
-          return viscosity / reference_viscosity;
-        }
-      else if (viscosity_source == list)
-        {
-          const unsigned int nlayers = depth_values.size()-1;
-          unsigned int i=0;
-          /* find the layer containing the specified depth and return the corresponding viscosity */
-          while (depth > depth_values[i] && i<nlayers)
-            {
-              /* increment i until depth is above base of layer i */
-              ++i;
-            }
-
-          return viscosity_values[i] / reference_viscosity;
-        }
-      else if (viscosity_source == none)
-        {
-          return 1.0;
-        }
-      else
-        {
-          Assert(false, ExcMessage("Invalid method for viscosity depth dependence"));
-          return 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    DepthDependent<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                                  typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      base_model->evaluate(in,out);
-      if (in.requests_property(MaterialProperties::viscosity))
-        {
-          // Scale the base model viscosity value by the depth dependent prefactor
-          for (unsigned int i=0; i < out.n_evaluation_points(); ++i)
-            {
-              const double depth = this->get_geometry_model().depth(in.position[i]);
-              out.viscosities[i] *= calculate_depth_dependent_prefactor(depth);
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    DepthDependent<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        // Depth-dependent parameters from the rheology plugin
-        Rheology::AsciiDepthProfile<dim>::declare_parameters(prm,
-                                                             "Depth dependent model");
-
-        prm.enter_subsection("Depth dependent model");
-        {
-          prm.declare_entry("Base model","simple",
-                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
-                            "The name of a material model that will be modified by a depth "
-                            "dependent viscosity. Valid values for this parameter "
-                            "are the names of models that are also valid for the "
-                            "``Material models/Model name'' parameter. See the documentation for "
-                            "that for more information.");
-          prm.declare_entry ("Depth dependence method", "None",
-                             Patterns::Selection("Function|File|List|None"),
-                             "Method that is used to specify how the viscosity should vary with depth.");
-          prm.declare_entry("Depth list", "", Patterns::List(Patterns::Double ()),
-                            "A comma-separated list of depth values for use with the ``List'' "
-                            "``Depth dependence method''. The list must be provided in order of "
-                            "increasing depth, and the last value must be greater than or equal to "
-                            "the maximal depth of the model. The depth list is interpreted as a layered "
-                            "viscosity structure and the depth values specify the maximum depths of each "
-                            "layer.");
-          prm.declare_entry("Viscosity list", "", Patterns::List(Patterns::Double ()),
-                            "A comma-separated list of viscosity values, corresponding to the depth values "
-                            "provided in ``Depth list''. The number of viscosity values specified here must "
-                            "be the same as the number of depths provided in ``Depth list''.");
-
-          prm.declare_entry ("Reference viscosity",
-                             boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
-                             Patterns::Double (0.),
-                             "The value of the constant reference viscosity $\\eta_r$ that is used to scale "
-                             "the non-dimensional depth-dependent viscosity prefactor. "
-                             "Units: \\si{\\pascal\\second}.");
-
-          prm.declare_alias ("Data file name","Viscosity depth file");
-
-          prm.enter_subsection("Viscosity depth function");
-          {
-            Functions::ParsedFunction<1>::declare_parameters(prm,1);
-            prm.declare_entry("Function expression","1.0e21");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    DepthDependent<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Depth dependent model");
-        {
-          AssertThrow( prm.get("Base model") != "depth dependent",
-                       ExcMessage("You may not use ``depth dependent'' as the base model for "
-                                  "a depth-dependent model.") );
-
-          // create the base model and initialize its SimulatorAccess base
-          // class; it will get a chance to read its parameters below after we
-          // leave the current section
-          base_model = create_material_model<dim>(prm.get("Base model"));
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
-            sim->initialize_simulator (this->get_simulator());
-
-          if (prm.get("Depth dependence method") == "Function")
-            viscosity_source = function;
-          else if (prm.get("Depth dependence method") == "File")
-            viscosity_source = file;
-          else if (prm.get("Depth dependence method") == "List")
-            viscosity_source = list;
-          else if (prm.get("Depth dependence method") == "None")
-            viscosity_source = none;
-          else
-            {
-              AssertThrow(false, ExcMessage("Unknown method for depth dependence."));
-            }
-
-          depth_values     = Utilities::string_to_double(Utilities::split_string_list(prm.get("Depth list")));
-          viscosity_values = Utilities::string_to_double(Utilities::split_string_list(prm.get("Viscosity list")));
-          /*
-           * check sanity of viscosity list values and depth list values input
-           */
-          if (viscosity_source == list)
-            {
-              /* check that length of depth values and viscosity values are compatible */
-              AssertThrow( depth_values.size() == viscosity_values.size() ,
-                           ExcMessage("Depth list must be same size as Viscosity list"));
-              /* check that list is in ascending order */
-              for (unsigned int i=1; i<depth_values.size(); ++i)
-                AssertThrow(depth_values[i] > depth_values[i-1],
-                            ExcMessage("Viscosity depth values must be strictly ascending"));
-              /* check that last layer includes base of model */
-              AssertThrow( *(depth_values.end()-1) >= this->get_geometry_model().maximal_depth(),
-                           ExcMessage("Last value in Depth list must be greater than or equal to maximal depth of domain"));
-            }
-
-          prm.enter_subsection("Viscosity depth function");
-          {
-            try
-              {
-                viscosity_function.parse_parameters(prm);
-              }
-            catch (...)
-              {
-                std::cerr << "FunctionParser failed to parse\n"
-                          << "\t Viscosity depth function\n"
-                          << "with expression \n"
-                          << "\t' " << prm.get("Function expression") << "'";
-                throw;
-              }
-          }
-          prm.leave_subsection();
-
-          reference_viscosity = prm.get_double("Reference viscosity");
-
-          AssertThrow(reference_viscosity != std::numeric_limits<double>::max(),
-                      ExcMessage("You have to set a reference viscosity for the depth dependent model."));
-        }
-        prm.leave_subsection();
-
-        if (viscosity_source == file)
-          {
-            depth_dependent_rheology = std::make_unique<Rheology::AsciiDepthProfile<dim>>();
-            depth_dependent_rheology->initialize_simulator (this->get_simulator());
-            depth_dependent_rheology->parse_parameters(prm, "Depth dependent model");
-            depth_dependent_rheology->initialize();
-          }
-      }
-      prm.leave_subsection();
-
-      /* After parsing the parameters for depth dependent, it is essential to parse
-      parameters related to the base model. */
-      base_model->parse_parameters(prm);
-      this->model_dependence = base_model->get_model_dependence();
-    }
-
-
-
-    template <int dim>
-    void
-    DepthDependent<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      base_model->create_additional_named_outputs(out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(DepthDependent,
-                                   "depth dependent",
-                                   "The ``depth dependent'' Material model applies a depth-dependent scaling "
-                                   "to the viscosity of any other available material models. In other words, it "
-                                   "is a ``compositing material model''."
-                                   "\n\n"
-                                   "Parameters related to the depth dependent model are read from a subsection "
-                                   "``Material model/Depth dependent model''. "
-                                   "The user must specify a ``Base model'' from which material properties are "
-                                   "derived. Currently the depth dependent model only allows depth dependence of "
-                                   "viscosity - other material properties are taken from the ``Base model''. "
-                                   "Viscosity $\\eta$ at depth $z$ is calculated according to:"
-                                   "$ \\eta(z,p,T,X,...) = \\eta(z) \\eta_b(p,T,X,..)/\\eta_{r}$ "
-                                   "where $\\eta(z)$ is the depth-dependence specified by the depth dependent "
-                                   "model, $\\eta_b(p,T,X,...)$ is the viscosity calculated from the base model, "
-                                   "and $\\eta_{r}$ is the reference viscosity. "
-                                   "In addition to the specification of the ``Base model'', the user must specify "
-                                   "the method to be used to calculate the depth-dependent viscosity $\\eta(z)$ as "
-                                   "``Material model/Depth dependent model/Depth dependence method'', which can be "
-                                   "chosen among ``None|Function|File|List''. Each method and the associated parameters "
-                                   "are as follows:"
-                                   "\n"
-                                   "\n"
-                                   "``Function'': read a user-specified parsed function from the input file in a "
-                                   "subsection ``Material model/Depth dependent model/Viscosity depth function''. "
-                                   "By default, this function is uniformly equal to 1.0e21. Specifying a function "
-                                   "that returns a value less than or equal to 0.0 anywhere in the model domain will "
-                                   "produce an error. "
-                                   "\n"
-                                   "\n"
-                                   "``File'': read a user-specified file containing viscosity values at specified "
-                                   "depths. The file containing depth-dependent viscosities is read from a "
-                                   "directory specified by the user as "
-                                   "``Material model/Depth dependent model/Data directory'', from a file with name "
-                                   "specified as ``Material model/Depth dependent model/Viscosity depth file''. "
-                                   "The format of this file is ascii text and contains two columns with one header line:"
-                                   "\n"
-                                   "\n"
-                                   "example Viscosity depth file:\\\\"
-                                   "Depth (m)    Viscosity (Pa-s)\\\\"
-                                   "0.0000000e+00     1.0000000e+21\\\\"
-                                   "6.7000000e+05     1.0000000e+22\\\\"
-                                   "\n"
-                                   "\n"
-                                   "Viscosity is interpolated from this file using linear interpolation. "
-                                   "``None'': no depth-dependence. Viscosity is taken directly from ``Base model''"
-                                   "\n"
-                                   "\n"
-                                   "``List:'': read a comma-separated list of depth values corresponding to the maximum "
-                                   "depths of layers having constant depth-dependence $\\eta(z)$. The layers must be "
-                                   "specified in order of increasing depth, and the last layer in the list must have a depth "
-                                   "greater than or equal to the maximal depth of the model. The list of layer depths is "
-                                   "specified as ``Material model/Depth dependent model/Depth list'' and the corresponding "
-                                   "list of layer viscosities is specified as "
-                                   "``Material model/Depth dependent model/Viscosity list''"
-                                  )
-  }
-}
diff --git a/source/material_model/diffusion_dislocation.cc.bak b/source/material_model/diffusion_dislocation.cc.bak
deleted file mode 100644
index 70c3147579b..00000000000
--- a/source/material_model/diffusion_dislocation.cc.bak
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/diffusion_dislocation.h>
-#include <aspect/utilities.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    DiffusionDislocation<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
-        {
-          // const Point<dim> position = in.position[i];
-          const double temperature = in.temperature[i];
-          const double pressure= in.pressure[i];
-          const std::vector<double> composition = in.composition[i];
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(composition,
-                                                       this->introspection().chemical_composition_field_indices());
-
-          // densities
-          double density = 0.0;
-          for (unsigned int j=0; j < volume_fractions.size(); ++j)
-            {
-              // not strictly correct if thermal expansivities are different, since we are interpreting
-              // these compositions as volume fractions, but the error introduced should not be too bad.
-              const double temperature_factor= (1.0 - thermal_expansivities[j] * (temperature - reference_T));
-              density += volume_fractions[j] * densities[j] * temperature_factor;
-            }
-
-          // thermal expansivities
-          double thermal_expansivity = 0.0;
-          for (unsigned int j=0; j < volume_fractions.size(); ++j)
-            thermal_expansivity += volume_fractions[j] * thermal_expansivities[j];
-
-          // calculate effective viscosity
-          if (in.requests_property(MaterialProperties::viscosity))
-            {
-              Assert(std::isfinite(in.strain_rate[i].norm()),
-                     ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                                "not filled by the caller."));
-              out.viscosities[i] = diffusion_dislocation.compute_viscosity(pressure, temperature, volume_fractions, in.strain_rate[i]);
-            }
-
-          out.densities[i] = density;
-          out.thermal_expansion_coefficients[i] = thermal_expansivity;
-          // Specific heat at the given positions.
-          out.specific_heat[i] = heat_capacity;
-          // Thermal conductivity at the given positions. If the temperature equation uses
-          // the reference density profile formulation, use the reference density to
-          // calculate thermal conductivity. Otherwise, use the real density. If the adiabatic
-          // conditions are not yet initialized, the real density will still be used.
-          if (this->get_parameters().formulation_temperature_equation ==
-              Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile &&
-              this->get_adiabatic_conditions().is_initialized())
-            out.thermal_conductivities[i] = thermal_diffusivity * heat_capacity *
-                                            this->get_adiabatic_conditions().density(in.position[i]);
-          else
-            out.thermal_conductivities[i] = thermal_diffusivity * heat_capacity * density;
-          // Compressibility at the given positions.
-          // The compressibility is given as
-          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
-          out.compressibilities[i] = 0.0;
-          // Pressure derivative of entropy at the given positions.
-          out.entropy_derivative_pressure[i] = 0.0;
-          // Temperature derivative of entropy at the given positions.
-          out.entropy_derivative_temperature[i] = 0.0;
-          // Change in composition due to chemical reactions at the
-          // given positions. The term reaction_terms[i][c] is the
-          // change in compositional field c at point i.
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-    template <int dim>
-    bool
-    DiffusionDislocation<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    DiffusionDislocation<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Diffusion dislocation");
-        {
-          Rheology::DiffusionDislocation<dim>::declare_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    DiffusionDislocation<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Diffusion dislocation");
-        {
-          reference_T = prm.get_double("Reference temperature");
-
-          // Retrieve the list of composition names
-          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-          // Establish that a background field is required here
-          compositional_field_names.insert(compositional_field_names.begin(),"background");
-
-          // Make options file for parsing maps to double arrays
-          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-          // Establish that a background field is required here
-          chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-          Utilities::MapParsing::Options options(chemical_field_names, "Densities");
-          options.list_of_allowed_keys = compositional_field_names;
-
-          densities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Densities"),
-                                                                        options);
-
-          options.property_name = "Thermal expansivities";
-          thermal_expansivities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Thermal expansivities"),
-                                                                                    options);
-
-          // Phenomenological parameters
-          thermal_diffusivity = prm.get_double("Thermal diffusivity");
-          heat_capacity = prm.get_double("Heat capacity");
-
-          diffusion_dislocation.initialize_simulator (this->get_simulator());
-          diffusion_dislocation.parse_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(DiffusionDislocation,
-                                   "diffusion dislocation",
-                                   "An implementation of a viscous rheology including diffusion "
-                                   "and dislocation creep. "
-                                   "Compositional fields can each be assigned individual "
-                                   "activation energies, reference densities, thermal expansivities, "
-                                   "and stress exponents. The effective viscosity is defined as "
-                                   "\n\n"
-                                   "$\\eta_{\\text{eff}} = \\left(\\frac{1}{\\eta_{\\text{eff}}^\\text{diff}}+ "
-                                   "\\frac{1}{\\eta_{\\text{eff}}^\\text{dis}}\\right)^{-1}$ "
-                                   "where "
-                                   "$\\eta_{\\text{i}} = \\frac{1}{2} A^{-\\frac{1}{n_i}} d^\\frac{m_i}{n_i} "
-                                   "\\dot{\\varepsilon_i}^{\\frac{1-n_i}{n_i}} "
-                                   "\\exp\\left(\\frac{E_i^\\ast + PV_i^\\ast}{n_iRT}\\right)$ "
-                                   "\n\n"
-                                   "where $d$ is grain size, $i$ corresponds to diffusion or dislocation creep, "
-                                   "$\\dot{\\varepsilon}$ is the square root of the second invariant of the "
-                                   "strain rate tensor, $R$ is the gas constant, $T$ is temperature, "
-                                   "and $P$ is pressure. "
-                                   "$A_i$ are prefactors, $n_i$ and $m_i$ are stress and grain size exponents "
-                                   "$E_i$ are the activation energies and $V_i$ are the activation volumes. "
-                                   "\n\n"
-                                   "This form of the viscosity equation is commonly used in geodynamic simulations "
-                                   "See, for example, Billen and Hirth (2007), G3, 8, Q08012. Significantly, "
-                                   "other studies may use slightly different forms of the viscosity equation "
-                                   "leading to variations in how specific terms are defined or combined. For "
-                                   "example, the grain size exponent should always be positive in the diffusion "
-                                   "viscosity equation used here, while other studies place the grain size term "
-                                   "in the denominator and invert the sign of the grain size exponent. When "
-                                   "examining previous work, one should carefully check how the viscous "
-                                   "prefactor and grain size terms are defined. "
-                                   " \n\n"
-                                   "The ratio of diffusion to dislocation strain rate is found by Newton's "
-                                   "method, iterating to find the stress which satisfies the above equations. "
-                                   "The value for the components of this formula and additional "
-                                   "parameters are read from the parameter file in subsection "
-                                   "'Material model/DiffusionDislocation'.")
-  }
-}
diff --git a/source/material_model/drucker_prager.cc.bak b/source/material_model/drucker_prager.cc.bak
deleted file mode 100644
index e59c6808b7a..00000000000
--- a/source/material_model/drucker_prager.cc.bak
+++ /dev/null
@@ -1,323 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/drucker_prager.h>
-#include <aspect/utilities.h>
-#include <aspect/newton.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    DruckerPrager<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // set up additional output for the derivatives
-      MaterialModel::MaterialModelDerivatives<dim> *derivatives;
-      derivatives = out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
-
-      EquationOfStateOutputs<dim> eos_outputs (1);
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          // To avoid negative yield strengths and eventually viscosities,
-          // we make sure the pressure is not negative
-          const double pressure=std::max(in.pressure[i],0.0);
-
-          // calculate effective viscosity
-          if (in.requests_property(MaterialProperties::viscosity))
-            {
-              Assert(std::isfinite(in.strain_rate[i].norm()),
-                     ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                                "not filled by the caller."));
-              const SymmetricTensor<2,dim> strain_rate_deviator = deviator(in.strain_rate[i]);
-
-              // For the very first time this function is called
-              // (the first iteration of the first timestep), this function is called
-              // with a zero input strain rate. We provide a representative reference
-              // strain rate for this case, which avoids division by zero and produces
-              // a representative first guess of the viscosities.
-              //
-              // In later iterations and timesteps we calculate the second moment
-              // invariant of the deviatoric strain rate tensor.
-              // This is equal to the negative of the second principle
-              // invariant of the deviatoric strain rate (calculated with the function second_invariant),
-              // as shown in Appendix A of Zienkiewicz and Taylor (Solid Mechanics, 2000).
-              //
-              // The negative of the second principle invariant is equal to 0.5 e_dot_dev_ij e_dot_dev_ji,
-              // where e_dot_dev is the deviatoric strain rate tensor. The square root of this quantity
-              // gives the common definition of effective strain rate.
-              const double edot_ii_strict = (this->simulator_is_past_initialization() == false
-                                             ?
-                                             // no simulator object available via
-                                             // the SimulatorAccess base class, or the
-                                             // Simulator itself has not been completely
-                                             // initialized. This might mean that we are
-                                             // in a unit test, or at least that we can't
-                                             // rely on any simulator information
-                                             std::fabs(second_invariant(strain_rate_deviator))
-                                             :
-                                             // simulator object is available, but we need to treat the
-                                             // first time step separately
-                                             ((this->get_timestep_number() == 0)
-                                              &&
-                                              (in.strain_rate[i].norm() <= std::numeric_limits<double>::min())
-                                              ?
-                                              reference_strain_rate * reference_strain_rate
-                                              :
-                                              std::fabs(second_invariant(strain_rate_deviator))));
-
-              const double strain_rate_effective = edot_ii_strict;
-
-              // In later time steps, we still need to care about cases of very small
-              // strain rates. We expect the viscosity to approach the maximum_viscosity
-              // in these cases. This check prevents a division-by-zero.
-              if (std::sqrt(strain_rate_effective) <= std::numeric_limits<double>::min())
-                {
-                  out.viscosities[i] = maximum_viscosity;
-
-                  if (derivatives != nullptr)
-                    {
-                      derivatives->viscosity_derivative_wrt_strain_rate[i] = 0.0;
-                      derivatives->viscosity_derivative_wrt_pressure[i] = 0.0;
-                    }
-                }
-              else
-                {
-                  // plasticity
-                  const double eta_plastic = drucker_prager_plasticity.compute_viscosity(cohesion,
-                                                                                         angle_of_internal_friction,
-                                                                                         pressure,
-                                                                                         std::sqrt(strain_rate_effective),
-                                                                                         std::numeric_limits<double>::infinity());
-
-                  const double viscosity_pressure_derivative = drucker_prager_plasticity.compute_derivative(angle_of_internal_friction,std::sqrt(strain_rate_effective));
-
-                  // Cut off the viscosity between a minimum and maximum value to avoid
-                  // a numerically unfavourable large viscosity range.
-                  const double effective_viscosity = 1.0 / ( ( 1.0 / ( eta_plastic + minimum_viscosity ) ) + ( 1.0 / maximum_viscosity ) );
-
-                  Assert(dealii::numbers::is_finite(effective_viscosity), ExcMessage ("Error: Viscosity is not finite."));
-
-                  out.viscosities[i] = effective_viscosity;
-
-                  Assert(dealii::numbers::is_finite(out.viscosities[i]),
-                         ExcMessage ("Error: Averaged viscosity is not finite."));
-
-                  if (derivatives != nullptr)
-                    {
-                      const double averaging_factor = maximum_viscosity * maximum_viscosity
-                                                      / ((eta_plastic + minimum_viscosity + maximum_viscosity) * (eta_plastic + minimum_viscosity + maximum_viscosity));
-                      const SymmetricTensor<2,dim> effective_viscosity_strain_rate_derivatives
-                        = -0.5 * averaging_factor * (eta_plastic / edot_ii_strict) * strain_rate_deviator;
-                      const double effective_viscosity_pressure_derivatives = averaging_factor * viscosity_pressure_derivative;
-
-                      derivatives->viscosity_derivative_wrt_strain_rate[i] = deviator_tensor<dim>() * effective_viscosity_strain_rate_derivatives;
-
-                      derivatives->viscosity_derivative_wrt_pressure[i] = effective_viscosity_pressure_derivatives;
-
-                      Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_pressure[i]),
-                             ExcMessage ("Error: Averaged viscosity_derivative_wrt_pressure is not finite."));
-                      for (int x = 0; x < dim; ++x)
-                        for (int y = 0; y < dim; ++y)
-                          Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]),
-                                 ExcMessage ("Error: Averaged viscosity_derivative_wrt_strain_rate is not finite."));
-
-                    }
-                }
-            }
-
-          equation_of_state.evaluate(in, i, eos_outputs);
-
-          out.densities[i] = eos_outputs.densities[0];
-          out.thermal_expansion_coefficients[i] = eos_outputs.thermal_expansion_coefficients[0];
-          out.specific_heat[i] = eos_outputs.specific_heat_capacities[0];
-          out.thermal_conductivities[i] = thermal_conductivities;
-          out.compressibilities[i] = eos_outputs.compressibilities[0];
-          out.entropy_derivative_pressure[i] = eos_outputs.entropy_derivative_pressure[0];
-          out.entropy_derivative_temperature[i] = eos_outputs.entropy_derivative_temperature[0];
-
-          for (unsigned int c=0; c < in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    DruckerPrager<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    void
-    DruckerPrager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Drucker Prager");
-        {
-          EquationOfState::LinearizedIncompressible<dim>::declare_parameters (prm);
-
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. The reference temperature is used "
-                             "in the density calculation. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.enter_subsection ("Viscosity");
-          {
-
-            prm.declare_entry ("Minimum viscosity", "1e19",
-                               Patterns::Double (0.),
-                               "The value of the minimum viscosity cutoff $\\eta_min$. Units: \\si{\\pascal\\second}.");
-            prm.declare_entry ("Maximum viscosity", "1e24",
-                               Patterns::Double (0.),
-                               "The value of the maximum viscosity cutoff $\\eta_max$. Units: \\si{\\pascal\\second}.");
-            prm.declare_entry ("Reference strain rate", "1e-15",
-                               Patterns::Double (0.),
-                               "The value of the initial strain rate prescribed during the "
-                               "first nonlinear iteration $\\dot{\\epsilon}_ref$. Units: \\si{\\per\\second}.");
-            prm.declare_entry ("Angle of internal friction", "0.",
-                               Patterns::Double (0.),
-                               "The value of the angle of internal friction $\\phi$. "
-                               "For a value of zero, in 2d the von Mises "
-                               "criterion is retrieved. Angles higher than 30 degrees are "
-                               "harder to solve numerically. Units: degrees.");
-            prm.declare_entry ("Cohesion", "2e7",
-                               Patterns::Double (0.),
-                               "The value of the cohesion $C$. Units: \\si{\\pascal}.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    DruckerPrager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Drucker Prager");
-        {
-          equation_of_state.parse_parameters (prm);
-
-          reference_T                = prm.get_double ("Reference temperature");
-          thermal_conductivities     = prm.get_double ("Thermal conductivity");
-          prm.enter_subsection ("Viscosity");
-          {
-            minimum_viscosity          = prm.get_double ("Minimum viscosity");
-            maximum_viscosity          = prm.get_double ("Maximum viscosity");
-            reference_strain_rate      = prm.get_double ("Reference strain rate");
-            // Convert degrees to radians
-            angle_of_internal_friction = prm.get_double ("Angle of internal friction") * constants::degree_to_radians;
-            cohesion                   = prm.get_double ("Cohesion");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-      this->model_dependence.viscosity = NonlinearDependence::strain_rate;
-      this->model_dependence.density = NonlinearDependence::temperature;
-
-      if (angle_of_internal_friction==0.0)
-        this->model_dependence.viscosity |= NonlinearDependence::pressure;
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(DruckerPrager,
-                                   "drucker prager",
-                                   "A material model that has constant values "
-                                   "for all coefficients but the density and viscosity. The defaults for all "
-                                   "coefficients are chosen to be similar to what is believed to be correct "
-                                   "for Earth's mantle. All of the values that define this model are read "
-                                   "from a section ``Material model/Drucker Prager'' in the input file, see "
-                                   "Section~\\ref{parameters:Material_20model/Drucker_20Prager}. "
-                                   "Note that the model does not take into account any dependencies of "
-                                   "material properties on compositional fields. "
-                                   "\n\n"
-                                   "The viscosity is computed according to the Drucker Prager frictional "
-                                   "plasticity criterion (non-associative) based on a user-defined "
-                                   "internal friction angle $\\phi$ and cohesion $C$. In 3d: "
-                                   " $\\sigma_y = \\frac{6 C \\cos(\\phi)}{\\sqrt{3} (3+\\sin(\\phi))} + "
-                                   "\\frac{6 P \\sin(\\phi)}{\\sqrt{3} (3+\\sin(\\phi))}$, "
-                                   "where $P$ is the pressure. "
-                                   "See for example Zienkiewicz, O. C., Humpheson, C. and Lewis, R. W. (1975), "
-                                   "G\\'{e}otechnique 25, No. 4, 671-689. "
-                                   "With this formulation we circumscribe instead of inscribe the Mohr Coulomb "
-                                   "yield surface. "
-                                   "In 2d the Drucker Prager yield surface is the same "
-                                   "as the Mohr Coulomb surface: "
-                                   " $\\sigma_y = P \\sin(\\phi) + C \\cos(\\phi)$. "
-                                   "Note that in 2d for $\\phi=0$, these criteria "
-                                   "revert to the von Mises criterion (no pressure dependence). "
-                                   "See for example \\cite{thieulot:2011}. "
-                                   "\n\n"
-                                   "Note that we enforce the pressure to be positive to prevent negative "
-                                   "yield strengths and viscosities. "
-                                   "\n\n"
-                                   "We then use the computed yield strength to scale back the viscosity on "
-                                   "to the yield surface using the Viscosity Rescaling Method described in "
-                                   "Kachanov, L. M. (2004), Fundamentals of the Theory of Plasticity, "
-                                   "Dover Publications, Inc. (Not Radial Return.)"
-                                   "A similar implementation can be found in GALE "
-                                   "(<https://geodynamics.org/resources/gale>). "
-                                   "\n\n"
-                                   "To avoid numerically unfavourably large (or even negative) viscosity ranges, "
-                                   "we cut off the viscosity with a user-defined minimum and maximum viscosity: "
-                                   "$\\eta_{eff} = \\frac{1}{\\frac{1}{\\eta_{min} + \\eta}+ "
-                                   "\\frac{1}{\\eta_{max}}}$. "
-                                   "\n\n"
-                                   "Note that this model uses the formulation that assumes an incompressible "
-                                   "medium despite the fact that the density follows the law "
-                                   "$\\rho(T)=\\rho_0(1-\\beta(T-T_{\\text{ref}}))$. ")
-  }
-}
diff --git a/source/material_model/entropy_model.cc.bak b/source/material_model/entropy_model.cc.bak
deleted file mode 100644
index 9a4089a3358..00000000000
--- a/source/material_model/entropy_model.cc.bak
+++ /dev/null
@@ -1,577 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/entropy_model.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/table.h>
-#include <fstream>
-#include <iostream>
-#include <aspect/material_model/rheology/visco_plastic.h>
-#include <aspect/material_model/steinberger.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace
-    {
-      template <int dim>
-      bool solver_scheme_is_supported(const Parameters<dim> &parameters)
-      {
-        // If we solve advection equations, we need to iterate them, because this material
-        // models splits temperature diffusion from entropy advection.
-        switch (parameters.nonlinear_solver)
-          {
-            case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_defect_correction_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Newton_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::no_Advection_no_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_defect_correction_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::no_Advection_single_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::first_timestep_only_single_Stokes:
-              return true;
-
-            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_single_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_defect_correction_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Newton_Stokes:
-            case Parameters<dim>::NonlinearSolver::Kind::single_Advection_no_Stokes:
-              return false;
-          }
-        Assert(false, ExcNotImplemented());
-        return false;
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    EntropyModel<dim>::initialize()
-    {
-      AssertThrow (this->get_parameters().formulation_mass_conservation ==
-                   Parameters<dim>::Formulation::MassConservation::projected_density_field,
-                   ExcMessage("The 'entropy model' material model was only tested with the "
-                              "'projected density field' approximation "
-                              "for the mass conservation equation, which is not selected."));
-
-      AssertThrow (this->introspection().composition_type_exists(CompositionalFieldDescription::Type::entropy),
-                   ExcMessage("The 'entropy model' material model requires the existence of a compositional field "
-                              "named 'entropy'. This field does not exist."));
-
-      AssertThrow(solver_scheme_is_supported(this->get_parameters()) == true,
-                  ExcMessage("The 'entropy model' material model requires the use of a solver scheme that "
-                             "iterates over the advection equations but a non iterating solver scheme was selected. "
-                             "Please check the consistency of your solver scheme."));
-
-      AssertThrow(material_file_names.size() == 1 || SimulatorAccess<dim>::get_end_time () == 0,
-                  ExcMessage("The 'entropy model' material model can only handle one composition, "
-                             "and can therefore only read one material lookup table."));
-
-
-
-      for (unsigned int i = 0; i < material_file_names.size(); ++i)
-        {
-          entropy_reader.push_back(std::make_unique<MaterialUtilities::Lookup::EntropyReader>());
-          entropy_reader[i]->initialize(this->get_mpi_communicator(), data_directory, material_file_names[i]);
-        }
-
-      lateral_viscosity_prefactor_lookup = std::make_unique<internal::LateralViscosityLookup>(data_directory+lateral_viscosity_file_name,
-                                           this->get_mpi_communicator());
-    }
-
-
-
-    template <int dim>
-    bool
-    EntropyModel<dim>::
-    is_compressible () const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    double
-    EntropyModel<dim>::
-    thermal_conductivity (const double temperature,
-                          const double pressure,
-                          const Point<dim> &position) const
-    {
-      if (conductivity_formulation == constant)
-        return thermal_conductivity_value;
-
-      else if (conductivity_formulation == p_T_dependent)
-        {
-          // Find the conductivity layer that corresponds to the depth of the evaluation point.
-          const double depth = this->get_geometry_model().depth(position);
-          unsigned int layer_index = std::distance(conductivity_transition_depths.begin(),
-                                                   std::lower_bound(conductivity_transition_depths.begin(),conductivity_transition_depths.end(), depth));
-
-          const double p_dependence = reference_thermal_conductivities[layer_index] + conductivity_pressure_dependencies[layer_index] * pressure;
-
-          // Make reasonably sure we will not compute any invalid values due to the temperature-dependence.
-          // Since both the temperature-dependence and the saturation time scale with (Tref/T), we have to
-          // make sure we can compute the square of this number. If the temperature is small enough to
-          // be close to yielding NaN values, the conductivity will be set to the maximum value anyway.
-          const double T = std::max(temperature, std::sqrt(std::numeric_limits<double>::min()) * conductivity_reference_temperatures[layer_index]);
-          const double T_dependence = std::pow(conductivity_reference_temperatures[layer_index] / T, conductivity_exponents[layer_index]);
-
-          // Function based on the theory of Roufosse and Klemens (1974) that accounts for saturation.
-          // For the Tosi formulation, the scaling should be zero so that this term is 1.
-          double saturation_function = 1.0;
-          if (1./T_dependence > 1.)
-            saturation_function = (1. - saturation_scaling[layer_index])
-                                  + saturation_scaling[layer_index] * (2./3. * std::sqrt(T_dependence) + 1./3. * 1./T_dependence);
-
-          return std::min(p_dependence * saturation_function * T_dependence, maximum_conductivity);
-        }
-      else
-        {
-          AssertThrow(false, ExcNotImplemented());
-          return numbers::signaling_nan<double>();
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    EntropyModel<dim>::evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                                MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      const unsigned int projected_density_index = this->introspection().compositional_index_for_name("density_field");
-      //TODO : need to make it work for more than one field
-      const std::vector<unsigned int> &entropy_indices = this->introspection().get_indices_for_fields_of_type(CompositionalFieldDescription::entropy);
-      const unsigned int entropy_index = entropy_indices[0];
-      const std::vector<unsigned int> &composition_indices = this->introspection().get_indices_for_fields_of_type(CompositionalFieldDescription::chemical_composition);
-
-      AssertThrow(composition_indices.size() == material_file_names.size() - 1,
-                  ExcMessage("The 'entropy model' material model assumes that there exists a background field in addition to the compositional fields, "
-                             "and therefore it requires one more lookup table than there are chemical compositional fields."));
-
-      EquationOfStateOutputs<dim> eos_outputs (material_file_names.size());
-      std::vector<double> volume_fractions (material_file_names.size());
-      std::vector<double> mass_fractions (material_file_names.size());
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          // Use the adiabatic pressure instead of the real one,
-          // to stabilize against pressure oscillations in phase transitions.
-          // This is a requirement of the projected density approximation for
-          // the Stokes equation and not related to the entropy formulation.
-          // Also convert pressure from Pa to bar, bar is used in the table.
-          const double entropy = in.composition[i][entropy_index];
-          const double pressure = this->get_adiabatic_conditions().pressure(in.position[i]) / 1.e5;
-
-          // Loop over all material files, and store the looked-up values for all compositions.
-          for (unsigned int j=0; j<material_file_names.size(); ++j)
-            {
-              eos_outputs.densities[j] = entropy_reader[j]->density(entropy, pressure);
-              eos_outputs.thermal_expansion_coefficients[j] = entropy_reader[j]->thermal_expansivity(entropy,pressure);
-              eos_outputs.specific_heat_capacities[j] = entropy_reader[j]->specific_heat(entropy,pressure);
-
-              const Tensor<1, 2> pressure_unit_vector({0.0, 1.0});
-              eos_outputs.compressibilities[j] = ((entropy_reader[j]->density_gradient(entropy,pressure)) * pressure_unit_vector) / eos_outputs.densities[j];
-            }
-
-          // Calculate volume fractions from mass fractions
-          // If there is only one lookup table, set the mass and volume fractions to 1
-          if (material_file_names.size() == 1)
-            mass_fractions [0] = 1.0;
-
-          else
-            {
-              // We only want to compute mass/volume fractions for fields that are chemical compositions.
-              mass_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[i], this->introspection().chemical_composition_field_indices());
-            }
-
-          volume_fractions = MaterialUtilities::compute_volumes_from_masses(mass_fractions,
-                                                                            eos_outputs.densities,
-                                                                            true);
-
-          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
-          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
-
-          out.specific_heat[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
-
-          out.compressibilities[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
-
-          // Thermal conductivity can be pressure temperature dependent
-          const double temperature_lookup =  entropy_reader[0]->temperature(entropy,pressure);
-          out.thermal_conductivities[i] = thermal_conductivity(temperature_lookup, in.pressure[i], in.position[i]);
-
-          out.entropy_derivative_pressure[i]    = 0.;
-          out.entropy_derivative_temperature[i] = 0.;
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c]            = 0.;
-
-          // set up variable to interpolate prescribed field outputs onto compositional fields
-          if (PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>())
-            {
-              prescribed_field_out->prescribed_field_outputs[i][projected_density_index] = out.densities[i];
-            }
-
-          // set up variable to interpolate prescribed field outputs onto temperature field
-          if (PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>())
-            {
-              prescribed_temperature_out->prescribed_temperature_outputs[i] = temperature_lookup;
-            }
-
-          // Calculate Viscosity
-          if (in.requests_property(MaterialProperties::viscosity))
-            {
-              // read in the viscosity profile
-              const double depth = this->get_geometry_model().depth(in.position[i]);
-              const double viscosity_profile = depth_dependent_rheology->compute_viscosity(depth);
-
-              // lateral viscosity variations
-              const double reference_temperature = this->get_adiabatic_conditions().is_initialized()
-                                                   ?
-                                                   this->get_adiabatic_conditions().temperature(in.position[i])
-                                                   :
-                                                   this->get_parameters().adiabatic_surface_temperature;
-
-              const double delta_temperature = temperature_lookup-reference_temperature;
-
-              // Steinberger & Calderwood viscosity
-              if (temperature_lookup*reference_temperature == 0)
-                out.viscosities[i] = max_eta;
-              else
-                {
-                  double vis_lateral = std::exp(-lateral_viscosity_prefactor_lookup->lateral_viscosity(depth)*delta_temperature/(temperature_lookup*reference_temperature));
-                  // lateral vis variation
-                  vis_lateral = std::max(std::min((vis_lateral),max_lateral_eta_variation),1/max_lateral_eta_variation);
-
-                  if (std::isnan(vis_lateral))
-                    vis_lateral = 1.0;
-
-                  double effective_viscosity = vis_lateral * viscosity_profile;
-
-                  const double strain_rate_effective = std::fabs(second_invariant(deviator(in.strain_rate[i])));
-
-                  if (std::sqrt(strain_rate_effective) >= std::numeric_limits<double>::min())
-                    {
-                      const double pressure =  this->get_adiabatic_conditions().pressure(in.position[i]);
-                      const double eta_plastic = drucker_prager_plasticity.compute_viscosity(cohesion,
-                                                                                             angle_of_internal_friction,
-                                                                                             pressure,
-                                                                                             std::sqrt(strain_rate_effective),
-                                                                                             std::numeric_limits<double>::infinity());
-
-                      effective_viscosity = 1.0 / ( ( 1.0 /  eta_plastic  ) + ( 1.0 / (vis_lateral * viscosity_profile) ) );
-
-                      PlasticAdditionalOutputs<dim> *plastic_out = out.template get_additional_output<PlasticAdditionalOutputs<dim>>();
-                      if (plastic_out != nullptr)
-                        {
-                          plastic_out->cohesions[i] = cohesion;
-                          plastic_out->friction_angles[i] = angle_of_internal_friction;
-                          plastic_out->yielding[i] = eta_plastic < (vis_lateral * viscosity_profile) ? 1 : 0;
-                        }
-                    }
-                  out.viscosities[i] = std::max(std::min(effective_viscosity,max_eta),min_eta);
-                }
-            }
-
-          // fill seismic velocities outputs if they exist
-          if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
-            {
-
-              std::vector<double> vp (material_file_names.size());
-              std::vector<double> vs (material_file_names.size());
-              for (unsigned int j=0; j<material_file_names.size(); ++j)
-                {
-                  vp[j] = entropy_reader[j]->seismic_vp(entropy,pressure);
-                  vs[j] = entropy_reader[j]->seismic_vs(entropy,pressure);
-                }
-              seismic_out->vp[i] = MaterialUtilities::average_value (volume_fractions, vp, MaterialUtilities::arithmetic);
-              seismic_out->vs[i] = MaterialUtilities::average_value (volume_fractions, vs, MaterialUtilities::arithmetic);
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    EntropyModel<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Entropy model");
-        {
-          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/",
-                             Patterns::DirectoryName (),
-                             "The path to the model data. The path may also include the special "
-                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                             "in which the ASPECT source files were located when ASPECT was "
-                             "compiled. This interpretation allows, for example, to reference "
-                             "files located in the `data/' subdirectory of ASPECT.");
-          prm.declare_entry ("Material file name", "material_table.txt",
-                             Patterns::List (Patterns::Anything()),
-                             "The file name of the material data. The first material data file is intended for the background composition. ");
-          prm.declare_entry ("Reference viscosity", "1e22",
-                             Patterns::Double(0),
-                             "The viscosity that is used in this model. "
-                             "\n\n"
-                             "Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Lateral viscosity file name", "temp-viscosity-prefactor.txt",
-                             Patterns::Anything (),
-                             "The file name of the lateral viscosity prefactor.");
-          prm.declare_entry ("Minimum viscosity", "1e19",
-                             Patterns::Double (0.),
-                             "The minimum viscosity that is allowed in the viscosity "
-                             "calculation. Smaller values will be cut off.");
-          prm.declare_entry ("Maximum viscosity", "1e23",
-                             Patterns::Double (0.),
-                             "The maximum viscosity that is allowed in the viscosity "
-                             "calculation. Larger values will be cut off.");
-          prm.declare_entry ("Maximum lateral viscosity variation", "1e2",
-                             Patterns::Double (0.),
-                             "The relative cutoff value for lateral viscosity variations "
-                             "caused by temperature deviations. The viscosity may vary "
-                             "laterally by this factor squared.");
-          prm.declare_entry ("Angle of internal friction", "0.",
-                             Patterns::Double (0.),
-                             "The value of the angle of internal friction, $\\phi$."
-                             "For a value of zero, in 2D the von Mises criterion is retrieved. "
-                             "Angles higher than 30 degrees are harder to solve numerically."
-                             "Units: degrees.");
-          prm.declare_entry ("Cohesion", "1e20",
-                             Patterns::Double (0.),
-                             "The value of the cohesion, $C$. The extremely large default"
-                             "cohesion value (1e20 Pa) prevents the viscous stress from "
-                             "exceeding the yield stress. Units: \\si{\\pascal}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Thermal conductivity formulation", "constant",
-                             Patterns::Selection("constant|p-T-dependent"),
-                             "Which law should be used to compute the thermal conductivity. "
-                             "The 'constant' law uses a constant value for the thermal "
-                             "conductivity. The 'p-T-dependent' formulation uses equations "
-                             "from Stackhouse et al. (2015): First-principles calculations "
-                             "of the lattice thermal conductivity of the lower mantle "
-                             "(https://doi.org/10.1016/j.epsl.2015.06.050), and Tosi et al. "
-                             "(2013): Mantle dynamics with pressure- and temperature-dependent "
-                             "thermal expansivity and conductivity "
-                             "(https://doi.org/10.1016/j.pepi.2013.02.004) to compute the "
-                             "thermal conductivity in dependence of temperature and pressure. "
-                             "The thermal conductivity parameter sets can be chosen in such a "
-                             "way that either the Stackhouse or the Tosi relations are used. "
-                             "The conductivity description can consist of several layers with "
-                             "different sets of parameters. Note that the Stackhouse "
-                             "parametrization is only valid for the lower mantle (bridgmanite).");
-          prm.declare_entry ("Thermal conductivity transition depths", "410000, 520000, 660000",
-                             Patterns::List(Patterns::Double (0.)),
-                             "A list of depth values that indicate where the transitions between "
-                             "the different conductivity parameter sets should occur in the "
-                             "'p-T-dependent' Thermal conductivity formulation (in most cases, "
-                             "this will be the depths of major mantle phase transitions). "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Reference thermal conductivities", "2.47, 3.81, 3.52, 4.9",
-                             Patterns::List(Patterns::Double (0.)),
-                             "A list of base values of the thermal conductivity for each of the "
-                             "horizontal layers in the 'p-T-dependent' thermal conductivity "
-                             "formulation. Pressure- and temperature-dependence will be applied"
-                             "on top of this base value, according to the parameters 'Pressure "
-                             "dependencies of thermal conductivity' and 'Reference temperatures "
-                             "for thermal conductivity'. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}");
-          prm.declare_entry ("Pressure dependencies of thermal conductivity", "3.3e-10, 3.4e-10, 3.6e-10, 1.05e-10",
-                             Patterns::List(Patterns::Double ()),
-                             "A list of values that determine the linear scaling of the "
-                             "thermal conductivity with the pressure in the 'p-T-dependent' "
-                             "thermal conductivity formulation. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin\\per\\pascal}.");
-          prm.declare_entry ("Reference temperatures for thermal conductivity", "300, 300, 300, 1200",
-                             Patterns::List(Patterns::Double (0.)),
-                             "A list of values of reference temperatures used to determine "
-                             "the temperature-dependence of the thermal conductivity in the "
-                             "'p-T-dependent' thermal conductivity formulation. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Thermal conductivity exponents", "0.48, 0.56, 0.61, 1.0",
-                             Patterns::List(Patterns::Double (0.)),
-                             "A list of exponents in the temperature-dependent term of the "
-                             "'p-T-dependent' thermal conductivity formulation. Note that this "
-                             "exponent is not used (and should have a value of 1) in the "
-                             "formulation of Stackhouse et al. (2015). "
-                             "Units: none.");
-          prm.declare_entry ("Saturation prefactors", "0, 0, 0, 1",
-                             Patterns::List(Patterns::Double (0., 1.)),
-                             "A list of values that indicate how a given layer in the "
-                             "conductivity formulation should take into account the effects "
-                             "of saturation on the temperature-dependence of the thermal "
-                             "conducitivity. This factor is multiplied with a saturation function "
-                             "based on the theory of Roufosse and Klemens, 1974. A value of 1 "
-                             "reproduces the formulation of Stackhouse et al. (2015), a value of "
-                             "0 reproduces the formulation of Tosi et al., (2013). "
-                             "Units: none.");
-          prm.declare_entry ("Maximum thermal conductivity", "1000",
-                             Patterns::Double (0.),
-                             "The maximum thermal conductivity that is allowed in the "
-                             "model. Larger values will be cut off.");
-          prm.leave_subsection();
-        }
-
-        // Depth-dependent parameters from the rheology plugin
-        Rheology::AsciiDepthProfile<dim>::declare_parameters(prm,
-                                                             "Depth dependent viscosity");
-
-        prm.leave_subsection();
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    EntropyModel<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Entropy model");
-        {
-          data_directory              = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-          material_file_names          = Utilities::split_string_list(prm.get ("Material file name"));
-          lateral_viscosity_file_name  = prm.get ("Lateral viscosity file name");
-          min_eta                     = prm.get_double ("Minimum viscosity");
-          max_eta                     = prm.get_double ("Maximum viscosity");
-          max_lateral_eta_variation    = prm.get_double ("Maximum lateral viscosity variation");
-          thermal_conductivity_value  = prm.get_double ("Thermal conductivity");
-
-          if (prm.get ("Thermal conductivity formulation") == "constant")
-            conductivity_formulation = constant;
-          else if (prm.get ("Thermal conductivity formulation") == "p-T-dependent")
-            conductivity_formulation = p_T_dependent;
-          else
-            AssertThrow(false, ExcMessage("Not a valid thermal conductivity formulation"));
-
-          conductivity_transition_depths = Utilities::string_to_double
-                                           (Utilities::split_string_list(prm.get ("Thermal conductivity transition depths")));
-          const unsigned int n_conductivity_layers = conductivity_transition_depths.size() + 1;
-          AssertThrow (std::is_sorted(conductivity_transition_depths.begin(), conductivity_transition_depths.end()),
-                       ExcMessage("The list of 'Thermal conductivity transition depths' must "
-                                  "be sorted such that the values increase monotonically."));
-
-          reference_thermal_conductivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Reference thermal conductivities"))),
-                                                                                     n_conductivity_layers,
-                                                                                     "Reference thermal conductivities");
-          conductivity_pressure_dependencies = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Pressure dependencies of thermal conductivity"))),
-                                                                                       n_conductivity_layers,
-                                                                                       "Pressure dependencies of thermal conductivity");
-          conductivity_reference_temperatures = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Reference temperatures for thermal conductivity"))),
-                                                                                        n_conductivity_layers,
-                                                                                        "Reference temperatures for thermal conductivity");
-          conductivity_exponents = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal conductivity exponents"))),
-                                                                           n_conductivity_layers,
-                                                                           "Thermal conductivity exponents");
-          saturation_scaling = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Saturation prefactors"))),
-                                                                       n_conductivity_layers,
-                                                                       "Saturation prefactors");
-          maximum_conductivity = prm.get_double ("Maximum thermal conductivity");
-
-          angle_of_internal_friction = prm.get_double ("Angle of internal friction") * constants::degree_to_radians;
-          cohesion = prm.get_double("Cohesion");
-
-          prm.leave_subsection();
-        }
-
-        depth_dependent_rheology = std::make_unique<Rheology::AsciiDepthProfile<dim>>();
-        depth_dependent_rheology->initialize_simulator (this->get_simulator());
-        depth_dependent_rheology->parse_parameters(prm, "Depth dependent viscosity");
-        depth_dependent_rheology->initialize();
-
-        prm.leave_subsection();
-
-        // Declare dependencies on solution variables
-        this->model_dependence.viscosity = NonlinearDependence::temperature;
-        this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-        this->model_dependence.compressibility = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-        this->model_dependence.specific_heat = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-        this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    EntropyModel<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
-        }
-
-      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>>
-            (n_points, this->n_compositional_fields()));
-        }
-
-      if (out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>>
-            (n_points));
-        }
-
-      if (out.template get_additional_output<PlasticAdditionalOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<PlasticAdditionalOutputs<dim>> (n_points));
-        }
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(EntropyModel,
-                                   "entropy model",
-                                   "A material model that is designed to use pressure and entropy (rather "
-                                   "than pressure and temperature) as independent variables. "
-                                   "It requires a thermodynamic data table that contains "
-                                   "all relevant properties in a specific format as illustrated in "
-                                   "the data/material-model/entropy-table/opxtable example folder. "
-                                   "The material model requires the use of the projected density "
-                                   "approximation for compressibility, and the existence of a "
-                                   "compositional field called 'entropy'.")
-  }
-}
diff --git a/source/material_model/equation_of_state/interface.cc.bak b/source/material_model/equation_of_state/interface.cc.bak
deleted file mode 100644
index d414d108ca0..00000000000
--- a/source/material_model/equation_of_state/interface.cc.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/equation_of_state/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    EquationOfStateOutputs<dim>::EquationOfStateOutputs(const unsigned int n_individual_compositions_and_phases)
-      :
-      densities(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
-      thermal_expansion_coefficients(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
-      specific_heat_capacities(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
-      compressibilities(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
-      entropy_derivative_pressure(n_individual_compositions_and_phases, numbers::signaling_nan<double>()),
-      entropy_derivative_temperature(n_individual_compositions_and_phases, numbers::signaling_nan<double>())
-    {}
-
-
-
-    template <int dim>
-    void
-    phase_average_equation_of_state_outputs(const EquationOfStateOutputs<dim> &eos_outputs_all_phases,
-                                            const std::vector<double> &phase_function_values,
-                                            const std::vector<unsigned int> &n_phase_transitions_per_composition,
-                                            EquationOfStateOutputs<dim> &eos_outputs)
-    {
-      for (unsigned int c=0; c<eos_outputs.densities.size(); ++c)
-        {
-          eos_outputs.densities[c] =
-            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.densities, c);
-          eos_outputs.thermal_expansion_coefficients[c] =
-            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.thermal_expansion_coefficients, c);
-          eos_outputs.specific_heat_capacities[c] =
-            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.specific_heat_capacities, c);
-          eos_outputs.compressibilities[c] =
-            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.compressibilities, c);
-          eos_outputs.entropy_derivative_pressure[c] =
-            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.entropy_derivative_pressure, c);
-          eos_outputs.entropy_derivative_temperature[c] =
-            MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition, eos_outputs_all_phases.entropy_derivative_temperature, c);
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  template struct EquationOfStateOutputs<dim>; \
-  template void phase_average_equation_of_state_outputs<dim> (const EquationOfStateOutputs<dim> &, \
-                                                              const std::vector<double> &phase_function_values, \
-                                                              const std::vector<unsigned int> &n_phase_transitions_per_composition, \
-                                                              EquationOfStateOutputs<dim> &);
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/equation_of_state/linearized_incompressible.cc.bak b/source/material_model/equation_of_state/linearized_incompressible.cc.bak
deleted file mode 100644
index 93459dbb073..00000000000
--- a/source/material_model/equation_of_state/linearized_incompressible.cc.bak
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/equation_of_state/linearized_incompressible.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-      template <int dim>
-      void
-      LinearizedIncompressible<dim>::
-      evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-               const unsigned int q,
-               MaterialModel::EquationOfStateOutputs<dim> &out) const
-      {
-
-        Assert(maximum_number_of_compositions+1 >= out.densities.size(),
-               ExcMessage("Error: You are trying to evaluate the equation of state with "
-                          + Utilities::to_string(out.densities.size()-1) +
-                          " compositional fields, which is larger than "
-                          + Utilities::to_string(maximum_number_of_compositions) +
-                          ", the number of fields the equation of state was set up with."));
-
-
-        for (unsigned int c=0; c < out.densities.size(); ++c)
-          {
-            out.densities[c] = reference_rho * (1 - thermal_alpha * (in.temperature[q] - reference_T));
-            if (c>0)
-              out.densities[c] += compositional_delta_rhos[c-1];
-
-            out.thermal_expansion_coefficients[c] = thermal_alpha;
-            out.specific_heat_capacities[c] = reference_specific_heat;
-            out.compressibilities[c] = 0.0;
-            out.entropy_derivative_pressure[c] = 0.0;
-            out.entropy_derivative_temperature[c] = 0.0;
-          }
-      }
-
-
-
-      template <int dim>
-      bool
-      LinearizedIncompressible<dim>::
-      is_compressible () const
-      {
-        return false;
-      }
-
-
-
-      template <int dim>
-      void
-      LinearizedIncompressible<dim>::declare_parameters (ParameterHandler &prm,
-                                                         const unsigned int n_compositions)
-      {
-        prm.declare_entry ("Reference density", "3300.",
-                           Patterns::Double (0.),
-                           "Reference density $\\rho_0$. "
-                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-        prm.declare_entry ("Reference temperature", "293.",
-                           Patterns::Double (0.),
-                           "The reference temperature $T_0$. The reference temperature is used "
-                           "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
-        prm.declare_entry ("Reference specific heat", "1250.",
-                           Patterns::Double (0.),
-                           "The value of the specific heat $C_p$. "
-                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-        prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                           Patterns::Double (0.),
-                           "The value of the thermal expansion coefficient $\\alpha$. "
-                           "Units: \\si{\\per\\kelvin}.");
-        if (n_compositions > 0)
-          prm.declare_entry ("Density differential for compositional field 1", "0.",
-                             Patterns::Double(),
-                             "If compositional fields are used, then one would frequently want "
-                             "to make the density depend on these fields. In this simple material "
-                             "model, we make the following assumptions: if no compositional fields "
-                             "are used in the current simulation, then the density is simply the usual "
-                             "one with its linear dependence on the temperature. If there are compositional "
-                             "fields, then the material model determines how many of them influence the density. "
-                             "The composition-dependence adds a term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
-                             "This parameter describes the value of $\\Delta \\rho$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
-        if (n_compositions > 1)
-          prm.declare_entry ("Density differential for compositional field 2", "0.",
-                             Patterns::Double(),
-                             "If compositional fields are used, then one would frequently want "
-                             "to make the density depend on these fields. In this simple material "
-                             "model, we make the following assumptions: if no compositional fields "
-                             "are used in the current simulation, then the density is simply the usual "
-                             "one with its linear dependence on the temperature. If there are compositional "
-                             "fields, then the material model determines how many of them influence the density. "
-                             "The composition-dependence adds a term of the kind $+\\Delta \\rho \\; c_2(\\mathbf x)$. "
-                             "This parameter describes the value of $\\Delta \\rho$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
-      }
-
-
-
-      template <int dim>
-      void
-      LinearizedIncompressible<dim>::parse_parameters (ParameterHandler &prm,
-                                                       const unsigned int n_compositions)
-      {
-        reference_rho              = prm.get_double ("Reference density");
-        reference_T                = prm.get_double ("Reference temperature");
-        reference_specific_heat    = prm.get_double ("Reference specific heat");
-        thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-
-        maximum_number_of_compositions = n_compositions;
-        compositional_delta_rhos.resize(maximum_number_of_compositions);
-        if (maximum_number_of_compositions > 0)
-          compositional_delta_rhos[0]    = prm.get_double ("Density differential for compositional field 1");
-        if (maximum_number_of_compositions > 1)
-          compositional_delta_rhos[1]    = prm.get_double ("Density differential for compositional field 2");
-      }
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-#define INSTANTIATE(dim) \
-  template class LinearizedIncompressible<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/source/material_model/equation_of_state/multicomponent_compressible.cc.bak b/source/material_model/equation_of_state/multicomponent_compressible.cc.bak
deleted file mode 100644
index a7652424cd4..00000000000
--- a/source/material_model/equation_of_state/multicomponent_compressible.cc.bak
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
-  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/equation_of_state/multicomponent_compressible.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-      template <int dim>
-      void
-      MulticomponentCompressible<dim>::
-      evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-               const unsigned int q,
-               MaterialModel::EquationOfStateOutputs<dim> &out) const
-      {
-
-        const double pressure = in.pressure[q];
-        const double temperature = std::max(in.temperature[q], 1.); // temperature can't be zero for correct evaluation
-
-        for (unsigned int c=0; c < out.densities.size(); ++c)
-          {
-            const double ak = reference_thermal_expansivities[c]/reference_isothermal_compressibilities[c];
-            const double f = (1. + (pressure - ak*(temperature - reference_temperatures[c])) *
-                              isothermal_bulk_modulus_pressure_derivatives[c] *
-                              reference_isothermal_compressibilities[c]);
-
-            out.densities[c] = reference_densities[c]*std::pow(f, 1./isothermal_bulk_modulus_pressure_derivatives[c]);
-            out.thermal_expansion_coefficients[c] = reference_thermal_expansivities[c] / f;
-            out.specific_heat_capacities[c] = (isochoric_specific_heats[c] +
-                                               (temperature*reference_thermal_expansivities[c] *
-                                                ak * std::pow(f, -1.-(1./isothermal_bulk_modulus_pressure_derivatives[c]))
-                                                / reference_densities[c]));
-            out.compressibilities[c] = reference_isothermal_compressibilities[c]/f;
-            out.entropy_derivative_pressure[c] = 0.;
-            out.entropy_derivative_temperature[c] = 0.;
-          }
-      }
-
-
-
-      template <int dim>
-      bool
-      MulticomponentCompressible<dim>::
-      is_compressible () const
-      {
-        return true;
-      }
-
-
-
-      template <int dim>
-      void
-      MulticomponentCompressible<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Reference temperatures", "298.15",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of reference temperatures $T_0$ for background mantle and compositional fields,"
-                           "for a total of N+1 values, where N is the number of compositional fields."
-                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
-        prm.declare_entry ("Reference densities", "3300.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of densities for background mantle and compositional fields,"
-                           "for a total of N+1 values, where N is the number of compositional fields."
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-        prm.declare_entry ("Reference isothermal compressibilities", "4e-12",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of isothermal compressibilities for background mantle and compositional fields,"
-                           "for a total of N+1 values, where N is the number of compositional fields."
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\per\\pascal}.");
-        prm.declare_entry ("Isothermal bulk modulus pressure derivatives", "4.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of isothermal pressure derivatives of the bulk moduli for background mantle and compositional fields,"
-                           "for a total of N+1 values, where N is the number of compositional fields."
-                           "If only one value is given, then all use the same value. "
-                           "Units: [].");
-        prm.declare_entry ("Reference thermal expansivities", "4.e-5",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of thermal expansivities for background mantle and compositional fields,"
-                           "for a total of N+1 values, where N is the number of compositional fields."
-                           "If only one value is given, then all use the same value. Units: \\si{\\per\\kelvin}.");
-        prm.declare_entry ("Isochoric specific heats", "1250.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of isochoric specific heats $C_v$ for background mantle and compositional fields,"
-                           "for a total of N+1 values, where N is the number of compositional fields."
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-      }
-
-
-
-      template <int dim>
-      void
-      MulticomponentCompressible<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        // Establish that a background field is required here
-        const bool has_background_field = true;
-
-        // Retrieve the list of composition names
-        const std::vector<std::string> list_of_composition_names = this->introspection().get_composition_names();
-
-        // Parse multicomponent properties
-        reference_temperatures = Utilities::parse_map_to_double_array (prm.get("Reference temperatures"),
-                                                                       list_of_composition_names,
-                                                                       has_background_field,
-                                                                       "Reference temperatures");
-
-        reference_densities = Utilities::parse_map_to_double_array (prm.get("Reference densities"),
-                                                                    list_of_composition_names,
-                                                                    has_background_field,
-                                                                    "Reference densities");
-
-        reference_isothermal_compressibilities = Utilities::parse_map_to_double_array (prm.get("Reference isothermal compressibilities"),
-                                                                                       list_of_composition_names,
-                                                                                       has_background_field,
-                                                                                       "Reference isothermal compressibilities");
-
-        isothermal_bulk_modulus_pressure_derivatives = Utilities::parse_map_to_double_array (prm.get("Isothermal bulk modulus pressure derivatives"),
-                                                       list_of_composition_names,
-                                                       has_background_field,
-                                                       "Isothermal bulk modulus pressure derivatives");
-
-        reference_thermal_expansivities = Utilities::parse_map_to_double_array (prm.get("Reference thermal expansivities"),
-                                                                                list_of_composition_names,
-                                                                                has_background_field,
-                                                                                "Reference thermal expansivities");
-
-        isochoric_specific_heats = Utilities::parse_map_to_double_array (prm.get("Isochoric specific heats"),
-                                                                         list_of_composition_names,
-                                                                         has_background_field,
-                                                                         "Isochoric specific heats");
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-#define INSTANTIATE(dim) \
-  template class MulticomponentCompressible<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/source/material_model/equation_of_state/multicomponent_incompressible.cc.bak b/source/material_model/equation_of_state/multicomponent_incompressible.cc.bak
deleted file mode 100644
index 3e8c0066e8d..00000000000
--- a/source/material_model/equation_of_state/multicomponent_incompressible.cc.bak
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/equation_of_state/multicomponent_incompressible.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-      template <int dim>
-      void
-      MulticomponentIncompressible<dim>::
-      evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-               const unsigned int input_index,
-               MaterialModel::EquationOfStateOutputs<dim> &out) const
-      {
-
-
-        // If adiabatic heating is used, the reference temperature used to calculate density should be the adiabatic
-        // temperature at the current position. This definition is consistent with the Extended Boussinesq Approximation.
-        const double reference_temperature = (this->include_adiabatic_heating()
-                                              ?
-                                              this->get_adiabatic_conditions().temperature(in.position[input_index])
-                                              :
-                                              reference_T);
-
-        for (unsigned int c=0; c < out.densities.size(); ++c)
-          {
-            out.densities[c] = densities[c] * (1 - thermal_expansivities[c] * (in.temperature[input_index] - reference_temperature));
-            out.thermal_expansion_coefficients[c] = thermal_expansivities[c];
-            out.specific_heat_capacities[c] = specific_heats[c];
-            out.compressibilities[c] = 0.0;
-            out.entropy_derivative_pressure[c] = 0.0;
-            out.entropy_derivative_temperature[c] = 0.0;
-          }
-      }
-
-
-
-      template <int dim>
-      bool
-      MulticomponentIncompressible<dim>::
-      is_compressible () const
-      {
-        return false;
-      }
-
-
-
-      template <int dim>
-      void
-      MulticomponentIncompressible<dim>::declare_parameters (ParameterHandler &prm,
-                                                             const double default_thermal_expansion)
-      {
-        prm.declare_entry ("Reference temperature", "293.",
-                           Patterns::Double (0.),
-                           "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
-        prm.declare_entry ("Densities", "3300.",
-                           Patterns::Anything(),
-                           "List of densities for background mantle and compositional fields,"
-                           "for a total of N+M+1 values, where N is the number of compositional fields and M is the number of phases. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-        prm.declare_entry ("Thermal expansivities", std::to_string(default_thermal_expansion),
-                           Patterns::Anything(),
-                           "List of thermal expansivities for background mantle and compositional fields,"
-                           "for a total of N+M+1 values, where N is the number of compositional fields and M is the number of phases. "
-                           "If only one value is given, then all use the same value. Units: \\si{\\per\\kelvin}.");
-        prm.declare_entry ("Heat capacities", "1250.",
-                           Patterns::Anything(),
-                           "List of specific heats $C_p$ for background mantle and compositional fields,"
-                           "for a total of N+M+1 values, where N is the number of compositional fields and M is the number of phases. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-        prm.declare_alias ("Heat capacities", "Specific heats");
-      }
-
-
-
-      template <int dim>
-      void
-      MulticomponentIncompressible<dim>::parse_parameters (ParameterHandler &prm,
-                                                           const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
-      {
-        reference_T = prm.get_double ("Reference temperature");
-
-        // Make options file for parsing maps to double arrays
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-        chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-        compositional_field_names.insert(compositional_field_names.begin(),"background");
-
-        Utilities::MapParsing::Options options(chemical_field_names, "Densities");
-        options.list_of_allowed_keys = compositional_field_names;
-        options.allow_multiple_values_per_key = true;
-        if (expected_n_phases_per_composition)
-          {
-            options.n_values_per_key = *expected_n_phases_per_composition;
-
-            // check_values_per_key is required to be true to duplicate single values
-            // if they are to be used for all phases associated with a given key.
-            options.check_values_per_key = true;
-          }
-
-        // Parse multicomponent properties
-        densities = Utilities::MapParsing::parse_map_to_double_array(prm.get("Densities"), options);
-        options.property_name = "Thermal expansivities";
-        thermal_expansivities = Utilities::MapParsing::parse_map_to_double_array(prm.get("Thermal expansivities"), options);
-        options.property_name = "Heat capacities";
-        specific_heats = Utilities::MapParsing::parse_map_to_double_array (prm.get("Heat capacities"), options);
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-#define INSTANTIATE(dim) \
-  template class MulticomponentIncompressible<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/source/material_model/equation_of_state/thermodynamic_table_lookup.cc.bak b/source/material_model/equation_of_state/thermodynamic_table_lookup.cc.bak
deleted file mode 100644
index 40ebfaac66e..00000000000
--- a/source/material_model/equation_of_state/thermodynamic_table_lookup.cc.bak
+++ /dev/null
@@ -1,579 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/equation_of_state/thermodynamic_table_lookup.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::initialize()
-      {
-        // This model allows the user to provide several PerpleX or HeFESTo
-        // P-T lookup files, each of which corresponds to a different material.
-        // The thermodynamic properties and stable mineral phases within each material
-        // will in general be different, and must be averaged in a reasonable way.
-
-        // In the following, we populate the material_lookups.
-        // We also populate the unique_phase_names vector, which is used to
-        // calculate the phase volumes if they are provided by the lookup.
-        // This equation of state sums the volume fractions of
-        // phases from different lookups if they have the same phase name.
-        std::set<std::string> set_phase_volume_column_names;
-
-        unique_phase_indices.resize(n_material_lookups, std::vector<unsigned int>());
-        global_index_of_lookup_phase.resize (n_material_lookups, std::vector<unsigned int>());
-
-        for (unsigned i = 0; i < n_material_lookups; ++i)
-          {
-            if (material_file_format == perplex)
-              material_lookup
-              .push_back(std::make_unique<MaterialModel::MaterialUtilities::Lookup::PerplexReader>(data_directory+material_file_names[i],
-                         use_bilinear_interpolation,
-                         this->get_mpi_communicator()));
-            else if (material_file_format == hefesto)
-              material_lookup
-              .push_back(std::make_unique<MaterialModel::MaterialUtilities::Lookup::HeFESToReader>(data_directory+material_file_names[i],
-                         data_directory+derivatives_file_names[i],
-                         use_bilinear_interpolation,
-                         this->get_mpi_communicator()));
-            else
-              AssertThrow (false, ExcNotImplemented());
-
-            // Here we look up all of the column names and insert
-            // unique names into the unique_phase_names vector and
-            // filling the unique_phase_indices object.
-            std::vector<std::string> phase_volume_column_names = material_lookup[i]->phase_volume_column_names();
-            for (const auto &phase_volume_column_name : phase_volume_column_names)
-              {
-                // iterate over the present unique_phase_names object
-                // to find phase_volume_column_name.
-                std::vector<std::string>::iterator it = std::find(unique_phase_names.begin(),
-                                                                  unique_phase_names.end(),
-                                                                  phase_volume_column_name);
-
-                // If phase_volume_column_name already exists in unique_phase_names,
-                // std::distance finds its index. Otherwise, std::distance will return
-                // the size of the present object, which is the index where we are
-                // about to push the new name. Either way, this is the index we want
-                // to add to the unique_phase_indices[i] vector.
-                unsigned int i_unique = std::distance(unique_phase_names.begin(), it);
-                unique_phase_indices[i].push_back(i_unique);
-
-                // If phase_volume_column_name did not already exist
-                // in unique_phase_names, we add it here.
-                if (it == unique_phase_names.end())
-                  unique_phase_names.push_back(phase_volume_column_name);
-              }
-
-            // Do the same for the dominant phases
-            std::vector<std::string> phase_names_one_lookup = material_lookup[i]->get_dominant_phase_names();
-            for (const auto &phase_name : phase_names_one_lookup)
-              {
-                std::vector<std::string>::iterator it = std::find(list_of_dominant_phases.begin(),
-                                                                  list_of_dominant_phases.end(),
-                                                                  phase_name);
-
-                // Each lookup only stores the index for the individual lookup, so we have to know
-                // how to convert from the indices of the individual lookup to the index in the
-                // list_of_dominant_phases vector. Here we fill the global_index_of_lookup_phase
-                // object to contain the global indices.
-                global_index_of_lookup_phase[i].push_back(std::distance(list_of_dominant_phases.begin(), it));
-
-                if (it == list_of_dominant_phases.end())
-                  list_of_dominant_phases.push_back(phase_name);
-              }
-
-            // Make sure that either all or none of the tables have a column with the dominant phase.
-            AssertThrow(material_lookup[0]->has_dominant_phase() == material_lookup[i]->has_dominant_phase(),
-                        ExcMessage("Some of the lookup tables you read in contain outputs for the dominant phase, "
-                                   "as indicated by the column 'phase', but in at least of of the tables you use "
-                                   "this column is missing."));
-          }
-
-        // Since the visualization output can only contain numbers and not strings
-        // we have to output the index instead of the name of the phase.
-        // We write out a data file that contains the list of dominant phases so
-        // that it is clear which index corresponds to which phase from the table.
-        const std::string filename = (this->get_output_directory() +
-                                      "thermodynamic_lookup_table_phases.txt");
-
-        if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0
-            && list_of_dominant_phases.size() > 0)
-          {
-            std::ofstream file;
-            file.open(filename);
-            file << "# <index>  <phase> " << std::endl;
-            for (unsigned int p=0; p<list_of_dominant_phases.size(); ++p)
-              {
-                file << p
-                     << ' '
-                     << list_of_dominant_phases[p]
-                     << std::endl;
-              }
-            AssertThrow (file, ExcMessage("Writing data to <" + filename +
-                                          "> did not succeed in the `phase outputs' additional names outputs "
-                                          "visualization postprocessor."));
-            file.close();
-          }
-      }
-
-
-
-      template <int dim>
-      unsigned int
-      ThermodynamicTableLookup<dim>::number_of_lookups() const
-      {
-        return n_material_lookups;
-      }
-
-
-
-      template <int dim>
-      bool
-      ThermodynamicTableLookup<dim>::
-      is_compressible () const
-      {
-        return true;
-      }
-
-
-
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::
-      fill_seismic_velocities (const MaterialModel::MaterialModelInputs<dim> &in,
-                               const std::vector<double> &composite_densities,
-                               const std::vector<std::vector<double>> &volume_fractions,
-                               SeismicAdditionalOutputs<dim> *seismic_out) const
-      {
-        // This function returns the Voigt-Reuss-Hill averages of the
-        // seismic velocities of the different materials.
-
-        // Now we calculate the averaged moduli.
-        // mu = rho*Vs^2; K_s = rho*Vp^2 - 4./3.*mu
-        // The Voigt average is an arithmetic volumetric average,
-        // while the Reuss average is a harmonic volumetric average.
-        for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
-          {
-            if (material_lookup.size() == 1)
-              {
-                seismic_out->vs[i] = material_lookup[0]->seismic_Vs(in.temperature[i],in.pressure[i]);
-                seismic_out->vp[i] = material_lookup[0]->seismic_Vp(in.temperature[i],in.pressure[i]);
-              }
-            else
-              {
-                double k_voigt = 0.;
-                double mu_voigt = 0.;
-                double invk_reuss = 0.;
-                double invmu_reuss = 0.;
-
-                for (unsigned int j = 0; j < material_lookup.size(); ++j)
-                  {
-                    const double mu = material_lookup[j]->density(in.temperature[i],in.pressure[i])*std::pow(material_lookup[j]->seismic_Vs(in.temperature[i],in.pressure[i]), 2.);
-                    const double k =  material_lookup[j]->density(in.temperature[i],in.pressure[i])*std::pow(material_lookup[j]->seismic_Vp(in.temperature[i],in.pressure[i]), 2.) - 4./3.*mu;
-
-                    k_voigt += volume_fractions[i][j] * k;
-                    mu_voigt += volume_fractions[i][j] * mu;
-                    invk_reuss += volume_fractions[i][j] / k;
-                    invmu_reuss += volume_fractions[i][j] / mu;
-                  }
-
-                const double k_VRH = (k_voigt + 1./invk_reuss)/2.;
-                const double mu_VRH = (mu_voigt + 1./invmu_reuss)/2.;
-                seismic_out->vp[i] = std::sqrt((k_VRH + 4./3.*mu_VRH)/composite_densities[i]);
-                seismic_out->vs[i] = std::sqrt(mu_VRH/composite_densities[i]);
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::
-      fill_phase_volume_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                                   const std::vector<std::vector<double>> &volume_fractions,
-                                   NamedAdditionalMaterialOutputs<dim> *phase_volume_fractions_out) const
-      {
-        // Each call to material_lookup[j]->phase_volume_fraction(k,temperature,pressure)
-        // returns the volume fraction of the kth phase which is present in that material lookup
-        // at the requested temperature and pressure.
-        // The total volume fraction of each phase at each evaluation point is equal to
-        // sum_j (volume_fraction_of_material_j * phase_volume_fraction_in_material_j).
-        // In the following function,
-        // the index i corresponds to the ith evaluation point
-        // the index j corresponds to the jth compositional field
-        // the index k corresponds to the kth phase in the lookup
-        std::vector<std::vector<double>> phase_volume_fractions(unique_phase_names.size(),
-                                                                 std::vector<double>(in.n_evaluation_points(), 0.));
-        for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
-          for (unsigned j = 0; j < material_lookup.size(); ++j)
-            for (unsigned int k = 0; k < unique_phase_indices[j].size(); ++k)
-              phase_volume_fractions[unique_phase_indices[j][k]][i] += volume_fractions[i][j] * material_lookup[j]->phase_volume_fraction(k,in.temperature[i],in.pressure[i]);
-
-        phase_volume_fractions_out->output_values = phase_volume_fractions;
-      }
-
-
-
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::
-      fill_dominant_phases (const MaterialModel::MaterialModelInputs<dim> &in,
-                            const std::vector<std::vector<double>> &volume_fractions,
-                            PhaseOutputs<dim> &dominant_phases_out) const
-      {
-        Assert(material_lookup[0]->has_dominant_phase(),
-               ExcMessage("You are trying to fill in outputs for the dominant phase, "
-                          "but these values do not exist in the material lookup."));
-
-        // Each call to material_lookup[j]->dominant_phase(temperature,pressure)
-        // returns the phase with the largest volume fraction in that material lookup
-        // at the requested temperature and pressure.
-        // In the following function,
-        // the index i corresponds to the ith evaluation point
-        // the index j corresponds to the jth compositional field
-        std::vector<std::vector<double>> dominant_phase_indices(1, std::vector<double>(in.n_evaluation_points(),
-                                                                                        std::numeric_limits<double>::quiet_NaN()));
-        for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
-          {
-            const unsigned int dominant_material_index = std::distance(volume_fractions[i].begin(), std::max_element(volume_fractions[i].begin(), volume_fractions[i].end()));
-            const unsigned int dominant_phase_in_material = material_lookup[dominant_material_index]->dominant_phase(in.temperature[i],in.pressure[i]);
-            dominant_phase_indices[0][i] = global_index_of_lookup_phase[dominant_material_index][dominant_phase_in_material];
-          }
-        dominant_phases_out.output_values = dominant_phase_indices;
-      }
-
-
-
-      template <int dim>
-      std::array<std::pair<double, unsigned int>,2>
-      ThermodynamicTableLookup<dim>::
-      enthalpy_derivatives (const typename Interface<dim>::MaterialModelInputs &in) const
-      {
-        std::array<std::pair<double, unsigned int>,2> derivative;
-
-        // get the pressures and temperatures at the vertices of the cell
-        const QTrapezoid<dim> quadrature_formula;
-
-        const unsigned int n_q_points = quadrature_formula.size();
-        FEValues<dim> fe_values (this->get_mapping(),
-                                 this->get_fe(),
-                                 quadrature_formula,
-                                 update_values);
-
-        std::vector<double> temperatures(n_q_points), pressures(n_q_points);
-        fe_values.reinit (in.current_cell);
-
-        fe_values[this->introspection().extractors.temperature]
-        .get_function_values (this->get_current_linearization_point(), temperatures);
-        fe_values[this->introspection().extractors.pressure]
-        .get_function_values (this->get_current_linearization_point(), pressures);
-
-        AssertThrow (n_material_lookups == 1,
-                     ExcMessage("This formalism is only implemented for one material "
-                                "table."));
-
-        // We have to take into account here that the p,T spacing of the table of material properties
-        // we use might be on a finer grid than our model. Because of that we compute the enthalpy
-        // derivatives by using finite differences that average over the whole temperature and
-        // pressure range that is used in this cell. This way we should not miss any phase transformation.
-        derivative = material_lookup[0]->enthalpy_derivatives(temperatures,
-                                                              pressures,
-                                                              max_latent_heat_substeps);
-
-        return derivative;
-      }
-
-
-
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::
-      evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-               std::vector<MaterialModel::EquationOfStateOutputs<dim>> &eos_outputs) const
-      {
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          {
-            const double pressure = in.pressure[i];
-            const double temperature = in.temperature[i];
-
-            for (unsigned int j=0; j<eos_outputs[i].densities.size(); ++j)
-              {
-                eos_outputs[i].densities[j] = material_lookup[j]->density(temperature, pressure);
-                eos_outputs[i].compressibilities[j] = material_lookup[j]->dRhodp(temperature, pressure)/eos_outputs[i].densities[j];
-
-                // Only calculate the non-reactive specific heat and
-                // thermal expansivity if latent heat is to be ignored.
-                if (!latent_heat)
-                  {
-                    eos_outputs[i].thermal_expansion_coefficients[j] = material_lookup[j]->thermal_expansivity(temperature, pressure);
-                    eos_outputs[i].specific_heat_capacities[j] = material_lookup[j]->specific_heat(temperature, pressure);
-                  }
-
-                eos_outputs[i].entropy_derivative_pressure[j] = 0.;
-                eos_outputs[i].entropy_derivative_temperature[j] = 0.;
-              }
-          }
-        // Calculate the specific heat and thermal expansivity
-        // including the effects of reaction.
-        if (latent_heat)
-          {
-            evaluate_thermal_enthalpy_derivatives(in, eos_outputs);
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::
-      evaluate_thermal_enthalpy_derivatives(const MaterialModel::MaterialModelInputs<dim> &in,
-                                            std::vector<MaterialModel::EquationOfStateOutputs<dim>> &eos_outputs) const
-      {
-        // The second derivatives of the thermodynamic potentials (compressibility, thermal expansivity, specific heat)
-        // are dependent not only on the phases present in the assemblage at the given temperature and pressure,
-        // but also on any reactions between phases in the assemblage. PerpleX and HeFESTo output only "static" properties
-        // (properties not including any reaction effects), and so do not capture the latent heat of reaction.
-
-        // In this material model, we always use a compressibility which includes the effects of reaction,
-        // but we allow the user the option to switch on or off thermal (latent heat) effects.
-        // If the latent_heat bool is set to true, thermal expansivity and specific heat are calculated from
-        // the change in enthalpy with pressure and temperature.
-
-        // There are alternative ways to capture the latent heat effect (by preprocessing the P-T table, for example),
-        // which may be a more appropriate approach in some cases, but the latent heat should always be considered if
-        // thermodynamic self-consistency is intended.
-
-        // The affected properties are computed using the partial derivatives of the enthalpy
-        // with respect to pressure and temperature:
-        // thermal expansivity = (1 - rho * (dH/dp)_T) / T
-        // specific heat capacity = (dH/dT)_P
-        // where the subscript indicates the natural variable which is held constant.
-        double average_temperature(0.0);
-        double average_density(0.0);
-        std::array<std::pair<double, unsigned int>,2> dH;
-
-        for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
-          {
-            average_temperature += in.temperature[i];
-            average_density += eos_outputs[i].densities[0];
-          }
-        average_temperature /= in.n_evaluation_points();
-        average_density /= in.n_evaluation_points();
-
-        if (in.current_cell.state() == IteratorState::valid)
-          dH = enthalpy_derivatives(in);
-
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          {
-            // Use the adiabatic pressure instead of the real one,
-            // to stabilize against pressure oscillations in phase transitions
-            const double pressure = this->get_adiabatic_conditions().pressure(in.position[i]);
-
-            if ((in.current_cell.state() == IteratorState::valid)
-                && (dH[0].second > 0) && (dH[1].second > 0))
-              {
-                eos_outputs[i].thermal_expansion_coefficients[0] = (1 - average_density * dH[1].first) / average_temperature;
-                eos_outputs[i].specific_heat_capacities[0] = dH[0].first;
-              }
-            else
-              {
-                eos_outputs[i].thermal_expansion_coefficients[0] = (1 - eos_outputs[i].densities[0] * material_lookup[0]->dHdp(in.temperature[i],pressure)) / in.temperature[i];
-                eos_outputs[i].specific_heat_capacities[0] = material_lookup[0]->dHdT(in.temperature[i],pressure);
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::fill_additional_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
-                                                              const std::vector<std::vector<double>> &volume_fractions,
-                                                              MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-        // fill seismic velocity outputs if they exist
-        if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
-          fill_seismic_velocities(in, out.densities, volume_fractions, seismic_out);
-
-        // fill phase volume outputs if they exist
-        if (NamedAdditionalMaterialOutputs<dim> *phase_volume_fractions_out = out.template get_additional_output<NamedAdditionalMaterialOutputs<dim>>())
-          fill_phase_volume_fractions(in, volume_fractions, phase_volume_fractions_out);
-
-        if (PhaseOutputs<dim> *dominant_phases_out = out.template get_additional_output<PhaseOutputs<dim>>())
-          fill_dominant_phases(in, volume_fractions, *dominant_phases_out);
-      }
-
-
-
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/steinberger/",
-                           Patterns::DirectoryName (),
-                           "The path to the model data. The path may also include the special "
-                           "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                           "in which the ASPECT source files were located when ASPECT was "
-                           "compiled. This interpretation allows, for example, to reference "
-                           "files located in the `data/' subdirectory of ASPECT. ");
-        prm.declare_entry ("Material file names", "pyr-ringwood88.txt",
-                           Patterns::List (Patterns::Anything()),
-                           "The file names of the material data (material "
-                           "data is assumed to be in order with the ordering "
-                           "of the compositional fields). Note that there are "
-                           "three options on how many files need to be listed "
-                           "here: 1. If only one file is provided, it is used "
-                           "for the whole model domain, and compositional fields "
-                           "are ignored. 2. If there is one more file name than the "
-                           "number of compositional fields, then the first file is "
-                           "assumed to define a `background composition' that is "
-                           "modified by the compositional fields. If there are "
-                           "exactly as many files as compositional fields, the fields are "
-                           "assumed to represent the fractions of different materials "
-                           "and the average property is computed as a sum of "
-                           "the value of the compositional field times the "
-                           "material property of that field.");
-        prm.declare_entry ("Derivatives file names", "",
-                           Patterns::List (Patterns::Anything()),
-                           "The file names of the enthalpy derivatives data. "
-                           "List with as many components as active "
-                           "compositional fields (material data is assumed to "
-                           "be in order with the ordering of the fields).");
-        prm.declare_entry ("Material file format", "perplex",
-                           Patterns::Selection ("perplex|hefesto"),
-                           "The material file format to be read in the property "
-                           "tables.");
-        prm.declare_entry ("Bilinear interpolation", "true",
-                           Patterns::Bool (),
-                           "Whether to use bilinear interpolation to compute "
-                           "material properties (slower but more accurate). ");
-        prm.declare_entry ("Latent heat", "false",
-                           Patterns::Bool (),
-                           "Whether to include latent heat effects in the "
-                           "calculation of thermal expansivity and specific heat. "
-                           "If true, ASPECT follows the approach of Nakagawa et al. 2009, "
-                           "using pressure and temperature derivatives of the enthalpy "
-                           "to calculate the thermal expansivity and specific heat. "
-                           "If false, ASPECT uses the thermal expansivity and "
-                           "specific heat values from the material properties table.");
-        prm.declare_entry ("Maximum latent heat substeps", "1",
-                           Patterns::Integer (1),
-                           "The maximum number of substeps over the temperature pressure range "
-                           "to calculate the averaged enthalpy gradient over a cell.");
-      }
-
-
-
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        data_directory               = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-        material_file_names          = Utilities::split_string_list(prm.get ("Material file names"));
-        n_material_lookups           = material_file_names.size();
-
-        derivatives_file_names       = Utilities::split_string_list(prm.get ("Derivatives file names"));
-        use_bilinear_interpolation   = prm.get_bool ("Bilinear interpolation");
-        latent_heat                  = prm.get_bool ("Latent heat");
-        max_latent_heat_substeps     = prm.get_integer ("Maximum latent heat substeps");
-
-        if (prm.get ("Material file format") == "perplex")
-          material_file_format       = perplex;
-        else if (prm.get ("Material file format") == "hefesto")
-          material_file_format       = hefesto;
-        else
-          AssertThrow (false, ExcNotImplemented());
-
-        if (latent_heat)
-          AssertThrow (n_material_lookups == 1,
-                       ExcMessage("Isochemical latent heat calculations are only implemented for a single material lookup."));
-
-      }
-
-
-
-      template <int dim>
-      void
-      ThermodynamicTableLookup<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-        if (out.template get_additional_output<NamedAdditionalMaterialOutputs<dim>>() == nullptr)
-          {
-            const unsigned int n_points = out.n_evaluation_points();
-            out.additional_outputs.push_back(
-              std::make_unique<MaterialModel::NamedAdditionalMaterialOutputs<dim>> (unique_phase_names, n_points));
-          }
-
-        if (out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
-          {
-            const unsigned int n_points = out.n_evaluation_points();
-            out.additional_outputs.push_back(
-              std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
-          }
-
-        if (out.template get_additional_output<PhaseOutputs<dim>>() == nullptr
-            && material_lookup[0]->has_dominant_phase())
-          {
-            const unsigned int n_points = out.n_evaluation_points();
-            out.additional_outputs.push_back(
-              std::make_unique<MaterialModel::PhaseOutputs<dim>> (n_points));
-          }
-      }
-
-
-
-      template <int dim>
-      const MaterialModel::MaterialUtilities::Lookup::MaterialLookup &
-      ThermodynamicTableLookup<dim>::get_material_lookup (unsigned int lookup_index) const
-      {
-        return *material_lookup[lookup_index].get();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace EquationOfState
-    {
-#define INSTANTIATE(dim) \
-  template class ThermodynamicTableLookup<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/source/material_model/grain_size.cc.bak b/source/material_model/grain_size.cc.bak
deleted file mode 100644
index 5f807ffa1ad..00000000000
--- a/source/material_model/grain_size.cc.bak
+++ /dev/null
@@ -1,1687 +0,0 @@
-/*
-  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/grain_size.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/heating_model/shear_heating.h>
-#include <aspect/material_model/rheology/visco_plastic.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/signaling_nan.h>
-
-#include <iostream>
-
-using namespace dealii;
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace
-    {
-      std::vector<std::string> make_dislocation_viscosity_outputs_names()
-      {
-        std::vector<std::string> names;
-        names.emplace_back("dislocation_viscosity");
-        names.emplace_back("diffusion_viscosity");
-        return names;
-      }
-    }
-
-
-
-    template <int dim>
-    DislocationViscosityOutputs<dim>::DislocationViscosityOutputs (const unsigned int n_points)
-      :
-      NamedAdditionalMaterialOutputs<dim>(make_dislocation_viscosity_outputs_names()),
-      dislocation_viscosities(n_points, numbers::signaling_nan<double>()),
-      diffusion_viscosities(n_points, numbers::signaling_nan<double>())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    DislocationViscosityOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      AssertIndexRange (idx, 2);
-      switch (idx)
-        {
-          case 0:
-            return dislocation_viscosities;
-
-          case 1:
-            return diffusion_viscosities;
-
-          default:
-            AssertThrow(false, ExcInternalError());
-        }
-      // we will never get here, so just return something
-      return dislocation_viscosities;
-    }
-
-
-
-    template <int dim>
-    void
-    GrainSize<dim>::initialize()
-    {
-      n_material_data = material_file_names.size();
-      for (unsigned i = 0; i < n_material_data; ++i)
-        {
-          if (material_file_format == perplex)
-            material_lookup
-            .push_back(std::make_unique<MaterialModel::MaterialUtilities::Lookup::PerplexReader>(datadirectory+material_file_names[i],
-                       use_bilinear_interpolation,
-                       this->get_mpi_communicator()));
-          else if (material_file_format == hefesto)
-            material_lookup
-            .push_back(std::make_unique<MaterialModel::MaterialUtilities::Lookup::HeFESToReader>(datadirectory+material_file_names[i],
-                       datadirectory+derivatives_file_names[i],
-                       use_bilinear_interpolation,
-                       this->get_mpi_communicator()));
-          else
-            AssertThrow (false, ExcNotImplemented());
-        }
-
-      AssertThrow( (grain_size_evolution_formulation != Formulation::paleopiezometer || !this->get_heating_model_manager().shear_heating_enabled()),
-                   ExcMessage("Shear heating output should not be used with the Paleopiezometer grain damage formulation."));
-    }
-
-
-
-    template <int dim>
-    unsigned int
-    GrainSize<dim>::
-    get_phase_index (const MaterialUtilities::PhaseFunctionInputs<dim> &in) const
-    {
-      Assert(grain_growth_activation_energy.size()>0,
-             ExcMessage("Error: No grain evolution parameters are given!"));
-
-      // Since phase transition depth increases monotonically, we only need
-      // to check for the first phase that has not yet undergone the transition
-      // (phase function value lower than 0.5).
-      for (unsigned int j=0; j<n_phase_transitions; ++j)
-        {
-          MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature,
-                                                                   in.pressure,
-                                                                   in.depth,
-                                                                   in.pressure_depth_derivative,
-                                                                   j);
-
-          if (phase_function.compute_value(phase_inputs) < 0.5)
-            return j;
-        }
-
-      return n_phase_transitions;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    compute_partitioning_fraction (const double temperature) const
-    {
-      const double power_term_base = maximum_grain_size_reduction_work_fraction/minimum_grain_size_reduction_work_fraction;
-
-      const double power_term_numerator    =  temperature_minimum_partitioning_power -
-                                              std::pow (temperature, grain_size_reduction_work_fraction_exponent);
-
-      const double power_term_denominator  =  temperature_minimum_partitioning_power -
-                                              temperature_maximum_partitioning_power;
-
-      // We have to ensure the power term exponent is between 0 and 1, otherwise the partitioning fraction
-      // will be outside the set bounds for the work fraction.
-      const double power_term_exponent = std::max(std::min(power_term_numerator / power_term_denominator, 1.0), 0.0);
-
-      const double power_term = std::pow(power_term_base,
-                                         power_term_exponent);
-
-      return minimum_grain_size_reduction_work_fraction * power_term;
-    }
-
-
-
-    namespace
-    {
-      double moment_of_grain_size_distribution (const unsigned int n)
-      {
-        // This function normalizes the grain size distribution using the nth moment.
-        // Description can be found in eq 8 of Bercovici and Richard (2012)
-        // This is the variance of the log-normal distribution
-        const double sigma = 0.8;
-
-        return std::exp(n * n * sigma * sigma / 2.);
-      }
-
-
-
-      double phase_distribution_function (const double volume_fraction_phase_one)
-      {
-        // This factor is used in pinned state grain damage formulation.
-        const double volume_fraction_phase_two = 1. - volume_fraction_phase_one;
-
-        return (volume_fraction_phase_one * volume_fraction_phase_two);
-      }
-
-
-
-      double
-      roughness_to_grain_size_factor (const double volume_fraction_phase_one)
-      {
-        // This factor is used to convert from an interface roughness equation to a mean grain size
-        // Refer to Appendix H.1, eqs 8, F.28 in Bercovici and Richard (2012) for more details.
-        const double b1 = 1./20 ;
-        const double c1 = 3.0 * b1 * moment_of_grain_size_distribution(4) / (8.0 * moment_of_grain_size_distribution (2));
-
-        const double volume_fraction_phase_two = 1. - volume_fraction_phase_one;
-
-        const double h1 = c1 * (1 - volume_fraction_phase_one);
-        const double h2 = c1 * (1 - volume_fraction_phase_two);
-
-        const double one_over_sqrt_h = volume_fraction_phase_one / std::sqrt(h1) + volume_fraction_phase_two / std::sqrt(h2);
-
-        return (1./one_over_sqrt_h);
-      }
-    }
-
-
-
-    template <int dim>
-    std::vector<std::vector<double>>
-    GrainSize<dim>::
-    grain_size_change (const typename Interface<dim>::MaterialModelInputs &in,
-                       const std::vector<double>                          &pressures,
-                       const std::vector<unsigned int>                    &phase_indices) const
-    {
-      // We want to iterate over the grain size evolution here, as we solve in fact an ordinary differential equation
-      // and it is not correct to use the starting grain size (and it introduces instabilities).
-      // We assume that the strain rate is constant across all substeps for the ODE (within one advection step).
-      // Even though this assumption may not always be the most accurate (compared to assuming a constant stress),
-      // it leads to a more stable behavior because it implies that a reduction in grain size leads to less work
-      // being done by dislocation creep, so that the grain size reduction rate is lower in the next substep.
-      std::vector<std::vector<double>> reaction_terms (in.n_evaluation_points(), std::vector<double>(this->n_compositional_fields(), 0.0));
-
-      // Set up a vector that tells us which phase transition has been crossed for each point we are evaluating.
-      std::vector<int> crossed_transitions (in.n_evaluation_points(), -1);
-
-      using VectorType = Vector<double>;
-      VectorType grain_sizes(in.n_evaluation_points());
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        grain_sizes[i] = std::max(min_grain_size, in.composition[i][grain_size_index]);
-
-      const double timestep = this->simulator_is_past_initialization()
-                              ?
-                              this->get_timestep()
-                              :
-                              0.0;
-
-      if (std::all_of(grain_sizes.begin(), grain_sizes.end(), [](double gs)
-      {
-        return gs != gs || gs < std::numeric_limits<double>::min();
-        })
-      || timestep == 0.0)
-      return reaction_terms;
-
-      SUNDIALS::ARKode<VectorType>::AdditionalData data;
-
-      data.initial_time = 0.0;
-      data.final_time = this->get_timestep();
-
-      // TODO: make this an input parameter.
-      data.initial_step_size = 0.001 * this->get_timestep();
-      data.output_period = this->get_timestep();
-      data.minimum_step_size = 1.e-6*this->get_timestep();
-      data.maximum_order = 3;
-      data.maximum_non_linear_iterations = 30;
-
-      // Because both tolerances are added, we set the absolute
-      // tolerance to 0.
-      data.relative_tolerance = 1e-3;
-      data.absolute_tolerance = 0;
-
-      SUNDIALS::ARKode<VectorType> ode(data);
-      ode.explicit_function = [&] (const double     /*time*/,
-                                   const VectorType &y,
-                                   VectorType       &grain_size_rates_of_change)
-      {
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            const double grain_size = std::max(min_grain_size, y[i]);
-
-            // Precompute the partitioning_fraction since it is constant during the evolution.
-            // This is only used for the pinned_grain_damage formulation.
-            const double partitioning_fraction = (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
-                                                 ?
-                                                 compute_partitioning_fraction(in.temperature[i])
-                                                 :
-                                                 0.0;
-
-            // We keep the dislocation viscosity of the last iteration as guess
-            // for the next one.
-            double current_dislocation_viscosity = 0.0;
-
-            const double adiabatic_temperature = this->get_adiabatic_conditions().is_initialized()
-                                                 ?
-                                                 this->get_adiabatic_conditions().temperature(in.position[i])
-                                                 :
-                                                 in.temperature[i];
-
-
-
-            // grain size growth due to Ostwald ripening
-            const double m = grain_growth_exponent[phase_indices[i]];
-
-            double grain_size_growth_rate = grain_growth_rate_constant[phase_indices[i]] / (m * std::pow(grain_size,m-1))
-                                            * std::exp(- (grain_growth_activation_energy[phase_indices[i]] + pressures[i] * grain_growth_activation_volume[phase_indices[i]])
-                                                       / (constants::gas_constant * in.temperature[i]));
-
-            // in the two-phase damage model grain growth depends on the proportion of the two phases
-            if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
-              grain_size_growth_rate *= geometric_constant[phase_indices[i]] * phase_distribution /
-                                        std::pow(roughness_to_grain_size, m);
-
-            // grain size reduction in dislocation creep regime
-            const SymmetricTensor<2,dim> shear_strain_rate = in.strain_rate[i] - 1./dim * trace(in.strain_rate[i]) * unit_symmetric_tensor<dim>();
-            const double second_strain_rate_invariant = std::sqrt(std::max(-second_invariant(shear_strain_rate), 0.));
-
-            const double current_diffusion_viscosity   = diffusion_viscosity(in.temperature[i], adiabatic_temperature, pressures[i], grain_size, second_strain_rate_invariant, phase_indices[i]);
-            current_dislocation_viscosity = dislocation_viscosity(in.temperature[i], adiabatic_temperature, pressures[i], in.strain_rate[i], phase_indices[i], current_diffusion_viscosity, current_dislocation_viscosity);
-
-            double current_viscosity;
-            if (std::abs(second_strain_rate_invariant) > 1e-30)
-              current_viscosity = current_dislocation_viscosity * current_diffusion_viscosity / (current_dislocation_viscosity + current_diffusion_viscosity);
-            else
-              current_viscosity = current_diffusion_viscosity;
-
-            const double dislocation_strain_rate = second_strain_rate_invariant
-                                                   * current_viscosity / current_dislocation_viscosity;
-
-            double grain_size_reduction_rate = 0.0;
-
-            if (grain_size_evolution_formulation == Formulation::paleowattmeter)
-              {
-                // paleowattmeter: Austin and Evans (2007): Paleowattmeters: A scaling relation for dynamically recrystallized grain size. Geology 35, 343-346
-                const double stress = 2.0 * second_strain_rate_invariant * std::min(std::max(min_eta,current_viscosity),max_eta);
-                grain_size_reduction_rate = 2.0 * stress * boundary_area_change_work_fraction[phase_indices[i]] * dislocation_strain_rate * grain_size * grain_size
-                                            / (geometric_constant[phase_indices[i]] * grain_boundary_energy[phase_indices[i]]);
-              }
-            else if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
-              {
-                // pinned_grain_damage: Mulyukova and Bercovici (2018) Collapse of passive margins by lithospheric damage and plunging grain size. Earth and Planetary Science Letters, 484, 341-352.
-                const double stress = 2.0 * second_strain_rate_invariant * std::min(std::max(min_eta,current_viscosity),max_eta);
-                grain_size_reduction_rate = 2.0 * stress * partitioning_fraction * second_strain_rate_invariant * grain_size * grain_size
-                                            * roughness_to_grain_size
-                                            / (geometric_constant[phase_indices[i]] * grain_boundary_energy[phase_indices[i]] * phase_distribution);
-              }
-            else if (grain_size_evolution_formulation == Formulation::paleopiezometer)
-              {
-                // paleopiezometer: Hall and Parmentier (2003): Influence of grain size evolution on convective instability. Geochem. Geophys. Geosyst., 4(3).
-                grain_size_reduction_rate = reciprocal_required_strain[phase_indices[i]] * dislocation_strain_rate * grain_size;
-              }
-            else
-              AssertThrow(false, ExcNotImplemented());
-
-            grain_size_rates_of_change[i] = grain_size_growth_rate - grain_size_reduction_rate;
-          }
-      };
-
-
-      const unsigned int iteration_count = ode.solve_ode(grain_sizes);
-      this->get_signals().post_ARKode_solve(*this, iteration_count);
-
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          Assert(grain_sizes[i] > 0,
-                 ExcMessage("The grain size became smaller than zero. This is not valid, "
-                            "and likely an effect of a too large sub-timestep, or unrealistic "
-                            "input parameters."));
-
-          // reduce grain size to recrystallized_grain_size when crossing phase transitions
-          // if the distance in radial direction a grain moved compared to the last time step
-          // is crossing a phase transition, reduce grain size
-
-          const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[i]).norm();
-          Tensor<1,dim> vertical_direction = this->get_gravity_model().gravity_vector(in.position[i]);
-          if (gravity_norm > 0.0)
-            vertical_direction /= gravity_norm;
-
-          int crossed_transition = -1;
-
-          // Figure out if the material in the current cell underwent a phase change.
-          // To do so, check if a grain has moved further than the distance from the phase transition and
-          // if the velocity is in the direction of the phase change. After the check 'crossed_transition' will
-          // be -1 if we crossed no transition, or the index of the phase transition, if we crossed it.
-          for (unsigned int phase=0; phase<n_phase_transitions; ++phase)
-            {
-              // Both distances are positive when they are downward from the transition (since gravity points down)
-              const double distance_from_transition = this->get_geometry_model().depth(in.position[i]) - phase_function.get_transition_depth(phase);
-              const double distance_moved = in.velocity[i] * vertical_direction * timestep;
-
-              // If we are close to the phase boundary (closer than the distance a grain has moved
-              // within one time step) and the velocity points away from the phase transition,
-              // then the material has crossed the transition.
-              // To make sure we actually reset the grain size of all the material passing through
-              // the transition, we take 110% of the distance a grain has moved for the check.
-              if (std::abs(distance_moved) * 1.1 > std::abs(distance_from_transition)
-                  &&
-                  distance_moved * distance_from_transition >= 0)
-                crossed_transition = phase;
-            }
-
-          // TODO: recrystallize first, and then do grain size growth/reduction for grains that crossed the transition
-          // in dependence of the distance they have moved
-          double phase_grain_size_reduction = 0.0;
-          if (this->get_timestep_number() > 0)
-            {
-              // check if material has crossed any phase transition, if yes, reset grain size
-              if (crossed_transition != -1)
-                if (recrystallized_grain_size[crossed_transition] > 0.0)
-                  phase_grain_size_reduction = grain_sizes[i] - recrystallized_grain_size[crossed_transition];
-            }
-
-          grain_sizes[i] = std::max(grain_sizes[i], minimum_grain_size);
-          const double grain_size_change = grain_sizes[i] - in.composition[i][grain_size_index] - phase_grain_size_reduction;
-
-          reaction_terms[i][grain_size_index] = grain_size_change;
-          // We do not have to fill the other fields because we have initialized them with zero.
-        }
-
-      return reaction_terms;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    diffusion_viscosity (const double temperature,
-                         const double adiabatic_temperature,
-                         const double adiabatic_pressure,
-                         const double grain_size,
-                         const double second_strain_rate_invariant,
-                         const unsigned int phase_index) const
-    {
-      double energy_term = std::exp((diffusion_activation_energy[phase_index] + diffusion_activation_volume[phase_index] * adiabatic_pressure)
-                                    / (diffusion_creep_exponent[phase_index] * constants::gas_constant * temperature));
-
-      // If the adiabatic profile is already calculated we can use it to limit
-      // variations in viscosity due to temperature.
-      if (this->get_adiabatic_conditions().is_initialized())
-        {
-          const double adiabatic_energy_term
-            = std::exp((diffusion_activation_energy[phase_index] + diffusion_activation_volume[phase_index] * adiabatic_pressure)
-                       / (diffusion_creep_exponent[phase_index] * constants::gas_constant * adiabatic_temperature));
-
-          const double temperature_dependence = energy_term / adiabatic_energy_term;
-          if (temperature_dependence > max_temperature_dependence_of_eta)
-            energy_term = adiabatic_energy_term * max_temperature_dependence_of_eta;
-          if (temperature_dependence < 1.0 / max_temperature_dependence_of_eta)
-            energy_term = adiabatic_energy_term / max_temperature_dependence_of_eta;
-        }
-
-      const double strain_rate_dependence = (1.0 - diffusion_creep_exponent[phase_index]) / diffusion_creep_exponent[phase_index];
-
-      return diffusion_creep_prefactor[phase_index]
-             * std::pow(second_strain_rate_invariant,strain_rate_dependence)
-             * std::pow(grain_size, diffusion_creep_grain_size_exponent[phase_index]/diffusion_creep_exponent[phase_index])
-             * energy_term;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    dislocation_viscosity (const double temperature,
-                           const double adiabatic_temperature,
-                           const double adiabatic_pressure,
-                           const SymmetricTensor<2,dim> &strain_rate,
-                           const unsigned int phase_index,
-                           const double diffusion_viscosity,
-                           const double viscosity_guess) const
-    {
-      // find out in which phase we are
-      double energy_term = std::exp((dislocation_activation_energy[phase_index] + dislocation_activation_volume[phase_index] * adiabatic_pressure)
-                                    / (dislocation_creep_exponent[phase_index] * constants::gas_constant * temperature));
-
-      // If we are past the initialization of the adiabatic profile, use it to
-      // limit viscosity variations due to temperature.
-      if (this->get_adiabatic_conditions().is_initialized())
-        {
-          const double adiabatic_energy_term
-            = std::exp((dislocation_activation_energy[phase_index] + dislocation_activation_volume[phase_index] * adiabatic_pressure)
-                       / (dislocation_creep_exponent[phase_index] * constants::gas_constant * adiabatic_temperature));
-
-          const double temperature_dependence = energy_term / adiabatic_energy_term;
-          if (temperature_dependence > max_temperature_dependence_of_eta)
-            energy_term = adiabatic_energy_term * max_temperature_dependence_of_eta;
-          if (temperature_dependence < 1.0 / max_temperature_dependence_of_eta)
-            energy_term = adiabatic_energy_term / max_temperature_dependence_of_eta;
-        }
-
-      const double strain_rate_dependence = (1.0 - dislocation_creep_exponent[phase_index]) / dislocation_creep_exponent[phase_index];
-      const SymmetricTensor<2,dim> shear_strain_rate = strain_rate - 1./dim * trace(strain_rate) * unit_symmetric_tensor<dim>();
-      const double second_strain_rate_invariant = std::sqrt(std::max(-second_invariant(shear_strain_rate), 0.));
-
-      // If the strain rate is zero, the dislocation viscosity is infinity.
-      if (second_strain_rate_invariant <= std::numeric_limits<double>::min())
-        return std::numeric_limits<double>::min();
-
-      // Start the iteration with the full strain rate
-      double dis_viscosity;
-      if (viscosity_guess == 0)
-        dis_viscosity = dislocation_creep_prefactor[phase_index]
-                        * std::pow(second_strain_rate_invariant,strain_rate_dependence)
-                        * energy_term;
-      else
-        dis_viscosity = viscosity_guess;
-
-      double dis_viscosity_old = 0;
-      unsigned int i = 0;
-      while ((std::abs((dis_viscosity-dis_viscosity_old) / dis_viscosity) > dislocation_viscosity_iteration_threshold)
-             && (i < dislocation_viscosity_iteration_number))
-        {
-          const SymmetricTensor<2,dim> dislocation_strain_rate = diffusion_viscosity
-                                                                 / (diffusion_viscosity + dis_viscosity) * shear_strain_rate;
-          const double dislocation_strain_rate_invariant = std::sqrt(std::max(-second_invariant(dislocation_strain_rate), 0.));
-
-          dis_viscosity_old = dis_viscosity;
-          dis_viscosity = dislocation_creep_prefactor[phase_index]
-                          * std::pow(dislocation_strain_rate_invariant,strain_rate_dependence)
-                          * energy_term;
-          ++i;
-        }
-
-      Assert(i<dislocation_viscosity_iteration_number,ExcInternalError());
-
-      return dis_viscosity;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    enthalpy (const double      temperature,
-              const double      pressure,
-              const std::vector<double> &compositional_fields,
-              const Point<dim> &/*position*/) const
-    {
-      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
-                   ExcMessage("Currently only compressible models are supported."));
-
-      double enthalpy = 0.0;
-      if (n_material_data == 1)
-        enthalpy = material_lookup[0]->enthalpy(temperature,pressure);
-      else
-        {
-          for (unsigned i = 0; i < n_material_data; ++i)
-            enthalpy += compositional_fields[i] * material_lookup[i]->enthalpy(temperature,pressure);
-        }
-      return enthalpy;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    seismic_Vp (const double      temperature,
-                const double      pressure,
-                const std::vector<double> &compositional_fields,
-                const Point<dim> &/*position*/) const
-    {
-      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
-                   ExcMessage("Currently only compressible models are supported."));
-
-      double vp = 0.0;
-      if (n_material_data == 1)
-        vp = material_lookup[0]->seismic_Vp(temperature,pressure);
-      else
-        {
-          for (unsigned i = 0; i < n_material_data; ++i)
-            vp += compositional_fields[i] * material_lookup[i]->seismic_Vp(temperature,pressure);
-        }
-      return vp;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    seismic_Vs (const double      temperature,
-                const double      pressure,
-                const std::vector<double> &compositional_fields,
-                const Point<dim> &/*position*/) const
-    {
-      AssertThrow ((reference_compressibility != 0.0) || use_table_properties,
-                   ExcMessage("Currently only compressible models are supported."));
-
-      double vs = 0.0;
-      if (n_material_data == 1)
-        vs = material_lookup[0]->seismic_Vs(temperature,pressure);
-      else
-        {
-          for (unsigned i = 0; i < n_material_data; ++i)
-            vs += compositional_fields[i] * material_lookup[i]->seismic_Vs(temperature,pressure);
-        }
-      return vs;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    density (const double temperature,
-             const double pressure,
-             const std::vector<double> &compositional_fields, /*composition*/
-             const Point<dim> &) const
-    {
-      if (!use_table_properties)
-        {
-          return reference_rho * std::exp(reference_compressibility * (pressure - this->get_surface_pressure()))
-                 * (1 - thermal_alpha * (temperature - reference_T));
-        }
-      else
-        {
-          double rho = 0.0;
-          if (n_material_data == 1)
-            {
-              rho = material_lookup[0]->density(temperature,pressure);
-            }
-          else
-            {
-              for (unsigned i = 0; i < n_material_data; ++i)
-                rho += compositional_fields[i] * material_lookup[i]->density(temperature,pressure);
-            }
-
-          return rho;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    GrainSize<dim>::
-    is_compressible () const
-    {
-      return (reference_compressibility != 0)
-             || use_table_properties;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    compressibility (const double temperature,
-                     const double pressure,
-                     const std::vector<double> &compositional_fields,
-                     const Point<dim> &position) const
-    {
-      if (!use_table_properties)
-        return reference_compressibility;
-
-      double dRhodp = 0.0;
-      if (n_material_data == 1)
-        dRhodp = material_lookup[0]->dRhodp(temperature,pressure);
-      else
-        {
-          for (unsigned i = 0; i < n_material_data; ++i)
-            dRhodp += compositional_fields[i] * material_lookup[i]->dRhodp(temperature,pressure);
-        }
-      const double rho = density(temperature,pressure,compositional_fields,position);
-      return (1/rho)*dRhodp;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    thermal_expansion_coefficient (const double      temperature,
-                                   const double      pressure,
-                                   const std::vector<double> &compositional_fields,
-                                   const Point<dim> &/*position*/) const
-    {
-      double alpha = 0.0;
-      if (!use_table_properties)
-        return thermal_alpha;
-      else
-        {
-          if (n_material_data == 1)
-            alpha = material_lookup[0]->thermal_expansivity(temperature,pressure);
-          else
-            {
-              for (unsigned i = 0; i < n_material_data; ++i)
-                alpha += compositional_fields[i] * material_lookup[i]->thermal_expansivity(temperature,pressure);
-            }
-        }
-      alpha = std::max(std::min(alpha,max_thermal_expansivity),min_thermal_expansivity);
-      return alpha;
-    }
-
-
-
-    template <int dim>
-    double
-    GrainSize<dim>::
-    specific_heat (const double temperature,
-                   const double pressure,
-                   const std::vector<double> &compositional_fields,
-                   const Point<dim> &/*position*/) const
-    {
-      double cp = 0.0;
-      if (!use_table_properties)
-        return reference_specific_heat;
-      else
-        {
-          if (n_material_data == 1)
-            cp = material_lookup[0]->specific_heat(temperature,pressure);
-          else
-            {
-              for (unsigned i = 0; i < n_material_data; ++i)
-                cp += compositional_fields[i] * material_lookup[i]->specific_heat(temperature,pressure);
-            }
-        }
-      cp = std::max(std::min(cp,max_specific_heat),min_specific_heat);
-      return cp;
-    }
-
-
-
-    template <int dim>
-    std::array<std::pair<double, unsigned int>,2>
-    GrainSize<dim>::
-    enthalpy_derivative (const typename Interface<dim>::MaterialModelInputs &in) const
-    {
-      std::array<std::pair<double, unsigned int>,2> derivative;
-
-      if (in.current_cell.state() == IteratorState::valid)
-        {
-          // get the pressures and temperatures at the vertices of the cell
-          const QTrapezoid<dim> quadrature_formula;
-
-          std::vector<double> solution_values(this->get_fe().dofs_per_cell);
-          in.current_cell->get_dof_values(this->get_current_linearization_point(),
-                                          solution_values.begin(),
-                                          solution_values.end());
-
-          // Only create the evaluator the first time we get here
-          if (!temperature_evaluator)
-            temperature_evaluator
-              = std::make_unique<FEPointEvaluation<1,dim>>(this->get_mapping(),
-                                                            this->get_fe(),
-                                                            update_values,
-                                                            this->introspection().component_indices.temperature);
-          if (!pressure_evaluator)
-            pressure_evaluator
-              = std::make_unique<FEPointEvaluation<1,dim>>(this->get_mapping(),
-                                                            this->get_fe(),
-                                                            update_values,
-                                                            this->introspection().component_indices.pressure);
-
-
-          // Initialize the evaluator for the temperature
-          temperature_evaluator->reinit(in.current_cell, quadrature_formula.get_points());
-          temperature_evaluator->evaluate(solution_values,
-                                          EvaluationFlags::values);
-
-          // Initialize the evaluator for the pressure
-          pressure_evaluator->reinit(in.current_cell, quadrature_formula.get_points());
-          pressure_evaluator->evaluate(solution_values,
-                                       EvaluationFlags::values);
-
-          std::vector<double> temperatures(quadrature_formula.size());
-          std::vector<double> pressures(quadrature_formula.size());
-
-          for (unsigned int i=0; i<quadrature_formula.size(); ++i)
-            {
-              temperatures[i] = temperature_evaluator->get_value(i);
-              pressures[i] = pressure_evaluator->get_value(i);
-            }
-
-          AssertThrow (material_lookup.size() == 1,
-                       ExcMessage("This formalism is only implemented for one material "
-                                  "table."));
-
-          // We have to take into account here that the p,T spacing of the table of material properties
-          // we use might be on a finer grid than our model. Because of that we compute the enthalpy
-          // derivatives by using finite differences that average over the whole temperature and
-          // pressure range that is used in this cell. This way we should not miss any phase transformation.
-          derivative = material_lookup[0]->enthalpy_derivatives(temperatures,
-                                                                pressures,
-                                                                max_latent_heat_substeps);
-        }
-
-      return derivative;
-    }
-
-
-
-    template <int dim>
-    void
-    GrainSize<dim>::
-    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      std::vector<double> adiabatic_pressures (in.n_evaluation_points());
-      std::vector<unsigned int> phase_indices (in.n_evaluation_points());
-
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          // Use the adiabatic pressure instead of the real one, because of oscillations
-          adiabatic_pressures[i] = (this->get_adiabatic_conditions().is_initialized())
-                                   ?
-                                   this->get_adiabatic_conditions().pressure(in.position[i])
-                                   :
-                                   in.pressure[i];
-
-          const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[i]).norm();
-
-          out.densities[i] = density(in.temperature[i], adiabatic_pressures[i], in.composition[i], in.position[i]);
-          out.thermal_conductivities[i] = k_value;
-          out.compressibilities[i] = compressibility(in.temperature[i], adiabatic_pressures[i], in.composition[i], in.position[i]);
-
-          // We do not fill the phase function index, because that will be done internally in the get_phase_index() function
-          const double depth = this->get_geometry_model().depth(in.position[i]);
-          const double rho_g = out.densities[i] * gravity_norm;
-          MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature[i], adiabatic_pressures[i], depth, rho_g, numbers::invalid_unsigned_int);
-          phase_indices[i] = get_phase_index(phase_inputs);
-
-          if (in.requests_property(MaterialProperties::viscosity))
-            {
-              double effective_viscosity;
-              double disl_viscosity = std::numeric_limits<double>::max();
-              Assert(std::isfinite(in.strain_rate[i].norm()),
-                     ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                                "not filled by the caller."));
-              const SymmetricTensor<2,dim> shear_strain_rate = deviator(in.strain_rate[i]);
-              const double second_strain_rate_invariant = std::sqrt(std::max(-second_invariant(shear_strain_rate), 0.));
-
-              const double adiabatic_temperature = this->get_adiabatic_conditions().is_initialized()
-                                                   ?
-                                                   this->get_adiabatic_conditions().temperature(in.position[i])
-                                                   :
-                                                   in.temperature[i];
-
-              // Make sure grain size is not negative/too small.
-              std::vector<double> composition (in.composition[i]);
-              composition[grain_size_index] = std::max(min_grain_size,composition[grain_size_index]);
-
-              const double diff_viscosity = diffusion_viscosity(in.temperature[i],
-                                                                adiabatic_temperature,
-                                                                adiabatic_pressures[i],
-                                                                composition[grain_size_index],
-                                                                second_strain_rate_invariant,
-                                                                phase_indices[i]);
-
-              if (std::abs(second_strain_rate_invariant) > 1e-30)
-                {
-                  disl_viscosity = dislocation_viscosity(in.temperature[i], adiabatic_temperature, adiabatic_pressures[i], in.strain_rate[i], phase_indices[i], diff_viscosity);
-                  effective_viscosity = disl_viscosity * diff_viscosity / (disl_viscosity + diff_viscosity);
-                }
-              else
-                effective_viscosity = diff_viscosity;
-
-              if (enable_drucker_prager_rheology)
-                {
-                  // Calculate non-yielding (viscous) stress magnitude.
-                  const double non_yielding_stress = 2. * effective_viscosity * second_strain_rate_invariant;
-
-                  // The following handles phases
-                  std::vector<unsigned int> n_phases = {n_phase_transitions+1};
-                  std::vector<double> phase_function_values(n_phase_transitions, 0.0);
-
-                  for (unsigned int k=0; k<n_phase_transitions; ++k)
-                    {
-                      phase_inputs.phase_index = k;
-                      phase_function_values[k] = phase_function.compute_value(phase_inputs);
-                    }
-
-                  // In the grain size material model, viscosity does not depend on composition,
-                  // so we set the compositional index for the Drucker-Prager parameters to 0.
-                  const Rheology::DruckerPragerParameters drucker_prager_parameters = drucker_prager_plasticity.compute_drucker_prager_parameters(0,
-                                                                                      phase_function_values,
-                                                                                      n_phases);
-                  const double pressure_for_yielding = use_adiabatic_pressure_for_yielding
-                                                       ?
-                                                       adiabatic_pressures[i]
-                                                       :
-                                                       std::max(in.pressure[i],0.0);
-
-                  const double yield_stress = drucker_prager_plasticity.compute_yield_stress(drucker_prager_parameters.cohesion,
-                                                                                             drucker_prager_parameters.angle_internal_friction,
-                                                                                             pressure_for_yielding,
-                                                                                             drucker_prager_parameters.max_yield_stress);
-
-                  // Apply plastic yielding:
-                  // If the non-yielding stress is greater than the yield stress,
-                  // rescale the viscosity back to yield surface
-                  if (non_yielding_stress >= yield_stress)
-                    {
-                      effective_viscosity = drucker_prager_plasticity.compute_viscosity(drucker_prager_parameters.cohesion,
-                                                                                        drucker_prager_parameters.angle_internal_friction,
-                                                                                        pressure_for_yielding,
-                                                                                        second_strain_rate_invariant,
-                                                                                        drucker_prager_parameters.max_yield_stress,
-                                                                                        effective_viscosity);
-                    }
-
-                  PlasticAdditionalOutputs<dim> *plastic_out = out.template get_additional_output<PlasticAdditionalOutputs<dim>>();
-
-                  if (plastic_out != nullptr)
-                    {
-                      plastic_out->cohesions[i] = drucker_prager_parameters.cohesion;
-                      plastic_out->friction_angles[i] = drucker_prager_parameters.angle_internal_friction;
-                      plastic_out->yield_stresses[i] = yield_stress;
-                      plastic_out->yielding[i] = non_yielding_stress >= yield_stress ? 1 : 0;
-                    }
-                }
-
-              out.viscosities[i] = std::min(std::max(min_eta,effective_viscosity),max_eta);
-
-              if (DislocationViscosityOutputs<dim> *disl_viscosities_out = out.template get_additional_output<DislocationViscosityOutputs<dim>>())
-                {
-                  disl_viscosities_out->dislocation_viscosities[i] = std::min(std::max(min_eta,disl_viscosity),1e300);
-                  disl_viscosities_out->diffusion_viscosities[i] = std::min(std::max(min_eta,diff_viscosity),1e300);
-                }
-
-              if (HeatingModel::ShearHeatingOutputs<dim> *shear_heating_out = out.template get_additional_output<HeatingModel::ShearHeatingOutputs<dim>>())
-                {
-                  if (grain_size_evolution_formulation == Formulation::paleowattmeter)
-                    {
-                      const double f = boundary_area_change_work_fraction[phase_indices[i]];
-                      shear_heating_out->shear_heating_work_fractions[i] = 1. - f * out.viscosities[i] / std::min(std::max(min_eta,disl_viscosity),1e300);
-                    }
-                  else if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
-                    {
-                      const double f = compute_partitioning_fraction(in.temperature[i]);
-                      shear_heating_out->shear_heating_work_fractions[i] = 1. - f;
-                    }
-                  else
-                    AssertThrow(false, ExcNotImplemented());
-                }
-            }
-
-          // fill seismic velocities outputs if they exist
-          if (use_table_properties)
-            if (SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>())
-              {
-                seismic_out->vp[i] = seismic_Vp(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
-                seismic_out->vs[i] = seismic_Vs(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
-              }
-        }
-
-      if (in.requests_property(MaterialProperties::reaction_terms))
-        out.reaction_terms = grain_size_change(in, adiabatic_pressures, phase_indices);
-
-
-      /* We separate the calculation of specific heat and thermal expansivity,
-       * because they depend on cell-wise averaged values that are only available
-       * here
-       */
-      double average_temperature(0.0);
-      double average_density(0.0);
-      for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
-        {
-          average_temperature += in.temperature[i];
-          average_density += out.densities[i];
-        }
-      average_temperature /= in.n_evaluation_points();
-      average_density /= in.n_evaluation_points();
-
-      std::array<std::pair<double, unsigned int>,2> dH;
-
-      if (use_table_properties && use_enthalpy)
-        dH = enthalpy_derivative(in);
-
-      for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
-        {
-          if (!use_table_properties)
-            {
-              out.thermal_expansion_coefficients[i] = thermal_alpha;
-              out.specific_heat[i] = reference_specific_heat;
-            }
-          else if (use_enthalpy)
-            {
-              if (this->get_adiabatic_conditions().is_initialized()
-                  && (in.current_cell.state() == IteratorState::valid)
-                  && (dH[0].second > 0)
-                  && (dH[1].second > 0))
-                {
-                  out.thermal_expansion_coefficients[i] = (1 - average_density * dH[1].first) / average_temperature;
-                  out.specific_heat[i] = dH[0].first;
-                }
-              else
-                {
-                  if (material_lookup.size() == 1)
-                    {
-                      out.thermal_expansion_coefficients[i] = (1 - out.densities[i] * material_lookup[0]->dHdp(in.temperature[i],adiabatic_pressures[i])) / in.temperature[i];
-                      out.specific_heat[i] = material_lookup[0]->dHdT(in.temperature[i],adiabatic_pressures[i]);
-                    }
-                  else
-                    {
-                      ExcNotImplemented();
-                    }
-                }
-            }
-          else
-            {
-              out.thermal_expansion_coefficients[i] = thermal_expansion_coefficient(in.temperature[i], adiabatic_pressures[i], in.composition[i], in.position[i]);
-              out.specific_heat[i] = specific_heat(in.temperature[i], adiabatic_pressures[i], in.composition[i], in.position[i]);
-            }
-
-          out.thermal_expansion_coefficients[i] = std::max(std::min(out.thermal_expansion_coefficients[i],max_thermal_expansivity),min_thermal_expansivity);
-          out.specific_heat[i] = std::max(std::min(out.specific_heat[i],max_specific_heat),min_specific_heat);
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    GrainSize<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Grain size model");
-        {
-          prm.declare_entry ("Reference density", "3300",
-                             Patterns::Double (0.),
-                             "The reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Viscosity", "5e24",
-                             Patterns::Double (0.),
-                             "The value of the constant viscosity. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250.",
-                             Patterns::Double (0.),
-                             "The value of the specific heat $cp$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\alpha$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Reference compressibility", "4e-12",
-                             Patterns::Double (0.),
-                             "The value of the reference compressibility. "
-                             "Units: \\si{\\per\\pascal}.");
-
-          MaterialUtilities::PhaseFunction<dim>::declare_parameters(prm);
-
-          prm.declare_entry ("Grain growth activation energy", "3.5e5",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The activation energy for grain growth $E_g$. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\joule\\per\\mole}.");
-          prm.declare_entry ("Grain growth activation volume", "8e-6",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The activation volume for grain growth $V_g$. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
-          prm.declare_entry ("Grain growth exponent", "3.",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The exponent of the grain growth law $p_g$. This is an experimentally determined "
-                             "grain growth constant. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: none.");
-          prm.declare_entry ("Grain growth rate constant", "1.5e-5",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The prefactor for the Ostwald ripening grain growth law $G_0$. "
-                             "This is dependent on water content, which is assumed to be "
-                             "50 H/$10^6$ Si for the default value. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\meter}$^{p_g}$\\si{\\per\\second}.");
-          prm.declare_entry ("Minimum grain size", "5e-6",
-                             Patterns::Double (0.),
-                             "The minimum allowable grain size. The grain size will be limited to be "
-                             "larger than this value. This can be used to damp out oscillations, or "
-                             "to limit the viscosity variation due to grain size. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Reciprocal required strain", "10.",
-                             Patterns::List (Patterns::Double (0.)),
-                             "This parameter ($\\lambda$) gives an estimate of the strain necessary "
-                             "to achieve a new grain size. "
-                             "List must have one more entry than the Phase transition depths.");
-          prm.declare_entry ("Recrystallized grain size", "",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The grain size $d_{ph}$ to that a phase will be reduced to when crossing a phase transition. "
-                             "When set to zero, grain size will not be reduced. "
-                             "List must have the same number of entries as Phase transition depths. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Phase volume fraction", "0.4",
-                             Patterns::Double (0., 1.),
-                             "The volume fraction of one of the phases in the two-phase damage model of Bercovici and Ricard (2012). "
-                             "The volume fraction of the other phase can be simply calculated by subtracting from one. "
-                             "This parameter is only used in the pinned state grain damage formulation."
-                             "Units: none.");
-          prm.declare_entry ("Grain size evolution formulation", "paleowattmeter",
-                             Patterns::Selection ("paleowattmeter|paleopiezometer|pinned grain damage"),
-                             "A flag indicating whether the material model should use the "
-                             "paleowattmeter approach of Austin and Evans (2007) for grain size reduction "
-                             "in the dislocation creep regime, the paleopiezometer approach "
-                             "from Hall and Parmetier (2003), or the pinned grain damage approach "
-                             "from Mulyukova and Bercovici (2018).");
-          prm.declare_entry ("Use paleowattmeter", "default",
-                             Patterns::Selection ("true|false|default"),
-                             "A flag indicating whether the computation should use the "
-                             "paleowattmeter approach of Austin and Evans (2007) for grain size reduction "
-                             "in the dislocation creep regime (if true) or the paleopiezometer approach "
-                             "from Hall and Parmetier (2003) (if false). This parameter has been removed. "
-                             "Use 'Grain size evolution formulation' instead.");
-          prm.declare_entry ("Average specific grain boundary energy", "1.0",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The average specific grain boundary energy $\\gamma$. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\joule\\per\\meter\\squared}.");
-          prm.declare_entry ("Work fraction for boundary area change", "0.1",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The fraction $\\chi$ of work done by dislocation creep to change the grain boundary area. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\joule\\per\\meter\\squared}.");
-          prm.declare_entry ("Geometric constant", "3.",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The geometric constant $c$ used in the paleowattmeter grain size reduction law. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: none.");
-          prm.declare_entry ("Dislocation viscosity iteration threshold", "1e-3",
-                             Patterns::Double (0.),
-                             "We need to perform an iteration inside the computation "
-                             "of the dislocation viscosity, because it depends on the "
-                             "dislocation strain rate, which depends on the dislocation "
-                             "viscosity itself. This number determines the termination "
-                             "accuracy, i.e. if the dislocation viscosity changes by less "
-                             "than this factor we terminate the iteration.");
-          prm.declare_entry ("Dislocation viscosity iteration number", "100",
-                             Patterns::Integer(0),
-                             "We need to perform an iteration inside the computation "
-                             "of the dislocation viscosity, because it depends on the "
-                             "dislocation strain rate, which depends on the dislocation "
-                             "viscosity itself. This number determines the maximum "
-                             "number of iterations that are performed. ");
-          prm.declare_entry ("Dislocation creep exponent", "3.5",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The power-law exponent $n_{dis}$ for dislocation creep. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: none.");
-          prm.declare_entry ("Dislocation activation energy", "4.8e5",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The activation energy for dislocation creep $E_{dis}$. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\joule\\per\\mole}.");
-          prm.declare_entry ("Dislocation activation volume", "1.1e-5",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The activation volume for dislocation creep $V_{dis}$. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
-          prm.declare_entry ("Dislocation creep prefactor", "4.5e-15",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The prefactor for the dislocation creep law $A_{dis}$. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\pascal}$^{-n_{dis}}$\\si{\\per\\second}.");
-          prm.declare_entry ("Diffusion creep exponent", "1.",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The power-law exponent $n_{diff}$ for diffusion creep. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: none.");
-          prm.declare_entry ("Diffusion activation energy", "3.35e5",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The activation energy for diffusion creep $E_{diff}$. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\joule\\per\\mole}.");
-          prm.declare_entry ("Diffusion activation volume", "4e-6",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The activation volume for diffusion creep $V_{diff}$. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\meter\\cubed\\per\\mole}.");
-          prm.declare_entry ("Diffusion creep prefactor", "7.4e-15",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The prefactor for the diffusion creep law $A_{diff}$. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: \\si{\\meter}$^{p_{diff}}$\\si{\\pascal}$^{-n_{diff}}$\\si{\\per\\second}.");
-          prm.declare_entry ("Diffusion creep grain size exponent", "3.",
-                             Patterns::List (Patterns::Double (0.)),
-                             "The diffusion creep grain size exponent $p_{diff}$ that determines the "
-                             "dependence of viscosity on grain size. "
-                             "List must have one more entry than the Phase transition depths. "
-                             "Units: none.");
-          prm.declare_entry ("Maximum temperature dependence of viscosity", "100.",
-                             Patterns::Double (0.),
-                             "The factor by which viscosity at adiabatic temperature and ambient temperature "
-                             "are allowed to differ (a value of x means that the viscosity can be x times higher "
-                             "or x times lower compared to the value at adiabatic temperature. This parameter "
-                             "is introduced to limit local viscosity contrasts, but still allow for a widely "
-                             "varying viscosity over the whole mantle range. "
-                             "Units: none.");
-          prm.declare_entry ("Minimum viscosity", "1e18",
-                             Patterns::Double (0.),
-                             "The minimum viscosity that is allowed in the whole model domain. "
-                             "Units: Pa \\, s.");
-          prm.declare_entry ("Maximum viscosity", "1e26",
-                             Patterns::Double (0.),
-                             "The maximum viscosity that is allowed in the whole model domain. "
-                             "Units: Pa \\, s.");
-          prm.declare_entry ("Minimum specific heat", "500.",
-                             Patterns::Double (0.),
-                             "The minimum specific heat that is allowed in the whole model domain. "
-                             "Units: J/kg/K.");
-          prm.declare_entry ("Maximum specific heat", "6000.",
-                             Patterns::Double (0.),
-                             "The maximum specific heat that is allowed in the whole model domain. "
-                             "Units: J/kg/K.");
-          prm.declare_entry ("Minimum thermal expansivity", "1e-5",
-                             Patterns::Double (),
-                             "The minimum thermal expansivity that is allowed in the whole model domain. "
-                             "Units: 1/K.");
-          prm.declare_entry ("Maximum thermal expansivity", "1e-3",
-                             Patterns::Double (),
-                             "The maximum thermal expansivity that is allowed in the whole model domain. "
-                             "Units: 1/K.");
-          prm.declare_entry ("Maximum latent heat substeps", "1",
-                             Patterns::Integer (1),
-                             "The maximum number of substeps over the temperature pressure range "
-                             "to calculate the averaged enthalpy gradient over a cell.");
-          prm.declare_entry ("Minimum grain size", "1e-5",
-                             Patterns::Double (0.),
-                             "The minimum grain size that is used for the material model. This parameter "
-                             "is introduced to limit local viscosity contrasts, but still allows for a widely "
-                             "varying viscosity over the whole mantle range. "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Lower mantle grain size scaling", "1.0",
-                             Patterns::Double (0.),
-                             "This option does not exist any more.");
-          prm.declare_entry ("Advect logarithm of grain size", "false",
-                             Patterns::Bool (),
-                             "This option does not exist any more.");
-          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/steinberger/",
-                             Patterns::DirectoryName (),
-                             "The path to the model data. The path may also include the special "
-                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                             "in which the ASPECT source files were located when ASPECT was "
-                             "compiled. This interpretation allows, for example, to reference "
-                             "files located in the 'data/' subdirectory of ASPECT. ");
-          prm.declare_entry ("Material file names", "pyr-ringwood88.txt",
-                             Patterns::List (Patterns::Anything()),
-                             "The file names of the material data. "
-                             "List with as many components as active "
-                             "compositional fields (material data is assumed to "
-                             "be in order with the ordering of the fields). ");
-          prm.declare_entry ("Derivatives file names", "",
-                             Patterns::List (Patterns::Anything()),
-                             "The file names of the enthalpy derivatives data. "
-                             "List with as many components as active "
-                             "compositional fields (material data is assumed to "
-                             "be in order with the ordering of the fields). ");
-          prm.declare_entry ("Use table properties", "false",
-                             Patterns::Bool(),
-                             "This parameter determines whether to use the table properties "
-                             "also for density, thermal expansivity and specific heat. "
-                             "If false the properties are generated as in the "
-                             "simple compressible plugin.");
-          prm.declare_entry ("Material file format", "perplex",
-                             Patterns::Selection ("perplex|hefesto"),
-                             "The material file format to be read in the property "
-                             "tables.");
-          prm.declare_entry ("Use enthalpy for material properties", "true",
-                             Patterns::Bool(),
-                             "This parameter determines whether to use the enthalpy to calculate "
-                             "the thermal expansivity and specific heat (if true) or use the "
-                             "thermal expansivity and specific heat values from "
-                             "the material properties table directly (if false).");
-          prm.declare_entry ("Bilinear interpolation", "true",
-                             Patterns::Bool (),
-                             "This parameter determines whether to use bilinear interpolation "
-                             "to compute material properties (slower but more accurate).");
-
-          prm.enter_subsection("Grain damage partitioning");
-          {
-            prm.declare_entry ("Temperature for minimum grain damage partitioning", "1600",
-                               Patterns::Double (0.),
-                               "This parameter determines the temperature at which the computed coefficient of shear energy "
-                               "partitioned into grain damage is minimum. This is used in the pinned state limit of the grain "
-                               "size evolution. One choice of this parameter is the mantle temperature at the ridge axis, "
-                               "see Mulyukova and Bercovici (2018) for details.");
-            prm.declare_entry ("Temperature for maximum grain damage partitioning", "283",
-                               Patterns::Double (0.),
-                               "This parameter determines the temperature at which the computed coefficient of shear energy "
-                               "partitioned into grain damage is maximum. This is used in the pinned state limit of the grain "
-                               "size evolution. One choice of this parameter is the surface temperature of the seafloor, see "
-                               "Mulyukova and Bercovici (2018) for details.");
-            prm.declare_entry ("Minimum grain size reduction work fraction", "1e-12",
-                               Patterns::Double (0., 1.),
-                               "This parameter determines the minimum value of the partitioning coefficient, which governs "
-                               "the amount of shear heating partitioned into grain damage in the pinned state limit.");
-            prm.declare_entry ("Maximum grain size reduction work fraction", "1e-1",
-                               Patterns::Double (0., 1.),
-                               "This parameter determines the maximum value of the partitioning coefficient, which governs "
-                               "the amount of shear heating partitioned into grain damage in the pinned state limit.");
-            prm.declare_entry ("Grain size reduction work fraction exponent", "10",
-                               Patterns::Double (0.),
-                               "This parameter determines the variability in how much shear heating is partitioned into "
-                               "grain damage. A higher value suggests a wider temperature range over which the partitioning "
-                               "coefficient is high.");
-          }
-          prm.leave_subsection();
-
-          // Drucker Prager plasticity parameters
-          prm.declare_entry ("Use Drucker-Prager rheology", "false",
-                             Patterns::Bool(),
-                             "This parameter determines whether to apply plastic yielding "
-                             "according to a Drucker-Prager rheology after computing the viscosity "
-                             "from the (grain-size dependent) visous creep flow laws (if true) "
-                             "or not (if false).");
-          prm.declare_entry ("Use adiabatic pressure for yield stress", "false",
-                             Patterns::Bool (),
-                             "Whether to use the adiabatic pressure (if true) instead of the full "
-                             "(non-negative) pressure (if false) when calculating the yield stress. "
-                             "Using the adiabatic pressure (which is analogous to the depth-dependent "
-                             "von Mises model) can be useful to avoid the strong non-linearity associated "
-                             "with dynamic pressure variations affecting the yield strength, which can "
-                             "make the problem ill-posed. However, dynamic pressure can affect the "
-                             "localization of the strain rate and the resulting deformation, and neglecting "
-                             "it therefore changes the solution.");
-          Rheology::DruckerPrager<dim>::declare_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    GrainSize<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      AssertThrow (this->introspection().compositional_name_exists("grain_size"),
-                   ExcMessage("The 'grain size' material model only works if a compositional "
-                              "field with name 'grain_size' is present. Please use another material "
-                              "model or add such a field."));
-      grain_size_index = this->introspection().compositional_index_for_name("grain_size");
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Grain size model");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          reference_T                = prm.get_double ("Reference temperature");
-          eta                        = prm.get_double ("Viscosity");
-          k_value                    = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-          reference_compressibility  = prm.get_double ("Reference compressibility");
-
-          // Phase transition parameters
-          phase_function.initialize_simulator (this->get_simulator());
-          phase_function.parse_parameters (prm);
-
-          std::vector<unsigned int> n_phases_for_each_composition = phase_function.n_phases_for_each_composition();
-          n_phase_transitions = n_phases_for_each_composition[0] - 1;
-
-          recrystallized_grain_size = Utilities::string_to_double
-                                      (Utilities::split_string_list(prm.get ("Recrystallized grain size")));
-
-          if (recrystallized_grain_size.size() != n_phase_transitions)
-            AssertThrow(false,
-                        ExcMessage("Error: The list of recrystallized grain sizes has to have as many entries as there are phases."));
-
-          for (unsigned int i=1; i<n_phase_transitions; ++i)
-            AssertThrow(phase_function.get_transition_depth(i-1)<phase_function.get_transition_depth(i),
-                        ExcMessage("Error: Phase transition depths have to be sorted in ascending order!"));
-
-          // grain evolution parameters
-          grain_growth_activation_energy        = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Grain growth activation energy")));
-          grain_growth_activation_volume        = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Grain growth activation volume")));
-          grain_growth_rate_constant            = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Grain growth rate constant")));
-          grain_growth_exponent                 = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Grain growth exponent")));
-          minimum_grain_size                    = prm.get_double("Minimum grain size");
-          reciprocal_required_strain            = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Reciprocal required strain")));
-
-          grain_size_evolution_formulation      = Formulation::parse(prm.get("Grain size evolution formulation"));
-
-          // TODO: Remove deprecated parameter in next release.
-          const std::string use_paleowattmeter  = prm.get ("Use paleowattmeter");
-          Assert(use_paleowattmeter == "default",
-                 ExcMessage("The parameter 'Use paleowattmeter' has been removed. "
-                            "Use the parameter 'Grain size evolution formulation instead'."));
-
-          const double volume_fraction_phase_one = prm.get_double ("Phase volume fraction");
-
-          AssertThrow(volume_fraction_phase_one != 0. && volume_fraction_phase_one != 1.,
-                      ExcMessage("Volume fraction must be between (0, 1) to use two phase damage in the pinned state!"));
-
-          phase_distribution = phase_distribution_function(volume_fraction_phase_one);
-          roughness_to_grain_size = roughness_to_grain_size_factor(volume_fraction_phase_one);
-
-          grain_boundary_energy                 = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Average specific grain boundary energy")));
-          boundary_area_change_work_fraction    = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Work fraction for boundary area change")));
-          geometric_constant                    = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Geometric constant")));
-
-          if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
-            {
-              prm.enter_subsection("Grain damage partitioning");
-              {
-                grain_size_reduction_work_fraction_exponent = prm.get_double ("Grain size reduction work fraction exponent");
-                maximum_grain_size_reduction_work_fraction  = prm.get_double ("Maximum grain size reduction work fraction");
-                minimum_grain_size_reduction_work_fraction  = prm.get_double ("Minimum grain size reduction work fraction");
-
-                AssertThrow(maximum_grain_size_reduction_work_fraction > 0. && maximum_grain_size_reduction_work_fraction < 1.,
-                            ExcMessage("Maximum grain size reduction work fraction cannot be smaller or equal to 0 or larger or equal to 1."));
-                AssertThrow(minimum_grain_size_reduction_work_fraction > 0. && minimum_grain_size_reduction_work_fraction < 1.,
-                            ExcMessage("Minimum grain size reduction work fraction cannot be smaller or equal to 0 or larger or equal to 1."));
-                AssertThrow(maximum_grain_size_reduction_work_fraction >= minimum_grain_size_reduction_work_fraction,
-                            ExcMessage("Maximum grain size reduction work fraction must be larger than minimum grain size reduction work fraction."));
-
-                const double temperature_minimum_partition  = prm.get_double ("Temperature for minimum grain damage partitioning");
-                const double temperature_maximum_partition  = prm.get_double ("Temperature for maximum grain damage partitioning");
-
-                AssertThrow(temperature_minimum_partition > temperature_maximum_partition,
-                            ExcMessage("Temperature for minimum grain damage partitioning must be larger than Temperature for maximum grain damage partitioning."));
-
-                temperature_minimum_partitioning_power = std::pow(temperature_minimum_partition,grain_size_reduction_work_fraction_exponent);
-                temperature_maximum_partitioning_power = std::pow(temperature_maximum_partition,grain_size_reduction_work_fraction_exponent);
-              }
-              prm.leave_subsection();
-            }
-
-          // rheology parameters
-          dislocation_viscosity_iteration_threshold = prm.get_double("Dislocation viscosity iteration threshold");
-          dislocation_viscosity_iteration_number = prm.get_integer("Dislocation viscosity iteration number");
-          dislocation_creep_exponent            = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Dislocation creep exponent")));
-          dislocation_activation_energy         = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Dislocation activation energy")));
-          dislocation_activation_volume         = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Dislocation activation volume")));
-          dislocation_creep_prefactor           = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Dislocation creep prefactor")));
-          diffusion_creep_exponent              = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion creep exponent")));
-          diffusion_activation_energy           = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion activation energy")));
-          diffusion_activation_volume           = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion activation volume")));
-          diffusion_creep_prefactor             = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion creep prefactor")));
-          diffusion_creep_grain_size_exponent   = Utilities::string_to_double
-                                                  (Utilities::split_string_list(prm.get ("Diffusion creep grain size exponent")));
-          max_temperature_dependence_of_eta     = prm.get_double ("Maximum temperature dependence of viscosity");
-          min_eta                               = prm.get_double ("Minimum viscosity");
-          max_eta                               = prm.get_double ("Maximum viscosity");
-          min_specific_heat                     = prm.get_double ("Minimum specific heat");
-          max_specific_heat                     = prm.get_double ("Maximum specific heat");
-          min_thermal_expansivity               = prm.get_double ("Minimum thermal expansivity");
-          max_thermal_expansivity               = prm.get_double ("Maximum thermal expansivity");
-          max_latent_heat_substeps              = prm.get_integer ("Maximum latent heat substeps");
-          min_grain_size                        = prm.get_double ("Minimum grain size");
-
-          // scale recrystallized grain size, diffusion creep and grain growth prefactor accordingly
-          diffusion_creep_prefactor[diffusion_creep_prefactor.size()-1] *= std::pow(1.0,diffusion_creep_grain_size_exponent[diffusion_creep_grain_size_exponent.size()-1]);
-          grain_growth_rate_constant[grain_growth_rate_constant.size()-1] *= std::pow(1.0,grain_growth_exponent[grain_growth_exponent.size()-1]);
-
-          // prefactors never appear without their exponents. perform some calculations here to save time later
-          for (unsigned int i=0; i<diffusion_creep_prefactor.size(); ++i)
-            diffusion_creep_prefactor[i] = std::pow(diffusion_creep_prefactor[i],-1.0/diffusion_creep_exponent[i]);
-          for (unsigned int i=0; i<dislocation_creep_prefactor.size(); ++i)
-            dislocation_creep_prefactor[i] = std::pow(dislocation_creep_prefactor[i],-1.0/dislocation_creep_exponent[i]);
-
-          // TODO: Remove deprecated parameters in next release.
-          const double pv_grain_size_scaling         = prm.get_double ("Lower mantle grain size scaling");
-          AssertThrow(pv_grain_size_scaling == 1.0,
-                      ExcMessage("Error: The 'Lower mantle grain size scaling' parameter "
-                                 "has been removed. Please remove it from your input file. For models "
-                                 "with large spatial variations in grain size, please advect your "
-                                 "grain size on particles."));
-
-          const bool advect_log_grainsize            = prm.get_bool ("Advect logarithm of grain size");
-          AssertThrow(advect_log_grainsize == false,
-                      ExcMessage("Error: The 'Advect logarithm of grain size' parameter "
-                                 "has been removed. Please remove it from your input file. For models "
-                                 "with large spatial variations in grain size, please advect your "
-                                 "grain size on particles."));
-
-          if (grain_growth_activation_energy.size() != grain_growth_activation_volume.size() ||
-              grain_growth_activation_energy.size() != grain_growth_rate_constant.size() ||
-              grain_growth_activation_energy.size() != grain_growth_exponent.size() ||
-              grain_growth_activation_energy.size() != dislocation_creep_exponent.size() ||
-              grain_growth_activation_energy.size() != dislocation_activation_energy.size() ||
-              grain_growth_activation_energy.size() != dislocation_activation_volume.size() ||
-              grain_growth_activation_energy.size() != dislocation_creep_prefactor.size() ||
-              grain_growth_activation_energy.size() != diffusion_creep_exponent.size() ||
-              grain_growth_activation_energy.size() != diffusion_activation_energy.size() ||
-              grain_growth_activation_energy.size() != diffusion_activation_volume.size() ||
-              grain_growth_activation_energy.size() != diffusion_creep_prefactor.size() ||
-              grain_growth_activation_energy.size() != diffusion_creep_grain_size_exponent.size() )
-            AssertThrow(false,
-                        ExcMessage("Error: The lists of grain size evolution and flow law parameters "
-                                   "need to have the same length!"));
-
-          if (grain_size_evolution_formulation == Formulation::paleowattmeter)
-            {
-              if (grain_growth_activation_energy.size() != grain_boundary_energy.size() ||
-                  grain_growth_activation_energy.size() != boundary_area_change_work_fraction.size() ||
-                  grain_growth_activation_energy.size() != geometric_constant.size() )
-                AssertThrow(false,
-                            ExcMessage("Error: One of the lists of grain size evolution parameters "
-                                       "given for the paleowattmeter does not have the correct length!"));
-            }
-          else if (grain_size_evolution_formulation == Formulation::paleopiezometer)
-            {
-              AssertThrow(grain_growth_activation_energy.size() == reciprocal_required_strain.size(),
-                          ExcMessage("Error: The list of grain size evolution parameters in the "
-                                     "paleopiezometer does not have the correct length!"));
-            }
-          else if (grain_size_evolution_formulation == Formulation::pinned_grain_damage)
-            {
-              AssertThrow(n_phase_transitions == 0,
-                          ExcMessage("Error: Currently, the pinned grain damage formulation is only implemented for one mineral phase."));
-            }
-          else
-            AssertThrow(false,
-                        ExcMessage("Error: The size of lists in grain size evolution and flow law parameters "
-                                   "should follow either of the 'paleowattmeter|paleopiezometer|pinned grain damage' "
-                                   "formulations!"));
-
-          AssertThrow(grain_growth_activation_energy.size() == n_phase_transitions+1,
-                      ExcMessage("Error: The lists of grain size evolution and flow law parameters need to "
-                                 "have exactly one more entry than the number of phase transitions "
-                                 "(which is defined by the length of the lists of phase transition depths, ...)!"));
-
-          // parameters for reading in tables with material properties
-          datadirectory        = prm.get ("Data directory");
-          datadirectory = Utilities::expand_ASPECT_SOURCE_DIR(datadirectory);
-          material_file_names  = Utilities::split_string_list
-                                 (prm.get ("Material file names"));
-          derivatives_file_names = Utilities::split_string_list
-                                   (prm.get ("Derivatives file names"));
-          use_table_properties = prm.get_bool ("Use table properties");
-          use_enthalpy = prm.get_bool ("Use enthalpy for material properties");
-
-          // Make sure the grain size field comes after all potential material
-          // data fields. Otherwise our material model calculation uses the
-          // wrong compositional fields.
-          if (use_table_properties && material_file_names.size() > 1)
-            {
-              AssertThrow(grain_size_index >= material_file_names.size(),
-                          ExcMessage("The compositional fields indicating the major element composition need to be first in the "
-                                     "list of compositional fields, but the grain size field seems to have a lower index than the number "
-                                     "of provided data files. This is likely inconsistent. Please check the number of provided data "
-                                     "files and the order of compositional fields."));
-            }
-
-          if (prm.get ("Material file format") == "perplex")
-            material_file_format = perplex;
-          else if (prm.get ("Material file format") == "hefesto")
-            material_file_format = hefesto;
-          else
-            AssertThrow (false, ExcNotImplemented());
-
-          use_bilinear_interpolation = prm.get_bool ("Bilinear interpolation");
-
-          // Plasticity parameters
-          enable_drucker_prager_rheology = prm.get_bool ("Use Drucker-Prager rheology");
-          use_adiabatic_pressure_for_yielding = prm.get_bool ("Use adiabatic pressure for yield stress");
-          drucker_prager_plasticity.initialize_simulator (this->get_simulator());
-
-          std::vector<unsigned int> n_phases = {n_phase_transitions+1};
-          drucker_prager_plasticity.parse_parameters(prm, std::make_unique<std::vector<unsigned int>> (n_phases));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-
-      // Declare dependencies on solution variables
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-
-      this->model_dependence.viscosity = NonlinearDependence::temperature
-                                         | NonlinearDependence::pressure
-                                         | NonlinearDependence::strain_rate
-                                         | NonlinearDependence::compositional_fields;
-
-      this->model_dependence.density = NonlinearDependence::none;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-
-      if (use_table_properties)
-        {
-          this->model_dependence.density |= NonlinearDependence::temperature
-                                            | NonlinearDependence::pressure
-                                            | NonlinearDependence::compositional_fields;
-          this->model_dependence.compressibility = NonlinearDependence::temperature
-                                                   | NonlinearDependence::pressure
-                                                   | NonlinearDependence::compositional_fields;
-          this->model_dependence.specific_heat = NonlinearDependence::temperature
-                                                 | NonlinearDependence::pressure
-                                                 | NonlinearDependence::compositional_fields;
-        }
-      else
-        {
-          if (thermal_alpha != 0)
-            this->model_dependence.density |=NonlinearDependence::temperature;
-          if (reference_compressibility != 0)
-            this->model_dependence.density |=NonlinearDependence::pressure;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    GrainSize<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // These properties are useful as output.
-      if (out.template get_additional_output<DislocationViscosityOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::DislocationViscosityOutputs<dim>> (n_points));
-        }
-
-      // These properties will be used by the heating model to reduce
-      // shear heating by the amount of work done to reduce grain size.
-      if (out.template get_additional_output<HeatingModel::ShearHeatingOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<HeatingModel::ShearHeatingOutputs<dim>> (n_points));
-        }
-
-      // These properties are only output properties.
-      if (use_table_properties && out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
-        }
-
-      if (enable_drucker_prager_rheology && out.template get_additional_output<PlasticAdditionalOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<PlasticAdditionalOutputs<dim>> (n_points));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(GrainSize,
-                                   "grain size",
-                                   "A material model that relies on compositional "
-                                   "fields that correspond to the average grain sizes of a "
-                                   "mineral phase and source terms that determine the grain "
-                                   "size evolution in terms of the strain rate, "
-                                   "temperature, phase transitions, and the creep regime. "
-                                   "This material model only works if a compositional field "
-                                   "named 'grain_size' is present. "
-                                   "In the diffusion creep regime, the viscosity depends "
-                                   "on this grain size field. "
-                                   "We use the grain size evolution laws described in Behn "
-                                   "et al., 2009. Implications of grain size evolution on the "
-                                   "seismic structure of the oceanic upper mantle, "
-                                   "Earth Planet. Sci. Letters, 282, 178–189. "
-                                   "Other material parameters are either prescribed similar "
-                                   "to the 'simple' material model, or read from data files "
-                                   "that were generated by the Perplex or Hefesto software. "
-                                   "This material model "
-                                   "is described in more detail in Dannberg, J., Z. Eilon, "
-                                   "U. Faul, R. Gassmoeller, P. Moulik, and R. Myhill (2017), "
-                                   "The importance of grain size to mantle dynamics and "
-                                   "seismological observations, Geochem. Geophys. Geosyst., "
-                                   "18, 3034–3061, doi:10.1002/2017GC006944.")
-
-#define INSTANTIATE(dim) \
-  template class DislocationViscosityOutputs<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/interface.cc.bak b/source/material_model/interface.cc.bak
deleted file mode 100644
index 11ffbae6d08..00000000000
--- a/source/material_model/interface.cc.bak
+++ /dev/null
@@ -1,1239 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/newton.h>
-
-#include <deal.II/base/exceptions.h>
-#include <deal.II/base/signaling_nan.h>
-#include <tuple>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/fe_q.h>
-
-#include <list>
-
-#ifdef DEBUG
-#ifdef ASPECT_USE_FP_EXCEPTIONS
-#include <cfenv>
-#endif
-#endif
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace NonlinearDependence
-    {
-      bool
-      identifies_single_variable(const Dependence dependence)
-      {
-        Assert (dependence != uninitialized,
-                ExcMessage ("You cannot call this function on an uninitialized dependence value!"));
-        return ((dependence == temperature)
-                ||
-                (dependence == pressure)
-                ||
-                (dependence == strain_rate)
-                ||
-                (dependence == compositional_fields));
-      }
-
-
-
-      ModelDependence::ModelDependence ()
-        :
-        viscosity (uninitialized),
-        density (uninitialized),
-        compressibility (uninitialized),
-        specific_heat (uninitialized),
-        thermal_conductivity (uninitialized)
-      {}
-    }
-
-
-
-// -------------------------------- Deal with registering material models and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    register_material_model (const std::string &name,
-                             const std::string &description,
-                             void (*declare_parameters_function) (ParameterHandler &),
-                             std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_material_model (const std::string &model_name)
-    {
-      return std::get<dim>(registered_plugins).create_plugin (model_name, "Material model::Model name");
-    }
-
-
-
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_material_model (ParameterHandler &prm)
-    {
-      std::string model_name;
-      prm.enter_subsection ("Material model");
-      {
-        model_name = prm.get ("Model name");
-      }
-      prm.leave_subsection ();
-
-      // If one sets the model name to an empty string in the input file,
-      // ParameterHandler produces an error while reading the file. However,
-      // if one omits specifying any model name at all (not even setting it to
-      // the empty string) then the value we get here is the empty string. If
-      // we don't catch this case here, we end up with awkward downstream
-      // errors because the value obviously does not conform to the Pattern.
-      AssertThrow(model_name != "unspecified",
-                  ExcMessage("You need to select a material model "
-                             "(`set Model name' in `subsection Material model')."));
-
-      return create_material_model<dim> (model_name);
-    }
-
-
-
-    template <int dim>
-    const NonlinearDependence::ModelDependence &
-    Interface<dim>::
-    get_model_dependence() const
-    {
-      return model_dependence;
-    }
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::
-    create_additional_named_outputs (MaterialModelOutputs &/*outputs*/) const
-    {
-      // by default we do nothing!
-    }
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::
-    fill_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &input,
-                                          const LinearAlgebra::BlockVector        &solution,
-                                          const FEValuesBase<dim>                 &fe_values,
-                                          const Introspection<dim>                &introspection) const
-    {
-      // go through the list of additional inputs and fill them
-      for (unsigned int i=0; i<input.additional_inputs.size(); ++i)
-        input.additional_inputs[i]->fill(solution, fe_values, introspection);
-    }
-
-
-
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ()
-    {
-      return std::get<dim>(registered_plugins).get_pattern_of_names ();
-    }
-
-
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm)
-    {
-      // declare the actual entry in the parameter file
-      prm.enter_subsection ("Material model");
-      {
-        const std::string pattern_of_names = get_valid_model_names_pattern<dim>();
-        prm.declare_entry ("Model name", "unspecified",
-                           Patterns::Selection (pattern_of_names+"|unspecified"),
-                           "The name of the material model to be used in "
-                           "this simulation. There are many material models "
-                           "you can choose from, as listed below. They generally "
-                           "fall into two category: (i) models that implement "
-                           "a particular case of material behavior, (ii) models "
-                           "that modify other models in some way. We sometimes "
-                           "call the latter ``compositing models''. An example "
-                           "of a compositing model is the ``depth dependent'' model "
-                           "below in that it takes another, freely choosable "
-                           "model as its base and then modifies that model's "
-                           "output in some way."
-                           "\n\n"
-                           "You can select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Material model interface",
-                                                            out);
-    }
-
-
-    template <int dim>
-    MaterialModelInputs<dim>::MaterialModelInputs(const unsigned int n_points,
-                                                  const unsigned int n_comp)
-      :
-      position(n_points, Point<dim>(numbers::signaling_nan<Tensor<1,dim>>())),
-      temperature(n_points, numbers::signaling_nan<double>()),
-      pressure(n_points, numbers::signaling_nan<double>()),
-      pressure_gradient(n_points, numbers::signaling_nan<Tensor<1,dim>>()),
-      velocity(n_points, numbers::signaling_nan<Tensor<1,dim>>()),
-      composition(n_points, std::vector<double>(n_comp, numbers::signaling_nan<double>())),
-      strain_rate(n_points, numbers::signaling_nan<SymmetricTensor<2,dim>>()),
-      current_cell(),
-      requested_properties(MaterialProperties::all_properties)
-    {}
-
-
-
-    template <int dim>
-    MaterialModelInputs<dim>::MaterialModelInputs(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                                  const Introspection<dim> &introspection,
-                                                  const bool compute_strain_rate)
-      :
-      position(input_data.evaluation_points),
-      temperature(input_data.solution_values.size(), numbers::signaling_nan<double>()),
-      pressure(input_data.solution_values.size(), numbers::signaling_nan<double>()),
-      pressure_gradient(input_data.solution_values.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-      velocity(input_data.solution_values.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-      composition(input_data.solution_values.size(), std::vector<double>(introspection.n_compositional_fields, numbers::signaling_nan<double>())),
-      strain_rate(input_data.solution_values.size(), numbers::signaling_nan<SymmetricTensor<2,dim>>()),
-      current_cell(input_data.template get_cell<dim>()),
-      requested_properties(MaterialProperties::all_properties)
-    {
-      AssertThrow (compute_strain_rate == true,
-                   ExcMessage ("The option to not compute the strain rate is no longer supported."));
-
-      for (unsigned int q=0; q<input_data.solution_values.size(); ++q)
-        {
-          Tensor<2,dim> grad_u;
-          for (unsigned int d=0; d<dim; ++d)
-            {
-              grad_u[d] = input_data.solution_gradients[q][introspection.component_indices.velocities[d]];
-              this->velocity[q][d] = input_data.solution_values[q][introspection.component_indices.velocities[d]];
-              this->pressure_gradient[q][d] = input_data.solution_gradients[q][introspection.component_indices.pressure][d];
-            }
-
-          this->strain_rate[q] = symmetrize (grad_u);
-          this->pressure[q] = input_data.solution_values[q][introspection.component_indices.pressure];
-          this->temperature[q] = input_data.solution_values[q][introspection.component_indices.temperature];
-
-          for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-            this->composition[q][c] = input_data.solution_values[q][introspection.component_indices.compositional_fields[c]];
-        }
-    }
-
-
-
-    template <int dim>
-    MaterialModelInputs<dim>::MaterialModelInputs(const FEValuesBase<dim,dim> &fe_values,
-                                                  const typename DoFHandler<dim>::active_cell_iterator &cell_x,
-                                                  const Introspection<dim> &introspection,
-                                                  const LinearAlgebra::BlockVector &solution_vector,
-                                                  const bool compute_strain_rate)
-      :
-      position(fe_values.get_quadrature_points()),
-      temperature(fe_values.n_quadrature_points, numbers::signaling_nan<double>()),
-      pressure(fe_values.n_quadrature_points, numbers::signaling_nan<double>()),
-      pressure_gradient(fe_values.n_quadrature_points, numbers::signaling_nan<Tensor<1,dim>>()),
-      velocity(fe_values.n_quadrature_points, numbers::signaling_nan<Tensor<1,dim>>()),
-      composition(fe_values.n_quadrature_points, std::vector<double>(introspection.n_compositional_fields, numbers::signaling_nan<double>())),
-      strain_rate(fe_values.n_quadrature_points, numbers::signaling_nan<SymmetricTensor<2,dim>>()),
-      current_cell (cell_x),
-      requested_properties(MaterialProperties::all_properties)
-    {
-      // Call the function reinit to populate the new arrays.
-      this->reinit(fe_values, current_cell, introspection, solution_vector, compute_strain_rate);
-    }
-
-
-
-    template <int dim>
-    MaterialModelInputs<dim>::MaterialModelInputs(const MaterialModelInputs &source)
-      :
-      position(source.position),
-      temperature(source.temperature),
-      pressure(source.pressure),
-      pressure_gradient(source.pressure_gradient),
-      velocity(source.velocity),
-      composition(source.composition),
-      strain_rate(source.strain_rate),
-      current_cell(source.current_cell),
-      requested_properties(source.requested_properties)
-    {
-      Assert (source.additional_inputs.size() == 0,
-              ExcMessage ("You can not copy MaterialModelInputs objects that have "
-                          "additional input objects attached"));
-    }
-
-
-
-    template <int dim>
-    void
-    MaterialModelInputs<dim>::reinit(const FEValuesBase<dim,dim> &fe_values,
-                                     const typename DoFHandler<dim>::active_cell_iterator &cell_x,
-                                     const Introspection<dim> &introspection,
-                                     const LinearAlgebra::BlockVector &solution_vector,
-                                     const bool compute_strain_rate)
-    {
-      AssertThrow (compute_strain_rate == true,
-                   ExcMessage ("The option to not compute the strain rate is no longer supported."));
-
-      // Populate the arrays that hold solution values and gradients
-      fe_values[introspection.extractors.temperature].get_function_values (solution_vector, this->temperature);
-      fe_values[introspection.extractors.velocities].get_function_values (solution_vector, this->velocity);
-      fe_values[introspection.extractors.pressure].get_function_values (solution_vector, this->pressure);
-      fe_values[introspection.extractors.pressure].get_function_gradients (solution_vector, this->pressure_gradient);
-      fe_values[introspection.extractors.velocities].get_function_symmetric_gradients (solution_vector, this->strain_rate);
-
-      // Vectors for evaluating the compositional field parts of the finite element solution
-      std::vector<std::vector<double>> composition_values (introspection.n_compositional_fields,
-                                                            std::vector<double> (fe_values.n_quadrature_points));
-      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-        fe_values[introspection.extractors.compositional_fields[c]]
-        .get_function_values(solution_vector,composition_values[c]);
-
-      // Then copy these values to exchange the inner and outer vector, because for the material
-      // model we need a vector with values of all the compositional fields for every quadrature point
-      for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
-        {
-          for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-            this->composition[q][c] = composition_values[c][q];
-        }
-
-      // Finally also record quadrature point positions and the cell
-      this->position = fe_values.get_quadrature_points();
-      this->current_cell = cell_x;
-    }
-
-
-
-    template <int dim>
-    unsigned int
-    MaterialModelInputs<dim>::n_evaluation_points() const
-    {
-      return position.size();
-    }
-
-
-
-    template <int dim>
-    bool
-    MaterialModelInputs<dim>::requests_property(const MaterialProperties::Property &property) const
-    {
-      // Note that this means 'requested_properties' can include other properties than
-      // just 'property', but in any case it at least requests 'property'.
-      return (requested_properties & property) != 0;
-    }
-
-
-
-    template <int dim>
-    MaterialModelOutputs<dim>::MaterialModelOutputs(const unsigned int n_points,
-                                                    const unsigned int n_comp)
-      :
-      viscosities(n_points, numbers::signaling_nan<double>()),
-      densities(n_points, numbers::signaling_nan<double>()),
-      thermal_expansion_coefficients(n_points, numbers::signaling_nan<double>()),
-      specific_heat(n_points, numbers::signaling_nan<double>()),
-      thermal_conductivities(n_points, numbers::signaling_nan<double>()),
-      compressibilities(n_points, numbers::signaling_nan<double>()),
-      entropy_derivative_pressure(n_points, numbers::signaling_nan<double>()),
-      entropy_derivative_temperature(n_points, numbers::signaling_nan<double>()),
-      reaction_terms(n_points, std::vector<double>(n_comp, numbers::signaling_nan<double>()))
-    {}
-
-
-    template <int dim>
-    MaterialModelOutputs<dim>::MaterialModelOutputs(const MaterialModelOutputs<dim> &source)
-      :
-      viscosities(source.viscosities),
-      densities(source.densities),
-      thermal_expansion_coefficients(source.thermal_expansion_coefficients),
-      specific_heat(source.specific_heat),
-      thermal_conductivities(source.thermal_conductivities),
-      compressibilities(source.compressibilities),
-      entropy_derivative_pressure(source.entropy_derivative_pressure),
-      entropy_derivative_temperature(source.entropy_derivative_temperature),
-      reaction_terms(source.reaction_terms),
-      additional_outputs()
-    {
-      Assert (source.additional_outputs.size() == 0,
-              ExcMessage ("You can not copy MaterialModelOutputs objects that have "
-                          "additional output objects attached"));
-    }
-
-
-
-    template <int dim>
-    unsigned int
-    MaterialModelOutputs<dim>::n_evaluation_points() const
-    {
-      return densities.size();
-    }
-
-
-
-    namespace MaterialAveraging
-    {
-      std::string get_averaging_operation_names ()
-      {
-        return "none|default averaging|arithmetic average|harmonic average|geometric average|pick largest|project to Q1|log average|harmonic average only viscosity|geometric average only viscosity|project to Q1 only viscosity";
-      }
-
-
-      AveragingOperation parse_averaging_operation_name (const std::string &s)
-      {
-        if (s == "none")
-          return none;
-        else if (s == "arithmetic average")
-          return arithmetic_average;
-        else if (s == "harmonic average")
-          return harmonic_average;
-        else if (s == "geometric average")
-          return geometric_average;
-        else if (s == "pick largest")
-          return pick_largest;
-        else if (s == "project to Q1")
-          return project_to_Q1;
-        else if (s == "log average")
-          return log_average;
-        else if (s == "harmonic average only viscosity")
-          return harmonic_average_only_viscosity;
-        else if (s == "geometric average only viscosity")
-          return geometric_average_only_viscosity;
-        else if (s == "project to Q1 only viscosity")
-          return project_to_Q1_only_viscosity;
-        else if (s == "default averaging")
-          return default_averaging;
-        else
-          AssertThrow (false,
-                       ExcMessage ("The value <" + s + "> for a material "
-                                   "averaging operation is not one of the "
-                                   "valid values."));
-
-        return none;
-      }
-
-
-
-      namespace
-      {
-        bool
-        all_entries_NaN (const std::vector<double> &values)
-        {
-          for (const double value : values)
-            if (std::isnan(value) == false)
-              return false;
-
-          return true;
-        }
-      }
-
-
-
-      // Do the requested averaging operation for one array. The
-      // projection matrix argument is only used if the operation
-      // chosen is project_to_Q1.
-      void average_property (const AveragingOperation  operation,
-                             const FullMatrix<double>      &projection_matrix,
-                             const FullMatrix<double>      &expansion_matrix,
-                             std::vector<double>           &values_out)
-      {
-#ifdef DEBUG
-#ifdef ASPECT_USE_FP_EXCEPTIONS
-        // disable floating point exceptions while averaging. Errors will be reported
-        // as soon as somebody will try to use the averaged values later.
-        fedisableexcept(FE_DIVBYZERO|FE_INVALID);
-#endif
-#endif
-
-        // if an output field has not been filled (because it was
-        // not requested), then simply do nothing -- no harm no foul
-        // note that it is still an error if only some entries are NaN
-        if (values_out.size() == 0 || all_entries_NaN(values_out) == true)
-          return;
-
-        const unsigned int N = values_out.size();
-        const unsigned int P = expansion_matrix.n();
-        Assert ((P==0) || (/*dim=2*/ P==4) || (/*dim=3*/ P==8),
-                ExcInternalError());
-        Assert (((operation == project_to_Q1) &&
-                 (projection_matrix.m() == P) &&
-                 (projection_matrix.n() == N) &&
-                 (expansion_matrix.m() == N) &&
-                 (expansion_matrix.n() == P))
-                ||
-                ((projection_matrix.m() == 0) &&
-                 (projection_matrix.n() == 0)),
-                ExcInternalError());
-
-        // otherwise do as instructed
-        switch (operation)
-          {
-            case none:
-            {
-              break;
-            }
-
-            case arithmetic_average:
-            {
-              double sum = 0;
-              for (unsigned int i=0; i<N; ++i)
-                sum += values_out[i];
-
-              const double average = sum/N;
-              for (unsigned int i=0; i<N; ++i)
-                values_out[i] = average;
-              break;
-            }
-
-            case harmonic_average:
-            {
-              // if one of the values is zero, the average is 0.0
-              for (unsigned int i=0; i<N; ++i)
-                if (values_out[i] == 0.0)
-                  {
-                    for (unsigned int j=0; j<N; ++j)
-                      values_out[j] = 0.0;
-                    return;
-                  }
-
-              double sum = 0;
-              for (unsigned int i=0; i<N; ++i)
-                sum += 1./values_out[i];
-
-              const double average = 1./(sum/N);
-              for (unsigned int i=0; i<N; ++i)
-                values_out[i] = average;
-              break;
-            }
-
-            case geometric_average:
-            {
-              double average = 1;
-              for (unsigned int i=0; i<N; ++i)
-                {
-                  Assert (values_out[i] >= 0,
-                          ExcMessage ("Computing the geometric average "
-                                      "only makes sense for non-negative "
-                                      "quantities."));
-                  average *= std::pow (values_out[i], 1./N);
-                }
-
-              for (unsigned int i=0; i<N; ++i)
-                values_out[i] = average;
-              break;
-            }
-
-            case pick_largest:
-            {
-              double max = std::numeric_limits<double>::lowest();
-              for (unsigned int i=0; i<N; ++i)
-                max = std::max(max, values_out[i]);
-
-              for (unsigned int i=0; i<N; ++i)
-                values_out[i] = max;
-              break;
-            }
-
-            case project_to_Q1:
-            {
-              // we will need the min/max values below, for use
-              // after the projection operation
-              double min = std::numeric_limits<double>::max();
-              for (unsigned int i=0; i<N; ++i)
-                min = std::min(min, values_out[i]);
-
-              double max = std::numeric_limits<double>::lowest();
-              for (unsigned int i=0; i<N; ++i)
-                max = std::max(max, values_out[i]);
-
-              // take the projection matrix and apply it to the
-              // values. as explained in the documentation of the
-              // compute_projection_matrix, this performs the operation
-              // we want in the current context
-              Vector<double> x (N), z(P), y(N);
-              for (unsigned int i=0; i<N; ++i)
-                y(i) = values_out[i];
-              projection_matrix.vmult (z, y);
-
-              // now that we have the Q1 values, restrict them to
-              // the min/max range of the original data
-              for (unsigned int i=0; i<P; ++i)
-                z[i] = std::max (min,
-                                 std::min (max,
-                                           z[i]));
-
-              // then expand back to the quadrature points
-              expansion_matrix.vmult (x, z);
-              for (unsigned int i=0; i<N; ++i)
-                values_out[i] = x(i);
-
-              break;
-            }
-
-            case log_average:
-            {
-              double sum = 0;
-              for (unsigned int i=0; i<N; ++i)
-                {
-                  if (values_out[i] == 0.0)
-                    {
-                      sum = -std::numeric_limits<double>::infinity();
-                      break;
-                    }
-                  Assert (values_out[i] > 0.0,
-                          ExcMessage ("Computing the log average "
-                                      "only makes sense for positive "
-                                      "quantities."));
-                  sum += std::log10(values_out[i]);
-                }
-              const double log_value_average = std::pow (10., sum/N);
-              for (unsigned int i=0; i<N; ++i)
-                values_out[i] = log_value_average;
-              break;
-            }
-
-            default:
-            {
-              AssertThrow (false,
-                           ExcMessage ("This averaging operation is not implemented."));
-            }
-          }
-
-#ifdef DEBUG
-#ifdef ASPECT_USE_FP_EXCEPTIONS
-        // enable floating point exceptions again:
-        feenableexcept(FE_DIVBYZERO|FE_INVALID);
-#endif
-#endif
-      }
-
-
-      /**
-       * Given a quadrature formula, compute a matrices $E, M^{-1}F$
-       * representing a linear operator in the following way: Let
-       * there be a vector $F$ with $N$ elements where the elements
-       * are data stored at each of the $N$ quadrature points of the
-       * given quadrature formula. (For this quadrature formula, we only
-       * care about the locations of the quadrature points on the
-       * reference cell, but not about quadrature weights.)
-       * Then project this data into a $Q_1$ space and evaluate this
-       * projection at the same quadrature points.
-       *
-       * This operator can be expressed in the following way where $P=2^{dim}$
-       * is the number of degrees of freedom of the $Q_1$ element:
-       *
-       * Let $y$ be the input vector with $N$ elements. We would like to find
-       * a function $u_h(x)$ that is a $Q_1$ function that is closest to
-       * the data points, i.e., we seek
-       * @f{align*}{
-       *   min_{u_h \in Q_1(K)} \frac 12 \sum_q |u_h(x_q) - y_q|^2 |J(x_q)| w_q.
-       * @f}
-       * where $x_q$ are the evaluation points, $J$ is the Jacobian matrix of the
-       * mapping from reference to real cell, and $w_q$ are the
-       * quadrature weights.
-       * Expanding $u_h = \sum_j U_j \varphi_j$, this leads to the following
-       * minimization problem for the vector of coefficients $U$:
-       * @f{align*}{
-       *   min_{U} \frac 12 \sum_q |\sum_j U_j \varphi_j(x_q) - y_q|^2 w_q,
-       * @f}
-       * which can be rewritten as
-       * @f{align*}{
-       *   min_{U} \frac 12 \sum_q
-       *       [ \sum_i \sum_j U_i U_j \varphi_i(x_q)\varphi_j(x_q)
-       *        - 2 \sum_j U_j \varphi_j(x_q) y_q
-       *        + y_q^2                                             ].
-       * @f}
-       * This optimization problem has the following solution that one can arrive at
-       * simply by setting the derivative of the objective function with regard to
-       * $U$ to zero:
-       * @f{align*}{
-       *       \sum q \sum_i \sum_j \varphi_i(x_q)\varphi_j(x_q) |J(x_q)| w_q U_j
-       *       =
-       *       \sum_q \varphi_i(x_q) |J(x_q)| w_q y_q
-       * @f}
-       * If we let $F$ be the $P \times N$ matrix so that
-       * @f{align*}{
-       *   F_{iq} = \varphi_i(x_q) |J(x_q)| w_q
-       * @f}
-       * Next, let $M_{ij}$ be the $P\times P$ mass matrix on the
-       * $Q_1$ space with regard to the given evaluation points and corresponding
-       * weights. Then $U = M^{-1}Fy$ corresponds to the projection
-       * of $y$ into the $Q_1$ space (or, more correctly, it
-       * corresponds to vector of the nodal values of this projection).
-       *
-       * Finally, let $E_{qi} = \varphi_i(x_q)$ be the evaluation
-       * operation of shape functions at quadrature points.
-       *
-       * Then, the operation $X=EM^{-1}F$ is the operation we seek.
-       * This function computes the matrices $E$ and $M^{-1}F$.
-       */
-      template <int dim>
-      void compute_projection_matrix (const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                      const Quadrature<dim>   &quadrature_formula,
-                                      const Mapping<dim>      &mapping,
-                                      FullMatrix<double>      &projection_matrix,
-                                      FullMatrix<double>      &expansion_matrix)
-      {
-        static const FE_Q<dim> fe(1);
-        FEValues<dim> fe_values (mapping, fe, quadrature_formula,
-                                 update_values | update_JxW_values);
-
-        const unsigned int P = fe.dofs_per_cell;
-        const unsigned int N = quadrature_formula.size();
-
-        FullMatrix<double> F (P, N);
-        FullMatrix<double> M (P, P);
-
-        projection_matrix.reinit (P, N);
-        expansion_matrix.reinit (N, P);
-
-        // reinitialize the fe_values object with the current cell. we get a
-        // DoFHandler cell, but we are not going to use it with the
-        // finite element associated with that DoFHandler, so cast it back
-        // to just a tria iterator (all we need anyway is the geometry)
-        fe_values.reinit (typename Triangulation<dim>::active_cell_iterator(cell));
-
-        // compute the matrices F, M, E
-        for (unsigned int i=0; i<P; ++i)
-          for (unsigned int q=0; q<N; ++q)
-            F(i,q) = fe_values.shape_value(i,q) *
-                     fe_values.JxW(q);
-
-        for (unsigned int i=0; i<P; ++i)
-          for (unsigned int j=0; j<P; ++j)
-            for (unsigned int q=0; q<N; ++q)
-              M(i,j) += fe_values.shape_value(i,q) *
-                        fe_values.shape_value(j,q) *
-                        fe_values.JxW(q);
-
-        for (unsigned int q=0; q<N; ++q)
-          for (unsigned int i=0; i<P; ++i)
-            expansion_matrix(q,i) = fe_values.shape_value(i,q);
-
-        // replace M by M^{-1}
-        M.gauss_jordan();
-
-        // form M^{-1} F
-        M.mmult (projection_matrix, F);
-      }
-
-
-      /**
-       * Calculate the weight for viscosity derivative, which depends on
-       * the material averaging scheme. Currently the newton method is
-       * only compatible with arithmetic average, harmonic average and
-       * geometric/log average for viscosity.
-       */
-      double
-      compute_viscosity_derivative_averaging_weight(const AveragingOperation operation,
-                                                    const double average_viscosity,
-                                                    const double viscosity_before_averaging,
-                                                    const double one_over_Nq)
-      {
-        switch (operation)
-          {
-            case none:
-              // should never reach here:
-              return numbers::signaling_nan<double>();
-
-            case arithmetic_average:
-              return one_over_Nq;
-
-            case harmonic_average:
-            case harmonic_average_only_viscosity:
-              return Utilities::fixed_power<2,double>(average_viscosity / viscosity_before_averaging)
-                     * one_over_Nq;
-
-            case geometric_average:
-            case geometric_average_only_viscosity:
-            case log_average:
-              return (average_viscosity / viscosity_before_averaging)
-                     * one_over_Nq;
-
-            default:
-              AssertThrow(false,
-                          ExcMessage("The Newton method currently only works if the material "
-                                     "averaging scheme is ``none'', ``arithmetic average'', "
-                                     "``harmonic average (only viscosity)'', ``geometric "
-                                     "average (only viscosity)'' or ``log average''."));
-          }
-      }
-
-
-      template <int dim>
-      void average (const AveragingOperation operation,
-                    const typename DoFHandler<dim>::active_cell_iterator &cell,
-                    const Quadrature<dim>         &quadrature_formula,
-                    const Mapping<dim>            &mapping,
-                    const MaterialProperties::Property &requested_properties,
-                    MaterialModelOutputs<dim>     &values_out)
-      {
-        if (operation == none)
-          return;
-
-        FullMatrix<double> projection_matrix;
-        FullMatrix<double> expansion_matrix;
-
-        const bool average_viscosity = requested_properties & MaterialProperties::Property::viscosity;
-
-        if (operation == project_to_Q1
-            ||
-            operation == project_to_Q1_only_viscosity)
-          {
-            Assert (quadrature_formula.size() == values_out.n_evaluation_points(),
-                    ExcMessage("When asking for a Q1-type averaging operation, "
-                               "this function requires to know the locations of "
-                               "the evaluation points."));
-            projection_matrix.reinit (quadrature_formula.size(),
-                                      quadrature_formula.size());
-            compute_projection_matrix (cell,
-                                       quadrature_formula,
-                                       mapping,
-                                       projection_matrix,
-                                       expansion_matrix);
-          }
-
-        // store the original viscosities if we need to compute the
-        // system jacobian later on
-        MaterialModelDerivatives<dim> *derivatives =
-          values_out.template get_additional_output<MaterialModelDerivatives<dim>>();
-
-        std::vector<double> viscosity_before_averaging;
-        if (derivatives != nullptr)
-          viscosity_before_averaging = values_out.viscosities;
-
-        // compute the average of viscosity
-        if (average_viscosity)
-          {
-            if (operation == harmonic_average_only_viscosity)
-              average_property (harmonic_average, projection_matrix, expansion_matrix,
-                                values_out.viscosities);
-
-            else if (operation == geometric_average_only_viscosity)
-              average_property (geometric_average, projection_matrix, expansion_matrix,
-                                values_out.viscosities);
-
-            else if (operation == project_to_Q1_only_viscosity)
-              average_property (project_to_Q1, projection_matrix, expansion_matrix,
-                                values_out.viscosities);
-
-            else
-              average_property (operation, projection_matrix, expansion_matrix,
-                                values_out.viscosities);
-
-            // calculate the weight of viscosity derivative at each
-            // quadrature point
-            if (derivatives != nullptr)
-              {
-                for (unsigned int q = 0; q < values_out.n_evaluation_points(); ++q)
-                  derivatives->viscosity_derivative_averaging_weights[q] =
-                    compute_viscosity_derivative_averaging_weight(
-                      operation, values_out.viscosities[q], viscosity_before_averaging[q],
-                      1. / values_out.n_evaluation_points());
-              }
-          }
-
-        if (operation == harmonic_average_only_viscosity ||
-            operation == geometric_average_only_viscosity ||
-            operation == project_to_Q1_only_viscosity)
-          return;
-
-        average_property (operation, projection_matrix, expansion_matrix,
-                          values_out.densities);
-        average_property (operation, projection_matrix, expansion_matrix,
-                          values_out.thermal_expansion_coefficients);
-        average_property (operation, projection_matrix, expansion_matrix,
-                          values_out.specific_heat);
-        average_property (operation, projection_matrix, expansion_matrix,
-                          values_out.thermal_conductivities);
-        average_property (operation, projection_matrix, expansion_matrix,
-                          values_out.compressibilities);
-        average_property (operation, projection_matrix, expansion_matrix,
-                          values_out.entropy_derivative_pressure);
-        average_property (operation, projection_matrix, expansion_matrix,
-                          values_out.entropy_derivative_temperature);
-
-        // The reaction terms are unfortunately stored in reverse
-        // indexing. It's also not quite clear whether these should
-        // really be averaged, so avoid this for now.
-
-        // average all additional outputs
-        for (unsigned int i=0; i<values_out.additional_outputs.size(); ++i)
-          values_out.additional_outputs[i]->average (operation, projection_matrix, expansion_matrix);
-      }
-    }
-
-
-
-    template <int dim>
-    NamedAdditionalMaterialOutputs<dim>::
-    NamedAdditionalMaterialOutputs(const std::vector<std::string> &output_names)
-      :
-      names(output_names)
-    {}
-
-
-
-    template <int dim>
-    NamedAdditionalMaterialOutputs<dim>::
-    NamedAdditionalMaterialOutputs(const std::vector<std::string> &output_names,
-                                   const unsigned int n_points)
-      :
-      output_values(output_names.size(), std::vector<double>(n_points, numbers::signaling_nan<double>())),
-      names(output_names)
-    {}
-
-
-
-    template <int dim>
-    NamedAdditionalMaterialOutputs<dim>::
-    ~NamedAdditionalMaterialOutputs()
-      = default;
-
-
-
-    template <int dim>
-    const std::vector<std::string> &
-    NamedAdditionalMaterialOutputs<dim>::get_names() const
-    {
-      return names;
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    NamedAdditionalMaterialOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      // In this function we extract the values for the nth output
-      // The number of outputs is the outer vector
-      Assert (output_values.size() > idx,
-              ExcMessage ("The requested output index is out of range for output_values."));
-      Assert (output_values[idx].size() > 0,
-              ExcMessage ("There must be one or more points for the nth output."));
-      return output_values[idx];
-    }
-
-
-
-    template <int dim>
-    PrescribedPlasticDilation<dim>::PrescribedPlasticDilation (const unsigned int n_points)
-      : NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1, "prescribed_dilation")),
-        dilation(n_points, numbers::signaling_nan<double>())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double> PrescribedPlasticDilation<dim>::get_nth_output(const unsigned int idx) const
-    {
-      (void)idx;
-      Assert(idx==0, ExcInternalError());
-      return dilation;
-    }
-
-
-
-    namespace
-    {
-      std::vector<std::string> make_seismic_additional_outputs_names()
-      {
-        std::vector<std::string> names;
-        names.emplace_back("seismic_Vs");
-        names.emplace_back("seismic_Vp");
-        return names;
-      }
-    }
-
-
-
-    template <int dim>
-    SeismicAdditionalOutputs<dim>::SeismicAdditionalOutputs (const unsigned int n_points)
-      :
-      NamedAdditionalMaterialOutputs<dim>(make_seismic_additional_outputs_names()),
-      vs(n_points, numbers::signaling_nan<double>()),
-      vp(n_points, numbers::signaling_nan<double>())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    SeismicAdditionalOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      AssertIndexRange (idx, 2);
-      switch (idx)
-        {
-          case 0:
-            return vs;
-
-          case 1:
-            return vp;
-
-          default:
-            AssertThrow(false, ExcInternalError());
-        }
-      // we will never get here, so just return something
-      return vs;
-    }
-
-
-
-    namespace
-    {
-      std::vector<std::string> make_reaction_rate_outputs_names(const unsigned int n_comp)
-      {
-        std::vector<std::string> names;
-        for (unsigned int c=0; c<n_comp; ++c)
-          names.push_back("reaction_rate_C" + Utilities::int_to_string(c));
-
-        return names;
-      }
-
-
-
-      std::vector<std::string> make_prescribed_field_output_names(const unsigned int n_comp)
-      {
-        std::vector<std::string> names;
-        for (unsigned int c=0; c<n_comp; ++c)
-          names.push_back("prescribed_field_output_C" + Utilities::int_to_string(c));
-        return names;
-      }
-    }
-
-
-
-    template <int dim>
-    ReactionRateOutputs<dim>::ReactionRateOutputs (const unsigned int n_points,
-                                                   const unsigned int n_comp)
-      :
-      NamedAdditionalMaterialOutputs<dim>(make_reaction_rate_outputs_names(n_comp)),
-      reaction_rates(n_points, std::vector<double>(n_comp, std::numeric_limits<double>::quiet_NaN()))
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    ReactionRateOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      // we have to extract the reaction rate outputs for one particular compositional
-      // field, but the vector in the material model outputs is sorted so that the
-      // number of evaluation points (and not the compositional fields) is the outer
-      // vector
-      std::vector<double> cth_reaction_rates(reaction_rates.size());
-      for (unsigned int q=0; q<reaction_rates.size(); ++q)
-        cth_reaction_rates[q] = reaction_rates[q][idx];
-
-      return cth_reaction_rates;
-    }
-
-
-
-    namespace
-    {
-      std::vector<std::string> make_phase_outputs_names()
-      {
-        std::vector<std::string> names;
-        names.emplace_back("phase");
-        return names;
-      }
-    }
-
-
-
-    template <int dim>
-    PhaseOutputs<dim>::PhaseOutputs (const unsigned int n_points)
-      :
-      NamedAdditionalMaterialOutputs<dim>(make_phase_outputs_names(), n_points)
-    {}
-
-
-
-    template <int dim>
-    PrescribedFieldOutputs<dim>::PrescribedFieldOutputs (const unsigned int n_points,
-                                                         const unsigned int n_comp)
-      :
-      NamedAdditionalMaterialOutputs<dim>(make_prescribed_field_output_names(n_comp)),
-      prescribed_field_outputs(n_points, std::vector<double>(n_comp, std::numeric_limits<double>::quiet_NaN()))
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    PrescribedFieldOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      // we have to extract the prescribed field outputs for one particular compositional
-      // field, but the vector in the material model outputs is sorted so that the
-      // number of evaluation points (and not the compositional fields) is the outer
-      // vector
-      std::vector<double> nth_prescribed_field_output(prescribed_field_outputs.size());
-      for (unsigned int q=0; q<prescribed_field_outputs.size(); ++q)
-        nth_prescribed_field_output[q] = prescribed_field_outputs[q][idx];
-      return nth_prescribed_field_output;
-    }
-
-
-
-    template <int dim>
-    PrescribedTemperatureOutputs<dim>::PrescribedTemperatureOutputs (const unsigned int n_points)
-      :
-      NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1,"prescribed_temperature")),
-      prescribed_temperature_outputs(n_points, std::numeric_limits<double>::quiet_NaN())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    PrescribedTemperatureOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      (void)idx;
-      AssertIndexRange (idx, 1);
-      return prescribed_temperature_outputs;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<MaterialModel::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<MaterialModel::Interface<2>>::plugins = nullptr;
-
-      template <>
-      std::list<internal::Plugins::PluginList<MaterialModel::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<MaterialModel::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_material_model<dim> (const std::string &, \
-                                const std::string &, \
-                                void ( *) (ParameterHandler &), \
-                                std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template \
-  std::string \
-  get_valid_model_names_pattern<dim> (); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_material_model<dim> (const std::string &model_name); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_material_model<dim> (ParameterHandler &prm); \
-  \
-  template class MaterialModelInputs<dim>; \
-  \
-  template class MaterialModelOutputs<dim>; \
-  \
-  template class AdditionalMaterialOutputs<dim>; \
-  \
-  template class NamedAdditionalMaterialOutputs<dim>; \
-  \
-  template class SeismicAdditionalOutputs<dim>; \
-  \
-  template class ReactionRateOutputs<dim>; \
-  \
-  template class PhaseOutputs<dim>; \
-  \
-  template class PrescribedPlasticDilation<dim>; \
-  \
-  template class PrescribedFieldOutputs<dim>; \
-  \
-  template class PrescribedTemperatureOutputs<dim>; \
-  \
-  namespace MaterialAveraging \
-  { \
-    template                \
-    void average (const AveragingOperation operation, \
-                  const DoFHandler<dim>::active_cell_iterator &cell, \
-                  const Quadrature<dim>     &quadrature_formula, \
-                  const Mapping<dim>        &mapping, \
-                  const MaterialProperties::Property &requested_properties, \
-                  MaterialModelOutputs<dim> &values_out); \
-  }
-
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/latent_heat.cc.bak b/source/material_model/latent_heat.cc.bak
deleted file mode 100644
index dd4a69ccac8..00000000000
--- a/source/material_model/latent_heat.cc.bak
+++ /dev/null
@@ -1,422 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/latent_heat.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/gravity_model/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    LatentHeat<dim>::
-    evaluate(const MaterialModelInputs<dim> &in,
-             MaterialModelOutputs<dim> &out) const
-    {
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double temperature = in.temperature[i];
-          const double pressure = in.pressure[i];
-          const std::vector<double> composition = in.composition[i];
-          const Point<dim> position = in.position[i];
-
-          // Assign constant material properties
-          {
-            out.specific_heat[i] = reference_specific_heat;
-            out.thermal_conductivities[i] = k_value;
-            out.thermal_expansion_coefficients[i] = thermal_alpha;
-            out.compressibilities[i] = reference_compressibility;
-          }
-
-          // Calculate Viscosity
-          {
-            const double reference_temperature = (this->include_adiabatic_heating()
-                                                  ?
-                                                  this->get_adiabatic_conditions().temperature(in.position[i])
-                                                  :
-                                                  reference_T);
-
-            const double delta_temp = temperature-reference_temperature;
-            const double T_dependence = ( thermal_viscosity_exponent == 0.0
-                                          ?
-                                          0.0
-                                          :
-                                          thermal_viscosity_exponent * delta_temp / reference_temperature );
-
-            double visc_temperature_dependence = std::max(std::min(std::exp(-T_dependence),1e2),1e-2);
-
-            if (std::isnan(visc_temperature_dependence))
-              visc_temperature_dependence = 1.0;
-
-            double visc_composition_dependence = 1.0;
-            if ((composition_viscosity_prefactor != 1.0) && (composition.size() > 0))
-              {
-                // geometric interpolation
-                out.viscosities[i] = (pow(10, ((1-composition[0]) * log10(eta*visc_temperature_dependence)
-                                               + composition[0] * log10(eta*composition_viscosity_prefactor*visc_temperature_dependence))));
-              }
-            else
-              out.viscosities[i] = visc_composition_dependence * visc_temperature_dependence * eta;
-          }
-
-          // Calculate density
-          // and phase dependence of viscosity
-          {
-            // first, calculate temperature dependence of density
-            // temperature dependence is 1 - alpha * (T - T(adiabatic))
-            const double density_temperature_dependence = 1.0 - (temperature - this->get_adiabatic_conditions().temperature(position))
-                                                          * thermal_alpha;
-
-            // second, calculate composition dependence of density
-            // constant density difference between peridotite and eclogite
-            const double density_composition_dependence = composition.size()>0
-                                                          ?
-                                                          compositional_delta_rho * composition[0]
-                                                          :
-                                                          0.0;
-
-            // third, calculate the density (and viscosity) differences due to phase
-            // transitions (temperature- and pressure dependence included).
-            // the phase function gives the percentage of material that has
-            // already undergone the phase transition to the higher-pressure material
-            // (this is done individual for each transitions and summed up
-            // in the end)
-            // this means, that there are no actual density or viscosity "jumps", but
-            // gradual transitions between the materials
-            double phase_dependence = 0.0;
-            double viscosity_phase_dependence = 1.0;
-
-            // Loop through phase transitions
-            for (unsigned int phase=0; phase<phase_function.n_phase_transitions(); ++phase)
-              {
-                const double depth = this->get_geometry_model().depth(position);
-                const double pressure_depth_derivative = (depth > 0.0)
-                                                         ?
-                                                         this->get_adiabatic_conditions().pressure(position) / depth
-                                                         :
-                                                         this->get_gravity_model().gravity_vector(position).norm() * reference_rho;
-
-                const MaterialUtilities::PhaseFunctionInputs<dim> phase_in(temperature,
-                                                                           pressure,
-                                                                           depth,
-                                                                           pressure_depth_derivative,
-                                                                           phase);
-
-                const double phaseFunction = phase_function.compute_value(phase_in);
-
-                // Note that for the densities we have a list of jumps, so the index used
-                // in the loop corresponds to the index of the phase transition. For the
-                // viscosities we have a list of prefactors, which has one more entry
-                // for the first layer, so we have to use phase+1 as the index.
-                if (composition.size()==0)
-                  {
-                    phase_dependence += phaseFunction * density_jumps[phase];
-                    viscosity_phase_dependence *= 1. + phaseFunction * (phase_prefactors[phase+1]-1.);
-                  }
-                else if (composition.size()>0)
-                  {
-                    if (transition_phases[phase] == 0)     // 1st compositional field
-                      phase_dependence += phaseFunction * density_jumps[phase] * (1.0 - composition[0]);
-                    else if (transition_phases[phase] == 1) // 2nd compositional field
-                      phase_dependence += phaseFunction * density_jumps[phase] * composition[0];
-
-                    viscosity_phase_dependence *= 1. + phaseFunction * (phase_prefactors[phase]-1.);
-                  }
-              }
-
-            // fourth, pressure dependence of density
-            const double kappa = reference_compressibility;
-            const double pressure_dependence = reference_rho * kappa * (pressure - this->get_surface_pressure());
-
-            // In the end, all the influences are added up.
-            // In the non-Boussinesq case, we chose to add the composition-, pressure-, and phase-dependent terms
-            // first, before applying the density changes due to thermal expansion, because they can be relatively
-            // large and should be taken into account for the temperature dependence (for example, if the material
-            // has a different density because it is in a new phase, we should take the density of that new phase
-            // to compute thermal expansion effects).
-            out.densities[i] = (reference_rho + density_composition_dependence + pressure_dependence + phase_dependence)
-                               * density_temperature_dependence;
-
-            // For the Boussinesq approximation, all terms are linearized and added separately (that is simply how
-            // the Boussinesq approximation is defined). This means we have to apply the temperature term first
-            // since it is (1 - alpha T).
-            if (this->get_parameters().formulation == Parameters<dim>::Formulation::boussinesq_approximation)
-              out.densities[i] = (reference_rho * density_temperature_dependence + density_composition_dependence + phase_dependence);
-
-            out.viscosities[i] = std::max(minimum_viscosity, std::min(maximum_viscosity, out.viscosities[i] * viscosity_phase_dependence));
-          }
-
-          // Calculate entropy derivative
-          {
-            double entropy_gradient_pressure = 0.0;
-            double entropy_gradient_temperature = 0.0;
-            const double rho = out.densities[i];
-
-            if (this->get_adiabatic_conditions().is_initialized() && this->include_latent_heat())
-              for (unsigned int phase=0; phase<phase_function.n_phase_transitions(); ++phase)
-                {
-                  const double depth = this->get_geometry_model().depth(in.position[i]);
-                  const double pressure_depth_derivative = (this->get_adiabatic_conditions().pressure(position) > 0)
-                                                           ?
-                                                           depth / this->get_adiabatic_conditions().pressure(position)
-                                                           :
-                                                           this->get_gravity_model().gravity_vector(in.position[i]).norm() * reference_rho;
-
-                  const MaterialUtilities::PhaseFunctionInputs<dim> phase_in(temperature,
-                                                                             pressure,
-                                                                             depth,
-                                                                             pressure_depth_derivative,
-                                                                             phase);
-
-                  const double PhaseFunctionDerivative = phase_function.compute_derivative(phase_in);
-                  const double clapeyron_slope = phase_function.get_transition_slope(phase);
-
-                  double entropy_change = 0.0;
-                  if (composition.size()==0)      // only one compositional field
-                    entropy_change = clapeyron_slope * density_jumps[phase] / (rho * rho);
-                  else
-                    {
-                      if (transition_phases[phase] == 0)     // 1st compositional field
-                        entropy_change = clapeyron_slope * density_jumps[phase] / (rho * rho) * (1.0 - composition[0]);
-                      else if (transition_phases[phase] == 1) // 2nd compositional field
-                        entropy_change = clapeyron_slope * density_jumps[phase] / (rho * rho) * composition[0];
-                    }
-                  // we need DeltaS * DX/Dpressure_deviation for the pressure derivative
-                  // and - DeltaS * DX/Dpressure_deviation * gamma for the temperature derivative
-                  entropy_gradient_pressure += PhaseFunctionDerivative * entropy_change;
-                  entropy_gradient_temperature -= PhaseFunctionDerivative * entropy_change * clapeyron_slope;
-                }
-
-            out.entropy_derivative_pressure[i] = entropy_gradient_pressure;
-            out.entropy_derivative_temperature[i] = entropy_gradient_temperature;
-          }
-
-          // Assign reaction terms
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    LatentHeat<dim>::
-    is_compressible () const
-    {
-      if (reference_compressibility > 0)
-        return true;
-      else
-        return false;
-    }
-
-
-
-    template <int dim>
-    void
-    LatentHeat<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Latent heat");
-        {
-          prm.declare_entry ("Reference density", "3300.",
-                             Patterns::Double (0.),
-                             "Reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Viscosity", "5e24",
-                             Patterns::Double (0.),
-                             "The value of the constant viscosity. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Composition viscosity prefactor", "1.0",
-                             Patterns::Double (0.),
-                             "A linear dependency of viscosity on composition. Dimensionless prefactor.");
-          prm.declare_entry ("Thermal viscosity exponent", "0.0",
-                             Patterns::Double (0.),
-                             "The temperature dependence of viscosity. Dimensionless exponent.");
-          prm.declare_entry ("Thermal conductivity", "2.38",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250.",
-                             Patterns::Double (0.),
-                             "The value of the specific heat $C_p$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "4e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\beta$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Compressibility", "5.124e-12",
-                             Patterns::Double (0.),
-                             "The value of the compressibility $\\kappa$. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("Density differential for compositional field 1", "0.",
-                             Patterns::Double(),
-                             "If compositional fields are used, then one would frequently want "
-                             "to make the density depend on these fields. In this simple material "
-                             "model, we make the following assumptions: if no compositional fields "
-                             "are used in the current simulation, then the density is simply the usual "
-                             "one with its linear dependence on the temperature. If there are compositional "
-                             "fields, then the density only depends on the first one in such a way that "
-                             "the density has an additional term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
-                             "This parameter describes the value of $\\Delta \\rho$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
-          prm.declare_entry ("Phase transition density jumps", "",
-                             Patterns::List (Patterns::Double (0.)),
-                             "A list of density jumps at each phase transition. A positive value means "
-                             "that the density increases with depth. The corresponding entry in "
-                             "Corresponding phase for density jump determines if the density jump occurs "
-                             "in peridotite, eclogite or none of them."
-                             "List must have the same number of entries as Phase transition depths. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Corresponding phase for density jump", "",
-                             Patterns::List (Patterns::Integer(0)),
-                             "A list of phases, which correspond to the Phase transition density jumps. "
-                             "The density jumps occur only in the phase that is given by this phase value. "
-                             "0 stands for the 1st compositional fields, 1 for the second compositional field "
-                             "and -1 for none of them. "
-                             "List must have the same number of entries as Phase transition depths. "
-                             "Units: \\si{\\pascal\\per\\kelvin}.");
-          prm.declare_entry ("Viscosity prefactors", "",
-                             Patterns::List (Patterns::Double (0.)),
-                             "A list of prefactors for the viscosity for each phase. The reference "
-                             "viscosity will be multiplied by this factor to get the corresponding "
-                             "viscosity for each phase. "
-                             "List must have one more entry than Phase transition depths. "
-                             "Units: non-dimensional.");
-          prm.declare_entry ("Minimum viscosity", "1e19",
-                             Patterns::Double (0.),
-                             "Limit for the minimum viscosity in the model. "
-                             "Units: Pa \\, s.");
-          prm.declare_entry ("Maximum viscosity", "1e24",
-                             Patterns::Double (0.),
-                             "Limit for the maximum viscosity in the model. "
-                             "Units: Pa \\, s.");
-
-          MaterialUtilities::PhaseFunction<dim>::declare_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    LatentHeat<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Latent heat");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          reference_T                = prm.get_double ("Reference temperature");
-          eta                        = prm.get_double ("Viscosity");
-          composition_viscosity_prefactor = prm.get_double ("Composition viscosity prefactor");
-          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
-          k_value                    = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-          reference_compressibility  = prm.get_double ("Compressibility");
-          compositional_delta_rho    = prm.get_double ("Density differential for compositional field 1");
-          minimum_viscosity              = prm.get_double ("Minimum viscosity");
-          maximum_viscosity              = prm.get_double ("Maximum viscosity");
-
-          phase_function.initialize_simulator (this->get_simulator());
-          phase_function.parse_parameters (prm);
-
-          density_jumps = Utilities::string_to_double
-                          (Utilities::split_string_list(prm.get ("Phase transition density jumps")));
-          transition_phases = Utilities::string_to_int
-                              (Utilities::split_string_list(prm.get ("Corresponding phase for density jump")));
-          phase_prefactors = Utilities::string_to_double
-                             (Utilities::split_string_list(prm.get ("Viscosity prefactors")));
-
-          const unsigned int n_transitions = phase_function.n_phase_transitions();
-          if (density_jumps.size() != n_transitions ||
-              transition_phases.size() != n_transitions ||
-              phase_prefactors.size() != n_transitions+1)
-            AssertThrow(false, ExcMessage("Error: At least one list that provides input parameters for phase "
-                                          "transitions has the wrong size. The phase function object reports that "
-                                          "there are " + std::to_string(n_transitions) + " transitions, "
-                                          "therefore the material model expects " + std::to_string(n_transitions) +
-                                          " density jumps and corresponding phases, and "
-                                          + std::to_string(n_transitions+1) + " viscosity prefactors."));
-
-          // as the phase viscosity prefactors are all applied multiplicatively on top of each other,
-          // we have to scale them here so that they are relative factors in comparison to the product
-          // of the prefactors of all phase above the current one
-          for (unsigned int phase=1; phase<phase_prefactors.size(); ++phase)
-            {
-              phase_prefactors[phase] /= phase_prefactors[phase-1];
-            }
-
-          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
-            AssertThrow(false, ExcMessage("Error: Material model latent heat with Thermal viscosity exponent can not have reference_T=0."));
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(LatentHeat,
-                                   "latent heat",
-                                   "A material model that includes phase transitions "
-                                   "and the possibility that latent heat is released "
-                                   "or absorbed when material crosses one of the "
-                                   "phase transitions of up to two different materials "
-                                   "(compositional fields). "
-                                   "This model implements a standard approximation "
-                                   "of the latent heat terms following Christensen \\& Yuen, 1985 \\cite{christensen:yuen:1985}. "
-                                   "The change of entropy is calculated as "
-                                   "$\\Delta S = \\gamma \\frac{\\Delta\\rho}{\\rho^2}$ with the "
-                                   "Clapeyron slope $\\gamma$ and the density change $\\Delta\\rho$ "
-                                   "of the phase transition being input parameters. "
-                                   "The model employs an analytic phase function in the form "
-                                   "$X=\\frac{1}{2} \\left( 1 + \\tanh \\left( \\frac{\\Delta p}{\\Delta p_0} \\right) \\right)$ "
-                                   "with $\\Delta p = p - p_{\\text{transition}} - \\gamma \\left( T - T_{\\text{transition}} \\right)$ "
-                                   "and $\\Delta p_0$ being the pressure difference over the width "
-                                   "of the phase transition (specified as input parameter).")
-  }
-}
diff --git a/source/material_model/latent_heat_melt.cc.bak b/source/material_model/latent_heat_melt.cc.bak
deleted file mode 100644
index 1cfab292052..00000000000
--- a/source/material_model/latent_heat_melt.cc.bak
+++ /dev/null
@@ -1,660 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/latent_heat_melt.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    LatentHeatMelt<dim>::
-
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-
-          out.entropy_derivative_pressure[i] = 0;
-          out.entropy_derivative_temperature[i] = 0;
-
-          for (unsigned int c=0; c < in.composition[i].size(); ++c )
-            {
-              out.reaction_terms[i][c]            = 0;
-            }
-
-          std::vector<double> composition = in.composition[i];
-
-          const double reference_temperature = (this->include_adiabatic_heating()
-                                                ?
-                                                this->get_adiabatic_conditions().temperature(in.position[i])
-                                                :
-                                                reference_T);
-
-          const double delta_temp = in.temperature[i] - reference_temperature;
-          const double T_dependence = ( thermal_viscosity_exponent == 0.0
-                                        ?
-                                        0.0
-                                        :
-                                        thermal_viscosity_exponent * delta_temp / reference_temperature );
-
-
-          double temperature_dependence = std::max (std::min ( std::exp( - T_dependence ), 1e2 ), 1e-2 );
-
-          if (std::isnan(temperature_dependence))
-            temperature_dependence = 1.0;
-
-          double composition_dependence = 1.0;
-          if ((composition_viscosity_prefactor != 1.0) && (composition.size() > 0))
-            {
-              //geometric interpolation
-              out.viscosities[i] = (pow (10, ( (1 - composition[0] ) * log10 ( eta * temperature_dependence )
-                                               + composition[0] * log10 ( eta * composition_viscosity_prefactor * temperature_dependence))));
-            }
-          else
-            {
-              out.viscosities[i] = composition_dependence * temperature_dependence * eta;
-            }
-
-          out.specific_heat[i] = reference_specific_heat;
-          out.thermal_conductivities[i] = k_value;
-          out.thermal_expansion_coefficients[i] = thermal_alpha;
-          out.compressibilities[i] = reference_compressibility;
-
-          temperature_dependence = 1.0;
-
-          if (this->include_adiabatic_heating ())
-            {
-              // temperature dependence is 1 - alpha * (T - T(adiabatic))
-              temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i])) * thermal_alpha;
-            }
-          else
-            {
-              temperature_dependence -= in.temperature[i] * thermal_alpha;
-            }
-          // second, calculate composition dependence of density
-          // constant density difference between peridotite and eclogite
-          composition_dependence = composition.size()>0
-                                   ?
-                                   compositional_delta_rho * composition[0]
-                                   :
-                                   0.0;
-
-          // third, pressure dependence of density
-          const double kappa = reference_compressibility;
-          const double pressure_dependence = reference_rho * kappa * (in.pressure[i] - this->get_surface_pressure());
-
-          // fourth, melt fraction dependence
-          double melt_dependence = (1.0 - relative_melt_density)
-                                   * melt_fraction(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
-
-          // in the end, all the influences are added up
-          out.densities[i] = (reference_rho + composition_dependence + pressure_dependence) * temperature_dependence
-                             * (1.0 - melt_dependence);
-
-
-          out.entropy_derivative_pressure[i] = entropy_derivative (in.temperature[i], in.pressure[i], composition,
-                                                                   in.position[i], NonlinearDependence::pressure) ; // for pressure dependence
-
-          out.entropy_derivative_temperature[i] = entropy_derivative (in.temperature[i], in.pressure[i], composition,
-                                                                      in.position[i], NonlinearDependence::temperature) ; // for temperature dependence
-
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    LatentHeatMelt<dim>::
-    entropy_derivative (const double temperature,
-                        const double pressure,
-                        const std::vector<double> &compositional_fields,
-                        const Point<dim> &position,
-                        const NonlinearDependence::Dependence dependence) const
-    {
-      double entropy_gradient = 0.0;
-
-      // calculate latent heat of melting
-      // we need the change of melt fraction in dependence of pressure and temperature
-
-      // for peridotite after Katz, 2003
-      const double T_solidus        = A1 + 273.15
-                                      + A2 * pressure
-                                      + A3 * pressure * pressure;
-      const double T_lherz_liquidus = B1 + 273.15
-                                      + B2 * pressure
-                                      + B3 * pressure * pressure;
-      const double T_liquidus       = C1 + 273.15
-                                      + C2 * pressure
-                                      + C3 * pressure * pressure;
-
-      const double dT_solidus_dp        = A2 + 2 * A3 * pressure;
-      const double dT_lherz_liquidus_dp = B2 + 2 * B3 * pressure;
-      const double dT_liquidus_dp       = C2 + 2 * C3 * pressure;
-
-      const double peridotite_fraction = (this->n_compositional_fields()>0
-                                          ?
-                                          1.0 - compositional_fields[0]
-                                          :
-                                          1.0);
-
-      if (temperature > T_solidus && temperature < T_liquidus && pressure < 1.3e10)
-        {
-          // melt fraction when clinopyroxene is still present
-          double melt_fraction_derivative_temperature
-            = beta * pow((temperature - T_solidus)/(T_lherz_liquidus - T_solidus),beta-1)
-              / (T_lherz_liquidus - T_solidus);
-
-          double melt_fraction_derivative_pressure
-            = beta * pow((temperature - T_solidus)/(T_lherz_liquidus - T_solidus),beta-1)
-              * (dT_solidus_dp * (temperature - T_lherz_liquidus)
-                 + dT_lherz_liquidus_dp * (T_solidus - temperature))
-              / pow(T_lherz_liquidus - T_solidus,2);
-
-          // melt fraction after melting of all clinopyroxene
-          const double R_cpx = r1 + r2 * pressure;
-          const double F_max = M_cpx / R_cpx;
-
-          if (peridotite_melt_fraction(temperature, pressure, compositional_fields, position) > F_max)
-            {
-              const double T_max = std::pow(F_max,1.0/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
-              const double dF_max_dp = - M_cpx * std::pow(r1 + r2 * pressure,-2) * r2;
-              const double dT_max_dp = dT_solidus_dp
-                                       + 1.0/beta * std::pow(F_max,1.0/beta - 1.0) * dF_max_dp * (T_lherz_liquidus - T_solidus)
-                                       + std::pow(F_max,1.0/beta) * (dT_lherz_liquidus_dp - dT_solidus_dp);
-
-              melt_fraction_derivative_temperature
-                = (1.0 - F_max) * beta * std::pow((temperature - T_max)/(T_liquidus - T_max),beta-1)
-                  / (T_liquidus - T_max);
-
-              melt_fraction_derivative_pressure
-                = dF_max_dp
-                  - dF_max_dp * std::pow((temperature - T_max)/(T_liquidus - T_max),beta)
-                  + (1.0 - F_max) * beta * std::pow((temperature - T_max)/(T_liquidus - T_max),beta-1)
-                  * (dT_max_dp * (T_max - T_liquidus) - (dT_liquidus_dp - dT_max_dp) * (temperature - T_max)) / std::pow(T_liquidus - T_max, 2);
-            }
-
-          double melt_fraction_derivative = 0;
-          if (dependence == NonlinearDependence::temperature)
-            melt_fraction_derivative = melt_fraction_derivative_temperature;
-          else if (dependence == NonlinearDependence::pressure)
-            melt_fraction_derivative = melt_fraction_derivative_pressure;
-          else
-            AssertThrow(false, ExcMessage("Error in calculating melt fraction derivative: not implemented"));
-
-          entropy_gradient += melt_fraction_derivative * peridotite_melting_entropy_change * peridotite_fraction;
-        }
-
-
-      // for melting of pyroxenite after Sobolev et al., 2011
-      if (this->n_compositional_fields()>0)
-        {
-          // calculate change of entropy for melting all material
-          const double X = pyroxenite_melt_fraction(temperature, pressure, compositional_fields, position);
-
-          // calculate change of melt fraction in dependence of pressure and temperature
-          const double T_melting = D1 + 273.15
-                                   + D2 * pressure
-                                   + D3 * pressure * pressure;
-          const double dT_melting_dp = 2*D3*pressure + D2;
-          const double discriminant = E1*E1/(E2*E2*4) + (temperature-T_melting)/E2;
-
-          double melt_fraction_derivative = 0.0;
-          if (temperature > T_melting && X < F_px_max && pressure < 1.3e10)
-            {
-              if (dependence == NonlinearDependence::temperature)
-                melt_fraction_derivative = -1.0/(2*E2 * sqrt(discriminant));
-              else if (dependence == NonlinearDependence::pressure)
-                melt_fraction_derivative = (dT_melting_dp)/(2*E2 * sqrt(discriminant));
-              else
-                AssertThrow(false, ExcMessage("Error in calculating melt fraction derivative: not implemented"));
-            }
-
-          entropy_gradient += melt_fraction_derivative * pyroxenite_melting_entropy_change * compositional_fields[0];
-        }
-
-      return entropy_gradient;
-    }
-
-
-    template <int dim>
-    void
-    LatentHeatMelt<dim>::
-    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                    std::vector<double> &melt_fractions) const
-    {
-      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
-        melt_fractions[q] = melt_fraction(in.temperature[q],
-                                          std::max(0.0, in.pressure[q]),
-                                          in.composition[q],
-                                          in.position[q]);
-    }
-
-    template <int dim>
-    double
-    LatentHeatMelt<dim>::
-    peridotite_melt_fraction (const double temperature,
-                              const double pressure,
-                              const std::vector<double> &,
-                              const Point<dim> &) const
-    {
-      // anhydrous melting of peridotite after Katz, 2003
-      const double T_solidus  = A1 + 273.15
-                                + A2 * pressure
-                                + A3 * pressure * pressure;
-      const double T_lherz_liquidus = B1 + 273.15
-                                      + B2 * pressure
-                                      + B3 * pressure * pressure;
-      const double T_liquidus = C1 + 273.15
-                                + C2 * pressure
-                                + C3 * pressure * pressure;
-
-      // melt fraction for peridotite with clinopyroxene
-      double peridotite_melt_fraction;
-      if (temperature < T_solidus || pressure > 1.3e10)
-        peridotite_melt_fraction = 0.0;
-      else if (temperature > T_lherz_liquidus)
-        peridotite_melt_fraction = 1.0;
-      else
-        peridotite_melt_fraction = std::pow((temperature - T_solidus) / (T_lherz_liquidus - T_solidus),beta);
-
-      // melt fraction after melting of all clinopyroxene
-      const double R_cpx = r1 + r2 * pressure;
-      const double F_max = M_cpx / R_cpx;
-
-      if (peridotite_melt_fraction > F_max && temperature < T_liquidus)
-        {
-          const double T_max = std::pow(F_max,1/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
-          peridotite_melt_fraction = F_max + (1 - F_max) * pow((temperature - T_max) / (T_liquidus - T_max),beta);
-        }
-      return peridotite_melt_fraction;
-
-    }
-
-    template <int dim>
-    double
-    LatentHeatMelt<dim>::
-    pyroxenite_melt_fraction (const double temperature,
-                              const double pressure,
-                              const std::vector<double> &,
-                              const Point<dim> &) const
-    {
-      // melting of pyroxenite after Sobolev et al., 2011
-      const double T_melting = D1 + 273.15
-                               + D2 * pressure
-                               + D3 * pressure * pressure;
-
-      const double discriminant = E1*E1/(E2*E2*4) + (temperature-T_melting)/E2;
-
-      double pyroxenite_melt_fraction;
-      if (temperature < T_melting || pressure > 1.3e10)
-        pyroxenite_melt_fraction = 0.0;
-      else if (discriminant < 0)
-        pyroxenite_melt_fraction = F_px_max;
-      else
-        pyroxenite_melt_fraction = -E1/(2*E2) - std::sqrt(discriminant);
-
-      return pyroxenite_melt_fraction;
-    }
-
-    template <int dim>
-    double
-    LatentHeatMelt<dim>::
-    melt_fraction (const double temperature,
-                   const double pressure,
-                   const std::vector<double> &composition, /*composition*/
-                   const Point<dim> &position) const
-    {
-      return (this->n_compositional_fields()>0
-              ?
-              pyroxenite_melt_fraction(temperature, pressure, composition, position)
-              * composition[0]
-              +
-              peridotite_melt_fraction(temperature, pressure, composition, position)
-              * (1.0 - composition[0])
-              :
-              peridotite_melt_fraction(temperature, pressure, composition, position));
-
-    }
-
-
-
-    template <int dim>
-    bool
-    LatentHeatMelt<dim>::
-    is_compressible () const
-    {
-      if (reference_compressibility > 0)
-        return true;
-      else
-        return false;
-    }
-
-
-
-    template <int dim>
-    void
-    LatentHeatMelt<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Latent heat melt");
-        {
-          prm.declare_entry ("Reference density", "3300.",
-                             Patterns::Double (0.),
-                             "Reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Viscosity", "5e24",
-                             Patterns::Double (0.),
-                             "The value of the constant viscosity. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Composition viscosity prefactor", "1.0",
-                             Patterns::Double (0.),
-                             "A linear dependency of viscosity on composition. Dimensionless prefactor.");
-          prm.declare_entry ("Thermal viscosity exponent", "0.0",
-                             Patterns::Double (0.),
-                             "The temperature dependence of viscosity. Dimensionless exponent.");
-          prm.declare_entry ("Thermal conductivity", "2.38",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250.",
-                             Patterns::Double (0.),
-                             "The value of the specific heat $C_p$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "4e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\alpha_s$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Thermal expansion coefficient of melt", "6.8e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\alpha_f$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Compressibility", "5.124e-12",
-                             Patterns::Double (0.),
-                             "The value of the compressibility $\\kappa$. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("Density differential for compositional field 1", "0.",
-                             Patterns::Double(),
-                             "If compositional fields are used, then one would frequently want "
-                             "to make the density depend on these fields. In this simple material "
-                             "model, we make the following assumptions: if no compositional fields "
-                             "are used in the current simulation, then the density is simply the usual "
-                             "one with its linear dependence on the temperature. If there are compositional "
-                             "fields, then the density only depends on the first one in such a way that "
-                             "the density has an additional term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
-                             "This parameter describes the value of $\\Delta \\rho$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
-          prm.declare_entry ("A1", "1085.7",
-                             Patterns::Double (),
-                             "Constant parameter in the quadratic "
-                             "function that approximates the solidus "
-                             "of peridotite. "
-                             "Units: \\si{\\degreeCelsius}.");
-          prm.declare_entry ("A2", "1.329e-7",
-                             Patterns::Double (),
-                             "Prefactor of the linear pressure term "
-                             "in the quadratic function that approximates "
-                             "the solidus of peridotite. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
-          prm.declare_entry ("A3", "-5.1e-18",
-                             Patterns::Double (),
-                             "Prefactor of the quadratic pressure term "
-                             "in the quadratic function that approximates "
-                             "the solidus of peridotite. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
-          prm.declare_entry ("B1", "1475.0",
-                             Patterns::Double (),
-                             "Constant parameter in the quadratic "
-                             "function that approximates the lherzolite "
-                             "liquidus used for calculating the fraction "
-                             "of peridotite-derived melt. "
-                             "Units: \\si{\\degreeCelsius}.");
-          prm.declare_entry ("B2", "8.0e-8",
-                             Patterns::Double (),
-                             "Prefactor of the linear pressure term "
-                             "in the quadratic function that approximates "
-                             "the  lherzolite liquidus used for "
-                             "calculating the fraction of peridotite-"
-                             "derived melt. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
-          prm.declare_entry ("B3", "-3.2e-18",
-                             Patterns::Double (),
-                             "Prefactor of the quadratic pressure term "
-                             "in the quadratic function that approximates "
-                             "the  lherzolite liquidus used for "
-                             "calculating the fraction of peridotite-"
-                             "derived melt. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
-          prm.declare_entry ("C1", "1780.0",
-                             Patterns::Double (),
-                             "Constant parameter in the quadratic "
-                             "function that approximates the liquidus "
-                             "of peridotite. "
-                             "Units: \\si{\\degreeCelsius}.");
-          prm.declare_entry ("C2", "4.50e-8",
-                             Patterns::Double (),
-                             "Prefactor of the linear pressure term "
-                             "in the quadratic function that approximates "
-                             "the liquidus of peridotite. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
-          prm.declare_entry ("C3", "-2.0e-18",
-                             Patterns::Double (),
-                             "Prefactor of the quadratic pressure term "
-                             "in the quadratic function that approximates "
-                             "the liquidus of peridotite. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
-          prm.declare_entry ("r1", "0.5",
-                             Patterns::Double (),
-                             "Constant in the linear function that "
-                             "approximates the clinopyroxene reaction "
-                             "coefficient. "
-                             "Units: non-dimensional.");
-          prm.declare_entry ("r2", "8e-11",
-                             Patterns::Double (),
-                             "Prefactor of the linear pressure term "
-                             "in the linear function that approximates "
-                             "the clinopyroxene reaction coefficient. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("beta", "1.5",
-                             Patterns::Double (),
-                             "Exponent of the melting temperature in "
-                             "the melt fraction calculation. "
-                             "Units: non-dimensional.");
-          prm.declare_entry ("Peridotite melting entropy change", "-300.",
-                             Patterns::Double (),
-                             "The entropy change for the phase transition "
-                             "from solid to melt of peridotite. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Mass fraction cpx", "0.15",
-                             Patterns::Double (),
-                             "Mass fraction of clinopyroxene in the "
-                             "peridotite to be molten. "
-                             "Units: non-dimensional.");
-          prm.declare_entry ("D1", "976.0",
-                             Patterns::Double (),
-                             "Constant parameter in the quadratic "
-                             "function that approximates the solidus "
-                             "of pyroxenite. "
-                             "Units: \\si{\\degreeCelsius}.");
-          prm.declare_entry ("D2", "1.329e-7",
-                             Patterns::Double (),
-                             "Prefactor of the linear pressure term "
-                             "in the quadratic function that approximates "
-                             "the solidus of pyroxenite. "
-                             "Note that this factor is different from the "
-                             "value given in Sobolev, 2011, because they use "
-                             "the potential temperature whereas we use the "
-                             "absolute temperature. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
-          prm.declare_entry ("D3", "-5.1e-18",
-                             Patterns::Double (),
-                             "Prefactor of the quadratic pressure term "
-                             "in the quadratic function that approximates "
-                             "the solidus of pyroxenite. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
-          prm.declare_entry ("E1", "663.8",
-                             Patterns::Double (),
-                             "Prefactor of the linear depletion term "
-                             "in the quadratic function that approximates "
-                             "the melt fraction of pyroxenite. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal}.");
-          prm.declare_entry ("E2", "-611.4",
-                             Patterns::Double (),
-                             "Prefactor of the quadratic depletion term "
-                             "in the quadratic function that approximates "
-                             "the melt fraction of pyroxenite. "
-                             "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
-          prm.declare_entry ("Pyroxenite melting entropy change", "-400.",
-                             Patterns::Double (),
-                             "The entropy change for the phase transition "
-                             "from solid to melt of pyroxenite. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Maximum pyroxenite melt fraction", "0.5429",
-                             Patterns::Double (),
-                             "Maximum melt fraction of pyroxenite "
-                             "in this parameterization. At higher "
-                             "temperatures peridotite begins to melt.");
-          prm.declare_entry ("Relative density of melt", "0.9",
-                             Patterns::Double (),
-                             "The relative density of melt compared to the "
-                             "solid material. This means, the density change "
-                             "upon melting is this parameter times the density "
-                             "of solid material."
-                             "Units: non-dimensional.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    LatentHeatMelt<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Latent heat melt");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          reference_T                = prm.get_double ("Reference temperature");
-          eta                        = prm.get_double ("Viscosity");
-          composition_viscosity_prefactor = prm.get_double ("Composition viscosity prefactor");
-          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
-          k_value                    = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-          melt_thermal_alpha         = prm.get_double ("Thermal expansion coefficient of melt");
-          reference_compressibility  = prm.get_double ("Compressibility");
-          compositional_delta_rho    = prm.get_double ("Density differential for compositional field 1");
-
-          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
-            AssertThrow(false, ExcMessage("Error: Material model latent heat with Thermal viscosity exponent can not have reference_T=0."));
-
-          A1              = prm.get_double ("A1");
-          A2              = prm.get_double ("A2");
-          A3              = prm.get_double ("A3");
-          B1              = prm.get_double ("B1");
-          B2              = prm.get_double ("B2");
-          B3              = prm.get_double ("B3");
-          C1              = prm.get_double ("C1");
-          C2              = prm.get_double ("C2");
-          C3              = prm.get_double ("C3");
-          r1              = prm.get_double ("r1");
-          r2              = prm.get_double ("r2");
-          beta            = prm.get_double ("beta");
-          peridotite_melting_entropy_change
-            = prm.get_double ("Peridotite melting entropy change");
-
-          M_cpx           = prm.get_double ("Mass fraction cpx");
-          D1              = prm.get_double ("D1");
-          D2              = prm.get_double ("D2");
-          D3              = prm.get_double ("D3");
-          E1              = prm.get_double ("E1");
-          E2              = prm.get_double ("E2");
-          pyroxenite_melting_entropy_change
-            = prm.get_double ("Pyroxenite melting entropy change");
-
-          F_px_max        = prm.get_double ("Maximum pyroxenite melt fraction");
-          relative_melt_density = prm.get_double ("Relative density of melt");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(LatentHeatMelt,
-                                   "latent heat melt",
-                                   "A material model that includes the latent heat of melting "
-                                   "for two materials: peridotite and pyroxenite. The melting model "
-                                   "for peridotite is taken from Katz et al., 2003 (A new "
-                                   "parameterization of hydrous mantle melting) and the one for "
-                                   "pyroxenite from Sobolev et al., 2011 (Linking mantle plumes, "
-                                   "large igneous provinces and environmental catastrophes). "
-                                   "The model assumes a constant entropy change for melting 100\\% "
-                                   "of the material, which can be specified in the input file. "
-                                   "The partial derivatives of entropy with respect to temperature "
-                                   "and pressure required for calculating the latent heat consumption "
-                                   "are then calculated as product of this constant entropy change, "
-                                   "and the respective derivative of the function the describes the "
-                                   "melt fraction. This is linearly averaged with respect to the "
-                                   "fractions of the two materials present. "
-                                   "If no compositional fields are specified in the input file, the "
-                                   "model assumes that the material is peridotite. If compositional "
-                                   "fields are specified, the model assumes that the first compositional "
-                                   "field is the fraction of pyroxenite and the rest of the material "
-                                   "is peridotite. "
-                                   "\n\n"
-                                   "Otherwise, this material model has a temperature- and pressure-"
-                                   "dependent density and viscosity and the density and thermal "
-                                   "expansivity depend on the melt fraction present. "
-                                   "It is possible to extent this model to include a melt fraction "
-                                   "dependence of all the material parameters by calling the "
-                                   "function melt_fraction in the calculation of the respective "
-                                   "parameter. "
-                                   "However, melt and solid move with the same velocity and "
-                                   "melt extraction is not taken into account (batch melting). ")
-  }
-}
diff --git a/source/material_model/melt_boukare.cc.bak b/source/material_model/melt_boukare.cc.bak
deleted file mode 100644
index 2e0b0ab91c2..00000000000
--- a/source/material_model/melt_boukare.cc.bak
+++ /dev/null
@@ -1,1314 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/material_model/melt_boukare.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace
-    {
-      std::vector<std::string> make_boukare_additional_outputs_names()
-      {
-        std::vector<std::string> names;
-        names.emplace_back("bulk_composition");
-        names.emplace_back("molar_volatiles_in_melt");
-        return names;
-      }
-    }
-
-
-
-    template <int dim>
-    BoukareOutputs<dim>::BoukareOutputs (const unsigned int n_points)
-      :
-      NamedAdditionalMaterialOutputs<dim>(make_boukare_additional_outputs_names()),
-      bulk_composition(n_points, numbers::signaling_nan<double>()),
-      molar_volatiles_in_melt(n_points, numbers::signaling_nan<double>())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    BoukareOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      AssertIndexRange (idx, 2);
-      if (idx == 0)
-        return bulk_composition;
-      else
-        return molar_volatiles_in_melt;
-    }
-
-
-
-    template <int dim>
-    void
-    MeltBoukare<dim>::initialize()
-    {
-      // Compute parameters for the modified Tait equation of state for the different endmembers
-      // derived from the isothermal bulk modulus and its two first pressure derivatives.
-      // This corresponds to Equation 4 from Holland and Powell, 2011 (https://doi.org/10.1111/j.1525-1314.2010.00923.x).
-
-      const unsigned int n_endmembers = reference_bulk_moduli.size();
-
-      tait_parameters_a.resize(n_endmembers);
-      tait_parameters_b.resize(n_endmembers);
-      tait_parameters_c.resize(n_endmembers);
-
-      for (unsigned int i=0; i<n_endmembers; ++i)
-        {
-          tait_parameters_a[i] = (1. + bulk_modulus_pressure_derivatives[i]) /
-                                 (1. + bulk_modulus_pressure_derivatives[i] + reference_bulk_moduli[i] * bulk_modulus_second_pressure_derivatives[i]);
-          tait_parameters_b[i] = bulk_modulus_pressure_derivatives[i] / reference_bulk_moduli[i]
-                                 - bulk_modulus_second_pressure_derivatives[i] / (1. + bulk_modulus_pressure_derivatives[i]);
-          tait_parameters_c[i] = (1. + bulk_modulus_pressure_derivatives[i] + reference_bulk_moduli[i] * bulk_modulus_second_pressure_derivatives[i]) /
-                                 (std::pow(bulk_modulus_pressure_derivatives[i],2) + bulk_modulus_pressure_derivatives[i]
-                                  - reference_bulk_moduli[i] * bulk_modulus_second_pressure_derivatives[i]);
-        }
-
-      febdg_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "FeSiO3_bridgmanite"));
-      mgbdg_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "MgSiO3_bridgmanite"));
-      wus_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "FeO_periclase"));
-      per_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "MgO_periclase"));
-      femelt_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "FeO_melt"));
-      mgmelt_idx = std::distance(endmember_names.begin(), find(endmember_names.begin(), endmember_names.end(), "MgO_melt"));
-    }
-
-
-
-    template <int dim>
-    double
-    MeltBoukare<dim>::
-    reference_darcy_coefficient () const
-    {
-      // 0.01 = 1% melt
-      return reference_permeability * std::pow(0.01,3.0) / eta_f;
-    }
-
-    template <int dim>
-    bool
-    MeltBoukare<dim>::
-    is_compressible () const
-    {
-      return true;
-    }
-
-
-    template <int dim>
-    MeltBoukare<dim>::
-    EndmemberProperties::EndmemberProperties(const unsigned int n_endmembers)
-      :
-      volumes(n_endmembers, numbers::signaling_nan<double>()),
-      gibbs_energies(n_endmembers, numbers::signaling_nan<double>()),
-      entropies(n_endmembers, numbers::signaling_nan<double>()),
-      thermal_expansivities(n_endmembers, numbers::signaling_nan<double>()),
-      bulk_moduli(n_endmembers, numbers::signaling_nan<double>()),
-      heat_capacities(n_endmembers, numbers::signaling_nan<double>())
-    {}
-
-
-
-    template <int dim>
-    void
-    MeltBoukare<dim>::
-    fill_endmember_properties (const typename Interface<dim>::MaterialModelInputs &in,
-                               const unsigned int q,
-                               EndmemberProperties &properties) const
-    {
-      const double n_endmembers = properties.volumes.size();
-
-      for (unsigned int i=0; i<n_endmembers; ++i)
-        {
-          const double a = tait_parameters_a[i];
-          const double b = tait_parameters_b[i];
-          const double c = tait_parameters_c[i];
-
-          const double Pth = endmember_thermal_pressure(in.temperature[q], i) - endmember_thermal_pressure(reference_temperature, i);
-
-          const double heat_capacity_ratio = endmember_molar_heat_capacity(in.temperature[q], i)
-                                             / endmember_molar_heat_capacity(reference_temperature, i) ;
-
-          // Integrate the gibbs free energy along the isobaric path from (P_ref, T_ref) to (P_ref, T_final)
-          const double G_Pref_Tf = reference_enthalpies[i] + endmember_enthalpy_thermal_addition(in.temperature[q], i)
-                                   - in.temperature[q] * (reference_entropies[i] + endmember_entropy_thermal_addition(in.temperature[q], i));
-
-          // Integrate the gibbs free energy along the isothermal path from (P_ref, T_final) to (P_final, T_final)
-          long double intVdP = 0.;
-          long double dintVdpdT = 0.;
-
-          const double pressure = this->get_adiabatic_conditions().pressure(in.position[q]);
-
-          if (pressure != reference_pressure && pressure > 0.0)
-            {
-              intVdP = reference_volumes[i]
-                       * ((pressure - reference_pressure) * (1. - a)
-                          + (a * (std::pow((1. + b * (reference_pressure - Pth)), 1. - c) - std::pow((1. + b * (pressure - Pth)), 1. - c)) / (b * (c - 1.))));
-
-              const double prefactor = reference_volumes[i] * reference_thermal_expansivities[i] * reference_bulk_moduli[i] * a * heat_capacity_ratio;
-              dintVdpdT = prefactor * (std::pow(1. + b * (pressure - Pth), -c) - std::pow(1. + b * (reference_pressure - Pth), -c));
-            }
-
-          properties.gibbs_energies[i] = G_Pref_Tf + intVdP;
-          properties.entropies[i] =  reference_entropies[i] + endmember_entropy_thermal_addition(in.temperature[q], i) + dintVdpdT;
-          properties.volumes[i] = reference_volumes[i] * (1 - a * (1. - std::pow(1. + b * (pressure - Pth), -c)));
-
-          properties.bulk_moduli[i] = reference_bulk_moduli[i] * (1. + b * (pressure - Pth))
-                                      * (a + (1. - a) * std::pow(1. + b * (pressure - Pth), c));
-
-          const double C_V0 = endmember_molar_heat_capacity(reference_temperature, i);
-          const double C_V = endmember_molar_heat_capacity(in.temperature[q], i);
-          properties.thermal_expansivities[i] = reference_thermal_expansivities[i] * (C_V / C_V0) *
-                                                1. / ((1. + b * (pressure - Pth)) *
-                                                      (a + (1. - a) * std::pow(1 + b * (pressure - Pth), c)));
-
-          const double Cp_ref = reference_specific_heats[i] + specific_heat_linear_coefficients[i] * in.temperature[q]
-                                + specific_heat_second_coefficients[i] * std::pow(in.temperature[q], -2.)
-                                + specific_heat_third_coefficients[i] * std::pow(in.temperature[q], -0.5);
-
-          const long double dSdT0 = reference_volumes[i] * reference_bulk_moduli[i] * std::pow(heat_capacity_ratio * reference_thermal_expansivities[i], 2.0)
-                                    * (std::pow(1. + b * (pressure - Pth), -1.-c) - std::pow(1. + b * (reference_pressure - Pth), -1.- c));
-
-          const double relative_T = Einstein_temperatures[i] / in.temperature[q];
-          const double dSdT = dSdT0 + dintVdpdT * (1 - 2./relative_T + 2./(std::exp(relative_T) - 1.)) * relative_T/in.temperature[q];
-
-          properties.heat_capacities[i] = Cp_ref + in.temperature[q] * dSdT;
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    MeltBoukare<dim>::
-    endmember_thermal_energy (const double temperature,
-                              const unsigned int endmember_index) const
-    {
-      AssertThrow(temperature > 0.0,
-                  ExcMessage("The temperature has to be larger than 0, but it is "
-                             + std::to_string(temperature) + " for endmember " + std::to_string(endmember_index) + "."));
-
-      const double relative_T = Einstein_temperatures[endmember_index] / temperature;
-      const double energy = 3. * number_of_atoms[endmember_index] * constants::gas_constant * Einstein_temperatures[endmember_index]
-                            * (0.5 + 1. / (std::exp(relative_T) - 1.0));
-
-      return energy;
-    }
-
-
-
-    template <int dim>
-    double
-    MeltBoukare<dim>::
-    endmember_molar_heat_capacity (const double temperature,
-                                   const unsigned int endmember_index) const
-    {
-      AssertThrow(temperature > 0.0,
-                  ExcMessage("The temperature has to be larger than 0!"));
-
-      const double relative_T = Einstein_temperatures[endmember_index] / temperature;
-      const double heat_capacity = 3. * number_of_atoms[endmember_index] * constants::gas_constant * std::pow(relative_T, 2)
-                                   * std::exp(relative_T) / std::pow(std::exp(relative_T) - 1.0, 2);
-
-      return heat_capacity;
-    }
-
-
-
-    template <int dim>
-    double
-    MeltBoukare<dim>::
-    endmember_thermal_pressure (const double temperature,
-                                const unsigned int endmember_index) const
-    {
-      const double thermal_energy = endmember_thermal_energy(temperature, endmember_index);
-      const double heat_capacity = endmember_molar_heat_capacity(reference_temperature, endmember_index);
-      const double thermal_pressure = reference_thermal_expansivities[endmember_index] * reference_bulk_moduli[endmember_index] / heat_capacity * thermal_energy;
-
-      return thermal_pressure;
-    }
-
-
-
-    template <int dim>
-    double
-    MeltBoukare<dim>::
-    endmember_enthalpy_thermal_addition (const double temperature,
-                                         const unsigned int i) const
-    {
-      const double addition = reference_specific_heats[i] * temperature
-                              + 0.5 * specific_heat_linear_coefficients[i] * std::pow(temperature, 2.)
-                              - specific_heat_second_coefficients[i] / temperature
-                              + 2. * specific_heat_third_coefficients[i] * std::sqrt(temperature)
-                              - (reference_specific_heats[i] * reference_temperature
-                                 + 0.5 * specific_heat_linear_coefficients[i] * std::pow(reference_temperature, 2.)
-                                 - specific_heat_second_coefficients[i] / reference_temperature
-                                 + 2.0 * specific_heat_third_coefficients[i] * std::sqrt(reference_temperature));
-
-      return addition;
-    }
-
-
-
-    template <int dim>
-    double
-    MeltBoukare<dim>::
-    endmember_entropy_thermal_addition (const double temperature,
-                                        const unsigned int i) const
-    {
-      const double addition = reference_specific_heats[i] * std::log(temperature)
-                              + specific_heat_linear_coefficients[i] * temperature
-                              - 0.5 * specific_heat_second_coefficients[i] / std::pow(temperature, 2.)
-                              - 2.0 * specific_heat_third_coefficients[i] / std::sqrt(temperature)
-                              - (reference_specific_heats[i] * std::log(reference_temperature)
-                                 + specific_heat_linear_coefficients[i] * reference_temperature
-                                 - 0.5 * specific_heat_second_coefficients[i] / std::pow(reference_temperature, 2.)
-                                 - 2.0 * specific_heat_third_coefficients[i] / std::sqrt(reference_temperature));
-
-      return addition;
-    }
-
-
-
-    template <int dim>
-    void
-    MeltBoukare<dim>::
-    convert_composition_to_fraction_of_endmembers (const double temperature,
-                                                   const double molar_Fe_in_solid,
-                                                   const double molar_Fe_in_melt,
-                                                   const std::vector<double> &endmember_gibbs_energies,
-                                                   std::vector<double> &endmember_mole_fractions_per_phase,
-                                                   double &molar_bridgmanite_in_solid) const
-    {
-      const double x_FeO = molar_Fe_in_solid * molar_FeO_in_Fe_mantle_endmember;
-      const double x_MgO = (1. - molar_Fe_in_solid) * molar_MgO_in_Mg_mantle_endmember;
-      const double x_SiO2 = molar_Fe_in_solid * molar_SiO2_in_Fe_mantle_endmember + (1. - molar_Fe_in_solid) * molar_SiO2_in_Mg_mantle_endmember;
-
-      const double molar_fraction_FeO = x_FeO/(x_MgO + x_FeO);
-      const double molar_fraction_SiO2 = x_SiO2/(x_MgO + x_FeO);
-      molar_bridgmanite_in_solid = molar_fraction_SiO2;
-
-      const double gibbs_energy_of_reaction = endmember_gibbs_energies[mgbdg_idx] + endmember_gibbs_energies[wus_idx]
-                                              - endmember_gibbs_energies[febdg_idx] - endmember_gibbs_energies[per_idx];
-      const double partition_coefficient = std::exp(gibbs_energy_of_reaction / (constants::gas_constant * temperature));
-
-      // Solving equation 6 in Nakajima et al., 2012 for X_Fe_fp and X_Fe_pv
-      // Solved using the definition of the distribution coefficient to define X_Fe_fp as a function of X_Fe_pv
-
-      const double num_to_sqrt = -4. * molar_fraction_FeO * (partition_coefficient - 1.) * partition_coefficient * molar_fraction_SiO2
-                                 + std::pow(1. + (molar_fraction_FeO + molar_fraction_SiO2) * (partition_coefficient - 1.0), 2.);
-
-      endmember_mole_fractions_per_phase[febdg_idx] = (-1. + molar_fraction_FeO - (molar_fraction_FeO * partition_coefficient) + molar_fraction_SiO2 - (molar_fraction_SiO2 * partition_coefficient) + std::sqrt(num_to_sqrt)) /
-                                                      (2. * molar_fraction_SiO2 * (1. - partition_coefficient));
-
-      endmember_mole_fractions_per_phase[wus_idx] = endmember_mole_fractions_per_phase[febdg_idx] / (((1. - endmember_mole_fractions_per_phase[febdg_idx]) * partition_coefficient) + endmember_mole_fractions_per_phase[febdg_idx]);
-
-      endmember_mole_fractions_per_phase[mgbdg_idx] = 1.0 - endmember_mole_fractions_per_phase[febdg_idx];
-      endmember_mole_fractions_per_phase[per_idx] = 1.0 - endmember_mole_fractions_per_phase[wus_idx];
-
-      endmember_mole_fractions_per_phase[mgmelt_idx] = 1. - molar_Fe_in_melt;
-      endmember_mole_fractions_per_phase[femelt_idx] = molar_Fe_in_melt;
-
-      return;
-    }
-
-
-
-    template <int dim>
-    double
-    MeltBoukare<dim>::
-    compute_melt_molar_fraction (const double porosity,
-                                 const double bridgmanite_molar_fraction_in_solid,
-                                 EndmemberProperties &endmembers,
-                                 const std::vector<double> &endmember_mole_fractions_per_phase) const
-    {
-      double melt_molar_volume = 0.0;
-      double solid_molar_volume = 0.0;
-      for (unsigned int i=0; i<endmember_names.size(); ++i)
-        {
-          // We assume here that the first 2 endmembers are the (solid) bridgmanite endmembers,
-          // and the 3rd and 4th are the (solid) ferropericlase endmembers. The endmember_phase_fraction_in_solid
-          // variable therefore indicates the fraction of bridgmanite or ferropericlase in the solid
-          // (depending on which phase the endmember belongs to).
-          const double endmember_phase_fraction_in_solid = i<2 ? bridgmanite_molar_fraction_in_solid : 1.0 - bridgmanite_molar_fraction_in_solid;
-
-          if (endmember_states[i] == EndmemberState::melt)
-            melt_molar_volume += endmember_mole_fractions_per_phase[i] * endmembers.volumes[i];
-          else if (endmember_states[i] == EndmemberState::solid)
-            solid_molar_volume += endmember_phase_fraction_in_solid * endmember_mole_fractions_per_phase[i] * endmembers.volumes[i];
-          else
-            AssertThrow (false, ExcNotImplemented());
-        }
-
-      // The porosity needs to be between 0 and 1,
-      // but that may not always be the case, because it is advected using the finite element.
-      const double bounded_porosity = std::min(1.0, std::max(0.0, porosity));
-
-      double melt_molar_fraction = 0.0;
-      if (melt_molar_volume > 0.0)
-        {
-          const double n_moles_total = bounded_porosity / melt_molar_volume + (1.0 - bounded_porosity) / solid_molar_volume;
-          melt_molar_fraction = bounded_porosity / (melt_molar_volume * n_moles_total);
-        }
-
-      return melt_molar_fraction;
-    }
-
-
-
-    template <int dim>
-    double
-    MeltBoukare<dim>::
-    assert_update_is_within_0_and_1 (const double old_value,
-                                     const double change_of_value) const
-    {
-      if (old_value + change_of_value < 0.0)
-        {
-          AssertThrow (false, ExcMessage("Update below 0. Proposed update: " + std::to_string(old_value + change_of_value)));
-          return -old_value;
-        }
-      else if (old_value + change_of_value > 1.0)
-        {
-          AssertThrow (false, ExcMessage("Update above 1. Proposed update: " + std::to_string(old_value + change_of_value)));
-          return 1.0 - old_value;
-        }
-      else
-        return change_of_value;
-    }
-
-
-
-    template <int dim>
-    double
-    MeltBoukare<dim>::
-    melt_fraction (const double temperature,
-                   const double pressure,
-                   const double molar_composition_of_bulk,
-                   double &molar_volatiles_in_melt,
-                   double &new_molar_composition_of_solid,
-                   double &new_molar_composition_of_melt) const
-    {
-      if (temperature == 0.0)
-        return 0.0;
-
-      const double molar_volatiles_in_bulk = 1.e-4;
-      {
-        // after Phipps Morgan, Jason. "Thermodynamics of pressure release melting of a veined plum pudding mantle."
-        // Geochemistry, Geophysics, Geosystems 2.4 (2001).
-        // See also Appendix B of Dannberg et al., 2021. "The morphology, evolution and seismic visibility of partial
-        // melt at the core-mantle boundary: Implications for ULVZs".
-        const double P = pressure;                   // pressure in Pa
-        const double T = temperature;                // temperature in K
-        const double R = constants::gas_constant;    // Ideal Gas Constant
-
-        // Free Energy Change Delta_G due to melting as a function of temperature and pressure
-        const double dG_Fe_mantle = (Fe_mantle_melting_temperature - T) * Fe_mantle_melting_entropy
-                                    + (P - melting_reference_pressure) * Fe_mantle_melting_volume;
-        const double dG_Mg_mantle = (Mg_mantle_melting_temperature - T) * Mg_mantle_melting_entropy
-                                    + (P - melting_reference_pressure) * Mg_mantle_melting_volume;
-
-        // Equations (B.13) and (B.14) in Appendix B of Dannberg et al., 2021.
-        const double c_Fe_endmember = std::exp(dG_Fe_mantle/(Fe_number_of_moles*R*T));
-        const double c_Mg_endmember = std::exp(dG_Mg_mantle/(Mg_number_of_moles*R*T));
-
-        // Mole composition of the solid and liquid (corresponds to the molar fraction of X_Fe, the iron-bearing endmember).
-        // In addition to the Phipps Morgan model, we also include volatiles here.
-        // Equations (B.8) and (B.10) to (B.12) in Appendix B of Dannberg et al., 2021.
-        const double q0 = (c_Fe_endmember - c_Mg_endmember) * c_Fe_endmember/c_Mg_endmember;
-        const double q1 = c_Fe_endmember * (1. - 1./c_Mg_endmember) - molar_composition_of_bulk * (c_Fe_endmember - c_Mg_endmember)/c_Mg_endmember + molar_volatiles_in_bulk * (1. - c_Fe_endmember);
-        const double q2 = -molar_composition_of_bulk * (1. - 1./c_Mg_endmember);
-        const double molar_composition_of_melt = (-q1 + std::sqrt(q1*q1 - 4.*q0*q2))/(2.*q0);
-
-        const double T_Fe_mantle = dG_Fe_mantle / Fe_mantle_melting_entropy;
-        const double T_Mg_mantle = dG_Mg_mantle / Mg_mantle_melting_entropy;
-
-        double melt_molar_fraction;
-
-        if (molar_composition_of_bulk < std::numeric_limits<double>::min())
-          {
-            melt_molar_fraction = T_Mg_mantle < 0.0 ? 1.0 : molar_volatiles_in_bulk;
-            new_molar_composition_of_melt = 0.0;
-            new_molar_composition_of_solid = 0.0;
-          }
-        else if (molar_composition_of_melt <= molar_composition_of_bulk
-                 && std::min(T_Fe_mantle, T_Mg_mantle) < 0.0) // above the liquidus
-          {
-            melt_molar_fraction = 1.0;
-            new_molar_composition_of_melt = molar_composition_of_bulk;
-            new_molar_composition_of_solid = molar_composition_of_bulk;
-
-            molar_volatiles_in_melt = molar_volatiles_in_bulk;
-          }
-        else
-          {
-            // Equations (B.9) in Appendix B of Dannberg et al., 2021.
-            const double molar_composition_of_solid = molar_composition_of_melt * c_Fe_endmember;
-
-            new_molar_composition_of_solid = std::max(std::min(molar_composition_of_solid, molar_composition_of_bulk), 0.0);
-            new_molar_composition_of_melt = std::min(std::max(molar_composition_of_melt, molar_composition_of_bulk), 1.0);
-
-            if (std::abs(molar_composition_of_melt - molar_composition_of_solid) > std::numeric_limits<double>::min())
-              melt_molar_fraction = std::min(std::max((molar_composition_of_bulk - molar_composition_of_solid) / (molar_composition_of_melt - molar_composition_of_solid), 0.0), 1.0);
-            // If solid and melt composition are the same, there is no two-phase region.
-            // If we are not above the liquidus, we are below the solidus.
-            else
-              melt_molar_fraction = molar_volatiles_in_bulk;
-
-            if (molar_volatiles_in_bulk > 0.0 && std::abs(molar_composition_of_bulk - molar_composition_of_solid) > std::numeric_limits<double>::min())
-              molar_volatiles_in_melt = molar_volatiles_in_bulk*(molar_composition_of_melt - molar_composition_of_solid)/(molar_composition_of_bulk - molar_composition_of_solid);
-          }
-
-        return melt_molar_fraction;
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    MeltBoukare<dim>::
-    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                    std::vector<double> &melt_fractions) const
-    {
-      const unsigned int Fe_solid_idx = this->introspection().compositional_index_for_name("molar_Fe_in_solid");
-      unsigned int Fe_melt_idx = numbers::invalid_unsigned_int;
-      unsigned int porosity_idx = numbers::invalid_unsigned_int;
-
-      if (this->include_melt_transport())
-        {
-          Fe_melt_idx = this->introspection().compositional_index_for_name("molar_Fe_in_melt");
-          porosity_idx = this->introspection().compositional_index_for_name("porosity");
-        }
-
-      const unsigned int n_endmembers = endmember_names.size();
-      EndmemberProperties endmembers(n_endmembers);
-
-      for (unsigned int q=0; q<in.temperature.size(); ++q)
-        {
-          std::vector<double> endmember_mole_fractions_per_phase(n_endmembers);
-
-          fill_endmember_properties(in, q, endmembers);
-
-          // We need the compositions of all phases.
-          double solid_composition = in.composition[q][Fe_solid_idx];
-          double melt_composition = 0.0, melt_molar_fraction = 0.0;
-          double bridgmanite_molar_fraction_in_solid;
-
-          if (this->include_melt_transport())
-            melt_composition = in.composition[q][Fe_melt_idx];
-
-          convert_composition_to_fraction_of_endmembers(in.temperature[q],
-                                                        solid_composition,
-                                                        melt_composition,
-                                                        endmembers.gibbs_energies,
-                                                        endmember_mole_fractions_per_phase,
-                                                        bridgmanite_molar_fraction_in_solid);
-
-
-          if (this->include_melt_transport())
-            melt_molar_fraction = compute_melt_molar_fraction(in.composition[q][porosity_idx],
-                                                              bridgmanite_molar_fraction_in_solid,
-                                                              endmembers,
-                                                              endmember_mole_fractions_per_phase);
-
-          const double solid_molar_fraction = 1.0 - melt_molar_fraction;
-          const double bulk_composition = melt_composition * melt_molar_fraction + solid_composition * solid_molar_fraction;
-          double molar_volatiles_in_melt = 0.0;
-
-          const double eq_melt_molar_fraction = this->melt_fraction(in.temperature[q],
-                                                                    this->get_adiabatic_conditions().pressure(in.position[q]),
-                                                                    bulk_composition,
-                                                                    molar_volatiles_in_melt,
-                                                                    solid_composition,
-                                                                    melt_composition);
-
-          // We have to compute the endmember fractions again here because the porosity is now different.
-          convert_composition_to_fraction_of_endmembers(in.temperature[q],
-                                                        solid_composition,
-                                                        melt_composition,
-                                                        endmembers.gibbs_energies,
-                                                        endmember_mole_fractions_per_phase,
-                                                        bridgmanite_molar_fraction_in_solid);
-
-
-          // convert from melt molar fraction to porosity
-          const double solid_molar_volume = bridgmanite_molar_fraction_in_solid * endmember_mole_fractions_per_phase[febdg_idx] * endmembers.volumes[febdg_idx]
-                                            + bridgmanite_molar_fraction_in_solid * endmember_mole_fractions_per_phase[mgbdg_idx] * endmembers.volumes[mgbdg_idx]
-                                            + (1. - bridgmanite_molar_fraction_in_solid) * endmember_mole_fractions_per_phase[per_idx] * endmembers.volumes[per_idx]
-                                            + (1. - bridgmanite_molar_fraction_in_solid) * endmember_mole_fractions_per_phase[wus_idx] * endmembers.volumes[wus_idx];
-          const double melt_molar_volume = endmember_mole_fractions_per_phase[mgmelt_idx] * endmembers.volumes[mgmelt_idx]
-                                           + endmember_mole_fractions_per_phase[femelt_idx] * endmembers.volumes[femelt_idx];
-
-          melt_fractions[q] = eq_melt_molar_fraction * melt_molar_volume
-                              / (eq_melt_molar_fraction * melt_molar_volume + (1.0 - eq_melt_molar_fraction) * solid_molar_volume);
-        }
-      return;
-    }
-
-
-
-    template <int dim>
-    void
-    MeltBoukare<dim>::
-    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
-      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
-      BoukareOutputs<dim> *boukare_out = out.template get_additional_output<BoukareOutputs<dim>>();
-      EnthalpyOutputs<dim> *enthalpy_out = out.template get_additional_output<EnthalpyOutputs<dim>>();
-
-      const unsigned int Fe_solid_idx = this->introspection().compositional_index_for_name("molar_Fe_in_solid");
-      unsigned int Fe_melt_idx = numbers::invalid_unsigned_int;
-      unsigned int porosity_idx = numbers::invalid_unsigned_int;
-
-      if (this->include_melt_transport())
-        {
-          Fe_melt_idx = this->introspection().compositional_index_for_name("molar_Fe_in_melt");
-          porosity_idx = this->introspection().compositional_index_for_name("porosity");
-        }
-
-      // If the temperature or pressure are zero, this model does not work.
-      // This should only happen when setting the melt constraints before we have the initial temperature.
-      // In this case, just fill the permeabilities and fluid viscosities and return.
-      const unsigned int n_points = in.n_evaluation_points();
-      for (unsigned int q=0; q<n_points; ++q)
-        {
-          if (in.temperature[q] == 0.0)
-            {
-              if (melt_out != nullptr)
-                {
-                  for (unsigned int q=0; q<n_points; ++q)
-                    {
-                      const double porosity = std::max(in.composition[q][porosity_idx],0.0);
-                      melt_out->fluid_viscosities[q] = eta_f;
-                      melt_out->permeabilities[q] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-                    }
-                }
-              return;
-            }
-        }
-
-      // We need the reaction step here to conserve bulk composition.
-      double reaction_time_step_size = 1.0;
-      double reaction_fraction = 0.0;
-      if (this->simulator_is_past_initialization())
-        {
-          const unsigned int number_of_reaction_steps = std::max(static_cast<unsigned int>(this->get_timestep() / this->get_parameters().reaction_time_step),
-                                                                 std::max(this->get_parameters().reaction_steps_per_advection_step,1U));
-          reaction_time_step_size = this->get_timestep() / static_cast<double>(number_of_reaction_steps);
-          reaction_fraction = reaction_time_step_size / melting_time_scale;
-        }
-
-      const unsigned int n_endmembers = endmember_names.size();
-      EndmemberProperties endmembers(n_endmembers);
-
-      for (unsigned int q=0; q<in.temperature.size(); ++q)
-        {
-          std::vector<double> endmember_mole_fractions_per_phase(n_endmembers);
-          std::vector<double> endmember_mole_fractions_in_composite(n_endmembers);
-
-          fill_endmember_properties(in, q, endmembers);
-
-          // We need the compositions of all phases.
-          const double solid_composition = in.composition[q][Fe_solid_idx];
-          double melt_composition = 0.0;
-          double melt_molar_fraction = 0.0;
-          double bridgmanite_molar_fraction_in_solid;
-
-          if (this->include_melt_transport())
-            melt_composition = in.composition[q][Fe_melt_idx];
-
-          convert_composition_to_fraction_of_endmembers(in.temperature[q],
-                                                        solid_composition,
-                                                        melt_composition,
-                                                        endmembers.gibbs_energies,
-                                                        endmember_mole_fractions_per_phase,
-                                                        bridgmanite_molar_fraction_in_solid);
-
-          if (this->include_melt_transport())
-            melt_molar_fraction = compute_melt_molar_fraction(in.composition[q][porosity_idx],
-                                                              bridgmanite_molar_fraction_in_solid,
-                                                              endmembers,
-                                                              endmember_mole_fractions_per_phase);
-
-          const double solid_molar_fraction = 1.0 - melt_molar_fraction;
-
-          // Compute endmember molar fractions in the composite.
-          std::vector<double> phase_mole_fractions_in_composite(n_endmembers);
-          double solid_molar_mass = 0.0;
-          double melt_molar_mass = 0.0;
-          double melt_molar_volume = 0.0;
-          double solid_molar_volume = 0.0;
-
-          for (unsigned int i=0; i<n_endmembers; ++i)
-            {
-              // We assume here that the first 2 endmembers are the (solid) bridgmanite endmembers,
-              // and the 3rd and 4th are the (solid) ferropericlase endmembers. The endmember_phase_fraction_in_solid
-              // variable therefore indicates the fraction of bridgmanite or ferropericlase in the solid
-              // (depending on which phase the endmember belongs to).
-              // TODO: allow for more flexibility by letting the user set a phase vector in the input file
-              // (then we can check if phase == 'bridgmanite').
-              const double endmember_phase_fraction_in_solid = i<2 ? bridgmanite_molar_fraction_in_solid : (1.0 - bridgmanite_molar_fraction_in_solid);
-
-              if (endmember_states[i] == EndmemberState::solid)
-                {
-                  // There are two phases in the solid (bridgmanite and ferropericlase). The mole fraction of each
-                  // phase in the composite is the product of the solid fraction in the composite and the fraction
-                  // of that individual phase in the solid.
-                  phase_mole_fractions_in_composite[i] = solid_molar_fraction * endmember_phase_fraction_in_solid;
-                  endmember_mole_fractions_in_composite[i] = phase_mole_fractions_in_composite[i] * endmember_mole_fractions_per_phase[i];
-                  solid_molar_mass += endmember_mole_fractions_in_composite[i] * molar_masses[i];
-                  solid_molar_volume += endmember_mole_fractions_in_composite[i] * endmembers.volumes[i];
-                }
-              else if (endmember_states[i] == EndmemberState::melt)
-                {
-                  // There is only one phase in the melt, so the mole fraction of that phase equals the melt fraction.
-                  phase_mole_fractions_in_composite[i] = melt_molar_fraction;
-                  endmember_mole_fractions_in_composite[i] = phase_mole_fractions_in_composite[i] * endmember_mole_fractions_per_phase[i];
-                  melt_molar_mass += endmember_mole_fractions_in_composite[i] * molar_masses[i];
-                  melt_molar_volume += endmember_mole_fractions_in_composite[i] * endmembers.volumes[i];
-                }
-              else
-                AssertThrow (false, ExcNotImplemented());
-            }
-
-          const double total_molar_mass = melt_molar_mass + solid_molar_mass;
-          const double total_volume = melt_molar_volume + solid_molar_volume;
-
-          out.thermal_expansion_coefficients[q] = 0.0;
-          out.specific_heat[q] = 0.0;
-          out.compressibilities[q] = 0.0;
-
-          // Average the individual endmember properties
-          for (unsigned int i=0; i<n_endmembers; ++i)
-            {
-              out.thermal_expansion_coefficients[q] += (endmember_mole_fractions_in_composite[i] * endmembers.volumes[i] * endmembers.thermal_expansivities[i]) / total_volume;
-              out.specific_heat[q] += endmember_mole_fractions_in_composite[i] * endmembers.heat_capacities[i] / total_molar_mass;
-
-
-              if (endmember_states[i] == EndmemberState::solid && solid_molar_volume > 0.0)
-                {
-                  out.compressibilities[q] += (endmember_mole_fractions_in_composite[i] * endmembers.volumes[i])
-                                              / (solid_molar_volume * endmembers.bulk_moduli[i]);
-                }
-            }
-
-          if (solid_molar_volume > 0.0)
-            out.densities[q] = solid_molar_mass / solid_molar_volume;
-          else
-            out.densities[q] = melt_molar_mass / melt_molar_volume;
-
-          if (melt_out != nullptr)
-            {
-              double melt_compressiblity = 0.0;
-              for (unsigned int i=0; i<n_endmembers; ++i)
-                if (endmember_states[i] == EndmemberState::melt && melt_molar_volume > 0.0)
-                  melt_compressiblity += (endmember_mole_fractions_in_composite[i] * endmembers.volumes[i]) / (melt_molar_volume * endmembers.bulk_moduli[i]);
-
-              if (melt_molar_volume > 0.0)
-                melt_out->fluid_densities[q] = melt_molar_mass / melt_molar_volume;
-              else
-                {
-                  // make sure we have a useful melt density even if there is no melt to avoid density jumps
-                  double mass = 0.0;
-                  double volume = 0.0;
-                  for (unsigned int i=0; i<n_endmembers; ++i)
-                    if (endmember_states[i] == EndmemberState::melt)
-                      {
-                        mass += endmember_mole_fractions_per_phase[i] * molar_masses[i];
-                        volume += endmember_mole_fractions_per_phase[i] * endmembers.volumes[i];
-                      }
-                  melt_out->fluid_densities[q] = mass/volume;
-                }
-
-              // This does not take into account the volume change due to thermal expansion of melt
-              melt_out->fluid_density_gradients[q] = melt_out->fluid_densities[q] * melt_out->fluid_densities[q]
-                                                     * melt_compressiblity
-                                                     * this->get_gravity_model().gravity_vector(in.position[q]);
-            }
-
-
-          if (this->include_melt_transport())
-            {
-              // TODO: Alternatively, this could also be done by summing over endmember_mole_fractions_in_composite
-              const double old_porosity = in.composition[q][porosity_idx];
-              const double old_solid_composition = in.composition[q][Fe_solid_idx];
-              const double old_melt_composition = in.composition[q][Fe_melt_idx];
-              const double old_melt_molar_fraction = melt_molar_fraction;
-
-              // in this simple model, the bulk composition is just one number, namely
-              // the molar fraction of the combined iron endmembers
-              const double bulk_composition = old_melt_composition * melt_molar_fraction + old_solid_composition * solid_molar_fraction;
-              double molar_volatiles_in_melt = 0.0;
-              double solid_composition, melt_composition;
-
-              // calculate the melting rate as difference between the equilibrium melt fraction
-              // and the solution of the previous time step, and also update melt and solid composition
-              melt_molar_fraction = melt_fraction(in.temperature[q],
-                                                  this->get_adiabatic_conditions().pressure(in.position[q]),
-                                                  bulk_composition,
-                                                  molar_volatiles_in_melt,
-                                                  solid_composition,
-                                                  melt_composition);
-
-              if (boukare_out != nullptr)
-                {
-                  boukare_out->bulk_composition[q] = bulk_composition;
-                  boukare_out->molar_volatiles_in_melt[q] = molar_volatiles_in_melt;
-                }
-
-              // We have to compute the update to the melt fraction in such a way that the bulk composition is conserved.
-              const double change_of_melt_composition = reaction_fraction * assert_update_is_within_0_and_1(old_melt_composition, melt_composition - old_melt_composition);
-              const double change_of_melt_fraction = reaction_fraction * assert_update_is_within_0_and_1(old_melt_molar_fraction, melt_molar_fraction - old_melt_molar_fraction);
-
-              melt_composition = old_melt_composition + change_of_melt_composition;
-              melt_molar_fraction = old_melt_molar_fraction + change_of_melt_fraction;
-
-              if (melt_molar_fraction > 0.0 && melt_molar_fraction < 1.0)
-                solid_composition = (bulk_composition - melt_molar_fraction * melt_composition)
-                                    / (1.0 - melt_molar_fraction);
-              const double change_of_solid_composition = solid_composition - old_solid_composition;
-
-
-              // We have to compute the endmember fractions again here because the porosity is now different.
-              convert_composition_to_fraction_of_endmembers(in.temperature[q],
-                                                            solid_composition,
-                                                            melt_composition,
-                                                            endmembers.gibbs_energies,
-                                                            endmember_mole_fractions_per_phase,
-                                                            bridgmanite_molar_fraction_in_solid);
-
-
-              // convert from melt molar fraction to porosity
-              const double solid_molar_volume = bridgmanite_molar_fraction_in_solid * endmember_mole_fractions_per_phase[febdg_idx] * endmembers.volumes[febdg_idx]
-                                                + bridgmanite_molar_fraction_in_solid * endmember_mole_fractions_per_phase[mgbdg_idx] * endmembers.volumes[mgbdg_idx]
-                                                + (1. - bridgmanite_molar_fraction_in_solid) * endmember_mole_fractions_per_phase[per_idx] * endmembers.volumes[per_idx]
-                                                + (1. - bridgmanite_molar_fraction_in_solid) * endmember_mole_fractions_per_phase[wus_idx] * endmembers.volumes[wus_idx];
-              const double melt_molar_volume = endmember_mole_fractions_per_phase[mgmelt_idx] * endmembers.volumes[mgmelt_idx]
-                                               + endmember_mole_fractions_per_phase[femelt_idx] * endmembers.volumes[femelt_idx];
-
-              const double new_porosity = melt_molar_fraction * melt_molar_volume
-                                          / (melt_molar_fraction * melt_molar_volume + (1.0 - melt_molar_fraction) * solid_molar_volume);
-              const double porosity_change = new_porosity - old_porosity;
-
-              // For this simple model, we only track the iron in the solid (bridgmanite) and the iron in the melt
-              for (unsigned int c=0; c<in.composition[q].size(); ++c)
-                {
-                  // fill reaction rate outputs
-                  if (reaction_rate_out != nullptr)
-                    {
-                      if (!include_melting_and_freezing)
-                        reaction_rate_out->reaction_rates[q][c] = 0.0;
-                      else if (c == Fe_solid_idx && this->get_timestep_number() > 0)
-                        reaction_rate_out->reaction_rates[q][c] = change_of_solid_composition / reaction_time_step_size;
-                      else if (c == Fe_melt_idx && this->get_timestep_number() > 0)
-                        reaction_rate_out->reaction_rates[q][c] = change_of_melt_composition / reaction_time_step_size;
-                      else if (c == porosity_idx && this->get_timestep_number() > 0)
-                        reaction_rate_out->reaction_rates[q][c] = porosity_change / reaction_time_step_size;
-                      else
-                        reaction_rate_out->reaction_rates[q][c] = 0.0;
-                    }
-                  out.reaction_terms[q][c] = 0.0;
-                }
-
-              if (enthalpy_out != nullptr)
-                {
-                  const double melt_molar_mass = endmember_mole_fractions_per_phase[mgmelt_idx] * molar_masses[mgmelt_idx]
-                                                 + endmember_mole_fractions_per_phase[femelt_idx] * molar_masses[femelt_idx];
-                  const double Fe_enthalpy_of_fusion = Fe_mantle_melting_temperature * Fe_mantle_melting_entropy
-                                                       + (this->get_adiabatic_conditions().pressure(in.position[q]) - melting_reference_pressure) * Fe_mantle_melting_volume;
-                  const double Mg_enthalpy_of_fusion = Mg_mantle_melting_temperature * Mg_mantle_melting_entropy
-                                                       + (this->get_adiabatic_conditions().pressure(in.position[q]) - melting_reference_pressure) * Mg_mantle_melting_volume;
-                  double enthalpy_of_fusion = Fe_enthalpy_of_fusion * bulk_composition + Mg_enthalpy_of_fusion * (1.0-bulk_composition);
-                  enthalpy_of_fusion /= melt_molar_mass;
-
-                  enthalpy_out->enthalpies_of_fusion[q] = enthalpy_of_fusion;
-                }
-
-              // cutoff for viscosity at 30%
-              const double porosity = std::min(0.3, std::max(in.composition[q][porosity_idx],0.0));
-              out.viscosities[q] = (1.0 - porosity) * eta_0 * std::exp(- alpha_phi * porosity);
-            }
-          else
-            {
-              out.viscosities[q] = eta_0;
-
-              // no melting/freezing is used in the model --> set all reactions to zero
-              for (unsigned int c=0; c<in.composition[q].size(); ++c)
-                {
-                  if (reaction_rate_out != nullptr)
-                    reaction_rate_out->reaction_rates[q][c] = 0.0;
-                }
-            }
-
-          out.entropy_derivative_pressure[q]    = 0.0;
-          out.entropy_derivative_temperature[q] = 0.0;
-          out.thermal_conductivities[q] = thermal_conductivity;
-
-          for (unsigned int c=0; c<in.composition[q].size(); ++c)
-            out.reaction_terms[q][c] = 0.0;
-
-          const double delta_temp = in.temperature[q]-this->get_adiabatic_conditions().temperature(in.position[q]);
-          const double viscosity_bound = 1.e8;
-          const double visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[q])),viscosity_bound),1./viscosity_bound);
-          out.viscosities[q] *= visc_temperature_dependence;
-        }
-
-      // fill melt outputs if they exist
-      if (melt_out != nullptr)
-        {
-          const unsigned int n_points = in.n_evaluation_points();
-          for (unsigned int q=0; q<n_points; ++q)
-            {
-              double porosity = std::max(in.composition[q][porosity_idx],0.0);
-
-              melt_out->fluid_viscosities[q] = eta_f;
-              melt_out->permeabilities[q] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-
-              // limit porosity to disaggregation threshold
-              porosity = std::min(0.3, porosity);
-
-              const double porosity_threshold = 0.01 * std::pow(this->get_melt_handler().melt_parameters.melt_scaling_factor_threshold, 1./3.);
-              melt_out->compaction_viscosities[q] = (1.0 - porosity) * xi_0 / std::max(porosity, porosity_threshold);
-
-              const double delta_temp = in.temperature[q]-this->get_adiabatic_conditions().temperature(in.position[q]);
-              const double compaction_viscosity_bound = 1.e4;
-              const double visc_temperature_dependence = std::max(std::min(std::exp(-thermal_bulk_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[q])),compaction_viscosity_bound),1./compaction_viscosity_bound);
-
-              melt_out->compaction_viscosities[q] *= visc_temperature_dependence;
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    MeltBoukare<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Melt boukare");
-        {
-          prm.declare_entry ("Reference shear viscosity", "5e20",
-                             Patterns::Double (0),
-                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
-                             "This viscosity may be modified by both temperature and porosity "
-                             "dependencies. Units: $Pa \\, s$.");
-          prm.declare_entry ("Reference bulk viscosity", "1e22",
-                             Patterns::Double (0),
-                             "The value of the constant bulk viscosity $\\xi_0$ of the solid matrix. "
-                             "This viscosity may be modified by both temperature and porosity "
-                             "dependencies. Units: $Pa \\, s$.");
-          prm.declare_entry ("Reference melt viscosity", "10",
-                             Patterns::Double (0),
-                             "The value of the constant melt viscosity $\\eta_f$. Units: $Pa \\, s$.");
-          prm.declare_entry ("Exponential melt weakening factor", "27",
-                             Patterns::Double (),
-                             "The porosity dependence of the viscosity. Units: dimensionless.");
-          prm.declare_entry ("Thermal viscosity exponent", "0.0",
-                             Patterns::Double (0),
-                             "The temperature dependence of the shear viscosity. Dimensionless exponent. "
-                             "See the general documentation "
-                             "of this model for a formula that states the dependence of the "
-                             "viscosity on this factor, which is called $\\beta$ there.");
-          prm.declare_entry ("Thermal bulk viscosity exponent", "0.0",
-                             Patterns::Double (0),
-                             "The temperature dependence of the bulk viscosity. Dimensionless exponent. "
-                             "See the general documentation "
-                             "of this model for a formula that states the dependence of the "
-                             "viscosity on this factor, which is called $\\beta$ there.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: $W/m/K$.");
-          prm.declare_entry ("Reference permeability", "1e-8",
-                             Patterns::Double(),
-                             "Reference permeability of the solid host rock."
-                             "Units: $m^2$.");
-          prm.declare_entry ("Include melting and freezing", "true",
-                             Patterns::Bool (),
-                             "Whether to include melting and freezing (according to a simplified "
-                             "linear melting approximation in the model (if true), or not (if "
-                             "false).");
-          prm.declare_entry ("Melting time scale for operator splitting", "1e3",
-                             Patterns::Double (0),
-                             "In case the operator splitting scheme is used, the porosity field can not "
-                             "be set to a new equilibrium melt fraction instantly, but the model has to "
-                             "provide a melting time scale instead. This time scale defines how fast melting "
-                             "happens, or more specifically, the parameter defines the time after which "
-                             "the deviation of the porosity from the equilibrium melt fraction will be "
-                             "reduced to a fraction of $1/e$. So if the melting time scale is small compared "
-                             "to the time step size, the reaction will be so fast that the porosity is very "
-                             "close to the equilibrium melt fraction after reactions are computed. Conversely, "
-                             "if the melting time scale is large compared to the time step size, almost no "
-                             "melting and freezing will occur."
-                             "\n\n"
-                             "Also note that the melting time scale has to be larger than or equal to the reaction "
-                             "time step used in the operator splitting scheme, otherwise reactions can not be "
-                             "computed. If the model does not use operator splitting, this parameter is not used. "
-                             "Units: yr or s, depending on the ``Use years "
-                             "in output instead of seconds'' parameter.");
-          prm.declare_entry ("Fe mantle melting temperature", "3424.5",
-                             Patterns::Double(),
-                             "The melting temperature of one of the components in the melting "
-                             "model, the Fe mantle endmember."
-                             "Units: K.");
-          prm.declare_entry ("Mg mantle melting temperature", "4821.2",
-                             Patterns::Double(),
-                             "The melting temperature of one of the components in the melting "
-                             "model, the Mg mantle endmember."
-                             "Units: K.");
-          prm.declare_entry ("Fe number of moles", "0.48",
-                             Patterns::Double(),
-                             "The number of moles of Fe atoms mixing on a pseudosite in the "
-                             "mantle lattice, This is needed because we use an empirical model "
-                             "fitting the full Boukare model, and can be changed to reflect "
-                             "partition coefficients from other sources."
-                             "Units: none.");
-          prm.declare_entry ("Mg number of moles", "0.62",
-                             Patterns::Double(),
-                             "The number of moles of Mg atoms mixing on a pseudosite in the "
-                             "mantle lattice, This is needed because we use an empirical model "
-                             "fitting the full Boukare model, and can be changed to reflect "
-                             "partition coefficients from other sources."
-                             "Units: none.");
-          prm.declare_entry ("Reference temperature", "298.15",
-                             Patterns::Double(),
-                             "Reference temperature used to compute the material properties"
-                             "of the different endmember components."
-                             "Units: K.");
-          prm.declare_entry ("Reference pressure", "1e11",
-                             Patterns::Double(),
-                             "Reference pressure used to compute the material properties"
-                             "of the different endmember components."
-                             "Units: Pa.");
-
-          prm.declare_entry ("Endmember names", "FeSiO3_bridgmanite, MgSiO3_bridgmanite, FeO_periclase, MgO_periclase, FeO_melt, MgO_melt, SiO2_melt",
-                             Patterns::List(Patterns::MultipleSelection("MgSiO3_bridgmanite|FeSiO3_bridgmanite|MgO_periclase|FeO_periclase|MgO_melt|FeO_melt|SiO2_melt")),
-                             "Names of the endmember components used in the equation of state and the melting model, "
-                             "and whose parameters are determined by the other input parameters of this material model. "
-                             "The order the parameters are given in has to be the same as the order the endmember names "
-                             "are given in. "
-                             "Units: none.");
-          prm.declare_entry ("Endmember states", "solid, solid, solid, solid, melt, melt, melt",
-                             Patterns::List(Patterns::MultipleSelection("solid|melt")),
-                             "States of the endmember components used in the equation of state and the melting model. "
-                             "For each endmember, this list has to define if they belong to the melt or to the solid. "
-                             "The order the states are given in has to be the same as the order the 'Endmember names' "
-                             "are given in. "
-                             "Units: none.");
-
-          prm.declare_entry ("Molar masses", "0.1319287, 0.1003887, 0.0718444, 0.0403044, 0.0707624708, 0.048592178, 0.048592178",
-                             Patterns::List(Patterns::Double(0)),
-                             "Molar masses of the different endmembers"
-                             "Units: kg/mol.");
-          prm.declare_entry ("Number of atoms", "5.0, 5.0, 2.0, 2.0, 2.092, 2.419, 2.419",
-                             Patterns::List(Patterns::Double(0)),
-                             "Number of atoms per in the formula of each endmember."
-                             "Units: none.");
-          prm.declare_entry ("Reference volumes", "2.534e-05, 2.445e-05, 1.206e-05, 1.125e-05, 1.2325484447664221e-05, 1.218e-05, 1.218e-05",
-                             Patterns::List(Patterns::Double(0)),
-                             "Reference volumes of the different endmembers."
-                             "Units: $m^3$.");
-          prm.declare_entry ("Reference thermal expansivities", "1.87e-05, 1.87e-05, 3.22e-05, 3.11e-05, 2.9614332469401705e-05, 2.06e-05, 2.06e-05",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of thermal expansivities for each different endmember at the reference temperature "
-                             "and reference pressure."
-                             "Units: 1/K.");
-          prm.declare_entry ("Reference bulk moduli", "2.81e11, 2.51e+11, 1.52e11, 1.616e11, 166652774642.11273, 2.317e11, 2.317e11",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of bulk moduli for each different endmember at the reference temperature "
-                             "and reference pressure."
-                             "Units: Pa.");
-          prm.declare_entry ("First derivatives of the bulk modulus", "4.14, 4.14, 4.9, 3.95, 5.0802472229003905, 4.25, 4.25",
-                             Patterns::List(Patterns::Double()),
-                             "The pressure derivative of the bulk modulus at the reference temperature and reference "
-                             "pressure for each different endmember component."
-                             "Units: none.");
-          prm.declare_entry ("Second derivatives of the bulk modulus", "-1.6e-11, -1.6e-11, -3.2e-11, -2.4e-11, -3.9742163085937504e-11, -2.14e-11, -2.14e-11",
-                             Patterns::List(Patterns::Double()),
-                             "The second pressure derivative of the bulk modulus at the reference temperature and reference "
-                             "pressure for each different endmember component."
-                             "Units: 1/Pa.");
-          prm.declare_entry ("Einstein temperatures", "418.1, 561.0, 297.6, 540.2, 505.75, 558.1, 558.1",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of Einstein temperatures for each different endmember."
-                             "Units: K.");
-          prm.declare_entry ("Reference enthalpies", "-1082910.0, -1442310.0, -262240.0, -601570.0, -195245.49100022088, -538009.8, -538009.8",
-                             Patterns::List(Patterns::Double()),
-                             "List of enthalpies at the reference temperature and reference "
-                             "pressure for each different endmember component."
-                             "Units: J/mol.");
-          prm.declare_entry ("Reference entropies", "95.0, 62.6, 58.6, 26.5, 95.0299295525918, 64.9, 64.9",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of entropies at the reference temperature and reference "
-                             "pressure for each different endmember component."
-                             "Units: J/K/mol.");
-          prm.declare_entry ("Reference specific heat capacities", "139.546209, 161.546581, 52.0016403, 73.1147154, 79.5326013, 79.5326013, 79.5326013",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of specific heat capacities for each different endmember at the reference temperature "
-                             "and reference pressure."
-                             "Units: J/kg/K.");
-          prm.declare_entry ("Linear coefficients for specific heat polynomial", "6.36191292e-03, -3.31714290e-03, 3.36163516e-03, -6.35318887e-03, -2.41909947e-03, -2.41909947e-03, -2.41909947e-03",
-                             Patterns::List(Patterns::Double()),
-                             "The first of three coefficients that are used to compute the specific heat capacities for each "
-                             "different endmember at the reference temperature and reference pressure. "
-                             "This coefficient describes the linear part of the temperature dependence. "
-                             "Units: J/kg/K/K.");
-          prm.declare_entry ("Second coefficients for specific heat polynomial", "-4.13886524e+06, -3.57533814e+06, -1.19540964e+06, -7.33679285e+05, -1.61692272e+06, -1.61692272e+06, -1.61692272e+06",
-                             Patterns::List(Patterns::Double()),
-                             "The second of three coefficients that are used to compute the specific heat capacities for each "
-                             "different endmember at the reference temperature and reference pressure. This coefficient describes "
-                             "the part of the temperature dependence that scales as the inverse of the square of the temperature. "
-                             "Units: J K/kg.");
-          prm.declare_entry ("Third coefficients for specific heat polynomial", "-464.775577, -1112.54791, 25.5067110, -592.994207, -562.222634, -562.222634, -562.222634",
-                             Patterns::List(Patterns::Double()),
-                             "The third of three coefficients that are used to compute the specific heat capacities for each "
-                             "different endmember at the reference temperature and reference pressure. This coefficient describes "
-                             "the part of the temperature dependence that scales as the inverse of the square root of the temperature"
-                             "Units: J/kg/sqrt(K).");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    MeltBoukare<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Melt boukare");
-        {
-          eta_0                             = prm.get_double ("Reference shear viscosity");
-          xi_0                              = prm.get_double ("Reference bulk viscosity");
-          eta_f                             = prm.get_double ("Reference melt viscosity");
-          reference_permeability            = prm.get_double ("Reference permeability");
-          thermal_viscosity_exponent        = prm.get_double ("Thermal viscosity exponent");
-          thermal_bulk_viscosity_exponent   = prm.get_double ("Thermal bulk viscosity exponent");
-          thermal_conductivity              = prm.get_double ("Thermal conductivity");
-          alpha_phi                         = prm.get_double ("Exponential melt weakening factor");
-          include_melting_and_freezing      = prm.get_bool ("Include melting and freezing");
-          melting_time_scale                = prm.get_double ("Melting time scale for operator splitting");
-          Fe_mantle_melting_temperature     = prm.get_double ("Fe mantle melting temperature");
-          Mg_mantle_melting_temperature     = prm.get_double ("Mg mantle melting temperature");
-          Fe_number_of_moles                = prm.get_double ("Fe number of moles");
-          Mg_number_of_moles                = prm.get_double ("Mg number of moles");
-
-          reference_temperature             = prm.get_double ("Reference temperature");
-          reference_pressure                = prm.get_double ("Reference pressure");
-
-          if (this->convert_output_to_years() == true)
-            melting_time_scale *= year_in_seconds;
-
-          AssertThrow(this->get_parameters().use_operator_splitting &&
-                      this->get_parameters().reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step,
-                      ExcMessage("The melt boukare material model has to be used with operator splitting, "
-                                 "and the reaction solver needs to be `fixed step'."));
-
-          AssertThrow(melting_time_scale >= this->get_parameters().reaction_time_step,
-                      ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
-                                 + " in the operator splitting scheme is too large to compute melting rates! "
-                                 "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
-                                 "operator splitting' chosen in the material model, which is currently "
-                                 + Utilities::to_string(melting_time_scale) + "."));
-          AssertThrow(melting_time_scale > 0.0,
-                      ExcMessage("The Melting time scale for operator splitting must be larger than 0!"));
-
-          // Equation of state parameters
-          endmember_names = Utilities::split_string_list(prm.get("Endmember names"));
-          AssertThrow(Utilities::has_unique_entries(endmember_names),
-                      ExcMessage("The list of strings for the parameter "
-                                 "'Material model/Melt boukare/Endmember names' contains entries more than once. "
-                                 "This is not allowed. Please check your parameter file."));
-
-          const unsigned int n_endmembers = endmember_names.size();
-          AssertThrow(n_endmembers == 7 || (!this->include_melt_transport() && n_endmembers == 4),
-                      ExcMessage("The list of strings for the parameter "
-                                 "'Material model/Melt boukare/Endmember names' does not contain the correct "
-                                 "number of entries. Please check your parameter file."));
-
-          std::vector<std::string> endmember_states_string = Utilities::split_string_list(prm.get("Endmember states"));
-          endmember_states.resize(endmember_states_string.size());
-
-          for (unsigned int i=0; i<endmember_states_string.size(); ++i)
-            {
-              if (endmember_states_string[i] == "solid")
-                endmember_states[i] = EndmemberState::solid;
-              else if (endmember_states_string[i] == "melt")
-                endmember_states[i] = EndmemberState::melt;
-              else
-                AssertThrow (false, ExcNotImplemented());
-            }
-
-          molar_masses = Utilities::parse_map_to_double_array (prm.get("Molar masses"),
-                                                               endmember_names,
-                                                               false,
-                                                               "Molar masses");
-
-          number_of_atoms = Utilities::parse_map_to_double_array (prm.get("Number of atoms"),
-                                                                  endmember_names,
-                                                                  false,
-                                                                  "Number of atoms");
-
-          reference_volumes = Utilities::parse_map_to_double_array (prm.get("Reference volumes"),
-                                                                    endmember_names,
-                                                                    false,
-                                                                    "Reference volumes");
-
-          reference_thermal_expansivities = Utilities::parse_map_to_double_array (prm.get("Reference thermal expansivities"),
-                                                                                  endmember_names,
-                                                                                  false,
-                                                                                  "Reference thermal expansivities");
-
-          reference_bulk_moduli = Utilities::parse_map_to_double_array (prm.get("Reference bulk moduli"),
-                                                                        endmember_names,
-                                                                        false,
-                                                                        "Reference bulk moduli");
-
-          bulk_modulus_pressure_derivatives = Utilities::parse_map_to_double_array (prm.get("First derivatives of the bulk modulus"),
-                                                                                    endmember_names,
-                                                                                    false,
-                                                                                    "First derivatives of the bulk modulus");
-
-          bulk_modulus_second_pressure_derivatives = Utilities::parse_map_to_double_array (prm.get("Second derivatives of the bulk modulus"),
-                                                     endmember_names,
-                                                     false,
-                                                     "Second derivatives of the bulk modulus");
-
-          Einstein_temperatures = Utilities::parse_map_to_double_array (prm.get("Einstein temperatures"),
-                                                                        endmember_names,
-                                                                        false,
-                                                                        "Einstein temperatures");
-
-          reference_enthalpies = Utilities::parse_map_to_double_array (prm.get("Reference enthalpies"),
-                                                                       endmember_names,
-                                                                       false,
-                                                                       "Reference enthalpies");
-
-          reference_entropies = Utilities::parse_map_to_double_array (prm.get("Reference entropies"),
-                                                                      endmember_names,
-                                                                      false,
-                                                                      "Reference entropies");
-
-          reference_specific_heats = Utilities::parse_map_to_double_array (prm.get("Reference specific heat capacities"),
-                                                                           endmember_names,
-                                                                           false,
-                                                                           "Reference specific heat capacities");
-
-          specific_heat_linear_coefficients = Utilities::parse_map_to_double_array (prm.get("Linear coefficients for specific heat polynomial"),
-                                                                                    endmember_names,
-                                                                                    false,
-                                                                                    "Linear coefficients for specific heat polynomial");
-
-          specific_heat_second_coefficients = Utilities::parse_map_to_double_array (prm.get("Second coefficients for specific heat polynomial"),
-                                                                                    endmember_names,
-                                                                                    false,
-                                                                                    "Second coefficients for specific heat polynomial");
-
-          specific_heat_third_coefficients = Utilities::parse_map_to_double_array (prm.get("Third coefficients for specific heat polynomial"),
-                                                                                   endmember_names,
-                                                                                   false,
-                                                                                   "Third coefficients for specific heat polynomial");
-
-          // Check all lists have the correct length.
-          AssertThrow(endmember_names.size() == endmember_states.size(),
-                      ExcMessage("One of the lists that define the endmember parameters does not have the "
-                                 "correct size.  Please check your parameter file."));
-
-
-          // All of these are molar fractions
-          // Check that all compositional fields we need exist
-          AssertThrow(this->introspection().compositional_name_exists("molar_Fe_in_solid"),
-                      ExcMessage("Material model melt boukare only works if there is a "
-                                 "compositional field called 'molar_Fe_in_solid'."));
-
-          if (this->include_melt_transport())
-            {
-              AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                          ExcMessage("Material model melt boukare only works if there is a "
-                                     "compositional field called porosity."));
-              AssertThrow(this->introspection().compositional_name_exists("molar_Fe_in_melt"),
-                          ExcMessage("Material model melt boukare only works if there is a "
-                                     "compositional field called 'molar_Fe_in_melt'."));
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    MeltBoukare<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (this->get_parameters().use_operator_splitting
-          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
-        {
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (out.n_evaluation_points(), this->n_compositional_fields()));
-        }
-
-      if (out.template get_additional_output<BoukareOutputs<dim>>() == nullptr)
-        {
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::BoukareOutputs<dim>> (out.n_evaluation_points()));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(MeltBoukare,
-                                   "melt boukare",
-                                   "A material model that implements a simplified version of the melting "
-                                   "model of Boukare et al. (https://doi.org/10.1002/2015JB011929) for the "
-                                   "lowermost mantle and uses it to compute the material parameters "
-                                   "required for the modeling of melt transport, including melting and "
-                                   "solidification and the corresponding changes in composition."
-                                   "The model parameterizes the composition (which includes the components "
-                                   "MgO, FeO and SiO2) as a mixture between two endmembers (one iron-bearing "
-                                   "and one magnesium-bearing). The equation of state considers three phases: "
-                                   "bridgmanite, ferropericlase, and melt (each with their individual "
-                                   "compositions). "
-                                   "More details can be found in Dannberg, J., Myhill, R., Gassmöller, R., "
-                                   "and Cottaar, S. (2021). The morphology, evolution and seismic visibility "
-                                   "of partial melt at the core–mantle boundary: implications for ULVZs. "
-                                   "Geophysical Journal International, 227(2), 1028-1059.")
-  }
-}
diff --git a/source/material_model/melt_global.cc.bak b/source/material_model/melt_global.cc.bak
deleted file mode 100644
index b0c48491595..00000000000
--- a/source/material_model/melt_global.cc.bak
+++ /dev/null
@@ -1,556 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/melt_global.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/numerics/fe_field_function.h>
-
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    double
-    MeltGlobal<dim>::
-    reference_darcy_coefficient () const
-    {
-      // 0.01 = 1% melt
-      return reference_permeability * std::pow(0.01,3.0) / eta_f;
-    }
-
-    template <int dim>
-    bool
-    MeltGlobal<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    double
-    MeltGlobal<dim>::
-    melt_fraction (const double temperature,
-                   const double pressure,
-                   const double depletion) const
-    {
-      const double T_solidus  = surface_solidus
-                                + pressure_solidus_change * pressure
-                                + std::max(depletion_solidus_change * depletion, -200.0);
-      const double T_liquidus = T_solidus + 500.0;
-
-      double melt_fraction;
-      if (temperature < T_solidus)
-        melt_fraction = 0.0;
-      else if (temperature > T_liquidus)
-        melt_fraction = 1.0;
-      else
-        melt_fraction = (temperature - T_solidus) / (T_liquidus - T_solidus);
-
-      return melt_fraction;
-    }
-
-
-    template <int dim>
-    void
-    MeltGlobal<dim>::
-    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                    std::vector<double> &melt_fractions) const
-    {
-      double depletion = 0.0;
-
-      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
-        {
-          if (this->include_melt_transport())
-            {
-              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-              const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
-              depletion = in.composition[q][peridotite_idx] - in.composition[q][porosity_idx];
-            }
-          melt_fractions[q] = this->melt_fraction(in.temperature[q],
-                                                  std::max(0.0, in.pressure[q]),
-                                                  depletion);
-        }
-    }
-
-
-    template <int dim>
-    void
-    MeltGlobal<dim>::
-    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      std::vector<double> old_porosity(in.n_evaluation_points());
-
-      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
-
-      // we want to get the porosity field from the old solution here,
-      // because we need a field that is not updated in the nonlinear iterations
-      if (this->include_melt_transport() && in.current_cell.state() == IteratorState::valid
-          && this->get_timestep_number() > 0 && !this->get_parameters().use_operator_splitting)
-        {
-          // Prepare the field function
-
-          Functions::FEFieldFunction<dim, LinearAlgebra::BlockVector>
-
-          fe_value(this->get_dof_handler(), this->get_old_solution(), this->get_mapping());
-
-          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-          fe_value.set_active_cell(in.current_cell);
-          fe_value.value_list(in.position,
-                              old_porosity,
-                              this->introspection().component_indices.compositional_fields[porosity_idx]);
-        }
-      else if (this->get_parameters().use_operator_splitting)
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-            old_porosity[i] = in.composition[i][porosity_idx];
-          }
-
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          // calculate density first, we need it for the reaction term
-          // temperature dependence of density is 1 - alpha * (T - T(adiabatic))
-          double temperature_dependence = 1.0;
-          if (this->include_adiabatic_heating ())
-            temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]))
-                                      * thermal_expansivity;
-          else
-            temperature_dependence -= (in.temperature[i] - reference_T) * thermal_expansivity;
-
-          // calculate composition dependence of density
-          const double delta_rho = this->introspection().compositional_name_exists("peridotite")
-                                   ?
-                                   depletion_density_change * in.composition[i][this->introspection().compositional_index_for_name("peridotite")]
-                                   :
-                                   0.0;
-          out.densities[i] = (reference_rho_s + delta_rho) * temperature_dependence
-                             * std::exp(compressibility * (in.pressure[i] - this->get_surface_pressure()));
-
-          out.viscosities[i] = eta_0;
-          // By default, no melting or freezing --> set all reactions to zero
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            {
-              out.reaction_terms[i][c] = 0.0;
-
-              if (this->get_parameters().use_operator_splitting && reaction_rate_out != nullptr)
-                reaction_rate_out->reaction_rates[i][c] = 0.0;
-            }
-
-          if (this->include_melt_transport())
-            {
-              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-              const double porosity = std::min(1.0, std::max(in.composition[i][porosity_idx],0.0));
-
-              // calculate viscosity based on local melt
-              out.viscosities[i] *= exp(- alpha_phi * porosity);
-
-              if (include_melting_and_freezing && (in.requests_property(MaterialProperties::reaction_terms) ||
-                                                   in.requests_property(MaterialProperties::reaction_rates) ||
-                                                   in.requests_property(MaterialProperties::viscosity)))
-                {
-                  Assert(this->get_timestep_number()<=1 || std::isfinite(in.strain_rate[i].norm()),
-                         ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                                    "not filled by the caller."));
-                  const double trace_strain_rate =
-                    (this->get_timestep_number() > 1) ?
-                    (trace(in.strain_rate[i]))
-                    :
-                    numbers::signaling_nan<double>();
-
-                  const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
-
-                  // Calculate the melting rate as difference between the equilibrium melt fraction
-                  // and the solution of the previous time step (or the current solution, in case
-                  // operator splitting is used).
-                  // The solidus is lowered by previous melting events (fractional melting).
-                  const double eq_melt_fraction = melt_fraction(in.temperature[i],
-                                                                this->get_adiabatic_conditions().pressure(in.position[i]),
-                                                                in.composition[i][peridotite_idx] - in.composition[i][porosity_idx]);
-                  double porosity_change = eq_melt_fraction - old_porosity[i];
-                  // do not allow negative porosity
-                  if (old_porosity[i] + porosity_change < 0)
-                    porosity_change = -old_porosity[i];
-
-                  for (unsigned int c = 0; c < in.composition[i].size(); ++c)
-                    {
-                      if (c == peridotite_idx && this->get_timestep_number() > 1)
-                        out.reaction_terms[i][c] = porosity_change - in.composition[i][peridotite_idx] * trace_strain_rate * this->get_timestep();
-                      else if (c == porosity_idx && this->get_timestep_number() > 1)
-                        out.reaction_terms[i][c] = porosity_change * out.densities[i] / this->get_timestep();
-                      else
-                        out.reaction_terms[i][c] = 0.0;
-
-                      // fill reaction rate outputs if the model uses operator splitting
-                      if (this->get_parameters().use_operator_splitting)
-                        {
-                          if (reaction_rate_out != nullptr)
-                            {
-                              if (c == peridotite_idx && this->get_timestep_number() > 0)
-                                reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale - in.composition[i][peridotite_idx] * trace(in.strain_rate[i]);
-                              else if (c == porosity_idx && this->get_timestep_number() > 0)
-                                reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale;
-                              else
-                                reaction_rate_out->reaction_rates[i][c] = 0.0;
-                            }
-                          out.reaction_terms[i][c] = 0.0;
-                        }
-                    }
-
-                  // find depletion = peridotite, which might affect shear viscosity:
-                  const double depletion_visc = std::min(1.0, std::max(in.composition[i][peridotite_idx], 0.0));
-
-                  // calculate strengthening due to depletion:
-                  const double depletion_strengthening = std::min(exp(alpha_depletion * depletion_visc), delta_eta_depletion_max);
-
-                  // calculate viscosity change due to local melt and depletion:
-                  out.viscosities[i] *= depletion_strengthening;
-                }
-            }
-
-          out.entropy_derivative_pressure[i]    = 0.0;
-          out.entropy_derivative_temperature[i] = 0.0;
-          out.thermal_expansion_coefficients[i] = thermal_expansivity;
-          out.specific_heat[i] = reference_specific_heat;
-          out.thermal_conductivities[i] = thermal_conductivity;
-          out.compressibilities[i] = 0.0;
-
-          double visc_temperature_dependence = 1.0;
-          if (this->include_adiabatic_heating ())
-            {
-              const double delta_temp = in.temperature[i]-this->get_adiabatic_conditions().temperature(in.position[i]);
-              visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[i])),1e4),1e-4);
-            }
-          else if (thermal_viscosity_exponent != 0.0)
-            {
-              const double delta_temp = in.temperature[i]-reference_T;
-              visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/reference_T),1e4),1e-4);
-            }
-          out.viscosities[i] *= visc_temperature_dependence;
-        }
-
-      // fill melt outputs if they exist
-      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
-
-      if (melt_out != nullptr)
-        {
-          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-            {
-              double porosity = std::max(in.composition[i][porosity_idx],0.0);
-
-              melt_out->fluid_viscosities[i] = eta_f;
-              melt_out->permeabilities[i] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-              melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-
-              // temperature dependence of density is 1 - alpha * (T - T(adiabatic))
-              double temperature_dependence = 1.0;
-              if (this->include_adiabatic_heating ())
-                temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]))
-                                          * thermal_expansivity;
-              else
-                temperature_dependence -= (in.temperature[i] - reference_T) * thermal_expansivity;
-              melt_out->fluid_densities[i] = reference_rho_f * temperature_dependence
-                                             * std::exp(melt_compressibility * (in.pressure[i] - this->get_surface_pressure()));
-
-              melt_out->compaction_viscosities[i] = xi_0 * exp(- alpha_phi * porosity);
-
-              double visc_temperature_dependence = 1.0;
-              if (this->include_adiabatic_heating ())
-                {
-                  const double delta_temp = in.temperature[i]-this->get_adiabatic_conditions().temperature(in.position[i]);
-                  visc_temperature_dependence = std::max(std::min(std::exp(-thermal_bulk_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[i])),1e4),1e-4);
-                }
-              else if (thermal_viscosity_exponent != 0.0)
-                {
-                  const double delta_temp = in.temperature[i]-reference_T;
-                  visc_temperature_dependence = std::max(std::min(std::exp(-thermal_bulk_viscosity_exponent*delta_temp/reference_T),1e4),1e-4);
-                }
-              melt_out->compaction_viscosities[i] *= visc_temperature_dependence;
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    MeltGlobal<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Melt global");
-        {
-          prm.declare_entry ("Reference solid density", "3000.",
-                             Patterns::Double (0.),
-                             "Reference density of the solid $\\rho_{s,0}$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference melt density", "2500.",
-                             Patterns::Double (0.),
-                             "Reference density of the melt/fluid$\\rho_{f,0}$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. The reference temperature is used "
-                             "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Reference shear viscosity", "5e20",
-                             Patterns::Double (0.),
-                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
-                             "This viscosity may be modified by both temperature and porosity "
-                             "dependencies. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Reference bulk viscosity", "1e22",
-                             Patterns::Double (0.),
-                             "The value of the constant bulk viscosity $\\xi_0$ of the solid matrix. "
-                             "This viscosity may be modified by both temperature and porosity "
-                             "dependencies. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Reference melt viscosity", "10.",
-                             Patterns::Double (0.),
-                             "The value of the constant melt viscosity $\\eta_f$. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Exponential melt weakening factor", "27.",
-                             Patterns::Double (0.),
-                             "The porosity dependence of the viscosity. Units: dimensionless.");
-          prm.declare_entry ("Thermal viscosity exponent", "0.0",
-                             Patterns::Double (0.),
-                             "The temperature dependence of the shear viscosity. Dimensionless exponent. "
-                             "See the general documentation "
-                             "of this model for a formula that states the dependence of the "
-                             "viscosity on this factor, which is called $\\beta$ there.");
-          prm.declare_entry ("Thermal bulk viscosity exponent", "0.0",
-                             Patterns::Double (0.),
-                             "The temperature dependence of the bulk viscosity. Dimensionless exponent. "
-                             "See the general documentation "
-                             "of this model for a formula that states the dependence of the "
-                             "viscosity on this factor, which is called $\\beta$ there.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250.",
-                             Patterns::Double (0.),
-                             "The value of the specific heat $C_p$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\beta$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Reference permeability", "1e-8",
-                             Patterns::Double(),
-                             "Reference permeability of the solid host rock."
-                             "Units: \\si{\\meter\\squared}.");
-          prm.declare_entry ("Depletion density change", "0.0",
-                             Patterns::Double (),
-                             "The density contrast between material with a depletion of 1 and a "
-                             "depletion of zero. Negative values indicate lower densities of "
-                             "depleted material. Depletion is indicated by the compositional "
-                             "field with the name peridotite. Not used if this field does not "
-                             "exist in the model. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Surface solidus", "1300.",
-                             Patterns::Double (0.),
-                             "Solidus for a pressure of zero. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Depletion solidus change", "200.0",
-                             Patterns::Double (),
-                             "The solidus temperature change for a depletion of 100\\%. For positive "
-                             "values, the solidus gets increased for a positive peridotite field "
-                             "(depletion) and lowered for a negative peridotite field (enrichment). "
-                             "Scaling with depletion is linear. Only active when fractional melting "
-                             "is used. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Pressure solidus change", "6e-8",
-                             Patterns::Double (),
-                             "The linear solidus temperature change with pressure. For positive "
-                             "values, the solidus gets increased for positive pressures. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("Solid compressibility", "0.0",
-                             Patterns::Double (0.),
-                             "The value of the compressibility of the solid matrix. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("Melt compressibility", "0.0",
-                             Patterns::Double (0.),
-                             "The value of the compressibility of the melt. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("Melt bulk modulus derivative", "0.0",
-                             Patterns::Double (0.),
-                             "The value of the pressure derivative of the melt bulk "
-                             "modulus. "
-                             "Units: None.");
-          prm.declare_entry ("Include melting and freezing", "true",
-                             Patterns::Bool (),
-                             "Whether to include melting and freezing (according to a simplified "
-                             "linear melting approximation in the model (if true), or not (if "
-                             "false).");
-          prm.declare_entry ("Melting time scale for operator splitting", "1e3",
-                             Patterns::Double (0.),
-                             "In case the operator splitting scheme is used, the porosity field can not "
-                             "be set to a new equilibrium melt fraction instantly, but the model has to "
-                             "provide a melting time scale instead. This time scale defines how fast melting "
-                             "happens, or more specifically, the parameter defines the time after which "
-                             "the deviation of the porosity from the equilibrium melt fraction will be "
-                             "reduced to a fraction of $1/e$. So if the melting time scale is small compared "
-                             "to the time step size, the reaction will be so fast that the porosity is very "
-                             "close to the equilibrium melt fraction after reactions are computed. Conversely, "
-                             "if the melting time scale is large compared to the time step size, almost no "
-                             "melting and freezing will occur."
-                             "\n\n"
-                             "Also note that the melting time scale has to be larger than or equal to the reaction "
-                             "time step used in the operator splitting scheme, otherwise reactions can not be "
-                             "computed. If the model does not use operator splitting, this parameter is not used. "
-                             "Units: yr or s, depending on the ``Use years "
-                             "in output instead of seconds'' parameter.");
-          prm.declare_entry ("Exponential depletion strengthening factor", "0.0",
-                             Patterns::Double (0.),
-                             "$\\alpha_F$: exponential dependency of viscosity on the depletion "
-                             "field $F$ (called peridotite). "
-                             "Dimensionless factor. With a value of 0.0 (the default) the "
-                             "viscosity does not depend on the depletion. The effective viscosity increase"
-                             "due to depletion is defined as $exp( \\alpha_F * F)$. "
-                             "Rationale: melting dehydrates the source rock by removing most of the volatiles,"
-                             "and makes it stronger. Hirth and Kohlstedt (1996) report typical values around a "
-                             "factor 100 to 1000 viscosity contrast between wet and dry rocks, although some "
-                             "experimental studies report a smaller (factor 10) contrast (e.g. Fei et al., 2013).");
-          prm.declare_entry ("Maximum Depletion viscosity change", "1.0e3",
-                             Patterns::Double (0.),
-                             "$\\Delta \\eta_{F,max}$: maximum depletion strengthening of viscosity. "
-                             "Rationale: melting dehydrates the source rock by removing most of the volatiles,"
-                             "and makes it stronger. Hirth and Kohlstedt (1996) report typical values around a "
-                             "factor 100 to 1000 viscosity contrast between wet and dry rocks, although some "
-                             "experimental studies report a smaller (factor 10) contrast (e.g. Fei et al., 2013).");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    MeltGlobal<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Melt global");
-        {
-          reference_rho_s                   = prm.get_double ("Reference solid density");
-          reference_rho_f                   = prm.get_double ("Reference melt density");
-          reference_T                       = prm.get_double ("Reference temperature");
-          eta_0                             = prm.get_double ("Reference shear viscosity");
-          xi_0                              = prm.get_double ("Reference bulk viscosity");
-          eta_f                             = prm.get_double ("Reference melt viscosity");
-          reference_permeability            = prm.get_double ("Reference permeability");
-          thermal_viscosity_exponent        = prm.get_double ("Thermal viscosity exponent");
-          thermal_bulk_viscosity_exponent   = prm.get_double ("Thermal bulk viscosity exponent");
-          thermal_conductivity              = prm.get_double ("Thermal conductivity");
-          reference_specific_heat           = prm.get_double ("Reference specific heat");
-          thermal_expansivity               = prm.get_double ("Thermal expansion coefficient");
-          alpha_phi                         = prm.get_double ("Exponential melt weakening factor");
-          depletion_density_change          = prm.get_double ("Depletion density change");
-          surface_solidus                   = prm.get_double ("Surface solidus");
-          depletion_solidus_change          = prm.get_double ("Depletion solidus change");
-          pressure_solidus_change           = prm.get_double ("Pressure solidus change");
-          compressibility                   = prm.get_double ("Solid compressibility");
-          melt_compressibility              = prm.get_double ("Melt compressibility");
-          include_melting_and_freezing      = prm.get_bool ("Include melting and freezing");
-          melting_time_scale                = prm.get_double ("Melting time scale for operator splitting");
-          alpha_depletion                   = prm.get_double ("Exponential depletion strengthening factor");
-          delta_eta_depletion_max           = prm.get_double ("Maximum Depletion viscosity change");
-
-          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
-            AssertThrow(false, ExcMessage("Error: Material model Melt global with Thermal viscosity exponent can not have reference_T=0."));
-
-          if (this->convert_output_to_years() == true)
-            melting_time_scale *= year_in_seconds;
-
-          if (this->get_parameters().use_operator_splitting)
-            {
-              if (this->get_parameters().reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
-                AssertThrow(melting_time_scale >= this->get_parameters().reaction_time_step,
-                            ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
-                                       + " in the operator splitting scheme is too large to compute melting rates! "
-                                       "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
-                                       "operator splitting' chosen in the material model, which is currently "
-                                       + Utilities::to_string(melting_time_scale) + "."));
-              AssertThrow(melting_time_scale > 0,
-                          ExcMessage("The Melting time scale for operator splitting must be larger than 0!"));
-              AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                          ExcMessage("Material model Melt global with melt transport only "
-                                     "works if there is a compositional field called porosity."));
-            }
-
-          if (this->include_melt_transport())
-            {
-              AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                          ExcMessage("Material model Melt global with melt transport only "
-                                     "works if there is a compositional field called porosity."));
-              if (include_melting_and_freezing)
-                {
-                  AssertThrow(this->introspection().compositional_name_exists("peridotite"),
-                              ExcMessage("Material model Melt global only works if there is a "
-                                         "compositional field called peridotite."));
-                }
-            }
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    MeltGlobal<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (this->get_parameters().use_operator_splitting
-          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(MeltGlobal,
-                                   "melt global",
-                                   "A material model that implements a simple formulation of the "
-                                   "material parameters required for the modeling of melt transport, "
-                                   "including a source term for the porosity according to a simplified "
-                                   "linear melting model similar to \\cite{schmeling2006}:\n"
-                                   "$\\phi_{\\text{equilibrium}} = \\frac{T-T_{\\text{sol}}}{T_{\\text{liq}}-T_{\\text{sol}}}$\n"
-                                   "with "
-                                   "$T_{\\text{sol}} = T_{\\text{sol,0}} + \\Delta T_p \\, p + \\Delta T_c \\, C$ \n"
-                                   "$T_{\\text{liq}} = T_{\\text{sol}}  + \\Delta T_{\\text{sol-liq}}$.")
-  }
-}
diff --git a/source/material_model/melt_simple.cc.bak b/source/material_model/melt_simple.cc.bak
deleted file mode 100644
index 1debe1eb863..00000000000
--- a/source/material_model/melt_simple.cc.bak
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/material_model/melt_simple.h>
-#include <aspect/material_model/reaction_model/katz2003_mantle_melting.h>
-#include <aspect/utilities.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/numerics/fe_field_function.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    double
-    MeltSimple<dim>::
-    reference_darcy_coefficient () const
-    {
-      // 0.01 = 1% melt
-      return katz2003_model.reference_darcy_coefficient();
-    }
-
-    template <int dim>
-    bool
-    MeltSimple<dim>::
-    is_compressible () const
-    {
-      return model_is_compressible;
-    }
-
-    template <int dim>
-    void
-    MeltSimple<dim>::
-    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                    std::vector<double> &melt_fractions) const
-    {
-      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
-        melt_fractions[q] = katz2003_model.melt_fraction(in.temperature[q],
-                                                         this->get_adiabatic_conditions().pressure(in.position[q]));
-    }
-
-
-    template <int dim>
-    void
-    MeltSimple<dim>::initialize ()
-    {
-      if (this->include_melt_transport())
-        {
-          AssertThrow(this->get_parameters().use_operator_splitting,
-                      ExcMessage("The material model ``Melt simple'' can only be used with operator splitting!"));
-          AssertThrow(this->introspection().compositional_name_exists("peridotite"),
-                      ExcMessage("Material model Melt simple only works if there is a "
-                                 "compositional field called peridotite."));
-          AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                      ExcMessage("Material model Melt simple with melt transport only "
-                                 "works if there is a compositional field called porosity."));
-        }
-    }
-
-
-    template <int dim>
-    void
-    MeltSimple<dim>::
-    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          // calculate density first, we need it for the reaction term
-          // first, calculate temperature dependence of density
-          double temperature_dependence = 1.0;
-          if (this->include_adiabatic_heating ())
-            {
-              // temperature dependence is 1 - alpha * (T - T(adiabatic))
-              temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]))
-                                        * thermal_expansivity;
-            }
-          else
-            temperature_dependence -= (in.temperature[i] - reference_T) * thermal_expansivity;
-
-          // calculate composition dependence of density
-          const double delta_rho = this->introspection().compositional_name_exists("peridotite")
-                                   ?
-                                   depletion_density_change * in.composition[i][this->introspection().compositional_index_for_name("peridotite")]
-                                   :
-                                   0.0;
-          out.densities[i] = (reference_rho_solid + delta_rho)
-                             * temperature_dependence * std::exp(compressibility * (in.pressure[i] - this->get_surface_pressure()));
-
-          out.viscosities[i] = eta_0;
-          out.thermal_expansion_coefficients[i] = thermal_expansivity;
-          out.specific_heat[i] = reference_specific_heat;
-          out.thermal_conductivities[i] = thermal_conductivity;
-          out.compressibilities[i] = compressibility;
-
-          double visc_temperature_dependence = 1.0;
-          if (this->include_adiabatic_heating ())
-            {
-              const double delta_temp = in.temperature[i]-this->get_adiabatic_conditions().temperature(in.position[i]);
-              visc_temperature_dependence = std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[i])),1e4),1e-4);
-            }
-          else
-            {
-              const double delta_temp = in.temperature[i]-reference_T;
-              const double T_dependence = (thermal_viscosity_exponent == 0.0
-                                           ?
-                                           0.0
-                                           :
-                                           thermal_viscosity_exponent*delta_temp/reference_T);
-              visc_temperature_dependence = std::max(std::min(std::exp(-T_dependence),1e4),1e-4);
-            }
-          out.viscosities[i] *= visc_temperature_dependence;
-
-        }
-
-      katz2003_model.calculate_reaction_rate_outputs(in, out);
-      katz2003_model.calculate_fluid_outputs(in, out, reference_T);
-    }
-
-
-    template <int dim>
-    void
-    MeltSimple<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Melt simple");
-        {
-          // Melt Fraction Parameters
-          ReactionModel::Katz2003MantleMelting<dim>::declare_parameters(prm);
-
-
-          prm.declare_entry ("Use full compressibility", "false",
-                             Patterns::Bool (),
-                             "If the compressibility should be used everywhere in the code "
-                             "(if true), changing the volume of material when the density changes, "
-                             "or only in the momentum conservation and advection equations "
-                             "(if false).");
-          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\beta$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Reference shear viscosity", "5e20",
-                             Patterns::Double (0.),
-                             "The value of the constant viscosity $\\eta_0$ of the solid matrix. "
-                             "This viscosity may be modified by both temperature and porosity "
-                             "dependencies. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Reference specific heat", "1250.",
-                             Patterns::Double (0.),
-                             "The value of the specific heat $C_p$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Solid compressibility", "0.0",
-                             Patterns::Double (0.),
-                             "The value of the compressibility of the solid matrix. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("Thermal viscosity exponent", "0.0",
-                             Patterns::Double (0.),
-                             "The temperature dependence of the shear viscosity. Dimensionless exponent. "
-                             "See the general documentation "
-                             "of this model for a formula that states the dependence of the "
-                             "viscosity on this factor, which is called $\\beta$ there.");
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. The reference temperature is used "
-                             "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Depletion density change", "0.0",
-                             Patterns::Double (),
-                             "The density contrast between material with a depletion of 1 and a "
-                             "depletion of zero. Negative values indicate lower densities of "
-                             "depleted material. Depletion is indicated by the compositional "
-                             "field with the name peridotite. Not used if this field does not "
-                             "exist in the model. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference solid density", "3000.",
-                             Patterns::Double (0.),
-                             "Reference density of the solid $\\rho_{s,0}$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    MeltSimple<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Melt simple");
-        {
-          model_is_compressible      = prm.get_bool ("Use full compressibility");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          eta_0                      = prm.get_double ("Reference shear viscosity");
-          thermal_expansivity        = prm.get_double ("Thermal expansion coefficient");
-          thermal_conductivity       = prm.get_double ("Thermal conductivity");
-          compressibility            = prm.get_double ("Solid compressibility");
-          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
-          reference_T                = prm.get_double ("Reference temperature");
-          depletion_density_change   = prm.get_double ("Depletion density change");
-          reference_rho_solid        = prm.get_double ("Reference solid density");
-
-
-
-          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
-            AssertThrow(false, ExcMessage("Error: Material model Melt simple with Thermal viscosity exponent can not have reference_T=0."));
-
-          // Melt model
-          katz2003_model.initialize_simulator (this->get_simulator());
-          katz2003_model.parse_parameters(prm);
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    MeltSimple<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (this->get_parameters().use_operator_splitting && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (n_points, this->n_compositional_fields()));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(MeltSimple,
-                                   "melt simple",
-                                   "A material model that implements a simple formulation of the "
-                                   "material parameters required for the modeling of melt transport, "
-                                   "including a source term for the porosity according to the melting "
-                                   "model for dry peridotite of \\cite{katz:etal:2003}. This also includes a "
-                                   "computation of the latent heat of melting (if the `latent heat' "
-                                   "heating model is active)."
-                                   "\n\n"
-                                   "Most of the material properties are constant, except for the shear, "
-                                   "viscosity $\\eta$, the compaction viscosity $\\xi$, and the "
-                                   "permeability $k$, which depend on the porosity; and the solid and melt "
-                                   "densities, which depend on temperature and pressure:\n "
-                                   "$\\eta(\\phi,T) = \\eta_0 e^{\\alpha(\\phi-\\phi_0)} e^{-\\beta(T-T_0)/T_0}$, "
-                                   "$\\xi(\\phi,T) = \\xi_0 \\frac{\\phi_0}{\\phi} e^{-\\beta(T-T_0)/T_0}$, "
-                                   "$k=k_0 \\phi^n (1-\\phi)^m$, "
-                                   "$\\rho=\\rho_0 (1 - \\alpha (T - T_{\\text{adi}})) e^{\\kappa p}$."
-                                   "\n\n"
-                                   "The model is compressible only if this is specified in the input file, "
-                                   "and contains compressibility for both solid and melt.")
-  }
-}
diff --git a/source/material_model/modified_tait.cc.bak b/source/material_model/modified_tait.cc.bak
deleted file mode 100644
index 6340609a461..00000000000
--- a/source/material_model/modified_tait.cc.bak
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/modified_tait.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    ModifiedTait<dim>::
-    evaluate(const MaterialModelInputs<dim> &in,
-             MaterialModelOutputs<dim> &out) const
-    {
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double temperature = in.temperature[i];
-          const double pressure = in.pressure[i];
-
-          AssertThrow(temperature > 100., ExcMessage("The current temperature is <100 K. "
-                                                     "The modified Tait equations of state is "
-                                                     "not designed for such temperatures. "
-                                                     "If this exception is triggered at the "
-                                                     "beginning of a run, you may need to "
-                                                     "set Adiabatic surface temperature "
-                                                     "to a value > 100 in the parameter file."));
-          out.viscosities[i] = eta;
-          out.thermal_conductivities[i] = k_value;
-
-          // Einstein equations for the heat capacity at constant volume
-          const double x_einstein = einstein_temperature/temperature;
-          const double x_einstein0 = einstein_temperature/reference_temperature;
-
-
-          AssertThrow(x_einstein < 35., ExcMessage("The current temperature is less than 1/35th "
-                                                   "of the Einstein temperature. This is not "
-                                                   "expected for geological materials."));
-          AssertThrow(x_einstein0 < 35., ExcMessage("The reference temperature of the "
-                                                    "equation of state is less than 1/35th "
-                                                    "of the Einstein temperature. This is not "
-                                                    "expected for geological materials."));
-
-          // The following Einstein energies and heat capacities are divided through by 3nR.
-          // This doesn't matter, as the equation of state relies only on ratios of these quantities.
-          const double E_th0 = einstein_temperature * (0.5 + 1. / (std::exp(x_einstein0) - 1.0));
-          const double C_V0 = x_einstein0 * x_einstein0 * std::exp(x_einstein0) / std::pow(std::exp(x_einstein0) - 1.0, 2.0);
-
-          const double E_th = einstein_temperature * (0.5 + 1. / (std::exp(x_einstein) - 1.0));
-          const double C_V = x_einstein * x_einstein * std::exp(x_einstein) / std::pow(std::exp(x_einstein) - 1.0, 2.0);
-
-          // The relative thermal pressure
-          const double Pth_rel = reference_thermal_expansivity * reference_isothermal_bulk_modulus * (E_th - E_th0) / C_V0;
-          const double psubpth = pressure - reference_pressure - Pth_rel;
-
-          // x = rho0/rho
-          const double x = 1 - tait_a * (1. - std::pow((1. + tait_b * psubpth), -1.0 * tait_c));
-
-          // xi
-          const double xi = (C_V / C_V0);
-
-          // Here we calculate the pressure effect on the heat capacity. It is a bit involved.
-          const double dintVdpdT = ((reference_thermal_expansivity *
-                                     reference_isothermal_bulk_modulus / reference_rho *
-                                     tait_a * xi) *
-                                    (std::pow((1. + tait_b * psubpth), - tait_c) -
-                                     std::pow((1. - tait_b * Pth_rel), - tait_c)));
-
-          const double dSdT = (reference_isothermal_bulk_modulus / reference_rho *
-                               std::pow((xi * reference_thermal_expansivity), 2) *
-                               (std::pow((1. + tait_b * psubpth), -1. - tait_c) -
-                                std::pow((1. - tait_b * Pth_rel), -1. - tait_c)) +
-                               dintVdpdT * (( 1 - 2./x_einstein + 2./(std::exp(x_einstein) - 1.))
-                                            * einstein_temperature/(temperature*temperature)));
-
-          const double rho = reference_rho / x;
-          const double isothermal_compressibility = 1./(reference_isothermal_bulk_modulus * (1. + tait_b * psubpth) * (tait_a + (1. - tait_a) * std::pow((1. + tait_b * psubpth), tait_c)));
-          const double alpha = reference_thermal_expansivity * xi * 1. / ((1. + tait_b * psubpth) * (tait_a + (1. - tait_a) * std::pow((1 + tait_b * psubpth), tait_c)));
-          const double heat_capacity = reference_heat_capacity_function.value(Point<1>(temperature)) + temperature * dSdT;
-
-          // The following line might be useful for some compressibility models
-          // double isentropic_compressibility = isothermal_compressibility - alpha*alpha*temperature/(rho*heat_capacity);
-          out.densities[i] = rho;
-          out.compressibilities[i] = isothermal_compressibility;
-          out.thermal_expansion_coefficients[i] = alpha;
-          out.specific_heat[i] = heat_capacity;
-
-          out.entropy_derivative_pressure[i] = -alpha / rho;
-          out.entropy_derivative_temperature[i] = heat_capacity/temperature;
-          // Change in composition due to chemical reactions at the
-          // given positions. The term reaction_terms[i][c] is the
-          // change in compositional field c at point i.
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    ModifiedTait<dim>::
-    is_compressible () const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    void
-    ModifiedTait<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Modified Tait model");
-        {
-          prm.declare_entry ("Reference pressure", "1e5",
-                             Patterns::Double (0.),
-                             "Reference pressure $P_0$. Units: \\si{\\pascal}.");
-          prm.declare_entry ("Reference temperature", "298.15",
-                             Patterns::Double (0.),
-                             "Reference temperature $T_0$. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Reference density", "3300.",
-                             Patterns::Double (0.),
-                             "The density at the reference pressure and temperature. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference isothermal bulk modulus", "125e9",
-                             Patterns::Double (0.),
-                             "The isothermal bulk modulus at the reference pressure and temperature. "
-                             "Units: \\si{\\pascal}.");
-          prm.declare_entry ("Reference bulk modulus derivative", "4.",
-                             Patterns::Double (0.),
-                             "The value of the first pressure derivative of the isothermal bulk modulus "
-                             "at the reference pressure and temperature. "
-                             "Units: None.");
-          prm.declare_entry ("Reference thermal expansivity", "2e-5",
-                             Patterns::Double (0.),
-                             "The thermal expansion coefficient at the reference pressure and temperature. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Einstein temperature", "600.",
-                             Patterns::Double (0.),
-                             "The Einstein temperature at the reference pressure and temperature. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Viscosity", "1e21",
-                             Patterns::Double (0.),
-                             "The value of the constant viscosity $\\eta_0$. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the constant thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-
-          prm.enter_subsection("Reference heat capacity function");
-          {
-            Functions::ParsedFunction<1>::declare_parameters(prm,1);
-            prm.declare_entry("Function expression","1.25e3");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ModifiedTait<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Modified Tait model");
-        {
-          reference_pressure                = prm.get_double ("Reference pressure");
-          reference_temperature             = prm.get_double ("Reference temperature");
-          reference_rho                     = prm.get_double ("Reference density");
-          reference_isothermal_bulk_modulus = prm.get_double ("Reference isothermal bulk modulus");
-          reference_Kprime                  = prm.get_double ("Reference bulk modulus derivative");
-          reference_thermal_expansivity     = prm.get_double ("Reference thermal expansivity");
-          einstein_temperature              = prm.get_double ("Einstein temperature");
-
-          eta                               = prm.get_double ("Viscosity");
-          k_value                           = prm.get_double ("Thermal conductivity");
-
-          prm.enter_subsection("Reference heat capacity function");
-          {
-            try
-              {
-                reference_heat_capacity_function.parse_parameters(prm);
-              }
-            catch (...)
-              {
-                std::cerr << "FunctionParser failed to parse\n"
-                          << "\t Reference heat capacity function\n"
-                          << "with expression \n"
-                          << "\t' " << prm.get("Function expression") << "'";
-                throw;
-              }
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Calculate dependent parameters
-      Kdprime_0 = -reference_Kprime/reference_isothermal_bulk_modulus;
-      tait_a = (1. + reference_Kprime) / (1. + reference_Kprime  + reference_isothermal_bulk_modulus * Kdprime_0);
-      tait_b = (reference_Kprime  / reference_isothermal_bulk_modulus) - (Kdprime_0  / (1. + reference_Kprime ));
-      tait_c = (1. + reference_Kprime  + reference_isothermal_bulk_modulus * Kdprime_0) /
-               (reference_Kprime * reference_Kprime + reference_Kprime - reference_isothermal_bulk_modulus * Kdprime_0);
-
-      // Declare dependencies on solution variables
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-      this->model_dependence.viscosity = NonlinearDependence::none;
-
-
-      this->model_dependence.density = NonlinearDependence::temperature
-                                       | NonlinearDependence::pressure
-                                       | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::temperature
-                                               | NonlinearDependence::pressure
-                                               | NonlinearDependence::compositional_fields;
-      this->model_dependence.specific_heat = NonlinearDependence::temperature
-                                             | NonlinearDependence::pressure
-                                             | NonlinearDependence::compositional_fields;
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ModifiedTait,
-                                   "modified tait",
-                                   "A material model that implements the thermal modified Tait "
-                                   "equation of state as written in \\cite{HP2011}. "
-                                   "Constant values are used for the thermal conductivity and "
-                                   "viscosity. The defaults for all coefficients are chosen "
-                                   "to be similar to what is believed to be correct "
-                                   "for Earth's mantle. "
-                                   "All of the values that define this model are read "
-                                   "from a section ``Material model/Modified Tait model'' "
-                                   "in the input file, see "
-                                   "Section~\\ref{parameters:Material_20model/Modified_20Tait_20model}.")
-  }
-}
diff --git a/source/material_model/multicomponent.cc.bak b/source/material_model/multicomponent.cc.bak
deleted file mode 100644
index 66040fe62ac..00000000000
--- a/source/material_model/multicomponent.cc.bak
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/multicomponent.h>
-#include <aspect/utilities.h>
-
-#include <numeric>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    Multicomponent<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      EquationOfStateOutputs<dim> eos_outputs (this->introspection().n_chemical_composition_fields()+1);
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          // The (incompressible) Boussinesq approximation treats the
-          // buoyancy term as Delta rho[i] * C[i], which implies that
-          // compositional fields are given as volume fractions.
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[i],
-                                                       this->introspection().chemical_composition_field_indices());
-
-          equation_of_state.evaluate(in, i, eos_outputs);
-          out.viscosities[i] = MaterialUtilities::average_value(volume_fractions, viscosities, viscosity_averaging);
-          out.specific_heat[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
-          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
-          out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
-          out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
-          out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
-
-          // Arithmetic averaging of thermal conductivities
-          // This may not be strictly the most reasonable thing, but for most Earth materials we hope
-          // that they do not vary so much that it is a big problem.
-          out.thermal_conductivities[i] = MaterialUtilities::average_value (volume_fractions, thermal_conductivities, MaterialUtilities::arithmetic);
-
-          // not strictly correct if thermal expansivities are different, since we are interpreting
-          // these compositions as volume fractions, but the error introduced should not be too bad.
-          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
-
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-
-        }
-    }
-
-    template <int dim>
-    bool
-    Multicomponent<dim>::
-    is_compressible () const
-    {
-      return equation_of_state.is_compressible();
-    }
-
-    template <int dim>
-    void
-    Multicomponent<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Multicomponent");
-        {
-          EquationOfState::MulticomponentIncompressible<dim>::declare_parameters (prm, 4.e-5);
-
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Viscosities", "1.e21",
-                             Patterns::Anything(),
-                             "List of viscosities for background mantle and compositional fields,"
-                             "for a total of N+1 values, where N is the number of compositional fields."
-                             "If only one value is given, then all use the same value. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Thermal conductivities", "4.7",
-                             Patterns::Anything(),
-                             "List of thermal conductivities for background mantle and compositional fields,"
-                             "for a total of N+1 values, where N is the number of compositional fields."
-                             "If only one value is given, then all use the same value. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
-                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
-                             "When more than one compositional field is present at a point "
-                             "with different viscosities, we need to come up with an average "
-                             "viscosity at that point.  Select a weighted harmonic, arithmetic, "
-                             "geometric, or maximum composition.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    Multicomponent<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Multicomponent");
-        {
-          equation_of_state.initialize_simulator (this->get_simulator());
-          equation_of_state.parse_parameters (prm);
-
-          reference_T = prm.get_double ("Reference temperature");
-
-          viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
-                                prm);
-
-          // Make options file for parsing maps to double arrays
-          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-          chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-          compositional_field_names.insert(compositional_field_names.begin(),"background");
-
-          Utilities::MapParsing::Options options(chemical_field_names, "Viscosities");
-          options.list_of_allowed_keys = compositional_field_names;
-          options.allow_multiple_values_per_key = true;
-
-          // Parse multicomponent properties
-          viscosities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Viscosities"), options);
-          options.property_name = "Thermal conductivities";
-          thermal_conductivities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Thermal conductivities"), options);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::compositional_fields;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Multicomponent,
-                                   "multicomponent",
-                                   "This incompressible model is for use with an arbitrary number of"
-                                   " compositional fields, where each field represents a rock type which"
-                                   " can have completely different properties from the others."
-                                   " However, each rock type itself has constant material properties.  The value of the "
-                                   " compositional field is interpreted as a volume fraction. If the sum of the fields is"
-                                   " greater than one, they are renormalized.  If it is less than one, material properties "
-                                   " for ``background mantle'' make up the rest. When more than one field is present, the"
-                                   " material properties are averaged arithmetically.  An exception is the viscosity,"
-                                   " where the averaging should make more of a difference.  For this, the user selects"
-                                   " between arithmetic, harmonic, geometric, or maximum composition averaging.")
-  }
-}
diff --git a/source/material_model/multicomponent_compressible.cc.bak b/source/material_model/multicomponent_compressible.cc.bak
deleted file mode 100644
index 09bc2634bb3..00000000000
--- a/source/material_model/multicomponent_compressible.cc.bak
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/multicomponent_compressible.h>
-#include <aspect/utilities.h>
-
-#include <numeric>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    MulticomponentCompressible<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      EquationOfStateOutputs<dim> eos_outputs (this->n_compositional_fields()+1);
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          equation_of_state.evaluate(in, i, eos_outputs);
-
-          // Calculate volume fractions from mass fractions
-          const std::vector<double> mass_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_volumes_from_masses(mass_fractions,
-                                                       eos_outputs.densities,
-                                                       true);
-
-          // Specific quantities are mass averaged
-          out.specific_heat[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
-          out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
-          out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
-
-          // Density, thermal expansivity and compressibility are all volume averaged
-          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
-          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
-          out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
-
-          // Arithmetic volume fraction averaging of thermal conductivities
-          // This may not be the most reasonable thing, but for most Earth materials we hope
-          // that they do not vary so much that it is a big problem.
-          out.thermal_conductivities[i] = MaterialUtilities::average_value (volume_fractions, thermal_conductivities, MaterialUtilities::arithmetic);
-
-          // User-defined volume fraction averaging of viscosities
-          out.viscosities[i] = MaterialUtilities::average_value (volume_fractions, viscosities, viscosity_averaging);
-
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-
-        }
-    }
-
-    template <int dim>
-    bool
-    MulticomponentCompressible<dim>::
-    is_compressible () const
-    {
-      return equation_of_state.is_compressible();
-    }
-
-    template <int dim>
-    void
-    MulticomponentCompressible<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Multicomponent compressible");
-        {
-          EquationOfState::MulticomponentCompressible<dim>::declare_parameters (prm);
-
-          prm.declare_entry ("Viscosities", "1.e21",
-                             Patterns::Anything(),
-                             "List of viscosities for background mantle and compositional fields,"
-                             "for a total of N+1 values, where N is the number of compositional fields."
-                             "If only one value is given, then all use the same value. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Thermal conductivities", "4.7",
-                             Patterns::Anything(),
-                             "List of thermal conductivities for background mantle and compositional fields,"
-                             "for a total of N+1 values, where N is the number of compositional fields."
-                             "If only one value is given, then all use the same value. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
-                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
-                             "When more than one compositional field is present at a point "
-                             "with different viscosities, we need to come up with an average "
-                             "viscosity at that point.  Select a weighted harmonic, arithmetic, "
-                             "geometric, or maximum composition.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    MulticomponentCompressible<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Multicomponent compressible");
-        {
-          equation_of_state.initialize_simulator (this->get_simulator());
-          equation_of_state.parse_parameters (prm);
-
-          viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
-                                prm);
-
-          // Establish that a background field is required here
-          const bool has_background_field = true;
-
-          // Retrieve the list of composition names
-          const std::vector<std::string> list_of_composition_names = this->introspection().get_composition_names();
-
-          viscosities = Utilities::parse_map_to_double_array (prm.get("Viscosities"),
-                                                              list_of_composition_names,
-                                                              has_background_field,
-                                                              "Viscosities");
-
-          thermal_conductivities = Utilities::parse_map_to_double_array (prm.get("Thermal conductivities"),
-                                                                         list_of_composition_names,
-                                                                         has_background_field,
-                                                                         "Thermal conductivities");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.thermal_conductivity = NonlinearDependence::compositional_fields;
-      this->model_dependence.viscosity = NonlinearDependence::compositional_fields;
-      this->model_dependence.density |= NonlinearDependence::temperature
-                                        | NonlinearDependence::pressure
-                                        | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::temperature
-                                               | NonlinearDependence::pressure
-                                               | NonlinearDependence::compositional_fields;
-      this->model_dependence.specific_heat = NonlinearDependence::temperature
-                                             | NonlinearDependence::pressure
-                                             | NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(MulticomponentCompressible,
-                                   "multicomponent compressible",
-                                   "This model is for use with an arbitrary number of compositional fields, where each field"
-                                   " represents a rock type which can have completely different properties from the others."
-                                   " Each rock type is described by a self-consistent equation of state.  The value of the "
-                                   " compositional field is interpreted as a mass fraction. If the sum of the fields is"
-                                   " greater than one, they are renormalized.  If it is less than one, material properties "
-                                   " for ``background mantle'' make up the rest. When more than one field is present, the "
-                                   "material properties are averaged arithmetically by mass fraction (for specific heat), "
-                                   "or volume fraction (for density, thermal expansivity and compressibility). "
-                                   "The thermal conductivity is also arithmetically averaged by volume fraction. "
-                                   "Finally, the viscosity is averaged by volume fraction, but the user can choose "
-                                   "between arithmetic, harmonic, geometric or maximum composition averaging.")
-  }
-}
diff --git a/source/material_model/nondimensional.cc.bak b/source/material_model/nondimensional.cc.bak
deleted file mode 100644
index 88607a5573f..00000000000
--- a/source/material_model/nondimensional.cc.bak
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/nondimensional.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    Nondimensional<dim>::initialize ()
-    {
-      Assert(this->get_parameters().formulation_temperature_equation
-             == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile,
-             ExcMessage("The Nondimensional material model can only work with a "
-                        "temperature formulation that is based on the reference "
-                        "profile."));
-      Assert((this->get_parameters().formulation_mass_conservation
-              == Parameters<dim>::Formulation::MassConservation::incompressible
-              && !compressible)
-             ||
-             (this->get_parameters().formulation_mass_conservation
-              == Parameters<dim>::Formulation::MassConservation::reference_density_profile
-              && compressible)
-             ||
-             (this->get_parameters().formulation_mass_conservation
-              == Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile
-              && compressible)
-             ,
-             ExcMessage("The Nondimensional material model can only work with a "
-                        "mass formulation that is incompressible or based on "
-                        "the reference profile and the Di has to be chosen "
-                        "accordingly."));
-    }
-
-
-    template <int dim>
-    void
-    Nondimensional<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const Point<dim> position = in.position[i];
-          const double temperature_deviation = in.temperature[i] - this->get_adiabatic_conditions().temperature(position);
-          const double pressure_deviation = in.pressure[i] - this->get_adiabatic_conditions().pressure(position);
-
-          const double depth = this->get_geometry_model().depth(position);
-
-          out.viscosities[i] = (compressible ? Di : 1.0) / Ra
-                               * std::exp( -exponential_viscosity_temperature_prefactor * temperature_deviation
-                                           + exponential_viscosity_depth_prefactor * depth);
-
-          out.specific_heat[i] = reference_specific_heat;
-          out.thermal_conductivities[i] = 1.0;
-          out.thermal_expansion_coefficients[i] = compressible ? Di : 1.0;
-
-          out.densities[i] = reference_rho
-                             * std::exp(depth * Di/gamma)
-                             * (1.0
-                                - out.thermal_expansion_coefficients[i] * temperature_deviation
-                                + (tala ? 0.0 : 1.0) * Di * gamma * pressure_deviation);
-
-          out.compressibilities[i] = 0.0;
-          out.entropy_derivative_pressure[i] = 0.0;
-          out.entropy_derivative_temperature[i] = 0.0;
-
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    Nondimensional<dim>::
-    is_compressible () const
-    {
-      return compressible;
-    }
-
-
-
-    template <int dim>
-    void
-    Nondimensional<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Nondimensional model");
-        {
-          prm.declare_entry ("Reference density", "1.0",
-                             Patterns::Double (0.),
-                             "Reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Ra", "1e4",
-                             Patterns::Double (0.),
-                             "Rayleigh number Ra");
-          prm.declare_entry ("Di", "0.0",
-                             Patterns::Double (0.),
-                             "Dissipation number. Pick 0.0 for incompressible "
-                             "computations.");
-          prm.declare_entry ("gamma", "1.0",
-                             Patterns::Double (0.),
-                             "Grueneisen parameter");
-          prm.declare_entry ("Reference specific heat", "1.0",
-                             Patterns::Double (0.),
-                             "The value of the specific heat $C_p$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Viscosity temperature prefactor", "0.0",
-                             Patterns::Double (0.),
-                             "Exponential temperature prefactor for viscosity.");
-          prm.declare_entry ("Viscosity depth prefactor", "0.0",
-                             Patterns::Double (0.),
-                             "Exponential depth prefactor for viscosity.");
-          prm.declare_entry ("Use TALA", "false",
-                             Patterns::Bool (),
-                             "Whether to use the TALA instead of the ALA "
-                             "approximation.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Nondimensional<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Nondimensional model");
-        {
-          reference_rho   = prm.get_double ("Reference density");
-          exponential_viscosity_temperature_prefactor = prm.get_double ("Viscosity temperature prefactor");
-          exponential_viscosity_depth_prefactor = prm.get_double ("Viscosity depth prefactor");
-          Di              = prm.get_double ("Di");
-          Ra              = prm.get_double ("Ra");
-          gamma           = prm.get_double ("gamma");
-          tala            = prm.get_bool ("Use TALA");
-          reference_specific_heat = prm.get_double ("Reference specific heat");
-
-          compressible = (Di!=0.0);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature;
-      this->model_dependence.density = NonlinearDependence::pressure | NonlinearDependence::temperature;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Nondimensional,
-                                   "nondimensional",
-                                   "A material model for nondimensionalized "
-                                   "computations for compressible or incompressible "
-                                   "computations defined through Rayleigh number \text{Ra} "
-                                   "and Dissipation number Di. This model is made "
-                                   "to be used with the Boussinesq, ALA, or TALA "
-                                   "formulation."
-                                   "\n\n"
-                                   "The viscosity is defined as $\\eta = \\text{Di} / \\text{Ra} \\cdot \\exp(-b T^\\prime + c z)$ "
-                                   "where $T^\\prime$ is the temperature variation from the "
-                                   "adiabatic temperature, $z$ is the depth, "
-                                   "$b$ is given by ``Viscosity temperature prefactor'', "
-                                   "and $c$ by ``Viscosity depth prefactor''. If "
-                                   "$\\text{Di}$ is zero, it will be replaced by 1.0 in $\\eta$."
-                                   "\n\n"
-                                   "The density is defined as $\\rho = \\exp(\\text{Di}/\\gamma \\cdot z) "
-                                   " (1.0 - \\alpha T^\\prime + \\text{Di} \\gamma p^\\prime),$ where "
-                                   "$\\alpha=\\text{Di}$ is the thermal expansion coefficient, "
-                                   "$\\gamma$ is the Grueneisen parameter, and $p^\\prime$ is "
-                                   "the pressure variation from the adiabatic "
-                                   "pressure. The pressure dependent term is not present "
-                                   "if ``TALA'' is enabled.")
-  }
-}
diff --git a/source/material_model/perplex_lookup.cc.bak b/source/material_model/perplex_lookup.cc.bak
deleted file mode 100644
index 46daf562cf7..00000000000
--- a/source/material_model/perplex_lookup.cc.bak
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/perplex_lookup.h>
-
-#ifdef ASPECT_WITH_PERPLEX
-extern "C" {
-#include <perplex_c.h>
-}
-#include <deal.II/base/multithread_info.h>
-#endif
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    PerpleXLookup<dim>::initialize()
-    {
-#ifdef ASPECT_WITH_PERPLEX
-      AssertThrow(dealii::MultithreadInfo::is_running_single_threaded(),
-                  ExcMessage("The PerpleXLookup MaterialModel only works in single threaded mode (do not use -j)!"));
-
-      ini_phaseq(perplex_file_name.c_str()); // this line initializes meemum
-#else
-      Assert (false, ExcMessage("ASPECT has not been compiled with the PerpleX libraries"));
-#endif
-    }
-
-    template <int dim>
-    bool
-    PerpleXLookup<dim>::
-    is_compressible () const
-    {
-      return true;
-    }
-
-    template <int dim>
-    void
-    PerpleXLookup<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      /* Instead of evaluating at every quadrature point per cell,
-       * we here average the P, T and X values, and evaluate once.
-       * This is much quicker than evaluating at all quadrature
-       * points, and if the grid is fine, it should be a reasonable
-       * approximation
-       */
-
-#ifdef ASPECT_WITH_PERPLEX
-      std::vector<double> wtphases(p_size_phases);
-      std::vector<double> cphases(p_size_phases * p_size_components);
-      std::vector<char> namephases(p_size_phases * p_pname_len);
-      std::vector<double> sysprop(p_size_sysprops);
-
-      int phaseq_dbg = 0;
-
-      unsigned int n_quad = in.n_evaluation_points(); // number of quadrature points in cell
-      unsigned int n_comp = in.composition[0].size(); // number of components in rock
-
-      const double average_temperature = std::min(max_temperature,
-                                                  std::max(min_temperature,
-                                                           (accumulate( in.temperature.begin(), in.temperature.end(), 0.0) /
-                                                            n_quad)));
-      const double average_pressure = std::min(max_pressure,
-                                               std::max(min_pressure,
-                                                        (accumulate( in.pressure.begin(), in.pressure.end(), 0.0) /
-                                                         n_quad)));
-
-      std::vector<double> comp;
-      comp.resize(n_comp);
-
-      for (unsigned int c=0; c<n_comp; ++c)
-        {
-          for (unsigned int i=0; i<n_quad; ++i)
-            {
-              comp[c] += in.composition[i][c];
-              out.reaction_terms[i][c] = 0.0;
-            }
-          comp[c] /= (double)n_quad;
-        }
-
-      // Here is the call to PerpleX/meemum
-      int nphases;
-
-      phaseq(average_pressure/1.e5, average_temperature,
-             n_comp, comp.data(), &nphases, wtphases.data(), cphases.data(),
-             sysprop.data(), namephases.data(), phaseq_dbg);
-
-      AssertThrow(!isnan(sysprop[9]) && !isnan(sysprop[11]) && !isnan(sysprop[12]) && !isnan(sysprop[13]),
-                  ExcMessage("PerpleX returned NaN for at least one material property at " +
-                             std::to_string(average_pressure) +" bar, " +
-                             std::to_string(average_temperature) + " K. Aborting. " +
-                             "Please adjust the P-T bounds in the parameter file or adjust the PerpleX files."));
-
-      for (unsigned int i=0; i<n_quad; ++i)
-        {
-          out.viscosities[i] = eta;
-          out.thermal_conductivities[i] = k_value;
-          out.densities[i] = sysprop[9];
-          out.specific_heat[i] = sysprop[11]*(1000./sysprop[16]); // molar Cp * (1000/molar mass) (g)
-          out.thermal_expansion_coefficients[i] = sysprop[12];
-          out.compressibilities[i] = sysprop[13]*1.e5;
-        }
-#else
-      (void)in;
-      (void)out;
-      Assert (false, ExcMessage("ASPECT has not been compiled with the PerpleX libraries"));
-#endif
-
-    }
-
-
-    template <int dim>
-    void
-    PerpleXLookup<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("PerpleX lookup model");
-        {
-
-          prm.declare_entry ("PerpleX input file name", "rock.dat",
-                             Patterns::Anything (),
-                             "The name of the PerpleX input file (should end with .dat).");
-          prm.declare_entry ("Viscosity", "5e24",
-                             Patterns::Double (0.),
-                             "The value of the viscosity $\\eta$. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Minimum material temperature", "0.",
-                             Patterns::Double (0.),
-                             "The value of the minimum temperature used to query PerpleX. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Maximum material temperature", "6000.",
-                             Patterns::Double (0.),
-                             "The value of the maximum temperature used to query PerpleX. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Minimum material pressure", "1.e5",
-                             Patterns::Double (0.),
-                             "The value of the minimum pressure used to query PerpleX. "
-                             "Units: \\si{\\pascal}.");
-          prm.declare_entry ("Maximum material pressure", "1.e12",
-                             Patterns::Double (0.),
-                             "The value of the maximum pressure used to query PerpleX. "
-                             "Units: \\si{\\pascal}.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    PerpleXLookup<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("PerpleX lookup model");
-        {
-          perplex_file_name   = prm.get ("PerpleX input file name");
-          eta                 = prm.get_double ("Viscosity");
-          k_value             = prm.get_double ("Thermal conductivity");
-          min_temperature     = prm.get_double ("Minimum material temperature");
-          max_temperature     = prm.get_double ("Maximum material temperature");
-          min_pressure        = prm.get_double ("Minimum material pressure");
-          max_pressure        = prm.get_double ("Maximum material pressure");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-
-      this->model_dependence.density = NonlinearDependence::temperature
-                                       | NonlinearDependence::pressure
-                                       | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::temperature
-                                               | NonlinearDependence::pressure
-                                               | NonlinearDependence::compositional_fields;
-      this->model_dependence.specific_heat = NonlinearDependence::temperature
-                                             | NonlinearDependence::pressure
-                                             | NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(PerpleXLookup,
-                                   "perplex lookup",
-                                   "A material model that has constant values "
-                                   "for viscosity and thermal conductivity, and "
-                                   "calculates other properties on-the-fly using "
-                                   "PerpleX meemum. Compositional fields correspond "
-                                   "to the individual components in the order given "
-                                   "in the PerpleX file.")
-  }
-}
diff --git a/source/material_model/prescribed_viscosity.cc.bak b/source/material_model/prescribed_viscosity.cc.bak
deleted file mode 100644
index 25f647ae177..00000000000
--- a/source/material_model/prescribed_viscosity.cc.bak
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/prescribed_viscosity.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    PrescribedViscosity<dim>::initialize()
-    {
-      base_model->initialize();
-    }
-
-
-
-    template <int dim>
-    void
-    PrescribedViscosity<dim>::update()
-    {
-      base_model->update();
-
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      const double time = this->convert_output_to_years() ? this->get_time() / year_in_seconds : this->get_time();
-      prescribed_viscosity_indicator_function.set_time (time);
-      prescribed_viscosity_function.set_time (time);
-    }
-
-
-
-    template <int dim>
-    void
-    PrescribedViscosity<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                                       typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      base_model->evaluate(in,out);
-      for (unsigned int i=0; i<out.n_evaluation_points(); ++i)
-        {
-          if (in.requests_property(MaterialProperties::viscosity))
-            {
-              const double indicator = prescribed_viscosity_indicator_function.value(in.position[i]);
-
-              if (indicator > 0.5)
-                {
-                  out.viscosities[i] = prescribed_viscosity_function.value(in.position[i]);
-                }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    PrescribedViscosity<dim>::
-    is_compressible () const
-    {
-      return base_model->is_compressible();
-    }
-
-
-
-    template <int dim>
-    void
-    PrescribedViscosity<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Prescribed viscosity");
-        {
-
-          prm.declare_entry("Base model","simple",
-                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
-                            "The name of a material model that will be modified by the prescribed "
-                            "viscosity material model. Valid values for this parameter "
-                            "are the names of models that are also valid for the "
-                            "``Material models/Model name'' parameter. See the documentation for "
-                            "that for more information.");
-
-          prm.enter_subsection ("Indicator function");
-          {
-            Functions::ParsedFunction<dim>::declare_parameters (prm, 3);
-          }
-          prm.leave_subsection ();
-
-          prm.enter_subsection ("Viscosity function");
-          {
-            Functions::ParsedFunction<dim>::declare_parameters (prm, 3);
-          }
-          prm.leave_subsection ();
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-
-    template <int dim>
-    void
-    PrescribedViscosity<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Prescribed viscosity");
-        {
-          AssertThrow( prm.get("Base model") != "prescribed viscosity",
-                       ExcMessage("You may not use ``prescribed viscosity'' as the base model for "
-                                  "a prescribed viscosity model.") );
-
-          // create the base model and initialize its SimulatorAccess base
-          // class; it will get a chance to read its parameters below after we
-          // leave the current section
-          base_model = create_material_model<dim>(prm.get("Base model"));
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
-            sim->initialize_simulator (this->get_simulator());
-
-          prm.enter_subsection("Indicator function");
-          {
-            try
-              {
-                prescribed_viscosity_indicator_function.parse_parameters (prm);
-              }
-            catch (...)
-              {
-                std::cerr << "ERROR: FunctionParser failed to parse\n"
-                          << "\t'Prescribed viscosity.Indicator function'\n"
-                          << "with expression\n"
-                          << "\t'" << prm.get("Function expression") << "'";
-                throw;
-              }
-          }
-          prm.leave_subsection();
-
-          prm.enter_subsection("Viscosity function");
-          {
-            try
-              {
-                prescribed_viscosity_function.parse_parameters (prm);
-              }
-            catch (...)
-              {
-                std::cerr << "ERROR: FunctionParser failed to parse\n"
-                          << "\t'Prescribed viscosity.Viscosity function'\n"
-                          << "with expression\n"
-                          << "\t'" << prm.get("Function expression") << "'";
-                throw;
-              }
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      /* After parsing the parameters for prescribed viscosity, it is essential to parse
-      parameters related to the base model. */
-      base_model->parse_parameters(prm);
-      this->model_dependence = base_model->get_model_dependence();
-    }
-
-
-
-    template <int dim>
-    void
-    PrescribedViscosity<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      base_model->create_additional_named_outputs(out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedViscosity,
-                                   "prescribed viscosity",
-                                   "A material model that applies a viscosity to a ''base model'' chosen from any of "
-                                   "the other available material models. This prescribed viscosity material model "
-                                   "allows the user to specify a function which describes where the viscosity should be "
-                                   "prescribed and a second function which describes the viscosity in that region. "
-                                   "This material model requires a base model which prescribes the viscosity and the "
-                                   "other material parameters in the rest of the model."
-                                  )
-  }
-}
diff --git a/source/material_model/reaction_model/katz2003_mantle_melting.cc.bak b/source/material_model/reaction_model/katz2003_mantle_melting.cc.bak
deleted file mode 100644
index 71993bc7ea7..00000000000
--- a/source/material_model/reaction_model/katz2003_mantle_melting.cc.bak
+++ /dev/null
@@ -1,651 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/reaction_model/katz2003_mantle_melting.h>
-#include <aspect/utilities.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace ReactionModel
-    {
-
-
-      template <int dim>
-      Katz2003MantleMelting<dim>::Katz2003MantleMelting()
-        = default;
-
-
-
-      template <int dim>
-      double
-      Katz2003MantleMelting<dim>::
-      reference_darcy_coefficient () const
-      {
-        // 0.01 = 1% melt
-        return reference_permeability * std::pow(0.01,3.0) / viscosity_fluid;
-      }
-
-
-      template <int dim>
-      double
-      Katz2003MantleMelting<dim>::
-      melt_fraction (const double temperature,
-                     const double pressure) const
-      {
-        // anhydrous melting of peridotite after Katz, 2003
-        const double T_solidus  = A1 + 273.15
-                                  + A2 * pressure
-                                  + A3 * pressure * pressure;
-        const double T_lherz_liquidus = B1 + 273.15
-                                        + B2 * pressure
-                                        + B3 * pressure * pressure;
-        const double T_liquidus = C1 + 273.15
-                                  + C2 * pressure
-                                  + C3 * pressure * pressure;
-
-        // melt fraction for peridotite with clinopyroxene
-        double peridotite_melt_fraction;
-        if (temperature < T_solidus || pressure > 1.3e10)
-          peridotite_melt_fraction = 0.0;
-        else if (temperature > T_lherz_liquidus)
-          peridotite_melt_fraction = 1.0;
-        else
-          peridotite_melt_fraction = std::pow((temperature - T_solidus) / (T_lherz_liquidus - T_solidus),beta);
-
-        // melt fraction after melting of all clinopyroxene
-        const double R_cpx = r1 + r2 * std::max(0.0, pressure);
-        const double F_max = M_cpx / R_cpx;
-
-        if (peridotite_melt_fraction > F_max && temperature < T_liquidus)
-          {
-            const double T_max = std::pow(F_max,1/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
-            peridotite_melt_fraction = F_max + (1 - F_max) * pow((temperature - T_max) / (T_liquidus - T_max),beta);
-          }
-        return peridotite_melt_fraction;
-      }
-
-
-
-      template <int dim>
-      double
-      Katz2003MantleMelting<dim>::
-      entropy_change (const double temperature,
-                      const double pressure,
-                      const double maximum_melt_fraction,
-                      const NonlinearDependence::Dependence dependence) const
-      {
-        double entropy_gradient = 0.0;
-
-        // calculate latent heat of melting
-        // we need the change of melt fraction in dependence of pressure and temperature
-
-        // for peridotite after Katz, 2003
-        const double T_solidus        = A1 + 273.15
-                                        + A2 * pressure
-                                        + A3 * pressure * pressure;
-        const double T_lherz_liquidus = B1 + 273.15
-                                        + B2 * pressure
-                                        + B3 * pressure * pressure;
-        const double T_liquidus       = C1 + 273.15
-                                        + C2 * pressure
-                                        + C3 * pressure * pressure;
-
-        const double dT_solidus_dp        = A2 + 2 * A3 * pressure;
-        const double dT_lherz_liquidus_dp = B2 + 2 * B3 * pressure;
-        const double dT_liquidus_dp       = C2 + 2 * C3 * pressure;
-
-        if (temperature > T_solidus && temperature < T_liquidus && pressure < 1.3e10)
-          {
-            // melt fraction when clinopyroxene is still present
-            double melt_fraction_derivative_temperature
-              = beta * pow((temperature - T_solidus)/(T_lherz_liquidus - T_solidus),beta-1)
-                / (T_lherz_liquidus - T_solidus);
-
-            double melt_fraction_derivative_pressure
-              = beta * pow((temperature - T_solidus)/(T_lherz_liquidus - T_solidus),beta-1)
-                * (dT_solidus_dp * (temperature - T_lherz_liquidus)
-                   + dT_lherz_liquidus_dp * (T_solidus - temperature))
-                / pow(T_lherz_liquidus - T_solidus,2);
-
-            // melt fraction after melting of all clinopyroxene
-            const double R_cpx = r1 + r2 * std::max(0.0, pressure);
-            const double F_max = M_cpx / R_cpx;
-
-            if (melt_fraction(temperature, pressure) > F_max)
-              {
-                const double T_max = std::pow(F_max,1.0/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
-                const double dF_max_dp = - M_cpx * std::pow(r1 + r2 * pressure,-2) * r2;
-                const double dT_max_dp = dT_solidus_dp
-                                         + 1.0/beta * std::pow(F_max,1.0/beta - 1.0) * dF_max_dp * (T_lherz_liquidus - T_solidus)
-                                         + std::pow(F_max,1.0/beta) * (dT_lherz_liquidus_dp - dT_solidus_dp);
-
-                melt_fraction_derivative_temperature
-                  = (1.0 - F_max) * beta * std::pow((temperature - T_max)/(T_liquidus - T_max),beta-1)
-                    / (T_liquidus - T_max);
-
-                melt_fraction_derivative_pressure
-                  = dF_max_dp
-                    - dF_max_dp * std::pow((temperature - T_max)/(T_liquidus - T_max),beta)
-                    + (1.0 - F_max) * beta * std::pow((temperature - T_max)/(T_liquidus - T_max),beta-1)
-                    * (dT_max_dp * (T_max - T_liquidus) - (dT_liquidus_dp - dT_max_dp) * (temperature - T_max)) / std::pow(T_liquidus - T_max, 2);
-              }
-
-            double melt_fraction_derivative = 0;
-            if (dependence == NonlinearDependence::temperature)
-              melt_fraction_derivative = melt_fraction_derivative_temperature;
-            else if (dependence == NonlinearDependence::pressure)
-              melt_fraction_derivative = melt_fraction_derivative_pressure;
-            else
-              AssertThrow(false, ExcMessage("not implemented"));
-
-            if (melt_fraction(temperature, pressure) >= maximum_melt_fraction)
-              entropy_gradient = melt_fraction_derivative * peridotite_melting_entropy_change;
-          }
-        return entropy_gradient;
-      }
-
-
-
-      template <int dim>
-      void
-      Katz2003MantleMelting<dim>::
-      calculate_reaction_rate_outputs(const typename Interface<dim>::MaterialModelInputs &in,
-                                      typename Interface<dim>::MaterialModelOutputs &out) const
-      {
-        ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
-
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-
-            if (this->include_melt_transport())
-              {
-                const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-                const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
-                const double old_porosity = in.composition[i][porosity_idx];
-                const double maximum_melt_fraction = in.composition[i][peridotite_idx];
-
-                // calculate the melting rate as difference between the equilibrium melt fraction
-                // and the solution of the previous time step
-                double porosity_change = 0.0;
-                if (fractional_melting)
-                  {
-                    // solidus is lowered by previous melting events (fractional melting)
-                    const double solidus_change = (maximum_melt_fraction - old_porosity) * depletion_solidus_change;
-                    const double eq_melt_fraction = melt_fraction(in.temperature[i] - solidus_change, this->get_adiabatic_conditions().pressure(in.position[i]));
-                    porosity_change = eq_melt_fraction - old_porosity;
-                  }
-                else
-                  {
-                    // batch melting
-                    porosity_change = melt_fraction(in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]))
-                                      - std::max(maximum_melt_fraction, 0.0);
-                    porosity_change = std::max(porosity_change, 0.0);
-
-                    // freezing of melt below the solidus
-
-                    // If the porosity is larger than the equilibrium melt fraction, melt should freeze again.
-                    // Because we do not track the melt composition, we have to use a workaround here for freezing of melt:
-                    // We reduce the porosity until either it reaches the equilibrium melt fraction, or the depletion
-                    // (peridotite field), which decreases as melt freezes, reaches the same value as the equilibrium
-                    // melt fraction, whatever happens earlier. An exception is when the melt fraction is zero; in this case
-                    // all melt should freeze.
-                    const double eq_melt_fraction = melt_fraction(in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]));
-
-                    // If the porosity change is not negative, there is no freezing, and the change in porosity
-                    // is covered by the melting relation above.
-
-                    // porosity reaches the equilibrium melt fraction:
-                    const double porosity_change_wrt_melt_fraction = std::min(eq_melt_fraction - old_porosity - porosity_change,0.0);
-
-                    // depletion reaches the equilibrium melt fraction:
-                    const double porosity_change_wrt_depletion = std::min((eq_melt_fraction - std::max(maximum_melt_fraction, 0.0))
-                                                                          * (1.0 - old_porosity) / (1.0 - maximum_melt_fraction),0.0);
-                    double freezing_amount = std::max(porosity_change_wrt_melt_fraction, porosity_change_wrt_depletion);
-
-                    if (eq_melt_fraction == 0.0)
-                      freezing_amount = - old_porosity;
-
-                    porosity_change += freezing_amount;
-
-                    // Adapt time scale of freezing with respect to melting.
-                    // We have to multiply with the melting time scale here to obtain the porosity change
-                    // that happens in the time defined by the melting time scale (as opposed to a rate).
-                    // This is important because we want to perform some checks on this quantity (for example,
-                    // we want to make sure that this change does not lead to a negative porosity, see below).
-                    // Later on, the overall porosity change is then divided again by the melting time scale
-                    // to obtain the rate of melting or freezing, which is used in the operator splitting scheme.
-                    if (porosity_change < 0 )
-                      porosity_change *= freezing_rate * melting_time_scale;
-
-                  }
-
-                // remove melt that gets close to the surface
-                if (this->get_geometry_model().depth(in.position[i]) < extraction_depth)
-                  porosity_change = -old_porosity * (in.position[i](1) - (this->get_geometry_model().maximal_depth() - extraction_depth))/extraction_depth;
-
-                // do not allow negative porosity
-                porosity_change = std::max(porosity_change, -old_porosity);
-
-                // because depletion is a volume-based, and not a mass-based property that is advected,
-                // additional scaling factors on the right hand side apply
-                for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                  {
-                    // fill reaction rate outputs
-                    if (reaction_rate_out != nullptr && in.requests_property(MaterialProperties::reaction_rates))
-                      {
-                        if (c == peridotite_idx && this->get_timestep_number() > 0)
-                          reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale * (1 - maximum_melt_fraction) / (1 - old_porosity);
-                        else if (c == porosity_idx && this->get_timestep_number() > 0)
-                          reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale;
-                        else
-                          reaction_rate_out->reaction_rates[i][c] = 0.0;
-                      }
-                    out.reaction_terms[i][c] = 0.0;
-                  }
-
-                out.entropy_derivative_pressure[i]    = entropy_change (in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]), maximum_melt_fraction, NonlinearDependence::pressure);
-                out.entropy_derivative_temperature[i] = entropy_change (in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]), maximum_melt_fraction, NonlinearDependence::temperature);
-              }
-            else
-              {
-                out.entropy_derivative_pressure[i]    = entropy_change (in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]), 0, NonlinearDependence::pressure);
-                out.entropy_derivative_temperature[i] = entropy_change (in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]), 0, NonlinearDependence::temperature);
-
-                // no melting/freezing is used in the model --> set all reactions to zero
-                for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                  {
-                    out.reaction_terms[i][c] = 0.0;
-
-                    if (reaction_rate_out != nullptr)
-                      reaction_rate_out->reaction_rates[i][c] = 0.0;
-                  }
-              }
-          }
-
-      }
-
-
-      template <int dim>
-      void
-      Katz2003MantleMelting<dim>::
-      calculate_fluid_outputs(const typename Interface<dim>::MaterialModelInputs &in,
-                              typename Interface<dim>::MaterialModelOutputs &out,
-                              const double reference_T) const
-      {
-        MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
-        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-        if (melt_out != nullptr)
-          {
-
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                double porosity = std::max(in.composition[i][porosity_idx],0.0);
-
-                melt_out->fluid_viscosities[i] = viscosity_fluid;
-                melt_out->permeabilities[i] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-
-                // first, calculate temperature dependence of density
-                double temperature_dependence = 1.0;
-                if (this->include_adiabatic_heating ())
-                  {
-                    // temperature dependence is 1 - alpha * (T - T(adiabatic))
-                    temperature_dependence -= (in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]))
-                                              * out.thermal_expansion_coefficients[i];
-                  }
-                else
-                  temperature_dependence -= (in.temperature[i] - reference_T) * out.thermal_expansion_coefficients[i];
-
-                // the fluid compressibility includes two parts, a constant compressibility, and a pressure-dependent one
-                // this is a simplified formulation, experimental data are often fit to the Birch-Murnaghan equation of state
-                const double fluid_compressibility = melt_compressibility / (1.0 + in.pressure[i] * melt_bulk_modulus_derivative * melt_compressibility);
-
-                melt_out->fluid_densities[i] = reference_rho_fluid * std::exp(fluid_compressibility * (in.pressure[i] - this->get_surface_pressure()))
-                                               * temperature_dependence;
-
-                melt_out->fluid_density_gradients[i] = melt_out->fluid_densities[i] * melt_out->fluid_densities[i]
-                                                       * fluid_compressibility
-                                                       * this->get_gravity_model().gravity_vector(in.position[i]);
-
-                const double phi_0 = 0.05;
-                porosity = std::max(std::min(porosity,0.995),1e-4);
-                melt_out->compaction_viscosities[i] = xi_0 * phi_0 / porosity;
-
-                double visc_temperature_dependence = 1.0;
-                if (this->include_adiabatic_heating ())
-                  {
-                    const double delta_temp = in.temperature[i]-this->get_adiabatic_conditions().temperature(in.position[i]);
-                    visc_temperature_dependence = std::max(std::min(std::exp(-thermal_bulk_viscosity_exponent*delta_temp/this->get_adiabatic_conditions().temperature(in.position[i])),1e4),1e-4);
-                  }
-                else
-                  {
-                    const double delta_temp = in.temperature[i]-reference_T;
-                    const double T_dependence = (thermal_bulk_viscosity_exponent == 0.0
-                                                 ?
-                                                 0.0
-                                                 :
-                                                 thermal_bulk_viscosity_exponent*delta_temp/reference_T);
-                    visc_temperature_dependence = std::max(std::min(std::exp(-T_dependence),1e4),1e-4);
-                  }
-                melt_out->compaction_viscosities[i] *= visc_temperature_dependence;
-
-
-              }
-          }
-
-        if (this->include_melt_transport() && in.requests_property(MaterialProperties::viscosity))
-          {
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                const double porosity = std::min(1.0, std::max(in.composition[i][porosity_idx],0.0));
-                out.viscosities[i] *= exp(- alpha_phi * porosity);
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      Katz2003MantleMelting<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("A1", "1085.7",
-                           Patterns::Double (),
-                           "Constant parameter in the quadratic "
-                           "function that approximates the solidus "
-                           "of peridotite. "
-                           "Units: \\si{\\degreeCelsius}.");
-        prm.declare_entry ("A2", "1.329e-7",
-                           Patterns::Double (),
-                           "Prefactor of the linear pressure term "
-                           "in the quadratic function that approximates "
-                           "the solidus of peridotite. "
-                           "Units: \\si{\\degreeCelsius\\per\\pascal}.");
-        prm.declare_entry ("A3", "-5.1e-18",
-                           Patterns::Double (),
-                           "Prefactor of the quadratic pressure term "
-                           "in the quadratic function that approximates "
-                           "the solidus of peridotite. "
-                           "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
-        prm.declare_entry ("B1", "1475.0",
-                           Patterns::Double (),
-                           "Constant parameter in the quadratic "
-                           "function that approximates the lherzolite "
-                           "liquidus used for calculating the fraction "
-                           "of peridotite-derived melt. "
-                           "Units: \\si{\\degreeCelsius}.");
-        prm.declare_entry ("B2", "8.0e-8",
-                           Patterns::Double (),
-                           "Prefactor of the linear pressure term "
-                           "in the quadratic function that approximates "
-                           "the  lherzolite liquidus used for "
-                           "calculating the fraction of peridotite-"
-                           "derived melt. "
-                           "Units: \\si{\\degreeCelsius\\per\\pascal}.");
-        prm.declare_entry ("B3", "-3.2e-18",
-                           Patterns::Double (),
-                           "Prefactor of the quadratic pressure term "
-                           "in the quadratic function that approximates "
-                           "the  lherzolite liquidus used for "
-                           "calculating the fraction of peridotite-"
-                           "derived melt. "
-                           "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
-        prm.declare_entry ("C1", "1780.0",
-                           Patterns::Double (),
-                           "Constant parameter in the quadratic "
-                           "function that approximates the liquidus "
-                           "of peridotite. "
-                           "Units: \\si{\\degreeCelsius}.");
-        prm.declare_entry ("C2", "4.50e-8",
-                           Patterns::Double (),
-                           "Prefactor of the linear pressure term "
-                           "in the quadratic function that approximates "
-                           "the liquidus of peridotite. "
-                           "Units: \\si{\\degreeCelsius\\per\\pascal}.");
-        prm.declare_entry ("C3", "-2.0e-18",
-                           Patterns::Double (),
-                           "Prefactor of the quadratic pressure term "
-                           "in the quadratic function that approximates "
-                           "the liquidus of peridotite. "
-                           "Units: \\si{\\degreeCelsius\\per\\pascal\\squared}.");
-        prm.declare_entry ("r1", "0.5",
-                           Patterns::Double (),
-                           "Constant in the linear function that "
-                           "approximates the clinopyroxene reaction "
-                           "coefficient. "
-                           "Units: non-dimensional.");
-        prm.declare_entry ("r2", "8e-11",
-                           Patterns::Double (),
-                           "Prefactor of the linear pressure term "
-                           "in the linear function that approximates "
-                           "the clinopyroxene reaction coefficient. "
-                           "Units: \\si{\\per\\pascal}.");
-        prm.declare_entry ("beta", "1.5",
-                           Patterns::Double (),
-                           "Exponent of the melting temperature in "
-                           "the melt fraction calculation. "
-                           "Units: non-dimensional.");
-        prm.declare_entry ("Mass fraction cpx", "0.15",
-                           Patterns::Double (),
-                           "Mass fraction of clinopyroxene in the "
-                           "peridotite to be molten. "
-                           "Units: non-dimensional.");
-        prm.declare_entry ("Peridotite melting entropy change", "-300.",
-                           Patterns::Double (),
-                           "The entropy change for the phase transition "
-                           "from solid to melt of peridotite. "
-                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-        prm.declare_entry ("Reference melt density", "2500.",
-                           Patterns::Double (0.),
-                           "Reference density of the melt/fluid$\\rho_{f,0}$. "
-                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-        prm.declare_entry ("Reference bulk viscosity", "1e22",
-                           Patterns::Double (0.),
-                           "The value of the constant bulk viscosity $\\xi_0$ of the solid matrix. "
-                           "This viscosity may be modified by both temperature and porosity "
-                           "dependencies. Units: \\si{\\pascal\\second}.");
-        prm.declare_entry ("Reference melt viscosity", "10.",
-                           Patterns::Double (0.),
-                           "The value of the constant melt viscosity $\\viscosity_fluid$. Units: \\si{\\pascal\\second}.");
-        prm.declare_entry ("Exponential melt weakening factor", "27.",
-                           Patterns::Double (0.),
-                           "The porosity dependence of the viscosity. Units: dimensionless.");
-        prm.declare_entry ("Thermal bulk viscosity exponent", "0.0",
-                           Patterns::Double (0.),
-                           "The temperature dependence of the bulk viscosity. Dimensionless exponent. "
-                           "See the general documentation "
-                           "of this model for a formula that states the dependence of the "
-                           "viscosity on this factor, which is called $\\beta$ there.");
-        prm.declare_entry ("Melt extraction depth", "1000.0",
-                           Patterns::Double (0.),
-                           "Depth above that melt will be extracted from the model, "
-                           "which is done by a negative reaction term proportional to the "
-                           "porosity field. "
-                           "Units: \\si{\\meter}.");
-        prm.declare_entry ("Melt compressibility", "0.0",
-                           Patterns::Double (0.),
-                           "The value of the compressibility of the melt. "
-                           "Units: \\si{\\per\\pascal}.");
-        prm.declare_entry ("Melt bulk modulus derivative", "0.0",
-                           Patterns::Double (0.),
-                           "The value of the pressure derivative of the melt bulk "
-                           "modulus. "
-                           "Units: None.");
-        prm.declare_entry ("Use fractional melting", "false",
-                           Patterns::Bool (),
-                           "If fractional melting should be used (if true), including a solidus "
-                           "change based on depletion (in this case, the amount of melt that has "
-                           "migrated away from its origin), and freezing of melt when it has moved "
-                           "to a region with temperatures lower than the solidus; or if batch "
-                           "melting should be used (if false), assuming that the melt fraction only "
-                           "depends on temperature and pressure, and how much melt has already been "
-                           "generated at a given point, but not considering movement of melt in "
-                           "the melting parameterization."
-                           "\n\n"
-                           "Note that melt does not freeze unless the 'Freezing rate' parameter is set "
-                           "to a value larger than 0.");
-        prm.declare_entry ("Freezing rate", "0.0",
-                           Patterns::Double (0.),
-                           "Freezing rate of melt when in subsolidus regions. "
-                           "If this parameter is set to a number larger than 0.0, it specifies the "
-                           "fraction of melt that will freeze per year (or per second, depending on the "
-                           "``Use years in output instead of seconds'' parameter), as soon as the porosity "
-                           "exceeds the equilibrium melt fraction, and the equilibrium melt fraction "
-                           "falls below the depletion. In this case, melt will freeze according to the "
-                           "given rate until one of those conditions is not fulfilled anymore. The "
-                           "reasoning behind this is that there should not be more melt present than "
-                           "the equilibrium melt fraction, as melt production decreases with increasing "
-                           "depletion, but the freezing process of melt also reduces the depletion by "
-                           "the same amount, and as soon as the depletion falls below the equilibrium "
-                           "melt fraction, we expect that material should melt again (no matter how "
-                           "much melt is present). This is quite a simplification and not a realistic "
-                           "freezing parameterization, but without tracking the melt composition, there "
-                           "is no way to compute freezing rates accurately. "
-                           "If this parameter is set to zero, no freezing will occur. "
-                           "Note that freezing can never be faster than determined by the "
-                           "``Melting time scale for operator splitting''. The product of the "
-                           "``Freezing rate'' and the ``Melting time scale for operator splitting'' "
-                           "defines how fast freezing occurs with respect to melting (if the "
-                           "product is 0.5, melting will occur twice as fast as freezing). "
-                           "Units: 1/yr or 1/s, depending on the ``Use years "
-                           "in output instead of seconds'' parameter.");
-        prm.declare_entry ("Melting time scale for operator splitting", "1e3",
-                           Patterns::Double (0.),
-                           "Because the operator splitting scheme is used, the porosity field can not "
-                           "be set to a new equilibrium melt fraction instantly, but the model has to "
-                           "provide a melting time scale instead. This time scale defines how fast melting "
-                           "happens, or more specifically, the parameter defines the time after which "
-                           "the deviation of the porosity from the equilibrium melt fraction will be "
-                           "reduced to a fraction of $1/e$. So if the melting time scale is small compared "
-                           "to the time step size, the reaction will be so fast that the porosity is very "
-                           "close to the equilibrium melt fraction after reactions are computed. Conversely, "
-                           "if the melting time scale is large compared to the time step size, almost no "
-                           "melting and freezing will occur."
-                           "\n\n"
-                           "Also note that the melting time scale has to be larger than or equal to the reaction "
-                           "time step used in the operator splitting scheme, otherwise reactions can not be "
-                           "computed. "
-                           "Units: yr or s, depending on the ``Use years in output instead of seconds'' parameter.");
-        prm.declare_entry ("Depletion solidus change", "200.0",
-                           Patterns::Double (0.),
-                           "The solidus temperature change for a depletion of 100\\%. For positive "
-                           "values, the solidus gets increased for a positive peridotite field "
-                           "(depletion) and lowered for a negative peridotite field (enrichment). "
-                           "Scaling with depletion is linear. Only active when fractional melting "
-                           "is used. "
-                           "Units: \\si{\\kelvin}.");
-        prm.declare_entry ("Reference permeability", "1e-8",
-                           Patterns::Double(),
-                           "Reference permeability of the solid host rock."
-                           "Units: \\si{\\meter\\squared}.");
-
-
-      }
-
-
-      template <int dim>
-      void
-      Katz2003MantleMelting<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        A1    = prm.get_double ("A1");
-        A2    = prm.get_double ("A2");
-        A3    = prm.get_double ("A3");
-        B1    = prm.get_double ("B1");
-        B2    = prm.get_double ("B2");
-        B3    = prm.get_double ("B3");
-        C1    = prm.get_double ("C1");
-        C2    = prm.get_double ("C2");
-        C3    = prm.get_double ("C3");
-        r1    = prm.get_double ("r1");
-        r2    = prm.get_double ("r2");
-        beta  = prm.get_double ("beta");
-        M_cpx = prm.get_double ("Mass fraction cpx");
-        peridotite_melting_entropy_change
-          = prm.get_double ("Peridotite melting entropy change");
-
-        reference_rho_fluid        = prm.get_double ("Reference melt density");
-        xi_0                       = prm.get_double ("Reference bulk viscosity");
-        viscosity_fluid            = prm.get_double ("Reference melt viscosity");
-        thermal_bulk_viscosity_exponent = prm.get_double ("Thermal bulk viscosity exponent");
-        alpha_phi                  = prm.get_double ("Exponential melt weakening factor");
-        extraction_depth           = prm.get_double ("Melt extraction depth");
-        melt_compressibility       = prm.get_double ("Melt compressibility");
-        fractional_melting         = prm.get_bool ("Use fractional melting");
-        freezing_rate              = prm.get_double ("Freezing rate");
-        melting_time_scale         = prm.get_double ("Melting time scale for operator splitting");
-        melt_bulk_modulus_derivative = prm.get_double ("Melt bulk modulus derivative");
-        depletion_solidus_change   = prm.get_double ("Depletion solidus change");
-        reference_permeability     = prm.get_double ("Reference permeability");
-
-
-        if (this->convert_output_to_years() == true)
-          {
-            melting_time_scale *= year_in_seconds;
-            freezing_rate /= year_in_seconds;
-          }
-
-        AssertThrow(melting_time_scale > 0,
-                    ExcMessage("The Melting time scale for operator splitting must be larger than 0!"));
-
-        if (this->get_parameters().reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
-          {
-            AssertThrow(melting_time_scale >= this->get_parameters().reaction_time_step,
-                        ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
-                                   + " in the operator splitting scheme is too large to compute melting rates! "
-                                   "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
-                                   "operator splitting' chosen in the material model, which is currently "
-                                   + Utilities::to_string(melting_time_scale) + "."));
-
-            AssertThrow(freezing_rate * this->get_parameters().reaction_time_step <= 1.0,
-                        ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
-                                   + " in the operator splitting scheme is too large to compute freezing rates! "
-                                   "You have to choose it in such a way that it is smaller than the inverse of the "
-                                   "'Freezing rate' chosen in the material model, which is currently "
-                                   + Utilities::to_string(1.0/freezing_rate) + "."));
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace ReactionModel \
-  { \
-    template class Katz2003MantleMelting<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/reactive_fluid_transport.cc.bak b/source/material_model/reactive_fluid_transport.cc.bak
deleted file mode 100644
index 84bd54dc09f..00000000000
--- a/source/material_model/reactive_fluid_transport.cc.bak
+++ /dev/null
@@ -1,585 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/reactive_fluid_transport.h>
-#include <aspect/simulator_access.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/numerics/fe_field_function.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    bool
-    ReactiveFluidTransport<dim>::
-    is_compressible () const
-    {
-      return base_model->is_compressible();
-    }
-
-
-
-    template <int dim>
-    double
-    ReactiveFluidTransport<dim>::
-    reference_darcy_coefficient () const
-    {
-      if (fluid_solid_reaction_scheme == katz2003)
-        {
-          return katz2003_model.reference_darcy_coefficient();
-        }
-      else
-        {
-          // 0.01 = 1% melt
-          return reference_permeability * std::pow(0.01,3.0) / eta_f;
-        }
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    ReactiveFluidTransport<dim>::
-    tian_equilibrium_bound_water_content (const MaterialModel::MaterialModelInputs<dim> &in,
-                                          unsigned int q) const
-    {
-      // Create arrays that will store the values of the polynomials at the current pressure
-      std::vector<double> LR_values(4);
-      std::vector<double> csat_values(4);
-      std::vector<double> Td_values(4);
-
-      // Loop over the four rock types (peridotite, gabbro, MORB, sediment) and the polynomial
-      // coefficients to fill the vectors defined above. The polynomials for LR are defined in
-      // equations 13, B2, B10, and B18. csat polynomials are defined in equations 14, B1, B9, and B17.
-      // Td polynomials are defined in equations 15, B3, B11, and B19.
-      for (unsigned int i = 0; i<devolatilization_enthalpy_changes.size(); ++i)
-        {
-          // Pressure, which must be in GPa for the parametrization, or GPa^-1. The polynomials for each lithology
-          // breaks down above certain pressures, make sure that we cap the pressure just before this break down.
-          // Introduce minimum pressure to avoid a division by 0.
-          const double minimum_pressure = 1e-12;
-          const double pressure = std::min(std::max(minimum_pressure, in.pressure[q]/1.e9), pressure_cutoffs[i]);
-          const double inverse_pressure = 1.0/pressure;
-          for (unsigned int j = 0; j<devolatilization_enthalpy_changes[i].size(); ++j)
-            {
-              LR_values[i] += devolatilization_enthalpy_changes[i][j] * std::pow(inverse_pressure, devolatilization_enthalpy_changes[i].size() - 1 - j);
-            }
-
-          for (unsigned int j = 0; j<water_mass_fractions[i].size(); ++j)
-            {
-              csat_values[i] += i==3 ? water_mass_fractions[i][j] * std::pow(std::log10(pressure), water_mass_fractions[i].size() - 1 - j) :\
-                                water_mass_fractions[i][j] * std::pow(pressure, water_mass_fractions[i].size() - 1 - j);
-            }
-
-          for (unsigned int j = 0; j<devolatilization_onset_temperatures[i].size(); ++j)
-            {
-              Td_values[i] += devolatilization_onset_temperatures[i][j] * std::pow(pressure, devolatilization_onset_temperatures[i].size() - 1 - j);
-            }
-        }
-
-      // Create an array for the equilibrium bound water content that is calculated from these polynomials
-      std::vector<double> eq_bound_water_content(4);
-
-      // Define the maximum bound water content allowed for the four different rock compositions
-      std::vector<double> max_bound_water_content = {tian_max_peridotite_water, tian_max_gabbro_water, tian_max_MORB_water, tian_max_sediment_water};
-
-      // Loop over all rock compositions and fill the equilibrium bound water content, divide by 100 to convert
-      // from percentage to fraction (equation 1)
-      for (unsigned int k = 0; k<LR_values.size(); ++k)
-        {
-          eq_bound_water_content[k] = (std::min(std::exp(csat_values[k]) * \
-                                                std::exp(std::exp(LR_values[k]) * (1/in.temperature[q] - 1/Td_values[k])), \
-                                                max_bound_water_content[k]) / 100.0);
-        }
-      return eq_bound_water_content;
-    }
-
-
-
-    template <int dim>
-    void
-    ReactiveFluidTransport<dim>::
-    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                    std::vector<double> &melt_fractions) const
-    {
-      for (unsigned int q=0; q<in.temperature.size(); ++q)
-        {
-          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-          switch (fluid_solid_reaction_scheme)
-            {
-              case no_reaction:
-              {
-                // No reactions occur between the solid and fluid phases,
-                // and the fluid volume fraction (stored in the melt_fractions
-                // vector) is equal to the porosity.
-                melt_fractions[q] = in.composition[q][porosity_idx];
-                break;
-              }
-              case zero_solubility:
-              {
-                // The fluid volume fraction in equilibrium with the solid
-                // at any point (stored in the melt_fractions vector) is
-                // equal to the sum of the bound fluid content and porosity.
-                const unsigned int bound_fluid_idx = this->introspection().compositional_index_for_name("bound_fluid");
-                melt_fractions[q] = in.composition[q][bound_fluid_idx] + in.composition[q][porosity_idx];
-                break;
-              }
-              case tian_approximation:
-              {
-                // The bound fluid content is calculated using parametrized phase
-                // diagrams for four different rock types: sediment, MORB, gabbro, and
-                // peridotite.
-                const unsigned int bound_fluid_idx = this->introspection().compositional_index_for_name("bound_fluid");
-                const unsigned int sediment_idx = this->introspection().compositional_index_for_name("sediment");
-                const unsigned int MORB_idx = this->introspection().compositional_index_for_name("MORB");
-                const unsigned int gabbro_idx = this->introspection().compositional_index_for_name("gabbro");
-                const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
-
-                // Initialize a vector that stores the compositions (mass fractions) for
-                // the four different rock compositions,
-                std::vector<double> tracked_rock_mass_fractions(4);
-                tracked_rock_mass_fractions[0] = (in.composition[q][peridotite_idx]);
-                tracked_rock_mass_fractions[1] = (in.composition[q][gabbro_idx]);
-                tracked_rock_mass_fractions[2] = (in.composition[q][MORB_idx]);
-                tracked_rock_mass_fractions[3] = (in.composition[q][sediment_idx]);
-
-                // The bound water content (water within the solid phase) for the four different rock types
-                std::vector<double> tian_eq_bound_water_content = tian_equilibrium_bound_water_content(in, q);
-
-                // average the water content between the four different rock types
-                double average_eq_bound_water_content = MaterialUtilities::average_value (tracked_rock_mass_fractions, tian_eq_bound_water_content, MaterialUtilities::arithmetic);
-
-                // The fluid volume fraction in equilibrium with the solid (stored in the melt_fractions vector)
-                // is equal to the sum of the porosity and the change in bound fluid content
-                // (current bound fluid - updated average bound fluid).
-                melt_fractions[q] = std::max(in.composition[q][bound_fluid_idx] + in.composition[q][porosity_idx] - average_eq_bound_water_content, 0.0);
-                break;
-              }
-              case katz2003:
-              {
-                melt_fractions[q] = katz2003_model.melt_fraction(in.temperature[q],
-                                                                 this->get_adiabatic_conditions().pressure(in.position[q]));
-                break;
-              }
-              default:
-              {
-                AssertThrow(false, ExcNotImplemented());
-                break;
-              }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    ReactiveFluidTransport<dim>::initialize()
-    {
-      base_model->initialize();
-    }
-
-
-
-    template <int dim>
-    void
-    ReactiveFluidTransport<dim>::update()
-    {
-      base_model->update();
-    }
-
-
-
-    template <int dim>
-    void
-    ReactiveFluidTransport<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                                          typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      base_model->evaluate(in,out);
-
-      if (fluid_solid_reaction_scheme != katz2003)
-        {
-          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-          // Modify the viscosity from the base model based on the presence of fluid.
-          if (in.requests_property(MaterialProperties::viscosity))
-            {
-              // Scale the base model viscosity value based on the porosity.
-              for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
-                {
-                  const double porosity = std::max(in.composition[q][porosity_idx],0.0);
-                  out.viscosities[q] *= (1.0 - porosity) * exp(- alpha_phi * porosity);
-                }
-            }
-
-          // Fill the melt outputs if they exist. Note that the MeltOutputs class was originally
-          // designed for two-phase flow material models in ASPECT that model the flow of melt,
-          // but can be reused for a geofluid of arbitrary composition.
-          MeltOutputs<dim> *fluid_out = out.template get_additional_output<MeltOutputs<dim>>();
-
-          if (fluid_out != nullptr)
-            {
-              for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
-                {
-                  double porosity = std::max(in.composition[q][porosity_idx],0.0);
-
-                  fluid_out->fluid_viscosities[q] = eta_f;
-                  fluid_out->permeabilities[q] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-
-                  fluid_out->fluid_densities[q] = reference_rho_f * std::exp(fluid_compressibility * (in.pressure[q] - this->get_surface_pressure()));
-
-                  if (in.requests_property(MaterialProperties::viscosity))
-                    {
-                      const double phi_0 = 0.05;
-
-                      // Limit the porosity to be no smaller than 1e-8 when
-                      // calculating fluid effects on viscosities.
-                      porosity = std::max(porosity,1e-8);
-                      fluid_out->compaction_viscosities[q] = std::max(std::min(out.viscosities[q] * shear_to_bulk_viscosity_ratio * phi_0/porosity, max_compaction_visc), min_compaction_visc);
-                    }
-                }
-            }
-
-          ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
-
-          // Fill reaction rate outputs if the model uses operator splitting.
-          // Specifically, change the porosity (representing the amount of free fluid)
-          // based on the water solubility and the fluid content.
-          if (this->get_parameters().use_operator_splitting && reaction_rate_out != nullptr)
-            {
-              std::vector<double> eq_free_fluid_fractions(out.n_evaluation_points());
-              melt_fractions(in, eq_free_fluid_fractions);
-
-              for (unsigned int q=0; q<out.n_evaluation_points(); ++q)
-                for (unsigned int c=0; c<in.composition[q].size(); ++c)
-                  {
-                    double porosity_change = eq_free_fluid_fractions[q] - in.composition[q][porosity_idx];
-                    // do not allow negative porosity
-                    if (in.composition[q][porosity_idx] + porosity_change < 0)
-                      porosity_change = -in.composition[q][porosity_idx];
-
-                    if (fluid_solid_reaction_scheme != katz2003)
-                      {
-                        const unsigned int bound_fluid_idx = this->introspection().compositional_index_for_name("bound_fluid");
-                        if (c == bound_fluid_idx && this->get_timestep_number() > 0)
-                          reaction_rate_out->reaction_rates[q][c] = - porosity_change / fluid_reaction_time_scale;
-                        else if (c == porosity_idx && this->get_timestep_number() > 0)
-                          reaction_rate_out->reaction_rates[q][c] = porosity_change / fluid_reaction_time_scale;
-                        else
-                          reaction_rate_out->reaction_rates[q][c] = 0.0;
-                      }
-                    else
-                      {
-                        if (c == porosity_idx && this->get_timestep_number() > 0)
-                          reaction_rate_out->reaction_rates[q][c] = porosity_change / fluid_reaction_time_scale;
-                        else
-                          reaction_rate_out->reaction_rates[q][c] = 0.0;
-                      }
-
-                  }
-            }
-        }
-      else
-        {
-          katz2003_model.calculate_reaction_rate_outputs(in, out);
-          katz2003_model.calculate_fluid_outputs(in, out, reference_T);
-        }
-    }
-
-    template <int dim>
-    void
-    ReactiveFluidTransport<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Reactive Fluid Transport Model");
-        {
-          prm.enter_subsection("Katz 2003 model");
-          {
-            // read in melting model parameters
-            ReactionModel::Katz2003MantleMelting<dim>::declare_parameters(prm);
-          }
-          prm.leave_subsection();
-
-          prm.declare_entry("Base model","visco plastic",
-                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
-                            "The name of a material model incorporating the "
-                            "addition of fluids. Valid values for this parameter "
-                            "are the names of models that are also valid for the "
-                            "``Material models/Model name'' parameter. See the documentation for "
-                            "that for more information.");
-          prm.declare_entry ("Reference fluid density", "2500",
-                             Patterns::Double (0),
-                             "Reference density of the melt/fluid$\\rho_{f,0}$. Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Shear to bulk viscosity ratio", "0.1",
-                             Patterns::Double (0),
-                             "Ratio between shear and bulk viscosity at the reference "
-                             "permeability $\\phi_0=0.05$. The bulk viscosity additionally "
-                             "scales with $\\phi_0/\\phi$. The shear viscosity is read in "
-                             "from the base model. Units: dimensionless.");
-          prm.declare_entry ("Minimum compaction viscosity", "0",
-                             Patterns::Double (0),
-                             "Lower cutoff for the compaction viscosity. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Maximum compaction viscosity",
-                             boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
-                             Patterns::Double (0),
-                             "Upper cutoff for the compaction viscosity. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Reference fluid viscosity", "10",
-                             Patterns::Double (0),
-                             "The value of the constant melt/fluid viscosity $\\eta_f$. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Exponential fluid weakening factor", "27",
-                             Patterns::Double (0),
-                             "The porosity dependence of the viscosity. Units: dimensionless.");
-          prm.declare_entry ("Reference permeability", "1e-8",
-                             Patterns::Double(),
-                             "Reference permeability of the solid host rock."
-                             "Units: \\si{\\meter\\squared}.");
-          prm.declare_entry ("Fluid compressibility", "0.0",
-                             Patterns::Double (0),
-                             "The value of the compressibility of the fluid. "
-                             "Units: \\si{\\per\\pascal}.");
-          prm.declare_entry ("Fluid reaction time scale for operator splitting", "1e3",
-                             Patterns::Double (0),
-                             "In case the operator splitting scheme is used, the porosity field can not "
-                             "be set to a new equilibrium fluid fraction instantly, but the model has to "
-                             "provide a reaction time scale instead. This time scale defines how fast fluid "
-                             "release and absorption happen, or more specifically, the parameter defines the "
-                             "time after which the deviation of the porosity from the free fluid fraction "
-                             "that would be in equilibrium with the solid will be reduced to a fraction of "
-                             "$1/e$. So if the fluid reaction time scale is small compared "
-                             "to the time step size, the reaction will be so fast that the porosity is very "
-                             "close to this equilibrium value after reactions are computed. Conversely, "
-                             "if the fluid reaction time scale is large compared to the time step size, almost no "
-                             "fluid release and absorption will occur."
-                             "\n\n"
-                             "Also note that the fluid reaction time scale has to be larger than or equal to the reaction "
-                             "time step used in the operator splitting scheme, otherwise reactions can not be "
-                             "computed. If the model does not use operator splitting, this parameter is not used. "
-                             "Units: yr or s, depending on the ``Use years "
-                             "in output instead of seconds'' parameter.");
-          prm.declare_entry ("Maximum weight percent water in sediment", "3",
-                             Patterns::Double (0),
-                             "The maximum allowed weight percent that the sediment composition can hold.");
-          prm.declare_entry ("Maximum weight percent water in MORB", "2",
-                             Patterns::Double (0),
-                             "The maximum allowed weight percent that the sediment composition can hold.");
-          prm.declare_entry ("Maximum weight percent water in gabbro", "1",
-                             Patterns::Double (0),
-                             "The maximum allowed weight percent that the sediment composition can hold.");
-          prm.declare_entry ("Maximum weight percent water in peridotite", "8",
-                             Patterns::Double (0),
-                             "The maximum allowed weight percent that the sediment composition can hold.");
-          prm.declare_entry ("Fluid-solid reaction scheme", "no reaction",
-                             Patterns::Selection("no reaction|zero solubility|tian approximation|katz2003"),
-                             "Select what type of scheme to use for reactions between fluid and solid phases. "
-                             "The current available options are models where no reactions occur between "
-                             "the two phases, or the solid phase is insoluble (zero solubility) and all "
-                             "of the bound fluid is released into the fluid phase, tian approximation "
-                             "use polynomials to describe hydration and dehydration reactions for four different "
-                             "rock compositions as defined in Tian et al., 2019, or the Katz et. al. 2003 mantle "
-                             "melting model. If the Katz 2003 melting model is used, its parameters are declared "
-                             "in its own subsection.");
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$ for the katz2003 reaction model. "
-                             "The reference temperature is used in both the density and "
-                             "viscosity formulas of this model. Units: \\si{\\kelvin}.");
-        }
-        prm.leave_subsection();
-
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    ReactiveFluidTransport<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Reactive Fluid Transport Model");
-        {
-          AssertThrow( prm.get("Base model") != "reactive fluid transport",
-                       ExcMessage("You may not use ``reactive fluid transport'' "
-                                  "as the base model for the reactive fluid transport "
-                                  "model itself.") );
-
-          reference_rho_f                   = prm.get_double ("Reference fluid density");
-          shear_to_bulk_viscosity_ratio     = prm.get_double ("Shear to bulk viscosity ratio");
-          max_compaction_visc               = prm.get_double ("Maximum compaction viscosity");
-          min_compaction_visc               = prm.get_double ("Minimum compaction viscosity");
-          eta_f                             = prm.get_double ("Reference fluid viscosity");
-          reference_permeability            = prm.get_double ("Reference permeability");
-          alpha_phi                         = prm.get_double ("Exponential fluid weakening factor");
-          fluid_compressibility             = prm.get_double ("Fluid compressibility");
-          fluid_reaction_time_scale         = prm.get_double ("Fluid reaction time scale for operator splitting");
-          reference_T                       = prm.get_double ("Reference temperature");
-
-          tian_max_peridotite_water         = prm.get_double ("Maximum weight percent water in peridotite");
-          tian_max_gabbro_water             = prm.get_double ("Maximum weight percent water in gabbro");
-          tian_max_MORB_water               = prm.get_double ("Maximum weight percent water in MORB");
-          tian_max_sediment_water           = prm.get_double ("Maximum weight percent water in sediment");
-
-          // Create the base model and initialize its SimulatorAccess base
-          // class; it will get a chance to read its parameters below after we
-          // leave the current section.
-          base_model = create_material_model<dim>(prm.get("Base model"));
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
-            sim->initialize_simulator (this->get_simulator());
-
-          if (this->convert_output_to_years() == true)
-            fluid_reaction_time_scale *= year_in_seconds;
-
-          // Reaction scheme parameter
-          if (prm.get ("Fluid-solid reaction scheme") == "zero solubility")
-            {
-              fluid_solid_reaction_scheme = zero_solubility;
-            }
-          else if (prm.get ("Fluid-solid reaction scheme") == "no reaction")
-            {
-              fluid_solid_reaction_scheme = no_reaction;
-            }
-          else if (prm.get ("Fluid-solid reaction scheme") == "tian approximation")
-            {
-              AssertThrow(this->introspection().compositional_name_exists("sediment"),
-                          ExcMessage("The Tian approximation only works "
-                                     "if there is a compositional field called sediment."));
-              AssertThrow(this->introspection().compositional_name_exists("MORB"),
-                          ExcMessage("The Tian approximation only works "
-                                     "if there is a compositional field called MORB."));
-              AssertThrow(this->introspection().compositional_name_exists("gabbro"),
-                          ExcMessage("The Tian approximation only works "
-                                     "if there is a compositional field called gabbro."));
-              AssertThrow(this->introspection().compositional_name_exists("peridotite"),
-                          ExcMessage("The Tian approximation only works "
-                                     "if there is a compositional field called peridotite."));
-              fluid_solid_reaction_scheme = tian_approximation;
-            }
-          else if (prm.get ("Fluid-solid reaction scheme") == "katz2003")
-            {
-              fluid_solid_reaction_scheme = katz2003;
-              prm.enter_subsection("Katz 2003 model");
-              {
-                katz2003_model.initialize_simulator (this->get_simulator());
-                katz2003_model.parse_parameters(prm);
-              }
-              prm.leave_subsection();
-            }
-          else
-            AssertThrow(false, ExcMessage("Not a valid fluid-solid reaction scheme"));
-
-          if (fluid_solid_reaction_scheme == no_reaction)
-            {
-              AssertThrow(this->get_parameters().use_operator_splitting == false,
-                          ExcMessage("The Fluid-reaction scheme no reaction should not be used with operator splitting."));
-            }
-
-          if (fluid_solid_reaction_scheme == zero_solubility)
-            {
-              AssertThrow(this->get_parameters().use_operator_splitting,
-                          ExcMessage("The Fluid-reaction scheme zero solubility must be used with operator splitting."));
-            }
-
-          if (fluid_solid_reaction_scheme == tian_approximation)
-            {
-              AssertThrow(this->get_parameters().use_operator_splitting,
-                          ExcMessage("The Fluid-reaction scheme tian approximation must be used with operator splitting."));
-            }
-
-          if (this->get_parameters().use_operator_splitting)
-            {
-              if (this->get_parameters().reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
-                AssertThrow(fluid_reaction_time_scale >= this->get_parameters().reaction_time_step,
-                            ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
-                                       + " in the operator splitting scheme is too large to compute fluid release rates! "
-                                       "You have to choose it in such a way that it is smaller than the 'Fluid reaction time scale for "
-                                       "operator splitting' chosen in the material model, which is currently "
-                                       + Utilities::to_string(fluid_reaction_time_scale) + "."));
-              AssertThrow(fluid_reaction_time_scale > 0,
-                          ExcMessage("The Fluid reaction time scale for operator splitting must be larger than 0!"));
-            }
-
-          AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                      ExcMessage("Material model Reactive Fluid Transport only "
-                                 "works if there is a compositional field called porosity."));
-
-          if (fluid_solid_reaction_scheme != katz2003)
-            {
-              AssertThrow(this->introspection().compositional_name_exists("bound_fluid"),
-                          ExcMessage("Material model Reactive Fluid Transport only "
-                                     "works if there is a compositional field called bound_fluid."));
-            }
-          else
-            {
-              AssertThrow(this->introspection().compositional_name_exists("peridotite"),
-                          ExcMessage("Material model Katz 2003 Mantle Melting only "
-                                     "works if there is a compositional field called peridotite."));
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // After parsing the parameters for this model, parse parameters related to the base model.
-      base_model->parse_parameters(prm);
-      this->model_dependence = base_model->get_model_dependence();
-      if (fluid_solid_reaction_scheme == zero_solubility)
-        {
-          AssertThrow(this->get_material_model().is_compressible() == false,
-                      ExcMessage("The Fluid-reaction scheme zero solubility must be used with an incompressible base model."));
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    ReactiveFluidTransport<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (this->get_parameters().use_operator_splitting
-          && out.template get_additional_output<ReactionRateOutputs<dim>>() == nullptr)
-        {
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ReactionRateOutputs<dim>> (out.n_evaluation_points(), this->n_compositional_fields()));
-        }
-      base_model->create_additional_named_outputs(out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ReactiveFluidTransport,
-                                   "reactive fluid transport",
-                                   "Material model that is designed to advect fluids and compute "
-                                   "fluid release and absorption based on different models for "
-                                   "fluid-rock interaction. At present, models where no fluid-rock "
-                                   "interactions occur or the solid has zero solubility are available. "
-                                   "The properties of the solid can be taken from another material model "
-                                   "that is used as a base model.")
-  }
-}
diff --git a/source/material_model/replace_lithosphere_viscosity.cc.bak b/source/material_model/replace_lithosphere_viscosity.cc.bak
deleted file mode 100644
index 1107255f18d..00000000000
--- a/source/material_model/replace_lithosphere_viscosity.cc.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/replace_lithosphere_viscosity.h>
-#include <aspect/initial_temperature/lithosphere_mask.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <limits>
-
-#include <array>
-#include <utility>
-
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    ReplaceLithosphereViscosity<dim>::initialize()
-    {
-      base_model->initialize();
-
-      lab_depth_lookup.initialize();
-    }
-
-
-    template <int dim>
-    void
-    ReplaceLithosphereViscosity<dim>::evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                                               typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      base_model->evaluate(in,out);
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double depth = this->SimulatorAccess<dim>::get_geometry_model().depth(in.position[i]);
-          const double lab_depth = lab_depth_lookup.get_lab_depth(in.position[i]);
-
-          if (depth <= lab_depth)
-            out.viscosities[i] = lithosphere_viscosity;
-        }
-
-    }
-
-
-    template <int dim>
-    void
-    ReplaceLithosphereViscosity<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Replace lithosphere viscosity");
-        {
-          prm.declare_entry("Base model","simple",
-                            Patterns::Selection(MaterialModel::get_valid_model_names_pattern<dim>()),
-                            "The name of a material model that will be modified by a replacing"
-                            "the viscosity in the lithosphere by a constant value. Valid values for this parameter "
-                            "are the names of models that are also valid for the "
-                            "``Material models/Model name'' parameter. See the documentation for "
-                            "more information.");
-          prm.declare_entry ("Lithosphere viscosity", "1e23",
-                             Patterns::Double (0.),
-                             "The viscosity within lithosphere, applied above"
-                             "the maximum lithosphere depth.");
-
-          InitialTemperature::LABDepth::LABDepthLookup<dim>::declare_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    ReplaceLithosphereViscosity<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      AssertThrow (dim == 3,
-                   ExcMessage ("The 'Replace lithosphere viscosity' material model "
-                               "is only available for 3d computations."));
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Replace lithosphere viscosity");
-        {
-          AssertThrow( prm.get("Base model") != "replace lithosphere viscosity",
-                       ExcMessage("You may not use ``replace lithosphere viscosity'' as the base model for "
-                                  "a replace lithosphere viscosity model.") );
-
-          // create the base model and initialize its SimulatorAccess base
-          // class; it will get a chance to read its parameters below after we
-          // leave the current section
-          base_model = create_material_model<dim>(prm.get("Base model"));
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(base_model.get()))
-            sim->initialize_simulator (this->get_simulator());
-
-          lab_depth_lookup.initialize_simulator(this->get_simulator());
-          lab_depth_lookup.parse_parameters(prm);
-          lithosphere_viscosity   = prm.get_double ("Lithosphere viscosity");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      /* After parsing the parameters for replace lithosphere viscosity, it is essential to parse
-      parameters related to the base model. */
-      base_model->parse_parameters(prm);
-      this->model_dependence = base_model->get_model_dependence();
-    }
-
-    template <int dim>
-    bool
-    ReplaceLithosphereViscosity<dim>::
-    is_compressible () const
-    {
-      return base_model->is_compressible();
-    }
-
-    template <int dim>
-    void
-    ReplaceLithosphereViscosity<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      base_model->create_additional_named_outputs(out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ReplaceLithosphereViscosity,
-                                   "replace lithosphere viscosity",
-                                   "The ``replace lithosphere viscosity'' Material model sets viscosity to a "
-                                   "prescribed constant above the lithosphere-asthenosphere boundary (specified by "
-                                   "an ascii file or maximum lithosphere depth). Below the lithosphere-asthenosphere"
-                                   "boundary the viscosity is taken from any of the other available material model. "
-                                   "In other words, it is a ``compositing material model''."
-                                   "\n"
-                                   "Parameters related to the replace lithosphere viscosity model are read from a subsection "
-                                   "``Material model/Replace lithosphere viscosity''. "
-                                   "The user must specify a ``Base model'' from which other material properties are "
-                                   "derived.  "
-                                   "\n"
-                                   "Note the required format of the input data file: The first lines may "
-                                   "contain any number of comments if they begin with ‘#’, but one of these lines "
-                                   "needs to contain the number of grid points in each dimension as for example "
-                                   "‘# POINTS: 3 3’. For a spherical model, the order of the data columns has to be"
-                                   "'phi', 'theta','depth (m)', where phi is the  azimuth angle and theta is the "
-                                   "polar angle measured positive from the north pole.")
-  }
-}
diff --git a/source/material_model/rheology/ascii_depth_profile.cc.bak b/source/material_model/rheology/ascii_depth_profile.cc.bak
deleted file mode 100644
index 7b2a90bb529..00000000000
--- a/source/material_model/rheology/ascii_depth_profile.cc.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/material_model/rheology/ascii_depth_profile.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-
-      template <int dim>
-      AsciiDepthProfile<dim>::AsciiDepthProfile ()
-        = default;
-
-
-
-      template <int dim>
-      void
-      AsciiDepthProfile<dim>::initialize ()
-      {
-        this->initialize(this->get_mpi_communicator());
-        viscosity_index = this->get_column_index_from_name("viscosity");
-      }
-
-
-
-      template <int dim>
-      double
-      AsciiDepthProfile<dim>::compute_viscosity (const double depth) const
-      {
-        return this->get_data_component (Point<1>(depth), viscosity_index);
-      }
-
-
-
-      template <int dim>
-      void
-      AsciiDepthProfile<dim>::declare_parameters (ParameterHandler &prm,
-                                                  const std::string &subsection_name)
-      {
-        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                          "$ASPECT_SOURCE_DIR/data/material-model/rheology/",
-                                                          "ascii_depth_profile.txt",
-                                                          subsection_name);
-      }
-
-
-
-      template <int dim>
-      void
-      AsciiDepthProfile<dim>::parse_parameters (ParameterHandler &prm,
-                                                const std::string &subsection_name)
-      {
-        Utilities::AsciiDataBase<dim>::parse_parameters(prm,
-                                                        subsection_name);
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class AsciiDepthProfile<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/composite_visco_plastic.cc.bak b/source/material_model/rheology/composite_visco_plastic.cc.bak
deleted file mode 100644
index 39ea0204c7b..00000000000
--- a/source/material_model/rheology/composite_visco_plastic.cc.bak
+++ /dev/null
@@ -1,458 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/composite_visco_plastic.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      // The following function is not yet used by ASPECT, so
-      // it is commented out to avoid tester issues.
-      //
-      // It will provide useful output when a material model which
-      // uses the CompositeViscoPlastic rheology has been implemented.
-      //
-      // The composite visco plastic rheology calculates the decomposed strain
-      // rates for each of the following deformation mechanisms:
-      // diffusion creep, dislocation creep, Peierls creep,
-      // Drucker-Prager plasticity and a constant (high) viscosity limiter.
-      // The values are provided in this order as a vector of additional
-      // outputs. If the user declares one or more mechanisms inactive
-      // (by assigning use_mechanism = False) then the corresponding
-      // strain rate output will be equal to zero.
-      //namespace
-      //{
-      //  std::vector<std::string> make_strain_rate_additional_outputs_names()
-      //  {
-      //    std::vector<std::string> names;
-      //    names.emplace_back("edot_diffusion");
-      //    names.emplace_back("edot_dislocation");
-      //    names.emplace_back("edot_peierls");
-      //    names.emplace_back("edot_drucker_prager");
-      //    names.emplace_back("edot_limiter");
-      //    return names;
-      //  }
-      //}
-
-
-      template <int dim>
-      CompositeViscoPlastic<dim>::CompositeViscoPlastic ()
-        = default;
-
-
-
-      template <int dim>
-      double
-      CompositeViscoPlastic<dim>::compute_viscosity (const double pressure,
-                                                     const double temperature,
-                                                     const std::vector<double> &volume_fractions,
-                                                     const SymmetricTensor<2,dim> &strain_rate,
-                                                     std::vector<double> &partial_strain_rates,
-                                                     const std::vector<double> &phase_function_values,
-                                                     const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        double viscosity = 0.;
-        partial_strain_rates.resize(5, 0.);
-
-        // Isostrain averaging
-        double total_volume_fraction = 1.;
-        for (unsigned int composition=0; composition < number_of_compositions; ++composition)
-          {
-            // Only include the contribution to the viscosity
-            // from a given composition if the volume fraction exceeds
-            // a certain (small) fraction.
-            if (volume_fractions[composition] > 2.*std::numeric_limits<double>::epsilon())
-              {
-                std::vector<double> partial_strain_rates_composition(5, 0.);
-                viscosity += (volume_fractions[composition]
-                              * compute_composition_viscosity (pressure,
-                                                               temperature,
-                                                               composition,
-                                                               strain_rate,
-                                                               partial_strain_rates_composition,
-                                                               phase_function_values,
-                                                               n_phase_transitions_per_composition));
-                for (unsigned int j=0; j < 5; ++j)
-                  partial_strain_rates[j] += volume_fractions[composition] * partial_strain_rates_composition[j];
-              }
-            else
-              {
-                total_volume_fraction -= volume_fractions[composition];
-              }
-
-            viscosity /= total_volume_fraction;
-            for (unsigned int j=0; j < 5; ++j)
-              partial_strain_rates[j] /= total_volume_fraction;
-          }
-        return viscosity;
-      }
-
-
-
-      template <int dim>
-      double
-      CompositeViscoPlastic<dim>::compute_composition_viscosity (const double pressure,
-                                                                 const double temperature,
-                                                                 const unsigned int composition,
-                                                                 const SymmetricTensor<2,dim> &strain_rate,
-                                                                 std::vector<double> &partial_strain_rates,
-                                                                 const std::vector<double> &phase_function_values,
-                                                                 const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        // If strain rate is zero (like during the first time step) set it to some very small number
-        // to prevent a division-by-zero, and a floating point exception.
-        // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
-        // strain rate (often simplified as epsilondot_ii)
-        const double edot_ii = std::max(std::sqrt(std::max(-second_invariant(deviator(strain_rate)), 0.)),
-                                        min_strain_rate);
-
-        Rheology::DiffusionCreepParameters diffusion_creep_parameters;
-        Rheology::DislocationCreepParameters dislocation_creep_parameters;
-        Rheology::PeierlsCreepParameters peierls_creep_parameters;
-        Rheology::DruckerPragerParameters drucker_prager_parameters;
-
-        double eta_diff = maximum_viscosity;
-        double eta_disl = maximum_viscosity;
-        double eta_prls = maximum_viscosity;
-
-        if (use_diffusion_creep)
-          {
-            diffusion_creep_parameters = diffusion_creep->compute_creep_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
-            eta_diff = diffusion_creep->compute_viscosity(pressure, temperature, composition, phase_function_values, n_phase_transitions_per_composition);
-          }
-
-        if (use_dislocation_creep)
-          {
-            dislocation_creep_parameters = dislocation_creep->compute_creep_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
-            eta_disl = dislocation_creep->compute_viscosity(edot_ii, pressure, temperature, composition, phase_function_values, n_phase_transitions_per_composition);
-          }
-
-        if (use_peierls_creep)
-          {
-            peierls_creep_parameters = peierls_creep->compute_creep_parameters(composition);
-            eta_prls = peierls_creep->compute_approximate_viscosity(edot_ii, pressure, temperature, composition);
-          }
-        // First guess at a stress using diffusion, dislocation, and Peierls creep viscosities calculated with the total second strain rate invariant.
-        const double eta_guess = std::min(std::max(minimum_viscosity, eta_diff*eta_disl*eta_prls/(eta_diff*eta_disl + eta_diff*eta_prls + eta_disl*eta_prls)), maximum_viscosity);
-
-        double creep_stress = 2.*eta_guess*edot_ii;
-
-        // Crude modification of the creep stress to be no higher than the
-        // Drucker-Prager yield stress. Probably fine for a first guess.
-        if (use_drucker_prager)
-          {
-            drucker_prager_parameters = drucker_prager->compute_drucker_prager_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
-            const double yield_stress = drucker_prager->compute_yield_stress(drucker_prager_parameters.cohesion,
-                                                                             drucker_prager_parameters.angle_internal_friction,
-                                                                             pressure,
-                                                                             drucker_prager_parameters.max_yield_stress);
-
-            creep_stress = std::min(creep_stress, yield_stress);
-          }
-
-        // In this rheology model, the total strain rate is partitioned between
-        // different flow laws. We do not know how the strain is partitioned
-        // between these flow laws, nor do we know the creep stress, which is
-        // required to calculate the partitioning.
-
-        // The following while loop conducts a Newton iteration to obtain the
-        // creep stress, which we need in order to calculate the viscosity.
-        double strain_rate_residual = 2*strain_rate_residual_threshold;
-        double strain_rate_deriv = 0;
-        unsigned int stress_iteration = 0;
-        while (std::abs(strain_rate_residual) > strain_rate_residual_threshold
-               && stress_iteration < stress_max_iteration_number)
-          {
-
-            const std::pair<double, double> creep_edot_and_deriv = compute_strain_rate_and_derivative (creep_stress,
-                                                                   pressure,
-                                                                   temperature,
-                                                                   diffusion_creep_parameters,
-                                                                   dislocation_creep_parameters,
-                                                                   peierls_creep_parameters,
-                                                                   drucker_prager_parameters);
-
-            const double strain_rate = creep_stress/(2.*maximum_viscosity) + (maximum_viscosity/(maximum_viscosity - minimum_viscosity))*creep_edot_and_deriv.first;
-            strain_rate_deriv = 1./(2.*maximum_viscosity) + (maximum_viscosity/(maximum_viscosity - minimum_viscosity))*creep_edot_and_deriv.second;
-
-            strain_rate_residual = strain_rate - edot_ii;
-
-            // If the strain rate derivative is zero, we catch it below.
-            if (strain_rate_deriv>std::numeric_limits<double>::min())
-              creep_stress -= strain_rate_residual/strain_rate_deriv;
-            stress_iteration += 1;
-
-            // If anything that would be used in the next iteration is not finite, the
-            // Newton iteration would trigger an exception and we want to abort the
-            // iteration instead.
-            // Currently, we still throw an exception, but if this exception is thrown,
-            // another more robust iterative scheme should be implemented
-            // (similar to that seen in the diffusion-dislocation material model).
-            const bool abort_newton_iteration = !numbers::is_finite(creep_stress)
-                                                || !numbers::is_finite(strain_rate_residual)
-                                                || !numbers::is_finite(strain_rate_deriv)
-                                                || strain_rate_deriv < std::numeric_limits<double>::min()
-                                                || stress_iteration == stress_max_iteration_number;
-            AssertThrow(!abort_newton_iteration,
-                        ExcMessage("No convergence has been reached in the loop that determines "
-                                   "the composite viscous creep stress. Aborting! "
-                                   "Residual is " + Utilities::to_string(strain_rate_residual) +
-                                   " after " + Utilities::to_string(stress_iteration) + " iterations. "
-                                   "You can increase the number of iterations by adapting the "
-                                   "parameter 'Maximum creep strain rate iterations'."));
-          }
-
-        // The creep stress is not the total stress, so we still need to do a little work to obtain the effective viscosity.
-        // First, we compute the stress running through the strain rate limiter, and then add that to the creep stress
-        // NOTE: The viscosity of the strain rate limiter is equal to (minimum_viscosity*maximum_viscosity)/(maximum_viscosity - minimum_viscosity)
-        const double lim_stress = 2.*minimum_viscosity*(edot_ii - creep_stress/(2.*maximum_viscosity));
-        const double total_stress = creep_stress + lim_stress;
-
-        // Compute the strain rate experienced by the different mechanisms
-        // These should sum to the total strain rate
-
-        // The components of partial_strain_rates must be provided in the order
-        // dictated by make_strain_rate_additional_outputs_names
-        if (use_diffusion_creep)
-          {
-            const std::pair<double, double> diff_edot_and_deriv = diffusion_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, diffusion_creep_parameters);
-            partial_strain_rates[0] = diff_edot_and_deriv.first;
-          }
-
-        if (use_dislocation_creep)
-          {
-            const std::pair<double, double> disl_edot_and_deriv = dislocation_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, dislocation_creep_parameters);
-            partial_strain_rates[1] = disl_edot_and_deriv.first;
-          }
-
-        if (use_peierls_creep)
-          {
-            const std::pair<double, double> prls_edot_and_deriv = peierls_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, peierls_creep_parameters);
-            partial_strain_rates[2] = prls_edot_and_deriv.first;
-          }
-
-        if (use_drucker_prager)
-          {
-            const std::pair<double, double> drpr_edot_and_deriv = drucker_prager->compute_strain_rate_and_derivative(creep_stress, pressure, drucker_prager_parameters);
-            partial_strain_rates[3] = drpr_edot_and_deriv.first;
-          }
-
-        partial_strain_rates[4] = total_stress/(2.*maximum_viscosity);
-
-        // Now we return the viscosity using the total stress
-        return total_stress/(2.*edot_ii);
-      }
-
-
-
-      // Overload the + operator to act on two pairs of doubles.
-      std::pair<double,double> operator+(const std::pair<double,double> &x, const std::pair<double,double> &y)
-      {
-        return std::make_pair(x.first+y.first, x.second+y.second);
-      }
-
-
-
-      template <int dim>
-      std::pair<double, double>
-      CompositeViscoPlastic<dim>::compute_strain_rate_and_derivative (const double creep_stress,
-                                                                      const double pressure,
-                                                                      const double temperature,
-                                                                      const DiffusionCreepParameters diffusion_creep_parameters,
-                                                                      const DislocationCreepParameters dislocation_creep_parameters,
-                                                                      const PeierlsCreepParameters peierls_creep_parameters,
-                                                                      const DruckerPragerParameters drucker_prager_parameters) const
-      {
-        std::pair<double, double> creep_edot_and_deriv = std::make_pair(0., 0.);
-
-        if (use_diffusion_creep)
-          creep_edot_and_deriv = creep_edot_and_deriv + diffusion_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, diffusion_creep_parameters);
-
-        if (use_dislocation_creep)
-          creep_edot_and_deriv = creep_edot_and_deriv + dislocation_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, dislocation_creep_parameters);
-
-        if (use_peierls_creep)
-          creep_edot_and_deriv = creep_edot_and_deriv + peierls_creep->compute_strain_rate_and_derivative(creep_stress, pressure, temperature, peierls_creep_parameters);
-
-        if (use_drucker_prager)
-          creep_edot_and_deriv = creep_edot_and_deriv + drucker_prager->compute_strain_rate_and_derivative(creep_stress, pressure, drucker_prager_parameters);
-
-        return creep_edot_and_deriv;
-      }
-
-
-
-      template <int dim>
-      void
-      CompositeViscoPlastic<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Include diffusion creep in composite rheology", "true",
-                           Patterns::Bool (),
-                           "Whether to include diffusion creep in the composite rheology formulation.");
-
-        prm.declare_entry ("Include dislocation creep in composite rheology", "true",
-                           Patterns::Bool (),
-                           "Whether to include dislocation creep in the composite rheology formulation.");
-
-        prm.declare_entry ("Include Peierls creep in composite rheology", "true",
-                           Patterns::Bool (),
-                           "Whether to include Peierls creep in the composite rheology formulation.");
-
-        prm.declare_entry ("Include Drucker Prager plasticity in composite rheology", "true",
-                           Patterns::Bool (),
-                           "Whether to include Drucker-Prager plasticity in the composite rheology formulation.");
-
-        // Diffusion creep parameters
-        Rheology::DiffusionCreep<dim>::declare_parameters(prm);
-
-        // Dislocation creep parameters
-        Rheology::DislocationCreep<dim>::declare_parameters(prm);
-
-        // Dislocation creep parameters
-        Rheology::PeierlsCreep<dim>::declare_parameters(prm);
-
-        // Drucker Prager parameters
-        Rheology::DruckerPrager<dim>::declare_parameters(prm);
-
-        // Some of the parameters below are shared with the subordinate
-        // rheology models (diffusion, dislocation, ...),
-        // and will already have been declared. This is fine, the deal.II
-        // parameter handler allows repeated declarations. The default values
-        // below will override any defaults given in the subordinate
-        // rheology models. The new defaults will apply both to
-        // this rheology model and to the subordinate rheology modules.
-        prm.declare_entry ("Minimum strain rate", "1.4e-20", Patterns::Double(0.),
-                           "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}.");
-
-        // Viscosity iteration parameters
-        prm.declare_entry ("Strain rate residual tolerance", "1e-22", Patterns::Double(0.),
-                           "Tolerance for correct diffusion/dislocation strain rate ratio.");
-        prm.declare_entry ("Maximum creep strain rate iterations", "40", Patterns::Integer(0),
-                           "Maximum number of iterations to find the correct "
-                           "creep strain rate.");
-
-        // Strain rate and stress limiting parameters
-        prm.declare_entry ("Minimum viscosity", "1.e17",
-                           Patterns::Double(0.),
-                           "Minimum effective viscosity. Units: \\si{\\pascal\\second}.");
-
-        prm.declare_entry ("Maximum viscosity", "1.e28",
-                           Patterns::Double(0.),
-                           "Maximum effective viscosity. Units: \\si{\\pascal\\second}.");
-      }
-
-
-
-      template <int dim>
-      void
-      CompositeViscoPlastic<dim>::parse_parameters (ParameterHandler &prm,
-                                                    const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
-      {
-        // Retrieve the list of composition names
-        const std::vector<std::string> list_of_composition_names = this->introspection().get_composition_names();
-
-        // A background field is required by the subordinate material models
-        number_of_compositions = list_of_composition_names.size() + 1;
-
-        min_strain_rate = prm.get_double("Minimum strain rate");
-
-        // Iteration parameters
-        strain_rate_residual_threshold = prm.get_double ("Strain rate residual tolerance");
-        stress_max_iteration_number = prm.get_integer ("Maximum creep strain rate iterations");
-
-        // Read min and max viscosity parameters
-        minimum_viscosity = prm.get_double ("Minimum viscosity");
-        maximum_viscosity = prm.get_double ("Maximum viscosity");
-
-        // Rheological parameters
-
-        // Diffusion creep parameters
-        use_diffusion_creep = prm.get_bool ("Include diffusion creep in composite rheology");
-        if (use_diffusion_creep)
-          {
-            diffusion_creep = std::make_unique<Rheology::DiffusionCreep<dim>>();
-            diffusion_creep->initialize_simulator (this->get_simulator());
-            diffusion_creep->parse_parameters(prm, expected_n_phases_per_composition);
-          }
-
-        // Dislocation creep parameters
-        use_dislocation_creep = prm.get_bool ("Include dislocation creep in composite rheology");
-        if (use_dislocation_creep)
-          {
-            dislocation_creep = std::make_unique<Rheology::DislocationCreep<dim>>();
-            dislocation_creep->initialize_simulator (this->get_simulator());
-            dislocation_creep->parse_parameters(prm, expected_n_phases_per_composition);
-          }
-
-        // Peierls creep parameters
-        use_peierls_creep = prm.get_bool ("Include Peierls creep in composite rheology");
-        if (use_peierls_creep)
-          {
-            peierls_creep = std::make_unique<Rheology::PeierlsCreep<dim>>();
-            peierls_creep->initialize_simulator (this->get_simulator());
-            peierls_creep->parse_parameters(prm, expected_n_phases_per_composition);
-          }
-
-        // Drucker Prager parameters
-        use_drucker_prager = prm.get_bool ("Include Drucker Prager plasticity in composite rheology");
-        if (use_drucker_prager)
-          {
-            drucker_prager = std::make_unique<Rheology::DruckerPrager<dim>>();
-            drucker_prager->initialize_simulator (this->get_simulator());
-            drucker_prager->parse_parameters(prm, expected_n_phases_per_composition);
-
-            AssertThrow(prm.get_bool("Use plastic damper") && prm.get_double("Plastic damper viscosity") > 0.,
-                        ExcMessage("If Drucker-Prager plasticity is included in the rheological formulation, you must use a viscous damper with a positive viscosity."));
-          }
-
-        AssertThrow(use_diffusion_creep == true || use_dislocation_creep == true || use_peierls_creep == true || use_drucker_prager == true,
-                    ExcMessage("You need to include at least one deformation mechanism."));
-
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class CompositeViscoPlastic<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/compositional_viscosity_prefactors.cc.bak b/source/material_model/rheology/compositional_viscosity_prefactors.cc.bak
deleted file mode 100644
index 45dae88661a..00000000000
--- a/source/material_model/rheology/compositional_viscosity_prefactors.cc.bak
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/compositional_viscosity_prefactors.h>
-#include <aspect/utilities.h>
-#include <aspect/global.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/parameters.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      template <int dim>
-      CompositionalViscosityPrefactors<dim>::CompositionalViscosityPrefactors ()
-        = default;
-
-      template <int dim>
-      double
-      CompositionalViscosityPrefactors<dim>::compute_viscosity (const MaterialModel::MaterialModelInputs<dim> &in,
-                                                                const double base_viscosity,
-                                                                const unsigned int composition_index,
-                                                                const unsigned int q,
-                                                                const ModifiedFlowLaws &modified_flow_laws) const
-      {
-        double factored_viscosities = base_viscosity;
-        switch (viscosity_prefactor_scheme)
-          {
-            case none:
-            {
-              factored_viscosities = base_viscosity;
-              break;
-            }
-            case hk04_olivine_hydration:
-            {
-              // We calculate the atomic H/Si ppm (C_OH) at each point to compute the water fugacity of
-              // olivine assuming a composition of 90 mol% Forsterite and 10 mol% Fayalite from Hirth
-              // and Kohlstaedt 2004 10.1029/138GM06.
-              const unsigned int bound_fluid_idx = this->introspection().compositional_index_for_name("bound_fluid");
-              const double mass_fraction_H2O = std::max(minimum_mass_fraction_water_for_dry_creep[composition_index], in.composition[q][bound_fluid_idx]); // mass fraction of bound water
-              const double mass_fraction_olivine = 1 - mass_fraction_H2O; // mass fraction of olivine
-              const double COH = (mass_fraction_H2O/molar_mass_H2O) / (mass_fraction_olivine/molar_mass_olivine) * 1e6; // COH in H / Si ppm
-              const double point_water_fugacity = COH / A_H2O *
-                                                  std::exp((activation_energy_H2O + in.pressure[q]*activation_volume_H2O)/
-                                                           (constants::gas_constant * in.temperature[q]));
-              const double r = modified_flow_laws == diffusion
-                               ?
-                               -diffusion_water_fugacity_exponents[composition_index]
-                               :
-                               -dislocation_water_fugacity_exponents[composition_index];
-              factored_viscosities = base_viscosity*std::pow(point_water_fugacity, r);
-              break;
-            }
-          }
-        return factored_viscosities;
-      }
-
-
-      template <int dim>
-      void
-      CompositionalViscosityPrefactors<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Minimum mass fraction bound water content for fugacity", "6.15e-6",
-                           Patterns::List(Patterns::Double(0)),
-                           "The minimum water content for the HK04 olivine hydration viscosity "
-                           "prefactor scheme. This acts as the cutoff between 'dry' creep and 'wet' creep "
-                           "for olivine, and the default value is chosen based on the value reported by "
-                           "Hirth & Kohlstaedt 2004. For a mass fraction of bound water beneath this value, "
-                           "this value is used instead to compute the water fugacity. Units: \\si{\\kg} / \\si{\\kg} %.");
-
-        prm.declare_entry ("Water fugacity exponents for diffusion creep", "0.0",
-                           Patterns::List(Patterns::Double(0)),
-                           "List of water fugacity exponents for diffusion creep for "
-                           "background material and compositional fields, for a total of N+1 "
-                           "where N is the number of all compositional fields or only those "
-                           "corresponding to chemical compositions. This is only applied when using the "
-                           "Viscosity prefactor scheme 'HK04 olivine hydration'. Note, the water fugacity exponent "
-                           "required by ASPECT for diffusion creep is r/n, where n is the stress exponent "
-                           "for diffusion creep, which typically is 1. Units: none.");
-
-        prm.declare_entry ("Water fugacity exponents for dislocation creep", "0.0",
-                           Patterns::List(Patterns::Double(0)),
-                           "List of water fugacity exponents for dislocation creep for "
-                           "background material and compositional fields, for a total of N+1 "
-                           "where N is the number of all compositional fields or only those "
-                           "corresponding to chemical compositions. This is only applied when using the "
-                           "Viscosity prefactor scheme 'HK04 olivine hydration'. Note, the water fugacity exponent "
-                           "required by ASPECT for dislocation creep is r/n, where n is the stress exponent "
-                           "for dislocation creep, which typically is 3.5. Units: none.");
-
-        prm.declare_entry ("Viscosity prefactor scheme", "none",
-                           Patterns::Selection("none|HK04 olivine hydration"),
-                           "Select what type of viscosity multiplicative prefactor scheme to apply. "
-                           "Allowed entries are 'none', and 'HK04 olivine hydration'. HK04 olivine "
-                           "hydration calculates the viscosity change due to hydrogen incorporation "
-                           "into olivine following Hirth & Kohlstaedt 2004 (10.1029/138GM06). none "
-                           "does not modify the viscosity. Units: none.");
-      }
-
-
-
-      template <int dim>
-      void
-      CompositionalViscosityPrefactors<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        if (prm.get ("Viscosity prefactor scheme") == "none")
-          viscosity_prefactor_scheme = none;
-        if (prm.get ("Viscosity prefactor scheme") == "HK04 olivine hydration")
-          {
-            // Retrieve the list of compositional names
-            std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-            AssertThrow(this->introspection().compositional_name_exists("bound_fluid"),
-                        ExcMessage("The HK04 olivine hydration pre-exponential factor only works if "
-                                   "there is a compositional field called bound_fluid."));
-            viscosity_prefactor_scheme = hk04_olivine_hydration;
-
-            // Retrieve the list of chemical names
-            std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-            // Establish that a background field is required here
-            compositional_field_names.insert(compositional_field_names.begin(), "background");
-            chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-            Utilities::MapParsing::Options options(chemical_field_names, "Water fugacity exponents for diffusion creep");
-
-            options.list_of_allowed_keys = compositional_field_names;
-            diffusion_water_fugacity_exponents = Utilities::MapParsing::parse_map_to_double_array (prm.get("Water fugacity exponents for diffusion creep"),
-                                                 options);
-            dislocation_water_fugacity_exponents = Utilities::MapParsing::parse_map_to_double_array (prm.get("Water fugacity exponents for dislocation creep"),
-                                                   options);
-            minimum_mass_fraction_water_for_dry_creep = Utilities::MapParsing::parse_map_to_double_array (prm.get("Minimum mass fraction bound water content for fugacity"),
-                                                        options);
-          }
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class CompositionalViscosityPrefactors<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/constant_viscosity.cc.bak b/source/material_model/rheology/constant_viscosity.cc.bak
deleted file mode 100644
index 06da2a5b933..00000000000
--- a/source/material_model/rheology/constant_viscosity.cc.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-  Copyright (C) 2019 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/constant_viscosity.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      ConstantViscosity::ConstantViscosity ()
-        :
-        viscosity(numbers::signaling_nan<double>())
-      {}
-
-
-
-      double
-      ConstantViscosity::compute_viscosity () const
-      {
-        return viscosity;
-      }
-
-
-
-      void
-      ConstantViscosity::declare_parameters (ParameterHandler &prm,
-                                             const double default_viscosity)
-      {
-        prm.declare_entry ("Viscosity", std::to_string(default_viscosity),
-                           Patterns::Double (0.),
-                           "The value of the viscosity $\\eta$. Units: \\si{\\pascal\\second}.");
-      }
-
-
-
-      void
-      ConstantViscosity::parse_parameters (ParameterHandler &prm)
-      {
-        viscosity = prm.get_double ("Viscosity");
-      }
-    }
-  }
-}
diff --git a/source/material_model/rheology/constant_viscosity_prefactors.cc.bak b/source/material_model/rheology/constant_viscosity_prefactors.cc.bak
deleted file mode 100644
index 4b3b91d6cfc..00000000000
--- a/source/material_model/rheology/constant_viscosity_prefactors.cc.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/constant_viscosity_prefactors.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      template <int dim>
-      ConstantViscosityPrefactors<dim>::ConstantViscosityPrefactors ()
-        = default;
-
-
-
-      template <int dim>
-      double
-      ConstantViscosityPrefactors<dim>::compute_viscosity (const double base_viscosity,
-                                                           const unsigned int composition_index) const
-      {
-        return base_viscosity * constant_viscosity_prefactors[composition_index];
-      }
-
-
-
-      template <int dim>
-      void
-      ConstantViscosityPrefactors<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Constant viscosity prefactors", "1.0",
-                           Patterns::List(Patterns::Double(0)),
-                           "List of constant viscosity prefactors (i.e., multiplicative factors) "
-                           "for background material and compositional fields, for a total of N+1 "
-                           "where N is the number of all compositional fields or only those "
-                           "corresponding to chemical compositions. Units: none.");
-      }
-
-
-
-      template <int dim>
-      void
-      ConstantViscosityPrefactors<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-        Utilities::MapParsing::Options options(chemical_field_names, "Constant viscosity prefactors");
-        options.list_of_allowed_keys = compositional_field_names;
-
-        constant_viscosity_prefactors = Utilities::MapParsing::parse_map_to_double_array (prm.get("Constant viscosity prefactors"),
-                                        options);
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class ConstantViscosityPrefactors<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/diffusion_creep.cc.bak b/source/material_model/rheology/diffusion_creep.cc.bak
deleted file mode 100644
index b2b3f0d087d..00000000000
--- a/source/material_model/rheology/diffusion_creep.cc.bak
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/diffusion_creep.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      DiffusionCreepParameters::DiffusionCreepParameters()
-        : prefactor (numbers::signaling_nan<double>()),
-          activation_energy (numbers::signaling_nan<double>()),
-          activation_volume (numbers::signaling_nan<double>()),
-          stress_exponent (numbers::signaling_nan<double>()),
-          grain_size_exponent (numbers::signaling_nan<double>())
-      {}
-
-
-
-      template <int dim>
-      DiffusionCreep<dim>::DiffusionCreep ()
-        = default;
-
-
-
-      template <int dim>
-      const DiffusionCreepParameters
-      DiffusionCreep<dim>::compute_creep_parameters (const unsigned int composition,
-                                                     const std::vector<double> &phase_function_values,
-                                                     const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        DiffusionCreepParameters creep_parameters;
-        if (phase_function_values == std::vector<double>())
-          {
-            // no phases
-            creep_parameters.prefactor = prefactors_diffusion[composition];
-            creep_parameters.activation_energy = activation_energies_diffusion[composition];
-            creep_parameters.activation_volume = activation_volumes_diffusion[composition];
-            creep_parameters.stress_exponent = stress_exponents_diffusion[composition];
-            creep_parameters.grain_size_exponent = grain_size_exponents_diffusion[composition];
-          }
-        else
-          {
-            // Average among phases
-            creep_parameters.prefactor = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                         prefactors_diffusion, composition,  MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic);
-            creep_parameters.activation_energy = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 activation_energies_diffusion, composition);
-            creep_parameters.activation_volume = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 activation_volumes_diffusion, composition);
-            creep_parameters.stress_exponent = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                               stress_exponents_diffusion, composition);
-            creep_parameters.grain_size_exponent = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                   grain_size_exponents_diffusion, composition);
-          }
-        return creep_parameters;
-      }
-
-
-
-      template <int dim>
-      double
-      DiffusionCreep<dim>::compute_viscosity (const double pressure,
-                                              const double temperature,
-                                              const unsigned int composition,
-                                              const std::vector<double> &phase_function_values,
-                                              const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        const DiffusionCreepParameters p = compute_creep_parameters(composition,
-                                                                    phase_function_values,
-                                                                    n_phase_transitions_per_composition);
-
-        // Power law creep equation
-        //    viscosity = 0.5 * A^(-1) * d^(m) * exp((E + P*V)/(RT))
-        // A: prefactor,
-        // d: grain size, m: grain size exponent, E: activation energy, P: pressure,
-        // V; activation volume, R: gas constant, T: temperature.
-        double viscosity_diffusion = 0.5 / p.prefactor *
-                                     std::exp((p.activation_energy +
-                                               pressure*p.activation_volume)/
-                                              (constants::gas_constant*temperature)) *
-                                     std::pow(grain_size, p.grain_size_exponent);
-
-        Assert (viscosity_diffusion > 0.0,
-                ExcMessage ("Negative diffusion viscosity detected. This is unphysical and should not happen. "
-                            "Check for negative parameters. Temperature and pressure are "
-                            + Utilities::to_string(temperature) + " K, " + Utilities::to_string(pressure) + " Pa. "));
-
-        // Creep viscosities become extremely large at low
-        // temperatures and can therefore provoke floating-point overflow errors. In
-        // real rocks, other deformation mechanisms become dominant at low temperatures,
-        // so these high viscosities are never achieved. It is therefore both reasonable
-        // and desirable to require the single-mechanism viscosity to be smaller than
-        // std::sqrt(max_double).
-        viscosity_diffusion = std::min(viscosity_diffusion, std::sqrt(std::numeric_limits<double>::max()));
-
-        return viscosity_diffusion;
-      }
-
-
-      template <int dim>
-      std::pair<double, double>
-      DiffusionCreep<dim>::compute_strain_rate_and_derivative (const double stress,
-                                                               const double pressure,
-                                                               const double temperature,
-                                                               const DiffusionCreepParameters creep_parameters) const
-      {
-        // Power law creep equation
-        //   edot_ii_partial = A * stress^n * d^-m * exp(-(E + P*V)/(RT))
-        //   d(edot_ii_partial)/d(stress) = A * n * stress^(n-1) * d^-m * exp(-(E + P*V)/(RT))
-        // A: prefactor, edot_ii_partial: square root of second invariant of deviatoric strain rate tensor attributable to the creep mechanism,
-        // d: grain size, m: grain size exponent, E: activation energy, P: pressure,
-        // V; activation volume, R: gas constant, T: temperature.
-        // For diffusion creep, n = 1 (strain rate is linearly dependent on stress).
-        const double dstrain_rate_dstress_diffusion = creep_parameters.prefactor *
-                                                      std::pow(grain_size, -creep_parameters.grain_size_exponent) *
-                                                      std::exp(-(creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
-                                                               (constants::gas_constant*temperature));
-
-        const double strain_rate_diffusion = stress * dstrain_rate_dstress_diffusion;
-
-        return std::make_pair(strain_rate_diffusion, dstrain_rate_dstress_diffusion);
-      }
-
-
-      template <int dim>
-      std::pair<double, double>
-      DiffusionCreep<dim>::compute_log_strain_rate_and_derivative (const double log_stress,
-                                                                   const double pressure,
-                                                                   const double temperature,
-                                                                   const DiffusionCreepParameters creep_parameters) const
-      {
-        // Power law creep equation
-        // log(edot_ii_partial) = std::log(A) + n*std::log(stress) - m*std::log(d) - (E + P*V)/(RT)
-        //   d(log_edot_ii_partial)/d(log_stress) = n
-        // A: prefactor, edot_ii_partial: square root of second invariant of deviatoric strain rate tensor attributable to the creep mechanism,
-        // d: grain size, m: grain size exponent, E: activation energy, P: pressure,
-        // V; activation volume, R: gas constant, T: temperature.
-        // For diffusion creep, n = 1 (strain rate is linearly dependent on stress).
-        const double log_strain_rate_diffusion = std::log(creep_parameters.prefactor) +
-                                                 log_stress -
-                                                 creep_parameters.grain_size_exponent * std::log(grain_size) -
-                                                 (creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
-                                                 (constants::gas_constant*temperature);
-
-        const double dlog_strain_rate_dlog_stress_diffusion = 1.0;
-
-        return std::make_pair(log_strain_rate_diffusion, dlog_strain_rate_dlog_stress_diffusion);
-      }
-
-
-
-
-      template <int dim>
-      void
-      DiffusionCreep<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Prefactors for diffusion creep", "1.5e-15",
-                           Patterns::Anything(),
-                           "List of viscosity prefactors, $A$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\per\\pascal\\meter}$^{m_{\\text{diffusion}}}$\\si{\\per\\second}.");
-        prm.declare_entry ("Stress exponents for diffusion creep", "1.",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of stress exponents, $n_{\\text{diffusion}}$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "The stress exponent for diffusion creep is almost always equal to one. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-        prm.declare_entry ("Grain size exponents for diffusion creep", "3.",
-                           Patterns::Anything(),
-                           "List of grain size exponents, $m_{\\text{diffusion}}$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. Units: None.");
-        prm.declare_entry ("Activation energies for diffusion creep", "375e3",
-                           Patterns::Anything(),
-                           "List of activation energies, $E_a$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\joule\\per\\mole}.");
-        prm.declare_entry ("Activation volumes for diffusion creep", "6e-6",
-                           Patterns::Anything(),
-                           "List of activation volumes, $V_a$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
-        prm.declare_entry ("Grain size", "1e-3", Patterns::Double (0.),
-                           "Units: \\si{\\meter}.");
-      }
-
-
-
-      template <int dim>
-      void
-      DiffusionCreep<dim>::parse_parameters (ParameterHandler &prm,
-                                             const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
-      {
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(), "background");
-
-        // Make options file for parsing maps to double arrays
-        Utilities::MapParsing::Options options(chemical_field_names, "Prefactors for diffusion creep");
-        options.list_of_allowed_keys = compositional_field_names;
-        options.allow_multiple_values_per_key = true;
-        if (expected_n_phases_per_composition)
-          {
-            options.n_values_per_key = *expected_n_phases_per_composition;
-
-            // check_values_per_key is required to be true to duplicate single values
-            // if they are to be used for all phases associated with a given key.
-            options.check_values_per_key = true;
-          }
-
-        // Read parameters, each of size of number of composition + number of phases + 1
-        prefactors_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactors for diffusion creep"),
-                                                                                options);
-
-        options.property_name = "Stress exponents for diffusion creep";
-        stress_exponents_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Stress exponents for diffusion creep"),
-                                                                                      options);
-
-        options.property_name = "Grain size exponents for diffusion creep";
-        grain_size_exponents_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Grain size exponents for diffusion creep"),
-                                         options);
-
-        options.property_name = "Activation energies for diffusion creep";
-        activation_energies_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation energies for diffusion creep"),
-                                        options);
-
-        options.property_name = "Activation volumes for diffusion creep";
-        activation_volumes_diffusion = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation volumes for diffusion creep"),
-                                                                                        options);
-
-        grain_size = prm.get_double("Grain size");
-
-        // Check that there are no entries set to zero,
-        // for example because the entry is for a field
-        // that is masked anyway, like strain. Despite
-        // these compositions being masked, their viscosities
-        // are computed anyway and this will lead to division by zero.
-        for (const double prefactor : prefactors_diffusion)
-          AssertThrow(prefactor > 0.,
-                      ExcMessage("The diffusion prefactor should be larger than zero."));
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class DiffusionCreep<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/diffusion_dislocation.cc.bak b/source/material_model/rheology/diffusion_dislocation.cc.bak
deleted file mode 100644
index d86b36f491c..00000000000
--- a/source/material_model/rheology/diffusion_dislocation.cc.bak
+++ /dev/null
@@ -1,386 +0,0 @@
-/*
-  Copyright (C) 2020 - 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/diffusion_dislocation.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      template <int dim>
-      DiffusionDislocation<dim>::DiffusionDislocation ()
-        = default;
-
-      template <int dim>
-      std::vector<double>
-      DiffusionDislocation<dim>::
-      calculate_isostrain_viscosities ( const double pressure,
-                                        const double temperature,
-                                        const SymmetricTensor<2,dim> &strain_rate) const
-      {
-        // This function calculates viscosities assuming that all the compositional fields
-        // experience the same strain rate (isostrain).
-
-        // If strain rate is zero (like during the first time step) set it to some very small number
-        // to prevent a division-by-zero, and a floating point exception.
-        // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
-        // strain rate (often simplified as epsilondot_ii)
-        const double edot_ii = std::max(std::sqrt(std::max(-second_invariant(deviator(strain_rate)), 0.)),
-                                        min_strain_rate);
-        const double log_edot_ii = std::log(edot_ii);
-
-
-        // Find effective viscosities for each of the individual phases
-        // Viscosities should have same number of entries as compositional fields
-        std::vector<double> composition_viscosities(n_chemical_composition_fields);
-        for (unsigned int j=0; j < n_chemical_composition_fields; ++j)
-          {
-            // Power law creep equation
-            // edot_ii_i = A_i * stress_ii_i^{n_i} * d^{-m} \exp\left(-\frac{E_i^\ast + PV_i^\ast}{n_iRT}\right)
-            // where ii indicates the square root of the second invariant and
-            // i corresponds to diffusion or dislocation creep
-
-            // For diffusion creep, viscosity is grain size dependent
-            const Rheology::DiffusionCreepParameters diffusion_creep_parameters = diffusion_creep.compute_creep_parameters(j);
-
-            // For dislocation creep, viscosity is grain size independent (m=0)
-            const Rheology::DislocationCreepParameters dislocation_creep_parameters = dislocation_creep.compute_creep_parameters(j);
-
-            // For diffusion creep, viscosity is grain size dependent
-            const double prefactor_stress_diffusion = diffusion_creep_parameters.prefactor *
-                                                      std::pow(grain_size, -diffusion_creep_parameters.grain_size_exponent) *
-                                                      std::exp(-(std::max(diffusion_creep_parameters.activation_energy + pressure*diffusion_creep_parameters.activation_volume,0.0))/
-                                                               (constants::gas_constant*temperature));
-
-            // Because the ratios of the diffusion and dislocation strain rates are not known, stress is also unknown
-            // We use Newton's method to find the second invariant of the stress tensor.
-            // Start with the assumption that all strain is accommodated by diffusion creep:
-            // If the diffusion creep prefactor is very small, that means that the diffusion viscosity is very large.
-            // In this case, use the maximum viscosity instead to compute the starting guess.
-            double stress_ii = (prefactor_stress_diffusion > (0.5 / maximum_viscosity)
-                                ?
-                                edot_ii/prefactor_stress_diffusion
-                                :
-                                0.5 / maximum_viscosity);
-            double log_stress_ii = std::log(stress_ii);
-            double log_strain_rate_residual = 2 * log_strain_rate_residual_threshold;
-            double log_strain_rate_deriv = 0;
-            unsigned int stress_iteration = 0;
-            while (std::abs(log_strain_rate_residual) > log_strain_rate_residual_threshold
-                   && stress_iteration < stress_max_iteration_number)
-              {
-                const std::pair<double, double> log_diff_edot_and_deriv = diffusion_creep.compute_log_strain_rate_and_derivative(log_stress_ii, pressure, temperature, diffusion_creep_parameters);
-                const std::pair<double, double> log_disl_edot_and_deriv = dislocation_creep.compute_log_strain_rate_and_derivative(log_stress_ii, pressure, temperature, dislocation_creep_parameters);
-
-                const double strain_rate_diffusion = std::exp(log_diff_edot_and_deriv.first);
-                const double strain_rate_dislocation = std::exp(log_disl_edot_and_deriv.first);
-                log_strain_rate_residual = std::log(strain_rate_diffusion + strain_rate_dislocation) - log_edot_ii;
-                log_strain_rate_deriv = (strain_rate_diffusion * log_diff_edot_and_deriv.second + strain_rate_dislocation * log_disl_edot_and_deriv.second)/
-                                        (strain_rate_diffusion + strain_rate_dislocation);
-
-                // If the log strain rate derivative is zero, we catch it below.
-                if (log_strain_rate_deriv>std::numeric_limits<double>::min())
-                  log_stress_ii -= log_strain_rate_residual/log_strain_rate_deriv;
-                stress_ii = std::exp(log_stress_ii);
-                stress_iteration += 1;
-
-                // In case the Newton iteration does not succeed, we do a fixpoint iteration.
-                // This allows us to bound both the diffusion and dislocation viscosity
-                // between a minimum and maximum value, so that we can compute the correct
-                // viscosity values even if the parameters lead to one or both of the
-                // viscosities being essentially zero or infinity.
-                // If anything that would be used in the next iteration is not finite, the
-                // Newton iteration would trigger an exception and we want to do the fixpoint
-                // iteration instead.
-                const bool abort_newton_iteration = !numbers::is_finite(stress_ii)
-                                                    || !numbers::is_finite(log_strain_rate_residual)
-                                                    || !numbers::is_finite(log_strain_rate_deriv)
-                                                    || log_strain_rate_deriv < std::numeric_limits<double>::min()
-                                                    || !numbers::is_finite(std::pow(stress_ii, diffusion_creep_parameters.stress_exponent-1))
-                                                    || !numbers::is_finite(std::pow(stress_ii, dislocation_creep_parameters.stress_exponent-1))
-                                                    || stress_iteration == stress_max_iteration_number;
-                if (abort_newton_iteration)
-                  {
-                    double diffusion_strain_rate = edot_ii;
-                    double dislocation_strain_rate = min_strain_rate;
-                    stress_iteration = 0;
-
-                    do
-                      {
-                        const double old_diffusion_strain_rate = diffusion_strain_rate;
-
-                        const double diffusion_prefactor = 0.5 * std::pow(diffusion_creep_parameters.prefactor,-1.0/diffusion_creep_parameters.stress_exponent);
-                        const double diffusion_grain_size_dependence = std::pow(grain_size, diffusion_creep_parameters.grain_size_exponent/diffusion_creep_parameters.stress_exponent);
-                        const double diffusion_strain_rate_dependence = std::pow(diffusion_strain_rate, (1.-diffusion_creep_parameters.stress_exponent)/diffusion_creep_parameters.stress_exponent);
-                        const double diffusion_T_and_P_dependence = std::exp(std::max(diffusion_creep_parameters.activation_energy + pressure*diffusion_creep_parameters.activation_volume,0.0)/
-                                                                             (constants::gas_constant*temperature));
-
-                        const double diffusion_viscosity = std::min(std::max(diffusion_prefactor * diffusion_grain_size_dependence
-                                                                             * diffusion_strain_rate_dependence * diffusion_T_and_P_dependence,
-                                                                             minimum_viscosity), maximum_viscosity);
-
-                        const double dislocation_prefactor = 0.5 * std::pow(dislocation_creep_parameters.prefactor,-1.0/dislocation_creep_parameters.stress_exponent);
-                        const double dislocation_strain_rate_dependence = std::pow(dislocation_strain_rate, (1.-dislocation_creep_parameters.stress_exponent)/dislocation_creep_parameters.stress_exponent);
-                        const double dislocation_T_and_P_dependence = std::exp(std::max(dislocation_creep_parameters.activation_energy + pressure*dislocation_creep_parameters.activation_volume,0.0)/
-                                                                               (dislocation_creep_parameters.stress_exponent*constants::gas_constant*temperature));
-
-                        const double dislocation_viscosity = std::min(std::max(dislocation_prefactor * dislocation_strain_rate_dependence
-                                                                               * dislocation_T_and_P_dependence,
-                                                                               minimum_viscosity), maximum_viscosity);
-
-                        diffusion_strain_rate = dislocation_viscosity / (diffusion_viscosity + dislocation_viscosity) * edot_ii;
-                        dislocation_strain_rate = diffusion_viscosity / (diffusion_viscosity + dislocation_viscosity) * edot_ii;
-
-                        ++stress_iteration;
-                        AssertThrow(stress_iteration < stress_max_iteration_number,
-                                    ExcMessage("No convergence has been reached in the loop that determines "
-                                               "the ratio of diffusion/dislocation viscosity. Aborting! "
-                                               "Residual is " + Utilities::to_string(log_strain_rate_residual) +
-                                               " after " + Utilities::to_string(stress_iteration) + " iterations. "
-                                               "You can increase the number of iterations by adapting the "
-                                               "parameter 'Maximum strain rate ratio iterations'."));
-
-                        log_strain_rate_residual = std::abs(std::log(diffusion_strain_rate/old_diffusion_strain_rate));
-                        stress_ii = 2.0 * edot_ii * 1./(1./diffusion_viscosity + 1./dislocation_viscosity);
-                      }
-                    while (log_strain_rate_residual > log_strain_rate_residual_threshold);
-
-                    break;
-                  }
-              }
-
-            // The effective viscosity, with minimum and maximum bounds
-            composition_viscosities[j] = std::min(std::max(stress_ii/edot_ii/2, minimum_viscosity), maximum_viscosity);
-          }
-        return composition_viscosities;
-      }
-
-      template <int dim>
-      double
-      DiffusionDislocation<dim>::compute_viscosity (const double pressure,
-                                                    const double temperature,
-                                                    const std::vector<double> &volume_fractions,
-                                                    const SymmetricTensor<2,dim> &strain_rate) const
-      {
-        // Currently, the viscosities for each of the compositional fields are calculated assuming
-        // isostrain amongst all compositions, allowing calculation of the viscosity ratio.
-        // TODO: This is only consistent with viscosity averaging if the arithmetic averaging
-        // scheme is chosen. It would be useful to have a function to calculate isostress viscosities.
-        const std::vector<double> composition_viscosities =
-          calculate_isostrain_viscosities(pressure, temperature, strain_rate);
-
-        // The isostrain condition implies that the viscosity averaging should be arithmetic (see above).
-        // We have given the user freedom to apply alternative bounds, because in diffusion-dominated
-        // creep (where n_diff=1) viscosities are stress and strain-rate independent, so the calculation
-        // of compositional field viscosities is consistent with any averaging scheme.
-        return MaterialUtilities::average_value(volume_fractions, composition_viscosities, viscosity_averaging);
-      }
-
-
-      template <int dim>
-      void
-      DiffusionDislocation<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        // Reference and minimum/maximum values
-        prm.declare_entry ("Reference temperature", "293.", Patterns::Double(0.),
-                           "For calculating density by thermal expansivity. Units: \\si{\\kelvin}.");
-        prm.declare_entry ("Minimum strain rate", "1.4e-20", Patterns::Double(0.),
-                           "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}.");
-        prm.declare_entry ("Minimum viscosity", "1e17", Patterns::Double(0.),
-                           "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}.");
-        prm.declare_entry ("Maximum viscosity", "1e28", Patterns::Double(0.),
-                           "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}.");
-        prm.declare_entry ("Effective viscosity coefficient", "1.0", Patterns::Double(0.),
-                           "Scaling coefficient for effective viscosity.");
-
-        // Viscosity iteration parameters
-        prm.declare_entry ("Strain rate residual tolerance", "1e-10", Patterns::Double(0.),
-                           "Tolerance for determining the correct stress and viscosity from the "
-                           "strain rate by internal iteration. The tolerance is expressed as the "
-                           "difference between the natural logarithm of the input strain rate and "
-                           "the strain rate at the current iteration. This determines that strain "
-                           "rate is correctly partitioned between diffusion and dislocation creep "
-                           "assuming that both mechanisms experience the same stress.");
-        prm.declare_entry ("Maximum strain rate ratio iterations", "40", Patterns::Integer(0),
-                           "Maximum number of iterations to find the correct "
-                           "diffusion/dislocation strain rate ratio.");
-
-        // Equation of state parameters
-        prm.declare_entry ("Thermal diffusivity", "0.8e-6", Patterns::Double(0.),
-                           "Units: \\si{\\meter\\squared\\per\\second}.");
-        prm.declare_entry ("Heat capacity", "1.25e3",
-                           Patterns::Double(0.),
-                           "The value of the specific heat $C_p$. "
-                           "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-        prm.declare_entry ("Densities", "3300.",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of densities, $\\rho$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-        prm.declare_entry ("Thermal expansivities", "3.5e-5",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of thermal expansivities for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}.");
-
-        // Rheological parameters
-        prm.declare_entry ("Viscosity averaging scheme", "harmonic",
-                           Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
-                           "When more than one compositional field is present at a point "
-                           "with different viscosities, we need to come up with an average "
-                           "viscosity at that point.  Select a weighted harmonic, arithmetic, "
-                           "geometric, or maximum composition.");
-        // Diffusion creep parameters
-        prm.declare_entry ("Prefactors for diffusion creep", "1.5e-15",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of viscosity prefactors, $A$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\per\\pascal} \\si{\\meter}$^{m_{\\text{diffusion}}}$ \\si{\\per\\second}.");
-        prm.declare_entry ("Stress exponents for diffusion creep", "1.",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of stress exponents, $n_{\\text{diffusion}}$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-        prm.declare_entry ("Grain size exponents for diffusion creep", "3.",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of grain size exponents, $m_{\\text{diffusion}}$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-        prm.declare_entry ("Activation energies for diffusion creep", "375e3",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of activation energies, $E_a$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\joule\\per\\mole}.");
-        prm.declare_entry ("Activation volumes for diffusion creep", "6e-6",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of activation volumes, $V_a$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
-
-        // Dislocation creep parameters
-        prm.declare_entry ("Prefactors for dislocation creep", "1.1e-16",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of viscosity prefactors, $A$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\pascal}$^{-n_{\\text{dislocation}}}$\\si{\\per\\second}.");
-        prm.declare_entry ("Stress exponents for dislocation creep", "3.5",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of stress exponents, $n_{\\text{dislocation}}$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-        prm.declare_entry ("Activation energies for dislocation creep", "530e3",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of activation energies, $E_a$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\joule\\per\\mole}.");
-        prm.declare_entry ("Activation volumes for dislocation creep", "1.4e-5",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of activation volumes, $V_a$, for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
-
-        // Diffusion creep parameters
-        Rheology::DiffusionCreep<dim>::declare_parameters(prm);
-
-        // Dislocation creep parameters
-        Rheology::DislocationCreep<dim>::declare_parameters(prm);
-      }
-
-
-
-      template <int dim>
-      void
-      DiffusionDislocation<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        // Reference and minimum/maximum values
-        min_strain_rate = prm.get_double("Minimum strain rate");
-        minimum_viscosity = prm.get_double ("Minimum viscosity");
-        maximum_viscosity = prm.get_double ("Maximum viscosity");
-
-        // Iteration parameters
-        log_strain_rate_residual_threshold = prm.get_double ("Strain rate residual tolerance");
-        stress_max_iteration_number = prm.get_integer ("Maximum strain rate ratio iterations");
-
-        // ---- Compositional parameters
-        grain_size = prm.get_double("Grain size");
-
-        viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
-                              prm);
-
-        // Rheological parameters for chemical compositions
-        // increment by one for background:
-        n_chemical_composition_fields = this->introspection().n_chemical_composition_fields() + 1;
-
-        // Diffusion creep parameters
-        diffusion_creep.initialize_simulator (this->get_simulator());
-        diffusion_creep.parse_parameters(prm, std::make_unique<std::vector<unsigned int>>(n_chemical_composition_fields));
-
-        // Dislocation creep parameters
-        dislocation_creep.initialize_simulator (this->get_simulator());
-        dislocation_creep.parse_parameters(prm, std::make_unique<std::vector<unsigned int>>(n_chemical_composition_fields));
-
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class DiffusionDislocation<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/dislocation_creep.cc.bak b/source/material_model/rheology/dislocation_creep.cc.bak
deleted file mode 100644
index 511444fb281..00000000000
--- a/source/material_model/rheology/dislocation_creep.cc.bak
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/dislocation_creep.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      DislocationCreepParameters::DislocationCreepParameters()
-        :  prefactor (numbers::signaling_nan<double>()),
-           activation_energy (numbers::signaling_nan<double>()),
-           activation_volume (numbers::signaling_nan<double>()),
-           stress_exponent (numbers::signaling_nan<double>())
-      {}
-
-
-
-      template <int dim>
-      DislocationCreep<dim>::DislocationCreep ()
-        = default;
-
-
-
-      template <int dim>
-      const DislocationCreepParameters
-      DislocationCreep<dim>::compute_creep_parameters (const unsigned int composition,
-                                                       const std::vector<double> &phase_function_values,
-                                                       const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        DislocationCreepParameters creep_parameters;
-        if (phase_function_values == std::vector<double>())
-          {
-            // no phases
-            creep_parameters.prefactor = prefactors_dislocation[composition];
-            creep_parameters.activation_energy = activation_energies_dislocation[composition];
-            creep_parameters.activation_volume = activation_volumes_dislocation[composition];
-            creep_parameters.stress_exponent = stress_exponents_dislocation[composition];
-          }
-        else
-          {
-            // Average among phases
-            creep_parameters.prefactor = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                         prefactors_dislocation, composition,
-                                         MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic);
-            creep_parameters.activation_energy = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 activation_energies_dislocation, composition);
-            creep_parameters.activation_volume = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 activation_volumes_dislocation , composition);
-            creep_parameters.stress_exponent = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                               stress_exponents_dislocation, composition);
-          }
-
-        return creep_parameters;
-      }
-
-
-
-      template <int dim>
-      double
-      DislocationCreep<dim>::compute_viscosity (const double strain_rate,
-                                                const double pressure,
-                                                const double temperature,
-                                                const unsigned int composition,
-                                                const std::vector<double> &phase_function_values,
-                                                const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        const DislocationCreepParameters p = compute_creep_parameters(composition,
-                                                                      phase_function_values,
-                                                                      n_phase_transitions_per_composition);
-
-        // Power law creep equation:
-        //    viscosity = 0.5 * A^(-1/n) * edot_ii^((1-n)/n) * exp((E + P*V)/(nRT))
-        // A: prefactor, edot_ii: square root of second invariant of deviatoric strain rate tensor,
-        // E: activation energy, P: pressure,
-        // V; activation volume, n: stress exponent, R: gas constant, T: temperature.
-        double viscosity_dislocation = 0.5 * std::pow(p.prefactor,-1/p.stress_exponent) *
-                                       std::exp((p.activation_energy + pressure*p.activation_volume)/
-                                                (constants::gas_constant*temperature*p.stress_exponent)) *
-                                       std::pow(strain_rate,((1. - p.stress_exponent)/p.stress_exponent));
-
-        Assert (viscosity_dislocation > 0.0,
-                ExcMessage ("Negative dislocation viscosity detected. This is unphysical and should not happen. "
-                            "Check for negative parameters. Temperature and pressure are "
-                            + Utilities::to_string(temperature) + " K, " + Utilities::to_string(pressure) + " Pa. "));
-
-        // Creep viscosities become extremely large at low
-        // temperatures and can therefore provoke floating-point overflow errors. In
-        // real rocks, other deformation mechanisms become dominant at low temperatures,
-        // so these high viscosities are never achieved. It is therefore both reasonable
-        // and desirable to require the single-mechanism viscosity to be smaller than
-        // std::sqrt(max_double).
-        viscosity_dislocation = std::min(viscosity_dislocation, std::sqrt(std::numeric_limits<double>::max()));
-
-        return viscosity_dislocation;
-      }
-
-
-
-      template <int dim>
-      std::pair<double, double>
-      DislocationCreep<dim>::compute_strain_rate_and_derivative (const double stress,
-                                                                 const double pressure,
-                                                                 const double temperature,
-                                                                 const DislocationCreepParameters creep_parameters) const
-      {
-        // Power law creep equation:
-        //   edot_ii_partial = A * stress^n * exp(-(E + P*V)/(RT))
-        //   d(edot_ii_partial)/d(stress) = A * n * stress^(n-1) * exp(-(E + P*V)/(RT))
-        // A: prefactor, edot_ii_partial: square root of second invariant of deviatoric strain rate tensor attributable to the creep mechanism,
-        // stress: deviatoric stress, E: activation energy, P: pressure,
-        // V; activation volume, n: stress exponent, R: gas constant, T: temperature.
-        const double strain_rate_dislocation = creep_parameters.prefactor *
-                                               std::pow(stress,creep_parameters.stress_exponent) *
-                                               std::exp(-(creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
-                                                        (constants::gas_constant*temperature));
-
-        const double dstrain_rate_dstress_dislocation = creep_parameters.prefactor *
-                                                        creep_parameters.stress_exponent *
-                                                        std::pow(stress,creep_parameters.stress_exponent-1.) *
-                                                        std::exp(-(creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
-                                                                 (constants::gas_constant*temperature));
-
-        return std::make_pair(strain_rate_dislocation, dstrain_rate_dstress_dislocation);
-      }
-
-
-      template <int dim>
-      std::pair<double, double>
-      DislocationCreep<dim>::compute_log_strain_rate_and_derivative (const double log_stress,
-                                                                     const double pressure,
-                                                                     const double temperature,
-                                                                     const DislocationCreepParameters creep_parameters) const
-      {
-        // Power law creep equation
-        // log(edot_ii_partial) = std::log(A) + n*std::log(stress) - m*std::log(d) - (E + P*V)/(RT)
-        //   d(log_edot_ii_partial)/d(log_stress) = n
-        // A: prefactor, edot_ii_partial: square root of second invariant of deviatoric strain rate tensor attributable to the creep mechanism,
-        // stress: deviatoric stress, E: activation energy, P: pressure,
-        // V; activation volume, n: stress exponent, R: gas constant, T: temperature.
-        const double log_strain_rate_dislocation = std::log(creep_parameters.prefactor) +
-                                                   creep_parameters.stress_exponent * log_stress -
-                                                   (creep_parameters.activation_energy + pressure*creep_parameters.activation_volume)/
-                                                   (constants::gas_constant*temperature);
-
-        const double dlog_strain_rate_dlog_stress_dislocation = creep_parameters.stress_exponent;
-
-        return std::make_pair(log_strain_rate_dislocation, dlog_strain_rate_dlog_stress_dislocation);
-      }
-
-
-
-      template <int dim>
-      void
-      DislocationCreep<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Prefactors for dislocation creep", "1.1e-16",
-                           Patterns::Anything(),
-                           "List of viscosity prefactors, $A$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\pascal}$^{-n_{\\text{dislocation}}}$ \\si{\\per\\second}.");
-        prm.declare_entry ("Stress exponents for dislocation creep", "3.5",
-                           Patterns::Anything(),
-                           "List of stress exponents, $n_{\\text{dislocation}}$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-        prm.declare_entry ("Activation energies for dislocation creep", "530e3",
-                           Patterns::Anything(),
-                           "List of activation energies, $E_a$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\joule\\per\\mole}.");
-        prm.declare_entry ("Activation volumes for dislocation creep", "1.4e-5",
-                           Patterns::Anything(),
-                           "List of activation volumes, $V_a$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
-      }
-
-
-
-      template <int dim>
-      void
-      DislocationCreep<dim>::parse_parameters (ParameterHandler &prm,
-                                               const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
-      {
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(), "background");
-
-        // Make options file for parsing maps to double arrays
-        Utilities::MapParsing::Options options(chemical_field_names, "Prefactors for dislocation creep");
-        options.list_of_allowed_keys = compositional_field_names;
-        options.allow_multiple_values_per_key = true;
-        if (expected_n_phases_per_composition)
-          {
-            options.n_values_per_key = *expected_n_phases_per_composition;
-
-            // check_values_per_key is required to be true to duplicate single values
-            // if they are to be used for all phases associated with a given key.
-            options.check_values_per_key = true;
-          }
-
-        // Read parameters, each of size of number of composition + number of phases + 1
-        prefactors_dislocation = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactors for dislocation creep"),
-                                                                                  options);
-
-        options.property_name = "Stress exponents for dislocation creep";
-        stress_exponents_dislocation = Utilities::MapParsing::parse_map_to_double_array(prm.get("Stress exponents for dislocation creep"),
-                                                                                        options);
-
-        options.property_name = "Activation energies for dislocation creep";
-        activation_energies_dislocation = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation energies for dislocation creep"),
-                                          options);
-
-        options.property_name = "Activation volumes for dislocation creep";
-        activation_volumes_dislocation = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation volumes for dislocation creep"),
-                                         options);
-
-        // Check that there are no prefactor entries set to zero,
-        // for example because the entry is for a field
-        // that is masked anyway, like strain. Despite
-        // these compositions being masked, their viscosities
-        // are computed anyway and this will lead to division by zero.
-        for (const double prefactor : prefactors_dislocation)
-          AssertThrow(prefactor > 0., ExcMessage("The dislocation prefactor should be larger than zero."));
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class DislocationCreep<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/drucker_prager.cc.bak b/source/material_model/rheology/drucker_prager.cc.bak
deleted file mode 100644
index aa5856a7a5e..00000000000
--- a/source/material_model/rheology/drucker_prager.cc.bak
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/drucker_prager.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      DruckerPragerParameters::DruckerPragerParameters()
-        : angle_internal_friction (numbers::signaling_nan<double>()),
-          cohesion  (numbers::signaling_nan<double>()),
-          max_yield_stress (numbers::signaling_nan<double>())
-      {}
-
-
-
-      template <int dim>
-      DruckerPrager<dim>::DruckerPrager ()
-        = default;
-
-
-
-      template <int dim>
-      const DruckerPragerParameters
-      DruckerPrager<dim>::compute_drucker_prager_parameters (const unsigned int composition,
-                                                             const std::vector<double> &phase_function_values,
-                                                             const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        DruckerPragerParameters drucker_prager_parameters;
-
-        drucker_prager_parameters.max_yield_stress = max_yield_stress;
-
-        if (phase_function_values == std::vector<double>())
-          {
-            // no phases
-            drucker_prager_parameters.angle_internal_friction = angles_internal_friction[composition];
-            drucker_prager_parameters.cohesion = cohesions[composition];
-          }
-        else
-          {
-            // Average among phases
-            drucker_prager_parameters.angle_internal_friction = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                                angles_internal_friction, composition);
-            drucker_prager_parameters.cohesion = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 cohesions, composition);
-          }
-        return drucker_prager_parameters;
-      }
-
-      template <int dim>
-      double
-      DruckerPrager<dim>::compute_yield_stress (const double cohesion,
-                                                const double angle_internal_friction,
-                                                const double pressure,
-                                                const double max_yield_stress) const
-      {
-        const double sin_phi = std::sin(angle_internal_friction);
-        const double cos_phi = std::cos(angle_internal_friction);
-
-        // The expression below differs from Eq. 9 of Glerum et al, 2018.
-        // There are actually three different ways of choosing this parameter, which
-        // correspond to the Drucker-Prager yield surface either
-        // circumscribing (Glerum et al 2018), middle circumscribing or
-        // inscribing the Mohr-Coulomb yield surface.
-        // See for instance Owen & Hinton, Finite Elements in Plasticity, 1980.
-        // Here the middle circumscribing approach is taken.
-        const double stress_inv_part = 1. / (std::sqrt(3.0) * (3.0 + sin_phi));
-
-        // Initial yield stress (no stabilization terms)
-        const double yield_stress = ( (dim==3)
-                                      ?
-                                      ( 6.0 * cohesion * cos_phi + 6.0 * pressure * sin_phi) * stress_inv_part
-                                      :
-                                      cohesion * cos_phi + pressure * sin_phi);
-
-        return std::min(yield_stress, max_yield_stress);
-      }
-
-
-
-      template <int dim>
-      double
-      DruckerPrager<dim>::compute_viscosity (const double cohesion,
-                                             const double angle_internal_friction,
-                                             const double pressure,
-                                             const double effective_strain_rate,
-                                             const double max_yield_stress,
-                                             const double non_yielding_viscosity) const
-      {
-        const double yield_stress = compute_yield_stress(cohesion, angle_internal_friction, pressure, max_yield_stress);
-
-        // If there is no damper, the yielding plastic element accommodates all the strain
-        double apparent_viscosity = yield_stress / (2. * effective_strain_rate);
-
-        // If the plastic damper is used, the effective strain rate is partitioned between the
-        // viscoelastic and damped plastic (Bingham) elements. Assuming that the viscoelastic
-        // elements have viscosities that are not strain rate dependent, we have:
-        // edot_eff = tau_T / (2 * eta_ve) + (tau_T - tau_yield) / (2 * eta_d)
-        // The apparent viscosity is defined such that:
-        // tau_T = 2 * eta_app * edot_eff.
-        // Substituting one equation into the other and rearranging yields the expression
-        // eta_app = ((1 + tau_yield / (2 * eta_d * edot_eff)) / (1 / eta_d + 1 / eta_ve)).
-        if (use_plastic_damper)
-          {
-            apparent_viscosity = ((damper_viscosity + apparent_viscosity) /
-                                  (1. + damper_viscosity / non_yielding_viscosity));
-          }
-
-        return apparent_viscosity;
-      }
-
-
-
-      template <int dim>
-      std::pair<double, double>
-      DruckerPrager<dim>::compute_strain_rate_and_derivative (const double stress,
-                                                              const double pressure,
-                                                              const DruckerPragerParameters p) const
-      {
-
-        const double yield_stress = compute_yield_stress(p.cohesion, p.angle_internal_friction, pressure, p.max_yield_stress);
-
-        if (stress > yield_stress)
-          {
-            return std::make_pair((stress - yield_stress)/(2.*damper_viscosity), 1./(2.*damper_viscosity));
-          }
-        else
-          {
-            return std::make_pair(0., 0.);
-          }
-      }
-
-
-
-      template <int dim>
-      double
-      DruckerPrager<dim>::compute_derivative (const double angle_internal_friction,
-                                              const double effective_strain_rate) const
-      {
-        const double sin_phi = std::sin(angle_internal_friction);
-
-        const double stress_inv_part = 1. / (std::sqrt(3.0) * (3.0 + sin_phi));
-
-        const double strain_rate_effective_inv = 1./(2.*effective_strain_rate);
-
-        const double viscosity_pressure_derivative = sin_phi * strain_rate_effective_inv *
-                                                     (dim == 3
-                                                      ?
-                                                      (6.0 * stress_inv_part)
-                                                      :
-                                                      1);
-
-        return viscosity_pressure_derivative;
-      }
-
-
-
-      template <int dim>
-      void
-      DruckerPrager<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Angles of internal friction", "0.",
-                           Patterns::Anything(),
-                           "List of angles of internal friction, $\\phi$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "For a value of zero, in 2d the von Mises criterion is retrieved. "
-                           "Angles higher than 30 degrees are harder to solve numerically. Units: degrees.");
-        prm.declare_entry ("Cohesions", "1e20",
-                           Patterns::Anything(),
-                           "List of cohesions, $C$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "The extremely large default cohesion value (1e20 Pa) prevents the viscous stress from "
-                           "exceeding the yield stress. Units: \\si{\\pascal}.");
-        prm.declare_entry ("Maximum yield stress", "1e12", Patterns::Double (0.),
-                           "Limits the maximum value of the yield stress determined by the "
-                           "Drucker-Prager plasticity parameters. Default value is chosen so this "
-                           "is not automatically used. Values of 100e6--1000e6 $Pa$ have been used "
-                           "in previous models. Units: \\si{\\pascal}.");
-        prm.declare_entry ("Use plastic damper","false",
-                           Patterns::Bool (),
-                           "Whether to use a plastic damper when computing the Drucker-Prager "
-                           "plastic viscosity. The damper acts to stabilize the plastic shear "
-                           "band width and remove associated mesh-dependent behavior at "
-                           "sufficient resolutions.");
-        prm.declare_entry ("Plastic damper viscosity", "0.0", Patterns::Double(0),
-                           "Viscosity of the damper that acts in parallel with the plastic viscosity "
-                           "to produce mesh-independent behavior at sufficient resolutions. Units: \\si{\\pascal\\second}");
-      }
-
-
-
-      template <int dim>
-      void
-      DruckerPrager<dim>::parse_parameters (ParameterHandler &prm,
-                                            const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
-      {
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(), "background");
-
-        Utilities::MapParsing::Options options(chemical_field_names, "Angles of internal friction");
-        options.list_of_allowed_keys = compositional_field_names;
-
-        if (expected_n_phases_per_composition)
-          {
-            options.allow_multiple_values_per_key = true;
-            options.n_values_per_key = *expected_n_phases_per_composition;
-
-            // check_values_per_key is required to be true to duplicate single values
-            // if they are to be used for all phases associated with a given key.
-            options.check_values_per_key = true;
-          }
-
-        angles_internal_friction = Utilities::MapParsing::parse_map_to_double_array(prm.get("Angles of internal friction"),
-                                                                                    options);
-
-        // Convert angles from degrees to radians
-        for (double &angle : angles_internal_friction)
-          angle *= constants::degree_to_radians;
-
-        options.property_name = "Cohesions";
-        cohesions = Utilities::MapParsing::parse_map_to_double_array(prm.get("Cohesions"),
-                                                                     options);
-
-        // Limit maximum value of the Drucker-Prager yield stress
-        max_yield_stress = prm.get_double("Maximum yield stress");
-
-        // Whether to include a plastic damper when computing the Drucker-Prager plastic viscosity
-        use_plastic_damper = prm.get_bool("Use plastic damper");
-
-        // Stabilize plasticity through a viscous damper.
-        // The viscosity of the damper is implicitly zero if it is not used
-        if (use_plastic_damper)
-          damper_viscosity = prm.get_double("Plastic damper viscosity");
-        else
-          damper_viscosity = 0.;
-
-      }
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class DruckerPrager<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/elasticity.cc.bak b/source/material_model/rheology/elasticity.cc.bak
deleted file mode 100644
index dd4022c4650..00000000000
--- a/source/material_model/rheology/elasticity.cc.bak
+++ /dev/null
@@ -1,529 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/elasticity.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/quadrature_lib.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace
-    {
-      std::vector<std::string> make_elastic_additional_outputs_names()
-      {
-        std::vector<std::string> names;
-        names.emplace_back("elastic_shear_modulus");
-        return names;
-      }
-    }
-
-    template <int dim>
-    ElasticAdditionalOutputs<dim>::ElasticAdditionalOutputs (const unsigned int n_points)
-      :
-      NamedAdditionalMaterialOutputs<dim>(make_elastic_additional_outputs_names()),
-      elastic_shear_moduli(n_points, numbers::signaling_nan<double>())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    ElasticAdditionalOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      (void)idx; // suppress warning in release mode
-      AssertIndexRange (idx, 1);
-      return elastic_shear_moduli;
-    }
-
-
-
-    namespace Rheology
-    {
-      template <int dim>
-      void
-      Elasticity<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Elastic shear moduli", "75.0e9",
-                           Patterns::List(Patterns::Double(0.)),
-                           "List of elastic shear moduli, $G$, "
-                           "for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "The default value of 75 GPa is representative of mantle rocks. Units: Pa.");
-        prm.declare_entry ("Use fixed elastic time step", "unspecified",
-                           Patterns::Selection("true|false|unspecified"),
-                           "Select whether the material time scale in the viscoelastic constitutive "
-                           "relationship uses the regular numerical time step or a separate fixed "
-                           "elastic time step throughout the model run. The fixed elastic time step "
-                           "is always used during the initial time step. If a fixed elastic time "
-                           "step is used throughout the model run, a stress averaging scheme is "
-                           "applied to account for differences with the numerical time step. An "
-                           "alternative approach is to limit the maximum time step size so that it "
-                           "is equal to the elastic time step. The default value of this parameter is "
-                           "'unspecified', which throws an exception during runtime. In order for "
-                           "the model to run the user must select 'true' or 'false'.");
-        prm.declare_entry ("Fixed elastic time step", "1.e3",
-                           Patterns::Double (0.),
-                           "The fixed elastic time step $dte$. Units: years if the "
-                           "'Use years in output instead of seconds' parameter is set; "
-                           "seconds otherwise.");
-        prm.declare_entry ("Stabilization time scale factor", "1.",
-                           Patterns::Double (1.),
-                           "A stabilization factor for the elastic stresses that influences how fast "
-                           "elastic stresses adjust to deformation. 1.0 is equivalent to no stabilization "
-                           "and may lead to oscillatory motion. Setting the factor to 2 "
-                           "avoids oscillations, but still enables an immediate elastic response. "
-                           "However, in complex models this can lead to problems of convergence, in which "
-                           "case the factor needs to be increased slightly. Setting the factor to "
-                           "infinity is equivalent to not applying elastic stresses at all. The "
-                           "factor is multiplied with the computational time step to create a time scale. ");
-        prm.declare_entry ("Elastic damper viscosity", "0.0",
-                           Patterns::Double (0.),
-                           "Viscosity of a viscous damper that acts in parallel with the elastic "
-                           "element to stabilize behavior. Units: \\si{\\pascal\\second}");
-      }
-
-
-
-      template <int dim>
-      void
-      Elasticity<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-        Utilities::MapParsing::Options options(chemical_field_names, "Elastic shear moduli");
-        options.list_of_allowed_keys = compositional_field_names;
-
-        elastic_shear_moduli = Utilities::MapParsing::parse_map_to_double_array (prm.get("Elastic shear moduli"),
-                                                                                 options);
-
-        // Stabilize elasticity through a viscous damper
-        elastic_damper_viscosity = prm.get_double("Elastic damper viscosity");
-
-        if (prm.get ("Use fixed elastic time step") == "true")
-          use_fixed_elastic_time_step = true;
-        else if (prm.get ("Use fixed elastic time step") == "false")
-          use_fixed_elastic_time_step = false;
-        else
-          AssertThrow(false, ExcMessage("'Use fixed elastic time step' must be set to 'true' or 'false'"));
-
-        stabilization_time_scale_factor = prm.get_double ("Stabilization time scale factor");
-
-        fixed_elastic_time_step = prm.get_double ("Fixed elastic time step");
-        AssertThrow(fixed_elastic_time_step > 0,
-                    ExcMessage("The fixed elastic time step must be greater than zero"));
-
-        if (this->convert_output_to_years())
-          fixed_elastic_time_step *= year_in_seconds;
-
-        AssertThrow(this->get_parameters().enable_elasticity == true,
-                    ExcMessage ("Material model Viscoelastic only works if 'Enable elasticity' is set to true"));
-
-        // Check whether the compositional fields representing the viscoelastic
-        // stress tensor are both named correctly and listed in the right order.
-        AssertThrow(this->introspection().compositional_index_for_name("ve_stress_xx") == 0,
-                    ExcMessage("Rheology model Elasticity only works if the first "
-                               "compositional field is called ve_stress_xx."));
-        AssertThrow(this->introspection().compositional_index_for_name("ve_stress_yy") == 1,
-                    ExcMessage("Rheology model Elasticity only works if the second "
-                               "compositional field is called ve_stress_yy."));
-        if (dim == 2)
-          {
-            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_xy") == 2,
-                        ExcMessage("Rheology model Elasticity only works if the third "
-                                   "compositional field is called ve_stress_xy."));
-          }
-        else if (dim == 3)
-          {
-            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_zz") == 2,
-                        ExcMessage("Rheology model Elasticity only works if the third "
-                                   "compositional field is called ve_stress_zz."));
-            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_xy") == 3,
-                        ExcMessage("Rheology model Elasticity only works if the fourth "
-                                   "compositional field is called ve_stress_xy."));
-            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_xz") == 4,
-                        ExcMessage("Rheology model Elasticity only works if the fifth "
-                                   "compositional field is called ve_stress_xz."));
-            AssertThrow(this->introspection().compositional_index_for_name("ve_stress_yz") == 5,
-                        ExcMessage("Rheology model Elasticity only works if the sixth "
-                                   "compositional field is called ve_stress_yz."));
-          }
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        // Currently, it only makes sense to use this material model when the nonlinear solver
-        // scheme does a single Advection iteration and at minimum one Stokes iteration. More
-        // than one nonlinear Advection iteration will produce an unrealistic build-up of
-        // viscoelastic stress, which are tracked through compositional fields.
-        AssertThrow((this->get_parameters().nonlinear_solver ==
-                     Parameters<dim>::NonlinearSolver::single_Advection_single_Stokes
-                     ||
-                     this->get_parameters().nonlinear_solver ==
-                     Parameters<dim>::NonlinearSolver::single_Advection_iterated_Stokes
-                     ||
-                     this->get_parameters().nonlinear_solver ==
-                     Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes
-                     ||
-                     this->get_parameters().nonlinear_solver ==
-                     Parameters<dim>::NonlinearSolver::single_Advection_iterated_defect_correction_Stokes),
-                    ExcMessage("The material model will only work with the nonlinear "
-                               "solver schemes 'single Advection, single Stokes', "
-                               "'single Advection, iterated Stokes', "
-                               "'single Advection, iterated Newton Stokes', and "
-                               "'single Advection, iterated defect correction Stokes' "));
-
-        // Functionality to average the additional RHS terms over the cell is not implemented.
-        // Also, there is no option implemented in this rheology module to project to Q1 the viscosity
-        // in the elastic force term for the RHS.
-        // Consequently, it is only possible to use elasticity with the Material averaging schemes
-        // 'none', 'harmonic average only viscosity', and 'geometric average only viscosity'.
-        // TODO: Find a way to include 'project to Q1 only viscosity'.
-        AssertThrow((this->get_parameters().material_averaging == MaterialModel::MaterialAveraging::none
-                     ||
-                     this->get_parameters().material_averaging == MaterialModel::MaterialAveraging::harmonic_average_only_viscosity
-                     ||
-                     this->get_parameters().material_averaging == MaterialModel::MaterialAveraging::geometric_average_only_viscosity
-                     ||
-                     this->get_parameters().material_averaging == MaterialModel::MaterialAveraging::default_averaging),
-                    ExcMessage("Material models with elasticity can only be used with the material "
-                               "averaging schemes 'none', 'harmonic average only viscosity' and "
-                               "'geometric average only viscosity'. This parameter ('Material averaging') "
-                               "is located within the 'Material model' subsection."));
-      }
-
-
-
-      template <int dim>
-      void
-      Elasticity<dim>::create_elastic_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-        if (out.template get_additional_output<ElasticAdditionalOutputs<dim>>() == nullptr)
-          {
-            const unsigned int n_points = out.n_evaluation_points();
-            out.additional_outputs.push_back(
-              std::make_unique<ElasticAdditionalOutputs<dim>> (n_points));
-          }
-      }
-
-
-      namespace
-      {
-        MaterialAveraging::AveragingOperation
-        get_averaging_operation_for_viscosity(const MaterialAveraging::AveragingOperation operation)
-        {
-          MaterialAveraging::AveragingOperation operation_for_viscosity = operation;
-          switch (operation)
-            {
-              case MaterialAveraging::harmonic_average:
-                operation_for_viscosity = MaterialAveraging::harmonic_average_only_viscosity;
-                break;
-
-              case MaterialAveraging::geometric_average:
-                operation_for_viscosity = MaterialAveraging::geometric_average_only_viscosity;
-                break;
-
-              case MaterialAveraging::project_to_Q1:
-                operation_for_viscosity = MaterialAveraging::project_to_Q1_only_viscosity;
-                break;
-
-              default:
-                operation_for_viscosity = operation;
-            }
-
-          return operation_for_viscosity;
-        }
-      }
-
-
-
-      template <int dim>
-      void
-      Elasticity<dim>::fill_elastic_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
-                                             const std::vector<double> &average_elastic_shear_moduli,
-                                             MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-        // Create a reference to the structure for the elastic outputs
-        MaterialModel::ElasticOutputs<dim>
-        *elastic_out = out.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
-
-        if (elastic_out == nullptr)
-          return;
-
-        if (in.requests_property(MaterialProperties::additional_outputs))
-          {
-            // The viscosity should be averaged if material averaging is applied.
-            std::vector<double> effective_creep_viscosities;
-            if (this->get_parameters().material_averaging != MaterialAveraging::none)
-              {
-                MaterialModelOutputs<dim> out_copy(out.n_evaluation_points(),
-                                                   this->introspection().n_compositional_fields);
-                out_copy.viscosities = out.viscosities;
-
-                const MaterialAveraging::AveragingOperation averaging_operation_for_viscosity =
-                  get_averaging_operation_for_viscosity(this->get_parameters().material_averaging);
-                MaterialAveraging::average(averaging_operation_for_viscosity,
-                                           in.current_cell,
-                                           this->introspection().quadratures.velocities,
-                                           this->get_mapping(),
-                                           in.requested_properties,
-                                           out_copy);
-
-                effective_creep_viscosities = out_copy.viscosities;
-              }
-            else
-              effective_creep_viscosities = out.viscosities;
-
-            for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-              {
-                // Get old stresses from compositional fields
-                const SymmetricTensor<2,dim> stress_old (Utilities::Tensors::to_symmetric_tensor<dim>(&in.composition[i][0],
-                                                         &in.composition[i][0]+SymmetricTensor<2,dim>::n_independent_components));
-
-                elastic_out->elastic_force[i] = -effective_creep_viscosities[i] / calculate_elastic_viscosity(average_elastic_shear_moduli[i]) * stress_old;
-                // The viscoelastic strain rate is needed only when the Newton method is selected.
-                const typename Parameters<dim>::NonlinearSolver::Kind nonlinear_solver = this->get_parameters().nonlinear_solver;
-                if ((nonlinear_solver == Parameters<dim>::NonlinearSolver::iterated_Advection_and_Newton_Stokes) ||
-                    (nonlinear_solver == Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes))
-                  elastic_out->viscoelastic_strain_rate[i] = calculate_viscoelastic_strain_rate(in.strain_rate[i], stress_old, average_elastic_shear_moduli[i]);
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      Elasticity<dim>::fill_reaction_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
-                                              const std::vector<double> &average_elastic_shear_moduli,
-                                              MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-        if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0 && in.requests_property(MaterialProperties::reaction_terms))
-          {
-            // Get old (previous time step) velocity gradients
-            std::vector<Point<dim>> quadrature_positions(in.n_evaluation_points());
-            for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-              quadrature_positions[i] = this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]);
-
-            std::vector<double> solution_values(this->get_fe().dofs_per_cell);
-            in.current_cell->get_dof_values(this->get_old_solution(),
-                                            solution_values.begin(),
-                                            solution_values.end());
-
-            // Only create the evaluator the first time we get here
-            if (!evaluator)
-              evaluator = std::make_unique<FEPointEvaluation<dim,dim>>(this->get_mapping(),
-                                                                        this->get_fe(),
-                                                                        update_gradients,
-                                                                        this->introspection().component_indices.velocities[0]);
-
-            // Initialize the evaluator for the old velocity gradients
-            evaluator->reinit(in.current_cell, quadrature_positions);
-            evaluator->evaluate(solution_values,
-                                EvaluationFlags::gradients);
-
-            const double dte = elastic_timestep();
-            const double dt = this->get_timestep();
-
-            // The viscosity should be averaged if material averaging is applied.
-            // Here the averaging scheme "project to Q1 (only viscosity)"  is
-            // excluded, because there is no way to know the quadrature formula
-            // used for evaluation.
-            // TODO: find a way to include "project to Q1 (only viscosity)" as well.
-            std::vector<double> effective_creep_viscosities;
-            if (this->get_parameters().material_averaging != MaterialAveraging::none &&
-                this->get_parameters().material_averaging != MaterialAveraging::project_to_Q1 &&
-                this->get_parameters().material_averaging != MaterialAveraging::project_to_Q1_only_viscosity)
-              {
-                MaterialModelOutputs<dim> out_copy(out.n_evaluation_points(),
-                                                   this->introspection().n_compositional_fields);
-                out_copy.viscosities = out.viscosities;
-
-                const MaterialAveraging::AveragingOperation averaging_operation_for_viscosity =
-                  get_averaging_operation_for_viscosity(this->get_parameters().material_averaging);
-                MaterialAveraging::average(averaging_operation_for_viscosity,
-                                           in.current_cell,
-                                           this->introspection().quadratures.compositional_fields,
-                                           this->get_mapping(),
-                                           in.requested_properties,
-                                           out_copy);
-
-                effective_creep_viscosities = out_copy.viscosities;
-              }
-            else
-              effective_creep_viscosities = out.viscosities;
-
-            for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-              {
-                // Get old stresses from compositional fields
-                const SymmetricTensor<2,dim> stress_old(Utilities::Tensors::to_symmetric_tensor<dim>(&in.composition[i][0],
-                                                        &in.composition[i][0]+SymmetricTensor<2,dim>::n_independent_components));
-
-                // Calculate the rotated stresses
-                // Rotation (vorticity) tensor (equation 25 in Moresi et al., 2003, J. Comp. Phys.)
-                const Tensor<2,dim> rotation = 0.5 * (evaluator->get_gradient(i) - transpose(evaluator->get_gradient(i)));
-
-                // Calculate the current (new) stored elastic stress, which is a function of the material
-                // properties (viscoelastic viscosity, shear modulus), elastic time step size, strain rate,
-                // vorticity, prior (inherited) viscoelastic stresses and viscosity of the elastic damper.
-                // In the absence of the elastic damper, the expression for "stress_new" is identical
-                // to the one found in Moresi et al. (2003, J. Comp. Phys., equation 29).
-                const double damped_elastic_viscosity = calculate_elastic_viscosity(average_elastic_shear_moduli[i]);
-
-                // stress_0 is the combination of the elastic stress tensor stored at the end of the last time step and the change in that stress generated by local rotation
-                const SymmetricTensor<2,dim> stress_0 = (stress_old + dte * ( symmetrize(rotation * Tensor<2,dim>(stress_old) ) - symmetrize(Tensor<2,dim>(stress_old) * rotation) ) );
-
-                // stress_creep is the stress experienced by the viscous and elastic components.
-                Assert(std::isfinite(in.strain_rate[i].norm()),
-                       ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                                  "not filled by the caller."));
-                const SymmetricTensor<2,dim> stress_creep = 2. * effective_creep_viscosities[i] * ( deviator(in.strain_rate[i]) + stress_0 / (2. * damped_elastic_viscosity ) );
-
-                // stress_new is the (new) stored elastic stress
-                SymmetricTensor<2,dim> stress_new = stress_creep * (1. - (elastic_damper_viscosity / damped_elastic_viscosity)) + elastic_damper_viscosity * stress_0 / damped_elastic_viscosity;
-
-                // Stress averaging scheme to account for difference between the elastic time step
-                // and the numerical time step (see equation 32 in Moresi et al., 2003, J. Comp. Phys.)
-                // Note that if there is no difference between the elastic timestep and the numerical
-                // timestep, then no averaging occurs as dt/dte = 1.
-                stress_new = ( ( 1. - ( dt / dte ) ) * stress_old ) + ( ( dt / dte ) * stress_new ) ;
-
-                const SymmetricTensor<2,dim> stress_update = stress_new - stress_old;
-
-                // Fill reaction terms
-                Utilities::Tensors::unroll_symmetric_tensor_into_array(stress_update,
-                                                                       &out.reaction_terms[i][0],
-                                                                       &out.reaction_terms[i][0]+SymmetricTensor<2,dim>::n_independent_components);
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      double
-      Elasticity<dim>::elastic_timestep () const
-      {
-        // The elastic time step (dte) is equal to the numerical time step if the time step number
-        // is greater than 0 and the parameter 'use_fixed_elastic_time_step' is set to false.
-        // On the first (0) time step the elastic time step is always equal to the value
-        // specified in 'fixed_elastic_time_step', which is also used in all subsequent time
-        // steps if 'use_fixed_elastic_time_step' is set to true.
-        //
-        // We also use this parameter when we are still *before* the first time step,
-        // i.e., if the time step number is numbers::invalid_unsigned_int.
-        const double dte = ( ( this->get_timestep_number() > 0 &&
-                               this->simulator_is_past_initialization() &&
-                               use_fixed_elastic_time_step == false )
-                             ?
-                             this->get_timestep() * stabilization_time_scale_factor
-                             :
-                             fixed_elastic_time_step);
-        return dte;
-      }
-
-
-
-      template <int dim>
-      const std::vector<double> &
-      Elasticity<dim>::get_elastic_shear_moduli () const
-      {
-        return elastic_shear_moduli;
-      }
-
-
-
-      template <int dim>
-      double
-      Elasticity<dim>::
-      calculate_elastic_viscosity (const double shear_modulus) const
-      {
-        return shear_modulus*elastic_timestep() + elastic_damper_viscosity;
-      }
-
-
-
-      template <int dim>
-      double
-      Elasticity<dim>::
-      calculate_viscoelastic_viscosity (const double viscosity,
-                                        const double shear_modulus) const
-      {
-        const double elastic_viscosity = calculate_elastic_viscosity(shear_modulus);
-        return 1. / (1./elastic_viscosity + 1./viscosity);
-      }
-
-
-
-      template <int dim>
-      SymmetricTensor<2,dim>
-      Elasticity<dim>::
-      calculate_viscoelastic_strain_rate(const SymmetricTensor<2,dim> &strain_rate,
-                                         const SymmetricTensor<2,dim> &stored_stress,
-                                         const double shear_modulus) const
-      {
-        // The first term in the following expression is the deviator of the true strain rate
-        // of one or more isostress rheological elements (in series).
-        // One of these elements must be an elastic component (potentially damped).
-        // The second term corresponds to a fictional strain rate arising from
-        // elastic stresses stored from the last time step.
-        // Note the parallels with the viscous part of the strain rate deviator,
-        // which is equal to 0.5 * stress / viscosity.
-        return deviator(strain_rate) + 0.5 * deviator(stored_stress) /
-               calculate_elastic_viscosity(shear_modulus);
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  template class ElasticAdditionalOutputs<dim>; \
-  \
-  namespace Rheology \
-  { \
-    template class Elasticity<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/frank_kamenetskii.cc.bak b/source/material_model/rheology/frank_kamenetskii.cc.bak
deleted file mode 100644
index fc61a80485e..00000000000
--- a/source/material_model/rheology/frank_kamenetskii.cc.bak
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/frank_kamenetskii.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      template <int dim>
-      FrankKamenetskii<dim>::FrankKamenetskii ()
-        = default;
-
-
-
-      template <int dim>
-      double
-      FrankKamenetskii<dim>::compute_viscosity (const double temperature,
-                                                const unsigned int composition,
-                                                const double pressure,
-                                                const double density,
-                                                const double gravity) const
-      {
-        const double reference_temperature = this->get_adiabatic_surface_temperature();
-        const double reference_pressure = this->get_surface_pressure();
-        const double max_depth = this->get_geometry_model().maximal_depth();
-
-        //Frank-Kamenetskii equation with added pressure dependence terms
-        const double viscosity_frank_kamenetskii = prefactors_frank_kamenetskii[composition] * std::exp(viscosity_ratios_frank_kamenetskii[composition] * 0.5 * (1.0-temperature/reference_temperature)
-                                                   + pressure_prefactors_frank_kamenetskii[composition] * (pressure-reference_pressure)/(density*gravity*max_depth));
-
-
-        return viscosity_frank_kamenetskii;
-      }
-
-
-
-
-
-      template <int dim>
-      void
-      FrankKamenetskii<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Viscosity ratios for Frank Kamenetskii", "15.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "An adjusted viscosity ratio, $E$, for the viscosity approximation, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: None");
-        prm.declare_entry ("Prefactors for Frank Kamenetskii", "1.e21",
-                           Patterns::List(Patterns::Double (0.)),
-                           "A viscosity prefactor for the viscosity approximation, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None");
-
-        prm.declare_entry ("Pressure prefactors for Frank Kamenetskii", "0.0",
-                           Patterns::List(Patterns::Double (0.)),
-                           "A prefactor for the pressure term in the viscosity approximation, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: None");
-      }
-
-
-
-      template <int dim>
-      void
-      FrankKamenetskii<dim>::parse_parameters (ParameterHandler &prm)
-      {
-
-        AssertThrow (this->include_adiabatic_heating() == false,
-                     ExcMessage("The Frank-Kamenetskii rheology is currently only implemented for "
-                                "models without adiabatic heating. Please implement the necessary "
-                                "temperature adjustment if you need this feature."));
-
-        AssertThrow (this->get_adiabatic_surface_temperature() > 0.0,
-                     ExcMessage("The Frank-Kamenetskii rheology can only be used when the adiabatic "
-                                "surface temperature (reference_temperature in equation for viscosity) "
-                                "is non-zero."));
-
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-        // Make options file for parsing maps to double arrays
-        Utilities::MapParsing::Options options(chemical_field_names, "Viscosity ratios for Frank Kamenetskii");
-        options.list_of_allowed_keys = compositional_field_names;
-
-        viscosity_ratios_frank_kamenetskii = Utilities::MapParsing::parse_map_to_double_array (prm.get("Viscosity ratios for Frank Kamenetskii"),
-                                             options);
-
-        options.property_name = "Prefactors for Frank Kamenetskii";
-        prefactors_frank_kamenetskii = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactors for Frank Kamenetskii"),
-                                                                                        options);
-
-        options.property_name = "Pressure prefactors for Frank Kamenetskii";
-        pressure_prefactors_frank_kamenetskii = Utilities::MapParsing::parse_map_to_double_array(prm.get("Pressure prefactors for Frank Kamenetskii"),
-                                                options);
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class FrankKamenetskii<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/friction_models.cc.bak b/source/material_model/rheology/friction_models.cc.bak
deleted file mode 100644
index bb2d49361bb..00000000000
--- a/source/material_model/rheology/friction_models.cc.bak
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/rheology/friction_models.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/quadrature_lib.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      template <int dim>
-      double
-      FrictionModels<dim>::
-      compute_friction_angle(const double current_edot_ii,
-                             const unsigned int volume_fraction_index,
-                             const double static_friction_angle,
-                             const Point<dim> &position) const
-      {
-
-        switch (friction_mechanism)
-          {
-            case static_friction:
-            {
-              return static_friction_angle;
-            }
-            case dynamic_friction:
-            {
-              // Calculate effective steady-state friction coefficient.
-              // This is based on the former material model dynamic friction.
-              // The formula below is equivalent to the equation 13 in \cite{van_dinther_seismic_2013}.
-              // Although here the dynamic friction coefficient is directly specified. In addition,
-              // we also use a reference strain rate in place of a characteristic
-              // velocity divided by local element size. This reference strain rate is called
-              // the dynamic characteristic strain rate and is used to compute what value between
-              // dynamic and static angle of internal friction should be used.
-              // Furthermore a smoothness exponent X is added, which determines whether the
-              // friction vs strain rate curve is rather step-like or more gradual.
-              // mu  = mu_d + (mu_s - mu_d) / ( (1 + strain_rate_dev_inv2/dynamic_characteristic_strain_rate)^X );
-              // Angles of friction are used in radians within ASPECT. The coefficient
-              // of friction (mu) is the tangent of the internal angle of friction, hence convergence is needed.
-              // The incoming variable static_friction_angle holds the static friction angle. It's value is
-              // then updated with the strain rate dependent friction angle which is returned by the function.
-              const double mu = (std::tan(dynamic_angles_of_internal_friction[volume_fraction_index])
-                                 + (std::tan(static_friction_angle) - std::tan(dynamic_angles_of_internal_friction[volume_fraction_index]))
-                                 / (1. + std::pow((current_edot_ii / dynamic_characteristic_strain_rate),
-                                                  dynamic_friction_smoothness_exponent)));
-              const double dynamic_friction_angle = std::atan (mu);
-              Assert((mu < 1) && (0 < dynamic_friction_angle) && (dynamic_friction_angle <= 1.6), ExcMessage(
-                       "The friction coefficient should be larger than zero and smaller than 1. "
-                       "The friction angle should be smaller than 1.6 rad."));
-              return dynamic_friction_angle;
-            }
-            case function:
-            {
-              // Use a given function input per composition to get the friction angle
-              Utilities::NaturalCoordinate<dim> point =
-                this->get_geometry_model().cartesian_to_other_coordinates(position, coordinate_system_friction_function);
-
-              // we get time passed as seconds (always) but may want
-              // to reinterpret it in years
-              if (this->convert_output_to_years())
-                friction_function->set_time (this->get_time() / year_in_seconds);
-              else
-                friction_function->set_time (this->get_time());
-
-              // determine the friction angle based on position and composition
-              // The volume_fraction_index is based on the number of chemical compositional fields.
-              // However, this plugin reads a function for every compositional field, regardless of
-              // its type. Therefore we have to get the correct index.
-              // If no fields or no chemical fields are present, but only background material, the index is zero.
-              // If chemical fields are present, volume_fractions will be of size 1+n_chemical_composition_fields.
-              // The size of chemical_composition_field_indices will be one less.
-              unsigned int index = 0;
-              if (this->introspection().composition_type_exists(CompositionalFieldDescription::chemical_composition))
-                index = this->introspection().chemical_composition_field_indices()[volume_fraction_index-1];
-              double friction_from_function =
-                friction_function->value(Utilities::convert_array_to_point<dim>(point.get_coordinates()),index);
-
-              // Convert angles from degrees to radians
-              friction_from_function *= constants::degree_to_radians;
-
-              return friction_from_function;
-            }
-          }
-        // we should never get here, return something anyway, so the compiler does not complain...
-        AssertThrow (false, ExcMessage("Unknown friction model."));
-        return static_friction_angle;
-      }
-
-
-
-      template <int dim>
-      FrictionMechanism
-      FrictionModels<dim>::
-      get_friction_mechanism() const
-      {
-        return friction_mechanism;
-      }
-
-
-
-      template <int dim>
-      void
-      FrictionModels<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Friction mechanism", "none",
-                           Patterns::Selection("none|dynamic friction|function"),
-                           "Whether to make the friction angle dependent on strain rate or not. This rheology "
-                           "is intended to be used together with the visco-plastic rheology model."
-                           "\n\n"
-                           "\\item ``none'': No dependence of the friction angle is applied. "
-                           "\n\n"
-                           "\\item ``dynamic friction'': The friction angle is rate dependent."
-                           "When 'dynamic angles of internal friction' are specified, "
-                           "the friction angle will be weakened for high strain rates with: "
-                           "$\\mu = \\mu_d + \\frac{\\mu_s-\\mu_d}{1+\\frac{\\dot{\\epsilon}_{ii}}{\\dot{\\epsilon}_C}}^x$  "
-                           "where $\\mu_s$ and $\\mu_d$ are the friction angles at low and high strain rates, "
-                           "respectively. $\\dot{\\epsilon}_{ii}$ is the second invariant of the strain rate and "
-                           "$\\dot{\\epsilon}_C$ is the 'dynamic characteristic strain rate' where $\\mu = (\\mu_s+\\mu_d)/2$. "
-                           "The 'dynamic friction smoothness exponent' x controls how "
-                           "smooth or step-like the change from $\\mu_s$ to $\\mu_d$ is. "
-                           "The equation is modified after Equation (13) in \\cite{van_dinther_seismic_2013}. "
-                           "$\\mu_s$ and $\\mu_d$ can be specified by setting 'Angles of internal friction' and "
-                           "'Dynamic angles of internal friction', respectively. "
-                           "This relationship is similar to rate-and-state friction constitutive relationships, which "
-                           "are applicable to the strength of rocks during earthquakes."
-                           "\n\n"
-                           "\\item ``function'': Specify the friction angle as a function of space and time "
-                           "for each compositional field.");
-
-        // Dynamic friction parameters
-        prm.declare_entry ("Dynamic characteristic strain rate", "1e-12",
-                           Patterns::Double (0),
-                           "The characteristic strain rate value at which the angle of friction is "
-                           "equal to $\\mu = (\\mu_s+\\mu_d)/2$. When the effective strain rate "
-                           "is very high, the dynamic angle of friction is taken, when it is very low, "
-                           "the static angle of internal friction is used. Around the dynamic characteristic "
-                           "strain rate, there is a smooth gradient from the static to the dynamic angle "
-                           "of internal friction. "
-                           "Units: \\si{\\per\\second}.");
-
-        prm.declare_entry ("Dynamic angles of internal friction", "2",
-                           Patterns::List(Patterns::Double(0)),
-                           "List of dynamic angles of internal friction, $\\phi$, for background material and compositional "
-                           "fields, for a total of N$+$1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "Dynamic angles of friction are used as the current friction angle when the effective "
-                           "strain rate is well above the 'dynamic characteristic strain rate'. "
-                           "Units: \\si{\\degree}.");
-
-        prm.declare_entry ("Dynamic friction smoothness exponent", "1",
-                           Patterns::Double (0),
-                           "An exponential factor in the equation for the calculation of the friction angle when a "
-                           "static and a dynamic angle of internal friction are specified. A factor of 1 returns the equation "
-                           "to Equation (13) in \\cite{van_dinther_seismic_2013}. A factor between 0 and 1 makes the "
-                           "curve of the friction angle vs. the strain rate smoother, while a factor $>$ 1 makes "
-                           "the change between static and dynamic friction angle more steplike. "
-                           "Units: none.");
-
-        /**
-         * If friction is specified as a function input.
-         */
-        prm.enter_subsection("Friction function");
-        {
-          /**
-           * The function to specify the friction angle per composition can be declared in dependence
-           * of depth, cartesian coordinates or spherical coordinates. Note that the order
-           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
-           * this allows for dimension independent expressions.
-           */
-          prm.declare_entry ("Coordinate system", "cartesian",
-                             Patterns::Selection ("cartesian|spherical|depth"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `cartesian', `spherical', and `depth'. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle. `depth' "
-                             "will create a function, in which only the first "
-                             "parameter is non-zero, which is interpreted to "
-                             "be the depth of the point.");
-
-          Functions::ParsedFunction<dim>::declare_parameters(prm,1);
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      FrictionModels<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        // Friction dependence parameters
-        if (prm.get ("Friction mechanism") == "none")
-          friction_mechanism = static_friction;
-        else if (prm.get ("Friction mechanism") == "dynamic friction")
-          friction_mechanism = dynamic_friction;
-        else if (prm.get ("Friction mechanism") == "function")
-          friction_mechanism = function;
-        else
-          AssertThrow(false, ExcMessage("Not a valid friction mechanism option!"));
-
-        // Dynamic friction parameters
-        dynamic_characteristic_strain_rate = prm.get_double("Dynamic characteristic strain rate");
-
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(), "background");
-
-        Utilities::MapParsing::Options options(chemical_field_names, "Dynamic angles of internal friction");
-        options.list_of_allowed_keys = compositional_field_names;
-
-        dynamic_angles_of_internal_friction = Utilities::MapParsing::parse_map_to_double_array (prm.get("Dynamic angles of internal friction"),
-                                              options);
-
-        // Convert angles from degrees to radians
-        for (double &angle : dynamic_angles_of_internal_friction)
-          {
-            AssertThrow(angle <= 90,
-                        ExcMessage("Dynamic angles of friction must be <= 90 degrees"));
-            angle *= constants::degree_to_radians;
-          }
-
-        dynamic_friction_smoothness_exponent = prm.get_double("Dynamic friction smoothness exponent");
-
-
-        // Get the number of fields for composition-dependent material properties
-        // including the background field.
-        // TODO Make sure functions only have to be specified per chemical composition,
-        // but can still be specified for all fields for backwards compatibility.
-        const unsigned int n_fields = this->n_compositional_fields() + 1;
-
-        // if friction is specified as a function
-        if (friction_mechanism == function)
-          {
-            prm.enter_subsection("Friction function");
-            {
-              coordinate_system_friction_function = Utilities::Coordinates::string_to_coordinate_system(prm.get("Coordinate system"));
-              try
-                {
-                  friction_function
-                    = std::make_unique<Functions::ParsedFunction<dim>>(n_fields);
-                  friction_function->parse_parameters (prm);
-                }
-              catch (...)
-                {
-                  std::cerr << "FunctionParser failed to parse\n"
-                            << "\t friction function\n"
-                            << "with expression \n"
-                            << "\t' " << prm.get("Function expression") << "'";
-                  throw;
-                }
-            }
-            prm.leave_subsection();
-          }
-
-      }
-    }
-  }
-}
-
-
-
-// Explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class FrictionModels<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/peierls_creep.cc.bak b/source/material_model/rheology/peierls_creep.cc.bak
deleted file mode 100644
index 8b46fd86b72..00000000000
--- a/source/material_model/rheology/peierls_creep.cc.bak
+++ /dev/null
@@ -1,679 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/peierls_creep.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      PeierlsCreepParameters::PeierlsCreepParameters()
-        : prefactor (numbers::signaling_nan<double>()),
-          stress_exponent (numbers::signaling_nan<double>()),
-          activation_energy (numbers::signaling_nan<double>()),
-          activation_volume (numbers::signaling_nan<double>()),
-          peierls_stress (numbers::signaling_nan<double>()),
-          glide_parameter_p (numbers::signaling_nan<double>()),
-          glide_parameter_q (numbers::signaling_nan<double>()),
-          fitting_parameter (numbers::signaling_nan<double>()),
-          stress_cutoff (numbers::signaling_nan<double>())
-      {}
-
-
-
-      template <int dim>
-      PeierlsCreep<dim>::PeierlsCreep ()
-        = default;
-
-
-
-      /**
-       * Compute the creep parameters for the Peierls creep law.
-       */
-      template <int dim>
-      const PeierlsCreepParameters
-      PeierlsCreep<dim>::compute_creep_parameters (const unsigned int composition,
-                                                   const std::vector<double> &phase_function_values,
-                                                   const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        PeierlsCreepParameters creep_parameters;
-        if (phase_function_values == std::vector<double>())
-          {
-            // no phases
-            creep_parameters.prefactor = prefactors[composition];
-            creep_parameters.stress_exponent = stress_exponents[composition];
-            creep_parameters.activation_energy = activation_energies[composition];
-            creep_parameters.activation_volume = activation_volumes[composition];
-            creep_parameters.peierls_stress = peierls_stresses[composition];
-            creep_parameters.glide_parameter_p = glide_parameters_p[composition];
-            creep_parameters.glide_parameter_q = glide_parameters_q[composition];
-            creep_parameters.fitting_parameter = fitting_parameters[composition];
-            creep_parameters.stress_cutoff = stress_cutoffs[composition];
-          }
-        else
-          {
-            // Average among phases. This averaging is not strictly correct, but
-            // it will not matter much if the parameters are similar across transitions.
-            creep_parameters.prefactor = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                         prefactors, composition,  MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic);
-            creep_parameters.stress_exponent = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                               stress_exponents, composition);
-            creep_parameters.activation_energy = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 activation_energies, composition);
-            creep_parameters.activation_volume = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 activation_volumes, composition);
-            creep_parameters.peierls_stress = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                              peierls_stresses, composition);
-            creep_parameters.glide_parameter_p = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 glide_parameters_p, composition);
-            creep_parameters.glide_parameter_q = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 glide_parameters_q, composition);
-            creep_parameters.fitting_parameter = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                                 fitting_parameters, composition);
-            creep_parameters.stress_cutoff = MaterialModel::MaterialUtilities::phase_average_value(phase_function_values, n_phase_transitions_per_composition,
-                                             stress_cutoffs, composition);
-          }
-        return creep_parameters;
-      }
-
-
-
-      template <int dim>
-      double
-      PeierlsCreep<dim>::compute_approximate_viscosity (const double strain_rate,
-                                                        const double pressure,
-                                                        const double temperature,
-                                                        const unsigned int composition,
-                                                        const std::vector<double> &phase_function_values,
-                                                        const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        /**
-         * An approximation of the Peierls creep formulation, where stress is replaced with strain rate
-         * (second invariant) when calculating viscosity. This substitution requires a fitting parameter (gamma),
-         * which describes the relationship between stress and the Peierls stress (gamma = stress/stress_peierls).
-         * Details of this derivation can be found in the following document:
-         * https://ucdavis.app.box.com/s/cl5mwhkjeabol4otrdukfcdwfvg9me4w/file/705438695737
-         * The formulation for the viscosity is:
-         *   stress_term * arrhenius_term * strain_rate_term, where
-         * stress_term      = (0.5 * gamma * sigma_p) / (A * ((gamma * sigma_p)^n)^(1/(s+n)))
-         * arrhenius_term   = exp(( (E + P * V) / (R * T)) * (1 - gamma^p)^q / (s + n) )
-         * strain_rate_term = edot_ii^(1 / (s + n) - 1)
-         * Above,
-         * s = ((E + P * V) / (R * T)) * p * q * (1 - gamma^p)^(q-1) * (gamma^p)
-         * sigma_p is the Peierls stress
-         * gamma is the Peierls creep fitting parameter
-         * p is the first Peierls glide parameter
-         * q is the second Peierls creep glide parameter
-         * A is the Peierls prefactor term (1/s 1/Pa^2)
-         * n is the Peierls stress exponent
-         * E is the Peierls activation energy (J/mol)
-         * V is the Peierls activation volume (m^3/mol). However, to date V has always been set to 0.
-         * edot_ii is the second invariant of the deviatoric strain rate (1/s)
-         * T is temperature (K)
-         * R is the gas constant
-         */
-
-        const PeierlsCreepParameters p = compute_creep_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
-
-        const double s = ( (p.activation_energy + pressure * p.activation_volume) / (constants::gas_constant * temperature)) *
-                         p.glide_parameter_p * p.glide_parameter_q *
-                         std::pow((1. - std::pow(p.fitting_parameter, p.glide_parameter_p)),(p.glide_parameter_q - 1.)) *
-                         std::pow(p.fitting_parameter, p.glide_parameter_p);
-
-        const double stress_term = 0.5 * (p.fitting_parameter * p.peierls_stress) /
-                                   std::pow((p.prefactor * std::pow(p.fitting_parameter * p.peierls_stress,p.stress_exponent)),( 1. / (s + p.stress_exponent)));
-
-        const double arrhenius_term = std::exp( ((p.activation_energy + pressure * p.activation_volume) / (constants::gas_constant * temperature)) *
-                                                (std::pow((1. - std::pow(p.fitting_parameter,p.glide_parameter_p)),p.glide_parameter_q)) /
-                                                (s + p.stress_exponent) );
-
-        const double strain_rate_term = std::pow(strain_rate, (1. / (s + p.stress_exponent)) - 1.);
-
-        double viscosity_peierls = stress_term * arrhenius_term * strain_rate_term;
-
-        Assert (viscosity_peierls > 0.0,
-                ExcMessage ("Negative peierls viscosity detected. This is unphysical and should not happen. "
-                            "Check for negative parameters."));
-
-        // Creep viscosities become extremely large at low
-        // temperatures and can therefore provoke floating-point overflow errors. In
-        // real rocks, other deformation mechanisms become dominant at low temperatures,
-        // so these high viscosities are never achieved. It is therefore both reasonable
-        // and desirable to require the single-mechanism viscosity to be smaller than
-        // std::sqrt(max_double).
-        viscosity_peierls = std::min(viscosity_peierls, std::sqrt(std::numeric_limits<double>::max()));
-
-        return viscosity_peierls;
-      }
-
-
-
-      template <int dim>
-      double
-      PeierlsCreep<dim>::compute_exact_viscosity (const double strain_rate,
-                                                  const double pressure,
-                                                  const double temperature,
-                                                  const unsigned int composition,
-                                                  const std::vector<double> &phase_function_values,
-                                                  const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        /**
-         * A generalized Peierls creep formulation. The Peierls creep expression
-         * for the strain rate has multiple stress-dependent terms, and cannot be
-         * directly inverted to find an expression for viscosity in terms of
-         * strain rate. For this reason, a Newton-Raphson iteration is required,
-         * which can be quite expensive.
-         * The equation for the strain rate is given in
-         * compute_exact_strain_rate_and_derivative.
-         */
-        const PeierlsCreepParameters p = compute_creep_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
-
-        // The generalized Peierls creep flow law cannot be expressed as viscosity in
-        // terms of strain rate, because there are two stress-dependent terms
-        // in the strain rate expression.
-        // We use Newton's method to find the second invariant of the stress tensor.
-
-        // Apply a strict cutoff if this option is chosen by user. A strain rate cutoff
-        // will be first computed and then compared to the input strain rate. A cutoff
-        // on stress will be triggered if the input strain rate is smaller.
-        const double log_strain_rate = std::log(strain_rate);
-
-        if (apply_strict_cutoff)
-          {
-            const std::pair<double, double> log_edot_and_deriv = compute_exact_log_strain_rate_and_derivative(std::log(p.stress_cutoff), pressure, temperature, p);
-            if (log_strain_rate < log_edot_and_deriv.first)
-              {
-                double viscosity = 0.5 * p.stress_cutoff / strain_rate;
-                return viscosity;
-              }
-          }
-
-        // Create a starting guess for the stress using
-        // the approximate form of the viscosity expression
-        double viscosity = compute_approximate_viscosity(strain_rate, pressure, temperature, composition);
-        double log_stress_ii = std::log(2.*viscosity*strain_rate);
-
-        // Before the first iteration, compute the residual
-        // of the initial guess and the derivative
-        unsigned int stress_iteration = 0;
-        const std::pair<double, double> log_edot_and_deriv = compute_exact_log_strain_rate_and_derivative(log_stress_ii, pressure, temperature, p);
-        double strain_rate_residual = log_edot_and_deriv.first - log_strain_rate;
-        double log_strain_rate_deriv = log_edot_and_deriv.second;
-
-        while (std::abs(strain_rate_residual) > strain_rate_residual_threshold
-               && stress_iteration < stress_max_iteration_number)
-          {
-            // If the strain rate derivative is zero, we catch it below.
-            if (log_strain_rate_deriv>std::numeric_limits<double>::min())
-              log_stress_ii -= strain_rate_residual/log_strain_rate_deriv;
-
-            const std::pair<double, double> log_edot_and_deriv = compute_exact_log_strain_rate_and_derivative(log_stress_ii, pressure, temperature, p);
-
-            strain_rate_residual = log_edot_and_deriv.first - log_strain_rate;
-            log_strain_rate_deriv = log_edot_and_deriv.second;
-
-            stress_iteration += 1;
-
-            // If anything that would be used in the next iteration is not finite, the
-            // Newton iteration would trigger an exception and we want to abort the
-            // iteration instead.
-            // Currently, we still throw an exception, but if this exception is thrown,
-            // another more robust iterative scheme should be implemented
-            // (similar to that seen in the diffusion-dislocation material model).
-            const bool abort_newton_iteration = !numbers::is_finite(log_stress_ii)
-                                                || !numbers::is_finite(strain_rate_residual)
-                                                || !numbers::is_finite(log_strain_rate_deriv)
-                                                || log_strain_rate_deriv < std::numeric_limits<double>::min()
-                                                || stress_iteration == stress_max_iteration_number;
-            AssertThrow(!abort_newton_iteration,
-                        ExcMessage("No convergence has been reached in the loop that determines "
-                                   "the Peierls creep viscosity. Aborting! "
-                                   "Residual is " + Utilities::to_string(strain_rate_residual) +
-                                   " after " + Utilities::to_string(stress_iteration) + " iterations. "
-                                   "You can increase the number of iterations by adapting the "
-                                   "parameter 'Maximum Peierls strain rate iterations'."));
-          }
-
-        viscosity = 0.5*std::exp(log_stress_ii)/strain_rate;
-
-        return viscosity;
-      }
-
-
-
-      template <int dim>
-      double
-      PeierlsCreep<dim>::compute_viscosity (const double strain_rate,
-                                            const double pressure,
-                                            const double temperature,
-                                            const unsigned int composition,
-                                            const std::vector<double> &phase_function_values,
-                                            const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        double viscosity = 0.0;
-
-        switch (peierls_creep_flow_law)
-          {
-            case viscosity_approximation:
-            {
-              viscosity = compute_approximate_viscosity(strain_rate, pressure, temperature, composition, phase_function_values, n_phase_transitions_per_composition);
-              break;
-            }
-            case exact:
-            {
-              viscosity = compute_exact_viscosity(strain_rate, pressure, temperature, composition, phase_function_values, n_phase_transitions_per_composition);
-              break;
-            }
-            default:
-            {
-              AssertThrow(false, ExcNotImplemented());
-              break;
-            }
-          }
-
-        return viscosity;
-      }
-
-
-
-      template <int dim>
-      std::pair<double, double>
-      PeierlsCreep<dim>::compute_approximate_strain_rate_and_derivative (const double stress,
-                                                                         const double pressure,
-                                                                         const double temperature,
-                                                                         const PeierlsCreepParameters creep_parameters) const
-      {
-        /**
-        * b = (E+P*V)/(R*T)
-        * c = std::pow(gamma, p)
-        * d = std::pow(1. - c, q)
-        * s = b*p*q*c*d/(1. - c)
-        * arrhenius = std::exp(-b*d)
-        *
-        * edot_ii = A * std::pow(stress, s + n) * std::pow(gamma*peierls_stress, -s) * arrhenius
-        * deriv = edot_ii / stress * (s + n)
-        */
-        const PeierlsCreepParameters p = creep_parameters;
-
-        const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
-        const double c = std::pow(p.fitting_parameter, p.glide_parameter_p);
-        const double d = std::pow(1. - c, p.glide_parameter_q);
-        const double s = b*p.glide_parameter_p*p.glide_parameter_q*c*d/(1. - c);
-        const double arrhenius = std::exp(-b*d);
-
-        const double edot_ii = p.prefactor * std::pow(stress, s + p.stress_exponent) * std::pow(p.fitting_parameter*p.peierls_stress, -s) * arrhenius;
-        const double deriv = edot_ii / stress * (s + p.stress_exponent);
-
-        return std::make_pair(edot_ii, deriv);
-      }
-
-
-
-      template <int dim>
-      std::pair<double, double>
-      PeierlsCreep<dim>::compute_exact_strain_rate_and_derivative (const double stress,
-                                                                   const double pressure,
-                                                                   const double temperature,
-                                                                   const PeierlsCreepParameters creep_parameters) const
-      {
-        /**
-        * b = (E+P*V)/(R*T)
-        * c = std::pow(stress/peierls_stress, p)
-        * d = std::pow(1 - c, q)
-        * s = b*p*q*c*d/(1 - c)
-        * arrhenius = std::exp(-b*d)
-        *
-        * edot_ii = A * std::pow(stress, n) * arrhenius
-        * deriv = edot_ii / stress * (s + n)
-        */
-        const PeierlsCreepParameters p = creep_parameters;
-        if (stress < p.stress_cutoff)
-          {
-
-            /**
-            * For Peierls creep flow laws that have a stress exponent equal to zero the strain rate does not approach zero as
-            * stress approaches zero. To ensure convergence in the solver, the strain rate is modelled as a quadratic function
-            * of stress;
-            * edot_ii = quadratic_term*stress^2 + linear_term*stress
-            * Where the quadratic and linear terms are defined at a constant cutoff temperature and pressure.
-            * T_cutoff = (E/R), P_cutoff = 0
-            * s_cutoff = p*q*c_cutoff*d_cutoff / (1 - c_cutoff)
-            * arrhenius_cutoff = std::exp(-d_cutoff)
-            */
-            const double c_cutoff = std::pow(p.stress_cutoff/p.peierls_stress, p.glide_parameter_p);
-            const double d_cutoff = std::pow(1. - c_cutoff, p.glide_parameter_q);
-            const double s_cutoff = p.glide_parameter_p*p.glide_parameter_q*c_cutoff*d_cutoff/(1. - c_cutoff);
-            const double arrhenius_cutoff = std::exp(-d_cutoff);
-            const double edot_ii_cutoff = p.prefactor * std::pow(p.stress_cutoff, p.stress_exponent) * arrhenius_cutoff;
-            const double deriv_cutoff = edot_ii_cutoff / p.stress_cutoff * (s_cutoff + p.stress_exponent);
-            const double quadratic_term = (deriv_cutoff - edot_ii_cutoff / p.stress_cutoff) / p.stress_cutoff / arrhenius_cutoff;
-            const double linear_term = (2*(edot_ii_cutoff / p.stress_cutoff) - deriv_cutoff) / arrhenius_cutoff;
-
-            const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
-            const double arrhenius = std::exp(-b*d_cutoff);
-            const double edot_ii = (quadratic_term*std::pow(stress, 2.) + linear_term*stress) * arrhenius;
-            const double deriv = (2*quadratic_term*stress + linear_term) * arrhenius;
-
-            return std::make_pair(edot_ii, deriv);
-          }
-
-        else
-          {
-            const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
-            const double c = std::pow(stress/p.peierls_stress, p.glide_parameter_p);
-            const double d = std::pow(1. - c, p.glide_parameter_q);
-            const double s = b*p.glide_parameter_p*p.glide_parameter_q*c*d/(1. - c);
-            const double arrhenius = std::exp(-b*d);
-
-            const double edot_ii = p.prefactor * std::pow(stress, p.stress_exponent) * arrhenius;
-            const double deriv = edot_ii / stress * (s + p.stress_exponent);
-
-            return std::make_pair(edot_ii, deriv);
-          }
-      }
-
-
-
-      template <int dim>
-      std::pair<double, double>
-      PeierlsCreep<dim>::compute_exact_log_strain_rate_and_derivative (const double log_stress,
-                                                                       const double pressure,
-                                                                       const double temperature,
-                                                                       const PeierlsCreepParameters creep_parameters) const
-      {
-        /**
-        * b = (E+P*V)/(R*T)
-        * c = std::pow(stress/peierls_stress, p)
-        * d = std::pow(1 - c, q)
-        *
-        * log_edot_ii = std::log(A) + n * std::log(stress) - b*d
-        * deriv_log = n + p * q * b * std::(1-c, p.q - 1)
-        * The deriv_log is the derivative of log(edot_ii) to log(stress).
-        */
-        const PeierlsCreepParameters p = creep_parameters;
-        const double stress = std::exp(log_stress);
-        if (stress < p.stress_cutoff)
-          {
-
-            /**
-            * For Peierls creep flow laws that have a stress exponent equal to zero the strain rate does not approach zero as
-            * stress approaches zero. To ensure convergence in the solver, the strain rate is modelled as a quadratic function
-            * of stress;
-            * edot_ii = quadratic_term*stress^2 + linear_term*stress
-            * Where the quadratic and linear terms are defined at a constant cutoff temperature and pressure.
-            * T_cutoff = (E/R), P_cutoff = 0
-            * s_cutoff = p*q*c_cutoff*d_cutoff / (1 - c_cutoff)
-            * arrhenius_cutoff = std::exp(-d_cutoff)
-            */
-            const double c_cutoff = std::pow(p.stress_cutoff/p.peierls_stress, p.glide_parameter_p);
-            const double d_cutoff = std::pow(1. - c_cutoff, p.glide_parameter_q);
-            const double s_cutoff = p.glide_parameter_p*p.glide_parameter_q*c_cutoff*d_cutoff/(1. - c_cutoff);
-            const double arrhenius_cutoff = std::exp(-d_cutoff);
-            const double edot_ii_cutoff = p.prefactor * std::pow(p.stress_cutoff, p.stress_exponent) * arrhenius_cutoff;
-            const double deriv_cutoff = edot_ii_cutoff / p.stress_cutoff * (s_cutoff + p.stress_exponent);
-            const double quadratic_term = (deriv_cutoff - edot_ii_cutoff / p.stress_cutoff) / p.stress_cutoff / arrhenius_cutoff;
-            const double linear_term = (2*(edot_ii_cutoff / p.stress_cutoff) - deriv_cutoff) / arrhenius_cutoff;
-
-            const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
-            const double arrhenius = std::exp(-b*d_cutoff);
-            const double edot_ii = (quadratic_term*std::pow(stress, 2.) + linear_term*stress) * arrhenius;
-            const double deriv_log = 2 - linear_term / (quadratic_term * stress + linear_term);
-
-            return std::make_pair(std::log(edot_ii), deriv_log);
-          }
-        else
-          {
-            const double b = (p.activation_energy + pressure*p.activation_volume)/(constants::gas_constant * temperature);
-            const double c = std::pow(stress/p.peierls_stress, p.glide_parameter_p);
-            const double d = std::pow(1. - c, p.glide_parameter_q);
-
-            const double log_edot_ii = std::log(p.prefactor) + p.stress_exponent * log_stress - b*d ;
-            const double deriv_log = p.stress_exponent + p.glide_parameter_p * p.glide_parameter_q * b * c * std::pow(1-c, p.glide_parameter_q - 1);
-
-            return std::make_pair(log_edot_ii, deriv_log);
-          }
-      }
-
-
-
-      template <int dim>
-      std::pair<double, double>
-      PeierlsCreep<dim>::compute_strain_rate_and_derivative (const double stress,
-                                                             const double pressure,
-                                                             const double temperature,
-                                                             const PeierlsCreepParameters creep_parameters) const
-      {
-        std::pair<double, double> strain_rate_and_deriv;
-
-        switch (peierls_creep_flow_law)
-          {
-            case viscosity_approximation:
-            {
-              strain_rate_and_deriv = compute_approximate_strain_rate_and_derivative(stress, pressure, temperature, creep_parameters);
-              break;
-            }
-            case exact:
-            {
-              strain_rate_and_deriv = compute_exact_strain_rate_and_derivative(stress, pressure, temperature, creep_parameters);
-              break;
-            }
-            default:
-            {
-              AssertThrow(false, ExcNotImplemented());
-              break;
-            }
-          }
-        return strain_rate_and_deriv;
-      }
-
-
-
-      template <int dim>
-      void
-      PeierlsCreep<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Peierls creep flow law", "viscosity approximation",
-                           Patterns::Selection("viscosity approximation|exact"),
-                           "Select what type of Peierls creep flow law to use. Currently, the "
-                           "available options are 'exact', which uses a Newton-Raphson iterative method "
-                           "to find the stress and then compute viscosity, and 'viscosity approximation', "
-                           "in which viscosity is an explicit function of the strain rate invariant, "
-                           "rather than stress. ");
-
-        // Viscosity iteration parameters
-        prm.declare_entry ("Peierls strain rate residual tolerance", "1e-10", Patterns::Double(0.),
-                           "Tolerance for the iterative solve to find the correct Peierls creep strain rate. "
-                           "The tolerance is expressed as the difference between the natural logarithm of the "
-                           "input strain rate and the strain rate at the current iteration.");
-        prm.declare_entry ("Maximum Peierls strain rate iterations", "40", Patterns::Integer(0),
-                           "Maximum number of iterations to find the correct "
-                           "Peierls strain rate.");
-
-        // Rheological parameters
-        prm.declare_entry ("Prefactors for Peierls creep", "1.4e-19",
-                           Patterns::Anything(),
-                           "List of viscosity prefactors, $A$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\pascal}$^{-n_{\\text{peierls}}}$ \\si{\\per\\second}");
-        prm.declare_entry ("Stress exponents for Peierls creep", "2.0",
-                           Patterns::Anything(),
-                           "List of stress exponents, $n_{\\text{peierls}}$, for background material and compositional "
-                           "fields, for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-        prm.declare_entry ("Activation energies for Peierls creep", "320e3",
-                           Patterns::Anything(),
-                           "List of activation energies, $E$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. Units: \\si{\\joule\\per\\mole}.");
-        prm.declare_entry ("Activation volumes for Peierls creep", "1.4e-5",
-                           Patterns::Anything(),
-                           "List of activation volumes, $V$, for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\meter\\cubed\\per\\mole}.");
-        prm.declare_entry ("Peierls stresses", "5.e9",
-                           Patterns::Anything(),
-                           "List of stress limits for Peierls creep $\\sigma_{\\text{peierls}}$ for background "
-                           "material and compositional fields, for a total of N+1 values, where N is the number "
-                           "of all compositional fields or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. "
-                           "Units: \\si{\\pascal}");
-        prm.declare_entry ("Peierls fitting parameters", "0.17",
-                           Patterns::Anything(),
-                           "List of fitting parameters $\\gamma$ between stress $\\sigma$ and the Peierls "
-                           "stress $\\sigma_{\\text{peierls}}$ for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. If only one value is given, "
-                           "then all use the same value. Units: none");
-        prm.declare_entry ("Peierls glide parameters p", "0.5",
-                           Patterns::Anything(),
-                           "List of the first Peierls creep glide parameters, $p$, for background and compositional "
-                           "fields for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. Units: none");
-        prm.declare_entry ("Peierls glide parameters q", "1.0",
-                           Patterns::Anything(),
-                           "List of the second Peierls creep glide parameters, $q$, for background and compositional "
-                           "fields for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. Units: none");
-        prm.declare_entry ("Cutoff stresses for Peierls creep", "0.0",
-                           Patterns::Anything(),
-                           "List of the Stress thresholds below which the strain rate is solved for as a quadratic "
-                           "function of stress to aid with convergence when stress exponent n=0. Units: \\si{\\pascal}");
-        prm.declare_entry ("Apply strict stress cutoff for Peierls creep", "false", Patterns::Bool(),
-                           "Whether the cutoff stresses for Peierls creep are used as the minimum "
-                           "stresses in the Peierls rheology");
-
-      }
-
-
-
-      template <int dim>
-      void
-      PeierlsCreep<dim>::parse_parameters (ParameterHandler &prm,
-                                           const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
-      {
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-        if (prm.get ("Peierls creep flow law") == "viscosity approximation")
-          peierls_creep_flow_law = viscosity_approximation;
-        else if (prm.get ("Peierls creep flow law") == "exact")
-          peierls_creep_flow_law = exact;
-        else
-          AssertThrow(false, ExcMessage("Not a valid Peierls creep flow law"));
-
-        // Iteration parameters
-        strain_rate_residual_threshold = prm.get_double ("Peierls strain rate residual tolerance");
-        stress_max_iteration_number = prm.get_integer ("Maximum Peierls strain rate iterations");
-
-        // Rheological parameters
-        // Make options file for parsing maps to double arrays
-        Utilities::MapParsing::Options options(chemical_field_names, "Prefactors for Peierls creep");
-        options.list_of_allowed_keys = compositional_field_names;
-        options.allow_multiple_values_per_key = true;
-        if (expected_n_phases_per_composition)
-          {
-            options.n_values_per_key = *expected_n_phases_per_composition;
-
-            // check_values_per_key is required to be true to duplicate single values
-            // if they are to be used for all phases associated with a given key.
-            options.check_values_per_key = true;
-          }
-
-        prefactors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactors for Peierls creep"),
-                                                                      options);
-
-        options.property_name = "Stress exponents for Peierls creep";
-        stress_exponents = Utilities::MapParsing::parse_map_to_double_array(prm.get("Stress exponents for Peierls creep"),
-                                                                            options);
-
-        options.property_name = "Activation energies for Peierls creep";
-        activation_energies = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation energies for Peierls creep"),
-                                                                               options);
-
-        options.property_name = "Activation volumes for Peierls creep";
-        activation_volumes = Utilities::MapParsing::parse_map_to_double_array(prm.get("Activation volumes for Peierls creep"),
-                                                                              options);
-
-        options.property_name = "Peierls stresses";
-        peierls_stresses = Utilities::MapParsing::parse_map_to_double_array(prm.get("Peierls stresses"),
-                                                                            options);
-
-        options.property_name = "Peierls fitting parameters";
-        fitting_parameters = Utilities::MapParsing::parse_map_to_double_array(prm.get("Peierls fitting parameters"),
-                                                                              options);
-
-        options.property_name = "Peierls glide parameters p";
-        glide_parameters_p = Utilities::MapParsing::parse_map_to_double_array(prm.get("Peierls glide parameters p"),
-                                                                              options);
-
-        options.property_name = "Peierls glide parameters q";
-        glide_parameters_q = Utilities::MapParsing::parse_map_to_double_array(prm.get("Peierls glide parameters q"),
-                                                                              options);
-
-        options.property_name = "Cutoff stresses for Peierls creep";
-        stress_cutoffs = Utilities::MapParsing::parse_map_to_double_array(prm.get("Cutoff stresses for Peierls creep"),
-                                                                          options);
-
-        apply_strict_cutoff = prm.get_bool("Apply strict stress cutoff for Peierls creep");
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class PeierlsCreep<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/strain_dependent.cc.bak b/source/material_model/rheology/strain_dependent.cc.bak
deleted file mode 100644
index d50c760d20c..00000000000
--- a/source/material_model/rheology/strain_dependent.cc.bak
+++ /dev/null
@@ -1,917 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/rheology/strain_dependent.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-#include <aspect/utilities.h>
-#include <aspect/postprocess/particles.h>
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/numerics/fe_field_function.h>
-#include <deal.II/base/quadrature_lib.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace Rheology
-    {
-      template <int dim>
-      void
-      StrainDependent<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Strain weakening mechanism", "default",
-                           Patterns::Selection("none|finite strain tensor|total strain|plastic weakening with plastic strain only|plastic weakening with total strain only|plastic weakening with plastic strain and viscous weakening with viscous strain|viscous weakening with viscous strain only|default"),
-                           "Whether to apply strain weakening to viscosity, cohesion and internal angle"
-                           "of friction based on accumulated finite strain, and if yes, which method to "
-                           "use. The following methods are available:"
-                           "\n\n"
-                           "\\item ``none'': No strain weakening is applied. "
-                           "\n\n"
-                           "\\item ``finite strain tensor'': The full finite strain tensor is tracked, "
-                           "and its second invariant is used to weaken both the plastic yield stress "
-                           "(specifically, the cohesion and friction angle) and the pre-yield viscosity "
-                           "that arises from diffusion and/or dislocation creep."
-                           "\n\n"
-                           "\\item ``total strain'': The finite strain is approximated as the product of "
-                           "the second invariant of the strain rate in each time step and the time step "
-                           "size, and this quantity is integrated and tracked over time. It is used to "
-                           "weaken both the plastic yield stress (specifically, the cohesion and friction "
-                           "angle) and the pre-yield viscosity."
-                           "\n\n"
-                           "\\item ``plastic weakening with plastic strain only'': The finite strain is "
-                           "approximated as the product of the second invariant of the strain rate"
-                           "in each time step and the time step size in regions where material is "
-                           "plastically yielding. This quantity is integrated and tracked over time, and "
-                           "used to weaken the cohesion and friction angle. The pre-yield viscosity is "
-                           "not weakened."
-                           "\n\n"
-                           "\\item ``plastic weakening with total strain only'': The finite strain is "
-                           "approximated as the product of the second invariant of the strain rate in each "
-                           "time step and the time step size, and this quantity is integrated and tracked "
-                           "over time. It is used to weaken the plastic yield stress (specifically, the "
-                           "cohesion and internal friction angle). The pre-yield viscosity is not weakened."
-                           "\n\n"
-                           "\\item ``plastic weakening with plastic strain and viscous weakening with viscous strain'': "
-                           "Both the finite strain accumulated by plastic deformation and by viscous deformation are "
-                           "computed separately (each approximated as the product of the second invariant of the "
-                           "corresponding strain rate in each time step and the time step size). The plastic strain "
-                           "is used to weaken the plastic yield stress (specifically, the cohesion and yield angle), and "
-                           "the viscous strain is used to weaken the pre-yield viscosity."
-                           "\n\n"
-                           "\\item ``viscous weakening with viscous strain only'': The finite strain is "
-                           "approximated as the product of the second invariant of the strain rate "
-                           "in each time step and the time step size in regions where material is "
-                           "not plastically yielding. This quantity is integrated and tracked over time, and "
-                           "used to weaken the pre-yield viscosity. The cohesion and friction angle are "
-                           "not weakened."
-                           "\n\n"
-                           "\\item ``default'': The default option has the same behavior as ``none'', "
-                           "but is there to make sure that the original parameters for specifying the "
-                           "strain weakening mechanism (``Use plastic/viscous strain weakening'') are still allowed, "
-                           "but to guarantee that one uses either the old parameter names or the new ones, "
-                           "never both."
-                           "\n\n"
-                           "If a compositional field named 'noninitial\\_plastic\\_strain' is "
-                           "included in the parameter file, this field will automatically be excluded from "
-                           "from volume fraction calculation and track the cumulative plastic strain with "
-                           "the initial plastic strain values removed.");
-
-        prm.declare_entry ("Start plasticity strain weakening intervals", "0.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of strain weakening interval initial strains "
-                           "for the cohesion and friction angle parameters of the "
-                           "background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. Units: None.");
-
-        prm.declare_entry ("End plasticity strain weakening intervals", "1.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of strain weakening interval final strains "
-                           "for the cohesion and friction angle parameters of the "
-                           "background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-
-        prm.declare_entry ("Cohesion strain weakening factors", "1.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of cohesion strain weakening factors "
-                           "for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-
-        prm.declare_entry ("Friction strain weakening factors", "1.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of friction strain weakening factors "
-                           "for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-
-        prm.declare_entry ("Start prefactor strain weakening intervals", "0.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of strain weakening interval initial strains "
-                           "for the diffusion and dislocation prefactor parameters of the "
-                           "background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-
-        prm.declare_entry ("End prefactor strain weakening intervals", "1.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of strain weakening interval final strains "
-                           "for the diffusion and dislocation prefactor parameters of the "
-                           "background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-
-        prm.declare_entry ("Prefactor strain weakening factors", "1.",
-                           Patterns::List(Patterns::Double(0., 1.)),
-                           "List of viscous strain weakening factors "
-                           "for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value.  Units: None.");
-
-
-        prm.declare_entry ("Use temperature activated strain softening", "false",
-                           Patterns::Bool (),
-                           "Whether viscous strain softening factor depends on temperature");
-
-        prm.declare_entry ("Lower temperature for onset of strain weakening", "823.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of lower temperature for onset of strain weakening "
-                           "for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
-
-        prm.declare_entry ("Lower temperature for maximum strain weakening", "923.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of lower temperature for maximum strain weakening "
-                           "for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
-
-        prm.declare_entry ("Upper temperature for maximum strain weakening", "1023.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of upper temperatures for maximum strain weakening "
-                           "for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
-
-        prm.declare_entry ("Upper temperature for onset of strain weakening", "1123.",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of upper temperatures for onset of strain weakening"
-                           "for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields "
-                           "or only those corresponding to chemical compositions. "
-                           "If only one value is given, then all use the same value. Units: \\si{\\kelvin}.");
-
-        prm.declare_entry ("Strain healing mechanism", "no healing",
-                           Patterns::Selection("no healing|temperature dependent"),
-                           "Whether to apply strain healing to plastic yielding and viscosity terms, "
-                           "and if yes, which method to use. The following methods are available:"
-                           "\n\n"
-                           "\\item ``no healing'': No strain healing is applied. "
-                           "\n\n"
-                           "\\item ``temperature dependent'': Purely temperature dependent "
-                           "strain healing applied to plastic yielding and viscosity terms, similar "
-                           "to the temperature-dependent Frank Kamenetskii formulation, computes "
-                           "strain healing as removing strain as a function of temperature, time, "
-                           "and a user-defined healing rate and prefactor "
-                           "as done in Fuchs and Becker, 2019, for mantle convection");
-
-        prm.declare_entry ("Strain healing temperature dependent recovery rate", "1.e-15", Patterns::Double(0),
-                           "Recovery rate prefactor for temperature dependent "
-                           "strain healing. Units: $1/s$");
-
-        prm.declare_entry ("Strain healing temperature dependent prefactor", "15.", Patterns::Double(0),
-                           "Prefactor for temperature dependent "
-                           "strain healing. Units: None");
-      }
-
-      template <int dim>
-      void
-      StrainDependent<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        // number of required compositional fields for full finite strain tensor
-        const unsigned int s = Tensor<2,dim>::n_independent_components;
-
-        // Strain weakening parameters
-        if (prm.get ("Strain weakening mechanism") == "none")
-          weakening_mechanism = none;
-        else if (prm.get ("Strain weakening mechanism") == "finite strain tensor")
-          weakening_mechanism = finite_strain_tensor;
-        else if (prm.get ("Strain weakening mechanism") == "total strain")
-          weakening_mechanism = total_strain;
-        else if (prm.get ("Strain weakening mechanism") == "plastic weakening with plastic strain only")
-          weakening_mechanism = plastic_weakening_with_plastic_strain_only;
-        else if (prm.get ("Strain weakening mechanism") == "plastic weakening with total strain only")
-          weakening_mechanism = plastic_weakening_with_total_strain_only;
-        else if (prm.get ("Strain weakening mechanism") == "plastic weakening with plastic strain and viscous weakening with viscous strain")
-          weakening_mechanism = plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain;
-        else if (prm.get ("Strain weakening mechanism") == "viscous weakening with viscous strain only")
-          weakening_mechanism = viscous_weakening_with_viscous_strain_only;
-        else if (prm.get ("Strain weakening mechanism") == "default")
-          weakening_mechanism = none;
-        else
-          AssertThrow(false, ExcMessage("Not a valid Strain weakening mechanism!"));
-
-        if (weakening_mechanism == plastic_weakening_with_plastic_strain_only
-            || weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
-          {
-            AssertThrow(this->introspection().compositional_name_exists("plastic_strain"),
-                        ExcMessage("Material model visco_plastic with plastic strain weakening only works if there is a "
-                                   "compositional field called plastic_strain."));
-          }
-
-        if (weakening_mechanism == viscous_weakening_with_viscous_strain_only
-            || weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
-          {
-            AssertThrow(this->introspection().compositional_name_exists("viscous_strain"),
-                        ExcMessage("Material model visco_plastic with viscous strain weakening only works if there is a "
-                                   "compositional field called viscous_strain."));
-          }
-
-        if (weakening_mechanism == finite_strain_tensor)
-          {
-            AssertThrow(this->n_compositional_fields() >= s,
-                        ExcMessage("There must be enough compositional fields to track all components of the finite strain tensor (4 in 2d, 9 in 3d). "));
-            // Assert that fields exist and that they are in the right order
-            const unsigned int n_s11 = this->introspection().compositional_index_for_name("s11");
-            const unsigned int n_s12 = this->introspection().compositional_index_for_name("s12");
-            const unsigned int n_s21 = this->introspection().compositional_index_for_name("s21");
-            const unsigned int n_s22 = this->introspection().compositional_index_for_name("s22");
-            if (dim==2)
-              {
-                AssertThrow(n_s11 < n_s12 && n_s12 < n_s21 && n_s21 < n_s22,
-                            ExcMessage("A material model with strain weakening using the full strain tensor only works if there are "
-                                       "compositional fields called sij, with i=1,..,dim and j=1,...,dim listed in the following order: "
-                                       "s11, s12, s21, s22."));
-                AssertThrow(n_s22 == n_s11+s-1, ExcMessage("The strain tensor components should be represented by consecutive fields."));
-              }
-            if (dim==3)
-              {
-                const unsigned int n_s13 = this->introspection().compositional_index_for_name("s13");
-                const unsigned int n_s23 = this->introspection().compositional_index_for_name("s23");
-                const unsigned int n_s31 = this->introspection().compositional_index_for_name("s31");
-                const unsigned int n_s32 = this->introspection().compositional_index_for_name("s32");
-                const unsigned int n_s33 = this->introspection().compositional_index_for_name("s33");
-                AssertThrow(n_s11 < n_s12 && n_s12 < n_s13 && n_s13 < n_s21 && n_s21 < n_s22 && n_s22 < n_s23 && n_s23 < n_s31 && n_s31 < n_s32 && n_s32 < n_s33,
-                            ExcMessage("A material model with strain weakening using the full strain tensor only works if there are "
-                                       "compositional fields called sij, with i=1,..,dim and j=1,...,dim listed in the following order: "
-                                       "s11, s12, s13, s21, s22, s23, s31, s32, s33."));
-                AssertThrow(n_s33 == n_s11+s-1, ExcMessage("The strain tensor components should be represented by consecutive fields."));
-              }
-          }
-
-
-        if (weakening_mechanism == total_strain || weakening_mechanism == plastic_weakening_with_total_strain_only)
-          AssertThrow(this->introspection().compositional_name_exists("total_strain"),
-                      ExcMessage("Material model visco_plastic with total strain weakening only works if there is a "
-                                 "compositional field called total_strain."));
-
-        // Currently, it only makes sense to use this material model with strain weakening when the
-        // nonlinear solver scheme does a single advection iteration. More than one nonlinear advection
-        // iteration will result in the incorrect value of strain being used in the material model, as
-        // the compositional fields representing strain are updated through the reaction terms.
-        if (weakening_mechanism != none)
-          {
-            AssertThrow((this->get_parameters().nonlinear_solver ==
-                         Parameters<dim>::NonlinearSolver::single_Advection_single_Stokes
-                         ||
-                         this->get_parameters().nonlinear_solver ==
-                         Parameters<dim>::NonlinearSolver::single_Advection_iterated_Stokes
-                         ||
-                         this->get_parameters().nonlinear_solver ==
-                         Parameters<dim>::NonlinearSolver::iterated_Advection_and_Stokes
-                         ||
-                         this->get_parameters().nonlinear_solver ==
-                         Parameters<dim>::NonlinearSolver::single_Advection_iterated_Newton_Stokes
-                         ||
-                         this->get_parameters().nonlinear_solver ==
-                         Parameters<dim>::NonlinearSolver::iterated_Advection_and_Newton_Stokes
-                         ||
-                         this->get_parameters().nonlinear_solver ==
-                         Parameters<dim>::NonlinearSolver::single_Advection_iterated_defect_correction_Stokes
-                         ||
-                         this->get_parameters().nonlinear_solver ==
-                         Parameters<dim>::NonlinearSolver::iterated_Advection_and_defect_correction_Stokes
-                         ||
-                         this->get_parameters().nonlinear_solver ==
-                         Parameters<dim>::NonlinearSolver::no_Advection_no_Stokes),
-                        ExcMessage("The material model will only work with the nonlinear "
-                                   "solver schemes 'single Advection, single Stokes', "
-                                   "'single Advection, iterated Stokes', "
-                                   "'iterated Advection and Stokes', "
-                                   "'single Advection, iterated Newton Stokes', "
-                                   "'iterated Advection and Newton Stokes', "
-                                   "'single Advection, iterated defect correction Stokes', "
-                                   "'iterated Advection and defect correction Stokes, and' "
-                                   "'no Advection, no Stokes' "
-                                   "when strain weakening is enabled."));
-          }
-
-
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-        Utilities::MapParsing::Options options(chemical_field_names, "Start plasticity strain weakening intervals");
-        options.list_of_allowed_keys = compositional_field_names;
-
-        start_plastic_strain_weakening_intervals = Utilities::MapParsing::parse_map_to_double_array(prm.get("Start plasticity strain weakening intervals"),
-                                                   options);
-
-        options.property_name = "End plasticity strain weakening intervals";
-        end_plastic_strain_weakening_intervals = Utilities::MapParsing::parse_map_to_double_array(prm.get("End plasticity strain weakening intervals"),
-                                                 options);
-
-        options.property_name = "Start prefactor strain weakening intervals";
-        start_viscous_strain_weakening_intervals = Utilities::MapParsing::parse_map_to_double_array(prm.get("Start prefactor strain weakening intervals"),
-                                                   options);
-
-        options.property_name = "End prefactor strain weakening intervals";
-        end_viscous_strain_weakening_intervals = Utilities::MapParsing::parse_map_to_double_array(prm.get("End prefactor strain weakening intervals"),
-                                                 options);
-
-        options.property_name = "Prefactor strain weakening factors";
-        viscous_strain_weakening_factors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Prefactor strain weakening factors"),
-                                           options);
-
-        options.property_name = "Lower temperature for onset of strain weakening";
-        viscous_strain_weakening_T0 = Utilities::MapParsing::parse_map_to_double_array(prm.get("Lower temperature for onset of strain weakening"),
-                                                                                       options);
-
-        options.property_name = "Lower temperature for maximum strain weakening";
-        viscous_strain_weakening_T1 = Utilities::MapParsing::parse_map_to_double_array(prm.get("Lower temperature for maximum strain weakening"),
-                                                                                       options);
-
-        options.property_name = "Upper temperature for maximum strain weakening";
-        viscous_strain_weakening_T2 = Utilities::MapParsing::parse_map_to_double_array(prm.get("Upper temperature for maximum strain weakening"),
-                                                                                       options);
-
-        options.property_name = "Upper temperature for onset of strain weakening";
-        viscous_strain_weakening_T3 = Utilities::MapParsing::parse_map_to_double_array(prm.get("Upper temperature for onset of strain weakening"),
-                                                                                       options);
-
-        use_temperature_activated_strain_softening = prm.get_bool("Use temperature activated strain softening");
-
-
-        options.property_name = "Cohesion strain weakening factors";
-        cohesion_strain_weakening_factors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Cohesion strain weakening factors"),
-                                            options);
-
-        options.property_name = "Friction strain weakening factors";
-        friction_strain_weakening_factors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Friction strain weakening factors"),
-                                            options);
-
-        if (prm.get ("Strain healing mechanism") == "no healing")
-          healing_mechanism = no_healing;
-        else if (prm.get ("Strain healing mechanism") == "temperature dependent")
-          healing_mechanism = temperature_dependent;
-        else
-          AssertThrow(false, ExcMessage("Not a valid Strain healing mechanism!"));
-
-        // Currently this functionality only works in field composition
-        if (healing_mechanism != no_healing && this->n_particle_worlds() > 0)
-          {
-            const Particle::Property::Manager<dim> &particle_property_manager = this->get_particle_world(0).get_property_manager();
-            AssertThrow(particle_property_manager.plugin_name_exists("viscoplastic strain invariants") == false, ExcMessage("This healing mechanism currently does not work if the strain is tracked on particles."));
-          }
-
-        // Temperature dependent strain healing requires that adiabatic surface temperature is non zero
-        if (healing_mechanism == temperature_dependent)
-          {
-            AssertThrow (this->get_adiabatic_surface_temperature() > 0.0,
-                         ExcMessage("The temperature dependent strain healing can only be used when the adiabatic "
-                                    "surface temperature (reference_temperature in equation for strain healing) "
-                                    "is non-zero."));
-          }
-
-        strain_healing_temperature_dependent_recovery_rate = prm.get_double ("Strain healing temperature dependent recovery rate");
-
-        strain_healing_temperature_dependent_prefactor = prm.get_double ("Strain healing temperature dependent prefactor");
-      }
-
-
-
-      template <int dim>
-      std::array<double, 3>
-      StrainDependent<dim>::
-      compute_strain_weakening_factors(const std::vector<double> &composition,
-                                       const unsigned int j) const
-      {
-        double viscous_weakening = 1.0;
-        std::pair<double, double> brittle_weakening (1.0, 1.0);
-
-        switch (weakening_mechanism)
-          {
-            case none:
-            {
-              break;
-            }
-            case finite_strain_tensor:
-            {
-              // Calculate second invariant of left stretching tensor "L"
-              const Tensor<2,dim> strain(make_array_view(&composition[0],
-                                                         &composition[0] + Tensor<2,dim>::n_independent_components));
-              const SymmetricTensor<2,dim> L = symmetrize( strain * transpose(strain) );
-
-              const double strain_ii = std::fabs(second_invariant(L));
-              brittle_weakening = calculate_plastic_weakening(strain_ii, j);
-              viscous_weakening = calculate_viscous_weakening(strain_ii, j);
-              break;
-            }
-            case total_strain:
-            {
-              const unsigned int total_strain_index = this->introspection().compositional_index_for_name("total_strain");
-              brittle_weakening = calculate_plastic_weakening(composition[total_strain_index], j);
-              viscous_weakening = calculate_viscous_weakening(composition[total_strain_index], j);
-              break;
-            }
-            case plastic_weakening_with_total_strain_only:
-            {
-              const unsigned int total_strain_index = this->introspection().compositional_index_for_name("total_strain");
-              brittle_weakening = calculate_plastic_weakening(composition[total_strain_index], j);
-              break;
-            }
-            case plastic_weakening_with_plastic_strain_only:
-            {
-              const unsigned int plastic_strain_index = this->introspection().compositional_index_for_name("plastic_strain");
-              brittle_weakening = calculate_plastic_weakening(composition[plastic_strain_index], j);
-              break;
-            }
-            case plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain:
-            {
-              const unsigned int plastic_strain_index = this->introspection().compositional_index_for_name("plastic_strain");
-              brittle_weakening = calculate_plastic_weakening(composition[plastic_strain_index], j);
-              const unsigned int viscous_strain_index = this->introspection().compositional_index_for_name("viscous_strain");
-              viscous_weakening = calculate_viscous_weakening(composition[viscous_strain_index], j);
-              break;
-            }
-            case viscous_weakening_with_viscous_strain_only:
-            {
-              const unsigned int viscous_strain_index = this->introspection().compositional_index_for_name("viscous_strain");
-              viscous_weakening = calculate_viscous_weakening(composition[viscous_strain_index], j);
-              break;
-            }
-            default:
-            {
-              AssertThrow(false, ExcNotImplemented());
-              break;
-            }
-          }
-
-        const std::array<double, 3> weakening_factors = {{brittle_weakening.first,brittle_weakening.second,viscous_weakening}};
-
-        return weakening_factors;
-
-      }
-
-
-
-      template <int dim>
-      std::array<double, 3>
-      StrainDependent<dim>::
-      compute_strain_weakening_factors(const unsigned int j,
-                                       const std::vector<double> &composition) const
-      {
-        return compute_strain_weakening_factors(composition,j);
-      }
-
-
-
-      template <int dim>
-      std::array<double, 3>
-      StrainDependent<dim>::
-      apply_temperature_dependence_to_strain_weakening_factors(const std::array<double, 3> &weakening_factors,
-                                                               const double temperature,
-                                                               const unsigned int j) const
-      {
-
-        double factor = 1;
-        const double T0 = viscous_strain_weakening_T0[j];
-        const double T1 = viscous_strain_weakening_T1[j];
-        const double T2 = viscous_strain_weakening_T2[j];
-        const double T3 = viscous_strain_weakening_T3[j];
-        std::array<double, 3> output = weakening_factors;
-
-        if (temperature>T0 && temperature<=T1)
-          factor = (output[2]-1.) / (T1-T0)*(temperature-T0) + 1.;
-        else if (temperature>T1 && temperature<=T2)
-          factor = output[2];
-        else if (temperature>T2 && temperature<=T3)
-          factor = (1-output[2]) / (T3-T2)*(temperature-T2) + output[2];
-        output[2] = factor;
-
-        return output;
-
-      }
-
-
-
-      template <int dim>
-      double
-      StrainDependent<dim>::
-      calculate_strain_healing(const MaterialModel::MaterialModelInputs<dim> &in,
-                               const unsigned int j) const
-      {
-        const double reference_temperature = this->get_adiabatic_surface_temperature();
-        double healed_strain = 0.0;
-
-        switch (healing_mechanism)
-          {
-            case no_healing:
-            {
-              break;
-            }
-            case temperature_dependent:
-            {
-              healed_strain = strain_healing_temperature_dependent_recovery_rate *
-                              std::exp(-strain_healing_temperature_dependent_prefactor * 0.5 * (1.0 - in.temperature[j]/reference_temperature))
-                              * this->get_timestep();
-              break;
-            }
-          }
-        return healed_strain;
-      }
-
-      template <int dim>
-      std::pair<double, double>
-      StrainDependent<dim>::
-      calculate_plastic_weakening(const double strain_ii,
-                                  const unsigned int j) const
-      {
-        // Constrain the second strain invariant of the previous timestep by the strain interval
-        const double cut_off_strain_ii = std::max(std::min(strain_ii,end_plastic_strain_weakening_intervals[j]),start_plastic_strain_weakening_intervals[j]);
-
-        // Linear strain weakening of cohesion and internal friction angle between specified strain values
-        const double strain_fraction = (cut_off_strain_ii - start_plastic_strain_weakening_intervals[j]) /
-                                       (start_plastic_strain_weakening_intervals[j] - end_plastic_strain_weakening_intervals[j]);
-
-        const double weakening_cohesion = 1. + (1. - cohesion_strain_weakening_factors[j]) * strain_fraction;
-        const double weakening_friction = 1. + (1. - friction_strain_weakening_factors[j]) * strain_fraction;
-
-        return std::make_pair (weakening_cohesion, weakening_friction);
-      }
-
-
-      template <int dim>
-      double
-      StrainDependent<dim>::
-      calculate_viscous_weakening(const double strain_ii,
-                                  const unsigned int j) const
-      {
-        // Constrain the second strain invariant of the previous timestep by the strain interval
-        const double cut_off_strain_ii = std::max(std::min(strain_ii,end_viscous_strain_weakening_intervals[j]),start_viscous_strain_weakening_intervals[j]);
-
-        // Linear strain weakening of the viscous flow law prefactors between specified strain values
-        const double strain_fraction = (cut_off_strain_ii - start_viscous_strain_weakening_intervals[j]) /
-                                       (start_viscous_strain_weakening_intervals[j] - end_viscous_strain_weakening_intervals[j]);
-        return 1. + ( 1. - viscous_strain_weakening_factors[j] ) * strain_fraction;
-      }
-
-      template <int dim>
-      void
-      StrainDependent<dim>::
-      fill_reaction_outputs (const MaterialModel::MaterialModelInputs<dim> &in,
-                             const int i,
-                             const double min_strain_rate,
-                             const bool plastic_yielding,
-                             MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-
-        // If strain weakening is used, overwrite the first reaction term,
-        // which represents the second invariant of the (plastic) strain tensor.
-        // If plastic strain is tracked (so not the total strain), only overwrite
-        // when plastically yielding.
-        // If viscous strain is also tracked, overwrite the second reaction term as well.
-        // Calculate changes in strain and update the reaction terms
-        if  (this->simulator_is_past_initialization() && this->get_timestep_number() > 0 && in.requests_property(MaterialProperties::reaction_terms))
-          {
-            Assert(std::isfinite(in.strain_rate[i].norm()),
-                   ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                              "not filled by the caller."));
-
-            const double edot_ii = std::max(std::sqrt(std::max(-second_invariant(deviator(in.strain_rate[i])), 0.)),
-                                            min_strain_rate);
-            double delta_e_ii = edot_ii*this->get_timestep();
-
-            // Assign accumulated strain value according to active deformation mechanism
-
-            // Plastic strain
-            double delta_e_ii_plastic = 0.;
-            if (plastic_yielding == true)
-              delta_e_ii_plastic = delta_e_ii;
-
-            // Viscous strain
-            double delta_e_ii_viscous = 0.;
-            if (plastic_yielding == false)
-              delta_e_ii_viscous = delta_e_ii;
-
-            // Now account for strain healing
-            if (healing_mechanism != no_healing)
-              {
-                // Temperature-dependent healing occurs independent of deformation state
-                const double healed_strain = calculate_strain_healing(in,i);
-
-                delta_e_ii_plastic -= healed_strain;
-                delta_e_ii_viscous -= healed_strain;
-                delta_e_ii -= healed_strain;
-              }
-
-            // We need to obtain the strain values from compositional fields at the previous time step,
-            // as the values from the current linearization point are an extrapolation of the solution
-            // from the old timesteps.
-            // Prepare the field function and extract the old solution values at the current cell.
-            std::vector<Point<dim>> quadrature_positions(1,this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]));
-
-            // Use a boost::small_vector to avoid memory allocation if possible.
-            // Create 100 values by default, which should be enough for most cases.
-            // If there are more than 100 DoFs per cell, this will work like a normal vector.
-            boost::container::small_vector<double, 100> old_solution_values(this->get_fe().dofs_per_cell);
-            in.current_cell->get_dof_values(this->get_old_solution(),
-                                            old_solution_values.begin(),
-                                            old_solution_values.end());
-
-            // If we have not been here before, create one evaluator for each compositional field
-            if (composition_evaluators.size() == 0)
-              composition_evaluators.resize(this->n_compositional_fields());
-
-            // Make sure the evaluators have been initialized correctly, and have not been tampered with
-            Assert(composition_evaluators.size() == this->n_compositional_fields(),
-                   ExcMessage("The number of composition evaluators should be equal to the number of compositional fields."));
-
-            const auto &component_indices = this->introspection().component_indices.compositional_fields;
-
-            // Assign incremental strain values to reaction terms
-            if (weakening_mechanism == plastic_weakening_with_plastic_strain_only)
-              {
-                const unsigned int strain_index = this->introspection().compositional_index_for_name("plastic_strain");
-                // Only create the evaluator the first time we get here
-                if (!composition_evaluators[strain_index])
-                  composition_evaluators[strain_index]
-                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
-                                                                   this->get_fe(),
-                                                                   update_values,
-                                                                   component_indices[strain_index]);
-
-                composition_evaluators[strain_index]->reinit(in.current_cell, quadrature_positions);
-                composition_evaluators[strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
-                                                               EvaluationFlags::values);
-                out.reaction_terms[i][strain_index] = std::max(delta_e_ii_plastic,
-                                                               -composition_evaluators[strain_index]->get_value(0));
-              }
-            if (weakening_mechanism == viscous_weakening_with_viscous_strain_only)
-              {
-                const unsigned int strain_index = this->introspection().compositional_index_for_name("viscous_strain");
-                // Only create the evaluator the first time we get here
-                if (!composition_evaluators[strain_index])
-                  composition_evaluators[strain_index]
-                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
-                                                                   this->get_fe(),
-                                                                   update_values,
-                                                                   component_indices[strain_index]);
-
-                composition_evaluators[strain_index]->reinit(in.current_cell, quadrature_positions);
-                composition_evaluators[strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
-                                                               EvaluationFlags::values);
-                out.reaction_terms[i][strain_index] = std::max(delta_e_ii_viscous,
-                                                               -composition_evaluators[strain_index]->get_value(0));
-              }
-            if (weakening_mechanism == total_strain || weakening_mechanism == plastic_weakening_with_total_strain_only)
-              {
-                const unsigned int strain_index = this->introspection().compositional_index_for_name("total_strain");
-                // Only create the evaluator the first time we get here
-                if (!composition_evaluators[strain_index])
-                  composition_evaluators[strain_index]
-                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
-                                                                   this->get_fe(),
-                                                                   update_values,
-                                                                   component_indices[strain_index]);
-                composition_evaluators[strain_index]->reinit(in.current_cell, quadrature_positions);
-                composition_evaluators[strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
-                                                               EvaluationFlags::values);
-                out.reaction_terms[i][strain_index] = std::max(delta_e_ii,
-                                                               -composition_evaluators[strain_index]->get_value(0));
-              }
-            if (weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
-              {
-                const unsigned int plastic_strain_index = this->introspection().compositional_index_for_name("plastic_strain");
-                // Only create the evaluator the first time we get here
-                if (!composition_evaluators[plastic_strain_index])
-                  composition_evaluators[plastic_strain_index]
-                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
-                                                                   this->get_fe(),
-                                                                   update_values,
-                                                                   component_indices[plastic_strain_index]);
-                composition_evaluators[plastic_strain_index]->reinit(in.current_cell, quadrature_positions);
-                composition_evaluators[plastic_strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
-                                                                       EvaluationFlags::values);
-                out.reaction_terms[i][plastic_strain_index] = std::max(delta_e_ii_plastic,
-                                                                       -composition_evaluators[plastic_strain_index]->get_value(0));
-
-                const unsigned viscous_strain_index = this->introspection().compositional_index_for_name("viscous_strain");
-                // Only create the evaluator the first time we get here
-                if (!composition_evaluators[viscous_strain_index])
-                  composition_evaluators[viscous_strain_index]
-                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
-                                                                   this->get_fe(),
-                                                                   update_values,
-                                                                   component_indices[viscous_strain_index]);
-                composition_evaluators[viscous_strain_index]->reinit(in.current_cell, quadrature_positions);
-                composition_evaluators[viscous_strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
-                                                                       EvaluationFlags::values);
-                out.reaction_terms[i][viscous_strain_index] = std::max(delta_e_ii_viscous,
-                                                                       -composition_evaluators[viscous_strain_index]->get_value(0));
-              }
-            if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
-              {
-                const unsigned int strain_index = this->introspection().compositional_index_for_name("noninitial_plastic_strain");
-                // Only create the evaluator the first time we get here
-                if (!composition_evaluators[strain_index])
-                  composition_evaluators[strain_index]
-                    = std::make_unique<FEPointEvaluation<1, dim>>(this->get_mapping(),
-                                                                   this->get_fe(),
-                                                                   update_values,
-                                                                   component_indices[strain_index]);
-
-                composition_evaluators[strain_index]->reinit(in.current_cell, quadrature_positions);
-                composition_evaluators[strain_index]->evaluate({old_solution_values.data(),old_solution_values.size()},
-                                                               EvaluationFlags::values);
-                out.reaction_terms[i][strain_index] = std::max(delta_e_ii_plastic,
-                                                               -composition_evaluators[strain_index]->get_value(0));
-              }
-          }
-      }
-
-
-      template <int dim>
-      void
-      StrainDependent<dim>::
-      compute_finite_strain_reaction_terms(const MaterialModel::MaterialModelInputs<dim> &in,
-                                           MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-
-        if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0 &&
-            in.requests_property(MaterialProperties::reaction_terms) && weakening_mechanism == finite_strain_tensor)
-          {
-            // We need the velocity gradient for the finite strain (they are not
-            // in material model inputs), so we get them from the finite element.
-            std::vector<Point<dim>> quadrature_positions(in.n_evaluation_points());
-            for (unsigned int i = 0; i < in.n_evaluation_points(); ++i)
-              quadrature_positions[i] = this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]);
-
-            std::vector<double> solution_values(this->get_fe().dofs_per_cell);
-            in.current_cell->get_dof_values(this->get_solution(),
-                                            solution_values.begin(),
-                                            solution_values.end());
-
-            // Only create the evaluator the first time we get here
-            if (!evaluator)
-              evaluator = std::make_unique<FEPointEvaluation<dim, dim>>(this->get_mapping(),
-                                                                         this->get_fe(),
-                                                                         update_gradients,
-                                                                         this->introspection().component_indices.velocities[0]);
-
-            // Initialize the evaluator for the old velocity gradients
-            evaluator->reinit(in.current_cell, quadrature_positions);
-            evaluator->evaluate(solution_values,
-                                EvaluationFlags::gradients);
-
-            // Assign the strain components to the compositional fields reaction terms.
-            // If there are too many fields, we simply fill only the first fields with the
-            // existing strain tensor components.
-
-            for (unsigned int q = 0; q < in.n_evaluation_points(); ++q)
-              {
-                if (in.current_cell.state() == IteratorState::valid)
-
-                  {
-                    // Convert the compositional fields into the tensor quantity they represent.
-                    Tensor<2, dim> strain;
-                    const unsigned int n_first = this->introspection().compositional_index_for_name("s11");
-                    for (unsigned int i = n_first; i < n_first + Tensor<2, dim>::n_independent_components; ++i)
-                      {
-                        strain[Tensor<2, dim>::unrolled_to_component_indices(i)] = in.composition[q][i];
-                      }
-
-                    // Compute the strain accumulated in this timestep.
-                    const Tensor<2, dim> strain_increment = this->get_timestep() * (evaluator->get_gradient(q) * strain);
-
-                    // Output the strain increment component-wise to its respective compositional field's reaction terms.
-                    for (unsigned int i = n_first; i < n_first + Tensor<2, dim>::n_independent_components; ++i)
-                      {
-                        out.reaction_terms[q][i] = strain_increment[Tensor<2, dim>::unrolled_to_component_indices(i)];
-                      }
-                  }
-              }
-          }
-      }
-
-      template <int dim>
-      ComponentMask
-      StrainDependent<dim>::
-      get_strain_composition_mask() const
-      {
-
-        // Store which components to exclude during volume fraction computation.
-        ComponentMask strain_mask(this->n_compositional_fields(),true);
-
-        if (weakening_mechanism != none)
-          {
-            if (weakening_mechanism == plastic_weakening_with_plastic_strain_only || weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
-              strain_mask.set(this->introspection().compositional_index_for_name("plastic_strain"),false);
-
-            if (weakening_mechanism == viscous_weakening_with_viscous_strain_only || weakening_mechanism == plastic_weakening_with_plastic_strain_and_viscous_weakening_with_viscous_strain)
-              strain_mask.set(this->introspection().compositional_index_for_name("viscous_strain"),false);
-
-            if (weakening_mechanism == total_strain || weakening_mechanism == plastic_weakening_with_total_strain_only)
-              strain_mask.set(this->introspection().compositional_index_for_name("total_strain"),false);
-
-            if (weakening_mechanism == finite_strain_tensor)
-              {
-                const unsigned int n_start = this->introspection().compositional_index_for_name("s11");
-                for (unsigned int i = n_start; i < n_start + Tensor<2,dim>::n_independent_components ; ++i)
-                  strain_mask.set(i,false);
-              }
-          }
-
-        if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
-          strain_mask.set(this->introspection().compositional_index_for_name("noninitial_plastic_strain"),false);
-
-        return strain_mask;
-      }
-
-      template <int dim>
-      WeakeningMechanism
-      StrainDependent<dim>::
-      get_weakening_mechanism() const
-      {
-        return weakening_mechanism;
-      }
-
-      template <int dim>
-      HealingMechanism
-      StrainDependent<dim>::
-      get_healing_mechanism() const
-      {
-        return healing_mechanism;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  namespace Rheology \
-  { \
-    template class StrainDependent<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/rheology/visco_plastic.cc.bak b/source/material_model/rheology/visco_plastic.cc.bak
deleted file mode 100644
index 2fe6259e7d2..00000000000
--- a/source/material_model/rheology/visco_plastic.cc.bak
+++ /dev/null
@@ -1,855 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/rheology/visco_plastic.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/utilities.h>
-#include <aspect/newton.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace
-    {
-      std::vector<std::string> make_plastic_additional_outputs_names()
-      {
-        std::vector<std::string> names;
-        names.emplace_back("current_cohesions");
-        names.emplace_back("current_friction_angles");
-        names.emplace_back("current_yield_stresses");
-        names.emplace_back("plastic_yielding");
-        return names;
-      }
-    }
-
-    template <int dim>
-    PlasticAdditionalOutputs<dim>::PlasticAdditionalOutputs(const unsigned int n_points)
-      : NamedAdditionalMaterialOutputs<dim>(make_plastic_additional_outputs_names()),
-        cohesions(n_points, numbers::signaling_nan<double>()),
-        friction_angles(n_points, numbers::signaling_nan<double>()),
-        yield_stresses(n_points, numbers::signaling_nan<double>()),
-        yielding(n_points, numbers::signaling_nan<double>())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    PlasticAdditionalOutputs<dim>::get_nth_output(const unsigned int idx) const
-    {
-      AssertIndexRange (idx, 4);
-      switch (idx)
-        {
-          case 0:
-            return cohesions;
-
-          case 1:
-            return friction_angles;
-
-          case 2:
-            return yield_stresses;
-
-          case 3:
-            return yielding;
-
-          default:
-            AssertThrow(false, ExcInternalError());
-        }
-      // We will never get here, so just return something
-      return cohesions;
-    }
-
-
-
-    namespace Rheology
-    {
-
-      template <int dim>
-      ViscoPlastic<dim>::ViscoPlastic ()
-        = default;
-
-
-
-      template <int dim>
-      IsostrainViscosities
-      ViscoPlastic<dim>::
-      calculate_isostrain_viscosities (const MaterialModel::MaterialModelInputs<dim> &in,
-                                       const unsigned int i,
-                                       const std::vector<double> &volume_fractions,
-                                       const std::vector<double> &phase_function_values,
-                                       const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        IsostrainViscosities output_parameters;
-
-        // Initialize or fill variables used to calculate viscosities
-        output_parameters.composition_yielding.resize(volume_fractions.size(), false);
-        output_parameters.composition_viscosities.resize(volume_fractions.size(), numbers::signaling_nan<double>());
-        output_parameters.current_friction_angles.resize(volume_fractions.size(), numbers::signaling_nan<double>());
-        output_parameters.current_cohesions.resize(volume_fractions.size(), numbers::signaling_nan<double>());
-
-        // Assemble stress tensor if elastic behavior is enabled
-        SymmetricTensor<2,dim> stress_old = numbers::signaling_nan<SymmetricTensor<2,dim>>();
-        if (this->get_parameters().enable_elasticity)
-          {
-            for (unsigned int j=0; j < SymmetricTensor<2,dim>::n_independent_components; ++j)
-              stress_old[SymmetricTensor<2,dim>::unrolled_to_component_indices(j)] = in.composition[i][j];
-          }
-
-        // Use a specified "reference" strain rate if the strain rate is not yet available,
-        // or close to zero. This is to avoid division by zero.
-        const bool use_reference_strainrate = this->simulator_is_past_initialization() == false
-                                              ||
-                                              (this->get_timestep_number() == 0 &&
-                                               this->get_nonlinear_iteration() == 0)
-                                              ||
-                                              (in.strain_rate[i].norm() <= std::numeric_limits<double>::min());
-
-        double edot_ii;
-        if (use_reference_strainrate)
-          edot_ii = ref_strain_rate;
-        else
-          // Calculate the square root of the second moment invariant for the deviatoric strain rate tensor.
-          edot_ii = std::max(std::sqrt(std::max(-second_invariant(deviator(in.strain_rate[i])), 0.)),
-                             min_strain_rate);
-
-        // Calculate viscosities for each of the individual compositional phases
-        for (unsigned int j=0; j < volume_fractions.size(); ++j)
-          {
-            // Step 1: viscous behavior
-            double non_yielding_viscosity = numbers::signaling_nan<double>();
-
-            // Choice of activation volume depends on whether there is an adiabatic temperature
-            // gradient used when calculating the viscosity. This allows the same activation volume
-            // to be used in incompressible and compressible models.
-            const double temperature_for_viscosity = (this->simulator_is_past_initialization())
-                                                     ?
-                                                     in.temperature[i] + adiabatic_temperature_gradient_for_viscosity*in.pressure[i]
-                                                     :
-                                                     this->get_adiabatic_conditions().temperature(in.position[i]);
-
-            AssertThrow(temperature_for_viscosity != 0, ExcMessage(
-                          "The temperature used in the calculation of the visco-plastic rheology is zero. "
-                          "This is not allowed, because this value is used to divide through. It is probably "
-                          "being caused by the temperature being zero somewhere in the model. The relevant "
-                          "values for debugging are: temperature (" + Utilities::to_string(in.temperature[i]) +
-                          "), adiabatic_temperature_gradient_for_viscosity ("
-                          + Utilities::to_string(adiabatic_temperature_gradient_for_viscosity) + ") and pressure ("
-                          + Utilities::to_string(in.pressure[i]) + ")."));
-            {
-
-              // Step 1a: compute viscosity from diffusion creep law, at least if it is going to be used
-
-              // Determine whether to use the adiabatic pressure instead of the full pressure (default)
-              // when calculating creep viscosity.
-              double pressure_for_creep = in.pressure[i];
-
-              if (use_adiabatic_pressure_in_creep)
-                pressure_for_creep = this->get_adiabatic_conditions().pressure(in.position[i]);
-
-              const double viscosity_diffusion
-                = (viscous_flow_law != dislocation
-                   ?
-                   diffusion_creep.compute_viscosity(pressure_for_creep, temperature_for_viscosity, j,
-                                                     phase_function_values,
-                                                     n_phase_transitions_per_composition)
-                   :
-                   numbers::signaling_nan<double>());
-
-              // Step 1b: compute viscosity from dislocation creep law
-              const double viscosity_dislocation
-                = (viscous_flow_law != diffusion
-                   ?
-                   dislocation_creep.compute_viscosity(edot_ii, pressure_for_creep, temperature_for_viscosity, j,
-                                                       phase_function_values,
-                                                       n_phase_transitions_per_composition)
-                   :
-                   numbers::signaling_nan<double>());
-
-              // Step 1c: select which form of viscosity to use (diffusion, dislocation, fk, or composite), and apply
-              // pre-exponential weakening, if required.
-              switch (viscous_flow_law)
-                {
-                  case diffusion:
-                  {
-                    non_yielding_viscosity = compositional_viscosity_prefactors.compute_viscosity(in, viscosity_diffusion, j, i, \
-                                                                                                  CompositionalViscosityPrefactors<dim>::ModifiedFlowLaws::diffusion);
-                    break;
-                  }
-                  case dislocation:
-                  {
-                    non_yielding_viscosity = compositional_viscosity_prefactors.compute_viscosity(in, viscosity_dislocation, j, i, \
-                                                                                                  CompositionalViscosityPrefactors<dim>::ModifiedFlowLaws::dislocation);
-                    break;
-                  }
-                  case frank_kamenetskii:
-                  {
-                    non_yielding_viscosity = frank_kamenetskii_rheology->compute_viscosity(in.temperature[i], j,
-                                                                                           in.pressure[i],
-                                                                                           this->get_adiabatic_conditions().density(this->get_geometry_model().representative_point(0)),
-                                                                                           this->get_gravity_model().gravity_vector(in.position[0]).norm());
-                    break;
-                  }
-                  case composite:
-                  {
-                    const double scaled_viscosity_diffusion = compositional_viscosity_prefactors.compute_viscosity(in, viscosity_diffusion, j, i, \
-                                                              CompositionalViscosityPrefactors<dim>::ModifiedFlowLaws::diffusion);
-                    const double scaled_viscosity_dislocation = compositional_viscosity_prefactors.compute_viscosity(in, viscosity_dislocation, j, i, \
-                                                                CompositionalViscosityPrefactors<dim>::ModifiedFlowLaws::dislocation);
-                    non_yielding_viscosity = (scaled_viscosity_diffusion * scaled_viscosity_dislocation)/
-                                             (scaled_viscosity_diffusion + scaled_viscosity_dislocation);
-                    break;
-                  }
-                  default:
-                  {
-                    AssertThrow(false, ExcNotImplemented());
-                    break;
-                  }
-                }
-
-              // Step 1d: compute the viscosity from the Peierls creep law and harmonically average with current viscosities
-              if (use_peierls_creep)
-                {
-                  const double viscosity_peierls = peierls_creep->compute_viscosity(edot_ii, pressure_for_creep, temperature_for_viscosity, j,
-                                                                                    phase_function_values,
-                                                                                    n_phase_transitions_per_composition);
-                  non_yielding_viscosity = (non_yielding_viscosity * viscosity_peierls) / (non_yielding_viscosity + viscosity_peierls);
-                }
-            }
-
-
-            // Step 1e: multiply the viscosity by a constant (default value is 1)
-            non_yielding_viscosity = constant_viscosity_prefactors.compute_viscosity(non_yielding_viscosity, j);
-
-            // Step 2: calculate strain weakening factors for the cohesion, friction, and pre-yield viscosity
-            // If no strain weakening is applied, the factors are 1.
-            std::array<double, 3> weakening_factors = strain_rheology.compute_strain_weakening_factors(in.composition[i], j);
-
-            if (strain_rheology.use_temperature_activated_strain_softening)
-              weakening_factors = strain_rheology.apply_temperature_dependence_to_strain_weakening_factors(weakening_factors,temperature_for_viscosity,j);
-
-            // Apply strain weakening to the viscous viscosity.
-            non_yielding_viscosity *= weakening_factors[2];
-
-
-            // Step 3: calculate the viscous stress magnitude
-            // and strain rate. If requested compute visco-elastic contributions.
-            double effective_edot_ii = edot_ii;
-
-            if (this->get_parameters().enable_elasticity)
-              {
-                const std::vector<double> &elastic_shear_moduli = elastic_rheology.get_elastic_shear_moduli();
-
-                if (use_reference_strainrate == true)
-                  effective_edot_ii = ref_strain_rate;
-                else
-                  {
-                    // Overwrite effective_edot_ii with a value that includes a term that accounts for
-                    // elastic stress arising from a previous time step.
-                    // If used, this variable is no longer the "true" strain rate, but is instead
-                    // an effective value that enables the use of a standard isotropic viscosity
-                    // formulation (i.e. where stress and strain are related by a scalar viscosity).
-                    // The additional strain rate component is supported by a corresponding fictional body force.
-                    Assert(std::isfinite(in.strain_rate[i].norm()),
-                           ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                                      "not filled by the caller."));
-                    const SymmetricTensor<2,dim> effective_strain_rate =
-                      elastic_rheology.calculate_viscoelastic_strain_rate(in.strain_rate[i],
-                                                                          stress_old,
-                                                                          elastic_shear_moduli[j]);
-
-                    effective_edot_ii = std::max(std::sqrt(std::max(-second_invariant(effective_strain_rate), 0.)),
-                                                 min_strain_rate);
-                  }
-
-                // Step 3a: calculate the viscoelastic (effective) viscosity
-                non_yielding_viscosity = elastic_rheology.calculate_viscoelastic_viscosity(non_yielding_viscosity,
-                                                                                           elastic_shear_moduli[j]);
-              }
-
-            // Step 3b: calculate non yielding (viscous or viscous + elastic) stress magnitude
-            double non_yielding_stress = 2. * non_yielding_viscosity * effective_edot_ii;
-
-            // Step 4a: calculate the strain-weakened friction and cohesion
-            const DruckerPragerParameters drucker_prager_parameters = drucker_prager_plasticity.compute_drucker_prager_parameters(j,
-                                                                      phase_function_values,
-                                                                      n_phase_transitions_per_composition);
-            const double current_cohesion = drucker_prager_parameters.cohesion * weakening_factors[0];
-            double current_friction = drucker_prager_parameters.angle_internal_friction * weakening_factors[1];
-
-            // Step 4b: calculate the friction angle dependent on strain rate if specified
-            // apply the strain rate dependence to the friction angle (including strain weakening if present)
-            // Note: Maybe this should also be turned around to first apply strain rate dependence and then
-            // the strain weakening to the dynamic friction angle. Didn't come up with a clear argument for
-            // one order or the other.
-            current_friction = friction_models.compute_friction_angle(effective_edot_ii,
-                                                                      j,
-                                                                      current_friction,
-                                                                      in.position[i]);
-            output_parameters.current_friction_angles[j] = current_friction;
-            output_parameters.current_cohesions[j] = current_cohesion;
-
-            // Step 5: plastic yielding
-
-            // Determine if the pressure used in Drucker Prager plasticity will be capped at 0 (default).
-            // This may be necessary in models without gravity and when the dynamic stresses are much higher
-            // than the lithostatic pressure.
-
-            double pressure_for_plasticity = in.pressure[i];
-            if (allow_negative_pressures_in_plasticity == false)
-              pressure_for_plasticity = std::max(in.pressure[i],0.0);
-
-            // Step 5a: calculate the Drucker-Prager yield stress
-            const double yield_stress = drucker_prager_plasticity.compute_yield_stress(current_cohesion,
-                                                                                       current_friction,
-                                                                                       pressure_for_plasticity,
-                                                                                       drucker_prager_parameters.max_yield_stress);
-
-            // Step 5b: select if the yield viscosity is based on Drucker Prager or a stress limiter rheology
-            double effective_viscosity = non_yielding_viscosity;
-            switch (yield_mechanism)
-              {
-                case stress_limiter:
-                {
-                  //Step 5b-1: always rescale the viscosity back to the yield surface
-                  const double viscosity_limiter = yield_stress / (2.0 * ref_strain_rate)
-                                                   * std::pow((edot_ii/ref_strain_rate),
-                                                              1./exponents_stress_limiter[j] - 1.0);
-                  effective_viscosity = 1. / ( 1./viscosity_limiter + 1./non_yielding_viscosity);
-                  break;
-                }
-                case drucker_prager:
-                {
-                  // Step 5b-2: if the non-yielding stress is greater than the yield stress,
-                  // rescale the viscosity back to yield surface
-                  if (non_yielding_stress >= yield_stress)
-                    {
-                      // The following uses the effective_edot_ii
-                      // (which has been modified for elastic effects, above),
-                      // and calculates the effective viscosity over all active rheological elements
-                      // assuming that the non-yielding viscosity is not strain rate dependent
-                      effective_viscosity = drucker_prager_plasticity.compute_viscosity(current_cohesion,
-                                                                                        current_friction,
-                                                                                        pressure_for_plasticity,
-                                                                                        effective_edot_ii,
-                                                                                        drucker_prager_parameters.max_yield_stress,
-                                                                                        non_yielding_viscosity);
-                      output_parameters.composition_yielding[j] = true;
-                    }
-                  break;
-                }
-                default:
-                {
-                  AssertThrow(false, ExcNotImplemented());
-                  break;
-                }
-              }
-
-            // Step 6: limit the viscosity with specified minimum and maximum bounds
-            const double maximum_viscosity_for_composition = MaterialModel::MaterialUtilities::phase_average_value(
-                                                               phase_function_values,
-                                                               n_phase_transitions_per_composition,
-                                                               maximum_viscosity,
-                                                               j,
-                                                               MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic
-                                                             );
-            const double minimum_viscosity_for_composition = MaterialModel::MaterialUtilities::phase_average_value(
-                                                               phase_function_values,
-                                                               n_phase_transitions_per_composition,
-                                                               minimum_viscosity,
-                                                               j,
-                                                               MaterialModel::MaterialUtilities::PhaseUtilities::logarithmic
-                                                             );
-            output_parameters.composition_viscosities[j] = std::min(std::max(effective_viscosity, minimum_viscosity_for_composition), maximum_viscosity_for_composition);
-          }
-        return output_parameters;
-      }
-
-
-
-      template <int dim>
-      void
-      ViscoPlastic<dim>::
-      compute_viscosity_derivatives(const unsigned int i,
-                                    const std::vector<double> &volume_fractions,
-                                    const std::vector<double> &composition_viscosities,
-                                    const MaterialModel::MaterialModelInputs<dim> &in,
-                                    MaterialModel::MaterialModelOutputs<dim> &out,
-                                    const std::vector<double> &phase_function_values,
-                                    const std::vector<unsigned int> &n_phase_transitions_per_composition) const
-      {
-        MaterialModel::MaterialModelDerivatives<dim> *derivatives =
-          out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
-
-        if (derivatives != nullptr)
-          {
-            // compute derivatives if necessary
-            std::vector<SymmetricTensor<2,dim>> composition_viscosities_derivatives(volume_fractions.size());
-            std::vector<double> composition_dviscosities_dpressure(volume_fractions.size());
-
-            const double finite_difference_accuracy = 1e-7;
-
-            // A new material model inputs variable that uses the strain rate and pressure difference.
-            MaterialModel::MaterialModelInputs<dim> in_derivatives = in;
-
-            Assert(std::isfinite(in.strain_rate[i].norm()),
-                   ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                              "not filled by the caller."));
-
-            const SymmetricTensor<2,dim> deviatoric_strain_rate = deviator(in.strain_rate[i]);
-
-            // For each independent component, compute the derivative.
-            for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
-              {
-                const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
-
-                const SymmetricTensor<2,dim> strain_rate_difference = deviatoric_strain_rate
-                                                                      + std::max(std::fabs(deviatoric_strain_rate[strain_rate_indices]), min_strain_rate)
-                                                                      * finite_difference_accuracy
-                                                                      * Utilities::nth_basis_for_symmetric_tensors<dim>(component);
-
-                in_derivatives.strain_rate[i] = strain_rate_difference;
-
-                std::vector<double> eta_component =
-                  calculate_isostrain_viscosities(in_derivatives, i, volume_fractions,
-                                                  phase_function_values, n_phase_transitions_per_composition).composition_viscosities;
-
-                // For each composition of the independent component, compute the derivative.
-                for (unsigned int composition_index = 0; composition_index < eta_component.size(); ++composition_index)
-                  {
-                    // compute the difference between the viscosity with and without the strain-rate difference.
-                    double viscosity_derivative = eta_component[composition_index] - composition_viscosities[composition_index];
-                    if (viscosity_derivative != 0)
-                      {
-                        // when the difference is non-zero, divide by the difference.
-                        viscosity_derivative /= std::max(std::fabs(strain_rate_difference[strain_rate_indices]), min_strain_rate)
-                                                * finite_difference_accuracy;
-                      }
-                    composition_viscosities_derivatives[composition_index][strain_rate_indices] = viscosity_derivative;
-                  }
-              }
-
-            // Now compute the derivative of the viscosity to the pressure
-            const double pressure_difference = in.pressure[i] + (std::fabs(in.pressure[i]) * finite_difference_accuracy);
-
-            in_derivatives.pressure[i] = pressure_difference;
-
-            // Modify the in_derivatives object again to take the original strain rate.
-            in_derivatives.strain_rate[i] = in.strain_rate[i];
-
-            const std::vector<double> viscosity_difference =
-              calculate_isostrain_viscosities(in_derivatives, i, volume_fractions,
-                                              phase_function_values, n_phase_transitions_per_composition).composition_viscosities;
-
-            for (unsigned int composition_index = 0; composition_index < viscosity_difference.size(); ++composition_index)
-              {
-                double viscosity_derivative = viscosity_difference[composition_index] - composition_viscosities[composition_index];
-                if (viscosity_difference[composition_index] != 0)
-                  {
-                    if (in.pressure[i] != 0)
-                      {
-                        viscosity_derivative /= std::fabs(in.pressure[i]) * finite_difference_accuracy;
-                      }
-                    else
-                      {
-                        viscosity_derivative = 0;
-                      }
-                  }
-                composition_dviscosities_dpressure[composition_index] = viscosity_derivative;
-              }
-
-            double viscosity_averaging_p = 0; // Geometric
-            if (viscosity_averaging == MaterialUtilities::harmonic)
-              viscosity_averaging_p = -1;
-            if (viscosity_averaging == MaterialUtilities::arithmetic)
-              viscosity_averaging_p = 1;
-            if (viscosity_averaging == MaterialUtilities::maximum_composition)
-              viscosity_averaging_p = 1000;
-
-            derivatives->viscosity_derivative_wrt_strain_rate[i] =
-              Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],
-                                                               volume_fractions,
-                                                               composition_viscosities,
-                                                               composition_viscosities_derivatives,
-                                                               viscosity_averaging_p);
-            derivatives->viscosity_derivative_wrt_pressure[i] =
-              Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],
-                                                               volume_fractions,
-                                                               composition_viscosities,
-                                                               composition_dviscosities_dpressure,
-                                                               viscosity_averaging_p);
-          }
-      }
-
-
-
-      template <int dim>
-      ComponentMask
-      ViscoPlastic<dim>::
-      get_volumetric_composition_mask() const
-      {
-        // Store which components to exclude during the volume fraction computation.
-        ComponentMask composition_mask = strain_rheology.get_strain_composition_mask();
-
-        if (this->get_parameters().enable_elasticity)
-          {
-            for (unsigned int i = 0; i < SymmetricTensor<2,dim>::n_independent_components ; ++i)
-              composition_mask.set(i,false);
-          }
-
-        return composition_mask;
-      }
-
-
-
-      template <int dim>
-      void
-      ViscoPlastic<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        Rheology::StrainDependent<dim>::declare_parameters (prm);
-
-        Rheology::FrictionModels<dim>::declare_parameters (prm);
-
-        Rheology::Elasticity<dim>::declare_parameters (prm);
-
-        // Reference and minimum/maximum values
-        prm.declare_entry ("Minimum strain rate", "1.0e-20", Patterns::Double (0.),
-                           "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}.");
-        prm.declare_entry ("Reference strain rate","1.0e-15",Patterns::Double (0.),
-                           "Reference strain rate for first time step. Units: \\si{\\per\\second}.");
-        prm.declare_entry ("Minimum viscosity", "1e17", Patterns::Anything(),
-                           "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}. "
-                           "List with as many components as active "
-                           "compositional fields (material data is assumed to "
-                           "be in order with the ordering of the fields). ");
-        prm.declare_entry ("Maximum viscosity", "1e28", Patterns::Anything(),
-                           "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}. "
-                           "List with as many components as active "
-                           "compositional fields (material data is assumed to "
-                           "be in order with the ordering of the fields). ");
-
-        // Rheological parameters
-        prm.declare_entry ("Viscosity averaging scheme", "harmonic",
-                           Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
-                           "When more than one compositional field is present at a point "
-                           "with different viscosities, we need to come up with an average "
-                           "viscosity at that point.  Select a weighted harmonic, arithmetic, "
-                           "geometric, or maximum composition.");
-        prm.declare_entry ("Viscous flow law", "composite",
-                           Patterns::Selection("diffusion|dislocation|frank kamenetskii|composite"),
-                           "Select what type of viscosity law to use between diffusion, "
-                           "dislocation, frank kamenetskii, and composite options. Soon there will be an option "
-                           "to select a specific flow law for each assigned composition ");
-        prm.declare_entry ("Yield mechanism", "drucker",
-                           Patterns::Selection("drucker|limiter"),
-                           "Select what type of yield mechanism to use between Drucker Prager "
-                           "and stress limiter options.");
-        prm.declare_entry ("Allow negative pressures in plasticity", "false",
-                           Patterns::Bool (),
-                           "Whether to allow negative pressures to be used in the computation "
-                           "of plastic yield stresses and viscosities. Setting this parameter "
-                           "to true may be advantageous in models without gravity where the "
-                           "dynamic stresses are much higher than the lithostatic pressure. "
-                           "If false, the minimum pressure in the plasticity formulation will "
-                           "be set to zero.");
-        prm.declare_entry ("Use adiabatic pressure in creep viscosity", "false",
-                           Patterns::Bool (),
-                           "Whether to use the adiabatic pressure instead of the full "
-                           "pressure (default) when calculating creep (diffusion, dislocation, "
-                           "and peierls) viscosity. This may be helpful in models where the "
-                           "full pressure has an unusually large negative value arising from "
-                           "large negative dynamic pressure, resulting in solver convergence "
-                           "issue and in some cases a viscosity of zero.");
-
-        // Diffusion creep parameters
-        Rheology::DiffusionCreep<dim>::declare_parameters(prm);
-
-        // Dislocation creep parameters
-        Rheology::DislocationCreep<dim>::declare_parameters(prm);
-
-        // Frank-Kamenetskii viscosity parameters
-        Rheology::FrankKamenetskii<dim>::declare_parameters(prm);
-
-        // Peierls creep parameters
-        Rheology::PeierlsCreep<dim>::declare_parameters(prm);
-
-        prm.declare_entry ("Include Peierls creep", "false",
-                           Patterns::Bool (),
-                           "Whether to include Peierls creep in the rheological formulation.");
-
-        // Constant viscosity prefactor parameters
-        Rheology::ConstantViscosityPrefactors<dim>::declare_parameters(prm);
-
-        // Variable viscosity prefactor parameters
-        Rheology::CompositionalViscosityPrefactors<dim>::declare_parameters(prm);
-
-        // Drucker Prager plasticity parameters
-        Rheology::DruckerPrager<dim>::declare_parameters(prm);
-
-        // Stress limiter parameters
-        prm.declare_entry ("Stress limiter exponents", "1.0",
-                           Patterns::List(Patterns::Double (0.)),
-                           "List of stress limiter exponents, $n_{\\text{lim}}$, "
-                           "for background material and compositional fields, "
-                           "for a total of N+1 values, where N is the number of all compositional fields or only "
-                           "those corresponding to chemical compositions. Units: none.");
-
-        // Temperature gradient in viscosity laws to include an adiabat (note units of K/Pa)
-        prm.declare_entry ("Adiabat temperature gradient for viscosity", "0.0", Patterns::Double (0.),
-                           "Add an adiabatic temperature gradient to the temperature used in the flow law "
-                           "so that the activation volume is consistent with what one would use in a "
-                           "earth-like (compressible) model. Default is set so this is off. "
-                           "Note that this is a linear approximation of the real adiabatic gradient, which "
-                           "is okay for the upper mantle, but is not really accurate for the lower mantle. "
-                           "Using a pressure gradient of 32436 Pa/m, then a value of "
-                           "0.3 K/km = 0.0003 K/m = 9.24e-09 K/Pa gives an earth-like adiabat."
-                           "Units: \\si{\\kelvin\\per\\pascal}.");
-      }
-
-
-
-      template <int dim>
-      void
-      ViscoPlastic<dim>::parse_parameters (ParameterHandler &prm,
-                                           const std::unique_ptr<std::vector<unsigned int>> &expected_n_phases_per_composition)
-      {
-        strain_rheology.initialize_simulator (this->get_simulator());
-        strain_rheology.parse_parameters(prm);
-
-        friction_models.initialize_simulator (this->get_simulator());
-        friction_models.parse_parameters(prm);
-
-        if (this->get_parameters().enable_elasticity)
-          {
-            elastic_rheology.initialize_simulator (this->get_simulator());
-            elastic_rheology.parse_parameters(prm);
-          }
-
-        // Reference and minimum/maximum values
-        min_strain_rate = prm.get_double("Minimum strain rate");
-        ref_strain_rate = prm.get_double("Reference strain rate");
-
-        // Retrieve the list of composition names
-        std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-        // Retrieve the list of names of fields that represent chemical compositions, and not, e.g.,
-        // plastic strain
-        std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-
-        // Establish that a background field is required here
-        compositional_field_names.insert(compositional_field_names.begin(), "background");
-        chemical_field_names.insert(chemical_field_names.begin(), "background");
-
-        Utilities::MapParsing::Options options(chemical_field_names, "Minimum viscosity");
-        options.list_of_allowed_keys = compositional_field_names;
-        options.allow_multiple_values_per_key = true;
-        if (expected_n_phases_per_composition)
-          {
-            options.n_values_per_key = *expected_n_phases_per_composition;
-
-            // check_values_per_key is required to be true to duplicate single values
-            // if they are to be used for all phases associated with a given key.
-            options.check_values_per_key = true;
-          }
-
-        minimum_viscosity = Utilities::MapParsing::parse_map_to_double_array (prm.get("Minimum viscosity"),
-                                                                              options);
-
-        options.property_name = "Maximum viscosity";
-        maximum_viscosity = Utilities::MapParsing::parse_map_to_double_array (prm.get("Maximum viscosity"),
-                                                                              options);
-
-        Assert(maximum_viscosity.size() == minimum_viscosity.size(),
-               ExcMessage("The input parameters 'Maximum viscosity' and 'Minimum viscosity' should have the same number of entries."));
-        for (auto p1 = maximum_viscosity.begin(), p2 = minimum_viscosity.begin();
-             p1 != maximum_viscosity.end(); ++p1, ++p2)
-          AssertThrow(*p1 >= *p2, ExcMessage("Maximum viscosity should be larger or equal to the minimum viscosity."));
-
-        viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
-                              prm);
-
-        // Rheological parameters
-        if (prm.get ("Viscous flow law") == "composite")
-          viscous_flow_law = composite;
-        else if (prm.get ("Viscous flow law") == "diffusion")
-          viscous_flow_law = diffusion;
-        else if (prm.get ("Viscous flow law") == "dislocation")
-          viscous_flow_law = dislocation;
-        else if (prm.get ("Viscous flow law") == "frank kamenetskii")
-          viscous_flow_law = frank_kamenetskii;
-        else
-          AssertThrow(false, ExcMessage("Not a valid viscous flow law"));
-
-        if (prm.get ("Yield mechanism") == "drucker")
-          yield_mechanism = drucker_prager;
-        else if (prm.get ("Yield mechanism") == "limiter")
-          yield_mechanism = stress_limiter;
-        else
-          AssertThrow(false, ExcMessage("Not a valid yield mechanism."));
-
-        AssertThrow(this->get_parameters().enable_elasticity == false || yield_mechanism == drucker_prager,
-                    ExcMessage("Elastic behavior is only tested with the "
-                               "'drucker prager' plasticity option."));
-
-        allow_negative_pressures_in_plasticity = prm.get_bool ("Allow negative pressures in plasticity");
-        use_adiabatic_pressure_in_creep = prm.get_bool("Use adiabatic pressure in creep viscosity");
-
-        // Diffusion creep parameters
-        diffusion_creep.initialize_simulator (this->get_simulator());
-        diffusion_creep.parse_parameters(prm, expected_n_phases_per_composition);
-
-        // Dislocation creep parameters
-        dislocation_creep.initialize_simulator (this->get_simulator());
-        dislocation_creep.parse_parameters(prm, expected_n_phases_per_composition);
-
-        // Frank Kamenetskii viscosity parameters
-        if (viscous_flow_law == frank_kamenetskii)
-          {
-            frank_kamenetskii_rheology = std::make_unique<Rheology::FrankKamenetskii<dim>>();
-            frank_kamenetskii_rheology->initialize_simulator (this->get_simulator());
-            frank_kamenetskii_rheology->parse_parameters(prm);
-          }
-
-        // Peierls creep parameters
-        use_peierls_creep = prm.get_bool ("Include Peierls creep");
-        if (use_peierls_creep)
-          {
-            peierls_creep = std::make_unique<Rheology::PeierlsCreep<dim>>();
-            peierls_creep->initialize_simulator (this->get_simulator());
-            peierls_creep->parse_parameters(prm, expected_n_phases_per_composition);
-          }
-
-        // Constant viscosity prefactor parameters
-        constant_viscosity_prefactors.initialize_simulator (this->get_simulator());
-        constant_viscosity_prefactors.parse_parameters(prm);
-
-        compositional_viscosity_prefactors.initialize_simulator (this->get_simulator());
-        compositional_viscosity_prefactors.parse_parameters(prm);
-
-        // Plasticity parameters
-        drucker_prager_plasticity.initialize_simulator (this->get_simulator());
-        drucker_prager_plasticity.parse_parameters(prm, expected_n_phases_per_composition);
-
-        // Stress limiter parameter (does not allow for phases per composition)
-        options.property_name = "Stress limiter exponents";
-        options.allow_multiple_values_per_key = false;
-        options.check_values_per_key = false;
-
-        exponents_stress_limiter = Utilities::MapParsing::parse_map_to_double_array (prm.get("Stress limiter exponents"),
-                                                                                     options);
-
-        // Include an adiabat temperature gradient in flow laws
-        adiabatic_temperature_gradient_for_viscosity = prm.get_double("Adiabat temperature gradient for viscosity");
-        if (this->get_heating_model_manager().adiabatic_heating_enabled())
-          AssertThrow (adiabatic_temperature_gradient_for_viscosity == 0.0,
-                       ExcMessage("If adiabatic heating is enabled you should not add another adiabatic gradient"
-                                  "to the temperature for computing the viscosity, because the ambient"
-                                  "temperature profile already includes the adiabatic gradient."));
-
-      }
-
-
-
-      template <int dim>
-      void
-      ViscoPlastic<dim>::create_plastic_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-        if (out.template get_additional_output<PlasticAdditionalOutputs<dim>>() == nullptr)
-          {
-            const unsigned int n_points = out.n_evaluation_points();
-            out.additional_outputs.push_back(
-              std::make_unique<PlasticAdditionalOutputs<dim>> (n_points));
-          }
-      }
-
-      template <int dim>
-      void
-      ViscoPlastic<dim>::
-      fill_plastic_outputs(const unsigned int i,
-                           const std::vector<double> &volume_fractions,
-                           const bool plastic_yielding,
-                           const MaterialModel::MaterialModelInputs<dim> &in,
-                           MaterialModel::MaterialModelOutputs<dim> &out,
-                           const IsostrainViscosities &isostrain_viscosities) const
-      {
-        PlasticAdditionalOutputs<dim> *plastic_out = out.template get_additional_output<PlasticAdditionalOutputs<dim>>();
-
-        if (plastic_out != nullptr)
-          {
-            AssertThrow(in.requests_property(MaterialProperties::viscosity),
-                        ExcMessage("The PlasticAdditionalOutputs cannot be filled when the viscosity has not been computed."));
-
-            plastic_out->cohesions[i] = 0;
-            plastic_out->friction_angles[i] = 0;
-            plastic_out->yield_stresses[i] = 0;
-            plastic_out->yielding[i] = plastic_yielding ? 1 : 0;
-
-            const std::vector<double> friction_angles_RAD = isostrain_viscosities.current_friction_angles;
-            const std::vector<double> cohesions = isostrain_viscosities.current_cohesions;
-
-            // The max yield stress is the same for each composition, so we give the 0th field value.
-            const double max_yield_stress = drucker_prager_plasticity.compute_drucker_prager_parameters(0).max_yield_stress;
-
-            double pressure_for_plasticity = in.pressure[i];
-            if (allow_negative_pressures_in_plasticity == false)
-              pressure_for_plasticity = std::max(in.pressure[i], 0.0);
-
-            // average over the volume volume fractions
-            for (unsigned int j = 0; j < volume_fractions.size(); ++j)
-              {
-                plastic_out->cohesions[i]   += volume_fractions[j] * cohesions[j];
-                // Also convert radians to degrees
-                plastic_out->friction_angles[i] += constants::radians_to_degree * volume_fractions[j] * friction_angles_RAD[j];
-                plastic_out->yield_stresses[i] += volume_fractions[j] * drucker_prager_plasticity.compute_yield_stress(cohesions[j],
-                                                  friction_angles_RAD[j],
-                                                  pressure_for_plasticity,
-                                                  max_yield_stress);
-
-              }
-          }
-      }
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-#define INSTANTIATE(dim) \
-  template class PlasticAdditionalOutputs<dim>; \
-  \
-  namespace Rheology \
-  { \
-    template class ViscoPlastic<dim>; \
-  }
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/material_model/simple.cc.bak b/source/material_model/simple.cc.bak
deleted file mode 100644
index ac2003a3744..00000000000
--- a/source/material_model/simple.cc.bak
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/simple.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    Simple<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // The Simple model has up to one compositional field (plus one background field)
-      // that can influence the density
-      const unsigned int n_compositions_for_eos = std::min(this->n_compositional_fields()+1, 2u);
-      EquationOfStateOutputs<dim> eos_outputs (n_compositions_for_eos);
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double delta_temp = in.temperature[i]-reference_T;
-          const double temperature_dependence
-            = (reference_T > 0
-               ?
-               std::max(std::min(std::exp(-thermal_viscosity_exponent *
-                                          delta_temp/reference_T),
-                                 maximum_thermal_prefactor),
-                        minimum_thermal_prefactor)
-               :
-               1.0);
-
-          out.viscosities[i] = ((composition_viscosity_prefactor != 1.0) && (in.composition[i].size()>0))
-                               ?
-                               // Geometric interpolation
-                               std::pow(10.0, ((1-in.composition[i][0]) * std::log10(eta *
-                                                                                     temperature_dependence)
-                                               + in.composition[i][0] * std::log10(eta *
-                                                                                   composition_viscosity_prefactor *
-                                                                                   temperature_dependence)))
-                               :
-                               temperature_dependence * eta;
-
-          equation_of_state.evaluate(in, i, eos_outputs);
-
-          // except for the density, all material properties are constant across compositions
-          out.thermal_expansion_coefficients[i] = eos_outputs.thermal_expansion_coefficients[0];
-          out.specific_heat[i] = eos_outputs.specific_heat_capacities[0];
-          out.thermal_conductivities[i] = k_value;
-          out.compressibilities[i] = eos_outputs.compressibilities[0];
-          out.entropy_derivative_pressure[i] = eos_outputs.entropy_derivative_pressure[0];
-          out.entropy_derivative_temperature[i] = eos_outputs.entropy_derivative_temperature[0];
-
-          // Change in composition due to chemical reactions at the
-          // given positions. The term reaction_terms[i][c] is the
-          // change in compositional field c at point i.
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-
-          std::vector<double> volume_fractions (n_compositions_for_eos, 1.0);
-          if (in.composition[i].size()>0)
-            {
-              volume_fractions[1] = std::max(0.0, in.composition[i][0]);
-              volume_fractions[0] = 1.0 - volume_fractions[1];
-            }
-
-          out.densities[i] = MaterialUtilities::average_value(volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    Simple<dim>::
-    is_compressible () const
-    {
-      return equation_of_state.is_compressible ();
-    }
-
-
-
-    template <int dim>
-    void
-    Simple<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simple model");
-        {
-          EquationOfState::LinearizedIncompressible<dim>::declare_parameters (prm, 1);
-
-          prm.declare_entry ("Reference temperature", "293.",
-                             Patterns::Double (0.),
-                             "The reference temperature $T_0$. The reference temperature is used "
-                             "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Viscosity", "5e24",
-                             Patterns::Double (0.),
-                             "The value of the constant viscosity $\\eta_0$. This viscosity may be "
-                             "modified by both temperature and compositional dependencies. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Composition viscosity prefactor", "1.0",
-                             Patterns::Double (0.),
-                             "A linear dependency of viscosity on the first compositional field. "
-                             "Dimensionless prefactor. With a value of 1.0 (the default) the "
-                             "viscosity does not depend on the composition. See the general documentation "
-                             "of this model for a formula that states the dependence of the "
-                             "viscosity on this factor, which is called $\\xi$ there.");
-          prm.declare_entry ("Thermal viscosity exponent", "0.0",
-                             Patterns::Double (0.),
-                             "The temperature dependence of viscosity. Dimensionless exponent. "
-                             "See the general documentation "
-                             "of this model for a formula that states the dependence of the "
-                             "viscosity on this factor, which is called $\\beta$ there.");
-          prm.declare_entry("Maximum thermal prefactor","1.0e2",
-                            Patterns::Double (0.),
-                            "The maximum value of the viscosity prefactor associated with temperature "
-                            "dependence.");
-          prm.declare_entry("Minimum thermal prefactor","1.0e-2",
-                            Patterns::Double (0.),
-                            "The minimum value of the viscosity prefactor associated with temperature "
-                            "dependence.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Simple<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simple model");
-        {
-          equation_of_state.parse_parameters (prm, 1);
-
-          reference_T                = prm.get_double ("Reference temperature");
-          eta                        = prm.get_double ("Viscosity");
-          composition_viscosity_prefactor = prm.get_double ("Composition viscosity prefactor");
-          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
-          maximum_thermal_prefactor       = prm.get_double ("Maximum thermal prefactor");
-          minimum_thermal_prefactor       = prm.get_double ("Minimum thermal prefactor");
-          if ( maximum_thermal_prefactor == 0.0 ) maximum_thermal_prefactor = std::numeric_limits<double>::max();
-          if ( minimum_thermal_prefactor == 0.0 ) minimum_thermal_prefactor = std::numeric_limits<double>::min();
-
-          k_value                    = prm.get_double ("Thermal conductivity");
-
-          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
-            AssertThrow(false, ExcMessage("Error: Material model simple with Thermal viscosity exponent can not have reference_T=0."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.density = NonlinearDependence::temperature|NonlinearDependence::compositional_fields;
-
-      if (thermal_viscosity_exponent != 0)
-        this->model_dependence.viscosity |= NonlinearDependence::temperature;
-      if (composition_viscosity_prefactor != 1.0)
-        this->model_dependence.viscosity |= NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Simple,
-                                   "simple",
-                                   "A material model that has constant values "
-                                   "for all coefficients but the density and viscosity. The defaults for all "
-                                   "coefficients are chosen to be similar to what is believed to be correct "
-                                   "for Earth's mantle. All of the values that define this model are read "
-                                   "from a section ``Material model/Simple model'' in the input file, see "
-                                   "Section~\\ref{parameters:Material_20model/Simple_20model}."
-                                   "\n\n"
-                                   "This model uses the following set of equations for the two coefficients that "
-                                   "are non-constant: "
-                                   "\\begin{align}"
-                                   "  \\eta(p,T,\\mathfrak c) &= \\tau(T) \\zeta(\\mathfrak c) \\eta_0, \\\\"
-                                   "  \\rho(p,T,\\mathfrak c) &= \\left(1-\\alpha (T-T_0)\\right)\\rho_0 + \\Delta\\rho \\; c_0,"
-                                   "\\end{align}"
-                                   "where $c_0$ is the first component of the compositional vector "
-                                   "$\\mathfrak c$ if the model uses compositional fields, or zero otherwise. "
-                                   "\n\n"
-                                   "The temperature pre-factor for the viscosity formula above is "
-                                   "defined as "
-                                   "\\begin{align}"
-                                   "  \\tau(T) &= H\\left(e^{-\\beta (T-T_0)/T_0}\\right),"
-                                   "\\intertext{with} "
-                                   "  \\qquad\\qquad H(x) &= \\begin{cases}"
-                                   "                            \\tau_{\\text{min}} & \\text{if}\\; x<\\tau_{\\text{min}}, \\\\"
-                                   "                            x & \\text{if}\\; 10^{-2}\\le x \\le 10^2, \\\\"
-                                   "                            \\tau_{\\text{max}} & \\text{if}\\; x>\\tau_{\\text{max}}, \\\\"
-                                   "                         \\end{cases}"
-                                   "\\end{align} "
-                                   "where $x=e^{-\\beta (T-T_0)/T_0}$, "
-                                   "$\\beta$ corresponds to the input parameter ``Thermal viscosity exponent'', "
-                                   "and $T_0$ to the parameter ``Reference temperature''. If you set $T_0=0$ "
-                                   "in the input file, the thermal pre-factor $\\tau(T)=1$. The parameters $\\tau_{\\text{min}}$ "
-                                   "and $\\tau_{\\text{max}}$ set the minimum and maximum values of the temperature pre-factor "
-                                   "and are set using ``Maximum thermal prefactor'' and ``Minimum thermal prefactor''. "
-                                   "Specifying a value of 0.0 for the minimum or maximum values will disable pre-factor limiting."
-                                   "\n\n"
-                                   "The compositional pre-factor for the viscosity is defined as "
-                                   "$ \\zeta(\\mathfrak c) = \\xi^{c_0}$ "
-                                   "if the model has compositional fields and equals one otherwise. $\\xi$ "
-                                   "corresponds to the parameter ``Composition viscosity prefactor'' in the "
-                                   "input file."
-                                   "\n\n"
-                                   "Finally, in the formula for the density, $\\alpha$ corresponds to the "
-                                   "``Thermal expansion coefficient'' and "
-                                   "$\\Delta\\rho$ "
-                                   "corresponds to the parameter ``Density differential for compositional field 1''."
-                                   "\n\n"
-                                   "Note that this model uses the formulation that assumes an incompressible "
-                                   "medium despite the fact that the density follows the law "
-                                   "$\\rho(T)=\\rho_0(1-\\alpha(T-T_{\\text{ref}}))$. "
-                                   "\n\n"
-                                   ":::{note}\n"
-                                   "Despite its name, this material model is not exactly ``simple'', "
-                                   "as indicated by the formulas above. While it was originally intended "
-                                   "to be simple, it has over time acquired all sorts of temperature "
-                                   "and compositional dependencies that weren't initially intended. "
-                                   "Consequently, there is now a ``simpler'' material model that now fills "
-                                   "the role the current model was originally intended to fill.\n"
-                                   ":::")
-  }
-}
diff --git a/source/material_model/simple_compressible.cc.bak b/source/material_model/simple_compressible.cc.bak
deleted file mode 100644
index fae99bbc633..00000000000
--- a/source/material_model/simple_compressible.cc.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple_compressible.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    SimpleCompressible<dim>::
-    evaluate(const MaterialModelInputs<dim> &in,
-             MaterialModelOutputs<dim> &out) const
-    {
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const Point<dim> position = in.position[i];
-          const double temperature = in.temperature[i];
-          const double pressure = in.pressure[i];
-
-          out.viscosities[i] = constant_rheology.compute_viscosity();
-          out.specific_heat[i] = reference_specific_heat;
-          out.thermal_conductivities[i] = k_value;
-          out.thermal_expansion_coefficients[i] = thermal_alpha;
-
-          double rho = reference_rho * std::exp(reference_compressibility * (pressure - this->get_surface_pressure()));
-          rho *= (1 - thermal_alpha * (temperature - this->get_adiabatic_conditions().temperature(position)));
-
-          out.densities[i] = rho;
-          out.compressibilities[i] = reference_compressibility; // 1/rho drho/dp
-          out.entropy_derivative_pressure[i] = 0.0;
-          out.entropy_derivative_temperature[i] = 0.0;
-          // Change in composition due to chemical reactions at the
-          // given positions. The term reaction_terms[i][c] is the
-          // change in compositional field c at point i.
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    SimpleCompressible<dim>::
-    is_compressible () const
-    {
-      return (reference_compressibility != 0);
-    }
-
-
-
-    template <int dim>
-    void
-    SimpleCompressible<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simple compressible model");
-        {
-          prm.declare_entry ("Reference density", "3300.",
-                             Patterns::Double (0.),
-                             "Reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250.",
-                             Patterns::Double (0.),
-                             "The value of the specific heat $C_p$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                             Patterns::Double (0.),
-                             "The value of the thermal expansion coefficient $\\alpha$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Reference compressibility", "4e-12",
-                             Patterns::Double (0.),
-                             "The value of the reference compressibility. "
-                             "Units: \\si{\\per\\pascal}.");
-
-          Rheology::ConstantViscosity::declare_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    SimpleCompressible<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simple compressible model");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          k_value                    = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-          reference_compressibility  = prm.get_double ("Reference compressibility");
-
-          constant_rheology.parse_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-      this->model_dependence.density = NonlinearDependence::none;
-
-      if (thermal_alpha != 0)
-        this->model_dependence.density |= NonlinearDependence::temperature;
-      if (reference_compressibility != 0)
-        this->model_dependence.density |= NonlinearDependence::pressure;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SimpleCompressible,
-                                   "simple compressible",
-                                   "A material model that has constant values "
-                                   "for all coefficients but the density. The defaults for all "
-                                   "coefficients are chosen to be similar to what is believed to be correct "
-                                   "for Earth's mantle. All of the values that define this model are read "
-                                   "from a section ``Material model/Simple compressible model'' in the input file, see "
-                                   "Section~\\ref{parameters:Material_20model/Simple_20compressible_20model}."
-                                   "\n\n"
-                                   "This model uses the following equations for the density: "
-                                   "$ \\rho(p,T) = \\rho_0 \\left(1-\\alpha (T-T_a)\\right) \\exp{\\beta (P-P_0))}$ "
-                                   "This formulation for the density assumes that the compressibility "
-                                   "provided by the user is the adiabatic compressibility ($\\beta_S$). "
-                                   "The thermal expansivity and isentropic compressibility implied by "
-                                   "the pressure and temperature dependence are equal to the "
-                                   "user-defined constant values only along the reference isentrope, and "
-                                   "there is also an implicit pressure dependence to the heat capacity "
-                                   "$C_p$ via Maxwell's relations.")
-  }
-}
diff --git a/source/material_model/simpler.cc.bak b/source/material_model/simpler.cc.bak
deleted file mode 100644
index 684666df8fc..00000000000
--- a/source/material_model/simpler.cc.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/simpler.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    bool
-    Simpler<dim>::
-    is_compressible () const
-    {
-      return equation_of_state.is_compressible ();
-    }
-
-    template <int dim>
-    void
-    Simpler<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // The Simpler model does not depend on composition
-      EquationOfStateOutputs<dim> eos_outputs (1);
-
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          equation_of_state.evaluate(in, i, eos_outputs);
-
-          out.viscosities[i] = constant_rheology.compute_viscosity();
-          out.densities[i] = eos_outputs.densities[0];
-          out.thermal_expansion_coefficients[i] = eos_outputs.thermal_expansion_coefficients[0];
-          out.specific_heat[i] = eos_outputs.specific_heat_capacities[0];
-          out.thermal_conductivities[i] = k_value;
-          out.compressibilities[i] = eos_outputs.compressibilities[0];
-
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-
-    }
-
-
-    template <int dim>
-    void
-    Simpler<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simpler model");
-        {
-          EquationOfState::LinearizedIncompressible<dim>::declare_parameters (prm);
-
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          Rheology::ConstantViscosity::declare_parameters(prm,5e24);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Simpler<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simpler model");
-        {
-          equation_of_state.parse_parameters (prm);
-
-          k_value                    = prm.get_double ("Thermal conductivity");
-
-          constant_rheology.parse_parameters(prm);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.density = NonlinearDependence::temperature;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Simpler,
-                                   "simpler",
-                                   "A material model that has constant values "
-                                   "except for density, which depends linearly on temperature: "
-                                   "$ \\rho(p,T) = \\left(1-\\alpha (T-T_0)\\right)\\rho_0.$ "
-                                   "\n\n"
-                                   "Note that this material model fills the role the ``simple'' material "
-                                   "model was originally intended to fill, before the latter acquired "
-                                   "all sorts of complicated temperature and compositional dependencies. ")
-  }
-}
diff --git a/source/material_model/steinberger.cc.bak b/source/material_model/steinberger.cc.bak
deleted file mode 100644
index 061f7c649e3..00000000000
--- a/source/material_model/steinberger.cc.bak
+++ /dev/null
@@ -1,631 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/steinberger.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/utilities.h>
-#include <aspect/lateral_averaging.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/table.h>
-#include <memory>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace internal
-    {
-      LateralViscosityLookup::LateralViscosityLookup(const std::string &filename,
-                                                     const MPI_Comm comm)
-      {
-        std::string temp;
-        // Read data from disk and distribute among processes
-        std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
-
-        std::getline(in, temp); // eat first line
-
-        min_depth=1e20;
-        max_depth=-1;
-
-        while (!in.eof())
-          {
-            double visc, depth;
-            in >> visc;
-            if (in.eof())
-              break;
-            in >> depth;
-            depth *=1000.0;
-            std::getline(in, temp);
-
-            min_depth = std::min(depth, min_depth);
-            max_depth = std::max(depth, max_depth);
-
-            values.push_back(visc);
-          }
-        delta_depth = (max_depth-min_depth)/(values.size()-1);
-      }
-
-      double LateralViscosityLookup::lateral_viscosity(double depth) const
-      {
-        depth=std::max(min_depth, depth);
-        depth=std::min(depth, max_depth);
-
-        Assert(depth>=min_depth, ExcMessage("ASPECT found a depth less than min_depth."));
-        Assert(depth<=max_depth, ExcMessage("ASPECT found a depth greater than max_depth."));
-        const unsigned int idx = static_cast<unsigned int>((depth-min_depth)/delta_depth);
-        Assert(idx<values.size(), ExcMessage("Attempting to look up a depth with an index that would be out of range. (depth-min_depth)/delta_depth too large."));
-        return values[idx];
-      }
-
-      int LateralViscosityLookup::get_nslices() const
-      {
-        return values.size();
-      }
-
-      RadialViscosityLookup::RadialViscosityLookup(const std::string &filename,
-                                                   const MPI_Comm comm)
-      {
-        std::string temp;
-        // Read data from disk and distribute among processes
-        std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
-
-        min_depth=1e20;
-        max_depth=-1;
-
-        while (!in.eof())
-          {
-            double visc, depth;
-            in >> visc;
-            if (in.eof())
-              break;
-            in >> depth;
-            depth *=1000.0;
-            std::getline(in, temp);
-
-            min_depth = std::min(depth, min_depth);
-            max_depth = std::max(depth, max_depth);
-
-            values.push_back(visc);
-          }
-        delta_depth = (max_depth-min_depth)/(values.size()-1);
-      }
-
-      double RadialViscosityLookup::radial_viscosity(double depth) const
-      {
-        depth=std::max(min_depth, depth);
-        depth=std::min(depth, max_depth);
-
-        Assert(depth>=min_depth, ExcMessage("ASPECT found a depth less than min_depth."));
-        Assert(depth<=max_depth, ExcMessage("ASPECT found a depth greater than max_depth."));
-        const unsigned int idx = static_cast<unsigned int>((depth-min_depth)/delta_depth);
-        Assert(idx<values.size(), ExcMessage("Attempting to look up a depth with an index that would be out of range. (depth-min_depth)/delta_depth too large."));
-        return values[idx];
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    Steinberger<dim>::initialize()
-    {
-      equation_of_state.initialize();
-
-      lateral_viscosity_lookup
-        = std::make_unique<internal::LateralViscosityLookup>(data_directory+lateral_viscosity_file_name,
-                                                             this->get_mpi_communicator());
-      radial_viscosity_lookup
-        = std::make_unique<internal::RadialViscosityLookup>(data_directory+radial_viscosity_file_name,
-                                                            this->get_mpi_communicator());
-      average_temperature.resize(n_lateral_slices);
-    }
-
-
-
-    template <int dim>
-    void
-    Steinberger<dim>::
-    update()
-    {
-      if (use_lateral_average_temperature)
-        {
-          this->get_lateral_averaging().get_temperature_averages(average_temperature);
-          for (double temperature : average_temperature)
-            AssertThrow(numbers::is_finite(temperature),
-                        ExcMessage("In computing depth averages, there is at"
-                                   " least one depth band that does not have"
-                                   " any quadrature points in it."
-                                   " Consider reducing number of depth layers"
-                                   " for averaging specified in the parameter"
-                                   " file.(Number lateral average bands)"));
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    Steinberger<dim>::
-    viscosity (const double temperature,
-               const double /*pressure*/,
-               const std::vector<double> &volume_fractions,
-               const SymmetricTensor<2,dim> &,
-               const Point<dim> &position) const
-    {
-      const double depth = this->get_geometry_model().depth(position);
-      const double adiabatic_temperature = this->get_adiabatic_conditions().temperature(position);
-
-      double delta_temperature;
-      if (use_lateral_average_temperature)
-        {
-          const unsigned int idx = static_cast<unsigned int>((average_temperature.size()-1) * depth / this->get_geometry_model().maximal_depth());
-          delta_temperature = temperature-average_temperature[idx];
-        }
-      else
-        delta_temperature = temperature-adiabatic_temperature;
-
-      // For an explanation on this formula see the Steinberger & Calderwood 2006 paper
-      // We here compute the lateral variation of viscosity due to temperature (thermal_prefactor) as
-      // V_lT = exp [-(H/nR)*dT/(T_adiabatic*(T_adiabatic + dT))] as in Eq. 6 of the paper.
-      // We get H/nR from the lateral_viscosity_lookup->lateral_viscosity function.
-      const double log_thermal_prefactor = -1.0 * lateral_viscosity_lookup->lateral_viscosity(depth) * delta_temperature / (temperature * adiabatic_temperature);
-
-      // Limit the lateral viscosity variation to a reasonable interval
-      const double thermal_prefactor = std::max(std::min(std::exp(log_thermal_prefactor), max_lateral_eta_variation), 1/max_lateral_eta_variation);
-
-      const double compositional_prefactor = MaterialUtilities::average_value (volume_fractions, viscosity_prefactors, viscosity_averaging_scheme);
-
-      // Visc_rT = exp[(H/nR)/T_adiabatic], Eq. 7 of the paper
-      const double eta_ref = radial_viscosity_lookup->radial_viscosity(depth);
-
-      // Radial viscosity profile is multiplied by thermal and compositional prefactors
-      return std::max(std::min(thermal_prefactor * compositional_prefactor * eta_ref, max_eta), min_eta);
-    }
-
-
-
-    template <int dim>
-    bool
-    Steinberger<dim>::
-    is_compressible () const
-    {
-      return equation_of_state.is_compressible();
-    }
-
-
-
-    template <int dim>
-    double
-    Steinberger<dim>::
-    thermal_conductivity (const double temperature,
-                          const double pressure,
-                          const Point<dim> &position) const
-    {
-      if (conductivity_formulation == constant)
-        return thermal_conductivity_value;
-
-      else if (conductivity_formulation == p_T_dependent)
-        {
-          // Find the conductivity layer that corresponds to the depth of the evaluation point.
-          const double depth = this->get_geometry_model().depth(position);
-          unsigned int layer_index = std::distance(conductivity_transition_depths.begin(),
-                                                   std::lower_bound(conductivity_transition_depths.begin(),conductivity_transition_depths.end(), depth));
-
-          const double p_dependence = reference_thermal_conductivities[layer_index] + conductivity_pressure_dependencies[layer_index] * pressure;
-
-          // Make reasonably sure we will not compute any invalid values due to the temperature-dependence.
-          // Since both the temperature-dependence and the saturation term scale with (Tref/T), we have to
-          // make sure we can compute the square of this number. If the temperature is small enough to
-          // be close to yielding NaN values, the conductivity will be set to the maximum value anyway.
-          const double T = std::max(temperature, std::sqrt(std::numeric_limits<double>::min()) * conductivity_reference_temperatures[layer_index]);
-          const double T_dependence = std::pow(conductivity_reference_temperatures[layer_index] / T, conductivity_exponents[layer_index]);
-
-          // Function based on the theory of Roufosse and Klemens (1974) that accounts for saturation.
-          // For the Tosi formulation, the scaling should be zero so that this term is 1.
-          double saturation_function = 1.0;
-          if (1./T_dependence > 1.)
-            saturation_function = (1. - saturation_scaling[layer_index])
-                                  + saturation_scaling[layer_index] * (2./3. * std::sqrt(T_dependence) + 1./3. * 1./T_dependence);
-
-          return std::min(p_dependence * saturation_function * T_dependence, maximum_conductivity);
-        }
-      else
-        {
-          AssertThrow(false, ExcNotImplemented());
-          return numbers::signaling_nan<double>();
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Steinberger<dim>::evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                               MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      std::vector<EquationOfStateOutputs<dim>> eos_outputs (in.n_evaluation_points(), equation_of_state.number_of_lookups());
-      std::vector<std::vector<double>> volume_fractions (in.n_evaluation_points(), std::vector<double> (equation_of_state.number_of_lookups()));
-
-      // We need to make a copy of the material model inputs because we want to use the adiabatic pressure
-      // rather than the real pressure for the equations of state (to avoid numerical instabilities).
-      MaterialModel::MaterialModelInputs<dim> eos_in(in);
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        eos_in.pressure[i] = this->get_adiabatic_conditions().pressure(in.position[i]);
-
-      // Evaluate the equation of state properties over all evaluation points
-      equation_of_state.evaluate(eos_in, eos_outputs);
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          out.thermal_conductivities[i] = thermal_conductivity(in.temperature[i], in.pressure[i], in.position[i]);
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0;
-
-          // Calculate volume fractions from mass fractions
-          // If there is only one lookup table, set the mass and volume fractions to 1
-          std::vector<double> mass_fractions;
-          if (equation_of_state.number_of_lookups() == 1)
-            mass_fractions.push_back(1.0);
-          else
-            {
-              // We only want to compute mass/volume fractions for fields that are chemical compositions.
-              mass_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[i],
-                                                                                     this->introspection().chemical_composition_field_indices());
-
-              // The function compute_volumes_from_masses expects as many mass_fractions as densities.
-              // But the function compute_composition_fractions always adds another element at the start
-              // of the vector that represents the background field. If there is no lookup table for
-              // the background field, the mass_fractions vector is too long and we remove this element.
-              if (!has_background_field)
-                mass_fractions.erase(mass_fractions.begin());
-            }
-
-          volume_fractions[i] = MaterialUtilities::compute_volumes_from_masses(mass_fractions,
-                                                                               eos_outputs[i].densities,
-                                                                               true);
-
-          if (in.requests_property(MaterialProperties::viscosity))
-            out.viscosities[i] = viscosity(in.temperature[i], in.pressure[i], volume_fractions[i], in.strain_rate[i], in.position[i]);
-
-          MaterialUtilities::fill_averaged_equation_of_state_outputs(eos_outputs[i], mass_fractions, volume_fractions[i], i, out);
-          fill_prescribed_outputs(i, volume_fractions[i], in, out);
-        }
-
-      // fill additional outputs if they exist
-      equation_of_state.fill_additional_outputs(in, volume_fractions, out);
-    }
-
-
-
-    template <int dim>
-    void
-    Steinberger<dim>::
-    fill_prescribed_outputs(const unsigned int q,
-                            const std::vector<double> &,
-                            const MaterialModel::MaterialModelInputs<dim> &,
-                            MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // set up variable to interpolate prescribed field outputs onto compositional field
-      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
-
-      if (this->introspection().composition_type_exists(CompositionalFieldDescription::density)
-          && prescribed_field_out != nullptr)
-        {
-          const unsigned int projected_density_index = this->introspection().find_composition_type(CompositionalFieldDescription::density);
-          prescribed_field_out->prescribed_field_outputs[q][projected_density_index] = out.densities[q];
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Steinberger<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Steinberger model");
-        {
-          prm.declare_entry ("Data directory", "$ASPECT_SOURCE_DIR/data/material-model/steinberger/",
-                             Patterns::DirectoryName (),
-                             "The path to the model data. The path may also include the special "
-                             "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                             "in which the ASPECT source files were located when ASPECT was "
-                             "compiled. This interpretation allows, for example, to reference "
-                             "files located in the `data/' subdirectory of ASPECT. ");
-          prm.declare_entry ("Radial viscosity file name", "radial-visc.txt",
-                             Patterns::Anything (),
-                             "The file name of the radial viscosity data. ");
-          prm.declare_entry ("Lateral viscosity file name", "temp-viscosity-prefactor.txt",
-                             Patterns::Anything (),
-                             "The file name of the lateral viscosity data. ");
-          prm.declare_entry ("Use lateral average temperature for viscosity", "true",
-                             Patterns::Bool (),
-                             "Whether to use the laterally averaged temperature "
-                             "instead of the adiabatic temperature as reference for the "
-                             "viscosity calculation. This ensures that the laterally averaged "
-                             "viscosities remain more or less constant over the model "
-                             "runtime. This behavior might or might not be desired.");
-          prm.declare_entry ("Number lateral average bands", "10",
-                             Patterns::Integer (1),
-                             "Number of bands to compute laterally averaged temperature within.");
-          prm.declare_entry ("Minimum viscosity", "1e19",
-                             Patterns::Double (0.),
-                             "The minimum viscosity that is allowed in the viscosity "
-                             "calculation. Smaller values will be cut off.");
-          prm.declare_entry ("Maximum viscosity", "1e23",
-                             Patterns::Double (0.),
-                             "The maximum viscosity that is allowed in the viscosity "
-                             "calculation. Larger values will be cut off.");
-          prm.declare_entry ("Maximum lateral viscosity variation", "1e2",
-                             Patterns::Double (0.),
-                             "The relative cutoff value for lateral viscosity variations "
-                             "caused by temperature deviations. The viscosity may vary "
-                             "laterally by this factor squared.");
-          prm.declare_entry ("Composition viscosity prefactors", "1",
-                             Patterns::Anything (),
-                             "List of N prefactors that are used to modify the reference viscosity, "
-                             "where N is either equal to one or the number of chemical components "
-                             "in the simulation. If only one value is given, then all components "
-                             "use the same value. Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
-                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition"),
-                             "Method to average viscosities over multiple compositional fields. "
-                             "One of arithmetic, harmonic, geometric or maximum composition.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0.),
-                             "The value of the thermal conductivity $k$. Only used in case "
-                             "the 'constant' Thermal conductivity formulation is selected. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Thermal conductivity formulation", "constant",
-                             Patterns::Selection("constant|p-T-dependent"),
-                             "Which law should be used to compute the thermal conductivity. "
-                             "The 'constant' law uses a constant value for the thermal "
-                             "conductivity. The 'p-T-dependent' formulation uses equations "
-                             "from Stackhouse et al. (2015): First-principles calculations "
-                             "of the lattice thermal conductivity of the lower mantle "
-                             "(https://doi.org/10.1016/j.epsl.2015.06.050), and Tosi et al. "
-                             "(2013): Mantle dynamics with pressure- and temperature-dependent "
-                             "thermal expansivity and conductivity "
-                             "(https://doi.org/10.1016/j.pepi.2013.02.004) to compute the "
-                             "thermal conductivity in dependence of temperature and pressure. "
-                             "The thermal conductivity parameter sets can be chosen in such a "
-                             "way that either the Stackhouse or the Tosi relations are used. "
-                             "The conductivity description can consist of several layers with "
-                             "different sets of parameters. Note that the Stackhouse "
-                             "parametrization is only valid for the lower mantle (bridgmanite).");
-          prm.declare_entry ("Thermal conductivity transition depths", "410000, 520000, 660000",
-                             Patterns::List(Patterns::Double (0.)),
-                             "A list of depth values that indicate where the transitions between "
-                             "the different conductivity parameter sets should occur in the "
-                             "'p-T-dependent' Thermal conductivity formulation (in most cases, "
-                             "this will be the depths of major mantle phase transitions). "
-                             "Units: \\si{\\meter}.");
-          prm.declare_entry ("Reference thermal conductivities", "2.47, 3.81, 3.52, 4.9",
-                             Patterns::List(Patterns::Double (0.)),
-                             "A list of base values of the thermal conductivity for each of the "
-                             "horizontal layers in the 'p-T-dependent' Thermal conductivity "
-                             "formulation. Pressure- and temperature-dependence will be applied"
-                             "on top of this base value, according to the parameters 'Pressure "
-                             "dependencies of thermal conductivity' and 'Reference temperatures "
-                             "for thermal conductivity'. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}");
-          prm.declare_entry ("Pressure dependencies of thermal conductivity", "3.3e-10, 3.4e-10, 3.6e-10, 1.05e-10",
-                             Patterns::List(Patterns::Double ()),
-                             "A list of values that determine the linear scaling of the "
-                             "thermal conductivity with the pressure in the 'p-T-dependent' "
-                             "Thermal conductivity formulation. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin\\per\\pascal}.");
-          prm.declare_entry ("Reference temperatures for thermal conductivity", "300, 300, 300, 1200",
-                             Patterns::List(Patterns::Double (0.)),
-                             "A list of values of reference temperatures used to determine "
-                             "the temperature-dependence of the thermal conductivity in the "
-                             "'p-T-dependent' Thermal conductivity formulation. "
-                             "Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Thermal conductivity exponents", "0.48, 0.56, 0.61, 1.0",
-                             Patterns::List(Patterns::Double (0.)),
-                             "A list of exponents in the temperature-dependent term of the "
-                             "'p-T-dependent' Thermal conductivity formulation. Note that this "
-                             "exponent is not used (and should have a value of 1) in the "
-                             "formulation of Stackhouse et al. (2015). "
-                             "Units: none.");
-          prm.declare_entry ("Saturation prefactors", "0, 0, 0, 1",
-                             Patterns::List(Patterns::Double (0., 1.)),
-                             "A list of values that indicate how a given layer in the "
-                             "conductivity formulation should take into account the effects "
-                             "of saturation on the temperature-dependence of the thermal "
-                             "conducitivity. This factor is multiplied with a saturation function "
-                             "based on the theory of Roufosse and Klemens, 1974. A value of 1 "
-                             "reproduces the formulation of Stackhouse et al. (2015), a value of "
-                             "0 reproduces the formulation of Tosi et al., (2013). "
-                             "Units: none.");
-          prm.declare_entry ("Maximum thermal conductivity", "1000",
-                             Patterns::Double (0.),
-                             "The maximum thermal conductivity that is allowed in the "
-                             "model. Larger values will be cut off.");
-
-          // Table lookup parameters
-          EquationOfState::ThermodynamicTableLookup<dim>::declare_parameters(prm);
-
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    Steinberger<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Steinberger model");
-        {
-          data_directory                  = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-          radial_viscosity_file_name      = prm.get ("Radial viscosity file name");
-          lateral_viscosity_file_name     = prm.get ("Lateral viscosity file name");
-          use_lateral_average_temperature = prm.get_bool ("Use lateral average temperature for viscosity");
-          n_lateral_slices                = prm.get_integer("Number lateral average bands");
-          min_eta                         = prm.get_double ("Minimum viscosity");
-          max_eta                         = prm.get_double ("Maximum viscosity");
-          max_lateral_eta_variation       = prm.get_double ("Maximum lateral viscosity variation");
-          viscosity_averaging_scheme      = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
-                                            prm);
-          thermal_conductivity_value      = prm.get_double ("Thermal conductivity");
-
-          // Rheological parameters
-          if (prm.get ("Thermal conductivity formulation") == "constant")
-            conductivity_formulation = constant;
-          else if (prm.get ("Thermal conductivity formulation") == "p-T-dependent")
-            conductivity_formulation = p_T_dependent;
-          else
-            AssertThrow(false, ExcMessage("Not a valid thermal conductivity formulation"));
-
-          conductivity_transition_depths = Utilities::string_to_double
-                                           (Utilities::split_string_list(prm.get ("Thermal conductivity transition depths")));
-          const unsigned int n_conductivity_layers = conductivity_transition_depths.size() + 1;
-
-          AssertThrow (std::is_sorted(conductivity_transition_depths.begin(), conductivity_transition_depths.end()),
-                       ExcMessage("The list of 'Thermal conductivity transition depths' must "
-                                  "be sorted such that the values increase monotonically."));
-
-          reference_thermal_conductivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Reference thermal conductivities"))),
-                                                                                     n_conductivity_layers,
-                                                                                     "Reference thermal conductivities");
-          conductivity_pressure_dependencies = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Pressure dependencies of thermal conductivity"))),
-                                                                                       n_conductivity_layers,
-                                                                                       "Pressure dependencies of thermal conductivity");
-          conductivity_reference_temperatures = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Reference temperatures for thermal conductivity"))),
-                                                                                        n_conductivity_layers,
-                                                                                        "Reference temperatures for thermal conductivity");
-          conductivity_exponents = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal conductivity exponents"))),
-                                                                           n_conductivity_layers,
-                                                                           "Thermal conductivity exponents");
-          saturation_scaling = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Saturation prefactors"))),
-                                                                       n_conductivity_layers,
-                                                                       "Saturation prefactors");
-          maximum_conductivity = prm.get_double ("Maximum thermal conductivity");
-
-          // Parse the table lookup parameters
-          equation_of_state.initialize_simulator (this->get_simulator());
-          equation_of_state.parse_parameters(prm);
-
-          // Assign background field and do some error checking
-          const unsigned int n_chemical_composition_fields = this->introspection().get_number_of_fields_of_type(CompositionalFieldDescription::chemical_composition);
-          has_background_field = ((equation_of_state.number_of_lookups() == 1) ||
-                                  (equation_of_state.number_of_lookups() == n_chemical_composition_fields + 1));
-          AssertThrow ((equation_of_state.number_of_lookups() == 1) ||
-                       (equation_of_state.number_of_lookups() == n_chemical_composition_fields) ||
-                       (equation_of_state.number_of_lookups() == n_chemical_composition_fields + 1),
-                       ExcMessage("The Steinberger material model assumes that either there is a single material "
-                                  "in the simulation, or that all compositional fields of the type "
-                                  "chemical composition correspond to mass fractions of different materials. "
-                                  "There must either be one material lookup file, the same number of "
-                                  "material lookup files as compositional fields of type chemical composition, "
-                                  "or one additional file (if a background field is used). You have "
-                                  + Utilities::int_to_string(equation_of_state.number_of_lookups())
-                                  + " material data files, but there are "
-                                  + Utilities::int_to_string(n_chemical_composition_fields)
-                                  + " fields of type chemical composition."));
-
-          // Parse the Composition viscosity prefactors parameter
-          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-
-          // If there is only one lookup, the list of Viscosity prefactors should have length one.
-          // The following if statement applies when defined fields of type chemical composition
-          // are not intended to be used as volume fractions of distinct materials.
-          if (equation_of_state.number_of_lookups() == 1)
-            {
-              chemical_field_names.clear();
-              compositional_field_names.clear();
-            }
-
-          if (has_background_field)
-            {
-              chemical_field_names.insert(chemical_field_names.begin(),"background");
-              compositional_field_names.insert(compositional_field_names.begin(),"background");
-            }
-
-          Utilities::MapParsing::Options options(chemical_field_names, "Composition viscosity prefactors");
-          options.list_of_allowed_keys = compositional_field_names;
-          viscosity_prefactors = Utilities::MapParsing::parse_map_to_double_array(prm.get("Composition viscosity prefactors"), options);
-
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-
-        // Declare dependencies on solution variables
-        this->model_dependence.viscosity = NonlinearDependence::temperature;
-        this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-        this->model_dependence.compressibility = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-        this->model_dependence.specific_heat = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-        this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    Steinberger<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      equation_of_state.create_additional_named_outputs(out);
-
-      if (this->introspection().composition_type_exists(CompositionalFieldDescription::density)
-          && out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points, this->n_compositional_fields()));
-        }
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Steinberger,
-                                   "Steinberger",
-                                   "This material model looks up the viscosity from the tables that "
-                                   "correspond to the paper of Steinberger and Calderwood "
-                                   "2006 (``Models of large-scale viscous flow in the Earth's "
-                                   "mantle with constraints from mineral physics and surface observations'', "
-                                   "Geophys. J. Int., 167, 1461-1481, "
-                                   "<http://dx.doi.org/10.1111/j.1365-246X.2006.03131.x>) and material "
-                                   "data from a database generated by the thermodynamics code \\texttt{Perplex}, "
-                                   "see <http://www.perplex.ethz.ch/>. "
-                                   "The default example data builds upon the thermodynamic "
-                                   "database by Stixrude 2011 and assumes a pyrolitic composition by "
-                                   "Ringwood 1988 but is easily replaceable by other data files. ")
-  }
-}
diff --git a/source/material_model/utilities.cc.bak b/source/material_model/utilities.cc.bak
deleted file mode 100644
index 2c426e215c6..00000000000
--- a/source/material_model/utilities.cc.bak
+++ /dev/null
@@ -1,1546 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-#include <aspect/structured_data.h>
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/gravity_model/interface.h>
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/equation_of_state/interface.h>
-#include <aspect/material_model/utilities.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/exceptions.h>
-#include <boost/lexical_cast.hpp>
-#include <list>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace MaterialUtilities
-    {
-      namespace Lookup
-      {
-        double
-        MaterialLookup::specific_heat(const double temperature,
-                                      const double pressure) const
-        {
-          return value(temperature,pressure,specific_heat_values,interpolation);
-        }
-
-        double
-        MaterialLookup::density(const double temperature,
-                                const double pressure) const
-        {
-          return value(temperature,pressure,density_values,interpolation);
-        }
-
-        double
-        MaterialLookup::thermal_expansivity(const double temperature,
-                                            const double pressure) const
-        {
-          return value(temperature,pressure,thermal_expansivity_values,interpolation);
-        }
-
-        double
-        MaterialLookup::seismic_Vp(const double temperature,
-                                   const double pressure) const
-        {
-          return value(temperature,pressure,vp_values,false);
-        }
-
-        double
-        MaterialLookup::seismic_Vs(const double temperature,
-                                   const double pressure) const
-        {
-          return value(temperature,pressure,vs_values,false);
-        }
-
-        double
-        MaterialLookup::enthalpy(const double temperature,
-                                 const double pressure) const
-        {
-          return value(temperature,pressure,enthalpy_values,true);
-        }
-
-        double
-        MaterialLookup::dHdT (const double temperature,
-                              const double pressure) const
-        {
-          const double h = value(temperature,pressure,enthalpy_values,interpolation);
-          const double dh = value(temperature+delta_temp,pressure,enthalpy_values,interpolation);
-          return (dh - h) / delta_temp;
-        }
-
-        double
-        MaterialLookup::dHdp (const double temperature,
-                              const double pressure) const
-        {
-          const double h = value(temperature,pressure,enthalpy_values,interpolation);
-          const double dh = value(temperature,pressure+delta_press,enthalpy_values,interpolation);
-          return (dh - h) / delta_press;
-        }
-
-        std::array<std::pair<double, unsigned int>,2>
-        MaterialLookup::enthalpy_derivatives(const std::vector<double> &temperatures,
-                                             const std::vector<double> &pressures,
-                                             const unsigned int n_substeps) const
-        {
-          Assert(temperatures.size() == pressures.size(),ExcInternalError());
-          const unsigned int n_q_points = temperatures.size();
-          unsigned int n_T(0), n_p(0);
-          double dHdT(0.0), dHdp(0.0);
-
-          for (unsigned int q=0; q<n_q_points; ++q)
-            {
-              for (unsigned int p=0; p<n_q_points; ++p)
-                {
-                  if (std::fabs(temperatures[q] - temperatures[p]) > 100.0 * std::numeric_limits<double>::epsilon() * std::fabs(temperatures[q] + std::numeric_limits<double>::epsilon()))
-                    {
-                      for (unsigned int substep = 0; substep < n_substeps; ++substep)
-                        {
-                          const double step_ratio = static_cast<double>(substep)/static_cast<double>(n_substeps);
-                          const double step_ratio_next = static_cast<double>(substep+1)/static_cast<double>(n_substeps);
-
-                          const double current_pressure = pressures[q]
-                                                          + step_ratio
-                                                          * (pressures[p]-pressures[q]);
-                          const double T1_substep = temperatures[q]
-                                                    + step_ratio
-                                                    * (temperatures[p]-temperatures[q]);
-                          const double T2_substep = temperatures[q]
-                                                    + step_ratio_next
-                                                    * (temperatures[p]-temperatures[q]);
-                          const double enthalpy2 = enthalpy(T2_substep,current_pressure);
-                          const double enthalpy1 = enthalpy(T1_substep,current_pressure);
-                          dHdT += (enthalpy2-enthalpy1)/(T2_substep-T1_substep);
-                          ++n_T;
-                        }
-                    }
-                  if (std::fabs(pressures[q] - pressures[p]) > 100.0 * std::numeric_limits<double>::epsilon() * std::fabs(pressures[q] + std::numeric_limits<double>::epsilon()))
-                    {
-                      for (unsigned int substep = 0; substep < n_substeps; ++substep)
-                        {
-                          const double step_ratio = static_cast<double>(substep)/static_cast<double>(n_substeps);
-                          const double step_ratio_next = static_cast<double>(substep+1)/static_cast<double>(n_substeps);
-                          const double current_temperature = temperatures[q]
-                                                             + step_ratio
-                                                             * (temperatures[p]-temperatures[q]);
-                          const double p1_substep = pressures[q]
-                                                    + step_ratio
-                                                    * (pressures[p]-pressures[q]);
-                          const double p2_substep = pressures[q]
-                                                    + step_ratio_next
-                                                    * (pressures[p]-pressures[q]);
-                          const double enthalpy2 = enthalpy(current_temperature,p2_substep);
-                          const double enthalpy1 = enthalpy(current_temperature,p1_substep);
-                          dHdp += (enthalpy2-enthalpy1)/(p2_substep-p1_substep);
-                          ++n_p;
-                        }
-                    }
-                }
-            }
-
-          if ((n_T > 0)
-              && (n_p > 0))
-            {
-              dHdT /= n_T;
-              dHdp /= n_p;
-            }
-
-          std::array<std::pair<double, unsigned int>,2> derivatives;
-          derivatives[0] = std::make_pair(dHdT,n_T);
-          derivatives[1] = std::make_pair(dHdp,n_p);
-          return derivatives;
-        }
-
-        double
-        MaterialLookup::dRhodp (const double temperature,
-                                const double pressure) const
-        {
-          const double rho = value(temperature,pressure,density_values,interpolation);
-          const double drho = value(temperature,pressure+delta_press,density_values,interpolation);
-          return (drho - rho) / delta_press;
-        }
-
-        unsigned int
-        MaterialLookup::dominant_phase (const double temperature,
-                                        const double pressure) const
-        {
-          if (!has_dominant_phase_column)
-            AssertThrow(false, ExcMessage("You can not ask for the column with the dominant phase if it does not exist in the data file."));
-          return value(temperature, pressure, dominant_phase_indices);
-        }
-
-        bool
-        MaterialLookup::has_dominant_phase() const
-        {
-          return has_dominant_phase_column;
-        }
-
-        std::vector<std::string>
-        MaterialLookup::phase_volume_column_names() const
-        {
-          return phase_column_names;
-        }
-
-        double
-        MaterialLookup::phase_volume_fraction(const int phase_id,
-                                              const double temperature,
-                                              const double pressure) const
-        {
-          return value(temperature,pressure,phase_volume_fractions[phase_id],interpolation);
-        }
-
-
-        const std::vector<std::string> &
-        MaterialLookup::get_dominant_phase_names() const
-        {
-          return dominant_phase_names;
-        }
-
-        double
-        MaterialLookup::value (const double temperature,
-                               const double pressure,
-                               const Table<2, double> &values,
-                               const bool interpol) const
-        {
-          const double nT = get_nT(temperature);
-          const unsigned int inT = static_cast<unsigned int>(nT);
-
-          const double np = get_np(pressure);
-          const unsigned int inp = static_cast<unsigned int>(np);
-
-          Assert(inT<values.n_rows(), ExcMessage("Attempting to look up a temperature value with index greater than the number of rows."));
-          Assert(inp<values.n_cols(), ExcMessage("Attempting to look up a pressure value with index greater than the number of columns."));
-
-          if (!interpol)
-            return values[inT][inp];
-          else
-            {
-              // compute the coordinates of this point in the
-              // reference cell between the data points
-              const double xi = nT-inT;
-              const double eta = np-inp;
-
-              Assert ((0 <= xi) && (xi <= 1), ExcInternalError());
-              Assert ((0 <= eta) && (eta <= 1), ExcInternalError());
-
-              // use these coordinates for a bilinear interpolation
-              return ((1-xi)*(1-eta)*values[inT][inp] +
-                      xi    *(1-eta)*values[inT+1][inp] +
-                      (1-xi)*eta    *values[inT][inp+1] +
-                      xi    *eta    *values[inT+1][inp+1]);
-            }
-        }
-
-        unsigned int
-        MaterialLookup::value (const double temperature,
-                               const double pressure,
-                               const Table<2, unsigned int> &values) const
-        {
-          const double nT = get_nT(temperature);
-          const unsigned int inT = static_cast<unsigned int>(nT);
-
-          const double np = get_np(pressure);
-          const unsigned int inp = static_cast<unsigned int>(np);
-
-          Assert(inT<values.n_rows(), ExcMessage("Attempting to look up a temperature value with index greater than the number of rows."));
-          Assert(inp<values.n_cols(), ExcMessage("Attempting to look up a pressure value with index greater than the number of columns."));
-
-          return values[inT][inp];
-        }
-
-        std::array<double,2>
-        MaterialLookup::get_pT_steps() const
-        {
-          std::array<double,2> pt_steps;
-          pt_steps[0] = delta_press;
-          pt_steps[1] = delta_temp;
-          return pt_steps;
-        }
-
-        double
-        MaterialLookup::get_nT(const double temperature) const
-        {
-          double bounded_temperature=std::max(min_temp, temperature);
-          bounded_temperature=std::min(bounded_temperature, max_temp-delta_temp);
-
-          return (bounded_temperature-min_temp)/delta_temp;
-        }
-
-        double
-        MaterialLookup::get_np(const double pressure) const
-        {
-          double bounded_pressure=std::max(min_press, pressure);
-          bounded_pressure=std::min(bounded_pressure, max_press-delta_press);
-
-          return (bounded_pressure-min_press)/delta_press;
-        }
-
-        HeFESToReader::HeFESToReader(const std::string &material_filename,
-                                     const std::string &derivatives_filename,
-                                     const bool interpol,
-                                     const MPI_Comm comm)
-        {
-          /* Initializing variables */
-          interpolation = interpol;
-          delta_press=numbers::signaling_nan<double>();
-          min_press=std::numeric_limits<double>::max();
-          max_press=std::numeric_limits<double>::lowest();
-          delta_temp=numbers::signaling_nan<double>();
-          min_temp=std::numeric_limits<double>::max();
-          max_temp=std::numeric_limits<double>::lowest();
-          n_temperature=0;
-          n_pressure=0;
-
-          std::string temp;
-
-          // Read material data
-          {
-            // Read data from disk and distribute among processes
-            std::istringstream in(Utilities::read_and_distribute_file_content(material_filename, comm));
-
-            bool parsed_first_column = false;
-            unsigned int i = 0;
-            double current_pressure = 0.0;
-            double old_pressure = -1.0;
-            while (!in.eof())
-              {
-                in >> current_pressure;
-                if (in.fail())
-                  {
-                    in.clear();
-                  }
-
-                if (!parsed_first_column)
-                  {
-                    if (current_pressure > old_pressure)
-                      old_pressure = current_pressure;
-                    else if (current_pressure <= old_pressure)
-                      {
-                        n_pressure = i;
-                        parsed_first_column = true;
-                      }
-                  }
-
-                std::getline(in, temp);
-                if (in.eof())
-                  break;
-                ++i;
-              }
-
-            in.clear();
-            in.seekg (0, in.beg);
-
-            n_temperature = i / n_pressure;
-
-            Assert(i == n_temperature * n_pressure,
-                   ExcMessage("Material table size not consistent."));
-
-            density_values.reinit(n_temperature,n_pressure);
-            thermal_expansivity_values.reinit(n_temperature,n_pressure);
-            specific_heat_values.reinit(n_temperature,n_pressure);
-            vp_values.reinit(n_temperature,n_pressure);
-            vs_values.reinit(n_temperature,n_pressure);
-            enthalpy_values.reinit(n_temperature,n_pressure);
-
-            i = 0;
-            while (!in.eof())
-              {
-                double P = 0.0;
-                double depth,T;
-                double rho,vb,vs,vp,vsq,vpq,h;
-                std::string code;
-                double alpha = 0.0;
-                double cp = 0.0;
-
-                in >> P >> depth >> T;
-                if (in.fail())
-                  in.clear();
-                // conversion from [GPa] to [Pa]
-                P *= 1e9;
-
-                min_press=std::min(P,min_press);
-                min_temp=std::min(T,min_temp);
-                max_temp = std::max(T,max_temp);
-                max_press = std::max(P,max_press);
-
-                in >> rho;
-                if (in.fail())
-                  {
-                    in.clear();
-                    rho = density_values[(i-1)%n_temperature][(i-1)/n_temperature];
-                  }
-                else
-                  rho *= 1e3; // conversion from [g/cm^3] to [kg/m^3]
-
-                in >> vb;
-                if (in.fail())
-                  in.clear();
-
-                in >> vs;
-                if (in.fail())
-                  {
-                    in.clear();
-                    vs = vs_values[(i-1)%n_temperature][(i-1)/n_temperature];
-                  }
-                in >> vp;
-                if (in.fail())
-                  {
-                    in.clear();
-                    vp = vp_values[(i-1)%n_temperature][(i-1)/n_temperature];
-                  }
-                in >> vsq >> vpq;
-
-                in >> h;
-                if (in.fail())
-                  {
-                    in.clear();
-                    h = enthalpy_values[(i-1)%n_temperature][(i-1)/n_temperature];
-                  }
-                else
-                  h *= 1e6; // conversion from [kJ/g] to [J/kg]
-
-                std::getline(in, temp);
-                if (in.eof())
-                  break;
-
-                density_values[i/n_pressure][i%n_pressure]=rho;
-                thermal_expansivity_values[i/n_pressure][i%n_pressure]=alpha;
-                specific_heat_values[i/n_pressure][i%n_pressure]=cp;
-                vp_values[i/n_pressure][i%n_pressure]=vp;
-                vs_values[i/n_pressure][i%n_pressure]=vs;
-                enthalpy_values[i/n_pressure][i%n_pressure]=h;
-
-                ++i;
-              }
-
-            delta_temp = (max_temp - min_temp) / (n_temperature - 1);
-            delta_press = (max_press - min_press) / (n_pressure - 1);
-
-            AssertThrow(max_temp >= 0.0, ExcMessage("Read in of Material header failed (max_temp)."));
-            AssertThrow(delta_temp > 0, ExcMessage("Read in of Material header failed (delta_temp)."));
-            AssertThrow(n_temperature > 0, ExcMessage("Read in of Material header failed (numtemp)."));
-            AssertThrow(max_press >= 0, ExcMessage("Read in of Material header failed (max_press)."));
-            AssertThrow(delta_press > 0, ExcMessage("Read in of Material header failed (delta_press)."));
-            AssertThrow(n_pressure > 0, ExcMessage("Read in of Material header failed (numpress)."));
-          }
-
-          // If requested read derivative data
-          if (derivatives_filename != "")
-            {
-              std::string temp;
-              // Read data from disk and distribute among processes
-              std::istringstream in(Utilities::read_and_distribute_file_content(derivatives_filename, comm));
-
-              int i = 0;
-              while (!in.eof())
-                {
-                  double P = 0.0;
-                  double depth,T;
-                  double cp,alpha,alpha_eff;
-                  double temp1,temp2;
-
-                  in >> P >> depth >> T;
-                  if (in.fail())
-                    in.clear();
-
-
-                  in >> cp;
-                  if (in.fail() || (cp <= std::numeric_limits<double>::min()))
-                    {
-                      in.clear();
-                      cp = specific_heat_values[(i-1)%n_temperature][(i-1)/n_temperature];
-                    }
-                  else
-                    cp *= 1e3; // conversion from [J/g/K] to [J/kg/K]
-
-                  in >> alpha >> alpha_eff;
-                  if (in.fail() || (alpha_eff <= std::numeric_limits<double>::min()))
-                    {
-                      in.clear();
-                      alpha_eff = thermal_expansivity_values[(i-1)%n_temperature][(i-1)/n_temperature];
-                    }
-                  else
-                    {
-                      alpha *= 1e-5;
-                      alpha_eff *= 1e-5;
-                    }
-
-                  in >> temp1 >> temp2;
-                  if (in.fail())
-                    in.clear();
-
-
-                  std::getline(in, temp);
-                  if (in.eof())
-                    break;
-
-                  specific_heat_values[i/n_pressure][i%n_pressure]=cp;
-                  thermal_expansivity_values[i/n_pressure][i%n_pressure]=alpha_eff;
-
-                  ++i;
-                }
-            }
-        }
-
-        PerplexReader::PerplexReader(const std::string &filename,
-                                     const bool interpol,
-                                     const MPI_Comm comm)
-        {
-          /* Initializing variables */
-          interpolation = interpol;
-          delta_press=numbers::signaling_nan<double>();
-          min_press=std::numeric_limits<double>::max();
-          max_press=std::numeric_limits<double>::lowest();
-          delta_temp=numbers::signaling_nan<double>();
-          min_temp=std::numeric_limits<double>::max();
-          max_temp=std::numeric_limits<double>::lowest();
-          n_temperature=0;
-          n_pressure=0;
-          has_dominant_phase_column = false;
-
-          std::string temp;
-          // Read data from disk and distribute among processes
-          std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
-
-          // The following lines read in a PerpleX tab file in standard format
-          // The first 13 lines are a header in the format:
-          // |<perplex version>
-          // <table filename>
-          // <grid dim>
-          // <grid variable 1> (usually T(K) or P(bar))
-          // <min grid variable 1>
-          // <delta grid variable 1>
-          // <n steps grid variable 1>
-          // <grid variable 2> (usually T(K) or P(bar))
-          // <min grid variable 2>
-          // <delta grid variable 2>
-          // <n steps grid variable 2>
-          // Number of property columns in the table
-          // Column names
-
-          // First line is the Perplex version number
-          std::getline(in, temp); // get next line, table file name
-
-          std::getline(in, temp); // get next line, dimension of table
-          unsigned int n_variables;
-          in >> n_variables;
-          AssertThrow (n_variables==2, ExcMessage("The PerpleX file " + filename + " must be two dimensional (P(bar)-T(K))."));
-
-          std::getline(in, temp); // get next line, either T(K) or P(bar)
-
-          for (unsigned int i=0; i<2; ++i)
-            {
-              std::string natural_variable;
-              in >> natural_variable;
-
-              if (natural_variable == "T(K)")
-                {
-                  std::getline(in, temp);
-                  in >> min_temp;
-                  std::getline(in, temp);
-                  in >> delta_temp;
-                  std::getline(in, temp);
-                  in >> n_temperature;
-                  std::getline(in, temp); // get next line, either T(K), P(bar) or number of columns
-                }
-              else if (natural_variable == "P(bar)")
-                {
-                  std::getline(in, temp);
-                  in >> min_press;
-                  min_press *= 1e5;  // conversion from [bar] to [Pa]
-                  std::getline(in, temp);
-                  in >> delta_press;
-                  delta_press *= 1e5; // conversion from [bar] to [Pa]
-                  std::getline(in, temp);
-                  in >> n_pressure;
-                  std::getline(in, temp); // get next line, either T(K), P(bar) or number of columns
-                }
-              else
-                {
-                  AssertThrow (false, ExcMessage("The start of the PerpleX file " + filename + " does not have the expected format."));
-                }
-            }
-
-          in >> n_columns;
-          std::getline(in, temp); // get next line, column labels
-
-          // here we string match to assign properties to columns
-          // column i in text file -> column j in properties
-          // Properties are stored in the order rho, alpha, cp, vp, vs, h
-          std::vector<int> prp_indices(6, -1);
-          std::vector<int> phase_column_indices;
-          unsigned int dominant_phase_column_index = numbers::invalid_unsigned_int;
-
-          // First two columns should be P(bar) and T(K).
-          // Here we find the order.
-          std::string column_name;
-          in >> column_name;
-
-          std::string first_natural_variable;
-          if (column_name == "P(bar)")
-            {
-              first_natural_variable = column_name;
-              in >> column_name;
-              AssertThrow(column_name == "T(K)", ExcMessage("The second column name in PerpleX lookup file " + filename + " should be T(K)."));
-            }
-          else if (column_name == "T(K)")
-            {
-              first_natural_variable = column_name;
-              in >> column_name;
-              AssertThrow(column_name == "P(bar)", ExcMessage("The second column name in PerpleX lookup file " + filename + " should be P(bar)."));
-            }
-          else
-            {
-              AssertThrow(false, ExcMessage("The first column name in the PerpleX lookup file " + filename + " should be P(bar) or T(K)."));
-            }
-
-          for (unsigned int n=2; n<n_columns; ++n)
-            {
-              in >> column_name;
-              if (column_name == "rho,kg/m3")
-                prp_indices[0] = n;
-              else if (column_name == "alpha,1/K")
-                prp_indices[1] = n;
-              else if (column_name == "cp,J/K/kg")
-                prp_indices[2] = n;
-              else if (column_name == "vp,km/s")
-                prp_indices[3] = n;
-              else if (column_name == "vs,km/s")
-                prp_indices[4] = n;
-              else if (column_name == "h,J/kg")
-                prp_indices[5] = n;
-              else if (column_name == "phase")
-                {
-                  has_dominant_phase_column = true;
-                  dominant_phase_column_index = n;
-                }
-              else if (column_name.length() > 3)
-                {
-                  if (column_name.substr(0,13).compare("vol_fraction_") == 0)
-                    {
-                      if (std::find(phase_column_names.begin(),
-                                    phase_column_names.end(),
-                                    column_name) != phase_column_names.end())
-                        {
-                          AssertThrow(false,
-                                      ExcMessage("The PerpleX lookup file " + filename + " must have unique column names. "
-                                                 "Sometimes, the same phase is stable with >1 composition at the same "
-                                                 "pressure and temperature, so you may see several columns with the same name. "
-                                                 "Either combine columns with the same name, or change the names."));
-                        }
-                      // Populate phase_column_names with the column name
-                      // and phase_column_indices with the column index in the current lookup file.
-                      phase_column_indices.push_back(n);
-                      phase_column_names.push_back(column_name);
-                    }
-                }
-            }
-          AssertThrow(std::all_of(prp_indices.begin(), prp_indices.end(), [](int i)
-          {
-            return i>=0;
-          }),
-          ExcMessage("The PerpleX lookup file " + filename + " must contain columns with names "
-                     "rho,kg/m3, alpha,1/K, cp,J/K/kg, vp,km/s, vs,km/s and h,J/kg."));
-
-          std::getline(in, temp); // first data line
-
-          AssertThrow(min_temp >= 0.0, ExcMessage("Read in of Material header failed (mintemp)."));
-          AssertThrow(delta_temp > 0, ExcMessage("Read in of Material header failed (delta_temp)."));
-          AssertThrow(n_temperature > 0, ExcMessage("Read in of Material header failed (numtemp)."));
-          AssertThrow(min_press >= 0, ExcMessage("Read in of Material header failed (min_press)."));
-          AssertThrow(delta_press > 0, ExcMessage("Read in of Material header failed (delta_press)."));
-          AssertThrow(n_pressure > 0, ExcMessage("Read in of Material header failed (numpress)."));
-
-
-          max_temp = min_temp + (n_temperature-1) * delta_temp;
-          max_press = min_press + (n_pressure-1) * delta_press;
-
-          density_values.reinit(n_temperature,n_pressure);
-          thermal_expansivity_values.reinit(n_temperature,n_pressure);
-          specific_heat_values.reinit(n_temperature,n_pressure);
-          vp_values.reinit(n_temperature,n_pressure);
-          vs_values.reinit(n_temperature,n_pressure);
-          enthalpy_values.reinit(n_temperature,n_pressure);
-
-          if (has_dominant_phase_column)
-            dominant_phase_indices.reinit(n_temperature,n_pressure);
-
-          phase_volume_fractions.resize(phase_column_names.size());
-          for (auto &phase_volume_fraction : phase_volume_fractions)
-            phase_volume_fraction.reinit(n_temperature,n_pressure);
-
-          unsigned int i = 0;
-          std::vector<double> previous_row_values(n_columns, 0.);
-
-          while (!in.eof())
-            {
-              std::vector<double> row_values(n_columns);
-              std::string phase;
-
-              for (unsigned int n=0; n<n_columns; ++n)
-                {
-                  if (n == dominant_phase_column_index)
-                    in >> phase;
-                  else
-                    in >> row_values[n]; // assigned as 0 if in.fail() == True
-
-                  // P-T grids created with PerpleX-werami sometimes contain rows
-                  // filled with NaNs at extreme P-T conditions where the thermodynamic
-                  // models break down. These P-T regions are typically not relevant to
-                  // geodynamic modeling (they most commonly appear above
-                  // mantle liquidus temperatures at low pressures).
-                  // More frustratingly, PerpleX-vertex occasionally fails to find a
-                  // valid mineral assemblage in small, isolated regions within the domain,
-                  // and so PerpleX-werami also returns NaNs for pixels within these regions.
-                  // It is recommended that the user preprocesses their input
-                  // files to replace these NaNs before plugging them into ASPECT.
-                  // If this lookup encounters invalid doubles it replaces them
-                  // with the most recent valid double.
-                  if (in.fail())
-                    {
-                      in.clear();
-                      row_values[n] = previous_row_values[n];
-                    }
-                }
-              previous_row_values = row_values;
-
-              std::getline(in, temp); // read next line
-              if (in.eof())
-                break;
-
-              if (std::find(dominant_phase_names.begin(), dominant_phase_names.end(), phase) == dominant_phase_names.end())
-                dominant_phase_names.push_back(phase);
-
-              // The ordering of the first two columns in the PerpleX table files
-              // dictates whether the inner loop is over temperature or pressure.
-              // The first column is always the inner loop.
-              // The following lines populate the material property tables
-              // according to that implicit loop structure.
-              if (first_natural_variable == "T(K)")
-                {
-                  density_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[0]];
-                  thermal_expansivity_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[1]];
-                  specific_heat_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[2]];
-                  vp_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[3]];
-                  vs_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[4]];
-                  enthalpy_values[i%n_temperature][i/n_temperature]=row_values[prp_indices[5]];
-
-                  if (has_dominant_phase_column)
-                    {
-                      std::vector<std::string>::iterator it = std::find(dominant_phase_names.begin(), dominant_phase_names.end(), phase);
-                      dominant_phase_indices[i%n_temperature][i/n_temperature] = std::distance(dominant_phase_names.begin(), it);
-                    }
-
-                  for (unsigned int n=0; n<phase_volume_fractions.size(); ++n)
-                    {
-                      phase_volume_fractions[n][i%n_temperature][i/n_temperature]=row_values[phase_column_indices[n]];
-                    }
-                }
-              else // first_natural_variable == "P(bar)"
-                {
-                  density_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[0]];
-                  thermal_expansivity_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[1]];
-                  specific_heat_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[2]];
-                  vp_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[3]];
-                  vs_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[4]];
-                  enthalpy_values[i/n_pressure][i%n_pressure]=row_values[prp_indices[5]];
-
-                  if (has_dominant_phase_column)
-                    {
-                      std::vector<std::string>::iterator it = std::find(dominant_phase_names.begin(), dominant_phase_names.end(), phase);
-                      dominant_phase_indices[i/n_pressure][i%n_pressure] = std::distance(dominant_phase_names.begin(), it);
-                    }
-
-                  for (unsigned int n=0; n<phase_volume_fractions.size(); ++n)
-                    {
-                      phase_volume_fractions[n][i/n_pressure][i%n_pressure]=row_values[phase_column_indices[n]];
-                    }
-                }
-              ++i;
-            }
-          AssertThrow(i == n_temperature*n_pressure, ExcMessage("Material table size not consistent with header."));
-
-        }
-
-
-
-        void
-        EntropyReader::initialize(const MPI_Comm comm,
-                                  const std::string &data_directory,
-                                  const std::string &material_file_name)
-        {
-          material_lookup = std::make_unique<Utilities::StructuredDataLookup<2>>(7,1.0);
-          material_lookup->load_file(data_directory+material_file_name,
-                                     comm);
-        }
-
-
-
-        double
-        EntropyReader::specific_heat(const double entropy,
-                                     const double pressure) const
-        {
-          const double specific_heat = material_lookup->get_data({entropy,pressure}, 3);
-          return specific_heat;
-        }
-
-
-
-        double
-        EntropyReader::density(const double entropy,
-                               const double pressure) const
-        {
-          const double density = material_lookup->get_data({entropy,pressure}, 1);
-          return density;
-        }
-
-
-
-        double
-        EntropyReader::thermal_expansivity(const double entropy,
-                                           const double pressure) const
-        {
-          const double thermal_expansivity = material_lookup->get_data({entropy,pressure}, 2);
-          return thermal_expansivity;
-        }
-
-
-
-        double
-        EntropyReader::temperature(const double entropy,
-                                   const double pressure) const
-        {
-          const double temperature = material_lookup->get_data({entropy,pressure}, 0);
-          return temperature;
-        }
-
-
-
-        double
-        EntropyReader::seismic_vp(const double entropy,
-                                  const double pressure) const
-        {
-          const double seismic_vp = material_lookup->get_data({entropy,pressure}, 4);
-          return seismic_vp;
-        }
-
-
-
-        double
-        EntropyReader::seismic_vs(const double entropy,
-                                  const double pressure) const
-        {
-          const double seismic_vs = material_lookup->get_data({entropy,pressure}, 5);
-          return seismic_vs;
-        }
-
-
-
-        Tensor<1, 2>
-        EntropyReader::density_gradient(const double entropy,
-                                        const double pressure) const
-        {
-          const Tensor<1, 2> density_gradient= material_lookup->get_gradients({entropy,pressure}, 1);
-          return density_gradient;
-        }
-
-
-      }
-
-
-
-      std::vector<double>
-      compute_only_composition_fractions(const std::vector<double> &compositional_fields,
-                                         const std::vector<unsigned int> &indices_to_use)
-      {
-        std::vector<double> composition_fractions(indices_to_use.size()+1);
-
-        // Clip the compositional fields so they are between zero and one,
-        // and sum the compositional fields for normalization purposes.
-        double sum_composition = 0.0;
-        std::vector<double> x_comp (indices_to_use.size());
-
-        for (unsigned int i=0; i < x_comp.size(); ++i)
-          {
-            x_comp[i] = std::min(std::max(compositional_fields[indices_to_use[i]], 0.0), 1.0);
-            sum_composition += x_comp[i];
-          }
-
-        // Compute background field fraction
-        if (sum_composition >= 1.0)
-          composition_fractions[0] = 0.0;
-        else
-          composition_fractions[0] = 1.0 - sum_composition;
-
-        // Compute and possibly normalize field fractions
-        for (unsigned int i=0; i < x_comp.size(); ++i)
-          {
-            if (sum_composition >= 1.0)
-              composition_fractions[i+1] = x_comp[i]/sum_composition;
-            else
-              composition_fractions[i+1] = x_comp[i];
-          }
-
-        return composition_fractions;
-      }
-
-
-
-      std::vector<double>
-      compute_composition_fractions(const std::vector<double> &compositional_fields,
-                                    const ComponentMask &field_mask)
-      {
-        std::vector<double> composition_fractions(compositional_fields.size()+1);
-
-        // Clip the compositional fields so they are between zero and one,
-        // and sum the compositional fields for normalization purposes.
-        double sum_composition = 0.0;
-        std::vector<double> x_comp = compositional_fields;
-        for (unsigned int i=0; i < x_comp.size(); ++i)
-          if (field_mask[i] == true)
-            {
-              x_comp[i] = std::min(std::max(x_comp[i], 0.0), 1.0);
-              sum_composition += x_comp[i];
-            }
-
-        // Compute background field fraction
-        if (sum_composition >= 1.0)
-          composition_fractions[0] = 0.0;
-        else
-          composition_fractions[0] = 1.0 - sum_composition;
-
-        // Compute and possibly normalize field fractions
-        for (unsigned int i=0; i < x_comp.size(); ++i)
-          if (field_mask[i] == true)
-            {
-              if (sum_composition >= 1.0)
-                composition_fractions[i+1] = x_comp[i]/sum_composition;
-              else
-                composition_fractions[i+1] = x_comp[i];
-            }
-
-        return composition_fractions;
-      }
-
-
-
-      std::vector<double>
-      compute_volume_fractions(const std::vector<double> &compositional_fields,
-                               const ComponentMask &field_mask)
-      {
-        return compute_composition_fractions(compositional_fields, field_mask);
-      }
-
-
-
-      std::vector<double>
-      compute_volumes_from_masses(const std::vector<double> &masses,
-                                  const std::vector<double> &densities,
-                                  const bool return_as_fraction)
-      {
-        Assert(masses.size() == densities.size(),
-               ExcMessage ("The mass fractions and densities vectors used for computing "
-                           "volumes from masses have to have the same length! "
-                           "You have provided "
-                           + Utilities::int_to_string(masses.size()) +
-                           " mass fractions and "
-                           + Utilities::int_to_string(densities.size()) +
-                           " densities."));
-
-        const unsigned int n_fields = masses.size();
-        std::vector<double> volumes(n_fields);
-
-        if (n_fields == 1 && return_as_fraction)
-          {
-            volumes[0] = 1.0;
-            return volumes;
-          }
-
-        double sum_volumes = 0.0;
-        for (unsigned int j=0; j < n_fields; ++j)
-          {
-            volumes[j] = masses[j] / densities[j];
-            sum_volumes += volumes[j];
-          }
-
-        if (return_as_fraction)
-          {
-            for (unsigned int j=0; j < n_fields; ++j)
-              volumes[j] /= sum_volumes;
-          }
-        return volumes;
-      }
-
-
-
-      CompositionalAveragingOperation
-      parse_compositional_averaging_operation (const std::string &parameter_name,
-                                               const ParameterHandler &prm)
-      {
-        CompositionalAveragingOperation averaging_operation;
-        if (prm.get (parameter_name) == "harmonic")
-          averaging_operation = MaterialUtilities::harmonic;
-        else if (prm.get (parameter_name) == "arithmetic")
-          averaging_operation = MaterialUtilities::arithmetic;
-        else if (prm.get (parameter_name) == "geometric")
-          averaging_operation = MaterialUtilities::geometric;
-        else if (prm.get (parameter_name) == "maximum composition")
-          averaging_operation = MaterialUtilities::maximum_composition;
-        else
-          {
-            AssertThrow(false, ExcMessage("Not a valid viscosity averaging scheme"));
-
-            //We will never get here, but we have to return something so the compiler does not complain
-            return MaterialUtilities::harmonic;
-          }
-
-        return averaging_operation;
-      }
-
-
-
-      double
-      average_value (const std::vector<double> &volume_fractions,
-                     const std::vector<double> &parameter_values,
-                     const enum CompositionalAveragingOperation &average_type)
-      {
-        Assert(volume_fractions.size() == parameter_values.size(),
-               ExcMessage ("The volume fractions and parameter values vectors used for averaging "
-                           "have to have the same length! You have provided "
-                           + Utilities::int_to_string(volume_fractions.size()) +
-                           " volume fractions and "
-                           + Utilities::int_to_string(parameter_values.size()) +
-                           " parameter values."));
-
-        double averaged_parameter = 0.0;
-
-        switch (average_type)
-          {
-            case arithmetic:
-            {
-              for (unsigned int i=0; i<volume_fractions.size(); ++i)
-                averaged_parameter += volume_fractions[i] * parameter_values[i];
-              break;
-            }
-            case harmonic:
-            {
-              for (unsigned int i=0; i<volume_fractions.size(); ++i)
-                {
-                  AssertThrow(parameter_values[i] > 0,
-                              ExcMessage ("All parameter values must be greater than 0 for harmonic averaging!"));
-                  averaged_parameter += volume_fractions[i]/(parameter_values[i]);
-                }
-              averaged_parameter = 1.0/averaged_parameter;
-              break;
-            }
-            case geometric:
-            {
-              for (unsigned int i=0; i<volume_fractions.size(); ++i)
-                {
-                  AssertThrow(parameter_values[i] > 0,
-                              ExcMessage ("All parameter values must be greater than 0 for geometric averaging!"));
-                  averaged_parameter += volume_fractions[i] * std::log(parameter_values[i]);
-                }
-              averaged_parameter = std::exp(averaged_parameter);
-              break;
-            }
-            case maximum_composition:
-            {
-              const unsigned int idx = static_cast<unsigned int>(std::max_element( volume_fractions.begin(),
-                                                                                   volume_fractions.end() )
-                                                                 - volume_fractions.begin());
-              averaged_parameter = parameter_values[idx];
-              break;
-            }
-            default:
-            {
-              AssertThrow(false, ExcNotImplemented());
-              break;
-            }
-          }
-        return averaged_parameter;
-      }
-
-
-
-      template <int dim>
-      void
-      fill_averaged_equation_of_state_outputs(const EquationOfStateOutputs<dim> &eos_outputs,
-                                              const std::vector<double> &mass_fractions,
-                                              const std::vector<double> &volume_fractions,
-                                              const unsigned int i,
-                                              MaterialModelOutputs<dim> &out)
-      {
-        // The density, isothermal compressibility and thermal expansivity are volume-averaged
-        // The specific entropy derivatives and heat capacity are mass-averaged
-        out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
-        out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
-        out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
-        out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
-        out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
-        out.specific_heat[i] = MaterialUtilities::average_value (mass_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
-      }
-
-
-
-      double phase_average_value (const std::vector<double> &phase_function_values,
-                                  const std::vector<unsigned int> &n_phase_transitions_per_composition,
-                                  const std::vector<double> &parameter_values,
-                                  const unsigned int composition_index,
-                                  const PhaseUtilities::PhaseAveragingOperation operation)
-      {
-        // Calculate base index and assign base value
-        unsigned int start_phase_index = 0;
-        for (unsigned int i=0; i<composition_index; ++i)
-          start_phase_index += n_phase_transitions_per_composition[i] + 1;
-
-        double averaged_parameter = parameter_values[start_phase_index];
-        if (n_phase_transitions_per_composition[composition_index] > 0)
-          {
-            // Do averaging when there are multiple phases
-            if (operation == PhaseUtilities::logarithmic)
-              averaged_parameter = log(averaged_parameter);
-
-            for (unsigned int i=0; i<n_phase_transitions_per_composition[composition_index]; ++i)
-              {
-                const unsigned int phase_index = start_phase_index + i;
-
-                Assert(phase_index+1<parameter_values.size(), ExcInternalError());
-                if (operation == PhaseUtilities::logarithmic)
-                  {
-                    // First average by log values and then take the exponential.
-                    // This is used for averaging prefactors in flow laws.
-                    averaged_parameter += phase_function_values[phase_index-composition_index] * (std::log(parameter_values[phase_index+1]) - averaged_parameter);
-                  }
-                else if (operation == PhaseUtilities::arithmetic)
-                  averaged_parameter += phase_function_values[phase_index-composition_index] * (parameter_values[phase_index+1] - averaged_parameter);
-
-                else
-                  AssertThrow(false, ExcInternalError());
-              }
-            if (operation == PhaseUtilities::logarithmic)
-              averaged_parameter = exp(averaged_parameter);
-          }
-        return averaged_parameter;
-      }
-
-      template <int dim>
-      PhaseFunctionInputs<dim>::PhaseFunctionInputs(const double temperature_,
-                                                    const double pressure_,
-                                                    const double depth_,
-                                                    const double pressure_depth_derivative_,
-                                                    const unsigned int phase_index_)
-
-        :
-        temperature(temperature_),
-        pressure(pressure_),
-        depth(depth_),
-        pressure_depth_derivative(pressure_depth_derivative_),
-        phase_index(phase_index_)
-      {}
-
-
-
-      template <int dim>
-      double
-      PhaseFunction<dim>::compute_value (const PhaseFunctionInputs<dim> &in) const
-      {
-        AssertIndexRange (in.phase_index, transition_temperature_lower_limits.size());
-        AssertIndexRange (in.phase_index, transition_temperature_upper_limits.size());
-
-        // the percentage of material that has undergone the transition
-        double function_value;
-        if (in.temperature < transition_temperature_lower_limits[in.phase_index] ||
-            in.temperature >= transition_temperature_upper_limits[in.phase_index])
-          {
-            // assign 0.0 if temperature is out of range
-            function_value = 0.0;
-          }
-        else
-          {
-            if (use_depth_instead_of_pressure)
-              {
-                AssertIndexRange (in.phase_index, transition_depths.size());
-
-                // calculate the deviation from the transition point (convert temperature to depth)
-                double depth_deviation = in.depth - transition_depths[in.phase_index];
-
-                if (in.pressure_depth_derivative != 0.0)
-                  {
-                    AssertIndexRange (in.phase_index, transition_slopes.size());
-                    AssertIndexRange (in.phase_index, transition_temperatures.size());
-
-                    depth_deviation -= transition_slopes[in.phase_index] / in.pressure_depth_derivative
-                                       * (in.temperature - transition_temperatures[in.phase_index]);
-                  }
-
-                // use delta function for width = 0
-                AssertIndexRange (in.phase_index, transition_widths.size());
-                if (transition_widths[in.phase_index] == 0)
-                  function_value = (depth_deviation > 0) ? 1. : 0.;
-                else
-                  function_value = 0.5*(1.0 + std::tanh(depth_deviation / transition_widths[in.phase_index]));
-              }
-            else
-              {
-                // calculate the deviation from the transition point (convert temperature to pressure)
-                AssertIndexRange (in.phase_index, transition_pressures.size());
-                const double pressure_deviation = in.pressure - transition_pressures[in.phase_index]
-                                                  - transition_slopes[in.phase_index] * (in.temperature - transition_temperatures[in.phase_index]);
-
-                // use delta function for width = 0
-                AssertIndexRange (in.phase_index, transition_pressure_widths.size());
-                if (transition_pressure_widths[in.phase_index] == 0)
-                  function_value = (pressure_deviation > 0) ? 1. : 0.;
-                else
-                  function_value = 0.5*(1.0 + std::tanh(pressure_deviation / transition_pressure_widths[in.phase_index]));
-              }
-          }
-
-        return function_value;
-      }
-
-
-
-      template <int dim>
-      double
-      PhaseFunction<dim>::compute_derivative (const PhaseFunctionInputs<dim> &in) const
-      {
-        double transition_pressure;
-        double pressure_width;
-        double width_temp;
-
-        // we already should have the adiabatic conditions here
-        Assert (this->get_adiabatic_conditions().is_initialized(),
-                ExcMessage("The adiabatic conditions need to be already initialized "
-                           "to calculate the derivative of phase functions. Either call this "
-                           "function after the reference conditions have been computed, or implement "
-                           "a workaround for the case without reference profile."));
-
-        // phase transition based on depth
-        if (use_depth_instead_of_pressure)
-          {
-            const Point<dim,double> transition_point = this->get_geometry_model().representative_point(transition_depths[in.phase_index]);
-            const Point<dim,double> transition_plus_width = this->get_geometry_model().representative_point(transition_depths[in.phase_index] + transition_widths[in.phase_index]);
-            const Point<dim,double> transition_minus_width = this->get_geometry_model().representative_point(transition_depths[in.phase_index] - transition_widths[in.phase_index]);
-            transition_pressure = this->get_adiabatic_conditions().pressure(transition_point);
-            pressure_width = 0.5 * (this->get_adiabatic_conditions().pressure(transition_plus_width)
-                                    - this->get_adiabatic_conditions().pressure(transition_minus_width));
-            width_temp = transition_widths[in.phase_index];
-          }
-        // using pressure instead of depth to define the phase transition
-        else
-          {
-            transition_pressure = transition_pressures[in.phase_index];
-            pressure_width = transition_pressure_widths[in.phase_index];
-            width_temp = transition_pressure_widths[in.phase_index];
-          }
-
-        // calculate the deviation from the transition point
-        const double pressure_deviation = in.pressure - transition_pressure
-                                          - transition_slopes[in.phase_index] * (in.temperature - transition_temperatures[in.phase_index]);
-
-        // calculate the analytical derivative of the phase function
-        if (
-          (in.temperature < transition_temperature_lower_limits[in.phase_index]) ||
-          (in.temperature >= transition_temperature_upper_limits[in.phase_index])
-        )
-          {
-            // return 0 if temperature is out of range
-            return 0;
-          }
-        else if (width_temp == 0)
-          return 0;
-        else
-          return 0.5 / pressure_width * (1.0 - std::tanh(pressure_deviation / pressure_width)
-                                         * std::tanh(pressure_deviation / pressure_width));
-      }
-
-
-
-      template <int dim>
-      unsigned int
-      PhaseFunction<dim>::
-      n_phase_transitions () const
-      {
-        if (use_depth_instead_of_pressure)
-          return transition_depths.size();
-        else
-          return transition_pressures.size();
-      }
-
-      template <int dim>
-      unsigned int
-      PhaseFunction<dim>::
-      n_phases () const
-      {
-        return n_phases_total;
-      }
-
-      template <int dim>
-      const std::vector<unsigned int> &
-      PhaseFunction<dim>::n_phase_transitions_for_each_composition () const
-      {
-        return *n_phase_transitions_per_composition;
-      }
-
-      template <int dim>
-      const std::vector<unsigned int> &
-      PhaseFunction<dim>::n_phases_for_each_composition () const
-      {
-        return n_phases_per_composition;
-      }
-
-
-
-      template <int dim>
-      double
-      PhaseFunction<dim>::
-      get_transition_slope (const unsigned int phase_index) const
-      {
-        return transition_slopes[phase_index];
-      }
-
-
-
-      template <int dim>
-      double
-      PhaseFunction<dim>::
-      get_transition_depth (const unsigned int phase_index) const
-      {
-        return transition_depths[phase_index];
-      }
-
-
-
-      template <int dim>
-      void
-      PhaseFunction<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Phase transition depths", "",
-                           Patterns::Anything(),
-                           "A list of depths where phase transitions occur. Values must "
-                           "monotonically increase. "
-                           "Units: \\si{\\meter}.");
-        prm.declare_entry ("Phase transition widths", "",
-                           Patterns::Anything(),
-                           "A list of widths for each phase transition, in terms of depth. The phase functions "
-                           "are scaled with these values, leading to a jump between phases "
-                           "for a value of zero and a gradual transition for larger values. "
-                           "List must have the same number of entries as Phase transition depths. "
-                           "Units: \\si{\\meter}.");
-        prm.declare_entry ("Phase transition pressures", "",
-                           Patterns::Anything(),
-                           "A list of pressures where phase transitions occur. Values must "
-                           "monotonically increase. Define transition by depth instead of "
-                           "pressure must be set to false to use this parameter. "
-                           "Units: \\si{\\pascal}.");
-        prm.declare_entry ("Phase transition pressure widths", "",
-                           Patterns::Anything(),
-                           "A list of widths for each phase transition, in terms of pressure. The phase functions "
-                           "are scaled with these values, leading to a jump between phases "
-                           "for a value of zero and a gradual transition for larger values. "
-                           "List must have the same number of entries as Phase transition pressures. "
-                           "Define transition by depth instead of pressure must be set to false "
-                           "to use this parameter. "
-                           "Units: \\si{\\pascal}.");
-        prm.declare_entry ("Define transition by depth instead of pressure", "true",
-                           Patterns::Bool (),
-                           "Whether to list phase transitions by depth or pressure. If this parameter is true, "
-                           "then the input file will use Phase transitions depths and Phase transition widths "
-                           "to define the phase transition. If it is false, the parameter file will read in "
-                           "phase transition data from Phase transition pressures and "
-                           "Phase transition pressure widths.");
-        prm.declare_entry ("Phase transition temperatures", "",
-                           Patterns::Anything(),
-                           "A list of temperatures where phase transitions occur. Higher or lower "
-                           "temperatures lead to phase transition occurring in smaller or greater "
-                           "depths than given in Phase transition depths, depending on the "
-                           "Clapeyron slope given in Phase transition Clapeyron slopes. "
-                           "List must have the same number of entries as Phase transition depths. "
-                           "Units: \\si{\\kelvin}.");
-        prm.declare_entry ("Phase transition temperature upper limits",
-                           boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
-                           Patterns::Anything(),
-                           "A list of upper temperature limits for each phase transition. Above "
-                           "this temperature the respective phase transition is deactivated. The default "
-                           "value means there is no upper limit for any phase transitions. "
-                           "List must have the same number of entries as Phase transition depths. "
-                           "When the optional temperature limits are applied, the user has to be "
-                           "careful about the consistency between adjacent phases. Phase transitions "
-                           "should be continuous in pressure-temperature space. "
-                           "We recommend producing a phase diagram with "
-                           "simple model setups to check the implementation as a starting point."
-                           "Units: \\si{\\kelvin}.");
-        prm.declare_entry ("Phase transition temperature lower limits",
-                           boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
-                           Patterns::Anything(),
-                           "A list of lower temperature limits for each phase transition. Below "
-                           "this temperature the respective phase transition is deactivated. The default "
-                           "value means there is no lower limit for any phase transition. "
-                           "List must have the same number of entries as Phase transition depths. "
-                           "When the optional temperature limits are applied, the user has to be "
-                           "careful about the consistency between adjacent phases. Phase transitions "
-                           "should be continuous in pressure-temperature space. "
-                           "We recommend producing a phase diagram with "
-                           "simple model setups to check the implementation as a starting point."
-                           "Units: \\si{\\kelvin}.");
-        prm.declare_entry ("Phase transition Clapeyron slopes", "",
-                           Patterns::Anything(),
-                           "A list of Clapeyron slopes for each phase transition. A positive "
-                           "Clapeyron slope indicates that the phase transition will occur in "
-                           "a greater depth, if the temperature is higher than the one given in "
-                           "Phase transition temperatures and in a smaller depth, if the "
-                           "temperature is smaller than the one given in Phase transition temperatures. "
-                           "For negative slopes the other way round. "
-                           "List must have the same number of entries as Phase transition depths. "
-                           "Units: \\si{\\pascal\\per\\kelvin}.");
-      }
-
-
-
-      template <int dim>
-      void
-      PhaseFunction<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        // Establish that a background field is required here
-        const bool has_background_field = true;
-
-        // Retrieve the list of composition names
-        const std::vector<std::string> list_of_composition_names = this->introspection().get_composition_names();
-
-        n_phase_transitions_per_composition = std::make_unique<std::vector<unsigned int>>();
-
-        use_depth_instead_of_pressure = prm.get_bool ("Define transition by depth instead of pressure");
-
-        if (use_depth_instead_of_pressure)
-          {
-            transition_depths          = Utilities::parse_map_to_double_array (prm.get("Phase transition depths"),
-                                                                               list_of_composition_names,
-                                                                               has_background_field,
-                                                                               "Phase transition depths",
-                                                                               true,
-                                                                               n_phase_transitions_per_composition,
-                                                                               true);
-
-            transition_widths          = Utilities::parse_map_to_double_array (prm.get("Phase transition widths"),
-                                                                               list_of_composition_names,
-                                                                               has_background_field,
-                                                                               "Phase transition widths",
-                                                                               true,
-                                                                               n_phase_transitions_per_composition,
-                                                                               true);
-          }
-        else
-          {
-            transition_pressures = Utilities::parse_map_to_double_array (prm.get("Phase transition pressures"),
-                                                                         list_of_composition_names,
-                                                                         has_background_field,
-                                                                         "Phase transition pressures",
-                                                                         true,
-                                                                         n_phase_transitions_per_composition,
-                                                                         true);
-
-            transition_pressure_widths = Utilities::parse_map_to_double_array (prm.get("Phase transition pressure widths"),
-                                                                               list_of_composition_names,
-                                                                               has_background_field,
-                                                                               "Phase transition pressure widths",
-                                                                               true,
-                                                                               n_phase_transitions_per_composition,
-                                                                               true);
-          }
-
-        transition_temperatures = Utilities::parse_map_to_double_array (prm.get("Phase transition temperatures"),
-                                                                        list_of_composition_names,
-                                                                        has_background_field,
-                                                                        "Phase transition temperatures",
-                                                                        true,
-                                                                        n_phase_transitions_per_composition,
-                                                                        true);
-
-        transition_temperature_upper_limits = Utilities::parse_map_to_double_array (prm.get("Phase transition temperature upper limits"),
-                                                                                    list_of_composition_names,
-                                                                                    has_background_field,
-                                                                                    "Phase transition temperature upper limits",
-                                                                                    true,
-                                                                                    n_phase_transitions_per_composition,
-                                                                                    true);
-
-        transition_temperature_lower_limits = Utilities::parse_map_to_double_array (prm.get("Phase transition temperature lower limits"),
-                                                                                    list_of_composition_names,
-                                                                                    has_background_field,
-                                                                                    "Phase transition temperature lower limits",
-                                                                                    true,
-                                                                                    n_phase_transitions_per_composition,
-                                                                                    true);
-
-        transition_slopes = Utilities::parse_map_to_double_array (prm.get("Phase transition Clapeyron slopes"),
-                                                                  list_of_composition_names,
-                                                                  has_background_field,
-                                                                  "Phase transition Clapeyron slopes",
-                                                                  true,
-                                                                  n_phase_transitions_per_composition,
-                                                                  true);
-
-        n_phases_total = 0;
-        n_phases_per_composition.clear();
-        for (unsigned int n : *n_phase_transitions_per_composition)
-          {
-            n_phases_per_composition.push_back(n+1);
-            n_phases_total += n+1;
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    namespace MaterialUtilities
-    {
-#define INSTANTIATE(dim) \
-  template void fill_averaged_equation_of_state_outputs<dim> (const EquationOfStateOutputs<dim> &, \
-                                                              const std::vector<double> &, \
-                                                              const std::vector<double> &, \
-                                                              const unsigned int, \
-                                                              MaterialModelOutputs<dim> &); \
-  template struct PhaseFunctionInputs<dim>; \
-  template class PhaseFunction<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/source/material_model/visco_plastic.cc.bak b/source/material_model/visco_plastic.cc.bak
deleted file mode 100644
index cef81e360e1..00000000000
--- a/source/material_model/visco_plastic.cc.bak
+++ /dev/null
@@ -1,678 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/visco_plastic.h>
-#include <aspect/utilities.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/signaling_nan.h>
-#include <aspect/newton.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/gravity_model/interface.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    bool
-    ViscoPlastic<dim>::
-    is_yielding (const double pressure,
-                 const double temperature,
-                 const std::vector<double> &composition,
-                 const SymmetricTensor<2,dim> &strain_rate) const
-    {
-      /* The following returns whether or not the material is plastically yielding
-       * as documented in evaluate.
-       */
-      bool plastic_yielding = false;
-
-      MaterialModel::MaterialModelInputs <dim> in (/*n_evaluation_points=*/1,
-                                                                           this->n_compositional_fields());
-      unsigned int i = 0;
-
-      in.pressure[i] = pressure;
-      in.temperature[i] = temperature;
-      in.composition[i] = composition;
-      in.strain_rate[i] = strain_rate;
-
-      const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(composition,
-                                                   this->introspection().chemical_composition_field_indices());
-
-      const IsostrainViscosities isostrain_viscosities
-        = rheology->calculate_isostrain_viscosities(in, i, volume_fractions);
-
-      std::vector<double>::const_iterator max_composition
-        = std::max_element(volume_fractions.begin(),volume_fractions.end());
-
-      plastic_yielding = isostrain_viscosities.composition_yielding[std::distance(volume_fractions.begin(),
-                                                                                  max_composition)];
-
-      return plastic_yielding;
-    }
-
-
-
-    template <int dim>
-    bool
-    ViscoPlastic<dim>::
-    is_yielding(const MaterialModelInputs<dim> &in) const
-    {
-      Assert(in.n_evaluation_points() == 1, ExcInternalError());
-
-      const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[0],
-                                                   this->introspection().chemical_composition_field_indices());
-
-      /* The following handles phases in a similar way as in the 'evaluate' function.
-       * Results then enter the calculation of plastic yielding.
-       */
-      std::vector<double> phase_function_values(phase_function.n_phase_transitions(), 0.0);
-
-      if (phase_function.n_phase_transitions() > 0)
-        {
-          const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[0]).norm();
-
-          double reference_density;
-          if (this->get_adiabatic_conditions().is_initialized())
-            {
-              reference_density = this->get_adiabatic_conditions().density(in.position[0]);
-            }
-          else
-            {
-              EquationOfStateOutputs<dim> eos_outputs_all_phases (n_phases);
-              equation_of_state.evaluate(in, 0, eos_outputs_all_phases);
-              reference_density = eos_outputs_all_phases.densities[0];
-            }
-
-          MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature[0],
-                                                                   in.pressure[0],
-                                                                   this->get_geometry_model().depth(in.position[0]),
-                                                                   gravity_norm*reference_density,
-                                                                   numbers::invalid_unsigned_int);
-
-          for (unsigned int j=0; j < phase_function.n_phase_transitions(); ++j)
-            {
-              phase_inputs.phase_index = j;
-              phase_function_values[j] = phase_function.compute_value(phase_inputs);
-            }
-        }
-
-      /* The following returns whether or not the material is plastically yielding
-       * as documented in evaluate.
-       */
-      const IsostrainViscosities isostrain_viscosities = rheology->calculate_isostrain_viscosities(in, 0, volume_fractions, phase_function_values, phase_function.n_phase_transitions_for_each_composition());
-
-      std::vector<double>::const_iterator max_composition = std::max_element(volume_fractions.begin(), volume_fractions.end());
-      const bool plastic_yielding = isostrain_viscosities.composition_yielding[std::distance(volume_fractions.begin(), max_composition)];
-
-      return plastic_yielding;
-    }
-
-
-
-    template <int dim>
-    void
-    ViscoPlastic<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      EquationOfStateOutputs<dim> eos_outputs (this->introspection().get_number_of_fields_of_type(CompositionalFieldDescription::chemical_composition)+1);
-      EquationOfStateOutputs<dim> eos_outputs_all_phases (n_phases);
-
-      std::vector<double> average_elastic_shear_moduli (in.n_evaluation_points());
-
-      // Store value of phase function for each phase and composition
-      // While the number of phases is fixed, the value of the phase function is updated for every point
-      std::vector<double> phase_function_values(phase_function.n_phase_transitions(), 0.0);
-
-      // Loop through all requested points
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          // First compute the equation of state variables and thermodynamic properties
-          equation_of_state.evaluate(in, i, eos_outputs_all_phases);
-
-          const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[i]).norm();
-          const double reference_density = (this->get_adiabatic_conditions().is_initialized())
-                                           ?
-                                           this->get_adiabatic_conditions().density(in.position[i])
-                                           :
-                                           eos_outputs_all_phases.densities[0];
-
-          // The phase index is set to invalid_unsigned_int, because it is only used internally
-          // in phase_average_equation_of_state_outputs to loop over all existing phases
-          MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature[i],
-                                                                   in.pressure[i],
-                                                                   this->get_geometry_model().depth(in.position[i]),
-                                                                   gravity_norm*reference_density,
-                                                                   numbers::invalid_unsigned_int);
-
-          // Compute value of phase functions
-          for (unsigned int j=0; j < phase_function.n_phase_transitions(); ++j)
-            {
-              phase_inputs.phase_index = j;
-              phase_function_values[j] = phase_function.compute_value(phase_inputs);
-            }
-
-          // Average by value of gamma function to get value of compositions
-          phase_average_equation_of_state_outputs(eos_outputs_all_phases,
-                                                  phase_function_values,
-                                                  n_phase_transitions_for_each_chemical_composition,
-                                                  eos_outputs);
-
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(in.composition[i],
-                                                       this->introspection().chemical_composition_field_indices());
-
-          // not strictly correct if thermal expansivities are different, since we are interpreting
-          // these compositions as volume fractions, but the error introduced should not be too bad.
-          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
-          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
-          out.specific_heat[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
-
-          if (define_conductivities == false)
-            {
-              double thermal_diffusivity = 0.0;
-
-              for (unsigned int j=0; j < volume_fractions.size(); ++j)
-                thermal_diffusivity += volume_fractions[j] * thermal_diffusivities[j];
-
-              // Thermal conductivity at the given positions. If the temperature equation uses
-              // the reference density profile formulation, use the reference density to
-              // calculate thermal conductivity. Otherwise, use the real density. If the adiabatic
-              // conditions are not yet initialized, the real density will still be used.
-              if (this->get_parameters().formulation_temperature_equation ==
-                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile &&
-                  this->get_adiabatic_conditions().is_initialized())
-                out.thermal_conductivities[i] = thermal_diffusivity * out.specific_heat[i] *
-                                                this->get_adiabatic_conditions().density(in.position[i]);
-              else
-                out.thermal_conductivities[i] = thermal_diffusivity * out.specific_heat[i] * out.densities[i];
-            }
-          else
-            {
-              // Use thermal conductivity values specified in the parameter file, if this
-              // option was selected.
-              out.thermal_conductivities[i] = MaterialUtilities::average_value (volume_fractions, thermal_conductivities, MaterialUtilities::arithmetic);
-            }
-
-          out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
-          out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
-          out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
-
-          // Compute the effective viscosity if requested and retrieve whether the material is plastically yielding.
-          // Also always compute the viscosity if additional outputs are requested, because the viscosity is needed
-          // to compute the elastic force term.
-          bool plastic_yielding = false;
-          IsostrainViscosities isostrain_viscosities;
-          if (in.requests_property(MaterialProperties::viscosity) || in.requests_property(MaterialProperties::additional_outputs))
-            {
-              // Currently, the viscosities for each of the compositional fields are calculated assuming
-              // isostrain amongst all compositions, allowing calculation of the viscosity ratio.
-              // TODO: This is only consistent with viscosity averaging if the arithmetic averaging
-              // scheme is chosen. It would be useful to have a function to calculate isostress viscosities.
-              isostrain_viscosities =
-                rheology->calculate_isostrain_viscosities(in, i, volume_fractions, phase_function_values, n_phase_transitions_for_each_chemical_composition);
-
-              // The isostrain condition implies that the viscosity averaging should be arithmetic (see above).
-              // We have given the user freedom to apply alternative bounds, because in diffusion-dominated
-              // creep (where n_diff=1) viscosities are stress and strain-rate independent, so the calculation
-              // of compositional field viscosities is consistent with any averaging scheme.
-              out.viscosities[i] = MaterialUtilities::average_value(volume_fractions, isostrain_viscosities.composition_viscosities, rheology->viscosity_averaging);
-
-              // Decide based on the maximum composition if material is yielding.
-              // This avoids for example division by zero for harmonic averaging (as plastic_yielding
-              // holds values that are either 0 or 1), but might not be consistent with the viscosity
-              // averaging chosen.
-              std::vector<double>::const_iterator max_composition = std::max_element(volume_fractions.begin(), volume_fractions.end());
-              plastic_yielding = isostrain_viscosities.composition_yielding[std::distance(volume_fractions.begin(), max_composition)];
-
-              // Compute viscosity derivatives if they are requested
-              if (MaterialModel::MaterialModelDerivatives<dim> *derivatives =
-                    out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>())
-
-                rheology->compute_viscosity_derivatives(i, volume_fractions,
-                                                        isostrain_viscosities.composition_viscosities,
-                                                        in, out, phase_function_values,
-                                                        n_phase_transitions_for_each_chemical_composition);
-            }
-          else
-            {
-              // The viscosity was not requested. Poison its value, along with the other
-              // quantities we set above and that would otherwise remain uninitialized
-              isostrain_viscosities.composition_yielding.clear();
-              isostrain_viscosities.composition_viscosities.clear();
-              isostrain_viscosities.current_friction_angles.clear();
-              isostrain_viscosities.current_cohesions.clear();
-
-              out.viscosities[i] = numbers::signaling_nan<double>();
-
-              if (MaterialModel::MaterialModelDerivatives<dim> *derivatives =
-                    out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>())
-                {
-                  derivatives->viscosity_derivative_wrt_strain_rate[i] = numbers::signaling_nan<SymmetricTensor<2,dim>>();
-                  derivatives->viscosity_derivative_wrt_pressure[i] = numbers::signaling_nan<double>();
-                }
-            }
-
-          // Now compute changes in the compositional fields (i.e. the accumulated strain).
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-
-          // Calculate changes in strain invariants and update the reaction terms
-          rheology->strain_rheology.fill_reaction_outputs(in, i, rheology->min_strain_rate, plastic_yielding, out);
-
-          // Fill plastic outputs if they exist.
-          // The values in isostrain_viscosities only make sense when the calculate_isostrain_viscosities function
-          // has been called.
-          // TODO do we even need a separate function? We could compute the PlasticAdditionalOutputs here like
-          // the ElasticAdditionalOutputs.
-          rheology->fill_plastic_outputs(i, volume_fractions, plastic_yielding, in, out, isostrain_viscosities);
-
-          if (this->get_parameters().enable_elasticity)
-            {
-              // Compute average elastic shear modulus
-              average_elastic_shear_moduli[i] = MaterialUtilities::average_value(volume_fractions,
-                                                                                 rheology->elastic_rheology.get_elastic_shear_moduli(),
-                                                                                 rheology->viscosity_averaging);
-
-              // Fill the material properties that are part of the elastic additional outputs
-              if (ElasticAdditionalOutputs<dim> *elastic_out = out.template get_additional_output<ElasticAdditionalOutputs<dim>>())
-                {
-                  elastic_out->elastic_shear_moduli[i] = average_elastic_shear_moduli[i];
-                }
-            }
-        }
-
-      // If we use the full strain tensor, compute the change in the individual tensor components.
-      rheology->strain_rheology.compute_finite_strain_reaction_terms(in, out);
-
-      if (this->get_parameters().enable_elasticity)
-        {
-          rheology->elastic_rheology.fill_elastic_outputs(in, average_elastic_shear_moduli, out);
-          rheology->elastic_rheology.fill_reaction_outputs(in, average_elastic_shear_moduli, out);
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    ViscoPlastic<dim>::
-    is_compressible () const
-    {
-      return equation_of_state.is_compressible();
-    }
-
-
-
-    template <int dim>
-    double ViscoPlastic<dim>::
-    get_min_strain_rate () const
-    {
-      return rheology->min_strain_rate;
-    }
-
-
-
-    template <int dim>
-    void
-    ViscoPlastic<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Visco Plastic");
-        {
-          MaterialUtilities::PhaseFunction<dim>::declare_parameters(prm);
-
-          EquationOfState::MulticomponentIncompressible<dim>::declare_parameters (prm);
-
-          Rheology::ViscoPlastic<dim>::declare_parameters(prm);
-
-          // Equation of state parameters
-          prm.declare_entry ("Thermal diffusivities", "0.8e-6",
-                             Patterns::List(Patterns::Double (0.)),
-                             "List of thermal diffusivities, for background material and compositional fields, "
-                             "for a total of N+1 values, where N is the number of all compositional fields or only "
-                             "those corresponding to chemical compositions. "
-                             "If only one value is given, then all use the same value.  "
-                             "Units: \\si{\\meter\\squared\\per\\second}.");
-          prm.declare_entry ("Define thermal conductivities","false",
-                             Patterns::Bool (),
-                             "Whether to directly define thermal conductivities for each compositional field "
-                             "instead of calculating the values through the specified thermal diffusivities, "
-                             "densities, and heat capacities. ");
-          prm.declare_entry ("Thermal conductivities", "3.0",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of thermal conductivities, for background material and compositional fields, "
-                             "for a total of N+1 values, where N is the number of all compositional fields or only "
-                             "those corresponding to chemical compositions. "
-                             "If only one value is given, then all use the same value. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ViscoPlastic<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Visco Plastic");
-        {
-          // Phase transition parameters
-          phase_function.initialize_simulator (this->get_simulator());
-          phase_function.parse_parameters (prm);
-
-          std::vector<unsigned int> n_phases_for_each_composition = phase_function.n_phases_for_each_composition();
-
-          // Currently, phase_function.n_phases_for_each_composition() returns a list of length
-          // equal to the total number of compositions, whether or not they are chemical compositions.
-          // The equation_of_state (multicomponent incompressible) requires a list only for
-          // chemical compositions.
-          std::vector<unsigned int> n_phases_for_each_chemical_composition = {n_phases_for_each_composition[0]};
-          n_phase_transitions_for_each_chemical_composition = {n_phases_for_each_composition[0] - 1};
-          n_phases = n_phases_for_each_composition[0];
-          for (auto i : this->introspection().chemical_composition_field_indices())
-            {
-              n_phases_for_each_chemical_composition.push_back(n_phases_for_each_composition[i+1]);
-              n_phase_transitions_for_each_chemical_composition.push_back(n_phases_for_each_composition[i+1] - 1);
-              n_phases += n_phases_for_each_composition[i+1];
-            }
-
-          // Equation of state parameters
-          equation_of_state.initialize_simulator (this->get_simulator());
-          equation_of_state.parse_parameters (prm,
-                                              std::make_unique<std::vector<unsigned int>>(n_phases_for_each_chemical_composition));
-
-          // Make options file for parsing maps to double arrays
-          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-          chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-          compositional_field_names.insert(compositional_field_names.begin(),"background");
-
-          Utilities::MapParsing::Options options(chemical_field_names, "Thermal diffusivities");
-          options.list_of_allowed_keys = compositional_field_names;
-          options.allow_multiple_values_per_key = true;
-          options.n_values_per_key = n_phases_for_each_chemical_composition;
-          options.check_values_per_key = (options.n_values_per_key.size() != 0);
-          options.store_values_per_key = (options.n_values_per_key.size() == 0);
-
-          thermal_diffusivities = Utilities::MapParsing::parse_map_to_double_array(prm.get("Thermal diffusivities"), options);
-          define_conductivities = prm.get_bool ("Define thermal conductivities");
-
-          options.property_name = "Thermal conductivities";
-          thermal_conductivities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Thermal conductivities"), options);
-
-          rheology = std::make_unique<Rheology::ViscoPlastic<dim>>();
-          rheology->initialize_simulator (this->get_simulator());
-          rheology->parse_parameters(prm, std::make_unique<std::vector<unsigned int>>(n_phases_for_each_chemical_composition));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-    }
-
-
-
-    template <int dim>
-    void
-    ViscoPlastic<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      rheology->create_plastic_outputs(out);
-
-      if (this->get_parameters().enable_elasticity)
-        rheology->elastic_rheology.create_elastic_outputs(out);
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ViscoPlastic,
-                                   "visco plastic",
-                                   "An implementation of an incompressible visco(elastic)-plastic rheology "
-                                   "with options for selecting dislocation creep, diffusion creep or "
-                                   "composite viscous flow laws. Prior to yielding, one may select to "
-                                   "modify the viscosity to account for viscoelastic effects by setting the "
-                                   "parameter 'Enable elasticity' in subsection Formulation to true. Plasticity "
-                                   "limits viscous stresses through a Drucker Prager yield criterion. "
-                                   "The implementation of this material model is based heavily on the "
-                                   "`DiffusionDislocation' (Bob Myhill), `DruckerPrager' "
-                                   "(Anne Glerum), and `Viscoelastic' (John Naliboff) material models. "
-                                   "\n\n "
-                                   "The viscosity for dislocation or diffusion creep is defined as "
-                                   "$ \\eta = \\frac 12 A^{-\\frac{1}{n}} d^{\\frac{m}{n}} "
-                                   "\\dot{\\varepsilon}_{ii}^{\\frac{1-n}{n}} "
-                                   "\\exp\\left(\\frac{E + PV}{nRT}\\right)$ "
-                                   "where $A$ is the prefactor, $n$ is the stress exponent, "
-                                   "$\\dot{\\varepsilon}_{ii}$ is the square root of the deviatoric "
-                                   "strain rate tensor second invariant, $d$ is grain size, "
-                                   "$m$ is the grain size exponent, $E$ is activation energy, "
-                                   "$V$ is activation volume, $P$ is pressure, $R$ is the gas "
-                                   "exponent and $T$ is temperature. "
-                                   "This form of the viscosity equation is commonly used in "
-                                   "geodynamic simulations. See, for example, Billen and Hirth "
-                                   "(2007), G3, 8, Q08012. Significantly, other studies may use "
-                                   "slightly different forms of the viscosity equation leading to "
-                                   "variations in how specific terms are defined or combined. For "
-                                   "example, the grain size exponent should always be positive in "
-                                   "the diffusion viscosity equation used here, while other studies "
-                                   "place the grain size term in the denominator and invert the sign "
-                                   "of the grain size exponent. When examining previous work, one "
-                                   "should carefully check how the viscous prefactor and grain size "
-                                   "terms are defined. "
-                                   "\n\n "
-                                   "One may select to use the diffusion ($\\eta_{\\text{diff}}$; $n=1$, $m\\neq 0$), "
-                                   "dislocation ($\\eta_{\\text{disl}}$, $n>1$, $m=0$) or composite "
-                                   "$\\frac{\\eta_{\\text{diff}} \\eta_{\\text{disl}}}{\\eta_{\\text{diff}}+\\eta_{\\text{disl}}}$ equation form. "
-                                   "\n\n "
-                                   "The diffusion and dislocation prefactors can be weakened with a factor "
-                                   "between 0 and 1 according to the total or the viscous strain only. "
-                                   "\n\n "
-                                   "Viscosity is limited through one of two different `yielding' mechanisms. "
-                                   "\n\n"
-                                   "The first plasticity mechanism limits viscous stress through a "
-                                   "Drucker Prager yield criterion, where the yield stress in 3d is  "
-                                   "$\\sigma_y = \\frac{6C\\cos(\\phi) + 2P\\sin(\\phi)} "
-                                   "{\\sqrt{3}(3+\\sin(\\phi))}$ "
-                                   "and "
-                                   "$\\sigma_y = C\\cos(\\phi) + P\\sin(\\phi)$ "
-                                   "in 2d. Above, $C$ is cohesion and $\\phi$  is the angle of "
-                                   "internal friction.  Note that the 2d form is equivalent to the "
-                                   "Mohr Coulomb yield surface.  If $\\phi$ is 0, the yield stress "
-                                   "is fixed and equal to the cohesion (Von Mises yield criterion). "
-                                   "When the viscous stress ($2\\eta {\\varepsilon}_{ii}$) exceeds "
-                                   "the yield stress, the viscosity is rescaled back to the yield "
-                                   "surface: $\\eta_{y}=\\sigma_{y}/(2{\\varepsilon}_{ii})$. "
-                                   "This form of plasticity is commonly used in geodynamic models. "
-                                   "See, for example, Thieulot, C. (2011), PEPI 188, pp. 47-68. "
-                                   "\n\n"
-                                   "The user has the option to linearly reduce the cohesion and "
-                                   "internal friction angle as a function of the finite strain magnitude. "
-                                   "The finite strain invariant or full strain tensor is calculated through "
-                                   "compositional fields within the material model. This implementation is "
-                                   "identical to the compositional field finite strain plugin and cookbook "
-                                   "described in the manual (author: Gassmoeller, Dannberg). If the user selects to track "
-                                   "the finite strain invariant ($e_{ii}$), a single compositional field tracks "
-                                   "the value derived from $e_{ii}^t = (e_{ii})^{(t-1)} + \\dot{e}_{ii}\\; dt$, where $t$ and $t-1$ "
-                                   "are the current and prior time steps, $\\dot{e}_{ii}$ is the second invariant of the "
-                                   "strain rate tensor and $dt$ is the time step size. In the case of the "
-                                   "full strain tensor $F$, the finite strain magnitude is derived from the "
-                                   "second invariant of the symmetric stretching tensor $L$, where "
-                                   "$L = F [F]^T$. The user must specify a single compositional "
-                                   "field for the finite strain invariant or multiple fields (4 in 2d, 9 in 3d) "
-                                   "for the finite strain tensor. These field(s) must be the first listed "
-                                   "compositional fields in the parameter file. Note that one or more of the finite strain "
-                                   "tensor components must be assigned a non-zero value initially. This value can be "
-                                   "be quite small (e.g., 1.e-8), but still non-zero. While the option to track and use "
-                                   "the full finite strain tensor exists, tracking the associated compositional fields "
-                                   "is computationally expensive in 3d. Similarly, the finite strain magnitudes "
-                                   "may in fact decrease if the orientation of the deformation field switches "
-                                   "through time. Consequently, the ideal solution is track the finite strain "
-                                   "invariant (single compositional) field within the material and track "
-                                   "the full finite strain tensor through particles."
-                                   "When only the second invariant of the strain is tracked, one has the option to "
-                                   "track the full strain or only the plastic strain. In the latter case, strain is only tracked "
-                                   "in case the material is plastically yielding, i.e. the viscous stress > yield stress. "
-                                   "\n\n"
-                                   "Viscous stress may also be limited by a non-linear stress limiter "
-                                   "that has a form similar to the Peierls creep mechanism. "
-                                   "This stress limiter assigns an effective viscosity "
-                                   "$\\sigma_{\\text{eff}} = \\frac{\\tau_y}{2\\varepsilon_y} "
-                                   "{\\frac{\\varepsilon_{ii}}{\\varepsilon_y}}^{\\frac{1}{n_y}-1}$ "
-                                   "Above $\\tau_y$ is a yield stress, $\\varepsilon_y$ is the "
-                                   "reference strain rate, $\\varepsilon_{ii}$ is the strain rate "
-                                   "and $n_y$ is the stress limiter exponent.  The yield stress, "
-                                   "$\\tau_y$, is defined through the Drucker Prager yield criterion "
-                                   "formulation. This method of limiting viscous stress has been used "
-                                   "in various forms within the geodynamic literature \\cite{chri92,vavv02,cibi13,cibi15}."
-                                   "When $n_y$ is 1, it essentially becomes a linear viscosity model, "
-                                   "and in the limit $n_y\\rightarrow \\infty$ it converges to the "
-                                   "standard viscosity rescaling method (concretely, values $n_y>20$ "
-                                   "are large enough)."
-                                   "\n\n "
-                                   "The visco-plastic rheology described above may also be modified to include "
-                                   "viscoelastic deformation, thus producing a viscoelastic plastic constitutive "
-                                   "relationship. "
-                                   "\n\n "
-                                   "The viscoelastic rheology behavior takes into account the elastic shear "
-                                   "strength (e.g., shear modulus), while the tensile and volumetric "
-                                   "strength (e.g., Young's and bulk modulus) are not considered. The "
-                                   "model is incompressible and allows specifying an arbitrary number "
-                                   "of compositional fields, where each field represents a different "
-                                   "rock type or component of the viscoelastic stress tensor. The stress "
-                                   "tensor in 2d and 3d, respectively, contains 3 or 6 components. The "
-                                   "compositional fields representing these components must be named "
-                                   "and listed in a very specific format, which is designed to minimize "
-                                   "mislabeling stress tensor components as distinct 'compositional "
-                                   "rock types' (or vice versa). For 2d models, the first three "
-                                   "compositional fields must be labeled 'stress\\_xx', 'stress\\_yy' and 'stress\\_xy'. "
-                                   "In 3d, the first six compositional fields must be labeled 'stress\\_xx', "
-                                   "'stress\\_yy', 'stress\\_zz', 'stress\\_xy', 'stress\\_xz', 'stress\\_yz'. "
-                                   "\n\n "
-                                   "Combining this viscoelasticity implementation with non-linear viscous flow "
-                                   "and plasticity produces a constitutive relationship commonly referred to "
-                                   "as partial elastoviscoplastic (e.g., pEVP) in the geodynamics community. "
-                                   "While extensively discussed and applied within the geodynamics "
-                                   "literature, notable references include: "
-                                   "Moresi et al. (2003), J. Comp. Phys., v. 184, p. 476-497. "
-                                   "Gerya and Yuen (2007), Phys. Earth. Planet. Inter., v. 163, p. 83-105. "
-                                   "Gerya (2010), Introduction to Numerical Geodynamic Modeling. "
-                                   "Kaus (2010), Tectonophysics, v. 484, p. 36-47. "
-                                   "Choi et al. (2013), J. Geophys. Res., v. 118, p. 2429-2444. "
-                                   "Keller et al. (2013), Geophys. J. Int., v. 195, p. 1406-1442. "
-                                   "\n\n "
-                                   "The overview below directly follows Moresi et al. (2003) eqns. 23-38. "
-                                   "However, an important distinction between this material model and "
-                                   "the studies above is the use of compositional fields, rather than "
-                                   "particles, to track individual components of the viscoelastic stress "
-                                   "tensor. The material model will be updated when an option to track "
-                                   "and calculate viscoelastic stresses with particles is implemented. "
-                                   "\n\n "
-                                   "Moresi et al. (2003) begins (eqn. 23) by writing the deviatoric "
-                                   "rate of deformation ($\\hat{D}$) as the sum of elastic "
-                                   "($\\hat{D_{e}}$) and viscous ($\\hat{D_{v}}$) components: "
-                                   "$\\hat{D} = \\hat{D_{e}} + \\hat{D_{v}}$.  "
-                                   "These terms further decompose into "
-                                   "$\\hat{D_{v}} = \\frac{\\tau}{2\\eta}$ and "
-                                   "$\\hat{D_{e}} = \\frac{\\overset{\\nabla}{\\tau}}{2\\mu}$, where "
-                                   "$\\tau$ is the viscous deviatoric stress, $\\eta$ is the shear viscosity, "
-                                   "$\\mu$ is the shear modulus and $\\overset{\\nabla}{\\tau}$ is the "
-                                   "Jaumann corotational stress rate. This later term (eqn. 24) contains the "
-                                   "time derivative of the deviatoric stress ($\\dot{\\tau}$) and terms that "
-                                   "account for material spin (e.g., rotation) due to advection: "
-                                   "$\\overset{\\nabla}{\\tau} = \\dot{\\tau} + {\\tau}W -W\\tau$. "
-                                   "Above, $W$ is the material spin tensor (eqn. 25): "
-                                   "$W_{ij} = \\frac{1}{2} \\left (\\frac{\\partial V_{i}}{\\partial x_{j}} - "
-                                   "\\frac{\\partial V_{j}}{\\partial x_{i}} \\right )$. "
-                                   "\n\n "
-                                   "If plasticity is included, the deviatoric rate of deformation may be written as: "
-                                   "$\\hat{D} = \\hat{D_{e}} + \\hat{D_{v}} + \\hat{D_{p}}$, where $\\hat{D_{p}}$ "
-                                   "is the plastic component. $\\hat{D_{p}}$ decomposes to $\\frac{\\tau_{y}}{2\\eta_{y}}$, "
-                                   "where $\\tau_{y}$ is the yield stress and $\\eta_{y}$ is the viscosity rescaled "
-                                   "to the yield surface. "
-                                   "The Jaumann stress-rate can also be approximated using terms from the "
-                                   "previous time step ($t$) and current time step ($t + \\Delta t^{e}$): "
-                                   "$\\smash[t]{\\overset{\\nabla}{\\tau}}^{t + \\Delta t^{e}} \\approx "
-                                   "\\frac{\\tau^{t + \\Delta t^{e} - \\tau^{t}}}{\\Delta t^{e}} - "
-                                   "W^{t}\\tau^{t} + \\tau^{t}W^{t}$. "
-                                   "In this material model, the size of the time step above ($\\Delta t^{e}$) "
-                                   "can be specified as the numerical time step size or an independent fixed time "
-                                   "step. If the latter case is selected, the user has an option to apply a "
-                                   "stress averaging scheme to account for the differences between the numerical "
-                                   "and fixed elastic time step (eqn. 32). If one selects to use a fixed elastic time "
-                                   "step throughout the model run, this can still be achieved by using CFL and "
-                                   "maximum time step values that restrict the numerical time step to a specific time."
-                                   "\n\n "
-                                   "The formulation above allows rewriting the total rate of deformation (eqn. 29) as\n "
-                                   "$\\tau^{t + \\Delta t^{e}} = \\eta_{eff} \\left ( "
-                                   "2\\hat{D}^{t + \\triangle t^{e}} + \\frac{\\tau^{t}}{\\mu \\Delta t^{e}} + "
-                                   "\\frac{W^{t}\\tau^{t} - \\tau^{t}W^{t}}{\\mu}  \\right )$. "
-                                   "\n\n "
-                                   "The effective viscosity (eqn. 28) is a function of the viscosity ($\\eta$), "
-                                   "elastic time step size ($\\Delta t^{e}$) and shear relaxation time "
-                                   "($ \\alpha = \\frac{\\eta}{\\mu} $): "
-                                   "$\\eta_{eff} = \\eta \\frac{\\Delta t^{e}}{\\Delta t^{e} + \\alpha}$ "
-                                   "The magnitude of the shear modulus thus controls how much the effective "
-                                   "viscosity is reduced relative to the initial viscosity. "
-                                   "\n\n "
-                                   "Elastic effects are introduced into the governing Stokes equations through "
-                                   "an elastic force term (eqn. 30) using stresses from the previous time step: "
-                                   "$F^{e,t} = -\\frac{\\eta_{eff}}{\\mu \\Delta t^{e}} \\tau^{t}$. "
-                                   "This force term is added onto the right-hand side force vector in the "
-                                   "system of equations. "
-                                   "\n\n "
-                                   "When plastic yielding occurs, the effective viscosity in equation 29 and 30 is the "
-                                   "plastic viscosity (equation 36). If the current stress is below the plastic "
-                                   "yield stress, the effective viscosity is still as defined in equation 28. "
-                                   "During non-linear iterations, we define the current stress prior to yielding "
-                                   "(e.g., value compared to yield stress) as "
-                                   "$\\tau^{t + \\Delta t^{e}} = \\eta_{eff} \\left ( 2\\hat{D}^{t + \\triangle t^{e}} + "
-                                   "\\frac{\\tau^{t}}{\\mu \\Delta t^{e}} \\right ) $"
-                                   "\n\n "
-                                   "Compositional fields can each be assigned individual values of "
-                                   "thermal diffusivity, heat capacity, density, thermal "
-                                   "expansivity and rheological parameters. "
-                                   "\n\n "
-                                   "If more than one compositional field is present at a given "
-                                   "point, viscosities are averaged with an arithmetic, geometric "
-                                   "harmonic (default) or maximum composition scheme. "
-                                   "\n\n "
-                                   "The value for the components of this formula and additional "
-                                   "parameters are read from the parameter file in subsection "
-                                   " 'Material model/Visco Plastic'.")
-  }
-}
diff --git a/source/material_model/viscoelastic.cc.bak b/source/material_model/viscoelastic.cc.bak
deleted file mode 100644
index f25c6375a4a..00000000000
--- a/source/material_model/viscoelastic.cc.bak
+++ /dev/null
@@ -1,313 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/viscoelastic.h>
-#include <aspect/utilities.h>
-#include <aspect/global.h>
-#include <numeric>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    Viscoelastic<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      EquationOfStateOutputs<dim> eos_outputs (this->introspection().get_number_of_fields_of_type(CompositionalFieldDescription::chemical_composition)+1);
-
-      // Store which components to exclude during volume fraction computation.
-      ComponentMask composition_mask(this->n_compositional_fields(), true);
-      // assign compositional fields associated with viscoelastic stress a value of 0
-      // assume these fields are listed first
-      for (unsigned int i=0; i < SymmetricTensor<2,dim>::n_independent_components; ++i)
-        composition_mask.set(i,false);
-
-      std::vector<double> average_elastic_shear_moduli (in.n_evaluation_points());
-      std::vector<double> elastic_shear_moduli(elastic_rheology.get_elastic_shear_moduli());
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const std::vector<double> composition = in.composition[i];
-
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_only_composition_fractions(composition,
-                                                       this->introspection().chemical_composition_field_indices());
-
-          equation_of_state.evaluate(in, i, eos_outputs);
-
-          // Arithmetic averaging of thermal conductivities
-          // This may not be strictly the most reasonable thing, but for most Earth materials we hope
-          // that they do not vary so much that it is a big problem.
-          out.thermal_conductivities[i] = MaterialUtilities::average_value(volume_fractions, thermal_conductivities, MaterialUtilities::arithmetic);
-
-          // not strictly correct if thermal expansivities are different, since we are interpreting
-          // these compositions as volume fractions, but the error introduced should not be too bad.
-          out.densities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.densities, MaterialUtilities::arithmetic);
-          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.thermal_expansion_coefficients, MaterialUtilities::arithmetic);
-          out.specific_heat[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.specific_heat_capacities, MaterialUtilities::arithmetic);
-
-          out.compressibilities[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.compressibilities, MaterialUtilities::arithmetic);
-          out.entropy_derivative_pressure[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_pressure, MaterialUtilities::arithmetic);
-          out.entropy_derivative_temperature[i] = MaterialUtilities::average_value (volume_fractions, eos_outputs.entropy_derivative_temperature, MaterialUtilities::arithmetic);
-
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-
-          // Average viscosity and shear modulus
-          const double average_viscosity = MaterialUtilities::average_value(volume_fractions, viscosities, viscosity_averaging);
-          average_elastic_shear_moduli[i] = MaterialUtilities::average_value(volume_fractions, elastic_shear_moduli, viscosity_averaging);
-
-          // Average viscoelastic (e.g., effective) viscosity (equation 28 in Moresi et al., 2003, J. Comp. Phys.)
-          out.viscosities[i] = elastic_rheology.calculate_viscoelastic_viscosity(average_viscosity,
-                                                                                 average_elastic_shear_moduli[i]);
-
-          // Fill the material properties that are part of the elastic additional outputs
-          if (ElasticAdditionalOutputs<dim> *elastic_out = out.template get_additional_output<ElasticAdditionalOutputs<dim>>())
-            {
-              elastic_out->elastic_shear_moduli[i] = average_elastic_shear_moduli[i];
-            }
-        }
-
-      elastic_rheology.fill_elastic_outputs(in, average_elastic_shear_moduli, out);
-      elastic_rheology.fill_reaction_outputs(in, average_elastic_shear_moduli, out);
-
-    }
-
-    template <int dim>
-    bool
-    Viscoelastic<dim>::
-    is_compressible () const
-    {
-      return equation_of_state.is_compressible();
-    }
-
-    template <int dim>
-    void
-    Viscoelastic<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Viscoelastic");
-        {
-          EquationOfState::MulticomponentIncompressible<dim>::declare_parameters (prm);
-          Rheology::Elasticity<dim>::declare_parameters (prm);
-
-          prm.declare_entry ("Viscosities", "1.e21",
-                             Patterns::List(Patterns::Double (0.)),
-                             "List of viscosities for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of all compositional fields or only "
-                             "those corresponding to chemical compositions. "
-                             "If only one value is given, then all use the same value. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Thermal conductivities", "4.7",
-                             Patterns::List(Patterns::Double (0.)),
-                             "List of thermal conductivities for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of all compositional fields or only "
-                             "those corresponding to chemical compositions. "
-                             "If only one value is given, then all use the same value. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
-                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition "),
-                             "When more than one compositional field is present at a point "
-                             "with different viscosities, we need to come up with an average "
-                             "viscosity at that point.  Select a weighted harmonic, arithmetic, "
-                             "geometric, or maximum composition.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    Viscoelastic<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Viscoelastic");
-        {
-          // Equation of state parameters
-          equation_of_state.initialize_simulator (this->get_simulator());
-          equation_of_state.parse_parameters (prm);
-
-          elastic_rheology.initialize_simulator (this->get_simulator());
-          elastic_rheology.parse_parameters(prm);
-
-          viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
-                                prm);
-
-          // Make options file for parsing maps to double arrays
-          std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-          chemical_field_names.insert(chemical_field_names.begin(),"background");
-
-          std::vector<std::string> compositional_field_names = this->introspection().get_composition_names();
-          compositional_field_names.insert(compositional_field_names.begin(),"background");
-
-          Utilities::MapParsing::Options options(chemical_field_names, "Viscosities");
-          options.list_of_allowed_keys = compositional_field_names;
-
-          viscosities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Viscosities"), options);
-          options.property_name = "Thermal conductivities";
-          thermal_conductivities = Utilities::MapParsing::parse_map_to_double_array (prm.get("Thermal conductivities"), options);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::compositional_fields;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::compositional_fields;
-    }
-
-
-
-    template <int dim>
-    void
-    Viscoelastic<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      elastic_rheology.create_elastic_outputs(out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Viscoelastic,
-                                   "viscoelastic",
-                                   "An implementation of a simple linear viscoelastic rheology that "
-                                   "only includes the deviatoric components of elasticity. Specifically, "
-                                   "the viscoelastic rheology only takes into account the elastic shear "
-                                   "strength (e.g., shear modulus), while the tensile and volumetric "
-                                   "strength (e.g., Young's and bulk modulus) are not considered. The "
-                                   "model is incompressible and allows specifying an arbitrary number "
-                                   "of compositional fields, where each field represents a different "
-                                   "rock type or component of the viscoelastic stress tensor. The stress "
-                                   "tensor in 2d and 3d, respectively, contains 3 or 6 components. The "
-                                   "compositional fields representing these components must be named "
-                                   "and listed in a very specific format, which is designed to minimize "
-                                   "mislabeling stress tensor components as distinct 'compositional "
-                                   "rock types' (or vice versa). For 2d models, the first three "
-                                   "compositional fields must be labeled 'stress\\_xx', 'stress\\_yy' and 'stress\\_xy'. "
-                                   "In 3d, the first six compositional fields must be labeled 'stress\\_xx', "
-                                   "'stress\\_yy', 'stress\\_zz', 'stress\\_xy', 'stress\\_xz', 'stress\\_yz'. "
-                                   "\n\n "
-                                   "Expanding the model to include non-linear viscous flow (e.g., "
-                                   "diffusion/dislocation creep) and plasticity would produce a "
-                                   "constitutive relationship commonly referred to as partial "
-                                   "elastoviscoplastic (e.g., pEVP) in the geodynamics community. "
-                                   "While extensively discussed and applied within the geodynamics "
-                                   "literature, notable references include: "
-                                   "Moresi et al. (2003), J. Comp. Phys., v. 184, p. 476-497. "
-                                   "Gerya and Yuen (2007), Phys. Earth. Planet. Inter., v. 163, p. 83-105. "
-                                   "Gerya (2010), Introduction to Numerical Geodynamic Modeling. "
-                                   "Kaus (2010), Tectonophysics, v. 484, p. 36-47. "
-                                   "Choi et al. (2013), J. Geophys. Res., v. 118, p. 2429-2444. "
-                                   "Keller et al. (2013), Geophys. J. Int., v. 195, p. 1406-1442. "
-                                   "\n\n "
-                                   "The overview below directly follows Moresi et al. (2003) eqns. 23-32. "
-                                   "However, an important distinction between this material model and "
-                                   "the studies above is the use of compositional fields, rather than "
-                                   "particles, to track individual components of the viscoelastic stress "
-                                   "tensor. The material model will be updated when an option to track "
-                                   "and calculate viscoelastic stresses with particles is implemented. "
-                                   "\n\n "
-                                   "Moresi et al. (2003) begins (eqn. 23) by writing the deviatoric "
-                                   "rate of deformation ($\\hat{D}$) as the sum of elastic "
-                                   "($\\hat{D_{e}}$) and viscous ($\\hat{D_{v}}$) components: "
-                                   "$\\hat{D} = \\hat{D_{e}} + \\hat{D_{v}}$.  "
-                                   "These terms further decompose into "
-                                   "$\\hat{D_{v}} = \\frac{\\tau}{2\\eta}$ and "
-                                   "$\\hat{D_{e}} = \\frac{\\overset{\\nabla}{\\tau}}{2\\mu}$, where "
-                                   "$\\tau$ is the viscous deviatoric stress, $\\eta$ is the shear viscosity, "
-                                   "$\\mu$ is the shear modulus and $\\overset{\\nabla}{\\tau}$ is the "
-                                   "Jaumann corotational stress rate. This later term (eqn. 24) contains the "
-                                   "time derivative of the deviatoric stress ($\\dot{\\tau}$) and terms that "
-                                   "account for material spin (e.g., rotation) due to advection: "
-                                   "$\\overset{\\nabla}{\\tau} = \\dot{\\tau} + {\\tau}W -W\\tau$. "
-                                   "Above, $W$ is the material spin tensor (eqn. 25): "
-                                   "$W_{ij} = \\frac{1}{2} \\left (\\frac{\\partial V_{i}}{\\partial x_{j}} - "
-                                   "\\frac{\\partial V_{j}}{\\partial x_{i}} \\right )$. "
-                                   "\n\n "
-                                   "The Jaumann stress-rate can also be approximated using terms from the "
-                                   "previous time step ($t$) and current time step ($t + \\Delta t^{e}$): "
-                                   "$\\smash[t]{\\overset{\\nabla}{\\tau}}^{t + \\Delta t^{e}} \\approx "
-                                   "\\frac{\\tau^{t + \\Delta t^{e} - \\tau^{t}}}{\\Delta t^{e}} - "
-                                   "W^{t}\\tau^{t} + \\tau^{t}W^{t}$. "
-                                   "In this material model, the size of the time step above ($\\Delta t^{e}$) "
-                                   "can be specified as the numerical time step size or an independent fixed time "
-                                   "step. If the latter case is selected, the user has an option to apply a "
-                                   "stress averaging scheme to account for the differences between the numerical "
-                                   "and fixed elastic time step (eqn. 32). If one selects to use a fixed elastic time "
-                                   "step throughout the model run, this can still be achieved by using CFL and "
-                                   "maximum time step values that restrict the numerical time step to a specific time."
-                                   "\n\n "
-                                   "The formulation above allows rewriting the total deviatoric stress (eqn. 29) as\n "
-                                   "$\\tau^{t + \\Delta t^{e}} = \\eta_\\text{eff} \\left ( "
-                                   "2\\hat{D}^{t + \\triangle t^{e}} + \\frac{\\tau^{t}}{\\mu \\Delta t^{e}} + "
-                                   "\\frac{W^{t}\\tau^{t} - \\tau^{t}W^{t}}{\\mu}  \\right )$. "
-                                   "\n\n "
-                                   "The effective viscosity (eqn. 28) is a function of the viscosity ($\\eta$), "
-                                   "elastic time step size ($\\Delta t^{e}$) and shear relaxation time "
-                                   "($ \\alpha = \\frac{\\eta}{\\mu} $): "
-                                   "$\\eta_\\text{eff} = \\eta \\frac{\\Delta t^{e}}{\\Delta t^{e} + \\alpha}$ "
-                                   "The magnitude of the shear modulus thus controls how much the effective "
-                                   "viscosity is reduced relative to the initial viscosity. "
-                                   "\n\n "
-                                   "Elastic effects are introduced into the governing Stokes equations through "
-                                   "an elastic force term (eqn. 30) using stresses from the previous time step: "
-                                   "$F^{e,t} = -\\frac{\\eta_\\text{eff}}{\\mu \\Delta t^{e}} \\tau^{t}$. "
-                                   "This force term is added onto the right-hand side force vector in the "
-                                   "system of equations. "
-                                   "\n\n "
-                                   "The value of each compositional field representing distinct rock types at a "
-                                   "point is interpreted to be a volume fraction of that rock type. If the sum of "
-                                   "the compositional field volume fractions is less than one, then the remainder "
-                                   "of the volume is assumed to be 'background material'."
-                                   "\n\n "
-                                   "Several model parameters (densities, elastic shear moduli, thermal expansivities, "
-                                   "thermal conductivies, specific heats) can be defined per-compositional field. "
-                                   "For each material parameter the user supplies a comma delimited list of length "
-                                   "N+1, where N is the number of compositional fields. The additional field corresponds "
-                                   "to the value for background material. They should be ordered ''background, "
-                                   "composition1, composition2...''. However, the first 3 (2d) or 6 (3d) composition "
-                                   "fields correspond to components of the elastic stress tensor and their material "
-                                   "values will not contribute to the volume fractions. If a single value is given, then "
-                                   "all the compositional fields are given that value. Other lengths of lists are not "
-                                   "allowed. For a given compositional field the material parameters are treated as "
-                                   "constant, except density, which varies linearly with temperature according to the "
-                                   "thermal expansivity. "
-                                   "\n\n "
-                                   "When more than one compositional field is present at a point, they are averaged "
-                                   "arithmetically. An exception is viscosity, which may be averaged arithmetically, "
-                                   "harmonically, geometrically, or by selecting the viscosity of the composition field "
-                                   "with the greatest volume fraction.")
-  }
-}
diff --git a/source/mesh_deformation/ascii_data.cc.bak b/source/mesh_deformation/ascii_data.cc.bak
deleted file mode 100644
index 4c8a6b6f3c3..00000000000
--- a/source/mesh_deformation/ascii_data.cc.bak
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/mesh_deformation/ascii_data.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/parameter_handler.h>
-#include <array>
-
-
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      :
-      surface_boundary_id(1)
-    {}
-
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      surface_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-      Utilities::AsciiDataBoundary<dim>::initialize({surface_boundary_id},
-                                                    1);
-    }
-
-
-
-    template <int dim>
-    Tensor<1,dim>
-    AsciiData<dim>::compute_initial_deformation_on_boundary(const types::boundary_id boundary_indicator,
-                                                            const Point<dim> &position) const
-    {
-      const double topo = Utilities::AsciiDataBoundary<dim>::get_data_component(boundary_indicator,
-                                                                                position,
-                                                                                0);
-
-      const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(position);
-
-      Tensor<1,dim> topography_direction;
-      if (gravity.norm() > 0.0)
-        topography_direction = -gravity / gravity.norm();
-
-      return topo * topography_direction;
-    }
-
-
-
-    template <int dim>
-    bool
-    AsciiData<dim>::
-    needs_surface_stabilization () const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh deformation");
-      {
-        Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                          "$ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/",
-                                                          "box_3d_%s.0.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh deformation");
-      {
-        Utilities::AsciiDataBase<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(AsciiData,
-                                           "ascii data",
-                                           "Implementation of a model in which the initial mesh "
-                                           "deformation (initial topography) is "
-                                           "derived from a file containing data "
-                                           "in ascii format. The following geometry models "
-                                           "are currently supported: box, chunk, spherical. "
-                                           "Note the required format of the "
-                                           "input data: The first lines may contain any number of comments "
-                                           "if they begin with `#', but one of these lines needs to "
-                                           "contain the number of grid points in each dimension as "
-                                           "for example `# POINTS: 3 3'. "
-                                           "The order of the data columns "
-                                           "has to be `x', `Topography [m]' in a 2d model and "
-                                           " `x', `y', `Topography [m]' in a 3d model, which means that "
-                                           "there has to be a single column "
-                                           "containing the topography. "
-                                           "Note that the data in the input "
-                                           "file needs to be sorted in a specific order: "
-                                           "the first coordinate needs to ascend first, "
-                                           "followed by the second in order to "
-                                           "assign the correct data to the prescribed coordinates. "
-                                           "If you use a spherical model, "
-                                           "then the assumed grid changes. "
-                                           "`x' will be replaced by the azimuth angle in radians "
-                                           " and `y' by the polar angle in radians measured "
-                                           "positive from the north pole. The grid will be assumed to be "
-                                           "a longitude-colatitude grid. Note that the order "
-                                           "of spherical coordinates is `phi', `theta' "
-                                           "and not `theta', `phi', since this allows "
-                                           "for dimension independent expressions.")
-  }
-}
diff --git a/source/mesh_deformation/diffusion.cc.bak b/source/mesh_deformation/diffusion.cc.bak
deleted file mode 100644
index abe769a856c..00000000000
--- a/source/mesh_deformation/diffusion.cc.bak
+++ /dev/null
@@ -1,582 +0,0 @@
-/*
-  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/mesh_deformation/diffusion.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/simulator.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/base/symmetric_tensor.h>
-#include <deal.II/numerics/vector_tools.h>
-#include <deal.II/lac/precondition.h>
-#include <deal.II/lac/trilinos_precondition.h>
-#include <boost/lexical_cast.hpp>
-
-namespace aspect
-{
-
-  namespace MeshDeformation
-  {
-    template <int dim>
-    Diffusion<dim>::Diffusion()
-      :
-      diffusivity(0.),
-      timesteps_between_diffusion (1),
-      apply_diffusion(false)
-    {}
-
-
-
-    template <int dim>
-    void
-    Diffusion<dim>::initialize ()
-    {
-      AssertThrow(Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
-                  Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
-                  ExcMessage("The surface diffusion mesh deformation plugin only works for Box geometries."));
-    }
-
-
-
-    template <int dim>
-    void
-    Diffusion<dim>::update ()
-    {
-      // Set the current timestep number
-      const unsigned int current_timestep_number = this->get_timestep_number();
-
-      // Determine whether we need to apply diffusion based
-      // on the timestep interval between applications.
-      // Because mesh deformation is computed at the beginning
-      // of each timestep, we do not apply diffusion in the first timestep.
-      if (current_timestep_number != 0)
-        {
-          if (current_timestep_number % timesteps_between_diffusion == 0)
-            apply_diffusion = true;
-          else
-            apply_diffusion = false;
-        }
-    }
-
-
-
-    template <int dim>
-    void Diffusion<dim>::diffuse_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                          const IndexSet &mesh_locally_owned,
-                                          const IndexSet &mesh_locally_relevant,
-                                          LinearAlgebra::Vector &output,
-                                          const std::set<types::boundary_id> &boundary_ids) const
-    {
-      // Check that the current timestep does not exceed the diffusion timestep
-      check_diffusion_time_step(mesh_deformation_dof_handler, boundary_ids);
-
-      // Set up constraints
-      AffineConstraints<double> matrix_constraints(mesh_locally_relevant);
-      DoFTools::make_hanging_node_constraints(mesh_deformation_dof_handler, matrix_constraints);
-
-      std::set<types::boundary_id> periodic_boundary_indicators;
-      using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
-      const periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
-      for (const auto &p : pbp)
-        {
-          DoFTools::make_periodicity_constraints(mesh_deformation_dof_handler,
-                                                 p.first.first, p.first.second, p.second, matrix_constraints);
-          periodic_boundary_indicators.insert(p.first.first);
-          periodic_boundary_indicators.insert(p.first.second);
-        }
-
-      // A boundary can be:
-      // 1) A mesh deformation boundary with its deformation computed by this plugin.
-      // 2) A zero mesh displacement boundary:
-      //    a) boundaries with zero Stokes velocity that are not an Additional tangential mesh boundary or mesh deformation boundary,
-      //    b) boundaries with prescribed Stokes velocity that are not an Additional tangential mesh boundary or mesh deformation boundary.
-      // 3) A tangential mesh displacement boundary (no normal flux):
-      //    a) tangential Stokes boundaries that are not a mesh deformation boundary,
-      //    b) additional tangential mesh boundaries other than those in a) and c),
-      //    c) periodic boundaries that are not a mesh deformation boundary.
-      // We obtain the zero mesh displacement boundaries by subtracting the mesh deformation ones (1+3) from all used boundary indicators. In this
-      // case, when no Stokes velocity boundary conditions are set (e.g. when using the single Advection,
-      // no Stokes solver scheme, we do end up with mesh displacement boundary conditions.
-
-      // All boundary indicators used by the current geometry.
-      const std::set<types::boundary_id> all_boundaries = this->get_geometry_model().get_used_boundary_indicators();
-
-      // Get the tangential Stokes velocity boundary indicators.
-      const std::set<types::boundary_id> tangential_velocity_boundary_indicators =
-        this->get_boundary_velocity_manager().get_tangential_boundary_velocity_indicators();
-
-      // The list of all tangential mesh deformation boundary indicators.
-      std::set<types::boundary_id> tmp_tangential_boundaries, tmp2_tangential_boundaries, all_tangential_boundaries;
-      std::set_union(tangential_velocity_boundary_indicators.begin(),tangential_velocity_boundary_indicators.end(),
-                     additional_tangential_mesh_boundary_indicators.begin(),additional_tangential_mesh_boundary_indicators.end(),
-                     std::inserter(tmp_tangential_boundaries, tmp_tangential_boundaries.end()));
-      std::set_union(tmp_tangential_boundaries.begin(),tmp_tangential_boundaries.end(),
-                     periodic_boundary_indicators.begin(),periodic_boundary_indicators.end(),
-                     std::inserter(tmp2_tangential_boundaries, tmp2_tangential_boundaries.end()));
-      // Tangential Stokes velocity boundaries can also be mesh deformation boundaries,
-      // so correct for that.
-      std::set_difference(tmp2_tangential_boundaries.begin(),tmp2_tangential_boundaries.end(),
-                          boundary_ids.begin(),boundary_ids.end(),
-                          std::inserter(all_tangential_boundaries, all_tangential_boundaries.end()));
-
-      // The list of mesh deformation boundary indicators of boundaries that are allowed to move either
-      // tangentially or in all directions.
-      std::set<types::boundary_id> all_deformable_boundaries;
-      std::set_union(all_tangential_boundaries.begin(),all_tangential_boundaries.end(),
-                     boundary_ids.begin(),boundary_ids.end(),
-                     std::inserter(all_deformable_boundaries, all_deformable_boundaries.end()));
-
-      // The list of mesh deformation boundary indicators of boundaries that are not allowed to move.
-      std::set<types::boundary_id> all_fixed_boundaries;
-      std::set_difference(all_boundaries.begin(),all_boundaries.end(),
-                          all_deformable_boundaries.begin(),all_deformable_boundaries.end(),
-                          std::inserter(all_fixed_boundaries, all_fixed_boundaries.end()));
-
-      // Make the no flux boundary constraints
-      for (const types::boundary_id &boundary_id : all_fixed_boundaries)
-        {
-          VectorTools::interpolate_boundary_values (this->get_mapping(),
-                                                    mesh_deformation_dof_handler,
-                                                    boundary_id,
-                                                    dealii::Functions::ZeroFunction<dim>(dim),
-                                                    matrix_constraints);
-        }
-
-      // Make the no normal flux boundary constraints
-      VectorTools::compute_no_normal_flux_constraints (mesh_deformation_dof_handler,
-                                                       /* first_vector_component= */
-                                                       0,
-                                                       all_tangential_boundaries,
-                                                       matrix_constraints, this->get_mapping());
-
-      matrix_constraints.close();
-
-      // Set up the system to solve
-      LinearAlgebra::SparseMatrix matrix;
-
-      // Sparsity of the matrix
-      TrilinosWrappers::SparsityPattern sp (mesh_locally_owned,
-                                            mesh_locally_owned,
-                                            mesh_locally_relevant,
-                                            this->get_mpi_communicator());
-      DoFTools::make_sparsity_pattern (mesh_deformation_dof_handler, sp, matrix_constraints, false,
-                                       Utilities::MPI::this_mpi_process(this->get_mpi_communicator()));
-
-      sp.compress();
-      matrix.reinit (sp);
-
-      LinearAlgebra::Vector system_rhs, solution;
-      system_rhs.reinit(mesh_locally_owned, this->get_mpi_communicator());
-      solution.reinit(mesh_locally_owned, this->get_mpi_communicator());
-
-      // Initialize Gauss-Legendre quadrature for degree+1 quadrature points of the surface faces
-      const QGauss<dim-1> face_quadrature(mesh_deformation_dof_handler.get_fe().degree+1);
-      // Update shape function values and gradients, the quadrature points and the Jacobian x quadrature weights.
-      const UpdateFlags update_flags = UpdateFlags(update_values | update_gradients | update_quadrature_points | update_normal_vectors | update_JxW_values);
-      // We want to extract the displacement at the free surface faces of the mesh deformation element.
-      FEFaceValues<dim> fs_fe_face_values (this->get_mapping(), mesh_deformation_dof_handler.get_fe(), face_quadrature, update_flags);
-      // and to solve on the whole mesh deformation mesh
-      // The number of quadrature points on a mesh deformation surface face
-      const unsigned int n_fs_face_q_points = fs_fe_face_values.n_quadrature_points;
-
-      // What we need to build our system on the mesh deformation element
-
-      // The nr of shape functions per mesh deformation element
-      const unsigned int dofs_per_cell = mesh_deformation_dof_handler.get_fe().dofs_per_cell;
-
-      // Map of local to global cell dof indices
-      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
-
-      // The local rhs vector
-      Vector<double> cell_vector (dofs_per_cell);
-      // The local matrix
-      FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
-
-      // Vector for getting the local dim displacement values
-      std::vector<Tensor<1, dim>> displacement_values(n_fs_face_q_points);
-
-      // Vector for getting the local dim initial topography values
-      std::vector<Tensor<1, dim>> initial_topography_values(n_fs_face_q_points);
-
-      // The global displacements on the MeshDeformation FE
-      LinearAlgebra::Vector displacements = this->get_mesh_deformation_handler().get_mesh_displacements();
-
-      // The global initial topography on the MeshDeformation FE
-      // TODO Once the initial mesh deformation is ready, this
-      // can be removed.
-      LinearAlgebra::Vector initial_topography = this->get_mesh_deformation_handler().get_initial_topography();
-
-      // Do nothing at time zero
-      if (this->get_timestep_number() < 1)
-        return;
-
-      // An extractor for the dim-valued displacement vectors
-      // Later on we will compute the gravity-parallel displacement
-      FEValuesExtractors::Vector extract_vertical_displacements(0);
-
-      // An extractor for the dim-valued initial topography vectors
-      // Later on we will compute the gravity-parallel displacement
-      FEValuesExtractors::Vector extract_initial_topography(0);
-
-      // Cell iterator over the MeshDeformation FE
-      typename DoFHandler<dim>::active_cell_iterator
-      fscell = mesh_deformation_dof_handler.begin_active(),
-      fsendc = mesh_deformation_dof_handler.end();
-
-      // Iterate over all cells to find those at the mesh deformation boundary
-      for (; fscell!=fsendc; ++fscell)
-        if (fscell->at_boundary() && fscell->is_locally_owned())
-          for (const unsigned int face_no : fscell->face_indices())
-            if (fscell->face(face_no)->at_boundary())
-              {
-                // Boundary indicator of current cell face
-                const types::boundary_id boundary_indicator
-                  = fscell->face(face_no)->boundary_id();
-
-                // Only apply diffusion to the requested boundaries
-                if (boundary_ids.find(boundary_indicator) == boundary_ids.end())
-                  continue;
-
-                // Recompute values, gradients, etc on the faces
-                fs_fe_face_values.reinit (fscell, face_no);
-
-                // Get the global numbers of the local DoFs of the mesh deformation cell
-                fscell->get_dof_indices (cell_dof_indices);
-
-                // Extract the displacement values
-                fs_fe_face_values[extract_vertical_displacements].get_function_values (displacements, displacement_values);
-
-                // Extract the initial topography values
-                fs_fe_face_values[extract_initial_topography].get_function_values (initial_topography, initial_topography_values);
-
-                // Reset local rhs and matrix
-                cell_vector = 0;
-                cell_matrix = 0;
-
-                // Loop over the quadrature points of the current face
-                for (unsigned int point=0; point<n_fs_face_q_points; ++point)
-                  {
-                    // Get the gravity vector to compute the outward direction of displacement
-                    Tensor<1,dim> direction = -(this->get_gravity_model().gravity_vector(fs_fe_face_values.quadrature_point(point)));
-                    // Normalize direction vector
-                    if (direction.norm() > 0.0)
-                      direction *= 1./direction.norm();
-                    // TODO this is only correct for box geometries
-                    else
-                      {
-                        AssertThrow(Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
-                                    Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
-                                    ExcMessage("The surface diffusion mesh deformation plugin only works for Box geometries."));
-                        direction[dim-1] = 1.;
-                      }
-
-                    // Compute the total displacement in the gravity direction,
-                    // i.e. the initial topography + any additional mesh displacement.
-                    const double displacement = direction * (displacement_values[point] + initial_topography_values[point]);
-
-                    // To project onto the tangent space of the surface,
-                    // we define the projection P:= I- n x n,
-                    // with I the unit tensor and n the unit normal to the surface.
-                    // The surface gradient then is P times the usual gradient of the shape functions.
-                    const Tensor<2, dim, double> projection = unit_symmetric_tensor<dim>() -
-                                                              outer_product(fs_fe_face_values.normal_vector(point), fs_fe_face_values.normal_vector(point));
-
-
-                    // The shape values for the i-loop
-                    std::vector<double> phi(dofs_per_cell);
-
-                    // The projected gradients of the shape values for the i-loop
-                    std::vector<Tensor<1, dim, double>> projected_grad_phi(dofs_per_cell);
-
-                    // Loop over the shape functions
-                    for (unsigned int i=0; i<dofs_per_cell; ++i)
-                      {
-                        // Make sure we only assemble for the y-component
-                        // TODO this is only correct for box geometries
-                        // Check that a box geometry is used
-                        AssertThrow(Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
-                                    Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()),
-                                    ExcMessage("The surface diffusion mesh deformation plugin only works for Box geometries."));
-                        if (mesh_deformation_dof_handler.get_fe().system_to_component_index(i).first == dim-1)
-                          {
-                            // Precompute shape values and projected shape value gradients
-                            phi[i] = fs_fe_face_values.shape_value (i, point);
-                            projected_grad_phi[i] = projection * fs_fe_face_values.shape_grad(i, point);
-
-                            // Assemble the RHS
-                            // RHS = M*H_old
-                            cell_vector(i) += phi[i] * displacement * fs_fe_face_values.JxW(point);
-
-                            for (unsigned int j=0; j<dofs_per_cell; ++j)
-                              {
-                                // Make sure we only assemble for the y-component
-                                // TODO this is only correct for box geometries
-                                if (mesh_deformation_dof_handler.get_fe().system_to_component_index(j).first == dim-1)
-                                  {
-                                    // Assemble the matrix, for backward first order time discretization:
-                                    // Matrix := (M+dt*K) = (M+dt*B^T*kappa*B)
-                                    cell_matrix(i,j) +=
-                                      (
-                                        phi[i] * fs_fe_face_values.shape_value (j, point) +
-                                        this->get_timestep() * diffusivity *
-                                        projected_grad_phi[i] *
-                                        (projection * fs_fe_face_values.shape_grad(j, point))
-                                      )
-                                      * fs_fe_face_values.JxW(point);
-                                  }
-                              }
-                          }
-                      }
-                  }
-
-                matrix_constraints.distribute_local_to_global (cell_matrix, cell_vector,
-                                                               cell_dof_indices, matrix, system_rhs, false);
-              }
-
-      system_rhs.compress (VectorOperation::add);
-      matrix.compress(VectorOperation::add);
-
-      // Jacobi seems to be fine here.  Other preconditioners (ILU, IC) run into trouble
-      // because the matrix is mostly empty, since we don't touch internal vertices.
-      LinearAlgebra::PreconditionJacobi preconditioner_mass;
-      LinearAlgebra::PreconditionJacobi::AdditionalData preconditioner_control(1,1e-16,1);
-      preconditioner_mass.initialize(matrix, preconditioner_control);
-
-      this->get_pcout() << "   Solving mesh surface diffusion" << std::endl;
-      SolverControl solver_control(5*system_rhs.size(), this->get_parameters().linear_stokes_solver_tolerance*system_rhs.l2_norm());
-      SolverCG<LinearAlgebra::Vector> cg(solver_control);
-      cg.solve (matrix, solution, system_rhs, preconditioner_mass);
-
-      // Distribute constraints on mass matrix
-      matrix_constraints.distribute (solution);
-
-      // The solution contains the new displacements, but we need to return a velocity.
-      // Therefore, we compute v=d_displacement/d_t.
-      // d_displacement are the new mesh node locations
-      // minus the old locations, which are initial_topography + displacements.
-      LinearAlgebra::Vector velocity(mesh_locally_owned, mesh_locally_relevant, this->get_mpi_communicator());
-      velocity = solution;
-      velocity -= initial_topography;
-      velocity -= displacements;
-
-      // The velocity
-      if (this->get_timestep() > 0.)
-        velocity /= this->get_timestep();
-      else
-        AssertThrow(false, ExcZero());
-
-      output = velocity;
-    }
-
-
-
-    template <int dim>
-    void Diffusion<dim>::check_diffusion_time_step (const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                    const std::set<types::boundary_id> &boundary_ids) const
-    {
-      double min_local_conduction_timestep = std::numeric_limits<double>::max();
-
-      for (const auto &fscell : mesh_deformation_dof_handler.active_cell_iterators())
-        if (fscell->at_boundary() && fscell->is_locally_owned())
-          for (const unsigned int face_no : fscell->face_indices())
-            if (fscell->face(face_no)->at_boundary())
-              {
-                // Get the boundary indicator of current cell face
-                const types::boundary_id boundary_indicator
-                  = fscell->face(face_no)->boundary_id();
-
-                // Only consider the requested boundaries
-                if (boundary_ids.find(boundary_indicator) == boundary_ids.end())
-                  continue;
-
-                // Calculate the corresponding conduction timestep
-                min_local_conduction_timestep = std::min(min_local_conduction_timestep,
-                                                         this->get_parameters().CFL_number*std::pow(fscell->face(face_no)->minimum_vertex_distance(),2.)
-                                                         / diffusivity);
-              }
-
-      // Get the global minimum timestep
-      const double min_conduction_timestep = Utilities::MPI::min (min_local_conduction_timestep, this->get_mpi_communicator());
-
-      double conduction_timestep = min_conduction_timestep;
-      if (this->convert_output_to_years())
-        conduction_timestep /= year_in_seconds;
-
-      AssertThrow (this->get_timestep() <= min_conduction_timestep,
-                   ExcMessage("The numerical timestep is too large for diffusion of the surface. Although the "
-                              "diffusion scheme is stable, note that the error increases linearly with the timestep. "
-                              "The diffusion timestep is: " + std::to_string(conduction_timestep) + ", while "
-                              "the advection timestep is: " + std::to_string (this->get_timestep ())));
-    }
-
-
-
-    template <int dim>
-    void
-    Diffusion<dim>::compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                             AffineConstraints<double> &mesh_velocity_constraints,
-                                                             const std::set<types::boundary_id> &boundary_id) const
-    {
-      if (!apply_diffusion)
-        return;
-
-      LinearAlgebra::Vector boundary_velocity;
-
-      const IndexSet &mesh_locally_owned = mesh_deformation_dof_handler.locally_owned_dofs();
-      IndexSet mesh_locally_relevant;
-      DoFTools::extract_locally_relevant_dofs (mesh_deformation_dof_handler,
-                                               mesh_locally_relevant);
-      boundary_velocity.reinit(mesh_locally_owned, mesh_locally_relevant,
-                               this->get_mpi_communicator());
-
-      // Determine the mesh velocity at the surface based on diffusion of
-      // the topography
-      diffuse_boundary(mesh_deformation_dof_handler, mesh_locally_owned,
-                       mesh_locally_relevant, boundary_velocity, boundary_id);
-
-      // now insert the relevant part of the solution into the mesh constraints
-      const IndexSet constrained_dofs =
-        DoFTools::extract_boundary_dofs(mesh_deformation_dof_handler,
-                                        ComponentMask(dim, true),
-                                        boundary_id);
-
-      for (unsigned int i = 0; i < constrained_dofs.n_elements();  ++i)
-        {
-          types::global_dof_index index = constrained_dofs.nth_index_in_set(i);
-          if (mesh_velocity_constraints.can_store_line(index))
-            if (mesh_velocity_constraints.is_constrained(index)==false)
-              {
-                mesh_velocity_constraints.add_line(index);
-                mesh_velocity_constraints.set_inhomogeneity(index, boundary_velocity[index]);
-              }
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    Diffusion<dim>::
-    needs_surface_stabilization () const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    void Diffusion<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh deformation");
-      {
-        prm.enter_subsection("Diffusion");
-        {
-          prm.declare_entry("Hillslope transport coefficient", "1e-6",
-                            Patterns::Double(0),
-                            "The hillslope transport coefficient $\\kappa$ used to "
-                            "diffuse the free surface, either as a  "
-                            "stabilization step or to mimic erosional "
-                            "and depositional processes. Units: $\\si{m^2/s}$. ");
-          prm.declare_entry("Time steps between diffusion", "1",
-                            Patterns::Integer(0,std::numeric_limits<int>::max()),
-                            "The number of time steps between each application of "
-                            "diffusion.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void Diffusion<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Mesh deformation");
-      {
-        // Create the list of tangential mesh movement boundary indicators.
-        try
-          {
-            const std::vector<types::boundary_id> x_additional_tangential_mesh_boundary_indicators
-              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
-                                                                                    (prm.get ("Additional tangential mesh velocity boundary indicators")));
-
-            additional_tangential_mesh_boundary_indicators.insert(x_additional_tangential_mesh_boundary_indicators.begin(),
-                                                                  x_additional_tangential_mesh_boundary_indicators.end());
-          }
-        catch (const std::string &error)
-          {
-            AssertThrow (false, ExcMessage ("While parsing the entry <Mesh deformation/Additional tangential "
-                                            "mesh velocity boundary indicators>, there was an error. Specifically, "
-                                            "the conversion function complained as follows:\n\n"
-                                            + error));
-          }
-
-        prm.enter_subsection ("Diffusion");
-        {
-          diffusivity                 = prm.get_double("Hillslope transport coefficient");
-          timesteps_between_diffusion = prm.get_integer("Time steps between diffusion");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(Diffusion,
-                                           "diffusion",
-                                           "A plugin that computes the deformation of surface "
-                                           "vertices according to the solution of the hillslope diffusion problem. "
-                                           "Specifically, at the end of each timestep, or after a specific number "
-                                           "of timesteps, this plugin solves the following equation: "
-                                           "\\begin{align*}"
-                                           "  \\frac{\\partial h}{\\partial t} = \\kappa \\left( \\frac{\\partial^{2} h}{\\partial x^{2}} "
-                                           "+ \\frac{\\partial^{2} h}{\\partial y^{2}} \\right), "
-                                           "\\end{align*} "
-                                           "where $\\kappa$ is the hillslope diffusion coefficient (diffusivity), and $h(x,y)$ the "
-                                           "height of a point along the top boundary with respect to the surface of the unperturbed domain. "
-                                           "\n\n"
-                                           "Using this definition, the plugin then solves for one time step, i.e., "
-                                           "using as initial condition $h(t_{n-1})$ the current surface elevation, "
-                                           "and computing $h(t_n)$ from it by solving the equation above over "
-                                           "the time interval $t_n-t_{n-1}$. From this, one can then compute "
-                                           "a surface velocity $v = \\frac{h(t_n)-h(t_{n-1})}{t_n-t_{n-1}}$. "
-                                           "\n\n"
-                                           "This surface velocity is used to deform the surface and as a boundary condition "
-                                           "for solving the Laplace equation to determine the mesh velocity in the "
-                                           "domain interior. "
-                                           "Diffusion can be applied every timestep, mimicking surface processes of erosion "
-                                           "and deposition, or at a user-defined timestep interval to purely smooth the surface "
-                                           "topography to avoid too great a distortion of mesh elements when a free "
-                                           "surface is also used.")
-  }
-}
diff --git a/source/mesh_deformation/fastscape.cc.bak b/source/mesh_deformation/fastscape.cc.bak
deleted file mode 100644
index e0adde32c31..00000000000
--- a/source/mesh_deformation/fastscape.cc.bak
+++ /dev/null
@@ -1,1997 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-#include <aspect/global.h>
-
-#ifdef ASPECT_WITH_FASTSCAPE
-
-#include <aspect/mesh_deformation/fastscape.h>
-#include <aspect/geometry_model/box.h>
-#include <deal.II/numerics/vector_tools.h>
-#include <aspect/postprocess/visualization.h>
-#include <ctime>
-#include <aspect/simulator.h>
-
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    /**
-     * Define FastScape functions as C functions. Must use the exact same function/variable name
-     * and type as used in FastScape. All function names must be made lowercase, and an
-     * underscore added at the end. Types must be defined as pointers, and sent to
-     * FastScape as a reference. Additional functions are available within FastScape,
-     * see https://fastscape.org/fastscapelib-fortran/ for a list of all functions and
-     * their input parameters. These functions must be defined at the top here before
-     * they are used.
-     */
-    extern"C"
-    {
-      /**
-       * Function to initialize FastScape.
-       */
-      void fastscape_init_();
-
-      /**
-       * Set the x and y extent of the FastScape model.
-       */
-      void fastscape_set_xl_yl_(const double *xxl,
-                                const double *yyl);
-
-      /**
-       * Set number of grid points in x (nx) and y (ny)
-       */
-      void fastscape_set_nx_ny_(const unsigned int *nnx,
-                                const unsigned int *nny);
-
-      /**
-       * Allocate memory, must be called after set nx/ny.
-       */
-      void fastscape_setup_();
-
-      /**
-       * Set FastScape boundary conditions.
-       */
-      void fastscape_set_bc_(const unsigned int *jbc);
-
-      /**
-       * Set FastScape timestep. This will vary based on the ASPECT timestep.
-       */
-      void fastscape_set_dt_(const double *dtt);
-
-      /**
-       * Initialize FastScape topography.
-       */
-      void fastscape_init_h_(double *hp);
-
-      /**
-       * Initialize FastScape silt fraction during a restart.
-       */
-      void fastscape_init_f_(double *sf);
-
-      /**
-       * Set FastScape erosional parameters on land. These parameters will apply to the stream power law (SPL)
-       * and hillslope diffusion for basement and sediment. This can be set between timesteps.
-       */
-      void fastscape_set_erosional_parameters_(double *kkf,
-                                               const double *kkfsed,
-                                               const double *mm,
-                                               const double *nnn,
-                                               double *kkd,
-                                               const double *kkdsed,
-                                               const double *gg1,
-                                               const double *gg2,
-                                               const double *pp);
-
-      /**
-       * Set FastScape marine erosional parameters. This can be set between timesteps.
-       */
-      void fastscape_set_marine_parameters_(const double *sl,
-                                            const double *p1,
-                                            const double *p2,
-                                            const double *z1,
-                                            const double *z2,
-                                            const double *r,
-                                            const double *l,
-                                            const double *kds1,
-                                            const double *kds2);
-
-      /**
-       * Set advection velocities for FastScape. This can be set between timesteps.
-       */
-      void fastscape_set_v_(double *ux,
-                            double *uy);
-
-      /**
-       * Set FastScape uplift rate. This can be set between timesteps.
-       */
-      void fastscape_set_u_(double *up);
-
-      /**
-       * Set FastScape topography. This can be set between timesteps.
-       */
-      void fastscape_set_h_(double *hp);
-
-      /**
-      * Set FastScape basement. This can be set between timesteps. Sediment within FastScape
-      * is considered as the difference between the topography and basement, though this may differ
-      * from sediment as seen in ASPECT because the FastScape basement only takes the surface
-      * velocities into consideration.
-      */
-      void fastscape_set_basement_(double *b);
-
-      /**
-       * Run FastScape for a single FastScape timestep.
-       */
-      void fastscape_execute_step_();
-
-      /**
-       * Create a .VTK file for the FastScape surface within the FastScape folder of the
-       * ASPECT output folder.
-       */
-      void fastscape_named_vtk_(double *fp,
-                                const double *vexp,
-                                unsigned int *astep,
-                                const char *c,
-                                const unsigned int *length);
-
-      /**
-       * Copy the current FastScape topography.
-       */
-      void fastscape_copy_h_(double *hp);
-
-      /**
-       * Copy the current FastScape basement.
-       */
-      void fastscape_copy_basement_(double *b);
-
-      /**
-       * Copy the current FastScape silt fraction.
-       */
-      void fastscape_copy_f_(double *sf);
-
-      /**
-       * Copy the current FastScape slopes.
-       */
-      void fastscape_copy_slope_(double *slopep);
-
-      /**
-       * Destroy FastScape.
-       */
-      void fastscape_destroy_();
-    }
-
-
-    template <int dim>
-    FastScape<dim>::~FastScape ()
-    {
-      // It doesn't seem to matter if this is done on all processors or only on the one that runs
-      // FastScape as the destroy function checks if the memory is allocated.
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        fastscape_destroy_();
-    }
-
-    template <int dim>
-    void
-    FastScape<dim>::initialize ()
-    {
-      AssertThrow(Plugins::plugin_type_matches<const GeometryModel::Box<dim>>(this->get_geometry_model()),
-                  ExcMessage("FastScape can only be run with a box geometry model."));
-
-      const GeometryModel::Box<dim> *geometry
-        = dynamic_cast<const GeometryModel::Box<dim>*> (&this->get_geometry_model());
-
-      // Find the id associated with the top boundary and boundaries that call mesh deformation.
-      const types::boundary_id top_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id ("top");
-      const std::set<types::boundary_id> mesh_deformation_boundary_ids
-        = this->get_mesh_deformation_handler().get_active_mesh_deformation_boundary_indicators();
-
-      // Get the deformation type names called for each boundary.
-      std::map<types::boundary_id, std::vector<std::string>> mesh_deformation_boundary_indicators_map
-        = this->get_mesh_deformation_handler().get_active_mesh_deformation_names();
-
-      // Loop over each mesh deformation boundary, and make sure FastScape is only called on the surface.
-      for (const types::boundary_id id : mesh_deformation_boundary_ids)
-        {
-          const std::vector<std::string> &names = mesh_deformation_boundary_indicators_map[id];
-          for (const auto &name : names)
-            {
-              if (name == "fastscape")
-                AssertThrow(id == top_boundary,
-                            ExcMessage("FastScape can only be called on the surface boundary."));
-            }
-        }
-
-      // Several compositional fields are commonly used in conjunction with the FastScape plugin, i.e.
-      // "sediment_age" to track the age of the sediment deposited and "deposition_depth" to track the depth
-      // with respect to the unperturbed surface of the model domain. Their values are controlled by setting
-      // boundary conditions on the top boundary that is deformed by FastScape. While it is useful to track these
-      // fields, they are not needed for any function in the FastScape plugin. If they exist however, we need
-      // to make sure that these fields do not have the type "chemical composition" and are therefore not taken
-      // into account when computing material properties.
-      const std::vector<std::string> chemical_field_names = this->introspection().chemical_composition_field_names();
-      if (this->introspection().compositional_name_exists("sediment_age"))
-        {
-          const std::vector<std::string>::const_iterator
-          it = std::find(chemical_field_names.begin(), chemical_field_names.end(), "sediment_age");
-          AssertThrow (it == chemical_field_names.end(),
-                       ExcMessage("There is a field sediment_age that is of type chemical composition. "
-                                  "Please change it to type generic so that it does not affect material properties."));
-        }
-      if (this->introspection().compositional_name_exists("deposition_depth"))
-        {
-          const std::vector<std::string>::const_iterator
-          it = std::find(chemical_field_names.begin(), chemical_field_names.end(), "deposition_depth");
-          AssertThrow (it == chemical_field_names.end(),
-                       ExcMessage("There is a field deposition_depth that is of type chemical composition. "
-                                  "Please change it to type generic so that it does not affect material properties."));
-        }
-
-      // Initialize parameters for restarting FastScape
-      restart = this->get_parameters().resume_computation;
-
-      // Since we don't open these until we're on one process, we need to check if the
-      // restart files exist beforehand.
-      if (restart)
-        {
-          if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-            {
-              AssertThrow(Utilities::fexists(this->get_output_directory() + "fastscape_elevation_restart.txt"),
-                          ExcMessage("Cannot open topography file to restart FastScape."));
-              AssertThrow(Utilities::fexists(this->get_output_directory() + "fastscape_basement_restart.txt"),
-                          ExcMessage("Cannot open basement file to restart FastScape."));
-              AssertThrow(Utilities::fexists(this->get_output_directory() + "fastscape_silt_fraction_restart.txt"),
-                          ExcMessage("Cannot open silt fraction file to restart FastScape."));
-            }
-        }
-
-      // The first entry represents the minimum coordinates of the model domain, the second the model extent.
-      for (unsigned int d=0; d<dim; ++d)
-        {
-          grid_extent[d].first = geometry->get_origin()[d];
-          grid_extent[d].second = geometry->get_extents()[d];
-        }
-
-      // Get the x and y repetitions used in the parameter file so
-      // the FastScape cell size can be properly set.
-      const std::array<unsigned int, dim> repetitions = geometry->get_repetitions();
-
-      // Set number of x points, which is generally 1+(FastScape refinement level)^2.
-      // The FastScape refinement level is a combination of the maximum ASPECT refinement level
-      // at the surface and any additional refinement we want in FastScape. If
-      // repetitions are specified we need to adjust the number of points to match what ASPECT has,
-      // which can be determined by multiplying the points by the repetitions before adding 1.
-      // Finally, if ghost nodes are used we add two additional points on each side.
-      const unsigned int ghost_nodes = 2*use_ghost_nodes;
-      const unsigned int fastscape_refinement_level = maximum_surface_refinement_level + additional_refinement_levels;
-      const unsigned int fastscape_nodes = std::pow(2,fastscape_refinement_level);
-      fastscape_nx = fastscape_nodes * repetitions[0] + ghost_nodes + 1;
-
-      // Size of FastScape cell.
-      fastscape_dx = (grid_extent[0].second)/(fastscape_nodes * repetitions[0]);
-
-      // FastScape X extent, which is generally ASPECT's extent unless the ghost nodes are used,
-      // in which case 2 cells are added on either side.
-      fastscape_x_extent = (grid_extent[0].second) + fastscape_dx * ghost_nodes;
-
-      // Sub intervals are 3 less than points, if including the ghost nodes. Otherwise 1 less.
-      table_intervals[0] = fastscape_nodes * repetitions[0];
-      table_intervals[dim-1] = 1;
-
-      if (dim == 2)
-        {
-          fastscape_dy = fastscape_dx;
-          fastscape_y_extent = round(fastscape_y_extent_2d/fastscape_dy)*fastscape_dy + fastscape_dy * ghost_nodes;
-          fastscape_ny = 1+fastscape_y_extent/fastscape_dy;
-        }
-      else
-        {
-          fastscape_ny = fastscape_nodes * repetitions[1] + ghost_nodes + 1;
-          fastscape_dy = (grid_extent[1].second)/(fastscape_nodes * repetitions[1]);
-          table_intervals[1] = fastscape_nodes * repetitions[1];
-          fastscape_y_extent = (grid_extent[1].second) + fastscape_dy * ghost_nodes;
-        }
-
-      // Create a folder for the FastScape visualization files.
-      Utilities::create_directory (this->get_output_directory() + "fastscape/",
-                                   this->get_mpi_communicator(),
-                                   false);
-
-      last_output_time = 0;
-    }
-
-
-    template <int dim>
-    void
-    FastScape<dim>::compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                             AffineConstraints<double> &mesh_velocity_constraints,
-                                                             const std::set<types::boundary_id> &boundary_ids) const
-    {
-
-      // Because there is no increase in time during timestep 0, we return and only
-      // initialize and run FastScape from timestep 1 and on.
-      if (this->get_timestep_number() == 0)
-        return;
-
-      TimerOutput::Scope timer_section(this->get_computing_timer(), "FastScape plugin");
-
-      const unsigned int current_timestep = this->get_timestep_number ();
-      const double aspect_timestep_in_years = this->get_timestep() / year_in_seconds;
-
-      // Find a FastScape timestep that is below our maximum timestep.
-      unsigned int fastscape_iterations = fastscape_steps_per_aspect_step;
-      double fastscape_timestep_in_years = aspect_timestep_in_years/fastscape_iterations;
-      while (fastscape_timestep_in_years>maximum_fastscape_timestep)
-        {
-          fastscape_iterations *= 2;
-          fastscape_timestep_in_years *= 0.5;
-        }
-
-      // Vector to hold the velocities that represent the change to the surface.
-      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
-      std::vector<double> mesh_velocity_z(fastscape_array_size);
-
-      // FastScape requires multiple specially defined and ordered variables sent to its functions. To make
-      // the transfer of these down to one process easier, we first fill out a vector of local_aspect_values,
-      // then when we get down to one process we use these local_aspect_values to fill the double arrays
-      // in the order needed for FastScape.
-      std::vector<std::vector<double>> local_aspect_values = get_aspect_values();
-
-      // Run FastScape on single process.
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          // Initialize the variables that will be sent to FastScape.
-          // Elevation is initialized at a very high number so that we can later check that all points
-          // received data from ASPECT, and if not throw an assert.
-          std::vector<double> elevation(fastscape_array_size, std::numeric_limits<double>::max());
-          std::vector<double> velocity_x(fastscape_array_size);
-          std::vector<double> velocity_y(fastscape_array_size);
-          std::vector<double> velocity_z(fastscape_array_size);
-          std::vector<double> bedrock_river_incision_rate_array(fastscape_array_size);
-          std::vector<double> bedrock_transport_coefficient_array(fastscape_array_size);
-          std::vector<double> basement(fastscape_array_size);
-          std::vector<double> silt_fraction(fastscape_array_size);
-          std::vector<double> elevation_old(fastscape_array_size);
-
-          fill_fastscape_arrays(elevation,
-                                bedrock_transport_coefficient_array,
-                                bedrock_river_incision_rate_array,
-                                velocity_x,
-                                velocity_y,
-                                velocity_z,
-                                local_aspect_values);
-
-          if (current_timestep == 1 || restart)
-            {
-              this->get_pcout() << "   Initializing FastScape... " << (1+maximum_surface_refinement_level+additional_refinement_levels) <<
-                                " levels, cell size: " << fastscape_dx << " m." << std::endl;
-
-              // Set ghost nodes before initializing.
-              if (use_ghost_nodes && !restart)
-                set_ghost_nodes(elevation,
-                                velocity_x,
-                                velocity_y,
-                                velocity_z,
-                                fastscape_timestep_in_years,
-                                true);
-
-              // If we are restarting from a checkpoint, load h values for FastScape instead of using the ASPECT values.
-              if (restart)
-                {
-                  read_restart_files(elevation,
-                                     basement,
-                                     silt_fraction);
-
-                  restart = false;
-                }
-
-              initialize_fastscape(elevation,
-                                   basement,
-                                   bedrock_transport_coefficient_array,
-                                   bedrock_river_incision_rate_array,
-                                   silt_fraction);
-            }
-          else
-            {
-              // If it isn't the first timestep we ignore initialization and instead copy all height values from FastScape.
-              // Generally, we overwrite the topography data from ASPECT as FastScape may be at a higher resolution. However,
-              // if we are not using FastScape to advect then we do not want to do this and instead use the ASPECT values.
-              if (fastscape_advection_uplift)
-                fastscape_copy_h_(elevation.data());
-            }
-
-          // Find the appropriate sediment rain based off the time interval.
-          const double time_in_years = this->get_time() / year_in_seconds;
-          auto it = std::lower_bound(sediment_rain_times.begin(), sediment_rain_times.end(), time_in_years);
-          const unsigned int inds = std::distance(sediment_rain_times.begin(), it);
-          const double sediment_rain = sediment_rain_rates[inds];
-
-          // Keep initial h values so we can calculate velocity later.
-          // In the first timestep, h will be given from other processes.
-          // In later timesteps, we copy h directly from FastScape.
-          std::mt19937 random_number_generator(fastscape_seed);
-          std::uniform_real_distribution<double> random_distribution(-noise_elevation,noise_elevation);
-          for (unsigned int i=0; i<fastscape_array_size; ++i)
-            {
-              elevation_old[i] = elevation[i];
-
-              // Initialize random noise after elevation_old is set, so ASPECT sees this initial topography change.
-              // Changing boundary height directly on a fixed FastScape boundary causes reproducibility issues,
-              // as such we do not add noise to the boundaries regardless of whether they are ghost nodes
-              // or not. However, the boundaries can be changed using the uplift velocity and not cause
-              // these issues.
-              // TODO: Should this be done through velocities instead of a flat height change?
-              if (!is_ghost_node(i,true))
-                {
-                  if (current_timestep == 1)
-                    {
-                      // + or - topography based on the initial noise magnitude.
-                      const double elevation_seed = random_distribution(random_number_generator);
-                      elevation[i] = elevation[i] + elevation_seed;
-                    }
-
-                  // Here we add the sediment rain (m/yr) as a flat increase in height.
-                  // This is done because adding it as an uplift rate would affect the basement.
-                  if (sediment_rain > 0 && use_marine_component)
-                    {
-                      // Only apply sediment rain to areas below sea level.
-                      if (elevation[i] < sea_level)
-                        {
-                          // If the rain would put us above sea level, set height to sea level.
-                          if (elevation[i] + sediment_rain*aspect_timestep_in_years > sea_level)
-                            elevation[i] = sea_level;
-                          else
-                            elevation[i] = std::min(sea_level,elevation[i] + sediment_rain*aspect_timestep_in_years);
-                        }
-                    }
-                }
-            }
-
-          // The ghost nodes are added as a single layer of points surrounding the entire model.
-          // For example, if ASPECT's surface mesh is a 2D surface that is 3x3 (nx x ny) points,
-          // FastScape will be set as a 2D 5x5 point surface. On return to ASPECT, the outer ghost nodes
-          // will be ignored, and ASPECT will see only the inner 3x3 surface of FastScape.
-          if (use_ghost_nodes)
-            set_ghost_nodes(elevation,
-                            velocity_x,
-                            velocity_y,
-                            velocity_z,
-                            fastscape_timestep_in_years,
-                            false);
-
-          // If specified, apply the orographic controls to the FastScape model.
-          if (use_orographic_controls)
-            apply_orographic_controls(elevation,
-                                      bedrock_transport_coefficient_array,
-                                      bedrock_river_incision_rate_array);
-
-          // Set velocity components.
-          if (fastscape_advection_uplift)
-            {
-              fastscape_set_u_(velocity_z.data());
-              fastscape_set_v_(velocity_x.data(),
-                               velocity_y.data());
-            }
-
-          // Set h to new values, and erosional parameters if there have been changes.
-          fastscape_set_h_(elevation.data());
-
-          fastscape_set_erosional_parameters_(bedrock_river_incision_rate_array.data(),
-                                              &sediment_river_incision_rate,
-                                              &drainage_area_exponent_m,
-                                              &slope_exponent_n,
-                                              bedrock_transport_coefficient_array.data(),
-                                              &sediment_transport_coefficient,
-                                              &bedrock_deposition_g,
-                                              &sediment_deposition_g,
-                                              &slope_exponent_p);
-
-          // Find timestep size, run FastScape, and make visualizations.
-          execute_fastscape(elevation,
-                            bedrock_transport_coefficient_array,
-                            velocity_x,
-                            velocity_y,
-                            velocity_z,
-                            fastscape_timestep_in_years,
-                            fastscape_iterations);
-
-          // Write a file to store h, b & step for restarting.
-          // TODO: It would be good to roll this into the general ASPECT checkpointing,
-          // and when we do this needs to be changed.
-          if (((this->get_parameters().checkpoint_time_secs == 0) &&
-               (this->get_parameters().checkpoint_steps > 0) &&
-               ((current_timestep + 1) % this->get_parameters().checkpoint_steps == 0)) ||
-              (this->get_time() == this->get_end_time() && this->get_timestepping_manager().need_checkpoint_on_terminate()))
-            {
-              save_restart_files(elevation,
-                                 basement,
-                                 silt_fraction);
-            }
-
-          // Find out our velocities from the change in height.
-          // Where mesh_velocity_z is a vector of array size that exists on all processes.
-          for (unsigned int i=0; i<fastscape_array_size; ++i)
-            {
-              mesh_velocity_z[i] = (elevation[i] - elevation_old[i])/aspect_timestep_in_years;
-            }
-
-          Utilities::MPI::broadcast(this->get_mpi_communicator(), mesh_velocity_z, 0);
-        }
-      else
-        {
-          for (unsigned int i=0; i<local_aspect_values.size(); ++i)
-            MPI_Ssend(&local_aspect_values[i][0], local_aspect_values[1].size(), MPI_DOUBLE, 0, 42, this->get_mpi_communicator());
-
-          // Check whether the FastScape mesh was filled with data.
-          const bool fastscape_mesh_filled = Utilities::MPI::broadcast (this->get_mpi_communicator(), true, 0);
-          if (fastscape_mesh_filled != true)
-            throw aspect::QuietException();
-
-          // This is called solely so we can set the timer and will return immediately.
-          execute_fastscape(mesh_velocity_z,
-                            mesh_velocity_z,
-                            mesh_velocity_z,
-                            mesh_velocity_z,
-                            mesh_velocity_z,
-                            aspect_timestep_in_years,
-                            fastscape_steps_per_aspect_step);
-
-          mesh_velocity_z = Utilities::MPI::broadcast(this->get_mpi_communicator(), mesh_velocity_z, 0);
-        }
-
-      // Get the sizes needed for a data table of the mesh velocities.
-      TableIndices<dim> size_idx;
-      for (unsigned int d=0; d<dim; ++d)
-        {
-          size_idx[d] = table_intervals[d]+1;
-        }
-
-      // Initialize a table to hold all velocity values that will be interpolated back to ASPECT.
-      const Table<dim,double> velocity_table = fill_data_table(mesh_velocity_z, size_idx, fastscape_nx, fastscape_ny);
-
-      // As our grid_extent variable end points do not account for the change related to an origin
-      // not at 0, we adjust this here into an interpolation extent.
-      std::array<std::pair<double,double>,dim> interpolation_extent;
-      for (unsigned int d=0; d<dim; ++d)
-        {
-          interpolation_extent[d].first = grid_extent[d].first;
-          interpolation_extent[d].second = (grid_extent[d].second + grid_extent[d].first);
-        }
-
-      //Functions::InterpolatedUniformGridData<dim> *velocities;
-      Functions::InterpolatedUniformGridData<dim> velocities (interpolation_extent,
-                                                              table_intervals,
-                                                              velocity_table);
-
-      VectorFunctionFromScalarFunctionObject<dim> vector_function_object(
-        [&](const Point<dim> &p) -> double
-      {
-        return velocities.value(p);
-      },
-      dim-1,
-      dim);
-
-      VectorTools::interpolate_boundary_values (mesh_deformation_dof_handler,
-                                                *boundary_ids.begin(),
-                                                vector_function_object,
-                                                mesh_velocity_constraints);
-    }
-
-
-    template <int dim>
-    std::vector<std::vector<double>>
-    FastScape<dim>::get_aspect_values() const
-    {
-
-      const types::boundary_id relevant_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id ("top");
-      std::vector<std::vector<double>> local_aspect_values(dim+2, std::vector<double>());
-
-      // Get a quadrature rule that exists only on the corners, and increase the refinement if specified.
-      const QIterated<dim-1> face_corners (QTrapezoid<1>(),
-                                           std::pow(2,additional_refinement_levels+surface_refinement_difference));
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        face_corners,
-                                        update_values |
-                                        update_quadrature_points);
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          for (unsigned int face_no = 0; face_no < GeometryInfo<dim>::faces_per_cell; ++face_no)
-            if (cell->face(face_no)->at_boundary())
-              {
-                if ( cell->face(face_no)->boundary_id() != relevant_boundary)
-                  continue;
-
-                std::vector<Tensor<1,dim>> vel(face_corners.size());
-                fe_face_values.reinit(cell, face_no);
-                fe_face_values[this->introspection().extractors.velocities].get_function_values(this->get_solution(), vel);
-
-                for (unsigned int corner = 0; corner < face_corners.size(); ++corner)
-                  {
-                    const Point<dim> vertex = fe_face_values.quadrature_point(corner);
-
-                    // Find what x point we're at. Add 1 or 2 depending on if ghost nodes are used.
-                    // Subtract the origin point so that it corresponds to an origin of 0,0 in FastScape.
-                    const double indx = 1+use_ghost_nodes+(vertex(0) - grid_extent[0].first)/fastscape_dx;
-
-                    // The quadrature rule is created so that there are enough interpolation points in the
-                    // lowest resolved ASPECT surface cell to fill out the FastScape mesh. However, as the
-                    // same rule is used for all cell sizes, higher resolution areas will have interpolation
-                    // points that do not correspond to a FastScape node. In which case, indx will not be a
-                    // whole number and we can ignore the point.
-                    if (std::abs(indx - round(indx)) >= node_tolerance)
-                      continue;
-
-
-                    // If we're in 2D, we want to take the values and apply them to every row of X points.
-                    if (dim == 2)
-                      {
-                        for (unsigned int ys=0; ys<fastscape_ny; ++ys)
-                          {
-                            // FastScape indexes from 1 to n, starting at X and Y = 0, and increases
-                            // across the X row. At the end of the row, it jumps back to X = 0
-                            // and up to the next X row in increasing Y direction. We track
-                            // this to correctly place the variables later on.
-                            // Nx*ys effectively tells us what row we are in
-                            // and then indx tells us what position in that row.
-                            const double index = round(indx)+fastscape_nx*ys;
-
-                            local_aspect_values[0].push_back(vertex(dim-1) - grid_extent[dim-1].second);
-                            local_aspect_values[1].push_back(index-1);
-
-                            for (unsigned int d=0; d<dim; ++d)
-                              {
-                                // Always convert to m/yr for FastScape
-                                local_aspect_values[2+d].push_back(vel[corner][d]*year_in_seconds);
-                              }
-                          }
-                      }
-                    // 3D case
-                    else
-                      {
-                        // Because indy only gives us the row we're in, we don't need to add 2 for the ghost node.
-                        const double indy = 1+use_ghost_nodes+(vertex(1) - grid_extent[1].first)/fastscape_dy;
-
-                        if (std::abs(indy - round(indy)) >= node_tolerance)
-                          continue;
-
-                        const double index = round((indy-1))*fastscape_nx+round(indx);
-
-                        local_aspect_values[0].push_back(vertex(dim-1) - grid_extent[dim-1].second);   //z component
-                        local_aspect_values[1].push_back(index-1);
-
-                        for (unsigned int d=0; d<dim; ++d)
-                          {
-                            local_aspect_values[2+d].push_back(vel[corner][d]*year_in_seconds);
-                          }
-                      }
-                  }
-              }
-
-      return local_aspect_values;
-    }
-
-
-    template <int dim>
-    void FastScape<dim>::fill_fastscape_arrays(std::vector<double> &elevation,
-                                               std::vector<double> &bedrock_transport_coefficient_array,
-                                               std::vector<double> &bedrock_river_incision_rate_array,
-                                               std::vector<double> &velocity_x,
-                                               std::vector<double> &velocity_y,
-                                               std::vector<double> &velocity_z,
-                                               std::vector<std::vector<double>> &local_aspect_values) const
-    {
-      for (unsigned int i=0; i<local_aspect_values[1].size(); ++i)
-        {
-
-          unsigned int index = local_aspect_values[1][i];
-          elevation[index] = local_aspect_values[0][i];
-          velocity_x[index] = local_aspect_values[2][i];
-          velocity_z[index] = local_aspect_values[dim+1][i];
-
-          if (dim == 2)
-            velocity_y[index] = 0;
-          else
-            velocity_y[index] = local_aspect_values[3][i];
-        }
-
-      for (unsigned int p=1; p<Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()); ++p)
-        {
-          // First, find out the size of the array a process wants to send.
-          MPI_Status status;
-          MPI_Probe(p, 42, this->get_mpi_communicator(), &status);
-          int incoming_size = 0;
-          MPI_Get_count(&status, MPI_DOUBLE, &incoming_size);
-
-          // Resize the array so it fits whatever the process sends.
-          for (unsigned int i=0; i<local_aspect_values.size(); ++i)
-            {
-              local_aspect_values[i].resize(incoming_size);
-            }
-
-          for (unsigned int i=0; i<local_aspect_values.size(); ++i)
-            MPI_Recv(&local_aspect_values[i][0], incoming_size, MPI_DOUBLE, p, 42, this->get_mpi_communicator(), &status);
-
-          // Now, place the numbers into the correct place based off the index.
-          for (unsigned int i=0; i<local_aspect_values[1].size(); ++i)
-            {
-              const unsigned int index = local_aspect_values[1][i];
-              elevation[index] = local_aspect_values[0][i];
-              velocity_x[index] = local_aspect_values[2][i];
-              velocity_z[index] = local_aspect_values[dim+1][i];
-
-              // In 2D there are no y velocities, so we set them to zero.
-              if (dim == 2 )
-                velocity_y[index] = 0;
-              else
-                velocity_y[index] = local_aspect_values[3][i];
-            }
-        }
-
-      // Initialize the bedrock river incision rate and transport coefficient,
-      // and check that there are no empty mesh points due to
-      // an improperly set maximum_surface_refinement_level, additional_refinement_levels,
-      // and surface_refinement_difference
-      bool fastscape_mesh_filled = true;
-      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
-      for (unsigned int i=0; i<fastscape_array_size; ++i)
-        {
-          bedrock_river_incision_rate_array[i] = bedrock_river_incision_rate;
-          bedrock_transport_coefficient_array[i] = bedrock_transport_coefficient;
-
-          // If this is a boundary node that is a ghost node then ignore that it
-          // has not filled yet as the ghost nodes haven't been set.
-          if (elevation[i] == std::numeric_limits<double>::max() && !is_ghost_node(i,false))
-            fastscape_mesh_filled = false;
-        }
-
-      Utilities::MPI::broadcast(this->get_mpi_communicator(), fastscape_mesh_filled, 0);
-      AssertThrow (fastscape_mesh_filled == true,
-                   ExcMessage("The FastScape mesh is missing data. A likely cause for this is that the "
-                              "maximum surface refinement or surface refinement difference are improperly set."));
-    }
-
-
-    template <int dim>
-    void FastScape<dim>::initialize_fastscape(std::vector<double> &elevation,
-                                              std::vector<double> &basement,
-                                              std::vector<double> &bedrock_transport_coefficient_array,
-                                              std::vector<double> &bedrock_river_incision_rate_array,
-                                              std::vector<double> &silt_fraction) const
-    {
-      Assert (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0, ExcInternalError());
-
-      const unsigned int current_timestep = this->get_timestep_number ();
-
-      // Initialize FastScape with grid and extent.
-      fastscape_init_();
-      fastscape_set_nx_ny_(&fastscape_nx,
-                           &fastscape_ny);
-      fastscape_setup_();
-      fastscape_set_xl_yl_(&fastscape_x_extent,
-                           &fastscape_y_extent);
-
-      // Set boundary conditions
-      fastscape_set_bc_(&fastscape_boundary_conditions);
-
-      // Initialize topography
-      fastscape_init_h_(elevation.data());
-
-      // Set erosional parameters.
-      fastscape_set_erosional_parameters_(bedrock_river_incision_rate_array.data(),
-                                          &sediment_river_incision_rate,
-                                          &drainage_area_exponent_m,
-                                          &slope_exponent_n,
-                                          bedrock_transport_coefficient_array.data(),
-                                          &sediment_transport_coefficient,
-                                          &bedrock_deposition_g,
-                                          &sediment_deposition_g,
-                                          &slope_exponent_p);
-
-      if (use_marine_component)
-        fastscape_set_marine_parameters_(&sea_level,
-                                         &sand_surface_porosity,
-                                         &silt_surface_porosity,
-                                         &sand_efold_depth,
-                                         &silt_efold_depth,
-                                         &sand_silt_ratio,
-                                         &sand_silt_averaging_depth,
-                                         &sand_transport_coefficient,
-                                         &silt_transport_coefficient);
-
-      // Only set the basement and silt_fraction if it's a restart
-      if (current_timestep != 1)
-        {
-          fastscape_set_basement_(basement.data());
-          if (use_marine_component)
-            fastscape_init_f_(silt_fraction.data());
-        }
-
-    }
-
-
-    template <int dim>
-    void FastScape<dim>::execute_fastscape(std::vector<double> &elevation,
-                                           std::vector<double> &extra_vtk_field,
-                                           std::vector<double> &velocity_x,
-                                           std::vector<double> &velocity_y,
-                                           std::vector<double> &velocity_z,
-                                           const double &fastscape_timestep_in_years,
-                                           const unsigned int &fastscape_iterations) const
-    {
-      TimerOutput::Scope timer_section(this->get_computing_timer(), "Execute FastScape");
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) != 0)
-        return;
-
-      // Because on the first timestep we will create an initial VTK file before running FastScape
-      // and a second after, we first set the visualization step to zero.
-      unsigned int visualization_step = 0;
-      const unsigned int current_timestep = this->get_timestep_number ();
-      std::string dirname = (this->get_output_directory() + "fastscape/");
-      const char *dirname_char=dirname.c_str();
-      const unsigned int dirname_length = dirname.length();
-
-      // Set time step
-      fastscape_set_dt_(&fastscape_timestep_in_years);
-      this->get_pcout() << "   Executing FastScape... " << (fastscape_iterations) << " timesteps of " << fastscape_timestep_in_years << " years." << std::endl;
-      {
-        // If it is the first timestep, write an initial VTK file.
-        if (current_timestep == 1)
-          {
-            this->get_pcout() << "      Writing initial VTK..." << std::endl;
-            // FastScape by default visualizes a field called HHHHH,
-            // and the parameter this shows will be whatever is given as the first
-            // position. At the moment it visualizes the bedrock diffusivity.
-            fastscape_named_vtk_(extra_vtk_field.data(),
-                                 &vexp,
-                                 &visualization_step,
-                                 dirname_char,
-                                 &dirname_length);
-          }
-
-        for (unsigned int fastscape_iteration = 0; fastscape_iteration < fastscape_iterations; ++fastscape_iteration)
-          {
-            fastscape_execute_step_();
-
-            // If we are using the ghost nodes we want to reset them every FastScape timestep.
-            if (use_ghost_nodes)
-              {
-                fastscape_copy_h_(elevation.data());
-
-                set_ghost_nodes(elevation,
-                                velocity_x,
-                                velocity_y,
-                                velocity_z,
-                                fastscape_timestep_in_years,
-                                false);
-
-                // Set velocity components.
-                if (fastscape_advection_uplift)
-                  {
-                    fastscape_set_u_(velocity_z.data());
-                    fastscape_set_v_(velocity_x.data(),
-                                     velocity_y.data());
-                  }
-
-                // Set h to new values, and erosional parameters if there have been changes.
-                fastscape_set_h_(elevation.data());
-              }
-          }
-
-        // Copy h values.
-        fastscape_copy_h_(elevation.data());
-
-
-        // Determine whether to create a VTK file this timestep.
-        bool write_vtk = false;
-
-        if (this->get_time() >= last_output_time + output_interval || this->get_time() == this->get_end_time())
-          {
-            write_vtk = true;
-
-            if (output_interval > 0)
-              {
-                // We need to find the last time output was supposed to be written.
-                // this is the last_output_time plus the largest positive multiple
-                // of output_intervals that passed since then. We need to handle the
-                // edge case where last_output_time+output_interval==current_time,
-                // we did an output and std::floor sadly rounds to zero. This is done
-                // by forcing std::floor to round 1.0-eps to 1.0.
-                const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-                last_output_time = last_output_time + std::floor((this->get_time()-last_output_time)/output_interval*magic) * output_interval/magic;
-              }
-          }
-
-        if (write_vtk)
-          {
-            this->get_pcout() << "      Writing FastScape VTK..." << std::endl;
-            visualization_step = current_timestep;
-            fastscape_named_vtk_(extra_vtk_field.data(),
-                                 &vexp,
-                                 &visualization_step,
-                                 dirname_char,
-                                 &dirname_length);
-          }
-      }
-    }
-
-
-    template <int dim>
-    void FastScape<dim>::apply_orographic_controls(const std::vector<double> &elevation,
-                                                   std::vector<double> &bedrock_transport_coefficient_array,
-                                                   std::vector<double> &bedrock_river_incision_rate_array) const
-    {
-      // First for the wind barrier, we find the maximum height and index
-      // along each line in the x and y direction.
-      // If wind is east or west, we find maximum point for each ny row along x.
-      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
-      std::vector<std::vector<double>> max_elevation_along_x(2, std::vector<double>(fastscape_ny, 0.0));
-      if (wind_direction == 0 || wind_direction == 1)
-        {
-          for (unsigned int i=0; i<fastscape_ny; ++i)
-            {
-              for (unsigned int j=0; j<fastscape_nx; ++j)
-                {
-                  if ( elevation[fastscape_nx*i+j] > max_elevation_along_x[0][i])
-                    {
-                      // Maximum elevation value along the ny row.
-                      max_elevation_along_x[0][i] = elevation[fastscape_nx*i+j];
-                      // Location of maximum elevation.
-                      max_elevation_along_x[1][i] = j;
-                    }
-                }
-            }
-        }
-
-      // If wind is north or south, we find maximum point for each nx row along y.
-      std::vector<std::vector<double>> max_elevation_along_y(2, std::vector<double>(fastscape_nx, 0.0));
-      if (wind_direction == 2 || wind_direction == 3)
-        {
-          for (unsigned int i=0; i<fastscape_nx; ++i)
-            {
-              for (unsigned int j=0; j<fastscape_ny; ++j)
-                {
-                  if ( elevation[fastscape_nx*j+i] > max_elevation_along_y[0][i])
-                    {
-                      max_elevation_along_y[0][i] = elevation[fastscape_nx*j+i];
-                      max_elevation_along_y[1][i] = j;
-                    }
-                }
-            }
-        }
-
-      // Now we loop through all the points again and apply the factors.
-      std::vector<double> control_applied(fastscape_array_size, 0);
-      for (unsigned int i=0; i<fastscape_ny; ++i)
-        {
-          // Factor from wind barrier. Apply a switch based off wind direction.
-          // Where 0 is wind going to the west, 1 the east, 2 the south, and 3 the north.
-          for (unsigned int j=0; j<fastscape_nx; ++j)
-            {
-              switch (wind_direction)
-                {
-                  case 0 :
-                  {
-                    // If we are above the set elevation, and on the correct side based on the wind direction apply
-                    // the factor. Apply this regardless of whether or not we stack controls.
-                    if ( (max_elevation_along_x[0][i] > wind_barrier_elevation) && (j < max_elevation_along_x[1][i]) )
-                      {
-                        bedrock_river_incision_rate_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
-                        bedrock_transport_coefficient_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
-                        control_applied[fastscape_nx*i+j] = 1;
-                      }
-                    break;
-                  }
-                  case 1 :
-                  {
-                    if ( (max_elevation_along_x[0][i] > wind_barrier_elevation) && (j > max_elevation_along_x[1][i]) )
-                      {
-                        bedrock_river_incision_rate_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
-                        bedrock_transport_coefficient_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
-                        control_applied[fastscape_nx*i+j] = 1;
-                      }
-                    break;
-                  }
-                  case 2 :
-                  {
-                    if ( (max_elevation_along_y[0][j] > wind_barrier_elevation) && (i > max_elevation_along_y[1][j]) )
-                      {
-                        bedrock_river_incision_rate_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
-                        bedrock_transport_coefficient_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
-                        control_applied[fastscape_nx*i+j] = 1;
-                      }
-                    break;
-                  }
-                  case 3 :
-                  {
-                    if ( (max_elevation_along_y[0][j] > wind_barrier_elevation) && (i < max_elevation_along_y[1][j]) )
-                      {
-                        bedrock_river_incision_rate_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
-                        bedrock_transport_coefficient_array[fastscape_nx*i+j] *= wind_barrier_erosional_factor;
-                        control_applied[fastscape_nx*i+j] = 1;
-                      }
-                    break;
-                  }
-                  default :
-                    AssertThrow(false, ExcMessage("This does not correspond with a wind direction."));
-                    break;
-                }
-
-              // If we are above the flat elevation and stack controls, apply the flat elevation factor. If we are not
-              // stacking controls, apply the factor if the wind barrier was not applied to this point.
-              if (elevation[fastscape_nx*i+j] > flat_elevation)
-                {
-                  if ( stack_controls==true || !stack_controls && (control_applied[fastscape_nx*i+j]==0) )
-                    {
-                      bedrock_river_incision_rate_array[fastscape_nx*i+j] *= flat_erosional_factor;
-                      bedrock_transport_coefficient_array[fastscape_nx*i+j] *= flat_erosional_factor;
-                    }
-                  // If we are not stacking controls and the wind barrier was applied to this point, only
-                  // switch to this control if the factor is greater.
-                  else if ( stack_controls==false && (control_applied[fastscape_nx*i+j]==1) && (flat_erosional_factor > wind_barrier_erosional_factor) )
-                    {
-                      if ( wind_barrier_erosional_factor != 0)
-                        {
-                          bedrock_river_incision_rate_array[fastscape_nx*i+j] = (bedrock_river_incision_rate_array[fastscape_nx*i+j]/wind_barrier_erosional_factor)*flat_erosional_factor;
-                          bedrock_transport_coefficient_array[fastscape_nx*i+j] = (bedrock_transport_coefficient_array[fastscape_nx*i+j]/wind_barrier_erosional_factor)*flat_erosional_factor;
-                        }
-                      // If a wind barrier factor of zero was applied for some reason, we set it back to the default
-                      // and apply the flat_erosional_factor.
-                      else
-                        {
-                          bedrock_river_incision_rate_array[fastscape_nx*i+j] = bedrock_river_incision_rate*flat_erosional_factor;
-                          bedrock_transport_coefficient_array[fastscape_nx*i+j] = bedrock_transport_coefficient*flat_erosional_factor;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-
-    template <int dim>
-    void FastScape<dim>::set_ghost_nodes(std::vector<double> &elevation,
-                                         std::vector<double> &velocity_x,
-                                         std::vector<double> &velocity_y,
-                                         std::vector<double> &velocity_z,
-                                         const double &fastscape_timestep_in_years,
-                                         const bool init) const
-    {
-      // Copy the slopes at each point, this will be used to set an H
-      // at the ghost nodes if a boundary mass flux is given.
-      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
-      std::vector<double> slopep(fastscape_array_size);
-
-      if (!init)
-        fastscape_copy_slope_(slopep.data());
-
-      // Here we set the ghost nodes at the left and right boundaries. In most cases,
-      // this involves setting the node to the same values of v and h as the inward node.
-      // With the inward node being above or below for the bottom and top rows of ghost nodes,
-      // or to the left and right for the right and left columns of ghost nodes.
-      for (unsigned int j=0; j<fastscape_ny; ++j)
-        {
-          // Nx*j will give us the row we're in, and one is subtracted as FastScape starts from 1 not zero.
-          // If we're on the left, the multiple of the row will always represent the first node.
-          // Subtracting one from the row above this gives us the last node of the previous row.
-          const unsigned int index_left = fastscape_nx*j;
-          const unsigned int index_right = fastscape_nx*(j+1)-1;
-          double slope = 0;
-
-          // Here we set the ghost nodes to the value of the nodes next to them, where for the left we
-          // add one to go to the node to the right, and for the right side
-          // we subtract one to go to the inner node to the left.
-          // For velocities, this is done whether it is the call before
-          // initialization or not.
-          if (left == 0 || !use_fixed_erosional_base)
-            {
-              velocity_z[index_left] = velocity_z[index_left+1];
-              velocity_y[index_left] = velocity_y[index_left+1];
-              velocity_x[index_left] = velocity_x[index_left+1];
-            }
-
-          if (right == 0 || !use_fixed_erosional_base)
-            {
-              velocity_z[index_right] = velocity_z[index_right-1];
-              velocity_y[index_right] = velocity_y[index_right-1];
-              velocity_x[index_right] = velocity_x[index_right-1];
-            }
-
-          if (init)
-            {
-              // We need to set h on initialization. If we use a fixed base level we set it to
-              // the user specified base level. If it is open or we do not have a fixed base, we
-              // will set it equal to the node next to it, and finally adjust based on user-defined
-              // influx if necessary. FastScape calculates the slope by looking at all
-              // nodes surrounding the point so we need to consider the slope over 2 dx.
-              slope = left_flux/bedrock_transport_coefficient;
-              if (left == 1 && use_fixed_erosional_base)
-                elevation[index_left] = h_erosional_base;
-              else
-                elevation[index_left] = elevation[index_left+1] + slope*2*fastscape_dx;
-
-              slope = right_flux/bedrock_transport_coefficient;
-              if (right == 1 && use_fixed_erosional_base)
-                elevation[index_right] = h_erosional_base;
-              else
-                elevation[index_right] = elevation[index_right-1] + slope*2*fastscape_dx;
-            }
-
-          if (left == 0 && !init)
-            {
-              // If it is not the initialization step, we set the h value for open boundaries depending on
-              // whether or not there is prescribed influx.
-              // If we have flux through a boundary, we need to update the height to keep the correct slope.
-              // Because the corner nodes always show a slope of zero, this will update them according to
-              // the closest non-ghost node. E.g. if we're at a corner node, look instead up a row and inward.
-              // If this is no flux, we set the node to the one next to it.
-              if (left_flux > 0)
-                {
-                  slope = 0;
-                  if (j == 0)
-                    slope = left_flux / bedrock_transport_coefficient - std::tan(slopep[index_left + fastscape_nx + 1] * numbers::PI / 180.);
-                  else if (j == (fastscape_ny - 1))
-                    slope = left_flux / bedrock_transport_coefficient - std::tan(slopep[index_left - fastscape_nx + 1] * numbers::PI / 180.);
-                  else
-                    slope = left_flux / bedrock_transport_coefficient - std::tan(slopep[index_left + 1] * numbers::PI / 180.);
-
-                  elevation[index_left] = elevation[index_left] + slope * 2 * fastscape_dx;
-                }
-              else
-                elevation[index_left] = elevation[index_left + 1];
-            }
-
-          if (right == 0 && !init)
-            {
-
-              if (right_flux > 0)
-                {
-                  slope = 0;
-                  if (j == 0)
-                    slope = right_flux / bedrock_transport_coefficient - std::tan(slopep[index_right + fastscape_nx - 1] * numbers::PI / 180.);
-                  else if (j == (fastscape_ny - 1))
-                    slope = right_flux / bedrock_transport_coefficient - std::tan(slopep[index_right - fastscape_nx - 1] * numbers::PI / 180.);
-                  else
-                    slope = right_flux / bedrock_transport_coefficient - std::tan(slopep[index_right - 1] * numbers::PI / 180.);
-
-                  elevation[index_right] = elevation[index_right] + slope * 2 * fastscape_dx;
-                }
-              else
-                elevation[index_right] = elevation[index_right - 1];
-
-
-            }
-
-          // If the boundaries are periodic, then we look at the velocities on both sides of the
-          // model, and set the ghost node according to the direction of flow. As FastScape will
-          // receive all velocities it will have a direction, and we only need to look at the (non-ghost)
-          // nodes directly to the left and right.
-          if (left == 0 && right == 0 || leftright_ghost_nodes_periodic == true)
-            {
-              // First we assume that flow is going to the left.
-              unsigned int side = index_left;
-              unsigned int op_side = index_right;
-
-              // Indexing depending on which side the ghost node is being set to.
-              int jj = 1;
-
-              // If nodes on both sides are going the same direction, then set the respective
-              // ghost nodes to equal these sides. By doing this, the ghost nodes at the opposite
-              // side of flow will work as a mirror mimicking what is happening on the other side.
-              if (velocity_x[index_right-1] > 0 && velocity_x[index_left+1] >= 0)
-                {
-                  side = index_right;
-                  op_side = index_left;
-                  jj = -1;
-                }
-              else if (velocity_x[index_right-1] <= 0 && velocity_x[index_left+1] < 0)
-                {
-                  side = index_left;
-                  op_side = index_right;
-                  jj = 1;
-                }
-              else
-                continue;
-
-              // Now set the nodes for periodic boundaries. As an example, assume we have 9 FastScape nodes in x:
-              //
-              // 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8
-              //
-              // Of these 9 nodes, 0 and 8 are ghost nodes and 1 and 7 are the periodic ASPECT boundaries.
-              // If we assume that the horizontal ASPECT direction of travel is towards node 7, then we would
-              // set the ghost node 8 velocities and heights to that of node 2, ghost node 0 to node 6, and
-              // ASPECT boundary node 1 to ASPECT boundary node 7. E.g., based on the FastScape values for
-              // vx, vy, vz, and elevation, the nodes could be rewritten as:
-              //
-              // 6 - 7 - 2 - 3 - 4 - 5 - 6 - 7 - 2
-              //
-              // This makes it so that effectively both periodic ASPECT boundaries see the same
-              // topography on either side of them to try and make sure they experience the same
-              // amount of diffusion and SPL.
-              velocity_x[index_right] = velocity_x[index_left+2];
-              velocity_y[index_right] = velocity_y[index_left+2];
-              velocity_z[index_right] = velocity_z[index_left+2] + (elevation[index_left+2] - elevation[index_right])/fastscape_timestep_in_years;
-
-              velocity_x[index_left] = velocity_x[index_right-2];
-              velocity_y[index_left] = velocity_y[index_right-2];
-              velocity_z[index_left] = velocity_z[index_right-2] + (elevation[index_right-2] - elevation[index_left])/fastscape_timestep_in_years;
-
-              // Set opposing ASPECT boundary so it's periodic.
-              elevation[op_side-jj] = elevation[side+jj];
-              velocity_x[op_side-jj] = velocity_x[side+jj];
-              velocity_y[op_side-jj] = velocity_y[side+jj];
-              velocity_z[op_side-jj] = velocity_z[side+jj];
-
-            }
-        }
-
-      // Now do the same for the top and bottom ghost nodes.
-      for (unsigned int j=0; j<fastscape_nx; ++j)
-        {
-          // The bottom row indexes are 0 to nx-1.
-          const unsigned int index_bot = j;
-
-          // Nx multiplied by (total rows - 1) gives us the start of
-          // the top row, and j gives the position in the row.
-          const unsigned int index_top = fastscape_nx*(fastscape_ny-1)+j;
-          double slope = 0;
-
-          if (top == 0 || !use_fixed_erosional_base)
-            {
-              velocity_z[index_top] = velocity_z[index_top-fastscape_nx];
-              velocity_y[index_top] = velocity_y[index_top-fastscape_nx];
-              velocity_x[index_top] = velocity_x[index_top-fastscape_nx];
-            }
-
-          if (bottom ==0 || !use_fixed_erosional_base)
-            {
-              velocity_z[index_bot] = velocity_z[index_bot+fastscape_nx];
-              velocity_y[index_bot] = velocity_y[index_bot+fastscape_nx];
-              velocity_x[index_bot] = velocity_x[index_bot+fastscape_nx];
-            }
-
-          if (init)
-            {
-              slope = top_flux / bedrock_transport_coefficient;
-              if (top == 1 && use_fixed_erosional_base)
-                elevation[index_top] = h_erosional_base;
-              else
-                elevation[index_top] = elevation[index_top-fastscape_nx] + slope*2*fastscape_dx;
-
-              slope = bottom_flux / bedrock_transport_coefficient;
-              if (bottom == 1 && use_fixed_erosional_base)
-                elevation[index_bot] = h_erosional_base;
-              else
-                elevation[index_bot] = elevation[index_bot + fastscape_nx] + slope*2*fastscape_dx;
-            }
-
-          if (top == 0 && !init)
-            {
-              if (top_flux > 0)
-                {
-                  slope = 0;
-                  if (j == 0)
-                    slope = top_flux / bedrock_transport_coefficient - std::tan(slopep[index_top - fastscape_nx + 1] * numbers::PI / 180.);
-                  else if (j == (fastscape_nx - 1))
-                    slope = top_flux / bedrock_transport_coefficient - std::tan(slopep[index_top - fastscape_nx - 1] * numbers::PI / 180.);
-                  else
-                    slope = top_flux / bedrock_transport_coefficient - std::tan(slopep[index_top - fastscape_nx] * numbers::PI / 180.);
-
-                  elevation[index_top] = elevation[index_top] + slope * 2 * fastscape_dx;
-                }
-              else
-                elevation[index_top] = elevation[index_top - fastscape_nx];
-            }
-
-          if (bottom == 0 && !init)
-            {
-              if (left_flux > 0)
-                {
-                  slope = 0;
-                  if (j == 0)
-                    slope = bottom_flux / bedrock_transport_coefficient - std::tan(slopep[index_bot + fastscape_nx + 1] * numbers::PI / 180.);
-                  else if (j == (fastscape_nx - 1))
-                    slope = bottom_flux / bedrock_transport_coefficient - std::tan(slopep[index_bot + fastscape_nx - 1] * numbers::PI / 180.);
-                  else
-                    slope = bottom_flux / bedrock_transport_coefficient - std::tan(slopep[index_bot + fastscape_nx] * numbers::PI / 180.);
-
-                  elevation[index_bot] = elevation[index_bot] + slope * 2 * fastscape_dx;
-                }
-              else
-                elevation[index_bot] = elevation[index_bot + fastscape_nx];
-            }
-
-          if (bottom == 0 && top == 0 || topbottom_ghost_nodes_periodic == true)
-            {
-              unsigned int side = index_bot;
-              unsigned int op_side = index_top;
-              int jj = fastscape_nx;
-
-              if (velocity_y[index_bot+fastscape_nx-1] > 0 && velocity_y[index_top-fastscape_nx-1] >= 0)
-                {
-                  side = index_top;
-                  op_side = index_bot;
-                  jj = -fastscape_nx;
-                }
-              else if (velocity_y[index_bot+fastscape_nx-1] <= 0 && velocity_y[index_top-fastscape_nx-1] < 0)
-                {
-                  side = index_bot;
-                  op_side = index_top;
-                  jj = fastscape_nx;
-                }
-              else
-                continue;
-
-              // Set top ghost node
-              velocity_x[index_top] = velocity_x[index_bot + 2*fastscape_nx];
-              velocity_y[index_top] = velocity_y[index_bot + 2*fastscape_nx];
-              velocity_z[index_top] = velocity_z[index_bot + 2*fastscape_nx] + (elevation[index_bot + 2*fastscape_nx] - elevation[index_top])/fastscape_timestep_in_years;
-
-              // Set bottom ghost node
-              velocity_x[index_bot] = velocity_x[index_top - 2*fastscape_nx];
-              velocity_y[index_bot] = velocity_y[index_top - 2*fastscape_nx];
-              velocity_z[index_bot] = velocity_z[index_top - 2*fastscape_nx] + (elevation[index_top - 2*fastscape_nx] - elevation[index_bot])/fastscape_timestep_in_years;
-
-              // Set opposing ASPECT boundary so it's periodic.
-              elevation[op_side-jj] = elevation[side+jj];
-              velocity_x[op_side-jj] = velocity_x[side+jj];
-              velocity_y[op_side-jj] = velocity_y[side+jj];
-              velocity_z[op_side-jj] = velocity_z[side+jj];
-            }
-        }
-    }
-
-    template <int dim>
-    bool FastScape<dim>::is_ghost_node(const unsigned int &index,
-                                       const bool &exclude_boundaries) const
-    {
-      if (use_ghost_nodes == false && exclude_boundaries == false)
-        return false;
-
-      const unsigned int row = index / fastscape_nx; // Calculate the row index
-      const unsigned int col = index % fastscape_nx; // Calculate the column index
-
-      // If we are at a boundary node and ghost nodes are enabled
-      // or we are excluding the boundaries then return true.
-      if (row == 0 || row == fastscape_ny-1 || col == 0 || col == fastscape_nx-1)
-        return true;
-      else
-        return false;
-    }
-
-
-    template <int dim>
-    Table<dim,double>
-    FastScape<dim>::fill_data_table(std::vector<double> &values,
-                                    TableIndices<dim> &size_idx,
-                                    const unsigned int &fastscape_nx,
-                                    const unsigned int &fastscape_ny) const
-    {
-      // Create data table based off of the given size.
-      Table<dim,double> data_table;
-      data_table.TableBase<dim,double>::reinit(size_idx);
-      TableIndices<dim> idx;
-
-      // Loop through the data table and fill it with the velocities from FastScape.
-      if (dim == 2)
-        {
-          std::vector<double> values_2d(fastscape_nx);
-
-          for (unsigned int x=use_ghost_nodes; x<(fastscape_nx-use_ghost_nodes); ++x)
-            {
-              // If we do not average the values, then use a slice near the center.
-              if (!average_out_of_plane_surface_topography)
-                {
-                  const unsigned int index = x+fastscape_nx*(round((fastscape_ny-use_ghost_nodes)/2));
-
-                  // If we are using the ghost nodes, then the x value locations need to be shifted back 1
-                  // e.g., given a 4x4 mesh an index of 5 would correspond to an x of 1 and y of 1 in the loop,
-                  // but should correspond to 0,0 for ASPECT.
-                  values_2d[x-use_ghost_nodes] = values[index];
-                }
-              // Here we use average velocities across the y nodes, excluding the ghost nodes (top and bottom row).
-              // Note: If ghost nodes are turned off, boundary effects may influence this.
-              else
-                {
-                  for (unsigned int y=use_ghost_nodes; y<(fastscape_ny-use_ghost_nodes); ++y)
-                    {
-                      const unsigned int index = x+fastscape_nx*y;
-                      values_2d[x-use_ghost_nodes] += values[index];
-                    }
-                  values_2d[x-use_ghost_nodes] = values_2d[x-use_ghost_nodes]/(fastscape_ny-2*use_ghost_nodes);
-                }
-            }
-
-          for (unsigned int x=0; x<data_table.size()[0]; ++x)
-            {
-              idx[0] = x;
-
-              for (unsigned int y=0; y<(data_table.size()[1]); ++y)
-                {
-                  idx[1] = y;
-
-                  // Convert back to m/s.
-                  data_table(idx) = values_2d[x] / year_in_seconds;
-                }
-            }
-        }
-      else
-        {
-          // Indexes through x, y, and z.
-          for (unsigned int x=0; x<data_table.size()[0]; ++x)
-            {
-              idx[0] = x;
-
-              for (unsigned int y=0; y<data_table.size()[1]; ++y)
-                {
-                  idx[1] = y;
-
-                  for (unsigned int z=0; z<data_table.size()[2]; ++z)
-                    {
-                      idx[2] = z;
-
-                      // Convert back to m/s.
-                      data_table(idx) = values[(fastscape_nx+1)*use_ghost_nodes+fastscape_nx*y+x] / year_in_seconds;
-
-                    }
-                }
-            }
-        }
-
-      return data_table;
-    }
-
-
-
-    template <int dim>
-    void FastScape<dim>::read_restart_files(std::vector<double> &elevation,
-                                            std::vector<double> &basement,
-                                            std::vector<double> &silt_fraction) const
-    {
-      this->get_pcout() << "   Loading FastScape restart file... " << std::endl;
-
-      // Create variables for output directory and restart file
-      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
-      std::string dirname = this->get_output_directory();
-      const std::string restart_filename_elevation = dirname + "fastscape_elevation_restart.txt";
-      const std::string restart_filename_basement = dirname + "fastscape_basement_restart.txt";
-      const std::string restart_filename_silt_fraction = dirname + "fastscape_silt_fraction_restart.txt";
-      const std::string restart_filename_time = dirname + "fastscape_last_output_time.txt";
-
-      // Load in h values.
-      std::ifstream in_elevation(restart_filename_elevation);
-      AssertThrow (in_elevation, ExcIO());
-      {
-        unsigned int line = 0;
-        while (line < fastscape_array_size)
-          {
-            in_elevation >> elevation[line];
-            line++;
-          }
-      }
-
-      // Load in b values.
-      std::ifstream in_basement(restart_filename_basement);
-      AssertThrow (in_basement, ExcIO());
-      {
-        unsigned int line = 0;
-        while (line < fastscape_array_size)
-          {
-            in_basement >> basement[line];
-            line++;
-          }
-      }
-
-      // Load in silt_fraction values if
-      // marine sediment transport and deposition is active.
-      if (use_marine_component)
-        {
-          std::ifstream in_silt_fraction(restart_filename_silt_fraction);
-          AssertThrow (in_silt_fraction, ExcIO());
-
-          if (sand_surface_porosity > 0. || silt_surface_porosity > 0.)
-            this->get_pcout() << "   Restarting runs with nonzero porosity can lead to a different system after restart. " << std::endl;
-          unsigned int line = 0;
-          while (line < fastscape_array_size)
-            {
-              in_silt_fraction >> silt_fraction[line];
-              line++;
-            }
-        }
-
-      // Now load the last output at time of restart.
-      // this allows us to correctly track when to call
-      // FastScape to make new VTK files.
-      std::ifstream in_last_output_time(restart_filename_time);
-      AssertThrow (in_last_output_time, ExcIO());
-      {
-        in_last_output_time >> last_output_time;
-      }
-    }
-
-    template <int dim>
-    void FastScape<dim>::save_restart_files(const std::vector<double> &elevation,
-                                            std::vector<double> &basement,
-                                            std::vector<double> &silt_fraction) const
-    {
-      this->get_pcout() << "      Writing FastScape restart file... " << std::endl;
-
-      // Create variables for output directory and restart file
-      const unsigned int fastscape_array_size = fastscape_nx*fastscape_ny;
-      std::string dirname = this->get_output_directory();
-      const std::string restart_filename_elevation = dirname + "fastscape_elevation_restart.txt";
-      const std::string restart_filename_basement = dirname + "fastscape_basement_restart.txt";
-      const std::string restart_filename_silt_fraction = dirname + "fastscape_silt_fraction_restart.txt";
-      const std::string restart_filename_time = dirname + "fastscape_last_output_time.txt";
-
-      std::ofstream out_elevation(restart_filename_elevation);
-      std::ofstream out_basement(restart_filename_basement);
-      std::ofstream out_silt_fraction(restart_filename_silt_fraction);
-      std::ofstream out_last_output_time(restart_filename_time);
-      std::stringstream buffer_basement;
-      std::stringstream buffer_elevation;
-      std::stringstream buffer_silt_fraction;
-      std::stringstream buffer_time;
-
-      fastscape_copy_basement_(basement.data());
-
-      // If marine sediment transport and deposition is active,
-      // we also need to store the silt fraction.
-      if (use_marine_component)
-        fastscape_copy_f_(silt_fraction.data());
-
-      out_last_output_time << last_output_time << "\n";
-
-      for (unsigned int i = 0; i < fastscape_array_size; ++i)
-        {
-          buffer_elevation << elevation[i] << "\n";
-          buffer_basement << basement[i] << "\n";
-          if (use_marine_component)
-            buffer_silt_fraction << silt_fraction[i] << "\n";
-        }
-
-      out_elevation << buffer_elevation.str();
-      out_basement << buffer_basement.str();
-      if (use_marine_component)
-        out_silt_fraction << buffer_silt_fraction.str();
-    }
-
-
-
-    template <int dim>
-    bool
-    FastScape<dim>::
-    needs_surface_stabilization () const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    void FastScape<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Mesh deformation");
-      {
-        prm.enter_subsection ("Fastscape");
-        {
-          prm.declare_entry("Number of fastscape timesteps per aspect timestep", "5",
-                            Patterns::Integer(),
-                            "Initial number of fastscape time steps per ASPECT timestep, this value will double if"
-                            "the FastScape timestep is above the maximum FastScape timestep.");
-          prm.declare_entry("Maximum timestep length", "10e3",
-                            Patterns::Double(0),
-                            "Maximum timestep for FastScape. Units: $\\{yrs}$");
-          prm.declare_entry("Vertical exaggeration", "-1",
-                            Patterns::Double(),
-                            "Vertical exaggeration for FastScape's VTK file. -1 outputs topography, basement, and sealevel.");
-          prm.declare_entry("Additional fastscape refinement", "0",
-                            Patterns::Integer(),
-                            "How many levels above ASPECT FastScape should be refined.");
-          prm.declare_entry ("Average out of plane surface topography in 2d", "true",
-                             Patterns::Bool (),
-                             "If this is set to false, then a 2D model will only consider the "
-                             "center slice FastScape gives. If set to true, then ASPECT will"
-                             "average the mesh along Y excluding the ghost nodes.");
-          prm.declare_entry("Fastscape seed", "1000",
-                            Patterns::Integer(),
-                            "Seed used for adding an initial noise to FastScape topography based on the initial noise magnitude.");
-          prm.declare_entry("Maximum surface refinement level", "1",
-                            Patterns::Integer(),
-                            "This should be set to the highest ASPECT refinement level expected at the surface.");
-          prm.declare_entry("Surface refinement difference", "0",
-                            Patterns::Integer(),
-                            "The difference between the lowest and highest refinement level at the surface. E.g., if three resolution "
-                            "levels are expected, this would be set to 2.");
-          prm.declare_entry ("Use marine component", "false",
-                             Patterns::Bool (),
-                             "Flag to use the marine component of FastScape.");
-          prm.declare_entry("Y extent in 2d", "100000",
-                            Patterns::Double(),
-                            "FastScape Y extent when using a 2D ASPECT model. Units: $\\{m}$");
-          prm.declare_entry ("Use ghost nodes", "true",
-                             Patterns::Bool (),
-                             "Flag to use ghost nodes");
-          prm.declare_entry ("Uplift and advect with fastscape", "true",
-                             Patterns::Bool (),
-                             "Flag to use FastScape advection and uplift.");
-          prm.declare_entry("Node tolerance", "0.001",
-                            Patterns::Double(),
-                            "Node tolerance for how close an ASPECT node must be to the FastScape node for the value to be transferred.");
-          prm.declare_entry ("Sediment rain rates", "0,0",
-                             Patterns::List (Patterns::Double(0)),
-                             "Sediment rain rates given as a list 1 greater than the number of sediment rain time intervals. E.g, "
-                             " If the time interval is given at 5 Myr, there will be one value for 0-5 Myr model time and a second value "
-                             " for 5+ Myr. Units: $\\{m/yr}$");
-          prm.declare_entry ("Sediment rain time intervals", "0",
-                             Patterns::List (Patterns::Double(0)),
-                             "A list of times to change the sediment rain rate. Units: $\\{yrs}$");
-          prm.declare_entry("Initial noise magnitude", "5",
-                            Patterns::Double(),
-                            "Maximum topography change from the initial noise. Units: $\\{m}$");
-
-          prm.enter_subsection ("Boundary conditions");
-          {
-            prm.declare_entry ("Front", "1",
-                               Patterns::Integer (0, 1),
-                               "Front (bottom) boundary condition, where 1 is fixed and 0 is reflective.");
-            prm.declare_entry ("Right", "1",
-                               Patterns::Integer (0, 1),
-                               "Right boundary condition, where 1 is fixed and 0 is reflective.");
-            prm.declare_entry ("Back", "1",
-                               Patterns::Integer (0, 1),
-                               "Back (top) boundary condition, where 1 is fixed and 0 is reflective.");
-            prm.declare_entry ("Left", "1",
-                               Patterns::Integer (0, 1),
-                               "Left boundary condition, where 1 is fixed and 0 is reflective.");
-            prm.declare_entry("Left mass flux", "0",
-                              Patterns::Double(),
-                              "Flux per unit length through left boundary. Units: $\\{m^2/yr}$ ");
-            prm.declare_entry("Right mass flux", "0",
-                              Patterns::Double(),
-                              "Flux per unit length through right boundary. Units: $\\{m^2/yr}$ ");
-            prm.declare_entry("Back mass flux", "0",
-                              Patterns::Double(),
-                              "Flux per unit length through back boundary. Units: $\\{m^2/yr}$ ");
-            prm.declare_entry("Front mass flux", "0",
-                              Patterns::Double(),
-                              "Flux per unit length through front boundary. Units: $\\{m^2/yr}$ ");
-            prm.declare_entry ("Back front ghost nodes periodic", "false",
-                               Patterns::Bool (),
-                               "Whether to set the ghost nodes at the FastScape back and front boundary "
-                               "to periodic even if 'Back' and 'Front' are set to fixed boundary.");
-            prm.declare_entry ("Left right ghost nodes periodic", "false",
-                               Patterns::Bool (),
-                               "Whether to set the ghost nodes at the FastScape left and right boundary "
-                               "to periodic even if 'Left' and 'Right' are set to fixed boundary.");
-          }
-          prm.leave_subsection();
-
-          prm.enter_subsection ("Erosional parameters");
-          {
-            prm.declare_entry("Drainage area exponent", "0.4",
-                              Patterns::Double(),
-                              "Exponent for drainage area.");
-            prm.declare_entry("Slope exponent", "1",
-                              Patterns::Double(),
-                              "The  slope  exponent  for  SPL (n).  Generally  m/n  should  equal  approximately 0.4");
-            prm.declare_entry("Multi-direction slope exponent", "1",
-                              Patterns::Double(),
-                              "Exponent to determine the distribution from the SPL to neighbor nodes, with"
-                              "10 being steepest decent and 1 being more varied.");
-            prm.declare_entry("Bedrock deposition coefficient", "1",
-                              Patterns::Double(),
-                              "Deposition coefficient for bedrock.");
-            prm.declare_entry("Sediment deposition coefficient", "-1",
-                              Patterns::Double(),
-                              "Deposition coefficient for sediment, -1 sets this to the same as the bedrock deposition coefficient.");
-            prm.declare_entry("Bedrock river incision rate", "1e-5",
-                              Patterns::Double(),
-                              "River incision rate for bedrock in the Stream Power Law. Units: $\\{m^(1-2*drainage_area_exponent)/yr}$");
-            prm.declare_entry("Sediment river incision rate", "-1",
-                              Patterns::Double(),
-                              "River incision rate for sediment in the Stream Power Law. -1 sets this to the bedrock river incision rate. Units: $\\{m^(1-2*drainage_area_exponent)/yr}$ ");
-            prm.declare_entry("Bedrock diffusivity", "1e-2",
-                              Patterns::Double(),
-                              "Transport coefficient (diffusivity) for bedrock. Units: $\\{m^2/yr}$ ");
-            prm.declare_entry("Sediment diffusivity", "-1",
-                              Patterns::Double(),
-                              "Transport coefficient (diffusivity) for sediment. -1 sets this to the bedrock diffusivity. Units: $\\{m^2/yr}$");
-            prm.declare_entry("Orographic elevation control", "2000",
-                              Patterns::Integer(),
-                              "Above this height, the elevation factor is applied. Units: $\\{m}$");
-            prm.declare_entry("Orographic wind barrier height", "500",
-                              Patterns::Integer(),
-                              "When terrain reaches this height the wind barrier factor is applied. Units: $\\{m}$");
-            prm.declare_entry("Elevation factor", "1",
-                              Patterns::Double(),
-                              "Amount to multiply the bedrock river incision rate nad transport coefficient by past the given orographic elevation control.");
-            prm.declare_entry("Wind barrier factor", "1",
-                              Patterns::Double(),
-                              "Amount to multiply the bedrock river incision rate nad transport coefficient by past given wind barrier height.");
-            prm.declare_entry ("Stack orographic controls", "true",
-                               Patterns::Bool (),
-                               "Whether or not to apply both controls to a point, or only a maximum of one set as the wind barrier.");
-            prm.declare_entry ("Flag to use orographic controls", "false",
-                               Patterns::Bool (),
-                               "Whether or not to apply orographic controls.");
-            prm.declare_entry ("Wind direction", "west",
-                               Patterns::Selection("east|west|south|north"),
-                               "This parameter assumes a wind direction, deciding which side is reduced from the wind barrier.");
-            prm.declare_entry ("Use a fixed erosional base level", "false",
-                               Patterns::Bool (),
-                               "Whether or not to use an erosional base level that differs from sea level. Setting this parameter to "
-                               "true will set all ghost nodes of fixed FastScape boundaries to the height you specify in "
-                               "'set Erosional base level'. \nThis can make "
-                               "sense for a continental model where the model surrounding topography is assumed above sea level, "
-                               "e.g. highlands. If the sea level would be used as an erosional base level in this case, all topography "
-                               "erodes away with lots of 'sediment volume' lost through the sides of the model. This is mostly "
-                               "important, when there are mountains in the middle of the model, while it is less important when there "
-                               "is lower relief in the middle of the model. \n"
-                               "In the FastScape  visualization files, setting the extra base level may show up as a strong "
-                               "slope at the fixed boundaries of the model. However, in the ASPECT visualization files it will not "
-                               "show up, as the ghost nodes only exist in FastScape.");
-            prm.declare_entry("Erosional base level", "0",
-                              Patterns::Double(),
-                              "When 'Use a fixed erosional base level' is set to true, all ghost nodes of fixed "
-                              "FastScape boundaries where no mass flux is specified by the user (FastScape boundary condition set to 1 "
-                              "and 'Left/Right/Bottom/Top mass flux' set to 0) will be fixed to this elevation. The "
-                              "reflecting boundaries (FastScape boundary condition set to 0) will not be affected, nor are the "
-                              "boundaries where a mass flux is specified. \n"
-                              "Units: m");
-          }
-          prm.leave_subsection();
-
-          prm.enter_subsection ("Marine parameters");
-          {
-            prm.declare_entry("Sea level", "0",
-                              Patterns::Double(),
-                              "Sea level relative to the ASPECT surface, where the maximum Z or Y extent in ASPECT is a sea level of zero. Units: $\\{m}$ ");
-            prm.declare_entry("Sand porosity", "0.0",
-                              Patterns::Double(),
-                              "Porosity of sand. ");
-            prm.declare_entry("Silt porosity", "0.0",
-                              Patterns::Double(),
-                              "Porosity of silt. ");
-            prm.declare_entry("Sand e-folding depth", "1e3",
-                              Patterns::Double(),
-                              "E-folding depth for the exponential of the sand porosity law. Units: $\\{m}$");
-            prm.declare_entry("Silt e-folding depth", "1e3",
-                              Patterns::Double(),
-                              "E-folding depth for the exponential of the silt porosity law. Units: $\\{m}$");
-            prm.declare_entry("Sand-silt ratio", "0.5",
-                              Patterns::Double(),
-                              "Ratio of sand to silt for material leaving continent.");
-            prm.declare_entry("Depth averaging thickness", "1e2",
-                              Patterns::Double(),
-                              "Depth averaging for the sand-silt equation. Units: $\\{m}$");
-            prm.declare_entry("Sand transport coefficient", "5e2",
-                              Patterns::Double(),
-                              "Transport coefficient (diffusivity) for sand. Units: $\\{m^2/yr}$");
-            prm.declare_entry("Silt transport coefficient", "2.5e2",
-                              Patterns::Double(),
-                              "Transport coefficient (diffusivity) for silt. Units: $\\{m^2/yr}$ ");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void FastScape<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Mesh deformation");
-      {
-        prm.enter_subsection("Fastscape");
-        {
-          fastscape_steps_per_aspect_step = prm.get_integer("Number of fastscape timesteps per aspect timestep");
-          maximum_fastscape_timestep = prm.get_double("Maximum timestep length");
-          vexp = prm.get_double("Vertical exaggeration");
-          additional_refinement_levels = prm.get_integer("Additional fastscape refinement");
-          average_out_of_plane_surface_topography = prm.get_bool("Average out of plane surface topography in 2d");
-          fastscape_seed = prm.get_integer("Fastscape seed");
-          maximum_surface_refinement_level = prm.get_integer("Maximum surface refinement level");
-          surface_refinement_difference = prm.get_integer("Surface refinement difference");
-          use_marine_component = prm.get_bool("Use marine component");
-          fastscape_y_extent_2d = prm.get_double("Y extent in 2d");
-          use_ghost_nodes = prm.get_bool("Use ghost nodes");
-          fastscape_advection_uplift = prm.get_bool("Uplift and advect with fastscape");
-          node_tolerance = prm.get_double("Node tolerance");
-          noise_elevation = prm.get_double("Initial noise magnitude");
-          sediment_rain_rates = Utilities::string_to_double
-                                (Utilities::split_string_list(prm.get ("Sediment rain rates")));
-          sediment_rain_times = Utilities::string_to_double
-                                (Utilities::split_string_list(prm.get ("Sediment rain time intervals")));
-
-          if (!this->convert_output_to_years())
-            {
-              maximum_fastscape_timestep /= year_in_seconds;
-              for (unsigned int j=0; j<sediment_rain_rates.size(); ++j)
-                sediment_rain_rates[j] *= year_in_seconds;
-            }
-
-          if (sediment_rain_rates.size() != sediment_rain_times.size()+1)
-            AssertThrow(false, ExcMessage("Error: There must be one more sediment rain rate than time interval."));
-
-          for (unsigned int i=1; i<sediment_rain_times.size(); ++i)
-            AssertThrow(sediment_rain_times[i] > sediment_rain_times[i-1], ExcMessage("Sediment rain time intervals must be an increasing array."));
-
-          prm.enter_subsection("Boundary conditions");
-          {
-            bottom = prm.get_integer("Front");
-            right = prm.get_integer("Right");
-            top = prm.get_integer("Back");
-            left = prm.get_integer("Left");
-            left_flux = prm.get_double("Left mass flux");
-            right_flux = prm.get_double("Right mass flux");
-            top_flux = prm.get_double("Back mass flux");
-            bottom_flux = prm.get_double("Front mass flux");
-
-            if (!this->convert_output_to_years())
-              {
-                left_flux *= year_in_seconds;
-                right_flux *= year_in_seconds;
-                top_flux *= year_in_seconds;
-                bottom_flux *= year_in_seconds;
-              }
-
-            // Put the boundary condition values into a four digit value to send to FastScape.
-            fastscape_boundary_conditions = bottom*1000+right*100+top*10+left;
-
-            if ((left_flux != 0 && top_flux != 0) || (left_flux != 0 && bottom_flux != 0) ||
-                (right_flux != 0 && bottom_flux != 0) || (right_flux != 0 && top_flux != 0))
-              AssertThrow(false,ExcMessage("Currently the plugin does not support mass flux through adjacent boundaries."));
-
-            topbottom_ghost_nodes_periodic = prm.get_bool("Back front ghost nodes periodic");
-            leftright_ghost_nodes_periodic = prm.get_bool("Left right ghost nodes periodic");
-          }
-          prm.leave_subsection();
-
-          prm.enter_subsection("Erosional parameters");
-          {
-            drainage_area_exponent_m = prm.get_double("Drainage area exponent");
-            slope_exponent_n = prm.get_double("Slope exponent");
-            sediment_river_incision_rate = prm.get_double("Sediment river incision rate");
-            bedrock_river_incision_rate = prm.get_double("Bedrock river incision rate");
-            sediment_transport_coefficient = prm.get_double("Sediment diffusivity");
-            bedrock_transport_coefficient = prm.get_double("Bedrock diffusivity");
-            bedrock_deposition_g = prm.get_double("Bedrock deposition coefficient");
-            sediment_deposition_g = prm.get_double("Sediment deposition coefficient");
-            slope_exponent_p = prm.get_double("Multi-direction slope exponent");
-            flat_elevation = prm.get_integer("Orographic elevation control");
-            wind_barrier_elevation = prm.get_integer("Orographic wind barrier height");
-            flat_erosional_factor = prm.get_double("Elevation factor");
-            wind_barrier_erosional_factor = prm.get_double("Wind barrier factor");
-            stack_controls = prm.get_bool("Stack orographic controls");
-            use_orographic_controls = prm.get_bool("Flag to use orographic controls");
-
-            if (!this->convert_output_to_years())
-              {
-                bedrock_river_incision_rate *= year_in_seconds;
-                bedrock_transport_coefficient *= year_in_seconds;
-                sediment_river_incision_rate *= year_in_seconds;
-                bedrock_transport_coefficient *= year_in_seconds;
-              }
-
-            // Wind direction
-            if (prm.get ("Wind direction") == "west")
-              wind_direction = 0;
-            else if (prm.get ("Wind direction") == "east")
-              wind_direction = 1;
-            else if (prm.get ("Wind direction") == "north")
-              wind_direction = 2;
-            else if (prm.get ("Wind direction") == "south")
-              wind_direction = 3;
-            else
-              AssertThrow(false, ExcMessage("Not a valid wind direction."));
-
-            // set fixed ghost nodes to a base level for erosion that differs from sea level
-            use_fixed_erosional_base = prm.get_bool("Use a fixed erosional base level");
-            if (use_fixed_erosional_base)
-              AssertThrow(use_fixed_erosional_base && use_ghost_nodes, ExcMessage(
-                            "If you want to use an erosional base level differing from sea level, "
-                            "you need to use ghost nodes."));
-            h_erosional_base = prm.get_double("Erosional base level");
-          }
-          prm.leave_subsection();
-
-          prm.enter_subsection("Marine parameters");
-          {
-            sea_level = prm.get_double("Sea level");
-            sand_surface_porosity = prm.get_double("Sand porosity");
-            silt_surface_porosity = prm.get_double("Silt porosity");
-            sand_efold_depth = prm.get_double("Sand e-folding depth");
-            silt_efold_depth = prm.get_double("Silt e-folding depth");
-            sand_silt_ratio = prm.get_double("Sand-silt ratio");
-            sand_silt_averaging_depth = prm.get_double("Depth averaging thickness");
-            sand_transport_coefficient = prm.get_double("Sand transport coefficient");
-            silt_transport_coefficient = prm.get_double("Silt transport coefficient");
-
-            if (!this->convert_output_to_years())
-              {
-                sand_transport_coefficient *= year_in_seconds;
-                silt_transport_coefficient *= year_in_seconds;
-              }
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection ();
-
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Visualization");
-        {
-          output_interval = prm.get_double ("Time between graphical output");
-          if (this->convert_output_to_years())
-            output_interval *= year_in_seconds;
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(FastScape,
-                                           "fastscape",
-                                           "A plugin that uses the program FastScape to compute the deformation of the mesh surface. "
-                                           "FastScape is a surface processes code that computes the erosion, transport and "
-                                           "deposition of sediments both on land and in the marine domain. These surface processes "
-                                           "include river incision (through the stream power law), hillslope diffusion and "
-                                           "marine diffusion, as described in Braun and Willett 2013; Yuan et al. 2019; "
-                                           "Yuan et al. 2019b. "
-                                           "\n"
-                                           "Upon initialization, FastScape requires the initial topography of the surface boundary "
-                                           "of ASPECT's model domain and several user-specified erosional and depositional parameters. "
-                                           "In each ASPECT timestep, FastScape is then fed ASPECT's material velocity at the surface "
-                                           "boundary. The z-component of this velocity is used to uplift the FastScape surface, "
-                                           "while the horizontal components are used to advect the topography in the x-y plane. "
-                                           "\n"
-                                           "After solving its governing equations (this can be done in several timesteps "
-                                           "that are smaller than the ASPECT timestep), FastScape returns a new topography of the surface. "
-                                           "The difference in topography before and after the call to FastScape divided by the ASPECT "
-                                           "timestep provides the mesh velocity at the domain's surface that is used to displace the surface "
-                                           "and internal mesh nodes. "
-                                           "\n"
-                                           "FastScape can be used in both 2D and 3D ASPECT simulations. In 2D, one can think of the coupled "
-                                           "model as a T-model.The ASPECT domain spans the x - z plane, while FastScape acts on the horizontal "
-                                           "x-y plane. This means that to communicate ASPECT's material velocities to FastScape, "
-                                           "FastScape mesh nodes with the same x-coordinate (so lying along the y-direction) get the same velocities. "
-                                           "In turn, the FastScape topography is collapsed back onto the line of the ASPECT surface boundary "
-                                           "by averaging the topography over the y-direction. In 3D no such actions are necessary. "
-                                           "\n"
-                                           "The FastScape manual (https://fastscape.org/fastscapelib-fortran/) provides more information "
-                                           "on the input parameters. ")
-
-  }
-}
-#endif
diff --git a/source/mesh_deformation/free_surface.cc.bak b/source/mesh_deformation/free_surface.cc.bak
deleted file mode 100644
index 83d083d7b07..00000000000
--- a/source/mesh_deformation/free_surface.cc.bak
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/mesh_deformation/free_surface.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/dofs/dof_tools.h>
-
-
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    template <int dim>
-    void
-    FreeSurface<dim>::initialize ()
-    {
-      // Pressure normalization doesn't really make sense with a free surface, and if we do
-      // use it, we can run into problems with geometry_model->depth().
-      AssertThrow ( this->get_parameters().pressure_normalization == "no",
-                    ExcMessage("The free surface scheme can only be used with no pressure normalization") );
-
-      // Check that we do not use the free surface on a boundary that has zero slip,
-      // free slip or prescribed velocity boundary conditions on it.
-
-      // Get the zero velocity boundary indicators
-      std::set<types::boundary_id> velocity_boundary_indicators = this->get_boundary_velocity_manager().get_zero_boundary_velocity_indicators();
-
-      // Get the tangential velocity boundary indicators
-      const std::set<types::boundary_id> tmp_tangential_vel_boundary_indicators = this->get_boundary_velocity_manager().get_tangential_boundary_velocity_indicators();
-      velocity_boundary_indicators.insert(tmp_tangential_vel_boundary_indicators.begin(),
-                                          tmp_tangential_vel_boundary_indicators.end());
-
-      // Get the active velocity boundary indicators
-      const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>>
-      tmp_active_vel_boundary_indicators = this->get_boundary_velocity_manager().get_active_boundary_velocity_names();
-
-      for (const auto &p : tmp_active_vel_boundary_indicators)
-        velocity_boundary_indicators.insert(p.first);
-
-      // Get the mesh deformation boundary indicators
-      const std::set<types::boundary_id> tmp_mesh_deformation_boundary_indicators = this->get_mesh_deformation_boundary_indicators();
-      for (const auto &p : tmp_mesh_deformation_boundary_indicators)
-        AssertThrow(velocity_boundary_indicators.find(p) == velocity_boundary_indicators.end(),
-                    ExcMessage("The free surface mesh deformation plugin cannot be used with the current velocity boundary conditions"));
-    }
-
-
-    template <int dim>
-    void FreeSurface<dim>::project_velocity_onto_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                          const IndexSet &mesh_locally_owned,
-                                                          const IndexSet &mesh_locally_relevant,
-                                                          LinearAlgebra::Vector &output) const
-    {
-      // TODO: should we use the extrapolated solution?
-
-      // stuff for iterating over the mesh
-      const QGauss<dim-1> face_quadrature(mesh_deformation_dof_handler.get_fe().degree+1);
-      UpdateFlags update_flags = UpdateFlags(update_values | update_quadrature_points
-                                             | update_normal_vectors | update_JxW_values);
-      FEFaceValues<dim> fs_fe_face_values (this->get_mapping(), mesh_deformation_dof_handler.get_fe(), face_quadrature, update_flags);
-      FEFaceValues<dim> fe_face_values (this->get_mapping(), this->get_fe(), face_quadrature, update_flags);
-      const unsigned int n_face_q_points = fe_face_values.n_quadrature_points,
-                         dofs_per_cell = fs_fe_face_values.dofs_per_cell;
-
-      // stuff for assembling system
-      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
-      Vector<double> cell_vector (dofs_per_cell);
-      FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
-
-      // stuff for getting the velocity values
-      std::vector<Tensor<1,dim>> velocity_values(n_face_q_points);
-
-      // set up constraints
-      AffineConstraints<double> mass_matrix_constraints(
-#if DEAL_II_VERSION_GTE(9,6,0)
-        mesh_deformation_dof_handler.locally_owned_dofs(),
-#endif
-        mesh_locally_relevant);
-      DoFTools::make_hanging_node_constraints(mesh_deformation_dof_handler, mass_matrix_constraints);
-
-      using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
-      periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
-      for (const auto &p : pbp)
-        DoFTools::make_periodicity_constraints(mesh_deformation_dof_handler,
-                                               p.first.first, p.first.second, p.second, mass_matrix_constraints);
-
-      mass_matrix_constraints.close();
-
-      // set up the matrix
-      LinearAlgebra::SparseMatrix mass_matrix;
-      TrilinosWrappers::SparsityPattern sp (mesh_locally_owned,
-                                            mesh_locally_owned,
-                                            mesh_locally_relevant,
-                                            this->get_mpi_communicator());
-      DoFTools::make_sparsity_pattern (mesh_deformation_dof_handler, sp, mass_matrix_constraints, false,
-                                       Utilities::MPI::this_mpi_process(this->get_mpi_communicator()));
-      sp.compress();
-      mass_matrix.reinit (sp);
-
-      FEValuesExtractors::Vector extract_vel(0);
-
-      // make distributed vectors.
-      LinearAlgebra::Vector rhs, dist_solution;
-      rhs.reinit(mesh_locally_owned, this->get_mpi_communicator());
-      dist_solution.reinit(mesh_locally_owned, this->get_mpi_communicator());
-
-      typename DoFHandler<dim>::active_cell_iterator
-      cell = this->get_dof_handler().begin_active(), endc= this->get_dof_handler().end();
-      typename DoFHandler<dim>::active_cell_iterator
-      fscell = mesh_deformation_dof_handler.begin_active();
-
-      // Get the boundary indicators of those boundaries with
-      // a free surface.
-      const std::set<types::boundary_id> tmp_free_surface_boundary_indicators = this->get_mesh_deformation_handler().get_free_surface_boundary_indicators();
-
-      for (; cell!=endc; ++cell, ++fscell)
-        if (cell->at_boundary() && cell->is_locally_owned())
-          for (const unsigned int face_no : cell->face_indices())
-            if (cell->face(face_no)->at_boundary())
-              {
-                const types::boundary_id boundary_indicator
-                  = cell->face(face_no)->boundary_id();
-
-                // Only project onto the free surface boundary/boundaries.
-                if (tmp_free_surface_boundary_indicators.find(boundary_indicator) == tmp_free_surface_boundary_indicators.end())
-                  continue;
-
-                fscell->get_dof_indices (cell_dof_indices);
-                fs_fe_face_values.reinit (fscell, face_no);
-                fe_face_values.reinit (cell, face_no);
-                fe_face_values[this->introspection().extractors.velocities].get_function_values(this->get_solution(), velocity_values);
-
-                cell_vector = 0;
-                cell_matrix = 0;
-                for (unsigned int point=0; point<n_face_q_points; ++point)
-                  {
-                    // Select the direction onto which to project the velocity solution
-                    Tensor<1,dim> direction;
-                    if ( advection_direction == SurfaceAdvection::normal ) // project onto normal vector
-                      direction = fs_fe_face_values.normal_vector(point);
-                    else if ( advection_direction == SurfaceAdvection::vertical ) // project onto local gravity
-                      direction = this->get_gravity_model().gravity_vector(fs_fe_face_values.quadrature_point(point));
-                    else
-                      AssertThrow(false, ExcInternalError());
-
-                    direction *= ( direction.norm() > 0.0 ? 1./direction.norm() : 0.0 );
-
-                    for (unsigned int i=0; i<dofs_per_cell; ++i)
-                      {
-                        for (unsigned int j=0; j<dofs_per_cell; ++j)
-                          {
-                            cell_matrix(i,j) += (fs_fe_face_values[extract_vel].value(j,point) *
-                                                 fs_fe_face_values[extract_vel].value(i,point) ) *
-                                                fs_fe_face_values.JxW(point);
-                          }
-
-                        cell_vector(i) += (fs_fe_face_values[extract_vel].value(i,point) * direction)
-                                          * (velocity_values[point] * direction)
-                                          * fs_fe_face_values.JxW(point);
-                      }
-                  }
-
-                mass_matrix_constraints.distribute_local_to_global (cell_matrix, cell_vector,
-                                                                    cell_dof_indices, mass_matrix, rhs, false);
-              }
-
-      rhs.compress (VectorOperation::add);
-      mass_matrix.compress(VectorOperation::add);
-
-      // Jacobi seems to be fine here.  Other preconditioners (ILU, IC) run into troubles
-      // because the matrix is mostly empty, since we don't touch internal vertices.
-      LinearAlgebra::PreconditionJacobi preconditioner_mass;
-      preconditioner_mass.initialize(mass_matrix);
-
-      SolverControl solver_control(5*rhs.size(), this->get_parameters().linear_stokes_solver_tolerance*rhs.l2_norm());
-      SolverCG<LinearAlgebra::Vector> cg(solver_control);
-      cg.solve (mass_matrix, dist_solution, rhs, preconditioner_mass);
-
-      mass_matrix_constraints.distribute (dist_solution);
-      output = dist_solution;
-    }
-
-
-
-    /**
-     * A function that creates constraints for the velocity of certain mesh
-     * vertices (e.g. the surface vertices) for a specific boundary.
-     * The calling class will respect
-     * these constraints when computing the new vertex positions.
-     */
-    template <int dim>
-    void
-    FreeSurface<dim>::compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                               AffineConstraints<double> &mesh_velocity_constraints,
-                                                               const std::set<types::boundary_id> &boundary_id) const
-    {
-      // For the free surface indicators we constrain the displacement to be v.n
-      LinearAlgebra::Vector boundary_velocity;
-
-      const IndexSet &mesh_locally_owned = mesh_deformation_dof_handler.locally_owned_dofs();
-      IndexSet mesh_locally_relevant;
-      DoFTools::extract_locally_relevant_dofs (mesh_deformation_dof_handler,
-                                               mesh_locally_relevant);
-      boundary_velocity.reinit(mesh_locally_owned, mesh_locally_relevant,
-                               this->get_mpi_communicator());
-      project_velocity_onto_boundary(mesh_deformation_dof_handler, mesh_locally_owned,
-                                     mesh_locally_relevant, boundary_velocity);
-
-      // now insert the relevant part of the solution into the mesh constraints
-      const IndexSet constrained_dofs =
-        DoFTools::extract_boundary_dofs(mesh_deformation_dof_handler,
-                                        ComponentMask(dim, true),
-                                        boundary_id);
-
-      for (unsigned int i = 0; i < constrained_dofs.n_elements();  ++i)
-        {
-          types::global_dof_index index = constrained_dofs.nth_index_in_set(i);
-          if (mesh_velocity_constraints.can_store_line(index))
-            if (mesh_velocity_constraints.is_constrained(index)==false)
-              {
-#if DEAL_II_VERSION_GTE(9,6,0)
-                mesh_velocity_constraints.add_constraint(index,
-                                                         {},
-                                                         boundary_velocity[index]);
-#else
-                mesh_velocity_constraints.add_line(index);
-                mesh_velocity_constraints.set_inhomogeneity(index, boundary_velocity[index]);
-#endif
-              }
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    FreeSurface<dim>::
-    needs_surface_stabilization () const
-    {
-      return true;
-    }
-
-
-
-    template <int dim>
-    void FreeSurface<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Mesh deformation");
-      {
-        prm.enter_subsection ("Free surface");
-        {
-          prm.declare_entry("Surface velocity projection", "normal",
-                            Patterns::Selection("normal|vertical"),
-                            "After each time step the free surface must be "
-                            "advected in the direction of the velocity field. "
-                            "Mass conservation requires that the mesh velocity "
-                            "is in the normal direction of the surface. However, "
-                            "for steep topography or large curvature, advection "
-                            "in the normal direction can become ill-conditioned, "
-                            "and instabilities in the mesh can form. Projection "
-                            "of the mesh velocity onto the local vertical direction "
-                            "can preserve the mesh quality better, but at the "
-                            "cost of slightly poorer mass conservation of the "
-                            "domain.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-
-    template <int dim>
-    void FreeSurface<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Mesh deformation");
-      {
-        prm.enter_subsection ("Free surface");
-        {
-          std::string advection_dir = prm.get("Surface velocity projection");
-
-          if ( advection_dir == "normal")
-            advection_direction = SurfaceAdvection::normal;
-          else if ( advection_dir == "vertical")
-            advection_direction = SurfaceAdvection::vertical;
-          else
-            AssertThrow(false, ExcMessage("The surface velocity projection must be ``normal'' or ``vertical''."));
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(FreeSurface,
-                                           "free surface",
-                                           "A plugin that computes the deformation of surface "
-                                           "vertices according to the solution of the flow problem. "
-                                           "In particular this means if the surface of the domain is "
-                                           "left open to flow, this flow will carry the mesh with it. "
-                                           "The implementation was described in \\cite{rose_freesurface}, "
-                                           "with the stabilization of the free surface originally described "
-                                           "in \\cite{kaus:etal:2010}.")
-  }
-}
diff --git a/source/mesh_deformation/function.cc.bak b/source/mesh_deformation/function.cc.bak
deleted file mode 100644
index 32027eafd2e..00000000000
--- a/source/mesh_deformation/function.cc.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/mesh_deformation/function.h>
-
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    template <int dim>
-    BoundaryFunction<dim>::BoundaryFunction()
-      :
-      function(dim)
-    {}
-
-
-
-    template <int dim>
-    void
-    BoundaryFunction<dim>::update ()
-    {
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        function.set_time (this->get_time() / year_in_seconds);
-      else
-        function.set_time (this->get_time());
-    }
-
-
-
-    /**
-     * A function that creates constraints for the velocity of certain mesh
-     * vertices (e.g. the surface vertices) for a specific boundary.
-     * The calling class will respect
-     * these constraints when computing the new vertex positions.
-     */
-    template <int dim>
-    void
-    BoundaryFunction<dim>::compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
-                                                                    AffineConstraints<double> &mesh_velocity_constraints,
-                                                                    const std::set<types::boundary_id> &boundary_ids) const
-    {
-      // Loop over all boundary indicators to set the velocity constraints
-      for (const auto boundary_id : boundary_ids)
-        VectorTools::interpolate_boundary_values (this->get_mapping(),
-                                                  mesh_deformation_dof_handler,
-                                                  boundary_id,
-                                                  function,
-                                                  mesh_velocity_constraints);
-    }
-
-
-
-    template <int dim>
-    bool
-    BoundaryFunction<dim>::
-    needs_surface_stabilization () const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    void BoundaryFunction<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Mesh deformation");
-      {
-        prm.enter_subsection ("Boundary function");
-        {
-          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection ();
-    }
-
-    template <int dim>
-    void BoundaryFunction<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Mesh deformation");
-      {
-        prm.enter_subsection("Boundary function");
-        {
-          try
-            {
-              function.parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Mesh deformation.BoundaryFunction'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(BoundaryFunction,
-                                           "boundary function",
-                                           "A plugin, which prescribes the surface mesh to "
-                                           "deform according to an analytically prescribed "
-                                           "function. Note that the function prescribes a "
-                                           "deformation velocity, i.e. the return value of "
-                                           "this plugin is later multiplied by the time step length "
-                                           "to compute the displacement increment in this time step. "
-                                           "Although the function's time variable is interpreted as "
-                                           "years when Use years in output instead of seconds is set to true, "
-                                           "the boundary deformation velocity should still be given "
-                                           "in m/s. The format of the "
-                                           "functions follows the syntax understood by the "
-                                           "muparser library, see {ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-  }
-}
diff --git a/source/mesh_deformation/interface.cc.bak b/source/mesh_deformation/interface.cc.bak
deleted file mode 100644
index 50d4f2307e8..00000000000
--- a/source/mesh_deformation/interface.cc.bak
+++ /dev/null
@@ -1,1605 +0,0 @@
-/*
-  Copyright (C) 2014 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/simulator.h>
-#include <aspect/stokes_matrix_free.h>
-
-#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/dof_tools.h>
-
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/mapping_q1_eulerian.h>
-#include <deal.II/fe/mapping_q_eulerian.h>
-
-#include <deal.II/lac/sparsity_tools.h>
-
-#include <deal.II/numerics/vector_tools.h>
-
-#include <aspect/melt.h>
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    template <int dim>
-    ApplyStabilization<dim>::ApplyStabilization(const double stabilization_theta)
-      :
-      free_surface_theta(stabilization_theta)
-    {}
-
-    template <int dim>
-    void
-    ApplyStabilization<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>       &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim>      &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>& > (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>& > (data_base);
-
-      AssertThrow(!this->get_mesh_deformation_handler().get_boundary_indicators_requiring_stabilization().empty(),
-                  ExcMessage("Applying surface stabilization, even though no boundary requires it."));
-
-
-      if (this->get_parameters().include_melt_transport)
-        {
-          this->get_melt_handler().apply_free_surface_stabilization_with_melt (free_surface_theta,
-                                                                               scratch.cell,
-                                                                               scratch,
-                                                                               data);
-          return;
-        }
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const typename DoFHandler<dim>::active_cell_iterator cell (&this->get_triangulation(),
-                                                                 scratch.finite_element_values.get_cell()->level(),
-                                                                 scratch.finite_element_values.get_cell()->index(),
-                                                                 &this->get_dof_handler());
-
-      const unsigned int n_face_q_points = scratch.face_finite_element_values.n_quadrature_points;
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-
-      // Get the boundary indicators of those boundaries that require stabilization
-      const std::set<types::boundary_id> tmp_boundary_indicators_requiring_stabilization = this->get_mesh_deformation_handler().get_boundary_indicators_requiring_stabilization();
-
-      // only apply on mesh deformation faces that require stabilization
-      if (cell->at_boundary() && cell->is_locally_owned())
-        for (const unsigned int face_no : cell->face_indices())
-          if (cell->face(face_no)->at_boundary())
-            {
-              const types::boundary_id boundary_indicator
-                = cell->face(face_no)->boundary_id();
-
-              if (tmp_boundary_indicators_requiring_stabilization.find(boundary_indicator)
-                  == tmp_boundary_indicators_requiring_stabilization.end())
-                continue;
-
-              scratch.face_finite_element_values.reinit(cell, face_no);
-
-              scratch.face_material_model_inputs.reinit  (scratch.face_finite_element_values,
-                                                          cell,
-                                                          this->introspection(),
-                                                          this->get_solution());
-              scratch.face_material_model_inputs.requested_properties = MaterialModel::MaterialProperties::density;
-
-              this->get_material_model().evaluate(scratch.face_material_model_inputs, scratch.face_material_model_outputs);
-
-              for (unsigned int q_point = 0; q_point < n_face_q_points; ++q_point)
-                {
-                  for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-                    {
-                      if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                        {
-                          scratch.phi_u[i_stokes] = scratch.face_finite_element_values[introspection.extractors.velocities].value(i, q_point);
-                          ++i_stokes;
-                        }
-                      ++i;
-                    }
-
-                  const Tensor<1,dim>
-                  gravity = this->get_gravity_model().gravity_vector(scratch.face_finite_element_values.quadrature_point(q_point));
-                  const double g_norm = gravity.norm();
-
-                  // construct the relevant vectors
-                  const Tensor<1,dim> n_hat = scratch.face_finite_element_values.normal_vector(q_point);
-                  const Tensor<1,dim> g_hat = (g_norm == 0.0 ? Tensor<1,dim>() : gravity/g_norm);
-
-                  const double pressure_perturbation = scratch.face_material_model_outputs.densities[q_point] *
-                                                       this->get_timestep() *
-                                                       free_surface_theta *
-                                                       g_norm;
-
-                  // see Kaus et al 2010 for details of the stabilization term
-                  for (unsigned int i=0; i< stokes_dofs_per_cell; ++i)
-                    for (unsigned int j=0; j< stokes_dofs_per_cell; ++j)
-                      {
-                        // The fictive stabilization stress is (phi_u[i].g)*(phi_u[j].n)
-                        const double stress_value = -pressure_perturbation*
-                                                    (scratch.phi_u[i]*g_hat) * (scratch.phi_u[j]*n_hat)
-                                                    *scratch.face_finite_element_values.JxW(q_point);
-
-                        data.local_matrix(i,j) += stress_value;
-                      }
-                }
-            }
-    }
-  }
-
-
-
-  namespace MeshDeformation
-  {
-    template <int dim>
-    bool
-    Interface<dim>::needs_surface_stabilization () const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    Tensor<1,dim>
-    Interface<dim>::
-    compute_initial_deformation_on_boundary(const types::boundary_id /*boundary_indicator*/,
-                                            const Point<dim> &/*position*/) const
-    {
-      return Tensor<1,dim>();
-    }
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::
-    compute_velocity_constraints_on_boundary(const DoFHandler<dim> &/*mesh_deformation_dof_handler*/,
-                                             AffineConstraints<double> &/*mesh_velocity_constraints*/,
-                                             const std::set<types::boundary_id> &/*boundary_id*/) const
-    {}
-
-
-
-    template <int dim>
-    MeshDeformationHandler<dim>::MeshDeformationHandler (Simulator<dim> &simulator)
-      : sim(simulator),  // reference to the simulator that owns the MeshDeformationHandler
-        mesh_deformation_fe (FE_Q<dim>(1),dim), // Q1 elements which describe the mesh geometry
-        mesh_deformation_dof_handler (sim.triangulation),
-        include_initial_topography(false)
-    {
-      // Now reset the mapping of the simulator to be something that captures mesh deformation in time.
-      sim.mapping = std::make_unique<MappingQ1Eulerian<dim, LinearAlgebra::Vector>> (mesh_deformation_dof_handler,
-                                                                                      mesh_displacements);
-    }
-
-
-
-    template <int dim>
-    MeshDeformationHandler<dim>::~MeshDeformationHandler ()
-    {
-      // Free the Simulator's mapping object, otherwise
-      // when the MeshDeformationHandler gets destroyed,
-      // the mapping's reference to the mesh displacement
-      // vector will be invalid.
-      sim.mapping.reset();
-    }
-
-
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    MeshDeformationHandler<dim>::initialize ()
-    {
-      // In case we prescribed initial topography, we should take this into
-      // account. However, it is not included in the mesh displacements,
-      // so we need to fetch it separately.
-      if (!Plugins::plugin_type_matches<InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()))
-        include_initial_topography = true;
-
-      // If a surface needs to be stabilized, set up the assemblers.
-      if (!this->get_mesh_deformation_handler().get_boundary_indicators_requiring_stabilization().empty())
-        {
-          this->get_signals().set_assemblers.connect(
-            [&](const SimulatorAccess<dim> &sim_access,
-                aspect::Assemblers::Manager<dim> &assemblers)
-          {
-            this->set_assemblers(sim_access, assemblers);
-          });
-        }
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::set_assemblers(const SimulatorAccess<dim> &,
-                                                     aspect::Assemblers::Manager<dim> &assemblers) const
-    {
-      assemblers.stokes_system.push_back(
-        std::make_unique<aspect::Assemblers::ApplyStabilization<dim>> (surface_theta));
-
-      // Note that we do not want face_material_model_data, because we do not
-      // connect to a face assembler. We instead connect to a normal assembler,
-      // and compute our own material_model_inputs in apply_stabilization
-      // (because we want to use the solution instead of the current_linearization_point
-      // to compute the material properties).
-      assemblers.stokes_system_assembler_on_boundary_face_properties.needed_update_flags |= (update_values  |
-          update_gradients |
-          update_quadrature_points |
-          update_normal_vectors |
-          update_JxW_values);
-    }
-
-
-
-    template <int dim>
-    void
-    MeshDeformationHandler<dim>::register_mesh_deformation (const std::string &name,
-                                                            const std::string &description,
-                                                            void (*declare_parameters_function) (ParameterHandler &),
-                                                            std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-
-    template <int dim>
-    void
-    MeshDeformationHandler<dim>::update ()
-    {
-      AssertThrow(sim.parameters.mesh_deformation_enabled, ExcInternalError());
-
-      for (const auto &boundary_and_deformation_objects : mesh_deformation_objects)
-        {
-          for (const auto &model : boundary_and_deformation_objects.second)
-            model->update();
-        }
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Mesh deformation");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry ("Additional tangential mesh velocity boundary indicators", "",
-                           Patterns::List (Patterns::Anything()),
-                           "A comma separated list of names denoting those boundaries "
-                           "where there the mesh is allowed to move tangential to the "
-                           "boundary. All tangential mesh movements along "
-                           "those boundaries that have tangential material velocity "
-                           "boundary conditions are allowed by default, this parameters "
-                           "allows to generate mesh movements along other boundaries that are "
-                           "open, or have prescribed material velocities or tractions."
-                           "\n\n"
-                           "The names of the boundaries listed here can either be "
-                           "numbers (in which case they correspond to the numerical "
-                           "boundary indicators assigned by the geometry object), or they "
-                           "can correspond to any of the symbolic names the geometry object "
-                           "may have provided for each part of the boundary. You may want "
-                           "to compare this with the documentation of the geometry model you "
-                           "use in your model.");
-        prm.declare_entry ("Mesh deformation boundary indicators", "",
-                           Patterns::List (Patterns::Anything()),
-                           "A comma separated list of names denoting those boundaries "
-                           "where there the mesh is allowed to move according to the "
-                           "specified mesh deformation objects. "
-                           "\n\n"
-                           "The names of the boundaries listed here can either be "
-                           "numbers (in which case they correspond to the numerical "
-                           "boundary indicators assigned by the geometry object), or they "
-                           "can correspond to any of the symbolic names the geometry object "
-                           "may have provided for each part of the boundary. You may want "
-                           "to compare this with the documentation of the geometry model you "
-                           "use in your model. "
-                           "\n\n"
-                           "The format is id1: object1 \\& object2, id2: object3 \\& object2, where "
-                           "objects are one of " + std::get<dim>(registered_plugins).get_description_string());
-
-        prm.enter_subsection ("Free surface");
-        {
-          prm.declare_entry("Free surface stabilization theta", "0.5",
-                            Patterns::Double(0., 1.),
-                            "Theta parameter described in \\cite{kaus:etal:2010}. "
-                            "An unstabilized free surface can overshoot its "
-                            "equilibrium position quite easily and generate "
-                            "unphysical results.  One solution is to use a "
-                            "quasi-implicit correction term to the forces near the "
-                            "free surface.  This parameter describes how much "
-                            "the free surface is stabilized with this term, "
-                            "where zero is no stabilization, and one is fully "
-                            "implicit.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Mesh deformation");
-      {
-        // Create the map of prescribed mesh movement boundary indicators
-        // Each boundary indicator can carry a number of mesh deformation plugin names.
-        const std::vector<std::string> x_mesh_deformation_boundary_indicators
-          = Utilities::split_string_list(prm.get("Mesh deformation boundary indicators"),",");
-
-        for (const auto &entry : x_mesh_deformation_boundary_indicators)
-          {
-            // each entry has the format (white space is optional):
-            // <boundary_id> : <object_name & object_name, ...>
-            const std::vector<std::string> split_parts = Utilities::split_string_list (entry, ':');
-            AssertThrow (split_parts.size() == 2,
-                         ExcMessage ("The format for mesh deformation indicators "
-                                     "requires that each entry has the form `"
-                                     "<id> : <value & value & ...>', but there does not "
-                                     "appear to be a colon in the entry <"
-                                     + entry
-                                     + ">."));
-
-            // Get the values, i.e. the mesh deformation plugin names
-            const std::vector<std::string> object_names = Utilities::split_string_list(split_parts[1],"&");
-
-            // Try to translate the id into a boundary_id.
-            types::boundary_id boundary_id;
-            try
-              {
-                boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id(split_parts[0]);
-              }
-            catch (const std::string &error)
-              {
-                AssertThrow (false, ExcMessage ("While parsing the entry <Mesh deformation/"
-                                                "Mesh deformation boundary indicators>, there was an error. Specifically, "
-                                                "the conversion function complained as follows:\n\n"
-                                                + error));
-              }
-
-            // Store the boundary indicator. If the entry exists this does nothing.
-            prescribed_mesh_deformation_boundary_indicators.insert(boundary_id);
-
-            for (const auto &object_name : object_names)
-              {
-                // Make sure there are no duplicated entries. If this boundary is not
-                // already in the map the first call to map[key] will create an empty entry.
-                AssertThrow(std::find(mesh_deformation_object_names[boundary_id].begin(),
-                                      mesh_deformation_object_names[boundary_id].end(), object_name)
-                            == mesh_deformation_object_names[boundary_id].end(),
-                            ExcMessage("The current mesh deformation object is listed twice for boundary indicator "
-                                       + dealii::Utilities::int_to_string(boundary_id)));
-
-                mesh_deformation_object_names[boundary_id].push_back(object_name);
-
-                if (object_name == "free surface")
-                  free_surface_boundary_indicators.insert(boundary_id);
-              }
-          }
-
-        // Create the list of tangential mesh movement boundary indicators
-        try
-          {
-            const std::vector<types::boundary_id> x_additional_tangential_mesh_boundary_indicators
-              = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
-                                                                                    (prm.get ("Additional tangential mesh velocity boundary indicators")));
-
-            tangential_mesh_deformation_boundary_indicators.insert(x_additional_tangential_mesh_boundary_indicators.begin(),
-                                                                   x_additional_tangential_mesh_boundary_indicators.end());
-          }
-        catch (const std::string &error)
-          {
-            AssertThrow (false, ExcMessage ("While parsing the entry <Mesh deformation/Additional tangential "
-                                            "mesh velocity boundary indicators>, there was an error. Specifically, "
-                                            "the conversion function complained as follows:\n\n"
-                                            + error));
-          }
-
-        // Boundaries with tangential Stokes velocity boundary conditions are implicitly
-        // treated as tangential mesh boundaries, but only if they do not have
-        // assigned mesh deformation objects.
-        for (const auto &boundary_id : this->get_boundary_velocity_manager().get_tangential_boundary_velocity_indicators())
-          tangential_mesh_deformation_boundary_indicators.insert(boundary_id);
-
-        // The tangential mesh boundaries can accidentally contain prescribed mesh
-        // boundaries if they were in the list of tangential Stokes boundaries.
-        // If so remove them.
-        for (const auto &boundary_id : prescribed_mesh_deformation_boundary_indicators)
-          tangential_mesh_deformation_boundary_indicators.erase(boundary_id);
-
-        // All periodic boundaries are implicitly treated as tangential mesh deformation boundaries.
-        using periodic_boundary_pair = std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>;
-        for (const periodic_boundary_pair &p : this->get_geometry_model().get_periodic_boundary_pairs())
-          {
-            tangential_mesh_deformation_boundary_indicators.insert(p.first.first);
-            tangential_mesh_deformation_boundary_indicators.insert(p.first.second);
-          }
-
-        // Create the list of zero mesh movement (fixed) boundary indicators, these are
-        // all boundaries, which are not prescribed or tangential.
-        zero_mesh_deformation_boundary_indicators = this->get_geometry_model().get_used_boundary_indicators();
-
-        for (const auto &boundary_id : prescribed_mesh_deformation_boundary_indicators)
-          zero_mesh_deformation_boundary_indicators.erase(boundary_id);
-
-        for (const auto &boundary_id : tangential_mesh_deformation_boundary_indicators)
-          zero_mesh_deformation_boundary_indicators.erase(boundary_id);
-
-        prm.enter_subsection ("Free surface");
-        {
-          surface_theta = prm.get_double("Free surface stabilization theta");
-        }
-        prm.leave_subsection ();
-
-      }
-      prm.leave_subsection ();
-
-      // go through the list of object names, create objects and let them parse
-      // their own parameters
-      for (const auto &boundary_and_object_names : mesh_deformation_object_names)
-        {
-          for (const auto &object_name : boundary_and_object_names.second)
-            {
-              mesh_deformation_objects[boundary_and_object_names.first].push_back(
-                std::unique_ptr<Interface<dim>> (std::get<dim>(registered_plugins)
-                                                  .create_plugin (object_name,
-                                                                  "Mesh deformation::Model names")));
-
-              if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(mesh_deformation_objects[boundary_and_object_names.first].back().get()))
-                sim->initialize_simulator (this->get_simulator());
-
-              mesh_deformation_objects[boundary_and_object_names.first].back()->parse_parameters (prm);
-              mesh_deformation_objects[boundary_and_object_names.first].back()->initialize ();
-            }
-        }
-
-      // Go through the objects, and get the indicators for boundaries that need to be stabilized.
-      for (const auto &boundary_and_deformation_objects : mesh_deformation_objects)
-        {
-          for (const auto &model : boundary_and_deformation_objects.second)
-            if (model->needs_surface_stabilization() == true)
-              boundary_indicators_requiring_stabilization.insert(boundary_and_deformation_objects.first);
-        }
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::execute()
-    {
-      AssertThrow(sim.parameters.mesh_deformation_enabled, ExcInternalError());
-
-      TimerOutput::Scope timer (sim.computing_timer, "Mesh deformation");
-
-      old_mesh_displacements = mesh_displacements;
-
-      // Make the constraints for the elliptic problem.
-      make_constraints();
-
-      // Assemble and solve the vector Laplace problem which determines
-      // the mesh displacements in the interior of the domain
-      if (this->is_stokes_matrix_free())
-        compute_mesh_displacements_gmg();
-      else
-        compute_mesh_displacements();
-
-      // Interpolate the mesh velocity into the same
-      // finite element space as used in the Stokes solve, which
-      // is needed for the ALE corrections.
-      interpolate_mesh_velocity();
-
-      // After changing the mesh we need to rebuild things
-      sim.rebuild_stokes_matrix = sim.rebuild_stokes_preconditioner = true;
-    }
-
-
-
-    template <int dim>
-    const Mapping<dim> &
-    MeshDeformationHandler<dim>::get_level_mapping(const unsigned int level) const
-    {
-      return *level_mappings[level].get();
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::make_constraints()
-    {
-      AssertThrow(sim.parameters.mesh_deformation_enabled, ExcInternalError());
-
-      // Now construct the mesh displacement constraints
-      mesh_velocity_constraints.clear();
-#if DEAL_II_VERSION_GTE(9,6,0)
-      mesh_velocity_constraints.reinit(mesh_deformation_dof_handler.locally_owned_dofs(),
-                                       mesh_locally_relevant);
-#else
-      mesh_velocity_constraints.reinit(mesh_locally_relevant);
-#endif
-      // mesh_velocity_constraints can use the same hanging node
-      // information that was used for mesh_vertex constraints.
-      mesh_velocity_constraints.merge(mesh_vertex_constraints);
-
-      // Add the vanilla periodic boundary constraints
-      using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
-      const periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
-      for (const auto &p : pbp)
-        DoFTools::make_periodicity_constraints(mesh_deformation_dof_handler,
-                                               p.first.first,
-                                               p.first.second,
-                                               p.second,
-                                               mesh_velocity_constraints);
-
-      // Zero out the displacement for the zero-velocity boundaries
-      // if the boundary is not in the set of tangential mesh boundaries and not in the set of mesh deformation boundary indicators
-      for (const auto &boundary_id : zero_mesh_deformation_boundary_indicators)
-        {
-          VectorTools::interpolate_boundary_values (this->get_mapping(),
-                                                    mesh_deformation_dof_handler,
-                                                    boundary_id,
-                                                    Functions::ZeroFunction<dim>(dim),
-                                                    mesh_velocity_constraints);
-        }
-
-      this->get_signals().pre_compute_no_normal_flux_constraints(sim.triangulation);
-      // Make the no flux boundary constraints
-      VectorTools::compute_no_normal_flux_constraints (mesh_deformation_dof_handler,
-                                                       /* first_vector_component= */
-                                                       0,
-                                                       tangential_mesh_deformation_boundary_indicators,
-                                                       mesh_velocity_constraints,
-                                                       this->get_mapping());
-
-      this->get_signals().post_compute_no_normal_flux_constraints(sim.triangulation);
-
-      // Ask all plugins to add their constraints.
-      // For the moment add constraints from all plugins into one matrix, then
-      // merge that matrix with the existing constraints (respecting the existing
-      // constraints as more important)
-      AffineConstraints<double> plugin_constraints(mesh_vertex_constraints.get_local_lines());
-
-      for (const auto &boundary_id : mesh_deformation_objects)
-        {
-          std::set<types::boundary_id> boundary_id_set;
-          boundary_id_set.insert(boundary_id.first);
-
-          for (const auto &model : boundary_id.second)
-            {
-              AffineConstraints<double> current_plugin_constraints(mesh_vertex_constraints.get_local_lines());
-
-              model->compute_velocity_constraints_on_boundary(mesh_deformation_dof_handler,
-                                                              current_plugin_constraints,
-                                                              boundary_id_set);
-              if ((this->is_stokes_matrix_free()))
-                {
-                  mg_constrained_dofs.make_zero_boundary_constraints(mesh_deformation_dof_handler,
-                                                                     boundary_id_set);
-                }
-
-              const IndexSet local_lines = current_plugin_constraints.get_local_lines();
-              for (dealii::IndexSet::size_type local_line : local_lines)
-                {
-                  if (current_plugin_constraints.is_constrained(local_line))
-                    {
-                      if (plugin_constraints.is_constrained(local_line) == false)
-                        {
-#if DEAL_II_VERSION_GTE(9,6,0)
-                          plugin_constraints.add_constraint(local_line,
-                                                            {},
-                                                            current_plugin_constraints.get_inhomogeneity(local_line));
-#else
-                          plugin_constraints.add_line(local_line);
-                          plugin_constraints.set_inhomogeneity(local_line,
-                                                               current_plugin_constraints.get_inhomogeneity(local_line));
-#endif
-                        }
-                      else
-                        {
-                          // Add the inhomogeneity of the current plugin to the existing constraints
-                          const double inhomogeneity = plugin_constraints.get_inhomogeneity(local_line);
-                          plugin_constraints.set_inhomogeneity(local_line, current_plugin_constraints.get_inhomogeneity(local_line) + inhomogeneity);
-                        }
-                    }
-                }
-            }
-        }
-
-      mesh_velocity_constraints.merge(plugin_constraints,AffineConstraints<double>::left_object_wins);
-      mesh_velocity_constraints.close();
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::make_initial_constraints()
-    {
-      AssertThrow(this->get_parameters().mesh_deformation_enabled, ExcInternalError());
-
-      // This might look incorrect at first glance, but it is okay to
-      // overwrite the velocity constraints with our displacements
-      // because this object is used for updating the displacement in
-      // compute_mesh_displacements().
-      mesh_velocity_constraints.clear();
-#if DEAL_II_VERSION_GTE(9,6,0)
-      mesh_velocity_constraints.reinit(mesh_deformation_dof_handler.locally_owned_dofs(),
-                                       mesh_locally_relevant);
-#else
-      mesh_velocity_constraints.reinit(mesh_locally_relevant);
-#endif
-      // mesh_velocity_constraints can use the same hanging node
-      // information that was used for mesh_vertex constraints.
-      mesh_velocity_constraints.merge(mesh_vertex_constraints);
-
-      // Add the vanilla periodic boundary constraints
-      std::set<types::boundary_id> periodic_boundaries;
-      using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
-      const periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
-      for (const auto &p : pbp)
-        {
-          periodic_boundaries.insert(p.first.first);
-          periodic_boundaries.insert(p.first.second);
-
-          DoFTools::make_periodicity_constraints(mesh_deformation_dof_handler,
-                                                 p.first.first,
-                                                 p.first.second,
-                                                 p.second,
-                                                 mesh_velocity_constraints);
-        }
-
-      // Zero out the displacement for the fixed boundaries
-      for (const types::boundary_id &boundary_id : zero_mesh_deformation_boundary_indicators)
-        {
-          VectorTools::interpolate_boundary_values (this->get_mapping(),
-                                                    mesh_deformation_dof_handler,
-                                                    boundary_id,
-                                                    Functions::ZeroFunction<dim>(dim),
-                                                    mesh_velocity_constraints);
-        }
-
-      // Make tangential deformation constraints for tangential boundaries
-      this->get_signals().pre_compute_no_normal_flux_constraints(sim.triangulation);
-      VectorTools::compute_no_normal_flux_constraints (mesh_deformation_dof_handler,
-                                                       /* first_vector_component= */
-                                                       0,
-                                                       tangential_mesh_deformation_boundary_indicators,
-                                                       mesh_velocity_constraints,
-                                                       this->get_mapping());
-      this->get_signals().post_compute_no_normal_flux_constraints(sim.triangulation);
-
-      // Ask all plugins to add their constraints.
-      // For the moment add constraints from all plugins into one matrix, then
-      // merge that matrix with the existing constraints (respecting the existing
-      // constraints as more important)
-      AffineConstraints<double> plugin_constraints(mesh_vertex_constraints.get_local_lines());
-
-      std::set<types::boundary_id> boundary_id_set;
-
-      for (const auto &boundary_id_and_deformation_objects: mesh_deformation_objects)
-        {
-          for (const auto &deformation_object : boundary_id_and_deformation_objects.second)
-            {
-              AffineConstraints<double> current_plugin_constraints(mesh_vertex_constraints.get_local_lines());
-
-              Utilities::VectorFunctionFromVelocityFunctionObject<dim> vel
-              (dim,
-               [&] (const Point<dim> &x) -> Tensor<1,dim>
-              {
-                return deformation_object->compute_initial_deformation_on_boundary(boundary_id_and_deformation_objects.first, x);
-              });
-
-              VectorTools::interpolate_boundary_values (this->get_mapping(),
-                                                        mesh_deformation_dof_handler,
-                                                        boundary_id_and_deformation_objects.first,
-                                                        vel,
-                                                        current_plugin_constraints);
-
-              boundary_id_set.insert(boundary_id_and_deformation_objects.first);
-
-
-              const IndexSet local_lines = current_plugin_constraints.get_local_lines();
-              for (dealii::IndexSet::size_type local_line : local_lines)
-                {
-                  if (current_plugin_constraints.is_constrained(local_line))
-                    {
-                      if (plugin_constraints.is_constrained(local_line) == false)
-                        {
-#if DEAL_II_VERSION_GTE(9,6,0)
-                          plugin_constraints.add_constraint(local_line,
-                                                            {},
-                                                            current_plugin_constraints.get_inhomogeneity(local_line));
-#else
-                          plugin_constraints.add_line(local_line);
-                          plugin_constraints.set_inhomogeneity(local_line,
-                                                               current_plugin_constraints.get_inhomogeneity(local_line));
-#endif
-                        }
-                      else
-                        {
-                          // Add the current plugin constraints to the existing inhomogeneity
-                          const double inhomogeneity = plugin_constraints.get_inhomogeneity(local_line);
-                          plugin_constraints.set_inhomogeneity(local_line, current_plugin_constraints.get_inhomogeneity(local_line) + inhomogeneity);
-                        }
-                    }
-                }
-            }
-        }
-      if ((this->is_stokes_matrix_free()))
-        {
-          mg_constrained_dofs.make_zero_boundary_constraints(mesh_deformation_dof_handler,
-                                                             boundary_id_set);
-        }
-      mesh_velocity_constraints.merge(plugin_constraints,
-                                      AffineConstraints<double>::left_object_wins);
-      mesh_velocity_constraints.close();
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::compute_mesh_displacements()
-    {
-      // This functions updates the mesh displacement of the whole
-      // domain (stored in the vector mesh_displacements) based on
-      // information on the boundary.
-      //
-      // Each step, we get the velocity specified on the free surface
-      // boundary (stored in mesh_velocity_constraints) and solve for
-      // the velocity in the interior by solving a vector Laplace
-      // problem. This velocity is then used to update the
-      // displacement vector.
-      //
-      // This is different in timestep 0. Here, the information on the
-      // boundary is actually a displacement (given initial
-      // topography), which is used to set the initial
-      // displacement. The process in this function is otherwise
-      // identical.
-
-      const QGauss<dim> quadrature(mesh_deformation_fe.degree + 1);
-      UpdateFlags update_flags = UpdateFlags(update_values | update_JxW_values | update_gradients);
-      FEValues<dim> fe_values (*sim.mapping, mesh_deformation_fe, quadrature, update_flags);
-
-      const unsigned int dofs_per_cell = fe_values.dofs_per_cell,
-                         dofs_per_face = sim.finite_element.dofs_per_face,
-                         n_q_points    = fe_values.n_quadrature_points;
-
-      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
-      std::vector<unsigned int> face_dof_indices (dofs_per_face);
-      Vector<double> cell_vector (dofs_per_cell);
-      FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
-
-      // We are just solving a Laplacian in each spatial direction, so
-      // the degrees of freedom for different dimensions do not couple.
-      Table<2,DoFTools::Coupling> coupling (dim, dim);
-      coupling.fill(DoFTools::none);
-
-      for (unsigned int c=0; c<dim; ++c)
-        coupling[c][c] = DoFTools::always;
-
-      LinearAlgebra::SparseMatrix mesh_matrix;
-      TrilinosWrappers::SparsityPattern sp (mesh_locally_owned,
-                                            mesh_locally_owned,
-                                            mesh_locally_relevant,
-                                            sim.mpi_communicator);
-      DoFTools::make_sparsity_pattern (mesh_deformation_dof_handler,
-                                       coupling, sp,
-                                       mesh_velocity_constraints, false,
-                                       Utilities::MPI::
-                                       this_mpi_process(sim.mpi_communicator));
-      sp.compress();
-      mesh_matrix.reinit (sp);
-
-      // carry out the solution
-      FEValuesExtractors::Vector extract_vel(0);
-
-      LinearAlgebra::Vector rhs, solution;
-      rhs.reinit(mesh_locally_owned, sim.mpi_communicator);
-      solution.reinit(mesh_locally_owned, sim.mpi_communicator);
-
-      for (const auto &cell : mesh_deformation_dof_handler.active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            cell->get_dof_indices (cell_dof_indices);
-            fe_values.reinit (cell);
-
-            cell_vector = 0;
-            cell_matrix = 0;
-            for (unsigned int point=0; point<n_q_points; ++point)
-              for (unsigned int i=0; i<dofs_per_cell; ++i)
-                {
-                  for (unsigned int j=0; j<dofs_per_cell; ++j)
-                    cell_matrix(i,j) += scalar_product( fe_values[extract_vel].gradient(i,point),
-                                                        fe_values[extract_vel].gradient(j,point) ) *
-                                        fe_values.JxW(point);
-                }
-
-            mesh_velocity_constraints.distribute_local_to_global (cell_matrix, cell_vector,
-                                                                  cell_dof_indices, mesh_matrix, rhs, false);
-          }
-
-      rhs.compress (VectorOperation::add);
-      mesh_matrix.compress (VectorOperation::add);
-
-      // Make the AMG preconditioner
-      std::vector<std::vector<bool>> constant_modes;
-      DoFTools::extract_constant_modes (mesh_deformation_dof_handler,
-                                        ComponentMask(dim, true),
-                                        constant_modes);
-      // TODO: think about keeping object between time steps
-      LinearAlgebra::PreconditionAMG preconditioner_stiffness;
-      LinearAlgebra::PreconditionAMG::AdditionalData Amg_data;
-      Amg_data.constant_modes = constant_modes;
-      Amg_data.elliptic = true;
-      Amg_data.higher_order_elements = false;
-      Amg_data.smoother_sweeps = 2;
-      Amg_data.aggregation_threshold = 0.02;
-      preconditioner_stiffness.initialize(mesh_matrix);
-
-      // we solve with higher accuracy in the initial timestep:
-      const double tolerance
-        = sim.parameters.linear_stokes_solver_tolerance
-          * ((this->simulator_is_past_initialization()) ? 1.0 : 1e-5);
-
-      SolverControl solver_control(5*rhs.size(), tolerance * rhs.l2_norm());
-      SolverCG<LinearAlgebra::Vector> cg(solver_control);
-
-      cg.solve (mesh_matrix, solution, rhs, preconditioner_stiffness);
-      this->get_pcout() << "   Solving mesh displacement system... " << solver_control.last_step() <<" iterations."<< std::endl;
-
-      mesh_velocity_constraints.distribute (solution);
-
-      // Update the mesh velocity vector
-      fs_mesh_velocity = solution;
-
-      // Update the mesh displacement vector
-      if (this->simulator_is_past_initialization())
-        {
-          // during the simulation, we add dt*solution
-          LinearAlgebra::Vector distributed_mesh_displacements(mesh_locally_owned, sim.mpi_communicator);
-          distributed_mesh_displacements = mesh_displacements;
-          distributed_mesh_displacements.add(this->get_timestep(), solution);
-          mesh_displacements = distributed_mesh_displacements;
-        }
-      else
-        {
-          // In the initial step we apply 100% of the initial displacement
-          mesh_displacements = solution;
-        }
-
-      if (this->is_stokes_matrix_free())
-        update_multilevel_deformation();
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::compute_mesh_displacements_gmg()
-    {
-      // Same as compute_mesh_displacements, but using matrix-free GMG
-      // instead of matrix-based AMG.
-
-      // We use this gmg solver only when the gmg stokes solver is used
-      // for the following reasons (TODO):
-      // 1. this gmg solver does not support periodic boundary conditions
-      // 2. To use this solver even when gmg stokes solver is not used, we need to
-      //    initialize the triangulation with Triangulation<dim>::limit_level_difference_at_vertices
-      //    and parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy
-      // 3. Although this gmg solver is much faster than the amg solver, it's only tested for
-      //    limited free surface cases.
-
-      Assert(mesh_deformation_fe.degree == 1, ExcNotImplemented());
-      // To be efficient, the operations performed in the matrix-free implementation require
-      // knowledge of loop lengths at compile time, which are given by the degree of the finite element.
-      const unsigned int mesh_deformation_fe_degree = 1;
-
-      using SystemOperatorType = dealii::MatrixFreeOperators::
-                                 LaplaceOperator<dim, mesh_deformation_fe_degree, mesh_deformation_fe_degree + 1, dim>;
-
-      SystemOperatorType laplace_operator;
-
-      MGLevelObject<SystemOperatorType> mg_matrices;
-
-      typename MatrixFree<dim, double>::AdditionalData additional_data;
-      additional_data.tasks_parallel_scheme =
-        MatrixFree<dim, double>::AdditionalData::none;
-      const UpdateFlags update_flags(update_values | update_JxW_values | update_gradients);
-      additional_data.mapping_update_flags = update_flags;
-      std::shared_ptr<MatrixFree<dim, double>> system_mf_storage
-        = std::make_shared<MatrixFree<dim, double>>();
-      system_mf_storage->reinit(*sim.mapping,
-                                mesh_deformation_dof_handler,
-                                mesh_velocity_constraints,
-                                QGauss<1>(mesh_deformation_fe_degree + 1),
-                                additional_data);
-      laplace_operator.initialize(system_mf_storage);
-
-      // correct rhs:
-      // In a matrix-free method, since the LaplaceOperator class represents
-      // the matrix-vector product of a homogeneous operator (the left-hand
-      // side of the last formula). It does not matter whether the AffineConstraints
-      // object passed to the MatrixFree::reinit() contains inhomogeneous constraints or not,
-      // the MatrixFree::cell_loop() call will only resolve the homogeneous
-      // part of the constraints as long as it represents a linear operator.
-
-      // What this function does is to move the inhomogeneous constraints to the
-      // right-hand side of the system by computing the residual of the system
-      // and subtracting it from the right-hand side: r = b - A*u0,
-      // where u0 is the initial guess and stored the degrees of freedom constrained by
-      // Inhomogeneous Dirichlet boundary conditions, and r is rhs.
-      // Then we have a new system Ax = r, and the solution is u = u0 + x.
-      // More details can be found in deal.II tutorial step-37 Section Possibilities for extensions.
-      dealii::LinearAlgebra::distributed::Vector<double> u0, rhs, solution;
-      laplace_operator.initialize_dof_vector(u0);
-      laplace_operator.initialize_dof_vector(rhs);
-      laplace_operator.initialize_dof_vector(solution);
-      u0 = 0.;
-      mesh_velocity_constraints.distribute(u0);
-      u0.update_ghost_values();
-
-      rhs = 0.;
-
-      FEEvaluation<dim, mesh_deformation_fe_degree, mesh_deformation_fe_degree + 1, dim, double> mesh_deformation(*laplace_operator.get_matrix_free());
-      for (unsigned int cell = 0;
-           cell < laplace_operator.get_matrix_free()->n_cell_batches();
-           ++cell)
-        {
-          mesh_deformation.reinit(cell);
-          mesh_deformation.read_dof_values_plain(u0);
-          mesh_deformation.evaluate(EvaluationFlags::gradients);
-          for (unsigned int q = 0; q < mesh_deformation.n_q_points; ++q)
-            {
-              mesh_deformation.submit_gradient(-1.0 * mesh_deformation.get_gradient(q), q);
-            }
-          mesh_deformation.integrate(EvaluationFlags::gradients);
-          mesh_deformation.distribute_local_to_global(rhs);
-        }
-      rhs.compress(VectorOperation::add);
-
-      // clear the level constraints of the previous time step
-      mg_constrained_dofs.clear_user_constraints();
-
-      // setup GMG, following deal.II step-37:
-      const unsigned int n_levels = sim.triangulation.n_global_levels();
-
-      // Currently does not support periodic boundary constraints
-      {
-        using periodic_boundary_pairs = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
-        const periodic_boundary_pairs pbp = this->get_geometry_model().get_periodic_boundary_pairs();
-        AssertThrow(pbp.size() == 0,
-                    ExcMessage("Periodic boundary constraints are not supported in computing mesh displacements using GMG."));
-      }
-
-      mg_constrained_dofs.make_zero_boundary_constraints(mesh_deformation_dof_handler,
-                                                         zero_mesh_deformation_boundary_indicators);
-
-      mg_matrices.clear_elements();
-      mg_matrices.resize(0, n_levels-1);
-
-      for (unsigned int level = 0; level < n_levels; ++level)
-        {
-          IndexSet relevant_dofs;
-          DoFTools::extract_locally_relevant_level_dofs(mesh_deformation_dof_handler,
-                                                        level,
-                                                        relevant_dofs);
-          AffineConstraints<double> level_constraints;
-#if DEAL_II_VERSION_GTE(9,6,0)
-          level_constraints.reinit(mesh_deformation_dof_handler.locally_owned_mg_dofs(level),
-                                   relevant_dofs);
-          for (const auto index : mg_constrained_dofs.get_boundary_indices(level))
-            level_constraints.constrain_dof_to_zero(index);
-#else
-          level_constraints.reinit(relevant_dofs);
-          level_constraints.add_lines(mg_constrained_dofs.get_boundary_indices(level));
-#endif
-          level_constraints.close();
-
-          const Mapping<dim> &mapping = get_level_mapping(level);
-
-          std::set<types::boundary_id> no_flux_boundary
-            = sim.boundary_velocity_manager.get_tangential_boundary_velocity_indicators();
-          if (!no_flux_boundary.empty())
-            {
-              AffineConstraints<double> user_level_constraints;
-#if DEAL_II_VERSION_GTE(9,6,0)
-              user_level_constraints.reinit(mesh_deformation_dof_handler.locally_owned_mg_dofs(level),
-                                            relevant_dofs);
-#else
-              user_level_constraints.reinit(relevant_dofs);
-#endif
-              const IndexSet &refinement_edge_indices =
-                mg_constrained_dofs.get_refinement_edge_indices(level);
-              dealii::VectorTools::compute_no_normal_flux_constraints_on_level(
-                mesh_deformation_dof_handler,
-                0,
-                no_flux_boundary,
-                user_level_constraints,
-                mapping,
-                refinement_edge_indices,
-                level);
-
-              user_level_constraints.close();
-              mg_constrained_dofs.add_user_constraints(level, user_level_constraints);
-
-              // let Dirichlet values win over no normal flux:
-              level_constraints.merge(user_level_constraints, AffineConstraints<double>::left_object_wins);
-              level_constraints.close();
-            }
-
-          typename MatrixFree<dim, double>::AdditionalData additional_data;
-          additional_data.tasks_parallel_scheme =
-            MatrixFree<dim, double>::AdditionalData::none;
-          additional_data.mapping_update_flags = update_flags;
-          additional_data.mg_level = level;
-          std::shared_ptr<MatrixFree<dim, double>> mg_mf_storage_level
-            = std::make_shared<MatrixFree<dim, double>>();
-
-          mg_mf_storage_level->reinit(mapping,
-                                      mesh_deformation_dof_handler,
-                                      level_constraints,
-                                      QGauss<1>(mesh_deformation_fe_degree + 1),
-                                      additional_data);
-          mg_matrices[level].clear();
-          mg_matrices[level].initialize(mg_mf_storage_level,
-                                        mg_constrained_dofs,
-                                        level);
-        }
-
-      MGTransferMF<dim, double> mg_transfer(mg_constrained_dofs);
-      mg_transfer.build(mesh_deformation_dof_handler);
-
-      using SmootherType =
-        PreconditionChebyshev<SystemOperatorType, dealii::LinearAlgebra::distributed::Vector<double>>;
-
-      mg::SmootherRelaxation<SmootherType, dealii::LinearAlgebra::distributed::Vector<double>> mg_smoother;
-
-      MGLevelObject<typename SmootherType::AdditionalData> smoother_data;
-      smoother_data.resize(0, n_levels - 1);
-
-      // Smoother: Chebyshev, degree 5. We use a relatively high degree here (5),
-      // since matrix-vector products are comparably cheap. We choose to smooth out
-      // a range of [1.2lambda_max/15,1.2lambda_max] in the smoother where lambda_max
-      // is an estimate of the largest eigenvalue (the factor 1.2 is applied inside
-      // PreconditionChebyshev). In order to compute that eigenvalue,
-      // the Chebyshev initialization performs a few steps of a CG algorithm without preconditioner.
-      // Since the highest eigenvalue is usually the easiest one to find
-      // and a rough estimate is enough, we choose 10 iterations.
-      for (unsigned int level = 0; level < n_levels;
-           ++level)
-        {
-          if (level > 0)
-            {
-              smoother_data[level].smoothing_range = 15.;
-              smoother_data[level].degree = 5;
-              smoother_data[level].eig_cg_n_iterations = 10;
-            }
-          else
-            {
-              // On level zero, we initialize the smoother differently
-              // because we want to use the Chebyshev iteration as a solver.
-              smoother_data[0].smoothing_range = 1e-3;
-              smoother_data[0].degree = numbers::invalid_unsigned_int;
-              smoother_data[0].eig_cg_n_iterations = mg_matrices[0].m();
-            }
-          mg_matrices[level].compute_diagonal();
-          smoother_data[level].preconditioner =
-            mg_matrices[level].get_matrix_diagonal_inverse();
-        }
-      mg_smoother.initialize(mg_matrices, smoother_data);
-      MGCoarseGridApplySmoother<dealii::LinearAlgebra::distributed::Vector<double>> mg_coarse;
-      mg_coarse.initialize(mg_smoother);
-
-      // set up the interface matrices
-      mg::Matrix<dealii::LinearAlgebra::distributed::Vector<double>> mg_matrix(mg_matrices);
-      MGLevelObject<MatrixFreeOperators::MGInterfaceOperator<SystemOperatorType>> mg_interface_matrices;
-      mg_interface_matrices.resize(0, n_levels - 1);
-      for (unsigned int level = 0; level < n_levels;
-           ++level)
-        mg_interface_matrices[level].initialize(mg_matrices[level]);
-      mg::Matrix<dealii::LinearAlgebra::distributed::Vector<double>> mg_interface(mg_interface_matrices);
-      Multigrid<dealii::LinearAlgebra::distributed::Vector<double>> mg(mg_matrix, mg_coarse, mg_transfer, mg_smoother, mg_smoother);
-      mg.set_edge_matrices(mg_interface, mg_interface);
-      PreconditionMG<dim,
-                     dealii::LinearAlgebra::distributed::Vector<double>,
-                     MGTransferMF<dim, double>>
-                     preconditioner(mesh_deformation_dof_handler, mg, mg_transfer);
-
-
-      // solve
-      const double tolerance
-        = sim.parameters.linear_stokes_solver_tolerance
-          * ((this->simulator_is_past_initialization()) ? 1.0 : 1e-5);
-
-      SolverControl solver_control_mf(5 * rhs.size(),
-                                      tolerance * rhs.l2_norm());
-      SolverCG<dealii::LinearAlgebra::distributed::Vector<double>> cg(solver_control_mf);
-
-      mesh_velocity_constraints.set_zero(solution);
-      cg.solve(laplace_operator, solution, rhs, preconditioner);
-      this->get_pcout() << "   Solving mesh displacement system... " << solver_control_mf.last_step() <<" iterations."<< std::endl;
-
-      mesh_velocity_constraints.distribute(solution);
-      solution.update_ghost_values();
-
-      // copy solution:
-      LinearAlgebra::Vector solution_tmp;
-      solution_tmp.reinit(mesh_locally_owned, sim.mpi_communicator);
-      internal::ChangeVectorTypes::copy(solution_tmp, solution);
-
-      // Update the mesh velocity vector
-      fs_mesh_velocity = solution_tmp;
-
-      // Update the mesh displacement vector
-      if (this->simulator_is_past_initialization())
-        {
-          // during the simulation, we add dt*solution
-          LinearAlgebra::Vector distributed_mesh_displacements(mesh_locally_owned, sim.mpi_communicator);
-          distributed_mesh_displacements = mesh_displacements;
-          distributed_mesh_displacements.add(this->get_timestep(), solution_tmp);
-          mesh_displacements = distributed_mesh_displacements;
-        }
-      else
-        {
-          // In the initial step we apply 100% of the initial displacement
-          mesh_displacements = solution_tmp;
-        }
-
-      update_multilevel_deformation();
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::set_initial_topography()
-    {
-      LinearAlgebra::Vector distributed_initial_topography;
-      distributed_initial_topography.reinit(mesh_locally_owned, sim.mpi_communicator);
-
-      if (!include_initial_topography)
-        distributed_initial_topography = 0.;
-      else
-        {
-          const std::vector<Point<dim>> support_points
-            = mesh_deformation_fe.base_element(0).get_unit_support_points();
-
-          const Quadrature<dim> quad(support_points);
-          const UpdateFlags update_flags = UpdateFlags(update_quadrature_points);
-          FEValues<dim> fs_fe_values (*sim.mapping, mesh_deformation_fe, quad, update_flags);
-
-          const unsigned int n_q_points = fs_fe_values.n_quadrature_points,
-                             dofs_per_cell = fs_fe_values.dofs_per_cell;
-
-          std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
-
-          for (const auto &cell : mesh_deformation_dof_handler.active_cell_iterators())
-            if (cell->is_locally_owned())
-              {
-                cell->get_dof_indices (cell_dof_indices);
-
-                fs_fe_values.reinit (cell);
-                for (unsigned int j=0; j<n_q_points; ++j)
-                  {
-                    Point<dim-1> surface_point;
-                    std::array<double, dim> natural_coord = this->get_geometry_model().cartesian_to_natural_coordinates(fs_fe_values.quadrature_point(j));
-                    if (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()))
-                      {
-                        for (unsigned int d=0; d<dim-1; ++d)
-                          surface_point[d] = natural_coord[d];
-                      }
-                    else
-                      {
-                        for (unsigned int d=1; d<dim; ++d)
-                          surface_point[d-1] = natural_coord[d];
-                      }
-                    // Get the topography at this point.
-                    const double topo = this->get_initial_topography_model().value(surface_point);
-
-
-                    // TODO adapt to radial topography
-                    const unsigned int support_point_index
-                      = mesh_deformation_fe.component_to_system_index(dim-1,/*dof index within component=*/ j);
-                    distributed_initial_topography[cell_dof_indices[support_point_index]] = topo;
-                  }
-              }
-        }
-
-      distributed_initial_topography.compress(VectorOperation::insert);
-      initial_topography = distributed_initial_topography;
-    }
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::interpolate_mesh_velocity()
-    {
-      // Interpolate the mesh vertex velocity onto the Stokes velocity system for use in ALE corrections
-      LinearAlgebra::BlockVector distributed_mesh_velocity;
-      distributed_mesh_velocity.reinit(sim.introspection.index_sets.system_partitioning, sim.mpi_communicator);
-
-      const std::vector<Point<dim>> support_points
-        = sim.finite_element.base_element(sim.introspection.component_indices.velocities[0]).get_unit_support_points();
-
-      const Quadrature<dim> quad(support_points);
-      const UpdateFlags update_flags = UpdateFlags(update_values | update_JxW_values);
-      FEValues<dim> fs_fe_values (*sim.mapping, mesh_deformation_fe, quad, update_flags);
-      FEValues<dim> fe_values (*sim.mapping, sim.finite_element, quad, update_flags);
-      const unsigned int n_q_points = fe_values.n_quadrature_points,
-                         dofs_per_cell = fe_values.dofs_per_cell;
-
-      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
-      FEValuesExtractors::Vector extract_vel(0);
-      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
-
-      typename DoFHandler<dim>::active_cell_iterator
-      fscell = mesh_deformation_dof_handler.begin_active();
-
-      for (const auto &cell : sim.dof_handler.active_cell_iterators())
-        {
-          if (cell->is_locally_owned())
-            {
-              cell->get_dof_indices (cell_dof_indices);
-
-              fe_values.reinit (cell);
-              fs_fe_values.reinit (fscell);
-              fs_fe_values[extract_vel].get_function_values(fs_mesh_velocity, velocity_values);
-              for (unsigned int j=0; j<n_q_points; ++j)
-                for (unsigned int dir=0; dir<dim; ++dir)
-                  {
-                    const unsigned int support_point_index
-                      = sim.finite_element.component_to_system_index(/*velocity component=*/ sim.introspection.component_indices.velocities[dir],
-                                                                                             /*dof index within component=*/ j);
-                    distributed_mesh_velocity[cell_dof_indices[support_point_index]] = velocity_values[j][dir];
-                  }
-            }
-          ++fscell;
-        }
-
-      distributed_mesh_velocity.compress(VectorOperation::insert);
-      mesh_velocity = distributed_mesh_velocity;
-    }
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::setup_dofs()
-    {
-      AssertThrow(sim.parameters.mesh_deformation_enabled, ExcInternalError());
-
-      // these live in the same FE as the velocity variable:
-      mesh_velocity.reinit(sim.introspection.index_sets.system_partitioning,
-                           sim.introspection.index_sets.system_relevant_partitioning,
-                           sim.mpi_communicator);
-
-      mesh_deformation_dof_handler.distribute_dofs(mesh_deformation_fe);
-
-      // Renumber the DoFs hierarchical so that we get the
-      // same numbering if we resume the computation. This
-      // is because the numbering depends on the order the
-      // cells are created.
-      DoFRenumbering::hierarchical (mesh_deformation_dof_handler);
-
-      if (this->is_stokes_matrix_free())
-        {
-          mesh_deformation_dof_handler.distribute_mg_dofs();
-
-          mg_constrained_dofs.initialize(mesh_deformation_dof_handler);
-
-          const unsigned int n_levels = this->get_triangulation().n_global_levels();
-
-          level_displacements.resize(0, n_levels-1);
-          // Important! Preallocate level vectors with all needed ghost
-          // entries. While interpolate_to_mg can create these vectors
-          // automatically, they will not contain all ghost values that we
-          // need to evaluate the mapping later.
-          for (unsigned int level = 0; level < n_levels; ++level)
-            {
-              IndexSet relevant_mg_dofs;
-              DoFTools::extract_locally_relevant_level_dofs(mesh_deformation_dof_handler,
-                                                            level,
-                                                            relevant_mg_dofs);
-              level_displacements[level].reinit(mesh_deformation_dof_handler.locally_owned_mg_dofs(level),
-                                                relevant_mg_dofs,
-                                                sim.mpi_communicator);
-              level_displacements[level].update_ghost_values();
-            }
-
-          // create the mappings on each level:
-          level_mappings.resize(0, n_levels-1);
-          level_mappings.apply([&](const unsigned int level, std::unique_ptr<Mapping<dim>> &object)
-          {
-            object = std::make_unique<MappingQEulerian<dim,
-            dealii::LinearAlgebra::distributed::Vector<double>>>(
-              /* degree = */ 1,
-              mesh_deformation_dof_handler,
-              level_displacements[level],
-              level);
-          });
-
-          mg_transfer.build(mesh_deformation_dof_handler);
-
-        }
-
-      {
-        std::locale s = this->get_pcout().get_stream().getloc();
-        // Creating std::locale with an empty string previously caused problems
-        // on some platforms, so the functionality to catch the exception and ignore
-        // is kept here, even though explicitly setting a facet should always work.
-        try
-          {
-            // Imbue the stream with a locale that does the right thing. The
-            // locale is responsible for later deleting the object pointed
-            // to by the last argument (the "facet"), see
-            // https://en.cppreference.com/w/cpp/locale/locale/locale
-            this->get_pcout().get_stream().imbue(std::locale(std::locale(),
-                                                             new aspect::Utilities::ThousandSep));
-          }
-        catch (const std::runtime_error &e)
-          {
-            // If the locale doesn't work, just give up
-          }
-
-        this->get_pcout() << "Number of mesh deformation degrees of freedom: "
-                          << mesh_deformation_dof_handler.n_dofs()
-                          << std::endl;
-
-        this->get_pcout().get_stream().imbue(s);
-      }
-
-      mesh_locally_owned = mesh_deformation_dof_handler.locally_owned_dofs();
-      DoFTools::extract_locally_relevant_dofs (mesh_deformation_dof_handler,
-                                               mesh_locally_relevant);
-
-      // This will initialize the mesh displacement and free surface
-      // mesh velocity vectors with zero-valued entries.
-      mesh_displacements.reinit(mesh_locally_owned, mesh_locally_relevant, sim.mpi_communicator);
-      old_mesh_displacements.reinit(mesh_locally_owned, mesh_locally_relevant, sim.mpi_communicator);
-      initial_topography.reinit(mesh_locally_owned, mesh_locally_relevant, sim.mpi_communicator);
-      fs_mesh_velocity.reinit(mesh_locally_owned, mesh_locally_relevant, sim.mpi_communicator);
-
-      // if we are just starting, we need to set the initial topography.
-      if (this->simulator_is_past_initialization() == false ||
-          this->get_timestep_number() == 0)
-        set_initial_topography();
-
-      // We would like to make sure that the mesh stays conforming upon
-      // redistribution, so we construct mesh_vertex_constraints, which
-      // keeps track of hanging node constraints.
-      // Note: this would be a more natural fit in make_constraints(),
-      // but we would like to be able to apply vertex constraints directly
-      // after setup_dofs(), as is done, for instance, during mesh
-      // refinement.
-      mesh_vertex_constraints.clear();
-#if DEAL_II_VERSION_GTE(9,6,0)
-      mesh_vertex_constraints.reinit(mesh_deformation_dof_handler.locally_owned_dofs(),
-                                     mesh_locally_relevant);
-#else
-      mesh_vertex_constraints.reinit(mesh_locally_relevant);
-#endif
-      DoFTools::make_hanging_node_constraints(mesh_deformation_dof_handler, mesh_vertex_constraints);
-
-      // We can safely close this now
-      mesh_vertex_constraints.close();
-
-      // if we are just starting, we need to prescribe the initial deformation
-      if (this->simulator_is_past_initialization() == false ||
-          this->get_timestep_number() == 0)
-        {
-          TimerOutput::Scope timer (sim.computing_timer, "Mesh deformation initialize");
-
-          make_initial_constraints();
-          if (this->is_stokes_matrix_free())
-            compute_mesh_displacements_gmg();
-          else
-            compute_mesh_displacements();
-        }
-
-      if (this->is_stokes_matrix_free())
-        update_multilevel_deformation();
-    }
-
-
-
-    template <int dim>
-    void MeshDeformationHandler<dim>::update_multilevel_deformation ()
-    {
-      Assert(this->is_stokes_matrix_free(), ExcInternalError());
-
-      // Convert the mesh_displacements to a d:Vector that we can use
-      // to transfer to the MG levels below. The conversion is done by
-      // going through a ReadWriteVector.
-      dealii::LinearAlgebra::distributed::Vector<double> displacements(mesh_deformation_dof_handler.locally_owned_dofs(),
-                                                                       this->get_triangulation().get_communicator());
-      dealii::LinearAlgebra::ReadWriteVector<double> rwv;
-      rwv.reinit(mesh_displacements);
-      displacements.import(rwv, VectorOperation::insert);
-
-      const unsigned int n_levels = sim.triangulation.n_global_levels();
-      for (unsigned int level = 0; level < n_levels; ++level)
-        {
-          level_displacements[level].zero_out_ghost_values();
-        }
-
-      mg_transfer.interpolate_to_mg(mesh_deformation_dof_handler,
-                                    level_displacements,
-                                    displacements);
-
-      for (unsigned int level = 0; level < n_levels; ++level)
-        {
-          level_displacements[level].update_ghost_values();
-        }
-
-    }
-
-
-
-    template <int dim>
-    const std::map<types::boundary_id, std::vector<std::string>> &
-    MeshDeformationHandler<dim>::get_active_mesh_deformation_names () const
-    {
-      return mesh_deformation_object_names;
-    }
-
-
-
-    template <int dim>
-    const std::map<types::boundary_id,std::vector<std::unique_ptr<Interface<dim>>>> &
-    MeshDeformationHandler<dim>::get_active_mesh_deformation_models () const
-    {
-      return mesh_deformation_objects;
-    }
-
-
-
-    template <int dim>
-    const std::set<types::boundary_id> &
-    MeshDeformationHandler<dim>::get_active_mesh_deformation_boundary_indicators () const
-    {
-      return prescribed_mesh_deformation_boundary_indicators;
-    }
-
-
-
-    template <int dim>
-    const std::set<types::boundary_id> &
-    MeshDeformationHandler<dim>::get_boundary_indicators_requiring_stabilization () const
-    {
-      return boundary_indicators_requiring_stabilization;
-    }
-
-
-
-    template <int dim>
-    const std::set<types::boundary_id> &
-    MeshDeformationHandler<dim>::get_free_surface_boundary_indicators () const
-    {
-      return free_surface_boundary_indicators;
-    }
-
-
-
-    template <int dim>
-    double MeshDeformationHandler<dim>::get_free_surface_theta()const
-    {
-      return surface_theta;
-    }
-
-
-
-    template <int dim>
-    const LinearAlgebra::Vector &
-    MeshDeformationHandler<dim>::get_mesh_displacements () const
-    {
-      return mesh_displacements;
-    }
-
-
-
-    template <int dim>
-    const DoFHandler<dim> &
-    MeshDeformationHandler<dim>::get_mesh_deformation_dof_handler () const
-    {
-      return mesh_deformation_dof_handler;
-    }
-
-
-
-    template <int dim>
-    const LinearAlgebra::Vector &
-    MeshDeformationHandler<dim>::get_initial_topography () const
-    {
-      return initial_topography;
-    }
-
-
-
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ()
-    {
-      return std::get<dim>(registered_plugins).get_pattern_of_names ();
-    }
-
-
-
-    template <int dim>
-    void
-    MeshDeformationHandler<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Mesh deformation interface",
-                                                            out);
-    }
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<MeshDeformation::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<MeshDeformation::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<MeshDeformation::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<MeshDeformation::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace MeshDeformation
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class MeshDeformationHandler<dim>; \
-  \
-  template \
-  std::string \
-  get_valid_model_names_pattern<dim> ();
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/mesh_refinement/artificial_viscosity.cc.bak b/source/mesh_refinement/artificial_viscosity.cc.bak
deleted file mode 100644
index 55573204606..00000000000
--- a/source/mesh_refinement/artificial_viscosity.cc.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
-  Copyright (C) 2015 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/artificial_viscosity.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    ArtificialViscosity<dim>::execute(Vector<float> &indicators) const
-    {
-      indicators = 0;
-      Vector<float> this_indicator(indicators.size());
-      if (temperature_scaling_factor > 0.0)
-        {
-          this->get_artificial_viscosity(indicators);
-          indicators *= temperature_scaling_factor;
-        }
-
-      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-        {
-          this_indicator = 0;
-          this->get_artificial_viscosity_composition(this_indicator, c);
-
-          // compute indicators += c*this_indicator:
-          indicators.add(composition_scaling_factors[c], this_indicator);
-        }
-    }
-
-    template <int dim>
-    void
-    ArtificialViscosity<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Artificial viscosity");
-        {
-          prm.declare_entry("Temperature scaling factor",
-                            "0.0",
-                            Patterns::Double (0.),
-                            "A scaling factor for the artificial viscosity "
-                            " of the temperature equation. Use 0.0 to disable.");
-          prm.declare_entry("Compositional field scaling factors",
-                            "",
-                            Patterns::List (Patterns::Double (0.)),
-                            "A list of scaling factors by which every individual compositional "
-                            "field will be multiplied. These "
-                            "factors are used to weigh the various indicators relative to "
-                            "each other and to the temperature. "
-                            "\n\n"
-                            "If the list of scaling factors given in this parameter is empty, then this "
-                            "indicates that they should all be chosen equal to 0. If the list "
-                            "is not empty then it needs to have as many entries as there are "
-                            "compositional fields.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    ArtificialViscosity<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Artificial viscosity");
-        {
-          temperature_scaling_factor = prm.get_double("Temperature scaling factor");
-
-          composition_scaling_factors
-            = Utilities::string_to_double(
-                Utilities::split_string_list(prm.get("Compositional field scaling factors")));
-
-          AssertThrow (composition_scaling_factors.size() == this->n_compositional_fields()
-                       ||
-                       composition_scaling_factors.size() == 0,
-                       ExcMessage ("The number of scaling factors given here must either be "
-                                   "zero or equal to the number of chosen refinement criteria."));
-
-          if (composition_scaling_factors.size() == 0)
-            composition_scaling_factors.resize (this->n_compositional_fields(), 0.0);
-
-          const double sum_composition_factors =
-            std::accumulate (composition_scaling_factors.begin(),
-                             composition_scaling_factors.end(), 0.0);
-
-          AssertThrow(sum_composition_factors + temperature_scaling_factor > 0.0,
-                      ExcMessage("You need to have a positive scaling factor "
-                                 "for at least one variable."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(ArtificialViscosity,
-                                              "artificial viscosity",
-                                              "A mesh refinement criterion that computes "
-                                              "refinement indicators from the artificial viscosity "
-                                              "of the temperature or compositional fields "
-                                              "based on user specified weights.")
-  }
-}
diff --git a/source/mesh_refinement/boundary.cc.bak b/source/mesh_refinement/boundary.cc.bak
deleted file mode 100644
index e51173946f2..00000000000
--- a/source/mesh_refinement/boundary.cc.bak
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/boundary.h>
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    Boundary<dim>::execute(Vector<float> &indicators) const
-    {
-      indicators = 0;
-
-      // iterate over all of the cells and choose the ones at the indicated
-      // boundaries for refinement (assign the largest error to them)
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          for (const unsigned int face_no : cell->face_indices())
-            if (cell->face(face_no)->at_boundary())
-              {
-                const types::boundary_id boundary_indicator
-                  = cell->face(face_no)->boundary_id();
-                if ( boundary_refinement_indicators.find(boundary_indicator) !=
-                     boundary_refinement_indicators.end() )
-                  {
-                    indicators(cell->active_cell_index()) = 1.0;
-                    break;  // no need to loop over the rest of the faces
-                  }
-              }
-
-    }
-
-    template <int dim>
-    void
-    Boundary<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Boundary");
-        {
-          prm.declare_entry ("Boundary refinement indicators", "",
-                             Patterns::List (Patterns::Anything()),
-                             "A comma separated list of names denoting those boundaries "
-                             "where there should be mesh refinement."
-                             "\n\n"
-                             "The names of the boundaries listed here can either be "
-                             "numbers (in which case they correspond to the numerical "
-                             "boundary indicators assigned by the geometry object), or they "
-                             "can correspond to any of the symbolic names the geometry object "
-                             "may have provided for each part of the boundary. You may want "
-                             "to compare this with the documentation of the geometry model you "
-                             "use in your model.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    Boundary<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Boundary");
-        {
-          const std::vector<types::boundary_id> x_boundary_refinement_indicators
-            = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
-                                                                                  (prm.get ("Boundary refinement indicators")));
-          boundary_refinement_indicators
-            = std::set<types::boundary_id> (x_boundary_refinement_indicators.begin(),
-                                            x_boundary_refinement_indicators.end());
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Boundary,
-                                              "boundary",
-                                              "A class that implements a mesh refinement criterion which "
-                                              "always flags all cells on specified boundaries for refinement. "
-                                              "This is useful to provide high accuracy for processes at or "
-                                              "close to the edge of the model domain."
-                                              "\n\n"
-                                              "To use this refinement criterion, you may want to combine "
-                                              "it with other refinement criteria, setting the 'Normalize "
-                                              "individual refinement criteria' flag and using the `max' "
-                                              "setting for 'Refinement criteria merge operation'.")
-  }
-}
diff --git a/source/mesh_refinement/compaction_length.cc.bak b/source/mesh_refinement/compaction_length.cc.bak
deleted file mode 100644
index 13d0ac9f614..00000000000
--- a/source/mesh_refinement/compaction_length.cc.bak
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/compaction_length.h>
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    CompactionLength<dim>::tag_additional_cells () const
-    {
-      // tag_additional_cells is executed before the equations are solved
-      // for the very first time. If we do not have the finite element, we
-      // do not have any material properties and just do nothing in this plugin.
-      if (this->get_dof_handler().n_locally_owned_dofs() == 0)
-        return;
-
-      // Use a quadrature in the support points of the porosity to compute the
-      // compaction length at:
-      const typename Simulator<dim>::AdvectionField porosity = Simulator<dim>::AdvectionField::composition(
-                                                                 this->introspection().compositional_index_for_name("porosity"));
-
-      const unsigned int base_element_index = porosity.base_element(this->introspection());
-      const Quadrature<dim> quadrature(this->get_fe().base_element(base_element_index).get_unit_support_points());
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature,
-                               update_quadrature_points | update_values | update_gradients);
-
-      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
-      MeltHandler<dim>::create_material_model_outputs(out);
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            bool refine = false;
-            bool clear_coarsen = false;
-
-            fe_values.reinit(cell);
-            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-            this->get_material_model().evaluate(in, out);
-
-            MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-            AssertThrow(melt_out != nullptr,
-                        ExcMessage("Need MeltOutputs from the material model for computing the melt properties."));
-
-            // for each composition dof, check if the compaction length exceeds the cell size
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                const double compaction_length = std::sqrt((out.viscosities[i] + 4./3. * melt_out->compaction_viscosities[i])
-                                                           * melt_out->permeabilities[i] / melt_out->fluid_viscosities[i]);
-
-                // If the compaction length exceeds the cell diameter anywhere in the cell, cell is marked for refinement.
-                // Do not apply any refinement if the porosity is so small that melt can not migrate.
-                if (compaction_length < 2.0 * cells_per_compaction_length * cell->minimum_vertex_distance()
-                    && this->get_melt_handler().is_melt_cell(cell))
-                  clear_coarsen = true;
-
-                if (compaction_length < cells_per_compaction_length * cell->minimum_vertex_distance()
-                    && this->get_melt_handler().is_melt_cell(cell))
-                  {
-                    refine = true;
-                    break;
-                  }
-              }
-
-            if (clear_coarsen)
-              cell->clear_coarsen_flag ();
-            if (refine)
-              cell->set_refine_flag ();
-          }
-    }
-
-    template <int dim>
-    void
-    CompactionLength<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Compaction length");
-        {
-          prm.declare_entry("Mesh cells per compaction length", "1.0",
-                            Patterns::Double (0.),
-                            "The desired ratio between compaction length and size of the "
-                            "mesh cells, or, in other words, how many cells the mesh should "
-                            "(at least) have per compaction length. Every cell where this "
-                            "ratio is smaller than the value specified by this parameter "
-                            "(in places with fewer mesh cells per compaction length) is "
-                            "marked for refinement.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    CompactionLength<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Compaction length");
-        {
-          cells_per_compaction_length = prm.get_double ("Mesh cells per compaction length");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(CompactionLength,
-                                              "compaction length",
-                                              "A mesh refinement criterion for models with melt transport "
-                                              "that computes refinement indicators based on the compaction "
-                                              "length, defined as "
-                                              "$\\delta = \\sqrt{\\frac{(\\xi + 4 \\eta/3) k}{\\eta_f}}$. "
-                                              "$\\xi$ is the bulk viscosity, $\\eta$ is the shear viscosity, "
-                                              "$k$ is the permeability and $\\eta_f$ is the melt viscosity. "
-                                              "If the cell width or height exceeds a multiple (which is "
-                                              "specified as an input parameter) of this compaction length, "
-                                              "the cell is marked for refinement.")
-  }
-}
diff --git a/source/mesh_refinement/composition.cc.bak b/source/mesh_refinement/composition.cc.bak
deleted file mode 100644
index 69a9c76d6a0..00000000000
--- a/source/mesh_refinement/composition.cc.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/composition.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    Composition<dim>::execute(Vector<float> &indicators) const
-    {
-      AssertThrow (this->n_compositional_fields() >= 1,
-                   ExcMessage ("This refinement criterion cannot be used when no "
-                               "compositional fields are active!"));
-      indicators = 0;
-      Vector<float> this_indicator (indicators.size());
-
-      const Quadrature<dim-1> &quadrature = this->introspection().face_quadratures.compositional_fields;
-
-      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-        {
-          this_indicator = 0;
-          KellyErrorEstimator<dim>::estimate (this->get_mapping(),
-                                              this->get_dof_handler(),
-                                              quadrature,
-                                              std::map<types::boundary_id,const Function<dim>*>(),
-                                              this->get_solution(),
-                                              this_indicator,
-                                              this->introspection().component_masks.compositional_fields[c],
-                                              nullptr,
-                                              0,
-                                              this->get_triangulation().locally_owned_subdomain());
-          // compute indicators += c*this_indicator:
-          indicators.add(composition_scaling_factors[c], this_indicator);
-        }
-    }
-
-    template <int dim>
-    void
-    Composition<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Composition");
-        {
-          prm.declare_entry("Compositional field scaling factors",
-                            "",
-                            Patterns::List (Patterns::Double (0.)),
-                            "A list of scaling factors by which every individual compositional "
-                            "field will be multiplied. If only a single compositional "
-                            "field exists, then this parameter has no particular meaning. "
-                            "On the other hand, if multiple criteria are chosen, then these "
-                            "factors are used to weigh the various indicators relative to "
-                            "each other. "
-                            "\n\n"
-                            "If the list of scaling factors given in this parameter is empty, then this "
-                            "indicates that they should all be chosen equal to one. If the list "
-                            "is not empty then it needs to have as many entries as there are "
-                            "compositional fields.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    Composition<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Composition");
-        {
-          composition_scaling_factors
-            = Utilities::string_to_double(
-                Utilities::split_string_list(prm.get("Compositional field scaling factors")));
-
-          AssertThrow (composition_scaling_factors.size() == this->n_compositional_fields()
-                       ||
-                       composition_scaling_factors.size() == 0,
-                       ExcMessage ("The number of scaling factors given here must either be "
-                                   "zero or equal to the number of chosen refinement criteria."));
-
-          if (composition_scaling_factors.size() == 0)
-            composition_scaling_factors.resize (this->n_compositional_fields(), 1.0);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Composition,
-                                              "composition",
-                                              "A mesh refinement criterion that computes "
-                                              "refinement indicators from the compositional fields. "
-                                              "If there is more than one compositional field, then "
-                                              "it simply takes the sum of the indicators computed "
-                                              "from each of the compositional field."
-                                              "\n\n"
-                                              "The way these indicators are computed is by "
-                                              "evaluating the `Kelly error indicator' on each "
-                                              "compositional field. This error indicator takes the "
-                                              "finite element approximation of the compositional "
-                                              "field and uses it to compute an approximation "
-                                              "of the second derivatives of the composition for "
-                                              "each cell. This approximation is then multiplied "
-                                              "by an appropriate power of the cell's diameter "
-                                              "to yield an indicator for how large the error "
-                                              "is likely going to be on this cell. This "
-                                              "construction rests on the observation that for "
-                                              "many partial differential equations, the error "
-                                              "on each cell is proportional to some power of "
-                                              "the cell's diameter times the second derivatives "
-                                              "of the solution on that cell."
-                                              "\n\n"
-                                              "For complex equations such as those we solve "
-                                              "here, this observation may not be strictly "
-                                              "true in the mathematical sense, but it often "
-                                              "yields meshes that are surprisingly good.")
-  }
-}
diff --git a/source/mesh_refinement/composition_approximate_gradient.cc.bak b/source/mesh_refinement/composition_approximate_gradient.cc.bak
deleted file mode 100644
index 0397704160a..00000000000
--- a/source/mesh_refinement/composition_approximate_gradient.cc.bak
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/composition_approximate_gradient.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/derivative_approximation.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    CompositionApproximateGradient<dim>::execute(Vector<float> &indicators) const
-    {
-      AssertThrow (this->n_compositional_fields() >= 1,
-                   ExcMessage ("This refinement criterion can not be used when no "
-                               "compositional fields are active!"));
-      indicators = 0;
-      // create a vector with the requisite ghost elements
-      // and use it for estimating the gradients of compositional field
-      LinearAlgebra::BlockVector vec(this->introspection().index_sets.system_partitioning,
-                                     this->introspection().index_sets.system_relevant_partitioning,
-                                     this->get_mpi_communicator());
-      Vector<float> indicators_tmp(this->get_triangulation().n_active_cells());
-      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-        {
-          const unsigned int block_idx = this->introspection().block_indices.compositional_fields[c];
-          vec.block(block_idx) = this->get_solution().block(block_idx);
-          vec.compress(VectorOperation::insert);
-          indicators_tmp = 0;
-          DerivativeApproximation::approximate_gradient(this->get_mapping(),
-                                                        this->get_dof_handler(),
-                                                        vec,
-                                                        indicators_tmp,
-                                                        this->introspection().component_indices.compositional_fields[c]);
-
-          indicators_tmp *= composition_scaling_factors[c];
-
-          // Scale approximated gradient in each cell with the correct power of h. Otherwise,
-          // error indicators do not reduce when refined if there is a density
-          // jump. We need at least order 1 for the error not to grow when
-          // refining, so anything >1 should work. (note that the gradient
-          // itself scales like 1/h, so multiplying it with any factor h^s, s>1
-          // will yield convergence of the error indicators to zero as h->0)
-          const double power = 1.0 + dim / 2.0;
-          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-            if (cell->is_locally_owned())
-              indicators_tmp(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
-
-          indicators += indicators_tmp;
-        }
-    }
-
-
-    template <int dim>
-    void
-    CompositionApproximateGradient<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Composition approximate gradient");
-        {
-          prm.declare_entry("Compositional field scaling factors",
-                            "",
-                            Patterns::List (Patterns::Double (0.)),
-                            "A list of scaling factors by which every individual compositional "
-                            "field gradient will be multiplied. If only a single compositional "
-                            "field exists, then this parameter has no particular meaning. "
-                            "On the other hand, if multiple criteria are chosen, then these "
-                            "factors are used to weigh the various indicators relative to "
-                            "each other. "
-                            "\n\n"
-                            "If the list of scaling factors given in this parameter is empty, then this "
-                            "indicates that they should all be chosen equal to one. If the list "
-                            "is not empty then it needs to have as many entries as there are "
-                            "compositional fields.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    CompositionApproximateGradient<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Composition approximate gradient");
-        {
-          composition_scaling_factors
-            = Utilities::string_to_double(
-                Utilities::split_string_list(prm.get("Compositional field scaling factors")));
-
-          AssertThrow (composition_scaling_factors.size() == this->n_compositional_fields()
-                       ||
-                       composition_scaling_factors.size() == 0,
-                       ExcMessage ("The number of scaling factors given here must either be "
-                                   "zero or equal to the number of chosen refinement criteria."));
-
-          if (composition_scaling_factors.size() == 0)
-            composition_scaling_factors.resize (this->n_compositional_fields(), 1.0);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(CompositionApproximateGradient,
-                                              "composition approximate gradient",
-                                              "A mesh refinement criterion that computes refinement "
-                                              "indicators from the gradients of compositional fields. "
-                                              "If there is more than one compositional field, then "
-                                              "it simply takes the sum of the indicators times "
-                                              "a user-specified weight for each field."
-                                              "\n\n"
-                                              "In contrast to the `composition gradient' refinement "
-                                              "criterion, the current criterion does not "
-                                              "compute the gradient at quadrature points on each cell, "
-                                              "but by a finite difference approximation between the "
-                                              "centers of cells. Consequently, it also works if "
-                                              "the compositional fields are computed using discontinuous "
-                                              "finite elements.")
-  }
-}
diff --git a/source/mesh_refinement/composition_gradient.cc.bak b/source/mesh_refinement/composition_gradient.cc.bak
deleted file mode 100644
index 47eace30bb8..00000000000
--- a/source/mesh_refinement/composition_gradient.cc.bak
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/mesh_refinement/composition_gradient.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    CompositionGradient<dim>::execute(Vector<float> &indicators) const
-    {
-      AssertThrow (this->n_compositional_fields() >= 1,
-                   ExcMessage ("This refinement criterion can not be used when no "
-                               "compositional fields are active!"));
-
-      indicators = 0;
-      const double power = 1.0 + dim/2.0;
-
-      for (const unsigned int base_element_index : this->introspection().get_composition_base_element_indices())
-        {
-          const Quadrature<dim> quadrature (this->get_fe().base_element(base_element_index).get_unit_support_points());
-          const unsigned int dofs_per_cell = quadrature.size();
-          FEValues<dim> fe_values (this->get_mapping(),
-                                   this->get_fe(),
-                                   quadrature,
-                                   update_quadrature_points | update_gradients);
-
-          // the values of the compositional fields are stored as block vectors for each field
-          // we have to extract them in this structure
-          std::vector<Tensor<1,dim>> composition_gradients (quadrature.size());
-
-          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-            if (cell->is_locally_owned())
-              {
-                const unsigned int idx = cell->active_cell_index();
-                fe_values.reinit(cell);
-
-                for (const unsigned int c : this->introspection().get_compositional_field_indices_with_base_element(base_element_index))
-                  {
-                    const typename Simulator<dim>::AdvectionField composition = Simulator<dim>::AdvectionField::composition(c);
-                    fe_values[composition.scalar_extractor(this->introspection())].get_function_gradients (this->get_solution(),
-                        composition_gradients);
-
-                    // Some up the indicators for this composition on this cell. Note that quadrature points and dofs
-                    // are enumerated in the same order.
-                    double this_indicator = 0.0;
-                    for (unsigned int j=0; j<dofs_per_cell; ++j)
-                      this_indicator += composition_gradients[j].norm();
-
-                    // Scale gradient in each cell with the correct power of h. Otherwise,
-                    // error indicators do not reduce when refined if there is a density
-                    // jump. We need at least order 1 for the error not to grow when
-                    // refining, so anything >1 should work. (note that the gradient
-                    // itself scales like 1/h, so multiplying it with any factor h^s, s>1
-                    // will yield convergence of the error indicators to zero as h->0)
-                    this_indicator *= std::pow(cell->diameter(), power);
-
-                    indicators[idx] += composition_scaling_factors[c] * this_indicator;
-                  }
-              }
-        }
-    }
-
-    template <int dim>
-    void
-    CompositionGradient<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Composition gradient");
-        {
-          prm.declare_entry("Compositional field scaling factors",
-                            "",
-                            Patterns::List (Patterns::Double (0.)),
-                            "A list of scaling factors by which every individual compositional "
-                            "field gradient will be multiplied. If only a single compositional "
-                            "field exists, then this parameter has no particular meaning. "
-                            "On the other hand, if multiple criteria are chosen, then these "
-                            "factors are used to weigh the various indicators relative to "
-                            "each other. "
-                            "\n\n"
-                            "If the list of scaling factors given in this parameter is empty, then this "
-                            "indicates that they should all be chosen equal to one. If the list "
-                            "is not empty then it needs to have as many entries as there are "
-                            "compositional fields.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    CompositionGradient<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Composition gradient");
-        {
-          composition_scaling_factors
-            = Utilities::string_to_double(
-                Utilities::split_string_list(prm.get("Compositional field scaling factors")));
-
-          AssertThrow (composition_scaling_factors.size() == this->n_compositional_fields()
-                       ||
-                       composition_scaling_factors.size() == 0,
-                       ExcMessage ("The number of scaling factors given here must either be "
-                                   "zero or equal to the number of chosen refinement criteria."));
-
-          if (composition_scaling_factors.size() == 0)
-            composition_scaling_factors.resize (this->n_compositional_fields(), 1.0);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(CompositionGradient,
-                                              "composition gradient",
-                                              "A mesh refinement criterion that computes refinement "
-                                              "indicators from the gradients of compositional fields. "
-                                              "If there is more than one compositional field, then "
-                                              "it simply takes the sum of the indicators times "
-                                              "a user-specified weight for each field."
-                                              "\n\n"
-                                              "This refinement criterion computes the gradient of "
-                                              "the compositional field at quadrature points on each "
-                                              "cell, and then averages them in some way to obtain a "
-                                              "refinement indicator for each cell. This will give a "
-                                              "reasonable approximation of the true gradient of the "
-                                              "compositional field if you are using a continuous "
-                                              "finite element."
-                                              "\n\n"
-                                              "On the other hand, for discontinuous "
-                                              "finite elements (see the `Use discontinuous composition "
-                                              "discretization' parameter in the `Discretization' "
-                                              "section), the gradient at quadrature points does not "
-                                              "include the contribution of jumps in the compositional "
-                                              "field between cells, and consequently will not be an "
-                                              "accurate approximation of the true gradient. As an "
-                                              "extreme example, consider the case of using piecewise "
-                                              "constant finite elements for compositional fields; in "
-                                              "that case, the gradient of the solution at quadrature "
-                                              "points inside each cell will always be exactly zero, "
-                                              "even if the finite element solution is different "
-                                              "from each cell to the next. Consequently, the "
-                                              "current refinement criterion will likely not be "
-                                              "useful in this situation. That said, "
-                                              "the `composition approximate "
-                                              "gradient' refinement criterion exists for exactly "
-                                              "this purpose.")
-  }
-}
diff --git a/source/mesh_refinement/composition_threshold.cc.bak b/source/mesh_refinement/composition_threshold.cc.bak
deleted file mode 100644
index d2ad3cbf622..00000000000
--- a/source/mesh_refinement/composition_threshold.cc.bak
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-  Copyright (C) 2015 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/composition_threshold.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    CompositionThreshold<dim>::tag_additional_cells () const
-    {
-      AssertThrow (this->n_compositional_fields() >= 1,
-                   ExcMessage ("This refinement criterion can not be used when no "
-                               "compositional fields are active!"));
-
-      // tag_additional_cells is executed before the equations are solved
-      // for the very first time. If we do not have the finite element, we
-      // do not have the compositional fields and just do nothing in this plugin.
-      if (this->get_dof_handler().n_locally_owned_dofs() == 0)
-        return;
-
-      const unsigned int dofs_per_cell = this->get_fe().dofs_per_cell;
-      std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            cell->get_dof_indices (local_dof_indices);
-            bool refine = false;
-
-            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-              {
-                const unsigned int component_idx = this->introspection().component_indices.compositional_fields[c];
-                for (unsigned int i=0; i<dofs_per_cell; ++i)
-                  {
-                    if (this->get_fe().system_to_component_index(i).first == component_idx)
-                      {
-                        const double composition_value = this->get_solution()[local_dof_indices[i]];
-                        // if the composition exceeds the threshold, cell is marked for refinement
-                        if (composition_value > composition_thresholds[c])
-                          {
-                            refine = true;
-                            break;
-                          }
-                      }
-                  }
-                if (refine)
-                  break;
-              }
-
-            if (refine)
-              {
-                cell->clear_coarsen_flag ();
-                cell->set_refine_flag ();
-              }
-          }
-    }
-
-    template <int dim>
-    void
-    CompositionThreshold<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Composition threshold");
-        {
-          prm.declare_entry("Compositional field thresholds",
-                            "",
-                            Patterns::List (Patterns::Double()),
-                            "A list of thresholds that every individual compositional "
-                            "field will be evaluated against.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    CompositionThreshold<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Composition threshold");
-        {
-          composition_thresholds
-            = Utilities::string_to_double(
-                Utilities::split_string_list(prm.get("Compositional field thresholds")));
-
-          AssertThrow (composition_thresholds.size() == this->n_compositional_fields(),
-                       ExcMessage ("The number of thresholds given here must be "
-                                   "equal to the number of chosen refinement criteria."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(CompositionThreshold,
-                                              "composition threshold",
-                                              "A mesh refinement criterion that computes refinement "
-                                              "indicators from the compositional fields. If any field "
-                                              "exceeds the threshold given in the input file, the cell "
-                                              "is marked for refinement.")
-  }
-}
diff --git a/source/mesh_refinement/density.cc.bak b/source/mesh_refinement/density.cc.bak
deleted file mode 100644
index 9f97b335d85..00000000000
--- a/source/mesh_refinement/density.cc.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/density.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/numerics/derivative_approximation.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    Density<dim>::execute(Vector<float> &indicators) const
-    {
-      indicators = 0;
-
-//TODO: if the density doesn't actually depend on the solution
-      // then we can get away with simply interpolating it spatially
-
-
-      // create a vector in which we set the temperature block to
-      // be a finite element interpolation of the density.
-      // we do so by setting up a quadrature formula with the
-      // temperature unit support points, then looping over these
-      // points, compute the output quantity at them, and writing
-      // the result into the output vector in the same order
-      // (because quadrature points and temperature dofs are,
-      // by design of the quadrature formula, numbered in the
-      // same way)
-      LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
-                                                  this->get_mpi_communicator());
-
-      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
-      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature,
-                               update_quadrature_points | update_values | update_gradients);
-
-      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(),
-                                                 this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(),
-                                                   this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::density;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit(cell);
-            // Set use_strain_rates to false since we don't need viscosity
-            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-            this->get_material_model().evaluate(in, out);
-
-            cell->get_dof_indices (local_dof_indices);
-
-            // for each temperature dof, write into the output
-            // vector the density. note that quadrature points and
-            // dofs are enumerated in the same order
-            for (unsigned int i=0; i<this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell; ++i)
-              {
-                const unsigned int system_local_dof
-                  = this->get_fe().component_to_system_index(this->introspection().component_indices.temperature,
-                                                             /*dof index within component=*/i);
-
-                vec_distributed(local_dof_indices[system_local_dof])
-                  = out.densities[i];
-              }
-          }
-
-      vec_distributed.compress(VectorOperation::insert);
-
-      // now create a vector with the requisite ghost elements
-      // and use it for estimating the gradients
-      LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
-                                      this->introspection().index_sets.system_relevant_partitioning,
-                                      this->get_mpi_communicator());
-      vec = vec_distributed;
-
-      DerivativeApproximation::approximate_gradient  (this->get_mapping(),
-                                                      this->get_dof_handler(),
-                                                      vec,
-                                                      indicators,
-                                                      this->introspection().component_indices.temperature);
-
-      // Scale gradient in each cell with the correct power of h. Otherwise,
-      // error indicators do not reduce when refined if there is a density
-      // jump. We need at least order 1 for the error not to grow when
-      // refining, so anything >1 should work. (note that the gradient
-      // itself scales like 1/h, so multiplying it with any factor h^s, s>1
-      // will yield convergence of the error indicators to zero as h->0)
-      const double power = 1.0 + dim/2.0;
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          indicators(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Density,
-                                              "density",
-                                              "A mesh refinement criterion that computes "
-                                              "refinement indicators from a field that describes "
-                                              "the spatial variability of the density, $\\rho$. "
-                                              "Because this quantity may not be a continuous function ($\\rho$ "
-                                              "and $C_p$ may be discontinuous functions along discontinuities in the "
-                                              "medium, for example due to phase changes), we approximate the "
-                                              "gradient of this quantity to refine the mesh. The error indicator "
-                                              "defined here takes the magnitude of the approximate gradient "
-                                              "and scales it by $h_K^{1+d/2}$ where $h_K$ is the diameter of each cell "
-                                              "and $d$ is the dimension. "
-                                              "This scaling ensures that the error indicators converge to zero as "
-                                              "$h_K\\rightarrow 0$ even if the energy density is discontinuous, since "
-                                              "the gradient of a discontinuous function grows like $1/h_K$.")
-  }
-}
diff --git a/source/mesh_refinement/interface.cc.bak b/source/mesh_refinement/interface.cc.bak
deleted file mode 100644
index 8e16815ddd4..00000000000
--- a/source/mesh_refinement/interface.cc.bak
+++ /dev/null
@@ -1,519 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/utilities.h>
-
-#include <typeinfo>
-
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-// ------------------------------ Interface -----------------------------
-
-    template <int dim>
-    void
-    Interface<dim>::execute (Vector<float> &error_indicators) const
-    {
-      for (float &error_indicator : error_indicators)
-        error_indicator = 0;
-    }
-
-
-    template <int dim>
-    void
-    Interface<dim>::tag_additional_cells () const
-    {}
-
-
-
-// ------------------------------ Manager -----------------------------
-
-    template <int dim>
-    Manager<dim>::~Manager()
-      = default;
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::update ()
-    {
-      Assert (this->plugin_objects.size() > 0, ExcInternalError());
-
-      // call the update() functions of all refinement plugins.
-      for (const auto &p : this->plugin_objects)
-        {
-          try
-            {
-              p->update ();
-            }
-
-          // plugins that throw exceptions usually do not result in
-          // anything good because they result in an unwinding of the stack
-          // and, if only one processor triggers an exception, the
-          // destruction of objects often causes a deadlock. thus, if
-          // an exception is generated, catch it, print an error message,
-          // and abort the program
-          catch (std::exception &exc)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running mesh refinement plugin <"
-                        << typeid(*p).name()
-                        << ">: " << std::endl
-                        << exc.what() << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-          catch (...)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running mesh refinement plugin <"
-                        << typeid(*p).name()
-                        << ">: " << std::endl;
-              std::cerr << "Unknown exception!" << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::execute (Vector<float> &error_indicators) const
-    {
-      Assert (this->plugin_objects.size() > 0, ExcInternalError());
-
-      // call the execute() functions of all plugins we have
-      // here in turns. then normalize the output vector and
-      // verify that its values are non-negative numbers
-      std::vector<Vector<float>> all_error_indicators (this->plugin_objects.size(),
-                                                        Vector<float>(error_indicators.size()));
-      unsigned int index = 0;
-      for (typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
-           p = this->plugin_objects.begin();
-           p != this->plugin_objects.end(); ++p, ++index)
-        {
-          try
-            {
-              (*p)->execute (all_error_indicators[index]);
-
-              for (unsigned int i=0; i<error_indicators.size(); ++i)
-                Assert (all_error_indicators[index](i) >= 0,
-                        ExcMessage ("Error indicators must be non-negative numbers!"));
-
-              // see if we want to normalize the criteria
-              if (normalize_criteria == true)
-                {
-                  const double global_max = Utilities::MPI::max (all_error_indicators[index].linfty_norm(),
-                                                                 this->get_mpi_communicator());
-                  if (global_max != 0)
-                    all_error_indicators[index] /= global_max;
-                }
-
-              // then also scale them
-              all_error_indicators[index] *= scaling_factors[index];
-            }
-          // plugins that throw exceptions usually do not result in
-          // anything good because they result in an unwinding of the stack
-          // and, if only one processor triggers an exception, the
-          // destruction of objects often causes a deadlock. thus, if
-          // an exception is generated, catch it, print an error message,
-          // and abort the program
-          catch (std::exception &exc)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running mesh refinement plugin <"
-                        << typeid(**p).name()
-                        << ">: " << std::endl
-                        << exc.what() << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-          catch (...)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running mesh refinement plugin <"
-                        << typeid(**p).name()
-                        << ">: " << std::endl;
-              std::cerr << "Unknown exception!" << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-        }
-
-      // now merge the results
-      switch  (merge_operation)
-        {
-          case plus:
-          {
-            for (unsigned int i=0; i<this->plugin_objects.size(); ++i)
-              error_indicators += all_error_indicators[i];
-            break;
-          }
-
-          case max:
-          {
-            error_indicators = all_error_indicators[0];
-            for (unsigned int i=1; i<this->plugin_objects.size(); ++i)
-              {
-                Assert (error_indicators.size() == all_error_indicators[i].size(),
-                        ExcInternalError());
-                for (unsigned int j=0; j<error_indicators.size(); ++j)
-                  error_indicators(j) = std::max (error_indicators(j),
-                                                  all_error_indicators[i](j));
-              }
-            break;
-          }
-
-          default:
-            Assert (false, ExcNotImplemented());
-        }
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::tag_additional_cells () const
-    {
-      Assert (this->plugin_objects.size() > 0, ExcInternalError());
-
-      // call the tag_additional_cells() functions of all
-      // plugins we have here in turns.
-      for (const auto &p : this->plugin_objects)
-        {
-          try
-            {
-              p->tag_additional_cells ();
-            }
-
-          // plugins that throw exceptions usually do not result in
-          // anything good because they result in an unwinding of the stack
-          // and, if only one processor triggers an exception, the
-          // destruction of objects often causes a deadlock. thus, if
-          // an exception is generated, catch it, print an error message,
-          // and abort the program
-          catch (std::exception &exc)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running mesh refinement plugin <"
-                        << typeid(*p).name()
-                        << ">: " << std::endl
-                        << exc.what() << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-          catch (...)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running mesh refinement plugin <"
-                        << typeid(*p).name()
-                        << ">: " << std::endl;
-              std::cerr << "Unknown exception!" << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-        }
-    }
-
-
-
-
-
-// -------------------------------- Deal with registering plugins and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // first declare the postprocessors we know about to
-      // choose from
-      prm.enter_subsection("Mesh refinement");
-      {
-        // construct a string for Patterns::MultipleSelection that
-        // contains the names of all registered plugins
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-        prm.declare_entry("Strategy",
-                          "thermal energy density",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma separated list of mesh refinement criteria that "
-                          "will be run whenever mesh refinement is required. The "
-                          "results of each of these criteria, i.e., the refinement "
-                          "indicators they produce for all the cells of the mesh "
-                          "will then be normalized to a range between zero and one "
-                          "and the results of different criteria will then be "
-                          "merged through the operation selected in this section.\n\n"
-                          "The following criteria are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-
-        prm.declare_entry("Normalize individual refinement criteria",
-                          "true",
-                          Patterns::Bool(),
-                          "If multiple refinement criteria are specified in the "
-                          "``Strategy'' parameter, then they need to be combined "
-                          "somehow to form the final refinement indicators. This "
-                          "is done using the method described by the ``Refinement "
-                          "criteria merge operation'' parameter which can either "
-                          "operate on the raw refinement indicators returned by "
-                          "each strategy (i.e., dimensional quantities) or using "
-                          "normalized values where the indicators of each strategy "
-                          "are first normalized to the interval $[0,1]$ (which also "
-                          "makes them non-dimensional). This parameter determines "
-                          "whether this normalization will happen.");
-        prm.declare_entry("Refinement criteria scaling factors",
-                          "",
-                          Patterns::List (Patterns::Double (0.)),
-                          "A list of scaling factors by which every individual refinement "
-                          "criterion will be multiplied by. If only a single refinement "
-                          "criterion is selected (using the ``Strategy'' parameter, then "
-                          "this parameter has no particular meaning. On the other hand, if "
-                          "multiple criteria are chosen, then these factors are used to "
-                          "weigh the various indicators relative to each other. "
-                          "\n\n"
-                          "If ``Normalize individual refinement criteria'' is set to true, "
-                          "then the criteria will first be normalized to the interval $[0,1]$ "
-                          "and then multiplied by the factors specified here. You will likely "
-                          "want to choose the factors to be not too far from 1 in that case, say "
-                          "between 1 and 10, to avoid essentially disabling those criteria "
-                          "with small weights. On the other hand, if the criteria are not "
-                          "normalized to $[0,1]$ using the parameter mentioned above, then "
-                          "the factors you specify here need to take into account the relative "
-                          "numerical size of refinement indicators (which in that case carry "
-                          "physical units)."
-                          "\n\n"
-                          "You can experimentally play with these scaling factors by choosing "
-                          "to output the refinement indicators into the graphical output of "
-                          "a run."
-                          "\n\n"
-                          "If the list of indicators given in this parameter is empty, then this "
-                          "indicates that they should all be chosen equal to one. If the list "
-                          "is not empty then it needs to have as many entries as there are "
-                          "indicators chosen in the ``Strategy'' parameter.");
-        prm.declare_entry("Refinement criteria merge operation",
-                          "max",
-                          Patterns::Selection("plus|max"),
-                          "If multiple mesh refinement criteria are computed for each cell "
-                          "(by passing a list of more than element to the \\texttt{Strategy} "
-                          "parameter in this section of the input file) "
-                          "then one will have to decide which criteria should win when deciding "
-                          "which cells to refine. The operation that determines how to combine these competing "
-                          "criteria is the one that is selected here. The options are:\n\n"
-                          "\\begin{itemize}\n"
-                          "\\item \\texttt{plus}: Add the various error indicators together and "
-                          "refine those cells on which the sum of indicators is largest.\n"
-                          "\\item \\texttt{max}: Take the maximum of the various error indicators and "
-                          "refine those cells on which the maximal indicators is largest.\n"
-                          "\\end{itemize}"
-                          "The refinement indicators computed by each strategy are modified by "
-                          "the ``Normalize individual refinement criteria'' and ``Refinement "
-                          "criteria scale factors'' parameters.");
-      }
-      prm.leave_subsection();
-
-      // now declare the parameters of each of the registered
-      // plugins in turn
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      Assert (std::get<dim>(registered_plugins).plugins != nullptr,
-              ExcMessage ("No mesh refinement plugins registered!?"));
-
-      // find out which plugins are requested and the various other
-      // parameters we declare here
-      std::vector<std::string> plugin_names;
-      prm.enter_subsection("Mesh refinement");
-      {
-        plugin_names
-          = Utilities::split_string_list(prm.get("Strategy"));
-
-        AssertThrow(Utilities::has_unique_entries(plugin_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Mesh refinement/Strategy' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-
-        normalize_criteria = prm.get_bool ("Normalize individual refinement criteria");
-
-        scaling_factors
-          = Utilities::string_to_double(
-              Utilities::split_string_list(prm.get("Refinement criteria scaling factors")));
-        AssertThrow (scaling_factors.size() == plugin_names.size()
-                     ||
-                     scaling_factors.size() == 0,
-                     ExcMessage ("The number of scaling factors given here must either be "
-                                 "zero or equal to the number of chosen refinement criteria."));
-        if (scaling_factors.size() == 0)
-          scaling_factors = std::vector<double> (plugin_names.size(), 1.0);
-
-        if (prm.get("Refinement criteria merge operation") == "plus")
-          merge_operation = plus;
-        else if (prm.get("Refinement criteria merge operation") == "max")
-          merge_operation = max;
-        else
-          AssertThrow (false, ExcNotImplemented());
-      }
-      prm.leave_subsection();
-
-      // go through the list, create objects and let them parse
-      // their own parameters
-      AssertThrow (plugin_names.size() >= 1,
-                   ExcMessage ("You need to provide at least one mesh refinement criterion in the input file!"));
-      for (auto &plugin_name : plugin_names)
-        {
-          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
-                                          (std::get<dim>(registered_plugins)
-                                           .create_plugin (plugin_name,
-                                                           "Mesh refinement::Refinement criteria merge operation")));
-
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
-            sim->initialize_simulator (this->get_simulator());
-
-          this->plugin_objects.back()->parse_parameters (prm);
-          this->plugin_objects.back()->initialize ();
-        }
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_mesh_refinement_criterion (const std::string &name,
-                                                      const std::string &description,
-                                                      void (*declare_parameters_function) (ParameterHandler &),
-                                                      std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Mesh refinement criteria interface",
-                                                            out);
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<MeshRefinement::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<MeshRefinement::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<MeshRefinement::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<MeshRefinement::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace MeshRefinement
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/mesh_refinement/isosurfaces.cc.bak b/source/mesh_refinement/isosurfaces.cc.bak
deleted file mode 100644
index c834b26fc08..00000000000
--- a/source/mesh_refinement/isosurfaces.cc.bak
+++ /dev/null
@@ -1,404 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <algorithm>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/mesh_refinement/isosurfaces.h>
-#include <aspect/utilities.h>
-#include <cmath>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    namespace internal
-    {
-      bool
-      Isosurface::are_all_values_in_range(const std::vector<double> &values) const
-      {
-        // This assumes that all the vectors in isosurfaces already have the
-        // same length.
-        Assert(values.size() == min_values.size(),
-               ExcMessage("internal error: Vector of values passed to the isosurface class "
-                          "function are_all_values_in_range, does not have the correct size."));
-        for (unsigned int index = 0; index < values.size(); ++index)
-          {
-            if (values[index] < min_values[index] || values[index] > max_values[index])
-              {
-                // outside this isosurface, no need to search further
-                return false;
-              }
-          }
-        // If we made it this far, then we are inside the conditions, so return true.
-        return true;
-      }
-
-      Property::Property(const std::string &property_name,
-                         const std::vector<std::string> &available_compositions)
-      {
-        bool found = false;
-        if (property_name == "Temperature")
-          {
-            type = PropertyType::Temperature;
-            index = 0;
-            found = true;
-          }
-        else
-          {
-            auto p = std::find(available_compositions.begin(), available_compositions.end(), property_name);
-            if (p != available_compositions.end())
-              {
-                type = PropertyType::Composition;
-                index = std::distance(available_compositions.begin(), p);
-                found = true;
-              }
-          }
-        if (found == false)
-          {
-            // The property name has not been found. This could be because the compositional field is not present.
-            // Abort and warn the user.
-            std::string key_list = "Temperature";
-            for (auto &composition : available_compositions)
-              key_list += ", " + composition;
-
-            AssertThrow(false,
-                        ExcMessage("The key given for the isosurface could not be converted. The provided key was: " + property_name + ". "
-                                   "The following keys are allowed for this model: " + key_list + "."));
-          }
-      }
-
-      /**
-       * Convert a string describing the refinement level which potentially contains the words "min"
-       * or "max" to an integer. The format is "min", "max", "min+X", "max-X", or "X", where X is a positive integer.
-       *
-       * For example if minimum_refinement_level  is 1, and the string is 'min+1', it will return 2.
-       * The returned value will be capped  by the provided @p minimum_refinement_level and @p maximum_refinement_level.
-       * The @p minimum_refinement_level and @p maximum_refinement_level are set in this input file subsection for this
-       * plugin, but in the Mesh refinement subsection.
-       *
-       * This function will throw an assertion when the string contains `max+` or `min-` since
-       * that is always incorrect.
-       */
-      unsigned int min_max_string_to_int(const std::string &string_value,
-                                         const unsigned int minimum_refinement_level,
-                                         const unsigned int maximum_refinement_level)
-      {
-        // start with removing the spaces so that a ' min + 1 ' would become 'min+1'.
-        std::string string = string_value;
-        std::string::iterator end_pos = std::remove(string.begin(), string.end(), ' ');
-        string.erase(end_pos, string.end());
-
-        // check whether the field starts with a 'min'
-        if (string.compare(0,3,"min") == 0)
-          {
-            if (string.compare(0,4,"min+") == 0)
-              {
-                std::vector<std::string> tmpNumber = Utilities::split_string_list(string,'+');
-                AssertThrow(tmpNumber.size() == 2,
-                            ExcMessage("Could not convert value '" + string + "' to an int because it contains more than one '+' sign."));
-                return std::min(std::max(minimum_refinement_level+Utilities::string_to_int(tmpNumber[1]),minimum_refinement_level),maximum_refinement_level);
-              }
-            else
-              {
-                AssertThrow(string == "min",
-                            ExcMessage("A value of " + string_value + " was provided, but you can't provide a smaller value than the minimum."));
-                return minimum_refinement_level;
-              }
-          }
-        else if (string.compare(0,3,"max") == 0)
-          {
-            if (string.compare(0,4,"max-") == 0)
-              {
-                std::vector<std::string> tmpNumber = Utilities::split_string_list(string,'-');
-                AssertThrow(tmpNumber.size() == 2,
-                            ExcMessage("Could not convert value '" + string + "' to an int because it contains more than one '-' sign."));
-                return std::min(std::max(maximum_refinement_level-Utilities::string_to_int(tmpNumber[1]),minimum_refinement_level),maximum_refinement_level);
-              }
-            else
-              {
-                AssertThrow(string=="max",
-                            ExcMessage("A value of " + string_value + " was provided, but you can't provide a larger value than the maximum."));
-                return maximum_refinement_level;
-              }
-          }
-        else
-          {
-            return std::min(std::max(static_cast<unsigned int>(Utilities::string_to_int(string)),minimum_refinement_level),maximum_refinement_level);
-          }
-
-      }
-    }
-
-    template <int dim>
-    void
-    Isosurfaces<dim>::update ()
-    { }
-
-    template <int dim>
-    void
-    Isosurfaces<dim>::tag_additional_cells () const
-    {
-      if (this->get_dof_handler().n_locally_owned_dofs() == 0)
-        return;
-
-      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature,
-                               update_quadrature_points | update_values | update_gradients);
-
-      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(),
-                                                 this->n_compositional_fields());
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        {
-          if (cell->is_locally_owned())
-            {
-              bool coarsen = false;
-              bool clear_refine = false;
-              bool refine = false;
-              bool clear_coarsen = false;
-
-              fe_values.reinit(cell);
-              in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-              for (unsigned int i_quad=0; i_quad<quadrature.size(); ++i_quad)
-                {
-                  for (auto &isosurface : isosurfaces)
-                    {
-                      // setup the vector containing the isosurfaces
-                      std::vector<double> values(isosurface.min_values.size());
-                      for (unsigned int index = 0; index < isosurface.properties.size(); ++index)
-                        {
-                          if (isosurface.properties[index].type == internal::PropertyType::Temperature)
-                            {
-                              values[index] = in.temperature[i_quad];
-                            }
-                          else if (isosurface.properties[index].type == internal::PropertyType::Composition)
-                            {
-                              values[index] = in.composition[i_quad][isosurface.properties[index].index];
-                            }
-                        }
-
-                      if ( isosurface.are_all_values_in_range(values))
-                        {
-                          // If the current refinement level is smaller than or equal to the minimum
-                          // refinement level, any coarsening flag should be cleared.
-                          if (cell->level() <= isosurface.min_refinement)
-                            {
-                              clear_coarsen = true;
-                            }
-
-                          // If the current refinement level is smaller than the minimum
-                          // refinement level, a refinement flag should be placed.
-                          if (cell->level() <  isosurface.min_refinement)
-                            {
-                              refine = true;
-                              break;
-                            }
-
-                          // If the current refinement level is larger than or equal to the maximum refinement
-                          // level, any refinement flag should be cleared.
-                          if (cell->level() >= isosurface.max_refinement)
-                            {
-                              clear_refine = true;
-                            }
-
-                          // If the current refinement level is larger than the maximum refinement level,
-                          // a coarsening flag should be placed.
-                          if (cell->level() >  isosurface.max_refinement)
-                            {
-                              coarsen = true;
-                            }
-                        }
-                    }
-                }
-
-              // if both coarsen and refine are true, give preference to refinement
-              if (coarsen && refine)
-                coarsen = false;
-              if (refine)
-                clear_refine = false;
-              if (clear_coarsen)
-                coarsen = false;
-
-              // Perform the actual placement of the coarsening and refinement flags.
-              if (clear_coarsen)
-                cell->clear_coarsen_flag ();
-              if (clear_refine)
-                cell->clear_refine_flag ();
-              if (coarsen)
-                cell->set_coarsen_flag ();
-              if (refine)
-                cell->set_refine_flag ();
-            }
-        }
-    }
-
-    template <int dim>
-    void
-    Isosurfaces<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Isosurfaces");
-        {
-          prm.declare_entry ("Isosurfaces", "",
-                             Patterns::Anything(),
-                             "A list of isosurfaces separated by semi-colons (;). Each isosurface entry consists of "
-                             "multiple entries separated by a comma. The first two entries indicate the minimum and maximum "
-                             "refinement levels respectively. The entries after the first two describe the fields the isosurface "
-                             "applies to, followed by a colon (:), which is again followed by the minimum and maximum property values separated by "
-                             "bar (|). An example for an isosurface is '0, 2, Temperature: 300 | 600; 2, 2, C\\_1: 0.5 | 1'. "
-                             "In this example the mesh refinement is kept between level 0 and level 2 if the temperature is between "
-                             "300 and 600 and at level 2 when the compositional field C\\_1 is between 0.5 and 1. If both happen at "
-                             "the same location and the current refinement level is 1, it means that the first isoline will not set any flag and the "
-                             "second isoline will set a refinement flag. This means the cell will be refined. If both the coarsening and refinement flags "
-                             "are set, preference is given to refinement. "
-                             "\n\n"
-                             "The first two entries for each isosurface, describing the minimum and maximum grid levels, can be "
-                             "two numbers or contain one of the key values 'min' and 'max'. This indicates the key will be replaced with "
-                             "the global minimum and maximum refinement levels. The 'min' and 'max' keys also accept adding "
-                             "values to be added or subtracted from them respectively. This is done by adding a '+' or '-' and a "
-                             "number behind them (e.g. min+2 or max-1). Note that you can't subtract a value from a minimum value or "
-                             "add a value to the maximum value. If, for example, `max-4` drops below the minimum or `min+4` goes above the "
-                             "maximum, it will simply use the global minimum and maximum values respectively. The same holds for any "
-                             "mesh refinement level below the global minimum or above the global maximum.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    Isosurfaces<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        // lookup the minimum and maximum refinement
-        const unsigned int minimum_refinement_level = this->get_parameters().min_grid_level;
-        const unsigned int maximum_refinement_level = this->get_parameters().initial_global_refinement +
-                                                      this->get_parameters().initial_adaptive_refinement;
-
-        const std::vector<std::string> &compositions = this->introspection().get_composition_names();
-        prm.enter_subsection("Isosurfaces");
-        {
-          // Split the list by comma delimited components.
-          const std::vector<std::string> isosurface_entries = dealii::Utilities::split_string_list(prm.get("Isosurfaces"), ';');
-          unsigned int isosurface_entry_number = 0;
-          for (auto &isosurface_entry : isosurface_entries)
-            {
-              ++isosurface_entry_number;
-              aspect::MeshRefinement::internal::Isosurface isosurface;
-              std::vector<aspect::MeshRefinement::internal::Property> properties;
-              std::vector<double> min_value_inputs;
-              std::vector<double> max_value_inputs;
-              const std::vector<std::string> field_entries = dealii::Utilities::split_string_list(isosurface_entry, ',');
-
-              AssertThrow(field_entries.size() >= 3,
-                          ExcMessage("An isosurface needs to contain at least 3 entries, but isosurface " + std::to_string(isosurface_entry_number)
-                                     + " contains  only " +  std::to_string(field_entries.size()) + " entries: " + isosurface_entry + "."));
-
-              // convert a potential min, min+1, min + 1, min+10, max, max-1, etc. to actual integers.
-              isosurface.min_refinement = internal::min_max_string_to_int(field_entries[0], minimum_refinement_level, maximum_refinement_level);
-              isosurface.max_refinement = internal::min_max_string_to_int(field_entries[1], minimum_refinement_level, maximum_refinement_level);
-              AssertThrow(isosurface.min_refinement <= isosurface.max_refinement,
-                          ExcMessage("The provided maximum refinement level has to be larger than the minimum refinement level."));
-              for (auto field_entry = field_entries.begin()+2; field_entry != field_entries.end(); ++field_entry)
-                {
-                  AssertThrow(Patterns::Map(Patterns::Anything(),
-                                            Patterns::List(Patterns::Double(), 0, std::numeric_limits<unsigned int>::max(), "|")
-                                           ).match(*field_entry),
-                              ExcMessage("The isosurface is not formatted correctly."));
-                  std::vector<std::string> key_and_value = Utilities::split_string_list (*field_entry, ':');
-                  AssertThrow(key_and_value.size() == 2,
-                              ExcMessage("The isosurface property must have a key (e.g. Temperature) and two values separated by a | (e.g. (300 | 600)."));
-                  properties.emplace_back(key_and_value[0], compositions); // convert key to property name
-                  const std::vector<std::string> values = dealii::Utilities::split_string_list(key_and_value[1], '|');
-                  AssertThrow(values.size() == 2,
-                              ExcMessage("Both a maximum and a minimum value are required for each isosurface."));
-                  min_value_inputs.push_back(Utilities::string_to_double(values[0]));  // get min and max values of the range
-                  max_value_inputs.push_back(Utilities::string_to_double(values[1]));
-                  AssertThrow(min_value_inputs.back() < max_value_inputs.back(),
-                              ExcMessage("The provided maximum property value has to be larger than the provided minimum property value."));
-                }
-              isosurface.min_values = min_value_inputs;
-              isosurface.max_values = max_value_inputs;
-              isosurface.properties = properties;
-              isosurfaces.push_back(isosurface);
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Isosurfaces,
-                                              "isosurfaces",
-                                              "A mesh refinement criterion that computes "
-                                              "coarsening and refinement indicators between two isosurfaces of "
-                                              "specific field entries (e.g. temperature, composition)."
-                                              "\n\n"
-                                              "The way these indicators are derived between pairs of isosurfaces is by "
-                                              "checking whether the solutions of specific "
-                                              "fields are within the ranges of the isosurface values given. If these conditions "
-                                              "hold, then coarsening and refinement indicators are set such that "
-                                              "the mesh refinement levels lies within the range of levels "
-                                              "given. Usage of this plugin allows the user to put a conditional "
-                                              "minimum and maximum refinement function onto fields that they "
-                                              "are interested in."
-                                              "\n\n"
-                                              "For now, only temperature and compositional fields are allowed as "
-                                              "field entries. The key words could be 'Temperature' or one of the names "
-                                              "of the compositional fields which are either specified by user or set up "
-                                              "as C\\_0, C\\_1, etc."
-                                              "\n\n"
-                                              "Usage: A list of isosurfaces separated by semi-colons (;). Each "
-                                              "isosurface entry consists of multiple entries separated by a comma. "
-                                              "The first two entries indicate the minimum and maximum refinement "
-                                              "levels respectively. The entries after the first two describe the "
-                                              "fields the isosurface applies to, followed by a colon (:), which again "
-                                              "is followed by the minimum and maximum field values separated by a bar (|). An "
-                                              "example for two isosurface entries is '0, 2, Temperature: 300 | 600; 2, 2, C\\_1: 0.5 | 1'. "
-                                              "If both isoterm entries are triggered at the same location and the current refinement level is 1, "
-                                              "it means that the first isoline will not set any flag and the second isoline will set a refinement flag. "
-                                              "This means the cell will be refined. If both the coarsening and refinement flags "
-                                              "are set, preference is given to refinement. "
-                                              "\n\n"
-                                              "The minimum and maximum refinement levels per isosurface can be provided in absolute values relative to "
-                                              "the global minimum and maximum refinement. This is done with the 'min' and 'max' key words. For example: "
-                                              "'set Isosurfaces = max-2,  max,    Temperature: 0 | 600 ; min + 1,min+2, Temperature: 1600 | 3000,   C\\_2 : 0.0 | 0.5'."
-                                             )
-  }
-}
diff --git a/source/mesh_refinement/maximum_refinement_function.cc.bak b/source/mesh_refinement/maximum_refinement_function.cc.bak
deleted file mode 100644
index 1d133dbb817..00000000000
--- a/source/mesh_refinement/maximum_refinement_function.cc.bak
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/mesh_refinement/maximum_refinement_function.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <cmath>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    MaximumRefinementFunction<dim>::update ()
-    {
-      const double time = this->get_time() /
-                          (this->convert_output_to_years()
-                           ?
-                           year_in_seconds
-                           :
-                           1.0);
-
-      max_refinement_level.set_time(time);
-    }
-
-    template <int dim>
-    void
-    MaximumRefinementFunction<dim>::tag_additional_cells () const
-    {
-      for (const auto &cell : this->get_triangulation().active_cell_iterators())
-        {
-          if (cell->is_locally_owned())
-            {
-              const Point<dim> center = cell->center();
-              const Utilities::NaturalCoordinate<dim> point =
-                this->get_geometry_model().cartesian_to_other_coordinates(center, coordinate_system);
-
-              const double maximum_refinement_level = max_refinement_level.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
-
-              if (cell->level() >= static_cast<int>(std::round(maximum_refinement_level)))
-                cell->clear_refine_flag ();
-
-              if (cell->level() > static_cast<int>(std::round(maximum_refinement_level)))
-                cell->set_coarsen_flag ();
-            }
-        }
-    }
-
-    template <int dim>
-    void
-    MaximumRefinementFunction<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-
-        prm.enter_subsection("Maximum refinement function");
-        {
-          /**
-           * Choose the coordinates to evaluate the maximum refinement level
-           * function. The function can be declared in dependence of depth,
-           * cartesian coordinates or spherical coordinates. Note that the order
-           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
-           * this allows for dimension independent expressions.
-           */
-          prm.declare_entry ("Coordinate system", "depth",
-                             Patterns::Selection ("depth|cartesian|spherical"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `depth', `cartesian' and `spherical'. `depth' "
-                             "will create a function, in which only the first "
-                             "variable is non-zero, which is interpreted to "
-                             "be the depth of the point. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle.");
-          /**
-           * Let the function that describes the maximal level of refinement
-           * as a function of position declare its parameters.
-           * This defines the maximum refinement level each cell should have,
-           * and that can not be exceeded by coarsening.
-           */
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    MaximumRefinementFunction<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Maximum refinement function");
-        {
-          if (prm.get ("Coordinate system") == "depth")
-            coordinate_system = Utilities::Coordinates::depth;
-          else if (prm.get ("Coordinate system") == "cartesian")
-            coordinate_system = Utilities::Coordinates::cartesian;
-          else if (prm.get ("Coordinate system") == "spherical")
-            coordinate_system = Utilities::Coordinates::spherical;
-          else
-            AssertThrow (false, ExcNotImplemented());
-
-          try
-            {
-              max_refinement_level.parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Mesh refinement.Maximum refinement function'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(MaximumRefinementFunction,
-                                              "maximum refinement function",
-                                              "A mesh refinement criterion that ensures a "
-                                              "maximum refinement level described by an "
-                                              "explicit formula with the depth or position "
-                                              "as argument. Which coordinate representation "
-                                              "is used is determined by an input parameter. "
-                                              "Whatever the coordinate system chosen, the "
-                                              "function you provide in the input file will "
-                                              "by default depend on variables `x', `y' and "
-                                              "`z' (if in 3d). However, the meaning of these "
-                                              "symbols depends on the coordinate system. In "
-                                              "the Cartesian coordinate system, they simply "
-                                              "refer to their natural meaning. If you have "
-                                              "selected `depth' for the coordinate system, "
-                                              "then `x' refers to the depth variable and `y' "
-                                              "and `z' will simply always be zero. If you "
-                                              "have selected a spherical coordinate system, "
-                                              "then `x' will refer to the radial distance of "
-                                              "the point to the origin, `y' to the azimuth "
-                                              "angle and `z' to the polar angle measured "
-                                              "positive from the north pole. Note that the "
-                                              "order of spherical coordinates is r,phi,theta "
-                                              "and not r,theta,phi, since this allows for "
-                                              "dimension independent expressions. "
-                                              "Each coordinate system also includes a final `t' "
-                                              "variable which represents the model time, evaluated "
-                                              "in years if the 'Use years in output instead of seconds' "
-                                              "parameter is set, otherwise evaluated in seconds. "
-                                              "After evaluating the function, its values are "
-                                              "rounded to the nearest integer."
-                                              "\n\n"
-                                              "The format of these "
-                                              "functions follows the syntax understood by the "
-                                              "muparser library, see "
-                                              "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-  }
-}
diff --git a/source/mesh_refinement/minimum_refinement_function.cc.bak b/source/mesh_refinement/minimum_refinement_function.cc.bak
deleted file mode 100644
index 4c5b67b64d2..00000000000
--- a/source/mesh_refinement/minimum_refinement_function.cc.bak
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/mesh_refinement/minimum_refinement_function.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <cmath>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    MinimumRefinementFunction<dim>::update ()
-    {
-      const double time = this->get_time() /
-                          (this->convert_output_to_years()
-                           ?
-                           year_in_seconds
-                           :
-                           1.0);
-
-      min_refinement_level.set_time(time);
-    }
-
-    template <int dim>
-    void
-    MinimumRefinementFunction<dim>::tag_additional_cells () const
-    {
-      for (const auto &cell : this->get_triangulation().active_cell_iterators())
-        {
-          if (cell->is_locally_owned())
-            {
-              const Point<dim> center = cell->center();
-              const Utilities::NaturalCoordinate<dim> point =
-                this->get_geometry_model().cartesian_to_other_coordinates(center, coordinate_system);
-
-              const double minimum_refinement_level = min_refinement_level.value(Utilities::convert_array_to_point<dim>(point.get_coordinates()));
-
-              if (cell->level() <= static_cast<int>(std::round(minimum_refinement_level)))
-                cell->clear_coarsen_flag ();
-              if (cell->level() < static_cast<int>(std::round(minimum_refinement_level)))
-                cell->set_refine_flag ();
-            }
-        }
-    }
-
-    template <int dim>
-    void
-    MinimumRefinementFunction<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-
-        prm.enter_subsection("Minimum refinement function");
-        {
-          /**
-           * Choose the coordinates to evaluate the minimum refinement level
-           * function. The function can be declared in dependence of depth,
-           * cartesian coordinates or spherical coordinates. Note that the order
-           * of spherical coordinates is r,phi,theta and not r,theta,phi, since
-           * this allows for dimension independent expressions.
-           */
-          prm.declare_entry ("Coordinate system", "depth",
-                             Patterns::Selection ("depth|cartesian|spherical"),
-                             "A selection that determines the assumed coordinate "
-                             "system for the function variables. Allowed values "
-                             "are `depth', `cartesian' and `spherical'. `depth' "
-                             "will create a function, in which only the first "
-                             "variable is non-zero, which is interpreted to "
-                             "be the depth of the point. `spherical' coordinates "
-                             "are interpreted as r,phi or r,phi,theta in 2d/3d "
-                             "respectively with theta being the polar angle.");
-          /**
-           * Let the function that describes the minimal level of refinement
-           * as a function of position declare its parameters.
-           * This defines the minimum refinement level each cell should have,
-           * and that can not be exceeded by coarsening.
-           */
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    MinimumRefinementFunction<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Minimum refinement function");
-        {
-          if (prm.get ("Coordinate system") == "depth")
-            coordinate_system = Utilities::Coordinates::depth;
-          else if (prm.get ("Coordinate system") == "cartesian")
-            coordinate_system = Utilities::Coordinates::cartesian;
-          else if (prm.get ("Coordinate system") == "spherical")
-            coordinate_system = Utilities::Coordinates::spherical;
-          else
-            AssertThrow (false, ExcNotImplemented());
-
-          try
-            {
-              min_refinement_level.parse_parameters (prm);
-            }
-          catch (...)
-            {
-              std::cerr << "ERROR: FunctionParser failed to parse\n"
-                        << "\t'Mesh refinement.Minimum refinement function'\n"
-                        << "with expression\n"
-                        << "\t'" << prm.get("Function expression") << "'"
-                        << "More information about the cause of the parse error \n"
-                        << "is shown below.\n";
-              throw;
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(MinimumRefinementFunction,
-                                              "minimum refinement function",
-                                              "A mesh refinement criterion that ensures a "
-                                              "minimum refinement level described by an "
-                                              "explicit formula with the depth or position "
-                                              "as argument. Which coordinate representation "
-                                              "is used is determined by an input parameter. "
-                                              "Whatever the coordinate system chosen, the "
-                                              "function you provide in the input file will "
-                                              "by default depend on variables `x', `y' and "
-                                              "`z' (if in 3d). However, the meaning of these "
-                                              "symbols depends on the coordinate system. In "
-                                              "the Cartesian coordinate system, they simply "
-                                              "refer to their natural meaning. If you have "
-                                              "selected `depth' for the coordinate system, "
-                                              "then `x' refers to the depth variable and `y' "
-                                              "and `z' will simply always be zero. If you "
-                                              "have selected a spherical coordinate system, "
-                                              "then `x' will refer to the radial distance of "
-                                              "the point to the origin, `y' to the azimuth "
-                                              "angle and `z' to the polar angle measured "
-                                              "positive from the north pole. Note that the "
-                                              "order of spherical coordinates is r,phi,theta "
-                                              "and not r,theta,phi, since this allows for "
-                                              "dimension independent expressions. "
-                                              "Each coordinate system also includes a final `t' "
-                                              "variable which represents the model time, evaluated "
-                                              "in years if the 'Use years in output instead of seconds' "
-                                              "parameter is set, otherwise evaluated in seconds. "
-                                              "After evaluating the function, its values are "
-                                              "rounded to the nearest integer."
-                                              "\n\n"
-                                              "The format of these "
-                                              "functions follows the syntax understood by the "
-                                              "muparser library, see "
-                                              "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-  }
-}
diff --git a/source/mesh_refinement/nonadiabatic_temperature.cc.bak b/source/mesh_refinement/nonadiabatic_temperature.cc.bak
deleted file mode 100644
index 3177c52d25b..00000000000
--- a/source/mesh_refinement/nonadiabatic_temperature.cc.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/nonadiabatic_temperature.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/numerics/derivative_approximation.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    NonadiabaticTemperature<dim>::execute(Vector<float> &indicators) const
-    {
-      indicators = 0;
-
-      // create a vector in which we set the temperature block to
-      // be a finite element interpolation of the nonadiabatic temperature.
-      // we do so by setting up a quadrature formula with the
-      // temperature unit support points, then looping over these
-      // points, compute the output quantity at them, and writing
-      // the result into the output vector in the same order
-      // (because quadrature points and temperature dofs are,
-      // by design of the quadrature formula, numbered in the
-      // same way)
-      LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
-                                                  this->get_mpi_communicator());
-
-      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
-      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature,
-                               update_quadrature_points | update_values);
-
-      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(),
-                                                 this->n_compositional_fields());
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit(cell);
-            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
-                                                                                         in.temperature);
-            in.position = fe_values.get_quadrature_points();
-
-            cell->get_dof_indices (local_dof_indices);
-
-            // for each temperature dof, write into the output
-            // vector the nonadiabatic temperature. note that quadrature points and
-            // dofs are enumerated in the same order
-            for (unsigned int i=0; i<this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell; ++i)
-              {
-                const unsigned int system_local_dof
-                  = this->get_fe().component_to_system_index(this->introspection().component_indices.temperature,
-                                                             /*dof index within component=*/i);
-
-                vec_distributed(local_dof_indices[system_local_dof])
-                  = in.temperature[i] - this->get_adiabatic_conditions().temperature(in.position[i]);
-              }
-          }
-
-      vec_distributed.compress(VectorOperation::insert);
-
-      // now create a vector with the requisite ghost elements
-      // and use it for estimating the gradients
-      LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
-                                      this->introspection().index_sets.system_relevant_partitioning,
-                                      this->get_mpi_communicator());
-      vec = vec_distributed;
-
-      DerivativeApproximation::approximate_gradient  (this->get_mapping(),
-                                                      this->get_dof_handler(),
-                                                      vec,
-                                                      indicators,
-                                                      this->introspection().component_indices.temperature);
-
-      // Scale gradient in each cell with the correct power of h. Otherwise,
-      // error indicators do not reduce when refined if there is a density
-      // jump. We need at least order 1 for the error not to grow when
-      // refining, so anything >1 should work. (note that the gradient
-      // itself scales like 1/h, so multiplying it with any factor h^s, s>1
-      // will yield convergence of the error indicators to zero as h->0)
-      const double power = 1.0 + dim/2.0;
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          indicators(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(NonadiabaticTemperature,
-                                              "nonadiabatic temperature",
-                                              "A mesh refinement criterion that computes "
-                                              "refinement indicators from the excess temperature"
-                                              "(difference between temperature and adiabatic "
-                                              "temperature.")
-  }
-}
diff --git a/source/mesh_refinement/nonadiabatic_temperature_threshold.cc.bak b/source/mesh_refinement/nonadiabatic_temperature_threshold.cc.bak
deleted file mode 100644
index eb8b2c8007d..00000000000
--- a/source/mesh_refinement/nonadiabatic_temperature_threshold.cc.bak
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/nonadiabatic_temperature_threshold.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    NonadiabaticTemperatureThreshold<dim>::tag_additional_cells () const
-    {
-      // tag_additional_cells is executed before the equations are solved
-      // for the very first time. If we do not have the finite element, we
-      // do not have the temperature and just do nothing in this plugin.
-      if (this->get_dof_handler().n_locally_owned_dofs() == 0)
-        return;
-
-      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature,
-                               update_quadrature_points | update_values);
-
-      std::vector<double> temperature_values (quadrature.size());
-      const unsigned int n_dofs_per_cell = this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            bool refine = false;
-
-            fe_values.reinit(cell);
-            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
-                                                                                         temperature_values);
-
-            // if the nonadiabatic temperature exceeds the threshold, cell is marked for refinement
-            for (unsigned int j=0; j<n_dofs_per_cell; ++j)
-              {
-                const double adiabatic_temperature = this->get_adiabatic_conditions().temperature(fe_values.quadrature_point(j));
-
-                double nonadiabatic_temperature = 0;
-                if (temperature_anomaly_type == absolute_value)
-                  nonadiabatic_temperature = std::abs(temperature_values[j] - adiabatic_temperature);
-                else if (temperature_anomaly_type == positive_only)
-                  nonadiabatic_temperature = temperature_values[j] - adiabatic_temperature;
-                else if (temperature_anomaly_type == negative_only)
-                  nonadiabatic_temperature = adiabatic_temperature - temperature_values[j];
-                else
-                  AssertThrow (false, ExcNotImplemented());
-
-                if (nonadiabatic_temperature > threshold)
-                  {
-                    refine = true;
-                    break;
-                  }
-              }
-
-            if (refine)
-              {
-                cell->clear_coarsen_flag ();
-                cell->set_refine_flag ();
-              }
-          }
-    }
-
-    template <int dim>
-    void
-    NonadiabaticTemperatureThreshold<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Nonadiabatic temperature threshold");
-        {
-          prm.declare_entry ("Threshold",
-                             "100",
-                             Patterns::Double (0.),
-                             "A threshold that the nonadiabatic temperature "
-                             "will be evaluated against. "
-                             "Units: \\si{\\kelvin}");
-          prm.declare_entry ("Temperature anomaly type",
-                             "absolute value",
-                             Patterns::Selection ("negative only|positive only|absolute value"),
-                             "What type of temperature anomaly should be considered when "
-                             "evaluating against the threshold: Only negative anomalies "
-                             "(negative only), only positive anomalies (positive only) "
-                             "or the absolute value of the nonadiabatic temperature.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    NonadiabaticTemperatureThreshold<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Nonadiabatic temperature threshold");
-        {
-          threshold = prm.get_double("Threshold");
-
-          if (prm.get ("Temperature anomaly type") == "negative only")
-            temperature_anomaly_type = negative_only;
-          else if (prm.get ("Temperature anomaly type") == "positive only")
-            temperature_anomaly_type = positive_only;
-          else if (prm.get ("Temperature anomaly type") == "absolute value")
-            temperature_anomaly_type = absolute_value;
-          else
-            AssertThrow (false, ExcNotImplemented());
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(NonadiabaticTemperatureThreshold,
-                                              "nonadiabatic temperature threshold",
-                                              "A mesh refinement criterion that computes refinement "
-                                              "indicators from the temperature difference between the "
-                                              "actual temperature and the adiabatic conditions (the "
-                                              "nonadiabatic temperature). If the temperature anomaly "
-                                              "exceeds the threshold given in the input file, the cell "
-                                              "is marked for refinement.")
-  }
-}
diff --git a/source/mesh_refinement/particle_density.cc.bak b/source/mesh_refinement/particle_density.cc.bak
deleted file mode 100644
index 9113dcd71e4..00000000000
--- a/source/mesh_refinement/particle_density.cc.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/particle_density.h>
-
-#include <aspect/particle/world.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    ParticleDensity<dim>::execute(Vector<float> &indicators) const
-    {
-      AssertThrow(this->n_particle_worlds() > 0,
-                  ExcMessage("The mesh refinement plugin `particle density' requires the "
-                             "postprocessor plugin `particles' to be selected. Please activate the "
-                             "particles or deactivate this mesh refinement plugin."));
-
-      const Particle::ParticleHandler<dim> &particle_handler = this->get_particle_world(0).get_particle_handler();
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            // Note  that this refinement indicator will level out the number
-            // of particles per cell, therefore creating fine cells in regions
-            // of high particle density and coarse cells in low particle
-            // density regions.
-            indicators(cell->active_cell_index()) = static_cast<float>(particle_handler.n_particles_in_cell(cell));
-          }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(ParticleDensity,
-                                              "particle density",
-                                              "A mesh refinement criterion that computes "
-                                              "refinement indicators based on the density "
-                                              "of particles. In practice this plugin "
-                                              "equilibrates the number of particles per cell, "
-                                              "leading to fine cells in high particle density regions "
-                                              "and coarse cells in low particle density regions. "
-                                              "This plugin is mostly useful for models with inhomogeneous "
-                                              "particle density, e.g. when tracking an initial interface "
-                                              "with a high particle density, or when the spatial particle "
-                                              "density denotes the region of interest. Additionally, this "
-                                              "plugin tends to balance the computational load between "
-                                              "processes in parallel computations, because the particle "
-                                              "and mesh density is more aligned.")
-  }
-}
diff --git a/source/mesh_refinement/slope.cc.bak b/source/mesh_refinement/slope.cc.bak
deleted file mode 100644
index e0804b371d6..00000000000
--- a/source/mesh_refinement/slope.cc.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/slope.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    Slope<dim>::execute(Vector<float> &indicators) const
-    {
-      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-      indicators = 0;
-
-      QMidpoint<dim-1> quadrature;
-      UpdateFlags update_flags = UpdateFlags(update_normal_vectors | update_quadrature_points );
-      FEFaceValues<dim> fe_face_values (this->get_mapping(), this->get_fe(), quadrature, update_flags);
-
-      // iterate over all of the cells, get a face normal, then
-      // dot it with the local gravity
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          {
-            const unsigned int idx = cell->active_cell_index();
-            for (const unsigned int face_no : cell->face_indices())
-              if (cell->face(face_no)->at_boundary())
-                {
-                  const types::boundary_id boundary_indicator
-                    = cell->face(face_no)->boundary_id();
-
-                  // Use cases for this plugin include a deforming mesh,
-                  // or a fixed mesh with initial topography
-                  if ( (this->get_parameters().mesh_deformation_enabled &&
-                        this->get_mesh_deformation_boundary_indicators().find(boundary_indicator) !=
-                        this->get_mesh_deformation_boundary_indicators().end()) ||
-                       (Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(this->get_initial_topography_model()) &&
-                        boundary_indicator == top_boundary_id)  )
-                    {
-                      fe_face_values.reinit(cell, face_no);
-
-                      const Tensor<1,dim> normal( fe_face_values.normal_vector(0) ); // Only one q point
-                      const Point<dim> midpoint = fe_face_values.quadrature_point(0);
-                      const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(midpoint);
-
-                      indicators(idx) = std::acos( std::abs ( normal * gravity / gravity.norm() ) ) // Don't care whether gravity is in the opposite direction
-                                        * std::pow( cell->diameter(), static_cast<double>(dim-1)); // scale with approximate surface area of the cell
-                      break;  // no need to loop over the rest of the faces
-                    }
-                }
-          }
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Slope,
-                                              "slope",
-                                              "A class that implements a mesh refinement criterion intended for "
-                                              "use with deforming mesh boundaries, like the free surface. "
-                                              "It calculates a local slope based on "
-                                              "the angle between the surface normal and the local gravity vector. "
-                                              "Cells with larger angles are marked for refinement."
-                                              "\n\n"
-                                              "To use this refinement criterion, you may want to combine "
-                                              "it with other refinement criteria, setting the 'Normalize "
-                                              "individual refinement criteria' flag and using the `max' "
-                                              "setting for 'Refinement criteria merge operation'.")
-  }
-}
diff --git a/source/mesh_refinement/strain_rate.cc.bak b/source/mesh_refinement/strain_rate.cc.bak
deleted file mode 100644
index e12467a1f18..00000000000
--- a/source/mesh_refinement/strain_rate.cc.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/strain_rate.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/numerics/derivative_approximation.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    StrainRate<dim>::execute(Vector<float> &indicators) const
-    {
-      indicators = 0;
-
-      const QMidpoint<dim> quadrature;
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature,
-                               update_quadrature_points | update_values | update_gradients);
-
-      std::vector<SymmetricTensor<2,dim>> strain_rates (quadrature.size());
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            const unsigned int idx = cell->active_cell_index();
-            fe_values.reinit(cell);
-
-            fe_values[this->introspection().extractors.velocities].get_function_symmetric_gradients (this->get_solution(),
-                strain_rates);
-
-            indicators(idx) = strain_rates[0].norm();
-          }
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(StrainRate,
-                                              "strain rate",
-                                              "A mesh refinement criterion that computes the "
-                                              "refinement indicators equal to the strain rate "
-                                              "norm computed at the center of the elements.")
-  }
-}
diff --git a/source/mesh_refinement/temperature.cc.bak b/source/mesh_refinement/temperature.cc.bak
deleted file mode 100644
index a8216ccc404..00000000000
--- a/source/mesh_refinement/temperature.cc.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/temperature.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    Temperature<dim>::execute(Vector<float> &indicators) const
-    {
-      indicators = 0;
-
-      const Quadrature<dim-1> &quadrature = this->introspection().face_quadratures.temperature;
-      KellyErrorEstimator<dim>::estimate (this->get_mapping(),
-                                          this->get_dof_handler(),
-                                          quadrature,
-                                          std::map<types::boundary_id,const Function<dim>*>(),
-                                          this->get_solution(),
-                                          indicators,
-                                          this->introspection().component_masks.temperature,
-                                          nullptr,
-                                          0,
-                                          this->get_triangulation().locally_owned_subdomain());
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Temperature,
-                                              "temperature",
-                                              "A mesh refinement criterion that computes "
-                                              "refinement indicators from the temperature field."
-                                              "\n\n"
-                                              "The way these indicators are computed is by "
-                                              "evaluating the `Kelly error indicator' on the "
-                                              "temperature field. This error indicator takes the "
-                                              "finite element approximation of the temperature "
-                                              "field and uses it to compute an approximation "
-                                              "of the second derivatives of the temperature for "
-                                              "each cell. This approximation is then multiplied "
-                                              "by an appropriate power of the cell's diameter "
-                                              "to yield an indicator for how large the error "
-                                              "is likely going to be on this cell. This "
-                                              "construction rests on the observation that for "
-                                              "many partial differential equations, the error "
-                                              "on each cell is proportional to some power of "
-                                              "the cell's diameter times the second derivatives "
-                                              "of the solution on that cell."
-                                              "\n\n"
-                                              "For complex equations such as those we solve "
-                                              "here, this observation may not be strictly "
-                                              "true in the mathematical sense, but it often "
-                                              "yields meshes that are surprisingly good.")
-  }
-}
diff --git a/source/mesh_refinement/thermal_energy_density.cc.bak b/source/mesh_refinement/thermal_energy_density.cc.bak
deleted file mode 100644
index 61b3d2ed4cc..00000000000
--- a/source/mesh_refinement/thermal_energy_density.cc.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/thermal_energy_density.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/numerics/derivative_approximation.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    ThermalEnergyDensity<dim>::execute(Vector<float> &indicators) const
-    {
-      indicators = 0;
-
-      // create a vector in which we set the temperature block to
-      // be a finite element interpolation of the thermal energy density
-      // rho*C_p*T. we do so by setting up a quadrature formula with the
-      // temperature unit support points, then looping over these
-      // points, compute the output quantity at them, and writing
-      // the result into the output vector in the same order
-      // (because quadrature points and temperature dofs are,
-      // by design of the quadrature formula, numbered in the
-      // same way)
-      LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
-                                                  this->get_mpi_communicator());
-
-      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
-      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature,
-                               update_quadrature_points | update_values | update_gradients);
-
-      // the values of the compositional fields are stored as block vectors for each field
-      // we have to extract them in this structure
-      std::vector<std::vector<double>> prelim_composition_values (this->n_compositional_fields(),
-                                                                   std::vector<double> (quadrature.size()));
-
-      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit(cell);
-            // Set use_strain_rates to false since we don't need viscosity
-            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-            this->get_material_model().evaluate(in, out);
-
-            cell->get_dof_indices (local_dof_indices);
-
-            // for each temperature dof, write into the output
-            // vector the density. note that quadrature points and
-            // dofs are enumerated in the same order
-            for (unsigned int i=0; i<this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell; ++i)
-              {
-                const unsigned int system_local_dof
-                  = this->get_fe().component_to_system_index(this->introspection().component_indices.temperature,
-                                                             /*dof index within component=*/i);
-
-                vec_distributed(local_dof_indices[system_local_dof])
-                  = out.densities[i]
-                    * in.temperature[i]
-                    * out.specific_heat[i];
-              }
-          }
-
-      vec_distributed.compress(VectorOperation::insert);
-
-      // now create a vector with the requisite ghost elements
-      // and use it for estimating the gradients
-      LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
-                                      this->introspection().index_sets.system_relevant_partitioning,
-                                      this->get_mpi_communicator());
-      vec = vec_distributed;
-
-      DerivativeApproximation::approximate_gradient  (this->get_mapping(),
-                                                      this->get_dof_handler(),
-                                                      vec,
-                                                      indicators,
-                                                      this->introspection().component_indices.temperature);
-
-      // Scale gradient in each cell with the correct power of h. Otherwise,
-      // error indicators do not reduce when refined if there is a density
-      // jump. We need at least order 1 for the error not to grow when
-      // refining, so anything >1 should work. (note that the gradient
-      // itself scales like 1/h, so multiplying it with any factor h^s, s>1
-      // will yield convergence of the error indicators to zero as h->0)
-      const double power = 1.5;
-      {
-        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned())
-            indicators(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(ThermalEnergyDensity,
-                                              "thermal energy density",
-                                              "A mesh refinement criterion that computes "
-                                              "refinement indicators from a field that describes "
-                                              "the spatial variability of the thermal energy density, $\\rho C_p T$. "
-                                              "Because this quantity may not be a continuous function ($\\rho$ "
-                                              "and $C_p$ may be discontinuous functions along discontinuities in the "
-                                              "medium, for example due to phase changes), we approximate the "
-                                              "gradient of this quantity to refine the mesh. The error indicator "
-                                              "defined here takes the magnitude of the approximate gradient "
-                                              "and scales it by $h_K^{1.5}$ where $h_K$ is the diameter of each cell. "
-                                              "This scaling ensures that the error indicators converge to zero as "
-                                              "$h_K\\rightarrow 0$ even if the energy density is discontinuous, since "
-                                              "the gradient of a discontinuous function grows like $1/h_K$.")
-  }
-}
diff --git a/source/mesh_refinement/topography.cc.bak b/source/mesh_refinement/topography.cc.bak
deleted file mode 100644
index 8606afd221e..00000000000
--- a/source/mesh_refinement/topography.cc.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-  Copyright (C) 2011 - 2019 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/topography.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    Topography<dim>::execute(Vector<float> &indicators) const
-    {
-      // For calculating surface topography in the respective postprocessor
-      // we use the pressure in the middle of the cell. Thus, to get an
-      // accurate result, all the cells at the upper boundary should have
-      // the same level of refinement. This postprocessor causes a refinement
-      // in the uppermost cells, which also makes sure that the upper
-      // boundary layer is resolved as good as possible.
-
-      indicators = 0;
-
-      // need quadrature formula to calculate the depth
-      // evaluate a single point per cell
-      const QMidpoint<dim> quadrature_formula;
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      // iterate over all of the cells and choose the ones at the upper
-      // boundary for refinement (assign the largest error to them)
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            const double depth = this->get_geometry_model().depth(fe_values.quadrature_point(0));
-            if (cell->at_boundary() && depth < cell->diameter())
-              indicators(cell->active_cell_index()) = 1.0;
-          }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Topography,
-                                              "topography",
-                                              "A class that implements a mesh refinement criterion, which "
-                                              "always flags all cells in the uppermost layer for refinement. "
-                                              "This is useful to provide high accuracy for processes at or "
-                                              "close to the surface."
-                                              "\n\n"
-                                              "To use this refinement criterion, you may want to combine "
-                                              "it with other refinement criteria, setting the 'Normalize "
-                                              "individual refinement criteria' flag and using the `max' "
-                                              "setting for 'Refinement criteria merge operation'.")
-  }
-}
diff --git a/source/mesh_refinement/velocity.cc.bak b/source/mesh_refinement/velocity.cc.bak
deleted file mode 100644
index 0690d20f828..00000000000
--- a/source/mesh_refinement/velocity.cc.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/velocity.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    Velocity<dim>::execute(Vector<float> &indicators) const
-    {
-      indicators = 0;
-
-      const Quadrature<dim-1> &quadrature = this->introspection().face_quadratures.velocities;
-      KellyErrorEstimator<dim>::estimate (this->get_mapping(),
-                                          this->get_dof_handler(),
-                                          quadrature,
-                                          std::map<types::boundary_id,const Function<dim>*>(),
-                                          this->get_solution(),
-                                          indicators,
-                                          this->introspection().component_masks.velocities,
-                                          nullptr,
-                                          0,
-                                          this->get_triangulation().locally_owned_subdomain());
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Velocity,
-                                              "velocity",
-                                              "A mesh refinement criterion that computes "
-                                              "refinement indicators from the velocity field."
-                                              "\n\n"
-                                              "The way these indicators are computed is by "
-                                              "evaluating the `Kelly error indicator' on the "
-                                              "velocity field. This error indicator takes the "
-                                              "finite element approximation of the velocity "
-                                              "field and uses it to compute an approximation "
-                                              "of the second derivatives of the velocity for "
-                                              "each cell. This approximation is then multiplied "
-                                              "by an appropriate power of the cell's diameter "
-                                              "to yield an indicator for how large the error "
-                                              "is likely going to be on this cell. This "
-                                              "construction rests on the observation that for "
-                                              "many partial differential equations, the error "
-                                              "on each cell is proportional to some power of "
-                                              "the cell's diameter times the second derivatives "
-                                              "of the solution on that cell."
-                                              "\n\n"
-                                              "For complex equations such as those we solve "
-                                              "here, this observation may not be strictly "
-                                              "true in the mathematical sense, but it often "
-                                              "yields meshes that are surprisingly good.")
-  }
-}
diff --git a/source/mesh_refinement/viscosity.cc.bak b/source/mesh_refinement/viscosity.cc.bak
deleted file mode 100644
index ab4cc0b167a..00000000000
--- a/source/mesh_refinement/viscosity.cc.bak
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/viscosity.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/numerics/derivative_approximation.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    template <int dim>
-    void
-    Viscosity<dim>::execute(Vector<float> &indicators) const
-    {
-      indicators = 0;
-
-//TODO: if the viscosity doesn't actually depend on the solution
-      // then we can get away with simply interpolating it spatially
-
-
-      // create a vector in which we set the temperature block to
-      // be a finite element interpolation of the viscosity.
-      // we do so by setting up a quadrature formula with the
-      // temperature unit support points, then looping over these
-      // points, compute the output quantity at them, and writing
-      // the result into the output vector in the same order
-      // (because quadrature points and temperature dofs are,
-      // by design of the quadrature formula, numbered in the
-      // same way)
-      LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
-                                                  this->get_mpi_communicator());
-
-      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_support_points());
-      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature,
-                               update_quadrature_points | update_values | update_gradients);
-
-      // the values of the compositional fields are stored as block vectors for each field
-      // we have to extract them in this structure
-      std::vector<std::vector<double>> prelim_composition_values (this->n_compositional_fields(),
-                                                                   std::vector<double> (quadrature.size()));
-
-      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(),
-                                                 this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(),
-                                                   this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit(cell);
-            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-            this->get_material_model().evaluate(in, out);
-
-            cell->get_dof_indices (local_dof_indices);
-
-            // for each temperature dof, write into the output
-            // vector the viscosity. note that quadrature points and
-            // dofs are enumerated in the same order
-            for (unsigned int i=0; i<this->get_fe().base_element(this->introspection().base_elements.temperature).dofs_per_cell; ++i)
-              {
-                const unsigned int system_local_dof
-                  = this->get_fe().component_to_system_index(this->introspection().component_indices.temperature,
-                                                             /*dof index within component=*/i);
-
-                vec_distributed(local_dof_indices[system_local_dof])
-                  = std::log(out.viscosities[i]);
-              }
-          }
-
-      vec_distributed.compress(VectorOperation::insert);
-
-      // now create a vector with the requisite ghost elements
-      // and use it for estimating the gradients
-      LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
-                                      this->introspection().index_sets.system_relevant_partitioning,
-                                      this->get_mpi_communicator());
-      vec = vec_distributed;
-
-      DerivativeApproximation::approximate_gradient  (this->get_mapping(),
-                                                      this->get_dof_handler(),
-                                                      vec,
-                                                      indicators,
-                                                      this->introspection().component_indices.temperature);
-
-      // Scale gradient in each cell with the correct power of h. Otherwise,
-      // error indicators do not reduce when refined if there is a viscosity
-      // jump. We need at least order 1 for the error not to grow when
-      // refining, so anything >1 should work. (note that the gradient
-      // itself scales like 1/h, so multiplying it with any factor h^s, s>1
-      // will yield convergence of the error indicators to zero as h->0)
-      const double power = 1.0 + dim/2.0;
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          indicators(cell->active_cell_index()) *= std::pow(cell->diameter(), power);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(Viscosity,
-                                              "viscosity",
-                                              "A mesh refinement criterion that computes "
-                                              "refinement indicators from a field that describes "
-                                              "the spatial variability of the logarithm of the viscosity, $\\log\\eta$. "
-                                              "(We choose the logarithm of the viscosity because it can vary by "
-                                              "orders of magnitude.)"
-                                              "Because this quantity may not be a continuous function ($\\eta$ "
-                                              "may be a discontinuous function along discontinuities in the "
-                                              "medium, for example due to phase changes), we approximate the "
-                                              "gradient of this quantity to refine the mesh. The error indicator "
-                                              "defined here takes the magnitude of the approximate gradient "
-                                              "and scales it by $h_K^{1+d/2}$ where $h_K$ is the diameter of each cell "
-                                              "and $d$ is the dimension. "
-                                              "This scaling ensures that the error indicators converge to zero as "
-                                              "$h_K\\rightarrow 0$ even if the viscosity is discontinuous, since "
-                                              "the gradient of a discontinuous function grows like $1/h_K$.")
-  }
-}
diff --git a/source/mesh_refinement/volume_of_fluid_interface.cc.bak b/source/mesh_refinement/volume_of_fluid_interface.cc.bak
deleted file mode 100644
index 3bc7d3e2d51..00000000000
--- a/source/mesh_refinement/volume_of_fluid_interface.cc.bak
+++ /dev/null
@@ -1,345 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_refinement/volume_of_fluid_interface.h>
-#include <aspect/volume_of_fluid/handler.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/geometry_info.h>
-
-#include <deal.II/numerics/error_estimator.h>
-
-#include <deal.II/fe/fe_values.h>
-
-#include <deal.II/grid/grid_tools.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-
-    template <int dim>
-    void
-    VolumeOfFluidInterface<dim>::tag_additional_cells() const
-    {
-      // Break early if DoFs have not been distributed yet.
-      if (this->get_dof_handler().n_dofs() == 0)
-        return;
-
-      const QMidpoint<dim> qMidC;
-
-      // Create a map from vertices to adjacent cells
-      const std::vector<std::set<typename Triangulation<dim>::active_cell_iterator>>
-      vertex_to_cells(GridTools::vertex_to_cell_map(this->get_triangulation()));
-
-      std::set<typename Triangulation<dim>::active_cell_iterator> marked_cells;
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               qMidC,
-                               update_values |
-                               update_quadrature_points);
-
-      // Create block vector to indicate when other mpi process believes cell
-      // borders an interface cell and therefore neighbors should be refined
-      // Use the first vof block, due to being the correct size, and only
-      // needing one indicator
-      LinearAlgebra::BlockVector interface_contained_local(
-        this->introspection().index_sets.system_partitioning,
-        this->get_mpi_communicator());
-
-      const FiniteElement<dim> &system_fe = this->get_fe();
-
-      const VolumeOfFluidField<dim> vof_field = this->get_volume_of_fluid_handler().field_struct_for_field_index(0);
-      const unsigned int volume_fraction_block = vof_field.volume_fraction.block_index;
-      const unsigned int volume_of_fluid_c_index = vof_field.volume_fraction.first_component_index;
-      const unsigned int volume_of_fluid_ind
-        = this->get_fe().component_to_system_index(volume_of_fluid_c_index, 0);
-
-      interface_contained_local.block(volume_fraction_block) = 0.0;
-
-      std::vector<types::global_dof_index> local_dof_indices (system_fe.dofs_per_cell);
-
-      for (unsigned int f=0; f<this->get_volume_of_fluid_handler().get_n_fields(); ++f)
-        {
-
-          const double volume_fraction_threshold = this->get_volume_of_fluid_handler().get_volume_fraction_threshold();
-
-          const FEValuesExtractors::Scalar volume_of_fluid_field = this->get_volume_of_fluid_handler().field_struct_for_field_index(f)
-                                                                   .volume_fraction.extractor_scalar();
-
-          std::vector<double> volume_of_fluid_values(qMidC.size());
-          std::vector<double> neighbor_volume_of_fluid_values(qMidC.size());
-
-
-          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-            if (!cell->is_artificial())
-              {
-                bool refine_current_cell = false;
-
-                // Get cell volume_of_fluid
-                fe_values.reinit(cell);
-                fe_values[volume_of_fluid_field].get_function_values(this->get_solution(),
-                                                                     volume_of_fluid_values);
-
-                // Handle overshoots
-                volume_of_fluid_values[0] = std::min(volume_of_fluid_values[0], 1.0);
-                volume_of_fluid_values[0] = std::max(volume_of_fluid_values[0], 0.0);
-
-                // Check if at interface
-                if (volume_of_fluid_values[0] > volume_fraction_threshold && volume_of_fluid_values[0] < (1.0 - volume_fraction_threshold))
-                  {
-                    refine_current_cell = true;
-                  }
-
-                if (!refine_current_cell)
-                  {
-                    for (const unsigned int f : cell->face_indices())
-                      {
-                        const bool cell_has_periodic_neighbor = cell->has_periodic_neighbor(f);
-                        const typename DoFHandler<dim>::face_iterator face = cell->face(f);
-
-                        // Skip if face is at boundary, and does not have a periodic neighbor
-                        if (face->at_boundary() && !cell_has_periodic_neighbor)
-                          continue;
-
-                        const typename DoFHandler<dim>::cell_iterator neighbor = cell->neighbor_or_periodic_neighbor(f);
-
-                        Assert(cell.state()==IteratorState::valid, ExcInternalError());
-
-                        if ((!face->at_boundary() && !face->has_children())
-                            ||
-                            (face->at_boundary() && cell->periodic_neighbor_is_coarser(f))
-                            ||
-                            (face->at_boundary() && neighbor->level() == cell->level() && neighbor->is_active()))
-                          {
-                            if (neighbor->is_active() && !neighbor->is_artificial())
-                              {
-                                fe_values.reinit(neighbor);
-                                fe_values[volume_of_fluid_field].get_function_values(this->get_solution(),
-                                                                                     neighbor_volume_of_fluid_values);
-
-                                // Handle overshoots
-                                neighbor_volume_of_fluid_values[0] = std::min(neighbor_volume_of_fluid_values[0], 1.0);
-                                neighbor_volume_of_fluid_values[0] = std::max(neighbor_volume_of_fluid_values[0], 0.0);
-
-                                if (std::abs(neighbor_volume_of_fluid_values[0]-volume_of_fluid_values[0])>volume_fraction_threshold)
-                                  {
-                                    refine_current_cell = true;
-                                    break;
-                                  }
-                              }
-                          }
-                        else
-                          {
-                            for (unsigned int subface=0; subface < face->n_children(); ++subface)
-                              {
-                                const typename DoFHandler<dim>::active_cell_iterator neighbor_sub =
-                                  (cell_has_periodic_neighbor
-                                   ?
-                                   cell->periodic_neighbor_child_on_subface(f, subface)
-                                   :
-                                   cell->neighbor_child_on_subface(f, subface));
-
-                                Assert(neighbor_sub.state()==IteratorState::valid, ExcInternalError());
-
-                                if (neighbor_sub->is_artificial())
-                                  continue;
-
-                                fe_values.reinit(neighbor_sub);
-                                fe_values[volume_of_fluid_field].get_function_values(this->get_solution(),
-                                                                                     neighbor_volume_of_fluid_values);
-
-                                // Handle overshoots
-                                neighbor_volume_of_fluid_values[0] = std::min(neighbor_volume_of_fluid_values[0], 1.0);
-                                neighbor_volume_of_fluid_values[0] = std::max(neighbor_volume_of_fluid_values[0], 0.0);
-
-                                if (std::abs(neighbor_volume_of_fluid_values[0]-volume_of_fluid_values[0])>volume_fraction_threshold)
-                                  {
-                                    refine_current_cell = true;
-                                    break;
-                                  }
-
-                              }
-                            if (refine_current_cell)
-                              break;
-                          }
-                      }
-                  }
-
-                if (refine_current_cell)
-                  {
-                    // Fractional volume
-                    marked_cells.insert(cell);
-                    if (cell->is_locally_owned())
-                      {
-                        cell->clear_coarsen_flag ();
-                        cell->set_refine_flag ();
-                        // Mark in vector, will be true here if true on any process
-                        cell->get_dof_indices(local_dof_indices);
-                        interface_contained_local(local_dof_indices[volume_of_fluid_ind]) = 1.0;
-                      }
-                  }
-
-              }
-        }
-
-      // Now communicate and mark any cells not already included, this could be
-      // reduced to only loop over cells bordering another process
-      LinearAlgebra::BlockVector interface_contained_global(
-        this->introspection().index_sets.system_partitioning,
-        this->introspection().index_sets.system_relevant_partitioning,
-        this->get_mpi_communicator());
-
-      interface_contained_global.block(volume_fraction_block) = interface_contained_local.block(volume_fraction_block);
-      interface_contained_global.update_ghost_values();
-
-      const FEValuesExtractors::Scalar ic_extract = this->get_volume_of_fluid_handler().field_struct_for_field_index(0)
-                                                    .volume_fraction.extractor_scalar();
-      std::vector<double> ic_values(qMidC.size());
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (!cell->is_artificial())
-          {
-            fe_values.reinit(cell);
-            fe_values[ic_extract].get_function_values(interface_contained_global,
-                                                      ic_values);
-
-            // If the cell has been indicated to need refinement add it
-            if (ic_values[0]>0.5)
-              {
-                marked_cells.insert(cell);
-              }
-          }
-
-      // Now mark for refinement all cells that are a neighbor of a cell that contains the interface
-
-      std::set<typename Triangulation<dim>::active_cell_iterator> marked_cells_and_neighbors = marked_cells;
-      typename std::set<typename parallel::distributed::Triangulation<dim>::active_cell_iterator>::const_iterator mcells = marked_cells.begin(),
-                                                                                                                  endmc = marked_cells.end();
-      for (; mcells != endmc; ++mcells)
-        {
-          typename parallel::distributed::Triangulation<dim>::active_cell_iterator mcell = *mcells;
-          for (const unsigned int vertex_index : mcell->vertex_indices())
-            {
-              const std::set<typename Triangulation<dim>::active_cell_iterator> &neighbor_cells = vertex_to_cells[mcell->vertex_index(vertex_index)];
-              for (const auto &neighbor_cell : neighbor_cells)
-                {
-                  if (neighbor_cell->is_active() && neighbor_cell->is_locally_owned())
-                    {
-                      neighbor_cell->clear_coarsen_flag ();
-                      neighbor_cell->set_refine_flag ();
-                      marked_cells_and_neighbors.insert(neighbor_cell);
-                    }
-                }
-            }
-
-          // Check for periodic neighbors, and refine if existing
-          for (const unsigned int f : mcell->face_indices())
-            {
-              if (mcell->has_periodic_neighbor(f))
-                {
-                  typename Triangulation<dim>::cell_iterator itr_tmp = mcell->periodic_neighbor(f);
-
-                  if (itr_tmp->is_active() && itr_tmp->is_locally_owned())
-                    {
-                      itr_tmp->clear_coarsen_flag ();
-                      itr_tmp->set_refine_flag ();
-                      marked_cells_and_neighbors.insert(itr_tmp);
-                    }
-                }
-            }
-        }
-
-      if (strict_coarsening)
-        {
-          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-            if (cell->is_locally_owned())
-              {
-                if (marked_cells_and_neighbors.find(cell) != marked_cells_and_neighbors.end())
-                  {
-                    //Refinement already requested
-                  }
-                else
-                  {
-                    if (cell->is_active())
-                      {
-                        cell->set_coarsen_flag();
-                        cell->clear_refine_flag();
-                      }
-                  }
-              }
-
-        }
-
-    }
-
-    template <int dim>
-    void
-    VolumeOfFluidInterface<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Volume of fluid interface");
-        {
-          prm.declare_entry("Strict coarsening", "false",
-                            Patterns::Bool(),
-                            "If true, then explicitly coarsen any cells not "
-                            "neighboring the VolumeOfFluid interface.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    VolumeOfFluidInterface<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      AssertThrow(this->get_parameters().volume_of_fluid_tracking_enabled,
-                  ExcMessage("The 'volume_of_fluid boundary' mesh refinement strategy requires that the 'Use interface tracking' parameter is enabled."));
-
-      prm.enter_subsection("Mesh refinement");
-      {
-        prm.enter_subsection("Volume of fluid interface");
-        {
-          strict_coarsening = prm.get_bool("Strict coarsening");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(VolumeOfFluidInterface,
-                                              "volume of fluid interface",
-                                              "A class that implements a mesh refinement criterion, which "
-                                              "ensures a minimum level of refinement near the volume of fluid interface boundary.")
-  }
-}
diff --git a/source/particle/generator/ascii_file.cc.bak b/source/particle/generator/ascii_file.cc.bak
deleted file mode 100644
index 539c55f496f..00000000000
--- a/source/particle/generator/ascii_file.cc.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/generator/ascii_file.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      template <int dim>
-      void
-      AsciiFile<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
-      {
-        const std::string filename = data_directory+data_filename;
-
-        // Read data from disk and distribute among processes
-        std::istringstream in(Utilities::read_and_distribute_file_content(filename, this->get_mpi_communicator()));
-
-        // Skip header lines
-        while (in.peek() == '#')
-          {
-            std::string temp;
-            std::getline(in,temp);
-          }
-
-        // Read data lines
-        types::particle_index particle_index = 0;
-        Point<dim> particle_position;
-
-        while (in >> particle_position)
-          {
-            this->insert_particle_at_position(particle_position, particle_index, particle_handler);
-            ++particle_index;
-          }
-        particle_handler.update_cached_numbers();
-      }
-
-
-      template <int dim>
-      void
-      AsciiFile<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Ascii file");
-          {
-            prm.declare_entry ("Data directory",
-                               "$ASPECT_SOURCE_DIR/data/particle/generator/ascii/",
-                               Patterns::DirectoryName (),
-                               "The name of a directory that contains the particle data. This path "
-                               "may either be absolute (if starting with a '/') or relative to "
-                               "the current directory. The path may also include the special "
-                               "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                               "in which the ASPECT source files were located when ASPECT was "
-                               "compiled. This interpretation allows, for example, to reference "
-                               "files located in the `data/' subdirectory of ASPECT. ");
-            prm.declare_entry ("Data file name", "particle.dat",
-                               Patterns::Anything (),
-                               "The name of the particle file.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      AsciiFile<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Ascii file");
-          {
-            data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-
-            data_filename    = prm.get ("Data file name");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      ASPECT_REGISTER_PARTICLE_GENERATOR(AsciiFile,
-                                         "ascii file",
-                                         "Generates a distribution of particles from coordinates "
-                                         "specified in an Ascii data file. The file format is "
-                                         "a simple text file, with as many columns as spatial "
-                                         "dimensions and as many lines as particles to be generated. "
-                                         "Initial comment lines starting with `#' will be discarded. "
-                                         "Note that this plugin always generates as many particles "
-                                         "as there are coordinates in the data file, the "
-                                         "``Particles/Number of particles'' parameter "
-                                         "has no effect on this plugin. "
-                                         "All of the values that define this generator are read "
-                                         "from a section ``Particles/Generator/Ascii file'' in the "
-                                         "input file, see "
-                                         "Section~\\ref{parameters:Particles/Generator/Ascii_20file}.")
-    }
-  }
-}
diff --git a/source/particle/generator/interface.cc.bak b/source/particle/generator/interface.cc.bak
deleted file mode 100644
index f48c36c2525..00000000000
--- a/source/particle/generator/interface.cc.bak
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/generator/interface.h>
-
-#include <tuple>
-#include <deal.II/grid/grid_tools.h>
-
-#include <boost/lexical_cast.hpp>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      template <int dim>
-      void
-      Interface<dim>::initialize ()
-      {
-        const unsigned int my_rank = Utilities::MPI::this_mpi_process(this->get_mpi_communicator());
-        random_number_generator.seed(5432+my_rank);
-      }
-
-
-
-      template <int dim>
-      void
-      Interface<dim>::generate_particles(std::multimap<Particles::internal::LevelInd, Particle<dim>> &/*particles*/)
-      {
-        AssertThrow(false,ExcInternalError());
-      }
-
-
-
-      template <int dim>
-      void
-      Interface<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
-      {
-        // This function is implemented to ensure backwards compatibility to an old interface.
-        // Once the old interface function has been removed this implementation can be removed
-        // as well and the function can be made pure.
-
-        std::multimap<Particles::internal::LevelInd, Particles::Particle<dim>> particles;
-
-        // avoid deprecation warnings about calling the old interface
-        DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-        generate_particles(particles);
-        DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-
-        std::multimap<typename Triangulation<dim>::active_cell_iterator, Particles::Particle<dim>> new_particles;
-
-        for (const auto &particle : particles)
-          new_particles.insert(new_particles.end(),
-                               std::make_pair(typename Triangulation<dim>::active_cell_iterator(&this->get_triangulation(),
-                                              particle.first.first, particle.first.second),
-                                              particle.second));
-
-        particle_handler.insert_particles(new_particles);
-      }
-
-
-
-      template <int dim>
-      std::pair<Particles::internal::LevelInd,Particle<dim>>
-      Interface<dim>::generate_particle(const Point<dim> &position,
-                                        const types::particle_index id) const
-      {
-        // Try to find the cell of the given position. If the position is not
-        // in the domain on the local process, throw a ExcParticlePointNotInDomain
-        // exception.
-        std::pair<const typename parallel::distributed::Triangulation<dim>::active_cell_iterator,
-            Point<dim>> it =
-              GridTools::find_active_cell_around_point<> (this->get_mapping(), this->get_triangulation(), position);
-
-        // Only try to add the point if the cell it is in, is on this processor
-        AssertThrow(it.first.state() == IteratorState::valid && it.first->is_locally_owned(),
-                    ExcParticlePointNotInDomain());
-
-        const Particle<dim> particle(position, it.second, id);
-        const Particles::internal::LevelInd cell(it.first->level(), it.first->index());
-        return std::make_pair(cell,particle);
-
-        // Avoid warnings about missing return
-        return {};
-      }
-
-
-
-      template <int dim>
-      Particles::ParticleIterator<dim>
-      Interface<dim>::insert_particle_at_position(const Point<dim> &position,
-                                                  const types::particle_index id,
-                                                  Particles::ParticleHandler<dim> &particle_handler) const
-      {
-        // Try to find the cell of the given position.
-        const std::pair<const typename parallel::distributed::Triangulation<dim>::active_cell_iterator,
-              Point<dim>> it =
-                GridTools::find_active_cell_around_point<> (this->get_mapping(), this->get_triangulation(), position);
-
-        if (it.first.state() != IteratorState::valid || it.first->is_locally_owned() == false)
-          return particle_handler.end();
-
-        return particle_handler.insert_particle(Particle<dim>(position, it.second, id), it.first);
-      }
-
-
-
-      template <int dim>
-      std::pair<Particles::internal::LevelInd,Particle<dim>>
-      Interface<dim>::generate_particle (const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell,
-                                         const types::particle_index id)
-      {
-        // Uniform distribution on the interval [0,1]. This
-        // will be used to generate random particle locations.
-        std::uniform_real_distribution<double> uniform_distribution_01(0.0, 1.0);
-
-        const BoundingBox<dim> cell_bounding_box = cell->bounding_box();
-
-        // Generate random points in these bounds until one is within the cell
-        unsigned int iteration = 0;
-        const unsigned int maximum_iterations = 100;
-        Point<dim> particle_position;
-        while (iteration < maximum_iterations)
-          {
-            // First generate a random point in the bounding box...
-            for (unsigned int d=0; d<dim; ++d)
-              particle_position[d] = cell_bounding_box.lower_bound(d)
-                                     + (uniform_distribution_01(random_number_generator) *
-                                        cell_bounding_box.side_length(d));
-
-            // ...then check whether it is actually in the cell:
-            try
-              {
-                const Point<dim> p_unit = this->get_mapping().transform_real_to_unit_cell(cell, particle_position);
-                if (
-                  cell->reference_cell().contains_point(p_unit)
-                )
-                  {
-                    // Add the generated particle to the set
-                    const Particle<dim> new_particle(particle_position, p_unit, id);
-                    const Particles::internal::LevelInd cellid(cell->level(), cell->index());
-                    return std::make_pair(cellid,new_particle);
-                  }
-              }
-            catch (typename Mapping<dim>::ExcTransformationFailed &)
-              {
-                // The point is not in this cell. Do nothing, just try again.
-              }
-            ++iteration;
-          }
-
-        // If the above algorithm has not worked (e.g. because of badly
-        // deformed cells), retry generating particles
-        // randomly within the reference cell. This is not generating a
-        // uniform distribution in real space, but will always succeed.
-        for (unsigned int d=0; d<dim; ++d)
-          particle_position[d] = uniform_distribution_01(random_number_generator);
-
-        const Point<dim> p_real = this->get_mapping().transform_unit_to_real_cell(cell,particle_position);
-
-        // Add the generated particle to the set
-        const Particle<dim> new_particle(p_real, particle_position, id);
-        const Particles::internal::LevelInd cellid(cell->level(), cell->index());
-
-        return std::make_pair(cellid, new_particle);
-      }
-
-
-// -------------------------------- Deal with registering models and automating
-// -------------------------------- their setup and selection at run time
-
-      namespace
-      {
-        std::tuple
-        <void *,
-        void *,
-        aspect::internal::Plugins::PluginList<Interface<2>>,
-        aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-      }
-
-
-
-      template <int dim>
-      void
-      register_particle_generator (const std::string &name,
-                                   const std::string &description,
-                                   void (*declare_parameters_function) (ParameterHandler &),
-                                   std::unique_ptr<Interface<dim>> (*factory_function) ())
-      {
-        std::get<dim>(registered_plugins).register_plugin (name,
-                                                           description,
-                                                           declare_parameters_function,
-                                                           factory_function);
-      }
-
-
-
-      template <int dim>
-      std::unique_ptr<Interface<dim>>
-      create_particle_generator (ParameterHandler &prm)
-      {
-        std::string name;
-        name = prm.get ("Particle generator name");
-
-        return std::get<dim>(registered_plugins).create_plugin (name,
-                                                                "Particle::Generator name");
-      }
-
-
-
-      template <int dim>
-      void
-      declare_parameters (ParameterHandler &prm)
-      {
-        // declare the entry in the parameter file
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry ("Particle generator name", "random uniform",
-                           Patterns::Selection (pattern_of_names),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-
-        std::get<dim>(registered_plugins).declare_parameters (prm);
-      }
-
-
-
-      template <int dim>
-      void
-      write_plugin_graph (std::ostream &out)
-      {
-        std::get<dim>(registered_plugins).write_plugin_graph ("Particle generator interface",
-                                                              out);
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<Particle::Generator::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<Particle::Generator::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<Particle::Generator::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<Particle::Generator::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace Particle
-  {
-    namespace Generator
-    {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_particle_generator<dim> (const std::string &, \
-                                    const std::string &, \
-                                    void ( *) (ParameterHandler &), \
-                                    std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_particle_generator<dim> (ParameterHandler &prm);
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/source/particle/generator/probability_density_function.cc.bak b/source/particle/generator/probability_density_function.cc.bak
deleted file mode 100644
index d276fd2399e..00000000000
--- a/source/particle/generator/probability_density_function.cc.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/generator/probability_density_function.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/geometry_info.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      template <int dim>
-      void
-      ProbabilityDensityFunction<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
-      {
-        Particles::Generators::probabilistic_locations(this->get_triangulation(),
-                                                       function,
-                                                       random_cell_selection,
-                                                       n_particles,
-                                                       particle_handler,
-                                                       this->get_mapping(),
-                                                       random_number_seed);
-      }
-
-
-
-      template <int dim>
-      void
-      ProbabilityDensityFunction<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Probability density function");
-          {
-            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-
-            prm.declare_entry ("Number of particles", "1000",
-                               Patterns::Double (0.),
-                               "Total number of particles to create (not per processor or per element). "
-                               "The number is parsed as a floating point number (so that one can "
-                               "specify, for example, '1e4' particles) but it is interpreted as "
-                               "an integer, of course.");
-
-            prm.declare_entry ("Random cell selection", "true",
-                               Patterns::Bool(),
-                               "If true, particle numbers per cell are calculated randomly "
-                               "according to their respective probability density. "
-                               "This means particle numbers per cell can deviate statistically from "
-                               "the integral of the probability density. If false, "
-                               "first determine how many particles each cell should have "
-                               "based on the integral of the density over each of the cells, "
-                               "and then once we know how many particles we want on each cell, "
-                               "choose their locations randomly within each cell.");
-
-            prm.declare_entry ("Random number seed", "5432",
-                               Patterns::Integer(0),
-                               "The seed for the random number generator that controls "
-                               "the particle generation. Keep constant to generate "
-                               "identical particle distributions in subsequent model "
-                               "runs. Change to get a different distribution. In parallel "
-                               "computations the seed is further modified on each process "
-                               "to ensure different particle patterns on different "
-                               "processes. Note that the number of particles per processor "
-                               "is not affected by the seed.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      ProbabilityDensityFunction<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Probability density function");
-          {
-            n_particles = static_cast<types::particle_index>(prm.get_double ("Number of particles"));
-            random_cell_selection = prm.get_bool("Random cell selection");
-            random_number_seed = prm.get_integer("Random number seed");
-
-            try
-              {
-                function.parse_parameters (prm);
-              }
-            catch (...)
-              {
-                std::cerr << "ERROR: FunctionParser failed to parse\n"
-                          << "\t'Particle.Generator.Probability density function'\n"
-                          << "with expression\n"
-                          << "\t'" << prm.get("Function expression") << "'";
-                throw;
-              }
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      ASPECT_REGISTER_PARTICLE_GENERATOR(ProbabilityDensityFunction,
-                                         "probability density function",
-                                         "Generate a random distribution of "
-                                         "particles over the entire simulation domain. "
-                                         "The probability density is prescribed in the "
-                                         "form of a user-prescribed function. The "
-                                         "format of this function follows the syntax "
-                                         "understood by the muparser library, see "
-                                         "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`. The "
-                                         "return value of the function is always "
-                                         "checked to be a non-negative probability "
-                                         "density but it can be zero in "
-                                         "parts of the domain.")
-    }
-  }
-}
diff --git a/source/particle/generator/quadrature_points.cc.bak b/source/particle/generator/quadrature_points.cc.bak
deleted file mode 100644
index 5264920e257..00000000000
--- a/source/particle/generator/quadrature_points.cc.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/generator/quadrature_points.h>
-
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      template <int dim>
-      void
-      QuadraturePoints<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
-      {
-        const Quadrature<dim> &quadrature_formula
-          = this->introspection().quadratures.velocities;
-
-        Particles::Generators::regular_reference_locations(
-          this->get_triangulation(),
-          quadrature_formula.get_points(),
-          particle_handler,
-          this->get_mapping());
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      ASPECT_REGISTER_PARTICLE_GENERATOR(QuadraturePoints,
-                                         "quadrature points",
-                                         "Generates particles at the quadrature points of each active cell of "
-                                         "the triangulation. Here, Gauss quadrature of degree (velocity\\_degree + 1), "
-                                         "is used similarly to the assembly of Stokes matrix.")
-    }
-  }
-}
diff --git a/source/particle/generator/random_uniform.cc.bak b/source/particle/generator/random_uniform.cc.bak
deleted file mode 100644
index 3fa2c84efca..00000000000
--- a/source/particle/generator/random_uniform.cc.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/generator/random_uniform.h>
-
-#include <deal.II/base/function.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      template <int dim>
-      void
-      RandomUniform<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
-      {
-        Particles::Generators::probabilistic_locations(this->get_triangulation(),
-                                                       Functions::ConstantFunction<dim>(1.0),
-                                                       random_cell_selection,
-                                                       n_particles,
-                                                       particle_handler,
-                                                       this->get_mapping(),
-                                                       random_number_seed);
-      }
-
-
-
-      template <int dim>
-      void
-      RandomUniform<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Probability density function");
-          {
-            prm.declare_entry ("Number of particles", "1000",
-                               Patterns::Double (0.),
-                               "Total number of particles to create (not per processor or per element). "
-                               "The number is parsed as a floating point number (so that one can "
-                               "specify, for example, '1e4' particles) but it is interpreted as "
-                               "an integer, of course.");
-
-            prm.declare_entry ("Random cell selection", "true",
-                               Patterns::Bool(),
-                               "If true, particle numbers per cell are calculated randomly "
-                               "according to their respective probability density. "
-                               "This means particle numbers per cell can deviate statistically from "
-                               "the integral of the probability density. If false, "
-                               "first determine how many particles each cell should have "
-                               "based on the integral of the density over each of the cells, "
-                               "and then once we know how many particles we want on each cell, "
-                               "choose their locations randomly within each cell.");
-
-            prm.declare_entry ("Random number seed", "5432",
-                               Patterns::Integer(0),
-                               "The seed for the random number generator that controls "
-                               "the particle generation. Keep constant to generate "
-                               "identical particle distributions in subsequent model "
-                               "runs. Change to get a different distribution. In parallel "
-                               "computations the seed is further modified on each process "
-                               "to ensure different particle patterns on different "
-                               "processes. Note that the number of particles per processor "
-                               "is not affected by the seed.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      RandomUniform<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Probability density function");
-          {
-            n_particles = static_cast<types::particle_index>(prm.get_double ("Number of particles"));
-            random_cell_selection = prm.get_bool("Random cell selection");
-            random_number_seed = prm.get_integer("Random number seed");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      ASPECT_REGISTER_PARTICLE_GENERATOR(RandomUniform,
-                                         "random uniform",
-                                         "Generates a random uniform distribution of "
-                                         "particles over the entire simulation domain.")
-    }
-  }
-}
diff --git a/source/particle/generator/reference_cell.cc.bak b/source/particle/generator/reference_cell.cc.bak
deleted file mode 100644
index cc63692f827..00000000000
--- a/source/particle/generator/reference_cell.cc.bak
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/generator/reference_cell.h>
-
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      template <int dim>
-      void
-      ReferenceCell<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
-      {
-        const std::vector<Point<dim>> reference_locations = generate_particle_positions_in_unit_cell();
-
-        Particles::Generators::regular_reference_locations(this->get_triangulation(),
-                                                           reference_locations,
-                                                           particle_handler,
-                                                           this->get_mapping());
-      }
-
-
-      template <int dim>
-      std::vector<Point<dim>>
-      ReferenceCell<dim>::generate_particle_positions_in_unit_cell()
-      {
-        std::vector<Point<dim>> particle_positions;
-        std::array<double, dim> spacing;
-
-        // Calculate separation of particles
-        for (unsigned int i = 0; i < dim; ++i)
-          spacing[i] = 1.0 / number_of_particles[i];
-
-        for (unsigned int i = 0; i < number_of_particles[0]; ++i)
-          {
-            for (unsigned int j = 0; j < number_of_particles[1]; ++j)
-              {
-                if (dim == 2)
-                  {
-                    const Point<dim> position_unit = Point<dim>(i * spacing[0] + spacing[0] / 2,
-                                                                j * spacing[1] + spacing[1] / 2);
-                    particle_positions.push_back(position_unit);
-                  }
-                else if (dim == 3)
-                  {
-                    for (unsigned int k = 0; k < number_of_particles[2]; ++k)
-                      {
-                        const Point<dim> position_unit = Point<dim>(i * spacing[0] + spacing[0] / 2,
-                                                                    j * spacing[1] + spacing[1] / 2,
-                                                                    k * spacing[2] + spacing[2] / 2);
-                        particle_positions.push_back(position_unit);
-                      }
-                  }
-                else
-                  ExcNotImplemented();
-              }
-          }
-
-        return particle_positions;
-      }
-
-
-      template <int dim>
-      void
-      ReferenceCell<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Reference cell");
-          {
-            prm.declare_entry ("Number of particles per cell per direction", "2",
-                               Patterns::List(Patterns::Integer(1)),
-                               "List of number of particles to create per cell and spatial dimension. "
-                               "The size of the list is the number of spatial dimensions. If only "
-                               "one value is given, then each spatial dimension is set to the same value. "
-                               "The list of numbers are parsed as a floating point number (so that one can "
-                               "specify, for example, '1e4' particles) but it is interpreted as "
-                               "an integer, of course.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      ReferenceCell<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Reference cell");
-          {
-            const auto n_particles_per_direction = Utilities::possibly_extend_from_1_to_N (
-                                                     Utilities::string_to_int(
-                                                       Utilities::split_string_list(prm.get("Number of particles per cell per direction"))),
-                                                     dim,
-                                                     "Number of particles per cell per direction");
-
-            for (const auto &n_particle_direction: n_particles_per_direction)
-              number_of_particles.push_back(static_cast<unsigned int> (n_particle_direction));
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      ASPECT_REGISTER_PARTICLE_GENERATOR(ReferenceCell,
-                                         "reference cell",
-                                         "Generates a uniform distribution of particles per cell and spatial direction in "
-                                         "the unit cell and transforms each of the particles back to real region in the model "
-                                         "domain. Uniform here means the particles will be generated with an equal spacing in "
-                                         "each spatial dimension.")
-    }
-  }
-}
diff --git a/source/particle/generator/uniform_box.cc.bak b/source/particle/generator/uniform_box.cc.bak
deleted file mode 100644
index ca452055b7a..00000000000
--- a/source/particle/generator/uniform_box.cc.bak
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/generator/uniform_box.h>
-
-#include <random>
-
-#include <array>
-#include <deal.II/base/exceptions.h>
-
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      template <int dim>
-      void
-      UniformBox<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
-      {
-        const Tensor<1,dim> P_diff = P_max - P_min;
-
-        double volume(1.0);
-        for (unsigned int i = 0; i < dim; ++i)
-          volume *= P_diff[i];
-
-        std::array<unsigned int,dim> n_particles_per_direction;
-        std::array<double,dim> spacing;
-
-        // Calculate separation of particles
-        for (unsigned int i = 0; i < dim; ++i)
-          {
-            n_particles_per_direction[i] = static_cast<unsigned int>(round(std::pow(n_particles * std::pow(P_diff[i],dim) / volume, 1./dim)));
-            spacing[i] = P_diff[i] / fmax(n_particles_per_direction[i] - 1,1);
-          }
-
-        types::particle_index particle_index = 0;
-
-        for (unsigned int i = 0; i < n_particles_per_direction[0]; ++i)
-          {
-            for (unsigned int j = 0; j < n_particles_per_direction[1]; ++j)
-              {
-                if (dim == 2)
-                  {
-                    const Point<dim> particle_position = Point<dim> (P_min[0]+i*spacing[0],P_min[1]+j*spacing[1]);
-                    this->insert_particle_at_position(particle_position, particle_index, particle_handler);
-                    ++particle_index;
-                  }
-                else if (dim == 3)
-                  for (unsigned int k = 0; k < n_particles_per_direction[2]; ++k)
-                    {
-                      const Point<dim> particle_position = Point<dim> (P_min[0]+i*spacing[0],P_min[1]+j*spacing[1],P_min[2]+k*spacing[2]);
-                      this->insert_particle_at_position(particle_position, particle_index, particle_handler);
-                      ++particle_index;
-                    }
-
-              }
-          }
-
-        particle_handler.update_cached_numbers();
-      }
-
-
-      template <int dim>
-      void
-      UniformBox<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Uniform box");
-          {
-            prm.declare_entry ("Number of particles", "1000",
-                               Patterns::Double (0.),
-                               "Total number of particles to create (not per processor or per element). "
-                               "The number is parsed as a floating point number (so that one can "
-                               "specify, for example, '1e4' particles) but it is interpreted as "
-                               "an integer, of course.");
-
-            prm.declare_entry ("Minimum x", "0.",
-                               Patterns::Double (),
-                               "Minimum x coordinate for the region of particles.");
-            prm.declare_entry ("Maximum x", "1.",
-                               Patterns::Double (),
-                               "Maximum x coordinate for the region of particles.");
-            prm.declare_entry ("Minimum y", "0.",
-                               Patterns::Double (),
-                               "Minimum y coordinate for the region of particles.");
-            prm.declare_entry ("Maximum y", "1.",
-                               Patterns::Double (),
-                               "Maximum y coordinate for the region of particles.");
-            prm.declare_entry ("Minimum z", "0.",
-                               Patterns::Double (),
-                               "Minimum z coordinate for the region of particles.");
-            prm.declare_entry ("Maximum z", "1.",
-                               Patterns::Double (),
-                               "Maximum z coordinate for the region of particles.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      UniformBox<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Uniform box");
-          {
-            n_particles    = static_cast<types::particle_index>(prm.get_double ("Number of particles"));
-
-            P_min(0) = prm.get_double ("Minimum x");
-            P_max(0) = prm.get_double ("Maximum x");
-            P_min(1) = prm.get_double ("Minimum y");
-            P_max(1) = prm.get_double ("Maximum y");
-
-            AssertThrow(P_min(0) < P_max(0), ExcMessage("Minimum x must be less than maximum x"));
-            AssertThrow(P_min(1) < P_max(1), ExcMessage("Minimum y must be less than maximum y"));
-
-            if (dim == 3)
-              {
-                P_min(2) = prm.get_double ("Minimum z");
-                P_max(2) = prm.get_double ("Maximum z");
-
-                AssertThrow(P_min(2) < P_max(2), ExcMessage("Minimum z must be less than maximum z"));
-              }
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      ASPECT_REGISTER_PARTICLE_GENERATOR(UniformBox,
-                                         "uniform box",
-                                         "Generate a uniform distribution of particles "
-                                         "over a rectangular domain in 2d or 3d. Uniform here means "
-                                         "the particles will be generated with an equal spacing in "
-                                         "each spatial dimension. Note that in order "
-                                         "to produce a regular distribution the number of generated "
-                                         "particles might not exactly match the one specified in the "
-                                         "input file.")
-    }
-  }
-}
diff --git a/source/particle/generator/uniform_radial.cc.bak b/source/particle/generator/uniform_radial.cc.bak
deleted file mode 100644
index 5604feb5ecb..00000000000
--- a/source/particle/generator/uniform_radial.cc.bak
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/generator/uniform_radial.h>
-
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      template <int dim>
-      void
-      UniformRadial<dim>::generate_particles(Particles::ParticleHandler<dim> &particle_handler)
-      {
-        // Create the array of shell to deal with
-        const double radial_spacing = (P_max[0] - P_min[0]) / fmax(radial_layers-1,1);
-
-        // Calculate number of particles per shell.
-        // The number of particles depend on the fraction of the area
-        // (or length in 2d) that this shell occupies compared to the total domain
-        std::vector<unsigned int> particles_per_layer(radial_layers);
-        if (dim == 2)
-          {
-            double total_radius = 0;
-            for (unsigned int i = 0; i < radial_layers; ++i)
-              total_radius += P_min[0] + (radial_spacing * i);
-            for (unsigned int i = 0; i < radial_layers; ++i)
-              {
-                const double radius = P_min[0] + (radial_spacing * i);
-                particles_per_layer[i] = static_cast<unsigned int>(round(n_particles * radius / total_radius));
-              }
-          }
-        else if (dim == 3)
-          {
-            double total_area = 0;
-            for (unsigned int i = 0; i < radial_layers; ++i)
-              total_area += std::pow(P_min[0] + (radial_spacing * i),2);
-            for (unsigned int i = 0; i < radial_layers; ++i)
-              {
-                const double area = std::pow(P_min[0] + (radial_spacing * i),2);
-                particles_per_layer[i] = static_cast<unsigned int>(round(n_particles * area / total_area));
-              }
-          }
-        else
-          ExcNotImplemented();
-
-        // Generate particles
-
-        types::particle_index particle_index = 0;
-        std::array<double,dim> spherical_coordinates;
-        for (unsigned int i = 0; i < radial_layers; ++i)
-          {
-            spherical_coordinates[0] = P_min[0] + (radial_spacing * i);
-            if (dim == 2)
-              {
-                const double phi_spacing = (P_max[1] - P_min[1]) / fmax(particles_per_layer[i]-1,1);
-
-                for (unsigned int j = 0; j < particles_per_layer[i]; ++j)
-                  {
-                    spherical_coordinates[1] = P_min[1] + j * phi_spacing;
-                    const Point<dim> particle_position = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_coordinates) + P_center;
-                    this->insert_particle_at_position(particle_position, particle_index, particle_handler);
-                    ++particle_index;
-                  }
-              }
-            else if (dim == 3)
-              {
-                const unsigned int theta_particles = static_cast<unsigned int>(
-                                                       round(sqrt(particles_per_layer[i])));
-                const unsigned int phi_particles = static_cast<unsigned int>(
-                                                     round(
-                                                       static_cast<double>(particles_per_layer[i])
-                                                       /
-                                                       static_cast<double>(theta_particles)));
-                const double theta_spacing = (P_max[2] - P_min[2]) / fmax(theta_particles-1,1);
-
-                for (unsigned int j = 0; j < theta_particles; ++j)
-                  {
-                    spherical_coordinates[2] = P_min[2] + j * theta_spacing;
-
-                    // Average value of sin(n) from 0 to 180 degrees is (2/pi)
-                    const unsigned int adjusted_phi_particles = std::max(static_cast<unsigned int> (phi_particles * std::sin(spherical_coordinates[2])), 1u);
-                    const double phi_spacing = (P_max[1] - P_min[1]) / fmax(adjusted_phi_particles-1,1);
-                    for (unsigned int k = 0; k < adjusted_phi_particles; ++k)
-                      {
-                        spherical_coordinates[1] = P_min[1] + k * phi_spacing;
-                        const Point<dim> particle_position = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(spherical_coordinates) + P_center;
-                        this->insert_particle_at_position(particle_position, particle_index, particle_handler);
-                        ++particle_index;
-                      }
-                  }
-              }
-          }
-
-        particle_handler.update_cached_numbers();
-      }
-
-
-      template <int dim>
-      void
-      UniformRadial<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Uniform radial");
-          {
-            prm.declare_entry ("Number of particles", "1000",
-                               Patterns::Double (0.),
-                               "Total number of particles to create (not per processor or per element). "
-                               "The number is parsed as a floating point number (so that one can "
-                               "specify, for example, '1e4' particles) but it is interpreted as "
-                               "an integer, of course.");
-
-            prm.declare_entry ("Center x", "0.",
-                               Patterns::Double (),
-                               "x coordinate for the center of the spherical region, "
-                               "where particles are generated.");
-            prm.declare_entry ("Center y", "0.",
-                               Patterns::Double (),
-                               "y coordinate for the center of the spherical region, "
-                               "where particles are generated.");
-            prm.declare_entry ("Center z", "0.",
-                               Patterns::Double (),
-                               "z coordinate for the center of the spherical region, "
-                               "where particles are generated.");
-            prm.declare_entry ("Minimum radius", "0.",
-                               Patterns::Double (0.),
-                               "Minimum radial coordinate for the region of particles. "
-                               "Measured from the center position.");
-            prm.declare_entry ("Maximum radius", "1.",
-                               Patterns::Double (),
-                               "Maximum radial coordinate for the region of particles. "
-                               "Measured from the center position.");
-            prm.declare_entry ("Minimum longitude", "0.",
-                               Patterns::Double (-180., 360.),
-                               "Minimum longitude coordinate for the region of particles "
-                               "in degrees. Measured from the center position.");
-            prm.declare_entry ("Maximum longitude", "360.",
-                               Patterns::Double (-180., 360.),
-                               "Maximum longitude coordinate for the region of particles "
-                               "in degrees. Measured from the center position.");
-            prm.declare_entry ("Minimum latitude", "0.",
-                               Patterns::Double (0., 180.),
-                               "Minimum latitude coordinate for the region of particles "
-                               "in degrees. Measured from the center position, and from "
-                               "the north pole.");
-            prm.declare_entry ("Maximum latitude", "180.",
-                               Patterns::Double (0., 180.),
-                               "Maximum latitude coordinate for the region of particles "
-                               "in degrees. Measured from the center position, and from "
-                               "the north pole.");
-            prm.declare_entry ("Radial layers", "1",
-                               Patterns::Integer(1),
-                               "The number of radial shells of particles that will be generated "
-                               "around the central point.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      UniformRadial<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Generator");
-        {
-          prm.enter_subsection("Uniform radial");
-          {
-            n_particles    = static_cast<types::particle_index>(prm.get_double ("Number of particles"));
-
-            P_center[0] = prm.get_double ("Center x");
-            P_center[1] = prm.get_double ("Center y");
-
-            P_min[0] = prm.get_double ("Minimum radius");
-            P_max[0] = prm.get_double ("Maximum radius");
-            P_min[1] = prm.get_double ("Minimum longitude") * constants::degree_to_radians;
-            P_max[1] = prm.get_double ("Maximum longitude") * constants::degree_to_radians;
-
-            AssertThrow(P_max[1] > P_min[1],
-                        ExcMessage("The maximum longitude you prescribed in the uniform radial"
-                                   "particle generator has to be higher than the minimum longitude."));
-            AssertThrow(P_max[1] - P_min[1] <= 2.0 * numbers::PI,
-                        ExcMessage("The difference between the maximum and minimum longitude you "
-                                   "prescribed in the uniform radial particle generator has to be "
-                                   "less than 360 degrees."));
-
-            if (dim ==3)
-              {
-                P_center[2] = prm.get_double ("Center z");
-
-                P_min[2]    = prm.get_double ("Minimum latitude") * constants::degree_to_radians;
-                P_max[2]    = prm.get_double ("Maximum latitude") * constants::degree_to_radians;
-
-                AssertThrow(P_max[2] > P_min[2],
-                            ExcMessage("The maximum latitude you prescribed in the uniform radial"
-                                       "particle generator has to be higher than the minimum latitude."));
-              }
-
-            radial_layers   = prm.get_integer("Radial layers");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Generator
-    {
-      ASPECT_REGISTER_PARTICLE_GENERATOR(UniformRadial,
-                                         "uniform radial",
-                                         "Generate a uniform distribution of particles "
-                                         "over a spherical domain in 2d or 3d. Uniform here means "
-                                         "the particles will be generated with an equal spacing in "
-                                         "each spherical spatial dimension, i.e., the particles are "
-                                         "created at positions that increase linearly with equal "
-                                         "spacing in radius, colatitude and longitude around a "
-                                         "certain center point. Note that in order "
-                                         "to produce a regular distribution the number of generated "
-                                         "particles might not exactly match the one specified in the "
-                                         "input file.")
-    }
-  }
-}
diff --git a/source/particle/integrator/euler.cc.bak b/source/particle/integrator/euler.cc.bak
deleted file mode 100644
index 791d7e095df..00000000000
--- a/source/particle/integrator/euler.cc.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/integrator/euler.h>
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      template <int dim>
-      void
-      Euler<dim>::local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                                       const typename ParticleHandler<dim>::particle_iterator &end_particle,
-                                       const std::vector<Tensor<1,dim>> &old_velocities,
-                                       const std::vector<Tensor<1,dim>> &,
-                                       const double dt)
-      {
-        Assert(static_cast<unsigned int> (std::distance(begin_particle, end_particle)) == old_velocities.size(),
-               ExcMessage("The particle integrator expects the velocity vector to be of equal size "
-                          "to the number of particles to advect. For some unknown reason they are different, "
-                          "most likely something went wrong in the calling function."));
-
-        const auto cell = begin_particle->get_surrounding_cell();
-        bool at_periodic_boundary = false;
-        if (this->get_triangulation().get_periodic_face_map().empty() == false)
-          for (const auto face_index: cell->face_indices())
-            if (cell->at_boundary(face_index))
-              if (cell->has_periodic_neighbor(face_index))
-                {
-                  at_periodic_boundary = true;
-                  break;
-                }
-
-        typename std::vector<Tensor<1,dim>>::const_iterator old_velocity = old_velocities.begin();
-
-        for (typename ParticleHandler<dim>::particle_iterator it = begin_particle;
-             it != end_particle; ++it, ++old_velocity)
-          {
-#if DEAL_II_VERSION_GTE(9, 6, 0)
-            // Get a reference to the particle location, so that we can update it in-place
-            Point<dim> &location = it->get_location();
-#else
-            Point<dim> location = it->get_location();
-#endif
-            location += dt * (*old_velocity);
-
-            if (at_periodic_boundary)
-              this->get_geometry_model().adjust_positions_for_periodicity(location);
-
-#if !DEAL_II_VERSION_GTE(9, 6, 0)
-            it->set_location(location);
-#endif
-          }
-      }
-
-
-
-      template <int dim>
-      std::array<bool, 3>
-      Euler<dim>::required_solution_vectors() const
-      {
-        return {{false, true, false}};
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      ASPECT_REGISTER_PARTICLE_INTEGRATOR(Euler,
-                                          "euler",
-                                          "Explicit Euler scheme integrator, where "
-                                          "$y_{n+1} = y_n + \\Delta t \\, v(y_n)$. "
-                                          "This requires only one integration substep per timestep.")
-    }
-  }
-}
diff --git a/source/particle/integrator/interface.cc.bak b/source/particle/integrator/interface.cc.bak
deleted file mode 100644
index 88a8342876f..00000000000
--- a/source/particle/integrator/interface.cc.bak
+++ /dev/null
@@ -1,248 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/integrator/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <tuple>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      template <int dim>
-      bool
-      Interface<dim>::new_integration_step()
-      {
-        return false;
-      }
-
-
-
-      template <int dim>
-      std::size_t
-      Interface<dim>::get_data_size() const
-      {
-        return 0;
-      }
-
-
-
-      template <int dim>
-      const void *
-      Interface<dim>::read_data(const typename ParticleHandler<dim>::particle_iterator &/*particle*/,
-                                const void *data)
-      {
-        return data;
-      }
-
-
-
-      template <int dim>
-      void *
-      Interface<dim>::write_data(const typename ParticleHandler<dim>::particle_iterator &/*particle*/,
-                                 void *data) const
-      {
-        return data;
-      }
-
-
-
-// -------------------------------- Deal with registering models and automating
-// -------------------------------- their setup and selection at run time
-
-      namespace
-      {
-        std::tuple
-        <void *,
-        void *,
-        aspect::internal::Plugins::PluginList<Interface<2>>,
-        aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-      }
-
-
-
-      template <int dim>
-      void
-      register_particle_integrator (const std::string &name,
-                                    const std::string &description,
-                                    void (*declare_parameters_function) (ParameterHandler &),
-                                    std::unique_ptr<Interface<dim>> (*factory_function) ())
-      {
-        std::get<dim>(registered_plugins).register_plugin (name,
-                                                           description,
-                                                           declare_parameters_function,
-                                                           factory_function);
-      }
-
-
-
-      template <int dim>
-      std::unique_ptr<Interface<dim>>
-      create_particle_integrator (ParameterHandler &prm)
-      {
-        std::string name;
-        name = prm.get ("Integration scheme");
-
-        return std::get<dim>(registered_plugins).create_plugin (name,
-                                                                "Particle::Integrator name");
-      }
-
-
-
-      template <int dim>
-      void
-      declare_parameters (ParameterHandler &prm)
-      {
-        // declare the entry in the parameter file
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry ("Integration scheme", "rk2",
-                           Patterns::Selection (pattern_of_names),
-                           "This parameter is used to decide which method to "
-                           "use to solve the equation that describes the position "
-                           "of particles, i.e., $\\frac{d}{dt}\\mathbf x_k(t) = "
-                           "\\mathbf u(\\mathbf x_k(t),t)$, where $k$ is an index "
-                           "that runs over all particles, and $\\mathbf u(\\mathbf x,t)$ "
-                           "is the velocity field that results from the Stokes "
-                           "equations."
-                           "\n\n"
-                           "In practice, the exact velocity $\\mathbf u(\\mathbf x,t)$ "
-                           "is of course not available, but only a numerical "
-                           "approximation $\\mathbf u_h(\\mathbf x,t)$. Furthermore, "
-                           "this approximation is only available at discrete time steps, "
-                           "$\\mathbf u^n(\\mathbf x)=\\mathbf u(\\mathbf x,t^n)$, and "
-                           "these need to be interpolated between time steps if the "
-                           "integrator for the equation above requires an evaluation at "
-                           "time points between the discrete time steps. If we denote this "
-                           "interpolation in time by $\\tilde{\\mathbf u}_h(\\mathbf x,t)$ "
-                           "where $\\tilde{\\mathbf u}_h(\\mathbf x,t^n)="
-                           "\\mathbf u^n(\\mathbf x)$, then the equation the differential "
-                           "equation solver really tries to solve is "
-                           "$\\frac{d}{dt}\\tilde{\\mathbf x}_k(t) = "
-                           " \\tilde{\\mathbf u}_h(\\mathbf x_k(t),t)$."
-                           "\n\n"
-                           "As a consequence of these considerations, if you try to "
-                           "assess convergence properties of an ODE integrator -- for "
-                           "example to verify that the RK4 integrator converges with "
-                           "fourth order --, it is important to recall that the "
-                           "integrator may not solve the equation you think it "
-                           "solves. If, for example, we call the numerical solution "
-                           "of the ODE $\\tilde{\\mathbf x}_{k,h}(t)$, then the "
-                           "error will typically satisfy a relationship like "
-                           "\\["
-                           "  \\| \\tilde{\\mathbf x}_k(T) - \\tilde{\\mathbf x}_{k,h}(T) \\|"
-                           "  \\le"
-                           "  C(T) \\Delta t^p"
-                           "\\] "
-                           "where $\\Delta t$ is the time step and $p$ the convergence order "
-                           "of the method, and $C(T)$ is a (generally unknown) constant "
-                           "that depends on the end time $T$ at which one compares the "
-                           "solutions. On the other hand, an analytically computed "
-                           "trajectory would likely use the \\textit{exact} velocity, "
-                           "and one may be tempted to compute "
-                           "$\\| \\mathbf x_k(T) - \\tilde{\\mathbf x}_{k,h}(T) \\|$, "
-                           "but this quantity will, in the best case, only satisfy an "
-                           "estimate of the form "
-                           "\\["
-                           "  \\| \\mathbf x_k(T) - \\tilde{\\mathbf x}_{k,h}(T) \\|"
-                           "  \\le"
-                           "  C_1(T) \\Delta t^p"
-                           "  + C_2(T) \\| \\mathbf u-\\mathbf u_h \\|"
-                           "  + C_3(T) \\| \\mathbf u_h-\\tilde{\\mathbf u}_h \\|"
-                           "\\] "
-                           "with appropriately chosen norms for the second and third "
-                           "term. These second and third terms typically converge to "
-                           "zero at relatively low rates (compared to the order $p$ of "
-                           "the integrator, which can often be chosen relatively high) "
-                           "in the mesh size $h$ and the time step size $\\\\Delta t$, "
-                           "limiting the overall accuracy of the ODE integrator."
-                           "\n\n"
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-
-        std::get<dim>(registered_plugins).declare_parameters (prm);
-      }
-
-
-
-      template <int dim>
-      void
-      write_plugin_graph (std::ostream &out)
-      {
-        std::get<dim>(registered_plugins).write_plugin_graph ("Particle integrator interface",
-                                                              out);
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<Particle::Integrator::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<Particle::Integrator::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<Particle::Integrator::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<Particle::Integrator::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace Particle
-  {
-    namespace Integrator
-    {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_particle_integrator<dim> (const std::string &, \
-                                     const std::string &, \
-                                     void ( *) (ParameterHandler &), \
-                                     std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_particle_integrator<dim> (ParameterHandler &prm);
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/source/particle/integrator/rk_2.cc.bak b/source/particle/integrator/rk_2.cc.bak
deleted file mode 100644
index eec91bde25c..00000000000
--- a/source/particle/integrator/rk_2.cc.bak
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/integrator/rk_2.h>
-#include <aspect/particle/property/interface.h>
-#include <aspect/particle/world.h>
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      template <int dim>
-      RK2<dim>::RK2()
-        :
-        integrator_substep(0)
-      {}
-
-
-
-      template <int dim>
-      void
-      RK2<dim>::initialize ()
-      {
-        const auto &property_information = this->get_particle_world(this->get_particle_world_index()).get_property_manager().get_data_info();
-        property_index_old_location = property_information.get_position_by_field_name("internal: integrator properties");
-      }
-
-
-
-      template <int dim>
-      void
-      RK2<dim>::local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                                     const typename ParticleHandler<dim>::particle_iterator &end_particle,
-                                     const std::vector<Tensor<1,dim>> &old_velocities,
-                                     const std::vector<Tensor<1,dim>> &velocities,
-                                     const double dt)
-      {
-        Assert(static_cast<unsigned int> (std::distance(begin_particle, end_particle)) == old_velocities.size(),
-               ExcMessage("The particle integrator expects the old velocity vector to be of equal size "
-                          "to the number of particles to advect. For some unknown reason they are different, "
-                          "most likely something went wrong in the calling function."));
-
-        if (higher_order_in_time == true && integrator_substep == 1)
-          Assert(old_velocities.size() == velocities.size(),
-                 ExcMessage("The particle integrator expects the velocity vector to be of equal size "
-                            "to the number of particles to advect. For some unknown reason they are different, "
-                            "most likely something went wrong in the calling function."));
-
-        const auto cell = begin_particle->get_surrounding_cell();
-        bool at_periodic_boundary = false;
-        if (this->get_triangulation().get_periodic_face_map().empty() == false)
-          for (const auto &face_index: cell->face_indices())
-            if (cell->at_boundary(face_index))
-              if (cell->has_periodic_neighbor(face_index))
-                {
-                  at_periodic_boundary = true;
-                  break;
-                }
-
-        typename std::vector<Tensor<1,dim>>::const_iterator old_velocity = old_velocities.begin();
-        typename std::vector<Tensor<1,dim>>::const_iterator velocity = velocities.begin();
-
-        for (typename ParticleHandler<dim>::particle_iterator it = begin_particle;
-             it != end_particle; ++it, ++velocity, ++old_velocity)
-          {
-            ArrayView<double> properties = it->get_properties();
-
-            if (integrator_substep == 0)
-              {
-                const Tensor<1,dim> k1 = dt * (*old_velocity);
-#if DEAL_II_VERSION_GTE(9, 6, 0)
-                // Get a reference to the particle location, so that we can update it in-place
-                Point<dim> &location = it->get_location();
-#else
-                Point<dim> location = it->get_location();
-#endif
-                Point<dim> new_location = location + 0.5 * k1;
-
-                // Check if we crossed a periodic boundary and if necessary adjust positions
-                if (at_periodic_boundary)
-                  this->get_geometry_model().adjust_positions_for_periodicity(new_location,
-                                                                              ArrayView<Point<dim>>(location));
-
-                for (unsigned int i=0; i<dim; ++i)
-                  {
-                    properties[property_index_old_location + i] = location[i];
-#if DEAL_II_VERSION_GTE(9, 6, 0)
-                    location[i] = new_location[i];
-#endif
-                  }
-#if !DEAL_II_VERSION_GTE(9, 6, 0)
-                it->set_location(new_location);
-#endif
-              }
-            else if (integrator_substep == 1)
-              {
-                const Tensor<1,dim> k2 = (higher_order_in_time == true)
-                                         ?
-                                         dt * (*old_velocity + *velocity) * 0.5
-                                         :
-                                         dt * (*old_velocity);
-
-#if DEAL_II_VERSION_GTE(9, 6, 0)
-                Point<dim> &location = it->get_location();
-#else
-                Point<dim> location = it->get_location();
-#endif
-
-                for (unsigned int i=0; i<dim; ++i)
-                  location[i] = properties[property_index_old_location + i] + k2[i];
-
-                // no need to adjust old location, because this is the last integrator step
-                if (at_periodic_boundary)
-                  this->get_geometry_model().adjust_positions_for_periodicity(location);
-
-#if !DEAL_II_VERSION_GTE(9, 6, 0)
-                it->set_location(location);
-#endif
-              }
-            else
-              {
-                Assert(false,
-                       ExcMessage("The RK2 integrator should never continue after two integration steps."));
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      bool
-      RK2<dim>::new_integration_step()
-      {
-        integrator_substep = (integrator_substep + 1) % 2;
-
-        // Continue until we're at the last step
-        return (integrator_substep != 0);
-      }
-
-
-
-      template <int dim>
-      std::array<bool, 3>
-      RK2<dim>::required_solution_vectors() const
-      {
-        switch (integrator_substep)
-          {
-            case 0:
-              return {{false, true, false}};
-            case 1:
-            {
-              if (higher_order_in_time)
-                return {{false, true, true}};
-              else
-                return {{false, true, false}};
-            }
-            default:
-              Assert(false,
-                     ExcMessage("The RK4 integrator should never continue after four integration steps."));
-
-              return {{false, false, false}};
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      RK2<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Integrator");
-        {
-          prm.enter_subsection("RK2");
-          {
-            prm.declare_entry ("Higher order accurate in time", "true",
-                               Patterns::Bool(),
-                               "Whether to correctly evaluate old and current velocity "
-                               "solution to reach higher-order accuracy in time. If set to "
-                               "'false' only the old velocity solution is evaluated to "
-                               "simulate a first order method in time. This is only "
-                               "recommended for benchmark purposes.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      RK2<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Integrator");
-        {
-          prm.enter_subsection("RK2");
-          {
-            higher_order_in_time = prm.get_bool("Higher order accurate in time");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      ASPECT_REGISTER_PARTICLE_INTEGRATOR(RK2,
-                                          "rk2",
-                                          "Second Order Runge Kutta integrator "
-                                          "$y_{n+1} = y_n + \\Delta t\\, v(t_{n+1/2}, y_{n} + \\frac{1}{2} k_1)$ "
-                                          "where $k_1 = \\Delta t\\, v(t_{n}, y_{n})$")
-    }
-  }
-}
diff --git a/source/particle/integrator/rk_4.cc.bak b/source/particle/integrator/rk_4.cc.bak
deleted file mode 100644
index e94b454783f..00000000000
--- a/source/particle/integrator/rk_4.cc.bak
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
-  Copyright (C) 2015 - 2021 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/integrator/rk_4.h>
-#include <aspect/particle/property/interface.h>
-#include <aspect/particle/world.h>
-#include <aspect/geometry_model/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      template <int dim>
-      RK4<dim>::RK4()
-        :
-        integrator_substep(0)
-      {}
-
-
-
-      template <int dim>
-      void
-      RK4<dim>::initialize ()
-      {
-        const auto &property_information = this->get_particle_world(this->get_particle_world_index()).get_property_manager().get_data_info();
-
-        property_indices[0] = property_information.get_position_by_field_name("internal: integrator properties");
-        property_indices[1] = property_indices[0] + dim;
-        property_indices[2] = property_indices[1] + dim;
-        property_indices[3] = property_indices[2] + dim;
-      }
-
-
-
-      template <int dim>
-      void
-      RK4<dim>::local_integrate_step(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                                     const typename ParticleHandler<dim>::particle_iterator &end_particle,
-                                     const std::vector<Tensor<1,dim>> &old_velocities,
-                                     const std::vector<Tensor<1,dim>> &velocities,
-                                     const double dt)
-      {
-        if (integrator_substep < 3)
-          {
-            Assert(static_cast<unsigned int> (std::distance(begin_particle, end_particle)) == old_velocities.size(),
-                   ExcMessage("The particle integrator expects the old velocity vector to be of equal size "
-                              "to the number of particles to advect. For some unknown reason they are different, "
-                              "most likely something went wrong in the calling function."));
-          }
-
-        if (integrator_substep >= 1 && integrator_substep < 4)
-          {
-            Assert(static_cast<unsigned int> (std::distance(begin_particle, end_particle)) == velocities.size(),
-                   ExcMessage("The particle integrator expects the velocity vector to be of equal size "
-                              "to the number of particles to advect. For some unknown reason they are different, "
-                              "most likely something went wrong in the calling function."));
-          }
-
-        const auto cell = begin_particle->get_surrounding_cell();
-        bool at_periodic_boundary = false;
-        if (this->get_triangulation().get_periodic_face_map().empty() == false)
-          for (const auto &face_index: cell->face_indices())
-            if (cell->at_boundary(face_index))
-              if (cell->has_periodic_neighbor(face_index))
-                {
-                  at_periodic_boundary = true;
-                  break;
-                }
-
-        typename std::vector<Tensor<1,dim>>::const_iterator old_velocity = old_velocities.begin();
-        typename std::vector<Tensor<1,dim>>::const_iterator velocity = velocities.begin();
-
-        std::array<Tensor<1,dim>,4> k;
-        for (typename ParticleHandler<dim>::particle_iterator it = begin_particle;
-             it != end_particle; ++it, ++velocity, ++old_velocity)
-          {
-            ArrayView<double> properties = it->get_properties();
-
-            if (integrator_substep == 0)
-              {
-#if DEAL_II_VERSION_GTE(9, 6, 0)
-                // Get a reference to the particle location, so that we can update it in-place
-                Point<dim> &location = it->get_location();
-#else
-                Point<dim> location = it->get_location();
-#endif
-                k[0] = dt * (*old_velocity);
-
-                Point<dim> new_location = location + 0.5 * k[0];
-
-                // Check if we crossed a periodic boundary and if necessary adjust positions
-                if (at_periodic_boundary)
-                  this->get_geometry_model().adjust_positions_for_periodicity(new_location,
-                                                                              ArrayView<Point<dim>>(&location,1),
-                                                                              ArrayView<Tensor<1,dim>>(&k[0],1));
-
-                for (unsigned int i=0; i<dim; ++i)
-                  {
-                    properties[property_indices[0] + i] = location[i];
-                    properties[property_indices[1] + i] = k[0][i];
-#if DEAL_II_VERSION_GTE(9, 6, 0)
-                    location[i] = new_location[i];
-#endif
-                  }
-
-#if !DEAL_II_VERSION_GTE(9, 6, 0)
-                it->set_location(new_location);
-#endif
-              }
-            else if (integrator_substep == 1)
-              {
-                k[1] = dt * ((*old_velocity) + (*velocity)) * 0.5;
-
-                Point<dim> old_location;
-                for (unsigned int i=0; i<dim; ++i)
-                  old_location[i] = properties[property_indices[0] + i];
-
-                Point<dim> new_location = old_location + 0.5 * k[1];
-
-                if (at_periodic_boundary)
-                  {
-                    for (unsigned int i=0; i<dim; ++i)
-                      k[0][i] = properties[property_indices[1] + i];
-
-                    this->get_geometry_model().adjust_positions_for_periodicity(new_location,
-                                                                                ArrayView<Point<dim>>(&old_location,1),
-                                                                                ArrayView<Tensor<1,dim>>(&k[0],2));
-
-                    for (unsigned int i=0; i<dim; ++i)
-                      {
-                        properties[property_indices[0] + i] = old_location[i];
-                        properties[property_indices[1] + i] = k[0][i];
-                        // k[1] will always be set below
-                      }
-                  }
-
-                for (unsigned int i=0; i<dim; ++i)
-                  properties[property_indices[2] + i] = k[1][i];
-
-                it->set_location(new_location);
-              }
-            else if (integrator_substep == 2)
-              {
-                k[2] = dt * (*old_velocity + *velocity) * 0.5;
-
-                Point<dim> old_location;
-                for (unsigned int i=0; i<dim; ++i)
-                  old_location[i] = properties[property_indices[0] + i];
-
-                Point<dim> new_location = old_location + k[2];
-
-                if (at_periodic_boundary)
-                  {
-                    for (unsigned int i=0; i<dim; ++i)
-                      {
-                        k[0][i] = properties[property_indices[1] + i];
-                        k[1][i] = properties[property_indices[2] + i];
-                      }
-
-                    this->get_geometry_model().adjust_positions_for_periodicity(new_location,
-                                                                                ArrayView<Point<dim>>(&old_location,1),
-                                                                                ArrayView<Tensor<1,dim>>(&k[0],3));
-
-                    for (unsigned int i=0; i<dim; ++i)
-                      {
-                        properties[property_indices[0] + i] = old_location[i];
-                        properties[property_indices[1] + i] = k[0][i];
-                        properties[property_indices[2] + i] = k[1][i];
-                      }
-                  }
-
-                for (unsigned int i=0; i<dim; ++i)
-                  properties[property_indices[3] + i] = k[2][i];
-
-                it->set_location(new_location);
-              }
-            else if (integrator_substep == 3)
-              {
-                k[3] = dt * (*velocity);
-
-                Point<dim> old_location;
-                for (unsigned int i=0; i<dim; ++i)
-                  old_location[i] = properties[property_indices[0] + i];
-
-                for (unsigned int i=0; i<dim; ++i)
-                  {
-                    k[0][i] = properties[property_indices[1] + i];
-                    k[1][i] = properties[property_indices[2] + i];
-                    k[2][i] = properties[property_indices[3] + i];
-                  }
-
-                Point<dim> new_location = old_location + (k[0] + 2.0*k[1] + 2.0*k[2] + k[3])/6.0;
-
-                // No need to fix intermediate values, this is the last integrator step
-                if (at_periodic_boundary)
-                  this->get_geometry_model().adjust_positions_for_periodicity(new_location);
-
-                it->set_location(new_location);
-              }
-            else
-              {
-                Assert(false,
-                       ExcMessage("The RK4 integrator should never continue after four integration stages."));
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      bool
-      RK4<dim>::new_integration_step()
-      {
-        integrator_substep = (integrator_substep+1)%4;
-
-        // Continue until we're at the last step
-        return (integrator_substep != 0);
-      }
-
-
-      template <int dim>
-      std::array<bool, 3>
-      RK4<dim>::required_solution_vectors() const
-      {
-        switch (integrator_substep)
-          {
-            case 0:
-              return {{false, true, false}};
-            case 1:
-              return {{false, true, true}};
-            case 2:
-              return {{false, true, true}};
-            case 3:
-              return {{false, false, true}};
-            default:
-              Assert(false,
-                     ExcMessage("The RK4 integrator should never continue after four integration steps."));
-          }
-
-        return {{false, false, false}};
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Integrator
-    {
-      ASPECT_REGISTER_PARTICLE_INTEGRATOR(RK4,
-                                          "rk4",
-                                          "Runge Kutta fourth order integrator, where "
-                                          "$y_{n+1} = y_n + \\frac{1}{6} k_1 + \\frac{1}{3} k_2 "
-                                          "+ \\frac{1}{3} k_3 + \\frac{1}{6} k_4$ "
-                                          "and $k_1$, $k_2$, $k_3$, $k_4$ are defined as usual.")
-    }
-  }
-}
diff --git a/source/particle/interface.cc.bak b/source/particle/interface.cc.bak
deleted file mode 100644
index 659e348739c..00000000000
--- a/source/particle/interface.cc.bak
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/interface.h>
-
-
-namespace aspect
-{
-  namespace Particle
-  {
-    void
-    ParticleInterfaceBase::set_particle_world_index(const unsigned int particle_world_index)
-    {
-      this->particle_world_index = particle_world_index;
-    }
-
-
-
-    unsigned int
-    ParticleInterfaceBase::get_particle_world_index() const
-    {
-      return particle_world_index;
-    }
-  }
-}
diff --git a/source/particle/interpolator/bilinear_least_squares.cc.bak b/source/particle/interpolator/bilinear_least_squares.cc.bak
deleted file mode 100644
index da2fc320bce..00000000000
--- a/source/particle/interpolator/bilinear_least_squares.cc.bak
+++ /dev/null
@@ -1,364 +0,0 @@
-/*
-  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/interpolator/bilinear_least_squares.h>
-#include <aspect/particle/world.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/grid/grid_tools.h>
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/lac/qr.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      template <int dim>
-      std::vector<std::vector<double>>
-      BilinearLeastSquares<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
-                                                      const std::vector<Point<dim>> &positions,
-                                                      const ComponentMask &selected_properties,
-                                                      const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
-      {
-        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
-        const unsigned int property_index = selected_properties.first_selected_component(selected_properties.size());
-
-        AssertThrow(property_index != numbers::invalid_unsigned_int,
-                    ExcMessage("Internal error: the particle property interpolator was "
-                               "called without a specified component to interpolate."));
-
-        const typename ParticleHandler<dim>::particle_iterator_range particle_range =
-          particle_handler.particles_in_cell(cell);
-
-        std::vector<std::vector<double>> cell_properties(positions.size(),
-                                                          std::vector<double>(n_particle_properties,
-                                                                              numbers::signaling_nan<double>()));
-
-        const unsigned int n_particles = std::distance(particle_range.begin(), particle_range.end());
-        const unsigned int n_matrix_columns = (dim == 2) ? 3 : 4;
-
-        // If there are too few particles, we can not perform a least squares interpolation
-        // fall back to a simpler method instead.
-        if (n_particles < n_matrix_columns)
-          return fallback_interpolator.properties_at_points(particle_handler,
-                                                            positions,
-                                                            selected_properties,
-                                                            cell);
-
-        // Noticed that the size of matrix A is n_particles x n_matrix_columns
-        // which usually is not a square matrix. Therefore, we find the
-        // least squares solution of Ac=r by solving the reduced QR factorization
-        // Ac = QRc = b -> Q^TQRc = Rc =Q^Tb
-        // A is a std::vector of Vectors(which are it's columns) so that we
-        // create what the ImplicitQR class needs.
-        std::vector<Vector<double>> A(n_matrix_columns, Vector<double>(n_particles));
-        std::vector<Vector<double>> b(n_particle_properties, Vector<double>(n_particles));
-
-        unsigned int particle_index = 0;
-        // The unit cell of deal.II is [0,1]^dim. The limiter needs a 'unit' cell of [-.5,.5]^dim.
-        const double unit_offset = 0.5;
-        std::vector<double> property_minimums(n_particle_properties, std::numeric_limits<double>::max());
-        std::vector<double> property_maximums(n_particle_properties, std::numeric_limits<double>::lowest());
-        for (typename ParticleHandler<dim>::particle_iterator particle = particle_range.begin();
-             particle != particle_range.end(); ++particle, ++particle_index)
-          {
-            const ArrayView<double> particle_property_value = particle->get_properties();
-            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-              {
-                if (selected_properties[property_index] == true)
-                  {
-                    b[property_index][particle_index] = particle_property_value[property_index];
-                    if (use_linear_least_squares_limiter[property_index] == true)
-                      {
-                        property_minimums[property_index] = std::min(property_minimums[property_index], particle_property_value[property_index]);
-                        property_maximums[property_index] = std::max(property_maximums[property_index], particle_property_value[property_index]);
-                      }
-                  }
-              }
-            Point<dim> relative_particle_position = particle->get_reference_location();
-
-            // A is accessed by A[column][row] here since we will need to append
-            // columns into the qr matrix
-            A[0][particle_index] = 1;
-            for (unsigned int i = 1; i < n_matrix_columns; ++i)
-              {
-                relative_particle_position[i - 1] -= unit_offset;
-                A[i][particle_index] = relative_particle_position[i - 1];
-              }
-          }
-
-        // If the limiter is enabled for at least one property then we know that we can access ghost cell
-        // particles to determine the bounds of the properties on the mode (due to the assert of
-        // 'Exchange ghost particles' in parse_parameters). Otherwise we do not need to access those particles
-        if (use_linear_least_squares_limiter.n_selected_components() != 0)
-          {
-            std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> active_neighbors;
-            GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell, active_neighbors);
-            for (const auto &active_neighbor : active_neighbors)
-              {
-                if (active_neighbor->is_artificial())
-                  continue;
-                const std::vector<double> neighbor_cell_average = fallback_interpolator.properties_at_points(particle_handler, positions, selected_properties, active_neighbor)[0];
-                for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-                  {
-                    if (selected_properties[property_index] == true && use_linear_least_squares_limiter[property_index] == true)
-                      {
-                        property_minimums[property_index] = std::min(property_minimums[property_index], neighbor_cell_average[property_index]);
-                        property_maximums[property_index] = std::max(property_maximums[property_index], neighbor_cell_average[property_index]);
-                      }
-                  }
-              }
-            if (cell->at_boundary())
-              {
-                const std::vector<double> cell_average_values = fallback_interpolator.properties_at_points(particle_handler, {positions[0]}, selected_properties, cell)[0];
-                for (unsigned int face_id = 0; face_id < cell->reference_cell().n_faces(); ++face_id)
-                  {
-                    if (cell->at_boundary(face_id))
-                      {
-                        const unsigned int opposing_face_id = GeometryInfo<dim>::opposite_face[face_id];
-                        const auto &opposing_cell = cell->neighbor(opposing_face_id);
-                        if (opposing_cell.state() == IteratorState::IteratorStates::valid && opposing_cell->is_active() && opposing_cell->is_artificial() == false)
-                          {
-                            const auto neighbor_cell_average = fallback_interpolator.properties_at_points(particle_handler, {positions[0]}, selected_properties, opposing_cell)[0];
-                            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-                              {
-                                if (selected_properties[property_index] == true && use_boundary_extrapolation[property_index] == true)
-                                  {
-                                    Assert(cell->reference_cell().is_hyper_cube() == true, ExcNotImplemented());
-                                    const double expected_boundary_value = 1.5 * cell_average_values[property_index] - 0.5 * neighbor_cell_average[property_index];
-                                    property_minimums[property_index] = std::min(property_minimums[property_index], expected_boundary_value);
-                                    property_maximums[property_index] = std::max(property_maximums[property_index], expected_boundary_value);
-                                  }
-                              }
-                          }
-                      }
-                  }
-              }
-          }
-
-        ImplicitQR<Vector<double>> qr;
-        for (const auto &column : A)
-          qr.append_column(column);
-        // If A is rank deficent then qr.append_column will not append
-        // the first column that can be written as a linear combination of
-        // other columns. We check that all columns were added or we
-        // rely on the fallback interpolator
-        if (qr.size() != n_matrix_columns)
-          return fallback_interpolator.properties_at_points(particle_handler,
-                                                            positions,
-                                                            selected_properties,
-                                                            cell);
-
-        std::vector<Vector<double>> QTb(n_particle_properties, Vector<double>(n_matrix_columns));
-        std::vector<Vector<double>> c(n_particle_properties, Vector<double>(n_matrix_columns));
-        for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-          {
-            if (selected_properties[property_index] == true)
-              {
-                qr.multiply_with_QT(QTb[property_index], b[property_index]);
-                qr.solve(c[property_index], QTb[property_index]);
-              }
-          }
-        const double half_h = .5;
-        for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-          {
-            if (selected_properties[property_index] == true)
-              {
-                if (use_linear_least_squares_limiter[property_index] == true)
-                  {
-                    c[property_index][0] = std::max(c[property_index][0], property_minimums[property_index]);
-                    c[property_index][0] = std::min(c[property_index][0], property_maximums[property_index]);
-
-                    const double max_total_slope = std::min(c[property_index][0] - property_minimums[property_index],
-                                                            property_maximums[property_index] - c[property_index][0])
-                                                   / half_h;
-                    double current_total_slope = 0.0;
-                    for (unsigned int i = 1; i < n_matrix_columns; ++i)
-                      {
-                        current_total_slope += std::abs(c[property_index][i]);
-                      }
-
-                    if (current_total_slope > max_total_slope && current_total_slope > std::numeric_limits<double>::min())
-                      {
-                        double slope_change_ratio = max_total_slope/current_total_slope;
-                        for (unsigned int i = 1; i < n_matrix_columns; ++i)
-                          c[property_index][i] *= slope_change_ratio;
-                      }
-                  }
-                std::size_t positions_index = 0;
-                for (typename std::vector<Point<dim>>::const_iterator itr = positions.begin(); itr != positions.end(); ++itr, ++positions_index)
-                  {
-                    Point<dim> relative_support_point_location = this->get_mapping().transform_real_to_unit_cell(cell, *itr);
-                    double interpolated_value = c[property_index][0];
-                    for (unsigned int i = 1; i < n_matrix_columns; ++i)
-                      {
-                        relative_support_point_location[i - 1] -= unit_offset;
-                        interpolated_value += c[property_index][i] * relative_support_point_location[i - 1];
-                      }
-                    if (use_linear_least_squares_limiter[property_index] == true)
-                      {
-                        // Assert that the limiter was reasonably effective. We can not expect perfect accuracy
-                        // due to inaccuracies e.g. in the inversion of the mapping.
-                        const double tolerance = std::sqrt(std::numeric_limits<double>::epsilon())
-                                                 * std::max(std::abs(property_minimums[property_index]),
-                                                            std::abs(property_maximums[property_index]));
-                        (void) tolerance;
-                        Assert(interpolated_value >= property_minimums[property_index] - tolerance,
-                               ExcMessage("The particle interpolation limiter did not succeed. Interpolated value: " + std::to_string(interpolated_value)
-                                          + " is smaller than the minimum particle property value: " + std::to_string(property_minimums[property_index]) + "."));
-                        Assert(interpolated_value <= property_maximums[property_index] + tolerance,
-                               ExcMessage("The particle interpolation limiter did not succeed. Interpolated value: " + std::to_string(interpolated_value)
-                                          + " is larger than the maximum particle property value: " + std::to_string(property_maximums[property_index]) + "."));
-
-                        interpolated_value = std::min(interpolated_value, property_maximums[property_index]);
-                        interpolated_value = std::max(interpolated_value, property_minimums[property_index]);
-                      }
-                    cell_properties[positions_index][property_index] = interpolated_value;
-                  }
-
-              }
-          }
-        return cell_properties;
-      }
-
-
-
-      template <int dim>
-      void
-      BilinearLeastSquares<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Interpolator");
-        {
-          prm.enter_subsection("Bilinear least squares");
-          {
-            prm.declare_entry("Use linear least squares limiter", "false",
-                              Patterns::List(Patterns::Bool()),
-                              "Limit the interpolation of particle properties onto the cell, so that "
-                              "the value of each property is no smaller than its minimum and no "
-                              "larger than its maximum on the particles of each cell, and the "
-                              "average of neighboring cells. If more than one value is given, "
-                              "it will be treated as a list with one component per particle property.");
-            prm.declare_entry("Use boundary extrapolation", "false",
-                              Patterns::List(Patterns::Bool()),
-                              "Extends the range used by 'Use linear least squares limiter' "
-                              "by linearly interpolating values at cell boundaries from neighboring "
-                              "cells. If more than one value is given, it will be treated as a list "
-                              "with one component per particle property. Enabling 'Use boundary "
-                              "extrapolation' requires enabling 'Use linear least squares "
-                              "limiter'.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      BilinearLeastSquares<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        fallback_interpolator.parse_parameters(prm);
-        prm.enter_subsection("Interpolator");
-        {
-          prm.enter_subsection("Bilinear least squares");
-          {
-            const auto &particle_property_information = this->get_particle_world(this->get_particle_world_index()).get_property_manager().get_data_info();
-            const unsigned int n_property_components = particle_property_information.n_components();
-            const unsigned int n_internal_components = particle_property_information.get_components_by_field_name("internal: integrator properties");
-
-            std::vector<std::string> linear_least_squares_limiter_split = Utilities::split_string_list(prm.get("Use linear least squares limiter"));
-            std::vector<bool> linear_least_squares_limiter_parsed;
-            if (linear_least_squares_limiter_split.size() == 1)
-              {
-                linear_least_squares_limiter_parsed = std::vector<bool>(n_property_components - n_internal_components, Utilities::string_to_bool(linear_least_squares_limiter_split[0]));
-              }
-            else if (linear_least_squares_limiter_split.size() == n_property_components - n_internal_components)
-              {
-                for (const auto &component: linear_least_squares_limiter_split)
-                  linear_least_squares_limiter_parsed.push_back(Utilities::string_to_bool(component));
-              }
-            else
-              {
-                AssertThrow(false, ExcMessage("The size of 'Use linear least squares limiter' should either be 1 or the number of particle properties"));
-              }
-            for (unsigned int i = 0; i < n_internal_components; ++i)
-              linear_least_squares_limiter_parsed.push_back(false);
-            use_linear_least_squares_limiter = ComponentMask(linear_least_squares_limiter_parsed);
-
-
-
-            const std::vector<std::string> boundary_extrapolation_split = Utilities::split_string_list(prm.get("Use boundary extrapolation"));
-            std::vector<bool> boundary_extrapolation_parsed;
-            if (boundary_extrapolation_split.size() == 1)
-              {
-                boundary_extrapolation_parsed = std::vector<bool>(n_property_components - n_internal_components, Utilities::string_to_bool(boundary_extrapolation_split[0]));
-              }
-            else if (boundary_extrapolation_split.size() == n_property_components - n_internal_components)
-              {
-                for (const auto &component: boundary_extrapolation_split)
-                  boundary_extrapolation_parsed.push_back(Utilities::string_to_bool(component));
-              }
-            else
-              {
-                AssertThrow(false, ExcMessage("The size of 'Use boundary extrapolation' should either be 1 or the number of particle properties"));
-              }
-            for (unsigned int i = 0; i < n_internal_components; ++i)
-              boundary_extrapolation_parsed.push_back(false);
-            use_boundary_extrapolation = ComponentMask(boundary_extrapolation_parsed);
-            for (unsigned int property_index = 0; property_index < n_property_components - n_internal_components; ++property_index)
-              {
-                AssertThrow(use_linear_least_squares_limiter[property_index] || !use_boundary_extrapolation[property_index],
-                            ExcMessage("'Use boundary extrapolation' must be set with 'Use linear least squares limiter' to be valid."));
-              }
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-        const bool limiter_enabled_for_at_least_one_property = (use_linear_least_squares_limiter.n_selected_components() != 0);
-        AssertThrow(limiter_enabled_for_at_least_one_property == false || prm.get_bool("Update ghost particles") == true,
-                    ExcMessage("If 'Use linear least squares limiter' is enabled for any particle property, then 'Update ghost particles' must be set to true"));
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(BilinearLeastSquares,
-                                            "bilinear least squares",
-                                            "Uses linear least squares to obtain the slopes and center of a 2d or "
-                                            "3d plane from the particle positions and a particular property value "
-                                            "on those particles. "
-                                            "Interpolate this property onto a vector of points. If the limiter is "
-                                            "enabled then it will ensure the interpolated properties do not exceed the "
-                                            "range of the minimum and maximum of the values of the property on the "
-                                            "particles. Note that deal.II must be configured with BLAS and LAPACK to "
-                                            "support this operation.")
-    }
-  }
-}
diff --git a/source/particle/interpolator/cell_average.cc.bak b/source/particle/interpolator/cell_average.cc.bak
deleted file mode 100644
index 1a7f4ddfc35..00000000000
--- a/source/particle/interpolator/cell_average.cc.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/interpolator/cell_average.h>
-
-#include <deal.II/grid/grid_tools.h>
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      template <int dim>
-      std::vector<std::vector<double>>
-      CellAverage<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
-                                             const std::vector<Point<dim>> &positions,
-                                             const ComponentMask &selected_properties,
-                                             const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
-      {
-        const typename ParticleHandler<dim>::particle_iterator_range particle_range =
-          particle_handler.particles_in_cell(cell);
-
-        const unsigned int n_particles = std::distance(particle_range.begin(),particle_range.end());
-        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
-
-        std::vector<double> cell_properties (n_particle_properties,numbers::signaling_nan<double>());
-
-        for (unsigned int i = 0; i < n_particle_properties; ++i)
-          if (selected_properties[i])
-            cell_properties[i] = 0.0;
-
-        if (n_particles > 0)
-          {
-            for (const auto &particle : particle_range)
-              {
-                const ArrayView<const double> &particle_properties = particle.get_properties();
-
-                for (unsigned int i = 0; i < particle_properties.size(); ++i)
-                  if (selected_properties[i])
-                    cell_properties[i] += particle_properties[i];
-              }
-
-            for (unsigned int i = 0; i < n_particle_properties; ++i)
-              if (selected_properties[i])
-                cell_properties[i] /= n_particles;
-          }
-        // If there are no particles in this cell use the average of the
-        // neighboring cells.
-        else
-          {
-            std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> neighbors;
-            GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell,neighbors);
-
-            unsigned int non_empty_neighbors = 0;
-            for (unsigned int i=0; i<neighbors.size(); ++i)
-              {
-                // Only recursively evaluate with cells whose particles can be accessed safely.
-                if (!neighbors[i]->is_locally_owned())
-                  continue;
-                // Only recursively call this function if the neighbor cell contains
-                // particles (else we end up in an endless recursion)
-                if (particle_handler.n_particles_in_cell(neighbors[i]) == 0)
-                  continue;
-
-                const std::vector<double> neighbor_properties = properties_at_points(particle_handler,
-                                                                                     std::vector<Point<dim>> (1,neighbors[i]->center(true,false)),
-                                                                                     selected_properties,
-                                                                                     neighbors[i])[0];
-
-                for (unsigned int i = 0; i < n_particle_properties; ++i)
-                  if (selected_properties[i])
-                    cell_properties[i] += neighbor_properties[i];
-
-                ++non_empty_neighbors;
-              }
-
-            if (!allow_cells_without_particles)
-              {
-                AssertThrow(non_empty_neighbors != 0,
-                            ExcMessage("A cell and all of its neighbors do not contain any particles. "
-                                       "The `cell average' interpolation scheme does not support this case unless specified "
-                                       "in Allow cells without particles."));
-              }
-
-            for (unsigned int i = 0; i < n_particle_properties; ++i)
-              {
-                if (selected_properties[i] && non_empty_neighbors != 0)
-                  cell_properties[i] /= non_empty_neighbors;
-                // Assume property is zero for any areas with no particles
-                else if (allow_cells_without_particles && non_empty_neighbors == 0)
-                  cell_properties[i] = 0;
-              }
-
-          }
-
-        return std::vector<std::vector<double>> (positions.size(),cell_properties);
-      }
-
-
-
-      template <int dim>
-      void
-      CellAverage<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Allow cells without particles", "false",
-                           Patterns::Bool (),
-                           "By default, every cell needs to contain particles to use this interpolator "
-                           "plugin. If this parameter is set to true, cells are allowed to have no particles, "
-                           "In case both the current cell and its neighbors are empty, "
-                           "the interpolator will return 0 for the current cell's properties.");
-      }
-
-
-
-      template <int dim>
-      void
-      CellAverage<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        allow_cells_without_particles = prm.get_bool("Allow cells without particles");
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(CellAverage,
-                                            "cell average",
-                                            "Return the arithmetic average of all particle properties in the given cell, "
-                                            "or in the neighboring cells if the given cell is empty. "
-                                            "In case the neighboring cells are also empty, and 'Allow cells "
-                                            "without particles' is set to true, the interpolator returns 0. "
-                                            "Otherwise, an exception is thrown. ")
-    }
-  }
-}
diff --git a/source/particle/interpolator/harmonic_average.cc.bak b/source/particle/interpolator/harmonic_average.cc.bak
deleted file mode 100644
index 6ae071041e3..00000000000
--- a/source/particle/interpolator/harmonic_average.cc.bak
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/interpolator/harmonic_average.h>
-
-#include <deal.II/grid/grid_tools.h>
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      template <int dim>
-      std::vector<std::vector<double>>
-      HarmonicAverage<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
-                                                 const std::vector<Point<dim>> &positions,
-                                                 const ComponentMask &selected_properties,
-                                                 const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
-      {
-        const typename ParticleHandler<dim>::particle_iterator_range particle_range =
-          particle_handler.particles_in_cell(cell);
-
-        const unsigned int n_particles = std::distance(particle_range.begin(),particle_range.end());
-        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
-
-        std::vector<double> cell_properties (n_particle_properties,numbers::signaling_nan<double>());
-
-        for (unsigned int i = 0; i < n_particle_properties; ++i)
-          if (selected_properties[i])
-            cell_properties[i] = 0.0;
-
-        if (n_particles > 0)
-          {
-            for (const auto &particle : particle_range)
-              {
-                const ArrayView<const double> &particle_properties = particle.get_properties();
-
-                for (unsigned int i = 0; i < particle_properties.size(); ++i)
-                  if (selected_properties[i])
-                    {
-                      AssertThrow(particle_properties[i] > 0,
-                                  ExcMessage ("All particle property values must be greater than 0 for harmonic averaging!"));
-                      cell_properties[i] += 1/particle_properties[i];
-                    }
-              }
-
-            for (unsigned int i = 0; i < n_particle_properties; ++i)
-              if (selected_properties[i])
-                {
-                  cell_properties[i] = n_particles/cell_properties[i];
-                }
-          }
-        // If there are no particles in this cell use the average of the
-        // neighboring cells.
-        else
-          {
-            std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> neighbors;
-            GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell,neighbors);
-
-            unsigned int non_empty_neighbors = 0;
-            for (unsigned int i=0; i<neighbors.size(); ++i)
-              {
-                // Only recursively call this function if the neighbor cell contains
-                // particles (else we end up in an endless recursion)
-                if (particle_handler.n_particles_in_cell(neighbors[i]) == 0)
-                  continue;
-
-                const std::vector<double> neighbor_properties = properties_at_points(particle_handler,
-                                                                                     std::vector<Point<dim>> (1,neighbors[i]->center(true,false)),
-                                                                                     selected_properties,
-                                                                                     neighbors[i])[0];
-
-                for (unsigned int i = 0; i < n_particle_properties; ++i)
-                  if (selected_properties[i])
-                    {
-                      AssertThrow(neighbor_properties[i] > 0,
-                                  ExcMessage ("All particle property values must be greater than 0 for harmonic averaging!"));
-                      cell_properties[i] += 1/neighbor_properties[i];
-                    }
-
-                ++non_empty_neighbors;
-              }
-
-            if (!allow_cells_without_particles)
-              {
-                AssertThrow(non_empty_neighbors != 0,
-                            ExcMessage("A cell and all of its neighbors do not contain any particles. "
-                                       "The `harmonic average' interpolation scheme does not support this case unless specified "
-                                       "in Allow cells without particles."));
-              }
-
-            for (unsigned int i = 0; i < n_particle_properties; ++i)
-              {
-                if (selected_properties[i] && non_empty_neighbors !=0)
-                  cell_properties[i] = non_empty_neighbors/cell_properties[i];
-                // Assume property is zero for any areas with no particles
-                else if (allow_cells_without_particles && non_empty_neighbors == 0)
-                  cell_properties[i] = 0;
-              }
-
-          }
-
-        return std::vector<std::vector<double>> (positions.size(),cell_properties);
-      }
-
-
-
-      template <int dim>
-      void
-      HarmonicAverage<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Allow cells without particles", "false",
-                           Patterns::Bool (),
-                           "By default, every cell needs to contain particles to use this interpolator "
-                           "plugin. If this parameter is set to true, cells are allowed to have no particles. "
-                           "In case both the current cell and its neighbors are empty, "
-                           "the interpolator will return 0 for the current cell's properties.");
-      }
-
-
-
-      template <int dim>
-      void
-      HarmonicAverage<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        allow_cells_without_particles = prm.get_bool("Allow cells without particles");
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(HarmonicAverage,
-                                            "harmonic average",
-                                            "Return the harmonic average of all particle properties in the "
-                                            "given cell. If the cell contains no particles, return the "
-                                            "harmonic average of the properties in the neighboring cells. "
-                                            "In case the neighboring cells are also empty, and 'Allow cells "
-                                            "without particles' is set to true, the interpolator returns 0. "
-                                            "Otherwise, an exception is thrown. ")
-    }
-  }
-}
diff --git a/source/particle/interpolator/interface.cc.bak b/source/particle/interpolator/interface.cc.bak
deleted file mode 100644
index 83a50104dec..00000000000
--- a/source/particle/interpolator/interface.cc.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/interpolator/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-// -------------------------------- Deal with registering models and automating
-// -------------------------------- their setup and selection at run time
-
-      namespace
-      {
-        std::tuple
-        <void *,
-        void *,
-        aspect::internal::Plugins::PluginList<Interface<2>>,
-        aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-      }
-
-
-
-      template <int dim>
-      void
-      register_particle_interpolator (const std::string &name,
-                                      const std::string &description,
-                                      void (*declare_parameters_function) (ParameterHandler &),
-                                      std::unique_ptr<Interface<dim>> (*factory_function) ())
-      {
-        std::get<dim>(registered_plugins).register_plugin (name,
-                                                           description,
-                                                           declare_parameters_function,
-                                                           factory_function);
-      }
-
-
-
-      template <int dim>
-      std::unique_ptr<Interface<dim>>
-      create_particle_interpolator (ParameterHandler &prm)
-      {
-        std::string name;
-        name = prm.get ("Interpolation scheme");
-
-        return std::get<dim>(registered_plugins).create_plugin (name,
-                                                                "Particle::Interpolator name");
-      }
-
-
-
-      template <int dim>
-      void
-      declare_parameters (ParameterHandler &prm)
-      {
-        // declare the entry in the parameter file
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry ("Interpolation scheme", "cell average",
-                           Patterns::Selection (pattern_of_names),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-
-        std::get<dim>(registered_plugins).declare_parameters (prm);
-      }
-
-
-
-      template <int dim>
-      void
-      write_plugin_graph (std::ostream &out)
-      {
-        std::get<dim>(registered_plugins).write_plugin_graph ("Particle interpolator interface",
-                                                              out);
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<Particle::Interpolator::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<Particle::Interpolator::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<Particle::Interpolator::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<Particle::Interpolator::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_particle_interpolator<dim> (const std::string &, \
-                                       const std::string &, \
-                                       void ( *) (ParameterHandler &), \
-                                       std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_particle_interpolator<dim> (ParameterHandler &prm);
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/source/particle/interpolator/nearest_neighbor.cc.bak b/source/particle/interpolator/nearest_neighbor.cc.bak
deleted file mode 100644
index 9903cb18a4d..00000000000
--- a/source/particle/interpolator/nearest_neighbor.cc.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/interpolator/nearest_neighbor.h>
-
-#include <deal.II/grid/grid_tools.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      template <int dim>
-      std::vector<std::vector<double>>
-      NearestNeighbor<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
-                                                 const std::vector<Point<dim>> &positions,
-                                                 const ComponentMask &selected_properties,
-                                                 const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
-      {
-        const typename ParticleHandler<dim>::particle_iterator_range particle_range = particle_handler.particles_in_cell(cell);
-
-        const unsigned int n_particles = std::distance(particle_range.begin(),particle_range.end());
-        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
-
-        std::vector<double> temp(n_particle_properties, 0.0);
-        std::vector<std::vector<double>> point_properties(positions.size(), temp);
-
-        for (unsigned int pos_idx=0; pos_idx < positions.size(); ++pos_idx)
-          {
-            double minimum_distance = std::numeric_limits<double>::max();
-            if (n_particles > 0)
-              {
-                typename ParticleHandler<dim>::particle_iterator nearest_neighbor;
-                for (typename ParticleHandler<dim>::particle_iterator particle = particle_range.begin();
-                     particle != particle_range.end(); ++particle)
-                  {
-                    const double dist = (positions[pos_idx] - particle->get_location()).norm_square();
-                    if (dist < minimum_distance)
-                      {
-                        minimum_distance = dist;
-                        nearest_neighbor = particle;
-                      }
-                  }
-                const dealii::ArrayView<const double> neighbor_props = nearest_neighbor->get_properties();
-                for (unsigned int i = 0; i < n_particle_properties; ++i)
-                  if (selected_properties[i])
-                    point_properties[pos_idx][i] = neighbor_props[i];
-              }
-            else
-              {
-                std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> neighbors;
-                GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell,neighbors);
-
-                unsigned int nearest_neighbor_cell = numbers::invalid_unsigned_int;
-                for (unsigned int i=0; i<neighbors.size(); ++i)
-                  {
-                    // Only recursively call this function if the neighbor cell contains
-                    // particles (else we end up in an endless recursion)
-                    if (particle_handler.n_particles_in_cell(neighbors[i]) == 0)
-                      continue;
-
-                    const double dist = (positions[pos_idx] - neighbors[i]->center()).norm_square();
-                    if (dist < minimum_distance)
-                      {
-                        minimum_distance = dist;
-                        nearest_neighbor_cell = i;
-                      }
-                  }
-
-                if (!allow_cells_without_particles)
-                  {
-                    AssertThrow(nearest_neighbor_cell != numbers::invalid_unsigned_int,
-                                ExcMessage("A cell and all of its neighbors do not contain any particles. "
-                                           "The `nearest neighbor' interpolation scheme does not support this case unless specified "
-                                           "in Allow cells without particles."));
-                  }
-
-                if (nearest_neighbor_cell != numbers::invalid_unsigned_int)
-                  {
-                    point_properties[pos_idx] = properties_at_points(particle_handler,
-                                                                     std::vector<Point<dim>> (1,positions[pos_idx]),
-                                                                     selected_properties,
-                                                                     neighbors[nearest_neighbor_cell])[0];
-                  }
-                else if (allow_cells_without_particles && nearest_neighbor_cell == numbers::invalid_unsigned_int)
-                  {
-                    for (unsigned int i = 0; i < n_particle_properties; ++i)
-                      if (selected_properties[i])
-                        point_properties[pos_idx][i] = 0;
-                  }
-
-              }
-
-          }
-
-        return point_properties;
-      }
-
-
-
-      template <int dim>
-      void
-      NearestNeighbor<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.declare_entry ("Allow cells without particles", "false",
-                           Patterns::Bool (),
-                           "By default, every cell needs to contain particles to use this interpolator "
-                           "plugin. If this parameter is set to true, cells are allowed to have no particles. "
-                           "In case both the current cell and its neighbors are empty, "
-                           "the interpolator will return 0 for the current cell's properties.");
-      }
-
-
-
-      template <int dim>
-      void
-      NearestNeighbor<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        allow_cells_without_particles = prm.get_bool("Allow cells without particles");
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(NearestNeighbor,
-                                            "nearest neighbor",
-                                            "Return the properties of the nearest neighboring particle "
-                                            "in the current cell, or nearest particle in nearest neighboring "
-                                            "cell if current cell is empty. "
-                                            "In case the neighboring cells are also empty, and 'Allow cells "
-                                            "without particles' is set to true, the interpolator returns 0. "
-                                            "Otherwise, an exception is thrown. ")
-    }
-  }
-}
diff --git a/source/particle/interpolator/quadratic_least_squares.cc.bak b/source/particle/interpolator/quadratic_least_squares.cc.bak
deleted file mode 100644
index 4dfdfe715f6..00000000000
--- a/source/particle/interpolator/quadratic_least_squares.cc.bak
+++ /dev/null
@@ -1,640 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/interpolator/quadratic_least_squares.h>
-#include <aspect/particle/world.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/grid/grid_tools.h>
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/lac/qr.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      template <int dim>
-      double QuadraticLeastSquares<dim>::evaluate_interpolation_function(const Vector<double> &coefficients, const Point<dim> &position) const
-      {
-        if (dim == 2)
-          {
-            return coefficients[0] +
-                   coefficients[1] * position[0] +
-                   coefficients[2] * position[1] +
-                   coefficients[3] * position[0] * position[1] +
-                   coefficients[4] * position[0] * position[0] +
-                   coefficients[5] * position[1] * position[1];
-          }
-        else
-          {
-            return coefficients[0] +
-                   coefficients[1] * position[0] +
-                   coefficients[2] * position[1] +
-                   coefficients[3] * position[2] +
-                   coefficients[4] * position[0] * position[1] +
-                   coefficients[5] * position[0] * position[2] +
-                   coefficients[6] * position[1] * position[2] +
-                   coefficients[7] * position[0] * position[0] +
-                   coefficients[8] * position[1] * position[1] +
-                   coefficients[9] * position[2] * position[2];
-          }
-      }
-
-
-      template <int dim>
-      std::pair<double, double> QuadraticLeastSquares<dim>::get_interpolation_bounds(const Vector<double> &coefficients) const
-      {
-        double interpolation_min = std::numeric_limits<double>::max();
-        double interpolation_max = std::numeric_limits<double>::lowest();
-        for (const auto &critical_point : get_critical_points(coefficients))
-          {
-            bool critical_point_in_cell = true;
-            for (unsigned int d = 0; d < dim; ++d)
-              {
-                if (critical_point[d] < -0.5 || critical_point[d] > 0.5)
-                  critical_point_in_cell = false;
-              }
-            if (critical_point_in_cell)
-              {
-                const double value_at_critical_point = evaluate_interpolation_function(coefficients, critical_point);
-                interpolation_min = std::min(interpolation_min, value_at_critical_point);
-                interpolation_max = std::max(interpolation_max, value_at_critical_point);
-              }
-          }
-        return {interpolation_min, interpolation_max};
-      }
-
-
-      template <int dim>
-      std::vector<Point<dim>> QuadraticLeastSquares<dim>::get_critical_points(const Vector<double> &coefficients) const
-      {
-        std::vector<Point<dim>> critical_points;
-        const double epsilon = 10. * coefficients.linfty_norm() * std::numeric_limits<double>::epsilon();
-        if (dim == 2)
-          {
-            // reserve the maximum number of critical points
-            // in 2d: one inside, 4 edges, and 4 corners
-            critical_points.reserve(1 + 4 + 4);
-            // If finding the critical point of the function (or along a cell edge) would
-            // require division by 0, or the solve of a singular matrix, then there is not
-            // a unique critical point. There cannot be two critical points to this function,
-            // so there must be infinitely many points with the same value, so it should be
-            // caught by one of the other checks of the value of the interpolation
-
-            // compute the location of the global critical point
-            Tensor<2, dim, double> critical_point_A;
-            critical_point_A[0][0] = 2 * coefficients[4];
-            critical_point_A[0][1] = coefficients[3];
-            critical_point_A[1][0] = coefficients[3];
-            critical_point_A[1][1] = 2 * coefficients[5];
-            Tensor<1, dim, double> critical_point_b;
-            critical_point_b[0] = -coefficients[1];
-            critical_point_b[1] = -coefficients[2];
-            if (std::abs(determinant(critical_point_A)) > epsilon)
-              {
-                critical_points.emplace_back(invert(critical_point_A) * critical_point_b);
-              }
-
-            // Compute the critical value for each of the edges. This is necessary even if we found the
-            // critical point inside the unit cell, because the value at the edges can be a minimum, while
-            // the critical point inside the cell is a maximum, or vice-versa. Additionally the critical
-            // point could be a saddle point, in which case we would still need to find a minimum and maximum over the cell.
-            if (std::abs(coefficients[5]) > epsilon)
-              {
-                critical_points.emplace_back(-0.5, -(2 * coefficients[2] - coefficients[3])/(4 * coefficients[5]));
-                critical_points.emplace_back( 0.5, -(2 * coefficients[2] + coefficients[3])/(4 * coefficients[5]));
-              }
-            if (std::abs(coefficients[4]) > epsilon)
-              {
-                critical_points.emplace_back(-(2 * coefficients[1] - coefficients[3])/(4 * coefficients[4]), -0.5);
-                critical_points.emplace_back(-(2 * coefficients[1] + coefficients[3])/(4 * coefficients[4]),  0.5);
-              }
-
-            // Compute the critical value for each of the corners. This is necessary even if critical points
-            // have already been found in previous steps, as the global critical point could be a minimum,
-            // and the edge critical points could also be minimums.
-            for (double x = -0.5; x <= 0.5; ++x)
-              {
-                for (double y = -0.5; y <= 0.5; ++y)
-                  {
-                    critical_points.emplace_back(x,y);
-                  }
-              }
-          }
-        else if (dim == 3)
-          {
-            // reserve the maximum number of critical points
-            // in 3d: one inside, 6 faces, 12 edges, and 8 corners
-            critical_points.reserve(1 + 6 + 12 + 8);
-            // If finding the critical point of the function (or along a cell edge) would
-            // require division by 0, or the solve of a singular matrix, then there is not
-            // a unique critical point. There cannot be two critical points to this function,
-            // so there must be infinitely many points with the same value, so it should be
-            // caught by one of the other checks of the value of the interpolation
-
-            // Compute the location of the global critical point
-            {
-              Tensor<2, dim, double> critical_point_A;
-              critical_point_A[0][0] = 2 * coefficients[7];
-              critical_point_A[0][1] = coefficients[4];
-              critical_point_A[0][2] = coefficients[5];
-              critical_point_A[1][0] = coefficients[4];
-              critical_point_A[1][1] = 2 * coefficients[8];
-              critical_point_A[1][2] = coefficients[6];
-              critical_point_A[2][0] = coefficients[5];
-              critical_point_A[2][1] = coefficients[6];
-              critical_point_A[2][2] = 2 * coefficients[9];
-              Tensor<1, dim, double> critical_point_b;
-              critical_point_b[0] = -coefficients[1];
-              critical_point_b[1] = -coefficients[2];
-              critical_point_b[2] = -coefficients[3];
-              if (std::abs(determinant(critical_point_A)) > epsilon)
-                {
-                  critical_points.emplace_back(invert(critical_point_A) * critical_point_b);
-                }
-            }
-
-            // Compute the location of critical points along the faces of the cell.
-            // This is is necessary even if we found a global critical point as it
-            // could be a minimum and the faces could have a maximum or vice-versa.
-            Tensor<2, 2, double> critical_point_A;
-            Tensor<1, 2, double> critical_point_b;
-            Tensor<1, 2, double> critical_point_X;
-            // The columns of this critical_point_A correspond to Y and Z.
-            critical_point_A[0][0] = 2 * coefficients[8];
-            critical_point_A[0][1] = coefficients[6];
-            critical_point_A[1][0] = coefficients[6];
-            critical_point_A[1][1] = 2 * coefficients[9];
-            if (std::abs(determinant(critical_point_A)) > epsilon)
-              {
-                const Tensor<2, 2, double> critical_point_A_inv = invert(critical_point_A);
-                double x = -0.5;
-                critical_point_b[0] = -(coefficients[2] + coefficients[4] * x);
-                critical_point_b[1] = -(coefficients[3] + coefficients[5] * x);
-                critical_point_X = critical_point_A_inv * critical_point_b;
-                critical_points.emplace_back(x, critical_point_X[0], critical_point_X[1]);
-                x = 0.5;
-                critical_point_b[0] = -(coefficients[2] + coefficients[4] * x);
-                critical_point_b[1] = -(coefficients[3] + coefficients[5] * x);
-                critical_point_X = critical_point_A_inv * critical_point_b;
-                critical_points.emplace_back(x, critical_point_X[0], critical_point_X[1]);
-              }
-            // The columns of this critical_point_A correspond to X and Z.
-            critical_point_A[0][0] = 2 * coefficients[7];
-            critical_point_A[0][1] = coefficients[5];
-            critical_point_A[1][0] = coefficients[5];
-            critical_point_A[1][1] = 2 * coefficients[9];
-            if (std::abs(determinant(critical_point_A)) > epsilon)
-              {
-                const Tensor<2, 2, double> critical_point_A_inv = invert(critical_point_A);
-                double y = -0.5;
-                critical_point_b[0] = -(coefficients[1] + coefficients[4] * y);
-                critical_point_b[1] = -(coefficients[3] + coefficients[6] * y);
-                critical_point_X = critical_point_A_inv * critical_point_b;
-                critical_points.emplace_back(critical_point_X[0], y, critical_point_X[1]);
-                y = 0.5;
-                critical_point_b[0] = -(coefficients[1] + coefficients[4] * y);
-                critical_point_b[1] = -(coefficients[3] + coefficients[6] * y);
-                critical_point_X = critical_point_A_inv * critical_point_b;
-                critical_points.emplace_back(critical_point_X[0], y, critical_point_X[1]);
-              }
-            // The columns of this critical_point_A correspond to X and Y.
-            critical_point_A[0][0] = 2 * coefficients[7];
-            critical_point_A[0][1] = coefficients[4];
-            critical_point_A[1][0] = coefficients[4];
-            critical_point_A[1][1] = 2 * coefficients[8];
-            if (std::abs(determinant(critical_point_A)) > epsilon)
-              {
-                const Tensor<2, 2, double> critical_point_A_inv = invert(critical_point_A);
-                double z = -0.5;
-                critical_point_b[0] = -(coefficients[1] + coefficients[5] * z);
-                critical_point_b[1] = -(coefficients[2] + coefficients[6] * z);
-                critical_point_X = critical_point_A_inv * critical_point_b;
-                critical_points.emplace_back(critical_point_X[0], critical_point_X[1], z);
-                z = 0.5;
-                critical_point_b[0] = -(coefficients[1] + coefficients[5] * z);
-                critical_point_b[1] = -(coefficients[2] + coefficients[6] * z);
-                critical_point_X = critical_point_A_inv * critical_point_b;
-                critical_points.emplace_back(critical_point_X[0], critical_point_X[1], z);
-              }
-
-            // Compute the location of critical points along the edges.
-            // This is necessary even if critical points have been found in previous
-            // steps, as the global critial point and critical points on faces could
-            // all be minimums.
-            if (std::abs(coefficients[9]) > epsilon)
-              {
-                for (double x = -0.5; x <= 0.5; ++x)
-                  {
-                    for (double y = -0.5; y <= 0.5; ++y)
-                      {
-                        critical_points.emplace_back(x,y, -(coefficients[3] + coefficients[5] * x + coefficients[6] * y)/(2 * coefficients[9]));
-                      }
-                  }
-              }
-            if (std::abs(coefficients[8]) > epsilon)
-              {
-                for (double x = -0.5; x <= 0.5; ++x)
-                  {
-                    for (double z = -0.5; z <= 0.5; ++z)
-                      {
-                        critical_points.emplace_back(x, -(coefficients[2] + coefficients[4] * x + coefficients[6] * z) / (2 * coefficients[8]), z);
-                      }
-                  }
-              }
-            if (std::abs(coefficients[7]) > epsilon)
-              {
-                for (double y = -0.5; y <= 0.5; ++y)
-                  {
-                    for (double z = -0.5; z <= 0.5; ++z)
-                      {
-                        critical_points.emplace_back(-(coefficients[1] + coefficients[4] * y + coefficients[5] * z)/(2*coefficients[7]), y, z);
-                      }
-                  }
-              }
-
-            // Compute the location of critical points along the corners
-            // This is necessary even if critical points have been found in previous
-            // steps, as the previously found critical points could all be minimums
-            // and the corners could hold the maximum value over the cell.
-            for (double x = -0.5; x <= 0.5; ++x)
-              {
-                for (double y = -0.5; y <= 0.5; ++y)
-                  {
-                    for (double z = -0.5; z <= 0.5; ++z)
-                      {
-                        critical_points.emplace_back(x, y, z);
-                      }
-                  }
-              }
-          }
-        return critical_points;
-      }
-
-      template <int dim>
-      std::vector<std::vector<double>>
-      QuadraticLeastSquares<dim>::properties_at_points(const ParticleHandler<dim> &particle_handler,
-                                                       const std::vector<Point<dim>> &positions,
-                                                       const ComponentMask &selected_properties,
-                                                       const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
-      {
-        const unsigned int n_particle_properties = particle_handler.n_properties_per_particle();
-
-        const unsigned int property_index = selected_properties.first_selected_component(selected_properties.size());
-
-        AssertThrow(property_index != numbers::invalid_unsigned_int,
-                    ExcMessage("Internal error: the particle property interpolator was "
-                               "called without a specified component to interpolate."));
-
-        const typename ParticleHandler<dim>::particle_iterator_range particle_range =
-          particle_handler.particles_in_cell(cell);
-
-        std::vector<std::vector<double>> cell_properties(positions.size(),
-                                                          std::vector<double>(n_particle_properties,
-                                                                              numbers::signaling_nan<double>()));
-
-        const unsigned int n_particles = std::distance(particle_range.begin(), particle_range.end());
-
-        const unsigned int n_matrix_columns = (dim == 2) ? 6 : 10;
-        if (n_particles < n_matrix_columns)
-          return fallback_interpolator.properties_at_points(particle_handler,
-                                                            positions,
-                                                            selected_properties,
-                                                            cell);
-        const std::vector<double> cell_average_values = fallback_interpolator.properties_at_points(particle_handler,
-        {positions[0]},
-        selected_properties,
-        cell)[0];
-
-
-        // Notice that the size of matrix A is n_particles x n_matrix_columns
-        // which usually is not a square matrix. Therefore, we find the
-        // least squares solution of Ac=r by solving the reduced QR factorization
-        // Ac = QRc = b -> Q^TQRc = Rc =Q^Tb
-        // A is a std::vector of Vectors(which are it's columns) so that we
-        // create what the ImplicitQR class needs.
-        std::vector<Vector<double>> A(n_matrix_columns, Vector<double>(n_particles));
-        std::vector<Vector<double>> b(n_particle_properties, Vector<double>(n_particles));
-
-        unsigned int particle_index = 0;
-        // The unit cell of deal.II is [0, 1]^dim. The limiter needs a 'unit' cell of [-0.5, 0.5]^dim
-        const double unit_offset = 0.5;
-        std::vector<double> property_minimums(n_particle_properties, std::numeric_limits<double>::max());
-        std::vector<double> property_maximums(n_particle_properties, std::numeric_limits<double>::lowest());
-        for (typename ParticleHandler<dim>::particle_iterator particle = particle_range.begin();
-             particle != particle_range.end(); ++particle, ++particle_index)
-          {
-            const ArrayView<double> particle_property_value = particle->get_properties();
-            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-              {
-                if (selected_properties[property_index] == true)
-                  {
-                    b[property_index][particle_index] = particle_property_value[property_index];
-                    property_minimums[property_index] = std::min(property_minimums[property_index], particle_property_value[property_index]);
-                    property_maximums[property_index] = std::max(property_maximums[property_index], particle_property_value[property_index]);
-                  }
-              }
-
-            Point<dim> relative_particle_position = particle->get_reference_location();
-            for (unsigned int d = 0; d < dim; ++d)
-              relative_particle_position[d] -= unit_offset;
-            // A is accessed by A[column][row] here since we need to append
-            // columns into the qr matrix.
-
-            // There is a potential that in the future we may change to
-            // interpolate to $Q_2$ instead of the current $P_2$. This would
-            // involve adding more terms to the interpolation for some problems.
-            // We for now leave those terms out of the interpolation because they
-            // would require more particles per cell and we are not yet aware of
-            // a benchmark where those terms have affected the convegence.
-            A[0][particle_index] = 1;
-            A[1][particle_index] = relative_particle_position[0];
-            A[2][particle_index] = relative_particle_position[1];
-            if (dim == 2)
-              {
-                A[3][particle_index] = relative_particle_position[0] * relative_particle_position[1];
-                A[4][particle_index] = relative_particle_position[0] * relative_particle_position[0];
-                A[5][particle_index] = relative_particle_position[1] * relative_particle_position[1];
-              }
-            else
-              {
-                A[3][particle_index] = relative_particle_position[2];
-                A[4][particle_index] = relative_particle_position[0] * relative_particle_position[1];
-                A[5][particle_index] = relative_particle_position[0] * relative_particle_position[2];
-                A[6][particle_index] = relative_particle_position[1] * relative_particle_position[2];
-                A[7][particle_index] = relative_particle_position[0] * relative_particle_position[0];
-                A[8][particle_index] = relative_particle_position[1] * relative_particle_position[1];
-                A[9][particle_index] = relative_particle_position[2] * relative_particle_position[2];
-              }
-          }
-
-        // If the limiter is enabled for at least one property then we know that we can access ghost cell
-        // particles to determine the bounds of the properties on the model (due to the assert of
-        // 'Exchange ghost particles' in parse_parameters). Otherwise we do not need to access those particles
-        if (use_quadratic_least_squares_limiter.n_selected_components(n_particle_properties) != 0)
-          {
-            std::vector<typename parallel::distributed::Triangulation<dim>::active_cell_iterator> active_neighbors;
-            GridTools::get_active_neighbors<parallel::distributed::Triangulation<dim>>(cell, active_neighbors);
-            for (const auto &active_neighbor : active_neighbors)
-              {
-                if (active_neighbor->is_artificial())
-                  continue;
-                const std::vector<double> neighbor_cell_average = fallback_interpolator.properties_at_points(particle_handler, positions, selected_properties, active_neighbor)[0];
-                for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-                  {
-                    if (selected_properties[property_index] == true && use_quadratic_least_squares_limiter[property_index] == true)
-                      {
-                        property_minimums[property_index] = std::min(property_minimums[property_index], neighbor_cell_average[property_index]);
-                        property_maximums[property_index] = std::max(property_maximums[property_index], neighbor_cell_average[property_index]);
-                      }
-                  }
-
-              }
-            if (cell->at_boundary())
-              {
-                for (unsigned int face_id = 0; face_id < cell->reference_cell().n_faces(); ++face_id)
-                  {
-                    if (cell->at_boundary(face_id))
-                      {
-                        const unsigned int opposing_face_id = GeometryInfo<dim>::opposite_face[face_id];
-                        const auto &opposing_cell = cell->neighbor(opposing_face_id);
-                        if (opposing_cell.state() == IteratorState::IteratorStates::valid && opposing_cell->is_active() && !opposing_cell->is_artificial())
-                          {
-
-                            const auto neighbor_cell_average = fallback_interpolator.properties_at_points(particle_handler, {positions[0]}, selected_properties, opposing_cell)[0];
-                            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-                              {
-                                if (selected_properties[property_index] == true && use_boundary_extrapolation[property_index] == true)
-                                  {
-                                    Assert(cell->reference_cell().is_hyper_cube() == true, ExcNotImplemented());
-                                    const double expected_boundary_value = 1.5 * cell_average_values[property_index] - 0.5 * neighbor_cell_average[property_index];
-                                    property_minimums[property_index] = std::min(property_minimums[property_index], expected_boundary_value);
-                                    property_maximums[property_index] = std::max(property_maximums[property_index], expected_boundary_value);
-                                  }
-                              }
-                          }
-                      }
-                  }
-              }
-          }
-        ImplicitQR<Vector<double>> qr;
-        for (const auto &column : A)
-          qr.append_column(column);
-        // If A is rank deficent then qr.append_column will not append
-        // the first column that can be written as a linear combination of
-        // other columns. We check that all columns were added or we
-        // rely on the fallback interpolator
-        if (qr.size() != n_matrix_columns)
-          return fallback_interpolator.properties_at_points(particle_handler,
-                                                            positions,
-                                                            selected_properties,
-                                                            cell);
-        std::vector<Vector<double>> QTb(n_particle_properties, Vector<double>(n_matrix_columns));
-        std::vector<Vector<double>> c(n_particle_properties, Vector<double>(n_matrix_columns));
-        for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-          {
-            if (selected_properties[property_index])
-              {
-                qr.multiply_with_QT(QTb[property_index], b[property_index]);
-                qr.solve(c[property_index], QTb[property_index]);
-                if (use_quadratic_least_squares_limiter[property_index])
-                  {
-
-                    const std::pair<double, double> interpolation_bounds = get_interpolation_bounds(c[property_index]);
-                    const double interpolation_min = interpolation_bounds.first;
-                    const double interpolation_max = interpolation_bounds.second;
-                    if ((interpolation_max - cell_average_values[property_index]) > std::numeric_limits<double>::epsilon() &&
-                        (cell_average_values[property_index] - interpolation_min) > std::numeric_limits<double>::epsilon())
-                      {
-                        const double alpha = std::max(std::min((cell_average_values[property_index] - property_minimums[property_index])/(cell_average_values[property_index] - interpolation_min),
-                                                               (property_maximums[property_index]-cell_average_values[property_index])/(interpolation_max - cell_average_values[property_index])), 0.0);
-                        // If alpha > 1, then using it would make the function grow to meet the bounds.
-                        if (alpha < 1.0)
-                          {
-                            c[property_index] *= alpha;
-                            c[property_index][0] += (1-alpha) * cell_average_values[property_index];
-                          }
-                      }
-                  }
-              }
-          }
-        unsigned int index_positions = 0;
-        for (typename std::vector<Point<dim>>::const_iterator itr = positions.begin(); itr != positions.end(); ++itr, ++index_positions)
-          {
-            Point<dim> relative_support_point_location = this->get_mapping().transform_real_to_unit_cell(cell, *itr);
-            for (unsigned int d = 0; d < dim; ++d)
-              relative_support_point_location[d] -= unit_offset;
-            for (unsigned int property_index = 0; property_index < n_particle_properties; ++property_index)
-              {
-                if (selected_properties[property_index] == true)
-                  {
-                    double interpolated_value = evaluate_interpolation_function(c[property_index], relative_support_point_location);
-                    // Overshoot and undershoot correction of interpolated particle property.
-                    if (use_quadratic_least_squares_limiter[property_index])
-                      {
-                        // Assert that the limiter was reasonably effective. We can not expect perfect accuracy
-                        // due to inaccuracies e.g. in the inversion of the mapping.
-                        const double tolerance = std::sqrt(std::numeric_limits<double>::epsilon())
-                                                 * std::max(std::abs(property_minimums[property_index]),
-                                                            std::abs(property_maximums[property_index]));
-                        (void) tolerance;
-                        Assert(interpolated_value >= property_minimums[property_index] - tolerance,
-                               ExcMessage("The particle interpolation limiter did not succeed. Interpolated value: " + std::to_string(interpolated_value)
-                                          + " is smaller than the minimum particle property value: " + std::to_string(property_minimums[property_index]) + "."));
-                        Assert(interpolated_value <= property_maximums[property_index] + tolerance,
-                               ExcMessage("The particle interpolation limiter did not succeed. Interpolated value: " + std::to_string(interpolated_value)
-                                          + " is larger than the maximum particle property value: " + std::to_string(property_maximums[property_index]) + "."));
-
-                        // This chopping is done to avoid values that are just outside
-                        // of the limiting bounds.
-                        interpolated_value = std::min(interpolated_value, property_maximums[property_index]);
-                        interpolated_value = std::max(interpolated_value, property_minimums[property_index]);
-                      }
-                    cell_properties[index_positions][property_index] = interpolated_value;
-                  }
-
-              }
-          }
-        return cell_properties;
-      }
-
-
-
-      template <int dim>
-      void
-      QuadraticLeastSquares<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Interpolator");
-        {
-          prm.enter_subsection("Quadratic least squares");
-          {
-            prm.declare_entry("Use quadratic least squares limiter", "true",
-                              Patterns::List(Patterns::Bool()),
-                              "Limit the interpolation of particle properties onto the cell, so that "
-                              "the value of each property is no smaller than its minimum and no "
-                              "larger than its maximum on the particles of each cell, and the "
-                              "average of neighboring cells. If more than one value is given, "
-                              "it will be treated as a list with one component per particle property.");
-            prm.declare_entry("Use boundary extrapolation", "false",
-                              Patterns::List(Patterns::Bool()),
-                              "Extends the range used by 'Use quadratic least squares limiter' "
-                              "by linearly interpolating values at cell boundaries from neighboring "
-                              "cells. If more than one value is given, it will be treated as a list "
-                              "with one component per particle property. Enabling 'Use boundary "
-                              "extrapolation' requires enabling 'Use quadratic least squares "
-                              "limiter'.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-      template <int dim>
-      void
-      QuadraticLeastSquares<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        fallback_interpolator.parse_parameters(prm);
-
-        prm.enter_subsection("Interpolator");
-        {
-          prm.enter_subsection("Quadratic least squares");
-          {
-            const auto &particle_property_information = this->get_particle_world(this->get_particle_world_index()).get_property_manager().get_data_info();
-            const unsigned int n_property_components = particle_property_information.n_components();
-            const unsigned int n_internal_components = particle_property_information.get_components_by_field_name("internal: integrator properties");
-
-            const std::vector<std::string> quadratic_least_squares_limiter_split = Utilities::split_string_list(prm.get("Use quadratic least squares limiter"));
-            std::vector<bool> quadratic_least_squares_limiter_parsed;
-            if (quadratic_least_squares_limiter_split.size() == 1)
-              {
-                quadratic_least_squares_limiter_parsed = std::vector<bool>(n_property_components - n_internal_components, Utilities::string_to_bool(quadratic_least_squares_limiter_split[0]));
-              }
-            else if (quadratic_least_squares_limiter_split.size() == n_property_components - n_internal_components)
-              {
-                for (const auto &component: quadratic_least_squares_limiter_split)
-                  quadratic_least_squares_limiter_parsed.push_back(Utilities::string_to_bool(component));
-              }
-            else
-              {
-                AssertThrow(false, ExcMessage("The size of 'Use quadratic least squares limiter' should either be 1 or the number of particle properties"));
-              }
-            for (unsigned int i = 0; i < n_internal_components; ++i)
-              quadratic_least_squares_limiter_parsed.push_back(false);
-            use_quadratic_least_squares_limiter = ComponentMask(quadratic_least_squares_limiter_parsed);
-
-
-            const std::vector<std::string> boundary_extrapolation_split = Utilities::split_string_list(prm.get("Use boundary extrapolation"));
-            std::vector<bool> boundary_extrapolation_parsed;
-            if (boundary_extrapolation_split.size() == 1)
-              {
-                boundary_extrapolation_parsed = std::vector<bool>(n_property_components - n_internal_components, Utilities::string_to_bool(boundary_extrapolation_split[0]));
-              }
-            else if (boundary_extrapolation_split.size() == n_property_components - n_internal_components)
-              {
-                for (const auto &component: boundary_extrapolation_split)
-                  boundary_extrapolation_parsed.push_back(Utilities::string_to_bool(component));
-              }
-            else
-              {
-                AssertThrow(false, ExcMessage("The size of 'Use boundary extrapolation' should either be 1 or the number of particle properties"));
-              }
-            for (unsigned int i = 0; i < n_internal_components; ++i)
-              boundary_extrapolation_parsed.push_back(false);
-            use_boundary_extrapolation = ComponentMask(boundary_extrapolation_parsed);
-            for (unsigned int property_index = 0; property_index < n_property_components - n_internal_components; ++property_index)
-              {
-                AssertThrow(use_quadratic_least_squares_limiter[property_index] || !use_boundary_extrapolation[property_index],
-                            ExcMessage("'Use boundary extrapolation' must be set with 'Use quadratic least squares limiter' to be valid."));
-              }
-
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-
-        // In general n_selected_components() requests an argument of the ComponentMask's size since it could be initialized to be entirely true without a size.
-        // Here it is given a size equal to n_property_components, so that argument is not necessary.
-        const bool limiter_enabled_for_at_least_one_property = (use_quadratic_least_squares_limiter.n_selected_components() != 0);
-        AssertThrow(limiter_enabled_for_at_least_one_property == false || prm.get_bool("Update ghost particles") == true,
-                    ExcMessage("If 'Use quadratic least squares limiter' is enabled for any particle property, then 'Update ghost particles' must be set to true"));
-
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Interpolator
-    {
-      ASPECT_REGISTER_PARTICLE_INTERPOLATOR(QuadraticLeastSquares,
-                                            "quadratic least squares",
-                                            "Interpolates particle properties onto a vector of points using a "
-                                            "quadratic least squares method. Note that deal.II must be configured "
-                                            "with BLAS/LAPACK.")
-    }
-  }
-}
diff --git a/source/particle/property/composition.cc.bak b/source/particle/property/composition.cc.bak
deleted file mode 100644
index 8584d0f65ad..00000000000
--- a/source/particle/property/composition.cc.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/particle/property/composition.h>
-#include <aspect/initial_composition/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      Composition<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                         std::vector<double> &data) const
-      {
-        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
-          data.push_back(this->get_initial_composition_manager().initial_composition(position,i));
-      }
-
-      template <int dim>
-      void
-      Composition<dim>::update_particle_property(const unsigned int data_position,
-                                                 const Vector<double> &solution,
-                                                 const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                                 typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
-          {
-            const unsigned int solution_component = this->introspection().component_indices.compositional_fields[i];
-            particle->get_properties()[data_position+i] = solution[solution_component];
-          }
-      }
-
-      template <int dim>
-      UpdateTimeFlags
-      Composition<dim>::need_update() const
-      {
-        return update_time_step;
-      }
-
-      template <int dim>
-      UpdateFlags
-      Composition<dim>::get_needed_update_flags () const
-      {
-        return update_values;
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      Composition<dim>::get_property_information() const
-      {
-
-        AssertThrow(this->n_compositional_fields() > 0,
-                    ExcMessage("You have requested the particle property <composition>, "
-                               "but the number of compositional fields is 0. "
-                               "Please add compositional fields to your model, or remove "
-                               "this particle property."));
-
-        std::vector<std::pair<std::string,unsigned int>> property_information;
-
-
-
-        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
-          {
-            const std::string field_name = this->introspection().name_for_compositional_index(i);
-            property_information.emplace_back(field_name,1);
-          }
-        return property_information;
-      }
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(Composition,
-                                        "composition",
-                                        "Implementation of a plugin in which the particle "
-                                        "property is defined by the compositional fields in "
-                                        "the model. This can be used to track solid composition"
-                                        "evolution over time.")
-    }
-  }
-}
diff --git a/source/particle/property/cpo_bingham_average.cc.bak b/source/particle/property/cpo_bingham_average.cc.bak
deleted file mode 100644
index 8ccba63ae27..00000000000
--- a/source/particle/property/cpo_bingham_average.cc.bak
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/cpo_bingham_average.h>
-#include <aspect/particle/world.h>
-
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      CpoBinghamAverage<dim>::initialize ()
-      {
-        const unsigned int my_rank = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
-        this->random_number_generator.seed(random_number_seed+my_rank);
-        const auto &manager = this->get_particle_world(this->get_particle_world_index()).get_property_manager();
-        AssertThrow(manager.plugin_name_exists("crystal preferred orientation"),
-                    ExcMessage("No crystal preferred orientation property plugin found."));
-
-        AssertThrow(manager.check_plugin_order("crystal preferred orientation","cpo bingham average"),
-                    ExcMessage("To use the cpo bingham average plugin, the cpo plugin need to be defined before this plugin."));
-
-        cpo_data_position = manager.get_data_info().get_position_by_plugin_index(manager.get_plugin_index_by_name("crystal preferred orientation"));
-
-      }
-
-
-
-      template <int dim>
-      void
-      CpoBinghamAverage<dim>::initialize_one_particle_property(const Point<dim> &,
-                                                               std::vector<double> &data) const
-      {
-        std::vector<double> volume_fractions_grains(n_grains);
-        std::vector<Tensor<2,3>> rotation_matrices_grains(n_grains);
-        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
-          {
-            // create volume fractions and rotation matrix vectors in the order that it is stored in the data array
-            for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
-              {
-                volume_fractions_grains[grain_i] = cpo_particle_property->get_volume_fractions_grains(cpo_data_position,data,mineral_i,grain_i);
-                rotation_matrices_grains[grain_i] = cpo_particle_property->get_rotation_matrix_grains(cpo_data_position,data,mineral_i,grain_i);
-              }
-
-            const std::vector<Tensor<2,3>> weighted_rotation_matrices =
-              Utilities::rotation_matrices_random_draw_volume_weighting(volume_fractions_grains,
-                                                                        rotation_matrices_grains,
-                                                                        n_samples,
-                                                                        this->random_number_generator);
-            const std::array<std::array<double,6>,3> bingham_average = compute_bingham_average(weighted_rotation_matrices);
-
-            for (unsigned int i = 0; i < 3; ++i)
-              for (unsigned int j = 0; j < 6; ++j)
-                data.emplace_back(bingham_average[i][j]);
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      CpoBinghamAverage<dim>::update_particle_property(const unsigned int data_position,
-                                                       const Vector<double> &/*solution*/,
-                                                       const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                                       typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        std::vector<double> volume_fractions_grains(n_grains);
-        std::vector<Tensor<2,3>> rotation_matrices_grains(n_grains);
-        ArrayView<double> data = particle->get_properties();
-        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
-          {
-            // create volume fractions and rotation matrix vectors in the order that it is stored in the data array
-            for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
-              {
-                volume_fractions_grains[grain_i] = cpo_particle_property->get_volume_fractions_grains(cpo_data_position,data,mineral_i,grain_i);
-                rotation_matrices_grains[grain_i] = cpo_particle_property->get_rotation_matrix_grains(cpo_data_position,data,mineral_i,grain_i);
-              }
-
-            const std::vector<Tensor<2,3>> weighted_rotation_matrices = Utilities::rotation_matrices_random_draw_volume_weighting(volume_fractions_grains, rotation_matrices_grains, n_samples, this->random_number_generator);
-            std::array<std::array<double,6>,3> bingham_average = compute_bingham_average(weighted_rotation_matrices);
-
-            for (unsigned int i = 0; i < 3; ++i)
-              for (unsigned int j = 0; j < 6; ++j)
-                {
-                  data[data_position + mineral_i*18 + i*3 + j] = bingham_average[i][j];
-                }
-          }
-      }
-
-
-
-      template <int dim>
-      std::array<std::array<double,6>,3>
-      CpoBinghamAverage<dim>::compute_bingham_average(std::vector<Tensor<2,3>> matrices) const
-      {
-        SymmetricTensor<2,3> sum_matrix_a;
-        SymmetricTensor<2,3> sum_matrix_b;
-        SymmetricTensor<2,3> sum_matrix_c;
-
-        // extracting the a, b and c orientations from the olivine a matrix
-        // see https://courses.eas.ualberta.ca/eas421/lecturepages/orientation.html
-        const unsigned int n_matrices = matrices.size();
-        for (unsigned int i_grain = 0; i_grain < n_matrices; ++i_grain)
-          {
-            sum_matrix_a[0][0] += matrices[i_grain][0][0] * matrices[i_grain][0][0]; // SUM(l^2)
-            sum_matrix_a[1][1] += matrices[i_grain][0][1] * matrices[i_grain][0][1]; // SUM(m^2)
-            sum_matrix_a[2][2] += matrices[i_grain][0][2] * matrices[i_grain][0][2]; // SUM(n^2)
-            sum_matrix_a[0][1] += matrices[i_grain][0][0] * matrices[i_grain][0][1]; // SUM(l*m)
-            sum_matrix_a[0][2] += matrices[i_grain][0][0] * matrices[i_grain][0][2]; // SUM(l*n)
-            sum_matrix_a[1][2] += matrices[i_grain][0][1] * matrices[i_grain][0][2]; // SUM(m*n)
-
-
-            sum_matrix_b[0][0] += matrices[i_grain][1][0] * matrices[i_grain][1][0]; // SUM(l^2)
-            sum_matrix_b[1][1] += matrices[i_grain][1][1] * matrices[i_grain][1][1]; // SUM(m^2)
-            sum_matrix_b[2][2] += matrices[i_grain][1][2] * matrices[i_grain][1][2]; // SUM(n^2)
-            sum_matrix_b[0][1] += matrices[i_grain][1][0] * matrices[i_grain][1][1]; // SUM(l*m)
-            sum_matrix_b[0][2] += matrices[i_grain][1][0] * matrices[i_grain][1][2]; // SUM(l*n)
-            sum_matrix_b[1][2] += matrices[i_grain][1][1] * matrices[i_grain][1][2]; // SUM(m*n)
-
-
-            sum_matrix_c[0][0] += matrices[i_grain][2][0] * matrices[i_grain][2][0]; // SUM(l^2)
-            sum_matrix_c[1][1] += matrices[i_grain][2][1] * matrices[i_grain][2][1]; // SUM(m^2)
-            sum_matrix_c[2][2] += matrices[i_grain][2][2] * matrices[i_grain][2][2]; // SUM(n^2)
-            sum_matrix_c[0][1] += matrices[i_grain][2][0] * matrices[i_grain][2][1]; // SUM(l*m)
-            sum_matrix_c[0][2] += matrices[i_grain][2][0] * matrices[i_grain][2][2]; // SUM(l*n)
-            sum_matrix_c[1][2] += matrices[i_grain][2][1] * matrices[i_grain][2][2]; // SUM(m*n)
-
-          }
-        const std::array<std::pair<double,Tensor<1,3,double>>, 3> eigenvectors_a = eigenvectors(sum_matrix_a, SymmetricTensorEigenvectorMethod::jacobi);
-        const std::array<std::pair<double,Tensor<1,3,double>>, 3> eigenvectors_b = eigenvectors(sum_matrix_b, SymmetricTensorEigenvectorMethod::jacobi);
-        const std::array<std::pair<double,Tensor<1,3,double>>, 3> eigenvectors_c = eigenvectors(sum_matrix_c, SymmetricTensorEigenvectorMethod::jacobi);
-
-        // average axis = eigenvector * largest eigenvalue
-        const Tensor<1,3,double> averaged_a = eigenvectors_a[0].second * eigenvectors_a[0].first;
-        const Tensor<1,3,double> averaged_b = eigenvectors_b[0].second * eigenvectors_b[0].first;
-        const Tensor<1,3,double> averaged_c = eigenvectors_c[0].second * eigenvectors_a[0].first;
-
-        // eigenvalues of all axes, used in the anisotropic viscosity material model to compute Hill's coefficients
-        const double eigenvalue_a1 = eigenvectors_a[0].first/matrices.size();
-        const double eigenvalue_a2 = eigenvectors_a[1].first/matrices.size();
-        const double eigenvalue_a3 = eigenvectors_a[2].first/matrices.size();
-        const double eigenvalue_b1 = eigenvectors_b[0].first/matrices.size();
-        const double eigenvalue_b2 = eigenvectors_b[1].first/matrices.size();
-        const double eigenvalue_b3 = eigenvectors_b[2].first/matrices.size();
-        const double eigenvalue_c1 = eigenvectors_c[0].first/matrices.size();
-        const double eigenvalue_c2 = eigenvectors_c[1].first/matrices.size();
-        const double eigenvalue_c3 = eigenvectors_c[2].first/matrices.size();
-
-        return
-        {
-          {
-            {{averaged_a[0],averaged_a[1],averaged_a[2], eigenvalue_a1, eigenvalue_a2, eigenvalue_a3}},
-            {{averaged_b[0],averaged_b[1],averaged_b[2], eigenvalue_b1, eigenvalue_b2, eigenvalue_b3}},
-            {{averaged_c[0],averaged_c[1],averaged_c[2], eigenvalue_c1, eigenvalue_c2, eigenvalue_c3}}
-          }
-        };
-
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      CpoBinghamAverage<dim>::need_update() const
-      {
-        return update_output_step;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      CpoBinghamAverage<dim>::get_needed_update_flags () const
-      {
-        return update_default;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      CpoBinghamAverage<dim>::get_property_information() const
-      {
-        std::vector<std::pair<std::string,unsigned int>> property_information;
-        property_information.reserve(6*n_minerals);
-        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
-          {
-            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " bingham average a axis",3);
-            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " eigenvalues a axis",3);
-            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " bingham average b axis",3);
-            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " eigenvalues b axis",3);
-            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " bingham average c axis",3);
-            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " eigenvalues c axis",3);
-          }
-
-        return property_information;
-      }
-
-
-
-      template <int dim>
-      void
-      CpoBinghamAverage<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("CPO Bingham Average");
-        {
-          prm.declare_entry ("Random number seed", "1",
-                             Patterns::Integer (0),
-                             "The seed used to generate random numbers. This will make sure that "
-                             "results are reproducible as long as the problem is run with the "
-                             "same amount of MPI processes. It is implemented as final seed = "
-                             "Random number seed + MPI Rank. ");
-
-          prm.declare_entry ("Number of samples", "0",
-                             Patterns::Double(0),
-                             "This determines how many samples are taken when using the random "
-                             "draw volume averaging. Setting it to zero means that the number of "
-                             "samples is set to be equal to the number of grains.");
-        }
-        prm.leave_subsection ();
-      }
-
-
-
-      template <int dim>
-      void
-      CpoBinghamAverage<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("CPO Bingham Average");
-        {
-          // Get a pointer to the CPO particle property.
-          cpo_particle_property = std::make_unique<const Particle::Property::CrystalPreferredOrientation<dim>> (
-                                    this->get_particle_world(this->get_particle_world_index()).get_property_manager().template get_matching_property<Particle::Property::CrystalPreferredOrientation<dim>>());
-
-          random_number_seed = prm.get_integer ("Random number seed");
-          n_grains = cpo_particle_property->get_number_of_grains();
-          n_minerals = cpo_particle_property->get_number_of_minerals();
-          n_samples = prm.get_integer("Number of samples");
-          if (n_samples == 0)
-            n_samples = n_grains;
-        }
-        prm.leave_subsection ();
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(CpoBinghamAverage,
-                                        "cpo bingham average",
-                                        "This is a particle property plugin which computes the Bingham "
-                                        "average for the Crystal Preferred Orientation particle property "
-                                        "plugin so that it can be visualized.")
-    }
-  }
-}
diff --git a/source/particle/property/cpo_elastic_tensor.cc.bak b/source/particle/property/cpo_elastic_tensor.cc.bak
deleted file mode 100644
index e15c4436b70..00000000000
--- a/source/particle/property/cpo_elastic_tensor.cc.bak
+++ /dev/null
@@ -1,261 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/cpo_elastic_tensor.h>
-#include <aspect/particle/world.h>
-
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-
-
-      template <int dim>
-      CpoElasticTensor<dim>::CpoElasticTensor ()
-      {
-        // The following values are directly from D-Rex.
-        // Todo: make them a input parameter
-        // Stiffness matrix for Olivine (GigaPascals)
-        stiffness_matrix_olivine[0][0] = 320.71;
-        stiffness_matrix_olivine[0][1] = 69.84;
-        stiffness_matrix_olivine[0][2] = 71.22;
-        stiffness_matrix_olivine[1][1] = 197.25;
-        stiffness_matrix_olivine[1][2] = 74.8;
-        stiffness_matrix_olivine[2][2] = 234.32;
-        stiffness_matrix_olivine[3][3] = 63.77;
-        stiffness_matrix_olivine[4][4] = 77.67;
-        stiffness_matrix_olivine[5][5] = 78.36;
-
-
-        // Stiffness matrix for Enstatite (GPa)
-        stiffness_matrix_enstatite[0][0] = 236.9;
-        stiffness_matrix_enstatite[0][1] = 79.6;
-        stiffness_matrix_enstatite[0][2] = 63.2;
-        stiffness_matrix_enstatite[1][1] = 180.5;
-        stiffness_matrix_enstatite[1][2] = 56.8;
-        stiffness_matrix_enstatite[2][2] = 230.4;
-        stiffness_matrix_enstatite[3][3] = 84.3;
-        stiffness_matrix_enstatite[4][4] = 79.4;
-        stiffness_matrix_enstatite[5][5] = 80.1;
-      }
-
-
-
-      template <int dim>
-      void
-      CpoElasticTensor<dim>::initialize ()
-      {
-        const auto &manager = this->get_particle_world(this->get_particle_world_index()).get_property_manager();
-        AssertThrow(manager.plugin_name_exists("crystal preferred orientation"),
-                    ExcMessage("No crystal preferred orientation property plugin found."));
-
-        AssertThrow(manager.check_plugin_order("crystal preferred orientation","cpo elastic tensor"),
-                    ExcMessage("To use the cpo elastic tensor plugin, the cpo plugin needs to be defined before this plugin."));
-
-        cpo_data_position = manager.get_data_info().get_position_by_plugin_index(manager.get_plugin_index_by_name("crystal preferred orientation"));
-      }
-
-
-
-      template <int dim>
-      SymmetricTensor<2,6>
-      CpoElasticTensor<dim>::voigt_average_elastic_tensor (const Particle::Property::CrystalPreferredOrientation<dim> &cpo_particle_property,
-                                                           const unsigned int cpo_data_position,
-                                                           const ArrayView<double> &data) const
-      {
-        SymmetricTensor<2,6> C_average;
-        const SymmetricTensor<2,6> *stiffness_matrix = &stiffness_matrix_olivine;
-        for (size_t mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
-          {
-            if (cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_a_fabric
-                || cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_b_fabric
-                || cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_d_fabric
-                || cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_c_fabric
-                || cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::olivine_e_fabric
-               )
-              {
-                stiffness_matrix = &stiffness_matrix_olivine;
-              }
-            else if (cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i) == DeformationType::enstatite)
-              {
-                stiffness_matrix = &stiffness_matrix_enstatite;
-              }
-            else
-              {
-                AssertThrow(false, ExcMessage("Stiffness matrix not implemented for deformation type "
-                                              + std::to_string(static_cast<unsigned int>(cpo_particle_property.get_deformation_type(cpo_data_position,data,mineral_i)))));
-              }
-
-            for (size_t grain_i = 0; grain_i < n_grains; grain_i++)
-              {
-                const auto rotated_matrix = Utilities::Tensors::rotate_voigt_stiffness_matrix(transpose(cpo_particle_property.get_rotation_matrix_grains(cpo_data_position,data,mineral_i,grain_i)),*stiffness_matrix);
-                C_average += cpo_particle_property.get_volume_fractions_grains(cpo_data_position,data,mineral_i,grain_i) * cpo_particle_property.get_volume_fraction_mineral(cpo_data_position,data,mineral_i) * rotated_matrix;
-              }
-          }
-
-        return C_average;
-      }
-
-
-
-      template <int dim>
-      void
-      CpoElasticTensor<dim>::initialize_one_particle_property(const Point<dim> &,
-                                                              std::vector<double> &data) const
-      {
-
-        // At initialization, the deformation type for cpo is initialized to -1.
-        // Initialize with the stiffness matrix of olivine to avoid errors in the computation.
-
-        for (unsigned int i = 0; i < SymmetricTensor<2,6>::n_independent_components ; ++i)
-          {
-            data.push_back(stiffness_matrix_olivine[SymmetricTensor<2,6>::unrolled_to_component_indices(i)]);
-          }
-
-
-      }
-
-
-
-      template <int dim>
-      void
-      CpoElasticTensor<dim>::update_particle_property(const unsigned int data_position,
-                                                      const Vector<double> &/*solution*/,
-                                                      const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                                      typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        // Get a reference to the CPO particle property.
-        const Particle::Property::CrystalPreferredOrientation<dim> &cpo_particle_property =
-          this->get_particle_world(this->get_particle_world_index()).get_property_manager().template get_matching_property<Particle::Property::CrystalPreferredOrientation<dim>>();
-
-
-        const SymmetricTensor<2,6> C_average = voigt_average_elastic_tensor(cpo_particle_property,
-                                                                            cpo_data_position,
-                                                                            particle->get_properties());
-
-        Particle::Property::CpoElasticTensor<dim>::set_elastic_tensor(data_position,
-                                                                      particle->get_properties(),
-                                                                      C_average);
-
-
-      }
-
-
-
-      template <int dim>
-      SymmetricTensor<2,6>
-      CpoElasticTensor<dim>::get_elastic_tensor(unsigned int cpo_data_position,
-                                                const ArrayView<double> &data)
-      {
-        return Utilities::Tensors::to_symmetric_tensor<6>(&data[cpo_data_position],
-                                                          &data[cpo_data_position]+SymmetricTensor<2,6>::n_independent_components);
-      }
-
-
-
-      template <int dim>
-      void
-      CpoElasticTensor<dim>::set_elastic_tensor(unsigned int cpo_data_position,
-                                                const ArrayView<double> &data,
-                                                const SymmetricTensor<2,6> &elastic_tensor)
-      {
-        Utilities::Tensors::unroll_symmetric_tensor_into_array(elastic_tensor,
-                                                               &data[cpo_data_position],
-                                                               &data[cpo_data_position]+SymmetricTensor<2,6>::n_independent_components);
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      CpoElasticTensor<dim>::need_update() const
-      {
-        return update_output_step;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      CpoElasticTensor<dim>::get_needed_update_flags () const
-      {
-        return update_default;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      CpoElasticTensor<dim>::get_property_information() const
-      {
-        std::vector<std::pair<std::string,unsigned int>> property_information;
-
-        property_information.emplace_back("cpo_elastic_tensor", SymmetricTensor<2,6>::n_independent_components);
-        return property_information;
-      }
-
-
-
-      template <int dim>
-      void
-      CpoElasticTensor<dim>::declare_parameters (ParameterHandler &)
-      {}
-
-
-
-      template <int dim>
-      void
-      CpoElasticTensor<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Crystal Preferred Orientation");
-        {
-          n_grains = prm.get_integer("Number of grains per particle");
-          prm.enter_subsection("Initial grains");
-          {
-            n_minerals = dealii::Utilities::split_string_list(prm.get("Minerals")).size();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(CpoElasticTensor,
-                                        "cpo elastic tensor",
-                                        "A plugin in which the particle property tensor is "
-                                        "defined as the Voigt average of the "
-                                        "elastic tensors of the minerals in the textured rock."
-                                        "Currently only Olivine and Enstatite are supported.")
-    }
-  }
-}
diff --git a/source/particle/property/crystal_preferred_orientation.cc.bak b/source/particle/property/crystal_preferred_orientation.cc.bak
deleted file mode 100644
index 3f849f0ca4d..00000000000
--- a/source/particle/property/crystal_preferred_orientation.cc.bak
+++ /dev/null
@@ -1,1275 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/crystal_preferred_orientation.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/citation_info.h>
-#include <aspect/utilities.h>
-
-#include <world_builder/grains.h>
-#include <world_builder/world.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-
-      template <int dim>
-      void
-      CrystalPreferredOrientation<dim>::initialize ()
-      {
-        CitationInfo::add("CPO");
-        const unsigned int my_rank = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
-        this->random_number_generator.seed(random_number_seed+my_rank);
-
-        // Don't assert when called by the unit tester.
-        if (this->simulator_is_past_initialization())
-          {
-            AssertThrow(this->introspection().compositional_name_exists("water"),
-                        ExcMessage("Particle property CPO only works if"
-                                   "there is a compositional field called water."));
-            water_index = this->introspection().compositional_index_for_name("water");
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      CrystalPreferredOrientation<dim>::compute_random_rotation_matrix(Tensor<2,3> &rotation_matrix) const
-      {
-
-        // This function is based on an article in Graphic Gems III, written by James Arvo, Cornell University (p 116-120).
-        // The original code can be found on  http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c
-        // and is licenced according to this website with the following licence:
-        //
-        // "The Graphics Gems code is copyright-protected. In other words, you cannot claim the text of the code as your own and
-        // resell it. Using the code is permitted in any program, product, or library, non-commercial or commercial. Giving credit
-        // is not required, though is a nice gesture. The code comes as-is, and if there are any flaws or problems with any Gems
-        // code, nobody involved with Gems - authors, editors, publishers, or webmasters - are to be held responsible. Basically,
-        // don't be a jerk, and remember that anything free comes with no guarantee.""
-        //
-        // The book states in the preface the following: "As in the first two volumes, all of the C and C++ code in this book is in
-        // the public domain, and is yours to study, modify, and use."
-
-        // first generate three random numbers between 0 and 1 and multiply them with 2 PI or 2 for z. Note that these are not the same as phi_1, theta and phi_2.
-
-        boost::random::uniform_real_distribution<double> uniform_distribution(0,1);
-        double one = uniform_distribution(this->random_number_generator);
-        double two = uniform_distribution(this->random_number_generator);
-        double three = uniform_distribution(this->random_number_generator);
-
-        double theta = 2.0 * M_PI * one; // Rotation about the pole (Z)
-        double phi = 2.0 * M_PI * two; // For direction of pole deflection.
-        double z = 2.0* three; //For magnitude of pole deflection.
-
-        // Compute a vector V used for distributing points over the sphere
-        // via the reflection I - V Transpose(V).  This formulation of V
-        // will guarantee that if x[1] and x[2] are uniformly distributed,
-        // the reflected points will be uniform on the sphere.  Note that V
-        // has length sqrt(2) to eliminate the 2 in the Householder matrix.
-
-        double r  = std::sqrt( z );
-        double Vx = std::sin( phi ) * r;
-        double Vy = std::cos( phi ) * r;
-        double Vz = std::sqrt( 2.f - z );
-
-        // Compute the row vector S = Transpose(V) * R, where R is a simple
-        // rotation by theta about the z-axis.  No need to compute Sz since
-        // it's just Vz.
-
-        double st = std::sin( theta );
-        double ct = std::cos( theta );
-        double Sx = Vx * ct - Vy * st;
-        double Sy = Vx * st + Vy * ct;
-
-        // Construct the rotation matrix  ( V Transpose(V) - I ) R, which
-        // is equivalent to V S - R.
-
-        rotation_matrix[0][0] = Vx * Sx - ct;
-        rotation_matrix[0][1] = Vx * Sy - st;
-        rotation_matrix[0][2] = Vx * Vz;
-        rotation_matrix[1][0] = Vy * Sx + st;
-        rotation_matrix[1][1] = Vy * Sy - ct;
-        rotation_matrix[1][2] = Vy * Vz;
-        rotation_matrix[2][0] = Vz * Sx;
-        rotation_matrix[2][1] = Vz * Sy;
-        rotation_matrix[2][2] = 1.0 - z;   // This equals Vz * Vz - 1.0
-      }
-
-
-
-      template <int dim>
-      void
-      CrystalPreferredOrientation<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                                         std::vector<double> &data) const
-      {
-        // the layout of the data vector per particle is the following:
-        // 1. M mineral times
-        //    1.1  olivine deformation type   -> 1 double, at location
-        //                                      => data_position + 0 + mineral_i * (n_grains * 10 + 2)
-        //    2.1. Mineral volume fraction    -> 1 double, at location
-        //                                      => data_position + 1 + mineral_i *(n_grains * 10 + 2)
-        //    2.2. N grains times:
-        //         2.1. volume fraction grain -> 1 double, at location:
-        //                                      => data_position + 2 + i_grain * 10 + mineral_i *(n_grains * 10 + 2), or
-        //                                      => data_position + 2 + i_grain * (2 * Tensor<2,3>::n_independent_components+ 2) + mineral_i * (n_grains * 10 + 2)
-        //         2.2. rotation matrix grain -> 9 (Tensor<2,dim>::n_independent_components) doubles, starts at:
-        //                                      => data_position + 3 + i_grain * 10 + mineral_i * (n_grains * 10 + 2), or
-        //                                      => data_position + 3 + i_grain * (2 * Tensor<2,3>::n_independent_components+ 2) + mineral_i * (n_grains * 10 + 2)
-        //
-        // Note that we store exactly the same number of grains of all minerals (e.g. olivine and enstatite
-        // grains), although their volume fractions may not be the same. We need a minimum amount
-        // of grains per tracer to perform reliable statistics on it. This minimum is the same for all phases.
-        // and enstatite.
-        //
-        // Furthermore, for this plugin the following dims are always 3. When using 2d an infinitely thin 3d domain is assumed.
-        //
-        // The rotation matrix is a direction cosine matrix, representing the orientation of the grain in the domain.
-        // The fabric is determined later in the computations, so initialize it to -1.
-        std::vector<double> deformation_type(n_minerals, -1.0);
-        std::vector<std::vector<double >>volume_fractions_grains(n_minerals);
-        std::vector<std::vector<Tensor<2,3>>> rotation_matrices_grains(n_minerals);
-
-        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
-          {
-            volume_fractions_grains[mineral_i].resize(n_grains);
-            rotation_matrices_grains[mineral_i].resize(n_grains);
-
-            // This will be set by the initial grain subsection.
-            if (initial_grains_model == CPOInitialGrainsModel::world_builder)
-              {
-#ifdef ASPECT_WITH_WORLD_BUILDER
-                WorldBuilder::grains wb_grains = this->get_world_builder().grains(Utilities::convert_point_to_array(position),
-                                                                                  -this->get_geometry_model().height_above_reference_surface(position),
-                                                                                  mineral_i,
-                                                                                  n_grains);
-                double sum_volume_fractions = 0;
-                for (unsigned int grain_i = 0; grain_i < n_grains ; ++grain_i)
-                  {
-                    sum_volume_fractions += wb_grains.sizes[grain_i];
-                    volume_fractions_grains[mineral_i][grain_i] = wb_grains.sizes[grain_i];
-                    // we are receiving a array<array<double,3>,3> from the world builder,
-                    // which needs to be copied in the correct way into a tensor<2,3>.
-                    for (unsigned int component_i = 0; component_i < 3 ; ++component_i)
-                      {
-                        for (unsigned int component_j = 0; component_j < 3 ; ++component_j)
-                          {
-                            Assert(!std::isnan(wb_grains.rotation_matrices[grain_i][component_i][component_j]), ExcMessage("Error: not a number."));
-                            rotation_matrices_grains[mineral_i][grain_i][component_i][component_j] = wb_grains.rotation_matrices[grain_i][component_i][component_j];
-                          }
-                      }
-                  }
-
-                AssertThrow(sum_volume_fractions != 0, ExcMessage("Sum of volumes is equal to zero, which is not supposed to happen. "
-                                                                  "Make sure that all parts of the domain which contain particles are covered by the world builder."));
-#else
-                AssertThrow(false,
-                            ExcMessage("The world builder was requested but not provided. Make sure that aspect is "
-                                       "compiled with the World Builder and that you provide a world builder file in the input."));
-#endif
-              }
-            else
-              {
-                // set volume fraction
-                const double initial_volume_fraction = 1.0/n_grains;
-
-                for (unsigned int grain_i = 0; grain_i < n_grains ; ++grain_i)
-                  {
-                    // set volume fraction
-                    volume_fractions_grains[mineral_i][grain_i] = initial_volume_fraction;
-
-                    // set a uniform random rotation_matrix per grain
-                    this->compute_random_rotation_matrix(rotation_matrices_grains[mineral_i][grain_i]);
-                  }
-              }
-          }
-
-        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
-          {
-            data.emplace_back(deformation_type[mineral_i]);
-            data.emplace_back(volume_fractions_minerals[mineral_i]);
-            for (unsigned int grain_i = 0; grain_i < n_grains ; ++grain_i)
-              {
-                data.emplace_back(volume_fractions_grains[mineral_i][grain_i]);
-                for (unsigned int i = 0; i < Tensor<2,3>::n_independent_components ; ++i)
-                  {
-                    const dealii::TableIndices<2> index = Tensor<2,3>::unrolled_to_component_indices(i);
-                    data.emplace_back(rotation_matrices_grains[mineral_i][grain_i][index]);
-                  }
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      CrystalPreferredOrientation<dim>::update_particle_property(const unsigned int data_position,
-                                                                 const Vector<double> &solution,
-                                                                 const std::vector<Tensor<1,dim>> &gradients,
-                                                                 typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        // STEP 1: Load data and preprocess it.
-
-        // need access to the pressure, viscosity,
-        // get velocity
-        Tensor<1,dim> velocity;
-        for (unsigned int i = 0; i < dim; ++i)
-          velocity[i] = solution[this->introspection().component_indices.velocities[i]];
-
-        // get velocity gradient tensor.
-        Tensor<2,dim> velocity_gradient;
-        for (unsigned int i = 0; i < dim; ++i)
-          velocity_gradient[i] = gradients[this->introspection().component_indices.velocities[i]];
-
-        // Calculate strain rate from velocity gradients
-        const SymmetricTensor<2,dim> strain_rate = symmetrize (velocity_gradient);
-        const SymmetricTensor<2,dim> deviatoric_strain_rate
-          = (this->get_material_model().is_compressible()
-             ?
-             strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
-             :
-             strain_rate);
-
-        const double pressure = solution[this->introspection().component_indices.pressure];
-        const double temperature = solution[this->introspection().component_indices.temperature];
-        const double water_content = solution[this->introspection().component_indices.compositional_fields[water_index]];
-
-        // get the composition of the particle
-        std::vector<double> compositions;
-        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
-          {
-            const unsigned int solution_component = this->introspection().component_indices.compositional_fields[i];
-            compositions.push_back(solution[solution_component]);
-          }
-
-        const double dt = this->get_timestep();
-
-        // even in 2d we need 3d strain-rates and velocity gradient tensors. So we make them 3d by
-        // adding an extra dimension which is zero.
-        SymmetricTensor<2,3> strain_rate_3d;
-        strain_rate_3d[0][0] = strain_rate[0][0];
-        strain_rate_3d[0][1] = strain_rate[0][1];
-        //sym: strain_rate_3d[1][0] = strain_rate[1][0];
-        strain_rate_3d[1][1] = strain_rate[1][1];
-
-        if (dim == 3)
-          {
-            strain_rate_3d[0][2] = strain_rate[0][2];
-            strain_rate_3d[1][2] = strain_rate[1][2];
-            //sym: strain_rate_3d[2][0] = strain_rate[0][2];
-            //sym: strain_rate_3d[2][1] = strain_rate[1][2];
-            strain_rate_3d[2][2] = strain_rate[2][2];
-          }
-        Tensor<2,3> velocity_gradient_3d;
-        velocity_gradient_3d[0][0] = velocity_gradient[0][0];
-        velocity_gradient_3d[0][1] = velocity_gradient[0][1];
-        velocity_gradient_3d[1][0] = velocity_gradient[1][0];
-        velocity_gradient_3d[1][1] = velocity_gradient[1][1];
-        if (dim == 3)
-          {
-            velocity_gradient_3d[0][2] = velocity_gradient[0][2];
-            velocity_gradient_3d[1][2] = velocity_gradient[1][2];
-            velocity_gradient_3d[2][0] = velocity_gradient[2][0];
-            velocity_gradient_3d[2][1] = velocity_gradient[2][1];
-            velocity_gradient_3d[2][2] = velocity_gradient[2][2];
-          }
-
-        ArrayView<double> data = particle->get_properties();
-
-        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
-          {
-
-            /**
-            * Now we have loaded all the data and can do the actual computation.
-            * The computation consists of two parts. The first part is computing
-            * the derivatives for the directions and grain sizes. Then those
-            * derivatives are used to advect the particle properties.
-            */
-            double sum_volume_mineral = 0;
-            std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
-            derivatives_grains = this->compute_derivatives(data_position,
-                                                           data,
-                                                           mineral_i,
-                                                           strain_rate_3d,
-                                                           velocity_gradient_3d,
-                                                           particle->get_location(),
-                                                           temperature,
-                                                           pressure,
-                                                           velocity,
-                                                           compositions,
-                                                           strain_rate,
-                                                           deviatoric_strain_rate,
-                                                           water_content);
-
-            switch (advection_method)
-              {
-                case AdvectionMethod::forward_euler:
-
-                  sum_volume_mineral = this->advect_forward_euler(data_position,
-                                                                  data,
-                                                                  mineral_i,
-                                                                  dt,
-                                                                  derivatives_grains);
-
-                  break;
-
-                case AdvectionMethod::backward_euler:
-                  sum_volume_mineral = this->advect_backward_euler(data_position,
-                                                                   data,
-                                                                   mineral_i,
-                                                                   dt,
-                                                                   derivatives_grains);
-
-                  break;
-              }
-
-            // normalize the volume fractions back to a total of 1 for each mineral
-            const double inv_sum_volume_mineral = 1.0/sum_volume_mineral;
-
-            Assert(std::isfinite(inv_sum_volume_mineral),
-                   ExcMessage("inv_sum_volume_mineral is not finite. sum_volume_enstatite = "
-                              + std::to_string(sum_volume_mineral)));
-
-            for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
-              {
-                const double volume_fraction_grains = get_volume_fractions_grains(data_position,data,mineral_i,grain_i)*inv_sum_volume_mineral;
-                set_volume_fractions_grains(data_position,data,mineral_i,grain_i,volume_fraction_grains);
-                Assert(isfinite(get_volume_fractions_grains(data_position,data,mineral_i,grain_i)),
-                       ExcMessage("volume_fractions_grains[mineral_i]" + std::to_string(grain_i) + "] is not finite: "
-                                  + std::to_string(get_volume_fractions_grains(data_position,data,mineral_i,grain_i)) + ", inv_sum_volume_mineral = "
-                                  + std::to_string(inv_sum_volume_mineral) + "."));
-
-                /**
-                 * Correct direction rotation matrices numerical error (orthnormality) after integration
-                 * Follows same method as in matlab version from Thissen (see https://github.com/cthissen/Drex-MATLAB/)
-                 * of finding the nearest orthonormal matrix using the SVD
-                 */
-                Tensor<2,3> rotation_matrix = get_rotation_matrix_grains(data_position,data,mineral_i,grain_i);
-                for (size_t i = 0; i < 3; ++i)
-                  {
-                    for (size_t j = 0; j < 3; ++j)
-                      {
-                        Assert(!std::isnan(rotation_matrix[i][j]), ExcMessage("rotation_matrix is nan before orthogonalization."));
-                      }
-                  }
-
-                rotation_matrix = dealii::project_onto_orthogonal_tensors(rotation_matrix);
-                for (size_t i = 0; i < 3; ++i)
-                  for (size_t j = 0; j < 3; ++j)
-                    {
-                      // I don't think this should happen with the projection, but D-Rex
-                      // does not do the orthogonal projection, but just clamps the values
-                      // to 1 and -1.
-                      Assert(std::fabs(rotation_matrix[i][j]) <= 1.0,
-                             ExcMessage("The rotation_matrix has a entry larger than 1."));
-
-                      Assert(!std::isnan(rotation_matrix[i][j]),
-                             ExcMessage("rotation_matrix is nan after orthoganalization: "
-                                        + std::to_string(rotation_matrix[i][j])));
-
-                      Assert(abs(rotation_matrix[i][j]) <= 1.0,
-                             ExcMessage("3. rotation_matrix[" + std::to_string(i) + "][" + std::to_string(j) +
-                                        "] is larger than one: "
-                                        + std::to_string(rotation_matrix[i][j]) + " (" + std::to_string(rotation_matrix[i][j]-1.0) + "). rotation_matrix = \n"
-                                        + std::to_string(rotation_matrix[0][0]) + " " + std::to_string(rotation_matrix[0][1]) + " " + std::to_string(rotation_matrix[0][2]) + "\n"
-                                        + std::to_string(rotation_matrix[1][0]) + " " + std::to_string(rotation_matrix[1][1]) + " " + std::to_string(rotation_matrix[1][2]) + "\n"
-                                        + std::to_string(rotation_matrix[2][0]) + " " + std::to_string(rotation_matrix[2][1]) + " " + std::to_string(rotation_matrix[2][2])));
-                    }
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      CrystalPreferredOrientation<dim>::need_update() const
-      {
-        return update_time_step;
-      }
-
-
-
-      template <int dim>
-      InitializationModeForLateParticles
-      CrystalPreferredOrientation<dim>::late_initialization_mode () const
-      {
-        return InitializationModeForLateParticles::interpolate;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      CrystalPreferredOrientation<dim>::get_needed_update_flags () const
-      {
-        return update_values | update_gradients;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      CrystalPreferredOrientation<dim>::get_property_information() const
-      {
-        std::vector<std::pair<std::string,unsigned int>> property_information;
-        property_information.reserve(n_minerals * n_grains * (1+Tensor<2,3>::n_independent_components));
-
-        for (unsigned int mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
-          {
-            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " type",1);
-            property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " volume fraction",1);
-
-            for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
-              {
-                property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " grain " + std::to_string(grain_i) + " volume fraction",1);
-
-                for (unsigned int index = 0; index < Tensor<2,3>::n_independent_components; ++index)
-                  {
-                    property_information.emplace_back("cpo mineral " + std::to_string(mineral_i) + " grain " + std::to_string(grain_i) + " rotation_matrix " + std::to_string(index),1);
-                  }
-              }
-          }
-
-        return property_information;
-      }
-
-
-
-      template <int dim>
-      double
-      CrystalPreferredOrientation<dim>::advect_forward_euler(const unsigned int cpo_index,
-                                                             const ArrayView<double> &data,
-                                                             const unsigned int mineral_i,
-                                                             const double dt,
-                                                             const std::pair<std::vector<double>, std::vector<Tensor<2,3>>> &derivatives) const
-      {
-        double sum_volume_fractions = 0;
-        Tensor<2,3> rotation_matrix;
-        for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
-          {
-            // Do the volume fraction of the grain
-            Assert(std::isfinite(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i)),ExcMessage("volume_fractions[grain_i] is not finite before it is set."));
-            double volume_fraction_grains = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
-            volume_fraction_grains =  volume_fraction_grains + dt * volume_fraction_grains * derivatives.first[grain_i];
-            set_volume_fractions_grains(cpo_index,data,mineral_i,grain_i, volume_fraction_grains);
-            Assert(std::isfinite(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i)),ExcMessage("volume_fractions[grain_i] is not finite. grain_i = "
-                   + std::to_string(grain_i) + ", volume_fractions[grain_i] = " + std::to_string(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i))
-                   + ", derivatives.first[grain_i] = " + std::to_string(derivatives.first[grain_i])));
-
-            sum_volume_fractions += get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
-
-            // Do the rotation matrix for this grain
-            rotation_matrix = get_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i);
-            rotation_matrix += dt * rotation_matrix * derivatives.second[grain_i];
-            set_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i,rotation_matrix);
-          }
-
-        Assert(sum_volume_fractions != 0, ExcMessage("The sum of all grain volume fractions of a mineral is equal to zero. This should not happen."));
-        return sum_volume_fractions;
-      }
-
-
-
-      template <int dim>
-      double
-      CrystalPreferredOrientation<dim>::advect_backward_euler(const unsigned int cpo_index,
-                                                              const ArrayView<double> &data,
-                                                              const unsigned int mineral_i,
-                                                              const double dt,
-                                                              const std::pair<std::vector<double>, std::vector<Tensor<2,3>>> &derivatives) const
-      {
-        double sum_volume_fractions = 0;
-        Tensor<2,3> cosine_ref;
-        for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
-          {
-            // Do the volume fraction of the grain
-            double vf_old = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
-            double vf_new = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
-            Assert(std::isfinite(vf_new),ExcMessage("vf_new is not finite before it is set."));
-            for (size_t iteration = 0; iteration < property_advection_max_iterations; ++iteration)
-              {
-                Assert(std::isfinite(vf_new),ExcMessage("vf_new is not finite before it is set. grain_i = "
-                                                        + std::to_string(grain_i) + ", volume_fractions[grain_i] = " + std::to_string(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i))
-                                                        + ", derivatives.first[grain_i] = " + std::to_string(derivatives.first[grain_i])));
-
-                vf_new = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i) + dt * vf_new * derivatives.first[grain_i];
-
-                Assert(std::isfinite(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i)),ExcMessage("volume_fractions[grain_i] is not finite. grain_i = "
-                       + std::to_string(grain_i) + ", volume_fractions[grain_i] = " + std::to_string(get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i))
-                       + ", derivatives.first[grain_i] = " + std::to_string(derivatives.first[grain_i])));
-                if (std::fabs(vf_new-vf_old) < property_advection_tolerance)
-                  {
-                    break;
-                  }
-                vf_old = vf_new;
-              }
-
-            set_volume_fractions_grains(cpo_index,data,mineral_i,grain_i,vf_new);
-            sum_volume_fractions += vf_new;
-
-            // Do the rotation matrix for this grain
-            cosine_ref = get_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i);
-            Tensor<2,3> cosine_old = cosine_ref;
-            Tensor<2,3> cosine_new = cosine_ref;
-
-            for (size_t iteration = 0; iteration < property_advection_max_iterations; ++iteration)
-              {
-                cosine_new = cosine_ref + dt * cosine_new * derivatives.second[grain_i];
-
-                if ((cosine_new-cosine_old).norm() < property_advection_tolerance)
-                  {
-                    break;
-                  }
-                cosine_old = cosine_new;
-              }
-
-            set_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i,cosine_new);
-
-          }
-
-
-        Assert(sum_volume_fractions != 0, ExcMessage("The sum of all grain volume fractions of a mineral is equal to zero. This should not happen."));
-        return sum_volume_fractions;
-      }
-
-
-
-      template <int dim>
-      std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
-      CrystalPreferredOrientation<dim>::compute_derivatives(const unsigned int cpo_index,
-                                                            const ArrayView<double> &data,
-                                                            const unsigned int mineral_i,
-                                                            const SymmetricTensor<2,3> &strain_rate_3d,
-                                                            const Tensor<2,3> &velocity_gradient_tensor,
-                                                            const Point<dim> &position,
-                                                            const double temperature,
-                                                            const double pressure,
-                                                            const Tensor<1,dim> &velocity,
-                                                            const std::vector<double> &compositions,
-                                                            const SymmetricTensor<2,dim> &strain_rate,
-                                                            const SymmetricTensor<2,dim> &deviatoric_strain_rate,
-                                                            const double water_content) const
-      {
-        std::pair<std::vector<double>, std::vector<Tensor<2,3>>> derivatives;
-        switch (cpo_derivative_algorithm)
-          {
-            case CPODerivativeAlgorithm::spin_tensor:
-            {
-              return compute_derivatives_spin_tensor(velocity_gradient_tensor);
-              break;
-            }
-            case CPODerivativeAlgorithm::drex_2004:
-            {
-
-              const DeformationType deformation_type = determine_deformation_type(deformation_type_selector[mineral_i],
-                                                                                  position,
-                                                                                  temperature,
-                                                                                  pressure,
-                                                                                  velocity,
-                                                                                  compositions,
-                                                                                  strain_rate,
-                                                                                  deviatoric_strain_rate,
-                                                                                  water_content);
-
-              set_deformation_type(cpo_index,data,mineral_i,deformation_type);
-
-              const std::array<double,4> ref_resolved_shear_stress = reference_resolved_shear_stress_from_deformation_type(deformation_type);
-
-              return compute_derivatives_drex_2004(cpo_index,
-                                                   data,
-                                                   mineral_i,
-                                                   strain_rate_3d,
-                                                   velocity_gradient_tensor,
-                                                   ref_resolved_shear_stress);
-              break;
-            }
-            default:
-              AssertThrow(false, ExcMessage("Internal error."));
-              break;
-          }
-        AssertThrow(false, ExcMessage("Internal error."));
-        return derivatives;
-      }
-
-
-
-      template <int dim>
-      std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
-      CrystalPreferredOrientation<dim>::compute_derivatives_spin_tensor(const Tensor<2,3> &velocity_gradient_tensor) const
-      {
-        // dA/dt = W * A, where W is the spin tensor and A is the rotation matrix
-        // The spin tensor is defined as W = 0.5 * ( L - L^T ), where L is the velocity gradient tensor.
-        const Tensor<2,3> spin_tensor = -0.5 *(velocity_gradient_tensor - dealii::transpose(velocity_gradient_tensor));
-
-        return std::pair<std::vector<double>, std::vector<Tensor<2,3>>>(std::vector<double>(n_grains,0.0), std::vector<Tensor<2,3>>(n_grains, spin_tensor));
-      }
-
-
-      template <int dim>
-      std::pair<std::vector<double>, std::vector<Tensor<2,3>>>
-      CrystalPreferredOrientation<dim>::compute_derivatives_drex_2004(const unsigned int cpo_index,
-                                                                      const ArrayView<double> &data,
-                                                                      const unsigned int mineral_i,
-                                                                      const SymmetricTensor<2,3> &strain_rate_3d,
-                                                                      const Tensor<2,3> &velocity_gradient_tensor,
-                                                                      const std::array<double,4> ref_resolved_shear_stress,
-                                                                      const bool prevent_nondimensionalization) const
-      {
-        // This if statement is only there for the unit test. In normal situations it should always be set to false,
-        // because the nondimensionalization should always be done (in this exact way), unless you really know what
-        // you are doing.
-        double nondimensionalization_value = 1.0;
-        if (!prevent_nondimensionalization)
-          {
-            const std::array< double, 3 > eigenvalues = dealii::eigenvalues(strain_rate_3d);
-            nondimensionalization_value = std::max(std::abs(eigenvalues[0]),std::abs(eigenvalues[2]));
-
-            Assert(!std::isnan(nondimensionalization_value), ExcMessage("The second invariant of the strain rate is not a number."));
-          }
-
-
-        // Make the strain-rate and velocity gradient tensor non-dimensional
-        // by dividing it through the second invariant
-        const Tensor<2,3> strain_rate_nondimensional = nondimensionalization_value != 0 ? strain_rate_3d/nondimensionalization_value : strain_rate_3d;
-        const Tensor<2,3> velocity_gradient_tensor_nondimensional = nondimensionalization_value != 0 ? velocity_gradient_tensor/nondimensionalization_value : velocity_gradient_tensor;
-
-        // create output variables
-        std::vector<double> deriv_volume_fractions(n_grains);
-        std::vector<Tensor<2,3>> deriv_a_cosine_matrices(n_grains);
-
-        // create shortcuts
-        const std::array<double, 4> &tau = ref_resolved_shear_stress;
-
-        std::vector<double> strain_energy(n_grains);
-        double mean_strain_energy = 0;
-
-        for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
-          {
-            // Compute the Schmidt tensor for this grain (nu), s is the slip system.
-            // We first compute beta_s,nu (equation 5, Kaminski & Ribe, 2001)
-            // Then we use the beta to calculate the Schmidt tensor G_{ij} (Eq. 5, Kaminski & Ribe, 2001)
-            Tensor<2,3> G;
-            Tensor<1,3> w;
-            Tensor<1,4> beta({1.0, 1.0, 1.0, 1.0});
-            std::array<Tensor<1,3>,4> slip_normal_reference {{Tensor<1,3>({0,1,0}),Tensor<1,3>({0,0,1}),Tensor<1,3>({0,1,0}),Tensor<1,3>({1,0,0})}};
-            std::array<Tensor<1,3>,4> slip_direction_reference {{Tensor<1,3>({1,0,0}),Tensor<1,3>({1,0,0}),Tensor<1,3>({0,0,1}),Tensor<1,3>({0,0,1})}};
-
-            // these are variables we only need for olivine, but we need them for both
-            // within this if block and the next ones
-            // Ordered vector where the first entry is the max/weakest and the last entry is the inactive slip system.
-            std::array<unsigned int,4> indices {};
-
-            // compute G and beta
-            Tensor<1,4> bigI;
-            const Tensor<2,3> rotation_matrix = get_rotation_matrix_grains(cpo_index,data,mineral_i,grain_i);
-            const Tensor<2,3> rotation_matrix_transposed = transpose(rotation_matrix);
-            for (unsigned int slip_system_i = 0; slip_system_i < 4; ++slip_system_i)
-              {
-                const Tensor<1,3> slip_normal_global = rotation_matrix_transposed*slip_normal_reference[slip_system_i];
-                const Tensor<1,3> slip_direction_global = rotation_matrix_transposed*slip_direction_reference[slip_system_i];
-                const Tensor<2,3> slip_cross_product = outer_product(slip_direction_global,slip_normal_global);
-                bigI[slip_system_i] = scalar_product(slip_cross_product,strain_rate_nondimensional);
-              }
-
-            if (bigI.norm() < 1e-10)
-              {
-                // In this case there is no shear, only (possibly) a rotation. So \gamma_y and/or G should be zero.
-                // Which is the default value, so do nothing.
-              }
-            else
-              {
-                // compute the element wise absolute value of the element wise
-                // division of BigI by tau (tau = ref_resolved_shear_stress).
-                std::array<double,4> q_abs;
-                for (unsigned int i = 0; i < 4; ++i)
-                  {
-                    q_abs[i] = std::abs(bigI[i] / tau[i]);
-                  }
-
-                // here we find the indices starting at the largest value and ending at the smallest value
-                // and assign them to special variables. Because all the variables are absolute values,
-                // we can set them to a negative value to ignore them. This should be faster then deleting
-                // the element, which would require allocation. (not tested)
-                for (unsigned int slip_system_i = 0; slip_system_i < 4; ++slip_system_i)
-                  {
-                    indices[slip_system_i] = std::distance(q_abs.begin(),std::max_element(q_abs.begin(), q_abs.end()));
-                    q_abs[indices[slip_system_i]] = -1;
-                  }
-
-                // compute the ordered beta vector, which is the relative slip rates of the active slip systems.
-                // Test whether the max element is not equal to zero.
-                Assert(bigI[indices[0]] != 0.0, ExcMessage("Internal error: bigI is zero."));
-                beta[indices[0]] = 1.0; // max q_abs, weak system (most deformation) "s=1"
-
-                const double ratio = tau[indices[0]]/bigI[indices[0]];
-                for (unsigned int slip_system_i = 1; slip_system_i < 4-1; ++slip_system_i)
-                  {
-                    beta[indices[slip_system_i]] = std::pow(std::abs(ratio * (bigI[indices[slip_system_i]]/tau[indices[slip_system_i]])), stress_exponent);
-                  }
-                beta[indices.back()] = 0.0;
-
-                // Now compute the crystal rate of deformation tensor. equation 4 of Kaminski&Ribe 2001
-                // rotation_matrix_transposed = inverse of rotation matrix
-                // (see Engler et al., 2024 book: Intro to Texture analysis chp 2.3.2 The Rotation Matrix)
-                // this transform the crystal reference frame to specimen reference frame
-                for (unsigned int slip_system_i = 0; slip_system_i < 4; ++slip_system_i)
-                  {
-                    const Tensor<1,3> slip_normal_global = rotation_matrix_transposed*slip_normal_reference[slip_system_i];
-                    const Tensor<1,3> slip_direction_global = rotation_matrix_transposed*slip_direction_reference[slip_system_i];
-                    const Tensor<2,3> slip_cross_product = outer_product(slip_direction_global,slip_normal_global);
-                    G += 2.0 * beta[slip_system_i] * slip_cross_product;
-                  }
-              }
-
-            // Now calculate the analytic solution to the deformation minimization problem
-            // compute gamma (equation 7, Kaminiski & Ribe, 2001)
-
-            // Top is the numerator and bottom is the denominator in equation 7.
-            double top = 0;
-            double bottom = 0;
-            for (unsigned int i = 0; i < 3; ++i)
-              {
-                // Following the actual Drex implementation we use i+2, which differs
-                // from the EPSL paper, which says gamma_nu depends on i+1
-                const unsigned int i_offset = (i==0) ? (i+2) : (i-1);
-
-                top = top - (velocity_gradient_tensor_nondimensional[i][i_offset]-velocity_gradient_tensor_nondimensional[i_offset][i])*(G[i][i_offset]-G[i_offset][i]);
-                bottom = bottom - (G[i][i_offset]-G[i_offset][i])*(G[i][i_offset]-G[i_offset][i]);
-
-                for (unsigned int j = 0; j < 3; ++j)
-                  {
-                    top = top + 2.0 * G[i][j]*velocity_gradient_tensor_nondimensional[i][j];
-                    bottom = bottom + 2.0* G[i][j] * G[i][j];
-                  }
-              }
-            // see comment on if all BigI are zero. In that case gamma should be zero.
-            const double gamma = (bottom != 0.0) ? top/bottom : 0.0;
-
-            // compute w (equation 8, Kaminiski & Ribe, 2001)
-            // w is the Rotation rate vector of the crystallographic axes of grain
-            w[0] = 0.5*(velocity_gradient_tensor_nondimensional[2][1]-velocity_gradient_tensor_nondimensional[1][2]) - 0.5*(G[2][1]-G[1][2])*gamma;
-            w[1] = 0.5*(velocity_gradient_tensor_nondimensional[0][2]-velocity_gradient_tensor_nondimensional[2][0]) - 0.5*(G[0][2]-G[2][0])*gamma;
-            w[2] = 0.5*(velocity_gradient_tensor_nondimensional[1][0]-velocity_gradient_tensor_nondimensional[0][1]) - 0.5*(G[1][0]-G[0][1])*gamma;
-
-            // Compute strain energy for this grain (abbreviated Estr)
-            // For olivine: DREX only sums over 1-3. But Christopher Thissen's matlab
-            // code (https://github.com/cthissen/Drex-MATLAB) corrected
-            // this and writes each term using the indices created when calculating bigI.
-            // Note tau = RRSS = (tau_m^s/tau_o), this why we get tau^(p-n)
-            for (unsigned int slip_system_i = 0; slip_system_i < 4; ++slip_system_i)
-              {
-                const double rhos = std::pow(tau[indices[slip_system_i]],exponent_p-stress_exponent) *
-                                    std::pow(std::abs(gamma*beta[indices[slip_system_i]]),exponent_p/stress_exponent);
-                strain_energy[grain_i] += rhos * std::exp(-nucleation_efficiency * rhos * rhos);
-
-                Assert(isfinite(strain_energy[grain_i]), ExcMessage("strain_energy[" + std::to_string(grain_i) + "] is not finite: " + std::to_string(strain_energy[grain_i])
-                                                                    + ", rhos (" + std::to_string(slip_system_i) + ") = " + std::to_string(rhos)
-                                                                    + ", nucleation_efficiency = " + std::to_string(nucleation_efficiency) + "."));
-              }
-
-
-            // compute the derivative of the rotation matrix: \frac{\partial a_{ij}}{\partial t}
-            // (Eq. 9, Kaminski & Ribe 2001)
-            deriv_a_cosine_matrices[grain_i] = 0;
-            const double volume_fraction_grain = get_volume_fractions_grains(cpo_index,data,mineral_i,grain_i);
-            if (volume_fraction_grain >= threshold_GBS/n_grains)
-              {
-                deriv_a_cosine_matrices[grain_i] = Utilities::Tensors::levi_civita<3>() * w * nondimensionalization_value;
-
-                // volume averaged strain energy
-                mean_strain_energy += volume_fraction_grain * strain_energy[grain_i];
-
-                Assert(isfinite(mean_strain_energy), ExcMessage("mean_strain_energy when adding grain " + std::to_string(grain_i) + " is not finite: " + std::to_string(mean_strain_energy)
-                                                                + ", volume_fraction_grain = " + std::to_string(volume_fraction_grain) + "."));
-              }
-            else
-              {
-                strain_energy[grain_i] = 0;
-              }
-          }
-
-        // Change of volume fraction of grains by grain boundary migration
-        for (unsigned int grain_i = 0; grain_i < n_grains; ++grain_i)
-          {
-            // Different than D-Rex. Here we actually only compute the derivative and do not multiply it with the volume_fractions. We do that when we advect.
-            deriv_volume_fractions[grain_i] = get_volume_fraction_mineral(cpo_index,data,mineral_i) * mobility * (mean_strain_energy - strain_energy[grain_i]) * nondimensionalization_value;
-
-            Assert(isfinite(deriv_volume_fractions[grain_i]),
-                   ExcMessage("deriv_volume_fractions[" + std::to_string(grain_i) + "] is not finite: "
-                              + std::to_string(deriv_volume_fractions[grain_i])));
-          }
-
-        return std::pair<std::vector<double>, std::vector<Tensor<2,3>>>(deriv_volume_fractions, deriv_a_cosine_matrices);
-      }
-
-
-      template <int dim>
-      DeformationType
-      CrystalPreferredOrientation<dim>::determine_deformation_type(const DeformationTypeSelector deformation_type_selector,
-                                                                   const Point<dim> &position,
-                                                                   const double temperature,
-                                                                   const double pressure,
-                                                                   const Tensor<1,dim> &velocity,
-                                                                   const std::vector<double> &compositions,
-                                                                   const SymmetricTensor<2,dim> &strain_rate,
-                                                                   const SymmetricTensor<2,dim> &deviatoric_strain_rate,
-                                                                   const double water_content) const
-      {
-        // Now compute what type of deformation takes place.
-        switch (deformation_type_selector)
-          {
-            case DeformationTypeSelector::passive:
-              return DeformationType::passive;
-            case DeformationTypeSelector::olivine_a_fabric:
-              return DeformationType::olivine_a_fabric;
-            case DeformationTypeSelector::olivine_b_fabric:
-              return DeformationType::olivine_b_fabric;
-            case DeformationTypeSelector::olivine_c_fabric:
-              return DeformationType::olivine_c_fabric;
-            case DeformationTypeSelector::olivine_d_fabric:
-              return DeformationType::olivine_d_fabric;
-            case DeformationTypeSelector::olivine_e_fabric:
-              return DeformationType::olivine_e_fabric;
-            case DeformationTypeSelector::enstatite:
-              return DeformationType::enstatite;
-            case DeformationTypeSelector::olivine_karato_2008:
-              // construct the material model inputs and outputs
-              // Since this function is only evaluating one particle,
-              // we use 1 for the amount of quadrature points.
-              MaterialModel::MaterialModelInputs<dim> material_model_inputs(1,this->n_compositional_fields());
-              material_model_inputs.position[0] = position;
-              material_model_inputs.temperature[0] = temperature;
-              material_model_inputs.pressure[0] = pressure;
-              material_model_inputs.velocity[0] = velocity;
-              material_model_inputs.composition[0] = compositions;
-              material_model_inputs.strain_rate[0] = strain_rate;
-
-              MaterialModel::MaterialModelOutputs<dim> material_model_outputs(1,this->n_compositional_fields());
-              this->get_material_model().evaluate(material_model_inputs, material_model_outputs);
-              double eta = material_model_outputs.viscosities[0];
-
-              const SymmetricTensor<2,dim> stress = 2*eta*deviatoric_strain_rate +
-                                                    pressure * unit_symmetric_tensor<dim>();
-              const std::array< double, dim > eigenvalues = dealii::eigenvalues(stress);
-              double differential_stress = eigenvalues[0]-eigenvalues[dim-1];
-              return determine_deformation_type_karato_2008(differential_stress, water_content);
-
-          }
-
-        AssertThrow(false, ExcMessage("Internal error. Deformation type not implemented."));
-        return DeformationType::passive;
-      }
-
-
-      template <int dim>
-      DeformationType
-      CrystalPreferredOrientation<dim>::determine_deformation_type_karato_2008(const double stress, const double water_content) const
-      {
-        constexpr double MPa = 1e6;
-        constexpr double ec_line_slope = -500./1050.;
-        if (stress > (380. - 0.05 * water_content)*MPa)
-          {
-            if (stress > (625. - 2.5 * water_content)*MPa)
-              {
-                return DeformationType::olivine_b_fabric;
-              }
-            else
-              {
-                return DeformationType::olivine_d_fabric;
-              }
-          }
-        else
-          {
-            if (stress < (625.0 -2.5 * water_content)*MPa)
-              {
-                return DeformationType::olivine_a_fabric;
-              }
-            else
-              {
-                if (stress < (500.0 + ec_line_slope*-100. + ec_line_slope * water_content)*MPa)
-                  {
-                    return DeformationType::olivine_e_fabric;
-                  }
-                else
-                  {
-                    return DeformationType::olivine_c_fabric;
-                  }
-              }
-          }
-      }
-
-
-      template <int dim>
-      std::array<double,4>
-      CrystalPreferredOrientation<dim>::reference_resolved_shear_stress_from_deformation_type(DeformationType deformation_type,
-          double max_value) const
-      {
-        std::array<double,4> ref_resolved_shear_stress;
-        switch (deformation_type)
-          {
-            // from Kaminski and Ribe, GJI 2004 and
-            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
-            case DeformationType::olivine_a_fabric :
-              ref_resolved_shear_stress[0] = 1;
-              ref_resolved_shear_stress[1] = 2;
-              ref_resolved_shear_stress[2] = 3;
-              ref_resolved_shear_stress[3] = max_value;
-              break;
-
-            // from Kaminski and Ribe, GJI 2004 and
-            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
-            case DeformationType::olivine_b_fabric :
-              ref_resolved_shear_stress[0] = 3;
-              ref_resolved_shear_stress[1] = 2;
-              ref_resolved_shear_stress[2] = 1;
-              ref_resolved_shear_stress[3] = max_value;
-              break;
-
-            // from Kaminski and Ribe, GJI 2004 and
-            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
-            case DeformationType::olivine_c_fabric :
-              ref_resolved_shear_stress[0] = 3;
-              ref_resolved_shear_stress[1] = max_value;
-              ref_resolved_shear_stress[2] = 2;
-              ref_resolved_shear_stress[3] = 1;
-              break;
-
-            // from Kaminski and Ribe, GRL 2002 and
-            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
-            case DeformationType::olivine_d_fabric :
-              ref_resolved_shear_stress[0] = 1;
-              ref_resolved_shear_stress[1] = 1;
-              ref_resolved_shear_stress[2] = 3;
-              ref_resolved_shear_stress[3] = max_value;
-              break;
-
-            // Kaminski, Ribe and Browaeys, GJI, 2004 (same as in the matlab code) and
-            // Becker et al., 2007 (http://www-udc.ig.utexas.edu/external/becker/preprints/bke07.pdf)
-            case DeformationType::olivine_e_fabric :
-              ref_resolved_shear_stress[0] = 2;
-              ref_resolved_shear_stress[1] = 1;
-              ref_resolved_shear_stress[2] = max_value;
-              ref_resolved_shear_stress[3] = 3;
-              break;
-
-            // from Kaminski and Ribe, GJI 2004.
-            // Todo: this one is not used in practice, since there is an optimization in
-            // the code. So maybe remove it in the future.
-            case DeformationType::enstatite :
-              ref_resolved_shear_stress[0] = max_value;
-              ref_resolved_shear_stress[1] = max_value;
-              ref_resolved_shear_stress[2] = max_value;
-              ref_resolved_shear_stress[3] = 1;
-              break;
-
-            default:
-              AssertThrow(false,
-                          ExcMessage("Deformation type enum with number " + std::to_string(static_cast<unsigned int>(deformation_type))
-                                     + " was not found."));
-              break;
-          }
-        return ref_resolved_shear_stress;
-      }
-
-      template <int dim>
-      unsigned int
-      CrystalPreferredOrientation<dim>::get_number_of_grains() const
-      {
-        return n_grains;
-      }
-
-
-
-      template <int dim>
-      unsigned int
-      CrystalPreferredOrientation<dim>::get_number_of_minerals() const
-      {
-        return n_minerals;
-      }
-
-
-
-      template <int dim>
-      void
-      CrystalPreferredOrientation<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Crystal Preferred Orientation");
-        {
-          prm.declare_entry ("Random number seed", "1",
-                             Patterns::Integer (0),
-                             "The seed used to generate random numbers. This will make sure that "
-                             "results are reproducible as long as the problem is run with the "
-                             "same number of MPI processes. It is implemented as final seed = "
-                             "user seed + MPI Rank. ");
-
-          prm.declare_entry ("Number of grains per particle", "50",
-                             Patterns::Integer (1),
-                             "The number of grains of each different mineral "
-                             "each particle contains.");
-
-          prm.declare_entry ("Property advection method", "Backward Euler",
-                             Patterns::Anything(),
-                             "Options: Forward Euler, Backward Euler");
-
-          prm.declare_entry ("Property advection tolerance", "1e-10",
-                             Patterns::Double(0),
-                             "The Backward Euler property advection method involve internal iterations. "
-                             "This option allows for setting a tolerance. When the norm of tensor new - tensor old is "
-                             "smaller than this tolerance, the iteration is stopped.");
-
-          prm.declare_entry ("Property advection max iterations", "100",
-                             Patterns::Integer(0),
-                             "The Backward Euler property advection method involve internal iterations. "
-                             "This option allows for setting the maximum number of iterations. Note that when the iteration "
-                             "is ended by the max iteration amount an assert is thrown.");
-
-          prm.declare_entry ("CPO derivatives algorithm", "Spin tensor",
-                             Patterns::List(Patterns::Anything()),
-                             "Options: Spin tensor");
-
-          prm.enter_subsection("Initial grains");
-          {
-            prm.declare_entry("Model name","Uniform grains and random uniform rotations",
-                              Patterns::Anything(),
-                              "The model used to initialize the CPO for all particles. "
-                              "Currently 'Uniform grains and random uniform rotations' and 'World Builder' are the only valid option.");
-
-            prm.declare_entry ("Minerals", "Olivine: Karato 2008, Enstatite",
-                               Patterns::List(Patterns::Anything()),
-                               "This determines what minerals and fabrics or fabric selectors are used used for the LPO/CPO calculation. "
-                               "The options are Olivine: Passive, A-fabric, Olivine: B-fabric, Olivine: C-fabric, Olivine: D-fabric, "
-                               "Olivine: E-fabric, Olivine: Karato 2008 or Enstatite. Passive sets all RRSS entries to the maximum. The "
-                               "Karato 2008 selector selects a fabric based on stress and water content as defined in "
-                               "figure 4 of the Karato 2008 review paper (doi: 10.1146/annurev.earth.36.031207.124120).");
-
-
-            prm.declare_entry ("Volume fractions minerals", "0.7, 0.3",
-                               Patterns::List(Patterns::Double(0)),
-                               "The volume fractions for the different minerals. "
-                               "There need to be the same number of values as there are minerals."
-                               "Note that the currently implemented scheme is incompressible and "
-                               "does not allow chemical interaction or the formation of new phases");
-          }
-          prm.leave_subsection ();
-
-          prm.enter_subsection("D-Rex 2004");
-          {
-
-            prm.declare_entry ("Mobility", "50",
-                               Patterns::Double(0),
-                               "The dimensionless intrinsic grain boundary mobility for both olivine and enstatite.");
-
-            prm.declare_entry ("Volume fractions minerals", "0.5, 0.5",
-                               Patterns::List(Patterns::Double(0)),
-                               "The volume fraction for the different minerals. "
-                               "There need to be the same amount of values as there are minerals");
-
-            prm.declare_entry ("Stress exponents", "3.5",
-                               Patterns::Double(0),
-                               "This is the power law exponent that characterizes the rheology of the "
-                               "slip systems. It is used in equation 11 of Kaminski et al., 2004.");
-
-            prm.declare_entry ("Exponents p", "1.5",
-                               Patterns::Double(0),
-                               "This is exponent p as defined in equation 11 of Kaminski et al., 2004. ");
-
-            prm.declare_entry ("Nucleation efficiency", "5",
-                               Patterns::Double(0),
-                               "This is the dimensionless nucleation rate as defined in equation 8 of "
-                               "Kaminski et al., 2004. ");
-
-            prm.declare_entry ("Threshold GBS", "0.3",
-                               Patterns::Double(0),
-                               "The Dimensionless Grain Boundary Sliding (GBS) threshold. "
-                               "This is a grain size threshold below which grain deform by GBS and "
-                               "become strain-free grains.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection ();
-      }
-
-
-
-      template <int dim>
-      void
-      CrystalPreferredOrientation<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        AssertThrow(dim == 3, ExcMessage("CPO computations are currently only supported for 3d models. "
-                                         "2d computations will work when this assert is removed, but you will need to make sure that the "
-                                         "correct 3d strain-rate and velocity gradient tensors are provided to the algorithm."));
-
-        prm.enter_subsection("Crystal Preferred Orientation");
-        {
-          random_number_seed = prm.get_integer ("Random number seed");
-          n_grains = prm.get_integer("Number of grains per particle");
-
-          property_advection_tolerance = prm.get_double("Property advection tolerance");
-          property_advection_max_iterations = prm.get_integer ("Property advection max iterations");
-
-          const std::string temp_cpo_derivative_algorithm = prm.get("CPO derivatives algorithm");
-
-          if (temp_cpo_derivative_algorithm == "Spin tensor")
-            {
-              cpo_derivative_algorithm = CPODerivativeAlgorithm::spin_tensor;
-            }
-          else if (temp_cpo_derivative_algorithm ==  "D-Rex 2004")
-            {
-              cpo_derivative_algorithm = CPODerivativeAlgorithm::drex_2004;
-            }
-          else
-            {
-              AssertThrow(false,
-                          ExcMessage("The CPO derivatives algorithm needs to be one of the following: "
-                                     "Spin tensor, D-Rex 2004."));
-            }
-
-          const std::string temp_advection_method = prm.get("Property advection method");
-          if (temp_advection_method == "Forward Euler")
-            {
-              advection_method = AdvectionMethod::forward_euler;
-            }
-          else if (temp_advection_method == "Backward Euler")
-            {
-              advection_method = AdvectionMethod::backward_euler;
-            }
-          else
-            {
-              AssertThrow(false, ExcMessage("particle property advection method not found: \"" + temp_advection_method + "\""));
-            }
-
-          prm.enter_subsection("Initial grains");
-          {
-            const std::string model_name = prm.get("Model name");
-            if (model_name == "Uniform grains and random uniform rotations")
-              {
-                initial_grains_model = CPOInitialGrainsModel::uniform_grains_and_random_uniform_rotations;
-              }
-            else if (model_name == "World Builder")
-              {
-                initial_grains_model = CPOInitialGrainsModel::world_builder;
-              }
-            else
-              {
-                AssertThrow(false,
-                            ExcMessage("No model named " + model_name + "for CPO particle property initialization. "
-                                       + "Only the model \"Uniform grains and random uniform rotations\"  and "
-                                       "\"World Builder\" are available."));
-              }
-
-            const std::vector<std::string> temp_deformation_type_selector = dealii::Utilities::split_string_list(prm.get("Minerals"));
-            n_minerals = temp_deformation_type_selector.size();
-            deformation_type_selector.resize(n_minerals);
-
-            for (size_t mineral_i = 0; mineral_i < n_minerals; ++mineral_i)
-              {
-                if (temp_deformation_type_selector[mineral_i] == "Passive")
-                  {
-                    deformation_type_selector[mineral_i] = DeformationTypeSelector::passive;
-                  }
-                else if (temp_deformation_type_selector[mineral_i] == "Olivine: Karato 2008")
-                  {
-                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_karato_2008;
-                  }
-                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: A-fabric")
-                  {
-                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_a_fabric;
-                  }
-                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: B-fabric")
-                  {
-                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_b_fabric;
-                  }
-                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: C-fabric")
-                  {
-                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_c_fabric;
-                  }
-                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: D-fabric")
-                  {
-                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_d_fabric;
-                  }
-                else if (temp_deformation_type_selector[mineral_i] ==  "Olivine: E-fabric")
-                  {
-                    deformation_type_selector[mineral_i] = DeformationTypeSelector::olivine_e_fabric;
-                  }
-                else if (temp_deformation_type_selector[mineral_i] ==  "Enstatite")
-                  {
-                    deformation_type_selector[mineral_i] = DeformationTypeSelector::enstatite;
-                  }
-                else
-                  {
-                    AssertThrow(false,
-                                ExcMessage("The fabric needs to be assigned one of the following comma-delimited values: Olivine: Karato 2008, "
-                                           "Olivine: A-fabric, Olivine: B-fabric, Olivine: C-fabric, Olivine: D-fabric,"
-                                           "Olivine: E-fabric, Enstatite, Passive."));
-                  }
-              }
-
-            volume_fractions_minerals = Utilities::string_to_double(dealii::Utilities::split_string_list(prm.get("Volume fractions minerals")));
-            double volume_fractions_minerals_sum = 0;
-            for (auto fraction : volume_fractions_minerals)
-              {
-                volume_fractions_minerals_sum += fraction;
-              }
-
-            AssertThrow(abs(volume_fractions_minerals_sum-1.0) < 2.0 * std::numeric_limits<double>::epsilon(),
-                        ExcMessage("The sum of the CPO volume fractions should be one."));
-          }
-          prm.leave_subsection();
-
-          prm.enter_subsection("D-Rex 2004");
-          {
-            mobility = prm.get_double("Mobility");
-            volume_fractions_minerals = Utilities::string_to_double(dealii::Utilities::split_string_list(prm.get("Volume fractions minerals")));
-            stress_exponent = prm.get_double("Stress exponents");
-            exponent_p = prm.get_double("Exponents p");
-            nucleation_efficiency = prm.get_double("Nucleation efficiency");
-            threshold_GBS = prm.get_double("Threshold GBS");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection ();
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(CrystalPreferredOrientation,
-                                        "crystal preferred orientation",
-                                        "WARNING: all the CPO plugins are a work in progress and not ready for production use yet. "
-                                        "See https://github.com/geodynamics/aspect/issues/3885 for current status and alternatives. "
-                                        "The plugin manages and computes the evolution of Lattice/Crystal Preferred Orientations (LPO/CPO) "
-                                        "on particles. Each ASPECT particle can be assigned many grains. Each grain is assigned a size and a orientation "
-                                        "matrix. This allows for CPO evolution tracking with polycrystalline kinematic CrystalPreferredOrientation evolution models such "
-                                        "as D-Rex (Kaminski and Ribe, 2001; Kaminski et al., 2004).")
-    }
-  }
-}
diff --git a/source/particle/property/elastic_stress.cc.bak b/source/particle/property/elastic_stress.cc.bak
deleted file mode 100644
index f0be9a72362..00000000000
--- a/source/particle/property/elastic_stress.cc.bak
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/elastic_stress.h>
-#include <aspect/material_model/visco_plastic.h>
-#include <aspect/material_model/viscoelastic.h>
-#include <aspect/initial_composition/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      ElasticStress<dim>::ElasticStress ()
-        :
-        material_inputs(1,0),
-        material_outputs(1,0)
-      {}
-
-
-
-      template <int dim>
-      void
-      ElasticStress<dim>::initialize ()
-      {
-        material_inputs = MaterialModel::MaterialModelInputs<dim>(1, this->n_compositional_fields());
-
-        material_outputs = MaterialModel::MaterialModelOutputs<dim>(1, this->n_compositional_fields());
-
-        AssertThrow((Plugins::plugin_type_matches<const MaterialModel::ViscoPlastic<dim>>(this->get_material_model())
-                     ||
-                     Plugins::plugin_type_matches<const MaterialModel::Viscoelastic<dim>>(this->get_material_model())),
-                    ExcMessage("This particle property only makes sense in combination with the viscoelastic or visco_plastic material model."));
-
-        AssertThrow(this->get_parameters().enable_elasticity == true,
-                    ExcMessage ("This particle property should only be used if 'Enable elasticity' is set to true"));
-
-      }
-
-
-
-      template <int dim>
-      void
-      ElasticStress<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                           std::vector<double> &data) const
-      {
-        // Give each elastic stress field its initial composition if one is prescribed.
-        data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_xx")));
-
-        data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_yy")));
-
-        if (dim == 2)
-          {
-            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_xy")));
-          }
-        else if (dim == 3)
-          {
-            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_zz")));
-
-            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_xy")));
-
-            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_xz")));
-
-            data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("ve_stress_yz")));
-          }
-
-      }
-
-
-
-      template <int dim>
-      void
-      ElasticStress<dim>::update_particle_property(const unsigned int data_position,
-                                                   const Vector<double> &solution,
-                                                   const std::vector<Tensor<1,dim>> &gradients,
-                                                   typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        material_inputs.position[0] = particle->get_location();
-
-
-        material_inputs.current_cell = typename DoFHandler<dim>::active_cell_iterator(*particle->get_surrounding_cell(),
-                                                                                      &(this->get_dof_handler()));
-
-        material_inputs.temperature[0] = solution[this->introspection().component_indices.temperature];
-
-        material_inputs.pressure[0] = solution[this->introspection().component_indices.pressure];
-
-        for (unsigned int d = 0; d < dim; ++d)
-          material_inputs.velocity[0][d] = solution[this->introspection().component_indices.velocities[d]];
-
-        for (unsigned int n = 0; n < this->n_compositional_fields(); ++n)
-          material_inputs.composition[0][n] = solution[this->introspection().component_indices.compositional_fields[n]];
-
-        Tensor<2,dim> grad_u;
-        for (unsigned int d=0; d<dim; ++d)
-          grad_u[d] = gradients[d];
-        material_inputs.strain_rate[0] = symmetrize (grad_u);
-
-        this->get_material_model().evaluate (material_inputs,material_outputs);
-
-        for (unsigned int i = 0; i < SymmetricTensor<2,dim>::n_independent_components ; ++i)
-          particle->get_properties()[data_position + i] += material_outputs.reaction_terms[0][i];
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      ElasticStress<dim>::need_update() const
-      {
-        return update_time_step;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      ElasticStress<dim>::get_needed_update_flags () const
-      {
-        return update_values | update_gradients;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      ElasticStress<dim>::get_property_information() const
-      {
-        std::vector<std::pair<std::string,unsigned int>> property_information;
-
-        //Check which fields are used in model and make an output for each.
-        if (this->introspection().compositional_name_exists("ve_stress_xx"))
-          property_information.emplace_back("ve_stress_xx",1);
-
-        if (this->introspection().compositional_name_exists("ve_stress_yy"))
-          property_information.emplace_back("ve_stress_yy",1);
-
-        if (dim == 2)
-          {
-            if (this->introspection().compositional_name_exists("ve_stress_xy"))
-              property_information.emplace_back("ve_stress_xy",1);
-          }
-        else if (dim == 3)
-          {
-            if (this->introspection().compositional_name_exists("ve_stress_zz"))
-              property_information.emplace_back("ve_stress_zz",1);
-
-            if (this->introspection().compositional_name_exists("ve_stress_xy"))
-              property_information.emplace_back("ve_stress_xy",1);
-
-            if (this->introspection().compositional_name_exists("ve_stress_xz"))
-              property_information.emplace_back("ve_stress_xz",1);
-
-            if (this->introspection().compositional_name_exists("ve_stress_yz"))
-              property_information.emplace_back("ve_stress_yz",1);
-          }
-
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(ElasticStress,
-                                        "elastic stress",
-                                        "A plugin in which the particle property tensor is "
-                                        "defined as the total elastic stress a particle has "
-                                        "accumulated. See the viscoelastic material model "
-                                        "documentation for more detailed information.")
-
-    }
-  }
-}
diff --git a/source/particle/property/elastic_tensor_decomposition.cc.bak b/source/particle/property/elastic_tensor_decomposition.cc.bak
deleted file mode 100644
index 25308ff2623..00000000000
--- a/source/particle/property/elastic_tensor_decomposition.cc.bak
+++ /dev/null
@@ -1,468 +0,0 @@
-/*
- Copyright (C) 2023 by the authors of the ASPECT code.
- This file is part of ASPECT.
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/elastic_tensor_decomposition.h>
-#include <aspect/particle/property/cpo_elastic_tensor.h>
-#include <aspect/particle/property/crystal_preferred_orientation.h>
-#include <aspect/particle/world.h>
-
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      namespace Utilities
-      {
-        std::array<unsigned int, 3>
-        indexed_even_permutation(const unsigned int index)
-        {
-          // there are 6 permutations, but only the odd or even are needed. We use the even
-          // permutation here.
-          switch (index)
-            {
-              case 0 :
-                return {{0,1,2}};
-              case 1 :
-                return {{1,2,0}};
-              case 2:
-                return {{2,0,1}};
-              /*case 3:
-                return {0,2,1};
-              case 4 :
-                return {1,0,2};
-              case 5:
-                return {2,1,0};*/
-              default:
-                AssertThrow(false,ExcMessage("Provided index larger then 2 (" + std::to_string(index)+ ")."));
-                return {{0,0,0}};
-            }
-
-        }
-
-
-
-        SymmetricTensor<2,3>
-        compute_voigt_stiffness_tensor(const SymmetricTensor<2,6> &elastic_matrix)
-        {
-          /**
-           * the Voigt stiffness tensor (see Browaeys and Chevrot, 2004)
-           * It defines the stress needed to cause an isotropic strain in the
-           * material
-           */
-          SymmetricTensor<2,3> voigt_stiffness_tensor;
-          voigt_stiffness_tensor[0][0]=elastic_matrix[0][0]+elastic_matrix[5][5]+elastic_matrix[4][4];
-          voigt_stiffness_tensor[1][1]=elastic_matrix[5][5]+elastic_matrix[1][1]+elastic_matrix[3][3];
-          voigt_stiffness_tensor[2][2]=elastic_matrix[4][4]+elastic_matrix[3][3]+elastic_matrix[2][2];
-          voigt_stiffness_tensor[1][0]=elastic_matrix[0][5]+elastic_matrix[1][5]+elastic_matrix[3][4];
-          voigt_stiffness_tensor[2][0]=elastic_matrix[0][4]+elastic_matrix[2][4]+elastic_matrix[3][5];
-          voigt_stiffness_tensor[2][1]=elastic_matrix[1][3]+elastic_matrix[2][3]+elastic_matrix[4][5];
-
-          return voigt_stiffness_tensor;
-        }
-
-
-
-        SymmetricTensor<2,3>
-        compute_dilatation_stiffness_tensor(const SymmetricTensor<2,6> &elastic_matrix)
-        {
-          /**
-           * The dilatational stiffness tensor (see Browaeys and Chevrot, 2004)
-           * It defines the stress to cause isotropic dilatation in the material.
-           */
-          SymmetricTensor<2,3> dilatation_stiffness_tensor;
-          for (size_t i = 0; i < 3; i++)
-            {
-              dilatation_stiffness_tensor[0][0]=elastic_matrix[0][i]+dilatation_stiffness_tensor[0][0];
-              dilatation_stiffness_tensor[1][1]=elastic_matrix[1][i]+dilatation_stiffness_tensor[1][1];
-              dilatation_stiffness_tensor[2][2]=elastic_matrix[2][i]+dilatation_stiffness_tensor[2][2];
-              dilatation_stiffness_tensor[1][0]=elastic_matrix[5][i]+dilatation_stiffness_tensor[1][0];
-              dilatation_stiffness_tensor[2][0]=elastic_matrix[4][i]+dilatation_stiffness_tensor[2][0];
-              dilatation_stiffness_tensor[2][1]=elastic_matrix[3][i]+dilatation_stiffness_tensor[2][1];
-            }
-          return dilatation_stiffness_tensor;
-        }
-
-
-
-        Tensor<2,3>
-        compute_unpermutated_SCCS(const SymmetricTensor<2,3> &dilatation_stiffness_tensor,
-                                  const SymmetricTensor<2,3> &voigt_stiffness_tensor)
-        {
-          // computing the eigenvector of the dilation and Voigt stiffness matrices and then averaging them by bysection.
-          const std::array<std::pair<double,Tensor<1,3,double>>, 3> voigt_eigenvectors_a = eigenvectors(voigt_stiffness_tensor, SymmetricTensorEigenvectorMethod::jacobi);
-          const std::array<std::pair<double,Tensor<1,3,double>>, 3> dilatation_eigenvectors_a = eigenvectors(dilatation_stiffness_tensor, SymmetricTensorEigenvectorMethod::jacobi);
-
-
-          std::array<Tensor<1,3,double>,3> unpermutated_SCCS;
-          // Averaging dilatation and voigt eigenvectors
-          // To do this we need to find the eigenvectors which are closest to each other and average those.
-          // The next function looks for the smallest angle and returns the corresponding vector index for
-          // that vector.
-          int vector_index_signed = 0;
-          for (unsigned int i1 = 0; i1 < 3; i1++)
-            {
-              vector_index_signed = 0;
-              double smallest_angle = std::numeric_limits<double>::max(); // angle D VeCtor
-              for (unsigned int i2 = 0; i2 < 3; i2++)
-                {
-                  double dv_dot_product = dilatation_eigenvectors_a[i1].second*voigt_eigenvectors_a[i2].second;
-                  // limit the dot product between 1 and -1 so we can use the arccos function safely.
-                  if (std::abs(dv_dot_product) >= 1.0)
-                    dv_dot_product = std::copysign(1.0,dv_dot_product);
-                  // Compute the angle between the vectors and account for that vector in the opposite
-                  // direction are the same (0 == 180 degrees). So limit the direction of the vectors between
-                  // 0 and 90 degrees such that it represents the minimum angle between the two lines.
-                  const double angle = dv_dot_product < 0.0 ? std::acos(-1.0)-std::acos(dv_dot_product) : std::acos(dv_dot_product);
-                  // store this if the angle is smaller
-                  if (angle < smallest_angle)
-                    {
-                      vector_index_signed = (dv_dot_product < 0.0) ? -i2 : i2;
-                      smallest_angle = angle;
-                    }
-                }
-
-              // Adds to the dilatation eigenvectors to the Voigt eigenvectors with the smallest angle
-              // Note that the voigt eigenvector is multiplied with a value which can be negative, which means it would be a subtraction.
-              // Lastly we normalize the unpermutated_SCCS.
-              unpermutated_SCCS[i1] = 0.5*(dilatation_eigenvectors_a[i1].second + static_cast<double>(vector_index_signed)*voigt_eigenvectors_a[std::abs(vector_index_signed)].second);
-              unpermutated_SCCS[i1] /= unpermutated_SCCS[i1].norm();
-            }
-
-          return Tensor<2,3>(
-          {
-            {unpermutated_SCCS[0][0],unpermutated_SCCS[0][1],unpermutated_SCCS[0][2]},
-            {unpermutated_SCCS[1][0],unpermutated_SCCS[1][1],unpermutated_SCCS[1][2]},
-            {unpermutated_SCCS[2][0],unpermutated_SCCS[2][1],unpermutated_SCCS[2][2]}
-          });
-        }
-
-
-
-        std::array<std::array<double,3>,7>
-        compute_elastic_tensor_SCCS_decompositions(
-          const Tensor<2,3> &unpermutated_SCCS,
-          const SymmetricTensor<2,6> &elastic_matrix)
-        {
-          /**
-           * Try the different permutations to determine what is the best hexagonal projection.
-           * This is based on Browaeys and Chevrot (2004), GJI (doi: 10.1111/j.1365-246X.2004.024115.x),
-           * which states at the end of paragraph 3.3 that "... an important property of an orthogonal projection
-           * is that the distance between a vector $X$ and its orthogonal projection $X_H = p(X)$ on a given
-           * subspace is minimum. These two features ensure that the decomposition is optimal once a 3-D Cartesian
-           * coordinate system is chosen.". The other property they talk about is that "The space of elastic
-           * vectors has a finite dimension [...], i.e. using a different norm from eq. (2.3 will change distances
-           * but not the resulting decomposition.".
-           */
-          std::array<Tensor<2,3>,3> permutated;
-          std::array<SymmetricTensor<2,6>,3> rotated_elastic_matrix;
-          // The norms variable contains the square norms of the different symmetry approximations of the elastic tensor.
-          std::array<std::array<double,3>,7> squared_norms_to_projections;
-
-          for (unsigned int permutation_i = 0; permutation_i < 3; permutation_i++)
-            {
-              std::array<unsigned int, 3> permutation = indexed_even_permutation(permutation_i);
-
-              for (size_t j = 0; j < 3; j++)
-                {
-                  permutated[permutation_i][j] = unpermutated_SCCS[permutation[j]];
-                }
-
-              rotated_elastic_matrix[permutation_i] = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix((permutated[permutation_i]),elastic_matrix);
-
-              const Tensor<1,21> full_elastic_vector_rotated = aspect::Utilities::Tensors::to_voigt_stiffness_vector(rotated_elastic_matrix[permutation_i]);
-
-
-              const double full_norm_square = full_elastic_vector_rotated.norm_square();
-              squared_norms_to_projections[6][permutation_i] = full_norm_square;
-
-              // Get the monoclinic and higher symmetry axes, which can be comptued by taking specific elements from the full vector.
-              // This means that this vector contains all symmetry axes, but the isotropic part is removed.
-              // The following line would do the same as the lines below, but is is very slow. It has therefore been
-              // replaced by the lines below.
-              //auto monoclinic_and_higher_vector = projection_matrix_triclinic_to_monoclinic*full_elastic_vector_rotated;
-              dealii::Tensor<1,21> monoclinic_and_higher_vector;
-              monoclinic_and_higher_vector[0] = full_elastic_vector_rotated[0];
-              monoclinic_and_higher_vector[1] = full_elastic_vector_rotated[1];
-              monoclinic_and_higher_vector[2] = full_elastic_vector_rotated[2];
-              monoclinic_and_higher_vector[3] = full_elastic_vector_rotated[3];
-              monoclinic_and_higher_vector[4] = full_elastic_vector_rotated[4];
-              monoclinic_and_higher_vector[5] = full_elastic_vector_rotated[5];
-              monoclinic_and_higher_vector[6] = full_elastic_vector_rotated[6];
-              monoclinic_and_higher_vector[7] = full_elastic_vector_rotated[7];
-              monoclinic_and_higher_vector[8] = full_elastic_vector_rotated[8];
-              monoclinic_and_higher_vector[11] = full_elastic_vector_rotated[11];
-              monoclinic_and_higher_vector[14] = full_elastic_vector_rotated[14];
-              monoclinic_and_higher_vector[17] = full_elastic_vector_rotated[17];
-              monoclinic_and_higher_vector[20] = full_elastic_vector_rotated[20];
-
-              // The triclinic vector is the full elastic tensor minux the monoclinic and higher symmetry axes vector.
-              auto triclinic_vector = full_elastic_vector_rotated-monoclinic_and_higher_vector;
-              squared_norms_to_projections[0][permutation_i] = triclinic_vector.norm_square();
-
-              // Only the first 9 elements are now non-zero, so crop the vector to the first 9 elements.
-              // The following line would do the same as the lines below, but it is slow. It has therefore been
-              // replaced by the lines below.
-              //auto orthorhombic_and_higher_vector = projection_matrix_monoclinic_to_orthorhombic*monoclinic_and_higher_vector;
-              dealii::Tensor<1,9>  monoclinic_and_higher_vector_cropped;
-              monoclinic_and_higher_vector_cropped[0] = monoclinic_and_higher_vector[0];
-              monoclinic_and_higher_vector_cropped[1] = monoclinic_and_higher_vector[1];
-              monoclinic_and_higher_vector_cropped[2] = monoclinic_and_higher_vector[2];
-              monoclinic_and_higher_vector_cropped[3] = monoclinic_and_higher_vector[3];
-              monoclinic_and_higher_vector_cropped[4] = monoclinic_and_higher_vector[4];
-              monoclinic_and_higher_vector_cropped[5] = monoclinic_and_higher_vector[5];
-              monoclinic_and_higher_vector_cropped[6] = monoclinic_and_higher_vector[6];
-              monoclinic_and_higher_vector_cropped[7] = monoclinic_and_higher_vector[7];
-              monoclinic_and_higher_vector_cropped[8] = monoclinic_and_higher_vector[8];
-              dealii::Tensor<1,9> orthorhombic_and_higher_vector;
-              orthorhombic_and_higher_vector[0] = monoclinic_and_higher_vector[0];
-              orthorhombic_and_higher_vector[1] = monoclinic_and_higher_vector[1];
-              orthorhombic_and_higher_vector[2] = monoclinic_and_higher_vector[2];
-              orthorhombic_and_higher_vector[3] = monoclinic_and_higher_vector[3];
-              orthorhombic_and_higher_vector[4] = monoclinic_and_higher_vector[4];
-              orthorhombic_and_higher_vector[5] = monoclinic_and_higher_vector[5];
-              orthorhombic_and_higher_vector[6] = monoclinic_and_higher_vector[6];
-              orthorhombic_and_higher_vector[7] = monoclinic_and_higher_vector[7];
-              orthorhombic_and_higher_vector[8] = monoclinic_and_higher_vector[8];
-
-              // The monoclinic vector is the monoclinic and higher symmetry axes vector minux the orthoclinic and higher symmetry axes vector.
-              auto monoclinic_vector = monoclinic_and_higher_vector_cropped-orthorhombic_and_higher_vector;
-              squared_norms_to_projections[1][permutation_i] = monoclinic_vector.norm_square();
-
-
-              auto tetragonal_and_higher_vector = projection_matrix_orthorhombic_to_tetragonal*orthorhombic_and_higher_vector;
-              auto orthorhombic_vector = orthorhombic_and_higher_vector-tetragonal_and_higher_vector;
-              squared_norms_to_projections[2][permutation_i] = orthorhombic_vector.norm_square();
-
-              auto hexagonal_and_higher_vector = projection_matrix_tetragonal_to_hexagonal*tetragonal_and_higher_vector;
-              auto tetragonal_vector = tetragonal_and_higher_vector-hexagonal_and_higher_vector;
-              squared_norms_to_projections[3][permutation_i] = tetragonal_vector.norm_square();
-
-              auto isotropic_vector = projection_matrix_hexagonal_to_isotropic*hexagonal_and_higher_vector;
-              auto hexagonal_vector = hexagonal_and_higher_vector-isotropic_vector;
-              squared_norms_to_projections[4][permutation_i] = hexagonal_vector.norm_square();
-              squared_norms_to_projections[5][permutation_i] = isotropic_vector.norm_square();
-
-            }
-          return squared_norms_to_projections;
-
-        }
-      }
-
-
-
-      template <int dim>
-      void
-      ElasticTensorDecomposition<dim>::initialize ()
-      {
-        const Particle::Property::Manager<dim> &manager = this->get_particle_world(this->get_particle_world_index()).get_property_manager();
-        AssertThrow(manager.plugin_name_exists("crystal preferred orientation"),
-                    ExcMessage("No cpo property plugin found."));
-        AssertThrow(manager.plugin_name_exists("cpo elastic tensor"),
-                    ExcMessage("No cpo elastic tensor property plugin found."));
-
-        AssertThrow(manager.check_plugin_order("crystal preferred orientation","elastic tensor decomposition"),
-                    ExcMessage("To use the elastic tensor decomposition plugin, the cpo plugin needs to be defined before this plugin."));
-
-        AssertThrow(manager.check_plugin_order("cpo elastic tensor","elastic tensor decomposition"),
-                    ExcMessage("To use the elastic tensor decomposition plugin, the cpo elastic tensor plugin needs to be defined before this plugin."));
-
-        cpo_elastic_tensor_data_position = manager.get_data_info().get_position_by_plugin_index(manager.get_plugin_index_by_name("cpo elastic tensor"));
-      }
-
-
-
-      template <int dim>
-      void
-      ElasticTensorDecomposition<dim>::initialize_one_particle_property(const Point<dim> &,
-                                                                        std::vector<double> &data) const
-      {
-        const SymmetricTensor<2,6> elastic_matrix = Particle::Property::CpoElasticTensor<dim>::get_elastic_tensor(cpo_elastic_tensor_data_position,
-                                                    data);
-
-        const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = Property::Utilities::compute_dilatation_stiffness_tensor(elastic_matrix);
-        const SymmetricTensor<2,3> voigt_stiffness_tensor_full = Property::Utilities::compute_voigt_stiffness_tensor(elastic_matrix);
-        const Tensor<2,3> SCCS_full = Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
-
-        const std::array<std::array<double,3>,7 > norms = Property::Utilities::compute_elastic_tensor_SCCS_decompositions(SCCS_full, elastic_matrix);
-
-        // get max hexagonal element index, which is the same as the permutation index
-        const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
-        std::array<unsigned int, 3> permutation = Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
-        // reorder the SCCS be the SCCS permutation which yields the largest hexagonal vector (percentage of anisotropy)
-        Tensor<2,3> hexagonal_permutated_SCCS;
-        for (size_t index = 0; index < 3; ++index)
-          {
-            hexagonal_permutated_SCCS[index] = SCCS_full[permutation[index]];
-          }
-
-        data.push_back(SCCS_full[0][0]);
-        data.push_back(SCCS_full[0][1]);
-        data.push_back(SCCS_full[0][2]);
-        data.push_back(SCCS_full[1][0]);
-        data.push_back(SCCS_full[1][1]);
-        data.push_back(SCCS_full[1][2]);
-        data.push_back(SCCS_full[2][0]);
-        data.push_back(SCCS_full[2][1]);
-        data.push_back(SCCS_full[2][2]);
-        data.push_back(hexagonal_permutated_SCCS[2][0]);
-        data.push_back(hexagonal_permutated_SCCS[2][1]);
-        data.push_back(hexagonal_permutated_SCCS[2][2]);
-        data.push_back(norms[6][0]);
-        data.push_back(norms[0][0]); // triclinic
-        data.push_back(norms[0][1]); // triclinic
-        data.push_back(norms[0][2]); // triclinic
-        data.push_back(norms[1][0]); // monoclinic
-        data.push_back(norms[1][1]); // monoclinic
-        data.push_back(norms[1][2]); // monoclinic
-        data.push_back(norms[2][0]); // orthorhomic
-        data.push_back(norms[2][1]); // orthorhomic
-        data.push_back(norms[2][2]); // orthorhomic
-        data.push_back(norms[3][0]); // tetragonal
-        data.push_back(norms[3][1]); // tetragonal
-        data.push_back(norms[3][2]); // tetragonal
-        data.push_back(norms[4][0]); // hexagonal
-        data.push_back(norms[4][1]); // hexagonal
-        data.push_back(norms[4][2]); // hexagonal
-        data.push_back(norms[5][0]); // isotropic
-
-      }
-
-
-
-      template <int dim>
-      void
-      ElasticTensorDecomposition<dim>::update_particle_property(const unsigned int data_position,
-                                                                const Vector<double> &/*solution*/,
-                                                                const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                                                typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        ArrayView<double> data = particle->get_properties();
-        const SymmetricTensor<2,6> elastic_matrix = Particle::Property::CpoElasticTensor<dim>::get_elastic_tensor(cpo_elastic_tensor_data_position,
-                                                    data);
-
-        const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = Utilities::compute_dilatation_stiffness_tensor(elastic_matrix);
-        const SymmetricTensor<2,3> voigt_stiffness_tensor_full = Utilities::compute_voigt_stiffness_tensor(elastic_matrix);
-        const Tensor<2,3> SCCS_full = Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
-
-        const std::array<std::array<double,3>,7 > norms = Utilities::compute_elastic_tensor_SCCS_decompositions(SCCS_full, elastic_matrix);
-
-        // get max hexagonal element index, which is the same as the permutation index
-        const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
-        std::array<unsigned int, 3> permutation = Utilities::indexed_even_permutation(max_hexagonal_element_index);
-        // reorder the SCCS by the SCCS permutation which yields the largest hexagonal vector (percentage of anisotropy)
-        Tensor<2,3> hexagonal_permutated_SCCS;
-        for (size_t index = 0; index < 3; ++index)
-          {
-            hexagonal_permutated_SCCS[index] = SCCS_full[permutation[index]];
-          }
-
-        data[data_position]    = SCCS_full[0][0];
-        data[data_position+1]  = SCCS_full[0][1];
-        data[data_position+2]  = SCCS_full[0][2];
-        data[data_position+3]  = SCCS_full[1][0];
-        data[data_position+4]  = SCCS_full[1][1];
-        data[data_position+5]  = SCCS_full[1][2];
-        data[data_position+6]  = SCCS_full[2][0];
-        data[data_position+7]  = SCCS_full[2][1];
-        data[data_position+8]  = SCCS_full[2][2];
-        data[data_position+9]  = hexagonal_permutated_SCCS[2][0];
-        data[data_position+10] = hexagonal_permutated_SCCS[2][1];
-        data[data_position+11] = hexagonal_permutated_SCCS[2][2];
-        data[data_position+12] = norms[6][0];
-        data[data_position+13] = norms[0][0]; // triclinic
-        data[data_position+14] = norms[0][1]; // triclinic
-        data[data_position+15] = norms[0][2]; // triclinic
-        data[data_position+16] = norms[1][0]; // monoclinic
-        data[data_position+17] = norms[1][1]; // monoclinic
-        data[data_position+18] = norms[1][2]; // monoclinic
-        data[data_position+19] = norms[2][0]; // orthorhomic
-        data[data_position+20] = norms[2][1]; // orthorhomic
-        data[data_position+21] = norms[2][2]; // orthorhomic
-        data[data_position+22] = norms[3][0]; // tetragonal
-        data[data_position+23] = norms[3][1]; // tetragonal
-        data[data_position+24] = norms[3][2]; // tetragonal
-        data[data_position+25] = norms[4][0]; // hexagonal
-        data[data_position+26] = norms[4][1]; // hexagonal
-        data[data_position+27] = norms[4][2]; // hexagonal
-        data[data_position+28] = norms[5][0]; // isotropic
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      ElasticTensorDecomposition<dim>::need_update() const
-      {
-        return update_output_step;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      ElasticTensorDecomposition<dim>::get_property_information() const
-      {
-        std::vector<std::pair<std::string,unsigned int>> property_information =
-        {
-          {"cpo elastic axis e1",3},
-          {"cpo elastic axis e2",3},
-          {"cpo elastic axis e3",3},
-          {"cpo elastic hexagonal axis",3},
-          {"cpo elastic vector norm square",1},
-          {"cpo elastic triclinic vector norm square p1",1},
-          {"cpo elastic triclinic vector norm square p2",1},
-          {"cpo elastic triclinic vector norm square p3",1},
-          {"cpo elastic monoclinic vector norm square p1",1},
-          {"cpo elastic monoclinic vector norm square p2",1},
-          {"cpo elastic monoclinic vector norm square p3",1},
-          {"cpo elastic orthorhombic vector norm square p1",1},
-          {"cpo elastic orthorhombic vector norm square p2",1},
-          {"cpo elastic orthorhombic vector norm square p3",1},
-          {"cpo elastic tetragonal vector norm square p1",1},
-          {"cpo elastic tetragonal vector norm square p2",1},
-          {"cpo elastic tetragonal vector norm square p3",1},
-          {"cpo elastic hexagonal vector norm square p1",1},
-          {"cpo elastic hexagonal vector norm square p2",1},
-          {"cpo elastic hexagonal vector norm square p3",1},
-          {"cpo elastic isotropic vector norm square",1}
-        };
-
-        return property_information;
-      }
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(ElasticTensorDecomposition,
-                                        "elastic tensor decomposition",
-                                        "A plugin which decomposes the elastic tensor into different approximations "
-                                        "(Isotropic, Hexagonal, Tetragonal, Orthorhombic, Monoclinic and Triclinic) "
-                                        "and provides the eigenvectors of the tensor.")
-    }
-  }
-}
diff --git a/source/particle/property/function.cc.bak b/source/particle/property/function.cc.bak
deleted file mode 100644
index d88dd252001..00000000000
--- a/source/particle/property/function.cc.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/function.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      Function<dim>::Function()
-        :
-        n_components (0)
-      {}
-
-      template <int dim>
-      void
-      Function<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                      std::vector<double> &data) const
-      {
-        for (unsigned int i = 0; i < n_components; ++i)
-          data.push_back(function->value(position, i));
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      Function<dim>::get_property_information() const
-      {
-        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("function",n_components));
-        return property_information;
-      }
-
-
-      template <int dim>
-      void
-      Function<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Function");
-        {
-          prm.declare_entry ("Number of components", "1",
-                             Patterns::Integer (0),
-                             "The number of function components where each component is described "
-                             "by a function expression delimited by a ';'.");
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      Function<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Function");
-        n_components = prm.get_integer ("Number of components");
-        try
-          {
-            function = std::make_unique<Functions::ParsedFunction<dim>>(n_components);
-            function->parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Particles.Function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'";
-            throw;
-          }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(Function,
-                                        "function",
-                                        "Implementation of a model in which the particle "
-                                        "property is set by evaluating an explicit function "
-                                        "at the initial position of each particle. The "
-                                        "function is defined in the parameters in section "
-                                        "``Particles|Function''. The format of these "
-                                        "functions follows the syntax understood by the "
-                                        "muparser library, see "
-                                        "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-    }
-  }
-}
diff --git a/source/particle/property/grain_size.cc.bak b/source/particle/property/grain_size.cc.bak
deleted file mode 100644
index 145d00f267c..00000000000
--- a/source/particle/property/grain_size.cc.bak
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/grain_size.h>
-#include <aspect/material_model/grain_size.h>
-#include <aspect/initial_composition/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      GrainSize<dim>::GrainSize ()
-        :
-        material_inputs(1,0),
-        material_outputs(1,0)
-      {}
-
-
-
-      template <int dim>
-      void
-      GrainSize<dim>::initialize ()
-      {
-        material_inputs  = MaterialModel::MaterialModelInputs<dim>(1, this->n_compositional_fields());
-        material_outputs = MaterialModel::MaterialModelOutputs<dim>(1, this->n_compositional_fields());
-
-        AssertThrow(this->introspection().compositional_name_exists("grain_size"),
-                    ExcMessage("This particle property only makes sense if "
-                               "there is a compositional field named 'grain_size'."));
-
-        grain_size_index = this->introspection().compositional_index_for_name("grain_size");
-      }
-
-
-
-      template <int dim>
-      void
-      GrainSize<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                       std::vector<double> &data) const
-      {
-        // Set the initial composition to the initial grain size.
-        data.push_back(this->get_initial_composition_manager().initial_composition(position,grain_size_index));
-      }
-
-
-
-      template <int dim>
-      void
-      GrainSize<dim>::update_particle_properties(const unsigned int data_position,
-                                                 const std::vector<Vector<double>> &solution,
-                                                 const std::vector<std::vector<Tensor<1,dim>>> &gradients,
-                                                 typename ParticleHandler<dim>::particle_iterator_range &particles) const
-      {
-        material_inputs  = MaterialModel::MaterialModelInputs<dim>(solution.size(), this->n_compositional_fields());
-        material_outputs = MaterialModel::MaterialModelOutputs<dim>(solution.size(), this->n_compositional_fields());
-        material_inputs.requested_properties = MaterialModel::MaterialProperties::reaction_terms;
-        material_inputs.current_cell = typename DoFHandler<dim>::active_cell_iterator(*particles.begin()->get_surrounding_cell(),
-                                                                                      &(this->get_dof_handler()));
-
-        unsigned int i = 0;
-        for (auto particle: particles)
-          {
-            // Make sure all particles are in the same cell
-            Assert(particle.get_surrounding_cell() == particles.begin()->get_surrounding_cell(),
-                   ExcMessage("All particles must be in the same cell."));
-
-            material_inputs.position[i] = particle.get_location();
-            material_inputs.temperature[i] = solution[i][this->introspection().component_indices.temperature];
-            material_inputs.pressure[i] = solution[i][this->introspection().component_indices.pressure];
-
-            for (unsigned int d = 0; d < dim; ++d)
-              material_inputs.velocity[i][d] = solution[i][this->introspection().component_indices.velocities[d]];
-
-            for (unsigned int n = 0; n < this->n_compositional_fields(); ++n)
-              material_inputs.composition[i][n] = solution[i][this->introspection().component_indices.compositional_fields[n]];
-
-            material_inputs.composition[i][grain_size_index] = particle.get_properties()[data_position];
-
-            Tensor<2,dim> grad_u;
-            for (unsigned int d=0; d<dim; ++d)
-              grad_u[d] = gradients[i][d];
-            material_inputs.strain_rate[i] = symmetrize (grad_u);
-
-            ++i;
-          }
-
-        this->get_material_model().evaluate(material_inputs,
-                                            material_outputs);
-
-        i = 0;
-        for (auto particle: particles)
-          {
-            particle.get_properties()[data_position] += material_outputs.reaction_terms[i][grain_size_index];
-            ++i;
-          }
-      }
-
-
-
-      template <int dim>
-      InitializationModeForLateParticles
-      GrainSize<dim>::late_initialization_mode () const
-      {
-        return interpolate_respect_boundary;
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      GrainSize<dim>::need_update() const
-      {
-        return update_time_step;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      GrainSize<dim>::get_needed_update_flags () const
-      {
-        return update_values | update_gradients;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      GrainSize<dim>::get_property_information() const
-      {
-        return {{"grain_size",1}};
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(GrainSize,
-                                        "grain size",
-                                        "A plugin in which the particle property is "
-                                        "defined as the evolving grain size of a particle. "
-                                        "See the grain_size material model "
-                                        "documentation for more detailed information.")
-
-    }
-  }
-}
diff --git a/source/particle/property/initial_composition.cc.bak b/source/particle/property/initial_composition.cc.bak
deleted file mode 100644
index 4c603e02744..00000000000
--- a/source/particle/property/initial_composition.cc.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/initial_composition.h>
-#include <aspect/initial_composition/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      InitialComposition<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                                std::vector<double> &data) const
-      {
-        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
-          data.push_back(this->get_initial_composition_manager().initial_composition(position,i));
-      }
-
-
-
-      template <int dim>
-      InitializationModeForLateParticles
-      InitialComposition<dim>::late_initialization_mode () const
-      {
-        return interpolate_respect_boundary;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      InitialComposition<dim>::get_property_information() const
-      {
-        AssertThrow(this->n_compositional_fields() > 0,
-                    ExcMessage("You have requested the particle property <initial "
-                               "composition>, but the number of compositional fields is 0. "
-                               "Please add compositional fields to your model, or remove "
-                               "this particle property."));
-
-        std::vector<std::pair<std::string,unsigned int>> property_information;
-
-        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
-          {
-            std::ostringstream field_name;
-            field_name << "initial " << this->introspection().name_for_compositional_index(i);
-            property_information.emplace_back(field_name.str(),1);
-          }
-
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(InitialComposition,
-                                        "initial composition",
-                                        "Implementation of a plugin in which the particle "
-                                        "property is given as the initial composition "
-                                        "at the particle's initial position. The particle "
-                                        "gets as many properties as there are "
-                                        "compositional fields.")
-    }
-  }
-}
diff --git a/source/particle/property/initial_position.cc.bak b/source/particle/property/initial_position.cc.bak
deleted file mode 100644
index ee44d3f0874..00000000000
--- a/source/particle/property/initial_position.cc.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/global.h>
-#include <aspect/particle/property/initial_position.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      InitialPosition<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                             std::vector<double> &data) const
-      {
-        for (unsigned int i = 0; i < dim; ++i)
-          data.push_back(position[i]);
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      InitialPosition<dim>::get_property_information() const
-      {
-        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("initial position",static_cast<unsigned int> (dim)));
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(InitialPosition,
-                                        "initial position",
-                                        "Implementation of a plugin in which the particle "
-                                        "property is given as the initial position "
-                                        "of the particle. This property is vector-valued with "
-                                        "as many components as there are space dimensions. "
-                                        "In practice, it is often most useful to only "
-                                        "visualize one of the components of this vector, "
-                                        "or the magnitude of the vector. For example, in "
-                                        "a spherical mantle simulation, the magnitude of this "
-                                        "property equals the starting radius of a particle, "
-                                        "and is thereby indicative of which part of the "
-                                        "mantle a particle comes from.")
-    }
-  }
-}
diff --git a/source/particle/property/integrated_strain.cc.bak b/source/particle/property/integrated_strain.cc.bak
deleted file mode 100644
index 7afa788bad3..00000000000
--- a/source/particle/property/integrated_strain.cc.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/integrated_strain.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      IntegratedStrain<dim>::initialize_one_particle_property(const Point<dim> &,
-                                                              std::vector<double> &data) const
-      {
-        const static Tensor<2,dim> identity = unit_symmetric_tensor<dim>();
-        for (unsigned int i = 0; i < Tensor<2,dim>::n_independent_components ; ++i)
-          data.push_back(identity[Tensor<2,dim>::unrolled_to_component_indices(i)]);
-      }
-
-      template <int dim>
-      void
-      IntegratedStrain<dim>::update_particle_property(const unsigned int data_position,
-                                                      const Vector<double> &/*solution*/,
-                                                      const std::vector<Tensor<1,dim>> &gradients,
-                                                      typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        const Tensor<2,dim> old_strain(make_array_view(&particle->get_properties()[data_position],
-                                                       &particle->get_properties()[data_position] + Tensor<2,dim>::n_independent_components));
-
-        Tensor<2,dim> grad_u;
-        for (unsigned int d=0; d<dim; ++d)
-          grad_u[d] = gradients[d];
-
-        const double dt = this->get_timestep();
-
-        Tensor<2,dim> new_strain;
-
-        // here we integrate the equation
-        // new_deformation_gradient = velocity_gradient * old_deformation_gradient
-        // using a RK4 integration scheme.
-        const Tensor<2,dim> k1 = grad_u * old_strain * dt;
-        new_strain = old_strain + 0.5*k1;
-
-        const Tensor<2,dim> k2 = grad_u * new_strain * dt;
-        new_strain = old_strain + 0.5*k2;
-
-        const Tensor<2,dim> k3 = grad_u * new_strain * dt;
-        new_strain = old_strain + k3;
-
-        const Tensor<2,dim> k4 = grad_u * new_strain * dt;
-
-        // the new strain is the rotated old strain plus the
-        // strain of the current time step
-        new_strain = old_strain + (k1 + 2.0*k2 + 2.0*k3 + k4)/6.0;
-
-        // unroll and store the new strain
-        new_strain.unroll(&particle->get_properties()[data_position],
-                          &particle->get_properties()[data_position] + Tensor<2,dim>::n_independent_components);
-      }
-
-      template <int dim>
-      UpdateTimeFlags
-      IntegratedStrain<dim>::need_update() const
-      {
-        return update_time_step;
-      }
-
-      template <int dim>
-      UpdateFlags
-      IntegratedStrain<dim>::get_needed_update_flags () const
-      {
-        return update_gradients;
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      IntegratedStrain<dim>::get_property_information() const
-      {
-        const unsigned int n_components = Tensor<2,dim>::n_independent_components;
-        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("integrated strain",n_components));
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(IntegratedStrain,
-                                        "integrated strain",
-                                        "A plugin in which the particle property tensor is "
-                                        "defined as the deformation gradient tensor "
-                                        "$\\mathbf F$ this particle has experienced. "
-                                        "$\\mathbf F$ can be polar-decomposed into the left stretching tensor "
-                                        "$\\mathbf L$ (the finite strain we are interested in), and the "
-                                        "rotation tensor $\\mathbf Q$. See the corresponding cookbook in "
-                                        "the manual for more detailed information.")
-    }
-  }
-}
diff --git a/source/particle/property/integrated_strain_invariant.cc.bak b/source/particle/property/integrated_strain_invariant.cc.bak
deleted file mode 100644
index a0d13bb0f82..00000000000
--- a/source/particle/property/integrated_strain_invariant.cc.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/integrated_strain_invariant.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      IntegratedStrainInvariant<dim>::initialize_one_particle_property(const Point<dim> &,
-                                                                       std::vector<double> &data) const
-      {
-        data.push_back(0.0);
-      }
-
-
-
-      template <int dim>
-      void
-      IntegratedStrainInvariant<dim>::update_particle_property(const unsigned int data_position,
-                                                               const Vector<double> &/*solution*/,
-                                                               const std::vector<Tensor<1,dim>> &gradients,
-                                                               typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        // Integrated strain invariant from prior time step
-        const auto data = particle->get_properties();
-        double old_strain = data[data_position];
-
-        // Current timestep
-        const double dt = this->get_timestep();
-
-        // Velocity gradients
-        Tensor<2,dim> grad_u;
-        for (unsigned int d=0; d<dim; ++d)
-          grad_u[d] = gradients[d];
-
-        // Calculate strain rate from velocity gradients
-        const SymmetricTensor<2,dim> strain_rate = symmetrize (grad_u);
-
-        // Calculate strain rate second invariant
-        const double edot_ii = std::sqrt(std::max(-second_invariant(deviator(strain_rate)), 0.));
-
-        // New strain is the old strain plus dt*edot_ii
-        const double new_strain = old_strain + dt*edot_ii;
-        data[data_position] = new_strain;
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      IntegratedStrainInvariant<dim>::need_update() const
-      {
-        return update_time_step;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      IntegratedStrainInvariant<dim>::get_needed_update_flags () const
-      {
-        return update_gradients;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      IntegratedStrainInvariant<dim>::get_property_information() const
-      {
-        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("integrated strain invariant",1));
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(IntegratedStrainInvariant,
-                                        "integrated strain invariant",
-                                        "A plugin in which the particle property is defined as "
-                                        "the finite strain invariant ($\\varepsilon_{ii}$). "
-                                        "This property is calculated with the timestep ($dt$) and "
-                                        "the second invariant of the deviatoric strain rate tensor "
-                                        "($\\dot{\\varepsilon}_{ii}$), where the value at time step $n$ is "
-                                        "$\\varepsilon_{ii}^{n} = \\varepsilon_{ii}^{n-1} + "
-                                        "dt\\dot{\\varepsilon}_{ii}$.")
-    }
-  }
-}
diff --git a/source/particle/property/interface.cc.bak b/source/particle/property/interface.cc.bak
deleted file mode 100644
index 47027dc7d45..00000000000
--- a/source/particle/property/interface.cc.bak
+++ /dev/null
@@ -1,820 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/interface.h>
-#include <aspect/utilities.h>
-
-#include <aspect/particle/integrator/euler.h>
-#include <aspect/particle/integrator/rk_2.h>
-#include <aspect/particle/integrator/rk_4.h>
-
-
-#include <aspect/boundary_composition/interface.h>
-
-#include <deal.II/grid/grid_tools.h>
-
-#include <list>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ParticlePropertyInformation::ParticlePropertyInformation()
-        :
-        number_of_components(numbers::invalid_unsigned_int),
-        number_of_fields(numbers::invalid_unsigned_int),
-        number_of_plugins(numbers::invalid_unsigned_int)
-      {}
-
-
-
-      ParticlePropertyInformation::ParticlePropertyInformation(const std::vector<
-                                                               std::vector<
-                                                               std::pair<std::string,unsigned int>>> &properties)
-      {
-        unsigned int global_component_index = 0;
-        for (const auto &property : properties)
-          {
-            unsigned int component_per_plugin = 0;
-            unsigned int field_per_plugin = 0;
-
-            position_per_plugin.push_back(global_component_index);
-
-            for (const auto &entry : property)
-              {
-                const std::string  name         = entry.first;
-                const unsigned int n_components = entry.second;
-
-                field_names.push_back(name);
-                components_per_field.push_back(n_components);
-                position_per_field.push_back(global_component_index);
-                component_per_plugin += n_components;
-                global_component_index += n_components;
-                ++field_per_plugin;
-              }
-
-            fields_per_plugin.push_back(field_per_plugin);
-            components_per_plugin.push_back(component_per_plugin);
-          }
-
-        number_of_components = global_component_index;
-        number_of_fields = field_names.size();
-        number_of_plugins = properties.size();
-      }
-
-
-
-      bool
-      ParticlePropertyInformation::fieldname_exists(const std::string &name) const
-      {
-        return (std::find(field_names.begin(),field_names.end(),name) != field_names.end());
-      }
-
-      unsigned int
-      ParticlePropertyInformation::get_field_index_by_name(const std::string &name) const
-      {
-        const std::vector<std::string>::const_iterator field = std::find(field_names.begin(),
-                                                                         field_names.end(),
-                                                                         name);
-
-        AssertThrow(field != field_names.end(),
-                    ExcMessage("The particle property manager was asked for a property "
-                               "field with the name <" + name + ">, but no such field could "
-                               "be found."));
-        return std::distance(field_names.begin(),field);
-      }
-
-      std::string
-      ParticlePropertyInformation::get_field_name_by_index(const unsigned int field_index) const
-      {
-        Assert(field_index < field_names.size(),
-               ExcMessage("The number of field names (" + std::to_string(field_names.size())
-                          + ") is smaller than the requested field index ("
-                          + std::to_string(field_index) + ")."));
-
-        return field_names[field_index];
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::get_position_by_field_name(const std::string &name) const
-      {
-        const unsigned int field_index = get_field_index_by_name(name);
-        return position_per_field[field_index];
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::get_components_by_field_name(const std::string &name) const
-      {
-        const unsigned int field_index = get_field_index_by_name(name);
-        return components_per_field[field_index];
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::get_position_by_field_index(const unsigned int field_index) const
-      {
-        return position_per_field[field_index];
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::get_components_by_field_index(const unsigned int field_index) const
-      {
-        return components_per_field[field_index];
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::get_position_by_plugin_index(const unsigned int plugin_index) const
-      {
-        return position_per_plugin[plugin_index];
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::get_components_by_plugin_index(const unsigned int plugin_index) const
-      {
-        return components_per_plugin[plugin_index];
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::get_fields_by_plugin_index(const unsigned int plugin_index) const
-      {
-        return fields_per_plugin[plugin_index];
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::n_plugins() const
-      {
-        return number_of_plugins;
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::n_fields() const
-      {
-        return number_of_fields;
-      }
-
-
-
-      unsigned int
-      ParticlePropertyInformation::n_components() const
-      {
-        return number_of_components;
-      }
-
-
-
-      template <int dim>
-      void
-      Interface<dim>::initialize_one_particle_property (const Point<dim> &,
-                                                        std::vector<double> &) const
-      {}
-
-
-
-      DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-      template <int dim>
-      void
-      Interface<dim>::update_particle_properties (const unsigned int data_position,
-                                                  const std::vector<Vector<double>> &solution,
-                                                  const std::vector<std::vector<Tensor<1,dim>>> &gradients,
-                                                  typename ParticleHandler<dim>::particle_iterator_range &particles) const
-      {
-        unsigned int i = 0;
-        for (typename ParticleHandler<dim>::particle_iterator particle = particles.begin();
-             particle != particles.end(); ++particle, ++i)
-          {
-            // call the deprecated version of this function
-            update_particle_property(data_position,
-                                     solution[i],
-                                     gradients[i],
-                                     particle);
-          }
-      }
-      DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-
-
-
-      template <int dim>
-      void
-      Interface<dim>::update_particle_property (const unsigned int /*data_position*/,
-                                                const Vector<double> &/*solution*/,
-                                                const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                                typename ParticleHandler<dim>::particle_iterator &/*particle*/) const
-      {}
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      Interface<dim>::need_update () const
-      {
-        return update_never;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      Interface<dim>::get_needed_update_flags () const
-      {
-        return update_default;
-      }
-
-
-
-      template <int dim>
-      InitializationModeForLateParticles
-      Interface<dim>::late_initialization_mode () const
-      {
-        return interpolate;
-      }
-
-
-
-      template <int dim>
-      void
-      IntegratorProperties<dim>::initialize_one_particle_property(const Point<dim> &/*position*/,
-                                                                  std::vector<double> &data) const
-      {
-        data.resize(data.size() + n_integrator_properties, 0.0);
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      IntegratorProperties<dim>::get_property_information() const
-      {
-        return {{"internal: integrator properties", n_integrator_properties}};
-      }
-
-
-
-      template <int dim>
-      void
-      IntegratorProperties<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        std::string name;
-        name = prm.get ("Integration scheme");
-
-        if (name == "rk2")
-          n_integrator_properties = Particle::Integrator::RK2<dim>::n_integrator_properties;
-        else if (name == "rk4")
-          n_integrator_properties = Particle::Integrator::RK4<dim>::n_integrator_properties;
-        else if (name == "euler")
-          n_integrator_properties = Particle::Integrator::Euler<dim>::n_integrator_properties;
-        else
-          AssertThrow(false,
-                      ExcMessage("Unknown integrator scheme. The particle property 'Integrator properties' "
-                                 "does not know how many particle properties to store for this integration scheme."));
-      }
-
-
-
-      template <int dim>
-      inline
-      Manager<dim>::Manager ()
-        = default;
-
-
-
-      template <int dim>
-      inline
-      Manager<dim>::~Manager ()
-        = default;
-
-
-
-      template <int dim>
-      void
-      Manager<dim>::initialize ()
-      {
-        std::vector<std::vector<std::pair<std::string, unsigned int>>> info;
-
-        // Get the property information of the selected plugins
-        for (const auto &p : this->plugin_objects)
-          {
-            info.push_back(p->get_property_information());
-          }
-
-        // Initialize our property information
-        property_information = ParticlePropertyInformation(info);
-        for (const auto &p : this->plugin_objects)
-          {
-            p->initialize();
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      Manager<dim>::update ()
-      {
-        for (const auto &p : this->plugin_objects)
-          p->update();
-      }
-
-
-
-      template <int dim>
-      void
-      Manager<dim>::initialize_one_particle (typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        if (property_information.n_components() == 0)
-          return;
-
-        std::vector<double> particle_properties;
-        particle_properties.reserve(property_information.n_components());
-
-        for (const auto &p : this->plugin_objects)
-          {
-            p->initialize_one_particle_property(particle->get_location(),
-                                                particle_properties);
-          }
-
-        Assert(particle_properties.size() == property_information.n_components(),
-               ExcMessage("The reported numbers of particle property components do not sum up "
-                          "to the number of particle properties that were initialized by "
-                          "the property plugins. Check the selected property plugins for "
-                          "consistency between reported size and actually set properties."));
-
-        particle->set_properties(particle_properties);
-      }
-
-
-
-      template <int dim>
-      std::vector<double>
-      Manager<dim>::initialize_late_particle (const Point<dim> &particle_location,
-                                              const ParticleHandler<dim> &particle_handler,
-                                              const Interpolator::Interface<dim> &interpolator,
-                                              const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell) const
-      {
-        if (property_information.n_components() == 0)
-          return {};
-
-        std::vector<double> particle_properties;
-        particle_properties.reserve(property_information.n_components());
-
-        unsigned int property_index = 0;
-        for (typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
-             p = this->plugin_objects.begin(); p!=this->plugin_objects.end(); ++p, ++property_index)
-          {
-            switch ((*p)->late_initialization_mode())
-              {
-                case aspect::Particle::Property::initialize_to_zero:
-                {
-                  for (unsigned int property_component = 0; property_component < property_information.get_components_by_plugin_index(property_index); ++property_component)
-                    particle_properties.push_back(0.0);
-                  break;
-                }
-
-                case aspect::Particle::Property::initialize:
-                {
-                  (*p)->initialize_one_particle_property(particle_location,
-                                                         particle_properties);
-                  break;
-                }
-
-                case aspect::Particle::Property::interpolate:
-                {
-                  typename parallel::distributed::Triangulation<dim>::cell_iterator found_cell;
-
-                  if (cell == typename parallel::distributed::Triangulation<dim>::active_cell_iterator())
-                    {
-                      found_cell = (GridTools::find_active_cell_around_point<> (this->get_mapping(),
-                                                                                this->get_triangulation(),
-                                                                                particle_location)).first;
-                    }
-                  else
-                    found_cell = cell;
-
-                  std::vector<std::vector<double>> interpolated_properties;
-
-                  try
-                    {
-                      interpolated_properties = interpolator.properties_at_points(particle_handler,
-                                                                                  std::vector<Point<dim>> (1,particle_location),
-                                                                                  ComponentMask(property_information.n_components(),true),
-                                                                                  found_cell);
-                    }
-                  // interpolators that throw exceptions usually do not result in
-                  // anything good, because they result in an unwinding of the stack
-                  // and, if only one processor triggers an exception, the
-                  // destruction of objects often causes a deadlock or completely
-                  // unrelated MPI error messages. Thus, if an exception is
-                  // generated, catch it, print an error message, and abort the program.
-                  catch (std::exception &exc)
-                    {
-                      std::cerr << std::endl << std::endl
-                                << "----------------------------------------------------"
-                                << std::endl;
-                      std::cerr << "Exception on MPI process <"
-                                << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                                << "> while generating new particle properties: "
-                                << std::endl
-                                << exc.what() << std::endl
-                                << "Aborting!" << std::endl
-                                << "----------------------------------------------------"
-                                << std::endl;
-
-                      // terminate the program!
-                      MPI_Abort (MPI_COMM_WORLD, 1);
-                    }
-
-                  for (unsigned int property_component = 0; property_component < property_information.get_components_by_plugin_index(property_index); ++property_component)
-                    particle_properties.push_back(interpolated_properties[0][property_information.get_position_by_plugin_index(property_index)+property_component]);
-                  break;
-                }
-
-                case aspect::Particle::Property::interpolate_respect_boundary:
-                {
-                  typename parallel::distributed::Triangulation<dim>::cell_iterator found_cell;
-
-                  if (cell == typename parallel::distributed::Triangulation<dim>::active_cell_iterator())
-                    {
-                      found_cell = (GridTools::find_active_cell_around_point<> (this->get_mapping(),
-                                                                                this->get_triangulation(),
-                                                                                particle_location)).first;
-                    }
-                  else
-                    found_cell = cell;
-
-                  const auto &manager = this->get_boundary_composition_manager();
-                  const auto &fixed_boundaries = manager.get_fixed_composition_boundary_indicators();
-
-                  // Determine if the current cell is at a Dirichlet boundary
-                  bool cell_at_fixed_boundary = false;
-                  unsigned int boundary_face = numbers::invalid_unsigned_int;
-                  double minimum_face_distance = std::numeric_limits<double>::max();
-                  for (const unsigned int f : cell->face_indices())
-                    if (cell->at_boundary(f) && fixed_boundaries.count(cell->face(f)->boundary_id()) == 1)
-                      {
-                        const double face_center_distance = particle_location.distance_square(cell->face(f)->center(true));
-                        if (face_center_distance < minimum_face_distance)
-                          {
-                            minimum_face_distance = face_center_distance;
-                            boundary_face = f;
-                            cell_at_fixed_boundary = true;
-                          }
-                      }
-
-                  // If no Dirichlet boundary, interpolate
-                  if (cell_at_fixed_boundary == false)
-                    {
-                      const std::vector<std::vector<double>> interpolated_properties = interpolator.properties_at_points(particle_handler,
-                                                                                        std::vector<Point<dim>> (1,particle_location),
-                                                                                        ComponentMask(property_information.n_components(),true),
-                                                                                        found_cell);
-                      for (unsigned int property_component = 0; property_component < property_information.get_components_by_plugin_index(property_index); ++property_component)
-                        particle_properties.push_back(interpolated_properties[0][property_information.get_position_by_plugin_index(property_index)+property_component]);
-                    }
-                  // Otherwise use the boundary condition
-                  else
-                    {
-                      Assert(property_information.get_components_by_plugin_index(property_index) == this->n_compositional_fields(),
-                             ExcInternalError());
-
-                      const types::boundary_id boundary_id = cell->face(boundary_face)->boundary_id();
-
-                      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                        {
-                          const double composition = manager.boundary_composition(boundary_id,particle_location,c);
-                          particle_properties.push_back(composition);
-                        }
-                    }
-
-                  break;
-                }
-
-                default:
-                  Assert (false, ExcInternalError());
-              }
-          }
-
-        Assert (particle_properties.size() == property_information.n_components(), ExcInternalError());
-
-        return particle_properties;
-      }
-
-
-
-      template <int dim>
-      void
-      Manager<dim>::update_particles (typename ParticleHandler<dim>::particle_iterator_range &particles,
-                                      const std::vector<Vector<double>> &solution,
-                                      const std::vector<std::vector<Tensor<1,dim>>> &gradients) const
-      {
-        unsigned int plugin_index = 0;
-        for (typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
-             p = this->plugin_objects.begin(); p!=this->plugin_objects.end(); ++p,++plugin_index)
-          {
-            (*p)->update_particle_properties(property_information.get_position_by_plugin_index(plugin_index),
-                                             solution,
-                                             gradients,
-                                             particles);
-          }
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      Manager<dim>::need_update () const
-      {
-        UpdateTimeFlags update = update_never;
-        for (const auto &p : this->plugin_objects)
-          {
-            update = std::max(update, p->need_update());
-          }
-        return update;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      Manager<dim>::get_needed_update_flags () const
-      {
-        UpdateFlags update = update_default;
-        for (const auto &p : this->plugin_objects)
-          {
-            update |= p->get_needed_update_flags();
-          }
-
-        return (update & (update_default | update_values | update_gradients));
-      }
-
-
-
-      template <int dim>
-      bool
-      Manager<dim>::plugin_name_exists(const std::string &name) const
-      {
-        return (std::find(plugin_names.begin(),plugin_names.end(),name) != plugin_names.end());
-      }
-
-
-
-      template <int dim>
-      bool
-      Manager<dim>::check_plugin_order(const std::string &first, const std::string &second) const
-      {
-
-        AssertThrow(first != second,
-                    ExcMessage("The first and second string are the same, so can not check the order."));
-        AssertThrow(plugin_name_exists(first),
-                    ExcMessage("Could not find a plugin with the name <" + first + ">."));
-        AssertThrow(plugin_name_exists(second),
-                    ExcMessage("Could not find a plugin with the name <" + second + ">."));
-
-        return (std::find(plugin_names.begin(),plugin_names.end(),first)
-                < std::find(plugin_names.begin(),plugin_names.end(),second));
-      }
-
-
-
-      template <int dim>
-      unsigned int
-      Manager<dim>::get_plugin_index_by_name(const std::string &name) const
-      {
-        const std::vector<std::string>::const_iterator plugin = std::find(plugin_names.begin(),
-                                                                          plugin_names.end(),
-                                                                          name);
-
-        AssertThrow(plugin != plugin_names.end(),
-                    ExcMessage("The particle property manager was asked for a plugin "
-                               "with the name <" + name + ">, but no such plugin could "
-                               "be found."));
-        return std::distance(plugin_names.begin(),plugin);
-      }
-
-
-
-      template <int dim>
-      unsigned int
-      Manager<dim>::get_n_property_components () const
-      {
-        return property_information.n_components();
-      }
-
-
-
-      template <int dim>
-      std::size_t
-      Manager<dim>::get_particle_size () const
-      {
-        return (property_information.n_components()+2*dim) * sizeof(double) + sizeof(types::particle_index);
-      }
-
-
-
-      template <int dim>
-      const ParticlePropertyInformation &
-      Manager<dim>::get_data_info () const
-      {
-        return property_information;
-      }
-
-
-
-      template <int dim>
-      unsigned int
-      Manager<dim>::get_property_component_by_name(const std::string &name) const
-      {
-        return property_information.get_position_by_field_name(name);
-      }
-
-
-
-      namespace
-      {
-        std::tuple
-        <void *,
-        void *,
-        aspect::internal::Plugins::PluginList<Property::Interface<2>>,
-        aspect::internal::Plugins::PluginList<Property::Interface<3>>> registered_plugins;
-      }
-
-
-
-      template <int dim>
-      void
-      Manager<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        // finally also construct a string for Patterns::MultipleSelection that
-        // contains the names of all registered particle properties
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry("List of particle properties",
-                          "",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma separated list of particle properties that should be tracked. "
-                          "By default none is selected, which means only position, velocity "
-                          "and id of the particles are output. \n\n"
-                          "The following properties are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-
-        // now declare the parameters of each of the registered
-        // particle properties in turn
-        std::get<dim>(registered_plugins).declare_parameters (prm);
-      }
-
-
-
-      template <int dim>
-      void
-      Manager<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        Assert (std::get<dim>(registered_plugins).plugins != nullptr,
-                ExcMessage ("No postprocessors registered!?"));
-
-        // now also see which derived quantities we are to compute
-        plugin_names = Utilities::split_string_list(prm.get("List of particle properties"));
-        AssertThrow(Utilities::has_unique_entries(plugin_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Particles/List of particle properties' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-
-        // see if 'all' was selected (or is part of the list). if so
-        // simply replace the list with one that contains all names
-        if (std::find (plugin_names.begin(),
-                       plugin_names.end(),
-                       "all") != plugin_names.end())
-          {
-            plugin_names.clear();
-            for (typename std::list<typename aspect::internal::Plugins::PluginList<aspect::Particle::Property::Interface<dim>>::PluginInfo>::const_iterator
-                 p = std::get<dim>(registered_plugins).plugins->begin();
-                 p != std::get<dim>(registered_plugins).plugins->end(); ++p)
-              plugin_names.push_back (std::get<0>(*p));
-          }
-
-        // then go through the list, create objects and let them parse
-        // their own parameters
-        for (auto &plugin_name : plugin_names)
-          {
-            this->plugin_objects.emplace_back (std::get<dim>(registered_plugins)
-                                               .create_plugin (plugin_name,
-                                                               "Particle property plugins"));
-
-            if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(this->plugin_objects.back().get()))
-              sim->initialize_simulator (this->get_simulator());
-
-            this->plugin_objects.back()->parse_parameters (prm);
-          }
-
-        // lastly store internal integrator properties
-        this->plugin_objects.emplace_back (std::make_unique<IntegratorProperties<dim>>());
-        this->plugin_objects.back()->parse_parameters (prm);
-      }
-
-
-
-      template <int dim>
-      void
-      Manager<dim>::set_particle_world_index(unsigned int particle_world_index)
-      {
-        for (auto &property : this->plugin_objects)
-          {
-            property->set_particle_world_index(particle_world_index);
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      Manager<dim>::
-      register_particle_property (const std::string &name,
-                                  const std::string &description,
-                                  void (*declare_parameters_function) (ParameterHandler &),
-                                  std::unique_ptr<Property::Interface<dim>> (*factory_function) ())
-      {
-        std::get<dim>(registered_plugins).register_plugin (name,
-                                                           description,
-                                                           declare_parameters_function,
-                                                           factory_function);
-      }
-
-
-
-      template <int dim>
-      void
-      Manager<dim>::write_plugin_graph (std::ostream &out)
-      {
-        std::get<dim>(registered_plugins).write_plugin_graph ("Particle property interface",
-                                                              out);
-      }
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<Particle::Property::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<Particle::Property::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<Particle::Property::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<Particle::Property::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace Particle
-  {
-    namespace Property
-    {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/source/particle/property/melt_particle.cc.bak b/source/particle/property/melt_particle.cc.bak
deleted file mode 100644
index fa80b32bee3..00000000000
--- a/source/particle/property/melt_particle.cc.bak
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/particle/property/melt_particle.h>
-#include <aspect/simulator.h>
-#include <aspect/melt.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      MeltParticle<dim>::initialize_one_particle_property(const Point<dim> &/*position*/,
-                                                          std::vector<double> &data) const
-      {
-        data.push_back(0.0);
-      }
-
-      template <int dim>
-      void
-      MeltParticle<dim>::update_particle_property(const unsigned int data_position,
-                                                  const Vector<double> &solution,
-                                                  const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                                  typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                    ExcMessage("Particle property melt particle only works if"
-                               "there is a compositional field called porosity."));
-        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-        if (solution[this->introspection().component_indices.compositional_fields[porosity_idx]] > threshold_for_melt_presence)
-          particle->get_properties()[data_position] = 1.0;
-        else
-          particle->get_properties()[data_position] = 0.0;
-      }
-
-      template <int dim>
-      UpdateTimeFlags
-      MeltParticle<dim>::need_update() const
-      {
-        return update_time_step;
-      }
-
-      template <int dim>
-      UpdateFlags
-      MeltParticle<dim>::get_needed_update_flags () const
-      {
-        return update_values;
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      MeltParticle<dim>::get_property_information() const
-      {
-        std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("melt_presence",1));
-        return property_information;
-      }
-
-      template <int dim>
-      void
-      MeltParticle<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Melt particle");
-        {
-          prm.declare_entry ("Threshold for melt presence", "1e-3",
-                             Patterns::Double (0., 1.),
-                             "The minimum porosity that has to be present at the position of a particle "
-                             "for it to be considered a melt particle (in the sense that the melt presence "
-                             "property is set to 1).");
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      MeltParticle<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Melt particle");
-        {
-          threshold_for_melt_presence = prm.get_double ("Threshold for melt presence");
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(MeltParticle,
-                                        "melt particle",
-                                        "Implementation of a plugin in which the particle "
-                                        "property is defined as presence of melt above a "
-                                        "threshold, which can be set as an input parameter. "
-                                        "This property is set to 0 if melt is not present and "
-                                        "set to 1 if melt is present.")
-    }
-  }
-}
diff --git a/source/particle/property/pT_path.cc.bak b/source/particle/property/pT_path.cc.bak
deleted file mode 100644
index ffff2519a9e..00000000000
--- a/source/particle/property/pT_path.cc.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/pT_path.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/initial_temperature/interface.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      PTPath<dim>::initialize()
-      {
-        // Make sure we keep track of the initial temperature manager and
-        // that it continues to live beyond the time when the simulator
-        // class releases its pointer to it.
-        initial_temperature = this->get_initial_temperature_manager_pointer();
-      }
-
-
-
-
-      template <int dim>
-      void
-      PTPath<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                    std::vector<double> &data) const
-      {
-        // The following is strictly only correct whenever a particle is
-        // created in the first time step. After that, taking pressure and
-        // temperature from adiabatic and initial temperature objects is
-        // not quite correct -- instead, we should be initializing from
-        // the current pressure and temperature, but that is substantially
-        // more complicated since we are not passed this information.
-        //
-        // The issue is probably not terribly important because at least for
-        // all following time steps, we set temperature and pressure to
-        // their correct then-current values.
-        data.push_back(this->get_adiabatic_conditions().pressure(position));
-        data.push_back(initial_temperature->initial_temperature(position));
-      }
-
-
-
-      template <int dim>
-      void
-      PTPath<dim>::update_particle_property(const unsigned int data_position,
-                                            const Vector<double> &solution,
-                                            const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                            typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        particle->get_properties()[data_position]   = solution[this->introspection().component_indices.pressure];
-        particle->get_properties()[data_position+1] = solution[this->introspection().component_indices.temperature];
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      PTPath<dim>::need_update() const
-      {
-        return update_output_step;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      PTPath<dim>::get_needed_update_flags () const
-      {
-        return update_values;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      PTPath<dim>::get_property_information() const
-      {
-        return {{"p", 1}, {"T", 1}};
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(PTPath,
-                                        "pT path",
-                                        "Implementation of a plugin in which the particle "
-                                        "property is defined as the current pressure and "
-                                        "temperature at this position. This can be used "
-                                        "to generate pressure-temperature paths of "
-                                        "material points over time.")
-    }
-  }
-}
diff --git a/source/particle/property/position.cc.bak b/source/particle/property/position.cc.bak
deleted file mode 100644
index a21a0837482..00000000000
--- a/source/particle/property/position.cc.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/position.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      Position<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                      std::vector<double> &data) const
-      {
-        for (unsigned int i = 0; i < dim; ++i)
-          data.push_back(position[i]);
-      }
-
-      template <int dim>
-      void
-      Position<dim>::update_particle_property(const unsigned int data_position,
-                                              const Vector<double> &/*solution*/,
-                                              const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                              typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        for (unsigned int i = 0; i < dim; ++i)
-          particle->get_properties()[data_position+i] = particle->get_location()[i];
-      }
-
-      template <int dim>
-      UpdateTimeFlags
-      Position<dim>::need_update() const
-      {
-        return update_output_step;
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      Position<dim>::get_property_information() const
-      {
-        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("position",dim));
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(Position,
-                                        "position",
-                                        "Implementation of a plugin in which the particle "
-                                        "property is defined as the current position.")
-    }
-  }
-}
diff --git a/source/particle/property/reference_position.cc.bak b/source/particle/property/reference_position.cc.bak
deleted file mode 100644
index 6d5fa5f978e..00000000000
--- a/source/particle/property/reference_position.cc.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/reference_position.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      ReferencePosition<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                               std::vector<double> &data) const
-      {
-        for (unsigned int i = 0; i < dim; ++i)
-          data.push_back(position[i]);
-      }
-
-      template <int dim>
-      void
-      ReferencePosition<dim>::update_particle_property(const unsigned int data_position,
-                                                       const Vector<double> &/*solution*/,
-                                                       const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                                       typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        for (unsigned int i = 0; i < dim; ++i)
-          particle->get_properties()[data_position+i] = particle->get_reference_location()[i];
-      }
-
-      template <int dim>
-      UpdateTimeFlags
-      ReferencePosition<dim>::need_update() const
-      {
-        return update_output_step;
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      ReferencePosition<dim>::get_property_information() const
-      {
-        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("reference position",dim));
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(ReferencePosition,
-                                        "reference position",
-                                        "Implementation of a plugin in which the particle "
-                                        "property is defined as the current reference position.")
-    }
-  }
-}
diff --git a/source/particle/property/strain_rate.cc.bak b/source/particle/property/strain_rate.cc.bak
deleted file mode 100644
index be79a182387..00000000000
--- a/source/particle/property/strain_rate.cc.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/strain_rate.h>
-#include <aspect/particle/property/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      StrainRate<dim>::initialize_one_particle_property(const Point<dim> &,
-                                                        std::vector<double> &data) const
-      {
-        const static Tensor<2,dim> identity = unit_symmetric_tensor<dim>();
-        for (unsigned int i = 0; i < Tensor<2,dim>::n_independent_components ; ++i)
-          data.push_back(identity[Tensor<2,dim>::unrolled_to_component_indices(i)]);
-
-      }
-
-      template <int dim>
-      void
-      StrainRate<dim>::update_particle_property(const unsigned int data_position,
-                                                const Vector<double> &/*solution*/,
-                                                const std::vector<Tensor<1,dim>> &gradients,
-                                                typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        const auto data = particle->get_properties();
-        // Velocity gradients
-        Tensor<2,dim> grad_u;
-        for (unsigned int d=0; d<dim; ++d)
-          grad_u[d] = gradients[d];
-
-        // Calculate strain rate from velocity gradients
-        const SymmetricTensor<2,dim> strain_rate = symmetrize (grad_u);
-
-        for (unsigned int i = 0; i < Tensor<2,dim>::n_independent_components ; ++i)
-          data[data_position + i] = strain_rate[Tensor<2,dim>::unrolled_to_component_indices(i)];
-
-      }
-
-      template <int dim>
-      UpdateTimeFlags
-      StrainRate<dim>::need_update() const
-      {
-        return update_time_step;
-      }
-
-      template <int dim>
-      UpdateFlags
-      StrainRate<dim>::get_needed_update_flags () const
-      {
-        return update_gradients;
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      StrainRate<dim>::get_property_information() const
-      {
-        const unsigned int n_components = Tensor<2,dim>::n_independent_components;
-        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("strainrate",n_components));
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(StrainRate,
-                                        "strain rate",
-                                        "Implementation of a plugin in which the time evolution of "
-                                        "strain rate is saved and stored on the particles.")
-    }
-  }
-}
diff --git a/source/particle/property/velocity.cc.bak b/source/particle/property/velocity.cc.bak
deleted file mode 100644
index 82270e8db5b..00000000000
--- a/source/particle/property/velocity.cc.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/velocity.h>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      void
-      Velocity<dim>::initialize_one_particle_property(const Point<dim> &,
-                                                      std::vector<double> &data) const
-      {
-        for (unsigned int i = 0; i < dim; ++i)
-          data.push_back(0.0);
-      }
-
-      template <int dim>
-      void
-      Velocity<dim>::update_particle_property(const unsigned int data_position,
-                                              const Vector<double> &solution,
-                                              const std::vector<Tensor<1,dim>> &/*gradients*/,
-                                              typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        for (unsigned int i = 0; i < dim; ++i)
-          particle->get_properties()[data_position+i] = solution[this->introspection().component_indices.velocities[i]];
-      }
-
-      template <int dim>
-      UpdateTimeFlags
-      Velocity<dim>::need_update() const
-      {
-        return update_output_step;
-      }
-
-      template <int dim>
-      UpdateFlags
-      Velocity<dim>::get_needed_update_flags () const
-      {
-        return update_values;
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      Velocity<dim>::get_property_information() const
-      {
-        const std::vector<std::pair<std::string,unsigned int>> property_information (1,std::make_pair("velocity",dim));
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(Velocity,
-                                        "velocity",
-                                        "Implementation of a plugin in which the particle "
-                                        "property is defined as the recent velocity at "
-                                        "this position.")
-    }
-  }
-}
diff --git a/source/particle/property/viscoplastic_strain_invariants.cc.bak b/source/particle/property/viscoplastic_strain_invariants.cc.bak
deleted file mode 100644
index 8ea89a2cda2..00000000000
--- a/source/particle/property/viscoplastic_strain_invariants.cc.bak
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/particle/property/viscoplastic_strain_invariants.h>
-#include <aspect/material_model/visco_plastic.h>
-#include <aspect/initial_composition/interface.h>
-
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-
-      template <int dim>
-      ViscoPlasticStrainInvariant<dim>::ViscoPlasticStrainInvariant ()
-        :
-        n_components(0),
-        material_inputs(1,0)
-      {}
-
-
-
-      template <int dim>
-      void
-      ViscoPlasticStrainInvariant<dim>::initialize ()
-      {
-        AssertThrow(Plugins::plugin_type_matches<const MaterialModel::ViscoPlastic<dim>>
-                    (this->get_material_model()),
-                    ExcMessage("This initial condition only makes sense in combination "
-                               "with the visco_plastic material model."));
-
-        n_components = 0;
-        material_inputs = MaterialModel::MaterialModelInputs<dim>(1,this->n_compositional_fields());
-
-        // Find out which fields are used.
-        if (this->introspection().compositional_name_exists("plastic_strain"))
-          n_components += 1;
-
-        if (this->introspection().compositional_name_exists("viscous_strain"))
-          n_components += 1;
-
-        if (this->introspection().compositional_name_exists("total_strain"))
-          n_components += 1;
-
-        if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
-          n_components += 1;
-
-        if (n_components == 0)
-          AssertThrow(false,
-                      ExcMessage("This particle property requires a compositional "
-                                 "strain field (plastic_strain, viscous_strain, "
-                                 "or total_strain)."));
-      }
-
-
-
-      template <int dim>
-      void
-      ViscoPlasticStrainInvariant<dim>::initialize_one_particle_property(const Point<dim> &position,
-                                                                         std::vector<double> &data) const
-      {
-        // Give each strain field its initial composition if one is prescribed.
-        if (this->introspection().compositional_name_exists("plastic_strain"))
-          data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("plastic_strain")));
-
-        if (this->introspection().compositional_name_exists("viscous_strain"))
-          data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("viscous_strain")));
-
-        if (this->introspection().compositional_name_exists("total_strain"))
-          data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("total_strain")));
-
-        if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
-          data.push_back(this->get_initial_composition_manager().initial_composition(position,this->introspection().compositional_index_for_name("noninitial_plastic_strain")));
-
-      }
-
-
-
-      template <int dim>
-      void
-      ViscoPlasticStrainInvariant<dim>::update_particle_property(const unsigned int data_position,
-                                                                 const Vector<double> &solution,
-                                                                 const std::vector<Tensor<1,dim>> &gradients,
-                                                                 typename ParticleHandler<dim>::particle_iterator &particle) const
-      {
-        // Current timestep
-        const double dt = this->get_timestep();
-
-        // Velocity gradients
-        Tensor<2,dim> grad_u;
-        for (unsigned int d=0; d<dim; ++d)
-          grad_u[d] = gradients[d];
-
-        material_inputs.pressure[0] = solution[this->introspection().component_indices.pressure];
-        material_inputs.temperature[0] = solution[this->introspection().component_indices.temperature];
-        material_inputs.position[0] = particle->get_location();
-
-        // Calculate strain rate from velocity gradients
-        material_inputs.strain_rate[0] = symmetrize (grad_u);
-
-        // Put compositional fields into single variable
-        for (unsigned int i = 0; i < this->n_compositional_fields(); ++i)
-          {
-            material_inputs.composition[0][i] = solution[this->introspection().component_indices.compositional_fields[i]];
-          }
-
-        // Find out plastic yielding by calling function in material model.
-        const MaterialModel::ViscoPlastic<dim> &viscoplastic
-          = Plugins::get_plugin_as_type<const MaterialModel::ViscoPlastic<dim>>(this->get_material_model());
-
-        const bool plastic_yielding = viscoplastic.is_yielding(material_inputs);
-
-        // Next take the integrated strain invariant from the prior time step.
-        const auto data = particle->get_properties();
-
-        // Calculate strain rate second invariant
-        const double edot_ii = std::sqrt(std::max(-second_invariant(deviator(material_inputs.strain_rate[0])), 0.));
-
-        // Calculate strain invariant magnitude over the last time step
-        const double strain_update = dt*edot_ii;
-
-        /* Update the strain values that are used in the simulation, which use the following assumptions
-         * to identify the correct position in the data vector for each value:
-         * (1) Total strain cannot be used in combination with any other strain field
-         * (2) If plastic strain is tracked, it will always be in the first data position
-         * (3) If noninitial plastic strain is tracked, it will always be in the last data position
-         * (4) If noninitial plastic strain is tracked, plastic strain is also being tracked
-         * (5) If only viscous strain is tracked, it will be in the first data position.
-         * (6) If both viscous and plastic strain are tracked, viscous strain will be in the second data position
-         * If these assumptions change in the future, they will need to be updated.
-         * */
-
-        if (this->introspection().compositional_name_exists("plastic_strain") && plastic_yielding == true)
-          data[data_position] += strain_update;
-
-        if (this->introspection().compositional_name_exists("viscous_strain") && plastic_yielding == false)
-          {
-            // Not yielding and only one field, which tracks the viscous strain.
-            if (n_components == 1)
-              data[data_position] += strain_update;
-
-            // Not yielding and either two or three fields are tracked. If two fields are tracked,
-            // they represent plastic strain (first data position) and viscous strain (second data
-            // data position, updated below). If three fields are tracked, they represent plastic
-            // strain (first data position), viscous strain (second data position, updated below),
-            // and noninitial plastic strain (third data position). In either case, the viscous
-            // strain is in the second data position, allowing us to use a single expression.
-            if (n_components > 1)
-              data[data_position+1] += strain_update;
-          }
-
-        // Only one field, which tracks total strain and is updated regardless of whether the
-        // material is yielding or not.
-        if (this->introspection().compositional_name_exists("total_strain"))
-          data[data_position] += strain_update;
-
-        // Yielding, and noninitial plastic strain (last data position, updated below) is tracked.
-        if (this->introspection().compositional_name_exists("noninitial_plastic_strain") && plastic_yielding == true)
-          data[data_position+(n_components-1)] += strain_update;
-      }
-
-
-
-      template <int dim>
-      UpdateTimeFlags
-      ViscoPlasticStrainInvariant<dim>::need_update() const
-      {
-        return update_time_step;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      ViscoPlasticStrainInvariant<dim>::get_needed_update_flags () const
-      {
-        // Need to update both of these to send into material model.
-        return update_values | update_gradients;
-      }
-
-      template <int dim>
-      std::vector<std::pair<std::string, unsigned int>>
-      ViscoPlasticStrainInvariant<dim>::get_property_information() const
-      {
-        std::vector<std::pair<std::string,unsigned int>> property_information;
-
-        //Check which fields are used in model and make an output for each.
-        if (this->introspection().compositional_name_exists("plastic_strain"))
-          property_information.emplace_back("plastic_strain", 1);
-
-        if (this->introspection().compositional_name_exists("viscous_strain"))
-          property_information.emplace_back("viscous_strain", 1);
-
-        if (this->introspection().compositional_name_exists("total_strain"))
-          property_information.emplace_back("total_strain", 1);
-
-        if (this->introspection().compositional_name_exists("noninitial_plastic_strain"))
-          property_information.emplace_back("noninitial_plastic_strain", 1);
-
-        return property_information;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(ViscoPlasticStrainInvariant,
-                                        "viscoplastic strain invariants",
-                                        "A plugin that calculates the finite strain invariant a particle has "
-                                        "experienced and assigns it to either the plastic and/or viscous strain field based "
-                                        "on whether the material is plastically yielding, or the total strain field "
-                                        "used in the visco plastic material model. The implementation of this property "
-                                        "is equivalent to the implementation for compositional fields that is located in "
-                                        "the plugin in \\texttt{benchmarks/buiter\\_et\\_al\\_2008\\_jgr/plugin/},"
-                                        "and is effectively the same as what the visco plastic material model uses for compositional fields.")
-    }
-  }
-}
diff --git a/source/particle/world.cc.bak b/source/particle/world.cc.bak
deleted file mode 100644
index 0c558f8a996..00000000000
--- a/source/particle/world.cc.bak
+++ /dev/null
@@ -1,1384 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/particle/world.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/citation_info.h>
-#include <aspect/simulator.h>
-#include <aspect/melt.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/grid/grid_tools.h>
-
-#include <deal.II/fe/mapping_cartesian.h>
-
-#include <boost/serialization/map.hpp>
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/text_iarchive.hpp>
-
-namespace aspect
-{
-  namespace Particle
-  {
-    template <int dim>
-    World<dim>::World()
-      = default;
-
-    template <int dim>
-    World<dim>::~World()
-      = default;
-
-    template <int dim>
-    void
-    World<dim>::initialize()
-    {
-      CitationInfo::add("particles");
-      if (particle_load_balancing & ParticleLoadBalancing::repartition)
-        this->get_triangulation().signals.weight.connect(
-#if DEAL_II_VERSION_GTE(9,6,0)
-          [&] (const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
-               const CellStatus status)
-          -> unsigned int
-#else
-          [&] (const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
-               const typename parallel::distributed::Triangulation<dim>::CellStatus status)
-          -> unsigned int
-#endif
-        {
-          return this->cell_weight(cell, status);
-        });
-
-      // Create a particle handler that stores the future particles.
-      // If we restarted from a checkpoint we will fill this particle handler
-      // later with its serialized variables and stored particles
-      particle_handler = std::make_unique<ParticleHandler<dim>>(this->get_triangulation(),
-                                                                 this->get_mapping(),
-                                                                 property_manager->get_n_property_components());
-
-      particle_handler_backup.initialize(this->get_triangulation(),
-                                         this->get_mapping(),
-                                         property_manager->get_n_property_components());
-
-      connect_to_signals(this->get_signals());
-
-      AssertThrow(this->introspection().get_composition_base_element_indices().size()<=1,
-                  ExcNotImplemented("Particles are not supported in computations with compositional fields with different finite element types."));
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::update()
-    {
-      generator->update();
-      integrator->update();
-      interpolator->update();
-      property_manager->update();
-    }
-
-
-
-    template <int dim>
-    const Property::Manager<dim> &
-    World<dim>::get_property_manager() const
-    {
-      return *property_manager;
-    }
-
-
-
-    template <int dim>
-    const Particles::ParticleHandler<dim> &
-    World<dim>::get_particle_handler() const
-    {
-      return *particle_handler.get();
-    }
-
-
-
-    template <int dim>
-    Particles::ParticleHandler<dim> &
-    World<dim>::get_particle_handler()
-    {
-      return *particle_handler.get();
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::copy_particle_handler (const Particles::ParticleHandler<dim> &from_particle_handler,
-                                       Particles::ParticleHandler<dim> &to_particle_handler) const
-    {
-      {
-        TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Copy");
-
-        to_particle_handler.copy_from(from_particle_handler);
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::backup_particles ()
-    {
-      copy_particle_handler (*particle_handler.get(), particle_handler_backup);
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::restore_particles ()
-    {
-      copy_particle_handler (particle_handler_backup, *particle_handler.get());
-    }
-
-
-
-    template <int dim>
-    const Interpolator::Interface<dim> &
-    World<dim>::get_interpolator() const
-    {
-      return *interpolator;
-    }
-
-
-
-    template <int dim>
-    types::particle_index
-    World<dim>::n_global_particles() const
-    {
-      return particle_handler->n_global_particles();
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::connect_to_signals(aspect::SimulatorSignals<dim> &signals)
-    {
-      signals.post_set_initial_state.connect(
-        [&] (const SimulatorAccess<dim> &)
-      {
-        this->setup_initial_state();
-      });
-
-      connect_particle_handler_signals(signals,*particle_handler);
-      // Particle handler backup will not be stored for checkpointing
-      connect_particle_handler_signals(signals, particle_handler_backup, false);
-
-      signals.post_refinement_load_user_data.connect(
-        [&] (typename parallel::distributed::Triangulation<dim> &)
-      {
-        this->apply_particle_per_cell_bounds();
-      });
-
-      signals.post_resume_load_user_data.connect(
-        [&] (typename parallel::distributed::Triangulation<dim> &)
-      {
-        this->apply_particle_per_cell_bounds();
-      });
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::connect_particle_handler_signals(aspect::SimulatorSignals<dim> &signals,
-                                                 ParticleHandler<dim> &particle_handler_,
-                                                 const bool connect_to_checkpoint_signals) const
-    {
-      signals.pre_refinement_store_user_data.connect(
-        [&] (typename parallel::distributed::Triangulation<dim> &)
-      {
-        particle_handler_.prepare_for_coarsening_and_refinement();
-      });
-
-      signals.post_refinement_load_user_data.connect(
-        [&] (typename parallel::distributed::Triangulation<dim> &)
-      {
-        particle_handler_.unpack_after_coarsening_and_refinement();
-      });
-
-      // Only connect to checkpoint signals if requested
-      if (connect_to_checkpoint_signals)
-        {
-          signals.pre_checkpoint_store_user_data.connect(
-            [&] (typename parallel::distributed::Triangulation<dim> &)
-          {
-            particle_handler_.prepare_for_serialization();
-          });
-
-          signals.post_resume_load_user_data.connect(
-            [&] (typename parallel::distributed::Triangulation<dim> &)
-          {
-            particle_handler_.deserialize();
-          });
-        }
-
-      if (update_ghost_particles &&
-          dealii::Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()) > 1)
-        {
-          auto do_ghost_exchange = [&] (typename parallel::distributed::Triangulation<dim> &)
-          {
-            particle_handler_.exchange_ghost_particles();
-          };
-          signals.post_refinement_load_user_data.connect(do_ghost_exchange);
-          signals.post_resume_load_user_data.connect(do_ghost_exchange);
-        }
-
-      signals.post_mesh_deformation.connect(
-        [&] (const SimulatorAccess<dim> &)
-      {
-        particle_handler->sort_particles_into_subdomains_and_cells();
-      },
-      boost::signals2::at_front);
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::apply_particle_per_cell_bounds()
-    {
-      // If any load balancing technique is selected that creates/destroys particles
-      if (particle_load_balancing & ParticleLoadBalancing::remove_and_add_particles)
-        {
-          // First do some preparation for particle generation in poorly
-          // populated areas. For this we need to know which particle ids to
-          // generate so that they are globally unique.
-          // Ensure this by communicating the number of particles that every
-          // process is going to generate.
-          particle_handler->update_cached_numbers();
-          types::particle_index local_next_particle_index = particle_handler->get_next_free_particle_index();
-          if (particle_load_balancing & ParticleLoadBalancing::add_particles)
-            {
-              types::particle_index particles_to_add_locally = 0;
-
-              // Loop over all cells and determine the number of particles to generate
-              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-                if (cell->is_locally_owned())
-                  {
-                    const unsigned int particles_in_cell = particle_handler->n_particles_in_cell(cell);
-
-                    if (particles_in_cell < min_particles_per_cell)
-                      particles_to_add_locally += static_cast<types::particle_index> (min_particles_per_cell - particles_in_cell);
-                  }
-
-              // Determine the starting particle index of this process, which
-              // is the highest currently existing particle index plus the sum
-              // of the number of newly generated particles of all
-              // processes with a lower rank.
-
-              types::particle_index local_start_index = 0.0;
-
-              const int ierr = MPI_Scan(&particles_to_add_locally, &local_start_index, 1, DEAL_II_PARTICLE_INDEX_MPI_TYPE, MPI_SUM, this->get_mpi_communicator());
-              AssertThrowMPI(ierr);
-
-              local_start_index -= particles_to_add_locally;
-              local_next_particle_index += local_start_index;
-
-              const types::particle_index globally_generated_particles =
-                dealii::Utilities::MPI::sum(particles_to_add_locally,this->get_mpi_communicator());
-
-              AssertThrow (particle_handler->get_next_free_particle_index()
-                           <= std::numeric_limits<types::particle_index>::max() - globally_generated_particles,
-                           ExcMessage("There is no free particle index left to generate a new particle id. Please check if your "
-                                      "model generates unusually many new particles (by repeatedly deleting and regenerating particles), or "
-                                      "recompile deal.II with the DEAL_II_WITH_64BIT_INDICES option enabled, to use 64-bit integers for "
-                                      "particle ids."));
-            }
-
-          std::mt19937 random_number_generator;
-
-          // Loop over all cells and generate or remove the particles cell-wise
-          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-            if (cell->is_locally_owned())
-              {
-                const unsigned int n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
-
-                // Add particles if necessary
-                if ((particle_load_balancing & ParticleLoadBalancing::add_particles) &&
-                    (n_particles_in_cell < min_particles_per_cell))
-                  {
-                    for (unsigned int i = n_particles_in_cell; i < min_particles_per_cell; ++i,++local_next_particle_index)
-                      {
-                        std::pair<Particles::internal::LevelInd,Particles::Particle<dim>> new_particle = generator->generate_particle(cell,local_next_particle_index);
-
-                        const std::vector<double> particle_properties =
-                          property_manager->initialize_late_particle(new_particle.second.get_location(),
-                                                                     *particle_handler,
-                                                                     *interpolator,
-                                                                     cell);
-
-                        typename ParticleHandler<dim>::particle_iterator particle = particle_handler->insert_particle(new_particle.second,
-                                                                                    typename parallel::distributed::Triangulation<dim>::cell_iterator (&this->get_triangulation(),
-                                                                                        new_particle.first.first,
-                                                                                        new_particle.first.second));
-                        particle->set_properties(particle_properties);
-                      }
-                  }
-
-                // Remove particles if necessary
-                else if ((particle_load_balancing & ParticleLoadBalancing::remove_particles) &&
-                         (n_particles_in_cell > max_particles_per_cell))
-                  {
-                    const unsigned int n_particles_to_remove = n_particles_in_cell - max_particles_per_cell;
-                    for (unsigned int i=0; i < n_particles_to_remove; ++i)
-                      {
-                        const unsigned int current_n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
-                        const unsigned int index_to_remove = std::uniform_int_distribution<unsigned int>
-                                                             (0,current_n_particles_in_cell-1)(random_number_generator);
-
-                        auto particle_to_remove = particle_handler->particles_in_cell(cell).begin();
-                        std::advance(particle_to_remove, index_to_remove);
-                        particle_handler->remove_particle(particle_to_remove);
-                      }
-
-                  }
-              }
-
-          particle_handler->update_cached_numbers();
-        }
-    }
-
-    template <int dim>
-    unsigned int
-    World<dim>::cell_weight(const typename parallel::distributed::Triangulation<dim>::cell_iterator &cell,
-#if DEAL_II_VERSION_GTE(9,6,0)
-                            const CellStatus status
-#else
-                            const typename parallel::distributed::Triangulation<dim>::CellStatus status
-#endif
-                           )
-    {
-      if (cell->is_active() && !cell->is_locally_owned())
-        return 0;
-
-      const unsigned int base_weight = 1000;
-      unsigned int n_particles_in_cell = 0;
-      switch (status)
-        {
-#if DEAL_II_VERSION_GTE(9,6,0)
-          case CellStatus::cell_will_persist:
-          case CellStatus::cell_will_be_refined:
-            n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
-            break;
-
-          case CellStatus::cell_invalid:
-            break;
-
-          case CellStatus::children_will_be_coarsened:
-            for (const auto &child : cell->child_iterators())
-              n_particles_in_cell += particle_handler->n_particles_in_cell(child);
-            break;
-#else
-          case parallel::distributed::Triangulation<dim>::CELL_PERSIST:
-          case parallel::distributed::Triangulation<dim>::CELL_REFINE:
-            n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
-            break;
-
-          case parallel::distributed::Triangulation<dim>::CELL_INVALID:
-            break;
-
-          case parallel::distributed::Triangulation<dim>::CELL_COARSEN:
-            for (const auto &child : cell->child_iterators())
-              n_particles_in_cell += particle_handler->n_particles_in_cell(child);
-            break;
-#endif
-          default:
-            Assert(false, ExcInternalError());
-            break;
-        }
-      return base_weight + n_particles_in_cell * particle_weight;
-    }
-
-
-    template <int dim>
-    std::map<types::subdomain_id, unsigned int>
-    World<dim>::get_subdomain_id_to_neighbor_map() const
-    {
-      std::map<types::subdomain_id, unsigned int> subdomain_id_to_neighbor_map;
-      const std::set<types::subdomain_id> ghost_owners = this->get_triangulation().ghost_owners();
-      std::set<types::subdomain_id>::const_iterator ghost_owner = ghost_owners.begin();
-
-      for (unsigned int neighbor_id=0; neighbor_id<ghost_owners.size(); ++neighbor_id,++ghost_owner)
-        {
-          subdomain_id_to_neighbor_map.insert(std::make_pair(*ghost_owner,neighbor_id));
-        }
-      return subdomain_id_to_neighbor_map;
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::local_initialize_particles(const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                                           const typename ParticleHandler<dim>::particle_iterator &end_particle)
-    {
-      for (typename ParticleHandler<dim>::particle_iterator it = begin_particle; it!=end_particle; ++it)
-        property_manager->initialize_one_particle(it);
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::local_update_particles(const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                       internal::SolutionEvaluators<dim> &evaluators)
-    {
-      const unsigned int n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
-      typename ParticleHandler<dim>::particle_iterator_range particles = particle_handler->particles_in_cell(cell);
-
-      std::vector<Point<dim>> positions;
-      positions.reserve(n_particles_in_cell);
-
-      for (const auto &particle : particles)
-        positions.push_back(particle.get_reference_location());
-
-      const UpdateFlags update_flags = property_manager->get_needed_update_flags();
-
-      boost::container::small_vector<double, 100> solution_values(this->get_fe().dofs_per_cell);
-
-      cell->get_dof_values(this->get_solution(),
-                           solution_values.begin(),
-                           solution_values.end());
-
-      if (update_flags & (update_values | update_gradients))
-        evaluators.reinit(cell, positions, {solution_values.data(), solution_values.size()}, update_flags);
-
-      std::vector<Vector<double>> solution;
-      if (update_flags & update_values)
-        solution.resize(n_particles_in_cell,Vector<double>(this->introspection().n_components));
-
-      std::vector<std::vector<Tensor<1,dim>>> gradients;
-      if (update_flags & update_gradients)
-        gradients.resize(n_particles_in_cell,std::vector<Tensor<1,dim>>(this->introspection().n_components));
-
-      for (unsigned int i = 0; i<n_particles_in_cell; ++i)
-        {
-          // Evaluate the solution, but only if it is requested in the update_flags
-          if (update_flags & update_values)
-            evaluators.get_solution(i, solution[i]);
-
-          // Evaluate the gradients, but only if they are requested in the update_flags
-          if (update_flags & update_gradients)
-            evaluators.get_gradients(i, gradients[i]);
-        }
-
-      property_manager->update_particles(particles,
-                                         solution,
-                                         gradients);
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::local_advect_particles(const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                       const typename ParticleHandler<dim>::particle_iterator &begin_particle,
-                                       const typename ParticleHandler<dim>::particle_iterator &end_particle,
-                                       internal::SolutionEvaluators<dim> &evaluators)
-    {
-      const unsigned int n_particles_in_cell = particle_handler->n_particles_in_cell(cell);
-
-      boost::container::small_vector<Point<dim>, 100>   positions;
-      positions.reserve(n_particles_in_cell);
-      for (auto particle = begin_particle; particle!=end_particle; ++particle)
-        positions.push_back(particle->get_reference_location());
-
-      const std::array<bool, 3> required_solution_vectors = integrator->required_solution_vectors();
-
-      AssertThrow (required_solution_vectors[0] == false,
-                   ExcMessage("The integrator requires the old old solution vector, but it is not available."));
-
-
-      const bool use_fluid_velocity = this->include_melt_transport() &&
-                                      property_manager->get_data_info().fieldname_exists("melt_presence");
-
-      auto &evaluator = evaluators.get_velocity_or_fluid_velocity_evaluator(use_fluid_velocity);
-      auto &mapping_info = evaluators.get_mapping_info();
-      mapping_info.reinit(cell, {positions.data(),positions.size()});
-
-      std::vector<Tensor<1,dim>> velocities;
-      std::vector<Tensor<1,dim>> old_velocities;
-
-      if (required_solution_vectors[1] == true)
-        {
-          boost::container::small_vector<double, 100> old_solution_values(this->get_fe().dofs_per_cell);
-          cell->get_dof_values(this->get_old_solution(),
-                               old_solution_values.begin(),
-                               old_solution_values.end());
-
-          evaluator.evaluate({old_solution_values.data(),old_solution_values.size()},
-                             EvaluationFlags::values);
-
-          old_velocities.resize(n_particles_in_cell);
-          for (unsigned int i=0; i<n_particles_in_cell; ++i)
-            old_velocities[i] = evaluator.get_value(i);
-        }
-
-      if (required_solution_vectors[2] == true)
-        {
-          boost::container::small_vector<double, 100> solution_values(this->get_fe().dofs_per_cell);
-          cell->get_dof_values(this->get_current_linearization_point(),
-                               solution_values.begin(),
-                               solution_values.end());
-          evaluator.evaluate({solution_values.data(),solution_values.size()},
-                             EvaluationFlags::values);
-
-          velocities.resize(n_particles_in_cell);
-          for (unsigned int i=0; i<n_particles_in_cell; ++i)
-            velocities[i] = evaluator.get_value(i);
-        }
-
-      integrator->local_integrate_step(begin_particle,
-                                       end_particle,
-                                       old_velocities,
-                                       velocities,
-                                       this->get_timestep());
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::setup_initial_state ()
-    {
-      // If we are in the first adaptive refinement cycle generate particles
-      if (this->get_pre_refinement_step() == 0)
-        generate_particles();
-
-      // And initialize the particle properties according to the initial
-      // conditions on the current mesh
-      initialize_particles();
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::generate_particles()
-    {
-      TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Generate");
-      generator->generate_particles(*particle_handler);
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::initialize_particles()
-    {
-      // TODO: Change this loop over all cells to use the WorkStream interface
-      if (property_manager->get_n_property_components() > 0)
-        {
-          TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Initialize properties");
-
-          particle_handler->get_property_pool().reserve(2 * particle_handler->n_locally_owned_particles());
-
-
-          if (particle_handler->n_locally_owned_particles() > 0)
-            local_initialize_particles(particle_handler->begin(),
-                                       particle_handler->end());
-
-          if (update_ghost_particles &&
-              dealii::Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()) > 1)
-            {
-              TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Exchange ghosts");
-              particle_handler->exchange_ghost_particles();
-            }
-        }
-    }
-
-
-
-    namespace internal
-    {
-      // This class evaluates the solution vector at arbitrary positions inside a cell.
-      // It uses the deal.II class FEPointEvaluation to do this efficiently. Because
-      // FEPointEvaluation only supports a single finite element, but ASPECT uses a FESystem with
-      // many components, this class creates several FEPointEvaluation objects that are used for
-      // the individual finite elements of our solution (pressure, velocity, temperature, and
-      // all other optional variables). Because FEPointEvaluation is templated based on the
-      // number of components, but ASPECT only knows the number of components at runtime
-      // we create this derived class with an additional template. This makes it possible
-      // to access the functionality through the base class, but create an object of this
-      // derived class with the correct number of components at runtime.
-      template <int dim, int n_compositional_fields>
-      class SolutionEvaluatorsImplementation: public SolutionEvaluators<dim>
-      {
-        public:
-          // Constructor. Create the member variables given a simulator and a set of
-          // update flags. The update flags control if only the solution or also the gradients
-          // should be evaluated.
-          SolutionEvaluatorsImplementation(const SimulatorAccess<dim> &simulator,
-                                           const UpdateFlags update_flags);
-
-          // Reinitialize all variables to evaluate the given solution for the given cell
-          // and the given positions. The update flags control if only the solution or
-          // also the gradients should be evaluated.
-          // If other flags are set an assertion is triggered.
-          void
-          reinit(const typename DoFHandler<dim>::active_cell_iterator &cell,
-                 const ArrayView<Point<dim>> &positions,
-                 const ArrayView<double> &solution_values,
-                 const UpdateFlags update_flags) override;
-
-          // Return the value of all solution components at the given evaluation point. Note
-          // that this function only works after a successful call to reinit(),
-          // because this function only returns the results of the computation that
-          // happened in reinit().
-          void get_solution(const unsigned int evaluation_point,
-                            Vector<double> &solution) override;
-
-          // Return the value of all solution gradients at the given evaluation point. Note
-          // that this function only works after a successful call to reinit(),
-          // because this function only returns the results of the computation that
-          // happened in reinit().
-          void get_gradients(const unsigned int evaluation_point,
-                             std::vector<Tensor<1,dim>> &gradients) override;
-
-          // Return the evaluator for velocity or fluid velocity. This is the only
-          // information necessary for advecting particles.
-          FEPointEvaluation<dim, dim> &
-          get_velocity_or_fluid_velocity_evaluator(const bool use_fluid_velocity) override;
-
-          // Return the cached mapping information.
-          NonMatching::MappingInfo<dim> &
-          get_mapping_info() override;
-        private:
-          // MappingInfo object for the FEPointEvaluation objects
-          NonMatching::MappingInfo<dim> mapping_info;
-
-          // FEPointEvaluation objects for all common
-          // components of ASPECT's finite element solution.
-          // These objects are used inside of the member functions of this class.
-          FEPointEvaluation<dim, dim> velocity;
-          std::unique_ptr<FEPointEvaluation<1, dim>> pressure;
-          FEPointEvaluation<1, dim> temperature;
-
-          // If instantiated evaluate multiple compositions at once, if
-          // not fall back to evaluating them individually.
-          FEPointEvaluation<n_compositional_fields, dim> compositions;
-          std::vector<FEPointEvaluation<1, dim>> additional_compositions;
-
-          // Pointers to FEPointEvaluation objects for all melt
-          // components of ASPECT's finite element solution, which only
-          // point to valid objects in case we use melt transport. Other
-          // documentation like for the objects directly above.
-          std::unique_ptr<FEPointEvaluation<dim, dim>> fluid_velocity;
-          std::unique_ptr<FEPointEvaluation<1, dim>> compaction_pressure;
-          std::unique_ptr<FEPointEvaluation<1, dim>> fluid_pressure;
-
-          // The component indices for the three melt formulation
-          // variables fluid velocity, compaction pressure, and
-          // fluid pressure (in this order). They are cached
-          // to avoid repeated expensive lookups.
-          std::array<unsigned int, 3> melt_component_indices;
-
-          // Reference to the active simulator access object. Provides
-          // access to the general simulation variables.
-          const SimulatorAccess<dim> &simulator_access;
-      };
-
-
-
-      template <int dim, int n_compositional_fields>
-      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::SolutionEvaluatorsImplementation(const SimulatorAccess<dim> &simulator,
-          const UpdateFlags update_flags)
-        :
-        mapping_info(simulator.get_mapping(),
-                     update_flags),
-        velocity(mapping_info,
-                 simulator.get_fe(),
-                 simulator.introspection().component_indices.velocities[0]),
-        pressure(std::make_unique<FEPointEvaluation<1, dim>>(mapping_info,
-                                                              simulator.get_fe(),
-                                                              simulator.introspection().component_indices.pressure)),
-        temperature(mapping_info,
-                    simulator.get_fe(),
-                    simulator.introspection().component_indices.temperature),
-        compositions(mapping_info,
-                     simulator.get_fe(),
-                     simulator.n_compositional_fields() > 0 ? simulator.introspection().component_indices.compositional_fields[0] : simulator.introspection().component_indices.temperature),
-
-        melt_component_indices(),
-        simulator_access(simulator)
-      {
-        // Create the evaluators for all compositional fields beyond the ones this class was
-        // instantiated for
-        const unsigned int n_total_compositional_fields = simulator_access.n_compositional_fields();
-        const auto &component_indices = simulator_access.introspection().component_indices.compositional_fields;
-        for (unsigned int composition = n_compositional_fields; composition < n_total_compositional_fields; ++composition)
-          additional_compositions.emplace_back(FEPointEvaluation<1, dim>(mapping_info,
-                                                                         simulator_access.get_fe(),
-                                                                         component_indices[composition]));
-
-        // The FE_DGP pressure element used in locally conservative discretization is not
-        // supported by the fast path of FEPointEvaluation. Replace with slow path.
-        if (simulator_access.get_parameters().use_locally_conservative_discretization == true)
-          pressure = std::make_unique<FEPointEvaluation<1, dim>>(simulator_access.get_mapping(),
-                                                                  simulator_access.get_fe(),
-                                                                  update_flags,
-                                                                  simulator.introspection().component_indices.pressure);
-
-        // Create the melt evaluators, but only if we use melt transport in the model
-        if (simulator_access.include_melt_transport())
-          {
-            // Store the melt component indices to avoid repeated string lookups later on
-            melt_component_indices[0] = simulator_access.introspection().variable("fluid velocity").first_component_index;
-            melt_component_indices[1] = simulator_access.introspection().variable("fluid pressure").first_component_index;
-            melt_component_indices[2] = simulator_access.introspection().variable("compaction pressure").first_component_index;
-
-            fluid_velocity = std::make_unique<FEPointEvaluation<dim, dim>>(mapping_info,
-                                                                            simulator_access.get_fe(),
-                                                                            melt_component_indices[0]);
-            if (simulator_access.get_parameters().use_locally_conservative_discretization == false)
-              fluid_pressure = std::make_unique<FEPointEvaluation<1, dim>>(mapping_info,
-                                                                            simulator_access.get_fe(),
-                                                                            melt_component_indices[1]);
-            else
-              {
-                fluid_pressure = std::make_unique<FEPointEvaluation<1, dim>>(simulator_access.get_mapping(),
-                                                                              simulator_access.get_fe(),
-                                                                              update_flags,
-                                                                              melt_component_indices[1]);
-              }
-
-            if (simulator_access.get_melt_handler().melt_parameters.use_discontinuous_p_c == false)
-              compaction_pressure = std::make_unique<FEPointEvaluation<1, dim>>(mapping_info,
-                                                                                 simulator_access.get_fe(),
-                                                                                 melt_component_indices[2]);
-            else
-              compaction_pressure = std::make_unique<FEPointEvaluation<1, dim>>(simulator_access.get_mapping(),
-                                                                                 simulator_access.get_fe(),
-                                                                                 update_flags,
-                                                                                 melt_component_indices[2]);
-
-
-          }
-      }
-
-
-
-      template <int dim, int n_compositional_fields>
-      void
-      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::reinit(const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                                                            const ArrayView<Point<dim>> &positions,
-                                                                            const ArrayView<double> &solution_values,
-                                                                            const UpdateFlags update_flags)
-      {
-        // FEPointEvaluation uses different evaluation flags than the common UpdateFlags.
-        // Translate between the two.
-        EvaluationFlags::EvaluationFlags evaluation_flags = EvaluationFlags::nothing;
-
-        if (update_flags & update_values)
-          evaluation_flags = evaluation_flags | EvaluationFlags::values;
-
-        if (update_flags & update_gradients)
-          evaluation_flags = evaluation_flags | EvaluationFlags::gradients;
-
-        // Make sure only the flags are set that we can deal with at the moment
-        Assert ((update_flags & ~(update_gradients | update_values)) == false,
-                ExcNotImplemented());
-
-        // Reinitialize and evaluate all evaluators.
-        // TODO: It would be nice to be able to hand over a ComponentMask
-        // to specify which evaluators to use. Currently, this is only
-        // possible by manually accessing the public members of this class.
-        mapping_info.reinit(cell,positions);
-
-        if (simulator_access.get_parameters().use_locally_conservative_discretization == true)
-          {
-            pressure->reinit(cell, positions);
-
-            if (simulator_access.include_melt_transport())
-              {
-                fluid_pressure->reinit (cell, positions);
-              }
-          }
-
-        if (simulator_access.include_melt_transport()
-            && simulator_access.get_melt_handler().melt_parameters.use_discontinuous_p_c == true)
-          {
-            compaction_pressure->reinit (cell, positions);
-          }
-
-
-        velocity.evaluate (solution_values, evaluation_flags);
-        pressure->evaluate (solution_values, evaluation_flags);
-        temperature.evaluate (solution_values, evaluation_flags);
-        compositions.evaluate (solution_values, evaluation_flags);
-
-        for (auto &evaluator_composition: additional_compositions)
-          evaluator_composition.evaluate (solution_values, evaluation_flags);
-
-        if (simulator_access.include_melt_transport())
-          {
-            fluid_velocity->evaluate (solution_values, evaluation_flags);
-            fluid_pressure->evaluate (solution_values, evaluation_flags);
-            compaction_pressure->evaluate (solution_values, evaluation_flags);
-          }
-      }
-
-      namespace
-      {
-        template <int n_compositional_fields>
-        double
-        get_value(const Tensor<1,n_compositional_fields> &solution,
-                  const unsigned int component_index)
-        {
-          AssertIndexRange(component_index, n_compositional_fields);
-          return solution[component_index];
-        }
-
-        template <int n_compositional_fields>
-        double
-        get_value(const double &solution,
-                  const unsigned int component_index)
-        {
-          (void) component_index;
-          AssertIndexRange(component_index, 1);
-          return solution;
-        }
-
-        template <int dim, int n_compositional_fields>
-        Tensor<1,dim>
-        get_gradient(const Tensor<1,n_compositional_fields,Tensor<1,dim>> &gradient,
-                     const unsigned int component_index)
-        {
-          AssertIndexRange(component_index, n_compositional_fields);
-          return gradient[component_index];
-        }
-
-
-        template <int dim, int n_compositional_fields>
-        Tensor<1,dim>
-        get_gradient(const Tensor<1,dim> &gradient,
-                     const unsigned int component_index)
-        {
-          (void) component_index;
-          AssertIndexRange(component_index, 1);
-          return gradient;
-        }
-      }
-
-
-      template <int dim, int n_compositional_fields>
-      void
-      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::get_solution(const unsigned int evaluation_point,
-                                                                                  Vector<double> &solution)
-      {
-        Assert(solution.size() == simulator_access.introspection().n_components,
-               ExcDimensionMismatch(solution.size(), simulator_access.introspection().n_components));
-
-        const auto &component_indices = simulator_access.introspection().component_indices;
-
-        const Tensor<1,dim> velocity_value = velocity.get_value(evaluation_point);
-        for (unsigned int j=0; j<dim; ++j)
-          solution[component_indices.velocities[j]] = velocity_value[j];
-
-        solution[component_indices.pressure] = pressure->get_value(evaluation_point);
-        solution[component_indices.temperature] = temperature.get_value(evaluation_point);
-
-        if (n_compositional_fields > 0)
-          for (unsigned int j=0; j<n_compositional_fields; ++j)
-            solution[component_indices.compositional_fields[j]] = get_value<n_compositional_fields>(
-                                                                    compositions.get_value(evaluation_point),
-                                                                    j);
-
-        const unsigned int n_additional_compositions = additional_compositions.size();
-        for (unsigned int j=0; j<n_additional_compositions; ++j)
-          solution[component_indices.compositional_fields[n_compositional_fields+j]] = additional_compositions[j].get_value(evaluation_point);
-
-        if (simulator_access.include_melt_transport())
-          {
-            const Tensor<1,dim> fluid_velocity_value = velocity.get_value(evaluation_point);
-            for (unsigned int j=0; j<dim; ++j)
-              solution[melt_component_indices[0]+j] = fluid_velocity_value[j];
-
-            solution[melt_component_indices[1]] = fluid_pressure->get_value(evaluation_point);
-            solution[melt_component_indices[2]] = compaction_pressure->get_value(evaluation_point);
-          }
-      }
-
-
-
-      template <int dim, int n_compositional_fields>
-      void
-      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::get_gradients(const unsigned int evaluation_point,
-                                                                                   std::vector<Tensor<1,dim>> &gradients)
-      {
-        Assert(gradients.size() == simulator_access.introspection().n_components,
-               ExcDimensionMismatch(gradients.size(), simulator_access.introspection().n_components));
-
-        const auto &component_indices = simulator_access.introspection().component_indices;
-
-        const Tensor<2,dim> velocity_gradient = velocity.get_gradient(evaluation_point);
-        for (unsigned int j=0; j<dim; ++j)
-          gradients[component_indices.velocities[j]] = velocity_gradient[j];
-
-        gradients[component_indices.pressure] = pressure->get_gradient(evaluation_point);
-        gradients[component_indices.temperature] = temperature.get_gradient(evaluation_point);
-
-        if (n_compositional_fields > 0)
-          for (unsigned int j=0; j<n_compositional_fields; ++j)
-            gradients[component_indices.compositional_fields[j]] = get_gradient<dim,n_compositional_fields>(
-                                                                     compositions.get_gradient(evaluation_point),
-                                                                     j);
-
-        const unsigned int n_additional_compositions = additional_compositions.size();
-        for (unsigned int j=0; j<n_additional_compositions; ++j)
-          gradients[component_indices.compositional_fields[n_compositional_fields+j]] = additional_compositions[j].get_gradient(evaluation_point);
-
-        if (simulator_access.include_melt_transport())
-          {
-            const Tensor<2,dim> fluid_velocity_gradient = velocity.get_gradient(evaluation_point);
-            for (unsigned int j=0; j<dim; ++j)
-              gradients[melt_component_indices[0]+j] = fluid_velocity_gradient[j];
-
-            gradients[melt_component_indices[1]] = fluid_pressure->get_gradient(evaluation_point);
-            gradients[melt_component_indices[2]] = compaction_pressure->get_gradient(evaluation_point);
-          }
-      }
-
-
-      template <int dim, int n_compositional_fields>
-      FEPointEvaluation<dim, dim> &
-      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::get_velocity_or_fluid_velocity_evaluator(const bool use_fluid_velocity)
-      {
-        if (use_fluid_velocity)
-          return *fluid_velocity;
-        else
-          return velocity;
-
-        return velocity;
-      }
-      template <int dim, int n_compositional_fields>
-      NonMatching::MappingInfo<dim> &
-      SolutionEvaluatorsImplementation<dim, n_compositional_fields>::get_mapping_info()
-      {
-        return mapping_info;
-      }
-
-
-
-      // A function to create a pointer to a SolutionEvaluators object.
-      template <int dim>
-      std::unique_ptr<internal::SolutionEvaluators<dim>>
-      construct_solution_evaluators (const SimulatorAccess<dim> &simulator_access,
-                                     const UpdateFlags update_flags)
-      {
-        switch (simulator_access.n_compositional_fields())
-          {
-            case 0:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,0>>(simulator_access, update_flags);
-            case 1:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,1>>(simulator_access, update_flags);
-            case 2:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,2>>(simulator_access, update_flags);
-            case 3:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,3>>(simulator_access, update_flags);
-            case 4:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,4>>(simulator_access, update_flags);
-            case 5:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,5>>(simulator_access, update_flags);
-            case 6:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,6>>(simulator_access, update_flags);
-            case 7:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,7>>(simulator_access, update_flags);
-            case 8:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,8>>(simulator_access, update_flags);
-            case 9:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,9>>(simulator_access, update_flags);
-            case 10:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,10>>(simulator_access, update_flags);
-            case 11:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,11>>(simulator_access, update_flags);
-            case 12:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,12>>(simulator_access, update_flags);
-            case 13:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,13>>(simulator_access, update_flags);
-            case 14:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,14>>(simulator_access, update_flags);
-            case 15:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,15>>(simulator_access, update_flags);
-            case 16:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,16>>(simulator_access, update_flags);
-            case 17:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,17>>(simulator_access, update_flags);
-            case 18:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,18>>(simulator_access, update_flags);
-            case 19:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,19>>(simulator_access, update_flags);
-            // Return the maximally instantiated object. The class will handle additional compositional fields
-            // by dynamically allocating additional scalar evaluators.
-            default:
-              return std::make_unique<SolutionEvaluatorsImplementation<dim,20>>(simulator_access, update_flags);
-          }
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::update_particles()
-    {
-      // TODO: Change this loop over all cells to use the WorkStream interface
-
-      if (property_manager->get_n_property_components() > 0)
-        {
-          TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Update properties");
-
-          Assert(dealii::internal::FEPointEvaluation::is_fast_path_supported(this->get_mapping()) == true,
-                 ExcMessage("The particle system was optimized for deal.II mappings that support the fast evaluation path "
-                            "of the class FEPointEvaluation. The mapping currently in use does not support this path. "
-                            "It is safe to uncomment this assertion, but you can expect a performance penalty."));
-
-          const UpdateFlags update_flags = property_manager->get_needed_update_flags();
-
-          std::unique_ptr<internal::SolutionEvaluators<dim>> evaluators = internal::construct_solution_evaluators(*this,
-                                                                           update_flags);
-
-          // Loop over all cells and update the particles cell-wise
-          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-            if (cell->is_locally_owned())
-              {
-                // Only update particles if there are any in this cell
-                if (particle_handler->n_particles_in_cell(cell) > 0)
-                  {
-                    local_update_particles(cell,
-                                           *evaluators);
-                  }
-
-              }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::advect_particles()
-    {
-      {
-        // TODO: Change this loop over all cells to use the WorkStream interface
-        TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Advect");
-
-        Assert(dealii::internal::FEPointEvaluation::is_fast_path_supported(this->get_mapping()) == true,
-               ExcMessage("The particle system was optimized for deal.II mappings that support the fast evaluation path "
-                          "of the class FEPointEvaluation. The mapping currently in use does not support this path. "
-                          "It is safe to uncomment this assertion, but you can expect a performance penalty."));
-
-        std::unique_ptr<internal::SolutionEvaluators<dim>> evaluators =
-          std::make_unique<internal::SolutionEvaluatorsImplementation<dim, 0>>(*this,
-                                                                                update_values);
-
-        // Loop over all cells and advect the particles cell-wise
-        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              const typename ParticleHandler<dim>::particle_iterator_range
-              particles_in_cell = particle_handler->particles_in_cell(cell);
-
-              // Only advect particles, if there are any in this cell
-              if (particles_in_cell.begin() != particles_in_cell.end())
-                {
-                  local_advect_particles(cell,
-                                         particles_in_cell.begin(),
-                                         particles_in_cell.end(),
-                                         *evaluators);
-                }
-            }
-      }
-
-      {
-        TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Sort");
-        // Find the cells that the particles moved to
-        particle_handler->sort_particles_into_subdomains_and_cells();
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::advance_timestep()
-    {
-      this->get_pcout() << "   Advecting particles... " << std::flush;
-      do
-        {
-          advect_particles();
-        }
-      // Keep calling the integrator until it indicates it is finished
-      while (integrator->new_integration_step());
-
-      apply_particle_per_cell_bounds();
-
-      // Update particle properties
-      if (property_manager->need_update() == Property::update_time_step)
-        update_particles();
-
-      // Now that all particle information was updated, exchange the new
-      // ghost particles.
-      if (update_ghost_particles &&
-          dealii::Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()) > 1)
-        {
-          TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Exchange ghosts");
-          particle_handler->exchange_ghost_particles();
-        }
-      this->get_pcout() << " done." << std::endl;
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::save (std::ostringstream &os) const
-    {
-      aspect::oarchive oa (os);
-      oa << (*this);
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::load (std::istringstream &is)
-    {
-      aspect::iarchive ia (is);
-      ia >> (*this);
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      constexpr unsigned int number_of_particle_worlds = 1;
-      for (unsigned int world_index = 0; world_index < number_of_particle_worlds; ++world_index)
-        {
-          if (world_index == 0)
-            {
-              prm.enter_subsection("Particles");
-            }
-          else
-            {
-              prm.enter_subsection("Particles " + std::to_string(world_index+1));
-            }
-          {
-            prm.declare_entry ("Load balancing strategy", "repartition",
-                               Patterns::MultipleSelection ("none|remove particles|add particles|"
-                                                            "remove and add particles|repartition"),
-                               "Strategy that is used to balance the computational "
-                               "load across processors for adaptive meshes.");
-            prm.declare_entry ("Minimum particles per cell", "0",
-                               Patterns::Integer (0),
-                               "Lower limit for particle number per cell. This limit is "
-                               "useful for adaptive meshes to prevent fine cells from being empty "
-                               "of particles. It will be checked and enforced after mesh "
-                               "refinement and after particle movement. "
-                               "If there are "
-                               "\\texttt{n\\_number\\_of\\_particles} $<$ \\texttt{min\\_particles\\_per\\_cell} "
-                               "particles in one cell then "
-                               "\\texttt{min\\_particles\\_per\\_cell} - \\texttt{n\\_number\\_of\\_particles} "
-                               "particles are generated and randomly placed in "
-                               "this cell. If the particles carry properties the "
-                               "individual property plugins control how the "
-                               "properties of the new particles are initialized.");
-            prm.declare_entry ("Maximum particles per cell", "100",
-                               Patterns::Integer (0),
-                               "Upper limit for particle number per cell. This limit is "
-                               "useful for adaptive meshes to prevent coarse cells from slowing down "
-                               "the whole model. It will be checked and enforced after mesh "
-                               "refinement, after MPI transfer of particles and after particle "
-                               "movement. If there are "
-                               "\\texttt{n\\_number\\_of\\_particles} $>$ \\texttt{max\\_particles\\_per\\_cell} "
-                               "particles in one cell then "
-                               "\\texttt{n\\_number\\_of\\_particles} - \\texttt{max\\_particles\\_per\\_cell} "
-                               "particles in this cell are randomly chosen and destroyed.");
-            prm.declare_entry ("Particle weight", "10",
-                               Patterns::Integer (0),
-                               "Weight that is associated with the computational load of "
-                               "a single particle. The sum of particle weights will be added "
-                               "to the sum of cell weights to determine the partitioning of "
-                               "the mesh if the `repartition' particle load balancing strategy "
-                               "is selected. The optimal weight depends on the used "
-                               "integrator and particle properties. In general for a more "
-                               "expensive integrator and more expensive properties a larger "
-                               "particle weight is recommended. Before adding the weights "
-                               "of particles, each cell already carries a weight of 1000 to "
-                               "account for the cost of field-based computations.");
-            prm.declare_entry ("Update ghost particles", "false",
-                               Patterns::Bool (),
-                               "Some particle interpolation algorithms require knowledge "
-                               "about particles in neighboring cells. To allow this, "
-                               "particles in ghost cells need to be exchanged between the "
-                               "processes neighboring this cell. This parameter determines "
-                               "whether this transport is happening.");
-
-            Generator::declare_parameters<dim>(prm);
-            Integrator::declare_parameters<dim>(prm);
-            Interpolator::declare_parameters<dim>(prm);
-
-            Property::Manager<dim>::declare_parameters(prm);
-          }
-          prm.leave_subsection ();
-        }
-
-    }
-
-
-
-    template <int dim>
-    void
-    World<dim>::parse_parameters (ParameterHandler &prm, const unsigned int world_index)
-    {
-      // First do some error checking. The current algorithm does not find
-      // the cells around particles, if the particles moved more than one
-      // cell in one timestep and we are running in parallel, because they
-      // skip the layer of ghost cells around our local domain. Assert this
-      // is not possible.
-      const double CFL_number = prm.get_double ("CFL number");
-      const unsigned int n_processes = Utilities::MPI::n_mpi_processes(this->get_mpi_communicator());
-
-      AssertThrow((n_processes == 1) || (CFL_number <= 1.0),
-                  ExcMessage("The current particle algorithm does not work in "
-                             "parallel if the CFL number is larger than 1.0, because "
-                             "in this case particles can move more than one cell "
-                             "diameter in one time step and therefore skip the layer "
-                             "of ghost cells around the local subdomain."));
-
-      if (world_index == 0)
-        {
-          prm.enter_subsection("Particles");
-        }
-      else
-        {
-          prm.enter_subsection("Particles " + std::to_string(world_index+1));
-        }
-      {
-        min_particles_per_cell = prm.get_integer("Minimum particles per cell");
-        max_particles_per_cell = prm.get_integer("Maximum particles per cell");
-
-        AssertThrow(min_particles_per_cell <= max_particles_per_cell,
-                    ExcMessage("Please select a 'Minimum particles per cell' parameter "
-                               "that is smaller than or equal to the 'Maximum particles per cell' parameter."));
-
-        particle_weight = prm.get_integer("Particle weight");
-
-        update_ghost_particles = prm.get_bool("Update ghost particles");
-
-        const std::vector<std::string> strategies = Utilities::split_string_list(prm.get ("Load balancing strategy"));
-        AssertThrow(Utilities::has_unique_entries(strategies),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Particles/Load balancing strategy' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-
-        particle_load_balancing = ParticleLoadBalancing::no_balancing;
-
-        for (std::vector<std::string>::const_iterator strategy = strategies.begin(); strategy != strategies.end(); ++strategy)
-          {
-            if (*strategy == "remove particles")
-              particle_load_balancing = typename ParticleLoadBalancing::Kind(particle_load_balancing | ParticleLoadBalancing::remove_particles);
-            else if (*strategy == "add particles")
-              particle_load_balancing = typename ParticleLoadBalancing::Kind(particle_load_balancing | ParticleLoadBalancing::add_particles);
-            else if (*strategy == "remove and add particles")
-              particle_load_balancing = typename ParticleLoadBalancing::Kind(particle_load_balancing | ParticleLoadBalancing::remove_and_add_particles);
-            else if (*strategy == "repartition")
-              particle_load_balancing = typename ParticleLoadBalancing::Kind(particle_load_balancing | ParticleLoadBalancing::repartition);
-            else if (*strategy == "none")
-              {
-                particle_load_balancing = ParticleLoadBalancing::no_balancing;
-                AssertThrow(strategies.size() == 1,
-                            ExcMessage("The particle load balancing strategy `none' is not compatible "
-                                       "with any other strategy, yet it seems another is selected as well. "
-                                       "Please check the parameter file."));
-              }
-            else
-              AssertThrow(false,
-                          ExcMessage("The 'Load balancing strategy' parameter contains an unknown value: <" + *strategy
-                                     + ">. This value does not correspond to any known load balancing strategy. Possible values "
-                                     "are listed in the corresponding manual subsection."));
-          }
-
-
-        TimerOutput::Scope timer_section(this->get_computing_timer(), "Particles: Initialization");
-
-        // Create a generator object depending on what the parameters specify
-        generator = Generator::create_particle_generator<dim> (prm);
-        if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(generator.get()))
-          sim->initialize_simulator (this->get_simulator());
-        generator->set_particle_world_index(world_index);
-        generator->parse_parameters(prm);
-        generator->initialize();
-
-        // Create a property_manager object and initialize its properties
-        property_manager = std::make_unique<Property::Manager<dim>> ();
-        SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(property_manager.get());
-        sim->initialize_simulator (this->get_simulator());
-        property_manager->set_particle_world_index(world_index);
-        property_manager->parse_parameters(prm);
-        property_manager->initialize();
-
-        // Create an integrator object depending on the specified parameter
-        integrator = Integrator::create_particle_integrator<dim> (prm);
-        if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(integrator.get()))
-          sim->initialize_simulator (this->get_simulator());
-        integrator->set_particle_world_index(world_index);
-        integrator->parse_parameters(prm);
-        integrator->initialize();
-
-        // Create an interpolator object depending on the specified parameter
-        interpolator = Interpolator::create_particle_interpolator<dim> (prm);
-        if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(interpolator.get()))
-          sim->initialize_simulator (this->get_simulator());
-        interpolator->set_particle_world_index(world_index);
-        interpolator->parse_parameters(prm);
-        interpolator->initialize();
-
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace Particle
-  {
-#define INSTANTIATE(dim) \
-  template class World<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/plugins.cc.bak b/source/plugins.cc.bak
deleted file mode 100644
index 2964077a074..00000000000
--- a/source/plugins.cc.bak
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-  Copyright (C) 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/plugins.h>
-
-namespace aspect
-{
-  namespace Plugins
-  {
-    void
-    InterfaceBase::initialize ()
-    {}
-
-
-
-    void
-    InterfaceBase::update ()
-    {}
-
-
-
-    void
-    InterfaceBase::
-    declare_parameters (dealii::ParameterHandler &)
-    {}
-
-
-
-    void
-    InterfaceBase::parse_parameters (dealii::ParameterHandler &)
-    {}
-  }
-}
diff --git a/source/postprocess/ODE_statistics.cc.bak b/source/postprocess/ODE_statistics.cc.bak
deleted file mode 100644
index 263bf22f7ba..00000000000
--- a/source/postprocess/ODE_statistics.cc.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/ODE_statistics.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <aspect/simulator.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    void
-    ODEStatistics<dim>::initialize()
-    {
-      this->get_signals().post_ARKode_solve.connect(
-        [&](const SimulatorAccess<dim> &/*simulator_access*/,
-            const unsigned int iteration_count)
-      {
-        this->store_ODE_solver_history(iteration_count);
-      });
-
-      this->clear_data();
-    }
-
-
-
-    template <int dim>
-    void
-    ODEStatistics<dim>::clear_data()
-    {
-      total_iteration_count = 0;
-      number_of_solves = 0;
-    }
-
-
-
-    template <int dim>
-    void
-    ODEStatistics<dim>::store_ODE_solver_history(const unsigned int iteration_count)
-    {
-      total_iteration_count += iteration_count;
-      number_of_solves += 1;
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    ODEStatistics<dim>::execute (TableHandler &statistics)
-    {
-#if DEAL_II_VERSION_GTE(9,6,0)
-      const double average_iteration_count = number_of_solves > 0
-                                             ?
-                                             total_iteration_count / number_of_solves
-                                             :
-                                             total_iteration_count;
-#else
-      // The computation is not correct for dealii versions older than
-      // June 2024.
-      const double average_iteration_count = std::numeric_limits<double>::quiet_NaN();
-#endif
-      statistics.add_value("Average iterations for ODE solver",
-                           average_iteration_count);
-
-      clear_data();
-
-      return std::make_pair (std::string(),std::string());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(ODEStatistics,
-                                  "ODE statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "ODEs solved during the model evolution, specifically, "
-                                  "how many iterations are needed to solve these ODEs "
-                                  "on average. ")
-  }
-}
diff --git a/source/postprocess/basic_statistics.cc.bak b/source/postprocess/basic_statistics.cc.bak
deleted file mode 100644
index ae0cea991ba..00000000000
--- a/source/postprocess/basic_statistics.cc.bak
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/basic_statistics.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/global.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    BasicStatistics<dim>::execute (TableHandler &)
-    {
-      if (!Plugins::plugin_type_matches<const MaterialModel::Simple<dim>>(this->get_material_model()))
-        return std::make_pair (std::string(),std::string());
-
-      if ((this->get_timestep_number() == 0) &&
-          (this->get_pre_refinement_step() == std::numeric_limits<unsigned int>::max()))
-        {
-          // Define the representative point (in this case a point with depth 0 -> at the surface)
-          const double reference_depth = 0.0;
-          const Point<dim> representative_point = this->get_geometry_model().representative_point(reference_depth);
-          const double gravity = this->get_gravity_model().gravity_vector(representative_point).norm();
-          const double model_depth = this->get_geometry_model().maximal_depth();
-
-          // temperature contrast is only meaningful if boundary temperatures are prescribed, otherwise it is 0
-          const double temperature_contrast = (this->has_boundary_temperature()
-                                               ?
-                                               this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators())
-                                               - this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators())
-                                               :
-                                               0);
-
-          // Compute material properties at the reference point using the adiabatic
-          // profile as reference temperature and pressure
-          const double temperature = this->get_adiabatic_conditions().temperature(representative_point);
-          const double pressure = this->get_adiabatic_conditions().pressure(representative_point);
-
-          MaterialModel::MaterialModelInputs<dim> in (1, this->n_compositional_fields());
-          MaterialModel::MaterialModelOutputs<dim> out (1, this->n_compositional_fields());
-          in.requested_properties = MaterialModel::MaterialProperties::thermal_conductivity |
-                                    MaterialModel::MaterialProperties::equation_of_state_properties |
-                                    MaterialModel::MaterialProperties::viscosity;
-
-          in.position[0] = representative_point;
-          in.temperature[0] = temperature;
-          in.pressure[0] = pressure;
-          for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-            in.composition[0][c] = 0.0;
-
-          this->get_material_model().evaluate(in, out);
-
-          const double thermal_diffusivity = ( (this->get_parameters().formulation_temperature_equation ==
-                                                Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-                                               ?
-                                               out.thermal_conductivities[0] /
-                                               (this->get_adiabatic_conditions().density(in.position[0]) * out.specific_heat[0])
-                                               :
-                                               out.thermal_conductivities[0] / (out.densities[0] * out.specific_heat[0])
-                                             );
-
-          // check whether diffusivity is set to 0 (in case of backward advection)
-          const double Ra = (thermal_diffusivity != 0) ?
-                            out.densities[0] *
-                            gravity *
-                            out.thermal_expansion_coefficients[0] *
-                            temperature_contrast * std::pow(model_depth,3)/
-                            (thermal_diffusivity * out.viscosities[0])
-                            :
-                            std::numeric_limits<double>::infinity();
-
-          this->get_pcout() <<  std::endl;
-          this->get_pcout() << "     Model domain depth (m):                        "
-                            << model_depth
-                            << std::endl;
-          this->get_pcout() << "     Temperature contrast across model domain (K):  "
-                            << temperature_contrast
-                            << std::endl;
-          this->get_pcout() << "     Reference depth (m):                           "
-                            << reference_depth
-                            << std::endl;
-          this->get_pcout() << "     Reference temperature (K):                     "
-                            << temperature
-                            << std::endl;
-          this->get_pcout() << "     Reference pressure (Pa):                       "
-                            << pressure
-                            << std::endl;
-          this->get_pcout() << "     Reference gravity (m/s^2):                     "
-                            << gravity
-                            << std::endl;
-          this->get_pcout() << "     Reference density (kg/m^3):                    "
-                            << out.densities[0]
-                            << std::endl;
-          this->get_pcout() << "     Reference thermal expansion coefficient (1/K): "
-                            << out.thermal_expansion_coefficients[0]
-                            << std::endl;
-          this->get_pcout() << "     Reference specific heat capacity (J/(K*kg)):   "
-                            << out.specific_heat[0]
-                            << std::endl;
-          this->get_pcout() << "     Reference thermal conductivity (W/(m*K)):      "
-                            << out.thermal_conductivities[0]
-                            << std::endl;
-          this->get_pcout() << "     Reference viscosity (Pa*s):                    "
-                            << out.viscosities[0]
-                            << std::endl;
-          this->get_pcout() << "     Reference thermal diffusivity (m^2/s):         "
-                            << thermal_diffusivity
-                            << std::endl;
-          this->get_pcout() << "     Rayleigh number:                               "
-                            << Ra
-                            << std::endl;
-
-          this->get_pcout() << std::endl;
-        }
-      return std::make_pair (std::string(),std::string());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(BasicStatistics,
-                                  "basic statistics",
-                                  "A postprocessor that outputs some simplified statistics "
-                                  "like the Rayleigh number and other quantities that only "
-                                  "make sense in certain model setups. The output is written "
-                                  "after completing initial adaptive refinement steps. "
-                                  "The postprocessor assumes a point at the surface at the adiabatic "
-                                  "surface temperature and pressure is a reasonable reference condition "
-                                  "for computing these properties. Furthermore, the Rayleigh "
-                                  "number is computed using the model depth (i.e. not the "
-                                  "radius of the Earth), as we need a definition that is geometry "
-                                  "independent. Take care when comparing these values to published "
-                                  "studies and make sure they use the same definitions.")
-  }
-}
diff --git a/source/postprocess/boundary_densities.cc.bak b/source/postprocess/boundary_densities.cc.bak
deleted file mode 100644
index ce4d9b71df1..00000000000
--- a/source/postprocess/boundary_densities.cc.bak
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/boundary_densities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    BoundaryDensities<dim>::execute (TableHandler &statistics)
-    {
-      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.temperature;
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula,
-                                        update_values |
-                                        update_gradients |
-                                        update_quadrature_points |
-                                        update_JxW_values);
-
-      double local_top_density = 0.;
-      double local_bottom_density = 0.;
-      double local_top_area = 0.;
-      double local_bottom_area = 0.;
-
-      typename MaterialModel::Interface<dim>::MaterialModelInputs in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-      typename MaterialModel::Interface<dim>::MaterialModelOutputs out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::density;
-      std::vector<std::vector<double>> composition_values(this->n_compositional_fields(), std::vector<double>(fe_face_values.n_quadrature_points));
-
-      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-      const types::boundary_id bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
-
-      // loop over all of the surface cells and if one less than h/3 away from
-      // the top or bottom surface, evaluate the density on that face
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          for (const unsigned int f : cell->face_indices())
-            {
-              bool cell_at_top = false;
-              bool cell_at_bottom = false;
-
-              // Test for top or bottom surface cell faces
-              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
-                cell_at_top = true;
-              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
-                cell_at_bottom = true;
-
-              if (cell_at_top || cell_at_bottom)
-                {
-                  // handle surface cells
-                  fe_face_values.reinit (cell, f);
-                  fe_face_values[this->introspection().extractors.temperature]
-                  .get_function_values (this->get_solution(), in.temperature);
-                  fe_face_values[this->introspection().extractors.pressure]
-                  .get_function_values (this->get_solution(), in.pressure);
-                  fe_face_values[this->introspection().extractors.velocities]
-                  .get_function_symmetric_gradients (this->get_solution(), in.strain_rate);
-
-                  in.position = fe_face_values.get_quadrature_points();
-
-                  for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                    fe_face_values[this->introspection().extractors.compositional_fields[c]]
-                    .get_function_values(this->get_solution(),
-                                         composition_values[c]);
-                  for (unsigned int i=0; i<fe_face_values.n_quadrature_points; ++i)
-                    {
-                      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                        in.composition[i][c] = composition_values[c][i];
-                    }
-
-                  this->get_material_model().evaluate(in, out);
-
-                  // calculate the top/bottom properties
-                  if (cell_at_top)
-                    for ( unsigned int q = 0; q < fe_face_values.n_quadrature_points; ++q)
-                      {
-                        local_top_density += out.densities[q] * fe_face_values.JxW(q);
-                        local_top_area += fe_face_values.JxW(q);
-                      }
-                  if (cell_at_bottom)
-                    for ( unsigned int q = 0; q < fe_face_values.n_quadrature_points; ++q)
-                      {
-                        local_bottom_density += out.densities[q] * fe_face_values.JxW(q);
-                        local_bottom_area += fe_face_values.JxW(q);
-                      }
-                }
-            }
-
-      // vector for packing local values before MPI summing them
-      double values[4] = {local_bottom_area, local_top_area, local_bottom_density, local_top_density};
-
-      Utilities::MPI::sum<double, 4>( values, this->get_mpi_communicator(), values );
-
-      top_density = values[3] / values[1]; // density over area
-      bottom_density = values[2] / values[0]; // density over area
-
-      statistics.add_value ("Density at top (kg/m^3)",
-                            top_density);
-      statistics.add_value ("Density at bottom (kg/m^3)",
-                            bottom_density);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      {
-        const char *columns[] = { "Density at top (kg/m^3)",
-                                  "Density at bottom (kg/m^3)"
-                                };
-        for (auto &column : columns)
-          {
-            statistics.set_precision (column, 8);
-            statistics.set_scientific (column, true);
-          }
-      }
-
-      std::ostringstream output;
-      output.precision(4);
-      output << top_density << " kg/m^3, "
-             << bottom_density << " kg/m^3";
-
-      return std::pair<std::string, std::string> ("Density at top/bottom of domain:",
-                                                  output.str());
-    }
-
-    template <int dim>
-    double
-    BoundaryDensities<dim>::density_at_top() const
-    {
-      return top_density;
-    }
-
-    template <int dim>
-    double
-    BoundaryDensities<dim>::density_at_bottom() const
-    {
-      return bottom_density;
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(BoundaryDensities,
-                                  "boundary densities",
-                                  "A postprocessor that computes the laterally averaged "
-                                  "density at the top and bottom of the domain.")
-  }
-}
diff --git a/source/postprocess/boundary_pressures.cc.bak b/source/postprocess/boundary_pressures.cc.bak
deleted file mode 100644
index 4e52f793394..00000000000
--- a/source/postprocess/boundary_pressures.cc.bak
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/boundary_pressures.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    BoundaryPressures<dim>::execute (TableHandler &statistics)
-    {
-      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.pressure;
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula,
-                                        update_values |
-                                        update_gradients |
-                                        update_quadrature_points |
-                                        update_JxW_values);
-
-      double local_top_pressure = 0.;
-      double local_bottom_pressure = 0.;
-      double local_top_area = 0.;
-      double local_bottom_area = 0.;
-
-      std::vector<double> pressure_vals (fe_face_values.n_quadrature_points);
-
-      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-      const types::boundary_id bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
-
-      // loop over all of the surface cells and if one less than h/3 away from
-      // the top or bottom surface, evaluate the pressure on that face
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          for (const unsigned int f : cell->face_indices())
-            {
-              bool cell_at_top = false;
-              bool cell_at_bottom = false;
-
-              // Test for top or bottom surface cell faces
-              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
-                cell_at_top = true;
-              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
-                cell_at_bottom = true;
-
-
-              if (cell_at_top || cell_at_bottom)
-                {
-                  // evaluate the pressure on the face
-                  fe_face_values.reinit (cell, f);
-                  fe_face_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(), pressure_vals);
-
-                  // calculate the top properties
-                  if (cell_at_top)
-                    for ( unsigned int q = 0; q < fe_face_values.n_quadrature_points; ++q)
-                      {
-                        local_top_pressure += pressure_vals[q] * fe_face_values.JxW(q);
-                        local_top_area += fe_face_values.JxW(q);
-                      }
-                  if (cell_at_bottom)
-                    for ( unsigned int q = 0; q < fe_face_values.n_quadrature_points; ++q)
-                      {
-                        local_bottom_pressure += pressure_vals[q] * fe_face_values.JxW(q);
-                        local_bottom_area += fe_face_values.JxW(q);
-                      }
-                }
-            }
-
-      // vector for packing local values before MPI summing them
-      double values[4] = {local_bottom_area, local_top_area, local_bottom_pressure, local_top_pressure};
-
-      Utilities::MPI::sum<double, 4>( values, this->get_mpi_communicator(), values );
-
-      top_pressure = values[3] / values[1]; // density over area
-      bottom_pressure = values[2] / values[0]; // density over area
-
-      statistics.add_value ("Pressure at top (Pa)",
-                            top_pressure);
-      statistics.add_value ("Pressure at bottom (Pa)",
-                            bottom_pressure);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      {
-        const char *columns[] = { "Pressure at top (Pa)",
-                                  "Pressure at bottom (Pa)"
-                                };
-        for (auto &column : columns)
-          {
-            statistics.set_precision (column, 8);
-            statistics.set_scientific (column, true);
-          }
-      }
-
-      std::ostringstream output;
-      output.precision(4);
-      output << top_pressure << " Pa, "
-             << bottom_pressure << " Pa";
-
-      return std::pair<std::string, std::string> ("Pressure at top/bottom of domain:",
-                                                  output.str());
-    }
-
-    template <int dim>
-    double
-    BoundaryPressures<dim>::pressure_at_top() const
-    {
-      return top_pressure;
-    }
-
-    template <int dim>
-    double
-    BoundaryPressures<dim>::pressure_at_bottom() const
-    {
-      return bottom_pressure;
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(BoundaryPressures,
-                                  "boundary pressures",
-                                  "A postprocessor that computes the laterally averaged "
-                                  "pressure at the top and bottom of the domain.")
-  }
-}
diff --git a/source/postprocess/boundary_strain_rate_residual_statistics.cc.bak b/source/postprocess/boundary_strain_rate_residual_statistics.cc.bak
deleted file mode 100644
index 251880b9451..00000000000
--- a/source/postprocess/boundary_strain_rate_residual_statistics.cc.bak
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/postprocess/boundary_strain_rate_residual_statistics.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    void
-    BoundaryStrainRateResidualStatistics<dim>::initialize ()
-    {
-      strain_rate_data_lookup = std::make_unique<Utilities::StructuredDataLookup<dim>>(1, scale_factor);
-      strain_rate_data_lookup->load_file(data_directory + data_file_name, this->get_mpi_communicator());
-    }
-
-
-
-    template <int dim>
-    double
-    BoundaryStrainRateResidualStatistics<dim>::get_data_surface_strain_rate (const Point<dim> &p) const
-    {
-      Point<dim> internal_position = p;
-
-      if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical)
-        {
-          const std::array<double,dim> spherical_position = this->get_geometry_model().
-                                                            cartesian_to_natural_coordinates(p);
-
-          for (unsigned int d = 0; d < dim; ++d)
-            internal_position[d] = spherical_position[d];
-        }
-
-      const double data_surface_strain_rate = strain_rate_data_lookup->get_data(internal_position, 0);
-
-      return data_surface_strain_rate;
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    BoundaryStrainRateResidualStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula for the velocity.
-      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.velocities;
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula,
-                                        update_gradients |
-                                        update_JxW_values |
-                                        update_quadrature_points);
-
-      // This variable stores the strain rates computed at the quadrature points.
-      std::vector<SymmetricTensor<2,dim>> strain_rate (fe_face_values.n_quadrature_points);
-
-      std::map<types::boundary_id, double> local_max_eii;
-      std::map<types::boundary_id, double> local_min_eii;
-      std::map<types::boundary_id, double> local_eii_square_integral;
-      std::map<types::boundary_id, double> local_boundary_area;
-
-      std::set<types::boundary_id> boundary_indicators;
-      boundary_indicators.insert(this->get_geometry_model().translate_symbolic_boundary_name_to_id("top"));
-
-      AssertThrow (boundary_indicators.size() == 1,
-                   ExcMessage("The <boundary strain rate residual statistics> plugin is only tested "
-                              "to work correctly for a single boundary indicator, "
-                              "but more than one was specified."));
-
-      for (const auto boundary_id : boundary_indicators)
-        {
-          local_max_eii[boundary_id] = std::numeric_limits<double>::lowest();
-          local_min_eii[boundary_id] = std::numeric_limits<double>::max();
-        }
-
-      // for every face that is part of the selected geometry boundary
-      // and that is owned by this processor,
-      // compute the maximum, minimum, and squared*area strain rate invariant residual
-      // magnitude, and the face area.
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (const unsigned int f : cell->face_indices())
-            for (const auto current_boundary_id : boundary_indicators)
-              if (cell->face(f)->at_boundary() && cell->face(f)->boundary_id() == current_boundary_id)
-                {
-                  fe_face_values.reinit (cell, f);
-
-                  fe_face_values[this->introspection().extractors.velocities].get_function_symmetric_gradients
-                  (this->get_solution(), strain_rate);
-
-                  // determine the max, min, and area integral of squared strain rate residual on the face
-                  // also determine the face area
-                  double local_max = std::numeric_limits<double>::lowest();
-                  double local_min = std::numeric_limits<double>::max();
-                  double local_square_strain_rate = 0.0;
-                  double local_fe_face_area = 0.0;
-                  for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                    {
-                      const Point<dim> point_at_surface = fe_face_values.quadrature_point(q);
-
-                      // Extract the strain rate invariant output here.
-                      const double e_ii = std::sqrt(std::fabs(second_invariant(deviator(strain_rate[q]))));
-
-                      // Extract data strain rate invartiant.
-                      double e_ii_data = get_data_surface_strain_rate(point_at_surface);
-
-                      if (this->convert_output_to_years() == true)
-                        e_ii_data = e_ii_data/year_in_seconds;
-
-                      // The strain rate invariant residual is calculated here. Ignore the computation if we
-                      // encounter nan or 1e300 in the input data.
-                      double strain_invariant_residual = 0;
-                      if (e_ii_data < 1e300 || !std::isnan(e_ii_data))
-                        strain_invariant_residual = std::abs(e_ii_data - e_ii);
-                      else
-                        continue;
-
-                      local_max = std::max(strain_invariant_residual,
-                                           local_max);
-                      local_min = std::min(strain_invariant_residual,
-                                           local_min);
-                      local_square_strain_rate += ((strain_invariant_residual * strain_invariant_residual) * fe_face_values.JxW(q));
-                      local_fe_face_area += fe_face_values.JxW(q);
-                    }
-                  // then merge them with the min/max/squared strain rates
-                  // and face areas we found for other faces with the same boundary indicator
-                  local_max_eii[current_boundary_id] = std::max(local_max,
-                                                                local_max_eii[current_boundary_id]);
-                  local_min_eii[current_boundary_id] = std::min(local_min,
-                                                                local_min_eii[current_boundary_id]);
-                  local_eii_square_integral[current_boundary_id] += local_square_strain_rate;
-                  local_boundary_area[current_boundary_id] += local_fe_face_area;
-                }
-
-      // now communicate to get the global values
-      std::map<types::boundary_id, double> global_max_eii;
-      std::map<types::boundary_id, double> global_min_eii;
-      std::map<types::boundary_id, double> global_rms_eii;
-      {
-        // first collect local values in the same order in which they are listed
-        // in the set of boundary indicators
-        std::vector<double> local_max_values;
-        std::vector<double> local_min_values;
-        std::vector<double> local_eii_square_integral_values;
-        std::vector<double> local_boundary_area_values;
-
-        for (const auto p : boundary_indicators)
-          {
-            local_max_values.push_back (local_max_eii[p]);
-            local_min_values.push_back (local_min_eii[p]);
-
-            local_eii_square_integral_values.push_back (local_eii_square_integral[p]);
-            local_boundary_area_values.push_back (local_boundary_area[p]);
-          }
-
-        // then collect contributions from all processors
-        std::vector<double> global_max_values (local_max_values.size());
-        Utilities::MPI::max (local_max_values, this->get_mpi_communicator(), global_max_values);
-        std::vector<double> global_min_values (local_min_values.size());
-        Utilities::MPI::min (local_min_values, this->get_mpi_communicator(), global_min_values);
-
-        std::vector<double> global_eii_square_integral_values (local_eii_square_integral_values.size());
-        Utilities::MPI::sum(local_eii_square_integral_values,this->get_mpi_communicator(),global_eii_square_integral_values);
-        std::vector<double> global_boundary_area_values (local_boundary_area_values.size());
-        Utilities::MPI::sum(local_boundary_area_values,this->get_mpi_communicator(),global_boundary_area_values);
-
-        // and now take them apart into the global map again
-        // At the same time, calculate the rms strain rate invariant for each boundary
-        unsigned int index = 0;
-        for (const auto boundary_id: boundary_indicators)
-          {
-            global_max_eii[boundary_id] = global_max_values[index];
-            global_min_eii[boundary_id] = global_min_values[index];
-            global_rms_eii[boundary_id] = std::sqrt(global_eii_square_integral_values[index] / global_boundary_area_values[index]);
-            ++index;
-          }
-      }
-
-      // now add the computed max, min, and rms strain rates to the statistics object
-      // and create a single string that can be output to the screen
-      const std::string units = (this->convert_output_to_years() == true) ? "1/yr" : "1/s";
-      const double unit_scale_factor = (this->convert_output_to_years() == true) ? year_in_seconds : 1.0;
-      std::ostringstream screen_text;
-      unsigned int index = 0;
-
-      for (std::map<types::boundary_id, double>::const_iterator
-           max_eii = global_max_eii.begin(), min_eii = global_min_eii.begin(), rms = global_rms_eii.begin();
-           max_eii != global_max_eii.end() && min_eii != global_min_eii.end() && rms != global_rms_eii.end();
-           ++max_eii, ++min_eii, ++rms, ++index)
-        {
-          const std::string name_max = "Maximum strain rate invariant residual magnitude on boundary with indicator "
-                                       + Utilities::int_to_string(max_eii->first)
-                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                     .translate_id_to_symbol_name (max_eii->first))
-                                       + " (" + units + ")";
-          statistics.add_value (name_max, max_eii->second*unit_scale_factor);
-          const std::string name_min = "Minimum strain rate invariant residual magnitude on boundary with indicator "
-                                       + Utilities::int_to_string(min_eii->first)
-                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                     .translate_id_to_symbol_name (min_eii->first))
-                                       + " (" + units + ")";
-          statistics.add_value (name_min, min_eii->second*unit_scale_factor);
-          const std::string name_rms = "RMS strain rate invariant residual on boundary with indicator "
-                                       + Utilities::int_to_string(rms->first)
-                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                     .translate_id_to_symbol_name (rms->first))
-                                       + " (" + units + ")";
-          statistics.add_value (name_rms, rms->second*unit_scale_factor);
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (name_max, 8);
-          statistics.set_scientific (name_max, true);
-          statistics.set_precision (name_min, 8);
-          statistics.set_scientific (name_min, true);
-          statistics.set_precision (name_rms, 8);
-          statistics.set_scientific (name_rms, true);
-
-          screen_text << max_eii->second *unit_scale_factor << " " << units << ", "
-                      << min_eii->second *unit_scale_factor << " " << units << ", "
-                      << rms->second *unit_scale_factor << " " << units
-                      << (index == global_max_eii.size()-1 ? "" : ", ");
-
-        }
-
-      return std::pair<std::string, std::string> ("Max, min, and RMS residual strain rate invariant along boundary parts:",
-                                                  screen_text.str());
-    }
-
-
-
-    template <int dim>
-    void
-    BoundaryStrainRateResidualStatistics<dim>::declare_parameters (ParameterHandler  &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Boundary strain rate residual statistics");
-        {
-          prm.declare_entry ("Data directory",
-                             "$ASPECT_SOURCE_DIR/data/postprocess/boundary-strain-rate-residual/",
-                             Patterns::DirectoryName (),
-                             "The name of a directory that contains the ascii data. "
-                             "This path may either be absolute (if starting with a "
-                             "`/') or relative to the current directory. The path may also "
-                             "include the special text `$ASPECT_SOURCE_DIR' which will be "
-                             "interpreted as the path in which the ASPECT source files were "
-                             "located when ASPECT was compiled. This interpretation allows, "
-                             "for example, to reference files located in the `data/' subdirectory "
-                             "of ASPECT.");
-          prm.declare_entry ("Data file name", "box_3d_boundary_strain_rate.txt",
-                             Patterns::Anything (),
-                             "The file name of the input surface strain rate an ascii data. "
-                             "The file has one column in addition to the coordinate columns "
-                             "corresponding to the second invariant of strain rate. ");
-          prm.declare_entry ("Scale factor", "1.",
-                             Patterns::Double (),
-                             "Scalar factor, which is applied to the model data. "
-                             "You might want to use this to scale the input to a "
-                             "reference model.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    BoundaryStrainRateResidualStatistics<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Boundary strain rate residual statistics");
-        {
-          // Get the path to the data files. If it contains a reference
-          // to $ASPECT_SOURCE_DIR, replace it by what CMake has given us
-          // as a #define
-          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-          data_file_name    = prm.get ("Data file name");
-          scale_factor      = prm.get_double ("Scale factor");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(BoundaryStrainRateResidualStatistics,
-                                  "boundary strain rate residual statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the surface strain rate residual along the top boundary. The residual "
-                                  "is the difference between the second invariant of the model strain rate and "
-                                  "the second strain rate invariant read from the input data file. "
-                                  "Currently, the strain residual statistics, i.e., min, max and the rms magnitude, "
-                                  "are computed at the top surface.")
-  }
-}
diff --git a/source/postprocess/boundary_velocity_residual_statistics.cc.bak b/source/postprocess/boundary_velocity_residual_statistics.cc.bak
deleted file mode 100644
index 2390c4e7be6..00000000000
--- a/source/postprocess/boundary_velocity_residual_statistics.cc.bak
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/postprocess/boundary_velocity_residual_statistics.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    void
-    BoundaryVelocityResidualStatistics<dim>::initialize ()
-    {
-      if (use_ascii_data)
-        {
-          // The input ascii table contains dim data columns (velocity components) in addition to the coordinate columns.
-          data_lookup = std::make_unique<Utilities::StructuredDataLookup<dim>>(dim, scale_factor);
-          data_lookup->load_file(data_directory + data_file_name, this->get_mpi_communicator());
-        }
-      else
-        {
-          // The two points are used in GPlates to find the 2d plane in which
-          // the model lies.  These values are not used for 3d geometries and
-          // are thus set to the default.
-          Point<2> point_one(numbers::PI/2., 0.);
-          Point<2> point_two(numbers::PI/2., numbers::PI/2.);
-
-          gplates_lookup =  std::make_unique<BoundaryVelocity::internal::GPlatesLookup<dim>> (
-                              point_one, point_two);
-
-          gplates_lookup->load_file(data_directory + data_file_name, this->get_mpi_communicator());
-        }
-    }
-
-
-
-    template <int dim>
-    Tensor<1,dim>
-    BoundaryVelocityResidualStatistics<dim>::get_data_velocity (const Point<dim> &p) const
-    {
-      Tensor<1,dim> data_velocity;
-      if (use_ascii_data)
-        {
-          Point<dim> internal_position = p;
-
-          if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical)
-            {
-              const std::array<double,dim> spherical_position = this->get_geometry_model().
-                                                                cartesian_to_natural_coordinates(p);
-
-              for (unsigned int d = 0; d < dim; ++d)
-                internal_position[d] = spherical_position[d];
-            }
-
-          for (unsigned int d = 0; d < dim; ++d)
-            data_velocity[d] = data_lookup->get_data(internal_position, d);
-          if (use_spherical_unit_vectors == true)
-            data_velocity = Utilities::Coordinates::spherical_to_cartesian_vector(data_velocity, p);
-        }
-      else
-        {
-          data_velocity =  gplates_lookup->surface_velocity(p);
-        }
-
-      return data_velocity;
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    BoundaryVelocityResidualStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula for the velocity.
-      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.velocities;
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula,
-                                        update_values |
-                                        update_JxW_values |
-                                        update_quadrature_points);
-
-      std::vector<Tensor<1,dim>> velocities (fe_face_values.n_quadrature_points);
-
-      std::map<types::boundary_id, double> local_max_vel;
-      std::map<types::boundary_id, double> local_min_vel;
-      std::map<types::boundary_id, double> local_velocity_square_integral;
-      std::map<types::boundary_id, double> local_boundary_area;
-
-      std::set<types::boundary_id> boundary_indicators;
-      boundary_indicators.insert(this->get_geometry_model().translate_symbolic_boundary_name_to_id("top"));
-
-      AssertThrow (boundary_indicators.size() == 1,
-                   ExcMessage("The <boundary velocity residual statistics> plugin is only tested "
-                              "to work correctly for a single boundary indicator, "
-                              "but more than one was specified."));
-
-      for (const auto p : boundary_indicators)
-        {
-          local_max_vel[p] = std::numeric_limits<double>::lowest();
-          local_min_vel[p] = std::numeric_limits<double>::max();
-        }
-
-      // for every face that is part of the selected geometry boundary
-      // and that is owned by this processor,
-      // compute the maximum, minimum, and squared*area velocity residual
-      // magnitude and the face area.
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (const unsigned int f : cell->face_indices())
-            for (const auto current_boundary_id : boundary_indicators)
-              if (cell->face(f)->at_boundary() && cell->face(f)->boundary_id() == current_boundary_id)
-                {
-                  fe_face_values.reinit (cell, f);
-
-                  fe_face_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                      velocities);
-
-                  // determine the max, min, and squared velocity residual on the face
-                  // also determine the face area
-                  double local_max = std::numeric_limits<double>::lowest();
-                  double local_min = std::numeric_limits<double>::max();
-                  double local_sqvel = 0.0;
-                  double local_fe_face_area = 0.0;
-                  for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                    {
-                      const Point<dim> point_at_surface = fe_face_values.quadrature_point(q);
-                      // Extract data velocity.
-                      Tensor<1,dim> data_velocity = get_data_velocity(point_at_surface);
-
-                      if (this->convert_output_to_years() == true)
-                        data_velocity = data_velocity/year_in_seconds;
-
-                      // The velocity residual is calculated here.
-                      const double vel_residual_mag = (velocities[q] - data_velocity).norm();
-
-                      local_max = std::max(vel_residual_mag,
-                                           local_max);
-                      local_min = std::min(vel_residual_mag,
-                                           local_min);
-                      local_sqvel += ((vel_residual_mag * vel_residual_mag) * fe_face_values.JxW(q));
-                      local_fe_face_area += fe_face_values.JxW(q);
-                    }
-
-                  // then merge them with the min/max/squared velocities
-                  // and face areas we found for other faces with the same boundary indicator
-                  local_max_vel[current_boundary_id] = std::max(local_max,
-                                                                local_max_vel[current_boundary_id]);
-                  local_min_vel[current_boundary_id] = std::min(local_min,
-                                                                local_min_vel[current_boundary_id]);
-                  local_velocity_square_integral[current_boundary_id] += local_sqvel;
-                  local_boundary_area[current_boundary_id] += local_fe_face_area;
-                }
-
-      // now communicate to get the global values
-      std::map<types::boundary_id, double> global_max_vel;
-      std::map<types::boundary_id, double> global_min_vel;
-      std::map<types::boundary_id, double> global_rms_vel;
-      {
-        // first collect local values in the same order in which they are listed
-        // in the set of boundary indicators
-        std::vector<double> local_max_values;
-        std::vector<double> local_min_values;
-        std::vector<double> local_velocity_square_integral_values;
-        std::vector<double> local_boundary_area_values;
-
-        for (const auto p : boundary_indicators)
-          {
-            local_max_values.push_back (local_max_vel[p]);
-            local_min_values.push_back (local_min_vel[p]);
-
-            local_velocity_square_integral_values.push_back (local_velocity_square_integral[p]);
-            local_boundary_area_values.push_back (local_boundary_area[p]);
-          }
-
-        // then collect contributions from all processors
-        std::vector<double> global_max_values (local_max_values.size());
-        Utilities::MPI::max (local_max_values, this->get_mpi_communicator(), global_max_values);
-        std::vector<double> global_min_values (local_min_values.size());
-        Utilities::MPI::min (local_min_values, this->get_mpi_communicator(), global_min_values);
-
-        std::vector<double> global_velocity_square_integral_values (local_velocity_square_integral_values.size());
-        Utilities::MPI::sum(local_velocity_square_integral_values,this->get_mpi_communicator(),global_velocity_square_integral_values);
-        std::vector<double> global_boundary_area_values (local_boundary_area_values.size());
-        Utilities::MPI::sum(local_boundary_area_values,this->get_mpi_communicator(),global_boundary_area_values);
-
-        // and now take them apart into the global map again
-        // At the same time, calculate the rms velocity for each boundary
-        unsigned int index = 0;
-        for (const auto boundary_id: boundary_indicators)
-          {
-            global_max_vel[boundary_id] = global_max_values[index];
-            global_min_vel[boundary_id] = global_min_values[index];
-            global_rms_vel[boundary_id] = std::sqrt(global_velocity_square_integral_values[index] / global_boundary_area_values[index]);
-            ++index;
-          }
-      }
-
-      // now add the computed max, min, and rms velocities to the statistics object
-      // and create a single string that can be output to the screen
-      const std::string units = (this->convert_output_to_years() == true) ? "m/year" : "m/s";
-      const double unit_scale_factor = (this->convert_output_to_years() == true) ? year_in_seconds : 1.0;
-      std::ostringstream screen_text;
-      unsigned int index = 0;
-
-      for (std::map<types::boundary_id, double>::const_iterator
-           max_velocity = global_max_vel.begin(), min_velocity = global_min_vel.begin(), rms = global_rms_vel.begin();
-           max_velocity != global_max_vel.end() && min_velocity != global_min_vel.end() && rms != global_rms_vel.end();
-           ++max_velocity, ++min_velocity, ++rms, ++index)
-        {
-          const std::string name_max = "Maximum velocity residual magnitude on boundary with indicator "
-                                       + Utilities::int_to_string(max_velocity->first)
-                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                     .translate_id_to_symbol_name (max_velocity->first))
-                                       + " (" + units + ")";
-          statistics.add_value (name_max, max_velocity->second*unit_scale_factor);
-          const std::string name_min = "Minimum velocity residual magnitude on boundary with indicator "
-                                       + Utilities::int_to_string(min_velocity->first)
-                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                     .translate_id_to_symbol_name (min_velocity->first))
-                                       + " (" + units + ")";
-          statistics.add_value (name_min, min_velocity->second*unit_scale_factor);
-          const std::string name_rms = "RMS velocity residual on boundary with indicator "
-                                       + Utilities::int_to_string(rms->first)
-                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                     .translate_id_to_symbol_name (rms->first))
-                                       + " (" + units + ")";
-          statistics.add_value (name_rms, rms->second*unit_scale_factor);
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (name_max, 8);
-          statistics.set_scientific (name_max, true);
-          statistics.set_precision (name_min, 8);
-          statistics.set_scientific (name_min, true);
-          statistics.set_precision (name_rms, 8);
-          statistics.set_scientific (name_rms, true);
-
-          // finally have something for the screen
-          screen_text.precision(4);
-          screen_text << max_velocity->second *unit_scale_factor << ' ' << units << ", "
-                      << min_velocity->second *unit_scale_factor << ' ' << units << ", "
-                      << rms->second *unit_scale_factor << ' ' << units
-                      << (index == global_max_vel.size()-1 ? "" : ", ");
-        }
-
-      return std::pair<std::string, std::string> ("Max, min, and RMS residual velocity along boundary parts:",
-                                                  screen_text.str());
-    }
-
-
-
-    template <int dim>
-    void
-    BoundaryVelocityResidualStatistics<dim>::declare_parameters (ParameterHandler  &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Boundary velocity residual statistics");
-        {
-          prm.declare_entry ("Data directory",
-                             "$ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/",
-                             Patterns::DirectoryName (),
-                             "The name of a directory that contains the GPlates model or the "
-                             "ascii data. This path may either be absolute (if starting with a "
-                             "`/') or relative to the current directory. The path may also "
-                             "include the special text `$ASPECT_SOURCE_DIR' which will be "
-                             "interpreted as the path in which the ASPECT source files were "
-                             "located when ASPECT was compiled. This interpretation allows, "
-                             "for example, to reference files located in the `data/' subdirectory "
-                             "of ASPECT.");
-          prm.declare_entry ("Data file name", "current_day.gpml",
-                             Patterns::Anything (),
-                             "The file name of the input velocity as a GPlates model or an ascii data. "
-                             "For the GPlates model, provide file in the same format as described "
-                             "in the 'gplates' boundary velocity plugin. "
-                             "For the ascii data, provide file in the same format as described in "
-                             " 'ascii data' initial composition plugin." );
-          prm.declare_entry ("Scale factor", "1.",
-                             Patterns::Double (),
-                             "Scalar factor, which is applied to the model data. "
-                             "You might want to use this to scale the input to a "
-                             "reference model. Another way to use this factor is to "
-                             "convert units of the input files. For instance, if you "
-                             "provide velocities in cm/year set this factor to 0.01.");
-          prm.declare_entry ("Use spherical unit vectors", "false",
-                             Patterns::Bool (),
-                             "Specify velocity as r, phi, and theta components "
-                             "instead of x, y, and z. Positive velocities point up, east, "
-                             "and north (in 3d) or out and clockwise (in 2d). "
-                             "This setting only makes sense for spherical geometries."
-                             "GPlates data is always interpreted to be in east and north directions "
-                             "and is not affected by this parameter.");
-          prm.declare_entry ("Use ascii data", "false",
-                             Patterns::Bool (),
-                             "Use ascii data files (e.g., GPS) for computing residual velocities "
-                             "instead of GPlates data.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    BoundaryVelocityResidualStatistics<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Boundary velocity residual statistics");
-        {
-          // Get the path to the data files. If it contains a reference
-          // to $ASPECT_SOURCE_DIR, replace it by what CMake has given us
-          // as a #define
-          data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-          data_file_name    = prm.get ("Data file name");
-          scale_factor      = prm.get_double ("Scale factor");
-
-          use_spherical_unit_vectors = prm.get_bool("Use spherical unit vectors");
-          use_ascii_data = prm.get_bool("Use ascii data");
-
-          if (use_spherical_unit_vectors)
-            AssertThrow (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::spherical,
-                         ExcMessage ("Spherical unit vectors should not be used "
-                                     "when geometry model is not spherical."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(BoundaryVelocityResidualStatistics,
-                                  "boundary velocity residual statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the velocity residual along the top boundary. The velocity residual "
-                                  "is the difference between the model solution velocities and the input "
-                                  "velocities (GPlates model or ascii data). Currently, the velocity residual "
-                                  "statistics, i.e., min, max and the rms magnitude, is computed at the top "
-                                  "surface.")
-  }
-}
diff --git a/source/postprocess/command.cc.bak b/source/postprocess/command.cc.bak
deleted file mode 100644
index 9160c73fea3..00000000000
--- a/source/postprocess/command.cc.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-  Copyright (C) 2016 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/postprocess/command.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    Command<dim>::execute (TableHandler &)
-    {
-      if (on_all_processes ||
-          (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0))
-        {
-
-          // Check if a command-processor is available by calling system() with a
-          // null pointer. System is guaranteed to return non-zero if it finds
-          // a terminal and zero if there is none (like on the compute nodes of
-          // some cluster architectures, e.g. IBM BlueGene/Q)
-          AssertThrow(system(nullptr) != 0,
-                      ExcMessage("The \"command\" postprocessor required a command-processor, "
-                                 "which appears to be unavailable on this system."));
-
-          const int error = system(command.c_str());
-
-          if (error != 0)
-            {
-              std::string err_str = (error<0 ? "-" : "") +
-                                    Utilities::int_to_string(std::abs(error));
-
-
-              if (terminate_on_failure)
-                {
-                  AssertThrow(false, ExcMessage("Command <" +
-                                                command +
-                                                "> failed with error code: " +
-                                                err_str +
-                                                ". Terminating process."));
-                }
-              else
-                {
-                  std::cerr << "*** WARNING: Command <" << command
-                            << "> failed with error code: "
-                            << err_str
-                            << ". Continuing anyway."
-                            << std::endl;
-                }
-            }
-        }
-
-      return std::make_pair (std::string("Running command:"),
-                             command);
-    }
-
-    template <int dim>
-    void
-    Command<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Command");
-        {
-          prm.declare_entry ("Terminate on failure", "false",
-                             Patterns::Bool(),
-                             "Select whether \\aspect{} should terminate if the "
-                             "command returns a non-zero exit status.");
-
-          prm.declare_entry ("Run on all processes", "false",
-                             Patterns::Bool(),
-                             "Whether to run command from all processes (true), "
-                             "or only on process 0 (false).");
-
-          prm.declare_entry ("Command", "",
-                             Patterns::Anything(),
-                             "Command to execute.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    Command<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Command");
-        {
-          terminate_on_failure = prm.get_bool ("Terminate on failure");
-          on_all_processes = prm.get_bool ("Run on all processes");
-          command = prm.get ("Command");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(Command,
-                                  "command",
-                                  "A postprocessor that executes a command line "
-                                  "process.")
-  }
-}
diff --git a/source/postprocess/composition_statistics.cc.bak b/source/postprocess/composition_statistics.cc.bak
deleted file mode 100644
index d0073fcf11c..00000000000
--- a/source/postprocess/composition_statistics.cc.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/composition_statistics.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    CompositionStatistics<dim>::execute (TableHandler &statistics)
-    {
-      if (this->n_compositional_fields() == 0)
-        return {"", ""};
-
-      // create a quadrature formula based on the compositional element alone.
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.compositional_fields;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      std::vector<double> compositional_values(n_q_points);
-
-      std::vector<double> local_compositional_integrals (this->n_compositional_fields());
-
-      // compute the integral quantities by quadrature
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-
-            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-              {
-                fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values (this->get_solution(),
-                    compositional_values);
-                for (unsigned int q=0; q<n_q_points; ++q)
-                  local_compositional_integrals[c] += compositional_values[q]*fe_values.JxW(q);
-              }
-          }
-      // compute the sum over all processors
-      std::vector<double> global_compositional_integrals (local_compositional_integrals.size());
-      Utilities::MPI::sum (local_compositional_integrals,
-                           this->get_mpi_communicator(),
-                           global_compositional_integrals);
-
-      // compute min/max by simply
-      // looping over the elements of the
-      // solution vector.
-      std::vector<double> local_min_compositions (this->n_compositional_fields(),
-                                                  std::numeric_limits<double>::max());
-      std::vector<double> local_max_compositions (this->n_compositional_fields(),
-                                                  std::numeric_limits<double>::lowest());
-
-      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-        {
-          IndexSet range = this->get_solution().block(this->introspection().block_indices.compositional_fields[c]).locally_owned_elements();
-          for (unsigned int i=0; i<range.n_elements(); ++i)
-            {
-              const unsigned int idx = range.nth_index_in_set(i);
-              const double val =  this->get_solution().block(this->introspection().block_indices.compositional_fields[c])(idx);
-
-              local_min_compositions[c] = std::min<double> (local_min_compositions[c], val);
-              local_max_compositions[c] = std::max<double> (local_max_compositions[c], val);
-            }
-
-        }
-
-      // now do the reductions over all processors
-      std::vector<double> global_min_compositions (this->n_compositional_fields(),
-                                                   std::numeric_limits<double>::max());
-      std::vector<double> global_max_compositions (this->n_compositional_fields(),
-                                                   std::numeric_limits<double>::lowest());
-      {
-        Utilities::MPI::min (local_min_compositions,
-                             this->get_mpi_communicator(),
-                             global_min_compositions);
-        Utilities::MPI::max (local_max_compositions,
-                             this->get_mpi_communicator(),
-                             global_max_compositions);
-      }
-
-      // finally produce something for the statistics file
-      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-        {
-          statistics.add_value ("Minimal value for composition " + this->introspection().name_for_compositional_index(c),
-                                global_min_compositions[c]);
-          statistics.add_value ("Maximal value for composition " + this->introspection().name_for_compositional_index(c),
-                                global_max_compositions[c]);
-          statistics.add_value ("Global mass for composition " + this->introspection().name_for_compositional_index(c),
-                                global_compositional_integrals[c]);
-        }
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-        {
-          const std::string columns[] = { "Minimal value for composition " + this->introspection().name_for_compositional_index(c),
-                                          "Maximal value for composition " + this->introspection().name_for_compositional_index(c),
-                                          "Global mass for composition " + this->introspection().name_for_compositional_index(c)
-                                        };
-          for (const auto &col : columns)
-            {
-              statistics.set_precision (col, 8);
-              statistics.set_scientific (col, true);
-            }
-        }
-
-      std::ostringstream output;
-      output.precision(4);
-      for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-        {
-          output << global_min_compositions[c] << '/'
-                 << global_max_compositions[c] << '/'
-                 << global_compositional_integrals[c];
-          if (c+1 != this->n_compositional_fields())
-            output << " // ";
-        }
-
-      return std::pair<std::string, std::string> ("Compositions min/max/mass:",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(CompositionStatistics,
-                                  "composition statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the compositional fields, if present in this simulation. "
-                                  "In particular, it computes maximal and minimal values of "
-                                  "each field, as well as the total mass contained in this "
-                                  "field as defined by the integral "
-                                  "$m_i(t) = \\int_\\Omega c_i(\\mathbf x,t) \\; \\text{d}x$.")
-  }
-}
diff --git a/source/postprocess/composition_velocity_statistics.cc.bak b/source/postprocess/composition_velocity_statistics.cc.bak
deleted file mode 100644
index ce2244a748c..00000000000
--- a/source/postprocess/composition_velocity_statistics.cc.bak
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/composition_velocity_statistics.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    CompositionVelocityStatistics<dim>::execute (TableHandler &statistics)
-    {
-      const QGauss<dim> quadrature_formula (this->get_fe()
-                                            .base_element(this->introspection().base_elements.velocities).degree+1);
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
-      std::vector<double> compositional_values(n_q_points);
-
-      std::vector<double> local_velocity_square_integral(this->n_compositional_fields());
-      std::vector<double> local_area_integral(this->n_compositional_fields());
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                                                                                        velocity_values);
-
-            for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-              {
-                fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
-                    compositional_values);
-
-                for (unsigned int q = 0; q < n_q_points; ++q)
-                  {
-                    if (compositional_values[q] >= 0.5)
-                      {
-                        local_velocity_square_integral[c] += ((velocity_values[q] * velocity_values[q]) *
-                                                              fe_values.JxW(q));
-                        local_area_integral[c] += fe_values.JxW(q);
-                      }
-                  }
-              }
-          }
-
-      std::vector<double> global_velocity_square_integral(local_velocity_square_integral.size());
-      Utilities::MPI::sum(local_velocity_square_integral, this->get_mpi_communicator(), global_velocity_square_integral);
-      std::vector<double> global_area_integral(local_area_integral.size());
-      Utilities::MPI::sum(local_area_integral, this->get_mpi_communicator(), global_area_integral);
-
-      // compute the RMS velocity for each compositional field and for the selected compositonal fields combined
-      std::vector<double> vrms_per_composition(local_area_integral.size());
-      double velocity_square_integral_selected_fields = 0., area_integral_selected_fields = 0.;
-      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-        {
-          vrms_per_composition[c] = std::sqrt(global_velocity_square_integral[c]) /
-                                    std::sqrt(global_area_integral[c]);
-
-          const std::vector<std::string>::iterator selected_field_it = std::find(selected_fields.begin(), selected_fields.end(), this->introspection().name_for_compositional_index(c));
-          if (selected_field_it != selected_fields.end())
-            {
-              velocity_square_integral_selected_fields += global_velocity_square_integral[c];
-              area_integral_selected_fields += global_area_integral[c];
-            }
-        }
-
-      const double vrms_selected_fields = std::sqrt(velocity_square_integral_selected_fields) / std::sqrt(area_integral_selected_fields);
-
-      const std::string unit = (this->convert_output_to_years()) ? "m/year" : "m/s";
-      const double time_scaling = (this->convert_output_to_years()) ? year_in_seconds : 1.0;
-
-      // finally produce something for the statistics file
-      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-        {
-          statistics.add_value("RMS velocity (" + unit + ") for composition " + this->introspection().name_for_compositional_index(c),
-                               time_scaling * vrms_per_composition[c]);
-
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          const std::string columns[] = {"RMS velocity (" + unit + ") for composition " +
-                                         this->introspection().name_for_compositional_index(c)
-                                        };
-
-          for (const auto &column : columns)
-            {
-              statistics.set_precision(column, 8);
-              statistics.set_scientific(column, true);
-            }
-        }
-
-      // Also output the selected fields vrms
-      statistics.add_value("RMS velocity (" + unit + ") for the selected field ",
-                           time_scaling * vrms_selected_fields);
-
-      const std::string column = {"RMS velocity (" + unit + ") for the selected field "};
-
-      statistics.set_precision(column, 8);
-      statistics.set_scientific(column, true);
-
-      std::ostringstream output;
-      output.precision(4);
-
-      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-        {
-          output << time_scaling *vrms_per_composition[c]
-                 << " " << unit;
-          output << " // ";
-        }
-      output << time_scaling *vrms_selected_fields;
-
-      return std::pair<std::string, std::string>("RMS velocity for compositions and combined selected fields:",
-                                                 output.str());
-    }
-
-
-
-    template <int dim>
-    void
-    CompositionVelocityStatistics<dim>::declare_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Composition velocity statistics");
-        {
-          prm.declare_entry("Names of selected compositional fields", "",
-                            Patterns::List(Patterns::Anything()),
-                            "A list of names for each of the compositional fields that "
-                            "you want to compute the combined RMS velocity for.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    CompositionVelocityStatistics<dim>::parse_parameters(ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Composition velocity statistics");
-        {
-          selected_fields = Utilities::split_string_list(prm.get("Names of selected compositional fields"));
-
-          AssertThrow((selected_fields.size() > 0) &&
-                      (selected_fields.size() <= this->n_compositional_fields()),
-                      ExcMessage("The length of the list of names for the compositional "
-                                 "fields for which the RMS velocity is to be summed must be larger than zero "
-                                 "and smaller or equal to the number of compositional fields."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(CompositionVelocityStatistics,
-                                  "composition velocity statistics",
-                                  "A postprocessor that computes the root mean square velocity "
-                                  "over the area spanned by each compositional field (i.e. where "
-                                  "the field values are larger or equal to 0.5.")
-  }
-}
diff --git a/source/postprocess/core_statistics.cc.bak b/source/postprocess/core_statistics.cc.bak
deleted file mode 100644
index 1179c83a4ff..00000000000
--- a/source/postprocess/core_statistics.cc.bak
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/core_statistics.h>
-#include <aspect/simulator_access.h>
-#include <aspect/boundary_temperature/dynamic_core.h>
-#include <aspect/geometry_model/spherical_shell.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    CoreStatistics<dim>::CoreStatistics()
-    {
-      core_data.is_initialized = false;
-    }
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    CoreStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // now add all of the computed heat fluxes to the statistics object
-      // and create a single string that can be output to the screen
-      std::ostringstream screen_text;
-
-      const BoundaryTemperature::DynamicCore<dim> &dynamic_core =
-        this->get_boundary_temperature_manager().template get_matching_boundary_temperature_model<BoundaryTemperature::DynamicCore<dim>>();
-
-      core_data = dynamic_core.get_core_data();
-
-      // now add core mantle boundary heat flux to the statistics object
-      // and create a single string that can be output to the screen
-      const std::string name = "CMB heat flux out of the core (TW)";
-      statistics.add_value (name, -core_data.Q/1e12);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      statistics.set_precision (name, 3);
-      statistics.set_scientific (name, true);
-
-      // finally have something for the screen
-      screen_text.precision(3);
-      screen_text << -core_data.Q/1e12 << " TW,";
-
-
-      const std::string name1 = "CMB Temperature (K)";
-      statistics.add_value (name1, core_data.Ti);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      statistics.set_precision (name1, 2);
-      statistics.set_scientific (name1, false);
-
-      const std::string name2 = "Inner core radius (km)";
-      statistics.add_value (name2, core_data.Ri*1e-3);
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      statistics.set_precision (name2, 2);
-      statistics.set_scientific (name2, false);
-
-      const std::string name3 = "Light element concentration (%)";
-      statistics.add_value (name3, core_data.Xi*100);
-      statistics.set_precision (name3, 4);
-      statistics.set_scientific (name3, false);
-
-      if (excess_entropy_only)
-        {
-          const std::string name4 = "Excess entropy (W/K)";
-          const double delta_E = core_data.Es*core_data.dT_dt
-                                 + core_data.Er
-                                 + core_data.Eh*core_data.dR_dt
-                                 + core_data.El*core_data.dR_dt
-                                 + core_data.Eg*core_data.dR_dt
-                                 - core_data.Ek;
-          statistics.add_value (name4, delta_E);
-          statistics.set_precision (name4, 3);
-          statistics.set_scientific (name4, true);
-        }
-      else
-        {
-          const std::string name5 = "Es (W/K)";
-          statistics.add_value (name5, core_data.Es*core_data.dT_dt);
-          statistics.set_precision (name5, 3);
-          statistics.set_scientific (name5, true);
-
-          const std::string name6 = "Er (W/K)";
-          statistics.add_value (name6, core_data.Er);
-          statistics.set_precision (name6, 3);
-          statistics.set_scientific (name6, true);
-
-          const std::string name7 = "Eh (W/K)";
-          statistics.add_value (name7, core_data.Eh*core_data.dR_dt);
-          statistics.set_precision (name7, 3);
-          statistics.set_scientific (name7, true);
-
-          const std::string name8 = "El (W/K)";
-          statistics.add_value (name8, core_data.El*core_data.dR_dt);
-          statistics.set_precision (name8, 3);
-          statistics.set_scientific (name8, true);
-
-          const std::string name9 = "Eg (W/K)";
-          statistics.add_value (name9, core_data.Eg*core_data.dR_dt);
-          statistics.set_precision (name9, 3);
-          statistics.set_scientific (name9, true);
-
-          const std::string name10 = "Ek (W/K)";
-          statistics.add_value (name10, core_data.Ek);
-          statistics.set_precision (name10, 3);
-          statistics.set_scientific (name10, true);
-        }
-
-      if (dynamic_core.is_OES_used())
-        {
-          const std::string name11 = "Other energy source (W)";
-          statistics.add_value (name11, core_data.Q_OES);
-          statistics.set_precision (name11, 3);
-          statistics.set_scientific (name11, true);
-        }
-
-      return std::pair<std::string, std::string> ("CMB heat flux out of the core",
-                                                  screen_text.str());
-    }
-
-    template <int dim>
-    void
-    CoreStatistics<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Dynamic core statistics");
-        {
-          prm.declare_entry("Excess entropy only","false",
-                            Patterns::Bool(),
-                            "Output the excess entropy only instead the each entropy terms.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    CoreStatistics<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Dynamic core statistics");
-        {
-          excess_entropy_only = prm.get_bool("Excess entropy only");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    const BoundaryTemperature::internal::CoreData &
-    CoreStatistics<dim>::get_core_data() const
-    {
-      return core_data;
-    }
-
-    template <int dim>
-    template <class Archive>
-    void CoreStatistics<dim>::serialize (Archive &ar, const unsigned int)
-    {
-      ar &(core_data.Ti);
-      ar &(core_data.Ri);
-      ar &(core_data.Xi);
-      ar &(core_data.Q);
-      ar &(core_data.dR_dt);
-      ar &(core_data.dT_dt);
-      ar &(core_data.dX_dt);
-      ar &(core_data.is_initialized);
-    }
-
-    template <int dim>
-    void CoreStatistics<dim>::save (std::map<std::string, std::string> &status_strings) const
-    {
-      std::ostringstream os;
-      aspect::oarchive oa (os);
-      oa << (*this);
-
-      status_strings["CoreStatistics"] = os.str();
-    }
-
-    template <int dim>
-    void CoreStatistics<dim>::load (const std::map<std::string, std::string> &status_strings)
-    {
-      // see if something was saved
-      if (status_strings.find("CoreStatistics") != status_strings.end())
-        {
-          std::istringstream is (status_strings.find("CoreStatistics")->second);
-          aspect::iarchive ia (is);
-          ia >> (*this);
-        }
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(CoreStatistics,
-                                  "core statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the core evolution. (Working only with dynamic core boundary temperature plugin)")
-  }
-}
diff --git a/source/postprocess/crystal_preferred_orientation.cc.bak b/source/postprocess/crystal_preferred_orientation.cc.bak
deleted file mode 100644
index 974ffa07e79..00000000000
--- a/source/postprocess/crystal_preferred_orientation.cc.bak
+++ /dev/null
@@ -1,870 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
- This file is part of ASPECT.
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/global.h>
-#include <aspect/postprocess/crystal_preferred_orientation.h>
-#include <aspect/particle/property/crystal_preferred_orientation.h>
-#include <aspect/utilities.h>
-
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/text_iarchive.hpp>
-
-#include <boost/iostreams/filtering_streambuf.hpp>
-#include <boost/iostreams/copy.hpp>
-#include <boost/iostreams/filter/gzip.hpp>
-
-#include <cstdio>
-#include <unistd.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    CrystalPreferredOrientation<dim>::CrystalPreferredOrientation ()
-      :
-      // the following value is later read from the input file
-      output_interval (0),
-      // initialize this to a nonsensical value; set it to the actual time
-      // the first time around we get to check it
-      last_output_time (std::numeric_limits<double>::quiet_NaN()),
-      output_file_number (numbers::invalid_unsigned_int),
-      group_files(0),
-      write_in_background_thread(false)
-    {}
-
-
-
-    template <int dim>
-    CrystalPreferredOrientation<dim>::~CrystalPreferredOrientation ()
-    {
-      // make sure a thread that may still be running in the background,
-      // writing data, finishes
-      if (background_thread_main.joinable())
-        background_thread_main.join ();
-
-      if (background_thread_content_raw.joinable())
-        background_thread_content_raw.join ();
-
-      if (background_thread_content_draw_volume_weighting.joinable())
-        background_thread_content_draw_volume_weighting.join ();
-    }
-
-
-
-    template <int dim>
-    void
-    CrystalPreferredOrientation<dim>::initialize ()
-    {
-      const unsigned int my_rank = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
-      this->random_number_generator.seed(random_number_seed+my_rank);
-    }
-
-
-
-    template <int dim>
-    std::list<std::string>
-    CrystalPreferredOrientation<dim>::required_other_postprocessors () const
-    {
-      return {"particles"};
-    }
-
-
-
-    template <int dim>
-    // We need to pass the arguments by value, as this function can be called on a separate thread:
-    void CrystalPreferredOrientation<dim>::writer (const std::string &filename,
-                                                   const std::string &temporary_output_location,
-                                                   const std::string &file_contents,
-                                                   const bool compress_contents)
-    {
-      std::string tmp_filename = filename;
-      if (temporary_output_location != "")
-        {
-          tmp_filename = temporary_output_location + "/aspect.tmp.XXXXXX";
-
-          // Create the temporary file; get at the actual filename
-          // by using a C-style string that mkstemp will then overwrite
-          std::vector<char> tmp_filename_x (tmp_filename.size()+1);
-          std::strcpy(tmp_filename_x.data(), tmp_filename.c_str());
-          const int tmp_file_desc = mkstemp(tmp_filename_x.data());
-          tmp_filename = tmp_filename_x.data();
-
-          // If we failed to create the temp file, just write directly to the target file.
-          // We also provide a warning about this fact. There are places where
-          // this fails *on every node*, so we will get a lot of warning messages
-          // into the output; in these cases, just writing multiple pieces to
-          // std::cerr will produce an unreadable mass of text; rather, first
-          // assemble the error message completely, and then output it atomically
-          if (tmp_file_desc == -1)
-            {
-              const std::string x = ("***** WARNING: could not create temporary file <"
-                                     +
-                                     tmp_filename
-                                     +
-                                     ">, will output directly to final location. This may negatively "
-                                     "affect performance. (On processor "
-                                     + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD))
-                                     + ".)\n");
-
-              std::cerr << x << std::flush;
-
-              tmp_filename = filename;
-            }
-          else
-            close(tmp_file_desc);
-        }
-
-      std::ofstream out(tmp_filename.c_str(), std::ofstream::binary);
-
-      AssertThrow (out, ExcMessage(std::string("Trying to write to file <") +
-                                   filename +
-                                   ">, but the file can't be opened!"));
-
-      // now write and then move the tmp file to its final destination
-      // if necessary
-      if (compress_contents)
-        {
-          namespace bio = boost::iostreams;
-
-          std::stringstream origin(file_contents);
-
-          bio::filtering_streambuf<bio::input> compress_out;
-          compress_out.push(bio::zlib_compressor());
-          compress_out.push(origin);
-          bio::copy(compress_out, out);
-        }
-      else
-        {
-          out << file_contents;
-        }
-
-      out.close ();
-
-      if (tmp_filename != filename)
-        {
-          std::string command = std::string("mv ") + tmp_filename + " " + filename;
-          int error = system(command.c_str());
-
-          AssertThrow(error == 0,
-                      ExcMessage("Could not move " + tmp_filename + " to "
-                                 + filename + ". On processor "
-                                 + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD)) + "."));
-        }
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    CrystalPreferredOrientation<dim>::execute (TableHandler &statistics)
-    {
-
-      const Particle::Property::Manager<dim> &manager = this->get_particle_world(0).get_property_manager();
-      const Particle::Property::ParticleHandler<dim> &particle_handler = this->get_particle_world(0).get_particle_handler();
-
-      const bool cpo_elastic_decomposition_plugin_exists = manager.plugin_name_exists("elastic tensor decomposition");
-
-      // Get a reference to the CPO particle property.
-      const Particle::Property::CrystalPreferredOrientation<dim> &cpo_particle_property =
-        manager.template get_matching_property<Particle::Property::CrystalPreferredOrientation<dim>>();
-
-      const unsigned int n_grains = cpo_particle_property.get_number_of_grains();
-      const unsigned int n_minerals = cpo_particle_property.get_number_of_minerals();
-
-      // if this is the first time we get here, set the last output time
-      // to the current time - output_interval. this makes sure we
-      // always produce data during the first time step
-      if (std::isnan(last_output_time))
-        last_output_time = this->get_time() - output_interval;
-
-      // If it's not time to generate an output file or we do not write output
-      // return early.
-      if (this->get_time() < last_output_time + output_interval && this->get_time() != end_time)
-        return std::make_pair("","");
-
-      if (output_file_number == numbers::invalid_unsigned_int)
-        output_file_number = 0;
-      else
-        ++output_file_number;
-
-      // Now prepare everything for writing the output
-      std::string particle_file_prefix_main = this->get_output_directory() +  "particles_cpo/particles-" + Utilities::int_to_string (output_file_number, 5);
-      std::string particle_file_prefix_content_raw = this->get_output_directory() +  "particles_cpo/CPO-" + Utilities::int_to_string (output_file_number, 5);
-      std::string particle_file_prefix_content_draw_volume_weighting = this->get_output_directory() +  "particles_cpo/weighted_CPO-" + Utilities::int_to_string (output_file_number, 5);
-
-      std::stringstream string_stream_main;
-      std::stringstream string_stream_content_raw;
-      std::stringstream string_stream_content_draw_volume_weighting;
-
-      string_stream_main << "id x y" << (dim == 3 ? " z" : "") << " olivine_deformation_type"
-                         << (cpo_elastic_decomposition_plugin_exists ? (std::string(" full_norm_square ")
-                                                                        + "triclinic_norm_square_p1 triclinic_norm_square_p2 triclinic_norm_square_p3 "
-                                                                        + "monoclinic_norm_square_p1 monoclinic_norm_square_p2 monoclinic_norm_square_p3 "
-                                                                        + "orthohombic_norm_square_p1 orthohombic_norm_square_p2 orthohombic_norm_square_p3 "
-                                                                        + "tetragonal_norm_square_p1 tetragonal_norm_square_p2 tetragonal_norm_square_p3 "
-                                                                        + "hexagonal_norm_square_p1 hexagonal_norm_square_p2 hexagonal_norm_square_p3 "
-                                                                        + "isotropic_norm_square") : "") << std::endl;
-
-      // get particle data
-      const Particle::Property::ParticlePropertyInformation &property_information = this->get_particle_world(0).get_property_manager().get_data_info();
-
-      AssertThrow(property_information.fieldname_exists("cpo mineral 0 type") ,
-                  ExcMessage("No CPO particle properties found. Make sure that the CPO particle property plugin is selected."));
-
-
-
-      const unsigned int cpo_data_position = property_information.n_fields() == 0
-                                             ?
-                                             0
-                                             :
-                                             property_information.get_position_by_field_name("cpo mineral 0 type");
-
-      std::vector<std::vector<Tensor<2,3>>> rotation_matrices (n_minerals, {n_grains,Tensor<2,3>()});
-      std::vector<std::vector<std::array<double,3>>> euler_angles(n_minerals, {n_grains,{{0}}});
-
-      // write unweighted header
-      if (write_raw_cpo.size() != 0)
-        {
-          string_stream_content_raw << "id" << " " << std::setprecision(12);
-          for (unsigned int property_i = 0; property_i < write_raw_cpo.size(); ++property_i)
-            {
-              switch (write_raw_cpo[property_i].second)
-                {
-                  case Output::VolumeFraction:
-                    string_stream_content_raw << "mineral_" << write_raw_cpo[property_i].first << "_volume_fraction" << " ";
-                    break;
-
-                  case Output::RotationMatrix:
-                    string_stream_content_raw << "mineral_" << write_raw_cpo[property_i].first << "_RM_0" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_1" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_2" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_3" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_4" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_5" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_6" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_7" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_RM_8" << " ";
-                    break;
-
-                  case Output::EulerAngles:
-                    string_stream_content_raw << "mineral_" << write_raw_cpo[property_i].first << "_EA_phi" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_EA_theta" << " "
-                                              << "mineral_" << write_raw_cpo[property_i].first << "_EA_z" << " ";
-                    break;
-                  default:
-                    Assert(false, ExcMessage("Internal error: raw CPO postprocess case not found."));
-                    break;
-                }
-            }
-          string_stream_content_raw << std::endl;
-        }
-
-
-      // write weighted header
-      if (write_draw_volume_weighted_cpo.size() != 0)
-        {
-          string_stream_content_draw_volume_weighting << "id" << " ";
-          for (unsigned int property_i = 0; property_i < write_draw_volume_weighted_cpo.size(); ++property_i)
-            {
-              switch (write_draw_volume_weighted_cpo[property_i].second)
-                {
-                  case Output::VolumeFraction:
-                    string_stream_content_draw_volume_weighting << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_volume_fraction" << " ";
-                    break;
-
-                  case Output::RotationMatrix:
-                    string_stream_content_draw_volume_weighting << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_0" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_1" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_2" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_3" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_4" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_5" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_6" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_7" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_RM_8" << " ";
-                    break;
-
-                  case Output::EulerAngles:
-                    string_stream_content_draw_volume_weighting << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_EA_phi" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_EA_theta" << " "
-                                                                << "mineral_" << write_draw_volume_weighted_cpo[property_i].first << "_EA_z" << " ";
-                    break;
-                  default:
-                    Assert(false, ExcMessage("Internal error: raw CPO postprocess case not found."));
-                    break;
-                }
-            }
-          string_stream_content_draw_volume_weighting << std::endl;
-
-        }
-
-      for (const auto &particle: particle_handler)
-        {
-          AssertThrow(particle.has_properties(),
-                      ExcMessage("No particle properties found. Make sure that the CPO particle property plugin is selected."));
-
-          const unsigned int id = particle.get_id();
-          const ArrayView<const double> properties = particle.get_properties();
-
-          const Point<dim> position = particle.get_location();
-
-          // always make a vector of rotation matrices
-          for (unsigned int mineral = 0; mineral < n_minerals; ++mineral)
-            {
-              rotation_matrices[mineral].resize(n_grains);
-              for (unsigned int i_grain = 0; i_grain < n_grains; ++i_grain)
-                {
-                  rotation_matrices[mineral][i_grain] = cpo_particle_property.get_rotation_matrix_grains(
-                                                          cpo_data_position,
-                                                          properties,
-                                                          mineral,
-                                                          i_grain);
-                }
-            }
-
-          const unsigned int lpo_hex_data_position = property_information.n_fields() == 0 || cpo_elastic_decomposition_plugin_exists == false
-                                                     ?
-                                                     0
-                                                     :
-                                                     property_information.get_position_by_field_name("cpo elastic axis e1");
-
-          // write main file
-          string_stream_main << id << " " << position << " " << properties[cpo_data_position];
-
-          if (cpo_elastic_decomposition_plugin_exists == true)
-            {
-              string_stream_main << " " << properties[lpo_hex_data_position+12] << " " << properties[lpo_hex_data_position+13]
-                                 << " " << properties[lpo_hex_data_position+14] << " " << properties[lpo_hex_data_position+15]
-                                 << " " << properties[lpo_hex_data_position+16] << " " << properties[lpo_hex_data_position+17]
-                                 << " " << properties[lpo_hex_data_position+18] << " " << properties[lpo_hex_data_position+19]
-                                 << " " << properties[lpo_hex_data_position+20] << " " << properties[lpo_hex_data_position+21]
-                                 << " " << properties[lpo_hex_data_position+22] << " " << properties[lpo_hex_data_position+23]
-                                 << " " << properties[lpo_hex_data_position+24] << " " << properties[lpo_hex_data_position+25]
-                                 << " " << properties[lpo_hex_data_position+26] << " " << properties[lpo_hex_data_position+27]
-                                 << " " << properties[lpo_hex_data_position+28];
-            }
-          string_stream_main << std::endl;
-
-          // write content file
-          if (compute_raw_euler_angles == true)
-            {
-              euler_angles.resize(n_minerals);
-              for (unsigned int mineral = 0; mineral < n_minerals; ++mineral)
-                {
-                  euler_angles[mineral].resize(n_grains);
-                  for (unsigned int i_grain = 0; i_grain < n_grains; ++i_grain)
-                    {
-                      euler_angles[mineral][i_grain] = Utilities::zxz_euler_angles_from_rotation_matrix(
-                                                         rotation_matrices[mineral][i_grain]);
-                    }
-                }
-            }
-
-          if (write_raw_cpo.size() != 0)
-            {
-              // write unweighted data
-              for (unsigned int grain = 0; grain < n_grains; ++grain)
-                {
-                  string_stream_content_raw << id << " ";
-                  for (unsigned int property_i = 0; property_i < write_raw_cpo.size(); ++property_i)
-                    {
-                      switch (write_raw_cpo[property_i].second)
-                        {
-                          case Output::VolumeFraction:
-                            string_stream_content_raw << cpo_particle_property.get_volume_fractions_grains(
-                                                        cpo_data_position,
-                                                        properties,
-                                                        write_raw_cpo[property_i].first,
-                                                        grain) << " ";
-                            break;
-
-                          case Output::RotationMatrix:
-                            string_stream_content_raw << rotation_matrices[write_raw_cpo[property_i].first][grain]<< " ";
-                            break;
-
-                          case Output::EulerAngles:
-                            Assert(compute_raw_euler_angles == true,
-                                   ExcMessage("Internal error: writing out raw Euler angles, without them being computed."));
-                            string_stream_content_raw << euler_angles[write_raw_cpo[property_i].first][grain][0] << " "
-                                                      <<  euler_angles[write_raw_cpo[property_i].first][grain][1] << " "
-                                                      <<  euler_angles[write_raw_cpo[property_i].first][grain][2] << " ";
-                            break;
-                          default:
-                            Assert(false, ExcMessage("Internal error: raw CPO postprocess case not found."));
-                            break;
-                        }
-                    }
-                  string_stream_content_raw << std::endl;
-                }
-
-            }
-
-          if (write_draw_volume_weighted_cpo.size() != 0)
-            {
-              std::vector<std::vector<dealii::Tensor<2,3>>> weighted_rotation_matrices;
-              std::vector<std::vector<std::array<double,3>>> weighted_euler_angles;
-
-              weighted_euler_angles.resize(n_minerals);
-              weighted_rotation_matrices.resize(n_minerals);
-              std::vector<std::vector<double>> volume_fractions_grains(n_minerals,std::vector<double>(n_grains,-1.));
-              for (unsigned int mineral = 0; mineral < n_minerals; ++mineral)
-                {
-                  for (unsigned int i_grain = 0; i_grain < n_grains; ++i_grain)
-                    {
-                      weighted_euler_angles[mineral].resize(n_grains);
-                      weighted_rotation_matrices[mineral].resize(n_grains);
-                      volume_fractions_grains[mineral][i_grain] = cpo_particle_property.get_volume_fractions_grains(
-                                                                    cpo_data_position,
-                                                                    properties,
-                                                                    mineral,
-                                                                    i_grain);
-                    }
-                  weighted_rotation_matrices[mineral] = Utilities::rotation_matrices_random_draw_volume_weighting(volume_fractions_grains[mineral], rotation_matrices[mineral], n_grains, this->random_number_generator);
-
-                  Assert(weighted_rotation_matrices[mineral].size() == euler_angles[mineral].size(),
-                         ExcMessage("Weighted rotation matrices vector (size = " + std::to_string(weighted_rotation_matrices[mineral].size()) +
-                                    ") has different size from input angles (size = " + std::to_string(euler_angles[mineral].size()) + ")."));
-
-                  for (unsigned int i_grain = 0; i_grain < n_grains; ++i_grain)
-                    {
-                      weighted_euler_angles[mineral][i_grain] = Utilities::zxz_euler_angles_from_rotation_matrix(
-                                                                  weighted_rotation_matrices[mineral][i_grain]);
-                    }
-                }
-              string_stream_content_draw_volume_weighting << std::endl;
-
-              // write data
-              for (unsigned int grain = 0; grain < n_grains; ++grain)
-                {
-                  string_stream_content_draw_volume_weighting << id << " ";
-                  for (unsigned int property_i = 0; property_i < write_draw_volume_weighted_cpo.size(); ++property_i)
-                    {
-                      switch (write_draw_volume_weighted_cpo[property_i].second)
-                        {
-                          case Output::VolumeFraction:
-                            string_stream_content_draw_volume_weighting << volume_fractions_grains[write_draw_volume_weighted_cpo[property_i].first][grain] << " ";
-                            break;
-
-                          case Output::RotationMatrix:
-                            string_stream_content_draw_volume_weighting << weighted_rotation_matrices[write_draw_volume_weighted_cpo[property_i].first][grain] << " ";
-                            break;
-
-                          case Output::EulerAngles:
-                            Assert(compute_raw_euler_angles == true,
-                                   ExcMessage("Internal error: writing out raw Euler angles, without them being computed."));
-                            string_stream_content_draw_volume_weighting << weighted_euler_angles[write_draw_volume_weighted_cpo[property_i].first][grain][0] << " "
-                                                                        <<  weighted_euler_angles[write_draw_volume_weighted_cpo[property_i].first][grain][1] << " "
-                                                                        <<  weighted_euler_angles[write_draw_volume_weighted_cpo[property_i].first][grain][2] << " ";
-                            break;
-
-                          default:
-                            Assert(false, ExcMessage("Internal error: raw CPO postprocess case not found."));
-                            break;
-                        }
-                    }
-                  string_stream_content_draw_volume_weighting << std::endl;
-                }
-            }
-        }
-
-      std::string filename_main = particle_file_prefix_main + "." + Utilities::int_to_string(dealii::Utilities::MPI::this_mpi_process (this->get_mpi_communicator()),4) + ".dat";
-      std::string filename_raw = particle_file_prefix_content_raw + "." + Utilities::int_to_string(dealii::Utilities::MPI::this_mpi_process (this->get_mpi_communicator()),4) + ".dat";
-      std::string filename_draw_volume_weighting = particle_file_prefix_content_draw_volume_weighting + "." + Utilities::int_to_string(dealii::Utilities::MPI::this_mpi_process (this->get_mpi_communicator()),4) + ".dat";
-
-      std::unique_ptr<std::string> file_contents_main = std::make_unique<std::string>(string_stream_main.str());
-      std::unique_ptr<std::string> file_contents_raw = std::make_unique<std::string>(string_stream_content_raw.str());
-      std::unique_ptr<std::string> file_contents_draw_volume_weighting = std::make_unique<std::string>(string_stream_content_draw_volume_weighting.str());
-
-      if (write_in_background_thread)
-        {
-          // Wait for all previous write operations to finish, should
-          // any be still active,
-          if (background_thread_main.joinable())
-            background_thread_main.join ();
-
-          // then continue with writing the main file
-          background_thread_main
-            = std::thread([ my_filename = std::move(filename_main),
-                            my_temporary_output_location = temporary_output_location,
-                            my_file_contents = std::move(file_contents_main)]()
-          {
-            writer (my_filename, my_temporary_output_location, *my_file_contents, false);
-          });
-
-          if (write_raw_cpo.size() != 0)
-            {
-              // Wait for all previous write operations to finish, should
-              // any be still active,
-              if (background_thread_content_raw.joinable())
-                background_thread_content_raw.join ();
-
-              // then continue with writing our own data.
-              background_thread_content_raw
-                = std::thread([ my_filename = std::move(filename_raw),
-                                my_temporary_output_location = temporary_output_location,
-                                my_file_contents = std::move(file_contents_raw),
-                                my_compress_cpo_data_files = compress_cpo_data_files]()
-              {
-                writer (my_filename, my_temporary_output_location, *my_file_contents, my_compress_cpo_data_files);
-              });
-            }
-
-          if (write_draw_volume_weighted_cpo.size() != 0)
-            {
-              // Wait for all previous write operations to finish, should
-              // any be still active,
-              if (background_thread_content_draw_volume_weighting.joinable())
-                background_thread_content_draw_volume_weighting.join ();
-
-              // then continue with writing our own data.
-              background_thread_content_draw_volume_weighting
-                = std::thread([ my_filename = std::move(filename_draw_volume_weighting),
-                                my_temporary_output_location = temporary_output_location,
-                                my_file_contents = std::move(file_contents_draw_volume_weighting),
-                                my_compress_cpo_data_files = compress_cpo_data_files]()
-              {
-                writer (my_filename, my_temporary_output_location, *my_file_contents, my_compress_cpo_data_files);
-              });
-            }
-        }
-      else
-        {
-          writer(filename_main,temporary_output_location,*file_contents_main, false);
-          if (write_raw_cpo.size() != 0)
-            writer(filename_raw,temporary_output_location,*file_contents_raw, compress_cpo_data_files);
-          if (write_draw_volume_weighted_cpo.size() != 0)
-            writer(filename_draw_volume_weighting,temporary_output_location,*file_contents_draw_volume_weighting, compress_cpo_data_files);
-        }
-
-
-      // up the next time we need output
-      set_last_output_time (this->get_time());
-
-      const std::string &particles_cpo_output = particle_file_prefix_content_raw;
-
-      // record the file base file name in the output file
-      statistics.add_value ("Particle CPO file name", particles_cpo_output);
-      return std::make_pair("Writing particle cpo output:", particles_cpo_output);
-    }
-
-
-
-    template <int dim>
-    void
-    CrystalPreferredOrientation<dim>::set_last_output_time (const double current_time)
-    {
-      // if output_interval is positive, then update the last supposed output
-      // time
-      if (output_interval > 0)
-        {
-          // We need to find the last time output was supposed to be written.
-          // this is the last_output_time plus the largest positive multiple
-          // of output_intervals that passed since then. We need to handle the
-          // edge case where last_output_time+output_interval==current_time,
-          // we did an output and std::floor sadly rounds to zero. This is done
-          // by forcing std::floor to round 1.0-eps to 1.0.
-          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
-        }
-    }
-
-
-
-    template <int dim>
-    typename CrystalPreferredOrientation<dim>::Output
-    CrystalPreferredOrientation<dim>::string_to_output_enum(const std::string &string)
-    {
-      // olivine volume fraction, olivine rotation matrix, olivine Euler angles, enstatite volume fraction, enstatite rotation matrix, enstatite Euler angles
-      if (string == "volume fraction")
-        return Output::VolumeFraction;
-      if (string == "rotation matrix")
-        return Output::RotationMatrix;
-      if (string == "Euler angles")
-        return Output::EulerAngles;
-      return Output::not_found;
-    }
-
-
-
-    template <int dim>
-    void
-    CrystalPreferredOrientation<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Crystal Preferred Orientation");
-        {
-          prm.declare_entry ("Time between data output", "1e8",
-                             Patterns::Double (0),
-                             "The time interval between each generation of "
-                             "output files. A value of zero indicates that "
-                             "output should be generated every time step.\n\n"
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-
-          prm.declare_entry ("Random number seed", "1",
-                             Patterns::Integer (0),
-                             "The seed used to generate random numbers. This will make sure that "
-                             "results are reproducible as long as the problem is run with the "
-                             "same amount of MPI processes. It is implemented as final seed = "
-                             "random number seed + MPI Rank. ");
-
-          prm.declare_entry ("Write in background thread", "false",
-                             Patterns::Bool(),
-                             "File operations can potentially take a long time, blocking the "
-                             "progress of the rest of the model run. Setting this variable to "
-                             "`true' moves this process into background threads, while the "
-                             "rest of the model continues.");
-
-          prm.declare_entry ("Temporary output location", "",
-                             Patterns::Anything(),
-                             "On large clusters it can be advantageous to first write the "
-                             "output to a temporary file on a local file system and later "
-                             "move this file to a network file system. If this variable is "
-                             "set to a non-empty string it will be interpreted as a "
-                             "temporary storage location.");
-
-          prm.declare_entry ("Write out raw cpo data",
-                             "olivine volume fraction,olivine Euler angles,enstatite volume fraction,enstatite Euler angles",
-                             Patterns::List(Patterns::Anything()),
-                             "A list containing what particle cpo data needs "
-                             "to be written out after the particle id. This writes out the raw "
-                             "cpo data files for each MPI process. It can write out the following data: "
-                             "olivine volume fraction, olivine rotation matrix, olivine Euler angles, "
-                             "enstatite volume fraction, enstatite rotation matrix, enstatite Euler angles. \n"
-                             "Note that the rotation matrix and Euler angles both contain the same "
-                             "information, but in a different format. Euler angles are recommended "
-                             "over the rotation matrix since they only require to write 3 values instead "
-                             "of 9. If the list is empty, this file will not be written."
-                             "Furthermore, the entries will be written out in the order given, "
-                             "and if entries are entered multiple times, they will be written "
-                             "out multiple times.");
-
-          prm.declare_entry ("Write out draw volume weighted cpo data",
-                             "olivine Euler angles,enstatite Euler angles",
-                             Patterns::List(Patterns::Anything()),
-                             "A list containing the what part of the random draw volume "
-                             "weighted particle cpo data needs to be written out after "
-                             "the particle id. after using a random draw volume weighting. "
-                             "The random draw volume weigthing uses a uniform random distribution "
-                             "This writes out the raw cpo data files for "
-                             "each MPI process. It can write out the following data: "
-                             "olivine volume fraction, olivine rotation matrix, olivine Euler angles, "
-                             "enstatite volume fraction, enstatite rotation matrix, enstatite Euler angles. \n"
-                             "Note that the rotation matrix and Euler angles both contain the same "
-                             "information, but in a different format. Euler angles are recommended "
-                             "over the rotation matrix since they only require to write 3 values instead "
-                             "of 9. If the list is empty, this file will not be written. "
-                             "Furthermore, the entries will be written out in the order given, "
-                             "and if entries are entered multiple times, they will be written "
-                             "out multiple times.");
-          prm.declare_entry ("Compress cpo data files", "true",
-                             Patterns::Bool(),
-                             "Whether to compress the raw and weighted cpo data output files with zlib.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-    }
-
-
-
-    template <int dim>
-    void
-    CrystalPreferredOrientation<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      end_time = prm.get_double ("End time");
-      if (this->convert_output_to_years())
-        end_time *= year_in_seconds;
-
-      unsigned int n_minerals;
-
-      prm.enter_subsection("Particles");
-      {
-        prm.enter_subsection("Crystal Preferred Orientation");
-        {
-          prm.enter_subsection("Initial grains");
-          {
-            // Static variable of CPO has not been initialize yet, so we need to get it directly.
-            n_minerals = dealii::Utilities::split_string_list(prm.get("Minerals")).size();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Crystal Preferred Orientation");
-        {
-          output_interval = prm.get_double ("Time between data output");
-          if (this->convert_output_to_years())
-            output_interval *= year_in_seconds;
-
-          random_number_seed = prm.get_integer ("Random number seed");
-
-          AssertThrow(this->get_parameters().run_postprocessors_on_nonlinear_iterations == false,
-                      ExcMessage("Postprocessing nonlinear iterations in models with "
-                                 "particles is currently not supported."));
-
-          aspect::Utilities::create_directory (this->get_output_directory() + "particles_cpo/",
-                                               this->get_mpi_communicator(),
-                                               true);
-
-          write_in_background_thread = prm.get_bool("Write in background thread");
-          temporary_output_location = prm.get("Temporary output location");
-
-          if (temporary_output_location != "")
-            {
-              // Check if a command-processor is available by calling system() with a
-              // null pointer. System is guaranteed to return non-zero if it finds
-              // a terminal and zero if there is none (like on the compute nodes of
-              // some cluster architectures, e.g. IBM BlueGene/Q)
-              AssertThrow(system((char *)nullptr) != 0,
-                          ExcMessage("Usage of a temporary storage location is only supported if "
-                                     "there is a terminal available to move the files to their final location "
-                                     "after writing. The system() command did not succeed in finding such a terminal."));
-            }
-
-          std::vector<std::string> write_raw_cpo_list = Utilities::split_string_list(prm.get("Write out raw cpo data"));
-          write_raw_cpo.resize(write_raw_cpo_list.size());
-          bool found_euler_angles = false;
-          for (unsigned int i = 0; i < write_raw_cpo_list.size(); ++i)
-            {
-              std::vector<std::string> split_raw_cpo_instructions = Utilities::split_string_list(write_raw_cpo_list[i],':');
-
-              AssertThrow(split_raw_cpo_instructions.size() == 2,
-                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
-                                     + "because it should contain a mineral identification and a output specifier separated by a colon (:). This entry "
-                                     + "does not follow those rules."));
-
-              // get mineral number
-              std::vector<std::string> mineral_instructions = Utilities::split_string_list(split_raw_cpo_instructions[0],' ');
-              AssertThrow(mineral_instructions.size() == 2,
-                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
-                                     + "because the mineral identification part should contain two elements, the word mineral and a number."));
-
-              AssertThrow(mineral_instructions[0] == "mineral",
-                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
-                                     + "because the mineral identification part should start with the word mineral and it starts with \""
-                                     + mineral_instructions[0] + "\"."));
-
-              int mineral_number = Utilities::string_to_int(mineral_instructions[1]);
-              Assert(mineral_number >= 0, ExcMessage("Internal error: mineral_number is negative: " + std::to_string(mineral_number) + "."));
-
-              AssertThrow((unsigned int) mineral_number < n_minerals,
-                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
-                                     + "because the mineral number (" + std::to_string(mineral_number) + ") is larger than the number of minerals "
-                                     + "provided in the CPO subsection (" + std::to_string(n_minerals) + ")."));
-
-              // get mineral fabric/deformation type
-              Output cpo_fabric_instruction = string_to_output_enum(split_raw_cpo_instructions[1]);
-
-              AssertThrow(cpo_fabric_instruction != Output::not_found,
-                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option."));
-
-              if (cpo_fabric_instruction == Output::EulerAngles)
-                found_euler_angles = true;
-
-              write_raw_cpo[i] = std::make_pair(mineral_number,cpo_fabric_instruction);
-            }
-
-          std::vector<std::string> write_draw_volume_weighted_cpo_list = Utilities::split_string_list(prm.get("Write out draw volume weighted cpo data"));
-          write_draw_volume_weighted_cpo.resize(write_draw_volume_weighted_cpo_list.size());
-          bool found_rotation_matrix = false;
-          for (unsigned int i = 0; i < write_draw_volume_weighted_cpo_list.size(); ++i)
-            {
-              std::vector<std::string> split_draw_volume_weighted_cpo_instructions = Utilities::split_string_list(write_draw_volume_weighted_cpo_list[i],':');
-
-              AssertThrow(split_draw_volume_weighted_cpo_instructions.size() == 2,
-                          ExcMessage("Value \""+ write_draw_volume_weighted_cpo_list[i] +"\", set in \"Write out draw volume weighted cpo data\", is not a correct option "
-                                     + "because it should contain a mineral identification and a output specifier separated by a colon (:). This entry "
-                                     + "does not follow those rules."));
-
-              // get mineral number
-              std::vector<std::string> mineral_instructions = Utilities::split_string_list(split_draw_volume_weighted_cpo_instructions[0],' ');
-              AssertThrow(mineral_instructions.size() == 2,
-                          ExcMessage("Value \""+ write_draw_volume_weighted_cpo_list[i] +"\", set in \"Write out draw volume weighted cpo data\", is not a correct option "
-                                     + "because the mineral identification part should contain two elements, the word mineral and a number."));
-
-              AssertThrow(mineral_instructions[0] == "mineral",
-                          ExcMessage("Value \""+ write_draw_volume_weighted_cpo_list[i] +"\", set in \"Write out draw volume weighted cpo data\", is not a correct option "
-                                     + "because the mineral identification part should start with the word mineral and it starts with \""
-                                     + mineral_instructions[0] + "\"."));
-
-              int mineral_number = Utilities::string_to_int(mineral_instructions[1]);
-              Assert(mineral_number >= 0, ExcMessage("Internal error: mineral_number is negative: " + std::to_string(mineral_number) + "."));
-
-              AssertThrow((unsigned int) mineral_number < n_minerals,
-                          ExcMessage("Value \""+ write_raw_cpo_list[i] +"\", set in \"Write out raw cpo data\", is not a correct option "
-                                     + "because the mineral number (" + std::to_string(mineral_number) + ") is larger than the number of minerals "
-                                     + "provided in the CPO subsection (" + std::to_string(n_minerals) + ")."));
-
-              // get mineral fabric/deformation type
-              Output cpo_fabric_instruction = string_to_output_enum(split_draw_volume_weighted_cpo_instructions[1]);
-
-              AssertThrow(cpo_fabric_instruction != Output::not_found,
-                          ExcMessage("Value \""+ write_draw_volume_weighted_cpo_list[i] +"\", set in \"Write out draw volume weighted cpo data\", is not a correct option."));
-
-              if (cpo_fabric_instruction == Output::RotationMatrix)
-                found_rotation_matrix = true;
-
-              write_draw_volume_weighted_cpo[i] = std::make_pair(mineral_number,cpo_fabric_instruction);
-            }
-
-          if (write_draw_volume_weighted_cpo_list.size() != 0 || found_euler_angles == true)
-            compute_raw_euler_angles = true;
-          else
-            compute_raw_euler_angles = false;
-
-          if (write_draw_volume_weighted_cpo_list.size() != 0 && found_rotation_matrix == true)
-            compute_weighted_rotation_matrix = true;
-          else
-            compute_weighted_rotation_matrix = false;
-
-          compress_cpo_data_files = prm.get_bool("Compress cpo data files");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(CrystalPreferredOrientation,
-                                  "crystal preferred orientation",
-                                  "A Postprocessor that writes out CPO specific particle data."
-                                  "It can write out the CPO data as it is stored (raw) and/or as a"
-                                  "random draw volume weighted representation. The latter one"
-                                  "is recommended for plotting against real data. For both representations"
-                                  "the specific output fields and their order can be set."
-                                  "The work of this postprocessor should better be done by the main particles "
-                                  "postprocessor, however we need to be able to process the data before outputting it, "
-                                  "which does not work with that postprocessor. If this is added to the other "
-                                  "postprocessor in the future this one becomes obsolete.")
-  }
-}
diff --git a/source/postprocess/depth_average.cc.bak b/source/postprocess/depth_average.cc.bak
deleted file mode 100644
index c753fef2467..00000000000
--- a/source/postprocess/depth_average.cc.bak
+++ /dev/null
@@ -1,517 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/depth_average.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/lateral_averaging.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/utilities.h>
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/tria.h>
-#include <deal.II/fe/fe_dgq.h>
-#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/numerics/data_out_stack.h>
-
-
-#include <cmath>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    template <class Archive>
-    void DepthAverage<dim>::DataPoint::serialize (Archive &ar,
-                                                  const unsigned int)
-    {
-      ar &time &values;
-    }
-
-
-    template <int dim>
-    DepthAverage<dim>::DepthAverage ()
-      :
-      // the following value is later read from the input file
-      output_interval (0),
-      // initialize this to a nonsensical value; set it to the actual time
-      // the first time around we get to check it
-      last_output_time (std::numeric_limits<double>::quiet_NaN()),
-      n_depth_zones (numbers::invalid_unsigned_int)
-    {}
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    DepthAverage<dim>::execute (TableHandler &)
-    {
-      // if this is the first time we get here, set the next output time
-      // to the current time. this makes sure we always produce data during
-      // the first time step
-      if (std::isnan(last_output_time))
-        last_output_time = this->get_time() - output_interval;
-
-      // see if output is requested at this time
-      if (this->get_time() < last_output_time + output_interval)
-        return {"", ""};
-
-      DataPoint data_point;
-      data_point.time       = this->get_time();
-
-      // Add all the requested fields
-      data_point.values = this->get_lateral_averaging().compute_lateral_averages(depth_bounds,variables);
-      entries.push_back (data_point);
-
-      // On the root process, write out the file. do this using the DataOutStack
-      // class on a piece-wise constant finite element space on
-      // a 1d mesh with the correct subdivisions
-      const std::string filename_prefix (this->get_output_directory() + "depth_average");
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          Triangulation<1> mesh;
-          const Point<1> p(depth_bounds[0]);
-          std::vector<std::vector<double>> spacing(1,std::vector<double>(depth_bounds.size()-1,0.0));
-          for (unsigned int i=0; i<spacing[0].size(); ++i)
-            spacing[0][i]=depth_bounds[i+1]-depth_bounds[i];
-
-          Table<1, types::material_id> material_id(spacing[0].size());
-
-          GridGenerator::subdivided_hyper_rectangle(mesh, spacing, p, material_id);
-
-          FE_DGQ<1> fe(0);
-          DoFHandler<1> dof_handler (mesh);
-          dof_handler.distribute_dofs(fe);
-          Assert (dof_handler.n_dofs() == n_depth_zones, ExcInternalError());
-
-          DataOutStack<1> data_out_stack;
-
-          for (const auto &output_format_string: output_formats)
-            {
-              if (output_format_string != "txt")
-                {
-                  for (const auto &variable : variables)
-                    data_out_stack.declare_data_vector (variable,
-                                                        DataOutStack<1>::cell_vector);
-
-                  for (unsigned int i=0; i<entries.size(); ++i)
-                    {
-                      data_out_stack.new_parameter_value ((this->convert_output_to_years()
-                                                           ?
-                                                           entries[i].time / year_in_seconds
-                                                           :
-                                                           entries[i].time),
-                                                          // declare the time step, which here is the difference
-                                                          // between successive output times. we don't have anything
-                                                          // for the first time step, however. we could do a zero
-                                                          // delta, but that leads to invisible output. rather, we
-                                                          // use an artificial value of one tenth of the first interval,
-                                                          // if available
-                                                          (i == 0 ?
-                                                           (entries.size() > 1 ? (entries[1].time - entries[0].time)/10 : 0) :
-                                                           entries[i].time - entries[i-1].time) /
-                                                          (this->convert_output_to_years()
-                                                           ?
-                                                           year_in_seconds
-                                                           :
-                                                           1));
-
-                      data_out_stack.attach_dof_handler (dof_handler);
-
-                      Vector<double> tmp(n_depth_zones);
-                      for (unsigned int j=0; j<variables.size(); ++j)
-                        {
-                          std::copy (entries[i].values[j].begin(),
-                                     entries[i].values[j].end(),
-                                     tmp.begin());
-                          data_out_stack.add_data_vector (tmp,
-                                                          variables[j]);
-                        }
-                      data_out_stack.build_patches ();
-                      data_out_stack.finish_parameter_value ();
-                    }
-
-                  const DataOutBase::OutputFormat output_format = DataOutBase::parse_output_format(output_format_string);
-
-                  const std::string filename = (filename_prefix +
-                                                DataOutBase::default_suffix(output_format));
-                  std::ofstream f (filename);
-
-
-                  if (output_format == DataOutBase::gnuplot)
-                    {
-                      DataOutBase::GnuplotFlags gnuplot_flags;
-                      gnuplot_flags.space_dimension_labels.resize(2);
-                      gnuplot_flags.space_dimension_labels[0] = "depth";
-                      gnuplot_flags.space_dimension_labels[1] = "time";
-                      data_out_stack.set_flags(gnuplot_flags);
-                    }
-                  data_out_stack.write (f, output_format);
-
-                  AssertThrow (f, ExcMessage("Writing data to <" + filename +
-                                             "> did not succeed in the `point values' "
-                                             "postprocessor."));
-                }
-              else
-                {
-                  const std::string filename (this->get_output_directory() + "depth_average.txt");
-                  std::ofstream f(filename, std::ofstream::out);
-
-                  // Write the header
-                  f << "#       time" << "        depth";
-                  for (const auto &variable : variables)
-                    f << ' ' << variable;
-                  f << std::endl;
-
-                  // Output each data point in the entries object
-                  for (const auto &point : entries)
-                    {
-                      for (unsigned int d = 0; d < point.values[0].size(); ++d)
-                        {
-                          const double depth = (depth_bounds[d] + depth_bounds[d+1]) / 2.0;
-                          f << std::setw(12)
-                            << (this->convert_output_to_years() ? point.time/year_in_seconds : point.time)
-                            << ' ' << std::setw(12) << depth;
-                          for ( unsigned int i = 0; i < variables.size(); ++i )
-                            f << ' ' << std::setw(12) << point.values[i][d];
-                          f << std::endl;
-                        }
-                    }
-
-                  AssertThrow (f, ExcMessage("Writing data to <" + filename +
-                                             "> did not succeed in the `point values' "
-                                             "postprocessor."));
-                }
-            }
-        }
-
-      set_last_output_time (this->get_time());
-
-      // return what should be printed to the screen. note that we had
-      // just incremented the number, so use the previous value
-      return std::make_pair (std::string ("Writing depth average:"),
-                             filename_prefix);
-    }
-
-
-    template <int dim>
-    void
-    DepthAverage<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Depth average");
-        {
-          prm.declare_entry ("Time between graphical output", "1e8",
-                             Patterns::Double (0.),
-                             "The time interval between each generation of "
-                             "graphical output files. A value of zero indicates "
-                             "that output should be generated in each time step. "
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-          prm.declare_entry ("Number of zones", "10",
-                             Patterns::Integer (1),
-                             "The number of zones in depth direction within which we "
-                             "are to compute averages. By default, we subdivide the entire "
-                             "domain into 10 depth zones and compute temperature and other "
-                             "averages within each of these zones. However, if you have a "
-                             "very coarse mesh, it may not make much sense to subdivide "
-                             "the domain into so many zones and you may wish to choose "
-                             "less than this default. It may also make computations slightly "
-                             "faster. On the other hand, if you have an extremely highly "
-                             "resolved mesh, choosing more zones might also make sense.");
-          prm.declare_entry ("Depth boundaries of zones", "",
-                             Patterns::List (Patterns::Double()),
-                             "The depth boundaries of zones within which we "
-                             "are to compute averages. By default this list is empty "
-                             "and we subdivide the entire "
-                             "domain into equidistant depth zones and compute "
-                             "averages within each of these zones. If this list is not "
-                             "empty it has to contain one more entry "
-                             "than the 'Number of zones' parameter, representing the upper "
-                             "and lower depth boundary of each zone. It is not necessary to "
-                             "cover the whole depth-range (i.e. you can select to only average in "
-                             "a single layer by choosing 2 arbitrary depths as the boundaries "
-                             "of that layer).");
-          prm.declare_entry ("Output format", "gnuplot, txt",
-                             Patterns::MultipleSelection(DataOutBase::get_output_format_names().append("|txt")),
-                             "A list of formats in which the output shall be produced. The "
-                             "format in which the output is generated also determines "
-                             "the extension of the file into which data is written. "
-                             "The list of possible output formats that can be given "
-                             "here is documented in the appendix of the manual where "
-                             "the current parameter is described. By default the output "
-                             "is written as gnuplot file (for plotting), and as a simple "
-                             "text file.");
-          const std::string variables =
-            "all|temperature|composition|"
-            "adiabatic temperature|adiabatic pressure|adiabatic density|adiabatic density derivative|"
-            "velocity magnitude|sinking velocity|rising velocity|Vs|Vp|log viscosity|"
-            "viscosity|vertical heat flux|vertical mass flux|composition mass";
-          prm.declare_entry("List of output variables", "all",
-                            Patterns::MultipleSelection(variables),
-                            "A comma separated list which specifies which quantities to "
-                            "average in each depth slice. It defaults to averaging all "
-                            "available quantities, but this can be an expensive operation, "
-                            "so you may want to select only a few.\n\n"
-                            "Specifically, the sinking velocity is defined as the scalar "
-                            "product of the velocity and a unit vector in the direction of "
-                            "gravity, if positive (being zero if this product is negative, "
-                            "which would correspond to an upward velocity). "
-                            "The rising velocity is the opposite: the scalar product of "
-                            "the velocity and a unit vector in the direction opposite of "
-                            "gravity, if positive (being zero for downward velocities). "
-                            "\n\n"
-                            "List of options:\n"
-                            +variables);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    DepthAverage<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Depth average");
-        {
-          n_depth_zones = prm.get_integer ("Number of zones");
-          depth_bounds = Utilities::string_to_double(Utilities::split_string_list(
-                                                       prm.get("Depth boundaries of zones")));
-
-          AssertThrow(depth_bounds.size() == 0 || depth_bounds.size() == n_depth_zones + 1,
-                      ExcMessage("The parameter 'Depth boundaries of zones' has to be either empty, or have exactly "
-                                 "one more entry than the 'Number of zones' parameter."));
-
-          if (depth_bounds.size() == 0)
-            {
-              const double maximal_depth = this->get_geometry_model().maximal_depth();
-              depth_bounds.resize(n_depth_zones+1);
-
-              // Leave index 0 at 0.0, and generate an increasing range of equidistant depth bounds
-              for (unsigned int i=1; i<depth_bounds.size(); ++i)
-                depth_bounds[i] = depth_bounds[i-1] + maximal_depth / n_depth_zones;
-            }
-          else
-            for (unsigned int i=1; i<depth_bounds.size(); ++i)
-              {
-                AssertThrow(depth_bounds[i]>depth_bounds[i-1],
-                            ExcMessage("The entries in the parameter 'Depth boundaries of zones' have "
-                                       "to be sorted in increasing order."));
-              }
-
-          output_interval = prm.get_double ("Time between graphical output");
-          if (this->convert_output_to_years())
-            output_interval *= year_in_seconds;
-
-          if (output_interval > 0.0)
-            {
-              // since we increase the time indicating when to write the next graphical output
-              // every time we execute the depth average postprocessor, there is no good way to
-              // figure out when to write graphical output for the nonlinear iterations if we do
-              // not want to output every time step
-              AssertThrow(this->get_parameters().run_postprocessors_on_nonlinear_iterations == false,
-                          ExcMessage("Postprocessing nonlinear iterations is only supported if every time "
-                                     "step is visualized, or in other words, if the 'Time between graphical "
-                                     "output' in the Depth average postprocessor is set to zero."));
-            }
-
-          std::vector<std::string> output_variables = Utilities::split_string_list(prm.get("List of output variables"));
-          AssertThrow(Utilities::has_unique_entries(output_variables),
-                      ExcMessage("The list of strings for the parameter "
-                                 "'Postprocess/Depth average/List of output variables' contains entries more than once. "
-                                 "This is not allowed. Please check your parameter file."));
-
-          bool output_all_variables = false;
-          if ( std::find( output_variables.begin(), output_variables.end(), "all") != output_variables.end())
-            output_all_variables = true;
-
-          // we have to parse the list in this order to match the output columns
-          {
-            if (output_all_variables || std::find( output_variables.begin(), output_variables.end(), "temperature") != output_variables.end() )
-              variables.emplace_back("temperature");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "composition") != output_variables.end() )
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                variables.emplace_back(this->introspection().name_for_compositional_index(c));
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "adiabatic temperature") != output_variables.end() )
-              variables.emplace_back("adiabatic_temperature");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "adiabatic pressure") != output_variables.end() )
-              variables.emplace_back("adiabatic_pressure");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "adiabatic density") != output_variables.end() )
-              variables.emplace_back("adiabatic_density");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "adiabatic density derivative") != output_variables.end() )
-              variables.emplace_back("adiabatic_density_derivative");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "velocity magnitude") != output_variables.end() )
-              variables.emplace_back("velocity_magnitude");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "sinking velocity") != output_variables.end() )
-              variables.emplace_back("sinking_velocity");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "rising velocity") != output_variables.end() )
-              variables.emplace_back("rising_velocity");
-
-            // handle seismic velocities, because they may, or may not be provided by the material model
-            {
-              MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
-              this->get_material_model().create_additional_named_outputs(out);
-
-              const bool material_model_provides_seismic_output =
-                (out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>() != nullptr);
-
-              const bool output_vs = std::find( output_variables.begin(), output_variables.end(), "Vs") != output_variables.end();
-              const bool output_vp = std::find( output_variables.begin(), output_variables.end(), "Vp") != output_variables.end();
-
-              if (output_vs || output_vp)
-                AssertThrow(material_model_provides_seismic_output,
-                            ExcMessage("You requested seismic velocities from the 'Depth average' postprocessor, "
-                                       "but the material model does not provide seismic velocities. Either remove 'Vs' and "
-                                       "'Vp' from the 'List of output variables' parameter, or use a material model that "
-                                       "provides these velocities."));
-
-              if (output_all_variables && material_model_provides_seismic_output)
-                {
-                  variables.emplace_back("Vs");
-                  variables.emplace_back("Vp");
-                }
-
-              if (output_vs)
-                variables.emplace_back("Vs");
-
-              if (output_vp)
-                variables.emplace_back("Vp");
-            }
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "viscosity") != output_variables.end() )
-              variables.emplace_back("viscosity");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "log viscosity") != output_variables.end() )
-              variables.emplace_back("log_viscosity");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "vertical heat flux") != output_variables.end() )
-              variables.emplace_back("vertical_heat_flux");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "vertical mass flux") != output_variables.end() )
-              variables.emplace_back("vertical_mass_flux");
-
-            if ( output_all_variables || std::find( output_variables.begin(), output_variables.end(), "composition mass") != output_variables.end() )
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                variables.emplace_back(this->introspection().name_for_compositional_index(c) + std::string("_mass"));
-          }
-
-          output_formats = Utilities::split_string_list(prm.get("Output format"));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    template <class Archive>
-    void DepthAverage<dim>::serialize (Archive &ar, const unsigned int)
-    {
-      ar &last_output_time
-      & entries;
-    }
-
-
-    template <int dim>
-    void
-    DepthAverage<dim>::save (std::map<std::string, std::string> &status_strings) const
-    {
-      std::ostringstream os;
-      aspect::oarchive oa (os);
-      oa << (*this);
-
-      status_strings["DepthAverage"] = os.str();
-    }
-
-
-    template <int dim>
-    void
-    DepthAverage<dim>::load (const std::map<std::string, std::string> &status_strings)
-    {
-      // see if something was saved
-      if (status_strings.find("DepthAverage") != status_strings.end())
-        {
-          std::istringstream is (status_strings.find("DepthAverage")->second);
-          aspect::iarchive ia (is);
-          ia >> (*this);
-        }
-    }
-
-
-    template <int dim>
-    void
-    DepthAverage<dim>::set_last_output_time (const double current_time)
-    {
-      // if output_interval is positive, then set the next output interval to
-      // a positive multiple.
-      if (output_interval > 0)
-        {
-          // We need to find the last time output was supposed to be written.
-          // this is the last_output_time plus the largest positive multiple
-          // of output_intervals that passed since then. We need to handle the
-          // edge case where last_output_time+output_interval==current_time,
-          // we did an output and std::floor sadly rounds to zero. This is done
-          // by forcing std::floor to round 1.0-eps to 1.0.
-          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
-        }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(DepthAverage,
-                                  "depth average",
-                                  "A postprocessor that computes depth averaged "
-                                  "quantities and writes them into a file <depth_average.ext> "
-                                  "in the output directory, where the extension of the file "
-                                  "is determined by the output format you select. In addition "
-                                  "to the output format, a number of other parameters also influence "
-                                  "this postprocessor, and they can be set in the section "
-                                  "\\texttt{Postprocess/Depth average} in the input file."
-                                  "\n\n"
-                                  "In the output files, the $x$-value of each data point corresponds "
-                                  "to the depth, whereas the $y$-value corresponds to the "
-                                  "simulation time. The time is provided in seconds or, if the "
-                                  "global ``Use years in output instead of seconds'' parameter is "
-                                  "set, in years.")
-  }
-}
diff --git a/source/postprocess/domain_volume_statistics.cc.bak b/source/postprocess/domain_volume_statistics.cc.bak
deleted file mode 100644
index c6220190fd3..00000000000
--- a/source/postprocess/domain_volume_statistics.cc.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/domain_volume_statistics.h>
-
-#include <deal.II/grid/grid_tools.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    DomainVolume<dim>::execute (TableHandler &statistics)
-    {
-      // Retrieve the current domain volume
-      const double global_volume = this->get_volume();
-
-      // add the volume to the statistics object
-      const std::string unit = (dim == 2) ? "m^2" : "m^3";
-      const std::string name = "Model domain volume (" + unit + ")";
-      statistics.add_value (name, global_volume);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      statistics.set_precision (name, 8);
-      statistics.set_scientific (name, true);
-
-      // create a single string to output to the screen
-      std::ostringstream screen_text;
-      screen_text.precision(4);
-      screen_text << global_volume << " " << unit;
-
-      return std::pair<std::string, std::string> ("Model domain volume:",
-                                                  screen_text.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(DomainVolume,
-                                  "domain volume statistics",
-                                  "A postprocessor that computes the total area (in 2d) "
-                                  "or volume (in 3d) of the computational domain. ")
-  }
-}
diff --git a/source/postprocess/dynamic_topography.cc.bak b/source/postprocess/dynamic_topography.cc.bak
deleted file mode 100644
index 8751c8f9463..00000000000
--- a/source/postprocess/dynamic_topography.cc.bak
+++ /dev/null
@@ -1,548 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/postprocess/dynamic_topography.h>
-
-#include <aspect/postprocess/boundary_pressures.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    DynamicTopography<dim>::execute (TableHandler &)
-    {
-      const Postprocess::BoundaryPressures<dim> &boundary_pressures =
-        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::BoundaryPressures<dim>>();
-
-      // Get the average pressure at the top and bottom boundaries.
-      // This will be used to compute the dynamic pressure at the boundaries.
-      const double surface_pressure = boundary_pressures.pressure_at_top();
-      const double bottom_pressure = boundary_pressures.pressure_at_bottom();
-
-      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-      const types::boundary_id bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
-
-      // If the gravity vector is pointed *up*, as determined by representative points
-      // at the surface and at depth, then we are running backwards advection, and need
-      // to reverse the dynamic topography values.
-      const bool backward_advection = (this->get_gravity_model().gravity_vector(this->get_geometry_model().representative_point(0.)) *
-                                       (this->get_geometry_model().representative_point(0.) -
-                                        this->get_geometry_model().representative_point(this->get_geometry_model().maximal_depth()))) >= 0.;
-
-      const unsigned int quadrature_degree = this->get_fe().base_element(this->introspection().base_elements.velocities).degree+1;
-      // Gauss quadrature in the interior for best accuracy.
-      const QGauss<dim> quadrature_formula(quadrature_degree);
-      // GLL quadrature on the surface to get a diagonal mass matrix.
-      const QGaussLobatto<dim-1> quadrature_formula_face(quadrature_degree);
-
-      const unsigned int dofs_per_cell = this->get_fe().dofs_per_cell;
-      const unsigned int dofs_per_face = this->get_fe().dofs_per_face;
-      const unsigned int n_q_points = quadrature_formula.size();
-      const unsigned int n_face_q_points = quadrature_formula_face.size();
-
-      // The CBF method involves both boundary and volume integrals on the
-      // cells at the boundary. Construct FEValues objects for each of these integrations.
-      FEValues<dim> fe_volume_values (this->get_mapping(),
-                                      this->get_fe(),
-                                      quadrature_formula,
-                                      update_values |
-                                      update_gradients |
-                                      update_quadrature_points |
-                                      update_JxW_values);
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula_face,
-                                        update_JxW_values |
-                                        update_values |
-                                        update_gradients |
-                                        update_quadrature_points);
-
-      // Storage for shape function values for the current solution.
-      // Used for constructing the known side of the CBF system.
-      std::vector<Tensor<1,dim>> phi_u (dofs_per_cell);
-      std::vector<SymmetricTensor<2,dim>> epsilon_phi_u (dofs_per_cell);
-      std::vector<double> div_phi_u (dofs_per_cell);
-      std::vector<double> div_solution(n_q_points);
-
-      // Vectors for solving CBF system.
-      Vector<double> local_vector(dofs_per_cell);
-      Vector<double> local_mass_matrix(dofs_per_cell);
-
-      LinearAlgebra::BlockVector rhs_vector(this->introspection().index_sets.system_partitioning, this->get_mpi_communicator());
-      // The mass matrix may be stored in a vector as it is a
-      // diagonal matrix.
-      LinearAlgebra::BlockVector mass_matrix(this->introspection().index_sets.system_partitioning, this->get_mpi_communicator());
-
-      LinearAlgebra::BlockVector distributed_topo_vector(this->introspection().index_sets.system_partitioning, this->get_mpi_communicator());
-
-      topo_vector.reinit(this->introspection().index_sets.system_partitioning,
-                         this->introspection().index_sets.system_relevant_partitioning,
-                         this->get_mpi_communicator());
-      distributed_topo_vector = 0.;
-      topo_vector = 0.;
-
-      // Possibly keep track of the dynamic topography values for
-      // later surface output.
-      std::vector<std::pair<Point<dim>, double>> stored_values_surface;
-      std::vector<std::pair<Point<dim>, double>> stored_values_bottom;
-      visualization_values.reinit(this->get_triangulation().n_active_cells());
-      visualization_values = 0.;
-
-      // Loop over all of the surface cells and if one less than h/3 away from
-      // one of the top or bottom boundaries, assemble CBF system for it.
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          {
-            // see if the cell is at the *top* or *bottom* boundary, not just any boundary
-            unsigned int face_idx = numbers::invalid_unsigned_int;
-            for (const unsigned int f : cell->face_indices())
-              {
-                if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
-                  {
-                    // If the cell is at the top boundary, assign face_idx.
-                    face_idx = f;
-                    break;
-                  }
-                else if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
-                  {
-                    // If the cell is at the bottom boundary, assign face_idx.
-                    face_idx = f;
-                    break;
-                  }
-              }
-            // If the cell is not at the boundary, jump to the next cell.
-            if (face_idx == numbers::invalid_unsigned_int)
-              continue;
-
-            fe_volume_values.reinit (cell);
-            fe_face_values.reinit (cell, face_idx);
-
-            local_vector = 0.;
-            local_mass_matrix = 0.;
-
-            // Evaluate the material model in the cell volume.
-            MaterialModel::MaterialModelInputs<dim> in_volume(fe_volume_values, cell, this->introspection(), this->get_solution());
-            MaterialModel::MaterialModelOutputs<dim> out_volume(fe_volume_values.n_quadrature_points, this->n_compositional_fields());
-            in_volume.requested_properties = MaterialModel::MaterialProperties::density | MaterialModel::MaterialProperties::viscosity;
-            this->get_material_model().evaluate(in_volume, out_volume);
-
-            // Get solution values for the divergence of the velocity, which is not
-            // computed by the material model.
-            fe_volume_values[this->introspection().extractors.velocities].get_function_divergences (this->get_solution(), div_solution);
-
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                const double eta = out_volume.viscosities[q];
-                const double density = out_volume.densities[q];
-                const bool is_compressible = this->get_material_model().is_compressible();
-                const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(in_volume.position[q]);
-
-                // Set up shape function values
-                for (unsigned int k=0; k<dofs_per_cell; ++k)
-                  {
-                    phi_u[k] = fe_volume_values[this->introspection().extractors.velocities].value(k,q);
-                    epsilon_phi_u[k] = fe_volume_values[this->introspection().extractors.velocities].symmetric_gradient(k,q);
-                    div_phi_u[k] = fe_volume_values[this->introspection().extractors.velocities].divergence (k, q);
-                  }
-
-                for (unsigned int i = 0; i<dofs_per_cell; ++i)
-                  {
-                    // Viscous stress part
-                    local_vector(i) += 2.0 * eta * ( epsilon_phi_u[i] * in_volume.strain_rate[q]
-                                                     - (is_compressible ? 1./3. * div_phi_u[i] * div_solution[q] : 0.0) ) * fe_volume_values.JxW(q);
-                    // Pressure and compressibility parts
-                    local_vector(i) -= div_phi_u[i] * in_volume.pressure[q] * fe_volume_values.JxW(q);
-                    // Force part
-                    local_vector(i) -= density * gravity * phi_u[i] * fe_volume_values.JxW(q);
-                  }
-              }
-            // Assemble the mass matrix for cell face. Since we are using GLL
-            // quadrature, the mass matrix will be diagonal, and we can just assemble it into a vector.
-            for (unsigned int q=0; q < n_face_q_points; ++q)
-              for (unsigned int i=0; i<dofs_per_cell; ++i)
-                local_mass_matrix(i) += fe_face_values[this->introspection().extractors.velocities].value(i,q) *
-                                        fe_face_values[this->introspection().extractors.velocities].value(i,q) *
-                                        fe_face_values.JxW(q);
-
-            cell->distribute_local_to_global(local_vector, rhs_vector);
-            cell->distribute_local_to_global(local_mass_matrix, mass_matrix);
-          }
-
-      rhs_vector.compress(VectorOperation::add);
-      mass_matrix.compress(VectorOperation::add);
-
-      // Since the mass matrix is diagonal, we can just solve for the stress vector by dividing.
-      const IndexSet local_elements = mass_matrix.locally_owned_elements();
-      for (unsigned int k=0; k<local_elements.n_elements(); ++k)
-        {
-          const unsigned int global_index = local_elements.nth_index_in_set(k);
-          if (mass_matrix[global_index] > 1.e-15)
-            distributed_topo_vector[global_index] = rhs_vector[global_index]/mass_matrix[global_index];
-        }
-      distributed_topo_vector.compress(VectorOperation::insert);
-      topo_vector = distributed_topo_vector;
-
-      // Now loop over the cells again and solve for the dynamic topography.
-      // We solve for it on the support points of the system, since it can be
-      // directly put into a system vector of the right size.
-      std::vector<Point<dim-1>> face_support_points = this->get_fe().base_element(this->introspection().base_elements.temperature).get_unit_face_support_points();
-      Quadrature<dim-1> support_quadrature(face_support_points);
-      FEFaceValues<dim> fe_support_values (this->get_mapping(),
-                                           this->get_fe(),
-                                           support_quadrature,
-                                           update_values | update_normal_vectors
-                                           | update_gradients | update_quadrature_points);
-
-      std::vector<Tensor<1,dim>> stress_support_values( support_quadrature.size() );
-      std::vector<double> topo_values( support_quadrature.size() );
-      std::vector<types::global_dof_index> face_dof_indices (dofs_per_face);
-
-      // Also construct data structures for getting the dynamic topography at the cell face
-      // midpoints. This is a more practical thing for text output and visualization.
-      const QGauss<dim-1> output_quadrature(quadrature_degree);
-      FEFaceValues<dim> fe_output_values (this->get_mapping(),
-                                          this->get_fe(),
-                                          output_quadrature,
-                                          update_values | update_normal_vectors | update_gradients |
-                                          update_quadrature_points | update_JxW_values);
-      std::vector<Tensor<1,dim>> stress_output_values( output_quadrature.size() );
-
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          {
-            // see if the cell is at the *top* boundary, not just any boundary
-            unsigned int face_idx = numbers::invalid_unsigned_int;
-            // if the face is at the upper surface 'at_upper_surface' will be true, if
-            // it is at the lower surface 'at_upper_surface' will be false. The default
-            // is true and will be changed to false if it's at the lower boundary. If the
-            // cell is at neither boundary the loop will continue to the next cell.
-            bool at_upper_surface = true;
-            for (const unsigned int f : cell->face_indices())
-              {
-                if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
-                  {
-                    // If the cell is at the top boundary, assign face_idx.
-                    face_idx = f;
-                    at_upper_surface = true;
-                    break;
-                  }
-                else if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
-                  {
-                    // If the cell is at the bottom boundary, assign face_idx.
-                    face_idx = f;
-                    at_upper_surface = false;
-                    break;
-                  }
-              }
-            // If the cell is not at the boundary, jump to the next cell.
-            if (face_idx == numbers::invalid_unsigned_int)
-              continue;
-
-            fe_support_values.reinit (cell, face_idx);
-
-            // Evaluate the material model on the cell face.
-            MaterialModel::MaterialModelInputs<dim> in_support(fe_support_values, cell, this->introspection(), this->get_solution());
-            MaterialModel::MaterialModelOutputs<dim> out_support(fe_support_values.n_quadrature_points, this->n_compositional_fields());
-            in_support.requested_properties = MaterialModel::MaterialProperties::density;
-            this->get_material_model().evaluate(in_support, out_support);
-
-            fe_support_values[this->introspection().extractors.velocities].get_function_values(topo_vector, stress_support_values);
-            cell->face(face_idx)->get_dof_indices (face_dof_indices);
-            for (unsigned int i = 0; i < face_dof_indices.size(); ++i)
-              {
-                // Given the face dof, we get the component and overall cell dof index.
-                const std::pair<unsigned int, unsigned int> component_index = this->get_fe().face_system_to_component_index(i);
-                const unsigned int component = component_index.first;
-                const unsigned int support_index = component_index.second;
-                // Dynamic topography is stored in the temperature component.
-                if (component == this->introspection().component_indices.temperature)
-                  {
-                    // Compute the local gravity at the support point.
-                    const Point<dim> point = fe_support_values.quadrature_point(support_index);
-                    const double gravity_norm = this->get_gravity_model().gravity_vector(point).norm();
-                    const Tensor<1,dim> normal = fe_support_values.normal_vector(support_index);
-
-                    // Compute the dynamic topography, formulae are slightly different
-                    // for upper and lower boundaries.
-                    double dynamic_topography;
-                    if (at_upper_surface)
-                      {
-                        const double delta_rho = out_support.densities[support_index] - density_above;
-                        AssertThrow(std::abs(delta_rho) > std::numeric_limits<double>::min(),
-                                    ExcMessage("delta_rho is close or equal to zero at the surface."));
-                        dynamic_topography = (-stress_support_values[support_index]*normal - surface_pressure)
-                                             / delta_rho / gravity_norm;
-                      }
-                    else
-                      {
-                        const double delta_rho = out_support.densities[support_index] - density_below;
-                        AssertThrow(std::abs(delta_rho) > std::numeric_limits<double>::min(),
-                                    ExcMessage("delta_rho is close or equal to zero at the bottom."));
-                        dynamic_topography = (-stress_support_values[support_index]*normal - bottom_pressure)
-                                             / delta_rho / gravity_norm;
-                      }
-                    distributed_topo_vector[face_dof_indices[i]] = dynamic_topography * (backward_advection ? -1. : 1.);
-                  }
-              }
-
-            // Also evaluate the dynamic topography on the cell faces. This is more convenient
-            // for ASCII output, as well as for use with the visualization postprocessor.
-            fe_output_values.reinit(cell, face_idx);
-
-            // Evaluate the material model on the cell face.
-            MaterialModel::MaterialModelInputs<dim> in_output(fe_output_values, cell, this->introspection(), this->get_solution());
-            MaterialModel::MaterialModelOutputs<dim> out_output(fe_output_values.n_quadrature_points, this->n_compositional_fields());
-            in_output.requested_properties = MaterialModel::MaterialProperties::density;
-            this->get_material_model().evaluate(in_output, out_output);
-
-            fe_output_values[this->introspection().extractors.velocities].get_function_values(topo_vector, stress_output_values);
-
-            // Compute the average dynamic topography at the cell face.
-            double face_area = 0.;
-            double dynamic_topography = 0.;
-            for (unsigned int q=0; q < output_quadrature.size(); ++q)
-              {
-                const Point<dim> point = fe_output_values.quadrature_point(q);
-                const Tensor<1,dim> normal = fe_output_values.normal_vector(q);
-                const double gravity_norm = this->get_gravity_model().gravity_vector(point).norm();
-
-                if (at_upper_surface)
-                  {
-                    const double delta_rho = out_output.densities[q] - density_above;
-                    dynamic_topography += (-stress_output_values[q]*normal - surface_pressure)
-                                          / delta_rho / gravity_norm * fe_output_values.JxW(q);
-                  }
-                else
-                  {
-                    const double delta_rho = out_output.densities[q] - density_below;
-
-                    dynamic_topography += (-stress_output_values[q]*normal - bottom_pressure)
-                                          / delta_rho / gravity_norm * fe_output_values.JxW(q);
-                  }
-                face_area += fe_output_values.JxW(q);
-              }
-            // Get the average dynamic topography for the cell
-            dynamic_topography = dynamic_topography * (backward_advection ? -1. : 1.) / face_area;
-
-            // Maybe keep track of surface output vector.
-            const bool respect_manifold = true;
-            if (output_surface && at_upper_surface)
-              stored_values_surface.push_back(std::make_pair(cell->face(face_idx)->center(respect_manifold), dynamic_topography));
-            // Maybe keep track of bottom output vector.
-            if (output_bottom && !at_upper_surface)
-              stored_values_bottom.push_back(std::make_pair(cell->face(face_idx)->center(respect_manifold), dynamic_topography));
-
-            // Add the value to the vector for the visualization postprocessor.
-            visualization_values(cell->active_cell_index()) = dynamic_topography;
-          }
-      distributed_topo_vector.compress(VectorOperation::insert);
-      topo_vector = distributed_topo_vector;
-
-      // Possibly output the result to file.
-      if (output_surface)
-        output_to_file(top_boundary_id, stored_values_surface);
-      if (output_bottom)
-        output_to_file(bottom_boundary_id, stored_values_bottom);
-
-      return std::pair<std::string,std::string>("Computing dynamic topography", "");
-    }
-
-    /**
-     * Return the topography vector as calculated by CBF formulation
-     */
-    template <int dim>
-    const LinearAlgebra::BlockVector &
-    DynamicTopography<dim>::
-    topography_vector() const
-    {
-      return topo_vector;
-    }
-
-    /**
-     * Return the cellwise topography vector as calculated by CBF formulation
-     */
-    template <int dim>
-    const Vector<float> &
-    DynamicTopography<dim>::
-    cellwise_topography() const
-    {
-      return visualization_values;
-    }
-
-    /**
-     * Register the other postprocessor that we need: BoundaryPressures
-     */
-    template <int dim>
-    std::list<std::string>
-    DynamicTopography<dim>::required_other_postprocessors() const
-    {
-      return {"boundary pressures"};
-    }
-
-
-    /**
-     * Output the dynamic topography solution to
-     * a file.
-     */
-    template <int dim>
-    void
-    DynamicTopography<dim>::output_to_file(const types::boundary_id boundary_id,
-                                           const std::vector<std::pair<Point<dim>,double>> &position_and_topography)
-    {
-      // get boundary name and avoid spaces for file output
-      std::string boundary_name = this->get_geometry_model().translate_id_to_symbol_name(boundary_id);
-      std::replace(boundary_name.begin(), boundary_name.end(), ' ', '_');
-
-      std::ostringstream output;
-
-      // On processor 0, write header lines
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          output << "# "
-                 << ((dim==2)? "x y " : "x y z ")
-                 << "dynamic_topography_" << boundary_name << std::endl;
-        }
-
-      for (unsigned int i = 0; i < position_and_topography.size(); ++i)
-        {
-          output << std::setprecision(10)
-                 << position_and_topography[i].first
-                 << ' '
-                 << std::setprecision(10)
-                 << position_and_topography[i].second
-                 << std::endl;
-        }
-
-      std::string filename = this->get_output_directory() +
-                             "dynamic_topography_" + boundary_name + "." +
-                             Utilities::int_to_string(this->get_timestep_number(), 5);
-      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
-        filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
-
-      Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
-    }
-
-
-    /**
-     * Declare the parameters for the postprocessor.
-     */
-    template <int dim>
-    void
-    DynamicTopography<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Dynamic topography");
-        {
-          prm.declare_entry ("Density above","0.",
-                             Patterns::Double (0.),
-                             "Dynamic topography is calculated as the excess or lack of mass that is supported by mantle flow. "
-                             "This value depends on the density of material that is moved up or down, i.e. crustal rock, and the "
-                             "density of the material that is displaced (generally water or air). While the density of crustal rock "
-                             "is part of the material model, this parameter `Density above' allows the user to specify the density "
-                             "value of material that is displaced above the solid surface. By default this material is assumed to "
-                             "be air, with a density of 0. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Density below","9900.",
-                             Patterns::Double (0.),
-                             "Dynamic topography is calculated as the excess or lack of mass that is supported by mantle flow. "
-                             "This value depends on the density of material that is moved up or down, i.e. mantle above CMB, and the "
-                             "density of the material that is displaced (generally outer core material). While the density of mantle rock "
-                             "is part of the material model, this parameter `Density below' allows the user to specify the density "
-                             "value of material that is displaced below the solid surface. By default this material is assumed to "
-                             "be outer core material with a density of 9900. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Output surface", "true",
-                             Patterns::Bool(),
-                             "Whether to output a file containing the surface dynamic topography.");
-          prm.declare_entry ("Output bottom", "true",
-                             Patterns::Bool(),
-                             "Whether to output a file containing the bottom (i.e., CMB) dynamic topography.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    /**
-     * Declare the parameters for the postprocessor.
-     */
-    template <int dim>
-    void
-    DynamicTopography<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Dynamic topography");
-        {
-          density_above = prm.get_double ("Density above");
-          density_below = prm.get_double ("Density below");
-          output_surface = prm.get_bool ("Output surface");
-          output_bottom = prm.get_bool ("Output bottom");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(DynamicTopography,
-                                  "dynamic topography",
-                                  "A postprocessor that computes a measure of dynamic topography "
-                                  "based on the stress at the boundary. The data is written into text "
-                                  "files named `dynamic\\_topography_\\X.NNNNN' in the output directory, "
-                                  "where X is the name of the boundary and NNNNN is the number of the time step."
-                                  "\n\n"
-                                  "The exact approach works as follows: At each selected boundary, we compute "
-                                  "the traction that acts normal to the boundary faces using the "
-                                  "consistent boundary flux method as described in "
-                                  "``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
-                                  "The consistent Galerkin FEM for computing derived boundary "
-                                  "quantities in thermal and or fluids problems. International "
-                                  "Journal for Numerical Methods in Fluids, 7(4), 371-394.'' "
-                                  "From this traction, the dynamic topography is computed using the formula "
-                                  "$h=\\frac{\\sigma_{n}}{g \\rho}$ where $g$ is the norm of the gravity and $\\rho$ "
-                                  "is the density. For the bottom surface we chose the convention "
-                                  "that positive values are up and negative values are down, analogous to "
-                                  "the deformation of the upper surface. Note that this implementation takes "
-                                  "the direction of gravity into account, which means that reversing the flow "
-                                  "in backward advection calculations will not reverse the instantaneous topography "
-                                  "because the reverse flow will be divided by the reverse surface gravity.  "
-                                  "\n"
-                                  "The file format then consists of lines with Euclidean coordinates "
-                                  "followed by the corresponding topography value.")
-  }
-}
diff --git a/source/postprocess/entropy_viscosity_statistics.cc.bak b/source/postprocess/entropy_viscosity_statistics.cc.bak
deleted file mode 100644
index 0df4a943994..00000000000
--- a/source/postprocess/entropy_viscosity_statistics.cc.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/entropy_viscosity_statistics.h>
-#include <aspect/global.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    EntropyViscosityStatistics<dim>::execute (TableHandler &statistics)
-    {
-      Vector<float> entropy_viscosity(this->get_triangulation().n_active_cells());
-      this->get_artificial_viscosity(entropy_viscosity);
-
-      // The entropy viscosity is cell-wise constant, so a simple midpoint quadrature
-      // will be sufficient to integrate the value over cells.
-      const QMidpoint<dim> quadrature_formula;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_JxW_values);
-
-      double local_maximum_viscosity = 0.0;
-      double local_integrated_viscosity = 0.0;
-      double local_volume = 0.0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                const double entropy_viscosity_cell = entropy_viscosity[cell->active_cell_index()];
-                local_maximum_viscosity = std::max(local_maximum_viscosity,entropy_viscosity_cell);
-                local_volume += fe_values.JxW(q);
-                local_integrated_viscosity += entropy_viscosity_cell * fe_values.JxW(q);
-              }
-          }
-
-      const double global_integrated_viscosity
-        = Utilities::MPI::sum (local_integrated_viscosity, this->get_mpi_communicator());
-      const double global_integrated_volume
-        = Utilities::MPI::sum (local_volume, this->get_mpi_communicator());
-      const double global_maximum_viscosity
-        = Utilities::MPI::max (local_maximum_viscosity, this->get_mpi_communicator());
-
-      const double average_viscosity = global_integrated_viscosity / global_integrated_volume;
-
-      statistics.add_value ("Max entropy viscosity (W/(m*K))",
-                            global_maximum_viscosity);
-      statistics.add_value ("Average entropy viscosity (W/(m*K))",
-                            average_viscosity);
-
-      // also make sure that the columns filled by this plugin
-      // show up with sufficient accuracy and in scientific notation
-      const char *columns[] = { "Max entropy viscosity (W/(m*K))",
-                                "Average entropy viscosity (W/(m*K))"
-                              };
-      for (auto &column : columns)
-        {
-          statistics.set_precision (column, 8);
-          statistics.set_scientific (column, true);
-        }
-
-      std::ostringstream output;
-      output.precision(3);
-      output << global_maximum_viscosity
-             << " W/(m*K), "
-             << average_viscosity
-             << " W/(m*K)";
-
-
-      return std::pair<std::string, std::string> ("Max / average entropy viscosity:",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(EntropyViscosityStatistics,
-                                  "entropy viscosity statistics",
-                                  "A postprocessor that computes the maximum and volume averaged"
-                                  "entropy viscosity stabilization for the temperature field.")
-  }
-}
diff --git a/source/postprocess/geoid.cc.bak b/source/postprocess/geoid.cc.bak
deleted file mode 100644
index 96789262ce4..00000000000
--- a/source/postprocess/geoid.cc.bak
+++ /dev/null
@@ -1,1060 +0,0 @@
-/*
- Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/simulator.h>
-#include <aspect/mesh_deformation/free_surface.h>
-#include <aspect/utilities.h>
-#include <aspect/postprocess/geoid.h>
-#include <aspect/postprocess/dynamic_topography.h>
-#include <aspect/postprocess/boundary_densities.h>
-#include <aspect/geometry_model/spherical_shell.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <aspect/citation_info.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::vector<double>,std::vector<double>>
-    Geoid<dim>::to_spherical_harmonic_coefficients(const std::vector<std::vector<double>> &spherical_function) const
-    {
-      std::vector<double> cosi(spherical_function.size(),0);
-      std::vector<double> sini(spherical_function.size(),0);
-      std::vector<double> coecos;
-      std::vector<double> coesin;
-
-      for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-        {
-          for (unsigned int iord = 0; iord < ideg+1; ++iord)
-            {
-              // Do the spherical harmonic expansion.
-              for (unsigned int ds_num = 0; ds_num < spherical_function.size(); ++ds_num)
-                {
-                  // Normalization after Dahlen and Tromp (1986) Appendix B.6.
-                  const std::pair<double,double> sph_harm_vals = aspect::Utilities::real_spherical_harmonic(ideg,iord,spherical_function.at(ds_num).at(0),spherical_function.at(ds_num).at(1));
-                  const double cos_component = sph_harm_vals.first; // real / cos part
-                  const double sin_component = sph_harm_vals.second; // imaginary / sin part
-
-                  cosi.at(ds_num) = (spherical_function.at(ds_num).at(3) * cos_component);
-                  sini.at(ds_num) = (spherical_function.at(ds_num).at(3) * sin_component);
-                }
-              // Integrate the contribution of each spherical infinitesimal.
-              double cosii = 0;
-              double sinii = 0;
-              for (unsigned int ds_num = 0; ds_num < spherical_function.size(); ++ds_num)
-                {
-                  cosii += cosi.at(ds_num) * spherical_function.at(ds_num).at(2);
-                  sinii += sini.at(ds_num) * spherical_function.at(ds_num).at(2);
-                }
-              coecos.push_back(cosii);
-              coesin.push_back(sinii);
-            }
-        }
-      // Sum over each processor.
-      dealii::Utilities::MPI::sum (coecos,this->get_mpi_communicator(),coecos);
-      dealii::Utilities::MPI::sum (coesin,this->get_mpi_communicator(),coesin);
-
-      return std::make_pair(coecos,coesin);
-    }
-
-    template <int dim>
-    std::pair<std::vector<double>,std::vector<double>>
-    Geoid<dim>::density_contribution (const double &/*outer_radius*/) const
-    {
-      Assert(false, ExcNotImplemented());
-      return std::make_pair(std::vector<double>(), std::vector<double>());
-
-    }
-
-    template <>
-    std::pair<std::vector<double>,std::vector<double>>
-    Geoid<3>::density_contribution (const double &outer_radius) const
-    {
-      const unsigned int quadrature_degree = this->introspection().polynomial_degree.temperature;
-
-      // Need to evaluate density contribution of each volume quadrature point.
-      const QGauss<3> quadrature_formula(quadrature_degree);
-
-      FEValues<3> fe_values (this->get_mapping(),
-                             this->get_fe(),
-                             quadrature_formula,
-                             update_values |
-                             update_quadrature_points |
-                             update_JxW_values |
-                             update_gradients);
-
-      MaterialModel::MaterialModelInputs<3> in(fe_values.n_quadrature_points, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<3> out(fe_values.n_quadrature_points, this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::density;
-
-      std::vector<std::vector<double>>
-      composition_values(this->n_compositional_fields(), std::vector<double>(quadrature_formula.size()));
-
-      // Directly do the global 3d integral over each quadrature point of every cell (different from traditional way to do layer integral).
-      // This is necessary because of ASPECT's adaptive mesh refinement feature.
-      std::vector<double> SH_density_coecos;
-      std::vector<double> SH_density_coesin;
-      for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-        {
-          for (unsigned int iord = 0; iord < ideg+1; ++iord)
-            {
-              // Initialization of the density contribution integral per degree, order.
-              double integrated_density_cos_component = 0;
-              double integrated_density_sin_component = 0;
-
-              // Loop over all of the cells.
-              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-                if (cell->is_locally_owned())
-                  {
-                    fe_values.reinit (cell);
-                    // Set use_strain_rates to false since we don't need viscosity.
-                    in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-                    this->get_material_model().evaluate(in, out);
-
-                    // Compute the integral of the density function
-                    // over the cell, by looping over all quadrature points.
-                    for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-                      {
-                        // Convert coordinates from [x,y,z] to [r, phi, theta].
-                        const std::array<double,3> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(in.position[q]);
-
-                        // Normalization after Dahlen and Tromp (1986) Appendix B.6.
-                        const std::pair<double,double> sph_harm_vals = aspect::Utilities::real_spherical_harmonic(ideg,iord,scoord[2],scoord[1]);
-                        const double cos_component = sph_harm_vals.first; // real / cos part
-                        const double sin_component = sph_harm_vals.second; // imaginary / sin part
-
-                        const double density = out.densities[q];
-                        const double r_q = in.position[q].norm();
-
-                        integrated_density_cos_component += density * (1./r_q) * std::pow(r_q/outer_radius,ideg+1) * cos_component * fe_values.JxW(q);
-                        integrated_density_sin_component += density * (1./r_q) * std::pow(r_q/outer_radius,ideg+1) * sin_component * fe_values.JxW(q);
-                      }
-                  }
-              SH_density_coecos.push_back(integrated_density_cos_component);
-              SH_density_coesin.push_back(integrated_density_sin_component);
-            }
-        }
-      // Sum over each processor.
-      dealii::Utilities::MPI::sum (SH_density_coecos,this->get_mpi_communicator(),SH_density_coecos);
-      dealii::Utilities::MPI::sum (SH_density_coesin,this->get_mpi_communicator(),SH_density_coesin);
-
-      return std::make_pair(SH_density_coecos,SH_density_coesin);
-    }
-
-    template <int dim>
-    std::pair<std::pair<double, std::pair<std::vector<double>,std::vector<double>>>, std::pair<double, std::pair<std::vector<double>,std::vector<double>>>>
-    Geoid<dim>::topography_contribution(const double &/*outer_radius*/,
-                                        const double &/*inner_radius*/) const
-    {
-      Assert(false, ExcNotImplemented());
-      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> temp;
-      return std::make_pair(temp, temp);
-    }
-
-    template <>
-    std::pair<std::pair<double, std::pair<std::vector<double>,std::vector<double>>>, std::pair<double, std::pair<std::vector<double>,std::vector<double>>>>
-    Geoid<3>::topography_contribution(const double &outer_radius,
-                                      const double &inner_radius) const
-    {
-      // Get a pointer to the boundary densities postprocessor.
-      const Postprocess::BoundaryDensities<3> &boundary_densities =
-        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::BoundaryDensities<3>>();
-
-      const double top_layer_average_density = boundary_densities.density_at_top();
-      const double bottom_layer_average_density = boundary_densities.density_at_bottom();
-
-      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-      const types::boundary_id bottom_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
-
-      const unsigned int quadrature_degree = this->introspection().polynomial_degree.temperature;
-      const QGauss<2> quadrature_formula_face(quadrature_degree);
-
-      FEFaceValues<3> fe_face_values (this->get_mapping(),
-                                      this->get_fe(),
-                                      quadrature_formula_face,
-                                      update_values |
-                                      update_quadrature_points |
-                                      update_JxW_values);
-
-      // Vectors to store the location, infinitesimal area, and topography associated with each quadrature point of each surface and bottom cell respectively.
-      std::vector<std::pair<Point<3>,std::pair<double,double>>> surface_stored_values;
-      std::vector<std::pair<Point<3>,std::pair<double,double>>> CMB_stored_values;
-
-      // Loop over all of the boundary cells and if one is at
-      // surface or CMB, evaluate the topography vector there.
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          {
-            unsigned int face_idx = numbers::invalid_unsigned_int;
-            bool at_upper_surface = false;
-            {
-              for (const unsigned int f : cell->face_indices())
-                {
-                  if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
-                    {
-                      // If the cell is at the top boundary, assign face_idx.
-                      face_idx = f;
-                      at_upper_surface = true;
-                      break;
-                    }
-                  else if (cell->at_boundary(f) && cell->face(f)->boundary_id() == bottom_boundary_id)
-                    {
-                      // If the cell is at the bottom boundary, assign face_idx.
-                      face_idx = f;
-                      at_upper_surface = false;
-                      break;
-                    }
-                }
-              // If the cell is not at the boundary, jump to the next cell.
-              if (face_idx == numbers::invalid_unsigned_int)
-                continue;
-            }
-
-            // Focus on the boundary cell's upper face if on the top boundary and lower face if on the bottom boundary.
-            fe_face_values.reinit(cell, face_idx);
-
-            // Topography is evaluated at each quadrature
-            // point on every top/bottom cell's boundary face. The
-            // reason to do this -- as opposed to using a single
-            // value per boundary face -- is that later in the
-            // spherical harmonic expansion, we will calculate
-            // sin(theta)*d_theta*d_phi by
-            // infinitesimal_area/radius^2. The accuracy of this
-            // transfer gets better as infinitesimal_area gets
-            // closer to zero, so using every boundary quadrature
-            // point's associated area (in the form of
-            // FEFaceValues::JxW) will lead to better accuracy in
-            // spherical harmonic expansion compared to using just
-            // one average value per face, especially in the coarse
-            // meshes.
-
-            // If the cell is at the top boundary, add its contributions to the topography surface storage vector.
-            if (at_upper_surface)
-              {
-                if (include_surface_topo_contribution == true)
-                  {
-                    if (use_free_surface_topography == true)
-                      {
-                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                          {
-                            const Point<3> current_position = fe_face_values.quadrature_point(q);
-                            const double topography = this->get_geometry_model().height_above_reference_surface(current_position);
-                            surface_stored_values.emplace_back (current_position, std::make_pair(fe_face_values.JxW(q), topography));
-                          }
-                      }
-                    else
-                      {
-                        // Get a reference to the dynamic topography postprocessor.
-                        const Postprocess::DynamicTopography<3> &dynamic_topography =
-                          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<3>>();
-
-                        // Get the already-computed dynamic topography solution.
-                        const LinearAlgebra::BlockVector &topo_vector = dynamic_topography.topography_vector();
-
-                        std::vector<double> topo_values(quadrature_formula_face.size());
-
-                        fe_face_values[this->introspection().extractors.temperature].get_function_values(topo_vector, topo_values);
-
-                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                          {
-                            surface_stored_values.emplace_back (fe_face_values.quadrature_point(q), std::make_pair(fe_face_values.JxW(q), topo_values[q]));
-                          }
-                      }
-                  }
-                else
-                  {
-                    // If the cell is at the top boundary, but you do not include the surface topography in the geoid computation,
-                    // add its zero contributions to the topography surface storage vector.
-                    if (at_upper_surface)
-                      {
-                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                          {
-                            surface_stored_values.emplace_back (fe_face_values.quadrature_point(q), std::make_pair(fe_face_values.JxW(q), 0.0));
-                          }
-                      }
-                  }
-              }
-
-            // If the cell is at the bottom boundary, add its contributions to the topography CMB storage vector.
-            if (at_upper_surface == false)
-              {
-                if (include_CMB_topo_contribution == true)
-                  {
-                    if (use_free_CMB_topography == true)
-                      {
-                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                          {
-                            const Point<3> current_position = fe_face_values.quadrature_point(q);
-                            const double topography = this->get_geometry_model().height_above_reference_surface(current_position) + (outer_radius - inner_radius);
-                            CMB_stored_values.emplace_back (current_position, std::make_pair(fe_face_values.JxW(q), topography));
-                          }
-                      }
-                    else
-                      {
-                        // Get a reference to the dynamic topography postprocessor.
-                        const Postprocess::DynamicTopography<3> &dynamic_topography =
-                          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<3>>();
-
-                        // Get the already-computed dynamic topography solution.
-                        const LinearAlgebra::BlockVector &topo_vector = dynamic_topography.topography_vector();
-
-                        std::vector<double> topo_values(quadrature_formula_face.size());
-
-                        fe_face_values[this->introspection().extractors.temperature].get_function_values(topo_vector, topo_values);
-
-                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                          {
-                            CMB_stored_values.emplace_back (fe_face_values.quadrature_point(q), std::make_pair(fe_face_values.JxW(q), topo_values[q]));
-                          }
-                      }
-                  }
-                else
-                  {
-                    // If the cell is at the bottom boundary, but you do not include the CMB topography in the geoid computation,
-                    // add its zero contributions to the topography CMB storage vector.
-                    if (at_upper_surface == false)
-                      {
-                        for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                          {
-                            CMB_stored_values.emplace_back (fe_face_values.quadrature_point(q), std::make_pair(fe_face_values.JxW(q), 0.0));
-                          }
-                      }
-                  }
-              }
-          }
-
-      std::vector<std::vector<double>> surface_topo_spherical_function;
-      std::vector<std::vector<double>> CMB_topo_spherical_function;
-
-      for (const auto &surface_stored_value : surface_stored_values)
-        {
-          const std::array<double,3> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(surface_stored_value.first);
-
-          // Calculate spherical infinitesimal sin(theta)*d_theta*d_phi by infinitesimal_area/radius^2
-          const double infinitesimal = surface_stored_value.second.first/(outer_radius*outer_radius);
-
-          // Theta, phi, spherical infinitesimal, and surface topography
-          surface_topo_spherical_function.emplace_back(std::vector<double> {scoord[2],
-                                                                            scoord[1],
-                                                                            infinitesimal,
-                                                                            surface_stored_value.second.second
-                                                                           });
-        }
-
-      for (const auto &CMB_stored_value : CMB_stored_values)
-        {
-          const std::array<double,3> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(CMB_stored_value.first);
-
-          // Calculate spherical infinitesimal sin(theta)*d_theta*d_phi by infinitesimal_area/radius^2
-          const double infinitesimal = CMB_stored_value.second.first/(inner_radius*inner_radius);
-
-          // Theta, phi, spherical infinitesimal, and CMB dynamic topography
-          CMB_topo_spherical_function.emplace_back(std::vector<double> {scoord[2],
-                                                                        scoord[1],
-                                                                        infinitesimal,
-                                                                        CMB_stored_value.second.second
-                                                                       });
-        }
-
-      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> SH_surface_topo_coes
-        = std::make_pair(top_layer_average_density,to_spherical_harmonic_coefficients(surface_topo_spherical_function));
-      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> SH_CMB_topo_coes
-        = std::make_pair(bottom_layer_average_density,to_spherical_harmonic_coefficients(CMB_topo_spherical_function));
-      return std::make_pair(SH_surface_topo_coes,SH_CMB_topo_coes);
-    }
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    Geoid<dim>::execute (TableHandler &)
-    {
-      // Current geoid code only works for spherical shell geometry.
-      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model())
-                   &&
-                   dim == 3,
-                   ExcMessage("The geoid postprocessor is currently only implemented for the 3d spherical shell geometry model."));
-
-      const GeometryModel::SphericalShell<dim> &geometry_model =
-        Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
-
-      // Get the value of the outer radius and inner radius.
-      const double outer_radius = geometry_model.outer_radius();
-      const double inner_radius = geometry_model.inner_radius();
-
-      const types::boundary_id top_boundary_id = geometry_model.translate_symbolic_boundary_name_to_id("top");
-
-      // Get the value of the surface gravity acceleration from the gravity model.
-      Point<dim> surface_point;
-      surface_point[0] = outer_radius;
-      const double surface_gravity = this->get_gravity_model().gravity_vector(surface_point).norm();
-
-      // Get the value of the universal gravitational constant.
-      const double G = aspect::constants::big_g;
-
-      // Get the spherical harmonic coefficients of the density contribution.
-      std::pair<std::vector<double>,std::vector<double>> SH_density_coes = density_contribution(outer_radius);
-      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> SH_surface_topo_coes;
-      std::pair<double, std::pair<std::vector<double>,std::vector<double>>> SH_CMB_topo_coes;
-
-      // Initialize the surface and CMB density contrasts with NaNs because they may be unused in case of no topography contribution.
-      double surface_delta_rho = numbers::signaling_nan<double>();
-      double CMB_delta_rho = numbers::signaling_nan<double>();
-
-      // Get the spherical harmonic coefficients of the surface and CMB topography.
-      std::pair<std::pair<double, std::pair<std::vector<double>,std::vector<double>>>, std::pair<double, std::pair<std::vector<double>,std::vector<double>>>> SH_topo_coes;
-      SH_topo_coes = topography_contribution(outer_radius,inner_radius);
-      SH_surface_topo_coes = SH_topo_coes.first;
-      SH_CMB_topo_coes = SH_topo_coes.second;
-
-      // Get the density contrast at the surface and CMB to replace the initialized NaN values.
-      // The surface and CMB density contrasts will be used later to calculate geoid,
-      // and the spherical harmonic output of the surface and CMB topography contribution to geoid.
-      surface_delta_rho =  SH_surface_topo_coes.first - density_above;
-      CMB_delta_rho = density_below - SH_CMB_topo_coes.first;
-
-      // Compute the spherical harmonic coefficients of geoid anomaly.
-      std::vector<double> density_anomaly_contribution_coecos;
-      std::vector<double> density_anomaly_contribution_coesin;
-      std::vector<double> surface_topo_contribution_coecos;
-      std::vector<double> surface_topo_contribution_coesin;
-      std::vector<double> CMB_topo_contribution_coecos;
-      std::vector<double> CMB_topo_contribution_coesin;
-      geoid_coecos.clear();
-      geoid_coesin.clear();
-
-      // First compute the spherical harmonic contributions from density anomaly, surface topography and CMB topography.
-      int ind = 0; // coefficients index
-      for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-        {
-          for (unsigned int iord = 0; iord < ideg+1; ++iord)
-            {
-              double coecos_density_anomaly = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1))) * SH_density_coes.first.at(ind);
-              double coesin_density_anomaly = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1))) * SH_density_coes.second.at(ind);
-              density_anomaly_contribution_coecos.push_back(coecos_density_anomaly);
-              density_anomaly_contribution_coesin.push_back(coesin_density_anomaly);
-
-              if (include_surface_topo_contribution == true || include_CMB_topo_contribution == true)
-                {
-                  const double coecos_surface_topo = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1)))
-                                                     * surface_delta_rho*SH_surface_topo_coes.second.first.at(ind)*outer_radius;
-                  const double coesin_surface_topo = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1)))
-                                                     * surface_delta_rho*SH_surface_topo_coes.second.second.at(ind)*outer_radius;
-                  surface_topo_contribution_coecos.push_back(coecos_surface_topo);
-                  surface_topo_contribution_coesin.push_back(coesin_surface_topo);
-
-                  const double coecos_CMB_topo = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1)))
-                                                 * CMB_delta_rho*SH_CMB_topo_coes.second.first.at(ind)*inner_radius*std::pow(inner_radius/outer_radius,ideg+1);
-                  const double coesin_CMB_topo = (4 * numbers::PI * G / (surface_gravity * (2 * ideg + 1)))
-                                                 * CMB_delta_rho*SH_CMB_topo_coes.second.second.at(ind)*inner_radius*std::pow(inner_radius/outer_radius,ideg+1);
-                  CMB_topo_contribution_coecos.push_back(coecos_CMB_topo);
-                  CMB_topo_contribution_coesin.push_back(coesin_CMB_topo);
-
-                }
-
-              ++ind;
-            }
-        }
-
-      // Then sum the three contributions together to get the spherical harmonic coefficients of geoid anomaly.
-      ind = 0; // coefficients index
-      for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-        {
-          for (unsigned int iord = 0; iord < ideg+1; ++iord)
-            {
-              if (include_surface_topo_contribution == true || include_CMB_topo_contribution == true)
-                {
-                  geoid_coecos.push_back(density_anomaly_contribution_coecos.at(ind)+surface_topo_contribution_coecos.at(ind)+CMB_topo_contribution_coecos.at(ind));
-                  geoid_coesin.push_back(density_anomaly_contribution_coesin.at(ind)+surface_topo_contribution_coesin.at(ind)+CMB_topo_contribution_coesin.at(ind));
-                }
-              else
-                {
-                  geoid_coecos.push_back(density_anomaly_contribution_coecos.at(ind));
-                  geoid_coesin.push_back(density_anomaly_contribution_coesin.at(ind));
-                }
-
-              ind += 1;
-            }
-        }
-
-      const QMidpoint<dim-1> quadrature_formula_face_center;
-      Assert(quadrature_formula_face_center.size() == 1, ExcInternalError());
-      FEFaceValues<dim> fe_face_center_values (this->get_mapping(),
-                                               this->get_fe(),
-                                               quadrature_formula_face_center,
-                                               update_values |
-                                               update_quadrature_points|
-                                               update_JxW_values);
-
-      // Define a vector to store the location of the cells along the surface.
-      std::vector<Point<dim>> surface_cell_locations;
-
-      // Loop over all the cells to get the locations of the surface cells to prepare for the geoid computation.
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          {
-            // If the cell is at the top boundary, store the cell's upper face midpoint location.
-            for (const unsigned int f : cell->face_indices())
-              if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
-                {
-                  fe_face_center_values.reinit(cell,f);
-                  const Point<dim> midpoint_at_top_face = fe_face_center_values.get_quadrature_points().at(0);
-                  surface_cell_locations.push_back(midpoint_at_top_face);
-                  break;
-                }
-          }
-
-      // Transfer the geocentric coordinates of the surface cells to the surface spherical coordinates (theta,phi)
-      std::vector<std::pair<double,double>> surface_cell_spherical_coordinates;
-      for (unsigned int i=0; i<surface_cell_locations.size(); ++i)
-        {
-          const std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(surface_cell_locations.at(i));
-          const double phi = scoord[1];
-          const double theta = scoord[2];
-          surface_cell_spherical_coordinates.emplace_back(theta,phi);
-        }
-
-      // Compute the grid geoid anomaly based on spherical harmonics.
-      std::vector<double> geoid_anomaly;
-      for (const auto &surface_cell_spherical_coordinate : surface_cell_spherical_coordinates)
-        {
-          int ind = 0;
-          double geoid_value = 0;
-          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-            {
-              for (unsigned int iord = 0; iord < ideg+1; ++iord)
-                {
-                  // Normalization after Dahlen and Tromp (1986) Appendix B.6.
-                  const std::pair<double,double> sph_harm_vals = aspect::Utilities::real_spherical_harmonic(ideg,iord,surface_cell_spherical_coordinate.first,surface_cell_spherical_coordinate.second);
-                  const double cos_component = sph_harm_vals.first; // real / cos part
-                  const double sin_component = sph_harm_vals.second; // imaginary / sin part
-
-                  geoid_value += geoid_coecos.at(ind)*cos_component+geoid_coesin.at(ind)*sin_component;
-                  ++ind;
-                }
-            }
-          geoid_anomaly.push_back(geoid_value);
-        }
-
-      // The user can get the spherical harmonic coefficients of the density anomaly contribution if needed
-      if (output_density_anomaly_contribution_SH_coes == true)
-        {
-          // Have a stream into which we write the SH coefficients data from density anomaly contribution.
-          // The text stream is then later sent to processor 0.
-          std::ostringstream output_density_anomaly_contribution_SH_coes;
-
-          // Prepare the output SH coefficients data from density anomaly contribution.
-          unsigned int SH_coes_ind = 0;
-          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-            {
-              for (unsigned int iord = 0; iord < ideg+1; ++iord)
-                {
-                  output_density_anomaly_contribution_SH_coes << ideg
-                                                              << ' '
-                                                              << iord
-                                                              << ' '
-                                                              << density_anomaly_contribution_coecos.at(SH_coes_ind)
-                                                              << ' '
-                                                              << density_anomaly_contribution_coesin.at(SH_coes_ind)
-                                                              << std::endl;
-                  ++SH_coes_ind;
-                }
-            }
-
-          const std::string density_anomaly_contribution_SH_coes_filename = this->get_output_directory() +
-                                                                            "density_anomaly_contribution_SH_coefficients." +
-                                                                            dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
-
-          // Because each processor already held all the SH coefficients from density anomaly contribution, we only need to stop by the processor 0 to get the data.
-          // On processor 0, collect all the data and put them into the output density anomaly contribution SH coefficients file.
-          if (dealii::Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-            {
-              std::ofstream density_anomaly_contribution_SH_coes_file (density_anomaly_contribution_SH_coes_filename);
-              density_anomaly_contribution_SH_coes_file << "# "
-                                                        << "degree order cosine_coefficient sine_coefficient"
-                                                        << std::endl;
-
-              // Write out the data on processor 0.
-              density_anomaly_contribution_SH_coes_file << output_density_anomaly_contribution_SH_coes.str();
-            }
-        }
-
-      // The user can get the spherical harmonic coefficients of the surface topography contribution if needed
-      if (output_surface_topo_contribution_SH_coes == true)
-        {
-          // Have a stream into which we write the SH coefficients data from surface topography contribution.
-          // The text stream is then later sent to processor 0.
-          std::ostringstream output_surface_topo_contribution_SH_coes;
-
-          // Prepare the output SH coefficients data from surface topography contribution.
-          unsigned int SH_coes_ind = 0;
-          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-            {
-              for (unsigned int iord = 0; iord < ideg+1; ++iord)
-                {
-                  output_surface_topo_contribution_SH_coes << ideg
-                                                           << ' '
-                                                           << iord
-                                                           << ' '
-                                                           << surface_topo_contribution_coecos.at(SH_coes_ind)
-                                                           << ' '
-                                                           << surface_topo_contribution_coesin.at(SH_coes_ind)
-                                                           << std::endl;
-                  ++SH_coes_ind;
-                }
-            }
-
-          const std::string surface_topo_contribution_SH_coes_filename = this->get_output_directory() +
-                                                                         "surface_topography_contribution_SH_coefficients." +
-                                                                         dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
-
-          // Because each processor already held all the SH coefficients from surface topography contribution,
-          // we only need to stop by the processor 0 to get the data. On processor 0, collect all the data
-          // and put them into the output surface topography contribution SH coefficients file.
-          if (dealii::Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-            {
-              std::ofstream surface_topo_contribution_SH_coes_file (surface_topo_contribution_SH_coes_filename);
-              surface_topo_contribution_SH_coes_file << "# "
-                                                     << "degree order cosine_coefficient sine_coefficient"
-                                                     << std::endl;
-              std::ostringstream output_surface_delta_rho;
-              output_surface_delta_rho << surface_delta_rho;
-              surface_topo_contribution_SH_coes_file << "surface density contrast(kg/m^3): "
-                                                     << output_surface_delta_rho.str()
-                                                     << std::endl;
-              // Write out the data on processor 0
-              surface_topo_contribution_SH_coes_file << output_surface_topo_contribution_SH_coes.str();
-            }
-        }
-
-      // The user can get the spherical harmonic coefficients of the CMB topography contribution if needed.
-      if (output_CMB_topo_contribution_SH_coes == true)
-        {
-          // Have a stream into which we write the SH coefficients data from CMB topography contribution.
-          // The text stream is then later sent to processor 0.
-          std::ostringstream output_CMB_topo_contribution_SH_coes;
-
-          // Prepare the output SH coefficients data from CMB topography contribution.
-          unsigned int SH_coes_ind = 0;
-          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-            {
-              for (unsigned int iord = 0; iord < ideg+1; ++iord)
-                {
-                  output_CMB_topo_contribution_SH_coes << ideg
-                                                       << ' '
-                                                       << iord
-                                                       << ' '
-                                                       << CMB_topo_contribution_coecos.at(SH_coes_ind)
-                                                       << ' '
-                                                       << CMB_topo_contribution_coesin.at(SH_coes_ind)
-                                                       << std::endl;
-                  ++SH_coes_ind;
-                }
-            }
-
-          const std::string CMB_topo_contribution_SH_coes_filename = this->get_output_directory() +
-                                                                     "CMB_topography_contribution_SH_coefficients." +
-                                                                     dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
-
-          // Because each processor already held all the SH coefficients from CMB topography contribution, we only need to stop by the processor 0
-          // to get the data. On processor 0, collect all the data and put them into the output CMB topography contribution SH coefficients file.
-          if (dealii::Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-            {
-              std::ofstream CMB_topo_contribution_SH_coes_file (CMB_topo_contribution_SH_coes_filename);
-              CMB_topo_contribution_SH_coes_file << "# "
-                                                 << "degree order cosine_coefficient sine_coefficient"
-                                                 << std::endl;
-              std::ostringstream output_CMB_delta_rho;
-              output_CMB_delta_rho << CMB_delta_rho;
-              CMB_topo_contribution_SH_coes_file << "CMB density contrast(kg/m^3): "
-                                                 << output_CMB_delta_rho.str()
-                                                 << std::endl;
-              // Write out the data on processor 0
-              CMB_topo_contribution_SH_coes_file << output_CMB_topo_contribution_SH_coes.str();
-            }
-        }
-
-      // The user can get the spherical harmonic coefficients of the geoid anomaly if needed.
-      if (output_geoid_anomaly_SH_coes == true)
-        {
-          // Have a stream into which we write the geoid anomaly SH coefficients data.
-          // The text stream is then later sent to processor 0.
-          std::ostringstream output_geoid_anomaly_SH_coes;
-
-          // Prepare the output geoid anomaly SH coefficients data.
-          unsigned int SH_coes_ind = 0;
-          for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-            {
-              for (unsigned int iord = 0; iord < ideg+1; ++iord)
-                {
-                  output_geoid_anomaly_SH_coes << ideg
-                                               << ' '
-                                               << iord
-                                               << ' '
-                                               << geoid_coecos.at(SH_coes_ind)
-                                               << ' '
-                                               << geoid_coesin.at(SH_coes_ind)
-                                               << std::endl;
-                  ++SH_coes_ind;
-                }
-            }
-
-          const std::string geoid_anomaly_SH_coes_filename = this->get_output_directory() +
-                                                             "geoid_anomaly_SH_coefficients." +
-                                                             dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
-
-          // Because each processor already held all the geoid anomaly SH coefficients, we only need to stop by the processor 0 to get the data.
-          // On processor 0, collect all the data and put them into the output geoid anomaly SH coefficients file.
-          if (dealii::Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-            {
-              std::ofstream geoid_anomaly_SH_coes_file (geoid_anomaly_SH_coes_filename);
-              geoid_anomaly_SH_coes_file << "# "
-                                         << "degree order cosine_coefficient sine_coefficient"
-                                         << std::endl;
-
-              // Write out the data on processor 0.
-              geoid_anomaly_SH_coes_file << output_geoid_anomaly_SH_coes.str();
-            }
-        }
-
-      // Have a stream into which we write the geoid height data. the text stream is then
-      // later sent to processor 0.
-      std::ostringstream output;
-
-      // On processor 0, write the header lines
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          output << "# "
-                 << ((output_in_lat_lon == true)? "longitude latitude" : "x y z")
-                 << " geoid_anomaly" << std::endl;
-        }
-
-      // Prepare the output data.
-      if (output_in_lat_lon == true)
-        {
-          double lon, lat;
-          for (unsigned int i=0; i<surface_cell_spherical_coordinates.size(); ++i)
-            {
-              // Transfer the spherical coordinates to geographical coordinates.
-              lat = 90. - surface_cell_spherical_coordinates.at(i).first * constants::radians_to_degree;
-              lon = (surface_cell_spherical_coordinates.at(i).second <= numbers::PI
-                     ?
-                     surface_cell_spherical_coordinates.at(i).second * constants::radians_to_degree
-                     :
-                     surface_cell_spherical_coordinates.at(i).second * constants::radians_to_degree - 360.);
-
-              // Write the solution to the stream output.
-              output << lon
-                     << ' '
-                     << lat
-                     << ' '
-                     << geoid_anomaly.at(i)
-                     << std::endl;
-            }
-        }
-      else
-        {
-          for (unsigned int i=0; i<surface_cell_locations.size(); ++i)
-            {
-              // Write the solution to the stream output.
-              output << surface_cell_locations.at(i)
-                     << ' '
-                     << geoid_anomaly.at(i)
-                     << std::endl;
-            }
-        }
-
-      const std::string filename = this->get_output_directory() +
-                                   "geoid_anomaly." +
-                                   dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
-
-      Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
-
-      // Prepare the free-air gravity anomaly output.
-      if (output_gravity_anomaly == true)
-        {
-          // Have a stream into which we write the gravity anomaly data. the text stream is then
-          // later sent to processor 0.
-          std::ostringstream output_gravity_anomaly;
-
-          // On processor 0, write the header lines:
-          if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-            {
-              output_gravity_anomaly << "# "
-                                     << ((output_in_lat_lon == true)? "longitude latitude" : "x y z")
-                                     << " gravity_anomaly" << std::endl;
-            }
-
-          // Compute the grid gravity anomaly based on spherical harmonics.
-          std::vector<double> gravity_anomaly;
-          gravity_anomaly.reserve(surface_cell_spherical_coordinates.size());
-
-          for (const auto &surface_cell_spherical_coordinate : surface_cell_spherical_coordinates)
-            {
-              int ind = 0;
-              double gravity_value = 0;
-              for (unsigned int ideg =  min_degree; ideg < max_degree+1; ++ideg)
-                {
-                  for (unsigned int iord = 0; iord < ideg+1; ++iord)
-                    {
-                      // Normalization after Dahlen and Tromp (1986) Appendix B.6.
-                      const std::pair<double,double> sph_harm_vals = aspect::Utilities::real_spherical_harmonic(ideg,iord,surface_cell_spherical_coordinate.first,surface_cell_spherical_coordinate.second);
-                      const double cos_component = sph_harm_vals.first; // real / cos part
-                      const double sin_component = sph_harm_vals.second; // imaginary / sin part
-
-                      // The conversion from geoid to gravity anomaly is given by gravity_anomaly = (l-1)*g/R_surface * geoid_anomaly
-                      // based on Forte (2007) equation [97].
-                      gravity_value += (geoid_coecos.at(ind)*cos_component+geoid_coesin.at(ind)*sin_component) * (ideg - 1) * surface_gravity / outer_radius;
-                      ++ind;
-                    }
-                }
-              gravity_anomaly.push_back(gravity_value);
-            }
-
-          // Prepare the output data.
-          if (output_in_lat_lon == true)
-            {
-              double lon, lat;
-              for (unsigned int i=0; i<surface_cell_spherical_coordinates.size(); ++i)
-                {
-                  // Transfer the spherical coordinates to geographical coordinates.
-                  lat = 90. - surface_cell_spherical_coordinates.at(i).first * constants::radians_to_degree;
-                  lon = (surface_cell_spherical_coordinates.at(i).second <= numbers::PI
-                         ?
-                         surface_cell_spherical_coordinates.at(i).second * constants::radians_to_degree
-                         :
-                         surface_cell_spherical_coordinates.at(i).second * constants::radians_to_degree - 360.);
-
-                  // Write the solution to the stream output.
-                  output_gravity_anomaly << lon
-                                         << ' '
-                                         << lat
-                                         << ' '
-                                         << gravity_anomaly.at(i)
-                                         << std::endl;
-                }
-            }
-          else
-            {
-              for (unsigned int i=0; i<surface_cell_locations.size(); ++i)
-                {
-                  // Write the solution to the stream output.
-                  output_gravity_anomaly << surface_cell_locations.at(i)
-                                         << ' '
-                                         << gravity_anomaly.at(i)
-                                         << std::endl;
-                }
-            }
-
-          const std::string filename = this->get_output_directory() +
-                                       "gravity_anomaly." +
-                                       dealii::Utilities::int_to_string(this->get_timestep_number(), 5);
-
-          Utilities::collect_and_write_file_content(filename, output_gravity_anomaly.str(), this->get_mpi_communicator());
-        }
-
-      return std::pair<std::string,std::string>("Writing geoid anomaly:",
-                                                filename);
-    }
-
-    template <int dim>
-    std::list<std::string>
-    Geoid<dim>::required_other_postprocessors() const
-    {
-      std::list<std::string> deps;
-
-      if ( (include_surface_topo_contribution == true && use_free_surface_topography == false) || (include_CMB_topo_contribution == true && use_free_CMB_topography == false) )
-        deps.emplace_back("dynamic topography");
-
-      deps.emplace_back("boundary densities");
-
-      return deps;
-    }
-
-    template <int dim>
-    double
-    Geoid<dim>::evaluate (const Point<dim> &/*p*/) const
-    {
-      Assert(false, ExcNotImplemented());
-      return 0;
-    }
-
-    template <>
-    double
-    Geoid<3>::evaluate (const Point<3> &p) const
-    {
-      const std::array<double,3> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(p);
-      const double theta = scoord[2];
-      const double phi = scoord[1];
-      double value = 0.;
-
-      for (unsigned int ideg=min_degree, k=0; ideg < max_degree+1; ++ideg)
-        for (unsigned int iord = 0; iord < ideg+1; ++iord, ++k)
-          {
-            std::pair<double,double> val = aspect::Utilities::real_spherical_harmonic( ideg, iord, theta, phi );
-
-            value += geoid_coecos[k] * val.first +
-                     geoid_coesin[k] * val.second;
-
-          }
-      return value;
-    }
-
-    template <int dim>
-    void
-    Geoid<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Geoid");
-        {
-          prm.declare_entry("Include surface topography contribution", "true",
-                            Patterns::Bool(),
-                            "Option to include the contribution from surface topography on geoid. The default is true.");
-          prm.declare_entry("Include CMB topography contribution", "true",
-                            Patterns::Bool(),
-                            "Option to include the contribution from CMB topography on geoid. The default is true.");
-          prm.declare_entry("Maximum degree","20",
-                            Patterns::Integer (0),
-                            "This parameter can be a random positive integer. However, the value normally should not exceed the maximum "
-                            "degree of the initial perturbed temperature field. For example, if the initial temperature uses S40RTS, the "
-                            "maximum degree should not be larger than 40.");
-          prm.declare_entry("Minimum degree","2",
-                            Patterns::Integer (0),
-                            "This parameter normally is set to 2 since the perturbed gravitational potential at degree 1 always vanishes "
-                            "in a reference frame with the planetary center of mass same as the center of figure.");
-          prm.declare_entry("Output data in geographical coordinates", "false",
-                            Patterns::Bool(),
-                            "Option to output the geoid anomaly in geographical coordinates (latitude and longitude). "
-                            "The default is false, so the postprocessor will output the data in geocentric coordinates (x,y,z) as normally.");
-          prm.declare_entry("Density above","0.",
-                            Patterns::Double (0.),
-                            "The density value above the surface boundary.");
-          prm.declare_entry("Density below","9900.",
-                            Patterns::Double (0.),
-                            "The density value below the CMB boundary.");
-          prm.declare_entry("Output geoid anomaly coefficients", "false",
-                            Patterns::Bool(),
-                            "Option to output the spherical harmonic coefficients of the geoid anomaly up to the maximum degree. "
-                            "The default is false, so the postprocessor will only output the geoid anomaly in grid format. ");
-          prm.declare_entry("Output surface topography contribution coefficients", "false",
-                            Patterns::Bool(),
-                            "Option to output the spherical harmonic coefficients of the surface topography contribution "
-                            "to the maximum degree. The default is false. ");
-          prm.declare_entry("Output CMB topography contribution coefficients", "false",
-                            Patterns::Bool(),
-                            "Option to output the spherical harmonic coefficients of the CMB topography contribution "
-                            "to the maximum degree. The default is false. ");
-          prm.declare_entry("Output density anomaly contribution coefficients", "false",
-                            Patterns::Bool(),
-                            "Option to output the spherical harmonic coefficients of the density anomaly contribution to the "
-                            "maximum degree. The default is false. ");
-          prm.declare_entry("Output gravity anomaly", "false",
-                            Patterns::Bool(),
-                            "Option to output the free-air gravity anomaly up to the maximum degree. "
-                            "The unit of the output is in SI, hence $m/s^2$ ($1mgal = 10^-5 m/s^2$). The default is false. ");
-
-          prm.declare_alias("Output geoid anomaly coefficients","Also output the spherical harmonic coefficients of geoid anomaly");
-          prm.declare_alias("Output surface topography contribution coefficients","Also output the spherical harmonic coefficients of surface dynamic topography contribution");
-          prm.declare_alias("Output CMB topography contribution coefficients","Also output the spherical harmonic coefficients of CMB dynamic topography contribution");
-          prm.declare_alias("Output density anomaly contribution coefficients","Also output the spherical harmonic coefficients of density anomaly contribution");
-          prm.declare_alias("Output gravity anomaly","Also output the gravity anomaly");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-    template <int dim>
-    void
-    Geoid<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      CitationInfo::add("geoid");
-
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Geoid");
-        {
-          include_surface_topo_contribution = prm.get_bool ("Include surface topography contribution");
-          include_CMB_topo_contribution = prm.get_bool ("Include CMB topography contribution");
-          max_degree = prm.get_integer ("Maximum degree");
-          min_degree = prm.get_integer ("Minimum degree");
-          output_in_lat_lon = prm.get_bool ("Output data in geographical coordinates");
-          density_above = prm.get_double ("Density above");
-          density_below = prm.get_double ("Density below");
-          output_geoid_anomaly_SH_coes = prm.get_bool ("Output geoid anomaly coefficients");
-          output_surface_topo_contribution_SH_coes = prm.get_bool ("Output surface topography contribution coefficients");
-          output_CMB_topo_contribution_SH_coes = prm.get_bool ("Output CMB topography contribution coefficients");
-          output_density_anomaly_contribution_SH_coes = prm.get_bool ("Output density anomaly contribution coefficients");
-          output_gravity_anomaly = prm.get_bool ("Output gravity anomaly");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-    template <int dim>
-    void
-    Geoid<dim>::initialize ()
-    {
-      // Find if the included boundaries are active free surfaces
-      if (include_surface_topo_contribution == true || include_CMB_topo_contribution == true)
-        {
-          if (this->get_parameters().mesh_deformation_enabled == true)
-            {
-              const  types::boundary_id surface_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-              const  types::boundary_id bottom_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("bottom");
-
-              const std::set<types::boundary_id> mesh_deformation_boundaries = this->get_mesh_deformation_handler().get_active_mesh_deformation_boundary_indicators();
-
-              use_free_surface_topography = mesh_deformation_boundaries.find(surface_id) != mesh_deformation_boundaries.end();
-              use_free_CMB_topography = mesh_deformation_boundaries.find(bottom_id) != mesh_deformation_boundaries.end();
-            }
-        }
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(Geoid,
-                                  "geoid",
-                                  "A postprocessor that computes a representation of "
-                                  "the geoid based on the density structure in the mantle, "
-                                  "as well as the topography at the surface and "
-                                  "core mantle boundary (CMB) if desired. The topography is based on the "
-                                  "dynamic topography postprocessor in case of no free surface, "
-                                  "and based on the real surface from the geometry model in case "
-                                  "of a free surface. The geoid is computed "
-                                  "from a spherical harmonic expansion, so the geometry "
-                                  "of the domain must be a 3d spherical shell.")
-  }
-}
diff --git a/source/postprocess/global_statistics.cc.bak b/source/postprocess/global_statistics.cc.bak
deleted file mode 100644
index aae8dd2e811..00000000000
--- a/source/postprocess/global_statistics.cc.bak
+++ /dev/null
@@ -1,324 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/global_statistics.h>
-#include <aspect/simulator.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    void
-    GlobalStatistics<dim>::initialize()
-    {
-      this->get_signals().post_stokes_solver.connect(
-        [&](const SimulatorAccess<dim> &/*simulator_access*/,
-            const unsigned int number_S_iterations,
-            const unsigned int number_A_iterations,
-            const SolverControl &solver_control_cheap,
-            const SolverControl &solver_control_expensive)
-      {
-        this->store_stokes_solver_history(number_S_iterations,
-                                          number_A_iterations,
-                                          solver_control_cheap,
-                                          solver_control_expensive);
-      });
-
-      this->get_signals().post_advection_solver.connect(
-        [&](const SimulatorAccess<dim> &/*simulator_access*/,
-            const bool solved_temperature_field,
-            const unsigned int compositional_index,
-            const SolverControl &solver_control)
-      {
-        this->store_advection_solver_history(solved_temperature_field,
-                                             compositional_index,
-                                             solver_control);
-      });
-
-      // delete the data after the initial refinement steps, to not mix it up
-      // with the first time step
-      if (!this->get_parameters().run_postprocessors_on_initial_refinement)
-        this->get_signals().post_set_initial_state.connect(
-          [&] (const SimulatorAccess<dim> &)
-        {
-          this->clear_data();
-        });
-    }
-
-
-
-    template <int dim>
-    void
-    GlobalStatistics<dim>::clear_data()
-    {
-      list_of_S_iterations.clear();
-      list_of_A_iterations.clear();
-      stokes_iterations_cheap.clear();
-      stokes_iterations_expensive.clear();
-      advection_iterations.clear();
-    }
-
-
-
-    template <int dim>
-    void
-    GlobalStatistics<dim>::store_stokes_solver_history(const unsigned int number_S_iterations,
-                                                       const unsigned int number_A_iterations,
-                                                       const SolverControl &solver_control_cheap,
-                                                       const SolverControl &solver_control_expensive)
-    {
-      list_of_S_iterations.push_back(number_S_iterations);
-      list_of_A_iterations.push_back(number_A_iterations);
-      stokes_iterations_cheap.push_back(solver_control_cheap.last_step());
-      stokes_iterations_expensive.push_back(solver_control_expensive.last_step());
-    }
-
-
-
-    template <int dim>
-    void
-    GlobalStatistics<dim>::store_advection_solver_history(const bool solved_temperature_field,
-                                                          const unsigned int compositional_index,
-                                                          const SolverControl &solver_control)
-    {
-      const std::string column_name = (solved_temperature_field) ?
-                                      "Iterations for temperature solver"
-                                      :
-                                      "Iterations for composition solver " + Utilities::int_to_string(compositional_index+1);
-
-      unsigned int column_position = numbers::invalid_unsigned_int;
-
-      for (unsigned int i=0; i<advection_iterations.size(); ++i)
-        if (column_name == advection_iterations[i].first)
-          column_position = i;
-
-      if (column_position == numbers::invalid_unsigned_int)
-        advection_iterations.emplace_back(column_name,std::vector<unsigned int>(1,solver_control.last_step()));
-      else
-        advection_iterations[column_position].second.push_back(solver_control.last_step());
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    GlobalStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // We would like to know how many nonlinear iterations were performed since
-      // the last call to execute(). Unfortunately some solver schemes iterate only the
-      // Stokes equation, some Stokes and advection, and some do not even call the
-      // Stokes or advection solver. Therefore, the best estimate for the number
-      // of nonlinear iterations since the last call is the maximum size of the
-      // vectors in which we store our data.
-      unsigned int nonlinear_iterations = stokes_iterations_cheap.size();
-
-      for (const auto &advection_iteration : advection_iterations)
-        nonlinear_iterations = std::max(nonlinear_iterations, static_cast<unsigned int> (advection_iteration.second.size()));
-
-      if (one_line_per_iteration)
-        for (unsigned int iteration = 0; iteration < nonlinear_iterations; ++iteration)
-          {
-            generate_global_statistics(statistics);
-
-            statistics.add_value("Nonlinear iteration number",
-                                 iteration);
-
-            for (const auto &advection_iteration : advection_iterations)
-              if (iteration < advection_iteration.second.size())
-                statistics.add_value(advection_iteration.first,
-                                     advection_iteration.second[iteration]);
-
-            if (iteration < stokes_iterations_cheap.size())
-              {
-                statistics.add_value("Iterations for Stokes solver",
-                                     stokes_iterations_cheap[iteration] + stokes_iterations_expensive[iteration]);
-                statistics.add_value("Velocity iterations in Stokes preconditioner",
-                                     list_of_A_iterations[iteration]);
-                statistics.add_value("Schur complement iterations in Stokes preconditioner",
-                                     list_of_S_iterations[iteration]);
-              }
-
-          }
-      else
-        {
-          generate_global_statistics(statistics);
-
-          unsigned int A_iterations = 0;
-          unsigned int S_iterations = 0;
-          unsigned int Stokes_outer_iterations = 0;
-          std::vector<unsigned int> advection_outer_iterations(advection_iterations.size(),0);
-
-          for (unsigned int iteration = 0; iteration < nonlinear_iterations; ++iteration)
-            {
-              for (unsigned int column=0; column<advection_iterations.size(); ++column)
-                if (iteration < advection_iterations[column].second.size())
-                  advection_outer_iterations[column] += advection_iterations[column].second[iteration];
-
-              if (iteration < stokes_iterations_cheap.size())
-                {
-                  A_iterations += list_of_A_iterations[iteration];
-                  S_iterations += list_of_S_iterations[iteration];
-                  Stokes_outer_iterations += stokes_iterations_cheap[iteration] +
-                                             stokes_iterations_expensive[iteration];
-                }
-            }
-
-          // only output the number of nonlinear iterations if we actually
-          // use a nonlinear solver scheme
-          if (!(this->get_parameters().nonlinear_solver == Parameters<dim>::NonlinearSolver::single_Advection_single_Stokes
-                || this->get_parameters().nonlinear_solver == Parameters<dim>::NonlinearSolver::single_Advection_no_Stokes))
-            statistics.add_value("Number of nonlinear iterations",
-                                 nonlinear_iterations);
-
-          // Only output statistics columns if the solver actually signaled at least one
-          // successful solve. Some solver schemes might need no advection or Stokes solver
-          for (unsigned int column=0; column<advection_iterations.size(); ++column)
-            statistics.add_value(advection_iterations[column].first,
-                                 advection_outer_iterations[column]);
-
-          // Note that even if no cheap solver iterations were done, the solver control
-          // object is still stored, so this line works in that case as well.
-          if (stokes_iterations_cheap.size() > 0)
-            {
-              statistics.add_value("Iterations for Stokes solver",
-                                   Stokes_outer_iterations);
-              statistics.add_value("Velocity iterations in Stokes preconditioner",
-                                   A_iterations);
-              statistics.add_value("Schur complement iterations in Stokes preconditioner",
-                                   S_iterations);
-            }
-        }
-
-      clear_data();
-
-      return std::make_pair (std::string(),std::string());
-    }
-
-
-
-    template <int dim>
-    void
-    GlobalStatistics<dim>::generate_global_statistics(TableHandler &statistics)
-    {
-      // set global statistics about this time step
-      statistics.add_value("Time step number", this->get_timestep_number());
-
-      if (this->convert_output_to_years() == true)
-        {
-          statistics.add_value("Time (years)", this->get_time() / year_in_seconds);
-          statistics.set_precision("Time (years)", 12);
-          statistics.set_scientific("Time (years)", true);
-
-          statistics.add_value("Time step size (years)", this->get_timestep() / year_in_seconds);
-          statistics.set_precision("Time step size (years)", 12);
-          statistics.set_scientific("Time step size (years)", true);
-        }
-      else
-        {
-          statistics.add_value("Time (seconds)", this->get_time());
-          statistics.set_precision("Time (seconds)", 12);
-          statistics.set_scientific("Time (seconds)", true);
-
-          statistics.add_value("Time step size (seconds)", this->get_timestep());
-          statistics.set_precision("Time step size (seconds)", 12);
-          statistics.set_scientific("Time step size (seconds)", true);
-        }
-
-      // set global statistics about the mesh and problem size
-      statistics.add_value("Number of mesh cells",
-                           this->get_triangulation().n_global_active_cells());
-
-      types::global_dof_index n_stokes_dofs = this->introspection().system_dofs_per_block[0];
-      if (this->introspection().block_indices.velocities != this->introspection().block_indices.pressure)
-        n_stokes_dofs += this->introspection().system_dofs_per_block[this->introspection().block_indices.pressure];
-
-      statistics.add_value("Number of Stokes degrees of freedom", n_stokes_dofs);
-      statistics.add_value("Number of temperature degrees of freedom",
-                           this->introspection().system_dofs_per_block[this->introspection().block_indices.temperature]);
-      if (this->n_compositional_fields() > 0)
-        statistics.add_value("Number of degrees of freedom for all compositions",
-                             static_cast<types::global_dof_index>(this->n_compositional_fields())
-                             * this->introspection().system_dofs_per_block[this->introspection().block_indices.compositional_fields[0]]);
-    }
-
-
-
-    template <int dim>
-    void
-    GlobalStatistics<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Global statistics");
-        {
-          prm.declare_entry ("Write statistics for each nonlinear iteration", "false",
-                             Patterns::Bool (),
-                             "Whether to put every nonlinear iteration into a separate "
-                             "line in the statistics file (if true), or to output only "
-                             "one line per time step that contains the total number of "
-                             "iterations of the Stokes and advection linear system solver.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    GlobalStatistics<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Global statistics");
-        {
-          one_line_per_iteration = prm.get_bool("Write statistics for each nonlinear iteration");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(GlobalStatistics,
-                                  "global statistics",
-                                  "A postprocessor that outputs all the global statistics "
-                                  "information, e.g. the time of the simulation, the timestep "
-                                  "number, number of degrees of freedom and solver iterations "
-                                  "for each timestep. The postprocessor can output different "
-                                  "formats, the first printing one line in the statistics file "
-                                  "per nonlinear solver iteration (if a nonlinear solver scheme "
-                                  "is selected). The second prints one line per timestep, "
-                                  "summing the information about all nonlinear iterations in "
-                                  "this line. Note that this postprocessor is always active "
-                                  "independent on whether or not it is selected in the "
-                                  "parameter file.")
-  }
-}
diff --git a/source/postprocess/gravity_point_values.cc.bak b/source/postprocess/gravity_point_values.cc.bak
deleted file mode 100644
index 4371292ea51..00000000000
--- a/source/postprocess/gravity_point_values.cc.bak
+++ /dev/null
@@ -1,850 +0,0 @@
-/*
-  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/postprocess/gravity_point_values.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/termination_criteria/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/mpi.templates.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/text_iarchive.hpp>
-#include <boost/lexical_cast.hpp>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    template <int dim>
-    GravityPointValues<dim>::GravityPointValues ()
-      :
-      // the following value is later read from the input file
-      output_interval (0),
-      // initialize this to a nonsensical value; set it to the actual time
-      // the first time around we get to check it
-      last_output_time (std::numeric_limits<double>::quiet_NaN()),
-      maximum_timesteps_between_outputs (std::numeric_limits<int>::max()),
-      last_output_timestep (numbers::invalid_unsigned_int),
-      output_file_number (numbers::invalid_unsigned_int)
-    {}
-
-
-
-    template <int dim>
-    void
-    GravityPointValues<dim>::initialize ()
-    {
-      // Get the value of the outer radius and inner radius:
-      if (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()))
-        {
-          model_outer_radius = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
-                               (this->get_geometry_model()).outer_radius();
-          model_inner_radius = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>>
-                               (this->get_geometry_model()).inner_radius();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()))
-        {
-          model_outer_radius = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
-                               (this->get_geometry_model()).outer_radius();
-          model_inner_radius = Plugins::get_plugin_as_type<const GeometryModel::Chunk<dim>>
-                               (this->get_geometry_model()).inner_radius();
-        }
-      else if (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()))
-        {
-          model_outer_radius = Plugins::get_plugin_as_type<const GeometryModel::Sphere<dim>>
-                               (this->get_geometry_model()).radius();
-          model_inner_radius = 0;
-        }
-      else
-        {
-          model_outer_radius = 1;
-          model_inner_radius = 0;
-        }
-
-
-      // *** First calculate the number of satellites according to the sampling scheme:
-      unsigned int n_satellites;
-      if (sampling_scheme == fibonacci_spiral)
-        n_satellites = n_points_spiral * n_points_radius;
-      else if (sampling_scheme == map)
-        n_satellites = n_points_radius * n_points_longitude * n_points_latitude;
-      else if (sampling_scheme == list_of_points)
-        n_satellites = longitude_list.size();
-      else n_satellites = 1;
-
-      // *** Second assign the coordinates of all satellites:
-      satellite_positions_spherical.resize(n_satellites);
-      if (sampling_scheme == map)
-        {
-          unsigned int p = 0;
-          for (unsigned int h=0; h < n_points_radius; ++h)
-            {
-              for (unsigned int i=0; i < n_points_longitude; ++i)
-                {
-                  for (unsigned int j=0; j < n_points_latitude; ++j)
-                    {
-                      if (n_points_radius > 1)
-                        satellite_positions_spherical[p][0] = minimum_radius + ((maximum_radius - minimum_radius) / (n_points_radius - 1)) * h;
-                      else
-                        satellite_positions_spherical[p][0] = minimum_radius;
-                      if (n_points_longitude > 1)
-                        satellite_positions_spherical[p][1] = (minimum_colongitude + ((maximum_colongitude - minimum_colongitude) /
-                                                                                      (n_points_longitude - 1)) * i) * constants::degree_to_radians;
-                      else
-                        satellite_positions_spherical[p][1] = minimum_colongitude * constants::degree_to_radians;
-                      if (n_points_latitude > 1)
-                        satellite_positions_spherical[p][2] = (minimum_colatitude + ((maximum_colatitude - minimum_colatitude) /
-                                                                                     (n_points_latitude - 1)) * j) * constants::degree_to_radians;
-                      else
-                        satellite_positions_spherical[p][2] = minimum_colatitude * constants::degree_to_radians;
-                      ++p;
-                    }
-                }
-            }
-        }
-      if (sampling_scheme == fibonacci_spiral)
-        {
-          const double golden_ratio = (1. + std::sqrt(5.))/2.;
-          const double golden_angle = 2. * numbers::PI * (1. - 1./golden_ratio);
-          unsigned int p = 0;
-          for (unsigned int h=0; h < n_points_radius; ++h)
-            {
-              for (unsigned int s=0; s < n_points_spiral; ++s)
-                {
-                  if (n_points_radius > 1)
-                    satellite_positions_spherical[p][0] = minimum_radius + ((maximum_radius - minimum_radius) / (n_points_radius - 1)) * h;
-                  else
-                    satellite_positions_spherical[p][0] = minimum_radius;
-                  satellite_positions_spherical[p][2] = std::acos(1. - 2. * s / (n_points_spiral - 1.));
-                  satellite_positions_spherical[p][1] = std::fmod((s*golden_angle), 2.*numbers::PI);
-                  ++p;
-                }
-            }
-        }
-      if (sampling_scheme == list_of_points)
-        {
-          for (unsigned int p=0; p < n_satellites; ++p)
-            {
-              if (radius_list.size() == 1)
-                satellite_positions_spherical[p][0] = radius_list[0];
-              else
-                satellite_positions_spherical[p][0] = radius_list[p];
-              if (longitude_list[p] < 0)
-                satellite_positions_spherical[p][1] = (360 + longitude_list[p]) * constants::degree_to_radians;
-              else
-                satellite_positions_spherical[p][1] = (longitude_list[p]) * constants::degree_to_radians;
-              satellite_positions_spherical[p][2] = (90 - latitude_list[p]) * constants::degree_to_radians;
-            }
-        }
-
-      // The spherical coordinates are shifted into cartesian to allow simplification
-      // in the mathematical equation.
-      satellite_positions_cartesian.resize (n_satellites);
-      for (unsigned int p=0; p<n_satellites; ++p)
-        satellite_positions_cartesian[p]
-          = Utilities::Coordinates::spherical_to_cartesian_coordinates<dim>(satellite_positions_spherical[p]);
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    GravityPointValues<dim>::execute (TableHandler &)
-    {
-      AssertThrow(false, ExcNotImplemented());
-      return {"", ""};
-    }
-
-
-
-    template <>
-    std::pair<std::string,std::string>
-    GravityPointValues<3>::execute (TableHandler &statistics)
-    {
-      const int dim = 3;
-
-      // Check time to see if we output gravity
-      if (std::isnan(last_output_time))
-        {
-          last_output_time = this->get_time() - output_interval;
-          last_output_timestep = this->get_timestep_number();
-        }
-      if ((this->get_time() < last_output_time + output_interval)
-          && (this->get_timestep_number() < last_output_timestep + maximum_timesteps_between_outputs)
-          && (this->get_timestep_number() != 0))
-        return {};
-
-      // Up the counter of the number of the file by one, but not in
-      // the very first output step. if we run postprocessors on all
-      // iterations, only increase file number in the first nonlinear iteration
-      const bool increase_file_number = (this->get_nonlinear_iteration() == 0) ||
-                                        (!this->get_parameters().run_postprocessors_on_nonlinear_iterations);
-      if (output_file_number == numbers::invalid_unsigned_int)
-        output_file_number = 0;
-      else if (increase_file_number)
-        ++output_file_number;
-
-      const std::string file_prefix = "gravity-" + Utilities::int_to_string (output_file_number, 5);
-      const std::string filename = (this->get_output_directory()
-                                    + "output_gravity/"
-                                    + file_prefix);
-
-      // Get quadrature formula and increase the degree of quadrature over the velocity
-      // element degree.
-      const unsigned int degree = this->get_fe().base_element(this->introspection()
-                                                              .base_elements.velocities).degree
-                                  + quadrature_degree_increase;
-      const QGauss<dim> quadrature_formula (degree);
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_gradients |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-
-      // Get the value of the universal gravitational constant:
-      const double G = aspect::constants::big_g;
-
-      const unsigned int n_quadrature_points_per_cell = quadrature_formula.size();
-
-      const unsigned int n_satellites = satellite_positions_spherical.size();
-
-
-      // This is the main loop which computes gravity acceleration, potential and
-      // gradients at a point located at the spherical coordinate [r, phi, theta].
-      // This loop corresponds to the 3 integrals of Newton law:
-      std::vector<double>                 local_g_potential (n_satellites);
-      std::vector<Tensor<1,dim>>          local_g (n_satellites);
-      std::vector<Tensor<1,dim>>          local_g_anomaly (n_satellites);
-      std::vector<SymmetricTensor<2,dim>> local_g_gradient (n_satellites);
-
-      std::vector<double> G_times_density_times_JxW (n_quadrature_points_per_cell);
-      std::vector<double> G_times_density_anomaly_times_JxW (n_quadrature_points_per_cell);
-
-      MaterialModel::MaterialModelInputs<dim> in(quadrature_formula.size(),
-                                                 this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(quadrature_formula.size(),
-                                                   this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::density;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            // Evaluate the solution at the quadrature points of this cell
-            fe_values.reinit (cell);
-
-            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-            this->get_material_model().evaluate(in, out);
-
-            // Pull some computations that are independent of the
-            // satellite position out of the following loop. This is
-            // because we may have a very large number of satellites,
-            // so even just one multiplication that is unnecessarily
-            // repeated can be expensive.
-            for (unsigned int q = 0; q < n_quadrature_points_per_cell; ++q)
-              {
-                G_times_density_times_JxW[q]         = G * out.densities[q] *
-                                                       fe_values.JxW(q);
-                G_times_density_anomaly_times_JxW[q] = G * (out.densities[q]-reference_density) *
-                                                       fe_values.JxW(q);
-              }
-
-
-            for (unsigned int p=0; p < n_satellites; ++p)
-              {
-                const Point<dim> satellite_position = satellite_positions_cartesian[p];
-
-                for (unsigned int q = 0; q < n_quadrature_points_per_cell; ++q)
-                  {
-                    const Tensor<1,dim> r_vector = satellite_position - fe_values.quadrature_point(q);
-
-                    const double r_squared = r_vector.norm_square();
-                    const double r = std::sqrt(r_squared);
-                    const double r_cubed = r * r_squared;
-                    const double one_over_r_cubed = 1. / r_cubed;
-                    const double r_to_the_5 = r_squared * r_cubed;
-
-                    const double G_density_JxW = G_times_density_times_JxW[q];
-
-                    // For gravity acceleration:
-                    const double KK = - G_density_JxW * one_over_r_cubed;
-                    local_g[p] += KK * r_vector;
-
-                    // For gravity anomalies:
-                    const double KK_anomalies = - G_times_density_anomaly_times_JxW[q] * one_over_r_cubed;
-                    local_g_anomaly[p] += KK_anomalies * r_vector;
-
-                    // For gravity potential:
-                    local_g_potential[p] -= G_density_JxW / r;
-
-                    // For gravity gradient:
-                    const double grad_KK = G_density_JxW / r_to_the_5;
-                    for (unsigned int e=0; e<dim; ++e)
-                      for (unsigned int f=e; f<dim; ++f)
-                        local_g_gradient[p][e][f] += grad_KK * (3.0
-                                                                * r_vector[e] * r_vector[f]
-                                                                - (e==f ? r_squared : 0));
-                  }
-              }
-          }
-
-      // Sum local gravity components over global domain and compute
-      // some max and mins. We can directly call Utilities::MPI::sum()
-      // for a vector of doubles, but for the other data types we have
-      // to be more creative:
-      std::vector<double> g_potential(n_satellites);
-      Utilities::MPI::sum (make_const_array_view(local_g_potential),
-                           this->get_mpi_communicator(),
-                           make_array_view(g_potential));
-
-      const auto tensor_sum
-        = [] (const auto &v1, const auto &v2)
-      {
-        AssertDimension (v1.size(), v2.size());
-
-        using element_type = typename std::remove_reference<decltype(v1)>::type::value_type;
-
-        std::vector<element_type> result (v1.size());
-        for (unsigned int i=0; i<result.size(); ++i)
-          result[i] = v1[i] + v2[i];
-        return result;
-      };
-
-      const std::vector<Tensor<1,dim>>
-      g = Utilities::MPI::all_reduce<decltype(local_g)>
-          (local_g,
-           this->get_mpi_communicator(),
-           tensor_sum);
-
-      const std::vector<Tensor<1,dim>>
-      g_anomaly = Utilities::MPI::all_reduce<decltype(local_g_anomaly)>
-                  (local_g_anomaly,
-                   this->get_mpi_communicator(),
-                   tensor_sum);
-
-      const std::vector<SymmetricTensor<2,dim>>
-      g_gradient = Utilities::MPI::all_reduce<decltype(local_g_gradient)>
-                   (local_g_gradient,
-                    this->get_mpi_communicator(),
-                    tensor_sum);
-
-      double sum_g = 0;
-      double min_g = std::numeric_limits<double>::max();
-      double max_g = std::numeric_limits<double>::lowest();
-      double sum_g_potential = 0;
-      double min_g_potential = std::numeric_limits<double>::max();
-      double max_g_potential = std::numeric_limits<double>::lowest();
-
-      for (unsigned int p=0; p < n_satellites; ++p)
-        {
-          // sum gravity components for all n_satellites:
-          sum_g += g[p].norm();
-          sum_g_potential += g_potential[p];
-          max_g = std::max(g[p].norm(), max_g);
-          min_g = std::min(g[p].norm(), min_g);
-          max_g_potential = std::max(g_potential[p], max_g_potential);
-          min_g_potential = std::min(g_potential[p], min_g_potential);
-        }
-
-
-      // Now also compute theoretical values. These are output only
-      // on process zero and, for now, also only computed on process zero.
-      std::vector<double> g_theory(n_satellites);
-      std::vector<double> g_potential_theory(n_satellites);
-      std::vector<SymmetricTensor<2,dim>> g_gradient_theory(n_satellites);
-
-      const unsigned int my_rank
-        = Utilities::MPI::this_mpi_process(this->get_mpi_communicator());
-      const unsigned int n_ranks
-        = Utilities::MPI::n_mpi_processes(this->get_mpi_communicator());
-
-      for (unsigned int p=0; p < n_satellites; ++p)
-        if (p % n_ranks == my_rank)
-          {
-            const Point<dim> satellite_position = satellite_positions_cartesian[p];
-
-            // analytical solution to calculate the theoretical gravity and its derivatives
-            // from a uniform density model. Can only be used if concentric density profile.
-            if (satellite_positions_spherical[p][0] <= model_inner_radius)
-              {
-                // We are inside the inner radius
-                g_theory[p] = 0;
-                g_potential_theory[p] = 2.0 * G * numbers::PI * reference_density *
-                                        ((model_inner_radius * model_inner_radius) - (model_outer_radius * model_outer_radius));
-              }
-            else if ((satellite_positions_spherical[p][0] > model_inner_radius)
-                     && (satellite_positions_spherical[p][0] < model_outer_radius))
-              {
-                // We are in the spherical shell
-                g_theory[p] = G * numbers::PI * 4./3. * reference_density *
-                              (satellite_positions_spherical[p][0] -
-                               ((model_inner_radius * model_inner_radius * model_inner_radius)
-                                /  (satellite_positions_spherical[p][0] * satellite_positions_spherical[p][0])));
-                g_potential_theory[p] = G * numbers::PI * 4./3. * reference_density *
-                                        (((satellite_positions_spherical[p][0] * satellite_positions_spherical[p][0])/2.0) +
-                                         ((model_inner_radius * model_inner_radius * model_inner_radius) / satellite_positions_spherical[p][0]))
-                                        -
-                                        G * numbers::PI * 2.0 * reference_density *
-                                        (model_outer_radius * model_outer_radius);
-              }
-            else
-              {
-                const double common_factor = G * numbers::PI * 4./3. * reference_density
-                                             * ((model_outer_radius * model_outer_radius * model_outer_radius) - (model_inner_radius * model_inner_radius * model_inner_radius));
-                const double r = satellite_positions_spherical[p][0];
-
-                g_theory[p] = common_factor / (r * r);
-                g_potential_theory[p] = - common_factor / r;
-
-                // For the gradient of g, start with the common part of
-                // the diagonal elements:
-                g_gradient_theory[p][0][0] =
-                  g_gradient_theory[p][1][1] =
-                    g_gradient_theory[p][2][2] = -1./(r * r * r);
-
-                // Then do the off-diagonal elements:
-                for (unsigned int e=0; e<dim; ++e)
-                  for (unsigned int f=e; f<dim; ++f)
-                    g_gradient_theory[p][e][f] += -(- 3.0 * satellite_position[e] * satellite_position[f])
-                                                  /  std::pow(r,5);
-                g_gradient_theory[p] *= common_factor;
-              }
-          }
-
-      g_theory = Utilities::MPI::all_reduce<decltype(g_theory)>
-                 (g_theory,
-                  this->get_mpi_communicator(),
-                  tensor_sum);
-
-      g_potential_theory = Utilities::MPI::all_reduce<decltype(g_potential_theory)>
-                           (g_potential_theory,
-                            this->get_mpi_communicator(),
-                            tensor_sum);
-
-      g_gradient_theory = Utilities::MPI::all_reduce<decltype(g_gradient_theory)>
-                          (g_gradient_theory,
-                           this->get_mpi_communicator(),
-                           tensor_sum);
-
-      // open the file on rank 0 and write the headers
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          // First put all of our output into a string buffer:
-          std::ostringstream output;
-          output << "# 1: position_satellite_r" << '\n'
-                 << "# 2: position_satellite_phi" << '\n'
-                 << "# 3: position_satellite_theta" << '\n'
-                 << "# 4: position_satellite_x" << '\n'
-                 << "# 5: position_satellite_y" << '\n'
-                 << "# 6: position_satellite_z" << '\n'
-                 << "# 7: gravity_x" << '\n'
-                 << "# 8: gravity_y" << '\n'
-                 << "# 9: gravity_z" << '\n'
-                 << "# 10: gravity_norm" << '\n'
-                 << "# 11: gravity_theory" << '\n'
-                 << "# 12: gravity_potential" << '\n'
-                 << "# 13: gravity_potential_theory" << '\n'
-                 << "# 14: gravity_anomaly_x" << '\n'
-                 << "# 15: gravity_anomaly_y" << '\n'
-                 << "# 16: gravity_anomaly_z" << '\n'
-                 << "# 17: gravity_anomaly_norm" << '\n'
-                 << "# 18: gravity_gradient_xx" << '\n'
-                 << "# 19: gravity_gradient_yy" << '\n'
-                 << "# 20: gravity_gradient_zz" << '\n'
-                 << "# 21: gravity_gradient_xy" << '\n'
-                 << "# 22: gravity_gradient_xz" << '\n'
-                 << "# 23: gravity_gradient_yz" << '\n'
-                 << "# 24: gravity_gradient_theory_xx" << '\n'
-                 << "# 25: gravity_gradient_theory_yy" << '\n'
-                 << "# 26: gravity_gradient_theory_zz" << '\n'
-                 << "# 27: gravity_gradient_theory_xy" << '\n'
-                 << "# 28: gravity_gradient_theory_xz" << '\n'
-                 << "# 29: gravity_gradient_theory_yz" << '\n'
-                 << '\n';
-
-          for (unsigned int p=0; p < n_satellites; ++p)
-            {
-              const Point<dim> satellite_position = satellite_positions_cartesian[p];
-
-              // write output.
-              // g_gradient is here given in eotvos E (1E = 1e-9 per square seconds):
-              output << satellite_positions_spherical[p][0] << ' '
-                     << satellite_positions_spherical[p][1] * constants::radians_to_degree << ' '
-                     << satellite_positions_spherical[p][2] * constants::radians_to_degree << ' '
-                     << satellite_position[0] << ' '
-                     << satellite_position[1] << ' '
-                     << satellite_position[2] << ' '
-                     << std::setprecision(precision)
-                     << g[p] << ' '
-                     << g[p].norm() << ' '
-                     << g_theory[p] << ' '
-                     << g_potential[p] << ' '
-                     << g_potential_theory[p] << ' '
-                     << g_anomaly[p] << ' '
-                     << g_anomaly[p].norm() << ' '
-                     << g_gradient[p][0][0] *1e9 << ' '
-                     << g_gradient[p][1][1] *1e9 << ' '
-                     << g_gradient[p][2][2] *1e9 << ' '
-                     << g_gradient[p][0][1] *1e9 << ' '
-                     << g_gradient[p][0][2] *1e9 << ' '
-                     << g_gradient[p][1][2] *1e9 << ' '
-                     << g_gradient_theory[p][0][0] *1e9 << ' '
-                     << g_gradient_theory[p][1][1] *1e9 << ' '
-                     << g_gradient_theory[p][2][2] *1e9 << ' '
-                     << g_gradient_theory[p][0][1] *1e9 << ' '
-                     << g_gradient_theory[p][0][2] *1e9 << ' '
-                     << g_gradient_theory[p][1][2] *1e9 << ' '
-                     << '\n';
-            }
-
-          // Now push the entire buffer into the output file in one swoop fell:
-          std::ofstream output_file(filename);
-          AssertThrow(output_file,
-                      ExcMessage("Unable to open file for writing: " + filename +"."));
-          output_file << output.str();
-        }
-
-      // write quantities in the statistic file
-      const std::string name2("Average gravity acceleration (m/s^2)");
-      statistics.add_value (name2, sum_g/n_satellites);
-      statistics.set_precision (name2, precision);
-      statistics.set_scientific (name2, true);
-
-      const std::string name3("Minimum gravity acceleration (m/s^2)");
-      statistics.add_value (name3, min_g);
-      statistics.set_precision (name3, precision);
-      statistics.set_scientific (name3, true);
-
-      const std::string name4("Maximum gravity acceleration (m/s^2)");
-      statistics.add_value (name4, max_g);
-      statistics.set_precision (name4, precision);
-      statistics.set_scientific (name4, true);
-
-      const std::string name5("Average gravity potential (m^2/s^2)");
-      statistics.add_value (name5, sum_g_potential/n_satellites);
-      statistics.set_precision (name5, precision);
-      statistics.set_scientific (name5, true);
-
-      const std::string name6("Minimum gravity potential (m^2/s^2)");
-      statistics.add_value (name6, min_g_potential);
-      statistics.set_precision (name6, precision);
-      statistics.set_scientific (name6, true);
-
-      const std::string name7("Maximum gravity potential (m^2/s^2)");
-      statistics.add_value (name7, max_g_potential);
-      statistics.set_precision (name7, precision);
-      statistics.set_scientific (name7, true);
-
-      // up the next time we need output:
-      set_last_output_time (this->get_time());
-      last_output_timestep = this->get_timestep_number();
-      return std::pair<std::string, std::string> ("Writing gravity output:", filename);
-    }
-
-
-
-    template <int dim>
-    void
-    GravityPointValues<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Postprocess");
-      {
-        prm.enter_subsection ("Gravity calculation");
-        {
-          prm.declare_entry ("Sampling scheme", "map",
-                             Patterns::Selection ("map|list|list of points|fibonacci spiral"),
-                             "Choose the sampling scheme. By default, the map produces a "
-                             "grid of equally angled points between a minimum and maximum "
-                             "radius, longitude, and latitude. A list of points contains "
-                             "the specific coordinates of the satellites. The fibonacci "
-                             "spiral sampling scheme produces a uniformly distributed map "
-                             "on the surface of sphere defined by a minimum and/or "
-                             "maximum radius.");
-          prm.declare_entry ("Number points fibonacci spiral", "200",
-                             Patterns::Integer (0),
-                             "Parameter for the fibonacci spiral sampling scheme: "
-                             "This specifies the desired number of satellites per radius "
-                             "layer. The default value is 200. Note that sampling "
-                             "becomes more uniform with increasing number of satellites");
-          prm.declare_entry ("Quadrature degree increase", "0",
-                             Patterns::Integer (-1),
-                             "Quadrature degree increase over the velocity element "
-                             "degree may be required when gravity is calculated near "
-                             "the surface or inside the model. An increase in the "
-                             "quadrature element adds accuracy to the gravity "
-                             "solution from noise due to the model grid.");
-          prm.declare_entry ("Number points radius", "1",
-                             Patterns::Integer (0),
-                             "Parameter for the map sampling scheme: "
-                             "This specifies the number of points along "
-                             "the radius (e.g. depth profile) between a minimum and "
-                             "maximum radius.");
-          prm.declare_entry ("Number points longitude", "1",
-                             Patterns::Integer (0),
-                             "Parameter for the map sampling scheme: "
-                             "This specifies the number of points along "
-                             "the longitude (e.g. gravity map) between a minimum and "
-                             "maximum longitude.");
-          prm.declare_entry ("Number points latitude", "1",
-                             Patterns::Integer (0),
-                             "Parameter for the map sampling scheme: "
-                             "This specifies the number of points along "
-                             "the latitude (e.g. gravity map) between a minimum and "
-                             "maximum latitude.");
-          prm.declare_entry ("Minimum radius", "0.",
-                             Patterns::Double (0.0),
-                             "Parameter for the map sampling scheme: "
-                             "Minimum radius may be defined in or outside the model. "
-                             "Prescribe a minimum radius for a sampling coverage at a "
-                             "specific height.");
-          prm.declare_entry ("Maximum radius", "0.",
-                             Patterns::Double (0.0),
-                             "Parameter for the map sampling scheme: "
-                             "Maximum radius can be defined in or outside the model.");
-          prm.declare_entry ("Minimum longitude", "-180.",
-                             Patterns::Double (-180.0, 180.0),
-                             "Parameter for the uniform distribution sampling scheme: "
-                             "Gravity may be calculated for a sets of points along "
-                             "the longitude between a minimum and maximum longitude.");
-          prm.declare_entry ("Minimum latitude", "-90.",
-                             Patterns::Double (-90.0, 90.0),
-                             "Parameter for the uniform distribution sampling scheme: "
-                             "Gravity may be calculated for a sets of points along "
-                             "the latitude between a minimum and maximum latitude.");
-          prm.declare_entry ("Maximum longitude", "180.",
-                             Patterns::Double (-180.0, 180.0),
-                             "Parameter for the uniform distribution sampling scheme: "
-                             "Gravity may be calculated for a sets of points along "
-                             "the longitude between a minimum and maximum longitude.");
-          prm.declare_entry ("Maximum latitude", "90",
-                             Patterns::Double (-90.0, 90.0),
-                             "Parameter for the uniform distribution sampling scheme: "
-                             "Gravity may be calculated for a sets of points along "
-                             "the latitude between a minimum and maximum latitude.");
-          prm.declare_entry ("Reference density", "3300.",
-                             Patterns::Double (0.0),
-                             "Gravity anomalies may be computed using density "
-                             "anomalies relative to a reference density.");
-          prm.declare_entry ("Precision in gravity output", "12",
-                             Patterns::Integer (1),
-                             "Set the precision of gravity acceleration, potential "
-                             "and gradients in the gravity output and statistics file.");
-          prm.declare_entry ("List of radius", "",
-                             Patterns::List (Patterns::Double (0.)),
-                             "Parameter for the list of points sampling scheme: "
-                             "List of satellite radius coordinates. Just specify one "
-                             "radius if all points values have the same radius. If "
-                             "not, make sure there are as many radius as longitude "
-                             "and latitude");
-          prm.declare_entry ("List of longitude", "",
-                             Patterns::List (Patterns::Double(-180.0, 180.0)),
-                             "Parameter for the list of points sampling scheme: "
-                             "List of satellite longitude coordinates.");
-          prm.declare_entry ("List of latitude", "",
-                             Patterns::List (Patterns::Double(-90.0, 90.0)),
-                             "Parameter for the list of points sampling scheme: "
-                             "List of satellite latitude coordinates.");
-          prm.declare_entry ("Time between gravity output", "1e8",
-                             Patterns::Double(0.0),
-                             "The time interval between each generation of "
-                             "gravity output files. A value of 0 indicates "
-                             "that output should be generated in each time step. "
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-          prm.declare_entry ("Time steps between gravity output", boost::lexical_cast<std::string>(std::numeric_limits<int>::max()),
-                             Patterns::Integer(0,std::numeric_limits<int>::max()),
-                             "The maximum number of time steps between each generation of "
-                             "gravity output files.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    GravityPointValues<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      std::string gravity_subdirectory = this->get_output_directory() + "output_gravity/";
-      Utilities::create_directory (gravity_subdirectory,
-                                   this->get_mpi_communicator(),
-                                   true);
-
-      end_time = prm.get_double ("End time");
-      if (this->convert_output_to_years())
-        end_time *= year_in_seconds;
-
-      prm.enter_subsection ("Postprocess");
-      {
-        prm.enter_subsection ("Gravity calculation");
-        {
-          if ( (prm.get ("Sampling scheme") == "uniform distribution") || (prm.get ("Sampling scheme") == "map") )
-            sampling_scheme = map;
-          else if ( (prm.get ("Sampling scheme") == "list of points") || (prm.get ("Sampling scheme") == "list") )
-            sampling_scheme = list_of_points;
-          else if (prm.get ("Sampling scheme") == "fibonacci spiral")
-            sampling_scheme = fibonacci_spiral;
-          else
-            AssertThrow (false, ExcMessage ("Not a valid sampling scheme."));
-          quadrature_degree_increase = prm.get_integer ("Quadrature degree increase");
-          n_points_spiral     = prm.get_integer("Number points fibonacci spiral");
-          n_points_radius     = prm.get_integer("Number points radius");
-          n_points_longitude  = prm.get_integer("Number points longitude");
-          n_points_latitude   = prm.get_integer("Number points latitude");
-          minimum_radius      = prm.get_double ("Minimum radius");
-          maximum_radius      = prm.get_double ("Maximum radius");
-          minimum_colongitude = prm.get_double ("Minimum longitude") + 180.;
-          maximum_colongitude = prm.get_double ("Maximum longitude") + 180.;
-          minimum_colatitude  = prm.get_double ("Minimum latitude") + 90.;
-          maximum_colatitude  = prm.get_double ("Maximum latitude") + 90.;
-          reference_density   = prm.get_double ("Reference density");
-          precision = prm.get_integer ("Precision in gravity output");
-          radius_list    = Utilities::string_to_double(Utilities::split_string_list(prm.get("List of radius")));
-          longitude_list = Utilities::string_to_double(Utilities::split_string_list(prm.get("List of longitude")));
-          latitude_list  = Utilities::string_to_double(Utilities::split_string_list(prm.get("List of latitude")));
-          AssertThrow (longitude_list.size() == latitude_list.size(),
-                       ExcMessage ("Make sure you have the same number of point coordinates in the list sampling scheme."));
-          AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()) ||
-                       Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()) ||
-                       Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()),
-                       ExcMessage ("This postprocessor can only be used if the geometry is a sphere, spherical shell or spherical chunk."));
-          AssertThrow (! this->get_material_model().is_compressible(),
-                       ExcMessage("This postprocessor was only tested for incompressible models so far."));
-          AssertThrow (dim==3,
-                       ExcMessage("This postprocessor was only tested for 3d models."));
-          output_interval = prm.get_double ("Time between gravity output");
-          if (this->convert_output_to_years())
-            output_interval *= year_in_seconds;
-          maximum_timesteps_between_outputs = prm.get_integer("Time steps between gravity output");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    template <class Archive>
-    void GravityPointValues<dim>::serialize (Archive &ar, const unsigned int)
-    {
-      // This deals with having the correct behavior during checkpoint/restart cycles:
-      ar &last_output_time
-      & last_output_timestep
-      & output_file_number
-      ;
-    }
-
-
-
-    template <int dim>
-    void
-    GravityPointValues<dim>::set_last_output_time (const double current_time)
-    {
-      // if output_interval is positive, then update the last supposed output time:
-      if (output_interval > 0)
-        {
-          // We need to find the last time output was supposed to be written.
-          // this is the last_output_time plus the largest positive multiple
-          // of output_intervals that passed since then. We need to handle the
-          // edge case where last_output_time+output_interval==current_time,
-          // we did an output and std::floor sadly rounds to zero. This is done
-          // by forcing std::floor to round 1.0-eps to 1.0.
-          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    GravityPointValues<dim>::save (std::map<std::string, std::string> &status_strings) const
-    {
-      std::ostringstream os;
-      aspect::oarchive oa (os);
-      oa << (*this);
-
-      status_strings["GravityPointValues"] = os.str();
-    }
-
-
-
-    template <int dim>
-    void
-    GravityPointValues<dim>::load (const std::map<std::string, std::string> &status_strings)
-    {
-      // see if something was saved
-      if (status_strings.find("GravityPointValues") != status_strings.end())
-        {
-          std::istringstream is (status_strings.find("GravityPointValues")->second);
-          aspect::iarchive ia (is);
-          ia >> (*this);
-        }
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(GravityPointValues,
-                                  "gravity calculation",
-                                  "A postprocessor that computes gravity, gravity anomalies, gravity "
-                                  "potential and gravity gradients for a set of points (e.g. satellites) "
-                                  "in or above the model surface for either a user-defined range of "
-                                  "latitudes, longitudes and radius or a list of point coordinates."
-                                  "Spherical coordinates in the output file are radius, colatitude "
-                                  "and colongitude. Gravity is here based on the density distribution "
-                                  "from the material model (and non adiabatic). This means that the "
-                                  "density may come directly from an ascii file. This postprocessor also "
-                                  "computes theoretical gravity and its derivatives, which corresponds to "
-                                  "the analytical solution of gravity in the same geometry but filled "
-                                  "with a reference density. The reference density is also used to "
-                                  "determine density anomalies for computing gravity anomalies. Thus "
-                                  "one must carefully evaluate the meaning of the gravity anomaly output, "
-                                  "because the solution may not reflect the actual gravity anomaly (due to "
-                                  "differences in the assumed reference density). On way to guarantee correct "
-                                  "gravity anomalies is to subtract gravity of a certain point from the average "
-                                  "gravity on the map. Another way is to directly use density anomalies for this "
-                                  "postprocessor."
-                                  "The average- minimum- and maximum gravity acceleration and potential are "
-                                  "written into the statistics file.")
-  }
-}
diff --git a/source/postprocess/heat_flux_densities.cc.bak b/source/postprocess/heat_flux_densities.cc.bak
deleted file mode 100644
index d4c715f8716..00000000000
--- a/source/postprocess/heat_flux_densities.cc.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/heat_flux_densities.h>
-#include <aspect/postprocess/heat_flux_map.h>
-
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    HeatFluxDensities<dim>::execute (TableHandler &statistics)
-    {
-      const char *unit = (dim==2)? "W/m" : "W/m^2";
-
-      std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area =
-        internal::compute_heat_flux_through_boundary_faces (*this);
-
-      std::map<types::boundary_id, double> local_boundary_fluxes;
-      std::map<types::boundary_id, double> local_areas;
-
-      // Compute the area and heat flux of each boundary that lives on this processor.
-      // Finally, sum over the processors and compute the ratio between the
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (const unsigned int f : cell->face_indices())
-            if (cell->at_boundary(f))
-              {
-                const types::boundary_id boundary_indicator
-                  = cell->face(f)->boundary_id();
-                local_boundary_fluxes[boundary_indicator] += heat_flux_and_area[cell->active_cell_index()][f].first;
-                local_areas[boundary_indicator] += heat_flux_and_area[cell->active_cell_index()][f].second;
-              }
-
-      // now communicate to get the global values
-      std::map<types::boundary_id, double> global_boundary_flux_densities;
-      {
-        // first collect local values in the same order in which they are listed
-        // in the set of boundary indicators
-        const std::set<types::boundary_id>
-        boundary_indicators
-          = this->get_geometry_model().get_used_boundary_indicators ();
-        std::vector<double> local_boundary_fluxes_vector;
-        std::vector<double> local_areas_vector;
-        for (const auto id : boundary_indicators)
-          {
-            local_boundary_fluxes_vector.push_back (local_boundary_fluxes[id]);
-            local_areas_vector.push_back (local_areas[id]);
-          }
-
-        // then collect contributions from all processors
-        std::vector<double> global_values (local_boundary_fluxes_vector.size());
-        std::vector<double> global_areas (local_areas_vector.size());
-        Utilities::MPI::sum (local_boundary_fluxes_vector, this->get_mpi_communicator(), global_values);
-        Utilities::MPI::sum (local_areas_vector, this->get_mpi_communicator(), global_areas);
-
-        // and now take them apart into the global map again and compute ratios
-        unsigned int index = 0;
-        for (const auto id : boundary_indicators)
-          {
-            global_boundary_flux_densities[id] = global_values[index]/global_areas[index];
-            ++index;
-          }
-      }
-
-      // now add all of the computed heat fluxes to the statistics object
-      // and create a single string that can be output to the screen
-      std::ostringstream screen_text;
-      unsigned int index = 0;
-      for (std::map<types::boundary_id, double>::const_iterator
-           p = global_boundary_flux_densities.begin();
-           p != global_boundary_flux_densities.end(); ++p, ++index)
-        {
-          const std::string name = "Outward heat flux density for boundary with id "
-                                   + Utilities::int_to_string(p->first)
-                                   + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                 .translate_id_to_symbol_name (p->first))
-                                   + " (" + unit +")";
-          statistics.add_value (name, p->second);
-
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (name, 8);
-          statistics.set_scientific (name, true);
-
-          // finally have something for the screen
-          screen_text.precision(4);
-          screen_text << p->second << ' ' << unit
-                      << (index == global_boundary_flux_densities.size()-1 ? "" : ", ");
-        }
-
-      return std::pair<std::string, std::string> ("Heat flux densities for boundaries:",
-                                                  screen_text.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(HeatFluxDensities,
-                                  "heat flux densities",
-                                  "A postprocessor that computes some statistics "
-                                  "about the heat flux density for each boundary id. "
-                                  "The heat flux density across each boundary "
-                                  "is computed in outward "
-                                  "direction, i.e., from the domain to the "
-                                  "outside. The heat flux is computed as sum "
-                                  "of advective heat flux and conductive heat "
-                                  "flux through Neumann boundaries, both "
-                                  "computed as integral over the boundary area, "
-                                  "and conductive heat flux through Dirichlet "
-                                  "boundaries, which is computed using the "
-                                  "consistent boundary flux method as described "
-                                  "in ``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
-                                  "The consistent Galerkin FEM for computing "
-                                  "derived boundary quantities in thermal and or "
-                                  "fluids problems. International Journal for "
-                                  "Numerical Methods in Fluids, 7(4), 371-394.''"
-                                  "\n\n"
-                                  "Note that the ``heat flux statistics'' "
-                                  "postprocessor computes the same quantity as "
-                                  "the one here, but not divided by the area of "
-                                  "the surface. In other words, it computes the "
-                                  "\\textit{total} heat flux through each boundary."
-                                 )
-  }
-}
diff --git a/source/postprocess/heat_flux_map.cc.bak b/source/postprocess/heat_flux_map.cc.bak
deleted file mode 100644
index c565d3cdcad..00000000000
--- a/source/postprocess/heat_flux_map.cc.bak
+++ /dev/null
@@ -1,565 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/heat_flux_map.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/boundary_heat_flux/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace internal
-    {
-      template <int dim>
-      LinearAlgebra::BlockVector
-      compute_dirichlet_boundary_heat_flux_solution_vector (const SimulatorAccess<dim> &simulator_access)
-      {
-        // Quadrature degree for assembling the consistent boundary flux equation, see Simulator::assemble_advection_system()
-        // for a justification of the chosen quadrature degree.
-        const unsigned int quadrature_degree = simulator_access.get_parameters().temperature_degree
-                                               +
-                                               (simulator_access.get_parameters().stokes_velocity_degree+1)/2;
-
-        // Gauss quadrature in the interior for best accuracy.
-        const QGauss<dim> quadrature_formula(quadrature_degree);
-        // GLL quadrature on the faces to get a diagonal mass matrix.
-        const QGaussLobatto<dim-1> quadrature_formula_face(quadrature_degree);
-
-        // The CBF method involves both boundary and volume integrals on the
-        // cells at the boundary. Construct FEValues objects for each of these integrations.
-        FEValues<dim> fe_volume_values (simulator_access.get_mapping(),
-                                        simulator_access.get_fe(),
-                                        quadrature_formula,
-                                        update_values |
-                                        update_gradients |
-                                        update_quadrature_points |
-                                        update_JxW_values);
-
-        FEFaceValues<dim> fe_face_values (simulator_access.get_mapping(),
-                                          simulator_access.get_fe(),
-                                          quadrature_formula_face,
-                                          update_JxW_values |
-                                          update_values |
-                                          update_gradients |
-                                          update_normal_vectors |
-                                          update_quadrature_points);
-
-        const unsigned int dofs_per_cell = simulator_access.get_fe().dofs_per_cell;
-        const unsigned int n_q_points = quadrature_formula.size();
-        const unsigned int n_face_q_points = quadrature_formula_face.size();
-
-        // Vectors for solving CBF system. Since we are using GLL
-        // quadrature, the mass matrix will be diagonal, and we can just assemble it into a vector.
-        Vector<double> local_rhs(dofs_per_cell);
-        Vector<double> local_mass_matrix(dofs_per_cell);
-
-        // The mass matrix may be stored in a vector as it is a diagonal matrix:
-        // it is computed based on quadrature over faces, and we use a node-location
-        // based quadrature formula above, so phi_i(x_q)=delta_{iq} where the
-        // x_q are the node points of the finite element shape functions on the face.
-        LinearAlgebra::BlockVector mass_matrix(simulator_access.introspection().index_sets.system_partitioning,
-                                               simulator_access.get_mpi_communicator());
-        LinearAlgebra::BlockVector distributed_heat_flux_vector(simulator_access.introspection().index_sets.system_partitioning,
-                                                                simulator_access.get_mpi_communicator());
-        LinearAlgebra::BlockVector heat_flux_vector(simulator_access.introspection().index_sets.system_partitioning,
-                                                    simulator_access.introspection().index_sets.system_relevant_partitioning,
-                                                    simulator_access.get_mpi_communicator());
-        LinearAlgebra::BlockVector rhs_vector(simulator_access.introspection().index_sets.system_partitioning,
-                                              simulator_access.get_mpi_communicator());
-
-        distributed_heat_flux_vector = 0.;
-        heat_flux_vector = 0.;
-
-        typename MaterialModel::Interface<dim>::MaterialModelInputs
-        in(fe_volume_values.n_quadrature_points, simulator_access.n_compositional_fields());
-        typename MaterialModel::Interface<dim>::MaterialModelOutputs
-        out(fe_volume_values.n_quadrature_points, simulator_access.n_compositional_fields());
-
-        HeatingModel::HeatingModelOutputs
-        heating_out(fe_volume_values.n_quadrature_points, simulator_access.n_compositional_fields());
-
-        typename MaterialModel::Interface<dim>::MaterialModelInputs
-        face_in(fe_face_values.n_quadrature_points, simulator_access.n_compositional_fields());
-        typename MaterialModel::Interface<dim>::MaterialModelOutputs
-        face_out(fe_face_values.n_quadrature_points, simulator_access.n_compositional_fields());
-
-        std::vector<double> old_temperatures (n_q_points);
-        std::vector<double> old_old_temperatures (n_q_points);
-        std::vector<Tensor<1,dim>> temperature_gradients (n_q_points);
-
-        const double time_step = simulator_access.get_timestep();
-        const double old_time_step = simulator_access.get_old_timestep();
-
-        const std::set<types::boundary_id> &fixed_temperature_boundaries =
-          simulator_access.get_boundary_temperature_manager().get_fixed_temperature_boundary_indicators();
-
-        const std::set<types::boundary_id> &fixed_heat_flux_boundaries =
-          simulator_access.get_parameters().fixed_heat_flux_boundary_indicators;
-
-        Vector<float> artificial_viscosity(simulator_access.get_triangulation().n_active_cells());
-        simulator_access.get_artificial_viscosity(artificial_viscosity, true);
-
-        // loop over all of the surface cells and evaluate the heat flux
-        for (const auto &cell : simulator_access.get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned() && cell->at_boundary())
-            {
-              fe_volume_values.reinit (cell);
-              in.reinit(fe_volume_values, cell, simulator_access.introspection(), simulator_access.get_solution());
-              simulator_access.get_material_model().evaluate(in, out);
-
-              if (simulator_access.get_parameters().formulation_temperature_equation ==
-                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-                {
-                  for (unsigned int q=0; q<n_q_points; ++q)
-                    {
-                      out.densities[q] = simulator_access.get_adiabatic_conditions().density(in.position[q]);
-                    }
-                }
-
-              MaterialModel::MaterialAveraging::average (simulator_access.get_parameters().material_averaging,
-                                                         cell,
-                                                         fe_volume_values.get_quadrature(),
-                                                         fe_volume_values.get_mapping(),
-                                                         in.requested_properties,
-                                                         out);
-
-              simulator_access.get_heating_model_manager().evaluate(in, out, heating_out);
-
-              local_rhs = 0.;
-              local_mass_matrix = 0.;
-
-              fe_volume_values[simulator_access.introspection().extractors.temperature].get_function_gradients (simulator_access.get_solution(), temperature_gradients);
-              fe_volume_values[simulator_access.introspection().extractors.temperature].get_function_values (simulator_access.get_old_solution(), old_temperatures);
-              fe_volume_values[simulator_access.introspection().extractors.temperature].get_function_values (simulator_access.get_old_old_solution(), old_old_temperatures);
-
-              // Compute volume integrals on RHS of the CBF system
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  double temperature_time_derivative;
-
-                  if (simulator_access.get_timestep_number() > 1)
-                    {
-                      Assert(time_step > 0.0 && old_time_step > 0.0,
-                             ExcMessage("The heat flux postprocessor found a time step length of 0. "
-                                        "This is not supported, because it needs to compute the time derivative of the "
-                                        "temperature. Either use a positive timestep, or modify the postprocessor to "
-                                        "ignore the time derivative."));
-
-                      temperature_time_derivative = (1.0/time_step) *
-                                                    (in.temperature[q] *
-                                                     (2*time_step + old_time_step) / (time_step + old_time_step)
-                                                     -
-                                                     old_temperatures[q] *
-                                                     (1 + time_step/old_time_step)
-                                                     +
-                                                     old_old_temperatures[q] *
-                                                     (time_step * time_step) / (old_time_step * (time_step + old_time_step)));
-                    }
-                  else if (simulator_access.get_timestep_number() == 1)
-                    {
-                      Assert(time_step > 0.0,
-                             ExcMessage("The heat flux postprocessor found a time step length of 0. "
-                                        "This is not supported, because it needs to compute the time derivative of the "
-                                        "temperature. Either use a positive timestep, or modify the postprocessor to "
-                                        "ignore the time derivative."));
-
-                      temperature_time_derivative =
-                        (in.temperature[q] - old_temperatures[q]) / time_step;
-                    }
-                  else
-                    temperature_time_derivative = 0.0;
-
-                  const double JxW = fe_volume_values.JxW(q);
-
-                  const double density_c_P = out.densities[q] * out.specific_heat[q];
-                  const double latent_heat_LHS = heating_out.lhs_latent_heat_terms[q];
-                  const double material_prefactor = density_c_P + latent_heat_LHS;
-
-                  const double artificial_viscosity_cell = static_cast<double>(artificial_viscosity(cell->active_cell_index()));
-
-                  // The SUPG parameter tau does not have the physical dimensions of a thermal conductivity and as such should not be included in heat flux calculations
-                  // By default, ASPECT includes the artificial viscosity in the thermal conductivity when calculating boundary heat flux.
-                  const double diffusion_constant = (simulator_access.get_parameters().advection_stabilization_method ==
-                                                     Parameters<dim>::AdvectionStabilizationMethod::supg) ?
-                                                    out.thermal_conductivities[q]
-                                                    :
-                                                    std::max(out.thermal_conductivities[q],
-                                                             artificial_viscosity_cell);
-
-                  for (unsigned int i = 0; i<dofs_per_cell; ++i)
-                    {
-                      local_rhs(i) +=
-                        // conduction term (term 2 in equation (30) of Gresho et al.)
-                        (-diffusion_constant * temperature_gradients[q] *
-                         fe_volume_values[simulator_access.introspection().extractors.temperature].gradient(i,q)
-                         +
-                         // advection term and time derivative (term 1 in equation (30) of Gresho et al.)
-                         (- material_prefactor * (temperature_gradients[q] * in.velocity[q] + temperature_time_derivative)
-                          // source terms (term 4 in equation (30) of Gresho et al.)
-                          + heating_out.heating_source_terms[q])
-                         * fe_volume_values[simulator_access.introspection().extractors.temperature].value(i,q))
-                        * JxW;
-                    }
-                }
-
-              for (const unsigned int f : cell->face_indices())
-                {
-                  if (!cell->at_boundary(f))
-                    continue;
-
-                  fe_face_values.reinit (cell, f);
-
-                  const unsigned int boundary_id = cell->face(f)->boundary_id();
-
-                  // Compute heat flux through Dirichlet boundary using CBF method
-                  if (fixed_temperature_boundaries.find(boundary_id) != fixed_temperature_boundaries.end())
-                    {
-                      // Assemble the mass matrix for cell face. Because the quadrature
-                      // formula is chosen as co-located with the nodes of shape functions,
-                      // the resulting matrix is diagonal.
-                      for (unsigned int q=0; q<n_face_q_points; ++q)
-                        for (unsigned int i=0; i<dofs_per_cell; ++i)
-                          local_mass_matrix(i) += fe_face_values[simulator_access.introspection().extractors.temperature].value(i,q) *
-                                                  fe_face_values[simulator_access.introspection().extractors.temperature].value(i,q) *
-                                                  fe_face_values.JxW(q);
-                    }
-                  // Compute heat flux through Neumann boundary by integrating the heat flux
-                  else if (fixed_heat_flux_boundaries.find(boundary_id) != fixed_heat_flux_boundaries.end())
-                    {
-                      face_in.reinit(fe_face_values, cell, simulator_access.introspection(), simulator_access.get_solution());
-                      simulator_access.get_material_model().evaluate(face_in, face_out);
-
-                      if (simulator_access.get_parameters().formulation_temperature_equation ==
-                          Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-                        {
-                          for (unsigned int q=0; q<n_face_q_points; ++q)
-                            {
-                              face_out.densities[q] = simulator_access.get_adiabatic_conditions().density(face_in.position[q]);
-                            }
-                        }
-
-                      std::vector<Tensor<1,dim>> heat_flux(n_face_q_points);
-                      heat_flux = simulator_access.get_boundary_heat_flux().heat_flux(
-                                    boundary_id,
-                                    face_in,
-                                    face_out,
-                                    fe_face_values.get_normal_vectors()
-                                  );
-
-                      // For inhomogeneous Neumann boundaries we know the heat flux across the boundary at each point,
-                      // and can thus simply integrate it for each cell. However, we still need to assemble the
-                      // boundary terms for the CBF method, because there could be Dirichlet boundaries on the
-                      // same cell (e.g. a different face in a corner). Therefore, do the integration into
-                      // heat_flux_and_area, and assemble the CBF term into local_rhs.
-                      for (unsigned int q=0; q < n_face_q_points; ++q)
-                        {
-                          for (unsigned int i = 0; i<dofs_per_cell; ++i)
-                            {
-                              // Neumann boundary condition term (term 3 in equation (30) of Gresho et al.)
-                              local_rhs(i) += - fe_face_values[simulator_access.introspection().extractors.temperature].value(i,q) *
-                                              heat_flux[q] * fe_face_values.normal_vector(q) * fe_face_values.JxW(q);
-                            }
-                        }
-                    }
-                }
-
-              cell->distribute_local_to_global(local_mass_matrix, mass_matrix);
-              cell->distribute_local_to_global(local_rhs, rhs_vector);
-            }
-
-        mass_matrix.compress(VectorOperation::add);
-        rhs_vector.compress(VectorOperation::add);
-
-        const IndexSet local_elements = mass_matrix.locally_owned_elements();
-        for (unsigned int k=0; k<local_elements.n_elements(); ++k)
-          {
-            const unsigned int global_index = local_elements.nth_index_in_set(k);
-
-            // Since the mass matrix is diagonal, we can just solve for the heat flux vector by dividing the
-            // right-hand side by the mass matrix entry
-            if (mass_matrix[global_index] > 1.e-15)
-              distributed_heat_flux_vector[global_index] = rhs_vector[global_index] / mass_matrix[global_index];
-          }
-
-        distributed_heat_flux_vector.compress(VectorOperation::insert);
-        heat_flux_vector = distributed_heat_flux_vector;
-
-        return heat_flux_vector;
-      }
-
-
-
-      template <int dim>
-      std::vector<std::vector<std::pair<double, double>>>
-      compute_heat_flux_through_boundary_faces (const SimulatorAccess<dim> &simulator_access)
-      {
-        std::vector<std::vector<std::pair<double, double>>>
-        heat_flux_and_area(simulator_access.get_triangulation().n_active_cells());
-
-        // Quadrature degree for assembling the consistent boundary flux equation, see Simulator::assemble_advection_system()
-        // for a justification of the chosen quadrature degree.
-        const unsigned int quadrature_degree = simulator_access.get_parameters().temperature_degree
-                                               +
-                                               (simulator_access.get_parameters().stokes_velocity_degree+1)/2;
-
-        // GLL quadrature on the faces to get a diagonal mass matrix.
-        const QGaussLobatto<dim-1> quadrature_formula_face(quadrature_degree);
-
-        FEFaceValues<dim> fe_face_values (simulator_access.get_mapping(),
-                                          simulator_access.get_fe(),
-                                          quadrature_formula_face,
-                                          update_JxW_values |
-                                          update_values |
-                                          update_gradients |
-                                          update_normal_vectors |
-                                          update_quadrature_points);
-
-        const unsigned int n_face_q_points = quadrature_formula_face.size();
-
-        typename MaterialModel::Interface<dim>::MaterialModelInputs face_in(fe_face_values.n_quadrature_points, simulator_access.n_compositional_fields());
-        typename MaterialModel::Interface<dim>::MaterialModelOutputs face_out(fe_face_values.n_quadrature_points, simulator_access.n_compositional_fields());
-
-        const std::set<types::boundary_id> &fixed_temperature_boundaries =
-          simulator_access.get_boundary_temperature_manager().get_fixed_temperature_boundary_indicators();
-
-        const std::set<types::boundary_id> &fixed_heat_flux_boundaries =
-          simulator_access.get_parameters().fixed_heat_flux_boundary_indicators;
-
-        const std::set<types::boundary_id> &tangential_velocity_boundaries =
-          simulator_access.get_boundary_velocity_manager().get_tangential_boundary_velocity_indicators();
-
-        const std::set<types::boundary_id> &zero_velocity_boundaries =
-          simulator_access.get_boundary_velocity_manager().get_zero_boundary_velocity_indicators();
-
-        const LinearAlgebra::BlockVector heat_flux_vector = compute_dirichlet_boundary_heat_flux_solution_vector(simulator_access);
-        std::vector<double> heat_flux_values(n_face_q_points);
-
-        // loop over all of the surface cells and evaluate the heat flux
-        for (const auto &cell : simulator_access.get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned() && cell->at_boundary())
-            {
-              for (const unsigned int f : cell->face_indices())
-                if (cell->at_boundary(f))
-                  {
-                    // See if this is the first face on this cell we visit, and if
-                    // so resize the output array.
-                    if (heat_flux_and_area[cell->active_cell_index()].size() == 0)
-                      heat_flux_and_area[cell->active_cell_index()]
-                      .resize (cell->n_faces(), std::pair<double,double>(0.0,0.0));
-                    else
-                      Assert (heat_flux_and_area[cell->active_cell_index()].size() == cell->n_faces(),
-                              ExcInternalError());
-
-                    // Determine the type of boundary
-                    const unsigned int boundary_id = cell->face(f)->boundary_id();
-                    const bool prescribed_temperature = fixed_temperature_boundaries.find(boundary_id) != fixed_temperature_boundaries.end();
-                    const bool prescribed_heat_flux = fixed_heat_flux_boundaries.find(boundary_id) != fixed_heat_flux_boundaries.end();
-                    const bool non_tangential_velocity =
-                      tangential_velocity_boundaries.find(boundary_id) == tangential_velocity_boundaries.end() &&
-                      zero_velocity_boundaries.find(boundary_id) == zero_velocity_boundaries.end();
-
-                    fe_face_values.reinit (cell, f);
-
-                    // Integrate the face area
-                    for (unsigned int q=0; q<n_face_q_points; ++q)
-                      heat_flux_and_area[cell->active_cell_index()][f].second += fe_face_values.JxW(q);
-
-                    // Compute heat flux through Dirichlet boundaries by integrating the CBF solution vector
-                    if (prescribed_temperature)
-                      {
-                        fe_face_values[simulator_access.introspection().extractors.temperature].get_function_values(heat_flux_vector, heat_flux_values);
-
-                        for (unsigned int q=0; q<n_face_q_points; ++q)
-                          heat_flux_and_area[cell->active_cell_index()][f].first += heat_flux_values[q] *
-                                                                                    fe_face_values.JxW(q);
-                      }
-
-                    // if necessary, compute material properties for this face
-                    if (prescribed_heat_flux || non_tangential_velocity)
-                      {
-                        face_in.reinit(fe_face_values, cell, simulator_access.introspection(), simulator_access.get_solution());
-                        simulator_access.get_material_model().evaluate(face_in, face_out);
-
-                        if (simulator_access.get_parameters().formulation_temperature_equation ==
-                            Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-                          {
-                            for (unsigned int q=0; q<n_face_q_points; ++q)
-                              {
-                                face_out.densities[q] = simulator_access.get_adiabatic_conditions().density(face_in.position[q]);
-                              }
-                          }
-                      }
-
-                    // Compute heat flux through Neumann boundary by integrating the heat flux
-                    if (prescribed_heat_flux)
-                      {
-                        std::vector<Tensor<1,dim>> heat_flux(n_face_q_points);
-                        heat_flux = simulator_access.get_boundary_heat_flux().heat_flux(
-                                      boundary_id,
-                                      face_in,
-                                      face_out,
-                                      fe_face_values.get_normal_vectors()
-                                    );
-
-                        for (unsigned int q=0; q < n_face_q_points; ++q)
-                          {
-                            const double normal_heat_flux = heat_flux[q] * fe_face_values.normal_vector(q);
-                            const double JxW = fe_face_values.JxW(q);
-                            heat_flux_and_area[cell->active_cell_index()][f].first += normal_heat_flux * JxW;
-                          }
-                      }
-
-                    // Compute advective heat flux
-                    if (non_tangential_velocity)
-                      {
-                        for (unsigned int q=0; q<n_face_q_points; ++q)
-                          {
-                            heat_flux_and_area[cell->active_cell_index()][f].first += face_out.densities[q] *
-                                                                                      face_out.specific_heat[q] * face_in.temperature[q] *
-                                                                                      face_in.velocity[q] * fe_face_values.normal_vector(q) *
-                                                                                      fe_face_values.JxW(q);
-                          }
-                      }
-                  }
-            }
-        return heat_flux_and_area;
-      }
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    HeatFluxMap<dim>::execute (TableHandler &)
-    {
-      std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area =
-        internal::compute_heat_flux_through_boundary_faces (*this);
-
-      const auto boundary_ids = this->get_geometry_model().get_used_boundary_indicators();
-      for (const auto &boundary_id: boundary_ids)
-        if (this->get_geometry_model().translate_id_to_symbol_name(boundary_id) == "top" ||
-            this->get_geometry_model().translate_id_to_symbol_name(boundary_id) == "bottom")
-          output_to_file(boundary_id, heat_flux_and_area);
-
-      std::string placeholder_name = this->get_output_directory() + "heat_flux." + Utilities::int_to_string(this->get_timestep_number(), 5);
-      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
-        placeholder_name.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
-
-      return std::pair<std::string,std::string>("Writing heat flux map",
-                                                placeholder_name);
-    }
-
-
-
-    template <int dim>
-    void
-    HeatFluxMap<dim>::output_to_file(const types::boundary_id boundary_id,
-                                     const std::vector<std::vector<std::pair<double, double>>> &heat_flux_and_area)
-    {
-      // get boundary name and avoid spaces for file output
-      std::string boundary_name = this->get_geometry_model().translate_id_to_symbol_name(boundary_id);
-      std::replace(boundary_name.begin(), boundary_name.end(), ' ', '_');
-
-      std::ostringstream output;
-
-      // write the file header. note that we only do so on processor 0
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          output << "# "
-                 << ((dim==2)? "x y" : "x y z")
-                 << " heat_flux_" << boundary_name << std::endl;
-        }
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (const unsigned int f: cell->face_indices())
-            if (cell->at_boundary(f) &&
-                (cell->face(f)->boundary_id() == boundary_id))
-              {
-                // evaluate position of heat flow to write into output file
-                const bool respect_manifold = true;
-                const Point<dim> midpoint_at_surface = cell->face(f)->center(respect_manifold);
-
-                const double flux_density = heat_flux_and_area[cell->active_cell_index()][f].first /
-                                            heat_flux_and_area[cell->active_cell_index()][f].second;
-
-                output << std::setprecision(10)
-                       << midpoint_at_surface
-                       << ' '
-                       << std::setprecision(10)
-                       << flux_density
-                       << std::endl;
-              }
-
-      std::string filename = this->get_output_directory() +
-                             "heat_flux_" + boundary_name + "." +
-                             Utilities::int_to_string(this->get_timestep_number(), 5);
-      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
-        filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
-
-      Utilities::collect_and_write_file_content(filename, output.str(), this->get_mpi_communicator());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace internal
-    {
-#define INSTANTIATE(dim) \
-  template LinearAlgebra::BlockVector compute_dirichlet_boundary_heat_flux_solution_vector (const SimulatorAccess<dim> &simulator_access);
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-
-    ASPECT_REGISTER_POSTPROCESSOR(HeatFluxMap,
-                                  "heat flux map",
-                                  "A postprocessor that computes the heat flux "
-                                  "density across each boundary in outward "
-                                  "direction, i.e., from the domain to the "
-                                  "outside. The heat flux is computed as sum "
-                                  "of advective heat flux and conductive heat "
-                                  "flux through Neumann boundaries, both "
-                                  "computed as integral over the boundary area, "
-                                  "and conductive heat flux through Dirichlet "
-                                  "boundaries, which is computed using the "
-                                  "consistent boundary flux method as described "
-                                  "in ``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
-                                  "The consistent Galerkin FEM for computing "
-                                  "derived boundary quantities in thermal and or "
-                                  "fluids problems. International Journal for "
-                                  "Numerical Methods in Fluids, 7(4), 371-394.''")
-  }
-}
diff --git a/source/postprocess/heat_flux_statistics.cc.bak b/source/postprocess/heat_flux_statistics.cc.bak
deleted file mode 100644
index e1c4110c748..00000000000
--- a/source/postprocess/heat_flux_statistics.cc.bak
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/heat_flux_statistics.h>
-#include <aspect/postprocess/heat_flux_map.h>
-
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    HeatFluxStatistics<dim>::execute (TableHandler &statistics)
-    {
-      std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area =
-        internal::compute_heat_flux_through_boundary_faces (*this);
-
-      std::map<types::boundary_id, double> local_boundary_fluxes;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (const unsigned int f : cell->face_indices())
-            if (cell->at_boundary(f))
-              {
-                const types::boundary_id boundary_indicator
-                  = cell->face(f)->boundary_id();
-                local_boundary_fluxes[boundary_indicator] += heat_flux_and_area[cell->active_cell_index()][f].first;
-              }
-
-      // now communicate to get the global values
-      std::map<types::boundary_id, double> global_boundary_fluxes;
-      {
-        // first collect local values in the same order in which they are listed
-        // in the set of boundary indicators
-        const std::set<types::boundary_id>
-        boundary_indicators
-          = this->get_geometry_model().get_used_boundary_indicators ();
-        std::vector<double> local_values;
-        local_values.reserve(boundary_indicators.size());
-        for (const auto p : boundary_indicators)
-          local_values.emplace_back (local_boundary_fluxes[p]);
-
-        // then collect contributions from all processors
-        std::vector<double> global_values (local_values.size());
-        Utilities::MPI::sum (local_values, this->get_mpi_communicator(), global_values);
-
-        // and now take them apart into the global map again
-        unsigned int index = 0;
-        for (std::set<types::boundary_id>::const_iterator
-             p = boundary_indicators.begin();
-             p != boundary_indicators.end(); ++p, ++index)
-          global_boundary_fluxes[*p] = global_values[index];
-      }
-
-      // now add all of the computed heat fluxes to the statistics object
-      // and create a single string that can be output to the screen
-      std::ostringstream screen_text;
-      unsigned int index = 0;
-      for (std::map<types::boundary_id, double>::const_iterator
-           p = global_boundary_fluxes.begin();
-           p != global_boundary_fluxes.end(); ++p, ++index)
-        {
-          const std::string name = "Outward heat flux through boundary with indicator "
-                                   + Utilities::int_to_string(p->first)
-                                   + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                 .translate_id_to_symbol_name (p->first))
-                                   + " (W)";
-          statistics.add_value (name, p->second);
-
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (name, 8);
-          statistics.set_scientific (name, true);
-
-          // finally have something for the screen
-          screen_text.precision(4);
-          screen_text << p->second << " W"
-                      << (index == global_boundary_fluxes.size()-1 ? "" : ", ");
-        }
-
-      return std::pair<std::string, std::string> ("Heat fluxes through boundary parts:",
-                                                  screen_text.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(HeatFluxStatistics,
-                                  "heat flux statistics",
-                                  "A postprocessor that computes some "
-                                  "statistics about the heat flux "
-                                  "density across each boundary in outward "
-                                  "direction, i.e., from the domain to the "
-                                  "outside. The heat flux is computed as sum "
-                                  "of advective heat flux and conductive heat "
-                                  "flux through Neumann boundaries, both "
-                                  "computed as integral over the boundary area, "
-                                  "and conductive heat flux through Dirichlet "
-                                  "boundaries, which is computed using the "
-                                  "consistent boundary flux method as described "
-                                  "in ``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
-                                  "The consistent Galerkin FEM for computing "
-                                  "derived boundary quantities in thermal and or "
-                                  "fluids problems. International Journal for "
-                                  "Numerical Methods in Fluids, 7(4), 371-394.''"
-                                  "The point-wise heat flux can be obtained from the heat flux map postprocessor, "
-                                  "which outputs the heat flux to a file, or the heat flux map "
-                                  "visualization postprocessor, which outputs the heat flux for "
-                                  "visualization. "
-                                  "\n\n"
-                                  "As stated, this postprocessor computes the \\textit{outbound} heat "
-                                  "flux. If you "
-                                  "are interested in the opposite direction, for example from "
-                                  "the core into the mantle when the domain describes the "
-                                  "mantle, then you need to multiply the result by -1."
-                                  "\n\n"
-                                  ":::{note}\n"
-                                  "In geodynamics, the term ``heat flux'' is often understood "
-                                  "to be the quantity $- k \\nabla T$, which is really a heat "
-                                  "flux \\textit{density}, i.e., a vector-valued field. In contrast "
-                                  "to this, the current postprocessor only computes the integrated "
-                                  "flux over each part of the boundary. Consequently, the units of "
-                                  "the quantity computed here are $W=\\frac{J}{s}$.\n"
-                                  ":::"
-                                  "\n\n"
-                                  "The ``heat flux densities'' postprocessor computes the same "
-                                  "quantity as the one here, but divided by the area of "
-                                  "the surface.")
-  }
-}
diff --git a/source/postprocess/heating_statistics.cc.bak b/source/postprocess/heating_statistics.cc.bak
deleted file mode 100644
index 92d4e91a3a5..00000000000
--- a/source/postprocess/heating_statistics.cc.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/postprocess/heating_statistics.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    HeatingStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the temperature element alone.
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_gradients |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, this->n_compositional_fields());
-      this->get_heating_model_manager().create_additional_material_model_inputs_and_outputs(in, out);
-
-      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-
-      const auto &heating_model_objects = this->get_heating_model_manager().get_active_heating_models();
-      const std::vector<std::string> &heating_model_names = this->get_heating_model_manager().get_active_heating_model_names();
-
-      HeatingModel::HeatingModelOutputs heating_model_outputs(n_q_points, this->n_compositional_fields());
-
-      std::ostringstream output;
-      output.precision(4);
-
-      double average_heating_integral = 0.0;
-      double total_heating_integral = 0.0;
-
-      std::vector<double> local_heating_integrals (heating_model_objects.size());
-      double local_mass = 0.0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-            this->get_material_model().fill_additional_material_model_inputs(in, this->get_solution(), fe_values, this->introspection());
-            this->get_material_model().evaluate(in, out);
-
-            if (this->get_parameters().formulation_temperature_equation
-                == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-              {
-                // Overwrite the density by the reference density coming from the
-                // adiabatic conditions as required by the formulation
-                for (unsigned int q=0; q<n_q_points; ++q)
-                  out.densities[q] = this->get_adiabatic_conditions().density(in.position[q]);
-              }
-            else if (this->get_parameters().formulation_temperature_equation
-                     == Parameters<dim>::Formulation::TemperatureEquation::real_density)
-              {
-                // use real density
-              }
-            else
-              AssertThrow(false, ExcNotImplemented());
-
-            for (unsigned int q=0; q<n_q_points; ++q)
-              local_mass += out.densities[q] * fe_values.JxW(q);
-
-            unsigned int index = 0;
-            for (typename std::list<std::unique_ptr<HeatingModel::Interface<dim>>>::const_iterator
-                 heating_model = heating_model_objects.begin();
-                 heating_model != heating_model_objects.end(); ++heating_model, ++index)
-              {
-                (*heating_model)->evaluate(in, out, heating_model_outputs);
-
-                for (unsigned int q=0; q<n_q_points; ++q)
-                  local_heating_integrals[index] += heating_model_outputs.heating_source_terms[q]
-                                                    * fe_values.JxW(q);
-              }
-          }
-
-      std::vector<double> global_heating_integrals (heating_model_objects.size());
-      double global_mass = 0.0;
-
-      // compute the sum over all processors
-      Utilities::MPI::sum (local_heating_integrals,
-                           this->get_mpi_communicator(),
-                           global_heating_integrals);
-      global_mass = Utilities::MPI::sum (local_mass, this->get_mpi_communicator());
-
-      unsigned int index = 0;
-      for (typename std::list<std::unique_ptr<HeatingModel::Interface<dim>>>::const_iterator
-           heating_model = heating_model_objects.begin();
-           heating_model != heating_model_objects.end(); ++heating_model, ++index)
-        {
-          // finally produce something for the statistics file
-          const std::string name1("Average " + heating_model_names[index] + " rate (W/kg)");
-          statistics.add_value (name1, global_heating_integrals[index]/global_mass);
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (name1, 8);
-          statistics.set_scientific (name1, true);
-
-          const std::string name2("Total " + heating_model_names[index] + " rate (W)");
-          statistics.add_value (name2, global_heating_integrals[index]);
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (name2, 8);
-          statistics.set_scientific (name2, true);
-
-          total_heating_integral += global_heating_integrals[index];
-        }
-
-      average_heating_integral = total_heating_integral/global_mass;
-
-      output << average_heating_integral << " W/kg, "
-             << total_heating_integral << " W";
-
-      return std::pair<std::string, std::string> ("Heating rate (average/total): ",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(HeatingStatistics,
-                                  "heating statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "heating, averaged by volume. ")
-  }
-}
diff --git a/source/postprocess/interface.cc.bak b/source/postprocess/interface.cc.bak
deleted file mode 100644
index 40ae8ab7c28..00000000000
--- a/source/postprocess/interface.cc.bak
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/utilities.h>
-
-#include <typeinfo>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-// ------------------------------ Interface -----------------------------
-
-    template <int dim>
-    std::list<std::string>
-    Interface<dim>::required_other_postprocessors() const
-    {
-      return {};
-    }
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::save (std::map<std::string,std::string> &) const
-    {}
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::load (const std::map<std::string,std::string> &)
-    {}
-
-
-
-// ------------------------------ Manager -----------------------------
-
-
-    template <int dim>
-    std::list<std::pair<std::string,std::string>>
-    Manager<dim>::execute (TableHandler &statistics)
-    {
-      // call the execute() functions of all postprocessor objects we have
-      // here in turns
-      std::list<std::pair<std::string,std::string>> output_list;
-      for (const auto &p : this->plugin_objects)
-        {
-          try
-            {
-              // first call the update() function.
-              p->update();
-
-              // call the execute() function. if it produces any output
-              // then add it to the list
-              std::pair<std::string,std::string> output
-                = p->execute (statistics);
-
-              if (output.first.size() + output.second.size() > 0)
-                output_list.push_back (output);
-            }
-          // postprocessors that throw exceptions usually do not result in
-          // anything good because they result in an unwinding of the stack
-          // and, if only one processor triggers an exception, the
-          // destruction of objects often causes a deadlock. thus, if
-          // an exception is generated, catch it, print an error message,
-          // and abort the program
-          catch (std::exception &exc)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running postprocessor <"
-                        << typeid(*p).name()
-                        << ">: " << std::endl
-                        << exc.what() << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-          catch (...)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running postprocessor <"
-                        << typeid(*p).name()
-                        << ">: " << std::endl;
-              std::cerr << "Unknown exception!" << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-        }
-
-      return  output_list;
-    }
-
-
-// -------------------------------- Deal with registering postprocessors and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // first declare the postprocessors we know about to
-      // choose from
-      prm.enter_subsection("Postprocess");
-      {
-        // construct a string for Patterns::MultipleSelection that
-        // contains the names of all registered postprocessors
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-        prm.declare_entry("List of postprocessors",
-                          "",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma separated list of postprocessor objects that should be run "
-                          "at the end of each time step. Some of these postprocessors will "
-                          "declare their own parameters which may, for example, include that "
-                          "they will actually do something only every so many time steps or "
-                          "years. Alternatively, the text `all' indicates that all available "
-                          "postprocessors should be run after each time step.\n\n"
-                          "The following postprocessors are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-      }
-      prm.leave_subsection();
-
-      // now declare the parameters of each of the registered
-      // postprocessors in turn
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      Assert (std::get<dim>(registered_plugins).plugins != nullptr,
-              ExcMessage ("No postprocessors registered!?"));
-
-      // first find out which postprocessors are requested
-      std::vector<std::string> postprocessor_names;
-      prm.enter_subsection("Postprocess");
-      {
-        postprocessor_names
-          = Utilities::split_string_list(prm.get("List of postprocessors"));
-        AssertThrow(Utilities::has_unique_entries(postprocessor_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Postprocess/List of postprocessors' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-      }
-      prm.leave_subsection();
-
-      // see if 'all' was selected (or is part of the list). if so
-      // simply replace the list with one that contains all names
-      if (std::find (postprocessor_names.begin(),
-                     postprocessor_names.end(),
-                     "all") != postprocessor_names.end())
-        {
-          postprocessor_names.clear();
-          for (typename std::list<typename aspect::internal::Plugins::PluginList<Interface<dim>>::PluginInfo>::const_iterator
-               p = std::get<dim>(registered_plugins).plugins->begin();
-               p != std::get<dim>(registered_plugins).plugins->end(); ++p)
-            postprocessor_names.push_back (std::get<0>(*p));
-        }
-
-      // see if the user specified "global statistics" somewhere; if so, remove
-      // it from the list because we will *always* want to have it and so
-      // whether or not it has been explicitly provided by the user makes no
-      // difference.
-      std::vector<std::string>::iterator new_end
-        = std::remove (postprocessor_names.begin(),
-                       postprocessor_names.end(),
-                       "global statistics");
-      if (new_end != postprocessor_names.end())
-        postprocessor_names.erase (new_end, postprocessor_names.end());
-
-      // in any case, put the global statistics postprocessor at the front:
-      postprocessor_names.insert(postprocessor_names.begin(), "global statistics");
-
-      // then go through the list, create objects and let them parse
-      // their own parameters
-      for (unsigned int name=0; name<postprocessor_names.size(); ++name)
-        {
-          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
-                                          (std::get<dim>(registered_plugins)
-                                           .create_plugin (postprocessor_names[name],
-                                                           "Postprocessor plugins")));
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
-            sim->initialize_simulator (this->get_simulator());
-
-          this->plugin_objects.back()->parse_parameters (prm);
-          this->plugin_objects.back()->initialize ();
-
-          // now see if the newly created postprocessor relies on others. if so,
-          // go through the list of the ones we already have and if the required
-          // ones are new, add them to the end of the list we work through
-          const std::list<std::string> additional_postprocessors
-            = this->plugin_objects.back()->required_other_postprocessors ();
-
-          for (const auto &p : additional_postprocessors)
-            {
-              AssertThrow (Patterns::Selection(std::get<dim>(registered_plugins).get_pattern_of_names ())
-                           .match (p) == true,
-                           ExcMessage ("Postprocessor <" + postprocessor_names[name] +
-                                       "> states that it depends on another postprocessor, <"
-                                       + p +
-                                       ">, but the latter is not a valid name."));
-
-              bool already_present = false;
-              for (const auto &postprocessor_name : postprocessor_names)
-                if (postprocessor_name == p)
-                  {
-                    already_present = true;
-                    break;
-                  }
-
-              if (already_present == false)
-                postprocessor_names.push_back (p);
-            }
-        }
-      Assert (postprocessor_names.size() == this->plugin_objects.size(),
-              ExcInternalError());
-
-      // we now have matching lists 'this->plugin_objects' and 'postprocessor_names'
-      // that define which postprocessors we have. we just need to bring them
-      // into an order so that dependencies run first, and dependents after
-      // them. the algorithm for creating a sorted list for this works as follows:
-      //
-      // while there are postprocessors not yet added to the sorted list:
-      // - go through the list
-      // - if we encounter a postprocessor that has not yet been added yet:
-      //   . if all of its dependencies are in the list, add it to the end
-      //   . if at least one of its dependencies are not yet in the list,
-      //     skip it
-      //
-      // if we go through a loop where we do not add a postprocessor to the list
-      // but there are still ones that haven't been added to the list, then we
-      // have found a cycle in the dependencies and that is clearly a problem
-      std::vector<bool> already_assigned (this->plugin_objects.size(), false);
-      std::vector<std::string> sorted_names;
-      std::list<std::unique_ptr<Interface<dim>>> sorted_postprocessors;
-      while (sorted_names.size() < this->plugin_objects.size())
-        {
-          bool at_least_one_element_added = false;
-
-          {
-            typename std::list<std::unique_ptr<Interface<dim>>>::iterator
-            pp = this->plugin_objects.begin();
-            for (unsigned int i=0; i<postprocessor_names.size(); ++i, ++pp)
-              if (already_assigned[i] == false)
-                {
-                  // for this postprocessor, check if all of its dependencies
-                  // are already in the list
-                  const std::list<std::string> deps = (*pp)->required_other_postprocessors();
-                  bool unmet_dependencies = false;
-                  for (const auto &p : deps)
-                    if (std::find (sorted_names.begin(),
-                                   sorted_names.end(),
-                                   p) == sorted_names.end())
-                      {
-                        unmet_dependencies = true;
-                        break;
-                      }
-
-                  // if we have unmet dependencies, there is nothing we can do
-                  // right now for this postprocessor (but we will come back for it)
-                  //
-                  // if there are none, add this postprocessor. using move semantics
-                  // removes the postprocessor from the 'this->plugin_objects' array,
-                  // which is ok since we will swap the two arrays at the end of the
-                  // function.
-                  if (unmet_dependencies == false)
-                    {
-                      sorted_names.push_back (postprocessor_names[i]);
-                      sorted_postprocessors.emplace_back (std::move(*pp));
-                      already_assigned[i] = true;
-                      at_least_one_element_added = true;
-                    }
-                }
-          }
-
-          // check that we have added at least one element; if not, there is a cycle
-          if (at_least_one_element_added == false)
-            {
-              std::ostringstream out;
-              out << "While sorting postprocessors by their dependencies, "
-                  "ASPECT encountered a cycle in dependencies. The following "
-                  "postprocessors are involved:\n";
-              typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
-              pp = this->plugin_objects.begin();
-              for (unsigned int i=0; i<postprocessor_names.size(); ++i, ++pp)
-                if (already_assigned[i] == false)
-                  {
-                    out << "  " << postprocessor_names[i] << " -> ";
-                    const std::list<std::string> deps = (*pp)->required_other_postprocessors();
-                    for (const auto &p : deps)
-                      out << "'" << p << "' ";
-                    out << std::endl;
-                  }
-              AssertThrow (false, ExcMessage(out.str()));
-            }
-        }
-      Assert (postprocessor_names.size() == sorted_names.size(),
-              ExcInternalError());
-      Assert (sorted_postprocessors.size() == sorted_names.size(),
-              ExcInternalError());
-      Assert (std::find (already_assigned.begin(), already_assigned.end(), false) == already_assigned.end(),
-              ExcInternalError());
-
-      // finally swap the unsorted list with the sorted list and only
-      // keep the latter
-      this->plugin_objects.swap (sorted_postprocessors);
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_postprocessor (const std::string &name,
-                                          const std::string &description,
-                                          void (*declare_parameters_function) (ParameterHandler &),
-                                          std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Postprocessor interface",
-                                                            out);
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<Postprocess::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<Postprocess::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<Postprocess::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<Postprocess::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace Postprocess
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/postprocess/load_balance_statistics.cc.bak b/source/postprocess/load_balance_statistics.cc.bak
deleted file mode 100644
index 2749d974c50..00000000000
--- a/source/postprocess/load_balance_statistics.cc.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/load_balance_statistics.h>
-
-#include <aspect/particle/world.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    LoadBalanceStatistics<dim>::execute (TableHandler &statistics)
-    {
-      const unsigned int locally_owned_active_cells = this->get_triangulation().n_locally_owned_active_cells();
-      const dealii::Utilities::MPI::MinMaxAvg cell_distribution
-        = dealii::Utilities::MPI::min_max_avg(locally_owned_active_cells,
-                                              this->get_mpi_communicator());
-
-      statistics.add_value ("Minimal cells per process",
-                            static_cast<unsigned int>(cell_distribution.min));
-      statistics.add_value ("Maximal cells per process",
-                            static_cast<unsigned int>(cell_distribution.max));
-      statistics.add_value ("Average cells per process",
-                            cell_distribution.avg);
-
-      if (this->n_particle_worlds() > 0)
-        {
-          const unsigned int locally_owned_particles = this->get_particle_world(0).
-                                                       get_particle_handler().n_locally_owned_particles();
-          const dealii::Utilities::MPI::MinMaxAvg particles_per_process =
-            dealii::Utilities::MPI::min_max_avg(locally_owned_particles,this->get_mpi_communicator());
-
-          statistics.add_value ("Minimal particles per process",
-                                static_cast<unsigned int>(particles_per_process.min));
-          statistics.add_value ("Maximal particles per process",
-                                static_cast<unsigned int>(particles_per_process.max));
-          statistics.add_value ("Average particles per process",
-                                particles_per_process.avg);
-
-          const double local_ratio = (locally_owned_active_cells != 0)
-                                     ?
-                                     static_cast<double>(locally_owned_particles)
-                                     / static_cast<double>(locally_owned_active_cells)
-                                     :
-                                     0.0;
-
-          const dealii::Utilities::MPI::MinMaxAvg particle_to_cell_ratio
-            = dealii::Utilities::MPI::min_max_avg(local_ratio,
-                                                  this->get_mpi_communicator());
-
-          statistics.add_value ("Minimal local particle to cell ratio", particle_to_cell_ratio.min);
-          statistics.add_value ("Maximal local particle to cell ratio", particle_to_cell_ratio.max);
-          statistics.add_value ("Average local particle to cell ratio", particle_to_cell_ratio.avg);
-        }
-
-      std::ostringstream output;
-      output.precision(4);
-      output << cell_distribution.min << '/'
-             << cell_distribution.max << '/'
-             << cell_distribution.avg;
-
-      return std::pair<std::string, std::string> ("Cells per process min/max/avg:",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(LoadBalanceStatistics,
-                                  "load balance statistics",
-                                  "A postprocessor that computes statistics about "
-                                  "the distribution of cells, and if present particles "
-                                  "across subdomains. "
-                                  "In particular, it computes maximal, average and "
-                                  "minimal number of cells across all ranks. "
-                                  "If there are particles it also computes the "
-                                  "maximal, average, and minimum number of particles across "
-                                  "all ranks, and maximal, average, and minimal ratio "
-                                  "between local number of particles and local number "
-                                  "of cells across all processes. All of these numbers "
-                                  "can be useful to assess the load balance between "
-                                  "different MPI ranks, as the difference between the "
-                                  "minimal and maximal load should be as small as "
-                                  "possible.")
-  }
-}
diff --git a/source/postprocess/mass_flux_statistics.cc.bak b/source/postprocess/mass_flux_statistics.cc.bak
deleted file mode 100644
index 55f09956ba6..00000000000
--- a/source/postprocess/mass_flux_statistics.cc.bak
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/mass_flux_statistics.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    MassFluxStatistics<dim>::execute (TableHandler &statistics)
-    {
-      const std::string unit = (this->convert_output_to_years())
-                               ?
-                               "kg/yr"
-                               :
-                               "kg/s";
-      const double in_years = (this->convert_output_to_years())
-                              ?
-                              year_in_seconds
-                              :
-                              1.0;
-
-      // create a quadrature formula based on the temperature element alone.
-      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.velocities;
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula,
-                                        update_values            | update_gradients |
-                                        update_normal_vectors    |
-                                        update_quadrature_points | update_JxW_values);
-
-      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-
-      std::map<types::boundary_id, double> local_boundary_fluxes;
-
-      MaterialModel::MaterialModelInputs<dim> in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::density;
-
-      // for every surface face on which it makes sense to compute a
-      // mass flux and that is owned by this processor,
-      // integrate the normal mass flux given by the formula
-      //   j =  \rho * v * n
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (const unsigned int f : cell->face_indices())
-            if (cell->at_boundary(f))
-              {
-                fe_face_values.reinit (cell, f);
-                // Set use_strain_rates to false since we don't need viscosity
-                in.reinit(fe_face_values, cell, this->introspection(), this->get_solution());
-
-                this->get_material_model().evaluate(in, out);
-
-
-                double local_normal_flux = 0;
-                for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                  {
-                    local_normal_flux
-                    +=
-                      out.densities[q]
-                      * (in.velocity[q] * fe_face_values.normal_vector(q))
-                      * fe_face_values.JxW(q);
-                  }
-
-                const types::boundary_id boundary_indicator
-                  = cell->face(f)->boundary_id();
-                local_boundary_fluxes[boundary_indicator] += local_normal_flux * in_years;
-              }
-
-      // now communicate to get the global values
-      std::map<types::boundary_id, double> global_boundary_fluxes;
-      {
-        // first collect local values in the same order in which they are listed
-        // in the set of boundary indicators
-        const std::set<types::boundary_id>
-        boundary_indicators
-          = this->get_geometry_model().get_used_boundary_indicators ();
-        std::vector<double> local_values;
-        local_values.reserve(boundary_indicators.size());
-        for (const auto p : boundary_indicators)
-          local_values.push_back (local_boundary_fluxes[p]);
-
-        // then collect contributions from all processors
-        std::vector<double> global_values (local_values.size());
-        Utilities::MPI::sum (local_values, this->get_mpi_communicator(), global_values);
-
-        // and now take them apart into the global map again
-        unsigned int index = 0;
-        for (std::set<types::boundary_id>::const_iterator
-             p = boundary_indicators.begin();
-             p != boundary_indicators.end(); ++p, ++index)
-          global_boundary_fluxes[*p] = global_values[index];
-      }
-
-      // now add all of the computed mass fluxes to the statistics object
-      // and create a single string that can be output to the screen
-      std::ostringstream screen_text;
-      unsigned int index = 0;
-      for (std::map<types::boundary_id, double>::const_iterator
-           p = global_boundary_fluxes.begin();
-           p != global_boundary_fluxes.end(); ++p, ++index)
-        {
-          const std::string name = "Outward mass flux through boundary with indicator "
-                                   + Utilities::int_to_string(p->first)
-                                   + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                 .translate_id_to_symbol_name (p->first))
-                                   + " (" + unit + ")";
-          statistics.add_value (name, p->second);
-
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (name, 8);
-          statistics.set_scientific (name, true);
-
-          // finally have something for the screen
-          screen_text.precision(4);
-          screen_text << p->second << ' ' << unit
-                      << (index == global_boundary_fluxes.size()-1 ? "" : ", ");
-        }
-
-      return std::pair<std::string, std::string> ("Mass fluxes through boundary parts:",
-                                                  screen_text.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(MassFluxStatistics,
-                                  "mass flux statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the mass flux across boundaries. For each boundary "
-                                  "indicator (see your geometry description for which boundary "
-                                  "indicators are used), the mass flux is computed in outward "
-                                  "direction, i.e., from the domain to the outside, using the "
-                                  "formula $\\int_{\\Gamma_i} \\rho \\mathbf v \\cdot \\mathbf n$ "
-                                  "where $\\Gamma_i$ is the part of the boundary with indicator $i$, "
-                                  "$\\rho$ is the density as reported by the material model, "
-                                  "$\\mathbf v$ is the velocity, and $\\mathbf n$ is the outward normal. "
-                                  "\n\n"
-                                  "As stated, this postprocessor computes the \\textit{outbound} mass "
-                                  "flux. If you "
-                                  "are interested in the opposite direction, for example from "
-                                  "the core into the mantle when the domain describes the "
-                                  "mantle, then you need to multiply the result by -1."
-                                  "\n\n"
-                                  ":::{note}\n"
-                                  "In geodynamics, the term ``mass flux'' is often understood "
-                                  "to be the quantity $\\rho \\mathbf v$, which is really a mass "
-                                  "flux \\textit{density}, i.e., a vector-valued field. In contrast "
-                                  "to this, the current postprocessor only computes the integrated "
-                                  "flux over each part of the boundary. Consequently, the units of "
-                                  "the quantity computed here are $\\frac{kg}{s}$.\n"
-                                  ":::")
-  }
-}
diff --git a/source/postprocess/material_statistics.cc.bak b/source/postprocess/material_statistics.cc.bak
deleted file mode 100644
index 9c7f6157417..00000000000
--- a/source/postprocess/material_statistics.cc.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/material_statistics.h>
-#include <aspect/material_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    MaterialStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the temperature element alone.
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_gradients |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::density | MaterialModel::MaterialProperties::viscosity;
-
-      double local_volume = 0.0;
-      double local_mass = 0.0;
-      double local_viscosity = 0.0;
-
-      // compute the integral quantities by quadrature
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-            this->get_material_model().fill_additional_material_model_inputs(in, this->get_solution(), fe_values, this->introspection());
-            this->get_material_model().evaluate(in, out);
-
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                local_mass += out.densities[q] * fe_values.JxW(q);
-                local_viscosity += out.viscosities[q] * fe_values.JxW(q);
-                local_volume += fe_values.JxW(q);
-              }
-          }
-
-      // compute the sum over all processors
-      const double global_mass = Utilities::MPI::sum (local_mass, this->get_mpi_communicator());
-      const double global_viscosity = Utilities::MPI::sum (local_viscosity, this->get_mpi_communicator());
-      const double global_volume = Utilities::MPI::sum (local_volume, this->get_mpi_communicator());
-      const double average_density = global_mass / global_volume;
-      const double average_viscosity = global_viscosity / global_volume;
-
-      const std::string name1("Average density (kg/m^3)");
-      statistics.add_value (name1, average_density);
-      statistics.set_precision (name1, 8);
-      statistics.set_scientific (name1, true);
-
-      const std::string name2("Average viscosity (Pa s)");
-      statistics.add_value (name2, average_viscosity);
-      statistics.set_precision (name2, 8);
-      statistics.set_scientific (name2, true);
-
-      const std::string name3("Total mass (kg)");
-      statistics.add_value (name3, global_mass);
-      statistics.set_precision (name3, 8);
-      statistics.set_scientific (name3, true);
-
-      std::ostringstream output;
-      output.precision(4);
-
-      output << average_density << " kg/m^3, "
-             << average_viscosity << " Pa s, "
-             << global_mass << " kg";
-
-      return std::pair<std::string, std::string> ("Average density / Average viscosity / Total mass: ",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(MaterialStatistics,
-                                  "material statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the material properties. In particular, it computes the "
-                                  "volume-averages of the density and viscosity, and the "
-                                  "total mass in the model. Specifically, it implements "
-                                  "the following formulas in each time step: "
-                                  "$\\left<\\rho\\right> = \\frac{1}{|\\Omega|} \\int_\\Omega \\rho(\\mathbf x) \\, \\text{d}x$, "
-                                  "$\\left<\\eta\\right> = \\frac{1}{|\\Omega|} \\int_\\Omega \\eta(\\mathbf x) \\, \\text{d}x$, "
-                                  "$M = \\int_\\Omega \\rho(\\mathbf x) \\, \\text{d}x$, "
-                                  "where $|\\Omega|$ is the volume of the domain.")
-  }
-}
diff --git a/source/postprocess/matrix_statistics.cc.bak b/source/postprocess/matrix_statistics.cc.bak
deleted file mode 100644
index 89409b70b32..00000000000
--- a/source/postprocess/matrix_statistics.cc.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/matrix_statistics.h>
-
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-
-
-namespace
-{
-  const std::string
-  get_stats(const aspect::LinearAlgebra::BlockSparseMatrix &matrix,
-            const std::string &matrix_name,
-            const MPI_Comm comm)
-  {
-    std::ostringstream output;
-
-    // convert from bytes into Mb
-    const double mb = 1024*1024;
-    // sum up local matrix memory usage
-    double global_matrix_memory_consumption = dealii::Utilities::MPI::sum(matrix.memory_consumption(),
-                                                                          comm);
-    output << "\nTotal " << matrix_name << " memory consumption: "
-           << std::fixed << std::setprecision(2) << global_matrix_memory_consumption/mb
-           << " MB." << std::endl;
-
-    // output number of nonzero elements in matrix. Do so with 1000s separator
-    // since they are frequently large; this was previously done by using the empty
-    // string locale, but creating std::locale with an empty string caused problems
-    // on some platforms, so the functionality to catch the exception and ignore
-    // is kept here, even though explicitly setting a facet should always work.
-    try
-      {
-        // Imbue the stream with a locale that does the right thing. The
-        // locale is responsible for later deleting the object pointed
-        // to by the last argument (the "facet"), see
-        // https://en.cppreference.com/w/cpp/locale/locale/locale
-        output.imbue(std::locale(std::locale(),
-                                 new aspect::Utilities::ThousandSep));
-      }
-    catch (const std::runtime_error &e)
-      {
-        // If the locale doesn't work, just give up
-      }
-
-
-    output << "Total " << matrix_name << " nnz: "
-           << matrix.n_nonzero_elements() << std::endl;
-
-    // output number of nonzero elements in each matrix block
-    output << matrix_name << " nnz by block: " << std::endl;
-    for (unsigned int i=0; i<matrix.n_block_rows(); ++i)
-      {
-        for (unsigned int j=0; j<matrix.n_block_rows(); ++j)
-          output << std::setw(12) << matrix.block(i,j).n_nonzero_elements();
-        output << std::endl;
-      }
-
-    return output.str();
-  }
-}
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    MatrixStatistics<dim>::execute (TableHandler &)
-    {
-      std::ostringstream output;
-      output << get_stats(this->get_system_matrix(),
-                          "system matrix",
-                          this->get_mpi_communicator());
-      output << get_stats(this->get_system_preconditioner_matrix(),
-                          "system preconditioner matrix",
-                          this->get_mpi_communicator());
-
-      return std::pair<std::string, std::string> ("",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(MatrixStatistics,
-                                  "matrix statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the matrices. "
-                                  "In particular, it outputs total memory consumption, "
-                                  "total non-zero elements, and non-zero elements per "
-                                  "block, for system matrix and system preconditioner matrix.")
-  }
-}
diff --git a/source/postprocess/max_depth_field.cc.bak b/source/postprocess/max_depth_field.cc.bak
deleted file mode 100644
index d0cba1d2a56..00000000000
--- a/source/postprocess/max_depth_field.cc.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-  Copyright (C) 2021 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/max_depth_field.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    MaxDepthField<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the compositional element alone.
-      // be defensive about determining that a compositional field actually exists
-      AssertThrow(this->n_compositional_fields() > 0,
-                  ExcMessage("This postprocessor cannot be used without compositional fields."));
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.compositional_fields;
-
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points);
-
-      std::vector<double> compositional_values(n_q_points);
-      std::vector<Point<dim>> position_values(n_q_points);
-
-      std::vector<double> local_max_depth(this->n_compositional_fields(), std::numeric_limits<double>::lowest());
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-
-            position_values = fe_values.get_quadrature_points();
-
-            for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-              {
-                fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(), compositional_values);
-
-                for (unsigned int q = 0; q < n_q_points; ++q)
-                  {
-                    const double depth = this->get_geometry_model().depth(position_values[q]);
-                    if (compositional_values[q] >= 0.5 && depth > local_max_depth[c])
-                      local_max_depth[c] = depth;
-                  }
-              }
-          }
-
-      // compute the max over all processors
-      std::vector<double> global_max_depth(this->n_compositional_fields());
-      Utilities::MPI::max (local_max_depth,
-                           this->get_mpi_communicator(),
-                           global_max_depth);
-
-      // finally produce something for the statistics file
-      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-        {
-          statistics.add_value("Max depth [m] for composition " + this->introspection().name_for_compositional_index(c),
-                               global_max_depth[c]);
-        }
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-        {
-          const std::string columns[] = {"Max depth [m] for composition " + this->introspection().name_for_compositional_index(c)};
-          for (const auto &col: columns)
-            {
-              statistics.set_precision(col, 8);
-              statistics.set_scientific(col, true);
-            }
-        }
-
-      std::ostringstream output;
-      output.precision(4);
-      for (unsigned int c = 0; c < this->n_compositional_fields(); ++c)
-        {
-          output << global_max_depth[c];
-          if (c + 1 != this->n_compositional_fields())
-            output << " // ";
-        }
-      return std::pair<std::string, std::string>("Compositions max depth [m]:",
-                                                 output.str());
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(MaxDepthField,
-                                  "maximum depth of field",
-                                  "A postprocessor that for each compositional field "
-                                  "outputs the largest depth at which "
-                                  "a quadrature point is found where the field "
-                                  "has a value of 0.5 or larger. For fields that do not "
-                                  "represent materials, but for example track a certain quantity "
-                                  "like strain, this value of 0.5 does not necessarily make sense. ")
-  }
-}
diff --git a/source/postprocess/melt_statistics.cc.bak b/source/postprocess/melt_statistics.cc.bak
deleted file mode 100644
index 22bb2ce3829..00000000000
--- a/source/postprocess/melt_statistics.cc.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/postprocess/melt_statistics.h>
-#include <aspect/melt.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    MeltStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the temperature element alone.
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
-      const unsigned int n_q_points = quadrature_formula.size();
-      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),
-                                                            std::vector<double> (n_q_points));
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_gradients |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
-
-      std::ostringstream output;
-      output.precision(4);
-
-      double local_melt_integral = 0.0;
-      double local_min_melt = std::numeric_limits<double>::max();
-      double local_max_melt = std::numeric_limits<double>::lowest();
-
-      // compute the integral quantities by quadrature
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            // fill material model inputs
-            fe_values.reinit (cell);
-            in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-            // we can only postprocess melt fractions if the material model that is used
-            // in the simulation has implemented them
-            // otherwise, set them to zero
-            std::vector<double> melt_fractions(n_q_points, 0.0);
-            if (MaterialModel::MeltFractionModel<dim>::is_melt_fraction_model(this->get_material_model()))
-              MaterialModel::MeltFractionModel<dim>::as_melt_fraction_model(this->get_material_model())
-              .melt_fractions(in, melt_fractions);
-
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                local_melt_integral += melt_fractions[q] * fe_values.JxW(q);
-                local_min_melt       = std::min(local_min_melt, melt_fractions[q]);
-                local_max_melt       = std::max(local_max_melt, melt_fractions[q]);
-              }
-
-          }
-
-      const double global_melt_integral
-        = Utilities::MPI::sum (local_melt_integral, this->get_mpi_communicator());
-      double global_min_melt = 0;
-      double global_max_melt = 0;
-
-      // now do the reductions that are
-      // min/max operations. do them in
-      // one communication by multiplying
-      // one value by -1
-      {
-        double local_values[2] = { -local_min_melt, local_max_melt };
-        double global_values[2];
-
-        Utilities::MPI::max (local_values, this->get_mpi_communicator(), global_values);
-
-        global_min_melt = -global_values[0];
-        global_max_melt = global_values[1];
-      }
-
-
-      // finally produce something for the statistics file
-      statistics.add_value ("Minimal melt fraction",
-                            global_min_melt);
-      statistics.add_value ("Total melt volume",
-                            global_melt_integral);
-      statistics.add_value ("Maximal melt fraction",
-                            global_max_melt);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      {
-        const char *columns[] = { "Minimal melt fraction",
-                                  "Total melt volume",
-                                  "Maximal melt fraction"
-                                };
-        for (auto &column : columns)
-          {
-            statistics.set_precision (column, 8);
-            statistics.set_scientific (column, true);
-          }
-      }
-
-      output << global_min_melt << ", "
-             << global_melt_integral << ", "
-             << global_max_melt;
-
-      return std::pair<std::string, std::string> ("Melt fraction min/total/max:",
-                                                  output.str());
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(MeltStatistics,
-                                  "melt statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the melt (volume) fraction. If the material model "
-                                  "does not implement a melt fraction function, the output is "
-                                  "set to zero.")
-  }
-}
diff --git a/source/postprocess/memory_statistics.cc.bak b/source/postprocess/memory_statistics.cc.bak
deleted file mode 100644
index 4bab32297b7..00000000000
--- a/source/postprocess/memory_statistics.cc.bak
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/postprocess/memory_statistics.h>
-#include <aspect/simulator.h>
-#include <aspect/stokes_matrix_free.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    MemoryStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // memory consumption:
-      const double mb = 1024*1024; // convert from bytes into mb
-
-      statistics.add_value ("System matrix memory consumption (MB) ", this->get_system_matrix().memory_consumption()/mb);
-      statistics.add_value ("Triangulation memory consumption (MB) ", this->get_triangulation().memory_consumption()/mb);
-      statistics.add_value ("p4est memory consumption (MB) ", this->get_triangulation().memory_consumption_p4est()/mb);
-
-      double dof_handler_mem = this->get_dof_handler().memory_consumption();
-      double constraints_mem = this->get_current_constraints().memory_consumption();
-      if (this->is_stokes_matrix_free())
-        {
-          dof_handler_mem += this->get_stokes_matrix_free().get_dof_handler_v().memory_consumption()
-                             + this->get_stokes_matrix_free().get_dof_handler_p().memory_consumption();
-
-          dof_handler_mem  += this->get_stokes_matrix_free().get_dof_handler_projection().memory_consumption();
-
-          constraints_mem += this->get_stokes_matrix_free().get_constraints_v().memory_consumption()
-                             + this->get_stokes_matrix_free().get_constraints_p().memory_consumption();
-        }
-      statistics.add_value ("DoFHandler memory consumption (MB) ", dof_handler_mem/mb);
-      statistics.add_value ("AffineConstraints<double> memory consumption (MB) ", constraints_mem/mb);
-
-      statistics.add_value ("Solution vector memory consumption (MB) ", this->get_solution().memory_consumption()/mb);
-
-      if (this->is_stokes_matrix_free())
-        {
-          const double mg_transfer_mem = this->get_stokes_matrix_free().get_mg_transfer_A().memory_consumption()
-                                         + this->get_stokes_matrix_free().get_mg_transfer_S().memory_consumption();
-          statistics.add_value ("MGTransfer memory consumption (MB) ", mg_transfer_mem/mb);
-
-          const double cell_data_mem = this->get_stokes_matrix_free().get_cell_data_memory_consumption();
-          statistics.add_value ("Matrix-free cell data memory consumption (MB) ", cell_data_mem/mb);
-        }
-
-      if (output_vmpeak)
-        {
-          // allow disabling of the output because this is not stable in automated tests:
-          dealii::Utilities::System::MemoryStats stats;
-          dealii::Utilities::System::get_memory_stats(stats);
-          const double max_vmpeak = dealii::Utilities::MPI::max(stats.VmPeak/1024.0, this->get_mpi_communicator());
-          statistics.add_value ("Peak virtual memory usage (VmPeak) (MB) ", max_vmpeak);
-        }
-
-      std::ostringstream output;
-      output << std::fixed << std::setprecision(2) << this->get_system_matrix().memory_consumption()/mb << " MB";
-
-      return std::pair<std::string, std::string> ("System matrix memory consumption: ",
-                                                  output.str());
-
-    }
-
-
-
-
-    template <int dim>
-    void
-    MemoryStatistics<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Memory statistics");
-        {
-          prm.declare_entry ("Output peak virtual memory (VmPeak)", "true",
-                             Patterns::Bool(),
-                             "If set to 'true', also output the peak virtual memory "
-                             "usage (computed as the maximum over all processors).");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    MemoryStatistics<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Memory statistics");
-        {
-          output_vmpeak = prm.get_bool ("Output peak virtual memory (VmPeak)");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(MemoryStatistics,
-                                  "memory statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the memory consumption. "
-                                  "In particular, it computes the memory usage of the "
-                                  "system matrix, triangulation, p4est, "
-                                  "DoFHandler, current constraints, solution vector, "
-                                  "and peak virtual memory usage, all in MB. "
-                                  "It also outputs the memory usage of the system "
-                                  "matrix to the screen.")
-  }
-}
diff --git a/source/postprocess/mobility_statistics.cc.bak b/source/postprocess/mobility_statistics.cc.bak
deleted file mode 100644
index f403f11a98c..00000000000
--- a/source/postprocess/mobility_statistics.cc.bak
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/postprocess/mobility_statistics.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/geometry_model/spherical_shell.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    MobilityStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula for the velocity for the volume of cells
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
-
-      // create a quadrature formula for the velocity for the surface of cells
-      const Quadrature<dim-1> &quadrature_formula_face
-        = this->introspection().face_quadratures.velocities;
-      const unsigned int n_q_points_face = quadrature_formula_face.size();
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula_face,
-                                        update_values |
-                                        update_JxW_values |
-                                        update_quadrature_points);
-
-      std::vector<Tensor<1,dim>> surface_velocity_values (n_q_points_face);
-
-      double local_velocity_square_integral = 0;
-      double local_velocity_square_integral_top_boundary = 0;
-      double local_top_boundary_area = 0;
-
-      const std::set<types::boundary_id>
-      boundary_indicators
-        = this->get_geometry_model().get_used_boundary_indicators ();
-      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            // extract velocities
-            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                                                                                        velocity_values);
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                local_velocity_square_integral += velocity_values[q].norm_square() *
-                                                  fe_values.JxW(q);
-              }
-
-            // now for the surface cells only
-            for (const unsigned int f : cell->face_indices())
-              if (cell->face(f)->boundary_id() == top_boundary_id)
-                {
-                  fe_face_values.reinit (cell, f);
-                  // extract velocities
-                  fe_face_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                      surface_velocity_values);
-
-                  // determine the squared velocity on the face
-                  for (unsigned int q = 0; q < n_q_points_face; ++q)
-                    {
-                      const double JxW = fe_face_values.JxW(q);
-                      local_velocity_square_integral_top_boundary += surface_velocity_values[q].norm_square() * JxW;
-                      local_top_boundary_area += JxW;
-                    }
-                }
-          }
-
-      // now communicate to get the global values and convert to rms
-      const double global_velocity_square_integral
-        = Utilities::MPI::sum (local_velocity_square_integral, this->get_mpi_communicator());
-
-      const double global_rms_vel = std::sqrt(global_velocity_square_integral) /
-                                    std::sqrt(this->get_volume());
-
-      const double global_top_velocity_square_integral = Utilities::MPI::sum(local_velocity_square_integral_top_boundary, this->get_mpi_communicator());
-      const double global_top_boundary_area_integral = Utilities::MPI::sum(local_top_boundary_area, this->get_mpi_communicator());
-
-      const double global_top_rms_vel = std::sqrt(global_top_velocity_square_integral) /
-                                        std::sqrt(global_top_boundary_area_integral);
-
-      // now add the computed rms velocities to the statistics object
-      // and create a single string that can be output to the screen
-      const double mobility  = global_top_rms_vel / global_rms_vel;
-      const std::string name_mobility = "Mobility";
-
-      statistics.add_value (name_mobility,
-                            mobility);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      statistics.set_precision (name_mobility, 8);
-      statistics.set_scientific (name_mobility, true);
-
-      std::ostringstream output;
-      output.precision(3);
-      output << mobility;
-
-      return std::pair<std::string, std::string> ("Mobility:",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(MobilityStatistics,
-                                  "mobility statistics",
-                                  "A postprocessor that computes some statistics about mobility "
-                                  "following Tackley (2000) and Lourenco et al. (2020).")
-  }
-}
diff --git a/source/postprocess/particle_count_statistics.cc.bak b/source/postprocess/particle_count_statistics.cc.bak
deleted file mode 100644
index 8b2ca0c952b..00000000000
--- a/source/postprocess/particle_count_statistics.cc.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/particle_count_statistics.h>
-#include <aspect/particle/world.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    ParticleCountStatistics<dim>::execute (TableHandler &statistics)
-    {
-      const Particle::ParticleHandler<dim> &particle_handler =
-        this->get_particle_world(0).get_particle_handler();
-
-      unsigned int local_min_particles = std::numeric_limits<unsigned int>::max();
-      unsigned int local_max_particles = 0;
-      const Particle::types::particle_index global_particles = this->get_particle_world(0).n_global_particles();
-
-      // compute local min/max
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            const unsigned int particles_in_cell = particle_handler.n_particles_in_cell(cell);
-            local_min_particles = std::min(local_min_particles,particles_in_cell);
-            local_max_particles = std::max(local_max_particles,particles_in_cell);
-          }
-
-      // now do the reductions over all processors
-      const unsigned int global_min_particles = Utilities::MPI::min (local_min_particles,
-                                                                     this->get_mpi_communicator());
-      const unsigned int global_max_particles = Utilities::MPI::max (local_max_particles,
-                                                                     this->get_mpi_communicator());
-
-      // finally produce something for the statistics file
-      statistics.add_value ("Minimal particles per cell: ", global_min_particles);
-      statistics.add_value ("Average particles per cell: ", global_particles / this->get_triangulation().n_global_active_cells());
-      statistics.add_value ("Maximal particles per cell: ", global_max_particles);
-
-      std::ostringstream output;
-      output << global_min_particles << ", "
-             << global_particles / this->get_triangulation().n_global_active_cells() << ", "
-             << global_max_particles;
-
-      return std::pair<std::string, std::string> ("Particle count per cell min/avg/max:",
-                                                  output.str());
-    }
-
-
-
-    template <int dim>
-    std::list<std::string>
-    ParticleCountStatistics<dim>::required_other_postprocessors() const
-    {
-      return {"particles"};
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(ParticleCountStatistics,
-                                  "particle count statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the particle distribution, if present in this simulation. "
-                                  "In particular, it computes minimal, average and maximal "
-                                  "values of particles per cell in the global domain.")
-  }
-}
diff --git a/source/postprocess/particles.cc.bak b/source/postprocess/particles.cc.bak
deleted file mode 100644
index 126f6a1f607..00000000000
--- a/source/postprocess/particles.cc.bak
+++ /dev/null
@@ -1,758 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file LICENSE.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/global.h>
-#include <aspect/postprocess/particles.h>
-#include <aspect/particle/world.h>
-#include <aspect/utilities.h>
-
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/text_iarchive.hpp>
-
-#include <cstdio>
-#include <unistd.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace internal
-    {
-      template <int dim>
-      void
-      ParticleOutput<dim>::build_patches(const dealii::Particles::ParticleHandler<dim> &particle_handler,
-                                         const aspect::Particle::Property::ParticlePropertyInformation &property_information,
-                                         const std::vector<std::string> &exclude_output_properties,
-                                         const bool only_group_3d_vectors)
-      {
-        // First store the names of the data fields that should be written
-        dataset_names.reserve(property_information.n_components()+1);
-        dataset_names.emplace_back("id");
-
-        // This is a map from an index for the particle property vector to an index in the output
-        // vector. Values equal 0 indicate a property will not be written, values bigger 0
-        // indicate into which output entry the property value should be written.
-        std::vector<unsigned int> property_index_to_output_index(property_information.n_components(),0);
-
-        if (std::find(exclude_output_properties.begin(),
-                      exclude_output_properties.end(),
-                      "all")
-            == exclude_output_properties.end())
-          {
-            // Start the output index from 1, because 0 is occupied by the "id"
-            unsigned int output_index = 1;
-            for (unsigned int field_index = 0; field_index < property_information.n_fields(); ++field_index)
-              {
-                // Determine some info about the field.
-                const unsigned n_components = property_information.get_components_by_field_index(field_index);
-                const std::string field_name = property_information.get_field_name_by_index(field_index);
-                const unsigned int field_position = property_information.n_fields() == 0
-                                                    ?
-                                                    0
-                                                    :
-                                                    property_information.get_position_by_field_index(field_index);
-
-                // HDF5 only supports 3d vector output, therefore only treat output fields as vector if we
-                // have a dimension of 3 and 3 components.
-                const bool field_is_vector = (only_group_3d_vectors == false
-                                              ?
-                                              n_components == dim
-                                              :
-                                              dim == 3 && n_components == 3);
-
-                // Determine if this field should be excluded, if so, skip it
-                bool exclude_property = false;
-                for (const auto &property : exclude_output_properties)
-                  if (field_name.find(property) != std::string::npos)
-                    {
-                      exclude_property = true;
-                      break;
-                    }
-
-                if (exclude_property == false)
-                  {
-                    // For each component record its name and position in output vector
-                    for (unsigned int component_index=0; component_index<n_components; ++component_index)
-                      {
-                        // If it is a 1D element, or a vector, print just the name, otherwise append the index after an underscore
-                        if ((n_components == 1) || field_is_vector)
-                          dataset_names.push_back(field_name);
-                        else
-                          dataset_names.push_back(field_name + "_" + Utilities::to_string(component_index));
-
-                        property_index_to_output_index[field_position + component_index] = output_index;
-                        ++output_index;
-                      }
-
-                    // If the property has dim components, we treat it as vector
-                    if (n_components == dim)
-                      {
-                        vector_datasets.emplace_back(property_index_to_output_index[field_position],
-                                                     property_index_to_output_index[field_position]+n_components-1,
-                                                     field_name,
-                                                     DataComponentInterpretation::component_is_part_of_vector);
-                      }
-                  }
-              }
-          }
-
-        // Now build the actual patch data
-        patches.resize(particle_handler.n_locally_owned_particles());
-        typename dealii::Particles::ParticleHandler<dim>::particle_iterator particle = particle_handler.begin();
-
-        for (unsigned int i=0; particle != particle_handler.end(); ++particle, ++i)
-          {
-            patches[i].vertices[0] = particle->get_location();
-            patches[i].patch_index = i;
-
-            patches[i].data.reinit(dataset_names.size(),1);
-
-            patches[i].data(0,0) = particle->get_id();
-
-            if (particle->has_properties())
-              {
-                const ArrayView<const double> properties = particle->get_properties();
-
-                for (unsigned int property_index = 0; property_index < properties.size(); ++property_index)
-                  {
-                    if (property_index_to_output_index[property_index] > 0)
-                      patches[i].data(property_index_to_output_index[property_index],0) = properties[property_index];
-                  }
-              }
-          }
-      }
-
-      template <int dim>
-      const std::vector<DataOutBase::Patch<0,dim>> &
-      ParticleOutput<dim>::get_patches () const
-      {
-        return patches;
-      }
-
-      template <int dim>
-      std::vector<std::string>
-      ParticleOutput<dim>::get_dataset_names () const
-      {
-        return dataset_names;
-      }
-
-      template <int dim>
-      std::vector<
-      std::tuple<unsigned int,
-          unsigned int, std::string,
-          DataComponentInterpretation::DataComponentInterpretation>>
-          ParticleOutput<dim>::get_nonscalar_data_ranges () const
-      {
-        return vector_datasets;
-      }
-    }
-
-    template <int dim>
-    Particles<dim>::Particles ()
-      :
-      // the following value is later read from the input file
-      output_interval (0),
-      // initialize this to a nonsensical value; set it to the actual time
-      // the first time around we get to check it
-      last_output_time (std::numeric_limits<double>::quiet_NaN())
-      ,output_file_number (numbers::invalid_unsigned_int),
-      group_files(0),
-      write_in_background_thread(false)
-    {}
-
-
-
-    template <int dim>
-    Particles<dim>::~Particles ()
-    {
-      // make sure a thread that may still be running in the background,
-      // writing data, finishes
-      if (background_thread.joinable())
-        background_thread.join ();
-    }
-
-
-
-    template <int dim>
-    // We need to pass the arguments by value, as this function can be called on a separate thread:
-    void Particles<dim>::writer (const std::string &filename, //NOLINT(performance-unnecessary-value-param)
-                                 const std::string &temporary_output_location, //NOLINT(performance-unnecessary-value-param)
-                                 const std::string &file_contents)
-    {
-      std::string tmp_filename = filename;
-      if (temporary_output_location != "")
-        {
-          tmp_filename = temporary_output_location + "/aspect.tmp.XXXXXX";
-
-          // Create the temporary file; get at the actual filename
-          // by using a C-style string that mkstemp will then overwrite
-          std::vector<char> tmp_filename_x (tmp_filename.size()+1);
-          std::strcpy(tmp_filename_x.data(), tmp_filename.c_str());
-          const int tmp_file_desc = mkstemp(tmp_filename_x.data());
-          tmp_filename = tmp_filename_x.data();
-
-          // If we failed to create the temp file, just write directly to the target file.
-          // We also provide a warning about this fact. There are places where
-          // this fails *on every node*, so we will get a lot of warning messages
-          // into the output; in these cases, just writing multiple pieces to
-          // std::cerr will produce an unreadable mass of text; rather, first
-          // assemble the error message completely, and then output it atomically
-          if (tmp_file_desc == -1)
-            {
-              const std::string x = ("***** WARNING: could not create temporary file <"
-                                     +
-                                     tmp_filename
-                                     +
-                                     ">, will output directly to final location. This may negatively "
-                                     "affect performance. (On processor "
-                                     + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD))
-                                     + ".)\n");
-
-              std::cerr << x << std::flush;
-
-              tmp_filename = filename;
-            }
-          else
-            close(tmp_file_desc);
-        }
-
-      std::ofstream out(tmp_filename);
-
-      AssertThrow (out, ExcMessage(std::string("Trying to write to file <") +
-                                   filename +
-                                   ">, but the file can't be opened!"));
-
-      // now write and then move the tmp file to its final destination
-      // if necessary
-      out << file_contents;
-      out.close ();
-
-      if (tmp_filename != filename)
-        {
-          std::string command = std::string("mv ") + tmp_filename + " " + filename;
-          int error = system(command.c_str());
-
-          AssertThrow(error == 0,
-                      ExcMessage("Could not move " + tmp_filename + " to "
-                                 + filename + ". On processor "
-                                 + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD)) + "."));
-        }
-    }
-
-    template <int dim>
-    void
-    Particles<dim>::write_description_files (const internal::ParticleOutput<dim> &data_out,
-                                             const std::string &solution_file_prefix,
-                                             const std::vector<std::string> &filenames)
-    {
-      const double time_in_years_or_seconds = (this->convert_output_to_years() ?
-                                               this->get_time() / year_in_seconds :
-                                               this->get_time());
-      const std::string pvtu_filename = (solution_file_prefix +
-                                         ".pvtu");
-      std::ofstream pvtu_file (this->get_output_directory() + "particles/" +
-                               pvtu_filename);
-      data_out.write_pvtu_record (pvtu_file, filenames);
-
-      // now also generate a .pvd file that matches simulation
-      // time and corresponding .pvtu record
-      times_and_pvtu_file_names.emplace_back(time_in_years_or_seconds, "particles/"+pvtu_filename);
-
-      const std::string pvd_filename = (this->get_output_directory() + "particles.pvd");
-      std::ofstream pvd_file (pvd_filename);
-
-      DataOutBase::write_pvd_record (pvd_file, times_and_pvtu_file_names);
-
-      // finally, do the same for VisIt via the .visit file for this
-      // time step, as well as for all time steps together
-      const std::string visit_filename = (this->get_output_directory()
-                                          + "particles/"
-                                          + solution_file_prefix
-                                          + ".visit");
-      std::ofstream visit_file (visit_filename);
-
-      DataOutBase::write_visit_record (visit_file, filenames);
-
-      {
-        // the global .visit file needs the relative path because it sits a
-        // directory above
-        std::vector<std::string> filenames_with_path;
-        filenames_with_path.reserve(filenames.size());
-        for (const auto &filename : filenames)
-          {
-            filenames_with_path.push_back("particles/" + filename);
-          }
-
-        output_file_names_by_timestep.push_back (filenames_with_path);
-      }
-
-      std::ofstream global_visit_file (this->get_output_directory() +
-                                       "particles.visit");
-
-      std::vector<std::pair<double, std::vector<std::string>>> times_and_output_file_names;
-      for (unsigned int timestep=0; timestep<times_and_pvtu_file_names.size(); ++timestep)
-        times_and_output_file_names.emplace_back(times_and_pvtu_file_names[timestep].first,
-                                                 output_file_names_by_timestep[timestep]);
-      DataOutBase::write_visit_record (global_visit_file, times_and_output_file_names);
-    }
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    Particles<dim>::execute (TableHandler &statistics)
-    {
-      // if this is the first time we get here, set the last output time
-      // to the current time - output_interval. this makes sure we
-      // always produce data during the first time step
-      if (std::isnan(last_output_time))
-        last_output_time = this->get_time() - output_interval;
-
-      const Particle::World<dim> &world = this->get_particle_world(0);
-
-      statistics.add_value("Number of advected particles",world.n_global_particles());
-
-      // If it's not time to generate an output file
-      // return early with the number of particles that were advected
-      if (this->get_time() < last_output_time + output_interval)
-        return std::make_pair("Number of advected particles:",
-                              Utilities::int_to_string(world.n_global_particles()));
-
-      // If we do not write output
-      // return early with the number of particles that were advected
-      if (output_formats.size() == 0 || output_formats[0] == "none")
-        {
-          // Up the next time we need output. This is relevant to correctly
-          // write output after a restart if the format is changed.
-          set_last_output_time (this->get_time());
-
-          return std::make_pair("Number of advected particles:",
-                                Utilities::int_to_string(world.n_global_particles()));
-        }
-
-      if (output_file_number == numbers::invalid_unsigned_int)
-        output_file_number = 0;
-      else
-        ++output_file_number;
-
-      // Create the particle output
-      const bool output_hdf5 = std::find(output_formats.begin(), output_formats.end(),"hdf5") != output_formats.end();
-      internal::ParticleOutput<dim> data_out;
-      data_out.build_patches(world.get_particle_handler(),
-                             world.get_property_manager().get_data_info(),
-                             exclude_output_properties,
-                             output_hdf5);
-
-      // Now prepare everything for writing the output and choose output format
-      std::string particle_file_prefix = "particles-" + Utilities::int_to_string (output_file_number, 5);
-
-      const double time_in_years_or_seconds = (this->convert_output_to_years() ?
-                                               this->get_time() / year_in_seconds :
-                                               this->get_time());
-
-      for (const auto &output_format : output_formats)
-        {
-          // this case was handled above
-          Assert(output_format != "none", ExcInternalError());
-
-          if (output_format == "hdf5")
-            {
-              const std::string particle_file_name = "particles/" + particle_file_prefix + ".h5";
-              const std::string xdmf_filename = "particles.xdmf";
-
-              // Do not filter redundant values, there are no duplicate particles
-              DataOutBase::DataOutFilter data_filter(DataOutBase::DataOutFilterFlags(false, true));
-
-              data_out.write_filtered_data(data_filter);
-              data_out.write_hdf5_parallel(data_filter,
-                                           this->get_output_directory()+particle_file_name,
-                                           this->get_mpi_communicator());
-
-              const XDMFEntry new_xdmf_entry = data_out.create_xdmf_entry(data_filter,
-                                                                          particle_file_name,
-                                                                          time_in_years_or_seconds,
-                                                                          this->get_mpi_communicator());
-              xdmf_entries.push_back(new_xdmf_entry);
-              data_out.write_xdmf_file(xdmf_entries, this->get_output_directory() + xdmf_filename,
-                                       this->get_mpi_communicator());
-            }
-          else if (output_format == "vtu")
-            {
-              // Write descriptive files (.pvtu,.pvd,.visit) on the root process
-              const int my_id = Utilities::MPI::this_mpi_process(this->get_mpi_communicator());
-
-              if (my_id == 0)
-                {
-                  std::vector<std::string> filenames;
-                  const unsigned int n_processes = Utilities::MPI::n_mpi_processes(this->get_mpi_communicator());
-                  const unsigned int n_files = (group_files == 0) ? n_processes : std::min(group_files,n_processes);
-                  for (unsigned int i=0; i<n_files; ++i)
-                    filenames.push_back (particle_file_prefix
-                                         + "." + Utilities::int_to_string(i, 4)
-                                         + ".vtu");
-                  write_description_files (data_out, particle_file_prefix, filenames);
-                }
-
-              const unsigned int n_processes = Utilities::MPI::n_mpi_processes(this->get_mpi_communicator());
-
-              const unsigned int my_file_id = (group_files == 0
-                                               ?
-                                               my_id
-                                               :
-                                               my_id % group_files);
-              const std::string filename = this->get_output_directory()
-                                           + "particles/"
-                                           + particle_file_prefix
-                                           + "."
-                                           + Utilities::int_to_string (my_file_id, 4)
-                                           + ".vtu";
-
-              // pass time step number and time as metadata into the output file
-              DataOutBase::VtkFlags vtk_flags;
-              vtk_flags.cycle = this->get_timestep_number();
-              vtk_flags.time = time_in_years_or_seconds;
-
-              data_out.set_flags (vtk_flags);
-
-              // Write as many files as processes. For this case we support writing in a
-              // background thread and to a temporary location, so we first write everything
-              // into a string that is written to disk in a writer function
-              if ((group_files == 0) || (group_files >= n_processes))
-                {
-                  // Put the content we want to write into a string object that
-                  // we can then write in the background
-                  std::unique_ptr<std::string> file_contents;
-                  {
-                    std::ostringstream tmp;
-
-                    data_out.write (tmp, DataOutBase::parse_output_format(output_format));
-                    file_contents = std::make_unique<std::string>(tmp.str());
-                  }
-
-                  if (write_in_background_thread)
-                    {
-                      // Wait for all previous write operations to finish, should
-                      // any be still active, ...
-                      if (background_thread.joinable())
-                        background_thread.join ();
-
-                      // ...then continue with writing our own data.
-                      background_thread
-                        = std::thread([ my_filename = filename, // filename is const, so we can not move from it
-                                        my_temporary_output_location = temporary_output_location,
-                                        my_file_contents = std::move(file_contents)]()
-                      {
-                        writer (my_filename, my_temporary_output_location, *my_file_contents);
-                      });
-                    }
-                  else
-                    writer(filename,temporary_output_location,*file_contents);
-                }
-              // Just write one data file in parallel
-              else if (group_files == 1)
-                {
-                  data_out.write_vtu_in_parallel(filename,
-                                                 this->get_mpi_communicator());
-                }
-              // Write as many output files as 'group_files' groups
-              else
-                {
-                  int color = my_id % group_files;
-
-                  MPI_Comm comm;
-                  int ierr = MPI_Comm_split(this->get_mpi_communicator(), color, my_id, &comm);
-                  AssertThrowMPI(ierr);
-
-                  data_out.write_vtu_in_parallel(filename, comm);
-                  ierr = MPI_Comm_free(&comm);
-                  AssertThrowMPI(ierr);
-                }
-            }
-          // Write in a different format than hdf5 or vtu. This case is supported, but is not
-          // optimized for parallel output in that every process will write one file directly
-          // into the output directory. This may or may not affect performance depending on
-          // the model setup and the network file system type.
-          else
-            {
-              const unsigned int myid = Utilities::MPI::this_mpi_process(this->get_mpi_communicator());
-
-              const std::string filename = this->get_output_directory()
-                                           + "particles/"
-                                           + particle_file_prefix
-                                           + "."
-                                           +  Utilities::int_to_string (myid, 4)
-                                           + DataOutBase::default_suffix
-                                           (DataOutBase::parse_output_format(output_format));
-
-              std::ofstream out (filename);
-
-              AssertThrow(out,
-                          ExcMessage("Unable to open file for writing: " + filename +"."));
-
-              data_out.write (out, DataOutBase::parse_output_format(output_format));
-            }
-        }
-
-
-      // up the next time we need output
-      set_last_output_time (this->get_time());
-
-      const std::string particle_output = this->get_output_directory() + "particles/" + particle_file_prefix;
-
-      // record the file base file name in the output file
-      statistics.add_value ("Particle file name",
-                            particle_output);
-      return std::make_pair("Writing particle output:", particle_output);
-    }
-
-
-
-    template <int dim>
-    void
-    Particles<dim>::set_last_output_time (const double current_time)
-    {
-      // if output_interval is positive, then update the last supposed output
-      // time
-      if (output_interval > 0)
-        {
-          // We need to find the last time output was supposed to be written.
-          // this is the last_output_time plus the largest positive multiple
-          // of output_intervals that passed since then. We need to handle the
-          // edge case where last_output_time+output_interval==current_time,
-          // we did an output and std::floor sadly rounds to zero. This is done
-          // by forcing std::floor to round 1.0-eps to 1.0.
-          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
-        }
-    }
-
-
-    template <int dim>
-    template <class Archive>
-    void Particles<dim>::serialize (Archive &ar, const unsigned int)
-    {
-      ar &last_output_time
-      & output_file_number
-      & times_and_pvtu_file_names
-      & output_file_names_by_timestep
-      & xdmf_entries
-      ;
-    }
-
-
-    template <int dim>
-    void
-    Particles<dim>::save (std::map<std::string, std::string> &status_strings) const
-    {
-      std::ostringstream os;
-      aspect::oarchive oa (os);
-
-      this->get_particle_world(0).save(os);
-      oa << (*this);
-
-      status_strings["Particles"] = os.str();
-    }
-
-
-    template <int dim>
-    void
-    Particles<dim>::load (const std::map<std::string, std::string> &status_strings)
-    {
-      // see if something was saved
-      if (status_strings.find("Particles") != status_strings.end())
-        {
-          std::istringstream is (status_strings.find("Particles")->second);
-          aspect::iarchive ia (is);
-
-          // Load the particle world
-          this->get_particle_world(0).load(is);
-
-          ia >> (*this);
-        }
-    }
-
-
-    template <int dim>
-    void
-    Particles<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Particles");
-        {
-          prm.declare_entry ("Time between data output", "1e8",
-                             Patterns::Double (0.),
-                             "The time interval between each generation of "
-                             "output files. A value of zero indicates that "
-                             "output should be generated every time step.\n\n"
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-
-          // now also see about the file format we're supposed to write in
-          // Note: "ascii" is a legacy format used by ASPECT before particle output
-          // in deal.II was implemented. It is nearly identical to the gnuplot format, thus
-          // we now simply replace "ascii" by "gnuplot" should it be selected.
-          prm.declare_entry ("Data output format", "vtu",
-                             Patterns::MultipleSelection (DataOutBase::get_output_format_names ()+"|ascii"),
-                             "A comma separated list of file formats to be used for graphical "
-                             "output. The list of possible output formats that can be given "
-                             "here is documented in the appendix of the manual where the current "
-                             "parameter is described.");
-
-          prm.declare_entry ("Number of grouped files", "16",
-                             Patterns::Integer(0),
-                             "VTU file output supports grouping files from several CPUs "
-                             "into a given number of files using MPI I/O when writing on a parallel "
-                             "filesystem. Select 0 for no grouping. This will disable "
-                             "parallel file output and instead write one file per processor. "
-                             "A value of 1 will generate one big file containing the whole "
-                             "solution, while a larger value will create that many files "
-                             "(at most as many as there are MPI ranks).");
-
-          prm.declare_entry ("Write in background thread", "false",
-                             Patterns::Bool(),
-                             "File operations can potentially take a long time, blocking the "
-                             "progress of the rest of the model run. Setting this variable to "
-                             "`true' moves this process into a background thread, while the "
-                             "rest of the model continues.");
-
-          prm.declare_entry ("Temporary output location", "",
-                             Patterns::Anything(),
-                             "On large clusters it can be advantageous to first write the "
-                             "output to a temporary file on a local file system and later "
-                             "move this file to a network file system. If this variable is "
-                             "set to a non-empty string it will be interpreted as a "
-                             "temporary storage location.");
-
-          prm.declare_entry ("Exclude output properties", "",
-                             Patterns::Anything(),
-                             "A comma separated list of particle properties that should "
-                             "\\textit{not} be output. If this list contains the "
-                             "entry `all', only the id of particles will be provided in "
-                             "graphical output files.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      Particle::World<dim>::declare_parameters(prm);
-    }
-
-
-    template <int dim>
-    void
-    Particles<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Particles");
-        {
-          output_interval = prm.get_double ("Time between data output");
-          if (this->convert_output_to_years())
-            output_interval *= year_in_seconds;
-
-          AssertThrow(this->get_parameters().run_postprocessors_on_nonlinear_iterations == false,
-                      ExcMessage("Postprocessing nonlinear iterations in models with "
-                                 "particles is currently not supported."));
-
-          output_formats   = Utilities::split_string_list(prm.get ("Data output format"));
-          AssertThrow(Utilities::has_unique_entries(output_formats),
-                      ExcMessage("The list of strings for the parameter "
-                                 "'Postprocess/Particles/Data output format' contains entries more than once. "
-                                 "This is not allowed. Please check your parameter file."));
-
-          AssertThrow ((std::find (output_formats.begin(),
-                                   output_formats.end(),
-                                   "none") == output_formats.end())
-                       ||
-                       (output_formats.size() == 1),
-                       ExcMessage ("If you specify 'none' for the parameter \"Data output format\", "
-                                   "then this needs to be the only value given."));
-
-          if (std::find (output_formats.begin(),
-                         output_formats.end(),
-                         "none") == output_formats.end())
-            aspect::Utilities::create_directory (this->get_output_directory() + "particles/",
-                                                 this->get_mpi_communicator(),
-                                                 true);
-
-          // Note: "ascii" is a legacy format used by ASPECT before particle output
-          // in deal.II was implemented. It is nearly identical to the gnuplot format, thus
-          // we simply replace "ascii" by "gnuplot" should it be selected.
-          std::vector<std::string>::iterator output_format =  std::find (output_formats.begin(),
-                                                                         output_formats.end(),
-                                                                         "ascii");
-          if (output_format != output_formats.end())
-            *output_format = "gnuplot";
-
-          group_files     = prm.get_integer("Number of grouped files");
-          write_in_background_thread = prm.get_bool("Write in background thread");
-          temporary_output_location = prm.get("Temporary output location");
-
-          if (temporary_output_location != "")
-            {
-              // Check if a command-processor is available by calling system() with a
-              // null pointer. System is guaranteed to return non-zero if it finds
-              // a terminal and zero if there is none (like on the compute nodes of
-              // some cluster architectures, e.g. IBM BlueGene/Q)
-              AssertThrow(system((char *)nullptr) != 0,
-                          ExcMessage("Usage of a temporary storage location is only supported if "
-                                     "there is a terminal available to move the files to their final location "
-                                     "after writing. The system() command did not succeed in finding such a terminal."));
-            }
-
-          exclude_output_properties = Utilities::split_string_list(prm.get("Exclude output properties"));
-
-          // Never output the integrator properties that are for internal use only
-          exclude_output_properties.emplace_back("internal: integrator properties");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace internal
-    {
-#define INSTANTIATE(dim) \
-  template class ParticleOutput<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-
-    ASPECT_REGISTER_POSTPROCESSOR(Particles,
-                                  "particles",
-                                  "A Postprocessor that creates particles that follow the "
-                                  "velocity field of the simulation. The particles can be generated "
-                                  "and propagated in various ways and they can carry a number of "
-                                  "constant or time-varying properties. The postprocessor can write "
-                                  "output positions and properties of all particles at chosen intervals, "
-                                  "although this is not mandatory. It also allows other parts of the "
-                                  "code to query the particles for information.")
-  }
-}
diff --git a/source/postprocess/point_values.cc.bak b/source/postprocess/point_values.cc.bak
deleted file mode 100644
index 9b3d7401b72..00000000000
--- a/source/postprocess/point_values.cc.bak
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/point_values.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/global.h>
-#include <deal.II/numerics/vector_tools.h>
-
-#include <cmath>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    PointValues<dim>::PointValues ()
-      :
-      // the following value is later read from the input file
-      output_interval (0),
-      // initialize this to a nonsensical value; set it to the actual time
-      // the first time around we get to check it
-      last_output_time (std::numeric_limits<double>::quiet_NaN()),
-      evaluation_points_cartesian (std::vector<Point<dim>>() ),
-      point_values (std::vector<std::pair<double, std::vector<Vector<double>>>>() ),
-      use_natural_coordinates (false)
-    {}
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    PointValues<dim>::execute (TableHandler &)
-    {
-      // if this is the first time we get here, set the next output time
-      // to the current time. this makes sure we always produce data during
-      // the first time step
-      if (std::isnan(last_output_time))
-        last_output_time = this->get_time() - output_interval;
-
-      // see if output is requested at this time
-      if (this->get_time() < last_output_time + output_interval)
-        return {"", ""};
-
-      // evaluate the solution at all of our evaluation points
-      std::vector<Vector<double>>
-      current_point_values (evaluation_points_cartesian.size(),
-                            Vector<double> (this->introspection().n_components));
-
-      for (unsigned int p=0; p<evaluation_points_cartesian.size(); ++p)
-        {
-          // try to evaluate the solution at this point. in parallel, the point
-          // will be on only one processor's owned cells, so the others are
-          // going to throw an exception. make sure at least one processor
-          // finds the given point
-          bool point_found = false;
-
-          try
-            {
-              VectorTools::point_value(this->get_mapping(),
-                                       this->get_dof_handler(),
-                                       this->get_solution(),
-                                       evaluation_points_cartesian[p],
-                                       current_point_values[p]);
-              point_found = true;
-            }
-          catch (const VectorTools::ExcPointNotAvailableHere &)
-            {
-              // ignore
-            }
-
-          // ensure that at least one processor found things
-          const int n_procs = Utilities::MPI::sum (point_found ? 1 : 0, this->get_mpi_communicator());
-          AssertThrow (n_procs > 0,
-                       ExcMessage ("While trying to evaluate the solution at point " +
-                                   Utilities::to_string(evaluation_points_cartesian[p][0]) + ", " +
-                                   Utilities::to_string(evaluation_points_cartesian[p][1]) +
-                                   (dim == 3
-                                    ?
-                                    ", " + Utilities::to_string(evaluation_points_cartesian[p][2])
-                                    :
-                                    "") + "), " +
-                                   "no processors reported that the point lies inside the " +
-                                   "set of cells they own. Are you trying to evaluate the " +
-                                   "solution at a point that lies outside of the domain?"
-                                  ));
-
-          // Reduce all collected values into local Vector
-          Utilities::MPI::sum (current_point_values[p], this->get_mpi_communicator(),
-                               current_point_values[p]);
-
-          // Normalize in cases where points are claimed by multiple processors
-          if (n_procs > 1)
-            current_point_values[p] /= n_procs;
-        }
-
-      // finally push these point values all onto the list we keep
-      point_values.emplace_back (this->get_time(), current_point_values);
-
-      // now write all of the data to the file of choice. start with a pre-amble that
-      // explains the meaning of the various fields
-      const std::string filename = (this->get_output_directory() +
-                                    "point_values.txt");
-
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-
-          std::ofstream f (filename);
-          f << ("# <time> "
-                "<evaluation_point_x> "
-                "<evaluation_point_y> ")
-            << (dim == 3 ? "<evaluation_point_z> " : "")
-            << ("<velocity_x> "
-                "<velocity_y> ")
-            << (dim == 3 ? "<velocity_z> " : "")
-            << "<pressure> <temperature>";
-          for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-            f << " <" << this->introspection().name_for_compositional_index(c) << '>';
-          f << '\n';
-
-          for (const auto &time_point : point_values)
-            {
-              Assert (time_point.second.size() == evaluation_points_cartesian.size(),
-                      ExcInternalError());
-              for (unsigned int i=0; i<evaluation_points_cartesian.size(); ++i)
-                {
-                  f << /* time = */ time_point.first / (this->convert_output_to_years() ? year_in_seconds : 1.)
-                    << ' '
-                    << /* location = */ evaluation_points_cartesian[i] << ' ';
-
-                  for (unsigned int c=0; c<time_point.second[i].size(); ++c)
-                    {
-                      // output a data element. internally, we store all point
-                      // values in the same format in which they were computed,
-                      // but we convert velocities to meters per year if so
-                      // requested
-                      if ((this->introspection().component_masks.velocities[c] == false)
-                          ||
-                          (this->convert_output_to_years() == false))
-                        f << time_point.second[i][c];
-                      else
-                        f << time_point.second[i][c] * year_in_seconds;
-
-                      f << (c != time_point.second[i].size()-1 ? ' ' : '\n');
-                    }
-                }
-
-              // have an empty line between time steps
-              f << '\n';
-            }
-
-          AssertThrow (f, ExcMessage("Writing data to <" + filename +
-                                     "> did not succeed in the `point values' "
-                                     "postprocessor."));
-        }
-
-
-      // Update time
-      set_last_output_time (this->get_time());
-
-      // return what should be printed to the screen. note that we had
-      // just incremented the number, so use the previous value
-      return std::make_pair (std::string ("Writing point values:"),
-                             filename);
-    }
-
-
-    template <int dim>
-    void
-    PointValues<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Point values");
-        {
-          prm.declare_entry ("Time between point values output", "0.",
-                             Patterns::Double (0.),
-                             "The time interval between each generation of "
-                             "point values output. A value of zero indicates "
-                             "that output should be generated in each time step. "
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-          prm.declare_entry("Evaluation points", "",
-                            // a list of points, separated by semicolons; each point has
-                            // exactly 'dim' components/coordinates, separated by commas
-                            Patterns::List (Patterns::List (Patterns::Double(), dim, dim, ","),
-                                            0, Patterns::List::max_int_value, ";"),
-                            "The list of points at which the solution should be evaluated. "
-                            "Points need to be separated by semicolons, and coordinates of "
-                            "each point need to be separated by commas.");
-          prm.declare_entry("Use natural coordinates", "false",
-                            Patterns::Bool (),
-                            "Whether or not the Evaluation points are specified in "
-                            "the natural coordinates of the geometry model, e.g. "
-                            "radius, lon, lat for the chunk model. "
-                            "Currently, natural coordinates for the spherical shell "
-                            "and sphere geometries are not supported. ");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    PointValues<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Point values");
-        {
-          output_interval = prm.get_double ("Time between point values output");
-          if (this->convert_output_to_years())
-            output_interval *= year_in_seconds;
-
-          const std::vector<std::string> point_list
-            = Utilities::split_string_list(prm.get("Evaluation points"), ';');
-
-          std::vector<std::array<double,dim>> evaluation_points;
-
-          for (const auto &p : point_list)
-            {
-              const std::vector<std::string> coordinates
-                = Utilities::split_string_list(p, ',');
-              AssertThrow (coordinates.size() == dim,
-                           ExcMessage ("In setting up the list of evaluation points for the <Point values> "
-                                       "postprocessor, one of the evaluation points reads <"
-                                       + p +
-                                       ">, but this does not correspond to a list of numbers with "
-                                       "as many coordinates as you run your simulation in."));
-
-              std::array<double,dim> point;
-              for (unsigned int d=0; d<dim; ++d)
-                point[d] = Utilities::string_to_double (coordinates[d]);
-              evaluation_points.push_back (point);
-            }
-
-          use_natural_coordinates = prm.get_bool("Use natural coordinates");
-
-          // Convert the vector of coordinate arrays in Cartesian or natural
-          // coordinates to a vector of Point<dim> of Cartesian coordinates.
-          evaluation_points_cartesian.resize(evaluation_points.size());
-          for (unsigned int p=0; p<evaluation_points.size(); ++p)
-            {
-              if (use_natural_coordinates)
-                evaluation_points_cartesian[p] = this->get_geometry_model().natural_to_cartesian_coordinates(evaluation_points[p]);
-              else
-                for (unsigned int i = 0; i < dim; ++i)
-                  evaluation_points_cartesian[p][i] = evaluation_points[p][i];
-            }
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    template <class Archive>
-    void PointValues<dim>::serialize (Archive &ar, const unsigned int)
-    {
-      ar &evaluation_points_cartesian
-      & point_values
-      & last_output_time;
-    }
-
-
-    template <int dim>
-    void
-    PointValues<dim>::save (std::map<std::string, std::string> &status_strings) const
-    {
-      std::ostringstream os;
-      aspect::oarchive oa (os);
-      oa << (*this);
-
-      status_strings["PointValues"] = os.str();
-    }
-
-
-    template <int dim>
-    void
-    PointValues<dim>::load (const std::map<std::string, std::string> &status_strings)
-    {
-      // see if something was saved
-      if (status_strings.find("PointValues") != status_strings.end())
-        {
-          std::istringstream is (status_strings.find("PointValues")->second);
-          aspect::iarchive ia (is);
-          ia >> (*this);
-        }
-    }
-
-
-    template <int dim>
-    void
-    PointValues<dim>::set_last_output_time (const double current_time)
-    {
-      // if output_interval is positive, then set the next output interval to
-      // a positive multiple.
-      if (output_interval > 0)
-        {
-          // We need to find the last time output was supposed to be written.
-          // this is the last_output_time plus the largest positive multiple
-          // of output_intervals that passed since then. We need to handle the
-          // edge case where last_output_time+output_interval==current_time,
-          // we did an output and std::floor sadly rounds to zero. This is done
-          // by forcing std::floor to round 1.0-eps to 1.0.
-          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
-        }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(PointValues,
-                                  "point values",
-                                  "A postprocessor that evaluates the solution (i.e., velocity, pressure, "
-                                  "temperature, and compositional fields along with other fields that "
-                                  "are treated as primary variables) at the end of every time step or "
-                                  "after a user-specified time interval "
-                                  "at a given set of points and then writes this data into the file "
-                                  "<point\\_values.txt> in the output directory. The points at which "
-                                  "the solution should be evaluated are specified in the section "
-                                  "\\texttt{Postprocess/Point values} in the input file."
-                                  "\n\n"
-                                  "In the output file, data is organized as (i) time, (ii) the 2 or 3 "
-                                  "coordinates of the evaluation points, and (iii) followed by the "
-                                  "values of the solution vector at this point. The time is provided "
-                                  "in seconds or, if the "
-                                  "global ``Use years in output instead of seconds'' parameter is "
-                                  "set, in years. In the latter case, the velocity is also converted "
-                                  "to meters/year, instead of meters/second."
-                                  "\n\n"
-                                  ":::{note}\n"
-                                  "Evaluating the solution of a finite element field at "
-                                  "arbitrarily chosen points is an expensive process. Using this "
-                                  "postprocessor will only be efficient if the number of evaluation "
-                                  "points or output times is relatively small. If you need a very large number of "
-                                  "evaluation points, you should consider extracting this "
-                                  "information from the visualization program you use to display "
-                                  "the output of the `visualization' postprocessor.\n"
-                                  ":::")
-  }
-}
diff --git a/source/postprocess/pressure_statistics.cc.bak b/source/postprocess/pressure_statistics.cc.bak
deleted file mode 100644
index df28ec25616..00000000000
--- a/source/postprocess/pressure_statistics.cc.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/pressure_statistics.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    PressureStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the pressure element alone.
-      // we need to compute max and min of the pressure as well, which
-      // may be on the boundary of the cell, so we use an iterated
-      // trapezoidal rule instead of the usual Gauss rule
-      //
-      // iterate it 'degree' times to make sure our evaluation points are
-      // in fact the support points.
-      const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
-                                               this->get_fe().base_element(this->introspection().base_elements.pressure).degree);
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      std::vector<double> pressure_values(n_q_points);
-
-      double local_pressure_integral = 0;
-      double local_min_pressure      = std::numeric_limits<double>::max();
-      double local_max_pressure      = std::numeric_limits<double>::lowest();
-
-      // compute the integral quantities by quadrature. note that compared to
-      // the temperature statistics postprocessor, we can not just loop over
-      // the pressure DoFs because they may be intermingled with the
-      // velocity DoFs if we use a direct solver
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
-                                                                                      pressure_values);
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                const double value = pressure_values[q];
-
-                local_pressure_integral += value*fe_values.JxW(q);
-                local_min_pressure = std::min (local_min_pressure, value);
-                local_max_pressure = std::max (local_max_pressure, value);
-              }
-          }
-
-      const double global_pressure_integral
-        = Utilities::MPI::sum (local_pressure_integral, this->get_mpi_communicator());
-
-      // now do the reductions that are
-      // min/max operations. do them in
-      // one communication by multiplying
-      // one value by -1
-      double global_min_pressure = 0;
-      double global_max_pressure = 0;
-      {
-        double local_values[2] = { -local_min_pressure, local_max_pressure };
-        double global_values[2];
-
-        Utilities::MPI::max (local_values, this->get_mpi_communicator(), global_values);
-
-        global_min_pressure = -global_values[0];
-        global_max_pressure = global_values[1];
-      }
-
-      double global_mean_pressure = global_pressure_integral / this->get_volume();
-      statistics.add_value ("Minimal pressure (Pa)",
-                            global_min_pressure);
-      statistics.add_value ("Average pressure (Pa)",
-                            global_mean_pressure);
-      statistics.add_value ("Maximal pressure (Pa)",
-                            global_max_pressure);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      {
-        const char *columns[] = { "Minimal pressure (Pa)",
-                                  "Average pressure (Pa)",
-                                  "Maximal pressure (Pa)"
-                                };
-        for (auto &column : columns)
-          {
-            statistics.set_precision (column, 8);
-            statistics.set_scientific (column, true);
-          }
-      }
-
-      std::ostringstream output;
-      output.precision(4);
-      output << global_min_pressure << " Pa, "
-             << global_pressure_integral / this->get_volume() << " Pa, "
-             << global_max_pressure << " Pa";
-
-      return std::pair<std::string, std::string> ("Pressure min/avg/max:",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(PressureStatistics,
-                                  "pressure statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the pressure field.")
-  }
-}
diff --git a/source/postprocess/rotation_statistics.cc.bak b/source/postprocess/rotation_statistics.cc.bak
deleted file mode 100644
index d430833fa02..00000000000
--- a/source/postprocess/rotation_statistics.cc.bak
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/rotation_statistics.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/global.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace
-    {
-      void add_scientific_column(const std::string &name,
-                                 const double value,
-                                 TableHandler &statistics)
-      {
-        statistics.add_value(name,value);
-        statistics.set_precision (name, 8);
-        statistics.set_scientific (name, true);
-      }
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    RotationStatistics<dim>::execute (TableHandler &statistics)
-    {
-      RotationProperties<dim> rotation = this->compute_net_angular_momentum(use_constant_density,
-                                                                            this->get_solution(),
-                                                                            false);
-
-      RotationProperties<dim> surface_rotation = this->compute_net_angular_momentum(true,
-                                                                                    this->get_solution(),
-                                                                                    true);
-
-      const std::vector<std::string> names = {"Angular momentum", "Moment of inertia", "Angular velocity", "Surface angular velocity"};
-      std::vector<std::string> units;
-
-      if (this->convert_output_to_years() == true)
-        {
-          units = {"kg*m^2/year", "kg*m^2", "1/year", "1/year"};
-
-          if (dim == 2)
-            {
-              rotation.scalar_angular_momentum *= year_in_seconds;
-              rotation.scalar_rotation *= year_in_seconds;
-              surface_rotation.scalar_rotation *= year_in_seconds;
-            }
-          else if (dim == 3)
-            {
-              rotation.tensor_angular_momentum *= year_in_seconds;
-              rotation.tensor_rotation *= year_in_seconds;
-              surface_rotation.tensor_rotation *= year_in_seconds;
-            }
-        }
-      else
-        {
-          units = {"kg*m^2/s", "kg*m^2", "1/s", "1/s"};
-        }
-
-      std::ostringstream output;
-      output.precision(3);
-
-      if (dim == 2)
-        {
-          add_scientific_column(names[0] + " (" + units[0] +")", rotation.scalar_angular_momentum, statistics);
-          add_scientific_column(names[1] + " (" + units[1] +")", rotation.scalar_moment_of_inertia, statistics);
-          add_scientific_column(names[2] + " (" + units[2] +")", rotation.scalar_rotation, statistics);
-          add_scientific_column(names[3] + " (" + units[3] +")", surface_rotation.scalar_rotation, statistics);
-
-          output << rotation.scalar_angular_momentum << ' ' << units[0] << ", "
-                 << rotation.scalar_moment_of_inertia << ' ' << units[1] << ", "
-                 << rotation.scalar_rotation << ' ' << units[2] << ", "
-                 << surface_rotation.scalar_rotation << ' ' << units[3];
-        }
-      else if (dim == 3)
-        {
-          add_scientific_column(names[0] + " (" + units[0] +")", rotation.tensor_angular_momentum.norm(), statistics);
-
-          const double scalar_moment_of_inertia = (rotation.tensor_moment_of_inertia * rotation.tensor_rotation / rotation.tensor_rotation.norm()).norm();
-
-          if (output_full_tensor == false)
-            {
-              add_scientific_column(names[1] + " (" + units[1] +")", scalar_moment_of_inertia, statistics);
-            }
-          else
-            {
-              add_scientific_column(names[1] + "_xx (" + units[1] +")", rotation.tensor_moment_of_inertia[0][0], statistics);
-              add_scientific_column(names[1] + "_yy (" + units[1] +")", rotation.tensor_moment_of_inertia[1][1], statistics);
-              add_scientific_column(names[1] + "_zz (" + units[1] +")", rotation.tensor_moment_of_inertia[2][2], statistics);
-              add_scientific_column(names[1] + "_xy (" + units[1] +")", rotation.tensor_moment_of_inertia[0][1], statistics);
-              add_scientific_column(names[1] + "_xz (" + units[1] +")", rotation.tensor_moment_of_inertia[0][2], statistics);
-              add_scientific_column(names[1] + "_yz (" + units[1] +")", rotation.tensor_moment_of_inertia[1][2], statistics);
-            }
-
-          add_scientific_column(names[2] + " (" + units[2] +")", rotation.tensor_rotation.norm(), statistics);
-          add_scientific_column(names[3] + " (" + units[3] +")", surface_rotation.tensor_rotation.norm(), statistics);
-
-          output << rotation.tensor_angular_momentum.norm() << ' ' << units[0] << ", "
-                 << scalar_moment_of_inertia << ' ' << units[1] << ", "
-                 << rotation.tensor_rotation.norm() << ' ' << units[2] << ", "
-                 << surface_rotation.tensor_rotation.norm() << ' ' << units[3];
-        }
-
-      return std::pair<std::string, std::string> (names[0]+ ", " + names[1] + ", " + names[2] + ", " + names[3] + ":",
-                                                  output.str());
-    }
-
-
-
-    template <int dim>
-    void
-    RotationStatistics<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Rotation statistics");
-        {
-          prm.declare_entry("Use constant density of one","false",
-                            Patterns::Bool(),
-                            "Whether to use a constant density of one for the computation of the "
-                            "angular momentum and moment of inertia. This is an approximation "
-                            "that assumes that the 'volumetric' rotation is equal to the 'mass' "
-                            "rotation. If this parameter is true this postprocessor computes "
-                            "'net rotation' instead of 'angular momentum'.");
-          prm.declare_entry("Output full moment of inertia tensor","false",
-                            Patterns::Bool(),
-                            "Whether to write the full moment of inertia tensor into the "
-                            "statistics output instead of its norm for the current rotation "
-                            "axis. This is a second-order symmetric tensor with "
-                            "6 components in 3d. In 2d this option has no effect, because "
-                            "the rotation axis is fixed and thus the moment of inertia "
-                            "is always a scalar.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    RotationStatistics<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Rotation statistics");
-        {
-          use_constant_density = prm.get_bool("Use constant density of one");
-          output_full_tensor = prm.get_bool("Output full moment of inertia tensor");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(RotationStatistics,
-                                  "rotation statistics",
-                                  "A postprocessor that computes some statistics about the "
-                                  "rotational velocity of the model (i.e. integrated "
-                                  "net rotation and angular momentum). In 2d we assume the "
-                                  "model to be a cross-section through an infinite domain in "
-                                  "z direction, with a zero z-velocity. Thus, the z-axis is "
-                                  "the only possible rotation axis and both moment of inertia "
-                                  "and angular momentum are scalar instead of tensor "
-                                  "quantities.")
-  }
-}
diff --git a/source/postprocess/sea_level.cc.bak b/source/postprocess/sea_level.cc.bak
deleted file mode 100644
index 4f95c70f2a2..00000000000
--- a/source/postprocess/sea_level.cc.bak
+++ /dev/null
@@ -1,618 +0,0 @@
-/*
-  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-#include <aspect/mesh_deformation/free_surface.h>
-#include <aspect/utilities.h>
-#include <aspect/structured_data.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/postprocess/sea_level.h>
-#include <aspect/postprocess/geoid.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <cmath>
-#include <limits>
-
-// TODO:
-// Include geoid anomaly of surface load.
-// Compute new surface gravity per location, dependent on surface topography and Earth model instead of outer_radius of geometry model.
-// Include option for time-changing ocean geometry, now it is a fixed ocean geometry.
-// The ice height data is now only loaded once from the first time step. It is not constant over time. Implement an option to load data for current timestep (as in boundary traction).
-// Implement iterative structure with solvers.
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    void
-    SeaLevel<dim>::initialize()
-    {
-      Assert(false, ExcNotImplemented(""));
-    }
-
-    template <>
-    void
-    SeaLevel<3>::initialize()
-    {
-      const int dim = 3;
-
-      topography_lookup = std::make_unique<Utilities::StructuredDataLookup<dim-1>>(/* n_components = */1,
-                          /* scale = */1.0);
-      topography_lookup->load_file(data_directory_topography+data_file_name_topography,this->get_mpi_communicator());
-
-      ice_height_lookup = std::make_unique<Utilities::StructuredDataLookup<dim-1>>(/* n_components = */1,
-                          /* scale = */1.0);
-      ice_height_lookup->load_file(data_directory_ice_height+data_file_name_ice_height,this->get_mpi_communicator());
-    }
-
-
-
-    template <int dim>
-    double
-    SeaLevel<dim>::compute_nonuniform_sea_level_change(const Point<dim> &/*position*/) const
-    {
-      Assert(false, ExcNotImplemented());
-      return 0;
-    }
-
-    template <>
-    double
-    SeaLevel<3>::compute_nonuniform_sea_level_change(const Point<3> &position) const
-    {
-      const int dim = 3;
-
-      const Postprocess::Geoid<dim> &geoid =
-        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Geoid<dim>>();
-
-      const double geoid_displacement = geoid.evaluate(position); // TODO: check sign of geoid_displacement
-      const double topography = this->get_geometry_model().height_above_reference_surface(position);
-
-      Point<dim-1> long_colat;
-      const std::array<double,dim> spherical_position = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
-      for (unsigned int d = 1; d < dim; ++d)
-        long_colat[d-1] = spherical_position[d];
-
-      const double topography_init = topography_lookup->get_data(long_colat,0);
-      int ocean_mask = 0;
-      if (topography_init < 0.0)
-        ocean_mask = 1;
-      else
-        ocean_mask = 0;
-
-      const double nonuniform_sea_level_change = (geoid_displacement-topography)*ocean_mask;
-
-      return nonuniform_sea_level_change;
-    }
-
-
-
-    template <int dim>
-    double
-    SeaLevel<dim>::compute_sea_level_offset()
-    {
-      Assert(false, ExcNotImplemented());
-      return 0;
-    }
-
-    template <>
-    double
-    SeaLevel<3>::compute_sea_level_offset()
-    {
-      const int dim = 3;
-
-      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-      const Postprocess::Geoid<dim> &geoid =
-        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Geoid<dim>>();
-
-      const unsigned int quadrature_degree = this->introspection().polynomial_degree.temperature;
-      const QGauss<dim-1> quadrature_formula_face(quadrature_degree);
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula_face,
-                                        update_values |
-                                        update_quadrature_points |
-                                        update_JxW_values);
-
-      double integral_ocean_mask = 0;
-      double integral_ice_height = 0;
-      double integral_topo_geoid = 0;
-
-      // Loop over all of the boundary cells and if one is at the
-      // surface, evaluate the topography/geoid displacement/ocean mask/ice height there.
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          {
-            unsigned int face_idx = numbers::invalid_unsigned_int;
-            bool at_upper_surface = false;
-            {
-              for (const unsigned int f : cell->face_indices())
-                {
-                  if (cell->at_boundary(f) && cell->face(f)->boundary_id() == top_boundary_id)
-                    {
-                      face_idx = f;
-                      at_upper_surface = true;
-                      break;
-                    }
-                }
-
-              // If the cell is not at the top boundary, jump to the next cell.
-              if (at_upper_surface == false)
-                continue;
-            }
-
-            // Focus on the boundary cell's upper face if on the top boundary.
-            fe_face_values.reinit(cell,face_idx);
-
-            // If the cell is at the top boundary, add its contributions to the topography/geoid displacement/ocean mask/ice height storage vectors.
-            for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-              {
-                const Point<dim> current_position = fe_face_values.quadrature_point(q);
-                const double topography = this->get_geometry_model().height_above_reference_surface(current_position);
-
-                const double geoid_displacement = geoid.evaluate(current_position);
-
-                Point<dim-1> long_colat;
-                const std::array<double,dim> spherical_position = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(current_position);
-                for (unsigned int d = 1; d < dim; ++d)
-                  long_colat[d-1] = spherical_position[d];
-
-                const double topography_init = topography_lookup->get_data(long_colat,0);
-                int ocean_mask = 0;
-                if (topography_init < 0.0)
-                  ocean_mask = 1;
-                else
-                  ocean_mask = 0;
-
-                const double ice_height = ice_height_lookup->get_data(long_colat,0);
-
-                // Compute required integrals for the sea level offset.
-                integral_ocean_mask += ocean_mask*fe_face_values.JxW(q);
-                integral_ice_height += ice_height*density_ice*(1-ocean_mask)*fe_face_values.JxW(q);
-                integral_topo_geoid += (geoid_displacement-topography)*ocean_mask*fe_face_values.JxW(q);
-              }
-          }
-
-      integral_ocean_mask = Utilities::MPI::sum (integral_ocean_mask, this->get_mpi_communicator());
-      integral_ice_height = Utilities::MPI::sum (integral_ice_height, this->get_mpi_communicator());
-      integral_topo_geoid = Utilities::MPI::sum (integral_topo_geoid, this->get_mpi_communicator());
-
-      const double sea_level_offset = -1./integral_ocean_mask*(1./density_water*integral_ice_height+integral_topo_geoid);
-
-      return sea_level_offset;
-    }
-
-
-
-    template <int dim>
-    double
-    SeaLevel<dim>::compute_total_surface_pressure(const Point<dim> &/*position*/) const
-    {
-      Assert(false, ExcNotImplemented());
-      return 0;
-    }
-
-    template <>
-    double
-    SeaLevel<3>::compute_total_surface_pressure(const Point<3> &position) const
-    {
-      // This function should be called from the boundary traction.
-      const int dim = 3;
-
-      const double nonuniform_sea_level_change = compute_nonuniform_sea_level_change(position);
-
-      Point<dim-1> long_colat;
-      const std::array<double,dim> spherical_position = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(position);
-      for (unsigned int d = 1; d < dim; ++d)
-        long_colat[d-1] = spherical_position[d];
-      const double ice_height = ice_height_lookup->get_data(long_colat,0);
-
-      const GeometryModel::SphericalShell<dim> &geometry_model = Plugins::get_plugin_as_type<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model());
-
-      // TODO: instead of outer_radius use free surface topography to get different gravity per surface point
-      const double outer_radius = geometry_model.outer_radius();
-      Point<dim> surface_point;
-      surface_point[0] = outer_radius;
-      const double surface_gravity = this->get_gravity_model().gravity_vector(surface_point).norm();
-
-      const double total_surface_pressure = surface_gravity*((nonuniform_sea_level_change+sea_level_offset)*density_water+ice_height*density_ice);
-
-      return total_surface_pressure;
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    SeaLevel<dim>::execute (TableHandler &/*statistics*/)
-    {
-      Assert(false, ExcNotImplemented());
-      return {{""},{""}};
-    }
-
-    template <>
-    std::pair<std::string,std::string>
-    SeaLevel<3>::execute (TableHandler &statistics)
-    {
-      const int dim = 3;
-
-      // Disallow use of the plugin for any other than a 3D spherical shell geometry.
-      AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) && dim == 3,
-                   ExcMessage("The geoid postprocessor is currently only implemented for the 3D spherical shell geometry model."));
-
-      const types::boundary_id top_boundary_id = this->get_geometry_model().translate_symbolic_boundary_name_to_id("top");
-
-      const Postprocess::Geoid<dim> &geoid =
-        this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Geoid<dim>>();
-
-      // Get the sea level offset (constant for every location).
-      sea_level_offset = compute_sea_level_offset();
-
-      // Define a quadrature rule that has points only on the vertices of
-      // a face, so that we can evaluate the solution at the surface
-      // nodes.
-      const QTrapezoid<dim-1> face_corners;
-
-      FEFaceValues<dim> face_vals (this->get_mapping(), this->get_fe(), face_corners, update_quadrature_points);
-
-      // Have a stream into which we write the data. The text stream is then later sent to processor 0.
-      std::ostringstream output_stats;
-      std::ostringstream output_file;
-
-      // Choose stupidly large values for initialization.
-      double local_max_height = -std::numeric_limits<double>::max();
-      double local_min_height = std::numeric_limits<double>::max();
-
-      // Loop over all of the surface cells and save the desired data to the output file.
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          for (const unsigned int face_no : cell->face_indices())
-            if (cell->face(face_no)->at_boundary())
-              {
-                if (cell->face(face_no)->boundary_id() != top_boundary_id)
-                  continue;
-
-                face_vals.reinit(cell, face_no);
-
-                for (unsigned int corner = 0; corner < face_corners.size(); ++corner)
-                  {
-                    const Point<dim> vertex = face_vals.quadrature_point(corner);
-                    const double nonuniform_sea_level_change = compute_nonuniform_sea_level_change(vertex);
-                    const double geoid_displacement = geoid.evaluate(vertex); // TODO: check sign of geoid_displacement
-                    const double topography = this->get_geometry_model().height_above_reference_surface(vertex);
-
-                    Point<dim-1> long_colat;
-                    const std::array<double,dim> spherical_position = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(vertex);
-                    for (unsigned int d = 1; d < dim; ++d)
-                      long_colat[d-1] = spherical_position[d];
-
-                    const double ice_height = ice_height_lookup->get_data(long_colat,0);
-                    const double topography_init = topography_lookup->get_data(long_colat,0);
-                    int ocean_mask = 0;
-                    if (topography_init < 0.0)
-                      ocean_mask = 1;
-                    else
-                      ocean_mask = 0;
-
-                    if (write_to_file)
-                      {
-                        const std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(vertex);
-                        output_file << scoord[0] << ' ' << scoord[1] << ' ' << scoord[2] << ' ' << nonuniform_sea_level_change << ' ' << sea_level_offset << ' ' << geoid_displacement << ' ' << topography << ' ' << ice_height << ' ' << ocean_mask << std::endl;
-                      }
-                    if (nonuniform_sea_level_change > local_max_height)
-                      local_max_height = nonuniform_sea_level_change;
-                    if (nonuniform_sea_level_change < local_min_height)
-                      local_min_height = nonuniform_sea_level_change;
-                  }
-              }
-
-      // Calculate min/max non uniform sea_level change across all processes.
-      const double max_nonuniform_sea_level_change = Utilities::MPI::max(local_max_height, this->get_mpi_communicator());
-      const double min_nonuniform_sea_level_change = Utilities::MPI::min(local_min_height, this->get_mpi_communicator());
-
-      // Write results to statistics file.
-      statistics.add_value ("Minimum non-uniform sea_level change (m)",
-                            min_nonuniform_sea_level_change);
-      statistics.add_value ("Maximum non-uniform sea_level change (m)",
-                            max_nonuniform_sea_level_change);
-      const char *columns[] = { "Minimum non-uniform sea_level change (m)",
-                                "Maximum non-uniform sea_level change (m)"
-                              };
-      for (const auto &column : columns)
-        {
-          statistics.set_precision (column, 8);
-          statistics.set_scientific (column, true);
-        }
-
-      output_stats.precision(4);
-      output_stats << min_nonuniform_sea_level_change << " m, "
-                   << max_nonuniform_sea_level_change << " m";
-
-      // Write the solution to file.
-
-      // If this is the first time we get here, set the last output time
-      // to the current time - output_interval. This makes sure we
-      // always produce data during the first time step.
-      if (std::isnan(last_output_time))
-        {
-          last_output_time = this->get_time() - output_interval;
-        }
-
-      // Just return stats if text output is not required at all or not needed at this time.
-      if (!write_to_file || ((this->get_time() < last_output_time + output_interval)
-                             && (this->get_timestep_number() != 0)))
-        return {"Non-uniform sea level change min/max:", output_stats.str()};
-
-      const unsigned int max_data_length = Utilities::MPI::max (output_file.str().size()+1,
-                                                                this->get_mpi_communicator());
-
-      const unsigned int mpi_tag = 777;
-
-      // On processor 0, collect all of the data the individual processors sent
-      // and concatenate them into one file.
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          std::string filename = this->get_output_directory() +
-                                 "nonuniform_sea_level_change." +
-                                 Utilities::int_to_string(this->get_timestep_number(), 5);
-          if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
-            filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
-
-          std::ofstream file (filename);
-
-          file << "# "
-               << "R phi theta"
-               << " nonuniform_sea_level_change"
-               << " sea_level_offset"
-               << " geoid_displacement"
-               << " topography"
-               << " ice_height"
-               << " ocean_mask" << std::endl;
-
-          // First write out the data we have created locally.
-          file << output_file.str();
-
-          std::string tmp;
-          tmp.resize (max_data_length, '\0');
-
-          // Then loop through all of the other processors and collect
-          // data, then write it to the file.
-          for (unsigned int p=1; p<Utilities::MPI::n_mpi_processes(this->get_mpi_communicator()); ++p)
-            {
-              MPI_Status status;
-              // Get the data. Note that MPI says that an MPI_Recv may receive
-              // less data than the length specified here. Since we have already
-              // determined the maximal message length, we use this feature here
-              // rather than trying to find out the exact message length with
-              // a call to MPI_Probe.
-              const int ierr = MPI_Recv (&tmp[0], max_data_length, MPI_CHAR, p, mpi_tag,
-                                         this->get_mpi_communicator(), &status);
-              AssertThrowMPI(ierr);
-
-              // Output the string. Note that 'tmp' has length max_data_length,
-              // but we only wrote a certain piece of it in the MPI_Recv, ended
-              // by a \0 character. Write only this part by outputting it as a
-              // C string object, rather than as a std::string.
-              file << tmp.c_str();
-            }
-        }
-      else
-        // On other processors, send the data to processor zero. include the \0
-        // character at the end of the string.
-        {
-          output_file << "\0";
-          const int ierr = MPI_Send (&output_file.str()[0], output_file.str().size()+1, MPI_CHAR, 0, mpi_tag,
-                                     this->get_mpi_communicator());
-          AssertThrowMPI(ierr);
-        }
-
-      // if output_interval is positive, then update the last supposed output time
-      if (output_interval > 0)
-        {
-          // We need to find the last time output was supposed to be written.
-          // This is the last_output_time plus the largest positive multiple
-          // of output_intervals that passed since then. We need to handle the
-          // edge case where last_output_time+output_interval==current_time,
-          // we did an output and std::floor sadly rounds to zero. This is done
-          // by forcing std::floor to round 1.0-eps to 1.0.
-          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-          last_output_time = last_output_time + std::floor((this->get_time()-last_output_time)/output_interval*magic) * output_interval/magic;
-        }
-
-      return {"Non-uniform sea level change min/max:", output_stats.str()};
-    }
-
-
-
-    template <int dim>
-    std::list<std::string>
-    SeaLevel<dim>::required_other_postprocessors() const
-    {
-      return {"geoid"};
-    }
-
-
-
-    template <int dim>
-    void
-    SeaLevel<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Sea level");
-        {
-          prm.declare_entry ("Ice density", "931",
-                             Patterns::Double(0.),
-                             "The density of ice [kg/m3]");
-          prm.declare_entry ("Water density", "1000",
-                             Patterns::Double(0.),
-                             "The density of water [kg/m3]");
-
-          prm.declare_entry ("Data directory topography",
-                             "$ASPECT_SOURCE_DIR/data/postprocess/sea-level/",
-                             Patterns::DirectoryName (),
-                             "The name of a directory that contains the topography "
-                             "ascii data. This path may either be absolute (if starting with a "
-                             "`/') or relative to the current directory. The path may also "
-                             "include the special text `$ASPECT_SOURCE_DIR' which will be "
-                             "interpreted as the path in which the ASPECT source files were "
-                             "located when ASPECT was compiled. This interpretation allows, "
-                             "for example, to reference files located in the `data/' subdirectory "
-                             "of ASPECT.");
-          prm.declare_entry ("Data file name topography", "shell_3d_topo_top.0.txt",
-                             Patterns::Anything (),
-                             "The file name of the topography ascii data. For the ascii data, "
-                             "provide file in the same format as described in "
-                             "'ascii data' initial composition plugin." );
-
-          prm.declare_entry ("Data directory ice height",
-                             "$ASPECT_SOURCE_DIR/data/postprocess/sea-level/",
-                             Patterns::DirectoryName (),
-                             "The name of a directory that contains the ice height [m] "
-                             "ascii data. This path may either be absolute (if starting with a "
-                             "`/') or relative to the current directory. The path may also "
-                             "include the special text `$ASPECT_SOURCE_DIR' which will be "
-                             "interpreted as the path in which the ASPECT source files were "
-                             "located when ASPECT was compiled. This interpretation allows, "
-                             "for example, to reference files located in the `data/' subdirectory "
-                             "of ASPECT.");
-          prm.declare_entry ("Data file name ice height", "shell_3d_ice_top.0.txt",
-                             Patterns::Anything (),
-                             "The file name of the ice height ascii data. For the ascii data, "
-                             "provide file in the same format as described in "
-                             "'ascii data' initial composition plugin." );
-
-          prm.declare_entry ("Output to file", "false",
-                             Patterns::List(Patterns::Bool()),
-                             "Whether or not to write sea level to a text file named named "
-                             "'sea_level.NNNNN' in the output directory");
-          prm.declare_entry ("Time between text output", "0.",
-                             Patterns::Double (0.),
-                             "The time interval between each generation of "
-                             "text output files. A value of zero indicates "
-                             "that output should be generated in each time step. "
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    SeaLevel<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Sea level");
-        {
-          density_ice = prm.get_double ("Ice density");
-          density_water = prm.get_double ("Water density");
-          data_directory_topography = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory topography"));
-          data_file_name_topography = prm.get ("Data file name topography");
-          data_directory_ice_height = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory ice height"));
-          data_file_name_ice_height = prm.get ("Data file name ice height");
-          write_to_file = prm.get_bool ("Output to file");
-          output_interval = prm.get_double ("Time between text output");
-          if (this->convert_output_to_years())
-            output_interval *= year_in_seconds;
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    template <class Archive>
-    void SeaLevel<dim>::serialize (Archive &ar, const unsigned int)
-    {
-      ar &last_output_time
-      & sea_level_offset;
-    }
-
-
-    template <int dim>
-    void
-    SeaLevel<dim>::save (std::map<std::string, std::string> &status_strings) const
-    {
-      std::ostringstream os;
-      aspect::oarchive oa (os);
-      oa << (*this);
-
-      status_strings["SeaLevel"] = os.str();
-    }
-
-
-    template <int dim>
-    void
-    SeaLevel<dim>::load (const std::map<std::string, std::string> &status_strings)
-    {
-      // see if something was saved
-      if (status_strings.find("SeaLevel") != status_strings.end())
-        {
-          std::istringstream is (status_strings.find("SeaLevel")->second);
-          aspect::iarchive ia (is);
-          ia >> (*this);
-        }
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(SeaLevel,
-                                  "sea level",
-                                  "A postprocessor that computes the sea level for glacial isostatic adjustment"
-                                  "modeling. When ice melts and enters the ocean, the ocean water needs to be"
-                                  "redistributed in a gravitationally consistent way. With the updated surface"
-                                  "loading (ocean and ice) the free surface deformation needs to be computed"
-                                  "iteratively before moving to the next time step. "
-                                  "A postprocessor intended for use with a deforming top surface. After every step "
-                                  "it computes the sea level based on the topography, ocean basin, ice melt, "
-                                  "perturbed gravitational potential of the Earth model and gravitational potential "
-                                  "of the ice load, relative to a reference datum (initial "
-                                  "radius for a spherical shell geometry model). "
-                                  "The sea level computation is based on \\cite{Martinec2018}. "
-                                  "If 'SeaLevel.Output to file' is set to true, also outputs sea level "
-                                  "into text files named `sea_level.NNNNN' in the output directory, "
-                                  "where NNNNN is the number of the time step. "
-                                  "\n\n"
-                                  "The file format then consists of lines with Euclidean coordinates "
-                                  "followed by the corresponding sea level value. "
-                                  "Sea level is printed/written in meters. ")
-  }
-}
diff --git a/source/postprocess/spherical_velocity_statistics.cc.bak b/source/postprocess/spherical_velocity_statistics.cc.bak
deleted file mode 100644
index e3f6eff709e..00000000000
--- a/source/postprocess/spherical_velocity_statistics.cc.bak
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/postprocess/spherical_velocity_statistics.h>
-#include <aspect/geometry_model/two_merged_chunks.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/global.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    SphericalVelocityStatistics<dim>::execute (TableHandler &statistics)
-    {
-      Assert (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()) ||
-              Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (this->get_geometry_model()) ||
-              Plugins::plugin_type_matches<const GeometryModel::TwoMergedChunks<dim>> (this->get_geometry_model()) ||
-              Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (this->get_geometry_model()),
-              ExcMessage ("This postprocessor can only be used if the geometry "
-                          "is a sphere, spherical shell or chunk."));
-
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
-
-      double local_rad_velocity_square_integral = 0;
-      double local_tan_velocity_square_integral = 0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                                                                                        velocity_values);
-            const std::vector<Point<dim>> &position_point = fe_values.get_quadrature_points();
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                // create unit vector in radial direction
-                const Tensor<1,dim> radial_unit_vector = position_point[q] / position_point[q].norm();
-
-                // compute the radial velocity by multiplying with the radial unit vector
-                const double radial_vel = (velocity_values[q] * radial_unit_vector);
-                local_rad_velocity_square_integral += (radial_vel * radial_vel) *
-                                                      fe_values.JxW(q);
-                // compute the tangential velocity by subtracting the radial velocity from the velocity
-                const Tensor<1,dim> tangential_vel = velocity_values[q] -  radial_vel * radial_unit_vector;
-                local_tan_velocity_square_integral += (tangential_vel * tangential_vel) *
-                                                      fe_values.JxW(q);
-              }
-          }
-      // compute the global sums
-      const double global_rad_velocity_square_integral
-        = Utilities::MPI::sum (local_rad_velocity_square_integral, this->get_mpi_communicator());
-      const double global_tan_velocity_square_integral
-        = Utilities::MPI::sum (local_tan_velocity_square_integral, this->get_mpi_communicator());
-
-      // compute the final output by dividing by the volume over which
-      // we integrated and taking the sqrt
-      const double rad_vrms = std::sqrt(global_rad_velocity_square_integral / this->get_volume());
-      const double tan_vrms = std::sqrt(global_tan_velocity_square_integral / this->get_volume());
-      const double vrms = std::sqrt(rad_vrms*rad_vrms + tan_vrms*tan_vrms);
-
-      if (this->convert_output_to_years() == true)
-        {
-          // make sure that the columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          const char *columns[] = { "Radial RMS velocity (m/yr)",
-                                    "Tangential RMS velocity (m/yr)",
-                                    "Total RMS velocity (m/yr)"
-                                  };
-          statistics.add_value (columns[0],
-                                rad_vrms * year_in_seconds);
-          statistics.add_value (columns[1],
-                                tan_vrms * year_in_seconds);
-          statistics.add_value (columns[2],
-                                vrms * year_in_seconds);
-          for (auto &column : columns)
-            {
-              statistics.set_precision (column, 8);
-              statistics.set_scientific (column, true);
-            }
-        }
-      else
-        {
-          // make sure that the columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          const char *columns[] = { "Radial RMS velocity (m/s)",
-                                    "Tangential RMS velocity (m/s)",
-                                    "Total RMS velocity (m/s)"
-                                  };
-          statistics.add_value (columns[0], rad_vrms);
-          statistics.add_value (columns[1], tan_vrms);
-          statistics.add_value (columns[2], vrms);
-          for (auto &column : columns)
-            {
-              statistics.set_precision (column, 8);
-              statistics.set_scientific (column, true);
-            }
-        }
-
-      std::ostringstream output;
-      output.precision(3);
-      if (this->convert_output_to_years() == true)
-        output << rad_vrms *year_in_seconds
-               << " m/yr, "
-               << tan_vrms *year_in_seconds
-               << " m/yr, "
-               << vrms *year_in_seconds
-               << " m/yr";
-      else
-        output << rad_vrms
-               << " m/s, "
-               << tan_vrms
-               << " m/s, "
-               << vrms
-               << " m/s";
-
-      return std::pair<std::string, std::string> ("Radial RMS, tangential RMS, total RMS velocity:",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(SphericalVelocityStatistics,
-                                  "spherical velocity statistics",
-                                  "A postprocessor that computes radial, tangential and total RMS "
-                                  "velocity.")
-  }
-}
diff --git a/source/postprocess/stokes_residual.cc.bak b/source/postprocess/stokes_residual.cc.bak
deleted file mode 100644
index c3eb41da105..00000000000
--- a/source/postprocess/stokes_residual.cc.bak
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/stokes_residual.h>
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/tria.h>
-#include <deal.II/fe/fe_dgq.h>
-#include <deal.II/dofs/dof_handler.h>
-#include <deal.II/numerics/data_out_stack.h>
-
-
-#include <cmath>
-#include <vector>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    template <class Archive>
-    void StokesResidual<dim>::DataPoint::serialize (Archive &ar,
-                                                    const unsigned int)
-    {
-      ar &time &solve_index &values;
-    }
-
-
-    template <int dim>
-    StokesResidual<dim>::StokesResidual ()
-      = default;
-
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    StokesResidual<dim>::execute (TableHandler &)
-    {
-      // On the root process, write out the file.
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          std::ofstream f(this->get_output_directory() +
-                          "stokes_residuals.txt");
-          f << "# time solveidx residual\n";
-          for (unsigned int i=0; i<entries.size(); ++i)
-            {
-              for (unsigned int j=0; j<entries[i].values.size(); ++j)
-                f << entries[i].time << ' '
-                  << entries[i].solve_index << ' '
-                  << entries[i].values[j] << '\n';
-
-              f << '\n';
-            }
-          f.close();
-        }
-
-      return std::make_pair (std::string ("Writing stokes residuals"),
-                             this->get_output_directory() +
-                             "stokes_residuals.txt");
-    }
-
-    template <int dim>
-    void StokesResidual<dim>::stokes_solver_callback (const SolverControl &solver_control_cheap,
-                                                      const SolverControl &solver_control_expensive)
-    {
-      unsigned int current_solve_index = 0;
-      if (entries.size()>0 && entries.back().time == this->get_time())
-        current_solve_index = entries.back().solve_index+1;
-
-      DataPoint data_point;
-      data_point.time = this->get_time();
-      data_point.solve_index = current_solve_index;
-
-      // If there were cheap iterations add them.
-      if (solver_control_cheap.last_step() != numbers::invalid_unsigned_int)
-        {
-          data_point.values = solver_control_cheap.get_history_data();
-        }
-
-      // If there were expensive iterations add them.
-      if (solver_control_expensive.last_step() != numbers::invalid_unsigned_int)
-        {
-          // If there were cheap iterations add the expensive iterations after a signalling -1.
-          if (data_point.values.size() > 0)
-            data_point.values.push_back(-1.0);
-
-          data_point.values.insert(data_point.values.end(),
-                                   solver_control_expensive.get_history_data().begin(),
-                                   solver_control_expensive.get_history_data().end());
-        }
-
-
-      entries.push_back(data_point);
-    }
-
-    template <int dim>
-    void
-    StokesResidual<dim>::initialize ()
-    {
-      this->get_signals().post_stokes_solver.connect(
-        [&](const SimulatorAccess<dim> &,
-            const unsigned int /*number_S_iterations*/,
-            const unsigned int /*number_A_iterations*/,
-            const SolverControl &solver_control_cheap,
-            const SolverControl &solver_control_expensive)
-      {
-        this->stokes_solver_callback(solver_control_cheap,solver_control_expensive);
-      });
-    }
-
-    template <int dim>
-    template <class Archive>
-    void StokesResidual<dim>::serialize (Archive &ar, const unsigned int)
-    {
-      ar &entries;
-    }
-
-
-    template <int dim>
-    void
-    StokesResidual<dim>::save (std::map<std::string, std::string> &status_strings) const
-    {
-      std::ostringstream os;
-      aspect::oarchive oa (os);
-      oa << (*this);
-
-      status_strings["StokesResidual"] = os.str();
-    }
-
-
-    template <int dim>
-    void
-    StokesResidual<dim>::load (const std::map<std::string, std::string> &status_strings)
-    {
-      // see if something was saved
-      if (status_strings.find("StokesResidual") != status_strings.end())
-        {
-          std::istringstream is (status_strings.find("StokesResidual")->second);
-          aspect::iarchive ia (is);
-          ia >> (*this);
-        }
-    }
-
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(StokesResidual,
-                                  "Stokes residual",
-                                  "A postprocessor that outputs the Stokes residuals during the iterative solver algorithm into a file stokes_residuals.txt in the output directory.")
-  }
-}
diff --git a/source/postprocess/temperature_statistics.cc.bak b/source/postprocess/temperature_statistics.cc.bak
deleted file mode 100644
index ed9f178853b..00000000000
--- a/source/postprocess/temperature_statistics.cc.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/temperature_statistics.h>
-#include <aspect/boundary_temperature/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    TemperatureStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula based on the temperature element alone.
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      std::vector<double> temperature_values(n_q_points);
-
-      double local_temperature_integral = 0;
-
-      // compute the integral quantities by quadrature
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
-                                                                                         temperature_values);
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                local_temperature_integral += temperature_values[q]*fe_values.JxW(q);
-              }
-          }
-
-      // compute min/max by simply
-      // looping over the elements of the
-      // solution vector. the reason is
-      // that minimum and maximum are
-      // usually attained at the
-      // boundary, and so taking their
-      // values at Gauss quadrature
-      // points gives an inaccurate
-      // picture of their true values
-      double local_min_temperature = std::numeric_limits<double>::max();
-      double local_max_temperature = std::numeric_limits<double>::lowest();
-      const unsigned int temperature_block = this->introspection().block_indices.temperature;
-      IndexSet range = this->get_solution().block(temperature_block).locally_owned_elements();
-      for (unsigned int i=0; i<range.n_elements(); ++i)
-        {
-          const unsigned int idx = range.nth_index_in_set(i);
-          const double val =  this->get_solution().block(temperature_block)(idx);
-
-          local_min_temperature = std::min<double> (local_min_temperature, val);
-          local_max_temperature = std::max<double> (local_max_temperature, val);
-        }
-
-      const double global_temperature_integral
-        = Utilities::MPI::sum (local_temperature_integral, this->get_mpi_communicator());
-      double global_min_temperature = 0;
-      double global_max_temperature = 0;
-
-      // now do the reductions that are
-      // min/max operations. do them in
-      // one communication by multiplying
-      // one value by -1
-      {
-        double local_values[2] = { -local_min_temperature, local_max_temperature };
-        double global_values[2];
-
-        Utilities::MPI::max (local_values, this->get_mpi_communicator(), global_values);
-
-        global_min_temperature = -global_values[0];
-        global_max_temperature = global_values[1];
-      }
-
-      double global_mean_temperature = global_temperature_integral / this->get_volume();
-      statistics.add_value ("Minimal temperature (K)",
-                            global_min_temperature);
-      statistics.add_value ("Average temperature (K)",
-                            global_mean_temperature);
-      statistics.add_value ("Maximal temperature (K)",
-                            global_max_temperature);
-      if ((this->get_fixed_temperature_boundary_indicators().size() > 0)
-          &&
-          (this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators())
-           !=
-           this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators())))
-        statistics.add_value ("Average nondimensional temperature (K)",
-                              (global_mean_temperature - global_min_temperature) /
-                              (this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators())
-                               -
-                               this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators())));
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      {
-        const char *columns[] = { "Minimal temperature (K)",
-                                  "Average temperature (K)",
-                                  "Maximal temperature (K)"
-                                };
-        for (auto &column : columns)
-          {
-            statistics.set_precision (column, 8);
-            statistics.set_scientific (column, true);
-          }
-
-        if ((this->get_fixed_temperature_boundary_indicators().size() > 0)
-            &&
-            (this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators())
-             !=
-             this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators())))
-          {
-            statistics.set_precision ("Average nondimensional temperature (K)", 8);
-            statistics.set_scientific ("Average nondimensional temperature (K)", true);
-          }
-      }
-
-      std::ostringstream output;
-      output.precision(4);
-      output << global_min_temperature << " K, "
-             << global_temperature_integral / this->get_volume() << " K, "
-             << global_max_temperature << " K";
-
-      return std::pair<std::string, std::string> ("Temperature min/avg/max:",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(TemperatureStatistics,
-                                  "temperature statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the temperature field.")
-  }
-}
diff --git a/source/postprocess/topography.cc.bak b/source/postprocess/topography.cc.bak
deleted file mode 100644
index 3fe13e569f9..00000000000
--- a/source/postprocess/topography.cc.bak
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/topography.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <cmath>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    Topography<dim>::execute (TableHandler &statistics)
-    {
-      //Disallow use of the plugin with sphere geometry model
-      AssertThrow(!Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>>(this->get_geometry_model()),
-                  ExcMessage("Topography postprocessor is not yet implemented "
-                             "for the sphere geometry model. "
-                             "Consider using a box, spherical shell, or chunk.") );
-
-      const types::boundary_id relevant_boundary = this->get_geometry_model().translate_symbolic_boundary_name_to_id ("top");
-
-      // Define a quadrature rule that has points only on the vertices of
-      // a face, so that we can evaluate the solution at the surface
-      // nodes.
-      const QTrapezoid<dim-1> face_corners;
-      FEFaceValues<dim> face_vals (this->get_mapping(), this->get_fe(), face_corners, update_quadrature_points);
-
-      // have a stream into which we write the data. the text stream is then
-      // later sent to processor 0
-      std::ostringstream output_stats;
-      std::ostringstream output_file;
-
-      // On processor 0, write the file header
-      if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-        {
-          output_file << "# "
-                      << ((dim==2)? "x y" : "x y z")
-                      << " topography" << std::endl;
-        }
-
-      // Choose stupidly large values for initialization
-      double local_max_height = std::numeric_limits<double>::lowest();
-      double local_min_height = std::numeric_limits<double>::max();
-
-      // loop over all of the surface cells and save the elevation to stored_value
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned() && cell->at_boundary())
-          for (const unsigned int face_no : cell->face_indices())
-            if (cell->face(face_no)->at_boundary())
-              {
-                if ( cell->face(face_no)->boundary_id() != relevant_boundary)
-                  continue;
-
-                face_vals.reinit( cell, face_no);
-
-                for (unsigned int corner = 0; corner < face_corners.size(); ++corner)
-                  {
-                    const Point<dim> vertex = face_vals.quadrature_point(corner);
-                    const double elevation = this->get_geometry_model().height_above_reference_surface(vertex);
-                    if (write_to_file)
-                      output_file << vertex << ' '<< elevation << std::endl;
-                    if ( elevation > local_max_height)
-                      local_max_height = elevation;
-                    if ( elevation < local_min_height)
-                      local_min_height = elevation;
-                  }
-              }
-
-      //Calculate min/max topography across all processes
-      const double max_topography = Utilities::MPI::max(local_max_height, this->get_mpi_communicator());
-      const double min_topography = Utilities::MPI::min(local_min_height, this->get_mpi_communicator());
-
-      //Write results to statistics file
-      statistics.add_value ("Minimum topography (m)",
-                            min_topography);
-      statistics.add_value ("Maximum topography (m)",
-                            max_topography);
-      const char *columns[] = { "Minimum topography (m)",
-                                "Maximum topography (m)"
-                              };
-      for (auto &column : columns)
-        {
-          statistics.set_precision (column, 8);
-          statistics.set_scientific (column, true);
-        }
-
-      output_stats.precision(4);
-      output_stats << min_topography << " m, "
-                   << max_topography << " m";
-
-      // Write the solution to file
-
-      // if this is the first time we get here, set the last output time
-      // to the current time - output_interval. this makes sure we
-      // always produce data during the first time step
-      if (std::isnan(last_output_time))
-        {
-          last_output_time = this->get_time() - output_interval;
-        }
-
-      // Just return stats if text output is not required at all or not needed at this time
-      if (!write_to_file || ((this->get_time() < last_output_time + output_interval)
-                             && (this->get_timestep_number() != 0)))
-        return std::pair<std::string, std::string> ("Topography min/max:",
-                                                    output_stats.str());
-
-      std::string filename = this->get_output_directory() +
-                             "topography." +
-                             Utilities::int_to_string(this->get_timestep_number(), 5);
-      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
-        filename.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
-
-      Utilities::collect_and_write_file_content(filename,
-                                                output_file.str(),
-                                                this->get_mpi_communicator());
-
-      // if output_interval is positive, then update the last supposed output
-      // time
-      if (output_interval > 0)
-        {
-          // We need to find the last time output was supposed to be written.
-          // this is the last_output_time plus the largest positive multiple
-          // of output_intervals that passed since then. We need to handle the
-          // edge case where last_output_time+output_interval==current_time,
-          // we did an output and std::floor sadly rounds to zero. This is done
-          // by forcing std::floor to round 1.0-eps to 1.0.
-          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-          last_output_time = last_output_time + std::floor((this->get_time()-last_output_time)/output_interval*magic) * output_interval/magic;
-        }
-
-      return std::pair<std::string, std::string> ("Topography min/max:",
-                                                  output_stats.str());
-    }
-
-    template <int dim>
-    void
-    Topography<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Topography");
-        {
-          prm.declare_entry ("Output to file", "false",
-                             Patterns::Bool(),
-                             "Whether or not to write topography to a text file named named "
-                             "'topography.NNNNN' in the output directory");
-
-          prm.declare_entry ("Time between text output", "0.",
-                             Patterns::Double (0.),
-                             "The time interval between each generation of "
-                             "text output files. A value of zero indicates "
-                             "that output should be generated in each time step. "
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Topography<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Topography");
-        {
-          write_to_file        = prm.get_bool ("Output to file");
-          output_interval = prm.get_double ("Time between text output");
-          if (this->convert_output_to_years())
-            output_interval *= year_in_seconds;
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(Topography,
-                                  "topography",
-                                  "A postprocessor intended for use with a deforming top surface.  After every step "
-                                  "it loops over all the vertices on the top surface and determines the "
-                                  "maximum and minimum topography relative to a reference datum (initial "
-                                  "box height for a box geometry model or initial radius for a "
-                                  "sphere/spherical shell geometry model). "
-                                  "If 'Topography.Output to file' is set to true, also outputs topography "
-                                  "into text files named `topography.NNNNN' in the output directory, "
-                                  "where NNNNN is the number of the time step.\n"
-                                  "The file format then consists of lines with Euclidean coordinates "
-                                  "followed by the corresponding topography value."
-                                  "Topography is printed/written in meters."
-                                  "\n\n"
-                                  "It is worth comparing this postprocessor with the "
-                                  "visualization postprocessor called ``surface elevation''. The latter is "
-                                  "used to *visualize* the surface elevation in graphical form, by "
-                                  "outputting it into the same files that the solution and other "
-                                  "postprocessed variables are written, to then be used for "
-                                  "visualization using programs such as VisIt or Paraview. In "
-                                  "contrast, the current postprocessor generates the same *kind* "
-                                  "of information, but instead writes it as a point cloud that "
-                                  "can then more easily be processed using tools other "
-                                  "than visualization programs.")
-  }
-}
diff --git a/source/postprocess/velocity_boundary_statistics.cc.bak b/source/postprocess/velocity_boundary_statistics.cc.bak
deleted file mode 100644
index aa68fce50ee..00000000000
--- a/source/postprocess/velocity_boundary_statistics.cc.bak
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/postprocess/velocity_boundary_statistics.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    VelocityBoundaryStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // create a quadrature formula for the velocity.
-      const Quadrature<dim-1> &quadrature_formula = this->introspection().face_quadratures.velocities;
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula,
-                                        update_values |
-                                        update_JxW_values |
-                                        update_quadrature_points);
-
-      std::vector<Tensor<1,dim>> velocities (fe_face_values.n_quadrature_points);
-
-      std::map<types::boundary_id, double> local_max_vel;
-      std::map<types::boundary_id, double> local_min_vel;
-      std::map<types::boundary_id, double> local_velocity_square_integral;
-      std::map<types::boundary_id, double> local_boundary_area;
-
-      const std::set<types::boundary_id>
-      boundary_indicators
-        = this->get_geometry_model().get_used_boundary_indicators ();
-      for (const auto p : boundary_indicators)
-        {
-          local_max_vel[p] = std::numeric_limits<double>::lowest();
-          local_min_vel[p] = std::numeric_limits<double>::max();
-        }
-
-      // for every surface face that is part of a geometry boundary
-      // and that is owned by this processor,
-      // compute the maximum, minimum, and squared*area velocity magnitude,
-      // and the face area.
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (const unsigned int f : cell->face_indices())
-            if (cell->face(f)->at_boundary())
-              {
-                fe_face_values.reinit (cell, f);
-                // extract velocities
-                fe_face_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                    velocities);
-                // determine the max, min, and squared velocity on the face
-                // also determine the face area
-                double local_max = std::numeric_limits<double>::lowest();
-                double local_min = std::numeric_limits<double>::max();
-                double local_sqvel = 0.0;
-                double local_fe_face_area = 0.0;
-                for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                  {
-                    const double vel_mag = velocities[q].norm();
-                    local_max = std::max(vel_mag,
-                                         local_max);
-                    local_min = std::min(vel_mag,
-                                         local_min);
-                    local_sqvel += ((vel_mag * vel_mag) * fe_face_values.JxW(q));
-                    local_fe_face_area += fe_face_values.JxW(q);
-                  }
-
-                // then merge them with the min/max/squared velocities
-                // and face areas we found for other faces with the same boundary indicator
-                const types::boundary_id boundary_indicator
-                  = cell->face(f)->boundary_id();
-
-                local_max_vel[boundary_indicator] = std::max(local_max,
-                                                             local_max_vel[boundary_indicator]);
-                local_min_vel[boundary_indicator] = std::min(local_min,
-                                                             local_min_vel[boundary_indicator]);
-                local_velocity_square_integral[boundary_indicator] += local_sqvel;
-                local_boundary_area[boundary_indicator] += local_fe_face_area;
-              }
-
-      // now communicate to get the global values
-      std::map<types::boundary_id, double> global_max_vel;
-      std::map<types::boundary_id, double> global_min_vel;
-      std::map<types::boundary_id, double> global_rms_vel;
-      {
-        // first collect local values in the same order in which they are listed
-        // in the set of boundary indicators
-        std::vector<double> local_max_values;
-        std::vector<double> local_min_values;
-        std::vector<double> local_velocity_square_integral_values;
-        std::vector<double> local_boundary_area_values;
-
-        for (const auto boundary_id : boundary_indicators)
-          {
-            local_max_values.push_back (local_max_vel[boundary_id]);
-            local_min_values.push_back (local_min_vel[boundary_id]);
-
-            local_velocity_square_integral_values.push_back (local_velocity_square_integral[boundary_id]);
-            local_boundary_area_values.push_back (local_boundary_area[boundary_id]);
-          }
-        // then collect contributions from all processors
-        std::vector<double> global_max_values (local_max_values.size());
-        Utilities::MPI::max (local_max_values, this->get_mpi_communicator(), global_max_values);
-        std::vector<double> global_min_values (local_min_values.size());
-        Utilities::MPI::min (local_min_values, this->get_mpi_communicator(), global_min_values);
-
-        std::vector<double> global_velocity_square_integral_values (local_velocity_square_integral_values.size());
-        Utilities::MPI::sum(local_velocity_square_integral_values,this->get_mpi_communicator(),global_velocity_square_integral_values);
-        std::vector<double> global_boundary_area_values (local_boundary_area_values.size());
-        Utilities::MPI::sum(local_boundary_area_values,this->get_mpi_communicator(),global_boundary_area_values);
-
-        // and now take them apart into the global map again
-        // At the same time, calculate the rms velocity for each boundary
-        unsigned int index = 0;
-        for (const auto boundary_id: boundary_indicators)
-          {
-            global_max_vel[boundary_id] = global_max_values[index];
-            global_min_vel[boundary_id] = global_min_values[index];
-            global_rms_vel[boundary_id] = std::sqrt(global_velocity_square_integral_values[index] / global_boundary_area_values[index]);
-            ++index;
-          }
-      }
-
-      // now add the computed max, min, and rms velocities to the statistics object
-      // and create a single string that can be output to the screen
-      const std::string units = (this->convert_output_to_years() == true) ? "m/year" : "m/s";
-      const double unit_scale_factor = (this->convert_output_to_years() == true) ? year_in_seconds : 1.0;
-      std::ostringstream screen_text;
-      unsigned int index = 0;
-
-      for (std::map<types::boundary_id, double>::const_iterator
-           max_velocity = global_max_vel.begin(), min_velocity = global_min_vel.begin(), rms = global_rms_vel.begin();
-           max_velocity != global_max_vel.end() && min_velocity != global_min_vel.end() && rms != global_rms_vel.end();
-           ++max_velocity, ++min_velocity, ++rms, ++index)
-        {
-          const std::string name_max = "Maximum velocity magnitude on boundary with indicator "
-                                       + Utilities::int_to_string(max_velocity->first)
-                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                     .translate_id_to_symbol_name (max_velocity->first))
-                                       + " (" + units + ")";
-          statistics.add_value (name_max, max_velocity->second*unit_scale_factor);
-          const std::string name_min = "Minimum velocity magnitude on boundary with indicator "
-                                       + Utilities::int_to_string(min_velocity->first)
-                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                     .translate_id_to_symbol_name (min_velocity->first))
-                                       + " (" + units + ")";
-          statistics.add_value (name_min, min_velocity->second*unit_scale_factor);
-          const std::string name_rms = "RMS velocity on boundary with indicator "
-                                       + Utilities::int_to_string(rms->first)
-                                       + aspect::Utilities::parenthesize_if_nonempty(this->get_geometry_model()
-                                                                                     .translate_id_to_symbol_name (rms->first))
-                                       + " (" + units + ")";
-          statistics.add_value (name_rms, rms->second*unit_scale_factor);
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (name_max, 8);
-          statistics.set_scientific (name_max, true);
-          statistics.set_precision (name_min, 8);
-          statistics.set_scientific (name_min, true);
-          statistics.set_precision (name_rms, 8);
-          statistics.set_scientific (name_rms, true);
-
-          // finally have something for the screen
-          screen_text.precision(4);
-          screen_text << max_velocity->second *unit_scale_factor << ' ' << units << ", "
-                      << min_velocity->second *unit_scale_factor << ' ' << units << ", "
-                      << rms->second *unit_scale_factor << ' ' << units
-                      << (index == global_max_vel.size()-1 ? "" : ", ");
-        }
-
-      return std::pair<std::string, std::string> ("Max, min, and rms velocity along boundary parts:",
-                                                  screen_text.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(VelocityBoundaryStatistics,
-                                  "velocity boundary statistics",
-                                  "A postprocessor that computes some statistics about "
-                                  "the velocity along the boundaries. For each boundary "
-                                  "indicator (see your geometry description for which boundary "
-                                  "indicators are used), the min and max velocity magnitude is computed.")
-  }
-}
diff --git a/source/postprocess/velocity_statistics.cc.bak b/source/postprocess/velocity_statistics.cc.bak
deleted file mode 100644
index 0ff4d66c43d..00000000000
--- a/source/postprocess/velocity_statistics.cc.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/velocity_statistics.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/global.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    VelocityStatistics<dim>::execute (TableHandler &statistics)
-    {
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
-
-      double local_velocity_square_integral = 0;
-      double local_max_velocity = 0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                                                                                        velocity_values);
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                local_velocity_square_integral += ((velocity_values[q] * velocity_values[q]) *
-                                                   fe_values.JxW(q));
-                local_max_velocity = std::max (std::sqrt(velocity_values[q]*velocity_values[q]),
-                                               local_max_velocity);
-              }
-          }
-
-      const double global_velocity_square_integral
-        = Utilities::MPI::sum (local_velocity_square_integral, this->get_mpi_communicator());
-      const double global_max_velocity
-        = Utilities::MPI::max (local_max_velocity, this->get_mpi_communicator());
-
-      const double vrms = std::sqrt(global_velocity_square_integral) /
-                          std::sqrt(this->get_volume());
-
-      const std::string units = (this->convert_output_to_years() == true) ? "m/year" : "m/s";
-      const double unit_scale_factor = (this->convert_output_to_years() == true) ? year_in_seconds : 1.0;
-      const std::vector<std::string> column_names = {"RMS velocity (" + units + ")",
-                                                     "Max. velocity (" + units + ")"
-                                                    };
-
-      statistics.add_value (column_names[0],
-                            vrms * unit_scale_factor);
-      statistics.add_value (column_names[1],
-                            global_max_velocity * unit_scale_factor);
-
-      // also make sure that the other columns filled by this object
-      // all show up with sufficient accuracy and in scientific notation
-      for (auto &column : column_names)
-        {
-          statistics.set_precision (column, 8);
-          statistics.set_scientific (column, true);
-        }
-
-      std::ostringstream output;
-      output.precision(3);
-      output << vrms *unit_scale_factor
-             << ' ' << units << ", "
-             << global_max_velocity *unit_scale_factor
-             << ' ' << units;
-
-      return std::pair<std::string, std::string> ("RMS, max velocity:",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(VelocityStatistics,
-                                  "velocity statistics",
-                                  "A postprocessor that computes the root mean square and "
-                                  "maximum velocity in the computational domain.")
-  }
-}
diff --git a/source/postprocess/viscous_dissipation_statistics.cc.bak b/source/postprocess/viscous_dissipation_statistics.cc.bak
deleted file mode 100644
index d4f47a29f54..00000000000
--- a/source/postprocess/viscous_dissipation_statistics.cc.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023-2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/viscous_dissipation_statistics.h>
-#include <aspect/global.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    ViscousDissipationStatistics<dim>::execute (TableHandler &statistics)
-    {
-      // Create a quadrature formula based on the velocity element.
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
-
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_gradients |
-                               update_JxW_values);
-
-      // Vector to store the local dissipation for all the fields and
-      // for the whole domain.
-      const unsigned int n_compositional_fields = this->n_compositional_fields();
-
-      std::vector<double> local_dissipation_integral (n_compositional_fields+1);
-      std::vector<double> compositional_values(n_q_points);
-
-      typename MaterialModel::Interface<dim>::MaterialModelInputs in(n_q_points,
-                                                                     n_compositional_fields);
-      typename MaterialModel::Interface<dim>::MaterialModelOutputs out(n_q_points,
-                                                                       n_compositional_fields);
-      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-
-            in.reinit(fe_values,
-                      cell,
-                      this->introspection(),
-                      this->get_solution());
-
-            this->get_material_model().fill_additional_material_model_inputs(in,
-                                                                             this->get_solution(),
-                                                                             fe_values,
-                                                                             this->introspection());
-
-            this->get_material_model().evaluate(in, out);
-
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                // Viscous dissipation D in 3d:
-                // D = 1/2 * volume_integral(deviatoric_stress*deviatoric_strain_rate)
-                //   = 1/2 * volume_integral(2*eta*deviatoric_strain_rate*deviatoric_strain_rate)
-                //   = volume_integral(eta*deviatoric_strain_rate*deviatoric_strain_rate)
-                const SymmetricTensor<2, dim> deviatoric_strain_rate =
-                  (this->get_material_model().is_compressible()
-                   ? in.strain_rate[q] - 1. / 3. * trace(in.strain_rate[q]) * unit_symmetric_tensor<dim>()
-                   : in.strain_rate[q]);
-                const double local_dissipation = out.viscosities[q] * (deviatoric_strain_rate *
-                                                                       deviatoric_strain_rate) * fe_values.JxW(q);
-
-                // Dissipation over the whole domain
-                local_dissipation_integral[n_compositional_fields] += local_dissipation;
-
-                // Dissipation over each compositional field
-                for (unsigned int c = 0; c<n_compositional_fields; ++c)
-                  if (in.composition[q][c] >= 0.5)
-                    local_dissipation_integral[c] += local_dissipation;
-              }
-          }
-
-      std::vector<double> viscous_dissipation (local_dissipation_integral.size());
-      Utilities::MPI::sum (local_dissipation_integral, this->get_mpi_communicator(), viscous_dissipation);
-
-      const std::string unit = (dim == 3) ? "(W)" : "(W/m)";
-
-      // Add the dissipation per compositional fields to the statistics output
-      for (unsigned int c = 0; c < n_compositional_fields; ++c)
-        {
-          statistics.add_value ("Viscous dissipation " + unit + " for composition " + this->introspection().name_for_compositional_index(c),
-                                viscous_dissipation[c]);
-
-          // also make sure that the other columns filled by this object
-          // all show up with sufficient accuracy and in scientific notation
-          const std::string column = "Viscous dissipation " + unit + " for composition " + this->introspection().name_for_compositional_index(c);
-
-          statistics.set_precision (column, 8);
-          statistics.set_scientific (column, true);
-        }
-
-      // Add the dissipation over the whole domain to the statistics output
-      statistics.add_value ("Viscous dissipation " + unit,
-                            viscous_dissipation[n_compositional_fields]);
-
-      const std::string column = "Viscous dissipation " + unit;
-      statistics.set_precision (column, 8);
-      statistics.set_scientific (column, true);
-
-      std::ostringstream output;
-      output.precision(4);
-
-      for (unsigned int n = 0; n < n_compositional_fields + 1; ++n)
-        {
-          output << viscous_dissipation[n];
-
-          if (n + 1 != n_compositional_fields+1)
-            output << " // ";
-        }
-
-      return std::pair<std::string, std::string> ("Viscous dissipation per field and for whole domain " + unit + ":",
-                                                  output.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(ViscousDissipationStatistics,
-                                  "viscous dissipation statistics",
-                                  "A postprocessor that outputs the viscous rate of dissipation of "
-                                  "energy for each compositional field (where the field has a value "
-                                  "of 0.5 or more) as well as over the whole domain. "
-                                  "When all the fields represent lithologies and there is no background "
-                                  "field, the sum of the individual field's dissipation should equal "
-                                  "that over the whole domain. "
-                                  "The viscous dissipation is computed as: "
-                                  "$\\int_{V}\\left(\\sigma^\\prime \\dot{\\epsilon}^\\prime \\right)$, "
-                                  "where $\\sigma^\\prime$  is the deviatoric stress and $\\dot{\\epsilon}^\\prime$ "
-                                  "the deviatoric strain rate."
-                                  "Note then when shear heating is included in the temperature equation, "
-                                  "it is better to use the 'heating statistics' postprocessor.")
-  }
-}
diff --git a/source/postprocess/visualization.cc.bak b/source/postprocess/visualization.cc.bak
deleted file mode 100644
index 61e3886af92..00000000000
--- a/source/postprocess/visualization.cc.bak
+++ /dev/null
@@ -1,1688 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-#include <aspect/simulator.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <deal.II/fe/mapping_q1_eulerian.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/numerics/data_out_faces.h>
-
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/text_iarchive.hpp>
-
-#include <cmath>
-#include <cstdio>
-#include <unistd.h>
-
-#include <algorithm>
-#include <type_traits>
-
-#include <boost/lexical_cast.hpp>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace
-    {
-      /**
-       * This Postprocessor will generate the output variables of velocity,
-       * pressure, temperature, and compositional fields. They can not be added
-       * directly if the velocity needs to be converted from m/s to m/year, so
-       * this is what this class does.
-       */
-      template <int dim>
-      class BaseVariablePostprocessor: public DataPostprocessor<dim>, public SimulatorAccess<dim>
-      {
-        public:
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override
-          {
-            const double velocity_scaling_factor =
-              this->convert_output_to_years() ? year_in_seconds : 1.0;
-            const unsigned int n_q_points = input_data.solution_values.size();
-            for (unsigned int q=0; q<n_q_points; ++q)
-              for (unsigned int i=0; i<computed_quantities[q].size(); ++i)
-                {
-                  // scale velocities and fluid velocities by year_in_seconds if needed
-                  if (this->introspection().component_masks.velocities[i] ||
-                      (this->include_melt_transport()
-                       && this->introspection().variable("fluid velocity").component_mask[i]))
-                    computed_quantities[q][i] = input_data.solution_values[q][i] * velocity_scaling_factor;
-                  else
-                    computed_quantities[q][i] = input_data.solution_values[q][i];
-                }
-          }
-
-
-          std::vector<std::string>
-          get_names () const override
-          {
-            std::vector<std::string> solution_names (dim, "velocity");
-
-            if (this->include_melt_transport())
-              {
-                solution_names.emplace_back("p_f");
-                solution_names.emplace_back("p_c_bar");
-                for (unsigned int i=0; i<dim; ++i)
-                  solution_names.emplace_back("u_f");
-              }
-            solution_names.emplace_back("p");
-
-            solution_names.emplace_back("T");
-            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-              solution_names.push_back (this->introspection().name_for_compositional_index(c));
-
-            return solution_names;
-          }
-
-
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          get_data_component_interpretation () const override
-          {
-            std::vector<DataComponentInterpretation::DataComponentInterpretation>
-            interpretation (dim,
-                            DataComponentInterpretation::component_is_part_of_vector);
-            if (this->include_melt_transport())
-              {
-                interpretation.push_back (DataComponentInterpretation::component_is_scalar);
-                interpretation.push_back (DataComponentInterpretation::component_is_scalar);
-                for (unsigned int i=0; i<dim; ++i)
-                  interpretation.push_back (DataComponentInterpretation::component_is_part_of_vector);
-              }
-            interpretation.push_back (DataComponentInterpretation::component_is_scalar); // p
-            interpretation.push_back (DataComponentInterpretation::component_is_scalar); // T
-            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-              interpretation.push_back (DataComponentInterpretation::component_is_scalar);
-
-            return interpretation;
-          }
-
-
-          UpdateFlags
-          get_needed_update_flags () const override
-          {
-            return update_values;
-          }
-
-
-          std::vector<std::string>
-          get_physical_units () const
-          {
-            std::vector<std::string> solution_units;
-
-            if (this->convert_output_to_years())
-              for (unsigned int d=0; d<dim; ++d)
-                solution_units.emplace_back("m/year");
-            else
-              for (unsigned int d=0; d<dim; ++d)
-                solution_units.emplace_back("m/s");
-
-            if (this->include_melt_transport())
-              {
-                solution_units.emplace_back("Pa"); // fluid pressure
-                solution_units.emplace_back("Pa"); // scaled pressure
-                for (unsigned int i=0; i<dim; ++i)
-                  solution_units.emplace_back("m/s");
-              }
-            solution_units.emplace_back("Pa");
-
-            solution_units.emplace_back("K");
-            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-              solution_units.emplace_back(""); // we don't know here
-
-            return solution_units;
-          }
-      };
-
-      /**
-       * Adapt the previous class BaseVariablePostprocessor for the case of surface output,
-       * so output on the surface of the model domain. The only difference with the previous
-       * class is that each output variable name is prepended with the string 'surface_'.
-       */
-      template <int dim>
-      class SurfaceBaseVariablePostprocessor: public VisualizationPostprocessors::SurfaceOnlyVisualization<dim>, public BaseVariablePostprocessor<dim>
-      {
-        public:
-
-          std::vector<std::string> get_names () const override
-          {
-            std::vector<std::string> solution_names = BaseVariablePostprocessor<dim>::get_names();
-
-            for (std::string &name : solution_names)
-              name = "surface_" + name;
-
-            return solution_names;
-          }
-
-      };
-
-      /**
-       * This Postprocessor will generate the output variables of mesh velocity and
-       * mesh displacement for when a deforming mesh is used.
-       */
-      template <int dim>
-      class MeshDeformationPostprocessor: public DataPostprocessorVector<dim>, public SimulatorAccess<dim>
-      {
-        public:
-          MeshDeformationPostprocessor (const std::string &name,
-                                        bool is_velocity)
-            : DataPostprocessorVector<dim>(name,
-                                           update_values),
-            is_velocity(is_velocity)
-          {}
-
-
-          void
-          evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                                std::vector<Vector<double>> &computed_quantities) const override
-          {
-            // check that the first quadrature point has dim components
-            Assert( computed_quantities[0].size() == dim,
-                    ExcMessage("Unexpected dimension in mesh velocity postprocessor"));
-            const double velocity_scaling_factor =
-              (is_velocity && this->convert_output_to_years()) ? year_in_seconds : 1.0;
-            const unsigned int n_q_points = input_data.solution_values.size();
-            for (unsigned int q=0; q<n_q_points; ++q)
-              for (unsigned int i=0; i<dim; ++i)
-                computed_quantities[q][i] = input_data.solution_values[q][i] * velocity_scaling_factor;
-          }
-
-
-          std::string
-          get_physical_units () const
-          {
-            if (is_velocity)
-              {
-                if (this->convert_output_to_years())
-                  return "m/year";
-                else
-                  return "m/s";
-              }
-            else
-              return "m";
-          }
-          bool is_velocity;
-      };
-    }
-
-
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      Interface<dim>::Interface (const std::string &physical_units)
-        :
-        physical_units (physical_units)
-      {}
-
-
-
-      template <int dim>
-      std::string
-      Interface<dim>::get_physical_units () const
-      {
-        return physical_units;
-      }
-
-
-
-      template <int dim>
-      std::list<std::string>
-      Interface<dim>::required_other_postprocessors () const
-      {
-        return {};
-      }
-
-
-
-      template <int dim>
-      void
-      Interface<dim>::save (std::map<std::string,std::string> &) const
-      {}
-
-
-      template <int dim>
-      void
-      Interface<dim>::load (const std::map<std::string,std::string> &)
-      {}
-
-
-
-      template <int dim>
-      CellDataVectorCreator<dim>::CellDataVectorCreator (const std::string &physical_units)
-        :
-        Interface<dim> (physical_units)
-      {}
-    }
-
-
-    template <int dim>
-    Visualization<dim>::OutputHistory::OutputHistory()
-      :
-      // Record that we have not yet written any meshes and so
-      // there are none we can reference from future output operations.
-      mesh_changed (true)
-    {}
-
-
-
-    template <int dim>
-    Visualization<dim>::OutputHistory::~OutputHistory()
-    {
-      // Make sure that any thread that may still be running in the background,
-      // writing data, finishes
-      if (background_thread.joinable())
-        background_thread.join ();
-    }
-
-
-
-    template <int dim>
-    template <class Archive>
-    void Visualization<dim>::OutputHistory::serialize (Archive &ar, const unsigned int)
-    {
-      ar
-      & last_mesh_file_name
-      & times_and_pvtu_names
-      & output_file_names_by_timestep
-      & xdmf_entries
-      ;
-
-      // We do not serialize mesh_changed but use the default (true) from our
-      // constructor. This will result in a new mesh file the first time we
-      // create visualization output after resuming from a snapshot. Otherwise
-      // we might get corrupted graphical output, because the ordering of
-      // vertices can be different after resuming. (This is because when
-      // deal.II builds a triangulation, it tears down and re-creates its mesh every time
-      // p4est changes the partitioning; this process introduces a history where
-      // cells and vertices may be numbered differently if the triangulation
-      // had previous content than when -- as is done after a restart -- the
-      // triangulation is empty.)
-    }
-
-
-
-    template <int dim>
-    Visualization<dim>::Visualization ()
-      :
-      // the following value is later read from the input file
-      output_interval (0),
-      // initialize this to a nonsensical value; set it to the actual time
-      // the first time around we get to check it
-      last_output_time (std::numeric_limits<double>::quiet_NaN()),
-      maximum_timesteps_between_outputs (std::numeric_limits<int>::max()),
-      last_output_timestep (numbers::invalid_unsigned_int),
-      output_file_number (numbers::invalid_unsigned_int)
-    {}
-
-
-
-    template <int dim>
-    void Visualization<dim>::mesh_changed_signal()
-    {
-      cell_output_history.mesh_changed = true;
-      face_output_history.mesh_changed = true;
-    }
-
-
-
-    template <int dim>
-    template <typename DataOutType>
-    void
-    Visualization<dim>::write_description_files (const DataOutType &data_out,
-                                                 const std::string &solution_file_prefix,
-                                                 const std::vector<std::string> &filenames,
-                                                 OutputHistory                  &output_history) const
-    {
-      static_assert (std::is_same<DataOutType,DataOut<dim>>::value ||
-                     std::is_same<DataOutType,DataOutFaces<dim>>::value,
-                     "The only allowed template types of this function are "
-                     "DataOut and DataOutFaces.");
-      const bool is_cell_data_output = std::is_same<DataOutType,DataOut<dim>>::value;
-
-      const double time_in_years_or_seconds = (this->convert_output_to_years() ?
-                                               this->get_time() / year_in_seconds :
-                                               this->get_time());
-      const std::string pvtu_filename = (solution_file_prefix +
-                                         ".pvtu");
-      std::ofstream pvtu_file (this->get_output_directory() + "solution/" +
-                               pvtu_filename);
-      data_out.write_pvtu_record (pvtu_file, filenames);
-
-      // now also generate a .pvd file that matches simulation
-      // time and corresponding .pvtu record
-      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
-        {
-          // in case we output all nonlinear iterations, we only want one
-          // entry per time step, so replace the last line with the current iteration
-          if (this->get_nonlinear_iteration() == 0)
-            output_history.times_and_pvtu_names.emplace_back(time_in_years_or_seconds, "solution/"+pvtu_filename);
-          else
-            output_history.times_and_pvtu_names.back() = (std::make_pair
-                                                          (time_in_years_or_seconds, "solution/"+pvtu_filename));
-        }
-      else
-        output_history.times_and_pvtu_names.emplace_back(time_in_years_or_seconds, "solution/"+pvtu_filename);
-
-      const std::string pvd_filename = (this->get_output_directory() +
-                                        (is_cell_data_output ? "solution.pvd" : "solution_surface.pvd"));
-      std::ofstream pvd_file (pvd_filename);
-
-      DataOutBase::write_pvd_record (pvd_file, output_history.times_and_pvtu_names);
-
-      // finally, do the same for VisIt via the .visit file for this
-      // time step, as well as for all time steps together
-      const std::string visit_filename = (this->get_output_directory()
-                                          + "solution/"
-                                          + solution_file_prefix
-                                          + ".visit");
-      std::ofstream visit_file (visit_filename);
-
-      DataOutBase::write_visit_record (visit_file, filenames);
-
-      {
-        // the global .visit file needs the relative path because it sits a
-        // directory above
-        std::vector<std::string> filenames_with_path;
-        filenames_with_path.reserve(filenames.size());
-        for (const auto &filename : filenames)
-          {
-            filenames_with_path.emplace_back("solution/" + filename);
-          }
-
-        if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
-          {
-            // in case we output all nonlinear iterations, we only want one
-            // entry per time step, so replace the last line with the current iteration
-            if (this->get_nonlinear_iteration() == 0)
-              output_history.output_file_names_by_timestep.push_back (filenames_with_path);
-            else
-              output_history.output_file_names_by_timestep.back() = filenames_with_path;
-          }
-        else
-          output_history.output_file_names_by_timestep.push_back (filenames_with_path);
-      }
-
-      std::ofstream global_visit_file (this->get_output_directory() +
-                                       (is_cell_data_output ? "solution.visit" : "solution_surface.visit"));
-
-      std::vector<std::pair<double, std::vector<std::string>>> times_and_output_file_names;
-      for (unsigned int timestep=0; timestep<output_history.times_and_pvtu_names.size(); ++timestep)
-        times_and_output_file_names.push_back(std::make_pair(output_history.times_and_pvtu_names[timestep].first,
-                                                             output_history.output_file_names_by_timestep[timestep]));
-      DataOutBase::write_visit_record (global_visit_file, times_and_output_file_names);
-    }
-
-
-
-    template <int dim>
-    void
-    Visualization<dim>::update ()
-    {
-      //Call the .update() method for each visualization postprocessor.
-      for (const auto &p : postprocessors)
-        p->update();
-    }
-
-
-
-    template <int dim>
-    template <typename DataOutType>
-    std::string
-    Visualization<dim>::write_data_out_data(DataOutType   &data_out,
-                                            OutputHistory &output_history,
-                                            const std::map<std::string,std::string> &visualization_field_names_and_units) const
-    {
-      static_assert (std::is_same<DataOutType,DataOut<dim>>::value ||
-                     std::is_same<DataOutType,DataOutFaces<dim>>::value,
-                     "The only allowed template types of this function are "
-                     "DataOut and DataOutFaces.");
-      const bool is_cell_data_output = std::is_same<DataOutType,DataOut<dim>>::value;
-
-      const double time_in_years_or_seconds = (this->convert_output_to_years() ?
-                                               this->get_time() / year_in_seconds :
-                                               this->get_time());
-
-      std::string solution_file_prefix =
-        (is_cell_data_output ? "solution-" : "solution_surface-")
-        + Utilities::int_to_string (output_file_number, 5);
-      if (this->get_parameters().run_postprocessors_on_nonlinear_iterations)
-        solution_file_prefix.append("." + Utilities::int_to_string (this->get_nonlinear_iteration(), 4));
-
-      if (output_format == "hdf5")
-        {
-          XDMFEntry new_xdmf_entry;
-          const std::string h5_solution_file_name = "solution/"
-                                                    + solution_file_prefix + ".h5";
-          const std::string xdmf_filename = "solution.xdmf";
-          // Filter redundant values if requested in the input file
-          DataOutBase::DataOutFilter data_filter(
-            DataOutBase::DataOutFilterFlags(filter_output, true));
-          // If the mesh changed since the last output, make a new mesh file
-          const std::string mesh_file_prefix =
-            (is_cell_data_output ? "mesh-" : "mesh_surface-")
-            + Utilities::int_to_string(output_file_number, 5);
-          if (output_history.mesh_changed)
-            output_history.last_mesh_file_name = "solution/" + mesh_file_prefix + ".h5";
-
-          data_out.write_filtered_data(data_filter);
-          data_out.write_hdf5_parallel(data_filter,
-                                       output_history.mesh_changed,
-                                       this->get_output_directory() + output_history.last_mesh_file_name,
-                                       this->get_output_directory() + h5_solution_file_name,
-                                       this->get_mpi_communicator());
-          new_xdmf_entry = data_out.create_xdmf_entry(data_filter,
-                                                      output_history.last_mesh_file_name,
-                                                      h5_solution_file_name,
-                                                      time_in_years_or_seconds, this->get_mpi_communicator());
-          output_history.xdmf_entries.push_back(new_xdmf_entry);
-          data_out.write_xdmf_file(output_history.xdmf_entries,
-                                   this->get_output_directory() + xdmf_filename,
-                                   this->get_mpi_communicator());
-          output_history.mesh_changed = false;
-        }
-      else if (output_format == "vtu")
-        {
-          // Pass time step number and time as metadata into the output file
-          DataOutBase::VtkFlags vtk_flags;
-          vtk_flags.cycle = this->get_timestep_number();
-          vtk_flags.time = time_in_years_or_seconds;
-
-          // Also describe the physical units if we have them. Postprocessors do
-          // describe them, but it's a slight hassle to get at the information:
-          vtk_flags.physical_units = visualization_field_names_and_units;
-
-          // Finally, set or do not set whether we want to describe cells
-          // with curved edges and faces:
-#if DEAL_II_VERSION_GTE(9,6,0)
-          vtk_flags.write_higher_order_cells = write_higher_order_output;
-#else
-          // In versions of deal.II up to 9.5 (and perhaps later, see
-          // https://github.com/dealii/dealii/issues/17091), higher
-          // order output on lines fails with an
-          // ExcNotImplemented(). So just back down to regular linear
-          // interpolation if that is the case. This is only the case
-          // if we are in 2d and using surface output (DataOutFaces).
-          if (std::is_same<DataOutType,DataOutFaces<dim>>::value && (dim==2))
-            vtk_flags.write_higher_order_cells = false;
-          else
-            vtk_flags.write_higher_order_cells = write_higher_order_output;
-#endif
-
-          data_out.set_flags(vtk_flags);
-
-          // Write the description files (.pvtu,.pvd,.visit) on the root process
-          const int my_id = Utilities::MPI::this_mpi_process(
-                              this->get_mpi_communicator());
-          if (my_id == 0)
-            {
-              std::vector<std::string> filenames;
-              const unsigned int n_processes = Utilities::MPI::n_mpi_processes(
-                                                 this->get_mpi_communicator());
-              const unsigned int n_files =
-                (group_files == 0) ?
-                n_processes : std::min(group_files, n_processes);
-              for (unsigned int i = 0; i < n_files; ++i)
-                filenames.push_back(
-                  solution_file_prefix + "."
-                  + Utilities::int_to_string(i, 4) + ".vtu");
-              write_description_files(data_out, solution_file_prefix, filenames, output_history);
-            }
-          const unsigned int n_processes = Utilities::MPI::n_mpi_processes(
-                                             this->get_mpi_communicator());
-          const unsigned int my_file_id = (group_files == 0 ? my_id : my_id % group_files);
-          const std::string filename = this->get_output_directory() + "solution/"
-                                       + solution_file_prefix + "."
-                                       + Utilities::int_to_string(my_file_id, 4) + ".vtu";
-
-          // Write as many files as processes. For this case we support writing in a
-          // background thread and to a temporary location, so we first write everything
-          // into a string that is written to disk in a writer function
-          if ((group_files == 0) || (group_files >= n_processes))
-            {
-              // Put the content we want to write into a string object that
-              // we can then write in the background
-              std::unique_ptr<std::string> file_contents;
-              {
-                std::ostringstream tmp;
-                data_out.write(tmp,
-                               DataOutBase::parse_output_format(output_format));
-                file_contents = std::make_unique<std::string>(tmp.str());
-              }
-
-              if (write_in_background_thread)
-                {
-                  // Wait for all previous write operations to finish, should
-                  // any be still active, ...
-                  if (output_history.background_thread.joinable())
-                    output_history.background_thread.join();
-                  // ...then continue with writing our own data.
-                  output_history.background_thread
-                    = std::thread([ my_filename = std::move(filename),
-                                    my_temporary_output_location = temporary_output_location,
-                                    my_file_contents = std::move(file_contents)]()
-                  {
-                    writer (my_filename, my_temporary_output_location, *my_file_contents);
-                  });
-                }
-              else
-                writer(filename, temporary_output_location, *file_contents);
-            }
-          else
-            // Just write one data file in parallel
-            if (group_files == 1)
-              {
-                data_out.write_vtu_in_parallel(filename,
-                                               this->get_mpi_communicator());
-              }
-            else               // Write as many output files as 'group_files' groups
-              {
-                int color = my_id % group_files;
-                MPI_Comm comm;
-                int ierr = MPI_Comm_split(this->get_mpi_communicator(), color, my_id, &comm);
-                AssertThrowMPI(ierr);
-                data_out.write_vtu_in_parallel(filename, comm);
-                ierr = MPI_Comm_free(&comm);
-                AssertThrowMPI(ierr);
-              }
-        }
-      else if (output_format == "parallel deal.II intermediate")
-        {
-          const std::string filename = this->get_output_directory() + "solution/"
-                                       + solution_file_prefix + ".pd2";
-
-          data_out.write_deal_II_intermediate_in_parallel(filename,
-                                                          this->get_mpi_communicator(),
-                                                          DataOutBase::CompressionLevel::default_compression);
-        }
-      else   // Write in a different format than hdf5 or vtu. This case is supported, but is not
-        // optimized for parallel output in that every process will write one file directly
-        // into the output directory. This may or may not affect performance depending on
-        // the model setup and the network file system type.
-        {
-          const unsigned int myid = Utilities::MPI::this_mpi_process(
-                                      this->get_mpi_communicator());
-          const std::string filename = this->get_output_directory() + "solution/"
-                                       + solution_file_prefix + "." + Utilities::int_to_string(myid, 4)
-                                       + DataOutBase::default_suffix(
-                                         DataOutBase::parse_output_format(output_format));
-          std::ofstream out(filename);
-          AssertThrow(out,
-                      ExcMessage(
-                        "Unable to open file for writing: " + filename + "."));
-          data_out.write(out, DataOutBase::parse_output_format(output_format));
-        }
-
-      return solution_file_prefix;
-    }
-
-
-
-    namespace
-    {
-      /**
-       * Keep track of the names and physical units of output quantities. The
-       * number of entries in the two input arguments must be the same.
-       *
-       * This function also checks that output names are unique.
-       */
-      void
-      track_output_field_names_and_units(const std::vector<std::string> &output_data_names,
-                                         const std::vector<std::string> &output_units,
-                                         std::map<std::string,std::string> &output_data_names_and_units)
-      {
-        AssertDimension (output_data_names.size(), output_units.size());
-
-        // First check that none of the data names are already in the list:
-        for (const auto &name : output_data_names)
-          AssertThrow(output_data_names_and_units.find(name) == output_data_names_and_units.end(),
-                      ExcMessage("The output variable <" + name + "> already exists in the list of output "
-                                 "variables. Make sure there is no duplication in the names of visualization output "
-                                 "variables, otherwise output files may be corrupted."));
-
-        // Then insert the new names into the map. It is possible that
-        // some names appear multiple times (for vector-valued output)
-        // and in that case we need to make sure that the provided
-        // units are identical
-        for (unsigned int i=0; i<output_data_names.size(); ++i)
-          {
-            AssertThrow(
-              // either the name has not been added before...
-              (output_data_names_and_units.find(output_data_names[i])
-               == output_data_names_and_units.end())
-              ||
-              // or if it has, then the unit then added must match
-              // what we're about to add here
-              (output_data_names_and_units[output_data_names[i]]
-               == output_units[i]),
-              ExcMessage("The output variable <" + output_data_names[i]
-                         + "> had previously been added with physical units <"
-                         + output_data_names_and_units[output_data_names[i]]
-                         + "> but is now added again with units <"
-                         + output_units[i] + ">."));
-
-            // Now add the name/units. Don't worry about whether it previously
-            // had already been in the map -- if so, the assertion makes
-            // sure that we overwrite with the same value.
-            output_data_names_and_units[output_data_names[i]] = output_units[i];
-          }
-      }
-
-
-
-      /**
-       * Keep track of the names and physical units of output quantities. The
-       * number of entries in the two input arguments must be the same.
-       *
-       * This variant of the function expands the single 'output_units' variable into as
-       * many components as there are in 'output_data_names'. If the single string is
-       * provided as a comma-separated list, then split it and make sure that
-       * there are as many entries as there are in 'output_data_names'. If
-       * it is not a comma-separated list, then replicate it as many times
-       * as necessary. In either case, pass things on to the other function.
-       */
-      void
-      track_output_field_names_and_units(const std::vector<std::string> &output_data_names,
-                                         const std::string              &output_units,
-                                         std::map<std::string,std::string> &output_data_names_and_units)
-      {
-        if (output_units.find(',') != output_units.npos)
-          {
-            const std::vector<std::string> split_units = Utilities::split_string_list(output_units, ",");
-            Assert (split_units.size() == output_data_names.size(),
-                    ExcMessage("The number of provided units does not match the "
-                               "number of output variables."));
-            track_output_field_names_and_units(output_data_names, split_units,
-                                               output_data_names_and_units);
-          }
-        else
-          track_output_field_names_and_units(output_data_names,
-                                             std::vector<std::string> (output_data_names.size(), output_units),
-                                             output_data_names_and_units);
-      }
-    }
-
-
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    Visualization<dim>::execute (TableHandler &statistics)
-    {
-      // if this is the first time we get here, set the last output time
-      // to the current time - output_interval. this makes sure we
-      // always produce data during the first time step
-      if (std::isnan(last_output_time))
-        {
-          last_output_time = this->get_time() - output_interval;
-          last_output_timestep = this->get_timestep_number();
-        }
-
-      // Return if graphical output is not requested at this time. Do not
-      // return in the first timestep, or if the last output was more than
-      // output_interval in time ago, or maximum_timesteps_between_outputs in
-      // number of timesteps ago.
-      // The comparison in number of timesteps is safe from integer overflow for
-      // at most 2 billion timesteps , which is not likely to
-      // be ever reached (both values are unsigned int,
-      // and the default value of maximum_timesteps_between_outputs is
-      // set to numeric_limits<int>::max())
-      if ((this->get_time() < last_output_time + output_interval)
-          && (this->get_timestep_number() < last_output_timestep + maximum_timesteps_between_outputs)
-          && (this->get_timestep_number() != 0))
-        return {"", ""};
-
-      // up the counter of the number of the file by one, but not in
-      // the very first output step. if we run postprocessors on all
-      // iterations, only increase file number in the first nonlinear iteration
-      const bool increase_file_number = (this->get_nonlinear_iteration() == 0) || (!this->get_parameters().run_postprocessors_on_nonlinear_iterations);
-      if (output_file_number == numbers::invalid_unsigned_int)
-        output_file_number = 0;
-      else if (increase_file_number)
-        ++output_file_number;
-
-      BaseVariablePostprocessor<dim> base_variables;
-      base_variables.initialize_simulator (this->get_simulator());
-
-      // Keep a list of the names of all output variables
-      // (to ensure unique names), along with their respective
-      // physical units
-      std::map<std::string,std::string> visualization_field_names_and_units;
-
-      // Insert base variable names into set of all output field names
-      track_output_field_names_and_units(base_variables.get_names(),
-                                         base_variables.get_physical_units(),
-                                         visualization_field_names_and_units);
-
-      SurfaceBaseVariablePostprocessor<dim> surface_base_variables;
-      if (output_base_variables_on_mesh_surface)
-        {
-          surface_base_variables.initialize_simulator (this->get_simulator());
-
-          // Insert surface base variable names into set of all output field names
-          track_output_field_names_and_units(surface_base_variables.get_names(),
-                                             surface_base_variables.get_physical_units(),
-                                             visualization_field_names_and_units);
-        }
-
-      std::unique_ptr<MeshDeformationPostprocessor<dim>> mesh_deformation_velocity;
-      std::unique_ptr<MeshDeformationPostprocessor<dim>> mesh_deformation_displacement;
-
-      DataOut<dim> data_out;
-      data_out.attach_dof_handler (this->get_dof_handler());
-      data_out.add_data_vector (this->get_solution(),
-                                base_variables);
-
-      // Also create an object for outputting information that lives on
-      // the faces of the mesh.
-      DataOutFaces<dim> data_out_faces;
-      data_out_faces.attach_dof_handler (this->get_dof_handler());
-
-      if (output_base_variables_on_mesh_surface)
-        data_out_faces.add_data_vector (this->get_solution(),
-                                        surface_base_variables);
-
-      // If there is a deforming mesh, also attach the mesh velocity object
-      if ( this->get_parameters().mesh_deformation_enabled && output_mesh_velocity)
-        {
-          mesh_deformation_velocity = std::make_unique<MeshDeformationPostprocessor<dim>>("mesh_velocity", true);
-          mesh_deformation_velocity->initialize_simulator(this->get_simulator());
-
-          // Insert mesh deformation variable names into set of all output field names
-          track_output_field_names_and_units(mesh_deformation_velocity->get_names(),
-                                             mesh_deformation_velocity->get_physical_units(),
-                                             visualization_field_names_and_units);
-
-          data_out.add_data_vector (this->get_mesh_velocity(),
-                                    *mesh_deformation_velocity);
-        }
-
-      if ( this->get_parameters().mesh_deformation_enabled && output_mesh_displacement)
-        {
-          mesh_deformation_displacement = std::make_unique<MeshDeformationPostprocessor<dim>>("mesh_displacement", false);
-          mesh_deformation_displacement->initialize_simulator(this->get_simulator());
-
-          // Insert mesh deformation variable names into set of all output field names
-          track_output_field_names_and_units(mesh_deformation_displacement->get_names(),
-                                             mesh_deformation_displacement->get_physical_units(),
-                                             visualization_field_names_and_units);
-
-          data_out.add_data_vector (this->get_mesh_deformation_handler().get_mesh_deformation_dof_handler(),
-                                    this->get_mesh_deformation_handler().get_mesh_displacements(),
-                                    *mesh_deformation_displacement);
-        }
-
-      bool have_face_viz_postprocessors = false;
-
-      // then for each additional selected output variable
-      // add the computed quantity as well. keep a list of
-      // pointers to data vectors created by cell data visualization
-      // postprocessors that will later be deleted
-      std::list<std::unique_ptr<Vector<float>>> cell_data_vectors;
-      for (const auto &p : postprocessors)
-        {
-          try
-            {
-              // There are two ways of writing visualization postprocessors:
-              // - deriving from DataPostprocessor
-              // - deriving from DataVectorCreator
-              // treat them in turn. In both cases, the information can
-              // be output on all cells, or via the faces on the surface
-              // only (if the class in question is derived from
-              // SurfaceOnlyVisualization), so we will have to switch between
-              // the two ways when we send things to the data_out or
-              // data_out_faces objects.
-              if (const DataPostprocessor<dim> *viz_postprocessor
-                  = dynamic_cast<const DataPostprocessor<dim>*>(& *p))
-                {
-                  track_output_field_names_and_units(viz_postprocessor->get_names(),
-                                                     p->get_physical_units(),
-                                                     visualization_field_names_and_units);
-
-                  if (dynamic_cast<const VisualizationPostprocessors::SurfaceOnlyVisualization<dim>*>
-                      (& *p) == nullptr)
-                    data_out.add_data_vector (this->get_solution(),
-                                              *viz_postprocessor);
-                  else
-                    {
-                      data_out_faces.add_data_vector (this->get_solution(),
-                                                      *viz_postprocessor);
-                      // Apart from the base variables, other postprocessors
-                      // output on the mesh surface.
-                      have_face_viz_postprocessors = true;
-                    }
-                }
-              else if (const VisualizationPostprocessors::CellDataVectorCreator<dim> *
-                       cell_data_creator
-                       = dynamic_cast<const VisualizationPostprocessors::CellDataVectorCreator<dim>*>
-                         (& *p))
-                {
-                  // get the data produced here
-                  std::pair<std::string, std::unique_ptr<Vector<float>>>
-                  cell_data = cell_data_creator->execute();
-                  Assert (cell_data.second->size() ==
-                          this->get_triangulation().n_active_cells(),
-                          ExcMessage ("Cell data visualization postprocessors must generate "
-                                      "vectors that have as many entries as there are active cells "
-                                      "on the current processor."));
-
-                  track_output_field_names_and_units({cell_data.first},
-                                                     cell_data_creator->get_physical_units(),
-                                                     visualization_field_names_and_units);
-
-                  // store the pointer, then attach the vector to the DataOut object
-                  cell_data_vectors.push_back (std::move(cell_data.second));
-
-                  if (dynamic_cast<const VisualizationPostprocessors::SurfaceOnlyVisualization<dim>*>
-                      (& *p) == nullptr)
-                    data_out.add_data_vector (*cell_data_vectors.back(),
-                                              cell_data.first,
-                                              DataOut<dim>::type_cell_data);
-                  else
-                    {
-                      data_out_faces.add_data_vector(*cell_data_vectors.back(),
-                                                     cell_data.first,
-                                                     DataOutFaces<dim>::type_cell_data);
-                      // Apart from the base variables, other postprocessors
-                      // output on the mesh surface.
-                      have_face_viz_postprocessors = true;
-                    }
-                }
-              else
-                // A viz postprocessor not derived from either DataPostprocessor
-                // or CellDataVectorCreator? We don't know what to do with that!
-                Assert (false,
-                        ExcMessage("The visualization system found a visualization "
-                                   "postprocessor class that is not either derived from "
-                                   "DataPostprocessor or "
-                                   "VisualizationPostprocessors::CellDataVectorCreator. "
-                                   "ASPECT does not know what to do with these kinds of "
-                                   "classes."));
-            }
-          // viz postprocessors that throw exceptions usually do not result in
-          // anything good because they result in an unwinding of the stack
-          // and, if only one processor triggers an exception, the
-          // destruction of objects often causes a deadlock. thus, if
-          // an exception is generated, catch it, print an error message,
-          // and abort the program
-          catch (std::exception &exc)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "An exception happened on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running the visualization postprocessor <"
-                        << typeid(*p).name()
-                        << ">: " << std::endl
-                        << exc.what() << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-          catch (...)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "An exception happened on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running the visualization postprocessor <"
-                        << typeid(*p).name()
-                        << ">: " << std::endl;
-              std::cerr << "Unknown exception!" << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-
-        }
-
-      // Now build the patches. If selected, increase the output resolution.
-      // Giving the mapping ensures that the case with mesh deformation works correctly.
-      const unsigned int subdivisions = interpolate_output
-                                        ?
-                                        this->get_stokes_velocity_degree()
-                                        :
-                                        0;
-
-      // Use the normal mapping unless we use mesh deformation and
-      // the user requests an undeformed mesh. In that case, we use
-      // a Q1 mapping here.
-      const Mapping<dim> &linear_mapping = ReferenceCells::get_hypercube<dim>().template get_default_linear_mapping<dim>();
-      const Mapping<dim> &mapping =
-        (output_undeformed_mesh && dynamic_cast<const MappingQ1Eulerian<dim, LinearAlgebra::Vector>*>(&this->get_mapping())) ?
-        (linear_mapping) : (this->get_mapping());
-
-      this->get_signals().pre_data_out_build_patches (data_out);
-
-      // Now get everything written for the DataOut case, and record this
-      // in the statistics file
-      std::string solution_file_prefix;
-      {
-        data_out.build_patches (mapping,
-                                subdivisions,
-                                this->get_geometry_model().has_curved_elements()
-                                ?
-                                DataOut<dim>::curved_inner_cells
-                                :
-                                DataOut<dim>::no_curved_cells);
-
-        solution_file_prefix
-          = write_data_out_data(data_out, cell_output_history,
-                                visualization_field_names_and_units);
-        statistics.add_value ("Visualization file name",
-                              this->get_output_directory()
-                              + "solution/"
-                              + solution_file_prefix);
-      }
-
-      // Then do the same again for the face data case. We won't print the
-      // output file name to screen (too much clutter on the screen already)
-      // but still put it into the statistics file
-      if (output_base_variables_on_mesh_surface || have_face_viz_postprocessors)
-        {
-          data_out_faces.build_patches (mapping,
-                                        subdivisions);
-
-          const std::string face_solution_file_prefix
-            = write_data_out_data(data_out_faces, face_output_history,
-                                  visualization_field_names_and_units);
-          statistics.add_value ("Surface visualization file name",
-                                this->get_output_directory()
-                                + "solution_surface/"
-                                + face_solution_file_prefix);
-        }
-
-      // Increment the next time we need output:
-      set_last_output_time (this->get_time());
-      last_output_timestep = this->get_timestep_number();
-
-      // Return what should be printed to the screen. This is a bit
-      // late (the output has already been written, and this probably took
-      // a good long while), but it's still good to provide a status
-      // update.
-      return std::make_pair (std::string ("Writing graphical output:"),
-                             this->get_output_directory()
-                             + "solution/"
-                             + solution_file_prefix);
-    }
-
-
-    template <int dim>
-    void Visualization<dim>::writer (const std::string &filename,
-                                     const std::string &temporary_output_location,
-                                     const std::string &file_contents)
-    {
-      std::string tmp_filename = filename;
-      if (temporary_output_location != "")
-        {
-          tmp_filename = temporary_output_location + "/aspect.tmp.XXXXXX";
-
-          // Create the temporary file; get at the actual filename
-          // by using a C-style string that mkstemp will then overwrite
-          std::vector<char> tmp_filename_x (tmp_filename.size()+1);
-          std::strcpy(tmp_filename_x.data(), tmp_filename.c_str());
-          const int tmp_file_desc = mkstemp(tmp_filename_x.data());
-          tmp_filename = tmp_filename_x.data();
-
-          // If we failed to create the temp file, just write directly to the target file.
-          // We also provide a warning about this fact. There are places where
-          // this fails *on every node*, so we will get a lot of warning messages
-          // into the output; in these cases, just writing multiple pieces to
-          // std::cerr will produce an unreadable mass of text; rather, first
-          // assemble the error message completely, and then output it atomically
-          if (tmp_file_desc == -1)
-            {
-              const std::string x = ("***** WARNING: could not create temporary file <"
-                                     +
-                                     tmp_filename
-                                     +
-                                     ">, will output directly to final location. This may negatively "
-                                     "affect performance. (On processor "
-                                     + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD))
-                                     + ".)\n");
-
-              std::cerr << x << std::flush;
-
-              tmp_filename = filename;
-            }
-          else
-            close(tmp_file_desc);
-        }
-
-      std::ofstream out(tmp_filename);
-
-      AssertThrow (out, ExcMessage(std::string("Trying to write to file <") +
-                                   filename +
-                                   ">, but the file can't be opened!"));
-
-      // now write and then move the tmp file to its final destination
-      // if necessary
-      out.write (file_contents.data(), file_contents.size());
-      out.close ();
-
-      if (tmp_filename != filename)
-        {
-          std::string command = std::string("mv ") + tmp_filename + " " + filename;
-          int error = system(command.c_str());
-
-          AssertThrow(error == 0,
-                      ExcMessage("Could not move " + tmp_filename + " to "
-                                 + filename + ". On processor "
-                                 + Utilities::int_to_string(Utilities::MPI::this_mpi_process (MPI_COMM_WORLD)) + "."));
-        }
-    }
-
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<VisualizationPostprocessors::Interface<2>>,
-      aspect::internal::Plugins::PluginList<VisualizationPostprocessors::Interface<3>>> registered_visualization_plugins;
-    }
-
-
-    template <int dim>
-    void
-    Visualization<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Visualization");
-        {
-          prm.declare_entry ("Time between graphical output", "1e8",
-                             Patterns::Double (0.),
-                             "The time interval between each generation of "
-                             "graphical output files. A value of zero indicates "
-                             "that output should be generated in each time step. "
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-
-          prm.declare_entry ("Time steps between graphical output", boost::lexical_cast<std::string>(std::numeric_limits<int>::max()),
-                             Patterns::Integer(0),
-                             "The maximum number of time steps between each generation of "
-                             "graphical output files.");
-
-          // now also see about the file format we're supposed to write in
-          prm.declare_entry ("Output format", "vtu",
-                             Patterns::Selection (DataOutBase::get_output_format_names ()
-                                                  + "|parallel deal.II intermediate"),
-                             "The file format to be used for graphical output. The list "
-                             "of possible output formats that can be given here is documented "
-                             "in the appendix of the manual where the current parameter "
-                             "is described.");
-
-          prm.declare_entry ("Number of grouped files", "16",
-                             Patterns::Integer(0),
-                             "VTU file output supports grouping files from several CPUs "
-                             "into a given number of files using MPI I/O when writing on a parallel "
-                             "filesystem. Select 0 for no grouping. This will disable "
-                             "parallel file output and instead write one file per processor. "
-                             "A value of 1 will generate one big file containing the whole "
-                             "solution, while a larger value will create that many files "
-                             "(at most as many as there are MPI ranks).");
-
-          prm.declare_entry ("Write in background thread", "false",
-                             Patterns::Bool(),
-                             "File operations can potentially take a long time, blocking the "
-                             "progress of the rest of the model run. Setting this variable to "
-                             "`true' moves this process into a background thread, while the "
-                             "rest of the model continues.");
-
-          prm.declare_entry ("Temporary output location", "",
-                             Patterns::Anything(),
-                             "On large clusters it can be advantageous to first write the "
-                             "output to a temporary file on a local file system and later "
-                             "move this file to a network file system. If this variable is "
-                             "set to a non-empty string it will be interpreted as a "
-                             "temporary storage location.");
-
-          prm.declare_entry ("Interpolate output", "true",
-                             Patterns::Bool(),
-                             "deal.II offers the possibility to linearly interpolate "
-                             "output fields of higher order elements to a finer resolution. "
-                             "This somewhat compensates the fact that most visualization "
-                             "software only offers linear interpolation between grid points "
-                             "and therefore the output file is a very coarse representation "
-                             "of the actual solution field. Activating this option increases "
-                             "the spatial resolution in each dimension by a factor equal "
-                             "to the polynomial degree used for the velocity finite element "
-                             "(usually 2). In other words, instead of showing one quadrilateral "
-                             "or hexahedron in the visualization per cell on which \\aspect{} "
-                             "computes, it shows multiple (for quadratic elements, it will "
-                             "describe each cell of the mesh on which we compute as "
-                             "$2\\times 2$ or $2\\times 2\\times 2$ cells in 2d and 3d, "
-                             "respectively; correspondingly more subdivisions are used if "
-                             "you use cubic, quartic, or even higher order elements for the "
-                             "velocity)."
-                             "\n\n"
-                             "The effect of using this option can be seen in the following "
-                             "picture showing a variation of the output produced with the "
-                             "input files from Section~\\ref{sec:cookbooks:shell_simple_2d}:"
-                             "\n\n"
-                             "\\begin{center}"
-                             "  \\includegraphics[width=0.5\\textwidth]{viz/parameters/build-patches}"
-                             "\\end{center}"
-                             "Here, the left picture shows one visualization cell per "
-                             "computational cell (i.e., the option is switched off), "
-                             "and the right picture shows the same simulation with the "
-                             "option switched on (which is the default). The images "
-                             "show the same data, demonstrating "
-                             "that interpolating the solution onto bilinear shape functions as is "
-                             "commonly done in visualizing data loses information."
-                             "\n\n"
-                             "Of course, activating this option also greatly increases the amount of "
-                             "data \\aspect{} will write to disk: approximately by a factor of 4 in 2d, "
-                             "and a factor of 8 in 3d, when using quadratic elements for the velocity, "
-                             "and correspondingly more for even higher order elements.");
-
-          prm.declare_entry ("Point-wise stress and strain", "false",
-                             Patterns::Bool(),
-                             "If set to true, quantities related to stress and strain are computed "
-                             "in each vertex. Otherwise, an average per cell is computed.");
-
-          prm.declare_entry ("Write higher order output", "false",
-                             Patterns::Bool(),
-                             "deal.II offers the possibility to write vtu files with higher order "
-                             "representations of the output data. This means each cell will correctly "
-                             "show the higher order representation of the output data instead of the "
-                             "linear interpolation between vertices that ParaView and VisIt usually show. "
-                             "Note that activating this option is safe and recommended, but requires that "
-                             "(i) ``Output format'' is set to ``vtu'', (ii) ``Interpolate output'' is "
-                             "set to true, (iii) you use a sufficiently new version of Paraview "
-                             "or VisIt to read the files (Paraview version 5.5 or newer, and VisIt version "
-                             "to be determined), and (iv) you use deal.II version 9.1.0 or newer. "
-                             "\n"
-                             "The effect of using this option can be seen in the following "
-                             "picture:"
-                             "\n\n"
-                             "\\begin{center}"
-                             "  \\includegraphics[width=0.5\\textwidth]{viz/parameters/higher-order-output}"
-                             "\\end{center}"
-                             "The top figure shows the plain output without interpolation or higher "
-                             "order output. The middle figure shows output that was interpolated as "
-                             "discussed for the ``Interpolate output'' option. The bottom panel "
-                             "shows higher order output that achieves better accuracy than the "
-                             "interpolated output at a lower memory cost.");
-
-          prm.declare_entry ("Filter output", "false",
-                             Patterns::Bool(),
-                             "deal.II offers the possibility to filter duplicate vertices for HDF5 "
-                             "output files. This merges the vertices of adjacent cells and "
-                             "therefore saves disk space, but misrepresents discontinuous "
-                             "output properties. Activating this function reduces the disk space "
-                             "by about a factor of $2^{dim}$ for HDF5 output, and currently has no "
-                             "effect on other output formats. "
-                             ":::{warning}\n"
-                             "Setting this flag to true will result in "
-                             "visualization output that does not accurately represent discontinuous "
-                             "fields. This may be because you are using a discontinuous finite "
-                             "element for the pressure, temperature, or compositional variables, "
-                             "or because you use a visualization postprocessor that outputs "
-                             "quantities as discontinuous fields (e.g., the strain rate, viscosity, "
-                             "etc.). These will then all be visualized as \\textit{continuous} "
-                             "quantities even though, internally, \\aspect{} considers them as "
-                             "discontinuous fields.\n"
-                             ":::");
-
-          prm.declare_entry ("Output mesh velocity", "false",
-                             Patterns::Bool(),
-                             "For computations with deforming meshes, ASPECT uses an Arbitrary-Lagrangian-"
-                             "Eulerian formulation to handle deforming the domain, so the mesh "
-                             "has its own velocity field.  This may be written as an output field "
-                             "by setting this parameter to true.");
-
-          prm.declare_entry ("Output mesh displacement", "false",
-                             Patterns::Bool(),
-                             "For computations with deforming meshes, ASPECT uses an Arbitrary-Lagrangian-"
-                             "Eulerian formulation to handle deforming the domain. The displacement vector from "
-                             "the reference configuration may be written as an output field by setting this "
-                             "parameter to true.");
-
-          prm.declare_entry ("Output undeformed mesh", "false",
-                             Patterns::Bool(),
-                             "For computations with deforming meshes, ASPECT uses an Arbitrary-Lagrangian-"
-                             "Eulerian formulation to handle deforming the domain. By default, we output "
-                             "the deformed mesh. If this setting is set to true, the mesh will be written "
-                             "in the reference state without deformation instead. If you output the mesh "
-                             "displacement, you can obtain the deformed mesh by using the 'warp by vector' "
-                             "ParaView filter.");
-
-          prm.declare_entry("Output base variables on mesh surface", "false",
-                            Patterns::Bool(),
-                            "Whether or not to also output the base variables velocity, fluid pressure "
-                            "(when present), fluid velocity (when present), pressure, "
-                            "temperature and compositional fields (when present) on the surface "
-                            "of the mesh. The mesh surface includes not only the top boundary, "
-                            "but all boundaries of the domain. ");
-
-          // Finally also construct a string for Patterns::MultipleSelection that
-          // contains the names of all registered visualization postprocessors.
-          // Also add a number of removed plugins that are now combined in 'material properties'
-          // to keep compatibility with input files. These will be filtered out in parse_parameters().
-          const std::string pattern_of_names
-            = std::get<dim>(registered_visualization_plugins).get_pattern_of_names ()
-              + "|density|specific heat|thermal conductivity|thermal diffusivity|thermal expansivity|viscosity";
-          prm.declare_entry("List of output variables",
-                            "",
-                            Patterns::MultipleSelection(pattern_of_names),
-                            "A comma separated list of visualization objects that should be run "
-                            "whenever writing graphical output. By default, the graphical "
-                            "output files will always contain the primary variables velocity, "
-                            "pressure, and temperature. However, one frequently wants to also "
-                            "visualize derived quantities, such as the thermodynamic phase "
-                            "that corresponds to a given temperature-pressure value, or the "
-                            "corresponding seismic wave speeds. The visualization objects do "
-                            "exactly this: they compute such derived quantities and place them "
-                            "into the output file. The current parameter is the place where "
-                            "you decide which of these additional output variables you want "
-                            "to have in your output file.\n\n"
-                            "The following postprocessors are available:\n\n"
-                            +
-                            std::get<dim>(registered_visualization_plugins).get_description_string());
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // now declare the parameters of each of the registered
-      // visualization postprocessors in turn
-      std::get<dim>(registered_visualization_plugins).declare_parameters (prm);
-    }
-
-
-    template <int dim>
-    void
-    Visualization<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      Assert (std::get<dim>(registered_visualization_plugins).plugins != nullptr,
-              ExcMessage ("No postprocessors registered!?"));
-      std::vector<std::string> viz_names;
-
-      std::string visualization_subdirectory = this->get_output_directory() + "solution/";
-      Utilities::create_directory (visualization_subdirectory,
-                                   this->get_mpi_communicator(),
-                                   true);
-
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("Visualization");
-        {
-          output_interval = prm.get_double ("Time between graphical output");
-          if (this->convert_output_to_years())
-            output_interval *= year_in_seconds;
-
-          maximum_timesteps_between_outputs = prm.get_integer("Time steps between graphical output");
-
-          if (output_interval > 0.0)
-            {
-              // since we increase the time indicating when to write the next graphical output
-              // every time we execute the visualization postprocessor, there is no good way to
-              // figure out when to write graphical output for the nonlinear iterations if we do
-              // not want to output every time step
-              AssertThrow(this->get_parameters().run_postprocessors_on_nonlinear_iterations == false,
-                          ExcMessage("Postprocessing nonlinear iterations is only supported if every time "
-                                     "step is visualized, or in other words, if the 'Time between graphical "
-                                     "output' in the Visualization postprocessor is set to zero."));
-            }
-
-          output_format   = prm.get ("Output format");
-          group_files     = prm.get_integer("Number of grouped files");
-          write_in_background_thread = prm.get_bool("Write in background thread");
-          temporary_output_location = prm.get("Temporary output location");
-
-          if (temporary_output_location != "")
-            {
-              // Check if a command-processor is available by calling system() with a
-              // null pointer. System is guaranteed to return non-zero if it finds
-              // a terminal and zero if there is none (like on the compute nodes of
-              // some cluster architectures, e.g. IBM BlueGene/Q)
-              AssertThrow(system((char *)nullptr) != 0,
-                          ExcMessage("Usage of a temporary storage location is only supported if "
-                                     "there is a terminal available to move the files to their final location "
-                                     "after writing. The system() command did not succeed in finding such a terminal."));
-            }
-
-          interpolate_output = prm.get_bool("Interpolate output");
-          filter_output = prm.get_bool("Filter output");
-          pointwise_stress_and_strain = prm.get_bool("Point-wise stress and strain");
-          write_higher_order_output = prm.get_bool("Write higher order output");
-
-          if (write_higher_order_output == true)
-            {
-              AssertThrow(output_format == "vtu",
-                          ExcMessage("The option 'Postprocess/Visualization/Write higher order output' requires the "
-                                     "data output format to be set to 'vtu'."));
-              AssertThrow(interpolate_output == true,
-                          ExcMessage("The input parameter 'Postprocess/Visualization/Write higher order output' "
-                                     "requires the input parameter 'Interpolate output' to be set to 'true'."));
-            }
-
-          output_mesh_velocity = prm.get_bool("Output mesh velocity");
-          output_mesh_displacement = prm.get_bool("Output mesh displacement");
-          output_undeformed_mesh = prm.get_bool("Output undeformed mesh");
-
-          output_base_variables_on_mesh_surface = prm.get_bool("Output base variables on mesh surface");
-
-          // now also see which derived quantities we are to compute
-          viz_names = Utilities::split_string_list(prm.get("List of output variables"));
-          AssertThrow(Utilities::has_unique_entries(viz_names),
-                      ExcMessage("The list of strings for the parameter "
-                                 "'Postprocess/Visualization/List of output variables' contains entries more than once. "
-                                 "This is not allowed. Please check your parameter file."));
-
-          // see if 'all' was selected (or is part of the list). if so
-          // simply replace the list with one that contains all names
-          if (std::find (viz_names.begin(),
-                         viz_names.end(),
-                         "all") != viz_names.end())
-            {
-              viz_names.clear();
-              for (typename std::list<typename aspect::internal::Plugins::PluginList<VisualizationPostprocessors::Interface<dim>>::PluginInfo>::const_iterator
-                   p = std::get<dim>(registered_visualization_plugins).plugins->begin();
-                   p != std::get<dim>(registered_visualization_plugins).plugins->end(); ++p)
-                viz_names.push_back (std::get<0>(*p));
-            }
-
-          // Unify material property visualization plugins into the 'material properties'
-          // plugin to avoid duplicated code and multiple calls to the material model
-          prm.enter_subsection("Material properties");
-          {
-            bool material_properties_enabled = std::find(viz_names.begin(),
-                                                         viz_names.end(),
-                                                         "material properties") != viz_names.end() ;
-
-            std::set<std::string> deprecated_postprocessors = {"density",
-                                                               "specific heat",
-                                                               "thermal conductivity",
-                                                               "thermal diffusivity",
-                                                               "thermal expansivity",
-                                                               "viscosity"
-                                                              };
-
-            // For all selected visualization plugins
-            auto plugin_name = viz_names.begin();
-            while (plugin_name != viz_names.end())
-              {
-                // Check if the current name is in the set of the deprecated names
-                if (deprecated_postprocessors.count(*plugin_name) != 0)
-                  {
-                    // If there is no 'material properties' yet
-                    if (material_properties_enabled == false)
-                      {
-                        // Set the current property name as the parameter for 'material properties'
-                        prm.set("List of material properties",*plugin_name);
-                        // Then replace the currently selected plugin with 'material properties'
-                        *plugin_name = "material properties";
-                        material_properties_enabled = true;
-                        ++plugin_name;
-                      }
-                    else
-                      {
-                        // Add the current property name to the parameter of 'material properties'
-                        std::string new_property_names = prm.get("List of material properties") + ", " + *plugin_name;
-                        prm.set("List of material properties",new_property_names);
-                        // Then delete the current plugin
-                        plugin_name = viz_names.erase(plugin_name);
-                      }
-                  }
-                else
-                  ++plugin_name;
-              }
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // then go through the list, create objects and let them parse
-      // their own parameters
-      for (const auto &viz_name : viz_names)
-        {
-          std::unique_ptr<VisualizationPostprocessors::Interface<dim>>
-          viz_postprocessor = std::get<dim>(registered_visualization_plugins)
-                              .create_plugin (viz_name,
-                                              "Visualization plugins");
-
-          // make sure that the postprocessor is indeed of type
-          // dealii::DataPostprocessor or of type
-          // VisualizationPostprocessors::CellDataVectorCreator
-          Assert ((dynamic_cast<DataPostprocessor<dim>*>(viz_postprocessor.get())
-                   != nullptr)
-                  ||
-                  (dynamic_cast<VisualizationPostprocessors::CellDataVectorCreator<dim>*>(viz_postprocessor.get())
-                   != nullptr)
-                  ,
-                  ExcMessage ("Can't convert visualization postprocessor to type "
-                              "dealii::DataPostprocessor or "
-                              "VisualizationPostprocessors::CellDataVectorCreator!?"));
-
-          postprocessors.emplace_back (std::move(viz_postprocessor));
-
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(postprocessors.back().get()))
-            sim->initialize_simulator (this->get_simulator());
-
-          postprocessors.back()->parse_parameters (prm);
-          postprocessors.back()->initialize ();
-        }
-
-      // Finally also set up a listener to check when the mesh changes
-      cell_output_history.mesh_changed = true;
-      face_output_history.mesh_changed = true;
-      this->get_triangulation().signals.post_refinement.connect(
-        [&]()
-      {
-        this->mesh_changed_signal();
-      });
-    }
-
-
-
-    template <int dim>
-    template <class Archive>
-    void Visualization<dim>::serialize (Archive &ar, const unsigned int)
-    {
-      ar &last_output_time
-      & last_output_timestep
-      & output_file_number
-      & cell_output_history
-      & face_output_history
-      ;
-    }
-
-
-    template <int dim>
-    void
-    Visualization<dim>::save (std::map<std::string, std::string> &status_strings) const
-    {
-      std::ostringstream os;
-      aspect::oarchive oa (os);
-      oa << (*this);
-
-      status_strings["Visualization"] = os.str();
-
-//TODO: do something about the visualization postprocessor plugins
-    }
-
-
-    template <int dim>
-    void
-    Visualization<dim>::load (const std::map<std::string, std::string> &status_strings)
-    {
-      // see if something was saved
-      if (status_strings.find("Visualization") != status_strings.end())
-        {
-          std::istringstream is (status_strings.find("Visualization")->second);
-          aspect::iarchive ia (is);
-          ia >> (*this);
-        }
-
-//TODO: do something about the visualization postprocessor plugins
-    }
-
-
-    template <int dim>
-    void
-    Visualization<dim>::set_last_output_time (const double current_time)
-    {
-      // if output_interval is positive, then update the last supposed output
-      // time
-      if (output_interval > 0)
-        {
-          // We need to find the last time output was supposed to be written.
-          // this is the last_output_time plus the largest positive multiple
-          // of output_intervals that passed since then. We need to handle the
-          // edge case where last_output_time+output_interval==current_time,
-          // we did an output and std::floor sadly rounds to zero. This is done
-          // by forcing std::floor to round 1.0-eps to 1.0.
-          const double magic = 1.0+2.0*std::numeric_limits<double>::epsilon();
-          last_output_time = last_output_time + std::floor((current_time-last_output_time)/output_interval*magic) * output_interval/magic;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    Visualization<dim>::
-    register_visualization_postprocessor (const std::string &name,
-                                          const std::string &description,
-                                          void (*declare_parameters_function) (ParameterHandler &),
-                                          std::unique_ptr<VisualizationPostprocessors::Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_visualization_plugins).register_plugin (name,
-                                                                       description,
-                                                                       declare_parameters_function,
-                                                                       factory_function);
-    }
-
-
-
-    template <int dim>
-    std::list<std::string>
-    Visualization<dim>::required_other_postprocessors () const
-    {
-      std::list<std::string> requirements;
-
-      // loop over all of the viz postprocessors and collect what
-      // they want. don't worry about duplicates, the postprocessor
-      // manager will filter them out
-      for (const auto &p : postprocessors)
-        {
-          const std::list<std::string> this_requirements = p->required_other_postprocessors();
-          requirements.insert (requirements.end(),
-                               this_requirements.begin(), this_requirements.end());
-        }
-
-      return requirements;
-    }
-
-
-
-    template <int dim>
-    bool
-    Visualization<dim>::output_pointwise_stress_and_strain () const
-    {
-      return pointwise_stress_and_strain;
-    }
-
-
-
-    template <int dim>
-    void
-    Visualization<dim>::write_plugin_graph (std::ostream &out)
-    {
-      // in contrast to all other plugins, the visualization
-      // postprocessors do not actually connect to the central
-      // Simulator class, but they are a sub-system of
-      // the Postprocessor plugin system. indicate this
-      // through the last argument of the function call
-      std::get<dim>(registered_visualization_plugins)
-      .write_plugin_graph ("Visualization postprocessor interface",
-                           out,
-                           typeid(Visualization<dim>).name());
-    }
-
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class CellDataVectorCreator<dim>;
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<Postprocess::VisualizationPostprocessors::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<Postprocess::VisualizationPostprocessors::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<Postprocess::VisualizationPostprocessors::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<Postprocess::VisualizationPostprocessors::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(Visualization,
-                                  "visualization",
-                                  "A postprocessor that takes the solution and writes "
-                                  "it into files that can be read by a graphical "
-                                  "visualization program. Additional run time parameters "
-                                  "are read from the parameter subsection 'Visualization'.")
-  }
-}
diff --git a/source/postprocess/visualization/ISA_rotation_timescale.cc.bak b/source/postprocess/visualization/ISA_rotation_timescale.cc.bak
deleted file mode 100644
index bb7a48614c7..00000000000
--- a/source/postprocess/visualization/ISA_rotation_timescale.cc.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/ISA_rotation_timescale.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/symmetric_tensor.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      ISARotationTimescale<dim>::
-      ISARotationTimescale ()
-        :
-        CellDataVectorCreator<dim>("s")
-      {}
-
-
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      ISARotationTimescale<dim>::execute() const
-      {
-        std::pair<std::string, std::unique_ptr<Vector<float>>> return_value("ISA_rotation_timescale",
-                                                                              std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-
-        const QMidpoint<dim> quadrature_formula;
-        const unsigned int n_q_points = quadrature_formula.size();
-
-        FEValues<dim> fe_values(this->get_mapping(), this->get_fe(),
-                                quadrature_formula,
-                                update_values | update_gradients | update_quadrature_points);
-
-        // Set up material models
-        MaterialModel::MaterialModelInputs<dim> in(n_q_points,
-                                                   this->n_compositional_fields());
-
-        // Loop over cells and calculate tauISA in each one
-        // Note that we start after timestep 0 because we need the strain rate,
-        // which doesn't exist during the initial step
-        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned() && this->get_timestep_number() > 0)
-            {
-
-              // Fill the material model objects for the cell (for strain rate)
-              fe_values.reinit(cell);
-              in.reinit(fe_values, cell, this->introspection(),
-                        this->get_solution());
-
-              // Calculate eigenvalues of strain rate and take maximum (absolute value)
-              // to get tauISA, the timescale for grain rotation toward the infinite strain axis
-              const SymmetricTensor<2, dim> strain_rate = in.strain_rate[0];
-              const std::array<double, dim> strain_rate_eigenvalues = eigenvalues(
-                                                                        strain_rate);
-              const double lambda1 = std::max(std::abs(strain_rate_eigenvalues[0]),
-                                              std::abs(strain_rate_eigenvalues[dim-1]));
-              const double tauISA = 1.0 / lambda1;
-
-              (*return_value.second)(cell->active_cell_index()) = tauISA;
-            }
-
-        return return_value;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ISARotationTimescale,
-                                                  "ISA rotation timescale",
-                                                  "A visualization output object that generates output "
-                                                  "showing the timescale for the rotation of grains "
-                                                  "toward the infinite strain axis. Kaminski and Ribe "
-                                                  "(see \\cite{Kaminski2002}) call this quantity "
-                                                  "$\\tau_\\text{ISA}$ and define it as "
-                                                  "$\\tau_\\text{ISA} \\approx \\frac{1}{\\dot{\\epsilon}}$ "
-                                                  "where $\\dot{\\epsilon}$ is the largest eigenvalue "
-                                                  "of the strain rate tensor. It can be used, "
-                                                  "along with the grain lag angle $\\Theta$, "
-                                                  "to calculate the grain orientation lag parameter."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\second}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/adiabat.cc.bak b/source/postprocess/visualization/adiabat.cc.bak
deleted file mode 100644
index 5e399d6de6c..00000000000
--- a/source/postprocess/visualization/adiabat.cc.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/adiabat.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      Adiabat<dim>::
-      Adiabat ()
-        :
-        DataPostprocessor<dim> (),
-        Interface<dim>("K,Pa,kg/m/m/m,kg/m/m/m/m")
-      {}
-
-
-
-      template <int dim>
-      std::vector<std::string>
-      Adiabat<dim>::
-      get_names () const
-      {
-        std::vector<std::string> solution_names;
-        solution_names.emplace_back("adiabatic_temperature");
-        solution_names.emplace_back("adiabatic_pressure");
-        solution_names.emplace_back("adiabatic_density");
-        solution_names.emplace_back("adiabatic_density_derivative");
-        return solution_names;
-      }
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      Adiabat<dim>::
-      get_data_component_interpretation () const
-      {
-        std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretation(4,
-            DataComponentInterpretation::component_is_scalar);
-
-        return interpretation;
-      }
-
-
-      template <int dim>
-      UpdateFlags
-      Adiabat<dim>::
-      get_needed_update_flags () const
-      {
-        return update_quadrature_points;
-      }
-
-
-      template <int dim>
-      void
-      Adiabat<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == 4,                   ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            computed_quantities[q](0) = this->get_adiabatic_conditions().temperature(input_data.evaluation_points[q]);
-            computed_quantities[q](1) = this->get_adiabatic_conditions().pressure(input_data.evaluation_points[q]);
-            computed_quantities[q](2) = this->get_adiabatic_conditions().density(input_data.evaluation_points[q]);
-            computed_quantities[q](3) = this->get_adiabatic_conditions().density_derivative(input_data.evaluation_points[q]);
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Adiabat,
-                                                  "adiabat",
-                                                  "A visualization output "
-                                                  "object that generates "
-                                                  "adiabatic temperature, pressure, "
-                                                  "density, and density derivative (with regard to depth)"
-                                                  "as produced by the \\texttt{AdiabaticConditions} class."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\kelvin}, \\si{\\pascal}, "
-                                                  "\\si{\\kilo\\gram\\per\\meter\\cubed\\per\\meter}, "
-                                                  "respectively, for the four components.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/artificial_viscosity.cc.bak b/source/postprocess/visualization/artificial_viscosity.cc.bak
deleted file mode 100644
index 002ec99d336..00000000000
--- a/source/postprocess/visualization/artificial_viscosity.cc.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/artificial_viscosity.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      ArtificialViscosity<dim>::
-      ArtificialViscosity ()
-        :
-        CellDataVectorCreator<dim>("W/m/K")
-      {}
-
-
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      ArtificialViscosity<dim>::execute() const
-      {
-        std::pair<std::string, std::unique_ptr<Vector<float>>>
-        return_value ("artificial_viscosity",
-                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-        this->get_artificial_viscosity(*return_value.second);
-
-        // The function we call above sets the artificial viscosity to
-        // signaling_nan on all artificial cells and, possibly, ghost cells.
-        // This runs into trouble in DataOut that wants to copy this vector
-        // from Vector<float> to Vector<double>, and the conversion trips
-        // up over the NaNs, causing a floating point exception.
-        //
-        // To avoid this, strip out the NaNs and instead set these values
-        // to zero -- we won't be outputting these values anyway.
-        for (const auto &cell : this->get_triangulation().active_cell_iterators())
-          if (cell->is_locally_owned() == false)
-            (*return_value.second)[cell->active_cell_index()] = 0;
-
-        return return_value;
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ArtificialViscosity,
-                                                  "artificial viscosity",
-                                                  "A visualization output object that generates output "
-                                                  "showing the value of the artificial viscosity on each "
-                                                  "cell."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\watt\\per\\meter\\per\\kelvin}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/artificial_viscosity_composition.cc.bak b/source/postprocess/visualization/artificial_viscosity_composition.cc.bak
deleted file mode 100644
index 61ff63decb3..00000000000
--- a/source/postprocess/visualization/artificial_viscosity_composition.cc.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/artificial_viscosity_composition.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      ArtificialViscosityComposition<dim>::
-      ArtificialViscosityComposition ()
-        :
-        CellDataVectorCreator<dim>("m/s/s")
-      {}
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      ArtificialViscosityComposition<dim>::execute() const
-      {
-        Assert(this->n_compositional_fields()>0,
-               ExcMessage ("The artificial viscosity for compositional fields can "
-                           "only be calculated if compositional fields are used in the simulation."));
-
-        std::pair<std::string, std::unique_ptr<Vector<float>>>
-        return_value ("artificial_viscosity_composition",
-                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-        this->get_artificial_viscosity_composition(*return_value.second, compositional_field);
-
-        // The function we call above sets the artificial viscosity to
-        // signaling_nan on all artificial cells and, possibly, ghost cells.
-        // This runs into trouble in DataOut that wants to copy this vector
-        // from Vector<float> to Vector<double>, and the conversion trips
-        // up over the NaNs, causing a floating point exception.
-        //
-        // To avoid this, strip out the NaNs and instead set these values
-        // to zero -- we won't be outputting these values anyway.
-        for (const auto &cell : this->get_triangulation().active_cell_iterators())
-          if (cell->is_locally_owned() == false)
-            (*return_value.second)[cell->active_cell_index()] = 0;
-
-        return return_value;
-      }
-
-      template <int dim>
-      void
-      ArtificialViscosityComposition<dim>::
-      declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Artificial viscosity composition");
-            {
-              prm.declare_entry ("Name of compositional field", "",
-                                 Patterns::Anything(),
-                                 "The name of the compositional field whose output "
-                                 "should be visualized. ");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-      template <int dim>
-      void
-      ArtificialViscosityComposition<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Artificial viscosity composition");
-            {
-              const std::string field_name = prm.get("Name of compositional field");
-
-              AssertThrow(this->introspection().compositional_name_exists(field_name),
-                          ExcMessage("No compositional field with name <" +
-                                     field_name +
-                                     "> exists for which you want to visualize the artificial viscosity."));
-
-              compositional_field = this->introspection().compositional_index_for_name(field_name);
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ArtificialViscosityComposition,
-                                                  "artificial viscosity composition",
-                                                  "A visualization output object that generates output "
-                                                  "showing the value of the artificial viscosity for a "
-                                                  "compositional field on each cell."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\meter\\squared\\per\\second}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/boundary_indicator.cc.bak b/source/postprocess/visualization/boundary_indicator.cc.bak
deleted file mode 100644
index 9df7639d16e..00000000000
--- a/source/postprocess/visualization/boundary_indicator.cc.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/boundary_indicator.h>
-#include <aspect/geometry_model/interface.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      BoundaryIndicator<dim>::
-      BoundaryIndicator ()
-        :
-        CellDataVectorCreator<dim>("") // no physical units
-      {}
-
-
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      BoundaryIndicator<dim>::execute() const
-      {
-        std::pair<std::string, std::unique_ptr<Vector<float>>>
-        return_value ("boundary_indicator",
-                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-
-        // retrieve the largest used boundary indicator and add one.
-        // this value will be set for internal cells
-        const types::boundary_id largest_boundary_id_plus_one =
-          *this->get_geometry_model().get_used_boundary_indicators().rbegin() + 1;
-
-        // loop over all of the surface cells and extract boundary indicators
-        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              if (cell->at_boundary())
-                {
-                  types::boundary_id boundary_id = largest_boundary_id_plus_one;
-                  for (const unsigned int f : cell->face_indices())
-                    {
-                      if (cell->face(f)->at_boundary())
-                        {
-                          boundary_id
-                            = cell->face(f)->boundary_id();
-                          break;
-                        }
-                    }
-                  (*return_value.second)(cell->active_cell_index()) = static_cast<float> (boundary_id);
-                }
-              // internal cells are all set to the same boundary indicator value
-              // of the largest boundary indicator used for the current geometry plus one.
-              else
-                {
-                  (*return_value.second)(cell->active_cell_index()) = largest_boundary_id_plus_one;
-                }
-            }
-
-        return return_value;
-      }
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(BoundaryIndicator,
-                                                  "boundary indicators",
-                                                  "A visualization output object that generates output "
-                                                  "about the used boundary indicators. In a loop over the active "
-                                                  "cells, if a cell lies at a domain boundary, the boundary indicator "
-                                                  "of the face along the boundary is requested. In case the cell "
-                                                  "does not lie along any domain boundary, the cell is assigned the "
-                                                  "value of the largest used boundary indicator plus one. "
-                                                  "When a cell is situated in one of the corners of the domain, "
-                                                  "multiple faces will have a boundary indicator. This postprocessor "
-                                                  "returns the value of the first face along a boundary that is encountered "
-                                                  "in a loop over all the faces."
-                                                  "\n\n"
-                                                  "Physical units: None.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/boundary_strain_rate_residual.cc.bak b/source/postprocess/visualization/boundary_strain_rate_residual.cc.bak
deleted file mode 100644
index 657cd5d8ac1..00000000000
--- a/source/postprocess/visualization/boundary_strain_rate_residual.cc.bak
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
-  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/postprocess/visualization/boundary_strain_rate_residual.h>
-#include <aspect/postprocess/boundary_strain_rate_residual_statistics.h>
-#include <aspect/simulator.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      BoundaryStrainRateResidual<dim>::
-      BoundaryStrainRateResidual ()
-        :
-        DataPostprocessorScalar<dim> ("boundary_strain_rate_residual",
-                                      update_quadrature_points | update_gradients),
-        Interface<dim>()    // unknown units at construction time, will be filled by a separate function
-      {}
-
-
-
-      template <int dim>
-      std::string
-      BoundaryStrainRateResidual<dim>::
-      get_physical_units () const
-      {
-        if (this->convert_output_to_years())
-          return "1/year";
-        else
-          return "1/s";
-      }
-
-
-
-      template <int dim>
-      void
-      BoundaryStrainRateResidual<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        (void) n_quadrature_points;
-        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,               ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
-
-        auto cell = input_data.template get_cell<dim>();
-
-        for (auto &quantity : computed_quantities)
-          quantity(0)= std::numeric_limits<double>::quiet_NaN();
-
-        const double unit_scaling_factor = this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-        const Postprocess::BoundaryStrainRateResidualStatistics<dim> &boundary_strain_rate_residual_statistics =
-          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::BoundaryStrainRateResidualStatistics<dim>>();
-
-        // We only want the output at the top boundary, so only compute it if the current cell
-        // has a face at the top boundary.
-        bool cell_at_top_boundary = false;
-        for (const unsigned int f : cell->face_indices())
-          if (cell->at_boundary(f) &&
-              (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top"))
-            {
-              cell_at_top_boundary = true;
-              break;
-            }
-
-        if (cell_at_top_boundary)
-          for (unsigned int q=0; q<computed_quantities.size(); ++q)
-            {
-              Tensor<2,dim> grad_u;
-              for (unsigned int d=0; d<dim; ++d)
-                grad_u[d] = input_data.solution_gradients[q][d];
-              const SymmetricTensor<2,dim> strain_rate = symmetrize(grad_u);
-
-              const double data_surface_strain_rate =
-                boundary_strain_rate_residual_statistics.get_data_surface_strain_rate(input_data.evaluation_points[q]);
-
-              // Only compute residual for doubles. This condition checks for nan values
-              if (data_surface_strain_rate < 1e300 || !std::isnan(data_surface_strain_rate))
-                computed_quantities[q](0) = data_surface_strain_rate -
-                                            std::sqrt(std::fabs(second_invariant(deviator(strain_rate)))) * unit_scaling_factor;
-              else
-                continue;
-
-            }
-
-        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
-        if (!viz.output_pointwise_stress_and_strain())
-          average_quantities(computed_quantities);
-
-      }
-
-
-
-      template <int dim>
-      std::list<std::string>
-      BoundaryStrainRateResidual<dim>::required_other_postprocessors() const
-      {
-        return {"boundary strain rate residual statistics"};
-      }
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(BoundaryStrainRateResidual,
-                                                  "boundary strain rate residual",
-                                                  "A visualization output object that generates output for the strain rate "
-                                                  "residual at the top surface. The residual is computed at each point at the "
-                                                  "surface as the difference between the strain rate invariant in the model and the input data, "
-                                                  "where the invariant is computed like in the 'strain rate' postprocessor. The user chooses "
-                                                  "the input data as ascii data files with coordinate columns and column corresponding "
-                                                  "to the surface strain rate norm."
-                                                  "\n\n"
-                                                  "Physical units: $\\frac{1}{\\text{s}}$ or "
-                                                  "$\\frac{1}{\\text{year}}$, depending on settings in the input file.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/boundary_velocity_residual.cc.bak b/source/postprocess/visualization/boundary_velocity_residual.cc.bak
deleted file mode 100644
index 65d3c194cbf..00000000000
--- a/source/postprocess/visualization/boundary_velocity_residual.cc.bak
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/postprocess/visualization/boundary_velocity_residual.h>
-#include <aspect/postprocess/boundary_velocity_residual_statistics.h>
-#include <aspect/simulator.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      BoundaryVelocityResidual<dim>::
-      BoundaryVelocityResidual ()
-        :
-        DataPostprocessorVector<dim> ("boundary_velocity_residual",
-                                      update_values | update_quadrature_points | update_gradients),
-        Interface<dim>()  // unknown units at construction time, will be filled by a separate function
-      {}
-
-
-
-      template <int dim>
-      std::string
-      BoundaryVelocityResidual<dim>::
-      get_physical_units () const
-      {
-        if (this->convert_output_to_years())
-          return "m/year";
-        else
-          return "m/s";
-      }
-
-
-
-      template <int dim>
-      void
-      BoundaryVelocityResidual<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        Assert ((computed_quantities[0].size() == dim), ExcInternalError());
-        for (auto &quantity : computed_quantities)
-          for (unsigned int d = 0; d < dim; ++d)
-            quantity(d)= 0.;
-
-        auto cell = input_data.template get_cell<dim>();
-        const double velocity_scaling_factor =
-          this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-        const Postprocess::BoundaryVelocityResidualStatistics<dim> &boundary_velocity_residual_statistics =
-          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::BoundaryVelocityResidualStatistics<dim>>();
-
-        // We only want the output at the top boundary, so only compute it if the current cell
-        // has a face at the top boundary.
-        bool cell_at_top_boundary = false;
-        for (const unsigned int f : cell->face_indices())
-          if (cell->at_boundary(f) &&
-              (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top"))
-            cell_at_top_boundary = true;
-
-        if (cell_at_top_boundary)
-          for (unsigned int q=0; q<computed_quantities.size(); ++q)
-            {
-              const Tensor<1,dim> data_velocity = boundary_velocity_residual_statistics.get_data_velocity(input_data.evaluation_points[q]);
-              for (unsigned int d = 0; d < dim; ++d)
-                computed_quantities[q](d) = data_velocity[d] - input_data.solution_values[q][d] * velocity_scaling_factor;
-            }
-
-      }
-
-
-
-      template <int dim>
-      std::list<std::string>
-      BoundaryVelocityResidual<dim>::required_other_postprocessors() const
-      {
-        return {"boundary velocity residual statistics"};
-      }
-
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(BoundaryVelocityResidual,
-                                                  "boundary velocity residual",
-                                                  "A visualization output object that generates output for the velocity "
-                                                  "residual at the top surface. The residual is computed at each point at the "
-                                                  "surface as the difference between the modeled velocities and the input "
-                                                  "data velocities for each vector component. The user has an option to choose "
-                                                  "the input data as ascii data files (e.g. GPS velocities) with columns "
-                                                  "in the same format as described for the 'ascii data' initial temperature plugin "
-                                                  "or a velocity field computed from the GPlates program as described in the gplates "
-                                                  "boundary velocity plugin."
-                                                  "\n\n"
-                                                  "Physical units: $\\frac{\\text{m}}{\\text{s}}$ or "
-                                                  "$\\frac{\\text{m}}{\\text{year}}$, depending on settings in the input file.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/compositional_vector.cc.bak b/source/postprocess/visualization/compositional_vector.cc.bak
deleted file mode 100644
index b9f31814dd6..00000000000
--- a/source/postprocess/visualization/compositional_vector.cc.bak
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/postprocess/visualization/compositional_vector.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      CompositionalVector<dim>::
-      CompositionalVector ()
-        :
-        DataPostprocessor<dim> (),
-        Interface<dim>("")  // we don't associate these objects with physical units
-      {}
-
-
-
-      template <int dim>
-      std::vector<std::string>
-      CompositionalVector<dim>::
-      get_names () const
-      {
-        std::vector<std::string> solution_names;
-        for (const auto &vector_name : vector_names)
-          for (unsigned int j=0; j<dim; ++j)
-            solution_names.push_back(vector_name);
-        return solution_names;
-      }
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      CompositionalVector<dim>::
-      get_data_component_interpretation () const
-      {
-        return std::vector<DataComponentInterpretation::DataComponentInterpretation>
-               (vector_names.size()*dim,
-                DataComponentInterpretation::component_is_part_of_vector);
-      }
-
-
-      template <int dim>
-      UpdateFlags
-      CompositionalVector<dim>::
-      get_needed_update_flags () const
-      {
-        return update_values;
-      }
-
-
-      template <int dim>
-      void
-      CompositionalVector<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError ());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError ());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            for (unsigned int i=0; i<vector_names.size(); ++i)
-              for (unsigned int j=0; j<dim; ++j)
-                computed_quantities[q][i*dim+j] =
-                  input_data.solution_values[q][this->introspection().component_indices.compositional_fields[sets[i][j]]];
-          }
-      }
-
-
-      template <int dim>
-      void
-      CompositionalVector<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Compositional fields as vectors");
-            {
-              prm.declare_entry("Names of vectors", "",
-                                Patterns::List (Patterns::Anything()),
-                                "Names of vectors as they will appear in the output.");
-
-              prm.declare_entry("Names of fields", "",
-                                Patterns::Anything (),
-                                "A list of sets of compositional fields which should be output "
-                                "as vectors. Sets are separated from each other by semicolons "
-                                "and vector components within each set are separated by commas "
-                                "(e.g. $vec1_x$, $vec1_y$ ; $vec2_x$, $vec2_y$) where each name must be "
-                                "a defined named compositional field. If only one name is given "
-                                "in a set, it is interpreted as the first in a sequence of dim "
-                                "consecutive compositional fields.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      CompositionalVector<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Compositional fields as vectors");
-            {
-              vector_names = Utilities::split_string_list(prm.get("Names of vectors"), ',');
-
-              const std::vector<std::string> sets_list = Utilities::split_string_list(prm.get("Names of fields"), ';');
-              for (const auto &set_string : sets_list)
-                {
-                  const std::vector<std::string> set = Utilities::split_string_list(set_string, ',');
-                  AssertThrow((set.size() == dim || set.size() == 1),
-                              ExcMessage("Sets of compositional fields to be output as vectors must have dim components, "
-                                         "or one component (i.e. the first field in a sequence of dim consecutive fields)."));
-
-                  std::vector<unsigned int> set_idx;
-                  for (const auto &name : set)
-                    {
-                      AssertThrow(this->introspection().compositional_name_exists (name),
-                                  ExcMessage("All fields in compositional vector sets must match names of compositional "
-                                             "fields as assigned in the \"Compositional fields/Names of fields\" parameter."));
-                      set_idx.push_back(this->introspection().compositional_index_for_name(name));
-                    }
-
-                  while (set_idx.size() < dim)
-                    {
-                      AssertThrow(set_idx[0]+set_idx.size() < this->n_compositional_fields(),
-                                  ExcMessage(set[0] + " must be the first in a sequence of dim compositional fields to be "
-                                             "interpreted as a vector. You have too few compositional fields."));
-                      set_idx.push_back(set_idx[0]+set_idx.size());
-                    }
-                  sets.push_back(set_idx);
-                }
-
-              AssertThrow(vector_names.size() == sets.size(),
-                          ExcMessage("You must define names for each of the sets of compositional fields which will "
-                                     "be output as vectors, and the length of that list must match the number of vectors."));
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(CompositionalVector,
-                                                  "compositional vector",
-                                                  "A visualization output object that outputs vectors whose "
-                                                  "components are derived from compositional fields. Input "
-                                                  "parameters for this postprocessor are defined in section "
-                                                  "Postprocess/Visualization/Compositional fields as vectors."
-                                                  "\n\n"
-                                                  "Physical units: None.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/depth.cc.bak b/source/postprocess/visualization/depth.cc.bak
deleted file mode 100644
index 8da0bf3f9ad..00000000000
--- a/source/postprocess/visualization/depth.cc.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/depth.h>
-#include <aspect/geometry_model/interface.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      Depth<dim>::
-      Depth ()
-        :
-        DataPostprocessorScalar<dim> ("depth",
-                                      update_quadrature_points),
-        Interface<dim>("m")
-      {}
-
-
-
-      template <int dim>
-      void
-      Depth<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            computed_quantities[q](0) = this->get_geometry_model().depth (input_data.evaluation_points[q]);
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Depth,
-                                                  "depth",
-                                                  "A visualization output postprocessor that outputs "
-                                                  "the depth for all points inside the domain, as "
-                                                  "determined by the geometry model."
-                                                  "\n\n"
-                                                  "It is worth comparing this visualization postprocessor with the "
-                                                  "one called ``surface elevation''. The current one is used to visualize a volume "
-                                                  "variable, whereas the latter only outputs information on "
-                                                  "the surface. Moreover ``depth'' is based on a member function of "
-                                                  "the geometry models that is documented as never returning a "
-                                                  "number less than zero -- in other words, it returns the depth "
-                                                  "of an evaluation point with regard to a reference surface that "
-                                                  "defines a zero depth, but for points that lie above this "
-                                                  "reference surface, it returns zero. As a consequence, it cannot "
-                                                  "be used to visualize positive elevations, whereas the the one "
-                                                  "called ``surface elevation'' can."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\meter}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/dynamic_topography.cc.bak b/source/postprocess/visualization/dynamic_topography.cc.bak
deleted file mode 100644
index 01817ddd267..00000000000
--- a/source/postprocess/visualization/dynamic_topography.cc.bak
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/postprocess/visualization/dynamic_topography.h>
-#include <aspect/postprocess/dynamic_topography.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      DynamicTopography<dim>::
-      DynamicTopography ()
-        :
-        DataPostprocessorScalar<dim> ("dynamic_topography",
-                                      update_quadrature_points),
-        Interface<dim>("m")
-      {}
-
-
-
-      template <int dim>
-      void
-      DynamicTopography<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        // Initialize everything to zero, so that we can ignore faces we are
-        // not interested in (namely, those not labeled as 'top' or 'bottom'
-        for (auto &quantity : computed_quantities)
-          quantity(0) = 0;
-
-        const Postprocess::DynamicTopography<dim> &dynamic_topography =
-          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<dim>>();
-
-        auto cell = input_data.template get_cell<dim>();
-
-        // We only want to output dynamic topography at the top and bottom
-        // boundary, so only compute it if the current cell has
-        // a face at the top or bottom boundary.
-        bool cell_at_top_or_bottom_boundary = false;
-        for (const unsigned int f : cell->face_indices())
-          if (cell->at_boundary(f) &&
-              (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top" ||
-               this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "bottom"))
-            cell_at_top_or_bottom_boundary = true;
-
-        if (cell_at_top_or_bottom_boundary)
-          {
-            std::vector<Point<dim>> quadrature_points(input_data.evaluation_points.size());
-            for (unsigned int i=0; i<input_data.evaluation_points.size(); ++i)
-              quadrature_points[i] = this->get_mapping().transform_real_to_unit_cell(cell,input_data.evaluation_points[i]);
-
-            const Quadrature<dim> quadrature_formula(quadrature_points);
-
-            FEValues<dim> fe_volume_values (this->get_mapping(),
-                                            this->get_fe(),
-                                            quadrature_formula,
-                                            update_values);
-
-            fe_volume_values.reinit(cell);
-
-            std::vector<double> dynamic_topography_values(quadrature_formula.size());
-
-            // It might seem unintuitive to use the extractor for the temperature block,
-            // but that is where dynamic_topography.topography_vector() stores the values.
-            // See the documentation of that function for more details.
-            fe_volume_values[this->introspection().extractors.temperature].get_function_values(dynamic_topography.topography_vector(),
-                dynamic_topography_values);
-
-            for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-              computed_quantities[q](0) = dynamic_topography_values[q];
-          }
-      }
-
-
-
-      /**
-       * Register the other postprocessor that we need: DynamicTopography
-       */
-      template <int dim>
-      std::list<std::string>
-      DynamicTopography<dim>::required_other_postprocessors() const
-      {
-        return {"dynamic topography"};
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(DynamicTopography,
-                                                  "dynamic topography",
-                                                  "A visualization output object that generates output "
-                                                  "for the dynamic topography at the top and bottom of the model space. "
-                                                  "The actual computation of this topography is handled inside the "
-                                                  "'dynamic topography' postprocessor, please check its documentation "
-                                                  "for details about the numerical methods."
-                                                  "\n\n"
-                                                  "Strictly speaking, the dynamic topography is of course a "
-                                                  "quantity that is only of interest at the surface. However, "
-                                                  "we compute it everywhere to make things fit into the framework "
-                                                  "within which we produce data for visualization. You probably "
-                                                  "only want to visualize whatever data this postprocessor generates "
-                                                  "at the surface of your domain and simply ignore the rest of the "
-                                                  "data generated."
-                                                  "\n\n"
-                                                  "Alternatively, consider using the "
-                                                  "\"surface dynamic topography\" visualization postprocessor "
-                                                  "to only output the dynamic topography at the boundary of "
-                                                  "the domain."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\meter}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/error_indicator.cc.bak b/source/postprocess/visualization/error_indicator.cc.bak
deleted file mode 100644
index fbbf5a7494e..00000000000
--- a/source/postprocess/visualization/error_indicator.cc.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/error_indicator.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      ErrorIndicator<dim>::
-      ErrorIndicator ()
-        :
-        CellDataVectorCreator<dim>("")
-      {}
-
-
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      ErrorIndicator<dim>::execute() const
-      {
-        std::pair<std::string, std::unique_ptr<Vector<float>>>
-        return_value ("error_indicator",
-                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-        this->get_refinement_criteria(*return_value.second);
-
-        return return_value;
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ErrorIndicator,
-                                                  "error indicator",
-                                                  "A visualization output object that generates output "
-                                                  "showing the estimated error or other mesh refinement "
-                                                  "indicator as a spatially variable function with one "
-                                                  "value per cell."
-                                                  "\n\n"
-                                                  "Physical units: None. (Strictly speaking, errors have "
-                                                  "physical units of course, but because error "
-                                                  "\\textit{indicators} can be computed from different "
-                                                  "solution components and other input, we consider "
-                                                  "error indicators unitless.)")
-
-    }
-  }
-}
diff --git a/source/postprocess/visualization/geoid.cc.bak b/source/postprocess/visualization/geoid.cc.bak
deleted file mode 100644
index d7af2b2fafc..00000000000
--- a/source/postprocess/visualization/geoid.cc.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/postprocess/visualization/geoid.h>
-#include <aspect/citation_info.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      Geoid<dim>::
-      Geoid ()
-        :
-        DataPostprocessorScalar<dim> ("geoid",
-                                      update_quadrature_points),
-        Interface<dim>("m")
-      {}
-
-
-
-      template <int dim>
-      void
-      Geoid<dim>::
-      initialize()
-      {
-        CitationInfo::add("geoid");
-      }
-
-
-
-      template <int dim>
-      void
-      Geoid<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>>(this->get_geometry_model()),
-                     ExcMessage("The geoid postprocessor is currently only implemented for "
-                                "the spherical shell geometry model."));
-
-        for (auto &quantity : computed_quantities)
-          quantity(0) = 0;
-
-        const Postprocess::Geoid<dim> &geoid =
-          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Geoid<dim>>();
-
-        auto cell = input_data.template get_cell<dim>();
-
-        bool cell_at_top_boundary = false;
-        for (const unsigned int f : cell->face_indices())
-          if (cell->at_boundary(f) &&
-              this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top")
-            cell_at_top_boundary = true;
-
-        if (cell_at_top_boundary)
-          for (unsigned int q=0; q<input_data.evaluation_points.size(); ++q)
-            computed_quantities[q](0) = geoid.evaluate(input_data.evaluation_points[q]);
-      }
-
-      template <int dim>
-      std::list<std::string>
-      Geoid<dim>::required_other_postprocessors() const
-      {
-        return {"geoid"};
-      }
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Geoid,
-                                                  "geoid",
-                                                  "Visualization for the geoid solution. The geoid is given "
-                                                  "by the equivalent water column height due to a gravity perturbation. "
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\meter}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/grain_lag_angle.cc.bak b/source/postprocess/visualization/grain_lag_angle.cc.bak
deleted file mode 100644
index e1983a603a5..00000000000
--- a/source/postprocess/visualization/grain_lag_angle.cc.bak
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/grain_lag_angle.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/symmetric_tensor.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      GrainLagAngle<dim>::
-      GrainLagAngle ()
-        :
-        CellDataVectorCreator<dim>("radian")
-      {}
-
-
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      GrainLagAngle<dim>::execute() const
-      {
-        std::pair<std::string, std::unique_ptr<Vector<float>>> return_value("grain_lag_angle",
-                                                                              std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-
-        const QMidpoint<dim> quadrature_formula;
-        const unsigned int n_q_points = quadrature_formula.size(); // this is 1 for QMidpoint
-
-        FEValues<dim> fe_values(this->get_mapping(), this->get_fe(),
-                                quadrature_formula,
-                                update_values | update_gradients | update_quadrature_points);
-
-        // Set up material models
-        MaterialModel::MaterialModelInputs<dim> in(n_q_points,
-                                                   this->n_compositional_fields());
-
-        // Loop over cells and calculate theta in each one
-        // Note that we start after timestep 0 because we need the strain rate,
-        // which doesn't exist during the initial step
-        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned() && this->get_timestep_number() > 0)
-            {
-              // Fill the material model objects for the cell (for strain rate)
-              fe_values.reinit(cell);
-              in.reinit(fe_values, cell, this->introspection(),
-                        this->get_solution());
-              // Also get velocity gradients
-              std::vector<Tensor<2, dim>> velocity_gradient(n_q_points,
-                                                             Tensor<2, dim>());
-              fe_values[this->introspection().extractors.velocities].get_function_gradients(
-                this->get_solution(), velocity_gradient);
-
-              // Calculate eigenvalues of strain rate and take maximum (absolute value)
-              // to get tauISA, the timescale for grain rotation toward the infinite strain axis
-              const SymmetricTensor<2, dim> strain_rate = in.strain_rate[0];
-              const std::array<double, dim> strain_rate_eigenvalues = eigenvalues(
-                                                                        strain_rate);
-
-              const double lambda1 = std::max(std::abs(strain_rate_eigenvalues[0]),
-                                              std::abs(strain_rate_eigenvalues[dim-1]));
-              const double tauISA = 1.0 / lambda1;
-
-              // Next, we want the ~infinite strain axis, so we start by
-              // calculating the deformation gradient tensor in the limit of "infinite"
-              // time using the velocity gradient tensor. The deformation gradient tensor (F) obeys
-              // dF/dt = LF
-              // where L is the velocity gradient tensor, and F(t=0) = I. The solution to this is
-              // F = exp(Lt)
-              // which can be written as an infinite sum:
-              // F = I + Lt + L^2*t^2/2! + L^3*t^3/3! + ...
-              // and then the "left stretch" tensor is U = F * F^T
-              // We truncate the series sum at the L^4 term. Note that L is sometimes
-              // taken to be the strain rate tensor (ie the velocity gradient without
-              // the rotational component).
-              // The eigenvectors of U are the directions of the major axes of the finite
-              // strain ellipsoid, so for the *infinite* strain axis, we want the eigenvector
-              // corresponding to the largest eigenvalue of U in the limit as t->infinity.
-              // As per Kaminski and Ribe (2002), tmax = 75*tauISA is infinite enough for
-              // most applications.
-              const unsigned int maxorder = 4; // truncate at L^4
-              Tensor<2, dim> F = unit_symmetric_tensor<dim, double>(); // initialize as identity (first term of sum)
-              const double tmax = 75 * tauISA; // "infinite" time
-
-              for (unsigned int i = 1; i <= maxorder; ++i) // loop and calculate terms of sum
-                {
-                  Tensor<2, dim> multiplier = unit_symmetric_tensor<dim, double>();  // to collect powers of L
-                  double factor = 1.0;  // to collect powers of tmax and factorials
-                  for (unsigned int j = 0; j < i; ++j)
-                    {
-                      multiplier = multiplier
-                                   * Tensor<2, dim>(velocity_gradient[0]);
-                      factor *= tmax / (j + 1);
-                    }
-                  multiplier = factor * multiplier;
-                  F += multiplier;  // sum terms
-                }
-
-              // The "left stretch" tensor is computed from the deformation gradient tensor
-              // Note that Kaminski and Ribe incorrectly wrote U=Ft*F (typo, I guess).
-              const Tensor<2, dim> Ft = transpose(F);
-              const SymmetricTensor<2, dim> U = SymmetricTensor<2, dim>(F * Ft);
-              // The ~infinite strain axis is the first eigenvector of the "left stretch" tensor.
-              const Tensor<1, dim> ehat = eigenvectors(U)[0].second;
-              // Calculate theta by dotting the ISA (ehat) and the velocity (scaled to a unit vector)
-              // theta is limited to be less than pi/2 (stay in the first quadrant)
-              const double umag = in.velocity[0].norm();
-              double theta_val = 0;
-              if (umag > 100.0 * std::numeric_limits<double>::min())
-                {
-                  double dotprod = 0;
-                  for (unsigned int iq = 0; iq < dim; ++iq)
-                    {
-                      dotprod = dotprod + in.velocity[0][iq]*ehat[iq];
-                    }
-                  theta_val = std::acos(std::abs(dotprod / umag));
-                  if (theta_val > numbers::PI/2)
-                    theta_val = std::fmod(theta_val, numbers::PI/2);
-                }
-              (*return_value.second)(cell->active_cell_index()) = theta_val;
-            }
-
-        return return_value;
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(GrainLagAngle,
-                                                  "grain lag angle",
-                                                  "A visualization output object that generates output "
-                                                  "showing the angle between the ~infinite strain axis "
-                                                  "and the flow velocity. Kaminski and Ribe "
-                                                  "(see \\cite{Kaminski2002}) call this quantity $\\Theta$ and "
-                                                  "define it as "
-                                                  "$\\Theta = \\cos^{-1}(\\hat{u}\\cdot\\hat{e})$ "
-                                                  " where $\\hat{u}=\\vec{u}/|{u}|$, $\\vec{u}$ "
-                                                  "is the local flow velocity, and "
-                                                  "$\\hat{e}$ is the local infinite strain axis, "
-                                                  "which we calculate as the first eigenvector of "
-                                                  "the 'left stretch' tensor. "
-                                                  "$\\Theta$ can be used to calculate the grain "
-                                                  "orientation lag parameter."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\radian}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/gravity.cc.bak b/source/postprocess/visualization/gravity.cc.bak
deleted file mode 100644
index c353c53f67f..00000000000
--- a/source/postprocess/visualization/gravity.cc.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/gravity.h>
-#include <aspect/gravity_model/interface.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      Gravity<dim>::
-      Gravity ()
-        :
-        DataPostprocessorVector<dim> ("gravity",
-                                      update_quadrature_points),
-        Interface<dim>("m/s/s")
-      {}
-
-
-
-      template <int dim>
-      void
-      Gravity<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.evaluation_points.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == dim,    ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            const Tensor<1,dim> g = this->get_gravity_model().gravity_vector (input_data.evaluation_points[q]);
-            for (unsigned int k=0; k<dim; ++k)
-              computed_quantities[q](k) = g[k];
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Gravity,
-                                                  "gravity",
-                                                  "A visualization output object that outputs the gravity vector."
-                                                  "\n\n"
-                                                  "Physical units: \\si {\\meter\\per\\second\\squared} .")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/heat_flux_map.cc.bak b/source/postprocess/visualization/heat_flux_map.cc.bak
deleted file mode 100644
index 3cb9a94d656..00000000000
--- a/source/postprocess/visualization/heat_flux_map.cc.bak
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/heat_flux_map.h>
-#include <aspect/postprocess/heat_flux_map.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      HeatFluxMap<dim>::
-      HeatFluxMap ()
-        :
-        DataPostprocessorScalar<dim> ("heat_flux_map",
-                                      update_quadrature_points),
-        Interface<dim>("W/m/m")
-      {}
-
-
-
-      template <int dim>
-      void
-      HeatFluxMap<dim>::update ()
-      {
-        if (output_point_wise_heat_flux)
-          heat_flux_density_solution = Postprocess::internal::compute_dirichlet_boundary_heat_flux_solution_vector(*this);
-        else
-          heat_flux_and_area = internal::compute_heat_flux_through_boundary_faces (*this);
-      }
-
-
-
-      template <int dim>
-      void
-      HeatFluxMap<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        for (auto &quantity : computed_quantities)
-          quantity(0) = 0;
-
-        auto cell = input_data.template get_cell<dim>();
-
-        if (output_point_wise_heat_flux)
-          {
-            bool cell_at_top_or_bottom_boundary = false;
-            for (const unsigned int f : cell->face_indices())
-              if (cell->at_boundary(f) &&
-                  (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top" ||
-                   this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "bottom"))
-                cell_at_top_or_bottom_boundary = true;
-
-            if (cell_at_top_or_bottom_boundary)
-              {
-                std::vector<Point<dim>> quadrature_points(input_data.evaluation_points.size());
-                for (unsigned int i=0; i<input_data.evaluation_points.size(); ++i)
-                  quadrature_points[i] = this->get_mapping().transform_real_to_unit_cell(cell,input_data.evaluation_points[i]);
-
-                const Quadrature<dim> quadrature_formula(quadrature_points);
-
-                FEValues<dim> fe_volume_values (this->get_mapping(),
-                                                this->get_fe(),
-                                                quadrature_formula,
-                                                update_values);
-
-                fe_volume_values.reinit(cell);
-
-                std::vector<double> heat_flux_values(quadrature_formula.size());
-                fe_volume_values[this->introspection().extractors.temperature].get_function_values(heat_flux_density_solution, heat_flux_values);
-
-                for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-                  computed_quantities[q](0) = heat_flux_values[q];
-              }
-          }
-        else
-          {
-            double heat_flux = 0.0;
-
-            for (const unsigned int f : cell->face_indices())
-              if (cell->at_boundary(f) &&
-                  (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top" ||
-                   this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "bottom"))
-                {
-                  // add heatflow for this face
-                  heat_flux += heat_flux_and_area[cell->active_cell_index()][f].first /
-                               heat_flux_and_area[cell->active_cell_index()][f].second;
-                }
-
-            for (auto &quantity : computed_quantities)
-              quantity(0) = heat_flux;
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      HeatFluxMap<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Heat flux map");
-            {
-              prm.declare_entry("Output point wise heat flux",
-                                "false",
-                                Patterns::Bool(),
-                                "A boolean flag that controls whether to output the "
-                                "heat flux map as a point wise value, or as a cell-wise "
-                                "averaged value. The point wise output is more "
-                                "accurate, but it currently omits prescribed heat "
-                                "flux values at boundaries and advective heat flux "
-                                "that is caused by velocities non-tangential to boundaries. "
-                                "If you do not use these two features it is recommended "
-                                "to switch this setting on to benefit from the increased "
-                                "output resolution.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-      template <int dim>
-      void
-      HeatFluxMap<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Heat flux map");
-            {
-              output_point_wise_heat_flux = prm.get_bool("Output point wise heat flux");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(HeatFluxMap,
-                                                  "heat flux map",
-                                                  "A visualization output object that generates output for "
-                                                  "the heat flux density across the top and bottom boundary "
-                                                  "in outward direction. "
-                                                  "The heat flux is computed as sum "
-                                                  "of advective heat flux and conductive heat "
-                                                  "flux through Neumann boundaries, both "
-                                                  "computed as integral over the boundary area, "
-                                                  "and conductive heat flux through Dirichlet "
-                                                  "boundaries, which is computed using the "
-                                                  "consistent boundary flux method as described "
-                                                  "in ``Gresho, Lee, Sani, Maslanik, Eaton (1987). "
-                                                  "The consistent Galerkin FEM for computing "
-                                                  "derived boundary quantities in thermal and or "
-                                                  "fluids problems. International Journal for "
-                                                  "Numerical Methods in Fluids, 7(4), 371-394.'' "
-                                                  "If only conductive heat flux through Dirichlet "
-                                                  "boundaries is of interest, the "
-                                                  "postprocessor can produce output of higher resolution "
-                                                  "by evaluating the CBF solution vector point-wise "
-                                                  "instead of computing cell-wise averaged values."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\watt\\per\\meter\\squared}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/heating.cc.bak b/source/postprocess/visualization/heating.cc.bak
deleted file mode 100644
index 20c9c92530b..00000000000
--- a/source/postprocess/visualization/heating.cc.bak
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/heating.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <deal.II/base/utilities.h>
-#include <deal.II/grid/grid_tools.h>
-
-#include <algorithm>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      Heating<dim>::
-      Heating ()
-        :
-        DataPostprocessor<dim> (),
-        Interface<dim>("W/m/m/m")
-      {}
-
-
-
-      template <int dim>
-      std::vector<std::string>
-      Heating<dim>::
-      get_names () const
-      {
-        std::vector<std::string> names = this->get_heating_model_manager().get_active_heating_model_names();
-
-        // make the names valid names for output variables via DataOut
-        for (auto &name : names)
-          std::replace(name.begin(), name.end(), ' ', '_');
-
-        return names;
-      }
-
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      Heating<dim>::
-      get_data_component_interpretation () const
-      {
-        return std::vector<DataComponentInterpretation::DataComponentInterpretation>
-               (this->get_heating_model_manager().get_active_heating_model_names().size(),
-                DataComponentInterpretation::component_is_scalar);
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      Heating<dim>::
-      get_needed_update_flags () const
-      {
-        return update_gradients | update_values  | update_quadrature_points | update_JxW_values;
-      }
-
-
-
-      template <int dim>
-      void
-      Heating<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        const auto &heating_model_objects = this->get_heating_model_manager().get_active_heating_models();
-
-        // we do not want to write any output if there are no heating models
-        // used in the computation
-        if (heating_model_objects.size() == 0)
-          return;
-
-        Assert (computed_quantities.size() == n_quadrature_points,
-                ExcMessage("The length of the vector of quantities that are computed in the "
-                           "postprocessor (" + dealii::Utilities::int_to_string(computed_quantities.size()) + ") has to match the "
-                           "number of quadrature points (" + dealii::Utilities::int_to_string(n_quadrature_points) + ")!"));
-        Assert (computed_quantities[0].size() == heating_model_objects.size(), ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError());
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data, this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points, this->n_compositional_fields());
-
-        std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (n_quadrature_points));
-
-        this->get_heating_model_manager().create_additional_material_model_inputs_and_outputs(in, out);
-        HeatingModel::HeatingModelOutputs heating_model_outputs(n_quadrature_points, this->n_compositional_fields());
-
-        // we need the cell as input for the material model because some heating models
-        // want to access the solution vector.
-        in.current_cell = input_data.template get_cell<dim>();
-
-        // we need an fevalues object to get the melt velocities
-        std::vector<Point<dim>> quadrature_points(n_quadrature_points);
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          quadrature_points[q] = this->get_mapping().transform_real_to_unit_cell(in.current_cell,input_data.evaluation_points[q]);
-
-        const Quadrature<dim> quadrature_formula (quadrature_points);
-        FEValues<dim> fe_values (this->get_mapping(),
-                                 this->get_fe(),
-                                 quadrature_formula,
-                                 update_values   |
-                                 update_gradients |
-                                 update_quadrature_points |
-                                 update_JxW_values);
-
-        fe_values.reinit(in.current_cell);
-        this->get_material_model().fill_additional_material_model_inputs(in,
-                                                                         this->get_solution(),
-                                                                         fe_values,
-                                                                         this->introspection());
-        this->get_material_model().evaluate(in, out);
-
-        if (this->get_parameters().formulation_temperature_equation
-            == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-          {
-            // Overwrite the density by the reference density coming from the
-            // adiabatic conditions as required by the formulation
-            for (unsigned int q=0; q<n_quadrature_points; ++q)
-              out.densities[q] = this->get_adiabatic_conditions().density(in.position[q]);
-          }
-        else if (this->get_parameters().formulation_temperature_equation
-                 == Parameters<dim>::Formulation::TemperatureEquation::real_density)
-          {
-            // use real density
-          }
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        unsigned int index = 0;
-        for (typename std::list<std::unique_ptr<HeatingModel::Interface<dim>>>::const_iterator
-             heating_model = heating_model_objects.begin();
-             heating_model != heating_model_objects.end(); ++heating_model, ++index)
-          {
-            (*heating_model)->evaluate(in, out, heating_model_outputs);
-
-            for (unsigned int q=0; q<n_quadrature_points; ++q)
-              computed_quantities[q][index] = heating_model_outputs.heating_source_terms[q];
-          }
-
-      }
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Heating,
-                                                  "heating",
-                                                  "A visualization output object that generates output "
-                                                  "for all the heating terms used in the energy equation."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\watt\\per\\cubic\\meter}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/kxrcf_indicator.cc.bak b/source/postprocess/visualization/kxrcf_indicator.cc.bak
deleted file mode 100644
index b932f96d09f..00000000000
--- a/source/postprocess/visualization/kxrcf_indicator.cc.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/kxrcf_indicator.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      KXRCFIndicator<dim>::KXRCFIndicator()
-        :
-        CellDataVectorCreator<dim>("")
-      {}
-
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      KXRCFIndicator<dim>::execute() const
-      {
-        std::pair<std::string, std::unique_ptr<Vector<float>>>
-        return_value ("KXRCF_indicator",
-                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-        this->compute_KXRCF_indicators(*return_value.second, field_index);
-        return return_value;
-      }
-
-
-      template <int dim>
-      void
-      KXRCFIndicator<dim>::declare_parameters(ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("KXRCF indicator");
-            {
-              prm.declare_entry ("Name of advection field", "",
-                                 Patterns::Anything(),
-                                 "The name of the advection field whose output "
-                                 "should be visualized. ");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-      template <int dim>
-      void
-      KXRCFIndicator<dim>::parse_parameters(ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("KXRCF indicator");
-            {
-              const std::string field_name = prm.get("Name of advection field");
-
-              if (field_name == "temperature")
-                field_index = 0;
-              else
-                {
-                  AssertThrow(this->introspection().compositional_name_exists(field_name),
-                              ExcMessage("No compositional field with name <" +
-                                         field_name +
-                                         "> exists for which you want to visualize the KXRCF indicator."));
-
-                  field_index = this->introspection().compositional_index_for_name(field_name) + 1;
-                }
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(KXRCFIndicator,
-                                                  "kxrcf indicator",
-                                                  "A visualization output object that generates output "
-                                                  "showing the value of the KXRCF indicator for a given "
-                                                  "advection field (either temperature or compositional "
-                                                  "field) on each cell. The KXRCF indicator is a metric "
-                                                  "of discontinuity for hyperbolic conservation laws. "
-                                                  "If the KXRCF value of a cell is higher than the value of "
-                                                  "``Temperature/Composition KXRCF indicator threshold'' "
-                                                  "of the corresponding field in the input parameter file, "
-                                                  "the cell will be identified as a ``troubled-cell'' that "
-                                                  "should be smoothed by the WENO limiter. For details, see "
-                                                  "\\cite{Krivodonova:etal:2004}."
-                                                  "\n\n"
-                                                  "This postprocessor should only be used for discontinuous "
-                                                  "advection fields. Otherwise, the postprocessor will produce "
-                                                  "a meaningless visualization output."
-                                                  "\n\n"
-                                                  "Physical units: none.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/material_properties.cc.bak b/source/postprocess/visualization/material_properties.cc.bak
deleted file mode 100644
index 76e6a5eedfd..00000000000
--- a/source/postprocess/visualization/material_properties.cc.bak
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/material_properties.h>
-#include <aspect/utilities.h>
-#include <aspect/melt.h>
-
-#include <algorithm>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      MaterialProperties<dim>::
-      MaterialProperties ()
-        :
-        DataPostprocessor<dim> (),
-        // What quantities are output depends on parameters, and so do the physical units.
-        // There is nothing useful we can provide here at this point.
-        Interface<dim>("")
-      {}
-
-
-
-      template <int dim>
-      std::vector<std::string>
-      MaterialProperties<dim>::
-      get_names () const
-      {
-        std::vector<std::string> solution_names;
-
-        for (const auto &property_name : property_names)
-          if (property_name == "reaction terms")
-            {
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                solution_names.push_back (this->introspection().name_for_compositional_index(c) + "_change");
-            }
-          else
-            {
-              solution_names.push_back(property_name);
-              std::replace(solution_names.back().begin(),solution_names.back().end(),' ', '_');
-            }
-
-        return solution_names;
-      }
-
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      MaterialProperties<dim>::
-      get_data_component_interpretation () const
-      {
-        std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretation;
-        for (const auto &property_name : property_names)
-          {
-            if (property_name == "reaction terms")
-              {
-                for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                  interpretation.push_back (DataComponentInterpretation::component_is_scalar);
-              }
-            else
-              interpretation.push_back (DataComponentInterpretation::component_is_scalar);
-          }
-
-        return interpretation;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      MaterialProperties<dim>::
-      get_needed_update_flags () const
-      {
-        return update_gradients | update_values  | update_quadrature_points;
-      }
-
-
-
-      template <int dim>
-      void
-      MaterialProperties<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,
-                ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,
-                ExcInternalError());
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-
-        this->get_material_model().evaluate(in, out);
-
-        // We want to output material properties as they are used in the
-        // program during assembly. To do so, some of the material averaging
-        // modes require a quadrature object -- but we do not have this,
-        // all we have is the mapped quadrature points. As a consequence,
-        // only do the averaging for those modes that do not require a
-        // functional quadrature object. This means that we only
-        // do the wrong thing for the Q1 averaging where the difference
-        // between input and output of the averaging operation is generally
-        // small and probably not visible anyway.
-        //
-        // The average() function checks whether any quadrature object
-        // it uses has the correct size. So passing an invalid object
-        // in the following code carries little risk if the list of
-        // averaging modes that require a quadrature object expands:
-        // Every time we generate graphical output for a model that
-        // uses this kind of averaging, we will trigger an exception.
-        if (this->get_parameters().material_averaging != MaterialModel::MaterialAveraging::AveragingOperation::project_to_Q1
-            &&
-            this->get_parameters().material_averaging != MaterialModel::MaterialAveraging::AveragingOperation::project_to_Q1_only_viscosity)
-          MaterialModel::MaterialAveraging::average (this->get_parameters().material_averaging,
-                                                     input_data.template get_cell<dim>(),
-                                                     Quadrature<dim>(),
-                                                     this->get_mapping(),
-                                                     in.requested_properties,
-                                                     out);
-
-        std::vector<double> melt_fractions(n_quadrature_points);
-        if (std::find(property_names.begin(), property_names.end(), "melt fraction") != property_names.end())
-          {
-            AssertThrow(MaterialModel::MeltFractionModel<dim>::is_melt_fraction_model(this->get_material_model()),
-                        ExcMessage("You are trying to visualize the melt fraction, but the material"
-                                   "model you use does not actually compute a melt fraction."));
-            MaterialModel::MeltFractionModel<dim>::as_melt_fraction_model(this->get_material_model())
-            .melt_fractions(in, melt_fractions);
-          }
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            unsigned output_index = 0;
-            for (unsigned int i=0; i<property_names.size(); ++i, ++output_index)
-              {
-                if (property_names[i] == "viscosity")
-                  computed_quantities[q][output_index] = out.viscosities[q];
-
-                else if (property_names[i] == "density")
-                  computed_quantities[q][output_index] = out.densities[q];
-
-                else if (property_names[i] == "thermal expansivity")
-                  computed_quantities[q][output_index] = out.thermal_expansion_coefficients[q];
-
-                else if (property_names[i] == "specific heat")
-                  computed_quantities[q][output_index] = out.specific_heat[q];
-
-                else if (property_names[i] == "thermal conductivity")
-                  computed_quantities[q][output_index] = out.thermal_conductivities[q];
-
-                else if (property_names[i] == "thermal diffusivity")
-                  computed_quantities[q][output_index] = out.thermal_conductivities[q]/(out.densities[q]*out.specific_heat[q]);
-
-                else if (property_names[i] == "compressibility")
-                  computed_quantities[q][output_index] = out.compressibilities[q];
-
-                else if (property_names[i] == "entropy derivative pressure")
-                  computed_quantities[q][output_index] = out.entropy_derivative_pressure[q];
-
-                else if (property_names[i] == "entropy derivative temperature")
-                  computed_quantities[q][output_index] = out.entropy_derivative_temperature[q];
-
-                else if (property_names[i] == "reaction terms")
-                  {
-                    for (unsigned int k=0; k<this->n_compositional_fields(); ++k, ++output_index)
-                      {
-                        computed_quantities[q][output_index] = out.reaction_terms[q][k];
-                      }
-                    --output_index;
-                  }
-                else if (property_names[i] == "melt fraction")
-                  computed_quantities[q][output_index] = melt_fractions[q];
-                else
-                  AssertThrow(false,
-                              ExcMessage("Material property not implemented for this postprocessor."));
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      MaterialProperties<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Material properties");
-            {
-              const std::string pattern_of_names
-                = "viscosity|density|thermal expansivity|specific heat|"
-                  "thermal conductivity|thermal diffusivity|compressibility|"
-                  "entropy derivative temperature|entropy derivative pressure|reaction terms|"
-                  "melt fraction";
-
-              prm.declare_entry("List of material properties",
-                                "density,thermal expansivity,specific heat,viscosity",
-                                Patterns::MultipleSelection(pattern_of_names),
-                                "A comma separated list of material properties that should be "
-                                "written whenever writing graphical output. By default, the "
-                                "material properties will always contain the density, thermal "
-                                "expansivity, specific heat and viscosity. "
-                                "The following material properties are available:\n\n"
-                                +
-                                pattern_of_names);
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      MaterialProperties<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Material properties");
-            {
-              // Get property names and compare against variable names
-              property_names = Utilities::split_string_list(prm.get ("List of material properties"));
-              AssertThrow(Utilities::has_unique_entries(property_names),
-                          ExcMessage("The list of strings for the parameter "
-                                     "'Postprocess/Visualization/Material properties/List of material properties' "
-                                     "contains entries more than once. This is not allowed. "
-                                     "Please check your parameter file."));
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MaterialProperties,
-                                                  "material properties",
-                                                  "A visualization output object that generates output "
-                                                  "for the material properties given by the material model. "
-                                                  "The current postprocessor allows to output a (potentially "
-                                                  "large) subset of all of the information provided by "
-                                                  "material models at once, with just a single material model "
-                                                  "evaluation per output point. "
-                                                  "Although individual properties can still be listed in the "
-                                                  "``List of output variables'', this visualization plugin "
-                                                  "is called internally to avoid duplicated evaluations of "
-                                                  "the material model. "
-                                                  "\n\n"
-                                                  "In almost all places inside \\aspect{}, the program "
-                                                  "can use ``averaged'' material properties, for example for "
-                                                  "the assembly of matrices and right hand side vectors. To "
-                                                  "accurately reflect the material parameters used internally, "
-                                                  "this visualization postprocessor averages in the same way "
-                                                  "as is used to do the assembly, and consequently the "
-                                                  "graphical output will reflect not pointwise properties, "
-                                                  "but averaged properties."
-                                                  "\n\n"
-                                                  "Physical units: Various.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/maximum_horizontal_compressive_stress.cc.bak b/source/postprocess/visualization/maximum_horizontal_compressive_stress.cc.bak
deleted file mode 100644
index 54144cfdf80..00000000000
--- a/source/postprocess/visualization/maximum_horizontal_compressive_stress.cc.bak
+++ /dev/null
@@ -1,366 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/maximum_horizontal_compressive_stress.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      MaximumHorizontalCompressiveStress<dim>::
-      MaximumHorizontalCompressiveStress ()
-        :
-        Interface<dim>("Pa")
-      {}
-
-
-
-      template <int dim>
-      void
-      MaximumHorizontalCompressiveStress<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert ((computed_quantities[0].size() == dim),
-                ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-
-        // We do not need to compute anything but the viscosity
-        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-        // Compute the viscosity...
-        this->get_material_model().evaluate(in, out);
-
-        // ...and use it to compute the stresses and from that the
-        // maximum compressive stress direction
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            const SymmetricTensor<2,dim> strain_rate = in.strain_rate[q];
-            const SymmetricTensor<2,dim> deviatoric_strain_rate
-              = (this->get_material_model().is_compressible()
-                 ?
-                 strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
-                 :
-                 strain_rate);
-
-            const double eta = out.viscosities[q];
-
-            // first compute the stress tensor, ignoring the pressure
-            // for the moment (the pressure has no effect on the
-            // direction since it just adds a multiple of the identity
-            // matrix to the stress, but because it is large, it may
-            // lead to numerical instabilities)
-            //
-            // note that the *compressive* stress is simply the
-            // negative stress
-            const SymmetricTensor<2,dim> compressive_stress = -2*eta*deviatoric_strain_rate;
-
-            // then find a set of (dim-1) horizontal, unit-length, mutually orthogonal vectors
-            const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector (in.position[q]);
-            const Tensor<1,dim> vertical_direction = gravity/gravity.norm();
-            std::array<Tensor<1,dim>,dim-1 > orthogonal_directions
-              = Utilities::orthogonal_vectors(vertical_direction);
-            for (unsigned int i=0; i<orthogonal_directions.size(); ++i)
-              orthogonal_directions[i] /= orthogonal_directions[i].norm();
-
-            Tensor<1,dim> maximum_horizontal_compressive_stress;
-            switch (dim)
-              {
-                // in 2d, there is only one horizontal direction, and
-                // we have already computed it above. give it the
-                // length of the compressive_stress (now taking into account the
-                // pressure) in this direction
-                case 2:
-                {
-                  maximum_horizontal_compressive_stress = orthogonal_directions[0] *
-                                                          (orthogonal_directions[0] *
-                                                           ((compressive_stress
-                                                             -
-                                                             in.pressure[q] * unit_symmetric_tensor<dim>()) *
-                                                            orthogonal_directions[0]));
-                  break;
-                }
-
-                // in 3d, use the formulas discussed in the
-                // documentation of the plugin below
-                case 3:
-                {
-                  const double a = orthogonal_directions[0] *
-                                   (compressive_stress *
-                                    orthogonal_directions[0]);
-                  const double b = orthogonal_directions[1] *
-                                   (compressive_stress *
-                                    orthogonal_directions[1]);
-                  const double c = 2.0*orthogonal_directions[0] *
-                                   (compressive_stress *
-                                    orthogonal_directions[1]);
-
-                  // compute the two stationary points of f(alpha)
-                  const double alpha_1 = 1./2 * std::atan2 (c, a-b);
-                  const double alpha_2 = alpha_1 + numbers::PI/2;
-
-                  // then check the sign of f''(alpha) to determine
-                  // which of the two stationary points is the maximum
-                  const double f_double_prime_1 = 2*(b-a)*std::cos(2*alpha_1)
-                                                  - 2*c*sin(2*alpha_1);
-                  double alpha;
-                  if (f_double_prime_1 < 0)
-                    alpha = alpha_1;
-                  else
-                    {
-                      Assert (/* f_double_prime_2 = */
-                        2*(b-a)*std::cos(2*alpha_2) - 2*c*sin(2*alpha_2) <= 0,
-                        ExcInternalError());
-                      alpha = alpha_2;
-                    }
-
-                  // then re-assemble the maximum horizontal compressive_stress
-                  // direction from alpha and the two horizontal
-                  // directions
-                  const Tensor<1,dim> n = std::cos(alpha) * orthogonal_directions[0] +
-                                          std::sin(alpha) * orthogonal_directions[1];
-
-                  // finally compute the actual direction * magnitude,
-                  // now taking into account the pressure (with the
-                  // correct sign in front of the pressure for the
-                  // *compressive* stress)
-                  //
-                  // the magnitude is computed as discussed in the
-                  // description of the plugin below
-                  const double maximum_horizontal_compressive_stress_magnitude
-                    = (n * ((compressive_stress
-                             -
-                             in.pressure[q] * unit_symmetric_tensor<dim>()) * n));
-                  const Tensor<1,dim> n_perp = std::sin(alpha) * orthogonal_directions[0] -
-                                               std::cos(alpha) * orthogonal_directions[1];
-
-                  const double minimum_horizontal_compressive_stress_magnitude
-                    = (n_perp * ((compressive_stress
-                                  -
-                                  in.pressure[q] * unit_symmetric_tensor<dim>()) * n_perp));
-
-                  maximum_horizontal_compressive_stress
-                    = n * (maximum_horizontal_compressive_stress_magnitude -
-                           minimum_horizontal_compressive_stress_magnitude);
-
-                  break;
-                }
-
-                default:
-                  Assert (false, ExcNotImplemented());
-              }
-
-            for (unsigned int i=0; i<dim; ++i)
-              computed_quantities[q](i) = maximum_horizontal_compressive_stress[i];
-          }
-      }
-
-
-      template <int dim>
-      std::vector<std::string>
-      MaximumHorizontalCompressiveStress<dim>::get_names () const
-      {
-        return std::vector<std::string> (dim, "maximum_horizontal_compressive_stress");
-      }
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      MaximumHorizontalCompressiveStress<dim>::get_data_component_interpretation () const
-      {
-        return
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          (dim,
-           DataComponentInterpretation::component_is_part_of_vector);
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      MaximumHorizontalCompressiveStress<dim>::get_needed_update_flags () const
-      {
-        return update_gradients | update_values | update_quadrature_points;
-      }
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MaximumHorizontalCompressiveStress,
-                                                  "maximum horizontal compressive stress",
-                                                  "A plugin that computes the direction and magnitude of the "
-                                                  "maximum horizontal component of the compressive stress as a vector "
-                                                  "field. The direction of this vector can often be used to "
-                                                  "visualize the principal mode of deformation (e.g., at "
-                                                  "normal faults or extensional margins) and can be "
-                                                  "correlated with seismic anisotropy. Recall that the "
-                                                  "\\textit{compressive} stress is simply the negative stress, "
-                                                  "$\\sigma_c=-\\sigma=-\\left["
-                                                  "     2\\eta (\\varepsilon(\\mathbf u)"
-                                                  "             - \\frac 13 (\\nabla \\cdot \\mathbf u) I)"
-                                                  "     + pI\\right]$."
-                                                  "\n\n"
-                                                  "Following \\cite{LundTownend07}, we define the maximum horizontal "
-                                                  "stress direction as that \\textit{horizontal} direction "
-                                                  "$\\mathbf n$ that maximizes $\\mathbf n^T \\sigma_c \\mathbf n$. We "
-                                                  "call a vector \\textit{horizontal} if it is perpendicular to the "
-                                                  "gravity vector $\\mathbf g$."
-                                                  "\n\n"
-                                                  "In two space dimensions, $\\mathbf n$ is simply a vector that "
-                                                  "is horizontal (we choose one of the two possible choices). "
-                                                  "This direction is then scaled by the size of the horizontal stress "
-                                                  "in this direction, i.e., the plugin outputs the vector "
-                                                  "$\\mathbf w = (\\mathbf n^T \\sigma_c \\mathbf n) \\; \\mathbf n$."
-                                                  "\n\n"
-                                                  "In three space dimensions, given two horizontal, perpendicular, "
-                                                  "unit length, but otherwise arbitrarily chosen vectors "
-                                                  "$\\mathbf u,\\mathbf v$, we can express "
-                                                  "$\\mathbf n = (\\cos \\alpha)\\mathbf u + (\\sin\\alpha)\\mathbf v$ "
-                                                  "where $\\alpha$ maximizes the expression "
-                                                  "\\begin{align*}"
-                                                  "  f(\\alpha) = \\mathbf n^T \\sigma_c \\mathbf n"
-                                                  "  = (\\mathbf u^T \\sigma_c \\mathbf u)(\\cos\\alpha)^2"
-                                                  "    +2(\\mathbf u^T \\sigma_c \\mathbf v)(\\cos\\alpha)(\\sin\\alpha)"
-                                                  "    +(\\mathbf v^T \\sigma_c \\mathbf v)(\\sin\\alpha)^2."
-                                                  "\\end{align*}"
-                                                  "\n\n"
-                                                  "The maximum of $f(\\alpha)$ is attained where $f^\\prime(\\alpha)=0$. "
-                                                  "Evaluating the derivative and using trigonometric identities, "
-                                                  "one finds that $\\alpha$ has to satisfy the equation "
-                                                  "\\begin{align*}"
-                                                  "  \\tan(2\\alpha) = \\frac{2.0\\mathbf u^T \\sigma_c \\mathbf v}"
-                                                  "                          {\\mathbf u^T \\sigma_c \\mathbf u "
-                                                  "                           - \\mathbf v^T \\sigma_c \\mathbf v}."
-                                                  "\\end{align*}"
-                                                  "Since the transform $\\alpha\\mapsto\\alpha+\\pi$ flips the "
-                                                  "direction of $\\mathbf n$, we only need to seek a solution "
-                                                  "to this equation in the interval $\\alpha\\in[0,\\pi)$. "
-                                                  "These are given by "
-                                                  "$\\alpha_1=\\frac 12 \\arctan \\frac{\\mathbf u^T \\sigma_c "
-                                                  "\\mathbf v}{\\mathbf u^T \\sigma_c \\mathbf u - "
-                                                  "\\mathbf v^T \\sigma_c \\mathbf v}$ and "
-                                                  "$\\alpha_2=\\alpha_1+\\frac{\\pi}{2}$, one of which will "
-                                                  "correspond to a minimum and the other to a maximum of "
-                                                  "$f(\\alpha)$. One checks the sign of "
-                                                  "$f^{\\prime\\prime}(\\alpha)=-2(\\mathbf u^T \\sigma_c \\mathbf u - "
-                                                  "\\mathbf v^T \\sigma_c \\mathbf v)\\cos(2\\alpha) "
-                                                  "- 2 (\\mathbf u^T \\sigma_c \\mathbf v) \\sin(2\\alpha)$ for "
-                                                  "each of these to determine the $\\alpha$ that maximizes "
-                                                  "$f(\\alpha)$, and from this immediately arrives at the correct "
-                                                  "form for the maximum horizontal stress $\\mathbf n$."
-                                                  "\n\n"
-                                                  "The description above computes a 3d \\textit{direction} vector "
-                                                  "$\\mathbf n$. If one were to scale this vector the same way "
-                                                  "as done in 2d, i.e., with the magnitude of the stress in "
-                                                  "this direction, one will typically get vectors whose length "
-                                                  "is principally determined by the hydrostatic pressure at "
-                                                  "a given location simply because the hydrostatic pressure "
-                                                  "is the largest component of the overall stress. On the other "
-                                                  "hand, the hydrostatic pressure does not determine any "
-                                                  "principal direction because it is an isotropic, anti-compressive "
-                                                  "force. As a consequence, there are often points in simulations "
-                                                  "(e.g., at the center of convection rolls) where the stress has "
-                                                  "no dominant horizontal direction, and the algorithm above will "
-                                                  "then in essence choose a random direction because the stress "
-                                                  "is approximately equal in all horizontal directions. If one "
-                                                  "scaled the output by the magnitude of the stress in this "
-                                                  "direction (i.e., approximately equal to the hydrostatic "
-                                                  "pressure at this point), one would get randomly oriented vectors "
-                                                  "at these locations with significant lengths."
-                                                  "\n\n"
-                                                  "To avoid this problem, we scale the maximal horizontal "
-                                                  "compressive stress direction $\\mathbf n$ by the \\textit{difference} "
-                                                  "between the stress in the maximal and minimal horizontal stress "
-                                                  "directions. In other words, let "
-                                                  "$\\mathbf n_\\perp=(\\sin \\alpha)\\mathbf u - (\\cos\\alpha)\\mathbf v$ "
-                                                  "be the horizontal direction perpendicular to "
-                                                  "$\\mathbf n$, then this plugin outputs the vector quantity "
-                                                  "$\\mathbf w = (\\mathbf n^T \\sigma_c \\mathbf n "
-                                                  "               -\\mathbf n^T_\\perp \\sigma_c \\mathbf n_\\perp) "
-                                                  "              \\; \\mathbf n$. "
-                                                  "In other words, the length of the vector produced indicates "
-                                                  "\\textit{how dominant} the direction of maximal horizontal "
-                                                  "compressive strength is."
-                                                  "\n\n"
-                                                  "Fig.~\\ref{fig:max-horizontal-compressive-stress} shows a "
-                                                  "simple example for this kind of visualization in 3d."
-                                                  "\n\n"
-                                                  "\\begin{figure}"
-                                                  "  \\includegraphics[width=0.3\\textwidth]"
-                                                  "    {viz/plugins/maximum_horizontal_compressive_stress/temperature.png}"
-                                                  "  \\hfill"
-                                                  "  \\includegraphics[width=0.3\\textwidth]"
-                                                  "    {viz/plugins/maximum_horizontal_compressive_stress/velocity.png}"
-                                                  "  \\hfill"
-                                                  "  \\includegraphics[width=0.3\\textwidth]"
-                                                  "    {viz/plugins/maximum_horizontal_compressive_stress/horizontal-stress.png}"
-                                                  "  \\caption{\\it Illustration of the `maximum horizontal "
-                                                  "    compressive stress' visualization plugin. The left "
-                                                  "    figure shows a ridge-like temperature anomaly. Together "
-                                                  "    with no-slip boundary along all six boundaries, this "
-                                                  "    results in two convection rolls (center). The maximal "
-                                                  "    horizontal compressive strength at the bottom center "
-                                                  "    of the domain is perpendicular to the ridge because "
-                                                  "    the flow comes together there from the left and right, "
-                                                  "    yielding a compressive force in left-right direction. "
-                                                  "    At the top of the model, the flow separates outward, "
-                                                  "    leading to a \\textit{negative} compressive stress "
-                                                  "    in left-right direction; because there is no flow "
-                                                  "    in front-back direction, the compressive strength "
-                                                  "    in front-back direction is zero, making the along-ridge "
-                                                  "    direction the dominant one. At the center of the "
-                                                  "    convection rolls, both horizontal directions yield "
-                                                  "    the same stress; the plugin therefore chooses an "
-                                                  "    essentially arbitrary horizontal vector, but then "
-                                                  "    uses a zero magnitude given that the difference "
-                                                  "    between the maximal and minimal horizontal stress "
-                                                  "    is zero at these points.}"
-                                                  "  \\label{fig:max-horizontal-compressive-stress}"
-                                                  "\\end{figure}"
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\pascal}."
-                                                 )
-    }
-  }
-}
diff --git a/source/postprocess/visualization/melt.cc.bak b/source/postprocess/visualization/melt.cc.bak
deleted file mode 100644
index ca291391f0d..00000000000
--- a/source/postprocess/visualization/melt.cc.bak
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/melt.h>
-#include <aspect/melt.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator.h>
-#include <aspect/material_model/interface.h>
-
-#include <deal.II/numerics/data_out.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-
-      template <int dim>
-      MeltMaterialProperties<dim>::
-      MeltMaterialProperties ()
-        :
-        DataPostprocessor<dim> (),
-        // What is being output depends on run-time parameters. We can not
-        // describe physical units to the base class at this point.
-        Interface<dim>("")
-      {}
-
-
-
-      template <int dim>
-      std::vector<std::string>
-      MeltMaterialProperties<dim>::
-      get_names () const
-      {
-        std::vector<std::string> solution_names;
-
-        for (const auto &property_name : property_names)
-          if (property_name == "fluid density gradient")
-            for (unsigned int i=0; i<dim; ++i)
-              solution_names.emplace_back("fluid_density_gradient");
-          else if (property_name == "compaction pressure")
-            {
-              solution_names.emplace_back("p_c");
-            }
-          else
-            {
-              solution_names.push_back(property_name);
-              std::replace(solution_names.back().begin(),solution_names.back().end(),' ', '_');
-            }
-
-        return solution_names;
-      }
-
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      MeltMaterialProperties<dim>::
-      get_data_component_interpretation () const
-      {
-        std::vector<DataComponentInterpretation::DataComponentInterpretation> interpretation;
-        for (const auto &property_name : property_names)
-          {
-            if (property_name == "fluid density gradient")
-              {
-                for (unsigned int c=0; c<dim; ++c)
-                  interpretation.push_back (DataComponentInterpretation::component_is_part_of_vector);
-              }
-            else
-              interpretation.push_back (DataComponentInterpretation::component_is_scalar);
-          }
-
-        return interpretation;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      MeltMaterialProperties<dim>::
-      get_needed_update_flags () const
-      {
-        return update_gradients | update_values  | update_quadrature_points;
-      }
-
-
-
-      template <int dim>
-      void
-      MeltMaterialProperties<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        AssertThrow(this->include_melt_transport()==true,
-                    ExcMessage("'Include melt transport' has to be on when using melt transport postprocessors."));
-
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
-
-        // Set use_strain_rates to true since the compaction viscosity might also depend on the strain rate.
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points, this->n_compositional_fields());
-        MeltHandler<dim>::create_material_model_outputs(out);
-
-        this->get_material_model().evaluate(in, out);
-        MaterialModel::MeltOutputs<dim> *melt_outputs = out.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-        AssertThrow(melt_outputs != nullptr,
-                    ExcMessage("Need MeltOutputs from the material model for computing the melt properties."));
-
-        const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(this->get_material_model()).p_c_scale(in,
-                                 out,
-                                 this->get_melt_handler(),
-                                 true);
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            unsigned output_index = 0;
-            for (unsigned int i=0; i<property_names.size(); ++i, ++output_index)
-              {
-                if (property_names[i] == "compaction viscosity")
-                  computed_quantities[q][output_index] = melt_outputs->compaction_viscosities[q];
-                else if (property_names[i] == "fluid viscosity")
-                  computed_quantities[q][output_index] = melt_outputs->fluid_viscosities[q];
-                else if (property_names[i] == "permeability")
-                  computed_quantities[q][output_index] = melt_outputs->permeabilities[q];
-                else if (property_names[i] == "fluid density")
-                  computed_quantities[q][output_index] = melt_outputs->fluid_densities[q];
-                else if (property_names[i] == "fluid density gradient")
-                  {
-                    for (unsigned int k=0; k<dim; ++k, ++output_index)
-                      {
-                        computed_quantities[q][output_index] = melt_outputs->fluid_density_gradients[q][k];
-                      }
-                    --output_index;
-                  }
-                else if (property_names[i] == "compaction pressure")
-                  {
-                    const unsigned int pc_comp_idx = this->introspection().variable("compaction pressure").first_component_index;
-                    const double p_c_bar = input_data.solution_values[q][pc_comp_idx];
-
-                    computed_quantities[q][output_index] = p_c_scale * p_c_bar;
-                  }
-                else if (property_names[i] == "darcy coefficient")
-                  {
-                    const double K_D = this->get_melt_handler().limited_darcy_coefficient(melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q], p_c_scale > 0);
-                    computed_quantities[q][output_index] = K_D;
-                  }
-                else if (property_names[i] == "darcy coefficient no cutoff")
-                  {
-                    const double K_D_no_cut = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q];
-                    computed_quantities[q][output_index] = K_D_no_cut;
-                  }
-                else if (property_names[i] == "is melt cell")
-                  {
-                    computed_quantities[q][output_index] = this->get_melt_handler().is_melt_cell(in.current_cell)? 1.0 : 0.0;
-                  }
-                else if (property_names[i] == "compaction length")
-                  {
-                    const double compaction_length = std::sqrt((out.viscosities[q] + 4./3. * melt_outputs->compaction_viscosities[q])
-                                                               * melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q]);
-                    computed_quantities[q][output_index] = compaction_length;
-                  }
-                else
-                  AssertThrow(false, ExcNotImplemented());
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      MeltMaterialProperties<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Melt material properties");
-            {
-              const std::string pattern_of_names
-                = "compaction viscosity|fluid viscosity|permeability|"
-                  "fluid density|fluid density gradient|is melt cell|"
-                  "darcy coefficient|darcy coefficient no cutoff|"
-                  "compaction length";
-
-              prm.declare_entry("List of properties",
-                                "compaction viscosity,permeability",
-                                Patterns::MultipleSelection(pattern_of_names),
-                                "A comma separated list of melt properties that should be "
-                                "written whenever writing graphical output. "
-                                "The following material properties are available:\n\n"
-                                +
-                                pattern_of_names);
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      MeltMaterialProperties<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Melt material properties");
-            {
-              property_names = Utilities::split_string_list(prm.get ("List of properties"));
-              AssertThrow(Utilities::has_unique_entries(property_names),
-                          ExcMessage("The list of strings for the parameter "
-                                     "'Postprocess/Visualization/Melt material properties/List of properties' contains entries more than once. "
-                                     "This is not allowed. Please check your parameter file."));
-
-              // Always output compaction pressure
-              property_names.insert(property_names.begin(),"compaction pressure");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MeltMaterialProperties,
-                                                  "melt material properties",
-                                                  "A visualization output object that generates output "
-                                                  "for melt related properties of the material model. Note "
-                                                  "that this postprocessor always outputs the compaction pressure, "
-                                                  "but can output a large range of additional properties, as "
-                                                  "selected in the ``List of properties'' parameter."
-                                                  "\n\n"
-                                                  "Physical units: Various, depending on what is being output.")
-
-    }
-  }
-}
diff --git a/source/postprocess/visualization/melt_fraction.cc.bak b/source/postprocess/visualization/melt_fraction.cc.bak
deleted file mode 100644
index 688d99a177e..00000000000
--- a/source/postprocess/visualization/melt_fraction.cc.bak
+++ /dev/null
@@ -1,354 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/melt_fraction.h>
-#include <aspect/melt.h>
-
-#include <deal.II/base/parameter_handler.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      MeltFraction<dim>::
-      MeltFraction ()
-        :
-        DataPostprocessorScalar<dim> ("melt_fraction",
-                                      update_values | update_quadrature_points),
-        Interface<dim>("")  // a fraction, so physical units "1"
-      {}
-
-
-
-      template <int dim>
-      void
-      MeltFraction<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
-
-        // in case the material model computes the melt fraction itself, we use that output
-        if (MaterialModel::MeltFractionModel<dim>::is_melt_fraction_model(this->get_material_model()))
-          {
-            MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                       this->introspection());
-            MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                         this->n_compositional_fields());
-
-            // Compute the melt fraction...
-            this->get_material_model().evaluate(in, out);
-
-            std::vector<double> melt_fractions(n_quadrature_points);
-            MaterialModel::MeltFractionModel<dim>::as_melt_fraction_model(this->get_material_model())
-            .melt_fractions(in, melt_fractions);
-
-            for (unsigned int q=0; q<n_quadrature_points; ++q)
-              computed_quantities[q](0) = melt_fractions[q];
-          }
-        else
-          for (unsigned int q=0; q<n_quadrature_points; ++q)
-            {
-              const double pressure    = input_data.solution_values[q][this->introspection().component_indices.pressure];
-              const double temperature = input_data.solution_values[q][this->introspection().component_indices.temperature];
-              std::vector<double> composition(this->n_compositional_fields());
-
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                composition[c] = input_data.solution_values[q][this->introspection().component_indices.compositional_fields[c]];
-
-              // anhydrous melting of peridotite after Katz, 2003
-              const double T_solidus  = A1 + 273.15
-                                        + A2 * pressure
-                                        + A3 * pressure * pressure;
-              const double T_lherz_liquidus = B1 + 273.15
-                                              + B2 * pressure
-                                              + B3 * pressure * pressure;
-              const double T_liquidus = C1 + 273.15
-                                        + C2 * pressure
-                                        + C3 * pressure * pressure;
-
-              // melt fraction for peridotite with clinopyroxene
-              double peridotite_melt_fraction;
-              if (temperature < T_solidus || pressure > 1.3e10)
-                peridotite_melt_fraction = 0.0;
-              else if (temperature > T_lherz_liquidus)
-                peridotite_melt_fraction = 1.0;
-              else
-                peridotite_melt_fraction = std::pow((temperature - T_solidus) / (T_lherz_liquidus - T_solidus),beta);
-
-              // melt fraction after melting of all clinopyroxene
-              const double R_cpx = r1 + r2 * std::max(0.0, pressure);
-              const double F_max = M_cpx / R_cpx;
-
-              if (peridotite_melt_fraction > F_max && temperature < T_liquidus)
-                {
-                  const double T_max = std::pow(F_max,1/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
-                  peridotite_melt_fraction = F_max + (1 - F_max) * pow((temperature - T_max) / (T_liquidus - T_max),beta);
-                }
-
-              // melting of pyroxenite after Sobolev et al., 2011
-              const double T_melting = D1 + 273.15
-                                       + D2 * pressure
-                                       + D3 * pressure * pressure;
-
-              const double discriminant = E1*E1/(E2*E2*4) + (temperature-T_melting)/E2;
-
-              double pyroxenite_melt_fraction;
-              if (temperature < T_melting || pressure > 1.3e10)
-                pyroxenite_melt_fraction = 0.0;
-              else if (discriminant < 0)
-                pyroxenite_melt_fraction = 0.5429;
-              else
-                pyroxenite_melt_fraction = -E1/(2*E2) - std::sqrt(discriminant);
-
-              double melt_fraction;
-              if (this->introspection().compositional_name_exists("pyroxenite"))
-                {
-                  const unsigned int pyroxenite_index = this->introspection().compositional_index_for_name("pyroxenite");
-                  melt_fraction = composition[pyroxenite_index] * pyroxenite_melt_fraction +
-                                  (1-composition[pyroxenite_index]) * peridotite_melt_fraction;
-                }
-              else
-                melt_fraction = peridotite_melt_fraction;
-
-              computed_quantities[q](0) = melt_fraction;
-            }
-      }
-
-
-
-      template <int dim>
-      void
-      MeltFraction<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Melt fraction");
-            {
-              prm.declare_entry ("A1", "1085.7",
-                                 Patterns::Double (),
-                                 "Constant parameter in the quadratic "
-                                 "function that approximates the solidus "
-                                 "of peridotite. "
-                                 "Units: \\si{\\degreeCelsius}.");
-              prm.declare_entry ("A2", "1.329e-7",
-                                 Patterns::Double (),
-                                 "Prefactor of the linear pressure term "
-                                 "in the quadratic function that approximates "
-                                 "the solidus of peridotite. "
-                                 "\\si{\\degreeCelsius\\per\\pascal}.");
-              prm.declare_entry ("A3", "-5.1e-18",
-                                 Patterns::Double (),
-                                 "Prefactor of the quadratic pressure term "
-                                 "in the quadratic function that approximates "
-                                 "the solidus of peridotite. "
-                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
-              prm.declare_entry ("B1", "1475.0",
-                                 Patterns::Double (),
-                                 "Constant parameter in the quadratic "
-                                 "function that approximates the lherzolite "
-                                 "liquidus used for calculating the fraction "
-                                 "of peridotite-derived melt. "
-                                 "Units: \\si{\\degreeCelsius}.");
-              prm.declare_entry ("B2", "8.0e-8",
-                                 Patterns::Double (),
-                                 "Prefactor of the linear pressure term "
-                                 "in the quadratic function that approximates "
-                                 "the  lherzolite liquidus used for "
-                                 "calculating the fraction of peridotite-"
-                                 "derived melt. "
-                                 "\\si{\\degreeCelsius\\per\\pascal}.");
-              prm.declare_entry ("B3", "-3.2e-18",
-                                 Patterns::Double (),
-                                 "Prefactor of the quadratic pressure term "
-                                 "in the quadratic function that approximates "
-                                 "the  lherzolite liquidus used for "
-                                 "calculating the fraction of peridotite-"
-                                 "derived melt. "
-                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
-              prm.declare_entry ("C1", "1780.0",
-                                 Patterns::Double (),
-                                 "Constant parameter in the quadratic "
-                                 "function that approximates the liquidus "
-                                 "of peridotite. "
-                                 "Units: \\si{\\degreeCelsius}.");
-              prm.declare_entry ("C2", "4.50e-8",
-                                 Patterns::Double (),
-                                 "Prefactor of the linear pressure term "
-                                 "in the quadratic function that approximates "
-                                 "the liquidus of peridotite. "
-                                 "\\si{\\degreeCelsius\\per\\pascal}.");
-              prm.declare_entry ("C3", "-2.0e-18",
-                                 Patterns::Double (),
-                                 "Prefactor of the quadratic pressure term "
-                                 "in the quadratic function that approximates "
-                                 "the liquidus of peridotite. "
-                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
-              prm.declare_entry ("r1", "0.5",
-                                 Patterns::Double (),
-                                 "Constant in the linear function that "
-                                 "approximates the clinopyroxene reaction "
-                                 "coefficient. "
-                                 "Units: non-dimensional.");
-              prm.declare_entry ("r2", "8e-11",
-                                 Patterns::Double (),
-                                 "Prefactor of the linear pressure term "
-                                 "in the linear function that approximates "
-                                 "the clinopyroxene reaction coefficient. "
-                                 "Units: \\si{\\per\\pascal}.");
-              prm.declare_entry ("beta", "1.5",
-                                 Patterns::Double (),
-                                 "Exponent of the melting temperature in "
-                                 "the melt fraction calculation. "
-                                 "Units: non-dimensional.");
-              prm.declare_entry ("Mass fraction cpx", "0.15",
-                                 Patterns::Double (),
-                                 "Mass fraction of clinopyroxene in the "
-                                 "peridotite to be molten. "
-                                 "Units: non-dimensional.");
-              prm.declare_entry ("D1", "976.0",
-                                 Patterns::Double (),
-                                 "Constant parameter in the quadratic "
-                                 "function that approximates the solidus "
-                                 "of pyroxenite. "
-                                 "Units: \\si{\\degreeCelsius}.");
-              prm.declare_entry ("D2", "1.329e-7",
-                                 Patterns::Double (),
-                                 "Prefactor of the linear pressure term "
-                                 "in the quadratic function that approximates "
-                                 "the solidus of pyroxenite. "
-                                 "Note that this factor is different from the "
-                                 "value given in Sobolev, 2011, because they use "
-                                 "the potential temperature whereas we use the "
-                                 "absolute temperature. "
-                                 "\\si{\\degreeCelsius\\per\\pascal}.");
-              prm.declare_entry ("D3", "-5.1e-18",
-                                 Patterns::Double (),
-                                 "Prefactor of the quadratic pressure term "
-                                 "in the quadratic function that approximates "
-                                 "the solidus of pyroxenite. "
-                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
-              prm.declare_entry ("E1", "663.8",
-                                 Patterns::Double (),
-                                 "Prefactor of the linear depletion term "
-                                 "in the quadratic function that approximates "
-                                 "the melt fraction of pyroxenite. "
-                                 "\\si{\\degreeCelsius\\per\\pascal}.");
-              prm.declare_entry ("E2", "-611.4",
-                                 Patterns::Double (),
-                                 "Prefactor of the quadratic depletion term "
-                                 "in the quadratic function that approximates "
-                                 "the melt fraction of pyroxenite. "
-                                 "\\si{\\degreeCelsius\\per\\pascal\\squared}.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-      template <int dim>
-      void
-      MeltFraction<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Melt fraction");
-            {
-              A1              = prm.get_double ("A1");
-              A2              = prm.get_double ("A2");
-              A3              = prm.get_double ("A3");
-              B1              = prm.get_double ("B1");
-              B2              = prm.get_double ("B2");
-              B3              = prm.get_double ("B3");
-              C1              = prm.get_double ("C1");
-              C2              = prm.get_double ("C2");
-              C3              = prm.get_double ("C3");
-              r1              = prm.get_double ("r1");
-              r2              = prm.get_double ("r2");
-              beta            = prm.get_double ("beta");
-              M_cpx           = prm.get_double ("Mass fraction cpx");
-              D1              = prm.get_double ("D1");
-              D2              = prm.get_double ("D2");
-              D3              = prm.get_double ("D3");
-              E1              = prm.get_double ("E1");
-              E2              = prm.get_double ("E2");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MeltFraction,
-                                                  "melt fraction", // TODO write down equations here
-                                                  "A visualization output object that generates output "
-                                                  "for the melt fraction at the temperature and "
-                                                  "pressure of the current point. If the material model computes "
-                                                  "a melt fraction, this is the quantity that will be visualized. "
-                                                  "Otherwise, a specific parametrization for batch melting "
-                                                  "(as described in the following) will be used. "
-                                                  "It does not take into account latent heat. "
-                                                  "If there are no compositional fields, or no fields called 'pyroxenite', "
-                                                  " this postprocessor will visualize the melt fraction of peridotite "
-                                                  "(calculated using the anhydrous model of Katz, 2003). "
-                                                  "If there is a compositional field called 'pyroxenite', the "
-                                                  "postprocessor assumes that this compositional "
-                                                  "field is the content of pyroxenite, and will visualize "
-                                                  "the melt fraction for a mixture of peridotite and pyroxenite "
-                                                  "(using the melting model of Sobolev, 2011 for pyroxenite). "
-                                                  "All the parameters that were used in these calculations "
-                                                  "can be changed in the input file, the most relevant maybe "
-                                                  "being the mass fraction of Cpx in peridotite in the Katz "
-                                                  "melting model (Mass fraction cpx), which right now has a "
-                                                  "default of 15\\%. "
-                                                  "The corresponding $p$-$T$-diagrams can be generated by running "
-                                                  "the tests melt\\_postprocessor\\_peridotite and "
-                                                  "melt\\_postprocessor\\_pyroxenite."
-                                                  "\n\n"
-                                                  "Physical units: None.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/named_additional_outputs.cc.bak b/source/postprocess/visualization/named_additional_outputs.cc.bak
deleted file mode 100644
index 411406b5703..00000000000
--- a/source/postprocess/visualization/named_additional_outputs.cc.bak
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/named_additional_outputs.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/utilities.h>
-
-#include <algorithm>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      NamedAdditionalOutputs<dim>::
-      NamedAdditionalOutputs ()
-        :
-        DataPostprocessor<dim> (),
-        Interface<dim>("")  // physical units depend on run-time parameters
-      {}
-
-
-
-      template <int dim>
-      void
-      NamedAdditionalOutputs<dim>::
-      initialize ()
-      {
-        MaterialModel::MaterialModelOutputs<dim> out(0,
-                                                     this->n_compositional_fields());
-        this->get_material_model().create_additional_named_outputs(out);
-
-        AssertThrow(out.additional_outputs.size() > 0,
-                    ExcMessage("You activated the postprocessor <named additional outputs>, but there are no additional outputs "
-                               "provided by the material model. Either remove the postprocessor, or check why no output is provided."));
-
-        for (unsigned int k=0; k<out.additional_outputs.size(); ++k)
-          {
-            const MaterialModel::NamedAdditionalMaterialOutputs<dim> *result
-              = dynamic_cast<const MaterialModel::NamedAdditionalMaterialOutputs<dim> *> (out.additional_outputs[k].get());
-
-            if (result)
-              {
-                std::vector<std::string> names = result->get_names();
-
-                for (const auto &name : names)
-                  property_names.push_back(name);
-              }
-          }
-
-        AssertThrow(property_names.size() > 0,
-                    ExcMessage("You activated the postprocessor <named additional outputs>, but none of the additional outputs "
-                               "provided by the material model are named outputs. Either remove the postprocessor, or check why no "
-                               "named output is provided."));
-
-        for (auto &property_name : property_names)
-          std::replace(property_name.begin(),property_name.end(),' ', '_');
-      }
-
-
-
-      template <int dim>
-      std::vector<std::string>
-      NamedAdditionalOutputs<dim>::
-      get_names () const
-      {
-        return property_names;
-      }
-
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      NamedAdditionalOutputs<dim>::
-      get_data_component_interpretation () const
-      {
-        return std::vector<DataComponentInterpretation::DataComponentInterpretation> (get_names().size(),
-                                                                                      DataComponentInterpretation::component_is_scalar);
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      NamedAdditionalOutputs<dim>::
-      get_needed_update_flags () const
-      {
-        return update_gradients | update_values  | update_quadrature_points;
-      }
-
-
-
-      template <int dim>
-      void
-      NamedAdditionalOutputs<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,
-                ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,
-                ExcInternalError());
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-
-        this->get_material_model().create_additional_named_outputs(out);
-        this->get_material_model().evaluate(in, out);
-
-        unsigned int field_index = 0;
-        for (unsigned int k=0; k<out.additional_outputs.size(); ++k)
-          {
-            const MaterialModel::NamedAdditionalMaterialOutputs<dim> *result
-              = dynamic_cast<const MaterialModel::NamedAdditionalMaterialOutputs<dim> *> (out.additional_outputs[k].get());
-
-            if (result)
-              {
-                std::vector<double> outputs(n_quadrature_points);
-                for (unsigned int i=0; i<result->get_names().size(); ++i, ++field_index)
-                  {
-                    outputs = result->get_nth_output(i);
-
-                    for (unsigned int q=0; q<n_quadrature_points; ++q)
-                      computed_quantities[q][field_index] = outputs[q];
-                  }
-              }
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(NamedAdditionalOutputs,
-                                                  "named additional outputs",
-                                                  "Some material models can compute quantities other than those "
-                                                  "that typically appear in the equations that \\aspect{} solves "
-                                                  "(such as the viscosity, density, etc). Examples of quantities "
-                                                  "material models may be able to compute are seismic velocities, "
-                                                  "or other quantities that can be derived from the state variables "
-                                                  "and the material coefficients such as the stress or stress "
-                                                  "anisotropies. These quantities are generically referred to as "
-                                                  "`named outputs' because they are given an explicit name different "
-                                                  "from the usual outputs of material models.\n\n"
-                                                  "This visualization postprocessor outputs whatever quantities the "
-                                                  "material model can compute. What quantities these are is specific "
-                                                  "to the material model in use for a simulation, and for many models "
-                                                  "in fact does not contain any named outputs at all."
-                                                  "\n\n"
-                                                  "Physical units: Various, depending on what is being output.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/nonadiabatic_pressure.cc.bak b/source/postprocess/visualization/nonadiabatic_pressure.cc.bak
deleted file mode 100644
index 2b1ddce0b3d..00000000000
--- a/source/postprocess/visualization/nonadiabatic_pressure.cc.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/nonadiabatic_pressure.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      NonadiabaticPressure<dim>::
-      NonadiabaticPressure ()
-        :
-        DataPostprocessorScalar<dim> ("nonadiabatic_pressure",
-                                      update_values | update_quadrature_points),
-        Interface<dim>("Pa")
-      {}
-
-
-
-      template <int dim>
-      void
-      NonadiabaticPressure<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            const double pressure    = input_data.solution_values[q][this->introspection().component_indices.pressure];
-
-            computed_quantities[q](0) = pressure - this->get_adiabatic_conditions().pressure(input_data.evaluation_points[q]);
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(NonadiabaticPressure,
-                                                  "nonadiabatic pressure",
-                                                  "A visualization output object that generates output "
-                                                  "for the non-adiabatic component of the pressure."
-                                                  "\n\n"
-                                                  "The variable that is outputted this way is computed by "
-                                                  "taking the pressure at each point and subtracting "
-                                                  "from it the adiabatic pressure computed at the beginning "
-                                                  "of the simulation. Because the adiabatic pressure is "
-                                                  "one way of defining a static pressure background field, "
-                                                  "what this visualization postprocessor therefore produces is "
-                                                  "\\textit{one} way to compute a \\textit{dynamic "
-                                                  "pressure}. There are, however, other ways as well, "
-                                                  "depending on the choice of the ``background pressure''."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\pascal}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/nonadiabatic_temperature.cc.bak b/source/postprocess/visualization/nonadiabatic_temperature.cc.bak
deleted file mode 100644
index 5453645b5f2..00000000000
--- a/source/postprocess/visualization/nonadiabatic_temperature.cc.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/nonadiabatic_temperature.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      NonadiabaticTemperature<dim>::
-      NonadiabaticTemperature ()
-        :
-        DataPostprocessorScalar<dim> ("nonadiabatic_temperature",
-                                      update_values | update_quadrature_points),
-        Interface<dim>("K")
-      {}
-
-
-
-      template <int dim>
-      void
-      NonadiabaticTemperature<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            const double temperature = input_data.solution_values[q][this->introspection().component_indices.temperature];
-
-            computed_quantities[q](0) = temperature - this->get_adiabatic_conditions().temperature(input_data.evaluation_points[q]);
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(NonadiabaticTemperature,
-                                                  "nonadiabatic temperature",
-                                                  "A visualization output object that generates output "
-                                                  "for the non-adiabatic component of the temperature."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\kelvin}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/particle_count.cc.bak b/source/postprocess/visualization/particle_count.cc.bak
deleted file mode 100644
index f84d67b7386..00000000000
--- a/source/postprocess/visualization/particle_count.cc.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/particle_count.h>
-#include <aspect/particle/world.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      ParticleCount<dim>::
-      ParticleCount ()
-        :
-        CellDataVectorCreator<dim>("")  // no physical units
-      {}
-
-
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      ParticleCount<dim>::execute() const
-      {
-        const Particle::ParticleHandler<dim> &particle_handler =
-          this->get_particle_world(0).get_particle_handler();
-
-        std::pair<std::string, std::unique_ptr<Vector<float>>>
-        return_value ("particles_per_cell",
-                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-
-        // loop over all of the cells and count particles in them
-        for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              (*return_value.second)(cell->active_cell_index()) = static_cast<float> (particle_handler.n_particles_in_cell(cell));
-            }
-
-        return return_value;
-      }
-
-
-
-      template <int dim>
-      std::list<std::string>
-      ParticleCount<dim>::required_other_postprocessors() const
-      {
-        return {"particles"};
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ParticleCount,
-                                                  "particle count",
-                                                  "A visualization output object that generates output "
-                                                  "about the number of particles per cell."
-                                                  "\n\n"
-                                                  "Physical units: None.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/partition.cc.bak b/source/postprocess/visualization/partition.cc.bak
deleted file mode 100644
index 21986d38f4e..00000000000
--- a/source/postprocess/visualization/partition.cc.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/partition.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      Partition<dim>::
-      Partition ()
-        :
-        // we don't need to know about any of the solution values
-        // in order to determine the partition number. thus, no
-        // need to specify any update flags
-        DataPostprocessorScalar<dim> ("partition",
-                                      update_default),
-        Interface<dim>("")  // no physical units
-      {}
-
-
-
-      template <int dim>
-      void
-      Partition<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &/*input_data*/,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        Assert (computed_quantities[0].size() == 1, ExcInternalError());
-
-        for (auto &quantity : computed_quantities)
-          {
-            // simply get the partition number from the triangulation
-            quantity(0) = this->get_triangulation().locally_owned_subdomain();
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Partition,
-                                                  "partition",
-                                                  "A visualization output object that generates output "
-                                                  "for the parallel partition that every cell of the "
-                                                  "mesh is associated with."
-                                                  "\n\n"
-                                                  "Physical units: None.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/principal_stress.cc.bak b/source/postprocess/visualization/principal_stress.cc.bak
deleted file mode 100644
index 9dcc46507c7..00000000000
--- a/source/postprocess/visualization/principal_stress.cc.bak
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
-  Copyright (C) 2020 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/postprocess/visualization/principal_stress.h>
-
-#include <deal.II/base/symmetric_tensor.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      PrincipalStress<dim>::
-      PrincipalStress ()
-        :
-        DataPostprocessor<dim> (),
-        Interface<dim>("Pa")
-      {}
-
-
-
-      template <int dim>
-      std::vector<std::string>
-      PrincipalStress<dim>::
-      get_names () const
-      {
-        std::vector<std::string> solution_names;
-
-        // dim principal stress values
-        for (unsigned int i=0; i<dim; ++i)
-          solution_names.push_back("principal_stress_" + std::to_string(i+1));
-
-        // dim principal stress directions
-        for (unsigned int i=0; i<dim; ++i)
-          for (unsigned int j=0; j<dim; ++j)
-            solution_names.push_back("principal_stress_direction_" + std::to_string(i+1));
-
-        return solution_names;
-      }
-
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      PrincipalStress<dim>::
-      get_data_component_interpretation () const
-      {
-        std::vector<DataComponentInterpretation::DataComponentInterpretation> solution_components;
-
-        // dim principal stress values
-        for (unsigned int i=0; i<dim; ++i)
-          solution_components.push_back(DataComponentInterpretation::component_is_scalar);
-
-        // dim principal stress directions
-        for (unsigned int i=0; i<dim; ++i)
-          for (unsigned int j=0; j<dim; ++j)
-            solution_components.push_back(DataComponentInterpretation::component_is_part_of_vector);
-
-        return solution_components;
-      }
-
-
-
-      template <int dim>
-      UpdateFlags
-      PrincipalStress<dim>::
-      get_needed_update_flags () const
-      {
-        return update_values | update_gradients | update_quadrature_points;
-      }
-
-
-
-      template <int dim>
-      void
-      PrincipalStress<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError());
-        Assert (computed_quantities[0].size() == dim*dim + dim, ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-
-        // We do not need to compute anything but the viscosity
-        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-        // Compute the viscosity...
-        this->get_material_model().evaluate(in, out);
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            SymmetricTensor<2,dim> stress;
-
-            // Add elastic stresses if existent
-            if (this->get_parameters().enable_elasticity == false)
-              {
-                const SymmetricTensor<2,dim> deviatoric_strain_rate
-                  = (this->get_material_model().is_compressible()
-                     ?
-                     in.strain_rate[q] - 1./3. * trace(in.strain_rate[q]) * unit_symmetric_tensor<dim>()
-                     :
-                     in.strain_rate[q]);
-
-                // Compressive stress is positive in geoscience applications
-                stress = -2. * out.viscosities[q] * deviatoric_strain_rate;
-              }
-            else
-              {
-                // Compressive stress is positive in geoscience applications
-                stress[0][0] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
-                stress[1][1] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
-                stress[0][1] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
-
-                if (dim == 3)
-                  {
-                    stress[2][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
-                    stress[0][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
-                    stress[1][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
-                  }
-              }
-
-
-            if (use_deviatoric_stress == false)
-              stress += in.pressure[q] * unit_symmetric_tensor<dim>();
-
-            const std::array<std::pair<double, Tensor<1,dim>>, dim> principal_stresses_and_directions = eigenvectors(stress);
-
-            // dim principal stress values
-            for (unsigned int i=0; i<dim; ++i)
-              computed_quantities[q][i] = principal_stresses_and_directions[i].first;
-
-            // dim principal stress directions
-            for (unsigned int i=0; i<dim; ++i)
-              for (unsigned int j=0; j<dim; ++j)
-                computed_quantities[q][dim + i*dim + j] = principal_stresses_and_directions[i].second[j];
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      PrincipalStress<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Principal stress");
-            {
-              prm.declare_entry("Use deviatoric stress", "false",
-                                Patterns::Bool(),
-                                "Whether to use the deviatoric stress tensor "
-                                "instead of the full stress tensor to compute "
-                                "principal stress directions and values.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      PrincipalStress<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Principal stress");
-            {
-              use_deviatoric_stress = prm.get_bool("Use deviatoric stress");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(PrincipalStress,
-                                                  "principal stress",
-                                                  "A visualization output object that outputs the "
-                                                  "principal stresses and directions, i.e., the "
-                                                  "eigenvalues and eigenvectors of the stress tensor. "
-                                                  "Wikipedia defines principal stresses as follows: "
-                                                  "At every point in a stressed body there are at least "
-                                                  "three planes, called principal planes, with normal "
-                                                  "vectors, called principal directions, where the "
-                                                  "corresponding stress vector is perpendicular to the "
-                                                  "plane, and where there are no normal "
-                                                  "shear stresses. The three stresses normal to these "
-                                                  "principal planes are called principal stresses. "
-                                                  "This postprocessor can either operate on the full "
-                                                  "stress tensor or only on the deviatoric stress tensor, "
-                                                  "depending on what run-time parameters are set."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\pascal}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/seismic_anomalies.cc.bak b/source/postprocess/visualization/seismic_anomalies.cc.bak
deleted file mode 100644
index b60be579379..00000000000
--- a/source/postprocess/visualization/seismic_anomalies.cc.bak
+++ /dev/null
@@ -1,566 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/seismic_anomalies.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/lateral_averaging.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      SeismicVsAnomaly<dim>::
-      SeismicVsAnomaly ()
-        :
-        CellDataVectorCreator<dim>("")  // no physical units
-      {}
-
-
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      SeismicVsAnomaly<dim>::execute() const
-      {
-        std::pair<std::string, std::unique_ptr<Vector<float>>>
-        return_value ("Vs_anomaly",
-                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-
-        // Calculate the maximum depth of the domain
-        const double max_depth = this->get_geometry_model().maximal_depth();
-
-        // The following lines evaluate the Vs at a single point per cell
-        // and then compute the percentage deviation from the average in
-        // the slice within which the point lies
-        const QMidpoint<dim> quadrature_formula;
-        const unsigned int n_q_points = quadrature_formula.size();
-
-        FEValues<dim> fe_values (this->get_mapping(),
-                                 this->get_fe(),
-                                 quadrature_formula,
-                                 update_values   |
-                                 update_gradients |
-                                 update_quadrature_points );
-
-        MaterialModel::MaterialModelInputs<dim> in(n_q_points, this->n_compositional_fields());
-        MaterialModel::MaterialModelOutputs<dim> out(n_q_points, this->n_compositional_fields());
-        in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
-
-        std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-
-        switch (average_velocity_scheme)
-          {
-            case reference_profile:
-            {
-              MaterialModel::MaterialModelOutputs<dim> adiabatic_out(n_q_points, this->n_compositional_fields());
-
-              // Loop over the cells
-              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-                if (cell->is_locally_owned())
-                  {
-                    // Get the pressure, temperature and composition in the cell
-                    fe_values.reinit (cell);
-
-                    in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-                    out.additional_outputs.push_back(
-                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
-                    this->get_material_model().evaluate(in, out);
-
-
-
-                    // Substitute the adiabatic reference state for temperature and pressure,
-                    // then reevaluate the material model.
-                    in.temperature[0]=this->get_adiabatic_conditions().temperature(in.position[0]);
-                    in.pressure[0]=this->get_adiabatic_conditions().pressure(in.position[0]);
-
-                    adiabatic_out.additional_outputs.push_back(
-                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
-                    this->get_material_model().evaluate(in, adiabatic_out);
-
-
-
-                    MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
-                      = out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
-                    const double Vs = seismic_outputs->vs[0];
-
-                    MaterialModel::SeismicAdditionalOutputs<dim> *adiabatic_seismic_outputs
-                      = adiabatic_out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
-                    const double adiabatic_Vs = adiabatic_seismic_outputs->vs[0];
-
-                    // Compute the percentage deviation from the average
-                    (*return_value.second)(cell->active_cell_index()) = (Vs - adiabatic_Vs)/adiabatic_Vs*1e2;
-                  }
-              break;
-            }
-
-            case lateral_average:
-            {
-              // Calculate the Vs averages within n slices
-              std::vector<double> Vs_depth_average(n_slices);
-              this->get_lateral_averaging().get_Vs_averages(Vs_depth_average);
-
-              // Estimates of the lateral Vs average at each depth are required
-              // for all cell depths, including those
-              // shallower than the midpoint of the first slice or
-              // deeper than the midpoint of the last slice.
-              // For this reason, the vector of Vs averages need to be padded by
-              // one element before the first element and after the last element.
-              // Mirror padding is chosen as it provides the least biased estimator
-              // (in the absence of further information).
-              std::vector<double> padded_Vs_depth_average(n_slices+2);
-              padded_Vs_depth_average[0] = 2.*Vs_depth_average[0] - Vs_depth_average[1];
-              padded_Vs_depth_average[n_slices+1] = 2.*Vs_depth_average[n_slices-1] - Vs_depth_average[n_slices-2];
-              std::copy ( Vs_depth_average.begin(), Vs_depth_average.end(), padded_Vs_depth_average.begin() + 1 );
-
-              // Loop over the cells
-              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-                if (cell->is_locally_owned())
-                  {
-                    // Get the pressure, temperature and composition in the cell
-                    fe_values.reinit (cell);
-
-                    in.reinit (fe_values, cell, this->introspection(), this->get_solution());
-
-                    out.additional_outputs.push_back(
-                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
-                    this->get_material_model().evaluate(in, out);
-
-                    MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
-                      = out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
-                    const double Vs = seismic_outputs->vs[0];
-
-                    // Find the depth of the zeroth quadrature point in the cell and work out
-                    // the depth slice which has its center just above that point
-                    const double depth = this->get_geometry_model().depth(fe_values.quadrature_point(0));
-
-                    // Please note: static_cast<int> always truncates the double (i.e. 1.9 -> 1)
-                    // Here we subtract 0.5 to find the first slice with its center shallower than the cell,
-                    // and add 1 to take padding into account (-0.5 + 1.0 = +0.5)
-                    const double slice_depth = (depth*n_slices)/max_depth + 0.5;
-                    const unsigned int idx = static_cast<unsigned int>(slice_depth);
-                    const double fractional_slice = slice_depth - static_cast<double>(idx);
-                    Assert(idx<n_slices+1, ExcInternalError());
-
-                    // Compute the percentage deviation from the average
-                    const double Vs_average = (1. - fractional_slice)*padded_Vs_depth_average[idx] + fractional_slice*padded_Vs_depth_average[idx+1];
-                    (*return_value.second)(cell->active_cell_index()) = (Vs - Vs_average)/Vs_average * 100 /* per cent */;
-                  }
-              break;
-            }
-          }
-        return return_value;
-      }
-
-
-      template <int dim>
-      SeismicVpAnomaly<dim>::
-      SeismicVpAnomaly ()
-        :
-        CellDataVectorCreator<dim>("")   // no physical units
-      {}
-
-
-
-      template <int dim>
-      std::pair<std::string, std::unique_ptr<Vector<float>>>
-      SeismicVpAnomaly<dim>::execute() const
-      {
-        std::pair<std::string, std::unique_ptr<Vector<float>>>
-        return_value ("Vp_anomaly",
-                      std::make_unique<Vector<float>>(this->get_triangulation().n_active_cells()));
-
-        // Calculate the maximum depth of the domain
-        const double max_depth = this->get_geometry_model().maximal_depth();
-
-        // The following lines evaluate the Vp at a single point per cell
-        // and then compute the percentage deviation from the average in
-        // the slice within which the point lies
-        const QMidpoint<dim> quadrature_formula;
-        const unsigned int n_q_points = quadrature_formula.size();
-
-        FEValues<dim> fe_values (this->get_mapping(),
-                                 this->get_fe(),
-                                 quadrature_formula,
-                                 update_values   |
-                                 update_gradients |
-                                 update_quadrature_points );
-
-        MaterialModel::MaterialModelInputs<dim> in(n_q_points, this->n_compositional_fields());
-        MaterialModel::MaterialModelOutputs<dim> out(n_q_points, this->n_compositional_fields());
-        in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
-
-        std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-
-        switch (average_velocity_scheme)
-          {
-            case reference_profile:
-            {
-              MaterialModel::MaterialModelOutputs<dim> adiabatic_out(n_q_points, this->n_compositional_fields());
-
-              // Loop over the cells
-              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-                if (cell->is_locally_owned())
-                  {
-                    // Get the pressure, temperature and composition in the cell
-                    fe_values.reinit (cell);
-
-                    in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-                    out.additional_outputs.push_back(
-                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>>(n_q_points));
-                    this->get_material_model().evaluate(in, out);
-
-                    // Substitute the adiabatic reference state for temperature and pressure,
-                    // then reevaluate the material model.
-                    in.temperature[0]=this->get_adiabatic_conditions().temperature(in.position[0]);
-                    in.pressure[0]=this->get_adiabatic_conditions().pressure(in.position[0]);
-
-                    adiabatic_out.additional_outputs.push_back(
-                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
-                    this->get_material_model().evaluate(in, adiabatic_out);
-
-
-
-                    MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
-                      = out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
-                    const double Vp = seismic_outputs->vp[0];
-
-                    MaterialModel::SeismicAdditionalOutputs<dim> *adiabatic_seismic_outputs
-                      = adiabatic_out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
-                    const double adiabatic_Vp = adiabatic_seismic_outputs->vp[0];
-
-                    // Compute the percentage deviation from the average
-                    (*return_value.second)(cell->active_cell_index()) = (Vp - adiabatic_Vp)/adiabatic_Vp * 100 /* per cent */;
-                  }
-              break;
-            }
-
-            case lateral_average:
-            {
-              // Calculate the Vp averages within n slices
-              std::vector<double> Vp_depth_average(n_slices);
-              this->get_lateral_averaging().get_Vp_averages(Vp_depth_average);
-
-              // Estimates of the lateral Vp average at each depth are required
-              // for all cell depths, including those
-              // shallower than the midpoint of the first slice or
-              // deeper than the midpoint of the last slice.
-              // For this reason, the vector of Vp averages need to be padded by
-              // one element before the first element and after the last element.
-              // Mirror padding is chosen as it provides the least biased estimator
-              // (in the absence of further information).
-              std::vector<double> padded_Vp_depth_average(n_slices+2);
-              padded_Vp_depth_average[0] = 2.*Vp_depth_average[0] - Vp_depth_average[1];
-              padded_Vp_depth_average[n_slices+1] = 2.*Vp_depth_average[n_slices-1] - Vp_depth_average[n_slices-2];
-              std::copy ( Vp_depth_average.begin(), Vp_depth_average.end(), padded_Vp_depth_average.begin() + 1 );
-
-
-              // Loop over the cells
-              for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-                if (cell->is_locally_owned())
-                  {
-                    // Get the pressure, temperature and composition in the cell
-                    fe_values.reinit (cell);
-
-                    // get the various components of the solution, then
-                    // evaluate the material properties there
-                    fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
-                                                                                                 in.temperature);
-                    fe_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
-                                                                                              in.pressure);
-                    fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                                                                                                in.velocity);
-                    fe_values[this->introspection().extractors.pressure].get_function_gradients (this->get_solution(),
-                                                                                                 in.pressure_gradient);
-                    in.position = fe_values.get_quadrature_points();
-
-                    // Loop over compositional fields to get composition values
-                    for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                      fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
-                          composition_values[c]);
-                    for (unsigned int i=0; i<fe_values.n_quadrature_points; ++i)
-                      {
-                        for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                          in.composition[i][c] = composition_values[c][i];
-                      }
-                    in.current_cell = cell;
-
-                    out.additional_outputs.push_back(
-                      std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_q_points));
-                    this->get_material_model().evaluate(in, out);
-
-                    MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
-                      = out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>();
-                    const double Vp = seismic_outputs->vs[0];
-
-                    // Find the depth of the zeroth quadrature point in the cell and work out
-                    // the depth slice which has its center just above that point
-                    const double depth = this->get_geometry_model().depth(fe_values.quadrature_point(0));
-
-                    // Please note: static_cast<int> always truncates the double (i.e. 1.9 -> 1)
-                    // Here we subtract 0.5 to find the first slice with its center shallower than the cell,
-                    // and add 1 to take padding into account (-0.5 + 1.0 = +0.5)
-                    const double slice_depth = (depth*n_slices)/max_depth + 0.5;
-                    const unsigned int idx = static_cast<unsigned int>(slice_depth);
-                    const double fractional_slice = slice_depth - static_cast<double>(idx);
-                    Assert(idx<n_slices+1, ExcInternalError());
-
-                    // Compute the percentage deviation from the average
-                    const double Vp_average = (1. - fractional_slice)*padded_Vp_depth_average[idx] + fractional_slice*padded_Vp_depth_average[idx+1];
-                    (*return_value.second)(cell->active_cell_index()) = (Vp - Vp_average)/Vp_average*1e2;
-                  }
-              break;
-            }
-          }
-
-        return return_value;
-      }
-
-
-
-      template <int dim>
-      void
-      SeismicVsAnomaly<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Vs anomaly");
-            {
-
-              prm.declare_entry ("Average velocity scheme", "reference profile",
-                                 Patterns::Selection("reference profile|lateral average"),
-                                 "Scheme to compute the average velocity-depth "
-                                 "profile. The reference profile option evaluates "
-                                 "the conditions along the reference adiabat "
-                                 "according to the material model. "
-                                 "The lateral average option instead calculates "
-                                 "a lateral average from subdivision of the mesh. "
-                                 "The lateral average option may produce spurious "
-                                 "results where there are sharp velocity changes.");
-
-              prm.declare_entry ("Number of depth slices", "50",
-                                 Patterns::Integer (1),
-                                 "Number of depth slices used to define "
-                                 "average seismic shear wave velocities "
-                                 "from which anomalies are calculated. "
-                                 "Units: non-dimensional.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      SeismicVsAnomaly<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        // First make sure the material model actually provides seismic velocities
-        MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
-        this->get_material_model().create_additional_named_outputs(out);
-
-        const bool material_model_provides_seismic_output =
-          (out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>() != nullptr);
-
-        AssertThrow(material_model_provides_seismic_output,
-                    ExcMessage("You requested the 'Vs anomaly' postprocessor, "
-                               "but the material model does not provide seismic velocities. Either remove 'Vs anomaly', "
-                               "or use a material model that provides these velocities."));
-
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Vs anomaly");
-            {
-              // Average velocity scheme
-              if (prm.get ("Average velocity scheme") == "reference profile")
-                average_velocity_scheme = reference_profile;
-              else if (prm.get ("Average velocity scheme") == "lateral average")
-                average_velocity_scheme = lateral_average;
-              else
-                AssertThrow(false, ExcMessage("Not a valid average velocity scheme."));
-
-              n_slices = prm.get_integer ("Number of depth slices");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      SeismicVpAnomaly<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Vp anomaly");
-            {
-
-              prm.declare_entry ("Average velocity scheme", "reference profile",
-                                 Patterns::Selection("reference profile|lateral average"),
-                                 "Scheme to compute the average velocity-depth "
-                                 "profile. The reference profile option evaluates "
-                                 "the conditions along the reference adiabat "
-                                 "according to the material model. "
-                                 "The lateral average option instead calculates "
-                                 "a lateral average from subdivision of the mesh. "
-                                 "The lateral average option may produce spurious "
-                                 "results where there are sharp velocity changes.");
-
-              prm.declare_entry ("Number of depth slices", "50",
-                                 Patterns::Integer (1),
-                                 "Number of depth slices used to define "
-                                 "average seismic compressional wave velocities "
-                                 "from which anomalies are calculated. "
-                                 "Units: non-dimensional.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      SeismicVpAnomaly<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        // First make sure the material model actually provides seismic velocities
-        MaterialModel::MaterialModelOutputs<dim> out(1, this->n_compositional_fields());
-        this->get_material_model().create_additional_named_outputs(out);
-
-        const bool material_model_provides_seismic_output =
-          (out.template get_additional_output<MaterialModel::SeismicAdditionalOutputs<dim>>() != nullptr);
-
-        AssertThrow(material_model_provides_seismic_output,
-                    ExcMessage("You requested the 'Vp anomaly' postprocessor, "
-                               "but the material model does not provide seismic velocities. Either remove 'Vp anomaly', "
-                               "or use a material model that provides these velocities."));
-
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Vp anomaly");
-            {
-              // Average velocity scheme
-              if (prm.get ("Average velocity scheme") == "reference profile")
-                average_velocity_scheme = reference_profile;
-              else if (prm.get ("Average velocity scheme") == "lateral average")
-                average_velocity_scheme = lateral_average;
-              else
-                AssertThrow(false, ExcMessage("Not a valid average velocity scheme."));
-
-              n_slices = prm.get_integer ("Number of depth slices");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SeismicVsAnomaly,
-                                                  "Vs anomaly",
-                                                  "A visualization output object that generates output "
-                                                  "showing the percentage anomaly in the seismic "
-                                                  "shear wave speed $V_s$ as a spatially variable "
-                                                  "function with one value per cell. This anomaly is either "
-                                                  "shown as a percentage anomaly relative to the reference "
-                                                  "profile given by adiabatic conditions (with the "
-                                                  "compositions given by the current composition, such that "
-                                                  "the reference could potentially change through time), or "
-                                                  "as a percentage change relative to the laterally averaged "
-                                                  "velocity at the depth of the cell. This velocity is "
-                                                  "calculated by linear interpolation between average values "
-                                                  "calculated within equally thick depth slices. The "
-                                                  "number of depth slices in the domain is user-defined. "
-                                                  "Typically, the best results will be obtained if the number "
-                                                  "of depth slices is balanced between being large enough to "
-                                                  "capture step changes in velocities, but small enough to "
-                                                  "maintain a reasonable number of evaluation points per slice. "
-                                                  "Bear in mind that lateral averaging subsamples the "
-                                                  "finite element mesh. Note that this plugin requires a "
-                                                  "material model that provides seismic velocities."
-                                                  "\n\n"
-                                                  "Physical units: None, the quantity being output is a "
-                                                  "fractional change provided as a percentage.")
-
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SeismicVpAnomaly,
-                                                  "Vp anomaly",
-                                                  "A visualization output object that generates output "
-                                                  "showing the percentage anomaly in the seismic "
-                                                  "compressional wave speed $V_p$ as a spatially variable "
-                                                  "function with one value per cell. This anomaly is either "
-                                                  "shown as a percentage anomaly relative to the reference "
-                                                  "profile given by adiabatic conditions (with the "
-                                                  "compositions given by the current composition, such that "
-                                                  "the reference could potentially change through time), or "
-                                                  "as a percentage change relative to the laterally averaged "
-                                                  "velocity at the depth of the cell. This velocity is "
-                                                  "calculated by linear interpolation between average values "
-                                                  "calculated within equally thick depth slices. The "
-                                                  "number of depth slices in the domain is user-defined. "
-                                                  "Typically, the best results will be obtained if the number "
-                                                  "of depth slices is balanced between being large enough to "
-                                                  "capture step changes in velocities, but small enough to "
-                                                  "maintain a reasonable number of evaluation points per slice. "
-                                                  "Bear in mind that lateral averaging subsamples the "
-                                                  "finite element mesh. Note that this plugin requires a "
-                                                  "material model that provides seismic velocities."
-                                                  "\n\n"
-                                                  "Physical units: None, the quantity being output is a "
-                                                  "fractional change provided as a percentage.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/shear_stress.cc.bak b/source/postprocess/visualization/shear_stress.cc.bak
deleted file mode 100644
index 49f0f54ce42..00000000000
--- a/source/postprocess/visualization/shear_stress.cc.bak
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/shear_stress.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      ShearStress<dim>::
-      ShearStress ()
-        :
-        DataPostprocessorTensor<dim> ("shear_stress",
-                                      update_values | update_gradients | update_quadrature_points),
-        Interface<dim>("Pa")
-      {}
-
-
-
-      template <int dim>
-      void
-      ShearStress<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
-                ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-
-        // We do not need to compute anything but the viscosity
-        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-        // Compute the viscosity...
-        this->get_material_model().evaluate(in, out);
-
-        // ...and use it to compute the stresses
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            // Compressive stress is negative by the sign convention
-            // used by the engineering community, and as input and used
-            // internally by ASPECT.
-            // Here, we change the sign of the stress to match the
-            // sign convention used by the geoscience community.
-            SymmetricTensor<2,dim> shear_stress;
-
-            // If elasticity is enabled, the deviatoric stress is stored
-            // in compositional fields, otherwise the deviatoric stress
-            // can be obtained from the viscosity and strain rate.
-            if (this->get_parameters().enable_elasticity == true)
-              {
-                shear_stress[0][0] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
-                shear_stress[1][1] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
-                shear_stress[0][1] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
-
-                if (dim == 3)
-                  {
-                    shear_stress[2][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
-                    shear_stress[0][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
-                    shear_stress[1][2] = -in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
-                  }
-              }
-            else
-              {
-                const SymmetricTensor<2,dim> strain_rate = in.strain_rate[q];
-                const SymmetricTensor<2,dim> deviatoric_strain_rate
-                  = (this->get_material_model().is_compressible()
-                     ?
-                     strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
-                     :
-                     strain_rate);
-
-                const double eta = out.viscosities[q];
-                shear_stress = -2. * eta * deviatoric_strain_rate;
-              }
-
-            for (unsigned int d=0; d<dim; ++d)
-              for (unsigned int e=0; e<dim; ++e)
-                computed_quantities[q][Tensor<2,dim>::component_to_unrolled_index(TableIndices<2>(d,e))]
-                  = shear_stress[d][e];
-          }
-
-        // average the values if requested
-        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
-        if (!viz.output_pointwise_stress_and_strain())
-          average_quantities(computed_quantities);
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(ShearStress,
-                                                  "shear stress",
-                                                  "A visualization output object that generates output "
-                                                  "for the 3 (in 2d) or 6 (in 3d) components of the shear stress "
-                                                  "tensor, i.e., for the components of the tensor "
-                                                  "$-2\\eta\\varepsilon(\\mathbf u)$ "
-                                                  "in the incompressible case and "
-                                                  "$-2\\eta\\left[\\varepsilon(\\mathbf u)-"
-                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I\\right]$ "
-                                                  "in the compressible case. If elasticity is used, the "
-                                                  "elastic contribution is being accounted for. The shear "
-                                                  "stress differs from the full stress tensor "
-                                                  "by the absence of the pressure. Note that the convention "
-                                                  "of positive compressive stress is followed."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\pascal}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/spd_factor.cc.bak b/source/postprocess/visualization/spd_factor.cc.bak
deleted file mode 100644
index 85a153d00af..00000000000
--- a/source/postprocess/visualization/spd_factor.cc.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/spd_factor.h>
-#include <aspect/newton.h>
-#include <aspect/utilities.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      SPD_Factor<dim>::
-      SPD_Factor ()
-        :
-        DataPostprocessorScalar<dim> ("spd_factor",
-                                      update_values | update_gradients | update_quadrature_points),
-        Interface<dim>("")  // no physical units
-      {}
-
-
-
-      template <int dim>
-      void
-      SPD_Factor<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,                             ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,                                            ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,    ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-        in.requested_properties = MaterialModel::MaterialProperties::viscosity | MaterialModel::MaterialProperties::additional_outputs;
-
-        out.additional_outputs.push_back(
-          std::make_unique<MaterialModel::MaterialModelDerivatives<dim>> (n_quadrature_points));
-
-        this->get_material_model().evaluate(in, out);
-
-        const MaterialModel::MaterialModelDerivatives<dim> *derivatives = out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            computed_quantities[q](0) = Utilities::compute_spd_factor<dim>(out.viscosities[q],
-                                                                           in.strain_rate[q],
-                                                                           derivatives->viscosity_derivative_wrt_strain_rate[q],
-                                                                           this->get_newton_handler().parameters.SPD_safety_factor);
-          }
-      }
-
-      template <int dim>
-      void
-      SPD_Factor<dim>::parse_parameters (ParameterHandler &/*prm*/)
-      {
-        AssertThrow(Parameters<dim>::is_defect_correction(this->get_parameters().nonlinear_solver),
-                    ExcMessage("The SPD factor plugin can only be used with defect correction type Stokes or Newton Stokes "
-                               "solvers."));
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SPD_Factor,
-                                                  "spd factor",
-                                                  "A visualization output object that generates output "
-                                                  "for the spd factor. The spd factor is a factor which "
-                                                  "scales a part of the Jacobian used for the Newton solver "
-                                                  "to make sure that the Jacobian remains positive definite."
-                                                  "\n\n"
-                                                  "Physical units: None.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/spherical_velocity_components.cc.bak b/source/postprocess/visualization/spherical_velocity_components.cc.bak
deleted file mode 100644
index 8ab0c707a44..00000000000
--- a/source/postprocess/visualization/spherical_velocity_components.cc.bak
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/spherical_velocity_components.h>
-#include <aspect/utilities.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      SphericalVelocityComponents<dim>::
-      SphericalVelocityComponents ()
-        :
-        DataPostprocessorVector<dim> ("spherical_velocity_components",
-                                      update_values | update_quadrature_points),
-        Interface<dim>()    // unknown units at construction time, will be filled by a separate function
-      {}
-
-
-
-      template <int dim>
-      std::string
-      SphericalVelocityComponents<dim>::
-      get_physical_units () const
-      {
-        if (this->convert_output_to_years())
-          return "m/year";
-        else
-          return "m/s";
-      }
-
-
-
-      template <int dim>
-      void
-      SphericalVelocityComponents<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.evaluation_points.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == dim,    ExcInternalError());
-
-        const double velocity_scaling_factor =
-          this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-        Tensor<1,dim> velocity;
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            for (unsigned int d = 0; d < dim; ++d)
-              {
-                velocity[d] = input_data.solution_values[q][this->introspection().component_indices.velocities[d]] * velocity_scaling_factor;
-              }
-
-            std::array<double,dim> scoord = aspect::Utilities::Coordinates::cartesian_to_spherical_coordinates(input_data.evaluation_points[q]);
-
-            if (dim==2)
-              {
-                computed_quantities[q](0) =  std::cos(scoord[1])*velocity[0]+std::sin(scoord[1])*velocity[1]; // v_r
-                computed_quantities[q](1) = -std::sin(scoord[1])*velocity[0]+std::cos(scoord[1])*velocity[1]; // v_scoord[1]
-              }
-
-            if (dim==3)
-              {
-                computed_quantities[q](0) = velocity[0]*(std::sin(scoord[2])*std::cos(scoord[1]))
-                                            + velocity[1]*(std::sin(scoord[2])*std::sin(scoord[1]))
-                                            + velocity[2]*(std::cos(scoord[2]));                // v_r
-                computed_quantities[q](1) = velocity[0]*(-std::sin(scoord[1]))
-                                            + velocity[1]*(std::cos(scoord[1]));                // v_phi
-                computed_quantities[q](2) = velocity[0]*(std::cos(scoord[2])*std::cos(scoord[1]))
-                                            + velocity[1]*(std::cos(scoord[2])*std::sin(scoord[1]))
-                                            + velocity[2]*(-std::sin(scoord[2]));               // v_theta
-              }
-          }
-      }
-
-
-      template <int dim>
-      std::vector<std::string>
-      SphericalVelocityComponents<dim>::get_names () const
-      {
-        std::vector<std::string> names;
-        names.emplace_back("v_r");
-        names.emplace_back("v_phi");
-        if (dim==3)
-          names.emplace_back("v_theta");
-        return names;
-      }
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      SphericalVelocityComponents<dim>::get_data_component_interpretation () const
-      {
-        return
-          std::vector<DataComponentInterpretation::DataComponentInterpretation>
-          (dim,DataComponentInterpretation::component_is_scalar);
-      }
-
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SphericalVelocityComponents,
-                                                  "spherical velocity components",
-                                                  "A visualization output object that outputs the polar coordinates "
-                                                  "components $v_r$ and $v_\\phi$ of the velocity field in 2d and the "
-                                                  "spherical coordinates components $v_r$, $v_{\\phi}$ and $v_{\\theta}$ "
-                                                  "of the velocity field in 3d."
-                                                  "\n\n"
-                                                  "Physical units: $\\frac{\\text{m}}{\\text{s}}$ or "
-                                                  "$\\frac{\\text{m}}{\\text{year}}$, depending on settings in the input file.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/strain_rate.cc.bak b/source/postprocess/visualization/strain_rate.cc.bak
deleted file mode 100644
index a50e49e8c1c..00000000000
--- a/source/postprocess/visualization/strain_rate.cc.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/strain_rate.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      StrainRate<dim>::
-      StrainRate ()
-        :
-        DataPostprocessorScalar<dim> ("strain_rate",
-                                      update_gradients | update_quadrature_points),
-        Interface<dim>("1/s")
-      {}
-
-
-
-      template <int dim>
-      void
-      StrainRate<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,
-                ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,
-                ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            Tensor<2,dim> grad_u;
-            for (unsigned int d=0; d<dim; ++d)
-              grad_u[d] = input_data.solution_gradients[q][d];
-
-            const SymmetricTensor<2,dim> strain_rate = symmetrize (grad_u);
-            computed_quantities[q](0) = std::sqrt(std::max(-second_invariant(deviator(strain_rate)), 0.));
-          }
-
-        // average the values if requested
-        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
-        if (!viz.output_pointwise_stress_and_strain())
-          average_quantities(computed_quantities);
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(StrainRate,
-                                                  "strain rate",
-                                                  "A visualization output object that generates output "
-                                                  "for the norm of the strain rate, i.e., for the quantity "
-                                                  "$\\sqrt{\\varepsilon(\\mathbf u):\\varepsilon(\\mathbf u)}$ "
-                                                  "in the incompressible case and "
-                                                  "$\\sqrt{[\\varepsilon(\\mathbf u)-\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I]:"
-                                                  "[\\varepsilon(\\mathbf u)-\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I]}$ "
-                                                  "in the compressible case."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\per\\second}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/strain_rate_tensor.cc.bak b/source/postprocess/visualization/strain_rate_tensor.cc.bak
deleted file mode 100644
index a68de211733..00000000000
--- a/source/postprocess/visualization/strain_rate_tensor.cc.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/strain_rate_tensor.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      StrainRateTensor<dim>::
-      StrainRateTensor ()
-        :
-        DataPostprocessorTensor<dim> ("strain_rate_tensor",
-                                      update_gradients | update_quadrature_points),
-        Interface<dim>("1/s")
-      {}
-
-
-
-      template <int dim>
-      void
-      StrainRateTensor<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError());
-        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
-                ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            Tensor<2,dim> grad_u;
-            for (unsigned int d=0; d<dim; ++d)
-              grad_u[d] = input_data.solution_gradients[q][d];
-
-            const SymmetricTensor<2,dim> strain_rate = symmetrize(grad_u);
-            const Tensor<2,dim> deviatoric_strain_rate
-              = (this->get_material_model().is_compressible()
-                 ?
-                 strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
-                 :
-                 strain_rate);
-
-            for (unsigned int d=0; d<dim; ++d)
-              for (unsigned int e=0; e<dim; ++e)
-                computed_quantities[q][Tensor<2,dim>::component_to_unrolled_index(TableIndices<2>(d,e))]
-                  = deviatoric_strain_rate[d][e];
-          }
-
-        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
-        if (!viz.output_pointwise_stress_and_strain())
-          average_quantities(computed_quantities);
-
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(StrainRateTensor,
-                                                  "strain rate tensor",
-                                                  "A visualization output object that generates output "
-                                                  "for the 4 (in 2d) or 9 (in 3d) components of the strain rate "
-                                                  "tensor, i.e., for the components of the tensor "
-                                                  "$\\varepsilon(\\mathbf u)$ "
-                                                  "in the incompressible case and "
-                                                  "$\\varepsilon(\\mathbf u)-"
-                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I$ "
-                                                  "in the compressible case."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\per\\second}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/stress.cc.bak b/source/postprocess/visualization/stress.cc.bak
deleted file mode 100644
index d4016b866d3..00000000000
--- a/source/postprocess/visualization/stress.cc.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/stress.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      Stress<dim>::
-      Stress ()
-        :
-        DataPostprocessorTensor<dim> ("stress",
-                                      update_values | update_gradients | update_quadrature_points),
-        Interface<dim>("Pa")
-      {}
-
-
-
-      template <int dim>
-      void
-      Stress<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
-                ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-
-        // We do not need to compute anything but the viscosity
-        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-        // Compute the viscosity...
-        this->get_material_model().evaluate(in, out);
-
-        // ...and use it to compute the stresses
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            // Compressive stress is negative by the sign convention
-            // used by the engineering community, and as input and used
-            // internally by ASPECT.
-            // Here, we change the sign of the stress to match the
-            // sign convention used by the geoscience community.
-            SymmetricTensor<2,dim> stress = in.pressure[q] * unit_symmetric_tensor<dim>();
-
-            // If elasticity is enabled, the deviatoric stress is stored
-            // in compositional fields, otherwise the deviatoric stress
-            // can be obtained from the viscosity and strain rate.
-            if (this->get_parameters().enable_elasticity)
-              {
-                stress[0][0] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
-                stress[1][1] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
-                stress[0][1] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
-
-                if (dim == 3)
-                  {
-                    stress[2][2] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
-                    stress[0][2] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
-                    stress[1][2] -= in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
-                  }
-              }
-            else
-              {
-                const SymmetricTensor<2,dim> strain_rate = in.strain_rate[q];
-                const SymmetricTensor<2,dim> deviatoric_strain_rate
-                  = (this->get_material_model().is_compressible()
-                     ?
-                     strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
-                     :
-                     strain_rate);
-
-                const double eta = out.viscosities[q];
-                stress -= 2. * eta * deviatoric_strain_rate;
-              }
-
-            for (unsigned int d=0; d<dim; ++d)
-              for (unsigned int e=0; e<dim; ++e)
-                computed_quantities[q][Tensor<2,dim>::component_to_unrolled_index(TableIndices<2>(d,e))]
-                  = stress[d][e];
-          }
-
-        // average the values if requested
-        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
-        if (!viz.output_pointwise_stress_and_strain())
-          average_quantities(computed_quantities);
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(Stress,
-                                                  "stress",
-                                                  "A visualization output object that generates output "
-                                                  "for the 3 (in 2d) or 6 (in 3d) components of the stress "
-                                                  "tensor, i.e., for the components of the tensor "
-                                                  "$-2\\eta\\varepsilon(\\mathbf u)+pI$ "
-                                                  "in the incompressible case and "
-                                                  "$-2\\eta\\left[\\varepsilon(\\mathbf u)-"
-                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I\\right]+pI$ "
-                                                  "in the compressible case. If elasticity is used, the "
-                                                  "elastic contribution is being accounted for. "
-                                                  "Note that the convention of positive "
-                                                  "compressive stress is followed."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\pascal}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/stress_second_invariant.cc.bak b/source/postprocess/visualization/stress_second_invariant.cc.bak
deleted file mode 100644
index 1b2f4c87b6f..00000000000
--- a/source/postprocess/visualization/stress_second_invariant.cc.bak
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/postprocess/visualization/stress_second_invariant.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      StressSecondInvariant<dim>::
-      StressSecondInvariant ()
-        :
-        DataPostprocessorScalar<dim> ("stress_second_invariant",
-                                      update_values | update_gradients | update_quadrature_points),
-        Interface<dim>("Pa")
-      {}
-
-
-
-      template <int dim>
-      void
-      StressSecondInvariant<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert(computed_quantities.size() == n_quadrature_points, ExcInternalError());
-        Assert(computed_quantities[0].size() == 1, ExcInternalError());
-        Assert(input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError());
-        Assert(input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
-
-        // Create the material model inputs and outputs to
-        // retrieve the current viscosity.
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-
-        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-
-        this->get_material_model().evaluate(in, out);
-
-        for (unsigned int q = 0; q < n_quadrature_points; ++q)
-          {
-            // Compressive stress is positive in geoscience applications.
-            SymmetricTensor<2, dim> stress = in.pressure[q] * unit_symmetric_tensor<dim>();
-
-            // Add elastic stresses if existent.
-            if (this->get_parameters().enable_elasticity == true)
-              {
-                stress[0][0] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
-                stress[1][1] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
-                stress[0][1] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
-
-                if (dim == 3)
-                  {
-                    stress[2][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
-                    stress[0][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
-                    stress[1][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
-                  }
-              }
-            else
-              {
-                const SymmetricTensor<2, dim> strain_rate = in.strain_rate[q];
-                const SymmetricTensor<2, dim> deviatoric_strain_rate = (this->get_material_model().is_compressible()
-                                                                        ? strain_rate - 1. / 3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
-                                                                        : strain_rate);
-
-                const double eta = out.viscosities[q];
-
-                stress += -2. * eta * deviatoric_strain_rate;
-              }
-
-            // Compute the deviatoric stress tensor after elastic stresses were added.
-            const SymmetricTensor<2, dim> deviatoric_stress = deviator(stress);
-
-            // Compute the second moment invariant of the deviatoric stress
-            // in the same way as the second moment invariant of the deviatoric
-            // strain rate is computed in the viscoplastic material model.
-            // TODO check that this is valid for the compressible case.
-            const double stress_invariant = std::sqrt(std::max(-second_invariant(deviatoric_stress), 0.));
-
-            computed_quantities[q](0) = stress_invariant;
-          }
-
-        // average the values if requested
-        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
-        if (!viz.output_pointwise_stress_and_strain())
-          average_quantities(computed_quantities);
-      }
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(StressSecondInvariant,
-                                                  "stress second invariant",
-                                                  "A visualization output object that outputs "
-                                                  "the second moment invariant of the deviatoric stress tensor."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\pascal}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/surface_dynamic_topography.cc.bak b/source/postprocess/visualization/surface_dynamic_topography.cc.bak
deleted file mode 100644
index 8b18c62e0ad..00000000000
--- a/source/postprocess/visualization/surface_dynamic_topography.cc.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/postprocess/visualization/surface_dynamic_topography.h>
-#include <aspect/postprocess/dynamic_topography.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      SurfaceDynamicTopography<dim>::
-      SurfaceDynamicTopography ()
-        :
-        DataPostprocessorScalar<dim> ("surface_dynamic_topography",
-                                      update_quadrature_points),
-        Interface<dim>("m")
-      {}
-
-
-
-      template <int dim>
-      void
-      SurfaceDynamicTopography<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        // Initialize everything to zero, so that we can ignore faces we are
-        // not interested in (namely, those not labeled as 'top' or 'bottom')
-        for (auto &quantity : computed_quantities)
-          quantity(0) = 0;
-
-        const Postprocess::DynamicTopography<dim> &dynamic_topography =
-          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::DynamicTopography<dim>>();
-
-        auto cell = input_data.template get_cell<dim>();
-
-        // We only want to output dynamic topography at the top and bottom
-        // boundary, so only compute it if the current cell has
-        // a face at the top or bottom boundary.
-        bool cell_at_top_or_bottom_boundary = false;
-        for (const unsigned int f : cell->face_indices())
-          if (cell->at_boundary(f) &&
-              (this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "top" ||
-               this->get_geometry_model().translate_id_to_symbol_name (cell->face(f)->boundary_id()) == "bottom"))
-            cell_at_top_or_bottom_boundary = true;
-
-        if (cell_at_top_or_bottom_boundary)
-          {
-            std::vector<Point<dim>> quadrature_points(input_data.evaluation_points.size());
-            for (unsigned int i=0; i<input_data.evaluation_points.size(); ++i)
-              quadrature_points[i] = this->get_mapping().transform_real_to_unit_cell(cell,input_data.evaluation_points[i]);
-
-            const Quadrature<dim> quadrature_formula(quadrature_points);
-
-            FEValues<dim> fe_volume_values (this->get_mapping(),
-                                            this->get_fe(),
-                                            quadrature_formula,
-                                            update_values);
-
-            fe_volume_values.reinit(cell);
-
-            std::vector<double> dynamic_topography_values(quadrature_formula.size());
-
-            // It might seem unintuitive to use the extractor for the temperature block,
-            // but that is where dynamic_topography.topography_vector() stores the values.
-            // See the documentation of that function for more details.
-            fe_volume_values[this->introspection().extractors.temperature].get_function_values(dynamic_topography.topography_vector(),
-                dynamic_topography_values);
-
-            for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-              computed_quantities[q](0) = dynamic_topography_values[q];
-          }
-      }
-
-
-
-      /**
-       * Register the other postprocessor that we need: DynamicTopography
-       */
-      template <int dim>
-      std::list<std::string>
-      SurfaceDynamicTopography<dim>::required_other_postprocessors() const
-      {
-        return {"dynamic topography"};
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SurfaceDynamicTopography,
-                                                  "surface dynamic topography",
-                                                  "A visualization output object that generates output "
-                                                  "for the dynamic topography at the top and bottom of the model space. "
-                                                  "The actual computation of this topography is handled inside the "
-                                                  "'dynamic topography' postprocessor, please check its documentation "
-                                                  "for details about the numerical methods."
-                                                  "\n\n"
-                                                  "In contrast to the `dynamic topography' visualization postprocessor, this "
-                                                  "plugin really only evaluates the dynamic topography at faces of cells "
-                                                  "that are adjacent to `bottom' and `top' boundaries, and only outputs "
-                                                  "information on the surface of the domain, rather than padding the "
-                                                  "information with zeros in the interior of the domain."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\meter}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/surface_elevation.cc.bak b/source/postprocess/visualization/surface_elevation.cc.bak
deleted file mode 100644
index a73286d9270..00000000000
--- a/source/postprocess/visualization/surface_elevation.cc.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/simulator.h>
-#include <aspect/postprocess/visualization/surface_elevation.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      SurfaceElevation<dim>::
-      SurfaceElevation ()
-        :
-        DataPostprocessorScalar<dim> ("surface_elevation",
-                                      update_quadrature_points),
-        Interface<dim>("m")
-      {}
-
-
-
-      template <int dim>
-      void
-      SurfaceElevation<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        // Initialize everything to zero, so that we can ignore faces we are
-        // not interested in (namely, those not labeled as 'top' or 'bottom')
-        for (auto &quantity : computed_quantities)
-          quantity(0) = 0;
-
-        // We only want to output dynamic topography at the top
-        // boundary. We know that this class will only be called on faces
-        // (because it is derived from SurfaceOnlyVisualization), so it is safe
-        // to query both cell and face associated with the DataPostprocessorInputs
-        // object.
-        const types::boundary_id boundary_id
-          = input_data.template get_cell<dim>()->face(input_data.get_face_number())->boundary_id();
-        if (this->get_geometry_model().translate_id_to_symbol_name (boundary_id) == "top")
-          for (unsigned int q=0; q<input_data.evaluation_points.size(); ++q)
-            computed_quantities[q](0)
-              = this->get_geometry_model().height_above_reference_surface(input_data.evaluation_points[q]);
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SurfaceElevation,
-                                                  "surface elevation",
-                                                  "This postprocessor is used to visualize the elevation of points "
-                                                  "on the surface of the geometry relative to a ``reference "
-                                                  "elevation'' defined by an undeformed geometry. It can be used, "
-                                                  "for example, to visualize an initial topography field, as well "
-                                                  "as the result of dynamic surface deformation due to a free "
-                                                  "surface."
-                                                  "\n\n"
-                                                  "The surface elevation is computed only for those parts of the "
-                                                  "boundary that the geometry description marks as ``top''. "
-                                                  "On all other parts of the boundary, the class outputs a zero "
-                                                  "elevation."
-                                                  "\n\n"
-                                                  "It is worth comparing this visualization postprocessor with the "
-                                                  "one called ``depth''. The latter is used to visualize a volume "
-                                                  "variable, whereas the current one only outputs information on "
-                                                  "the surface. Moreover ``depth'' is based on a member function of "
-                                                  "the geometry models that is documented as never returning a "
-                                                  "number less than zero -- in other words, it returns the depth "
-                                                  "of an evaluation point with regard to a reference surface that "
-                                                  "defines a zero depth, but for points that lie above this "
-                                                  "reference surface, it returns zero. As a consequence, it cannot "
-                                                  "be used to visualize positive elevations, whereas the current "
-                                                  "visualization postprocessor can."
-                                                  "\n\n"
-                                                  "Finally, it is worth pointing out the ``topography'' "
-                                                  "postprocessor (not a visualization postprocessor) that returns "
-                                                  "the surface elevation as a point cloud into a text file. The "
-                                                  "information is comparable to what the current object creates, "
-                                                  "but it is not as easily used to visualize information."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\meter}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/surface_strain_rate_tensor.cc.bak b/source/postprocess/visualization/surface_strain_rate_tensor.cc.bak
deleted file mode 100644
index 6dd8b5c02ef..00000000000
--- a/source/postprocess/visualization/surface_strain_rate_tensor.cc.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/surface_strain_rate_tensor.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      SurfaceStrainRateTensor<dim>::
-      SurfaceStrainRateTensor()
-        : DataPostprocessorTensor<dim>("surface_strain_rate_tensor",
-                                       update_gradients | update_quadrature_points),
-        Interface<dim>("1/s")
-      {}
-
-
-
-      template <int dim>
-      void
-      SurfaceStrainRateTensor<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError());
-        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
-                ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components, ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            Tensor<2,dim> grad_u;
-            for (unsigned int d=0; d<dim; ++d)
-              grad_u[d] = input_data.solution_gradients[q][d];
-
-            const SymmetricTensor<2,dim> strain_rate = symmetrize(grad_u);
-            const Tensor<2,dim> deviatoric_strain_rate
-              = (this->get_material_model().is_compressible()
-                 ?
-                 strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
-                 :
-                 strain_rate);
-
-            for (unsigned int d = 0; d < dim; ++d)
-              for (unsigned int e = 0; e < dim; ++e)
-                computed_quantities[q][Tensor<2, dim>::component_to_unrolled_index(TableIndices<2>(d, e))]
-                  = deviatoric_strain_rate[d][e];
-          }
-
-        // average the values if requested
-        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
-        if (!viz.output_pointwise_stress_and_strain())
-          average_quantities(computed_quantities);
-
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SurfaceStrainRateTensor,
-                                                  "surface strain rate tensor",
-                                                  "A visualization output object that generates output "
-                                                  "on the surface of the domain "
-                                                  "for the 4 (in 2d) or 9 (in 3d) components of the strain rate "
-                                                  "tensor, i.e., for the components of the tensor "
-                                                  "$\\varepsilon(\\mathbf u)$ "
-                                                  "in the incompressible case and "
-                                                  "$\\varepsilon(\\mathbf u)-"
-                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I$ "
-                                                  "in the compressible case."
-                                                  "Note that both in 2d and in 3d the output tensor will have 9 "
-                                                  "elements, but that in 2d, only 4 are filled. "
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\per\\second}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/surface_stress.cc.bak b/source/postprocess/visualization/surface_stress.cc.bak
deleted file mode 100644
index f1dea24cc0f..00000000000
--- a/source/postprocess/visualization/surface_stress.cc.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/surface_stress.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      SurfaceStress<dim>::
-      SurfaceStress ()
-        :
-        DataPostprocessorTensor<dim> ("surface_stress",
-                                      update_values | update_gradients | update_quadrature_points),
-        Interface<dim>("Pa")
-      {}
-
-
-
-      template <int dim>
-      void
-      SurfaceStress<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert ((computed_quantities[0].size() == Tensor<2,dim>::n_independent_components),
-                ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,   ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,  ExcInternalError());
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-
-        // We do not need to compute anything but the viscosity
-        in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-        // Compute the viscosity...
-        this->get_material_model().evaluate(in, out);
-
-        // ...and use it to compute the stresses
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            const SymmetricTensor<2,dim> strain_rate = in.strain_rate[q];
-            const SymmetricTensor<2,dim> deviatoric_strain_rate
-              = (this->get_material_model().is_compressible()
-                 ?
-                 strain_rate - 1./3 * trace(strain_rate) * unit_symmetric_tensor<dim>()
-                 :
-                 strain_rate);
-
-            const double eta = out.viscosities[q];
-
-            // Compressive stress is positive in geoscience applications
-            SymmetricTensor<2,dim> stress = -2.*eta*deviatoric_strain_rate +
-                                            in.pressure[q] * unit_symmetric_tensor<dim>();
-
-            // Add elastic stresses if existent
-            if (this->get_parameters().enable_elasticity == true)
-              {
-                stress[0][0] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xx")];
-                stress[1][1] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yy")];
-                stress[0][1] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xy")];
-
-                if (dim == 3)
-                  {
-                    stress[2][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_zz")];
-                    stress[0][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_xz")];
-                    stress[1][2] += in.composition[q][this->introspection().compositional_index_for_name("ve_stress_yz")];
-                  }
-              }
-
-            for (unsigned int d=0; d<dim; ++d)
-              for (unsigned int e=0; e<dim; ++e)
-                computed_quantities[q][Tensor<2,dim>::component_to_unrolled_index(TableIndices<2>(d,e))]
-                  = stress[d][e];
-          }
-
-        // average the values if requested
-        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
-        if (!viz.output_pointwise_stress_and_strain())
-          average_quantities(computed_quantities);
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(SurfaceStress,
-                                                  "surface stress",
-                                                  "A visualization output object that generates output "
-                                                  "on the surface of the domain "
-                                                  "for the 3 (in 2d) or 6 (in 3d) components of the stress "
-                                                  "tensor, i.e., for the components of the tensor "
-                                                  "$-2\\eta\\varepsilon(\\mathbf u)+pI$ "
-                                                  "in the incompressible case and "
-                                                  "$-2\\eta\\left[\\varepsilon(\\mathbf u)-"
-                                                  "\\tfrac 13(\\textrm{tr}\\;\\varepsilon(\\mathbf u))\\mathbf I\\right]+pI$ "
-                                                  "in the compressible case. If elasticity is included, "
-                                                  "its contribution is accounted for. Note that the convention of positive "
-                                                  "compressive stress is followed."
-                                                  "The stress outputted on the surface of the domain will equal "
-                                                  "the stress on the surface of the volume output if the parameter "
-                                                  "'Point-wise stress and strain' in the Visualization subsection "
-                                                  "is set to true. "
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\pascal}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/temperature_anomaly.cc.bak b/source/postprocess/visualization/temperature_anomaly.cc.bak
deleted file mode 100644
index 61ea2516197..00000000000
--- a/source/postprocess/visualization/temperature_anomaly.cc.bak
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/temperature_anomaly.h>
-#include <aspect/boundary_temperature/constant.h>
-#include <aspect/lateral_averaging.h>
-#include <aspect/geometry_model/interface.h>
-
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      TemperatureAnomaly<dim>::
-      TemperatureAnomaly ()
-        :
-        DataPostprocessorScalar<dim> ("temperature_anomaly",
-                                      update_values | update_quadrature_points ),
-        Interface<dim>("K")
-      {}
-
-
-
-      template <int dim>
-      void
-      TemperatureAnomaly<dim>::
-      update ()
-      {
-        std::vector<double> temperature_depth_average(n_slices);
-        this->get_lateral_averaging().get_temperature_averages(temperature_depth_average);
-
-        // Estimates of the lateral temperature average at each depth are required
-        // for all cell depths, including those
-        // shallower than the midpoint of the first slice or
-        // deeper than the midpoint of the last slice.
-
-        padded_temperature_depth_average.resize(n_slices+2);
-
-        if ( extrapolate_surface )
-          {
-            padded_temperature_depth_average[0] = 2.*temperature_depth_average[0] - temperature_depth_average[1];
-          }
-        else
-          {
-            Assert( this->has_boundary_temperature(),ExcInternalError());
-            // retrieve the minimum temperature from the fixed temperature boundary indicators
-            const double surface_temperature = this->get_boundary_temperature_manager().minimal_temperature(this->get_fixed_temperature_boundary_indicators());
-            padded_temperature_depth_average[0] = 2.*surface_temperature - temperature_depth_average[0];
-          }
-        if ( extrapolate_bottom )
-          {
-            padded_temperature_depth_average[n_slices+1] = 2.*temperature_depth_average[n_slices-1] - temperature_depth_average[n_slices-2];
-          }
-        else
-          {
-            const double bottom_temperature = this->get_boundary_temperature_manager().maximal_temperature(this->get_fixed_temperature_boundary_indicators());
-            padded_temperature_depth_average[n_slices+1] = 2.*bottom_temperature - temperature_depth_average[n_slices-1];
-          }
-        std::copy ( temperature_depth_average.begin(), temperature_depth_average.end(), padded_temperature_depth_average.begin() + 1 );
-
-      }
-
-
-
-      template <int dim>
-      void
-      TemperatureAnomaly<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const double max_depth = this->get_geometry_model().maximal_depth();
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            const double temperature = input_data.solution_values[q][this->introspection().component_indices.temperature];
-            const double depth = this->get_geometry_model().depth (input_data.evaluation_points[q]);
-            // calculate the depth-average cell containing this point. Note that cell centers are offset +0.5 cells in depth.
-            const double slice_depth = (depth*n_slices)/max_depth + 0.5;
-            const unsigned int idx = static_cast<unsigned int>(slice_depth);
-            const double fractional_slice = slice_depth - static_cast<double>(idx);
-            Assert(idx<n_slices+1, ExcInternalError());
-            const double depth_average_temperature= (1. - fractional_slice)*padded_temperature_depth_average[idx] + fractional_slice*padded_temperature_depth_average[idx+1];
-            computed_quantities[q](0) = temperature - depth_average_temperature;
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      TemperatureAnomaly<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Temperature anomaly");
-            {
-              prm.declare_entry ("Number of depth slices","20",
-                                 Patterns::Integer (1),
-                                 "Number of depth slices used to define "
-                                 "average temperature.");
-              prm.declare_entry ("Use maximal temperature for bottom","true",
-                                 Patterns::Bool(),
-                                 "If true, use the specified boundary temperatures as average temperatures at the surface. "
-                                 "If false, extrapolate the temperature gradient between the first and second cells to the surface. "
-                                 "This option will only work for models with a fixed surface temperature. ");
-              prm.declare_entry ("Use minimal temperature for surface","true",
-                                 Patterns::Bool(),
-                                 "Whether to use the minimal specified boundary temperature as the bottom boundary temperature. "
-                                 "This option will only work for models with a fixed bottom boundary temperature. ");
-
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      TemperatureAnomaly<dim>::parse_parameters(ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Temperature anomaly");
-            {
-              n_slices = prm.get_integer("Number of depth slices");
-              extrapolate_surface = !prm.get_bool("Use minimal temperature for surface");
-              extrapolate_bottom = !prm.get_bool("Use maximal temperature for bottom");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(TemperatureAnomaly,
-                                                  "temperature anomaly",
-                                                  "A visualization output postprocessor that outputs the temperature minus the depth-average of the temperature."
-                                                  "The average temperature is calculated using the lateral averaging function from the ``depth average'' "
-                                                  "postprocessor and interpolated linearly between the layers specified through ``Number of depth slices''."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\kelvin}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/vertical_heat_flux.cc.bak b/source/postprocess/visualization/vertical_heat_flux.cc.bak
deleted file mode 100644
index 78a49f73c5b..00000000000
--- a/source/postprocess/visualization/vertical_heat_flux.cc.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/vertical_heat_flux.h>
-#include <aspect/gravity_model/interface.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      VerticalHeatFlux<dim>::
-      VerticalHeatFlux ()
-        :
-        DataPostprocessorScalar<dim> ("vertical_heat_flux",
-                                      update_values | update_quadrature_points | update_gradients),
-        Interface<dim>("W/m/m")
-      {}
-
-
-
-      template <int dim>
-      void
-      VerticalHeatFlux<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
-
-        //Create vector for the temperature gradients.  All the other things
-        //we need are in MaterialModelInputs/Outputs
-        std::vector<Tensor<1,dim>> temperature_gradient(n_quadrature_points);
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          for (unsigned int d = 0; d < dim; ++d)
-            temperature_gradient[q][d] = input_data.solution_gradients[q][this->introspection().component_indices.temperature][d];
-
-
-        MaterialModel::MaterialModelInputs<dim> in(input_data,
-                                                   this->introspection());
-        MaterialModel::MaterialModelOutputs<dim> out(n_quadrature_points,
-                                                     this->n_compositional_fields());
-        in.requested_properties = MaterialModel::MaterialProperties::density |
-                                  MaterialModel::MaterialProperties::specific_heat |
-                                  MaterialModel::MaterialProperties::thermal_conductivity;
-
-        this->get_material_model().evaluate(in, out);
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(in.position[q]);
-            const Tensor<1,dim> vertical = -gravity/( gravity.norm() != 0.0 ?
-                                                      gravity.norm() : 1.0 );
-            const double advective_flux = (in.velocity[q] * vertical) * in.temperature[q] *
-                                          out.densities[q]*out.specific_heat[q];
-            const double conductive_flux = -(temperature_gradient[q]*vertical) *
-                                           out.thermal_conductivities[q];
-            computed_quantities[q](0) = advective_flux + conductive_flux;
-          }
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(VerticalHeatFlux,
-                                                  "vertical heat flux",
-                                                  "A visualization output object that generates output "
-                                                  "for the heat flux in the vertical direction, which is "
-                                                  "the sum of the advective and the conductive heat flux, "
-                                                  "with the sign convention of positive flux upwards."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\watt\\per\\square\\meter}.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/volume_of_fluid_values.cc.bak b/source/postprocess/visualization/volume_of_fluid_values.cc.bak
deleted file mode 100644
index 5dc24913cbc..00000000000
--- a/source/postprocess/visualization/volume_of_fluid_values.cc.bak
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/postprocess/visualization/volume_of_fluid_values.h>
-#include <aspect/volume_of_fluid/handler.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      VolumeOfFluidValues<dim>::
-      VolumeOfFluidValues ()
-        :
-        DataPostprocessor<dim> (),
-        Interface<dim>("")  // physical units of a fractional volume, so units of "1"
-      {}
-
-
-      template <int dim>
-      std::vector<std::string>
-      VolumeOfFluidValues<dim>::
-      get_names () const
-      {
-        return volume_of_fluid_names;
-      }
-
-
-      template <int dim>
-      std::vector<DataComponentInterpretation::DataComponentInterpretation>
-      VolumeOfFluidValues<dim>::
-      get_data_component_interpretation () const
-      {
-        return interpretations;
-      }
-
-
-      template <int dim>
-      UpdateFlags
-      VolumeOfFluidValues<dim>::
-      get_needed_update_flags () const
-      {
-        return update_values;
-      }
-
-
-      template <int dim>
-      void
-      VolumeOfFluidValues<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points, ExcInternalError ());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components, ExcInternalError ());
-
-        unsigned int out_per_field=1;
-        if (include_contour)
-          out_per_field += 1;
-        if (include_normal)
-          out_per_field += dim;
-
-        for (unsigned int f=0; f<this->get_volume_of_fluid_handler().get_n_fields(); ++f)
-          {
-            const VolumeOfFluidField<dim> &field = this->get_volume_of_fluid_handler().field_struct_for_field_index(f);
-
-            const FEVariable<dim> &volume_of_fluid_var = field.volume_fraction;
-            const unsigned int volume_of_fluid_ind = volume_of_fluid_var.first_component_index;
-            const FEVariable<dim> &volume_of_fluidLS_var = field.level_set;
-            const unsigned int volume_of_fluidLS_ind = volume_of_fluidLS_var.first_component_index;
-
-            for (unsigned int q=0; q<n_quadrature_points; ++q)
-              {
-                unsigned int out_ind = f*out_per_field;
-                computed_quantities[q][out_ind] = input_data.solution_values[q][volume_of_fluid_ind];
-                ++out_ind;
-                if (include_contour)
-                  {
-                    computed_quantities[q][out_ind] = input_data.solution_values[q][volume_of_fluidLS_ind];
-                    ++out_ind;
-                  }
-
-                // TODO: Adjust this so the output will match the "physical" space rather than unit cell space.
-                // Some rescaling may be desirable to keep $\|n\|_2=1$ in cases with an interface
-                if (include_normal)
-                  {
-                    Tensor<1, dim, double> normal = -input_data.solution_gradients[q][volume_of_fluidLS_ind];
-                    for (unsigned int i = 0; i<dim; ++i)
-                      {
-                        computed_quantities[q][out_ind] = normal[i];
-                        ++out_ind;
-                      }
-                  }
-              }
-          }
-      }
-
-
-
-      template <int dim>
-      void
-      VolumeOfFluidValues<dim>::declare_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Volume of Fluid");
-            {
-              prm.declare_entry("Output interface reconstruction contour", "false",
-                                Patterns::Bool (),
-                                "Include fields defined such that the 0 contour is the fluid interface.");
-
-              // TODO: Fix this for curved geometries
-              prm.declare_entry("Output interface normals", "false",
-                                Patterns::Bool (),
-                                "Include the internal data for the interface normal on the unit cells.");
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-
-
-
-      template <int dim>
-      void
-      VolumeOfFluidValues<dim>::parse_parameters (ParameterHandler &prm)
-      {
-        prm.enter_subsection("Postprocess");
-        {
-          prm.enter_subsection("Visualization");
-          {
-            prm.enter_subsection("Volume of Fluid");
-            {
-              include_contour = prm.get_bool("Output interface reconstruction contour");
-              include_normal = prm.get_bool("Output interface normals");
-
-              for (unsigned int f=0; f<this->get_volume_of_fluid_handler().get_n_fields(); ++f)
-                {
-                  std::string field_name = this->get_volume_of_fluid_handler().name_for_field_index(f);
-                  volume_of_fluid_names.push_back("volume_fraction_"+field_name);
-                  interpretations.push_back(DataComponentInterpretation::component_is_scalar);
-
-                  if (include_contour)
-                    {
-                      volume_of_fluid_names.push_back("volume_of_fluid_contour_"+field_name);
-                      interpretations.push_back(DataComponentInterpretation::component_is_scalar);
-                    }
-
-                  if (include_normal)
-                    {
-                      for (unsigned int i=0; i<dim; ++i)
-                        {
-                          volume_of_fluid_names.push_back("volume_of_fluid_interface_normal_"+field_name);
-                          interpretations.push_back(DataComponentInterpretation::component_is_part_of_vector);
-                        }
-                    }
-                }
-            }
-            prm.leave_subsection();
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(VolumeOfFluidValues,
-                                                  "volume of fluid values",
-                                                  "A visualization output object that outputs the volume fraction "
-                                                  "and optionally a level set field and the interface normal "
-                                                  "vectors of volume of fluid fields."
-                                                  "\n\n"
-                                                  "Physical units: None.")
-    }
-  }
-}
diff --git a/source/postprocess/visualization/volumetric_strain_rate.cc.bak b/source/postprocess/visualization/volumetric_strain_rate.cc.bak
deleted file mode 100644
index 3c5c6273238..00000000000
--- a/source/postprocess/visualization/volumetric_strain_rate.cc.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/visualization/volumetric_strain_rate.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      VolumetricStrainRate<dim>::
-      VolumetricStrainRate ()
-        :
-        DataPostprocessorScalar<dim> ("volumetric_strain_rate",
-                                      update_gradients | update_quadrature_points),
-        Interface<dim>("1/s")
-      {}
-
-
-
-      template <int dim>
-      void
-      VolumetricStrainRate<dim>::
-      evaluate_vector_field(const DataPostprocessorInputs::Vector<dim> &input_data,
-                            std::vector<Vector<double>> &computed_quantities) const
-      {
-        const unsigned int n_quadrature_points = input_data.solution_values.size();
-        Assert (computed_quantities.size() == n_quadrature_points,    ExcInternalError());
-        Assert (computed_quantities[0].size() == 1,                   ExcInternalError());
-        Assert (input_data.solution_values[0].size() == this->introspection().n_components,           ExcInternalError());
-        Assert (input_data.solution_gradients[0].size() == this->introspection().n_components,          ExcInternalError());
-
-        for (unsigned int q=0; q<n_quadrature_points; ++q)
-          {
-            // extract the velocity gradients
-            Tensor<2,dim> grad_u;
-            for (unsigned int d=0; d<dim; ++d)
-              grad_u[d] = input_data.solution_gradients[q][d];
-
-            const double div_u = trace(grad_u);
-            computed_quantities[q](0) = div_u;
-          }
-
-        // average the values if requested
-        const auto &viz = this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::Visualization<dim>>();
-        if (!viz.output_pointwise_stress_and_strain())
-          average_quantities(computed_quantities);
-      }
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(VolumetricStrainRate,
-                                                  "volumetric strain rate",
-                                                  "A visualization output object that generates output "
-                                                  "for the volumetric strain rate, i.e., for the quantity "
-                                                  "$\\nabla\\cdot\\mathbf u = \\textrm{div}\\; \\mathbf u = "
-                                                  "\\textrm{trace}\\; \\varepsilon(\\mathbf u)$. "
-                                                  "This should be zero (in some average sense) in incompressible "
-                                                  "convection models, but can be non-zero in compressible models and "
-                                                  "models with melt transport."
-                                                  "\n\n"
-                                                  "Physical units: \\si{\\per\\second}.")
-    }
-  }
-}
diff --git a/source/postprocess/volume_of_fluid_statistics.cc.bak b/source/postprocess/volume_of_fluid_statistics.cc.bak
deleted file mode 100644
index e6d6cbef61b..00000000000
--- a/source/postprocess/volume_of_fluid_statistics.cc.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/postprocess/volume_of_fluid_statistics.h>
-#include <aspect/volume_of_fluid/handler.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    VolumeOfFluidStatistics<dim>::execute (TableHandler &statistics)
-    {
-      AssertThrow(this->get_volume_of_fluid_handler().get_n_fields()!=numbers::invalid_unsigned_int,
-                  ExcMessage("This postprocessor cannot be used without VolumeOfFluid fields"));
-      const QGauss<dim> quadrature_formula (1);
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      const unsigned int n_volume_of_fluid_fields
-        = this->get_volume_of_fluid_handler().get_n_fields();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-      std::vector<double> volume_of_fluid_values(n_q_points);
-
-      std::vector<double> local_volume_of_fluid_vol_sums(n_volume_of_fluid_fields);
-
-      for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
-        {
-          const FEValuesExtractors::Scalar
-          volume_of_fluid (this->get_volume_of_fluid_handler().field_struct_for_field_index(f)
-                           .volume_fraction.extractor_scalar());
-          double volume_of_fluid_vol_sum=0.0;
-
-          for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-            if (cell->is_locally_owned())
-              {
-                fe_values.reinit (cell);
-                fe_values[volume_of_fluid].get_function_values (this->get_solution(),
-                                                                volume_of_fluid_values);
-                for (unsigned int q = 0; q < n_q_points; ++q)
-                  {
-                    volume_of_fluid_vol_sum += volume_of_fluid_values[q] * fe_values.JxW(q);
-                  }
-              }
-          local_volume_of_fluid_vol_sums[f] = volume_of_fluid_vol_sum;
-        }
-
-      std::vector<double> global_volume_of_fluid_vol_sums(n_volume_of_fluid_fields);
-
-      Utilities::MPI::sum (local_volume_of_fluid_vol_sums, this->get_mpi_communicator(),
-                           global_volume_of_fluid_vol_sums);
-
-      std::ostringstream output;
-      output.precision(3);
-
-      for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
-        {
-          const std::string col_name = "Global volume of fluid volumes for " +
-                                       this->get_volume_of_fluid_handler().name_for_field_index(f);
-          statistics.add_value (col_name, global_volume_of_fluid_vol_sums[f]);
-
-          output << global_volume_of_fluid_vol_sums[f];
-
-          if (f+1 < n_volume_of_fluid_fields)
-            output << '/';
-
-          // also make sure that the columns filled by this object
-          // show up with sufficient accuracy and in scientific notation
-          statistics.set_precision (col_name, 8);
-          statistics.set_scientific (col_name, true);
-        }
-
-      return {"Global volume of fluid volumes (m^3):", output.str()};
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(VolumeOfFluidStatistics,
-                                  "volume of fluid statistics",
-                                  "A postprocessor that computes some statistics about the "
-                                  "volume-of-fluid fields.")
-  }
-}
diff --git a/source/prescribed_stokes_solution/ascii_data.cc.bak b/source/prescribed_stokes_solution/ascii_data.cc.bak
deleted file mode 100644
index 7e7aa4af79b..00000000000
--- a/source/prescribed_stokes_solution/ascii_data.cc.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/global.h>
-#include <aspect/prescribed_stokes_solution/ascii_data.h>
-
-
-
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    template <int dim>
-    AsciiData<dim>::AsciiData ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::initialize ()
-    {
-      Utilities::AsciiDataInitial<dim>::initialize(dim);
-
-      AssertThrow(!this->get_parameters().include_melt_transport,
-                  ExcMessage("Using the ascii data plugin for the prescribed Stokes solution "
-                             "is not supported in models with melt transport."));
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::
-    stokes_solution (const Point<dim> &position, Vector<double> &value) const
-    {
-      value(0) = Utilities::AsciiDataInitial<dim>::get_data_component(position,0);
-      value(1) = Utilities::AsciiDataInitial<dim>::get_data_component(position,1);
-      if (dim == 3)
-        value(2) = Utilities::AsciiDataInitial<dim>::get_data_component(position,2);
-      value(dim) = 0;  // makes pressure 0, must set pressure
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Prescribed Stokes solution");
-      {
-        Utilities::AsciiDataInitial<dim>::declare_parameters(prm,
-                                                             "$ASPECT_SOURCE_DIR/data/prescribed-stokes-solution/",
-                                                             "box_2d.txt");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiData<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Prescribed Stokes solution");
-      {
-        Utilities::AsciiDataInitial<dim>::parse_parameters(prm);
-      }
-      prm.leave_subsection();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(AsciiData,
-                                               "ascii data",
-                                               "Implementation of a model in which the velocity "
-                                               "is derived from files containing data "
-                                               "in ascii format. Note the required format of the "
-                                               "input data: The first lines may contain any number of comments "
-                                               "if they begin with `#', but one of these lines needs to "
-                                               "contain the number of grid points in each dimension as "
-                                               "for example `# POINTS: 3 3'. "
-                                               "The order of the data columns "
-                                               "has to be `x', `y', `v${}_x$' , `v${}_y$' in a 2d model and "
-                                               " `x', `y', `z', `v${}_x$' , `v${}_y$' , `v${}_z$' in a 3d model. "
-                                               "Note that the data in the input "
-                                               "files need to be sorted in a specific order: "
-                                               "the first coordinate needs to ascend first, "
-                                               "followed by the second and the third at last in order to "
-                                               "assign the correct data to the prescribed coordinates. "
-                                               "If you use a spherical model, "
-                                               "then the data will still be handled as Cartesian, "
-                                               "however the assumed grid changes. `x' will be replaced by "
-                                               "the radial distance of the point to the bottom of the model, "
-                                               "`y' by the azimuth angle and `z' by the polar angle measured "
-                                               "positive from the north pole. The grid will be assumed to be "
-                                               "a latitude-longitude grid. Note that the order "
-                                               "of spherical coordinates is `r', `phi', `theta' "
-                                               "and not `r', `theta', `phi', since this allows "
-                                               "for dimension independent expressions.")
-  }
-}
diff --git a/source/prescribed_stokes_solution/circle.cc.bak b/source/prescribed_stokes_solution/circle.cc.bak
deleted file mode 100644
index dfa6a8a589b..00000000000
--- a/source/prescribed_stokes_solution/circle.cc.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/prescribed_stokes_solution/circle.h>
-
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    template <int dim>
-    void Circle<dim>::stokes_solution (const Point<dim> &p, Vector<double> &value) const
-    {
-      value(0) = -p(1);
-      value(1) = p(0);
-      if (dim == 3)
-        value(2) = 0;
-
-      if (this->get_parameters().include_melt_transport)
-        {
-          value(dim) = 0;       // fluid pressure
-          value(dim+1) = 0;     // compaction pressure
-
-          value(dim+2) = -p(1); // fluid velocity x
-          value(dim+3) = p(0);  // fluid velocity y
-          if (dim == 3)
-            value(dim+4) = 0;
-
-          value(2*dim+2) = 0;   // pressure
-        }
-      else
-        {
-          value(dim) = 0;       // pressure
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(Circle,
-                                               "circle",
-                                               "This value describes a vector field that rotates "
-                                               "around the z-axis with constant angular velocity "
-                                               "(i.e., with a velocity that increases with "
-                                               "distance from the axis). The pressure is set "
-                                               "to zero.")
-  }
-}
diff --git a/source/prescribed_stokes_solution/function.cc.bak b/source/prescribed_stokes_solution/function.cc.bak
deleted file mode 100644
index 6ea86197904..00000000000
--- a/source/prescribed_stokes_solution/function.cc.bak
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/prescribed_stokes_solution/function.h>
-
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    template <int dim>
-    Function<dim>::Function ()
-      :
-      prescribed_velocity_function (dim),
-      prescribed_pressure_function (1),
-      prescribed_fluid_pressure_function (1),
-      prescribed_compaction_pressure_function (1),
-      prescribed_fluid_velocity_function (dim)
-    {}
-
-    template <int dim>
-    void
-    Function<dim>::stokes_solution (const Point<dim> &position, Vector<double> &value) const
-    {
-      // velocity
-      for (unsigned int d=0; d<dim; ++d)
-        {
-          value[d] = prescribed_velocity_function.value(position,d);
-
-          if (this->convert_output_to_years())
-            value[d] /= year_in_seconds;
-        }
-
-      if (this->get_parameters().include_melt_transport)
-        {
-          // fluid pressure
-          value(dim) = prescribed_fluid_pressure_function.value(position);
-
-          // compaction pressure
-          value(dim+1) = prescribed_compaction_pressure_function.value(position);
-
-          // fluid velocity
-          for (unsigned int d=0; d<dim; ++d)
-            {
-              value[dim+2+d] = prescribed_fluid_velocity_function.value(position,d);
-
-              if (this->convert_output_to_years())
-                value[dim+2+d] /= year_in_seconds;
-            }
-
-          // pressure
-          value(2*dim+2) = prescribed_pressure_function.value(position);
-        }
-      else
-        {
-          // pressure
-          value(dim) = prescribed_pressure_function.value(position);
-        }
-    }
-
-    template <int dim>
-    void
-    Function<dim>::update()
-    {
-      // we get time passed as seconds (always) but may want
-      // to reinterpret it in years
-      if (this->convert_output_to_years())
-        {
-          prescribed_velocity_function.set_time (this->get_time() / year_in_seconds);
-          prescribed_pressure_function.set_time (this->get_time() / year_in_seconds);
-          prescribed_fluid_pressure_function.set_time (this->get_time() / year_in_seconds);
-          prescribed_compaction_pressure_function.set_time (this->get_time() / year_in_seconds);
-          prescribed_fluid_velocity_function.set_time (this->get_time() / year_in_seconds);
-        }
-      else
-        {
-          prescribed_velocity_function.set_time (this->get_time());
-          prescribed_pressure_function.set_time (this->get_time());
-          prescribed_fluid_pressure_function.set_time (this->get_time());
-          prescribed_compaction_pressure_function.set_time (this->get_time());
-          prescribed_fluid_velocity_function.set_time (this->get_time());
-        }
-    }
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Prescribed Stokes solution");
-      {
-        prm.enter_subsection("Velocity function");
-        {
-          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
-        }
-        prm.leave_subsection();
-        prm.enter_subsection("Pressure function");
-        {
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-        prm.enter_subsection("Fluid pressure function");
-        {
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-        prm.enter_subsection("Compaction pressure function");
-        {
-          Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-        }
-        prm.leave_subsection();
-        prm.enter_subsection("Fluid velocity function");
-        {
-          Functions::ParsedFunction<dim>::declare_parameters (prm, dim);
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Prescribed Stokes solution");
-      {
-        prm.enter_subsection("Velocity function");
-        try
-          {
-            prescribed_velocity_function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Prescribed Stokes solution.Function.Velocity function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-        prm.enter_subsection("Pressure function");
-        try
-          {
-            prescribed_pressure_function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Prescribed Stokes solution.Function.Pressure function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-        prm.enter_subsection("Fluid pressure function");
-        try
-          {
-            prescribed_fluid_pressure_function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Initial conditions.Function.Fluid pressure function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-        prm.enter_subsection("Compaction pressure function");
-        try
-          {
-            prescribed_compaction_pressure_function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Initial conditions.Function.Compaction pressure function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-        prm.enter_subsection("Fluid velocity function");
-        try
-          {
-            prescribed_fluid_velocity_function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Initial conditions.Function.Fluid velocity function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-    ASPECT_REGISTER_PRESCRIBED_STOKES_SOLUTION(Function,
-                                               "function",
-                                               "This plugin allows to prescribe the Stokes solution "
-                                               "for the velocity and pressure field in terms of an "
-                                               "explicit formula. The format of these "
-                                               "functions follows the syntax understood by the "
-                                               "muparser library, see "
-                                               "{ref}\\`sec:run-aspect:parameters-overview:muparser-format\\`.")
-  }
-}
diff --git a/source/prescribed_stokes_solution/interface.cc.bak b/source/prescribed_stokes_solution/interface.cc.bak
deleted file mode 100644
index 244e91a4fab..00000000000
--- a/source/prescribed_stokes_solution/interface.cc.bak
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/prescribed_stokes_solution/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace PrescribedStokesSolution
-  {
-// -------------------------------- Deal with registering prescribed_stokes_solution models and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    register_prescribed_stokes_solution_model (const std::string &name,
-                                               const std::string &description,
-                                               void (*declare_parameters_function) (ParameterHandler &),
-                                               std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-    template <int dim>
-    std::unique_ptr<Interface<dim>>
-    create_prescribed_stokes_solution (ParameterHandler &prm)
-    {
-      std::string model_name;
-      prm.enter_subsection ("Prescribed Stokes solution");
-      {
-        model_name = prm.get ("Model name");
-      }
-      prm.leave_subsection ();
-
-      if (model_name == "unspecified")
-        return nullptr;
-
-      std::unique_ptr<Interface<dim>>plugin = std::get<dim>(registered_plugins).create_plugin (model_name,
-                                               "Prescribed Stokes solution::Model name");
-      return plugin;
-    }
-
-
-
-    template <int dim>
-    void
-    declare_parameters (ParameterHandler &prm)
-    {
-      // declare the entry in the parameter file
-      prm.enter_subsection ("Prescribed Stokes solution");
-      {
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-        prm.declare_entry ("Model name", "unspecified",
-                           Patterns::Selection (pattern_of_names+"|unspecified"),
-                           "Select one of the following models:\n\n"
-                           +
-                           std::get<dim>(registered_plugins).get_description_string());
-      }
-      prm.leave_subsection ();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Prescribed Stokes solution interface",
-                                                            out);
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<PrescribedStokesSolution::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<PrescribedStokesSolution::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<PrescribedStokesSolution::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<PrescribedStokesSolution::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace PrescribedStokesSolution
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  \
-  template \
-  void \
-  register_prescribed_stokes_solution_model<dim> (const std::string &, \
-                                                  const std::string &, \
-                                                  void ( *) (ParameterHandler &), \
-                                                  std::unique_ptr<Interface<dim>>( *) ()); \
-  \
-  template  \
-  void \
-  declare_parameters<dim> (ParameterHandler &); \
-  \
-  template \
-  void \
-  write_plugin_graph<dim> (std::ostream &); \
-  \
-  template \
-  std::unique_ptr<Interface<dim>> \
-  create_prescribed_stokes_solution<dim> (ParameterHandler &prm);
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/simulator/assemblers/advection.cc.bak b/source/simulator/assemblers/advection.cc.bak
deleted file mode 100644
index 4143e08e62e..00000000000
--- a/source/simulator/assemblers/advection.cc.bak
+++ /dev/null
@@ -1,1634 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator/assemblers/advection.h>
-
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    namespace
-    {
-      /* These functions implement a reduced form of the code from deal.II's TriaAccessor::measure().
-       * In the 3d dG case, a call to face->measure() is not implemented for non-planar faces.
-       * Since we only care about the scaling here, it is enough to have an approximation instead.
-       * The 2d case remains unchanged.
-       */
-      double
-      approximate_face_measure(const DoFHandler<2>::face_iterator &face)
-      {
-        return (face->vertex(0)-face->vertex(1)).norm();
-      }
-
-      double
-      approximate_face_measure(const DoFHandler<3>::face_iterator &face)
-      {
-        const Tensor<1,3> v03 = face->vertex(3) - face->vertex(0);
-        const Tensor<1,3> v12 = face->vertex(2) - face->vertex(1);
-        const Tensor<1,3> twice_area = cross_product_3d(v03, v12);
-        return 0.5 * twice_area.norm();
-      }
-    }
-
-    template <int dim>
-    void
-    AdvectionSystem<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                                   internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
-
-      const bool use_supg = (this->get_parameters().advection_stabilization_method
-                             == Parameters<dim>::AdvectionStabilizationMethod::supg);
-      const bool   use_bdf2_scheme = (this->get_timestep_number() > 1);
-      const double time_step = this->get_timestep();
-      const double old_time_step = this->get_old_timestep();
-      const double bdf2_factor = (use_bdf2_scheme)? ((2*time_step + old_time_step) /
-                                                     (time_step + old_time_step)) : 1.0;
-
-      const bool advection_field_is_temperature = advection_field.is_temperature();
-      const unsigned int solution_component = advection_field.component_index(introspection);
-
-      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
-
-      Assert(advection_field.advection_method(introspection)
-             == Parameters<dim>::AdvectionFieldMethod::fem_field,
-             ExcMessage("The 'AdvectionSystem' assembler can only be executed for fields "
-                        "that use the advection method 'field'."));
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          // precompute the values of shape functions and their gradients.
-          // We only need to look up values of shape functions if they
-          // belong to 'our' component. They are zero otherwise anyway.
-          // Note that we later only look at the values that we do set here.
-          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
-            {
-              if (fe.system_to_component_index(i).first == solution_component)
-                {
-                  if (use_supg)
-                    scratch.laplacian_phi_field[i_advection] = trace(scratch.finite_element_values[solution_field].hessian (i,q));
-
-                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
-                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
-                  ++i_advection;
-                }
-              ++i;
-            }
-
-          const double density_c_P              =
-            ((advection_field_is_temperature)
-             ?
-             scratch.material_model_outputs.densities[q] *
-             scratch.material_model_outputs.specific_heat[q]
-             :
-             1.0);
-
-          AssertThrow (density_c_P >= 0,
-                       ExcMessage ("The product of density and c_P needs to be a "
-                                   "non-negative quantity."));
-
-          const double latent_heat_LHS =
-            ((advection_field_is_temperature)
-             ?
-             scratch.heating_model_outputs.lhs_latent_heat_terms[q]
-             :
-             0.0);
-          AssertThrow (density_c_P + latent_heat_LHS >= 0,
-                       ExcMessage ("The sum of density times c_P and the latent heat contribution "
-                                   "to the left hand side needs to be a non-negative quantity."));
-
-          const double gamma =
-            ((advection_field_is_temperature)
-             ?
-             scratch.heating_model_outputs.heating_source_terms[q]
-             :
-             0.0);
-
-          const double reaction_term =
-            ((advection_field_is_temperature)
-             ?
-             0.0
-             :
-             scratch.material_model_outputs.reaction_terms[q][advection_field.compositional_variable]);
-
-          const double field_term_for_rhs
-            = (use_bdf2_scheme ?
-               (scratch.old_field_values[q] *
-                (1 + time_step/old_time_step)
-                -
-                scratch.old_old_field_values[q] *
-                (time_step * time_step) /
-                (old_time_step * (time_step + old_time_step)))
-               :
-               scratch.old_field_values[q])
-              *
-              (density_c_P + latent_heat_LHS);
-
-          Tensor<1,dim> current_u = scratch.current_velocity_values[q];
-          // Subtract off the mesh velocity for ALE corrections if necessary
-          if (this->get_parameters().mesh_deformation_enabled)
-            current_u -= scratch.mesh_velocity_values[q];
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          // For the diffusion constant, use the larger of the physical
-          // and the artificial viscosity/conductivity/diffusion constant.
-          // One could also choose the sum of the two, but if the
-          // physical diffusion is larger than the artificial one,
-          // then (because the latter is chosen sufficiently large to
-          // make the problem stable) one may as well stick with the
-          // physical one. And if the physical diffusion is too small to
-          // make the problem stable, then we ought to choose the smallest
-          // diffusivity value that makes the problem stable -- which is
-          // exactly the artificial viscosity.
-          const double conductivity = (advection_field_is_temperature
-                                       ?
-                                       scratch.material_model_outputs.thermal_conductivities[q]
-                                       :
-                                       0.0);
-
-          const double diffusion_constant = (use_supg)
-                                            ?
-                                            conductivity
-                                            :
-                                            std::max (conductivity, scratch.artificial_viscosity);
-
-          const double tau = (use_supg) ? scratch.artificial_viscosity : 0.0;
-
-          // do the actual assembly. note that we only need to loop over the advection
-          // shape functions because these are the only contributions we compute here
-          for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i)
-              += (field_term_for_rhs * scratch.phi_field[i]
-                  + time_step *
-                  scratch.phi_field[i]
-                  * gamma
-                  + scratch.phi_field[i]
-                  * reaction_term)
-                 *
-                 JxW;
-
-              if (use_supg)
-                data.local_rhs(i)
-                += tau *
-                   (
-                     (current_u * (density_c_P + latent_heat_LHS)) *
-                     scratch.grad_phi_field[i] *
-                     (
-                       field_term_for_rhs
-                       +
-                       time_step * gamma
-                       +
-                       reaction_term
-                     )
-                   ) * JxW;
-
-
-              for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                {
-                  data.local_matrix(i,j)
-                  += (
-                       (time_step * diffusion_constant
-                        * (scratch.grad_phi_field[i] * scratch.grad_phi_field[j]))
-                       + ((time_step * (scratch.phi_field[i] * (current_u * scratch.grad_phi_field[j])))
-                          + (bdf2_factor * scratch.phi_field[i] * scratch.phi_field[j])) *
-                       (density_c_P + latent_heat_LHS)
-                     )
-                     * JxW;
-                }
-
-              if (use_supg)
-                {
-                  for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                    {
-                      // Note that we assume that the conductivity is constant, otherwise we would need to
-                      // compute div (kappa grad T), which we don't have access to.
-                      data.local_matrix(i,j)
-                      += tau *
-                         (
-                           (current_u * (density_c_P + latent_heat_LHS)) *
-                           scratch.grad_phi_field[i] *
-                           (
-                             -time_step * conductivity * scratch.laplacian_phi_field[j]
-                             +
-                             (
-                               (time_step * current_u * scratch.grad_phi_field[j])
-                               +
-                               (bdf2_factor * scratch.phi_field[j])
-                             ) *
-                             (density_c_P + latent_heat_LHS)
-                           )
-                         ) * JxW;
-                    }
-                }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    AdvectionSystem<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      std::vector<double> residuals(n_q_points);
-
-      if (advection_field.is_temperature())
-        this->get_heating_model_manager().evaluate(scratch.material_model_inputs,
-                                                   scratch.material_model_outputs,
-                                                   scratch.heating_model_outputs);
-
-      for (unsigned int q=0; q < n_q_points; ++q)
-        {
-          const Tensor<1,dim> u = (scratch.old_velocity_values[q] +
-                                   scratch.old_old_velocity_values[q]) / 2;
-
-          const double dField_dt = (this->get_old_timestep() == 0.0) ? 0.0 :
-                                   (
-                                     ((scratch.old_field_values)[q] - (scratch.old_old_field_values)[q])
-                                     / this->get_old_timestep());
-          const double u_grad_field = u * (scratch.old_field_grads[q] +
-                                           scratch.old_old_field_grads[q]) / 2;
-
-          if (advection_field.is_temperature())
-            {
-              const double density       = scratch.material_model_outputs.densities[q];
-              const double conductivity  = scratch.material_model_outputs.thermal_conductivities[q];
-              const double c_P           = scratch.material_model_outputs.specific_heat[q];
-              // Note that we assume that the conductivity is constant, otherwise we would need to
-              // compute div (kappa grad T), which we don't have access to.
-              const double k_Delta_field = conductivity * (scratch.old_field_laplacians[q] +
-                                                           scratch.old_old_field_laplacians[q]) / 2;
-
-              const double gamma           = scratch.heating_model_outputs.heating_source_terms[q];
-              const double latent_heat_LHS = scratch.heating_model_outputs.lhs_latent_heat_terms[q];
-
-              residuals[q]
-                = std::abs((density * c_P + latent_heat_LHS) * (dField_dt + u_grad_field) - k_Delta_field - gamma);
-            }
-          else
-            {
-              const double dreaction_term_dt = (this->get_old_timestep() == 0) ? 0.0 :
-                                               scratch.material_model_outputs.reaction_terms[q][advection_field.compositional_variable]
-                                               / this->get_old_timestep();
-
-              residuals[q] = std::abs(dField_dt + u_grad_field - dreaction_term_dt);
-            }
-        }
-      return residuals;
-    }
-
-
-
-    template <int dim>
-    void
-    DiffusionSystem<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                                   internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
-
-      const Parameters<dim> &parameters = this->get_parameters();
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-
-      Assert(advection_field.advection_method(introspection)
-             == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion,
-             ExcMessage("The 'DiffusionSystem' assembler can only be executed for fields "
-                        "that use the advection method 'prescribed field with diffusion'."));
-
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
-
-      const unsigned int solution_component = advection_field.component_index(introspection);
-      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          // precompute the values of shape functions and their gradients.
-          // We only need to look up values of shape functions if they
-          // belong to 'our' component. They are zero otherwise anyway.
-          // Note that we later only look at the values that we do set here.
-          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
-            {
-              if (fe.system_to_component_index(i).first == solution_component)
-                {
-                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
-                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
-                  ++i_advection;
-                }
-              ++i;
-            }
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          // do the actual assembly. note that we only need to loop over the advection
-          // shape functions because these are the only contributions we compute here
-          for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i)
-              += scratch.old_field_values[q] * scratch.phi_field[i]
-                 *
-                 JxW;
-
-              for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                {
-                  data.local_matrix(i,j)
-                  += (parameters.diffusion_length_scale * parameters.diffusion_length_scale *
-                      (scratch.grad_phi_field[i] * scratch.grad_phi_field[j])
-                      + (scratch.phi_field[i] * scratch.phi_field[j])
-                     )
-                     * JxW;
-                }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    DiffusionSystem<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-      std::vector<double> residuals(scratch.finite_element_values.n_quadrature_points, 0.0);
-
-      return residuals;
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    DiffusionSystem<dim>::advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-      return std::vector<double> (scratch.material_model_inputs.n_evaluation_points(), 0.0);
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    DiffusionSystem<dim>::diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-
-      const double prefactor = this->get_timestep() > 0
-                               ?
-                               this->get_parameters().diffusion_length_scale
-                               * this->get_parameters().diffusion_length_scale
-                               / this->get_timestep()
-                               :
-                               0.0;
-
-      return std::vector<double> (scratch.material_model_inputs.n_evaluation_points(), prefactor);
-    }
-
-
-
-    template <int dim>
-    void
-    AdvectionSystemBoundaryHeatFlux<dim>::execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                                                  internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-
-      if (!advection_field.is_temperature())
-        return;
-
-      const unsigned int face_no = scratch.face_number;
-      const typename DoFHandler<dim>::face_iterator face = scratch.cell->face(face_no);
-
-      const unsigned int n_face_q_points    = scratch.face_finite_element_values->n_quadrature_points;
-      const double time_step = this->get_timestep();
-
-      // also have the number of dofs that correspond just to the element for
-      // the system we are currently trying to assemble
-      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
-
-      Assert (advection_dofs_per_cell < scratch.face_finite_element_values->get_fe().dofs_per_cell, ExcInternalError());
-      Assert (scratch.face_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
-
-      const unsigned int solution_component = advection_field.component_index(introspection);
-      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
-
-      if (this->get_fixed_heat_flux_boundary_indicators().find(face->boundary_id())
-          != this->get_fixed_heat_flux_boundary_indicators().end())
-        {
-          // We are in the case of a Neumann temperature boundary.
-          // Impose the Neumann value weakly using a RHS term.
-
-          std::vector<Tensor<1,dim>> heat_flux(n_face_q_points);
-          heat_flux = this->get_boundary_heat_flux().heat_flux(
-                        face->boundary_id(),
-                        scratch.face_material_model_inputs,
-                        scratch.face_material_model_outputs,
-                        scratch.face_finite_element_values->get_normal_vectors()
-                      );
-
-          for (unsigned int q=0; q<n_face_q_points; ++q)
-            {
-              // precompute the values of shape functions.
-              // We only need to look up values of shape functions if they
-              // belong to 'our' component. They are zero otherwise anyway.
-              // Note that we later only look at the values that we do set here.
-              for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
-                {
-                  if (fe.system_to_component_index(i).first == solution_component)
-                    {
-                      scratch.face_phi_field[i_advection]      = (*scratch.face_finite_element_values)[solution_field].value (i, q);
-                      ++i_advection;
-                    }
-                  ++i;
-                }
-
-              for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-                {
-                  data.local_rhs(i)
-                  -= time_step * scratch.face_phi_field[i] *
-                     (heat_flux[q] * scratch.face_finite_element_values->normal_vector(q))
-                     *
-                     scratch.face_finite_element_values->JxW(q);
-                }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    DarcySystem<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      MeltHandler<dim>::create_material_model_outputs(outputs);
-    }
-
-    template <int dim>
-    void
-    DarcySystem<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                               internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>& > (scratch_base);
-      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>& > (data_base);
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-
-      Assert(advection_field.advection_method(introspection)
-             == Parameters<dim>::AdvectionFieldMethod::fem_darcy_field,
-             ExcMessage("The 'DarcySystem' assembler can only be executed for fields "
-                        "that use the advection method 'darcy field'."));
-
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
-
-      const bool use_supg = (this->get_parameters().advection_stabilization_method
-                             == Parameters<dim>::AdvectionStabilizationMethod::supg);
-      AssertThrow(use_supg == false,
-                  ExcMessage("The Darcy field advection method does not support the use of SUPG"));
-
-      const bool   use_bdf2_scheme = (this->get_timestep_number() > 1);
-      const double time_step = this->get_timestep();
-      const double old_time_step = this->get_old_timestep();
-
-      const double bdf2_factor = (use_bdf2_scheme)? ((2*time_step + old_time_step) /
-                                                     (time_step + old_time_step)) : 1.0;
-      const unsigned int solution_component = advection_field.component_index(introspection);
-      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
-      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          // precompute the values of shape functions and their gradients.
-          // We only need to look up values of shape functions if they
-          // belong to 'our' component. They are zero otherwise anyway.
-          // Note that we later only look at the values that we do set here.
-          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
-            {
-              if (fe.system_to_component_index(i).first == solution_component)
-                {
-                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
-                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
-                  ++i_advection;
-                }
-              ++i;
-            }
-
-          const double reaction_term = scratch.material_model_outputs.reaction_terms[q][advection_field.compositional_variable];
-
-          const double field_term_for_rhs
-            = (use_bdf2_scheme ?
-               (scratch.old_field_values[q] *
-                (1 + time_step/old_time_step)
-                -
-                scratch.old_old_field_values[q] *
-                (time_step * time_step) /
-                (old_time_step * (time_step + old_time_step)))
-               :
-               scratch.old_field_values[q]);
-
-
-          // We calculate the fluid velocity current_u_f using an approximation of Darcy's Law:
-          // u_f = u_s - K_D / phi * (rho_s * g - rho_f * g)
-          // u_f = fluid velocity
-          // u_s = solid velocity
-          // K_D = Darcy Coefficient
-          // phi = porosity
-          // rho_f = fluid density
-          // rhos_s = solid density
-          // g = gravity
-          // The second term on the rhs of Darcy's Law only contributes to the component of the
-          // fluid velocity parallel to the gravity vector, which is proportional to the
-          // buoyancy of the fluid phase.
-          const double rho_s = scratch.material_model_outputs.densities[q];
-          const double rho_f = melt_outputs->fluid_densities[q];
-          const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-          const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
-          const double porosity         = std::max(scratch.material_model_inputs.composition[q][porosity_index],1e-10);
-          const double K_D = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q] / porosity;
-          const Tensor<1,dim> current_u = scratch.current_velocity_values[q];
-          Tensor<1,dim> current_u_f = current_u - K_D * (rho_s - rho_f) * gravity;
-
-          // Subtract off the mesh velocity for ALE corrections if necessary
-          if (this->get_parameters().mesh_deformation_enabled)
-            current_u_f -= scratch.mesh_velocity_values[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          // do the actual assembly. note that we only need to loop over the advection
-          // shape functions because these are the only contributions we compute here
-          for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i)
-              += (field_term_for_rhs * scratch.phi_field[i]
-                  + scratch.phi_field[i]
-                  * reaction_term)
-                 * JxW;
-
-              for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                {
-                  data.local_matrix(i,j)
-                  += (
-                       (time_step * scratch.artificial_viscosity
-                        * (scratch.grad_phi_field[i] * scratch.grad_phi_field[j]))
-                       + ((time_step * (scratch.phi_field[i] * (current_u_f * scratch.grad_phi_field[j])))
-                          + (bdf2_factor * scratch.phi_field[i] * scratch.phi_field[j]))
-                     )
-                     * JxW;
-                }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    DarcySystem<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>& > (scratch_base);
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      const Introspection<dim> &introspection = this->introspection();
-      std::vector<double> residuals(n_q_points);
-      if (advection_field.is_temperature())
-        {
-          return residuals;
-        }
-
-
-      const MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-      for (unsigned int q=0; q < n_q_points; ++q)
-        {
-
-          const double K_D = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q];
-          const double rho_s = scratch.material_model_outputs.densities[q];
-          const double rho_f = melt_outputs->fluid_densities[q];
-          const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
-          const double porosity         = std::max(scratch.material_model_inputs.composition[q][porosity_index], 1e-10);
-          const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-
-          const Tensor<1,dim> u = (scratch.old_velocity_values[q] +
-                                   scratch.old_old_velocity_values[q]) / 2
-                                  - K_D*(rho_s - rho_f)*gravity/porosity;
-
-          const double dField_dt = (this->get_old_timestep() == 0.0) ? 0.0 :
-                                   (
-                                     ((scratch.old_field_values)[q] - (scratch.old_old_field_values)[q])
-                                     / this->get_old_timestep());
-          const double u_grad_field = u * (scratch.old_field_grads[q] +
-                                           scratch.old_old_field_grads[q]) / 2;
-
-          const double dreaction_term_dt = (this->get_old_timestep() == 0) ? 0.0 :
-                                           scratch.material_model_outputs.reaction_terms[q][advection_field.compositional_variable]
-                                           / this->get_old_timestep();
-
-          residuals[q] = std::abs(dField_dt + u_grad_field - dreaction_term_dt);
-        }
-      return residuals;
-    }
-
-
-
-    template <int dim>
-    void
-    AdvectionSystemBoundaryFace<dim>::execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                                              internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
-
-      const Parameters<dim> &parameters = this->get_parameters();
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-
-      const unsigned int face_no = scratch.face_number;
-      const typename DoFHandler<dim>::face_iterator face = scratch.cell->face(face_no);
-
-      const unsigned int n_q_points    = scratch.face_finite_element_values->n_quadrature_points;
-
-      const double time_step = this->get_timestep();
-
-      Assert(advection_field.is_discontinuous(introspection)
-             && advection_field.advection_method(introspection)
-             == Parameters<dim>::AdvectionFieldMethod::fem_field,
-             ExcMessage("The 'AdvectionSystemBoundaryFace' assembler can only be executed for fields "
-                        "that use the advection method 'field' and a discontinuous discretization."));
-
-      // also have the number of dofs that correspond just to the element for
-      // the system we are currently trying to assemble
-      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
-
-      Assert (advection_dofs_per_cell < scratch.face_finite_element_values->get_fe().dofs_per_cell, ExcInternalError());
-      Assert (scratch.face_grad_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
-      Assert (scratch.face_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
-
-      const unsigned int solution_component = advection_field.component_index(introspection);
-
-      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
-
-
-      if (((this->get_fixed_temperature_boundary_indicators().find(
-              face->boundary_id()
-            )
-            != this->get_fixed_temperature_boundary_indicators().end())
-           && (advection_field.is_temperature()))
-          ||
-          (( this->get_fixed_composition_boundary_indicators().find(
-               face->boundary_id()
-             )
-             != this->get_fixed_composition_boundary_indicators().end())
-           && (!advection_field.is_temperature())))
-        {
-          /*
-           * We are in the case of a Dirichlet temperature or composition boundary.
-           * In the temperature case, impose the Dirichlet value weakly using a matrix term
-           * and RHS term. In the composition case, Dirichlet conditions can only be imposed
-           * on inflow boundaries, and we only have the flow-dependent terms, so we only
-           * assemble the corresponding flow-dependent and matrix and RHS terms
-           * if we are on an inflow boundary.
-           */
-
-          for (unsigned int q=0; q<n_q_points; ++q)
-            {
-              // precompute the values of shape functions and their gradients.
-              // We only need to look up values of shape functions if they
-              // belong to 'our' component. They are zero otherwise anyway.
-              // Note that we later only look at the values that we do set here.
-              for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
-                {
-                  if (fe.system_to_component_index(i).first == solution_component)
-                    {
-                      scratch.face_grad_phi_field[i_advection] = (*scratch.face_finite_element_values)[solution_field].gradient (i, q);
-                      scratch.face_phi_field[i_advection]      = (*scratch.face_finite_element_values)[solution_field].value (i, q);
-                      ++i_advection;
-                    }
-                  ++i;
-                }
-
-              const double density_c_P              =
-                ((advection_field.is_temperature())
-                 ?
-                 scratch.face_material_model_outputs.densities[q] *
-                 scratch.face_material_model_outputs.specific_heat[q]
-                 :
-                 1.0);
-
-              AssertThrow (density_c_P >= 0,
-                           ExcMessage ("The product of density and c_P needs to be a "
-                                       "non-negative quantity."));
-
-              const double conductivity =
-                ((advection_field.is_temperature())
-                 ?
-                 scratch.face_material_model_outputs.thermal_conductivities[q]
-                 :
-                 0.0);
-              const double latent_heat_LHS =
-                ((advection_field.is_temperature())
-                 ?
-                 scratch.face_heating_model_outputs.lhs_latent_heat_terms[q]
-                 :
-                 0.0);
-              AssertThrow (density_c_P + latent_heat_LHS >= 0,
-                           ExcMessage ("The sum of density times c_P and the latent heat contribution "
-                                       "to the left hand side needs to be a non-negative quantity."));
-
-              const double penalty = (advection_field.is_temperature()
-                                      ?
-                                      parameters.discontinuous_penalty
-                                      * parameters.temperature_degree
-                                      * parameters.temperature_degree
-                                      / approximate_face_measure(face)
-                                      * conductivity
-                                      / (density_c_P + latent_heat_LHS)
-                                      :
-                                      0.0);
-
-              const double dirichlet_value = (advection_field.is_temperature()
-                                              ?
-                                              this->get_boundary_temperature_manager().boundary_temperature(
-                                                face->boundary_id(),
-                                                scratch.face_finite_element_values->quadrature_point(q))
-                                              :
-                                              this->get_boundary_composition_manager().boundary_composition(
-                                                face->boundary_id(),
-                                                scratch.face_finite_element_values->quadrature_point(q),
-                                                advection_field.compositional_variable));
-
-              Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
-              // Subtract off the mesh velocity for ALE corrections if necessary
-              if (parameters.mesh_deformation_enabled)
-                current_u -= scratch.face_mesh_velocity_values[q];
-
-              /**
-               * The discontinuous Galerkin method uses 2 types of jumps over edges:
-               * undirected and directed jumps. Undirected jumps are dependent only
-               * on the order of the numbering of cells. Directed jumps are dependent
-               * on the direction of the flow. Thus the flow-dependent terms below are
-               * only calculated if the edge is an inflow edge.
-               */
-              const bool inflow = ((current_u * scratch.face_finite_element_values->normal_vector(q)) < 0.);
-
-              for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-                {
-                  data.local_rhs(i)
-                  += (- time_step *  conductivity
-                      * scratch.face_grad_phi_field[i]
-                      * scratch.face_finite_element_values->normal_vector(q)
-                      * dirichlet_value
-
-                      + time_step
-                      * (density_c_P + latent_heat_LHS)
-                      * penalty
-                      * scratch.face_phi_field[i]
-                      * dirichlet_value
-
-                      + (inflow
-                         ?
-                         - (density_c_P + latent_heat_LHS)
-                         * time_step
-                         * (current_u
-                            * scratch.face_finite_element_values->normal_vector(q))
-                         * dirichlet_value
-                         * scratch.face_phi_field[i]
-                         :
-                         0.)
-                     )
-                     *
-                     scratch.face_finite_element_values->JxW(q);
-
-                  // local_matrix terms
-                  for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                    {
-                      data.local_matrix(i,j)
-                      += (- time_step *  conductivity
-                          * scratch.face_grad_phi_field[i]
-                          * scratch.face_finite_element_values->normal_vector(q)
-                          * scratch.face_phi_field[j]
-
-                          - time_step *  conductivity
-                          * scratch.face_grad_phi_field[j]
-                          * scratch.face_finite_element_values->normal_vector(q)
-                          * scratch.face_phi_field[i]
-
-                          + time_step
-                          * (density_c_P + latent_heat_LHS)
-                          * penalty
-                          * scratch.face_phi_field[i]
-                          * scratch.face_phi_field[j]
-
-                          + (inflow
-                             ?
-                             - (density_c_P + latent_heat_LHS)
-                             * time_step
-                             * (current_u
-                                * scratch.face_finite_element_values->normal_vector(q))
-                             * scratch.face_phi_field[i]
-                             * scratch.face_phi_field[j]
-                             :
-                             0.)
-                         )
-                         * scratch.face_finite_element_values->JxW(q);
-                    }
-                }
-            }
-        }
-      else
-        {
-          // Neumann temperature term - no non-zero contribution as only homogeneous Neumann boundary conditions are implemented elsewhere for temperature
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    AdvectionSystemInteriorFace<dim>::execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                                              internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
-
-      const Parameters<dim> &parameters = this->get_parameters();
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const typename DoFHandler<dim>::active_cell_iterator cell = scratch.cell;
-      const unsigned int face_no = scratch.face_number;
-      const typename DoFHandler<dim>::face_iterator face = cell->face(face_no);
-
-      const typename Simulator<dim>::AdvectionField advection_field = *scratch.advection_field;
-
-      const unsigned int n_q_points    = scratch.face_finite_element_values->n_quadrature_points;
-
-      const double time_step = this->get_timestep();
-
-      if (!advection_field.is_discontinuous(introspection))
-        return;
-
-      // also have the number of dofs that correspond just to the element for
-      // the system we are currently trying to assemble
-      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int dofs_per_cell = fe.dofs_per_cell;
-
-      Assert (advection_dofs_per_cell < scratch.face_finite_element_values->get_fe().dofs_per_cell, ExcInternalError());
-      Assert (scratch.face_grad_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
-      Assert (scratch.face_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
-      Assert (n_q_points == scratch.subface_finite_element_values->n_quadrature_points, ExcInternalError());
-      Assert (n_q_points == scratch.neighbor_face_finite_element_values->n_quadrature_points, ExcInternalError());
-
-      const unsigned int solution_component = advection_field.component_index(introspection);
-
-      const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
-
-      // interior face or periodic face - no contribution on RHS
-
-      const typename DoFHandler<dim>::cell_iterator
-      neighbor = cell->neighbor_or_periodic_neighbor (face_no);
-      // note: "neighbor" defined above is NOT active_cell_iterator, so this includes cells that are refined
-      // for example: cell with periodic boundary.
-      Assert (neighbor.state() == IteratorState::valid,
-              ExcInternalError());
-      const bool cell_has_periodic_neighbor = cell->has_periodic_neighbor (face_no);
-
-      if (!neighbor->has_children())
-        {
-          if (neighbor->level () == cell->level () &&
-              neighbor->is_active() &&
-              (((neighbor->is_locally_owned()) && (cell->index() < neighbor->index()))
-               ||
-               ((!neighbor->is_locally_owned()) && (cell->subdomain_id() < neighbor->subdomain_id()))))
-            {
-              Assert (cell->is_locally_owned(), ExcInternalError());
-              // cell and neighbor are equal-sized, and cell has been chosen to assemble this face, so calculate from cell
-
-              const unsigned int neighbor2 =
-                (cell->has_periodic_neighbor(face_no)
-                 ?
-                 // how does the periodic neighbor talk about this cell?
-                 cell->periodic_neighbor_of_periodic_neighbor( face_no )
-                 :
-                 // how does the neighbor talk about this cell?
-                 cell->neighbor_of_neighbor(face_no));
-
-              // set up neighbor values
-              scratch.neighbor_face_finite_element_values->reinit (neighbor, neighbor2);
-
-              scratch.neighbor_face_material_model_inputs.reinit  (*scratch.neighbor_face_finite_element_values,
-                                                                   neighbor,
-                                                                   this->introspection(),
-                                                                   this->get_current_linearization_point());
-
-              this->create_additional_material_model_outputs(scratch.neighbor_face_material_model_outputs);
-              this->get_heating_model_manager().create_additional_material_model_inputs_and_outputs(scratch.neighbor_face_material_model_inputs,
-                  scratch.neighbor_face_material_model_outputs);
-
-              this->get_material_model().fill_additional_material_model_inputs(scratch.neighbor_face_material_model_inputs,
-                                                                               this->get_current_linearization_point(),
-                                                                               *scratch.neighbor_face_finite_element_values,
-                                                                               this->introspection());
-
-              this->get_material_model().evaluate(scratch.neighbor_face_material_model_inputs,
-                                                  scratch.neighbor_face_material_model_outputs);
-
-              if (parameters.formulation_temperature_equation ==
-                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-                {
-                  for (unsigned int q=0; q<n_q_points; ++q)
-                    {
-                      scratch.neighbor_face_material_model_outputs.densities[q] = this->get_adiabatic_conditions().density(scratch.neighbor_face_material_model_inputs.position[q]);
-                    }
-                }
-
-              this->get_heating_model_manager().evaluate(scratch.neighbor_face_material_model_inputs,
-                                                         scratch.neighbor_face_material_model_outputs,
-                                                         scratch.neighbor_face_heating_model_outputs);
-
-              std::vector<types::global_dof_index> neighbor_dof_indices (dofs_per_cell);
-              // get all dof indices on the neighbor, then extract those
-              // that correspond to the solution_field we are interested in
-              neighbor->get_dof_indices (neighbor_dof_indices);
-              for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
-                {
-                  if (fe.system_to_component_index(i).first == solution_component)
-                    {
-                      data.neighbor_dof_indices[nth_interface_matrix(fe.reference_cell(), face_no)][i_advection] = neighbor_dof_indices[i];
-                      ++i_advection;
-                    }
-                  ++i;
-                }
-              data.assembled_matrices[nth_interface_matrix(fe.reference_cell(), face_no)] = true;
-
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  // precompute the values of shape functions and their gradients.
-                  // We only need to look up values of shape functions if they
-                  // belong to 'our' component. They are zero otherwise anyway.
-                  // Note that we later only look at the values that we do set here.
-                  for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
-                    {
-                      if (fe.system_to_component_index(i).first == solution_component)
-                        {
-                          scratch.face_grad_phi_field[i_advection]          = (*scratch.face_finite_element_values)[solution_field].gradient (i, q);
-                          scratch.face_phi_field[i_advection]               = (*scratch.face_finite_element_values)[solution_field].value (i, q);
-                          scratch.neighbor_face_grad_phi_field[i_advection] = (*scratch.neighbor_face_finite_element_values)[solution_field].gradient (i, q);
-                          scratch.neighbor_face_phi_field[i_advection]      = (*scratch.neighbor_face_finite_element_values)[solution_field].value (i, q);
-                          ++i_advection;
-                        }
-                      ++i;
-                    }
-
-                  const double density_c_P              =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.face_material_model_outputs.densities[q] *
-                     scratch.face_material_model_outputs.specific_heat[q]
-                     :
-                     1.0);
-
-                  AssertThrow (density_c_P >= 0,
-                               ExcMessage ("The product of density and c_P needs to be a "
-                                           "non-negative quantity."));
-
-                  const double conductivity =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.face_material_model_outputs.thermal_conductivities[q]
-                     :
-                     0.0);
-                  const double latent_heat_LHS =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.face_heating_model_outputs.lhs_latent_heat_terms[q]
-                     :
-                     0.0);
-                  AssertThrow (density_c_P + latent_heat_LHS >= 0,
-                               ExcMessage ("The sum of density times c_P and the latent heat contribution "
-                                           "to the left hand side needs to be a non-negative quantity."));
-
-                  const double penalty = (advection_field.is_temperature()
-                                          ?
-                                          parameters.discontinuous_penalty
-                                          * parameters.temperature_degree
-                                          * parameters.temperature_degree
-                                          / approximate_face_measure(face)
-                                          * conductivity
-                                          / (density_c_P + latent_heat_LHS)
-                                          :
-                                          0.0);
-
-                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
-                  // Subtract off the mesh velocity for ALE corrections if necessary
-                  if (parameters.mesh_deformation_enabled)
-                    current_u -= scratch.face_mesh_velocity_values[q];
-
-                  const double neighbor_density_c_P              =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.neighbor_face_material_model_outputs.densities[q] *
-                     scratch.neighbor_face_material_model_outputs.specific_heat[q]
-                     :
-                     1.0);
-
-                  AssertThrow (neighbor_density_c_P >= 0,
-                               ExcMessage ("The product of density and c_P on the neighbor needs to be a "
-                                           "non-negative quantity."));
-
-                  const double neighbor_conductivity =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.neighbor_face_material_model_outputs.thermal_conductivities[q]
-                     :
-                     0.0);
-                  const double neighbor_latent_heat_LHS =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.neighbor_face_heating_model_outputs.lhs_latent_heat_terms[q]
-                     :
-                     0.0);
-                  AssertThrow (neighbor_density_c_P + neighbor_latent_heat_LHS >= 0,
-                               ExcMessage ("The sum of density times c_P and the latent heat contribution "
-                                           "to the left hand side on the neighbor needs to be a non-negative quantity."));
-
-                  const double neighbor_penalty = (advection_field.is_temperature()
-                                                   ?
-                                                   parameters.discontinuous_penalty
-                                                   * parameters.temperature_degree
-                                                   * parameters.temperature_degree
-                                                   / approximate_face_measure(neighbor->face(neighbor2))
-                                                   * neighbor_conductivity
-                                                   / (neighbor_density_c_P + neighbor_latent_heat_LHS)
-                                                   :
-                                                   0.0);
-
-                  const double max_penalty = std::max(penalty, neighbor_penalty);
-
-                  const double max_density_c_P_and_latent_heat =
-                    std::max(density_c_P + latent_heat_LHS,
-                             neighbor_density_c_P + neighbor_latent_heat_LHS);
-
-                  AssertThrow (numbers::is_finite(max_density_c_P_and_latent_heat),
-                               ExcMessage ("The maximum product of density and c_P plus latent heat LHS on the neighbor needs to be a finite quantity."));
-                  AssertThrow (max_density_c_P_and_latent_heat >= 0,
-                               ExcMessage ("The maximum product of density and c_P plus latent heat LHS on the neighbor needs to be a "
-                                           "non-negative quantity."));
-
-                  /**
-                   * The discontinuous Galerkin method uses 2 types of jumps over edges:
-                   * undirected and directed jumps. Undirected jumps are dependent only
-                   * on the order of the numbering of cells. Directed jumps are dependent
-                   * on the direction of the flow. Thus the flow-dependent terms below are
-                   * only calculated if the edge is an inflow edge.
-                   */
-                  const bool inflow = ((current_u * scratch.face_finite_element_values->normal_vector(q)) < 0.);
-
-                  for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-                    {
-                      for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                        {
-                          data.local_matrix(i,j)
-                          += (- 0.5 * time_step * conductivity
-                              * scratch.face_grad_phi_field[i]
-                              * scratch.face_finite_element_values->normal_vector(q)
-                              * scratch.face_phi_field[j]
-
-                              - 0.5 * time_step * conductivity
-                              * scratch.face_grad_phi_field[j]
-                              * scratch.face_finite_element_values->normal_vector(q)
-                              * scratch.face_phi_field[i]
-
-                              + time_step
-                              * max_density_c_P_and_latent_heat
-                              * max_penalty
-                              * scratch.face_phi_field[i]
-                              * scratch.face_phi_field[j]
-
-                              - (inflow
-                                 ?
-                                 (density_c_P + latent_heat_LHS)
-                                 * time_step
-                                 * (current_u
-                                    * scratch.face_finite_element_values->normal_vector(q))
-                                 * scratch.face_phi_field[i]
-                                 * scratch.face_phi_field[j]
-                                 :
-                                 0.)
-                             )
-                             * scratch.face_finite_element_values->JxW(q);
-
-                          data.local_matrices_int_ext[nth_interface_matrix(fe.reference_cell(), face_no)](i,j)
-                          += (- 0.5 * time_step * neighbor_conductivity
-                              * scratch.neighbor_face_grad_phi_field[j]
-                              * scratch.face_finite_element_values->normal_vector(q)
-                              * scratch.face_phi_field[i]
-
-                              + 0.5 * time_step * conductivity
-                              * scratch.face_grad_phi_field[i]
-                              * scratch.face_finite_element_values->normal_vector(q)
-                              * scratch.neighbor_face_phi_field[j]
-
-                              - time_step
-                              * max_density_c_P_and_latent_heat
-                              * max_penalty
-                              * scratch.neighbor_face_phi_field[j]
-                              * scratch.face_phi_field[i]
-
-                              + (inflow
-                                 ?
-                                 (density_c_P + latent_heat_LHS)
-                                 * time_step
-                                 * (current_u
-                                    * scratch.face_finite_element_values->normal_vector(q))
-                                 * scratch.face_phi_field[i]
-                                 * scratch.neighbor_face_phi_field[j]
-                                 :
-                                 0.)
-                             )
-                             * scratch.face_finite_element_values->JxW(q);
-
-                          data.local_matrices_ext_int[nth_interface_matrix(fe.reference_cell(), face_no)](i,j)
-                          += (+ 0.5 * time_step * conductivity
-                              * scratch.face_grad_phi_field[j]
-                              * scratch.face_finite_element_values->normal_vector(q)
-                              * scratch.neighbor_face_phi_field[i]
-
-                              - 0.5 * time_step * neighbor_conductivity
-                              * scratch.neighbor_face_grad_phi_field[i]
-                              * scratch.face_finite_element_values->normal_vector(q)
-                              * scratch.face_phi_field[j]
-
-                              - time_step
-                              * max_density_c_P_and_latent_heat
-                              * max_penalty
-                              * scratch.face_phi_field[j]
-                              * scratch.neighbor_face_phi_field[i]
-
-                              - (!inflow
-                                 ?
-                                 (neighbor_density_c_P + neighbor_latent_heat_LHS)
-                                 * time_step
-                                 * (current_u
-                                    * scratch.face_finite_element_values->normal_vector(q))
-                                 * scratch.neighbor_face_phi_field[i]
-                                 * scratch.face_phi_field[j]
-                                 :
-                                 0.)
-                             )
-                             * scratch.face_finite_element_values->JxW(q);
-
-                          data.local_matrices_ext_ext[nth_interface_matrix(fe.reference_cell(), face_no)](i,j)
-                          += (+ 0.5 * time_step * neighbor_conductivity
-                              * scratch.neighbor_face_grad_phi_field[i]
-                              * scratch.face_finite_element_values->normal_vector(q)
-                              * scratch.neighbor_face_phi_field[j]
-
-                              + 0.5 * time_step * neighbor_conductivity
-                              * scratch.neighbor_face_grad_phi_field[j]
-                              * scratch.face_finite_element_values->normal_vector(q)
-                              * scratch.neighbor_face_phi_field[i]
-
-                              + time_step
-                              * max_density_c_P_and_latent_heat
-                              * max_penalty
-                              * scratch.neighbor_face_phi_field[i]
-                              * scratch.neighbor_face_phi_field[j]
-
-                              + (!inflow
-                                 ?
-                                 (neighbor_density_c_P + neighbor_latent_heat_LHS)
-                                 * time_step
-                                 * (current_u
-                                    * scratch.face_finite_element_values->normal_vector(q))
-                                 * scratch.neighbor_face_phi_field[i]
-                                 * scratch.neighbor_face_phi_field[j]
-                                 :
-                                 0.)
-                             )
-                             * scratch.face_finite_element_values->JxW(q);
-                        }
-                    }
-                }
-            }
-          else
-            {
-              /* neighbor is taking responsibility for assembly of this face, because
-               * either (1) neighbor is coarser, or
-               *        (2) neighbor is equally-sized and
-               *           (a) neighbor is on a different subdomain, with lower subdmain_id(), or
-               *           (b) neighbor is on the same subdomain and has lower index().
-              */
-            }
-        }
-      // neighbor has children, so always assemble from here.
-      else
-        {
-          const unsigned int neighbor2 =
-            (cell_has_periodic_neighbor
-             ?
-             cell->periodic_neighbor_face_no(face_no)
-             :
-             cell->neighbor_face_no(face_no));
-
-          // Loop over subfaces. We know that the neighbor is finer, so we could loop over the subfaces of the current
-          // face. but if we are at a periodic boundary, then the face of the current cell has no children, so instead use
-          // the children of the periodic neighbor's corresponding face since we know that the letter does indeed have
-          // children (because we know that the neighbor is refined).
-          typename DoFHandler<dim>::face_iterator neighbor_face=neighbor->face(neighbor2);
-          for (unsigned int subface_no=0; subface_no<neighbor_face->n_children(); ++subface_no)
-            {
-              const typename DoFHandler<dim>::active_cell_iterator neighbor_child
-                = ( cell_has_periodic_neighbor
-                    ?
-                    cell->periodic_neighbor_child_on_subface(face_no,subface_no)
-                    :
-                    cell->neighbor_child_on_subface (face_no, subface_no));
-
-              // set up subface values
-              scratch.subface_finite_element_values->reinit (cell, face_no, subface_no);
-
-              // subface->face
-              (*scratch.subface_finite_element_values)[introspection.extractors.velocities].get_function_values(this->get_current_linearization_point(),
-                  scratch.face_current_velocity_values);
-
-              // get the mesh velocity, as we need to subtract it off of the advection systems
-              if (parameters.mesh_deformation_enabled)
-                (*scratch.subface_finite_element_values)[introspection.extractors.velocities].get_function_values(this->get_mesh_velocity(),
-                    scratch.face_mesh_velocity_values);
-
-              scratch.face_material_model_inputs.reinit  (*scratch.subface_finite_element_values,
-                                                          cell,
-                                                          this->introspection(),
-                                                          this->get_current_linearization_point());
-              this->get_material_model().evaluate(scratch.face_material_model_inputs,
-                                                  scratch.face_material_model_outputs);
-
-              if (parameters.formulation_temperature_equation ==
-                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-                {
-                  for (unsigned int q=0; q<n_q_points; ++q)
-                    {
-                      scratch.face_material_model_outputs.densities[q] = this->get_adiabatic_conditions().density(scratch.face_material_model_inputs.position[q]);
-                    }
-                }
-
-              this->get_heating_model_manager().evaluate(scratch.face_material_model_inputs,
-                                                         scratch.face_material_model_outputs,
-                                                         scratch.face_heating_model_outputs);
-
-              // set up neighbor values
-              scratch.neighbor_face_finite_element_values->reinit (neighbor_child, neighbor2);
-
-              scratch.neighbor_face_material_model_inputs.reinit  (*scratch.neighbor_face_finite_element_values,
-                                                                   neighbor_child,
-                                                                   this->introspection(),
-                                                                   this->get_current_linearization_point());
-              this->get_material_model().evaluate(scratch.neighbor_face_material_model_inputs,
-                                                  scratch.neighbor_face_material_model_outputs);
-
-              if (parameters.formulation_temperature_equation ==
-                  Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-                {
-                  for (unsigned int q=0; q<n_q_points; ++q)
-                    {
-                      scratch.neighbor_face_material_model_outputs.densities[q] = this->get_adiabatic_conditions().density(scratch.neighbor_face_material_model_inputs.position[q]);
-                    }
-                }
-
-              this->get_heating_model_manager().evaluate(scratch.neighbor_face_material_model_inputs,
-                                                         scratch.neighbor_face_material_model_outputs,
-                                                         scratch.neighbor_face_heating_model_outputs);
-
-              std::vector<types::global_dof_index> neighbor_dof_indices (fe.dofs_per_cell);
-              // get all dof indices on the neighbor, then extract those
-              // that correspond to the solution_field we are interested in
-              neighbor_child->get_dof_indices (neighbor_dof_indices);
-              for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell;/*increment at end of loop*/)
-                {
-                  if (fe.system_to_component_index(i).first == solution_component)
-                    {
-                      data.neighbor_dof_indices[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)][i_advection] = neighbor_dof_indices[i];
-                      ++i_advection;
-                    }
-                  ++i;
-                }
-              data.assembled_matrices[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)] = true;
-
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  // precompute the values of shape functions and their gradients.
-                  // We only need to look up values of shape functions if they
-                  // belong to 'our' component. They are zero otherwise anyway.
-                  // Note that we later only look at the values that we do set here.
-                  for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
-                    {
-                      if (fe.system_to_component_index(i).first == solution_component)
-                        {
-                          scratch.face_grad_phi_field[i_advection]          = (*scratch.subface_finite_element_values)[solution_field].gradient (i, q);
-                          scratch.face_phi_field[i_advection]               = (*scratch.subface_finite_element_values)[solution_field].value (i, q);
-                          scratch.neighbor_face_grad_phi_field[i_advection] = (*scratch.neighbor_face_finite_element_values)[solution_field].gradient (i, q);
-                          scratch.neighbor_face_phi_field[i_advection]      = (*scratch.neighbor_face_finite_element_values)[solution_field].value (i, q);
-                          ++i_advection;
-                        }
-                      ++i;
-                    }
-
-                  const double density_c_P              =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.face_material_model_outputs.densities[q] *
-                     scratch.face_material_model_outputs.specific_heat[q]
-                     :
-                     1.0);
-
-                  AssertThrow (density_c_P >= 0,
-                               ExcMessage ("The product of density and c_P needs to be a "
-                                           "non-negative quantity."));
-
-                  const double conductivity =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.face_material_model_outputs.thermal_conductivities[q]
-                     :
-                     0.0);
-                  const double latent_heat_LHS =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.face_heating_model_outputs.lhs_latent_heat_terms[q]
-                     :
-                     0.0);
-                  AssertThrow (density_c_P + latent_heat_LHS >= 0,
-                               ExcMessage ("The sum of density times c_P and the latent heat contribution "
-                                           "to the left hand side needs to be a non-negative quantity."));
-
-                  const double penalty = (advection_field.is_temperature()
-                                          ?
-                                          parameters.discontinuous_penalty
-                                          * parameters.temperature_degree
-                                          * parameters.temperature_degree
-                                          / approximate_face_measure(face)
-                                          * conductivity
-                                          / (density_c_P + latent_heat_LHS)
-                                          :
-                                          0.0);
-
-                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
-                  // Subtract off the mesh velocity for ALE corrections if necessary
-                  if (parameters.mesh_deformation_enabled)
-                    current_u -= scratch.face_mesh_velocity_values[q];
-
-                  const double neighbor_density_c_P              =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.neighbor_face_material_model_outputs.densities[q] *
-                     scratch.neighbor_face_material_model_outputs.specific_heat[q]
-                     :
-                     1.0);
-
-                  AssertThrow (neighbor_density_c_P >= 0,
-                               ExcMessage ("The product of density and c_P on the neighbor needs to be a "
-                                           "non-negative quantity."));
-
-                  const double neighbor_conductivity =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.neighbor_face_material_model_outputs.thermal_conductivities[q]
-                     :
-                     0.0);
-                  const double neighbor_latent_heat_LHS =
-                    ((advection_field.is_temperature())
-                     ?
-                     scratch.neighbor_face_heating_model_outputs.lhs_latent_heat_terms[q]
-                     :
-                     0.0);
-                  AssertThrow (neighbor_density_c_P + neighbor_latent_heat_LHS >= 0,
-                               ExcMessage ("The sum of density times c_P and the latent heat contribution "
-                                           "to the left hand side on the neighbor needs to be a non-negative quantity."));
-
-                  const double neighbor_penalty = (advection_field.is_temperature()
-                                                   ?
-                                                   parameters.discontinuous_penalty
-                                                   * parameters.temperature_degree
-                                                   * parameters.temperature_degree
-                                                   / approximate_face_measure(neighbor_child->face(neighbor2))
-                                                   * neighbor_conductivity
-                                                   / (neighbor_density_c_P + neighbor_latent_heat_LHS)
-                                                   :
-                                                   0.0);
-
-                  const double max_penalty = std::max(penalty, neighbor_penalty);
-
-                  const double max_density_c_P_and_latent_heat =
-                    std::max(density_c_P + latent_heat_LHS,
-                             neighbor_density_c_P + neighbor_latent_heat_LHS);
-
-                  AssertThrow (numbers::is_finite(max_density_c_P_and_latent_heat),
-                               ExcMessage ("The maximum product of density and c_P plus latent heat LHS on the neighbor needs to be a finite quantity."));
-                  AssertThrow (max_density_c_P_and_latent_heat >= 0,
-                               ExcMessage ("The maximum product of density and c_P plus latent heat LHS on the neighbor needs to be a "
-                                           "non-negative quantity."));
-
-                  /**
-                   * The discontinuous Galerkin method uses 2 types of jumps over edges:
-                   * undirected and directed jumps. Undirected jumps are dependent only
-                   * on the order of the numbering of cells. Directed jumps are dependent
-                   * on the direction of the flow. Thus the flow-dependent terms below are
-                   * only calculated if the edge is an inflow edge.
-                   */
-                  const bool inflow = ((current_u * scratch.subface_finite_element_values->normal_vector(q)) < 0.);
-
-                  for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-                    {
-                      for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                        {
-                          data.local_matrix(i,j)
-                          += (- 0.5 * time_step * conductivity
-                              * scratch.face_grad_phi_field[i]
-                              * scratch.subface_finite_element_values->normal_vector(q)
-                              * scratch.face_phi_field[j]
-
-                              - 0.5 * time_step * conductivity
-                              * scratch.face_grad_phi_field[j]
-                              * scratch.subface_finite_element_values->normal_vector(q)
-                              * scratch.face_phi_field[i]
-
-                              + time_step
-                              * max_density_c_P_and_latent_heat
-                              * max_penalty
-                              * scratch.face_phi_field[i]
-                              * scratch.face_phi_field[j]
-
-                              - (inflow
-                                 ?
-                                 (density_c_P + latent_heat_LHS)
-                                 * time_step
-                                 * (current_u
-                                    * scratch.subface_finite_element_values->normal_vector(q))
-                                 * scratch.face_phi_field[i]
-                                 * scratch.face_phi_field[j]
-                                 :
-                                 0.)
-                             )
-                             * scratch.subface_finite_element_values->JxW(q);
-
-                          data.local_matrices_int_ext[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)](i,j)
-                          += (- 0.5 * time_step * neighbor_conductivity
-                              * scratch.neighbor_face_grad_phi_field[j]
-                              * scratch.subface_finite_element_values->normal_vector(q)
-                              * scratch.face_phi_field[i]
-
-                              + 0.5 * time_step * conductivity
-                              * scratch.face_grad_phi_field[i]
-                              * scratch.subface_finite_element_values->normal_vector(q)
-                              * scratch.neighbor_face_phi_field[j]
-
-                              - time_step
-                              * max_density_c_P_and_latent_heat
-                              * max_penalty
-                              * scratch.neighbor_face_phi_field[j]
-                              * scratch.face_phi_field[i]
-
-                              + (inflow
-                                 ?
-                                 (density_c_P + latent_heat_LHS)
-                                 * time_step
-                                 * (current_u
-                                    * scratch.subface_finite_element_values->normal_vector(q))
-                                 * scratch.face_phi_field[i]
-                                 * scratch.neighbor_face_phi_field[j]
-                                 :
-                                 0.)
-                             )
-                             * scratch.subface_finite_element_values->JxW(q);
-
-                          data.local_matrices_ext_int[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)](i,j)
-                          += (+ 0.5 * time_step * conductivity
-                              * scratch.face_grad_phi_field[j]
-                              * scratch.subface_finite_element_values->normal_vector(q)
-                              * scratch.neighbor_face_phi_field[i]
-
-                              - 0.5 * time_step * neighbor_conductivity
-                              * scratch.neighbor_face_grad_phi_field[i]
-                              * scratch.subface_finite_element_values->normal_vector(q)
-                              * scratch.face_phi_field[j]
-
-                              - time_step
-                              * max_density_c_P_and_latent_heat
-                              * max_penalty
-                              * scratch.face_phi_field[j]
-                              * scratch.neighbor_face_phi_field[i]
-
-                              - (!inflow
-                                 ?
-                                 (neighbor_density_c_P + neighbor_latent_heat_LHS)
-                                 * time_step
-                                 * (current_u
-                                    * scratch.subface_finite_element_values->normal_vector(q))
-                                 * scratch.neighbor_face_phi_field[i]
-                                 * scratch.face_phi_field[j]
-                                 :
-                                 0.)
-                             )
-                             * scratch.subface_finite_element_values->JxW(q);
-
-                          data.local_matrices_ext_ext[nth_interface_matrix(fe.reference_cell(), face_no, subface_no)](i,j)
-                          += (+ 0.5 * time_step * neighbor_conductivity
-                              * scratch.neighbor_face_grad_phi_field[i]
-                              * scratch.subface_finite_element_values->normal_vector(q)
-                              * scratch.neighbor_face_phi_field[j]
-
-                              + 0.5 * time_step * neighbor_conductivity
-                              * scratch.neighbor_face_grad_phi_field[j]
-                              * scratch.subface_finite_element_values->normal_vector(q)
-                              * scratch.neighbor_face_phi_field[i]
-
-                              + time_step
-                              * max_density_c_P_and_latent_heat
-                              * max_penalty
-                              * scratch.neighbor_face_phi_field[i]
-                              * scratch.neighbor_face_phi_field[j]
-
-                              + (!inflow
-                                 ?
-                                 (neighbor_density_c_P + neighbor_latent_heat_LHS)
-                                 * time_step
-                                 * (current_u
-                                    * scratch.subface_finite_element_values->normal_vector(q))
-                                 * scratch.neighbor_face_phi_field[i]
-                                 * scratch.neighbor_face_phi_field[j]
-                                 :
-                                 0.)
-                             )
-                             * scratch.subface_finite_element_values->JxW(q);
-                        }
-                    }
-                }
-            }
-        }
-    }
-  }
-} // namespace aspect
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace Assemblers
-  {
-#define INSTANTIATE(dim) \
-  template class AdvectionSystem<dim>; \
-  template class DiffusionSystem<dim>; \
-  template class DarcySystem<dim>; \
-  template class AdvectionSystemBoundaryFace<dim>; \
-  template class AdvectionSystemInteriorFace<dim>; \
-  template class AdvectionSystemBoundaryHeatFlux<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/simulator/assemblers/interface.cc.bak b/source/simulator/assemblers/interface.cc.bak
deleted file mode 100644
index b824393e2c3..00000000000
--- a/source/simulator/assemblers/interface.cc.bak
+++ /dev/null
@@ -1,656 +0,0 @@
-/*
-  Copyright (C) 2017 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator/assemblers/interface.h>
-
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Assembly
-    {
-      namespace Scratch
-      {
-        template <int dim>
-        StokesPreconditioner<dim>::
-        StokesPreconditioner (const FiniteElement<dim> &finite_element,
-                              const Quadrature<dim>    &quadrature,
-                              const Mapping<dim>       &mapping,
-                              const UpdateFlags         update_flags,
-                              const unsigned int        n_compositional_fields,
-                              const unsigned int        stokes_dofs_per_cell,
-                              const bool                add_compaction_pressure,
-                              const bool                rebuild_matrix,
-                              const bool                use_bfbt)
-          :
-          ScratchBase<dim>(),
-
-          finite_element_values (mapping, finite_element, quadrature,
-                                 update_flags),
-          local_dof_indices (finite_element.dofs_per_cell),
-          dof_component_indices(stokes_dofs_per_cell),
-          grads_phi_u (stokes_dofs_per_cell, numbers::signaling_nan<SymmetricTensor<2,dim>>()),
-          div_phi_u (stokes_dofs_per_cell, numbers::signaling_nan<double>()),
-          phi_p (stokes_dofs_per_cell, numbers::signaling_nan<double>()),
-          phi_u (stokes_dofs_per_cell,numbers::signaling_nan<Tensor<1,dim>>()),
-          phi_p_c (add_compaction_pressure ? stokes_dofs_per_cell : 0, numbers::signaling_nan<double>()),
-          grad_phi_p ((add_compaction_pressure || use_bfbt) ? stokes_dofs_per_cell : 0, numbers::signaling_nan<Tensor<1,dim>>()),
-          material_model_inputs(quadrature.size(), n_compositional_fields),
-          material_model_outputs(quadrature.size(), n_compositional_fields),
-          rebuild_stokes_matrix(rebuild_matrix)
-        {}
-
-
-
-        template <int dim>
-        StokesPreconditioner<dim>::
-        StokesPreconditioner (const StokesPreconditioner &scratch)
-          :
-          ScratchBase<dim>(scratch),
-
-          finite_element_values (scratch.finite_element_values.get_mapping(),
-                                 scratch.finite_element_values.get_fe(),
-                                 scratch.finite_element_values.get_quadrature(),
-                                 scratch.finite_element_values.get_update_flags()),
-
-          local_dof_indices (scratch.local_dof_indices),
-          dof_component_indices( scratch.dof_component_indices),
-          grads_phi_u (scratch.grads_phi_u),
-          div_phi_u (scratch.div_phi_u),
-          phi_p (scratch.phi_p),
-          phi_u (scratch.phi_u),
-          phi_p_c (scratch.phi_p_c),
-          grad_phi_p(scratch.grad_phi_p),
-          material_model_inputs(scratch.material_model_inputs),
-          material_model_outputs(scratch.material_model_outputs),
-          rebuild_stokes_matrix(scratch.rebuild_stokes_matrix)
-        {}
-
-
-        template <int dim>
-        StokesPreconditioner<dim>::
-        ~StokesPreconditioner ()
-          = default;
-
-
-        template <int dim>
-        void
-        StokesPreconditioner<dim>::
-        reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref)
-        {
-          this->cell = cell_ref;
-          this->face_number = numbers::invalid_unsigned_int;
-          finite_element_values.reinit (cell_ref);
-        }
-
-
-        template <int dim>
-        StokesSystem<dim>::
-        StokesSystem (const FiniteElement<dim> &finite_element,
-                      const Mapping<dim>       &mapping,
-                      const Quadrature<dim>    &quadrature,
-                      const Quadrature<dim-1>  &face_quadrature,
-                      const UpdateFlags         update_flags,
-                      const UpdateFlags         face_update_flags,
-                      const unsigned int        n_compositional_fields,
-                      const unsigned int        stokes_dofs_per_cell,
-                      const bool                add_compaction_pressure,
-                      const bool                use_reference_density_profile,
-                      const bool                rebuild_stokes_matrix,
-                      const bool                rebuild_newton_stokes_matrix,
-                      const bool                use_bfbt)
-          :
-          StokesPreconditioner<dim> (finite_element, quadrature,
-                                     mapping,
-                                     update_flags,
-                                     n_compositional_fields,
-                                     stokes_dofs_per_cell,
-                                     add_compaction_pressure,
-                                     rebuild_stokes_matrix,
-                                     use_bfbt),
-
-          face_finite_element_values (mapping,
-                                      finite_element,
-                                      face_quadrature,
-                                      face_update_flags),
-
-          phi_u (stokes_dofs_per_cell, numbers::signaling_nan<Tensor<1,dim>>()),
-          velocity_values (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          velocity_divergence(quadrature.size(), numbers::signaling_nan<double>()),
-          temperature_gradients (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          face_material_model_inputs(face_quadrature.size(), n_compositional_fields),
-          face_material_model_outputs(face_quadrature.size(), n_compositional_fields),
-          reference_densities(use_reference_density_profile ? quadrature.size() : 0, numbers::signaling_nan<double>()),
-          reference_densities_depth_derivative(use_reference_density_profile ? quadrature.size() : 0, numbers::signaling_nan<double>()),
-          rebuild_newton_stokes_matrix(rebuild_newton_stokes_matrix)
-        {}
-
-
-
-        template <int dim>
-        StokesSystem<dim>::
-        StokesSystem (const StokesSystem<dim> &scratch)
-          :
-          StokesPreconditioner<dim> (scratch),
-
-          face_finite_element_values (scratch.face_finite_element_values.get_mapping(),
-                                      scratch.face_finite_element_values.get_fe(),
-                                      scratch.face_finite_element_values.get_quadrature(),
-                                      scratch.face_finite_element_values.get_update_flags()),
-
-          phi_u (scratch.phi_u),
-          velocity_values (scratch.velocity_values),
-          velocity_divergence (scratch.velocity_divergence),
-          temperature_gradients (scratch.temperature_gradients),
-          face_material_model_inputs(scratch.face_material_model_inputs),
-          face_material_model_outputs(scratch.face_material_model_outputs),
-          reference_densities(scratch.reference_densities),
-          reference_densities_depth_derivative(scratch.reference_densities_depth_derivative),
-          rebuild_newton_stokes_matrix(scratch.rebuild_newton_stokes_matrix)
-        {}
-
-        template <int dim>
-        void
-        StokesSystem<dim>::
-        reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref,
-                const unsigned face_number_ref)
-        {
-          this->cell = cell_ref;
-          this->face_number = face_number_ref;
-          face_finite_element_values.reinit(cell_ref, face_number_ref);
-        }
-
-
-
-        template <int dim>
-        AdvectionSystem<dim>::
-        AdvectionSystem (const FiniteElement<dim> &finite_element,
-                         const FiniteElement<dim> &advection_element,
-                         const Mapping<dim>       &mapping,
-                         const Quadrature<dim>    &quadrature,
-                         const Quadrature<dim-1>  &face_quadrature,
-                         const UpdateFlags         update_flags,
-                         const UpdateFlags         face_update_flags,
-                         const unsigned int        n_compositional_fields,
-                         const typename Simulator<dim>::AdvectionField &field)
-          :
-          ScratchBase<dim>(),
-
-          finite_element_values (mapping,
-                                 finite_element, quadrature,
-                                 update_flags),
-          face_finite_element_values (face_quadrature.size() > 0
-                                      ?
-                                      std::make_unique<FEFaceValues<dim>> (mapping,
-                                                                            finite_element, face_quadrature,
-                                                                            face_update_flags)
-                                      :
-                                      nullptr),
-          neighbor_face_finite_element_values (face_quadrature.size() > 0
-                                               ?
-                                               std::make_unique<FEFaceValues<dim>> (mapping,
-                                                                                     finite_element, face_quadrature,
-                                                                                     face_update_flags)
-                                               :
-                                               nullptr),
-          subface_finite_element_values (face_quadrature.size() > 0
-                                         ?
-                                         std::make_unique<FESubfaceValues<dim>> (mapping,
-                                                                                  finite_element, face_quadrature,
-                                                                                  face_update_flags)
-                                         :
-                                         nullptr),
-          local_dof_indices (finite_element.dofs_per_cell),
-
-          phi_field (advection_element.dofs_per_cell, numbers::signaling_nan<double>()),
-          grad_phi_field (advection_element.dofs_per_cell, numbers::signaling_nan<Tensor<1,dim>>()),
-          laplacian_phi_field (advection_element.dofs_per_cell, numbers::signaling_nan<double>()),
-          face_phi_field ((face_quadrature.size() > 0 ? advection_element.dofs_per_cell : 0),
-                          numbers::signaling_nan<double>()),
-          face_grad_phi_field ((face_quadrature.size() > 0 ? advection_element.dofs_per_cell : 0),
-                               numbers::signaling_nan<Tensor<1,dim>>()),
-          neighbor_face_phi_field ((face_quadrature.size() > 0 ? advection_element.dofs_per_cell : 0),
-                                   numbers::signaling_nan<double>()),
-          neighbor_face_grad_phi_field ((face_quadrature.size() > 0 ? advection_element.dofs_per_cell : 0),
-                                        numbers::signaling_nan<Tensor<1,dim>>()),
-          old_velocity_values (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          old_old_velocity_values (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          old_pressure (quadrature.size(), numbers::signaling_nan<double>()),
-          old_old_pressure (quadrature.size(), numbers::signaling_nan<double>()),
-          old_pressure_gradients (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          old_old_pressure_gradients (quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          old_strain_rates (quadrature.size(), numbers::signaling_nan<SymmetricTensor<2,dim>>()),
-          old_old_strain_rates (quadrature.size(), numbers::signaling_nan<SymmetricTensor<2,dim>>()),
-          old_temperature_values (quadrature.size(), numbers::signaling_nan<double>()),
-          old_old_temperature_values(quadrature.size(), numbers::signaling_nan<double>()),
-          old_field_values (quadrature.size(), numbers::signaling_nan<double>()),
-          old_old_field_values(quadrature.size(), numbers::signaling_nan<double>()),
-          old_field_grads(quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          old_old_field_grads(quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          old_field_laplacians(quadrature.size(), numbers::signaling_nan<double>()),
-          old_old_field_laplacians(quadrature.size(), numbers::signaling_nan<double>()),
-          old_composition_values(n_compositional_fields,
-                                 std::vector<double>(quadrature.size(), numbers::signaling_nan<double>())),
-          old_old_composition_values(n_compositional_fields,
-                                     std::vector<double>(quadrature.size(), numbers::signaling_nan<double>())),
-          current_temperature_values(quadrature.size(), numbers::signaling_nan<double>()),
-          current_velocity_values(quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          face_current_velocity_values(face_quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          mesh_velocity_values(quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          face_mesh_velocity_values(face_quadrature.size(), numbers::signaling_nan<Tensor<1,dim>>()),
-          current_strain_rates(quadrature.size(), numbers::signaling_nan<SymmetricTensor<2,dim>>()),
-          current_composition_values(n_compositional_fields,
-                                     std::vector<double>(quadrature.size(), numbers::signaling_nan<double>())),
-          current_velocity_divergences(quadrature.size(), numbers::signaling_nan<double>()),
-          material_model_inputs(quadrature.size(), n_compositional_fields),
-          material_model_outputs(quadrature.size(), n_compositional_fields),
-          face_material_model_inputs(face_quadrature.size(), n_compositional_fields),
-          face_material_model_outputs(face_quadrature.size(), n_compositional_fields),
-          neighbor_face_material_model_inputs(face_quadrature.size(), n_compositional_fields),
-          neighbor_face_material_model_outputs(face_quadrature.size(), n_compositional_fields),
-          heating_model_outputs(quadrature.size(), n_compositional_fields),
-          face_heating_model_outputs(face_quadrature.size(), n_compositional_fields),
-          neighbor_face_heating_model_outputs(face_quadrature.size(), n_compositional_fields),
-          advection_field(&field),
-          artificial_viscosity(numbers::signaling_nan<double>())
-        {}
-
-
-
-        template <int dim>
-        AdvectionSystem<dim>::
-        AdvectionSystem (const AdvectionSystem &scratch)
-          :
-          ScratchBase<dim>(scratch),
-
-          finite_element_values (scratch.finite_element_values.get_mapping(),
-                                 scratch.finite_element_values.get_fe(),
-                                 scratch.finite_element_values.get_quadrature(),
-                                 scratch.finite_element_values.get_update_flags()),
-          face_finite_element_values (scratch.face_finite_element_values.get()
-                                      ?
-                                      std::make_unique<FEFaceValues<dim>> (scratch.face_finite_element_values->get_mapping(),
-                                                                            scratch.face_finite_element_values->get_fe(),
-                                                                            scratch.face_finite_element_values->get_quadrature(),
-                                                                            scratch.face_finite_element_values->get_update_flags())
-                                      :
-                                      nullptr),
-          neighbor_face_finite_element_values (scratch.neighbor_face_finite_element_values.get()
-                                               ?
-                                               std::make_unique<FEFaceValues<dim>> (scratch.neighbor_face_finite_element_values->get_mapping(),
-                                                                                     scratch.neighbor_face_finite_element_values->get_fe(),
-                                                                                     scratch.neighbor_face_finite_element_values->get_quadrature(),
-                                                                                     scratch.neighbor_face_finite_element_values->get_update_flags())
-                                               :
-                                               nullptr),
-          subface_finite_element_values (scratch.subface_finite_element_values.get()
-                                         ?
-                                         std::make_unique<FESubfaceValues<dim>> (scratch.subface_finite_element_values->get_mapping(),
-                                                                                  scratch.subface_finite_element_values->get_fe(),
-                                                                                  scratch.subface_finite_element_values->get_quadrature(),
-                                                                                  scratch.subface_finite_element_values->get_update_flags())
-                                         :
-                                         nullptr),
-          local_dof_indices (scratch.finite_element_values.get_fe().dofs_per_cell),
-
-          phi_field (scratch.phi_field),
-          grad_phi_field (scratch.grad_phi_field),
-          laplacian_phi_field (scratch.laplacian_phi_field),
-          face_phi_field (scratch.face_phi_field),
-          face_grad_phi_field (scratch.face_grad_phi_field),
-          neighbor_face_phi_field (scratch.neighbor_face_phi_field),
-          neighbor_face_grad_phi_field (scratch.neighbor_face_grad_phi_field),
-          old_velocity_values (scratch.old_velocity_values),
-          old_old_velocity_values (scratch.old_old_velocity_values),
-          old_pressure (scratch.old_pressure),
-          old_old_pressure (scratch.old_old_pressure),
-          old_pressure_gradients (scratch.old_pressure_gradients),
-          old_old_pressure_gradients (scratch.old_old_pressure_gradients),
-          old_strain_rates (scratch.old_strain_rates),
-          old_old_strain_rates (scratch.old_old_strain_rates),
-          old_temperature_values (scratch.old_temperature_values),
-          old_old_temperature_values (scratch.old_old_temperature_values),
-          old_field_values (scratch.old_field_values),
-          old_old_field_values(scratch.old_old_field_values),
-          old_field_grads (scratch.old_field_grads),
-          old_old_field_grads (scratch.old_old_field_grads),
-          old_field_laplacians (scratch.old_field_laplacians),
-          old_old_field_laplacians (scratch.old_old_field_laplacians),
-          old_composition_values(scratch.old_composition_values),
-          old_old_composition_values(scratch.old_old_composition_values),
-          current_temperature_values(scratch.current_temperature_values),
-          current_velocity_values(scratch.current_velocity_values),
-          face_current_velocity_values(scratch.face_current_velocity_values),
-          mesh_velocity_values(scratch.mesh_velocity_values),
-          face_mesh_velocity_values(scratch.face_mesh_velocity_values),
-          current_strain_rates(scratch.current_strain_rates),
-          current_composition_values(scratch.current_composition_values),
-          current_velocity_divergences(scratch.current_velocity_divergences),
-          material_model_inputs(scratch.material_model_inputs),
-          material_model_outputs(scratch.material_model_outputs),
-          face_material_model_inputs(scratch.face_material_model_inputs),
-          face_material_model_outputs(scratch.face_material_model_outputs),
-          neighbor_face_material_model_inputs(scratch.neighbor_face_material_model_inputs),
-          neighbor_face_material_model_outputs(scratch.neighbor_face_material_model_outputs),
-          heating_model_outputs(scratch.heating_model_outputs),
-          face_heating_model_outputs(scratch.face_heating_model_outputs),
-          neighbor_face_heating_model_outputs(scratch.neighbor_face_heating_model_outputs),
-          advection_field(scratch.advection_field),
-          artificial_viscosity(scratch.artificial_viscosity)
-        {}
-
-
-        template <int dim>
-        void
-        AdvectionSystem<dim>::
-        reinit (const typename DoFHandler<dim>::active_cell_iterator &cell_ref)
-        {
-          this->cell = cell_ref;
-          this->face_number = numbers::invalid_unsigned_int;
-          finite_element_values.reinit (cell_ref);
-        }
-
-      }
-
-
-      namespace CopyData
-      {
-
-        template <int dim>
-        StokesPreconditioner<dim>::
-        StokesPreconditioner (const unsigned int stokes_dofs_per_cell)
-          :
-          local_matrix (stokes_dofs_per_cell,
-                        stokes_dofs_per_cell),
-          local_inverse_lumped_mass_matrix (stokes_dofs_per_cell),
-          local_dof_indices (stokes_dofs_per_cell)
-        {}
-
-
-
-        template <int dim>
-        StokesPreconditioner<dim>::
-        StokesPreconditioner (const StokesPreconditioner &data)
-          :
-          local_matrix (data.local_matrix),
-          local_inverse_lumped_mass_matrix (data.local_inverse_lumped_mass_matrix),
-          local_dof_indices (data.local_dof_indices)
-        {}
-
-
-        template <int dim>
-        void StokesPreconditioner<dim>::
-        extract_stokes_dof_indices(const std::vector<types::global_dof_index> &all_dof_indices,
-                                   const Introspection<dim>                   &introspection,
-                                   const FiniteElement<dim>           &finite_element)
-        {
-          const unsigned int dofs_per_cell = finite_element.dofs_per_cell;
-
-          for (unsigned int i=0, i_stokes=0; i<dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(finite_element.system_to_component_index(i).first))
-                {
-                  this->local_dof_indices[i_stokes] = all_dof_indices[i];
-                  ++i_stokes;
-                }
-              ++i;
-            }
-        }
-
-
-
-        template <int dim>
-        StokesSystem<dim>::
-        StokesSystem (const unsigned int        stokes_dofs_per_cell,
-                      const bool                do_pressure_rhs_compatibility_modification)
-          :
-          StokesPreconditioner<dim> (stokes_dofs_per_cell),
-          local_rhs (stokes_dofs_per_cell),
-          local_pressure_shape_function_integrals (do_pressure_rhs_compatibility_modification ?
-                                                   stokes_dofs_per_cell
-                                                   :
-                                                   0)
-        {}
-
-
-
-        template <int dim>
-        StokesSystem<dim>::
-        StokesSystem (const StokesSystem<dim> &data)
-          :
-          StokesPreconditioner<dim> (data),
-          local_rhs (data.local_rhs),
-          local_pressure_shape_function_integrals (data.local_pressure_shape_function_integrals.size())
-        {}
-
-
-
-
-        template <int dim>
-        AdvectionSystem<dim>::
-        AdvectionSystem (const FiniteElement<dim> &finite_element,
-                         const bool                field_is_discontinuous)
-          :
-          local_matrix (finite_element.dofs_per_cell,
-                        finite_element.dofs_per_cell),
-          local_matrices_int_ext ((field_is_discontinuous
-                                   ?
-                                   Assemblers::n_interface_matrices(finite_element.reference_cell())
-                                   :
-                                   0),
-                                  FullMatrix<double>(finite_element.dofs_per_cell,
-                                                     finite_element.dofs_per_cell)),
-          local_matrices_ext_int ((field_is_discontinuous
-                                   ?
-                                   Assemblers::n_interface_matrices(finite_element.reference_cell())
-                                   :
-                                   0),
-                                  FullMatrix<double>(finite_element.dofs_per_cell,
-                                                     finite_element.dofs_per_cell)),
-          local_matrices_ext_ext ((field_is_discontinuous
-                                   ?
-                                   Assemblers::n_interface_matrices(finite_element.reference_cell())
-                                   :
-                                   0),
-                                  FullMatrix<double>(finite_element.dofs_per_cell,
-                                                     finite_element.dofs_per_cell)),
-          local_rhs (finite_element.dofs_per_cell),
-
-          assembled_matrices ((field_is_discontinuous
-                               ?
-                               Assemblers::n_interface_matrices(finite_element.reference_cell())
-                               :
-                               0), false),
-
-          local_dof_indices (finite_element.dofs_per_cell),
-          neighbor_dof_indices ((field_is_discontinuous
-                                 ?
-                                 Assemblers::n_interface_matrices(finite_element.reference_cell())
-                                 :
-                                 0),
-                                std::vector<types::global_dof_index>(finite_element.dofs_per_cell))
-        {}
-
-      }
-    }
-  }
-
-
-
-  namespace Assemblers
-  {
-    unsigned int
-    n_interface_matrices (const ReferenceCell &reference_cell)
-    {
-      // The current implementation assumes that all faces are
-      // the same; so no wedges or pyramids please.
-      Assert ((reference_cell == ReferenceCells::Triangle)
-              ||
-              (reference_cell == ReferenceCells::Quadrilateral)
-              ||
-              (reference_cell == ReferenceCells::Tetrahedron)
-              ||
-              (reference_cell == ReferenceCells::Hexahedron),
-              ExcNotImplemented());
-      return (reference_cell.n_faces() *
-              reference_cell.face_reference_cell(0).n_isotropic_children());
-    }
-
-
-
-    unsigned int
-    nth_interface_matrix (const ReferenceCell &reference_cell,
-                          const unsigned int face)
-    {
-      AssertIndexRange (face, reference_cell.n_faces());
-      return (face *
-              reference_cell.face_reference_cell(0).n_isotropic_children());
-    }
-
-
-
-    unsigned int
-    nth_interface_matrix (const ReferenceCell &reference_cell,
-                          const unsigned int face,
-                          const unsigned int sub_face)
-    {
-      AssertIndexRange (face, reference_cell.n_faces());
-      AssertIndexRange (sub_face,
-                        reference_cell.face_reference_cell(0).n_isotropic_children());
-      return (face *
-              reference_cell.face_reference_cell(0).n_isotropic_children()
-              + sub_face);
-    }
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &) const
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    Interface<dim>::compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &) const
-    {
-      AssertThrow(false,
-                  ExcMessage("If this is an assembler that has to compute a residual"
-                             "then this function should be implemented. "
-                             "If this is an assembler that does not have to compute a residual, it should not be called."));
-
-      return {};
-    }
-
-
-
-    template <int dim>
-    AdvectionStabilizationInterface<dim>::~AdvectionStabilizationInterface()
-      = default;
-
-
-
-    template <int dim>
-    std::vector<double>
-    AdvectionStabilizationInterface<dim>::advection_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-
-      std::vector<double> prefactors(scratch.material_model_inputs.n_evaluation_points(), 1.0);
-
-      if (scratch.advection_field->is_temperature())
-        for (unsigned int i=0; i<prefactors.size(); ++i)
-          prefactors[i] = scratch.material_model_outputs.densities[i] * scratch.material_model_outputs.specific_heat[i];
-
-      return prefactors;
-    }
-
-
-
-    template <int dim>
-    std::vector<double>
-    AdvectionStabilizationInterface<dim>::diffusion_prefactors(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-
-      if (scratch.advection_field->is_temperature())
-        return scratch.material_model_outputs.thermal_conductivities;
-
-      return std::vector<double> (scratch.material_model_inputs.n_evaluation_points(), 0.0);
-    }
-
-
-
-    template <int dim>
-    void Manager<dim>::reset ()
-    {
-      stokes_preconditioner.clear();
-      stokes_system.clear();
-      stokes_system_on_boundary_face.clear();
-      advection_system.clear();
-      advection_system_on_boundary_face.clear();
-      advection_system_on_interior_face.clear();
-    }
-
-    template <int dim>
-    Manager<dim>::Properties::Properties ()
-      :
-      need_face_material_model_data (false),
-      need_face_finite_element_evaluation(false),
-      need_viscosity(false),
-      needed_update_flags ()
-    {}
-  }
-} // namespace aspect
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-
-#define INSTANTIATE(dim) \
-  namespace internal { \
-    namespace Assembly { \
-      namespace Scratch { \
-        template struct StokesPreconditioner<dim>; \
-        template struct StokesSystem<dim>; \
-        template struct AdvectionSystem<dim>; \
-      } \
-      namespace CopyData { \
-        template struct StokesPreconditioner<dim>; \
-        template struct StokesSystem<dim>; \
-        template struct AdvectionSystem<dim>; \
-      } \
-    } \
-  } \
-  namespace Assemblers { \
-    template class Interface<dim>; \
-    template class AdvectionStabilizationInterface<dim>; \
-    template class Manager<dim>; \
-  }
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/assemblers/newton_stokes.cc.bak b/source/simulator/assemblers/newton_stokes.cc.bak
deleted file mode 100644
index 174bab9cbc2..00000000000
--- a/source/simulator/assemblers/newton_stokes.cc.bak
+++ /dev/null
@@ -1,972 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/newton.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-#include <aspect/material_model/rheology/elasticity.h>
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    template <int dim>
-    void
-    NewtonInterface<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      if (this->get_newton_handler().parameters.newton_derivative_scaling_factor == 0)
-        return;
-
-      NewtonHandler<dim>::create_material_model_outputs(outputs);
-    }
-
-
-
-    template <int dim>
-    void
-    NewtonStokesPreconditioner<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
-      const double derivative_scaling_factor = this->get_newton_handler().parameters.newton_derivative_scaling_factor;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      const MaterialModel::MaterialAveraging::AveragingOperation
-      material_averaging = this->get_parameters().material_averaging;
-
-      // If elasticity is enabled, then we need ElasticOutputs to get the viscoelastic
-      // strain rate.
-      const MaterialModel::ElasticOutputs<dim> *elastic_out =
-        scratch.material_model_outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
-      if (this->get_parameters().enable_elasticity)
-        AssertThrow(elastic_out != nullptr,
-                    ExcMessage("Error: The Newton method requires ElasticOutputs when elasticity is enabled."));
-
-      // First loop over all dofs and find those that are in the Stokes system
-      // save the component (pressure and dim velocities) each belongs to.
-      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-        {
-          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-            {
-              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
-              ++i_stokes;
-            }
-          ++i;
-        }
-
-      const MaterialModel::MaterialModelDerivatives<dim> *derivatives
-        = scratch.material_model_outputs.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
-
-      std::vector<double> deta_deps_times_grads_phi_u(stokes_dofs_per_cell);
-      std::vector<double> eps_times_grads_phi_u(stokes_dofs_per_cell);
-
-      // Calculate the weighted average of viscosity derivatives if
-      // material averaging is applied.
-      if (derivative_scaling_factor > 0 &&
-          material_averaging != MaterialModel::MaterialAveraging::none)
-        {
-          AssertThrow(derivatives != nullptr,
-                      ExcMessage ("Error: The newton method requires derivatives from the material model."));
-
-          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  double avg = 0;
-                  for (unsigned int q = 0; q < n_q_points; ++q)
-                    avg += derivatives->viscosity_derivative_averaging_weights[q] *
-                           (derivatives->viscosity_derivative_wrt_strain_rate[q] *
-                            scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i, q));
-
-                  deta_deps_times_grads_phi_u[i_stokes] = avg;
-
-                  ++i_stokes;
-                }
-              ++i;
-            }
-        }
-
-      // Loop over all quadrature points and assemble their contributions to
-      // the preconditioner matrix
-      for (unsigned int q = 0; q < n_q_points; ++q)
-        {
-          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.grads_phi_u[i_stokes] =
-                    scratch.finite_element_values[introspection.extractors
-                                                  .velocities].symmetric_gradient(i, q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection
-                                                                          .extractors.pressure].value(i, q);
-
-#if DEBUG
-                  // This is needed to test the velocity part of the matrix for
-                  // being symmetric positive-definite.
-                  scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
-#endif
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const double eta = scratch.material_model_outputs.viscosities[q];
-          const double one_over_eta = 1. / eta;
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          // TODO: Find out why in this version of ASPECT adding the derivative to the preconditioning
-          // is way worse than the normal preconditioning
-          if (derivative_scaling_factor == 0)
-            {
-              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-                for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
-                  if (scratch.dof_component_indices[i] ==
-                      scratch.dof_component_indices[j])
-                    data.local_matrix(i, j) += (
-                                                 // top left block: for the current case with
-                                                 // derivative_scaling_factor==0 the top left block
-                                                 // of the system matrix only contains the usual
-                                                 // Stokes term. So approximate this block in the
-                                                 // same way as we do in the preconditioner when
-                                                 // we solve the regular Stokes problem, i.e.,
-                                                 // by replacing the symmetric gradient by the
-                                                 // regular gradient to make the block more sparse
-                                                 (2.0 * eta * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
-                                                 +
-                                                 // bottom right block: approximate the pressure
-                                                 // Schur complement by the pressure mass matrix.
-                                                 // if the derivative scaling factor is zero,
-                                                 // then we only use the viscosity in the top
-                                                 // left block, and so clearly the mass matrix
-                                                 // approximation in the bottom right needs to
-                                                 // only be scaled by 1/eta, without considering
-                                                 // the derivatives
-                                                 one_over_eta
-                                                 * pressure_scaling
-                                                 * pressure_scaling
-                                                 * (scratch.phi_p[i] * scratch.phi_p[j]))
-                                               * JxW;
-            }
-          else
-            {
-              const SymmetricTensor<2,dim> viscosity_derivative_wrt_strain_rate = derivatives->viscosity_derivative_wrt_strain_rate[q];
-              const SymmetricTensor<2,dim> effective_strain_rate =
-                elastic_out == nullptr ? deviator(scratch.material_model_inputs.strain_rate[q]) : elastic_out->viscoelastic_strain_rate[q];
-
-              const typename Newton::Parameters::Stabilization
-              preconditioner_stabilization = this->get_newton_handler().parameters.preconditioner_stabilization;
-
-              // use the spd factor when the stabilization is PD or SPD
-              const double alpha = (preconditioner_stabilization & Newton::Parameters::Stabilization::PD) != Newton::Parameters::Stabilization::none ?
-                                   Utilities::compute_spd_factor<dim>(eta, effective_strain_rate, viscosity_derivative_wrt_strain_rate,
-                                                                      this->get_newton_handler().parameters.SPD_safety_factor)
-                                   :
-                                   1;
-
-              // pre-compute the tensor contractions
-              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-                {
-                  eps_times_grads_phi_u[i] = effective_strain_rate * scratch.grads_phi_u[i];
-                  if (material_averaging == MaterialModel::MaterialAveraging::none)
-                    deta_deps_times_grads_phi_u[i] = viscosity_derivative_wrt_strain_rate * scratch.grads_phi_u[i];
-                }
-
-              // symmetrize when the stabilization is symmetric or SPD
-              const bool symmetrize = ((preconditioner_stabilization & Newton::Parameters::Stabilization::symmetric)
-                                       != Newton::Parameters::Stabilization::none);
-
-              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-                for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
-                  if (scratch.dof_component_indices[i] ==
-                      scratch.dof_component_indices[j])
-                    {
-                      data.local_matrix(i, j)
-                      += (
-                           // top left block: approximate J^{uu}
-                           (2.0 * eta * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
-                           +
-                           derivative_scaling_factor * alpha *
-                           ( symmetrize ?
-                             (eps_times_grads_phi_u[i] * deta_deps_times_grads_phi_u[j] +
-                              eps_times_grads_phi_u[j] * deta_deps_times_grads_phi_u[i] ) :
-                             2.0 * eps_times_grads_phi_u[i] * deta_deps_times_grads_phi_u[j] )
-                           +
-                           // bottom right block: approximate the
-                           // pressure Schur complement by the
-                           // pressure mass matrix.  strictly
-                           // speaking, we probably ought to also
-                           // consider the derivatives deta/deps
-                           // here, but we leave this as a TODO
-                           one_over_eta
-                           * pressure_scaling
-                           * pressure_scaling
-                           * (scratch.phi_p[i] * scratch.phi_p[j])
-                         )
-                         * JxW;
-                    }
-            }
-        }
-#if DEBUG
-      {
-        if (this->get_newton_handler().parameters.preconditioner_stabilization == Newton::Parameters::Stabilization::SPD)
-          {
-            // regardless of whether we do or do not add the Newton
-            // linearization terms, we ought to test whether the top-left
-            // block of the matrix is Symmetric Positive Definite (SPD).
-            //
-            // the reason why this is not entirely obvious is described in
-            // the paper that discusses the Newton implementation
-            Vector<double> tmp (stokes_dofs_per_cell);
-            for (unsigned int sample = 0; sample < 100; ++sample)
-              {
-                // fill a vector with random numbers for the Stokes DoFs
-                for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-                  if (scratch.dof_component_indices[i] < dim)
-                    tmp[i] = Utilities::generate_normal_random_number (0, 1);
-                  else
-                    tmp[i] = 0;
-
-                // then verify that the product tmp*(A*tmp) -- which by construction
-                // of the vector tmp only covers the top-left block of the matrix A
-                // -- is indeed positive (or nearly so)
-                Assert (data.local_matrix.matrix_norm_square(tmp)/(tmp*tmp)
-                        >=
-                        -1e-12*data.local_matrix.frobenius_norm(),
-                        ExcMessage ("The top left block of the local Newton-Stokes "
-                                    "matrix is not positive definite but has an "
-                                    "eigenvalue less than "
-                                    + Utilities::to_string (data.local_matrix.matrix_norm_square(tmp)/(tmp*tmp))
-                                    + " < 0. This should not happen."));
-              }
-          }
-      }
-#endif
-    }
-
-
-    template <int dim>
-    void
-    NewtonStokesPreconditioner<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      if (this->get_parameters().enable_elasticity &&
-          outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ElasticOutputs<dim>> (outputs.n_evaluation_points()));
-        }
-
-      if (this->get_newton_handler().parameters.newton_derivative_scaling_factor != 0)
-        NewtonHandler<dim>::create_material_model_outputs(outputs);
-    }
-
-
-    template <int dim>
-    void
-    NewtonStokesIncompressibleTerms<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double derivative_scaling_factor = this->get_newton_handler().parameters.newton_derivative_scaling_factor;
-
-      const MaterialModel::MaterialAveraging::AveragingOperation
-      material_averaging = this->get_parameters().material_averaging;
-
-      const bool enable_additional_stokes_rhs = this->get_parameters().enable_additional_stokes_rhs;
-
-      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim> *force = enable_additional_stokes_rhs ?
-                                                                            scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()
-                                                                            : nullptr;
-
-      // If elasticity is enabled, then we need ElasticOutputs to get the viscoelastic
-      // strain rate and the elastic force.
-      const bool enable_elasticity = this->get_parameters().enable_elasticity;
-      const MaterialModel::ElasticOutputs<dim> *elastic_out =
-        scratch.material_model_outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
-      if (enable_elasticity)
-        AssertThrow(elastic_out != nullptr,
-                    ExcMessage("Error: The Newton method requires ElasticOutputs when elasticity is enabled."));
-
-      const bool enable_prescribed_dilation = this->get_parameters().enable_prescribed_dilation;
-
-      const MaterialModel::PrescribedPlasticDilation<dim>
-      *prescribed_dilation = enable_prescribed_dilation ?
-                             scratch.material_model_outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>()
-                             : nullptr;
-
-      const bool material_model_is_compressible = (this->get_material_model().is_compressible());
-
-      const MaterialModel::MaterialModelDerivatives<dim> *derivatives
-        = scratch.material_model_outputs.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
-
-
-
-      std::vector<double> deta_deps_times_grads_phi_u(stokes_dofs_per_cell);
-      std::vector<double> deta_dp_times_phi_p(stokes_dofs_per_cell);
-      std::vector<double> eps_times_grads_phi_u(stokes_dofs_per_cell);
-
-      // Calculate the weighted average of viscosity derivatives if
-      // material averaging is applied.
-      if (derivative_scaling_factor > 0 &&
-          material_averaging != MaterialModel::MaterialAveraging::none)
-        {
-          // This one is only available in debug mode, because normally
-          // the AssertThrow in the preconditioner should already have
-          // caught the problem.
-          Assert(derivatives != nullptr,
-                 ExcMessage ("Error: The Newton method requires the material model to "
-                             "compute derivatives."));
-
-          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  double avg_wrt_eps = 0, avg_wrt_p = 0;
-                  for (unsigned int q = 0; q < n_q_points; ++q)
-                    {
-                      avg_wrt_eps += derivatives->viscosity_derivative_averaging_weights[q] *
-                                     (derivatives->viscosity_derivative_wrt_strain_rate[q] *
-                                      scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i, q));
-                      avg_wrt_p   += derivatives->viscosity_derivative_averaging_weights[q] *
-                                     (derivatives->viscosity_derivative_wrt_pressure[q] *
-                                      scratch.finite_element_values[introspection.extractors.pressure].value(i, q));
-                    }
-
-                  deta_deps_times_grads_phi_u[i_stokes] = avg_wrt_eps;
-                  deta_dp_times_phi_p[i_stokes] = avg_wrt_p;
-
-                  ++i_stokes;
-                }
-              ++i;
-            }
-        }
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-
-#if DEBUG
-                  // This is needed to test the velocity part of the matrix for
-                  // being symmetric positive-definite.
-                  scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
-#endif
-
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          // Viscosity scalar
-          const double eta = scratch.material_model_outputs.viscosities[q];
-          const double pressure = scratch.material_model_inputs.pressure[q];
-          const double velocity_divergence = scratch.velocity_divergence[q];
-
-          const SymmetricTensor<2,dim> effective_strain_rate =
-            elastic_out == nullptr ? deviator(scratch.material_model_inputs.strain_rate[q]) : elastic_out->viscoelastic_strain_rate[q];
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-
-          const double density = scratch.material_model_outputs.densities[q];
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-          const double pressure_scaling = this->get_pressure_scaling();
-
-          // first assemble the rhs
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i) -= (eta * 2.0 * (scratch.grads_phi_u[i] *
-                                                 scratch.material_model_inputs.strain_rate[q])
-                                    - (scratch.div_phi_u[i] * pressure)
-                                    - (pressure_scaling * scratch.phi_p[i] * velocity_divergence)
-                                    -(density * gravity * scratch.phi_u[i]))
-                                   * JxW;
-
-              if (enable_elasticity)
-                data.local_rhs(i) += ( deviator(elastic_out->elastic_force[q])
-                                       * scratch.grads_phi_u[i]
-                                     ) * JxW;
-
-              if (enable_additional_stokes_rhs)
-                data.local_rhs(i) += (force->rhs_u[q] * scratch.phi_u[i]
-                                      + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i])
-                                     * JxW;
-
-              if (enable_prescribed_dilation)
-                data.local_rhs(i) += (
-                                       // RHS of - (div u,q) = - (R,q)
-                                       - pressure_scaling
-                                       * prescribed_dilation->dilation[q]
-                                       * scratch.phi_p[i]
-                                     ) * JxW;
-
-              // Only assemble this term if we are running incompressible, otherwise this term
-              // is already included on the LHS of the equation.
-              if (enable_prescribed_dilation && !material_model_is_compressible)
-                data.local_rhs(i) += (
-                                       // RHS of momentum eqn: - \int 2/3 eta R, div v
-                                       - 2.0 / 3.0 * eta
-                                       * prescribed_dilation->dilation[q]
-                                       * scratch.div_phi_u[i]
-                                     ) * JxW;
-            }
-
-          // and then the matrix, if necessary
-          if (scratch.rebuild_newton_stokes_matrix)
-            {
-              // always compute the common terms in the Newton matrix
-              for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                  {
-                    data.local_matrix(i,j) += (
-                                                eta * 2.0 * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j])
-                                                // assemble \nabla p as -(p, div v):
-                                                - (pressure_scaling *
-                                                   (scratch.div_phi_u[i] * scratch.phi_p[j]))
-                                                // assemble the term -div(u) as -(div u, q).
-                                                // Note the negative sign to make this
-                                                // operator adjoint to the grad p term:
-                                                - (pressure_scaling *
-                                                   (scratch.phi_p[i] * scratch.div_phi_u[j])))
-                                              * JxW;
-                  }
-
-              // then also see whether we have to add terms due to the
-              // Newton linearization
-              if (derivative_scaling_factor != 0)
-                {
-                  const SymmetricTensor<2,dim> viscosity_derivative_wrt_strain_rate = derivatives->viscosity_derivative_wrt_strain_rate[q];
-                  const double viscosity_derivative_wrt_pressure = derivatives->viscosity_derivative_wrt_pressure[q];
-                  const Newton::Parameters::Stabilization velocity_block_stabilization
-                    = this->get_newton_handler().parameters.velocity_block_stabilization;
-
-                  // use the spd factor when the stabilization is PD or SPD
-                  const double alpha =  (velocity_block_stabilization & Newton::Parameters::Stabilization::PD)
-                                        != Newton::Parameters::Stabilization::none
-                                        ?
-                                        Utilities::compute_spd_factor<dim>(eta, effective_strain_rate, viscosity_derivative_wrt_strain_rate,
-                                                                           this->get_newton_handler().parameters.SPD_safety_factor)
-                                        :
-                                        1;
-
-                  // pre-compute the tensor contractions
-                  for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-                    {
-                      eps_times_grads_phi_u[i] = effective_strain_rate * scratch.grads_phi_u[i];
-                      if (material_averaging == MaterialModel::MaterialAveraging::none)
-                        {
-                          deta_deps_times_grads_phi_u[i] = viscosity_derivative_wrt_strain_rate * scratch.grads_phi_u[i];
-                          deta_dp_times_phi_p[i]         = viscosity_derivative_wrt_pressure * scratch.phi_p[i];
-                        }
-                    }
-
-                  // symmetrize when the stabilization is symmetric or SPD
-                  const bool symmetrize = ((velocity_block_stabilization & Newton::Parameters::Stabilization::symmetric)
-                                           != Newton::Parameters::Stabilization::none);
-
-                  for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-                    {
-                      for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                        {
-                          data.local_matrix(i,j) += ( alpha *
-                                                      ( symmetrize ?
-                                                        ( eps_times_grads_phi_u[i] * deta_deps_times_grads_phi_u[j] +
-                                                          eps_times_grads_phi_u[j] * deta_deps_times_grads_phi_u[i] ) :
-                                                        2.0 * eps_times_grads_phi_u[i] * deta_deps_times_grads_phi_u[j]
-                                                      )
-                                                      + pressure_scaling * 2.0 * eps_times_grads_phi_u[i] * deta_dp_times_phi_p[j]
-                                                    )
-                                                    * derivative_scaling_factor
-                                                    * JxW;
-
-                          Assert(dealii::numbers::is_finite(data.local_matrix(i,j)),
-                                 ExcMessage ("Error: Assembly matrix is not finite." +
-                                             Utilities::to_string(data.local_matrix(i,j)) +
-                                             " = " + Utilities::to_string(eta)));
-                        }
-                    }
-                }
-            }
-        }
-
-#if DEBUG
-      if (scratch.rebuild_newton_stokes_matrix)
-        {
-          if (this->get_newton_handler().parameters.velocity_block_stabilization
-              == Newton::Parameters::Stabilization::SPD)
-            {
-              // regardless of whether we do or do not add the Newton
-              // linearization terms, we ought to test whether the top-left
-              // block of the matrix is Symmetric Positive Definite (SPD).
-              //
-              // the reason why this is not entirely obvious is described in
-              // the paper that discusses the Newton implementation
-              Vector<double> tmp (stokes_dofs_per_cell);
-              for (unsigned int sample = 0; sample < 100; ++sample)
-                {
-                  // fill a vector with random numbers for the Stokes DoFs
-                  for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-                    if (scratch.dof_component_indices[i] < dim)
-                      tmp[i] = Utilities::generate_normal_random_number (0, 1);
-                    else
-                      tmp[i] = 0;
-
-                  // then verify that the product tmp*(A*tmp) -- which by construction
-                  // of the vector tmp only covers the top-left block of the matrix A
-                  // -- is indeed positive (or nearly so)
-                  Assert (data.local_matrix.matrix_norm_square(tmp)/(tmp*tmp)
-                          >=
-                          -1e-12*data.local_matrix.frobenius_norm(),
-                          ExcMessage ("The top left block of the local Newton-Stokes "
-                                      "matrix is not positive definite but has an "
-                                      "eigenvalue less than "
-                                      + Utilities::to_string (data.local_matrix.matrix_norm_square(tmp)/(tmp*tmp))
-                                      + " < 0. This should not happen."));
-                }
-            }
-        }
-#endif
-    }
-
-    template <int dim>
-    void
-    NewtonStokesIncompressibleTerms<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      const unsigned int n_points = outputs.n_evaluation_points();
-
-      if (this->get_parameters().enable_additional_stokes_rhs
-          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>> (n_points));
-        }
-
-      Assert(!this->get_parameters().enable_additional_stokes_rhs
-             ||
-             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
-             == n_points, ExcInternalError());
-
-      if ((this->get_parameters().enable_elasticity) &&
-          outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ElasticOutputs<dim>> (n_points));
-        }
-
-      Assert(!this->get_parameters().enable_elasticity
-             ||
-             outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>()->elastic_force.size()
-             == n_points, ExcInternalError());
-
-      // prescribed dilation:
-      if (this->get_parameters().enable_prescribed_dilation
-          && outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedPlasticDilation<dim>> (n_points));
-        }
-
-      Assert(!this->get_parameters().enable_prescribed_dilation
-             ||
-             outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>()->dilation.size()
-             == n_points, ExcInternalError());
-
-      if (this->get_newton_handler().parameters.newton_derivative_scaling_factor != 0)
-        NewtonHandler<dim>::create_material_model_outputs(outputs);
-    }
-
-
-    template <int dim>
-    void
-    NewtonStokesCompressibleStrainRateViscosityTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      const double derivative_scaling_factor = this->get_newton_handler().parameters.newton_derivative_scaling_factor;
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          // Viscosity scalar
-          const double two_thirds = 2.0 / 3.0;
-          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * two_thirds;
-          const double velocity_divergence = scratch.velocity_divergence[q];
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i) -= (- eta_two_thirds * (scratch.div_phi_u[i]*velocity_divergence)) * JxW;
-            }
-
-          if (scratch.rebuild_stokes_matrix)
-            {
-              if (derivative_scaling_factor == 0)
-                {
-                  if (scratch.rebuild_newton_stokes_matrix)
-                    for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-                      for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                        {
-                          data.local_matrix(i,j) += (- eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])) * JxW;
-                        }
-                }
-              else
-                {
-                  const MaterialModel::MaterialModelDerivatives<dim> *derivatives = scratch.material_model_outputs.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
-
-                  // This one is only available in debug mode, because normally
-                  // the AssertThrow in the preconditioner should already have
-                  // caught the problem.
-                  Assert(derivatives != nullptr, ExcMessage ("Error: The newton method requires the derivatives"));
-
-                  const SymmetricTensor<2,dim> viscosity_derivative_wrt_strain_rate = derivatives->viscosity_derivative_wrt_strain_rate[q];
-                  const double viscosity_derivative_wrt_pressure = derivatives->viscosity_derivative_wrt_pressure[q];
-
-                  for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-                    for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                      {
-                        data.local_matrix(i,j) += (-eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
-                                                   - derivative_scaling_factor * two_thirds * scratch.div_phi_u[i] * ( (viscosity_derivative_wrt_strain_rate * scratch.grads_phi_u[j]) * velocity_divergence)
-                                                   - derivative_scaling_factor * two_thirds * (scratch.div_phi_u[i] * viscosity_derivative_wrt_pressure * scratch.phi_p[j]) * velocity_divergence
-                                                  )
-                                                  * JxW;
-                      }
-                }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    NewtonStokesReferenceDensityCompressibilityTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      // assemble RHS of:
-      //  - div u = 1/rho * drho/dz g/||g||* u
-      Assert(this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::reference_density_profile,
-             ExcInternalError());
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-          const double drho_dz_u = scratch.reference_densities_depth_derivative[q]
-                                   * (gravity * scratch.velocity_values[q]) / gravity.norm();
-          const double one_over_rho = 1.0/scratch.reference_densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            data.local_rhs(i) += (pressure_scaling *
-                                  one_over_rho * drho_dz_u * scratch.phi_p[i])
-                                 * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    NewtonStokesImplicitReferenceDensityCompressibilityTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      // assemble compressibility term of:
-      //  - div u - 1/rho * drho/dz g/||g||* u = 0
-      Assert(this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile,
-             ExcInternalError());
-
-      if (!scratch.rebuild_stokes_matrix)
-        return;
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i,q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-          const Tensor<1,dim> drho_dz = scratch.reference_densities_depth_derivative[q]
-                                        * gravity / gravity.norm();
-          const double one_over_rho = 1.0/scratch.reference_densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-              data.local_matrix(i,j) += (pressure_scaling *
-                                         one_over_rho * drho_dz * scratch.phi_u[j] * scratch.phi_p[i])
-                                        * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    NewtonStokesIsentropicCompressionTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      // assemble RHS of:
-      //  - div u = 1/rho * drho/dp rho * g * u
-      Assert(this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::isentropic_compression,
-             ExcInternalError());
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-
-          const double compressibility
-            = scratch.material_model_outputs.compressibilities[q];
-
-          const double density = scratch.material_model_outputs.densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            data.local_rhs(i) += (
-                                   // add the term that results from the compressibility. compared
-                                   // to the manual, this term seems to have the wrong sign, but this
-                                   // is because we negate the entire equation to make sure we get
-                                   // -div(u) as the adjoint operator of grad(p)
-                                   (pressure_scaling *
-                                    compressibility * density *
-                                    (scratch.velocity_values[q] * gravity) *
-                                    scratch.phi_p[i])
-                                 )
-                                 * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    NewtonStokesProjectedDensityFieldTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      // assemble RHS of:
-      // $ - \nabla \cdot \mathbf{u} = \frac{1}{\rho} \frac{\partial \rho}{\partial t} + \frac{1}{\rho} \nabla \rho \cdot \mathbf{u}$
-
-      // Compared to the manual, this term seems to have the wrong sign, but
-      // this is because we negate the entire equation to make sure we get
-      // -div(u) as the adjoint operator of grad(p)
-
-      Assert(this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::projected_density_field,
-             ExcInternalError());
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-      const unsigned int density_idx = this->introspection().find_composition_type(CompositionalFieldDescription::density);
-
-      const double time_step = this->get_timestep();
-      const double old_time_step = this->get_old_timestep();
-
-      std::vector<Tensor<1,dim>> density_gradients(n_q_points);
-      std::vector<double> density(n_q_points);
-      std::vector<double> density_old(n_q_points);
-      std::vector<double> density_old_old(n_q_points);
-
-      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_gradients (this->get_current_linearization_point(),
-          density_gradients);
-      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_current_linearization_point(),
-          density);
-      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_old_solution(),
-          density_old);
-      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_old_old_solution(),
-          density_old_old);
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          double drho_dt;
-
-          if (this->get_timestep_number() > 1)
-            drho_dt = (1.0/time_step) *
-                      (density[q] *
-                       (2*time_step + old_time_step) / (time_step + old_time_step)
-                       -
-                       density_old[q] *
-                       (1 + time_step/old_time_step)
-                       +
-                       density_old_old[q] *
-                       (time_step * time_step) / (old_time_step * (time_step + old_time_step)));
-          else if (this->get_timestep_number() == 1)
-            drho_dt =
-              (density[q] - density_old[q]) / time_step;
-          else
-            drho_dt = 0.0;
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            data.local_rhs(i) += (
-                                   (pressure_scaling *
-                                    (1.0 / density[q]) *
-                                    (density_gradients[q] *
-                                     scratch.velocity_values[q]) *
-                                    scratch.phi_p[i])
-                                   + pressure_scaling * (1.0 / density[q]) * drho_dt * scratch.phi_p[i]
-                                 )
-                                 * JxW;
-        }
-    }
-  }
-} // namespace aspect
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace Assemblers
-  {
-#define INSTANTIATE(dim) \
-  template class NewtonInterface<dim>; \
-  template class NewtonStokesPreconditioner<dim>; \
-  template class NewtonStokesIncompressibleTerms<dim>; \
-  template class NewtonStokesCompressibleStrainRateViscosityTerm<dim>; \
-  template class NewtonStokesReferenceDensityCompressibilityTerm<dim>; \
-  template class NewtonStokesImplicitReferenceDensityCompressibilityTerm<dim>; \
-  template class NewtonStokesIsentropicCompressionTerm<dim>; \
-  template class NewtonStokesProjectedDensityFieldTerm<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/simulator/assemblers/stokes.cc.bak b/source/simulator/assemblers/stokes.cc.bak
deleted file mode 100644
index 164a7a7913e..00000000000
--- a/source/simulator/assemblers/stokes.cc.bak
+++ /dev/null
@@ -1,994 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator/assemblers/stokes.h>
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    template <int dim>
-    void
-    StokesPreconditioner<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      // First loop over all dofs and find those that are in the Stokes system
-      // save the component (pressure and dim velocities) each belongs to.
-      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-        {
-          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-            {
-              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
-              ++i_stokes;
-            }
-          ++i;
-        }
-
-      // When using the Q1-Q1 equal order element, we need to compute the
-      // projection of the Q1 pressure shape functions onto the constants
-      // and use this projection in the computation of matrix terms.
-      // Do this here by computing the integral of the shape functions
-      // over the cell and then dividing by the area of the cell.
-      std::vector<double> average_pressure_shape_function (this->get_parameters().use_equal_order_interpolation_for_stokes
-                                                           ?
-                                                           stokes_dofs_per_cell
-                                                           :
-                                                           0,
-                                                           numbers::signaling_nan<double>());
-      if (this->get_parameters().use_equal_order_interpolation_for_stokes)
-        {
-          // Check that we are really only using a Q1-Q1 element and
-          // not a Q2-Q2 element. This is because in the latter case, the
-          // projection isn't just on the piecewise constants, but onto
-          // the piecewise (bi,tri)linears, and this is going to be a bit
-          // more involved than just computing a single number per shape
-          // function.
-          Assert (this->get_parameters().stokes_velocity_degree==1,
-                  ExcNotImplemented());
-
-          double area       = 0;
-          for (unsigned int q=0; q<n_q_points; ++q)
-            area += scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  double int_over_p = 0;
-
-                  for (unsigned int q=0; q<n_q_points; ++q)
-                    {
-                      int_over_p += scratch.finite_element_values[introspection.extractors.pressure].value(i,q)
-                                    *
-                                    scratch.finite_element_values.JxW(q);
-                    }
-
-                  average_pressure_shape_function[i_stokes] = int_over_p/area;
-                  ++i_stokes;
-                }
-              ++i;
-            }
-        }
-
-      // Loop over all quadrature points and assemble their contributions to
-      // the preconditioner matrix
-      for (unsigned int q = 0; q < n_q_points; ++q)
-        {
-          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  if (this->get_parameters().use_full_A_block_preconditioner == false)
-                    scratch.grads_phi_u[i_stokes] =
-                      scratch.finite_element_values[introspection.extractors
-                                                    .velocities].symmetric_gradient(i, q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection
-                                                                          .extractors.pressure].value(i, q);
-                  if (this->get_parameters().use_bfbt == true)
-                    {
-                      scratch.grad_phi_p[i_stokes]=scratch.finite_element_values[introspection.extractors.pressure].gradient(i,q);
-                      scratch.phi_u[i_stokes]=scratch.finite_element_values[introspection.extractors.velocities].value(i,q);
-                    }
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const double eta = scratch.material_model_outputs.viscosities[q];
-          const double one_over_eta = 1. / eta;
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          if (this->get_parameters().use_full_A_block_preconditioner == false)
-            {
-              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-                for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
-                  if (scratch.dof_component_indices[i] ==
-                      scratch.dof_component_indices[j])
-                    {
-                      data.local_matrix(i, j) += ((2.0 * eta * (scratch.grads_phi_u[i]
-                                                                * scratch.grads_phi_u[j]))
-                                                 )
-                                                 * JxW;
-                    }
-
-
-            }
-          if (this->get_parameters().use_bfbt == true)
-            {
-              const double sqrt_eta = sqrt(eta);
-              const unsigned int pressure_component_index = this->introspection().component_indices.pressure;
-
-              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-                {
-                  for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
-                    {
-
-
-                      // i and j are not pressures
-                      if (scratch.dof_component_indices[i] != pressure_component_index && scratch.dof_component_indices[j] != pressure_component_index)
-                        data.local_inverse_lumped_mass_matrix[i] += sqrt_eta*scalar_product(scratch.phi_u[i],scratch.phi_u[j])*JxW;
-
-
-                      // i and j are pressures
-                      if (scratch.dof_component_indices[i] == pressure_component_index && scratch.dof_component_indices[j] == pressure_component_index)
-                        data.local_matrix(i, j) += (
-                                                     1.0/sqrt_eta * pressure_scaling
-                                                     * pressure_scaling
-                                                     * (scratch.grad_phi_p[i]
-                                                        * scratch.grad_phi_p[j] + 1e-6*scratch.phi_p[i]*scratch.phi_p[j] ))
-                                                   * JxW;
-                    }
-                }
-            }
-          else
-            {
-              for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-                for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
-                  if (scratch.dof_component_indices[i] ==
-                      scratch.dof_component_indices[j])
-                    {
-                      data.local_matrix(i, j) += (
-                                                   one_over_eta * pressure_scaling
-                                                   * pressure_scaling
-                                                   * (scratch.phi_p[i]
-                                                      * scratch.phi_p[j]))
-                                                 * JxW;
-                    }
-            }
-
-          // If we are using the equal order Q1-Q1 element, then we also need
-          // to add the stabilization term to the (P,P) block of the matrix.
-          // Note the change in sign from the one in the assembly of the
-          // system matrix, which is due to the fact that the Schur complement
-          // of the matrix
-          //    [ A   B ]
-          //    [ B^T C ]
-          // is actually
-          //    S  =  B^T A^{-1} B - C
-          // with the minus sign in front of C. Because C is defined in the
-          // method of Dohrmann and Bochev as a *negative* definite operator,
-          // we here need to add the *positive* operator.
-          if (this->get_parameters().use_equal_order_interpolation_for_stokes)
-            {
-              for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                  {
-                    data.local_matrix(i,j) += ( one_over_eta * pressure_scaling * pressure_scaling *
-                                                (scratch.phi_p[i] - average_pressure_shape_function[i]) *
-                                                (scratch.phi_p[j] - average_pressure_shape_function[j]))
-                                              * JxW;
-                  }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesCompressiblePreconditioner<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      Assert (this->get_parameters().use_equal_order_interpolation_for_stokes == false,
-              ExcNotImplemented());
-
-      Assert (this->get_parameters().use_full_A_block_preconditioner == false,
-              ExcMessage("This assembler should only be called if the simplified A block "
-                         "preconditioner is used."));
-
-      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
-
-      // First loop over all dofs and find those that are in the Stokes system
-      // save the component (pressure and dim velocities) each belongs to.
-      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-        {
-          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-            {
-              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
-              ++i_stokes;
-            }
-          ++i;
-        }
-
-      // Loop over all quadrature points and assemble their contributions to
-      // the preconditioner matrix
-      for (unsigned int q = 0; q < n_q_points; ++q)
-        {
-          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0;
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-            for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
-              if (scratch.dof_component_indices[i] ==
-                  scratch.dof_component_indices[j])
-                data.local_matrix(i, j) += (- eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
-                                           )
-                                           * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesIncompressibleTerms<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
-      *force = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
-
-      const MaterialModel::ElasticOutputs<dim>
-      *elastic_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
-
-      const MaterialModel::PrescribedPlasticDilation<dim>
-      *prescribed_dilation =
-        (this->get_parameters().enable_prescribed_dilation)
-        ? scratch.material_model_outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>()
-        : nullptr;
-
-      const bool material_model_is_compressible = (this->get_material_model().is_compressible());
-
-      // When using the Q1-Q1 equal order element, we need to compute the
-      // projection of the Q1 pressure shape functions onto the constants
-      // and use this projection in the computation of matrix terms.
-      // Do this here by computing the integral of the shape functions
-      // over the cell and then dividing by the area of the cell.
-      std::vector<double> average_pressure_shape_function (this->get_parameters().use_equal_order_interpolation_for_stokes
-                                                           ?
-                                                           stokes_dofs_per_cell
-                                                           :
-                                                           0,
-                                                           numbers::signaling_nan<double>());
-      if (this->get_parameters().use_equal_order_interpolation_for_stokes)
-        {
-          // Check that we are really only using a Q1-Q1 element and
-          // not a Q2-Q2 element. This is because in the latter case, the
-          // projection isn't just on the piecewise constants, but onto
-          // the piecewise (bi,tri)linears, and this is going to be a bit
-          // more involved than just computing a single number per shape
-          // function.
-          Assert (this->get_parameters().stokes_velocity_degree==1,
-                  ExcNotImplemented());
-
-          double area       = 0;
-          for (unsigned int q=0; q<n_q_points; ++q)
-            area += scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  double int_over_p = 0;
-
-                  for (unsigned int q=0; q<n_q_points; ++q)
-                    {
-                      int_over_p += scratch.finite_element_values[introspection.extractors.pressure].value(i,q)
-                                    *
-                                    scratch.finite_element_values.JxW(q);
-                    }
-
-                  average_pressure_shape_function[i_stokes] = int_over_p/area;
-                  ++i_stokes;
-                }
-              ++i;
-            }
-        }
-
-      // Next, do the integration of matrix and right hand side terms.
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  if (scratch.rebuild_stokes_matrix)
-                    {
-                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-                    }
-                  else if (this->get_parameters().enable_elasticity)
-                    {
-                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                    }
-                  else if (prescribed_dilation && !material_model_is_compressible)
-                    {
-                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-                    }
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-
-          // Viscosity scalar
-          const double eta = ((scratch.rebuild_stokes_matrix || prescribed_dilation)
-                              ?
-                              scratch.material_model_outputs.viscosities[q]
-                              :
-                              numbers::signaling_nan<double>());
-          const double one_over_eta = (scratch.rebuild_stokes_matrix
-                                       &&
-                                       this->get_parameters().use_equal_order_interpolation_for_stokes
-                                       ?
-                                       1./eta
-                                       :
-                                       numbers::signaling_nan<double>());
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-
-          const double density = scratch.material_model_outputs.densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i) += (density * gravity * scratch.phi_u[i])
-                                   * JxW;
-
-              if (force != nullptr && this->get_parameters().enable_additional_stokes_rhs)
-                data.local_rhs(i) += (force->rhs_u[q] * scratch.phi_u[i]
-                                      + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i])
-                                     * JxW;
-
-              if (elastic_outputs != nullptr && this->get_parameters().enable_elasticity)
-                data.local_rhs(i) += (scalar_product(elastic_outputs->elastic_force[q],Tensor<2,dim>(scratch.grads_phi_u[i])))
-                                     * JxW;
-
-              if (prescribed_dilation != nullptr)
-                data.local_rhs(i) += (
-                                       // RHS of - (div u,q) = - (R,q)
-                                       - pressure_scaling
-                                       * prescribed_dilation->dilation[q]
-                                       * scratch.phi_p[i]
-                                     ) * JxW;
-
-              // Only assemble this term if we are running incompressible, otherwise this term
-              // is already included on the LHS of the equation.
-              if (prescribed_dilation != nullptr && !material_model_is_compressible)
-                data.local_rhs(i) += (
-                                       // RHS of momentum eqn: - \int 2/3 eta R, div v
-                                       - 2.0 / 3.0 * eta
-                                       * prescribed_dilation->dilation[q]
-                                       * scratch.div_phi_u[i]
-                                     ) * JxW;
-
-              if (scratch.rebuild_stokes_matrix)
-                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                  {
-                    data.local_matrix(i,j) += ( (eta * 2.0 * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
-                                                // assemble \nabla p as -(p, div v):
-                                                - (pressure_scaling *
-                                                   scratch.div_phi_u[i] * scratch.phi_p[j])
-                                                // assemble the term -div(u) as -(div u, q).
-                                                // Note the negative sign to make this
-                                                // operator adjoint to the grad p term:
-                                                - (pressure_scaling *
-                                                   scratch.phi_p[i] * scratch.div_phi_u[j]))
-                                              * JxW;
-                  }
-            }
-
-          // If we are using the equal order Q1-Q1 element, then we also need
-          // to put the stabilization term into the (P,P) block of the matrix:
-          if (scratch.rebuild_stokes_matrix
-              &&
-              this->get_parameters().use_equal_order_interpolation_for_stokes)
-            {
-              for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                  {
-                    data.local_matrix(i,j) += ( - (one_over_eta * pressure_scaling * pressure_scaling *
-                                                   (scratch.phi_p[i] - average_pressure_shape_function[i]) *
-                                                   (scratch.phi_p[j] - average_pressure_shape_function[j])))
-                                              * JxW;
-                  }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesIncompressibleTerms<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      const unsigned int n_points = outputs.n_evaluation_points();
-
-      // Stokes RHS:
-      if (this->get_parameters().enable_additional_stokes_rhs
-          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>> (n_points));
-        }
-
-      Assert(!this->get_parameters().enable_additional_stokes_rhs
-             ||
-             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
-             == n_points, ExcInternalError());
-
-      // prescribed dilation:
-      if (this->get_parameters().enable_prescribed_dilation
-          && outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedPlasticDilation<dim>> (n_points));
-        }
-
-      Assert(!this->get_parameters().enable_prescribed_dilation
-             ||
-             outputs.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>()->dilation.size()
-             == n_points, ExcInternalError());
-
-      // Elasticity:
-      if ((this->get_parameters().enable_elasticity) &&
-          outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::ElasticOutputs<dim>> (n_points));
-        }
-
-      Assert(!this->get_parameters().enable_elasticity
-             ||
-             outputs.template get_additional_output<MaterialModel::ElasticOutputs<dim>>()->elastic_force.size()
-             == n_points, ExcInternalError());
-    }
-
-
-
-    template <int dim>
-    void
-    StokesCompressibleStrainRateViscosityTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      if (!scratch.rebuild_stokes_matrix)
-        return;
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          // Viscosity scalar
-          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0;
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-              {
-                data.local_matrix(i,j) += (- (eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
-                                             ))
-                                          * JxW;
-              }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesReferenceDensityCompressibilityTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      // assemble RHS of:
-      //  - div u = 1/rho * drho/dz g/||g||* u
-      Assert(this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::reference_density_profile,
-             ExcInternalError());
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-          const double drho_dz_u = scratch.reference_densities_depth_derivative[q]
-                                   * (gravity * scratch.velocity_values[q]) / gravity.norm();
-          const double one_over_rho = 1.0/scratch.reference_densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            data.local_rhs(i) += (pressure_scaling *
-                                  one_over_rho * drho_dz_u * scratch.phi_p[i])
-                                 * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesImplicitReferenceDensityCompressibilityTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      // assemble compressibility term of:
-      //  - div u - 1/rho * drho/dz g/||g||* u = 0
-      Assert(this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile,
-             ExcInternalError());
-
-      if (!scratch.rebuild_stokes_matrix)
-        return;
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i,q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-          const Tensor<1,dim> drho_dz = scratch.reference_densities_depth_derivative[q]
-                                        * gravity / gravity.norm();
-          const double one_over_rho = 1.0/scratch.reference_densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-              data.local_matrix(i,j) += -(pressure_scaling *
-                                          one_over_rho * drho_dz * scratch.phi_u[j] * scratch.phi_p[i])
-                                        * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesIsentropicCompressionTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      // assemble RHS of:
-      //  - div \mathbf{u} = \frac{1}{\rho} \frac{\partial rho}{\partial p} \rho \mathbf{g} \cdot \mathbf{u}
-
-      // Compared to the manual, this term seems to have the wrong sign, but
-      // this is because we negate the entire equation to make sure we get
-      // -div(u) as the adjoint operator of grad(p)
-
-      Assert(this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::isentropic_compression,
-             ExcInternalError());
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-
-          const double compressibility
-            = scratch.material_model_outputs.compressibilities[q];
-
-          const double density = scratch.material_model_outputs.densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            data.local_rhs(i) += (
-                                   (pressure_scaling *
-                                    compressibility * density *
-                                    (scratch.velocity_values[q] * gravity) *
-                                    scratch.phi_p[i])
-                                 )
-                                 * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesProjectedDensityFieldTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      // assemble RHS of:
-      // $ - \nabla \cdot \mathbf{u} = \frac{1}{\rho} \frac{\partial \rho}{\partial t} + \frac{1}{\rho} \nabla \rho \cdot \mathbf{u}$
-
-      // Compared to the manual, this term seems to have the wrong sign, but
-      // this is because we negate the entire equation to make sure we get
-      // -div(u) as the adjoint operator of grad(p)
-
-      Assert(this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::projected_density_field,
-             ExcInternalError());
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-      const unsigned int density_idx = this->introspection().find_composition_type(CompositionalFieldDescription::density);
-
-      const double time_step = this->get_timestep();
-      const double old_time_step = this->get_old_timestep();
-
-      std::vector<Tensor<1,dim>> density_gradients(n_q_points);
-      std::vector<double> density(n_q_points);
-      std::vector<double> density_old(n_q_points);
-      std::vector<double> density_old_old(n_q_points);
-
-      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_gradients (this->get_current_linearization_point(),
-          density_gradients);
-      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_current_linearization_point(),
-          density);
-      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_old_solution(),
-          density_old);
-      scratch.finite_element_values[introspection.extractors.compositional_fields[density_idx]].get_function_values (this->get_old_old_solution(),
-          density_old_old);
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          double drho_dt;
-
-          if (this->get_timestep_number() > 1)
-            drho_dt = (1.0/time_step) *
-                      (density[q] *
-                       (2*time_step + old_time_step) / (time_step + old_time_step)
-                       -
-                       density_old[q] *
-                       (1 + time_step/old_time_step)
-                       +
-                       density_old_old[q] *
-                       (time_step * time_step) / (old_time_step * (time_step + old_time_step)));
-          else if (this->get_timestep_number() == 1)
-            drho_dt =
-              (density[q] - density_old[q]) / time_step;
-          else
-            drho_dt = 0.0;
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            data.local_rhs(i) += (
-                                   (pressure_scaling *
-                                    (1.0 / density[q]) *
-                                    (density_gradients[q] *
-                                     scratch.velocity_values[q]) *
-                                    scratch.phi_p[i])
-                                   + pressure_scaling * (1.0 / density[q]) * drho_dt * scratch.phi_p[i]
-                                 )
-                                 * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesHydrostaticCompressionTerm<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      // assemble RHS of:
-      // $ -\nabla \cdot \mathbf{u} = \left( \kappa \rho \textbf{g} - \alpha \nabla T \right) \cdot \textbf{u}$
-      //
-      // where $\frac{1}{\rho} \frac{\partial \rho}{\partial p} = \kappa$ is the compressibility,
-      // $- \frac{1}{\rho}\frac{\partial \rho}{\partial T} = \alpha$ is the thermal expansion coefficient,
-      // and both are defined in the material model.
-
-      // Compared to the manual, this term seems to have the wrong sign, but
-      // this is because we negate the entire equation to make sure we get
-      // -div(u) as the adjoint operator of grad(p)
-
-      Assert(this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::hydrostatic_compression,
-             ExcInternalError());
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-
-          const double compressibility
-            = scratch.material_model_outputs.compressibilities[q];
-
-          const double thermal_alpha
-            = scratch.material_model_outputs.thermal_expansion_coefficients[q];
-
-          const double density = scratch.material_model_outputs.densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            data.local_rhs(i) += (
-                                   (pressure_scaling *
-                                    (
-                                      // pressure part:
-                                      compressibility * density *
-                                      (scratch.velocity_values[q] * gravity)
-                                      // temperature part:
-                                      - thermal_alpha *
-                                      (scratch.velocity_values[q] * scratch.temperature_gradients[q])
-                                    ) * scratch.phi_p[i])
-                                 )
-                                 * JxW;
-
-        }
-    }
-
-
-    template <int dim>
-    void
-    StokesPressureRHSCompatibilityModification<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                                                              internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = scratch.finite_element_values.get_fe();
-
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-          {
-            if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-              {
-                scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                data.local_pressure_shape_function_integrals(i_stokes) += scratch.phi_p[i_stokes] * scratch.finite_element_values.JxW(q);
-                ++i_stokes;
-              }
-            ++i;
-          }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesBoundaryTraction<dim>::execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-                                          internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = scratch.finite_element_values.get_fe();
-
-      // see if any of the faces are traction boundaries for which
-      // we need to assemble force terms for the right hand side
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-
-      const typename DoFHandler<dim>::face_iterator face = scratch.cell->face(scratch.face_number);
-
-      if (this->get_boundary_traction_manager().get_active_boundary_traction_names().find (face->boundary_id())
-          !=
-          this->get_boundary_traction_manager().get_active_boundary_traction_names().end())
-        {
-          for (unsigned int q=0; q<scratch.face_finite_element_values.n_quadrature_points; ++q)
-            {
-              const Tensor<1,dim> traction
-                = this->get_boundary_traction_manager().
-                  boundary_traction (face->boundary_id(),
-                                     scratch.face_finite_element_values.quadrature_point(q),
-                                     scratch.face_finite_element_values.normal_vector(q));
-
-              for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-                {
-                  if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                    {
-                      data.local_rhs(i_stokes) += scratch.face_finite_element_values[introspection.extractors.velocities].value(i,q) *
-                                                  traction *
-                                                  scratch.face_finite_element_values.JxW(q);
-                      ++i_stokes;
-                    }
-                  ++i;
-                }
-            }
-        }
-    }
-  }
-} // namespace aspect
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace Assemblers
-  {
-#define INSTANTIATE(dim) \
-  template class StokesPreconditioner<dim>; \
-  template class StokesCompressiblePreconditioner<dim>; \
-  template class StokesIncompressibleTerms<dim>; \
-  template class StokesCompressibleStrainRateViscosityTerm<dim>; \
-  template class StokesReferenceDensityCompressibilityTerm<dim>; \
-  template class StokesImplicitReferenceDensityCompressibilityTerm<dim>; \
-  template class StokesIsentropicCompressionTerm<dim>; \
-  template class StokesHydrostaticCompressionTerm<dim>; \
-  template class StokesProjectedDensityFieldTerm<dim>; \
-  template class StokesPressureRHSCompatibilityModification<dim>; \
-  template class StokesBoundaryTraction<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/simulator/assembly.cc.bak b/source/simulator/assembly.cc.bak
deleted file mode 100644
index 5142237c083..00000000000
--- a/source/simulator/assembly.cc.bak
+++ /dev/null
@@ -1,1301 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-#include <aspect/compat.h>
-#include <aspect/simulator_access.h>
-#include <aspect/citation_info.h>
-
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/melt.h>
-#include <aspect/newton.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/simulator/assemblers/stokes.h>
-#include <aspect/simulator/assemblers/advection.h>
-
-#include <aspect/stokes_matrix_free.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/work_stream.h>
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/lac/full_matrix.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/filtered_iterator.h>
-#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/fe/fe_values.h>
-
-
-
-namespace aspect
-{
-  namespace
-  {
-    // This function initializes the simulator access for all assemblers
-    // inside of the assemblers parameter. This is just a shortcut to save some
-    // lines in set_assemblers(), where this operation appears multiple times.
-    template <int dim, class AssemblerType>
-    void
-    initialize_simulator(const Simulator<dim> &simulator,
-                         std::vector<std::unique_ptr<AssemblerType>> &assemblers)
-    {
-      for (unsigned int i=0; i<assemblers.size(); ++i)
-        if (SimulatorAccess<dim> *p = dynamic_cast<SimulatorAccess<dim>*>(assemblers[i].get()))
-          p->initialize_simulator(simulator);
-    }
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  set_stokes_assemblers()
-  {
-    assemblers->stokes_preconditioner.push_back(std::make_unique<aspect::Assemblers::StokesPreconditioner<dim>>());
-    assemblers->stokes_system.push_back(std::make_unique<aspect::Assemblers::StokesIncompressibleTerms<dim>>());
-
-    if (material_model->is_compressible())
-      {
-        // The compressible part of the preconditioner is only necessary if we use the simplified A block
-        if (parameters.use_full_A_block_preconditioner == false)
-          assemblers->stokes_preconditioner.push_back(
-            std::make_unique<aspect::Assemblers::StokesCompressiblePreconditioner<dim>>());
-
-        assemblers->stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::StokesCompressibleStrainRateViscosityTerm<dim>>());
-      }
-
-    if (parameters.formulation_mass_conservation ==
-        Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile)
-      {
-        assemblers->stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::StokesImplicitReferenceDensityCompressibilityTerm<dim>>());
-      }
-    else if (parameters.formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::reference_density_profile)
-      {
-        assemblers->stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::StokesReferenceDensityCompressibilityTerm<dim>>());
-      }
-    else if (parameters.formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::incompressible)
-      {
-        // do nothing, because we assembled div u =0 above already
-      }
-    else if (parameters.formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::isentropic_compression)
-      {
-        assemblers->stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::StokesIsentropicCompressionTerm<dim>>());
-      }
-    else if (parameters.formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::hydrostatic_compression)
-      {
-        assemblers->stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::StokesHydrostaticCompressionTerm<dim>>());
-      }
-    else if (parameters.formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::projected_density_field)
-      {
-        CitationInfo::add("pda");
-        assemblers->stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::StokesProjectedDensityFieldTerm<dim>>());
-      }
-    else
-      AssertThrow(false,
-                  ExcMessage("Unknown mass conservation equation approximation. There is no assembler"
-                             " defined that handles this formulation."));
-
-    // add the terms for traction boundary conditions
-    if (!boundary_traction_manager.get_active_boundary_traction_names().empty())
-      {
-        assemblers->stokes_system_on_boundary_face.push_back(
-          std::make_unique<aspect::Assemblers::StokesBoundaryTraction<dim>>());
-      }
-
-    // add the terms necessary to normalize the pressure
-    if (do_pressure_rhs_compatibility_modification)
-      assemblers->stokes_system.push_back(
-        std::make_unique<aspect::Assemblers::StokesPressureRHSCompatibilityModification<dim>>());
-
-  }
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  set_advection_assemblers()
-  {
-    // Loop over all advection fields and add the assemblers that each field uses. i=0 is the temperature.
-    for (unsigned int i=0; i<1+introspection.n_compositional_fields; ++i)
-      {
-        if ((i==0 && parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::fem_field)
-            ||
-            (i>0 && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_field))
-          assemblers->advection_system[i].push_back(
-            std::make_unique<aspect::Assemblers::AdvectionSystem<dim>>());
-
-        // Only add the diffusion assembler if advection field i uses the prescribed_field_with_diffusion method.
-        if ((i==0 && parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion)
-            ||
-            (i>0 && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion))
-          assemblers->advection_system[i].push_back(
-            std::make_unique<aspect::Assemblers::DiffusionSystem<dim>>());
-
-        // Add the darcy assemblers if we have fields that use this method
-        if (i>0 && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_darcy_field)
-          assemblers->advection_system[i].push_back(
-            std::make_unique<aspect::Assemblers::DarcySystem<dim>>());
-
-        if ((i==0 && parameters.use_discontinuous_temperature_discretization
-             && parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::fem_field)
-            ||
-            (i>0 && parameters.use_discontinuous_composition_discretization[i-1]
-             && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_field))
-          {
-            assemblers->advection_system_on_boundary_face[i].push_back(
-              std::make_unique<aspect::Assemblers::AdvectionSystemBoundaryFace<dim>>());
-
-            assemblers->advection_system_on_interior_face[i].push_back(
-              std::make_unique<aspect::Assemblers::AdvectionSystemInteriorFace<dim>>());
-          }
-
-        if (i==0 && parameters.fixed_heat_flux_boundary_indicators.size() != 0)
-          {
-            assemblers->advection_system_on_boundary_face[i].push_back(
-              std::make_unique<aspect::Assemblers::AdvectionSystemBoundaryHeatFlux<dim>>());
-          }
-
-        if (parameters.use_discontinuous_temperature_discretization
-            || parameters.fixed_heat_flux_boundary_indicators.size() != 0)
-          {
-            assemblers->advection_system_assembler_on_face_properties[0].need_face_material_model_data = true;
-            assemblers->advection_system_assembler_on_face_properties[0].need_face_finite_element_evaluation = true;
-          }
-
-        if (i > 0 && parameters.use_discontinuous_composition_discretization[i-1]
-            && parameters.compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_field)
-          {
-            assemblers->advection_system_assembler_on_face_properties[i].need_face_material_model_data = true;
-            assemblers->advection_system_assembler_on_face_properties[i].need_face_finite_element_evaluation = true;
-          }
-      }
-
-    if (parameters.use_discontinuous_temperature_discretization ||
-        parameters.have_discontinuous_composition_discretization)
-      {
-        const bool dc_temperature = parameters.use_discontinuous_temperature_discretization && parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::fem_field;
-        bool dc_composition = false;
-
-        for (unsigned int c=0; c<parameters.n_compositional_fields; ++c)
-          {
-            if (parameters.use_discontinuous_composition_discretization[c]
-                && parameters.compositional_field_methods[c] == Parameters<dim>::AdvectionFieldMethod::fem_field)
-              {
-                dc_composition = true;
-                break;
-              }
-          }
-
-        const bool no_dc_field_method = !dc_temperature && !dc_composition;
-
-        // TODO: This currently does not work in parallel, because the sparsity
-        // pattern of the matrix does not seem to know about flux terms
-        // across periodic faces of different levels. Fix this.
-        AssertThrow(geometry_model->get_periodic_boundary_pairs().size() == 0 ||
-                    Utilities::MPI::n_mpi_processes(mpi_communicator) == 1 ||
-                    no_dc_field_method ||
-                    (parameters.initial_adaptive_refinement == 0 &&
-                     parameters.adaptive_refinement_interval == 0),
-                    ExcMessage("Combining discontinuous elements with periodic boundaries and "
-                               "adaptive mesh refinement in parallel models is currently not supported. "
-                               "Please switch off any of those options or run on a single process."));
-      }
-  }
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  set_assemblers ()
-  {
-    // first let the manager delete all existing assemblers:
-    assemblers->reset();
-
-    assemblers->advection_system.resize(1+introspection.n_compositional_fields);
-    assemblers->advection_system_on_boundary_face.resize(1+introspection.n_compositional_fields);
-    assemblers->advection_system_on_interior_face.resize(1+introspection.n_compositional_fields);
-    assemblers->advection_system_assembler_properties.resize(1+introspection.n_compositional_fields);
-    assemblers->advection_system_assembler_on_face_properties.resize(1+introspection.n_compositional_fields);
-
-    // Set up the set of assemblers depending on the mode of equations
-    if (!parameters.include_melt_transport
-        && !assemble_newton_stokes_system)
-      {
-        set_advection_assemblers();
-        set_stokes_assemblers();
-      }
-    else if (parameters.include_melt_transport
-             && !assemble_newton_stokes_system)
-      {
-        melt_handler->set_assemblers(*assemblers);
-      }
-    else if (!parameters.include_melt_transport
-             && assemble_newton_stokes_system)
-      {
-        set_advection_assemblers();
-        newton_handler->set_assemblers(*assemblers);
-      }
-    else if (parameters.include_melt_transport
-             && assemble_newton_stokes_system)
-      {
-        AssertThrow (false,
-                     ExcMessage("The melt implementation does not support the Newton solver at the moment."));
-      }
-    else
-      AssertThrow(false,ExcInternalError());
-
-    // allow other assemblers to add themselves or modify the existing ones by firing the signal
-    this->signals.set_assemblers(*this, *assemblers);
-
-    // ensure that all assembler objects have access to the SimulatorAccess
-    // base class
-    initialize_simulator(*this,assemblers->stokes_preconditioner);
-    initialize_simulator(*this,assemblers->stokes_system);
-    initialize_simulator(*this,assemblers->stokes_system_on_boundary_face);
-
-    for (unsigned int i=0; i<1+introspection.n_compositional_fields; ++i)
-      {
-        initialize_simulator(*this,assemblers->advection_system[i]);
-        initialize_simulator(*this,assemblers->advection_system_on_boundary_face[i]);
-        initialize_simulator(*this,assemblers->advection_system_on_interior_face[i]);
-      }
-  }
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  local_assemble_stokes_preconditioner (const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                        internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch,
-                                        internal::Assembly::CopyData::StokesPreconditioner<dim> &data)
-  {
-    // First get all dof indices of the current cell, then extract those
-    // that correspond to the Stokes system we are interested in.
-    // Note that assemblers below can modify this list of dofs, if they in fact
-    // assemble a different system than the standard Stokes system (e.g. in
-    // models with melt transport).
-
-    cell->get_dof_indices (scratch.local_dof_indices);
-    data.extract_stokes_dof_indices(scratch.local_dof_indices, introspection, finite_element);
-
-    // Prepare the data structures for assembly
-    scratch.reinit(cell);
-    data.local_matrix = 0;
-    data.local_inverse_lumped_mass_matrix = 0;
-
-    scratch.material_model_inputs.reinit  (scratch.finite_element_values,
-                                           cell,
-                                           this->introspection,
-                                           current_linearization_point);
-
-    for (unsigned int i=0; i<assemblers->stokes_preconditioner.size(); ++i)
-      assemblers->stokes_preconditioner[i]->create_additional_material_model_outputs(scratch.material_model_outputs);
-
-    material_model->evaluate(scratch.material_model_inputs,
-                             scratch.material_model_outputs);
-    MaterialModel::MaterialAveraging::average (parameters.material_averaging,
-                                               cell,
-                                               scratch.finite_element_values.get_quadrature(),
-                                               scratch.finite_element_values.get_mapping(),
-                                               scratch.material_model_inputs.requested_properties,
-                                               scratch.material_model_outputs);
-
-    for (unsigned int i=0; i<assemblers->stokes_preconditioner.size(); ++i)
-      assemblers->stokes_preconditioner[i]->execute(scratch,data);
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  copy_local_to_global_stokes_preconditioner (const internal::Assembly::CopyData::StokesPreconditioner<dim> &data)
-  {
-    current_constraints.distribute_local_to_global (data.local_matrix,
-                                                    data.local_dof_indices,
-                                                    system_preconditioner_matrix);
-    if (parameters.use_bfbt)
-      current_constraints.distribute_local_to_global(data.local_inverse_lumped_mass_matrix,data.local_dof_indices,inverse_lumped_mass_matrix);
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::assemble_stokes_preconditioner ()
-  {
-    if (stokes_matrix_free)
-      return;
-
-    system_preconditioner_matrix = 0;
-
-    const Quadrature<dim> &quadrature_formula = introspection.quadratures.velocities;
-
-    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
-
-    // determine which update flags to use for the cell integrals
-    const UpdateFlags cell_update_flags
-      = ((update_JxW_values |
-          update_values |
-          update_gradients |
-          update_quadrature_points)
-         |
-         assemblers->stokes_preconditioner_assembler_properties.needed_update_flags);
-
-    unsigned int stokes_dofs_per_cell = dim * finite_element.base_element(introspection.base_elements.velocities).dofs_per_cell
-                                        + finite_element.base_element(introspection.base_elements.pressure).dofs_per_cell;
-
-    if (parameters.include_melt_transport)
-      stokes_dofs_per_cell += finite_element.base_element(introspection.variable("compaction pressure").base_index).dofs_per_cell;
-
-    auto worker = [&](const typename DoFHandler<dim>::active_cell_iterator &cell,
-                      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch,
-                      internal::Assembly::CopyData::StokesPreconditioner<dim> &data)
-    {
-      this->local_assemble_stokes_preconditioner(cell, scratch, data);
-    };
-
-    auto copier = [&](const internal::Assembly::CopyData::StokesPreconditioner<dim> &data)
-    {
-      this->copy_local_to_global_stokes_preconditioner(data);
-    };
-
-    WorkStream::
-    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     dof_handler.begin_active()),
-         CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     dof_handler.end()),
-         worker,
-         copier,
-         internal::Assembly::Scratch::
-         StokesPreconditioner<dim> (finite_element, quadrature_formula,
-                                    *mapping,
-                                    cell_update_flags,
-                                    introspection.n_compositional_fields,
-                                    stokes_dofs_per_cell,
-                                    parameters.include_melt_transport,
-                                    rebuild_stokes_matrix,
-                                    parameters.use_bfbt),
-         internal::Assembly::CopyData::
-         StokesPreconditioner<dim> (stokes_dofs_per_cell));
-
-    system_preconditioner_matrix.compress(VectorOperation::add);
-    if (parameters.use_bfbt)
-      {
-        inverse_lumped_mass_matrix.compress(VectorOperation::add);
-        IndexSet local_indices = inverse_lumped_mass_matrix.block(0).locally_owned_elements();
-        for (auto i: local_indices)
-          {
-            if (current_constraints.is_constrained(i))
-              {
-                inverse_lumped_mass_matrix.block(0)[i] = 1.0;
-              }
-            else
-              {
-                inverse_lumped_mass_matrix.block(0)[i] = 1.0/inverse_lumped_mass_matrix.block(0)[i];
-              }
-          }
-        inverse_lumped_mass_matrix.block(0).compress(VectorOperation::insert);
-      }
-
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::build_stokes_preconditioner ()
-  {
-    if (rebuild_stokes_preconditioner == false)
-      return;
-
-    if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
-      return;
-    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_amg)
-      {
-        // continue below
-      }
-    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::direct_solver)
-      return;
-    else
-      AssertThrow(false, ExcNotImplemented());
-
-    TimerOutput::Scope timer (computing_timer, "Build Stokes preconditioner");
-    pcout << "   Rebuilding Stokes preconditioner..." << std::flush;
-
-    // first assemble the raw matrices necessary for the preconditioner
-    assemble_stokes_preconditioner ();
-
-    // then extract the other information necessary to build the
-    // AMG preconditioners for the A and M blocks
-    std::vector<std::vector<bool>> constant_modes;
-    DoFTools::extract_constant_modes (dof_handler,
-                                      introspection.component_masks.velocities,
-                                      constant_modes);
-
-    // When we solve with melt migration, the pressure block contains
-    // both pressures and contains an elliptic operator, so it makes
-    // sense to use AMG instead of ILU:
-    if (parameters.include_melt_transport)
-      Mp_preconditioner = std::make_unique<LinearAlgebra::PreconditionAMG>();
-    else
-      Mp_preconditioner = std::make_unique<LinearAlgebra::PreconditionILU>();
-
-    Amg_preconditioner = std::make_unique<LinearAlgebra::PreconditionAMG>();
-
-    LinearAlgebra::PreconditionAMG::AdditionalData Amg_data;
-    Amg_data.constant_modes = constant_modes;
-    Amg_data.elliptic = true;
-    Amg_data.higher_order_elements = true;
-
-    // set the AMG parameters in a way that minimizes the run
-    // time. compared to some of the deal.II tutorial programs, we
-    // found that it pays off to set the aggregation threshold to
-    // zero, especially for ill-conditioned problems with large
-    // variations in the viscosity
-    //
-    // for extensive benchmarking of various settings of these
-    // parameters and others, see
-    // https://github.com/geodynamics/aspect/pull/234
-    Amg_data.smoother_type = parameters.AMG_smoother_type.c_str();
-    Amg_data.smoother_sweeps = parameters.AMG_smoother_sweeps;
-    Amg_data.aggregation_threshold = parameters.AMG_aggregation_threshold;
-    Amg_data.output_details = parameters.AMG_output_details;
-
-    /*  The stabilization term for the free surface (Kaus et. al., 2010)
-     *  makes changes to the system matrix which are of the same form as
-     *  boundary stresses. If these stresses are not also added to the
-     *  system_preconditioner_matrix, then it fails to be very good as a
-     *  preconditioner. Instead, we just pass the system_matrix to the
-     *  AMG precondition initialization so that it builds the preconditioner
-     *  directly from that. However, we still need the mass matrix for the
-     *  pressure block which is assembled in the preconditioner matrix.
-     *  So rather than build a different preconditioner matrix which only
-     *  does the mass matrix, we just reuse the same system_preconditioner_matrix
-     *  for the Mp_preconditioner block.  Maybe a bit messy*/
-
-    if (parameters.include_melt_transport == false)
-      {
-        LinearAlgebra::PreconditionILU *Mp_preconditioner_ILU
-          = dynamic_cast<LinearAlgebra::PreconditionILU *> (Mp_preconditioner.get());
-        Mp_preconditioner_ILU->initialize (system_preconditioner_matrix.block(1,1));
-      }
-    else
-      {
-        // in the case of melt transport we have an AMG preconditioner for the lower right block.
-        LinearAlgebra::PreconditionAMG::AdditionalData Amg_data;
-        std::vector<std::vector<bool>> constant_modes;
-        dealii::ComponentMask cm_pressure = introspection.component_masks.pressure;
-        if (parameters.include_melt_transport)
-          cm_pressure = cm_pressure | introspection.variable("compaction pressure").component_mask;
-        DoFTools::extract_constant_modes (dof_handler,
-                                          cm_pressure,
-                                          constant_modes);
-
-        Amg_data.elliptic = true;
-        Amg_data.higher_order_elements = false;
-
-        Amg_data.smoother_sweeps = 2;
-        Amg_data.coarse_type = "symmetric Gauss-Seidel";
-
-        LinearAlgebra::PreconditionAMG *Mp_preconditioner_AMG
-          = dynamic_cast<LinearAlgebra::PreconditionAMG *> (Mp_preconditioner.get());
-        Mp_preconditioner_AMG->initialize (system_preconditioner_matrix.block(1,1), Amg_data);
-      }
-
-    if (parameters.use_full_A_block_preconditioner)
-      Amg_preconditioner->initialize (system_matrix.block(0,0),
-                                      Amg_data);
-    else
-      Amg_preconditioner->initialize (system_preconditioner_matrix.block(0,0),
-                                      Amg_data);
-
-    rebuild_stokes_preconditioner = false;
-
-    pcout << std::endl;
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  local_assemble_stokes_system (const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                internal::Assembly::Scratch::StokesSystem<dim> &scratch,
-                                internal::Assembly::CopyData::StokesSystem<dim> &data)
-  {
-    // First get all dof indices of the current cell, then extract those
-    // that correspond to the Stokes system we are interested in.
-    // Note that assemblers below can modify this list of dofs, if they in fact
-    // assemble a different system than the standard Stokes system (e.g. in
-    // models with melt transport).
-    cell->get_dof_indices (scratch.local_dof_indices);
-
-    data.extract_stokes_dof_indices (scratch.local_dof_indices, introspection, finite_element);
-
-    // Prepare the data structures for assembly
-    scratch.reinit(cell);
-
-    if (rebuild_stokes_matrix)
-      data.local_matrix = 0;
-    data.local_rhs = 0;
-    if (do_pressure_rhs_compatibility_modification)
-      data.local_pressure_shape_function_integrals = 0;
-
-    // initialize the material model data on the cell
-    const bool need_viscosity =
-      assemble_newton_stokes_system || this->parameters.enable_prescribed_dilation || rebuild_stokes_matrix;
-
-    scratch.material_model_inputs.reinit  (scratch.finite_element_values,
-                                           cell,
-                                           this->introspection,
-                                           current_linearization_point);
-
-    scratch.material_model_inputs.requested_properties
-      =
-        MaterialModel::MaterialProperties::equation_of_state_properties |
-        MaterialModel::MaterialProperties::additional_outputs
-        |
-        (need_viscosity ? MaterialModel::MaterialProperties::viscosity : MaterialModel::MaterialProperties::uninitialized);
-
-    for (unsigned int i=0; i<assemblers->stokes_system.size(); ++i)
-      assemblers->stokes_system[i]->create_additional_material_model_outputs(scratch.material_model_outputs);
-
-    material_model->evaluate(scratch.material_model_inputs,
-                             scratch.material_model_outputs);
-    MaterialModel::MaterialAveraging::average (parameters.material_averaging,
-                                               cell,
-                                               scratch.finite_element_values.get_quadrature(),
-                                               scratch.finite_element_values.get_mapping(),
-                                               scratch.material_model_inputs.requested_properties,
-                                               scratch.material_model_outputs);
-
-    scratch.finite_element_values[introspection.extractors.velocities].get_function_values(current_linearization_point,
-        scratch.velocity_values);
-    if (assemble_newton_stokes_system)
-      scratch.finite_element_values[introspection.extractors.velocities].get_function_divergences(current_linearization_point,scratch.velocity_divergence);
-    if (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::hydrostatic_compression)
-      scratch.finite_element_values[introspection.extractors.temperature].get_function_gradients(current_linearization_point,
-          scratch.temperature_gradients);
-
-
-    const bool use_reference_density_profile = (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::reference_density_profile)
-                                               || (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile);
-    if (use_reference_density_profile)
-      {
-        for (unsigned int q=0; q<scratch.finite_element_values.n_quadrature_points; ++q)
-          {
-            scratch.reference_densities[q] = adiabatic_conditions->density(scratch.material_model_inputs.position[q]);
-            scratch.reference_densities_depth_derivative[q] = adiabatic_conditions->density_derivative(scratch.material_model_inputs.position[q]);
-          }
-      }
-
-
-    // trigger the invocation of the various functions that actually do
-    // all of the assembling
-    for (unsigned int i=0; i<assemblers->stokes_system.size(); ++i)
-      assemblers->stokes_system[i]->execute(scratch,data);
-
-    if (!assemblers->stokes_system_on_boundary_face.empty())
-      {
-        // then also work on possible face terms. if necessary, initialize
-        // the material model data on faces
-        for (const unsigned int face_number : cell->face_indices())
-          if (cell->at_boundary(face_number) && !cell->has_periodic_neighbor(face_number))
-            {
-              scratch.reinit(cell, face_number);
-              if (assemblers->stokes_system_assembler_on_boundary_face_properties.need_face_material_model_data)
-                {
-                  const bool need_viscosity = rebuild_stokes_matrix |
-                                              assemblers->stokes_system_assembler_on_boundary_face_properties.need_viscosity;
-
-                  scratch.face_material_model_inputs.reinit  (scratch.face_finite_element_values,
-                                                              cell,
-                                                              this->introspection,
-                                                              current_linearization_point);
-
-                  for (unsigned int i=0; i<assemblers->stokes_system_on_boundary_face.size(); ++i)
-                    assemblers->stokes_system_on_boundary_face[i]->create_additional_material_model_outputs(scratch.face_material_model_outputs);
-
-                  scratch.face_material_model_inputs.requested_properties
-                    = (MaterialModel::MaterialProperties::equation_of_state_properties |
-                       MaterialModel::MaterialProperties::additional_outputs |
-                       (need_viscosity ? MaterialModel::MaterialProperties::viscosity : MaterialModel::MaterialProperties::uninitialized));
-
-
-                  material_model->evaluate(scratch.face_material_model_inputs,
-                                           scratch.face_material_model_outputs);
-
-                  // TODO: Currently we do not supply reference density values to Stokes face assemblers.
-                  // This seems acceptable for now, since the only face assemblers are the ones for the melt
-                  // assembly where one would not want to use the reference density anyway. In case the reference
-                  // density is ever needed, those assemblers can also query the adiabatic conditions for the
-                  // reference density.
-
-                  // TODO: the following doesn't currently compile because the get_quadrature() call returns
-                  //  a dim-1 dimensional quadrature
-                  // MaterialModel::MaterialAveraging::average (parameters.material_averaging,
-                  //                                            cell,
-                  //                                            compressibility * density *
-                  //                                            scratch.face_finite_element_values.get_mapping(),
-                  //                                            scratch.face_material_model_outputs);
-                }
-
-              for (unsigned int i=0; i<assemblers->stokes_system_on_boundary_face.size(); ++i)
-                assemblers->stokes_system_on_boundary_face[i]->execute(scratch,data);
-            }
-      }
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  copy_local_to_global_stokes_system (const internal::Assembly::CopyData::StokesSystem<dim> &data)
-  {
-    if (rebuild_stokes_matrix == true)
-      current_constraints.distribute_local_to_global (data.local_matrix,
-                                                      data.local_rhs,
-                                                      data.local_dof_indices,
-                                                      system_matrix,
-                                                      system_rhs);
-    else
-      current_constraints.distribute_local_to_global (data.local_rhs,
-                                                      data.local_dof_indices,
-                                                      system_rhs);
-
-    if (do_pressure_rhs_compatibility_modification)
-      current_constraints.distribute_local_to_global (data.local_pressure_shape_function_integrals,
-                                                      data.local_dof_indices,
-                                                      pressure_shape_function_integrals);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::assemble_stokes_system ()
-  {
-    std::string timer_section_name = "Assemble Stokes system";
-
-    if (assemble_newton_stokes_system)
-      {
-        if (!assemble_newton_stokes_matrix && !stokes_matrix_free)
-          timer_section_name += " rhs";
-        else if (assemble_newton_stokes_matrix && newton_handler->parameters.newton_derivative_scaling_factor == 0)
-          timer_section_name += " Picard";
-        else if (assemble_newton_stokes_matrix && newton_handler->parameters.newton_derivative_scaling_factor != 0)
-          timer_section_name += " Newton";
-      }
-
-    if (stokes_matrix_free)
-      {
-        rebuild_stokes_matrix = false;
-        assemble_newton_stokes_matrix = false;
-        timer_section_name += " rhs";
-      }
-
-    TimerOutput::Scope timer (computing_timer,
-                              timer_section_name);
-
-    // Re-compute the pressure scaling factor.
-    pressure_scaling = compute_pressure_scaling_factor();
-
-    if (rebuild_stokes_matrix == true)
-      system_matrix = 0;
-
-    // We are using constraints.distribute_local_to_global() without a matrix
-    // if we do not rebuild the Stokes matrix. This produces incorrect results
-    // when having inhomogeneous constraints. Make sure that we can not have
-    // this situation (no active boundary conditions means that only
-    // no-slip/free slip are used). This should not happen as we set this up
-    // correctly before calling this function.
-    // Note that for Dirichlet boundary conditions in matrix-free computations,
-    // we will update the right-hand side with boundary information in
-    // StokesMatrixFreeHandler::correct_stokes_rhs().
-    if (!stokes_matrix_free)
-      Assert(rebuild_stokes_matrix || boundary_velocity_manager.get_active_boundary_velocity_conditions().size()==0,
-             ExcInternalError("If we have inhomogeneous constraints, we must re-assemble the system matrix."));
-
-    system_rhs = 0;
-    if (do_pressure_rhs_compatibility_modification)
-      pressure_shape_function_integrals = 0;
-
-    const Quadrature<dim>   &quadrature_formula = introspection.quadratures.velocities;
-    const Quadrature<dim-1> &face_quadrature_formula = introspection.face_quadratures.velocities;
-
-    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
-
-    // determine which updates flags we need on cells and faces
-    const UpdateFlags cell_update_flags
-      = (update_values    |
-         update_gradients |
-         update_quadrature_points  |
-         update_JxW_values)
-        |
-        assemblers->stokes_system_assembler_properties.needed_update_flags;
-    const UpdateFlags face_update_flags
-      = (
-          // see if we need to assemble traction boundary conditions.
-          // only if so do we actually need to have an FEFaceValues object
-          boundary_traction_manager.get_active_boundary_traction_names ().size() > 0
-          ?
-          update_values |
-          update_quadrature_points |
-          update_normal_vectors |
-          update_JxW_values
-          :
-          update_default)
-        |
-        (assemblers->stokes_system_assembler_on_boundary_face_properties.need_face_material_model_data
-         ?
-         // if we need a material model input on the faces, we need to
-         // also be able to compute the strain rate
-         update_gradients
-         :
-         update_default)
-        |
-        assemblers->stokes_system_assembler_on_boundary_face_properties.needed_update_flags;
-
-    unsigned int stokes_dofs_per_cell = dim * finite_element.base_element(introspection.base_elements.velocities).dofs_per_cell
-                                        + finite_element.base_element(introspection.base_elements.pressure).dofs_per_cell;
-
-    if (parameters.include_melt_transport)
-      stokes_dofs_per_cell += finite_element.base_element(introspection.variable("compaction pressure").base_index).dofs_per_cell;
-
-    const bool use_reference_density_profile = (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::reference_density_profile)
-                                               || (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile);
-
-    auto worker = [&](const typename DoFHandler<dim>::active_cell_iterator &cell,
-                      internal::Assembly::Scratch::StokesSystem<dim> &scratch,
-                      internal::Assembly::CopyData::StokesSystem<dim> &data)
-    {
-      this->local_assemble_stokes_system(cell, scratch, data);
-    };
-
-    auto copier = [&](const internal::Assembly::CopyData::StokesSystem<dim> &data)
-    {
-      this->copy_local_to_global_stokes_system(data);
-    };
-
-    WorkStream::
-    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     dof_handler.begin_active()),
-         CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     dof_handler.end()),
-         worker,
-         copier,
-         internal::Assembly::Scratch::
-         StokesSystem<dim> (finite_element, *mapping, quadrature_formula,
-                            face_quadrature_formula,
-                            cell_update_flags,
-                            face_update_flags,
-                            introspection.n_compositional_fields,
-                            stokes_dofs_per_cell,
-                            parameters.include_melt_transport,
-                            use_reference_density_profile,
-                            rebuild_stokes_matrix,
-                            assemble_newton_stokes_matrix,
-                            parameters.use_bfbt),
-         internal::Assembly::CopyData::
-         StokesSystem<dim> (stokes_dofs_per_cell,
-                            do_pressure_rhs_compatibility_modification));
-
-    system_matrix.compress(VectorOperation::add);
-    system_rhs.compress(VectorOperation::add);
-
-    // If we change the system_rhs, matrix-free Stokes must update
-    if (stokes_matrix_free)
-      stokes_matrix_free->assemble();
-
-    // if the model is compressible then we need to adjust the right hand
-    // side of the equation to make it compatible with the matrix on the
-    // left
-    if (do_pressure_rhs_compatibility_modification)
-      {
-        pressure_shape_function_integrals.compress(VectorOperation::add);
-        make_pressure_rhs_compatible(system_rhs);
-      }
-
-    // record that we have just rebuilt the matrix
-    rebuild_stokes_matrix = false;
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::build_advection_preconditioner(const AdvectionField &advection_field,
-                                                 LinearAlgebra::PreconditionILU &preconditioner,
-                                                 const double diagonal_strengthening)
-  {
-    TimerOutput::Scope timer (computing_timer, (advection_field.is_temperature() ?
-                                                "Build temperature preconditioner" :
-                                                "Build composition preconditioner"));
-
-    const unsigned int block_idx = advection_field.block_index(introspection);
-
-
-    LinearAlgebra::PreconditionILU::AdditionalData data;
-    data.ilu_atol = diagonal_strengthening;
-
-    preconditioner.initialize (system_matrix.block(block_idx, block_idx), data);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::
-  local_assemble_advection_system (const AdvectionField     &advection_field,
-                                   const Vector<double>           &viscosity_per_cell,
-                                   const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                   internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
-                                   internal::Assembly::CopyData::AdvectionSystem<dim> &data)
-  {
-    // also have the number of dofs that correspond just to the element for
-    // the system we are currently trying to assemble
-    const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
-
-    Assert (advection_dofs_per_cell < scratch.finite_element_values.get_fe().dofs_per_cell, ExcInternalError());
-    Assert (scratch.grad_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
-    Assert (scratch.phi_field.size() == advection_dofs_per_cell, ExcInternalError());
-
-    const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
-
-    const unsigned int solution_component = advection_field.component_index(introspection);
-
-    scratch.reinit(cell);
-
-    // get all dof indices on the current cell, then extract those
-    // that correspond to the solution_field we are interested in
-    cell->get_dof_indices (scratch.local_dof_indices);
-    for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
-      {
-        if (finite_element.system_to_component_index(i).first == solution_component)
-          {
-            data.local_dof_indices[i_advection] = scratch.local_dof_indices[i];
-            ++i_advection;
-          }
-        ++i;
-      }
-
-    data.local_matrix = 0;
-    data.local_rhs = 0;
-
-    scratch.finite_element_values[solution_field].get_function_values (old_solution,
-                                                                       scratch.old_field_values);
-    scratch.finite_element_values[solution_field].get_function_values (old_old_solution,
-                                                                       scratch.old_old_field_values);
-
-
-    scratch.finite_element_values[introspection.extractors.velocities].get_function_values(current_linearization_point,
-        scratch.current_velocity_values);
-
-    if (parameters.include_melt_transport)
-      scratch.finite_element_values[introspection.extractors.velocities].get_function_divergences(current_linearization_point,
-          scratch.current_velocity_divergences);
-
-    // get the mesh velocity, as we need to subtract it off of the advection systems
-    if (parameters.mesh_deformation_enabled)
-      scratch.finite_element_values[introspection.extractors.velocities].get_function_values(mesh_deformation->mesh_velocity,
-          scratch.mesh_velocity_values);
-
-    // compute material properties and heating terms
-    scratch.material_model_inputs.reinit  (scratch.finite_element_values,
-                                           cell,
-                                           this->introspection,
-                                           current_linearization_point);
-
-    for (unsigned int i=0; i<1+introspection.n_compositional_fields; ++i)
-      for (unsigned int j=0; j<assemblers->advection_system[i].size(); ++j)
-        assemblers->advection_system[i][j]->create_additional_material_model_outputs(scratch.material_model_outputs);
-
-    heating_model_manager.create_additional_material_model_inputs_and_outputs(scratch.material_model_inputs,
-                                                                              scratch.material_model_outputs);
-    material_model->fill_additional_material_model_inputs(scratch.material_model_inputs,
-                                                          current_linearization_point,
-                                                          scratch.finite_element_values,
-                                                          introspection);
-
-    material_model->evaluate(scratch.material_model_inputs,
-                             scratch.material_model_outputs);
-    if (parameters.formulation_temperature_equation ==
-        Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-      {
-        const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-        for (unsigned int q=0; q<n_q_points; ++q)
-          {
-            scratch.material_model_outputs.densities[q] = adiabatic_conditions->density(scratch.material_model_inputs.position[q]);
-          }
-      }
-
-#ifdef DEBUG
-    // make sure that if the model does not use operator splitting,
-    // the material model outputs do not fill the reaction_rates (because the reaction_terms are used instead)
-    if (!parameters.use_operator_splitting)
-      {
-        material_model->create_additional_named_outputs(scratch.material_model_outputs);
-        MaterialModel::ReactionRateOutputs<dim> *reaction_rate_outputs
-          = scratch.material_model_outputs.template get_additional_output<MaterialModel::ReactionRateOutputs<dim>>();
-
-        Assert(reaction_rate_outputs == nullptr,
-               ExcMessage("You are using a material model where the reaction rate outputs "
-                          "are created even though the operator splitting solver option is "
-                          "not used in the model, this is not supported! "
-                          "If operator splitting is disabled, the reaction_rates should not "
-                          "be created at all. If you want to run a model where reactions are "
-                          "much faster than the advection, which is what the reaction rate "
-                          "outputs are designed for, you should enable operator splitting."));
-      }
-#endif
-
-    MaterialModel::MaterialAveraging::average (parameters.material_averaging,
-                                               cell,
-                                               scratch.finite_element_values.get_quadrature(),
-                                               scratch.finite_element_values.get_mapping(),
-                                               scratch.material_model_inputs.requested_properties,
-                                               scratch.material_model_outputs);
-
-    heating_model_manager.evaluate(scratch.material_model_inputs,
-                                   scratch.material_model_outputs,
-                                   scratch.heating_model_outputs);
-
-    // TODO: Compute artificial viscosity once per timestep instead of each time
-    // temperature system is assembled (as this might happen more than once per
-    // timestep for iterative solvers)
-    scratch.artificial_viscosity = viscosity_per_cell[cell->active_cell_index()];
-    Assert (scratch.artificial_viscosity >= 0, ExcMessage ("The artificial viscosity needs to be a non-negative quantity."));
-
-    // trigger the invocation of the various functions that actually do
-    // all of the assembling
-    for (unsigned int i=0; i<assemblers->advection_system[advection_field.field_index()].size(); ++i)
-      assemblers->advection_system[advection_field.field_index()][i]->execute(scratch,data);
-
-    // then also work on possible face terms. if necessary, initialize
-    // the material model data on faces
-    const bool has_boundary_face_assemblers = !assemblers->advection_system_on_boundary_face[advection_field.field_index()].empty()
-                                              && assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation;
-    const bool has_interior_face_assemblers = !assemblers->advection_system_on_interior_face[advection_field.field_index()].empty()
-                                              && assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation;
-
-    // skip the remainder if no work needs to be done on faces
-    if (!has_boundary_face_assemblers && !has_interior_face_assemblers)
-      return;
-
-    if (has_interior_face_assemblers)
-      {
-        // For interior face contributions loop over all possible
-        // subfaces of the cell, and reset their matrices.
-        for (auto &m : data.local_matrices_ext_int)
-          m = 0;
-        for (auto &m : data.local_matrices_int_ext)
-          m = 0;
-        for (auto &m : data.local_matrices_ext_ext)
-          m = 0;
-        // Mark the arrays initialized to zero above as currently all unused
-        std::fill (data.assembled_matrices.begin(), data.assembled_matrices.end(),
-                   false);
-      }
-
-    for (scratch.face_number=0; scratch.face_number<cell->n_faces(); ++scratch.face_number)
-      {
-        const typename DoFHandler<dim>::face_iterator face = cell->face (scratch.face_number);
-
-        if ((has_boundary_face_assemblers && face->at_boundary()) ||
-            (has_interior_face_assemblers && !face->at_boundary()))
-          {
-            (*scratch.face_finite_element_values).reinit (cell, scratch.face_number);
-
-            (*scratch.face_finite_element_values)[introspection.extractors.velocities].get_function_values(current_linearization_point,
-                scratch.face_current_velocity_values);
-
-            // get the mesh velocity, as we need to subtract it off of the advection systems
-            if (parameters.mesh_deformation_enabled)
-              (*scratch.face_finite_element_values)[introspection.extractors.velocities].get_function_values(mesh_deformation->mesh_velocity,
-                  scratch.face_mesh_velocity_values);
-
-            if (assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_material_model_data)
-              {
-                scratch.face_material_model_inputs.reinit  (*scratch.face_finite_element_values,
-                                                            cell,
-                                                            this->introspection,
-                                                            current_linearization_point);
-
-                for (unsigned int i=0; i<assemblers->advection_system_on_boundary_face[advection_field.field_index()].size(); ++i)
-                  assemblers->advection_system_on_boundary_face[advection_field.field_index()][i]->create_additional_material_model_outputs(scratch.face_material_model_outputs);
-
-                for (unsigned int i=0; i<assemblers->advection_system_on_interior_face[advection_field.field_index()].size(); ++i)
-                  assemblers->advection_system_on_interior_face[advection_field.field_index()][i]->create_additional_material_model_outputs(scratch.face_material_model_outputs);
-
-                heating_model_manager.create_additional_material_model_inputs_and_outputs(scratch.face_material_model_inputs,
-                                                                                          scratch.face_material_model_outputs);
-                material_model->fill_additional_material_model_inputs(scratch.face_material_model_inputs,
-                                                                      current_linearization_point,
-                                                                      *scratch.face_finite_element_values,
-                                                                      introspection);
-
-                material_model->evaluate(scratch.face_material_model_inputs,
-                                         scratch.face_material_model_outputs);
-
-                if (parameters.formulation_temperature_equation ==
-                    Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-                  {
-                    const unsigned int n_q_points = scratch.face_finite_element_values->n_quadrature_points;
-                    for (unsigned int q=0; q<n_q_points; ++q)
-                      {
-                        scratch.face_material_model_outputs.densities[q] = adiabatic_conditions->density(scratch.face_material_model_inputs.position[q]);
-                      }
-                  }
-
-                heating_model_manager.evaluate(scratch.face_material_model_inputs,
-                                               scratch.face_material_model_outputs,
-                                               scratch.face_heating_model_outputs);
-                // TODO: the following doesn't currently compile because the get_quadrature() call returns
-                //  a dim-1 dimensional quadrature
-                // MaterialModel::MaterialAveraging::average (parameters.material_averaging,
-                //                                            cell,
-                //                                            scratch.face_finite_element_values.get_quadrature(),
-                //                                            scratch.face_finite_element_values.get_mapping(),
-                //                                            scratch.face_material_model_outputs);
-              }
-
-            // handle faces at periodic boundaries like interior faces
-            if (face->at_boundary() && !cell->has_periodic_neighbor (scratch.face_number))
-              for (unsigned int i=0; i<assemblers->advection_system_on_boundary_face[advection_field.field_index()].size(); ++i)
-                assemblers->advection_system_on_boundary_face[advection_field.field_index()][i]->execute(scratch,data);
-            else
-              for (unsigned int i=0; i<assemblers->advection_system_on_interior_face[advection_field.field_index()].size(); ++i)
-                assemblers->advection_system_on_interior_face[advection_field.field_index()][i]->execute(scratch,data);
-          }
-      }
-  }
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  copy_local_to_global_advection_system (const AdvectionField &advection_field,
-                                         const internal::Assembly::CopyData::AdvectionSystem<dim> &data)
-  {
-    // copy entries into the global matrix. note that these local contributions
-    // only correspond to the advection dofs, as assembled above
-    current_constraints.distribute_local_to_global (data.local_matrix,
-                                                    data.local_rhs,
-                                                    data.local_dof_indices,
-                                                    system_matrix,
-                                                    system_rhs);
-
-    // In the following, we copy DG contributions entry by entry. This
-    // is allowed since there are no constraints imposed on discontinuous fields.
-    if (!assemblers->advection_system_on_interior_face.empty() &&
-        assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation)
-      {
-        for (unsigned int f=0; f<data.assembled_matrices.size(); ++f)
-          if (data.assembled_matrices[f])
-            {
-              for (unsigned int i=0; i<data.local_dof_indices.size(); ++i)
-                for (unsigned int j=0; j<data.neighbor_dof_indices[f].size(); ++j)
-                  {
-                    system_matrix.add (data.local_dof_indices[i],
-                                       data.neighbor_dof_indices[f][j],
-                                       data.local_matrices_int_ext[f](i,j));
-                    system_matrix.add (data.neighbor_dof_indices[f][j],
-                                       data.local_dof_indices[i],
-                                       data.local_matrices_ext_int[f](j,i));
-                  }
-
-              for (unsigned int i=0; i<data.neighbor_dof_indices[f].size(); ++i)
-                for (unsigned int j=0; j<data.neighbor_dof_indices[f].size(); ++j)
-                  system_matrix.add (data.neighbor_dof_indices[f][i],
-                                     data.neighbor_dof_indices[f][j],
-                                     data.local_matrices_ext_ext[f](i,j));
-            }
-      }
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::assemble_advection_system (const AdvectionField &advection_field)
-  {
-    TimerOutput::Scope timer (computing_timer, (advection_field.is_temperature() ?
-                                                "Assemble temperature system" :
-                                                "Assemble composition system"));
-
-    const unsigned int block_idx = advection_field.block_index(introspection);
-    const unsigned int sparsity_block_idx = advection_field.sparsity_pattern_block_index(introspection);
-
-    if (!advection_field.is_temperature() && sparsity_block_idx != block_idx)
-      {
-        // We need to allocate our matrix in block block_idx with the sparsity
-        // pattern stored in block sparsity_block_idx and we will free the memory
-        // again after solving. This way we can reuse the sparsity pattern and
-        // save memory by only having 1 compositional matrix allocated at a time.
-        // If all compositional fields are the same, only composition 0 is non-empty
-        // at this time.
-        system_matrix.block(block_idx, block_idx).reinit(system_matrix.block(sparsity_block_idx, sparsity_block_idx));
-      }
-
-    system_matrix.block(block_idx, block_idx) = 0;
-    system_rhs.block(block_idx) = 0;
-
-
-    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
-
-    Vector<double> viscosity_per_cell;
-    viscosity_per_cell.reinit(triangulation.n_active_cells());
-    get_artificial_viscosity(viscosity_per_cell, advection_field);
-
-    // We have to assemble the term u.grad phi_i * phi_j, which is
-    // of total polynomial degree
-    //   stokes_deg + 2*temp_deg -1
-    // (or similar for comp_deg). This suggests using a Gauss
-    // quadrature formula of order
-    //   temp_deg + stokes_deg/2
-    // rounded up (note that x/2 rounded up
-    // equals (x+1)/2 using integer division.)
-    //
-    // (Note: All compositional fields have the same base element and therefore
-    // the same composition_degree. Thus, we do not need to find out the degree
-    // of the current field, but use the global instead)
-    const unsigned int advection_quadrature_degree = advection_field.polynomial_degree(introspection)
-                                                     +
-                                                     (parameters.stokes_velocity_degree+1)/2;
-
-    const bool allocate_face_quadrature = (!assemblers->advection_system_on_boundary_face.empty() ||
-                                           !assemblers->advection_system_on_interior_face.empty()) &&
-                                          assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation;
-    const bool allocate_neighbor_contributions = !assemblers->advection_system_on_interior_face.empty() &&
-                                                 assemblers->advection_system_assembler_on_face_properties[advection_field.field_index()].need_face_finite_element_evaluation;
-
-    const bool use_supg = (parameters.advection_stabilization_method
-                           == Parameters<dim>::AdvectionStabilizationMethod::supg);
-
-    // When using SUPG, we need to compute hessians to be able to compute the residual:
-    const UpdateFlags update_flags = update_values |
-                                     update_gradients |
-                                     update_quadrature_points |
-                                     update_JxW_values |
-                                     ((use_supg) ? update_hessians : UpdateFlags(0));
-
-    const UpdateFlags face_update_flags = (allocate_face_quadrature ?
-                                           update_values |
-                                           update_gradients |
-                                           update_quadrature_points |
-                                           update_normal_vectors |
-                                           update_JxW_values
-                                           :
-                                           update_default);
-
-    auto worker = [&](const typename DoFHandler<dim>::active_cell_iterator &cell,
-                      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
-                      internal::Assembly::CopyData::AdvectionSystem<dim> &data)
-    {
-      this->local_assemble_advection_system(advection_field, viscosity_per_cell, cell, scratch, data);
-    };
-
-    auto copier = [&](const internal::Assembly::CopyData::AdvectionSystem<dim> &data)
-    {
-      this->copy_local_to_global_advection_system(advection_field, data);
-    };
-
-    WorkStream::
-    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     dof_handler.begin_active()),
-         CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     dof_handler.end()),
-         worker,
-         copier,
-         internal::Assembly::Scratch::
-         AdvectionSystem<dim> (finite_element,
-                               finite_element.base_element(advection_field.base_element(introspection)),
-                               *mapping,
-                               QGauss<dim>(advection_quadrature_degree),
-                               /* Only generate a valid face quadrature if necessary.
-                                * Otherwise, generate invalid face quadrature rule.
-                                */
-                               (allocate_face_quadrature ?
-                                QGauss<dim-1>(advection_quadrature_degree) :
-                                Quadrature<dim-1> ()),
-                               update_flags,
-                               face_update_flags,
-                               introspection.n_compositional_fields,
-                               advection_field),
-         internal::Assembly::CopyData::
-         AdvectionSystem<dim> (finite_element.base_element(advection_field.base_element(introspection)),
-                               allocate_neighbor_contributions));
-
-    system_matrix.compress(VectorOperation::add);
-    system_rhs.compress(VectorOperation::add);
-  }
-}
-
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template void Simulator<dim>::set_assemblers (); \
-  template void Simulator<dim>::local_assemble_stokes_preconditioner ( \
-                                                                       const DoFHandler<dim>::active_cell_iterator &cell, \
-                                                                       internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch, \
-                                                                       internal::Assembly::CopyData::StokesPreconditioner<dim> &data); \
-  template void Simulator<dim>::copy_local_to_global_stokes_preconditioner ( \
-                                                                             const internal::Assembly::CopyData::StokesPreconditioner<dim> &data); \
-  template void Simulator<dim>::assemble_stokes_preconditioner (); \
-  template void Simulator<dim>::build_stokes_preconditioner (); \
-  template void Simulator<dim>::local_assemble_stokes_system ( \
-                                                               const DoFHandler<dim>::active_cell_iterator &cell, \
-                                                               internal::Assembly::Scratch::StokesSystem<dim>  &scratch, \
-                                                               internal::Assembly::CopyData::StokesSystem<dim> &data); \
-  template void Simulator<dim>::copy_local_to_global_stokes_system ( \
-                                                                     const internal::Assembly::CopyData::StokesSystem<dim> &data); \
-  template void Simulator<dim>::assemble_stokes_system (); \
-  template void Simulator<dim>::build_advection_preconditioner (const AdvectionField &, \
-                                                                aspect::LinearAlgebra::PreconditionILU &preconditioner, \
-                                                                const double diagonal_strengthening); \
-  template void Simulator<dim>::local_assemble_advection_system ( \
-                                                                  const AdvectionField          &advection_field, \
-                                                                  const Vector<double>           &viscosity_per_cell, \
-                                                                  const DoFHandler<dim>::active_cell_iterator &cell, \
-                                                                  internal::Assembly::Scratch::AdvectionSystem<dim>  &scratch, \
-                                                                  internal::Assembly::CopyData::AdvectionSystem<dim> &data); \
-  template void Simulator<dim>::copy_local_to_global_advection_system ( \
-                                                                        const AdvectionField          &advection_field, \
-                                                                        const internal::Assembly::CopyData::AdvectionSystem<dim> &data); \
-  template void Simulator<dim>::assemble_advection_system (const AdvectionField     &advection_field);
-
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/checkpoint_restart.cc.bak b/source/simulator/checkpoint_restart.cc.bak
deleted file mode 100644
index 935afb8cb7e..00000000000
--- a/source/simulator/checkpoint_restart.cc.bak
+++ /dev/null
@@ -1,650 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/melt.h>
-
-#include <deal.II/base/mpi.h>
-#include <deal.II/grid/grid_tools.h>
-#include <deal.II/distributed/solution_transfer.h>
-#include <deal.II/fe/mapping_q_cache.h>
-
-#ifdef DEAL_II_WITH_ZLIB
-#  include <zlib.h>
-#endif
-
-namespace aspect
-{
-  namespace
-  {
-    /**
-     * Move/rename a file from the given old to the given new name.
-     */
-    void move_file (const std::string &old_name,
-                    const std::string &new_name)
-    {
-      int error = system (("mv " + old_name + " " + new_name).c_str());
-
-      // If the above call failed, e.g. because there is no command-line
-      // available, try with internal functions.
-      if (error != 0)
-        {
-          if (Utilities::fexists(new_name))
-            {
-              error = remove(new_name.c_str());
-              AssertThrow (error == 0, ExcMessage(std::string ("Unable to remove file: "
-                                                               + new_name
-                                                               + ", although it seems to exist. "
-                                                               + "The error code is "
-                                                               + Utilities::to_string(error) + ".")));
-            }
-
-          error = rename(old_name.c_str(),new_name.c_str());
-          AssertThrow (error == 0, ExcMessage(std::string ("Unable to rename files: ")
-                                              +
-                                              old_name + " -> " + new_name
-                                              + ". The error code is "
-                                              + Utilities::to_string(error) + "."));
-        }
-    }
-  }
-
-
-  namespace
-  {
-    /**
-     * Save a few of the critical parameters of the current run in the
-     * checkpoint file. We will load them again later during
-     * restart to verify that they are the same as the ones set
-     * in the input file active during restart.
-     */
-    template <int dim>
-    void save_critical_parameters (const Parameters<dim> &parameters,
-                                   aspect::oarchive &oa)
-    {
-      oa << parameters.convert_to_years;
-      oa << parameters.surface_pressure;
-      oa << parameters.use_operator_splitting;
-      oa << parameters.include_melt_transport;
-      oa << parameters.stokes_velocity_degree;
-      oa << parameters.use_locally_conservative_discretization;
-      oa << parameters.use_discontinuous_temperature_discretization;
-      oa << parameters.use_discontinuous_composition_discretization;
-      oa << parameters.temperature_degree;
-      oa << parameters.composition_degree;
-      oa << parameters.pressure_normalization;
-      oa << parameters.n_compositional_fields;
-      oa << parameters.names_of_compositional_fields;
-      oa << parameters.normalized_fields;
-      oa << parameters.mesh_deformation_enabled;
-    }
-
-
-
-    /**
-     * Load a few of the critical parameters from a checkpoint file during
-     * restart to verify that they are the same as the ones currently set
-     * in the input file active during restart.
-     */
-    template <int dim>
-    void load_and_check_critical_parameters (const Parameters<dim> &parameters,
-                                             aspect::iarchive &ia)
-    {
-      bool convert_to_years;
-      ia >> convert_to_years;
-      AssertThrow (convert_to_years == parameters.convert_to_years,
-                   ExcMessage ("The value provided for `Use years in output instead of seconds' that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      double surface_pressure;
-      ia >> surface_pressure;
-      AssertThrow (surface_pressure == parameters.surface_pressure,
-                   ExcMessage ("The value of surface pressure that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      bool use_operator_splitting;
-      ia >> use_operator_splitting;
-      AssertThrow (use_operator_splitting == parameters.use_operator_splitting,
-                   ExcMessage ("The operator splitting mode that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      bool include_melt_transport;
-      ia >> include_melt_transport;
-      AssertThrow (include_melt_transport == parameters.include_melt_transport,
-                   ExcMessage ("The melt transport mode that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      unsigned int stokes_velocity_degree;
-      ia >> stokes_velocity_degree;
-      AssertThrow (stokes_velocity_degree == parameters.stokes_velocity_degree,
-                   ExcMessage ("The polynomial degree used for the Stokes "
-                               "finite element that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-
-      // It is conceivable that one could change this setting from one time
-      // step to another, but it is, at best, not tested. So disallow it for
-      // now, until someone tests it.
-      bool use_locally_conservative_discretization;
-      ia >> use_locally_conservative_discretization;
-      AssertThrow (use_locally_conservative_discretization == parameters.use_locally_conservative_discretization,
-                   ExcMessage ("The value provided for `Use locally conservative discretization' that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      bool use_discontinuous_temperature_discretization;
-      ia >> use_discontinuous_temperature_discretization;
-      AssertThrow (use_discontinuous_temperature_discretization == parameters.use_discontinuous_temperature_discretization,
-                   ExcMessage ("The value provided for `Use discontinuous temperature discretization' that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      std::vector<bool> use_discontinuous_composition_discretization;
-      ia >> use_discontinuous_composition_discretization;
-      AssertThrow (use_discontinuous_composition_discretization == parameters.use_discontinuous_composition_discretization,
-                   ExcMessage ("The value provided for `Use discontinuous composition discretization' that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      unsigned int temperature_degree;
-      ia >> temperature_degree;
-      AssertThrow (temperature_degree == parameters.temperature_degree,
-                   ExcMessage ("The temperature polynomial degree that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      unsigned int composition_degree;
-      ia >> composition_degree;
-      AssertThrow (composition_degree == parameters.composition_degree,
-                   ExcMessage ("The composition polynomial degree that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      // One could allow changing the pressure normalization between runs, but
-      // the change would then lead to a jump in pressure from one time step
-      // to the next when we, for example, change from requiring the *surface*
-      // average to be zero, to requiring the *domain* average to be zero.
-      // That's unlikely what the user really wanted. However, we do allow
-      // disabling the pressure normalization in case the user wants to enable
-      // a free surface boundary.
-      std::string pressure_normalization;
-      ia >> pressure_normalization;
-      AssertThrow (pressure_normalization == parameters.pressure_normalization ||
-                   parameters.pressure_normalization == "no",
-                   ExcMessage ("The pressure normalization method that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file and your new "
-                               "pressure normalization method is not 'no'. "
-                               "The only allowed change for the pressure "
-                               "normalization method during a restart is to "
-                               "disable normalization."));
-
-      unsigned int n_compositional_fields;
-      ia >> n_compositional_fields;
-      AssertThrow (n_compositional_fields == parameters.n_compositional_fields,
-                   ExcMessage ("The number of compositional fields that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      std::vector<std::string> names_of_compositional_fields;
-      ia >> names_of_compositional_fields;
-      AssertThrow (names_of_compositional_fields == parameters.names_of_compositional_fields,
-                   ExcMessage ("The names of compositional fields that were stored "
-                               "in the checkpoint file are not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      std::vector<unsigned int> normalized_fields;
-      ia >> normalized_fields;
-      AssertThrow (normalized_fields == parameters.normalized_fields,
-                   ExcMessage ("The list of normalized fields that was stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-      bool mesh_deformation_enabled;
-      ia >> mesh_deformation_enabled;
-      AssertThrow (mesh_deformation_enabled == parameters.mesh_deformation_enabled,
-                   ExcMessage ("The enable mesh deformation settings that were stored "
-                               "in the checkpoint file is not the same as the one "
-                               "you currently set in your input file. "
-                               "These need to be the same during restarting "
-                               "from a checkpoint."));
-
-    }
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::create_snapshot()
-  {
-    TimerOutput::Scope timer (computing_timer, "Create snapshot");
-
-    // Take elapsed time from timer so that we can serialize it:
-    total_walltime_until_last_snapshot += wall_timer.wall_time();
-    wall_timer.restart();
-
-    const unsigned int my_id = Utilities::MPI::this_mpi_process (mpi_communicator);
-
-    // save Triangulation and Solution vectors:
-    {
-      std::vector<const LinearAlgebra::BlockVector *> x_system
-        = { &solution, &old_solution, &old_old_solution };
-
-      // If we are using a deforming mesh, include the mesh velocity, which uses the system dof handler
-      if (parameters.mesh_deformation_enabled)
-        x_system.push_back( &mesh_deformation->mesh_velocity );
-
-      parallel::distributed::SolutionTransfer<dim, LinearAlgebra::BlockVector>
-      system_trans (dof_handler);
-
-      system_trans.prepare_for_serialization (x_system);
-
-
-      // If we are deforming the mesh, also serialize the mesh vertices vector, which
-      // uses its own dof handler
-      std::vector<const LinearAlgebra::Vector *> x_fs_system;
-      std::unique_ptr<parallel::distributed::SolutionTransfer<dim,LinearAlgebra::Vector>> mesh_deformation_trans;
-      if (parameters.mesh_deformation_enabled)
-        {
-          x_fs_system.push_back (&mesh_deformation->mesh_displacements);
-          x_fs_system.push_back (&mesh_deformation->initial_topography);
-
-          mesh_deformation_trans
-            = std::make_unique<parallel::distributed::SolutionTransfer<dim,LinearAlgebra::Vector>>
-              (mesh_deformation->mesh_deformation_dof_handler);
-
-          mesh_deformation_trans->prepare_for_serialization(x_fs_system);
-        }
-
-      signals.pre_checkpoint_store_user_data(triangulation);
-
-      triangulation.save (parameters.output_directory + "restart.mesh.new");
-    }
-
-    // save general information This calls the serialization functions on all
-    // processes (so that they can take additional action, if necessary, see
-    // the manual) but only writes to the restart file on process 0
-    {
-      std::ostringstream oss;
-
-      // serialize into a stringstream
-      aspect::oarchive oa (oss);
-      save_critical_parameters (this->parameters, oa);
-      oa << (*this);
-
-      // compress with zlib and write to file on the root processor
-#ifdef DEAL_II_WITH_ZLIB
-      if (my_id == 0)
-        {
-          uLongf compressed_data_length = compressBound (oss.str().length());
-          std::vector<char *> compressed_data (compressed_data_length);
-          int err = compress2 (reinterpret_cast<Bytef *>(&compressed_data[0]),
-                               &compressed_data_length,
-                               reinterpret_cast<const Bytef *>(oss.str().data()),
-                               oss.str().length(),
-                               Z_BEST_COMPRESSION);
-          (void)err;
-          Assert (err == Z_OK, ExcInternalError());
-
-          // build compression header
-          const uint32_t compression_header[4]
-            = { 1,                                   /* number of blocks */
-                static_cast<uint32_t>(oss.str().length()), /* size of block */
-                static_cast<uint32_t>(oss.str().length()), /* size of last block */
-                static_cast<uint32_t>(compressed_data_length)
-              }; /* list of compressed sizes of blocks */
-
-          std::ofstream f ((parameters.output_directory + "restart.resume.z.new"));
-          f.write(reinterpret_cast<const char *>(compression_header), 4 * sizeof(compression_header[0]));
-          f.write(reinterpret_cast<char *>(&compressed_data[0]), compressed_data_length);
-          f.close();
-
-          // We check the fail state of the stream _after_ closing the file to
-          // make sure the writes were completed correctly. This also catches
-          // the cases where the file could not be opened in the first place
-          // or one of the write() commands fails, as the fail state is
-          // "sticky".
-          if (!f)
-            AssertThrow(false, ExcMessage ("Writing of the checkpoint file '" + parameters.output_directory
-                                           + "restart.resume.z.new' with size "
-                                           + Utilities::to_string(4 * sizeof(compression_header[0])+compressed_data_length)
-                                           + " failed on processor 0."));
-        }
-#else
-      AssertThrow (false,
-                   ExcMessage ("You need to have deal.II configured with the `libz' "
-                               "option to support checkpoint/restart, but deal.II "
-                               "did not detect its presence when you called `cmake'."));
-#endif
-
-    }
-
-    // Wait for everyone to finish writing
-    const int ierr = MPI_Barrier(mpi_communicator);
-    AssertThrowMPI(ierr);
-
-    // Now rename the snapshots to put the new one in place of the old one.
-    // Do this after writing the new one, because writing large checkpoints
-    // can be slow, and the model might be cancelled during writing.
-    // This way restart remains usable even if restart.new is not completely
-    // written.
-    if (my_id == 0)
-      {
-        // if we have previously written a snapshot, then keep the last
-        // snapshot in case this one fails to save. Note: static variables
-        // will only be initialized once per model run.
-        static bool previous_snapshot_exists = (parameters.resume_computation == true);
-
-        if (previous_snapshot_exists == true)
-          {
-            move_file (parameters.output_directory + "restart.mesh",
-                       parameters.output_directory + "restart.mesh.old");
-            move_file (parameters.output_directory + "restart.mesh.info",
-                       parameters.output_directory + "restart.mesh.info.old");
-            move_file (parameters.output_directory + "restart.resume.z",
-                       parameters.output_directory + "restart.resume.z.old");
-
-            move_file (parameters.output_directory + "restart.mesh_fixed.data",
-                       parameters.output_directory + "restart.mesh_fixed.data.old");
-
-            if (Utilities::fexists(parameters.output_directory + "restart.mesh_variable.data"))
-              {
-                move_file (parameters.output_directory + "restart.mesh_variable.data",
-                           parameters.output_directory + "restart.mesh_variable.data.old");
-              }
-
-          }
-
-        move_file (parameters.output_directory + "restart.mesh.new",
-                   parameters.output_directory + "restart.mesh");
-        move_file (parameters.output_directory + "restart.mesh.new.info",
-                   parameters.output_directory + "restart.mesh.info");
-        move_file (parameters.output_directory + "restart.resume.z.new",
-                   parameters.output_directory + "restart.resume.z");
-
-        move_file (parameters.output_directory + "restart.mesh.new_fixed.data",
-                   parameters.output_directory + "restart.mesh_fixed.data");
-
-        if (Utilities::fexists(parameters.output_directory + "restart.mesh.new_variable.data"))
-          {
-            move_file (parameters.output_directory + "restart.mesh.new_variable.data",
-                       parameters.output_directory + "restart.mesh_variable.data");
-          }
-
-
-        // from now on, we know that if we get into this
-        // function again that a snapshot has previously
-        // been written
-        previous_snapshot_exists = true;
-      }
-
-    pcout << "*** Snapshot created!" << std::endl << std::endl;
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::resume_from_snapshot()
-  {
-    // By definition, a checkpoint is past the first time step. As a consequence,
-    // the Simulator object will not need the initial conditions objects, and
-    // we can release the pointers to these objects that we have created in
-    // the constructor of this class. If some of the other plugins created there
-    // still need access to these initial conditions, they will have created
-    // their own shared pointers.
-    initial_temperature_manager.reset();
-    initial_composition_manager.reset();
-#ifdef ASPECT_WITH_WORLD_BUILDER
-    // The same applies to the world builder object:
-    world_builder.reset();
-#endif
-
-    // Then start with the actual deserialization.
-    // First check existence of the two restart files
-    AssertThrow (Utilities::fexists(parameters.output_directory + "restart.mesh", mpi_communicator),
-                 ExcMessage ("You are trying to restart a previous computation, "
-                             "but the restart file <"
-                             +
-                             parameters.output_directory + "restart.mesh"
-                             +
-                             "> does not appear to exist!"));
-
-    AssertThrow (Utilities::fexists(parameters.output_directory + "restart.resume.z", mpi_communicator),
-                 ExcMessage ("You are trying to restart a previous computation, "
-                             "but the restart file <"
-                             +
-                             parameters.output_directory + "restart.resume.z"
-                             +
-                             "> does not appear to exist!"));
-
-    pcout << "*** Resuming from snapshot!" << std::endl << std::endl;
-
-    // Read resume.z to set up the state of the model
-    try
-      {
-#ifdef DEAL_II_WITH_ZLIB
-        const std::string restart_data
-          = Utilities::read_and_distribute_file_content (parameters.output_directory + "restart.resume.z",
-                                                         mpi_communicator);
-
-        std::istringstream ifs (restart_data);
-
-        uint32_t compression_header[4];
-        ifs.read(reinterpret_cast<char *>(compression_header), 4 * sizeof(compression_header[0]));
-        Assert(compression_header[0]==1, ExcInternalError());
-
-        std::vector<char> compressed(compression_header[3]);
-        std::vector<char> uncompressed(compression_header[1]);
-        ifs.read(&compressed[0],compression_header[3]);
-        uLongf uncompressed_size = compression_header[1];
-
-        const int err = uncompress(reinterpret_cast<Bytef *>(&uncompressed[0]), &uncompressed_size,
-                                   reinterpret_cast<Bytef *>(&compressed[0]), compression_header[3]);
-        AssertThrow (err == Z_OK,
-                     ExcMessage (std::string("Uncompressing the data buffer resulted in an error with code <")
-                                 +
-                                 Utilities::int_to_string(err)));
-
-        {
-          std::istringstream ss;
-          ss.str(std::string (&uncompressed[0], uncompressed_size));
-
-          aspect::iarchive ia (ss);
-          load_and_check_critical_parameters(this->parameters, ia);
-          ia >> (*this);
-        }
-#else
-        AssertThrow (false,
-                     ExcMessage ("You need to have deal.II configured with the `libz' "
-                                 "option to support checkpoint/restart, but deal.II "
-                                 "did not detect its presence when you called `cmake'."));
-#endif
-      }
-    catch (std::exception &e)
-      {
-        AssertThrow (false,
-                     ExcMessage (std::string("Cannot seem to deserialize the data previously stored!\n")
-                                 +
-                                 "Some part of the machinery generated an exception that says:\n"
-                                 +
-                                 e.what()));
-      }
-
-    // now that we have resumed from the snapshot load the mesh and solution vectors
-    try
-      {
-        triangulation.load (parameters.output_directory + "restart.mesh");
-      }
-    catch (...)
-      {
-        AssertThrow(false, ExcMessage("Cannot open snapshot mesh file or read the triangulation stored there."));
-      }
-
-    // if using a cached mapping, update the cache with the new triangulation
-    if (MappingQCache<dim> *map = dynamic_cast<MappingQCache<dim>*>(&(*mapping)))
-      map->initialize(MappingQGeneric<dim>(4), triangulation);
-
-    setup_dofs();
-    global_volume = GridTools::volume (triangulation, *mapping);
-
-    LinearAlgebra::BlockVector distributed_system (system_rhs);
-    LinearAlgebra::BlockVector old_distributed_system (system_rhs);
-    LinearAlgebra::BlockVector old_old_distributed_system (system_rhs);
-    LinearAlgebra::BlockVector distributed_mesh_velocity (system_rhs);
-
-    std::vector<LinearAlgebra::BlockVector *> x_system
-      = { &distributed_system, &old_distributed_system, &old_old_distributed_system };
-
-    // If necessary, also include the mesh velocity for deserialization
-    // with the system dof handler
-    if (parameters.mesh_deformation_enabled)
-      x_system.push_back(&distributed_mesh_velocity);
-
-    parallel::distributed::SolutionTransfer<dim, LinearAlgebra::BlockVector>
-    system_trans (dof_handler);
-
-    system_trans.deserialize (x_system);
-
-    solution = distributed_system;
-    old_solution = old_distributed_system;
-    old_old_solution = old_old_distributed_system;
-
-    if (parameters.mesh_deformation_enabled)
-      {
-        // copy the mesh velocity which uses the system dof handler
-        mesh_deformation->mesh_velocity = distributed_mesh_velocity;
-
-        // deserialize and copy the vectors using the mesh deformation dof handler
-        parallel::distributed::SolutionTransfer<dim, LinearAlgebra::Vector> mesh_deformation_trans( mesh_deformation->mesh_deformation_dof_handler );
-        LinearAlgebra::Vector distributed_mesh_displacements( mesh_deformation->mesh_locally_owned,
-                                                              mpi_communicator );
-        LinearAlgebra::Vector distributed_initial_topography( mesh_deformation->mesh_locally_owned,
-                                                              mpi_communicator );
-        std::vector<LinearAlgebra::Vector *> fs_system
-        = { &distributed_mesh_displacements,
-            &distributed_initial_topography
-          };
-
-        mesh_deformation_trans.deserialize (fs_system);
-        mesh_deformation->mesh_displacements = distributed_mesh_displacements;
-        mesh_deformation->initial_topography = distributed_initial_topography;
-      }
-
-    signals.post_resume_load_user_data(triangulation);
-
-    // Overwrite the existing statistics file with the one that would have
-    // been current at the time of the snapshot we just read back in. We
-    // do this because the simulation that created the snapshot may have
-    // continued for a few more time steps. The operation here then
-    // effectively truncates the 'statistics' file to the position from
-    // which the current simulation is going to continue.
-    output_statistics();
-
-    // We have to compute the constraints here because the vector that tells
-    // us if a cell is a melt cell is not saved between restarts.
-    if (parameters.include_melt_transport)
-      {
-        initialize_current_linearization_point();
-        compute_current_constraints ();
-      }
-  }
-
-}
-
-//why do we need this?!
-BOOST_CLASS_TRACKING (aspect::Simulator<2>, boost::serialization::track_never)
-BOOST_CLASS_TRACKING (aspect::Simulator<3>, boost::serialization::track_never)
-
-
-namespace aspect
-{
-
-  template <int dim>
-  template <class Archive>
-  void Simulator<dim>::serialize (Archive &ar, const unsigned int)
-  {
-    ar &time;
-    ar &time_step;
-    ar &old_time_step;
-    ar &timestep_number;
-    ar &pre_refinement_step;
-    ar &last_pressure_normalization_adjustment;
-    ar &total_walltime_until_last_snapshot;
-
-    ar &postprocess_manager;
-
-    ar &statistics;
-
-    // We do not serialize the statistics_last_write_size and
-    // statistics_last_hash variables on purpose. This way, upon
-    // restart, they are left at the values initialized by the
-    // Simulator::Simulator() constructor, and this causes the
-    // Simulator::output_statistics() function to write the
-    // whole statistics file anew at the end of the first time
-    // step after restart. See there why this is the
-    // correct behavior after restart.
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template void Simulator<dim>::create_snapshot(); \
-  template void Simulator<dim>::resume_from_snapshot();
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/core.cc.bak b/source/simulator/core.cc.bak
deleted file mode 100644
index 76cac919a8f..00000000000
--- a/source/simulator/core.cc.bak
+++ /dev/null
@@ -1,2199 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/melt.h>
-#include <aspect/volume_of_fluid/handler.h>
-#include <aspect/newton.h>
-#include <aspect/stokes_matrix_free.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/citation_info.h>
-#include <aspect/postprocess/particles.h>
-
-#ifdef ASPECT_WITH_WORLD_BUILDER
-#include <world_builder/world.h>
-#endif
-
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-#include <aspect/material_model/rheology/elasticity.h>
-
-#include <deal.II/base/index_set.h>
-#include <deal.II/base/conditional_ostream.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/lac/block_sparsity_pattern.h>
-#include <deal.II/lac/sparsity_tools.h>
-#include <deal.II/grid/grid_tools.h>
-
-#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/dof_tools.h>
-
-#include <deal.II/fe/mapping_q.h>
-#include <deal.II/fe/mapping_cartesian.h>
-#include <deal.II/fe/mapping_q_cache.h>
-
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/derivative_approximation.h>
-#include <deal.II/numerics/vector_tools.h>
-
-#include <deal.II/distributed/solution_transfer.h>
-#include <deal.II/distributed/grid_refinement.h>
-
-#include <fstream>
-#include <iostream>
-#include <locale>
-#include <string>
-
-
-
-
-namespace aspect
-{
-  namespace
-  {
-    /**
-     * Helper function to construct the final std::vector of FEVariable before
-     * it is used to construct the Introspection object. Create the default
-     * setup based on parameters followed by a signal to allow modifications.
-     */
-    template <int dim>
-    std::vector<VariableDeclaration<dim>> construct_variables(const Parameters<dim> &parameters,
-                                                               SimulatorSignals<dim> &signals,
-                                                               std::unique_ptr<MeltHandler<dim>> &melt_handler)
-    {
-      std::vector<VariableDeclaration<dim>> variables
-        = construct_default_variables (parameters);
-      if (melt_handler)
-        melt_handler->edit_finite_element_variables (parameters, variables);
-
-      signals.edit_finite_element_variables(variables);
-      return variables;
-    }
-
-    /**
-     * Helper function to construct mapping for the model.
-     * The mapping is given by a degree four MappingQ for the case
-     * of a curved mesh, and a cartesian mapping for a rectangular mesh that is
-     * not deformed. Use a MappingQ1 if the initial mesh is deformed.
-     * If mesh deformation is enabled, each mapping is later swapped out for a
-     * MappingQ1Eulerian, which allows for mesh deformation during the
-     * computation.
-     */
-    template <int dim>
-    std::unique_ptr<Mapping<dim>>
-    construct_mapping(const GeometryModel::Interface<dim> &geometry_model,
-                      const InitialTopographyModel::Interface<dim> &initial_topography_model)
-    {
-      if (geometry_model.has_curved_elements())
-        return std::make_unique<MappingQCache<dim>>(4);
-
-      if (Plugins::plugin_type_matches<const InitialTopographyModel::ZeroTopography<dim>>(initial_topography_model))
-        return std::make_unique<MappingCartesian<dim>>();
-
-      return std::make_unique<MappingQ1<dim>>();
-    }
-  }
-
-
-  /**
-   * Constructor of the IntermediaryConstructorAction class. Since the
-   * class has no members, there is nothing to initialize -- all we
-   * need to do is execute the 'action' argument.
-   */
-  template <int dim>
-  Simulator<dim>::IntermediaryConstructorAction::
-  IntermediaryConstructorAction (const std::function<void ()> &action)
-  {
-    action();
-  }
-
-
-
-  /**
-   * Constructor. Initialize all member variables.
-   **/
-  template <int dim>
-  Simulator<dim>::Simulator (const MPI_Comm mpi_communicator_,
-                             ParameterHandler &prm)
-    :
-    simulator_is_past_initialization (false),
-    assemblers (std::make_unique<Assemblers::Manager<dim>>()),
-    parameters (prm, mpi_communicator_),
-    melt_handler (parameters.include_melt_transport ?
-                  std::make_unique<MeltHandler<dim>>(prm) :
-                  nullptr),
-    newton_handler (Parameters<dim>::is_defect_correction(parameters.nonlinear_solver) ?
-                    std::make_unique<NewtonHandler<dim>>() :
-                    nullptr),
-    post_signal_creation(
-      std::bind (&internals::SimulatorSignals::call_connector_functions<dim>,
-                 std::ref(signals))),
-    volume_of_fluid_handler (parameters.volume_of_fluid_tracking_enabled ?
-                             std::make_unique<VolumeOfFluidHandler<dim>> (*this, prm) :
-                             nullptr),
-    introspection (construct_variables<dim>(parameters, signals, melt_handler), parameters),
-    mpi_communicator (Utilities::MPI::duplicate_communicator (mpi_communicator_)),
-    iostream_tee_device(std::cout, log_file_stream),
-    iostream_tee_stream(iostream_tee_device),
-    pcout (iostream_tee_stream,
-           (Utilities::MPI::
-            this_mpi_process(mpi_communicator)
-            == 0)),
-
-    statistics_last_write_size (0),
-    statistics_last_hash (0),
-
-    computing_timer (mpi_communicator,
-                     pcout,
-                     TimerOutput::never,
-                     TimerOutput::wall_times),
-    total_walltime_until_last_snapshot(0.),
-    initial_topography_model(InitialTopographyModel::create_initial_topography_model<dim>(prm)),
-    geometry_model (GeometryModel::create_geometry_model<dim>(prm)),
-    // make sure the parameters object gets a chance to
-    // parse those parameters that depend on symbolic names
-    // for boundary components
-    post_geometry_model_creation_action (std::bind (&Parameters<dim>::parse_geometry_dependent_parameters,
-                                                    std::ref(parameters),
-                                                    std::ref(prm),
-                                                    std::cref(*geometry_model))),
-    material_model (MaterialModel::create_material_model<dim>(prm)),
-    gravity_model (GravityModel::create_gravity_model<dim>(prm)),
-    prescribed_stokes_solution (PrescribedStokesSolution::create_prescribed_stokes_solution<dim>(prm)),
-    adiabatic_conditions (AdiabaticConditions::create_adiabatic_conditions<dim>(prm)),
-#ifdef ASPECT_WITH_WORLD_BUILDER
-    world_builder (parameters.world_builder_file != "" ?
-                   std::make_shared<WorldBuilder::World>(parameters.world_builder_file) :
-                   nullptr),
-#endif
-    boundary_heat_flux (BoundaryHeatFlux::create_boundary_heat_flux<dim>(prm)),
-    particle_worlds(),
-    time (numbers::signaling_nan<double>()),
-    time_step (numbers::signaling_nan<double>()),
-    old_time_step (numbers::signaling_nan<double>()),
-    timestep_number (numbers::invalid_unsigned_int),
-    nonlinear_iteration (numbers::invalid_unsigned_int),
-
-    // We need to disable eliminate_refined_boundary_islands as this leads to
-    // a deadlock for deal.II <= 9.2.0 as described in
-    // https://github.com/geodynamics/aspect/issues/3604 when an
-    // refined_island is at a periodic boundary. This flag is not too
-    // important as it does not improve accuracy. Otherwise, these flags
-    // correspond to smoothing_on_refinement|smoothing_on_coarsening.
-    triangulation (mpi_communicator,
-                   static_cast<typename Triangulation<dim>::MeshSmoothing>
-                   (
-                     Triangulation<dim>::limit_level_difference_at_vertices |
-                     (Triangulation<dim>::eliminate_unrefined_islands |
-                      Triangulation<dim>::eliminate_refined_inner_islands |
-                      // Triangulation<dim>::eliminate_refined_boundary_islands |
-                      Triangulation<dim>::do_not_produce_unrefined_islands)
-                   )
-                   ,
-                   (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg ||
-                    parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::default_solver
-                    ?
-                    static_cast<typename parallel::distributed::Triangulation<dim>::Settings>
-                    (parallel::distributed::Triangulation<dim>::mesh_reconstruction_after_repartitioning |
-                     parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy)
-                    :
-                    parallel::distributed::Triangulation<dim>::mesh_reconstruction_after_repartitioning)),
-
-    mapping(construct_mapping<dim>(*geometry_model,*initial_topography_model)),
-
-    // define the finite element
-    finite_element(introspection.get_fes(), introspection.get_multiplicities()),
-
-    dof_handler (triangulation),
-
-    last_pressure_normalization_adjustment (numbers::signaling_nan<double>()),
-    pressure_scaling (numbers::signaling_nan<double>()),
-
-    rebuild_stokes_matrix (true),
-    assemble_newton_stokes_matrix (true),
-    assemble_newton_stokes_system (Parameters<dim>::is_defect_correction(parameters.nonlinear_solver)
-                                   ?
-                                   true
-                                   :
-                                   false),
-    rebuild_stokes_preconditioner (true)
-  {
-    wall_timer.start();
-
-    if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
-      {
-        // only open the log file on processor 0, the other processors won't be
-        // writing into the stream anyway
-        log_file_stream.open(parameters.output_directory + "log.txt",
-                             parameters.resume_computation ? std::ios_base::app : std::ios_base::out);
-
-        // we already printed the header to the screen, so here we just dump it
-        // into the log file.
-        print_aspect_header(log_file_stream);
-      }
-
-    // now that we have output set up, we can start timer sections
-    TimerOutput::Scope timer (computing_timer, "Initialization");
-
-
-    // if any plugin wants access to the Simulator by deriving from SimulatorAccess, initialize it and
-    // call the initialize() functions immediately after.
-    //
-    // up front, we can not know whether a plugin derives from
-    // SimulatorAccess. all we have is a pointer to the base class of
-    // each plugin type (the 'Interface' class in the namespace
-    // corresponding to each plugin type), but this base class is not
-    // derived from SimulatorAccess. in order to find out whether a
-    // concrete plugin derives from this base (interface) class AND
-    // the SimulatorAccess class via multiple inheritance, we need to
-    // do a sideways dynamic_cast to this putative sibling of the
-    // interface class, and investigate if the dynamic_cast
-    // succeeds. if it succeeds, the dynamic_cast returns a non-nullptr
-    // result, and we can test this in an if-statement. there is a nice
-    // idiom whereby we can write
-    //    if (SiblingClass *ptr = dynamic_cast<SiblingClass*>(ptr_to_base))
-    //      ptr->do_something()
-    // where we declare a variable *inside* the 'if' condition, and only
-    // enter the code block guarded by the 'if' in case the so-declared
-    // variable evaluates to something non-zero, which here means that
-    // the dynamic_cast succeeded and returned the address of the sibling
-    // object.
-    //
-    // we also need to let all models parse their parameters. this is done *after* setting
-    // up their SimulatorAccess base class so that they can query, for example, the
-    // geometry model's description of symbolic names for boundary parts. note that
-    // the geometry model is the only model whose run time parameters are already read
-    // at the time it is created
-    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(initial_topography_model.get()))
-      sim->initialize_simulator (*this);
-    initial_topography_model->initialize ();
-
-    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(geometry_model.get()))
-      sim->initialize_simulator (*this);
-    geometry_model->initialize ();
-
-    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(material_model.get()))
-      sim->initialize_simulator (*this);
-    material_model->parse_parameters (prm);
-    material_model->initialize ();
-
-    // Make sure that the material model supports elasticity when it is requested,
-    // by checking that the material model creates the necessary material model
-    // outputs.
-    if (parameters.enable_elasticity)
-      {
-        // Set up outputs for one point
-        MaterialModel::MaterialModelOutputs<dim> out(1,
-                                                     introspection.n_compositional_fields);
-
-        material_model->create_additional_named_outputs(out);
-
-        MaterialModel::ElasticAdditionalOutputs<dim> *elastic_outputs = out.template get_additional_output<MaterialModel::ElasticAdditionalOutputs<dim>>();
-
-        // Throw if the elastic_outputs do not exist
-        AssertThrow(elastic_outputs != nullptr,
-                    ExcMessage("Elasticity is enabled, but not supported by the material model."));
-      }
-
-    heating_model_manager.initialize_simulator(*this);
-    heating_model_manager.parse_parameters (prm);
-
-    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(gravity_model.get()))
-      sim->initialize_simulator (*this);
-    gravity_model->parse_parameters (prm);
-    gravity_model->initialize ();
-
-    // Create the initial temperature and condition plugins, and then
-    // initialize them. Some of these objects store std::shared_ptrs
-    // to the initial temperature and composition objects, so it is
-    // important that we have the pointers of the current class
-    // already set by the time we call the initialize() functions.
-    initial_temperature_manager
-      = std::make_shared<InitialTemperature::Manager<dim>>();
-    initial_composition_manager
-      = std::make_shared<InitialComposition::Manager<dim>>();
-
-    initial_temperature_manager->initialize_simulator(*this);
-    initial_temperature_manager->parse_parameters (prm);
-
-    initial_composition_manager->initialize_simulator(*this);
-    initial_composition_manager->parse_parameters (prm);
-
-    // Create a boundary temperature manager
-    boundary_temperature_manager.initialize_simulator (*this);
-    boundary_temperature_manager.parse_parameters (prm);
-
-    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(boundary_heat_flux.get()))
-      sim->initialize_simulator (*this);
-    boundary_heat_flux->parse_parameters (prm);
-    boundary_heat_flux->initialize ();
-
-    // Create a boundary composition manager
-    boundary_composition_manager.initialize_simulator (*this);
-    boundary_composition_manager.parse_parameters (prm);
-
-    boundary_velocity_manager.initialize_simulator (*this);
-    boundary_velocity_manager.parse_parameters (prm);
-
-    // Make sure we only have a prescribed Stokes plugin if needed
-    if (parameters.nonlinear_solver == NonlinearSolver::single_Advection_no_Stokes)
-      {
-        AssertThrow(prescribed_stokes_solution.get()!=nullptr,
-                    ExcMessage("For the 'single Advection, no Stokes' solver scheme you need to provide a Stokes plugin!")
-                   );
-      }
-    else
-      {
-        AssertThrow(prescribed_stokes_solution.get()==nullptr,
-                    ExcMessage("The prescribed stokes plugin you selected only works with the solver "
-                               "scheme 'single Advection, no Stokes'.")
-                   );
-      }
-
-    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(prescribed_stokes_solution.get()))
-      sim->initialize_simulator (*this);
-    if (prescribed_stokes_solution.get())
-      {
-        prescribed_stokes_solution->parse_parameters (prm);
-        prescribed_stokes_solution->initialize ();
-      }
-
-
-    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(adiabatic_conditions.get()))
-      sim->initialize_simulator (*this);
-    adiabatic_conditions->parse_parameters (prm);
-    adiabatic_conditions->initialize ();
-
-    // Create a boundary traction manager
-    boundary_traction_manager.initialize_simulator (*this);
-    boundary_traction_manager.parse_parameters (prm);
-
-    // Initialize the mesh deformation handler
-    if (parameters.mesh_deformation_enabled)
-      {
-        // Models with deformed boundaries require
-        // the full A block to converge consistently
-        parameters.use_full_A_block_preconditioner = true;
-
-        // Allocate the MeshDeformationHandler object
-        mesh_deformation = std::make_unique<MeshDeformation::MeshDeformationHandler<dim>>(*this);
-        mesh_deformation->initialize_simulator(*this);
-        mesh_deformation->parse_parameters(prm);
-        mesh_deformation->initialize();
-      }
-
-    // Initialize the melt handler
-    if (parameters.include_melt_transport)
-      {
-        // Models with melt transport require
-        // the full A block to converge consistently
-        parameters.use_full_A_block_preconditioner = true;
-
-        melt_handler->initialize_simulator (*this);
-        melt_handler->initialize();
-      }
-
-    // If the solver type is a Newton or defect correction type of solver, we need to set make sure
-    // assemble_newton_stokes_system set to true.
-    if (Parameters<dim>::is_defect_correction(parameters.nonlinear_solver))
-      {
-        assemble_newton_stokes_system = true;
-        newton_handler->initialize_simulator(*this);
-        newton_handler->parameters.parse_parameters(prm);
-      }
-
-    // choose the default solver and averaging scheme
-    select_default_solver_and_averaging();
-
-    if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
-      {
-        switch (parameters.stokes_velocity_degree)
-          {
-            case 2:
-              stokes_matrix_free = std::make_unique<StokesMatrixFreeHandlerImplementation<dim,2>>(*this, prm);
-              break;
-            case 3:
-              stokes_matrix_free = std::make_unique<StokesMatrixFreeHandlerImplementation<dim,3>>(*this, prm);
-              break;
-            default:
-              AssertThrow(false, ExcMessage("The finite element degree for the Stokes system you selected is not supported yet."));
-          }
-
-      }
-
-    postprocess_manager.initialize_simulator (*this);
-    postprocess_manager.parse_parameters (prm);
-
-    if (postprocess_manager.template has_matching_postprocessor<Postprocess::Particles<dim>>())
-      {
-        particle_worlds.emplace_back(std::move(std::make_unique<Particle::World<dim>>()));
-        for (unsigned int particle_world_index = 0 ; particle_world_index < particle_worlds.size(); ++particle_world_index)
-          {
-            if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(particle_worlds[particle_world_index].get()))
-              sim->initialize_simulator (*this);
-
-            particle_worlds.back()->parse_parameters(prm,particle_world_index);
-            particle_worlds.back()->initialize();
-
-          }
-      }
-
-    mesh_refinement_manager.initialize_simulator (*this);
-    mesh_refinement_manager.parse_parameters (prm);
-
-    // VoF Must be initialized after mesh_refinement_manager, due to needing to check
-    // for a mesh refinement strategy
-    if (parameters.volume_of_fluid_tracking_enabled)
-      {
-        volume_of_fluid_handler->initialize (prm);
-      }
-
-    time_stepping_manager.initialize_simulator (*this);
-    time_stepping_manager.parse_parameters (prm);
-
-    lateral_averaging.initialize_simulator (*this);
-
-    geometry_model->create_coarse_mesh (triangulation);
-    Assert (triangulation.all_reference_cells_are_hyper_cube(),
-            ExcMessage ("ASPECT only supports meshes that are composed of quadrilateral "
-                        "or hexahedral cells."));
-    global_Omega_diameter = GridTools::diameter (triangulation);
-
-    // After creating the coarse mesh, initialize mapping cache if one is used
-    if (MappingQCache<dim> *map = dynamic_cast<MappingQCache<dim>*>(&(*mapping)))
-      map->initialize(MappingQGeneric<dim>(4), triangulation);
-
-    bool bp_limiter_enabled = (parameters.limiter_for_discontinuous_temperature_solution
-                               == Parameters<dim>::DGLimiterType::bound_preserving);
-    for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-      bp_limiter_enabled = bp_limiter_enabled || (parameters.limiter_for_discontinuous_composition_solution[c]
-                                                  == Parameters<dim>::DGLimiterType::bound_preserving);
-
-    // Check that BP limiters are only used with cartesian mapping
-    if (bp_limiter_enabled)
-      AssertThrow(geometry_model->natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian,
-                  ExcMessage("The bound preserving limiter for the discontinuous temperature and composition solutions "
-                             "has not been tested in non-Cartesian geometries and currently requires "
-                             "the use of a Cartesian geometry model."));
-
-    std::set<types::boundary_id> open_velocity_boundary_indicators
-      = geometry_model->get_used_boundary_indicators();
-    for (const auto &p : boundary_velocity_manager.get_active_boundary_velocity_names())
-      open_velocity_boundary_indicators.erase (p.first);
-    for (const auto p : boundary_velocity_manager.get_zero_boundary_velocity_indicators())
-      open_velocity_boundary_indicators.erase (p);
-    for (const auto p : boundary_velocity_manager.get_tangential_boundary_velocity_indicators())
-      open_velocity_boundary_indicators.erase (p);
-
-    // Make sure that we do the pressure right-hand side modification correctly for periodic boundaries
-    using periodic_boundary_set
-      = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
-    periodic_boundary_set pbs = geometry_model->get_periodic_boundary_pairs();
-    for (const auto &pb : pbs)
-      {
-        open_velocity_boundary_indicators.erase (pb.first.first);
-        open_velocity_boundary_indicators.erase (pb.first.second);
-      }
-
-    // We need to do the RHS compatibility modification, if the model is
-    // compressible or compatible (in the case of melt transport), and
-    // there is no open boundary to balance the pressure.
-    do_pressure_rhs_compatibility_modification = ((material_model->is_compressible() && !parameters.include_melt_transport)
-                                                  ||
-                                                  (parameters.include_melt_transport && !material_model->is_compressible())
-                                                  || parameters.enable_prescribed_dilation)
-                                                 &&
-                                                 (open_velocity_boundary_indicators.size() == 0);
-
-    // make sure that we don't have to fill every column of the statistics
-    // object in each time step.
-    statistics.set_auto_fill_mode(true);
-
-    // finally produce a record of the run-time parameters by writing
-    // the currently used values into a file
-    // Only write the parameter files on the root node to avoid file system conflicts
-    if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
-      {
-        std::ofstream prm_out ((parameters.output_directory + "parameters.prm"));
-        AssertThrow (prm_out,
-                     ExcMessage (std::string("Could not open file <") +
-                                 parameters.output_directory + "parameters.prm>."));
-        prm.print_parameters(prm_out, ParameterHandler::Text);
-
-        std::ofstream json_out ((parameters.output_directory + "parameters.json"));
-        AssertThrow (json_out,
-                     ExcMessage (std::string("Could not open file <") +
-                                 parameters.output_directory + "parameters.json>."));
-        prm.print_parameters(json_out, ParameterHandler::JSON);
-      }
-
-    // check that the boundary condition selection is consistent
-    check_consistency_of_boundary_conditions();
-
-    // check that the setup of equations, material models, and heating terms is consistent
-    check_consistency_of_formulation();
-
-    if (parameters.use_discontinuous_temperature_discretization || parameters.have_discontinuous_composition_discretization)
-      CitationInfo::add("dg");
-
-    // now that all member variables have been set up, also
-    // connect the functions that will actually do the assembly
-    set_assemblers();
-  }
-
-
-  /**
-   * Destructor.
-   */
-  template <int dim>
-  Simulator<dim>::~Simulator ()
-  {
-    // The particle_world object is declared before the triangulation, and so
-    // is destroyed after the latter. But it stores a pointer to the
-    // triangulation and uses it during destruction. This results in
-    // trouble. So destroy it first.
-
-    for (auto &particle_world : particle_worlds)
-      particle_world.reset();
-
-    // wait if there is a thread that's still writing the statistics
-    // object (set from the output_statistics() function)
-    if (output_statistics_thread.joinable())
-      output_statistics_thread.join();
-
-    // If an exception is being thrown (for example due to AssertThrow()), we
-    // might end up here with currently active timing sections. The destructor
-    // of TimerOutput does MPI communication, which can lead to deadlocks,
-    // hangs, or confusing MPI error messages. To avoid this, we can call
-    // reset() to remove all open sections. In a normal run, we won't have any
-    // active sessions, so this won't hurt to do:
-    computing_timer.reset();
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  start_timestep ()
-  {
-    // first produce some output for the screen to show where we are
-    {
-      const char *unit = (parameters.convert_to_years ? "years" : "seconds");
-      const double multiplier = (parameters.convert_to_years ? 1./year_in_seconds : 1.0);
-
-      pcout << "*** Timestep " << timestep_number
-            << ":  t=" << (time * multiplier) << ' ' << unit
-            << ", dt=" << (time_step * multiplier) << ' ' << unit
-            << std::endl;
-    }
-
-    nonlinear_iteration = 0;
-
-    signals.start_timestep(*this);
-
-    // Copy particle handler to restore particle location and properties
-    // before repeating a timestep
-    for (auto &particle_world : particle_worlds)
-      particle_world->backup_particles();
-
-
-    // then interpolate the current boundary velocities. copy constraints
-    // into current_constraints and then add to current_constraints
-    compute_current_constraints ();
-
-    // If needed, construct sparsity patterns and matrices with the current
-    // constraints. Of course we need to force assembly too.
-    if (rebuild_sparsity_and_matrices)
-      {
-        TimerOutput::Scope timer (computing_timer, "Setup matrices");
-
-        rebuild_sparsity_and_matrices = false;
-        setup_system_matrix (introspection.index_sets.system_partitioning);
-        setup_system_preconditioner (introspection.index_sets.system_partitioning);
-        rebuild_stokes_matrix = rebuild_stokes_preconditioner = true;
-      }
-
-    // notify different system components that we started the next time step
-    // TODO: implement this for all plugins that might need it at one place.
-    // Temperature BC are currently updated in compute_current_constraints
-    geometry_model->update();
-    material_model->update();
-    gravity_model->update();
-    heating_model_manager.update();
-    adiabatic_conditions->update();
-    mesh_refinement_manager.update();
-    if (parameters.mesh_deformation_enabled)
-      mesh_deformation->update();
-
-    if (prescribed_stokes_solution.get())
-      prescribed_stokes_solution->update();
-
-    for (auto &particle_world : particle_worlds)
-      particle_world->update();
-
-    // do the same for the traction boundary conditions and other things
-    // that end up in the bilinear form. we update those that end up in
-    // the constraints object when calling compute_current_constraints()
-    // above
-    boundary_traction_manager.update();
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  compute_current_constraints ()
-  {
-    // We put the constraints we compute into a separate AffineConstraints<double> so we can check
-    // if the set of constraints has changed. If it did, we need to update the sparsity patterns.
-    AffineConstraints<double> new_current_constraints(
-#if DEAL_II_VERSION_GTE(9,6,0)
-      dof_handler.locally_owned_dofs(),
-#endif
-      introspection.index_sets.system_relevant_set
-    );
-    new_current_constraints.merge (constraints);
-    compute_current_velocity_boundary_constraints(new_current_constraints);
-
-    // If there is a fixed boundary temperature or heat flux,
-    // update the temperature boundary condition.
-    boundary_temperature_manager.update();
-    boundary_heat_flux->update();
-
-    // If we do not want to prescribe Dirichlet boundary conditions on outflow boundaries,
-    // we update the boundary indicators of all faces that belong to outflow boundaries
-    // so that they are not in the list of fixed temperature boundary indicators any more.
-    // We will undo this change in a later step, after the constraints have been set.
-    // As long as we allow deal.II 8.5, we can not have boundary ids of more than 256,
-    // so we want to offset them by 128 and not allow more than 128 boundary ids.
-    const unsigned int boundary_id_offset = 128;
-    if (!boundary_temperature_manager.allows_fixed_temperature_on_outflow_boundaries())
-      replace_outflow_boundary_ids(boundary_id_offset);
-
-    // if using continuous temperature FE, do the same for the temperature variable:
-    // evaluate the current boundary temperature and add these constraints as well
-    if (!parameters.use_discontinuous_temperature_discretization)
-      {
-        // obtain the boundary indicators that belong to Dirichlet-type
-        // temperature boundary conditions and interpolate the temperature
-        // there
-        for (const auto p : boundary_temperature_manager.get_fixed_temperature_boundary_indicators())
-          {
-            VectorFunctionFromScalarFunctionObject<dim> vector_function_object(
-              [&] (const dealii::Point<dim> &x) -> double
-            {
-              return boundary_temperature_manager.boundary_temperature(p, x);
-            },
-            introspection.component_masks.temperature.first_selected_component(),
-            introspection.n_components);
-
-            VectorTools::interpolate_boundary_values (*mapping,
-                                                      dof_handler,
-                                                      p,
-                                                      vector_function_object,
-                                                      new_current_constraints,
-                                                      introspection.component_masks.temperature);
-          }
-      }
-
-    if (!boundary_temperature_manager.allows_fixed_temperature_on_outflow_boundaries())
-      restore_outflow_boundary_ids(boundary_id_offset);
-
-    // If there are fixed boundary compositions,
-    // update the composition boundary condition.
-    boundary_composition_manager.update();
-
-    // If we do not want to prescribe Dirichlet boundary conditions on outflow boundaries,
-    // use the same trick for marking up outflow boundary conditions for compositional fields
-    // as we did above already for the temperature.
-    if (!boundary_composition_manager.allows_fixed_composition_on_outflow_boundaries())
-      replace_outflow_boundary_ids(boundary_id_offset);
-
-    // now do the same for the composition variables:
-    {
-      // obtain the boundary indicators that belong to Dirichlet-type
-      // composition boundary conditions and interpolate the composition
-      // there
-      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-        if (parameters.use_discontinuous_composition_discretization[c] == false)
-          for (const auto p : boundary_composition_manager.get_fixed_composition_boundary_indicators())
-            {
-              VectorFunctionFromScalarFunctionObject<dim> vector_function_object(
-                [&] (const Point<dim> &x) -> double
-              {
-                return boundary_composition_manager.boundary_composition(p, x, c);
-              },
-              introspection.component_masks.compositional_fields[c].first_selected_component(),
-              introspection.n_components);
-
-              VectorTools::interpolate_boundary_values (*mapping,
-                                                        dof_handler,
-                                                        p,
-                                                        vector_function_object,
-                                                        new_current_constraints,
-                                                        introspection.component_masks.compositional_fields[c]);
-            }
-    }
-
-    if (!boundary_composition_manager.allows_fixed_composition_on_outflow_boundaries())
-      restore_outflow_boundary_ids(boundary_id_offset);
-
-    if (parameters.include_melt_transport)
-      melt_handler->add_current_constraints (new_current_constraints);
-
-    // let plugins add more constraints if they so choose, then close the
-    // constraints object
-    signals.post_constraints_creation(*this, new_current_constraints);
-
-    new_current_constraints.close();
-
-    // Now check if the current_constraints we just computed changed from before. Do this before the melt handler
-    // adds constraints for the melt cells, because they are allowed to change (and often do) without us having
-    // to reinit the sparsity pattern.
-    // If the mesh got refined and the size of the linear system changed, the old and new constraint
-    // matrices will have different entries, and we can not easily compare them.
-    // Note that we can have a situation where mesh_has_changed==true on only some of the machines,
-    // so we need to do the MPI::sum below in all cases to avoid a deadlock.
-    const bool mesh_has_changed = (current_constraints.get_local_lines().size()
-                                   != new_current_constraints.get_local_lines().size())
-                                  ||
-                                  (current_constraints.get_local_lines()
-                                   != new_current_constraints.get_local_lines());
-    // Figure out if any entry that was constrained before is now no longer constrained:
-    bool constraints_changed = false;
-
-    if (mesh_has_changed)
-      {
-        // The mesh changed, so we know we need to update the constraints:
-        constraints_changed = true;
-      }
-    else
-      {
-        // the mesh has not changed on our machine, so compare the constraints:
-        for (auto &row: current_constraints.get_lines())
-          {
-            if (!new_current_constraints.is_constrained(row.index))
-              {
-                constraints_changed = true;
-                break;
-              }
-          }
-      }
-
-    // If at least one processor has different constraints, force rebuilding the matrices:
-    const bool any_constrained_dofs_set_changed = (Utilities::MPI::sum(constraints_changed ? 1 : 0,
-                                                                       mpi_communicator)
-                                                   > 0);
-    if (any_constrained_dofs_set_changed)
-      rebuild_sparsity_and_matrices = true;
-
-#if DEAL_II_VERSION_GTE(9,6,0)
-    current_constraints = std::move(new_current_constraints);
-#else
-    current_constraints.reinit (introspection.index_sets.system_relevant_set);
-    current_constraints.copy_from(new_current_constraints);
-#endif
-    current_constraints.close();
-
-    // TODO: We should use current_constraints.is_consistent_in_parallel()
-    // here to assert that our constraints are consistent between
-    // processors. This got removed in
-    // https://github.com/geodynamics/aspect/pull/3282 because it triggered in
-    // normal computations due to small floating point differences. See
-    // https://github.com/geodynamics/aspect/issues/3248 for the discussion.
-  }
-
-
-
-  namespace
-  {
-    template <int dim>
-    bool solver_scheme_solves_advection_equations(const Parameters<dim> &parameters)
-    {
-      // Check if we use a solver scheme that solves the advection equations
-      switch (parameters.nonlinear_solver)
-        {
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_single_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_defect_correction_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_defect_correction_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_defect_correction_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Newton_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Newton_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_no_Stokes:
-            return true;
-
-          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_single_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::first_timestep_only_single_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_no_Stokes:
-            return false;
-        }
-      Assert(false, ExcNotImplemented());
-      return false;
-    }
-
-
-
-    template <int dim>
-    bool solver_scheme_solves_stokes_equations(const Parameters<dim> &parameters)
-    {
-      // Check if we use a solver scheme that solves the Stokes equations
-      switch (parameters.nonlinear_solver)
-        {
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_single_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_single_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_iterated_defect_correction_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_defect_correction_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_defect_correction_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::iterated_Advection_and_Newton_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_iterated_Newton_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::first_timestep_only_single_Stokes:
-            return true;
-
-          case Parameters<dim>::NonlinearSolver::Kind::single_Advection_no_Stokes:
-          case Parameters<dim>::NonlinearSolver::Kind::no_Advection_no_Stokes:
-            return false;
-        }
-      Assert(false, ExcNotImplemented());
-      return false;
-    }
-
-
-
-    template <int dim>
-    bool compositional_field_needs_matrix_block(const Introspection<dim> &introspection, const unsigned int composition_index)
-    {
-      const typename Simulator<dim>::AdvectionField adv_field (Simulator<dim>::AdvectionField::composition(composition_index));
-      switch (adv_field.advection_method(introspection))
-        {
-          case Parameters<dim>::AdvectionFieldMethod::fem_field:
-          case Parameters<dim>::AdvectionFieldMethod::fem_melt_field:
-          case Parameters<dim>::AdvectionFieldMethod::fem_darcy_field:
-          case Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion:
-            return true;
-          case Parameters<dim>::AdvectionFieldMethod::particles:
-          case Parameters<dim>::AdvectionFieldMethod::volume_of_fluid:
-          case Parameters<dim>::AdvectionFieldMethod::static_field:
-          case Parameters<dim>::AdvectionFieldMethod::prescribed_field:
-            break;
-          default:
-            Assert (false, ExcNotImplemented());
-        }
-      return false;
-    }
-
-
-
-    template <int dim>
-    bool compositional_fields_need_matrix_block(const Introspection<dim> &introspection)
-    {
-      // Check if any compositional field method actually requires a matrix block
-      // (as opposed to all are advected by other means or prescribed fields)
-      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-        {
-          if (compositional_field_needs_matrix_block(introspection, c))
-            return true;
-        }
-      return false;
-    }
-  }
-
-
-
-  template <int dim>
-  Table<2,DoFTools::Coupling>
-  Simulator<dim>::
-  setup_system_matrix_coupling () const
-  {
-    Table<2,DoFTools::Coupling> coupling(introspection.n_components,
-                                         introspection.n_components);
-
-    // Start by assuming nothing couples
-    coupling.fill (DoFTools::none);
-
-    const typename Introspection<dim>::ComponentIndices &x
-      = introspection.component_indices;
-
-    // Determine which blocks in the Stokes blocks
-    // of the matrix are in use. At the moment this distinguishes
-    // 3 solvers: melt transport, matrix-free multigrid, and the default
-    // matrix based algebraic multigrid.
-    if (solver_scheme_solves_stokes_equations(parameters))
-      {
-        // The matrix-free solver does not work with melt transport
-        Assert(!(parameters.include_melt_transport && stokes_matrix_free),
-               ExcNotImplemented());
-
-        if (stokes_matrix_free)
-          {
-            // nothing couples in the matrix free solver
-          }
-        else if (parameters.include_melt_transport)
-          {
-            // For the melt transport solver all velocities and pressures couple with themselves.
-            // Additionally solid velocities couple with all pressures, and all pressures
-            // couple with solid velocities.
-
-            const unsigned int first_fluid_c_i = introspection.variable("fluid velocity").first_component_index;
-
-            for (unsigned int d=0; d<dim; ++d)
-              {
-                for (unsigned int c=0; c<dim; ++c)
-                  {
-                    coupling[x.velocities[c]][x.velocities[d]] = DoFTools::always;
-                    coupling[first_fluid_c_i+c][first_fluid_c_i+d] = DoFTools::always;
-                  }
-
-                coupling[x.velocities[d]][
-                  introspection.variable("compaction pressure").first_component_index] = DoFTools::always;
-                coupling[introspection.variable("compaction pressure").first_component_index]
-                [x.velocities[d]]
-                  = DoFTools::always;
-                coupling[x.velocities[d]]
-                [introspection.variable("fluid pressure").first_component_index]
-                  = DoFTools::always;
-                coupling[introspection.variable("fluid pressure").first_component_index]
-                [x.velocities[d]]
-                  = DoFTools::always;
-              }
-
-            coupling[introspection.variable("fluid pressure").first_component_index]
-            [introspection.variable("fluid pressure").first_component_index]
-              = DoFTools::always;
-            coupling[introspection.variable("compaction pressure").first_component_index]
-            [introspection.variable("compaction pressure").first_component_index]
-              = DoFTools::always;
-          }
-        else
-          {
-            // The AMG matrix based solver: all velocities couple with all velocities,
-            // pressure couples with all velocities and the other way around,
-            // and pressures only couple with themselves for equal order elements
-            for (unsigned int c=0; c<dim; ++c)
-              for (unsigned int d=0; d<dim; ++d)
-                coupling[x.velocities[c]][x.velocities[d]] = DoFTools::always;
-
-            for (unsigned int d=0; d<dim; ++d)
-              {
-                coupling[x.velocities[d]][x.pressure] = DoFTools::always;
-                coupling[x.pressure][x.velocities[d]] = DoFTools::always;
-              }
-
-            // For equal-order interpolation, we need a stabilization term
-            // in the bottom right of Stokes matrix. Make sure we have the
-            // necessary entries.
-            if (parameters.use_equal_order_interpolation_for_stokes == true)
-              coupling[x.pressure][x.pressure] = DoFTools::always;
-          }
-      }
-
-    // Only enable temperature coupling if temperature block is needed
-    if (solver_scheme_solves_advection_equations(parameters)
-        &&
-        parameters.temperature_method != Parameters<dim>::AdvectionFieldMethod::prescribed_field
-        &&
-        parameters.temperature_method != Parameters<dim>::AdvectionFieldMethod::static_field)
-      coupling[x.temperature][x.temperature] = DoFTools::always;
-
-    // Only enable composition coupling if a composition block is needed
-    if (solver_scheme_solves_advection_equations(parameters)
-        &&
-        compositional_fields_need_matrix_block(introspection))
-      {
-        // We reuse matrix blocks for compositional fields, but we need different blocks for each base_element.
-        // All other matrix blocks are left empty to save memory.
-        for (const unsigned int base_element_index : introspection.get_composition_base_element_indices())
-          {
-            bool block_needed = false;
-            for (const unsigned int c : introspection.get_compositional_field_indices_with_base_element(base_element_index))
-              if (compositional_field_needs_matrix_block(introspection, c))
-                block_needed = true;
-
-            if (block_needed)
-              {
-                const unsigned int first_c = introspection.get_compositional_field_indices_with_base_element(base_element_index).front();
-                coupling[x.compositional_fields[first_c]][x.compositional_fields[first_c]] = DoFTools::always;
-              }
-          }
-      }
-
-    // If we are using volume of fluid interface tracking, create a matrix block in the
-    // field corresponding to the volume fraction.
-    if (parameters.volume_of_fluid_tracking_enabled)
-      {
-        const unsigned int volume_of_fluid_block = volume_of_fluid_handler->field_struct_for_field_index(0)
-                                                   .volume_fraction.first_component_index;
-        coupling[volume_of_fluid_block][volume_of_fluid_block] = DoFTools::always;
-      }
-
-    return coupling;
-  }
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  setup_system_matrix (const std::vector<IndexSet> &system_partitioning)
-  {
-    system_matrix.clear ();
-
-    const Table<2,DoFTools::Coupling> coupling = setup_system_matrix_coupling();
-    LinearAlgebra::BlockDynamicSparsityPattern sp;
-
-    sp.reinit (system_partitioning,
-               system_partitioning,
-               introspection.index_sets.system_relevant_partitioning,
-               mpi_communicator);
-
-
-    if ((parameters.use_discontinuous_temperature_discretization) ||
-        (parameters.have_discontinuous_composition_discretization) ||
-        (parameters.volume_of_fluid_tracking_enabled))
-      {
-        Table<2,DoFTools::Coupling> face_coupling (introspection.n_components,
-                                                   introspection.n_components);
-        face_coupling.fill (DoFTools::none);
-
-        const typename Introspection<dim>::ComponentIndices &x
-          = introspection.component_indices;
-        if (parameters.use_discontinuous_temperature_discretization &&
-            solver_scheme_solves_advection_equations(parameters) &&
-            parameters.temperature_method != Parameters<dim>::AdvectionFieldMethod::prescribed_field &&
-            parameters.temperature_method != Parameters<dim>::AdvectionFieldMethod::static_field)
-          face_coupling[x.temperature][x.temperature] = DoFTools::always;
-
-        for (const unsigned int base_element_index : introspection.get_composition_base_element_indices())
-          {
-            bool block_needed = false;
-            for (const unsigned int c : introspection.get_compositional_field_indices_with_base_element(base_element_index))
-              if (compositional_field_needs_matrix_block(introspection, c))
-                block_needed = true;
-
-            const unsigned int first_c = introspection.get_compositional_field_indices_with_base_element(base_element_index).front();
-
-            if (parameters.use_discontinuous_composition_discretization[first_c]
-                && solver_scheme_solves_advection_equations(parameters)
-                && block_needed)
-              face_coupling[x.compositional_fields[first_c]][x.compositional_fields[first_c]] = DoFTools::always;
-          }
-
-        if (parameters.volume_of_fluid_tracking_enabled)
-          {
-            const unsigned int volume_of_fluid_block = volume_of_fluid_handler->field_struct_for_field_index(0)
-                                                       .volume_fraction.first_component_index;
-            face_coupling[volume_of_fluid_block][volume_of_fluid_block] = DoFTools::always;
-          }
-
-        DoFTools::make_flux_sparsity_pattern (dof_handler,
-                                              sp,
-                                              current_constraints, false,
-                                              coupling,
-                                              face_coupling,
-                                              Utilities::MPI::
-                                              this_mpi_process(mpi_communicator));
-
-        if (solver_scheme_solves_advection_equations(parameters))
-          {
-            // If we solve for more than one compositional field make sure we keep constrained entries
-            // to allow different boundary conditions for different fields. In order to keep constrained
-            // entries we need to repeat the call to DoFTools::make_flux_sparsity_pattern above,
-            // but with 'true' as 4th argument, and only for the composition block.
-            Table<2,DoFTools::Coupling> composition_coupling(introspection.n_components,
-                                                             introspection.n_components);
-            composition_coupling.fill (DoFTools::none);
-
-            for (const unsigned int base_element_index : introspection.get_composition_base_element_indices())
-              {
-                const unsigned int first_c = introspection.get_compositional_field_indices_with_base_element(base_element_index).front();
-                const unsigned int component = x.compositional_fields[first_c];
-                composition_coupling[component][component] = coupling[component][component];
-
-                const unsigned int block = introspection.block_indices.compositional_field_sparsity_pattern[first_c];
-                sp.block(block,block).reinit(sp.block(block,block).locally_owned_range_indices(),
-                                             sp.block(block,block).locally_owned_domain_indices());
-
-                DoFTools::make_flux_sparsity_pattern (dof_handler,
-                                                      sp,
-                                                      current_constraints, true,
-                                                      composition_coupling,
-                                                      face_coupling,
-                                                      Utilities::MPI::
-                                                      this_mpi_process(mpi_communicator));
-              }
-          }
-      }
-    else
-      {
-        DoFTools::make_sparsity_pattern (dof_handler,
-                                         coupling, sp,
-                                         current_constraints, false,
-                                         Utilities::MPI::
-                                         this_mpi_process(mpi_communicator));
-
-        // If we solve for more than one compositional field make sure we keep constrained entries
-        // to allow different boundary conditions for different fields. In order to keep constrained
-        // entries we need to repeat the call to DoFTools::make_sparsity_pattern above,
-        // but with 'true' as 4th argument, and only for the composition block.
-        if (solver_scheme_solves_advection_equations(parameters)
-            &&
-            compositional_fields_need_matrix_block(introspection))
-          {
-            Table<2,DoFTools::Coupling> composition_coupling(introspection.n_components,
-                                                             introspection.n_components);
-            composition_coupling.fill (DoFTools::none);
-
-            const unsigned int component = introspection.component_indices.compositional_fields[0];
-            composition_coupling[component][component] = coupling[component][component];
-
-            const unsigned int block = introspection.get_components_to_blocks()[component];
-            sp.block(block,block).reinit(sp.block(block,block).locally_owned_range_indices(),
-                                         sp.block(block,block).locally_owned_domain_indices());
-
-            DoFTools::make_sparsity_pattern (dof_handler,
-                                             composition_coupling, sp,
-                                             current_constraints, true,
-                                             Utilities::MPI::
-                                             this_mpi_process(mpi_communicator));
-          }
-      }
-
-    sp.compress();
-
-    // We may only allocate some of the matrix blocks, but the sparsity pattern
-    // will still create entries for hanging nodes and boundary conditions.
-    // These are unnecessary and are removed here.
-    for (unsigned int i=0; i<introspection.n_components; ++i)
-      {
-        if (coupling[i][i] == DoFTools::none)
-          {
-            // The pressure is special, because it does not couple with itself,
-            // but if the velocity block is assembled we also need to keep pressure
-            // hanging node constraints. Thus skip clearing the
-            // sparsity pattern in that case.
-            if ((i == introspection.component_indices.pressure) &&
-                coupling[introspection.component_indices.velocities[0]][introspection.component_indices.velocities[0]] != DoFTools::none)
-              continue;
-
-            const unsigned int block = introspection.get_components_to_blocks()[i];
-
-            // TODO: using clear() would be nice here but clear() also resets the
-            // size, so just reinit():
-            sp.block(block,block).reinit(sp.block(block,block).locally_owned_range_indices(),
-                                         sp.block(block,block).locally_owned_domain_indices());
-            sp.block(block,block).compress();
-          }
-      }
-
-    system_matrix.reinit (sp);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::
-  setup_system_preconditioner (const std::vector<IndexSet> &system_partitioning)
-  {
-    Amg_preconditioner.reset ();
-    Mp_preconditioner.reset ();
-    system_preconditioner_matrix.clear ();
-
-    // The preconditioner matrix is only used for the Stokes block (velocity and Schur complement)
-    // and only needed if we actually solve iteratively and matrix-based
-    if (solver_scheme_solves_stokes_equations(parameters) == false)
-      return;
-    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
-      return;
-    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_amg)
-      {
-        // continue below
-      }
-    else if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::direct_solver)
-      return;
-    else
-      AssertThrow(false, ExcNotImplemented());
-
-    Table<2,DoFTools::Coupling> coupling (introspection.n_components,
-                                          introspection.n_components);
-    coupling.fill (DoFTools::none);
-
-    const typename Introspection<dim>::ComponentIndices &x
-      = introspection.component_indices;
-
-    // velocity-velocity block (only block diagonal) is only
-    // needed if we use the simplified A block preconditioner
-    if (parameters.use_full_A_block_preconditioner == false)
-      for (unsigned int d=0; d<dim; ++d)
-        coupling[x.velocities[d]][x.velocities[d]] = DoFTools::always;
-
-    // TODO: The newton handler always assembles the preconditioner matrix
-    // even if it is not used. Fix that by modifying the newton assemblers.
-    if (newton_handler.get() != nullptr)
-      for (unsigned int d=0; d<dim; ++d)
-        coupling[x.velocities[d]][x.velocities[d]] = DoFTools::always;
-
-    // Schur complement block (pressure - pressure):
-    if (parameters.include_melt_transport)
-      {
-        coupling[introspection.variable("fluid pressure").first_component_index]
-        [introspection.variable("fluid pressure").first_component_index] = DoFTools::always;
-        coupling[introspection.variable("compaction pressure").first_component_index]
-        [introspection.variable("compaction pressure").first_component_index] = DoFTools::always;
-        coupling[introspection.variable("compaction pressure").first_component_index]
-        [introspection.variable("fluid pressure").first_component_index] = DoFTools::always;
-        coupling[introspection.variable("fluid pressure").first_component_index]
-        [introspection.variable("compaction pressure").first_component_index] = DoFTools::always;
-      }
-    else
-      coupling[x.pressure][x.pressure] = DoFTools::always;
-    // the system_preconditioner matrix is only used for the Stokes
-    // system as there we use a separate matrix for preconditioning
-    // than the system_matrix object). for temperature and
-    // compositional fields, we precondition with the respective block
-    // of system_matrix. consequently, there is no need to allocate
-    // memory for these blocks in the system_preconditioner matrix and
-    // its sparsity pattern here -- the corresponding entries of
-    // 'coupling' simply remain at DoFTools::none
-
-    LinearAlgebra::BlockDynamicSparsityPattern sp;
-
-    sp.reinit (system_partitioning,
-               system_partitioning,
-               introspection.index_sets.system_relevant_partitioning,
-               mpi_communicator);
-
-    DoFTools::make_sparsity_pattern (dof_handler,
-                                     coupling, sp,
-                                     current_constraints, false,
-                                     Utilities::MPI::
-                                     this_mpi_process(mpi_communicator));
-
-
-    sp.compress();
-
-    // We are not interested in temperature and composition matrices for the
-    // preconditioner matrix. But even though we specify a coupling of
-    // DoFTools::none, entries for constrained entries for boundary conditions
-    // and hanging nodes are being created by make_sparsity_pattern. These are
-    // unnecessary, so we remove those entries here.
-    {
-      // temperature:
-      const unsigned int block_idx = introspection.block_indices.temperature;
-      // TODO: using clear() would be nice here but clear() also resets the
-      // size, so just reinit():
-      sp.block(block_idx, block_idx).reinit(sp.block(block_idx, block_idx).locally_owned_range_indices(),
-                                            sp.block(block_idx, block_idx).locally_owned_domain_indices());
-      sp.block(block_idx, block_idx).compress();
-    }
-    // compositions:
-    for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-      {
-        const unsigned int block_idx = introspection.block_indices.compositional_fields[c];
-        // TODO: using clear() would be nice here but clear() also resets the
-        // size, so just reinit():
-        sp.block(block_idx, block_idx).reinit(sp.block(block_idx, block_idx).locally_owned_range_indices(),
-                                              sp.block(block_idx, block_idx).locally_owned_domain_indices());
-        sp.block(block_idx, block_idx).compress();
-      }
-
-    system_preconditioner_matrix.reinit (sp);
-    if (parameters.use_bfbt)
-      inverse_lumped_mass_matrix.reinit(introspection.index_sets.stokes_partitioning);
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::compute_initial_velocity_boundary_constraints (AffineConstraints<double> &constraints)
-  {
-
-    // This needs to happen after the periodic constraints are added:
-    setup_nullspace_constraints(constraints);
-
-    // then compute constraints for the velocity. the constraints we compute
-    // here are the ones that are the same for all following time steps. in
-    // addition, we may be computing constraints from boundary values for the
-    // velocity that are different between time steps. these are then put
-    // into current_constraints in start_timestep().
-    signals.pre_compute_no_normal_flux_constraints(triangulation);
-    {
-      // do the interpolation for zero velocity
-      for (const auto p : boundary_velocity_manager.get_zero_boundary_velocity_indicators())
-        VectorTools::interpolate_boundary_values (*mapping,
-                                                  dof_handler,
-                                                  p,
-                                                  Functions::ZeroFunction<dim>(introspection.n_components),
-                                                  constraints,
-                                                  introspection.component_masks.velocities);
-
-
-      // do the same for no-normal-flux boundaries
-      VectorTools::compute_no_normal_flux_constraints (dof_handler,
-                                                       /* first_vector_component= */
-                                                       introspection.component_indices.velocities[0],
-                                                       boundary_velocity_manager.get_tangential_boundary_velocity_indicators(),
-                                                       constraints,
-                                                       *mapping);
-    }
-
-
-  }
-
-  template <int dim>
-  void Simulator<dim>::compute_current_velocity_boundary_constraints (AffineConstraints<double> &constraints)
-  {
-    // set the current time and do the interpolation
-    // for the prescribed velocity fields
-    boundary_velocity_manager.update();
-    for (const auto &p : boundary_velocity_manager.get_active_boundary_velocity_names())
-      {
-        Utilities::VectorFunctionFromVelocityFunctionObject<dim> vel
-        (introspection.n_components,
-         [&] (const dealii::Point<dim> &x) -> Tensor<1,dim>
-        {
-          return boundary_velocity_manager.boundary_velocity(p.first, x);
-        });
-
-        // here we create a mask for interpolate_boundary_values out of the 'selector'
-        std::vector<bool> mask(introspection.component_masks.velocities.size(), false);
-        const std::string &comp = p.second.first;
-
-        if (comp.length()>0)
-          {
-            for (const char direction : comp)
-              {
-                switch (direction)
-                  {
-                    case 'x':
-                      mask[introspection.component_indices.velocities[0]] = true;
-                      break;
-                    case 'y':
-                      mask[introspection.component_indices.velocities[1]] = true;
-                      break;
-                    case 'z':
-                      // we must be in 3d, or 'z' should never have gotten through
-                      Assert (dim==3, ExcInternalError());
-                      if (dim==3)
-                        mask[introspection.component_indices.velocities[dim-1]] = true;
-                      break;
-                    default:
-                      Assert (false, ExcInternalError());
-                  }
-              }
-          }
-        else
-          {
-            // no mask given -- take all velocities
-            for (unsigned int i=0; i<introspection.component_masks.velocities.size(); ++i)
-              mask[i]=introspection.component_masks.velocities[i];
-          }
-
-        if (!assemble_newton_stokes_system || (assemble_newton_stokes_system && nonlinear_iteration == 0))
-          {
-            VectorTools::interpolate_boundary_values (*mapping,
-                                                      dof_handler,
-                                                      p.first,
-                                                      vel,
-                                                      constraints,
-                                                      ComponentMask(mask));
-          }
-        else
-          {
-            VectorTools::interpolate_boundary_values (*mapping,
-                                                      dof_handler,
-                                                      p.first,
-                                                      Functions::ZeroFunction<dim>(introspection.n_components),
-                                                      constraints,
-                                                      ComponentMask(mask));
-          }
-      }
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::setup_dofs ()
-  {
-    signals.edit_parameters_pre_setup_dofs(*this, parameters);
-
-    TimerOutput::Scope timer (computing_timer, "Setup dof systems");
-
-    dof_handler.distribute_dofs(finite_element);
-
-    // Renumber the DoFs hierarchical so that we get the
-    // same numbering if we resume the computation. This
-    // is because the numbering depends on the order the
-    // cells are created.
-    DoFRenumbering::hierarchical (dof_handler);
-    DoFRenumbering::component_wise (dof_handler,
-                                    introspection.get_components_to_blocks());
-
-    // set up the introspection object that stores all sorts of
-    // information about components of the finite element, component
-    // masks, etc
-    setup_introspection();
-
-    // print dof numbers. Do so with 1000s separator since they are frequently
-    // large
-    {
-      std::locale s = pcout.get_stream().getloc();
-      // Creating std::locale with an empty string previously caused problems
-      // on some platforms, so the functionality to catch the exception and ignore
-      // is kept here, even though explicitly setting a facet should always work.
-      try
-        {
-          // Imbue the stream with a locale that does the right thing. The
-          // locale is responsible for later deleting the object pointed
-          // to by the last argument (the "facet"), see
-          // https://en.cppreference.com/w/cpp/locale/locale/locale
-          pcout.get_stream().imbue(std::locale(std::locale(),
-                                               new aspect::Utilities::ThousandSep));
-        }
-      catch (const std::runtime_error &e)
-        {
-          // If the locale doesn't work, just give up
-        }
-
-      pcout << "Number of active cells: "
-            << triangulation.n_global_active_cells()
-            << " (on "
-            << triangulation.n_global_levels()
-            << " levels)"
-            << std::endl
-            << "Number of degrees of freedom: "
-            << dof_handler.n_dofs()
-            << " ("
-            << introspection.system_dofs_per_block[0];
-      for (unsigned int b=1; b<introspection.system_dofs_per_block.size(); ++b)
-        pcout << '+' << introspection.system_dofs_per_block[b];
-      pcout <<')'
-            << std::endl
-            << std::endl;
-
-      pcout.get_stream().imbue(s);
-    }
-
-    // We need to set up the mesh deformation degrees of freedom first if mesh deformation
-    // is active, since the mapping must be in place before applying boundary
-    // conditions that rely on it (such as no flux BCs).
-    if (parameters.mesh_deformation_enabled)
-      mesh_deformation->setup_dofs();
-
-
-    // Reconstruct the constraint-matrix:
-#if DEAL_II_VERSION_GTE(9,6,0)
-    constraints.reinit (dof_handler.locally_owned_dofs(), introspection.index_sets.system_relevant_set);
-#else
-    constraints.reinit(introspection.index_sets.system_relevant_set);
-#endif
-
-    // Set up the constraints for periodic boundary conditions:
-
-    // Note: this has to happen _before_ we do hanging node constraints,
-    // because inconsistent constraints could be generated in parallel otherwise.
-    geometry_model->make_periodicity_constraints(dof_handler,
-                                                 constraints);
-
-    //  Make hanging node constraints:
-    DoFTools::make_hanging_node_constraints (dof_handler,
-                                             constraints);
-
-
-    compute_initial_velocity_boundary_constraints(constraints);
-    constraints.close();
-    signals.post_compute_no_normal_flux_constraints(triangulation);
-
-    // Finally initialize vectors. We delay construction of the sparsity
-    // patterns and matrices until we have current_constraints.
-    rebuild_sparsity_and_matrices = true;
-
-    system_rhs.reinit(introspection.index_sets.system_partitioning, mpi_communicator);
-    solution.reinit(introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
-    old_solution.reinit(introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
-    old_old_solution.reinit(introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
-    current_linearization_point.reinit (introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
-
-    if (parameters.use_operator_splitting)
-      operator_split_reaction_vector.reinit (introspection.index_sets.system_partitioning, introspection.index_sets.system_relevant_partitioning, mpi_communicator);
-
-    if (do_pressure_rhs_compatibility_modification)
-      pressure_shape_function_integrals.reinit (introspection.index_sets.system_partitioning, mpi_communicator);
-
-    rebuild_stokes_matrix         = true;
-    rebuild_stokes_preconditioner = true;
-
-    // Setup matrix-free dofs
-    if (stokes_matrix_free)
-      stokes_matrix_free->setup_dofs();
-  }
-
-
-
-
-
-  template <int dim>
-  void Simulator<dim>::setup_introspection ()
-  {
-    // compute the various partitionings between processors and blocks
-    // of vectors and matrices
-    introspection.system_dofs_per_block = DoFTools::count_dofs_per_fe_block (dof_handler,
-                                                                             introspection.get_components_to_blocks());
-
-    {
-      IndexSet system_index_set = dof_handler.locally_owned_dofs();
-      introspection.index_sets.system_partitioning = system_index_set.split_by_block(introspection.system_dofs_per_block);
-
-      DoFTools::extract_locally_relevant_dofs (dof_handler,
-                                               introspection.index_sets.system_relevant_set);
-      introspection.index_sets.system_relevant_partitioning =
-        introspection.index_sets.system_relevant_set.split_by_block(introspection.system_dofs_per_block);
-
-      if (!parameters.include_melt_transport)
-        {
-          if (parameters.use_direct_stokes_solver)
-            introspection.index_sets.locally_owned_pressure_dofs = system_index_set & Utilities::extract_locally_active_dofs_with_component(dof_handler, introspection.component_masks.pressure);
-          else
-            introspection.index_sets.locally_owned_pressure_dofs = introspection.index_sets.system_partitioning[introspection.block_indices.pressure];
-        }
-
-      if (parameters.include_melt_transport)
-        {
-          introspection.index_sets.locally_owned_melt_pressure_dofs = system_index_set & Utilities::extract_locally_active_dofs_with_component(dof_handler,
-                                                                      introspection.variable("fluid pressure").component_mask|
-                                                                      introspection.variable("compaction pressure").component_mask);
-          introspection.index_sets.locally_owned_fluid_pressure_dofs = system_index_set & Utilities::extract_locally_active_dofs_with_component(dof_handler,
-                                                                       introspection.variable("fluid pressure").component_mask);
-        }
-
-
-
-      introspection.index_sets.stokes_partitioning.clear ();
-      introspection.index_sets.stokes_partitioning.push_back(introspection.index_sets.system_partitioning[introspection.block_indices.velocities]);
-      if (!parameters.use_direct_stokes_solver)
-        {
-          if (parameters.include_melt_transport)
-            // p_f and p_c are in the same block
-            introspection.index_sets.stokes_partitioning.push_back(introspection.index_sets.system_partitioning[introspection.variable("fluid pressure").block_index]);
-          else
-            introspection.index_sets.stokes_partitioning.push_back(introspection.index_sets.system_partitioning[introspection.block_indices.pressure]);
-        }
-
-      Assert(!parameters.use_direct_stokes_solver ||
-             parameters.include_melt_transport ||
-             (introspection.block_indices.velocities == introspection.block_indices.pressure),
-             ExcInternalError());
-    }
-
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::postprocess ()
-  {
-    TimerOutput::Scope timer (computing_timer, "Postprocessing");
-    pcout << "   Postprocessing:" << std::endl;
-
-    // run all the postprocessing routines and then write
-    // the current state of the statistics table to a file
-    std::list<std::pair<std::string,std::string>>
-    output_list = postprocess_manager.execute (statistics);
-
-    // if we are on processor zero, print to screen
-    // whatever the postprocessors have generated
-    if (Utilities::MPI::this_mpi_process(mpi_communicator)==0)
-      {
-        // determine the width of the first column of text so that
-        // everything gets nicely aligned; then output everything
-        {
-          unsigned int width = 0;
-          for (const auto &p : output_list)
-            width = std::max<unsigned int> (width, p.first.size());
-
-          for (const auto &p : output_list)
-            pcout << "     "
-                  << std::left
-                  << std::setw(width)
-                  << p.first
-                  << ' '
-                  << p.second
-                  << std::endl;
-        }
-
-        pcout << std::endl;
-      }
-
-    // finally, write the entire set of current results to disk
-    output_statistics();
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::refine_mesh (const unsigned int max_grid_level)
-  {
-    parallel::distributed::SolutionTransfer<dim,LinearAlgebra::BlockVector>
-    system_trans(dof_handler);
-
-    std::unique_ptr<parallel::distributed::SolutionTransfer<dim,LinearAlgebra::Vector>>
-    mesh_deformation_trans;
-
-    {
-      TimerOutput::Scope timer (computing_timer, "Refine mesh structure, part 1");
-
-      Vector<float> estimated_error_per_cell (triangulation.n_active_cells());
-      mesh_refinement_manager.execute (estimated_error_per_cell);
-
-      if (parameters.adapt_by_fraction_of_cells)
-        parallel::distributed::GridRefinement::
-        refine_and_coarsen_fixed_number   (triangulation,
-                                           estimated_error_per_cell,
-                                           parameters.refinement_fraction,
-                                           parameters.coarsening_fraction);
-      else
-        parallel::distributed::GridRefinement::
-        refine_and_coarsen_fixed_fraction (triangulation,
-                                           estimated_error_per_cell,
-                                           parameters.refinement_fraction,
-                                           parameters.coarsening_fraction);
-
-      mesh_refinement_manager.tag_additional_cells ();
-
-
-      // clear refinement flags if parameter.refinement_fraction=0.0
-      if (parameters.refinement_fraction==0.0)
-        {
-          for (const auto &cell : triangulation.active_cell_iterators())
-            cell->clear_refine_flag ();
-        }
-      else
-        {
-          // limit maximum refinement level
-          if (triangulation.n_levels() > max_grid_level)
-            for (typename Triangulation<dim>::active_cell_iterator
-                 cell = triangulation.begin_active(max_grid_level);
-                 cell != triangulation.end(); ++cell)
-              cell->clear_refine_flag ();
-        }
-
-      // clear coarsening flags if parameter.coarsening_fraction=0.0
-      if (parameters.coarsening_fraction==0.0)
-        {
-          for (const auto &cell : triangulation.active_cell_iterators())
-            cell->clear_coarsen_flag ();
-        }
-      else
-        {
-          // limit minimum refinement level
-          for (typename Triangulation<dim>::active_cell_iterator
-               cell = triangulation.begin_active(0);
-               cell != triangulation.end_active(parameters.min_grid_level); ++cell)
-            cell->clear_coarsen_flag ();
-        }
-
-
-      // Next set up whatever is necessary to transfer the solution from old
-      // to new mesh:
-      std::vector<const LinearAlgebra::BlockVector *> x_system
-        = { &solution, &old_solution };
-
-      if (parameters.mesh_deformation_enabled)
-        x_system.push_back(&mesh_deformation->mesh_velocity);
-
-      std::vector<const LinearAlgebra::Vector *> x_fs_system;
-      if (parameters.mesh_deformation_enabled)
-        {
-          x_fs_system.push_back (&mesh_deformation->mesh_displacements);
-          x_fs_system.push_back (&mesh_deformation->old_mesh_displacements);
-          x_fs_system.push_back (&mesh_deformation->initial_topography);
-          mesh_deformation_trans
-            = std::make_unique<parallel::distributed::SolutionTransfer<dim,LinearAlgebra::Vector>>
-              (mesh_deformation->mesh_deformation_dof_handler);
-        }
-
-
-      // Possibly store data of plugins associated with cells
-      signals.pre_refinement_store_user_data(triangulation);
-
-      exchange_refinement_flags();
-
-      triangulation.prepare_coarsening_and_refinement();
-      bool any_flags_set = false;
-      {
-        for (const auto &cell:dof_handler.active_cell_iterators())
-          {
-            if (cell->refine_flag_set() || cell->coarsen_flag_set())
-              {
-                any_flags_set = true;
-                break;
-              }
-          }
-      }
-      const bool mesh_changed = Utilities::MPI::max(any_flags_set?1:0,mpi_communicator) == 1 ? true : false;
-      if (!mesh_changed)
-        {
-          pcout << "Skipping mesh refinement, because the mesh did not change.\n" << std::endl;
-          return;
-        }
-
-      system_trans.prepare_for_coarsening_and_refinement(x_system);
-
-      if (parameters.mesh_deformation_enabled)
-        mesh_deformation_trans->prepare_for_coarsening_and_refinement(x_fs_system);
-
-      triangulation.execute_coarsening_and_refinement ();
-      if (MappingQCache<dim> *map = dynamic_cast<MappingQCache<dim>*>(&(*mapping)))
-        map->initialize(MappingQGeneric<dim>(4), triangulation);
-    } // leave the timed section
-
-    setup_dofs ();
-
-    {
-      TimerOutput::Scope timer (computing_timer, "Refine mesh structure, part 2");
-
-      LinearAlgebra::BlockVector distributed_system;
-      LinearAlgebra::BlockVector old_distributed_system;
-      LinearAlgebra::BlockVector distributed_mesh_velocity;
-
-      distributed_system.reinit(introspection.index_sets.system_partitioning, mpi_communicator);
-      old_distributed_system.reinit(introspection.index_sets.system_partitioning, mpi_communicator);
-      if (parameters.mesh_deformation_enabled)
-        distributed_mesh_velocity.reinit(introspection.index_sets.system_partitioning, mpi_communicator);
-
-      std::vector<LinearAlgebra::BlockVector *> system_tmp
-        = { &distributed_system, &old_distributed_system};
-
-      if (parameters.mesh_deformation_enabled)
-        system_tmp.push_back(&distributed_mesh_velocity);
-
-      // transfer the data previously stored into the vectors indexed by
-      // system_tmp. then ensure that the interpolated solution satisfies
-      // hanging node constraints
-      //
-      // note that the 'constraints' variable contains hanging node constraints
-      // and constraints from periodic boundary conditions (as well as from
-      // zero and tangential velocity boundary conditions), but not from
-      // non-homogeneous boundary conditions. the latter are added not in setup_dofs(),
-      // which we call above, but added to 'current_constraints' in start_timestep(),
-      // which we do not want to call here.
-      //
-      // however, what we have should be sufficient: we have everything that
-      // is necessary to make the solution vectors *conforming* on the current
-      // mesh.
-      system_trans.interpolate (system_tmp);
-
-      constraints.distribute (distributed_system);
-      solution     = distributed_system;
-
-      constraints.distribute (old_distributed_system);
-      old_solution = old_distributed_system;
-
-      // We need the current linearization point at the start of the new time step
-      // when we set the boundary conditions for advected fields (to determine parts
-      // of the boundary with outflow). Therefore, we here set it to the solution
-      // vector, but it will be reinitialized the next time the equations are solved.
-      current_linearization_point = distributed_system;
-
-      // do the same as above, but for the mesh deformation solution
-      if (parameters.mesh_deformation_enabled)
-        {
-          constraints.distribute (distributed_mesh_velocity);
-          mesh_deformation->mesh_velocity = distributed_mesh_velocity;
-
-          LinearAlgebra::Vector distributed_mesh_displacements,
-                        distributed_old_mesh_displacements,
-                        distributed_initial_topography;
-
-          distributed_mesh_displacements.reinit(mesh_deformation->mesh_locally_owned,
-                                                mpi_communicator);
-          distributed_old_mesh_displacements.reinit(mesh_deformation->mesh_locally_owned,
-                                                    mpi_communicator);
-          distributed_initial_topography.reinit(mesh_deformation->mesh_locally_owned,
-                                                mpi_communicator);
-
-          std::vector<LinearAlgebra::Vector *> system_tmp
-          = { &distributed_mesh_displacements,
-              &distributed_old_mesh_displacements,
-              &distributed_initial_topography
-            };
-
-          mesh_deformation_trans->interpolate (system_tmp);
-
-          mesh_deformation->mesh_vertex_constraints.distribute (distributed_mesh_displacements);
-          mesh_deformation->mesh_displacements = distributed_mesh_displacements;
-
-          mesh_deformation->mesh_vertex_constraints.distribute (distributed_old_mesh_displacements);
-          mesh_deformation->old_mesh_displacements = distributed_old_mesh_displacements;
-
-          mesh_deformation->mesh_vertex_constraints.distribute (distributed_initial_topography);
-          mesh_deformation->initial_topography = distributed_initial_topography;
-        }
-
-      // Possibly load data of plugins associated with cells
-      signals.post_refinement_load_user_data(triangulation);
-
-      // calculate global volume after refining mesh
-      global_volume = GridTools::volume (triangulation, *mapping);
-    }
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  solve_timestep ()
-  {
-    // start any scheme with an extrapolated value from the previous
-    // two time steps if those are available
-    initialize_current_linearization_point();
-
-    // The mesh deformation scheme is currently not built to work inside a nonlinear solver.
-    // We do the mesh deformation execution at the beginning of the timestep for a specific reason.
-    // The time step size is calculated AFTER the whole solve_timestep() function.  If we call
-    // mesh_deformation_execute() after the Stokes solve, it will be before we know what the appropriate
-    // time step to take is, and we will timestep the boundary incorrectly.
-    if (parameters.mesh_deformation_enabled)
-      {
-        mesh_deformation->execute ();
-
-        // calculate global volume after deforming mesh
-        global_volume = GridTools::volume (triangulation, *mapping);
-        signals.post_mesh_deformation(*this);
-      }
-
-    // Compute the reactions of compositional fields and temperature in case of operator splitting.
-    if (parameters.use_operator_splitting)
-      compute_reactions ();
-
-    switch (parameters.nonlinear_solver)
-      {
-        case NonlinearSolver::single_Advection_single_Stokes:
-        {
-          solve_single_advection_single_stokes();
-          break;
-        }
-
-        case NonlinearSolver::no_Advection_iterated_Stokes:
-        {
-          solve_no_advection_iterated_stokes();
-          break;
-        }
-
-        case NonlinearSolver::no_Advection_single_Stokes:
-        {
-          solve_no_advection_single_stokes();
-          break;
-        }
-
-        case NonlinearSolver::iterated_Advection_and_Stokes:
-        {
-          solve_iterated_advection_and_stokes();
-          break;
-        }
-
-        case NonlinearSolver::single_Advection_iterated_Stokes:
-        {
-          solve_single_advection_iterated_stokes();
-          break;
-        }
-
-        case NonlinearSolver::no_Advection_iterated_defect_correction_Stokes:
-        {
-          solve_no_advection_iterated_defect_correction_stokes();
-          break;
-        }
-
-        case NonlinearSolver::single_Advection_iterated_defect_correction_Stokes:
-        {
-          solve_single_advection_iterated_defect_correction_stokes();
-          break;
-        }
-
-        case NonlinearSolver::iterated_Advection_and_defect_correction_Stokes:
-        {
-          solve_iterated_advection_and_defect_correction_stokes();
-          break;
-        }
-
-        case NonlinearSolver::iterated_Advection_and_Newton_Stokes:
-        {
-          solve_iterated_advection_and_newton_stokes(/*use_newton_iterations =*/ true);
-          break;
-        }
-
-        case NonlinearSolver::single_Advection_iterated_Newton_Stokes:
-        {
-          solve_single_advection_and_iterated_newton_stokes(/*use_newton_iterations =*/ true);
-          break;
-        }
-
-        case NonlinearSolver::single_Advection_no_Stokes:
-        {
-          solve_single_advection_no_stokes();
-          break;
-        }
-
-        case NonlinearSolver::first_timestep_only_single_Stokes:
-        {
-          solve_first_timestep_only_single_stokes();
-          break;
-        }
-
-        case NonlinearSolver::no_Advection_no_Stokes:
-        {
-          solve_no_advection_no_stokes();
-          break;
-        }
-
-        default:
-          Assert (false, ExcNotImplemented());
-      }
-
-    pcout << std::endl;
-  }
-
-
-  /**
-   * This is the main function of the program, containing the overall
-   * logic which function is called when.
-   */
-  template <int dim>
-  void Simulator<dim>::run ()
-  {
-    CitationInfo::print_info_block(pcout);
-
-    unsigned int max_refinement_level = parameters.initial_global_refinement +
-                                        parameters.initial_adaptive_refinement;
-    pre_refinement_step = 0;
-
-    // if we want to resume a computation from an earlier point
-    // then reload it from a snapshot. otherwise do the basic
-    // start-up
-    if (parameters.resume_computation == true)
-      {
-        resume_from_snapshot();
-        // we need to remove additional_refinement_times that are in the past
-        // and adjust max_refinement_level which is not written to file
-        while ((parameters.additional_refinement_times.size() > 0)
-               &&
-               (parameters.additional_refinement_times.front () < time+time_step))
-          {
-            ++max_refinement_level;
-            parameters.additional_refinement_times
-            .erase (parameters.additional_refinement_times.begin());
-          }
-      }
-    else
-      {
-        time = parameters.start_time;
-
-        // Instead of calling global_refine(n) we flag all cells for
-        // refinement and then allow the mesh refinement plugins to unflag
-        // the cells if desired. This procedure is repeated n times. If there
-        // is no plugin that modifies the flags, it is equivalent to
-        // refine_global(n).
-        for (unsigned int n=0; n<parameters.initial_global_refinement; ++n)
-          {
-            for (const auto &cell : triangulation.active_cell_iterators())
-              if (cell->is_locally_owned())
-                cell->set_refine_flag ();
-
-            mesh_refinement_manager.tag_additional_cells ();
-
-            exchange_refinement_flags();
-
-            triangulation.execute_coarsening_and_refinement();
-            if (MappingQCache<dim> *map = dynamic_cast<MappingQCache<dim>*>(&(*mapping)))
-              map->initialize(MappingQGeneric<dim>(4), triangulation);
-          }
-
-        setup_dofs();
-
-        // calculate global volume after refining mesh
-        global_volume = GridTools::volume (triangulation, *mapping);
-      }
-
-    // start the timer for periodic checkpoints after the setup above
-    time_t last_checkpoint_time = std::time(nullptr);
-
-  start_time_iteration:
-
-    if (parameters.resume_computation == false)
-      {
-        TimerOutput::Scope timer (computing_timer, "Setup initial conditions");
-
-        timestep_number           = 0;
-        time_step = old_time_step = 0;
-
-        if (! parameters.skip_setup_initial_conditions_on_initial_refinement
-            ||
-            ! (pre_refinement_step < parameters.initial_adaptive_refinement))
-          {
-            // Add topography to box models after all initial refinement
-            // is completed.
-            if (pre_refinement_step == parameters.initial_adaptive_refinement)
-              signals.pre_set_initial_state (triangulation);
-
-            set_initial_temperature_and_compositional_fields ();
-            compute_initial_pressure_field ();
-
-            signals.post_set_initial_state (*this);
-          }
-      }
-
-    // Start the principal loop over time steps. At this point, everything
-    // is completely initialized, so set that status as well
-    simulator_is_past_initialization = true;
-    do
-      {
-        // Only solve if we are not in pre-refinement, or we do not want to skip
-        // solving in pre-refinement.
-        if (! (parameters.skip_solvers_on_initial_refinement
-               && pre_refinement_step < parameters.initial_adaptive_refinement))
-          {
-            start_timestep ();
-
-            // then do the core work: assemble systems and solve
-            solve_timestep ();
-          }
-
-        // See if we have to start over with a new adaptive refinement cycle
-        // at the beginning of the simulation. If so, set the
-        // simulator_is_past_initialization variable back to false because we will
-        // have to re-initialize some variables such as the size of vectors,
-        // the initial state, etc.
-        if (timestep_number == 0)
-          {
-            const bool initial_refinement_done = maybe_do_initial_refinement(max_refinement_level);
-            if (initial_refinement_done)
-              {
-                simulator_is_past_initialization = false;
-                goto start_time_iteration;
-              }
-          }
-
-        // We're now definitely past the point where we need the initial
-        // conditions objects, and we can release the pointers to these objects
-        // that we have created in the constructor of this class. If some of the
-        // other plugins created there still need access to these initial
-        // conditions, they will have created their own shared pointers.
-        initial_temperature_manager.reset();
-        initial_composition_manager.reset();
-#ifdef ASPECT_WITH_WORLD_BUILDER
-        // The same applies to the world builder object:
-        world_builder.reset();
-#endif
-        // Prepare the next time step:
-        time_stepping_manager.update();
-
-        const double new_time_step_size = time_stepping_manager.get_next_time_step_size();
-
-        // if we postprocess nonlinear iterations, this function is called within
-        // solve_timestep () in the individual solver schemes
-        if (!time_stepping_manager.should_repeat_time_step()
-            && !parameters.run_postprocessors_on_nonlinear_iterations)
-          postprocess ();
-
-        if (time_stepping_manager.should_refine_mesh())
-          {
-            pcout << "Refining the mesh based on the time stepping manager ...\n" << std::endl;
-            refine_mesh(max_refinement_level);
-          }
-        else
-          maybe_refine_mesh(new_time_step_size, max_refinement_level);
-
-        if (time_stepping_manager.should_repeat_time_step())
-          {
-            pcout << "Repeating the current time step based on the time stepping manager ..." << std::endl;
-
-            if (mesh_deformation)
-              mesh_deformation->mesh_displacements = mesh_deformation->old_mesh_displacements;
-
-            // adjust time and time_step size:
-            time = time - time_step + new_time_step_size;
-            time_step = new_time_step_size;
-
-            // Restore particles through stored copy of particle handler,
-            // created in start_timestep(),
-            // but only if this timestep is to be repeated.
-            for (auto &particle_world : particle_worlds)
-              particle_world->restore_particles();
-
-            continue; // repeat time step loop
-          }
-
-        // see if we want to write a timing summary
-        maybe_write_timing_output();
-
-        // update values for timestep, increment time step by one.
-        advance_time(new_time_step_size);
-
-        // Check whether to terminate the simulation:
-        const bool should_terminate = time_stepping_manager.should_simulation_terminate_now();
-
-        const bool write_checkpoint_due_to_termination
-          = should_terminate && time_stepping_manager.need_checkpoint_on_terminate();
-
-        const bool checkpoint_written = maybe_write_checkpoint(last_checkpoint_time,
-                                                               write_checkpoint_due_to_termination);
-
-        if (checkpoint_written)
-          last_checkpoint_time = std::time(nullptr);
-
-        if (should_terminate)
-          break;
-      }
-    while (true);
-
-    // we disable automatic summary printing so that it won't happen when
-    // throwing an exception. Therefore, we have to do this manually here:
-    computing_timer.print_summary ();
-
-    pcout << "-- Total wallclock time elapsed including restarts: "
-          << round(wall_timer.wall_time()+total_walltime_until_last_snapshot)
-          << 's' << std::endl;
-
-    CitationInfo::print_info_block (pcout);
-
-    stokes_matrix_free.reset();
-  }
-}
-
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template class Simulator<dim>;
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/entropy_viscosity.cc.bak b/source/simulator/entropy_viscosity.cc.bak
deleted file mode 100644
index 9ddae9f4ff6..00000000000
--- a/source/simulator/entropy_viscosity.cc.bak
+++ /dev/null
@@ -1,710 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/melt.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  /**
-   * Compute the variation in the entropy needed in the definition of the
-   * artificial viscosity used to stabilize the composition/temperature equation.
-   */
-  template <int dim>
-  double
-  Simulator<dim>::get_entropy_variation (const double average_field,
-                                         const AdvectionField &advection_field) const
-  {
-    // only do this if we really need entropy
-    // variation. otherwise return something that's obviously
-    // nonsensical
-    if (parameters.stabilization_alpha != 2)
-      return numbers::signaling_nan<double>();
-
-    // record maximal entropy on Gauss quadrature points
-    const Quadrature<dim> &quadrature_formula
-      = (advection_field.is_temperature() ?
-         introspection.quadratures.temperature :
-         introspection.quadratures.compositional_fields);
-    const unsigned int n_q_points = quadrature_formula.size();
-
-    const FEValuesExtractors::Scalar field = advection_field.scalar_extractor(introspection);
-
-    FEValues<dim> fe_values (finite_element, quadrature_formula,
-                             update_values | update_JxW_values);
-    std::vector<double> old_field_values(n_q_points);
-    std::vector<double> old_old_field_values(n_q_points);
-
-    double min_entropy = std::numeric_limits<double>::max(),
-           max_entropy = std::numeric_limits<double>::lowest(),
-           area = 0,
-           entropy_integrated = 0;
-
-    // loop over all locally owned cells and evaluate the entropy
-    // at all quadrature points. keep a running tally of the
-    // integral over the entropy as well as the area and the
-    // maximal and minimal entropy
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          fe_values[field].get_function_values (old_solution,
-                                                old_field_values);
-          fe_values[field].get_function_values (old_old_solution,
-                                                old_old_field_values);
-          for (unsigned int q=0; q<n_q_points; ++q)
-            {
-              const double field_value = (old_field_values[q] +
-                                          old_old_field_values[q]) / 2;
-              const double entropy = ((field_value-average_field) *
-                                      (field_value-average_field));
-
-              min_entropy = std::min (min_entropy, entropy);
-              max_entropy = std::max (max_entropy, entropy);
-
-              area += fe_values.JxW(q);
-              entropy_integrated += fe_values.JxW(q) * entropy;
-            }
-        }
-
-    // do MPI data exchange: we need to sum over
-    // the two integrals (area,
-    // entropy_integrated), and get the extrema
-    // for maximum and minimum. combine
-    // MPI_Allreduce for two values since that is
-    // an expensive operation
-    const double local_for_sum[2] = { entropy_integrated, area },
-                                    local_for_max[2] = { -min_entropy, max_entropy };
-    double global_for_sum[2], global_for_max[2];
-
-    dealii::Utilities::MPI::sum (local_for_sum, mpi_communicator, global_for_sum);
-    dealii::Utilities::MPI::max (local_for_max, mpi_communicator, global_for_max);
-
-    const double average_entropy = global_for_sum[0] / global_for_sum[1];
-
-    // return the maximal deviation of the entropy everywhere from the
-    // average value
-    return std::max(global_for_max[1] - average_entropy,
-                    average_entropy - (-global_for_max[0]));
-  }
-
-
-
-  template <int dim>
-  double
-  Simulator<dim>::
-  compute_viscosity (internal::Assembly::Scratch::AdvectionSystem<dim> &scratch,
-                     const double                        global_u_infty,
-                     const double                        global_field_variation,
-                     const double                        average_field,
-                     const double                        global_entropy_variation,
-                     const double                        cell_diameter,
-                     const AdvectionField               &advection_field) const
-  {
-    // discontinuous Galerkin doesn't require an artificial viscosity
-    if (advection_field.is_discontinuous(introspection))
-      return 0.;
-
-    double max_residual = 0.0;
-    double max_velocity = 0.0;
-    double max_advection_prefactor = 0.0;
-    double max_conductivity = 0.0;
-
-    std::vector<double> residual (scratch.finite_element_values.n_quadrature_points,0.0);
-
-    for (unsigned int i=0; i<assemblers->advection_system[advection_field.field_index()].size(); ++i)
-      {
-        const std::vector<double> new_residual = assemblers->advection_system[advection_field.field_index()][i]->compute_residual(scratch);
-        for (unsigned int j=0; j<residual.size(); ++j)
-          residual[j] += new_residual[j];
-
-        auto *stabilization_assembler =
-          dynamic_cast<Assemblers::AdvectionStabilizationInterface<dim>*> ((assemblers->advection_system[advection_field.field_index()][i]).get());
-
-        Assert (stabilization_assembler != nullptr,
-                ExcMessage("Entropy viscosity can only be computed for assemblers that "
-                           "are derived from the advection stabilization assembler interface."));
-
-        // Ensure no other assembler has set max_advection_prefactor or max_conductivity before,
-        // otherwise we dont know which one to use.
-        Assert (max_advection_prefactor == 0.0 && max_conductivity == 0.0,
-                ExcMessage("More than one assembler has provided scaling factors for the entropy "
-                           "viscosity stabilization, which is not supported. Make sure only one active advection "
-                           "assembler is derived from the class AdvectionStabilizationInterface."));
-
-        const std::vector<double> advection_prefactors = stabilization_assembler->advection_prefactors(scratch);
-        const std::vector<double> conductivities = stabilization_assembler->diffusion_prefactors(scratch);
-
-        max_advection_prefactor = *std::max_element(advection_prefactors.begin(),advection_prefactors.end());
-        max_conductivity = *std::max_element(conductivities.begin(),conductivities.end());
-      }
-
-    std::vector<Tensor<1,dim>> old_fluid_velocity_values(scratch.finite_element_values.n_quadrature_points);
-    std::vector<Tensor<1,dim>> old_old_fluid_velocity_values(scratch.finite_element_values.n_quadrature_points);
-    if (parameters.include_melt_transport)
-      {
-        const FEValuesExtractors::Vector ex_u_f = introspection.variable("fluid velocity").extractor_vector();
-        scratch.finite_element_values[ex_u_f].get_function_values (old_solution,old_fluid_velocity_values);
-        scratch.finite_element_values[ex_u_f].get_function_values (old_old_solution,old_old_fluid_velocity_values);
-      }
-
-    for (unsigned int q=0; q < scratch.finite_element_values.n_quadrature_points; ++q)
-      {
-        const Tensor<1,dim> velocity = (scratch.old_velocity_values[q] +
-                                        scratch.old_old_velocity_values[q]) / 2;
-        double velocity_norm = velocity.norm();
-
-        if (parameters.include_melt_transport)
-          {
-            const Tensor<1,dim> fluid_velocity = (old_fluid_velocity_values[q] +
-                                                  old_old_fluid_velocity_values[q]) / 2;
-            velocity_norm = std::max (fluid_velocity.norm(), velocity_norm);
-          }
-
-        const double strain_rate = ((scratch.old_strain_rates[q]
-                                     + scratch.old_old_strain_rates[q]) / 2).norm();
-
-        if (parameters.stabilization_alpha == 2)
-          {
-            const double field = (scratch.old_field_values[q] + scratch.old_old_field_values[q]) / 2;
-            residual[q] *= std::abs(field - average_field);
-          }
-
-        max_residual = std::max (residual[q],     max_residual);
-        max_velocity = std::max (velocity_norm
-                                 + parameters.stabilization_gamma * strain_rate * cell_diameter,
-                                 max_velocity);
-      }
-
-    // If the velocity is 0 we have to assume a sensible velocity to calculate
-    // an artificial diffusion. We choose similar to nondimensional
-    // formulations: v ~ thermal_diffusivity / length_scale, which cancels
-    // the density and specific heat from the entropy formulation. It seems
-    // surprising at first that only the conductivity remains, but remember
-    // that this actually *is* an additional artificial diffusion.
-    if (std::abs(global_u_infty) < 1e-50)
-      return parameters.stabilization_beta[advection_field.field_index()] *
-             max_conductivity / geometry_model->length_scale() *
-             cell_diameter;
-
-    const double maximum_viscosity = parameters.stabilization_beta[advection_field.field_index()] *
-                                     max_advection_prefactor *
-                                     max_velocity * cell_diameter;
-
-    if (timestep_number <= 1
-        || std::abs(global_entropy_variation) < 1e-50
-        || std::abs(global_field_variation) < 1e-50)
-      // we don't have sensible time-steps during the first two iterations
-      // and we can not divide by the entropy_variation if it is zero
-      return maximum_viscosity;
-    else
-      {
-        Assert (old_time_step > 0, ExcInternalError());
-
-        double entropy_viscosity;
-        if (parameters.stabilization_alpha == 2)
-          entropy_viscosity = (parameters.stabilization_c_R[advection_field.field_index()] *
-                               cell_diameter * cell_diameter *
-                               max_residual /
-                               global_entropy_variation);
-        else
-          entropy_viscosity = (parameters.stabilization_c_R[advection_field.field_index()] *
-                               cell_diameter * global_Omega_diameter *
-                               max_velocity * max_residual /
-                               (global_u_infty * global_field_variation));
-
-
-        return std::min (maximum_viscosity, entropy_viscosity);
-      }
-  }
-
-
-
-  template <int dim>
-  template <typename T>
-  void
-  Simulator<dim>::
-  get_artificial_viscosity (Vector<T> &viscosity_per_cell,
-                            const AdvectionField &advection_field,
-                            const bool skip_interior_cells) const
-  {
-    Assert(viscosity_per_cell.size()==triangulation.n_active_cells(), ExcInternalError());
-
-    if (advection_field.field_type == AdvectionField::compositional_field)
-      Assert(introspection.n_compositional_fields > advection_field.compositional_variable, ExcInternalError());
-
-    viscosity_per_cell = 0.0;
-
-    // discontinuous Galerkin doesn't require an artificial viscosity
-    if (advection_field.is_discontinuous(introspection))
-      return;
-
-    bool skip_EV_dirichlet_boundary_cells = false;
-
-    if (advection_field.is_temperature())
-      skip_EV_dirichlet_boundary_cells = true;
-    else
-      {
-        const std::string field_name = introspection.name_for_compositional_index(advection_field.compositional_variable);
-        if (std::find(parameters.compositional_fields_with_disabled_boundary_entropy_viscosity.begin(),
-                      parameters.compositional_fields_with_disabled_boundary_entropy_viscosity.end(),
-                      field_name)
-            !=
-            parameters.compositional_fields_with_disabled_boundary_entropy_viscosity.end())
-          skip_EV_dirichlet_boundary_cells = true;
-      }
-
-    const std::pair<double,double>
-    global_field_range = get_extrapolated_advection_field_range (advection_field);
-    const double global_entropy_variation = get_entropy_variation ((global_field_range.first +
-                                                                    global_field_range.second) / 2,
-                                                                   advection_field);
-    const double global_max_velocity = get_maximal_velocity(old_solution);
-
-    UpdateFlags update_flags = update_values |
-                               update_gradients |
-                               update_quadrature_points |
-                               update_JxW_values;
-
-    if (advection_field.is_temperature())
-      update_flags = update_flags | update_hessians;
-
-    for (unsigned int i = 0; i < assemblers->advection_system_assembler_properties.size(); ++i)
-      update_flags = update_flags | assemblers->advection_system_assembler_properties[i].needed_update_flags;
-
-    // We need the face integrals to determine if a Dirichlet boundary
-    // is conduction dominated in which case we disable stabilization
-    // to get the most accurate heat flux, or still advection
-    // dominated (e.g. a boundary with normal flow) in which case we
-    // still need stabilization.
-    const UpdateFlags face_update_flags = update_values |
-                                          update_quadrature_points |
-                                          update_normal_vectors |
-                                          update_JxW_values;
-
-    internal::Assembly::Scratch::
-    AdvectionSystem<dim> scratch (finite_element,
-                                  finite_element.base_element(advection_field.base_element(introspection)),
-                                  *mapping,
-                                  QGauss<dim>(advection_field.polynomial_degree(introspection)
-                                              +
-                                              (parameters.stokes_velocity_degree+1)/2),
-                                  QTrapezoid<dim-1> (),
-                                  update_flags,
-                                  face_update_flags,
-                                  introspection.n_compositional_fields,
-                                  advection_field);
-
-    std::vector<Tensor<1,dim>> face_old_velocity_values (scratch.face_finite_element_values->n_quadrature_points);
-    std::vector<Tensor<1,dim>> face_old_old_velocity_values (scratch.face_finite_element_values->n_quadrature_points);
-
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      {
-        // Skip cells for which we can not/do not need to compute the
-        // stabilization. We need to compute the artificial viscosity
-        // on all locally owned cells, but if we want to
-        // smooth/average it over a neighborhood of a locally owned
-        // cell, then we also need it on ghost cells; we could get it
-        // there through parallel communication, but the easier way is
-        // to simply compute it there as well
-        if (cell->is_artificial()
-            ||
-            (cell->is_ghost() &&
-             parameters.use_artificial_viscosity_smoothing == false))
-          {
-            viscosity_per_cell[cell->active_cell_index()] = numbers::signaling_nan<T>();
-            continue;
-          }
-        // Also skip all interior cells if we are asked to do so. Do not
-        // skip neighbor cells of boundary cells if smoothing is on, because
-        // the smoothing uses both the boundary cell and its neighbor.
-        else if (skip_interior_cells && !cell->at_boundary())
-          {
-            bool neighbor_at_boundary = false;
-            for (const unsigned int face_no : cell->face_indices())
-              if (cell->neighbor(face_no)->at_boundary() == true)
-                neighbor_at_boundary = true;
-
-            if (parameters.use_artificial_viscosity_smoothing == false ||
-                neighbor_at_boundary == false)
-              {
-                viscosity_per_cell[cell->active_cell_index()] = numbers::signaling_nan<T>();
-                continue;
-              }
-          }
-
-        // For fields that have physical diffusion (e.g. temperature),
-        // we can disable artificial viscosity stabilization at
-        // Dirichlet boundaries, because the boundary is conduction
-        // dominated anyway. Moreover, the residual we would compute
-        // would be erroneously large, because it does not take into
-        // account the boundary constraints. This would lead to
-        // unnecessary large diffusion in the cells that matter most
-        // for the overall energy balance of the system. However, we
-        // sometimes have Dirichlet temperature boundary conditions
-        // with prescribed non-tangential velocities, in these cases
-        // we need the stabilization, because the boundary cells can
-        // be advection dominated. Hence, only disable artificial
-        // viscosity if flow through the boundary is slow, or
-        // tangential. Also disable artificial viscosity for compositions
-        // for which this is requested (e.g. compositions with
-        // physical diffusion).
-        if (parameters.advection_stabilization_method
-            == Parameters<dim>::AdvectionStabilizationMethod::entropy_viscosity
-            && skip_EV_dirichlet_boundary_cells == true)
-          {
-            const std::set<types::boundary_id> &dirichlet_boundaries =
-              (advection_field.is_temperature() == true)
-              ?
-              boundary_temperature_manager.get_fixed_temperature_boundary_indicators()
-              :
-              boundary_composition_manager.get_fixed_composition_boundary_indicators();
-            const std::set<types::boundary_id> &tangential_velocity_boundaries =
-              boundary_velocity_manager.get_tangential_boundary_velocity_indicators();
-            const std::set<types::boundary_id> &zero_velocity_boundaries =
-              boundary_velocity_manager.get_zero_boundary_velocity_indicators();
-
-            bool cell_at_conduction_dominated_dirichlet_boundary = false;
-            for (const unsigned int face_no : cell->face_indices())
-              if (cell->at_boundary(face_no) == true &&
-                  dirichlet_boundaries.find(cell->face(face_no)->boundary_id()) != dirichlet_boundaries.end())
-                {
-                  // If the velocity is tangential or zero we can always disable stabilization, except if there is another
-                  // face at a different boundary. Therefore continue with the next face rather than break the loop.
-                  if ((tangential_velocity_boundaries.find(cell->face(face_no)->boundary_id())
-                       != tangential_velocity_boundaries.end())
-                      ||
-                      (zero_velocity_boundaries.find(cell->face(face_no)->boundary_id())
-                       != zero_velocity_boundaries.end()))
-                    {
-                      cell_at_conduction_dominated_dirichlet_boundary = true;
-                      continue;   // test next face
-                    }
-
-                  scratch.face_finite_element_values->reinit (cell, face_no);
-                  (*scratch.face_finite_element_values)[introspection.extractors.velocities].get_function_values(old_solution,
-                      face_old_velocity_values);
-                  (*scratch.face_finite_element_values)[introspection.extractors.velocities].get_function_values(old_old_solution,
-                      face_old_old_velocity_values);
-
-                  // ... check if the face is a boundary with normal flow by integrating the normal velocities
-                  // (flux through the boundary) as: int u*n ds = Sum_q u(x_q)*n(x_q) JxW(x_q)...
-                  double normal_flow = 0.0;
-                  double flow = 0.0;
-                  double area = 0.0;
-                  for (unsigned int q=0; q<scratch.face_finite_element_values->n_quadrature_points; ++q)
-                    {
-                      normal_flow += ((face_old_velocity_values[q]+face_old_old_velocity_values[q])/2.0 *
-                                      scratch.face_finite_element_values->normal_vector(q)) *
-                                     scratch.face_finite_element_values->JxW(q);
-                      flow += ((face_old_velocity_values[q]+face_old_old_velocity_values[q])/2.0).norm() *
-                              scratch.face_finite_element_values->JxW(q);
-                      area += scratch.face_finite_element_values->JxW(q);
-                    }
-
-                  // Disable stabilization for boundaries with slow flow, or tangential flow.
-                  // Break the loop in case a face is at multiple boundaries, some with flow, some without.
-                  // In those cases we can not disable stabilization.
-                  if ((std::abs(flow/area) * time_step
-                       < std::sqrt(std::numeric_limits<double>::epsilon()) * cell->diameter())
-                      ||
-                      (std::abs(normal_flow)
-                       < std::sqrt(std::numeric_limits<double>::epsilon()) * std::abs(flow)))
-                    {
-                      cell_at_conduction_dominated_dirichlet_boundary = true;
-                    }
-                  else
-                    {
-                      cell_at_conduction_dominated_dirichlet_boundary = false;
-                      break; // no need to check any other face
-                    }
-                }
-
-            if (cell_at_conduction_dominated_dirichlet_boundary)
-              {
-                // If we set the viscosity to zero, we don't need any further computation on this cell
-                viscosity_per_cell[cell->active_cell_index()] = 0.0;
-                continue;   // next cell
-              }
-          }
-
-        const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-
-        // also have the number of dofs that correspond just to the element for
-        // the system we are currently trying to assemble
-        const unsigned int advection_dofs_per_cell = scratch.phi_field.size();
-        (void)advection_dofs_per_cell;
-        Assert (advection_dofs_per_cell < scratch.finite_element_values.get_fe().dofs_per_cell, ExcInternalError());
-        Assert (scratch.grad_phi_field.size() == advection_dofs_per_cell, ExcInternalError());
-        Assert (scratch.phi_field.size() == advection_dofs_per_cell, ExcInternalError());
-
-        const FEValuesExtractors::Scalar solution_field = advection_field.scalar_extractor(introspection);
-
-        scratch.finite_element_values.reinit (cell);
-
-        // get all dof indices on the current cell, then extract those
-        // that correspond to the solution_field we are interested in
-        cell->get_dof_indices (scratch.local_dof_indices);
-
-        // initialize all of the scratch fields for further down
-        scratch.finite_element_values[introspection.extractors.temperature].get_function_values (old_solution,
-            scratch.old_temperature_values);
-        scratch.finite_element_values[introspection.extractors.temperature].get_function_values (old_old_solution,
-            scratch.old_old_temperature_values);
-
-        scratch.finite_element_values[introspection.extractors.velocities].get_function_symmetric_gradients (old_solution,
-            scratch.old_strain_rates);
-        scratch.finite_element_values[introspection.extractors.velocities].get_function_symmetric_gradients (old_old_solution,
-            scratch.old_old_strain_rates);
-
-        scratch.finite_element_values[introspection.extractors.pressure].get_function_values (old_solution,
-            scratch.old_pressure);
-        scratch.finite_element_values[introspection.extractors.pressure].get_function_values (old_old_solution,
-            scratch.old_old_pressure);
-
-        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-          {
-            scratch.finite_element_values[introspection.extractors.compositional_fields[c]].get_function_values(old_solution,
-                scratch.old_composition_values[c]);
-            scratch.finite_element_values[introspection.extractors.compositional_fields[c]].get_function_values(old_old_solution,
-                scratch.old_old_composition_values[c]);
-          }
-
-        scratch.finite_element_values[introspection.extractors.velocities].get_function_values (old_solution,
-            scratch.old_velocity_values);
-        scratch.finite_element_values[introspection.extractors.velocities].get_function_values (old_old_solution,
-            scratch.old_old_velocity_values);
-        scratch.finite_element_values[introspection.extractors.velocities].get_function_values(current_linearization_point,
-            scratch.current_velocity_values);
-
-        scratch.finite_element_values[introspection.extractors.pressure].get_function_gradients (old_solution,
-            scratch.old_pressure_gradients);
-        scratch.finite_element_values[introspection.extractors.pressure].get_function_gradients (old_old_solution,
-            scratch.old_old_pressure_gradients);
-
-
-        scratch.old_field_values = (advection_field.is_temperature()
-                                    ?
-                                    scratch.old_temperature_values
-                                    :
-                                    scratch.old_composition_values[advection_field.compositional_variable]);
-        scratch.old_old_field_values = (advection_field.is_temperature()
-                                        ?
-                                        scratch.old_old_temperature_values
-                                        :
-                                        scratch.old_old_composition_values[advection_field.compositional_variable]);
-
-        scratch.finite_element_values[solution_field].get_function_gradients (old_solution,
-                                                                              scratch.old_field_grads);
-        scratch.finite_element_values[solution_field].get_function_gradients (old_old_solution,
-                                                                              scratch.old_old_field_grads);
-
-        if (update_flags & update_hessians)
-          {
-            scratch.finite_element_values[solution_field].get_function_laplacians (old_solution,
-                                                                                   scratch.old_field_laplacians);
-            scratch.finite_element_values[solution_field].get_function_laplacians (old_old_solution,
-                                                                                   scratch.old_old_field_laplacians);
-          }
-
-        if (parameters.include_melt_transport && melt_handler->is_porosity(advection_field))
-          {
-            scratch.finite_element_values[introspection.extractors.velocities].get_function_divergences (current_linearization_point,
-                scratch.current_velocity_divergences);
-          }
-
-        /**
-         * Explicit material model inputs and outputs.
-         */
-        for (unsigned int q=0; q<n_q_points; ++q)
-          {
-            scratch.material_model_inputs.temperature[q] = (scratch.old_temperature_values[q] + scratch.old_old_temperature_values[q]) / 2;
-            scratch.material_model_inputs.position[q] = scratch.finite_element_values.quadrature_point(q);
-            scratch.material_model_inputs.pressure[q] = (scratch.old_pressure[q] + scratch.old_old_pressure[q]) / 2;
-            scratch.material_model_inputs.velocity[q] = (scratch.old_velocity_values[q] + scratch.old_old_velocity_values[q]) / 2;
-            scratch.material_model_inputs.pressure_gradient[q] = (scratch.old_pressure_gradients[q] + scratch.old_old_pressure_gradients[q]) / 2;
-
-            for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-              scratch.material_model_inputs.composition[q][c] = (scratch.old_composition_values[c][q] + scratch.old_old_composition_values[c][q]) / 2;
-            scratch.material_model_inputs.strain_rate[q] = (scratch.old_strain_rates[q] + scratch.old_old_strain_rates[q]) / 2;
-          }
-        scratch.material_model_inputs.current_cell = cell;
-
-        for (unsigned int i=0; i<assemblers->advection_system[advection_field.field_index()].size(); ++i)
-          assemblers->advection_system[advection_field.field_index()][i]->create_additional_material_model_outputs(scratch.material_model_outputs);
-        heating_model_manager.create_additional_material_model_inputs_and_outputs(scratch.material_model_inputs,
-                                                                                  scratch.material_model_outputs);
-
-        material_model->fill_additional_material_model_inputs(scratch.material_model_inputs,
-                                                              solution,
-                                                              scratch.finite_element_values,
-                                                              introspection);
-        material_model->evaluate(scratch.material_model_inputs,scratch.material_model_outputs);
-        heating_model_manager.evaluate(scratch.material_model_inputs,scratch.material_model_outputs,scratch.heating_model_outputs);
-
-        if (parameters.formulation_temperature_equation
-            == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-          {
-            // Overwrite the density by the reference density coming from the
-            // adiabatic conditions as required by the formulation
-            for (unsigned int q=0; q<n_q_points; ++q)
-              scratch.material_model_outputs.densities[q] = adiabatic_conditions->density(scratch.material_model_inputs.position[q]);
-          }
-        else if (parameters.formulation_temperature_equation
-                 == Parameters<dim>::Formulation::TemperatureEquation::real_density)
-          {
-            // use real density
-          }
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        MaterialModel::MaterialAveraging::average (parameters.material_averaging,
-                                                   cell,
-                                                   scratch.finite_element_values.get_quadrature(),
-                                                   scratch.finite_element_values.get_mapping(),
-                                                   scratch.material_model_inputs.requested_properties,
-                                                   scratch.material_model_outputs);
-
-        if (parameters.advection_stabilization_method == Parameters<dim>::AdvectionStabilizationMethod::entropy_viscosity)
-          {
-            viscosity_per_cell[cell->active_cell_index()] = compute_viscosity(scratch,
-                                                                              global_max_velocity,
-                                                                              global_field_range.second - global_field_range.first,
-                                                                              0.5 * (global_field_range.second + global_field_range.first),
-                                                                              global_entropy_variation,
-                                                                              cell->diameter(),
-                                                                              advection_field);
-          }
-        else if (parameters.advection_stabilization_method == Parameters<dim>::AdvectionStabilizationMethod::supg)
-          {
-            double norm_of_advection_term = 0.0;
-            double max_conductivity_on_cell = 0.0;
-
-            {
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  if (advection_field.is_temperature())
-                    {
-                      norm_of_advection_term =
-                        std::max(scratch.current_velocity_values[q].norm()*
-                                 (scratch.material_model_outputs.densities[q] *
-                                  scratch.material_model_outputs.specific_heat[q] +
-                                  scratch.heating_model_outputs.lhs_latent_heat_terms[q]),
-                                 norm_of_advection_term);
-
-                      max_conductivity_on_cell =
-                        std::max(scratch.material_model_outputs.thermal_conductivities[q],max_conductivity_on_cell);
-                    }
-                  else
-                    {
-                      norm_of_advection_term =
-                        std::max(scratch.current_velocity_values[q].norm(),norm_of_advection_term);
-
-                      max_conductivity_on_cell = 0.0;
-                    }
-                }
-            }
-
-            const double fe_order = advection_field.polynomial_degree(introspection);
-            const double h = cell->diameter();
-            const double eps = max_conductivity_on_cell;
-
-            // SUPG parameter design from "On Discontinuity-Capturing Methods
-            // for Convection-Diffusion Equations" by Volker John and Petr
-            // Knobloch. Also see deal.II step-63:
-            // delta_k = h / (2 \|u\| k) * (coth(Pe) - 1/Pe)
-            // Pe = \| u \| h/(2 p eps)
-            const double peclet_times_eps = norm_of_advection_term * h / (2.0 * fe_order);
-
-            // Instead of Pe < 1, we check Pe*eps < eps as eps can be ==0:
-            if (peclet_times_eps==0.0 || peclet_times_eps < eps)
-              {
-                // Diffusion dominant case, no stabilization needed:
-                viscosity_per_cell[cell->active_cell_index()] = 0.0;
-              }
-            else
-              {
-                // To avoid a division by zero, increase eps slightly. The actual value is not
-                // important, as long as the result is still a valid number. Note that this
-                // is only important if \|u\| and eps are zero.
-                const double peclet = peclet_times_eps / (eps + 1e-100);
-                const double coth_of_peclet = (1.0 + exp(-2.0*peclet)) / (1.0 - exp(-2.0*peclet));
-                const double delta = h/(2.0*norm_of_advection_term*fe_order) * (coth_of_peclet - 1.0/peclet);
-                viscosity_per_cell[cell->active_cell_index()] = delta;
-              }
-            Assert (viscosity_per_cell[cell->active_cell_index()] >= 0, ExcMessage ("tau for SUPG needs to be a nonnegative constant."));
-          }
-        else
-          AssertThrow(false, ExcNotImplemented());
-      }
-
-    // if set to true, the maximum of the artificial viscosity in the cell as well
-    // as the neighbors of the cell is computed and used instead
-    if (parameters.use_artificial_viscosity_smoothing  == true)
-      {
-        Vector<T> viscosity_per_cell_temp;
-        viscosity_per_cell_temp.reinit(triangulation.n_active_cells());
-
-        viscosity_per_cell_temp = viscosity_per_cell;
-        for (const auto &cell : dof_handler.active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              if (skip_interior_cells && !cell->at_boundary())
-                continue;
-
-              for (const unsigned int face_no : cell->face_indices())
-                if (cell->at_boundary(face_no) == false)
-                  {
-                    if (cell->neighbor(face_no)->is_active())
-                      viscosity_per_cell[cell->active_cell_index()] = std::max(viscosity_per_cell[cell->active_cell_index()],
-                                                                               viscosity_per_cell_temp[cell->neighbor(face_no)->active_cell_index()]);
-                    else
-                      for (unsigned int l=0; l<cell->neighbor(face_no)->n_children(); ++l)
-                        if (cell->neighbor(face_no)->child(l)->is_active())
-                          viscosity_per_cell[cell->active_cell_index()] = std::max(viscosity_per_cell[cell->active_cell_index()],
-                                                                                   viscosity_per_cell_temp[cell->neighbor(face_no)->child(l)->active_cell_index()]);
-                  }
-            }
-      }
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template void Simulator<dim>::get_artificial_viscosity (Vector<double> &viscosity_per_cell,  \
-                                                          const AdvectionField &advection_field, \
-                                                          const bool skip_interior_cells) const; \
-  template void Simulator<dim>::get_artificial_viscosity (Vector<float> &viscosity_per_cell,  \
-                                                          const AdvectionField &advection_field, \
-                                                          const bool skip_interior_cells) const;
-
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/helper_functions.cc.bak b/source/simulator/helper_functions.cc.bak
deleted file mode 100644
index bd84cabf160..00000000000
--- a/source/simulator/helper_functions.cc.bak
+++ /dev/null
@@ -1,2521 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/melt.h>
-#include <aspect/volume_of_fluid/handler.h>
-#include <aspect/newton.h>
-#include <aspect/global.h>
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/heating_model/adiabatic_heating.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/particle/generator/interface.h>
-#include <aspect/particle/integrator/interface.h>
-#include <aspect/particle/interpolator/interface.h>
-#include <aspect/particle/property/interface.h>
-#include <aspect/postprocess/visualization.h>
-
-#include <deal.II/base/index_set.h>
-#include <deal.II/base/conditional_ostream.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/lac/block_sparsity_pattern.h>
-#include <deal.II/grid/grid_tools.h>
-
-#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/dof_tools.h>
-
-#include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/fe_dgq.h>
-#include <deal.II/fe/fe_dgp.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <deal.II/sundials/arkode.h>
-
-#include <fstream>
-#include <iostream>
-#include <string>
-
-
-namespace aspect
-{
-
-  template <int dim>
-  Simulator<dim>::AdvectionField::
-  AdvectionField (const FieldType field_type,
-                  const unsigned int compositional_variable)
-    :
-    field_type (field_type),
-    compositional_variable (compositional_variable)
-  {
-    if (field_type == temperature_field)
-      Assert (compositional_variable == numbers::invalid_unsigned_int,
-              ExcMessage ("You can't specify a compositional variable if you "
-                          "have in fact selected the temperature."));
-  }
-
-
-
-  template <int dim>
-  typename Simulator<dim>::AdvectionField
-  Simulator<dim>::AdvectionField::temperature ()
-  {
-    return AdvectionField(temperature_field);
-  }
-
-
-
-  template <int dim>
-  typename Simulator<dim>::AdvectionField
-  Simulator<dim>::AdvectionField::composition (const unsigned int compositional_variable)
-  {
-    return AdvectionField(compositional_field,
-                          compositional_variable);
-  }
-
-
-  template <int dim>
-  bool
-  Simulator<dim>::AdvectionField::is_temperature() const
-  {
-    return (field_type == temperature_field);
-  }
-
-  template <int dim>
-  bool
-  Simulator<dim>::AdvectionField::is_discontinuous(const Introspection<dim> &introspection) const
-  {
-    if (field_type == temperature_field)
-      return introspection.use_discontinuous_temperature_discretization;
-    else if (field_type == compositional_field)
-      return introspection.use_discontinuous_composition_discretization[compositional_variable];
-
-    Assert (false, ExcInternalError());
-    return false;
-  }
-
-  template <int dim>
-  typename Parameters<dim>::AdvectionFieldMethod::Kind
-  Simulator<dim>::AdvectionField::advection_method(const Introspection<dim> &introspection) const
-  {
-    if (field_type == temperature_field)
-      return introspection.temperature_method;
-    else if (field_type == compositional_field)
-      return introspection.compositional_field_methods[compositional_variable];
-
-    Assert (false, ExcInternalError());
-    return Parameters<dim>::AdvectionFieldMethod::fem_field;
-  }
-
-  template <int dim>
-  unsigned int
-  Simulator<dim>::AdvectionField::block_index(const Introspection<dim> &introspection) const
-  {
-    if (this->is_temperature())
-      return introspection.block_indices.temperature;
-    else
-      return introspection.block_indices.compositional_fields[compositional_variable];
-  }
-
-  template <int dim>
-  unsigned int
-  Simulator<dim>::AdvectionField::sparsity_pattern_block_index(const Introspection<dim> &introspection) const
-  {
-    if (this->is_temperature())
-      return introspection.block_indices.temperature;
-    else
-      return introspection.block_indices.compositional_field_sparsity_pattern[compositional_variable];
-  }
-
-  template <int dim>
-  unsigned int
-  Simulator<dim>::AdvectionField::component_index(const Introspection<dim> &introspection) const
-  {
-    if (this->is_temperature())
-      return introspection.component_indices.temperature;
-    else
-      return introspection.component_indices.compositional_fields[compositional_variable];
-  }
-
-  template <int dim>
-  unsigned int
-  Simulator<dim>::AdvectionField::field_index() const
-  {
-    if (this->is_temperature())
-      return 0;
-    else
-      return compositional_variable + 1;
-  }
-
-  template <int dim>
-  unsigned int
-  Simulator<dim>::AdvectionField::base_element(const Introspection<dim> &introspection) const
-  {
-    if (this->is_temperature())
-      return introspection.base_elements.temperature;
-    else
-      return introspection.base_elements.compositional_fields[compositional_variable];
-  }
-
-  template <int dim>
-  FEValuesExtractors::Scalar
-  Simulator<dim>::AdvectionField::scalar_extractor(const Introspection<dim> &introspection) const
-  {
-    if (this->is_temperature())
-      return introspection.extractors.temperature;
-    else
-      {
-        Assert(compositional_variable < introspection.n_compositional_fields,
-               ExcMessage("Invalid AdvectionField."));
-        return introspection.extractors.compositional_fields[compositional_variable];
-      }
-  }
-
-  template <int dim>
-  unsigned int
-  Simulator<dim>::AdvectionField::polynomial_degree(const Introspection<dim> &introspection) const
-  {
-    if (this->is_temperature())
-      return introspection.polynomial_degree.temperature;
-    else
-      return introspection.polynomial_degree.compositional_fields;
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::write_plugin_graph (std::ostream &out) const
-  {
-    // write the preamble
-    out << "digraph Plugins\n"
-        "{\n"
-        "  splines=line;\n"
-        "  splines=true;\n"
-        "  overlap=false;\n"
-        "  edge [fontname=\"FreeSans\",\n"
-        "        fontsize=\"10\",\n"
-        "        labelfontname=\"FreeSans\",\n"
-        "        labelfontsize=\"10\",\n"
-        "        color=\"black\",\n"
-        "        style=\"solid\"];\n"
-        "  node [fontname=\"FreeSans\",\n"
-        "        fontsize=\"10\",\n"
-        "        shape=\"rectangle\",\n"
-        "        height=0.2,\n"
-        "        width=0.4,\n"
-        "        color=\"black\",\n"
-        "        fillcolor=\"white\",\n"
-        "        style=\"filled\"];\n"
-        "  layout=neato;\n"
-        "\n";
-
-    // then also write nodes for the Simulator and SimulatorAccess classes,
-    // and an arrow from the former to the latter to indicate flow of
-    // information
-    out << "  Simulator [height=1.5,width=2,shape=\"octagon\",fillcolor=\"yellow\"];\n";
-    out << "  SimulatorAccess [height=1.2,width=1.2,shape=\"rect\",fillcolor=\"yellow\"];\n";
-    out << "  Simulator -> SimulatorAccess [len=1, weight=100];\n";
-
-    // then go through all plugin systems and output everything we have
-    AdiabaticConditions::write_plugin_graph<dim>(out);
-    BoundaryComposition::Manager<dim>::write_plugin_graph(out);
-    BoundaryFluidPressure::write_plugin_graph<dim>(out);
-    BoundaryTemperature::Manager<dim>::write_plugin_graph(out);
-    BoundaryTraction::Manager<dim>::write_plugin_graph(out);
-    BoundaryVelocity::Manager<dim>::write_plugin_graph(out);
-    InitialTopographyModel::write_plugin_graph<dim>(out);
-    GeometryModel::write_plugin_graph<dim>(out);
-    GravityModel::write_plugin_graph<dim>(out);
-    HeatingModel::Manager<dim>::write_plugin_graph(out);
-    InitialComposition::Manager<dim>::write_plugin_graph(out);
-    InitialTemperature::Manager<dim>::write_plugin_graph(out);
-    MaterialModel::write_plugin_graph<dim>(out);
-    MeshRefinement::Manager<dim>::write_plugin_graph(out);
-    Particle::Generator::write_plugin_graph<dim>(out);
-    Particle::Integrator::write_plugin_graph<dim>(out);
-    Particle::Interpolator::write_plugin_graph<dim>(out);
-    Particle::Property::Manager<dim>::write_plugin_graph(out);
-    Postprocess::Manager<dim>::write_plugin_graph(out);
-    Postprocess::Visualization<dim>::write_plugin_graph(out);
-    PrescribedStokesSolution::write_plugin_graph<dim>(out);
-    TerminationCriteria::Manager<dim>::write_plugin_graph(out);
-
-    // end the graph
-    out << '}'
-        << std::endl;
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::output_statistics()
-  {
-    // Only write the statistics file from processor zero
-    if (Utilities::MPI::this_mpi_process(mpi_communicator)!=0)
-      return;
-
-    // Formatting the table we're about to output and writing the
-    // actual file may take some time, so do it on a separate
-    // thread. We do this using a lambda function that takes
-    // a copy of the statistics object to make sure that whatever
-    // we do to the 'real' statistics object at the time of
-    // writing data doesn't affect what we write.
-    //
-    // Before we can start working on a new thread, we need to
-    // make sure that the previous thread is done or they'll
-    // step on each other's feet.
-    if (output_statistics_thread.joinable())
-      output_statistics_thread.join();
-
-    // Write data in the background through a lambda function.
-    // This happening in the background means that we have
-    // to create a copy of the statistics table, since whatever is
-    // running in the foreground may continue to add entries to the
-    // statistics table at the same time.
-    output_statistics_thread = std::thread (
-                                 [statistics_copy_ptr = std::make_unique<TableHandler>(statistics),this]()
-    {
-      // First write everything into a string in memory
-      std::ostringstream stream;
-      statistics_copy_ptr->write_text (stream,
-                                       TableHandler::table_with_separate_column_description);
-      stream.flush();
-
-      const std::string statistics_contents = stream.str();
-
-      // Next find out whether we need to write everything into
-      // the statistics file, or whether it is enough to just write
-      // the last few bytes that were added since we wrote to that
-      // file again. The way we do that is by checking whether the
-      // first few bytes of the string we just created match what we
-      // had previously written. One might think that they always should,
-      // but the statistics object automatically sizes the column widths
-      // of its output to match what is being written, and so if a later
-      // entry requires more width, then even the first columns are
-      // changed -- in that case, we will have to write everything,
-      // not just append one line.
-      const bool write_everything
-        = ( // We may have never written anything. More precisely, this
-            // case happens if the statistics_last_write_size is at the
-            // value initialized by the Simulator::Simulator()
-            // constructor, and this can happen in two situations:
-            // (i) At the end of the first time step; and (ii) upon restart
-            // since the variable we query here is not serialized. It is clear
-            // that in both situations, we want to write the
-            // entire contents of the statistics object. For the second
-            // case, this is also appropriate since someone may have
-            // previously restarted from a checkpoint, run a couple of
-            // time steps that have added to the statistics file, but then
-            // aborted the run again; a later restart from the same
-            // checkpoint then requires overwriting the statistics file
-            // on disk with what we have when this function is called for
-            // the first time after the restart. The same situation
-            // happens if the simulation kept running for some time after
-            // a checkpoint, but is resumed from that checkpoint (i.e.,
-            // at an earlier time step than when the statistics file was
-            // written to last). In these situations, we effectively want
-            // to "truncate" the file to the state stored in the checkpoint,
-            // and we do that by just overwriting the entire file.
-            (statistics_last_write_size == 0)
-            ||
-            // Or the size of the statistics file may have
-            // shrunk mysteriously -- this shouldn't happen
-            // but if it did we'd get into trouble with the
-            // .substr() call in the next check.
-            (statistics_last_write_size > statistics_contents.size())
-            ||
-            // Or the hash of what we wrote last time doesn't match
-            // the hash of the first part of what we want to write
-            (statistics_last_hash
-             !=
-             std::hash<std::string>()(statistics_contents.substr(0, statistics_last_write_size))) );
-
-      const std::string stat_file_name = parameters.output_directory + "statistics";
-      if (write_everything)
-        {
-          // Write what we have into a tmp file, then move that into
-          // place
-          const std::string tmp_file_name = stat_file_name + ".tmp";
-          {
-            std::ofstream tmp_file (tmp_file_name);
-            tmp_file << statistics_contents;
-          }
-          std::rename(tmp_file_name.c_str(), stat_file_name.c_str());
-        }
-      else
-        {
-          // If we don't have to write everything, then the first part of what
-          // we want to write matches what's already on disk. In that case,
-          // we just have to append what's new.
-          std::ofstream stat_file (stat_file_name, std::ios::app);
-          stat_file << statistics_contents.substr(statistics_last_write_size, std::string::npos);
-        }
-
-      // Now update the size and hash of what we just wrote so that
-      // we can compare against it next time we get here. Note that we do
-      // not need to guard access to these variables with a mutex because
-      // this is the only function that touches the variables, and
-      // this function runs only once at a time (on a different
-      // thread, but it's not started a second time while the previous
-      // run hasn't finished).
-      statistics_last_write_size = statistics_contents.size();
-      statistics_last_hash       = std::hash<std::string>()(statistics_contents);
-    });
-  }
-
-
-
-  template <int dim>
-  double
-  Simulator<dim>::
-  compute_pressure_scaling_factor() const
-  {
-    // Determine how to treat the pressure. We have to scale it for the solver
-    // to make velocities and pressures of roughly the same (numerical) size,
-    // and we may have to fix up the right hand side vector before solving for
-    // compressible models if there are no in-/outflow boundaries
-    //
-    // We do this by scaling the divergence equation by a constant factor that
-    // is equal to a reference viscosity divided by a length scale.
-    // We get the latter from the geometry model, and the former
-    // by looping over all cells and averaging the "order of magnitude"
-    // of the viscosity. The order of magnitude is the logarithm of
-    // the viscosity, so
-    //
-    //   \eta_{ref} = exp ( 1/N * (log(eta_1) + log(eta_2) + ... + log(eta_N))
-    //
-    // where the \eta_i are typical viscosities on the cells of the mesh.
-    // For this, we just take the viscosity at the cell center.
-    //
-    // The formula above computes the exponential of the average of the
-    // logarithms. It is easy to verify that this is equivalent to
-    // computing the *geometric* mean of the viscosities, but the
-    // formula above is numerically stable.
-
-    // Do return NaN if we do not solve the Stokes equation. Technically, there is
-    // no harm in computing the factor anyway, but the viscosity has to be positive
-    // for this function to work, and some models may set viscosity to 0 if not solving
-    // the Stokes equation. Returning NaN guarantees this value cannot be used.
-    if (parameters.nonlinear_solver == NonlinearSolver::no_Advection_no_Stokes ||
-        parameters.nonlinear_solver == NonlinearSolver::single_Advection_no_Stokes)
-      return numbers::signaling_nan<double>();
-
-    const QMidpoint<dim> quadrature_formula;
-
-    FEValues<dim> fe_values (*mapping,
-                             finite_element,
-                             quadrature_formula,
-                             update_values |
-                             update_gradients |
-                             update_quadrature_points |
-                             update_JxW_values);
-
-    const unsigned int n_q_points = quadrature_formula.size();
-
-    double local_integrated_viscosity_logarithm = 0.;
-    double local_volume = 0.;
-
-    MaterialModel::MaterialModelInputs<dim> in(n_q_points,
-                                               introspection.n_compositional_fields);
-    MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
-                                                 introspection.n_compositional_fields);
-
-    // We do not need to compute anything but the viscosity
-    in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          in.reinit(fe_values,
-                    cell,
-                    introspection,
-                    solution);
-
-          // We do not call the cell-wise average function of the
-          // material model, because we average globally below
-          material_model->evaluate(in, out);
-
-          // Evaluate viscosity at the mid-point of each cell and
-          // calculate the volume weighted harmonic average of all cells
-          for (unsigned int q=0; q<n_q_points; ++q)
-            {
-              Assert(out.viscosities[q] > 0,
-                     ExcMessage ("The viscosity needs to be a "
-                                 "positive quantity."));
-
-              const double JxW = fe_values.JxW(q);
-              local_integrated_viscosity_logarithm += std::log(out.viscosities[q]) * JxW;
-              local_volume += JxW;
-            }
-        }
-
-    // vector for packing local values before MPI summing them
-    double values[2] = {local_integrated_viscosity_logarithm, local_volume};
-
-    Utilities::MPI::sum(values, mpi_communicator, values);
-
-    const double reference_viscosity = std::exp(values[0]/values[1]);
-    const double length_scale = geometry_model->length_scale();
-
-    // Allow the user to inspect and/or overwrite our result:
-    const double result = reference_viscosity / length_scale;
-    if (boost::optional<double> value = signals.modify_pressure_scaling(result, reference_viscosity, length_scale))
-      return *value;
-    else
-      return result;
-  }
-
-
-
-  template <int dim>
-  double
-  Simulator<dim>::
-  get_maximal_velocity (const LinearAlgebra::BlockVector &solution) const
-  {
-    // use a quadrature formula that has one point at
-    // the location of each degree of freedom in the
-    // velocity element
-    const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
-                                             parameters.stokes_velocity_degree);
-    const unsigned int n_q_points = quadrature_formula.size();
-
-
-    FEValues<dim> fe_values (*mapping, finite_element, quadrature_formula, update_values);
-    std::vector<Tensor<1,dim>> velocity_values(n_q_points);
-
-    double max_local_velocity = 0;
-
-    // loop over all locally owned cells and evaluate the velocities at each
-    // quadrature point (i.e. each node). keep a running tally of the largest
-    // such velocity
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          fe_values[introspection.extractors.velocities].get_function_values (solution,
-                                                                              velocity_values);
-
-          for (unsigned int q=0; q<n_q_points; ++q)
-            max_local_velocity = std::max (max_local_velocity,
-                                           velocity_values[q].norm());
-        }
-
-    // return the largest value over all processors
-    return Utilities::MPI::max (max_local_velocity, mpi_communicator);
-  }
-
-
-
-  template <int dim>
-  bool Simulator<dim>::maybe_do_initial_refinement (const unsigned int max_refinement_level)
-  {
-    if (pre_refinement_step < parameters.initial_adaptive_refinement)
-      {
-        if (parameters.timing_output_frequency == 0)
-          {
-            computing_timer.print_summary ();
-            pcout << "-- Total wallclock time elapsed including restarts: "
-                  << round(wall_timer.wall_time()+total_walltime_until_last_snapshot)
-                  << 's' << std::endl;
-          }
-
-        output_statistics();
-
-        // we only want to do the postprocessing here if it is not already done in
-        // the nonlinear iteration scheme, which is the case if we run postprocessors
-        // on all nonlinear iterations
-        if (parameters.run_postprocessors_on_initial_refinement && (!parameters.run_postprocessors_on_nonlinear_iterations))
-          postprocess ();
-
-        refine_mesh (max_refinement_level);
-        ++pre_refinement_step;
-        return true;
-      }
-    else
-      {
-        // invalidate the value of pre_refinement_step since it will no longer be used from here on
-        pre_refinement_step = std::numeric_limits<unsigned int>::max();
-        return false;
-      }
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::exchange_refinement_flags ()
-  {
-    // Communicate refinement flags on ghost cells from the owner of the
-    // cell. This is necessary to get consistent refinement, as mesh
-    // smoothing would undo some of the requested coarsening/refinement.
-
-    auto pack
-    = [] (const typename DoFHandler<dim>::active_cell_iterator &cell) -> std::uint8_t
-    {
-      if (cell->refine_flag_set())
-        return 1;
-      if (cell->coarsen_flag_set())
-        return 2;
-      return 0;
-    };
-    auto unpack
-    = [] (const typename DoFHandler<dim>::active_cell_iterator &cell, const std::uint8_t &flag) -> void
-    {
-      cell->clear_coarsen_flag();
-      cell->clear_refine_flag();
-      if (flag==1)
-        cell->set_refine_flag();
-      else if (flag==2)
-        cell->set_coarsen_flag();
-    };
-
-    GridTools::exchange_cell_data_to_ghosts<std::uint8_t, DoFHandler<dim>>
-    (dof_handler, pack, unpack);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::maybe_refine_mesh (const double new_time_step,
-                                          unsigned int &max_refinement_level)
-  {
-    /*
-     * see if this is an additional refinement cycle. An additional refinement
-     * cycle differs from a regular, because the maximal refinement level allowed
-     * is increased by one from this time on.
-     */
-    if ((parameters.additional_refinement_times.size() > 0)
-        &&
-        (parameters.additional_refinement_times.front () < time+new_time_step))
-      {
-        // loop over as many times as this is necessary
-        while ((parameters.additional_refinement_times.size() > 0)
-               &&
-               (parameters.additional_refinement_times.front () < time+new_time_step))
-          {
-            ++max_refinement_level;
-            refine_mesh (max_refinement_level);
-
-            parameters.additional_refinement_times
-            .erase (parameters.additional_refinement_times.begin());
-          }
-      }
-    // see if this is a time step where regular refinement is requested
-    else if ((timestep_number > 0
-              &&
-              parameters.adaptive_refinement_interval > 0
-              &&
-              timestep_number % parameters.adaptive_refinement_interval == 0)
-             ||
-             (timestep_number == 0 && parameters.adaptive_refinement_interval == 1)
-            )
-      {
-        refine_mesh (max_refinement_level);
-      }
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::maybe_write_timing_output () const
-  {
-    bool write_timing_output = false;
-    if (parameters.timing_output_frequency <= 1)
-      write_timing_output = true;
-    else if ((timestep_number > 0) &&
-             (timestep_number % parameters.timing_output_frequency == 0))
-      write_timing_output = true;
-
-    // if requested output a summary of the current timing information
-    if (write_timing_output)
-      {
-        computing_timer.print_summary ();
-        pcout << "-- Total wallclock time elapsed including restarts: "
-              << round(wall_timer.wall_time()+total_walltime_until_last_snapshot)
-              << 's' << std::endl;
-      }
-  }
-
-
-
-  template <int dim>
-  bool Simulator<dim>::maybe_write_checkpoint (const time_t last_checkpoint_time,
-                                               const bool force_writing_checkpoint)
-  {
-    // Do a checkpoint if this is the end of simulation,
-    // and the termination criteria say to checkpoint at the end.
-    bool write_checkpoint = force_writing_checkpoint;
-
-    // If we base checkpoint frequency on timing, measure the time at process 0
-    // This prevents race conditions where some processes will checkpoint and others won't
-    if (!write_checkpoint && parameters.checkpoint_time_secs > 0)
-      {
-        int global_do_checkpoint = ((std::time(nullptr)-last_checkpoint_time) >=
-                                    parameters.checkpoint_time_secs);
-        const int ierr = MPI_Bcast(&global_do_checkpoint, 1, MPI_INT, 0, mpi_communicator);
-        AssertThrowMPI(ierr);
-
-        if (global_do_checkpoint == 1)
-          write_checkpoint = true;
-      }
-
-    // If we base checkpoint frequency on steps, see if it's time for another checkpoint
-    if (!write_checkpoint &&
-        (parameters.checkpoint_time_secs == 0) &&
-        (parameters.checkpoint_steps > 0) &&
-        (timestep_number % parameters.checkpoint_steps == 0))
-      write_checkpoint = true;
-
-    // Do a checkpoint if indicated by checkpoint parameters
-    if (write_checkpoint)
-      {
-        create_snapshot();
-        // matrices will be regenerated after a resume, so do that here too
-        // to be consistent. otherwise we would get different results
-        // for a restarted computation than for one that ran straight
-        // through
-        rebuild_stokes_matrix =
-          rebuild_stokes_preconditioner = true;
-      }
-    return write_checkpoint;
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::advance_time (const double step_size)
-  {
-    old_time_step = time_step;
-    time_step = step_size;
-    time += time_step;
-    ++timestep_number;
-
-    // prepare for the next time step by shifting solution vectors
-    // by one time step. In timestep 0 (just increased in the
-    // line above) initialize both old_solution
-    // and old_old_solution with the currently computed solution.
-    if (timestep_number == 1)
-      {
-        old_old_solution      = solution;
-        old_solution          = solution;
-      }
-    else
-      {
-        old_old_solution      = old_solution;
-        old_solution          = solution;
-      }
-  }
-
-
-
-  template <int dim>
-  std::pair<double,double>
-  Simulator<dim>::
-  get_extrapolated_advection_field_range (const AdvectionField &advection_field) const
-  {
-    const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
-                                             advection_field.polynomial_degree(introspection));
-
-    const unsigned int n_q_points = quadrature_formula.size();
-
-    const FEValuesExtractors::Scalar field = advection_field.scalar_extractor(introspection);
-
-    FEValues<dim> fe_values (*mapping, finite_element, quadrature_formula,
-                             update_values);
-    std::vector<double> old_field_values(n_q_points);
-    std::vector<double> old_old_field_values(n_q_points);
-
-    // This presets the minimum with a bigger
-    // and the maximum with a smaller number
-    // than one that is going to appear. Will
-    // be overwritten in the cell loop or in
-    // the communication step at the
-    // latest.
-    double min_local_field = std::numeric_limits<double>::max(),
-           max_local_field = std::numeric_limits<double>::lowest();
-
-    if (timestep_number > 1)
-      {
-        for (const auto &cell : dof_handler.active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              fe_values.reinit (cell);
-              fe_values[field].get_function_values (old_solution,
-                                                    old_field_values);
-              fe_values[field].get_function_values (old_old_solution,
-                                                    old_old_field_values);
-
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  const double extrapolated_field =
-                    (1. + time_step/old_time_step) * old_field_values[q]-
-                    time_step/old_time_step * old_old_field_values[q];
-
-                  min_local_field = std::min (min_local_field,
-                                              extrapolated_field);
-                  max_local_field = std::max (max_local_field,
-                                              extrapolated_field);
-                }
-            }
-      }
-    else
-      {
-        for (const auto &cell : dof_handler.active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              fe_values.reinit (cell);
-              fe_values[field].get_function_values (old_solution,
-                                                    old_field_values);
-
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  const double extrapolated_field = old_field_values[q];
-
-                  min_local_field = std::min (min_local_field,
-                                              extrapolated_field);
-                  max_local_field = std::max (max_local_field,
-                                              extrapolated_field);
-                }
-            }
-      }
-
-    return std::make_pair(Utilities::MPI::min (min_local_field,
-                                               mpi_communicator),
-                          Utilities::MPI::max (max_local_field,
-                                               mpi_communicator));
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::interpolate_onto_velocity_system(const TensorFunction<1,dim> &func,
-                                                        LinearAlgebra::Vector &vec)
-  {
-    Assert(introspection.block_indices.velocities == 0, ExcNotImplemented());
-
-    const std::vector<Point<dim>> mesh_support_points = finite_element.base_element(introspection.base_elements.velocities).get_unit_support_points();
-    const unsigned int n_velocity_dofs_per_cell = finite_element.base_element(introspection.base_elements.velocities).dofs_per_cell;
-
-    FEValues<dim> mesh_points (*mapping, finite_element, mesh_support_points, update_quadrature_points);
-    std::vector<types::global_dof_index> cell_dof_indices (finite_element.dofs_per_cell);
-
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          mesh_points.reinit(cell);
-          cell->get_dof_indices (cell_dof_indices);
-          for (unsigned int j=0; j<n_velocity_dofs_per_cell; ++j)
-            for (unsigned int dir=0; dir<dim; ++dir)
-              {
-                const unsigned int support_point_index
-                  = finite_element.component_to_system_index(/*velocity component=*/ introspection.component_indices.velocities[dir],
-                                                                                     /*dof index within component=*/ j);
-                vec[cell_dof_indices[support_point_index]] = func.value(mesh_points.quadrature_point(j))[dir];
-              }
-        }
-
-    vec.compress(VectorOperation::insert);
-
-    AffineConstraints<double> hanging_node_constraints(introspection.index_sets.system_relevant_set);
-    DoFTools::make_hanging_node_constraints(dof_handler, hanging_node_constraints);
-    hanging_node_constraints.close();
-
-    // Create a view of all constraints that only pertains to the
-    // Stokes subset of degrees of freedom. We can then use this later
-    // to call constraints.distribute(), constraints.set_zero(), etc.,
-    // on those block vectors that only have the Stokes components in
-    // them.
-    //
-    // For the moment, assume that the Stokes degrees are first in the
-    // overall vector, so that they form a contiguous range starting
-    // at zero. The assertion checks this, but this could easily be
-    // generalized if the Stokes block were not starting at zero.
-#if DEAL_II_VERSION_GTE(9,6,0)
-    Assert (introspection.block_indices.velocities == 0,
-            ExcNotImplemented());
-    if (parameters.use_direct_stokes_solver == false)
-      Assert (introspection.block_indices.pressure == 1,
-              ExcNotImplemented());
-
-    IndexSet stokes_dofs (dof_handler.n_dofs());
-    stokes_dofs.add_range (0, vec.size());
-    const AffineConstraints<double> stokes_hanging_node_constraints
-      = hanging_node_constraints.get_view (stokes_dofs);
-#else
-    const AffineConstraints<double> &stokes_hanging_node_constraints = hanging_node_constraints;
-#endif
-
-    stokes_hanging_node_constraints.distribute(vec);
-  }
-
-
-
-  template <int dim>
-  double Simulator<dim>::normalize_pressure (LinearAlgebra::BlockVector &vector) const
-  {
-    if (parameters.pressure_normalization == "no")
-      return 0;
-
-    const FEValuesExtractors::Scalar &extractor_pressure =
-      (parameters.include_melt_transport ?
-       introspection.variable("fluid pressure").extractor_scalar()
-       : introspection.extractors.pressure);
-
-    double my_pressure = 0.0;
-    double my_area = 0.0;
-    if (parameters.pressure_normalization == "surface")
-      {
-        const types::boundary_id top_boundary_id = geometry_model->translate_symbolic_boundary_name_to_id("top");
-
-        const Quadrature<dim-1> &quadrature = this->introspection.face_quadratures.pressure;
-        const unsigned int n_q_points = quadrature.size();
-
-        FEFaceValues<dim> fe_face_values (*mapping, finite_element,  quadrature,
-                                          update_JxW_values | update_values);
-
-        std::vector<double> pressure_values(n_q_points);
-
-        for (const auto &cell : dof_handler.active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              for (const unsigned int face_no : cell->face_indices())
-                {
-                  const typename DoFHandler<dim>::face_iterator face = cell->face (face_no);
-                  if (face->at_boundary() && face->boundary_id() == top_boundary_id)
-                    {
-                      fe_face_values.reinit (cell, face_no);
-                      fe_face_values[extractor_pressure].get_function_values(vector,
-                                                                             pressure_values);
-
-                      for (unsigned int q = 0; q < n_q_points; ++q)
-                        {
-                          const double JxW = fe_face_values.JxW(q);
-                          my_pressure += pressure_values[q]
-                                         * JxW;
-                          my_area += JxW;
-                        }
-                    }
-                }
-            }
-      }
-    else if (parameters.pressure_normalization == "volume")
-      {
-        const Quadrature<dim> &quadrature = this->introspection.quadratures.pressure;
-        const unsigned int n_q_points = quadrature.size();
-
-        FEValues<dim> fe_values (*mapping, finite_element,  quadrature,
-                                 update_JxW_values | update_values);
-
-        std::vector<double> pressure_values(n_q_points);
-
-        for (const auto &cell : dof_handler.active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              fe_values.reinit (cell);
-              fe_values[extractor_pressure].get_function_values(vector,
-                                                                pressure_values);
-
-              for (unsigned int q = 0; q < n_q_points; ++q)
-                {
-                  my_pressure += pressure_values[q]
-                                 * fe_values.JxW (q);
-                  my_area += fe_values.JxW (q);
-                }
-            }
-      }
-    else
-      AssertThrow (false, ExcMessage("Invalid pressure normalization method: " +
-                                     parameters.pressure_normalization));
-
-    // sum up the integrals from each processor and compute the result we care about
-    double pressure_adjustment = numbers::signaling_nan<double>();
-    {
-      const double my_temp[2] = {my_pressure, my_area};
-      double temp[2];
-      Utilities::MPI::sum (my_temp, mpi_communicator, temp);
-      const double pressure = temp[0];
-      const double area = temp[1];
-
-      Assert (area > 0,
-              ExcMessage("While computing the average pressure, the area/volume "
-                         "to integrate over was found to be zero or negative. This "
-                         "indicates that no appropriate surface faces were found, "
-                         "which is typically the case if the geometry model is not "
-                         "set up correctly."));
-
-      if (parameters.pressure_normalization == "surface")
-        pressure_adjustment = -pressure/area + parameters.surface_pressure;
-      else if (parameters.pressure_normalization == "volume")
-        pressure_adjustment = -pressure/area;
-      else
-        AssertThrow(false, ExcNotImplemented());
-    }
-
-    // A complication is that we can't modify individual
-    // elements of the solution vector since that one has ghost element.
-    // rather, we first need to localize it and then distribute back
-    LinearAlgebra::BlockVector distributed_vector (introspection.index_sets.system_partitioning,
-                                                   mpi_communicator);
-    distributed_vector = vector;
-
-    if (parameters.use_locally_conservative_discretization == false)
-      {
-        if (introspection.block_indices.velocities != introspection.block_indices.pressure
-            && !parameters.include_melt_transport)
-          distributed_vector.block(introspection.block_indices.pressure).add(pressure_adjustment);
-        else
-          {
-            // pressure is not in a separate block, so we have to modify the values manually
-            const unsigned int pressure_component = (parameters.include_melt_transport ?
-                                                     introspection.variable("fluid pressure").first_component_index
-                                                     : introspection.component_indices.pressure);
-            const unsigned int n_local_pressure_dofs = (parameters.include_melt_transport ?
-                                                        finite_element.base_element(introspection.variable("fluid pressure").base_index).dofs_per_cell
-                                                        : finite_element.base_element(introspection.base_elements.pressure).dofs_per_cell);
-            std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-            for (const auto &cell : dof_handler.active_cell_iterators())
-              if (cell->is_locally_owned())
-                {
-                  cell->get_dof_indices (local_dof_indices);
-                  for (unsigned int j=0; j<n_local_pressure_dofs; ++j)
-                    {
-                      unsigned int support_point_index
-                        = finite_element.component_to_system_index(pressure_component,
-                                                                   /*dof index within component=*/ j);
-
-                      // then adjust its value. Note that because we end up touching
-                      // entries more than once, we are not simply incrementing
-                      // distributed_vector but copy from the unchanged vector.
-                      distributed_vector(local_dof_indices[support_point_index]) = vector(local_dof_indices[support_point_index]) + pressure_adjustment;
-                    }
-                }
-            distributed_vector.compress(VectorOperation::insert);
-          }
-      }
-    else
-      {
-        // this case is a bit more complicated: if the condition above is false
-        // then we use the FE_DGP element for which the shape functions do not
-        // add up to one; consequently, adding a constant to all degrees of
-        // freedom does not alter the overall function by that constant, but
-        // by something different
-        //
-        // we can work around this by using the documented property of the
-        // FE_DGP element that the first shape function is constant.
-        // consequently, adding the adjustment to the global function is
-        // achieved by adding the adjustment to the first pressure degree
-        // of freedom on each cell.
-        Assert (dynamic_cast<const FE_DGP<dim>*>(&finite_element.base_element(introspection.base_elements.pressure)) != nullptr,
-                ExcInternalError());
-        const unsigned int pressure_component = (parameters.include_melt_transport ?
-                                                 introspection.variable("fluid pressure").first_component_index
-                                                 : introspection.component_indices.pressure);
-        std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-
-        for (const auto &cell : dof_handler.active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              // identify the first pressure dof
-              cell->get_dof_indices (local_dof_indices);
-              const unsigned int first_pressure_dof
-                = finite_element.component_to_system_index (pressure_component, 0);
-
-              // make sure that this DoF is really owned by the current processor
-              // and that it is in fact a pressure dof
-              Assert (dof_handler.locally_owned_dofs().is_element(local_dof_indices[first_pressure_dof]),
-                      ExcInternalError());
-
-              // then adjust its value
-              distributed_vector(local_dof_indices[first_pressure_dof]) = vector(local_dof_indices[first_pressure_dof])
-                                                                          + pressure_adjustment;
-            }
-        distributed_vector.compress(VectorOperation::insert);
-      }
-
-    // now get back to the original vector and return the adjustment used
-    // in the computations above
-    vector = distributed_vector;
-
-    return pressure_adjustment;
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::
-  denormalize_pressure (const double                      pressure_adjustment,
-                        LinearAlgebra::BlockVector       &vector,
-                        const LinearAlgebra::BlockVector &relevant_vector) const
-  {
-    if (parameters.pressure_normalization == "no")
-      return;
-
-    if (parameters.use_locally_conservative_discretization == false)
-      {
-        if ((introspection.block_indices.velocities != introspection.block_indices.pressure)
-            && !parameters.include_melt_transport)
-          vector.block(introspection.block_indices.pressure).add(-1.0 * pressure_adjustment);
-        else
-          {
-            // pressure is not in a separate block so we have to modify the values manually
-            const unsigned int pressure_component = (parameters.include_melt_transport ?
-                                                     introspection.variable("fluid pressure").first_component_index
-                                                     : introspection.component_indices.pressure);
-            const unsigned int n_local_pressure_dofs = (parameters.include_melt_transport ?
-                                                        finite_element.base_element(introspection.variable("fluid pressure").base_index).dofs_per_cell
-                                                        : finite_element.base_element(introspection.base_elements.pressure).dofs_per_cell);
-
-            std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-            for (const auto &cell : dof_handler.active_cell_iterators())
-              if (cell->is_locally_owned())
-                {
-                  cell->get_dof_indices (local_dof_indices);
-                  for (unsigned int j=0; j<n_local_pressure_dofs; ++j)
-                    {
-                      const unsigned int local_dof_index
-                        = finite_element.component_to_system_index(pressure_component,
-                                                                   /*dof index within component=*/ j);
-
-                      // then adjust its value. Note that because we end up touching
-                      // entries more than once, we are not simply incrementing
-                      // distributed_vector but copy from the unchanged vector.
-                      vector(local_dof_indices[local_dof_index])
-                        = relevant_vector(local_dof_indices[local_dof_index]) - pressure_adjustment;
-                    }
-                }
-            vector.compress(VectorOperation::insert);
-          }
-      }
-    else
-      {
-        // this case is a bit more complicated: if the condition above is false
-        // then we use the FE_DGP element for which the shape functions do not
-        // add up to one; consequently, adding a constant to all degrees of
-        // freedom does not alter the overall function by that constant, but
-        // by something different
-        //
-        // we can work around this by using the documented property of the
-        // FE_DGP element that the first shape function is constant.
-        // consequently, adding the adjustment to the global function is
-        // achieved by adding the adjustment to the first pressure degree
-        // of freedom on each cell.
-        Assert (dynamic_cast<const FE_DGP<dim>*>(&finite_element.base_element(introspection.base_elements.pressure)) != nullptr,
-                ExcInternalError());
-        Assert(!parameters.include_melt_transport, ExcNotImplemented());
-        const unsigned int pressure_component = introspection.component_indices.pressure;
-        std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-        for (const auto &cell : dof_handler.active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              // identify the first pressure dof
-              cell->get_dof_indices (local_dof_indices);
-              const unsigned int first_pressure_dof
-                = finite_element.component_to_system_index (pressure_component, 0);
-
-              // make sure that this DoF is really owned by the current processor
-              // and that it is in fact a pressure dof
-              Assert (dof_handler.locally_owned_dofs().is_element(local_dof_indices[first_pressure_dof]),
-                      ExcInternalError());
-
-              // then adjust its value
-              vector (local_dof_indices[first_pressure_dof]) = relevant_vector(local_dof_indices[first_pressure_dof])
-                                                               - pressure_adjustment;
-            }
-
-        vector.compress(VectorOperation::insert);
-      }
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::make_pressure_rhs_compatible(LinearAlgebra::BlockVector &vector)
-  {
-    // If the mass conservation is written as
-    //   div u = f
-    // make sure this is solvable by modifying f to ensure that
-    // int_\Omega f = int_\Omega div u = 0
-    //
-    // We have to deal with several complications:
-    // - we can have an FE_Q or an FE_DGP for the pressure
-    // - we might use a direct solver, so pressure and velocity are in the same block
-    // - we might have melt transport, where we need to operate only on p_f
-    //
-    // We ensure int_\Omega f = 0 by computing a correction factor
-    //   c = \int f
-    // and adjust pressure RHS to be
-    //  fnew = f - c/|\Omega|
-    // such that
-    //   \int fnew = \int f - c/|\Omega| = -c + \int f = 0.
-    //
-    // We can compute
-    //   c = \int f = (f, 1) = (f, \sum_i \phi_i) = \sum_i (f, \phi_i) = \sum_i F_i
-    // which is just the sum over the RHS vector for FE_Q. For FE_DGP
-    // we need to restrict to 0th shape functions on each cell,
-    // because this is the shape function that is constant 1. (The
-    // other shape functions have mean value zero.)
-    //
-    // To make the adjustment fnew = f - c/|\Omega|
-    // note that
-    // fnew_i = f_i - c/|\Omega| * (1, \phi_i)
-    // and the same logic for FE_DGP applies
-
-
-    if ((!parameters.use_locally_conservative_discretization)
-        &&
-        (!parameters.include_melt_transport)
-        &&
-        (introspection.block_indices.velocities != introspection.block_indices.pressure))
-      {
-        // Easy Case. We have an FE_Q in a separate block, so we can use
-        // mean_value() and vector.block(p) += correction:
-        const double mean = vector.block(introspection.block_indices.pressure).mean_value();
-        Assert(std::isfinite(mean), ExcInternalError());
-        const double int_rhs = mean * vector.block(introspection.block_indices.pressure).size();
-        const double correction = -int_rhs / global_volume;
-        Assert(global_volume > 0.0, ExcInternalError());
-
-        vector.block(introspection.block_indices.pressure).add(correction, pressure_shape_function_integrals.block(introspection.block_indices.pressure));
-      }
-    else if (!parameters.use_locally_conservative_discretization)
-      {
-        // FE_Q but we can not access the pressure block separately (either
-        // a direct solver or we have melt with p_f and p_c in the same block).
-        // Luckily we don't need to go over DoFs on each cell, because we
-        // have IndexSets to help us:
-
-        // we need to operate only on p_f not on p_c
-        const IndexSet &idxset = parameters.include_melt_transport ?
-                                 introspection.index_sets.locally_owned_fluid_pressure_dofs
-                                 :
-                                 introspection.index_sets.locally_owned_pressure_dofs;
-        double int_rhs = 0.0;
-
-        for (unsigned int i=0; i < idxset.n_elements(); ++i)
-          {
-            types::global_dof_index idx = idxset.nth_index_in_set(i);
-            int_rhs += vector(idx);
-          }
-
-        // We do not have to integrate over the normal velocity at the
-        // boundaries with a prescribed velocity because the constraints
-        // are already distributed to the right hand side in
-        // current_constraints.distribute.
-        const double global_int_rhs = Utilities::MPI::sum(int_rhs, mpi_communicator);
-        const double correction = - global_int_rhs / global_volume;
-
-        for (unsigned int i=0; i < idxset.n_elements(); ++i)
-          {
-            types::global_dof_index idx = idxset.nth_index_in_set(i);
-            vector(idx) += correction * pressure_shape_function_integrals(idx);
-          }
-
-        vector.compress(VectorOperation::add);
-      }
-    else
-      {
-        // Locally conservative with or without direct solver and with or
-        // without melt: grab a pickaxe and do everything by hand!
-        AssertThrow(parameters.use_locally_conservative_discretization,
-                    ExcInternalError());
-
-        double int_rhs = 0.0;
-        const unsigned int pressure_component = (parameters.include_melt_transport ?
-                                                 introspection.variable("fluid pressure").first_component_index
-                                                 : introspection.component_indices.pressure);
-        std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-        for (const auto &cell : dof_handler.active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              // identify the first pressure dof
-              cell->get_dof_indices (local_dof_indices);
-              const unsigned int first_pressure_dof
-                = finite_element.component_to_system_index (pressure_component, 0);
-
-              // make sure that this DoF is really owned by the current processor
-              // and that it is in fact a pressure dof
-              Assert (dof_handler.locally_owned_dofs().is_element(local_dof_indices[first_pressure_dof]),
-                      ExcInternalError());
-
-              // compute integral:
-              int_rhs += vector(local_dof_indices[first_pressure_dof]);
-            }
-
-        const double global_int_rhs = Utilities::MPI::sum(int_rhs, mpi_communicator);
-        const double correction = - global_int_rhs / global_volume;
-
-        // Now modify our RHS with the correction factor:
-        for (const auto &cell : dof_handler.active_cell_iterators())
-          if (cell->is_locally_owned())
-            {
-              // identify the first pressure dof
-              cell->get_dof_indices (local_dof_indices);
-              const unsigned int first_pressure_dof
-                = finite_element.component_to_system_index (pressure_component, 0);
-
-              // make sure that this DoF is really owned by the current processor
-              // and that it is in fact a pressure dof
-              Assert (dof_handler.locally_owned_dofs().is_element(local_dof_indices[first_pressure_dof]),
-                      ExcInternalError());
-
-              // correct:
-              types::global_dof_index idx = local_dof_indices[first_pressure_dof];
-              vector(idx) += correction * pressure_shape_function_integrals(idx);
-            }
-
-        vector.compress(VectorOperation::add);
-      }
-  }
-
-
-  template <int dim>
-  double
-  Simulator<dim>::compute_initial_stokes_residual()
-  {
-    LinearAlgebra::BlockVector linearized_stokes_variables (introspection.index_sets.stokes_partitioning, mpi_communicator);
-    LinearAlgebra::BlockVector residual (introspection.index_sets.stokes_partitioning, mpi_communicator);
-    const unsigned int block_p =
-      parameters.include_melt_transport ?
-      introspection.variable("fluid pressure").block_index
-      :
-      introspection.block_indices.pressure;
-
-    // if velocity and pressure are in the same block, we have to copy the
-    // pressure to the solution and RHS vector with a zero velocity
-    if (block_p == introspection.block_indices.velocities)
-      {
-        const IndexSet &idxset = (parameters.include_melt_transport) ?
-                                 introspection.index_sets.locally_owned_fluid_pressure_dofs
-                                 :
-                                 introspection.index_sets.locally_owned_pressure_dofs;
-
-        for (unsigned int i=0; i < idxset.n_elements(); ++i)
-          {
-            types::global_dof_index idx = idxset.nth_index_in_set(i);
-            linearized_stokes_variables(idx)        = current_linearization_point(idx);
-          }
-        linearized_stokes_variables.block(block_p).compress(VectorOperation::insert);
-      }
-    else
-      linearized_stokes_variables.block (block_p) = current_linearization_point.block (block_p);
-
-    // TODO: we don't have .stokes_relevant_partitioning so I am creating a much
-    // bigger vector here, oh well.
-    LinearAlgebra::BlockVector ghosted (introspection.index_sets.system_partitioning,
-                                        introspection.index_sets.system_relevant_partitioning,
-                                        mpi_communicator);
-    // TODO for Timo: can we create the ghost vector inside of denormalize_pressure
-    // (only in cases where we need it)
-    ghosted.block(block_p) = linearized_stokes_variables.block(block_p);
-    denormalize_pressure (this->last_pressure_normalization_adjustment, linearized_stokes_variables, ghosted);
-    current_constraints.set_zero (linearized_stokes_variables);
-
-    linearized_stokes_variables.block (block_p) /= pressure_scaling;
-
-    // we calculate the velocity residual with a zero velocity,
-    // computing only the part of the RHS not balanced by the static pressure
-    if (block_p == introspection.block_indices.velocities)
-      {
-        // we can use the whole block here because we set the velocity to zero above
-        return system_matrix.block(0,0).residual (residual.block(0),
-                                                  linearized_stokes_variables.block(0),
-                                                  system_rhs.block(0));
-      }
-    else
-      {
-        const double residual_u = system_matrix.block(0,1).residual (residual.block(0),
-                                                                     linearized_stokes_variables.block(1),
-                                                                     system_rhs.block(0));
-        const double residual_p = system_rhs.block(block_p).l2_norm();
-        return std::sqrt(residual_u*residual_u+residual_p*residual_p);
-      }
-  }
-
-
-
-  template <int dim>
-  bool
-  Simulator<dim>::stokes_matrix_depends_on_solution() const
-  {
-    // Currently, the only coefficient that really appears on the
-    // left hand side of the Stokes equation is the viscosity and possibly
-    // the density in the case of the implicit reference density profile
-    // approximation.
-    // If melt transport is included in the simulation, we have an
-    // additional equation with more coefficients on the left hand
-    // side.
-
-    return (material_model->get_model_dependence().viscosity != MaterialModel::NonlinearDependence::none)
-           || (parameters.formulation_mass_conservation ==
-               Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile)
-           || parameters.include_melt_transport;
-  }
-
-
-
-  template <int dim>
-  bool
-  Simulator<dim>::stokes_A_block_is_symmetric() const
-  {
-    // The A block should be symmetric, unless there are free surface stabilization terms, or
-    // the user has forced the use of a different solver.
-    if (mesh_deformation && mesh_deformation->get_boundary_indicators_requiring_stabilization().empty() == false)
-      return false;
-    else if (parameters.force_nonsymmetric_A_block_solver)
-      return false;
-    else
-      return true;
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::update_solution_vectors_with_reaction_results (const unsigned int block_index,
-                                                                      const LinearAlgebra::BlockVector &distributed_vector,
-                                                                      const LinearAlgebra::BlockVector &distributed_reaction_vector)
-  {
-    solution.block(block_index) = distributed_vector.block(block_index);
-
-    // we have to update the old solution with our reaction update too
-    // so that the advection scheme will have the correct time stepping in the next step
-    LinearAlgebra::BlockVector tmp;
-    tmp.reinit(distributed_vector, false);
-
-    // What we really want to do is
-    //     old_solution.block(block_index) += distributed_reaction_vector.block(block_index);
-    // but because 'old_solution' is a ghosted vector, we can't write into it directly. Rather,
-    // we have to go around with a completely distributed vector.
-    tmp.block(block_index) = old_solution.block(block_index);
-    tmp.block(block_index) +=  distributed_reaction_vector.block(block_index);
-    old_solution.block(block_index) = tmp.block(block_index);
-
-    // Same here with going through a distributed vector.
-    tmp.block(block_index) = old_old_solution.block(block_index);
-    tmp.block(block_index) +=  distributed_reaction_vector.block(block_index);
-    old_old_solution.block(block_index) = tmp.block(block_index);
-
-    operator_split_reaction_vector.block(block_index) = distributed_reaction_vector.block(block_index);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::compute_reactions ()
-  {
-    // if the time step has a length of zero, there are no reactions
-    if (time_step == 0)
-      return;
-
-    TimerOutput::Scope timer (computing_timer, "Solve composition reactions");
-
-    // we need some temporary vectors to store our updates to composition and temperature in
-    // while we do the time stepping, before we copy them over to the solution vector in the end
-    LinearAlgebra::BlockVector distributed_vector (introspection.index_sets.system_partitioning,
-                                                   mpi_communicator);
-
-    LinearAlgebra::BlockVector distributed_reaction_vector (introspection.index_sets.system_partitioning,
-                                                            mpi_communicator);
-
-    // we use a different (potentially smaller) time step than in the advection scheme.
-    // and for the fixed step scheme, we want all of our reaction time steps (within one advection step) to have the same size
-    const unsigned int number_of_reaction_steps = std::max(static_cast<unsigned int>(time_step / parameters.reaction_time_step),
-                                                           std::max(parameters.reaction_steps_per_advection_step,1U));
-
-    const double reaction_time_step_size = time_step / static_cast<double>(number_of_reaction_steps);
-
-    if (parameters.reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
-      Assert (reaction_time_step_size > 0,
-              ExcMessage("Reaction time step must be greater than 0."));
-
-    pcout << "   Solving composition reactions... " << std::flush;
-
-
-    // We want to compute reactions in each support point for all fields (compositional fields and temperature). The reaction
-    // rate for an individual field depends on the values of all other fields, so we have to step them forward in time together.
-    // The rates comes from the material and heating model, otherwise we have a simple ODE in each point on each cell to solve.
-    //
-    // So far so good. Except that fields can have different Finite Element discretizations (degree, continuous/discontinuous)
-    // and will have different support points. We solve this by computing the union of all support points and evaluating all fields
-    // in these points for every cell (if necessary by interpolation). Then we solve the ODEs on each cell together and
-    // write back all values that correspond to support points of that particular field. Field values we computed that are
-    // not actually support points, we just throw away.
-
-    // First compute the union of all support points (temperature and compositions):
-    std::vector<Point<dim>> unique_support_points;
-    // For each field (T or composition) store where each support point is found in the list of indices of support points
-    // unique_support_points. This means index=support_point_index_by_field[0][3] is the index of the third support point
-    // of the temperature field and unique_support_points[index] is its location.
-    const unsigned int n_fields = 1 + introspection.n_compositional_fields;
-    std::vector<std::vector<unsigned int>> support_point_index_by_field(n_fields);
-
-    // Fill in the support_point_index_by_field data structure. This is a bit complicated...
-    {
-      // first fill in temperature:
-      unique_support_points = dof_handler.get_fe().base_element(introspection.base_elements.temperature).get_unit_support_points();
-      for (unsigned int i=0; i<unique_support_points.size(); ++i)
-        support_point_index_by_field[0].push_back(i);
-
-      // Naive n^2 algorithm to merge all compositional fields into the data structure.
-      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-        {
-          const auto composition = Simulator<dim>::AdvectionField::composition(c);
-          const std::vector<Point<dim>> &points = dof_handler.get_fe().base_element(composition.base_element(introspection)).get_unit_support_points();
-
-          for (unsigned int i=0; i<points.size(); ++i)
-            {
-              const auto it = std::find(unique_support_points.begin(), unique_support_points.end(), points[i]);
-              if (it != unique_support_points.end())
-                {
-                  // We already have this support point, record its number:
-                  support_point_index_by_field[1+c].push_back(std::distance(unique_support_points.begin(), it));
-                }
-              else
-                {
-                  // This is a new point that needs to be added:
-                  unique_support_points.push_back(points[i]);
-                  support_point_index_by_field[1+c].push_back(unique_support_points.size()-1);
-                }
-            }
-        }
-    }
-
-    const Quadrature<dim> combined_support_points(unique_support_points);
-    FEValues<dim> fe_values (*mapping,
-                             dof_handler.get_fe(),
-                             combined_support_points,
-                             update_quadrature_points | update_values | update_gradients);
-
-    const unsigned int n_q_points = combined_support_points.size();
-    std::vector<types::global_dof_index> local_dof_indices (dof_handler.get_fe().dofs_per_cell);
-    MaterialModel::MaterialModelInputs<dim> in(n_q_points, introspection.n_compositional_fields);
-    MaterialModel::MaterialModelOutputs<dim> out(n_q_points, introspection.n_compositional_fields);
-    HeatingModel::HeatingModelOutputs heating_model_outputs(n_q_points, introspection.n_compositional_fields);
-
-    // add reaction rate outputs
-    material_model->create_additional_named_outputs(out);
-
-    MaterialModel::ReactionRateOutputs<dim> *reaction_rate_outputs
-      = out.template get_additional_output<MaterialModel::ReactionRateOutputs<dim>>();
-
-    AssertThrow(reaction_rate_outputs != nullptr,
-                ExcMessage("You are trying to use the operator splitting solver scheme, "
-                           "but the material model you use does not support operator splitting "
-                           "(it does not create ReactionRateOutputs, which are required for this "
-                           "solver scheme)."));
-
-    // some heating models require the additional outputs
-    heating_model_manager.create_additional_material_model_inputs_and_outputs(in, out);
-
-    // We use SUNDIALs ARKode to compute the reactions. Set up the required parameters.
-    // TODO: Should we change some of these based on the Reaction time step input parameter?
-    using VectorType = Vector<double>;
-    SUNDIALS::ARKode<VectorType>::AdditionalData data;
-    data.initial_time = time;
-    data.final_time = time + time_step;
-    data.initial_step_size = 0.001 * time_step;
-    data.output_period = time_step;
-    data.minimum_step_size = 1.e-6 * time_step;
-
-    // Both tolerances are added, but the composition might become 0.
-    // We therefore set the absolute tolerance to a very small value.
-    data.relative_tolerance = 1e-6;
-    data.absolute_tolerance = 1e-10;
-
-    SUNDIALS::ARKode<VectorType> ode(data);
-
-    std::vector<std::vector<double>> initial_values_C (n_q_points, std::vector<double> (introspection.n_compositional_fields));
-    std::vector<double> initial_values_T (n_q_points);
-
-    // We have to store all values of the temperature and composition fields in one long vector.
-    // Create the vector and functions for transferring values between this vector and the material model inputs object.
-    VectorType fields (n_q_points * n_fields);
-
-    auto copy_fields_into_one_vector = [n_q_points,n_fields](const MaterialModel::MaterialModelInputs<dim> &in,
-                                                             VectorType &fields)
-    {
-      for (unsigned int j=0; j<n_q_points; ++j)
-        for (unsigned int f=0; f<n_fields; ++f)
-          if (f==0)
-            fields[j*n_fields+f] = in.temperature[j];
-          else
-            fields[j*n_fields+f] = in.composition[j][f-1];
-      return;
-    };
-
-    auto copy_fields_into_material_model_inputs = [n_q_points,n_fields](const VectorType &fields,
-                                                                        MaterialModel::MaterialModelInputs<dim> &in)
-    {
-      for (unsigned int j=0; j<n_q_points; ++j)
-        for (unsigned int f=0; f<n_fields; ++f)
-          if (f==0)
-            in.temperature[j]      = fields[j*n_fields+f];
-          else
-            in.composition[j][f-1] = fields[j*n_fields+f];
-      return;
-    };
-
-    auto copy_rates_into_one_vector = [n_q_points,n_fields](const MaterialModel::ReactionRateOutputs<dim> *reaction_out,
-                                                            const HeatingModel::HeatingModelOutputs &heating_out,
-                                                            VectorType &rates)
-    {
-      for (unsigned int j=0; j<n_q_points; ++j)
-        for (unsigned int f=0; f<n_fields; ++f)
-          if (f==0)
-            rates[j*n_fields+f] = heating_out.rates_of_temperature_change[j];
-          else
-            rates[j*n_fields+f] = reaction_out->reaction_rates[j][f-1];
-      return;
-    };
-
-    unsigned int total_iteration_count = 0;
-    unsigned int number_of_solves = 0;
-
-    // Make a loop first over all cells, than over all reaction time steps, and then over
-    // all degrees of freedom in each element to compute the reactions. This is possible
-    // because the reactions only depend on the temperature and composition values at a given
-    // degree of freedom (and are independent of the solution in other points).
-
-    // Note that the values for some degrees of freedom are set more than once in the loop
-    // below where we assign the new values to distributed_vector (if they are located on the
-    // interface between cells), as we loop over all cells, and then over all degrees of freedom
-    // on each cell. Although this means we do some additional work, the results are still
-    // correct, as we never read from distributed_vector inside the loop over all cells.
-    // We initialize the material model inputs object in using the solution vector
-    // on every cell, compute the update, and then on every cell put the result into the
-    // distributed_vector vector. Only after the loop over all cells do we copy distributed_vector
-    // back onto the solution vector.
-    // So even though we touch some DoF more than once, we always start from the same value, compute the
-    // same value, and then overwrite the same value in distributed_vector.
-    // TODO: make this even more efficient.
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          in.reinit(fe_values, cell, introspection, solution);
-
-          std::vector<std::vector<double>> accumulated_reactions_C (n_q_points, std::vector<double> (introspection.n_compositional_fields));
-          std::vector<double> accumulated_reactions_T (n_q_points);
-
-          copy_fields_into_one_vector (in, fields);
-
-          initial_values_C = in.composition;
-          initial_values_T = in.temperature;
-
-          if (parameters.reaction_solver_type == Parameters<dim>::ReactionSolverType::ARKode)
-            {
-
-              ode.explicit_function = [&] (const double /*time*/,
-                                           const VectorType &y,
-                                           VectorType &ydot)
-              {
-                copy_fields_into_material_model_inputs (y, in);
-                material_model->fill_additional_material_model_inputs(in, solution, fe_values, introspection);
-                material_model->evaluate(in, out);
-                heating_model_manager.evaluate(in, out, heating_model_outputs);
-                copy_rates_into_one_vector (reaction_rate_outputs, heating_model_outputs, ydot);
-              };
-
-              // Make the reaction time steps: We have to update the values of compositional fields and the temperature.
-              // We can reuse the same material model inputs and outputs structure for each reaction time step.
-              // We store the computed updates to temperature and composition in a separate (accumulated_reactions) vector,
-              // so that we can later copy it over to the solution vector.
-              const unsigned int iteration_count = ode.solve_ode(fields);
-
-              total_iteration_count += iteration_count;
-              number_of_solves += 1;
-
-              for (unsigned int j=0; j<n_q_points; ++j)
-                for (unsigned int f=0; f<n_fields; ++f)
-                  {
-                    if (f==0)
-                      {
-                        in.temperature[j]          = fields[j*n_fields+f];
-                        accumulated_reactions_T[j] = in.temperature[j] - initial_values_T[j];
-                      }
-                    else
-                      {
-                        in.composition[j][f-1]          = fields[j*n_fields+f];
-                        accumulated_reactions_C[j][f-1] = in.composition[j][f-1] - initial_values_C[j][f-1];
-                      }
-                  }
-            }
-
-          else if (parameters.reaction_solver_type == Parameters<dim>::ReactionSolverType::fixed_step)
-            {
-              for (unsigned int i=0; i<number_of_reaction_steps; ++i)
-                {
-                  // Loop over composition element
-                  material_model->fill_additional_material_model_inputs(in, solution, fe_values, introspection);
-
-                  material_model->evaluate(in, out);
-                  heating_model_manager.evaluate(in, out, heating_model_outputs);
-
-                  for (unsigned int j=0; j<n_q_points; ++j)
-                    {
-                      for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-                        {
-                          // simple forward euler
-                          in.composition[j][c] = in.composition[j][c]
-                                                 + reaction_time_step_size * reaction_rate_outputs->reaction_rates[j][c];
-                          accumulated_reactions_C[j][c] += reaction_time_step_size * reaction_rate_outputs->reaction_rates[j][c];
-                        }
-                      in.temperature[j] = in.temperature[j]
-                                          + reaction_time_step_size * heating_model_outputs.rates_of_temperature_change[j];
-                      accumulated_reactions_T[j] += reaction_time_step_size * heating_model_outputs.rates_of_temperature_change[j];
-                    }
-                }
-            }
-
-          cell->get_dof_indices (local_dof_indices);
-          const unsigned int component_idx_T = introspection.component_indices.temperature;
-
-          for (unsigned int dof_idx = 0; dof_idx < local_dof_indices.size(); ++dof_idx)
-            {
-              const auto comp_pair = dof_handler.get_fe().system_to_component_index(dof_idx);
-              const unsigned int component_idx = comp_pair.first;
-              if (component_idx>=component_idx_T) // ignore velocity, pressure, etc.
-                {
-                  // We found a DoF that belongs to component component_idx, which is a temperature or compositional
-                  // field. That means we want to find where this DoF in the computed reactions above to copy it
-                  // back into the global solution vector.
-
-                  // These two variables tell us the how-manyth shape function of which field (and therefore
-                  // field) this DoF is:
-                  const unsigned int index_within = comp_pair.second;
-                  const unsigned int field_index = component_idx-component_idx_T;
-                  // Now we can look up in the support_point_index_by_field data structure where this support
-                  // point is in the list of unique_support_points (and in the Quadrature):
-                  const unsigned int point_idx = support_point_index_by_field[field_index][index_within];
-
-                  // The final step is grabbing the value from the reaction computation and write it into
-                  // the global vector (if we own it, of course):
-                  if (dof_handler.locally_owned_dofs().is_element(local_dof_indices[dof_idx]))
-                    {
-                      // temperatures and compositions are stored differently:
-                      if (component_idx == component_idx_T)
-                        {
-                          distributed_vector(local_dof_indices[dof_idx]) = in.temperature[point_idx];
-                          distributed_reaction_vector(local_dof_indices[dof_idx]) = accumulated_reactions_T[point_idx];
-                        }
-                      else
-                        {
-                          const unsigned int composition = field_index-1; // 0 is temperature...
-                          distributed_vector(local_dof_indices[dof_idx]) = in.composition[point_idx][composition];
-                          distributed_reaction_vector(local_dof_indices[dof_idx]) = accumulated_reactions_C[point_idx][composition];
-                        }
-                    }
-                }
-            }
-        }
-
-    distributed_vector.compress(VectorOperation::insert);
-    distributed_reaction_vector.compress(VectorOperation::insert);
-
-    // put the final values into the solution vector
-    for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-      update_solution_vectors_with_reaction_results(introspection.block_indices.compositional_fields[c],
-                                                    distributed_vector,
-                                                    distributed_reaction_vector);
-
-    update_solution_vectors_with_reaction_results(introspection.block_indices.temperature,
-                                                  distributed_vector,
-                                                  distributed_reaction_vector);
-
-    initialize_current_linearization_point();
-
-    double average_iteration_count = number_of_reaction_steps;
-    if (parameters.reaction_solver_type == Parameters<dim>::ReactionSolverType::ARKode)
-      {
-        if (number_of_solves > 0)
-          average_iteration_count = total_iteration_count / number_of_solves;
-        else
-          average_iteration_count = total_iteration_count;
-      }
-
-    pcout << "in "
-          << average_iteration_count
-          << " substep(s)."
-          << std::endl;
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::initialize_current_linearization_point ()
-  {
-    // Start with a simple copy of the last timestep
-    current_linearization_point = old_solution;
-
-    // If possible use an extrapolated solution from last and
-    // previous to last timestep.
-    if (timestep_number > 1)
-      {
-        // TODO: Trilinos sadd does not like ghost vectors even as input. Copy
-        // into distributed vectors for now:
-        LinearAlgebra::BlockVector distr_solution (system_rhs);
-        distr_solution = old_solution;
-        LinearAlgebra::BlockVector distr_old_solution (system_rhs);
-        distr_old_solution = old_old_solution;
-        distr_solution.sadd ((1 + time_step/old_time_step),
-                             -time_step/old_time_step,
-                             distr_old_solution);
-        current_linearization_point = distr_solution;
-      }
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::interpolate_material_output_into_advection_field (const AdvectionField &adv_field)
-  {
-    // we need some temporary vectors to store our updates to composition in
-    // before we copy them over to the solution vector in the end
-    LinearAlgebra::BlockVector distributed_vector (introspection.index_sets.system_partitioning,
-                                                   mpi_communicator);
-
-    if (adv_field.is_temperature())
-      pcout << "   Copying properties into prescribed temperature field... "
-            << std::flush;
-    else
-      {
-        const std::string name_of_field = introspection.name_for_compositional_index(adv_field.compositional_variable);
-
-        pcout << "   Copying properties into prescribed compositional field " + name_of_field + "... "
-              << std::flush;
-      }
-
-    // Create an FEValues object that allows us to interpolate onto the solution
-    // vector. To make this happen, we need to have a quadrature formula that
-    // consists of the support points of the advection field finite element
-    const Quadrature<dim> quadrature(dof_handler.get_fe().base_element(adv_field.base_element(introspection))
-                                     .get_unit_support_points());
-
-    FEValues<dim> fe_values (*mapping,
-                             dof_handler.get_fe(),
-                             quadrature,
-                             update_quadrature_points | update_values | update_gradients);
-
-    std::vector<types::global_dof_index> local_dof_indices (dof_handler.get_fe().dofs_per_cell);
-    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), introspection.n_compositional_fields);
-    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), introspection.n_compositional_fields);
-
-    // add the prescribed field outputs that will be used for interpolating
-    material_model->create_additional_named_outputs(out);
-
-    MaterialModel::PrescribedFieldOutputs<dim> *prescribed_field_out
-      = out.template get_additional_output<MaterialModel::PrescribedFieldOutputs<dim>>();
-    MaterialModel::PrescribedTemperatureOutputs<dim> *prescribed_temperature_out
-      = out.template get_additional_output<MaterialModel::PrescribedTemperatureOutputs<dim>>();
-
-    // check if the material model computes the correct prescribed field outputs
-    if (adv_field.is_temperature())
-      {
-        AssertThrow(prescribed_temperature_out != nullptr,
-                    ExcMessage("You are trying to use a prescribed temperature field, "
-                               "but the material model you use does not support interpolating properties "
-                               "(it does not create PrescribedTemperatureOutputs, which is required for this "
-                               "temperature field type)."));
-      }
-    else
-      {
-        AssertThrow(prescribed_field_out != nullptr,
-                    ExcMessage("You are trying to use a prescribed advection field, "
-                               "but the material model you use does not support interpolating properties "
-                               "(it does not create PrescribedFieldOutputs, which is required for this "
-                               "advection field type)."));
-      }
-
-    // Make a loop first over all cells, and then over all degrees of freedom in each element
-    // to interpolate material properties onto a solution vector.
-
-    // Note that the values for some degrees of freedom are set more than once in the loop
-    // below where we assign the new values to distributed_vector (if they are located on the
-    // interface between cells), as we loop over all cells, and then over all degrees of freedom
-    // on each cell. But even though we touch some DoF more than once, we always compute the same value,
-    // and then overwrite the same value in distributed_vector.
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          cell->get_dof_indices (local_dof_indices);
-          in.reinit(fe_values, cell, introspection, solution);
-
-          material_model->evaluate(in, out);
-
-          // Interpolate material properties onto the advection fields
-          const unsigned int advection_dofs_per_cell =
-            dof_handler.get_fe().base_element(adv_field.base_element(introspection)).dofs_per_cell;
-
-          for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-            {
-              const unsigned int dof_idx
-                = dof_handler.get_fe().component_to_system_index(adv_field.component_index(introspection),
-                                                                 /*dof index within component=*/ j);
-
-              // Skip degrees of freedom that are not locally owned. These
-              // will eventually be handled by one of the other processors.
-              if (dof_handler.locally_owned_dofs().is_element(local_dof_indices[dof_idx]))
-                {
-                  if (adv_field.is_temperature())
-                    {
-                      Assert(numbers::is_finite(prescribed_temperature_out->prescribed_temperature_outputs[j]),
-                             ExcMessage("You are trying to use a prescribed advection field, "
-                                        "but the material model you use does not fill the PrescribedFieldOutputs "
-                                        "for your prescribed field, which is required for this method."));
-
-                      distributed_vector(local_dof_indices[dof_idx])
-                        = prescribed_temperature_out->prescribed_temperature_outputs[j];
-                    }
-                  else
-                    {
-                      Assert(numbers::is_finite(prescribed_field_out->prescribed_field_outputs[j][adv_field.compositional_variable]),
-                             ExcMessage("You are trying to use a prescribed advection field, "
-                                        "but the material model you use does not fill the PrescribedFieldOutputs "
-                                        "for your prescribed field, which is required for this method."));
-
-                      distributed_vector(local_dof_indices[dof_idx])
-                        = prescribed_field_out->prescribed_field_outputs[j][adv_field.compositional_variable];
-                    }
-                }
-            }
-        }
-
-    // Put the final values into the solution vector, also
-    // updating the ghost elements of the 'solution' vector.
-    const unsigned int advection_block = adv_field.block_index(introspection);
-    distributed_vector.block(advection_block).compress(VectorOperation::insert);
-
-    if (adv_field.is_temperature() ||
-        adv_field.compositional_variable != introspection.find_composition_type(CompositionalFieldDescription::density))
-      current_constraints.distribute (distributed_vector);
-
-    solution.block(advection_block) = distributed_vector.block(advection_block);
-
-    pcout << "done." << std::endl;
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::check_consistency_of_formulation()
-  {
-    // Replace Formulation::MassConservation::ask_material_model by the respective terms to avoid
-    // complicated checks later on
-    if (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::ask_material_model)
-      {
-        if (material_model->is_compressible() == true)
-          parameters.formulation_mass_conservation = Parameters<dim>::Formulation::MassConservation::isentropic_compression;
-        else
-          parameters.formulation_mass_conservation = Parameters<dim>::Formulation::MassConservation::incompressible;
-      }
-
-    // Ensure the material model supports the selected formulation of the mass conservation equation
-    if (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::incompressible)
-      {
-        AssertThrow(material_model->is_compressible() == false,
-                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
-                               "The mass conservation equation was selected to be incompressible, "
-                               "but the provided material model reports that it is compressible. "
-                               "Please check the consistency of your material model and selected formulation."));
-      }
-    else if (parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::isentropic_compression
-             || parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::reference_density_profile
-             || parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile
-             || parameters.formulation_mass_conservation == Parameters<dim>::Formulation::MassConservation::projected_density_field)
-      {
-        AssertThrow(material_model->is_compressible() == true,
-                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
-                               "The mass conservation equation was selected to be compressible, "
-                               "but the provided material model reports that it is incompressible. "
-                               "Please check the consistency of your material model and selected formulation."));
-      }
-
-    // Ensure that the correct heating terms have been selected for the chosen combined formulation
-    // Note that if the combined formulation is 'custom' there is no check
-    // (useful e.g. for smaller scale lithospheric models with shear heating but without adiabatic heating)
-    if (parameters.formulation == Parameters<dim>::Formulation::isentropic_compression)
-      {
-        AssertThrow(heating_model_manager.adiabatic_heating_enabled(),
-                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
-                               "The `isentropic compression' formulation expects adiabatic heating to be enabled, "
-                               "but the `adiabatic heating' plugin has not been selected in the input file. "
-                               "Please check the consistency of your input file."));
-
-        AssertThrow(heating_model_manager.shear_heating_enabled(),
-                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
-                               "The `isentropic compression' formulation expects shear heating to be enabled, "
-                               "but the `shear heating' plugin has not been selected in the input file. "
-                               "Please check the consistency of your input file."));
-      }
-    else if (parameters.formulation == Parameters<dim>::Formulation::boussinesq_approximation)
-      {
-        AssertThrow(!heating_model_manager.adiabatic_heating_enabled(),
-                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
-                               "The 'Boussinesq approximation' formulation expects adiabatic heating to be disabled, "
-                               "but the `adiabatic heating' plugin has been selected in the input file. "
-                               "Please check the consistency of your input file."));
-
-        AssertThrow(!heating_model_manager.shear_heating_enabled(),
-                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
-                               "The 'Boussinesq approximation' formulation expects shear heating to be disabled, "
-                               "but the `shear heating' plugin has been selected in the input file. "
-                               "Please check the consistency of your input file."));
-      }
-    else if (parameters.formulation == Parameters<dim>::Formulation::anelastic_liquid_approximation)
-      {
-        AssertThrow(heating_model_manager.adiabatic_heating_enabled(),
-                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
-                               "The `anelastic liquid approximation' formulation expects adiabatic heating to be enabled, "
-                               "but the `adiabatic heating' plugin has not been selected in the input file. "
-                               "Please check the consistency of your input file."));
-
-        AssertThrow(heating_model_manager.shear_heating_enabled(),
-                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
-                               "The `anelastic liquid approximation' formulation expects shear heating to be enabled, "
-                               "but the `shear heating' plugin has not been selected in the input file. "
-                               "Please check the consistency of your input file."));
-
-        const bool use_simplified_adiabatic_heating =
-          heating_model_manager.template get_matching_heating_model<HeatingModel::AdiabaticHeating<dim>>()
-          .use_simplified_adiabatic_heating();
-
-        AssertThrow(use_simplified_adiabatic_heating == true,
-                    ExcMessage("ASPECT detected an inconsistency in the provided input file. "
-                               "The `anelastic liquid approximation' formulation expects adiabatic heating to use "
-                               "a simplified heating term that neglects dynamic pressure influences, "
-                               "but the adiabatic heating plugin does not report to simplify this term. "
-                               "Please check the consistency of your input file."));
-      }
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::replace_outflow_boundary_ids(const unsigned int offset)
-  {
-    const Quadrature<dim-1> &quadrature_formula = introspection.face_quadratures.temperature;
-
-    FEFaceValues<dim> fe_face_values (*mapping,
-                                      finite_element,
-                                      quadrature_formula,
-                                      update_values   | update_normal_vectors |
-                                      update_quadrature_points | update_JxW_values);
-
-    std::vector<Tensor<1,dim>> face_current_velocity_values (fe_face_values.n_quadrature_points);
-
-    const auto &tangential_velocity_boundaries =
-      boundary_velocity_manager.get_tangential_boundary_velocity_indicators();
-
-    const auto &zero_velocity_boundaries =
-      boundary_velocity_manager.get_zero_boundary_velocity_indicators();
-
-    const auto &prescribed_velocity_boundaries =
-      boundary_velocity_manager.get_active_boundary_velocity_conditions();
-
-    // Loop over all of the boundary faces, ...
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (!cell->is_artificial())
-        for (const unsigned int face_number : cell->face_indices())
-          {
-            const typename DoFHandler<dim>::face_iterator face = cell->face(face_number);
-
-            // If the face is at a boundary where we may want to replace its id
-            if (face->at_boundary() &&
-                tangential_velocity_boundaries.find(face->boundary_id()) == tangential_velocity_boundaries.end() &&
-                zero_velocity_boundaries.find(face->boundary_id()) == zero_velocity_boundaries.end())
-              {
-                Assert(face->boundary_id() <= offset,
-                       ExcMessage("If you do not 'Allow fixed temperature/composition on outflow boundaries', "
-                                  "you are only allowed to use boundary ids between 0 and 128."));
-
-                fe_face_values.reinit (cell, face_number);
-                fe_face_values[introspection.extractors.velocities].get_function_values(current_linearization_point,
-                                                                                        face_current_velocity_values);
-
-                // ... check if the face is an outflow boundary by integrating the normal velocities
-                // (flux through the boundary) as: int u*n ds = Sum_q u(x_q)*n(x_q) JxW(x_q)...
-                double integrated_flow = 0;
-
-                for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                  {
-                    Tensor<1,dim> boundary_velocity;
-                    if (prescribed_velocity_boundaries.find(face->boundary_id()) == prescribed_velocity_boundaries.end())
-                      boundary_velocity = face_current_velocity_values[q];
-                    else
-                      boundary_velocity = boundary_velocity_manager.boundary_velocity(face->boundary_id(),
-                                                                                      fe_face_values.quadrature_point(q));
-
-                    integrated_flow += (boundary_velocity * fe_face_values.normal_vector(q)) *
-                                       fe_face_values.JxW(q);
-                  }
-
-                // ... and change the boundary id of any outflow boundary faces.
-                if (integrated_flow > 0)
-                  face->set_boundary_id(face->boundary_id() + offset);
-              }
-          }
-  }
-
-
-  template <int dim>
-  void
-  Simulator<dim>::restore_outflow_boundary_ids(const unsigned int offset)
-  {
-    // Loop over all of the boundary faces...
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (!cell->is_artificial())
-        for (const unsigned int face_number : cell->face_indices())
-          {
-            const typename DoFHandler<dim>::face_iterator face = cell->face(face_number);
-            if (face->at_boundary())
-              {
-                // ... and reset all of the boundary ids we changed in replace_outflow_boundary_ids above.
-                if (face->boundary_id() >= offset)
-                  face->set_boundary_id(face->boundary_id() - offset);
-              }
-          }
-  }
-
-
-  namespace
-  {
-    /**
-     * Return whether t is an element of the given container object.
-     */
-    template <typename Container>
-    bool is_element (const typename Container::value_type &t,
-                     const Container                      &container)
-    {
-      for (const auto &p : container)
-        if (p == t)
-          return true;
-
-      return false;
-    }
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::check_consistency_of_boundary_conditions() const
-  {
-    // make sure velocity and traction boundary indicators don't appear in multiple lists
-    std::set<types::boundary_id> boundary_indicator_lists[6]
-      = { boundary_velocity_manager.get_zero_boundary_velocity_indicators(),
-          boundary_velocity_manager.get_tangential_boundary_velocity_indicators(),
-          std::set<types::boundary_id>()   // to be prescribed velocity and traction boundary indicators
-        };
-
-    // sets of the boundary indicators only (no selectors and values)
-    std::set<types::boundary_id> velocity_bi;
-    std::set<types::boundary_id> traction_bi;
-
-    for (const auto &p : boundary_velocity_manager.get_active_boundary_velocity_names())
-      velocity_bi.insert(p.first);
-
-    for (const auto &r : parameters.prescribed_traction_boundary_indicators)
-      traction_bi.insert(r.first);
-
-    // are there any indicators that occur in both the prescribed velocity and traction list?
-    std::set<types::boundary_id> intersection;
-    std::set_intersection (velocity_bi.begin(),
-                           velocity_bi.end(),
-                           traction_bi.begin(),
-                           traction_bi.end(),
-                           std::inserter(intersection, intersection.end()));
-
-    // if so, do they have different selectors?
-    if (!intersection.empty())
-      {
-        for (const auto it : intersection)
-          {
-            const std::map<types::boundary_id, std::pair<std::string,std::vector<std::string>>>::const_iterator
-            boundary_velocity_names = boundary_velocity_manager.get_active_boundary_velocity_names().find(it);
-            Assert(boundary_velocity_names != boundary_velocity_manager.get_active_boundary_velocity_names().end(),
-                   ExcInternalError());
-
-            std::set<char> velocity_selector;
-            std::set<char> traction_selector;
-
-            for (const auto it_selector : boundary_velocity_names->second.first)
-              velocity_selector.insert(it_selector);
-
-            for (std::string::const_iterator
-                 it_selector  = parameters.prescribed_traction_boundary_indicators.find(it)->second.first.begin();
-                 it_selector != parameters.prescribed_traction_boundary_indicators.find(it)->second.first.end();
-                 ++it_selector)
-              traction_selector.insert(*it_selector);
-
-            // if there are no selectors specified, throw exception
-            AssertThrow(!velocity_selector.empty() || !traction_selector.empty(),
-                        ExcMessage ("Boundary indicator <"
-                                    +
-                                    Utilities::int_to_string(it)
-                                    +
-                                    "> with symbolic name <"
-                                    +
-                                    geometry_model->translate_id_to_symbol_name (it)
-                                    +
-                                    "> is listed as having both "
-                                    "velocity and traction boundary conditions in the input file."));
-
-            std::set<char> intersection_selector;
-            std::set_intersection (velocity_selector.begin(),
-                                   velocity_selector.end(),
-                                   traction_selector.begin(),
-                                   traction_selector.end(),
-                                   std::inserter(intersection_selector, intersection_selector.end()));
-
-            // if the same selectors are specified, throw exception
-            AssertThrow(intersection_selector.empty(),
-                        ExcMessage ("Selectors of boundary indicator <"
-                                    +
-                                    Utilities::int_to_string(it)
-                                    +
-                                    "> with symbolic name <"
-                                    +
-                                    geometry_model->translate_id_to_symbol_name (it)
-                                    +
-                                    "> are listed as having both "
-                                    "velocity and traction boundary conditions in the input file."));
-          }
-      }
-
-    // remove correct boundary indicators that occur in both the velocity and the traction set
-    // but have different selectors
-    std::set<types::boundary_id> union_set;
-    std::set_union (velocity_bi.begin(),
-                    velocity_bi.end(),
-                    traction_bi.begin(),
-                    traction_bi.end(),
-                    std::inserter(union_set, union_set.end()));
-
-    // assign the prescribed boundary indicator list to the boundary_indicator_lists
-    boundary_indicator_lists[3] = union_set;
-
-    // for each combination of boundary indicator lists, make sure that the
-    // intersection is empty
-    for (unsigned int i=0; i<sizeof(boundary_indicator_lists)/sizeof(boundary_indicator_lists[0]); ++i)
-      for (unsigned int j=i+1; j<sizeof(boundary_indicator_lists)/sizeof(boundary_indicator_lists[0]); ++j)
-        {
-          std::set<types::boundary_id> intersection;
-          std::set_intersection (boundary_indicator_lists[i].begin(),
-                                 boundary_indicator_lists[i].end(),
-                                 boundary_indicator_lists[j].begin(),
-                                 boundary_indicator_lists[j].end(),
-                                 std::inserter(intersection, intersection.end()));
-
-          // if the same indicators are specified for different boundary conditions, throw exception
-          AssertThrow (intersection.empty(),
-                       ExcMessage ("Boundary indicator <"
-                                   +
-                                   Utilities::int_to_string(*intersection.begin())
-                                   +
-                                   "> with symbolic name <"
-                                   +
-                                   geometry_model->translate_id_to_symbol_name (*intersection.begin())
-                                   +
-                                   "> is listed as having more "
-                                   "than one type of velocity or traction boundary condition in the input file."));
-        }
-
-    // make sure temperature and heat flux boundary indicators don't appear in multiple lists
-    // this is easier than for the velocity/traction, as there are no selectors
-    std::set<types::boundary_id> temperature_bi = boundary_temperature_manager.get_fixed_temperature_boundary_indicators();
-    std::set<types::boundary_id> heat_flux_bi = parameters.fixed_heat_flux_boundary_indicators;
-
-    // are there any indicators that occur in both the prescribed temperature and heat flux list?
-    std::set<types::boundary_id> T_intersection;
-    std::set_intersection (temperature_bi.begin(),
-                           temperature_bi.end(),
-                           heat_flux_bi.begin(),
-                           heat_flux_bi.end(),
-                           std::inserter(T_intersection, T_intersection.end()));
-
-    AssertThrow(T_intersection.empty(),
-                ExcMessage ("There is a boundary indicator listed as having both "
-                            "temperature and heat flux boundary conditions in the input file."));
-
-    // Check that the periodic boundaries do not have other boundary conditions set
-    using periodic_boundary_set
-      = std::set<std::pair<std::pair<types::boundary_id, types::boundary_id>, unsigned int>>;
-
-    periodic_boundary_set pbs = geometry_model->get_periodic_boundary_pairs();
-
-    for (const auto &pb : pbs)
-      {
-        // Throw error if we are trying to use the same boundary for more than one boundary condition
-        AssertThrow( is_element( pb.first.first, boundary_temperature_manager.get_fixed_temperature_boundary_indicators() ) == false &&
-                     is_element( pb.first.second, boundary_temperature_manager.get_fixed_temperature_boundary_indicators() ) == false &&
-                     is_element( pb.first.first, boundary_composition_manager.get_fixed_composition_boundary_indicators() ) == false &&
-                     is_element( pb.first.second, boundary_composition_manager.get_fixed_composition_boundary_indicators() ) == false &&
-                     is_element( pb.first.first, boundary_indicator_lists[0] ) == false && // zero velocity
-                     is_element( pb.first.second, boundary_indicator_lists[0] ) == false && // zero velocity
-                     is_element( pb.first.first, boundary_indicator_lists[1] ) == false && // tangential velocity
-                     is_element( pb.first.second, boundary_indicator_lists[1] ) == false && // tangential velocity
-                     is_element( pb.first.first, boundary_indicator_lists[3] ) == false && // prescribed traction or velocity
-                     is_element( pb.first.second, boundary_indicator_lists[3] ) == false,  // prescribed traction or velocity
-                     ExcMessage("Periodic boundaries must not have boundary conditions set."));
-      }
-
-    const std::set<types::boundary_id> all_boundary_indicators
-      = geometry_model->get_used_boundary_indicators();
-    if (parameters.nonlinear_solver != NonlinearSolver::single_Advection_no_Stokes)
-      {
-        // next make sure that all listed indicators are actually used by
-        // this geometry
-        for (const auto &list : boundary_indicator_lists)
-          for (const auto &p : list)
-            AssertThrow (all_boundary_indicators.find (p)
-                         != all_boundary_indicators.end(),
-                         ExcMessage ("One of the boundary indicators listed in the input file "
-                                     "is not used by the geometry model."));
-      }
-    else
-      {
-        // next make sure that there are no listed indicators
-        for (const auto &list : boundary_indicator_lists)
-          AssertThrow (list.empty(),
-                       ExcMessage ("With the solver scheme `single Advection, no Stokes', "
-                                   "one cannot set boundary conditions for velocity."));
-      }
-
-
-    // now do the same for the fixed temperature indicators and the
-    // compositional indicators
-    for (const auto p : boundary_temperature_manager.get_fixed_temperature_boundary_indicators())
-      AssertThrow (all_boundary_indicators.find (p)
-                   != all_boundary_indicators.end(),
-                   ExcMessage ("One of the fixed boundary temperature indicators listed in the input file "
-                               "is not used by the geometry model."));
-    for (const auto p : boundary_composition_manager.get_fixed_composition_boundary_indicators())
-      AssertThrow (all_boundary_indicators.find (p)
-                   != all_boundary_indicators.end(),
-                   ExcMessage ("One of the fixed boundary composition indicators listed in the input file "
-                               "is not used by the geometry model."));
-  }
-
-
-
-  template <int dim>
-  double
-  Simulator<dim>::compute_initial_newton_residual(const LinearAlgebra::BlockVector &linearized_stokes_initial_guess)
-  {
-    // Store the values of the current_linearization_point and linearized_stokes_initial_guess so we can reset them again.
-    LinearAlgebra::BlockVector temp_linearization_point = current_linearization_point;
-    LinearAlgebra::BlockVector temp_linearized_stokes_initial_guess = linearized_stokes_initial_guess;
-    const unsigned int block_vel = introspection.block_indices.velocities;
-
-    // Set the velocity initial guess to zero, but we use the initial guess for the pressure.
-    current_linearization_point.block(introspection.block_indices.velocities) = 0;
-    temp_linearized_stokes_initial_guess.block (block_vel) = 0;
-
-    denormalize_pressure (last_pressure_normalization_adjustment,
-                          temp_linearized_stokes_initial_guess,
-                          current_linearization_point);
-
-    // rebuild the whole system to compute the rhs.
-    assemble_newton_stokes_system = true;
-    rebuild_stokes_preconditioner = false;
-    rebuild_stokes_matrix = boundary_velocity_manager.get_active_boundary_velocity_conditions().size()!=0;
-    assemble_newton_stokes_matrix = boundary_velocity_manager.get_active_boundary_velocity_conditions().size()!=0;
-
-    compute_current_constraints ();
-
-    assemble_stokes_system();
-
-    last_pressure_normalization_adjustment = normalize_pressure(current_linearization_point);
-
-    const double initial_newton_residual_vel = system_rhs.block(introspection.block_indices.velocities).l2_norm();
-    const double initial_newton_residual_p = system_rhs.block(introspection.block_indices.pressure).l2_norm();
-    const double initial_newton_residual = std::sqrt(initial_newton_residual_vel * initial_newton_residual_vel + initial_newton_residual_p * initial_newton_residual_p);
-
-    current_linearization_point = temp_linearization_point;
-
-    pcout << "   Initial Newton Stokes residual = " << initial_newton_residual << ", v = " << initial_newton_residual_vel << ", p = " << initial_newton_residual_p << std::endl << std::endl;
-    return initial_newton_residual;
-  }
-
-
-
-  template <int dim>
-  double
-  Simulator<dim>::compute_Eisenstat_Walker_linear_tolerance(const bool EisenstatWalkerChoiceOne,
-                                                            const double maximum_linear_stokes_solver_tolerance,
-                                                            const double linear_stokes_solver_tolerance,
-                                                            const double stokes_residual,
-                                                            const double newton_residual,
-                                                            const double newton_residual_old)
-  {
-    /**
-       * The Eisenstat and Walker (1996) method is used for determining the linear tolerance of
-       * the iteration after the first iteration. The paper gives two preferred choices of computing
-       * this tolerance. Both choices are implemented here with the suggested parameter values and
-       * safeguards.
-     */
-    double new_linear_stokes_solver_tolerance = linear_stokes_solver_tolerance;
-    if (EisenstatWalkerChoiceOne)
-      {
-        // This is the preferred value for this parameter in the paper.
-        // A value of 2 for the power-term might also work fine.
-        const double powerterm = (1+std::sqrt(5))*0.5;
-        if (std::pow(linear_stokes_solver_tolerance,powerterm) <= 0.1)
-          {
-            new_linear_stokes_solver_tolerance = std::min(maximum_linear_stokes_solver_tolerance,
-                                                          std::fabs(newton_residual-stokes_residual)/(newton_residual_old));
-          }
-        else
-          {
-            new_linear_stokes_solver_tolerance = std::min(maximum_linear_stokes_solver_tolerance,
-                                                          std::max(std::fabs(newton_residual-stokes_residual)/newton_residual_old,
-                                                                   std::pow(linear_stokes_solver_tolerance,powerterm)));
-          }
-      }
-    else
-      {
-        if (0.9*linear_stokes_solver_tolerance * linear_stokes_solver_tolerance <= 0.1)
-          {
-            new_linear_stokes_solver_tolerance =  std::min(maximum_linear_stokes_solver_tolerance,
-                                                           0.9 * std::fabs(newton_residual * newton_residual) /
-                                                           (newton_residual_old * newton_residual_old));
-          }
-        else
-          {
-            new_linear_stokes_solver_tolerance = std::min(newton_handler->parameters.maximum_linear_stokes_solver_tolerance,
-                                                          std::max(0.9 * std::fabs(newton_residual*newton_residual)
-                                                                   /
-                                                                   (newton_residual_old*newton_residual_old),
-                                                                   0.9*linear_stokes_solver_tolerance*linear_stokes_solver_tolerance));
-          }
-      }
-    return new_linear_stokes_solver_tolerance;
-  }
-
-
-
-  template <int dim>
-  void
-  Simulator<dim>::select_default_solver_and_averaging()
-  {
-    if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::default_solver)
-      {
-        // Catch all situations that are not supported by the GMG solver:
-        //   - Melt transport
-        //   - Ellipsoidal geometry
-        //   - Locally conservative discretization
-        //   - Implicit reference density profile
-        //   - Periodic boundaries
-        //   - Stokes velocity degree not 2 or 3
-        //   - Material averaging explicitly disabled
-        if (parameters.include_melt_transport == true ||
-            dynamic_cast<const GeometryModel::EllipsoidalChunk<dim>*>(geometry_model.get()) != nullptr ||
-            parameters.use_locally_conservative_discretization == true ||
-            (material_model->is_compressible() == true && parameters.formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile) ||
-            (geometry_model->get_periodic_boundary_pairs().size()) > 0 ||
-            (parameters.stokes_velocity_degree < 2 || parameters.stokes_velocity_degree > 3) ||
-            parameters.material_averaging == MaterialModel::MaterialAveraging::none)
-          {
-            // GMG is not supported (yet), by default fall back to AMG.
-            parameters.stokes_solver_type = Parameters<dim>::StokesSolverType::block_amg;
-          }
-        else
-          {
-            // GMG is supported for all other cases
-            parameters.stokes_solver_type = Parameters<dim>::StokesSolverType::block_gmg;
-          }
-      }
-
-    // Now pick an appropriate material averaging for the chosen solver
-    if (parameters.material_averaging == MaterialModel::MaterialAveraging::default_averaging)
-      {
-        if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
-          {
-            // project to Q1 is more accurate, but not supported if:
-            //   - elasticity is enabled
-            //   - the Newton solver is enabled
-            if (parameters.enable_elasticity == true ||
-                parameters.nonlinear_solver == NonlinearSolver::iterated_Advection_and_Newton_Stokes ||
-                parameters.nonlinear_solver == NonlinearSolver::single_Advection_iterated_Newton_Stokes)
-              parameters.material_averaging = MaterialModel::MaterialAveraging::harmonic_average_only_viscosity;
-            else
-              parameters.material_averaging = MaterialModel::MaterialAveraging::project_to_Q1_only_viscosity;
-          }
-        else
-          parameters.material_averaging = MaterialModel::MaterialAveraging::none;
-      }
-  }
-}
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template struct Simulator<dim>::AdvectionField; \
-  template double Simulator<dim>::normalize_pressure(LinearAlgebra::BlockVector &vector) const; \
-  template void Simulator<dim>::denormalize_pressure(const double pressure_adjustment, \
-                                                     LinearAlgebra::BlockVector &vector, \
-                                                     const LinearAlgebra::BlockVector &relevant_vector) const; \
-  template double Simulator<dim>::compute_pressure_scaling_factor () const; \
-  template double Simulator<dim>::get_maximal_velocity (const LinearAlgebra::BlockVector &solution) const; \
-  template std::pair<double,double> Simulator<dim>::get_extrapolated_advection_field_range (const AdvectionField &advection_field) const; \
-  template void Simulator<dim>::maybe_write_timing_output () const; \
-  template bool Simulator<dim>::maybe_write_checkpoint (const time_t, const bool); \
-  template bool Simulator<dim>::maybe_do_initial_refinement (const unsigned int max_refinement_level); \
-  template void Simulator<dim>::exchange_refinement_flags (); \
-  template void Simulator<dim>::maybe_refine_mesh (const double new_time_step, unsigned int &max_refinement_level); \
-  template void Simulator<dim>::advance_time (const double step_size); \
-  template void Simulator<dim>::make_pressure_rhs_compatible(LinearAlgebra::BlockVector &vector); \
-  template void Simulator<dim>::output_statistics(); \
-  template void Simulator<dim>::write_plugin_graph(std::ostream &) const; \
-  template double Simulator<dim>::compute_initial_stokes_residual(); \
-  template bool Simulator<dim>::stokes_matrix_depends_on_solution() const; \
-  template bool Simulator<dim>::stokes_A_block_is_symmetric() const; \
-  template void Simulator<dim>::interpolate_onto_velocity_system(const TensorFunction<1,dim> &func, LinearAlgebra::Vector &vec);\
-  template void Simulator<dim>::compute_reactions(); \
-  template void Simulator<dim>::initialize_current_linearization_point (); \
-  template void Simulator<dim>::interpolate_material_output_into_advection_field(const AdvectionField &adv_field); \
-  template void Simulator<dim>::check_consistency_of_formulation(); \
-  template void Simulator<dim>::replace_outflow_boundary_ids(const unsigned int boundary_id_offset); \
-  template void Simulator<dim>::restore_outflow_boundary_ids(const unsigned int boundary_id_offset); \
-  template void Simulator<dim>::check_consistency_of_boundary_conditions() const; \
-  template double Simulator<dim>::compute_initial_newton_residual(const LinearAlgebra::BlockVector &linearized_stokes_initial_guess); \
-  template double Simulator<dim>::compute_Eisenstat_Walker_linear_tolerance(const bool EisenstatWalkerChoiceOne, \
-                                                                            const double maximum_linear_stokes_solver_tolerance, \
-                                                                            const double linear_stokes_solver_tolerance, \
-                                                                            const double stokes_residual, \
-                                                                            const double newton_residual, \
-                                                                            const double newton_residual_old); \
-  template void Simulator<dim>::select_default_solver_and_averaging();
-
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/initial_conditions.cc.bak b/source/simulator/initial_conditions.cc.bak
deleted file mode 100644
index 836a95c0f66..00000000000
--- a/source/simulator/initial_conditions.cc.bak
+++ /dev/null
@@ -1,545 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/initial_composition/interface.h>
-#include <aspect/postprocess/particles.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function.h>
-
-#include <deal.II/lac/full_matrix.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-namespace aspect
-{
-
-  template <int dim>
-  void Simulator<dim>::set_initial_temperature_and_compositional_fields ()
-  {
-    // create a fully distributed vector since we
-    // need to write into it and we can not
-    // write into vectors with ghost elements
-    LinearAlgebra::BlockVector initial_solution;
-    double max_sum_comp = 0.0;
-
-    // we need to track whether we need to normalize the totality of fields
-    bool normalize_composition = false;
-
-    initial_solution.reinit(system_rhs, false);
-
-    // below, we would want to call VectorTools::interpolate on the
-    // entire FESystem. there currently is no way to restrict the
-    // interpolation operations to only a subset of vector
-    // components (oversight in deal.II?), specifically to the
-    // temperature component. this causes more work than necessary
-    // but worse yet, it doesn't work for the DGP(q) pressure element
-    // if we use a locally conservative formulation since there the
-    // pressure element is non-interpolating (we get an exception
-    // even though we are, strictly speaking, not interested in
-    // interpolating the pressure; but, as mentioned, there is no way
-    // to tell VectorTools::interpolate that)
-    //
-    // to work around this problem, the following code is essentially
-    // a (simplified) copy of the code in VectorTools::interpolate
-    // that only works on the temperature component
-    //
-    // TODO: it would be great if we had a cleaner way than iterating to 1+n_fields.
-    // Additionally, the n==1 logic for normalization at the bottom is not pretty.
-    for (unsigned int n=0; n<1+introspection.n_compositional_fields; ++n)
-      {
-        const AdvectionField advf = ((n == 0) ? AdvectionField::temperature()
-                                     : AdvectionField::composition(n-1));
-
-        const unsigned int base_element = advf.base_element(introspection);
-
-        // get the temperature/composition support points
-        const std::vector<Point<dim>> support_points
-          = finite_element.base_element(base_element).get_unit_support_points();
-        Assert (support_points.size() != 0,
-                ExcInternalError());
-
-        // create an FEValues object with just the temperature/composition element
-        FEValues<dim> fe_values (*mapping, finite_element,
-                                 support_points,
-                                 update_quadrature_points);
-
-        std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-
-        const VectorFunctionFromScalarFunctionObject<dim, double> &advf_init_function
-          =
-            (advf.is_temperature()
-             ?
-             VectorFunctionFromScalarFunctionObject<dim, double>(
-               [&](const Point<dim> &p) -> double
-        {
-          return initial_temperature_manager->initial_temperature(p);
-        },
-        introspection.component_indices.temperature,
-        introspection.n_components)
-        :
-        VectorFunctionFromScalarFunctionObject<dim, double>(
-          [&](const Point<dim> &p) -> double
-        {
-          return initial_composition_manager->initial_composition(p, n-1);
-        },
-        introspection.component_indices.compositional_fields[n-1],
-        introspection.n_components));
-
-        const ComponentMask advf_mask =
-          (advf.is_temperature()
-           ?
-           introspection.component_masks.temperature
-           :
-           introspection.component_masks.compositional_fields[n-1]);
-
-        try
-          {
-            VectorTools::interpolate(*mapping,
-                                     dof_handler,
-                                     advf_init_function,
-                                     initial_solution,
-                                     advf_mask);
-          }
-        // initial conditions that throw exceptions usually do not result in
-        // anything good because they result in an unwinding of the stack
-        // and, if only one processor triggers an exception, the
-        // destruction of objects often causes a deadlock. thus, if
-        // an exception is generated, catch it, print an error message,
-        // and abort the program
-        catch (std::exception &exc)
-          {
-            const std::string field_name = (advf.is_temperature()
-                                            ?
-                                            "temperature"
-                                            :
-                                            introspection.name_for_compositional_index(n-1));
-
-            std::cerr << std::endl << std::endl
-                      << "----------------------------------------------------"
-                      << std::endl;
-            std::cerr << "Exception on MPI process <"
-                      << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                      << "> while setting the initial condition for field <"
-                      << field_name
-                      << ">: " << std::endl
-                      << exc.what() << std::endl
-                      << "Aborting!" << std::endl
-                      << "----------------------------------------------------"
-                      << std::endl;
-
-            // terminate the program!
-            MPI_Abort (MPI_COMM_WORLD, 1);
-          }
-        catch (...)
-          {
-            const std::string field_name = (advf.is_temperature()
-                                            ?
-                                            "temperature"
-                                            :
-                                            introspection.name_for_compositional_index(n-1));
-
-            std::cerr << std::endl << std::endl
-                      << "----------------------------------------------------"
-                      << std::endl;
-            std::cerr << "Exception on MPI process <"
-                      << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                      << "> while setting the initial condition for field <"
-                      << field_name
-                      << ">: " << std::endl;
-            std::cerr << "Unknown exception!" << std::endl
-                      << "Aborting!" << std::endl
-                      << "----------------------------------------------------"
-                      << std::endl;
-
-            // terminate the program!
-            MPI_Abort (MPI_COMM_WORLD, 1);
-          }
-
-        if (parameters.normalized_fields.size()>0 && n==1)
-          for (const auto &cell : dof_handler.active_cell_iterators())
-            if (cell->is_locally_owned())
-              {
-                fe_values.reinit (cell);
-
-                // Go through the support points for each dof
-                for (unsigned int i=0; i<finite_element.base_element(base_element).dofs_per_cell; ++i)
-                  {
-                    // if it is specified in the parameter file that the sum of all compositional fields
-                    // must not exceed one, this should be checked
-                    double sum = 0;
-                    for (unsigned int m=0; m<parameters.normalized_fields.size(); ++m)
-                      sum += initial_composition_manager->initial_composition(fe_values.quadrature_point(i),
-                                                                              parameters.normalized_fields[m]);
-
-                    if (std::abs(sum) > 1.0+std::numeric_limits<double>::epsilon())
-                      {
-                        max_sum_comp = std::max(sum, max_sum_comp);
-                        normalize_composition = true;
-                      }
-                  }
-              }
-
-        initial_solution.compress(VectorOperation::insert);
-
-        // if at least one processor decides that it needs
-        // to normalize, do the same on all processors.
-        if (Utilities::MPI::max (normalize_composition ? 1 : 0,
-                                 mpi_communicator)
-            == 1)
-          {
-            const double global_max
-              = Utilities::MPI::max (max_sum_comp, mpi_communicator);
-
-            if (n==1)
-              pcout << "Sum of compositional fields is not one, fields will be normalized"
-                    << std::endl;
-
-            for (unsigned int m=0; m<parameters.normalized_fields.size(); ++m)
-              if (n-1==parameters.normalized_fields[m])
-                initial_solution.block(introspection.block_indices.compositional_fields[n-1]) /= global_max;
-          }
-      }
-
-    // then apply constraints and copy the
-    // result into vectors with ghost elements. to do so,
-    // we need the current constraints to be correct for
-    // the current time
-    compute_current_constraints ();
-    current_constraints.distribute(initial_solution);
-
-    // Now copy the temperature and initial composition blocks into the solution variables
-
-    for (unsigned int n=0; n<1+introspection.n_compositional_fields; ++n)
-      {
-        AdvectionField advf = ((n == 0) ? AdvectionField::temperature()
-                               : AdvectionField::composition(n-1));
-
-        const unsigned int blockidx = advf.block_index(introspection);
-
-        solution.block(blockidx) = initial_solution.block(blockidx);
-        old_solution.block(blockidx) = initial_solution.block(blockidx);
-        old_old_solution.block(blockidx) = initial_solution.block(blockidx);
-        current_linearization_point.block(blockidx) = initial_solution.block(blockidx);
-      }
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::interpolate_particle_properties (const AdvectionField &advection_field)
-  {
-    std::vector<AdvectionField> advection_fields(1,advection_field);
-    interpolate_particle_properties(advection_fields);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::interpolate_particle_properties (const std::vector<AdvectionField> &advection_fields)
-  {
-    TimerOutput::Scope timer (computing_timer, "Particles: Interpolate");
-
-    // below, we would want to call VectorTools::interpolate on the
-    // entire FESystem. there currently is no way to restrict the
-    // interpolation operations to only a subset of vector
-    // components (oversight in deal.II?), specifically to the
-    // temperature component. this causes more work than necessary
-    // but worse yet, it doesn't work for the DGP(q) pressure element
-    // if we use a locally conservative formulation since there the
-    // pressure element is non-interpolating (we get an exception
-    // even though we are, strictly speaking, not interested in
-    // interpolating the pressure; but, as mentioned, there is no way
-    // to tell VectorTools::interpolate that)
-    //
-    // to work around this problem, the following code is essentially
-    // a (simplified) copy of the code in VectorTools::interpolate
-    // that only works on the given component
-
-    // create a fully distributed vector since we
-    // need to write into it and we can not
-    // write into vectors with ghost elements
-
-    const Particle::Interpolator::Interface<dim> &particle_interpolator = particle_worlds[0]->get_interpolator();
-    const Particle::Property::Manager<dim> &particle_property_manager = particle_worlds[0]->get_property_manager();
-
-    std::vector<unsigned int> particle_property_indices;
-    ComponentMask property_mask  (particle_property_manager.get_data_info().n_components(),false);
-
-    for (const auto &advection_field: advection_fields)
-      {
-        if (parameters.mapped_particle_properties.size() != 0)
-          {
-            const std::pair<std::string,unsigned int> particle_property_and_component = parameters.mapped_particle_properties.find(advection_field.compositional_variable)->second;
-
-            const unsigned int particle_property_index = particle_property_manager.get_data_info().get_position_by_field_name(particle_property_and_component.first)
-                                                         + particle_property_and_component.second;
-
-            particle_property_indices.push_back(particle_property_index);
-
-            property_mask.set(particle_property_index,true);
-          }
-        else
-          {
-            const unsigned int particle_property_index = std::count(introspection.compositional_field_methods.begin(),
-                                                                    introspection.compositional_field_methods.begin() + advection_field.compositional_variable,
-                                                                    Parameters<dim>::AdvectionFieldMethod::particles);
-            AssertThrow(particle_property_index <= particle_property_manager.get_data_info().n_components(),
-                        ExcMessage("Can not automatically match particle properties to fields, because there are"
-                                   "more fields that are marked as particle advected than particle properties"));
-
-            particle_property_indices.push_back(particle_property_index);
-            property_mask.set(particle_property_index,true);
-          }
-      }
-
-    LinearAlgebra::BlockVector particle_solution;
-
-    particle_solution.reinit(system_rhs, false);
-
-    const unsigned int base_element_index = advection_fields[0].base_element(introspection);
-
-    // We can only combine the interpolation of properties into fields
-    // that share the same base element. Otherwise the element support points
-    // are not guaranteed to be identical.
-    for (const auto &advection_field: advection_fields)
-      {
-        (void) advection_field;
-        Assert (advection_field.base_element(introspection) == base_element_index, ExcInternalError());
-      }
-
-    // get the temperature/composition support points
-    const std::vector<Point<dim>> support_points
-      = finite_element.base_element(base_element_index).get_unit_support_points();
-    Assert (support_points.size() != 0,
-            ExcInternalError());
-
-    // create an FEValues object with just the temperature/composition element
-    FEValues<dim> fe_values (*mapping, finite_element,
-                             support_points,
-                             update_quadrature_points);
-
-    std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          const std::vector<Point<dim>> quadrature_points = fe_values.get_quadrature_points();
-
-          std::vector<std::vector<double>> particle_properties;
-
-          try
-            {
-              particle_properties =
-                particle_interpolator.properties_at_points(particle_worlds[0]->get_particle_handler(),
-                                                           quadrature_points,
-                                                           property_mask,
-                                                           cell);
-            }
-          // interpolators that throw exceptions usually do not result in
-          // anything good, because they result in an unwinding of the stack
-          // and, if only one processor triggers an exception, the
-          // destruction of objects often causes a deadlock or completely
-          // unrelated MPI error messages. Thus, if an exception is
-          // generated, catch it, print an error message, and abort the program.
-          catch (std::exception &exc)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while interpolating particle properties: "
-                        << std::endl
-                        << exc.what() << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-
-          // go through the composition dofs and set their global values
-          // to the particle field interpolated at these points
-          cell->get_dof_indices (local_dof_indices);
-          const unsigned int n_dofs_per_cell = finite_element.base_element(base_element_index).dofs_per_cell;
-          for (unsigned int j=0; j<advection_fields.size(); ++j)
-            for (unsigned int i=0; i<n_dofs_per_cell; ++i)
-              {
-                const unsigned int system_local_dof
-                  = finite_element.component_to_system_index(advection_fields[j].component_index(introspection),
-                                                             /*dof index within component=*/i);
-
-                particle_solution(local_dof_indices[system_local_dof]) = particle_properties[i][particle_property_indices[j]];
-              }
-        }
-
-    particle_solution.compress(VectorOperation::insert);
-
-    // overwrite the relevant composition blocks only
-    std::vector<bool> particle_blocks (introspection.n_blocks,false);
-    for (const auto &advection_field: advection_fields)
-      {
-        const unsigned int blockidx = advection_field.block_index(introspection);
-        particle_blocks[blockidx] = true;
-        solution.block(blockidx) = particle_solution.block(blockidx);
-
-        // In the first timestep, and for iterative Advection schemes only
-        // in the first nonlinear iteration, initialize all solution vectors with the initial
-        // particle solution, identical to the end of the
-        // Simulator<dim>::set_initial_temperature_and_compositional_fields ()
-        // function.
-        if (timestep_number == 0 && nonlinear_iteration == 0)
-          {
-            old_solution.block(blockidx) = particle_solution.block(blockidx);
-            old_old_solution.block(blockidx) = particle_solution.block(blockidx);
-          }
-      }
-
-    // we should not have written at all into any of the blocks
-    // that are not interpolated from particles
-    for (unsigned int b=0; b<introspection.n_blocks; ++b)
-      if (particle_blocks[b] == false)
-        Assert (particle_solution.block(b).l2_norm() == 0,
-                ExcInternalError());
-
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::compute_initial_pressure_field ()
-  {
-    // Note that this code will overwrite the velocity solution with 0 if
-    // velocity and pressure are in the same block (i.e., direct solver is
-    // used). As the velocity is all zero anyway, this is currently not a
-    // problem.
-
-    // we'd like to interpolate the initial pressure onto the pressure
-    // variable but that's a bit involved because the pressure may either
-    // be an FE_Q (for which we can interpolate) or an FE_DGP (for which
-    // we can't since the element has no nodal basis.
-    //
-    // fortunately, in the latter case, the element is discontinuous and
-    // we can compute a local projection onto the pressure space
-    if (parameters.use_locally_conservative_discretization == false)
-      {
-        // allocate a vector that is distributed but doesn't have
-        // ghost elements (vectors with ghost elements are not
-        // writable); the stokes_rhs vector is a valid template for
-        // this kind of thing. interpolate into it and later copy it into the
-        // solution vector that does have the necessary ghost elements
-        LinearAlgebra::BlockVector system_tmp;
-        system_tmp.reinit (system_rhs);
-
-        // First grab the correct pressure to work on:
-        const FEVariable<dim> &pressure_variable
-          = parameters.include_melt_transport ?
-            introspection.variable("fluid pressure")
-            : introspection.variable("pressure");
-        const unsigned int pressure_comp = pressure_variable.first_component_index;
-        const ComponentMask pressure_component_mask = pressure_variable.component_mask;
-
-        // interpolate the pressure given by the adiabatic conditions
-        // object onto the solution space. note that interpolate
-        // wants a function that represents all components of the
-        // solution vector, so create such a function object
-        // that is simply zero for all velocity components
-        VectorFunctionFromScalarFunctionObject<dim> vector_function_object(
-          [&](const Point<dim> &p) -> double
-        {
-          return adiabatic_conditions->pressure(p);
-        },
-        pressure_comp,
-        introspection.n_components);
-
-        VectorTools::interpolate (*mapping, dof_handler,
-                                  vector_function_object,
-                                  system_tmp,
-                                  pressure_component_mask);
-
-        // we may have hanging nodes, so apply constraints
-        constraints.distribute (system_tmp);
-
-        const unsigned int pressure_block = pressure_variable.block_index;
-        old_solution.block(pressure_block) = system_tmp.block(pressure_block);
-      }
-    else
-      {
-        // Find the local projection for the discontinuous pressure
-        // element. This is only going to work if, indeed, the element
-        // is discontinuous.
-        Assert (finite_element.base_element(introspection.base_elements.pressure).dofs_per_face == 0,
-                ExcNotImplemented());
-
-        LinearAlgebra::BlockVector system_tmp;
-        system_tmp.reinit (system_rhs);
-
-        const Quadrature<dim> &quadrature = introspection.quadratures.velocities;
-        Utilities::project_cellwise<dim,LinearAlgebra::BlockVector>(*mapping,
-                                                                    dof_handler,
-                                                                    introspection.component_indices.pressure,
-                                                                    quadrature,
-                                                                    [&](const typename DoFHandler<dim>::active_cell_iterator & /*cell*/,
-                                                                        const std::vector<Point<dim>> &q_points,
-                                                                        std::vector<double> &values) -> void
-        {
-          for (unsigned int i=0; i<values.size(); ++i)
-            values[i] = adiabatic_conditions->pressure(q_points[i]);
-          return;
-        },
-        system_tmp);
-
-        old_solution.block(introspection.block_indices.pressure) = system_tmp.block(introspection.block_indices.pressure);
-      }
-
-    // normalize the pressure in such a way that the surface pressure
-    // equals a known and desired value
-    this->last_pressure_normalization_adjustment = normalize_pressure(old_solution);
-
-    // set all solution vectors to the same value as the previous solution
-    solution = old_solution;
-    old_old_solution = old_solution;
-  }
-}
-
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template void Simulator<dim>::set_initial_temperature_and_compositional_fields(); \
-  template void Simulator<dim>::compute_initial_pressure_field(); \
-  template void Simulator<dim>::interpolate_particle_properties(const AdvectionField &);
-
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/introspection.cc.bak b/source/simulator/introspection.cc.bak
deleted file mode 100644
index c52c4e91181..00000000000
--- a/source/simulator/introspection.cc.bak
+++ /dev/null
@@ -1,615 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/introspection.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/fe_dgq.h>
-#include <deal.II/fe/fe_dgp.h>
-
-namespace aspect
-{
-  namespace internal
-  {
-    /**
-     * Return a filled ComponentIndices structure.
-     */
-    template <int dim>
-    typename Introspection<dim>::ComponentIndices
-    setup_component_indices (FEVariableCollection<dim> &fevs)
-    {
-      typename Introspection<dim>::ComponentIndices ci;
-      for (unsigned int i=0; i<dim; ++i)
-        ci.velocities[i] = fevs.variable("velocity").first_component_index+i;
-
-      ci.pressure = fevs.variable("pressure").first_component_index;
-      ci.temperature = fevs.variable("temperature").first_component_index;
-
-      {
-        const auto composition_variables = fevs.variables_with_name("compositions");
-        for (const auto &fe : composition_variables)
-          {
-            for (unsigned int i=0; i<fe->multiplicity; ++i)
-              {
-                ci.compositional_fields.push_back(fe->first_component_index+i);
-              }
-          }
-      }
-
-      return ci;
-    }
-
-    /**
-     * return filled BlockIndices structure.
-     */
-    template <int dim>
-    typename Introspection<dim>::BlockIndices
-    setup_blocks (FEVariableCollection<dim> &fevs)
-    {
-      typename Introspection<dim>::BlockIndices b;
-      b.velocities = fevs.variable("velocity").block_index;
-      b.pressure = fevs.variable("pressure").block_index;
-      b.temperature = fevs.variable("temperature").block_index;
-
-      {
-        const auto variables = fevs.variables_with_name("compositions");
-        for (const auto &fe : variables)
-          {
-            for (unsigned int i=0; i<fe->multiplicity; ++i)
-              {
-                b.compositional_fields.push_back(fe->block_index + i);
-                b.compositional_field_sparsity_pattern.push_back(fe->block_index);
-              }
-          }
-      }
-      return b;
-    }
-
-
-
-    template <int dim>
-    typename Introspection<dim>::BaseElements
-    setup_base_elements (FEVariableCollection<dim> &fevs)
-    {
-      typename Introspection<dim>::BaseElements base_elements;
-
-      base_elements.velocities = fevs.variable("velocity").base_index;
-      base_elements.pressure = fevs.variable("pressure").base_index;
-      base_elements.temperature = fevs.variable("temperature").base_index;
-
-      {
-        // TODO: We would ideally reuse base elements also when they are
-        // not consecutively encountered. For now, just ignore that fact.
-        const auto variables = fevs.variables_with_name("compositions");
-        for (const auto &fe : variables)
-          {
-            for (unsigned int i=0; i<fe->multiplicity; ++i)
-              base_elements.compositional_fields.push_back(fe->base_index);
-          }
-      }
-
-
-
-
-      return base_elements;
-    }
-
-
-
-    template <int dim>
-    typename Introspection<dim>::PolynomialDegree
-    setup_polynomial_degree (const Parameters<dim> &parameters)
-    {
-      typename Introspection<dim>::PolynomialDegree polynomial_degree;
-
-      polynomial_degree.velocities = parameters.stokes_velocity_degree;
-      polynomial_degree.temperature = parameters.temperature_degree;
-      polynomial_degree.compositional_fields = parameters.composition_degree;
-
-      return polynomial_degree;
-    }
-
-
-
-    template <int dim>
-    typename Introspection<dim>::Quadratures
-    setup_quadratures (const Parameters<dim> &parameters,
-                       const ReferenceCell reference_cell)
-    {
-      typename Introspection<dim>::Quadratures quadratures;
-
-      quadratures.velocities = reference_cell.get_gauss_type_quadrature<dim>(parameters.stokes_velocity_degree+1);
-      quadratures.pressure = reference_cell.get_gauss_type_quadrature<dim>(parameters.use_equal_order_interpolation_for_stokes
-                                                                           ?
-                                                                           parameters.stokes_velocity_degree+1
-                                                                           :
-                                                                           parameters.stokes_velocity_degree);
-      quadratures.temperature = reference_cell.get_gauss_type_quadrature<dim>(parameters.temperature_degree+1);
-      quadratures.compositional_fields = reference_cell.get_gauss_type_quadrature<dim>(parameters.composition_degree+1);
-      quadratures.system = reference_cell.get_gauss_type_quadrature<dim>(std::max({parameters.stokes_velocity_degree,
-                                                                                   parameters.temperature_degree,
-                                                                                   parameters.composition_degree
-                                                                                  }) + 1);
-
-      return quadratures;
-    }
-
-
-
-    template <int dim>
-    typename Introspection<dim>::FaceQuadratures
-    setup_face_quadratures (const Parameters<dim> &parameters,
-                            const ReferenceCell reference_cell)
-    {
-      typename Introspection<dim>::FaceQuadratures quadratures;
-
-      quadratures.velocities = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(parameters.stokes_velocity_degree+1);
-      quadratures.pressure = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(parameters.use_equal_order_interpolation_for_stokes
-                             ?
-                             parameters.stokes_velocity_degree+1
-                             :
-                             parameters.stokes_velocity_degree);
-      quadratures.temperature = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(parameters.temperature_degree+1);
-      quadratures.compositional_fields = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(parameters.composition_degree+1);
-      quadratures.system = reference_cell.face_reference_cell(0).get_gauss_type_quadrature<dim-1>(std::max({parameters.stokes_velocity_degree,
-                           parameters.temperature_degree,
-                           parameters.composition_degree
-                                                                                                           }) + 1);
-
-      return quadratures;
-    }
-
-
-
-    template <int dim>
-    std::shared_ptr<FiniteElement<dim>>
-    new_FE_Q_or_DGP(const bool discontinuous,
-                    const unsigned int degree)
-    {
-      if (discontinuous)
-        return std::make_shared<FE_DGP<dim>>(degree);
-      else
-        return std::make_shared<FE_Q<dim>>(degree);
-    }
-
-
-
-    template <int dim>
-    std::shared_ptr<FiniteElement<dim>>
-    new_FE_Q_or_DGQ(const bool discontinuous,
-                    const unsigned int degree)
-    {
-      if (discontinuous)
-        return std::make_shared<FE_DGQ<dim>>(degree);
-      else
-        return std::make_shared<FE_Q<dim>>(degree);
-    }
-  }
-
-
-
-
-  template <int dim>
-  std::vector<VariableDeclaration<dim>>
-  construct_default_variables (const Parameters<dim> &parameters)
-  {
-    std::vector<VariableDeclaration<dim>> variables;
-
-    const unsigned int n_velocity_blocks = parameters.use_direct_stokes_solver ? 0 : 1;
-    variables.push_back(
-      VariableDeclaration<dim>("velocity",
-                               std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree),
-                               dim,
-                               n_velocity_blocks));
-
-    if (parameters.use_equal_order_interpolation_for_stokes == false)
-      variables.push_back(
-        VariableDeclaration<dim>(
-          "pressure",
-          internal::new_FE_Q_or_DGP<dim>(parameters.use_locally_conservative_discretization,
-                                         parameters.stokes_velocity_degree-1),
-          1,
-          1));
-    else
-      variables.push_back(
-        VariableDeclaration<dim>(
-          "pressure",
-          std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree),
-          1,
-          1));
-
-
-    variables.push_back(
-      VariableDeclaration<dim>(
-        "temperature",
-        internal::new_FE_Q_or_DGQ<dim>(parameters.use_discontinuous_temperature_discretization,
-                                       parameters.temperature_degree),
-        1,
-        1));
-
-    // We can not create a single composition with multiplicity n (this assumes all have the same FiniteElement) and
-    // we also don't want to create n different compositional fields for performance reasons. Instead, we combine
-    // consecutive compositions of the same type into the same base element. For example, if the user requests
-    // "Q2,Q2,DGQ1,Q2", we actually create "Q2^2, DGQ1, Q2":
-    for (unsigned int c=0; c<parameters.n_compositional_fields; ++c)
-      {
-        if (c>0 && parameters.use_discontinuous_composition_discretization[c] == parameters.use_discontinuous_composition_discretization[c-1])
-          {
-            // reuse last one because it is the same
-            variables.back().multiplicity += 1;
-            variables.back().n_blocks += 1;
-          }
-        else
-          {
-            std::shared_ptr<FiniteElement<dim>> fe = internal::new_FE_Q_or_DGQ<dim>(parameters.use_discontinuous_composition_discretization[c],
-                                                                                     parameters.composition_degree);
-            variables.push_back(VariableDeclaration<dim>("compositions", fe, 1, 1));
-          }
-      }
-
-    return variables;
-  }
-
-
-  template <int dim>
-  Introspection<dim>::Introspection(const std::vector<VariableDeclaration<dim>> &variable_definition,
-                                    const Parameters<dim> &parameters
-                                   )
-    :
-    FEVariableCollection<dim>(variable_definition),
-    n_components (FEVariableCollection<dim>::n_components()),
-    n_compositional_fields (parameters.n_compositional_fields),
-    use_discontinuous_temperature_discretization (parameters.use_discontinuous_temperature_discretization),
-    use_discontinuous_composition_discretization (parameters.use_discontinuous_composition_discretization),
-    component_indices (internal::setup_component_indices<dim>(*this)),
-    n_blocks (FEVariableCollection<dim>::n_blocks()),
-    block_indices (internal::setup_blocks<dim>(*this)),
-    extractors (component_indices),
-    base_elements (internal::setup_base_elements<dim>(*this)),
-    polynomial_degree (internal::setup_polynomial_degree<dim>(parameters)),
-    quadratures (internal::setup_quadratures<dim>(parameters, ReferenceCells::get_hypercube<dim>())),
-    face_quadratures (internal::setup_face_quadratures<dim>(parameters, ReferenceCells::get_hypercube<dim>())),
-    component_masks (*this, component_indices),
-    system_dofs_per_block (n_blocks),
-    temperature_method(parameters.temperature_method),
-    compositional_field_methods(parameters.compositional_field_methods),
-    composition_names(parameters.names_of_compositional_fields),
-    composition_descriptions(parameters.composition_descriptions),
-    composition_names_for_type(CompositionalFieldDescription::n_types),
-    composition_indices_for_type(CompositionalFieldDescription::n_types)
-  {
-    // Set up the indices for the different types of compositional fields
-    for (unsigned int c=0; c<composition_descriptions.size(); ++c)
-      {
-        composition_indices_for_type[composition_descriptions[c].type].push_back(c);
-        composition_names_for_type[composition_descriptions[c].type].push_back(composition_names[c]);
-      }
-
-    // Fill composition_base_element_indices
-    {
-      if (this->n_compositional_fields > 0)
-        {
-          // We are assigning base elements in order, so the first compositional field
-          // gives us the first base element index. Then we find the largest index
-          // in the vector. This is necessary, because the fields could have type A,B,A.
-          const unsigned int first = this->base_elements.compositional_fields[0];
-          const unsigned int last = *std::max_element(this->base_elements.compositional_fields.begin(),
-                                                      this->base_elements.compositional_fields.end());
-
-          composition_base_element_indices.resize(last-first+1);
-          std::iota(composition_base_element_indices.begin(), composition_base_element_indices.end(), first);
-        }
-    }
-
-// Fill compositional_field_indices_with_base_element
-    {
-      for (const auto base_element_index : composition_base_element_indices)
-        {
-          std::vector<unsigned int> result;
-
-          unsigned int idx = 0;
-          for (const auto base_idx : this->base_elements.compositional_fields)
-            {
-              if (base_idx == base_element_index)
-                result.emplace_back(idx);
-              ++idx;
-            }
-
-          Assert(result.size() > 0, ExcInternalError("There should be at least one compositional field for a valid base element."));
-          compositional_field_indices_with_base_element[base_element_index] = result;
-        }
-    }
-
-  }
-
-
-
-  template <int dim>
-  Introspection<dim>::~Introspection ()
-    = default;
-
-
-
-  namespace
-  {
-    std::vector<FEValuesExtractors::Scalar>
-    make_extractor_sequence (const std::vector<unsigned int> &compositional_fields)
-    {
-      std::vector<FEValuesExtractors::Scalar> x;
-      x.reserve(compositional_fields.size());
-      for (const unsigned int compositional_field : compositional_fields)
-        x.emplace_back(compositional_field);
-      return x;
-    }
-  }
-
-
-
-  template <int dim>
-  Introspection<dim>::Extractors::Extractors (const Introspection<dim>::ComponentIndices &component_indices)
-    :
-    velocities (component_indices.velocities[0]),
-    pressure (component_indices.pressure),
-    temperature (component_indices.temperature),
-    compositional_fields (make_extractor_sequence (component_indices.compositional_fields))
-  {}
-
-
-
-  namespace
-  {
-    template <int dim>
-    std::vector<ComponentMask>
-    make_composition_component_mask_sequence (const FEVariableCollection<dim> &fevs, const typename Introspection<dim>::ComponentIndices &indices)
-    {
-      std::vector<ComponentMask> result;
-      for (const unsigned int idx : indices.compositional_fields)
-        {
-          result.push_back(ComponentMask(fevs.n_components(), false));
-          result.back().set(idx, true);
-        }
-      return result;
-    }
-  }
-
-
-
-  template <int dim>
-  Introspection<dim>::ComponentMasks::ComponentMasks (const FEVariableCollection<dim> &fevs, const Introspection<dim>::ComponentIndices &indices)
-    :
-    velocities (fevs.variable("velocity").component_mask),
-    pressure (fevs.variable("pressure").component_mask),
-    temperature (fevs.variable("temperature").component_mask),
-    compositional_fields (make_composition_component_mask_sequence (fevs, indices))
-  {}
-
-
-
-  template <int dim>
-  const std::vector<unsigned int> &
-  Introspection<dim>::get_composition_base_element_indices() const
-  {
-    return composition_base_element_indices;
-  }
-
-
-
-  template <int dim>
-  const std::vector<unsigned int> &
-  Introspection<dim>::get_compositional_field_indices_with_base_element(const unsigned int base_element_index) const
-  {
-    Assert(compositional_field_indices_with_base_element.find(base_element_index)
-           != compositional_field_indices_with_base_element.end(),
-           ExcMessage("Invalid base_element_index specified."));
-    return compositional_field_indices_with_base_element.find(base_element_index)->second;
-  }
-
-
-
-  template <int dim>
-  unsigned int
-  Introspection<dim>::compositional_index_for_name (const std::string &name) const
-  {
-    const std::vector<std::string>::const_iterator
-    it = std::find(composition_names.begin(), composition_names.end(), name);
-    AssertThrow (it != composition_names.end(),
-                 ExcMessage ("The compositional field " + name +
-                             " you asked for is not used in the simulation."));
-
-    return (it - composition_names.begin());
-  }
-
-
-
-  template <int dim>
-  std::string
-  Introspection<dim>::name_for_compositional_index (const unsigned int index) const
-  {
-    // make sure that what we get here is really an index of one of the compositional fields
-    AssertIndexRange(index,composition_names.size());
-    return composition_names[index];
-  }
-
-
-
-  template <int dim>
-  const std::vector<std::string> &
-  Introspection<dim>::get_composition_names () const
-  {
-    // Simply return the full list of composition names
-    return composition_names;
-  }
-
-
-
-  template <int dim>
-  const std::vector<CompositionalFieldDescription> &
-  Introspection<dim>::get_composition_descriptions () const
-  {
-    return composition_descriptions;
-  }
-
-
-
-  template <int dim>
-  const std::vector<std::string> &
-  Introspection<dim>::chemical_composition_field_names () const
-  {
-    return get_names_for_fields_of_type(CompositionalFieldDescription::chemical_composition);
-  }
-
-
-
-  template <int dim>
-  const std::vector<unsigned int> &
-  Introspection<dim>::chemical_composition_field_indices () const
-  {
-    return get_indices_for_fields_of_type(CompositionalFieldDescription::chemical_composition);
-  }
-
-
-
-  template <int dim>
-  unsigned int
-  Introspection<dim>::n_chemical_composition_fields () const
-  {
-    return get_number_of_fields_of_type(CompositionalFieldDescription::Type::chemical_composition);
-  }
-
-
-
-  template <int dim>
-  bool
-  Introspection<dim>::composition_type_exists (const CompositionalFieldDescription::Type &type) const
-  {
-    Assert(type < composition_indices_for_type.size(), ExcInternalError());
-
-    return composition_indices_for_type[type].size() > 0;
-  }
-
-
-
-  template <int dim>
-  unsigned int
-  Introspection<dim>::find_composition_type (const typename CompositionalFieldDescription::Type &type) const
-  {
-    Assert(type < composition_indices_for_type.size(), ExcInternalError());
-
-    if (composition_indices_for_type[type].size() > 0)
-      return composition_indices_for_type[type][0];
-
-    return composition_descriptions.size();
-  }
-
-
-
-  template <int dim>
-  bool
-  Introspection<dim>::compositional_name_exists (const std::string &name) const
-  {
-    return (std::find(composition_names.begin(), composition_names.end(), name) != composition_names.end()
-            ?
-            true
-            :
-            false);
-  }
-
-
-
-  template <int dim>
-  const std::vector<unsigned int> &
-  Introspection<dim>::get_indices_for_fields_of_type (const CompositionalFieldDescription::Type &type) const
-  {
-    Assert(type < composition_indices_for_type.size(), ExcInternalError());
-    return composition_indices_for_type[type];
-  }
-
-
-
-  template <int dim>
-  const std::vector<std::string> &
-  Introspection<dim>::get_names_for_fields_of_type (const CompositionalFieldDescription::Type &type) const
-  {
-    Assert(type < composition_names_for_type.size(), ExcInternalError());
-    return composition_names_for_type[type];
-  }
-
-
-
-  template <int dim>
-  unsigned int
-  Introspection<dim>::get_number_of_fields_of_type (const CompositionalFieldDescription::Type &type) const
-  {
-    Assert(type < composition_indices_for_type.size(), ExcInternalError());
-    return composition_indices_for_type[type].size();
-  }
-
-
-
-  template <int dim>
-  bool
-  Introspection<dim>::is_stokes_component (const unsigned int component_index) const
-  {
-    if (component_index == component_indices.pressure)
-      return true;
-
-    for (unsigned int i=0; i<dim; ++i)
-      if (component_index == component_indices.velocities[i])
-        return true;
-
-    return false;
-  }
-
-
-
-  template <int dim>
-  bool
-  Introspection<dim>::is_composition_component (const unsigned int component_index) const
-  {
-    // All compositions live at the end. Just to be sure, there are no other components
-    // in our system after compositional fields, right?
-    Assert(component_indices.compositional_fields[0] > component_indices.temperature
-           && component_indices.compositional_fields.back() == n_components-1, ExcInternalError());
-
-    if (component_index >= component_indices.compositional_fields[0])
-      return true;
-    else
-      return false;
-  }
-
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template struct Introspection<dim>; \
-  template \
-  std::vector<VariableDeclaration<dim>> \
-  construct_default_variables (const Parameters<dim> &parameters);
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/lateral_averaging.cc.bak b/source/simulator/lateral_averaging.cc.bak
deleted file mode 100644
index 3b1218c80ec..00000000000
--- a/source/simulator/lateral_averaging.cc.bak
+++ /dev/null
@@ -1,972 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/lateral_averaging.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/quadrature_lib.h>
-
-
-
-namespace aspect
-{
-  /**
-   * This namespace contains all the implemented functors. They are used to
-   * compute various properties of the solution that will be laterally averaged.
-   */
-  namespace
-  {
-    template <int dim>
-    class FunctorDepthAverageField: public internal::FunctorBase<dim>
-    {
-      public:
-        FunctorDepthAverageField(const FEValuesExtractors::Scalar &field)
-          : field_(field)
-        {}
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
-                        const MaterialModel::MaterialModelOutputs<dim> &,
-                        const FEValues<dim> &fe_values,
-                        const LinearAlgebra::BlockVector &solution,
-                        std::vector<double> &output) override
-        {
-          fe_values[field_].get_function_values (solution, output);
-        }
-
-        const FEValuesExtractors::Scalar field_;
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageAdiabat: public internal::FunctorBase<dim>
-    {
-      public:
-        enum Property
-        {
-          temperature,
-          pressure,
-          density,
-          density_derivative
-        } property;
-
-
-
-        FunctorDepthAverageAdiabat(const Property &property,
-                                   const AdiabaticConditions::Interface<dim> &adiabat)
-          : property(property),
-            adiabat(adiabat)
-        {}
-
-
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
-                        const MaterialModel::MaterialModelOutputs<dim> &,
-                        const FEValues<dim> &fe_values,
-                        const LinearAlgebra::BlockVector &,
-                        std::vector<double> &output) override
-        {
-          const unsigned int n_quadrature_points = output.size();
-          for (unsigned int i=0; i<n_quadrature_points; ++i)
-            {
-              if (property == Property::temperature)
-                output[i] = adiabat.temperature(fe_values.quadrature_point(i));
-              else if (property == Property::pressure)
-                output[i] = adiabat.pressure(fe_values.quadrature_point(i));
-              else if (property == Property::density)
-                output[i] = adiabat.density(fe_values.quadrature_point(i));
-              else if (property == Property::density_derivative)
-                output[i] = adiabat.density_derivative(fe_values.quadrature_point(i));
-              else
-                AssertThrow(false, ExcNotImplemented());
-            }
-        }
-
-        const AdiabaticConditions::Interface<dim> &adiabat;
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageViscosity: public internal::FunctorBase<dim>
-    {
-      public:
-        bool need_material_properties() const override
-        {
-          return true;
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
-                        const MaterialModel::MaterialModelOutputs<dim> &out,
-                        const FEValues<dim> &,
-                        const LinearAlgebra::BlockVector &,
-                        std::vector<double> &output) override
-        {
-          output = out.viscosities;
-        }
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageLogViscosity: public internal::FunctorBase<dim>
-    {
-      public:
-        bool need_material_properties() const override
-        {
-          return true;
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
-                        const MaterialModel::MaterialModelOutputs<dim> &out,
-                        const FEValues<dim> &,
-                        const LinearAlgebra::BlockVector &,
-                        std::vector<double> &output) override
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          for (unsigned i = 0; i < n_points; ++i)
-            output[i] = std::log10 (out.viscosities[i]);
-        }
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageVelocityMagnitude: public internal::FunctorBase<dim>
-    {
-      public:
-        FunctorDepthAverageVelocityMagnitude(const FEValuesExtractors::Vector &field,
-                                             bool convert_to_years)
-          : field_(field), convert_to_years_(convert_to_years)
-        {}
-
-        void setup(const unsigned int q_points) override
-        {
-          velocity_values.resize(q_points);
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
-                        const MaterialModel::MaterialModelOutputs<dim> &,
-                        const FEValues<dim> &fe_values,
-                        const LinearAlgebra::BlockVector &solution,
-                        std::vector<double> &output) override
-        {
-          fe_values[field_].get_function_values (solution, velocity_values);
-          for (unsigned int q=0; q<output.size(); ++q)
-            output[q] = std::sqrt( velocity_values[q] * velocity_values[q] ) *
-                        (convert_to_years_ ? year_in_seconds : 1.0);
-        }
-
-        std::vector<Tensor<1,dim>> velocity_values;
-        const FEValuesExtractors::Vector field_;
-        const bool convert_to_years_;
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageSinkingVelocity: public internal::FunctorBase<dim>
-    {
-      public:
-        FunctorDepthAverageSinkingVelocity(const FEValuesExtractors::Vector &field,
-                                           const GravityModel::Interface<dim> *gravity,
-                                           bool convert_to_years)
-          : field_(field),
-            gravity_(gravity),
-            convert_to_years_(convert_to_years)
-        {}
-
-        bool need_material_properties() const override
-        {
-          // this is needed because we want to access in.position in operator()
-          return true;
-        }
-
-        void setup(const unsigned int q_points) override
-        {
-          velocity_values.resize(q_points);
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &in,
-                        const MaterialModel::MaterialModelOutputs<dim> &,
-                        const FEValues<dim> &fe_values,
-                        const LinearAlgebra::BlockVector &solution,
-                        std::vector<double> &output) override
-        {
-          fe_values[field_].get_function_values (solution, velocity_values);
-          for (unsigned int q=0; q<output.size(); ++q)
-            {
-              const Tensor<1,dim> g = gravity_->gravity_vector(in.position[q]);
-              const Tensor<1,dim> vertically_down = (g.norm() > 0 ? g/g.norm() : Tensor<1,dim>());
-
-              output[q] = std::max(0.0, velocity_values[q] * vertically_down)
-                          * (convert_to_years_ ? year_in_seconds : 1.0);
-            }
-        }
-
-        std::vector<Tensor<1,dim>> velocity_values;
-        const FEValuesExtractors::Vector field_;
-        const GravityModel::Interface<dim> *gravity_;
-        const bool convert_to_years_;
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageRisingVelocity: public internal::FunctorBase<dim>
-    {
-      public:
-        FunctorDepthAverageRisingVelocity(const FEValuesExtractors::Vector &field,
-                                          const GravityModel::Interface<dim> *gravity,
-                                          bool convert_to_years)
-          : field_(field),
-            gravity_(gravity),
-            convert_to_years_(convert_to_years)
-        {}
-
-        bool need_material_properties() const override
-        {
-          // this is needed because we want to access in.position in operator()
-          return true;
-        }
-
-        void setup(const unsigned int q_points) override
-        {
-          velocity_values.resize(q_points);
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &in,
-                        const MaterialModel::MaterialModelOutputs<dim> &,
-                        const FEValues<dim> &fe_values,
-                        const LinearAlgebra::BlockVector &solution,
-                        std::vector<double> &output) override
-        {
-          fe_values[field_].get_function_values (solution, velocity_values);
-          for (unsigned int q=0; q<output.size(); ++q)
-            {
-              const Tensor<1,dim> g = gravity_->gravity_vector(in.position[q]);
-              const Tensor<1,dim> vertically_up = (g.norm() > 0 ? -g/g.norm() : Tensor<1,dim>());
-
-              output[q] = std::max(0.0, velocity_values[q] * vertically_up)
-                          * (convert_to_years_ ? year_in_seconds : 1.0);
-            }
-        }
-
-        std::vector<Tensor<1,dim>> velocity_values;
-        const FEValuesExtractors::Vector field_;
-        const GravityModel::Interface<dim> *gravity_;
-        const bool convert_to_years_;
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageVsVp: public internal::FunctorBase<dim>
-    {
-      public:
-        FunctorDepthAverageVsVp(bool vs)
-          : vs_(vs)
-        {}
-
-        bool need_material_properties() const override
-        {
-          return true;
-        }
-
-        void
-        create_additional_material_model_outputs (const unsigned int n_points,
-                                                  MaterialModel::MaterialModelOutputs<dim> &outputs) const override
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
-                        const MaterialModel::MaterialModelOutputs<dim> &out,
-                        const FEValues<dim> &,
-                        const LinearAlgebra::BlockVector &,
-                        std::vector<double> &output) override
-        {
-          const MaterialModel::SeismicAdditionalOutputs<dim> *seismic_outputs
-            = out.template get_additional_output<const MaterialModel::SeismicAdditionalOutputs<dim>>();
-
-          Assert(seismic_outputs != nullptr,ExcInternalError());
-
-          if (vs_)
-            for (unsigned int q=0; q<output.size(); ++q)
-              output[q] = seismic_outputs->vs[q];
-          else
-            for (unsigned int q=0; q<output.size(); ++q)
-              output[q] = seismic_outputs->vp[q];
-        }
-
-        bool vs_;
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageVerticalHeatFlux: public internal::FunctorBase<dim>
-    {
-      public:
-        FunctorDepthAverageVerticalHeatFlux(const FEValuesExtractors::Vector &velocity_field,
-                                            const FEValuesExtractors::Scalar &temperature_field,
-                                            const GravityModel::Interface<dim> *gm)
-          : velocity_field_(velocity_field),
-            temperature_field_(temperature_field),
-            gravity_model(gm)
-        {}
-
-        bool need_material_properties() const override
-        {
-          return true;
-        }
-
-        void setup(const unsigned int q_points) override
-        {
-          velocity_values.resize(q_points);
-          temperature_values.resize(q_points);
-          temperature_gradients.resize(q_points);
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &in,
-                        const MaterialModel::MaterialModelOutputs<dim> &out,
-                        const FEValues<dim> &fe_values,
-                        const LinearAlgebra::BlockVector &solution,
-                        std::vector<double> &output) override
-        {
-          fe_values[velocity_field_].get_function_values (solution, velocity_values);
-          fe_values[temperature_field_].get_function_values (solution, temperature_values);
-          fe_values[temperature_field_].get_function_gradients (solution, temperature_gradients);
-
-          for (unsigned int q=0; q<output.size(); ++q)
-            {
-              const Tensor<1,dim> gravity = gravity_model->gravity_vector(in.position[q]);
-              const Tensor<1,dim> vertical = -gravity/( gravity.norm() != 0.0 ?
-                                                        gravity.norm() : 1.0 );
-              const double advective_flux = (velocity_values[q] * vertical) * in.temperature[q] *
-                                            out.densities[q]*out.specific_heat[q];
-              const double conductive_flux = -(temperature_gradients[q]*vertical) *
-                                             out.thermal_conductivities[q];
-              output[q] = advective_flux + conductive_flux;
-            }
-        }
-
-        const FEValuesExtractors::Vector velocity_field_;
-        const FEValuesExtractors::Scalar temperature_field_;
-        const GravityModel::Interface<dim> *gravity_model;
-        std::vector<Tensor<1,dim>> velocity_values;
-        std::vector<Tensor<1,dim>> temperature_gradients;
-        std::vector<double> temperature_values;
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageVerticalMassFlux: public internal::FunctorBase<dim>
-    {
-      public:
-        FunctorDepthAverageVerticalMassFlux(const FEValuesExtractors::Vector &velocity_field,
-                                            const GravityModel::Interface<dim> *gm)
-          : velocity_field_(velocity_field),
-            gravity_model(gm)
-        {}
-
-        bool need_material_properties() const override
-        {
-          return true;
-        }
-
-        void setup(const unsigned int q_points) override
-        {
-          velocity_values.resize(q_points);
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &in,
-                        const MaterialModel::MaterialModelOutputs<dim> &out,
-                        const FEValues<dim> &fe_values,
-                        const LinearAlgebra::BlockVector &solution,
-                        std::vector<double> &output) override
-        {
-          fe_values[velocity_field_].get_function_values (solution, velocity_values);
-
-          for (unsigned int q=0; q<output.size(); ++q)
-            {
-              const Tensor<1,dim> gravity = gravity_model->gravity_vector(in.position[q]);
-              const Tensor<1,dim> vertical = -gravity/( gravity.norm() != 0.0 ?
-                                                        gravity.norm() : 1.0 );
-
-              output[q] = std::fabs(velocity_values[q] * vertical) * out.densities[q];
-            }
-        }
-
-        const FEValuesExtractors::Vector velocity_field_;
-        const GravityModel::Interface<dim> *gravity_model;
-        std::vector<Tensor<1,dim>> velocity_values;
-    };
-
-
-
-    template <int dim>
-    class FunctorDepthAverageFieldMass: public internal::FunctorBase<dim>
-    {
-      public:
-        FunctorDepthAverageFieldMass(const FEValuesExtractors::Scalar &field)
-          : field_(field)
-        {}
-
-        bool need_material_properties() const override
-        {
-          return true;
-        }
-
-        void setup(const unsigned int q_points) override
-        {
-          field_values.resize(q_points);
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
-                        const MaterialModel::MaterialModelOutputs<dim> &out,
-                        const FEValues<dim> &fe_values,
-                        const LinearAlgebra::BlockVector &solution,
-                        std::vector<double> &output) override
-        {
-          fe_values[field_].get_function_values (solution, field_values);
-
-          for (unsigned int q=0; q<output.size(); ++q)
-            output[q] = field_values[q] * out.densities[q];
-        }
-
-        const FEValuesExtractors::Scalar field_;
-        std::vector<double> field_values;
-    };
-  }
-
-  namespace internal
-  {
-    template <int dim>
-    bool
-    FunctorBase<dim>::need_material_properties() const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    FunctorBase<dim>::~FunctorBase()
-      = default;
-
-
-
-    template <int dim>
-    void
-    FunctorBase<dim>::create_additional_material_model_outputs (const unsigned int /*n_points*/,
-                                                                MaterialModel::MaterialModelOutputs<dim> &/*outputs*/) const
-    {}
-
-
-
-    template <int dim>
-    void
-    FunctorBase<dim>::setup(const unsigned int /*q_points*/)
-    {}
-
-    template <int dim>
-    QAnisotropic<dim>
-    get_quadrature_formula(const unsigned int lateral_quadrature_degree,
-                           const unsigned int depth_dimension);
-
-    template <>
-    QAnisotropic<3>
-    get_quadrature_formula(const unsigned int lateral_quadrature_degree,
-                           const unsigned int depth_dimension)
-    {
-      const unsigned int dim = 3;
-
-      if (depth_dimension == dim)
-        return QAnisotropic<dim> (QGauss<1>(lateral_quadrature_degree),
-                                  QGauss<1>(lateral_quadrature_degree),
-                                  QIterated<1>(QMidpoint<1>(),10));
-      else if (depth_dimension == 1)
-        return QAnisotropic<dim> (QIterated<1>(QMidpoint<1>(),10),
-                                  QGauss<1>(lateral_quadrature_degree),
-                                  QGauss<1>(lateral_quadrature_degree));
-
-      return QAnisotropic<dim>(QGauss<1>(lateral_quadrature_degree),
-                               QGauss<1>(lateral_quadrature_degree),
-                               QIterated<1>(QMidpoint<1>(),10));
-    }
-
-    template <>
-    QAnisotropic<2>
-    get_quadrature_formula(const unsigned int lateral_quadrature_degree,
-                           const unsigned int depth_dimension)
-    {
-      const unsigned int dim = 2;
-
-      if (depth_dimension == dim)
-        return QAnisotropic<dim> (QGauss<1>(lateral_quadrature_degree),
-                                  QIterated<1>(QMidpoint<1>(),10));
-      else if (depth_dimension == 1)
-        return QAnisotropic<dim> (QIterated<1>(QMidpoint<1>(),10),
-                                  QGauss<1>(lateral_quadrature_degree));
-
-      return QAnisotropic<dim>(QGauss<1>(lateral_quadrature_degree),
-                               QIterated<1>(QMidpoint<1>(),10));
-    }
-  }
-
-
-
-  template <int dim>
-  std::vector<std::vector<double>>
-  LateralAveraging<dim>::compute_lateral_averages(const std::vector<double> &depth_bounds,
-                                                  std::vector<std::unique_ptr<internal::FunctorBase<dim>>> &functors) const
-  {
-    Assert (functors.size() > 0,
-            ExcMessage ("To call this function, you need to request a positive "
-                        "number of properties to compute."));
-    Assert (depth_bounds.size() > 1,
-            ExcMessage ("To call this function, you need to request at least two "
-                        "depth boundaries."));
-    Assert(std::is_sorted(depth_bounds.begin(),depth_bounds.end()),
-           ExcMessage ("To call this function the depth boundaries need to be ordered "
-                       "with increasing depth."));
-
-    const unsigned int n_properties = functors.size();
-    const unsigned int n_slices = depth_bounds.size()-1;
-
-    std::vector<std::vector<double>> values(n_properties,
-                                             std::vector<double>(n_slices,0.0));
-    std::vector<double> volume(n_slices,0.0);
-
-    // We would like to use a quadrature formula that is appropriately accurate laterally,
-    // but has a higher resolution in depth (to have values for all depth slices, even if there
-    // are adaptively coarsened cells that are much bigger than individual slices).
-    // For that we need to know the depth direction in the unit cell coordinate system, which
-    // is only unique (= the same for all cells) in some geometries. In these geometries we
-    // can optimize the quadrature, otherwise we need to use a high-resolution quadrature in
-    // all directions, which is more expensive.
-    // The Chunk geometry model has depth as first dimension (radius, lon, lat),
-    // all others with unique direction have it last; however, the Chunk and
-    // EllipsoidalChunk geometry have not been successfully tested with
-    // the lower quadrature, so we leave it at the conservative quadrature for now.
-
-    unsigned int geometry_unique_depth_direction;
-    if (Plugins::plugin_type_matches<GeometryModel::Box<dim>>(this->get_geometry_model()) ||
-        Plugins::plugin_type_matches<GeometryModel::SphericalShell<dim>>(this->get_geometry_model()) ||
-        Plugins::plugin_type_matches<GeometryModel::TwoMergedBoxes<dim>>(this->get_geometry_model()))
-      geometry_unique_depth_direction = dim;
-    else if (Plugins::plugin_type_matches<GeometryModel::Chunk<dim>>(this->get_geometry_model()) ||
-             Plugins::plugin_type_matches<GeometryModel::EllipsoidalChunk<dim>>(this->get_geometry_model()))
-      geometry_unique_depth_direction = numbers::invalid_unsigned_int;
-    else
-      geometry_unique_depth_direction = numbers::invalid_unsigned_int;
-
-    const unsigned int max_fe_degree = std::max(this->introspection().polynomial_degree.velocities,
-                                                std::max(this->introspection().polynomial_degree.temperature,
-                                                         this->introspection().polynomial_degree.compositional_fields));
-
-    // We want to integrate over a polynomial of degree p = max_fe_degree, for which we
-    // need a quadrature of at least q, with p <= 2q-1 --> q >= (p+1)/2
-    const unsigned int lateral_quadrature_degree = static_cast<unsigned int>(std::ceil((max_fe_degree+1.0)/2.0));
-
-    std::unique_ptr<Quadrature<dim>> quadrature_formula;
-    if (geometry_unique_depth_direction != numbers::invalid_unsigned_int)
-      quadrature_formula = std::make_unique<Quadrature<dim>>(internal::get_quadrature_formula<dim>(lateral_quadrature_degree,
-                                                              geometry_unique_depth_direction));
-    else
-      quadrature_formula = std::make_unique<Quadrature<dim>>(QIterated<dim>(QMidpoint<1>(),10));
-
-    const unsigned int n_q_points = quadrature_formula->size();
-
-    FEValues<dim> fe_values (this->get_mapping(),
-                             this->get_fe(),
-                             *quadrature_formula,
-                             update_values | update_gradients | update_quadrature_points | update_JxW_values);
-
-    std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),
-                                                          std::vector<double> (n_q_points));
-    std::vector<std::vector<double>> output_values(n_properties,
-                                                    std::vector<double>(n_q_points));
-
-    MaterialModel::MaterialModelInputs<dim> in(n_q_points,
-                                               this->n_compositional_fields());
-    MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
-                                                 this->n_compositional_fields());
-
-    bool functors_need_material_output = false;
-    for (unsigned int i=0; i<n_properties; ++i)
-      {
-        functors[i]->setup(n_q_points);
-        if (functors[i]->need_material_properties())
-          functors_need_material_output = true;
-
-        functors[i]->create_additional_material_model_outputs(n_q_points,out);
-      }
-
-    for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-
-          if (functors_need_material_output)
-            {
-              // get the material properties at each quadrature point if necessary
-              in.reinit(fe_values,
-                        cell,
-                        this->introspection(),
-                        this->get_solution());
-              this->get_material_model().evaluate(in, out);
-            }
-
-          for (unsigned int i = 0; i < n_properties; ++i)
-            (*functors[i])(in, out, fe_values, this->get_solution(), output_values[i]);
-
-          for (unsigned int q = 0; q < n_q_points; ++q)
-            {
-              const double depth = this->get_geometry_model().depth(fe_values.quadrature_point(q));
-
-              if (depth < depth_bounds.front() || depth > depth_bounds.back())
-                continue;
-
-              // This makes sure depth == front() and depth == back() are handled correctly.
-              // lower_bound returns the first layer boundary larger than depth, the correct
-              // layer index is then one less than this (except for depth == depth_bounds[0],
-              // in which case the depth_bounds index is also the layer_index, namely 0).
-              unsigned int layer_index = std::distance(depth_bounds.begin(),
-                                                       std::lower_bound(depth_bounds.begin(),depth_bounds.end(),depth));
-              if (layer_index > 0)
-                layer_index -= 1;
-
-              Assert(layer_index<n_slices, ExcInternalError());
-
-              for (unsigned int i = 0; i < n_properties; ++i)
-                values[i][layer_index] += output_values[i][q] * fe_values.JxW(q);
-
-              volume[layer_index] += fe_values.JxW(q);
-            }
-        }
-
-    std::vector<double> volume_all(n_slices);
-    Utilities::MPI::sum(volume, this->get_mpi_communicator(), volume_all);
-
-    bool print_under_res_warning=false;
-    for (unsigned int property=0; property<n_properties; ++property)
-      {
-        std::vector<double> values_all(n_slices);
-        Utilities::MPI::sum(values[property], this->get_mpi_communicator(), values_all);
-
-        for (unsigned int i=0; i<n_slices; ++i)
-          {
-            if (volume_all[i] > 0.0)
-              {
-                values[property][i] = values_all[i] / (static_cast<double>(volume_all[i]));
-              }
-            else
-              {
-                print_under_res_warning = true;
-                // Output nan if no quadrature points in depth block
-                values[property][i] = std::numeric_limits<double>::quiet_NaN();
-              }
-          }
-      }
-
-    if (print_under_res_warning)
-      {
-        this->get_pcout() << std::endl
-                          << "**** Warning: When computing depth averages, there is at least one depth band"
-                          << std::endl
-                          << "     that does not have any quadrature points in it."
-                          << std::endl
-                          << "     Consider reducing the number of depth layers for averaging."
-                          << std::endl << std::endl;
-      }
-
-    return values;
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_temperature_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"temperature"))[0];
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_composition_averages(const unsigned int c,
-                                                       std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"C_" + Utilities::int_to_string(c)))[0];
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_viscosity_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"viscosity"))[0];
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_log_viscosity_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"log_viscosity"))[0];
-  }
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_velocity_magnitude_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"velocity_magnitude"))[0];
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_sinking_velocity_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"sinking_velocity"))[0];
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_rising_velocity_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"rising_velocity"))[0];
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_Vs_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"Vs"))[0];
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_Vp_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"Vp"))[0];
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_vertical_heat_flux_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"vertical_heat_flux"))[0];
-  }
-
-
-
-  template <int dim>
-  void LateralAveraging<dim>::get_vertical_mass_flux_averages(std::vector<double> &values) const
-  {
-    values = compute_lateral_averages(values.size(),
-                                      std::vector<std::string>(1,"vertical_mass_flux"))[0];
-  }
-
-
-
-  template <int dim>
-  std::vector<std::vector<double>>
-  LateralAveraging<dim>::get_averages(const unsigned int n_slices,
-                                      const std::vector<std::string> &property_names) const
-  {
-    return compute_lateral_averages(n_slices, property_names);
-  }
-
-
-
-  template <int dim>
-  std::vector<std::vector<double>>
-  LateralAveraging<dim>::compute_lateral_averages(const unsigned int n_slices,
-                                                  const std::vector<std::string> &property_names) const
-  {
-    const double maximal_depth = this->get_geometry_model().maximal_depth();
-    std::vector<double> depth_bounds(n_slices+1, 0.0);
-
-    // Leave index 0 at 0.0, and generate an increasing range of equidistant depth bounds
-    for (unsigned int i=1; i<depth_bounds.size(); ++i)
-      depth_bounds[i] = depth_bounds[i-1] + maximal_depth / n_slices;
-
-    return compute_lateral_averages(depth_bounds, property_names);
-  }
-
-
-
-  template <int dim>
-  std::vector<std::vector<double>>
-  LateralAveraging<dim>::compute_lateral_averages(const std::vector<double> &depth_thresholds,
-                                                  const std::vector<std::string> &property_names) const
-  {
-    std::vector<std::unique_ptr<internal::FunctorBase<dim>>> functors;
-    for (const auto &property_name : property_names)
-      {
-        if (property_name == "temperature")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageField<dim>>
-                               (this->introspection().extractors.temperature));
-          }
-        else if (this->introspection().compositional_name_exists(property_name))
-          {
-            const unsigned int c =
-              this->introspection().compositional_index_for_name(property_name);
-
-            functors.push_back(std::make_unique<FunctorDepthAverageField<dim>> (
-                                 this->introspection().extractors.compositional_fields[c]));
-          }
-        else if (property_name == "velocity_magnitude")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageVelocityMagnitude<dim>>
-                               (this->introspection().extractors.velocities,
-                                this->convert_output_to_years()));
-          }
-        else if (property_name == "sinking_velocity")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageSinkingVelocity<dim>>
-                               (this->introspection().extractors.velocities,
-                                &this->get_gravity_model(),
-                                this->convert_output_to_years()));
-          }
-        else if (property_name == "rising_velocity")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageRisingVelocity<dim>>
-                               (this->introspection().extractors.velocities,
-                                &this->get_gravity_model(),
-                                this->convert_output_to_years()));
-          }
-        else if (property_name == "Vs")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageVsVp<dim>> (true /* Vs */));
-          }
-        else if (property_name == "Vp")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageVsVp<dim>> (false /* Vp */));
-          }
-        else if (property_name == "viscosity")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageViscosity<dim>>());
-          }
-        else if (property_name == "log_viscosity")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageLogViscosity<dim>>());
-          }
-        else if (property_name == "vertical_heat_flux")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageVerticalHeatFlux<dim>>
-                               (this->introspection().extractors.velocities,
-                                this->introspection().extractors.temperature,
-                                &this->get_gravity_model()));
-          }
-        else if (property_name == "vertical_mass_flux")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageVerticalMassFlux<dim>>
-                               (this->introspection().extractors.velocities,
-                                &this->get_gravity_model()));
-          }
-        else if (this->introspection().compositional_name_exists(property_name.substr(0, property_name.size()-5)) &&
-                 property_name.substr(property_name.size()-5) == "_mass")
-          {
-            const unsigned int c =
-              this->introspection().compositional_index_for_name(property_name.substr(0, property_name.size()-5));
-
-            functors.push_back(std::make_unique<FunctorDepthAverageFieldMass<dim>> (
-                                 this->introspection().extractors.compositional_fields[c]));
-          }
-        else if (property_name == "adiabatic_temperature")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageAdiabat<dim>>
-                               (FunctorDepthAverageAdiabat<dim>::temperature,
-                                this->get_adiabatic_conditions()));
-          }
-        else if (property_name == "adiabatic_pressure")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageAdiabat<dim>>
-                               (FunctorDepthAverageAdiabat<dim>::pressure,
-                                this->get_adiabatic_conditions()));
-          }
-        else if (property_name == "adiabatic_density")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageAdiabat<dim>>
-                               (FunctorDepthAverageAdiabat<dim>::density,
-                                this->get_adiabatic_conditions()));
-          }
-        else if (property_name == "adiabatic_density_derivative")
-          {
-            functors.push_back(std::make_unique<FunctorDepthAverageAdiabat<dim>>
-                               (FunctorDepthAverageAdiabat<dim>::density_derivative,
-                                this->get_adiabatic_conditions()));
-          }
-        else
-          {
-            AssertThrow(false,
-                        ExcMessage("The lateral averaging scheme was asked to average the property "
-                                   "named <" + property_name + ">, but it does not know how "
-                                   "to do that. There is no functor implemented that computes this property."));
-          }
-      }
-
-    // Now compute values for all selected properties.
-    return compute_lateral_averages(depth_thresholds, functors);
-  }
-}
-
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template class LateralAveraging<dim>; \
-  namespace internal \
-  { \
-    template class FunctorBase<dim>; \
-  }
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/limiters.cc.bak b/source/simulator/limiters.cc.bak
deleted file mode 100644
index bce8fba5b4a..00000000000
--- a/source/simulator/limiters.cc.bak
+++ /dev/null
@@ -1,876 +0,0 @@
-#include <aspect/simulator.h>
-#include <aspect/volume_of_fluid/handler.h>
-#include <aspect/mesh_deformation/interface.h>
-
-namespace aspect
-{
-  template <int dim>
-  void
-  Simulator<dim>::apply_BP_limiter_to_dg_solutions(const AdvectionField &advection_field)
-  {
-    // TODO: Modify to more robust method
-    // Skip if this composition field is being set from the volume_of_fluid handler
-    if (!advection_field.is_temperature() &&
-        parameters.volume_of_fluid_tracking_enabled)
-      if (volume_of_fluid_handler->field_index_for_name(introspection.name_for_compositional_index(advection_field.compositional_variable))
-          != volume_of_fluid_handler->get_n_fields())
-        return;
-
-    /*
-     * First setup the quadrature points which are used to find the maximum and minimum solution values at those points.
-     * A quadrature formula that combines all quadrature points constructed as all tensor products of
-     * 1) one dimensional Gauss points; 2) one dimensional Gauss-Lobatto points.
-     * We require that the Gauss-Lobatto points (2) appear in only one direction.
-     * Therefore, possible combination
-     * in 2d: the combinations are 21, 12
-     * in 3d: the combinations are 211, 121, 112
-     */
-    const QGauss<1> quadrature_formula_1 (advection_field.polynomial_degree(introspection)+1);
-    const QGaussLobatto<1> quadrature_formula_2 (advection_field.polynomial_degree(introspection)+1);
-
-    const unsigned int n_q_points_1 = quadrature_formula_1.size();
-    const unsigned int n_q_points_2 = quadrature_formula_2.size();
-    const unsigned int n_q_points   = dim * n_q_points_2 * static_cast<unsigned int>(std::pow(n_q_points_1, dim-1));
-
-    std::vector<Point <dim>> quadrature_points;
-    quadrature_points.reserve(n_q_points);
-
-    switch (dim)
-      {
-        case 2:
-        {
-          // append quadrature points combination 12
-          for (unsigned int i=0; i < n_q_points_1 ; ++i)
-            {
-              const double  x = quadrature_formula_1.point(i)(0);
-              for (unsigned int j=0; j < n_q_points_2 ; ++j)
-                {
-                  const double y = quadrature_formula_2.point(j)(0);
-                  quadrature_points.push_back(Point<dim>(x,y));
-                }
-            }
-          // append quadrature points combination 21
-          for (unsigned int i=0; i < n_q_points_2 ; ++i)
-            {
-              const double  x = quadrature_formula_2.point(i)(0);
-              for (unsigned int j=0; j < n_q_points_1 ; ++j)
-                {
-                  const double y = quadrature_formula_1.point(j)(0);
-                  quadrature_points.push_back(Point<dim>(x,y));
-                }
-            }
-          break;
-        }
-
-        case 3:
-        {
-          // append quadrature points combination 121
-          for ( unsigned int i=0; i < n_q_points_1 ; ++i)
-            {
-              const double x = quadrature_formula_1.point(i)(0);
-              for ( unsigned int j=0; j < n_q_points_2 ; ++j)
-                {
-                  const double y = quadrature_formula_2.point(j)(0);
-                  for ( unsigned int k=0; k < n_q_points_1 ; ++k)
-                    {
-                      const double z = quadrature_formula_1.point(k)(0);
-                      quadrature_points.push_back(Point<dim>(x,y,z));
-                    }
-                }
-            }
-          // append quadrature points combination 112
-          for (unsigned int i=0; i < n_q_points_1 ; ++i)
-            {
-              const double x = quadrature_formula_1.point(i)(0);
-              for (unsigned int j=0; j < n_q_points_1 ; ++j)
-                {
-                  const double y = quadrature_formula_1.point(j)(0);
-                  for (unsigned int k=0; k < n_q_points_2 ; ++k)
-                    {
-                      const double z = quadrature_formula_2.point(k)(0);
-                      quadrature_points.push_back(Point<dim>(x,y,z));
-                    }
-                }
-            }
-          // append quadrature points combination 211
-          for (unsigned int i=0; i < n_q_points_2 ; ++i)
-            {
-              const double x = quadrature_formula_2.point(i)(0);
-              for ( unsigned int j=0; j < n_q_points_1 ; ++j)
-                {
-                  const double y = quadrature_formula_1.point(j)(0);
-                  for ( unsigned int k=0; k < n_q_points_1 ; ++k)
-                    {
-                      const double z = quadrature_formula_1.point(k)(0);
-                      quadrature_points.push_back(Point<dim>(x,y,z));
-                    }
-                }
-            }
-          break;
-        }
-
-        default:
-          Assert (false, ExcNotImplemented());
-      }
-
-    Assert (quadrature_points.size() == n_q_points, ExcInternalError());
-    const Quadrature<dim> quadrature_formula(quadrature_points);
-
-    // Quadrature rules only used for the numerical integration for better accuracy
-    const Quadrature<dim> &quadrature_formula_0
-      = (advection_field.is_temperature() ?
-         introspection.quadratures.temperature :
-         introspection.quadratures.compositional_fields);
-    const unsigned int n_q_points_0 = quadrature_formula_0.size();
-
-    // fe values for points evaluation
-    FEValues<dim> fe_values (*mapping,
-                             finite_element,
-                             quadrature_formula,
-                             update_values   |
-                             update_quadrature_points);
-    std::vector<double> values (n_q_points);
-    // fe values for numerical integration, with a number of quadrature points
-    // that is equal to 1/dim times the number of total points above
-    FEValues<dim> fe_values_0 (*mapping,
-                               finite_element,
-                               quadrature_formula_0,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-    std::vector<double> values_0 (n_q_points_0);
-
-    const FEValuesExtractors::Scalar field
-      = (advection_field.is_temperature()
-         ?
-         introspection.extractors.temperature
-         :
-         introspection.extractors.compositional_fields[advection_field.compositional_variable]
-        );
-
-    const double max_solution_exact_global = (advection_field.is_temperature()
-                                              ?
-                                              parameters.global_temperature_max_preset
-                                              :
-                                              parameters.global_composition_max_preset[advection_field.compositional_variable]
-                                             );
-    const double min_solution_exact_global = (advection_field.is_temperature()
-                                              ?
-                                              parameters.global_temperature_min_preset
-                                              :
-                                              parameters.global_composition_min_preset[advection_field.compositional_variable]
-                                             );
-
-    LinearAlgebra::BlockVector distributed_solution (introspection.index_sets.system_partitioning,
-                                                     mpi_communicator);
-    const unsigned int block_idx = advection_field.block_index(introspection);
-    distributed_solution.block(block_idx) = solution.block(block_idx);
-
-    std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          cell->get_dof_indices (local_dof_indices);
-          // used to find the maximum, minimum
-          fe_values.reinit (cell);
-          fe_values[field].get_function_values(solution, values);
-          // used for the numerical integration
-          fe_values_0.reinit (cell);
-          fe_values_0[field].get_function_values(solution, values_0);
-
-          // Find the local max and local min
-          const double min_solution_local = *std::min_element (values.begin(), values.end());
-          const double max_solution_local = *std::max_element (values.begin(), values.end());
-          // Find the trouble cell
-          if (min_solution_local < min_solution_exact_global
-              || max_solution_local > max_solution_exact_global)
-            {
-              // Compute the cell area and cell solution average
-              double local_area = 0.0;
-              double local_solution_average = 0.0;
-              for (unsigned int q = 0; q < n_q_points_0; ++q)
-                {
-                  local_area += fe_values_0.JxW(q);
-                  local_solution_average += values_0[q]*fe_values_0.JxW(q);
-                }
-              local_solution_average /= local_area;
-
-              /*
-               * Define theta: a scaling constant used to correct the old solution by the formula
-               *   new_value = theta * (old_value-old_solution_cell_average)+old_solution_cell_average
-               * where theta \in [0,1] defined as below.
-               * After the correction, the new solution does not exceed the user-given
-               * exact global maximum/minimum values. Meanwhile, the new solution's cell average
-               * equals to the old solution's cell average.
-               */
-              double theta = 1.0;
-              if (std::abs(max_solution_local-local_solution_average) > std::numeric_limits<double>::min())
-                {
-                  theta = std::min(theta, std::abs((max_solution_exact_global-local_solution_average)
-                                                   / (max_solution_local-local_solution_average)));
-                }
-              if (std::abs(min_solution_local-local_solution_average) > std::numeric_limits<double>::min())
-                {
-                  theta = std::min(theta, std::abs((min_solution_exact_global-local_solution_average)
-                                                   / (min_solution_local-local_solution_average)));
-                }
-
-              /* Modify the advection degrees of freedom of the numerical solution.
-               * Note that we are using DG elements, so every DoF on a locally owned cell is locally owned;
-               * this means that we do not need to check whether the 'distributed_solution' vector actually
-               * stores the element we read from/write to here.
-               */
-              for (unsigned int j = 0;
-                   j < finite_element.base_element(advection_field.base_element(introspection)).dofs_per_cell;
-                   ++j)
-                {
-                  const unsigned int support_point_index = finite_element.component_to_system_index(
-                                                             (advection_field.is_temperature()
-                                                              ?
-                                                              introspection.component_indices.temperature
-                                                              :
-                                                              introspection.component_indices.compositional_fields[advection_field.compositional_variable]
-                                                             ),
-                                                             /*dof index within component=*/ j);
-                  const double solution_value = solution(local_dof_indices[support_point_index]);
-                  const double limited_solution_value = theta * (solution_value-local_solution_average) + local_solution_average;
-                  distributed_solution(local_dof_indices[support_point_index]) = limited_solution_value;
-                }
-            }
-        }
-
-    distributed_solution.compress(VectorOperation::insert);
-    // now get back to the original vector
-    solution.block(block_idx) = distributed_solution.block(block_idx);
-  }
-
-
-
-  namespace internal
-  {
-    struct KXRCFCellData
-    {
-      double cell_norm;
-      double inflow_face_jump;
-      double inflow_face_area;
-
-      KXRCFCellData()
-        : cell_norm(0.0)
-        , inflow_face_jump(0.0)
-        , inflow_face_area(0.0)
-      {}
-    };
-  }
-
-
-  template <int dim>
-  template <typename T>
-  void
-  Simulator<dim>::compute_KXRCF_indicators(Vector<T>            &KXRCF_indicators,
-                                           const AdvectionField &advection_field) const
-  {
-    // stuff for computing the integrals in cells and cell faces
-    QGauss<dim>   quadrature(2);
-    QGauss<dim-1> face_quadrature(2);
-
-    FEValues<dim> fe_values(*mapping,
-                            finite_element,
-                            quadrature,
-                            update_values);
-
-    FEFaceValues<dim> fe_face_values(*mapping,
-                                     finite_element,
-                                     face_quadrature,
-                                     update_values |
-                                     update_normal_vectors |
-                                     update_JxW_values);
-
-    FESubfaceValues<dim> fe_subface_values(*mapping,
-                                           finite_element,
-                                           face_quadrature,
-                                           update_values |
-                                           update_normal_vectors |
-                                           update_JxW_values);
-
-    FEFaceValues<dim> neighbor_fe_face_values(*mapping,
-                                              finite_element,
-                                              face_quadrature,
-                                              update_values |
-                                              update_JxW_values);
-
-    const FEValuesExtractors::Scalar &field_extractor = advection_field.scalar_extractor(introspection);
-
-    const unsigned int n_q_points      = fe_values.n_quadrature_points;
-    const unsigned int n_face_q_points = fe_face_values.n_quadrature_points;
-
-    std::vector<double> field_values(n_q_points);
-    std::vector<double> face_field_values(n_face_q_points);
-    std::vector<double> neighbor_face_field_values(n_face_q_points);
-
-    std::vector<Tensor<1,dim>> face_velocity_values(n_face_q_points);
-    std::vector<Tensor<1,dim>> face_mesh_velocity_values(n_face_q_points);
-
-    // KXRCF indicator requires the computation of (1) cell maximum norm;
-    // (2) integration of the jump over inflow faces of each field. To
-    // avoid doing integration twice on each cell face, we set up a map
-    // to store the cell data and then loop over the cells using the same
-    // strategy as in Assemblers::AdvectionSystemInteriorFace::execute().
-    std::map<unsigned int, internal::KXRCFCellData> data;
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        data.insert(std::make_pair(cell->active_cell_index(),
-                                   internal::KXRCFCellData()));
-
-    // Now loop over locally owned cells and compute the maximum norm
-    // and the jump over inflow faces.
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          auto cell_data = data.find(cell->active_cell_index());
-
-          // Compute the maximum norm of field values in this cell.
-          fe_values.reinit(cell);
-          fe_values[field_extractor].get_function_values(solution, field_values);
-
-          double cell_norm = 0.0;
-          for (unsigned int q = 0; q < n_q_points; ++q)
-            cell_norm = std::max(cell_norm, std::abs(field_values[q]));
-
-          cell_data->second.cell_norm = cell_norm;
-
-          // Compute the jump of field values over inflow faces.
-          for (const unsigned int face_no : cell->face_indices())
-            {
-              if (!cell->at_boundary(face_no) || cell->has_periodic_neighbor(face_no))
-                {
-                  const typename DoFHandler<dim>::cell_iterator
-                  neighbor = cell->neighbor_or_periodic_neighbor(face_no);
-
-                  const bool cell_has_periodic_neighbor = cell->has_periodic_neighbor(face_no);
-
-                  // 'neighbor' defined above is NOT active_cell_iterator, this includes cells
-                  // that are refined
-                  if (!neighbor->has_children())
-                    {
-                      if (neighbor->level() == cell->level() &&
-                          neighbor->is_active() &&
-                          (((neighbor->is_locally_owned()) && (cell->index() < neighbor->index()))
-                           ||
-                           ((!neighbor->is_locally_owned()) && (cell->subdomain_id() < neighbor->subdomain_id()))))
-                        {
-                          // cell and neighbor are equal-sized, and cell has been chosen to
-                          // assemble this face, so calculate from cell
-                          const unsigned int neighbor2 =
-                            (cell_has_periodic_neighbor
-                             ?
-                             cell->periodic_neighbor_of_periodic_neighbor(face_no)
-                             :
-                             cell->neighbor_of_neighbor(face_no));
-
-                          auto neighbor_data = data.find(neighbor->active_cell_index());
-
-                          // Set up face values.
-                          fe_face_values.reinit(cell, face_no);
-                          fe_face_values[field_extractor].get_function_values(solution, face_field_values);
-
-                          fe_face_values[introspection.extractors.velocities].get_function_values(
-                            solution, face_velocity_values);
-                          if (parameters.mesh_deformation_enabled)
-                            fe_face_values[introspection.extractors.velocities].get_function_values(
-                              mesh_deformation->mesh_velocity, face_mesh_velocity_values);
-
-                          // Set up neighbor face values.
-                          neighbor_fe_face_values.reinit(neighbor, neighbor2);
-                          neighbor_fe_face_values[field_extractor].get_function_values(solution, neighbor_face_field_values);
-
-                          const double face_area = cell->face(face_no)->measure();
-
-                          double v_n = 0.0;
-                          double face_jump = 0.0;
-                          for (unsigned int q = 0; q < n_face_q_points; ++q)
-                            {
-                              Tensor<1,dim> current_u = face_velocity_values[q];
-                              if (parameters.mesh_deformation_enabled)
-                                current_u -= face_mesh_velocity_values[q];
-
-                              v_n += (current_u * fe_face_values.normal_vector(q)) * fe_face_values.JxW(q);
-
-                              face_jump += (face_field_values[q] - neighbor_face_field_values[q]) * fe_face_values.JxW(q);
-                            }
-
-                          if (v_n < 0.0) // inflow
-                            {
-                              cell_data->second.inflow_face_jump += face_jump;
-                              cell_data->second.inflow_face_area += face_area;
-                            }
-                          else // outflow
-                            {
-                              if (neighbor_data != data.end())
-                                {
-                                  neighbor_data->second.inflow_face_jump -= face_jump;
-                                  neighbor_data->second.inflow_face_area += face_area;
-                                }
-                            }
-
-                        }
-                      else
-                        {
-                          // Neighbor is taking responsibility for assembly of this face, because
-                          // either (1) neighbor is coarser, or
-                          //        (2) neighbor is equally-sized and
-                          //           (a) neighbor is on a different subdomain, with lower subdomain_id(), or
-                          //           (b) neighbor is on the same subdomain and has lower index().
-                        }
-                    }
-                  else
-                    {
-                      // Neighbor has children, so always assemble from here.
-                      const unsigned int neighbor2 =
-                        (cell_has_periodic_neighbor
-                         ?
-                         cell->periodic_neighbor_face_no(face_no)
-                         :
-                         cell->neighbor_face_no(face_no));
-
-                      // Loop over subfaces. We know that the neighbor is finer, so we could loop over the subfaces of the current
-                      // face. but if we are at a periodic boundary, then the face of the current cell has no children, so instead use
-                      // the children of the periodic neighbor's corresponding face since we know that the letter does indeed have
-                      // children (because we know that the neighbor is refined).
-                      typename DoFHandler<dim>::face_iterator neighbor_face = neighbor->face(neighbor2);
-                      for (unsigned int subface_no = 0; subface_no < neighbor_face->n_children(); ++subface_no)
-                        {
-                          const typename DoFHandler<dim>::active_cell_iterator neighbor_child =
-                            (cell_has_periodic_neighbor
-                             ?
-                             cell->periodic_neighbor_child_on_subface(face_no, subface_no)
-                             :
-                             cell->neighbor_child_on_subface(face_no, subface_no));
-
-                          auto neighbor_data = data.find(neighbor_child->active_cell_index());
-
-                          // Set up subface values.
-                          fe_subface_values.reinit(cell, face_no, subface_no);
-                          fe_subface_values[field_extractor].get_function_values(solution, face_field_values);
-
-                          fe_subface_values[introspection.extractors.velocities].get_function_values(
-                            solution, face_velocity_values);
-                          if (parameters.mesh_deformation_enabled)
-                            fe_subface_values[introspection.extractors.velocities].get_function_values(
-                              mesh_deformation->mesh_velocity, face_mesh_velocity_values);
-
-                          neighbor_fe_face_values.reinit(neighbor_child, neighbor2);
-                          neighbor_fe_face_values[field_extractor].get_function_values(solution, neighbor_face_field_values);
-
-                          const double face_area = neighbor_child->face(neighbor2)->measure();
-
-                          double v_n = 0.0;
-                          double face_jump = 0.0;
-                          for (unsigned int q = 0; q < n_face_q_points; ++q)
-                            {
-                              Tensor<1,dim> current_u = face_velocity_values[q];
-                              if (parameters.mesh_deformation_enabled)
-                                current_u -= face_mesh_velocity_values[q];
-
-                              v_n += (current_u * fe_subface_values.normal_vector(q)) * fe_subface_values.JxW(q);
-
-                              face_jump += (face_field_values[q] - neighbor_face_field_values[q]) * fe_subface_values.JxW(q);
-                            }
-
-                          if (v_n < 0.0) // inflow
-                            {
-                              cell_data->second.inflow_face_jump += face_jump;
-                              cell_data->second.inflow_face_area += face_area;
-                            }
-                          else // outflow
-                            {
-                              if (neighbor_data != data.end())
-                                {
-                                  neighbor_data->second.inflow_face_jump -= face_jump;
-                                  neighbor_data->second.inflow_face_area += face_area;
-                                }
-                            }
-                        }
-                    }
-                }
-              else
-                {
-                  // The current face is a boundary face.
-                }
-            }
-        }
-
-    // Finally, compute the KXRCF indicator and pick the largest one as
-    // troubled cell indicator.
-    const unsigned int degree = advection_field.polynomial_degree(introspection);
-    const double power = (degree + 1.0) / 2.0;
-    const double scaling_factor = 1. / global_Omega_diameter;
-
-    const unsigned int block_idx = advection_field.block_index(introspection);
-    const double epsilon = std::max(1e-20,
-                                    1e-3 * (solution.block(block_idx).max() - solution.block(block_idx).min()));
-
-    KXRCF_indicators.reinit(triangulation.n_active_cells());
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          // The characteristic mesh spacing is calculated by d/D, where
-          // d and D are the diameters of the present cell and the geometry
-          // model, respectively.
-          const double h_pow = std::pow(cell->diameter() * scaling_factor, power);
-          const auto cell_data = data.find(cell->active_cell_index());
-          if (cell_data->second.inflow_face_area == 0.0)
-            KXRCF_indicators[cell->active_cell_index()] = 0.0;
-          else
-            KXRCF_indicators[cell->active_cell_index()] =
-              std::abs(cell_data->second.inflow_face_jump) /
-              (h_pow * cell_data->second.inflow_face_area * (cell_data->second.cell_norm + epsilon));
-        }
-  }
-
-
-  template <int dim>
-  void
-  Simulator<dim>::apply_WENO_limiter_to_dg_solutions(const AdvectionField &advection_field)
-  {
-    // Skip if this composition field is being set from the volume_of_fluid handler
-    if (!advection_field.is_temperature() &&
-        parameters.volume_of_fluid_tracking_enabled)
-      if (volume_of_fluid_handler->field_index_for_name(introspection.name_for_compositional_index(advection_field.compositional_variable))
-          != volume_of_fluid_handler->get_n_fields())
-        return;
-
-    const unsigned int degree = advection_field.polynomial_degree(introspection);
-    AssertThrow(degree < 3,
-                ExcMessage("Currently, WENO limiter has only been implemented for "
-                           "advection fields with polynomial degree 1 or 2."));
-
-    // We need two objects of FEValues in the following computation:
-    // fe_values: computes the cell average and smoothness indicator of the target cell,
-    //   and provides the coordinates and JxWs of the quadrature points of the target
-    //   cell when computing the smoothness indicators of neighbor cells;
-    // neighbor_fe_values: computes the cell averages and field derivatives of
-    //   neighbor cells at quadrature points of the target cell. With the derivatives
-    //   at hand, we can use the JxWs provided by fe_values to compute the smoothness
-    //   indicators of neighbor cells.
-    // The coordinates of quadrature points of neighbor_fe_values change from cell to
-    // cell since the mesh may not be Cartesian, hence neighbor_fe_values has to be
-    // reconstructed in each cell.
-    Quadrature<dim> quadrature(advection_field.is_temperature() ?
-                               introspection.quadratures.temperature :
-                               introspection.quadratures.compositional_fields);
-
-    UpdateFlags update_flags = update_values | update_gradients |
-                               update_quadrature_points | update_JxW_values |
-                               (degree > 1 ? update_hessians : update_default);
-
-    UpdateFlags neighbor_update_flags = update_values | update_gradients |
-                                        (degree > 1 ? update_hessians : update_default);
-
-    FEValues<dim> fe_values(*mapping, finite_element, quadrature, update_flags);
-
-    const unsigned int n_q_points          = fe_values.n_quadrature_points;
-    const unsigned int field_dofs_per_cell = finite_element.base_element(advection_field.base_element(introspection)).dofs_per_cell;
-    const unsigned int field_component     = advection_field.component_index(introspection);
-
-    const FEValuesExtractors::Scalar &field_extractor = advection_field.scalar_extractor(introspection);
-
-    std::vector<double>        field_values(n_q_points);
-    std::vector<Tensor<1,dim>> field_gradients(n_q_points);
-    std::vector<Tensor<2,dim>> field_hessians(n_q_points);
-
-    std::vector<Point<dim>> neighbor_quadrature_points(n_q_points);
-
-    std::vector<double> reconstructed_values(n_q_points);
-
-    std::vector<double> cell_averages;
-    std::vector<double> smoothness_indicators;
-    std::vector<double> linear_weights;
-    std::vector<double> nonlinear_weights;
-    std::vector<std::vector<double>> field_values_in_target_cell;
-
-    // stuff for projecting the reconstructed polynomial onto grid nodes
-    FullMatrix<double> cell_matrix(field_dofs_per_cell, field_dofs_per_cell);
-    Vector<double> cell_rhs(field_dofs_per_cell);
-    Vector<double> cell_solution(field_dofs_per_cell);
-    std::vector<double> phi_field(field_dofs_per_cell);
-    std::vector<types::global_dof_index> cell_dof_indices(finite_element.dofs_per_cell);
-
-    // Detect troubled cells with KXRCF indicator.
-    Vector<double> KXRCF_indicators;
-    compute_KXRCF_indicators(KXRCF_indicators, advection_field);
-
-    TrilinosWrappers::MPI::BlockVector distributed_solution(introspection.index_sets.system_partitioning,
-                                                            mpi_communicator);
-
-    const unsigned int block_idx = advection_field.block_index(introspection);
-    distributed_solution.block(block_idx) = solution.block(block_idx);
-
-    const double KXRCF_indicator_threshold = (advection_field.is_temperature() ?
-                                              parameters.temperature_KXRCF_indicator_threshold :
-                                              parameters.composition_KXRCF_indicator_threshold[advection_field.compositional_variable]);
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          // If the KXRCF indicator of the present cell is lower than the threshold,
-          // then we do not have to do WENO reconstruction for the cell.
-          if (KXRCF_indicators[cell->active_cell_index()] < KXRCF_indicator_threshold)
-            continue;
-
-          cell_averages.clear();
-          smoothness_indicators.clear();
-          field_values_in_target_cell.clear();
-          linear_weights.clear();
-
-          // Compute the field values and derivatives at quadrature points.
-          fe_values.reinit(cell);
-          fe_values[field_extractor].get_function_values(solution, field_values);
-          fe_values[field_extractor].get_function_gradients(solution, field_gradients);
-          if (degree > 1)
-            fe_values[field_extractor].get_function_hessians(solution, field_hessians);
-
-          // Compute the cell average and the smoothness indicator.
-          double cell_measure                   = 0.0;
-          double field_integral                 = 0.0;
-          double field_gradient_square_integral = 0.0;
-          double field_hessian_square_integral  = 0.0;
-          for (unsigned int q = 0; q < n_q_points; ++q)
-            {
-              cell_measure += fe_values.JxW(q);
-              field_integral += field_values[q] * fe_values.JxW(q);
-
-              field_gradient_square_integral += field_gradients[q].norm_square() * fe_values.JxW(q);
-              if (degree > 1)
-                field_hessian_square_integral += field_hessians[q].norm_square() * fe_values.JxW(q);
-            }
-
-          double beta = field_gradient_square_integral;
-          if (degree > 1)
-            beta += field_hessian_square_integral * cell_measure;
-
-          cell_averages.push_back(field_integral / cell_measure);
-          smoothness_indicators.push_back(beta);
-          field_values_in_target_cell.push_back(field_values);
-          // Linear weight of the target cell cannot be determined at present time
-          // (because we don't know how many neighbors the target cell has). Fill in
-          // the position with an invalid value.
-          linear_weights.push_back(numbers::signaling_nan<double>());
-
-          // Loop over the neighbor cells.
-          for (const unsigned int face_no : cell->face_indices())
-            {
-              if (cell->face(face_no)->at_boundary())
-                continue;
-
-              const typename DoFHandler<dim>::cell_iterator
-              neighbor = cell->neighbor_or_periodic_neighbor(face_no);
-
-              // 'neighbor' defined above is NOT active_cell_iterator, this includes cells
-              // that are refined
-              if (!neighbor->has_children())
-                {
-                  // Compute the field values at quadrature points of the neighbor.
-
-                  // Compute the field derivatives at quadrature points of the target cell.
-                  // To do so, we need to transform the quadrature points of the target cell
-                  // to the 'unit cell' defined by the neighbor.
-                  mapping->transform_points_real_to_unit_cell(neighbor,
-                                                              fe_values.get_quadrature_points(),
-                                                              neighbor_quadrature_points);
-
-                  Quadrature<dim> neighbor_quadrature(neighbor_quadrature_points,
-                                                      quadrature.get_weights());
-
-                  FEValues<dim> neighbor_fe_values(*mapping,
-                                                   finite_element,
-                                                   neighbor_quadrature,
-                                                   neighbor_update_flags);
-
-                  neighbor_fe_values.reinit(neighbor);
-                  neighbor_fe_values[field_extractor].get_function_values(solution, field_values);
-                  neighbor_fe_values[field_extractor].get_function_gradients(solution, field_gradients);
-                  if (degree > 1)
-                    neighbor_fe_values[field_extractor].get_function_hessians(solution, field_hessians);
-
-                  // Compute the cell average and the smoothness indicator.
-                  double field_integral                 = 0.0;
-                  double field_gradient_square_integral = 0.0;
-                  double field_hessian_square_integral  = 0.0;
-                  for (unsigned int q = 0; q < n_q_points; ++q)
-                    {
-                      field_integral += field_values[q] * fe_values.JxW(q);
-                      field_gradient_square_integral += field_gradients[q].norm_square() * fe_values.JxW(q);
-                      if (degree > 1)
-                        field_hessian_square_integral += field_hessians[q].norm_square() * fe_values.JxW(q);
-                    }
-
-                  double beta = field_gradient_square_integral;
-                  if (degree > 1)
-                    beta += field_hessian_square_integral * cell_measure;
-
-                  cell_averages.push_back(field_integral / cell_measure);
-                  smoothness_indicators.push_back(beta);
-                  field_values_in_target_cell.push_back(field_values);
-                  linear_weights.push_back(parameters.WENO_linear_weight);
-                }
-              else
-                {
-                  // Neighbor has children. We use a half of the children that are adjacent to
-                  // the target cell (i.e., children that share a face with the target cell) to
-                  // compute the cell average and smoothness indicator.
-                  const unsigned int neighbor_face_no =
-                    (cell->has_periodic_neighbor(face_no)
-                     ?
-                     cell->periodic_neighbor_face_no(face_no)
-                     :
-                     cell->neighbor_face_no(face_no));
-
-                  typename DoFHandler<dim>::face_iterator neighbor_face = neighbor->face(neighbor_face_no);
-                  for (unsigned int subface_no = 0; subface_no < neighbor_face->n_children(); ++subface_no)
-                    {
-                      const unsigned int child_no =
-                        GeometryInfo<dim>::child_cell_on_face(RefinementCase<dim>::isotropic_refinement,
-                                                              neighbor_face_no,
-                                                              subface_no,
-                                                              neighbor->face_orientation(face_no),
-                                                              neighbor->face_flip(face_no),
-                                                              neighbor->face_rotation(face_no));
-
-                      typename DoFHandler<dim>::active_cell_iterator
-                      neighbor_child = neighbor->child(child_no);
-
-                      // Compute the field derivatives at quadrature points of the target cell.
-                      // To do so, we need to transform the quadrature points of the target cell
-                      // to the 'unit cell' defined by the neighbor.
-                      mapping->transform_points_real_to_unit_cell(neighbor_child,
-                                                                  fe_values.get_quadrature_points(),
-                                                                  neighbor_quadrature_points);
-
-                      Quadrature<dim> neighbor_quadrature(neighbor_quadrature_points,
-                                                          quadrature.get_weights());
-
-                      FEValues<dim> neighbor_fe_values(*mapping,
-                                                       finite_element,
-                                                       neighbor_quadrature,
-                                                       neighbor_update_flags);
-
-                      neighbor_fe_values.reinit(neighbor_child);
-                      neighbor_fe_values[field_extractor].get_function_values(solution, field_values);
-                      neighbor_fe_values[field_extractor].get_function_gradients(solution, field_gradients);
-                      if (degree > 1)
-                        neighbor_fe_values[field_extractor].get_function_hessians(solution, field_hessians);
-
-                      // Compute the cell average and the smoothness indicator.
-                      double field_integral                 = 0.0;
-                      double field_gradient_square_integral = 0.0;
-                      double field_hessian_square_integral  = 0.0;
-                      for (unsigned int q = 0; q < n_q_points; ++q)
-                        {
-                          field_integral += field_values[q] * fe_values.JxW(q);
-                          field_gradient_square_integral += field_gradients[q].norm_square() * fe_values.JxW(q);
-                          if (degree > 1)
-                            field_hessian_square_integral += field_hessians[q].norm_square() * fe_values.JxW(q);
-                        }
-
-                      double beta = field_gradient_square_integral;
-                      if (degree > 1)
-                        beta += field_hessian_square_integral * cell_measure;
-
-                      cell_averages.push_back(field_integral / cell_measure);
-                      smoothness_indicators.push_back(beta);
-                      field_values_in_target_cell.push_back(field_values);
-                      linear_weights.push_back(parameters.WENO_linear_weight / neighbor_face->n_children());
-                    }
-                }
-            }
-
-          // Compute the linear weights of the target cell.
-          linear_weights[0] = 1.0;
-          for (unsigned int i = 1; i < linear_weights.size(); ++i)
-            linear_weights[0] -= linear_weights[i];
-
-          // Compute the nonlinear weights.
-          const double epsilon = 1e-6 * std::accumulate(smoothness_indicators.begin(),
-                                                        smoothness_indicators.end(),
-                                                        0.0);
-          nonlinear_weights.clear();
-          for (unsigned int i = 0; i < linear_weights.size(); ++i)
-            nonlinear_weights.push_back(linear_weights[i] /
-                                        Utilities::fixed_power<2,double>(smoothness_indicators[i] + epsilon));
-
-          // Normalize the nonlinear weights.
-          const double sum = std::accumulate(nonlinear_weights.begin(),
-                                             nonlinear_weights.end(),
-                                             0.0);
-
-          for (unsigned int i = 0; i < nonlinear_weights.size(); ++i)
-            nonlinear_weights[i] /= sum;
-
-          // Compute the values of the reconstructed polynomial at quadrature points.
-          std::fill(reconstructed_values.begin(), reconstructed_values.end(), 0.0);
-          for (unsigned int q = 0; q < n_q_points; ++q)
-            for (unsigned int i = 0; i < nonlinear_weights.size(); ++i)
-              reconstructed_values[q] += (field_values_in_target_cell[i][q] - cell_averages[i] + cell_averages[0]) * nonlinear_weights[i];
-
-          // Project the reconstructed polynomial onto grid nodes.
-          cell_matrix = 0;
-          cell_rhs = 0;
-          for (unsigned int q = 0; q < n_q_points; ++q)
-            {
-              for (unsigned int i = 0, i_field = 0; i_field < field_dofs_per_cell; /*increment at end of loop*/)
-                {
-                  if (finite_element.system_to_component_index(i).first == field_component)
-                    {
-                      phi_field[i_field] = fe_values[field_extractor].value(i, q);
-                      ++i_field;
-                    }
-                  ++i;
-                }
-
-              for (unsigned int i = 0; i < field_dofs_per_cell; ++i)
-                {
-                  cell_rhs(i) += phi_field[i] * reconstructed_values[q] * fe_values.JxW(q);
-
-                  for (unsigned int j = 0; j < field_dofs_per_cell; ++j)
-                    cell_matrix(i, j) += phi_field[i] * phi_field[j] * fe_values.JxW(q);
-                }
-            }
-
-          cell_matrix.gauss_jordan();
-          cell_matrix.vmult(cell_solution, cell_rhs);
-
-          // Copy the results to the distributed solution vector.
-          cell->get_dof_indices(cell_dof_indices);
-          for (unsigned int i = 0, i_field = 0; i_field < field_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (finite_element.system_to_component_index(i).first == field_component)
-                {
-                  distributed_solution[cell_dof_indices[i]] = cell_solution(i_field);
-                  ++i_field;
-                }
-              ++i;
-            }
-        }
-
-    // Update the solution vector.
-    distributed_solution.compress(VectorOperation::insert);
-    solution.block(block_idx) = distributed_solution.block(block_idx);
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-
-#define INSTANTIATE(dim) \
-  template void Simulator<dim>::apply_BP_limiter_to_dg_solutions(const AdvectionField &advection_field); \
-  template void Simulator<dim>::compute_KXRCF_indicators(Vector<double> &, \
-                                                         const AdvectionField &) const; \
-  template void Simulator<dim>::compute_KXRCF_indicators(Vector<float> &, \
-                                                         const AdvectionField &) const; \
-  template void Simulator<dim>::apply_WENO_limiter_to_dg_solutions(const AdvectionField &advection_field);
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/melt.cc.bak b/source/simulator/melt.cc.bak
deleted file mode 100644
index eef4deeb9c7..00000000000
--- a/source/simulator/melt.cc.bak
+++ /dev/null
@@ -1,1960 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-#include <aspect/citation_info.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/simulator/assemblers/advection.h>
-#include <deal.II/base/signaling_nan.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/lac/sparsity_tools.h>
-
-#include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/fe_dgp.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/work_stream.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/filtered_iterator.h>
-#include <deal.II/grid/grid_tools.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    MeltInputs<dim>::MeltInputs (const unsigned int n_points)
-      :
-      compaction_pressures(n_points, numbers::signaling_nan<double>()),
-      fluid_velocities(n_points, numbers::signaling_nan<Tensor<1,dim>>())
-    {}
-
-
-
-    template <int dim>
-    void MeltInputs<dim>::fill (const LinearAlgebra::BlockVector &solution,
-                                const FEValuesBase<dim>          &fe_values,
-                                const Introspection<dim>         &introspection)
-    {
-      compaction_pressures.resize(fe_values.n_quadrature_points);
-      fluid_velocities.resize(fe_values.n_quadrature_points, Tensor<1,dim>());
-
-      const FEValuesExtractors::Vector ex_u_f = introspection.variable("fluid velocity").extractor_vector();
-      fe_values[ex_u_f].get_function_values (solution, fluid_velocities);
-
-      const FEValuesExtractors::Scalar ex_p_c = introspection.variable("compaction pressure").extractor_scalar();
-      fe_values[ex_p_c].get_function_values (solution, compaction_pressures);
-    }
-
-
-
-    template <int dim>
-    void MeltOutputs<dim>::average (const MaterialAveraging::AveragingOperation operation,
-                                    const FullMatrix<double>  &projection_matrix,
-                                    const FullMatrix<double>  &expansion_matrix)
-    {
-      average_property (operation, projection_matrix, expansion_matrix,
-                        compaction_viscosities);
-      average_property (operation, projection_matrix, expansion_matrix,
-                        fluid_viscosities);
-      average_property (operation, projection_matrix, expansion_matrix,
-                        permeabilities);
-      average_property (operation, projection_matrix, expansion_matrix,
-                        fluid_densities);
-
-      // The fluid density gradients are unfortunately stored in reverse
-      // indexing and averaging is not implemented for tensors (only for
-      // doubles). It's also not quite clear whether these should
-      // really be averaged, so avoid this for now
-    }
-
-
-
-    template <int dim>
-    double
-    MeltInterface<dim>::p_c_scale (const MaterialModel::MaterialModelInputs<dim> &inputs,
-                                   const MaterialModel::MaterialModelOutputs<dim> &outputs,
-                                   const MeltHandler<dim> &melt_handler,
-                                   const bool consider_is_melt_cell) const
-    {
-      Assert(inputs.current_cell.state() == IteratorState::valid,
-             ExcMessage("You are trying to access the property of a cell (if it is "
-                        "a melt cell or not), but the cell iterator in the provided material "
-                        "model inputs does not point to a cell."));
-
-      if (consider_is_melt_cell && !melt_handler.is_melt_cell(inputs.current_cell))
-        return 0.0;
-
-      const MaterialModel::MeltOutputs<dim> *melt_outputs = outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-      const double ref_K_D = this->reference_darcy_coefficient();
-
-      double K_D = 0.0;
-      double max_K_D = 0.0;
-      const unsigned int N = melt_outputs->permeabilities.size();
-      for (unsigned int q=0; q<N; ++q)
-        {
-          K_D += std::max(melt_outputs->permeabilities[q], 0.0) / (melt_outputs->fluid_viscosities[q] * N);
-          max_K_D = std::max(max_K_D, melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q]);
-        }
-
-      // For melt cells, we return the average Darcy coefficient of the cell,
-      // but always a value larger than a threshold depending on the reference Darcy coefficient,
-      // so that K_D can never be zero (or close to zero) in melt cells.
-      // The same threshold is used when computing which cells are melt cells (the else branch),
-      // with the difference that we return a p_c_scale of zero to indicate that the cell is not
-      // a melt cell if the maximum Darcy coefficient of the cell is below the threshold.
-      const double K_D_threshold = melt_handler.melt_parameters.melt_scaling_factor_threshold;
-      if (consider_is_melt_cell)
-        K_D = std::max(K_D, K_D_threshold * ref_K_D);
-      else
-        K_D = (max_K_D < K_D_threshold * ref_K_D) ? 0.0 : K_D;
-
-      // If the reference permeability is set to zero, there is no melt transport in the whole model and we return zero.
-      return (ref_K_D > 0 ? std::sqrt(K_D / ref_K_D) : 0.0);
-    }
-  }
-
-
-
-  namespace Assemblers
-  {
-    namespace
-    {
-      template <int dim>
-      bool
-      is_velocity_or_pressures (const Introspection<dim> &introspection,
-                                const unsigned int p_c_component_index,
-                                const unsigned int p_f_component_index,
-                                const unsigned int component_index)
-      {
-        if (component_index == p_c_component_index)
-          return true;
-
-        if (component_index == p_f_component_index)
-          return true;
-
-        for (unsigned int i=0; i<dim; ++i)
-          if (component_index == introspection.component_indices.velocities[i])
-            return true;
-
-        return false;
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    MeltInterface<dim>::create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      MeltHandler<dim>::create_material_model_outputs(outputs);
-
-      if (this->get_parameters().enable_additional_stokes_rhs
-          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>(outputs.n_evaluation_points()));
-        }
-
-      Assert(!this->get_parameters().enable_additional_stokes_rhs
-             ||
-             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
-             == outputs.n_evaluation_points(), ExcInternalError());
-    }
-
-
-
-    template <int dim>
-    void
-    MeltStokesPreconditioner<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int   stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int   n_q_points      = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      Assert(Plugins::plugin_type_matches<const MaterialModel::MeltInterface<dim>>(this->get_material_model()),
-             ExcMessage("Error: The current material model needs to be derived from MeltInterface to use melt transport."));
-
-      const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(
-                                 this->get_material_model()).p_c_scale(scratch.material_model_inputs,
-                                                                       scratch.material_model_outputs,
-                                                                       this->get_melt_handler(),
-                                                                       true);
-
-      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-
-      const FEValuesExtractors::Scalar ex_p_f = introspection.variable("fluid pressure").extractor_scalar();
-      const FEValuesExtractors::Scalar ex_p_c = introspection.variable("compaction pressure").extractor_scalar();
-
-      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
-      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
-
-      for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-        {
-          const unsigned int component_index_i = fe.system_to_component_index(i).first;
-
-          if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
-            {
-              data.local_dof_indices[i_stokes] = scratch.local_dof_indices[i];
-              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
-              ++i_stokes;
-            }
-          ++i;
-        }
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              const unsigned int component_index_i = fe.system_to_component_index(i).first;
-
-              if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
-                {
-                  scratch.phi_p[i_stokes]       = scratch.finite_element_values[ex_p_f].value (i, q);
-                  scratch.phi_p_c[i_stokes]     = scratch.finite_element_values[ex_p_c].value (i, q);
-                  scratch.grad_phi_p[i_stokes]  = scratch.finite_element_values[ex_p_f].gradient (i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const double eta = scratch.material_model_outputs.viscosities[q];
-          const double one_over_eta = 1. / eta;
-          const double K_D = this->get_melt_handler().limited_darcy_coefficient(melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q],
-                                                                                p_c_scale > 0);
-
-          /*
-            - R = 1/eta M_p + K_D L_p for p
-            S = - (1/eta + 1/viscosity_c)  M_p  for p_c
-          */
-          const double viscosity_c = melt_outputs->compaction_viscosities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-              {
-                if (scratch.dof_component_indices[i] == scratch.dof_component_indices[j])
-                  data.local_matrix(i,j) += ((one_over_eta *
-                                              pressure_scaling *
-                                              pressure_scaling)
-                                             * scratch.phi_p[i] * scratch.phi_p[j]
-                                             +
-                                             (K_D *
-                                              pressure_scaling *
-                                              pressure_scaling) *
-                                             scratch.grad_phi_p[i] *
-                                             scratch.grad_phi_p[j]
-                                             +
-                                             (1./eta + 1./viscosity_c) * p_c_scale * p_c_scale *
-                                             pressure_scaling *
-                                             pressure_scaling *
-                                             (scratch.phi_p_c[i] * scratch.phi_p_c[j])
-                                            )
-                                            * JxW;
-
-                // add S between p_c and p_f
-                data.local_matrix(i,j) +=
-                  (
-                    (p_c_scale * one_over_eta *
-                     pressure_scaling *
-                     pressure_scaling)
-                    * scratch.phi_p[i] * scratch.phi_p_c[j]
-                    +
-                    (p_c_scale * one_over_eta *
-                     pressure_scaling *
-                     pressure_scaling)
-                    * scratch.phi_p_c[i] * scratch.phi_p[j]
-                  )
-                  * JxW;
-              }
-        }
-    }
-
-    namespace
-    {
-      /**
-       * Compute the right-hand side of the fluid pressure equation of the Stokes
-       * system in case the simulation uses melt transport. This includes a term
-       * derived from Darcy's law, a term including the melting rate and a term dependent
-       * on the densities and velocities of fluid and solid.
-       */
-      template <int dim>
-      double
-      compute_fluid_pressure_rhs(const SimulatorAccess<dim> *simulator_access,
-                                 const internal::Assembly::Scratch::StokesSystem<dim> &scratch,
-                                 const unsigned int q_point,
-                                 const double K_D,
-                                 const double operator_split_reaction)
-      {
-        if (!simulator_access->get_parameters().include_melt_transport)
-          return 0.0;
-
-        const Introspection<dim> &introspection = simulator_access->introspection();
-        const MaterialModel::MeltOutputs<dim> *melt_out = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-
-        Assert(melt_out != nullptr, ExcInternalError());
-
-        const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
-        const unsigned int is_compressible = simulator_access->get_material_model().is_compressible();
-
-        const double solid_density    = scratch.material_model_outputs.densities[q_point];
-        const double fluid_density    = melt_out->fluid_densities[q_point];
-        double melting_rate           = scratch.material_model_outputs.reaction_terms[q_point][porosity_index];
-
-        if (simulator_access->get_parameters().use_operator_splitting)
-          melting_rate = (simulator_access->get_timestep() > 0
-                          ?
-                          operator_split_reaction * solid_density / simulator_access->get_timestep()
-                          :
-                          0.0);
-
-        const double solid_compressibility = scratch.material_model_outputs.compressibilities[q_point];
-        const Tensor<1,dim> fluid_density_gradient = melt_out->fluid_density_gradients[q_point];
-        const Tensor<1,dim> current_u = scratch.velocity_values[q_point];
-        const double porosity         = std::max(scratch.material_model_inputs.composition[q_point][porosity_index],0.0);
-
-        const Tensor<1,dim>
-        gravity = simulator_access->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q_point));
-
-        double fluid_pressure_RHS = 0.0;
-
-        // melting term
-        fluid_pressure_RHS -= melting_rate * (1.0/fluid_density - 1.0/solid_density);
-
-        // compression term
-        // The whole expression for the first term on the RHS would be
-        // (u_s \cdot g) (\phi \rho_f \kappa_f + (1 - \phi) \rho_s \kappa_s).
-        // However, we already have the term (u_s \cdot g) \rho_s \kappa_s in the
-        // assembly of the Stokes system without melt. Because of that, we only
-        // need to have -\phi \rho_s \kappa_s here.
-        fluid_pressure_RHS += is_compressible
-                              ?
-                              (current_u * fluid_density_gradient) * porosity / fluid_density
-                              - (current_u * gravity) * porosity * solid_density * solid_compressibility
-                              + K_D * (fluid_density_gradient * gravity)
-                              :
-                              0.0;
-
-        return fluid_pressure_RHS;
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    MeltStokesSystem<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-
-      Assert(Plugins::plugin_type_matches<const MaterialModel::MeltInterface<dim>>(this->get_material_model()),
-             ExcMessage("Error: The current material model needs to be derived from MeltInterface to use melt transport."));
-
-      const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>
-                               (this->get_material_model()).p_c_scale(scratch.material_model_inputs,
-                                                                      scratch.material_model_outputs,
-                                                                      this->get_melt_handler(),
-                                                                      true);
-
-      const FEValuesExtractors::Scalar extractor_pressure = introspection.variable("fluid pressure").extractor_scalar();
-      const FEValuesExtractors::Scalar ex_p_c = introspection.variable("compaction pressure").extractor_scalar();
-
-      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
-      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
-
-      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
-      *force = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
-
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      std::vector<double> reactions(n_q_points, numbers::signaling_nan<double>());
-      const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
-      if (this->get_parameters().use_operator_splitting)
-        scratch.finite_element_values[introspection.extractors.compositional_fields[porosity_index]].get_function_values(this->get_reaction_vector(),
-            reactions);
-
-      for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-        {
-          const unsigned int component_index_i = fe.system_to_component_index(i).first;
-
-          if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
-            {
-              data.local_dof_indices[i_stokes] = scratch.local_dof_indices[i];
-              ++i_stokes;
-            }
-          ++i;
-        }
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              const unsigned int component_index_i = fe.system_to_component_index(i).first;
-
-              if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
-                {
-                  scratch.phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
-                  scratch.phi_p[i_stokes]   = scratch.finite_element_values[extractor_pressure].value (i, q);
-                  scratch.phi_p_c[i_stokes] = scratch.finite_element_values[ex_p_c].value (i, q);
-                  scratch.grad_phi_p[i_stokes] = scratch.finite_element_values[extractor_pressure].gradient (i, q);
-
-                  if (scratch.rebuild_stokes_matrix)
-                    {
-                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-                    }
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          // Viscosity scalar
-          const double eta = (scratch.rebuild_stokes_matrix
-                              ?
-                              scratch.material_model_outputs.viscosities[q]
-                              :
-                              numbers::signaling_nan<double>());
-          const double eta_two_thirds = (scratch.rebuild_stokes_matrix
-                                         ?
-                                         scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0
-                                         :
-                                         numbers::signaling_nan<double>());
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-
-          const double compressibility
-            = (this->get_material_model().is_compressible()
-               ?
-               scratch.material_model_outputs.compressibilities[q]
-               :
-               numbers::signaling_nan<double>() );
-
-          const double density_s = scratch.material_model_outputs.densities[q]; // density of the solid
-
-          const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
-          const double porosity = std::max(scratch.material_model_inputs.composition[q][porosity_index],0.000);
-
-          const double K_D = this->get_melt_handler().limited_darcy_coefficient(melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q],
-                                                                                p_c_scale > 0);
-          const double viscosity_c = melt_outputs->compaction_viscosities[q];
-          const Tensor<1,dim> density_gradient_f = melt_outputs->fluid_density_gradients[q];
-          const double density_f = melt_outputs->fluid_densities[q];
-          const double p_f_RHS = compute_fluid_pressure_rhs(this,
-                                                            scratch,
-                                                            q,
-                                                            K_D,
-                                                            reactions[q]);
-          const double bulk_density = (1.0 - porosity) * density_s + porosity * density_f;
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i) += (
-                                     (bulk_density * gravity * scratch.phi_u[i])
-                                     +
-                                     // add a force to the RHS if present
-                                     (force!=nullptr ?
-                                      (force->rhs_u[q] * scratch.phi_u[i]
-                                       + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i]
-                                       + pressure_scaling * force->rhs_melt_pc[q] * p_c_scale * scratch.phi_p_c[i])
-                                      : 0.0)
-                                     +
-                                     // add the term that results from the compressibility. compared
-                                     // to the manual, this term seems to have the wrong sign, but this
-                                     // is because we negate the entire equation to make sure we get
-                                     // -div(u) as the adjoint operator of grad(p) (see above where
-                                     // we assemble the matrix)
-                                     (this->get_material_model().is_compressible()
-                                      ?
-                                      (pressure_scaling *
-                                       compressibility * density_s *
-                                       (scratch.velocity_values[q] * gravity) *
-                                       scratch.phi_p[i])
-                                      :
-                                      0)
-                                     + pressure_scaling *
-                                     p_f_RHS * scratch.phi_p[i]
-                                     - pressure_scaling *
-                                     K_D * density_f *
-                                     (scratch.grad_phi_p[i] * gravity)
-                                   )
-                                   * JxW;
-
-              if (scratch.rebuild_stokes_matrix)
-                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                  {
-                    data.local_matrix(i,j) += ( (eta * 2.0 * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
-                                                - (eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
-                                                  )
-                                                - (pressure_scaling *
-                                                   scratch.div_phi_u[i] * scratch.phi_p[j])
-                                                // finally the term -div(u). note the negative sign to make this
-                                                // operator adjoint to the grad(p) term
-                                                - (pressure_scaling *
-                                                   scratch.phi_p[i] * scratch.div_phi_u[j])
-                                                +
-                                                (- pressure_scaling * pressure_scaling / viscosity_c * p_c_scale * p_c_scale
-                                                 * scratch.phi_p_c[i] * scratch.phi_p_c[j])
-                                                - pressure_scaling * scratch.div_phi_u[i] * scratch.phi_p_c[j] * p_c_scale
-                                                - pressure_scaling * scratch.phi_p_c[i] * scratch.div_phi_u[j] * p_c_scale
-                                                - K_D * pressure_scaling * pressure_scaling *
-                                                (scratch.grad_phi_p[i] * scratch.grad_phi_p[j])
-                                                + (this->get_material_model().is_compressible()
-                                                   ?
-                                                   K_D * pressure_scaling * pressure_scaling / density_f
-                                                   * scratch.phi_p[i] * (scratch.grad_phi_p[j] * density_gradient_f)
-                                                   :
-                                                   0.0))
-                                              * JxW;
-                  }
-            }
-        }
-
-    }
-
-
-
-    template <int dim>
-    void
-    MeltStokesSystemBoundary<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const unsigned int n_face_q_points = scratch.face_finite_element_values.n_quadrature_points;
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const FEValuesExtractors::Scalar ex_p_f = introspection.variable("fluid pressure").extractor_scalar();
-      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
-      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
-      const bool is_melt_cell = this->get_melt_handler().is_melt_cell(scratch.material_model_inputs.current_cell);
-
-      const typename DoFHandler<dim>::face_iterator face = scratch.face_material_model_inputs.current_cell->face(scratch.face_number);
-
-      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.face_material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-
-      std::vector<double> grad_p_f(n_face_q_points);
-      this->get_melt_handler().get_boundary_fluid_pressure().fluid_pressure_gradient(
-        face->boundary_id(),
-        scratch.face_material_model_inputs,
-        scratch.face_material_model_outputs,
-        scratch.face_finite_element_values.get_normal_vectors(),
-        grad_p_f);
-
-      for (unsigned int q=0; q<n_face_q_points; ++q)
-        {
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.face_finite_element_values.quadrature_point(q));
-          const double density_f = melt_outputs->fluid_densities[q];
-          const double K_D = this->get_melt_handler().limited_darcy_coefficient(melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q],
-                                                                                is_melt_cell);
-
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              const unsigned int component_index_i = fe.system_to_component_index(i).first;
-
-              if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
-                {
-                  // apply the fluid pressure boundary condition
-                  data.local_rhs(i_stokes) += (scratch.face_finite_element_values[ex_p_f].value(i, q)
-                                               * this->get_pressure_scaling() * K_D *
-                                               (density_f
-                                                * (scratch.face_finite_element_values.normal_vector(q) * gravity)
-                                                - grad_p_f[q])
-                                               * scratch.face_finite_element_values.JxW(q));
-                  ++i_stokes;
-                }
-              ++i;
-            }
-        }
-    }
-
-    namespace
-    {
-      /**
-       * Compute the right-hand side for the porosity system.
-       * It includes the melting rate and a term dependent
-       * on the density and velocity.
-       *
-       * This function is implemented in
-       * <code>source/simulator/melt.cc</code>.
-       */
-      template <int dim>
-      double
-      compute_melting_RHS(const SimulatorAccess<dim> *simulator_access,
-                          const internal::Assembly::Scratch::AdvectionSystem<dim>  &scratch,
-                          const unsigned int q_point,
-                          const double divergence_u)
-      {
-        Assert (scratch.material_model_outputs.densities[q_point] > 0,
-                ExcMessage ("The density needs to be a positive quantity "
-                            "when melt transport is included in the simulation."));
-
-        const double melting_rate         = scratch.material_model_outputs.reaction_terms[q_point][scratch.advection_field->compositional_variable];
-        const double density              = scratch.material_model_outputs.densities[q_point];
-
-        const double compressibility      = (simulator_access->get_material_model().is_compressible()
-                                             ?
-                                             scratch.material_model_outputs.compressibilities[q_point]
-                                             :
-                                             0.0);
-        const Tensor<1,dim> current_u     = scratch.current_velocity_values[q_point];
-        const Tensor<1,dim>
-        gravity = simulator_access->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q_point));
-
-        // Note that the full advection term would be (1 - phi) * (div u + kappa rho u g),
-        // but we expanded the term and move the part (- phi) * (div u + kappa rho u g) over to the LHS.
-        double melt_transport_RHS = melting_rate / density
-                                    + divergence_u + compressibility * density * (current_u * gravity);
-
-        if (!simulator_access->get_melt_handler().is_melt_cell(scratch.material_model_inputs.current_cell))
-          melt_transport_RHS = melting_rate / density;
-
-        return melt_transport_RHS;
-      }
-    }
-
-
-    template <int dim>
-    void
-    MeltAdvectionSystem<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::AdvectionSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::AdvectionSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      const bool use_bdf2_scheme = (this->get_timestep_number() > 1);
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      const unsigned int advection_dofs_per_cell = data.local_dof_indices.size();
-
-      const double time_step = this->get_timestep();
-      const double old_time_step = this->get_old_timestep();
-
-      const unsigned int solution_component = scratch.advection_field->component_index(introspection);
-
-      const FEValuesExtractors::Scalar solution_field = scratch.advection_field->scalar_extractor(introspection);
-
-      MaterialModel::MeltOutputs<dim> *melt_outputs = scratch.material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-
-      Assert(melt_outputs->compaction_viscosities[0] > 0.0,
-             ExcMessage ("MeltOutputs have to be filled for models with melt transport. "
-                         "At the moment, these outputs are not filled, or they do not have "
-                         "reasonable values."));
-
-      std::vector<Tensor<1,dim>> fluid_velocity_values(n_q_points);
-      const FEValuesExtractors::Vector ex_u_f = introspection.variable("fluid velocity").extractor_vector();
-      scratch.finite_element_values[ex_u_f].get_function_values (this->get_solution(),fluid_velocity_values);
-
-      // average divergence u over the cell (needed for porosity advection)
-      double divergence_u = 0.0;
-      if (this->get_melt_handler().is_porosity(*scratch.advection_field))
-        for (unsigned int q=0; q<n_q_points; ++q)
-          divergence_u += scratch.current_velocity_divergences[q] * 1./n_q_points;
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          // precompute the values of shape functions and their gradients.
-          // We only need to look up values of shape functions if they
-          // belong to 'our' component. They are zero otherwise anyway.
-          // Note that we later only look at the values that we do set here.
-          for (unsigned int i=0, i_advection=0; i_advection<advection_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (fe.system_to_component_index(i).first == solution_component)
-                {
-                  scratch.grad_phi_field[i_advection] = scratch.finite_element_values[solution_field].gradient (i,q);
-                  scratch.phi_field[i_advection]      = scratch.finite_element_values[solution_field].value (i,q);
-                  ++i_advection;
-                }
-              ++i;
-            }
-
-          const unsigned int porosity_index = introspection.compositional_index_for_name("porosity");
-          const double porosity = std::max(scratch.material_model_inputs.composition[q][porosity_index],0.0);
-          const double bulk_density = (1.0 - porosity) * scratch.material_model_outputs.densities[q] + porosity * melt_outputs->fluid_densities[q];
-
-          const double density_c_P =
-            ((scratch.advection_field->is_temperature())
-             ?
-             bulk_density *
-             scratch.material_model_outputs.specific_heat[q]
-             :
-             1.0);
-
-          Assert (density_c_P >= 0,
-                  ExcMessage ("The product of density and c_P needs to be a "
-                              "non-negative quantity."));
-
-          const double conductivity =
-            (scratch.advection_field->is_temperature()
-             ?
-             scratch.material_model_outputs.thermal_conductivities[q]
-             :
-             0.0);
-          const double latent_heat_LHS =
-            ((scratch.advection_field->is_temperature())
-             ?
-             scratch.heating_model_outputs.lhs_latent_heat_terms[q]
-             :
-             0.0);
-          Assert (density_c_P + latent_heat_LHS >= 0,
-                  ExcMessage ("The sum of density times c_P and the latent heat contribution "
-                              "to the left hand side needs to be a non-negative quantity."));
-
-          const double gamma =
-            ((scratch.advection_field->is_temperature())
-             ?
-             scratch.heating_model_outputs.heating_source_terms[q]
-             :
-             0.0);
-
-          const double reaction_term =
-            ((scratch.advection_field->is_temperature() || this->get_melt_handler().is_porosity(*scratch.advection_field))
-             ?
-             0.0
-             :
-             scratch.material_model_outputs.reaction_terms[q][scratch.advection_field->compositional_variable]);
-
-          const double melt_transport_RHS = (this->get_melt_handler().is_porosity(*scratch.advection_field) ?
-                                             compute_melting_RHS (this,
-                                                                  scratch,
-                                                                  q,
-                                                                  divergence_u)
-                                             :
-                                             0.0);
-
-          const double field_term_for_rhs
-            = (use_bdf2_scheme ?
-               ((scratch.old_field_values)[q] *
-                (1 + time_step/old_time_step)
-                -
-                (scratch.old_old_field_values)[q] *
-                (time_step * time_step) /
-                (old_time_step * (time_step + old_time_step)))
-               :
-               (scratch.old_field_values)[q])
-              *
-              (density_c_P + latent_heat_LHS);
-
-          Tensor<1,dim> current_u = scratch.current_velocity_values[q];
-          // Subtract off the mesh velocity for ALE corrections if necessary
-          if (this->get_parameters().mesh_deformation_enabled)
-            current_u -= scratch.mesh_velocity_values[q];
-
-          const double melt_transport_LHS =
-            (this->get_melt_handler().is_porosity(*scratch.advection_field)
-             && this->get_melt_handler().is_melt_cell(scratch.material_model_inputs.current_cell)
-             ?
-             divergence_u
-             + (this->get_material_model().is_compressible()
-                ?
-                scratch.material_model_outputs.compressibilities[q]
-                * scratch.material_model_outputs.densities[q]
-                * current_u
-                * this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q))
-                :
-                0.0)
-             :
-             0.0);
-
-          const double factor = (use_bdf2_scheme)? ((2*time_step + old_time_step) /
-                                                    (time_step + old_time_step)) : 1.0;
-
-          // for advective transport of heat by melt, or advecting compositional fields
-          // with the melt velocity, we have to consider melt velocities
-          const Tensor<1,dim> current_u_f = fluid_velocity_values[q];
-          double density_c_P_solid = density_c_P;
-          double density_c_P_melt = 0.0;
-
-          if (scratch.advection_field->is_temperature() && this->get_melt_handler().is_melt_cell(scratch.cell)
-              && this->get_melt_handler().melt_parameters.heat_advection_by_melt)
-            {
-              density_c_P_solid = (1.0 - porosity) * scratch.material_model_outputs.densities[q] * scratch.material_model_outputs.specific_heat[q];
-              density_c_P_melt = porosity * melt_outputs->fluid_densities[q] * scratch.material_model_outputs.specific_heat[q];
-            }
-          else if (!scratch.advection_field->is_temperature()
-                   && !this->get_melt_handler().is_porosity(*scratch.advection_field)
-                   && scratch.advection_field->advection_method(this->introspection()) == Parameters<dim>::AdvectionFieldMethod::fem_melt_field)
-            {
-              // if the field is advected with the fem_melt_field method,
-              // we want to use the melt (fluid) velocity instead of the solid velocity for advecting it
-              density_c_P_solid = 0.0;
-              density_c_P_melt = 1.0;
-            }
-
-          // do the actual assembly. note that we only need to loop over the advection
-          // shape functions because these are the only contributions we compute here
-          for (unsigned int i=0; i<advection_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i)
-              += (field_term_for_rhs * scratch.phi_field[i]
-                  + time_step *
-                  scratch.phi_field[i]
-                  * (gamma + melt_transport_RHS)
-                  + scratch.phi_field[i]
-                  * reaction_term)
-                 *
-                 scratch.finite_element_values.JxW(q);
-
-              for (unsigned int j=0; j<advection_dofs_per_cell; ++j)
-                {
-                  data.local_matrix(i,j)
-                  += (
-                       (time_step * (conductivity + scratch.artificial_viscosity)
-                        * (scratch.grad_phi_field[i] * scratch.grad_phi_field[j]))
-                       + ((time_step * (scratch.phi_field[i] * (current_u * scratch.grad_phi_field[j])))
-                          + (factor * scratch.phi_field[i] * scratch.phi_field[j])) *
-                       (density_c_P_solid + latent_heat_LHS)
-                       + ((time_step * (scratch.phi_field[i] * (current_u_f * scratch.grad_phi_field[j])))
-                          + (factor * scratch.phi_field[i] * scratch.phi_field[j])) *
-                       (density_c_P_melt)
-                       + time_step * scratch.phi_field[i] * scratch.phi_field[j] * melt_transport_LHS
-                     )
-                     * scratch.finite_element_values.JxW(q);
-                }
-            }
-        }
-    }
-
-    template <int dim>
-    std::vector<double>
-    MeltAdvectionSystem<dim>::
-    compute_residual(internal::Assembly::Scratch::ScratchBase<dim> &scratch_base) const
-    {
-      internal::Assembly::Scratch::AdvectionSystem<dim> &scratch =
-        dynamic_cast<internal::Assembly::Scratch::AdvectionSystem<dim>&> (scratch_base);
-
-      const unsigned int n_q_points = scratch.finite_element_values.n_quadrature_points;
-      std::vector<double> residuals(n_q_points);
-
-      this->get_heating_model_manager().evaluate(scratch.material_model_inputs,
-                                                 scratch.material_model_outputs,
-                                                 scratch.heating_model_outputs);
-
-      // average divergence u over the cell (needed for porosity advection)
-      double divergence_u = 0.0;
-      if (this->get_melt_handler().is_porosity(*scratch.advection_field))
-        for (unsigned int q=0; q<n_q_points; ++q)
-          divergence_u += scratch.current_velocity_divergences[q] * 1./n_q_points;
-
-      for (unsigned int q=0; q < n_q_points; ++q)
-        {
-          const Tensor<1,dim> u = (scratch.old_velocity_values[q] +
-                                   scratch.old_old_velocity_values[q]) / 2;
-
-          const double dField_dt = (this->get_old_timestep() == 0.0) ? 0.0 :
-                                   (
-                                     ((scratch.old_field_values)[q] - (scratch.old_old_field_values)[q])
-                                     / this->get_old_timestep());
-          const double u_grad_field = u * (scratch.old_field_grads[q] +
-                                           scratch.old_old_field_grads[q]) / 2;
-
-          if (scratch.advection_field->is_temperature())
-            {
-              const double density       = scratch.material_model_outputs.densities[q];
-              const double conductivity  = scratch.material_model_outputs.thermal_conductivities[q];
-              const double c_P           = scratch.material_model_outputs.specific_heat[q];
-              const double k_Delta_field = conductivity * (scratch.old_field_laplacians[q] +
-                                                           scratch.old_old_field_laplacians[q]) / 2;
-
-              const double gamma           = scratch.heating_model_outputs.heating_source_terms[q];
-              const double latent_heat_LHS = scratch.heating_model_outputs.lhs_latent_heat_terms[q];
-
-              residuals[q]
-                = std::abs((density * c_P + latent_heat_LHS) * (dField_dt + u_grad_field) - k_Delta_field - gamma);
-            }
-          else
-            {
-              const double field = ((scratch.old_field_values)[q] + (scratch.old_old_field_values)[q]) / 2;
-
-              const double dreaction_term_dt =
-                (this->get_old_timestep() == 0 || this->get_melt_handler().is_porosity(*scratch.advection_field))
-                ?
-                0.0
-                :
-                (scratch.material_model_outputs.reaction_terms[q][scratch.advection_field->compositional_variable]
-                 / this->get_old_timestep());
-
-
-              const double melt_transport_RHS = (this->get_melt_handler().is_porosity(*scratch.advection_field) ?
-                                                 compute_melting_RHS (this,
-                                                                      scratch,
-                                                                      q,
-                                                                      divergence_u)
-                                                 :
-                                                 0.0);
-
-              const double melt_transport_LHS =
-                (this->get_melt_handler().is_porosity(*scratch.advection_field)
-                 ?
-                 scratch.current_velocity_divergences[q]
-                 + (this->get_material_model().is_compressible()
-                    ?
-                    scratch.material_model_outputs.compressibilities[q]
-                    * scratch.material_model_outputs.densities[q]
-                    * u
-                    * this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q))
-                    :
-                    0.0)
-                 :
-                 0.0);
-
-              residuals[q]
-                = std::abs(dField_dt + u_grad_field + melt_transport_LHS * field
-                           - melt_transport_RHS - dreaction_term_dt);
-            }
-        }
-      return residuals;
-    }
-
-
-
-    template <int dim>
-    void
-    MeltPressureRHSCompatibilityModification<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = scratch.finite_element_values.get_fe();
-
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
-      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
-
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-
-      const FEValuesExtractors::Scalar ex_p_f = introspection.variable("fluid pressure").extractor_scalar();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-          {
-            const unsigned int component_index_i = fe.system_to_component_index(i).first;
-
-            if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
-              {
-                scratch.phi_p[i_stokes] = scratch.finite_element_values[ex_p_f].value (i, q);
-                data.local_pressure_shape_function_integrals(i_stokes) += scratch.phi_p[i_stokes] * scratch.finite_element_values.JxW(q);
-                ++i_stokes;
-              }
-            ++i;
-          }
-    }
-
-    template <int dim>
-    void
-    MeltBoundaryTraction<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>  &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      // see if any of the faces are traction boundaries for which
-      // we need to assemble force terms for the right hand side
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int p_f_component_index = introspection.variable("fluid pressure").first_component_index;
-      const unsigned int p_c_component_index = introspection.variable("compaction pressure").first_component_index;
-
-      const typename DoFHandler<dim>::active_cell_iterator cell (&this->get_triangulation(),
-                                                                 scratch.face_finite_element_values.get_cell()->level(),
-                                                                 scratch.face_finite_element_values.get_cell()->index(),
-                                                                 &this->get_dof_handler());
-
-      unsigned int face_no = numbers::invalid_unsigned_int;
-      for (face_no=0; face_no<cell->n_faces(); ++face_no)
-        if (scratch.face_finite_element_values.get_face_index() == cell->face_index(face_no))
-          break;
-      Assert(face_no != numbers::invalid_unsigned_int,ExcInternalError());
-
-      const typename DoFHandler<dim>::face_iterator face = cell->face(face_no);
-
-      if (this->get_boundary_traction_manager().get_active_boundary_traction_names()
-          .find (face->boundary_id())
-          !=
-          this->get_boundary_traction_manager().get_active_boundary_traction_names().end())
-        {
-          scratch.face_finite_element_values.reinit (cell, face_no);
-
-          for (unsigned int q=0; q<scratch.face_finite_element_values.n_quadrature_points; ++q)
-            {
-              const Tensor<1,dim> traction
-                = this->get_boundary_traction_manager().
-                  boundary_traction (face->boundary_id(),
-                                     scratch.face_finite_element_values.quadrature_point(q),
-                                     scratch.face_finite_element_values.normal_vector(q));
-
-              for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-                {
-                  const unsigned int component_index_i = fe.system_to_component_index(i).first;
-
-                  if (is_velocity_or_pressures(introspection,p_c_component_index,p_f_component_index,component_index_i))
-                    {
-                      data.local_rhs(i_stokes) += scratch.face_finite_element_values[introspection.extractors.velocities].value(i,q) *
-                                                  traction *
-                                                  scratch.face_finite_element_values.JxW(q);
-                      ++i_stokes;
-                    }
-                  ++i;
-                }
-            }
-        }
-    }
-  }
-
-
-  template <int dim>
-  void
-  MeltHandler<dim>::
-  compute_melt_variables(LinearAlgebra::BlockSparseMatrix &system_matrix,
-                         LinearAlgebra::BlockVector &solution,
-                         LinearAlgebra::BlockVector &system_rhs)
-  {
-    if (!this->include_melt_transport())
-      return;
-
-    Assert (this->include_melt_transport(), ExcMessage ("'Include melt transport' has to be on to "
-                                                        "compute melt variables"));
-
-    LinearAlgebra::BlockVector distributed_solution (this->introspection().index_sets.system_partitioning,
-                                                     this->get_mpi_communicator());
-
-    const unsigned int por_idx = this->introspection().compositional_index_for_name("porosity");
-
-    {
-      // compute fluid_velocity
-      // u_f =  u_s - K_D (nabla p_f - rho_f g) / phi  or = 0
-      // by solving a mass matrix problem
-
-      const unsigned int block_idx = this->introspection().variable("fluid velocity").block_index;
-      system_matrix.block(block_idx, block_idx) = 0;
-      system_rhs.block(block_idx) = 0;
-
-      const Quadrature<dim> &quadrature = this->introspection().quadratures.velocities;
-      const FiniteElement<dim> &fe = this->get_fe();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               fe,
-                               quadrature,
-                               update_quadrature_points | update_values | update_gradients | update_JxW_values);
-
-      const unsigned int dofs_per_cell = fe_values.dofs_per_cell,
-                         n_q_points    = fe_values.n_quadrature_points;
-
-      const FEVariable<dim> &u_f_variable = this->introspection().variable("fluid velocity");
-      const unsigned int fluid_velocity_dofs_per_cell = fe.element_multiplicity(u_f_variable.base_index) *
-                                                        fe.base_element(u_f_variable.base_index).dofs_per_cell;
-
-      std::vector<types::global_dof_index> cell_dof_indices (dofs_per_cell);
-      std::vector<types::global_dof_index> cell_u_f_dof_indices (fluid_velocity_dofs_per_cell);
-
-      Vector<double> cell_vector (fluid_velocity_dofs_per_cell);
-      FullMatrix<double> cell_matrix (fluid_velocity_dofs_per_cell, fluid_velocity_dofs_per_cell);
-
-      std::vector<double> porosity_values(quadrature.size());
-      std::vector<Tensor<1,dim>> grad_p_f_values(quadrature.size());
-      std::vector<Tensor<1,dim>> u_s_values(quadrature.size());
-
-      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
-
-      create_material_model_outputs(out);
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            cell_vector = 0;
-            cell_matrix = 0;
-            fe_values.reinit (cell);
-
-            cell->get_dof_indices (cell_dof_indices);
-
-            // Extract the dofs of this cell that are actually fluid velocity dofs
-            for (unsigned int i=0, i_u_f=0; i_u_f<fluid_velocity_dofs_per_cell; /*increment at end of loop*/)
-              {
-                if (u_f_variable.component_mask[fe.system_to_component_index(i).first])
-                  {
-                    cell_u_f_dof_indices[i_u_f] = cell_dof_indices[i];
-                    ++i_u_f;
-                  }
-                ++i;
-              }
-
-            fe_values[this->introspection().extractors.compositional_fields[por_idx]].get_function_values (
-              solution, porosity_values);
-            fe_values[this->introspection().extractors.velocities].get_function_values (
-              solution, u_s_values);
-
-            fe_values[this->introspection().variable("fluid pressure").extractor_scalar()].get_function_gradients (
-              solution, grad_p_f_values);
-
-
-            in.reinit(fe_values,
-                      cell,
-                      this->introspection(),
-                      this->get_solution());
-
-            this->get_material_model().evaluate(in, out);
-
-            const bool is_melt_cell = this->get_melt_handler().is_melt_cell(in.current_cell);
-
-            MaterialModel::MeltOutputs<dim> *melt_outputs = out.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-            Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for computing the melt variables."));
-            const FEValuesExtractors::Vector fluid_velocity_extractor = this->introspection().variable("fluid velocity").extractor_vector();
-
-            std::vector<Tensor<1,dim>> phi_u_f(fluid_velocity_dofs_per_cell);
-
-            double K_D_over_phi = 1.0;
-
-            if (melt_parameters.average_melt_velocity)
-              {
-                // average the K_D and the porosity cell-wise (geometric mean)
-                for (unsigned int q=0; q<n_q_points; ++q)
-                  {
-                    const double K_D = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q];
-                    const double K_D_over_phi_q_point = (porosity_values[q] > 0 ? K_D / porosity_values[q] : 0.0);
-                    K_D_over_phi *= std::pow(K_D_over_phi_q_point, 1.0/n_q_points);
-                  }
-              }
-
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                for (unsigned int i = 0, i_u_f = 0; i_u_f < fluid_velocity_dofs_per_cell; /*increment at end of loop*/)
-                  {
-                    if (u_f_variable.component_mask[fe.system_to_component_index(i).first])
-                      {
-                        phi_u_f[i_u_f] = fe_values[fluid_velocity_extractor].value(i,q);
-                        ++i_u_f;
-                      }
-                    ++i;
-                  }
-
-                const double JxW = fe_values.JxW(q);
-
-                for (unsigned int i=0; i<fluid_velocity_dofs_per_cell; ++i)
-                  for (unsigned int j=0; j<fluid_velocity_dofs_per_cell; ++j)
-                    cell_matrix(i,j) += phi_u_f[j] * phi_u_f[i] * JxW;
-
-                if (!melt_parameters.average_melt_velocity)
-                  {
-                    // use K_D without cutoff to compute u_f
-                    const double phi = std::max(0.0, porosity_values[q]);
-                    const double K_D = melt_outputs->permeabilities[q] / melt_outputs->fluid_viscosities[q];
-
-                    K_D_over_phi = (phi > 0 ? K_D / phi : 0.0);
-                  }
-
-                // u_f =  u_s - K_D (nabla p_f - rho_f g) / phi  or = 0
-                if (is_melt_cell)
-                  {
-                    const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(in.position[q]);
-
-
-                    for (unsigned int i=0; i<fluid_velocity_dofs_per_cell; ++i)
-                      cell_vector(i) += (u_s_values[q] - K_D_over_phi * (grad_p_f_values[q] - melt_outputs->fluid_densities[q]*gravity))
-                                        * phi_u_f[i]
-                                        * JxW;
-                  }
-                else
-                  for (unsigned int i=0; i<fluid_velocity_dofs_per_cell; ++i)
-                    cell_vector(i) += (u_s_values[q])
-                                      * phi_u_f[i]
-                                      * JxW;
-
-              }
-
-            this->get_current_constraints().distribute_local_to_global (cell_matrix, cell_vector,
-                                                                        cell_u_f_dof_indices, system_matrix,
-                                                                        system_rhs, false);
-          }
-
-      system_rhs.compress (VectorOperation::add);
-      system_matrix.compress (VectorOperation::add);
-
-      LinearAlgebra::PreconditionAMG preconditioner;
-      LinearAlgebra::PreconditionAMG::AdditionalData Amg_data;
-
-      // Amg_data.constant_modes = constant_modes;
-      Amg_data.elliptic = true;
-      Amg_data.higher_order_elements = false;
-      Amg_data.smoother_sweeps = 2;
-      Amg_data.aggregation_threshold = 0.02;
-      preconditioner.initialize(system_matrix.block(block_idx, block_idx));
-
-      SolverControl solver_control(system_rhs.block(block_idx).size(),
-                                   1e-8*system_rhs.block(block_idx).l2_norm());
-      SolverCG<LinearAlgebra::Vector> cg(solver_control);
-
-      this->get_pcout() << "   Solving fluid velocity system... " << std::flush;
-
-      cg.solve (system_matrix.block(block_idx, block_idx),
-                distributed_solution.block(block_idx),
-                system_rhs.block(block_idx),
-                preconditioner);
-
-      this->get_pcout() << solver_control.last_step() <<" iterations."<< std::endl;
-
-      this->get_current_constraints().distribute (distributed_solution);
-      solution.block(block_idx) = distributed_solution.block(block_idx);
-    }
-
-    // compute solid pressure as
-    // p_s = (p_c+ (1-phi)p_f) / (1-phi)
-    // p_s = p_c / (1-phi) + p_f
-    {
-      const unsigned int block_p = this->introspection().block_indices.pressure;
-
-      // Think what we need to do if the pressure is not an FE_Q...
-      Assert(this->get_parameters().use_locally_conservative_discretization == false, ExcNotImplemented());
-
-      const Quadrature<dim> quadrature(this->get_fe().base_element(this->introspection().base_elements.pressure).get_unit_support_points());
-      std::vector<double> porosity_values(quadrature.size());
-      std::vector<double> p_c_values(quadrature.size());
-      std::vector<double> p_f_values(quadrature.size());
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature,
-                               update_quadrature_points | update_gradients | update_values);
-
-      MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
-      // We only need access to the MeltOutputs in p_c_scale().
-      in.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
-
-      MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
-      create_material_model_outputs(out);
-
-      std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit(cell);
-            cell->get_dof_indices (local_dof_indices);
-            fe_values[this->introspection().extractors.compositional_fields[por_idx]].get_function_values (
-              solution, porosity_values);
-            fe_values[this->introspection().variable("compaction pressure").extractor_scalar()].get_function_values (
-              solution, p_c_values);
-            fe_values[this->introspection().variable("fluid pressure").extractor_scalar()].get_function_values (
-              solution, p_f_values);
-            in.reinit(fe_values,
-                      cell,
-                      this->introspection(),
-                      solution);
-
-            this->get_material_model().evaluate(in, out);
-
-            const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(
-                                       this->get_material_model()).p_c_scale(in,
-                                                                             out,
-                                                                             this->get_melt_handler(),
-                                                                             true);
-
-            for (unsigned int j=0; j<this->get_fe().base_element(this->introspection().base_elements.pressure).dofs_per_cell; ++j)
-              {
-                const unsigned int pressure_idx
-                  = this->get_fe().component_to_system_index(this->introspection().component_indices.pressure,
-                                                             /*dof index within component=*/ j);
-
-                // skip entries that are not locally owned:
-                if (!this->get_dof_handler().locally_owned_dofs().is_element(local_dof_indices[pressure_idx]))
-                  continue;
-
-                const double phi = std::max(0.0, porosity_values[j]);
-
-                double p = p_f_values[j];
-                if (p_c_scale > 0 && (1.0-phi) > std::numeric_limits<double>::min())
-                  p = (p_c_scale*p_c_values[j] - (phi-1.0) * p_f_values[j]) / (1.0-phi);
-
-                distributed_solution(local_dof_indices[pressure_idx]) = p;
-              }
-          }
-
-      distributed_solution.block(block_p).compress(VectorOperation::insert);
-      solution.block(block_p) = distributed_solution.block(block_p);
-    }
-  }
-
-
-
-  template <int dim>
-  bool
-  MeltHandler<dim>::
-  is_porosity(const typename Simulator<dim>::AdvectionField &advection_field) const
-  {
-    if (advection_field.field_type != Simulator<dim>::AdvectionField::compositional_field)
-      return false;
-    else
-      return (this->introspection().name_for_compositional_index(advection_field.compositional_variable) == "porosity");
-  }
-
-
-
-  namespace internal
-  {
-    // This is a scratch object for the setting the compaction pressure constraints
-    // in cells without melt (where we do not solve the melt transport equations,
-    // so we set the compaction pressure to zero).
-    template <int dim>
-    struct PcConstraintsAssembleData
-    {
-      // Standard constructor
-      PcConstraintsAssembleData (const FiniteElement<dim> &finite_element,
-                                 const Quadrature<dim>    &quadrature,
-                                 const Mapping<dim>       &mapping,
-                                 const UpdateFlags         update_flags,
-                                 const unsigned int        n_compositional_fields,
-                                 const unsigned int        stokes_dofs_per_cell)
-        :
-        finite_element_values (mapping, finite_element, quadrature,
-                               update_flags),
-        local_dof_indices (finite_element.dofs_per_cell),
-        dof_component_indices(stokes_dofs_per_cell),
-        material_model_inputs(quadrature.size(), n_compositional_fields),
-        material_model_outputs(quadrature.size(), n_compositional_fields)
-      {}
-
-
-      // Copy constructor
-      PcConstraintsAssembleData (const PcConstraintsAssembleData &scratch)
-        :
-        finite_element_values (scratch.finite_element_values.get_mapping(),
-                               scratch.finite_element_values.get_fe(),
-                               scratch.finite_element_values.get_quadrature(),
-                               scratch.finite_element_values.get_update_flags()),
-        local_dof_indices (scratch.local_dof_indices),
-        dof_component_indices( scratch.dof_component_indices),
-        material_model_inputs(scratch.material_model_inputs),
-        material_model_outputs(scratch.material_model_outputs)
-      {}
-
-      virtual ~PcConstraintsAssembleData () = default;
-
-      FEValues<dim>                            finite_element_values;
-
-      std::vector<types::global_dof_index>     local_dof_indices;
-      std::vector<unsigned int>                dof_component_indices;
-
-      MaterialModel::MaterialModelInputs<dim>  material_model_inputs;
-      MaterialModel::MaterialModelOutputs<dim> material_model_outputs;
-
-    };
-
-    template <int dim>
-    struct PcConstraintsCopyData
-    {
-      explicit PcConstraintsCopyData (const unsigned int stokes_dofs_per_cell)
-      {
-        nonzero_dof_indices.reserve(stokes_dofs_per_cell);
-      }
-
-      std::vector<types::global_dof_index>   nonzero_dof_indices;
-    };
-
-
-    // Assembler for setting the compaction pressure constraints in cells without melt.
-    // Note that the assembler does not actually assemble anything, it just uses the
-    // structure of an assembler to loop over all compaction pressure dofs and to insert
-    // the ones that are in melt cells into an IndexSet (nonzero_dof_indices) that is
-    // later needed for setting the constraints.
-    template <int dim>
-    class PcNonZeroDofsAssembler : public SimulatorAccess<dim>
-    {
-      public:
-        PcNonZeroDofsAssembler(const std::vector<bool> &is_melt_cell,
-                               IndexSet &nonzero_entries)
-          : is_melt_cell (is_melt_cell),
-            nonzero_entries (nonzero_entries)
-        {}
-
-
-        void
-        local_save_nonzero_pc_dofs (const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                    PcConstraintsAssembleData<dim> &scratch,
-                                    PcConstraintsCopyData<dim> &data)
-        {
-          data.nonzero_dof_indices.clear();
-          cell->get_dof_indices (scratch.local_dof_indices);
-
-          const unsigned int pc_component_index = this->introspection().variable("compaction pressure").first_component_index;
-          const unsigned int pc_base_index = this->introspection().variable("compaction pressure").base_index;
-
-          Assert(cell.state() == IteratorState::valid,
-                 ExcMessage("You are trying to access the property of a cell (if it is "
-                            "a melt cell or not), but the cell iterator provided does not "
-                            "point to a cell."));
-          const bool is_melt_cell = this->get_melt_handler().is_melt_cell(cell);
-
-          if (is_melt_cell)
-            {
-              data.nonzero_dof_indices.resize(this->get_fe().base_element(pc_base_index).dofs_per_cell);
-              for (unsigned int j=0; j<this->get_fe().base_element(pc_base_index).dofs_per_cell; ++j)
-                {
-                  const unsigned int pressure_idx
-                    = this->get_fe().component_to_system_index(pc_component_index,
-                                                               /*dof index within component=*/ j);
-
-                  data.nonzero_dof_indices[j] = scratch.local_dof_indices[pressure_idx];
-                }
-            }
-        }
-
-        void
-        copy_local_to_global (const PcConstraintsCopyData<dim> &data)
-        {
-          nonzero_entries.add_indices(data.nonzero_dof_indices.begin(),
-                                      data.nonzero_dof_indices.end());
-        }
-
-      private:
-        const std::vector<bool> &is_melt_cell;
-        IndexSet &nonzero_entries;
-
-    };
-
-  }
-
-
-
-  template <int dim>
-  void
-  MeltHandler<dim>::
-  add_current_constraints(AffineConstraints<double> &constraints)
-  {
-    IndexSet nonzero_pc_dofs(this->introspection().index_sets.system_relevant_set.size());
-
-    const QTrapezoid<dim> quadrature_formula;
-    const UpdateFlags cell_update_flags = update_quadrature_points | update_values | update_gradients;
-    const FiniteElement<dim> &fe = this->get_fe();
-
-    is_melt_cell_vector.resize(this->get_dof_handler().get_triangulation().n_active_cells());
-
-    {
-      // find the "melt cells" by looking at p_c_scale
-
-      const unsigned int n_compositional_fields = this->introspection().n_compositional_fields;
-      FEValues<dim> finite_element_values(this->get_mapping(), fe, quadrature_formula, cell_update_flags);
-
-      MaterialModel::MaterialModelInputs<dim> material_model_inputs(quadrature_formula.size(), n_compositional_fields);
-      MaterialModel::MaterialModelOutputs<dim> material_model_outputs(quadrature_formula.size(), n_compositional_fields);
-
-      MeltHandler<dim>::create_material_model_outputs(material_model_outputs);
-      Assert(Plugins::plugin_type_matches<const MaterialModel::MeltInterface<dim>>(this->get_material_model()),
-             ExcMessage("Your material model does not derive from MaterialModel::MeltInterface, which is required."));
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            finite_element_values.reinit (cell);
-
-            material_model_inputs.reinit(finite_element_values,
-                                         cell,
-                                         this->introspection(),
-                                         this->get_current_linearization_point());
-
-            // We only need access to the MeltOutputs in p_c_scale().
-            material_model_inputs.requested_properties = MaterialModel::MaterialProperties::additional_outputs;
-
-            this->get_material_model().evaluate(material_model_inputs,
-                                                material_model_outputs);
-
-            const double p_c_scale = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(
-                                       this->get_material_model()).p_c_scale(material_model_inputs,
-                                                                             material_model_outputs,
-                                                                             this->get_melt_handler(),
-                                                                             false /*=consider_is_melt_cell*/);
-            const bool is_melt_cell = (p_c_scale > 0.0);
-            is_melt_cell_vector[cell->active_cell_index()] = is_melt_cell;
-          }
-    }
-
-
-    internal::PcNonZeroDofsAssembler<dim> assembler(is_melt_cell_vector, nonzero_pc_dofs);
-    assembler.initialize_simulator(this->get_simulator());
-
-    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
-
-    const unsigned int stokes_dofs_per_cell = dim * fe.base_element(this->introspection().base_elements.velocities).dofs_per_cell
-                                              + fe.base_element(this->introspection().base_elements.pressure).dofs_per_cell
-                                              + fe.base_element(this->introspection().base_elements.pressure).dofs_per_cell;
-
-    auto worker = [&](const typename DoFHandler<dim>::active_cell_iterator &cell,
-                      internal::PcConstraintsAssembleData<dim> &scratch,
-                      internal::PcConstraintsCopyData<dim> &data)
-    {
-      assembler.local_save_nonzero_pc_dofs(cell, scratch, data);
-    };
-
-    auto copier = [&](const internal::PcConstraintsCopyData<dim> &data)
-    {
-      assembler.copy_local_to_global(data);
-    };
-
-    // Here we call the assembler in order to save all compaction pressure dofs
-    // that are in melt cells (and are nonzero) in the nonzero_pc_dofs index set.
-    WorkStream::
-    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     this->get_dof_handler().begin_active()),
-         CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     this->get_dof_handler().end()),
-         worker,
-         copier,
-         internal::PcConstraintsAssembleData<dim> (
-           fe,
-           quadrature_formula,
-           this->get_mapping(),
-           cell_update_flags,
-           this->introspection().n_compositional_fields,
-           stokes_dofs_per_cell),
-         internal::PcConstraintsCopyData<dim> (stokes_dofs_per_cell));
-
-    // For the constraints, first pick all relevant p_c dofs:
-    IndexSet for_constraints = this->introspection().index_sets.system_relevant_set
-                               & Utilities::extract_locally_active_dofs_with_component<dim>(this->get_dof_handler(),
-                                   this->introspection().variable("compaction pressure").component_mask);
-
-    // now subtract the ones that are nonzero as computed above:
-    for_constraints.subtract_set(nonzero_pc_dofs);
-
-    // and constrain the remaining dofs (that are not in melt cells).
-#if DEAL_II_VERSION_GTE(9,6,0)
-    for (const auto index : for_constraints)
-      constraints.constrain_dof_to_zero(index);
-#else
-    constraints.add_lines(for_constraints);
-#endif
-  }
-
-
-
-  template <int dim>
-  bool
-  MeltHandler<dim>::
-  is_melt_cell(const typename DoFHandler<dim>::active_cell_iterator &cell) const
-  {
-    return is_melt_cell_vector[cell->active_cell_index()];
-  }
-
-
-
-  template <int dim>
-  double
-  MeltHandler<dim>::
-  limited_darcy_coefficient(const double K_D,
-                            const bool is_melt_cell) const
-  {
-    const double ref_K_D = Plugins::get_plugin_as_type<const MaterialModel::MeltInterface<dim>>(this->get_material_model()).reference_darcy_coefficient();
-    return is_melt_cell ? std::max(K_D, melt_parameters.melt_scaling_factor_threshold*ref_K_D) : 0;
-  }
-
-
-
-  template <int dim>
-  const BoundaryFluidPressure::Interface<dim> &
-  MeltHandler<dim>::
-  get_boundary_fluid_pressure () const
-  {
-    return *boundary_fluid_pressure.get();
-  }
-
-
-
-  template <int dim>
-  void
-  MeltHandler<dim>::
-  edit_finite_element_variables(const Parameters<dim> &parameters,
-                                std::vector<VariableDeclaration<dim>> &variables)
-  {
-
-    if (!parameters.include_melt_transport)
-      return;
-
-    variables.insert(variables.begin()+1,
-                     VariableDeclaration<dim>(
-                       "fluid pressure",
-                       std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree-1),
-                       1,
-                       0)); // same block as p_c even without a direct solver!
-
-    variables.insert(variables.begin()+2,
-                     VariableDeclaration<dim>(
-                       "compaction pressure",
-                       melt_parameters.use_discontinuous_p_c
-                       ?
-                       std::shared_ptr<FiniteElement<dim>>(
-                         std::make_shared<FE_DGP<dim>>(parameters.stokes_velocity_degree-1))
-                       :
-                       std::shared_ptr<FiniteElement<dim>>(
-                         std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree-1)),
-                       1,
-                       1));
-
-    variables.insert(variables.begin()+3,
-                     VariableDeclaration<dim>("fluid velocity",
-                                              std::make_shared<FE_Q<dim>>(parameters.stokes_velocity_degree),
-                                              dim,
-                                              1));
-
-  }
-
-
-
-  template <int dim>
-  void
-  MeltHandler<dim>::
-  set_assemblers (Assemblers::Manager<dim> &assemblers) const
-  {
-    assemblers.stokes_preconditioner.push_back(std::make_unique<Assemblers::MeltStokesPreconditioner<dim>> ());
-    assemblers.stokes_system.push_back(std::make_unique<Assemblers::MeltStokesSystem<dim>> ());
-
-    AssertThrow((this->get_parameters().formulation_mass_conservation ==
-                 Parameters<dim>::Formulation::MassConservation::isentropic_compression) ||
-                (this->get_parameters().formulation_mass_conservation ==
-                 Parameters<dim>::Formulation::MassConservation::incompressible),
-                ExcMessage("The melt implementation currently only supports the isentropic compression "
-                           "approximation or the incompressible formulation of the mass conservation equation."));
-
-    // add the boundary integral for melt migration
-    assemblers.stokes_system_assembler_on_boundary_face_properties.need_face_material_model_data = true;
-    assemblers.stokes_system_assembler_on_boundary_face_properties.needed_update_flags = (update_values  | update_quadrature_points |
-        update_normal_vectors | update_gradients |
-        update_JxW_values);
-
-
-    assemblers.stokes_system_on_boundary_face.push_back(
-      std::make_unique<aspect::Assemblers::MeltStokesSystemBoundary<dim>>());
-
-    // add the terms for traction boundary conditions
-    if (!this->get_boundary_traction_manager().get_active_boundary_traction_names().empty())
-      {
-        assemblers.stokes_system_on_boundary_face.push_back(
-          std::make_unique<Assemblers::MeltBoundaryTraction<dim>> ());
-      }
-
-    // add the terms necessary to normalize the pressure
-    if (this->pressure_rhs_needs_compatibility_modification())
-      {
-        assemblers.stokes_system.push_back(
-          std::make_unique<Assemblers::MeltPressureRHSCompatibilityModification<dim>> ());
-      }
-
-    for (unsigned int i=0; i<1+this->introspection().n_compositional_fields; ++i)
-      {
-        if ((i==0 && this->get_parameters().temperature_method == Parameters<dim>::AdvectionFieldMethod::fem_field)
-            ||
-            (i>0 && this->get_parameters().compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_field)
-            ||
-            (i>0 && this->get_parameters().compositional_field_methods[i-1] == Parameters<dim>::AdvectionFieldMethod::fem_melt_field))
-          assemblers.advection_system[i].push_back(
-            std::make_unique<Assemblers::MeltAdvectionSystem<dim>> ());
-
-        if (this->get_parameters().fixed_heat_flux_boundary_indicators.size() != 0)
-          {
-            assemblers.advection_system_on_boundary_face[i].push_back(
-              std::make_unique<aspect::Assemblers::AdvectionSystemBoundaryHeatFlux<dim>>());
-            assemblers.advection_system_assembler_on_face_properties[0].need_face_material_model_data = true;
-            assemblers.advection_system_assembler_on_face_properties[0].need_face_finite_element_evaluation = true;
-          }
-      }
-  }
-
-
-  namespace Melt
-  {
-    template <int dim>
-    void
-    Parameters<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Melt settings");
-      {
-        prm.declare_entry ("Melt scaling factor threshold", "1e-7",
-                           Patterns::Double (),
-                           "The factor by how much the Darcy coefficient K\\_D in a cell can be smaller than "
-                           "the reference Darcy coefficient for this cell still to be considered a melt cell "
-                           "(for which the melt transport equations are solved). For smaller Darcy coefficients, "
-                           "the Stokes equations (without melt) are solved instead. Only used if "
-                           "``Include melt transport'' is true. ");
-        prm.declare_entry ("Heat advection by melt", "false",
-                           Patterns::Bool (),
-                           "Whether to use a porosity weighted average of the melt and solid velocity "
-                           "to advect heat in the temperature equation or not. If this is set to true, "
-                           "additional terms are assembled on the left-hand side of the temperature "
-                           "advection equation. Only used if Include melt transport is true. "
-                           "If this is set to false, only the solid velocity is used (as in models "
-                           "without melt migration).");
-        prm.declare_entry ("Use discontinuous compaction pressure", "true",
-                           Patterns::Bool (),
-                           "Whether to use a discontinuous element for the compaction pressure or not. "
-                           "From our preliminary tests, continuous elements seem to work better in models "
-                           "where the porosity is > 0 everywhere in the domain, and discontinuous elements "
-                           "work better in models where in parts of the domain the porosity = 0.");
-        prm.declare_entry ("Average melt velocity", "true",
-                           Patterns::Bool (),
-                           "Whether to cell-wise average the material properties that are used to "
-                           "compute the melt velocity or not. The melt velocity is computed as the "
-                           "sum of the solid velocity and the phase separation flux "
-                           "$ - K_D / \\phi (\\nabla p_f - \\rho_f \\mathbf g)$. "
-                           "If this parameter is set to true, $K_D$ and $\\phi$ will be averaged "
-                           "cell-wise in the computation of the phase separation flux. "
-                           "This is useful because in some models the melt velocity can have spikes "
-                           "close to the interface between regions of melt and no melt, as both $K_D$ "
-                           "and $\\phi$ go to zero for vanishing melt fraction. As the melt velocity is "
-                           "used for computing the time step size, and in models that use heat "
-                           "transport by melt or shear heating of melt, setting this parameter to true "
-                           "can speed up the model and make it mode stable. In computations where "
-                           "accuracy and convergence behavior of the melt velocity is important "
-                           "(like in benchmark cases with an analytical solution), this parameter "
-                           "should probably be set to 'false'.");
-      }
-      prm.leave_subsection();
-
-      BoundaryFluidPressure::declare_parameters<dim> (prm);
-    }
-
-    template <int dim>
-    void
-    Parameters<dim>::
-    parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Melt settings");
-      {
-        melt_scaling_factor_threshold = prm.get_double("Melt scaling factor threshold");
-        heat_advection_by_melt = prm.get_bool("Heat advection by melt");
-        use_discontinuous_p_c = prm.get_bool("Use discontinuous compaction pressure");
-        average_melt_velocity = prm.get_bool("Average melt velocity");
-      }
-      prm.leave_subsection();
-    }
-  }
-
-  template <int dim>
-  MeltHandler<dim>::MeltHandler (ParameterHandler &prm)
-    :
-    boundary_fluid_pressure(BoundaryFluidPressure::create_boundary_fluid_pressure<dim>(prm))
-  {
-    CitationInfo::add("melt");
-    melt_parameters.parse_parameters(prm);
-    boundary_fluid_pressure->parse_parameters(prm);
-  }
-
-
-  template <int dim>
-  void
-  MeltHandler<dim>::initialize () const
-  {
-    // The additional terms in the temperature systems have not been ported
-    // to the DG formulation:
-    AssertThrow(!this->get_parameters().use_discontinuous_temperature_discretization &&
-                !this->get_parameters().have_discontinuous_composition_discretization,
-                ExcMessage("Using discontinuous elements for temperature "
-                           "or composition in models with melt transport is currently not implemented.") );
-    if (melt_parameters.use_discontinuous_p_c)
-      AssertThrow(!this->model_has_prescribed_stokes_solution(),
-                  ExcMessage("You can not use a discontinuous p_c in a model "
-                             "with a prescribed Stokes solution."));
-    // We can not have a DG p_f.
-    AssertThrow(!this->get_parameters().use_locally_conservative_discretization,
-                ExcMessage ("Discontinuous elements for the fluid pressure "
-                            "are not supported in models with melt transport."));
-  }
-
-
-  template <int dim>
-  void
-  MeltHandler<dim>::initialize_simulator (const Simulator<dim> &simulator_object)
-  {
-    this->SimulatorAccess<dim>::initialize_simulator(simulator_object);
-    if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(boundary_fluid_pressure.get()))
-      sim->initialize_simulator (simulator_object);
-    boundary_fluid_pressure->initialize ();
-  }
-
-
-  template <int dim>
-  void
-  MeltHandler<dim>::
-  create_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output)
-  {
-    if (output.template get_additional_output<MaterialModel::MeltOutputs<dim>>() != nullptr)
-      return;
-
-    const unsigned int n_comp = output.reaction_terms[0].size();
-    output.additional_outputs.push_back(
-      std::make_unique<MaterialModel::MeltOutputs<dim>> (output.n_evaluation_points(), n_comp));
-  }
-
-
-  template <int dim>
-  void
-  MeltHandler<dim>::
-  apply_free_surface_stabilization_with_melt (const double free_surface_theta,
-                                              const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                              internal::Assembly::Scratch::StokesSystem<dim>       &scratch,
-                                              internal::Assembly::CopyData::StokesSystem<dim>      &data) const
-  {
-    const std::set<types::boundary_id> tmp_boundary_indicators_requiring_stabilization = this->get_mesh_deformation_handler().get_boundary_indicators_requiring_stabilization();
-    if (tmp_boundary_indicators_requiring_stabilization.empty())
-      return;
-
-    const unsigned int n_face_q_points = scratch.face_finite_element_values.n_quadrature_points;
-    const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-
-    // only apply on mesh deformation surfaces that require stabilization
-    if (cell->at_boundary() && cell->is_locally_owned())
-      for (const unsigned int face_no : cell->face_indices())
-        if (cell->face(face_no)->at_boundary())
-          {
-            const types::boundary_id boundary_indicator
-              = cell->face(face_no)->boundary_id();
-
-            if (tmp_boundary_indicators_requiring_stabilization.find(boundary_indicator) == tmp_boundary_indicators_requiring_stabilization.end())
-              continue;
-
-            scratch.face_finite_element_values.reinit(cell, face_no);
-
-            scratch.face_material_model_inputs.reinit  (scratch.face_finite_element_values,
-                                                        cell,
-                                                        this->introspection(),
-                                                        this->get_solution());
-
-            this->get_material_model().evaluate(scratch.face_material_model_inputs, scratch.face_material_model_outputs);
-
-            const unsigned int p_f_component_index = this->introspection().variable("fluid pressure").first_component_index;
-            const unsigned int p_c_component_index = this->introspection().variable("compaction pressure").first_component_index;
-
-            for (unsigned int q_point = 0; q_point < n_face_q_points; ++q_point)
-              {
-                for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-                  {
-                    const unsigned int component_index_i = this->get_fe().system_to_component_index(i).first;
-
-                    if (Assemblers::is_velocity_or_pressures(this->introspection(),p_c_component_index,p_f_component_index,component_index_i))
-                      {
-                        scratch.phi_u[i_stokes] = scratch.face_finite_element_values[this->introspection().extractors.velocities].value(i, q_point);
-                        ++i_stokes;
-                      }
-                    ++i;
-                  }
-
-                const Tensor<1,dim>
-                gravity = this->get_gravity_model().gravity_vector(scratch.face_finite_element_values.quadrature_point(q_point));
-                const double g_norm = gravity.norm();
-
-                // construct the relevant vectors
-                const Tensor<1,dim> n_hat = scratch.face_finite_element_values.normal_vector(q_point);
-                const Tensor<1,dim> g_hat = (g_norm == 0.0 ? Tensor<1,dim>() : gravity/g_norm);
-
-                const double pressure_perturbation = scratch.face_material_model_outputs.densities[q_point] *
-                                                     this->get_timestep() * free_surface_theta * g_norm;
-
-                // see Kaus et al 2010 for details of the stabilization term
-                for (unsigned int i=0; i< stokes_dofs_per_cell; ++i)
-                  for (unsigned int j=0; j< stokes_dofs_per_cell; ++j)
-                    {
-                      // The fictive stabilization stress is (phi_u[i].g)*(phi_u[j].n)
-                      const double stress_value = - pressure_perturbation
-                                                  * (scratch.phi_u[i] * g_hat) * (scratch.phi_u[j] * n_hat)
-                                                  * scratch.face_finite_element_values.JxW(q_point);
-
-                      data.local_matrix(i,j) += stress_value;
-                    }
-              }
-          }
-
-
-  }
-}
-
-
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-
-#define INSTANTIATE(dim) \
-  \
-  template \
-  class \
-  MeltHandler<dim>; \
-  \
-  namespace MaterialModel \
-  { \
-    template \
-    class \
-    MeltInputs<dim>; \
-  } \
-  \
-  namespace Melt \
-  { \
-    template struct Parameters<dim>; \
-  } \
-  namespace Assemblers \
-  { \
-    template class MeltInterface<dim>; \
-    template class MeltStokesPreconditioner<dim>; \
-    template class MeltStokesSystem<dim>; \
-    template class MeltStokesSystemBoundary<dim>; \
-    template class MeltAdvectionSystem<dim>; \
-    template class MeltPressureRHSCompatibilityModification<dim>; \
-    template class MeltBoundaryTraction<dim>; \
-  }
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-
-}
diff --git a/source/simulator/newton.cc.bak b/source/simulator/newton.cc.bak
deleted file mode 100644
index 9297ebd3c15..00000000000
--- a/source/simulator/newton.cc.bak
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
-  Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/newton.h>
-#include <aspect/simulator/assemblers/advection.h>
-#include <aspect/simulator/assemblers/stokes.h>
-
-#include <aspect/simulator.h>
-#include <aspect/citation_info.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    MaterialModelDerivatives<dim>::
-    MaterialModelDerivatives (const unsigned int n_points)
-      : viscosity_derivative_wrt_pressure(n_points, numbers::signaling_nan<double>())
-      , viscosity_derivative_wrt_strain_rate(n_points, numbers::signaling_nan<SymmetricTensor<2,dim>>())
-      , viscosity_derivative_averaging_weights(n_points, numbers::signaling_nan<double>())
-    {}
-  }
-
-
-
-  template <int dim>
-  void
-  NewtonHandler<dim>::
-  set_assemblers (Assemblers::Manager<dim> &assemblers) const
-  {
-    assemblers.stokes_preconditioner.push_back(std::make_unique<aspect::Assemblers::NewtonStokesPreconditioner<dim>>());
-    assemblers.stokes_system.push_back(std::make_unique<aspect::Assemblers::NewtonStokesIncompressibleTerms<dim>>());
-
-    if (this->get_material_model().is_compressible())
-      {
-        // The compressible part of the preconditioner is only necessary if we use the simplified A block
-        if (this->get_parameters().use_full_A_block_preconditioner == false)
-          assemblers.stokes_preconditioner.push_back(
-            std::make_unique<aspect::Assemblers::StokesCompressiblePreconditioner<dim>>());
-
-        assemblers.stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::NewtonStokesCompressibleStrainRateViscosityTerm<dim>>());
-      }
-
-    if (this->get_parameters().formulation_mass_conservation ==
-        Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile)
-      {
-        assemblers.stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::NewtonStokesImplicitReferenceDensityCompressibilityTerm<dim>>());
-      }
-    else if (this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::reference_density_profile)
-      {
-        assemblers.stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::NewtonStokesReferenceDensityCompressibilityTerm<dim>>());
-      }
-    else if (this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::incompressible)
-      {
-        // do nothing, because we assembled div u =0 above already
-      }
-    else if (this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::isentropic_compression)
-      {
-        assemblers.stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::NewtonStokesIsentropicCompressionTerm<dim>>());
-      }
-    else if (this->get_parameters().formulation_mass_conservation ==
-             Parameters<dim>::Formulation::MassConservation::projected_density_field)
-      {
-        CitationInfo::add("pda");
-        assemblers.stokes_system.push_back(
-          std::make_unique<aspect::Assemblers::NewtonStokesProjectedDensityFieldTerm<dim>>());
-      }
-    else
-      AssertThrow(false,
-                  ExcMessage("Unknown mass conservation equation approximation. There is no assembler"
-                             " defined that handles this formulation."));
-
-    // add the terms for traction boundary conditions
-    if (!this->get_boundary_traction_manager().get_active_boundary_traction_names().empty())
-      {
-        assemblers.stokes_system_on_boundary_face.push_back(
-          std::make_unique<aspect::Assemblers::StokesBoundaryTraction<dim>>());
-      }
-
-    // add the terms necessary to normalize the pressure
-    if (this->pressure_rhs_needs_compatibility_modification())
-      assemblers.stokes_system.push_back(
-        std::make_unique<aspect::Assemblers::StokesPressureRHSCompatibilityModification<dim>>());
-  }
-
-
-
-  template <int dim>
-  void
-  NewtonHandler<dim>::
-  create_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &output)
-  {
-    if (output.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>() != nullptr)
-      return;
-
-    output.additional_outputs.push_back(
-      std::make_unique<MaterialModel::MaterialModelDerivatives<dim>>(output.n_evaluation_points()));
-  }
-
-
-
-  namespace Newton
-  {
-    std::string
-    to_string(const Newton::Parameters::Stabilization preconditioner_stabilization)
-    {
-      switch (preconditioner_stabilization)
-        {
-          case Newton::Parameters::Stabilization::SPD:
-            return "SPD";
-          case Newton::Parameters::Stabilization::PD:
-            return "PD";
-          case Newton::Parameters::Stabilization::symmetric:
-            return "symmetric";
-          case Newton::Parameters::Stabilization::none:
-            return "none";
-          default:
-            Assert(false,ExcNotImplemented());
-            return "";
-        }
-    }
-
-
-
-    void
-    Parameters::
-    declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Solver parameters");
-      {
-        prm.enter_subsection ("Newton solver parameters");
-        {
-          prm.declare_entry ("Nonlinear Newton solver switch tolerance", "1e-5",
-                             Patterns::Double(0., 1.),
-                             "A relative tolerance with respect to the residual of the first "
-                             "iteration, up to which the nonlinear Picard solver will iterate, "
-                             "before changing to the Newton solver.");
-
-          prm.declare_entry ("Max pre-Newton nonlinear iterations", "10",
-                             Patterns::Integer (0),
-                             "If the 'Nonlinear Newton solver switch tolerance' is reached before the "
-                             "maximal number of Picard iterations, then the solver switches to Newton "
-                             "solves anyway.");
-
-          prm.declare_entry ("Max Newton line search iterations", "5",
-                             Patterns::Integer (0),
-                             "The maximum number of line search iterations allowed. If the "
-                             "criterion is not reached after this number of iterations, we apply "
-                             "the scaled increment even though it does not satisfy the necessary "
-                             "criteria and simply continue with the next Newton iteration.");
-
-          prm.declare_entry ("Use Newton residual scaling method", "false",
-                             Patterns::Bool (),
-                             "This method allows to slowly introduce the derivatives based on the improvement "
-                             "of the residual. If set to false, the scaling factor for the Newton derivatives "
-                             "is set to one immediately when switching on the Newton solver. When this is set to "
-                             "true, the derivatives are slowly introduced by the following equation: $\\max(0.0, "
-                             "(1.0-(residual/switch\\_initial\\_residual)))$, where switch\\_initial\\_residual is the "
-                             "residual at the time when the Newton solver is switched on.");
-
-          prm.declare_entry ("Maximum linear Stokes solver tolerance", "1e-2",
-                             Patterns::Double (0., 1.),
-                             "The linear Stokes solver tolerance is dynamically chosen for the Newton solver, based "
-                             "on the Eisenstat Walker (1994) paper (https://doi.org/10.1137/0917003), equation 2.2. "
-                             "Because this value can become larger than one, we limit this value by this parameter.");
-
-          prm.declare_entry ("Stabilization preconditioner", "SPD",
-                             Patterns::Selection ("SPD|PD|symmetric|none"),
-                             "This parameters allows for the stabilization of the preconditioner. If one derives the Newton "
-                             "method without any modifications, the matrix created for the preconditioning is not necessarily "
-                             "Symmetric Positive Definite. This is problematic (see \\cite{fraters:etal:2019}). When `none' is chosen, "
-                             "the preconditioner is not stabilized. The `symmetric' parameters symmetrizes the matrix, and `PD' makes "
-                             "the matrix Positive Definite. `SPD' is the full stabilization, where the matrix is guaranteed Symmetric "
-                             "Positive Definite.");
-
-          prm.declare_entry ("Stabilization velocity block", "SPD",
-                             Patterns::Selection ("SPD|PD|symmetric|none"),
-                             "This parameters allows for the stabilization of the velocity block. If one derives the Newton "
-                             "method without any modifications, the matrix created for the velocity block is not necessarily "
-                             "Symmetric Positive Definite. This is problematic (see \\cite{fraters:etal:2019}). When `none' is chosen, "
-                             "the velocity block is not stabilized. The `symmetric' parameters symmetrizes the matrix, and `PD' makes "
-                             "the matrix Positive Definite. `SPD' is the full stabilization, where the matrix is guaranteed Symmetric "
-                             "Positive Definite.");
-
-          prm.declare_entry ("Use Newton failsafe", "false",
-                             Patterns::Bool (),
-                             "When this parameter is true and the linear solver fails, we try again, but now with SPD stabilization "
-                             "for both the preconditioner and the velocity block. The SPD stabilization will remain active until "
-                             "the next timestep, when the default values are restored.");
-
-
-          prm.declare_entry ("SPD safety factor", "0.9",
-                             Patterns::Double (0., 1.),
-                             "When stabilizing the Newton matrix, we can encounter situations where the coefficient inside the elliptic (top-left) "
-                             "block becomes negative or zero. This coefficient has the form $1+x$ where $x$ can sometimes be smaller than $-1$. In "
-                             "this case, the top-left block of the matrix is no longer positive definite, and both preconditioners and iterative "
-                             "solvers may fail. To prevent this, the stabilization computes an $\\alpha$ so that $1+\\alpha x$ is never negative "
-                             "and so that always "
-                             "$0\\le \\alpha \\le 1$.  On the other hand, we also want to stay away from $1+\\alpha x=0$, and so modify the choice of "
-                             "$\\alpha$ by a factor $c$ between zero and one so that if $c<1$, we are "
-                             "assured that $1+\\alpha x>0$, i.e., bounded away from zero. If $c=1$, we allow $1+\\alpha x=0$, i.e., an "
-                             "unsafe situation. If $c=0$, then $\\alpha$ is always set to zero which guarantees the desired property that "
-                             "$1+\\alpha x=1>0$, but at the cost of a diminished convergence rate of the Newton method.");
-
-          prm.declare_entry ("Use Eisenstat Walker method for Picard iterations", "false",
-                             Patterns::Bool(),
-                             "If set to true, the Picard iteration uses the Eisenstat Walker method to determine how accurately linear systems need "
-                             "to be solved. The Picard iteration is used, for example, in the first few iterations of the Newton method before the "
-                             "matrix is built including derivatives of the model, since the Picard iteration generally converges even from points "
-                             "where Newton's method does not. "
-                             "\n\n"
-                             "Once derivatives are used in a Newton method, \\aspect{} always uses the Eisenstat Walker method.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-
-    void
-    Parameters::
-    parse_parameters (ParameterHandler &prm)
-    {
-      CitationInfo::add("NewtonSolver");
-      prm.enter_subsection ("Solver parameters");
-      {
-        prm.enter_subsection ("Newton solver parameters");
-        {
-          nonlinear_switch_tolerance = prm.get_double("Nonlinear Newton solver switch tolerance");
-          max_pre_newton_nonlinear_iterations = prm.get_integer ("Max pre-Newton nonlinear iterations");
-          max_newton_line_search_iterations = prm.get_integer ("Max Newton line search iterations");
-          use_newton_residual_scaling_method = prm.get_bool("Use Newton residual scaling method");
-          maximum_linear_stokes_solver_tolerance = prm.get_double("Maximum linear Stokes solver tolerance");
-          std::string preconditioner_stabilization_string = prm.get("Stabilization preconditioner");
-          if (preconditioner_stabilization_string == "SPD")
-            preconditioner_stabilization = Stabilization::SPD;
-          else if (preconditioner_stabilization_string == "PD")
-            preconditioner_stabilization = Stabilization::PD;
-          else if (preconditioner_stabilization_string == "symmetric")
-            preconditioner_stabilization = Stabilization::symmetric;
-          else if (preconditioner_stabilization_string == "none")
-            preconditioner_stabilization = Stabilization::none;
-
-          std::string velocity_block_stabilization_string = prm.get("Stabilization velocity block");
-          if (velocity_block_stabilization_string == "SPD")
-            velocity_block_stabilization = Stabilization::SPD;
-          else if (velocity_block_stabilization_string == "PD")
-            velocity_block_stabilization = Stabilization::PD;
-          else if (velocity_block_stabilization_string == "symmetric")
-            velocity_block_stabilization = Stabilization::symmetric;
-          else if (velocity_block_stabilization_string == "none")
-            velocity_block_stabilization = Stabilization::none;
-
-          use_Newton_failsafe = prm.get_bool("Use Newton failsafe");
-          SPD_safety_factor = prm.get_double("SPD safety factor");
-          use_Eisenstat_Walker_method_for_Picard_iterations = prm.get_bool("Use Eisenstat Walker method for Picard iterations");
-
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-    }
-  }
-}
-
-
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-
-#define INSTANTIATE(dim) \
-  \
-  template \
-  class \
-  NewtonHandler<dim>; \
-  \
-  namespace MaterialModel \
-  { \
-    template \
-    class \
-    MaterialModelDerivatives<dim>; \
-  }
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-
-}
diff --git a/source/simulator/nullspace.cc.bak b/source/simulator/nullspace.cc.bak
deleted file mode 100644
index ad692cf6185..00000000000
--- a/source/simulator/nullspace.cc.bak
+++ /dev/null
@@ -1,522 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-
-#include <deal.II/base/tensor_function.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace internal
-  {
-
-    /**
-     * A class we use when setting up the data structures for nullspace removal
-     * of the rotations in spherical or annular shells.
-     */
-    template <int dim>
-    class Rotation : public TensorFunction<1,dim>
-    {
-      private:
-        const Tensor<1,dim> axis;
-
-      public:
-        // Constructor for TensorFunction that takes cartesian direction (1,2, or 3)
-        // and creates a solid body rotation around that axis.
-        Rotation(const unsigned int a)
-          :
-          axis(Tensor<1,dim>(Point<dim>::unit_vector(a)))
-        {}
-
-        // Constructor for TensorFunction that takes an axis
-        // and creates a solid body rotation around that axis.
-        Rotation(const Tensor<1,dim> &rotation_axis)
-          :
-          axis(rotation_axis)
-        {}
-
-        Tensor<1,dim> value (const Point<dim> &p) const override
-        {
-          if ( dim == 2)
-            return cross_product_2d(p);
-          else
-            return cross_product_3d(axis, p);
-        }
-    };
-
-
-    /**
-     * A class we use when setting up the data structures for nullspace removal
-     * of the translations in box-like geometries.
-     */
-    template <int dim>
-    class Translation : public TensorFunction<1,dim>
-    {
-      private:
-        const Tensor<1,dim> translation;
-
-      public:
-        // Constructor for TensorFunction that takes a Cartesian direction (1,2, or 3)
-        // and creates a translation along that axis
-        Translation(const unsigned int d)
-          :
-          translation( Point<dim>::unit_vector(d) )
-        {}
-
-        // Constructor for TensorFunction that takes a vector
-        // and creates a translation along that vector
-        Translation(const Tensor<1,dim> &t)
-          :
-          translation(t)
-        {}
-
-        Tensor<1,dim> value(const Point<dim> &) const override
-        {
-          return translation;
-        }
-    };
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::setup_nullspace_constraints(AffineConstraints<double> &constraints)
-  {
-    if (parameters.nullspace_removal & NullspaceRemoval::any_translation)
-      {
-        // Note: We want to add a single Dirichlet zero constraint for each
-        // translation direction. This is complicated by the fact that we need to
-        // find a DoF that is not already constrained. In parallel the constraint
-        // needs to be added on all processors where it is locally_relevant and
-        // all processors need to agree on the index.
-
-        // First find candidates for DoF indices to constrain for each velocity component.
-        std::array<types::global_dof_index,dim> vel_idx;
-        {
-          for (types::global_dof_index &idx : vel_idx)
-            idx = numbers::invalid_dof_index;
-
-          unsigned int n_left_to_find = dim;
-
-          std::vector<types::global_dof_index> local_dof_indices (finite_element.dofs_per_cell);
-          typename DoFHandler<dim>::active_cell_iterator cell;
-          for (const auto &cell : dof_handler.active_cell_iterators())
-            if (cell->is_locally_owned())
-              {
-                cell->get_dof_indices (local_dof_indices);
-
-                for (unsigned int i=0; i<finite_element.dofs_per_cell; ++i)
-                  {
-                    const unsigned int component = finite_element.system_to_component_index(i).first;
-
-                    if (component < introspection.component_indices.velocities[0]
-                        || component > introspection.component_indices.velocities[dim-1])
-                      continue; // only look at velocity
-
-                    const unsigned int velocity_component = component - introspection.component_indices.velocities[0];
-
-                    if (vel_idx[velocity_component] != numbers::invalid_dof_index)
-                      continue; // already found one
-
-                    const types::global_dof_index idx = local_dof_indices[i];
-
-                    if (constraints.can_store_line(idx) && !constraints.is_constrained(idx))
-                      {
-                        vel_idx[velocity_component] = idx;
-                        --n_left_to_find;
-                      }
-
-                    // are we done searching?
-                    if (n_left_to_find == 0)
-                      goto after_cell_loop; // exit both nested loops at the same time
-                  }
-              }
-
-        after_cell_loop:
-          ;
-        }
-
-
-        const unsigned int flags[] = {(NullspaceRemoval::linear_momentum_x
-                                       |NullspaceRemoval::net_translation_x),
-                                      (NullspaceRemoval::linear_momentum_y
-                                       |NullspaceRemoval::net_translation_y),
-                                      (NullspaceRemoval::linear_momentum_z
-                                       |NullspaceRemoval::net_translation_z)
-                                     };
-
-        for (unsigned int d=0; d<dim; ++d)
-          if (parameters.nullspace_removal & flags[d])
-            {
-              // Make a reduction to find the smallest index (processors that
-              // found a larger candidate just happened to not be able to store
-              // that index with the minimum value). Note that it is possible that
-              // some processors might not be able to find a potential DoF, for
-              // example because they don't own any DoFs. On those processors we
-              // will use dof_handler.n_dofs() when building the minimum (larger
-              // than any valid DoF index).
-              const types::global_dof_index global_idx = dealii::Utilities::MPI::min(
-                                                           (vel_idx[d] != numbers::invalid_dof_index)
-                                                           ?
-                                                           vel_idx[d]
-                                                           :
-                                                           dof_handler.n_dofs(),
-                                                           mpi_communicator);
-
-              Assert(global_idx < dof_handler.n_dofs(),
-                     ExcMessage("Error, couldn't find a velocity DoF to constrain."));
-
-              // Finally set this DoF to zero (if the current MPI process
-              // cares about it):
-              if (constraints.can_store_line(global_idx))
-                {
-                  Assert(!constraints.is_constrained((global_idx)),
-                         ExcInternalError());
-#if DEAL_II_VERSION_GTE(9,6,0)
-                  constraints.constrain_dof_to_zero(global_idx);
-#else
-                  constraints.add_line(global_idx);
-#endif
-                }
-            }
-      }
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::remove_nullspace(LinearAlgebra::BlockVector &relevant_dst,
-                                        LinearAlgebra::BlockVector &tmp_distributed_stokes)
-  {
-    if (parameters.nullspace_removal & NullspaceRemoval::angular_momentum)
-      {
-        remove_net_angular_momentum( /* use_constant_density = */ false, // remove net momentum
-                                                                  relevant_dst,
-                                                                  tmp_distributed_stokes);
-      }
-    if (parameters.nullspace_removal & NullspaceRemoval::net_rotation)
-      {
-        remove_net_angular_momentum( /* use_constant_density = */ true, // remove net rotation
-                                                                  relevant_dst,
-                                                                  tmp_distributed_stokes);
-      }
-    if (parameters.nullspace_removal & NullspaceRemoval::net_surface_rotation)
-      {
-        remove_net_angular_momentum( /* use_constant_density = */ true, // remove net rotation
-                                                                  relevant_dst,
-                                                                  tmp_distributed_stokes,
-                                                                  /* limit_to_top_faces = */ true);
-      }
-
-    if (parameters.nullspace_removal & NullspaceRemoval::linear_momentum)
-      {
-        remove_net_linear_momentum( /* use_constant_density = */ false, // remove net momentum
-                                                                 relevant_dst,
-                                                                 tmp_distributed_stokes);
-      }
-    if (parameters.nullspace_removal & NullspaceRemoval::net_translation)
-      {
-        remove_net_linear_momentum( /* use_constant_density = */ true, // remove net translation
-                                                                 relevant_dst,
-                                                                 tmp_distributed_stokes);
-      }
-  }
-
-  template <int dim>
-  void Simulator<dim>::remove_net_linear_momentum( const bool use_constant_density,
-                                                   LinearAlgebra::BlockVector &relevant_dst,
-                                                   LinearAlgebra::BlockVector &tmp_distributed_stokes )
-  {
-    Assert(introspection.block_indices.velocities != introspection.block_indices.pressure,
-           ExcNotImplemented());
-
-    // compute and remove net linear momentum from velocity field, by computing
-    // \int \rho (v + v_const) = 0
-    const Quadrature<dim> &quadrature = introspection.quadratures.velocities;
-    const unsigned int n_q_points = quadrature.size();
-    FEValues<dim> fe(*mapping, finite_element, quadrature,
-                     UpdateFlags(update_quadrature_points | update_JxW_values | update_values | update_gradients));
-
-    Tensor<1,dim> local_momentum;
-    double local_mass = 0.0;
-
-    // loop over all local cells
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          fe.reinit (cell);
-
-          // get the density at each quadrature point if necessary
-          MaterialModel::MaterialModelInputs<dim> in(n_q_points,
-                                                     introspection.n_compositional_fields);
-          MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
-                                                       introspection.n_compositional_fields);
-
-          if (use_constant_density)
-            {
-              // get only the velocity at each quadrature point
-              fe[introspection.extractors.velocities].get_function_values (relevant_dst, in.velocity);
-            }
-          else
-            {
-              // get all material inputs including velocity and evaluate for density
-              in.reinit(fe,cell,introspection,relevant_dst);
-              in.requested_properties = MaterialModel::MaterialProperties::density;
-              material_model->evaluate(in, out);
-            }
-
-          // actually compute the momentum and mass
-          for (unsigned int k=0; k<n_q_points; ++k)
-            {
-              // get the density at this quadrature point
-              const double rho = (use_constant_density ? 1.0 : out.densities[k]);
-              const double JxW = fe.JxW(k);
-
-              local_momentum += in.velocity[k] * rho * JxW;
-              local_mass += rho * JxW;
-            }
-        }
-
-    // Calculate the total mass and velocity correction
-    const double mass = Utilities::MPI::sum(local_mass, mpi_communicator);
-    Tensor<1,dim> velocity_correction = Utilities::MPI::sum(local_momentum, mpi_communicator) / mass;
-
-    // We may only want to remove the nullspace for a single component, so zero out
-    // the velocity correction if it is not selected by the NullspaceRemoval flag
-    if (use_constant_density) // disable translation correction
-      {
-        if ( !(parameters.nullspace_removal & NullspaceRemoval::net_translation_x) )
-          velocity_correction[0] = 0.0;  // don't correct x translation
-        if ( !(parameters.nullspace_removal & NullspaceRemoval::net_translation_y) )
-          velocity_correction[1] = 0.0;  // don't correct y translation
-        if ( !(parameters.nullspace_removal & NullspaceRemoval::net_translation_z) && dim == 3 )
-          velocity_correction[2] = 0.0;  // don't correct z translation
-      }
-    else // disable momentum correction
-      {
-        if ( !(parameters.nullspace_removal & NullspaceRemoval::linear_momentum_x) )
-          velocity_correction[0] = 0.0;  // don't correct x translation
-        if ( !(parameters.nullspace_removal & NullspaceRemoval::linear_momentum_y) )
-          velocity_correction[1] = 0.0;  // don't correct y translation
-        if ( !(parameters.nullspace_removal & NullspaceRemoval::linear_momentum_z) && dim == 3 )
-          velocity_correction[2] = 0.0;  // don't correct z translation
-      }
-
-    // vector for storing the correction to the velocity field
-    LinearAlgebra::Vector correction(tmp_distributed_stokes.block(introspection.block_indices.velocities));
-
-    // Now construct a translation vector with the desired rate and subtract it from our vector
-    internal::Translation<dim> translation( velocity_correction );
-    interpolate_onto_velocity_system(translation, correction);
-    tmp_distributed_stokes.block(introspection.block_indices.velocities).add(-1.0,correction);
-
-    // copy into the locally relevant vector
-    relevant_dst.block(introspection.block_indices.velocities) =
-      tmp_distributed_stokes.block(introspection.block_indices.velocities);
-  }
-
-
-
-  template <int dim>
-  RotationProperties<dim>
-  Simulator<dim>::compute_net_angular_momentum(const bool use_constant_density,
-                                               const LinearAlgebra::BlockVector &solution,
-                                               const bool limit_to_top_faces) const
-  {
-    // compute the momentum from velocity field, by computing
-    // \int \rho u \cdot r_orth = \omega  * \int \rho x^2    ( 2 dimensions)
-    // \int \rho r \times u =  I \cdot \omega  (3 dimensions)
-
-    const Quadrature<dim> &quadrature = introspection.quadratures.velocities;
-    const Quadrature<dim-1> &surface_quadrature = introspection.face_quadratures.velocities;
-
-    const unsigned int n_q_points = (limit_to_top_faces == false) ? quadrature.size() : surface_quadrature.size();
-    UpdateFlags flags = update_quadrature_points | update_JxW_values | update_values | update_gradients;
-
-    FEValues<dim> fe_values (*mapping, finite_element, quadrature, flags);
-    FEFaceValues<dim> fe_face_values (*mapping, finite_element, surface_quadrature, flags);
-    FEValuesBase<dim> &fe((limit_to_top_faces == false)
-                          ?
-                          dynamic_cast<FEValuesBase<dim> &>(fe_values)
-                          :
-                          dynamic_cast<FEValuesBase<dim> &>(fe_face_values));
-
-    // moment of inertia and angular momentum for 3d
-    SymmetricTensor<2,dim> local_moment_of_inertia;
-    Tensor<1,dim> local_angular_momentum;
-
-    // analogues to the moment of inertia and angular momentum for 2d
-    double local_scalar_moment_of_inertia = 0.0;
-    double local_scalar_angular_momentum = 0.0;
-
-    // Structures for evaluating the velocities and the material model
-    MaterialModel::MaterialModelInputs<dim> in(n_q_points,
-                                               introspection.n_compositional_fields);
-    MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
-                                                 introspection.n_compositional_fields);
-    in.requested_properties = MaterialModel::MaterialProperties::density;
-
-    // loop over all local cells
-    for (const auto &cell : dof_handler.active_cell_iterators())
-      if (cell->is_locally_owned())
-        {
-          if (limit_to_top_faces == false)
-            fe_values.reinit(cell);
-          else
-            {
-              // We only want the output at the top boundary, so only compute it if the current cell
-              // has a face at the top boundary.
-              bool cell_at_top_boundary = false;
-              for (const unsigned int f : cell->face_indices())
-                if (cell->at_boundary(f) &&
-                    (geometry_model->translate_id_to_symbol_name(cell->face(f)->boundary_id()) == "top"))
-                  {
-                    Assert(cell_at_top_boundary == false,
-                           ExcInternalError("Error, more than one top surface found in a cell."));
-
-                    cell_at_top_boundary = true;
-                    fe_face_values.reinit(cell, f);
-                  }
-
-              if (cell_at_top_boundary == false)
-                continue;
-            }
-
-          const std::vector<Point<dim>> &q_points = fe.get_quadrature_points();
-
-          if (use_constant_density == false)
-            {
-              // Set use_strain_rates to false since we don't need viscosity
-              in.reinit(fe, cell, introspection, solution);
-              material_model->evaluate(in, out);
-            }
-          else
-            {
-              // Get the velocity at each quadrature point
-              fe[introspection.extractors.velocities].get_function_values(solution, in.velocity);
-            }
-
-          // actually compute the moment of inertia and angular momentum
-          for (unsigned int k = 0; k < n_q_points; ++k)
-            {
-              // get the position and density at this quadrature point
-              const Point<dim> r_vec = q_points[k];
-              const double rho = (use_constant_density ? 1.0 : out.densities[k]);
-              const double JxW = fe.JxW(k);
-
-              if (dim == 2)
-                {
-                  // Get the velocity perpendicular to the position vector
-                  const Tensor<1, dim> r_perp = cross_product_2d(r_vec);
-
-                  local_scalar_angular_momentum += in.velocity[k] * r_perp * rho * JxW;
-                  local_scalar_moment_of_inertia += r_vec.norm_square() * rho * JxW;
-                }
-              else
-                {
-                  const Tensor<1, dim> r_cross_v = cross_product_3d(r_vec, in.velocity[k]);
-
-                  local_angular_momentum += r_cross_v * rho * JxW;
-                  local_moment_of_inertia += (r_vec.norm_square() * unit_symmetric_tensor<dim>() - symmetrize(outer_product(r_vec, r_vec))) * rho * JxW;
-                }
-            }
-        }
-
-    RotationProperties<dim> properties;
-
-    // Sum up the local contributions and solve for the overall rotation
-    if (dim == 2)
-      {
-        properties.scalar_moment_of_inertia = Utilities::MPI::sum(local_scalar_moment_of_inertia, mpi_communicator);
-        properties.scalar_angular_momentum = Utilities::MPI::sum(local_scalar_angular_momentum, mpi_communicator);
-        properties.scalar_rotation = properties.scalar_angular_momentum / properties.scalar_moment_of_inertia;
-      }
-    else
-      {
-        properties.tensor_moment_of_inertia = Utilities::MPI::sum(local_moment_of_inertia,
-                                                                  mpi_communicator);
-        properties.tensor_angular_momentum = Utilities::MPI::sum(local_angular_momentum, mpi_communicator );
-        const SymmetricTensor<2,dim> inverse_moment (invert(Tensor<2,dim>(properties.tensor_moment_of_inertia)));
-        properties.tensor_rotation = - inverse_moment * properties.tensor_angular_momentum;
-      }
-
-    return properties;
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::remove_net_angular_momentum( const bool use_constant_density,
-                                                    LinearAlgebra::BlockVector &relevant_dst,
-                                                    LinearAlgebra::BlockVector &tmp_distributed_stokes,
-                                                    const bool limit_to_top_faces)
-  {
-    Assert(introspection.block_indices.velocities != introspection.block_indices.pressure,
-           ExcNotImplemented());
-
-    RotationProperties<dim> rotation_properties = compute_net_angular_momentum(use_constant_density,
-                                                                               relevant_dst,
-                                                                               limit_to_top_faces);
-
-    // vector for storing the correction to the velocity field
-    LinearAlgebra::Vector correction(tmp_distributed_stokes.block(introspection.block_indices.velocities));
-
-    if (dim == 2)
-      {
-        // Now construct a rotation vector with the desired rate and subtract it from our vector
-        const internal::Rotation<dim> rot(0);
-        interpolate_onto_velocity_system(rot, correction);
-        tmp_distributed_stokes.block(introspection.block_indices.velocities).add(-1.0*rotation_properties.scalar_rotation,correction);
-      }
-    else
-      {
-        // Remove that rotation from the solution vector
-        const internal::Rotation<dim> rot(rotation_properties.tensor_rotation);
-        interpolate_onto_velocity_system(rot, correction);
-        tmp_distributed_stokes.block(introspection.block_indices.velocities).add(1.0,correction);
-      }
-
-    // copy into the locally relevant vector
-    relevant_dst.block(introspection.block_indices.velocities) =
-      tmp_distributed_stokes.block(introspection.block_indices.velocities);
-  }
-
-}
-
-
-
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template struct RotationProperties<dim>; \
-  template void Simulator<dim>::remove_nullspace (LinearAlgebra::BlockVector &,LinearAlgebra::BlockVector &vector); \
-  template void Simulator<dim>::setup_nullspace_constraints (AffineConstraints<double> &);
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/parameters.cc.bak b/source/simulator/parameters.cc.bak
deleted file mode 100644
index 9738cb515aa..00000000000
--- a/source/simulator/parameters.cc.bak
+++ /dev/null
@@ -1,2329 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/melt.h>
-#include <aspect/volume_of_fluid/handler.h>
-#include <aspect/stokes_matrix_free.h>
-#include <aspect/newton.h>
-#include <aspect/mesh_deformation/free_surface.h>
-
-#include <deal.II/base/parameter_handler.h>
-
-#include <boost/lexical_cast.hpp>
-#include <cstdlib>
-#include <regex>
-#include <sys/stat.h>
-
-namespace aspect
-{
-  template <int dim>
-  Parameters<dim>::Parameters (ParameterHandler &prm,
-                               const MPI_Comm mpi_communicator)
-  {
-    parse_parameters (prm, mpi_communicator);
-  }
-
-
-  template <int dim>
-  void
-  Parameters<dim>::
-  declare_parameters (ParameterHandler &prm)
-  {
-    prm.declare_entry ("Dimension", "2",
-                       Patterns::Integer (2,3),
-                       "The number of space dimensions you want to run this program in. "
-                       "ASPECT can run in 2 and 3 space dimensions.");
-    prm.declare_entry ("Additional shared libraries", "",
-                       Patterns::List (Patterns::FileName()),
-                       "A list of names of additional shared libraries that should be loaded "
-                       "upon starting up the program. The names of these files can contain absolute "
-                       "or relative paths (relative to the directory in which you call ASPECT). "
-                       "In fact, file names that do not contain any directory "
-                       "information (i.e., only the name of a file such as <libmyplugin.so> "
-                       "will not be found if they are not located in one of the directories "
-                       "listed in the \\texttt{LD_LIBRARY_PATH} environment variable. In order "
-                       "to load a library in the current directory, use <./libmyplugin.so> "
-                       "instead."
-                       "\n\n"
-                       "If you specify <./libmyplugin.so>, ASPECT will open either "
-                       "<./libmyplugin.debug.so> or <./libmyplugin.release.so> "
-                       "depending on the current ASPECT build type."
-                       "\n\n"
-                       "The typical use of this parameter is so that you can implement "
-                       "additional plugins in your own directories, rather than in the ASPECT "
-                       "source directories. You can then simply compile these plugins into a "
-                       "shared library without having to re-compile all of ASPECT. See the "
-                       "section of the manual discussing writing extensions for more "
-                       "information on how to compile additional files into a shared "
-                       "library.");
-
-    prm.declare_entry ("Resume computation", "false",
-                       Patterns::Selection ("true|false|auto"),
-                       "A flag indicating whether the computation should be resumed from "
-                       "a previously saved state (if true) or start from scratch (if false). "
-                       "If auto is selected, models will be resumed if there is an existing "
-                       "checkpoint file, otherwise started from scratch.");
-
-    prm.declare_entry ("Max nonlinear iterations", "10",
-                       Patterns::Integer (1),
-                       "The maximal number of nonlinear iterations to be performed.");
-
-    prm.declare_entry ("Max nonlinear iterations in pre-refinement", boost::lexical_cast<std::string>(std::numeric_limits<int>::max()),
-                       Patterns::Integer (0),
-                       "The maximal number of nonlinear iterations to be performed in the pre-refinement "
-                       "steps. This does not include the last refinement step before moving to timestep 1. "
-                       "When this parameter has a larger value than max nonlinear iterations, the latter is used.");
-
-    prm.declare_entry ("Start time", "0.",
-                       Patterns::Double (),
-                       "The start time of the simulation. Units: Years if the "
-                       "'Use years in output instead of seconds' parameter is set; "
-                       "seconds otherwise.");
-
-    prm.declare_entry ("Timing output frequency", "100",
-                       Patterns::Integer(0),
-                       "How frequently in timesteps to output timing information. This is "
-                       "generally adjusted only for debugging and timing purposes. If the "
-                       "value is set to zero it will also output timing information at the "
-                       "initiation timesteps.");
-
-    prm.declare_entry ("Use years in output instead of seconds", "true",
-                       Patterns::Bool (),
-                       "When computing results for mantle convection simulations, "
-                       "it is often difficult to judge the order of magnitude of results "
-                       "when they are stated in MKS units involving seconds. Rather, "
-                       "some kinds of results such as velocities are often stated in "
-                       "terms of meters per year (or, sometimes, centimeters per year). "
-                       "On the other hand, for non-dimensional computations, one wants "
-                       "results in their natural unit system as used inside the code. "
-                       "If this flag is set to `true' conversion to years happens; if "
-                       "it is `false', no such conversion happens."
-                       "\n\n"
-                       "Contrary to the word ``output'' in the name of this parameter, "
-                       "a number of plugins also use this parameter to determine "
-                       "how to interpret their \\textit{inputs}. For example, when `true', "
-                       "several of the boundary velocity models described in Section~"
-                       "\\ref{parameters:Boundary_20velocity_20model} interpret both "
-                       "specific times in years instead of seconds, and velocities in "
-                       "meters per year instead of meters per second.");
-
-    prm.declare_entry ("CFL number", "1.0",
-                       Patterns::Double (0.),
-                       "In computations, the time step $k$ is chosen according to "
-                       "$k = c \\min_K \\frac {h_K} {\\|u\\|_{\\infty,K} p_T}$ where $h_K$ is the "
-                       "diameter of cell $K$, and the denominator is the maximal magnitude "
-                       "of the velocity on cell $K$ times the polynomial degree $p_T$ of the "
-                       "temperature discretization. The dimensionless constant $c$ is called the "
-                       "CFL number in this program. For time discretizations that have explicit "
-                       "components, $c$ must be less than a constant that depends on the "
-                       "details of the time discretization and that is no larger than one. "
-                       "On the other hand, for implicit discretizations such as the one chosen "
-                       "here, one can choose the time step as large as one wants (in particular, "
-                       "one can choose $c>1$) though a CFL number significantly larger than "
-                       "one will yield rather diffusive solutions. Units: None.");
-
-    prm.declare_entry ("Maximum time step",
-                       /* boost::lexical_cast<std::string>(std::numeric_limits<double>::max() /
-                                                           year_in_seconds) = */ "5.69e+300",
-                       Patterns::Double (0.),
-                       "Set a maximum time step size for the solver to use. Generally the time step "
-                       "based on the CFL number should be sufficient, but for complicated models "
-                       "or benchmarking it may be useful to limit the time step to some value. "
-                       "The default value is a value so that when converted from years into seconds "
-                       "it equals the largest number representable by a floating "
-                       "point number, implying an unlimited time step."
-                       "Units: Years or seconds, depending on the ``Use years "
-                       "in output instead of seconds'' parameter.");
-
-    prm.declare_entry ("Maximum first time step",
-                       /* boost::lexical_cast<std::string>(std::numeric_limits<double>::max() /
-                                                           year_in_seconds) = */ "5.69e+300",
-                       Patterns::Double (0.),
-                       "Set a maximum time step size for only the first timestep. Generally the time step "
-                       "based on the CFL number should be sufficient, but for complicated models "
-                       "or benchmarking it may be useful to limit the first time step to some value, "
-                       "especially when using the free surface, which needs to settle to prevent "
-                       "instabilities. This should in that case be combined with a value set for "
-                       "``Maximum relative increase in time step''. "
-                       "The default value is a value so that when converted from years into seconds "
-                       "it equals the largest number representable by a floating "
-                       "point number, implying an unlimited time step. "
-                       "Units: Years or seconds, depending on the ``Use years "
-                       "in output instead of seconds'' parameter.");
-
-    prm.declare_entry ("Maximum relative increase in time step",
-                       "91.0",
-                       Patterns::Double (0.),
-                       "Set a percentage with which the length of the time step is limited to increase. Generally the "
-                       "time step based on the CFL number should be sufficient, but for complicated models "
-                       "which may suddenly drastically change behavior, it may be useful to limit the increase "
-                       "in the time step, without limiting the time step size of the whole simulation to a "
-                       "particular number. For example, if this parameter is set to $50$, then that means that "
-                       "the length of a time step can at most increase by 50\\% from one time step to the next, or by a "
-                       "factor of 1.5. "
-                       "\n\n"
-                       "Here, the default value is set to be 91\\% because the best available step-size ratio bound "
-                       "guaranteeing stability in the PDE context seems to be 1.91, see \\cite{Denner:2014}. "
-                       "In that thesis, the bound was proved in the context of semilinear parabolic problem, "
-                       "but it appears reasonable to also use this value as an upper bound in the current "
-                       "context."
-                       "\n\n"
-                       "Units: \\%.");
-
-    prm.declare_entry ("Use conduction timestep", "false",
-                       Patterns::Bool (),
-                       "Mantle convection simulations are often focused on convection "
-                       "dominated systems. However, these codes can also be used to "
-                       "investigate systems where heat conduction plays a dominant role. "
-                       "This parameter indicates whether the simulator should also use "
-                       "heat conduction in determining the length of each time step.");
-
-    const std::string allowed_solver_schemes = "single Advection, single Stokes|iterated Advection and Stokes|"
-                                               "single Advection, iterated Stokes|no Advection, iterated Stokes|"
-                                               "no Advection, single Stokes|"
-                                               "no Advection, iterated defect correction Stokes|"
-                                               "single Advection, iterated defect correction Stokes|"
-                                               "iterated Advection and defect correction Stokes|"
-                                               "iterated Advection and Newton Stokes|single Advection, iterated Newton Stokes|"
-                                               "single Advection, no Stokes|IMPES|iterated IMPES|"
-                                               "iterated Stokes|Newton Stokes|Stokes only|Advection only|"
-                                               "first timestep only, single Stokes|no Advection, no Stokes";
-
-    prm.declare_entry ("Nonlinear solver scheme", "single Advection, single Stokes",
-                       Patterns::Selection (allowed_solver_schemes),
-                       "The kind of scheme used to resolve the nonlinearity in the system. "
-                       "`single Advection, single Stokes' means that no nonlinear iterations are done, "
-                       "and the temperature, compositional fields and Stokes equations are solved exactly "
-                       "once per time step, one after the other. "
-                       "The `iterated Advection and Stokes' scheme iterates this decoupled approach "
-                       "by alternating the solution of the temperature, composition and Stokes systems. "
-                       "The `single Advection, iterated Stokes' scheme solves the temperature and composition "
-                       "equation once at the beginning of each time step and then iterates out the solution of "
-                       "the Stokes equation. "
-                       "The `no Advection, iterated Stokes' scheme only solves the Stokes system, iterating "
-                       "out the solution, and ignores compositions and the temperature equation (careful, "
-                       "the material model must not depend on the temperature or composition; this is mostly "
-                       "useful for Stokes benchmarks). "
-                       " The `no Advection, single Stokes' scheme only solves the Stokes system once per "
-                       "timestep. This is also mostly useful for Stokes benchmarks. "
-                       "The `single Advection, no Stokes' scheme only solves the temperature and other advection "
-                       "systems once, and instead of solving for the Stokes system, a prescribed velocity "
-                       "and pressure is used. "
-                       "The `iterated Advection and Newton Stokes' scheme iterates by alternating the solution "
-                       "of the temperature, composition and Stokes equations, using Picard iterations for the "
-                       "temperature and composition, and Newton iterations for the Stokes system. "
-                       "The `single Advection, iterated Newton Stokes' scheme solves "
-                       "the temperature and composition equations once at the beginning of each time step and "
-                       "then iterates out the solution of the Stokes equation, using Newton iterations for the "
-                       "Stokes system. "
-                       "The `iterated Advection and defect correction Stokes' scheme iterates by alternating the "
-                       "solution of the temperature, composition and Stokes equations, using Picard iterations for "
-                       "the temperature and composition, and defect correction Picard iterations for the Stokes system. "
-                       "The `single Advection, iterated defect correction Stokes' scheme solves "
-                       "the temperature and composition equations once at the beginning of each time step and "
-                       "then iterates out the solution of the Stokes equation, using defect correction Picard "
-                       "iterations for the Stokes system. "
-                       "The `no Advection, iterated defect correction Stokes' scheme solves "
-                       "the temperature and composition equations once at the beginning of each time step and "
-                       "then iterates out the solution of the Stokes equation, using defect correction Picard "
-                       "iterations for the Stokes system. "
-                       "The `first timestep only, single Stokes' scheme solves the Stokes equations exactly "
-                       "once, at the first time step. No nonlinear iterations are done, and the temperature and "
-                       "composition systems are not solved. "
-                       "\n\n"
-                       "The `IMPES' scheme is deprecated and only allowed for reasons of backwards "
-                       "compatibility. It is the same as `single Advection, single Stokes' ."
-                       "The `iterated IMPES' scheme is deprecated and only allowed for reasons of "
-                       "backwards compatibility. It is the same as `iterated Advection and Stokes'. "
-                       "The `iterated Stokes' scheme is deprecated and only allowed for reasons of "
-                       "backwards compatibility. It is the same as `single Advection, iterated Stokes'. "
-                       "The `Stokes only' scheme is deprecated and only allowed for reasons of "
-                       "backwards compatibility. It is the same as `no Advection, iterated Stokes'. "
-                       "The `Advection only' scheme is deprecated and only allowed for reasons of "
-                       "backwards compatibility. It is the same as `single Advection, no Stokes'. "
-                       "The `Newton Stokes' scheme is deprecated and only allowed for reasons of "
-                       "backwards compatibility. It is the same as `iterated Advection and Newton Stokes'.");
-
-    prm.declare_entry ("Nonlinear solver tolerance", "1e-5",
-                       Patterns::Double(0., 1.),
-                       "A relative tolerance up to which the nonlinear solver will iterate. "
-                       "This parameter is only relevant if the `Nonlinear solver scheme' does nonlinear "
-                       "iterations, in other words, if it is set to something other than "
-                       "`single Advection, single Stokes' or `single Advection, no Stokes'.");
-
-    prm.declare_entry ("Pressure normalization", "surface",
-                       Patterns::Selection ("surface|volume|no"),
-                       "If and how to normalize the pressure after the solution step. "
-                       "This is necessary because depending on boundary conditions, "
-                       "in many cases the pressure is only determined by the model "
-                       "up to a constant. On the other hand, we often would like to "
-                       "have a well-determined pressure, for example for "
-                       "table lookups of material properties in models "
-                       "or for comparing solutions. If the given value is `surface', then "
-                       "normalization at the end of each time steps adds a constant value "
-                       "to the pressure in such a way that the average pressure at the surface "
-                       "of the domain is what is set in the `Surface pressure' parameter; "
-                       "the surface of the domain is determined by asking "
-                       "the geometry model whether a particular face of the geometry has a zero "
-                       "or small `depth'. If the value of this parameter is `volume' then the "
-                       "pressure is normalized so that the domain average is zero. If `no' is "
-                       "given, the no pressure normalization is performed.");
-
-    prm.declare_entry ("Surface pressure", "0.",
-                       Patterns::Double(),
-                       "The value the pressure is normalized to in each time step when "
-                       "`Pressure normalization' is set to `surface' with default value 0. "
-                       "This setting is ignored in all other cases."
-                       "\n\n"
-                       "The mathematical equations that describe thermal convection "
-                       "only determine the pressure up to an arbitrary constant. On "
-                       "the other hand, for comparison and for looking up material "
-                       "parameters it is important that the pressure be normalized "
-                       "somehow. We do this by enforcing a particular average pressure "
-                       "value at the surface of the domain, where the geometry model "
-                       "determines where the surface is. This parameter describes what "
-                       "this average surface pressure value is supposed to be. By "
-                       "default, it is set to zero, but one may want to choose a "
-                       "different value for example for simulating only the volume "
-                       "of the mantle below the lithosphere, in which case the surface "
-                       "pressure should be the lithostatic pressure at the bottom "
-                       "of the lithosphere."
-                       "\n\n"
-                       "For more information, see the section in the manual that discusses "
-                       "the general mathematical model.");
-
-    prm.declare_entry ("Adiabatic surface temperature", "0.",
-                       Patterns::Double(),
-                       "In order to make the problem in the first time step easier to "
-                       "solve, we need a reasonable guess for the temperature and pressure. "
-                       "To obtain it, we use an adiabatic pressure and temperature field. "
-                       "This parameter describes what the `adiabatic' temperature would "
-                       "be at the surface of the domain (i.e. at depth zero). Note "
-                       "that this value need not coincide with the boundary condition "
-                       "posed at this point. Rather, the boundary condition may differ "
-                       "significantly from the adiabatic value, and then typically "
-                       "induce a thermal boundary layer."
-                       "\n\n"
-                       "For more information, see the section in the manual that discusses "
-                       "the general mathematical model.");
-
-    prm.declare_entry ("Output directory", "output",
-                       Patterns::DirectoryName(),
-                       "The name of the directory into which all output files should be "
-                       "placed. This may be an absolute or a relative path.");
-
-    prm.declare_entry ("Use operator splitting", "false",
-                       Patterns::Bool(),
-                       "If set to true, the advection and reactions of compositional fields and "
-                       "temperature are solved separately, and can use different time steps. Note that "
-                       "this will only work if the material/heating model fills the reaction\\_rates/"
-                       "heating\\_reaction\\_rates structures. Operator splitting can be used with any "
-                       "existing solver schemes that solve the temperature/composition equations.");
-
-    prm.declare_entry ("World builder file", "",
-                       Patterns::FileName(),
-                       "Name of the world builder file. If empty, the world builder is not initialized.");
-
-    prm.enter_subsection ("Solver parameters");
-    {
-      prm.declare_entry ("Temperature solver tolerance", "1e-12",
-                         Patterns::Double(0., 1.),
-                         "The relative tolerance up to which the linear system for "
-                         "the temperature system gets solved. See `Stokes solver "
-                         "parameters/Linear solver tolerance' for more details.");
-
-      prm.declare_entry ("Composition solver tolerance", "1e-12",
-                         Patterns::Double(0., 1.),
-                         "The relative tolerance up to which the linear system for "
-                         "the composition system gets solved. See `Stokes solver "
-                         "parameters/Linear solver tolerance' for more details.");
-
-      prm.enter_subsection ("Advection solver parameters");
-      {
-        prm.declare_entry ("GMRES solver restart length", "50",
-                           Patterns::Integer(1),
-                           "This is the number of iterations that define the "
-                           "GMRES solver restart length. Increasing this "
-                           "parameter makes the solver more robust and decreases "
-                           "the number of iterations. Be aware that "
-                           "increasing this number increases the memory usage "
-                           "of the advection solver, and makes individual "
-                           "iterations more expensive.");
-      }
-      prm.leave_subsection();
-
-
-      prm.enter_subsection ("Stokes solver parameters");
-      {
-        prm.declare_entry ("Stokes solver type", "default solver",
-                           Patterns::Selection(StokesSolverType::pattern()),
-                           "This is the type of solver used on the Stokes system. The block geometric "
-                           "multigrid solver currently has a limited implementation and therefore "
-                           "may trigger Asserts in the code when used. If this is the case, "
-                           "please switch to 'block AMG'. Additionally, the block GMG solver requires "
-                           "using material model averaging. The 'default solver' chooses "
-                           "the geometric multigrid solver if supported, otherwise the AMG solver.");
-
-        prm.declare_entry ("Use direct solver for Stokes system", "false",
-                           Patterns::Bool(),
-                           "If set to true the linear system for the Stokes equation will "
-                           "be solved using Trilinos klu, otherwise an iterative Schur "
-                           "complement solver is used. The direct solver is only efficient "
-                           "for small problems.");
-
-        prm.declare_entry ("Use weighted BFBT for Schur complement", "false",
-                           Patterns::Bool(),
-                           "If set to true, the Schur complement approximation in the Block preconditioner "
-                           "uses the weighted BFBT preconditioner, otherwise a weighted mass matrix will "
-                           "be used. The BFBT preconditioner is more expensive, but works better for large "
-                           "viscosity variations.");
-
-        prm.declare_entry ("Krylov method for cheap solver steps", "GMRES",
-                           Patterns::Selection(StokesKrylovType::pattern()),
-                           "This is the Krylov method used to solve the Stokes system. Both options, GMRES "
-                           "and IDR(s), solve non-symmetric, indefinite systems. GMRES "
-                           "guarantees the residual will be reduced in each iteration while IDR(s) has "
-                           "no such property. On the other hand, the vector storage requirement for GMRES is "
-                           "dependent on the restart length and can be quite restrictive (since, for "
-                           "the matrix-free GMG solver, memory is dominated by these vectors) whereas "
-                           "IDR(s) has a short term recurrence. "
-                           "Note that the IDR(s) Krylov method is not available for the AMG solver since "
-                           "it is not a flexible method, i.e., it cannot handle a preconditioner which "
-                           "may change in each iteration (the AMG-based preconditioner contains a CG solve "
-                           "in the pressure space which may have different number of iterations each step).");
-
-        prm.declare_entry ("IDR(s) parameter", "2",
-                           Patterns::Integer(1),
-                           "This is the sole parameter for the IDR(s) Krylov solver and will dictate the "
-                           "number of matrix-vector products and preconditioner applications per iteration (s+1) "
-                           "and the total number of temporary vectors required (5+3*s). For s=1, this method is "
-                           "analogous to BiCGStab. As s is increased this method is expected to converge to "
-                           "GMRES in terms of matrix-vector/preconditioner applications to solution.");
-
-        prm.declare_entry ("Linear solver tolerance", "1e-7",
-                           Patterns::Double(0., 1.),
-                           "A relative tolerance up to which the linear Stokes systems in each "
-                           "time or nonlinear step should be solved. The absolute tolerance will "
-                           "then be $\\| M x_0 - F \\| \\cdot \\text{tol}$, where $x_0 = (0,p_0)$ "
-                           "is the initial guess of the pressure, $M$ is the system matrix, "
-                           "$F$ is the right-hand side, and tol is the parameter specified here. "
-                           "We include the initial guess of the pressure "
-                           "to remove the dependency of the tolerance on the static pressure. "
-                           "A given tolerance value of 1 would "
-                           "mean that a zero solution vector is an acceptable solution "
-                           "since in that case the norm of the residual of the linear "
-                           "system equals the norm of the right hand side. A given "
-                           "tolerance of 0 would mean that the linear system has to be "
-                           "solved exactly, since this is the only way to obtain "
-                           "a zero residual."
-                           "\n\n"
-                           "In practice, you should choose the value of this parameter "
-                           "to be so that if you make it smaller the results of your "
-                           "simulation do not change any more (qualitatively) whereas "
-                           "if you make it larger, they do. For most cases, the default "
-                           "value should be sufficient. In fact, a tolerance of 1e-4 "
-                           "might be accurate enough.");
-
-        prm.declare_entry ("Number of cheap Stokes solver steps", "1000",
-                           Patterns::Integer(0),
-                           "As explained in the paper that describes ASPECT (Kronbichler, Heister, and Bangerth, "
-                           "2012, see \\cite{kronbichler:etal:2012}) we first try to solve the Stokes system in every "
-                           "time step using a GMRES iteration with a poor but cheap "
-                           "preconditioner. By default, we try whether we can converge the GMRES "
-                           "solver in 200 such iterations before deciding that we need a better "
-                           "preconditioner. This is sufficient for simple problems with variable "
-                           "viscosity and we never need the second phase with the more expensive "
-                           "preconditioner. On the other hand, for more complex problems, and in "
-                           "particular for problems with strongly nonlinear viscosity, the 200 "
-                           "cheap iterations don't actually do very much good and one might skip "
-                           "this part right away. In that case, this parameter can be set to "
-                           "zero, i.e., we immediately start with the better but more expensive "
-                           "preconditioner.");
-
-        prm.declare_entry ("Maximum number of expensive Stokes solver steps", "1000",
-                           Patterns::Integer(0),
-                           "This sets the maximum number of iterations used in the expensive Stokes solver. "
-                           "If this value is set too low for the size of the problem, the Stokes solver will "
-                           "not converge and return an error message pointing out that the user didn't allow "
-                           "a sufficiently large number of iterations for the iterative solver to converge.");
-
-        prm.declare_entry ("GMRES solver restart length", "100",
-                           Patterns::Integer(1),
-                           "This is the number of iterations that define the GMRES solver restart length. "
-                           "Increasing this parameter helps with convergence issues arising from high localized "
-                           "viscosity jumps in the domain. Be aware that increasing this number increases the "
-                           "memory usage of the Stokes solver, and makes individual Stokes iterations more "
-                           "expensive.");
-
-        prm.declare_entry ("Linear solver A block tolerance", "1e-2",
-                           Patterns::Double(0., 1.),
-                           "A relative tolerance up to which the approximate inverse of the $A$ block "
-                           "of the Stokes system is computed. This approximate $A$ is used in the "
-                           "preconditioning used in the GMRES solver. The exact definition of this "
-                           "block preconditioner for the Stokes equation can be found in "
-                           "\\cite{kronbichler:etal:2012}.");
-
-        prm.declare_entry ("Use full A block as preconditioner", "false",
-                           Patterns::Bool(),
-                           "This parameter determines whether we use an simplified approximation of the "
-                           "$A$ block as preconditioner for the Stokes solver, or the full $A$ block. The "
-                           "simplified approximation only contains the terms that describe the coupling of "
-                           "identical components (plus boundary conditions) as described in "
-                           "\\cite{kronbichler:etal:2012}. The full block is closer to the description in "
-                           "\\cite{rudi2017weighted}."
-                           "\n\n"
-                           "There is no clear way to determine which preconditioner "
-                           "performs better. The default value (simplified approximation) requires "
-                           "more outer GMRES iterations, but is faster to apply in each iteration. The full block "
-                           "needs less assembly time (because the block is "
-                           "available anyway), converges in less GMRES iterations, but requires more time per "
-                           "iteration. There are also differences in the amount of memory consumption between "
-                           "the two approaches."
-                           "\n\n"
-                           "The default value should be good for relatively simple models, but in "
-                           "particular for very strong viscosity contrasts the full $A$ block can be "
-                           "advantageous. This parameter is always set to true when using the GMG solver.");
-
-        prm.declare_entry ("Force nonsymmetric A block solver", "false",
-                           Patterns::Bool(),
-                           "This parameter determines whether to enforce a solver that supports nonsymmetric "
-                           "matrices when solving the inner $A$ block of the Stokes system. "
-                           "By default ASPECT recognizes cases where the A block is nonsymmetric "
-                           "automatically, and chooses an appropriate solver. However, if the "
-                           "inner A block solver does not converge, this parameter can be set to 'true' "
-                           "to force the use of a solver that can handle nonsymmetric matrices.");
-
-        prm.declare_entry ("Linear solver S block tolerance", "1e-6",
-                           Patterns::Double(0., 1.),
-                           "A relative tolerance up to which the approximate inverse of the $S$ block "
-                           "(i.e., the Schur complement matrix $S = BA^{-1}B^{T}$) of the Stokes "
-                           "system is computed. This approximate inverse of the $S$ block is used "
-                           "in the preconditioning used in the GMRES solver. The exact definition of "
-                           "this block preconditioner for the Stokes equation can be found in "
-                           "\\cite{kronbichler:etal:2012}.");
-      }
-      prm.leave_subsection ();
-
-      prm.enter_subsection ("AMG parameters");
-      {
-        prm.declare_entry ("AMG smoother type", "Chebyshev",
-                           Patterns::Selection ("Chebyshev|symmetric Gauss-Seidel"),
-                           "This parameter sets the type of smoother for the AMG. "
-                           "The default is strongly recommended for any normal runs "
-                           "with ASPECT. There are some indications that the symmetric "
-                           "Gauss-Seidel might be better and more stable for the Newton "
-                           "solver. For extensive benchmarking of various settings of the "
-                           "AMG parameters in this section for the Stokes problem and others, "
-                           "see https://github.com/geodynamics/aspect/pull/234.");
-
-        prm.declare_entry ("AMG smoother sweeps", "2",
-                           Patterns::Integer(0),
-                           "Determines how many sweeps of the smoother should be performed. When the flag elliptic "
-                           "is set to true, (which is true for ASPECT), the polynomial degree of "
-                           "the Chebyshev smoother is set to this value. The term sweeps refers to the number of "
-                           "matrix-vector products performed in the Chebyshev case. In the non-elliptic case, "
-                           "this parameter sets the number of SSOR relaxation sweeps for post-smoothing to be performed. "
-                           "The default is strongly recommended. There are indications that for the Newton solver a different "
-                           "value might be better. For extensive benchmarking of various settings of the "
-                           "AMG parameters in this section for the Stokes problem and others, "
-                           "see https://github.com/geodynamics/aspect/pull/234.");
-
-        prm.declare_entry ("AMG aggregation threshold", "0.001",
-                           Patterns::Double(0., 1.),
-                           "This threshold tells the AMG setup how the coarsening should be performed. "
-                           "In the AMG used by ML, all points that strongly couple with the tentative coarse-level "
-                           "point form one aggregate. The term strong coupling is controlled by the variable "
-                           "aggregation\\_threshold, meaning that all elements that are not smaller than "
-                           "aggregation\\_threshold times the diagonal element do couple strongly. "
-                           "The default is strongly recommended. There are indications that for the Newton solver a different "
-                           "value might be better. For extensive benchmarking of various settings of the "
-                           "AMG parameters in this section for the Stokes problem and others, "
-                           "see https://github.com/geodynamics/aspect/pull/234.");
-
-        prm.declare_entry ("AMG output details", "false",
-                           Patterns::Bool(),
-                           "Turns on extra information on the AMG solver. Note that this will generate much more output.");
-      }
-      prm.leave_subsection ();
-      prm.enter_subsection ("Operator splitting parameters");
-      {
-        prm.declare_entry ("Reaction solver type", "ARKode",
-                           Patterns::Selection ("ARKode|fixed step"),
-                           "This parameter determines what solver will be used when the reactions "
-                           "are computed within the operator splitting scheme. For reactions where "
-                           "the reaction rate is a known, finite quantity, the appropriate choice "
-                           "is `ARKode', which uses an ODE solver from SUNDIALs ARKode (adaptive-step "
-                           "additive Runge Kutta ODE solver methods) to compute the solution. ARKode "
-                           "will pick a reasonable step size based on the reaction rate and the given "
-                           "`Reaction solver relative tolerance'. "
-                           "However, in some cases we have instantaneous reactions, where we know the "
-                           "new value of a compositional field (and the reaction rate would be "
-                           "infinite), or reaction where we need to know or be able to control the step "
-                           "size we use to compute the reactions. In theses cases, it is appropriate "
-                           "to use the `fixed step' scheme, a method that a forward Euler scheme and a "
-                           "fixed number of steps given by the `Reaction time step' and "
-                           "`Reaction time steps per advection step' parameters. ");
-
-        prm.declare_entry ("Reaction solver relative tolerance", "1e-6",
-                           Patterns::Double (0.),
-                           "The relative solver tolerance used in the ARKode reaction solver. "
-                           "This tolerance is used to adaptively determine the reaction step size. "
-                           "For more details, see the ARKode documentation. This parameter is only used "
-                           "if the `ARKode' reaction solver type is used. "
-                           "Units: none.");
-
-        prm.declare_entry ("Reaction time step", "1000.0",
-                           Patterns::Double (0.),
-                           "Set a time step size for computing reactions of compositional fields and the "
-                           "temperature field in case operator splitting is used. This is only used "
-                           "when the parameter ``Use operator splitting'' is set to true and when the "
-                           "`fixed step' reaction solver type is used. "
-                           "The reaction time step must be greater than 0. "
-                           "If you want to prescribe the reaction time step only as a relative value "
-                           "compared to the advection time step as opposed to as an absolute value, you "
-                           "should use the parameter ``Reaction time steps per advection step'' and set "
-                           "this parameter to the same (or larger) value as the ``Maximum time step'' "
-                           "(which is 5.69e+300 by default). "
-                           "Units: Years or seconds, depending on the ``Use years "
-                           "in output instead of seconds'' parameter.");
-
-        prm.declare_entry ("Reaction time steps per advection step", "0",
-                           Patterns::Integer (0),
-                           "The number of reaction time steps done within one advection time step "
-                           "in case operator splitting is used. This is only used if the parameter "
-                           "``Use operator splitting'' is set to true and when the `fixed step' "
-                           "reaction solver type is used. If set to zero, this parameter is ignored. "
-                           "Otherwise, the reaction time step size is chosen according to "
-                           "this criterion and the ``Reaction time step'', whichever yields the "
-                           "smaller time step. "
-                           "Units: none.");
-      }
-      prm.leave_subsection ();
-      prm.enter_subsection ("Diffusion solver parameters");
-      {
-        prm.declare_entry ("Diffusion length scale", "1.e4",
-                           Patterns::Double (0.),
-                           "Set a length scale for the diffusion of advection fields if the "
-                           "``prescribed field with diffusion'' method is selected for a field. "
-                           "More precisely, this length scale represents the square root of the "
-                           "product of diffusivity and time in the diffusion equation, and controls "
-                           "the distance over which features are diffused. "
-                           "Units: \\si{\\meter}.");
-      }
-      prm.leave_subsection ();
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection("Formulation");
-    {
-      prm.declare_entry ("Formulation", "custom",
-                         Patterns::Selection ("isentropic compression|custom|anelastic liquid approximation|Boussinesq approximation"),
-                         "Select a formulation for the basic equations. Different "
-                         "published formulations are available in ASPECT (see the list of "
-                         "possible values for this parameter in the manual for available options). "
-                         "Two ASPECT specific options are\n"
-                         "  * `isentropic compression': ASPECT's original "
-                         "formulation, using the explicit compressible mass equation, "
-                         "and the full density for the temperature equation.\n"
-                         "  * `custom': A custom selection of `Mass conservation' and "
-                         "`Temperature equation'.\n"
-                         ":::{warning}\n"
-                         "The `custom' option is "
-                         "implemented for advanced users that want full control over the "
-                         "equations solved. It is possible to choose inconsistent formulations "
-                         "and no error checking is performed on the consistency of the resulting "
-                         "equations.\n"
-                         ":::\n\n"
-                         ":::{note}\n"
-                         "The `anelastic liquid approximation' option here can also be "
-                         "used to set up the `truncated anelastic liquid approximation' as long as "
-                         "this option is chosen together with a material model that defines a "
-                         "density that depends on temperature and depth and not on the pressure.\n"
-                         ":::");
-
-      prm.declare_entry ("Mass conservation", "ask material model",
-                         Patterns::Selection ("incompressible|isentropic compression|hydrostatic compression|"
-                                              "reference density profile|implicit reference density profile|"
-                                              "projected density field|"
-                                              "ask material model"),
-                         "Possible approximations for the density derivatives in the mass "
-                         "conservation equation. Note that this parameter is only evaluated "
-                         "if `Formulation' is set to `custom'. Other formulations ignore "
-                         "the value of this parameter.");
-      prm.declare_entry ("Temperature equation", "real density",
-                         Patterns::Selection ("real density|reference density profile"),
-                         "Possible approximations for the density in the temperature equation. "
-                         "Possible approximations are `real density' and `reference density profile'. "
-                         "Note that this parameter is only evaluated "
-                         "if `Formulation' is set to `custom'. Other formulations ignore "
-                         "the value of this parameter.");
-      prm.declare_entry ("Enable additional Stokes RHS", "false",
-                         Patterns::Bool (),
-                         "Whether to ask the material model for additional terms for the right-hand side "
-                         "of the Stokes equation. This feature is likely only used when implementing force "
-                         "vectors for manufactured solution problems and requires filling additional outputs "
-                         "of type AdditionalMaterialOutputsStokesRHS.");
-      prm.declare_entry ("Enable elasticity", "false",
-                         Patterns::Bool (),
-                         "Whether to include the additional elastic terms on the right-hand side of "
-                         "the Stokes equation.");
-      prm.declare_entry ("Enable prescribed dilation", "false",
-                         Patterns::Bool (),
-                         "Whether to include additional terms on the right-hand side of "
-                         "the Stokes equation to set a given compression term specified in the "
-                         "MaterialModel output PrescribedPlasticDilation.");
-    }
-    prm.leave_subsection();
-
-    // next declare parameters that pertain to the equations to be
-    // solved, along with boundary conditions etc. note that at this
-    // point we do not know yet which geometry model we will use, so
-    // we do not know which symbolic names will be valid to address individual
-    // parts of the boundary. we can only work around this by allowing any string
-    // to indicate a boundary
-    prm.enter_subsection ("Melt settings");
-    {
-      prm.declare_entry ("Include melt transport", "false",
-                         Patterns::Bool (),
-                         "Whether to include the transport of melt into the model or not. If this "
-                         "is set to true, two additional pressures (the fluid pressure and the "
-                         "compaction pressure) will be added to the finite element. "
-                         "Including melt transport in the simulation also requires that there is "
-                         "one compositional field that has the name `porosity'. This field will "
-                         "be used for computing the additional pressures and the melt velocity, "
-                         "and has a different advection equation than other compositional fields, "
-                         "as it is effectively advected with the melt velocity.");
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Mesh deformation");
-    {
-      prm.declare_entry ("Mesh deformation boundary indicators", "",
-                         Patterns::List (Patterns::Anything()),
-                         "A comma separated list of names denoting those boundaries "
-                         "where there is some type of mesh deformation. Set to nothing to disable all "
-                         "deformation computations."
-                         "\n\n"
-                         "The names of the boundaries listed here can either by "
-                         "numbers (in which case they correspond to the numerical "
-                         "boundary indicators assigned by the geometry object), or they "
-                         "can correspond to any of the symbolic names the geometry object "
-                         "may have provided for each part of the boundary. You may want "
-                         "to compare this with the documentation of the geometry model you "
-                         "use in your model.");
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Boundary heat flux model");
-    {
-      prm.declare_entry ("Fixed heat flux boundary indicators", "",
-                         Patterns::List (Patterns::Anything()),
-                         "A comma separated list of names denoting those boundaries "
-                         "on which the heat flux is fixed and described by the "
-                         "boundary heat flux object selected in the 'Model name' parameter. "
-                         "All boundary indicators used by the geometry but not explicitly "
-                         "listed here or in the list of 'Fixed temperature boundary indicators' "
-                         "in the 'Boundary temperature model' will end up with no-flux "
-                         "(insulating) boundary conditions."
-                         "\n\n"
-                         "The names of the boundaries listed here can either be "
-                         "numbers (in which case they correspond to the numerical "
-                         "boundary indicators assigned by the geometry object), or they "
-                         "can correspond to any of the symbolic names the geometry object "
-                         "may have provided for each part of the boundary. You may want "
-                         "to compare this with the documentation of the geometry model you "
-                         "use in your model."
-                         "\n\n"
-                         "This parameter only describes which boundaries have a fixed "
-                         "heat flux, but not what heat flux should hold on these "
-                         "boundaries. The latter piece of information needs to be "
-                         "implemented in a plugin in the BoundaryHeatFlux "
-                         "group, unless an existing implementation in this group "
-                         "already provides what you want.");
-    }
-    prm.leave_subsection();
-
-
-    prm.enter_subsection ("Nullspace removal");
-    {
-      prm.declare_entry ("Remove nullspace", "",
-                         Patterns::MultipleSelection("net rotation|angular momentum|"
-                                                     "net surface rotation|"
-                                                     "net translation|linear momentum|"
-                                                     "net x translation|net y translation|net z translation|"
-                                                     "linear x momentum|linear y momentum|linear z momentum"),
-                         "Choose none, one or several from "
-                         "\n\n"
-                         "\\begin{itemize} \\item net rotation \\item angular momentum \\item net translation "
-                         "\\item net surface rotation"
-                         "\\item linear momentum \\item net x translation \\item net y translation "
-                         "\\item net z translation \\item linear x momentum \\item linear y momentum "
-                         "\\item linear z momentum \\end{itemize}"
-                         "\n\n"
-                         "These are a selection of operations to remove certain parts of the nullspace from "
-                         "the velocity after solving. For some geometries and certain boundary conditions "
-                         "the velocity field is not uniquely determined but contains free translations "
-                         "and/or rotations. Depending on what you specify here, these non-determined "
-                         "modes will be removed from the velocity field at the end of the Stokes solve step.\n"
-                         "\n\n"
-                         "The ``angular momentum'' option removes a rotation such that the net angular momentum "
-                         "is zero. The ``linear * momentum'' options remove translations such that the net "
-                         "momentum in the relevant direction is zero.  The ``net rotation'' option removes the "
-                         "net rotation of the whole domain, the ``net surface rotation'' option removes the net "
-                         "rotation of the top surface, and the ``net * translation'' options remove the "
-                         "net translations in the relevant directions.  For most problems there should not be a "
-                         "significant difference between the momentum and rotation/translation versions of "
-                         "nullspace removal, although the momentum versions are more physically motivated. "
-                         "They are equivalent for constant density simulations, and approximately equivalent "
-                         "when the density variations are small."
-                         "\n\n"
-                         "Note that while more than one operation can be selected it only makes sense to "
-                         "pick one rotational and one translational operation.");
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Mesh refinement");
-    {
-      prm.declare_entry ("Initial global refinement", "2",
-                         Patterns::Integer (0),
-                         "The number of global refinement steps performed on "
-                         "the initial coarse mesh, before the problem is first "
-                         "solved there."
-                         "\n\n"
-                         "Note that it is possible to supply conflicting refinement "
-                         "and coarsening settings, such as an 'Initial global refinement' "
-                         "of 4 and a 'Maximum refinement function' strategy that limits "
-                         "the refinement locally to 2. In this case, the tagging strategies "
-                         "such as the 'Maximum refinement function' will remove refinement "
-                         "flags in each initial global refinement step, such that the "
-                         "resulting mesh is not necessarily uniform or of the level "
-                         "given by the 'Initial global refinement' parameter.");
-      prm.declare_entry ("Initial adaptive refinement", "0",
-                         Patterns::Integer (0),
-                         "The number of adaptive refinement steps performed after "
-                         "initial global refinement but while still within the first "
-                         "time step. These refinement steps (n) are added to the value "
-                         "for initial global refinement (m) so that the final mesh has "
-                         "cells that are at most on refinement level $n+m$.");
-      prm.declare_entry ("Time steps between mesh refinement", "10",
-                         Patterns::Integer (0),
-                         "The number of time steps after which the mesh is to be "
-                         "adapted again based on computed error indicators. If 0 "
-                         "then the mesh will never be changed.");
-      prm.declare_entry ("Refinement fraction", "0.3",
-                         Patterns::Double(0., 1.),
-                         "Cells are sorted from largest to smallest by their total error "
-                         "(determined by the Strategy). Then the cells with the largest "
-                         "error (top of this sorted list) that account for given fraction "
-                         "of the error are refined.");
-      prm.declare_entry ("Coarsening fraction", "0.05",
-                         Patterns::Double(0., 1.),
-                         "Cells are sorted from largest to smallest by their total error "
-                         "(determined by the Strategy). Then the cells with the smallest "
-                         "error (bottom of this sorted list) that account for the given fraction "
-                         "of the error are coarsened.");
-      prm.declare_entry ("Adapt by fraction of cells", "false",
-                         Patterns::Bool(),
-                         "Use fraction of the total number of cells instead of "
-                         "fraction of the total error as the limit for refinement "
-                         "and coarsening.");
-      prm.declare_entry ("Minimum refinement level", "0",
-                         Patterns::Integer (0),
-                         "The minimum refinement level each cell should have, "
-                         "and that can not be exceeded by coarsening. "
-                         "Should not be higher than the 'Initial global refinement' "
-                         "parameter.");
-      prm.declare_entry ("Additional refinement times", "",
-                         Patterns::List (Patterns::Double (0.)),
-                         "A list of times so that if the end time of a time step "
-                         "is beyond this time, an additional round of mesh refinement "
-                         "is triggered. This is mostly useful to make sure we "
-                         "can get through the initial transient phase of a simulation "
-                         "on a relatively coarse mesh, and then refine again when we "
-                         "are in a time range that we are interested in and where "
-                         "we would like to use a finer mesh. Units: Each element of the "
-                         "list has units years if the "
-                         "'Use years in output instead of seconds' parameter is set; "
-                         "seconds otherwise.");
-      prm.declare_entry ("Run postprocessors on initial refinement", "false",
-                         Patterns::Bool (),
-                         "Whether or not the postprocessors should be executed after "
-                         "each of the initial adaptive refinement cycles that are run at "
-                         "the start of the simulation. This is useful for "
-                         "plotting/analyzing how the mesh refinement parameters are "
-                         "working for a particular model.");
-      prm.declare_entry ("Skip solvers on initial refinement", "false",
-                         Patterns::Bool (),
-                         "Whether or not solvers should be executed during the initial "
-                         "adaptive refinement cycles that are run at the start of the "
-                         "simulation.");
-      prm.declare_entry ("Skip setup initial conditions on initial refinement", "false",
-                         Patterns::Bool (),
-                         "Whether or not the initial conditions should be set up during the "
-                         "adaptive refinement cycles that are run at the start of the "
-                         "simulation.");
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Postprocess");
-    {
-      prm.declare_entry ("Run postprocessors on nonlinear iterations", "false",
-                         Patterns::Bool (),
-                         "Whether or not the postprocessors should be executed after "
-                         "each of the nonlinear iterations done within one time step. "
-                         "As this is mainly an option for the purposes of debugging, "
-                         "it is not supported when the 'Time between graphical output' "
-                         "is larger than zero, or when the postprocessor is not intended "
-                         "to be run more than once per timestep.");
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Checkpointing");
-    {
-      prm.declare_entry ("Time between checkpoint", "0",
-                         Patterns::Integer (0),
-                         "The wall time between performing checkpoints. "
-                         "If 0, will use the checkpoint step frequency instead. "
-                         "Units: Seconds.");
-      prm.declare_entry ("Steps between checkpoint", "0",
-                         Patterns::Integer (0),
-                         "The number of timesteps between performing checkpoints. "
-                         "If 0 and time between checkpoint is not specified, "
-                         "checkpointing will not be performed. "
-                         "Units: None.");
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection ("Discretization");
-    {
-      prm.declare_entry ("Stokes velocity polynomial degree", "2",
-                         Patterns::Integer (1),
-                         "The polynomial degree to use for the velocity variables "
-                         "in the Stokes system. The polynomial degree for the pressure "
-                         "variable will then be one less in order to make the velocity/pressure "
-                         "pair conform with the usual LBB (Babu{\\v s}ka-Brezzi) condition. In "
-                         "other words, we are using a Taylor-Hood element for the Stokes "
-                         "equations and this parameter indicates the polynomial degree of it. "
-                         "As an example, a value of 2 for this parameter will yield the "
-                         "element $Q_2^d \\times Q_1$ for the $d$ velocity components and the "
-                         "pressure, respectively (unless the `Use locally conservative "
-                         "discretization' parameter is set, which modifies the pressure "
-                         "element). "
-                         "\n\n"
-                         "Be careful if you choose 1 as the degree. The resulting element "
-                         "is not stable and it may lead to artifacts in the solution. "
-                         "Units: None.");
-      prm.declare_entry ("Temperature polynomial degree", "2",
-                         Patterns::Integer (1),
-                         "The polynomial degree to use for the temperature variable. "
-                         "As an example, a value of 2 for this parameter will yield "
-                         "either the element $Q_2$ or $DGQ_2$ for the temperature "
-                         "field, depending on whether we use a continuous or "
-                         "discontinuous field. "
-                         "Units: None.");
-      prm.declare_entry ("Composition polynomial degree", "2",
-                         Patterns::Integer (0),
-                         "The polynomial degree to use for the composition variable(s). "
-                         "As an example, a value of 2 for this parameter will yield "
-                         "either the element $Q_2$ or $DGQ_2$ for the compositional "
-                         "field(s), depending on whether we use continuous or "
-                         "discontinuous field(s). "
-                         "\n\n"
-                         "For continuous elements, the value needs to be 1 or larger "
-                         "as $Q_1$ is the lowest order element, while $DGQ_0$ is a "
-                         "valid choice. "
-                         "Units: None.");
-      prm.declare_entry ("Use locally conservative discretization", "false",
-                         Patterns::Bool (),
-                         "Whether to use a Stokes discretization that is locally "
-                         "conservative at the expense of a larger number of degrees "
-                         "of freedom (true), or to go with a cheaper discretization "
-                         "that does not locally conserve mass, although it is "
-                         "globally conservative (false)."
-                         "\n\n"
-                         "When using a locally "
-                         "conservative discretization, the finite element space for "
-                         "the pressure is discontinuous between cells and is the "
-                         "polynomial space $P_{-(k-1)}$ of polynomials of degree $k-1$ in "
-                         "each variable separately. Here, $k$ is the value "
-                         "given in the parameter ``Stokes velocity polynomial degree'', and "
-                         "consequently the polynomial degree for the pressure, $k-1$, is one "
-                         "lower than that for the velocity."
-                         "\n\n"
-                         "As a consequence of choosing this element for the pressure rather "
-                         "than the more commonly used $Q_{k-1}$ element that is continuous, "
-                         "it can be shown that if the medium is considered incompressible "
-                         "then the computed discrete velocity "
-                         "field $\\mathbf u_h$ satisfies the property $\\int_ {\\partial K} \\mathbf u_h "
-                         "\\cdot \\mathbf n = 0$ for every cell $K$, i.e., for each cell inflow and "
-                         "outflow exactly balance each other as one would expect for an "
-                         "incompressible medium. In other words, the velocity field is "
-                         "\\textit{locally conservative}."
-                         "\n\n"
-                         "On the other hand, if this parameter is set to ``false''"
-                         "(the default), then the finite element space is chosen as $Q_{k-1}$. "
-                         "This choice does not yield the local conservation property but "
-                         "has the advantage of requiring fewer degrees of freedom. Furthermore, "
-                         "the error is generally smaller with this choice."
-                         "\n\n"
-                         "For an in-depth discussion of these issues and a quantitative evaluation "
-                         "of the different choices, see \\cite{kronbichler:etal:2012}.");
-      prm.declare_entry ("Use equal order interpolation for Stokes", "false",
-                         Patterns::Bool(),
-                         "By default (i.e., when this parameter is set to its default value "
-                         "`false') \\aspect{} uses finite element combinations in which the "
-                         "pressure shape functions are polynomials one degree lower than "
-                         "the shape functions for the velocity. An example is the "
-                         "Taylor-Hood element that uses $Q_k$ elements for the velocity "
-                         "and $Q_{k-1}$ for the pressure. This is because using the "
-                         "\\textit{same} polynomial degree for both the velocity and the "
-                         "pressure turns out to violate some mathematical properties "
-                         "necessary to make the problem solvable. (In particular, the"
-                         "condition in question goes by the name ``inf-sup'' or "
-                         "Babu{\\v s}ka-Brezzi or LBB condition.) A consequence of "
-                         "violating this condition is that the pressure may show "
-                         "oscillations and not converge to the correct pressure."
-                         "\n\n"
-                         "That said, people have often used $Q_1$ elements for both the "
-                         "velocity and pressure anyway. This is commonly referred to as "
-                         "using the $Q_1-Q_1$ method. It is, by default, not stable as "
-                         "mentioned above, but it can be made stable by adding a small "
-                         "amount of compressibility to the model. There are numerous "
-                         "ways to do that. Today, the way that is generally considered "
-                         "to be the best approach is the one by Dohrmann and Bochev "
-                         "\\cite{DohrmannBochev2004}."
-                         "\n\n"
-                         "When this parameter is set to ``true'', then \\aspect{} "
-                         "will use this method by using $Q_k\\times Q_k$ elements for "
-                         "velocity and pressure, respectively, where $k$ is the value "
-                         "provided for the parameter ``Stokes velocity polynomial "
-                         "degree''."
-                         "\n\n"
-                         ":::{note}\n"
-                         "While \\aspect{} \\textit{allows} you to use this "
-                         "method, it is generally understood that this is not a "
-                         "great idea as it leads to rather low accuracy in "
-                         "general as documented in \\cite{thba22}. "
-                         "It also leads to substantial problems when "
-                         "using free surfaces. As a consequence, the presence "
-                         "of this parameter should not be seen as an "
-                         "endorsement of the method, or a suggestion to "
-                         "actually use it. It simply makes the method available.\n"
-                         ":::");
-      prm.declare_entry ("Use discontinuous temperature discretization", "false",
-                         Patterns::Bool (),
-                         "Whether to use a temperature discretization that is discontinuous "
-                         "as opposed to continuous. This then requires the assembly of face terms "
-                         "between cells, and weak imposition of boundary terms for the temperature "
-                         "field via the interior-penalty discontinuous Galerkin method.");
-      prm.declare_entry ("Use discontinuous composition discretization", "false",
-                         Patterns::List(Patterns::Bool ()),
-                         "Whether to use a composition discretization that is discontinuous "
-                         "as opposed to continuous. This then requires the assembly of face terms "
-                         "between cells, and weak imposition of boundary terms for the composition "
-                         "field via the discontinuous Galerkin method.");
-
-      prm.enter_subsection ("Stabilization parameters");
-      {
-        prm.declare_entry ("Stabilization method", "entropy viscosity",
-                           Patterns::Selection("entropy viscosity|SUPG"),
-                           "Select the method for stabilizing the advection equation. The original "
-                           "method implemented is 'entropy viscosity' as described in \\cite {kronbichler:etal:2012}. "
-                           "SUPG is currently experimental.");
-
-        prm.declare_entry ("List of compositional fields with disabled boundary entropy viscosity", "",
-                           Patterns::List(Patterns::Anything()),
-                           "Select for which compositional fields to skip the entropy viscosity "
-                           "stabilization at dirichlet boundaries. This is "
-                           "only advisable for compositional fields"
-                           "that have intrinsic physical diffusion terms, otherwise "
-                           "oscillations may develop. The parameter should contain a list of "
-                           "compositional field names.");
-
-        prm.declare_entry ("Use artificial viscosity smoothing", "false",
-                           Patterns::Bool (),
-                           "If set to false, the artificial viscosity of a cell is computed and "
-                           "is computed on every cell separately as discussed in \\cite{kronbichler:etal:2012}. "
-                           "If set to true, the maximum of the artificial viscosity in "
-                           "the cell as well as the neighbors of the cell is computed and used "
-                           "instead.");
-
-        prm.declare_entry ("alpha", "2",
-                           Patterns::Integer (1, 2),
-                           "The exponent $\\alpha$ in the entropy viscosity stabilization. Valid "
-                           "options are 1 or 2. The recommended setting is 2. (This parameter does "
-                           "not correspond to any variable in the 2012 paper by Kronbichler, "
-                           "Heister and Bangerth that describes ASPECT, see \\cite{kronbichler:etal:2012}. "
-                           "Rather, the paper always uses 2 as the exponent in the definition "
-                           "of the entropy, following equation (15) of the paper. The full "
-                           "approach is discussed in \\cite{guermond:etal:2011}.) Note that this is not the "
-                           "thermal expansion coefficient, also commonly referred to as $\\alpha$."
-                           "Units: None.");
-        prm.declare_entry ("cR", "0.11",
-                           Patterns::List(Patterns::Double (0.)),
-                           "The $c_R$ factor in the entropy viscosity "
-                           "stabilization. This parameter controls the part of the entropy viscosity "
-                           "that depends on the solution field itself and its residual in addition "
-                           "to the cell diameter and the maximum velocity in the cell. "
-                           "This parameter can be given as a single value or as a list with as "
-                           "many entries as one plus the number of compositional fields. In the "
-                           "former case all advection fields use the same stabilization parameters, "
-                           "in the latter case each field (temperature first, then all compositions) "
-                           "use individual parameters. This can be useful to reduce the stabilization "
-                           "for the temperature, which already has some physical diffusion. "
-                           "(For historical reasons, the name used here is different "
-                           "from the one used in the 2012 paper by Kronbichler, "
-                           "Heister and Bangerth that describes ASPECT, see \\cite{kronbichler:etal:2012}. "
-                           "This parameter corresponds "
-                           "to the factor $\\alpha_E$ in the formulas following equation (15) of "
-                           "the paper.) Units: None.");
-        prm.declare_entry ("beta", "0.052",
-                           Patterns::List(Patterns::Double (0.)),
-                           "The $\\beta$ factor in the artificial viscosity "
-                           "stabilization. This parameter controls the maximum dissipation of the "
-                           "entropy viscosity, which is the part that only scales with the cell diameter "
-                           "and the maximum velocity in the cell, but does not depend on the solution "
-                           "field itself or its residual. An appropriate value for 2d is 0.052 and "
-                           "0.78 for 3d. (For historical reasons, the name used here is different "
-                           "from the one used in the 2012 paper by Kronbichler, "
-                           "Heister and Bangerth that describes ASPECT, see \\cite{kronbichler:etal:2012}. "
-                           "This parameter can be given as a single value or as a list with as "
-                           "many entries as one plus the number of compositional fields. In the "
-                           "former case all advection fields use the same stabilization parameters, "
-                           "in the latter case each field (temperature first, then all compositions) "
-                           "use individual parameters. This can be useful to reduce the stabilization "
-                           "for the temperature, which already has some physical diffusion. "
-                           "This parameter corresponds "
-                           "to the factor $\\alpha_{\\text{max}}$ in the formulas following equation (15) of "
-                           "the paper.) Units: None.");
-        prm.declare_entry ("gamma", "0.0",
-                           Patterns::Double (0.),
-                           "The strain rate scaling factor in the artificial viscosity "
-                           "stabilization. This parameter determines how much the strain rate (in addition "
-                           "to the velocity) should influence the stabilization. (This parameter does "
-                           "not correspond to any variable in the 2012 paper by Kronbichler, "
-                           "Heister and Bangerth that describes ASPECT, see \\cite{kronbichler:etal:2012}. "
-                           "Rather, the paper always uses "
-                           "0, i.e. they specify the maximum dissipation $\\nu_h^\\text{max}$ as "
-                           "$\\nu_h^\\text{max}\\vert_K = \\alpha_{\\text{max}} h_K \\|\\mathbf u\\|_{\\infty,K}$. "
-                           "Here, we use "
-                           "$\\|\\lvert\\mathbf u\\rvert + \\gamma h_K \\lvert\\varepsilon (\\mathbf u)\\rvert\\|_{\\infty,K}$ "
-                           "instead of $\\|\\mathbf u\\|_{\\infty,K}$. "
-                           "Units: None.");
-        prm.declare_entry ("Discontinuous penalty", "10.",
-                           Patterns::Double (0.),
-                           "The value used to penalize discontinuities in the discontinuous Galerkin "
-                           "method. This is used only for the temperature field, and not for the composition "
-                           "field, as pure advection does not use the interior penalty method. This "
-                           "is largely empirically decided -- it must be large enough to ensure "
-                           "the bilinear form is coercive, but not so large as to penalize "
-                           "discontinuity at all costs.");
-        prm.declare_entry ("Limiter for discontinuous temperature solution", "none",
-                           Patterns::Selection(DGLimiterType::pattern()),
-                           "The type of limiter to apply to the discontinuous temperature solution. "
-                           "Available options are:\n"
-                           "  * `bound preserving': a limiter that keeps the discontinuous solution "
-                           "in the range given by `Global temperature maximum' and `Global temperature "
-                           "minimum'.\n"
-                           "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
-                           "a polynomial function in places where shocks are detected, as described in "
-                           "\\cite{zhong:etal:2013}.\n"
-                           "  * `none`: if chosen, no limiter is applied to the discontinuous solution.\n"
-                           "Note that if this entry is not set to `none', then the limiter will modify "
-                           "the solution, so the nonlinear residual for this field is meaningless, and "
-                           "in nonlinear solvers we will ignore the residual for this field to evaluate "
-                           "if the nonlinear solver has converged.");
-        prm.declare_entry ("Limiter for discontinuous composition solution", "none",
-                           Patterns::List(Patterns::Selection(DGLimiterType::pattern())),
-                           "The type of limiter to apply to the discontinuous composition solution. The "
-                           "number of the input values separated by ',' has to be one or the same as the "
-                           "number of the compositional fields. When only one value is supplied, this "
-                           "same value is assumed for all compositional fields.\n"
-                           "Available options are:\n"
-                           "  * `bound preserving': a limiter that keeps the discontinuous solution "
-                           "in the range given by `Global temperature maximum' and `Global temperature "
-                           "minimum'.\n"
-                           "  * `WENO': a limiter that eliminates spurious oscillations by reconstructing "
-                           "a polynomial function in places where shocks are detected, as described in "
-                           "\\cite{zhong:etal:2013}.\n"
-                           "  * `none`: if chosen, no limiter is applied to the discontinuous solution.\n"
-                           "Note that if this entry is not set to `none', then the limiter will modify "
-                           "the solution, so the nonlinear residual for this field is meaning less, and "
-                           "in nonlinear solvers we will ignore the residual for this field to evaluate "
-                           "if the nonlinear solver has converged.");
-        prm.declare_entry ("Global temperature maximum",
-                           boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
-                           Patterns::Double (),
-                           "The maximum global temperature value that will be used in the bound preserving "
-                           "limiter for the discontinuous solutions from temperature advection fields. "
-                           "The input value is active only when `Limiter for discontinuous temperature "
-                           "solution' is set to `bound preserving'.");
-        prm.declare_entry ("Global temperature minimum",
-                           boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
-                           Patterns::Double (),
-                           "The minimum global temperature value that will be used in the bound preserving "
-                           "limiter for the discontinuous solutions from temperature advection fields."
-                           "The input value is active only when `Limiter for discontinuous temperature "
-                           "solution' is set to `bound preserving'.");
-        prm.declare_entry ("Global composition maximum",
-                           boost::lexical_cast<std::string>(std::numeric_limits<double>::max()),
-                           Patterns::List(Patterns::Double ()),
-                           "The maximum global composition values that will be used in the bound preserving "
-                           "limiter for the discontinuous solutions from composition advection fields. "
-                           "The number of the input 'Global composition maximum' values separated by ',' has to be "
-                           "one or the same as the number of the compositional fields. When only one value "
-                           "is supplied, this same value is assumed for all compositional fields. "
-                           "The input value is active only when `Limiter for discontinuous composition "
-                           "solution' is set to `bound preserving'.");
-        prm.declare_entry ("Global composition minimum",
-                           boost::lexical_cast<std::string>(std::numeric_limits<double>::lowest()),
-                           Patterns::List(Patterns::Double ()),
-                           "The minimum global composition value that will be used in the bound preserving "
-                           "limiter for the discontinuous solutions from composition advection fields. "
-                           "The number of the input 'Global composition minimum' values separated by ',' has to be "
-                           "one or the same as the number of the compositional fields. When only one value "
-                           "is supplied, this same value is assumed for all compositional fields.\n"
-                           "The input value is active only when `Limiter for discontinuous composition "
-                           "solution' is set to `bound preserving'.");
-        prm.declare_entry ("Temperature KXRCF indicator threshold", "1.0",
-                           Patterns::Double(0.0),
-                           "The threshold of KXRCF indicator for the temperature field, as described in "
-                           "\\cite{Krivodonova:etal:2004}. If the KXRCF indicator of a cell is greater than "
-                           "the threshold, then the cell is marked as 'troubled' and will be smoothed by "
-                           "the WENO limiter.\n"
-                           "The input value is active only when `Limiter for discontinuous temperature "
-                           "solution' is set to `WENO'.");
-        prm.declare_entry ("Composition KXRCF indicator threshold", "1.0",
-                           Patterns::List(Double(0.0)),
-                           "The threshold of KXRCF indicator for the temperature field, as described in "
-                           "\\cite{Krivodonova:etal:2004}. If the KXRCF indicator of a cell is greater than "
-                           "the threshold, then the cell is marked as 'troubled' and will be smoothed by "
-                           "the WENO limiter. The number of the input values separated by ',' has to be one "
-                           "or the same as the number of the compositional fields. When only one value is "
-                           "supplied, this same value is assumed for all compositional fields.\n"
-                           "The input value is active only when `Limiter for discontinuous composition "
-                           "solution' is set to `WENO'.");
-        prm.declare_entry ("WENO linear weight of neighbor cells", "0.001",
-                           Patterns::Double(0.0, 1.0),
-                           "The linear weight of neighbor cells in WENO scheme. The larger this value is, "
-                           "the more weight is given to information from neighbor cells when reconstructing the polynomial "
-                           "reconstruction. See \\cite{zhong:etal:2013} for detail.");
-      }
-      prm.leave_subsection ();
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection ("Temperature field");
-    {
-      prm.declare_entry ("Temperature method", "field",
-                         Patterns::Selection("field|prescribed field|prescribed field with diffusion|static"),
-                         "A comma separated list denoting the solution method of the "
-                         "temperature field. Each entry of the list must be "
-                         "one of the currently implemented field types."
-                         "\n\n"
-                         "These choices correspond to the following methods by which "
-                         "the temperature field gains its values:"
-                         "\\begin{itemize}"
-                         "\\item ``field'': If the temperature is marked with this "
-                         "method, then its values are computed in each time step by "
-                         "solving the temperature advection-diffusion equation. In other words, "
-                         "this corresponds to the usual notion of a temperature. "
-                         "\n"
-                         "\\item ``prescribed field'': The value of the temperature is determined "
-                         "in each time step from the material model. If a compositional field is "
-                         "marked with this method, then the value of a specific additional material "
-                         "model output, called the `PrescribedTemperatureOutputs' is interpolated "
-                         "onto the temperature. This field does not change otherwise, it is not "
-                         "advected with the flow. "
-                         "\n"
-                         "\\item ``prescribed field with diffusion'': If the temperature field is "
-                         "marked this way, the value of a specific additional material model output, "
-                         "called the `PrescribedTemperatureOutputs' is interpolated onto the field, as in "
-                         "the ``prescribed field'' method. Afterwards, the field is diffused based on "
-                         "a solver parameter, the diffusion length scale, smoothing the field. "
-                         "Specifically, the field is updated by solving the equation "
-                         "$(I-l^2 \\Delta) T_\\text{smoothed} = T_\\text{prescribed}$, "
-                         "where $l$ is the diffusion length scale. Note that this means that the amount "
-                         "of diffusion is independent of the time step size, and that the field is not "
-                         "advected with the flow."
-                         "\n"
-                         "\\item ``static'': If a temperature field is marked "
-                         "this way, then it does not evolve at all. Its values are "
-                         "simply set to the initial conditions, and will then "
-                         "never change."
-                         "\\end{itemize}");
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Compositional fields");
-    {
-      prm.declare_entry ("Number of fields", "0",
-                         Patterns::Integer (0),
-                         "The number of fields that will be advected along with the flow field, excluding "
-                         "velocity, pressure and temperature.");
-      prm.declare_entry ("Names of fields", "",
-                         Patterns::List(Patterns::Anything()),
-                         "A user-defined name for each of the compositional fields requested.");
-      prm.declare_entry ("Types of fields", "unspecified",
-                         Patterns::List (Patterns::Selection("chemical composition|stress|strain|grain size|porosity|density|entropy|generic|unspecified")),
-                         "A type for each of the compositional fields requested. "
-                         "Each entry of the list must be "
-                         "one of several recognized types: chemical composition, "
-                         "stress, strain, grain size, porosity, density, entropy, "
-                         "general and unspecified. "
-                         "The generic type is intended to be a placeholder type "
-                         "that has no effect on the running of any material model, "
-                         "while the unspecified type is intended to tell ASPECT "
-                         "that the user has not explicitly indicated the type of "
-                         "field (facilitating parameter file checking). "
-                         "Plugins such as material models can use these types "
-                         "to affect how that plugin functions.");
-      prm.declare_entry ("Compositional field methods", "",
-                         Patterns::List (Patterns::Selection("field|particles|volume of fluid|static|melt field|darcy field|prescribed field|prescribed field with diffusion")),
-                         "A comma separated list denoting the solution method of each "
-                         "compositional field. Each entry of the list must be "
-                         "one of the currently implemented field methods."
-                         "\n\n"
-                         "These choices correspond to the following methods by which "
-                         "compositional fields gain their values:"
-                         "\\begin{itemize}"
-                         "\\item ``field'': If a compositional field is marked with this "
-                         "method, then its values are computed in each time step by "
-                         "advecting along the values of the previous time step using the "
-                         "velocity field, and applying reaction rates to it. In other words, "
-                         "this corresponds to the usual notion of a composition field as "
-                         "mentioned in Section~\\ref{sec:methods:compositional-fields}. "
-                         "\n"
-                         "\\item ``particles'': If a compositional field is marked with "
-                         "this method, then its values are obtained in each time step "
-                         "by interpolating the corresponding properties from the "
-                         "particles located on each cell. The time evolution therefore "
-                         "happens because particles move along with the velocity field, "
-                         "and particle properties can react with each other as well. "
-                         "See Section~\\ref{sec:methods:particles} for more information about "
-                         "how particles behave."
-                         "\n"
-                         "\\item ``volume of fluid``: If a compositional field "
-                         "is marked with this method, then its values are "
-                         "obtained in each timestep by reconstructing a "
-                         "polynomial finite element approximation on each cell "
-                         "from a volume of fluid interface tracking method, "
-                         "which is used to compute the advection updates."
-                         "\n"
-                         "\\item ``static'': If a compositional field is marked "
-                         "this way, then it does not evolve at all. Its values are "
-                         "simply set to the initial conditions, and will then "
-                         "never change."
-                         "\n"
-                         "\\item ``melt field'': If a compositional field is marked with this "
-                         "method, then its values are computed in each time step by "
-                         "advecting along the values of the previous time step using the "
-                         "melt velocity, and applying reaction rates to it. In other words, "
-                         "this corresponds to the usual notion of a composition field as "
-                         "mentioned in Section~\\ref{sec:methods:compositional-fields}, except that it is "
-                         "advected with the melt velocity instead of the solid velocity. "
-                         "This method can only be chosen if melt transport is active in the "
-                         "model."
-                         "\n"
-                         "\\item ``darcy field'': If a compositional field is marked with this "
-                         "method, then its values are computed in each time step by "
-                         "advecting along the values of the previous time step using the "
-                         "fluid velocity prescribed by Darcy's Law, and applying reaction rates "
-                         "to it. In other words this corresponds to the usual notion of a composition "
-                         "field as mentioned in Section~\\ref{sec:methods:compositional-fields}, except that it is "
-                         "advected with the Darcy velocity instead of the solid velocity. This method "
-                         "requires there to be a compositional field named porosity that is advected "
-                         "the darcy field method. We calculate the fluid velocity $u_f$ using an "
-                         "approximation of Darcy's Law: $u_f = u_s - K_D / \\phi * (rho_s * g - rho_f * g)$."
-                         "\n"
-                         "\\item ``prescribed field'': The value of these fields is determined "
-                         "in each time step from the material model. If a compositional field is "
-                         "marked with this method, then the value of a specific additional material "
-                         "model output, called the `PrescribedFieldOutputs' is interpolated "
-                         "onto the field. This field does not change otherwise, it is not "
-                         "advected with the flow."
-                         "\n"
-                         "\\item ``prescribed field with diffusion'': If a compositional field is "
-                         "marked this way, the value of a specific additional material model output, "
-                         "called the `PrescribedFieldOutputs' is interpolated onto the field, as in "
-                         "the ``prescribed field'' method. Afterwards, the field is diffused based on "
-                         "a solver parameter, the diffusion length scale, smoothing the field. "
-                         "Specifically, the field is updated by solving the equation "
-                         "$(I-l^2 \\Delta) C_\\text{smoothed} = C_\\text{prescribed}$, "
-                         "where $l$ is the diffusion length scale. Note that this means that the amount "
-                         "of diffusion is independent of the time step size, and that the field is not "
-                         "advected with the flow."
-                         "\\end{itemize}");
-      prm.declare_entry ("Mapped particle properties", "",
-                         Patterns::Map (Patterns::Anything(),
-                                        Patterns::Anything()),
-                         "A comma separated list denoting the particle properties "
-                         "that will be projected to those compositional fields that "
-                         "are of the ``particles'' field type."
-                         "\n\n"
-                         "The format of valid entries for this parameter is that of a map "
-                         "given as ``key1: value1, key2: value2 [component2], key3: value3 [component4], "
-                         "...'' where each key must be a valid field name of the "
-                         "``particles'' type, and each value must be one of the currently "
-                         "selected particle properties. Component is a component index of "
-                         "the particle property that is 0 by default, but can be set up to "
-                         "n-1, where n is the number of vector components of this particle "
-                         "property. The component indicator only needs to be "
-                         "set if not the first component of the particle property should be "
-                         "mapped (e.g. the $y$-component of the velocity at the particle positions).");
-      prm.declare_entry ("List of normalized fields", "",
-                         Patterns::List (Patterns::Integer(0)),
-                         "A list of integers smaller than or equal to the number of "
-                         "compositional fields. All compositional fields in this "
-                         "list will be normalized before the first timestep. "
-                         "The normalization is implemented in the following way: "
-                         "First, the sum of the fields to be normalized is calculated "
-                         "at every point and the global maximum is determined. "
-                         "Second, the compositional fields to be normalized are "
-                         "divided by this maximum.");
-    }
-    prm.leave_subsection ();
-
-    // Finally declare a couple of parameters related how we should
-    // evaluate the material models when assembling the matrix and
-    // preconditioner
-    prm.enter_subsection ("Material model");
-    {
-      prm.declare_entry ("Material averaging", "default averaging",
-                         Patterns::Selection(MaterialModel::MaterialAveraging::
-                                             get_averaging_operation_names()),
-                         "Whether or not (and in the first case, how) to do any averaging of "
-                         "material model output data when constructing the linear systems "
-                         "for velocity/pressure, temperature, and compositions in each "
-                         "time step, as well as their corresponding preconditioners. "
-                         "The default value 'default averaging' will choose the averaging "
-                         "option based on the Stokes solver type."
-                         "\n\n"
-                         "Possible choices: " + MaterialModel::MaterialAveraging::
-                         get_averaging_operation_names()
-                         +
-                         "\n\n"
-                         "The process of averaging, and where it may be used, is "
-                         "discussed in more detail in "
-                         "Section~\\ref{sec:cookbooks:sinker-with-averaging}."
-                         "\n\n"
-                         "More averaging schemes are available in the averaging material "
-                         "model. This material model is a ``compositing material model'' "
-                         "which can be used in combination with other material models.");
-    }
-    prm.leave_subsection ();
-
-    VolumeOfFluidHandler<dim>::declare_parameters(prm);
-
-    // then, finally, let user additions that do not go through the usual
-    // plugin mechanism, declare their parameters if they have subscribed
-    // to the relevant signals
-    SimulatorSignals<dim>::declare_additional_parameters (dim, prm);
-  }
-
-
-
-  template <int dim>
-  void
-  Parameters<dim>::
-  parse_parameters (ParameterHandler &prm,
-                    const MPI_Comm mpi_communicator)
-  {
-    // first, make sure that the ParameterHandler parser agrees
-    // with the code in main() about the meaning of the "Dimension"
-    // parameter
-    AssertThrow (prm.get_integer("Dimension") == dim,
-                 ExcInternalError());
-
-    CFL_number              = prm.get_double ("CFL number");
-    use_conduction_timestep = prm.get_bool ("Use conduction timestep");
-    convert_to_years        = prm.get_bool ("Use years in output instead of seconds");
-    timing_output_frequency = prm.get_integer ("Timing output frequency");
-    world_builder_file      = prm.get("World builder file");
-
-    maximum_time_step       = prm.get_double("Maximum time step");
-    if (convert_to_years == true)
-      maximum_time_step *= year_in_seconds;
-
-    maximum_relative_increase_time_step = prm.get_double("Maximum relative increase in time step") * 0.01;
-    maximum_first_time_step = prm.get_double("Maximum first time step");
-    if (convert_to_years == true)
-      maximum_first_time_step *= year_in_seconds;
-
-    {
-      const std::string solver_scheme = prm.get ("Nonlinear solver scheme");
-      if (solver_scheme == "single Advection, single Stokes" || solver_scheme == "IMPES")
-        nonlinear_solver = NonlinearSolver::single_Advection_single_Stokes;
-      else if (solver_scheme == "iterated Advection and Stokes" || solver_scheme == "iterated IMPES")
-        nonlinear_solver = NonlinearSolver::iterated_Advection_and_Stokes;
-      else if (solver_scheme == "single Advection, iterated Stokes" || solver_scheme == "iterated Stokes")
-        nonlinear_solver = NonlinearSolver::single_Advection_iterated_Stokes;
-      else if (solver_scheme == "no Advection, iterated Stokes" || solver_scheme == "Stokes only")
-        nonlinear_solver = NonlinearSolver::no_Advection_iterated_Stokes;
-      else if (solver_scheme == "no Advection, single Stokes")
-        nonlinear_solver = NonlinearSolver::no_Advection_single_Stokes;
-      else if (solver_scheme == "no Advection, iterated defect correction Stokes")
-        nonlinear_solver = NonlinearSolver::no_Advection_iterated_defect_correction_Stokes;
-      else if (solver_scheme == "single Advection, iterated defect correction Stokes")
-        nonlinear_solver = NonlinearSolver::single_Advection_iterated_defect_correction_Stokes;
-      else if (solver_scheme == "iterated Advection and defect correction Stokes")
-        nonlinear_solver = NonlinearSolver::iterated_Advection_and_defect_correction_Stokes;
-      else if (solver_scheme == "iterated Advection and Newton Stokes" || solver_scheme == "Newton Stokes")
-        nonlinear_solver = NonlinearSolver::iterated_Advection_and_Newton_Stokes;
-      else if (solver_scheme == "single Advection, iterated Newton Stokes")
-        nonlinear_solver = NonlinearSolver::single_Advection_iterated_Newton_Stokes;
-      else if (solver_scheme == "single Advection, no Stokes" || solver_scheme == "Advection only")
-        nonlinear_solver = NonlinearSolver::single_Advection_no_Stokes;
-      else if (solver_scheme == "first timestep only, single Stokes")
-        nonlinear_solver = NonlinearSolver::first_timestep_only_single_Stokes;
-      else if (solver_scheme == "no Advection, no Stokes")
-        nonlinear_solver = NonlinearSolver::no_Advection_no_Stokes;
-      else
-        AssertThrow (false, ExcNotImplemented());
-    }
-
-    prm.enter_subsection ("Solver parameters");
-    {
-      temperature_solver_tolerance    = prm.get_double ("Temperature solver tolerance");
-      composition_solver_tolerance    = prm.get_double ("Composition solver tolerance");
-
-      prm.enter_subsection ("Advection solver parameters");
-      {
-        advection_gmres_restart_length     = prm.get_integer("GMRES solver restart length");
-      }
-      prm.leave_subsection ();
-
-      prm.enter_subsection ("Stokes solver parameters");
-      {
-        stokes_solver_type = StokesSolverType::parse(prm.get("Stokes solver type"));
-        if (prm.get_bool("Use direct solver for Stokes system"))
-          stokes_solver_type = StokesSolverType::direct_solver;
-        use_bfbt = prm.get_bool("Use weighted BFBT for Schur complement");
-        use_direct_stokes_solver        = stokes_solver_type==StokesSolverType::direct_solver;
-        stokes_krylov_type = StokesKrylovType::parse(prm.get("Krylov method for cheap solver steps"));
-        idr_s_parameter    = prm.get_integer("IDR(s) parameter");
-
-        linear_stokes_solver_tolerance  = prm.get_double ("Linear solver tolerance");
-        n_cheap_stokes_solver_steps     = prm.get_integer ("Number of cheap Stokes solver steps");
-        n_expensive_stokes_solver_steps = prm.get_integer ("Maximum number of expensive Stokes solver steps");
-        linear_solver_A_block_tolerance = prm.get_double ("Linear solver A block tolerance");
-        use_full_A_block_preconditioner = prm.get_bool ("Use full A block as preconditioner");
-        force_nonsymmetric_A_block_solver = prm.get_bool("Force nonsymmetric A block solver");
-        linear_solver_S_block_tolerance = prm.get_double ("Linear solver S block tolerance");
-        stokes_gmres_restart_length     = prm.get_integer("GMRES solver restart length");
-      }
-      prm.leave_subsection ();
-
-      prm.enter_subsection ("AMG parameters");
-      {
-        AMG_smoother_type                      = prm.get ("AMG smoother type");
-        AMG_smoother_sweeps                    = prm.get_integer ("AMG smoother sweeps");
-        AMG_aggregation_threshold              = prm.get_double ("AMG aggregation threshold");
-        AMG_output_details                     = prm.get_bool ("AMG output details");
-      }
-      prm.leave_subsection ();
-      prm.enter_subsection ("Operator splitting parameters");
-      {
-        reaction_solver_type                   = ReactionSolverType::parse(prm.get("Reaction solver type"));
-        ARKode_relative_tolerance              = prm.get_double("Reaction solver relative tolerance");
-        reaction_time_step       = prm.get_double("Reaction time step");
-        AssertThrow (reaction_time_step > 0,
-                     ExcMessage("Reaction time step must be greater than 0."));
-        if (convert_to_years == true)
-          reaction_time_step *= year_in_seconds;
-        reaction_steps_per_advection_step = prm.get_integer ("Reaction time steps per advection step");
-      }
-      prm.leave_subsection ();
-      prm.enter_subsection ("Diffusion solver parameters");
-      {
-        diffusion_length_scale = prm.get_double("Diffusion length scale");
-      }
-      prm.leave_subsection ();
-    }
-    prm.leave_subsection ();
-
-    nonlinear_tolerance = prm.get_double("Nonlinear solver tolerance");
-
-    max_nonlinear_iterations = prm.get_integer ("Max nonlinear iterations");
-    max_nonlinear_iterations_in_prerefinement = prm.get_integer ("Max nonlinear iterations in pre-refinement");
-
-    start_time              = prm.get_double ("Start time");
-    if (convert_to_years == true)
-      start_time *= year_in_seconds;
-
-    end_time = prm.get_double ("End time");
-    if (convert_to_years == true)
-      end_time *= year_in_seconds;
-
-    output_directory        = prm.get ("Output directory");
-    if (output_directory.size() == 0)
-      output_directory = "./";
-    else if (output_directory[output_directory.size()-1] != '/')
-      output_directory += "/";
-
-    Utilities::create_directory (output_directory,
-                                 mpi_communicator,
-                                 false);
-
-    if (prm.get ("Resume computation") == "true")
-      resume_computation = true;
-    else if (prm.get ("Resume computation") == "false")
-      resume_computation = false;
-    else if (prm.get ("Resume computation") == "auto")
-      {
-        resume_computation = Utilities::fexists(output_directory+"restart.mesh", mpi_communicator);
-      }
-    else
-      AssertThrow (false, ExcMessage ("Resume computation parameter must be either `true', `false', or `auto'."));
-#ifndef DEAL_II_WITH_ZLIB
-    AssertThrow (resume_computation == false,
-                 ExcMessage ("You need to have deal.II configured with the `libz' "
-                             "option if you want to resume a computation from a checkpoint, but deal.II "
-                             "did not detect its presence when you called `cmake'."));
-#endif
-
-    surface_pressure                = prm.get_double ("Surface pressure");
-    adiabatic_surface_temperature   = prm.get_double ("Adiabatic surface temperature");
-    pressure_normalization          = prm.get("Pressure normalization");
-
-    use_operator_splitting          = prm.get_bool("Use operator splitting");
-
-    prm.enter_subsection ("Mesh refinement");
-    {
-      initial_global_refinement    = prm.get_integer ("Initial global refinement");
-      initial_adaptive_refinement  = prm.get_integer ("Initial adaptive refinement");
-
-      adaptive_refinement_interval = prm.get_integer ("Time steps between mesh refinement");
-      refinement_fraction          = prm.get_double ("Refinement fraction");
-      coarsening_fraction          = prm.get_double ("Coarsening fraction");
-      adapt_by_fraction_of_cells   = prm.get_bool ("Adapt by fraction of cells");
-      min_grid_level               = prm.get_integer ("Minimum refinement level");
-
-      AssertThrow(refinement_fraction >= 0 && coarsening_fraction >= 0,
-                  ExcMessage("Refinement/coarsening fractions must be positive."));
-      AssertThrow(refinement_fraction+coarsening_fraction <= 1,
-                  ExcMessage("Refinement and coarsening fractions must be <= 1."));
-      AssertThrow(min_grid_level <= initial_global_refinement,
-                  ExcMessage("Minimum refinement level must not be larger than "
-                             "Initial global refinement."));
-
-      // extract the list of times at which additional refinement is requested
-      // then sort it and convert it to seconds
-      additional_refinement_times
-        = Utilities::string_to_double
-          (Utilities::split_string_list(prm.get ("Additional refinement times")));
-      std::sort (additional_refinement_times.begin(),
-                 additional_refinement_times.end());
-      if (convert_to_years == true)
-        for (double &additional_refinement_time : additional_refinement_times)
-          additional_refinement_time *= year_in_seconds;
-
-      skip_solvers_on_initial_refinement = prm.get_bool("Skip solvers on initial refinement");
-      skip_setup_initial_conditions_on_initial_refinement = prm.get_bool("Skip setup initial conditions on initial refinement");
-
-      if (skip_setup_initial_conditions_on_initial_refinement == true && skip_solvers_on_initial_refinement == false)
-        AssertThrow(false, ExcMessage("Cannot execute solvers if no initial conditions are set up. "
-                                      "You must set skip_solvers_on_initial_refinement to true."));
-
-      run_postprocessors_on_initial_refinement = prm.get_bool("Run postprocessors on initial refinement");
-
-      if (skip_setup_initial_conditions_on_initial_refinement == true && run_postprocessors_on_initial_refinement == true)
-        AssertThrow(false, ExcMessage("Cannot run postprocessors if no initial conditions are set up. "
-                                      "You must set run_postprocessors_on_initial_refinement to false."));
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection ("Postprocess");
-    {
-      run_postprocessors_on_nonlinear_iterations = prm.get_bool("Run postprocessors on nonlinear iterations");
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection ("Formulation");
-    {
-      // The following options each have a set of conditions to be met in order
-      // for the formulation to be consistent, however, most of
-      // the information is not available at this point. Therefore, the error checking is done
-      // in Simulator<dim>::check_consistency_of_formulation() after the initialization of
-      // material models, heating plugins, and adiabatic conditions.
-      formulation = Formulation::parse(prm.get("Formulation"));
-      if (formulation == Formulation::isentropic_compression)
-        {
-          formulation_mass_conservation = Formulation::MassConservation::isentropic_compression;
-          formulation_temperature_equation = Formulation::TemperatureEquation::real_density;
-        }
-      else if (formulation == Formulation::boussinesq_approximation)
-        {
-          formulation_mass_conservation = Formulation::MassConservation::incompressible;
-          formulation_temperature_equation = Formulation::TemperatureEquation::reference_density_profile;
-        }
-      else if (formulation == Formulation::anelastic_liquid_approximation)
-        {
-          // equally possible: implicit_reference_profile
-          formulation_mass_conservation = Formulation::MassConservation::reference_density_profile;
-          formulation_temperature_equation = Formulation::TemperatureEquation::reference_density_profile;
-        }
-      else if (formulation == Formulation::custom)
-        {
-          formulation_mass_conservation = Formulation::MassConservation::parse(prm.get("Mass conservation"));
-          formulation_temperature_equation = Formulation::TemperatureEquation::parse(prm.get("Temperature equation"));
-        }
-      else AssertThrow(false, ExcNotImplemented());
-
-      enable_additional_stokes_rhs = prm.get_bool ("Enable additional Stokes RHS");
-      enable_elasticity = prm.get_bool("Enable elasticity");
-      enable_prescribed_dilation = prm.get_bool("Enable prescribed dilation");
-    }
-    prm.leave_subsection ();
-
-
-    prm.enter_subsection ("Melt settings");
-    {
-      include_melt_transport = prm.get_bool ("Include melt transport");
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Nullspace removal");
-    {
-      nullspace_removal = NullspaceRemoval::none;
-      std::vector<std::string> nullspace_names =
-        Utilities::split_string_list(prm.get("Remove nullspace"));
-      AssertThrow(Utilities::has_unique_entries(nullspace_names),
-                  ExcMessage("The list of strings for the parameter "
-                             "'Nullspace removal/Remove nullspace' contains entries more than once. "
-                             "This is not allowed. Please check your parameter file."));
-
-      for (const auto &nullspace_name : nullspace_names)
-        {
-          if (nullspace_name=="net rotation")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::net_rotation);
-          else if (nullspace_name=="net surface rotation")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::net_surface_rotation);
-          else if (nullspace_name=="angular momentum")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::angular_momentum);
-          else if (nullspace_name=="net translation")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::net_translation_x |
-                                  NullspaceRemoval::net_translation_y | ( dim == 3 ?
-                                                                          NullspaceRemoval::net_translation_z : 0) );
-          else if (nullspace_name=="net x translation")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::net_translation_x);
-          else if (nullspace_name=="net y translation")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::net_translation_y);
-          else if (nullspace_name=="net z translation")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::net_translation_z);
-          else if (nullspace_name=="linear x momentum")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::linear_momentum_x);
-          else if (nullspace_name=="linear y momentum")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::linear_momentum_y);
-          else if (nullspace_name=="linear z momentum")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::linear_momentum_z);
-          else if (nullspace_name=="linear momentum")
-            nullspace_removal = typename NullspaceRemoval::Kind(
-                                  nullspace_removal | NullspaceRemoval::linear_momentum_x |
-                                  NullspaceRemoval::linear_momentum_y | ( dim == 3 ?
-                                                                          NullspaceRemoval::linear_momentum_z : 0) );
-          else
-            AssertThrow(false, ExcInternalError());
-        }
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection ("Checkpointing");
-    {
-      checkpoint_time_secs = prm.get_integer ("Time between checkpoint");
-      checkpoint_steps     = prm.get_integer ("Steps between checkpoint");
-
-#ifndef DEAL_II_WITH_ZLIB
-      AssertThrow ((checkpoint_time_secs == 0)
-                   &&
-                   (checkpoint_steps == 0),
-                   ExcMessage ("You need to have deal.II configured with the `libz' "
-                               "option if you want to generate checkpoints, but deal.II "
-                               "did not detect its presence when you called `cmake'."));
-#endif
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection ("Compositional fields");
-    {
-      n_compositional_fields = prm.get_integer ("Number of fields");
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Discretization");
-    {
-      stokes_velocity_degree = prm.get_integer ("Stokes velocity polynomial degree");
-      temperature_degree     = prm.get_integer ("Temperature polynomial degree");
-      composition_degree     = prm.get_integer ("Composition polynomial degree");
-      use_locally_conservative_discretization
-        = prm.get_bool ("Use locally conservative discretization");
-      use_equal_order_interpolation_for_stokes
-        = prm.get_bool ("Use equal order interpolation for Stokes");
-      use_discontinuous_temperature_discretization
-        = prm.get_bool("Use discontinuous temperature discretization");
-      use_discontinuous_composition_discretization
-        = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_bool(Utilities::split_string_list(prm.get("Use discontinuous composition discretization"))),
-                                                  n_compositional_fields,
-                                                  "Use discontinuous composition discretization");
-      have_discontinuous_composition_discretization =
-        (std::find(use_discontinuous_composition_discretization.begin(), use_discontinuous_composition_discretization.end(), true)
-         != use_discontinuous_composition_discretization.end());
-
-      // TODO: this needs to be modified once we lift the restriction that all compositions have the same degree.
-      AssertThrow(have_discontinuous_composition_discretization == true || composition_degree > 0,
-                  ExcMessage("Using a composition polynomial degree of 0 (cell-wise constant composition) "
-                             "is only supported if a discontinuous composition discretization is selected."));
-
-      prm.enter_subsection ("Stabilization parameters");
-      {
-        advection_stabilization_method = AdvectionStabilizationMethod::parse(prm.get("Stabilization method"));
-        use_artificial_viscosity_smoothing  = prm.get_bool ("Use artificial viscosity smoothing");
-        stabilization_alpha                 = prm.get_integer ("alpha");
-
-        stabilization_c_R                   = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("cR"))),
-                                                                                      n_compositional_fields+1,
-                                                                                      "cR");
-        stabilization_beta                  = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("beta"))),
-                                                                                      n_compositional_fields+1,
-                                                                                      "beta");
-
-        stabilization_gamma                 = prm.get_double ("gamma");
-        discontinuous_penalty               = prm.get_double ("Discontinuous penalty");
-
-        limiter_for_discontinuous_temperature_solution = DGLimiterType::parse(prm.get("Limiter for discontinuous temperature solution"));
-        std::vector<std::string> x_limiter_for_discontinuous_composition_solution =
-          Utilities::possibly_extend_from_1_to_N(Utilities::split_string_list(prm.get("Limiter for discontinuous composition solution")),
-                                                 n_compositional_fields,
-                                                 "Limiter for discontinuous composition solution");
-        limiter_for_discontinuous_composition_solution.resize(n_compositional_fields);
-        for (unsigned int c = 0; c < n_compositional_fields; ++c)
-          limiter_for_discontinuous_composition_solution[c] = DGLimiterType::parse(x_limiter_for_discontinuous_composition_solution[c]);
-
-        global_temperature_max_preset       = prm.get_double ("Global temperature maximum");
-        global_temperature_min_preset       = prm.get_double ("Global temperature minimum");
-        global_composition_max_preset       = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double
-                                                                                      (Utilities::split_string_list(prm.get ("Global composition maximum"))),
-                                                                                      n_compositional_fields,
-                                                                                      "Global composition maximum");
-        global_composition_min_preset       = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double
-                                                                                      (Utilities::split_string_list(prm.get ("Global composition minimum"))),
-                                                                                      n_compositional_fields,
-                                                                                      "Global composition minimum");
-
-        temperature_KXRCF_indicator_threshold = prm.get_double ("Temperature KXRCF indicator threshold");
-        composition_KXRCF_indicator_threshold = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double
-                                                                                        (Utilities::split_string_list(prm.get("Composition KXRCF indicator threshold"))),
-                                                                                        n_compositional_fields,
-                                                                                        "Composition KXRCF indicator threshold");
-        WENO_linear_weight = prm.get_double("WENO linear weight of neighbor cells");
-
-        compositional_fields_with_disabled_boundary_entropy_viscosity =
-          Utilities::split_string_list(prm.get("List of compositional fields with disabled boundary entropy viscosity"));
-
-      }
-      prm.leave_subsection ();
-
-      AssertThrow ((use_locally_conservative_discretization ||
-                    use_equal_order_interpolation_for_stokes)
-                   ||
-                   (stokes_velocity_degree > 1),
-                   ExcMessage ("The polynomial degree for the velocity field "
-                               "specified in the 'Stokes velocity polynomial degree' "
-                               "parameter must be at least 2, unless you are using "
-                               "the 'Use equal order interpolation for Stokes' parameter, "
-                               "or if you are using "
-                               "a locally conservative discretization as specified by the "
-                               "'Use locally conservative discretization' parameter. "
-                               "In both of these cases, the polynomial degree used for the "
-                               "velocity may be equal to one."
-                               "\n\n"
-                               "The restriction exists because by default, the pressure element "
-                               "is of one degree lower and continuous, and if you selected "
-                               "a linear element for the velocity, you'd need a continuous "
-                               "element of degree zero for the pressure, which does not exist. "
-                               "On the other hand, if using equal-order interpolation, "
-                               "choosing the polynomial degree as one yields a Q1-Q1 "
-                               "element; using a locally conservative discretization "
-                               "with polynomial degree of one yields a Q1-P0 "
-                               "element."));
-
-      AssertThrow (! (use_locally_conservative_discretization &&
-                      use_equal_order_interpolation_for_stokes),
-                   ExcMessage ("You have tried to use both the 'Use locally "
-                               "conservative discretization' and 'Use equal order "
-                               "interpolation for Stokes' parameters in the input "
-                               "file. However, their use is incompatible: you "
-                               "can only select one of the two."));
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection ("Temperature field");
-    {
-      std::string x_temperature_method
-        = prm.get ("Temperature method");
-
-      if (x_temperature_method == "field")
-        temperature_method = AdvectionFieldMethod::fem_field;
-      else if (x_temperature_method == "prescribed field")
-        temperature_method = AdvectionFieldMethod::prescribed_field;
-      else if (x_temperature_method == "prescribed field with diffusion")
-        temperature_method = AdvectionFieldMethod::prescribed_field_with_diffusion;
-      else if (x_temperature_method == "static")
-        temperature_method = AdvectionFieldMethod::static_field;
-      else
-        AssertThrow(false,ExcNotImplemented());
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Compositional fields");
-    {
-      if (include_melt_transport && (n_compositional_fields == 0))
-        {
-          AssertThrow (false,
-                       ExcMessage ("If melt transport is included in the model, "
-                                   "there has to be at least one compositional field."));
-        }
-
-      names_of_compositional_fields = Utilities::split_string_list (prm.get("Names of fields"));
-      AssertThrow ((names_of_compositional_fields.size() == 0) ||
-                   (names_of_compositional_fields.size() == n_compositional_fields),
-                   ExcMessage ("The length of the list of names for the compositional "
-                               "fields needs to either be empty or have length equal to "
-                               "the number of compositional fields."));
-
-      // check that the names use only allowed characters, are not empty strings and are unique
-      for (unsigned int i=0; i<names_of_compositional_fields.size(); ++i)
-        {
-          AssertThrow (names_of_compositional_fields[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
-                                                                          "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                                                          "0123456789_") == std::string::npos,
-                       ExcMessage("Invalid character in field " + names_of_compositional_fields[i] + ". "
-                                  "Names of compositional fields should consist of a "
-                                  "combination of letters, numbers and underscores."));
-          AssertThrow (names_of_compositional_fields[i].size() > 0,
-                       ExcMessage("Invalid name of field " + names_of_compositional_fields[i] + ". "
-                                  "Names of compositional fields need to be non-empty."));
-          for (unsigned int j=0; j<i; ++j)
-            AssertThrow (names_of_compositional_fields[i] != names_of_compositional_fields[j],
-                         ExcMessage("Names of compositional fields have to be unique! " + names_of_compositional_fields[i] +
-                                    " is used more than once."));
-        }
-
-      // default names if list is empty
-      if (names_of_compositional_fields.size() == 0)
-        for (unsigned int i=0; i<n_compositional_fields; ++i)
-          names_of_compositional_fields.push_back("C_" + Utilities::int_to_string(i+1));
-
-      // if we want to solve the melt transport equations, check that one of the fields
-      // has the name porosity
-      if (include_melt_transport && std::find(names_of_compositional_fields.begin(),
-                                              names_of_compositional_fields.end(), "porosity")
-          == names_of_compositional_fields.end())
-        {
-          AssertThrow (false, ExcMessage ("If melt transport is included in the model, "
-                                          "there has to be at least one compositional field "
-                                          "with the name `porosity'."));
-        }
-
-      const std::vector<int> n_normalized_fields = Utilities::string_to_int
-                                                   (Utilities::split_string_list(prm.get ("List of normalized fields")));
-      normalized_fields = std::vector<unsigned int> (n_normalized_fields.begin(),
-                                                     n_normalized_fields.end());
-
-      AssertThrow (normalized_fields.size() <= n_compositional_fields,
-                   ExcMessage("Invalid input parameter file: Too many entries in List of normalized fields"));
-
-      // Process the compositional field types
-      // There are three valid cases:
-      // 1) The user doesn't specify types of fields. This choice should
-      // result in the default type being used for all fields.
-      // The default type is "unspecified".
-      // 2) The user specifies just one type of field. In this case, ASPECT
-      // should automatically assume that all fields have the same type.
-      // 3) The user specifies types for every compositional field.
-      std::vector<std::string> x_compositional_field_types
-        = Utilities::split_string_list
-          (prm.get ("Types of fields"));
-
-      AssertThrow ((x_compositional_field_types.size() == 1) ||
-                   (x_compositional_field_types.size() == n_compositional_fields),
-                   ExcMessage ("The length of the list of names for the field types of compositional "
-                               "fields needs to either have one entry or have a length equal to "
-                               "the number of compositional fields."));
-
-      // If only one method is specified apply this to all fields
-      if (x_compositional_field_types.size() == 1)
-        x_compositional_field_types = std::vector<std::string> (n_compositional_fields, x_compositional_field_types[0]);
-
-      for (unsigned int i=0; i<n_compositional_fields; ++i)
-        if (x_compositional_field_types[i] == "unspecified")
-          {
-            // Loop over various possibilities before
-            // choosing "chemical composition" as the standard field name
-            // stress, strain, grain_size, porosity, density
-            if (names_of_compositional_fields[i].find("stress") != std::string::npos)
-              {
-                x_compositional_field_types[i] = "stress";
-                // Fields that are of stress type will not be taken into
-                // account by the viscoplastic and viscoelastic material model
-                // when material properties are computed. Force the user to set a field type
-                // for fields with 'stress' in their name if elasticity is not enabled.
-                AssertThrow(enable_elasticity,
-                            ExcMessage("Even though elasticity is not enabled, ASPECT deduced a stress field type from the name of a compositional field. "
-                                       "Please specify the compositional field types explicitly. "
-                                       "At the moment the type of field " + names_of_compositional_fields[i] + " is unspecified."));
-              }
-            else if ((names_of_compositional_fields[i].find("strain") != std::string::npos)
-                     || (std::regex_match(names_of_compositional_fields[i],std::regex("s[1-3][1-3]"))))
-              x_compositional_field_types[i] = "strain";
-            else if (names_of_compositional_fields[i].find("grain_size") != std::string::npos)
-              x_compositional_field_types[i] = "grain size";
-            else if (names_of_compositional_fields[i].find("entropy") != std::string::npos)
-              x_compositional_field_types[i] = "entropy";
-            else if (names_of_compositional_fields[i] == "porosity")
-              x_compositional_field_types[i] = "porosity";
-            else if (names_of_compositional_fields[i] == "density_field")
-              x_compositional_field_types[i] = "density";
-            else
-              x_compositional_field_types[i] = "chemical composition";
-          }
-
-      // If only one method is specified apply this to all fields
-      if (x_compositional_field_types.size() == 1)
-        x_compositional_field_types = std::vector<std::string> (n_compositional_fields, x_compositional_field_types[0]);
-
-      AssertThrow (std::count(x_compositional_field_types.begin(), x_compositional_field_types.end(), "density") < 2,
-                   ExcMessage("There can only be one field of type 'density' in a simulation!"));
-
-      composition_descriptions.resize(n_compositional_fields);
-
-      for (unsigned int i=0; i<n_compositional_fields; ++i)
-        composition_descriptions[i].type = aspect::CompositionalFieldDescription::parse_type(x_compositional_field_types[i]);
-
-      std::vector<std::string> x_compositional_field_methods
-        = Utilities::split_string_list
-          (prm.get ("Compositional field methods"));
-
-      AssertThrow ((x_compositional_field_methods.size() == 0) ||
-                   (x_compositional_field_methods.size() == 1) ||
-                   (x_compositional_field_methods.size() == n_compositional_fields),
-                   ExcMessage ("The length of the list of names for the field method of compositional "
-                               "fields needs to be empty, or have one entry, or have a length equal to "
-                               "the number of compositional fields."));
-
-      // If no method is specified set the default, which is solve every composition
-      // by a continuous field method
-      if (x_compositional_field_methods.size() == 0)
-        x_compositional_field_methods = std::vector<std::string> (n_compositional_fields,"field");
-      // If only one method is specified assume all fields are solved by this method
-      else if (x_compositional_field_methods.size() == 1)
-        x_compositional_field_methods = std::vector<std::string> (n_compositional_fields,x_compositional_field_methods[0]);
-
-
-      // Parse all field methods and store them, the vector should be empty
-      // since nobody should have written into it yet.
-      Assert(compositional_field_methods.size() == 0,
-             ExcInternalError());
-      compositional_field_methods.resize(n_compositional_fields);
-      for (unsigned int i = 0; i < n_compositional_fields; ++i)
-        {
-          if (x_compositional_field_methods[i] == "field")
-            compositional_field_methods[i] = AdvectionFieldMethod::fem_field;
-          else if (x_compositional_field_methods[i] == "particles")
-            compositional_field_methods[i] = AdvectionFieldMethod::particles;
-          else if (x_compositional_field_methods[i] == "volume of fluid")
-            {
-              AssertThrow (dim==2,
-                           ExcMessage ("The 'volume of fluid' method is currently "
-                                       "only implemented for two-dimensional "
-                                       "computations."));
-              compositional_field_methods[i] = AdvectionFieldMethod::volume_of_fluid;
-            }
-          else if (x_compositional_field_methods[i] == "static")
-            compositional_field_methods[i] = AdvectionFieldMethod::static_field;
-          else if (x_compositional_field_methods[i] == "melt field")
-            compositional_field_methods[i] = AdvectionFieldMethod::fem_melt_field;
-          else if (x_compositional_field_methods[i] == "darcy field")
-            compositional_field_methods[i] = AdvectionFieldMethod::fem_darcy_field;
-          else if (x_compositional_field_methods[i] == "prescribed field")
-            compositional_field_methods[i] = AdvectionFieldMethod::prescribed_field;
-          else if (x_compositional_field_methods[i] == "prescribed field with diffusion")
-            compositional_field_methods[i] = AdvectionFieldMethod::prescribed_field_with_diffusion;
-          else
-            AssertThrow(false,ExcNotImplemented());
-        }
-
-      // Enable Volume of Fluid field tracking if any compositional_field_methods are volume_of_fluid
-      volume_of_fluid_tracking_enabled =
-        (std::count(compositional_field_methods.begin(),compositional_field_methods.end(),AdvectionFieldMethod::volume_of_fluid)
-         > 0);
-
-      if (std::find(compositional_field_methods.begin(), compositional_field_methods.end(), AdvectionFieldMethod::fem_melt_field)
-          != compositional_field_methods.end())
-        AssertThrow (this->include_melt_transport,
-                     ExcMessage ("The advection method 'melt field' can only be selected if melt "
-                                 "transport is used in the simulation."));
-
-      const std::vector<std::string> x_mapped_particle_properties
-        = Utilities::split_string_list
-          (prm.get ("Mapped particle properties"));
-
-      const unsigned int number_of_particle_fields =
-        std::count(compositional_field_methods.begin(),compositional_field_methods.end(),AdvectionFieldMethod::particles);
-
-      AssertThrow ((x_mapped_particle_properties.size() == number_of_particle_fields)
-                   || (x_mapped_particle_properties.size() == 0),
-                   ExcMessage ("The list of names for the mapped particle property fields needs to either be empty or have a length equal to "
-                               "the number of compositional fields that are interpolated from particle properties."));
-
-      if (std::find(compositional_field_methods.begin(), compositional_field_methods.end(), AdvectionFieldMethod::fem_darcy_field)
-          != compositional_field_methods.end())
-        {
-          const unsigned int porosity_idx = std::find(names_of_compositional_fields.begin(), names_of_compositional_fields.end(), "porosity")
-                                            - names_of_compositional_fields.begin();
-          AssertThrow (porosity_idx != n_compositional_fields,
-                       ExcMessage ("The Darcy advection field method only works if there is a compositional field named 'porosity'"));
-          AssertThrow (compositional_field_methods[porosity_idx] == AdvectionFieldMethod::fem_darcy_field,
-                       ExcMessage ("When using the Darcy advection field method, the porosity field must be advected with the darcy method."));
-        }
-
-      for (const auto &p : x_mapped_particle_properties)
-        {
-          // each entry has the format (white space is optional):
-          // <name> : <value (might have spaces)> [component]
-          //
-          // first tease apart the two halves
-          const std::vector<std::string> split_parts = Utilities::split_string_list (p, ':');
-          AssertThrow (split_parts.size() == 2,
-                       ExcMessage ("The format for mapped particle properties  "
-                                   "requires that each entry has the form `"
-                                   "<name of field> : <particle property> [component]', "
-                                   "but there does not appear to be a colon in the entry <"
-                                   + p
-                                   + ">."));
-
-          // the easy part: get the name of the compositional field
-          const std::string &key = split_parts[0];
-
-          // check that the names used are actually names of fields,
-          // are solved by particles, and are unique in this list
-          std::vector<std::string>::iterator field_name_iterator = std::find(names_of_compositional_fields.begin(),
-                                                                             names_of_compositional_fields.end(), key);
-          AssertThrow (field_name_iterator
-                       != names_of_compositional_fields.end(),
-                       ExcMessage ("Name of field <" + key +
-                                   "> appears in the parameter "
-                                   "<Compositional fields/Mapped particle properties>, but "
-                                   "there is no field with this name."));
-
-          const unsigned int compositional_field_index = std::distance(names_of_compositional_fields.begin(),
-                                                                       field_name_iterator);
-
-          AssertThrow (compositional_field_methods[compositional_field_index]
-                       == AdvectionFieldMethod::particles,
-                       ExcMessage ("The field <" + key +
-                                   "> appears in the parameter <Compositional fields/Mapped particle properties>, but "
-                                   "is not advected by a particle method."));
-
-          AssertThrow (std::count(names_of_compositional_fields.begin(),
-                                  names_of_compositional_fields.end(), key) == 1,
-                       ExcMessage ("Name of field <" + key +
-                                   "> appears more than once in the parameter "
-                                   "<Compositional fields/Mapped particle properties>."));
-
-          // now for the rest. since we don't know whether there is a
-          // component selector, start reading at the end and subtract
-          // a number that might be a component selector
-          std::string particle_property = split_parts[1];
-          std::string component;
-          if ((particle_property.size()>3) &&
-              (particle_property[particle_property.size()-1] == ']'))
-            {
-              particle_property.erase (--particle_property.end());
-
-              // this handles the (rare) case of multi digit components
-              while ((particle_property[particle_property.size()-1] >= '0') &&
-                     (particle_property[particle_property.size()-1] <= '9'))
-                {
-                  component.insert(component.begin(),particle_property[particle_property.size()-1]);
-                  particle_property.erase (--particle_property.end());
-                }
-
-              AssertThrow (particle_property[particle_property.size()-1] == '[',
-                           ExcMessage("Problem in parsing a component selector from the string <"
-                                      + split_parts[1] + ">. A component selector has to be of the "
-                                      "form [x], where x must be an unsigned integer between 0 "
-                                      "and the maximum number of components of this particle property."));
-
-              particle_property.erase (--particle_property.end());
-            }
-
-          // we've stopped reading component selectors now.
-          // eat spaces that may be at the end of particle_property to get key
-          while ((particle_property.size()>0) && (particle_property[particle_property.size()-1] == ' '))
-            particle_property.erase (--particle_property.end());
-
-          // finally, put it into the list
-          mapped_particle_properties.insert(std::make_pair(compositional_field_index,
-                                                           std::make_pair(particle_property,atoi(component.c_str()))));
-        }
-
-      // Check that the names inside compositional_fields_with_disabled_boundary_entropy_viscosity
-      // are actually fields. We parse and store this value above, but only here do we know the
-      // names of the present fields.
-      for (const std::string &field_name: compositional_fields_with_disabled_boundary_entropy_viscosity)
-        {
-          AssertThrow(std::find(names_of_compositional_fields.begin(),
-                                names_of_compositional_fields.end(),
-                                field_name)
-                      != names_of_compositional_fields.end(),
-                      ExcMessage("The entry '" + field_name + "' in the parameter "
-                                 "<List of compositional fields with disabled boundary entropy viscosity> "
-                                 "is not a valid name of a compositional field "
-                                 "as specified in the <Compositional fields/Names of fields> parameter."));
-        }
-    }
-    prm.leave_subsection ();
-
-
-    // now also get the parameter related to material model averaging
-    prm.enter_subsection ("Material model");
-    {
-      material_averaging
-        = MaterialModel::MaterialAveraging::parse_averaging_operation_name
-          (prm.get ("Material averaging"));
-    }
-    prm.leave_subsection ();
-
-    // then, finally, let user additions that do not go through the usual
-    // plugin mechanism, declare their parameters if they have subscribed
-    // to the relevant signals
-    SimulatorSignals<dim>::parse_additional_parameters (*this, prm);
-
-    AssertThrow((!use_direct_stokes_solver) || (nullspace_removal == NullspaceRemoval::none),
-                ExcMessage("Because of the difference in system partitioning, nullspace removal is "
-                           "currently not compatible with the direct solver. "
-                           "Please turn off one or both of the options 'Nullspace removal/Remove nullspace', "
-                           "or 'Use direct solver for Stokes system', or contribute code to enable "
-                           "this feature combination."));
-  }
-
-
-
-  template <int dim>
-  void
-  Parameters<dim>::
-  parse_geometry_dependent_parameters(ParameterHandler &prm,
-                                      const GeometryModel::Interface<dim> &geometry_model)
-  {
-    prm.enter_subsection ("Mesh deformation");
-    {
-      // Test here for whether there are any boundary indicators active
-      // for which mesh deformation objects are to be set.
-      const std::vector<std::string> x_mesh_deformation_boundary_indicators
-        = Utilities::split_string_list(prm.get("Mesh deformation boundary indicators"),";");
-      mesh_deformation_enabled = !x_mesh_deformation_boundary_indicators.empty();
-    }
-    prm.leave_subsection();
-
-    prm.enter_subsection ("Boundary heat flux model");
-    {
-      try
-        {
-          const std::vector<types::boundary_id> x_fixed_heat_flux_boundary_indicators
-            = geometry_model.translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
-                                                                      (prm.get ("Fixed heat flux boundary indicators")));
-          fixed_heat_flux_boundary_indicators
-            = std::set<types::boundary_id> (x_fixed_heat_flux_boundary_indicators.begin(),
-                                            x_fixed_heat_flux_boundary_indicators.end());
-        }
-      catch (const std::string &error)
-        {
-          AssertThrow (false, ExcMessage ("While parsing the entry <Boundary heat flux model/Fixed heat flux "
-                                          "boundary indicators>, there was an error. Specifically, "
-                                          "the conversion function complained as follows:\n\n"
-                                          + error));
-        }
-    }
-    prm.leave_subsection ();
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::declare_parameters (ParameterHandler &prm)
-  {
-    Parameters<dim>::declare_parameters (prm);
-    Melt::Parameters<dim>::declare_parameters (prm);
-    Newton::Parameters::declare_parameters (prm);
-    StokesMatrixFreeHandler<dim>::declare_parameters (prm);
-    MeshDeformation::MeshDeformationHandler<dim>::declare_parameters (prm);
-    Postprocess::Manager<dim>::declare_parameters (prm);
-    MeshRefinement::Manager<dim>::declare_parameters (prm);
-    TimeStepping::Manager<dim>::declare_parameters (prm);
-    MaterialModel::declare_parameters<dim> (prm);
-    HeatingModel::Manager<dim>::declare_parameters (prm);
-    GeometryModel::declare_parameters <dim>(prm);
-    InitialTopographyModel::declare_parameters <dim>(prm);
-    GravityModel::declare_parameters<dim> (prm);
-    InitialTemperature::Manager<dim>::declare_parameters (prm);
-    InitialComposition::Manager<dim>::declare_parameters (prm);
-    PrescribedStokesSolution::declare_parameters<dim> (prm);
-    BoundaryTemperature::Manager<dim>::declare_parameters (prm);
-    BoundaryComposition::Manager<dim>::declare_parameters (prm);
-    AdiabaticConditions::declare_parameters<dim> (prm);
-    BoundaryVelocity::Manager<dim>::declare_parameters (prm);
-    BoundaryTraction::Manager<dim>::declare_parameters (prm);
-    BoundaryHeatFlux::declare_parameters<dim> (prm);
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template Parameters<dim>::Parameters (ParameterHandler &prm, \
-                                        const MPI_Comm mpi_communicator); \
-  template void Parameters<dim>::declare_parameters (ParameterHandler &prm); \
-  template void Parameters<dim>::parse_parameters(ParameterHandler &prm, \
-                                                  const MPI_Comm mpi_communicator); \
-  template void Parameters<dim>::parse_geometry_dependent_parameters(ParameterHandler &prm, \
-                                                                     const GeometryModel::Interface<dim> &geometry_model); \
-  template void Simulator<dim>::declare_parameters (ParameterHandler &prm);
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/simulator_access.cc.bak b/source/simulator/simulator_access.cc.bak
deleted file mode 100644
index 12b4a3affeb..00000000000
--- a/source/simulator/simulator_access.cc.bak
+++ /dev/null
@@ -1,901 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/mesh_deformation/free_surface.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/particle/world.h>
-
-namespace aspect
-{
-  template <int dim>
-  SimulatorAccess<dim>::SimulatorAccess ()
-    :
-    simulator (nullptr)
-  {}
-
-
-
-  template <int dim>
-  SimulatorAccess<dim>::SimulatorAccess (const Simulator<dim> &simulator_object)
-    :
-    simulator (&simulator_object)
-  {}
-
-
-
-  template <int dim>
-  void
-  SimulatorAccess<dim>::initialize_simulator (const Simulator<dim> &simulator_object)
-  {
-    simulator = &simulator_object;
-  }
-
-
-
-  template <int dim>
-  const Simulator<dim> &
-  SimulatorAccess<dim>::get_simulator() const
-  {
-    return *simulator;
-  }
-
-
-  template <int dim>
-  const Parameters<dim> &
-  SimulatorAccess<dim>::get_parameters() const
-  {
-    return simulator->parameters;
-  }
-
-
-
-  template <int dim>
-  SimulatorSignals<dim> &
-  SimulatorAccess<dim>::get_signals() const
-  {
-    // Our reference to the Simulator is const, but we need to
-    // be able to connect to the signals so a cast is required.
-    return const_cast<SimulatorSignals<dim>&>(simulator->signals);
-  }
-
-
-
-  template <int dim>
-  const Introspection<dim> &
-  SimulatorAccess<dim>::introspection () const
-  {
-    return simulator->introspection;
-  }
-
-
-
-  template <int dim>
-  MPI_Comm
-  SimulatorAccess<dim>::get_mpi_communicator () const
-  {
-    return simulator->mpi_communicator;
-  }
-
-
-
-  template <int dim>
-  TimerOutput &
-  SimulatorAccess<dim>::get_computing_timer () const
-  {
-    return simulator->computing_timer;
-  }
-
-
-
-  template <int dim>
-  const ConditionalOStream &
-  SimulatorAccess<dim>::get_pcout () const
-  {
-    return simulator->pcout;
-  }
-
-
-
-  template <int dim>
-  double SimulatorAccess<dim>::get_time () const
-  {
-    return simulator->time;
-  }
-
-
-
-  template <int dim>
-  double SimulatorAccess<dim>::get_timestep () const
-  {
-    return simulator->time_step;
-  }
-
-
-
-  template <int dim>
-  double SimulatorAccess<dim>::get_old_timestep () const
-  {
-    return simulator->old_time_step;
-  }
-
-
-
-  template <int dim>
-  unsigned int SimulatorAccess<dim>::get_timestep_number () const
-  {
-    return simulator->timestep_number;
-  }
-
-
-
-  template <int dim>
-  const TimeStepping::Manager<dim> &
-  SimulatorAccess<dim>::get_timestepping_manager() const
-  {
-    return simulator->time_stepping_manager;
-  }
-
-
-
-  template <int dim>
-  unsigned int SimulatorAccess<dim>::get_nonlinear_iteration () const
-  {
-    return simulator->nonlinear_iteration;
-  }
-
-
-
-  template <int dim>
-  const parallel::distributed::Triangulation<dim> &
-  SimulatorAccess<dim>::get_triangulation () const
-  {
-    return simulator->triangulation;
-  }
-
-
-
-  template <int dim>
-  double
-  SimulatorAccess<dim>::get_volume () const
-  {
-    return simulator->global_volume;
-  }
-
-
-
-  template <int dim>
-  const Mapping<dim> &
-  SimulatorAccess<dim>::get_mapping () const
-  {
-    return *(simulator->mapping);
-  }
-
-
-
-  template <int dim>
-  std::string
-  SimulatorAccess<dim>::get_output_directory () const
-  {
-    return simulator->parameters.output_directory;
-  }
-
-
-
-  template <int dim>
-  bool
-  SimulatorAccess<dim>::convert_output_to_years () const
-  {
-    return simulator->parameters.convert_to_years;
-  }
-
-
-
-  template <int dim>
-  double
-  SimulatorAccess<dim>::get_end_time () const
-  {
-    return simulator->parameters.end_time;
-  }
-
-
-  template <int dim>
-  unsigned int
-  SimulatorAccess<dim>::get_pre_refinement_step () const
-  {
-    return simulator->pre_refinement_step;
-  }
-
-
-
-  template <int dim>
-  unsigned int
-  SimulatorAccess<dim>::n_compositional_fields () const
-  {
-    return simulator->introspection.n_compositional_fields;
-  }
-
-
-
-  template <int dim>
-  bool
-  SimulatorAccess<dim>::include_adiabatic_heating () const
-  {
-    return simulator->heating_model_manager.adiabatic_heating_enabled();
-  }
-
-
-
-  template <int dim>
-  bool
-  SimulatorAccess<dim>::include_latent_heat () const
-  {
-    const std::vector<std::string> &heating_models = simulator->heating_model_manager.get_active_heating_model_names();
-    return (std::find(heating_models.begin(), heating_models.end(), "latent heat") != heating_models.end());
-  }
-
-
-
-  template <int dim>
-  bool
-  SimulatorAccess<dim>::include_melt_transport () const
-  {
-    return simulator->parameters.include_melt_transport;
-  }
-
-
-
-  template <int dim>
-  int
-  SimulatorAccess<dim>::get_stokes_velocity_degree () const
-  {
-    return simulator->parameters.stokes_velocity_degree;
-  }
-
-
-
-  template <int dim>
-  double
-  SimulatorAccess<dim>::get_adiabatic_surface_temperature () const
-  {
-    return simulator->parameters.adiabatic_surface_temperature;
-  }
-
-
-
-  template <int dim>
-  double
-  SimulatorAccess<dim>::get_surface_pressure () const
-  {
-    return simulator->parameters.surface_pressure;
-  }
-
-
-
-  template <int dim>
-  void
-  SimulatorAccess<dim>::get_refinement_criteria (Vector<float> &estimated_error_per_cell) const
-  {
-    simulator->mesh_refinement_manager.execute (estimated_error_per_cell);
-  }
-
-
-
-  template <int dim>
-  void
-  SimulatorAccess<dim>::get_artificial_viscosity (Vector<float> &viscosity_per_cell,
-                                                  const bool skip_interior_cells) const
-  {
-    const typename Simulator<dim>::AdvectionField advection_field = Simulator<dim>::AdvectionField::temperature();
-    simulator->get_artificial_viscosity(viscosity_per_cell, advection_field, skip_interior_cells);
-  }
-
-
-
-  template <int dim>
-  void
-  SimulatorAccess<dim>::get_artificial_viscosity_composition (Vector<float> &viscosity_per_cell,
-                                                              const unsigned int compositional_variable) const
-  {
-    const typename Simulator<dim>::AdvectionField advection_field = Simulator<dim>::AdvectionField::composition(compositional_variable);
-    simulator->get_artificial_viscosity(viscosity_per_cell, advection_field);
-  }
-
-
-
-  template <int dim>
-  void
-  SimulatorAccess<dim>::compute_KXRCF_indicators(Vector<float> &KXRCF_indicators,
-                                                 const unsigned int field_index) const
-  {
-    const typename Simulator<dim>::AdvectionField advection_field =
-      (field_index == 0 ? Simulator<dim>::AdvectionField::temperature()
-       : Simulator<dim>::AdvectionField::composition(field_index-1));
-    simulator->compute_KXRCF_indicators(KXRCF_indicators, advection_field);
-  }
-
-
-
-  template <int dim>
-  const LinearAlgebra::BlockVector &
-  SimulatorAccess<dim>::get_current_linearization_point () const
-  {
-    return simulator->current_linearization_point;
-  }
-
-
-
-  template <int dim>
-  const LinearAlgebra::BlockVector &
-  SimulatorAccess<dim>::get_solution () const
-  {
-    return simulator->solution;
-  }
-
-
-
-  template <int dim>
-  const LinearAlgebra::BlockVector &
-  SimulatorAccess<dim>::get_old_solution () const
-  {
-    return simulator->old_solution;
-  }
-
-
-
-  template <int dim>
-  const LinearAlgebra::BlockVector &
-  SimulatorAccess<dim>::get_old_old_solution () const
-  {
-    return simulator->old_old_solution;
-  }
-
-
-
-  template <int dim>
-  const LinearAlgebra::BlockVector &
-  SimulatorAccess<dim>::get_reaction_vector () const
-  {
-    return simulator->operator_split_reaction_vector;
-  }
-
-
-
-  template <int dim>
-  const LinearAlgebra::BlockVector &
-  SimulatorAccess<dim>::get_mesh_velocity () const
-  {
-    Assert( simulator->parameters.mesh_deformation_enabled,
-            ExcMessage("You cannot get the mesh velocity if mesh deformation is not enabled."));
-    return simulator->mesh_deformation->mesh_velocity;
-  }
-
-
-
-  template <int dim>
-  const DoFHandler<dim> &
-  SimulatorAccess<dim>::get_dof_handler () const
-  {
-    return simulator->dof_handler;
-  }
-
-
-
-  template <int dim>
-  const FiniteElement<dim> &
-  SimulatorAccess<dim>::get_fe () const
-  {
-    return simulator->finite_element;
-  }
-
-
-
-  template <int dim>
-  const LinearAlgebra::BlockSparseMatrix &
-  SimulatorAccess<dim>::get_system_matrix () const
-  {
-    return simulator->system_matrix;
-  }
-
-
-
-  template <int dim>
-  const LinearAlgebra::BlockSparseMatrix &
-  SimulatorAccess<dim>::get_system_preconditioner_matrix () const
-  {
-    return simulator->system_preconditioner_matrix;
-  }
-
-
-
-  template <int dim>
-  const MaterialModel::Interface<dim> &
-  SimulatorAccess<dim>::get_material_model () const
-  {
-    Assert (simulator->material_model.get() != nullptr,
-            ExcMessage("You can not call this function if no such model is actually available."));
-    return *simulator->material_model.get();
-  }
-
-
-
-  template <int dim>
-  const BoundaryTraction::Manager<dim> &
-  SimulatorAccess<dim>::get_boundary_traction_manager () const
-  {
-    return simulator->boundary_traction_manager;
-  }
-
-
-
-  template <int dim>
-  bool
-  SimulatorAccess<dim>::has_boundary_temperature () const
-  {
-    return (get_boundary_temperature_manager().get_fixed_temperature_boundary_indicators().size() > 0);
-  }
-
-
-
-  template <int dim>
-  const BoundaryTemperature::Manager<dim> &
-  SimulatorAccess<dim>::get_boundary_temperature_manager () const
-  {
-    return simulator->boundary_temperature_manager;
-  }
-
-
-
-  template <int dim>
-  const BoundaryHeatFlux::Interface<dim> &
-  SimulatorAccess<dim>::get_boundary_heat_flux () const
-  {
-    Assert (simulator->boundary_heat_flux.get() != nullptr,
-            ExcMessage("You can not call this function if no such model is actually available."));
-    return *simulator->boundary_heat_flux.get();
-  }
-
-
-
-  template <int dim>
-  bool
-  SimulatorAccess<dim>::has_boundary_composition () const
-  {
-    return (get_boundary_composition_manager().get_fixed_composition_boundary_indicators().size() > 0);
-  }
-
-
-
-  template <int dim>
-  const BoundaryComposition::Manager<dim> &
-  SimulatorAccess<dim>::get_boundary_composition_manager () const
-  {
-    return simulator->boundary_composition_manager;
-  }
-
-
-
-  template <int dim>
-  const std::set<types::boundary_id> &
-  SimulatorAccess<dim>::get_fixed_temperature_boundary_indicators () const
-  {
-    return get_boundary_temperature_manager().get_fixed_temperature_boundary_indicators();
-  }
-
-
-
-  template <int dim>
-  const std::set<types::boundary_id> &
-  SimulatorAccess<dim>::get_fixed_heat_flux_boundary_indicators () const
-  {
-    return simulator->parameters.fixed_heat_flux_boundary_indicators;
-  }
-
-
-
-  template <int dim>
-  const std::set<types::boundary_id> &
-  SimulatorAccess<dim>::get_fixed_composition_boundary_indicators () const
-  {
-    return get_boundary_composition_manager().get_fixed_composition_boundary_indicators();
-  }
-
-
-  template <int dim>
-  const std::set<types::boundary_id> &
-  SimulatorAccess<dim>::get_mesh_deformation_boundary_indicators () const
-  {
-    Assert( simulator->parameters.mesh_deformation_enabled,
-            ExcMessage("You cannot get the mesh deformation boundary indicators if mesh deformation is not enabled."));
-    return simulator->mesh_deformation->get_active_mesh_deformation_boundary_indicators();
-  }
-
-
-
-  template <int dim>
-  const BoundaryVelocity::Manager<dim> &
-  SimulatorAccess<dim>::get_boundary_velocity_manager () const
-  {
-    return simulator->boundary_velocity_manager;
-  }
-
-
-  template <int dim>
-  const InitialTopographyModel::Interface<dim> &
-  SimulatorAccess<dim>::get_initial_topography_model () const
-  {
-    Assert (simulator->initial_topography_model.get() != nullptr,
-            ExcMessage("You can not call this function if no such model is actually available."));
-    return *simulator->initial_topography_model.get();
-  }
-
-
-  template <int dim>
-  const GeometryModel::Interface<dim> &
-  SimulatorAccess<dim>::get_geometry_model () const
-  {
-    Assert (simulator->geometry_model.get() != nullptr,
-            ExcMessage("You can not call this function if no such model is actually available."));
-    return *simulator->geometry_model.get();
-  }
-
-  template <int dim>
-  const GravityModel::Interface<dim> &
-  SimulatorAccess<dim>::get_gravity_model () const
-  {
-    Assert (simulator->gravity_model.get() != nullptr,
-            ExcMessage("You can not call this function if no such model is actually available."));
-    return *simulator->gravity_model.get();
-  }
-
-
-  template <int dim>
-  const AdiabaticConditions::Interface<dim> &
-  SimulatorAccess<dim>::get_adiabatic_conditions () const
-  {
-    Assert (simulator->adiabatic_conditions.get() != nullptr,
-            ExcMessage("You can not call this function if no such model is actually available."));
-    return *simulator->adiabatic_conditions.get();
-  }
-
-
-
-  template <int dim>
-  std::shared_ptr<const InitialTemperature::Manager<dim>>
-  SimulatorAccess<dim>::get_initial_temperature_manager_pointer () const
-  {
-    Assert (simulator->initial_temperature_manager,
-            ExcMessage ("You are trying to access the initial temperature manager "
-                        "object, but the Simulator object is no longer keeping "
-                        "track of it because the initial time has passed. If "
-                        "you need to access this object after the first time "
-                        "step, you need to copy the object returned by "
-                        "this function before or during the first time step "
-                        "into a std::shared_ptr that lives long enough to "
-                        "extend the lifetime of the object pointed to "
-                        "beyond the time frame that the Simulator object "
-                        "keeps track of it."));
-    return simulator->initial_temperature_manager;
-  }
-
-
-
-  template <int dim>
-  const InitialTemperature::Manager<dim> &
-  SimulatorAccess<dim>::get_initial_temperature_manager () const
-  {
-    Assert (simulator->initial_temperature_manager,
-            ExcMessage ("You are trying to access the initial temperature manager "
-                        "object, but the Simulator object is no longer keeping "
-                        "track of it because the initial time has passed. If "
-                        "you need to access this object after the first time "
-                        "step, you need to copy the object returned by "
-                        "this function before or during the first time step "
-                        "into a std::shared_ptr that lives long enough to "
-                        "extend the lifetime of the object pointed to "
-                        "beyond the time frame that the Simulator object "
-                        "keeps track of it."));
-    return *simulator->initial_temperature_manager;
-  }
-
-
-
-  template <int dim>
-  std::shared_ptr<const InitialComposition::Manager<dim>>
-  SimulatorAccess<dim>::get_initial_composition_manager_pointer () const
-  {
-    Assert (simulator->initial_composition_manager,
-            ExcMessage ("You are trying to access the initial composition manager "
-                        "object, but the Simulator object is no longer keeping "
-                        "track of it because the initial time has passed. If "
-                        "you need to access to this object after the first time "
-                        "step, you need to copy the object returned by "
-                        "this function before or during the first time step "
-                        "into a std::shared_ptr that lives long enough to "
-                        "extend the lifetime of the object pointed to "
-                        "beyond the timeframe that the Simulator object "
-                        "keeps track of it."));
-    return simulator->initial_composition_manager;
-  }
-
-
-
-  template <int dim>
-  const InitialComposition::Manager<dim> &
-  SimulatorAccess<dim>::get_initial_composition_manager () const
-  {
-    Assert (simulator->initial_composition_manager,
-            ExcMessage ("You are trying to access the initial composition manager "
-                        "object, but the Simulator object is no longer keeping "
-                        "track of it because the initial time has passed. If "
-                        "you need access to this object after the first time "
-                        "step, you need to copy the object returned by "
-                        "this function before or during the first time step "
-                        "into a std::shared_ptr that lives long enough to "
-                        "extend the lifetime of the object pointed to "
-                        "beyond the timeframe that the Simulator object "
-                        "keeps track of it."));
-    return *simulator->initial_composition_manager;
-  }
-
-
-
-  template <int dim>
-  const HeatingModel::Manager<dim> &
-  SimulatorAccess<dim>::get_heating_model_manager () const
-  {
-    return simulator->heating_model_manager;
-  }
-
-  template <int dim>
-  const MeshRefinement::Manager<dim> &
-  SimulatorAccess<dim>::get_mesh_refinement_manager () const
-  {
-    return simulator->mesh_refinement_manager;
-  }
-
-  template <int dim>
-  const MeltHandler<dim> &
-  SimulatorAccess<dim>::get_melt_handler () const
-  {
-    Assert (simulator->melt_handler.get() != nullptr,
-            ExcMessage("You can not call this function if melt transport is not enabled."));
-    return *(simulator->melt_handler);
-  }
-
-  template <int dim>
-  const VolumeOfFluidHandler<dim> &
-  SimulatorAccess<dim>::get_volume_of_fluid_handler () const
-  {
-    Assert (simulator->volume_of_fluid_handler.get() != nullptr,
-            ExcMessage("You can not call this function if volume of fluid interface tracking is not enabled."));
-    return *(simulator->volume_of_fluid_handler);
-  }
-
-  template <int dim>
-  const NewtonHandler<dim> &
-  SimulatorAccess<dim>::get_newton_handler () const
-  {
-    Assert (simulator->newton_handler.get() != nullptr,
-            ExcMessage("You can not call this function if the Newton solver is not enabled."));
-    return *(simulator->newton_handler);
-  }
-
-
-#ifdef ASPECT_WITH_WORLD_BUILDER
-  template <int dim>
-  const WorldBuilder::World &
-  SimulatorAccess<dim>::get_world_builder () const
-  {
-    Assert (simulator->world_builder.get() != nullptr,
-            ExcMessage ("You are trying to access the WorldBuilder "
-                        "object, but the Simulator object is not currently storing "
-                        "a valid pointer to such an object. This is likely "
-                        "because the Simulator object is no longer keeping "
-                        "track of wht WorldBuilder object because "
-                        "the initial time has passed. If "
-                        "you need to access this object after the first time "
-                        "step, you need to copy the object returned by "
-                        "this function before or during the first time step "
-                        "into a std::shared_ptr that lives long enough to "
-                        "extend the lifetime of the object pointed to "
-                        "beyond the time frame that the Simulator object "
-                        "keeps track of it."));
-    return *simulator->world_builder;
-  }
-
-
-  template <int dim>
-  std::shared_ptr<const WorldBuilder::World>
-  SimulatorAccess<dim>::get_world_builder_pointer () const
-  {
-    Assert (simulator->world_builder.get() != nullptr,
-            ExcMessage ("You are trying to access the WorldBuilder "
-                        "object, but the Simulator object is not currently storing "
-                        "a valid pointer to such an object. This is likely "
-                        "because the Simulator object is no longer keeping "
-                        "track of wht WorldBuilder object because "
-                        "the initial time has passed. If "
-                        "you need to access this object after the first time "
-                        "step, you need to copy the object returned by "
-                        "this function before or during the first time step "
-                        "into a std::shared_ptr that lives long enough to "
-                        "extend the lifetime of the object pointed to "
-                        "beyond the time frame that the Simulator object "
-                        "keeps track of it."));
-    return simulator->world_builder;
-  }
-#endif
-
-
-  template <int dim>
-  const MeshDeformation::MeshDeformationHandler<dim> &
-  SimulatorAccess<dim>::get_mesh_deformation_handler () const
-  {
-    Assert (simulator->mesh_deformation.get() != nullptr,
-            ExcMessage("You cannot call this function if mesh deformation is not enabled."));
-
-    return *(simulator->mesh_deformation);
-  }
-
-  template <int dim>
-  void
-  SimulatorAccess<dim>::get_composition_values_at_q_point (const std::vector<std::vector<double>> &composition_values,
-                                                           const unsigned int                      q,
-                                                           std::vector<double>                    &composition_values_at_q_point)
-  {
-    for (unsigned int k=0; k < composition_values_at_q_point.size(); ++k)
-      composition_values_at_q_point[k] = composition_values[k][q];
-  }
-
-
-  template <int dim>
-  TableHandler &
-  SimulatorAccess<dim>::get_statistics_object () const
-  {
-    return const_cast<TableHandler &>(simulator->statistics);
-  }
-
-  template <int dim>
-  const LateralAveraging<dim> &
-  SimulatorAccess<dim>::get_lateral_averaging() const
-  {
-    return simulator->lateral_averaging;
-  }
-
-  template <int dim>
-  const AffineConstraints<double> &
-  SimulatorAccess<dim>::get_current_constraints() const
-  {
-    return simulator->current_constraints;
-  }
-
-
-
-  template <int dim>
-  bool
-  SimulatorAccess<dim>::simulator_is_past_initialization () const
-  {
-    return ((simulator != nullptr)
-            &&
-            (simulator->simulator_is_past_initialization == true));
-  }
-
-
-  template <int dim>
-  double
-  SimulatorAccess<dim>::get_pressure_scaling () const
-  {
-    return (simulator->pressure_scaling);
-  }
-
-  template <int dim>
-  bool
-  SimulatorAccess<dim>::pressure_rhs_needs_compatibility_modification () const
-  {
-    return simulator->do_pressure_rhs_compatibility_modification;
-  }
-
-  template <int dim>
-  bool
-  SimulatorAccess<dim>::model_has_prescribed_stokes_solution () const
-  {
-    return (simulator->prescribed_stokes_solution.get() != nullptr);
-  }
-
-  template <int dim>
-  const Postprocess::Manager<dim> &
-  SimulatorAccess<dim>::get_postprocess_manager() const
-  {
-    return simulator->postprocess_manager;
-  }
-
-
-
-  template <int dim>
-  unsigned int
-  SimulatorAccess<dim>::n_particle_worlds() const
-  {
-    return simulator->particle_worlds.size();
-  }
-
-
-
-  template <int dim>
-  const Particle::World<dim> &
-  SimulatorAccess<dim>::get_particle_world(unsigned int particle_world_index) const
-  {
-    AssertThrow (particle_world_index < simulator->particle_worlds.size(), ExcInternalError());
-    return *simulator->particle_worlds[particle_world_index].get();
-  }
-
-
-
-  template <int dim>
-  Particle::World<dim> &
-  SimulatorAccess<dim>::get_particle_world(unsigned int particle_world_index)
-  {
-    AssertThrow (particle_world_index < simulator->particle_worlds.size(), ExcInternalError());
-    return *simulator->particle_worlds[particle_world_index].get();
-  }
-
-
-
-  template <int dim>
-  bool SimulatorAccess<dim>::is_stokes_matrix_free()
-  {
-    return (simulator->stokes_matrix_free ? true : false);
-  }
-
-
-
-  template <int dim>
-  const StokesMatrixFreeHandler<dim> &
-  SimulatorAccess<dim>::get_stokes_matrix_free () const
-  {
-    Assert (simulator->stokes_matrix_free.get() != nullptr,
-            ExcMessage("You can not call this function if the matrix-free Stokes solver is not used."));
-    return *(simulator->stokes_matrix_free);
-  }
-
-
-
-  template <int dim>
-  RotationProperties<dim>
-  SimulatorAccess<dim>::compute_net_angular_momentum(const bool use_constant_density,
-                                                     const LinearAlgebra::BlockVector &solution,
-                                                     const bool limit_to_top_faces) const
-  {
-    return simulator->compute_net_angular_momentum(use_constant_density, solution, limit_to_top_faces);
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template class SimulatorAccess<dim>;
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/simulator_signals.cc.bak b/source/simulator/simulator_signals.cc.bak
deleted file mode 100644
index 67a77f953c7..00000000000
--- a/source/simulator/simulator_signals.cc.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator_signals.h>
-
-#include <list>
-
-
-namespace aspect
-{
-  // provide locations for the static variables of this class
-  template <int dim>
-  boost::signals2::signal<void (const unsigned int,
-                                ParameterHandler &)>  SimulatorSignals<dim>::declare_additional_parameters;
-
-  template <int dim>
-  boost::signals2::signal<void (const Parameters<dim> &,
-                                ParameterHandler &)>  SimulatorSignals<dim>::parse_additional_parameters;
-
-
-  namespace internals
-  {
-    namespace SimulatorSignals
-    {
-      std::list<std::function<void (aspect::SimulatorSignals<2> &)>> connector_functions_2d;
-      std::list<std::function<void (aspect::SimulatorSignals<3> &)>> connector_functions_3d;
-
-      static bool connector_functions_have_been_called = false;
-
-      // add a user-provided connector to the list of connectors we keep
-      void register_connector_function_2d (const std::function<void (aspect::SimulatorSignals<2> &)> &connector)
-      {
-        Assert(!connector_functions_have_been_called,
-               ExcMessage("Registration of signal connector happened after connection has already been called!"));
-        connector_functions_2d.push_back (connector);
-      }
-
-      void register_connector_function_3d (const std::function<void (aspect::SimulatorSignals<3> &)> &connector)
-      {
-        Assert(!connector_functions_have_been_called,
-               ExcMessage("Registration of signal connector happened after connection has already been called!"));
-        connector_functions_3d.push_back (connector);
-      }
-
-
-      // call connectors to ensure that plugins get a change to register their slots
-      template <>
-      void call_connector_functions (aspect::SimulatorSignals<2> &signals)
-      {
-        Assert(!connector_functions_have_been_called,
-               ExcInternalError());
-
-        for (const auto &p : connector_functions_2d)
-          p(signals);
-
-        connector_functions_have_been_called = true;
-      }
-
-      template <>
-      void call_connector_functions (aspect::SimulatorSignals<3> &signals)
-      {
-        Assert(!connector_functions_have_been_called,
-               ExcInternalError());
-
-        for (const auto &p : connector_functions_3d)
-          p(signals);
-
-        connector_functions_have_been_called = true;
-      }
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template struct SimulatorSignals<dim>;
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/solver.cc.bak b/source/simulator/solver.cc.bak
deleted file mode 100644
index c91409716bb..00000000000
--- a/source/simulator/solver.cc.bak
+++ /dev/null
@@ -1,1270 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-#include <aspect/stokes_matrix_free.h>
-#include <aspect/mesh_deformation/interface.h>
-
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/lac/solver_gmres.h>
-#include <deal.II/lac/solver_bicgstab.h>
-#include <deal.II/lac/solver_cg.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace internal
-  {
-    /**
-     * Implement multiplication with Stokes part of system matrix. In essence, this
-     * object represents a 2x2 block matrix that corresponds to the top left
-     * sub-blocks of the entire system matrix (i.e., the Stokes part)
-     */
-    class StokesBlock
-    {
-      public:
-        /**
-         * @brief Constructor
-         *
-         * @param S The entire system matrix
-         */
-        StokesBlock (const LinearAlgebra::BlockSparseMatrix  &S)
-          : system_matrix(S) {}
-
-        /**
-         * Matrix vector product with Stokes block.
-         */
-        void vmult (LinearAlgebra::BlockVector       &dst,
-                    const LinearAlgebra::BlockVector &src) const;
-
-        void Tvmult (LinearAlgebra::BlockVector       &dst,
-                     const LinearAlgebra::BlockVector &src) const;
-
-        void vmult_add (LinearAlgebra::BlockVector       &dst,
-                        const LinearAlgebra::BlockVector &src) const;
-
-        void Tvmult_add (LinearAlgebra::BlockVector       &dst,
-                         const LinearAlgebra::BlockVector &src) const;
-
-        /**
-         * Compute the residual with the Stokes block. In a departure from
-         * the other functions, the #b variable may actually have more than
-         * two blocks so that we can put it a global system_rhs vector. The
-         * other vectors need to have 2 blocks only.
-         */
-        double residual (LinearAlgebra::BlockVector       &dst,
-                         const LinearAlgebra::BlockVector &x,
-                         const LinearAlgebra::BlockVector &b) const;
-
-
-      private:
-
-        /**
-         * Reference to the system matrix object.
-         */
-        const LinearAlgebra::BlockSparseMatrix &system_matrix;
-    };
-
-
-
-    void StokesBlock::vmult (LinearAlgebra::BlockVector       &dst,
-                             const LinearAlgebra::BlockVector &src) const
-    {
-      Assert (src.n_blocks() == 2, ExcInternalError());
-      Assert (dst.n_blocks() == 2, ExcInternalError());
-
-      system_matrix.block(0,0).vmult(dst.block(0), src.block(0));
-      system_matrix.block(0,1).vmult_add(dst.block(0), src.block(1));
-
-      system_matrix.block(1,0).vmult(dst.block(1), src.block(0));
-      system_matrix.block(1,1).vmult_add(dst.block(1), src.block(1));
-    }
-
-
-    void StokesBlock::Tvmult (LinearAlgebra::BlockVector       &dst,
-                              const LinearAlgebra::BlockVector &src) const
-    {
-      Assert (src.n_blocks() == 2, ExcInternalError());
-      Assert (dst.n_blocks() == 2, ExcInternalError());
-
-      system_matrix.block(0,0).Tvmult(dst.block(0), src.block(0));
-      system_matrix.block(1,0).Tvmult_add(dst.block(0), src.block(1));
-
-      system_matrix.block(0,1).Tvmult(dst.block(1), src.block(0));
-      system_matrix.block(1,1).Tvmult_add(dst.block(1), src.block(1));
-    }
-
-
-    void StokesBlock::vmult_add (LinearAlgebra::BlockVector       &dst,
-                                 const LinearAlgebra::BlockVector &src) const
-    {
-      Assert (src.n_blocks() == 2, ExcInternalError());
-      Assert (dst.n_blocks() == 2, ExcInternalError());
-
-      system_matrix.block(0,0).vmult_add(dst.block(0), src.block(0));
-      system_matrix.block(0,1).vmult_add(dst.block(0), src.block(1));
-
-      system_matrix.block(1,0).vmult_add(dst.block(1), src.block(0));
-      system_matrix.block(1,1).vmult_add(dst.block(1), src.block(1));
-    }
-
-
-    void StokesBlock::Tvmult_add (LinearAlgebra::BlockVector       &dst,
-                                  const LinearAlgebra::BlockVector &src) const
-    {
-      Assert (src.n_blocks() == 2, ExcInternalError());
-      Assert (dst.n_blocks() == 2, ExcInternalError());
-
-      system_matrix.block(0,0).Tvmult_add(dst.block(0), src.block(0));
-      system_matrix.block(1,0).Tvmult_add(dst.block(0), src.block(1));
-
-      system_matrix.block(0,1).Tvmult_add(dst.block(1), src.block(0));
-      system_matrix.block(1,1).Tvmult_add(dst.block(1), src.block(1));
-    }
-
-
-
-    double StokesBlock::residual (LinearAlgebra::BlockVector       &dst,
-                                  const LinearAlgebra::BlockVector &x,
-                                  const LinearAlgebra::BlockVector &b) const
-    {
-      Assert (x.n_blocks() == 2, ExcInternalError());
-      Assert (dst.n_blocks() == 2, ExcInternalError());
-
-      // compute b-Ax where A is only the top left 2x2 block
-      this->vmult (dst, x);
-      dst.block(0).sadd (-1, 1, b.block(0));
-      dst.block(1).sadd (-1, 1, b.block(1));
-
-      // clear blocks we didn't want to fill
-      for (unsigned int block=2; block<dst.n_blocks(); ++block)
-        dst.block(block) = 0;
-
-      return dst.l2_norm();
-    }
-
-
-    /**
-     * Implement the block Schur preconditioner for the Stokes system.
-     */
-    template <class AInvOperator, class SInvOperator>
-    class BlockSchurPreconditioner : public Subscriptor
-    {
-      public:
-        /**
-         * @brief Constructor
-         *
-         * @param S The entire Stokes matrix
-         * @param Spre The matrix whose blocks are used in the definition of
-         *     the preconditioning of the Stokes matrix, i.e. containing approximations
-         *     of the A and S blocks.
-         * @param S_inverse_operator Approximation for the inverse Schur complement,
-         * can be chosen as the mass matrix.
-         * @param A_inv_operator Preconditioner object for the matrix A.
-         **/
-        BlockSchurPreconditioner (const LinearAlgebra::BlockSparseMatrix     &S,
-                                  const LinearAlgebra::BlockSparseMatrix     &Spre,
-                                  const SInvOperator                         &S_inverse_operator,
-                                  const AInvOperator                         &A_inv_operator);
-
-        /**
-         * Matrix vector product with this preconditioner object.
-         */
-        void vmult (LinearAlgebra::BlockVector       &dst,
-                    const LinearAlgebra::BlockVector &src) const;
-
-      private:
-        /**
-         * References to the various matrix object this preconditioner works on.
-         */
-        const LinearAlgebra::BlockSparseMatrix &stokes_matrix;
-        const LinearAlgebra::BlockSparseMatrix &stokes_preconditioner_matrix;
-        const SInvOperator                     &S_inv_operator;
-        const AInvOperator                     &A_inv_operator;
-    };
-
-
-    template <class AInvOperator, class SInvOperator>
-    BlockSchurPreconditioner<AInvOperator, SInvOperator>::
-    BlockSchurPreconditioner (const LinearAlgebra::BlockSparseMatrix     &S,
-                              const LinearAlgebra::BlockSparseMatrix     &Spre,
-                              const SInvOperator                         &S_inv_operator,
-                              const AInvOperator                         &A_inv_operator)
-      :
-      stokes_matrix (S),
-      stokes_preconditioner_matrix (Spre),
-      S_inv_operator (S_inv_operator),
-      A_inv_operator (A_inv_operator)
-    {}
-
-
-
-    template <class AInvOperator, class SInvOperator>
-    void
-    BlockSchurPreconditioner<AInvOperator, SInvOperator>::
-    vmult (LinearAlgebra::BlockVector       &dst,
-           const LinearAlgebra::BlockVector &src) const
-    {
-      LinearAlgebra::Vector utmp(src.block(0));
-
-      // first solve with the bottom right block, which we have built
-      // as a mass matrix with the inverse of the viscosity
-      {
-        S_inv_operator.vmult(dst.block(1),src.block(1));
-        dst.block(1) *= -1.0;
-      }
-
-      // apply the top right block
-      {
-        stokes_matrix.block(0,1).vmult(utmp, dst.block(1)); // B^T or J^{up}
-        utmp *= -1.0;
-        utmp += src.block(0);
-      }
-
-      A_inv_operator.vmult(dst.block(0), utmp);
-    }
-
-
-    /**
-      * This class is used in the implementation of the right preconditioner
-      * as an approximation for the inverse of the velocity (A) block.
-      * This operator can either just apply the preconditioner (AMG)
-      * or perform an inner CG solve with the same preconditioner.
-      */
-    template <class PreconditionerA>
-    class InverseVelocityBlock
-    {
-      public:
-        /**
-         * Constructor.
-         * @param matrix The matrix that contains A (from the system matrix)
-         * @param preconditioner The preconditioner to be used
-         * @param do_solve_A A flag indicating whether we should actually solve with
-         *     the matrix $A$, or only apply one preconditioner step with it.
-         * @param A_block_is_symmetric A flag indicating whether the matrix $A$ is symmetric.
-         * @param A_block_tolerance The tolerance for the CG solver which computes
-         *     the inverse of the A block.
-        */
-        InverseVelocityBlock(const TrilinosWrappers::SparseMatrix &matrix,
-                             const PreconditionerA &preconditioner,
-                             const bool do_solve_A,
-                             const bool A_block_is_symmetric,
-                             const double solver_tolerance);
-
-        void vmult(TrilinosWrappers::MPI::Vector &dst,
-                   const TrilinosWrappers::MPI::Vector &src) const;
-
-        unsigned int n_iterations() const;
-
-      private:
-        mutable unsigned int n_iterations_;
-        const TrilinosWrappers::SparseMatrix &matrix;
-        const PreconditionerA &preconditioner;
-        const bool do_solve_A;
-        const bool A_block_is_symmetric;
-        const double solver_tolerance;
-    };
-
-
-
-    template <class PreconditionerA>
-    InverseVelocityBlock<PreconditionerA>::InverseVelocityBlock(
-      const TrilinosWrappers::SparseMatrix &matrix,
-      const PreconditionerA &preconditioner,
-      const bool do_solve_A,
-      const bool A_block_is_symmetric,
-      const double solver_tolerance)
-      : n_iterations_ (0),
-        matrix (matrix),
-        preconditioner (preconditioner),
-        do_solve_A (do_solve_A),
-        A_block_is_symmetric (A_block_is_symmetric),
-        solver_tolerance (solver_tolerance)
-    {}
-
-
-
-    template <class PreconditionerA>
-    void InverseVelocityBlock<PreconditionerA>::vmult(TrilinosWrappers::MPI::Vector &dst,
-                                                      const TrilinosWrappers::MPI::Vector &src) const
-    {
-      // Either solve with the top left block
-      // or just apply one preconditioner sweep (for the first few
-      // iterations of our two-stage outer GMRES iteration)
-      if (do_solve_A == true)
-        {
-          SolverControl solver_control(10000, src.l2_norm() * solver_tolerance);
-          PrimitiveVectorMemory<LinearAlgebra::Vector> mem;
-
-          try
-            {
-              dst = 0.0;
-
-              if (A_block_is_symmetric)
-                {
-                  SolverCG<LinearAlgebra::Vector> solver(solver_control, mem);
-                  solver.solve(matrix, dst, src, preconditioner);
-                }
-              else
-                {
-                  // Use BiCGStab for non-symmetric matrices.
-                  // BiCGStab can also solve indefinite systems if necessary.
-                  // Do not compute the exact residual, as this
-                  // is more expensive, and we only need an approximate solution.
-                  SolverBicgstab<LinearAlgebra::Vector>
-                  solver(solver_control,
-                         mem,
-                         SolverBicgstab<LinearAlgebra::Vector>::AdditionalData(/*exact_residual=*/ false));
-                  solver.solve(matrix, dst, src, preconditioner);
-                }
-              n_iterations_ += solver_control.last_step();
-            }
-          catch (const std::exception &exc)
-            {
-              // if the solver fails, report the error from processor 0 with some additional
-              // information about its location, and throw a quiet exception on all other
-              // processors
-              Utilities::throw_linear_solver_failure_exception("iterative (top left) solver",
-                                                               "BlockSchurPreconditioner::vmult",
-                                                               std::vector<SolverControl> {solver_control},
-                                                               exc,
-                                                               src.get_mpi_communicator());
-            }
-        }
-      else
-        {
-          preconditioner.vmult (dst, src);
-          n_iterations_ += 1;
-        }
-    }
-
-
-
-    template <class PreconditionerA>
-    unsigned int InverseVelocityBlock<PreconditionerA>::n_iterations() const
-    {
-      return n_iterations_;
-    }
-
-    /**
-     * Base class for Schur Complement operators.
-    */
-    class SchurComplementOperator
-    {
-      public:
-        virtual void vmult(TrilinosWrappers::MPI::Vector &dst,
-                           const TrilinosWrappers::MPI::Vector &src) const=0;
-        virtual unsigned int n_iterations() const=0;
-
-    };
-
-    /**
-     * This class approximates the Schur Complement inverse operator
-     * by S^{-1} = (BC^{-1}B^T)^{-1}(BC^{-1}AD^{-1}B^T)(BD^{-1}B^T)^{-1},
-     * which is known as the weighted BFBT method. Here,
-     * C^{-1} and D^{-1} are chosen to be the inverse weighted lumped
-     * velocity mass matrix.
-    */
-    template <class PreconditionerMp>
-    class WeightedBFBT: public SchurComplementOperator
-    {
-      public:
-        /**
-         * Constructor.
-         * @param mp_matrix Matrix approximating S to be used in the inner solve
-         * @param mp_preconditioner The preconditioner for @p mp_matrix
-         * @param solver_tolerance The relative solver tolerance for the inner solve
-         * @param inverse_lumped_mass_matrix Lumped mass matrix associated with the velocity block
-         * @param system_matrix Sparse block matrix storing the Stokes system of the form
-         * [A B^T
-         *  B 0].
-         */
-        WeightedBFBT(const TrilinosWrappers::SparseMatrix &mp_matrix,
-                     const PreconditionerMp &mp_preconditioner,
-                     const double solver_tolerance,
-                     const TrilinosWrappers::MPI::Vector &inverse_lumped_mass_matrix,
-                     const TrilinosWrappers::BlockSparseMatrix &system_matrix);
-
-        void vmult(TrilinosWrappers::MPI::Vector &dst,
-                   const TrilinosWrappers::MPI::Vector &src) const override;
-
-        unsigned int n_iterations() const override;
-
-      private:
-        mutable unsigned int n_iterations_;
-        const TrilinosWrappers::SparseMatrix &mp_matrix;
-        const PreconditionerMp &mp_preconditioner;
-        const double solver_tolerance;
-        const TrilinosWrappers::MPI::Vector  &inverse_lumped_mass_matrix;
-        const TrilinosWrappers::BlockSparseMatrix &system_matrix;
-    };
-
-    template <class PreconditionerMp>
-    WeightedBFBT<PreconditionerMp>::WeightedBFBT(
-      const TrilinosWrappers::SparseMatrix &mp_matrix,
-      const PreconditionerMp &mp_preconditioner,
-      const double solver_tolerance,
-      const TrilinosWrappers::MPI::Vector &inverse_lumped_mass_matrix,
-      const TrilinosWrappers::BlockSparseMatrix &system_matrix)
-      : n_iterations_ (0),
-        mp_matrix (mp_matrix),
-        mp_preconditioner (mp_preconditioner),
-        solver_tolerance (solver_tolerance),
-        inverse_lumped_mass_matrix(inverse_lumped_mass_matrix),
-        system_matrix (system_matrix)
-    {}
-
-
-    template <class PreconditionerMp>
-    void WeightedBFBT<PreconditionerMp>::vmult(TrilinosWrappers::MPI::Vector &dst,
-                                               const TrilinosWrappers::MPI::Vector &src) const
-    {
-      SolverControl solver_control(1000, src.l2_norm() * solver_tolerance);
-      PrimitiveVectorMemory<LinearAlgebra::Vector> mem;
-      SolverCG<LinearAlgebra::Vector> solver(solver_control, mem);
-
-      try
-        {
-          TrilinosWrappers::MPI::Vector utmp;
-          utmp.reinit(inverse_lumped_mass_matrix);
-          TrilinosWrappers::MPI::Vector ptmp;
-          ptmp.reinit(src);
-          TrilinosWrappers::MPI::Vector wtmp;
-          wtmp.reinit(inverse_lumped_mass_matrix);
-          {
-            SolverControl solver_control(5000, 1e-6 * src.l2_norm(), false, true);
-            SolverCG<TrilinosWrappers::MPI::Vector> solver(solver_control);
-            //Solve with Schur Complement approximation
-            solver.solve(mp_matrix,
-                         ptmp,
-                         src,
-                         mp_preconditioner);
-            n_iterations_ += solver_control.last_step();
-            system_matrix.block(0,1).vmult(utmp,ptmp);
-
-            utmp.scale(inverse_lumped_mass_matrix);
-            system_matrix.block(0,0).vmult(wtmp,utmp);
-            wtmp.scale(inverse_lumped_mass_matrix);
-            system_matrix.block(1,0).vmult(ptmp,wtmp);
-
-            dst=0;
-            solver.solve(mp_matrix,
-                         dst,
-                         ptmp,
-                         mp_preconditioner);
-            n_iterations_ += solver_control.last_step();
-          }
-        }
-      // if the solver fails, report the error from processor 0 with some additional
-      // information about its location, and throw a quiet exception on all other
-      // processors
-      catch (const std::exception &exc)
-        {
-          Utilities::throw_linear_solver_failure_exception("iterative (bottom right) solver",
-                                                           "BlockSchurPreconditioner::vmult",
-                                                           std::vector<SolverControl> {solver_control},
-                                                           exc,
-                                                           src.get_mpi_communicator());
-        }
-    }
-
-
-
-    template <class PreconditionerMp>
-    unsigned int WeightedBFBT<PreconditionerMp>::n_iterations() const
-    {
-      return n_iterations_;
-    }
-
-
-
-    /**
-      * This class is used in the implementation of the right preconditioner.
-      * Here, the Schur complement is approximated by
-      * the pressure mass matrix weighted by the inverse of viscosity and
-      * the inverse is computed with a CG solve preconditioned by
-      * PreconditionerMp passed to the constructor.
-      */
-    template <class PreconditionerMp>
-    class InverseWeightedMassMatrix: public SchurComplementOperator
-    {
-      public:
-        /**
-         * Constructor.
-         * @param mp_matrix Matrix approximating S to be used in the inner solve
-         * @param mp_preconditioner The preconditioner for @p mp_matrix
-         * @param solver_tolerance The relative solver tolerance for the inner solve
-         */
-        InverseWeightedMassMatrix(const TrilinosWrappers::SparseMatrix &mp_matrix,
-                                  const PreconditionerMp &mp_preconditioner,
-                                  const double solver_tolerance);
-
-        void vmult(TrilinosWrappers::MPI::Vector &dst,
-                   const TrilinosWrappers::MPI::Vector &src) const override;
-
-        unsigned int n_iterations() const override;
-
-      private:
-        mutable unsigned int n_iterations_;
-        const TrilinosWrappers::SparseMatrix &mp_matrix;
-        const PreconditionerMp &mp_preconditioner;
-        const double solver_tolerance;
-    };
-
-
-
-    template <class PreconditionerMp>
-    InverseWeightedMassMatrix<PreconditionerMp>::InverseWeightedMassMatrix(
-      const TrilinosWrappers::SparseMatrix &mp_matrix,
-      const PreconditionerMp &mp_preconditioner,
-      const double solver_tolerance)
-      : n_iterations_ (0),
-        mp_matrix (mp_matrix),
-        mp_preconditioner (mp_preconditioner),
-        solver_tolerance (solver_tolerance)
-    {}
-
-
-
-    template <class PreconditionerMp>
-    void InverseWeightedMassMatrix<PreconditionerMp>::vmult(TrilinosWrappers::MPI::Vector &dst,
-                                                            const TrilinosWrappers::MPI::Vector &src) const
-    {
-      // Trilinos reports a breakdown in case src=dst=0, even though it should return
-      // convergence without iterating. We simply skip solving in this case.
-      if (src.l2_norm() > 1e-50)
-        {
-          SolverControl solver_control(1000, src.l2_norm() * solver_tolerance);
-          PrimitiveVectorMemory<LinearAlgebra::Vector> mem;
-          SolverCG<LinearAlgebra::Vector> solver(solver_control, mem);
-          try
-            {
-              dst = 0.0;
-              solver.solve(mp_matrix,
-                           dst,
-                           src,
-                           mp_preconditioner);
-              n_iterations_ += solver_control.last_step();
-            }
-          // if the solver fails, report the error from processor 0 with some additional
-          // information about its location, and throw a quiet exception on all other
-          // processors
-          catch (const std::exception &exc)
-            {
-              Utilities::throw_linear_solver_failure_exception("iterative (bottom right) solver",
-                                                               "BlockSchurPreconditioner::vmult",
-                                                               std::vector<SolverControl> {solver_control},
-                                                               exc,
-                                                               src.get_mpi_communicator());
-            }
-        }
-    }
-
-
-
-    template <class PreconditionerMp>
-    unsigned int InverseWeightedMassMatrix<PreconditionerMp>::n_iterations() const
-    {
-      return n_iterations_;
-    }
-
-  }
-
-
-
-  template <int dim>
-  double Simulator<dim>::solve_advection (const AdvectionField &advection_field)
-  {
-    const unsigned int block_idx = advection_field.block_index(introspection);
-
-    std::string field_name = (advection_field.is_temperature()
-                              ?
-                              "temperature"
-                              :
-                              introspection.name_for_compositional_index(advection_field.compositional_variable) + " composition");
-
-    const double advection_solver_tolerance = (advection_field.is_temperature()) ? (parameters.temperature_solver_tolerance) : (parameters.composition_solver_tolerance);
-
-    const double tolerance = std::max(1e-50,
-                                      advection_solver_tolerance*system_rhs.block(block_idx).l2_norm());
-
-    SolverControl solver_control (1000, tolerance);
-
-    solver_control.enable_history_data();
-
-    SolverGMRES<LinearAlgebra::Vector>   solver (solver_control,
-                                                 SolverGMRES<LinearAlgebra::Vector>::AdditionalData(parameters.advection_gmres_restart_length,true));
-
-    // check if matrix and/or RHS are zero
-    // note: to avoid a warning, we compare against numeric_limits<double>::min() instead of 0 here
-    if (system_rhs.block(block_idx).l2_norm() <= std::numeric_limits<double>::min())
-      {
-        pcout << "   Skipping " + field_name + " solve because RHS is zero." << std::endl;
-        solution.block(block_idx) = 0;
-
-        // signal successful solver and signal residual of zero
-        solver_control.check(0, 0.0);
-        signals.post_advection_solver(*this,
-                                      advection_field.is_temperature(),
-                                      advection_field.compositional_variable,
-                                      solver_control);
-
-        return 0;
-      }
-
-    AssertThrow(system_matrix.block(block_idx,
-                                    block_idx).linfty_norm() > std::numeric_limits<double>::min(),
-                ExcMessage ("The " + field_name + " equation can not be solved, because the matrix is zero, "
-                            "but the right-hand side is nonzero."));
-
-    LinearAlgebra::PreconditionILU preconditioner;
-    // first build without diagonal strengthening:
-    build_advection_preconditioner(advection_field, preconditioner, 0.);
-
-    TimerOutput::Scope timer (computing_timer, (advection_field.is_temperature() ?
-                                                "Solve temperature system" :
-                                                "Solve composition system"));
-    if (advection_field.is_temperature())
-      {
-        pcout << "   Solving temperature system... " << std::flush;
-      }
-    else
-      {
-        pcout << "   Solving "
-              << introspection.name_for_compositional_index(advection_field.compositional_variable)
-              << " system "
-              << "... " << std::flush;
-      }
-
-    // Create distributed vector (we need all blocks here even though we only
-    // solve for the current block) because only have a AffineConstraints<double>
-    // for the whole system, current_linearization_point contains our initial guess.
-    LinearAlgebra::BlockVector distributed_solution (
-      introspection.index_sets.system_partitioning,
-      mpi_communicator);
-    distributed_solution.block(block_idx) = current_linearization_point.block (block_idx);
-
-    // Temporary vector to hold the residual, we don't need a BlockVector here.
-    LinearAlgebra::Vector temp (
-      introspection.index_sets.system_partitioning[block_idx],
-      mpi_communicator);
-
-    current_constraints.set_zero(distributed_solution);
-
-    // Compute the residual before we solve and return this at the end.
-    // This is used in the nonlinear solver.
-    const double initial_residual = system_matrix.block(block_idx,block_idx).residual
-                                    (temp,
-                                     distributed_solution.block(block_idx),
-                                     system_rhs.block(block_idx));
-
-    // solve the linear system:
-    try
-      {
-        try
-          {
-            solver.solve (system_matrix.block(block_idx,block_idx),
-                          distributed_solution.block(block_idx),
-                          system_rhs.block(block_idx),
-                          preconditioner);
-          }
-        catch (const std::exception &exc)
-          {
-            // Try rebuilding the preconditioner with diagonal strengthening. In general,
-            // this increases the number of iterations needed, but helps in rare situations,
-            // especially when SUPG is used.
-            pcout << "retrying linear solve with different preconditioner..." << std::endl;
-            build_advection_preconditioner(advection_field, preconditioner, 1e-5);
-            solver.solve (system_matrix.block(block_idx,block_idx),
-                          distributed_solution.block(block_idx),
-                          system_rhs.block(block_idx),
-                          preconditioner);
-          }
-
-      }
-    // if the solver fails, report the error from processor 0 with some additional
-    // information about its location, and throw a quiet exception on all other
-    // processors
-    catch (const std::exception &exc)
-      {
-        // signal unsuccessful solver
-        signals.post_advection_solver(*this,
-                                      advection_field.is_temperature(),
-                                      advection_field.compositional_variable,
-                                      solver_control);
-
-
-        Utilities::throw_linear_solver_failure_exception("iterative advection solver",
-                                                         "Simulator::solve_advection",
-                                                         std::vector<SolverControl> {solver_control},
-                                                         exc,
-                                                         mpi_communicator,
-                                                         parameters.output_directory+"solver_history.txt");
-      }
-
-    // signal successful solver
-    signals.post_advection_solver(*this,
-                                  advection_field.is_temperature(),
-                                  advection_field.compositional_variable,
-                                  solver_control);
-
-    current_constraints.distribute (distributed_solution);
-    solution.block(block_idx) = distributed_solution.block(block_idx);
-
-    // print number of iterations and also record it in the
-    // statistics file
-    pcout << solver_control.last_step()
-          << " iterations." << std::endl;
-
-    if (advection_field.is_discontinuous(introspection))
-      {
-        const typename Parameters<dim>::DGLimiterType::Kind
-        limiter = (advection_field.is_temperature() ?
-                   parameters.limiter_for_discontinuous_temperature_solution :
-                   parameters.limiter_for_discontinuous_composition_solution[advection_field.compositional_variable]);
-
-        switch (limiter)
-          {
-            case Parameters<dim>::DGLimiterType::bound_preserving:
-              apply_BP_limiter_to_dg_solutions(advection_field);
-              break;
-            case Parameters<dim>::DGLimiterType::WENO:
-              apply_WENO_limiter_to_dg_solutions(advection_field);
-              break;
-            case Parameters<dim>::DGLimiterType::none:
-              break;
-            default:
-              AssertThrow(false, ExcNotImplemented());
-          }
-
-        if (limiter != Parameters<dim>::DGLimiterType::none)
-          // by applying the limiter we have modified the solution to no longer
-          // satisfy the equation. Therefore the residual is meaningless and cannot
-          // converge to zero in nonlinear iterations. Disable residual computation
-          // for this field.
-          return 0.0;
-        else
-          return initial_residual;
-      }
-
-    return initial_residual;
-  }
-
-
-
-  template <int dim>
-  std::pair<double,double>
-  Simulator<dim>::solve_stokes ()
-  {
-    TimerOutput::Scope timer (computing_timer, "Solve Stokes system");
-    pcout << "   Solving Stokes system... " << std::flush;
-
-    if (parameters.stokes_solver_type == Parameters<dim>::StokesSolverType::block_gmg)
-      {
-        return stokes_matrix_free->solve();
-      }
-
-    // In the following, we will operate on a vector that contains only
-    // the velocity and pressure DoFs, rather than on the full
-    // system. Set such a reduced vector up, without any ghost elements.
-    // (Worth noting: for direct solvers, this vector has one block,
-    // whereas for the iterative solvers, the result has two blocks.)
-    LinearAlgebra::BlockVector distributed_stokes_solution (introspection.index_sets.stokes_partitioning,
-                                                            mpi_communicator);
-
-    // Create a view of all constraints that only pertains to the
-    // Stokes subset of degrees of freedom. We can then use this later
-    // to call constraints.distribute(), constraints.set_zero(), etc.,
-    // on those block vectors that only have the Stokes components in
-    // them.
-    //
-    // For the moment, assume that the Stokes degrees are first in the
-    // overall vector, so that they form a contiguous range starting
-    // at zero. The assertion checks this, but this could easily be
-    // generalized if the Stokes block were not starting at zero.
-#if DEAL_II_VERSION_GTE(9,6,0)
-    {
-      const unsigned int block_vel = introspection.block_indices.velocities;
-      (void) block_vel;
-
-      Assert (block_vel == 0, ExcNotImplemented());
-      if (parameters.use_direct_stokes_solver == false)
-        {
-          const unsigned int block_p = (parameters.include_melt_transport) ?
-                                       introspection.variable("fluid pressure").block_index
-                                       : introspection.block_indices.pressure;
-          (void) block_p;
-          Assert (block_p == 1, ExcNotImplemented());
-        }
-    }
-
-    IndexSet stokes_dofs (dof_handler.n_dofs());
-    stokes_dofs.add_range (0, distributed_stokes_solution.size());
-    const AffineConstraints<double> current_stokes_constraints
-      = current_constraints.get_view (stokes_dofs);
-#else
-    const AffineConstraints<double> &current_stokes_constraints = current_constraints;
-#endif
-
-    double initial_nonlinear_residual = numbers::signaling_nan<double>();
-    double final_linear_residual      = numbers::signaling_nan<double>();
-
-    if (parameters.use_direct_stokes_solver)
-      {
-        Assert (distributed_stokes_solution.n_blocks() == 1, ExcInternalError());
-
-        // Many parts of the solver depend on the block layout (typically,
-        // velocity = 0, pressure = 1, but differently for direct solver
-        // setups -- see the comment above).
-        const unsigned int block_vel_and_pres = introspection.block_indices.velocities;
-        Assert(block_vel_and_pres == 0, ExcNotImplemented());
-
-        // We hard-code the blocks down below, so make sure block 0 is indeed
-        // the block containing velocity and pressure:
-        Assert(introspection.block_indices.velocities == 0, ExcNotImplemented());
-        Assert(introspection.block_indices.pressure == 0
-               ||
-               (parameters.include_melt_transport
-                && introspection.variable("fluid pressure").block_index == 0
-                && introspection.variable("compaction pressure").block_index == 0),
-               ExcNotImplemented());
-
-        // Start with a reasonable guess.
-        //
-        // While we don't need to set up the initial guess for the direct solver
-        // (it will be ignored by the solver anyway), we need this if we are
-        // using a nonlinear scheme, because we use this to compute the current
-        // nonlinear residual (see initial_residual below).
-        solution.block(block_vel_and_pres) = current_linearization_point.block(block_vel_and_pres);
-
-        // TODO: if there was an easy way to know if the caller needs the
-        // initial residual we could skip all of this stuff.
-        distributed_stokes_solution.block(0) = solution.block(block_vel_and_pres);
-        denormalize_pressure (this->last_pressure_normalization_adjustment,
-                              distributed_stokes_solution,
-                              solution);
-        current_stokes_constraints.set_zero (distributed_stokes_solution);
-
-        // Undo the pressure scaling:
-        IndexSet &pressure_idxset = parameters.include_melt_transport ?
-                                    introspection.index_sets.locally_owned_melt_pressure_dofs
-                                    : introspection.index_sets.locally_owned_pressure_dofs;
-
-        for (unsigned int i=0; i< pressure_idxset.n_elements(); ++i)
-          {
-            types::global_dof_index idx = pressure_idxset.nth_index_in_set(i);
-
-            distributed_stokes_solution(idx) /= pressure_scaling;
-          }
-        distributed_stokes_solution.compress(VectorOperation::insert);
-
-        // we need a temporary vector for the residual (even if we don't care about it)
-        LinearAlgebra::Vector residual (introspection.index_sets.stokes_partitioning[0], mpi_communicator);
-
-        initial_nonlinear_residual = system_matrix.block(block_vel_and_pres,block_vel_and_pres).residual(
-                                       residual,
-                                       distributed_stokes_solution.block(0),
-                                       system_rhs.block(block_vel_and_pres));
-
-        SolverControl cn;
-        // TODO: can we re-use the direct solver?
-        TrilinosWrappers::SolverDirect solver(cn);
-        try
-          {
-            solver.solve(system_matrix.block(block_vel_and_pres,block_vel_and_pres),
-                         distributed_stokes_solution.block(0),
-                         system_rhs.block(block_vel_and_pres));
-
-            // if we got here, we have successfully solved the linear system
-            // with a direct solver, and the final linear residual should
-            // be approximately zero. we could compute it exactly, but
-            // this is probably not necessary
-            final_linear_residual = 0;
-          }
-        // if the solver fails, report the error from processor 0 with some additional
-        // information about its location, and throw a quiet exception on all other
-        // processors
-        catch (const std::exception &exc)
-          {
-            if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
-              {
-                AssertThrow (false,
-                             ExcMessage (std::string("The direct Stokes solver "
-                                                     "did not succeed. It reported the following error:\n\n")
-                                         +
-                                         exc.what()));
-              }
-            else
-              throw QuietException();
-          }
-
-
-        current_stokes_constraints.distribute (distributed_stokes_solution);
-
-        // Now rescale the pressure back to real physical units. Note that we are
-        // working on a vector in which all velocities and pressures are in one
-        // block (that's the design for block layout in case we're using a direct
-        // solver), and so unlike in the "common" case, we can't just scale a
-        // whole vector block -- we have to do it element by element.
-        {
-          const IndexSet &pressure_idxset
-            = (parameters.include_melt_transport ?
-               introspection.index_sets.locally_owned_melt_pressure_dofs
-               : introspection.index_sets.locally_owned_pressure_dofs);
-          for (const types::global_dof_index i : pressure_idxset)
-            distributed_stokes_solution(i) *= pressure_scaling;
-
-          distributed_stokes_solution.block(0).compress(VectorOperation::insert);
-        }
-
-        // Then copy back the solution from the temporary (non-ghosted) vector
-        // into the ghosted one with all solution components. Note that
-        // for a direct solver, we have only one block for velocity+pressure,
-        // and so only one block needs to be copied.
-        solution.block(block_vel_and_pres) = distributed_stokes_solution.block(0);
-
-        pcout << "done." << std::endl;
-      }
-    else // use iterative solver
-      {
-        Assert (distributed_stokes_solution.n_blocks() == 2, ExcInternalError());
-        Assert(!parameters.include_melt_transport
-               || introspection.variable("compaction pressure").block_index == 1,
-               ExcNotImplemented());
-
-        // Many parts of the solver depend on the block layout (velocity = 0,
-        // pressure = 1). For example the linearized_stokes_initial_guess vector or the StokesBlock matrix
-        // wrapper. Let us make sure that this holds (and shorten their names):
-        const unsigned int block_vel = introspection.block_indices.velocities;
-        const unsigned int block_p = (parameters.include_melt_transport) ?
-                                     introspection.variable("fluid pressure").block_index
-                                     : introspection.block_indices.pressure;
-        Assert(block_vel == 0, ExcNotImplemented());
-        Assert(block_p == 1, ExcNotImplemented());
-        Assert(!parameters.include_melt_transport
-               || introspection.variable("compaction pressure").block_index == 1,
-               ExcNotImplemented());
-
-        const internal::StokesBlock stokes_block(system_matrix);
-
-        // create a completely distributed vector that will be used for
-        // the scaled and denormalized solution and later used as a
-        // starting guess for the linear solver
-        LinearAlgebra::BlockVector linearized_stokes_initial_guess (introspection.index_sets.stokes_partitioning, mpi_communicator);
-
-        // copy the velocity and pressure from current_linearization_point into
-        // the vector linearized_stokes_initial_guess. We need to do the copy because
-        // linearized_stokes_variables has a different
-        // layout than current_linearization_point, which also contains all the
-        // other solution variables.
-        if (assemble_newton_stokes_system == false)
-          {
-            linearized_stokes_initial_guess.block (block_vel) = current_linearization_point.block (block_vel);
-            linearized_stokes_initial_guess.block (block_p) = current_linearization_point.block (block_p);
-
-            denormalize_pressure (this->last_pressure_normalization_adjustment,
-                                  linearized_stokes_initial_guess,
-                                  current_linearization_point);
-          }
-        else
-          {
-            // The Newton solver solves for updates to variables, for which our best guess is zero when
-            // it isn't the first nonlinear iteration. When it is the first nonlinear iteration, we
-            // have to assemble the full (non-defect correction) Picard, to get the boundary conditions
-            // right in combination with being able to use the initial guess optimally. So we should never
-            // end up here when it is the first nonlinear iteration.
-            Assert(nonlinear_iteration != 0,
-                   ExcMessage ("The Newton solver should not be active in the first nonlinear iteration."));
-
-            linearized_stokes_initial_guess.block (block_vel) = 0;
-            linearized_stokes_initial_guess.block (block_p) = 0;
-          }
-
-        current_stokes_constraints.set_zero (linearized_stokes_initial_guess);
-        linearized_stokes_initial_guess.block (block_p) /= pressure_scaling;
-
-        double solver_tolerance = 0;
-        if (assemble_newton_stokes_system == false)
-          {
-            // (ab)use the distributed solution vector to temporarily put a residual in
-            // (we don't care about the residual vector -- all we care about is the
-            // value (number) of the initial residual). The initial residual is returned
-            // to the caller (for nonlinear computations). This value is computed before
-            // the solve because we want to compute || A^{k+1} U^k - F^{k+1} ||, which is
-            // the nonlinear residual. Because the place where the nonlinear residual is
-            // checked against the nonlinear tolerance comes after the solve, the system
-            // is solved one time too many in the case of a nonlinear Picard solver.
-            initial_nonlinear_residual = stokes_block.residual (distributed_stokes_solution,
-                                                                linearized_stokes_initial_guess,
-                                                                system_rhs);
-
-            // Note: the residual is computed with a zero velocity, effectively computing
-            // || B^T p - g ||, which we are going to use for our solver tolerance.
-            // We do not use the current velocity for the initial residual because
-            // this would not decrease the number of iterations if we had a better
-            // initial guess (say using a smaller timestep). But we need to use
-            // the pressure instead of only using the norm of the rhs, because we
-            // are only interested in the part of the rhs not balanced by the static
-            // pressure (the current pressure is a good approximation for the static
-            // pressure).
-            const double residual_u = system_matrix.block(0,1).residual (distributed_stokes_solution.block(0),
-                                                                         linearized_stokes_initial_guess.block(1),
-                                                                         system_rhs.block(0));
-            const double residual_p = system_rhs.block(1).l2_norm();
-
-            solver_tolerance = parameters.linear_stokes_solver_tolerance *
-                               std::sqrt(residual_u*residual_u+residual_p*residual_p);
-          }
-        else
-          {
-            // if we are solving for the Newton update, then the initial guess of the solution
-            // vector is the zero vector, and the starting (nonlinear) residual is simply
-            // the norm of the (Newton) right hand side vector
-            const double residual_u = system_rhs.block(0).l2_norm();
-            const double residual_p = system_rhs.block(1).l2_norm();
-            solver_tolerance = parameters.linear_stokes_solver_tolerance *
-                               std::sqrt(residual_u*residual_u+residual_p*residual_p);
-
-            // as described in the documentation of the function, the initial
-            // nonlinear residual for the Newton method is computed by just
-            // taking the norm of the right hand side
-            initial_nonlinear_residual = std::sqrt(residual_u*residual_u+residual_p*residual_p);
-          }
-        // Now overwrite the solution vector again with the current best guess
-        // to solve the linear system
-        distributed_stokes_solution = linearized_stokes_initial_guess;
-
-        // extract Stokes parts of rhs vector
-        LinearAlgebra::BlockVector distributed_stokes_rhs(introspection.index_sets.stokes_partitioning);
-
-        distributed_stokes_rhs.block(block_vel) = system_rhs.block(block_vel);
-        distributed_stokes_rhs.block(block_p) = system_rhs.block(block_p);
-
-        PrimitiveVectorMemory<LinearAlgebra::BlockVector> mem;
-
-        // create Solver controls for the cheap and expensive solver phase
-        SolverControl solver_control_cheap (parameters.n_cheap_stokes_solver_steps,
-                                            solver_tolerance);
-
-        SolverControl solver_control_expensive (parameters.n_expensive_stokes_solver_steps,
-                                                solver_tolerance);
-
-        solver_control_cheap.enable_history_data();
-        solver_control_expensive.enable_history_data();
-
-        std::unique_ptr<internal::SchurComplementOperator> schur;
-        if (parameters.use_bfbt)
-          {
-            schur = std::make_unique<internal::WeightedBFBT<TrilinosWrappers::PreconditionBase>>(
-                      system_preconditioner_matrix.block(1,1),
-                      *Mp_preconditioner,
-                      parameters.linear_solver_S_block_tolerance,
-                      inverse_lumped_mass_matrix.block(0),
-                      system_matrix);
-          }
-        else
-          {
-            schur = std::make_unique<internal::InverseWeightedMassMatrix<TrilinosWrappers::PreconditionBase>>(
-                      system_preconditioner_matrix.block(1,1),
-                      *Mp_preconditioner,
-                      parameters.linear_solver_S_block_tolerance);
-
-          }
-
-        // create a cheap preconditioner that consists of only a single V-cycle
-        internal::InverseVelocityBlock<LinearAlgebra::PreconditionAMG> inverse_velocity_block_cheap(
-          system_matrix.block(0,0),
-          *Amg_preconditioner,
-          /* do_solve_A = */ false,
-          stokes_A_block_is_symmetric(),
-          parameters.linear_solver_A_block_tolerance);
-        const internal::BlockSchurPreconditioner<internal::InverseVelocityBlock<LinearAlgebra::PreconditionAMG>,
-              internal::SchurComplementOperator>
-              preconditioner_cheap (system_matrix,
-                                    system_preconditioner_matrix,
-                                    *schur,
-                                    inverse_velocity_block_cheap);
-
-        // create an expensive preconditioner that solves for the A block with CG
-        internal::InverseVelocityBlock<LinearAlgebra::PreconditionAMG> inverse_velocity_block_expensive(
-          system_matrix.block(0,0),
-          *Amg_preconditioner,
-          /* do_solve_A = */ true,
-          stokes_A_block_is_symmetric(),
-          parameters.linear_solver_A_block_tolerance);
-        const internal::BlockSchurPreconditioner<internal::InverseVelocityBlock<LinearAlgebra::PreconditionAMG>,
-              internal::SchurComplementOperator>
-              preconditioner_expensive (system_matrix,
-                                        system_preconditioner_matrix,
-                                        *schur,
-                                        inverse_velocity_block_expensive);
-        // step 1a: try if the simple and fast solver
-        // succeeds in n_cheap_stokes_solver_steps steps or less.
-        try
-          {
-            // if this cheaper solver is not desired, then simply
-            // short-cut the attempt at solving with the cheaper
-            // preconditioner by throwing an exception right away,
-            // which is equivalent to a 'goto' statement to the top of
-            // the 'catch' block below
-            if (parameters.n_cheap_stokes_solver_steps == 0)
-              throw SolverControl::NoConvergence(0,0);
-
-            SolverFGMRES<LinearAlgebra::BlockVector>
-            solver(solver_control_cheap, mem,
-                   SolverFGMRES<LinearAlgebra::BlockVector>::
-                   AdditionalData(parameters.stokes_gmres_restart_length));
-
-            solver.solve (stokes_block,
-                          distributed_stokes_solution,
-                          distributed_stokes_rhs,
-                          preconditioner_cheap);
-
-            // Success. Print all iterations to screen (0 expensive iterations).
-            pcout << (solver_control_cheap.last_step() != numbers::invalid_unsigned_int ?
-                      solver_control_cheap.last_step():
-                      0)
-                  << "+0"
-                  << " iterations." << std::endl;
-
-            final_linear_residual = solver_control_cheap.last_value();
-          }
-
-        // step 1b: take the stronger solver in case
-        // the simple solver failed and attempt solving
-        // it in n_expensive_stokes_solver_steps steps or less.
-        catch (const SolverControl::NoConvergence &exc)
-          {
-            // The cheap solver failed or never ran.
-            // Print the number of cheap iterations to screen to indicate we
-            // try the expensive solver next.
-            pcout << (solver_control_cheap.last_step() != numbers::invalid_unsigned_int ?
-                      solver_control_cheap.last_step():
-                      0) << '+' << std::flush;
-
-            // use the value defined by the user
-            // OR
-            // at least a restart length of 100 for melt models
-            const unsigned int number_of_temporary_vectors = (parameters.include_melt_transport == false ?
-                                                              parameters.stokes_gmres_restart_length :
-                                                              std::max(parameters.stokes_gmres_restart_length, 100U));
-
-            try
-              {
-                // if no expensive steps allowed, we have failed, rethrow exception
-                if (parameters.n_expensive_stokes_solver_steps == 0)
-                  {
-                    pcout << "0 iterations." << std::endl;
-                    throw exc;
-                  }
-
-                SolverFGMRES<LinearAlgebra::BlockVector>
-                solver(solver_control_expensive, mem,
-                       SolverFGMRES<LinearAlgebra::BlockVector>::
-                       AdditionalData(number_of_temporary_vectors));
-
-                solver.solve (stokes_block,
-                              distributed_stokes_solution,
-                              distributed_stokes_rhs,
-                              preconditioner_expensive);
-                // Success. Print expensive iterations to screen.
-                pcout << solver_control_expensive.last_step()
-                      << " iterations." << std::endl;
-
-                final_linear_residual = solver_control_expensive.last_value();
-              }
-            // if the solver fails, report the error from processor 0 with some additional
-            // information about its location, and throw a quiet exception on all other
-            // processors
-            catch (const std::exception &exc)
-              {
-                signals.post_stokes_solver(*this,
-                                           schur->n_iterations(),
-                                           inverse_velocity_block_cheap.n_iterations()+inverse_velocity_block_expensive.n_iterations(),
-                                           solver_control_cheap,
-                                           solver_control_expensive);
-
-                std::vector<SolverControl> solver_controls;
-                if (parameters.n_cheap_stokes_solver_steps > 0)
-                  solver_controls.push_back(solver_control_cheap);
-
-                if (parameters.n_expensive_stokes_solver_steps > 0)
-                  solver_controls.push_back(solver_control_expensive);
-
-                // Exit with an exception that describes the underlying cause:
-                Utilities::throw_linear_solver_failure_exception("iterative Stokes solver",
-                                                                 "Simulator::solve_stokes",
-                                                                 solver_controls,
-                                                                 exc,
-                                                                 mpi_communicator,
-                                                                 parameters.output_directory+"solver_history.txt");
-              }
-          }
-
-        // distribute hanging node and other constraints
-        current_stokes_constraints.distribute (distributed_stokes_solution);
-
-        // now rescale the pressure back to real physical units
-        distributed_stokes_solution.block(block_p) *= pressure_scaling;
-
-        // then copy back the solution from the temporary (non-ghosted) vector
-        // into the ghosted one with all solution components
-        solution.block(block_vel) = distributed_stokes_solution.block(0);
-        solution.block(block_p) = distributed_stokes_solution.block(1);
-
-        // signal successful solver
-        signals.post_stokes_solver(*this,
-                                   schur->n_iterations(),
-                                   inverse_velocity_block_cheap.n_iterations()+inverse_velocity_block_expensive.n_iterations(),
-                                   solver_control_cheap,
-                                   solver_control_expensive);
-      }
-
-    // do some cleanup now that we have the solution
-    remove_nullspace(solution, distributed_stokes_solution);
-    if (assemble_newton_stokes_system == false)
-      this->last_pressure_normalization_adjustment = normalize_pressure(solution);
-
-    // convert melt pressures:
-    if (parameters.include_melt_transport)
-      melt_handler->compute_melt_variables(system_matrix,solution,system_rhs);
-
-    return std::pair<double,double>(initial_nonlinear_residual,
-                                    final_linear_residual);
-  }
-
-}
-
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template double Simulator<dim>::solve_advection (const AdvectionField &); \
-  template std::pair<double,double> Simulator<dim>::solve_stokes ();
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/solver_schemes.cc.bak b/source/simulator/solver_schemes.cc.bak
deleted file mode 100644
index ec59003c77c..00000000000
--- a/source/simulator/solver_schemes.cc.bak
+++ /dev/null
@@ -1,1411 +0,0 @@
-/*
-  Copyright (C) 2017 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/simulator.h>
-#include <aspect/global.h>
-#include <aspect/mesh_deformation/free_surface.h>
-#include <aspect/volume_of_fluid/handler.h>
-#include <aspect/newton.h>
-#include <aspect/melt.h>
-
-#include <deal.II/numerics/vector_tools.h>
-
-#include <aspect/stokes_matrix_free.h>
-
-
-namespace aspect
-{
-
-  namespace
-  {
-    /**
-     * Converts a function with a certain number of components into a Function@<dim@>
-     * with optionally having additional zero components.
-     **/
-    template <int dim>
-    class VectorFunctionFromVectorFunctionObject : public Function<dim>
-    {
-      public:
-        /**
-         * Converts a function with @p n_object_components components into a Function@dim@
-         * while optionally providing additional components that are set to zero.
-         *
-         * @param function_object The function that will form the components
-         *     of the resulting Function object.
-         * @param first_component The first component that should be
-         *     filled.
-         * @param n_object_components The number of components that should be
-         *     filled from the first.
-         * @param n_total_components The total number of vector components of the
-         *     resulting Function object.
-         **/
-
-        VectorFunctionFromVectorFunctionObject (const std::function<void (const Point<dim> &,Vector<double> &)> &function_object,
-                                                const unsigned int first_component,
-                                                const unsigned int n_object_components,
-                                                const unsigned int n_total_components)
-          :
-          Function<dim>(n_total_components),
-          function_object (function_object),
-          first_component (first_component),
-          n_object_components (n_object_components)
-        {
-          Assert ((n_object_components > 0
-                   &&
-                   first_component+n_object_components <= n_total_components),
-                  ExcMessage ("Number of objects components needs to be less than number of total components"));
-        }
-
-
-
-        double
-        value (const Point<dim> &p,
-               const unsigned int component) const override
-        {
-          Assert (component < this->n_components,
-                  ExcIndexRange (component, 0, this->n_components));
-
-          if (component < first_component)
-            return 0;
-          else if (component >= first_component + n_object_components)
-            return 0;
-          else
-            {
-              Vector<double> temp(n_object_components);
-              function_object (p, temp);
-              return temp(component - first_component);
-            }
-        }
-
-
-
-        void
-        vector_value (const Point<dim>   &p,
-                      Vector<double>     &values) const override
-        {
-          AssertDimension(values.size(), this->n_components);
-
-          // set everything to zero, and then the right components to their correct values
-          values = 0;
-          Vector<double> temp(n_object_components);
-          function_object (p, temp);
-          for (unsigned int i = 0; i < n_object_components; ++i)
-            {
-              values(first_component + i) = temp(i);
-            }
-        }
-
-
-
-      private:
-        /**
-         * The function object which we call when this class's solution() function is called.
-         **/
-        const std::function<void (const Point<dim> &,Vector<double> &)> function_object;
-
-        /**
-         * The first vector component whose value is to be filled by the given
-         * function.
-         */
-        const unsigned int first_component;
-        /**
-         * The number of vector components whose values are to be filled by the given
-         * function.
-         */
-        const unsigned int n_object_components;
-
-    };
-
-  }
-
-
-
-  template <int dim>
-  double Simulator<dim>::assemble_and_solve_temperature (const double &initial_residual,
-                                                         double *residual)
-  {
-    double current_residual = 0.0;
-
-    switch (parameters.temperature_method)
-      {
-        case Parameters<dim>::AdvectionFieldMethod::fem_field:
-        case Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion:
-        {
-          const AdvectionField adv_field (AdvectionField::temperature());
-
-          // if this is a prescribed field with diffusion, we first have to copy the material model
-          // outputs into the prescribed field before we assemble and solve the equation
-          if (parameters.temperature_method == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion)
-            {
-              TimerOutput::Scope timer (computing_timer, "Interpolate prescribed temperature");
-
-              interpolate_material_output_into_advection_field(adv_field);
-
-              // Also set the old_solution block to the prescribed field. The old
-              // solution is the one that is used to assemble the diffusion system in
-              // assemble_advection_system() for this solver scheme.
-              old_solution.block(adv_field.block_index(introspection)) = solution.block(adv_field.block_index(introspection));
-            }
-
-          assemble_advection_system (adv_field);
-
-          if (residual)
-            *residual = system_rhs.block(introspection.block_indices.temperature).l2_norm();
-
-          current_residual = solve_advection(adv_field);
-          break;
-        }
-
-        case Parameters<dim>::AdvectionFieldMethod::prescribed_field:
-        {
-          const AdvectionField adv_field (AdvectionField::temperature());
-
-          TimerOutput::Scope timer (computing_timer, "Interpolate prescribed temperature");
-
-          interpolate_material_output_into_advection_field(adv_field);
-
-          // Call the signal in case the user wants to do something with the variable:
-          SolverControl dummy;
-          signals.post_advection_solver(*this,
-                                        adv_field.is_temperature(),
-                                        adv_field.compositional_variable,
-                                        dummy);
-          break;
-        }
-
-        case Parameters<dim>::AdvectionFieldMethod::static_field:
-        {
-          const AdvectionField adv_field (AdvectionField::temperature());
-          // Do nothing here, but at least call the signal in case the
-          // user wants to do something with the variable:
-          SolverControl dummy;
-          signals.post_advection_solver(*this,
-                                        adv_field.is_temperature(),
-                                        adv_field.compositional_variable,
-                                        dummy);
-          break;
-        }
-
-        default:
-          AssertThrow(false,ExcNotImplemented());
-      }
-
-    current_linearization_point.block(introspection.block_indices.temperature)
-      = solution.block(introspection.block_indices.temperature);
-
-    if (initial_residual > 0)
-      return current_residual / initial_residual;
-
-    return 0.0;
-  }
-
-
-
-  template <int dim>
-  std::vector<double>
-  Simulator<dim>::assemble_and_solve_composition (const std::vector<double> &initial_residual,
-                                                  std::vector<double> *residual)
-  {
-    // Advect the particles before they are potentially used to
-    // set up the compositional fields.
-    for (auto &particle_world : particle_worlds)
-      {
-        // Do not advect the particles in the initial refinement stage
-        const bool in_initial_refinement = (timestep_number == 0)
-                                           && (pre_refinement_step < parameters.initial_adaptive_refinement);
-        if (!in_initial_refinement)
-          // Advance the particles in the world to the current time
-          particle_world->advance_timestep();
-
-        if (particle_world->get_property_manager().need_update() == Particle::Property::update_output_step)
-          particle_world->update_particles();
-      }
-
-    std::vector<double> current_residual(introspection.n_compositional_fields,0.0);
-
-    if (residual)
-      Assert(residual->size() == introspection.n_compositional_fields, ExcInternalError());
-
-    std::vector<AdvectionField> fields_advected_by_particles;
-
-    for (unsigned int c=0; c < introspection.n_compositional_fields; ++c)
-      {
-        const AdvectionField adv_field (AdvectionField::composition(c));
-        const typename Parameters<dim>::AdvectionFieldMethod::Kind method = adv_field.advection_method(introspection);
-        switch (method)
-          {
-            case Parameters<dim>::AdvectionFieldMethod::fem_field:
-            case Parameters<dim>::AdvectionFieldMethod::fem_melt_field:
-            case Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion:
-            case Parameters<dim>::AdvectionFieldMethod::fem_darcy_field:
-            {
-              // if this is a prescribed field with diffusion, we first have to copy the material model
-              // outputs into the prescribed field before we assemble and solve the equation
-              if (method == Parameters<dim>::AdvectionFieldMethod::prescribed_field_with_diffusion)
-                {
-                  TimerOutput::Scope timer (computing_timer, "Interpolate prescribed composition");
-
-                  interpolate_material_output_into_advection_field(adv_field);
-
-                  // Also set the old_solution block to the prescribed field. The old
-                  // solution is the one that is used to assemble the diffusion system in
-                  // assemble_advection_system() for this solver scheme.
-                  old_solution.block(adv_field.block_index(introspection)) = solution.block(adv_field.block_index(introspection));
-                }
-
-              assemble_advection_system (adv_field);
-
-              if (residual)
-                (*residual)[c] = system_rhs.block(introspection.block_indices.compositional_fields[c]).l2_norm();
-
-              current_residual[c] = solve_advection(adv_field);
-
-              // Release the contents of the matrix block we used again:
-              const unsigned int block_idx = adv_field.block_index(introspection);
-              if (adv_field.sparsity_pattern_block_index(introspection)!=block_idx)
-                system_matrix.block(block_idx, block_idx).clear();
-
-              // No need to call the post_advection_solver signal here: It is
-              // automatically called from solve_advection() above.
-
-              break;
-            }
-
-            case Parameters<dim>::AdvectionFieldMethod::particles:
-            {
-              // handle all particle fields together to increase efficiency
-              fields_advected_by_particles.push_back(adv_field);
-              break;
-            }
-
-            case Parameters<dim>::AdvectionFieldMethod::prescribed_field:
-            {
-              TimerOutput::Scope timer (computing_timer, "Interpolate prescribed composition");
-
-              interpolate_material_output_into_advection_field(adv_field);
-
-              // Call the signal in case the user wants to do something with the variable:
-              SolverControl dummy;
-              signals.post_advection_solver(*this,
-                                            adv_field.is_temperature(),
-                                            adv_field.compositional_variable,
-                                            dummy);
-              break;
-            }
-
-            case Parameters<dim>::AdvectionFieldMethod::volume_of_fluid:
-            {
-              volume_of_fluid_handler->do_volume_of_fluid_update(adv_field);
-              break;
-            }
-
-            case Parameters<dim>::AdvectionFieldMethod::static_field:
-            {
-              // Do nothing here, but at least call the signal in case the
-              // user wants to do something with the variable:
-              SolverControl dummy;
-              signals.post_advection_solver(*this,
-                                            adv_field.is_temperature(),
-                                            adv_field.compositional_variable,
-                                            dummy);
-              break;
-            }
-
-            default:
-              AssertThrow(false,ExcNotImplemented());
-          }
-      }
-
-    if (fields_advected_by_particles.size() > 0)
-      interpolate_particle_properties(fields_advected_by_particles);
-
-
-    // for consistency we update the current linearization point only after we have solved
-    // all fields, so that we use the same point in time for every field when solving
-    for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-      {
-        current_linearization_point.block(introspection.block_indices.compositional_fields[c])
-          = solution.block(introspection.block_indices.compositional_fields[c]);
-
-        if ((initial_residual.size() > 0) && (initial_residual[c] > 0))
-          current_residual[c] /= initial_residual[c];
-        else
-          current_residual[c] = 0.0;
-      }
-
-    return current_residual;
-  }
-
-
-
-  template <int dim>
-  double
-  Simulator<dim>::assemble_and_solve_stokes (const double &initial_nonlinear_residual,
-                                             double *nonlinear_residual)
-  {
-    // If the Stokes matrix depends on the solution, or we have active
-    // velocity boundary conditions, we need to re-assemble the system matrix
-    // (and preconditioner) every time. If we have active boundary conditions,
-    // they could a) depend on the solution, or b) be inhomogeneous. In both
-    // cases, just assembling the RHS will be incorrect.  If no active
-    // boundaries exist, we only have no-slip or free slip conditions, so we
-    // don't need to force assembly of the matrix.
-    if (stokes_matrix_depends_on_solution()
-        ||
-        (boundary_velocity_manager.get_active_boundary_velocity_conditions().size() > 0)
-        || parameters.mesh_deformation_enabled
-       )
-      rebuild_stokes_matrix = rebuild_stokes_preconditioner = true;
-
-    // set constraints for p_c if porosity is below a threshold
-    if (nonlinear_iteration == 0 && parameters.include_melt_transport)
-      {
-        compute_current_constraints();
-        if (rebuild_sparsity_and_matrices)
-          {
-            setup_system_matrix (introspection.index_sets.system_partitioning);
-            setup_system_preconditioner (introspection.index_sets.system_partitioning);
-
-            rebuild_stokes_matrix = rebuild_stokes_preconditioner = true;
-          }
-      }
-
-    assemble_stokes_system ();
-
-    // build the preconditioner
-    if (stokes_matrix_free)
-      stokes_matrix_free->build_preconditioner();
-    else
-      build_stokes_preconditioner();
-
-    if (nonlinear_residual)
-      *nonlinear_residual = compute_initial_stokes_residual();
-
-    const double current_nonlinear_residual = solve_stokes().first;
-
-    current_linearization_point.block(introspection.block_indices.velocities)
-      = solution.block(introspection.block_indices.velocities);
-
-    if (introspection.block_indices.velocities != introspection.block_indices.pressure)
-      current_linearization_point.block(introspection.block_indices.pressure)
-        = solution.block(introspection.block_indices.pressure);
-
-    if (parameters.include_melt_transport)
-      {
-        // Note that the compaction pressure is in the fluid pressure block
-        // and will therefore be updated as well.
-        const unsigned int fluid_velocity_block = introspection.variable("fluid velocity").block_index;
-        const unsigned int fluid_pressure_block = introspection.variable("fluid pressure").block_index;
-        current_linearization_point.block(fluid_velocity_block) = solution.block(fluid_velocity_block);
-        current_linearization_point.block(fluid_pressure_block) = solution.block(fluid_pressure_block);
-      }
-
-    if (initial_nonlinear_residual > 0)
-      return current_nonlinear_residual / initial_nonlinear_residual;
-    else
-      return 0.0;
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::do_one_defect_correction_Stokes_step(DefectCorrectionResiduals &dcr,
-                                                            const bool use_picard)
-  {
-    /**
-     * copied from solver.cc
-     */
-
-    // Many parts of the solver depend on the block layout (velocity = 0,
-    // pressure = 1). For example the linearized_stokes_initial_guess vector or the StokesBlock matrix
-    // wrapper. Let us make sure that this holds (and shorten their names):
-    const unsigned int block_vel = introspection.block_indices.velocities;
-    const unsigned int block_p = (parameters.include_melt_transport) ?
-                                 introspection.variable("fluid pressure").block_index
-                                 : introspection.block_indices.pressure;
-    Assert(block_vel == 0, ExcNotImplemented());
-    Assert(block_p == 1, ExcNotImplemented());
-    Assert(!parameters.include_melt_transport
-           || introspection.variable("compaction pressure").block_index == 1, ExcNotImplemented());
-
-    // create a completely distributed vector that will be used for
-    // the scaled and denormalized solution and later used as a
-    // starting guess for the linear solver
-    LinearAlgebra::BlockVector linearized_stokes_initial_guess(introspection.index_sets.stokes_partitioning, mpi_communicator);
-    linearized_stokes_initial_guess.block(block_vel) = current_linearization_point.block(block_vel);
-    linearized_stokes_initial_guess.block(block_p) = current_linearization_point.block(block_p);
-
-    if (nonlinear_iteration == 0)
-      {
-        dcr.initial_residual = compute_initial_newton_residual(linearized_stokes_initial_guess);
-        dcr.switch_initial_residual = dcr.initial_residual;
-        dcr.residual_old = dcr.initial_residual;
-        dcr.residual = dcr.initial_residual;
-      }
-
-    assemble_newton_stokes_system = assemble_newton_stokes_matrix = true;
-
-    if (nonlinear_iteration == 0)
-      {
-        assemble_newton_stokes_system = assemble_newton_stokes_matrix = false;
-      }
-    else
-      {
-        denormalize_pressure (last_pressure_normalization_adjustment,
-                              linearized_stokes_initial_guess,
-                              current_linearization_point);
-      }
-
-    if (nonlinear_iteration <= 1)
-      {
-        set_assemblers();
-        compute_current_constraints ();
-      }
-
-    // If the Stokes matrix depends on the solution, or we have active
-    // velocity boundary conditions, we need to re-assemble the system matrix
-    // (and preconditioner) every time. If we have active boundary conditions,
-    // they could a) depend on the solution, or b) be inhomogeneous. In both
-    // cases, just assembling the RHS will be incorrect.  If no active
-    // boundaries exist, we only have no-slip or free slip conditions, so we
-    // don't need to force assembly of the matrix.
-    if (stokes_matrix_depends_on_solution()
-        ||
-        nonlinear_iteration == 0)
-      rebuild_stokes_matrix = rebuild_stokes_preconditioner = assemble_newton_stokes_matrix = true;
-    else if (parameters.enable_prescribed_dilation)
-      // The dilation requires the Stokes matrix (which is on the rhs
-      // in the Newton solver) to be updated.
-      rebuild_stokes_matrix = true;
-
-    assemble_stokes_system();
-
-    // recompute rhs
-    dcr.velocity_residual = system_rhs.block(introspection.block_indices.velocities).l2_norm();
-    dcr.pressure_residual = system_rhs.block(introspection.block_indices.pressure).l2_norm();
-    dcr.residual = std::sqrt(dcr.velocity_residual * dcr.velocity_residual + dcr.pressure_residual * dcr.pressure_residual);
-
-    // Test whether the rhs has dropped so much that we can assume that the iteration is done.
-    if (dcr.residual < dcr.residual_old * 1e-8)
-      {
-        pcout << "   Nonlinear residual reduction has been very large ("
-              << dcr.residual/dcr.residual_old << "); skipping Stokes solve"
-              << std::endl;
-        return;
-      }
-
-    /**
-     * Eisenstat Walker method for determining the tolerance
-     */
-    if (nonlinear_iteration > 1)
-      {
-        if (!use_picard || newton_handler->parameters.use_Eisenstat_Walker_method_for_Picard_iterations)
-          {
-            const bool EisenstatWalkerChoiceOne = true;
-            parameters.linear_stokes_solver_tolerance = compute_Eisenstat_Walker_linear_tolerance(EisenstatWalkerChoiceOne,
-                                                        newton_handler->parameters.maximum_linear_stokes_solver_tolerance,
-                                                        parameters.linear_stokes_solver_tolerance,
-                                                        dcr.stokes_residuals.second,
-                                                        dcr.residual,
-                                                        dcr.residual_old);
-
-            pcout << "   The linear solver tolerance is set to "
-                  << parameters.linear_stokes_solver_tolerance
-                  << ". ";
-            if (!use_picard)
-              {
-                pcout << "Stabilization Preconditioner is "
-                      << Newton::to_string(newton_handler->parameters.preconditioner_stabilization)
-                      << " and A block is "
-                      << Newton::to_string(newton_handler->parameters.velocity_block_stabilization)
-                      << '.';
-              }
-            pcout << std::endl;
-          }
-      }
-
-    if (stokes_matrix_free)
-      stokes_matrix_free->build_preconditioner();
-    else
-      build_stokes_preconditioner();
-
-    if (newton_handler->parameters.use_Newton_failsafe == false)
-      {
-        dcr.stokes_residuals = solve_stokes();
-      }
-    else
-      {
-        try
-          {
-            dcr.stokes_residuals = solve_stokes();
-          }
-        catch (const std::exception &exc)
-          {
-            // Test that the exception we got is one of the two documented by
-            // throw_linear_solver_failure_exception(). If not, we have a genuine
-            // problem here, and will need to get outta here right away:
-            if ((dynamic_cast<const ExcMessage *>(&exc)==nullptr) &&
-                (dynamic_cast<const QuietException *>(&exc)==nullptr))
-              throw;
-
-            // start the solve over again and try with a stabilized version
-            pcout << "failed, trying again with stabilization" << std::endl;
-            newton_handler->parameters.preconditioner_stabilization = Newton::Parameters::Stabilization::SPD;
-            newton_handler->parameters.velocity_block_stabilization = Newton::Parameters::Stabilization::SPD;
-
-            // If the Stokes matrix depends on the solution, or we have active
-            // velocity boundary conditions, we need to re-assemble the system matrix
-            // (and preconditioner) every time. If we have active boundary conditions,
-            // they could a) depend on the solution, or b) be inhomogeneous. In both
-            // cases, just assembling the RHS will be incorrect.  If no active
-            // boundaries exist, we only have no-slip or free slip conditions, so we
-            // don't need to force assembly of the matrix.
-            if (stokes_matrix_depends_on_solution()
-                ||
-                (nonlinear_iteration == 0 && boundary_velocity_manager.get_active_boundary_velocity_conditions().size() > 0))
-              rebuild_stokes_matrix = rebuild_stokes_preconditioner = assemble_newton_stokes_matrix = true;
-            else if (parameters.enable_prescribed_dilation)
-              // The dilation requires the Stokes matrix (which is on the rhs
-              // in the Newton solver) to be updated.
-              rebuild_stokes_matrix = true;
-
-            assemble_stokes_system();
-
-            /**
-             * Eisenstat Walker method for determining the tolerance
-             */
-            if (nonlinear_iteration > 1)
-              {
-                dcr.residual_old = dcr.residual;
-                dcr.velocity_residual = system_rhs.block(introspection.block_indices.velocities).l2_norm();
-                dcr.pressure_residual = system_rhs.block(introspection.block_indices.pressure).l2_norm();
-                dcr.residual = std::sqrt(dcr.velocity_residual * dcr.velocity_residual + dcr.pressure_residual * dcr.pressure_residual);
-
-                if (!use_picard)
-                  {
-                    const bool EisenstatWalkerChoiceOne = true;
-                    parameters.linear_stokes_solver_tolerance = compute_Eisenstat_Walker_linear_tolerance(EisenstatWalkerChoiceOne,
-                                                                newton_handler->parameters.maximum_linear_stokes_solver_tolerance,
-                                                                parameters.linear_stokes_solver_tolerance,
-                                                                dcr.stokes_residuals.second,
-                                                                dcr.residual,
-                                                                dcr.residual_old);
-
-                    pcout << "   The linear solver tolerance is set to " << parameters.linear_stokes_solver_tolerance << std::endl;
-                  }
-              }
-
-            if (stokes_matrix_free)
-              stokes_matrix_free->build_preconditioner();
-            else
-              build_stokes_preconditioner();
-
-            // Give this another try:
-            dcr.stokes_residuals = solve_stokes();
-          }
-      }
-
-    dcr.velocity_residual = system_rhs.block(introspection.block_indices.velocities).l2_norm();
-    dcr.pressure_residual = system_rhs.block(introspection.block_indices.pressure).l2_norm();
-    dcr.residual = std::sqrt(dcr.velocity_residual * dcr.velocity_residual + dcr.pressure_residual * dcr.pressure_residual);
-
-    double test_residual = dcr.residual;
-    if (nonlinear_iteration == 0)
-      {
-        /**
-         * The first nonlinear iteration we are computing the whole system in a non-defect corrected Picard way,
-         * to make sure that the boundary conditions are correct in combination with correct initial guesses.
-         */
-        current_linearization_point.block(introspection.block_indices.velocities) = solution.block(introspection.block_indices.velocities);
-        current_linearization_point.block(introspection.block_indices.pressure) = solution.block(introspection.block_indices.pressure);
-
-        dcr.residual = dcr.stokes_residuals.first;
-
-        pcout << "      Newton system information: Norm of the rhs: " << dcr.stokes_residuals.first << std::endl;
-      }
-    else
-      {
-        /**
-         * We may need to do a line search if the solution update doesn't decrease the norm of the rhs enough.
-         * This is done by adding the solution update to the current linearization point and then assembling
-         * the Newton right hand side. If the Newton residual has decreased enough by using this update,
-         * then we continue, otherwise we reset the current linearization point with the help of the backup and
-         * add each iteration an increasingly smaller solution update until the decreasing residual condition
-         * is met, or the line search iteration limit is reached.
-         */
-        LinearAlgebra::BlockVector backup_linearization_point(introspection.index_sets.stokes_partitioning, mpi_communicator);
-        backup_linearization_point.block(introspection.block_indices.pressure) = current_linearization_point.block(introspection.block_indices.pressure);
-        backup_linearization_point.block(introspection.block_indices.velocities) = current_linearization_point.block(introspection.block_indices.velocities);
-
-
-        double test_velocity_residual = 0;
-        double test_pressure_residual = 0;
-        double step_length_factor = 1;
-        double alpha = 1e-4;
-        unsigned int line_search_iteration = 0;
-
-
-        /**
-         * Do the loop for the line search. Even when we
-         * don't do a line search we go into this loop
-         */
-        do
-          {
-            // Reset the current linearization point and the search direction
-            current_linearization_point.block(introspection.block_indices.pressure) = backup_linearization_point.block(introspection.block_indices.pressure);
-            current_linearization_point.block(introspection.block_indices.velocities) = backup_linearization_point.block(introspection.block_indices.velocities);
-
-            LinearAlgebra::BlockVector search_direction = solution;
-            search_direction *= step_length_factor;
-
-            current_linearization_point.block(introspection.block_indices.pressure) += search_direction.block(introspection.block_indices.pressure);
-            current_linearization_point.block(introspection.block_indices.velocities) += search_direction.block(introspection.block_indices.velocities);
-
-            // Rebuild the rhs to determine the new residual.
-            assemble_newton_stokes_matrix = rebuild_stokes_preconditioner = false;
-            rebuild_stokes_matrix = (boundary_velocity_manager.get_active_boundary_velocity_conditions().empty()
-                                     == false);
-
-            assemble_stokes_system();
-
-            test_velocity_residual = system_rhs.block(introspection.block_indices.velocities).l2_norm();
-            test_pressure_residual = system_rhs.block(introspection.block_indices.pressure).l2_norm();
-            test_residual = std::sqrt(test_velocity_residual * test_velocity_residual
-                                      + test_pressure_residual * test_pressure_residual);
-
-            // Determine if the decrease is sufficient.
-            if (test_residual < (1.0 - alpha * step_length_factor) * dcr.residual
-                ||
-                line_search_iteration >= newton_handler->parameters.max_newton_line_search_iterations
-                ||
-                use_picard)
-              {
-                pcout << "      Newton system information: Norm of the rhs: " << test_residual
-                      << ", Derivative scaling factor: " << newton_handler->parameters.newton_derivative_scaling_factor << std::endl;
-                dcr.residual = test_residual;
-                break;
-              }
-            else
-              {
-
-                pcout << "   Line search iteration " << line_search_iteration << ", with norm of the rhs "
-                      << test_residual << " and going to " << (1.0 - alpha * step_length_factor) * dcr.residual
-                      << ", relative residual: " << test_residual/dcr.initial_residual << std::endl;
-
-                /**
-                 * The line search step was not sufficient to decrease the residual
-                 * enough, so we take a smaller step to see if it improves the residual.
-                 */
-                step_length_factor *= (2.0/3.0);// TODO: make a parameter out of this.
-              }
-
-            ++line_search_iteration;
-            Assert(line_search_iteration <= newton_handler->parameters.max_newton_line_search_iterations,
-                   ExcMessage ("This tests the while condition. This condition should "
-                               "actually never be false, because the break statement "
-                               "above should have caught it."));
-          }
-        while (true);
-      }
-
-
-    if (use_picard == true)
-      {
-        // When we are using (defect corrected) Picard, keep the
-        // newton_derivative_scaling_factor at zero. The newton_derivative_scaling_factor
-        // is calculated above as std::max(0.0, (1.0-(
-        // newton_residual_for_derivative_scaling_factor/switch_initial_residual)))
-        dcr.switch_initial_residual = dcr.residual;
-        dcr.newton_residual_for_derivative_scaling_factor = dcr.residual;
-      }
-    else
-      {
-        /**
-         * This method allows to slowly introduce the derivatives based
-         * on the improvement of the residual. This method was suggested
-         * by Raid Hassani.
-         */
-        if (newton_handler->parameters.use_newton_residual_scaling_method)
-          dcr.newton_residual_for_derivative_scaling_factor = test_residual;
-        else
-          dcr.newton_residual_for_derivative_scaling_factor = 0;
-      }
-
-    dcr.residual_old = dcr.residual;
-
-    if (nonlinear_iteration != 0)
-      last_pressure_normalization_adjustment = normalize_pressure(current_linearization_point);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_single_advection_single_stokes ()
-  {
-    assemble_and_solve_temperature();
-    assemble_and_solve_composition();
-    assemble_and_solve_stokes();
-
-    if (parameters.run_postprocessors_on_nonlinear_iterations)
-      postprocess ();
-
-    // Setup a nonlinear solver control that only allows a single iteration
-    SolverControl nonlinear_solver_control(1,1.0);
-    // Announce that we did a single iteration, and assume we have converged
-    nonlinear_solver_control.check(1,0.0);
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_no_advection_iterated_stokes ()
-  {
-    double initial_stokes_residual = 0.0;
-
-    const unsigned int max_nonlinear_iterations =
-      (pre_refinement_step < parameters.initial_adaptive_refinement)
-      ?
-      std::min(parameters.max_nonlinear_iterations,
-               parameters.max_nonlinear_iterations_in_prerefinement)
-      :
-      parameters.max_nonlinear_iterations;
-
-    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
-                                           parameters.nonlinear_tolerance);
-
-    double relative_residual = std::numeric_limits<double>::max();
-    nonlinear_iteration = 0;
-    do
-      {
-        relative_residual =
-          assemble_and_solve_stokes(initial_stokes_residual,
-                                    nonlinear_iteration == 0 ? &initial_stokes_residual : nullptr);
-
-        pcout << "      Relative nonlinear residual (Stokes system) after nonlinear iteration " << nonlinear_iteration+1
-              << ": " << relative_residual
-              << std::endl
-              << std::endl;
-
-        if (parameters.run_postprocessors_on_nonlinear_iterations)
-          postprocess ();
-
-        ++nonlinear_iteration;
-      }
-    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
-
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_no_advection_iterated_defect_correction_stokes ()
-  {
-    // Now store the linear_tolerance we started out with, because we might change
-    // it within this timestep.
-    const double begin_linear_tolerance = parameters.linear_stokes_solver_tolerance;
-
-    DefectCorrectionResiduals dcr;
-    dcr.initial_residual = 1;
-
-    dcr.velocity_residual = 0;
-    dcr.pressure_residual = 0;
-    dcr.residual = 1;
-    dcr.residual_old = 1;
-
-    dcr.switch_initial_residual = 1;
-    dcr.newton_residual_for_derivative_scaling_factor = 1;
-
-    const unsigned int max_nonlinear_iterations =
-      (pre_refinement_step < parameters.initial_adaptive_refinement)
-      ?
-      std::min(parameters.max_nonlinear_iterations,
-               parameters.max_nonlinear_iterations_in_prerefinement)
-      :
-      parameters.max_nonlinear_iterations;
-
-    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
-                                           parameters.nonlinear_tolerance);
-
-    // Now iterate out the nonlinearities.
-    dcr.stokes_residuals = std::pair<double,double>  (numbers::signaling_nan<double>(),
-                                                      numbers::signaling_nan<double>());
-
-    double relative_residual = std::numeric_limits<double>::max();
-    nonlinear_iteration = 0;
-    do
-      {
-        do_one_defect_correction_Stokes_step(dcr, /* use_picard= */true);
-
-        relative_residual = dcr.residual/dcr.initial_residual;
-
-        pcout << "      Relative nonlinear residual (Stokes system) after nonlinear iteration " << nonlinear_iteration+1
-              << ": " << relative_residual
-              << std::endl
-              << std::endl;
-
-        if (parameters.run_postprocessors_on_nonlinear_iterations)
-          {
-            // Before postprocessing, we need to copy the actual solution into the solution vector
-            // (which is used for postprocessing)
-            solution = current_linearization_point;
-            postprocess ();
-          }
-
-        ++nonlinear_iteration;
-      }
-    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
-
-    // Reset the linear tolerance to what it was at the beginning of the time step.
-    parameters.linear_stokes_solver_tolerance = begin_linear_tolerance;
-
-    // When we are finished iterating, we need to set the final solution to the current linearization point,
-    // because the solution vector is used in the postprocess.
-    solution = current_linearization_point;
-
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_single_advection_iterated_defect_correction_stokes ()
-  {
-    // The defect correction solver is just the Newton solver without derivatives.
-    solve_single_advection_and_iterated_newton_stokes(/*use_newton_iterations = */ false);
-  }
-
-  template <int dim>
-  void Simulator<dim>::solve_iterated_advection_and_defect_correction_stokes ()
-  {
-    // The defect correction solver is just the Newton solver without derivatives.
-    solve_iterated_advection_and_newton_stokes(/*use_newton_iterations = */ false);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_no_advection_single_stokes ()
-  {
-    assemble_and_solve_stokes();
-
-    if (parameters.run_postprocessors_on_nonlinear_iterations)
-      postprocess ();
-
-    // Setup a nonlinear solver control that only allows a single iteration
-    SolverControl nonlinear_solver_control(1,1.0);
-    // Announce that we did a single iteration, and assume we have converged
-    nonlinear_solver_control.check(1,0.0);
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-  template <int dim>
-  void Simulator<dim>::solve_first_timestep_only_single_stokes ()
-  {
-    if (timestep_number == 0)
-      assemble_and_solve_stokes();
-
-    // Setup a nonlinear solver control that only allows a single iteration
-    SolverControl nonlinear_solver_control(1,1.0);
-    // Announce that we did a single iteration, and assume we have converged
-    nonlinear_solver_control.check(1,0.0);
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_iterated_advection_and_stokes ()
-  {
-    double initial_temperature_residual = 0;
-    double initial_stokes_residual      = 0;
-    std::vector<double> initial_composition_residual (introspection.n_compositional_fields,0);
-
-    const unsigned int max_nonlinear_iterations =
-      (pre_refinement_step < parameters.initial_adaptive_refinement)
-      ?
-      std::min(parameters.max_nonlinear_iterations,
-               parameters.max_nonlinear_iterations_in_prerefinement)
-      :
-      parameters.max_nonlinear_iterations;
-
-    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
-                                           parameters.nonlinear_tolerance);
-
-    double relative_residual = std::numeric_limits<double>::max();
-    nonlinear_iteration = 0;
-
-    do
-      {
-        // Restore particles through stored copy of particle handler,
-        // but only if they have already been displaced in a nonlinear
-        // iteration (in the assemble_and_solve_composition call).
-
-        if (nonlinear_iteration > 0)
-          for (auto &particle_world : particle_worlds)
-            particle_world->restore_particles();
-
-        const double relative_temperature_residual =
-          assemble_and_solve_temperature(initial_temperature_residual,
-                                         nonlinear_iteration == 0 ? &initial_temperature_residual : nullptr);
-
-        const std::vector<double>  relative_composition_residual =
-          assemble_and_solve_composition(initial_composition_residual,
-                                         nonlinear_iteration == 0 ? &initial_composition_residual : nullptr);
-
-        const double relative_nonlinear_stokes_residual =
-          assemble_and_solve_stokes(initial_stokes_residual,
-                                    nonlinear_iteration == 0 ? &initial_stokes_residual : nullptr);
-
-        // write the residual output in the same order as the solutions
-        pcout << "      Relative nonlinear residuals (temperature"
-              << (introspection.n_compositional_fields > 0 ? ", compositional fields" : "")
-              << ", Stokes system): " << relative_temperature_residual;
-        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-          pcout << ", " << relative_composition_residual[c];
-        pcout << ", " << relative_nonlinear_stokes_residual;
-        pcout << std::endl;
-
-        // Find the maximum residual of the individual equations
-        relative_residual = relative_temperature_residual;
-        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-          {
-            // in models with melt migration the melt advection equation includes the divergence of the velocity
-            // and can not be expected to converge to a smaller value than the residual of the Stokes equation.
-            // thus, we set a threshold for the initial composition residual.
-            // this only plays a role if the right-hand side of the advection equation is very small.
-            const double threshold = (parameters.include_melt_transport && c == introspection.compositional_index_for_name("porosity")
-                                      ?
-                                      parameters.linear_stokes_solver_tolerance * time_step
-                                      :
-                                      0.0);
-            if (initial_composition_residual[c]>threshold)
-              relative_residual = std::max(relative_composition_residual[c],relative_residual);
-          }
-        relative_residual = std::max(relative_nonlinear_stokes_residual, relative_residual);
-
-        pcout << "      Relative nonlinear residual (total system) after nonlinear iteration " << nonlinear_iteration+1
-              << ": " << relative_residual
-              << std::endl
-              << std::endl;
-
-        if (parameters.run_postprocessors_on_nonlinear_iterations)
-          postprocess ();
-
-        ++nonlinear_iteration;
-      }
-    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
-
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_single_advection_iterated_stokes ()
-  {
-    // solve the temperature and composition systems once...
-    assemble_and_solve_temperature();
-
-    assemble_and_solve_composition();
-
-    // ...and then iterate the solution of the Stokes system
-    double initial_stokes_residual = 0;
-
-    const unsigned int max_nonlinear_iterations =
-      (pre_refinement_step < parameters.initial_adaptive_refinement)
-      ?
-      std::min(parameters.max_nonlinear_iterations,
-               parameters.max_nonlinear_iterations_in_prerefinement)
-      :
-      parameters.max_nonlinear_iterations;
-
-    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
-                                           parameters.nonlinear_tolerance);
-
-    double relative_residual = std::numeric_limits<double>::max();
-    nonlinear_iteration = 0;
-    do
-      {
-        relative_residual =
-          assemble_and_solve_stokes(initial_stokes_residual,
-                                    nonlinear_iteration == 0 ? &initial_stokes_residual : nullptr);
-
-        pcout << "      Relative nonlinear residual (Stokes system) after nonlinear iteration " << nonlinear_iteration+1
-              << ": " << relative_residual
-              << std::endl
-              << std::endl;
-
-        if (parameters.run_postprocessors_on_nonlinear_iterations)
-          postprocess ();
-
-        ++nonlinear_iteration;
-      }
-    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
-
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_iterated_advection_and_newton_stokes (bool use_newton_iterations)
-  {
-    // Now store the linear_tolerance we started out with, because we might change
-    // it within this timestep.
-    const double begin_linear_tolerance = parameters.linear_stokes_solver_tolerance;
-    double initial_temperature_residual = 0;
-    std::vector<double> initial_composition_residual (parameters.n_compositional_fields,0);
-
-    DefectCorrectionResiduals dcr;
-    dcr.initial_residual = 1;
-
-    dcr.velocity_residual = 0;
-    dcr.pressure_residual = 0;
-    dcr.residual = 1;
-    dcr.residual_old = 1;
-
-    dcr.switch_initial_residual = 1;
-    dcr.newton_residual_for_derivative_scaling_factor = 1;
-
-    bool use_picard = true;
-
-    const Newton::Parameters::Stabilization starting_preconditioner_stabilization = newton_handler->parameters.preconditioner_stabilization;
-    const Newton::Parameters::Stabilization starting_velocity_block_stabilization = newton_handler->parameters.velocity_block_stabilization;
-
-    const unsigned int max_nonlinear_iterations =
-      (pre_refinement_step < parameters.initial_adaptive_refinement)
-      ?
-      std::min(parameters.max_nonlinear_iterations,
-               parameters.max_nonlinear_iterations_in_prerefinement)
-      :
-      parameters.max_nonlinear_iterations;
-
-    // Now iterate out the nonlinearities.
-    dcr.stokes_residuals = std::pair<double,double>  (numbers::signaling_nan<double>(),
-                                                      numbers::signaling_nan<double>());
-
-    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
-                                           parameters.nonlinear_tolerance);
-
-    SolverControl nonlinear_solver_control_picard(newton_handler->parameters.max_pre_newton_nonlinear_iterations,
-                                                  newton_handler->parameters.nonlinear_switch_tolerance);
-
-    double relative_residual = std::numeric_limits<double>::max();
-    nonlinear_iteration = 0;
-
-    do
-      {
-        // Restore particles through stored copy of particle handler,
-        // but only if they have already been displaced in a nonlinear
-        // iteration (in the assemble_and_solve_composition call).
-
-        if (nonlinear_iteration > 0)
-          for (auto &particle_world : particle_worlds)
-            particle_world->restore_particles();
-
-        const double relative_temperature_residual =
-          assemble_and_solve_temperature(initial_temperature_residual,
-                                         nonlinear_iteration == 0 ? &initial_temperature_residual : nullptr);
-
-        const std::vector<double>  relative_composition_residual =
-          assemble_and_solve_composition(initial_composition_residual,
-                                         nonlinear_iteration == 0 ? &initial_composition_residual : nullptr);
-
-        if (use_newton_iterations && use_picard &&
-            nonlinear_solver_control_picard.check(nonlinear_iteration, relative_residual) != SolverControl::iterate)
-          {
-            use_picard = false;
-            pcout << "   Switching from defect correction form of Picard to the Newton solver scheme." << std::endl;
-
-            /**
-             * This method allows to slowly introduce the derivatives based
-             * on the improvement of the residual. If we do not use it, we
-             * just set it so the newton_derivative_scaling_factor goes from
-             * zero to one when switching on the Newton solver.
-             */
-            if (!newton_handler->parameters.use_newton_residual_scaling_method)
-              dcr.newton_residual_for_derivative_scaling_factor = 0;
-          }
-
-        newton_handler->parameters.newton_derivative_scaling_factor
-          = (std::max(0.0,
-                      (1.0-(dcr.newton_residual_for_derivative_scaling_factor/dcr.switch_initial_residual))));
-
-        do_one_defect_correction_Stokes_step(dcr, use_picard);
-
-        double max_residual = relative_temperature_residual;
-        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-          {
-            // in models with melt migration the melt advection equation includes the divergence of the velocity
-            // and can not be expected to converge to a smaller value than the residual of the Stokes equation.
-            // thus, we set a threshold for the initial composition residual.
-            // this only plays a role if the right-hand side of the advection equation is very small.
-            const double threshold = (parameters.include_melt_transport && c == introspection.compositional_index_for_name("porosity")
-                                      ?
-                                      parameters.linear_stokes_solver_tolerance * time_step
-                                      :
-                                      0.0);
-            if (initial_composition_residual[c]>threshold)
-              max_residual = std::max(relative_composition_residual[c],max_residual);
-          }
-
-        // write the residual output in the same order as the solutions
-        pcout << "      Relative nonlinear residuals (temperature"
-              << (introspection.n_compositional_fields > 0 ? ", compositional fields" : "")
-              << ", Stokes system): " << relative_temperature_residual;
-        for (unsigned int c=0; c<introspection.n_compositional_fields; ++c)
-          pcout << ", " << relative_composition_residual[c];
-        pcout << ", " << dcr.residual/dcr.initial_residual << std::endl;
-
-        relative_residual = std::max(dcr.residual/dcr.initial_residual, max_residual);
-        pcout << "      Relative nonlinear residual (total system) after nonlinear iteration " << nonlinear_iteration+1
-              << ": " << relative_residual
-              << std::endl
-              << std::endl;
-
-        if (parameters.run_postprocessors_on_nonlinear_iterations)
-          {
-            // Before postprocessing, we need to copy the actual solution into the solution vector
-            // (which is used for postprocessing)
-            solution = current_linearization_point;
-            postprocess ();
-          }
-
-        ++nonlinear_iteration;
-      }
-    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
-
-    // Reset the Newton stabilization at the end of the timestep.
-    newton_handler->parameters.preconditioner_stabilization = starting_preconditioner_stabilization;
-    newton_handler->parameters.velocity_block_stabilization = starting_velocity_block_stabilization;
-
-    // Reset the linear tolerance to what it was at the beginning of the time step.
-    parameters.linear_stokes_solver_tolerance = begin_linear_tolerance;
-
-    // When we are finished iterating, we need to set the final solution to the current linearization point,
-    // because the solution vector is used in the postprocess.
-    solution = current_linearization_point;
-
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-
-  template <int dim>
-  void Simulator<dim>::solve_single_advection_and_iterated_newton_stokes (bool use_newton_iterations)
-  {
-    // First assemble and solve the temperature and compositional fields
-    assemble_and_solve_temperature();
-    assemble_and_solve_composition();
-
-    // Now store the linear_tolerance we started out with, because we might change
-    // it within this timestep.
-    double begin_linear_tolerance = parameters.linear_stokes_solver_tolerance;
-
-    std::vector<double> initial_composition_residual (parameters.n_compositional_fields,0);
-
-    DefectCorrectionResiduals dcr;
-    dcr.initial_residual = 1;
-
-    dcr.velocity_residual = 0;
-    dcr.pressure_residual = 0;
-    dcr.residual = 1;
-    dcr.residual_old = 1;
-
-    dcr.switch_initial_residual = 1;
-    dcr.newton_residual_for_derivative_scaling_factor = 1;
-
-    bool use_picard = true;
-
-    const Newton::Parameters::Stabilization starting_preconditioner_stabilization = newton_handler->parameters.preconditioner_stabilization;
-    const Newton::Parameters::Stabilization starting_velocity_block_stabilization = newton_handler->parameters.velocity_block_stabilization;
-
-    const unsigned int max_nonlinear_iterations =
-      (pre_refinement_step < parameters.initial_adaptive_refinement)
-      ?
-      std::min(parameters.max_nonlinear_iterations,
-               parameters.max_nonlinear_iterations_in_prerefinement)
-      :
-      parameters.max_nonlinear_iterations;
-
-    SolverControl nonlinear_solver_control(max_nonlinear_iterations,
-                                           parameters.nonlinear_tolerance);
-
-    SolverControl nonlinear_solver_control_picard(newton_handler->parameters.max_pre_newton_nonlinear_iterations,
-                                                  newton_handler->parameters.nonlinear_switch_tolerance);
-
-    // Now iterate out the nonlinearities.
-    dcr.stokes_residuals = {numbers::signaling_nan<double>(), numbers::signaling_nan<double>()};
-
-    double relative_residual = std::numeric_limits<double>::max();
-    nonlinear_iteration = 0;
-    do
-      {
-        // If we are in the Picard phase, check if we can switch to Newton
-        if (use_newton_iterations && use_picard &&
-            nonlinear_solver_control_picard.check(nonlinear_iteration, relative_residual) != SolverControl::iterate)
-          {
-            use_picard = false;
-            pcout << "   Switching from defect correction form of Picard to the Newton solver scheme." << std::endl;
-
-            /**
-             * This method allows to slowly introduce the derivatives based
-             * on the improvement of the residual. If we do not use it, we
-             * just set it so the newton_derivative_scaling_factor goes from
-             * zero to one when switching on the Newton solver.
-             */
-            if (!newton_handler->parameters.use_newton_residual_scaling_method)
-              dcr.newton_residual_for_derivative_scaling_factor = 0;
-          }
-
-        newton_handler->parameters.newton_derivative_scaling_factor
-          = (std::max(0.0,
-                      (1.0-(dcr.newton_residual_for_derivative_scaling_factor/dcr.switch_initial_residual))));
-
-        do_one_defect_correction_Stokes_step(dcr, use_picard);
-
-        relative_residual = dcr.residual/dcr.initial_residual;
-
-        pcout << "      Relative nonlinear residual (Stokes system) after nonlinear iteration " << nonlinear_iteration+1
-              << ": " << relative_residual
-              << std::endl
-              << std::endl;
-
-        if (parameters.run_postprocessors_on_nonlinear_iterations)
-          {
-            // Before postprocessing, we need to copy the actual solution into the solution vector
-            // (which is used for postprocessing)
-            solution = current_linearization_point;
-            postprocess ();
-          }
-
-        ++nonlinear_iteration;
-      }
-    while (nonlinear_solver_control.check(nonlinear_iteration, relative_residual) == SolverControl::iterate);
-
-    // Reset the Newton stabilization at the end of the timestep.
-    newton_handler->parameters.preconditioner_stabilization = starting_preconditioner_stabilization;
-    newton_handler->parameters.velocity_block_stabilization = starting_velocity_block_stabilization;
-
-    // Reset the linear tolerance to what it was at the beginning of the time step.
-    parameters.linear_stokes_solver_tolerance = begin_linear_tolerance;
-
-    // When we are finished iterating, we need to set the final solution to the current linearization point,
-    // because the solution vector is used in the postprocess.
-    solution = current_linearization_point;
-
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_single_advection_no_stokes ()
-  {
-    assemble_and_solve_temperature();
-    assemble_and_solve_composition();
-
-    {
-      TimerOutput::Scope timer (computing_timer, "Interpolate Stokes solution");
-
-      // Assign Stokes solution
-      LinearAlgebra::BlockVector distributed_stokes_solution (introspection.index_sets.system_partitioning, mpi_communicator);
-
-      VectorFunctionFromVectorFunctionObject<dim> func(
-        [&](const Point<dim> &p, Vector<double> &result)
-      {
-        prescribed_stokes_solution->stokes_solution(p, result);
-      },
-      0,
-      parameters.include_melt_transport ? 2*dim+3 : dim+1, // velocity and pressure
-      introspection.n_components);
-
-      VectorTools::interpolate (*mapping, dof_handler, func, distributed_stokes_solution);
-
-      // distribute hanging node and other constraints
-      current_constraints.distribute (distributed_stokes_solution);
-
-      solution.block(introspection.block_indices.velocities) =
-        distributed_stokes_solution.block(introspection.block_indices.velocities);
-      solution.block(introspection.block_indices.pressure) =
-        distributed_stokes_solution.block(introspection.block_indices.pressure);
-
-      if (parameters.include_melt_transport)
-        {
-          const unsigned int block_u_f = introspection.variable("fluid velocity").block_index;
-          const unsigned int block_p_f = introspection.variable("fluid pressure").block_index;
-          solution.block(block_u_f) = distributed_stokes_solution.block(block_u_f);
-          solution.block(block_p_f) = distributed_stokes_solution.block(block_p_f);
-        }
-
-    }
-
-    if (parameters.run_postprocessors_on_nonlinear_iterations)
-      postprocess ();
-
-    // Setup a nonlinear solver control that only allows a single iteration
-    SolverControl nonlinear_solver_control(1,1.0);
-    // Announce that we did a single iteration, and assume we have converged
-    nonlinear_solver_control.check(1,0.0);
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-
-
-
-  template <int dim>
-  void Simulator<dim>::solve_no_advection_no_stokes ()
-  {
-    if (parameters.run_postprocessors_on_nonlinear_iterations)
-      postprocess ();
-
-    // Setup a nonlinear solver control that only allows a single iteration
-    SolverControl nonlinear_solver_control(1,1.0);
-    // Announce that we did a single iteration, and assume we have converged
-    nonlinear_solver_control.check(1,0.0);
-    signals.post_nonlinear_solver(nonlinear_solver_control);
-  }
-}
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template double Simulator<dim>::assemble_and_solve_temperature(const double &, double*); \
-  template std::vector<double> Simulator<dim>::assemble_and_solve_composition(const std::vector<double> &, std::vector<double> *); \
-  template double Simulator<dim>::assemble_and_solve_stokes(const double &, double*); \
-  template void Simulator<dim>::solve_single_advection_single_stokes(); \
-  template void Simulator<dim>::solve_no_advection_iterated_stokes(); \
-  template void Simulator<dim>::solve_no_advection_single_stokes(); \
-  template void Simulator<dim>::solve_iterated_advection_and_stokes(); \
-  template void Simulator<dim>::solve_single_advection_iterated_stokes(); \
-  template void Simulator<dim>::solve_no_advection_iterated_defect_correction_stokes(); \
-  template void Simulator<dim>::solve_single_advection_iterated_defect_correction_stokes(); \
-  template void Simulator<dim>::solve_iterated_advection_and_defect_correction_stokes(); \
-  template void Simulator<dim>::solve_iterated_advection_and_newton_stokes(bool); \
-  template void Simulator<dim>::solve_single_advection_and_iterated_newton_stokes(bool); \
-  template void Simulator<dim>::solve_single_advection_no_stokes(); \
-  template void Simulator<dim>::solve_first_timestep_only_single_stokes(); \
-  template void Simulator<dim>::solve_no_advection_no_stokes();
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/simulator/stokes_matrix_free.cc.bak b/source/simulator/stokes_matrix_free.cc.bak
deleted file mode 100644
index 646e3d8437b..00000000000
--- a/source/simulator/stokes_matrix_free.cc.bak
+++ /dev/null
@@ -1,2798 +0,0 @@
-/*
-  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/stokes_matrix_free.h>
-#include <aspect/citation_info.h>
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/mesh_deformation/free_surface.h>
-#include <aspect/melt.h>
-#include <aspect/newton.h>
-
-#include <deal.II/base/signaling_nan.h>
-
-#include <deal.II/dofs/dof_renumbering.h>
-#include <deal.II/dofs/dof_accessor.h>
-#include <deal.II/dofs/dof_tools.h>
-
-#include <deal.II/numerics/vector_tools.h>
-
-#include <deal.II/fe/fe_q.h>
-#include <deal.II/fe/fe_dgq.h>
-#include <deal.II/fe/fe_values.h>
-
-#include <deal.II/lac/solver_gmres.h>
-#include <deal.II/lac/read_write_vector.templates.h>
-#include <deal.II/lac/solver_idr.h>
-#include <deal.II/lac/solver_cg.h>
-#include <deal.II/lac/solver_bicgstab.h>
-
-#include <deal.II/grid/manifold.h>
-
-#include <deal.II/matrix_free/tools.h>
-
-namespace aspect
-{
-  namespace internal
-  {
-    /**
-     * Matrix-free operators must use deal.II defined vectors, while the rest of the ASPECT
-     * software is based on Trilinos vectors. Here we define functions which copy between the
-     * vector types.
-     */
-    namespace ChangeVectorTypes
-    {
-      void copy(TrilinosWrappers::MPI::Vector &out,
-                const dealii::LinearAlgebra::distributed::Vector<double> &in)
-      {
-        dealii::LinearAlgebra::ReadWriteVector<double> rwv(out.locally_owned_elements());
-        rwv.import_elements(in, VectorOperation::insert);
-        out.import_elements(rwv,VectorOperation::insert);
-      }
-
-      void copy(dealii::LinearAlgebra::distributed::Vector<double> &out,
-                const TrilinosWrappers::MPI::Vector &in)
-      {
-        dealii::LinearAlgebra::ReadWriteVector<double> rwv;
-        rwv.reinit(in);
-        out.import(rwv, VectorOperation::insert);
-      }
-
-      void copy(TrilinosWrappers::MPI::BlockVector &out,
-                const dealii::LinearAlgebra::distributed::BlockVector<double> &in)
-      {
-        const unsigned int n_blocks = in.n_blocks();
-        for (unsigned int b=0; b<n_blocks; ++b)
-          copy(out.block(b),in.block(b));
-      }
-
-      void copy(dealii::LinearAlgebra::distributed::BlockVector<double> &out,
-                const TrilinosWrappers::MPI::BlockVector &in)
-      {
-        const unsigned int n_blocks = in.n_blocks();
-        for (unsigned int b=0; b<n_blocks; ++b)
-          copy(out.block(b),in.block(b));
-      }
-    }
-
-
-    /**
-     * Implement the block Schur preconditioner for the Stokes system.
-     */
-    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
-              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
-    class BlockSchurGMGPreconditioner : public Subscriptor
-    {
-      public:
-        /**
-         * @brief Constructor
-         *
-         * @param Stokes_matrix The entire Stokes matrix
-         * @param A_block The A block of the Stokes matrix
-         * @param Schur_complement_block The matrix which describes the Schur complement approximation
-         * @param A_block_preconditioner Preconditioner object for the matrix A.
-         * @param Schur_complement_preconditioner Preconditioner object for the Schur complement.
-         * @param do_solve_A A flag indicating whether we should actually solve with
-         *     the matrix $A_block$, or only apply one preconditioner step with it.
-         * @param do_solve_Schur_complement A flag indicating whether we should actually solve with
-         *     the matrix $Schur_complement_block$, or only apply one preconditioner step with it.
-         * @param A_block_is_symmetric A flag indicating whether the A block is symmetric.
-         * @param A_block_tolerance The tolerance for the CG solver which computes
-         *     the inverse of the A block.
-         * @param Schur_complement_tolerance The tolerance for the CG solver which computes
-         *     the inverse of the Schur complement block (Schur complement approximation matrix).
-         */
-        BlockSchurGMGPreconditioner (const StokesMatrixType                  &Stokes_matrix,
-                                     const ABlockMatrixType                  &A_block,
-                                     const SchurComplementMatrixType         &Schur_complement_block,
-                                     const ABlockPreconditionerType          &A_block_preconditioner,
-                                     const SchurComplementPreconditionerType &Schur_complement_preconditioner,
-                                     const bool                               do_solve_A,
-                                     const bool                               do_solve_Schur_complement,
-                                     const bool                               A_block_is_symmetric,
-                                     const double                             A_block_tolerance,
-                                     const double                             Schur_complement_tolerance);
-
-        /**
-         * Matrix vector product with this preconditioner object.
-         */
-        void vmult (dealii::LinearAlgebra::distributed::BlockVector<double>       &dst,
-                    const dealii::LinearAlgebra::distributed::BlockVector<double> &src) const;
-
-        unsigned int n_iterations_A_block() const;
-        unsigned int n_iterations_Schur_complement() const;
-
-
-      private:
-        /**
-         * References to the various matrix object this preconditioner works on.
-         */
-        const StokesMatrixType                  &stokes_matrix;
-        const ABlockMatrixType                  &A_block;
-        const SchurComplementMatrixType         &Schur_complement_block;
-        const ABlockPreconditionerType          &A_block_preconditioner;
-        const SchurComplementPreconditionerType &Schur_complement_preconditioner;
-
-        /**
-         * Whether to actually invert the $\tilde M$ or $\tilde A$ of the preconditioner matrix
-         * or to just apply a single preconditioner step with it.
-         */
-        const bool                                                      do_solve_A;
-        const bool                                                      do_solve_Schur_complement;
-        const bool                                                      A_block_is_symmetric;
-        mutable unsigned int                                            n_iterations_A_;
-        mutable unsigned int                                            n_iterations_Schur_complement_;
-        const double                                                    A_block_tolerance;
-        const double                                                    Schur_complement_tolerance;
-        mutable dealii::LinearAlgebra::distributed::BlockVector<double> utmp;
-    };
-
-    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
-              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
-    BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType,
-                                ABlockPreconditionerType, SchurComplementPreconditionerType>::
-                                BlockSchurGMGPreconditioner (const StokesMatrixType                  &Stokes_matrix,
-                                                             const ABlockMatrixType                  &A_block,
-                                                             const SchurComplementMatrixType         &Schur_complement_block,
-                                                             const ABlockPreconditionerType          &A_block_preconditioner,
-                                                             const SchurComplementPreconditionerType &Schur_complement_preconditioner,
-                                                             const bool                               do_solve_A,
-                                                             const bool                               do_solve_Schur_complement,
-                                                             const bool                               A_block_symmetric,
-                                                             const double                             A_block_tolerance,
-                                                             const double                             Schur_complement_tolerance)
-                                  :
-                                  stokes_matrix                   (Stokes_matrix),
-                                  A_block                         (A_block),
-                                  Schur_complement_block          (Schur_complement_block),
-                                  A_block_preconditioner          (A_block_preconditioner),
-                                  Schur_complement_preconditioner (Schur_complement_preconditioner),
-                                  do_solve_A                      (do_solve_A),
-                                  do_solve_Schur_complement       (do_solve_Schur_complement),
-                                  A_block_is_symmetric            (A_block_symmetric),
-                                  n_iterations_A_                 (0),
-                                  n_iterations_Schur_complement_  (0),
-                                  A_block_tolerance               (A_block_tolerance),
-                                  Schur_complement_tolerance      (Schur_complement_tolerance)
-    {}
-
-    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
-              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
-    unsigned int
-    BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType,
-                                ABlockPreconditionerType, SchurComplementPreconditionerType>::
-                                n_iterations_A_block() const
-    {
-      return n_iterations_A_;
-    }
-
-    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
-              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
-    unsigned int
-    BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType,
-                                ABlockPreconditionerType, SchurComplementPreconditionerType>::
-                                n_iterations_Schur_complement() const
-    {
-      return n_iterations_Schur_complement_;
-    }
-
-    template <class StokesMatrixType, class ABlockMatrixType, class SchurComplementMatrixType,
-              class ABlockPreconditionerType, class SchurComplementPreconditionerType>
-    void
-    BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType,
-                                ABlockPreconditionerType, SchurComplementPreconditionerType>::
-                                vmult (dealii::LinearAlgebra::distributed::BlockVector<double>       &dst,
-                                       const dealii::LinearAlgebra::distributed::BlockVector<double>  &src) const
-    {
-      if (utmp.size()==0)
-        utmp.reinit(src);
-
-      // This needs to be done explicitly, as GMRES does not
-      // initialize the data of the vector dst before calling
-      // us. Otherwise we might use random data as our initial guess.
-      dst = 0.0;
-
-      // either solve with the Schur complement matrix (if do_solve_Schur_complement==true)
-      // or just apply one preconditioner sweep (for the first few
-      // iterations of our two-stage outer GMRES iteration)
-      if (do_solve_Schur_complement)
-        {
-          // first solve with the bottom right block, which we have built
-          // as a mass matrix with the inverse of the viscosity
-          SolverControl solver_control(100, src.block(1).l2_norm() * Schur_complement_tolerance,true);
-
-          SolverCG<dealii::LinearAlgebra::distributed::Vector<double>> solver(solver_control);
-          // Trilinos reports a breakdown
-          // in case src=dst=0, even
-          // though it should return
-          // convergence without
-          // iterating. We simply skip
-          // solving in this case.
-          if (src.block(1).l2_norm() > 1e-50)
-            {
-              try
-                {
-                  solver.solve(Schur_complement_block,
-                               dst.block(1), src.block(1),
-                               Schur_complement_preconditioner);
-                  n_iterations_Schur_complement_ += solver_control.last_step();
-                }
-              // if the solver fails, report the error from processor 0 with some additional
-              // information about its location, and throw a quiet exception on all other
-              // processors
-              catch (const std::exception &exc)
-                {
-                  Utilities::throw_linear_solver_failure_exception("iterative (bottom right) solver",
-                                                                   "BlockSchurGMGPreconditioner::vmult",
-                                                                   std::vector<SolverControl> {solver_control},
-                                                                   exc,
-                                                                   src.block(0).get_mpi_communicator());
-                }
-            }
-        }
-      else
-        {
-          Schur_complement_preconditioner.vmult(dst.block(1),src.block(1));
-          n_iterations_Schur_complement_ += 1;
-        }
-
-      dst.block(1) *= -1.0;
-
-      {
-        // the u-block of dst only contains zeros
-        stokes_matrix.vmult(utmp, dst); // B^T
-        utmp.block(0) *= -1.0;
-        utmp.block(0) += src.block(0);
-      }
-
-      // now either solve with the top left block (if do_solve_A==true)
-      // or just apply one preconditioner sweep (for the first few
-      // iterations of our two-stage outer GMRES iteration)
-      if (do_solve_A == true)
-        {
-          SolverControl solver_control(1000, utmp.block(0).l2_norm() * A_block_tolerance);
-          PrimitiveVectorMemory<dealii::LinearAlgebra::distributed::Vector<double>> mem;
-
-          try
-            {
-              if (A_block_is_symmetric)
-                {
-                  SolverCG<dealii::LinearAlgebra::distributed::Vector<double>> solver(solver_control,mem);
-                  solver.solve(A_block, dst.block(0), utmp.block(0),
-                               A_block_preconditioner);
-                }
-              else
-                {
-                  // Use BiCGStab for non-symmetric matrices.
-                  // BiCGStab can also solve indefinite systems if necessary.
-                  // Do not compute the exact residual, as this
-                  // is more expensive, and we only need an approximate solution.
-                  SolverBicgstab<dealii::LinearAlgebra::distributed::Vector<double>>
-                  solver(solver_control,
-                         mem,
-                         SolverBicgstab<dealii::LinearAlgebra::distributed::Vector<double>>::AdditionalData(/*exact_residual=*/ false));
-                  solver.solve(A_block, dst.block(0), utmp.block(0),
-                               A_block_preconditioner);
-                }
-
-              n_iterations_A_ += solver_control.last_step();
-            }
-          // if the solver fails, report the error from processor 0 with some additional
-          // information about its location, and throw a quiet exception on all other
-          // processors
-          catch (const std::exception &exc)
-            {
-              Utilities::throw_linear_solver_failure_exception("iterative (top left) solver",
-                                                               "BlockSchurGMGPreconditioner::vmult",
-                                                               std::vector<SolverControl> {solver_control},
-                                                               exc,
-                                                               src.block(0).get_mpi_communicator());
-            }
-        }
-      else
-        {
-          A_block_preconditioner.vmult (dst.block(0), utmp.block(0));
-          n_iterations_A_ += 1;
-        }
-    }
-  }
-
-
-  namespace MatrixFreeStokesOperators
-  {
-    template <int dim, typename number>
-    inline std::size_t
-    OperatorCellData<dim,number>::memory_consumption() const
-    {
-      return viscosity.memory_consumption()
-             + newton_factor_wrt_pressure_table.memory_consumption()
-             + strain_rate_table.memory_consumption()
-             + newton_factor_wrt_strain_rate_table.memory_consumption();
-    }
-
-
-
-    template <int dim, typename number>
-    void
-    OperatorCellData<dim,number>::clear()
-    {
-      enable_newton_derivatives = false;
-      viscosity.clear();
-      newton_factor_wrt_pressure_table.clear();
-      strain_rate_table.clear();
-      newton_factor_wrt_strain_rate_table.clear();
-    }
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>::StokesOperator ()
-    :
-    MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::BlockVector<number>>()
-  {}
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>::clear ()
-  {
-    this->cell_data = nullptr;
-    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::BlockVector<number>>::clear();
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>::
-  set_cell_data (const OperatorCellData<dim,number> &data)
-  {
-    this->cell_data = &data;
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>
-  ::compute_diagonal ()
-  {
-    // There is currently no need in the code for the diagonal of the entire Stokes
-    // block. If needed, one could easily construct based on the diagonal of the A
-    // block and append zeros to the end for the number of pressure DoFs.
-    Assert(false, ExcNotImplemented());
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>
-  ::local_apply (const dealii::MatrixFree<dim, number>                         &data,
-                 dealii::LinearAlgebra::distributed::BlockVector<number>       &dst,
-                 const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
-                 const std::pair<unsigned int, unsigned int>                   &cell_range) const
-  {
-    FEEvaluation<dim,degree_v,degree_v+1,dim,number> u_eval(data, 0);
-    FEEvaluation<dim,degree_v-1,degree_v+1,1,number> p_eval(data, /*dofh*/1);
-
-    const bool use_viscosity_at_quadrature_points
-      = (cell_data->viscosity.size(1) == u_eval.n_q_points);
-
-    for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
-      {
-        VectorizedArray<number> viscosity_x_2 = 2. * cell_data->viscosity(cell,0);
-
-        u_eval.reinit(cell);
-        u_eval.gather_evaluate(src.block(0), EvaluationFlags::gradients);
-
-        p_eval.reinit(cell);
-        p_eval.gather_evaluate(src.block(1), EvaluationFlags::values);
-
-        // Store the symmetric gradients of the velocity field and the
-        // values of the pressure field
-        AlignedVector<SymmetricTensor<2,dim,VectorizedArray<number>>> sym_grad_u;
-        AlignedVector<VectorizedArray<number>> val_p;
-        if (cell_data->enable_newton_derivatives)
-          {
-            sym_grad_u.resize(u_eval.n_q_points);
-            val_p.resize(u_eval.n_q_points);
-            for (const unsigned int r : u_eval.quadrature_point_indices())
-              {
-                sym_grad_u[r] = u_eval.get_symmetric_gradient(r);
-                val_p[r]      = p_eval.get_value(r);
-              }
-          }
-
-        for (const unsigned int q : u_eval.quadrature_point_indices())
-          {
-            // Only update the viscosity if a Q1 projection is used.
-            if (use_viscosity_at_quadrature_points)
-              viscosity_x_2 = 2. * cell_data->viscosity(cell,q);
-
-            const SymmetricTensor<2,dim,VectorizedArray<number>>
-            sym_grad_u_q = u_eval.get_symmetric_gradient(q);
-            const VectorizedArray<number> div_u_q = trace(sym_grad_u_q);
-            const VectorizedArray<number> val_p_q = p_eval.get_value(q);
-
-            // Terms to be tested by phi_p:
-            const VectorizedArray<number> pressure_terms =
-              -cell_data->pressure_scaling * div_u_q;
-
-            // Terms to be tested by the symmetric gradients of phi_u:
-            SymmetricTensor<2,dim,VectorizedArray<number>>
-            velocity_terms = viscosity_x_2 * sym_grad_u_q;
-
-            for (unsigned int d=0; d<dim; ++d)
-              velocity_terms[d][d] -= cell_data->pressure_scaling * val_p_q;
-
-            if (cell_data->is_compressible)
-              for (unsigned int d=0; d<dim; ++d)
-                velocity_terms[d][d] -= viscosity_x_2 / 3. * div_u_q;
-
-            // Add the Newton derivatives if required.
-            if (cell_data->enable_newton_derivatives)
-              {
-                VectorizedArray<number> deta_deps_times_sym_grad_u(0.);
-                VectorizedArray<number> eps_times_sym_grad_u(0.);
-                VectorizedArray<number> deta_dp_times_p(0.);
-                for (const unsigned int r : u_eval.quadrature_point_indices())
-                  {
-                    deta_deps_times_sym_grad_u += cell_data->newton_factor_wrt_strain_rate_table(cell,r)
-                                                  * sym_grad_u[r];
-                    deta_dp_times_p += cell_data->newton_factor_wrt_pressure_table(cell,r) * val_p[r];
-                    if (cell_data->symmetrize_newton_system)
-                      eps_times_sym_grad_u += cell_data->strain_rate_table(cell,r) * sym_grad_u[r];
-                  }
-
-                velocity_terms +=
-                  ( cell_data->symmetrize_newton_system ?
-                    ( cell_data->strain_rate_table(cell,q) * deta_deps_times_sym_grad_u +
-                      cell_data->newton_factor_wrt_strain_rate_table(cell,q) * eps_times_sym_grad_u ) :
-                    2. * cell_data->strain_rate_table(cell,q) * deta_deps_times_sym_grad_u )
-                  +
-                  2. * cell_data->strain_rate_table(cell,q) * deta_dp_times_p;
-              }
-
-            u_eval.submit_symmetric_gradient(velocity_terms, q);
-            p_eval.submit_value(pressure_terms, q);
-          }
-
-        u_eval.integrate_scatter(EvaluationFlags::gradients, dst.block(0));
-        p_eval.integrate_scatter(EvaluationFlags::values, dst.block(1));
-      }
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::StokesOperator<dim, degree_v, number>
-  ::local_apply_face(const dealii::MatrixFree<dim, number> &,
-                     dealii::LinearAlgebra::distributed::BlockVector<number> &,
-                     const dealii::LinearAlgebra::distributed::BlockVector<number> &,
-                     const std::pair<unsigned int, unsigned int> &) const
-  {
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::StokesOperator<dim, degree_v, number>
-  ::local_apply_boundary_face(const dealii::MatrixFree<dim, number> &data,
-                              dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
-                              const dealii::LinearAlgebra::distributed::BlockVector<number> &src,
-                              const std::pair<unsigned int, unsigned int> &face_range) const
-  {
-    // Assemble the fictive stabilization stress (phi_u[i].g)*(phi_u[j].n)
-    // g=pressure_perturbation * g_hat is stored in free_surface_stabilization_term_table
-    //  n is the normal vector
-    FEFaceEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(data);
-    const unsigned int n_faces_interior = data.n_inner_face_batches();
-
-    for (unsigned int face = face_range.first; face < face_range.second; ++face)
-      {
-        const auto boundary_id = data.get_boundary_id(face);
-        if (cell_data->free_surface_boundary_indicators.find(boundary_id)
-            == cell_data->free_surface_boundary_indicators.end())
-          continue;
-
-        velocity.reinit(face);
-        velocity.gather_evaluate (src.block(0), EvaluationFlags::values);
-
-        for (const unsigned int q : velocity.quadrature_point_indices())
-          {
-            const Tensor<1, dim, VectorizedArray<number>> phi_u_i = velocity.get_value(q);
-            const auto &normal_vector = velocity.get_normal_vector(q);
-            const auto stabilization_tensor = cell_data->free_surface_stabilization_term_table(face - n_faces_interior, q);
-            const auto value_submit = -(stabilization_tensor * phi_u_i) * normal_vector;
-
-            velocity.submit_value(value_submit, q);
-          }
-        velocity.integrate_scatter(EvaluationFlags::values, dst.block(0));
-      }
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::StokesOperator<dim,degree_v,number>
-  ::apply_add (dealii::LinearAlgebra::distributed::BlockVector<number> &dst,
-               const dealii::LinearAlgebra::distributed::BlockVector<number> &src) const
-  {
-    if (cell_data->apply_stabilization_free_surface_faces)
-      MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::BlockVector<number>>::
-      data->loop(&StokesOperator::local_apply,
-                 &StokesOperator::local_apply_face,
-                 &StokesOperator::local_apply_boundary_face,
-                 this,
-                 dst,
-                 src,
-                 false, /*zero_dst_vector*/
-                 MatrixFree<dim, number>::DataAccessOnFaces::values,
-                 MatrixFree<dim, number>::DataAccessOnFaces::values);
-
-    else
-      MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::BlockVector<number>>::
-      data->cell_loop(&StokesOperator::local_apply, this, dst, src);
-  }
-
-  /**
-   * Mass matrix operator on pressure
-   */
-  template <int dim, int degree_p, typename number>
-  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>::MassMatrixOperator ()
-    :
-    MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::Vector<number>>()
-  {}
-
-
-
-  template <int dim, int degree_p, typename number>
-  void
-  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>::clear ()
-  {
-    this->cell_data = nullptr;
-    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::Vector<number>>::clear();
-  }
-
-
-
-  template <int dim, int degree_p, typename number>
-  void
-  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>::
-  set_cell_data (const OperatorCellData<dim,number> &data)
-  {
-    this->cell_data = &data;
-  }
-
-
-
-  template <int dim, int degree_p, typename number>
-  void
-  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>
-  ::local_apply (const dealii::MatrixFree<dim, number>                 &data,
-                 dealii::LinearAlgebra::distributed::Vector<number>       &dst,
-                 const dealii::LinearAlgebra::distributed::Vector<number> &src,
-                 const std::pair<unsigned int, unsigned int>           &cell_range) const
-  {
-    FEEvaluation<dim,degree_p,degree_p+2,1,number> pressure (data, /*dofh*/1);
-
-    const bool use_viscosity_at_quadrature_points
-      = (cell_data->viscosity.size(1) == pressure.n_q_points);
-
-    for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
-      {
-        VectorizedArray<number> one_over_viscosity = cell_data->viscosity(cell, 0);
-
-        const unsigned int n_components_filled = this->get_matrix_free()->n_active_entries_per_cell_batch(cell);
-
-        // The /= operator for VectorizedArray results in a floating point operation
-        // (divide by 0) since the (*viscosity)(cell) array is not completely filled.
-        // Therefore, we need to divide each entry manually.
-        for (unsigned int c=0; c<n_components_filled; ++c)
-          one_over_viscosity[c] = cell_data->pressure_scaling*cell_data->pressure_scaling/one_over_viscosity[c];
-
-        pressure.reinit (cell);
-        pressure.gather_evaluate (src, EvaluationFlags::values);
-
-        for (const unsigned int q : pressure.quadrature_point_indices())
-          {
-            // Only update the viscosity if a Q1 projection is used.
-            if (use_viscosity_at_quadrature_points)
-              {
-                one_over_viscosity = cell_data->viscosity(cell, q);
-
-                const unsigned int n_components_filled = this->get_matrix_free()->n_active_entries_per_cell_batch(cell);
-
-                for (unsigned int c=0; c<n_components_filled; ++c)
-                  one_over_viscosity[c] = cell_data->pressure_scaling*cell_data->pressure_scaling/one_over_viscosity[c];
-              }
-
-            pressure.submit_value(one_over_viscosity*
-                                  pressure.get_value(q),q);
-          }
-
-        pressure.integrate_scatter (EvaluationFlags::values, dst);
-      }
-  }
-
-
-
-  template <int dim, int degree_p, typename number>
-  void
-  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>
-  ::apply_add (dealii::LinearAlgebra::distributed::Vector<number> &dst,
-               const dealii::LinearAlgebra::distributed::Vector<number> &src) const
-  {
-    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::Vector<number>>::
-    data->cell_loop(&MassMatrixOperator::local_apply, this, dst, src);
-  }
-
-
-
-  template <int dim, int degree_p, typename number>
-  void
-  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>
-  ::compute_diagonal ()
-  {
-    this->inverse_diagonal_entries =
-      std::make_shared<DiagonalMatrix<dealii::LinearAlgebra::distributed::Vector<number>>>();
-    this->diagonal_entries =
-      std::make_shared<DiagonalMatrix<dealii::LinearAlgebra::distributed::Vector<number>>>();
-
-    dealii::LinearAlgebra::distributed::Vector<number> &inverse_diagonal =
-      this->inverse_diagonal_entries->get_vector();
-    dealii::LinearAlgebra::distributed::Vector<number> &diagonal =
-      this->diagonal_entries->get_vector();
-
-    unsigned int dummy = 0;
-    this->data->initialize_dof_vector(inverse_diagonal, /*dofh*/1);
-    this->data->initialize_dof_vector(diagonal, /*dofh*/1);
-
-    this->data->cell_loop (&MassMatrixOperator::local_compute_diagonal, this,
-                           diagonal, dummy);
-
-    this->set_constrained_entries_to_one(diagonal);
-    inverse_diagonal = diagonal;
-
-    // Finally loop over all of the computed diagonal elements and invert them.
-    // The following loop relies on the fact that inverse_diagonal.begin()/end()
-    // iterates only over the *locally owned* elements of the vector in which
-    // we store inverse_diagonal.
-    for (auto &local_element : inverse_diagonal)
-      {
-        Assert(local_element > 0.,
-               ExcMessage("No diagonal entry in a positive definite operator "
-                          "should be zero or negative."));
-        local_element = 1./local_element;
-      }
-  }
-
-
-
-  template <int dim, int degree_p, typename number>
-  void
-  MatrixFreeStokesOperators::MassMatrixOperator<dim,degree_p,number>
-  ::local_compute_diagonal (const MatrixFree<dim,number>                     &data,
-                            dealii::LinearAlgebra::distributed::Vector<number>  &dst,
-                            const unsigned int &,
-                            const std::pair<unsigned int,unsigned int>       &cell_range) const
-  {
-    FEEvaluation<dim,degree_p,degree_p+2,1,number> pressure (data, 1);
-
-    AlignedVector<VectorizedArray<number>> diagonal(pressure.dofs_per_cell);
-
-    const bool use_viscosity_at_quadrature_points
-      = (cell_data->viscosity.size(1) == pressure.n_q_points);
-
-    for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
-      {
-        VectorizedArray<number> one_over_viscosity = cell_data->viscosity(cell, 0);
-
-        const unsigned int n_components_filled = this->get_matrix_free()->n_active_entries_per_cell_batch(cell);
-
-        // The /= operator for VectorizedArray results in a floating point operation
-        // (divide by 0) since the (*viscosity)(cell) array is not completely filled.
-        // Therefore, we need to divide each entry manually.
-        for (unsigned int c=0; c<n_components_filled; ++c)
-          one_over_viscosity[c] = cell_data->pressure_scaling*cell_data->pressure_scaling/one_over_viscosity[c];
-
-        pressure.reinit (cell);
-        for (unsigned int i=0; i<pressure.dofs_per_cell; ++i)
-          {
-            for (unsigned int j=0; j<pressure.dofs_per_cell; ++j)
-              pressure.begin_dof_values()[j] = VectorizedArray<number>();
-            pressure.begin_dof_values()[i] = make_vectorized_array<number> (1.);
-
-            pressure.evaluate (EvaluationFlags::values);
-
-            for (const unsigned int q : pressure.quadrature_point_indices())
-              {
-                // Only update the viscosity if a Q1 projection is used.
-                if (use_viscosity_at_quadrature_points)
-                  {
-                    one_over_viscosity = cell_data->viscosity(cell, q);
-
-                    const unsigned int n_components_filled = this->get_matrix_free()->n_active_entries_per_cell_batch(cell);
-
-                    for (unsigned int c=0; c<n_components_filled; ++c)
-                      one_over_viscosity[c] = cell_data->pressure_scaling*cell_data->pressure_scaling/one_over_viscosity[c];
-                  }
-
-                pressure.submit_value(one_over_viscosity*
-                                      pressure.get_value(q),q);
-              }
-
-            pressure.integrate (EvaluationFlags::values);
-
-            diagonal[i] = pressure.begin_dof_values()[i];
-          }
-
-        for (unsigned int i=0; i<pressure.dofs_per_cell; ++i)
-          pressure.begin_dof_values()[i] = diagonal[i];
-        pressure.distribute_local_to_global (dst);
-      }
-  }
-
-
-
-  /**
-   * Velocity block operator
-   */
-  template <int dim, int degree_v, typename number>
-  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>::ABlockOperator ()
-    :
-    MatrixFreeOperators::Base<dim, dealii::LinearAlgebra::distributed::Vector<number>>()
-  {}
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>::clear ()
-  {
-    this->cell_data = nullptr;
-    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::Vector<number>>::clear();
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>::
-  set_cell_data (const OperatorCellData<dim,number> &data)
-  {
-    this->cell_data = &data;
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
-  ::inner_cell_operation(FEEvaluation<dim,
-                         degree_v,
-                         degree_v+1,
-                         dim,
-                         number> &velocity) const
-  {
-    const bool use_viscosity_at_quadrature_points
-      = (cell_data->viscosity.size(1) == velocity.n_q_points);
-
-    const unsigned int cell = velocity.get_current_cell_index();
-    VectorizedArray<number> viscosity_x_2 = 2.0*cell_data->viscosity(cell, 0);
-
-    for (const unsigned int q : velocity.quadrature_point_indices())
-      {
-        // Only update the viscosity if a Q1 projection is used.
-        if (use_viscosity_at_quadrature_points)
-          viscosity_x_2 = 2.0*cell_data->viscosity(cell, q);
-
-        SymmetricTensor<2,dim,VectorizedArray<number>> sym_grad_u =
-          velocity.get_symmetric_gradient (q);
-        sym_grad_u *= viscosity_x_2;
-
-        if (cell_data->is_compressible)
-          {
-            const VectorizedArray<number> div = trace(sym_grad_u);
-            for (unsigned int d=0; d<dim; ++d)
-              sym_grad_u[d][d] -= 1.0/3.0*div;
-          }
-
-        velocity.submit_symmetric_gradient(sym_grad_u, q);
-      }
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
-  ::cell_operation(FEEvaluation<dim,
-                   degree_v,
-                   degree_v+1,
-                   dim,
-                   number> &velocity) const
-  {
-    velocity.evaluate (EvaluationFlags::gradients);
-    this->inner_cell_operation(velocity);
-    velocity.integrate(EvaluationFlags::gradients);
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
-  ::local_apply (const dealii::MatrixFree<dim, number>                 &data,
-                 dealii::LinearAlgebra::distributed::Vector<number>       &dst,
-                 const dealii::LinearAlgebra::distributed::Vector<number> &src,
-                 const std::pair<unsigned int, unsigned int>           &cell_range) const
-  {
-    FEEvaluation<dim,degree_v,degree_v+1,dim,number> velocity (data,0);
-
-    for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
-      {
-        velocity.reinit (cell);
-
-        // Instead of calling
-        //   velocity.read_dof_values (src);
-        //   velocity.evaluate (EvaluationFlags::gradients);
-        // (the latter by calling cell_operation()), we use the more efficient
-        // combined gather_evaluate() and use inner_cell_operation().
-        velocity.gather_evaluate (src, EvaluationFlags::gradients);
-        this->inner_cell_operation(velocity);
-        velocity.integrate_scatter (EvaluationFlags::gradients, dst);
-      }
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
-  ::apply_add (dealii::LinearAlgebra::distributed::Vector<number> &dst,
-               const dealii::LinearAlgebra::distributed::Vector<number> &src) const
-  {
-    MatrixFreeOperators::Base<dim,dealii::LinearAlgebra::distributed::Vector<number>>::
-    data->cell_loop(&ABlockOperator::local_apply, this, dst, src);
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
-  ::compute_diagonal ()
-  {
-    this->inverse_diagonal_entries =
-      std::make_shared<DiagonalMatrix<dealii::LinearAlgebra::distributed::Vector<number>>>();
-    dealii::LinearAlgebra::distributed::Vector<number> &inverse_diagonal =
-      this->inverse_diagonal_entries->get_vector();
-    this->data->initialize_dof_vector(inverse_diagonal);
-
-    MatrixFreeTools::compute_diagonal(
-      *(this->get_matrix_free()),
-      inverse_diagonal,
-      &MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>::cell_operation,
-      this);
-
-    this->set_constrained_entries_to_one(inverse_diagonal);
-
-    // Finally loop over all of the computed diagonal elements and invert them.
-    // The following loop relies on the fact that inverse_diagonal.begin()/end()
-    // iterates only over the *locally owned* elements of the vector in which
-    // we store inverse_diagonal.
-    for (auto &local_element : inverse_diagonal)
-      {
-        Assert(local_element > 0.,
-               ExcMessage("No diagonal entry in a positive definite operator "
-                          "should be zero or negative."));
-        local_element = 1./local_element;
-      }
-  }
-
-
-
-  template <int dim, int degree_v, typename number>
-  void
-  MatrixFreeStokesOperators::ABlockOperator<dim,degree_v,number>
-  ::set_diagonal (const dealii::LinearAlgebra::distributed::Vector<number> &diag)
-  {
-    this->inverse_diagonal_entries =
-      std::make_shared<DiagonalMatrix<dealii::LinearAlgebra::distributed::Vector<number>>>();
-    dealii::LinearAlgebra::distributed::Vector<number> &inverse_diagonal =
-      this->inverse_diagonal_entries->get_vector();
-    this->data->initialize_dof_vector(inverse_diagonal);
-
-    inverse_diagonal = diag;
-
-    this->set_constrained_entries_to_one(inverse_diagonal);
-
-    // Finally loop over all of the computed diagonal elements and invert them.
-    // The following loop relies on the fact that inverse_diagonal.begin()/end()
-    // iterates only over the *locally owned* elements of the vector in which
-    // we store inverse_diagonal.
-    for (auto &local_element : inverse_diagonal)
-      {
-        Assert(local_element > 0.,
-               ExcMessage("No diagonal entry in a positive definite operator "
-                          "should be zero or negative."));
-        local_element = 1./local_element;
-      }
-  }
-
-
-
-  template <int dim>
-  void StokesMatrixFreeHandler<dim>::declare_parameters(ParameterHandler &prm)
-  {
-    StokesMatrixFreeHandlerImplementation<dim,2>::declare_parameters(prm);
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  void
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::declare_parameters(ParameterHandler &prm)
-  {
-    prm.enter_subsection ("Solver parameters");
-    prm.enter_subsection ("Matrix Free");
-    {
-      prm.declare_entry ("Output details", "false",
-                         Patterns::Bool(),
-                         "Turns on extra information for the matrix free GMG solver to be printed.");
-      prm.declare_entry ("Execute solver timings", "false",
-                         Patterns::Bool(),
-                         "Executes different parts of the Stokes solver repeatedly and print timing information. "
-                         "This is for internal benchmarking purposes: It is useful if you want to see how the solver "
-                         "performs. Otherwise, you don't want to enable this, since it adds additional computational cost "
-                         "to get the timing information.");
-    }
-    prm.leave_subsection ();
-    prm.leave_subsection ();
-
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  void StokesMatrixFreeHandlerImplementation<dim,velocity_degree>::parse_parameters(ParameterHandler &prm)
-  {
-    prm.enter_subsection ("Solver parameters");
-    prm.enter_subsection ("Matrix Free");
-    {
-      print_details = prm.get_bool ("Output details");
-      do_timings = prm.get_bool ("Execute solver timings");
-    }
-    prm.leave_subsection ();
-    prm.leave_subsection ();
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::StokesMatrixFreeHandlerImplementation (Simulator<dim> &simulator,
-      ParameterHandler &prm)
-    : sim(simulator),
-
-      dof_handler_v(simulator.triangulation),
-      dof_handler_p(simulator.triangulation),
-      dof_handler_projection(simulator.triangulation),
-
-      fe_v (FE_Q<dim>(sim.parameters.stokes_velocity_degree), dim),
-      fe_p (FE_Q<dim>(sim.parameters.stokes_velocity_degree-1),1),
-
-      // The finite element used to describe the viscosity on the active level
-      // and to project the viscosity to GMG levels needs to be DGQ1 if we are
-      // using a degree 1 representation of viscosity, and DGQ0 if we are using
-      // a cellwise constant average.
-      fe_projection(FE_DGQ<dim>(sim.parameters.material_averaging
-                                ==
-                                MaterialModel::MaterialAveraging::AveragingOperation::project_to_Q1
-                                ||
-                                sim.parameters.material_averaging
-                                ==
-                                MaterialModel::MaterialAveraging::AveragingOperation::project_to_Q1_only_viscosity
-                                ? 1 : 0), 1)
-  {
-    parse_parameters(prm);
-    CitationInfo::add("mf");
-
-    // Sorry, not any time soon:
-    AssertThrow(!sim.parameters.include_melt_transport, ExcNotImplemented());
-    // Not very difficult to do, but will require a different mass matrix
-    // operator:
-    AssertThrow(!sim.parameters.use_locally_conservative_discretization, ExcNotImplemented());
-
-    // sanity check:
-    Assert(sim.introspection.variable("velocity").block_index==0, ExcNotImplemented());
-    Assert(sim.introspection.variable("pressure").block_index==1, ExcNotImplemented());
-
-    // We currently only support averaging of the viscosity to a constant or Q1:
-    using avg = MaterialModel::MaterialAveraging::AveragingOperation;
-    AssertThrow((sim.parameters.material_averaging &
-                 (avg::arithmetic_average | avg::harmonic_average | avg::geometric_average
-                  | avg::pick_largest | avg::project_to_Q1 | avg::log_average
-                  | avg::harmonic_average_only_viscosity | avg::geometric_average_only_viscosity
-                  | avg::project_to_Q1_only_viscosity)) != 0,
-                ExcMessage("The matrix-free Stokes solver currently only works if material model averaging "
-                           "is enabled. If no averaging is desired, consider using ``project to Q1 only "
-                           "viscosity''."));
-
-    // Currently cannot solve compressible flow with implicit reference density
-    if (sim.material_model->is_compressible() == true)
-      AssertThrow(sim.parameters.formulation_mass_conservation !=
-                  Parameters<dim>::Formulation::MassConservation::implicit_reference_density_profile,
-                  ExcNotImplemented());
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::assemble ()
-  {
-    if (sim.mesh_deformation)
-      {
-        // Update the geometry information stored in the MatrixFree
-        // objects from the mapping.  Grab the mapping stored in the
-        // object and do not replace with sim.mapping as we have
-        // different mappings per level.
-        for (auto &obj : matrix_free_objects)
-          obj->update_mapping(*obj->get_mapping_info().mapping);
-      }
-
-    evaluate_material_model();
-
-    correct_stokes_rhs();
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::evaluate_material_model ()
-  {
-    dealii::LinearAlgebra::distributed::Vector<double> active_viscosity_vector(dof_handler_projection.locally_owned_dofs(),
-                                                                               sim.triangulation.get_communicator());
-
-    const Quadrature<dim> &quadrature_formula = sim.introspection.quadratures.velocities;
-
-    double minimum_viscosity_local = std::numeric_limits<double>::max();
-    double maximum_viscosity_local = std::numeric_limits<double>::lowest();
-
-    // Fill the DGQ0 or DGQ1 vector of viscosity values on the active mesh
-    {
-      FEValues<dim> fe_values (*sim.mapping,
-                               sim.finite_element,
-                               quadrature_formula,
-                               update_values   |
-                               update_gradients |
-                               update_quadrature_points |
-                               update_JxW_values);
-
-      MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, sim.introspection.n_compositional_fields);
-      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-      MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, sim.introspection.n_compositional_fields);
-
-      // This function call computes a cellwise projection of data defined at quadrature points to
-      // a vector defined by the projection DoFHandler. As an input, we must define a lambda which returns
-      // a viscosity value for each quadrature point of the given cell. The projection is then stored in
-      // the active level viscosity vector provided.
-      Utilities::project_cellwise<dim, dealii::LinearAlgebra::distributed::Vector<double>>(*(sim.mapping),
-          dof_handler_projection,
-          0,
-          quadrature_formula,
-          [&](const typename DoFHandler<dim>::active_cell_iterator & cell,
-              const std::vector<Point<dim>> & /*q_points*/,
-              std::vector<double> &values) -> void
-      {
-        typename DoFHandler<dim>::active_cell_iterator FEQ_cell(&sim.triangulation,
-        cell->level(),
-        cell->index(),
-        &(sim.dof_handler));
-
-        fe_values.reinit (FEQ_cell);
-        in.reinit(fe_values, FEQ_cell, sim.introspection, sim.current_linearization_point);
-
-        // Query the material model for the active level viscosities
-        sim.material_model->fill_additional_material_model_inputs(in, sim.current_linearization_point, fe_values, sim.introspection);
-        sim.material_model->evaluate(in, out);
-
-        // If using a cellwise average for viscosity, average the values here.
-        // When the projection is computed, this will set the viscosity exactly
-        // to this averaged value.
-        if (dof_handler_projection.get_fe().degree == 0)
-          MaterialModel::MaterialAveraging::average (sim.parameters.material_averaging,
-          FEQ_cell,
-          quadrature_formula,
-          *sim.mapping,
-          in.requested_properties,
-          out);
-
-        for (unsigned int i=0; i<values.size(); ++i)
-          {
-            // Find the local max/min of the evaluated viscosities.
-            minimum_viscosity_local = std::min(minimum_viscosity_local, out.viscosities[i]);
-            maximum_viscosity_local = std::max(maximum_viscosity_local, out.viscosities[i]);
-
-            values[i] = out.viscosities[i];
-          }
-        return;
-      },
-      active_viscosity_vector);
-
-      active_viscosity_vector.compress(VectorOperation::insert);
-    }
-
-    minimum_viscosity = dealii::Utilities::MPI::min(minimum_viscosity_local, sim.triangulation.get_communicator());
-    maximum_viscosity = dealii::Utilities::MPI::max(maximum_viscosity_local, sim.triangulation.get_communicator());
-
-    FEValues<dim> fe_values_projection (*(sim.mapping),
-                                        fe_projection,
-                                        quadrature_formula,
-                                        update_values);
-
-    // Create active mesh viscosity table.
-    {
-
-      const unsigned int n_cells = stokes_matrix.get_matrix_free()->n_cell_batches();
-
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      std::vector<double> values_on_quad;
-
-      // One value per cell is required for DGQ0 projection and n_q_points
-      // values per cell for DGQ1.
-      if (dof_handler_projection.get_fe().degree == 0)
-        active_cell_data.viscosity.reinit(TableIndices<2>(n_cells, 1));
-      else if (dof_handler_projection.get_fe().degree == 1)
-        {
-          values_on_quad.resize(n_q_points);
-          active_cell_data.viscosity.reinit(TableIndices<2>(n_cells, n_q_points));
-        }
-      else
-        Assert(false, ExcInternalError());
-
-      std::vector<types::global_dof_index> local_dof_indices(fe_projection.dofs_per_cell);
-      for (unsigned int cell=0; cell<n_cells; ++cell)
-        {
-          const unsigned int n_components_filled = stokes_matrix.get_matrix_free()->n_active_entries_per_cell_batch(cell);
-
-          for (unsigned int i=0; i<n_components_filled; ++i)
-            {
-              typename DoFHandler<dim>::active_cell_iterator FEQ_cell =
-                stokes_matrix.get_matrix_free()->get_cell_iterator(cell,i);
-              typename DoFHandler<dim>::active_cell_iterator DG_cell(&(sim.triangulation),
-                                                                     FEQ_cell->level(),
-                                                                     FEQ_cell->index(),
-                                                                     &dof_handler_projection);
-              DG_cell->get_active_or_mg_dof_indices(local_dof_indices);
-
-#ifdef DEBUG
-              {
-                // Verify that all MatrixFree objects iterate over cells in the same way:
-                typename DoFHandler<dim>::active_cell_iterator s_cell =
-                  Schur_complement_block_matrix.get_matrix_free()->get_cell_iterator(cell,i,1);
-                double distance_s = s_cell->center().distance(FEQ_cell->center());
-                Assert(distance_s < 1e-10, ExcInternalError());
-
-                typename DoFHandler<dim>::active_cell_iterator A_cell =
-                  A_block_matrix.get_matrix_free()->get_cell_iterator(cell,i);
-                double distance_A = A_cell->center().distance(FEQ_cell->center());
-                Assert(distance_A < 1e-10, ExcInternalError());
-              }
-#endif
-
-              // For DGQ0, we simply use the viscosity at the single
-              // support point of the element. For DGQ1, we must project
-              // back to quadrature point values.
-              if (dof_handler_projection.get_fe().degree == 0)
-                active_cell_data.viscosity(cell, 0)[i] = active_viscosity_vector(local_dof_indices[0]);
-              else
-                {
-                  fe_values_projection.reinit(DG_cell);
-                  fe_values_projection.get_function_values(active_viscosity_vector,
-                                                           local_dof_indices,
-                                                           values_on_quad);
-
-                  // Do not allow viscosity to be greater than or less than the limits
-                  // of the evaluated viscosity on the active level.
-                  for (unsigned int q=0; q<n_q_points; ++q)
-                    active_cell_data.viscosity(cell, q)[i]
-                      = std::min(std::max(values_on_quad[q], minimum_viscosity), maximum_viscosity);
-                }
-            }
-        }
-    }
-
-    active_cell_data.is_compressible = sim.material_model->is_compressible();
-    active_cell_data.pressure_scaling = sim.pressure_scaling;
-
-    // Store viscosity tables and other data into the active level matrix-free objects.
-    stokes_matrix.set_cell_data(active_cell_data);
-
-    if (sim.parameters.n_expensive_stokes_solver_steps > 0)
-      {
-        A_block_matrix.set_cell_data(active_cell_data);
-        Schur_complement_block_matrix.set_cell_data(active_cell_data);
-      }
-
-    const unsigned int n_levels = sim.triangulation.n_global_levels();
-    level_cell_data.resize(0,n_levels-1);
-
-    MGLevelObject<dealii::LinearAlgebra::distributed::Vector<GMGNumberType>> level_viscosity_vector;
-    level_viscosity_vector.resize(0,n_levels-1);
-
-    // Project the active level viscosity vector to multilevel vector representations
-    // using MG transfer objects. This transfer is based on the same linear operator used to
-    // transfer data inside a v-cycle.
-    MGTransferMF<dim,GMGNumberType> transfer;
-
-    transfer.build(dof_handler_projection);
-
-    transfer.interpolate_to_mg(dof_handler_projection,
-                               level_viscosity_vector,
-                               active_viscosity_vector);
-
-    for (unsigned int level=0; level<n_levels; ++level)
-      {
-        level_cell_data[level].is_compressible = sim.material_model->is_compressible();
-        level_cell_data[level].pressure_scaling = sim.pressure_scaling;
-
-        // Create viscosity tables on each level.
-        const unsigned int n_cells = mg_matrices_A_block[level].get_matrix_free()->n_cell_batches();
-
-        const unsigned int n_q_points = quadrature_formula.size();
-
-        std::vector<GMGNumberType> values_on_quad;
-
-        // One value per cell is required for DGQ0 projection and n_q_points
-        // values per cell for DGQ1.
-        if (dof_handler_projection.get_fe().degree == 0)
-          level_cell_data[level].viscosity.reinit(TableIndices<2>(n_cells, 1));
-        else
-          {
-            values_on_quad.resize(n_q_points);
-            level_cell_data[level].viscosity.reinit(TableIndices<2>(n_cells, n_q_points));
-          }
-
-        std::vector<types::global_dof_index> local_dof_indices(fe_projection.dofs_per_cell);
-        for (unsigned int cell=0; cell<n_cells; ++cell)
-          {
-            const unsigned int n_components_filled = mg_matrices_A_block[level].get_matrix_free()->n_active_entries_per_cell_batch(cell);
-
-            for (unsigned int i=0; i<n_components_filled; ++i)
-              {
-                typename DoFHandler<dim>::level_cell_iterator FEQ_cell =
-                  mg_matrices_A_block[level].get_matrix_free()->get_cell_iterator(cell,i);
-                typename DoFHandler<dim>::level_cell_iterator DG_cell(&(sim.triangulation),
-                                                                      FEQ_cell->level(),
-                                                                      FEQ_cell->index(),
-                                                                      &dof_handler_projection);
-                DG_cell->get_active_or_mg_dof_indices(local_dof_indices);
-
-                // For DGQ0, we simply use the viscosity at the single
-                // support point of the element. For DGQ1, we must project
-                // back to quadrature point values.
-                if (dof_handler_projection.get_fe().degree == 0)
-                  level_cell_data[level].viscosity(cell, 0)[i] = level_viscosity_vector[level](local_dof_indices[0]);
-                else
-                  {
-                    fe_values_projection.reinit(DG_cell);
-                    fe_values_projection.get_function_values(level_viscosity_vector[level],
-                                                             local_dof_indices,
-                                                             values_on_quad);
-
-                    // Do not allow viscosity to be greater than or less than the limits
-                    // of the evaluated viscosity on the active level.
-                    for (unsigned int q=0; q<n_q_points; ++q)
-                      level_cell_data[level].viscosity(cell,q)[i]
-                        = std::min(std::max(values_on_quad[q], static_cast<GMGNumberType>(minimum_viscosity)),
-                                   static_cast<GMGNumberType>(maximum_viscosity));
-                  }
-              }
-          }
-
-        // Store viscosity tables and other data into the multigrid level matrix-free objects.
-        mg_matrices_A_block[level].set_cell_data (level_cell_data[level]);
-        mg_matrices_Schur_complement[level].set_cell_data (level_cell_data[level]);
-      }
-
-    {
-      // create active mesh tables for derivatives needed in Newton method
-      // and the strain rate.
-      if (sim.newton_handler != nullptr
-          && sim.newton_handler->parameters.newton_derivative_scaling_factor != 0)
-        {
-          const double newton_derivative_scaling_factor =
-            sim.newton_handler->parameters.newton_derivative_scaling_factor;
-
-          active_cell_data.enable_newton_derivatives = true;
-
-          // TODO: these are not implemented yet
-          for (unsigned int level=0; level<n_levels; ++level)
-            level_cell_data[level].enable_newton_derivatives = false;
-
-
-          FEValues<dim> fe_values (*sim.mapping,
-                                   sim.finite_element,
-                                   quadrature_formula,
-                                   update_values   |
-                                   update_gradients |
-                                   update_quadrature_points |
-                                   update_JxW_values);
-
-          MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, sim.introspection.n_compositional_fields);
-          MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, sim.introspection.n_compositional_fields);
-          sim.newton_handler->create_material_model_outputs(out);
-          if (sim.parameters.enable_elasticity &&
-              out.template get_additional_output<MaterialModel::ElasticOutputs<dim>>() == nullptr)
-            out.additional_outputs.push_back(std::make_unique<MaterialModel::ElasticOutputs<dim>>(out.n_evaluation_points()));
-
-          const unsigned int n_cells = stokes_matrix.get_matrix_free()->n_cell_batches();
-          const unsigned int n_q_points = quadrature_formula.size();
-
-          active_cell_data.strain_rate_table.reinit(TableIndices<2>(n_cells, n_q_points));
-          active_cell_data.newton_factor_wrt_pressure_table.reinit(TableIndices<2>(n_cells, n_q_points));
-          active_cell_data.newton_factor_wrt_strain_rate_table.reinit(TableIndices<2>(n_cells, n_q_points));
-
-          for (unsigned int cell=0; cell<n_cells; ++cell)
-            {
-              const unsigned int n_components_filled = stokes_matrix.get_matrix_free()->n_active_entries_per_cell_batch(cell);
-
-              for (unsigned int i=0; i<n_components_filled; ++i)
-                {
-                  typename DoFHandler<dim>::active_cell_iterator matrix_free_cell =
-                    stokes_matrix.get_matrix_free()->get_cell_iterator(cell,i);
-                  typename DoFHandler<dim>::active_cell_iterator simulator_cell(&(sim.triangulation),
-                                                                                matrix_free_cell->level(),
-                                                                                matrix_free_cell->index(),
-                                                                                &(sim.dof_handler));
-
-                  fe_values.reinit(simulator_cell);
-                  in.reinit(fe_values, simulator_cell, sim.introspection, sim.current_linearization_point);
-
-                  sim.material_model->fill_additional_material_model_inputs(in, sim.current_linearization_point, fe_values, sim.introspection);
-                  sim.material_model->evaluate(in, out);
-
-                  MaterialModel::MaterialAveraging::average(sim.parameters.material_averaging,
-                                                            in.current_cell,
-                                                            fe_values.get_quadrature(),
-                                                            *sim.mapping,
-                                                            in.requested_properties,
-                                                            out);
-
-                  Assert(std::isfinite(in.strain_rate[0].norm()),
-                         ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                                    "not filled by the caller."));
-
-                  const MaterialModel::MaterialModelDerivatives<dim> *derivatives
-                    = out.template get_additional_output<MaterialModel::MaterialModelDerivatives<dim>>();
-
-                  Assert(derivatives != nullptr,
-                         ExcMessage ("Error: The Newton method requires the material to "
-                                     "compute derivatives."));
-
-                  const MaterialModel::ElasticOutputs<dim> *elastic_out
-                    = out.template get_additional_output<MaterialModel::ElasticOutputs<dim>>();
-
-                  for (unsigned int q=0; q<n_q_points; ++q)
-                    {
-                      const SymmetricTensor<2,dim> effective_strain_rate =
-                        elastic_out == nullptr ? deviator(in.strain_rate[q]) : elastic_out->viscoelastic_strain_rate[q];
-
-                      // use the spd factor when the stabilization is PD or SPD.
-                      const double alpha =  (sim.newton_handler->parameters.velocity_block_stabilization
-                                             & Newton::Parameters::Stabilization::PD)
-                                            != Newton::Parameters::Stabilization::none
-                                            ?
-                                            Utilities::compute_spd_factor<dim>(out.viscosities[q],
-                                                                               effective_strain_rate,
-                                                                               derivatives->viscosity_derivative_wrt_strain_rate[q],
-                                                                               sim.newton_handler->parameters.SPD_safety_factor)
-                                            :
-                                            1.0;
-
-                      active_cell_data.newton_factor_wrt_pressure_table(cell,q)[i]
-                        = derivatives->viscosity_derivative_wrt_pressure[q] *
-                          derivatives->viscosity_derivative_averaging_weights[q] *
-                          newton_derivative_scaling_factor;
-                      Assert(std::isfinite(active_cell_data.newton_factor_wrt_pressure_table(cell,q)[i]),
-                             ExcMessage("active_cell_data.newton_factor_wrt_pressure_table is not finite: " + std::to_string(active_cell_data.newton_factor_wrt_pressure_table(cell,q)[i]) +
-                                        ". Relevant variables are derivatives->viscosity_derivative_wrt_pressure[q] = " + std::to_string(derivatives->viscosity_derivative_wrt_pressure[q]) +
-                                        ", derivatives->viscosity_derivative_averaging_weights[q] = " + std::to_string(derivatives->viscosity_derivative_averaging_weights[q]) +
-                                        ", and newton_derivative_scaling_factor = " + std::to_string(newton_derivative_scaling_factor)));
-
-                      for (unsigned int m=0; m<dim; ++m)
-                        for (unsigned int n=0; n<dim; ++n)
-                          {
-                            active_cell_data.strain_rate_table(cell, q)[m][n][i]
-                              = effective_strain_rate[m][n];
-
-                            active_cell_data.newton_factor_wrt_strain_rate_table(cell, q)[m][n][i]
-                              = derivatives->viscosity_derivative_wrt_strain_rate[q][m][n] *
-                                derivatives->viscosity_derivative_averaging_weights[q] *
-                                newton_derivative_scaling_factor * alpha;
-
-                            Assert(std::isfinite(active_cell_data.strain_rate_table(cell, q)[m][n][i]),
-                                   ExcMessage("active_cell_data.strain_rate_table has an element which is not finite: " + std::to_string(active_cell_data.strain_rate_table(cell, q)[m][n][i])));
-                            Assert(std::isfinite(active_cell_data.newton_factor_wrt_strain_rate_table(cell, q)[m][n][i]),
-                                   ExcMessage("active_cell_data.newton_factor_wrt_strain_rate_table has an element which is not finite: " + std::to_string(active_cell_data.newton_factor_wrt_strain_rate_table(cell, q)[m][n][i])));
-                          }
-                    }
-                }
-            }
-
-          // symmetrize the Newton_system when the stabilization is symmetric or SPD
-          const bool symmetrize_newton_system =
-            (sim.newton_handler->parameters.velocity_block_stabilization & Newton::Parameters::Stabilization::symmetric)
-            != Newton::Parameters::Stabilization::none;
-          active_cell_data.symmetrize_newton_system = symmetrize_newton_system;
-        }
-      else
-        {
-          // delete data used for Newton derivatives if necessary
-          // TODO: use Table::clear() once implemented in 10.0.pre
-          active_cell_data.enable_newton_derivatives = false;
-          active_cell_data.newton_factor_wrt_pressure_table.reinit(TableIndices<2>(0,0));
-          active_cell_data.strain_rate_table.reinit(TableIndices<2>(0,0));
-          active_cell_data.newton_factor_wrt_strain_rate_table.reinit(TableIndices<2>(0,0));
-
-          for (unsigned int level=0; level<n_levels; ++level)
-            level_cell_data[level].enable_newton_derivatives = false;
-        }
-    }
-
-    {
-      // Create active mesh tables to store the product of the pressure perturbation and
-      // the normalized gravity used in the free surface stabilization.
-      // Currently, mutilevel is not implemented yet, it may slow down the convergence.
-
-      // TODO: implement multilevel surface terms for the free surface stabilization.
-
-      active_cell_data.apply_stabilization_free_surface_faces = sim.mesh_deformation
-                                                                && !sim.mesh_deformation->get_free_surface_boundary_indicators().empty();
-      if (active_cell_data.apply_stabilization_free_surface_faces == true)
-        {
-          const double free_surface_theta = sim.mesh_deformation->get_free_surface_theta();
-
-          const Quadrature<dim-1> &face_quadrature_formula = sim.introspection.face_quadratures.velocities;
-
-          const unsigned int n_face_q_points = face_quadrature_formula.size();
-
-          // We need the gradients for the material model inputs.
-          FEFaceValues<dim> fe_face_values (*sim.mapping,
-                                            sim.finite_element,
-                                            face_quadrature_formula,
-                                            update_values   |
-                                            update_gradients |
-                                            update_quadrature_points |
-                                            update_JxW_values);
-
-          const unsigned int n_faces_boundary = stokes_matrix.get_matrix_free()->n_boundary_face_batches();
-          const unsigned int n_faces_interior = stokes_matrix.get_matrix_free()->n_inner_face_batches();
-
-          active_cell_data.free_surface_boundary_indicators =
-            sim.mesh_deformation->get_free_surface_boundary_indicators();
-
-          MaterialModel::MaterialModelInputs<dim> face_material_inputs(n_face_q_points, sim.introspection.n_compositional_fields);
-          face_material_inputs.requested_properties = MaterialModel::MaterialProperties::density;
-          MaterialModel::MaterialModelOutputs<dim> face_material_outputs(n_face_q_points, sim.introspection.n_compositional_fields);
-
-          active_cell_data.free_surface_stabilization_term_table.reinit(n_faces_boundary, n_face_q_points);
-
-          for (unsigned int face=n_faces_interior; face<n_faces_boundary + n_faces_interior; ++face)
-            {
-              const unsigned int n_components_filled = stokes_matrix.get_matrix_free()->n_active_entries_per_face_batch(face);
-
-              for (unsigned int i=0; i<n_components_filled; ++i)
-                {
-                  // The first element of the pair is the active cell iterator
-                  // the second element of the pair is the face number
-                  const auto cell_face_pair = stokes_matrix.get_matrix_free()->get_face_iterator(face, i, true);
-
-                  typename DoFHandler<dim>::active_cell_iterator matrix_free_cell =
-                    cell_face_pair.first;
-                  typename DoFHandler<dim>::active_cell_iterator simulator_cell(&(sim.triangulation),
-                                                                                matrix_free_cell->level(),
-                                                                                matrix_free_cell->index(),
-                                                                                &(sim.dof_handler));
-
-                  const types::boundary_id boundary_indicator = stokes_matrix.get_matrix_free()->get_boundary_id(face);
-                  Assert(boundary_indicator == simulator_cell->face(cell_face_pair.second)->boundary_id(), ExcInternalError());
-
-                  // only apply on free surface faces
-                  if (active_cell_data.free_surface_boundary_indicators.find(boundary_indicator)
-                      == active_cell_data.free_surface_boundary_indicators.end())
-                    continue;
-
-                  fe_face_values.reinit(simulator_cell, cell_face_pair.second);
-
-                  face_material_inputs.reinit  (fe_face_values,
-                                                simulator_cell,
-                                                sim.introspection,
-                                                sim.solution);
-                  face_material_inputs.requested_properties = MaterialModel::MaterialProperties::density;
-                  sim.material_model->evaluate(face_material_inputs, face_material_outputs);
-
-                  for (unsigned int q = 0; q < n_face_q_points; ++q)
-                    {
-                      const Tensor<1,dim>
-                      gravity = sim.gravity_model->gravity_vector(fe_face_values.quadrature_point(q));
-                      const double g_norm = gravity.norm();
-
-                      const Tensor<1,dim> g_hat = (g_norm == 0.0 ? Tensor<1,dim>() : gravity/g_norm);
-
-                      const double pressure_perturbation = face_material_outputs.densities[q] *
-                                                           sim.time_step *
-                                                           free_surface_theta *
-                                                           g_norm;
-                      for (unsigned int d = 0; d < dim; ++d)
-                        active_cell_data.free_surface_stabilization_term_table(face - n_faces_interior, q)[d][i]
-                          = pressure_perturbation * g_hat[d];
-                    }
-                }
-            }
-        }
-    }
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::correct_stokes_rhs()
-  {
-    // We never include Newton terms in step 0 and after that we solve with zero boundary conditions.
-    // Therefore, we don't need to include Newton terms here.
-
-    const bool is_compressible = sim.material_model->is_compressible();
-
-    dealii::LinearAlgebra::distributed::BlockVector<double> rhs_correction(2);
-    dealii::LinearAlgebra::distributed::BlockVector<double> u0(2);
-
-    stokes_matrix.initialize_dof_vector(rhs_correction);
-    stokes_matrix.initialize_dof_vector(u0);
-
-    // The vector u0 is a zero vector, but we need to ensure that it
-    // has the correct boundary values:
-    u0 = 0;
-
-#if DEAL_II_VERSION_GTE(9,6,0)
-    IndexSet stokes_dofs (sim.dof_handler.n_dofs());
-    stokes_dofs.add_range (0, u0.size());
-    const AffineConstraints<double> current_stokes_constraints
-      = sim.current_constraints.get_view (stokes_dofs);
-    current_stokes_constraints.distribute(u0);
-#else
-    sim.current_constraints.distribute(u0);
-#endif
-
-    u0.update_ghost_values();
-
-    rhs_correction = 0;
-
-    FEEvaluation<dim,velocity_degree,velocity_degree+1,dim,double>
-    velocity (*stokes_matrix.get_matrix_free(), 0);
-    FEEvaluation<dim,velocity_degree-1,velocity_degree+1,1,double>
-    pressure (*stokes_matrix.get_matrix_free(), 1);
-
-    const bool use_viscosity_at_quadrature_points
-      = (active_cell_data.viscosity.size(1) == velocity.n_q_points);
-
-    const unsigned int n_cells = stokes_matrix.get_matrix_free()->n_cell_batches();
-
-    // Much like the matrix-free apply_add() functions compute a matrix-vector
-    // product by looping over cells and applying local matrix operations,
-    // here we apply the negative of the stokes_matrix operator to u0.
-    for (unsigned int cell=0; cell<n_cells; ++cell)
-      {
-        VectorizedArray<double> viscosity_x_2 = 2.0*active_cell_data.viscosity(cell, 0);
-
-        // We must use read_dof_values_plain() as to not overwrite boundary information
-        // with the zero boundary used by the stokes_matrix operator.
-        velocity.reinit (cell);
-        velocity.read_dof_values_plain (u0.block(0));
-        velocity.evaluate (EvaluationFlags::gradients);
-
-        pressure.reinit (cell);
-        pressure.read_dof_values_plain (u0.block(1));
-        pressure.evaluate (EvaluationFlags::values);
-
-        for (const unsigned int q : velocity.quadrature_point_indices())
-          {
-            // Only update the viscosity if a Q1 projection is used.
-            if (use_viscosity_at_quadrature_points)
-              viscosity_x_2 = 2.0*active_cell_data.viscosity(cell, q);
-
-            SymmetricTensor<2,dim,VectorizedArray<double>> sym_grad_u =
-              velocity.get_symmetric_gradient (q);
-            const VectorizedArray<double> pres = pressure.get_value(q);
-            const VectorizedArray<double> div = trace(sym_grad_u);
-            pressure.submit_value(sim.pressure_scaling*div, q);
-
-            sym_grad_u *= viscosity_x_2;
-
-            for (unsigned int d=0; d<dim; ++d)
-              sym_grad_u[d][d] -= sim.pressure_scaling*pres;
-
-            if (is_compressible)
-              for (unsigned int d=0; d<dim; ++d)
-                sym_grad_u[d][d] -= viscosity_x_2/3.0*div;
-
-            velocity.submit_symmetric_gradient(-1.0*sym_grad_u, q);
-          }
-
-
-        velocity.integrate_scatter (EvaluationFlags::gradients,
-                                    rhs_correction.block(0));
-
-        pressure.integrate_scatter (EvaluationFlags::values,
-                                    rhs_correction.block(1));
-      }
-
-    if (active_cell_data.apply_stabilization_free_surface_faces)
-      {
-        const unsigned int n_faces_boundary = stokes_matrix.get_matrix_free()->n_boundary_face_batches();
-        const unsigned int n_faces_interior = stokes_matrix.get_matrix_free()->n_inner_face_batches();
-
-        FEFaceEvaluation<dim,velocity_degree,velocity_degree+1,dim,double>
-        velocity_boundary(*stokes_matrix.get_matrix_free());
-
-        for (unsigned int face=n_faces_interior; face<n_faces_boundary + n_faces_interior; ++face)
-          {
-            const auto boundary_id = stokes_matrix.get_matrix_free()->get_boundary_id(face);
-            if (active_cell_data.free_surface_boundary_indicators.find(boundary_id)
-                == active_cell_data.free_surface_boundary_indicators.end())
-              continue;
-
-            velocity_boundary.reinit(face);
-            velocity_boundary.read_dof_values_plain (u0.block(0));
-            velocity_boundary.evaluate (EvaluationFlags::values);
-
-            for (const unsigned int q : velocity_boundary.quadrature_point_indices())
-              {
-                const Tensor<1, dim, VectorizedArray<double>> phi_u_i = velocity_boundary.get_value(q);
-                const auto &normal_vector = velocity_boundary.get_normal_vector(q);
-                const auto stabilization_tensor = active_cell_data.free_surface_stabilization_term_table(face - n_faces_interior, q);
-                const auto value_submit = (stabilization_tensor * phi_u_i) * normal_vector;
-                velocity_boundary.submit_value(value_submit, q);
-
-              }
-            velocity_boundary.integrate_scatter(EvaluationFlags::values,
-                                                rhs_correction.block(0));
-          }
-      }
-
-    rhs_correction.compress(VectorOperation::add);
-
-    // Copy to the correct vector type and add the correction to the system rhs.
-    LinearAlgebra::BlockVector stokes_rhs_correction (sim.introspection.index_sets.stokes_partitioning, sim.mpi_communicator);
-    internal::ChangeVectorTypes::copy(stokes_rhs_correction,rhs_correction);
-
-    sim.system_rhs.block(0) += stokes_rhs_correction.block(0);
-    sim.system_rhs.block(1) += stokes_rhs_correction.block(1);
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  std::pair<double,double> StokesMatrixFreeHandlerImplementation<dim,velocity_degree>::solve()
-  {
-    double initial_nonlinear_residual = numbers::signaling_nan<double>();
-    double final_linear_residual      = numbers::signaling_nan<double>();
-
-    // Below we define all the objects needed to build the GMG preconditioner:
-    using VectorType = dealii::LinearAlgebra::distributed::Vector<GMGNumberType>;
-
-    // ABlock GMG Smoother: Chebyshev, degree 4. Parameter values were chosen
-    // by trial and error. We use a more powerful version of the smoother on the
-    // coarsest level than on the other levels.
-    using ASmootherType = PreconditionChebyshev<GMGABlockMatrixType,VectorType>;
-    mg::SmootherRelaxation<ASmootherType, VectorType>
-    mg_smoother_A;
-    {
-      MGLevelObject<typename ASmootherType::AdditionalData> smoother_data_A;
-      smoother_data_A.resize(0, sim.triangulation.n_global_levels()-1);
-      for (unsigned int level = 0; level<sim.triangulation.n_global_levels(); ++level)
-        {
-          if (level > 0)
-            {
-              smoother_data_A[level].smoothing_range = 15.;
-              smoother_data_A[level].degree = 4;
-              smoother_data_A[level].eig_cg_n_iterations = 10;
-            }
-          else
-            {
-              smoother_data_A[0].smoothing_range = 1e-3;
-              smoother_data_A[0].degree = 8;
-              smoother_data_A[0].eig_cg_n_iterations = 100;
-            }
-          smoother_data_A[level].preconditioner = mg_matrices_A_block[level].get_matrix_diagonal_inverse();
-        }
-      mg_smoother_A.initialize(mg_matrices_A_block, smoother_data_A);
-    }
-
-    // Schur complement matrix GMG Smoother: Chebyshev, degree 4. Parameter values
-    // were chosen by trial and error. We use a more powerful version of the smoother
-    // on the coarsest level than on the other levels.
-    using MSmootherType = PreconditionChebyshev<GMGSchurComplementMatrixType,VectorType>;
-    mg::SmootherRelaxation<MSmootherType, VectorType>
-    mg_smoother_Schur(4);
-    {
-      MGLevelObject<typename MSmootherType::AdditionalData> smoother_data_Schur;
-      smoother_data_Schur.resize(0, sim.triangulation.n_global_levels()-1);
-      for (unsigned int level = 0; level<sim.triangulation.n_global_levels(); ++level)
-        {
-          if (level > 0)
-            {
-              smoother_data_Schur[level].smoothing_range = 15.;
-              smoother_data_Schur[level].degree = 4;
-              smoother_data_Schur[level].eig_cg_n_iterations = 10;
-            }
-          else
-            {
-              smoother_data_Schur[0].smoothing_range = 1e-3;
-              smoother_data_Schur[0].degree = 8;
-              smoother_data_Schur[0].eig_cg_n_iterations = 100;
-            }
-          smoother_data_Schur[level].preconditioner = mg_matrices_Schur_complement[level].get_matrix_diagonal_inverse();
-        }
-      mg_smoother_Schur.initialize(mg_matrices_Schur_complement, smoother_data_Schur);
-    }
-
-    // Estimate the eigenvalues for the Chebyshev smoothers.
-
-    types::global_dof_index coarse_A_size = numbers::invalid_dof_index, coarse_S_size = numbers::invalid_dof_index;
-
-    //TODO: The setup for the smoother (as well as the entire GMG setup) should
-    //       be moved to an assembly timing block instead of the Stokes solve
-    //       timing block (as is currently the case).
-    for (unsigned int level = 0; level<sim.triangulation.n_global_levels(); ++level)
-      {
-        VectorType temp_velocity;
-        VectorType temp_pressure;
-        mg_matrices_A_block[level].initialize_dof_vector(temp_velocity);
-        mg_matrices_Schur_complement[level].initialize_dof_vector(temp_pressure);
-
-        mg_smoother_A[level].estimate_eigenvalues(temp_velocity);
-        mg_smoother_Schur[level].estimate_eigenvalues(temp_pressure);
-
-        if (level==0)
-          {
-            coarse_A_size = temp_velocity.size();
-            coarse_S_size = temp_pressure.size();
-          }
-      }
-
-
-    // Coarse Solver is just an application of the Chebyshev smoother setup
-    // in such a way to be a solver
-    //ABlock GMG
-    MGCoarseGridApplySmoother<VectorType> mg_coarse_A;
-    mg_coarse_A.initialize(mg_smoother_A);
-
-    //Schur complement matrix GMG
-    MGCoarseGridApplySmoother<VectorType> mg_coarse_Schur;
-    mg_coarse_Schur.initialize(mg_smoother_Schur);
-
-
-    if (print_details)
-      {
-        sim.pcout << std::endl
-                  << "    GMG coarse size A: " << coarse_A_size << ", coarse size S: " << coarse_S_size << std::endl
-                  << "    GMG n_levels: " << sim.triangulation.n_global_levels() << std::endl
-                  << "    Viscosity range: " << minimum_viscosity << " - " << maximum_viscosity << std::endl;
-
-        const double imbalance = MGTools::workload_imbalance(sim.triangulation);
-        sim.pcout << "    GMG workload imbalance: " << imbalance << std::endl
-                  << "    Stokes solver: " << std::flush;
-      }
-
-    // Interface matrices
-    // Ablock GMG
-    MGLevelObject<MatrixFreeOperators::MGInterfaceOperator<GMGABlockMatrixType>> mg_interface_matrices_A;
-    mg_interface_matrices_A.resize(0, sim.triangulation.n_global_levels()-1);
-    for (unsigned int level=0; level<sim.triangulation.n_global_levels(); ++level)
-      mg_interface_matrices_A[level].initialize(mg_matrices_A_block[level]);
-    mg::Matrix<VectorType> mg_interface_A(mg_interface_matrices_A);
-
-    // Schur complement matrix GMG
-    MGLevelObject<MatrixFreeOperators::MGInterfaceOperator<GMGSchurComplementMatrixType>> mg_interface_matrices_Schur;
-    mg_interface_matrices_Schur.resize(0, sim.triangulation.n_global_levels()-1);
-    for (unsigned int level=0; level<sim.triangulation.n_global_levels(); ++level)
-      mg_interface_matrices_Schur[level].initialize(mg_matrices_Schur_complement[level]);
-    mg::Matrix<VectorType> mg_interface_Schur(mg_interface_matrices_Schur);
-
-    // MG Matrix
-    mg::Matrix<VectorType> mg_matrix_A(mg_matrices_A_block);
-    mg::Matrix<VectorType> mg_matrix_Schur(mg_matrices_Schur_complement);
-
-    // MG object
-    // ABlock GMG
-    Multigrid<VectorType> mg_A(mg_matrix_A,
-                               mg_coarse_A,
-                               mg_transfer_A_block,
-                               mg_smoother_A,
-                               mg_smoother_A);
-    mg_A.set_edge_matrices(mg_interface_A, mg_interface_A);
-
-    // Schur complement matrix GMG
-    Multigrid<VectorType> mg_Schur(mg_matrix_Schur,
-                                   mg_coarse_Schur,
-                                   mg_transfer_Schur_complement,
-                                   mg_smoother_Schur,
-                                   mg_smoother_Schur);
-    mg_Schur.set_edge_matrices(mg_interface_Schur, mg_interface_Schur);
-
-    // GMG Preconditioner for ABlock and Schur complement
-    using GMGPreconditioner = PreconditionMG<dim, VectorType, MGTransferMF<dim,GMGNumberType>>;
-    GMGPreconditioner prec_A(dof_handler_v, mg_A, mg_transfer_A_block);
-    GMGPreconditioner prec_Schur(dof_handler_p, mg_Schur, mg_transfer_Schur_complement);
-
-
-    // Many parts of the solver depend on the block layout (velocity = 0,
-    // pressure = 1). For example the linearized_stokes_initial_guess vector or the StokesBlock matrix
-    // wrapper. Let us make sure that this holds (and shorten their names):
-    const unsigned int block_vel = sim.introspection.block_indices.velocities;
-    const unsigned int block_p = (sim.parameters.include_melt_transport) ?
-                                 sim.introspection.variable("fluid pressure").block_index
-                                 : sim.introspection.block_indices.pressure;
-
-    LinearAlgebra::BlockVector distributed_stokes_solution (sim.introspection.index_sets.stokes_partitioning,
-                                                            sim.mpi_communicator);
-    // extract Stokes parts of rhs vector
-    LinearAlgebra::BlockVector distributed_stokes_rhs(sim.introspection.index_sets.stokes_partitioning,
-                                                      sim.mpi_communicator);
-
-    distributed_stokes_rhs.block(block_vel) = sim.system_rhs.block(block_vel);
-    distributed_stokes_rhs.block(block_p) = sim.system_rhs.block(block_p);
-
-    Assert(block_vel == 0, ExcNotImplemented());
-    Assert(block_p == 1, ExcNotImplemented());
-    Assert(!sim.parameters.include_melt_transport
-           || sim.introspection.variable("compaction pressure").block_index == 1, ExcNotImplemented());
-
-    // create a completely distributed vector that will be used for
-    // the scaled and denormalized solution and later used as a
-    // starting guess for the linear solver
-    LinearAlgebra::BlockVector linearized_stokes_initial_guess (sim.introspection.index_sets.stokes_partitioning,
-                                                                sim.mpi_communicator);
-
-    // copy the velocity and pressure from current_linearization_point into
-    // the vector linearized_stokes_initial_guess. We need to do the copy because
-    // linearized_stokes_variables has a different
-    // layout than current_linearization_point, which also contains all the
-    // other solution variables.
-    if (sim.assemble_newton_stokes_system == false)
-      {
-        linearized_stokes_initial_guess.block (block_vel) = sim.current_linearization_point.block (block_vel);
-        linearized_stokes_initial_guess.block (block_p) = sim.current_linearization_point.block (block_p);
-
-        sim.denormalize_pressure (sim.last_pressure_normalization_adjustment,
-                                  linearized_stokes_initial_guess,
-                                  sim.current_linearization_point);
-      }
-    else
-      {
-        // The Newton solver solves for updates to variables, for which our best guess is zero when
-        // the it isn't the first nonlinear iteration. When it is the first nonlinear iteration, we
-        // have to assemble the full (non-defect correction) Picard, to get the boundary conditions
-        // right in combination with being able to use the initial guess optimally. So we may never
-        // end up here when it is the first nonlinear iteration.
-        Assert(sim.nonlinear_iteration != 0,
-               ExcMessage ("The Newton solver may not be active in the first nonlinear iteration"));
-
-        linearized_stokes_initial_guess.block (block_vel) = 0;
-        linearized_stokes_initial_guess.block (block_p) = 0;
-      }
-
-    sim.current_constraints.set_zero (linearized_stokes_initial_guess);
-    linearized_stokes_initial_guess.block (block_p) /= sim.pressure_scaling;
-
-    double solver_tolerance = 0;
-    if (sim.assemble_newton_stokes_system == false)
-      {
-        // (ab)use the distributed solution vector to temporarily put a residual in
-        // (we don't care about the residual vector -- all we care about is the
-        // value (number) of the initial residual). The initial residual is returned
-        // to the caller (for nonlinear computations). This value is computed before
-        // the solve because we want to compute || A^{k+1} U^k - F^{k+1} ||, which is
-        // the nonlinear residual. Because the place where the nonlinear residual is
-        // checked against the nonlinear tolerance comes after the solve, the system
-        // is solved one time too many in the case of a nonlinear Picard solver.
-
-        // We must copy between Trilinos/dealii vector types
-        dealii::LinearAlgebra::distributed::BlockVector<double> solution_copy(2);
-        dealii::LinearAlgebra::distributed::BlockVector<double> initial_copy(2);
-        dealii::LinearAlgebra::distributed::BlockVector<double> rhs_copy(2);
-
-        stokes_matrix.initialize_dof_vector(solution_copy);
-        stokes_matrix.initialize_dof_vector(initial_copy);
-        stokes_matrix.initialize_dof_vector(rhs_copy);
-
-        internal::ChangeVectorTypes::copy(solution_copy,distributed_stokes_solution);
-        internal::ChangeVectorTypes::copy(initial_copy,linearized_stokes_initial_guess);
-        internal::ChangeVectorTypes::copy(rhs_copy,distributed_stokes_rhs);
-
-        // Compute residual l2_norm
-        stokes_matrix.vmult(solution_copy,initial_copy);
-        solution_copy.sadd(-1,1,rhs_copy);
-        initial_nonlinear_residual = solution_copy.l2_norm();
-
-        // Note: the residual is computed with a zero velocity, effectively computing
-        // || B^T p - g ||, which we are going to use for our solver tolerance.
-        // We do not use the current velocity for the initial residual because
-        // this would not decrease the number of iterations if we had a better
-        // initial guess (say using a smaller timestep). But we need to use
-        // the pressure instead of only using the norm of the rhs, because we
-        // are only interested in the part of the rhs not balanced by the static
-        // pressure (the current pressure is a good approximation for the static
-        // pressure).
-        initial_copy.block(0) = 0.;
-        stokes_matrix.vmult(solution_copy,initial_copy);
-        solution_copy.block(0).sadd(-1,1,rhs_copy.block(0));
-
-        const double residual_u = solution_copy.block(0).l2_norm();
-
-        const double residual_p = rhs_copy.block(1).l2_norm();
-
-        solver_tolerance = sim.parameters.linear_stokes_solver_tolerance *
-                           std::sqrt(residual_u*residual_u+residual_p*residual_p);
-      }
-    else
-      {
-        // if we are solving for the Newton update, then the initial guess of the solution
-        // vector is the zero vector, and the starting (nonlinear) residual is simply
-        // the norm of the (Newton) right hand side vector
-        const double residual_u = distributed_stokes_rhs.block(0).l2_norm();
-        const double residual_p = distributed_stokes_rhs.block(1).l2_norm();
-        solver_tolerance = sim.parameters.linear_stokes_solver_tolerance *
-                           std::sqrt(residual_u*residual_u+residual_p*residual_p);
-
-        // as described in the documentation of the function, the initial
-        // nonlinear residual for the Newton method is computed by just
-        // taking the norm of the right hand side
-        initial_nonlinear_residual = std::sqrt(residual_u*residual_u+residual_p*residual_p);
-      }
-
-    // Now overwrite the solution vector again with the current best guess
-    // to solve the linear system
-    distributed_stokes_solution = linearized_stokes_initial_guess;
-
-    // Again, copy solution and rhs vectors to solve with matrix-free operators
-    dealii::LinearAlgebra::distributed::BlockVector<double> solution_copy(2);
-    dealii::LinearAlgebra::distributed::BlockVector<double> rhs_copy(2);
-
-    stokes_matrix.initialize_dof_vector(solution_copy);
-    stokes_matrix.initialize_dof_vector(rhs_copy);
-
-    internal::ChangeVectorTypes::copy(solution_copy,distributed_stokes_solution);
-    internal::ChangeVectorTypes::copy(rhs_copy,distributed_stokes_rhs);
-
-    // create Solver controls for the cheap and expensive solver phase
-    SolverControl solver_control_cheap (sim.parameters.n_cheap_stokes_solver_steps,
-                                        solver_tolerance, true);
-    SolverControl solver_control_expensive (sim.parameters.n_expensive_stokes_solver_steps,
-                                            solver_tolerance);
-
-    solver_control_cheap.enable_history_data();
-    solver_control_expensive.enable_history_data();
-
-    // create a cheap preconditioner that consists of only a single V-cycle
-    const internal::BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType, GMGPreconditioner, GMGPreconditioner>
-    preconditioner_cheap (stokes_matrix, A_block_matrix, Schur_complement_block_matrix,
-                          prec_A, prec_Schur,
-                          /*do_solve_A*/false,
-                          /*do_solve_Schur*/false,
-                          sim.stokes_A_block_is_symmetric(),
-                          sim.parameters.linear_solver_A_block_tolerance,
-                          sim.parameters.linear_solver_S_block_tolerance);
-
-    // create an expensive preconditioner that solves for the A block with CG
-    const internal::BlockSchurGMGPreconditioner<StokesMatrixType, ABlockMatrixType, SchurComplementMatrixType, GMGPreconditioner, GMGPreconditioner>
-    preconditioner_expensive (stokes_matrix, A_block_matrix, Schur_complement_block_matrix,
-                              prec_A, prec_Schur,
-                              /*do_solve_A*/true,
-                              /*do_solve_Schur*/true,
-                              sim.stokes_A_block_is_symmetric(),
-                              sim.parameters.linear_solver_A_block_tolerance,
-                              sim.parameters.linear_solver_S_block_tolerance);
-
-    PrimitiveVectorMemory<dealii::LinearAlgebra::distributed::BlockVector<double>> mem;
-
-    // Time vmult of different matrix-free operators, solver IDR with the cheap preconditioner, and
-    // solver GMRES with the cheap preconditioner. Each timing is repeated 10 times, and the
-    // function may be called a couple of times within each timing, depending on the argument repeats.
-    if (do_timings)
-      {
-        const int n_timings = 10;
-        Timer timer(sim.mpi_communicator);
-
-        auto time_this = [&](const char *name, int repeats, const std::function<void()> &body, const std::function<void()> &prepare)
-        {
-          sim.pcout << "Timing " << name << ' ' << n_timings << " time(s) and repeat "
-                    << repeats << " time(s) within each timing:" << std::endl;
-
-          body(); // warm up
-
-          double average_time = 0.;
-
-          for (int i=0; i<n_timings; ++i)
-            {
-              prepare();
-              sim.pcout << "\t... " << std::flush;
-              timer.restart();
-
-              for (int r=0; r<repeats; ++r)
-                body();
-
-              timer.stop();
-              double time = timer.wall_time();
-              const double average_time_per_timing = time/repeats;
-              sim.pcout << average_time_per_timing << std::endl;
-              average_time += average_time_per_timing;
-            }
-
-          sim.pcout << "\taverage wall time of all: "<< average_time/n_timings << " seconds" << std::endl;
-
-        };
-
-        // stokes vmult
-        {
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
-          time_this("stokes_vmult", 10,
-                    [&] ()
-          {
-            stokes_matrix.vmult(tmp_dst, tmp_src);
-          },
-          [&] ()
-          {
-            tmp_src = tmp_dst;
-          }
-                   );
-        }
-
-        // stokes preconditioner
-        {
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
-          time_this("stokes_preconditioner", 1,
-                    [&] ()
-          {
-            preconditioner_cheap.vmult(tmp_dst, tmp_src);
-          },
-          [&] ()
-          {
-            tmp_src = tmp_dst;
-          }
-                   );
-        }
-        // A preconditioner
-        {
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
-          time_this("A_preconditioner", 1,
-                    [&] ()
-          {
-            prec_A.vmult(tmp_dst.block(0), tmp_src.block(0));
-          },
-          [&] ()
-          {
-            tmp_src = tmp_dst;
-          }
-                   );
-        }
-        // S preconditioner
-        {
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
-          time_this("S_preconditioner", 5,
-                    [&] ()
-          {
-            prec_Schur.vmult(tmp_dst.block(1), tmp_src.block(1));
-          },
-          [&] ()
-          {
-            tmp_src = tmp_dst;
-          }
-                   );
-        }
-        // Solve
-        {
-          // hard-code the number of iterations here to always do cheap iterations
-          SolverControl solver_control_cheap (1000, solver_tolerance, true);
-
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_dst = solution_copy;
-          dealii::LinearAlgebra::distributed::BlockVector<double> tmp_src = rhs_copy;
-          time_this("Stokes_solve_cheap_idr", 1,
-                    [&]
-          {
-            SolverIDR<dealii::LinearAlgebra::distributed::BlockVector<double>>
-            solver(solver_control_cheap, mem,
-            SolverIDR<dealii::LinearAlgebra::distributed::BlockVector<double>>::
-            AdditionalData(sim.parameters.idr_s_parameter));
-
-            solver.solve (stokes_matrix,
-            tmp_dst,
-            tmp_src,
-            preconditioner_cheap);
-          },
-          [&] ()
-          {
-            tmp_dst = solution_copy;
-          }
-                   );
-
-          time_this("Stokes_solve_cheap_gmres", 1,
-                    [&]
-          {
-            SolverGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>
-            solver(solver_control_cheap, mem,
-            SolverGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>::
-            AdditionalData(sim.parameters.stokes_gmres_restart_length+2,
-            true));
-
-            solver.solve (stokes_matrix,
-            tmp_dst,
-            tmp_src,
-            preconditioner_cheap);
-          },
-          [&] ()
-          {
-            tmp_dst = solution_copy;
-          }
-                   );
-        }
-      }
-
-    // step 1a: try if the simple and fast solver
-    // succeeds in n_cheap_stokes_solver_steps steps or less.
-    try
-      {
-        // if this cheaper solver is not desired, then simply short-cut
-        // the attempt at solving with the cheaper preconditioner
-        if (sim.parameters.n_cheap_stokes_solver_steps == 0)
-          throw SolverControl::NoConvergence(0,0);
-
-        // Unlike with the expensive preconditioner which uses CG solves on both the
-        // velocity and pressure space, the cheap preconditioner only contains matrix-vector
-        // products and GMG v-cycle where the smoothers, transfer operators, and coarse
-        // solvers are all defined to be linear operators which do not change from iteration
-        // to iteration. Therefore we can use non-flexible Krylov methods like GMRES or IDR(s),
-        // instead of requiring FGMRES, greatly lowing the memory requirement of the solver.
-        if (sim.parameters.stokes_krylov_type == Parameters<dim>::StokesKrylovType::gmres)
-          {
-            SolverGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>
-            solver(solver_control_cheap, mem,
-                   SolverGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>::
-                   AdditionalData(sim.parameters.stokes_gmres_restart_length+2,
-                                  true));
-
-            solver.solve (stokes_matrix,
-                          solution_copy,
-                          rhs_copy,
-                          preconditioner_cheap);
-          }
-        else if (sim.parameters.stokes_krylov_type == Parameters<dim>::StokesKrylovType::idr_s)
-          {
-            SolverIDR<dealii::LinearAlgebra::distributed::BlockVector<double>>
-            solver(solver_control_cheap, mem,
-                   SolverIDR<dealii::LinearAlgebra::distributed::BlockVector<double>>::
-                   AdditionalData(sim.parameters.idr_s_parameter));
-
-            solver.solve (stokes_matrix,
-                          solution_copy,
-                          rhs_copy,
-                          preconditioner_cheap);
-          }
-        else
-          Assert(false,ExcNotImplemented());
-
-        // Success. Print all iterations to screen (0 expensive iterations).
-        sim.pcout << (solver_control_cheap.last_step() != numbers::invalid_unsigned_int ?
-                      solver_control_cheap.last_step():
-                      0)
-                  << "+0"
-                  << " iterations." << std::endl;
-
-        final_linear_residual = solver_control_cheap.last_value();
-      }
-    // step 1b: take the stronger solver in case
-    // the simple solver failed and attempt solving
-    // it in n_expensive_stokes_solver_steps steps or less.
-    catch (const SolverControl::NoConvergence &exc)
-      {
-        // The cheap solver failed or never ran.
-        // Print the number of cheap iterations to screen to indicate we
-        // try the expensive solver next.
-        sim.pcout << (solver_control_cheap.last_step() != numbers::invalid_unsigned_int ?
-                      solver_control_cheap.last_step():
-                      0) << '+' << std::flush;
-
-        // use the value defined by the user
-        // OR
-        // at least a restart length of 100 for melt models
-        const unsigned int number_of_temporary_vectors = (sim.parameters.include_melt_transport == false ?
-                                                          sim.parameters.stokes_gmres_restart_length :
-                                                          std::max(sim.parameters.stokes_gmres_restart_length, 100U));
-
-        SolverFGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>
-        solver(solver_control_expensive, mem,
-               SolverFGMRES<dealii::LinearAlgebra::distributed::BlockVector<double>>::
-               AdditionalData(number_of_temporary_vectors));
-
-        try
-          {
-            // if no expensive steps allowed, we have failed
-            if (sim.parameters.n_expensive_stokes_solver_steps == 0)
-              {
-                sim.pcout << "0 iterations." << std::endl;
-                throw exc;
-              }
-
-            solver.solve(stokes_matrix,
-                         solution_copy,
-                         rhs_copy,
-                         preconditioner_expensive);
-
-            // Success. Print expensive iterations to screen.
-            sim.pcout << solver_control_expensive.last_step()
-                      << " iterations." << std::endl;
-
-            final_linear_residual = solver_control_expensive.last_value();
-          }
-        // if the solver fails trigger the post stokes solver signal and throw an exception
-        catch (const std::exception &exc)
-          {
-            sim.signals.post_stokes_solver(sim,
-                                           preconditioner_cheap.n_iterations_Schur_complement() + preconditioner_expensive.n_iterations_Schur_complement(),
-                                           preconditioner_cheap.n_iterations_A_block() + preconditioner_expensive.n_iterations_A_block(),
-                                           solver_control_cheap,
-                                           solver_control_expensive);
-
-            std::vector<SolverControl> solver_controls;
-            if (sim.parameters.n_cheap_stokes_solver_steps > 0)
-              solver_controls.push_back(solver_control_cheap);
-            if (sim.parameters.n_expensive_stokes_solver_steps > 0)
-              solver_controls.push_back(solver_control_expensive);
-
-            Utilities::throw_linear_solver_failure_exception("iterative Stokes solver",
-                                                             "StokesMatrixFreeHandlerImplementation::solve",
-                                                             solver_controls,
-                                                             exc,
-                                                             sim.mpi_communicator,
-                                                             sim.parameters.output_directory+"solver_history.txt");
-          }
-      }
-
-    //signal successful solver
-    sim.signals.post_stokes_solver(sim,
-                                   preconditioner_cheap.n_iterations_Schur_complement() + preconditioner_expensive.n_iterations_Schur_complement(),
-                                   preconditioner_cheap.n_iterations_A_block() + preconditioner_expensive.n_iterations_A_block(),
-                                   solver_control_cheap,
-                                   solver_control_expensive);
-
-    // distribute hanging node and other constraints
-    solution_copy.update_ghost_values();
-    internal::ChangeVectorTypes::copy(distributed_stokes_solution,solution_copy);
-
-#if DEAL_II_VERSION_GTE(9,6,0)
-    IndexSet stokes_dofs (sim.dof_handler.n_dofs());
-    stokes_dofs.add_range (0, distributed_stokes_solution.size());
-    const AffineConstraints<double> current_stokes_constraints
-      = sim.current_constraints.get_view (stokes_dofs);
-    current_stokes_constraints.distribute(distributed_stokes_solution);
-#else
-    sim.current_constraints.distribute(distributed_stokes_solution);
-#endif
-
-    // now rescale the pressure back to real physical units
-    distributed_stokes_solution.block(block_p) *= sim.pressure_scaling;
-
-    // then copy back the solution from the temporary (non-ghosted) vector
-    // into the ghosted one with all solution components
-    sim.solution.block(block_vel) = distributed_stokes_solution.block(block_vel);
-    sim.solution.block(block_p) = distributed_stokes_solution.block(block_p);
-
-    if (print_details)
-      {
-        sim.pcout << "    Schur complement preconditioner: " << preconditioner_cheap.n_iterations_Schur_complement()
-                  << '+'
-                  << preconditioner_expensive.n_iterations_Schur_complement()
-                  << " iterations." << std::endl;
-        sim.pcout << "    A block preconditioner: " << preconditioner_cheap.n_iterations_A_block()
-                  << '+'
-                  << preconditioner_expensive.n_iterations_A_block()
-                  << " iterations." << std::endl;
-      }
-
-    // do some cleanup now that we have the solution
-    sim.remove_nullspace(sim.solution, distributed_stokes_solution);
-    if (sim.assemble_newton_stokes_system == false)
-      sim.last_pressure_normalization_adjustment = sim.normalize_pressure(sim.solution);
-
-
-    // convert melt pressures
-    // TODO: We assert in the StokesMatrixFreeHandler constructor that we
-    //       are not including melt transport.
-    if (sim.parameters.include_melt_transport)
-      sim.melt_handler->compute_melt_variables(sim.system_matrix,sim.solution,sim.system_rhs);
-
-
-    return std::pair<double,double>(initial_nonlinear_residual,
-                                    final_linear_residual);
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::setup_dofs()
-  {
-    // Periodic boundary conditions with hanging nodes on the boundary currently
-    // cause the GMG not to converge. We catch this case early to provide the
-    // user with a reasonable error message:
-    {
-      bool have_periodic_hanging_nodes = false;
-      for (const auto &cell : sim.triangulation.active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (const auto f : cell->face_indices())
-            {
-              if (cell->has_periodic_neighbor(f))
-                {
-                  const auto &neighbor = cell->periodic_neighbor(f);
-                  // This way, we can only detect the case where the neighbor is coarser,
-                  // but this is fine as the other owner covers that situation:
-                  if (neighbor->level()<cell->level())
-                    have_periodic_hanging_nodes = true;
-                }
-            }
-
-      have_periodic_hanging_nodes = (dealii::Utilities::MPI::max(have_periodic_hanging_nodes ? 1 : 0, sim.triangulation.get_communicator())) == 1;
-      AssertThrow(have_periodic_hanging_nodes==false, ExcNotImplemented());
-    }
-
-    // This vector will be refilled with the new MatrixFree objects below:
-    matrix_free_objects.clear();
-
-    // Velocity DoFHandler
-    {
-      dof_handler_v.clear();
-      dof_handler_v.distribute_dofs(fe_v);
-
-      DoFRenumbering::hierarchical(dof_handler_v);
-
-      IndexSet locally_relevant_dofs;
-      DoFTools::extract_locally_relevant_dofs (dof_handler_v,
-                                               locally_relevant_dofs);
-#if DEAL_II_VERSION_GTE(9,6,0)
-      constraints_v.reinit(dof_handler_v.locally_owned_dofs(), locally_relevant_dofs);
-#else
-      constraints_v.reinit(locally_relevant_dofs);
-#endif
-
-      {
-        const auto &pbs = sim.geometry_model->get_periodic_boundary_pairs();
-
-        for (const auto &p: pbs)
-          {
-            DoFTools::make_periodicity_constraints(dof_handler_v,
-                                                   p.first.first,  // first boundary id
-                                                   p.first.second, // second boundary id
-                                                   p.second,       // cartesian direction for translational symmetry
-                                                   constraints_v);
-          }
-      }
-      DoFTools::make_hanging_node_constraints (dof_handler_v, constraints_v);
-      sim.compute_initial_velocity_boundary_constraints(constraints_v);
-      sim.compute_current_velocity_boundary_constraints(constraints_v);
-
-
-      VectorTools::compute_no_normal_flux_constraints (dof_handler_v,
-                                                       /* first_vector_component= */
-                                                       0,
-                                                       sim.boundary_velocity_manager.get_tangential_boundary_velocity_indicators(),
-                                                       constraints_v,
-                                                       *sim.mapping);
-      constraints_v.close ();
-    }
-
-    // Pressure DoFHandler
-    {
-      dof_handler_p.clear();
-      dof_handler_p.distribute_dofs(fe_p);
-
-      DoFRenumbering::hierarchical(dof_handler_p);
-
-      IndexSet locally_relevant_dofs;
-      DoFTools::extract_locally_relevant_dofs (dof_handler_p,
-                                               locally_relevant_dofs);
-      constraints_p.reinit(
-#if DEAL_II_VERSION_GTE(9,6,0)
-        dof_handler_p.locally_owned_dofs(),
-#endif
-        locally_relevant_dofs);
-      {
-        const auto &pbs = sim.geometry_model->get_periodic_boundary_pairs();
-
-        for (const auto &p: pbs)
-          {
-            DoFTools::make_periodicity_constraints(dof_handler_p,
-                                                   p.first.first,  // first boundary id
-                                                   p.first.second, // second boundary id
-                                                   p.second,       // cartesian direction for translational symmetry
-                                                   constraints_p);
-          }
-      }
-      DoFTools::make_hanging_node_constraints (dof_handler_p, constraints_p);
-      constraints_p.close();
-    }
-
-    // Coefficient transfer objects
-    {
-      dof_handler_projection.clear();
-      dof_handler_projection.distribute_dofs(fe_projection);
-
-      DoFRenumbering::hierarchical(dof_handler_projection);
-    }
-
-    // Multigrid DoF setup
-    {
-      //Ablock GMG
-      dof_handler_v.distribute_mg_dofs();
-
-      mg_constrained_dofs_A_block.clear();
-      mg_constrained_dofs_A_block.initialize(dof_handler_v);
-
-      std::set<types::boundary_id> dirichlet_boundary = sim.boundary_velocity_manager.get_zero_boundary_velocity_indicators();
-      for (const auto &it: sim.boundary_velocity_manager.get_active_boundary_velocity_names())
-        {
-          const types::boundary_id bdryid = it.first;
-          const std::string component=it.second.first;
-
-          if (component.length()>0)
-            {
-              std::vector<bool> mask(fe_v.n_components(), false);
-              for (const auto &direction : component)
-                {
-                  switch (direction)
-                    {
-                      case 'x':
-                        mask[0] = true;
-                        break;
-                      case 'y':
-                        mask[1] = true;
-                        break;
-                      case 'z':
-                        // we must be in 3d, or 'z' should never have gotten through
-                        Assert (dim==3, ExcInternalError());
-                        if (dim==3)
-                          mask[2] = true;
-                        break;
-                      default:
-                        Assert (false, ExcInternalError());
-                    }
-                }
-              mg_constrained_dofs_A_block.make_zero_boundary_constraints(dof_handler_v, {bdryid}, ComponentMask(mask));
-            }
-          else
-            {
-              // no mask given: add at the end
-              dirichlet_boundary.insert(bdryid);
-            }
-        }
-
-      // Unconditionally call this function, even if the set is empty. Otherwise, the data structure
-      // for boundary indices will not be created (if mesh has no Dirichlet conditions).
-      mg_constrained_dofs_A_block.make_zero_boundary_constraints(dof_handler_v, dirichlet_boundary);
-
-      //Schur complement matrix GMG
-      dof_handler_p.distribute_mg_dofs();
-
-      mg_constrained_dofs_Schur_complement.clear();
-      mg_constrained_dofs_Schur_complement.initialize(dof_handler_p);
-
-      dof_handler_projection.distribute_mg_dofs();
-    }
-
-    // Setup the matrix-free operators
-    std::shared_ptr<MatrixFree<dim,double>> matrix_free = std::make_shared<MatrixFree<dim,double>>();
-    matrix_free_objects.push_back(matrix_free);
-
-    // Matrixfree object
-    {
-      typename MatrixFree<dim,double>::AdditionalData additional_data;
-      additional_data.tasks_parallel_scheme = MatrixFree<dim,double>::AdditionalData::none;
-      additional_data.mapping_update_flags = (update_gradients | update_JxW_values);
-
-      if (sim.mesh_deformation
-          && !sim.mesh_deformation->get_free_surface_boundary_indicators().empty())
-        additional_data.mapping_update_flags_boundary_faces =
-          (update_values  |
-           update_quadrature_points |
-           update_normal_vectors |
-           update_JxW_values);
-
-      std::vector<const DoFHandler<dim>*> stokes_dofs {&dof_handler_v, &dof_handler_p};
-      std::vector<const AffineConstraints<double> *> stokes_constraints {&constraints_v, &constraints_p};
-
-      matrix_free->reinit(*sim.mapping, stokes_dofs, stokes_constraints,
-                          QGauss<1>(sim.parameters.stokes_velocity_degree+1), additional_data);
-    }
-
-    // Stokes matrix
-    {
-      stokes_matrix.clear();
-      stokes_matrix.initialize(matrix_free);
-    }
-
-    // ABlock matrix
-    {
-      A_block_matrix.clear();
-      std::vector<unsigned int> selected = {0}; // select velocity DoFHandler
-      A_block_matrix.initialize(matrix_free, selected);
-    }
-
-    // Schur complement block matrix
-    {
-      Schur_complement_block_matrix.clear();
-      std::vector< unsigned int > selected = {1}; // select pressure DoFHandler
-      Schur_complement_block_matrix.initialize(matrix_free, selected , selected);
-    }
-
-    // GMG matrices
-    {
-      const unsigned int n_levels = sim.triangulation.n_global_levels();
-
-      mg_matrices_Schur_complement.clear_elements();
-      mg_matrices_Schur_complement.resize(0, n_levels-1);
-      mg_matrices_A_block.clear_elements();
-      mg_matrices_A_block.resize(0, n_levels-1);
-
-      for (unsigned int level=0; level<n_levels; ++level)
-        {
-          AffineConstraints<double> level_constraints_v;
-          AffineConstraints<double> level_constraints_p;
-          const Mapping<dim> &mapping =
-            (sim.mesh_deformation) ? sim.mesh_deformation->get_level_mapping(level) : *sim.mapping;
-
-          {
-            IndexSet relevant_dofs;
-            DoFTools::extract_locally_relevant_level_dofs(dof_handler_v, level, relevant_dofs);
-#if DEAL_II_VERSION_GTE(9,6,0)
-            level_constraints_v.reinit(dof_handler_v.locally_owned_mg_dofs(level), relevant_dofs);
-            for (const auto index : mg_constrained_dofs_A_block.get_boundary_indices(level))
-              level_constraints_v.constrain_dof_to_zero(index);
-#else
-            level_constraints_v.reinit(relevant_dofs);
-            level_constraints_v.add_lines(mg_constrained_dofs_A_block.get_boundary_indices(level));
-#endif
-            level_constraints_v.close();
-
-            std::set<types::boundary_id> no_flux_boundary
-              = sim.boundary_velocity_manager.get_tangential_boundary_velocity_indicators();
-            if (!no_flux_boundary.empty())
-              {
-                AffineConstraints<double> user_level_constraints;
-#if DEAL_II_VERSION_GTE(9,6,0)
-                user_level_constraints.reinit(dof_handler_v.locally_owned_mg_dofs(level), relevant_dofs);
-#else
-                user_level_constraints.reinit(relevant_dofs);
-#endif
-                const IndexSet &refinement_edge_indices =
-                  mg_constrained_dofs_A_block.get_refinement_edge_indices(level);
-                dealii::VectorTools::compute_no_normal_flux_constraints_on_level(
-                  dof_handler_v,
-                  0,
-                  no_flux_boundary,
-                  user_level_constraints,
-                  mapping,
-                  refinement_edge_indices,
-                  level);
-
-                user_level_constraints.close();
-                mg_constrained_dofs_A_block.add_user_constraints(level,user_level_constraints);
-
-                // let Dirichlet values win over no normal flux:
-                level_constraints_v.merge(user_level_constraints, AffineConstraints<double>::left_object_wins);
-                level_constraints_v.close();
-              }
-          }
-          {
-            IndexSet relevant_dofs;
-            DoFTools::extract_locally_relevant_level_dofs(dof_handler_p, level, relevant_dofs);
-
-#if DEAL_II_VERSION_GTE(9,6,0)
-            level_constraints_p.reinit(dof_handler_p.locally_owned_mg_dofs(level), relevant_dofs);
-#else
-            level_constraints_p.reinit(relevant_dofs);
-#endif
-
-            level_constraints_p.close();
-          }
-
-          std::shared_ptr<MatrixFree<dim,GMGNumberType>> matrix_free_level = std::make_shared<MatrixFree<dim,GMGNumberType>>();
-          matrix_free_objects.push_back(matrix_free_level);
-
-          {
-            typename MatrixFree<dim,GMGNumberType>::AdditionalData additional_data;
-            additional_data.tasks_parallel_scheme = MatrixFree<dim,GMGNumberType>::AdditionalData::none;
-            additional_data.mapping_update_flags = (update_gradients | update_JxW_values);
-            additional_data.mg_level = level;
-
-            std::vector<const DoFHandler<dim>*> stokes_dofs {&dof_handler_v, &dof_handler_p};
-            std::vector<const AffineConstraints<double> *> stokes_constraints {&level_constraints_v,&level_constraints_p};
-
-            matrix_free_level->reinit(mapping,
-                                      stokes_dofs, stokes_constraints,
-                                      QGauss<1>(sim.parameters.stokes_velocity_degree+1),
-                                      additional_data);
-          }
-          {
-            mg_matrices_A_block[level].clear();
-            std::vector<unsigned int> selected = {0}; // select velocity DoFHandler
-            mg_matrices_A_block[level].initialize(matrix_free_level, mg_constrained_dofs_A_block, level, selected);
-          }
-          {
-            mg_matrices_Schur_complement[level].clear();
-            std::vector<unsigned int> selected = {1}; // select pressure DoFHandler
-            mg_matrices_Schur_complement[level].initialize(matrix_free_level, mg_constrained_dofs_Schur_complement, level, selected);
-          }
-        }
-    }
-
-    // Build MG transfer
-    mg_transfer_A_block.clear();
-    mg_transfer_A_block.initialize_constraints(mg_constrained_dofs_A_block);
-    mg_transfer_A_block.build(dof_handler_v);
-
-    mg_transfer_Schur_complement.clear();
-    mg_transfer_Schur_complement.initialize_constraints(mg_constrained_dofs_Schur_complement);
-    mg_transfer_Schur_complement.build(dof_handler_p);
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  void StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::build_preconditioner()
-  {
-    TimerOutput::Scope timer (this->sim.computing_timer, "Build Stokes preconditioner");
-
-    for (unsigned int level=0; level < sim.triangulation.n_global_levels(); ++level)
-      {
-        mg_matrices_Schur_complement[level].compute_diagonal();
-        mg_matrices_A_block[level].compute_diagonal();
-      }
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  const DoFHandler<dim> &
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_dof_handler_v () const
-  {
-    return dof_handler_v;
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  const DoFHandler<dim> &
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_dof_handler_p () const
-  {
-    return dof_handler_p;
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  const DoFHandler<dim> &
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_dof_handler_projection () const
-  {
-    return dof_handler_projection;
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  const AffineConstraints<double> &
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_constraints_v() const
-  {
-    return constraints_v;
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  const AffineConstraints<double> &
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_constraints_p() const
-  {
-    return constraints_p;
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  const MGTransferMF<dim,GMGNumberType> &
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_mg_transfer_A() const
-  {
-    return mg_transfer_A_block;
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  const MGTransferMF<dim,GMGNumberType> &
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>::get_mg_transfer_S() const
-  {
-    return mg_transfer_Schur_complement;
-  }
-
-
-
-  template <int dim, int velocity_degree>
-  std::size_t
-  StokesMatrixFreeHandlerImplementation<dim, velocity_degree>:: get_cell_data_memory_consumption() const
-  {
-    std::size_t total = active_cell_data.memory_consumption();
-
-    for (unsigned int level=0; level<level_cell_data.max_level(); ++level)
-      total += level_cell_data[level].memory_consumption();
-
-    return total;
-  }
-
-
-
-// explicit instantiation of the functions we implement in this file
-#define INSTANTIATE(dim) \
-  template class StokesMatrixFreeHandler<dim>; \
-  template class StokesMatrixFreeHandlerImplementation<dim,2>; \
-  template class StokesMatrixFreeHandlerImplementation<dim,3>;
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/structured_data.cc.bak b/source/structured_data.cc.bak
deleted file mode 100644
index 62da14cd9b8..00000000000
--- a/source/structured_data.cc.bak
+++ /dev/null
@@ -1,1952 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/global.h>
-#include <aspect/structured_data.h>
-
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/geometry_model/sphere.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/two_merged_chunks.h>
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-#include <aspect/geometry_model/initial_topography_model/ascii_data.h>
-#include <aspect/geometry_model/two_merged_chunks.h>
-
-#include <deal.II/base/exceptions.h>
-
-#include <boost/lexical_cast.hpp>
-#include <regex>
-
-#ifdef ASPECT_WITH_NETCDF
-
-#include <netcdf.h>
-#define AssertThrowNetCDF(error_code) \
-  AssertThrow(error_code == NC_NOERR, dealii::ExcMessage("A NetCDF Error with code " + std::to_string(error_code) + " occurred."))
-
-#else
-
-#define AssertThrowNetCDF(error_code) \
-  AssertThrow(false, ExcInternalError())
-
-#endif
-
-
-
-namespace aspect
-{
-  namespace Utilities
-  {
-
-    template <int dim>
-    StructuredDataLookup<dim>::StructuredDataLookup(const unsigned int n_components,
-                                                    const double scale_factor)
-      :
-      n_components(n_components),
-      data(n_components),
-      maximum_component_value(n_components),
-      scale_factor(scale_factor),
-      coordinate_values_are_equidistant(false)
-    {}
-
-
-
-    template <int dim>
-    StructuredDataLookup<dim>::StructuredDataLookup(const double scale_factor)
-      :
-      n_components(numbers::invalid_unsigned_int),
-      data(),
-      maximum_component_value(),
-      scale_factor(scale_factor),
-      coordinate_values_are_equidistant(false)
-    {}
-
-
-
-    template <int dim>
-    std::vector<std::string>
-    StructuredDataLookup<dim>::get_column_names() const
-    {
-      return data_component_names;
-    }
-
-
-
-    template <int dim>
-    bool
-    StructuredDataLookup<dim>::has_equidistant_coordinates() const
-    {
-      return coordinate_values_are_equidistant;
-    }
-
-
-
-    template <int dim>
-    const std::vector<double> &
-    StructuredDataLookup<dim>::get_interpolation_point_coordinates(const unsigned int dimension) const
-    {
-      AssertThrow(dimension < dim,
-                  ExcMessage("There is no spatial dimension number " + std::to_string(dimension)
-                             + " in the current data file."));
-
-      return coordinate_values[dimension];
-    }
-
-
-
-    template <int dim>
-    unsigned int
-    StructuredDataLookup<dim>::get_column_index_from_name(const std::string &column_name) const
-    {
-      const std::vector<std::string>::const_iterator column_position =
-        std::find(data_component_names.begin(),data_component_names.end(),column_name);
-
-      AssertThrow(column_position != data_component_names.end(),
-                  ExcMessage("There is no data column named " + column_name
-                             + " in the current data file. Please check the name and the "
-                             "first line not starting with '#' of your data file."));
-
-      return std::distance(data_component_names.begin(),column_position);
-    }
-
-    template <int dim>
-    std::string
-    StructuredDataLookup<dim>::get_column_name_from_index(const unsigned int column_index) const
-    {
-      AssertThrow(data_component_names.size() > column_index,
-                  ExcMessage("There is no data column number " + Utilities::to_string(column_index)
-                             + " in the current data file. The data file only contains "
-                             + Utilities::to_string(data_component_names.size()) + " named columns."));
-
-      return data_component_names[column_index];
-    }
-
-    template <int dim>
-    double
-    StructuredDataLookup<dim>::get_maximum_component_value(const unsigned int component) const
-    {
-      return maximum_component_value[component];
-    }
-
-
-
-    namespace
-    {
-      /**
-       * Return whether a set of coordinate points in dim space dimensions
-       * are all equidistantly spaced within some small tolerance.
-       */
-      template <int dim>
-      bool data_is_equidistant (const std::array<std::vector<double>,dim> &coordinate_values)
-      {
-        bool coordinate_values_are_equidistant = true;
-
-        for (unsigned int d=0; d<dim; ++d)
-          {
-            const double grid_spacing = coordinate_values[d][1] - coordinate_values[d][0];
-
-            for (unsigned int n = 1; n < coordinate_values[d].size(); ++n)
-              {
-                const double current_grid_spacing = coordinate_values[d][n] - coordinate_values[d][n-1];
-
-                AssertThrow(current_grid_spacing > 0.0,
-                            ExcMessage ("Coordinates in dimension "
-                                        + Utilities::int_to_string(d)
-                                        + " are not strictly ascending."));
-
-                // If spacing between coordinates changed (with a relative
-                // tolerance), keep track of that information.  Note that we do
-                // not break out of this loop in this case but run through the
-                // whole array, so that the AssertThrow above is executed for
-                // each entry to ensure increasing coordinate values.
-                if (std::abs(current_grid_spacing - grid_spacing) > 0.005*(current_grid_spacing+grid_spacing))
-                  coordinate_values_are_equidistant = false;
-              }
-          }
-
-        return coordinate_values_are_equidistant;
-      }
-    }
-
-
-    template <int dim>
-    void
-    StructuredDataLookup<dim>::reinit(const std::vector<std::string> &column_names,
-                                      std::vector<std::vector<double>> &&coordinate_values_,
-                                      std::vector<Table<dim,double>> &&data_table,
-                                      const MPI_Comm mpi_communicator,
-                                      const unsigned int root_process)
-    {
-      // If this is the root process, or if the user did not request
-      // sharing, set up the various member variables we need to compute
-      // from the input data:
-      if ((root_process == numbers::invalid_unsigned_int)
-          ||
-          ((root_process != numbers::invalid_unsigned_int)
-           &&
-           (Utilities::MPI::this_mpi_process(mpi_communicator) == root_process)))
-        {
-          Assert(coordinate_values_.size()==dim, ExcMessage("Invalid size of coordinate_values."));
-          for (unsigned int d=0; d<dim; ++d)
-            {
-              this->coordinate_values[d] = std::move(coordinate_values_[d]);
-              AssertThrow(this->coordinate_values[d].size()>1,
-                          ExcMessage("Error: At least 2 entries per coordinate direction are required."));
-              table_points[d] = this->coordinate_values[d].size();
-            }
-
-          n_components = column_names.size();
-          data_component_names = column_names;
-          Assert(data_table.size() == n_components,
-                 ExcMessage("Error: Incorrect number of columns specified."));
-          for (unsigned int c=0; c<n_components; ++c)
-            Assert(data_table[c].size() == table_points,
-                   ExcMessage("Error: One of the data tables has an incorrect size."));
-
-          // compute maximum_component_value for each component:
-          maximum_component_value = std::vector<double>(n_components,-std::numeric_limits<double>::max());
-          for (unsigned int c=0; c<n_components; ++c)
-            {
-              const std::size_t n_elements = data_table[c].n_elements();
-              for (std::size_t idx=0; idx<n_elements; ++idx)
-                maximum_component_value[c] = std::max(maximum_component_value[c], data_table[c](
-                                                        compute_table_indices(table_points, idx)));
-            }
-
-          // In case the data is specified on a grid that is equidistant
-          // in each coordinate direction, we only need to store
-          // (besides the data) the number of intervals in each direction and
-          // the begin- and end-points of the coordinates.
-          // In case the grid is not equidistant, we need to keep
-          // all the coordinates in each direction, which is more costly.
-          coordinate_values_are_equidistant = data_is_equidistant<dim> (coordinate_values);
-        }
-
-      // If the caller of this function requested it, then we have
-      // set up member variables on the root process, but not on any of
-      // the other processes. Broadcast the data to the remaining
-      // processes
-      if (root_process != numbers::invalid_unsigned_int)
-        {
-          coordinate_values                 = Utilities::MPI::broadcast (mpi_communicator,
-                                                                         coordinate_values,
-                                                                         root_process);
-          n_components                        = Utilities::MPI::broadcast (mpi_communicator,
-                                                                           n_components,
-                                                                           root_process);
-          data_component_names              = Utilities::MPI::broadcast (mpi_communicator,
-                                                                         data_component_names,
-                                                                         root_process);
-          maximum_component_value           = Utilities::MPI::broadcast (mpi_communicator,
-                                                                         maximum_component_value,
-                                                                         root_process);
-          coordinate_values_are_equidistant = Utilities::MPI::broadcast (mpi_communicator,
-                                                                         coordinate_values_are_equidistant,
-                                                                         root_process);
-          table_points                      = Utilities::MPI::broadcast (mpi_communicator,
-                                                                         table_points,
-                                                                         root_process);
-
-          // We can then also prepare the data tables for sharing between
-          // processes
-          for (unsigned int c = 0; c < n_components; ++c)
-            data_table[c].replicate_across_communicator (mpi_communicator,
-                                                         root_process);
-        }
-
-      Assert(data_table.size() == n_components,
-             ExcMessage("Error: Incorrect number of columns specified."));
-      for (unsigned int c=0; c<n_components; ++c)
-        Assert(data_table[c].size() == table_points,
-               ExcMessage("Error: One of the data tables has an incorrect size."));
-
-
-      // For each data component, set up a GridData,
-      // its type depending on the read-in grid.
-      data.resize(n_components);
-      for (unsigned int c = 0; c < n_components; ++c)
-        {
-          if (coordinate_values_are_equidistant)
-            {
-              std::array<unsigned int,dim> table_intervals;
-              for (unsigned int d=0; d<dim; ++d)
-                table_intervals[d] = table_points[d]-1;
-
-              // The min and max of the coordinates in the data file.
-              std::array<std::pair<double,double>,dim> grid_extent;
-              for (unsigned int d=0; d<dim; ++d)
-                {
-                  grid_extent[d].first = coordinate_values[d][0];
-                  grid_extent[d].second = coordinate_values[d][table_points[d]-1];
-
-                  Assert(table_intervals[d] >= 1,
-                         ExcMessage("There needs to be at least one subinterval in each "
-                                    "coordinate direction."));
-                  Assert(grid_extent[d].first <
-                         grid_extent[d].second,
-                         ExcMessage("The interval in each coordinate direction needs "
-                                    "to have positive size"));
-                }
-
-              data[c]
-                = std::make_unique<Functions::InterpolatedUniformGridData<dim>> (std::move(grid_extent),
-                                                                                  std::move(table_intervals),
-                                                                                  std::move(data_table[c]));
-            }
-          else
-            // Create the object and move the big objects. Due to an old design flaw,
-            // the current class stores a copy of the 'coordinate_values' and some
-            // plugins actually use it too, i.e., we can't move the data out of
-            // this object. In another design flaw, the deal.II classes
-            // do not make the coordinate values accessible, so we have to continue
-            // storing a copy. In other words, we can't just move stuff --
-            // we have to make a copy of 'coordinate_values' and then move
-            // that copy.
-            //
-            // (The call to std::move on the first argument is unnecessary: We
-            // create a temporary object, and that's an rvalue that the constructor
-            // we call would bind to. But never a bad idea to be explicit.)
-            data[c]
-              = std::make_unique<Functions::InterpolatedTensorProductGridData<dim>>
-                (std::move(std::array<std::vector<double>,dim>(this->coordinate_values)),
-                 std::move(data_table[c]));
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StructuredDataLookup<dim>::load_ascii(const std::string &filename,
-                                          const MPI_Comm comm)
-    {
-      const unsigned int root_process = 0;
-
-      std::vector<std::string> column_names;
-      std::vector<Table<dim,double>> data_tables;
-      std::vector<std::vector<double>> coordinate_values(dim);
-
-      // If this is the root process, set up the various member variables we need to compute
-      // from the input data
-      if (Utilities::MPI::this_mpi_process(comm) == root_process)
-        {
-          // Grab the values already stored in this class (if they exist), this way we can
-          // check if somebody changes the size of the table over time and error out (see below)
-          TableIndices<dim> new_table_points = this->table_points;
-
-          // We do not need to distribute the contents as we are using shared data
-          // to place it later. Therefore, just pass MPI_COMM_SELF (i.e.,
-          // a communicator with just a single MPI process) and no distribution
-          // will happen.
-          std::stringstream in(read_and_distribute_file_content(filename,
-                                                                MPI_COMM_SELF));
-
-          // Read header lines and table size
-          while (in.peek() == '#')
-            {
-              std::string line;
-              std::getline(in,line);
-              std::stringstream linestream(line);
-              std::string word;
-              while (linestream >> word)
-                if (word == "POINTS:")
-                  for (unsigned int i = 0; i < dim; ++i)
-                    {
-                      unsigned int temp_index;
-                      linestream >> temp_index;
-
-                      if (new_table_points[i] == 0)
-                        new_table_points[i] = temp_index;
-                      else
-                        AssertThrow (new_table_points[i] == temp_index,
-                                     ExcMessage("The file grid must not change over model runtime. "
-                                                "Either you prescribed a conflicting number of points in "
-                                                "the input file, or the POINTS comment in your data files "
-                                                "is changing between following files."));
-                    }
-            }
-
-          for (unsigned int i = 0; i < dim; ++i)
-            {
-              AssertThrow(new_table_points[i] != 0,
-                          ExcMessage("Could not successfully read in the file header of the "
-                                     "ascii data file <" + filename + ">. One header line has to "
-                                     "be of the format: '#POINTS: N1 [N2] [N3]', where N1 and "
-                                     "potentially N2 and N3 have to be the number of data points "
-                                     "in their respective dimension. Check for typos in this line "
-                                     "(e.g. a missing space character)."));
-            }
-
-          // Read column lines if present
-          unsigned int name_column_index = 0;
-          double temp_data;
-
-          while (true)
-            {
-              AssertThrow (name_column_index < 100,
-                           ExcMessage("The program found more than 100 columns in the first line of the data file. "
-                                      "This is unlikely intentional. Check your data file and make sure the data can be "
-                                      "interpreted as floating point numbers. If you do want to read a data file with more "
-                                      "than 100 columns, please remove this assertion."));
-
-              std::string column_name_or_data;
-              in >> column_name_or_data;
-              try
-                {
-                  // If the data field contains a name this will throw an exception
-                  temp_data = boost::lexical_cast<double>(column_name_or_data);
-
-                  // If there was no exception we have left the line containing names
-                  // and have read the first data field. Save number of n_components, and
-                  // make sure there is no contradiction if the n_components were already given to
-                  // the constructor of this class.
-                  if (n_components == numbers::invalid_unsigned_int)
-                    n_components = name_column_index - dim;
-                  else if (name_column_index != 0)
-                    AssertThrow (n_components+dim == name_column_index,
-                                 ExcMessage("The number of expected data columns and the "
-                                            "list of column names at the beginning of the data file "
-                                            + filename + " do not match. The file should contain "
-                                            + Utilities::int_to_string(name_column_index) + " column "
-                                            "names (one for each dimension and one per data column), "
-                                            "but it only has " + Utilities::int_to_string(n_components+dim) +
-                                            " column names."));
-                  break;
-                }
-              catch (const boost::bad_lexical_cast &e)
-                {
-                  // The first dim columns are coordinates and contain no data
-                  if (name_column_index >= dim)
-                    {
-                      // Transform name to lower case to prevent confusion with capital letters
-                      // Note: only ASCII characters allowed
-                      std::transform(column_name_or_data.begin(), column_name_or_data.end(), column_name_or_data.begin(), ::tolower);
-
-                      AssertThrow(std::find(column_names.begin(),column_names.end(),column_name_or_data)
-                                  == column_names.end(),
-                                  ExcMessage("There are multiple fields named " + column_name_or_data +
-                                             " in the data file " + filename + ". Please remove duplication to "
-                                             "allow for unique association between column and name."));
-
-                      column_names.push_back(column_name_or_data);
-                    }
-                  ++name_column_index;
-                }
-            }
-
-          // Create table for the data. This peculiar reinit is necessary, because
-          // there is no constructor for Table, which takes TableIndices as
-          // argument.
-          Table<dim,double> data_table;
-          data_table.TableBase<dim,double>::reinit(new_table_points);
-          AssertThrow (n_components != numbers::invalid_unsigned_int,
-                       ExcMessage("ERROR: number of n_components in " + filename + " could not be "
-                                  "determined automatically. Either add a header with column "
-                                  "names or pass the number of columns in the StructuredData "
-                                  "constructor."));
-          data_tables.resize(n_components, data_table);
-
-          for (unsigned int d=0; d<dim; ++d)
-            coordinate_values[d].resize(new_table_points[d]);
-
-          if (column_names.size()==0)
-            {
-              // set default column names:
-              for (unsigned int c=0; c<n_components; ++c)
-                column_names.push_back("column " + Utilities::int_to_string(c,2));
-            }
-
-          // Make sure the data file actually has as many columns as we think it has
-          // (either based on the header, or based on what was passed to the constructor).
-          const std::streampos position = in.tellg();
-          std::string first_data_row;
-          std::getline(in, first_data_row);
-          std::stringstream linestream(first_data_row);
-          std::string column_entry;
-
-          // We have already read in the first data entry above in the try/catch block,
-          // so there's one more column in the file than in the line we just read in.
-          unsigned int number_of_entries = 1;
-          while (linestream >> column_entry)
-            number_of_entries += 1;
-
-          AssertThrow ((number_of_entries) == column_names.size()+dim,
-                       ExcMessage("ERROR: The number of columns in the data file " + filename +
-                                  " is incorrect. It needs to have " + Utilities::int_to_string(column_names.size()+dim) +
-                                  " columns, but the first row has " + Utilities::int_to_string(number_of_entries) +
-                                  " columns."));
-
-          // Go back to the position in the file where we started the check for the column numbers.
-          in.seekg (position);
-
-          // Finally read data lines:
-          std::size_t read_data_entries = 0;
-          do
-            {
-              // what row and column of the file are we in?
-              const std::size_t column_num = read_data_entries%(n_components+dim);
-              const std::size_t row_num = read_data_entries/(n_components+dim);
-              const TableIndices<dim> idx = compute_table_indices(new_table_points, row_num);
-
-              if (column_num < dim)
-                {
-                  // This is a coordinate. Store (and check that they are consistent)
-                  const double old_value = coordinate_values[column_num][idx[column_num]];
-
-                  AssertThrow(old_value == 0. ||
-                              (std::abs(old_value-temp_data) < 1e-8*std::abs(old_value)),
-                              ExcMessage("Invalid coordinate in column "
-                                         + Utilities::int_to_string(column_num) + " in row "
-                                         + Utilities::int_to_string(row_num)
-                                         + " in file " + filename +
-                                         "\nThis class expects the coordinates to be structured, meaning "
-                                         "the coordinate values in each coordinate direction repeat exactly "
-                                         "each time. This also means each row in the data file has to have "
-                                         "the same number of columns as the first row containing data."));
-
-                  coordinate_values[column_num][idx[column_num]] = temp_data;
-                }
-              else
-                {
-                  // This is a data value, so scale and store:
-                  const unsigned int component = column_num - dim;
-                  data_tables[component](idx) = temp_data * scale_factor;
-                }
-
-              ++read_data_entries;
-            }
-          while (in >> temp_data);
-
-          AssertThrow(in.eof(),
-                      ExcMessage ("While reading the data file '" + filename + "' the ascii data "
-                                  "plugin has encountered an error before the end of the file. "
-                                  "Please check for malformed data values (e.g. NaN) or superfluous "
-                                  "lines at the end of the data file."));
-
-          const std::size_t n_expected_data_entries = (n_components + dim) * data_table.n_elements();
-          AssertThrow(read_data_entries == n_expected_data_entries,
-                      ExcMessage ("While reading the data file '" + filename + "' the ascii data "
-                                  "plugin has reached the end of the file, but has not found the "
-                                  "expected number of data values considering the spatial dimension, "
-                                  "data columns, and number of lines prescribed by the POINTS header "
-                                  "of the file. Please check the number of data "
-                                  "lines against the POINTS header in the file."));
-        }
-
-      // deal.II supports sharing data (since 9.4), so we have to
-      // set up member variables on the root process, but not on any of
-      // the other processes. So broadcast the data to the remaining
-      // processes -- the code above really only wrote into one
-      // member variable ('n_components'), so that is the only one we
-      // have to broadcast.
-      //
-      // The first three arguments to the call to reinit() below will
-      // only be read on the root process, and so it is totally ok
-      // that we are passing empty tables on all other processes. In
-      // the case of 'data_table', we do have to make sure that it is
-      // an array of the right size, though, even though the array
-      // contains only empty tables.
-      {
-        n_components = Utilities::MPI::broadcast (comm,
-                                                  n_components,
-                                                  root_process);
-        coordinate_values = Utilities::MPI::broadcast (comm,
-                                                       coordinate_values,
-                                                       root_process);
-        column_names = Utilities::MPI::broadcast (comm,
-                                                  column_names,
-                                                  root_process);
-
-        if (Utilities::MPI::this_mpi_process(comm) != root_process)
-          data_tables.resize (n_components);
-      }
-
-      // Finally create the data. We want to call the move-version of reinit() so
-      // that the data doesn't have to be copied, so use std::move on all big
-      // objects.
-      this->reinit(column_names,
-                   std::move(coordinate_values),
-                   std::move(data_tables),
-                   comm,
-                   root_process);
-    }
-
-
-
-    template <int dim>
-    void
-    StructuredDataLookup<dim>::load_netcdf(const std::string &filename, const std::vector<std::string> &data_column_names_)
-    {
-#ifndef ASPECT_WITH_NETCDF
-      (void)filename;
-      (void)data_column_names_;
-      AssertThrow(false, ExcMessage("Loading NetCDF files is only supported if ASPECT is configured with the NetCDF library!"));
-#else
-      TableIndices<dim> new_table_points;
-      std::vector<std::string> coordinate_column_names(dim);
-      std::vector<Table<dim,double>> data_tables;
-      std::vector<std::string> data_column_names = data_column_names_;
-      std::vector<std::vector<double>> coordinate_values(dim);
-
-      int ncid;
-      int status;
-
-      status = nc_open(filename.c_str(), NC_NOWRITE, &ncid);
-      AssertThrowNetCDF(status);
-
-      int ndims, nvars, ngatts, unlimdimid;
-      status = nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid);
-      AssertThrowNetCDF(status);
-
-      // The number of dimensions ndims in the netcdf file can be
-      // different than dim. In fact, each variable (data column in
-      // our notation) has a subset of those dimensions associated
-      // with it. That also means that variables can have a different
-      // number of dimensions and/or a different subset. We can only
-      // use variables with dim dimensions (our template argument) and
-      // only those that all use the same dimids inside the netcdf
-      // file.
-      int dimids_to_use[dim] = {}; // dimids of the coordinate columns to use
-      std::vector<int> varids_to_use; // all netCDF varids of the data columns
-
-      if (data_column_names.empty())
-        {
-          // The user did not ask for a specific list of data
-          // columns. Let's find all columns we can possible load. We
-          // find the first data column with the correct number of
-          // dims. This one will determine the dimids of the
-          // coordinates to use. Following that, we pick all other
-          // data columns with the same coordinates.
-
-          for (int varid=0; varid<nvars; ++varid)
-            {
-              // Each netCDF dimension also has an associated variable that stores the
-              // coordinate data. We are looking for data columns, so skip them:
-              if (varid < ndims)
-                continue;
-
-              char  var_name[NC_MAX_NAME];
-              nc_type xtype;
-              int var_ndims;
-              int var_dimids[NC_MAX_VAR_DIMS];
-              int var_natts;
-
-              status = nc_inq_var (ncid, varid, var_name, &xtype, &var_ndims, var_dimids,
-                                   &var_natts);
-              AssertThrowNetCDF(status);
-
-              // only consider data that has dim variables:
-              if (var_ndims == dim)
-                {
-                  bool use = true;
-                  if (varids_to_use.size()>0)
-                    {
-                      // This is not the first data column, so we can only use it if
-                      // it uses the same dim variables as the first data column we
-                      // found.
-                      for (int i=0; i<dim; ++i)
-                        if (dimids_to_use[i]!=var_dimids[i])
-                          {
-                            use=false;
-                            break;
-                          }
-                    }
-                  else
-                    {
-                      // This is the first data column we found, so grab the ids of
-                      // the dimensions to use and store in dimids_to_use:
-                      for (int i=0; i<dim; ++i)
-                        {
-                          size_t length;
-                          status = nc_inq_dim(ncid, var_dimids[i], nullptr, &length);
-                          dimids_to_use[i] = var_dimids[i];
-                          // dimensions are specified in reverse order in the nc file:
-                          new_table_points[dim-1-i] = length;
-                        }
-                    }
-
-                  if (use)
-                    {
-                      varids_to_use.push_back(varid);
-                      data_column_names.push_back(var_name);
-                    }
-                }
-            }
-
-        }
-      else
-        {
-          // The user wants a specific list of columns, so lets find them.
-
-          for (const auto &cur_name: data_column_names)
-            {
-              bool found = false;
-
-              for (int varid=0; varid<nvars; ++varid)
-                {
-                  // Each netCDF dimension also has an associated variable that stores the
-                  // coordinate data. We are looking for data columns, so skip them:
-                  if (varid < ndims)
-                    continue;
-
-                  char  var_name[NC_MAX_NAME];
-                  nc_type xtype;
-                  int var_ndims;
-                  int var_dimids[NC_MAX_VAR_DIMS];
-                  int var_natts;
-
-                  status = nc_inq_var (ncid, varid, var_name, &xtype, &var_ndims, var_dimids,
-                                       &var_natts);
-                  AssertThrowNetCDF(status);
-                  if (cur_name != var_name)
-                    continue;
-
-                  found = true;
-
-                  if (var_ndims == dim)
-                    {
-                      bool use = true;
-                      if (varids_to_use.size()>0)
-                        {
-                          for (int i=0; i<dim; ++i)
-                            if (dimids_to_use[i]!=var_dimids[i])
-                              {
-                                use=false;
-                                break;
-                              }
-                        }
-                      else
-                        {
-                          for (int i=0; i<dim; ++i)
-                            {
-                              size_t length;
-                              status = nc_inq_dim(ncid, var_dimids[i], nullptr, &length);
-                              dimids_to_use[i] = var_dimids[i];
-                              // dimensions are specified in reverse order in the nc file:
-                              new_table_points[dim-1-i] = length;
-                            }
-                        }
-
-                      AssertThrow(use, ExcMessage(
-                                    "You asked to include column '" + cur_name + "', but it unfortunately has different dimensions than the first column you chose."
-                                  ));
-
-
-                      varids_to_use.push_back(varid);
-                    }
-                  else
-                    AssertThrow(false, ExcMessage(
-                                  "You asked to include column '" + cur_name + "', but it unfortunately has an incorrect number of dimensions."
-                                ));
-
-                }
-              AssertThrow(found, ExcMessage(
-                            "You asked to include column '" + cur_name + "', but it was not found!"
-                          ));
-
-            }
-        }
-
-
-      // Extract names of the coordinates
-      for (int idx=0; idx<dim; ++idx)
-        {
-          char  name[NC_MAX_NAME];
-          size_t length;
-          status = nc_inq_dim(ncid, dimids_to_use[idx], name, &length);
-          AssertThrowNetCDF(status);
-          coordinate_column_names[idx] = name;
-        }
-
-      {
-        // Now load coordinate data
-
-        for (int d=0; d<dim; ++d)
-          {
-            // dimensions are specified in reverse order in the nc file:
-            int varid = dimids_to_use[dim-1-d];
-
-            nc_type xtype;
-            int ndims;
-            int dimids[NC_MAX_VAR_DIMS];
-            char  name[NC_MAX_NAME];
-            int natts;
-
-            status = nc_inq_var (ncid, varid, name, &xtype, &ndims, dimids,
-                                 &natts);
-            AssertThrow(ndims == 1, ExcMessage("A variable of a dimension should have only one dimension."));
-
-            AssertThrow(xtype == NC_DOUBLE || xtype == NC_FLOAT, ExcMessage("We only support float or double data."));
-
-            coordinate_values[d].resize(new_table_points[d]);
-            status = nc_get_var_double(ncid, varid, coordinate_values[d].data());
-            AssertThrowNetCDF(status);
-          }
-      }
-
-      {
-        // Finally load the data for each column
-        data_tables.resize(varids_to_use.size());
-        std::vector<double> raw_data;
-
-        for (unsigned int var = 0; var<varids_to_use.size(); ++var)
-          {
-            // Allocate space
-            data_tables[var].TableBase<dim,double>::reinit(new_table_points);
-            const std::size_t n_elements = data_tables[var].n_elements();
-            raw_data.resize(n_elements);
-
-            // Load the data
-            status = nc_get_var_double(ncid, varids_to_use[var], raw_data.data());
-            AssertThrowNetCDF(status);
-
-            // .. and copy it over:
-            for (std::size_t n = 0; n < n_elements; ++n)
-              {
-                TableIndices<dim> ind = compute_table_indices(new_table_points, n);
-                TableIndices<dim> ind_to_use;
-                for (int i=0; i<dim; ++i)
-                  ind_to_use[i] = ind[dimids_to_use[i]];
-
-                data_tables[var](ind) = scale_factor * raw_data[n];
-              }
-          }
-
-      }
-
-
-      status = nc_close(ncid);
-      AssertThrowNetCDF(status);
-
-      // ready to go:
-      this->reinit(data_column_names, std::move(coordinate_values),std::move(data_tables));
-#endif
-    }
-
-    template <int dim>
-    void
-    StructuredDataLookup<dim>::load_file(const std::string &filename,
-                                         const MPI_Comm communicator)
-    {
-      const bool is_netcdf_filename = std::regex_search(filename, std::regex("\\.(nc|NC)$"));
-      if (is_netcdf_filename)
-        load_netcdf(filename);
-      else
-        load_ascii(filename, communicator);
-    }
-
-    template <int dim>
-    double
-    StructuredDataLookup<dim>::get_data(const Point<dim> &position,
-                                        const unsigned int component) const
-    {
-      Assert(component<n_components, ExcMessage("Invalid component index"));
-      return data[component]->value(position);
-    }
-
-    template <int dim>
-    Tensor<1,dim>
-    StructuredDataLookup<dim>::get_gradients(const Point<dim> &position,
-                                             const unsigned int component)
-    {
-      return data[component]->gradient(position,0);
-    }
-
-
-    template <int dim>
-    TableIndices<dim>
-    StructuredDataLookup<dim>::compute_table_indices(const TableIndices<dim> &sizes, const std::size_t idx) const
-    {
-      TableIndices<dim> result;
-      result[0] = idx % sizes[0];
-      if (dim >= 2)
-        result[1] = (idx / sizes[0]) % sizes[1];
-      if (dim == 3)
-        result[2] = idx / (sizes[0] * sizes[1]);
-
-      return result;
-    }
-
-
-
-    template <int dim>
-    AsciiDataBase<dim>::AsciiDataBase ()
-      = default;
-
-
-    template <int dim>
-    void
-    AsciiDataBase<dim>::declare_parameters (ParameterHandler  &prm,
-                                            const std::string &default_directory,
-                                            const std::string &default_filename,
-                                            const std::string &subsection_name)
-    {
-      prm.enter_subsection (subsection_name);
-      {
-        prm.declare_entry ("Data directory",
-                           default_directory,
-                           Patterns::DirectoryName (),
-                           "The name of a directory that contains the model data. This path "
-                           "may either be absolute (if starting with a `/') or relative to "
-                           "the current directory. The path may also include the special "
-                           "text `$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                           "in which the ASPECT source files were located when ASPECT was "
-                           "compiled. This interpretation allows, for example, to reference "
-                           "files located in the `data/' subdirectory of ASPECT.");
-        prm.declare_entry ("Data file name",
-                           default_filename,
-                           Patterns::Anything (),
-                           "The file name of the model data.");
-        prm.declare_entry ("Scale factor", "1.",
-                           Patterns::Double (),
-                           "Scalar factor, which is applied to the model data. "
-                           "You might want to use this to scale the input to a "
-                           "reference model. Another way to use this factor is to "
-                           "convert units of the input files. For instance, if you "
-                           "provide velocities in cm/yr set this factor to 0.01.");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataBase<dim>::parse_parameters (ParameterHandler &prm,
-                                          const std::string &subsection_name)
-    {
-      prm.enter_subsection (subsection_name);
-      {
-        // Get the path to the data files. If it contains a reference
-        // to $ASPECT_SOURCE_DIR, replace it by what CMake has given us
-        // as a #define
-        data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-        data_file_name    = prm.get ("Data file name");
-        scale_factor      = prm.get_double ("Scale factor");
-      }
-      prm.leave_subsection();
-    }
-
-    namespace
-    {
-      template <int dim>
-      void
-      check_supported_geometry_models(const GeometryModel::Interface<dim> &geometry_model)
-      {
-        AssertThrow ((Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (geometry_model))
-                     || (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (geometry_model))
-                     || (Plugins::plugin_type_matches<const GeometryModel::TwoMergedChunks<dim>> (geometry_model))
-                     || (Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>> (geometry_model))
-                     || (Plugins::plugin_type_matches<const GeometryModel::Sphere<dim>> (geometry_model))
-                     || (Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (geometry_model))
-                     || (Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (geometry_model)),
-                     ExcMessage ("This ascii data plugin can only be used with supported "
-                                 "geometry models."));
-      }
-    }
-
-
-
-    template <int dim>
-    AsciiDataBoundary<dim>::AsciiDataBoundary ()
-      :
-      current_file_number(numbers::invalid_unsigned_int),
-      first_data_file_number(numbers::invalid_unsigned_int),
-      decreasing_file_order(false),
-      data_file_time_step(numbers::signaling_nan<double>()),
-      time_weight(numbers::signaling_nan<double>()),
-      time_dependent(false),
-      lookups(),
-      old_lookups()
-    {}
-
-
-
-    template <int dim>
-    void
-    AsciiDataBoundary<dim>::initialize(const std::set<types::boundary_id> &boundary_ids,
-                                       const unsigned int n_components)
-    {
-      check_supported_geometry_models(this->get_geometry_model());
-
-      for (const auto &boundary_id : boundary_ids)
-        {
-          lookups.insert(std::make_pair(boundary_id,
-                                        std::make_unique<Utilities::StructuredDataLookup<dim-1>>
-                                        (n_components,
-                                         this->scale_factor)));
-
-          // Set the first file number and load the first files
-          current_file_number = first_data_file_number;
-
-          const std::string filename (create_filename (current_file_number, boundary_id));
-
-          this->get_pcout() << std::endl << "   Loading Ascii data boundary file "
-                            << filename << '.' << std::endl << std::endl;
-
-
-          AssertThrow(Utilities::fexists(filename, this->get_mpi_communicator()) || filename_is_url(filename),
-                      ExcMessage (std::string("Ascii data file <")
-                                  +
-                                  filename
-                                  +
-                                  "> not found!"));
-          lookups.find(boundary_id)->second->load_file(filename,this->get_mpi_communicator());
-
-          if (time_dependent == true)
-            {
-              old_lookups.insert(std::make_pair(boundary_id,
-                                                std::make_unique<Utilities::StructuredDataLookup<dim-1>>
-                                                (n_components,
-                                                 this->scale_factor)));
-
-              const int next_file_number =
-                (decreasing_file_order) ?
-                current_file_number - 1
-                :
-                current_file_number + 1;
-
-              const std::string filename (create_filename (next_file_number, boundary_id));
-              if (Utilities::fexists(filename, this->get_mpi_communicator()))
-                {
-                  this->get_pcout() << std::endl << "   Also loading next Ascii data boundary file "
-                                    << filename << '.' << std::endl << std::endl;
-                  lookups.find(boundary_id)->second.swap(old_lookups.find(boundary_id)->second);
-                  lookups.find(boundary_id)->second->load_file(filename, this->get_mpi_communicator());
-                }
-              else
-                {
-                  // next file not found, issue warning and end looking for new files
-                  end_time_dependence ();
-                }
-            }
-        }
-    }
-
-
-
-    namespace
-    {
-      /**
-       * Given a string @p filename_and_path that contains exactly one
-       * <code>%s</code> and one <code>%d</code> code (possibly modified
-       * by flag, field, and length modifiers as discussed in the man
-       * pages of the <code>printf()</code> family of functions),
-       * return the expanded string where the <code>%s</code> code is
-       * replaced by @p boundary_name, and <code>%d</code> is replaced
-       * by @p filenumber. Options: (1) specify both boundary_name and
-       * filenumber placeholders (%s and %d), (2) do not specify any
-       * boundary_name and filenumber placeholders, (3) only specify
-       * boundary_name placeholder (%s). Do not only specify filenumber
-       * placeholder (%d). Placeholders order is first boundary_name
-       * (%s), then filenumber (%d).
-       */
-      std::string replace_placeholders(const std::string &filename_and_path,
-                                       const std::string &boundary_name,
-                                       const int filenumber)
-      {
-        const int maxsize = filename_and_path.length() + 256;
-        char *filename = static_cast<char *>(malloc (maxsize * sizeof(char)));
-        int ret = snprintf (filename,
-                            maxsize,
-                            filename_and_path.c_str(),
-                            boundary_name.c_str(),
-                            filenumber);
-
-        AssertThrow(ret >= 0, ExcMessage("Invalid string placeholder in filename detected."));
-        AssertThrow(ret< maxsize, ExcInternalError("snprintf string overflow detected."));
-        const std::string str_result (filename);
-        free (filename);
-        return str_result;
-      }
-
-    }
-
-    template <int dim>
-    std::string
-    AsciiDataBoundary<dim>::create_filename (const int filenumber,
-                                             const types::boundary_id boundary_id) const
-    {
-      std::string templ = this->data_directory + this->data_file_name;
-
-      const std::string boundary_name = this->get_geometry_model().translate_id_to_symbol_name(boundary_id);
-
-      const std::string result = replace_placeholders(templ, boundary_name, filenumber);
-      if (fexists(result, this->get_mpi_communicator()))
-        return result;
-
-      // Backwards compatibility check: people might still be using the old
-      // names of the top/bottom boundary. If they do, print a warning but
-      // accept those files.
-      std::string compatible_result;
-      if (boundary_name == "top")
-        {
-          compatible_result = replace_placeholders(templ, "surface", filenumber);
-          if (!fexists(compatible_result, this->get_mpi_communicator()))
-            compatible_result = replace_placeholders(templ, "outer", filenumber);
-        }
-      else if (boundary_name == "bottom")
-        compatible_result = replace_placeholders(templ, "inner", filenumber);
-
-      if (!fexists(result, this->get_mpi_communicator()) && fexists(compatible_result, this->get_mpi_communicator()))
-        {
-          this->get_pcout() << "WARNING: Filename convention concerning geometry boundary "
-                            "names changed. Please rename '" << compatible_result << "'"
-                            << " to '" << result << "'"
-                            << std::endl;
-          return compatible_result;
-        }
-
-      return result;
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataBoundary<dim>::update ()
-    {
-      if (time_dependent == true)
-        {
-          // always initialize with the start time during model setup, even
-          // when restarting (to have identical setup in both cases)
-          double model_time = this->get_parameters().start_time;
-
-          // if we are past initialization use the current time instead
-          if (this->simulator_is_past_initialization())
-            model_time = this->get_time();
-
-          const double time_steps_since_start = model_time / data_file_time_step;
-          // whether we need to update our data files. This looks so complicated
-          // because we need to catch increasing and decreasing file orders and all
-          // possible first_data_file_numbers.
-          const bool need_update =
-            static_cast<int> (time_steps_since_start)
-            > std::abs(current_file_number - first_data_file_number);
-
-          if (need_update)
-            {
-              // The last file, which was tried to be loaded was
-              // number current_file_number +/- 1, because current_file_number
-              // is the file older than the current model time
-              const int old_file_number =
-                (decreasing_file_order) ?
-                current_file_number - 1
-                :
-                current_file_number + 1;
-
-              // Calculate new file_number
-              current_file_number =
-                (decreasing_file_order) ?
-                first_data_file_number
-                - static_cast<unsigned int> (time_steps_since_start)
-                :
-                first_data_file_number
-                + static_cast<unsigned int> (time_steps_since_start);
-
-              const bool load_both_files = std::abs(current_file_number - old_file_number) >= 1;
-
-              for (const auto &boundary_id : lookups)
-                update_data(boundary_id.first, load_both_files);
-            }
-
-          time_weight = time_steps_since_start
-                        - std::abs(current_file_number - first_data_file_number);
-
-          Assert ((0 <= time_weight) && (time_weight <= 1),
-                  ExcMessage (
-                    "Error in set_current_time. Time_weight has to be in [0,1]"));
-        }
-    }
-
-    template <int dim>
-    void
-    AsciiDataBoundary<dim>::update_data (const types::boundary_id boundary_id,
-                                         const bool load_both_files)
-    {
-      // If the time step was large enough to move forward more
-      // then one data file we need to load both current files
-      // to stay accurate in interpolation
-      if (load_both_files)
-        {
-          const std::string filename (create_filename (current_file_number,boundary_id));
-          this->get_pcout() << std::endl << "   Loading Ascii data boundary file "
-                            << filename << '.' << std::endl << std::endl;
-          if (Utilities::fexists(filename, this->get_mpi_communicator()))
-            {
-              lookups.find(boundary_id)->second.swap(old_lookups.find(boundary_id)->second);
-              lookups.find(boundary_id)->second->load_file(filename,this->get_mpi_communicator());
-            }
-
-          // If loading current_time_step failed, end time dependent part with old_file_number.
-          else
-            end_time_dependence ();
-        }
-
-      // Now load the next data file. This part is the main purpose of this function.
-      const int next_file_number =
-        (decreasing_file_order) ?
-        current_file_number - 1
-        :
-        current_file_number + 1;
-
-      const std::string filename (create_filename (next_file_number,boundary_id));
-      this->get_pcout() << std::endl << "   Loading Ascii data boundary file "
-                        << filename << '.' << std::endl << std::endl;
-      if (Utilities::fexists(filename, this->get_mpi_communicator()))
-        {
-          lookups.find(boundary_id)->second.swap(old_lookups.find(boundary_id)->second);
-          lookups.find(boundary_id)->second->load_file(filename,this->get_mpi_communicator());
-        }
-
-      // If next file does not exist, end time dependent part with current_time_step and issue warning.
-      else
-        end_time_dependence ();
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiDataBoundary<dim>::end_time_dependence ()
-    {
-      // no longer consider the problem time dependent from here on out
-      // this cancels all attempts to read files at the next time steps
-      time_dependent = false;
-
-      // Give warning if first processor
-      this->get_pcout() << std::endl
-                        << "   From this timestep onwards, ASPECT will not attempt to load new Ascii data files." << std::endl
-                        << "   This is either because ASPECT has already read all the files necessary to impose" << std::endl
-                        << "   the requested boundary condition, or that the last available file has been read." << std::endl
-                        << "   If the Ascii data represented a time-dependent boundary condition," << std::endl
-                        << "   that time-dependence ends at this timestep  (i.e. the boundary condition" << std::endl
-                        << "   will continue unchanged from the last known state into the future)." << std::endl << std::endl;
-    }
-
-
-
-    namespace
-    {
-      /**
-       * Determines which of the dimensions of a position are aligned with
-       * a certain @p boundary_id. E.g. the left boundary of a box
-       * model extents in the y and z direction (position[1] and
-       * position[2]), therefore the function would return [1,2] for dim==3
-       * or [1] for dim==2. We are lucky that these indices are identical
-       * for all existing geometries (if we use natural coordinates),
-       * therefore we do not need to distinguish between them. If we
-       * introduce a geometry model for which boundaries are not aligned
-       * with natural coordinates this needs to become a function in
-       * the interface of the geometry model and needs to be specialized
-       * for distinct geometry models.
-       */
-      template <int dim>
-      std::array<unsigned int,dim-1>
-      get_boundary_dimensions (const types::boundary_id boundary_id)
-      {
-        std::array<unsigned int,dim-1> boundary_dimensions;
-        boundary_dimensions.fill(numbers::invalid_unsigned_int);
-
-        switch (dim)
-          {
-            case 2:
-              if ((boundary_id == 2) || (boundary_id == 3) || (boundary_id == 4) || (boundary_id == 5))
-                {
-                  boundary_dimensions[0] = 0;
-                }
-              else if ((boundary_id == 0) || (boundary_id == 1))
-                {
-                  boundary_dimensions[0] = 1;
-                }
-              else
-                {
-                  AssertThrow(false,ExcNotImplemented());
-                }
-              break;
-
-            case 3:
-              if ((boundary_id == 4) || (boundary_id == 5) || (boundary_id == 8) || (boundary_id == 9))
-                {
-                  boundary_dimensions[0] = 0;
-                  boundary_dimensions[1] = 1;
-                }
-              else if ((boundary_id == 0) || (boundary_id == 1))
-                {
-                  boundary_dimensions[0] = 1;
-                  boundary_dimensions[1] = 2;
-                }
-              else if ((boundary_id == 2) || (boundary_id == 3) || (boundary_id == 6) || (boundary_id == 7))
-                {
-                  boundary_dimensions[0] = 0;
-                  boundary_dimensions[1] = 2;
-                }
-              else
-                {
-                  AssertThrow(false,ExcNotImplemented());
-                }
-
-              break;
-
-            default:
-              AssertThrow(false,ExcNotImplemented());
-          }
-        return boundary_dimensions;
-      }
-
-
-
-      /**
-       * Convert a point @p position in cartesian coordinates into the set of coordinates
-       * used in the structured data input files, i.e. coordinates in the
-       * natural coordinate system of the given @p geometry_model.
-       */
-      template <int dim>
-      Point<dim>
-      data_coordinates_from_position (const Point<dim> &position,
-                                      const aspect::GeometryModel::Interface<dim> &geometry_model)
-      {
-        const std::array<double,dim> natural_position = geometry_model.cartesian_to_natural_coordinates(position);
-        Point<dim> data_coordinates = Utilities::convert_array_to_point<dim>(natural_position);
-
-        // The chunk model has latitude as natural coordinate. We need to convert this to colatitude
-        // to allow for consistent data files between chunk geometries and spherical geometries.
-        if (dim == 3 &&
-            (Plugins::plugin_type_matches<const GeometryModel::Chunk<dim>> (geometry_model) ||
-             Plugins::plugin_type_matches<const GeometryModel::TwoMergedChunks<dim>> (geometry_model) ||
-             Plugins::plugin_type_matches<const GeometryModel::EllipsoidalChunk<dim>> (geometry_model)))
-          {
-            data_coordinates[2] = numbers::PI/2. - data_coordinates[2];
-          }
-
-        return data_coordinates;
-      }
-
-
-
-      /**
-       * Convert a point @p data_coordinates using coordinates appropriate for
-       * volumetric structured data input files (e.g. produced by the
-       * data_coordinates_from_position() function above) into appropriate
-       * coordinates on the boundary given by @p boundary_indicator.
-       * Because all existing geometry models use boundaries that are aligned
-       * with natural coordinate directions this means finding the correct n_components
-       * of the input coordinates and returning a point with one dimension less
-       * than the input point that is determined by these coordinates.
-       */
-      template <int dim>
-      Point<dim-1>
-      boundary_coordinates_from_data_coordinates (const Point<dim> &data_coordinates,
-                                                  const types::boundary_id boundary_indicator)
-      {
-        const std::array<unsigned int,dim-1> boundary_dimensions =
-          get_boundary_dimensions<dim>(boundary_indicator);
-
-        Point<dim-1> boundary_coordinates;
-        for (unsigned int i = 0; i < dim-1; ++i)
-          boundary_coordinates[i] = data_coordinates[boundary_dimensions[i]];
-
-        return boundary_coordinates;
-      }
-    }
-
-
-
-    template <int dim>
-    double
-    AsciiDataBoundary<dim>::
-    get_data_component (const types::boundary_id             boundary_indicator,
-                        const Point<dim>                    &position,
-                        const unsigned int                   component) const
-    {
-      const Point<dim> data_coordinates = data_coordinates_from_position(position, this->get_geometry_model());
-      const Point<dim-1> boundary_coordinates = boundary_coordinates_from_data_coordinates(data_coordinates, boundary_indicator);
-
-      Assert (lookups.find(boundary_indicator) != lookups.end(),
-              ExcInternalError());
-      const double data = lookups.find(boundary_indicator)->second->get_data(boundary_coordinates,component);
-
-      if (!time_dependent)
-        return data;
-
-      const double old_data = old_lookups.find(boundary_indicator)->second->get_data(boundary_coordinates,component);
-
-      return time_weight * data + (1 - time_weight) * old_data;
-    }
-
-
-    template <int dim>
-    Tensor<1,dim-1>
-    AsciiDataBoundary<dim>::vector_gradient (const types::boundary_id             boundary_indicator,
-                                             const Point<dim>                    &position,
-                                             const unsigned int                   component) const
-    {
-      const Point<dim> data_coordinates = data_coordinates_from_position(position, this->get_geometry_model());
-      const Point<dim-1> boundary_coordinates = boundary_coordinates_from_data_coordinates(data_coordinates, boundary_indicator);
-
-      const Tensor<1,dim-1>  gradients = lookups.find(boundary_indicator)->second->get_gradients(boundary_coordinates,component);
-
-      if (!time_dependent)
-        return gradients;
-
-      const Tensor<1,dim-1> old_gradients = old_lookups.find(boundary_indicator)->second->get_gradients(boundary_coordinates,component);
-
-      return time_weight * gradients + (1 - time_weight) * old_gradients;
-    }
-
-
-    template <int dim>
-    double
-    AsciiDataBoundary<dim>::get_maximum_component_value (const types::boundary_id boundary_indicator, const unsigned int component) const
-    {
-      return lookups.find(boundary_indicator)->second->get_maximum_component_value(component);
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataBoundary<dim>::declare_parameters (ParameterHandler  &prm,
-                                                const std::string &default_directory,
-                                                const std::string &default_filename,
-                                                const std::string &subsection_name,
-                                                const bool declare_time_dependent_parameters)
-    {
-      Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                        default_directory,
-                                                        default_filename,
-                                                        subsection_name);
-
-      prm.enter_subsection (subsection_name);
-      {
-        if (declare_time_dependent_parameters == true)
-          {
-            prm.declare_entry ("Data file name",
-                               default_filename,
-                               Patterns::Anything (),
-                               "The file name of the model data. Provide file in format: "
-                               "(File name).\\%s\\%d, where \\%s is a string specifying "
-                               "the boundary of the model according to the names of the boundary "
-                               "indicators (of the chosen geometry model), and \\%d is any sprintf "
-                               "integer qualifier specifying the format of the current file number.");
-            prm.declare_entry ("Data file time step", "1e6",
-                               Patterns::Double (0.),
-                               "Time step between following data files. "
-                               "Depending on the setting of the global `Use years in output instead of seconds' flag "
-                               "in the input file, this number is either interpreted as seconds or as years. "
-                               "The default is one million, i.e., either one million seconds or one million years.");
-            prm.declare_entry ("First data file model time", "0",
-                               Patterns::Double (0.),
-                               "The `First data file model time' parameter "
-                               "has been deactivated and will be removed in a future release. "
-                               "Do not use this parameter and instead provide data files "
-                               "starting from the model start time.");
-            prm.declare_entry ("First data file number", "0",
-                               Patterns::Integer (),
-                               "Number of the first velocity file to be loaded when the model time "
-                               "is larger than `First velocity file model time'.");
-            prm.declare_entry ("Decreasing file order", "false",
-                               Patterns::Bool (),
-                               "In some cases the boundary files are not numbered in increasing "
-                               "but in decreasing order (e.g. `Ma BP'). If this flag is set to "
-                               "`True' the plugin will first load the file with the number "
-                               "`First data file number' and decrease the file number during "
-                               "the model run.");
-          }
-        else
-          {
-            prm.declare_entry ("Data file name",
-                               default_filename,
-                               Patterns::Anything (),
-                               "The file name of the model data. Provide file in format: "
-                               "(File name).\\%s, where \\%s is a string specifying "
-                               "the boundary of the model according to the names of the boundary "
-                               "indicators (of the chosen geometry model).");
-          }
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataBoundary<dim>::parse_parameters (ParameterHandler &prm,
-                                              const std::string &subsection_name,
-                                              const bool parse_time_dependent_parameters)
-    {
-      Utilities::AsciiDataBase<dim>::parse_parameters(prm,
-                                                      subsection_name);
-
-      prm.enter_subsection(subsection_name);
-      {
-        if (parse_time_dependent_parameters == true)
-          {
-            data_file_time_step             = prm.get_double ("Data file time step");
-            const double first_data_file_model_time      = prm.get_double ("First data file model time");
-
-            AssertThrow (first_data_file_model_time == 0.0,
-                         ExcMessage("The `First data file model time' parameter "
-                                    "has been deactivated and will be removed in a future release. "
-                                    "Do not use this parameter and instead provide data files "
-                                    "starting from the model start time."));
-
-            first_data_file_number          = prm.get_integer("First data file number");
-            decreasing_file_order           = prm.get_bool   ("Decreasing file order");
-
-            if (this->convert_output_to_years() == true)
-              {
-                data_file_time_step        *= year_in_seconds;
-              }
-          }
-        else
-          {
-            AssertThrow (create_filename (0, 0) == create_filename (1, 0),
-                         ExcMessage("A boundary data file name was used that contained a placeholder for "
-                                    "the current file number, but this AsciiDataBoundary object does not support "
-                                    "time dependent information. Please remove the file number placeholder."));
-          }
-
-        // if filename does not contain a placeholder for timestep, no time dependence
-        // do not issue a warning, the parameter file is specifying exactly one file.
-        if (create_filename (0, 0) == create_filename (1, 0))
-          time_dependent = false;
-        else
-          time_dependent = true;
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    AsciiDataLayered<dim>::AsciiDataLayered ()
-      = default;
-
-
-
-    template <int dim>
-    void
-    AsciiDataLayered<dim>::initialize(const unsigned int n_components)
-    {
-      check_supported_geometry_models(this->get_geometry_model());
-
-      // Create the lookups for each file
-      number_of_layer_boundaries = data_file_names.size();
-      for (unsigned int i=0; i<number_of_layer_boundaries; ++i)
-        {
-          const std::string filename = data_directory + data_file_names[i];
-          AssertThrow(Utilities::fexists(filename, this->get_mpi_communicator()) || filename_is_url(filename),
-                      ExcMessage (std::string("Ascii data file <")
-                                  +
-                                  filename
-                                  +
-                                  "> not found!"));
-
-          lookups.push_back(std::make_unique<Utilities::StructuredDataLookup<dim-1>> (n_components,
-                                                                                       this->scale_factor));
-          lookups[i]->load_file(filename,this->get_mpi_communicator());
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    AsciiDataLayered<dim>::
-    get_data_component (const Point<dim> &position,
-                        const unsigned int component) const
-    {
-      const Point<dim> data_coordinates = data_coordinates_from_position(position, this->get_geometry_model());
-
-      double vertical_position;
-      Point<dim-1> horizontal_position;
-      if (this->get_geometry_model().natural_coordinate_system() == Utilities::Coordinates::CoordinateSystem::cartesian)
-        {
-          // in cartesian coordinates, the vertical component comes last
-          vertical_position = data_coordinates[dim-1];
-          for (unsigned int i = 0; i < dim-1; ++i)
-            horizontal_position[i] = data_coordinates[i];
-        }
-      else
-        {
-          // in spherical coordinates, the vertical component comes first
-          vertical_position = data_coordinates[0];
-          for (unsigned int i = 0; i < dim-1; ++i)
-            horizontal_position[i] = data_coordinates[i+1];
-        }
-
-      // Find which layer we're in
-      unsigned int layer_boundary_index=0;
-      // if position < position of the first boundary layer, stop
-      double old_difference_in_vertical_position = vertical_position - lookups[layer_boundary_index]->get_data(horizontal_position,0);
-      double difference_in_vertical_position = old_difference_in_vertical_position;
-      while (difference_in_vertical_position > 0. && layer_boundary_index < number_of_layer_boundaries-1)
-        {
-          ++layer_boundary_index;
-          old_difference_in_vertical_position = difference_in_vertical_position;
-          difference_in_vertical_position = vertical_position - lookups[layer_boundary_index]->get_data(horizontal_position,0);
-        }
-
-      if (interpolation_scheme == "piecewise constant")
-        {
-          return lookups[layer_boundary_index]->get_data(horizontal_position,component); // takes value from layer above
-        }
-      else if (interpolation_scheme == "linear")
-        {
-          if (difference_in_vertical_position > 0 || layer_boundary_index == 0) // if the point is above the first layer or below the last
-            {
-              return lookups[layer_boundary_index]->get_data(horizontal_position,component);
-            }
-          else
-            {
-              const double f = difference_in_vertical_position/(difference_in_vertical_position-old_difference_in_vertical_position);
-              return ((1.-f)*lookups[layer_boundary_index]->get_data(horizontal_position,component) +
-                      f*lookups[layer_boundary_index-1]->get_data(horizontal_position,component));
-            }
-        }
-      return 0;
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataLayered<dim>::declare_parameters (ParameterHandler  &prm,
-                                               const std::string &default_directory,
-                                               const std::string &default_filename,
-                                               const std::string &subsection_name)
-    {
-      Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                        default_directory,
-                                                        default_filename,
-                                                        subsection_name);
-
-      prm.enter_subsection (subsection_name);
-      {
-        prm.declare_entry ("Data directory",
-                           default_directory,
-                           Patterns::DirectoryName (),
-                           "The name of a directory that contains the model data. This path "
-                           "may either be absolute (if starting with a `/') or relative to "
-                           "the current directory. The path may also include the special "
-                           "text `$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                           "in which the ASPECT source files were located when ASPECT was "
-                           "compiled. This interpretation allows, for example, to reference "
-                           "files located in the `data/' subdirectory of ASPECT. ");
-
-        prm.declare_entry ("Data file names",
-                           default_filename,
-                           Patterns::List (Patterns::Anything()),
-                           "The file names of the model data (comma separated). ");
-
-        prm.declare_entry ("Interpolation scheme", "linear",
-                           Patterns::Selection("piecewise constant|linear"),
-                           "Method to interpolate between layer boundaries. Select from "
-                           "piecewise constant or linear. Piecewise constant takes the "
-                           "value from the nearest layer boundary above the data point. "
-                           "The linear option interpolates linearly between layer boundaries. "
-                           "Above and below the domain given by the layer boundaries, the values are"
-                           "given by the top and bottom layer boundary.");
-
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    AsciiDataLayered<dim>::parse_parameters (ParameterHandler &prm,
-                                             const std::string &subsection_name)
-    {
-      Utilities::AsciiDataBase<dim>::parse_parameters(prm, subsection_name);
-
-      prm.enter_subsection(subsection_name);
-      {
-        data_directory = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Data directory"));
-        data_file_names = Utilities::split_string_list(prm.get ("Data file names"), ',');
-        interpolation_scheme = prm.get("Interpolation scheme");
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    AsciiDataInitial<dim>::AsciiDataInitial ()
-      : slice_data(false),
-        rotation_matrix()
-    {}
-
-
-
-    template <int dim>
-    void
-    AsciiDataInitial<dim>::initialize (const unsigned int n_components)
-    {
-      const std::string filename = this->data_directory + this->data_file_name;
-
-      this->get_pcout() << std::endl << "   Loading Ascii data initial file "
-                        << filename << '.' << std::endl << std::endl;
-
-
-      AssertThrow(Utilities::fexists(filename, this->get_mpi_communicator()) || filename_is_url(filename),
-                  ExcMessage (std::string("Ascii data file <")
-                              +
-                              filename
-                              +
-                              "> not found!"));
-
-      if (slice_data == true)
-        {
-          slice_lookup = std::make_unique<Utilities::StructuredDataLookup<3>> (n_components,
-                                                                                this->scale_factor);
-          slice_lookup->load_file(filename, this->get_mpi_communicator());
-        }
-      else
-        {
-          lookup = std::make_unique<Utilities::StructuredDataLookup<dim>> (n_components,
-                                                                            this->scale_factor);
-          lookup->load_file(filename, this->get_mpi_communicator());
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    AsciiDataInitial<dim>::
-    get_data_component (const Point<dim> &position,
-                        const unsigned int component) const
-    {
-      // Handle the special case of slicing through data first
-      if (slice_data == true)
-        {
-          // This implies a SphericalShell, a 2d model, and a 3d dataset as asserted
-          // in the parse_parameters function below.
-
-          // Compute the coordinates of a 3d point based on the 2d position.
-          const Tensor<1,3> position_tensor({position[0], position[1], 0.0});
-          const Point<3> rotated_position (rotation_matrix * position_tensor);
-
-          const std::array<double,3> spherical_position =
-            Utilities::Coordinates::cartesian_to_spherical_coordinates(rotated_position);
-
-          return slice_lookup->get_data(Point<3>(Tensor<1,3>(ArrayView<const double>(spherical_position))),component);
-        }
-
-      // else slice_data == false: model and dataset have the same dimension
-      const Point<dim> data_coordinates = data_coordinates_from_position(position, this->get_geometry_model());
-
-      return lookup->get_data(data_coordinates,component);
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiDataInitial<dim>::declare_parameters (ParameterHandler  &prm,
-                                               const std::string &default_directory,
-                                               const std::string &default_filename,
-                                               const std::string &subsection_name)
-    {
-      Utilities::AsciiDataBase<dim>::declare_parameters(prm,
-                                                        default_directory,
-                                                        default_filename,
-                                                        subsection_name);
-
-      prm.enter_subsection (subsection_name);
-      {
-        prm.declare_entry("Slice dataset in 2D plane", "false",
-                          Patterns::Bool (),
-                          "Whether to use a 2d data slice of a 3d data file "
-                          "or the entire data file. Slicing a 3d dataset is "
-                          "only supported for 2d models.");
-        prm.declare_entry ("First point on slice", "0.0,1.0,0.0",
-                           Patterns::Anything (),
-                           "Point that determines the plane in which the 2d slice lies in. "
-                           "This variable is only used if 'Slice dataset in 2d plane' is true. "
-                           "The slice will go through this point, the point defined by the "
-                           "parameter 'Second point on slice', and the center of the model "
-                           "domain. After the rotation, this first point will lie along the "
-                           "(0,1,0) axis of the coordinate system. The coordinates of the "
-                           "point have to be given in Cartesian coordinates.");
-        prm.declare_entry ("Second point on slice", "1.0,0.0,0.0",
-                           Patterns::Anything (),
-                           "Second point that determines the plane in which the 2d slice lies in. "
-                           "This variable is only used if 'Slice dataset in 2d plane' is true. "
-                           "The slice will go through this point, the point defined by the "
-                           "parameter 'First point on slice', and the center of the model "
-                           "domain. The coordinates of the point have to be given in Cartesian "
-                           "coordinates.");
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    AsciiDataInitial<dim>::parse_parameters (ParameterHandler &prm,
-                                             const std::string &subsection_name)
-    {
-      Utilities::AsciiDataBase<dim>::parse_parameters(prm,
-                                                      subsection_name);
-
-      prm.enter_subsection(subsection_name);
-      {
-        slice_data = prm.get_bool ("Slice dataset in 2D plane");
-        if (slice_data == true)
-          {
-            AssertThrow (Plugins::plugin_type_matches<const GeometryModel::SphericalShell<dim>> (this->get_geometry_model()),
-                         ExcMessage ("Slicing an ascii dataset is only supported when using "
-                                     "a spherical shell geometry."));
-
-            AssertThrow(dim == 2,
-                        ExcMessage("The AsciiDataInitial class can only slice data in 2d models."));
-
-            std::vector<double> point_one = Utilities::string_to_double(Utilities::split_string_list(prm.get("First point on slice")));
-            std::vector<double> point_two = Utilities::string_to_double(Utilities::split_string_list(prm.get("Second point on slice")));
-
-            AssertThrow(point_one.size() == 3 && point_two.size() == 3,
-                        ExcMessage("The points on the slice in the Ascii data model need "
-                                   "to be given in three dimensions; in other words, as three "
-                                   "numbers, separated by commas."));
-
-            Point<3> first_point_on_slice;
-            Point<3> second_point_on_slice;
-
-            for (unsigned int d=0; d<3; ++d)
-              first_point_on_slice[d] = point_one[d];
-
-            for (unsigned int d=0; d<3; ++d)
-              second_point_on_slice[d] = point_two[d];
-
-            rotation_matrix = Utilities::compute_rotation_matrix_for_slice(first_point_on_slice, second_point_on_slice);
-          }
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    AsciiDataProfile<dim>::AsciiDataProfile ()
-      = default;
-
-
-
-    template <int dim>
-    void
-    AsciiDataProfile<dim>::initialize (const MPI_Comm communicator)
-    {
-      lookup = std::make_unique<Utilities::StructuredDataLookup<1>> (this->scale_factor);
-
-      const std::string filename = this->data_directory + this->data_file_name;
-
-      AssertThrow(Utilities::fexists(filename, communicator) || filename_is_url(filename),
-                  ExcMessage (std::string("Ascii data file <")
-                              +
-                              filename
-                              +
-                              "> not found!"));
-      lookup->load_file(filename,communicator);
-    }
-
-
-
-    template <int dim>
-    std::vector<std::string>
-    AsciiDataProfile<dim>::get_column_names() const
-    {
-      return lookup->get_column_names();
-    }
-
-
-
-    template <int dim>
-    unsigned int
-    AsciiDataProfile<dim>::get_column_index_from_name(const std::string &column_name) const
-    {
-      return lookup->get_column_index_from_name(column_name);
-    }
-
-
-
-    template <int dim>
-    unsigned int
-    AsciiDataProfile<dim>::maybe_get_column_index_from_name(const std::string &column_name) const
-    {
-      try
-        {
-          // read the entries in if they exist
-          return lookup->get_column_index_from_name(column_name);
-        }
-      catch (...)
-        {
-          // return an invalid unsigned int entry if the column does not exist
-          return numbers::invalid_unsigned_int;
-        }
-    }
-
-
-
-    template <int dim>
-    std::string
-    AsciiDataProfile<dim>::get_column_name_from_index(const unsigned int column_index) const
-    {
-      return lookup->get_column_name_from_index(column_index);
-    }
-
-
-
-    template <int dim>
-    double
-    AsciiDataProfile<dim>::
-    get_data_component (const Point<1>                      &position,
-                        const unsigned int                   component) const
-    {
-      return lookup->get_data(position,component);
-    }
-
-
-
-    template <int dim>
-    const std::vector<double> &
-    AsciiDataProfile<dim>::get_interpolation_point_coordinates() const
-    {
-      return lookup->get_interpolation_point_coordinates(0);
-    }
-
-
-
-// Explicit instantiations
-
-    template class StructuredDataLookup<1>;
-    template class StructuredDataLookup<2>;
-    template class StructuredDataLookup<3>;
-    template class AsciiDataBase<2>;
-    template class AsciiDataBase<3>;
-    template class AsciiDataBoundary<2>;
-    template class AsciiDataBoundary<3>;
-    template class AsciiDataLayered<2>;
-    template class AsciiDataLayered<3>;
-    template class AsciiDataInitial<2>;
-    template class AsciiDataInitial<3>;
-    template class AsciiDataProfile<1>;
-    template class AsciiDataProfile<2>;
-    template class AsciiDataProfile<3>;
-  }
-}
diff --git a/source/termination_criteria/end_step.cc.bak b/source/termination_criteria/end_step.cc.bak
deleted file mode 100644
index ebec3937242..00000000000
--- a/source/termination_criteria/end_step.cc.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2011 - 2018 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/termination_criteria/end_step.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    template <int dim>
-    bool
-    EndStep<dim>::execute()
-    {
-      return (this->get_timestep_number () > end_step);
-    }
-
-    template <int dim>
-    void
-    EndStep<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.declare_entry ("End step", "100",
-                           Patterns::Integer (0),
-                           "Terminate the simulation once the specified timestep has been reached.");
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    EndStep<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        end_step = prm.get_integer ("End step");
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    ASPECT_REGISTER_TERMINATION_CRITERION(EndStep,
-                                          "end step",
-                                          "Terminate the simulation once the specified timestep "
-                                          "has been reached. ")
-  }
-}
diff --git a/source/termination_criteria/end_time.cc.bak b/source/termination_criteria/end_time.cc.bak
deleted file mode 100644
index c4d4bc5125a..00000000000
--- a/source/termination_criteria/end_time.cc.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2011 - 2017 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/termination_criteria/end_time.h>
-
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    template <int dim>
-    bool
-    EndTime<dim>::execute()
-    {
-      return (this->get_time() > end_time);
-    }
-
-    template <int dim>
-    double EndTime<dim>::check_for_last_time_step (const double time_step) const
-    {
-      if ((this->get_time()<end_time)
-          &&
-          (this->get_time()+time_step > end_time))
-        return end_time - this->get_time();
-      else
-        return time_step;
-    }
-
-    template <int dim>
-    void
-    EndTime<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.declare_entry ("End time",
-                         /* boost::lexical_cast<std::string>(std::numeric_limits<double>::max() /
-                                              year_in_seconds) = */ "5.69e+300",
-                         Patterns::Double (),
-                         "The end time of the simulation. The default value is a number "
-                         "so that when converted from years to seconds it is approximately "
-                         "equal to the largest number representable in floating point "
-                         "arithmetic. For all practical purposes, this equals infinity. "
-                         "Units: Years if the "
-                         "'Use years in output instead of seconds' parameter is set; "
-                         "seconds otherwise.");
-    }
-
-
-    template <int dim>
-    void
-    EndTime<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      // read end time from parameter file. if it is to be interpreted
-      // in years rather than seconds, then do the conversion
-      end_time = prm.get_double ("End time");
-      if (prm.get_bool ("Use years in output instead of seconds") == true)
-        end_time *= year_in_seconds;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    ASPECT_REGISTER_TERMINATION_CRITERION(EndTime,
-                                          "end time",
-                                          "Terminate the simulation once the end time "
-                                          "specified in the input file has been reached. "
-                                          "Unlike all other termination criteria, this "
-                                          "criterion is \\textit{always} active, whether it "
-                                          "has been explicitly selected or not in the input file "
-                                          "(this is done to preserve historical behavior of "
-                                          "\\aspect{}, but it also likely does not inconvenience "
-                                          "anyone since it is what would be selected in most "
-                                          "cases anyway).")
-  }
-}
diff --git a/source/termination_criteria/end_walltime.cc.bak b/source/termination_criteria/end_walltime.cc.bak
deleted file mode 100644
index 2a1810196ac..00000000000
--- a/source/termination_criteria/end_walltime.cc.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/termination_criteria/end_walltime.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    // The start_walltime is made as static and initialized here to
-    // make sure it is initialized when the program starts.
-    template <int dim>
-    std::time_t
-    EndWalltime<dim>::start_walltime = std::time(nullptr);
-
-    template <int dim>
-    bool
-    EndWalltime<dim>::execute()
-    {
-      return std::difftime(std::time(nullptr),start_walltime) >= walltime_duration;
-    }
-
-
-    template <int dim>
-    void
-    EndWalltime<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.declare_entry ("Wall time",
-                           "24.",
-                           Patterns::Double (0.),
-                           "The wall time of the simulation. Unit: hours.");
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    EndWalltime<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        // Change from hours to seconds:
-        walltime_duration = static_cast<unsigned int>(prm.get_double ("Wall time") * 3600.);
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    ASPECT_REGISTER_TERMINATION_CRITERION(EndWalltime,
-                                          "wall time",
-                                          "Terminate the simulation once the wall time limit has reached.")
-  }
-}
diff --git a/source/termination_criteria/interface.cc.bak b/source/termination_criteria/interface.cc.bak
deleted file mode 100644
index 3f6e7998cc5..00000000000
--- a/source/termination_criteria/interface.cc.bak
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/termination_criteria/interface.h>
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-
-#include <typeinfo>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-// ------------------------------ Interface -----------------------------
-
-    template <int dim>
-    double Interface<dim>::check_for_last_time_step (const double time_step) const
-    {
-      return time_step;
-    }
-
-
-
-// ------------------------------ Manager -----------------------------
-
-    template <int dim>
-    double Manager<dim>::check_for_last_time_step (const double time_step) const
-    {
-      double new_time_step = time_step;
-      for (const auto &p : this->plugin_objects)
-        {
-          double current_time_step = p->check_for_last_time_step (new_time_step);
-
-          AssertThrow (current_time_step > 0,
-                       ExcMessage("Time step must be greater than 0."));
-          AssertThrow (current_time_step <= new_time_step,
-                       ExcMessage("Current time step must be less than or equal to time step entered into function."));
-
-          new_time_step = std::min(current_time_step, new_time_step);
-        }
-      return new_time_step;
-    }
-
-    template <int dim>
-    bool
-    Manager<dim>::execute () const
-    {
-      bool terminate_simulation = false;
-
-
-      // call the execute() functions of all plugins we have
-      // here in turns.
-      std::list<std::string>::const_iterator  itn = termination_obj_names.begin();
-      for (typename std::list<std::unique_ptr<Interface<dim>>>::const_iterator
-           p = this->plugin_objects.begin();
-           p != this->plugin_objects.end(); ++p,++itn)
-        {
-          try
-            {
-              const bool terminate = (*p)->execute ();
-
-              // do the reduction: does any one of the processors
-              // think that we should terminate? (do the reduction in
-              // data type int since there is currently no function
-              // Utilities::MPI::CollectiveOr or similar)
-              const bool all_terminate = (Utilities::MPI::max ((terminate ? 1 : 0),
-                                                               this->get_mpi_communicator())
-                                          == 1);
-              terminate_simulation |= all_terminate;
-
-              // Let the user know which criterion caused the termination
-              if (all_terminate == true)
-                this->get_pcout() << "Termination requested by criterion: "
-                                  << *itn
-                                  << std::endl;
-            }
-          // plugins that throw exceptions usually do not result in
-          // anything good because they result in an unwinding of the stack
-          // and, if only one processor triggers an exception, the
-          // destruction of objects often causes a deadlock. thus, if
-          // an exception is generated, catch it, print an error message,
-          // and abort the program
-          catch (std::exception &exc)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running termination criterion plugin <"
-                        << typeid(**p).name()
-                        << ">: " << std::endl
-                        << exc.what() << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-          catch (...)
-            {
-              std::cerr << std::endl << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-              std::cerr << "Exception on MPI process <"
-                        << Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)
-                        << "> while running termination criterion plugin <"
-                        << typeid(**p).name()
-                        << ">: " << std::endl;
-              std::cerr << "Unknown exception!" << std::endl
-                        << "Aborting!" << std::endl
-                        << "----------------------------------------------------"
-                        << std::endl;
-
-              // terminate the program!
-              MPI_Abort (MPI_COMM_WORLD, 1);
-            }
-        }
-
-      return terminate_simulation;
-    }
-
-
-// -------------------------------- Deal with registering plugins and automating
-// -------------------------------- their setup and selection at run time
-
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // first declare the postprocessors we know about to
-      // choose from
-      prm.enter_subsection("Termination criteria");
-      {
-        // construct a string for Patterns::MultipleSelection that
-        // contains the names of all registered termination criteria
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-        prm.declare_entry("Termination criteria",
-                          "end time",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma separated list of termination criteria that will "
-                          "determine when the simulation should end. "
-                          "Whether explicitly stated or not, the ``end time'' "
-                          "termination criterion will always be used."
-                          "The following termination criteria are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-      }
-      prm.leave_subsection();
-
-      // now declare the parameters of each of the registered
-      // plugins in turn
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      Assert (std::get<dim>(registered_plugins).plugins != nullptr,
-              ExcMessage ("No termination criteria plugins registered!?"));
-
-      // first find out which plugins are requested
-      std::vector<std::string> plugin_names;
-      prm.enter_subsection("Termination criteria");
-      {
-        plugin_names = Utilities::split_string_list(prm.get("Termination criteria"));
-        AssertThrow(Utilities::has_unique_entries(plugin_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Termination criteria/Termination criteria' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-
-        // as described, the end time plugin is always active
-        if (std::find (plugin_names.begin(), plugin_names.end(), "end time")
-            == plugin_names.end())
-          plugin_names.emplace_back("end time");
-      }
-      prm.leave_subsection();
-
-      // go through the list, create objects, initialize them, and let them parse
-      // their own parameters
-      for (const auto &plugin_name : plugin_names)
-        {
-          this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
-                                          (std::get<dim>(registered_plugins)
-                                           .create_plugin (plugin_name,
-                                                           "Termination criteria::Termination criteria")));
-          if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
-            sim->initialize_simulator (this->get_simulator());
-          this->plugin_objects.back()->parse_parameters (prm);
-          this->plugin_objects.back()->initialize ();
-
-          termination_obj_names.push_back(plugin_name);
-        }
-    }
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_termination_criterion (const std::string &name,
-                                                  const std::string &description,
-                                                  void (*declare_parameters_function) (ParameterHandler &),
-                                                  std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Termination criteria interface",
-                                                            out);
-    }
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<TerminationCriteria::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<TerminationCriteria::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<TerminationCriteria::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<TerminationCriteria::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace TerminationCriteria
-  {
-#define INSTANTIATE(dim) \
-  template class Interface<dim>; \
-  template class Manager<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/termination_criteria/steady_heat_flux.cc.bak b/source/termination_criteria/steady_heat_flux.cc.bak
deleted file mode 100644
index cc1530914be..00000000000
--- a/source/termination_criteria/steady_heat_flux.cc.bak
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
-  Copyright (C) 2021 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/termination_criteria/steady_heat_flux.h>
-#include <aspect/postprocess/heat_flux_map.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    namespace
-    {
-      /**
-       * A function that trims the handed over list and removes all entries from the front that are
-       * further back in time measured from the last entry than given by the first argument.
-       * Additionally it makes sure to always keep two entries in the list, if the list had
-       * two or more entries. Otherwise the function does not change the list.
-       */
-      void trim_time_heat_flux_list (const double necessary_time_in_steady_state,
-                                     std::list<std::pair<double, double>> &time_heat_flux_list)
-      {
-        // Remove old times until we're at the correct time period
-        // but ensure at least two entries remain in the list (one old, one current timestep)
-        auto it = time_heat_flux_list.begin();
-        while (time_heat_flux_list.back().first - (*it).first > necessary_time_in_steady_state &&
-               std::distance(it,time_heat_flux_list.end()) > 2)
-          ++it;
-
-        time_heat_flux_list.erase(time_heat_flux_list.begin(), it);
-      }
-    }
-
-
-
-    template <int dim>
-    bool
-    SteadyHeatFlux<dim>::execute()
-    {
-      const std::vector<std::vector<std::pair<double, double>>> heat_flux_and_area =
-        Postprocess::internal::compute_heat_flux_through_boundary_faces (*this);
-
-      double local_boundary_fluxes = 0.0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          for (const unsigned int f : cell->face_indices())
-            if (cell->at_boundary(f))
-              {
-                const types::boundary_id boundary_indicator
-                  = cell->face(f)->boundary_id();
-                if (boundary_indicators.find(boundary_indicator) != boundary_indicators.end())
-                  local_boundary_fluxes += heat_flux_and_area[cell->active_cell_index()][f].first;
-              }
-
-      const double global_heat_flux_integral
-        = Utilities::MPI::sum (local_boundary_fluxes, this->get_mpi_communicator());
-
-      // Keep a list of times and heat fluxes at those times
-      time_heat_flux.emplace_back(this->get_time(), global_heat_flux_integral);
-
-      // If the length of the simulation time covered in the list is shorter than the
-      // specified parameter, we must continue the simulation
-      if ((time_heat_flux.size() <= 2)
-          ||
-          (time_heat_flux.back().first - time_heat_flux.front().first < necessary_time_in_steady_state))
-        return false;
-
-      // Remove old entries outside of current time window
-      trim_time_heat_flux_list(necessary_time_in_steady_state,time_heat_flux);
-
-      // Scan through the list and calculate the min, mean and max heat flux
-      // We assume a linear change of heat flux between times
-      double flux_min, flux_max, flux_prev, time_prev, flux_sum=0, flux_mean, deviation_max;
-      flux_min = flux_max = flux_prev = time_heat_flux.front().second;
-      time_prev = time_heat_flux.front().first;
-      for (const auto &it : time_heat_flux)
-        {
-          flux_min = std::min(flux_min, it.second);
-          flux_max = std::max(flux_max, it.second);
-          flux_sum += ((it.second + flux_prev)/2.0)*(it.first-time_prev);
-          time_prev = it.first;
-          flux_prev = it.second;
-        }
-
-      flux_mean = flux_sum/(time_heat_flux.back().first-time_heat_flux.front().first);
-
-      // If the min and max are within the acceptable deviation of the mean,
-      // we are in steady state and return true, otherwise return false
-      deviation_max = std::max(flux_mean - flux_min, flux_max - flux_mean);
-
-      AssertThrow(std::abs(flux_mean) > std::numeric_limits<double>::min(),
-                  ExcMessage("The average heat flux is close to 0.0. The "
-                             "'steady state heat flux' plugin can not compute a "
-                             "relative deviation of heat flux in this case."));
-
-      if (deviation_max/flux_mean > allowed_relative_deviation)
-        return false;
-
-      return true;
-    }
-
-
-    template <int dim>
-    void
-    SteadyHeatFlux<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.enter_subsection("Steady state heat flux");
-        {
-          prm.declare_entry ("Maximum relative deviation", "0.05",
-                             Patterns::Double (0.),
-                             "The maximum relative deviation of the heat flux in recent "
-                             "simulation time for the system to be considered in "
-                             "steady state. If the actual deviation is smaller "
-                             "than this number, then the simulation will be terminated.");
-          prm.declare_entry ("Time in steady state", "1e7",
-                             Patterns::Double (0.),
-                             "The minimum length of simulation time that the system "
-                             "should be in steady state before termination. "
-                             "Note that if the time step size is similar to or larger than "
-                             "this value, the termination criterion will only have very few "
-                             "(in the most extreme case, just two) heat flux values to check. "
-                             "To ensure that a larger number of time steps are included in "
-                             "the check for steady state, this value should be much larger "
-                             "than the time step size. "
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-          prm.declare_entry ("Boundary indicators", "",
-                             Patterns::List (Patterns::Anything()),
-                             "A comma separated list of names denoting those boundaries "
-                             "that should be taken into account for integrating the heat "
-                             "flux. Note that the plugin will compute the integrated heat "
-                             "flux over these boundaries (instead of taking them into "
-                             "account individually)."
-                             "\n\n"
-                             "The names of the boundaries listed here can either be "
-                             "numbers (in which case they correspond to the numerical "
-                             "boundary indicators assigned by the geometry object), or they "
-                             "can correspond to any of the symbolic names the geometry object "
-                             "may have provided for each part of the boundary. You may want "
-                             "to compare this with the documentation of the geometry model you "
-                             "use in your model.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    SteadyHeatFlux<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.enter_subsection("Steady state heat flux");
-        {
-          allowed_relative_deviation = prm.get_double ("Maximum relative deviation");
-          necessary_time_in_steady_state = prm.get_double ("Time in steady state");
-          necessary_time_in_steady_state *= this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-          try
-            {
-              const std::vector<types::boundary_id> x_boundary_indicators
-                = this->get_geometry_model().translate_symbolic_boundary_names_to_ids(Utilities::split_string_list
-                                                                                      (prm.get ("Boundary indicators")));
-              boundary_indicators
-                = std::set<types::boundary_id> (x_boundary_indicators.begin(),
-                                                x_boundary_indicators.end());
-
-              AssertThrow (boundary_indicators.size() != 0,
-                           ExcMessage ("You have specified the steady state heat flux as one of "
-                                       "the termination criteria, but the list of boundary indicators "
-                                       "that should be used for computing the heat flux is empty."));
-            }
-          catch (const std::string &error)
-            {
-              AssertThrow (false, ExcMessage ("While parsing the entry <Termination criteria/Steady "
-                                              "state heat flux>, there was an error. Specifically, "
-                                              "the conversion function complained as follows: "
-                                              + error));
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-
-      AssertThrow (allowed_relative_deviation >= 0,
-                   ExcMessage("Relative deviation must be greater than or equal to 0."));
-      AssertThrow (necessary_time_in_steady_state > 0,
-                   ExcMessage("Steady state minimum time period must be greater than 0."));
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    ASPECT_REGISTER_TERMINATION_CRITERION(SteadyHeatFlux,
-                                          "steady state heat flux",
-                                          "A criterion that terminates the simulation when the integrated "
-                                          "heat flux over a given list of boundaries stays within a certain "
-                                          "range for a specified period of time."
-                                          "\n\n"
-                                          "The criterion considers the total heat flux over all boundaries "
-                                          "listed by their boundary indicators, rather than each boundary "
-                                          "separately. As a consequence, if the \\textit{sum} of heat fluxes "
-                                          "over individual parts of the boundary no longer changes, then this "
-                                          "criterion recommends termination, even if the heat flux over "
-                                          "individual parts of the boundary continues to change.")
-  }
-}
diff --git a/source/termination_criteria/steady_rms_velocity.cc.bak b/source/termination_criteria/steady_rms_velocity.cc.bak
deleted file mode 100644
index 3aa2ccd0782..00000000000
--- a/source/termination_criteria/steady_rms_velocity.cc.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/termination_criteria/steady_rms_velocity.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    template <int dim>
-    bool
-    SteadyRMSVelocity<dim>::execute()
-    {
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.velocities;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
-
-      double local_velocity_square_integral = 0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                                                                                        velocity_values);
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                local_velocity_square_integral += ((velocity_values[q] * velocity_values[q]) *
-                                                   fe_values.JxW(q));
-              }
-          }
-
-      const double global_velocity_square_integral
-        = Utilities::MPI::sum (local_velocity_square_integral, this->get_mpi_communicator());
-
-      // Calculate the global root mean square velocity
-      const double vrms = std::sqrt(global_velocity_square_integral) / std::sqrt(this->get_volume());
-
-      // Keep a list of times and RMS velocities at those times
-      time_rmsvel.emplace_back(this->get_time(), vrms);
-
-      // If the length of the simulation time covered in the list is shorter than the
-      // specified parameter, we must continue the simulation
-      const double adjusted_time
-        = time_length * (this->convert_output_to_years() ? year_in_seconds : 1);
-      if ((time_rmsvel.size() == 0)
-          ||
-          (time_rmsvel.back().first - time_rmsvel.front().first < adjusted_time))
-        return false;
-
-      // Remove old times until we're at the correct time period
-      std::list<std::pair<double, double>>::iterator it = time_rmsvel.begin();
-      while (time_rmsvel.back().first - (*it).first > adjusted_time)
-        ++it;
-      time_rmsvel.erase(time_rmsvel.begin(), it);
-
-      // Scan through the list and calculate the min, mean and max of the RMS velocities
-      // We assume a linear change of RMS velocity between times
-      double      rms_min, rms_max, rms_prev, time_prev, rms_sum=0, rms_mean, deviation_max;
-      rms_min = rms_max = rms_prev = time_rmsvel.front().second;
-      time_prev = time_rmsvel.front().first;
-      for (it=time_rmsvel.begin(); it!=time_rmsvel.end(); ++it)
-        {
-          rms_min = std::min(rms_min, (*it).second);
-          rms_max = std::max(rms_max, (*it).second);
-          rms_sum += (((*it).second + rms_prev)/2.0)*((*it).first-time_prev);
-          time_prev = (*it).first;
-          rms_prev = (*it).second;
-        }
-      rms_mean = rms_sum/(time_rmsvel.back().first-time_rmsvel.front().first);
-
-      // If the min and max are within the acceptable deviation of the mean,
-      // we are in steady state and return true, otherwise return false
-      deviation_max = std::max(rms_mean - rms_min, rms_max - rms_mean);
-
-      if (deviation_max/rms_mean > relative_deviation)
-        return false;
-
-      return true;
-    }
-
-
-    template <int dim>
-    void
-    SteadyRMSVelocity<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.enter_subsection("Steady state velocity");
-        {
-          prm.declare_entry ("Maximum relative deviation", "0.05",
-                             Patterns::Double (0.),
-                             "The maximum relative deviation of the RMS in recent "
-                             "simulation time for the system to be considered in "
-                             "steady state. If the actual deviation is smaller "
-                             "than this number, then the simulation will be terminated.");
-          prm.declare_entry ("Time in steady state", "1e7",
-                             Patterns::Double (0.),
-                             "The minimum length of simulation time that the system "
-                             "should be in steady state before termination."
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    SteadyRMSVelocity<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.enter_subsection("Steady state velocity");
-        {
-          relative_deviation = prm.get_double ("Maximum relative deviation");
-          time_length = prm.get_double ("Time in steady state");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-      AssertThrow (relative_deviation >= 0,
-                   ExcMessage("Relative deviation must be greater than or equal to 0."));
-      AssertThrow (time_length > 0,
-                   ExcMessage("Steady state minimum time period must be greater than 0."));
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    ASPECT_REGISTER_TERMINATION_CRITERION(SteadyRMSVelocity,
-                                          "steady state velocity",
-                                          "A criterion that terminates the simulation when the RMS "
-                                          "of the velocity field stays within a certain range for a "
-                                          "specified period of time.")
-  }
-}
diff --git a/source/termination_criteria/steady_temperature.cc.bak b/source/termination_criteria/steady_temperature.cc.bak
deleted file mode 100644
index 6a0c69da92c..00000000000
--- a/source/termination_criteria/steady_temperature.cc.bak
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
-  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/termination_criteria/steady_temperature.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    namespace
-    {
-      /**
-       * A function that trims the handed over list and removes all entries from the front that are
-       * further back in time measured from the last entry than given by the first argument.
-       * Additionally it makes sure to always keep two entries in the list, if the list had
-       * two or more entries. Otherwise the function does not change the list.
-       */
-      void trim_time_temperature_list (const double necessary_time_in_steady_state,
-                                       std::list<std::pair<double, double>> &time_temperature_list)
-      {
-        // Remove old times until we're at the correct time period
-        // but ensure at least two entries remain in the list (one old, one current timestep)
-        auto it = time_temperature_list.begin();
-        while (time_temperature_list.back().first - (*it).first > necessary_time_in_steady_state &&
-               std::distance(it,time_temperature_list.end()) > 2)
-          ++it;
-
-        time_temperature_list.erase(time_temperature_list.begin(), it);
-      }
-    }
-
-
-
-    template <int dim>
-    bool
-    SteadyTemperature<dim>::execute()
-    {
-      const Quadrature<dim> &quadrature_formula = this->introspection().quadratures.temperature;
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values   |
-                               update_quadrature_points |
-                               update_JxW_values);
-      std::vector<double> temperature_values(n_q_points);
-
-      double local_temperature_integral = 0;
-
-      typename DoFHandler<dim>::active_cell_iterator
-      cell = this->get_dof_handler().begin_active(),
-      endc = this->get_dof_handler().end();
-      for (; cell!=endc; ++cell)
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
-                                                                                         temperature_values);
-            for (unsigned int q = 0; q < n_q_points; ++q)
-              {
-                local_temperature_integral += (temperature_values[q] * fe_values.JxW(q));
-              }
-          }
-
-      const double global_temperature_integral
-        = Utilities::MPI::sum (local_temperature_integral, this->get_mpi_communicator());
-
-      // Calculate the average global temperature
-      const double average_temperature = global_temperature_integral / this->get_volume();
-
-      // Keep a list of times and temperatures at those times
-      time_temperature.emplace_back(this->get_time(), average_temperature);
-
-      // If the length of the simulation time covered in the list is shorter than the
-      // specified parameter, we must continue the simulation
-      if ((time_temperature.size() <= 2)
-          ||
-          (time_temperature.back().first - time_temperature.front().first < necessary_time_in_steady_state))
-        return false;
-
-      // Remove old entries outside of current time window
-      trim_time_temperature_list(necessary_time_in_steady_state,time_temperature);
-
-      // Scan through the list and calculate the min, mean and max temperature
-      // We assume a linear change of temperatures between times
-      double T_min, T_max, T_prev, time_prev, T_sum=0, T_mean, deviation_max;
-      T_min = T_max = T_prev = time_temperature.front().second;
-      time_prev = time_temperature.front().first;
-      for (const auto &it : time_temperature)
-        {
-          T_min = std::min(T_min, it.second);
-          T_max = std::max(T_max, it.second);
-          T_sum += ((it.second + T_prev)/2.0)*(it.first-time_prev);
-          time_prev = it.first;
-          T_prev = it.second;
-        }
-
-      T_mean = T_sum/(time_temperature.back().first-time_temperature.front().first);
-
-      // If the min and max are within the acceptable deviation of the mean,
-      // we are in steady state and return true, otherwise return false
-      deviation_max = std::max(T_mean - T_min, T_max - T_mean);
-
-      AssertThrow(std::abs(T_mean) > std::numeric_limits<double>::min(),
-                  ExcMessage("The average temperature is close to 0.0. The "
-                             "'steady state temperature' plugin can not compute a "
-                             "relative deviation of temperature in this case."));
-
-      if (deviation_max/T_mean > allowed_relative_deviation)
-        return false;
-
-      return true;
-    }
-
-
-    template <int dim>
-    void
-    SteadyTemperature<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.enter_subsection("Steady state temperature");
-        {
-          prm.declare_entry ("Maximum relative deviation", "0.05",
-                             Patterns::Double (0.),
-                             "The maximum relative deviation of the temperature in recent "
-                             "simulation time for the system to be considered in "
-                             "steady state. If the actual deviation is smaller "
-                             "than this number, then the simulation will be terminated.");
-          prm.declare_entry ("Time in steady state", "1e7",
-                             Patterns::Double (0.),
-                             "The minimum length of simulation time that the system "
-                             "should be in steady state before termination."
-                             "Units: years if the "
-                             "'Use years in output instead of seconds' parameter is set; "
-                             "seconds otherwise.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    SteadyTemperature<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.enter_subsection("Steady state temperature");
-        {
-          allowed_relative_deviation = prm.get_double ("Maximum relative deviation");
-          necessary_time_in_steady_state = prm.get_double ("Time in steady state");
-          necessary_time_in_steady_state *= this->convert_output_to_years() ? year_in_seconds : 1.0;
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-      AssertThrow (allowed_relative_deviation >= 0,
-                   ExcMessage("Relative deviation must be greater than or equal to 0."));
-      AssertThrow (necessary_time_in_steady_state > 0,
-                   ExcMessage("Steady state minimum time period must be greater than 0."));
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    ASPECT_REGISTER_TERMINATION_CRITERION(SteadyTemperature,
-                                          "steady state temperature",
-                                          "A criterion that terminates the simulation when the global integral "
-                                          "of the temperature field stays within a certain range for a "
-                                          "specified period of time.")
-  }
-}
diff --git a/source/termination_criteria/user_request.cc.bak b/source/termination_criteria/user_request.cc.bak
deleted file mode 100644
index 1ff543616d9..00000000000
--- a/source/termination_criteria/user_request.cc.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/termination_criteria/user_request.h>
-#include <aspect/utilities.h>
-
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    template <int dim>
-    bool
-    UserRequest<dim>::execute()
-    {
-      return Utilities::fexists(this->get_output_directory()+filename_to_test, this->get_mpi_communicator());
-    }
-
-    template <int dim>
-    void
-    UserRequest<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.enter_subsection("User request");
-        {
-          prm.declare_entry ("File name", "terminate-aspect",
-                             Patterns::FileName(Patterns::FileName::input),
-                             "The name of a file that, if it exists in the output "
-                             "directory (whose name is also specified in the input file) "
-                             "will lead to termination of the simulation. "
-                             "The file's location is chosen to be in the output directory, "
-                             "rather than in a generic location such as the ASPECT directory, "
-                             "so that one can run multiple simulations at the same time (which "
-                             "presumably write to different output directories) and can "
-                             "selectively terminate a particular one.");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    UserRequest<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.enter_subsection("User request");
-        {
-          filename_to_test = prm.get ("File name");
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TerminationCriteria
-  {
-    ASPECT_REGISTER_TERMINATION_CRITERION(UserRequest,
-                                          "user request",
-                                          "Terminate the simulation gracefully when a file with a specified "
-                                          "name appears in the output directory. This allows the user to "
-                                          "gracefully exit the simulation at any time by simply creating "
-                                          "such a file using, for example, \\texttt{touch output/terminate}. "
-                                          "The file's location is chosen to be in the output directory, "
-                                          "rather than in a generic location such as the ASPECT directory, "
-                                          "so that one can run multiple simulations at the same time (which "
-                                          "presumably write to different output directories) and can "
-                                          "selectively terminate a particular one.")
-  }
-}
diff --git a/source/time_stepping/conduction_time_step.cc.bak b/source/time_stepping/conduction_time_step.cc.bak
deleted file mode 100644
index 7df04c5fa67..00000000000
--- a/source/time_stepping/conduction_time_step.cc.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/time_stepping/conduction_time_step.h>
-#include <aspect/adiabatic_conditions/interface.h>
-
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    template <int dim>
-    double
-    ConductionTimeStep<dim>::execute()
-    {
-      double min_local_conduction_timestep = std::numeric_limits<double>::max();
-
-      const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
-                                               this->get_parameters().stokes_velocity_degree);
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values |
-                               update_gradients |
-                               update_quadrature_points);
-
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      MaterialModel::MaterialModelInputs<dim> in(n_q_points,
-                                                 this->introspection().n_compositional_fields);
-      MaterialModel::MaterialModelOutputs<dim> out(n_q_points,
-                                                   this->introspection().n_compositional_fields);
-      in.requested_properties = MaterialModel::MaterialProperties::equation_of_state_properties |
-                                MaterialModel::MaterialProperties::thermal_conductivity;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            in.reinit(fe_values,
-                      cell,
-                      this->introspection(),
-                      this->get_solution());
-
-            this->get_material_model().evaluate(in, out);
-
-            if (this->get_parameters().formulation_temperature_equation
-                == Parameters<dim>::Formulation::TemperatureEquation::reference_density_profile)
-              {
-                // Overwrite the density by the reference density coming from the
-                // adiabatic conditions as required by the formulation
-                for (unsigned int q=0; q<n_q_points; ++q)
-                  out.densities[q] = this->get_adiabatic_conditions().density(in.position[q]);
-              }
-            else if (this->get_parameters().formulation_temperature_equation
-                     == Parameters<dim>::Formulation::TemperatureEquation::real_density)
-              {
-                // use real density
-              }
-            else
-              AssertThrow(false, ExcNotImplemented());
-
-            // Evaluate thermal diffusivity at each quadrature point and
-            // calculate the corresponding conduction timestep, if applicable
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                const double k = out.thermal_conductivities[q];
-                const double rho = out.densities[q];
-                const double c_p = out.specific_heat[q];
-
-                Assert(rho * c_p > 0,
-                       ExcMessage ("The product of density and c_P needs to be a "
-                                   "non-negative quantity."));
-
-                const double thermal_diffusivity = k/(rho*c_p);
-
-                if (thermal_diffusivity > 0)
-                  {
-                    min_local_conduction_timestep = std::min(min_local_conduction_timestep,
-                                                             this->get_parameters().CFL_number*pow(cell->minimum_vertex_distance(),2.)
-                                                             / thermal_diffusivity);
-                  }
-              }
-          }
-
-      const double min_conduction_timestep = Utilities::MPI::min (min_local_conduction_timestep, this->get_mpi_communicator());
-
-      AssertThrow (min_conduction_timestep > 0,
-                   ExcMessage("The time step length for the each time step needs to be positive, "
-                              "but the computed step length was: " + std::to_string(min_conduction_timestep) + ". "
-                              "Please check for non-positive material properties."));
-
-      return min_conduction_timestep;
-    }
-
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    ASPECT_REGISTER_TIME_STEPPING_MODEL(ConductionTimeStep,
-                                        "conduction time step",
-                                        "This model computes the conduction time step as the minimum "
-                                        "over all cells of $ CFL h^2 \\cdot \\rho C_p / k$, "
-                                        "where k is the thermal conductivity. This plugin will always "
-                                        "request advancing to the next time step.")
-  }
-}
diff --git a/source/time_stepping/convection_time_step.cc.bak b/source/time_stepping/convection_time_step.cc.bak
deleted file mode 100644
index 9460a30d9b3..00000000000
--- a/source/time_stepping/convection_time_step.cc.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
-  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/time_stepping/convection_time_step.h>
-
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    template <int dim>
-    double
-    ConvectionTimeStep<dim>::execute()
-    {
-      const QIterated<dim> quadrature_formula (QTrapezoid<1>(),
-                                               this->get_parameters().stokes_velocity_degree);
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_values);
-
-      const unsigned int n_q_points = quadrature_formula.size();
-
-      std::vector<Tensor<1,dim>> velocity_values(n_q_points);
-      std::vector<Tensor<1,dim>> fluid_velocity_values(n_q_points);
-
-      double max_local_speed_over_meshsize = 0;
-
-      for (const auto &cell : this->get_dof_handler().active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                                                                                        velocity_values);
-
-            double max_local_velocity = 0;
-            for (unsigned int q=0; q<n_q_points; ++q)
-              max_local_velocity = std::max (max_local_velocity,
-                                             velocity_values[q].norm());
-
-            if (this->get_parameters().include_melt_transport)
-              {
-                const FEValuesExtractors::Vector ex_u_f = this->introspection().variable("fluid velocity").extractor_vector();
-                fe_values[ex_u_f].get_function_values (this->get_solution(), fluid_velocity_values);
-
-                for (unsigned int q=0; q<n_q_points; ++q)
-                  max_local_velocity = std::max (max_local_velocity,
-                                                 fluid_velocity_values[q].norm());
-              }
-
-            max_local_speed_over_meshsize = std::max(max_local_speed_over_meshsize,
-                                                     max_local_velocity
-                                                     /
-                                                     cell->minimum_vertex_distance());
-
-          }
-
-      const double max_global_speed_over_meshsize
-        = Utilities::MPI::max (max_local_speed_over_meshsize, this->get_mpi_communicator());
-
-      double min_convection_timestep = std::numeric_limits<double>::max();
-
-      if (max_global_speed_over_meshsize != 0.0)
-        min_convection_timestep = this->get_parameters().CFL_number / (this->get_parameters().temperature_degree * max_global_speed_over_meshsize);
-
-      AssertThrow (min_convection_timestep > 0,
-                   ExcMessage("The time step length for the each time step needs to be positive, "
-                              "but the computed step length was: " + std::to_string(min_convection_timestep) + ". "
-                              "Please check for non-positive material properties."));
-
-      return min_convection_timestep;
-    }
-
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    ASPECT_REGISTER_TIME_STEPPING_MODEL(ConvectionTimeStep,
-                                        "convection time step",
-                                        "This model computes the convection time step as "
-                                        "$ CFL / \\max \\| u \\| / h$ over all cells, "
-                                        "where $u$ is the velocity and $h$ is the product of mesh size "
-                                        "and temperature polynomial degree.")
-  }
-}
diff --git a/source/time_stepping/function.cc.bak b/source/time_stepping/function.cc.bak
deleted file mode 100644
index 01c554214ba..00000000000
--- a/source/time_stepping/function.cc.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-  Copyright (C) 2018 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/time_stepping/function.h>
-
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    template <int dim>
-    double
-    Function<dim>::execute()
-    {
-      double new_time_step = function.value(Point<1>(this->get_time()));
-
-      AssertThrow (new_time_step > 0,
-                   ExcMessage("The time step length for the each time step needs to be positive, "
-                              "but the computed step length of the \"function\" plugin was: " +
-                              std::to_string(new_time_step) + "."));
-
-      return new_time_step;
-    }
-
-
-
-    template <int dim>
-    void
-    Function<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Time stepping");
-      {
-        prm.enter_subsection("Function");
-        Functions::ParsedFunction<1>::declare_parameters (prm, 1);
-        prm.declare_entry("Function expression", "1.0",
-                          Patterns::Anything(),
-                          "Expression for the time step size as a function of 'time'.");
-        prm.declare_entry("Variable names", "time",
-                          Patterns::Anything(),
-                          "Name for the variable representing the current time.");
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    Function<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Time stepping");
-      {
-        prm.enter_subsection("Function");
-        try
-          {
-            function.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Timestepping.Function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'"
-                      << "More information about the cause of the parse error \n"
-                      << "is shown below.\n";
-            throw;
-          }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    ASPECT_REGISTER_TIME_STEPPING_MODEL(Function,
-                                        "function",
-                                        "This model uses a time step specified in the parameter "
-                                        "file specified as a function of time. This plugin will always "
-                                        "request advancing to the next time step.")
-  }
-}
diff --git a/source/time_stepping/interface.cc.bak b/source/time_stepping/interface.cc.bak
deleted file mode 100644
index 584da9baedd..00000000000
--- a/source/time_stepping/interface.cc.bak
+++ /dev/null
@@ -1,380 +0,0 @@
-/*
-  Copyright (C) 2019 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
- */
-
-
-#include <aspect/time_stepping/interface.h>
-#include <aspect/simulator.h>
-
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    namespace
-    {
-      std::tuple
-      <void *,
-      void *,
-      aspect::internal::Plugins::PluginList<Interface<2>>,
-      aspect::internal::Plugins::PluginList<Interface<3>>> registered_plugins;
-    }
-
-
-
-    template <int dim>
-    std::pair<Reaction, double>
-    Interface<dim>::
-    determine_reaction (const TimeStepInfo & /*info*/)
-    {
-      return std::make_pair<Reaction, double>(Reaction::advance, std::numeric_limits<double>::max());
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::
-    update()
-    {
-      double new_time_step = std::numeric_limits<double>::max();
-
-      for (const auto &plugin : this->plugin_objects)
-        {
-          const double this_time_step = plugin->execute();
-          new_time_step = std::min(new_time_step, this_time_step);
-        }
-
-      new_time_step = Utilities::MPI::min(new_time_step, this->get_mpi_communicator());
-
-      // Do not go below a minimum time step size as given by the user. Note that
-      // we first apply the minimum and then apply further restrictions that might
-      // lower this value. Hitting the end time is more important than a minimum
-      // time step size, for example.
-      new_time_step = std::max(minimum_time_step_size, new_time_step);
-
-      // Make sure we do not exceed the maximum time step length. This can happen
-      // if velocities get too small or even zero in models that are stably stratified
-      // or use prescribed velocities.
-      new_time_step = std::min(new_time_step, this->get_parameters().maximum_time_step);
-
-      // Make sure that the time step doesn't increase too fast
-      if (this->get_timestep() != 0)
-        new_time_step = std::min(new_time_step, this->get_timestep() + this->get_timestep() * this->get_parameters().maximum_relative_increase_time_step);
-
-      // Make sure we do not exceed the maximum length for the first time step
-      if (this->get_timestep_number() == 0)
-        new_time_step = std::min(new_time_step, this->get_parameters().maximum_first_time_step);
-
-      // Make sure we reduce the time step length appropriately if we terminate after this step
-      TimeStepInfo info;
-      info.reduced_by_termination_plugin = false;
-      {
-        const double reduced_time_step = termination_manager.check_for_last_time_step(new_time_step);
-        if (reduced_time_step < new_time_step)
-          {
-            new_time_step = reduced_time_step;
-            info.reduced_by_termination_plugin = true;
-          }
-      }
-      info.next_time_step_size = new_time_step;
-
-      AssertThrow (new_time_step > 0,
-                   ExcMessage("The time step length for the each time step needs to be positive, "
-                              "but the computed step length was: " + std::to_string(new_time_step) + ". "
-                              "Please check the time stepping plugins in use."));
-
-      Reaction reaction = Reaction::advance;
-      double repeat_step_size = std::numeric_limits<double>::max();
-
-      for (const auto &plugin : this->plugin_objects)
-        {
-          const std::pair<Reaction, double> answer = plugin->determine_reaction(info);
-          reaction = static_cast<Reaction>(std::min(reaction, answer.first));
-          repeat_step_size = std::min(repeat_step_size, answer.second);
-        }
-
-      reaction = static_cast<Reaction>(Utilities::MPI::min(static_cast<int>(reaction), this->get_mpi_communicator()));
-      repeat_step_size = Utilities::MPI::min(repeat_step_size, this->get_mpi_communicator());
-
-      current_reaction = reaction;
-      if (should_repeat_time_step())
-        next_time_step_size = repeat_step_size;
-      else
-        next_time_step_size = new_time_step;
-    }
-
-
-
-    template <int dim>
-    double
-    Manager<dim>::get_next_time_step_size() const
-    {
-      return next_time_step_size;
-    }
-
-
-
-    template <int dim>
-    bool
-    Manager<dim>::should_repeat_time_step() const
-    {
-      switch (current_reaction)
-        {
-          case Reaction::refine_and_repeat_step:
-            return true;
-          case Reaction::repeat_step:
-            return true;
-          case Reaction::refine_and_advance:
-            return false;
-          case Reaction::advance:
-            return false;
-
-          default:
-            AssertThrow(false, ExcNotImplemented());
-            return false;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    Manager<dim>::should_refine_mesh() const
-    {
-      switch (current_reaction)
-        {
-          case Reaction::refine_and_repeat_step:
-            return true;
-          case Reaction::repeat_step:
-            return false;
-          case Reaction::refine_and_advance:
-            return true;
-          case Reaction::advance:
-            return false;
-
-          default:
-            AssertThrow(false, ExcNotImplemented());
-            return false;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    Manager<dim>::
-    need_checkpoint_on_terminate() const
-    {
-      return do_checkpoint_on_terminate;
-    }
-
-
-
-    template <int dim>
-    bool
-    Manager<dim>::should_simulation_terminate_now() const
-    {
-      return termination_manager.execute();
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::initialize_simulator (const Simulator<dim> &simulator_object)
-    {
-      SimulatorAccess<dim>::initialize_simulator(simulator_object);
-      termination_manager.initialize_simulator(simulator_object);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::register_time_stepping_model(const std::string &name,
-                                               const std::string &description,
-                                               void (*declare_parameters_function) (ParameterHandler &),
-                                               std::unique_ptr<Interface<dim>> (*factory_function) ())
-    {
-      std::get<dim>(registered_plugins).register_plugin (name,
-                                                         description,
-                                                         declare_parameters_function,
-                                                         factory_function);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>:: declare_parameters (ParameterHandler &prm)
-    {
-      TerminationCriteria::Manager<dim>::declare_parameters(prm);
-      prm.enter_subsection("Termination criteria");
-      {
-        prm.declare_entry("Checkpoint on termination", "false",
-                          Patterns::Bool (),
-                          "Whether to checkpoint the simulation right before termination.");
-      }
-      prm.leave_subsection();
-
-
-      prm.enter_subsection("Time stepping");
-      {
-        prm.declare_entry("Minimum time step size", "0.",
-                          Patterns::Double (0.),
-                          "Specify a minimum time step size (or 0 to disable).");
-
-        const std::string pattern_of_names
-          = std::get<dim>(registered_plugins).get_pattern_of_names ();
-
-        prm.declare_entry("List of model names",
-                          "",
-                          Patterns::MultipleSelection(pattern_of_names),
-                          "A comma separated list of time stepping plugins that "
-                          "will be used to calculate the time step size. The minimum of the "
-                          " result of each plugin will be used.\n\n"
-                          "The following plugins are available:\n\n"
-                          +
-                          std::get<dim>(registered_plugins).get_description_string());
-
-      }
-      prm.leave_subsection();
-
-      std::get<dim>(registered_plugins).declare_parameters (prm);
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      termination_manager.parse_parameters(prm);
-      prm.enter_subsection("Termination criteria");
-      {
-        do_checkpoint_on_terminate = prm.get_bool("Checkpoint on termination");
-      }
-      prm.leave_subsection();
-
-      {
-        prm.enter_subsection("Time stepping");
-
-        minimum_time_step_size = prm.get_double("Minimum time step size")
-                                 * (this->convert_output_to_years() ? year_in_seconds : 1.0);
-
-        std::vector<std::string>
-        model_names
-          = Utilities::split_string_list(prm.get("List of model names"));
-
-        AssertThrow(Utilities::has_unique_entries(model_names),
-                    ExcMessage("The list of strings for the parameter "
-                               "'Time stepping/List of model names' contains entries more than once. "
-                               "This is not allowed. Please check your parameter file."));
-
-        if (model_names.size()==0)
-          {
-            // handle the default case, where the user has not chosen any time stepping scheme explicitly:
-
-            model_names.emplace_back("convection time step");
-
-            if (this->get_parameters().use_conduction_timestep)
-              model_names.emplace_back("conduction time step");
-          }
-        else
-          {
-            AssertThrow(this->get_parameters().use_conduction_timestep == false,
-                        ExcMessage("When you are using Time stepping:: List of model names, do can not "
-                                   "set \"Use conduction timestep\" to true. Use the \"conduction time step\" "
-                                   "instead"));
-          }
-
-        prm.leave_subsection();
-
-        for (const auto &model_name : model_names)
-          {
-            this->plugin_objects.push_back (std::unique_ptr<Interface<dim>>
-                                            (std::get<dim>(registered_plugins)
-                                             .create_plugin (model_name,
-                                                             "Time stepping::Model names")));
-
-            if (SimulatorAccess<dim> *sim = dynamic_cast<SimulatorAccess<dim>*>(&*this->plugin_objects.back()))
-              sim->initialize_simulator (this->get_simulator());
-
-            this->plugin_objects.back()->parse_parameters (prm);
-            this->plugin_objects.back()->initialize ();
-          }
-      }
-    }
-
-
-
-    template <int dim>
-    void
-    Manager<dim>::write_plugin_graph (std::ostream &out)
-    {
-      std::get<dim>(registered_plugins).write_plugin_graph ("Time stepping interface",
-                                                            out);
-    }
-
-
-    template <int dim>
-    std::string
-    get_valid_model_names_pattern ()
-    {
-      return std::get<dim>(registered_plugins).get_pattern_of_names ();
-    }
-
-  }
-}
-
-
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-
-  namespace internal
-  {
-    namespace Plugins
-    {
-      template <>
-      std::list<internal::Plugins::PluginList<TimeStepping::Interface<2>>::PluginInfo> *
-      internal::Plugins::PluginList<TimeStepping::Interface<2>>::plugins = nullptr;
-      template <>
-      std::list<internal::Plugins::PluginList<TimeStepping::Interface<3>>::PluginInfo> *
-      internal::Plugins::PluginList<TimeStepping::Interface<3>>::plugins = nullptr;
-    }
-  }
-
-  namespace TimeStepping
-  {
-#define INSTANTIATE(dim) \
-  \
-  template class Interface<dim>; \
-  template class Manager<dim>; \
-  template \
-  std::string \
-  get_valid_model_names_pattern<dim> ();
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-  }
-}
diff --git a/source/time_stepping/repeat_on_cutback.cc.bak b/source/time_stepping/repeat_on_cutback.cc.bak
deleted file mode 100644
index 2191a36daa4..00000000000
--- a/source/time_stepping/repeat_on_cutback.cc.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
-  Copyright (C) 2018 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/time_stepping/repeat_on_cutback.h>
-
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    template <int dim>
-    double
-    RepeatOnCutback<dim>::execute()
-    {
-      return std::numeric_limits<double>::max();
-    }
-
-
-
-    template <int dim>
-    std::pair<Reaction, double>
-    RepeatOnCutback<dim>::determine_reaction (const TimeStepInfo &info)
-    {
-      if (info.next_time_step_size < this->get_timestep()*this->repeat_threshold
-          && !info.reduced_by_termination_plugin)
-        return
-          std::make_pair<Reaction, double>(Reaction::repeat_step,
-                                           this->get_timestep()*this->cut_back_amount);
-      else
-        return
-          std::make_pair<Reaction, double>(Reaction::advance,
-                                           std::numeric_limits<double>::max());
-    }
-
-
-
-    template <int dim>
-    void
-    RepeatOnCutback<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Time stepping");
-      {
-        prm.enter_subsection("Repeat on cutback");
-
-        prm.declare_entry("Relative repeat threshold", "0.2",
-                          Patterns::Double (0.),
-                          "A factor that controls when a step is going to be repeated. If "
-                          "the newly computed step size is smaller than the last step size "
-                          "multiplied by this factor, the step is repeated.");
-
-        prm.declare_entry("Cut back amount", "0.5",
-                          Patterns::Double (0.),
-                          "A factor that controls the size of the time step when repeating. The "
-                          "default of 0.5 corresponds to 50\\% of the original step taken.");
-
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    RepeatOnCutback<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Time stepping");
-      {
-        prm.enter_subsection("Repeat on cutback");
-
-        repeat_threshold = prm.get_double("Relative repeat threshold");
-        cut_back_amount = prm.get_double("Cut back amount");
-
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace TimeStepping
-  {
-    ASPECT_REGISTER_TIME_STEPPING_MODEL(RepeatOnCutback,
-                                        "repeat on cutback",
-                                        "This time stepping plugin will detect a situation where the computed time step "
-                                        "shrinks by more than a user-controlled factor. In that situation, the previous "
-                                        "time step will be repeated with a smaller step size.\n"
-                                        "A large reduction in time step size typically happens when velocities change "
-                                        "abruptly. Repeating the time step ensure properly resolving this event. It is "
-                                        "useful to consider setting the \"Maximum relative increase in time step\" option "
-                                        "to avoid repeatedly repeating every other time step.")
-  }
-}
diff --git a/source/utilities.cc.bak b/source/utilities.cc.bak
deleted file mode 100644
index b4f6876cd61..00000000000
--- a/source/utilities.cc.bak
+++ /dev/null
@@ -1,3601 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_access.h>
-#include <aspect/geometry_model/interface.h>
-
-#ifdef ASPECT_WITH_LIBDAP
-#include <D4Connect.h>
-#include <Connect.h>
-#include <Response.h>
-#include <Array.h>
-#endif
-
-#include <array>
-#include <deal.II/base/point.h>
-
-#include <deal.II/base/mpi.h>
-#include <deal.II/base/table.h>
-#include <deal.II/base/table_indices.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/base/exceptions.h>
-#include <deal.II/base/signaling_nan.h>
-#include <deal.II/base/patterns.h>
-#include <deal.II/grid/grid_tools.h>
-
-#include <cerrno>
-#include <dirent.h>
-#include <fstream>
-#include <string>
-#include <sys/stat.h>
-#include <iostream>
-#include <regex>
-
-#include <boost/math/special_functions/spherical_harmonic.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/iostreams/filtering_stream.hpp>
-#include <boost/iostreams/filter/gzip.hpp>
-#include <boost/iostreams/copy.hpp>
-
-namespace aspect
-{
-  /**
-   * A namespace for utility functions that might be used in many different
-   * places to prevent code duplication.
-   */
-  namespace Utilities
-  {
-    namespace internal
-    {
-      namespace MPI
-      {
-        // --------------------------------------------------------------------
-        // The following is copied from deal.II's mpi.templates.h file.
-        // We should instead import it from deal.II's header files directly
-        // if that information is made available via one of the existing .h
-        // files.
-        // --------------------------------------------------------------------
-#ifdef DEAL_II_WITH_MPI
-        /**
-         * Return the corresponding MPI data type id for the argument given.
-         */
-        inline MPI_Datatype
-        mpi_type_id(const bool *)
-        {
-          return MPI_CXX_BOOL;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const char *)
-        {
-          return MPI_CHAR;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const signed char *)
-        {
-          return MPI_SIGNED_CHAR;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const short *)
-        {
-          return MPI_SHORT;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const int *)
-        {
-          return MPI_INT;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const long int *)
-        {
-          return MPI_LONG;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const unsigned char *)
-        {
-          return MPI_UNSIGNED_CHAR;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const unsigned short *)
-        {
-          return MPI_UNSIGNED_SHORT;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const unsigned int *)
-        {
-          return MPI_UNSIGNED;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const unsigned long int *)
-        {
-          return MPI_UNSIGNED_LONG;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const unsigned long long int *)
-        {
-          return MPI_UNSIGNED_LONG_LONG;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const float *)
-        {
-          return MPI_FLOAT;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const double *)
-        {
-          return MPI_DOUBLE;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const long double *)
-        {
-          return MPI_LONG_DOUBLE;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const std::complex<float> *)
-        {
-          return MPI_COMPLEX;
-        }
-
-
-
-        inline MPI_Datatype
-        mpi_type_id(const std::complex<double> *)
-        {
-          return MPI_DOUBLE_COMPLEX;
-        }
-#endif
-      }
-    }
-
-
-
-
-
-
-    template <typename T>
-    Table<2,T>
-    parse_input_table (const std::string &input_string,
-                       const unsigned int n_rows,
-                       const unsigned int n_columns,
-                       const std::string &property_name)
-    {
-      Table<2,T> input_table(n_rows,n_columns);
-
-      const std::vector<std::string> rows = Utilities::possibly_extend_from_1_to_N(Utilities::split_string_list(input_string,';'),
-                                                                                   n_rows,
-                                                                                   property_name);
-
-      for (unsigned int i=0; i<rows.size(); ++i)
-        {
-          std::vector<std::string> current_columns = Utilities::possibly_extend_from_1_to_N(Utilities::split_string_list(rows[i]),
-                                                     n_columns,
-                                                     property_name);
-
-          for (unsigned int j=0; j<current_columns.size(); ++j)
-            {
-              // get rid of surrounding whitespace
-              trim(current_columns[j]);
-
-              input_table[i][j] = boost::lexical_cast<T>(current_columns[j]);
-            }
-        }
-
-      return input_table;
-    }
-
-
-
-    namespace MapParsing
-    {
-      namespace
-      {
-        // This is a helper function used in parse_map_to_double_array below.
-        // It takes an input_string that is expected to follow the input format
-        // explained in the documentation of the parse_map_to_double_array function
-        // and parses it into a multimap, only performing rudimentary error checking
-        // for correct formatting.
-        std::multimap<std::string, double>
-        parse_string_to_map (const std::string &input_string,
-                             const Options &options)
-        {
-          std::multimap<std::string, double> parsed_map;
-
-          // Parse the input string, if it follows the structure of
-          // 'key1:value1, key2:value2', or 'key1:value1|value2, ...'.
-          if (Patterns::Map(Patterns::Anything(),
-                            Patterns::List(Patterns::Double(),
-                                           0,
-                                           std::numeric_limits<unsigned int>::max(),
-                                           "|")).match(input_string))
-            {
-              // Split the list by comma delimited components.
-              const std::vector<std::string> field_entries = dealii::Utilities::split_string_list(input_string, ',');
-              for (const auto &field_entry : field_entries)
-                {
-                  // Split each entry into string and value ( <id> : <value>)
-                  std::vector<std::string> key_and_value = Utilities::split_string_list (field_entry, ':');
-
-                  // Ensure that each entry has the correct form.
-                  AssertThrow (key_and_value.size() == 2,
-                               ExcMessage ("The format for mapped "
-                                           + options.property_name
-                                           + "requires that each entry has the "
-                                           "form `<key> : <value>' "
-                                           ", but the entry <"
-                                           + field_entry
-                                           + "> does not appear to follow this pattern."));
-
-                  // Handle special key "all", which must be the only entry if found
-                  if (key_and_value[0] == "all")
-                    {
-                      AssertThrow (field_entries.size() == 1,
-                                   ExcMessage ("The keyword `all' in the property "
-                                               + options.property_name
-                                               + " is only allowed if there is no other "
-                                               "keyword."));
-
-                      const std::vector<std::string> values = dealii::Utilities::split_string_list(key_and_value[1], '|');
-
-                      // Assign all the values to all fields
-                      for (const std::string &key: options.list_of_required_keys)
-                        for (const std::string &value : values)
-                          {
-                            parsed_map.emplace(key, Utilities::string_to_double(value));
-                          }
-                    }
-                  // Handle lists of multiple unique entries
-                  else
-                    {
-                      AssertThrow (parsed_map.find(key_and_value[0]) == parsed_map.end(),
-                                   ExcMessage ("The keyword <"
-                                               + key_and_value[0]
-                                               + "> in "
-                                               + options.property_name
-                                               + " is listed multiple times. "
-                                               "Check that you have only one value for "
-                                               "each field id in your list."));
-
-                      const std::vector<std::string> values = dealii::Utilities::split_string_list(key_and_value[1], '|');
-
-                      for (const auto &value : values)
-                        parsed_map.emplace(key_and_value[0],Utilities::string_to_double(value));
-                    }
-                }
-            }
-          // Parse the input string, if it follows the structure of
-          // 'value1, value2, value3' with as many entries as allowed keys.
-          else if (Patterns::List(Patterns::Double(),options.list_of_allowed_keys.size(),options.list_of_allowed_keys.size()).match(input_string))
-            {
-              const std::vector<double> values = possibly_extend_from_1_to_N(dealii::Utilities::string_to_double(dealii::Utilities::split_string_list(input_string)),
-                                                                             options.list_of_allowed_keys.size(),
-                                                                             options.property_name);
-
-              for (unsigned int i=0; i<values.size(); ++i)
-                {
-                  // list_of_keys and values have the same length, which is guaranteed by the
-                  // call to possibly_extend_from_1_to_N() above
-                  parsed_map.emplace(options.list_of_allowed_keys[i],values[i]);
-                }
-            }
-          // Parse the input string, if it follows the structure of
-          // 'value1, value2, value3' with one entry or as many entries as required keys.
-          else if (Patterns::List(Patterns::Double(),1,options.list_of_required_keys.size()).match(input_string))
-            {
-              const std::vector<double> values = possibly_extend_from_1_to_N (dealii::Utilities::string_to_double(dealii::Utilities::split_string_list(input_string)),
-                                                                              options.list_of_required_keys.size(),
-                                                                              options.property_name);
-
-              for (unsigned int i=0; i<values.size(); ++i)
-                {
-                  // list_of_keys and values have the same length, which is guaranteed by the
-                  // call to possibly_extend_from_1_to_N() above
-                  parsed_map.emplace(options.list_of_required_keys[i],values[i]);
-                }
-            }
-          else
-            {
-              // No Patterns matches were found!
-              AssertThrow (false,
-                           ExcMessage ("The string for property <"
-                                       + options.property_name
-                                       + "> does not have the expected format. "
-                                       + "Check that the string is either a "
-                                       + "comma separated list of `<double>' or "
-                                       + "`<key1> : <double>|<double>|..., "
-                                       + "<key2> : <double>|... , ... '. "
-                                       + "If the string looks correct, "
-                                       + "it is likely that the length of the "
-                                       + "list of keys passed to "
-                                       + "parse_map_to_double_array does not "
-                                       + "match the length of the "
-                                       + "comma separated property list."));
-            }
-
-          // Now remove all allowed but not requested keys from the map
-          // If no keys are specifically requested, do not delete any.
-          if (options.list_of_allowed_keys.size() > options.list_of_required_keys.size())
-            {
-              for (const auto &allowed_key: options.list_of_allowed_keys)
-                if (std::find(options.list_of_required_keys.begin(),
-                              options.list_of_required_keys.end(),
-                              allowed_key) == options.list_of_required_keys.end())
-                  parsed_map.erase(allowed_key);
-            }
-
-          return parsed_map;
-        }
-
-        // This is a helper function used in parse_map_to_double_array below.
-        // It takes an input multimap for example generated by parse_string_to_map
-        // above and flattens it into a
-        // vector of plain doubles (in the order of the given keys).
-        std::vector<double>
-        flatten_map_to_vector (const std::multimap<std::string, double> &map,
-                               const std::vector<std::string> &keys)
-        {
-          std::vector<double> values;
-          values.reserve(map.size());
-
-          for (const std::string &field_name: keys)
-            {
-              const std::pair<std::multimap<std::string, double>::const_iterator,
-                    std::multimap<std::string, double>::const_iterator> entry_range = map.equal_range(field_name);
-
-              for (auto entry = entry_range.first; entry != entry_range.second; ++entry)
-                values.push_back(entry->second);
-            }
-          return values;
-        }
-
-        void
-        read_or_check_map_structure (std::multimap<std::string, double> &map,
-                                     Options &options)
-        {
-          const unsigned int n_fields = options.list_of_required_keys.size();
-
-          std::vector<unsigned int> values_per_key(n_fields, 0);
-
-          if (options.check_values_per_key)
-            AssertThrow(options.n_values_per_key.size() == n_fields,
-                        ExcMessage("When providing an expected structure for input parameter " + options.property_name + " you need to provide "
-                                   + "as many entries in the structure vector as there are input field names (+1 if there is a background field). "
-                                   + "The current structure vector has " + std::to_string(options.n_values_per_key.size()) + " entries, but there are "
-                                   + std::to_string(n_fields) + " field names." ));
-
-          for (const std::pair<const std::string, double> &key_and_value: map)
-            {
-              const std::vector<std::string>::const_iterator field_name =
-                std::find(options.list_of_required_keys.begin(),
-                          options.list_of_required_keys.end(),
-                          key_and_value.first);
-
-              // Ensure that each key is in the list of field names
-              AssertThrow (field_name != options.list_of_required_keys.end(),
-                           ExcMessage ("The keyword <" + key_and_value.first + "> in "
-                                       + options.property_name + " does not match any entries "
-                                       "from the list of requested field names."
-                                       "Check that you only use valid names.\n\n"
-                                       "One example of where to check this is if "
-                                       "Compositional fields are used, "
-                                       "then check the id list "
-                                       "from `set Names of fields' in the "
-                                       "Compositional fields subsection. "
-                                       "Alternatively, if `set Names of fields' "
-                                       "is not set, the default names are "
-                                       "C_1, C_2, ..., C_n."));
-
-              const unsigned int field_index = std::distance(options.list_of_required_keys.cbegin(), field_name);
-              values_per_key[field_index] += 1;
-            }
-
-          if (options.store_values_per_key)
-            options.n_values_per_key = values_per_key;
-
-          unsigned int field_index = 0;
-          for (const unsigned int &n_values: values_per_key)
-            {
-              if (options.allow_multiple_values_per_key == false)
-                AssertThrow (n_values <= 1,
-                             ExcMessage ("The keyword <"
-                                         + options.list_of_required_keys[field_index]
-                                         + "> in "
-                                         + options.property_name
-                                         + " has multiple values, which is unexpected. "
-                                         "Check that you have only one value for "
-                                         "each field id in your list."));
-
-              if (options.allow_missing_keys == false)
-                AssertThrow (n_values > 0,
-                             ExcMessage ("The keyword <"
-                                         + options.list_of_required_keys[field_index]
-                                         + "> in "
-                                         + options.property_name
-                                         + " is not listed, although it is expected. "
-                                         "Check that you have at least one value for "
-                                         "each field id in your list (possibly plus "
-                                         "`background` if a background field is expected "
-                                         "for this property)."));
-
-              if (options.check_values_per_key)
-                {
-                  const unsigned int n_expected_values = options.n_values_per_key[field_index];
-                  const std::string field_name = options.list_of_required_keys[field_index];
-
-                  AssertThrow((n_expected_values == n_values || n_values == 1),
-                              ExcMessage("The key <" + field_name + "> in <"+ options.property_name + "> does not have "
-                                         + "the expected number of values. It expects " + std::to_string(n_expected_values)
-                                         + " or 1 values, but we found " + std::to_string(n_values) + " values."));
-
-                  // If we expect multiple values for a key, but found exactly one: assume
-                  // the one value stands for every expected value. This allows
-                  // for short and simpler input if all values for a key are the same.
-                  if (n_values == 1)
-                    {
-                      const double field_value = map.find(field_name)->second;
-                      for (unsigned int i=1; i<n_expected_values; ++i)
-                        map.emplace(field_name, field_value);
-                    }
-                }
-
-              ++field_index;
-            }
-        }
-      }
-
-      std::vector<double>
-      parse_map_to_double_array(const std::string &input_string,
-                                Options &options)
-      {
-        // Check options for consistency
-        AssertThrow (options.property_name != "",
-                     ExcMessage("parse_map_to_double_array needs a property name to be able to properly report parsing errors."));
-        AssertThrow (options.list_of_required_keys.size() != 0,
-                     ExcMessage("parse_map_to_double_array needs at least one required key name for property "
-                                + options.property_name
-                                + "."));
-        AssertThrow (options.check_values_per_key == false ||
-                     options.store_values_per_key == false,
-                     ExcMessage("parse_map_to_double_array can not simultaneously store the structure "
-                                "of the parsed map for "
-                                + options.property_name
-                                + " and check that structure against a given structure."));
-        AssertThrow (options.check_values_per_key == false ||
-                     options.n_values_per_key.size() == options.list_of_required_keys.size(),
-                     ExcMessage("parse_map_to_double_array can only check the structure "
-                                "of the parsed map for "
-                                + options.property_name
-                                + " if an expected number of values for each key is given."));
-
-        // First: parse the string into a map depending on what Pattern we are dealing with
-        std::multimap<std::string, double> parsed_map = parse_string_to_map(input_string,
-                                                                            options);
-
-        // Second: Now check that the structure of the map is as expected
-        read_or_check_map_structure(parsed_map,
-                                    options);
-
-        // Finally: Convert the map into a vector of doubles, sorted in the order
-        // of the list_of_required_keys option
-        return flatten_map_to_vector(parsed_map, options.list_of_required_keys);
-      }
-    }
-
-
-
-    std::vector<double>
-    parse_map_to_double_array (const std::string &input_string,
-                               const std::vector<std::string> &list_of_keys,
-                               const bool expects_background_field,
-                               const std::string &property_name,
-                               const bool allow_multiple_values_per_key,
-                               const std::unique_ptr<std::vector<unsigned int>> &n_values_per_key,
-                               const bool allow_missing_keys)
-    {
-      std::vector<std::string> input_field_names = list_of_keys;
-
-      if (expects_background_field)
-        input_field_names.insert(input_field_names.begin(),"background");
-
-      MapParsing::Options options(input_field_names, property_name);
-      options.allow_multiple_values_per_key = allow_multiple_values_per_key;
-      options.allow_missing_keys = allow_missing_keys;
-
-      if (n_values_per_key)
-        {
-          options.n_values_per_key = *n_values_per_key;
-          options.check_values_per_key = (n_values_per_key->size() != 0);
-          options.store_values_per_key = (n_values_per_key->size() == 0);
-        }
-
-      const auto parsed_map = MapParsing::parse_map_to_double_array(input_string, options);
-
-      if (n_values_per_key)
-        *n_values_per_key = options.n_values_per_key;
-
-      return parsed_map;
-    }
-
-
-
-    template <int dim>
-    std::vector<std::string>
-    expand_dimensional_variable_names (const std::vector<std::string> &var_declarations)
-    {
-      std::string dim_names[3] = {"x", "y", "z"};
-      char fn_split = '(', fn_end = ')';
-      std::vector<std::string> var_name_list;
-
-      for (const auto &var_decl : var_declarations)
-        {
-          if (var_decl.find(fn_split) != std::string::npos && var_decl[var_decl.length()-1]==fn_end)
-            {
-              const std::string fn_name = var_decl.substr(0, var_decl.find(fn_split));
-
-              // Cannot be const because will be manipulated to strip whitespace
-              std::string var_name = var_decl.substr(var_decl.find(fn_split)+1, var_decl.length()-2-var_decl.find(fn_split));
-              while ((var_name.length() != 0) && (var_name[0] == ' '))
-                var_name.erase(0, 1);
-              while ((var_name.length() != 0) && (var_name[var_name.length()-1] == ' '))
-                var_name.erase(var_name.length()-1, 1);
-              if (fn_name == "vector")
-                {
-                  for (int i=0; i<dim; ++i)
-                    var_name_list.push_back(var_name+"_"+dim_names[i]);
-                }
-              else if (fn_name == "tensor")
-                {
-                  for (int i=0; i<dim; ++i)
-                    for (int j=0; j< dim; ++j)
-                      var_name_list.push_back(var_name+"_"+dim_names[i]+dim_names[j]);
-                }
-              else
-                {
-                  var_name_list.push_back(var_decl);
-                }
-            }
-          else
-            {
-              var_name_list.push_back(var_decl);
-            }
-        }
-      return var_name_list;
-    }
-
-
-
-    /**
-    * This is an internal deal.II function stolen from dof_tools.cc
-    *
-    * Return an array that for each dof on the reference cell lists the
-    * corresponding vector component.
-    */
-    template <int dim, int spacedim>
-    std::vector<unsigned char>
-    get_local_component_association (const FiniteElement<dim,spacedim>  &fe,
-                                     const ComponentMask        & /*component_mask*/)
-    {
-      const unsigned char invalid = static_cast<unsigned char>(-1);
-      std::vector<unsigned char> local_component_association (fe.dofs_per_cell, invalid);
-
-      // compute the component each local dof belongs to.
-      // if the shape function is primitive, then this
-      // is simple and we can just associate it with
-      // what system_to_component_index gives us
-      for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
-        {
-          // see the deal.II version if we ever need non-primitive FEs.
-          Assert (fe.is_primitive(i), ExcNotImplemented());
-          local_component_association[i] =
-            fe.system_to_component_index(i).first;
-        }
-
-      Assert (std::find (local_component_association.begin(),
-                         local_component_association.end(),
-                         invalid)
-              ==
-              local_component_association.end(),
-              ExcInternalError());
-
-      return local_component_association;
-    }
-
-
-
-    template <int dim>
-    IndexSet extract_locally_active_dofs_with_component(const DoFHandler<dim> &dof_handler,
-                                                        const ComponentMask &component_mask)
-    {
-      std::vector<unsigned char> local_asoc =
-        get_local_component_association (dof_handler.get_fe(),
-                                         ComponentMask(dof_handler.get_fe().n_components(), true));
-
-      IndexSet ret(dof_handler.n_dofs());
-
-      unsigned int dofs_per_cell = dof_handler.get_fe().dofs_per_cell;
-      std::vector<types::global_dof_index> indices(dofs_per_cell);
-      for (const auto &cell : dof_handler.active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            cell->get_dof_indices(indices);
-            for (unsigned int i=0; i<dofs_per_cell; ++i)
-              if (component_mask[local_asoc[i]])
-                ret.add_index(indices[i]);
-          }
-
-      return ret;
-    }
-
-
-
-    template <int dim>
-    std::vector<Point<dim>> get_unit_support_points(const SimulatorAccess<dim> &simulator_access)
-    {
-      if ( !simulator_access.get_parameters().use_locally_conservative_discretization )
-        {
-          return simulator_access.get_fe().get_unit_support_points();
-        }
-      else
-        {
-          //special case for discontinuous pressure elements, which lack unit support points
-          const unsigned int dofs_per_cell = simulator_access.get_fe().dofs_per_cell;
-          std::vector<Point<dim>> unit_support_points;
-          unit_support_points.reserve(dofs_per_cell);
-
-          for (unsigned int dof=0; dof < dofs_per_cell; ++dof)
-            {
-              // base will hold element, base_index holds node/shape function within that element
-              const unsigned int base       = simulator_access.get_fe().system_to_base_index(dof).first.first;
-              const unsigned int base_index = simulator_access.get_fe().system_to_base_index(dof).second;
-              // get the unit support points for the relevant element
-              const std::vector<Point<dim>> &my_support_points = simulator_access.get_fe().base_element(base).get_unit_support_points();
-              if ( my_support_points.size() == 0 )
-                {
-                  //manufacture a support point, arbitrarily at cell center
-                  if (dim==2)
-                    unit_support_points.push_back(Point<dim> (0.5,0.5));
-                  if (dim==3)
-                    unit_support_points.push_back(Point<dim> (0.5,0.5,0.5));
-                }
-              else
-                {
-                  unit_support_points.push_back(my_support_points[base_index]);
-                }
-            }
-          return unit_support_points;
-        }
-    }
-
-
-
-    template <int dim>
-    bool
-    point_is_in_triangulation(const Mapping<dim> &mapping,
-                              const parallel::distributed::Triangulation<dim> &triangulation,
-                              const Point<dim> &point,
-                              const MPI_Comm mpi_communicator)
-    {
-      // Try to find the cell around the given point.
-      bool cell_found = false;
-      std::pair<const typename parallel::distributed::Triangulation<dim>::active_cell_iterator,
-          Point<dim>> it =
-            GridTools::find_active_cell_around_point<>(mapping, triangulation, point);
-
-      // If we found the correct cell on this MPI process, we have found the right cell.
-      if (it.first.state() == IteratorState::valid && it.first->is_locally_owned())
-        cell_found = true;
-
-      // Compute how many processes found the cell.
-      const int n_procs_cell_found = Utilities::MPI::sum(cell_found ? 1 : 0, mpi_communicator);
-      // If at least one process found the cell, the point is in the triangulation.
-      if (n_procs_cell_found > 0)
-        return true;
-      else
-        return false;
-    }
-
-
-
-    namespace Coordinates
-    {
-
-      template <int dim>
-      std::array<double,dim>
-      WGS84_coordinates(const Point<dim> &position)
-      {
-        Assert (dim==3, ExcNotImplemented());
-
-        std::array<double,dim> ecoord;
-
-        // Define WGS84 ellipsoid constants.
-        const double radius = 6378137.;
-        const double ellipticity = 8.1819190842622e-2;
-        const double b = std::sqrt(radius * radius
-                                   * (1 - ellipticity * ellipticity));
-        const double ep = std::sqrt((radius * radius - b * b) / (b * b));
-        const double p = std::sqrt(position(0) * position(0) + position(1) * position(1));
-        const double th = std::atan2(radius * position(2), b * p);
-        ecoord[2] = std::atan2((position(2) + ep * ep * b * std::sin(th)
-                                * std::sin(th) * std::sin(th)),
-                               (p - (ellipticity * ellipticity * radius * (std::cos(th)
-                                                                           * std::cos(th) * std::cos(th)))))
-                    * constants::radians_to_degree;
-
-        ecoord[1] = std::atan2(position(1), position(0))
-                    * constants::radians_to_degree;
-
-        // Set all longitudes between [0,360]:
-        if (ecoord[1] < 0.)
-          ecoord[1] += 360.;
-        else if (ecoord[1] > 360.)
-          ecoord[1] -= 360.;
-
-
-        ecoord[0] = radius/std::sqrt(1- ellipticity * ellipticity
-                                     * std::sin(constants::degree_to_radians * ecoord[2])
-                                     * std::sin(constants::degree_to_radians * ecoord[2]));
-        return ecoord;
-      }
-
-
-
-      template <int dim>
-      std::array<double,dim>
-      cartesian_to_spherical_coordinates(const Point<dim> &position)
-      {
-        std::array<double,dim> scoord;
-
-        scoord[0] = position.norm(); // R
-
-        // Compute the longitude phi. Note that atan2 is documented to return
-        // its result as a value between -pi and +pi, whereas we use the
-        // convention that we consider eastern longitude between 0 and 2pi.
-        // As a consequence, we correct where necessary.
-        scoord[1] = std::atan2(position(1),position(0));
-        if (scoord[1] < 0.0)
-          scoord[1] += 2.0*numbers::PI; // correct phi to [0,2*pi]
-
-        // In 3d also compute the polar angle (=colatitude)
-        if (dim==3)
-          {
-            if (/* R= */scoord[0] > std::numeric_limits<double>::min())
-              scoord[2] = std::acos(position(2)/scoord[0]);
-            else
-              scoord[2] = 0.0;
-          }
-        return scoord;
-      }
-
-
-
-      template <int dim>
-      Point<dim>
-      spherical_to_cartesian_coordinates(const std::array<double,dim> &scoord)
-      {
-        Point<dim> ccoord;
-
-        switch (dim)
-          {
-            case 2:
-            {
-              ccoord[0] = scoord[0] * std::cos(scoord[1]); // X
-              ccoord[1] = scoord[0] * std::sin(scoord[1]); // Y
-              break;
-            }
-            case 3:
-            {
-              ccoord[0] = scoord[0] * std::sin(scoord[2]) * std::cos(scoord[1]); // X
-              ccoord[1] = scoord[0] * std::sin(scoord[2]) * std::sin(scoord[1]); // Y
-              ccoord[2] = scoord[0] * std::cos(scoord[2]); // Z
-              break;
-            }
-            default:
-              Assert (false, ExcNotImplemented());
-              break;
-          }
-
-        return ccoord;
-      }
-
-
-
-      template <int dim>
-      std::array<double,3>
-      cartesian_to_ellipsoidal_coordinates(const Point<3> &x,
-                                           const double semi_major_axis_a,
-                                           const double eccentricity)
-      {
-        const double R    = semi_major_axis_a;
-        const double b      = std::sqrt(R * R * (1 - eccentricity * eccentricity));
-        const double ep     = std::sqrt((R * R - b * b) / (b * b));
-        const double p      = std::sqrt(x(0) * x(0) + x(1) * x(1));
-        const double th     = std::atan2(R * x(2), b * p);
-        const double phi    = std::atan2(x(1), x(0));
-        const double theta  = std::atan2(x(2) + ep * ep * b * std::pow(std::sin(th),3),
-                                         (p - (eccentricity * eccentricity * R  * std::pow(std::cos(th),3))));
-        const double R_bar = R / (std::sqrt(1 - eccentricity * eccentricity * std::sin(theta) * std::sin(theta)));
-        const double R_plus_d = p / std::cos(theta);
-
-        std::array<double,3> phi_theta_d;
-        phi_theta_d[0] = phi;
-
-        phi_theta_d[1] = theta;
-        phi_theta_d[2] = R_plus_d - R_bar;
-        return phi_theta_d;
-      }
-
-
-
-      template <int dim>
-      Point<3>
-      ellipsoidal_to_cartesian_coordinates(const std::array<double,3> &phi_theta_d,
-                                           const double semi_major_axis_a,
-                                           const double eccentricity)
-      {
-        const double phi   = phi_theta_d[0];
-        const double theta = phi_theta_d[1];
-        const double d     = phi_theta_d[2];
-
-        const double R_bar = semi_major_axis_a / std::sqrt(1 - (eccentricity * eccentricity *
-                                                                std::sin(theta) * std::sin(theta)));
-
-        return Point<3> ((R_bar + d) * std::cos(phi) * std::cos(theta),
-                         (R_bar + d) * std::sin(phi) * std::cos(theta),
-                         ((1 - eccentricity * eccentricity) * R_bar + d) * std::sin(theta));
-
-      }
-
-
-
-      template <int dim>
-      Tensor<1, dim>
-      spherical_to_cartesian_vector(const Tensor<1, dim> &spherical_vector,
-                                    const Point<dim> &position)
-      {
-        Tensor<1, dim> cartesian_vector;
-
-        const std::array<double, dim> r_phi_theta = cartesian_to_spherical_coordinates(position);
-
-        switch (dim)
-          {
-            case 2:
-            {
-              const double phi = r_phi_theta[1];
-
-              const double u_r   = spherical_vector[0];
-              const double u_phi = spherical_vector[1];
-
-              cartesian_vector[0] = std::cos(phi)*u_r
-                                    - std::sin(phi)*u_phi; // X
-              cartesian_vector[1] = std::sin(phi)*u_r
-                                    + std::cos(phi)*u_phi; // Y
-
-              break;
-            }
-            case 3:
-            {
-              const double phi   = r_phi_theta[1];
-              const double theta = r_phi_theta[2];
-
-              const double u_r     = spherical_vector[0];
-              const double u_phi   = spherical_vector[1];
-              const double u_theta = spherical_vector[2];
-
-              cartesian_vector[0] = std::cos(phi)*std::sin(theta)*u_r
-                                    - std::sin(phi)*u_phi
-                                    + std::cos(phi)*std::cos(theta)*u_theta; // X
-              cartesian_vector[1] = std::sin(phi)*std::sin(theta)*u_r
-                                    + std::cos(phi)*u_phi
-                                    + std::sin(phi)*std::cos(theta)*u_theta; // Y
-              cartesian_vector[2] = std::cos(theta)*u_r
-                                    - std::sin(theta)*u_theta; // Z
-              break;
-            }
-
-            default:
-              Assert (false, ExcNotImplemented());
-              break;
-          }
-
-        return cartesian_vector;
-      }
-
-
-
-      CoordinateSystem
-      string_to_coordinate_system(const std::string &coordinate_system)
-      {
-        if (coordinate_system == "cartesian")
-          return cartesian;
-        else if (coordinate_system == "spherical")
-          return spherical;
-        else if (coordinate_system == "depth")
-          return Coordinates::depth;
-        else
-          AssertThrow(false, ExcNotImplemented());
-
-        return Coordinates::invalid;
-      }
-    }
-
-
-
-    template <int dim>
-    bool
-    polygon_contains_point(const std::vector<Point<2>> &point_list,
-                           const dealii::Point<2> &point)
-    {
-      /**
-       * This code has been based on http://geomalgorithms.com/a03-_inclusion.html,
-       * and therefore requires the following copyright notice:
-       *
-       * Copyright 2000 softSurfer, 2012 Dan Sunday
-       * This code may be freely used and modified for any purpose
-       * providing that this copyright notice is included with it.
-       * SoftSurfer makes no warranty for this code, and cannot be held
-       * liable for any real or imagined damage resulting from its use.
-       * Users of this code must verify correctness for their application.
-       *
-       * The main functional difference between the original code and this
-       * code is that all the boundaries are considered to be inside the
-       * polygon. One should of course realize that with floating point
-       * arithmetic no guarantees can be made for the borders, but for
-       * exact arithmetic this algorithm would work (also see polygon
-       * in point test).
-       */
-      int pointNo = point_list.size();
-      int    wn = 0;    // the  winding number counter
-      int   j=pointNo-1;
-
-      // loop through all edges of the polygon
-      for (int i=0; i<pointNo; ++i)
-        {
-          // edge from V[i] to  V[i+1]
-          if (point_list[j][1] <= point[1])
-            {
-              // start y <= P.y
-              if (point_list[i][1] >= point[1])      // an upward crossing
-                {
-                  const double is_left = (point_list[i][0] - point_list[j][0]) * (point[1] - point_list[j][1])
-                                         - (point[0] -  point_list[j][0]) * (point_list[i][1] - point_list[j][1]);
-
-                  if ( is_left > 0 && point_list[i][1] > point[1])
-                    {
-                      // P left of  edge
-                      ++wn;            // have  a valid up intersect
-                    }
-                  else if ( is_left == 0)
-                    {
-                      // The point is exactly on the infinite line.
-                      // determine if it is on the segment
-                      const double dot_product = (point - point_list[j])*(point_list[i] - point_list[j]);
-
-                      if (dot_product >= 0)
-                        {
-                          const double squaredlength = (point_list[i] - point_list[j]).norm_square();
-
-                          if (dot_product <= squaredlength)
-                            {
-                              return true;
-                            }
-                        }
-                    }
-                }
-            }
-          else
-            {
-              // start y > P.y (no test needed)
-              if (point_list[i][1]  <= point[1])     // a downward crossing
-                {
-                  const double is_left = (point_list[i][0] - point_list[j][0]) * (point[1] - point_list[j][1])
-                                         - (point[0] -  point_list[j][0]) * (point_list[i][1] - point_list[j][1]);
-
-                  if ( is_left < 0)
-                    {
-                      // P right of  edge
-                      --wn;            // have  a valid down intersect
-                    }
-                  else if ( is_left == 0)
-                    {
-                      // This code is to make sure that the boundaries are included in the polygon.
-                      // The point is exactly on the infinite line.
-                      // determine if it is on the segment
-                      const double dot_product = (point - point_list[j])*(point_list[i] - point_list[j]);
-
-                      if (dot_product >= 0)
-                        {
-                          const double squaredlength = (point_list[i] - point_list[j]).norm_square();
-
-                          if (dot_product <= squaredlength)
-                            {
-                              return true;
-                            }
-                        }
-                    }
-                }
-            }
-          j=i;
-        }
-
-      return (wn != 0);
-    }
-
-
-
-    template <int dim>
-    double
-    signed_distance_to_polygon(const std::vector<Point<2>> &point_list,
-                               const dealii::Point<2> &point)
-    {
-      // If the point lies outside polygon, we give it a negative sign,
-      // inside a positive sign.
-      const double sign = polygon_contains_point<dim>(point_list, point) ? 1.0 : -1.0;
-
-      /**
-       * This code is based on http://geomalgorithms.com/a02-_lines.html#Distance-to-Infinite-Line,
-       * and therefore requires the following copyright notice:
-       *
-       * Copyright 2000 softSurfer, 2012 Dan Sunday
-       * This code may be freely used and modified for any purpose
-       * providing that this copyright notice is included with it.
-       * SoftSurfer makes no warranty for this code, and cannot be held
-       * liable for any real or imagined damage resulting from its use.
-       * Users of this code must verify correctness for their application.
-       *
-       */
-
-      const unsigned int n_poly_points = point_list.size();
-      AssertThrow(n_poly_points >= 3, ExcMessage("Not enough polygon points were specified."));
-
-      // Initialize a vector of distances for each point of the polygon with a very large distance
-      std::vector<double> distances(n_poly_points, 1e23);
-
-      // Create another polygon but with all points shifted 1 position to the right
-      std::vector<Point<2>> shifted_point_list(n_poly_points);
-      shifted_point_list[0] = point_list[n_poly_points-1];
-
-      for (unsigned int i = 0; i < n_poly_points-1; ++i)
-        shifted_point_list[i+1] = point_list[i];
-
-      for (unsigned int i = 0; i < n_poly_points; ++i)
-        {
-          const std::array<Point<2>,2> list = {{point_list[i], shifted_point_list[i]}};
-          distances[i] = distance_to_line(list, point);
-        }
-
-      // Return the minimum of the distances of the point to all polygon segments
-      return *std::min_element(distances.begin(),distances.end()) * sign;
-    }
-
-
-
-    double
-    distance_to_line(const std::array<dealii::Point<2>,2> &point_list,
-                     const dealii::Point<2> &point)
-    {
-
-      /**
-       * This code is based on http://geomalgorithms.com/a02-_lines.html#Distance-to-Infinite-Line,
-       * and therefore requires the following copyright notice:
-       *
-       * Copyright 2000 softSurfer, 2012 Dan Sunday
-       * This code may be freely used and modified for any purpose
-       * providing that this copyright notice is included with it.
-       * SoftSurfer makes no warranty for this code, and cannot be held
-       * liable for any real or imagined damage resulting from its use.
-       * Users of this code must verify correctness for their application.
-       *
-       */
-
-      const unsigned int n_poly_points = point_list.size();
-      AssertThrow(n_poly_points == 2, ExcMessage("A list of points for a line segment should consist of 2 points."));
-
-      // Create vector along the polygon line segment P0 to P1
-      const Tensor<1,2> vector_segment = point_list[1] - point_list[0];
-      // Create vector from point P to the second segment point
-      const Tensor<1,2> vector_point_segment = point - point_list[0];
-
-      // Compute dot products to get angles
-      const double c1 = vector_point_segment * vector_segment;
-
-      // Point P's perpendicular base line lies outside segment, before P0.
-      // Return distance between points P and P0.
-      if (c1 <= 0.0)
-        return (Tensor<1,2> (point_list[0] - point)).norm();
-
-      const double c2 = vector_segment * vector_segment;
-
-      // Point P's perpendicular base line lies outside segment, after P1.
-      // Return distance between points P and P1.
-      if (c2 <= c1)
-        return (Tensor<1,2> (point_list[1] - point)).norm();
-
-      // Point P's perpendicular base line lies on the line segment.
-      // Return distance between point P and the base point.
-      const Point<2> point_on_segment = point_list[0] + (c1/c2) * vector_segment;
-      return (Tensor<1,2> (point - point_on_segment)).norm();
-    }
-
-
-
-    template <int dim>
-    std::array<Tensor<1,dim>,dim-1>
-    orthogonal_vectors (const Tensor<1,dim> &v)
-    {
-      Assert (v.norm() > 0,
-              ExcMessage ("This function can not be called with a zero "
-                          "input vector."));
-
-      std::array<Tensor<1,dim>,dim-1> return_value;
-      switch (dim)
-        {
-          case 2:
-          {
-            // create a direction by swapping the two coordinates and
-            // flipping one sign; this is orthogonal to 'v' and has
-            // the same length already
-            return_value[0][0] = v[1];
-            return_value[0][1] = -v[0];
-            break;
-          }
-
-          case 3:
-          {
-            // In 3d, we can get two other vectors in a 3-step procedure:
-            // - compute a 'w' that is definitely not collinear with 'v'
-            // - compute the first direction as u[1] = v \times w,
-            //   normalize it
-            // - compute the second direction as u[2] = v \times u[1],
-            //   normalize it
-            //
-            // For the first step, use a procedure suggested by Luca Heltai:
-            // Set d to the index of the largest component of v. Make a vector
-            // with this component equal to zero, and with the other two
-            // equal to the norm of the point. Call this 'w'.
-            unsigned int max_component = 0;
-            for (unsigned int d=1; d<dim; ++d)
-              if (std::fabs(v[d]) > std::fabs(v[max_component]))
-                max_component = d;
-            Tensor<1,dim> w = v;
-            w[max_component] = 0;
-            for (unsigned int d=1; d<dim; ++d)
-              if (d != max_component)
-                w[d] = v.norm();
-
-            return_value[0] = cross_product_3d(v, w);
-            return_value[0] *= v.norm() / return_value[0].norm();
-
-            return_value[1] = cross_product_3d(v, return_value[0]);
-            return_value[1] *= v.norm() / return_value[1].norm();
-
-            break;
-          }
-
-          default:
-            Assert (false, ExcNotImplemented());
-        }
-
-      return return_value;
-    }
-
-
-
-    Tensor<2,3>
-    rotation_matrix_from_axis (const Tensor<1,3> &rotation_axis,
-                               const double rotation_angle)
-    {
-      Tensor<2,3> rotation_matrix;
-      rotation_matrix[0][0] = (1-std::cos(rotation_angle)) * rotation_axis[0]*rotation_axis[0] + std::cos(rotation_angle);
-      rotation_matrix[0][1] = (1-std::cos(rotation_angle)) * rotation_axis[0]*rotation_axis[1] - rotation_axis[2] * std::sin(rotation_angle);
-      rotation_matrix[0][2] = (1-std::cos(rotation_angle)) * rotation_axis[0]*rotation_axis[2] + rotation_axis[1] * std::sin(rotation_angle);
-      rotation_matrix[1][0] = (1-std::cos(rotation_angle)) * rotation_axis[1]*rotation_axis[0] + rotation_axis[2] * std::sin(rotation_angle);
-      rotation_matrix[1][1] = (1-std::cos(rotation_angle)) * rotation_axis[1]*rotation_axis[1] + std::cos(rotation_angle);
-      rotation_matrix[1][2] = (1-std::cos(rotation_angle)) * rotation_axis[1]*rotation_axis[2] - rotation_axis[0] * std::sin(rotation_angle);
-      rotation_matrix[2][0] = (1-std::cos(rotation_angle)) * rotation_axis[2]*rotation_axis[0] - rotation_axis[1] * std::sin(rotation_angle);
-      rotation_matrix[2][1] = (1-std::cos(rotation_angle)) * rotation_axis[2]*rotation_axis[1] + rotation_axis[0] * std::sin(rotation_angle);
-      rotation_matrix[2][2] = (1-std::cos(rotation_angle)) * rotation_axis[2]*rotation_axis[2] + std::cos(rotation_angle);
-      return rotation_matrix;
-    }
-
-
-
-    Tensor<2,3>
-    compute_rotation_matrix_for_slice (const Tensor<1,3> &point_one,
-                                       const Tensor<1,3> &point_two)
-    {
-      AssertThrow(point_one.norm() > std::numeric_limits<double>::min()
-                  && point_two.norm() > std::numeric_limits<double>::min(),
-                  ExcMessage("The points that are used to define the slice that "
-                             "should be rotated onto the x-y-plane can not lie "
-                             "at the origin of the coordinate system."));
-
-      // Set up the normal vector of an unrotated 2d spherical shell
-      // that by default lies in the x-y plane.
-      const Tensor<1,3> unrotated_normal_vector ({0.0,0.0,1.0});
-
-      // Compute the normal vector of the plane that contains
-      // the origin and the two points specified as the function arguments.
-      Tensor<1,3> rotated_normal_vector = cross_product_3d(point_one, point_two);
-
-      AssertThrow(rotated_normal_vector.norm() > std::numeric_limits<double>::min(),
-                  ExcMessage("The points that are used to define the slice that "
-                             "should be rotated onto the x-y-plane can not lie "
-                             "along the line that also goes through the origin "
-                             "of the coordinate system."));
-
-      rotated_normal_vector /= rotated_normal_vector.norm();
-
-      Tensor<2,3> rotation_matrix ({{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}});
-
-      // Calculate the crossing line of the two normals,
-      // which will be the rotation axis to transform the one
-      // normal into the other
-      Tensor<1,3> rotation_axis = cross_product_3d(unrotated_normal_vector, rotated_normal_vector);
-
-      // If the normal vector of the slice already points in z-direction, we do not have to
-      // apply the first rotation.
-      if (rotation_axis.norm() > std::numeric_limits<double>::min())
-        {
-          rotation_axis /= rotation_axis.norm();
-
-          // Calculate the rotation angle from the inner product rule
-          const double rotation_angle = std::acos(rotated_normal_vector * unrotated_normal_vector);
-          rotation_matrix = rotation_matrix_from_axis(rotation_axis, rotation_angle);
-        }
-
-      // Now apply the rotation that will project point_one onto the known point
-      // (0,1,0).
-      const Tensor<1,3> normalized_point_one = point_one / point_one.norm();
-      const Tensor<1,3> rotated_point_one = transpose(rotation_matrix) * normalized_point_one;
-      const Tensor<1,3> final_point_one ({0.0,1.0,0.0});
-
-      const double second_rotation_angle = std::acos(rotated_point_one * final_point_one);
-      Tensor<1,3> second_rotation_axis = cross_product_3d(final_point_one, rotated_point_one);
-
-      // If point 1 is already located at (0,1,0) after the first rotation, we do not
-      // have to apply the second rotation.
-      if (second_rotation_axis.norm() > std::numeric_limits<double>::min())
-        {
-          second_rotation_axis /= second_rotation_axis.norm();
-          const Tensor<2,3> second_rotation_matrix = rotation_matrix_from_axis(second_rotation_axis, second_rotation_angle);
-
-          // The final rotation used for the model will be the combined
-          // rotation of the two operations above. This is achieved by a
-          // matrix multiplication of the rotation matrices.
-          // This concatenation of rotations is the reason for using a
-          // rotation matrix instead of a combined rotation_axis + angle.
-          rotation_matrix = rotation_matrix * second_rotation_matrix;
-        }
-      return rotation_matrix;
-    }
-
-
-
-    std::pair<double,double> real_spherical_harmonic( const unsigned int l,
-                                                      const unsigned int m,
-                                                      const double theta,
-                                                      const double phi)
-    {
-      Assert (l<65, ExcMessage("ASPECT uses the implementation of spherical harmonics provided by the "
-                               "BOOST library, which is only accurate up a limited degree (see "
-                               "https://www.boost.org/doc/libs/1_62_0/libs/math/doc/html/math_toolkit/sf_poly/sph_harm.html#math_toolkit.sf_poly.sph_harm.accuracy). "
-                               "The function Utilities::real_spherical_harmonic was asked for a higher degree of "
-                               + std::to_string(l) + ", which is not guaranteed to produce a correct value. "
-                               "If you absolutely need to use higher degrees, uncomment this assertion on "
-                               "your own risk and benchmark your results before using them."));
-
-      const double sqrt_2 = numbers::SQRT2;
-      const std::complex<double> sph_harm_val = boost::math::spherical_harmonic( l, m, theta, phi );
-      if ( m == 0 )
-        return std::make_pair( sph_harm_val.real(), 0.0 );
-      else
-        return std::make_pair( sqrt_2 * sph_harm_val.real(), sqrt_2 * sph_harm_val.imag() );
-    }
-
-
-
-    bool
-    fexists(const std::string &filename)
-    {
-      std::ifstream ifile(filename);
-
-      // return whether construction of the input file has succeeded;
-      // success requires the file to exist and to be readable
-      return static_cast<bool>(ifile);
-    }
-
-
-
-    bool
-    fexists(const std::string &filename, const MPI_Comm comm)
-    {
-      bool file_exists = false;
-      if (Utilities::MPI::this_mpi_process(comm) == 0)
-        {
-          std::ifstream ifile(filename);
-
-          // return whether construction of the input file has succeeded;
-          // success requires the file to exist and to be readable
-          file_exists = static_cast<bool>(ifile);
-        }
-      return Utilities::MPI::broadcast(comm, file_exists);
-    }
-
-
-
-    bool
-    filename_is_url(const std::string &filename)
-    {
-      if (filename.find("http://") == 0 || filename.find("https://") == 0 || filename.find("file://") == 0)
-        return true;
-      else
-        return false;
-    }
-
-
-
-    std::string
-    read_and_distribute_file_content(const std::string &filename,
-                                     const MPI_Comm comm)
-    {
-      std::string data_string;
-
-      if (Utilities::MPI::this_mpi_process(comm) == 0)
-        {
-          std::size_t filesize;
-
-          // Check to see if the prm file will be reading data from disk or
-          // from a provided URL
-          if (filename_is_url(filename))
-            {
-#ifdef ASPECT_WITH_LIBDAP
-              std::unique_ptr<libdap::Connect> url
-                = std::make_unique<libdap::Connect>(filename);
-              libdap::BaseTypeFactory factory;
-              libdap::DataDDS dds(&factory);
-              libdap::DAS das;
-
-              url->request_data(dds, "");
-              url->request_das(das);
-
-
-              // Temporary vector that will hold the different arrays stored in urlArray
-              std::vector<libdap::dods_float32> tmp;
-              // Vector that will hold the arrays (columns) and the values within those arrays
-              std::vector<std::vector<libdap::dods_float32>> columns;
-
-              // Check dds values to make sure the arrays are of the same length and of type string
-              for (libdap::DDS::Vars_iter i = dds.var_begin(); i != dds.var_end(); ++i)
-                {
-                  libdap::BaseType *btp = *i;
-                  if ((*i)->type() == libdap::dods_array_c)
-                    {
-                      // Array to store the url data
-                      libdap::Array *urlArray;
-                      urlArray = static_cast <libdap::Array *>(btp);
-                      if (urlArray->var() != nullptr && urlArray->var()->type() == libdap::dods_float32_c)
-                        {
-                          tmp.resize(urlArray->length());
-
-                          // The url Array contains a separate array for each column of data.
-                          // This will put each of these individual arrays into its own vector.
-                          urlArray->value(&tmp[0]);
-                          columns.push_back(tmp);
-                        }
-                      else
-                        {
-                          AssertThrow (false,
-                                       ExcMessage (std::string("Error when reading from url: ") + filename +
-                                                   " Check your connection to the server and make sure the server "
-                                                   "delivers correct data."));
-                        }
-
-                    }
-                  else
-                    {
-                      AssertThrow (false,
-                                   ExcMessage (std::string("Error when reading from url: ") + filename +
-                                               " Check your connection to the server and make sure the server "
-                                               "delivers correct data."));
-                    }
-                }
-
-              // Add the POINTS data that is required and found at the top of the data file.
-              // The POINTS values are set as attributes inside a table.
-              // Loop through the Attribute table to locate the points values within
-              std::vector<std::string> points;
-              for (libdap::AttrTable::Attr_iter i = das.var_begin(); i != das.var_end(); ++i)
-                {
-                  libdap::AttrTable *table = das.get_table(i);
-                  if (table->get_attr("POINTS") != "")
-                    points.push_back(table->get_attr("POINTS"));
-                  if (table->get_attr("points") != "")
-                    points.push_back(table->get_attr("points"));
-                }
-
-              std::stringstream urlString;
-
-              // Append the gathered POINTS in the proper format:
-              // "# POINTS: <val1> <val2> <val3>"
-              urlString << "# POINTS:";
-              for (unsigned int i = 0; i < points.size(); ++i)
-                {
-                  urlString << ' ' << points[i];
-                }
-              urlString << "\n";
-
-              // Add the values from the arrays into the stringstream. The values are passed in
-              // per row with a character return added at the end of each row.
-              // TODO: Add a check to make sure that each column is the same size before writing
-              //     to the stringstream
-              for (unsigned int i = 0; i < tmp.size(); ++i)
-                {
-                  for (unsigned int j = 0; j < columns.size(); ++j)
-                    {
-                      urlString << columns[j][i];
-                      urlString << ' ';
-                    }
-                  urlString << "\n";
-                }
-
-              data_string = urlString.str();
-              filesize = data_string.size();
-
-#else // ASPECT_WITH_LIBDAP
-
-              // Broadcast failure state, then throw. We signal the failure by
-              // setting the file size to an invalid size, then trigger an assert.
-              {
-                std::size_t invalid_filesize = numbers::invalid_size_type;
-                const int ierr = MPI_Bcast(&invalid_filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
-                AssertThrowMPI(ierr);
-              }
-              AssertThrow(false,
-                          ExcMessage(std::string("Reading of file ") + filename + " failed. " +
-                                     "Make sure you have the dependencies for reading a url " +
-                                     "(run cmake with -DASPECT_WITH_LIBDAP=ON)"));
-
-#endif // ASPECT_WITH_LIBDAP
-            }
-          else
-            {
-              std::ifstream filestream;
-              const bool filename_ends_in_gz = std::regex_search(filename, std::regex("\\.gz$"));
-              if (filename_ends_in_gz == true)
-                filestream.open(filename, std::ios_base::in | std::ios_base::binary);
-              else
-                filestream.open(filename);
-
-              if (!filestream)
-                {
-                  // broadcast failure state, then throw
-                  std::size_t invalid_filesize = numbers::invalid_size_type;
-                  const int ierr = MPI_Bcast(&invalid_filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
-                  AssertThrowMPI(ierr);
-                  AssertThrow (false,
-                               ExcMessage (std::string("Could not open file <") + filename + ">."));
-                }
-
-              // Read data from disk
-              std::stringstream datastream;
-
-              try
-                {
-                  boost::iostreams::filtering_istreambuf in;
-                  if (filename_ends_in_gz == true)
-                    in.push(boost::iostreams::gzip_decompressor());
-
-                  in.push(filestream);
-                  boost::iostreams::copy(in, datastream);
-                }
-              catch (const std::ios::failure &)
-                {
-                  // broadcast failure state, then throw
-                  std::size_t invalid_filesize = numbers::invalid_size_type;
-                  const int ierr = MPI_Bcast(&invalid_filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
-                  AssertThrowMPI(ierr);
-                  AssertThrow (false,
-                               ExcMessage (std::string("Could not read file content from <") + filename + ">."));
-                }
-
-              data_string = datastream.str();
-              filesize = data_string.size();
-            }
-
-          // Distribute data_size and data across processes
-          int ierr = MPI_Bcast(&filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
-          AssertThrowMPI(ierr);
-
-          big_mpi::broadcast(&data_string[0], filesize, 0, comm);
-        }
-      else
-        {
-          // Prepare for receiving data
-          std::size_t filesize;
-          int ierr = MPI_Bcast(&filesize, 1, Utilities::internal::MPI::mpi_type_id(&filesize), 0, comm);
-          AssertThrowMPI(ierr);
-          if (filesize == numbers::invalid_size_type)
-            throw QuietException();
-
-          data_string.resize(filesize);
-
-          // Receive and store data
-          big_mpi::broadcast(&data_string[0], filesize, 0, comm);
-        }
-
-      return data_string;
-    }
-
-
-
-    void
-    collect_and_write_file_content(const std::string &filename,
-                                   const std::string &file_content,
-                                   const MPI_Comm comm)
-    {
-      const std::vector<std::string> collected_content = Utilities::MPI::gather(comm, file_content);
-
-      if (Utilities::MPI::this_mpi_process(comm) == 0)
-        {
-          std::ofstream filestream(filename);
-
-          AssertThrow (filestream.good(),
-                       ExcMessage (std::string("Could not open file <") + filename + ">."));
-
-          try
-            {
-              for (const auto &content : collected_content)
-                filestream << content;
-
-              bool success = filestream.good();
-              const int ierr = MPI_Bcast(&success, 1, Utilities::internal::MPI::mpi_type_id(&success), 0, comm);
-              AssertThrowMPI(ierr);
-            }
-          catch (const std::ios::failure &)
-            {
-              // broadcast failure state, then throw
-              bool success = false;
-              const int ierr = MPI_Bcast(&success, 1, Utilities::internal::MPI::mpi_type_id(&success), 0, comm);
-              AssertThrowMPI(ierr);
-              AssertThrow (false,
-                           ExcMessage (std::string("Could not write content to file <") + filename + ">."));
-            }
-
-          filestream.close();
-        }
-      else
-        {
-          // Check that the file was written successfully
-          bool success;
-          int ierr = MPI_Bcast(&success, 1, Utilities::internal::MPI::mpi_type_id(&success), 0, comm);
-          AssertThrowMPI(ierr);
-          if (success == false)
-            throw QuietException();
-        }
-    }
-
-
-
-    int
-    mkdirp(std::string pathname,const mode_t mode)
-    {
-      // force trailing / so we can handle everything in loop
-      if (pathname[pathname.size()-1] != '/')
-        {
-          pathname += '/';
-        }
-
-      size_t pre = 0;
-      size_t pos;
-
-      while ((pos = pathname.find_first_of('/',pre)) != std::string::npos)
-        {
-          const std::string subdir = pathname.substr(0,++pos);
-          pre = pos;
-
-          // if leading '/', first string is 0 length
-          if (subdir.size() == 0)
-            continue;
-
-          int mkdir_return_value;
-          if ((mkdir_return_value = mkdir(subdir.c_str(),mode)) && (errno != EEXIST))
-            return mkdir_return_value;
-
-        }
-
-      return 0;
-    }
-
-
-
-    void create_directory(const std::string &pathname,
-                          const MPI_Comm comm,
-                          bool silent)
-    {
-      // verify that the output directory actually exists. if it doesn't, create
-      // it on processor zero
-      int error;
-
-      if ((Utilities::MPI::this_mpi_process(comm) == 0))
-        {
-          DIR *output_directory = opendir(pathname.c_str());
-          if (output_directory == nullptr)
-            {
-              if (!silent)
-                std::cout << "\n"
-                          << "-----------------------------------------------------------------------------\n"
-                          << "The output directory <" << pathname
-                          << "> provided in the input file appears not to exist.\n"
-                          << "ASPECT will create it for you.\n"
-                          << "-----------------------------------------------------------------------------\n\n"
-                          << std::endl;
-
-              error = Utilities::mkdirp(pathname, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
-
-            }
-          else
-            {
-              error = closedir(output_directory);
-            }
-          // Broadcast error code
-          const int ierr = MPI_Bcast (&error, 1, MPI_INT, 0, comm);
-          AssertThrowMPI(ierr);
-          AssertThrow (error == 0,
-                       ExcMessage (std::string("Can't create the output directory at <") + pathname + ">"));
-        }
-      else
-        {
-          // Wait to receive error code, and throw QuietException if directory
-          // creation has failed
-          const int ierr = MPI_Bcast (&error, 1, MPI_INT, 0, comm);
-          AssertThrowMPI(ierr);
-          if (error!=0)
-            throw aspect::QuietException();
-        }
-    }
-
-
-
-// tk does the cubic spline interpolation that can be used between different spherical layers in the mantle.
-// This interpolation is based on the script spline.h, which was downloaded from
-// http://kluge.in-chemnitz.de/opensource/spline/spline.h   //
-// copyright (C) 2011, 2014 Tino Kluge (ttk448 at gmail.com)
-    namespace tk
-    {
-      /**
-       * Band matrix solver for a banded, square matrix of size @p dim. Used
-       * by spline interpolation in tk::spline.
-       */
-      class band_matrix
-      {
-        public:
-          /**
-           * Constructor, see resize()
-           */
-          band_matrix(int dim, int n_u, int n_l);
-
-
-
-          /**
-           * Resize to a @p dim by @dim matrix with given number
-           * of off-diagonals.
-           */
-          void resize(int dim, int n_u, int n_l);
-
-
-
-          /**
-           * Return the dimension of the matrix
-           */
-          int dim() const;
-
-
-
-          /**
-           * Number of off-diagonals above.
-           */
-          int num_upper() const
-          {
-            return m_upper.size()-1;
-          }
-
-
-
-          /**
-           * Number of off-diagonals below.
-           */
-          int num_lower() const
-          {
-            return m_lower.size()-1;
-          }
-
-
-
-          /**
-           * Writeable access to element A(i,j), indices going from
-           * i=0,...,dim()-1
-           */
-          double &operator () (int i, int j);
-
-
-
-          /**
-           * Read-only access
-           */
-          double operator () (int i, int j) const;
-
-
-
-          /**
-           * second diagonal (used in LU decomposition), saved in m_lower[0]
-           */
-          double &saved_diag(int i);
-
-
-
-          /**
-           * second diagonal (used in LU decomposition), saved in m_lower[0]
-           */
-          double saved_diag(int i) const;
-
-
-
-          /**
-           * LU-Decomposition of a band matrix
-           */
-          void lu_decompose();
-
-
-
-          /**
-           * solves Ux=y
-           */
-          std::vector<double> r_solve(const std::vector<double> &b) const;
-
-
-
-          /**
-           * solves Ly=b
-           */
-          std::vector<double> l_solve(const std::vector<double> &b) const;
-
-
-
-          /**
-           * Solve Ax=b and builds LU decomposition using lu_decompose()
-           * if @p is_lu_decomposed is false.
-           */
-          std::vector<double> lu_solve(const std::vector<double> &b,
-                                       bool is_lu_decomposed=false);
-
-
-
-        private:
-          /**
-           * diagonal and off-diagonals above
-           */
-          std::vector<std::vector<double>> m_upper;
-
-          /**
-           * diagonals below the diagonal
-           */
-          std::vector<std::vector<double>> m_lower;
-      };
-
-
-
-      band_matrix::band_matrix(int dim, int n_u, int n_l)
-      {
-        resize(dim, n_u, n_l);
-      }
-
-
-
-      void band_matrix::resize(int dim, int n_u, int n_l)
-      {
-        assert(dim > 0);
-        assert(n_u >= 0);
-        assert(n_l >= 0);
-        m_upper.resize(n_u+1);
-        m_lower.resize(n_l+1);
-        for (auto &x : m_upper)
-          x.resize(dim);
-        for (auto &x : m_lower)
-          x.resize(dim);
-      }
-
-
-
-      int band_matrix::dim() const
-      {
-        if (m_upper.size()>0)
-          {
-            return m_upper[0].size();
-          }
-        else
-          {
-            return 0;
-          }
-      }
-
-
-
-      double &band_matrix::operator () (int i, int j)
-      {
-        int k = j - i;       // what band is the entry
-        assert( (i >= 0) && (i<dim()) && (j >= 0) && (j < dim()) );
-        assert( (-num_lower() <= k) && (k <= num_upper()) );
-        // k=0 -> diagonal, k<0 lower left part, k>0 upper right part
-        if (k >= 0)
-          return m_upper[k][i];
-        else
-          return m_lower[-k][i];
-      }
-
-
-
-      double band_matrix::operator () (int i, int j) const
-      {
-        int k=j-i;       // what band is the entry
-        assert( (i >= 0) && (i < dim()) && (j >= 0) && (j < dim()) );
-        assert( (-num_lower() <= k) && (k <= num_upper()) );
-        // k=0 -> diagonal, k<0 lower left part, k>0 upper right part
-        if (k >= 0)
-          return m_upper[k][i];
-        else
-          return m_lower[-k][i];
-      }
-
-
-
-      double band_matrix::saved_diag(int i) const
-      {
-        assert( (i >= 0) && (i < dim()) );
-        return m_lower[0][i];
-      }
-
-
-
-      double &band_matrix::saved_diag(int i)
-      {
-        assert( (i >= 0) && (i < dim()) );
-        return m_lower[0][i];
-      }
-
-
-
-      void band_matrix::lu_decompose()
-      {
-        int i_max,j_max;
-        int j_min;
-        double x;
-
-        // preconditioning
-        // normalize column i so that a_ii=1
-        for (int i = 0; i < this->dim(); ++i)
-          {
-            assert(this->operator()(i,i) != 0.0);
-            this->saved_diag(i) = 1.0/this->operator()(i,i);
-            j_min = std::max(0,i-this->num_lower());
-            j_max = std::min(this->dim()-1,i+this->num_upper());
-            for (int j = j_min; j <= j_max; ++j)
-              {
-                this->operator()(i,j) *= this->saved_diag(i);
-              }
-            this->operator()(i,i) = 1.0;          // prevents rounding errors
-          }
-
-        // Gauss LR-Decomposition
-        for (int k = 0; k < this->dim(); ++k)
-          {
-            i_max = std::min(this->dim()-1,k+this->num_lower());  // num_lower not a mistake!
-            for (int i = k+1; i <= i_max; ++i)
-              {
-                assert(this->operator()(k,k) != 0.0);
-                x = -this->operator()(i,k)/this->operator()(k,k);
-                this->operator()(i,k) = -x;                         // assembly part of L
-                j_max = std::min(this->dim()-1, k + this->num_upper());
-                for (int j = k+1; j <= j_max; ++j)
-                  {
-                    // assembly part of R
-                    this->operator()(i,j) = this->operator()(i,j)+x*this->operator()(k,j);
-                  }
-              }
-          }
-      }
-
-
-
-      std::vector<double> band_matrix::l_solve(const std::vector<double> &b) const
-      {
-        assert( this->dim() == static_cast<int>(b.size()) );
-        std::vector<double> x(this->dim());
-        int j_start;
-        double sum;
-        for (int i = 0; i < this->dim(); ++i)
-          {
-            sum = 0;
-            j_start = std::max(0,i-this->num_lower());
-            for (int j = j_start; j < i; ++j) sum += this->operator()(i,j)*x[j];
-            x[i] = (b[i]*this->saved_diag(i)) - sum;
-          }
-        return x;
-      }
-
-
-
-      std::vector<double> band_matrix::r_solve(const std::vector<double> &b) const
-      {
-        assert( this->dim() == static_cast<int>(b.size()) );
-        std::vector<double> x(this->dim());
-        int j_stop;
-        double sum;
-        for (int i = this->dim()-1; i >= 0; i--)
-          {
-            sum = 0;
-            j_stop = std::min(this->dim()-1, i + this->num_upper());
-            for (int j = i+1; j <= j_stop; ++j) sum += this->operator()(i,j)*x[j];
-            x[i] = (b[i] - sum) / this->operator()(i,i);
-          }
-        return x;
-      }
-
-
-
-      std::vector<double> band_matrix::lu_solve(const std::vector<double> &b,
-                                                bool is_lu_decomposed)
-      {
-        assert( this->dim() == static_cast<int>(b.size()) );
-        std::vector<double>  x,y;
-        // TODO: this is completely unsafe because you rely on the user
-        // if the function is called more than once.
-        if (is_lu_decomposed == false)
-          {
-            this->lu_decompose();
-          }
-        y = this->l_solve(b);
-        x = this->r_solve(y);
-        return x;
-      }
-
-
-
-      void spline::set_points(const std::vector<double> &x,
-                              const std::vector<double> &y,
-                              bool cubic_spline,
-                              bool monotone_spline)
-      {
-        assert(x.size() == y.size());
-        m_x = x;
-        m_y = y;
-        const unsigned int n = x.size();
-        for (unsigned int i = 0; i < n-1; ++i)
-          {
-            assert(m_x[i] < m_x[i+1]);
-          }
-
-        if (cubic_spline == true)  // cubic spline interpolation
-          {
-            if (monotone_spline == true)
-              {
-                /**
-                 * This monotone spline algorithm is based on the javascript version
-                 * at https://en.wikipedia.org/wiki/Monotone_cubic_interpolation. The
-                 * parameters from this algorithm prevent overshooting in the
-                 * interpolation spline.
-                 */
-                std::vector<double> dys(n-1), dxs(n-1), ms(n-1);
-                for (unsigned int i=0; i < n-1; ++i)
-                  {
-                    dxs[i] = x[i+1]-x[i];
-                    dys[i] = y[i+1]-y[i];
-                    ms[i] = dys[i]/dxs[i];
-                  }
-
-                // get m_a parameter
-                m_c.resize(n);
-                m_c[0] = 0;
-
-                for (unsigned int i = 0; i < n-2; ++i)
-                  {
-                    const double m0 = ms[i];
-                    const double m1 = ms[i+1];
-
-                    if (m0 * m1 <= 0)
-                      {
-                        m_c[i+1] = 0;
-                      }
-                    else
-                      {
-                        const double dx0 = dxs[i];
-                        const double dx1 = dxs[i+1];
-                        const double common = dx0 + dx1;
-                        m_c[i+1] = 3*common/((common + dx0)/m0 + (common + dx1)/m1);
-                      }
-                  }
-                m_c[n-1] = ms[n-2];
-
-                // Get b and c coefficients
-                m_a.resize(n);
-                m_b.resize(n);
-                for (unsigned int i = 0; i < m_c.size()-1; ++i)
-                  {
-                    const double c1 = m_c[i];
-                    const double m0 = ms[i];
-
-                    const double invDx = 1/dxs[i];
-                    const double common0 = c1 + m_c[i+1] - m0 - m0;
-                    m_b[i] = (m0 - c1 - common0) * invDx;
-                    m_a[i] = common0 * invDx * invDx;
-                  }
-              }
-            else
-              {
-                // setting up the matrix and right hand side of the equation system
-                // for the parameters b[]
-                band_matrix A(n,1,1);
-                std::vector<double>  rhs(n);
-                for (unsigned int i = 1; i<n-1; ++i)
-                  {
-                    A(i,i-1) = 1.0/3.0*(x[i]-x[i-1]);
-                    A(i,i) = 2.0/3.0*(x[i+1]-x[i-1]);
-                    A(i,i+1) = 1.0/3.0*(x[i+1]-x[i]);
-                    rhs[i] = (y[i+1]-y[i])/(x[i+1]-x[i]) - (y[i]-y[i-1])/(x[i]-x[i-1]);
-                  }
-                // boundary conditions, zero curvature b[0]=b[n-1]=0
-                A(0,0) = 2.0;
-                A(0,1) = 0.0;
-                rhs[0] = 0.0;
-                A(n-1,n-1) = 2.0;
-                A(n-1,n-2) = 0.0;
-                rhs[n-1] = 0.0;
-
-                // solve the equation system to obtain the parameters b[]
-                m_b = A.lu_solve(rhs);
-
-                // calculate parameters a[] and c[] based on b[]
-                m_a.resize(n);
-                m_c.resize(n);
-                for (unsigned int i = 0; i<n-1; ++i)
-                  {
-                    m_a[i] = 1.0/3.0*(m_b[i+1]-m_b[i])/(x[i+1]-x[i]);
-                    m_c[i] = (y[i+1]-y[i])/(x[i+1]-x[i])
-                             - 1.0/3.0*(2.0*m_b[i]+m_b[i+1])*(x[i+1]-x[i]);
-                  }
-              }
-          }
-        else     // linear interpolation
-          {
-            m_a.resize(n);
-            m_b.resize(n);
-            m_c.resize(n);
-            for (unsigned int i = 0; i<n-1; ++i)
-              {
-                m_a[i] = 0.0;
-                m_b[i] = 0.0;
-                m_c[i] = (m_y[i+1]-m_y[i])/(m_x[i+1]-m_x[i]);
-              }
-          }
-
-        // for the right boundary we define
-        // f_{n-1}(x) = b*(x-x_{n-1})^2 + c*(x-x_{n-1}) + y_{n-1}
-        double h = x[n-1]-x[n-2];
-        // m_b[n-1] is determined by the boundary condition
-        if (!monotone_spline)
-          {
-            m_a[n-1] = 0.0;
-            m_c[n-1] = 3.0*m_a[n-2]*h*h+2.0*m_b[n-2]*h+m_c[n-2];   // = f'_{n-2}(x_{n-1})
-          }
-      }
-
-
-
-      double spline::operator() (double x) const
-      {
-        size_t n = m_x.size();
-        // find the closest point m_x[idx] < x, idx=0 even if x<m_x[0]
-        std::vector<double>::const_iterator it;
-        it = std::lower_bound(m_x.begin(),m_x.end(),x);
-        const int idx = std::max( static_cast<int>(it-m_x.begin())-1, 0);
-
-        double h = x-m_x[idx];
-        double interpol;
-        if (x<m_x[0])
-          {
-            // extrapolation to the left
-            interpol = ((m_b[0])*h + m_c[0])*h + m_y[0];
-          }
-        else if (x>m_x[n-1])
-          {
-            // extrapolation to the right
-            interpol = ((m_b[n-1])*h + m_c[n-1])*h + m_y[n-1];
-          }
-        else
-          {
-            // interpolation
-            interpol = ((m_a[idx]*h + m_b[idx])*h + m_c[idx])*h + m_y[idx];
-          }
-        return interpol;
-      }
-    } // namespace tk
-
-
-
-    std::string
-    expand_ASPECT_SOURCE_DIR (const std::string &location)
-    {
-      // Check for environment variable override to ASPECT_SOURCE_DIR
-      char const *ASPECT_SOURCE_DIR_env = getenv("ASPECT_SOURCE_DIR");
-      if (ASPECT_SOURCE_DIR_env != nullptr)
-        {
-          return Utilities::replace_in_string(location,
-                                              "$ASPECT_SOURCE_DIR",
-                                              ASPECT_SOURCE_DIR_env);
-        }
-
-      // Otherwise, use the default define from config.h
-      return Utilities::replace_in_string(location,
-                                          "$ASPECT_SOURCE_DIR",
-                                          ASPECT_SOURCE_DIR);
-    }
-
-
-
-    std::string parenthesize_if_nonempty (const std::string &s)
-    {
-      if (s.size() > 0)
-        return " (\"" + s + "\")";
-      else
-        return "";
-    }
-
-
-
-    bool
-    string_to_bool(const std::string &s)
-    {
-      return (s == "true" || s == "yes");
-    }
-
-
-
-    std::vector<bool>
-    string_to_bool(const std::vector<std::string> &s)
-    {
-      std::vector<bool> result;
-      result.reserve(s.size());
-
-      for (auto &i : s)
-        result.push_back(string_to_bool(i));
-
-      return result;
-    }
-
-
-
-    unsigned int
-    string_to_unsigned_int(const std::string &s)
-    {
-      const int value = dealii::Utilities::string_to_int(s);
-      AssertThrow (value >= 0, ExcMessage("Negative number in string_to_unsigned_int() detected."));
-      return static_cast<unsigned int>(value);
-    }
-
-
-
-    std::vector<unsigned int>
-    string_to_unsigned_int(const std::vector<std::string> &s)
-    {
-      std::vector<unsigned int> result;
-      result.reserve(s.size());
-
-      for (auto &str : s)
-        result.emplace_back(string_to_unsigned_int(str));
-
-      return result;
-    }
-
-
-
-    bool
-    has_unique_entries (const std::vector<std::string> &strings)
-    {
-      const std::set<std::string> set_of_strings(strings.begin(),strings.end());
-      return (set_of_strings.size() == strings.size());
-    }
-
-
-
-    double
-    weighted_p_norm_average ( const std::vector<double> &weights,
-                              const std::vector<double> &values,
-                              const double p)
-    {
-      // TODO: prevent division by zero for all
-      double averaged_parameter = 0.0;
-
-      // first look at the special cases which can be done faster
-      if (p <= -1000)
-        {
-          // Minimum
-          double min_value = 0;
-          unsigned int first_element_with_nonzero_weight = 0;
-          for (; first_element_with_nonzero_weight < weights.size(); ++first_element_with_nonzero_weight)
-            if (weights[first_element_with_nonzero_weight] > 0)
-              {
-                min_value = values[first_element_with_nonzero_weight];
-                break;
-              }
-          Assert (first_element_with_nonzero_weight < weights.size(),
-                  ExcMessage ("There are only zero (or smaller) weights in the weights vector."));
-
-          for (unsigned int i=first_element_with_nonzero_weight+1; i < weights.size(); ++i)
-            if (weights[i] != 0)
-              if (values[i] < min_value)
-                min_value = values[i];
-
-          return min_value;
-        }
-      else if (p == -1)
-        {
-          // Harmonic average
-          for (unsigned int i=0; i< weights.size(); ++i)
-            {
-              /**
-               * if the value is zero, we get a division by zero. To prevent this
-               * we look at what should happen in this case. When a value is zero,
-               * and the correspondent weight is non-zero, this corresponds to no
-               * resistance in a parallel system. This means that this will dominate,
-               * and we should return zero. If the value is zero and the weight is
-               * zero, we just ignore it.
-               */
-              if (values[i] == 0 && weights[i] > 0)
-                return 0;
-              else if (values[i] != 0)
-                averaged_parameter += weights[i]/values[i];
-            }
-
-          Assert (averaged_parameter > 0, ExcMessage ("The sum of the weights/values may not be smaller or equal to zero."));
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-          return sum_of_weights/averaged_parameter;
-        }
-      else if (p == 0)
-        {
-          // Geometric average
-          for (unsigned int i=0; i < weights.size(); ++i)
-            averaged_parameter += weights[i]*std::log(values[i]);
-
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-          Assert (sum_of_weights != 0,
-                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
-          return std::exp(averaged_parameter/sum_of_weights);
-        }
-      else if (p == 1)
-        {
-          // Arithmetic average
-          for (unsigned int i=0; i< weights.size(); ++i)
-            averaged_parameter += weights[i]*values[i];
-
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-          Assert (sum_of_weights != 0,
-                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
-          return averaged_parameter/sum_of_weights;
-        }
-      else if (p == 2)
-        {
-          // Quadratic average (RMS)
-          for (unsigned int i=0; i< weights.size(); ++i)
-            averaged_parameter += weights[i]*values[i]*values[i];
-
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-          Assert (sum_of_weights != 0,
-                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
-          Assert (averaged_parameter/sum_of_weights > 0, ExcMessage ("The sum of the weights is smaller or equal to zero."));
-          return std::sqrt(averaged_parameter/sum_of_weights);
-        }
-      else if (p == 3)
-        {
-          // Cubic average
-          for (unsigned int i=0; i< weights.size(); ++i)
-            averaged_parameter += weights[i]*values[i]*values[i]*values[i];
-
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-          Assert (sum_of_weights != 0,
-                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
-          return cbrt(averaged_parameter/sum_of_weights);
-        }
-      else if (p >= 1000)
-        {
-          // Maximum
-          double max_value = 0;
-          unsigned int first_element_with_nonzero_weight = 0;
-          for (; first_element_with_nonzero_weight < weights.size(); ++first_element_with_nonzero_weight)
-            if (weights[first_element_with_nonzero_weight] > 0)
-              {
-                max_value = values[first_element_with_nonzero_weight];
-                break;
-              }
-          Assert (first_element_with_nonzero_weight < weights.size(),
-                  ExcMessage ("There are only zero (or smaller) weights in the weights vector."));
-
-          for (unsigned int i=first_element_with_nonzero_weight+1; i < weights.size(); ++i)
-            if (weights[i] != 0)
-              if (values[i] > max_value)
-                max_value = values[i];
-
-          return max_value;
-        }
-      else
-        {
-          for (unsigned int i=0; i< weights.size(); ++i)
-            {
-              /**
-               * When a value is zero or smaller, the exponent is smaller then one and the
-               * correspondent  weight is non-zero, this corresponds to no resistance in a
-               * parallel system.  This means that this 'path' will be followed, and we
-               * return zero.
-               */
-              if (values[i] <= 0 && p < 0)
-                return 0;
-              averaged_parameter += weights[i] * std::pow(values[i],p);
-            }
-
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-
-          Assert (sum_of_weights > 0, ExcMessage ("The sum of the weights may not be smaller or equal to zero."));
-          Assert (averaged_parameter > 0,
-                  ExcMessage ("The sum of the weights times the values to the power p may not be smaller or equal to zero."));
-          return std::pow(averaged_parameter/sum_of_weights, 1/p);
-        }
-    }
-
-
-
-    template <typename T>
-    T
-    derivative_of_weighted_p_norm_average (const double /*averaged_parameter*/,
-                                           const std::vector<double> &weights,
-                                           const std::vector<double> &values,
-                                           const std::vector<T> &derivatives,
-                                           const double p)
-    {
-      // TODO: use averaged_parameter to speed up computation?
-      // TODO: add special cases p = 2 and p = 3
-      double averaged_parameter_derivative_part_1 = 0.0;
-      T averaged_parameter_derivative_part_2 = T();
-
-      // first look at the special cases which can be done faster
-      if (p <= -1000)
-        {
-          // Minimum
-          double min_value = 0;
-          unsigned int element_with_minimum_value = 0;
-          unsigned int first_element_with_nonzero_weight = 0;
-          for (; first_element_with_nonzero_weight < weights.size(); ++first_element_with_nonzero_weight)
-            if (weights[first_element_with_nonzero_weight] > 0)
-              {
-                min_value = values[first_element_with_nonzero_weight];
-                element_with_minimum_value = first_element_with_nonzero_weight;
-                break;
-              }
-          Assert (first_element_with_nonzero_weight < weights.size(),
-                  ExcMessage ("There are only zero (or smaller) weights in the weights vector."));
-
-          for (unsigned int i=first_element_with_nonzero_weight+1; i < weights.size(); ++i)
-            if (weights[i] != 0)
-              if (values[i] < min_value)
-                {
-                  min_value = values[i];
-                  element_with_minimum_value = i;
-                }
-          return derivatives[element_with_minimum_value];
-        }
-      else if (p == -1)
-        {
-          // Harmonic average
-          for (unsigned int i=0; i< weights.size(); ++i)
-            {
-              /**
-               * if the value is zero, we get a division by zero. To prevent this
-               * we look at what should happen in this case. When a value is zero,
-               * and the correspondent weight is non-zero, this corresponds to no
-               * resistance in a parallel system. This means that this will dominate,
-               * and we should return this derivative. If the value is zero and the
-               * weight is zero, we just ignore it.
-               */
-              if (values[i] == 0 && weights[i] > 0)
-                return derivatives[i];
-              else if (values[i] != 0)
-                {
-                  averaged_parameter_derivative_part_1 += weights[i] / values[i];
-                  averaged_parameter_derivative_part_2 += weights[i] * (1/(values[i] * values[i])) * derivatives[i];
-                }
-            }
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-          Assert (sum_of_weights > 0, ExcMessage ("The sum of the weights may not be smaller or equal to zero."));
-          return std::pow(averaged_parameter_derivative_part_1/sum_of_weights,-2) * averaged_parameter_derivative_part_2/sum_of_weights;
-        }
-      else if (p == 0)
-        {
-          // Geometric average
-          for (unsigned int i=0; i < weights.size(); ++i)
-            {
-              averaged_parameter_derivative_part_1 += weights[i]*std::log(values[i]);
-              averaged_parameter_derivative_part_2 += weights[i]*(1/values[i])*derivatives[i];
-            }
-
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-          Assert (sum_of_weights != 0,
-                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
-          return std::exp(averaged_parameter_derivative_part_1/sum_of_weights) * averaged_parameter_derivative_part_2/sum_of_weights;
-        }
-      else if (p == 1)
-        {
-          // Arithmetic average
-          for (unsigned int i=0; i< weights.size(); ++i)
-            averaged_parameter_derivative_part_2 += weights[i]*derivatives[i];
-
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-          Assert (sum_of_weights != 0,
-                  ExcMessage ("The sum of the weights may not be equal to zero, because we need to divide through it."));
-          return averaged_parameter_derivative_part_2/sum_of_weights;
-        }
-      else if (p >= 1000)
-        {
-          // Maximum
-          double max_value = 0;
-          unsigned int element_with_maximum_value = 0;
-          unsigned int first_element_with_nonzero_weight = 0;
-          for (; first_element_with_nonzero_weight < weights.size(); ++first_element_with_nonzero_weight)
-            if (weights[first_element_with_nonzero_weight] > 0)
-              {
-                max_value = values[first_element_with_nonzero_weight];
-                element_with_maximum_value = first_element_with_nonzero_weight;
-                break;
-              }
-          Assert (first_element_with_nonzero_weight < weights.size(),
-                  ExcMessage ("There are only zero (or smaller) weights in the weights vector."));
-
-          for (unsigned int i=first_element_with_nonzero_weight+1; i < weights.size(); ++i)
-            if (weights[i] != 0)
-              if (values[i] > max_value)
-                {
-                  max_value = values[i];
-                  element_with_maximum_value = i;
-                }
-
-          return derivatives[element_with_maximum_value];
-        }
-      else
-        {
-          // The general case: We can simplify the equation by stating that (1/p) * p = 1
-          // TODO: This can probably be optimized by using:
-          // averaged_parameter_derivative_part_2 += weights[i]*values_p[i]*(1/values[i])*derivatives[i]; and
-          // averaged_parameter_derivative = averaged_parameter * (1/averaged_parameter_derivative_part_1) * averaged_parameter_derivative_part_2;
-          for (unsigned int i=0; i< weights.size(); ++i)
-            {
-              /**
-               * When a value is zero or smaller, the exponent is smaller then one and the
-               * correspondent  weight is non-zero, this corresponds to no resistance in a
-               * parallel system. This means that this 'path' will be followed, and we
-               * return that derivative.
-               */
-              if (values[i] <= 0 && p < 0)
-                return derivatives[i];
-              averaged_parameter_derivative_part_1 += weights[i] * std::pow(values[i],p);
-              averaged_parameter_derivative_part_2 += weights[i] * std::pow(values[i],p-1) * derivatives[i];
-            }
-          const double sum_of_weights = std::accumulate(weights.begin(), weights.end(), 0.0);
-          Assert (sum_of_weights > 0, ExcMessage ("The sum of the weights may not be smaller or equal to zero."));
-          Assert (averaged_parameter_derivative_part_1/sum_of_weights > 0,
-                  ExcMessage ("The sum of the weights times the values to the power p may not be smaller or equal to zero."));
-          return std::pow(averaged_parameter_derivative_part_1/sum_of_weights,(1/p)-1) * averaged_parameter_derivative_part_2/sum_of_weights;
-          // TODO: find a way to check if value is finite for any type? Or just leave this kind of checking up to the user?
-        }
-    }
-
-
-
-    template <int dim>
-    double compute_spd_factor(const double eta,
-                              const SymmetricTensor<2,dim> &strain_rate,
-                              const SymmetricTensor<2,dim> &dviscosities_dstrain_rate,
-                              const double SPD_safety_factor)
-    {
-      // if the strain rate is zero, or the derivative is zero, then
-      // the exact choice of alpha factor does not matter because the
-      // factor that it multiplies is zero -- so return the best value
-      // (i.e., one)
-      if ((strain_rate.norm() == 0) || (dviscosities_dstrain_rate.norm() == 0))
-        return 1;
-
-
-      // The factor in the Newton matrix is going to be of the form
-      //   2*eta I + (a \otimes b + b \otimes a)
-      // where a=strain_rate and b=dviscosities_dstrain_rate.
-      //
-      // If a,b are parallel, this simplifies to
-      //   [2*eta + 2 a:b] I =  2 [eta + a:b] I
-      // and we need to make sure that
-      //   [eta + alpha a:b] > (1-safety_factor)*eta
-      // by choosing alpha appropriately.
-
-      // So, first check: If
-      //   [eta + a:b] > (1-safety_factor)*eta
-      // is already satisfied, then we can choose alpha=1
-      const double a_colon_b = strain_rate * dviscosities_dstrain_rate;
-      if (eta + a_colon_b > eta * (1. - SPD_safety_factor))
-        return 1.0;
-      else
-        {
-          // Otherwise solve the equation above for alpha, which yields
-          //   a:b = -safety_factor*eta / a:b
-          // This can only ever happen if a:b < 0, so we get
-          //   a:b = safety_factor * abs(eta / a:b)
-          Assert (a_colon_b < 0, ExcInternalError());
-          return SPD_safety_factor * std::abs(eta / a_colon_b);
-        }
-    }
-
-
-
-    template <int dim>
-    Point<dim> convert_array_to_point(const std::array<double,dim> &array)
-    {
-      Point<dim> point;
-      for (unsigned int i = 0; i < dim; ++i)
-        point[i] = array[i];
-
-      return point;
-    }
-
-
-
-    template <int dim>
-    std::array<double,dim> convert_point_to_array(const Point<dim> &point)
-    {
-      std::array<double,dim> array;
-      for (unsigned int i = 0; i < dim; ++i)
-        array[i] = point[i];
-
-      return array;
-    }
-
-
-
-    Operator::Operator()
-      :
-      op(uninitialized)
-    {}
-
-
-
-    Operator::Operator(const operation _op)
-      :
-      op(_op)
-    {}
-
-
-
-    double
-    Operator::operator() (const double x, const double y) const
-    {
-      switch (op)
-        {
-          case Utilities::Operator::add:
-          {
-            return x + y;
-          }
-          case Utilities::Operator::subtract:
-          {
-            return x - y;
-          }
-          case Utilities::Operator::minimum:
-          {
-            return std::min(x,y);
-          }
-          case Utilities::Operator::maximum:
-          {
-            return std::max(x,y);
-          }
-          case Utilities::Operator::replace_if_valid:
-          {
-            if (std::isnan(y))
-              return x;
-            else
-              return y;
-          }
-          default:
-          {
-            Assert (false, ExcInternalError());
-          }
-        }
-      return numbers::signaling_nan<double>();
-    }
-
-
-
-    bool
-    Operator::operator== (const operation other_op) const
-    {
-      return other_op == op;
-    }
-
-
-
-    std::vector<Operator> create_model_operator_list(const std::vector<std::string> &operator_names)
-    {
-      std::vector<Operator> operator_list(operator_names.size());
-      for (unsigned int i=0; i<operator_names.size(); ++i)
-        {
-          // create operator list
-          if (operator_names[i] == "add")
-            operator_list[i] = Operator(Operator::add);
-          else if (operator_names[i] == "subtract")
-            operator_list[i] = Operator(Operator::subtract);
-          else if (operator_names[i] == "minimum")
-            operator_list[i] = Operator(Operator::minimum);
-          else if (operator_names[i] == "maximum")
-            operator_list[i] = Operator(Operator::maximum);
-          else if (operator_names[i] == "replace if valid")
-            operator_list[i] = Operator(Operator::replace_if_valid);
-          else
-            AssertThrow(false,
-                        ExcMessage ("ASPECT only accepts the following operators: "
-                                    "add, subtract, minimum, maximum, and replace if valid. But your parameter file "
-                                    "contains: " + operator_names[i] + ". Please check your parameter file.") );
-        }
-
-      return operator_list;
-    }
-
-
-
-    const std::string get_model_operator_options()
-    {
-      return "add|subtract|minimum|maximum|replace if valid";
-    }
-
-
-
-    template <int dim>
-    SymmetricTensor<2,dim>
-    nth_basis_for_symmetric_tensors (const unsigned int k)
-    {
-      Assert((k < SymmetricTensor<2,dim>::n_independent_components),
-             ExcMessage("The component is larger then the amount of independent components in the matrix.") );
-
-      const TableIndices<2> indices_ij = SymmetricTensor<2,dim>::unrolled_to_component_indices (k);
-
-      Tensor<2,dim> result;
-      result[indices_ij] = 1;
-
-      return symmetrize(result);
-    }
-
-
-
-    template <int dim>
-    NaturalCoordinate<dim>::NaturalCoordinate(Point<dim> &position,
-                                              const GeometryModel::Interface<dim> &geometry_model)
-    {
-      coordinate_system = geometry_model.natural_coordinate_system();
-      coordinates = geometry_model.cartesian_to_natural_coordinates(position);
-    }
-
-
-
-    template <int dim>
-    NaturalCoordinate<dim>::NaturalCoordinate(const std::array<double, dim> &coord,
-                                              const Utilities::Coordinates::CoordinateSystem &coord_system) :
-      coordinate_system (coord_system), coordinates (coord)
-    {}
-
-
-
-    template <int dim>
-    std::array<double,dim> &NaturalCoordinate<dim>::get_coordinates()
-    {
-      return coordinates;
-    }
-
-
-
-    template <int dim>
-    const std::array<double,dim> &NaturalCoordinate<dim>::get_coordinates() const
-    {
-      return coordinates;
-    }
-
-
-
-    template <>
-    std::array<double,1> NaturalCoordinate<2>::get_surface_coordinates() const
-    {
-      std::array<double,1> coordinate;
-
-      switch (coordinate_system)
-        {
-          case Coordinates::CoordinateSystem::cartesian:
-            coordinate[0] = coordinates[0];
-            break;
-
-          case Coordinates::CoordinateSystem::spherical:
-            coordinate[0] = coordinates[1];
-            break;
-
-          case Coordinates::CoordinateSystem::ellipsoidal:
-            coordinate[0] = coordinates[1];
-            break;
-
-          default:
-            coordinate[0] = 0;
-            Assert (false, ExcNotImplemented());
-            break;
-        }
-
-      return coordinate;
-    }
-
-
-
-    template <>
-    std::array<double,2> NaturalCoordinate<3>::get_surface_coordinates() const
-    {
-      std::array<double,2> coordinate;
-
-      switch (coordinate_system)
-        {
-          case Coordinates::CoordinateSystem::cartesian:
-            coordinate[0] = coordinates[0];
-            coordinate[1] = coordinates[1];
-            break;
-
-          case Coordinates::CoordinateSystem::spherical:
-            coordinate[0] = coordinates[1];
-            coordinate[1] = coordinates[2];
-            break;
-
-          case Coordinates::CoordinateSystem::ellipsoidal:
-            coordinate[0] = coordinates[1];
-            coordinate[1] = coordinates[2];
-            break;
-
-          default:
-            Assert (false, ExcNotImplemented());
-        }
-
-      return coordinate;
-    }
-
-
-
-    template <int dim>
-    double NaturalCoordinate<dim>::get_depth_coordinate() const
-    {
-      switch (coordinate_system)
-        {
-          case Coordinates::CoordinateSystem::cartesian:
-            return coordinates[dim-1];
-
-          case Coordinates::CoordinateSystem::spherical:
-            return coordinates[0];
-
-          case Coordinates::CoordinateSystem::ellipsoidal:
-            return coordinates[0];
-
-          default:
-            Assert (false, ExcNotImplemented());
-        }
-
-      return 0;
-    }
-
-
-
-    template <int dim, typename VectorType>
-    void
-    project_cellwise(const Mapping<dim>                                        &mapping,
-                     const DoFHandler<dim>                                     &dof_handler,
-                     const unsigned int                                         component_index,
-                     const Quadrature<dim>                                     &quadrature,
-                     const std::function<void(
-                       const typename DoFHandler<dim>::active_cell_iterator &,
-                       const std::vector<Point<dim>> &,
-                       std::vector<double> &)>                                 &function,
-                     VectorType                                                &vec_result)
-    {
-      const FEValuesExtractors::Scalar extractor(component_index);
-
-      UpdateFlags update_flags = UpdateFlags(update_values   |
-                                             update_quadrature_points |
-                                             update_JxW_values);
-
-      FEValues<dim> fe_values (mapping, dof_handler.get_fe(), quadrature, update_flags);
-
-      const unsigned int
-      dofs_per_cell = fe_values.dofs_per_cell,
-      n_q_points    = fe_values.n_quadrature_points;
-
-      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
-      Vector<double> cell_vector (dofs_per_cell);
-      Vector<double> local_projection (dofs_per_cell);
-      FullMatrix<double> local_mass_matrix (dofs_per_cell, dofs_per_cell);
-
-      std::vector<double> rhs_values(n_q_points);
-
-      for (const auto &cell : dof_handler.active_cell_iterators())
-        if (cell->is_locally_owned())
-          {
-            // For each cell, create a local mass matrix and rhs.
-            cell->get_dof_indices (local_dof_indices);
-            fe_values.reinit(cell);
-
-            function(cell, fe_values.get_quadrature_points(), rhs_values);
-
-            cell_vector = 0;
-            local_mass_matrix = 0;
-            for (unsigned int point=0; point<n_q_points; ++point)
-              for (unsigned int i=0; i<dofs_per_cell; ++i)
-                {
-                  if (dof_handler.get_fe().system_to_component_index(i).first == component_index)
-                    cell_vector(i) +=
-                      rhs_values[point] *
-                      fe_values[extractor].value(i,point) *
-                      fe_values.JxW(point);
-
-                  for (unsigned int j=0; j<dofs_per_cell; ++j)
-                    if ((dof_handler.get_fe().system_to_component_index(i).first ==
-                         component_index)
-                        &&
-                        (dof_handler.get_fe().system_to_component_index(j).first ==
-                         component_index))
-                      local_mass_matrix(j,i) += (fe_values[extractor].value(i,point) * fe_values[extractor].value(j,point) *
-                                                 fe_values.JxW(point));
-                    else if (i == j)
-                      local_mass_matrix(i,j) = 1.;
-                }
-
-            // now invert the local mass matrix and multiply it with the rhs
-            local_mass_matrix.gauss_jordan();
-            local_mass_matrix.vmult (local_projection, cell_vector);
-
-            // then set the global solution vector to the values just computed
-            cell->set_dof_values (local_projection, vec_result);
-          }
-    }
-
-
-
-    template <int dim>
-    VectorFunctionFromVelocityFunctionObject<dim>::
-    VectorFunctionFromVelocityFunctionObject
-    (const unsigned int n_components,
-     const std::function<Tensor<1,dim> (const Point<dim> &)> &function_object)
-      :
-      Function<dim>(n_components),
-      function_object (function_object)
-    {
-    }
-
-
-
-    template <int dim>
-    double
-    VectorFunctionFromVelocityFunctionObject<dim>::value (const Point<dim> &p,
-                                                          const unsigned int component) const
-    {
-      Assert (component < this->n_components,
-              ExcIndexRange (component, 0, this->n_components));
-
-      if (component < dim)
-        {
-          const Tensor<1,dim> v = function_object(p);
-          return v[component];
-        }
-      else
-        return 0;
-    }
-
-
-
-    template <int dim>
-    void
-    VectorFunctionFromVelocityFunctionObject<dim>::
-    vector_value (const Point<dim>   &p,
-                  Vector<double>     &values) const
-    {
-      AssertDimension(values.size(), this->n_components);
-
-      // set everything to zero, and then the right components to their correct values
-      values = 0;
-
-      const Tensor<1,dim> v = function_object(p);
-      for (unsigned int d=0; d<dim; ++d)
-        values(d) = v[d];
-    }
-
-
-
-    void throw_linear_solver_failure_exception(const std::string &solver_name,
-                                               const std::string &function_name,
-                                               const std::vector<SolverControl> &solver_controls,
-                                               const std::exception &exc,
-                                               const MPI_Comm mpi_communicator,
-                                               const std::string &output_filename)
-    {
-      if (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
-        {
-          std::ostringstream exception_message;
-          exception_message << std::scientific
-                            << "The " + solver_name
-                            << " in " + function_name
-                            << " did not converge. " << std::endl << std::endl;
-
-          if (solver_controls.front().last_step() != numbers::invalid_unsigned_int)
-            exception_message << "The initial residual was: "
-                              << solver_controls.front().initial_value() << std::endl;
-
-          if (solver_controls.back().last_step() != numbers::invalid_unsigned_int)
-            exception_message << "The final residual is: "
-                              << solver_controls.back().last_value() << std::endl;
-
-          exception_message << "The required residual for convergence is: "
-                            << solver_controls.front().tolerance() << std::endl;
-
-          if (output_filename != "")
-            {
-              // output solver history
-              std::ofstream f((output_filename));
-
-              for (const auto &solver_control: solver_controls)
-                {
-                  // Skip the output if no iterations were run for this solver
-                  if (solver_control.last_step() == numbers::invalid_unsigned_int)
-                    continue;
-
-                  // Add an empty line between solvers
-                  if (&solver_control != &(solver_controls.front()))
-                    f << std::endl;
-
-                  unsigned int j=0;
-                  for (const auto &residual: solver_control.get_history_data())
-                    f << j++ << ' ' << residual << std::endl;
-                }
-
-              f.close();
-
-              exception_message << "See " << output_filename
-                                << " for the full convergence history." << std::endl;
-            }
-
-          exception_message << std::endl
-                            << "The solver reported the following error:"
-                            << std::endl;
-          exception_message << exc.what();
-
-          AssertThrow (false,
-                       ExcMessage (exception_message.str()));
-        }
-      else
-        throw QuietException();
-    }
-
-
-
-    std::vector<Tensor<2,3>>
-    rotation_matrices_random_draw_volume_weighting(const std::vector<double> &volume_fraction,
-                                                   const std::vector<Tensor<2,3>> &rotation_matrices,
-                                                   const unsigned int n_output_matrices,
-                                                   std::mt19937 &random_number_generator)
-    {
-      const unsigned int n_grains = volume_fraction.size();
-
-      // Get volume weighted euler angles, using random draws to convert odf
-      // to a discrete number of orientations, weighted by volume
-      // 1a. Sort the volume fractions and matrices based on the volume fractions size
-      const auto p = compute_sorting_permutation(volume_fraction);
-
-      const std::vector<double> fv_sorted = apply_permutation(volume_fraction, p);
-      const std::vector<Tensor<2,3>> matrices_sorted = apply_permutation(rotation_matrices, p);
-
-      // 2. Get cumulative weight for volume fraction
-      std::vector<double> cum_weight(n_grains);
-      std::partial_sum(fv_sorted.begin(),fv_sorted.end(),cum_weight.begin());
-
-      // 3. Generate random indices
-      std::uniform_real_distribution<> dist(0, cum_weight[n_grains-1]);
-      std::vector<double> idxgrain(n_output_matrices);
-      for (unsigned int grain_i = 0; grain_i < n_output_matrices; ++grain_i)
-        {
-          idxgrain[grain_i] = dist(random_number_generator);
-        }
-
-      // 4. Find the maximum cum_weight that is less than the random value.
-      // the euler angle index is +1. For example, if the idxGrain(g) < cumWeight(1),
-      // the index should be 1 not zero)
-      std::vector<Tensor<2,3>> matrices_out(n_output_matrices);
-      for (unsigned int grain_i = 0; grain_i < n_output_matrices; ++grain_i)
-        {
-          const std::vector<double>::iterator selected_matrix =
-            std::lower_bound(cum_weight.begin(),
-                             cum_weight.end(),
-                             idxgrain[grain_i]);
-
-          const unsigned int matrix_index =
-            std::distance(cum_weight.begin(), selected_matrix);
-
-          matrices_out[grain_i] = matrices_sorted[matrix_index];
-        }
-      return matrices_out;
-    }
-
-
-
-    double
-    wrap_angle(const double angle)
-    {
-      return angle - 360.0*std::floor(angle/360.0);
-    }
-
-
-
-    std::array<double,3>
-    zxz_euler_angles_from_rotation_matrix(const Tensor<2,3> &rotation_matrix)
-    {
-      // ZXZ Euler angles
-      std::array<double,3> euler_angles;
-      for (size_t i = 0; i < 3; ++i)
-        for (size_t j = 0; j < 3; ++j)
-          Assert(abs(rotation_matrix[i][j]) <= 1.0,
-                 ExcMessage("rotation_matrix[" + std::to_string(i) + "][" + std::to_string(j) +
-                            "] is larger than one: " + std::to_string(rotation_matrix[i][j]) + " (" + std::to_string(rotation_matrix[i][j]-1.0) + "). rotation_matrix = \n"
-                            + std::to_string(rotation_matrix[0][0]) + " " + std::to_string(rotation_matrix[0][1]) + " " + std::to_string(rotation_matrix[0][2]) + "\n"
-                            + std::to_string(rotation_matrix[1][0]) + " " + std::to_string(rotation_matrix[1][1]) + " " + std::to_string(rotation_matrix[1][2]) + "\n"
-                            + std::to_string(rotation_matrix[2][0]) + " " + std::to_string(rotation_matrix[2][1]) + " " + std::to_string(rotation_matrix[2][2])));
-
-
-      AssertThrow(rotation_matrix[2][2] <= 1.0, ExcMessage("rot_matrix[2][2] > 1.0"));
-
-      const double theta = std::acos(rotation_matrix[2][2]);
-      double phi1 = 0.0;
-      double phi2 = 0.0;
-
-      if (theta != 0.0 && theta != dealii::numbers::PI)
-        {
-          //
-          phi1  = std::atan2(rotation_matrix[2][0]/-std::sin(theta),rotation_matrix[2][1]/-std::sin(theta));
-          phi2  = std::atan2(rotation_matrix[0][2]/-std::sin(theta),rotation_matrix[1][2]/std::sin(theta));
-        }
-
-      // note that in the case theta is 0 or phi a dimension is lost
-      // see: https://en.wikipedia.org/wiki/Gimbal_lock. We set phi1
-      // to 0 and compute the corresponding phi2. The resulting direction
-      // (cosine matrix) should be the same.
-      else if (theta == 0.0)
-        {
-          phi2 = - phi1 - std::atan2(rotation_matrix[0][1],rotation_matrix[0][0]);
-        }
-      else
-        {
-          phi2 = phi1 + std::atan2(rotation_matrix[0][1],rotation_matrix[0][0]);
-        }
-
-
-      AssertThrow(!std::isnan(phi1), ExcMessage("phi1 is not a number. theta = " + std::to_string(theta) + ", rotation_matrix[2][2]= " + std::to_string(rotation_matrix[2][2])
-                                                + ", acos(rotation_matrix[2][2]) = " + std::to_string(std::acos(rotation_matrix[2][2])) + ", acos(1.0) = " + std::to_string(std::acos(1.0))));
-      AssertThrow(!std::isnan(theta), ExcMessage("theta is not a number."));
-      AssertThrow(!std::isnan(phi2), ExcMessage("phi2 is not a number."));
-
-      euler_angles[0] = wrap_angle(phi1 * constants::radians_to_degree);
-      euler_angles[1] = wrap_angle(theta * constants::radians_to_degree);
-      euler_angles[2] = wrap_angle(phi2 * constants::radians_to_degree);
-
-
-      AssertThrow(!std::isnan(euler_angles[0]), ExcMessage(" euler_angles[0] is not a number."));
-      AssertThrow(!std::isnan(euler_angles[1]), ExcMessage(" euler_angles[1] is not a number."));
-      AssertThrow(!std::isnan(euler_angles[2]), ExcMessage(" euler_angles[2] is not a number."));
-
-      return euler_angles;
-    }
-
-
-
-    Tensor<2,3>
-    zxz_euler_angles_to_rotation_matrix(const double phi1_degrees, const double theta_degrees, const double phi2_degrees)
-    {
-      // ZXZ Euler angles
-      const double phi1 = phi1_degrees * constants::degree_to_radians;
-      const double theta = theta_degrees * constants::degree_to_radians;
-      const double phi2 = phi2_degrees * constants::degree_to_radians;
-      Tensor<2,3> rot_matrix;
-
-      rot_matrix[0][0] = std::cos(phi2)*std::cos(phi1) - std::cos(theta)*std::sin(phi1)*std::sin(phi2);
-      rot_matrix[0][1] = -std::cos(phi2)*std::sin(phi1) - std::cos(theta)*std::cos(phi1)*std::sin(phi2);
-      rot_matrix[0][2] = -std::sin(phi2)*std::sin(theta);
-
-      rot_matrix[1][0] = std::sin(phi2)*std::cos(phi1) + std::cos(theta)*std::sin(phi1)*std::cos(phi2);
-      rot_matrix[1][1] = -std::sin(phi2)*std::sin(phi1) + std::cos(theta)*std::cos(phi1)*std::cos(phi2);
-      rot_matrix[1][2] = std::cos(phi2)*std::sin(theta);
-
-      rot_matrix[2][0] = -std::sin(theta)*std::sin(phi1);
-      rot_matrix[2][1] = -std::sin(theta)*std::cos(phi1);
-      rot_matrix[2][2] = std::cos(theta);
-      AssertThrow(rot_matrix[2][2] <= 1.0, ExcMessage("rot_matrix[2][2] > 1.0"));
-
-      return rot_matrix;
-    }
-
-
-
-    namespace Tensors
-    {
-      SymmetricTensor<4,3>
-      rotate_full_stiffness_tensor(const Tensor<2,3> &rotation_tensor, const SymmetricTensor<4,3> &input_tensor)
-      {
-        SymmetricTensor<4,3> output;
-
-        // Dealii symmetric tensor is C_{ijkl} == C_{jikl} == C_{ijlk}, but not C_{klij}.
-        // So we make sure that those entries are not added twice in this loop by having
-        // the second and 4th loop starting with the first and third index respectively.
-        for (unsigned short int i1 = 0; i1 < 3; ++i1)
-          {
-            for (unsigned short int i2 = i1; i2 < 3; ++i2)
-              {
-                for (unsigned short int i3 = 0; i3 < 3; ++i3)
-                  {
-                    for (unsigned short int i4 = i3; i4 < 3; ++i4)
-                      {
-                        for (unsigned short int j1 = 0; j1 < 3; ++j1)
-                          {
-                            for (unsigned short int j2 = 0; j2 < 3; ++j2)
-                              {
-                                for (unsigned short int j3 = 0; j3 < 3; ++j3)
-                                  {
-                                    for (unsigned short int j4 = 0; j4 < 3; ++j4)
-                                      {
-                                        output[i1][i2][i3][i4] += rotation_tensor[i1][j1]*rotation_tensor[i2][j2]*rotation_tensor[i3][j3]*rotation_tensor[i4][j4]*input_tensor[j1][j2][j3][j4];
-                                      }
-                                  }
-                              }
-                          }
-                      }
-                  }
-              }
-          }
-
-        return output;
-      }
-
-
-
-      SymmetricTensor<2,6>
-      rotate_voigt_stiffness_matrix(const Tensor<2,3> &rotation_tensor, const SymmetricTensor<2,6> &input_tensor)
-      {
-        // we can represent the rotation of the 4th order tensor as a rotation in the Voigt
-        // notation by computing $C'=MCM^{-1}$. Because M is orthogonal we can replace $M^{-1}$
-        // with $M^T$ resulting in $C'=MCM^{T}$ (Carcione, J. M. (2007). Wave Fields in Real Media:
-        // Wave Propagation in Anisotropic, Anelastic, Porous and Electromagnetic Media. Netherlands:
-        // Elsevier Science. Pages 8-9).
-        Tensor<2,6> rotation_matrix;
-        // top left block
-        rotation_matrix[0][0] = rotation_tensor[0][0] * rotation_tensor[0][0];
-        rotation_matrix[1][0] = rotation_tensor[1][0] * rotation_tensor[1][0];
-        rotation_matrix[2][0] = rotation_tensor[2][0] * rotation_tensor[2][0];
-        rotation_matrix[0][1] = rotation_tensor[0][1] * rotation_tensor[0][1];
-        rotation_matrix[1][1] = rotation_tensor[1][1] * rotation_tensor[1][1];
-        rotation_matrix[2][1] = rotation_tensor[2][1] * rotation_tensor[2][1];
-        rotation_matrix[0][2] = rotation_tensor[0][2] * rotation_tensor[0][2];
-        rotation_matrix[1][2] = rotation_tensor[1][2] * rotation_tensor[1][2];
-        rotation_matrix[2][2] = rotation_tensor[2][2] * rotation_tensor[2][2];
-
-        // top right block
-        rotation_matrix[0][3] = 2.0 * rotation_tensor[0][1] * rotation_tensor[0][2];
-        rotation_matrix[1][3] = 2.0 * rotation_tensor[1][1] * rotation_tensor[1][2];
-        rotation_matrix[2][3] = 2.0 * rotation_tensor[2][1] * rotation_tensor[2][2];
-        rotation_matrix[0][4] = 2.0 * rotation_tensor[0][2] * rotation_tensor[0][0];
-        rotation_matrix[1][4] = 2.0 * rotation_tensor[1][2] * rotation_tensor[1][0];
-        rotation_matrix[2][4] = 2.0 * rotation_tensor[2][2] * rotation_tensor[2][0];
-        rotation_matrix[0][5] = 2.0 * rotation_tensor[0][0] * rotation_tensor[0][1];
-        rotation_matrix[1][5] = 2.0 * rotation_tensor[1][0] * rotation_tensor[1][1];
-        rotation_matrix[2][5] = 2.0 * rotation_tensor[2][0] * rotation_tensor[2][1];
-
-        // bottom left block
-        rotation_matrix[3][0] = rotation_tensor[1][0] * rotation_tensor[2][0];
-        rotation_matrix[4][0] = rotation_tensor[2][0] * rotation_tensor[0][0];
-        rotation_matrix[5][0] = rotation_tensor[0][0] * rotation_tensor[1][0];
-        rotation_matrix[3][1] = rotation_tensor[1][1] * rotation_tensor[2][1];
-        rotation_matrix[4][1] = rotation_tensor[2][1] * rotation_tensor[0][1];
-        rotation_matrix[5][1] = rotation_tensor[0][1] * rotation_tensor[1][1];
-        rotation_matrix[3][2] = rotation_tensor[1][2] * rotation_tensor[2][2];
-        rotation_matrix[4][2] = rotation_tensor[2][2] * rotation_tensor[0][2];
-        rotation_matrix[5][2] = rotation_tensor[0][2] * rotation_tensor[1][2];
-
-        // bottom right block
-        rotation_matrix[3][3] = rotation_tensor[1][1] * rotation_tensor[2][2] + rotation_tensor[1][2] * rotation_tensor[2][1];
-        rotation_matrix[4][3] = rotation_tensor[0][1] * rotation_tensor[2][2] + rotation_tensor[0][2] * rotation_tensor[2][1];
-        rotation_matrix[5][3] = rotation_tensor[0][1] * rotation_tensor[1][2] + rotation_tensor[0][2] * rotation_tensor[1][1];
-        rotation_matrix[3][4] = rotation_tensor[1][0] * rotation_tensor[2][2] + rotation_tensor[1][2] * rotation_tensor[2][0];
-        rotation_matrix[4][4] = rotation_tensor[0][2] * rotation_tensor[2][0] + rotation_tensor[0][0] * rotation_tensor[2][2];
-        rotation_matrix[5][4] = rotation_tensor[0][2] * rotation_tensor[1][0] + rotation_tensor[0][0] * rotation_tensor[1][2];
-        rotation_matrix[3][5] = rotation_tensor[1][1] * rotation_tensor[2][0] + rotation_tensor[1][0] * rotation_tensor[2][1];
-        rotation_matrix[4][5] = rotation_tensor[0][0] * rotation_tensor[2][1] + rotation_tensor[0][1] * rotation_tensor[2][0];
-        rotation_matrix[5][5] = rotation_tensor[0][0] * rotation_tensor[1][1] + rotation_tensor[0][1] * rotation_tensor[1][0];
-
-        const Tensor<2,6> rotation_matrix_transposed = transpose(rotation_matrix);
-
-        return symmetrize((rotation_matrix*input_tensor)*rotation_matrix_transposed);
-      }
-
-
-
-      SymmetricTensor<2,6>
-      to_voigt_stiffness_matrix(const SymmetricTensor<4,3> &input_tensor)
-      {
-        SymmetricTensor<2,6> output;
-
-        for (unsigned short int i = 0; i < 3; i++)
-          {
-            output[i][i] = input_tensor[i][i][i][i];
-          }
-
-        for (unsigned short int i = 1; i < 3; i++)
-          {
-            output[0][i] = 0.5*(input_tensor[0][0][i][i] + input_tensor[i][i][0][0]);
-            //symmetry: output[0][i] = output[i][0];
-          }
-        output[1][2]=0.5*(input_tensor[1][1][2][2]+input_tensor[2][2][1][1]);
-        //symmetry: output[2][1]=output[1][2];
-
-        for (unsigned short int i = 0; i < 3; i++)
-          {
-            output[i][3]=0.25*(input_tensor[i][i][1][2]+input_tensor[i][i][2][1]+ input_tensor[1][2][i][i]+input_tensor[2][1][i][i]);
-            //symmetry: output[3][i]=output[i][3];
-          }
-
-        for (unsigned short int i = 0; i < 3; i++)
-          {
-            output[i][4]=0.25*(input_tensor[i][i][0][2]+input_tensor[i][i][2][0]+ input_tensor[0][2][i][i]+input_tensor[2][0][i][i]);
-            //symmetry: output[4][i]=output[i][4];
-          }
-
-        for (unsigned short int i = 0; i < 3; i++)
-          {
-            output[i][5]=0.25*(input_tensor[i][i][0][1]+input_tensor[i][i][1][0]+input_tensor[0][1][i][i]+input_tensor[1][0][i][i]);
-            //symmetry: output[5][i]=output[i][5];
-          }
-
-        output[3][3]=0.25*(input_tensor[1][2][1][2]+input_tensor[1][2][2][1]+input_tensor[2][1][1][2]+input_tensor[2][1][2][1]);
-        output[4][4]=0.25*(input_tensor[0][2][0][2]+input_tensor[0][2][2][0]+input_tensor[2][0][0][2]+input_tensor[2][0][2][0]);
-        output[5][5]=0.25*(input_tensor[1][0][1][0]+input_tensor[1][0][0][1]+input_tensor[0][1][1][0]+input_tensor[0][1][0][1]);
-
-        output[3][4]=0.125*(input_tensor[1][2][0][2]+input_tensor[1][2][2][0]+input_tensor[2][1][0][2]+input_tensor[2][1][2][0]+input_tensor[0][2][1][2]+input_tensor[0][2][2][1]+input_tensor[2][0][1][2]+input_tensor[2][0][2][1]);
-        //symmetry: output[4][3]=output[3][4];
-        output[3][5]=0.125*(input_tensor[1][2][0][1]+input_tensor[1][2][1][0]+input_tensor[2][1][0][1]+input_tensor[2][1][1][0]+input_tensor[0][1][1][2]+input_tensor[0][1][2][1]+input_tensor[1][0][1][2]+input_tensor[1][0][2][1]);
-        //symmetry: output[5][3]=output[3][5];
-        output[4][5]=0.125*(input_tensor[0][2][0][1]+input_tensor[0][2][1][0]+input_tensor[2][0][0][1]+input_tensor[2][0][1][0]+input_tensor[0][1][0][2]+input_tensor[0][1][2][0]+input_tensor[1][0][0][2]+input_tensor[1][0][2][0]);
-        //symmetry: output[5][4]=output[4][5];
-
-        return output;
-      }
-
-
-
-      SymmetricTensor<4,3>
-      to_full_stiffness_tensor(const SymmetricTensor<2,6> &input_tensor)
-      {
-        SymmetricTensor<4,3> output;
-
-        for (unsigned short int i = 0; i < 3; i++)
-          for (unsigned short int j = 0; j < 3; j++)
-            for (unsigned short int k = 0; k < 3; k++)
-              for (unsigned short int l = 0; l < 3; l++)
-                {
-                  // The first part of the inline if statement gets the diagonal.
-                  // The second part is never higher than 5 (which is the limit of the tensor index)
-                  // because to reach this part the variables need to be different, which results in
-                  // at least a minus 1.
-                  const unsigned short int p = (i == j ? i : 6 - i - j);
-                  const unsigned short int q = (k == l ? k : 6 - k - l);
-                  output[i][j][k][l] = input_tensor[p][q];
-                }
-        return output;
-      }
-
-
-
-      Tensor<1,21>
-      to_voigt_stiffness_vector(const SymmetricTensor<2,6> &input)
-      {
-        return Tensor<1,21,double> (
-        {
-          input[0][0],           // 0  // 1
-          input[1][1],           // 1  // 2
-          input[2][2],           // 2  // 3
-          numbers::SQRT2 *input[1][2],  // 3  // 4
-          numbers::SQRT2 *input[0][2],  // 4  // 5
-          numbers::SQRT2 *input[0][1],  // 5  // 6
-          2*input[3][3],         // 6  // 7
-          2*input[4][4],         // 7  // 8
-          2*input[5][5],         // 8  // 9
-          2*input[0][3],         // 9  // 10
-          2*input[1][4],         // 10 // 11
-          2*input[2][5],         // 11 // 12
-          2*input[2][3],         // 12 // 13
-          2*input[0][4],         // 13 // 14
-          2*input[1][5],         // 14 // 15
-          2*input[1][3],         // 15 // 16
-          2*input[2][4],         // 16 // 17
-          2*input[0][5],         // 17 // 18
-          2*numbers::SQRT2 *input[4][5], // 18 // 19
-          2*numbers::SQRT2 *input[3][5], // 19 // 20
-          2*numbers::SQRT2 *input[3][4] // 20 // 21
-        });
-
-      }
-
-
-
-      SymmetricTensor<2,6>
-      to_voigt_stiffness_matrix(const Tensor<1,21> &input)
-      {
-        SymmetricTensor<2,6> result;
-
-        const double sqrt_2_inv = 1/numbers::SQRT2;
-
-        result[0][0] = input[0];
-        result[1][1] = input[1];
-        result[2][2] = input[2];
-        result[1][2] = sqrt_2_inv * input[3];
-        result[0][2] = sqrt_2_inv * input[4];
-        result[0][1] = sqrt_2_inv * input[5];
-        result[3][3] = 0.5 * input[6];
-        result[4][4] = 0.5 * input[7];
-        result[5][5] = 0.5 * input[8];
-        result[0][3] = 0.5 * input[9];
-        result[1][4] = 0.5 * input[10];
-        result[2][5] = 0.5 * input[11];
-        result[2][3] = 0.5 * input[12];
-        result[0][4] = 0.5 * input[13];
-        result[1][5] = 0.5 * input[14];
-        result[1][3] = 0.5 * input[15];
-        result[2][4] = 0.5 * input[16];
-        result[0][5] = 0.5 * input[17];
-        result[4][5] = 0.5 * sqrt_2_inv * input[18];
-        result[3][5] = 0.5 * sqrt_2_inv * input[19];
-        result[3][4] = 0.5 * sqrt_2_inv * input[20];
-
-        return result;
-
-      }
-
-
-
-      Tensor<1,21>
-      to_voigt_stiffness_vector(const SymmetricTensor<4,3> &input_tensor)
-      {
-        return Tensor<1,21,double> (
-        {
-          input_tensor[0][0][0][0],           // 0  // 1
-          input_tensor[1][1][1][1],           // 1  // 2
-          input_tensor[2][2][2][2],           // 2  // 3
-          numbers::SQRT2*0.5*(input_tensor[1][1][2][2] + input_tensor[2][2][1][1]),   // 3  // 4
-          numbers::SQRT2*0.5*(input_tensor[0][0][2][2] + input_tensor[2][2][0][0]),   // 4  // 5
-          numbers::SQRT2*0.5*(input_tensor[0][0][1][1] + input_tensor[1][1][0][0]),   // 5  // 6
-          0.5*(input_tensor[1][2][1][2]+input_tensor[1][2][2][1]+input_tensor[2][1][1][2]+input_tensor[2][1][2][1]),         // 6  // 7
-          0.5*(input_tensor[0][2][0][2]+input_tensor[0][2][2][0]+input_tensor[2][0][0][2]+input_tensor[2][0][2][0]),         // 7  // 8
-          0.5*(input_tensor[1][0][1][0]+input_tensor[1][0][0][1]+input_tensor[0][1][1][0]+input_tensor[0][1][0][1]),         // 8  // 9
-          0.5*(input_tensor[0][0][1][2]+input_tensor[0][0][2][1]+input_tensor[1][2][0][0]+input_tensor[2][1][0][0]),         // 9  // 10
-          0.5*(input_tensor[1][1][0][2]+input_tensor[1][1][2][0]+input_tensor[0][2][1][1]+input_tensor[2][0][1][1]),         // 10 // 11
-          0.5*(input_tensor[2][2][0][1]+input_tensor[2][2][1][0]+input_tensor[0][1][2][2]+input_tensor[1][0][2][2]),         // 11 // 12
-          0.5*(input_tensor[2][2][1][2]+input_tensor[2][2][2][1]+input_tensor[1][2][2][2]+input_tensor[2][1][2][2]),         // 12 // 13
-          0.5*(input_tensor[0][0][0][2]+input_tensor[0][0][2][0]+input_tensor[0][2][0][0]+input_tensor[2][0][0][0]),         // 13 // 14
-          0.5*(input_tensor[1][1][0][1]+input_tensor[1][1][1][0]+input_tensor[0][1][1][1]+input_tensor[1][0][1][1]),         // 14 // 15
-          0.5*(input_tensor[1][1][1][2]+input_tensor[1][1][2][1]+input_tensor[1][2][1][1]+input_tensor[2][1][1][1]),         // 15 // 16
-          0.5*(input_tensor[2][2][0][2]+input_tensor[2][2][2][0]+input_tensor[0][2][2][2]+input_tensor[2][0][2][2]),         // 16 // 17
-          0.5*(input_tensor[0][0][0][1]+input_tensor[0][0][1][0]+input_tensor[0][1][0][0]+input_tensor[1][0][0][0]),         // 17 // 18
-          numbers::SQRT2*0.25*(input_tensor[0][2][0][1]+input_tensor[0][2][1][0]+input_tensor[2][0][0][1]+input_tensor[2][0][1][0]+input_tensor[0][1][0][2]+input_tensor[0][1][2][0]+input_tensor[1][0][0][2]+input_tensor[1][0][2][0]), // 18 // 19
-          numbers::SQRT2*0.25*(input_tensor[1][2][0][1]+input_tensor[1][2][1][0]+input_tensor[2][1][0][1]+input_tensor[2][1][1][0]+input_tensor[0][1][1][2]+input_tensor[0][1][2][1]+input_tensor[1][0][1][2]+input_tensor[1][0][2][1]), // 19 // 20
-          numbers::SQRT2*0.25*(input_tensor[1][2][0][2]+input_tensor[1][2][2][0]+input_tensor[2][1][0][2]+input_tensor[2][1][2][0]+input_tensor[0][2][1][2]+input_tensor[0][2][2][1]+input_tensor[2][0][1][2]+input_tensor[2][0][2][1])  // 20 // 21
-        });
-
-      }
-
-
-      template <>
-      const Tensor<3,3> &levi_civita<3>()
-      {
-        static const Tensor<3,3> t =
-          []()
-        {
-          Tensor<3,3> permutation_operator_3d;
-
-          permutation_operator_3d[0][1][2]  = 1;
-          permutation_operator_3d[1][2][0]  = 1;
-          permutation_operator_3d[2][0][1]  = 1;
-          permutation_operator_3d[0][2][1]  = -1;
-          permutation_operator_3d[1][0][2]  = -1;
-          permutation_operator_3d[2][1][0]  = -1;
-          return permutation_operator_3d;
-        }();
-
-        return t;
-      }
-    }
-
-
-// Explicit instantiations
-
-#define INSTANTIATE(dim) \
-  template \
-  IndexSet extract_locally_active_dofs_with_component(const DoFHandler<dim> &, \
-                                                      const ComponentMask &); \
-  \
-  template \
-  std::vector<Point<dim>> \
-  get_unit_support_points(const SimulatorAccess<dim> &simulator_access); \
-  \
-  template \
-  std::vector<std::string> \
-  expand_dimensional_variable_names<dim> (const std::vector<std::string> &var_declarations); \
-  \
-  template \
-  class VectorFunctionFromVelocityFunctionObject<dim>; \
-  \
-  template \
-  Point<dim> Coordinates::spherical_to_cartesian_coordinates<dim>(const std::array<double,dim> &scoord); \
-  \
-  template \
-  std::array<double,dim> Coordinates::cartesian_to_spherical_coordinates<dim>(const Point<dim> &position); \
-  \
-  template \
-  Tensor<1,dim> Coordinates::spherical_to_cartesian_vector<dim>(const Tensor<1,dim> &spherical_vector, \
-                                                                const Point<dim> &position); \
-  \
-  template \
-  bool polygon_contains_point<dim>(const std::vector<Point<2>> &pointList, \
-                                   const dealii::Point<2> &point); \
-  \
-  template \
-  bool point_is_in_triangulation<dim>(const Mapping<dim> &mapping, \
-                                      const parallel::distributed::Triangulation<dim> &triangulation, \
-                                      const Point<dim> &point, \
-                                      const MPI_Comm mpi_communicator); \
-  \
-  template \
-  double signed_distance_to_polygon<dim>(const std::vector<Point<2>> &pointList, \
-                                         const dealii::Point<2> &point); \
-  \
-  template \
-  std::array<Tensor<1,dim>,dim-1> orthogonal_vectors (const Tensor<1,dim> &v); \
-  \
-  template \
-  dealii::SymmetricTensor<2, dim, double> \
-  derivative_of_weighted_p_norm_average (const double averaged_parameter, \
-                                         const std::vector<double> &weights, \
-                                         const std::vector<double> &values, \
-                                         const std::vector<dealii::SymmetricTensor<2, dim, double>> &derivatives, \
-                                         const double p); \
-  \
-  template \
-  double compute_spd_factor(const double eta, \
-                            const SymmetricTensor<2,dim> &strain_rate, \
-                            const SymmetricTensor<2,dim> &dviscosities_dstrain_rate, \
-                            const double safety_factor); \
-  \
-  template \
-  Point<dim> convert_array_to_point<dim>(const std::array<double,dim> &array); \
-  \
-  template \
-  std::array<double,dim> convert_point_to_array<dim>(const Point<dim> &point); \
-  \
-  template \
-  SymmetricTensor<2,dim> nth_basis_for_symmetric_tensors (const unsigned int k); \
-  \
-  template \
-  class NaturalCoordinate<dim>; \
-  \
-  template \
-  void \
-  project_cellwise(const Mapping<dim> &mapping, \
-                   const DoFHandler<dim> &dof_handler, \
-                   const unsigned int component_index, \
-                   const Quadrature<dim> &quadrature, \
-                   const std::function<void( \
-                                             const DoFHandler<dim>::active_cell_iterator &, \
-                                             const std::vector<Point<dim>> &, \
-                                             std::vector<double> &)> &function, \
-                   dealii::LinearAlgebra::distributed::Vector<double> &vec_result); \
-  \
-  template \
-  void \
-  project_cellwise(const Mapping<dim> &mapping, \
-                   const DoFHandler<dim> &dof_handler, \
-                   const unsigned int component_index, \
-                   const Quadrature<dim> &quadrature, \
-                   const std::function<void( \
-                                             const DoFHandler<dim>::active_cell_iterator &, \
-                                             const std::vector<Point<dim>> &, \
-                                             std::vector<double> &)> &function, \
-                   LinearAlgebra::BlockVector &vec_result);
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-
-    // only instantiate for dim=3:
-    template                \
-    std::array<double,3> Coordinates::WGS84_coordinates<3>(const Point<3> &position);
-
-
-    template double
-    derivative_of_weighted_p_norm_average (const double averaged_parameter,
-                                           const std::vector<double> &weights,
-                                           const std::vector<double> &values,
-                                           const std::vector<double> &derivatives,
-                                           const double p);
-
-    template Table<2,double> parse_input_table(const std::string &input_string,
-                                               const unsigned int n_rows,
-                                               const unsigned int n_columns,
-                                               const std::string &property_name);
-  }
-}
diff --git a/source/volume_of_fluid/assembler.cc.bak b/source/volume_of_fluid/assembler.cc.bak
deleted file mode 100644
index 1d92fb49bfc..00000000000
--- a/source/volume_of_fluid/assembler.cc.bak
+++ /dev/null
@@ -1,650 +0,0 @@
-/*
- Copyright (C) 2016 - 2022 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file doc/COPYING.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/volume_of_fluid/utilities.h>
-#include <aspect/volume_of_fluid/handler.h>
-#include <aspect/volume_of_fluid/field.h>
-#include <aspect/volume_of_fluid/assembly.h>
-
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-    template <int dim>
-    void VolumeOfFluidAssembler<dim>::local_assemble_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
-                                                                             const unsigned int calc_dir,
-                                                                             const bool update_from_old,
-                                                                             const typename DoFHandler<dim>::active_cell_iterator &cell,
-                                                                             internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
-                                                                             internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const
-    {
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-
-      // also have the number of dofs that correspond just to the element for
-      // the system we are currently trying to assemble
-      const unsigned int volume_of_fluid_dofs_per_cell = data.local_dof_indices.size();
-
-      Assert (volume_of_fluid_dofs_per_cell < scratch.finite_element_values.get_fe().dofs_per_cell, ExcInternalError());
-      Assert (volume_of_fluid_dofs_per_cell < scratch.face_finite_element_values.get_fe().dofs_per_cell, ExcInternalError());
-      Assert (scratch.phi_field.size() == volume_of_fluid_dofs_per_cell, ExcInternalError());
-
-      const FiniteElement<dim> &main_fe = scratch.finite_element_values.get_fe();
-
-      const unsigned int volume_of_fluidN_component = field.reconstruction.first_component_index;
-      const FEValuesExtractors::Vector volume_of_fluidN_n = FEValuesExtractors::Vector(volume_of_fluidN_component);
-      const FEValuesExtractors::Scalar volume_of_fluidN_d = FEValuesExtractors::Scalar(volume_of_fluidN_component+dim);
-
-      const unsigned int solution_component = field.volume_fraction.first_component_index;
-      const FEValuesExtractors::Scalar solution_field = field.volume_fraction.extractor_scalar();
-
-      const LinearAlgebra::BlockVector &vof_solution_vector = (update_from_old)
-                                                              ?
-                                                              this->get_old_solution()
-                                                              :
-                                                              this->get_solution();
-
-      scratch.finite_element_values.reinit (cell);
-
-      cell->get_dof_indices (scratch.local_dof_indices);
-      for (unsigned int i=0; i<volume_of_fluid_dofs_per_cell; ++i)
-        data.local_dof_indices[i] = scratch.local_dof_indices[main_fe.component_to_system_index(solution_component, i)];
-
-      data.local_matrix = 0;
-      data.local_rhs = 0;
-
-      // For interior face contributions loop over all possible
-      // subfaces of the cell, and reset their matrices.
-      for (auto &m : data.local_face_rhs)
-        m = 0;
-      for (auto &m : data.local_face_matrices_ext_ext)
-        m = 0;
-
-      // Mark the arrays initialized to zero above as currently all unused
-      std::fill (data.face_contributions_mask.begin(), data.face_contributions_mask.end(),
-                 false);
-
-      scratch.finite_element_values[solution_field].get_function_values (vof_solution_vector,
-                                                                         scratch.old_field_values);
-
-      scratch.finite_element_values[volume_of_fluidN_n].get_function_values (vof_solution_vector,
-                                                                             scratch.cell_i_n_values);
-
-      scratch.finite_element_values[volume_of_fluidN_d].get_function_values (vof_solution_vector,
-                                                                             scratch.cell_i_d_values);
-
-      scratch.volume = 0.0;
-
-      for (unsigned int q = 0; q< n_q_points; ++q)
-        {
-          // Init FE field vals
-          for (unsigned int k=0; k<volume_of_fluid_dofs_per_cell; ++k)
-            scratch.phi_field[k] = scratch.finite_element_values[solution_field].value(main_fe.component_to_system_index(solution_component, k), q);
-
-          for (unsigned int i = 0; i<volume_of_fluid_dofs_per_cell; ++i)
-            {
-              data.local_rhs[i] += scratch.old_field_values[q] *
-                                   scratch.finite_element_values.JxW(q);
-              for (unsigned int j=0; j<volume_of_fluid_dofs_per_cell; ++j)
-                data.local_matrix (i, j) += scratch.phi_field[i] *
-                                            scratch.phi_field[j] *
-                                            scratch.finite_element_values.JxW(q);
-            }
-          scratch.volume += scratch.finite_element_values.JxW(q);
-        }
-
-      for (const unsigned int face_no : cell->face_indices())
-        {
-          // Obtain the normal direction for the face in question
-          // Deal.II orders faces as dim*2+(face_direction_is_positive?1:0)
-          const unsigned int face_normal_direction = face_no/2;
-
-          if (face_normal_direction != calc_dir)
-            continue;
-
-          const typename DoFHandler<dim>::face_iterator face = cell->face (face_no);
-
-          if (!face->at_boundary())
-            this->local_assemble_internal_face_volume_of_fluid_system (field, update_from_old, cell, face_no, scratch, data);
-          else
-            this->local_assemble_boundary_face_volume_of_fluid_system (field, update_from_old, cell, face_no, scratch, data);
-        }
-    }
-
-
-
-    template <int dim>
-    void VolumeOfFluidAssembler<dim>::local_assemble_boundary_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
-        const bool update_from_old,
-        const typename DoFHandler<dim>::active_cell_iterator &cell,
-        const unsigned int face_no,
-        internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
-        internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const
-    {
-      const double volume_fraction_threshold = this->get_volume_of_fluid_handler().get_volume_fraction_threshold();
-
-      const bool old_velocity_available = (this->get_timestep_number() > 0);
-
-      const typename DoFHandler<dim>::face_iterator face = cell->face(face_no);
-
-      const unsigned int f_dim = face_no/2; // Obtain dimension
-      const bool face_normal_is_positive = (face_no%2==1);
-
-      const unsigned int n_f_q_points    = scratch.face_finite_element_values.n_quadrature_points;
-
-      // Currently assuming cartesian mapping, so cell->measure()
-      // works, and the neighbor volume cannot be computed easily using
-      // a sum in this call.
-      const double cell_volume = scratch.volume;
-
-      // volume fraction and interface values are constants, so can set from first value
-      const double cell_volume_of_fluid = scratch.old_field_values[0];
-      const Tensor<1, dim> cell_i_normal = scratch.cell_i_n_values[0];
-      const double cell_i_d = scratch.cell_i_d_values[0];
-
-      scratch.face_finite_element_values.reinit (cell, face_no);
-
-      scratch.face_finite_element_values[this->introspection().extractors.velocities]
-      .get_function_values (this->get_current_linearization_point(),
-                            scratch.face_current_velocity_values);
-
-      scratch.face_finite_element_values[this->introspection().extractors.velocities]
-      .get_function_values (this->get_old_solution(),
-                            scratch.face_old_velocity_values);
-
-      if (cell->has_periodic_neighbor (face_no))
-        {
-          // Periodic temperature/composition term: consider the corresponding periodic faces as the case of interior faces
-          this->local_assemble_internal_face_volume_of_fluid_system(field, update_from_old, cell, face_no, scratch, data);
-        }
-      else
-        {
-          // Boundary is not periodic
-
-          double face_flux = 0;
-
-          // Variables for holding values that indicate the "level set" (not
-          // signed distance) on the cell face aperture for calculating the
-          // volume fluxed through this cell face.
-          double face_level_set_d = 0;
-          double face_level_set_time_grad = 0;
-          double boundary_fluid_flux = 0;
-
-          // Using VolumeOfFluid so need to accumulate flux through face
-          if ( this->get_fixed_composition_boundary_indicators().find(
-                 face->boundary_id()
-               )
-               != this->get_fixed_composition_boundary_indicators().end())
-            {
-              // We are in the case of a Dirichlet BC, so calculate the fluid flux if the boundary is upwind.
-              for (unsigned int q=0; q<n_f_q_points; ++q)
-                {
-
-                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
-
-                  //If old velocity available average to half timestep
-                  if (old_velocity_available)
-                    current_u += 0.5*(scratch.face_old_velocity_values[q] -
-                                      scratch.face_current_velocity_values[q]);
-
-
-                  face_flux += this->get_timestep() *
-                               current_u *
-                               scratch.face_finite_element_values.normal_vector(q) *
-                               scratch.face_finite_element_values.JxW(q);
-
-                  boundary_fluid_flux += this->get_boundary_composition_manager().boundary_composition(
-                                           face->boundary_id(),
-                                           scratch.face_finite_element_values.quadrature_point(q),
-                                           field.composition_index) *
-                                         this->get_timestep() *
-                                         current_u *
-                                         scratch.face_finite_element_values.normal_vector(q) *
-                                         scratch.face_finite_element_values.JxW(q);
-
-                }
-            }
-          else
-            {
-              // We are in the case of a Neumann boundary, so only accumulate
-              // the volume flux through the boundary for the correction term
-              for (unsigned int q=0; q<n_f_q_points; ++q)
-                {
-
-                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
-
-                  //If old velocity available average to half timestep
-                  if (old_velocity_available)
-                    current_u += 0.5*(scratch.face_old_velocity_values[q] -
-                                      scratch.face_current_velocity_values[q]);
-
-                  face_flux += this->get_timestep() *
-                               current_u *
-                               scratch.face_finite_element_values.normal_vector(q) *
-                               scratch.face_finite_element_values.JxW(q);
-
-                }
-            }
-
-          // Need to explicitly calculated the values of the "level set"
-          // function on the unit cell on the cell interface being assembled
-          if (face_normal_is_positive)
-            {
-              face_level_set_d = cell_i_d - 0.5*cell_i_normal[f_dim];
-              face_level_set_time_grad = (face_flux/cell_volume)*cell_i_normal[f_dim];
-            }
-          else
-            {
-              face_level_set_d = cell_i_d + 0.5*cell_i_normal[f_dim];
-              face_level_set_time_grad = -(face_flux/cell_volume)*cell_i_normal[f_dim];
-            }
-
-          // Calculate outward flux
-          double flux_volume_of_fluid;
-          if (std::abs(face_flux) < volume_fraction_threshold*cell_volume)
-            {
-              // Volume flux through face is too small for accurate evaluation,
-              // so set the fluxed volume fraction to the raw volume fraction
-              // of the cell for reasonable assembly
-              flux_volume_of_fluid = cell_volume_of_fluid;
-            }
-          else if (face_flux < 0.0) // edge is upwind (inflow boundary), so use the volume fraction implied by the boundary condition
-            {
-              flux_volume_of_fluid = boundary_fluid_flux/face_flux;
-            }
-          else // Cell is upwind of boundary, so compute the volume fraction on the advected volume
-            {
-              flux_volume_of_fluid = VolumeOfFluid::Utilities::calculate_volume_flux<dim> (f_dim,
-                                                                                           face_level_set_time_grad,
-                                                                                           cell_i_normal,
-                                                                                           face_level_set_d);
-            }
-
-          // Add fluxes to RHS
-          if (update_from_old)
-            {
-              // First part of dimensional split update, so use an implicit correction term (adjust matrix)
-              data.local_matrix(0, 0) -= face_flux;
-              data.local_rhs[0] -= (flux_volume_of_fluid) * face_flux;
-            }
-          else
-            {
-              // Later part of dimensional split update, so use an explicit correction term
-              // Matrix term was assembled in the cell portion of the assembler, so no update needed
-              data.local_rhs[0] -= (flux_volume_of_fluid-cell_volume_of_fluid) * face_flux;
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void VolumeOfFluidAssembler<dim>::local_assemble_internal_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
-        const bool update_from_old,
-        const typename DoFHandler<dim>::active_cell_iterator &cell,
-        const unsigned int face_no,
-        internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
-        internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const
-    {
-      const double volume_fraction_threshold = this->get_volume_of_fluid_handler().get_volume_fraction_threshold();
-      const bool old_velocity_available = (this->get_timestep_number() > 0);
-
-      const unsigned int f_dim = face_no/2; // Obtain dimension
-      const bool face_normal_is_positive = (face_no%2==1); // identify direction of face normal
-
-      const unsigned int n_f_q_points    = scratch.face_finite_element_values.n_quadrature_points;
-
-      // Currently assuming cartesian mapping, so cell->measure() works, we
-      // also will need neighbor volume, which cannot be computed easily using
-      // a sum in this call.
-      const double cell_volume = scratch.volume;
-
-      // Volume fraction and interface values are cell-wise constants, so we
-      // can set them from the first solution entry
-      const double cell_volume_of_fluid = scratch.old_field_values[0];
-      const Tensor<1, dim, double> cell_i_normal = scratch.cell_i_n_values[0];
-      const double cell_i_d = scratch.cell_i_d_values[0];
-
-      const FiniteElement<dim> &main_fe = scratch.finite_element_values.get_fe();
-
-      // also have the number of dofs that correspond just to the element for
-      // the system we are currently trying to assemble
-      const unsigned int volume_of_fluid_dofs_per_cell = data.local_dof_indices.size();
-
-      const unsigned int solution_component = field.volume_fraction.first_component_index;
-      const FEValuesExtractors::Scalar solution_field = field.volume_fraction.extractor_scalar();
-
-      const unsigned int volume_of_fluidN_component = field.reconstruction.first_component_index;
-      const FEValuesExtractors::Vector volume_of_fluidN_n = FEValuesExtractors::Vector(volume_of_fluidN_component);
-      const FEValuesExtractors::Scalar volume_of_fluidN_d = FEValuesExtractors::Scalar(volume_of_fluidN_component+dim);
-
-      const typename DoFHandler<dim>::face_iterator face = cell->face (face_no);
-
-      scratch.face_finite_element_values.reinit (cell, face_no);
-
-      const LinearAlgebra::BlockVector &vof_solution_vector = (update_from_old)
-                                                              ?
-                                                              this->get_old_solution()
-                                                              :
-                                                              this->get_solution();
-
-      scratch.face_finite_element_values[this->introspection().extractors.velocities]
-      .get_function_values (this->get_current_linearization_point(),
-                            scratch.face_current_velocity_values);
-
-      scratch.face_finite_element_values[this->introspection().extractors.velocities]
-      .get_function_values (this->get_old_solution(),
-                            scratch.face_old_velocity_values);
-
-      const typename DoFHandler<dim>::cell_iterator
-      neighbor = cell->neighbor_or_periodic_neighbor (face_no);
-      // note: "neighbor" defined above is NOT active_cell_iterator, so this includes cells that are refined
-      // for example: cell with periodic boundary.
-      Assert (neighbor.state() == IteratorState::valid,
-              ExcInternalError());
-      const bool cell_has_periodic_neighbor = cell->has_periodic_neighbor (face_no);
-      const unsigned int neighbor_face_no = (cell_has_periodic_neighbor
-                                             ?
-                                             cell->periodic_neighbor_face_no(face_no)
-                                             :
-                                             cell->neighbor_face_no(face_no));
-
-      const unsigned int n_f_dim = neighbor_face_no/2;
-      const bool n_face_normal_is_positive = (neighbor_face_no%2==1);
-
-      if ((!face->at_boundary() && !face->has_children())
-          || (face->at_boundary() && neighbor->is_active()))
-        {
-          if (neighbor->level () == cell->level () &&
-              neighbor->is_active() &&
-              (((neighbor->is_locally_owned()) && (cell->index() < neighbor->index()))
-               ||
-               ((!neighbor->is_locally_owned()) && (cell->subdomain_id() < neighbor->subdomain_id()))))
-            {
-              /* This cell is taking responsibility for assembly of this face, because
-               *  this cell is equally-sized and
-               *    (a) this cell is on a different subdomain, with lower subdmain_id(), or
-               *    (b) this cell is on the same subdomain and has lower index().
-               */
-              Assert (cell->is_locally_owned(), ExcInternalError());
-
-              Assert (neighbor.state() == IteratorState::valid,
-                      ExcInternalError());
-
-              // Neighbor cell values
-
-              scratch.neighbor_finite_element_values.reinit(neighbor);
-
-              scratch.neighbor_finite_element_values[solution_field]
-              .get_function_values(vof_solution_vector,
-                                   scratch.neighbor_old_values);
-              scratch.neighbor_finite_element_values[volume_of_fluidN_n]
-              .get_function_values(vof_solution_vector,
-                                   scratch.neighbor_i_n_values);
-              scratch.neighbor_finite_element_values[volume_of_fluidN_d]
-              .get_function_values(vof_solution_vector,
-                                   scratch.neighbor_i_d_values);
-
-              // Currently assuming cartesian mapping, so cell->measure()
-              // works, and the neighbor volume cannot be computed easily using
-              // a sum in this call.
-              const double neighbor_volume = neighbor->measure();
-              const double neighbor_volume_of_fluid = scratch.neighbor_old_values[0];
-              const Tensor<1, dim, double> neighbor_i_normal = scratch.neighbor_i_n_values[0];
-              const double neighbor_i_d = scratch.neighbor_i_d_values[0];
-
-              double face_flux = 0;
-              // Variables for holding values that indicate the "level set"
-              // (not signed distance) on the cell face aperture (face x time)
-              // for calculating the volume fluxed through this cell face.
-              double face_level_set_d = 0;
-              double face_level_set_time_grad = 0;
-              double n_face_level_set_d = 0;
-              double n_face_level_set_time_grad =0;
-
-              // Using VolumeOfFluid so need to accumulate flux through face
-              for (unsigned int q=0; q<n_f_q_points; ++q)
-                {
-
-                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
-
-                  //If old velocity available average to half timestep
-                  if (old_velocity_available)
-                    current_u += 0.5*(scratch.face_old_velocity_values[q] -
-                                      scratch.face_current_velocity_values[q]);
-
-                  face_flux += this->get_timestep() *
-                               current_u *
-                               scratch.face_finite_element_values.normal_vector(q) *
-                               scratch.face_finite_element_values.JxW(q);
-
-                }
-
-              // Because the level set data is stored implicitly as a set of
-              // cell-wise constants, the calculation for the relevant normal
-              // time gradient and value of d at the face center must be
-              // computed here
-              if (face_normal_is_positive)
-                {
-                  face_level_set_d = cell_i_d - 0.5*cell_i_normal[f_dim];
-                  face_level_set_time_grad = (face_flux/cell_volume)*cell_i_normal[f_dim];
-                }
-              else
-                {
-                  face_level_set_d = cell_i_d + 0.5*cell_i_normal[f_dim];
-                  face_level_set_time_grad = -(face_flux/cell_volume)*cell_i_normal[f_dim];
-                }
-
-              if (n_face_normal_is_positive)
-                {
-                  n_face_level_set_d = neighbor_i_d - 0.5*neighbor_i_normal[n_f_dim];
-                  n_face_level_set_time_grad = -(face_flux/neighbor_volume)*neighbor_i_normal[n_f_dim];
-                }
-              else
-                {
-                  n_face_level_set_d = neighbor_i_d + 0.5*neighbor_i_normal[n_f_dim];
-                  n_face_level_set_time_grad = (face_flux/neighbor_volume)*neighbor_i_normal[n_f_dim];
-                }
-
-              // Calculate outward flux
-              double flux_volume_of_fluid;
-              if (std::abs(face_flux) < 0.5*volume_fraction_threshold*(cell_volume+neighbor_volume))
-                {
-                  flux_volume_of_fluid = 0.5*(cell_volume_of_fluid+neighbor_volume_of_fluid);
-                }
-              else if (face_flux < 0.0) // Neighbor is upwind
-                {
-                  flux_volume_of_fluid = VolumeOfFluid::Utilities::calculate_volume_flux<dim> (n_f_dim,
-                                                                                               n_face_level_set_time_grad,
-                                                                                               neighbor_i_normal,
-                                                                                               n_face_level_set_d);
-                }
-              else // This cell is upwind
-                {
-                  flux_volume_of_fluid = VolumeOfFluid::Utilities::calculate_volume_flux<dim> (f_dim,
-                                                                                               face_level_set_time_grad,
-                                                                                               cell_i_normal,
-                                                                                               face_level_set_d);
-                }
-
-              std::vector<types::global_dof_index> neighbor_dof_indices (main_fe.dofs_per_cell);
-              // get all dof indices on the neighbor, then extract those
-              // that correspond to the solution_field we are interested in
-              neighbor->get_dof_indices (neighbor_dof_indices);
-
-              const unsigned int f_rhs_ind = Assemblers::nth_interface_matrix(cell->reference_cell(), face_no);
-
-              for (unsigned int i=0; i<volume_of_fluid_dofs_per_cell; ++i)
-                data.neighbor_dof_indices[f_rhs_ind][i]
-                  = neighbor_dof_indices[main_fe.component_to_system_index(solution_component, i)];
-
-              data.face_contributions_mask[f_rhs_ind] = true;
-
-              // fluxes to RHS
-              if (update_from_old)
-                {
-                  data.local_matrix(0, 0) -= face_flux;
-                  data.local_face_matrices_ext_ext[f_rhs_ind](0, 0) += face_flux;
-                  data.local_rhs [0] -= (flux_volume_of_fluid) * face_flux;
-                  data.local_face_rhs[f_rhs_ind][0] += (flux_volume_of_fluid) * face_flux;
-                }
-              else
-                {
-                  data.local_rhs [0] -= (flux_volume_of_fluid-cell_volume_of_fluid) * face_flux;
-                  data.local_face_rhs[f_rhs_ind][0] += (flux_volume_of_fluid-neighbor_volume_of_fluid) * face_flux;
-                }
-            }
-          else
-            {
-              /* neighbor is taking responsibility for assembly of this face, because
-               * either (1) neighbor is coarser, or
-               *        (2) neighbor is equally-sized and
-               *           (a) neighbor is on a different subdomain, with lower subdmain_id(), or
-               *           (b) neighbor is on the same subdomain and has lower index().
-              */
-            }
-        }
-      else // face->has_children() so always assemble from here
-        {
-          for (unsigned int subface_no=0; subface_no< face->n_children(); ++subface_no)
-            {
-              const typename DoFHandler<dim>::active_cell_iterator neighbor_child
-                = ( cell_has_periodic_neighbor
-                    ?
-                    cell->periodic_neighbor_child_on_subface(face_no, subface_no)
-                    :
-                    cell->neighbor_child_on_subface (face_no, subface_no));
-
-              // Neighbor cell values
-
-              scratch.neighbor_finite_element_values.reinit(neighbor_child);
-
-              scratch.neighbor_finite_element_values[solution_field]
-              .get_function_values(vof_solution_vector,
-                                   scratch.neighbor_old_values);
-              scratch.neighbor_finite_element_values[volume_of_fluidN_n]
-              .get_function_values(vof_solution_vector,
-                                   scratch.neighbor_i_n_values);
-              scratch.neighbor_finite_element_values[volume_of_fluidN_d]
-              .get_function_values(vof_solution_vector,
-                                   scratch.neighbor_i_d_values);
-
-              // Currently assuming cartesian mapping, so cell->measure()
-              // works, and the neighbor volume cannot be computed easily using
-              // a sum in this call.
-              const double neighbor_volume = neighbor->measure();
-              const double neighbor_volume_of_fluid = scratch.neighbor_old_values[0];
-
-              scratch.subface_finite_element_values.reinit (cell, face_no, subface_no);
-
-              scratch.subface_finite_element_values[this->introspection().extractors.velocities]
-              .get_function_values (this->get_current_linearization_point(),
-                                    scratch.face_current_velocity_values);
-
-              scratch.subface_finite_element_values[this->introspection().extractors.velocities]
-              .get_function_values (this->get_old_solution(),
-                                    scratch.face_old_velocity_values);
-
-              double face_flux = 0;
-
-              // Using VolumeOfFluid so need to accumulate flux through face
-              for (unsigned int q=0; q<n_f_q_points; ++q)
-                {
-
-                  Tensor<1,dim> current_u = scratch.face_current_velocity_values[q];
-
-                  //If old velocity available average to half timestep
-                  if (old_velocity_available)
-                    current_u += 0.5*(scratch.face_old_velocity_values[q] -
-                                      scratch.face_current_velocity_values[q]);
-
-                  face_flux += this->get_timestep() *
-                               current_u *
-                               scratch.subface_finite_element_values.normal_vector(q) *
-                               scratch.subface_finite_element_values.JxW(q);
-
-                }
-
-              std::vector<types::global_dof_index> neighbor_dof_indices (scratch.subface_finite_element_values.get_fe().dofs_per_cell);
-              neighbor_child->get_dof_indices (neighbor_dof_indices);
-
-              const unsigned int f_rhs_ind = Assemblers::nth_interface_matrix(cell->reference_cell(), face_no, subface_no);
-
-              for (unsigned int i=0; i<volume_of_fluid_dofs_per_cell; ++i)
-                data.neighbor_dof_indices[f_rhs_ind][i]
-                  = neighbor_dof_indices[main_fe.component_to_system_index(solution_component, i)];
-
-              data.face_contributions_mask[f_rhs_ind] = true;
-
-              // fluxes to RHS
-              double flux_volume_of_fluid = face_flux>0.0?cell_volume_of_fluid:neighbor_volume_of_fluid;
-              if (std::abs(face_flux) < 0.5*volume_fraction_threshold*(cell_volume+neighbor_volume))
-                {
-                  flux_volume_of_fluid = 0.5*(cell_volume_of_fluid+neighbor_volume_of_fluid);
-                }
-              if (flux_volume_of_fluid < 0.0)
-                flux_volume_of_fluid = 0.0;
-              if (flux_volume_of_fluid > 1.0)
-                flux_volume_of_fluid = 1.0;
-
-              if (update_from_old)
-                {
-                  data.local_matrix(0, 0) -= face_flux;
-                  data.local_face_matrices_ext_ext[f_rhs_ind](0, 0) += face_flux;
-                  data.local_rhs [0] -= (flux_volume_of_fluid) * face_flux;
-                  data.local_face_rhs[f_rhs_ind][0] += (flux_volume_of_fluid) * face_flux;
-                }
-              else
-                {
-                  data.local_rhs [0] -= (flux_volume_of_fluid-cell_volume_of_fluid) * face_flux;
-                  data.local_face_rhs[f_rhs_ind][0] += (flux_volume_of_fluid-neighbor_volume_of_fluid) * face_flux;
-                }
-
-              // We are currently assembling for a case where the AMR refinement level differs.
-              // If the volume fraction of the fluid flux is not 0 or 1 (to
-              // within tolerance), we are at a VoF fluid interface but have
-              // not correctly computed the advection flux
-              AssertThrow(flux_volume_of_fluid < volume_fraction_threshold || flux_volume_of_fluid>1.0-volume_fraction_threshold,
-                          ExcMessage("Volume of Fluid interface coincides with variation in AMR refinement levels. "
-                                     "This case is not handled by the current Volume of Fluid assembler."));
-            }
-        }
-    }
-  }
-}
-
-
-
-namespace aspect
-{
-  namespace Assemblers
-  {
-#define INSTANTIATE(dim) \
-  template class VolumeOfFluidAssembler<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-
-  }
-}
diff --git a/source/volume_of_fluid/handler.cc.bak b/source/volume_of_fluid/handler.cc.bak
deleted file mode 100644
index 42f4b1698d4..00000000000
--- a/source/volume_of_fluid/handler.cc.bak
+++ /dev/null
@@ -1,647 +0,0 @@
-/*
-  Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/global.h>
-#include <aspect/parameters.h>
-#include <aspect/volume_of_fluid/handler.h>
-#include <aspect/mesh_refinement/volume_of_fluid_interface.h>
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-
-#include <deal.II/base/work_stream.h>
-#include <deal.II/grid/filtered_iterator.h>
-#include <deal.II/fe/fe_dgq.h>
-#include <deal.II/fe/mapping_cartesian.h>
-
-using namespace dealii;
-
-namespace aspect
-{
-  namespace internal
-  {
-    namespace Assembly
-    {
-      namespace Scratch
-      {
-        template <int dim>
-        VolumeOfFluidSystem<dim>::VolumeOfFluidSystem (const FiniteElement<dim> &finite_element,
-                                                       const FiniteElement<dim> &volume_of_fluid_element,
-                                                       const Mapping<dim>       &mapping,
-                                                       const Quadrature<dim>    &quadrature,
-                                                       const Quadrature<dim-1>  &face_quadrature)
-          :
-          finite_element_values (mapping,
-                                 finite_element, quadrature,
-                                 update_values |
-                                 update_gradients |
-                                 update_JxW_values),
-          neighbor_finite_element_values (mapping,
-                                          finite_element, quadrature,
-                                          update_values |
-                                          update_gradients |
-                                          update_JxW_values),
-          face_finite_element_values (mapping,
-                                      finite_element, face_quadrature,
-                                      update_values |
-                                      update_quadrature_points |
-                                      update_gradients |
-                                      update_normal_vectors |
-                                      update_JxW_values),
-          neighbor_face_finite_element_values (mapping,
-                                               finite_element, face_quadrature,
-                                               update_values |
-                                               update_gradients |
-                                               update_normal_vectors |
-                                               update_JxW_values),
-          subface_finite_element_values (mapping,
-                                         finite_element, face_quadrature,
-                                         update_values |
-                                         update_gradients |
-                                         update_normal_vectors |
-                                         update_JxW_values),
-          local_dof_indices(finite_element.dofs_per_cell),
-          phi_field (volume_of_fluid_element.dofs_per_cell, numbers::signaling_nan<double>()),
-          old_field_values (quadrature.size(), numbers::signaling_nan<double>()),
-          cell_i_n_values (quadrature.size(), numbers::signaling_nan<Tensor<1, dim>> ()),
-          cell_i_d_values (quadrature.size(), numbers::signaling_nan<double> ()),
-          face_current_velocity_values (face_quadrature.size(), numbers::signaling_nan<Tensor<1, dim>>()),
-          face_old_velocity_values (face_quadrature.size(), numbers::signaling_nan<Tensor<1, dim>>()),
-          face_old_old_velocity_values (face_quadrature.size(), numbers::signaling_nan<Tensor<1, dim>>()),
-          neighbor_old_values (face_quadrature.size(), numbers::signaling_nan<double>()),
-          neighbor_i_n_values (face_quadrature.size(), numbers::signaling_nan<Tensor<1, dim>>()),
-          neighbor_i_d_values (face_quadrature.size(), numbers::signaling_nan<double>())
-        {}
-
-
-
-        template <int dim>
-        VolumeOfFluidSystem<dim>::VolumeOfFluidSystem (const VolumeOfFluidSystem &scratch)
-          :
-          finite_element_values (scratch.finite_element_values.get_mapping(),
-                                 scratch.finite_element_values.get_fe(),
-                                 scratch.finite_element_values.get_quadrature(),
-                                 scratch.finite_element_values.get_update_flags()),
-          neighbor_finite_element_values (scratch.neighbor_finite_element_values.get_mapping(),
-                                          scratch.neighbor_finite_element_values.get_fe(),
-                                          scratch.neighbor_finite_element_values.get_quadrature(),
-                                          scratch.neighbor_finite_element_values.get_update_flags()),
-          face_finite_element_values (scratch.face_finite_element_values.get_mapping(),
-                                      scratch.face_finite_element_values.get_fe(),
-                                      scratch.face_finite_element_values.get_quadrature(),
-                                      scratch.face_finite_element_values.get_update_flags()),
-          neighbor_face_finite_element_values (scratch.neighbor_face_finite_element_values.get_mapping(),
-                                               scratch.neighbor_face_finite_element_values.get_fe(),
-                                               scratch.neighbor_face_finite_element_values.get_quadrature(),
-                                               scratch.neighbor_face_finite_element_values.get_update_flags()),
-          subface_finite_element_values (scratch.subface_finite_element_values.get_mapping(),
-                                         scratch.subface_finite_element_values.get_fe(),
-                                         scratch.subface_finite_element_values.get_quadrature(),
-                                         scratch.subface_finite_element_values.get_update_flags()),
-          local_dof_indices (scratch.finite_element_values.get_fe().dofs_per_cell),
-          phi_field (scratch.phi_field),
-          old_field_values (scratch.old_field_values),
-          cell_i_n_values (scratch.cell_i_n_values),
-          cell_i_d_values (scratch.cell_i_d_values),
-          face_current_velocity_values (scratch.face_current_velocity_values),
-          face_old_velocity_values (scratch.face_old_velocity_values),
-          face_old_old_velocity_values (scratch.face_old_old_velocity_values),
-          neighbor_old_values (scratch.neighbor_old_values),
-          neighbor_i_n_values (scratch.neighbor_i_n_values),
-          neighbor_i_d_values (scratch.neighbor_i_d_values)
-        {}
-      }
-
-
-
-      namespace CopyData
-      {
-        template <int dim>
-        VolumeOfFluidSystem<dim>::VolumeOfFluidSystem(const FiniteElement<dim> &finite_element)
-          :
-          local_matrix (finite_element.dofs_per_cell,
-                        finite_element.dofs_per_cell),
-          local_rhs (finite_element.dofs_per_cell),
-          local_face_rhs (Assemblers::n_interface_matrices(finite_element.reference_cell()),
-                          Vector<double>(finite_element.dofs_per_cell)),
-          local_face_matrices_ext_ext(Assemblers::n_interface_matrices(finite_element.reference_cell()),
-                                      FullMatrix<double>(finite_element.dofs_per_cell,
-                                                         finite_element.dofs_per_cell)),
-          face_contributions_mask(Assemblers::n_interface_matrices(finite_element.reference_cell()),
-                                  false),
-
-          local_dof_indices (finite_element.dofs_per_cell),
-          neighbor_dof_indices(Assemblers::n_interface_matrices(finite_element.reference_cell()),
-                               std::vector<types::global_dof_index>(finite_element.dofs_per_cell))
-        {}
-
-
-
-        template <int dim>
-        VolumeOfFluidSystem<dim>::VolumeOfFluidSystem(const VolumeOfFluidSystem &data)
-          :
-          local_matrix (data.local_matrix),
-          local_rhs (data.local_rhs),
-          local_face_rhs (data.local_face_rhs),
-          local_face_matrices_ext_ext (data.local_face_matrices_ext_ext),
-          // clear the flag that indicates that we have valid data in any
-          // of the matrices:
-          face_contributions_mask(data.face_contributions_mask.size(), false),
-          local_dof_indices (data.local_dof_indices),
-          neighbor_dof_indices (data.neighbor_dof_indices)
-        {}
-      }
-    }
-  }
-
-
-
-  template <int dim>
-  VolumeOfFluidField<dim>::VolumeOfFluidField(const FEVariable<dim> &volume_fraction,
-                                              const FEVariable<dim> &reconstruction,
-                                              const FEVariable<dim> &level_set,
-                                              const unsigned int composition_index)
-    : volume_fraction (volume_fraction),
-      reconstruction (reconstruction),
-      level_set (level_set),
-      composition_index(composition_index)
-  {}
-
-
-
-  template <int dim>
-  VolumeOfFluidHandler<dim>::VolumeOfFluidHandler (Simulator<dim> &simulator,
-                                                   ParameterHandler &prm)
-    : sim (simulator),
-      assembler ()
-  {
-    this->initialize_simulator(sim);
-    assembler.initialize_simulator(sim);
-    parse_parameters (prm);
-
-    this->get_signals().edit_finite_element_variables.connect(
-      [&](std::vector<VariableDeclaration<dim>> &vars)
-    {
-      this->edit_finite_element_variables(vars);
-    });
-
-    this->get_signals().post_set_initial_state.connect(
-      [&](const SimulatorAccess<dim> &)
-    {
-      this->set_initial_volume_fractions();
-    });
-  }
-
-
-
-  template <int dim>
-  void
-  VolumeOfFluidHandler<dim>::edit_finite_element_variables (std::vector<VariableDeclaration<dim>> &vars)
-  {
-    for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
-      {
-        // Add declaration for volume fraction field
-        vars.push_back(VariableDeclaration<dim>("volume_fraction_"+volume_of_fluid_field_names[f],
-                                                std::make_unique<FE_DGQ<dim>>(0),
-                                                1,
-                                                1));
-
-        // Add declaration for reconstructed interface cache
-        vars.push_back(VariableDeclaration<dim>("volume_of_fluid_interface_reconstruction_"+volume_of_fluid_field_names[f],
-                                                std::make_unique<FE_DGQ<dim>>(0),
-                                                dim+1,
-                                                1));
-
-        vars.push_back(VariableDeclaration<dim>("volume_of_fluid_contour_"+volume_of_fluid_field_names[f],
-                                                std::make_unique<FE_DGQ<dim>>(1),
-                                                1,
-                                                1));
-      }
-  }
-
-
-
-  template <int dim>
-  void
-  VolumeOfFluidHandler<dim>::declare_parameters (ParameterHandler &prm)
-  {
-    prm.enter_subsection ("Volume of Fluid");
-    {
-      prm.declare_entry ("Volume fraction threshold", "1e-6",
-                         Patterns::Double (0., 1.),
-                         "Minimum significant volume. Fluid fractions below this value are considered to be zero.");
-
-      prm.declare_entry ("Volume of Fluid solver tolerance", "1e-12",
-                         Patterns::Double(0., 1.),
-                         "The relative tolerance up to which the linear system "
-                         "for the Volume of Fluid system gets solved. See "
-                         "'Solver parameters/Composition solver tolerance' "
-                         "for more details.");
-
-      prm.declare_entry ("Number initialization samples", "3",
-                         Patterns::Integer (1),
-                         "Number of divisions per dimension when computing the initial volume fractions."
-                         "If set to the default of 3 for a 2d model, then initialization will be based on "
-                         "the initialization criterion at $3^2=9$ points within each cell. If the initialization "
-                         "based on a composition style initial condition, a larger value may be desired for better "
-                         "approximation of the initial fluid fractions. Smaller values will suffice in the case of "
-                         "level set initializations due to the presence of more information to better approximate "
-                         "the initial fluid fractions.");
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection("Initial composition model");
-    {
-      prm.declare_entry("Volume of fluid initialization type", "",
-                        Patterns::Map (Patterns::Anything(),
-                                       Patterns::Selection("composition|level set")),
-                        "A comma separated list denoting the method to be used to "
-                        "initialize a composition field specified to be advected using "
-                        "the volume of fluid method.\n\n"
-                        "The format of valid entries for this parameter is that "
-                        "of a map given as ``key1:value1, key2:value2`` where "
-                        "each key must be the name of a compositional field "
-                        "using the volume of fluid advection method, and the "
-                        "value is one of ``composition`` or ``level "
-                        "set``. ``composition`` is the default\n\n"
-                        "When ``composition is specified, the initial model is "
-                        "treated as a standard composition field with bounds "
-                        "between 0 and 1 assumed, The initial fluid fractions "
-                        "are then based on an iterated midpoint quadrature. "
-                        "Resultant volume fractions outside of the bounds will be "
-                        "coerced to the nearest valid value (ie 0 or 1). "
-                        "If ``level set`` is specified, the initial data will be assumed to "
-                        "be in the form of a signed distance level set function "
-                        "(i.e. a function which is positive when in the "
-                        "fluid, negative outside, and zero on the interface "
-                        "and the magnitude is always the distance to the "
-                        "interface so the gradient is one everywhere).");
-    }
-    prm.leave_subsection();
-  }
-
-
-
-  template <int dim>
-  void
-  VolumeOfFluidHandler<dim>::parse_parameters (ParameterHandler &prm)
-  {
-    // Get parameter data
-    n_volume_of_fluid_fields = 0;
-    std::vector<std::string> names_of_compositional_fields = this->get_parameters().names_of_compositional_fields;
-    std::vector<typename Parameters<dim>::AdvectionFieldMethod::Kind> compositional_field_methods = this->get_parameters().compositional_field_methods;
-
-    for (unsigned int i=0; i<names_of_compositional_fields.size(); ++i)
-      {
-        if (compositional_field_methods[i] == Parameters<dim>::AdvectionFieldMethod::volume_of_fluid)
-          {
-            // Add this field as the next volume of fluid field
-            volume_of_fluid_field_names.push_back(names_of_compositional_fields[i]);
-            // Note that compositional field indices include temperature as field 0, so increase index by 1
-            volume_of_fluid_composition_map_index[i+1] = n_volume_of_fluid_fields;
-            ++n_volume_of_fluid_fields;
-          }
-      }
-
-    prm.enter_subsection ("Volume of Fluid");
-    {
-      volume_fraction_threshold = prm.get_double("Volume fraction threshold");
-
-      volume_of_fluid_solver_tolerance = prm.get_double("Volume of Fluid solver tolerance");
-
-      n_init_samples = prm.get_integer ("Number initialization samples");
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection("Initial composition model");
-    {
-      const std::vector<std::string> x_initialization_type = Utilities::split_string_list(prm.get("Volume of fluid initialization type"));
-
-      initialization_data_type = std::vector<VolumeOfFluid::VolumeOfFluidInputType::Kind> (n_volume_of_fluid_fields,
-                                 VolumeOfFluid::VolumeOfFluidInputType::composition);
-
-      for (const auto &p : x_initialization_type)
-        {
-          // each entry has the format (white space is optional):
-          // <name> : <value (might have spaces)>
-          //
-          // first tease apart the two halves
-          const std::vector<std::string> split_parts = Utilities::split_string_list (p, ':');
-          AssertThrow (split_parts.size() == 2,
-                       ExcMessage ("The format for "
-                                   "<Initial composition model/Volume of fluid initialization method> "
-                                   "volume of fluid initialization met "
-                                   "requires that each entry " "has the form "
-                                   "`<name of field> : <method>', but this "
-                                   "does not match the number of colons in the "
-                                   "entry <" + p + ">."));
-
-          // get the name of the compositional field
-          const std::string &key = split_parts[0];
-
-          // check that the names used are actually names of fields,
-          // are solved by volume of fluid fields, and are unique in this list
-          std::vector<std::string>::iterator field_name_iterator = std::find(names_of_compositional_fields.begin(),
-                                                                             names_of_compositional_fields.end(), key);
-          AssertThrow (field_name_iterator
-                       != names_of_compositional_fields.end(),
-                       ExcMessage ("Name of field <" + key +
-                                   "> appears in the parameter "
-                                   "<Initial composition model/Volume of fluid initialization method>, but "
-                                   "there is no field with this name."));
-
-          const unsigned int compositional_field_index = std::distance(names_of_compositional_fields.begin(),
-                                                                       field_name_iterator);
-
-          AssertThrow (compositional_field_methods[compositional_field_index]
-                       == Parameters<dim>::AdvectionFieldMethod::volume_of_fluid,
-                       ExcMessage ("The field <" + key + "> appears in the parameter "
-                                   "<Initial composition model/Volume of fluid initialization method>, "
-                                   "but is not advected by a particle method."));
-
-          AssertThrow (std::count(names_of_compositional_fields.begin(),
-                                  names_of_compositional_fields.end(), key) == 1,
-                       ExcMessage ("Name of field <" + key + "> appears more "
-                                   "than once in the parameter "
-                                   "<Initial composition model/Volume of fluid initialization type>."));
-
-          // Get specification for how to treat initializing data
-          const std::string &value = split_parts[1];
-
-          if (value == "composition")
-            initialization_data_type[volume_of_fluid_composition_map_index[compositional_field_index+1]]
-              = VolumeOfFluid::VolumeOfFluidInputType::composition;
-          else if (value == "level set")
-            initialization_data_type[volume_of_fluid_composition_map_index[compositional_field_index+1]]
-              = VolumeOfFluid::VolumeOfFluidInputType::level_set;
-          else
-            AssertThrow(false,ExcNotImplemented());
-        }
-    }
-    prm.leave_subsection();
-  }
-
-
-
-  template <int dim>
-  void
-  VolumeOfFluidHandler<dim>::initialize (ParameterHandler &/*prm*/)
-  {
-    // Do checks on required assumptions
-    AssertThrow(dim==2,
-                ExcMessage("Volume of Fluid Interface Tracking is currently only functional for dim=2."));
-
-    AssertThrow(this->get_parameters().CFL_number < 1.0,
-                ExcMessage("Volume of Fluid Interface Tracking requires CFL < 1."));
-
-    AssertThrow(!this->get_material_model().is_compressible(),
-                ExcMessage("Volume of Fluid Interface Tracking currently assumes incompressibility."));
-
-    AssertThrow(Plugins::plugin_type_matches<const GeometryModel::Box<dim>> (this->get_geometry_model()) ||
-                Plugins::plugin_type_matches<const GeometryModel::TwoMergedBoxes<dim>> (this->get_geometry_model()),
-                ExcMessage("Volume of Fluid Interface Tracking currently requires a box geometry."));
-
-    AssertThrow(!this->get_parameters().mesh_deformation_enabled,
-                ExcMessage("Volume of Fluid Interface Tracking is currently incompatible with the Free Surface implementation."));
-
-    AssertThrow(!this->get_parameters().include_melt_transport,
-                ExcMessage("Volume of Fluid Interface Tracking has not been tested with melt transport yet, so inclusion of both is currently disabled."));
-
-    if ( this->get_parameters().initial_adaptive_refinement > 0 ||
-         this->get_parameters().adaptive_refinement_interval > 0 )
-      {
-        AssertThrow(this->get_mesh_refinement_manager().template has_matching_mesh_refinement_strategy<MeshRefinement::VolumeOfFluidInterface<dim>>(),
-                    ExcMessage("Volume of Fluid Interface Tracking requires that the 'volume of fluid interface' strategy be used for AMR"));
-
-        AssertThrow(this->get_parameters().adaptive_refinement_interval <(1/this->get_parameters().CFL_number),
-                    ExcMessage("Currently, the Volume of Fluid Interface Tracking requires that the AMR interval be less than "
-                               "1.0/CFL_number to preserve the intended accuracy. Circumventing this limitation requires "
-                               "additional care in the reconstruction algorithm."));
-      }
-
-    // Gather the created volume fraction data into a structure for easier programmatic referencing
-
-    for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
-      {
-        data.push_back(VolumeOfFluidField<dim>(this->introspection().variable("volume_fraction_"+volume_of_fluid_field_names[f]),
-                                               this->introspection().variable("volume_of_fluid_interface_reconstruction_"+volume_of_fluid_field_names[f]),
-                                               this->introspection().variable("volume_of_fluid_contour_"+volume_of_fluid_field_names[f]),
-                                               this->introspection().compositional_index_for_name(volume_of_fluid_field_names[f])));
-      }
-  }
-
-
-
-  template <int dim>
-  unsigned int VolumeOfFluidHandler<dim>::get_n_fields() const
-  {
-    return n_volume_of_fluid_fields;
-  }
-
-
-
-  template <int dim>
-  const std::string VolumeOfFluidHandler<dim>::name_for_field_index(unsigned int field) const
-  {
-    Assert(field < n_volume_of_fluid_fields,
-           ExcMessage("Invalid field index"));
-    return volume_of_fluid_field_names[field];
-  }
-
-
-
-  template <int dim>
-  double VolumeOfFluidHandler<dim>::get_volume_fraction_threshold() const
-  {
-    return volume_fraction_threshold;
-  }
-
-
-
-  template <int dim>
-  const VolumeOfFluidField<dim> &VolumeOfFluidHandler<dim>::field_struct_for_field_index(unsigned int field) const
-  {
-    Assert(field < n_volume_of_fluid_fields,
-           ExcMessage("Invalid field index"));
-    return data[field];
-  }
-
-
-
-  template <int dim>
-  unsigned int VolumeOfFluidHandler<dim>::field_index_for_name(const std::string &composition_fieldname) const
-  {
-    const unsigned int composition_index = this->introspection().compositional_index_for_name(composition_fieldname);
-    if (volume_of_fluid_composition_map_index.count(composition_index) ==0)
-      return n_volume_of_fluid_fields;
-    return volume_of_fluid_composition_map_index.at(composition_index);
-  }
-
-
-
-  template <int dim>
-  void VolumeOfFluidHandler<dim>::do_volume_of_fluid_update (const typename Simulator<dim>::AdvectionField &advection_field)
-  {
-    const bool direction_order_descending = (this->get_timestep_number() % 2) == 1;
-    const VolumeOfFluidField<dim> volume_of_fluid_field = data[volume_of_fluid_composition_map_index[advection_field.field_index()]];
-
-    const unsigned int volume_of_fluid_block_idx = volume_of_fluid_field.volume_fraction.block_index;
-    const unsigned int volume_of_fluidN_block_idx = volume_of_fluid_field.reconstruction.block_index;
-
-    // Due to dimensionally split formulation, use Strang (second-order dimensional) splitting
-    for (unsigned int direction = 0; direction < dim; ++direction)
-      {
-        // Only reference old_solution for data from prior substep if this is the first
-        // substep for dimensional splitting
-        bool update_from_old = (direction == 0);
-        // Update base to intermediate solution
-        if (!direction_order_descending)
-          {
-            assemble_volume_of_fluid_system(volume_of_fluid_field, direction, update_from_old);
-          }
-        else
-          {
-            assemble_volume_of_fluid_system(volume_of_fluid_field, dim-direction-1, update_from_old);
-          }
-        solve_volume_of_fluid_system (volume_of_fluid_field);
-        // Copy current candidate normals.
-        // primarily useful for exact linear translation
-        sim.solution.block(volume_of_fluidN_block_idx) = sim.old_solution.block(volume_of_fluidN_block_idx);
-        update_volume_of_fluid_normals (volume_of_fluid_field, sim.solution);
-
-        sim.current_linearization_point.block(volume_of_fluid_block_idx) = sim.solution.block(volume_of_fluid_block_idx);
-        sim.current_linearization_point.block(volume_of_fluidN_block_idx) = sim.solution.block(volume_of_fluidN_block_idx);
-      }
-    update_volume_of_fluid_composition(advection_field, volume_of_fluid_field, sim.solution);
-  }
-
-
-
-  template <int dim>
-  void VolumeOfFluidHandler<dim>::assemble_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
-                                                                   const unsigned int dir,
-                                                                   const bool update_from_old)
-  {
-    TimerOutput::Scope timer (sim.computing_timer, "Assemble volume of fluid system");
-
-    const unsigned int block0_idx = field_struct_for_field_index(0).volume_fraction.block_index;
-    const unsigned int block_idx = field.volume_fraction.block_index;
-
-    if (block0_idx!=block_idx)
-      {
-        // Allocate the system matrix for the current VoF field by
-        // reusing the Trilinos sparsity pattern from the matrix stored for
-        // composition 0 (this is the place we allocate the matrix at).
-        sim.system_matrix.block(block_idx, block_idx).reinit(sim.system_matrix.block(block0_idx, block0_idx));
-      }
-
-    sim.system_matrix.block(block_idx, block_idx) = 0;
-    sim.system_rhs = 0;
-
-    using CellFilter = FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
-
-    const FiniteElement<dim> &volume_of_fluid_fe = (*field.volume_fraction.fe);
-
-    // we have to assemble the term u.grad phi_i * phi_j, which is
-    // of total polynomial degree
-    //   stokes_deg - 1
-    // (or similar for comp_deg). this suggests using a Gauss
-    // quadrature formula of order
-    //   stokes_deg/2
-    // rounded up. do so. (note that x/2 rounded up
-    // equals (x+1)/2 using integer division.)
-    const unsigned int vof_quadrature_degree = (this->get_parameters().stokes_velocity_degree+1)/2;
-
-    WorkStream::
-    run (CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     this->get_dof_handler().begin_active()),
-         CellFilter (IteratorFilters::LocallyOwnedCell(),
-                     this->get_dof_handler().end()),
-         std::bind (&Assemblers::VolumeOfFluidAssembler<dim>::
-                    local_assemble_volume_of_fluid_system,
-                    assembler,
-                    field,
-                    dir,
-                    update_from_old,
-                    std::placeholders::_1,
-                    std::placeholders::_2,
-                    std::placeholders::_3),
-         std::bind (&VolumeOfFluidHandler<dim>::
-                    copy_local_to_global_volume_of_fluid_system,
-                    this,
-                    std::placeholders::_1),
-         internal::Assembly::Scratch::
-         VolumeOfFluidSystem<dim> (this->get_fe(),
-                                   volume_of_fluid_fe,
-                                   this->get_mapping(),
-                                   QGauss<dim>(vof_quadrature_degree),
-                                   QGauss<dim-1>(vof_quadrature_degree)),
-         internal::Assembly::CopyData::
-         VolumeOfFluidSystem<dim> (volume_of_fluid_fe));
-
-    sim.system_matrix.compress(VectorOperation::add);
-    sim.system_rhs.compress(VectorOperation::add);
-  }
-
-
-
-  template <int dim>
-  void VolumeOfFluidHandler<dim>::copy_local_to_global_volume_of_fluid_system (const internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data)
-  {
-    // copy entries into the global matrix. note that these local contributions
-    // only correspond to the advection dofs, as assembled above
-    sim.current_constraints.distribute_local_to_global (data.local_matrix,
-                                                        data.local_rhs,
-                                                        data.local_dof_indices,
-                                                        sim.system_matrix,
-                                                        sim.system_rhs);
-
-    // In the following, we copy DG contributions entry by entry. This
-    // is allowed since there are no constraints imposed on discontinuous fields.
-    for (unsigned int f=0; f<data.face_contributions_mask.size(); ++f)
-      {
-        if (data.face_contributions_mask[f])
-          {
-            for (unsigned int i=0; i<data.neighbor_dof_indices[f].size(); ++i)
-              {
-                sim.system_rhs(data.neighbor_dof_indices[f][i]) += data.local_face_rhs[f][i];
-                for (unsigned int j=0; j< data.neighbor_dof_indices[f].size(); ++j)
-                  {
-                    sim.system_matrix.add(data.neighbor_dof_indices[f][i],
-                                          data.neighbor_dof_indices[f][j],
-                                          data.local_face_matrices_ext_ext[f](i,j));
-                  }
-              }
-          }
-      }
-  }
-}
-
-
-
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template class VolumeOfFluidHandler<dim>;
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/volume_of_fluid/reconstruct.cc.bak b/source/volume_of_fluid/reconstruct.cc.bak
deleted file mode 100644
index 4ad97a38dfa..00000000000
--- a/source/volume_of_fluid/reconstruct.cc.bak
+++ /dev/null
@@ -1,519 +0,0 @@
-/*
- Copyright (C) 2016 - 2023 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file doc/COPYING.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/global.h>
-#include <aspect/simulator.h>
-#include <aspect/volume_of_fluid/handler.h>
-#include <aspect/volume_of_fluid/utilities.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <>
-  void VolumeOfFluidHandler<2>::update_volume_of_fluid_normals (const VolumeOfFluidField<2> &field,
-                                                                LinearAlgebra::BlockVector &solution)
-  {
-    const unsigned int dim = 2;
-    const unsigned int max_degree = 1;
-
-    LinearAlgebra::BlockVector initial_solution;
-
-    TimerOutput::Scope timer (sim.computing_timer, "Reconstruct VolumeOfFluid interfaces");
-
-    initial_solution.reinit(sim.system_rhs, false);
-
-    // Boundary reference
-    typename DoFHandler<dim>::active_cell_iterator endc =
-      this->get_dof_handler().end ();
-
-    // Number of cells in the local reconstruction stencil
-    const unsigned int n_cells_local_stencil = 9;
-
-    Vector<double> local_volume_of_fluids (n_cells_local_stencil);
-    std::vector<Point<dim>> stencil_unit_cell_centers (n_cells_local_stencil);
-    std::vector<typename DoFHandler<dim>::active_cell_iterator> neighbor_cells(n_cells_local_stencil);
-
-    const unsigned int n_candidate_normals_per_dim = 3; // Named variable for number of candidate sums for each dimension
-    std::vector<double> strip_sums (dim * n_candidate_normals_per_dim);
-
-    // Named variable for number of candidate interface normal vectors for the reconstruction
-    const unsigned int n_candidate_normals = dim*n_candidate_normals_per_dim+1;
-    std::vector<Tensor<1, dim, double>> normals (n_candidate_normals);
-    std::vector<double> d_vals (n_candidate_normals);
-    std::vector<double> errs (n_candidate_normals);
-
-    // Variables to do volume calculations
-
-    const QGauss<dim> quadrature(max_degree);
-
-    std::vector<double> xFEM_values(quadrature.size());
-
-    const FiniteElement<dim> &system_fe = this->get_fe();
-
-    FEValues<dim> fevalues(this->get_mapping(), system_fe, quadrature,
-                           update_JxW_values);
-
-    // Normal holding vars
-    Point<dim> reconstruction_stencil_unit_cell_center;
-    Tensor<1, dim, double> normal;
-    double d;
-
-    for (unsigned int i=0; i<dim; ++i)
-      reconstruction_stencil_unit_cell_center[i] = 0.5;
-
-    std::vector<types::global_dof_index> cell_dof_indices (system_fe.dofs_per_cell);
-    std::vector<types::global_dof_index> local_dof_indices (system_fe.dofs_per_cell);
-
-    const FEVariable<dim> &volume_of_fluid_var = field.volume_fraction;
-    const unsigned int volume_of_fluid_c_index = volume_of_fluid_var.first_component_index;
-    const unsigned int volume_of_fluid_ind
-      = this->get_fe().component_to_system_index(volume_of_fluid_c_index, 0);
-
-    const FEVariable<dim> &volume_of_fluidN_var = field.reconstruction;
-    const unsigned int volume_of_fluidN_c_index = volume_of_fluidN_var.first_component_index;
-    const unsigned int volume_of_fluidN_blockidx = volume_of_fluidN_var.block_index;
-
-    const FEVariable<dim> &volume_of_fluidLS_var = field.level_set;
-    const unsigned int volume_of_fluidLS_c_index = volume_of_fluidLS_var.first_component_index;
-    const unsigned int n_volume_of_fluidLS_dofs = volume_of_fluidLS_var.fe->dofs_per_cell;
-    const unsigned int volume_of_fluidLS_blockidx = volume_of_fluidLS_var.block_index;
-
-    //Iterate over cells
-    for (auto cell : this->get_dof_handler().active_cell_iterators ())
-      {
-        if (!cell->is_locally_owned ())
-          continue;
-
-        // Obtain data for this cell and neighbors
-        cell->get_dof_indices (local_dof_indices);
-        const double cell_volume_of_fluid = solution(local_dof_indices[volume_of_fluid_ind]);
-
-        normal[0] = 0.0;
-        normal[1] = 0.0;
-        d = -1.0;
-
-        if (cell_volume_of_fluid > 1.0 - volume_fraction_threshold)
-          {
-            d = 1.0;
-            initial_solution(local_dof_indices[volume_of_fluid_ind]) = 1.0;
-          }
-        else if (cell_volume_of_fluid < volume_fraction_threshold)
-          {
-            d = -1.0;
-            initial_solution(local_dof_indices[volume_of_fluid_ind]) = 0.0;
-          }
-        else
-          {
-            initial_solution(local_dof_indices[volume_of_fluid_ind]) = cell_volume_of_fluid;
-
-            // Get references to neighboring cells to build stencil references
-            //
-            // Due to mesh structure, we need to obtain the cells by
-            // considering the pattern of neighboring cells
-            //
-            // Indices used for the stencil references follow the
-            // pattern
-            //
-            // 6 7 8
-            // 3 4 5
-            // 0 1 2
-            const unsigned int stencil_side_cell_count = 3;
-            for (unsigned int i = 0; i < stencil_side_cell_count; ++i)
-              {
-                typename DoFHandler<dim>::active_cell_iterator cen; // holding variable for cell at column center
-                if (i == 0 || i == 2)
-                  {
-                    // Not on center column, so obtain the center cell of the appropriate row
-                    const unsigned int neighbor_no = (i/2);
-                    const typename DoFHandler<dim>::face_iterator face = cell->face (neighbor_no);
-                    if ((face->at_boundary() && !cell->has_periodic_neighbor(neighbor_no)) ||
-                        face->has_children())
-                      cen = endc;
-                    else
-                      {
-                        const typename DoFHandler<dim>::cell_iterator neighbor =
-                          cell->neighbor_or_periodic_neighbor(neighbor_no);
-                        if (neighbor->level() == cell->level() &&
-                            neighbor->is_active())
-                          cen = neighbor;
-                        else
-                          cen = endc;
-                      }
-                  }
-                else
-                  {
-                    // On center column, so current cell is center of column
-                    cen = cell;
-                  }
-
-                for (unsigned int j = 0; j < stencil_side_cell_count; ++j)
-                  {
-                    typename DoFHandler<dim>::active_cell_iterator curr; // Variable for cell at current stencil location
-                    if (cen == endc)
-                      {
-                        // Current column center is not in mesh, so assume that
-                        // the desired piece of the stencil is also outside.
-                        curr = endc;
-                      }
-                    else
-                      {
-                        // Current column center exists, so obtain correct cell reference
-                        if (j == 0 || j == 2)
-                          {
-                            //
-                            const unsigned int neighbor_no = 2+(j/2);
-                            const typename DoFHandler<dim>::face_iterator face = cen->face (neighbor_no);
-                            if ((face->at_boundary() && !cen->has_periodic_neighbor(neighbor_no)) ||
-                                face->has_children())
-                              curr = endc;
-                            else
-                              {
-                                const typename DoFHandler<dim>::cell_iterator neighbor =
-                                  cen->neighbor_or_periodic_neighbor(neighbor_no);
-                                if (neighbor->level() == cell->level() &&
-                                    neighbor->is_active())
-                                  curr = neighbor;
-                                else
-                                  curr = endc;
-                              }
-                          }
-                        else
-                          {
-                            // Current stencil reference is column center column center
-                            curr = cen;
-                          }
-                      }
-                    if (curr != endc)
-                      {
-                        // Cell reference is valid, so get data
-                        curr->get_dof_indices (cell_dof_indices);
-                        stencil_unit_cell_centers[3 * j + i] = Point<dim> (-1.0 + i,
-                                                                           -1.0 + j);
-                      }
-                    else
-                      {
-                        // Cell reference is invalid, so replace with current
-                        // cell to reduce branching complexity in the later
-                        // algorithm
-                        cell->get_dof_indices (cell_dof_indices);
-                        stencil_unit_cell_centers[3 * j + i] = Point<dim> (0.0,
-                                                                           0.0);
-                      }
-                    local_volume_of_fluids (3 * j + i) = solution (cell_dof_indices[volume_of_fluid_ind]);
-                    neighbor_cells[3 * j + i] = curr;
-                  }
-              }
-
-            // Gather cell strip sums
-            //
-            // Sums are indexed as
-            // [n_sums_per_dim * parallel_dim + ind]
-            const unsigned int n_sums_per_dim = 3;
-            for (unsigned int i = 0; i < dim * n_candidate_normals_per_dim; ++i)
-              strip_sums[i] = 0.0;
-
-            for (unsigned int i = 0; i < stencil_side_cell_count; ++i)
-              {
-                for (unsigned int j = 0; j < stencil_side_cell_count; ++j)
-                  {
-                    strip_sums[n_sums_per_dim * 0 + i] += local_volume_of_fluids (stencil_side_cell_count * j + i);
-                    strip_sums[n_sums_per_dim * 1 + j] += local_volume_of_fluids (stencil_side_cell_count * j + i);
-                  }
-              }
-
-            // Calculate normal vectors for the 6 candidates from the efficient
-            // least squares approach
-            //
-            // Labeling the sums of the perpendicular strips as
-            // 0 1 2
-            // L C R
-            //
-            // For each dimension consider the interface normals implied by the
-            // 3 divided differences
-            //
-            // L-C/1
-            // C-R/2
-            // L-R/1
-            //
-            for (unsigned int di = 0; di < dim; ++di)
-              {
-                // Get index other dimension
-                unsigned int di2 = (di == 0) ? 1 : 0;
-                for (unsigned int i = 0; i < 3; ++i)
-                  {
-                    normals[n_candidate_normals_per_dim * di + i][di] = 0.0;
-                    normals[n_candidate_normals_per_dim * di + i][di2] = 0.0;
-                    if (i==0 || i == 2)
-                      {
-                        // Positive sum in difference is L
-                        normals[n_candidate_normals_per_dim * di + i][di] += strip_sums[n_sums_per_dim * di + 0];
-                        normals[3 * di + i][di2] += 1.0;
-                      }
-                    else
-                      {
-                        // Positive sum in difference is C
-                        normals[3 * di + i][di] += strip_sums[3 * di + 1];
-                        normals[3 * di + i][di2] += 0.0;
-                      }
-                    if (i == 0)
-                      {
-                        // Negative sum in difference is C
-                        normals[3 * di + i][di] -= strip_sums[3 * di + 1];
-                        normals[3 * di + i][di2] += 0.0;
-                      }
-                    else
-                      {
-                        // Negative sum in difference is R
-                        normals[3 * di + i][di] -= strip_sums[3 * di + 2];
-                        normals[3 * di + i][di2] += 1.0;
-                      }
-
-                    if (strip_sums[3 * di2 + 2] > strip_sums[3 * di2 + 0])
-                      {
-                        // There is more fluid in in area above the interface on the stencil,
-                        // so flip normal direction
-                        normals[3 * di + i][di2] *= -1.0;
-                      }
-                  }
-              }
-
-            // Add time extrapolated local normal as candidate
-            // this is not expected to be the best candidate in general, but
-            // should result in exact reconstruction for linear interface
-            // translations
-            // Inclusion of this candidate will not reduce accuracy due to it
-            // only being selected if it produces a better interface
-            // approximation than the ELS candidates. Note that this will
-            // render linear translation problems less dependent on the
-            // interface reconstruction, so other tests will also be necessary.
-            for (unsigned int i=0; i<dim; ++i)
-              normals[6][i] = solution(local_dof_indices[system_fe
-                                                         .component_to_system_index(volume_of_fluidN_c_index+i, 0)]);
-
-            // If candidate normal too small, remove from consideration
-            if (normals[6]*normals[6]< volume_fraction_threshold)
-              {
-                normals[6][0] = 0;
-                normals[6][1] = 0;
-              }
-
-            unsigned int index_of_best_normal = 0;
-            {
-              fevalues.reinit(cell);
-              const std::vector<double> weights = fevalues.get_JxW_values();
-
-              double cell_vol = 0.0;
-              for (const double weight : weights)
-                {
-                  cell_vol+=weight;
-                }
-              for (unsigned int nind = 0; nind < n_candidate_normals; ++nind)
-                {
-                  errs[nind] = 0.0;
-                  const double normal_norm = normals[nind].norm_square();
-
-                  if (normal_norm > volume_fraction_threshold) // If candidate normal too small set error to maximum
-                    {
-                      d_vals[nind] = VolumeOfFluid::Utilities::compute_interface_location_newton<dim> (
-                                       max_degree,
-                                       normals[nind],
-                                       cell_volume_of_fluid,
-                                       cell_vol,
-                                       volume_of_fluid_reconstruct_epsilon,
-                                       quadrature.get_points(), weights);
-                    }
-                  else
-                    {
-                      errs[nind] = 9.0;
-                    }
-                }
-            }
-
-            for (unsigned int i = 0; i < n_cells_local_stencil; ++i)
-              {
-                if (neighbor_cells[i] == endc)
-                  {
-                    continue;
-                  }
-
-                fevalues.reinit(neighbor_cells[i]);
-
-                const std::vector<double> weights = fevalues.get_JxW_values();
-
-                double cell_vol = 0.0;
-                for (const double weight : weights)
-                  {
-                    cell_vol+=weight;
-                  }
-
-                for (unsigned int nind = 0; nind < n_candidate_normals; ++nind)
-                  {
-                    const double normal_norm = normals[nind]*normals[nind];
-
-                    if (normal_norm > volume_fraction_threshold) // If candidate normal too small skip as set to max already
-                      {
-                        double dot = 0.0;
-                        for (unsigned int di = 0; di < dim; ++di)
-                          dot += normals[nind][di] * stencil_unit_cell_centers[i][di];
-                        const double n_volume_of_fluid = VolumeOfFluid::Utilities::compute_fluid_volume<dim> (max_degree, normals[nind], d_vals[nind]-dot,
-                                                         quadrature.get_points(), weights)/cell_vol;
-                        const double cell_err = local_volume_of_fluids (i) - n_volume_of_fluid;
-                        errs[nind] += cell_err * cell_err;
-                      }
-                  }
-              }
-
-            for (unsigned int nind = 0; nind < n_candidate_normals; ++nind)
-              {
-                if (errs[index_of_best_normal] >= errs[nind])
-                  index_of_best_normal = nind;
-              }
-
-            normal = normals[index_of_best_normal];
-            d = d_vals[index_of_best_normal];
-          }
-
-        for (unsigned int i=0; i<dim; ++i)
-          initial_solution (local_dof_indices[system_fe
-                                              .component_to_system_index(volume_of_fluidN_c_index+i, 0)]) = normal[i];
-
-        initial_solution (local_dof_indices[system_fe
-                                            .component_to_system_index(volume_of_fluidN_c_index+dim, 0)]) = d;
-
-        for (unsigned int i=0; i<n_volume_of_fluidLS_dofs; ++i)
-          {
-            // Recenter unit cell on origin
-            Tensor<1, dim, double> recentered_support_point = volume_of_fluidLS_var.fe->unit_support_point(i)-reconstruction_stencil_unit_cell_center;
-            initial_solution (local_dof_indices[system_fe
-                                                .component_to_system_index(volume_of_fluidLS_c_index, i)])
-              = d-recentered_support_point*normal;
-          }
-      }
-
-    initial_solution.compress(VectorOperation::insert);
-
-    sim.compute_current_constraints();
-    sim.current_constraints.distribute(initial_solution);
-
-    solution.block(volume_of_fluidN_blockidx) = initial_solution.block(volume_of_fluidN_blockidx);
-    solution.block(volume_of_fluidLS_blockidx) = initial_solution.block(volume_of_fluidLS_blockidx);
-  }
-
-
-  template <>
-  void VolumeOfFluidHandler<3>::update_volume_of_fluid_normals (const VolumeOfFluidField<3> &/*field*/,
-                                                                LinearAlgebra::BlockVector &/*solution*/)
-  {
-    Assert(false, ExcNotImplemented());
-  }
-
-  template <>
-  void VolumeOfFluidHandler<2>::update_volume_of_fluid_composition (const typename Simulator<2>::AdvectionField &composition_field,
-                                                                    const VolumeOfFluidField<2> &volume_of_fluid_field,
-                                                                    LinearAlgebra::BlockVector &solution)
-  {
-    const unsigned int dim = 2;
-
-    LinearAlgebra::BlockVector initial_solution;
-
-    TimerOutput::Scope timer (sim.computing_timer, "Compute VolumeOfFluid compositions");
-
-    initial_solution.reinit(sim.system_rhs, false);
-
-    // Normal holding vars
-    Point<dim> reconstruction_stencil_unit_cell_center;
-
-    for (unsigned int i=0; i<dim; ++i)
-      reconstruction_stencil_unit_cell_center[i] = 0.5;
-
-    const FiniteElement<dim> &system_fe = this->get_fe();
-
-    std::vector<types::global_dof_index> local_dof_indices (system_fe.dofs_per_cell);
-
-    const FEVariable<dim> &volume_of_fluid_var = volume_of_fluid_field.volume_fraction;
-    const unsigned int volume_of_fluid_c_index = volume_of_fluid_var.first_component_index;
-    const unsigned int volume_of_fluid_ind
-      = system_fe.component_to_system_index(volume_of_fluid_c_index, 0);
-
-    const FEVariable<dim> &volume_of_fluidN_var = volume_of_fluid_field.reconstruction;
-    const unsigned int volume_of_fluidN_c_index = volume_of_fluidN_var.first_component_index;
-
-    const unsigned int base_element = composition_field.base_element(this->introspection());
-    const std::vector<Point<dim>> support_points = system_fe.base_element(base_element).get_unit_support_points();
-
-    for (auto cell : this->get_dof_handler().active_cell_iterators ())
-      {
-        if (!cell->is_locally_owned())
-          continue;
-
-        cell->get_dof_indices (local_dof_indices);
-        const double cell_volume_of_fluid = solution(local_dof_indices[volume_of_fluid_ind]);
-
-        Tensor<1, dim, double> normal;
-
-        for (unsigned int i=0; i<dim; ++i)
-          normal[i] = solution(local_dof_indices[system_fe
-                                                 .component_to_system_index(volume_of_fluidN_c_index+i, 0)]);
-
-        // Compute L1 normalized normal vector
-        // (Use of L1 normalization makes calculating the correct correction
-        // factor much simpler to retain $0\leq C\leq 1$ bound much simpler)
-        double normal_l1_norm = 0.0;
-        for (unsigned int i=0; i<dim; ++i)
-          {
-            normal_l1_norm += std::abs(normal[i]);
-          }
-        //Calculate correct factor to retain vol frac and [0,1] bound
-        double correction_factor = (normal_l1_norm<volume_fraction_threshold)
-                                   ?
-                                   0.0
-                                   :
-                                   2.0*(0.5-abs(cell_volume_of_fluid-0.5))/normal_l1_norm;
-        for (unsigned int i=0; i<system_fe.base_element(base_element).dofs_per_cell; ++i)
-          {
-            const unsigned int system_local_dof
-              = system_fe.component_to_system_index(composition_field.component_index(sim.introspection),
-                                                    /*dof index within component*/i);
-
-            Tensor<1, dim, double> recentered_support_point = support_points[i]-reconstruction_stencil_unit_cell_center;
-
-            const double value = cell_volume_of_fluid - correction_factor*(recentered_support_point*normal);
-
-            initial_solution(local_dof_indices[system_local_dof]) = value;
-          }
-
-      }
-
-
-    const unsigned int blockidx = composition_field.block_index(this->introspection());
-    solution.block(blockidx) = initial_solution.block(blockidx);
-  }
-
-
-
-  template <>
-  void VolumeOfFluidHandler<3>::update_volume_of_fluid_composition (const Simulator<3>::AdvectionField &/*composition_field*/,
-                                                                    const VolumeOfFluidField<3> &/*volume_of_fluid_field*/,
-                                                                    LinearAlgebra::BlockVector &/*solution*/)
-  {
-    Assert(false, ExcNotImplemented());
-  }
-}
diff --git a/source/volume_of_fluid/setup_initial_conditions.cc.bak b/source/volume_of_fluid/setup_initial_conditions.cc.bak
deleted file mode 100644
index 41209956832..00000000000
--- a/source/volume_of_fluid/setup_initial_conditions.cc.bak
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
- Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file doc/COPYING.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/global.h>
-#include <aspect/simulator.h>
-#include <aspect/volume_of_fluid/handler.h>
-#include <aspect/volume_of_fluid/utilities.h>
-
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim>
-  void VolumeOfFluidHandler<dim>::set_initial_volume_fractions ()
-  {
-    for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
-      {
-
-        switch (initialization_data_type[f])
-          {
-            case VolumeOfFluid::VolumeOfFluidInputType::composition:
-              initialize_from_composition_field (data[f]);
-              break;
-            case VolumeOfFluid::VolumeOfFluidInputType::level_set:
-              initialize_from_level_set (data[f]);
-              break;
-            default:
-              Assert(false, ExcNotImplemented ());
-          }
-
-        const unsigned int volume_of_fluidN_blockidx = data[f].reconstruction.block_index;
-        const unsigned int volume_of_fluidLS_blockidx = data[f].level_set.block_index;
-        update_volume_of_fluid_normals (data[f], sim.solution);
-        sim.old_solution.block(volume_of_fluidN_blockidx) = sim.solution.block(volume_of_fluidN_blockidx);
-        sim.old_old_solution.block(volume_of_fluidN_blockidx) = sim.solution.block(volume_of_fluidN_blockidx);
-        sim.old_solution.block(volume_of_fluidLS_blockidx) = sim.solution.block(volume_of_fluidLS_blockidx);
-        sim.old_old_solution.block(volume_of_fluidLS_blockidx) = sim.solution.block(volume_of_fluidLS_blockidx);
-
-        // Update associated composition field
-        const typename Simulator<dim>::AdvectionField composition_field = Simulator<dim>::AdvectionField::composition(data[f].composition_index);
-        update_volume_of_fluid_composition (composition_field, data[f], sim.solution);
-        const unsigned int volume_of_fluid_C_blockidx = composition_field.block_index(this->introspection());
-        sim.old_solution.block(volume_of_fluid_C_blockidx) = sim.solution.block(volume_of_fluid_C_blockidx);
-        sim.old_old_solution.block(volume_of_fluid_C_blockidx) = sim.solution.block(volume_of_fluid_C_blockidx);
-      }
-  }
-
-  template <int dim>
-  void VolumeOfFluidHandler<dim>::initialize_from_composition_field (
-    const VolumeOfFluidField<dim> &field)
-  {
-    LinearAlgebra::BlockVector initial_solution;
-
-    initial_solution.reinit(sim.system_rhs, false);
-
-    const QIterated<dim> quadrature (QMidpoint<1>(), n_init_samples);
-    FEValues<dim, dim> fe_init (this->get_mapping(), this->get_fe(), quadrature,
-                                update_JxW_values | update_quadrature_points);
-
-    std::vector<types::global_dof_index>
-    local_dof_indices (this->get_fe().dofs_per_cell);
-
-    const FEVariable<dim> &volume_of_fluid_var = field.volume_fraction;
-    const unsigned int component_index = volume_of_fluid_var.first_component_index;
-    const unsigned int blockidx = volume_of_fluid_var.block_index;
-    const unsigned int volume_of_fluid_ind
-      = this->get_fe().component_to_system_index(component_index, 0);
-
-    // Initialize state based on provided function
-    for (auto cell : this->get_dof_handler().active_cell_iterators ())
-      {
-        if (!cell->is_locally_owned ())
-          continue;
-
-        // Calculate approximation for volume
-        cell->get_dof_indices (local_dof_indices);
-
-        fe_init.reinit (cell);
-
-        double volume_of_fluid_val = 0.0;
-        double cell_vol = 0.0;
-
-        for (unsigned int i = 0; i < fe_init.n_quadrature_points; ++i)
-          {
-            const double fraction_at_point = this->get_initial_composition_manager().initial_composition(fe_init.quadrature_point(i),
-                                             field.composition_index);
-            volume_of_fluid_val += fraction_at_point * fe_init.JxW (i);
-            cell_vol += fe_init.JxW(i);
-          }
-
-        volume_of_fluid_val /= cell_vol;
-
-        volume_of_fluid_val = std::min(volume_of_fluid_val, 1.0);
-        volume_of_fluid_val = std::max(volume_of_fluid_val, 0.0);
-
-        initial_solution (local_dof_indices[volume_of_fluid_ind]) = volume_of_fluid_val;
-      }
-
-    initial_solution.compress(VectorOperation::insert);
-
-    // Apply constraints and update solution blocks. This is duplicated from
-    // Simulator<dim>::set_initial_temperature_and_compositional_fields()
-    // in order to separate the volume of fluid algorithm as much as possible from
-    // the rest of the code.
-    sim.compute_current_constraints();
-    sim.current_constraints.distribute(initial_solution);
-
-    sim.solution.block(blockidx) = initial_solution.block(blockidx);
-    sim.old_solution.block(blockidx) = initial_solution.block(blockidx);
-    sim.old_old_solution.block(blockidx) = initial_solution.block(blockidx);
-  }
-
-  template <int dim>
-  void VolumeOfFluidHandler<dim>::initialize_from_level_set (
-    const VolumeOfFluidField<dim> &field)
-  {
-    LinearAlgebra::BlockVector initial_solution;
-
-    initial_solution.reinit(sim.system_rhs, false);
-
-    const QIterated<dim> quadrature (QMidpoint<1>(), n_init_samples);
-    FEValues<dim, dim> fe_init (this->get_mapping(),
-                                this->get_fe(),
-                                quadrature,
-                                update_JxW_values | update_quadrature_points);
-
-    const double h = 1.0/n_init_samples;
-
-    std::vector<types::global_dof_index>
-    local_dof_indices (this->get_fe().dofs_per_cell);
-
-    const FEVariable<dim> &volume_of_fluid_var = field.volume_fraction;
-    const unsigned int component_index = volume_of_fluid_var.first_component_index;
-    const unsigned int blockidx = volume_of_fluid_var.block_index;
-    const unsigned int volume_of_fluid_ind
-      = this->get_fe().component_to_system_index(component_index, 0);
-
-    // Initialize state based on provided function
-    for (auto cell : this->get_dof_handler().active_cell_iterators ())
-      {
-        if (!cell->is_locally_owned ())
-          continue;
-
-        // Calculate approximation for volume
-        cell->get_dof_indices (local_dof_indices);
-
-        const double cell_diam = cell->diameter();
-        const double d_func = this->get_initial_composition_manager().initial_composition(cell->barycenter(),
-                              field.composition_index);
-        fe_init.reinit (cell);
-
-        double volume_of_fluid_val = 0.0;
-        double cell_vol = 0.0;
-
-        if (d_func <=-0.5*cell_diam)
-          {
-            volume_of_fluid_val = 0.0;
-          }
-        else if (d_func >= 0.5*cell_diam)
-          {
-            volume_of_fluid_val = 1.0;
-          }
-        else
-          {
-
-            // For each quadrature point compute an approximation to the fluid fraction in the surrounding region
-            for (unsigned int i = 0; i < fe_init.n_quadrature_points; ++i)
-              {
-                double d = 0.0;
-                Tensor<1, dim, double> grad;
-                Point<dim> xU = quadrature.point (i);
-
-                // Get an approximation to local normal at the closest interface (level set gradient)
-                // and the distance to the closest interface (value of level set function)
-                for (unsigned int di = 0; di < dim; ++di)
-                  {
-                    Point<dim> xH, xL;
-                    xH = xU;
-                    xL = xU;
-                    xH[di] += 0.5*h;
-                    xL[di] -= 0.5*h;
-                    const double dH = this->get_initial_composition_manager().initial_composition(cell->intermediate_point(xH),
-                                                                                                  field.composition_index);
-                    const double dL = this->get_initial_composition_manager().initial_composition(cell->intermediate_point(xL),
-                                                                                                  field.composition_index);
-                    grad[di] = (dL-dH);
-                    d += (0.5/dim)*(dH+dL);
-                  }
-                // Use the basic fluid fraction formula to compute an approximation to the fluid fraction
-                const double fraction_at_point = VolumeOfFluid::Utilities::compute_fluid_fraction (grad, d);
-                volume_of_fluid_val += fraction_at_point * fe_init.JxW (i);
-                cell_vol += fe_init.JxW (i);
-              }
-            volume_of_fluid_val /= cell_vol;
-          }
-
-        initial_solution (local_dof_indices[volume_of_fluid_ind]) = volume_of_fluid_val;
-      }
-
-    initial_solution.compress(VectorOperation::insert);
-
-    // Apply constraints and update solution blocks. This is duplicated from
-    // Simulator<dim>::set_initial_temperature_and_compositional_fields()
-    // in order to separate the volume of fluid algorithm as much as possible from
-    // the rest of the code.
-    sim.compute_current_constraints();
-    sim.current_constraints.distribute(initial_solution);
-
-    sim.solution.block(blockidx) = initial_solution.block(blockidx);
-    sim.old_solution.block(blockidx) = initial_solution.block(blockidx);
-    sim.old_old_solution.block(blockidx) = initial_solution.block(blockidx);
-  }
-}
-
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template void VolumeOfFluidHandler<dim>::set_initial_volume_fractions ();\
-  template void VolumeOfFluidHandler<dim>::initialize_from_composition_field (const VolumeOfFluidField<dim> &field); \
-  template void VolumeOfFluidHandler<dim>::initialize_from_level_set (const VolumeOfFluidField<dim> &field);
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/volume_of_fluid/solver.cc.bak b/source/volume_of_fluid/solver.cc.bak
deleted file mode 100644
index 283ce0d526f..00000000000
--- a/source/volume_of_fluid/solver.cc.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- Copyright (C) 2016 - 2021 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file doc/COPYING.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/global.h>
-#include <aspect/volume_of_fluid/handler.h>
-
-#include <deal.II/lac/affine_constraints.h>
-#include <deal.II/lac/trilinos_solver.h>
-
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  template <int dim>
-  void VolumeOfFluidHandler<dim>::solve_volume_of_fluid_system (const VolumeOfFluidField<dim> &field)
-  {
-    const unsigned int block_idx = field.volume_fraction.block_index;
-
-    TimerOutput::Scope timer (sim.computing_timer, "Solve volume of fluid system");
-    this->get_pcout() << "   Solving volume of fluid system... " << std::flush;
-
-    const double tolerance = std::max(1e-50,
-                                      volume_of_fluid_solver_tolerance*sim.system_rhs.block(block_idx).l2_norm());
-
-    SolverControl solver_control (1000, tolerance);
-
-    TrilinosWrappers::SolverCG solver(solver_control);
-    TrilinosWrappers::PreconditionJacobi precondition;
-    precondition.initialize(sim.system_matrix.block(block_idx, block_idx));
-
-    // Create distributed vector (we need all blocks here even though we only
-    // solve for the current block) because only have a AffineConstraints<double>
-    // for the whole system, current_linearization_point contains our initial guess.
-    LinearAlgebra::BlockVector distributed_solution (
-      this->introspection().index_sets.system_partitioning,
-      this->get_mpi_communicator());
-    distributed_solution.block(block_idx) = sim.current_linearization_point.block (block_idx);
-
-    sim.current_constraints.set_zero(distributed_solution);
-
-    // solve the linear system:
-    try
-      {
-        solver.solve (sim.system_matrix.block(block_idx,block_idx),
-                      distributed_solution.block(block_idx),
-                      sim.system_rhs.block(block_idx),
-                      precondition);
-      }
-    // if the solver fails, report the error from processor 0 with some additional
-    // information about its location, and throw a quiet exception on all other
-    // processors
-    catch (const std::exception &exc)
-      {
-        if (Utilities::MPI::this_mpi_process(this->get_mpi_communicator()) == 0)
-          {
-            AssertThrow (false,
-                         ExcMessage (std::string("The iterative advection solver "
-                                                 "did not converge. It reported the following error:\n\n")
-                                     +
-                                     exc.what()));
-          }
-        else
-          throw QuietException();
-      }
-
-    sim.current_constraints.distribute (distributed_solution);
-    sim.solution.block(block_idx) = distributed_solution.block(block_idx);
-
-    // print number of iterations and also record it in the
-    // statistics file
-    this->get_pcout() << solver_control.last_step()
-                      << " iterations." << std::endl;
-
-    // Do not add VolumeOfFluid solver iterations to statistics, duplication due to
-    // dimensional splitting results in incorrect line formatting (lines of
-    // data split inconsistently with missing values)
-  }
-}
-
-namespace aspect
-{
-#define INSTANTIATE(dim) \
-  template void VolumeOfFluidHandler<dim>::solve_volume_of_fluid_system (const VolumeOfFluidField<dim> &field);
-
-
-  ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-}
diff --git a/source/volume_of_fluid/utilities.cc.bak b/source/volume_of_fluid/utilities.cc.bak
deleted file mode 100644
index fe9cacefc70..00000000000
--- a/source/volume_of_fluid/utilities.cc.bak
+++ /dev/null
@@ -1,694 +0,0 @@
-/*
- Copyright (C) 2016 - 2020 by the authors of the ASPECT code.
-
- This file is part of ASPECT.
-
- ASPECT is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- ASPECT is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with ASPECT; see the file doc/COPYING.  If not see
- <http://www.gnu.org/licenses/>.
- */
-
-#include <aspect/volume_of_fluid/utilities.h>
-
-namespace aspect
-{
-  namespace VolumeOfFluid
-  {
-    namespace Utilities
-    {
-      using namespace dealii;
-
-
-      double compute_fluid_fraction (const Tensor<1, 2> normal,
-                                     const double d)
-      {
-        const int dim = 2;
-
-        //Get 1-Norm
-        double norm1 = 0.0;
-        double max = 0.0;
-        for (unsigned int i = 0; i < dim; ++i)
-          {
-            const double normal_component = std::abs (normal[i]);
-            norm1 += normal_component;
-            max = (max < normal_component) ? normal_component : max;
-          }
-
-        //Obtain volume
-        if (d <= -0.5*norm1)
-          {
-            return 0.0;
-          }
-        if (d >= 0.5*norm1)
-          {
-            return 1.0;
-          }
-        const double dtest = d / norm1; // Threshold value for changes in computation behavior
-        // Normalized parameter indicating the "slope" (positive and finite)
-        // Chosen due to resulting in simple formulas
-        // Equal to the absolute value of the smaller vector entry in the 1-norm normalized normal vector
-        const double mpos = 1.0 - max/norm1;
-        if (dtest < mpos - 0.5)
-          {
-            return (dtest + 0.5) * (dtest + 0.5) / (2.0*mpos * (1.0 - mpos));
-          }
-        if (dtest > 0.5 - mpos)
-          {
-            return 1.0 - (dtest - 0.5) * (dtest - 0.5) / (2.0*mpos * (1.0 - mpos));
-          }
-        return 0.5 + dtest / (1.0 - mpos);
-      }
-
-
-
-      double compute_interface_location (const Tensor<1, 2> normal,
-                                         const double vol)
-      {
-        const int dim = 2;
-
-        //Get 1-Norm
-        double norm1 = 0.0;
-        double max = 0.0;
-        for (unsigned int i = 0; i < dim; ++i)
-          {
-            double normal_component = std::abs (normal[i]);
-            norm1 += normal_component;
-            max = (max < normal_component) ? normal_component : max;
-          }
-
-        // Normalized parameter indicating the "slope" (positive and finite)
-        // Chosen due to resulting in simple formulas
-        // Equal to the absolute value of the smaller vector entry in the 1-norm normalized normal vector
-        const double mpos = (norm1==0.0)?0.0:(1.0-max/norm1);
-        norm1 = (norm1==0.0)? 1.0:norm1;
-
-        // Obtain correct RHS term for interface position
-        if (vol <= 0.0)
-          {
-            return -0.5 * norm1;
-          }
-        else if (vol >= 1.0)
-          {
-            return 0.5 * norm1;
-          }
-        else if (vol < 0.5 * mpos / (1 - mpos))
-          {
-            return norm1 * (-0.5 + sqrt (2.0*vol * mpos * (1 - mpos)));
-          }
-        else if (vol > 1.0 - 0.5 * mpos / (1 - mpos))
-          {
-            return norm1 * (0.5 - sqrt (2.0*(1.0 - vol) * mpos * (1 - mpos)));
-          }
-        else
-          {
-            return norm1 * (1 - mpos) * (vol - 0.5);
-          }
-      }
-
-
-
-      double compute_fluid_fraction (const Tensor<1, 3> normal,
-                                     const double d)
-      {
-        // Calculations done by Scardovelli and Zaleski in
-        // doi:10.1006/jcph.2000.6567,
-        // modified to fit chosen convention on normal interface
-        const int dim = 3;
-
-        Tensor<1, 3> nnormal;
-        //Simplify calculation by reducing to case of d<=0
-        if (d>0.0)
-          {
-            return 1.0-compute_fluid_fraction(-normal, -d);
-          }
-
-        //Get 1-Norm
-        double norm1 = 0.0;
-        for (unsigned int i = 0; i < dim; ++i)
-          {
-            double term = std::abs(normal[i]);
-            norm1 += term;
-          }
-
-        //Return volume in simple cases
-        if (d <= -0.5*norm1)
-          {
-            return 0.0;
-          }
-        if (norm1 == 0.0)
-          {
-            // Case should never occur, return reasonable output for edge circumstance
-            return 0.5;
-          }
-        const double dtest = d / norm1;
-
-        // sort normalized values for normal into nnormal in ascending order of absolute value
-        double mprod = 1.0;
-        for (unsigned int i = 0; i < dim; ++i)
-          {
-            nnormal[i]=std::abs(normal[i])/norm1;
-            mprod *= nnormal[i];
-          }
-        for (unsigned int i =0; i < dim; ++i)
-          {
-            for (unsigned int j=i+1; j < dim; ++j)
-              {
-                if (nnormal[j]<nnormal[i])
-                  {
-                    //Swap
-                    const double tmp = nnormal[j];
-                    nnormal[j] = nnormal[i];
-                    nnormal[i] = tmp;
-                  }
-              }
-          }
-        const double m12 = nnormal[0]+nnormal[1];
-        const double mmin = (m12<nnormal[2])?m12:nnormal[2];
-        const double eps = 1e-10;
-        const double v1= (6.0*nnormal[1]*nnormal[2]>eps)
-                         ?
-                         nnormal[0]*nnormal[0]/(eps)
-                         :
-                         nnormal[0]*nnormal[0]/(6*nnormal[1]*nnormal[2]);
-
-        // do computation for standard cases
-        // Case 1 of Scardovelli and Zaleski (Tetrahedron)
-        if (dtest<nnormal[0]-0.5)
-          {
-            return (dtest+0.5)*(dtest+0.5)*(dtest+0.5)/(6*mprod);
-          }
-        // Case 2 of Scardovelli and Zaleski ("Triangular prism-like")
-        else if (dtest<nnormal[1]-0.5)
-          {
-            return (dtest+0.5)*(dtest+0.5-nnormal[0])/(2*nnormal[1]*nnormal[2])+v1;
-          }
-        // Case 3 of Scardovelli and Zaleski
-        else if (dtest<mmin-0.5)
-          {
-            return (dtest+0.5)*(dtest+0.5)*(3*m12-dtest-0.5)/(6*mprod) +
-                   nnormal[0]*nnormal[0]*(nnormal[0]-3*dtest-1.5)/(6*mprod) +
-                   nnormal[1]*nnormal[1]*(nnormal[1]-3*dtest-1.5)/(6*mprod);
-          }
-        // Case 4 of Scardovelli and Zaleski
-        else if ( nnormal[2]<m12)
-          {
-            return (dtest+0.5)*(dtest+0.5)*(3-2*dtest-1.0)/(6*mprod) +
-                   nnormal[0]*nnormal[0]*(nnormal[0]-3*dtest-1.5)/(6*mprod) +
-                   nnormal[1]*nnormal[1]*(nnormal[1]-3*dtest-1.5)/(6*mprod) +
-                   nnormal[2]*nnormal[2]*(nnormal[2]-3*dtest-1.5)/(6*mprod);
-          }
-
-        // Case 5 of Scardovelli and Zaleski
-        return 0.5*(2.0*dtest+1.0-m12)/nnormal[2];
-      }
-
-
-
-      double compute_interface_location (const Tensor<1, 3, double> normal,
-                                         const double vol)
-      {
-        // Calculations done by Scardovelli and Zaleski in
-        // doi:10.1006/jcph.2000.6567,
-        // modified to fit chosen convention on normal interface
-        const int dim = 3;
-        // Simplify to vol<0.5 case
-        if (vol>0.5)
-          {
-            return -compute_interface_location(-normal, 1.0-vol);
-          }
-
-        //Get 1-Norm
-        double norm1 = 0.0;
-        for (unsigned int i = 0; i < dim; ++i)
-          {
-            double term = std::abs(normal[i]);
-            norm1 += term;
-          }
-        const double eps = 1e-10;
-        double mprod = 1.0;
-        Tensor<1, 3> nnormal;
-        if (norm1<eps)
-          {
-            nnormal[0] = 0.0;
-            nnormal[1] = 0.0;
-            nnormal[2] = 1.0;
-            norm1 = 1.0;
-            mprod =0.0;
-          }
-        else
-          {
-            // sort normalized values for normal into nnormal in ascending order of absolute value
-            for (unsigned int i = 0; i < dim; ++i)
-              {
-                nnormal[i]=std::abs(normal[i])/norm1;
-                mprod *= nnormal[i];
-              }
-            for (unsigned int i =0; i < dim; ++i)
-              {
-                for (unsigned int j=i+1; j < dim; ++j)
-                  {
-                    if (nnormal[j]<nnormal[i])
-                      {
-                        //Swap
-                        const double tmp = nnormal[j];
-                        nnormal[j] = nnormal[i];
-                        nnormal[i] = tmp;
-                      }
-                  }
-              }
-          }
-        //Simple cases
-        if (vol<=0.0)
-          {
-            return -0.5*norm1;
-          }
-
-        const double m1 = nnormal[0];
-        const double m2 = nnormal[1];
-        const double m3 = nnormal[2];
-        const double m12 = m1+m2;
-
-        // Case 1 of Scardovelli and Zaleski
-        const double v1=(6.0*m2*m3>eps)
-                        ?
-                        m1*m1/(eps)
-                        :
-                        m1*m1/(6*m2*m3);
-
-        if (vol<v1)
-          {
-            return -0.5+std::pow(6*mprod*vol, 1./3.);
-          }
-
-        // Case 2 of Scardovelli and Zaleski
-        const double v2 = v1 + 0.5*(m2-m1)/m3;
-        if (vol<v2)
-          {
-            return 0.5*(-1+m1+sqrt(m1*m1+8*m2*m3*(vol-v1)));
-          }
-
-        // Case 3 of Scardovelli and Zaleski
-        double v3 = (m12<m3)
-                    ?
-                    m3*m3*(3*m12-m3)/(6.0*mprod)
-                    + m1*m1*(m1-3*m3)/(6*mprod)
-                    + m2*m2*(m2-3*m3)/(6*mprod)
-                    :
-                    0.5*m12/m3;
-
-        if (vol<v3)
-          {
-            // Solve appropriate cubic
-            const double a2 = -3.0*m12;
-            const double a1 = 3.0*(m1*m1+m2*m2);
-            const double a0 = 6*mprod*vol-m1*m1*m1-m2*m2*m2;
-            const double np0 = a2*a2/9.0-a1/3.0;
-            const double q0 = (a1*a2-3.0*a0)/6.0-a2*a2*a2/27.0;
-            const double theta = acos(q0/sqrt(np0*np0*np0))/3.0;
-            return sqrt(np0)*(sqrt(3.0)*sin(theta)-cos(theta))-a2/3.0;
-          }
-
-        // Case 4
-        if (m3<m12)
-          {
-            // Solve appropriate cubic
-            double a2 = -1.5;
-            double a1 = 1.5*(m1*m1+m2*m2+m3*m3);
-            double a0 = 6*mprod*vol-m1*m1*m1-m2*m2*m2-m3*m3*m3;
-            double np0 = a2*a2/9.0-a1/3.0;
-            double q0 = (a1*a2-3.0*a0)/6.0-a2*a2*a2/27.0;
-            double theta = acos(q0/sqrt(np0*np0*np0))/3.0;
-            return sqrt(np0)*(sqrt(3.0)*sin(theta)-cos(theta))-a2/3.0;
-          }
-
-        return -0.5+m1*vol+0.5*m12;
-      }
-
-
-
-      void xFEM_Heaviside(const unsigned int degree,
-                          const Tensor<1, 2> normal,
-                          const double d,
-                          const std::vector<Point<2>> &points,
-                          std::vector<double> &values)
-      {
-        const int basis_count=4;
-        std::vector<double> coeffs(basis_count);
-
-        const double n_xp = fabs(normal[0]), n_yp = fabs(normal[1]);
-        const double sign_n_x = (((normal[0]) > 0) - ((normal[0]) < 0)),
-                     sign_n_y = (((normal[1]) > 0) - ((normal[1]) < 0));
-
-        const double norm1 = n_xp + n_yp;
-        const double triangle_break = 0.5*fabs(n_xp-n_yp);
-
-        const unsigned int max_degree = 1;
-
-        AssertThrow(degree<=max_degree,
-                    ExcMessage("Cannot generate xFEM polynomials. Only implemented for degrees<2."));
-
-        // The formulas below calculate the correct coefficients for a given
-        // basis in order to form a polynomial $f$ which will satisfy $\int
-        // fpdx=\int pH(d-n\cdot x)dx$ for all polynomials $p$ less than or
-        // equal to the given degree
-        //
-        // The functions for the correct values were calculated and exported using sympy
-        if (d<-0.5*norm1)
-          {
-            for (unsigned int i =0; i < basis_count; ++i)
-              coeffs[i] = 0.0;
-          }
-        else if (d>0.5*norm1)
-          {
-            // Full cell
-            coeffs[0] = 1.0;
-            for (unsigned int i =1; i < basis_count; ++i)
-              coeffs[i] = 0.0;
-          }
-        else if (norm1< 1e-7)
-          {
-            coeffs[0] = 0.5;
-            for (unsigned int i =1; i < basis_count; ++i)
-              coeffs[i] = 0.0;
-          }
-        else if (d<=-triangle_break)
-          {
-            //Triangle
-            const double d_n = d + 0.5*norm1;
-            coeffs[0]=0.5*d_n*d_n/(n_xp*n_yp); // 1
-            coeffs[1]=d_n*d_n*(d_n - 1.5*n_yp)/(n_xp*n_yp*n_yp)*sign_n_y; // 2*y - 1
-            coeffs[2]=d_n*d_n*(d_n - 1.5*n_xp)/(n_xp*n_xp*n_yp)*sign_n_x; // 2*x - 1
-            coeffs[3]=1.5*d_n*d_n*(d_n*d_n - 2.0*d_n*n_xp - 2.0*d_n*n_yp + 3.0*n_xp*n_yp)/
-                      (n_xp*n_xp*n_yp*n_yp)*sign_n_x*sign_n_y; // (2*x - 1)*(2*y - 1)
-          }
-        else if (d<triangle_break && n_xp<n_yp)
-          {
-            //Trapezoid X
-            coeffs[0]=(d + 0.5*n_yp)/n_yp; // 1
-            coeffs[1]=0.25*(12.0*d*d + n_xp*n_xp - 3.0*n_yp*n_yp)/(n_yp*n_yp)*sign_n_y; // 2*y - 1
-            coeffs[2]=-0.5*n_xp/n_yp*sign_n_x; // 2*x - 1
-            coeffs[3]=-3.0*d*n_xp/(n_yp*n_yp)*sign_n_x*sign_n_y; // (2*x - 1)*(2*y - 1)
-          }
-        else if (d<triangle_break && n_yp<n_xp)
-          {
-            //Trapezoid Y
-            coeffs[0]=(d + 0.5*n_xp)/n_xp; // 1
-            coeffs[1]=-0.5*n_yp/n_xp*sign_n_y; // 2*y - 1
-            coeffs[2]=0.25*(12.0*pow(d, 2) - 3.0*n_xp*n_xp + n_yp*n_yp)/(n_xp*n_xp)*sign_n_x; // 2*x - 1
-            coeffs[3]=-3.0*d*n_yp/(n_xp*n_xp)*sign_n_x*sign_n_y; // (2*x - 1)*(2*y - 1)
-          }
-        else
-          {
-            //ITriangle
-            const double d_nn = 0.5*norm1-d;
-            coeffs[0]=1.0L-0.5L*d_nn*d_nn/(n_xp*n_yp); // 1
-            coeffs[1]=0.5L*(d_nn*d_nn)*sign_n_y*(2*d_nn - 3*n_yp)/(n_xp*(n_yp*n_yp)); // 2*y - 1
-            coeffs[2]=0.5L*(d_nn*d_nn)*sign_n_x*(2*d_nn - 3*n_xp)/((n_xp*n_xp)*n_yp); // 2*x - 1
-            coeffs[3]=1.5L*(d_nn*d_nn)*sign_n_x*sign_n_y*(-(d_nn*d_nn) + 2*d_nn*n_xp + 2*d_nn*n_yp - 3*n_xp*n_yp)/((n_xp*n_xp)*(n_yp*n_yp)); // (2*x - 1)*(2*y - 1)
-          }
-
-        // Calculate the correct values at the provided quadrature points by
-        // multiplying coefficients by the basis polynomials.
-        for (unsigned int i = 0; i<points.size(); ++i)
-          {
-            const Point<2> point = points[i];
-            const double x = point[0], y = point[1];
-            values[i] = coeffs[0];
-            if (degree>=1)
-              {
-                values[i] += coeffs[1]*(2.0*y-1.0) +
-                             coeffs[2]*(2.0*x-1.0) +
-                             coeffs[3]*(2.0*x - 1)*(2.0*y - 1.0);
-              }
-          }
-      }
-
-
-
-      void xFEM_Heaviside(const unsigned int /*degree*/,
-                          const Tensor<1, 3> /*normal*/,
-                          const double /*d*/,
-                          const std::vector<Point<3>> &/*points*/,
-                          std::vector<double> &/*values*/)
-      {
-        AssertThrow(false, ExcNotImplemented());
-      }
-
-
-
-      void xFEM_Heaviside_derivative_d(const unsigned int degree,
-                                       const Tensor<1, 2> normal,
-                                       const double d,
-                                       const std::vector<Point<2>> &points,
-                                       std::vector<double> &values)
-      {
-        const int basis_count=4;
-        std::vector<double> coeffs(basis_count);
-
-        const double n_xp = fabs(normal[0]), n_yp = fabs(normal[1]);
-        const double sign_n_x = (((normal[0]) > 0) - ((normal[0]) < 0)),
-                     sign_n_y = (((normal[1]) > 0) - ((normal[1]) < 0));
-
-        const double norm1 = n_xp + n_yp;
-        const double triangle_break = 0.5L*fabs(n_xp-n_yp);
-
-        const int max_degree = 1;
-
-        AssertThrow(degree<=max_degree,
-                    ExcMessage("Cannot generate xFEM polynomials are only functional for degrees<2."));
-
-
-        // The formulas below calculate the correct coefficients for a given
-        // basis in order to form a polynomial $f$ which will satisfy $\int
-        // fpdx=\int pH(d-n\cdot x)dx$ for all polynomials $p$ less than or
-        // equal to the given degree
-        //
-        // The functions for the correct values were calculated and exported using sympy
-        if (d<-0.5*norm1)
-          {
-            for (int i =0; i < basis_count; ++i)
-              coeffs[i] = 0.0;
-          }
-        else if (d>0.5*norm1)
-          {
-            // Full cell
-            for (int i =0; i < basis_count; ++i)
-              coeffs[i] = 0.0;
-          }
-        else if (norm1<1e-7)
-          {
-            for (int i =0; i < basis_count; ++i)
-              coeffs[i] = 0.0;
-          }
-        else if (d<=-triangle_break)
-          {
-            //D Triangle
-            const double d_n = d + 0.5*norm1;
-            coeffs[0]=d_n/(n_xp*n_yp); // 1
-            coeffs[1]=3*d_n*sign_n_y*(d_n - n_yp)/(n_xp*(n_yp*n_yp)); // 2*y - 1
-            coeffs[2]=3*d_n*sign_n_x*(d_n - n_xp)/((n_xp*n_xp)*n_yp); // 2*x - 1
-            coeffs[3]=3*d_n*sign_n_x*sign_n_y*(2*(d_n*d_n) - 3*d_n*n_xp - 3*d_n*n_yp + 3*n_xp*n_yp)/((n_xp*n_xp)*(n_yp*n_yp)); // (2*x - 1)*(2*y - 1)
-          }
-        else if (d<triangle_break && n_xp<n_yp)
-          {
-            //D Trapezoid X
-            coeffs[0]=1.0/n_yp; // 1
-            coeffs[1]=6*d*sign_n_y/(n_yp*n_yp); // 2*y - 1
-            coeffs[2]=0; // 2*x - 1
-            coeffs[3]=-3*n_xp*sign_n_x*sign_n_y/(n_yp*n_yp); // (2*x - 1)*(2*y - 1)
-          }
-        else if (d<triangle_break && n_yp<n_xp)
-          {
-            //D Trapezoid Y
-            coeffs[0]=1.0/n_xp; // 1
-            coeffs[1]=0; // 2*y - 1
-            coeffs[2]=6*d*sign_n_x/(n_xp*n_xp); // 2*x - 1
-            coeffs[3]=-3*n_yp*sign_n_x*sign_n_y/(n_xp*n_xp); // (2*x - 1)*(2*y - 1)
-          }
-        else
-          {
-            //D ITriangle
-            const double d_nn = 0.5*norm1-d;
-            coeffs[0]=d_nn/(n_xp*n_yp); // 1
-            coeffs[1]=3*d_nn*sign_n_y*(-d_nn + n_yp)/(n_xp*(n_yp*n_yp)); // 2*y - 1
-            coeffs[2]=3*d_nn*sign_n_x*(-d_nn + n_xp)/((n_xp*n_xp)*n_yp); // 2*x - 1
-            coeffs[3]=3*d_nn*sign_n_x*sign_n_y*(2*(d_nn*d_nn) - 3*d_nn*n_xp - 3*d_nn*n_yp + 3*n_xp*n_yp)/((n_xp*n_xp)*(n_yp*n_yp)); // (2*x - 1)*(2*y - 1)
-          }
-
-
-        // Calculate the correct values at the provided quadrature points by
-        // multiplying coefficients by the basis polynomials.
-        for (unsigned int i = 0; i<points.size(); ++i)
-          {
-            const Point<2> point = points[i];
-            const double x = point[0], y = point[1];
-            values[i] = coeffs[0];
-            if (degree>=1)
-              {
-                values[i] += coeffs[1]*(2*y-1.0) +
-                             coeffs[2]*(2*x-1.0) +
-                             coeffs[3]*(2*x - 1)*(2*y - 1);
-              }
-          }
-      }
-
-
-
-      void xFEM_Heaviside_derivative_d(const unsigned int /*degree*/,
-                                       const Tensor<1, 3> /*normal*/,
-                                       const double /*d*/,
-                                       const std::vector<Point<3>> &/*points*/,
-                                       std::vector<double> &/*values*/)
-      {
-        AssertThrow(false, ExcNotImplemented());
-      }
-
-
-
-      template <int dim>
-      double compute_interface_location_newton(const unsigned int degree,
-                                               const Tensor<1, dim> normal,
-                                               const double volume_fraction,
-                                               const double vol,
-                                               const double epsilon,
-                                               const std::vector<Point<dim>> &points,
-                                               const std::vector<double> &weights)
-      {
-        double norm1=0.0;
-        for (int i=0; i<dim; ++i)
-          norm1+=fabs(normal[i]);
-        double d_l=-0.5L*norm1, d_h=0.5L*norm1;
-        double f_l=0.0, f_h=1.0;
-        double d_guess= d_l + (volume_fraction-f_l)*(d_h-d_l)/(f_h-f_l);
-
-        std::vector<double> f_values(points.size());
-        std::vector<double> df_values(points.size());
-
-        for (int iter=0; iter<40; ++iter)
-          {
-            xFEM_Heaviside(degree, normal, d_guess, points, f_values);
-            xFEM_Heaviside_derivative_d(degree, normal, d_guess, points, df_values);
-
-            double f_guess=0.0;
-            double df_guess=0.0;
-            for (unsigned int i=0; i<points.size(); ++i)
-              {
-                const double factor = weights[i]/vol;
-                f_guess  += f_values[i]*factor;
-                df_guess += df_values[i]*factor;
-              }
-
-            // Break if within tolerance
-            if (fabs(f_guess-volume_fraction)<epsilon)
-              {
-                break;
-              }
-
-            if (volume_fraction<f_guess)
-              {
-                d_h = d_guess;
-                f_h = f_guess;
-              }
-            else
-              {
-                d_l = d_guess;
-                f_l = f_guess;
-              }
-
-            if (fabs(df_guess)<epsilon)
-              {
-                d_guess = (volume_fraction-f_l)/(f_h-f_l)*(d_h-d_l);
-              }
-            else
-              {
-                d_guess += (volume_fraction-f_guess)/(df_guess);
-
-                if (d_guess < d_l || d_guess > d_h)
-                  {
-                    d_guess = d_l + (volume_fraction-f_l)*(d_h-d_l)/(f_h-f_l);
-                  }
-              }
-          }
-
-        return d_guess;
-      }
-
-      template <int dim>
-      double compute_fluid_volume(const unsigned int degree,
-                                  const Tensor<1, dim> normal,
-                                  const double d,
-                                  const std::vector<Point<dim>> &points,
-                                  const std::vector<double> &weights)
-      {
-        std::vector<double> f_values(points.size());
-
-        xFEM_Heaviside(degree, normal, d, points, f_values);
-
-        double fluid_volume=0.0;
-        for (unsigned int i=0; i<points.size(); ++i)
-          fluid_volume += f_values[i]*weights[i];
-
-        return fluid_volume;
-      }
-
-      template <int dim>
-      double calculate_volume_flux(const unsigned int dir,
-                                   const double time_direction_derivative,
-                                   const Tensor<1, dim> normal,
-                                   const double d_face)
-      {
-        Tensor<1, dim> i_normal;
-        double i_d;
-
-        // Get d value at center of "aperture" (cell face cross timestep)
-        i_d = d_face+0.5*time_direction_derivative;
-        // Get normal vector on "aperture" by replacing the appropriate component with the time_direction_derivative
-        i_normal = normal;
-        i_normal[dir] = time_direction_derivative;
-
-        return compute_fluid_fraction (i_normal, i_d);
-      }
-    }
-  }
-}
-
-namespace aspect
-{
-  namespace VolumeOfFluid
-  {
-    namespace Utilities
-    {
-#define INSTANTIATE(dim) \
-  template double calculate_volume_flux<dim>(const unsigned int dir, \
-                                             const double time_direction_derivative, \
-                                             const Tensor<1, dim> normal, \
-                                             const double d); \
-  template double compute_interface_location_newton<dim>(const unsigned int degree, \
-                                                         const Tensor<1, dim> normal, \
-                                                         const double volume_fraction, \
-                                                         const double vol, \
-                                                         const double epsilon, \
-                                                         const std::vector<Point<dim>> &points, \
-                                                         const std::vector<double> &weights); \
-  template double compute_fluid_volume<dim>(const unsigned int degree, \
-                                            const Tensor<1, dim> normal,\
-                                            const double d,\
-                                            const std::vector<Point<dim>> &points,\
-                                            const std::vector<double> &weights);
-
-      ASPECT_INSTANTIATE(INSTANTIATE)
-
-#undef INSTANTIATE
-    }
-  }
-}
diff --git a/tests/2d_annulus_pyvista_cookbook.prm.bak b/tests/2d_annulus_pyvista_cookbook.prm.bak
deleted file mode 100644
index 973d6157e82..00000000000
--- a/tests/2d_annulus_pyvista_cookbook.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# This setup is a copy of
-# cookbook/onset-of-convection/onset-of-convection.prm
-# with the difference that the geometry is a 2D cylindrical
-# annulus and the initial and boundary temperatures
-# are reduced to generate a lower Rayleigh number system.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Output directory                       = 2d_annulus_pyvista_cookbook
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use conduction timestep                = true
-
-subsection Termination criteria
-  set Termination criteria                 = end step
-  set End step                             = 0
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Outer radius = 6371000
-    set Inner radius = 3481000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r,phi
-    set Function expression = 1600 + 10*sin(2*phi)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2000
-    set Outer temperature = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 4000
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity                     = 1e23
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set Time steps between graphical output = 5
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/ISA_rotation_timescale.prm.bak b/tests/ISA_rotation_timescale.prm.bak
deleted file mode 100644
index 6fa1a19b239..00000000000
--- a/tests/ISA_rotation_timescale.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# 2D model for half of a mid-ocean ridge
-# for testing the ISA rotation timescale postprocessor
-# based on the mid-ocean ridge cookbook, with a few simplifications
-
-set Dimension = 2
-set End time = 5e5
-set Adiabatic surface temperature = 1570
-
-# geometry
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 105000
-    set Y extent  = 70000
-    set X repetitions  = 3
-    set Y repetitions  = 2
-  end
-end
-
-# gravity
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# boundary velocity
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function
-  set Tangential velocity boundary indicators = left
-
-  subsection Function
-    set Function constants  = u0=0.05, x0=10000, xc=52500
-    set Variable names  = x,z
-    set Function expression  = if(x<x0,(1-(x/x0-1)*(x/x0-1))*u0,u0); 0
-  end
-end
-
-# boundary traction
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Representative point  = 105000, 7000
-  end
-end
-
-# initial temperature
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer  = 1e8
-    set Age bottom boundary layer  = 1e5
-    set Amplitude      = 0
-  end
-end
-
-# boundary temperature
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 293
-    set Bottom temperature = 1570
-  end
-end
-
-# material
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 4.7
-    set Reference density = 3400
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity = 5e21
-    set Thermal viscosity exponent = 7
-    set Reference temperature = 1570
-  end
-end
-
-# mesh refinement
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# postprocessing
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables = ISA rotation timescale
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/Picard_compressible.prm.bak b/tests/Picard_compressible.prm.bak
deleted file mode 100644
index cdd244f61ea..00000000000
--- a/tests/Picard_compressible.prm.bak
+++ /dev/null
@@ -1,249 +0,0 @@
-#### This is a compressible whole Earth model solved by the
-#### single Advection, iterated Stokes. This represent a coarse
-#### version of a production type setup.
-#### Global parameters
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 150
-set Max nonlinear iterations in pre-refinement = 0
-set Pressure normalization                 = surface
-set Maximum time step                      = 1e6
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 0.5
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set GMRES solver restart length = 250
-    set Linear solver tolerance             = 1e-5
-    set Maximum number of expensive Stokes solver steps = 1000
-    set Number of cheap Stokes solver steps    = 200
-  end
-end
-
-#### Model Geometry
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3485e3
-    set Outer radius  = 6371e3 #5961e3
-    set Opening angle = 360
-  end
-end
-
-#### Mesh refinement
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Variable names      = depth,t
-    set Coordinate system = depth
-    set Function expression = if(depth<=200e3, 5,if(depth<=620e3, 5,if(depth<=680e3,5,if(depth>=2586e3,5,5))))
-
-    #if(depth<560e3,0,if(depth>760e3,0,6))
-    #        if(depth<560e3,5,if(depth>760e3,5,6))
-  end
-end
-
-##### Set temperature Model
-subsection Boundary temperature model
-  #set Allow fixed temperature on outflow boundaries = true  # default
-  set Fixed temperature boundary indicators         = bottom, top
-
-  #  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 273 #273 for surface ############
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators       = inner, outer
-
-  # set Zero velocity boundary indicators             = outer
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-# Number and names of compositional fields
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = plastic_strain #add strain field
-end
-
-#### Temperature model
-subsection Initial temperature model
-  #set Model name = adiabatic
-  set List of model names =  adiabatic, function
-  set List of model operators = add
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 100.e6
-    set Age top boundary layer = 100.e6
-    set Radius = 0
-    set Amplitude = 0
-    set Position = center
-    set Subadiabaticity = 0
-  end
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names      = x,y,z
-    set Function constants  = R=6371.e3
-    set Function expression = \
-                               if(sqrt(x*x+y*y)<=R<100e3, rand_seed(1) * 100 -50 , 0)
-  end
-end
-
-subsection Adiabatic conditions model # need to initialize for initial adiabatic temp.
-  #send
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_isentrope.txt
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating, radioactive decay
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-
-  subsection Radioactive decay
-    set Crust defined by composition = false
-    set Crust depth = 10e3
-    set Half decay times = 4.468e9, 0.704e9, 14e9, 1.248e9
-    set Heating rates = 9.4946e-5, 5.68e-4, 2.6368e-5, 2.8761e-5
-    set Initial concentrations crust = 0.0, 0.0, 0.0, 0.0
-    set Initial concentrations mantle = 0.0082, 0.000059, 0.024, 0.013
-    set Number of elements = 4
-  end
-
-  #set List of model names = compositional heating
-end
-
-############################ MATERIAL MODEL ######################################################################
-
-subsection Material model
-  set Model name = compositing #visco plastic #melt simple
-  set Material averaging = harmonic average
-
-  ############################ MATERIAL MODEL ######################################################################
-  subsection Compositing
-    set Viscosity = visco plastic
-    set Density = ascii reference profile
-    set Thermal expansion coefficient = ascii reference profile
-    set Specific heat = ascii reference profile
-    set Thermal conductivity = visco plastic
-    set Compressibility = ascii reference profile
-    set Entropy derivative pressure = ascii reference profile
-    set Entropy derivative temperature = ascii reference profile
-    set Reaction terms = visco plastic
-  end
-
-  subsection Ascii reference profile
-    set Thermal conductivity =  3.0
-
-    subsection Ascii data model
-      set Data file name = example_isentrope.txt
-      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    end
-  end
-
-  subsection Visco Plastic
-    set Define transition by depth instead of pressure  = true
-    set Phase transition Clapeyron slopes = background: 3.0e6|-2.5e6|9.e6
-    set Phase transition depths           = background: 410e3|660e3|2740e3
-    set Phase transition widths           = background: 12e3|23e3|11e3
-    set Phase transition temperatures     = background: 1770|1852|2591
-
-    # Reference temperature and viscosity
-    set Reference temperature = 293
-
-    # The minimum strain-rate helps limit large viscosities values that arise
-    # as the strain-rate approaches zero.
-    # The reference strain-rate is used on the first non-linear iteration
-    # of the first time step when the velocity has not been determined yet.
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-
-    # Limit the viscosity with minimum and maximum values
-    set Minimum viscosity = 1e20
-    set Maximum viscosity = 1e26
-
-    # Harmonic viscosity averaging
-    set Viscosity averaging scheme = harmonic
-
-    # Choose to have the viscosity (pre-yield) follow a dislocation
-    # diffusion or composite flow law.  Here, dislocation is selected
-    # so no need to specify diffusion creep parameters below, which are
-    # only used if "diffusion" or "composite" option is selected.
-    set Viscous flow law = diffusion
-
-    #  from cizkov
-    #     order:                           background    ,        mantle_low        ,        mantle_up
-    #    set Thermal diffusivities =   8.384146341463415e-07,     8.384146341463415e-07   , 7.309941520467837e-07
-
-    set Thermal diffusivities = 1.e-6
-    set Thermal expansivities = background: 3.e-5|2.e-5|2.e-5|2.e-5, plastic_strain: 3.e-5
-    set Heat capacities       =        1250     # specific heat
-    set Densities             = background: 3416|3800|4750|4750, plastic_strain: 3416
-    set Prefactors for dislocation creep          = background: 1e-22|1e-22|1e-30|1e-30, plastic_strain:1e-22
-    set Stress exponents for dislocation creep    = 3.5
-    set Activation energies for dislocation creep = background: 4.8e5|4.8e5|4.8e5|4.8e5, plastic_strain:4.8e5
-    set Activation volumes for dislocation creep  = background: 11.e-6|11.e-6|11.e-6|11.e-6, plastic_strain: 11.e-6
-    set Prefactors for diffusion creep            = background: 1.e-9|1.e-9|1.0e-16|1.0e-16, plastic_strain: 1.e-9
-    set Stress exponents for diffusion creep      = 1.0                                                  #### doesnt exist anymore??? ####
-    set Activation energies for diffusion creep   = background: 3.35e5|3.35e5|2.e5|2.e5, plastic_strain: 3.35e5
-    set Activation volumes for diffusion creep    = background: 4.8e-6|4.8e-6|1.1e-6|1.1e-6, plastic_strain: 4.8e-6
-    set Grain size                                = 1 #1e-3
-    set Grain size exponents for diffusion creep  = 0   #default
-
-    ###    # Plasticity parameters
-    set Angles of internal friction = background: 0|0|0|0, plastic_strain:0            # Angle Mohr
-    set Cohesions                   = background: 40e6|1e20|1e20|1e20, plastic_strain:40e6
-    set Strain weakening mechanism = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals = 1.e30
-    set Cohesion strain weakening factors = 1
-    set Friction strain weakening factors = 1
-    set End plasticity strain weakening intervals = 2.e30
-  end
-end
-
-#######################
-# Gravity model
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
-
-#######################
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, \
-                               composition statistics, depth average, heat flux statistics
-
-  subsection Depth average
-    set Number of zones = 3
-    set Output format = txt
-    set Time between graphical output = 1e7
-    set Depth boundaries of zones = 0, 10000,150000,2900000
-  end
-end
diff --git a/tests/additional_outputs_02.cc.bak b/tests/additional_outputs_02.cc.bak
deleted file mode 100644
index 8323fb2e583..00000000000
--- a/tests/additional_outputs_02.cc.bak
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-#include <aspect/simulator/assemblers/interface.h>
-
-#include <iostream>
-
-unsigned int counter_without = 0, counter_with = 0;
-bool quiet = true;
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-    template <int dim>
-    class AdditionalOutputs1 : public AdditionalMaterialOutputs<dim>
-    {
-      public:
-        AdditionalOutputs1 (const unsigned int n_points)
-        {
-          additional_material_output1.resize(n_points);
-        }
-
-        std::vector<double> additional_material_output1;
-    };
-
-
-    template <int dim>
-    class Material1 : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const
-        {
-          MaterialModel::Simple<dim>::evaluate(in, out);
-
-          AdditionalOutputs1<dim> *additional;
-
-          additional = out.template get_additional_output<AdditionalOutputs1<dim>>();
-          if (additional)
-            ++counter_with;
-          else
-            ++counter_without;
-
-          if (additional)
-            additional->additional_material_output1[0] = 42.0;
-
-          if (quiet)
-            return;
-
-          if (additional)
-            std::cout << "* evaluate called with additional outputs!" << std::endl;
-          else
-            std::cout << "* evaluate called without additional outputs!" << std::endl;
-
-        }
-
-
-    };
-
-  }
-
-
-  template <int dim>
-  class TestAssembler :
-    public aspect::Assemblers::Interface<dim>
-  {
-    public:
-
-      virtual void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-        std::cout << "* create_additional_material_model_outputs() called" << std::endl;
-
-        if (out.template get_additional_output<MaterialModel::AdditionalOutputs1<dim>>() != nullptr)
-          return;
-
-        std::cout << "   creating additional output!" << std::endl;
-        out.additional_outputs.push_back(std::make_unique<MaterialModel::AdditionalOutputs1<dim>> (1));
-
-      }
-
-      virtual void execute(internal::Assembly::Scratch::ScratchBase<dim>        &scratch_base,
-                           internal::Assembly::CopyData::CopyDataBase<dim>       &/*data_base*/) const
-      {
-        internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-
-        MaterialModel::AdditionalOutputs1<dim> *additional
-          = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalOutputs1<dim>>();
-
-        std::cout << "* local_assemble_stokes call, have additional? " << (additional!=nullptr) << std::endl;
-        if (additional!=nullptr)
-          std::cout << "   value = " << additional->additional_material_output1[0] << std::endl;
-
-
-      }
-
-
-  };
-
-
-  template <int dim>
-  void set_assemblers1(const SimulatorAccess<dim> &,
-                       Assemblers::Manager<dim> &assemblers)
-  {
-    std::cout << "* set_assemblers()" << std::endl;
-
-    std::cout << "called without: " << counter_without << " with: " << counter_with << std::endl;
-    counter_without = 0;
-    counter_with = 0;
-    quiet = false;
-
-    TestAssembler<dim> *test_assembler = new TestAssembler<dim>();
-    assemblers.stokes_system.push_back(std::unique_ptr<Assemblers::Interface<dim>>(test_assembler));
-  }
-}
-
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  std::cout << "* Connecting signals" << std::endl;
-  signals.set_assemblers.connect (&aspect::set_assemblers1<dim>);
-
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
-
-
-class f
-{
-  public:
-    ~f()
-    {
-      std::cout << "called without: " << counter_without << " with: " << counter_with << std::endl;
-    }
-} instance;
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Material1,
-                                   "Material1",
-                                   "")
-  }
-}
diff --git a/tests/additional_outputs_02.prm.bak b/tests/additional_outputs_02.prm.bak
deleted file mode 100644
index f8723b5d3ef..00000000000
--- a/tests/additional_outputs_02.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# A test that adds an assembler that tests if we can create additional
-# material model outputs
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = Material1
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set List of output variables      = viscosity
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/additional_outputs_03.cc.bak b/tests/additional_outputs_03.cc.bak
deleted file mode 100644
index 871eaa60c29..00000000000
--- a/tests/additional_outputs_03.cc.bak
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-#include <aspect/simulator/assemblers/interface.h>
-
-#include <iostream>
-
-unsigned int counter_without = 0, counter_with = 0;
-bool quiet = true;
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-    template <int dim>
-    class AdditionalOutputs1 : public AdditionalMaterialOutputs<dim>
-    {
-      public:
-        AdditionalOutputs1 (const unsigned int n_points)
-        {
-          additional_material_output1.resize(n_points);
-        }
-        virtual void average (const MaterialAveraging::AveragingOperation operation,
-                              const FullMatrix<double>  &projection_matrix,
-                              const FullMatrix<double>  &expansion_matrix)
-        {
-          std::cout << "averaging!" << std::endl;
-          average_property (operation, projection_matrix, expansion_matrix,
-                            additional_material_output1);
-        }
-
-
-
-        std::vector<double> additional_material_output1;
-    };
-
-
-    template <int dim>
-    class Material1 : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const
-        {
-          MaterialModel::Simple<dim>::evaluate(in, out);
-
-          AdditionalOutputs1<dim> *additional;
-
-          additional = out.template get_additional_output<AdditionalOutputs1<dim>>();
-          if (additional)
-            ++counter_with;
-          else
-            ++counter_without;
-
-          if (additional)
-            {
-              additional->additional_material_output1[0] = 42.0;
-              additional->additional_material_output1[1] = 0.0;
-            }
-
-
-          if (quiet)
-            return;
-
-          if (additional)
-            std::cout << "* evaluate called with additional outputs!" << std::endl;
-          else
-            std::cout << "* evaluate called without additional outputs!" << std::endl;
-
-        }
-
-
-    };
-
-  }
-
-
-  template <int dim>
-  class TestAssembler :
-    public aspect::Assemblers::Interface<dim>
-  {
-    public:
-
-      virtual void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &out) const
-      {
-        std::cout << "* create_additional_material_model_outputs() called" << std::endl;
-
-        if (out.template get_additional_output<MaterialModel::AdditionalOutputs1<dim>>() != nullptr)
-          return;
-
-        std::cout << "   creating additional output!" << std::endl;
-        out.additional_outputs.push_back(std::make_unique<MaterialModel::AdditionalOutputs1<dim>> (2));
-
-      }
-
-      virtual void execute(internal::Assembly::Scratch::ScratchBase<dim>        &scratch_base,
-                           internal::Assembly::CopyData::CopyDataBase<dim>       &/*data_base*/) const
-      {
-        internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-
-        MaterialModel::AdditionalOutputs1<dim> *additional
-          = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalOutputs1<dim>>();
-
-        std::cout << "* local_assemble_stokes call, have additional? " << (additional!=nullptr) << std::endl;
-        if (additional!=nullptr)
-          std::cout << "   value = " << additional->additional_material_output1[0]
-                    << ' ' << additional->additional_material_output1[1] << std::endl;
-
-
-      }
-
-
-  };
-
-
-  template <int dim>
-  void set_assemblers1(const SimulatorAccess<dim> &,
-                       Assemblers::Manager<dim> &assemblers)
-  {
-    std::cout << "* set_assemblers()" << std::endl;
-    std::cout << "called without: " << counter_without << " with: " << counter_with << std::endl;
-    counter_without = 0;
-    counter_with = 0;
-    quiet = false;
-
-    TestAssembler<dim> *test_assembler = new TestAssembler<dim>();
-    assemblers.stokes_system.push_back(std::unique_ptr<Assemblers::Interface<dim>>(test_assembler));
-  }
-}
-
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  std::cout << "* Connecting signals" << std::endl;
-  signals.set_assemblers.connect (&aspect::set_assemblers1<dim>);
-
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
-
-
-class f
-{
-  public:
-    ~f()
-    {
-      std::cout << "called without: " << counter_without << " with: " << counter_with << std::endl;
-    }
-} instance;
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Material1,
-                                   "Material1",
-                                   "")
-  }
-}
diff --git a/tests/additional_outputs_03.prm.bak b/tests/additional_outputs_03.prm.bak
deleted file mode 100644
index a657bae3ad4..00000000000
--- a/tests/additional_outputs_03.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-# A test that adds an assembler that tests if we can create additional
-# material model outputs
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = Material1
-  set Material averaging = arithmetic average
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set List of output variables      = viscosity
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/adiabatic_boundary.prm.bak b/tests/adiabatic_boundary.prm.bak
deleted file mode 100644
index 94096d1c1f6..00000000000
--- a/tests/adiabatic_boundary.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# This test was created by Tahiry Rajaonarison, Emmanuel Njinju, and D. Sarah Stamps
-# for the adiabatic boundary initial conditions plugin.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-4
-set Max nonlinear iterations               = 10
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 35
-    set Chunk maximum longitude = 55
-    set Chunk minimum latitude = -28
-    set Chunk maximum latitude = -8
-    set Chunk inner radius = 5878137
-    set Chunk outer radius = 6378137
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic boundary
-
-  subsection Ascii data model
-    set Data file name = adiabatic_boundary.txt
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Initial temperature
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, outer, west, east, south, north
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/adiabatic_conditions.prm.bak b/tests/adiabatic_conditions.prm.bak
deleted file mode 100644
index 6288c0e397d..00000000000
--- a/tests/adiabatic_conditions.prm.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, depth average
-
-  subsection Depth average
-    set Number of zones = 10
-  end
-end
diff --git a/tests/adiabatic_conditions_composition_function.prm.bak b/tests/adiabatic_conditions_composition_function.prm.bak
deleted file mode 100644
index b153af3f295..00000000000
--- a/tests/adiabatic_conditions_composition_function.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# This test uses an analytical function to compute the
-# adiabatic initial profile. This is useful if the
-# initial composition plugin depends on the adiabatic
-# condition, and can therefore not be used to compute it.
-
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature = 1613
-set End time = 0
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Function expression = if(x > 1500000,1.0,0.0)
-    set Composition reference profile = function
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = 0, 1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Outer temperature = 1613
-    set Inner temperature = 1613
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = 1
-  set Tangential velocity boundary indicators = 0, 2, 3
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 5
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = adiabat
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference temperature = 1613
-    set Viscosity = 1e21
-    set Thermal conductivity = 1e-06
-    set Density differential for compositional field 1 = 500
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function
-end
diff --git a/tests/adiabatic_conditions_function.prm.bak b/tests/adiabatic_conditions_function.prm.bak
deleted file mode 100644
index 9374f7d3cea..00000000000
--- a/tests/adiabatic_conditions_function.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# Test AdiabaticCondition::Function
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = sin(depth); depth; 5.0+depth*depth
-    set Variable names      = depth
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent                = 1
-    set Y extent                = 6.2
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = adiabat
-  end
-end
diff --git a/tests/adiabatic_conditions_time_change.prm.bak b/tests/adiabatic_conditions_time_change.prm.bak
deleted file mode 100644
index 4f1f487fc8b..00000000000
--- a/tests/adiabatic_conditions_time_change.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e-5
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Use surface condition function = true
-
-    subsection Surface condition function
-      set Function expression = 1e12*t; 1613.0+1e6*t
-    end
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1e-5
-    set List of output variables = adiabat
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/adiabatic_heating.prm.bak b/tests/adiabatic_heating.prm.bak
deleted file mode 100644
index 272d403f20b..00000000000
--- a/tests/adiabatic_heating.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# This test is used to check if the adiabatic heating
-# is calculated correctly.
-# The material is upwelling with a constant velocity
-# and without conduction of heat, so that the steady state
-# of the model is an adiabatic temperature profile, and
-# the temperature should not change over time.
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 2.5e13
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9177
-    set Y extent = 183540      # maximum pressure 6 GPa
-    set Y repetitions = 20
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    set Function expression = 0;1e-10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density        = 3300
-    set Reference specific heat  = 1000
-    set Reference temperature    = 1600
-    set Thermal conductivity     = 0.0
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature
-  end
-end
diff --git a/tests/adiabatic_heating_simplified.prm.bak b/tests/adiabatic_heating_simplified.prm.bak
deleted file mode 100644
index d7a2ce2e002..00000000000
--- a/tests/adiabatic_heating_simplified.prm.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-# This test is used to check if the adiabatic heating
-# is calculated correctly. It is based on the test
-# adiabatic_heating, but uses the simplified adiabatic
-# heating model instead.
-# The material is upwelling with a constant velocity
-# and without conduction of heat, so that the steady state
-# of the model is an adiabatic temperature profile, and
-# the temperature should not change over time.
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 2.5e13
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9177
-    set Y extent = 183540      # maximum pressure 6 GPa
-    set Y repetitions = 20
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    set Function expression = 0;1e-10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density        = 3300
-    set Reference specific heat  = 1000
-    set Reference temperature    = 1600
-    set Thermal conductivity     = 0.0
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature
-  end
-end
diff --git a/tests/adiabatic_heating_with_melt.prm.bak b/tests/adiabatic_heating_with_melt.prm.bak
deleted file mode 100644
index c23b6cf5d00..00000000000
--- a/tests/adiabatic_heating_with_melt.prm.bak
+++ /dev/null
@@ -1,146 +0,0 @@
-# This test is used to check if the adiabatic heating
-# of melt is calculated correctly.
-# The material is upwelling with a constant velocity
-# and without conduction of heat, so that the steady state
-# of the model is an adiabatic temperature profile, and
-# the temperature should not change over time.
-#
-# The testcase is very similar to the adiabatic_heating
-# test, but melt transport and the adiabatic heat of melt
-# heating model are enabled. There is 100% melt in the model,
-# and melt has a different density than the solid (so that
-# melt an solid velocities are different). However, the melt
-# should still upwell adiabatically, so temperature should
-# not change.
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 2.5e13
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9177
-    set Y extent = 183540      # maximum pressure 6 GPa
-    set Y repetitions = 20
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    subsection Function
-      set Function expression       = 1.0;0.0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0; 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 3:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    set Function expression = 0;1e-10
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, adiabatic heating of melt
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Reference solid density  = 3300
-    set Reference melt density   = 3000
-    set Reference specific heat  = 1000
-    set Reference temperature    = 1600
-    set Thermal conductivity     = 0.0
-    set Surface solidus          = 10000.0
-    set Include melting and freezing = false
-    set Reference permeability   = 1.2345679e-10
-    set Exponential melt weakening factor = 0.
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
diff --git a/tests/adiabatic_initial_conditions.prm.bak b/tests/adiabatic_initial_conditions.prm.bak
deleted file mode 100644
index 9c5173dbd10..00000000000
--- a/tests/adiabatic_initial_conditions.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# In ASPECT 0.2, we managed to get the adiabatic initial conditions
-# wrong. This was fixed in r1678 by Juliane Dannberg
-#
-# The computation was only wrong if one specified boundary layers. This
-# test verifies this.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature = 1200
-
-############ These parameters are of interest for this test: #########
-
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 3000.0
-    set Outer temperature = 300.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 3.16e15
-    set Age bottom boundary layer = 3.16e15
-    set Subadiabaticity = 0
-  end
-end
-
-########################################################################
-
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 4.125
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = adiabat
-  end
-
-  subsection Depth average
-    set Number of zones = 10
-  end
-end
diff --git a/tests/adiabatic_initial_conditions_chunk.prm.bak b/tests/adiabatic_initial_conditions_chunk.prm.bak
deleted file mode 100644
index a0a2c1b9ae2..00000000000
--- a/tests/adiabatic_initial_conditions_chunk.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# This parameter file tests the adiabatic initial conditions
-# implemented for the chunk geometry.
-# The 2D chunk geometry has a 60 degree opening angle.
-# A 100 K spherical perturbation of radius 400 km is applied
-# in the middle of the inner boundary.
-#
-# This test is based on adiabatic_initial_conditions.prm
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature = 1200
-
-############ These parameters are of interest for this test: #########
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 15
-    set Chunk maximum longitude = 75
-    set Longitude repetitions = 10
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Radius          = 400000.0
-    set Amplitude       = 100
-    set Subadiabaticity = 0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = inner, outer
-end
-
-########################################################################
-
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 4.125
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 3
-  set Strategy                           = temperature
-  set Refinement fraction                = 0.95
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, west, east
-  set Zero velocity boundary indicators       = outer
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Number of zones = 10
-  end
-end
diff --git a/tests/adiabatic_initial_conditions_chunk_3d.prm.bak b/tests/adiabatic_initial_conditions_chunk_3d.prm.bak
deleted file mode 100644
index 857e02bd8a1..00000000000
--- a/tests/adiabatic_initial_conditions_chunk_3d.prm.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-# This parameter file tests the adiabatic initial conditions
-# implemented for the chunk geometry.
-# The 3D chunk geometry has a 30/30 degree opening angle in
-# longitude/latitude.
-# A 50 K spherical perturbation of radius 500 km is applied
-# in the middle of the inner boundary.
-#
-# This test is based on adiabatic_initial_conditions.prm
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature = 1200
-
-############ These parameters are of interest for this test: #########
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 30
-    set Chunk maximum longitude = 60
-    set Longitude repetitions = 4
-    set Chunk minimum latitude = 0
-    set Chunk maximum latitude = 30
-    set Latitude repetitions = 4
-    set Chunk inner radius = 5000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 4
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Radius          = 500000.0
-    set Amplitude       = 50
-    set Subadiabaticity = 0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = inner, outer
-end
-
-########################################################################
-
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 4.125
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Refinement fraction                = 0.95
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, west, east, south, north
-  set Zero velocity boundary indicators       = outer
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Number of zones = 4
-  end
-end
diff --git a/tests/adiabatic_initial_conditions_compressible.prm.bak b/tests/adiabatic_initial_conditions_compressible.prm.bak
deleted file mode 100644
index 0bfd591263e..00000000000
--- a/tests/adiabatic_initial_conditions_compressible.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# like adiabatic_initial_conditions.prm but with a compressible problem
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature = 1200
-
-############ These parameters are of interest for this test: #########
-
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 3000.0
-    set Outer temperature = 300.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 3.16e15
-    set Age bottom boundary layer = 3.16e15
-    set Subadiabaticity = 0
-  end
-end
-
-########################################################################
-
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference compressibility = 4e-12
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Thermal conductivity          = 4.125
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = adiabat
-  end
-
-  subsection Depth average
-    set Number of zones = 10
-  end
-end
diff --git a/tests/adiabatic_initial_conditions_constant.prm.bak b/tests/adiabatic_initial_conditions_constant.prm.bak
deleted file mode 100644
index e8ad4e62ac9..00000000000
--- a/tests/adiabatic_initial_conditions_constant.prm.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-# The adiabatic initial conditions are intended to work
-# as well for models without adiabatic heating, by using
-# the adiabatic surface temperature.
-# This test ensures that boundary layers are handled
-# correctly in this case.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature = 1600
-
-############ These parameters are of interest for this test: #########
-
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 3000.0
-    set Outer temperature = 300.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 3.16e15
-    set Age bottom boundary layer = 3.16e15
-    set Subadiabaticity = 200
-  end
-end
-
-########################################################################
-
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 4.125
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, depth average
-
-  subsection Depth average
-    set Number of zones = 10
-  end
-end
diff --git a/tests/adiabatic_initial_conditions_points.prm.bak b/tests/adiabatic_initial_conditions_points.prm.bak
deleted file mode 100644
index 71d48862b10..00000000000
--- a/tests/adiabatic_initial_conditions_points.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-# Here we verify that the adiabatic conditions plugin can use
-# a variable number of points. We only use 5 points, so that the
-# profile should have distinct kinks.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature = 1200
-
-############ These parameters are of interest for this test: #########
-
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 3000.0
-    set Outer temperature = 300.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 0
-    set Age bottom boundary layer = 0
-    set Subadiabaticity = 0
-  end
-end
-
-subsection Adiabatic conditions model
-  set Model name = compute profile
-
-  subsection Compute profile
-    set Number of points = 5
-  end
-end
-
-########################################################################
-
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Thermal conductivity          = 4.125
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-    set Reference compressibility     = 1e-11
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = adiabat
-  end
-
-  subsection Depth average
-    set Number of zones = 10
-  end
-end
diff --git a/tests/adiabatic_initial_conditions_subadiabaticity.prm.bak b/tests/adiabatic_initial_conditions_subadiabaticity.prm.bak
deleted file mode 100644
index 8569e698aeb..00000000000
--- a/tests/adiabatic_initial_conditions_subadiabaticity.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# In ASPECT 0.2, we managed to get the adiabatic initial conditions
-# wrong. This was fixed in r1678 by Juliane Dannberg
-#
-# The computation was only wrong if one specified boundary layers. Compared
-# to adiabatic_initial_conditions.prm, we here also specify a subadiabaticity
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature = 1200
-
-############ These parameters are of interest for this test: #########
-
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 3000.0
-    set Outer temperature = 300.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 3.16e15
-    set Age bottom boundary layer = 3.16e15
-    set Subadiabaticity = 300
-  end
-end
-
-########################################################################
-
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 4.125
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, depth average
-
-  subsection Depth average
-    set Number of zones = 10
-  end
-end
diff --git a/tests/adiabatic_initial_conditions_without_boundary.prm.bak b/tests/adiabatic_initial_conditions_without_boundary.prm.bak
deleted file mode 100644
index 9001c1871f2..00000000000
--- a/tests/adiabatic_initial_conditions_without_boundary.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# In ASPECT 1.2, we managed to get the adiabatic initial conditions
-# wrong in the rare case of no prescribed boundary temperature and a
-# prescribed bottom thermal boundary layer age. This case makes no sense,
-# but it might occur by accident. The expected result is no boundary layer,
-# however previously we computed a boundary layer against the adiabatic
-# surface temperature. This test verifies the solution of this bug.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-
-############ These parameters are of interest for this test: #########
-
-set Adiabatic surface temperature = 1200
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 1e8
-    set Age bottom boundary layer = 1e8
-  end
-end
-
-########################################################################
-
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
diff --git a/tests/adiabatic_plate_cooling.prm.bak b/tests/adiabatic_plate_cooling.prm.bak
deleted file mode 100644
index 546c10fdc1c..00000000000
--- a/tests/adiabatic_plate_cooling.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# This test is used to check if the plate cooling model with seafloor ages
-# defined in an ASCII data file is calculated correctly.
-
-set Dimension                              = 2
-set Output directory                       = adiabatic_plate_cooling
-set Use years in output instead of seconds = true
-set End time                               = 1.
-set Pressure normalization                 = no
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1623   # Set to the mantle temperature
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 150e3
-    set Y extent = 150e3
-    set X repetitions = 10
-    set Y repetitions = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Top boundary layer age model = ascii data
-    set Cooling model = plate cooling
-    set Lithosphere thickness = 125e3
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators = top, bottom
-
-  subsection Box
-    set Bottom temperature = 1623
-    set Top temperature = 293
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density        = 3300
-    set Reference specific heat  = 1000
-    set Reference temperature    = 1600
-    set Thermal conductivity     = 4.7
-    set Thermal expansion coefficient = 0.
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature
-  end
-end
diff --git a/tests/adiabatic_plate_function.prm.bak b/tests/adiabatic_plate_function.prm.bak
deleted file mode 100644
index a2611a29b43..00000000000
--- a/tests/adiabatic_plate_function.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# This test is used to check if the half-space cooling model with seafloor ages
-# defined in an analytic function is calculated correctly. It is similar to
-# the adiabatic_plate_cooling test.
-
-set Dimension                              = 2
-set Output directory                       = adiabatic_plate_cooling
-set Use years in output instead of seconds = true
-set End time                               = 1.
-set Pressure normalization                 = no
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1623   # Set to the mantle temperature
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 150e3
-    set Y extent = 150e3
-    set X repetitions = 20
-    set Y repetitions = 20
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Top boundary layer age model = function
-    set Cooling model = half-space cooling
-
-    subsection Age function
-      set Function constants = cm=0.01, year=1
-      set Function expression = x / (1 * cm / year)
-    end
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators = top, bottom
-
-  subsection Box
-    set Bottom temperature = 1623
-    set Top temperature = 293
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density        = 3300
-    set Reference specific heat  = 1000
-    set Reference temperature    = 1600
-    set Thermal conductivity     = 4.7
-    set Thermal expansion coefficient = 0.
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature
-  end
-end
diff --git a/tests/advect_field_with_melt_velocity.cc.bak b/tests/advect_field_with_melt_velocity.cc.bak
deleted file mode 100644
index 41a9c23ffdf..00000000000
--- a/tests/advect_field_with_melt_velocity.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "rising_melt_blob.cc"
diff --git a/tests/advect_field_with_melt_velocity.prm.bak b/tests/advect_field_with_melt_velocity.prm.bak
deleted file mode 100644
index 58d97f1b99b..00000000000
--- a/tests/advect_field_with_melt_velocity.prm.bak
+++ /dev/null
@@ -1,142 +0,0 @@
-#########################################################
-# This is a test for the advection scheme that transports
-# compositional fields with the melt velocity. The material
-# properties are set in such a way that the melt velocity
-# is 1 m/yr and the solid velocity is 0.
-# There are two compositional fields, one is transported
-# with the solid velocity (the peridotite field), and one is
-# transported with the melt velocity (the melt composition
-# field).
-# While the mass of the peridotite field should be conserved,
-# the mass of the melt_composition field should decrease over
-# time with a rate of 1/yr.
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.1
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 50
-set CFL number                             = 1
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-############### Parameters describing the model
-# Let us here choose again a box domain
-# where we fix the temperature at the bottom and top,
-# allow free slip along the boundaries
-# and include melt migration.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2
-  set List of model names = initial temperature
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = 2
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-
-  #  set Prescribed velocity boundary indicators = 2:function
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
-    set Function expression = 0;0.01
-  end
-end
-
-subsection Melt settings
-  set Include melt transport = true
-end
-
-############### Compositional fields
-# We want to use two compositional fields, the porosity and
-# an additional field, to check if the melting rate functionality
-# has the same effect as the reaction term for the other
-# compositional fields. As the porosity field is advected by
-# a different mechanism, slight differences between the fields
-# are expected.
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = porosity, peridotite, melt_composition
-  set Compositional field methods = field, field, melt field
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
-    set Function expression = 293
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=50000,y0=0.5,c=10000
-    set Function expression = 0.0872158; if(y>y0,1,0); if(y>y0,1,0)
-  end
-end
-
-subsection Material model
-  set Model name = melting rate
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/advect_mesh_vertically.prm.bak b/tests/advect_mesh_vertically.prm.bak
deleted file mode 100644
index 379d775d456..00000000000
--- a/tests/advect_mesh_vertically.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# Test projecting onto gravity direction for free surface computations
-# with a sinking blob.
-
-set Dimension = 2
-set CFL number                             = 0.1
-set End time                               = 1e8
-set Output directory                       = output
-set Pressure normalization                 = no
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = left, right, bottom, top
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities             = 2970., 3800.
-    set Viscosities                     = 1.e20, 1.e24
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = composition, boundary
-  set Time steps between mesh refinement = 5
-  set Refinement criteria merge operation         = plus
-  set Refinement criteria scaling factors         = 2, 1
-
-  subsection Boundary
-    set Boundary refinement indicators = top
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-    set Surface velocity projection = vertical
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 20
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( sqrt( (x-250.e3)^2 + (y-160.e3)^2 ) < 25.e3, 1.0, 0.0)
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 400
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,topography,velocity statistics,
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format = gnuplot
-    set Time between graphical output = 1.e4
-  end
-end
diff --git a/tests/advection_reaction.cc.bak b/tests/advection_reaction.cc.bak
deleted file mode 100644
index 346c5ac73ce..00000000000
--- a/tests/advection_reaction.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/operator_splitting/advection_reaction/advection_reaction.cc"
diff --git a/tests/advection_reaction.prm.bak b/tests/advection_reaction.prm.bak
deleted file mode 100644
index 6a87e4fbeba..00000000000
--- a/tests/advection_reaction.prm.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-#########################################################
-# This is a benchmark case that tests the operator split
-# solver scheme, which can use a different time step to
-# compute reactions between compositional fields than
-# the time step used for advection.
-# In comparison to the example 'exponential_decay', the
-# initial composition depends on x, and there is a constant
-# horizontal velocity. The composition decays over time,
-# following the equations for exponential decay with a decay
-# rate that depends on y.
-
-set Additional shared libraries = ./libadvection_reaction.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-# We use a new solver scheme that enables the operator split.
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Use operator splitting                 = true
-set Maximum time step                      = 1
-
-# As we split the time-stepping of advection and reactions,
-# there are now two different time steps in the model:
-# We control the advection time step using the 'Maximum time step'
-# parameter (for easy comparison with the exponential decay test
-# case), and the reaction time step is controlled internally
-# through the ODE solver scheme. Instead of changing the step
-# for the ODE solver, we can make the solution more accurate by
-# modifying the Reaction solver relative tolerance.
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction solver relative tolerance = 1e-6
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.0
-    set cR = 0.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0
-  set List of model names = ExponentialDecayBoundary
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = 0
-  set List of model names = ExponentialDecayBoundary
-end
-
-# The velocity on all boundaries is prescribed to a constant
-# value, leading to horizontal flow from left to right.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  =
-    set Function expression = 0.01;0.0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-# For this model, we choose a sinusoidal initial temperature
-# and composition, so that we can see how the field changes
-# over time as it is advected and decays over time.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = sin(2*pi*x)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = sin(2*pi*x)
-  end
-end
-
-# We choose material and heating models that let temperature
-# and composition decay over time, and that is implemented in
-# a plugin.
-subsection Heating model
-  set List of model names = exponential decay heating
-
-  subsection Exponential decay heating
-    set Half life = 10
-  end
-end
-
-subsection Material model
-  set Model name = exponential decay
-
-  subsection Exponential decay
-    set Half life = 10
-  end
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1e5
-    set Density differential for compositional field 1 = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization, ExponentialDecayPostprocessor
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/advection_solver_fail.prm.bak b/tests/advection_solver_fail.prm.bak
deleted file mode 100644
index 395d67fc8ae..00000000000
--- a/tests/advection_solver_fail.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-# This is a copy of simple_incompressible.prm that decreases solver
-# tolerance to provoke a crash and check the error message and
-# solver history output.
-
-# EXPECT FAILURE
-
-include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
-
-
-subsection Solver parameters
-  set Temperature solver tolerance = 0
-end
diff --git a/tests/airy_isostasy.prm.bak b/tests/airy_isostasy.prm.bak
deleted file mode 100644
index 378198354a7..00000000000
--- a/tests/airy_isostasy.prm.bak
+++ /dev/null
@@ -1,140 +0,0 @@
-# We setup three columns, of which the middle column has a higher density
-# and viscosity. By choosing a free surface in combination with a
-# prescribed lithostatic pressure calculated in the left column,
-# we see the middle column sink until isostasy is reached (if end time is increased)
-
-set Dimension = 2
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Pressure normalization                 = no
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# A simple one by one box
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# Temperature is zero everywhere
-# In/outflow through the bottom in the vertical direction only
-# The lithostatic pressure is prescribed for the normal traction
-# component of the bottom boundary.
-# We choose to set zero velocity boundary conditions on the
-# vertical boundaries through Prescribed velocity boundary indicators
-# because then we can specify that the mesh along these boundaries
-# is allowed to move according to the free surface displacement
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-# The composition field has a higher density and viscosity
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities                  = 1,1.05
-    set Reference temperature      = 0
-    set Specific heats             = 1.
-    set Thermal conductivities     = 0.
-    set Thermal expansivities      = 0.
-    set Viscosities                = 1,1e4
-    set Viscosity averaging scheme = geometric
-  end
-end
-
-# We refine at the surface along the compositional field
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 5
-  set Strategy                           = minimum refinement function
-  set Refinement fraction                = 0.7
-  set Time steps between mesh refinement       = 3
-  set Minimum refinement level           = 3
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names = x, z
-    set Function expression = if(x>0.2&x<0.8&z>0.9, 7,5)
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = 2 #,3
-  set List of model names = initial composition
-end
-
-# The representative point determines where the pressure
-# profile is calculated, this can be anywhere in the two
-# outer columns
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 2 y: initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Number of integration points = 260
-    set Representative point         = 0.1,1
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2 x: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = 0;0
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = 3: free surface
-  set Additional tangential mesh velocity boundary indicators = 0,1
-
-  # On the vertical boundaries we allow the mesh to move tangentially
-  # We only displace the surface in the vertical direction
-  subsection Free surface
-    set Surface velocity projection                             = vertical
-  end
-end
-
-# One compositional field in the middle of the domain
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z
-    set Function constants = r=0.3333,p=0.6666
-    set Function expression = if(x>=r&x<p,1,0)
-  end
-end
-
-# In the end, the middle column should have sunk by ~0.048
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, topography
-end
diff --git a/tests/airy_isostasy_initial_topo.cc.bak b/tests/airy_isostasy_initial_topo.cc.bak
deleted file mode 100644
index 6576120d3b1..00000000000
--- a/tests/airy_isostasy_initial_topo.cc.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/geometry_model/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    class PointIsInDomain : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        virtual
-        std::pair<std::string,std::string>
-        execute (TableHandler &);
-    };
-  }
-}
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    PointIsInDomain<dim>::execute(TableHandler &)
-    {
-      // The airy isostasy box domain is 1x1 with max 0.05 topography.
-      const Point<dim> point_in_domain(0.1, 0.1);
-      const Point<dim> point_not_in_domain(0.1, 2.0);
-      const Point<dim> point_not_in_domain_2(2.0, 0.01);
-
-      std::ostringstream screen_text;
-      screen_text << std::boolalpha << this->get_geometry_model().point_is_in_domain(point_in_domain) << " ";
-      screen_text << std::boolalpha << this->get_geometry_model().point_is_in_domain(point_not_in_domain) << " ";
-      screen_text << std::boolalpha << this->get_geometry_model().point_is_in_domain(point_not_in_domain_2);
-
-      return std::pair<std::string, std::string> ("Points lie in domain: ",
-                                                  screen_text.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(PointIsInDomain,
-                                  "point is in domain",
-                                  "A postprocessor that tests whether certain points "
-                                  "lie within the domain.")
-  }
-}
diff --git a/tests/airy_isostasy_initial_topo.prm.bak b/tests/airy_isostasy_initial_topo.prm.bak
deleted file mode 100644
index 867ab8cb2e1..00000000000
--- a/tests/airy_isostasy_initial_topo.prm.bak
+++ /dev/null
@@ -1,37 +0,0 @@
-# We setup three columns, of which the middle column has a higher density
-# and viscosity. By choosing a free surface in combination with a
-# prescribed lithostatic pressure,
-# we see the middle column sink until isostasy is reached (if end time is increased)
-# Compared to airy_isostasy.prm, we start off with a nonzero initial topography.
-
-include $ASPECT_SOURCE_DIR/tests/airy_isostasy.prm
-
-set Dimension = 2
-set End time                               = 3.5e-9
-
-subsection Geometry model
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function constants = L=1, R=0.05, C=0.5
-      set Function expression = R * cos(pi*(x-C)/(L))
-      set Maximum topography value = 0.05
-    end
-  end
-end
-
-# The lithostatic pressure at the bottom of the domain
-# is rho * g * h = 1 * 10 * 1 = 10.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 2 y: function
-
-  subsection Function
-    set Function expression = 0;10
-  end
-end
-
-# Also test the point_is_in_domain function of the geometry model.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, topography, point is in domain
-end
diff --git a/tests/airy_isostasy_initial_topo_lithostatic_pressure.prm.bak b/tests/airy_isostasy_initial_topo_lithostatic_pressure.prm.bak
deleted file mode 100644
index 05787fc3a72..00000000000
--- a/tests/airy_isostasy_initial_topo_lithostatic_pressure.prm.bak
+++ /dev/null
@@ -1,41 +0,0 @@
-# We setup three columns, of which the middle column has a higher density
-# and viscosity. By choosing a free surface in combination with a
-# prescribed lithostatic pressure,
-# we see the middle column sink until isostasy is reached (if end time is increased)
-# Compared to airy_isostasy.prm, we start off with a nonzero initial topography.
-# This test in particular tests the point_is_in_domain function of the geometry
-# model. It should take into account the initial topography and find that the
-# Representative point lies within the domain. At x = 0.2, the initial topography
-# is namely 0.02948.
-
-include $ASPECT_SOURCE_DIR/tests/airy_isostasy.prm
-
-set Dimension = 2
-
-# The point_is_in_domain function is only called in
-# timestep 0, so we do not need to run the test further.
-set End time                               = 0
-
-subsection Geometry model
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function constants = L=1, R=0.05, C=0.5
-      set Function expression = R * cos(pi*(x-C)/(L))
-      set Maximum topography value = 0.05
-    end
-  end
-end
-
-# The representative point determines where the pressure
-# profile is calculated. We pick a point in the left
-# column which has some initial topography prescribed.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 2 y: initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Number of integration points = 260
-    set Representative point         = 0.2,1.02
-  end
-end
diff --git a/tests/always_refine.prm.bak b/tests/always_refine.prm.bak
deleted file mode 100644
index eb8443f434f..00000000000
--- a/tests/always_refine.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-#########################################################
-# Refine in every time step and see what happens.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.5
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/tests/analytic_artificial_viscosity_0.prm.bak b/tests/analytic_artificial_viscosity_0.prm.bak
deleted file mode 100644
index b7ecb7c7512..00000000000
--- a/tests/analytic_artificial_viscosity_0.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# This is a test for the entropy viscosity.
-# In particular, it checks that the value for the maximum viscosity is computed
-# as described in the ASPECT publication.
-
-set Adiabatic surface temperature          = 1600
-set Dimension                              = 2
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 2
-end
-
-# The settings below will cause the residual based entropy viscosity to always
-# be higher than the maximum viscosity. Since the minimum of both is chosen as
-# the applied stabilization, the output will be equal to the latter. For a
-# uniform box, and all material parameters and velocity chosen as one, the
-# maximum viscosity should be equal to the cell diameter (i.e. sqrt(1+1)),
-# which was verified for this test.
-subsection Discretization
-  subsection Stabilization parameters
-    set cR  = 1e100
-    set beta  = 1.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function, bottom:function, left:function, right:function
-
-  subsection Function
-    set Function expression = 1.0;0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (x<0.5) ? 0.0 : 1.0
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density = 1.0
-    set Reference specific heat = 1.0
-    set Thermal expansion coefficient = 0.0
-    set Thermal conductivity          = 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, entropy viscosity statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set Interpolate output = true
-    set List of output variables = material properties, thermal conductivity, artificial viscosity
-  end
-end
diff --git a/tests/anisotropic_viscosity.cc.bak b/tests/anisotropic_viscosity.cc.bak
deleted file mode 100644
index b41d1e35892..00000000000
--- a/tests/anisotropic_viscosity.cc.bak
+++ /dev/null
@@ -1,830 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_access.h>
-
-#include <aspect/material_model/simple.h>
-#include <aspect/heating_model/shear_heating.h>
-#include <aspect/heating_model/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator/assemblers/stokes.h>
-#include <aspect/simulator_signals.h>
-
-#include <deal.II/base/symmetric_tensor.h>
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    /**
-      * Additional output fields for anisotropic viscosities to be added to
-      * the MaterialModel::MaterialModelOutputs structure and filled in the
-      * MaterialModel::Interface::evaluate() function.
-      */
-    template <int dim>
-    class AnisotropicViscosity : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        AnisotropicViscosity(const unsigned int n_points);
-
-        virtual std::vector<double> get_nth_output(const unsigned int idx) const;
-
-        /**
-         * Stress-strain "director" tensors at the given positions. This
-         * variable is used to implement anisotropic viscosity.
-         *
-         * @note The strain rate term in equation (1) of the manual will be
-         * multiplied by this tensor *and* the viscosity scalar ($\eta$), as
-         * described in the manual section titled "Constitutive laws". This
-         * variable is assigned the rank-four identity tensor by default.
-         * This leaves the isotropic constitutive law unchanged if the material
-         * model does not explicitly assign a value.
-         */
-        std::vector<SymmetricTensor<4,dim>> stress_strain_directors;
-    };
-
-    template <int dim>
-    AnisotropicViscosity<dim>::AnisotropicViscosity (const unsigned int n_points)
-      :
-      NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1,"anisotropic_viscosity")),
-      stress_strain_directors(n_points, dealii::identity_tensor<dim> ())
-    {}
-
-
-
-    template <int dim>
-    std::vector<double>
-    AnisotropicViscosity<dim>::get_nth_output(const unsigned int /*idx*/) const
-    {
-      return std::vector<double>();
-    }
-  }
-
-  namespace Assemblers
-  {
-    /**
-     * A class containing the functions to assemble the Stokes preconditioner.
-     */
-    template <int dim>
-    class StokesPreconditionerAnisotropicViscosity : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        virtual
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const;
-
-        /**
-         * Create AnisotropicViscosities.
-         */
-        virtual void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const;
-    };
-
-    /**
-     * A class containing the functions to assemble the compressible adjustment
-     * to the Stokes preconditioner.
-     */
-    template <int dim>
-    class StokesCompressiblePreconditionerAnisotropicViscosity : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        virtual
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const;
-    };
-
-    /**
-     * This class assembles the terms for the matrix and right-hand-side of the incompressible
-     * Stokes equation for the current cell.
-     */
-    template <int dim>
-    class StokesIncompressibleTermsAnisotropicViscosity : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        virtual
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const;
-
-        /**
-         * Create AdditionalMaterialOutputsStokesRHS if we need to do so.
-         */
-        virtual void create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const;
-    };
-
-    /**
-     * This class assembles the term that arises in the viscosity term of Stokes matrix for
-     * compressible models, because the divergence of the velocity is not longer zero.
-     */
-    template <int dim>
-    class StokesCompressibleStrainRateViscosityTermAnisotropicViscosity : public Assemblers::Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        virtual
-        void
-        execute(internal::Assembly::Scratch::ScratchBase<dim>   &scratch,
-                internal::Assembly::CopyData::CopyDataBase<dim> &data) const;
-    };
-
-    template <int dim>
-    void
-    StokesPreconditionerAnisotropicViscosity<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
-
-      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      // First loop over all dofs and find those that are in the Stokes system
-      // save the component (pressure and dim velocities) each belongs to.
-      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-        {
-          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-            {
-              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
-              ++i_stokes;
-            }
-          ++i;
-        }
-
-      // Loop over all quadrature points and assemble their contributions to
-      // the preconditioner matrix
-      for (unsigned int q = 0; q < n_q_points; ++q)
-        {
-          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.grads_phi_u[i_stokes] =
-                    scratch.finite_element_values[introspection.extractors
-                                                  .velocities].symmetric_gradient(i, q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection
-                                                                          .extractors.pressure].value(i, q);
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const double eta = scratch.material_model_outputs.viscosities[q];
-          const double one_over_eta = 1. / eta;
-
-          const bool use_tensor = (anisotropic_viscosity != nullptr);
-
-          const SymmetricTensor<4, dim> &stress_strain_director = (use_tensor)
-                                                                  ?
-                                                                  anisotropic_viscosity->stress_strain_directors[q]
-                                                                  :
-                                                                  dealii::identity_tensor<dim>();
-
-
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-            for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
-              if (scratch.dof_component_indices[i] ==
-                  scratch.dof_component_indices[j])
-                data.local_matrix(i, j) += ((
-                                              use_tensor ?
-                                              2.0 * eta * (scratch.grads_phi_u[i]
-                                                           * stress_strain_director
-                                                           * scratch.grads_phi_u[j]) :
-                                              2.0 * eta * (scratch.grads_phi_u[i]
-                                                           * scratch.grads_phi_u[j]))
-                                            + one_over_eta * pressure_scaling
-                                            * pressure_scaling
-                                            * (scratch.phi_p[i]
-                                               * scratch.phi_p[j]))
-                                           * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesPreconditionerAnisotropicViscosity<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      const unsigned int n_points = outputs.viscosities.size();
-
-      if (outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesCompressiblePreconditionerAnisotropicViscosity<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesPreconditioner<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesPreconditioner<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesPreconditioner<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesPreconditioner<dim>&> (data_base);
-
-      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points           = scratch.finite_element_values.n_quadrature_points;
-
-      // First loop over all dofs and find those that are in the Stokes system
-      // save the component (pressure and dim velocities) each belongs to.
-      for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-        {
-          if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-            {
-              scratch.dof_component_indices[i_stokes] = fe.system_to_component_index(i).first;
-              ++i_stokes;
-            }
-          ++i;
-        }
-
-      // Loop over all quadrature points and assemble their contributions to
-      // the preconditioner matrix
-      for (unsigned int q = 0; q < n_q_points; ++q)
-        {
-          for (unsigned int i = 0, i_stokes = 0; i_stokes < stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0;
-
-          const bool use_tensor = (anisotropic_viscosity != nullptr);
-
-          const SymmetricTensor<4, dim> &stress_strain_director = (use_tensor)
-                                                                  ?
-                                                                  anisotropic_viscosity->stress_strain_directors[q]
-                                                                  :
-                                                                  dealii::identity_tensor<dim>();
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i = 0; i < stokes_dofs_per_cell; ++i)
-            for (unsigned int j = 0; j < stokes_dofs_per_cell; ++j)
-              if (scratch.dof_component_indices[i] ==
-                  scratch.dof_component_indices[j])
-                data.local_matrix(i, j) += (- (use_tensor ?
-                                               eta_two_thirds * (scratch.div_phi_u[i] * trace(stress_strain_director * scratch.grads_phi_u[j]))
-                                               :
-                                               eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
-                                              ))
-                                           * JxW;
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesIncompressibleTermsAnisotropicViscosity<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-      const double pressure_scaling = this->get_pressure_scaling();
-
-      const MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
-      *force = scratch.material_model_outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
-                  scratch.phi_p[i_stokes] = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-                  if (scratch.rebuild_stokes_matrix)
-                    {
-                      scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                      scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-                    }
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-
-          // Viscosity scalar
-          const double eta = (scratch.rebuild_stokes_matrix
-                              ?
-                              scratch.material_model_outputs.viscosities[q]
-                              :
-                              numbers::signaling_nan<double>());
-
-          const bool use_tensor = (anisotropic_viscosity != nullptr);
-
-          const SymmetricTensor<4, dim> &stress_strain_director = (use_tensor)
-                                                                  ?
-                                                                  anisotropic_viscosity->stress_strain_directors[q]
-                                                                  :
-                                                                  dealii::identity_tensor<dim>();
-
-          const Tensor<1,dim>
-          gravity = this->get_gravity_model().gravity_vector (scratch.finite_element_values.quadrature_point(q));
-
-          const double density = scratch.material_model_outputs.densities[q];
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            {
-              data.local_rhs(i) += (density * gravity * scratch.phi_u[i])
-                                   * JxW;
-
-              if (force != nullptr)
-                data.local_rhs(i) += (force->rhs_u[q] * scratch.phi_u[i]
-                                      + pressure_scaling * force->rhs_p[q] * scratch.phi_p[i])
-                                     * JxW;
-
-              if (scratch.rebuild_stokes_matrix)
-                for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-                  {
-                    data.local_matrix(i,j) += ( (use_tensor ?
-                                                 eta * 2.0 * (scratch.grads_phi_u[i] * stress_strain_director * scratch.grads_phi_u[j])
-                                                 :
-                                                 eta * 2.0 * (scratch.grads_phi_u[i] * scratch.grads_phi_u[j]))
-                                                // assemble \nabla p as -(p, div v):
-                                                - (pressure_scaling *
-                                                   scratch.div_phi_u[i] * scratch.phi_p[j])
-                                                // assemble the term -div(u) as -(div u, q).
-                                                // Note the negative sign to make this
-                                                // operator adjoint to the grad p term:
-                                                - (pressure_scaling *
-                                                   scratch.phi_p[i] * scratch.div_phi_u[j]))
-                                              * JxW;
-                  }
-            }
-        }
-    }
-
-
-
-    template <int dim>
-    void
-    StokesIncompressibleTermsAnisotropicViscosity<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &outputs) const
-    {
-      const unsigned int n_points = outputs.viscosities.size();
-
-      if (outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
-        }
-
-      if (this->get_parameters().enable_additional_stokes_rhs
-          && outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>() == nullptr)
-        {
-          outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>> (n_points));
-        }
-      Assert(!this->get_parameters().enable_additional_stokes_rhs
-             ||
-             outputs.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>()->rhs_u.size()
-             == n_points, ExcInternalError());
-    }
-
-
-
-    template <int dim>
-    void
-    StokesCompressibleStrainRateViscosityTermAnisotropicViscosity<dim>::
-    execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-             internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-    {
-      internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-      internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-      if (!scratch.rebuild_stokes_matrix)
-        return;
-
-      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        scratch.material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      const Introspection<dim> &introspection = this->introspection();
-      const FiniteElement<dim> &fe = this->get_fe();
-      const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-      const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-
-      for (unsigned int q=0; q<n_q_points; ++q)
-        {
-          for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-            {
-              if (introspection.is_stokes_component(fe.system_to_component_index(i).first))
-                {
-                  scratch.grads_phi_u[i_stokes] = scratch.finite_element_values[introspection.extractors.velocities].symmetric_gradient(i,q);
-                  scratch.div_phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].divergence (i, q);
-
-                  ++i_stokes;
-                }
-              ++i;
-            }
-
-          // Viscosity scalar
-          const double eta_two_thirds = scratch.material_model_outputs.viscosities[q] * 2.0 / 3.0;
-
-          const bool use_tensor = (anisotropic_viscosity != nullptr);
-
-          const SymmetricTensor<4, dim> &stress_strain_director = (use_tensor)
-                                                                  ?
-                                                                  anisotropic_viscosity->stress_strain_directors[q]
-                                                                  :
-                                                                  dealii::identity_tensor<dim>();
-
-          const double JxW = scratch.finite_element_values.JxW(q);
-
-          for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-            for (unsigned int j=0; j<stokes_dofs_per_cell; ++j)
-              {
-                data.local_matrix(i,j) += (- (use_tensor ?
-                                              eta_two_thirds * (scratch.div_phi_u[i] * trace(stress_strain_director * scratch.grads_phi_u[j]))
-                                              :
-                                              eta_two_thirds * (scratch.div_phi_u[i] * scratch.div_phi_u[j])
-                                             ))
-                                          * JxW;
-              }
-        }
-    }
-  }
-
-
-  namespace HeatingModel
-  {
-    template <int dim>
-    class ShearHeatingAnisotropicViscosity : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Compute the heating model outputs for this class.
-         */
-        virtual
-        void
-        evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                  const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-                  HeatingModel::HeatingModelOutputs &heating_model_outputs) const;
-
-        /**
-         * Allow the heating model to attach additional material model outputs.
-         */
-        virtual
-        void
-        create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const;
-    };
-
-    template <int dim>
-    void
-    ShearHeatingAnisotropicViscosity<dim>::
-    evaluate (const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-              const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-              HeatingModel::HeatingModelOutputs &heating_model_outputs) const
-    {
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.position.size(),
-             ExcMessage ("Heating outputs need to have the same number of entries as the material model inputs."));
-
-      Assert(heating_model_outputs.heating_source_terms.size() == material_model_inputs.strain_rate.size(),
-             ExcMessage ("The shear heating plugin needs the strain rate!"));
-
-      // Some material models provide dislocation viscosities and boundary area work fractions
-      // as additional material outputs. If they are attached, use them.
-      const ShearHeatingOutputs<dim> *shear_heating_out =
-        material_model_outputs.template get_additional_output<ShearHeatingOutputs<dim>>();
-
-      const MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      for (unsigned int q=0; q<heating_model_outputs.heating_source_terms.size(); ++q)
-        {
-          // If there is an anisotropic viscosity, use it to compute the correct stress
-          const SymmetricTensor<2,dim> &directed_strain_rate = ((anisotropic_viscosity != nullptr)
-                                                                ?
-                                                                anisotropic_viscosity->stress_strain_directors[q]
-                                                                * material_model_inputs.strain_rate[q]
-                                                                :
-                                                                material_model_inputs.strain_rate[q]);
-
-          const SymmetricTensor<2,dim> stress =
-            2 * material_model_outputs.viscosities[q] *
-            (this->get_material_model().is_compressible()
-             ?
-             directed_strain_rate - 1./3. * trace(directed_strain_rate) * unit_symmetric_tensor<dim>()
-             :
-             directed_strain_rate);
-
-          const SymmetricTensor<2,dim> deviatoric_strain_rate =
-            (this->get_material_model().is_compressible()
-             ?
-             material_model_inputs.strain_rate[q]
-             - 1./3. * trace(material_model_inputs.strain_rate[q]) * unit_symmetric_tensor<dim>()
-             :
-             material_model_inputs.strain_rate[q]);
-
-          heating_model_outputs.heating_source_terms[q] = stress * deviatoric_strain_rate;
-
-          // If shear heating work fractions are provided, reduce the
-          // overall heating by this amount (which is assumed to be converted into other forms of energy)
-          if (shear_heating_out != nullptr)
-            heating_model_outputs.heating_source_terms[q] *= shear_heating_out->shear_heating_work_fractions[q];
-
-          heating_model_outputs.lhs_latent_heat_terms[q] = 0.0;
-        }
-    }
-
-    template <int dim>
-    void
-    ShearHeatingAnisotropicViscosity<dim>::
-    create_additional_material_model_outputs(MaterialModel::MaterialModelOutputs<dim> &material_model_outputs) const
-    {
-      const unsigned int n_points = material_model_outputs.viscosities.size();
-
-      if (material_model_outputs.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>() == nullptr)
-        {
-          material_model_outputs.additional_outputs.push_back(
-            std::make_unique<MaterialModel::AnisotropicViscosity<dim>> (n_points));
-        }
-
-      this->get_material_model().create_additional_named_outputs(material_model_outputs);
-    }
-  }
-
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class Anisotropic : public MaterialModel::Simple<dim>
-    {
-      public:
-        virtual void initialize();
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-        static void declare_parameters(ParameterHandler &prm);
-        virtual void parse_parameters(ParameterHandler &prm);
-
-        /**
-          * Return true if the compressibility() function returns something that
-          * is not zero.
-          */
-        virtual bool
-        is_compressible () const;
-
-      private:
-        void set_assemblers(const SimulatorAccess<dim> &,
-                            Assemblers::Manager<dim> &assemblers) const;
-
-        // Constitutive tensor
-        SymmetricTensor<4,dim> C;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    template <int dim>
-    void
-    Anisotropic<dim>::set_assemblers(const SimulatorAccess<dim> &,
-                                     Assemblers::Manager<dim> &assemblers) const
-    {
-      for (unsigned int i=0; i<assemblers.stokes_preconditioner.size(); ++i)
-        {
-          if (dynamic_cast<Assemblers::StokesPreconditioner<dim> *>(assemblers.stokes_preconditioner[i].get()) != nullptr)
-            assemblers.stokes_preconditioner[i] = std::make_unique<Assemblers::StokesPreconditionerAnisotropicViscosity<dim>> ();
-          if (dynamic_cast<Assemblers::StokesCompressiblePreconditioner<dim> *>(assemblers.stokes_preconditioner[i].get()) != nullptr)
-            assemblers.stokes_preconditioner[i] = std::make_unique<Assemblers::StokesCompressiblePreconditionerAnisotropicViscosity<dim>> ();
-        }
-
-      for (unsigned int i=0; i<assemblers.stokes_system.size(); ++i)
-        {
-          if (dynamic_cast<Assemblers::StokesIncompressibleTerms<dim> *>(assemblers.stokes_system[i].get()) != nullptr)
-            assemblers.stokes_system[i] = std::make_unique<Assemblers::StokesIncompressibleTermsAnisotropicViscosity<dim>> ();
-          if (dynamic_cast<Assemblers::StokesCompressibleStrainRateViscosityTerm<dim> *>(assemblers.stokes_system[i].get()) != nullptr)
-            assemblers.stokes_system[i] = std::make_unique<Assemblers::StokesCompressibleStrainRateViscosityTermAnisotropicViscosity<dim>> ();
-        }
-    }
-
-    template <int dim>
-    void
-    Anisotropic<dim>::
-    initialize()
-    {
-      this->get_signals().set_assemblers.connect (std::bind(&Anisotropic<dim>::set_assemblers,
-                                                            std::cref(*this),
-                                                            std::placeholders::_1,
-                                                            std::placeholders::_2));
-    }
-
-    template <int dim>
-    void
-    Anisotropic<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      MaterialModel::AnisotropicViscosity<dim> *anisotropic_viscosity =
-        out.template get_additional_output<MaterialModel::AnisotropicViscosity<dim>>();
-
-      Simple<dim>::evaluate(in, out);
-      Point<dim> center;
-      center[0] = 0.5;
-      center[1] = 0.5;
-      if (dim == 3)
-        center[2] = 0.5;
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double pressure = in.pressure[i];
-          out.densities[i] = 1.0 + pressure;
-          out.compressibilities[i] = 1.0 / (1. + pressure);
-          if ((in.position[i]-center).norm() < 0.25)
-            {
-              if (anisotropic_viscosity != nullptr)
-                anisotropic_viscosity->stress_strain_directors[i] = C;
-            }
-        }
-    }
-
-    template <int dim>
-    bool
-    Anisotropic<dim>::
-    is_compressible () const
-    {
-      return true;
-    }
-
-    template <int dim>
-    void
-    Anisotropic<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      Simple<dim>::declare_parameters (prm);
-      prm.enter_subsection ("Material model");
-      {
-        prm.enter_subsection ("Anisotropic");
-        {
-          if (dim == 2)
-            prm.declare_entry ("Viscosity tensor",
-                               "1, 0, 0,"
-                               "0, 1, 0,"
-                               "0, 0,.5",
-                               Patterns::List(Patterns::Double()),
-                               "Viscosity-scaling tensor in Voigt notation.");
-          else
-            prm.declare_entry ("Viscosity tensor",
-                               "1, 0, 0, 0, 0, 0,"
-                               "0, 1, 0, 0, 0, 0,"
-                               "0, 0, 1, 0, 0, 0,"
-                               "0, 0, 0,.5, 0, 0,"
-                               "0, 0, 0, 0,.5, 0,"
-                               "0, 0, 0, 0, 0,.5",
-                               Patterns::List(Patterns::Double()),
-                               "Viscosity-scaling tensor in Voigt notation.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    Anisotropic<dim>::
-    parse_parameters (ParameterHandler &prm)
-    {
-      Simple<dim>::parse_parameters (prm);
-      prm.enter_subsection ("Material model");
-      {
-        prm.enter_subsection ("Anisotropic");
-        {
-          const int size_voigt = (dim == 3 ? 6 : 3);
-          const std::vector<double> tmp_tensor =
-            Utilities::string_to_double(Utilities::split_string_list(prm.get ("Viscosity tensor")));
-          Assert(tmp_tensor.size() == size_voigt*size_voigt,
-                 ExcMessage("Constitutive voigt matrix must have 9 components in 2D, or 36 components in 3d"));
-
-          std::vector<std::vector<double>> voigt_visc_tensor (size_voigt);
-          for (unsigned int i=0; i<size_voigt; ++i)
-            {
-              voigt_visc_tensor[i].resize(size_voigt);
-              for (unsigned int j=0; j<size_voigt; ++j)
-                voigt_visc_tensor[i][j] = tmp_tensor[i*size_voigt+j];
-            }
-
-          // Voigt indices (For mapping back to real tensor)
-          const unsigned int vi3d0[] = {0, 1, 2, 1, 0, 0};
-          const unsigned int vi3d1[] = {0, 1, 2, 2, 2, 1};
-          const unsigned int vi2d0[] = {0, 1, 0};
-          const unsigned int vi2d1[] = {0, 1, 1};
-
-          // Fill the constitutive tensor with values from the Voigt tensor
-          for (unsigned int i=0; i<size_voigt; ++i)
-            for (unsigned int j=0; j<size_voigt; ++j)
-              if (dim == 2)
-                C[vi2d0[i]][vi2d1[i]][vi2d0[j]][vi2d1[j]] = voigt_visc_tensor[i][j];
-              else
-                C[vi3d0[i]][vi3d1[i]][vi3d0[j]][vi3d1[j]] = voigt_visc_tensor[i][j];
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Assemblers
-  {
-#define INSTANTIATE(dim) \
-  template class StokesPreconditioner<dim>; \
-  template class StokesCompressiblePreconditioner<dim>; \
-  template class StokesIncompressibleTerms<dim>; \
-  template class StokesCompressibleStrainRateViscosityTerm<dim>; \
-  template class StokesReferenceDensityCompressibilityTerm<dim>; \
-  template class StokesImplicitReferenceDensityCompressibilityTerm<dim>; \
-  template class StokesIsentropicCompressionTerm<dim>; \
-  template class StokesHydrostaticCompressionTerm<dim>; \
-  template class StokesPressureRHSCompatibilityModification<dim>; \
-  template class StokesBoundaryTraction<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-  }
-
-  namespace HeatingModel
-  {
-    ASPECT_REGISTER_HEATING_MODEL(ShearHeatingAnisotropicViscosity,
-                                  "anisotropic shear heating",
-                                  "Implementation of a standard model for shear heating. "
-                                  "Adds the term: "
-                                  "$  2 \\eta \\left( \\varepsilon - \\frac{1}{3} \\text{tr} "
-                                  "\\varepsilon \\mathbf 1 \\right) : \\left( \\varepsilon - \\frac{1}{3} "
-                                  "\\text{tr} \\varepsilon \\mathbf 1 \\right)$ to the "
-                                  "right-hand side of the temperature equation.")
-  }
-
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Anisotropic,
-                                   "anisotropic",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but has a non-zero compressibility "
-                                   "and always has a blob of anisotropic material in "
-                                   "the center.")
-  }
-}
diff --git a/tests/anisotropic_viscosity.prm.bak b/tests/anisotropic_viscosity.prm.bak
deleted file mode 100644
index 83e848af2b4..00000000000
--- a/tests/anisotropic_viscosity.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# This tests an implementation of anisotropic viscosity terms in the Stokes
-# equation. In this test we create new assembler
-# classes in anisotropic_viscosity.cc that extend the standard assemblers
-# with a fourth order viscosity tensor. The chosen material model 'anisotropic'
-# then replaces the standard assemblers with the custom ones during the call
-# to the set_assemblers signal, and during every call to evaluate()
-# fills the AdditionalMaterialOutputs object of type AnisotropicViscosity with
-# the chosen viscosity tensor that is selected in this input file.
-# This way the solved equations are changed without modifying the main code
-# base.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = anisotropic
-
-  subsection Anisotropic
-    # n = (1,1); eta_s/eta_n = 0.001
-    set Viscosity tensor = 0.501, 0.499, 0.0, \
-                           0.499, 0.501, 0.0, \
-                           0.0,   0.0,   0.5
-  end
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Heating model
-  set List of model names = anisotropic shear heating
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 1;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = heating statistics, velocity statistics
-end
diff --git a/tests/annulus.cc.bak b/tests/annulus.cc.bak
deleted file mode 100644
index 061436b9fcc..00000000000
--- a/tests/annulus.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/annulus/plugin/annulus.cc"
diff --git a/tests/annulus.prm.bak b/tests/annulus.prm.bak
deleted file mode 100644
index 10d628a02d9..00000000000
--- a/tests/annulus.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-# A test for the instantaneous 2D annulus benchmark.
-
-include $ASPECT_SOURCE_DIR/benchmarks/annulus/instantaneous/annulus.prm
-
-set Additional shared libraries            = ./libannulus.so
-set Dimension                              = 2
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-end
diff --git a/tests/annulus_transient.cc.bak b/tests/annulus_transient.cc.bak
deleted file mode 100644
index 061436b9fcc..00000000000
--- a/tests/annulus_transient.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/annulus/plugin/annulus.cc"
diff --git a/tests/annulus_transient.prm.bak b/tests/annulus_transient.prm.bak
deleted file mode 100644
index 9fd7494a90a..00000000000
--- a/tests/annulus_transient.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# A test for the transient 2D annulus benchmark.
-# We would like to include the actual benchmark parameter file,
-# but it contains an $ASPECT_SOURCE_DIR statement that cannot
-# be expanded when included from another file. Therefore this is
-# a slightly modified copy of
-# benchmarks/annulus/transient/transient_annulus.prm.
-
-# The 2D Stokes in an annulus benchmark, for which an
-# analytical solution is available. This is the rotating
-# version of the benchmark described in Gassmoeller et al. 2023.
-#
-# See the doc/ directory or manual for more information.
-
-# Most parameters are identical to the instantaneous version
-# of the benchmark. Refer to that parameter file for most settings.
-include $ASPECT_SOURCE_DIR/benchmarks/annulus/instantaneous/annulus.prm
-
-
-# Only list parameters that are specific for the transient benchmark
-set Additional shared libraries            = ../plugin/libannulus.so
-set Dimension                              = 2
-
-# for benchmark: t = log(1 + 4 pi)
-set End time                                = 0.05
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = density_field
-end
-
-subsection Initial composition model
-  set List of model names = initial density
-end
-
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-end
-
-subsection Annulus benchmark
-  set Use analytical density  = false
-  set Use transient solution  = true
-  set k                       = 4
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, AnnulusPostprocessor, rotation statistics
-
-  subsection Dynamic topography
-    set Density above = 0
-    set Density below = 0
-  end
-
-  subsection Visualization
-    set List of output variables = density, gravity, AnnulusVisualizationPostprocessor
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 2.6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 200
-    set Stokes solver type = block GMG
-    set Krylov method for cheap solver steps = IDR(s)
-    set IDR(s) parameter = 4
-  end
-end
-
-subsection Particles
-  set Integration scheme = rk2
-  set Interpolation scheme = bilinear least squares
-  set List of particle properties = particle density
-  set Update ghost particles = true
-  set Particle generator name = random uniform
-  set Load balancing strategy = add particles
-  set Minimum particles per cell = 12
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 49152
-    end
-  end
-end
diff --git a/tests/artificial_postprocess.cc.bak b/tests/artificial_postprocess.cc.bak
deleted file mode 100644
index 39c36b68121..00000000000
--- a/tests/artificial_postprocess.cc.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim>
-  class EVPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Generate graphical output from the current solution.
-       */
-      virtual
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics);
-  };
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  EVPostprocessor<dim>::execute (TableHandler &statistics)
-  {
-    std::ostringstream os;
-    Vector<float> ev(this->get_triangulation().n_active_cells());
-    this->get_artificial_viscosity(ev);
-    std::cout << "EV temperature: " << std::endl;
-    ev.print(std::cout);
-    os << ev.l2_norm() << ' ';
-
-    for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-      {
-        ev = 0.0;
-        this->get_artificial_viscosity_composition(ev, c);
-        std::cout << "EV composition " << c << ": " << std::endl;
-        ev.print(std::cout, 10);
-        os << ev.l2_norm() << ' ';
-      }
-    return std::make_pair("EV norms:", os.str());
-  }
-
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_POSTPROCESSOR(EVPostprocessor,
-                                "EVPostprocessor",
-                                "")
-}
diff --git a/tests/artificial_postprocess.prm.bak b/tests/artificial_postprocess.prm.bak
deleted file mode 100644
index ce9334bb753..00000000000
--- a/tests/artificial_postprocess.prm.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-# check SimulatorAccess::get_artificial_viscosity_composition
-# this test crashes on mainline with:
-# An error occurred in line <2922> of file </scratch/deal-git/source/fe/fe_system.cc> in function
-#     const dealii::FiniteElement<dim, spacedim>& dealii::FESystem<dim, spacedim>::base_element(unsigned int) const [with int dim = 2; int spacedim = 2]
-# The violated condition was:
-#     index < base_elements.size()
-# The name and call sequence of the exception was:
-#     ExcIndexRange(index, 0, base_elements.size())
-# Additional Information:
-# Index 4 is not in [0,4[
-#
-#
-# test modified from composition_names.prm
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 1e11
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = comp1, comp2
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;if (x<250000, 100, 50)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient                  = 1e-5
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, EVPostprocessor
-end
diff --git a/tests/artificial_viscosity.prm.bak b/tests/artificial_viscosity.prm.bak
deleted file mode 100644
index b25810caef5..00000000000
--- a/tests/artificial_viscosity.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# This is a test for the artificial viscosity.
-# In particular, it checks that the results for
-# temperature and compositional fields are the same.
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 0.1
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Dimension                              = 2
-set End time                               = 0.005
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.078
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# we apply simple shear here, so that the top and bottom boundaries
-# move with the same speed u0, but in opposite directions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-
-  subsection Function
-    set Function constants = u0=0.01,ymid=0.5
-    set Function expression = 1.0;0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set X periodic = true
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=64000
-    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=64000
-    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Thermal conductivity          = 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = artificial viscosity, artificial viscosity composition
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0.004
-
-    subsection Artificial viscosity composition
-      set Name of compositional field = porosity
-    end
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-8
-  set Composition solver tolerance = 1e-8
-
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/artificial_viscosity_dirichlet_boundaries.prm.bak b/tests/artificial_viscosity_dirichlet_boundaries.prm.bak
deleted file mode 100644
index 09fa24626c4..00000000000
--- a/tests/artificial_viscosity_dirichlet_boundaries.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# This is a test for the artificial viscosity.
-# In particular, it checks that the entropy viscosity
-# for the composition at dirichlet boundaries can be set
-# to 0 if requested.
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 0.1
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Dimension                              = 2
-set End time                               = 0.01
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set List of compositional fields with disabled boundary entropy viscosity = porosity
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = initial temperature
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = top, bottom
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-
-  subsection Function
-    set Function constants = u0=0.01,ymid=0.5
-    set Function expression = 1.0;0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set X periodic = true
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=64000
-    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=64000
-    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Thermal conductivity          = 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 3
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, visualization, entropy viscosity statistics
-
-  subsection Visualization
-    set Interpolate output            = false
-    set List of output variables      = artificial viscosity, artificial viscosity composition
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-
-    subsection Artificial viscosity composition
-      set Name of compositional field = porosity
-    end
-  end
-end
diff --git a/tests/artificial_viscosity_list.prm.bak b/tests/artificial_viscosity_list.prm.bak
deleted file mode 100644
index f85b5b0a842..00000000000
--- a/tests/artificial_viscosity_list.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# A simple setup for convection in a 3d shell. See the
-# manual for more information.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1973
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.473e3
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = (x>0) ? 1.0 : 0.0
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta = 1e-5,0.078
-    set cR = 1e-5,0.11
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = artificial viscosity, artificial viscosity composition
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-
-    subsection Artificial viscosity composition
-      set Name of compositional field = C_1
-    end
-  end
-end
diff --git a/tests/ascii_boundary_member.cc.bak b/tests/ascii_boundary_member.cc.bak
deleted file mode 100644
index 16b580f44c3..00000000000
--- a/tests/ascii_boundary_member.cc.bak
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-#include <aspect/global.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-
-namespace aspect
-{
-  using namespace dealii;
-  /**
-   * A boundary velocity plugin that uses an AsciiDataBoundary object as member
-   */
-  template <int dim>
-  class AsciiBoundaryMember : public BoundaryVelocity::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Empty Constructor.
-       */
-      AsciiBoundaryMember ();
-
-      /**
-       * Initialization function. This function is called once at the
-       * beginning of the program. Checks preconditions.
-       */
-      void
-      initialize ();
-
-      /**
-       * A function that is called at the beginning of each time step. For
-       * the current plugin, this function loads the next data files if
-       * necessary and outputs a warning if the end of the set of data files
-       * is reached.
-       */
-      void
-      update ();
-
-      /**
-       * Return the boundary velocity as a function of position. For the
-       * current class, this function returns value from the text files.
-       */
-      Tensor<1,dim>
-      boundary_velocity (const types::boundary_id boundary_indicator,
-                         const Point<dim> &position) const;
-
-      /**
-       * Declare the parameters this class takes through input files.
-       */
-      static
-      void
-      declare_parameters (ParameterHandler &prm);
-
-      /**
-       * Read the parameters this class declares from the parameter file.
-       */
-      void
-      parse_parameters (ParameterHandler &prm);
-
-      std::unique_ptr<Utilities::AsciiDataBoundary<dim>> member;
-
-      std::set<types::boundary_id> boundary_ids;
-  };
-
-  template <int dim>
-  AsciiBoundaryMember<dim>::AsciiBoundaryMember ()
-  {}
-
-
-  template <int dim>
-  void
-  AsciiBoundaryMember<dim>::initialize ()
-  {
-    const std::map<types::boundary_id,std::vector<std::unique_ptr<BoundaryVelocity::Interface<dim>>>> &
-    bvs = this->get_boundary_velocity_manager().get_active_boundary_velocity_conditions();
-    for (const auto &boundary : bvs)
-      for (const auto &p : boundary.second)
-        {
-          if (p.get() == this)
-            boundary_ids.insert(boundary.first);
-        }
-    AssertThrow(*(boundary_ids.begin()) != numbers::invalid_boundary_id,
-                ExcMessage("Did not find the boundary indicator for the prescribed data plugin."));
-
-    member->initialize(boundary_ids,
-                       dim);
-  }
-
-  template <int dim>
-  void
-  AsciiBoundaryMember<dim>::update ()
-  {
-    member->update();
-  }
-
-
-  template <int dim>
-  Tensor<1,dim>
-  AsciiBoundaryMember<dim>::
-  boundary_velocity (const types::boundary_id ,
-                     const Point<dim> &position) const
-  {
-    Tensor<1,dim> velocity;
-    for (unsigned int i = 0; i < dim; i++)
-      velocity[i] = member->get_data_component(*(boundary_ids.begin()),
-                                               position,
-                                               i);
-    return velocity;
-  }
-
-
-  template <int dim>
-  void
-  AsciiBoundaryMember<dim>::declare_parameters (ParameterHandler &prm)
-  {
-    prm.enter_subsection("Boundary velocity model");
-    {
-      Utilities::AsciiDataBoundary<dim>::declare_parameters(prm,
-                                                            "$ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/",
-                                                            "box_2d_%s.%d.txt");
-    }
-    prm.leave_subsection();
-  }
-
-
-  template <int dim>
-  void
-  AsciiBoundaryMember<dim>::parse_parameters (ParameterHandler &prm)
-  {
-    prm.enter_subsection("Boundary velocity model");
-    {
-      member = std::make_unique<Utilities::AsciiDataBoundary<dim>>();
-      member->initialize_simulator(this->get_simulator());
-
-      member->parse_parameters(prm);
-
-      if (this->convert_output_to_years() == true)
-        {
-          member->scale_factor               /= year_in_seconds;
-        }
-
-    }
-    prm.leave_subsection();
-  }
-
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(AsciiBoundaryMember,
-                                          "ascii boundary member",
-                                          "Implementation of a model in which the boundary "
-                                          "velocity is derived from files containing data "
-                                          "in ascii format. Note the required format of the "
-                                          "input data: The first lines may contain any number of comments "
-                                          "if they begin with '#', but one of these lines needs to "
-                                          "contain the number of grid points in each dimension as "
-                                          "for example '# POINTS: 3 3'. "
-                                          "The order of the data columns "
-                                          "has to be 'x', 'velocity_x', 'velocity_y' in a 2d model "
-                                          "or 'x', 'y', 'velocity_x', 'velocity_y', "
-                                          "'velocity_z' in a 3d model. "
-                                          "Note that the data in the input "
-                                          "files need to be sorted in a specific order: "
-                                          "the first coordinate needs to ascend first, "
-                                          "followed by the second in order to "
-                                          "assign the correct data to the prescribed coordinates."
-                                          "If you use a spherical model, "
-                                          "then the velocities will still be handled as Cartesian, "
-                                          "however the assumed grid changes. 'x' will be replaced by "
-                                          "the radial distance of the point to the bottom of the model, "
-                                          "'y' by the azimuth angle and 'z' by the polar angle measured "
-                                          "positive from the north pole. The grid will be assumed to be "
-                                          "a latitude-longitude grid. Note that the order "
-                                          "of spherical coordinates is 'r', 'phi', 'theta' "
-                                          "and not 'r', 'theta', 'phi', since this allows "
-                                          "for dimension independent expressions. "
-                                          "No matter which geometry model is chosen, "
-                                          "the unit of the velocities is assumed to be "
-                                          "m/s or m/yr depending on the 'Use years in output "
-                                          "instead of seconds' flag.")
-}
diff --git a/tests/ascii_boundary_member.prm.bak b/tests/ascii_boundary_member.prm.bak
deleted file mode 100644
index cfb5d0a8cd2..00000000000
--- a/tests/ascii_boundary_member.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-##### simple test for ascii data
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:ascii boundary member,left: ascii boundary member,right: ascii boundary member,top: ascii boundary member
-
-  subsection Ascii data model
-    set Data file name       = box_2d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_adiabatic_conditions.prm.bak b/tests/ascii_data_adiabatic_conditions.prm.bak
deleted file mode 100644
index 1f15c36ba47..00000000000
--- a/tests/ascii_data_adiabatic_conditions.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-##### simple test for ascii data adiabatic conditions
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Adiabatic conditions model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name       = simple_test.txt
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = top, bottom
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = top : 3.0, bottom : 4.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2890000
-    set Y extent = 2890000
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = adiabat
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/ascii_data_boundary_composition_2d_box_time.prm.bak b/tests/ascii_data_boundary_composition_2d_box_time.prm.bak
deleted file mode 100644
index 679c6d4ab18..00000000000
--- a/tests/ascii_data_boundary_composition_2d_box_time.prm.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-# simple test for ascii data composition
-# This test is particularly designed to test the time dependent behavior with
-# a set of files labeled with increasing file order.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 6e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1e-8*x
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Boundary composition model
-  set List of model names = ascii data
-  set Fixed composition boundary indicators   = left
-
-  subsection Ascii data model
-    set Data file name       = box_2d_%s.%d.txt
-    set Data file time step = 2e5
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top: function, bottom: function, left:function, right:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
-end
diff --git a/tests/ascii_data_boundary_composition_3d_box.prm.bak b/tests/ascii_data_boundary_composition_3d_box.prm.bak
deleted file mode 100644
index 42d8d11c6d2..00000000000
--- a/tests/ascii_data_boundary_composition_3d_box.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-##### simple test for ascii data composition
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e4
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set Z extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Boundary composition model
-  set List of model names = ascii data
-  set Fixed composition boundary indicators   = bottom,left,top,front,back
-
-  subsection Ascii data model
-    set Data file name       = box_3d_%s.0.txt
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function,front:function,back:function
-
-  subsection Function
-    set Function expression = 1;0;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
-end
diff --git a/tests/ascii_data_boundary_temperature_2d_box_time.prm.bak b/tests/ascii_data_boundary_temperature_2d_box_time.prm.bak
deleted file mode 100644
index 6f0b5e41de4..00000000000
--- a/tests/ascii_data_boundary_temperature_2d_box_time.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-##### simple test for ascii data temperature
-# This test is particularly designed to test the time dependent behavior with
-# a set of files labeled with increasing file order.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 6e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = ascii data
-  set Fixed temperature boundary indicators   = left
-
-  subsection Ascii data model
-    set Data file name       = box_2d_%s.%d.txt
-    set Data file time step = 2e5
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top: function, bottom: function, left:function, right:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_temperature_3d_box.prm.bak b/tests/ascii_data_boundary_temperature_3d_box.prm.bak
deleted file mode 100644
index d3cda5614e0..00000000000
--- a/tests/ascii_data_boundary_temperature_3d_box.prm.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-##### simple test for ascii data temperature
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set Z extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = ascii data
-  set Fixed temperature boundary indicators   = bottom,left,top,front,back, right
-
-  subsection Ascii data model
-    set Data file name       = box_3d_%s.0.txt
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function,front:function,back:function
-
-  subsection Function
-    set Function expression = 1;0;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_2d_box.prm.bak b/tests/ascii_data_boundary_velocity_2d_box.prm.bak
deleted file mode 100644
index e5236ee28a1..00000000000
--- a/tests/ascii_data_boundary_velocity_2d_box.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-##### simple test for ascii data
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:ascii data,left: ascii data,right: ascii data,top: ascii data
-
-  subsection Ascii data model
-    set Data file name       = box_2d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_2d_box_list.prm.bak b/tests/ascii_data_boundary_velocity_2d_box_list.prm.bak
deleted file mode 100644
index ae78b57bd97..00000000000
--- a/tests/ascii_data_boundary_velocity_2d_box_list.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-# test for the boundary velocity plugins, in particular for
-# summing several plugins and prescribing components on certain boundaries.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: ascii data,right: ascii data, left x: function, right: function
-  set Tangential velocity boundary indicators = top, bottom
-
-  subsection Ascii data model
-    set Data file name       = box_2d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 0.01
-  end
-
-  subsection Function
-    set Function expression = 0.01;0.0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_2d_box_time.prm.bak b/tests/ascii_data_boundary_velocity_2d_box_time.prm.bak
deleted file mode 100644
index ef4599b670f..00000000000
--- a/tests/ascii_data_boundary_velocity_2d_box_time.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-##### simple test for ascii data
-# This test is particularly designed to test the time dependent behavior with
-# a set of files labeled with increasing file order.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 6e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top: ascii data, bottom: function, left:ascii data, right:ascii data
-
-  subsection Ascii data model
-    set Data file name       = box_2d_%s.%d.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Data file time step = 2e5
-    set Scale factor = 1
-  end
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_2d_box_time_backward.prm.bak b/tests/ascii_data_boundary_velocity_2d_box_time_backward.prm.bak
deleted file mode 100644
index 9d19316854a..00000000000
--- a/tests/ascii_data_boundary_velocity_2d_box_time_backward.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-##### simple test for ascii data
-# This test is particularly designed to test the time dependent behavior with
-# a set of files labeled with decreasing file order.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 6e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top: ascii data, bottom: function
-  set Tangential velocity boundary indicators = left,right
-
-  subsection Ascii data model
-    set Data file name       = box_2d_%s.%d.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set First data file number = 2
-    set Data file time step = 2e5
-    set Decreasing file order = true
-    set Scale factor = 1
-  end
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_2d_box_time_non_equidistant.prm.bak b/tests/ascii_data_boundary_velocity_2d_box_time_non_equidistant.prm.bak
deleted file mode 100644
index 6073be5c8aa..00000000000
--- a/tests/ascii_data_boundary_velocity_2d_box_time_non_equidistant.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-# This test is a copy of ascii_data_boundary_velocity_2d_box_time and
-# uses non equidistant data files instead.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 6e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top: ascii data, bottom: function, left:function, right:function
-
-  subsection Ascii data model
-    set Data file name       = box_2d_%s_non_equidistant.%d.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Data file time step = 2e5
-    set Scale factor = 1
-  end
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_2d_chunk.prm.bak b/tests/ascii_data_boundary_velocity_2d_chunk.prm.bak
deleted file mode 100644
index a63e6bd2799..00000000000
--- a/tests/ascii_data_boundary_velocity_2d_chunk.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-##### simple test for ascii data
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Chunk inner radius = 3481000
-    set Chunk outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = west: ascii data,east:ascii data, inner: ascii data, outer: ascii data
-
-  subsection Ascii data model
-    set Data file name       = chunk_2d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_2d_shell.prm.bak b/tests/ascii_data_boundary_velocity_2d_shell.prm.bak
deleted file mode 100644
index fed563c6f05..00000000000
--- a/tests/ascii_data_boundary_velocity_2d_shell.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-##### simple test for ascii data
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 3
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left: ascii data,right:ascii data, inner: ascii data, outer: ascii data
-
-  subsection Ascii data model
-    set Data file name       = shell_2d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_2d_shell_spherical.prm.bak b/tests/ascii_data_boundary_velocity_2d_shell_spherical.prm.bak
deleted file mode 100644
index 97952a5cdc5..00000000000
--- a/tests/ascii_data_boundary_velocity_2d_shell_spherical.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-##### simple test for ascii data using spherical unit vectors
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 3
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left: ascii data,right:ascii data, inner: ascii data, outer: ascii data
-
-  subsection Ascii data model
-    set Data file name       = shell_2d_%s_spherical.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 1
-    set Use spherical unit vectors = true
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_3d_box.prm.bak b/tests/ascii_data_boundary_velocity_3d_box.prm.bak
deleted file mode 100644
index c05bea3cb18..00000000000
--- a/tests/ascii_data_boundary_velocity_3d_box.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-##### simple test for ascii data
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 3300000
-    set Z extent = 660000
-    set X repetitions = 5
-    set Y repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-
-  subsection Box
-    set Bottom temperature = 1613
-    set Top temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:ascii data,left:ascii data,right:ascii data,top:ascii data,front:ascii data,back:ascii data
-
-  subsection Ascii data model
-    set Data file name       = box_3d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_3d_chunk.prm.bak b/tests/ascii_data_boundary_velocity_3d_chunk.prm.bak
deleted file mode 100644
index f327968b210..00000000000
--- a/tests/ascii_data_boundary_velocity_3d_chunk.prm.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-##### simple test for ascii data
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e3
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Chunk minimum latitude = 0
-    set Chunk maximum latitude = 80
-    set Chunk inner radius = 3481000
-    set Chunk outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = west:ascii data, east:ascii data
-  set Tangential velocity boundary indicators = north, south, inner, outer
-
-  subsection Ascii data model
-    set Data file name       = chunk_3d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_3d_shell.prm.bak b/tests/ascii_data_boundary_velocity_3d_shell.prm.bak
deleted file mode 100644
index db0af6d2d5e..00000000000
--- a/tests/ascii_data_boundary_velocity_3d_shell.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-##### simple test for ascii data
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e3
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 30
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = west:ascii data, east:ascii data, south:ascii data, inner:ascii data, outer: ascii data
-
-  subsection Ascii data model
-    set Data file name       = shell_3d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_3d_shell_spherical.prm.bak b/tests/ascii_data_boundary_velocity_3d_shell_spherical.prm.bak
deleted file mode 100644
index 371d49b144e..00000000000
--- a/tests/ascii_data_boundary_velocity_3d_shell_spherical.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-##### simple test for ascii data using spherical unit vectors
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e3
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 30
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = west:ascii data, east:ascii data, south:ascii data, inner:ascii data, outer: ascii data
-
-  subsection Ascii data model
-    set Data file name       = shell_3d_%s_spherical.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 10
-    set Use spherical unit vectors = true
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_boundary_velocity_3d_sphere.prm.bak b/tests/ascii_data_boundary_velocity_3d_sphere.prm.bak
deleted file mode 100644
index 8cecf533c3d..00000000000
--- a/tests/ascii_data_boundary_velocity_3d_sphere.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-# simple test for ascii data in a 3d sphere
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e3
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = sphere
-
-  subsection Sphere
-    set Radius = 6371000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = outer: ascii data
-
-  subsection Ascii data model
-    set Data file name       = shell_3d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Output format = vtu
-    set Interpolate output = true
-  end
-end
diff --git a/tests/ascii_data_boundary_velocity_residual_shell.prm.bak b/tests/ascii_data_boundary_velocity_residual_shell.prm.bak
deleted file mode 100644
index 6717c4df7b6..00000000000
--- a/tests/ascii_data_boundary_velocity_residual_shell.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-##### simple test for boundary velocity residual visualization object in postprocessing
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set Output directory                       = ascii_data_boundary_velocity_residual_shell
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 30
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = west:ascii data, east:ascii data, south:ascii data, inner:ascii data, outer: ascii data
-
-  subsection Ascii data model
-    set Data file name       = shell_3d_%s.0.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, boundary velocity residual statistics
-
-  subsection Visualization
-    set Output format                 = gnuplot
-    set List of output variables      = boundary velocity residual
-  end
-
-  subsection Boundary velocity residual statistics
-    set Use ascii data = true
-    set Data file name       = shell_3d_boundary_velocity.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/postprocess/boundary-velocity-residual/
-  end
-end
diff --git a/tests/ascii_data_fail_1.prm.bak b/tests/ascii_data_fail_1.prm.bak
deleted file mode 100644
index d35cc749d0f..00000000000
--- a/tests/ascii_data_fail_1.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# Failing test for ascii data that checks the error message
-# for bad data values.
-#
-# EXPECT FAILURE
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-  set Prescribed velocity boundary indicators = top: ascii data
-
-  subsection Ascii data model
-    set Data file name       = fail_1.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_fail_2.prm.bak b/tests/ascii_data_fail_2.prm.bak
deleted file mode 100644
index f7d6a6aec08..00000000000
--- a/tests/ascii_data_fail_2.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# Failing test for ascii data that checks the error message
-# for too many data values.
-#
-# EXPECT FAILURE
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-  set Prescribed velocity boundary indicators = top: ascii data
-
-  subsection Ascii data model
-    set Data file name       = fail_2.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_fail_3.prm.bak b/tests/ascii_data_fail_3.prm.bak
deleted file mode 100644
index 4378da850c8..00000000000
--- a/tests/ascii_data_fail_3.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# Failing test for ascii data that checks the error message
-# for too few data values.
-#
-# EXPECT FAILURE
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-  set Prescribed velocity boundary indicators = top: ascii data
-
-  subsection Ascii data model
-    set Data file name       = fail_3.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_fail_4.prm.bak b/tests/ascii_data_fail_4.prm.bak
deleted file mode 100644
index e617815b2e0..00000000000
--- a/tests/ascii_data_fail_4.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# Failing test for ascii data that checks the error message
-# for a missing data file.
-#
-# EXPECT FAILURE
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-  set Prescribed velocity boundary indicators = top: ascii data
-
-  subsection Ascii data model
-    set Data file name       = fail_4.txt
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/
-    set Scale factor = 0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_gravity.prm.bak b/tests/ascii_data_gravity.prm.bak
deleted file mode 100644
index cf738f86d25..00000000000
--- a/tests/ascii_data_gravity.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-##### simple test for ascii data gravity profile
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Adiabatic conditions model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name       = simple_test.txt
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = top, bottom
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = top : 3.0, bottom : 4.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2890000
-    set Y extent = 2890000
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right, top
-end
-
-subsection Gravity model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name       = simple_test.txt
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = gravity
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/ascii_data_initial_composition_2d_box.prm.bak b/tests/ascii_data_initial_composition_2d_box.prm.bak
deleted file mode 100644
index b2728e7624b..00000000000
--- a/tests/ascii_data_initial_composition_2d_box.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-##### simple test for ascii data initial composition
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
-end
diff --git a/tests/ascii_data_initial_composition_2d_box_gz.prm.bak b/tests/ascii_data_initial_composition_2d_box_gz.prm.bak
deleted file mode 100644
index cb144c82a2e..00000000000
--- a/tests/ascii_data_initial_composition_2d_box_gz.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-# Simple test for ascii data initial composition. Like
-# ascii_data_initial_composition_2d_box, but reads in
-# a gzip compressed data file.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = box_2d.txt.gz
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
-end
diff --git a/tests/ascii_data_initial_composition_3d_chunk.prm.bak b/tests/ascii_data_initial_composition_3d_chunk.prm.bak
deleted file mode 100644
index 5b942b8d0e9..00000000000
--- a/tests/ascii_data_initial_composition_3d_chunk.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-##### simple test for ascii data initial composition
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Chunk minimum latitude = 0
-    set Chunk maximum latitude = 80
-    set Chunk inner radius = 3481000
-    set Chunk outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = north, south, east, west, inner, outer
-
-  subsection Function
-    set Function expression = 1;0;0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = shell_3d.txt
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
diff --git a/tests/ascii_data_initial_composition_3d_shell.prm.bak b/tests/ascii_data_initial_composition_3d_shell.prm.bak
deleted file mode 100644
index 71e9ea174b6..00000000000
--- a/tests/ascii_data_initial_composition_3d_shell.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-##### simple test for ascii data initial composition
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 30
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = west:function, east:function, south:function, inner:function, outer:function
-
-  subsection Function
-    set Function expression = 1;0;0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = shell_3d.txt
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_initial_temperature_2d_box.prm.bak b/tests/ascii_data_initial_temperature_2d_box.prm.bak
deleted file mode 100644
index 4b7695ec194..00000000000
--- a/tests/ascii_data_initial_temperature_2d_box.prm.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-##### simple test for ascii data initial temperature
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_initial_temperature_3d_chunk.prm.bak b/tests/ascii_data_initial_temperature_3d_chunk.prm.bak
deleted file mode 100644
index b37f309db55..00000000000
--- a/tests/ascii_data_initial_temperature_3d_chunk.prm.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-##### simple test for ascii data initial temperature
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Chunk minimum latitude = 0
-    set Chunk maximum latitude = 80
-    set Chunk inner radius = 3481000
-    set Chunk outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = shell_3d.txt
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = west:function, east:function, south:function, north:function, inner:function, outer:function
-
-  subsection Function
-    set Function expression = 1;0;0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_initial_temperature_3d_ellipsoidal_chunk.prm.bak b/tests/ascii_data_initial_temperature_3d_ellipsoidal_chunk.prm.bak
deleted file mode 100644
index c98ab1e461e..00000000000
--- a/tests/ascii_data_initial_temperature_3d_ellipsoidal_chunk.prm.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-##### simple test for ascii data initial temperature
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = ellipsoidal chunk
-
-  subsection Ellipsoidal chunk
-    set NE corner = 90:80
-    set NW corner = 0:80
-    set SW corner = 0:0
-    set Depth = 2855000
-    set Semi-major axis = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = shell_3d.txt
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = west:function, east:function, south:function, north:function, bottom:function, top:function
-
-  subsection Function
-    set Function expression = 1;0;0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_initial_temperature_3d_shell.prm.bak b/tests/ascii_data_initial_temperature_3d_shell.prm.bak
deleted file mode 100644
index 31545cb752d..00000000000
--- a/tests/ascii_data_initial_temperature_3d_shell.prm.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-##### simple test for ascii data initial temperature
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = shell_3d.txt
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = west:function, east:function, south:function, inner:function, outer:function
-
-  subsection Function
-    set Function expression = 1;0;0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_initial_temperature_3d_two_chunks.prm.bak b/tests/ascii_data_initial_temperature_3d_two_chunks.prm.bak
deleted file mode 100644
index fd9231419df..00000000000
--- a/tests/ascii_data_initial_temperature_3d_two_chunks.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-##### simple test for ascii data initial temperature
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = chunk with lithosphere boundary indicators
-
-  subsection Chunk with lithosphere boundary indicators
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Chunk minimum latitude = 0
-    set Chunk maximum latitude = 80
-    set Chunk inner radius = 3481000
-    set Chunk outer radius = 6336000
-    set Chunk middle boundary radius = 4908500
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = shell_3d.txt
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = lowerwest:function, lowereast:function, upperwest:function, uppereast:function, \
-                                                lowersouth:function, lowernorth:function, uppersouth:function, uppernorth:function, \
-                                                bottom:function, top:function
-
-  subsection Function
-    set Function expression = 1;0;0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_layered_initial_composition_2d_box.prm.bak b/tests/ascii_data_layered_initial_composition_2d_box.prm.bak
deleted file mode 100644
index 5004e2cc17f..00000000000
--- a/tests/ascii_data_layered_initial_composition_2d_box.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# This test is to check that the layered ascii data initial composition
-# plugin works in a 2D box with composition defined as piecewise constant
-# between layers.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100e3
-    set Y extent = 100e3
-    set X repetitions = 3
-    set Y repetitions = 3
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = ascii data layered
-
-  subsection Ascii data model
-    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file names       = initial_composition_top_mantle_box_2d.txt, initial_composition_top_crust_box_2d.txt
-    set Interpolation scheme  = piecewise constant
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, depth average, composition statistics
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/ascii_data_layered_initial_temperature_2d_box.prm.bak b/tests/ascii_data_layered_initial_temperature_2d_box.prm.bak
deleted file mode 100644
index 11497fb0eae..00000000000
--- a/tests/ascii_data_layered_initial_temperature_2d_box.prm.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-# This test is to check that the layered ascii data initial temperature
-# plugin works in a 2D box with temperature defined as linear
-# between isotherms and constant below and above the
-# first and last isotherm (with a value taken from that isotherm).
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 600e3
-    set Y extent = 660e3
-    set X repetitions = 3
-    set Y repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data layered
-
-  subsection Ascii data model
-    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file names       = initial_isotherm_1000K_box_2d.txt, initial_isotherm_500K_box_2d.txt
-    set Interpolation scheme  = linear
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/ascii_data_layered_initial_temperature_2d_chunk.prm.bak b/tests/ascii_data_layered_initial_temperature_2d_chunk.prm.bak
deleted file mode 100644
index 717aeda093d..00000000000
--- a/tests/ascii_data_layered_initial_temperature_2d_chunk.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# This test is to check that the layered ascii data initial temperature
-# plugin works in a 2D chunk with temperature defined as linear
-# between isotherms and constant below and above the
-# first and last isotherm (with a value taken from that isotherm).
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Longitude repetitions = 3
-    set Chunk inner radius = 5740e3
-    set Chunk outer radius = 6400e3
-    set Radius repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data layered
-
-  subsection Ascii data model
-    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file names       = initial_isotherm_1000K_chunk_2d.txt, initial_isotherm_500K_chunk_2d.txt
-    set Interpolation scheme  = linear
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = east, west, top, bottom
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/ascii_data_layered_initial_temperature_3d_box.prm.bak b/tests/ascii_data_layered_initial_temperature_3d_box.prm.bak
deleted file mode 100644
index 8961cc862f8..00000000000
--- a/tests/ascii_data_layered_initial_temperature_3d_box.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# This test is to check that the layered ascii data initial temperature
-# plugin works in a 3D box with temperature defined as linear
-# between isotherms and constant below and above the
-# first and last isotherm (with a value taken from that isotherm).
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 600e3
-    set Y extent = 600e3
-    set Z extent = 660e3
-    set X repetitions = 3
-    set Y repetitions = 3
-    set Z repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data layered
-
-  subsection Ascii data model
-    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file names       = initial_isotherm_1000K_box_3d.txt, initial_isotherm_500K_box_3d.txt
-    set Interpolation scheme  = linear
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, front, back, top, bottom
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/ascii_data_layered_initial_temperature_3d_chunk.prm.bak b/tests/ascii_data_layered_initial_temperature_3d_chunk.prm.bak
deleted file mode 100644
index fdd417b8673..00000000000
--- a/tests/ascii_data_layered_initial_temperature_3d_chunk.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# This test is to check that the layered ascii data initial temperature
-# plugin works in a 3D chunk with temperature defined as linear
-# between isotherms and constant below and above the
-# first and last isotherm (with a value taken from that isotherm).
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Longitude repetitions = 9
-    set Chunk minimum latitude = 0
-    set Chunk maximum latitude = 80
-    set Latitude repetitions = 9
-    set Chunk inner radius = 5740000
-    set Chunk outer radius = 6400000
-    set Radius repetitions = 6
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data layered
-
-  subsection Ascii data model
-    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file names       = initial_isotherm_1000K_chunk_3d.txt, initial_isotherm_500K_chunk_3d.txt
-    set Interpolation scheme  = linear
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, outer, west, east, south, north
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Refinement fraction                = 0.95
-  set Initial global refinement          = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/ascii_data_layered_initial_temperature_piecewise_constant_3d_box.prm.bak b/tests/ascii_data_layered_initial_temperature_piecewise_constant_3d_box.prm.bak
deleted file mode 100644
index cf06ed2e041..00000000000
--- a/tests/ascii_data_layered_initial_temperature_piecewise_constant_3d_box.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# This test is to check that the layered ascii data initial temperature
-# plugin works in a 3D box with temperature defined as piecewise constant
-# between isotherms (with temperature taken from the overlying isotherm).
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 600e3
-    set Y extent = 600e3
-    set Z extent = 660e3
-    set X repetitions = 3
-    set Y repetitions = 3
-    set Z repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data layered
-
-  subsection Ascii data model
-    set Data directory        = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file names       = initial_isotherm_1000K_box_3d.txt, initial_isotherm_500K_box_3d.txt
-    set Interpolation scheme  = piecewise constant
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, front, back, top, bottom
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/ascii_data_nonuniform_initial_composition_2d_box.prm.bak b/tests/ascii_data_nonuniform_initial_composition_2d_box.prm.bak
deleted file mode 100644
index 6c8f58e87e4..00000000000
--- a/tests/ascii_data_nonuniform_initial_composition_2d_box.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-##### simple test for ascii data initial composition
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = box_2d_nonuniform.txt
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = top,bottom,left
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = left
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/ascii_data_prescribed_stokes_2d_box.prm.bak b/tests/ascii_data_prescribed_stokes_2d_box.prm.bak
deleted file mode 100644
index 4437e0e8a47..00000000000
--- a/tests/ascii_data_prescribed_stokes_2d_box.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-# A test for velocity ascii files
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.005
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-# to turn stokes off and prescribe velocity
-subsection Prescribed Stokes solution
-  set Model name = ascii data
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/ascii_data_slice.prm.bak b/tests/ascii_data_slice.prm.bak
deleted file mode 100644
index 2da2715dbda..00000000000
--- a/tests/ascii_data_slice.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-# This is a test that makes sure that the ascii data slice model
-# reads in 3d files for the initial composition correctly, and
-# and then rotates them to the correct 2d plane.
-# The output was verified with a 3d version of the model, using
-# the same data file.
-
-set Dimension = 2
-set Use years in output instead of seconds = true
-set Output directory                       = ascii-data-slice
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Start time                             = 0
-set End time                               = 0
-set Adiabatic surface temperature          = 1600.0
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                         = 1e-4
-    set Stokes solver type                              = block GMG
-    set Number of cheap Stokes solver steps             = 5000
-    set GMRES solver restart length                     = 1000
-    set Maximum number of expensive Stokes solver steps = 0
-    set Use full A block as preconditioner              = true
-    set Linear solver A block tolerance                 = 1e-2
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 3
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = composition_1
-  set Compositional field methods = static
-end
-
-subsection Initial composition model
-  set List of model names = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name = shell_3d_2.txt
-    set Slice dataset in 2D plane = true
-    set First point on slice  = 0.3, -1, 0
-    set Second point on slice = 0.4, 1, -1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net surface rotation
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3700
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer    = 1e8
-    set Age bottom boundary layer = 1e8
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Material model
-  set Model name         = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Viscosity = 1e22
-    set Thermal viscosity exponent = 10.0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors         = velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables      = adiabat, material properties, gravity, nonadiabatic temperature, nonadiabatic pressure
-    set Output format  = gnuplot
-  end
-end
diff --git a/tests/ascii_data_slice_temperature.prm.bak b/tests/ascii_data_slice_temperature.prm.bak
deleted file mode 100644
index 7cace560005..00000000000
--- a/tests/ascii_data_slice_temperature.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-# This is a test that makes sure that the ascii data slice model
-# reads in 3d files for the initial temperature correctly, and
-# and then rotates them to the correct 2d plane.
-# The output was verified against the output of the ascii_data_slice
-# test.
-
-set Dimension = 2
-set Use years in output instead of seconds = true
-set Output directory                       = ascii-data-slice-temperature
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Start time                             = 0
-set End time                               = 0
-set Adiabatic surface temperature          = 1600.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top,
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net surface rotation
-end
-
-subsection Initial temperature model
-  set List of model names = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name = shell_3d_2.txt
-    set Slice dataset in 2D plane = true
-    set First point on slice  = 0.3, -1, 0
-    set Second point on slice = 0.4, 1, -1
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Material model
-  set Model name         = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Viscosity = 1e22
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors         = velocity statistics, temperature statistics
-end
diff --git a/tests/average_arithmetic.prm.bak b/tests/average_arithmetic.prm.bak
deleted file mode 100644
index 31edde1d041..00000000000
--- a/tests/average_arithmetic.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = arithmetic average
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/average_density_boundary_fluid_pressure.prm.bak b/tests/average_density_boundary_fluid_pressure.prm.bak
deleted file mode 100644
index 4bcc12e59af..00000000000
--- a/tests/average_density_boundary_fluid_pressure.prm.bak
+++ /dev/null
@@ -1,280 +0,0 @@
-# This is a variation of the melt and traction test, with the only
-# difference that it uses the product of the average (solid and melt)
-# density as the boundary fluid pressure, and that the domain is only
-# half as large in y direction so that there is melt present at the
-# lower boundary.
-
-# This is a test to see if traction boundary conditions work in models
-# with melt migration.
-# At the right and bottom boundary, the lithostatic pressure is applied,
-# so both the solid and the melt velocity should be approximately zero.
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 1600
-set Maximum time step                      = 1e6
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 20
-set Nonlinear solver tolerance             = 1e-7
-
-# In addition, melting and freezing normally happens on a much faster
-# time scale than the flow of melt, so we want to decouple the advection
-# of melt (and temperature) and the melting process itself. To do that,
-# we use the operator splitting scheme.
-set Use operator splitting                     = true
-
-# The end time of the simulation. We only do one time step.
-set End time                               = 1e5
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 100
-  end
-end
-
-# We apply the lithostatic pressure at the bottom and the right side.
-
-##################### Boundary conditions ########################
-
-# As boundary conditions for the temperature, we just use the
-# initial conditions again. This temperature is applied as a prescribed
-# temperature at the top and bottom boundary, as specified above.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3700
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function
-  set Tangential velocity boundary indicators = left
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0; 0
-  end
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom y:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Number of integration points = 10000
-    set Representative point         = 300000,150000
-  end
-end
-
-subsection Melt settings
-  # In addition, we now also specify in the model settings that we want to
-  # run a model with melt transport.
-  set Include melt transport                  = true
-end
-
-##################### Settings for melt transport ########################
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.5
-    set cR    = 1
-  end
-end
-
-##################### Initial temperature model ########################
-
-# We choose an adiabatic temperature profile as initial condition.
-subsection Initial temperature model
-  set List of model names = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 0
-    set Age top boundary layer    = 5e7
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-end
-
-# Now that our model uses compositional fields, we also need initial
-# conditions for the composition.
-# We use the function plugin to set both fields to zero at the beginning
-# of the model run.
-subsection Initial composition model
-  set List of model names = function, porosity
-
-  subsection Function
-    set Function expression = 0; 0
-    set Variable names      = x,y
-  end
-end
-
-# We again choose the initial composition as boundary condition
-# for all compositional fields.
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Models with melt transport also need an additional boundary condition.
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = average density
-  end
-end
-
-##################### Model geometry ########################
-
-# The model geometry is a square with a dimension of 300 km.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 300000
-    set Y extent = 150000
-    set X repetitions = 2
-  end
-end
-
-################ Gravity and material properties ##################
-
-# The model has a constant gravity.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We use the melt global material model, which is one of the
-# material models that works with melt transport, as it also
-# specifies the material properties needed for melt migration,
-# such as the permeability, the melt density and the melt
-# viscosity.
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    # First we describe the parameters for the solid, in the same way
-    # we did in the model without melt transport
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Thermal expansion coefficient     = 2e-5
-    set Reference shear viscosity         = 5e21
-    set Thermal viscosity exponent        = 7
-    set Reference temperature             = 1600
-
-    # The melt usually has a different (lower) density than the solid.
-    set Reference melt density            = 3400
-
-    # The permeability describes how well the pores of a porous material
-    # are connected (and hence how fast melt can flow through the rock).
-    # It is computed as the product of the reference value given here
-    # and the porosity cubed. This means that the lower the porosity is
-    # the more difficult it is for the melt to flow.
-    set Reference permeability            = 1e-8
-
-    # The bulk viscosity describes the resistance of the rock to dilation
-    # and compaction. Melt can only flow into a region that had no melt
-    # before if the matrix of the solid rock expands, so this parameter
-    # also limits how fast melt can flow upwards.
-    # The bulk viscosity is computed as the reference value given here times
-    # a term that scales with one over the porosity. This means that for zero
-    # porosity, the rock can not dilate/compact any more, which is the same
-    # behavior that we have for solid mantle convection.
-    set Reference bulk viscosity          = 1e19
-
-    # In dependence of how much melt is present, we also weaken the shear
-    # viscosity: The more melt is present, the weaker the rock gets.
-    # This scaling is exponential, following the relation
-    # viscosity ~ exp(-alpha * phi),
-    # where alpha is the parameter given here, and phi is the porosity.
-    set Exponential melt weakening factor = 10
-
-    # In the same way the shear viscosity is reduced with increasing temperature,
-    # we also prescribe the temperature-dependence of the bulk viscosity.
-    set Thermal bulk viscosity exponent   = 7
-
-    # Finally, we prescribe the viscosity of the melt, which is used in Darcy's
-    # law. The lower this viscosity, the faster melt can flow.
-    set Reference melt viscosity          = 1
-
-    # change the density contrast of depleted material (in kg/m^3)
-    set Depletion density change          = -200.0
-
-    # How much melt has been generated and subsequently extracted from a particular
-    # volume of rock (how 'depleted' that volume of rock is) usually changes the
-    # solidus. The more the material has been molten already, the less melt will be
-    # generated afterwards for the same pressure and temperature conditions. We
-    # model this using a simplified, linear relationship, saying that to melt 100%
-    # of the rock the temperature has to be 200 K higher than to melt it initially.
-    set Depletion solidus change          = 200
-    set Melting time scale for operator splitting = 1e100
-    set Include melting and freezing      = false
-  end
-end
-
-##################### Mesh refinement #########################
-
-# For the model with melt migration, we use adaptive refinement.
-# We make use of two different refinement criteria: we set a minimum of 4 global
-# refinements everywhere in the model (which is the same resolution as for the
-# model without melt), and we refine in regions where melt is present, to be
-# precise, everywhere where the porosity is bigger than 1e-4.
-# We adapt the mesh every 5 time steps.
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Time steps between mesh refinement       = 0
-end
-
-# As the model is compressible and has an adiabatic temperature profile, we include
-# adiabatic heating in the list of heating models.
-# To make this model as simple as possible, we do not include shear heating (although
-# usually, adiabatic heating and shear heating should always be used together).
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-##################### Postprocessing ########################
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, mass flux statistics
-  set Run postprocessors on nonlinear iterations = true
-
-  # For the model with melt migration, also add a visualization
-  # postprocessor that computes the material properties relevant
-  # to migration (permeability, viscosity of the melt, etc.).
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt material properties, nonadiabatic pressure
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Interpolate output            = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
diff --git a/tests/average_geometric.prm.bak b/tests/average_geometric.prm.bak
deleted file mode 100644
index d6180a92947..00000000000
--- a/tests/average_geometric.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = geometric average
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/average_harmonic.prm.bak b/tests/average_harmonic.prm.bak
deleted file mode 100644
index 274123e9149..00000000000
--- a/tests/average_harmonic.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0.0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/average_log.prm.bak b/tests/average_log.prm.bak
deleted file mode 100644
index dc68193c475..00000000000
--- a/tests/average_log.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = log average
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/average_none.prm.bak b/tests/average_none.prm.bak
deleted file mode 100644
index 98a00d4c28b..00000000000
--- a/tests/average_none.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = none
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set Stokes solver type = block AMG
-  end
-end
diff --git a/tests/average_nwd_arithmetic.prm.bak b/tests/average_nwd_arithmetic.prm.bak
deleted file mode 100644
index f0051d92b35..00000000000
--- a/tests/average_nwd_arithmetic.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = averaging
-
-  subsection Averaging
-    set Base model = simple
-    set Averaging operation =  nwd arithmetic average
-    set Bell shape limit = 0.75
-  end
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/average_nwd_geometric.prm.bak b/tests/average_nwd_geometric.prm.bak
deleted file mode 100644
index 2659f74c1c8..00000000000
--- a/tests/average_nwd_geometric.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = averaging
-
-  subsection Averaging
-    set Base model = simple
-    set Averaging operation =  nwd geometric average
-    set Bell shape limit = 0.75
-  end
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/average_nwd_harmonic.prm.bak b/tests/average_nwd_harmonic.prm.bak
deleted file mode 100644
index 80b00d47730..00000000000
--- a/tests/average_nwd_harmonic.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = averaging
-
-  subsection Averaging
-    set Base model = simple
-    set Averaging operation =  nwd harmonic average
-    set Bell shape limit = 0.75
-  end
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/average_pick_largest.prm.bak b/tests/average_pick_largest.prm.bak
deleted file mode 100644
index edf84cd415f..00000000000
--- a/tests/average_pick_largest.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = pick largest
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/average_project_to_q1.prm.bak b/tests/average_project_to_q1.prm.bak
deleted file mode 100644
index 67878e1e410..00000000000
--- a/tests/average_project_to_q1.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# Variations of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for the different kinds of averaging operations
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = project to Q1
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set Number of cheap Stokes solver steps = 1000
-  end
-end
diff --git a/tests/background_output_writer.prm.bak b/tests/background_output_writer.prm.bak
deleted file mode 100644
index 08cd6fd00f9..00000000000
--- a/tests/background_output_writer.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-# This is a copy of the maximum_refinement_function_spherical test,
-# but the real purpose of the test is to check that writing data in
-# the background actually works.
-
-# MPI: 2
-
-include $ASPECT_SOURCE_DIR/tests/maximum_refinement_function_spherical.prm
-
-
-subsection Postprocess
-  subsection Visualization
-    set Write in background thread = true
-  end
-end
diff --git a/tests/backward_advection.prm.bak b/tests/backward_advection.prm.bak
deleted file mode 100644
index 7901867684d..00000000000
--- a/tests/backward_advection.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# Test the spherical hexagonal perturbation initial temperature model
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = -9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 360
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          =  0 #1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Additional refinement times              =
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = basic statistics, visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/benchmark_layeredflow.cc.bak b/tests/benchmark_layeredflow.cc.bak
deleted file mode 100644
index 12e621ee1e6..00000000000
--- a/tests/benchmark_layeredflow.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/layeredflow/layeredflow.cc"
diff --git a/tests/benchmark_layeredflow.prm.bak b/tests/benchmark_layeredflow.prm.bak
deleted file mode 100644
index 3f44415ac8b..00000000000
--- a/tests/benchmark_layeredflow.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# test for benchmarks/layeredflow/
-
-include $ASPECT_SOURCE_DIR/benchmarks/layeredflow/layeredflow.prm
-
-set Dimension                              = 2
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, LayeredFlowPostprocessor
-end
diff --git a/tests/benchmark_particle_integration_scheme.prm.bak b/tests/benchmark_particle_integration_scheme.prm.bak
deleted file mode 100644
index dbff68e5758..00000000000
--- a/tests/benchmark_particle_integration_scheme.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-# A benchmark of particle integration schemes in Gassmoller 2018
-#  See the benchmark folder for more information.
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/particle_integration_scheme/circle.prm
-
-set End time = 0.1
diff --git a/tests/blankenbach.prm.bak b/tests/blankenbach.prm.bak
deleted file mode 100644
index 099d601074a..00000000000
--- a/tests/blankenbach.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# This case is identical to case 1a from the Blankenbach Benchmark
-# (Blankenbach 1989). Cases b and c can be run by changing the
-# Viscosity to 1e-5 and 1e-6, respectively, which leads to the
-# corresponding change of the Rayleigh number from 1e4 to 1e5 and
-# 1e6. This test essentially resembles the convection-box cookbook
-# and reproduces its results very closely (a slight difference results
-# from the different refinement levels).
-# The relevant output is the vrms velocity and the heat flux through
-# the top boundary, which in this setup is identical to the Nu number.
-
-set End time                               = 0.002 # 1.0 for full benchmark
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e3
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-3
-    set Viscosity                     = 1e-4
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/blankenbach_approximation.prm.bak b/tests/blankenbach_approximation.prm.bak
deleted file mode 100644
index c4ff6f6b5f1..00000000000
--- a/tests/blankenbach_approximation.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# Like blankenbach.prm but with the BA approximation, so we can rescale
-# parameters however we want.
-
-set End time                               = 0.002 # 1.0 for full benchmark
-set Use years in output instead of seconds = false
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0; 0; 1
-    set Variable names      = depth
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e4
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation # this overwrites the parameters below
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1e-10
-    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
-  end
-end
diff --git a/tests/blankenbach_case1a.cc.bak b/tests/blankenbach_case1a.cc.bak
deleted file mode 100644
index db7193d6fc8..00000000000
--- a/tests/blankenbach_case1a.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/blankenbach/plugin/code.cc"
-#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case1a.prm.bak b/tests/blankenbach_case1a.prm.bak
deleted file mode 100644
index 5ad4ad90282..00000000000
--- a/tests/blankenbach_case1a.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-# blankenbach case 1a as described in benchmarks/blankenbach/README.md
-
-include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case1a.prm
-
-set End time                               = 0.02
-set CFL number = 5.0
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
-end
diff --git a/tests/blankenbach_case1b.cc.bak b/tests/blankenbach_case1b.cc.bak
deleted file mode 100644
index db7193d6fc8..00000000000
--- a/tests/blankenbach_case1b.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/blankenbach/plugin/code.cc"
-#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case1b.prm.bak b/tests/blankenbach_case1b.prm.bak
deleted file mode 100644
index 6ba5a0311c3..00000000000
--- a/tests/blankenbach_case1b.prm.bak
+++ /dev/null
@@ -1,26 +0,0 @@
-# blankenbach case 1b as described in benchmarks/blankenbach/README.md
-
-include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case1a.prm
-
-set End time                               = 0.02
-set CFL number = 5.0
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  subsection Nondimensional model
-    set Ra                      = 1e5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
-end
diff --git a/tests/blankenbach_case1c.cc.bak b/tests/blankenbach_case1c.cc.bak
deleted file mode 100644
index db7193d6fc8..00000000000
--- a/tests/blankenbach_case1c.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/blankenbach/plugin/code.cc"
-#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case1c.prm.bak b/tests/blankenbach_case1c.prm.bak
deleted file mode 100644
index b44962394c5..00000000000
--- a/tests/blankenbach_case1c.prm.bak
+++ /dev/null
@@ -1,26 +0,0 @@
-# blankenbach case 1c as described in benchmarks/blankenbach/README.md
-
-include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case1a.prm
-
-set End time                               = 0.02
-set CFL number = 5.0
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  subsection Nondimensional model
-    set Ra                      = 1e6
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
-end
diff --git a/tests/blankenbach_case2a.cc.bak b/tests/blankenbach_case2a.cc.bak
deleted file mode 100644
index db7193d6fc8..00000000000
--- a/tests/blankenbach_case2a.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/blankenbach/plugin/code.cc"
-#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case2a.prm.bak b/tests/blankenbach_case2a.prm.bak
deleted file mode 100644
index f60a83a88dc..00000000000
--- a/tests/blankenbach_case2a.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-# blankenbach case 2a as described in benchmarks/blankenbach/README.md
-
-include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case2a.prm
-
-set End time                               = 0.02
-set CFL number = 5.0
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
-end
diff --git a/tests/blankenbach_case2b.cc.bak b/tests/blankenbach_case2b.cc.bak
deleted file mode 100644
index db7193d6fc8..00000000000
--- a/tests/blankenbach_case2b.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/blankenbach/plugin/code.cc"
-#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/blankenbach_case2b.prm.bak b/tests/blankenbach_case2b.prm.bak
deleted file mode 100644
index 3326d8e2b55..00000000000
--- a/tests/blankenbach_case2b.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-# blankenbach case 2b as described in benchmarks/blankenbach/README.md
-
-include $ASPECT_SOURCE_DIR/benchmarks/blankenbach/base_case2b.prm
-
-set End time                               = 0.006
-set CFL number = 5.0
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1, ratio=2.5
-    set Function expression = 1* ((1.0-z/L) + p*cos(k*pi*x/L/ratio)*sin(pi*z/L))
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
-end
diff --git a/tests/boukare_bulk_composition.prm.bak b/tests/boukare_bulk_composition.prm.bak
deleted file mode 100644
index f27f707aa8c..00000000000
--- a/tests/boukare_bulk_composition.prm.bak
+++ /dev/null
@@ -1,211 +0,0 @@
-# Simplified setup of convection in the lowermost mantle
-# on a small scale, but melt is not allowed to move.
-# That means that the bulk composition should be conserved
-# everywhere in the domain at 0.07
-# (except maybe at the inflow boundary).
-
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set CFL number                             = 1.0
-set Use years in output instead of seconds = true
-set End time                               = 6e5
-set Output directory                       = output_bulk_3
-set Nonlinear solver scheme                = iterated IMPES
-set Max nonlinear iterations               = 10
-set Nonlinear solver tolerance             = 1e-4
-set Pressure normalization                 = surface
-set Surface pressure                       = 1.34888e+11
-set Adiabatic surface temperature          = 2510
-set Use conduction timestep                = true
-set Use operator splitting                 = true
-
-#set Maximum time step                      = 2e5
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
-end
-
-subsection Melt settings
-  set Include melt transport               = true
-  set Melt scaling factor threshold        = 1e20 #1e-8
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set GMRES solver restart length = 200
-  end
-
-  subsection Operator splitting parameters
-    set Reaction time step                     = 5e3
-    set Reaction solver type                   = fixed step
-  end
-end
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 40000
-    set Y extent = 20000
-    set X periodic = false
-    set X repetitions = 2
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 1e8
-
-    subsection Function
-      set Function expression = 0; 0.07; 0.49
-    end
-  end
-
-  subsection Function
-    set Function constants  = amplitude=500, width=50000, b=100000, x0=0 #25000
-    set Function expression = 10 * exp(-((x-x0)*(x-x0)/(2*5000*5000)+y*y/(2*5000*5000)))
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function #, porosity
-
-  subsection Function
-    set Function expression = 0; 0.07; 0.49
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       =
-  set Prescribed velocity boundary indicators = bottom:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Function constants  = amplitude=500, width=50000, b=100000, x0=0 #25000
-    set Function expression = if(y>10000,0.001*sin(3.1416*x/40000),-0.001*sin(3.1416*x/40000));0
-  end
-end
-
-subsection Boundary temperature model
-  set Allow fixed temperature on outflow boundaries = false
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Maximal temperature = 4000
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-  set Fixed composition boundary indicators   = top
-  set Model name = initial composition
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating, latent heat melt
-
-  subsection Latent heat melt
-    set Melting entropy change = 0
-    set Retrieve entropy change from material model = true
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Material model
-  set Model name = melt boukare
-
-  subsection Melt boukare
-    set Thermal conductivity          = 8.5
-    set Reference shear viscosity     = 5e22
-    set Reference bulk viscosity      = 5e22
-    set Thermal viscosity exponent    = 10
-    set Thermal bulk viscosity exponent    = 10
-    set Exponential melt weakening factor    = 15
-    set Melting time scale for operator splitting = 5e4 #5e3
-    set Fe mantle melting temperature = 2824.5 #default: 3424.5
-    set Mg mantle melting temperature = 4221.2 #default: 4821.2
-    set Reference permeability        = 5e-13
-    set Include melting and freezing  = true
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 1  # maybe start with 5+2, and then change to 5+4 for the restart
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = minimum refinement function
-  set Minimum refinement level                 = 3
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Function expression = if(y<4000,4,3)
-  end
-
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-5, 1, 1
-  end
-end
-
-subsection Boundary fluid pressure model
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 6e5
-    set List of output variables = material properties, nonadiabatic temperature, melt fraction, melt material properties, named additional outputs
-    set Output format = gnuplot
-    set Interpolate output = false
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
-    end
-
-    subsection Melt material properties
-      set List of properties = compaction viscosity, permeability, fluid density
-    end
-  end
-end
diff --git a/tests/boukare_conserve_mass.prm.bak b/tests/boukare_conserve_mass.prm.bak
deleted file mode 100644
index 992bdf8b545..00000000000
--- a/tests/boukare_conserve_mass.prm.bak
+++ /dev/null
@@ -1,159 +0,0 @@
-# This setup checks that mass is conserved when reactions occur.
-# The model starts with a Gaussian porosity distributon that
-# solidifies over time, decreasing the density in the model.
-# According to this change in mass, material flows out of the box
-# at the top. At refinement 5, the outflow should be about
-# 2336 kg/yr in the first time step and 819 kg/yr in the second
-# time step (they should equal the product of the change in mass
-# of the porosity field and the density difference between melt
-# and solid of 72.3 kg/m^3, divided by the time step size).
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set Use years in output instead of seconds = true
-set End time                               = 1e5
-set Nonlinear solver scheme                = iterated IMPES
-set Max nonlinear iterations               = 20
-set Nonlinear solver tolerance             = 1e-4
-set Pressure normalization                 = surface
-set Surface pressure                       = 1.35e+11
-set Adiabatic surface temperature          = 2510
-set Use operator splitting                 = true
-set Maximum time step                      = 5e4
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
-end
-
-subsection Melt settings
-  set Include melt transport               = true
-  set Melt scaling factor threshold        = 1e-8
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set GMRES solver restart length = 200
-    set Linear solver S block tolerance = 1e-5
-  end
-
-  subsection Operator splitting parameters
-    set Reaction time step                     = 5e2
-    set Reaction solver type                   = fixed step
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 20000
-    set Y extent = 20000
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 0
-
-    subsection Function
-      set Function expression = 0; 0.07; 0.49
-    end
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = width=2000, x0=10000
-    set Function expression = 0.1 * exp(-((x-x0)*(x-x0)/(2*width*width)+(y-x0)*(y-x0)/(2*width*width))); 0.07; 0.07
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-end
-
-subsection Boundary temperature model
-  set Allow fixed temperature on outflow boundaries = false
-  set Fixed temperature boundary indicators   = top
-  set List of model names = initial temperature
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-  set Fixed composition boundary indicators   = top
-  set Model name = initial composition
-end
-
-subsection Heating model
-  set List of model names =
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = melt boukare
-
-  subsection Melt boukare
-    set Thermal conductivity          = 8.5
-    set Reference shear viscosity     = 1e19
-    set Reference bulk viscosity      = 1e19
-    set Reference volumes             = 2.534e-05, 2.445e-05, 1.206e-05, 1.125e-05, 1.3e-5, 1.218e-05, 1.218e-05
-    set Thermal viscosity exponent    = 0
-    set Thermal bulk viscosity exponent = 0
-    set Exponential melt weakening factor = 0
-    set Melting time scale for operator splitting = 5e4
-    set Fe mantle melting temperature = 2824.5 #default: 3424.5
-    set Mg mantle melting temperature = 4221.2 #default: 4821.2
-    set Reference permeability        = 5e-13
-    set Include melting and freezing  = true
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Function expression = if(y<4000,4,3)
-  end
-end
-
-subsection Boundary fluid pressure model
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, composition statistics, mass flux statistics
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set List of output variables = material properties, nonadiabatic temperature, melt fraction, melt material properties, named additional outputs
-
-    #    set Output format = gnuplot
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
-    end
-
-    subsection Melt material properties
-      set List of properties = compaction viscosity, permeability, fluid density
-    end
-  end
-end
diff --git a/tests/boukare_latent_heat.prm.bak b/tests/boukare_latent_heat.prm.bak
deleted file mode 100644
index ce06e480c7f..00000000000
--- a/tests/boukare_latent_heat.prm.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-# This is a test for the latent heat release and consumption
-# in the melt boukare material model. The initial temperature
-# is set to a value that is out of equilibrium with the initial
-# porosity in the model, specifically, it is set so high that
-# the energy released by reducing the temperature to the solidus
-# allows for melting of approximately 10% of the material. This
-# means that the steady-state melt fraction at the end of the
-# model run should be 0.1.
-# The test also outputs the bulk composition to make sure it is
-# conserved (it should be 0.001).
-
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 15
-set Maximum time step                      = 0.1
-set Output directory                       = output_latent_heat
-set Nonlinear solver scheme                = single Advection, no Stokes
-set Max nonlinear iterations               = 3
-set Pressure normalization                 = surface
-set Surface pressure                       = 120.e9
-set Adiabatic surface temperature          = 4817.17773612
-set Use operator splitting = true
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Function expression = 0;0
-  end
-
-  subsection Pressure function
-    set Function expression = 120.e9
-  end
-
-  subsection Fluid pressure function
-    set Function expression = 120.e9
-  end
-
-  subsection Compaction pressure function
-    set Function expression = 0
-  end
-
-  subsection Fluid velocity function
-    set Function expression = 0;0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
-end
-
-subsection Melt settings
-  set Include melt transport               = true
-  set Melt scaling factor threshold        = 1e-8
-  set Use discontinuous compaction pressure = false
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-
-  subsection Operator splitting parameters
-    set Reaction time step                     = 0.1
-    set Reaction solver type                   = fixed step
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 5096.848501701
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 0; 0.001; 0.001
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       =
-  set Prescribed velocity boundary indicators =
-
-  #  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-  set Model name = initial composition
-end
-
-subsection Heating model
-  set List of model names = latent heat melt
-
-  subsection Latent heat melt
-    set Melting entropy change = 0
-    set Retrieve entropy change from material model = true
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = melt boukare
-
-  subsection Melt boukare
-    set Thermal conductivity          = 0
-    set Reference shear viscosity     = 5e22
-    set Thermal viscosity exponent    = 0
-    set Exponential melt weakening factor    = 0
-    set Include melting and freezing  = true
-    set Melting time scale for operator splitting = 50
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Minimum refinement level                 = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, composition statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set Output format = gnuplot
-    set List of output variables = material properties, nonadiabatic temperature, melt fraction, named additional outputs
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
-    end
-  end
-end
diff --git a/tests/boukare_melting_diagram.prm.bak b/tests/boukare_melting_diagram.prm.bak
deleted file mode 100644
index 4d8d19d7544..00000000000
--- a/tests/boukare_melting_diagram.prm.bak
+++ /dev/null
@@ -1,162 +0,0 @@
-# This is a test for the melt fraction computation.
-# The gnuplot output of time step zero should show the binary loop
-# melting model, with a zero melt fraction below the solidus,
-# and a melt fraction of 1 above the solidus.
-
-# To plot the output:
-# gnuplot
-# set view map
-# splot "solution-00000.0000.gnuplot" using 1:2:20 palette
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Maximum time step                      = 1e3
-set Output directory                       = output_melting_diagram2
-set Nonlinear solver scheme                = first timestep only, single Stokes
-set Max nonlinear iterations               = 3
-set Pressure normalization                 = surface
-set Surface pressure                       = 120.e9
-set Adiabatic surface temperature          = 5000
-set Use conduction timestep                = true
-set Use operator splitting = true
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
-end
-
-subsection Melt settings
-  set Include melt transport               = true
-  set Melt scaling factor threshold        = 1e6
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-
-  subsection Operator splitting parameters
-    set Reaction time step                     = 100000.0
-    set Reaction solver type                   = fixed step
-  end
-end
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 0.9999998
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = amplitude=500, width=50000, b=100000
-    set Function expression = 3400 + 1600 * y
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 0; x+1e-7; x+1e-7
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       =
-  set Prescribed velocity boundary indicators =
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Heating model
-  set List of model names =
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = melt boukare
-
-  subsection Melt boukare
-    set Thermal conductivity          = 8.5
-    set Reference shear viscosity     = 5e22
-    set Thermal viscosity exponent    = 10
-    set Exponential melt weakening factor    = 0
-    set Include melting and freezing  = false #true
-    set Melting time scale for operator splitting = 1e15
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = composition threshold
-  set Minimum refinement level                 = 0
-
-  subsection Composition threshold
-    set Compositional field thresholds = 0.01,1,1
-  end
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set List of output variables = material properties, nonadiabatic temperature, melt fraction
-    set Output format = gnuplot
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
-    end
-  end
-end
-
-subsection Checkpointing
-  # The wall time between performing checkpoints. If 0, will use the
-  # checkpoint step frequency instead. Units: Seconds.
-  set Time between checkpoint  = 900
-end
diff --git a/tests/boundary_composition_list.prm.bak b/tests/boundary_composition_list.prm.bak
deleted file mode 100644
index 2086b70a2fa..00000000000
--- a/tests/boundary_composition_list.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-# simple test for using multiple boundary temperature plugins
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Boundary composition model
-  set List of model names = box, function, initial composition
-  set List of model operators = maximum, subtract, add
-  set Fixed composition boundary indicators   = top,left,bottom,right
-
-  subsection Box
-    set Left composition = 15
-    set Right composition = 0
-    set Top composition = 0
-    set Bottom composition = 7
-  end
-
-  subsection Function
-    set Function expression = if (x>500000,3,0)
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-1,1.5)
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-1,1.5)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box, constant, function, initial temperature
-  set List of model operators = maximum, add, subtract, add
-  set Fixed temperature boundary indicators   = top,left,bottom,right
-
-  subsection Box
-    set Left temperature = 15
-  end
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = bottom:7, left:0, top:0, right:0
-  end
-
-  subsection Function
-    set Function expression = if (x>500000,3,0)
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
diff --git a/tests/boundary_composition_passive_cartesian.prm.bak b/tests/boundary_composition_passive_cartesian.prm.bak
deleted file mode 100644
index 9180c917cd3..00000000000
--- a/tests/boundary_composition_passive_cartesian.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-#########################################################
-# This is a variation of the platelike-boundary.prm file.
-# All settings are exactly the same with the exception
-# of the ones that pertain to compositional fields.
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = top, bottom, left, right
-  set List of model names = function
-
-  subsection Function
-    set Variable names      = x, y
-    set Coordinate system   = cartesian
-    set Function expression = if(y<0.2, 1,  0) ; if(y>0.5, 1, 0)
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
diff --git a/tests/boundary_composition_passive_depth.prm.bak b/tests/boundary_composition_passive_depth.prm.bak
deleted file mode 100644
index 012399661e8..00000000000
--- a/tests/boundary_composition_passive_depth.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-#########################################################
-# This is a variation of the platelike-boundary.prm file.
-# All settings are exactly the same with the exception
-# of the ones that pertain to compositional fields.
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = top, bottom, left, right
-  set List of model names = function
-
-  subsection Function
-    set Variable names      = depth,y
-    set Coordinate system   = depth
-    set Function expression = if(depth>0.8, 1,  0) ; if(depth<0.5, 1, 0)
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
diff --git a/tests/boundary_composition_passive_sphere.prm.bak b/tests/boundary_composition_passive_sphere.prm.bak
deleted file mode 100644
index 5abbacf021b..00000000000
--- a/tests/boundary_composition_passive_sphere.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-#########################################################
-# This is a variation of the platelike-boundary.prm file.
-# All settings are exactly the same with the exception
-# of the ones that pertain to compositional fields.
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = .45
-    set Outer radius  = 1
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer, left, right
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = inner, outer, left, right
-  set List of model names = function
-
-  subsection Function
-    set Variable names      = r, theta
-    set Coordinate system   = spherical
-    set Function expression = if(r<0.5, 1,  0) ; if(theta>0.8, 1, 0)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system   = spherical
-    set Variable names      = r,phi
-    set Function expression = (1-r)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
diff --git a/tests/boundary_heatflux.prm.bak b/tests/boundary_heatflux.prm.bak
deleted file mode 100644
index a9f866495c6..00000000000
--- a/tests/boundary_heatflux.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# This test is used to check if the heat flux boundary conditions
-# work correctly. It prescribes a zero heat flux at the sides, a
-# basal heat flow of 4 mW/m^2 and a surface temperature of 90 K.
-# Presently, we use a conductivity of
-# 2.38 (the conductivity of ice at 273 K). This test should yield a
-# temperature of approximately 420 K at the base of the model.
-
-#           Ts = 90 K
-#      ------------------
-#      |                |
-#      |                |   flux = 0 at sides
-#      |                |
-#      ------------------
-#        q = 4 mW / m^2
-#
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 2.5e14
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 90  # -183°C adiabat
-set Use conduction timestep                = true
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 20000
-  end
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.42
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
-
-  subsection Function
-    set Function expression = 0;0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top
-  set List of model names = initial temperature
-end
-
-subsection Boundary heat flux model
-  set Fixed heat flux boundary indicators = bottom
-  set Model name = function
-
-  subsection Function
-    set Function expression = -0.04
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density        = 950
-    set Reference specific heat  = 1000
-    set Reference temperature    = 273
-    set Thermal conductivity     = 2.38
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization.
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =  heat flux map
-  end
-end
diff --git a/tests/boundary_heatflux_update.cc.bak b/tests/boundary_heatflux_update.cc.bak
deleted file mode 100644
index 662e4cbcc07..00000000000
--- a/tests/boundary_heatflux_update.cc.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/boundary_heat_flux/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/base/parsed_function.h>
-#include <aspect/global.h>
-#include <deal.II/base/signaling_nan.h>
-
-namespace aspect
-{
-  namespace BoundaryHeatFlux
-  {
-    using namespace dealii;
-
-    /**
-     * A class that implements heat flux boundary conditions based on a
-     * functional description provided in the input file.
-     *
-     * @ingroup BoundaryHeatFlux
-     */
-    template <int dim>
-    class Update : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Return the boundary heat flux as a function of position.
-         */
-        virtual
-        std::vector<Tensor<1,dim>>
-        heat_flux (const types::boundary_id /*boundary_indicator*/,
-                   const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-                   const MaterialModel::MaterialModelOutputs<dim> &/*material_model_outputs*/,
-                   const std::vector<Tensor<1,dim>> &normal_vectors) const
-        {
-          std::vector<Tensor<1,dim>> heat_flux(normal_vectors);
-          const unsigned int n_evaluation_points = material_model_inputs.position.size();
-          for (unsigned int i=0; i<n_evaluation_points; ++i)
-            heat_flux[i] *= timestep * (-1.e-4);
-          return heat_flux;
-        }
-
-        /**
-         * Initialization function. This function is called once at the
-         * beginning of the program after parse_parameters is run and after the
-         * SimulatorAccess (if applicable) is initialized.
-         */
-        virtual
-        void
-        initialize ()
-        {
-          std::cout << "Initializing boundary heat flux!" << std::endl;
-          timestep = 0;
-        };
-
-        /**
-         * A function that is called at the beginning of each time step to
-         * indicate what the model time is for which the boundary values will
-         * next be evaluated. For the current class, the function passes to
-         * the parsed function what the current time is.
-         */
-        virtual
-        void
-        update ()
-        {
-          timestep = this->get_timestep_number();
-          std::cout << "Updating boundary heat flux to time step "
-                    << timestep
-                    << '!'
-                    << std::endl;
-        }
-
-      private:
-        unsigned int timestep;
-    };
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryHeatFlux
-  {
-    ASPECT_REGISTER_BOUNDARY_HEAT_FLUX_MODEL(Update,
-                                             "heatflux update",
-                                             "Heat flux boundary to test the update and initialize functions.")
-  }
-}
diff --git a/tests/boundary_heatflux_update.prm.bak b/tests/boundary_heatflux_update.prm.bak
deleted file mode 100644
index 73170a83e72..00000000000
--- a/tests/boundary_heatflux_update.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# This test is used to check if the heat flux boundary conditions
-# work correctly, in particular if the initialize and update functions work.
-# Otherwise, it is a copy of the boundary_heatflux test.
-set Use years in output instead of seconds = false
-set End time                               = 2e12
-set Maximum time step                      = 1e12
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 90
-set Use conduction timestep                = true
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-  end
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.42
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
-
-  subsection Function
-    set Function expression = 0;0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top
-  set List of model names = initial temperature
-end
-
-subsection Boundary heat flux model
-  set Fixed heat flux boundary indicators = bottom
-  set Model name = heatflux update
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density        = 950
-    set Reference specific heat  = 1000
-    set Reference temperature    = 273
-    set Thermal conductivity     = 2.38
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization.
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =  heat flux map
-  end
-end
diff --git a/tests/boundary_temperature_function.prm.bak b/tests/boundary_temperature_function.prm.bak
deleted file mode 100644
index 05f63c796b4..00000000000
--- a/tests/boundary_temperature_function.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-# Copy of the simpler box test with a function
-# object describing the gravity
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-
-  subsection Function
-    set Function expression = x * 1600
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density
-  end
-end
diff --git a/tests/boundary_temperature_list.prm.bak b/tests/boundary_temperature_list.prm.bak
deleted file mode 100644
index 0d6263a05d2..00000000000
--- a/tests/boundary_temperature_list.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# simple test for using multiple boundary temperature plugins
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-1,1.5)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box, constant, function, initial temperature
-  set List of model operators = maximum, add, subtract, add
-  set Fixed temperature boundary indicators   = top,left,bottom,right
-
-  subsection Box
-    set Left temperature = 15
-  end
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = bottom:7, left:0, top:0, right:0
-  end
-
-  subsection Function
-    set Function expression = if (x>500000,3,0)
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
diff --git a/tests/boundary_traction_function_cartesian_free_surface.prm.bak b/tests/boundary_traction_function_cartesian_free_surface.prm.bak
deleted file mode 100644
index bb1f55c6f78..00000000000
--- a/tests/boundary_traction_function_cartesian_free_surface.prm.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-##### test for boundary traction function using cartesian coordinates
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 5
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set CFL number                             = 0.5
-set Maximum time step                      = 2.5
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 5871.e3
-    set Chunk outer radius = 6371.e3
-    set Chunk minimum longitude = 35.0
-    set Chunk maximum longitude = 55.0
-    set Longitude repetitions = 60
-    set Radius repetitions = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 2
-  set Time steps between mesh refinement = 0
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system   = spherical
-    set Variable names      = r,phi
-    set Function expression = r>=6169.e3 ? 2 : 0
-  end
-end
-
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Mesh deformation
-  set Additional tangential mesh velocity boundary indicators = east, west
-  set Mesh deformation boundary indicators = outer: free surface
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, east, west
-end
-
-subsection Nullspace removal
-  set Remove nullspace = angular momentum
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = outer: function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x,y,t
-    set Function constants  = alpha1=0.767945, alpha2=0.802851, tend=100., Re=6371.e3, F=10000000
-    set Function expression = x>=Re*cos(alpha2) && x<=Re*cos(alpha1) ? -F*t/tend*cos(atan(y/x)) : 0; x>=Re*cos(alpha2) && x<=Re*cos(alpha1) ? -F*t/tend*sin(atan(y/x)) : 0;
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = ve_stress_xx, ve_stress_yy, ve_stress_xy
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0;
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = true
-  set List of model names = initial composition
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = inner, outer, east, west
-  set List of model names = initial temperature
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 4450
-    set Viscosities                 = 5.0e20
-    set Elastic shear moduli        = 175.e9
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 2.5
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.8
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics
-
-  subsection Topography
-    set Output to file = true
-    set Time between text output = 0
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/tests/boundary_traction_function_spherical_free_surface.prm.bak b/tests/boundary_traction_function_spherical_free_surface.prm.bak
deleted file mode 100644
index c45db3508a8..00000000000
--- a/tests/boundary_traction_function_spherical_free_surface.prm.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-##### test for boundary traction function using spherical coordinates
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 5
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set CFL number                             = 0.5
-set Maximum time step                      = 2.5
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 5871.e3
-    set Chunk outer radius = 6371.e3
-    set Chunk minimum longitude = 35.0
-    set Chunk maximum longitude = 55.0
-    set Longitude repetitions = 60
-    set Radius repetitions = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 2
-  set Time steps between mesh refinement = 0
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system   = spherical
-    set Variable names      = r,phi
-    set Function expression = r>=6169.e3 ? 2 : 0
-  end
-end
-
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Mesh deformation
-  set Additional tangential mesh velocity boundary indicators = east, west
-  set Mesh deformation boundary indicators = outer: free surface
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, east, west
-end
-
-subsection Nullspace removal
-  set Remove nullspace = angular momentum
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = outer: function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Use spherical unit vectors = true
-    set Variable names = r,phi,t
-    set Function constants  = alpha1=0.767945, alpha2=0.802851, tend=100., Re=6371.e3, F=10000000
-    set Function expression = phi>=alpha1 && phi<=alpha2 ? -F*t/tend: 0; 0;
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = ve_stress_xx, ve_stress_yy, ve_stress_xy
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0;
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = true
-  set List of model names = initial composition
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = inner, outer, east, west
-  set List of model names = initial temperature
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 4450
-    set Viscosities                 = 5.0e20
-    set Elastic shear moduli        = 175.e9
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 2.5
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.8
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics
-
-  subsection Topography
-    set Output to file = true
-    set Time between text output = 0
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/tests/boundary_velocity_function_spherical.prm.bak b/tests/boundary_velocity_function_spherical.prm.bak
deleted file mode 100644
index 8b0a3239b9a..00000000000
--- a/tests/boundary_velocity_function_spherical.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-##### test for boundary velocity function using spherical coordinates
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 3
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, inner
-  set Prescribed velocity boundary indicators = outer: function
-
-  subsection Function
-    set Coordinate system   = spherical
-    set Variable names      = r, phi
-    set Function expression = sin(4*phi);sin(2*phi)
-    set Use spherical unit vectors = true
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/box_end_time_1e7_terminate.prm.bak b/tests/box_end_time_1e7_terminate.prm.bak
deleted file mode 100644
index 1a108186aae..00000000000
--- a/tests/box_end_time_1e7_terminate.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# a test that verifies that setting an end time earlier than when
-# we achieve steady state still terminates the program at the right
-# time
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = steady state velocity
-
-  subsection Steady state velocity
-    set Maximum relative deviation = 0.05
-    set Time in steady state       = 5e6
-  end
-end
diff --git a/tests/box_first_time_step.prm.bak b/tests/box_first_time_step.prm.bak
deleted file mode 100644
index 6dd31b16557..00000000000
--- a/tests/box_first_time_step.prm.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-end
diff --git a/tests/box_first_time_step_alternate_bc.prm.bak b/tests/box_first_time_step_alternate_bc.prm.bak
deleted file mode 100644
index b66028b539e..00000000000
--- a/tests/box_first_time_step_alternate_bc.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-# This is a copy of the box_first_time_step.prm. The difference is this: One
-# can mark boundaries as having zero velocity, or one can mark them as having
-# Dirichlet velocity boundary conditions and then select that the boundary
-# function should in fact be zero. The result should of course be the
-# same. This test verifies that this is indeed so.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: zero velocity, 2: zero velocity, 3: zero velocity
-  set Tangential velocity boundary indicators = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-end
diff --git a/tests/box_initial_mesh_deformation.cc.bak b/tests/box_initial_mesh_deformation.cc.bak
deleted file mode 100644
index 56b3edfdad0..00000000000
--- a/tests/box_initial_mesh_deformation.cc.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Copyright (C) 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/mesh_deformation/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace MeshDeformation
-  {
-    template <int dim>
-    class PrescribedDeformation : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        PrescribedDeformation()
-        {}
-
-        Tensor<1,dim>
-        compute_initial_deformation_on_boundary(const types::boundary_id /*boundary_indicator*/,
-                                                const Point<dim> &position) const
-        {
-          const Tensor<1,dim> gravity = this->get_gravity_model().gravity_vector(position);
-          Tensor<1,dim> topography_direction;
-          if (gravity.norm() > 0.0)
-            topography_direction = -gravity / gravity.norm();
-
-          const double topography_amplitude = 20000. * std::cos(2.*numbers::PI*position[0]/(660000.));
-          return topography_amplitude * topography_direction;
-        }
-    };
-  }
-}
-
-
-// explicit instantiation of the functions we implement in this file
-namespace aspect
-{
-  namespace MeshDeformation
-  {
-    ASPECT_REGISTER_MESH_DEFORMATION_MODEL(PrescribedDeformation,
-                                           "prescribed deformation",
-                                           "A test plugin for initial mesh deformation.")
-  }
-}
diff --git a/tests/box_initial_mesh_deformation.prm.bak b/tests/box_initial_mesh_deformation.prm.bak
deleted file mode 100644
index 126460dc9a7..00000000000
--- a/tests/box_initial_mesh_deformation.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# This input file tests the box geometry in
-# combination with an initial prescribed
-# mesh deformation.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: prescribed deformation
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Strategy                           = minimum refinement function
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, top, bottom
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables =
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/box_initial_mesh_deformation_ascii_data.prm.bak b/tests/box_initial_mesh_deformation_ascii_data.prm.bak
deleted file mode 100644
index d0ca2dad273..00000000000
--- a/tests/box_initial_mesh_deformation_ascii_data.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# This input file tests the box geometry in
-# combination with the ascii data initial
-# mesh deformation model.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# We take a box geometry and increase the repetitions
-# of the coarse mesh to capture the initial topography.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set Z extent = 660000
-    set X repetitions = 1
-    set Y repetitions = 1
-    set Z repetitions = 1
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: ascii data
-
-  # This specifies parameters for initial topography from ascii data
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-    set Data file name = box_3d_top.0.txt
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = 5
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Function expression             = if(x<200000, 2,1)
-  end
-end
-
-# Unlike in the geometry_model/initial_topography_model test
-# we must use free-slip boundaries, otherwise the mesh will not
-# deform at the boundaries of the box
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators       = 0,1,2,3,4
-end
-
-# The maximum topography in the ascii file is 350 km and the minimum is 20 km.
-# The topography statistics should not exceed these bounds.
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = boundary indicators, depth
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/box_initial_mesh_deformation_periodic.cc.bak b/tests/box_initial_mesh_deformation_periodic.cc.bak
deleted file mode 100644
index a05d9059016..00000000000
--- a/tests/box_initial_mesh_deformation_periodic.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "box_initial_mesh_deformation.cc"
diff --git a/tests/box_initial_mesh_deformation_periodic.prm.bak b/tests/box_initial_mesh_deformation_periodic.prm.bak
deleted file mode 100644
index ad8539d8f0e..00000000000
--- a/tests/box_initial_mesh_deformation_periodic.prm.bak
+++ /dev/null
@@ -1,25 +0,0 @@
-# Like box_initial_mesh_deformation.prm, but test
-# that periodic boundaries are correctly interpreted as
-# tangential mesh movement boundaries.
-
-include $ASPECT_SOURCE_DIR/tests/box_initial_mesh_deformation.prm
-
-set Dimension                              = 2
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set X periodic = true
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: prescribed deformation
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = top, bottom
-end
diff --git a/tests/box_initial_topography_ascii_data.prm.bak b/tests/box_initial_topography_ascii_data.prm.bak
deleted file mode 100644
index fe3f0b0e560..00000000000
--- a/tests/box_initial_topography_ascii_data.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# This input file tests the box geometry in
-# combination with the ascii data initial
-# topography model.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# We take a box geometry and increase the repetitions
-# of the coarse mesh to capture the initial topography.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set Z extent = 660000
-    set X repetitions = 1
-    set Y repetitions = 1
-    set Z repetitions = 1
-  end
-
-  # We specify the name and directory of the ascii data file
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-      set Data file name = box_3d_top.0.txt
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = 5
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Function expression             = if(x<220000, 2,1)
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0,1,2,3,4,5
-end
-
-# The maximum topography in the ascii file is 350 km and the minimum is 20 km.
-# The topography statistics should not exceed these bounds.
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = boundary indicators, depth
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/box_initial_topography_ascii_data_moved_origin.prm.bak b/tests/box_initial_topography_ascii_data_moved_origin.prm.bak
deleted file mode 100644
index ec31e30789f..00000000000
--- a/tests/box_initial_topography_ascii_data_moved_origin.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# This input is based on box_initial_topography_ascii_data
-# and tests the box geometry with a moved box origin in
-# combination with the ascii data initial
-# topography model.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# We take a box geometry and increase the repetitions
-# of the coarse mesh to capture the initial topography.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set Z extent = 660000
-    set Box origin Z coordinate = -655000
-    set X repetitions = 1
-    set Y repetitions = 1
-    set Z repetitions = 1
-  end
-
-  # We specify the name and directory of the ascii data file
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-      set Data file name = box_3d_top.0.txt
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = 5
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Function expression             = if(x<220000, 2,1)
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0,1,2,3,4,5
-end
-
-# The maximum topography in the ascii file is 350 km and the minimum is 20 km.
-# The topography statistics should not exceed these bounds.
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = boundary indicators, depth
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/box_initial_topography_function.prm.bak b/tests/box_initial_topography_function.prm.bak
deleted file mode 100644
index 68225fe381f..00000000000
--- a/tests/box_initial_topography_function.prm.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-# This input file tests the box geometry in
-# combination with the function initial
-# topography model.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# We take a box geometry and increase the repetitions
-# of the coarse mesh to capture the initial topography.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set X repetitions = 1
-    set Y repetitions = 1
-  end
-
-  # We specify the topography with a cosine function
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function constants = L=660000, R=20000
-      set Function expression = R * cos(pi*x/(2*L))
-      set Maximum topography value = 20000
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = top
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Function expression             = if(x<300000, 2,1)
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, top, bottom
-end
-
-# The maximum topography of the function is 20 km and the minimum is 0 km.
-# The topography statistics should not exceed these bounds.
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = boundary indicators, depth
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/box_initial_topography_prm_polygon.prm.bak b/tests/box_initial_topography_prm_polygon.prm.bak
deleted file mode 100644
index c6444f7a7a9..00000000000
--- a/tests/box_initial_topography_prm_polygon.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# This input file tests the box geometry in
-# combination with the prm polygon initial
-# topography model.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# We take a box geometry and increase the repetitions
-# of the coarse mesh to capture the initial topography.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set Z extent = 660000
-    set X repetitions = 1
-    set Y repetitions = 1
-    set Z repetitions = 1
-  end
-
-  # We specify a triangular polygon where topography is 50 km.
-  subsection Initial topography model
-    set Model name = prm polygon
-
-    subsection Prm polygon
-      set Topography parameters = 50000 > 100000,0;550000,100000;550000,550000
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = 5
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0,1,2,3,4,5
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = boundary indicators, depth
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/box_lithostatic_pressure_2d.prm.bak b/tests/box_lithostatic_pressure_2d.prm.bak
deleted file mode 100644
index 239c2b52320..00000000000
--- a/tests/box_lithostatic_pressure_2d.prm.bak
+++ /dev/null
@@ -1,142 +0,0 @@
-# This is a version of the stokes' law input file
-# that demonstrates a lithostatic pressure boundary
-# - "open boundary" - for a sinking sphere.
-
-
-
-############### Global parameters
-# We use a 2d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Pressure normalization                 = surface
-
-############### Parameters describing the model
-# The setup is a 2d box with edge length 2890000 in which
-# all sides except the left have free slip boundary conditions. Because
-# the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2890000
-    set Y extent  = 2890000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1,2,3
-end
-
-#############
-# The lithostatic pressure profile is calculated
-# at x = 10000, over 1000 integration points
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 0: initial lithostatic pressure #, 1: lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Representative point = 10000,0
-  end
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = (289e4-z)*9.81*33e2;0
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = #linear x momentum
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Viscosity                     = 1e22
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# This, however, is the more important part: We need to describe
-# the compositional field and its influence on the density
-# function. The following blocks say that we want to
-# advect a single compositional field and that we give it an
-# initial value that is zero outside a sphere of radius
-# r=200000m and centered at the point (p,p) with
-# p=1445000 (which is half the diameter of the box) and one inside.
-# The last block re-opens the material model and sets the
-# density differential per unit change in compositional field to
-# 100.
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = r=2e5,p=1445e3
-    set Function expression = if(sqrt((x-p)*(x-p)+(z-p)*(z-p)) > r, 0, 1)
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = composition
-end
-
-############### Parameters describing the what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-# The lithostatic pressure at the bottom boundary should be
-# 2890000*9.81*3300 = 93557970000 (9.4e10).
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, velocity boundary statistics, boundary pressures
-end
diff --git a/tests/box_lithostatic_pressure_3d.prm.bak b/tests/box_lithostatic_pressure_3d.prm.bak
deleted file mode 100644
index 9d310274bca..00000000000
--- a/tests/box_lithostatic_pressure_3d.prm.bak
+++ /dev/null
@@ -1,140 +0,0 @@
-# This is a version of the stokes' law input file
-# that demonstrates a lithostatic pressure boundary
-# - "open boundary" - for a sinking sphere.
-
-
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Pressure normalization                 = surface
-
-############### Parameters describing the model
-# The setup is a 3d box with edge length 2890000 in which
-# all sides except the left have free slip boundary conditions. Because
-# the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2890000
-    set Y extent  = 2890000
-    set Z extent  = 2890000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1,2,3,4,5
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 0: initial lithostatic pressure #, 1: initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Representative point = 10000,10000,2890000
-  end
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = (289e4-z)*9.81*33e2;0
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = #linear x momentum
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Viscosity                     = 1e22
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# This, however, is the more important part: We need to describe
-# the compositional field and its influence on the density
-# function. The following blocks say that we want to
-# advect a single compositional field and that we give it an
-# initial value that is zero outside a sphere of radius
-# r=200000m and centered at the point (p,p,p) with
-# p=1445000 (which is half the diameter of the box) and one inside.
-# The last block re-opens the material model and sets the
-# density differential per unit change in compositional field to
-# 100.
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = r=2e5,p=1445e3
-    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = composition
-  set Run postprocessors on initial refinement = true
-  set Time steps between mesh refinement       = 0
-end
-
-############### Parameters describing the what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, velocity boundary statistics, boundary pressures
-end
diff --git a/tests/box_origin.prm.bak b/tests/box_origin.prm.bak
deleted file mode 100644
index 84df87e1e37..00000000000
--- a/tests/box_origin.prm.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box # Test comment
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  #test comment3
-  set Model name = vertical#test comment2
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.3
-    set Y extent = 2.2
-    set Z extent = 1.1
-    set Box origin X coordinate = -1.9
-    set Box origin Y coordinate = 2.5
-    set Box origin Z coordinate = 3.1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/box_repetitions.prm.bak b/tests/box_repetitions.prm.bak
deleted file mode 100644
index 4b2cb4e38be..00000000000
--- a/tests/box_repetitions.prm.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-    set X repetitions = 3
-    set Y repetitions = 7
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization#, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/box_simple_log_viscosity_depth_average.prm.bak b/tests/box_simple_log_viscosity_depth_average.prm.bak
deleted file mode 100644
index cca6fb00e9e..00000000000
--- a/tests/box_simple_log_viscosity_depth_average.prm.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-# Test geometric depth averaging of visocity using  material model in 2d box
-# using a file # to specify depth-dependence.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Geometry of the domain. In order to test the depth averaging,
-# we use the X and Y repetitions such that four equal depth
-# layers of visocisty are created in the depth-dependent material
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2e6
-    set Y extent = 2e6
-    set X repetitions = 24
-    set Y repetitions = 24
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 0
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
-    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 2773
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 273.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc).
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = depth dependent
-
-  subsection Depth dependent model
-    set Base model = simple
-    set Depth dependence method = List
-    set Depth list =  5e5, 1e6, 1.5e6, 2e6
-    set Viscosity list = 1e23, 1e21, 1e22, 1e21
-    set Reference viscosity = 1e21
-  end
-
-  subsection Simple model
-    set Reference density             = 3300.0
-    set Reference specific heat       = 1250.0
-    set Reference temperature         = 0
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1e24
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Depth average
-    set List of output variables = log viscosity, viscosity
-    set Time between graphical output = 0
-    set Number of zones = 2
-    set Depth boundaries of zones = 0, 1e6, 2e6
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/box_simple_surface_strain_rate_residual.prm.bak b/tests/box_simple_surface_strain_rate_residual.prm.bak
deleted file mode 100644
index 058a948ec39..00000000000
--- a/tests/box_simple_surface_strain_rate_residual.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-##### simple test to check the boundary strain rate residual statistics and
-##### visualization postprocessor. The input data has zero strain rate so
-##### to check that the posprocessor is working : the output `strain rate`
-##### and `boundary strain rate residual` are equal in magnitude and opposite
-##### in signs.
-
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Nonlinear solver tolerance             = 1e-10
-set CFL number                             = 0.5
-set Pressure normalization                 = no
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Dimension                              = 3
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Refinement fraction                      = 0.0
-  set Coarsening fraction                      = 0.0
-  set Time steps between mesh refinement       = 0
-  set Initial adaptive refinement              = 0
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,1,2,3        # default:
-
-  subsection Initial temperature
-    set Maximal temperature = 101.0
-    set Minimal temperature = 99.0
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Geometry model
-  set Model name = box # default:
-
-  subsection Box
-    set X extent  = 100e3
-    set Y extent  = 100e3
-    set Z extent  = 100e3
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = top: free surface
-
-  subsection Free surface
-    set Surface velocity projection = vertical
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left:function, right:function
-
-  subsection Function
-    set Function constants = vel=0.1
-    set Function expression = if ( (x==0), vel, if ( (x==100e3), -vel, 0) ) ; 0; 0
-    set Variable names      = x,y,z
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function # default:
-
-  subsection Function
-    set Function expression = 100.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, boundary strain rate residual statistics
-
-  subsection Visualization
-    set Output format                 = gnuplot
-    set List of output variables      = strain rate, boundary strain rate residual
-    set Point-wise stress and strain  = true
-  end
-
-  subsection Boundary strain rate residual statistics
-    set Data file name                     = box_3d_boundary_strain_rate.txt
-    set Data directory                     = $ASPECT_SOURCE_DIR/data/postprocess/boundary-strain-rate-residual/
-  end
-end
diff --git a/tests/box_steady_state_terminate.prm.bak b/tests/box_steady_state_terminate.prm.bak
deleted file mode 100644
index 8907b6b355a..00000000000
--- a/tests/box_steady_state_terminate.prm.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 5e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = steady state velocity
-
-  subsection Steady state velocity
-    set Maximum relative deviation = 0.05
-    set Time in steady state       = 5e6
-  end
-end
diff --git a/tests/box_steady_temperature_terminate.prm.bak b/tests/box_steady_temperature_terminate.prm.bak
deleted file mode 100644
index 107285063ea..00000000000
--- a/tests/box_steady_temperature_terminate.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-# A test for the 'steady state temperature' termination criterion
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 5e9
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Use conduction timestep = true
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (1-y)*x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0.1
-    set Viscosity                     = 1e-3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, velocity statistics
-
-  subsection Visualization
-    set List of output variables = material properties
-    set Time between graphical output = 0.1
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = steady state temperature
-
-  subsection Steady state temperature
-    set Maximum relative deviation = 1e-8
-    set Time in steady state       = 1
-  end
-end
diff --git a/tests/box_surface_base_variables.prm.bak b/tests/box_surface_base_variables.prm.bak
deleted file mode 100644
index ec646ea17f2..00000000000
--- a/tests/box_surface_base_variables.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-# This input file tests the box geometry in
-# combination with the ascii data initial
-# topography model and visualization output
-# on the mesh surface.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# We take a box geometry and increase the repetitions
-# of the coarse mesh to capture the initial topography.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set Z extent = 660000
-    set X repetitions = 1
-    set Y repetitions = 1
-    set Z repetitions = 1
-  end
-
-  # We specify the name and directory of the ascii data file
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-      set Data file name = box_3d_top.0.txt
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-# The parameters below this comment were created by the update script
-# as replacement for the old 'Model settings' subsection. They can be
-# safely merged with any existing subsections with the same name.
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = 5
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Function expression             = if(x<400000, 2,1)
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0,1,2,3,4,5
-end
-
-# The maximum topography in the ascii file is 350 km and the minimum is 20 km.
-# The topography statistics should not exceed these bounds.
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = boundary indicators, depth
-    set Output base variables on mesh surface = true
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/bunge_cookbook.prm.bak b/tests/bunge_cookbook.prm.bak
deleted file mode 100644
index 01ce4d3693a..00000000000
--- a/tests/bunge_cookbook.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test cookbooks/cookbooks/bunge_et_al_mantle_convection/
-
-
-include $ASPECT_SOURCE_DIR/cookbooks/bunge_et_al_mantle_convection/bunge_et_al.prm
-
-set End time                               = 1e2
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Time steps between mesh refinement = 0
-end
-
-# Post processing
-subsection Postprocess
-  #  set List of postprocessors = temperature statistics
-end
diff --git a/tests/burnman_seismic_test.prm.bak b/tests/burnman_seismic_test.prm.bak
deleted file mode 100644
index 8091d8e93ed..00000000000
--- a/tests/burnman_seismic_test.prm.bak
+++ /dev/null
@@ -1,151 +0,0 @@
-# A cookbook based on the burnman_test cookbook, but modified testing
-# the output of seismic velocity data generated by burnman and reading
-# them in through an ascii data file.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-subsection Material model
-  set Model name = ascii reference profile
-  set Material averaging = harmonic average
-
-  subsection Ascii reference profile
-    set Thermal viscosity exponent = 10.0
-    set Viscosity prefactors = 1.0, 0.1, 1.0, 10.0
-
-    subsection Ascii data model
-      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-      set Data file name = example_seismic_velocities.txt
-    end
-  end
-end
-
-# The geometry is a spherical shell with the inner and
-# outer radius of the Earth's mantle.
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Adiabatic conditions model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_seismic_velocities.txt
-  end
-end
-
-# The gravity model reads an ascii data file that contains a gravity
-# profile consistent with the material properties computed using the
-# Birch-Murnaghan equation of state. It automatically uses the same file
-# specified in the adiabatic conditions model.
-subsection Gravity model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_seismic_velocities.txt
-  end
-end
-
-# The model uses the anelastic liquid approximation.
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
-
-# The present-day plate velocities are imposed on the upper model
-# boundary.
-
-
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = outer:gplates
-  set Tangential velocity boundary indicators = inner
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 273
-  end
-end
-
-# The initial temperature is an adiabatic profile, which is
-# taken from the adiabatic conditions model. In this case, this is
-# is the ascii data model that loads a file containing profiles
-# corresponding to the Birch-Murnaghan equation of state.
-# In addition to the adiabatic profile, there are thermal boundary
-# layers at the surface and the core-mantle boundary.
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = if(sqrt(x*x+(z-4500000)*(z-4500000))<1000000,800,0)
-  end
-end
-
-subsection Mesh refinement
-  set Refinement fraction                = 0.4
-  set Coarsening fraction                = 0.05
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 5
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set Number of grouped files       = 0
-    set List of output variables      = named additional outputs
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint  = 1800
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-  end
-end
diff --git a/tests/burnman_test.prm.bak b/tests/burnman_test.prm.bak
deleted file mode 100644
index 51922959030..00000000000
--- a/tests/burnman_test.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# A test using adiabatic conditions and a gravity
-# profile generated by a mineral physics toolkit and read in
-# through an ascii data file. In this example, material properties
-# are based on a Birch-Murnaghan equation of state.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-
-subsection Material model
-  set Model name = ascii reference profile
-  set Material averaging = harmonic average
-
-  subsection Ascii reference profile
-    set Thermal viscosity exponent = 0
-    set Viscosity prefactors = 1.0, 1.0, 1.0, 1.0
-
-    subsection Ascii data model
-      set Data file name = example_isentrope.txt
-      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    end
-  end
-end
-
-# The geometry is a spherical shell with the inner and
-# outer radius of the Earth's mantle.
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Adiabatic conditions model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_isentrope.txt
-  end
-end
-
-# The gravity model reads an ascii data file that contains a gravity
-# profile consistent with the material properties computed using the
-# Birch-Murnaghan equation of state. It automatically uses the same file
-# specified in the adiabatic conditions model.
-subsection Gravity model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_isentrope.txt
-  end
-end
-
-# The model uses the anelastic liquid approximation.
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
-
-# The present-day plate velocities are imposed on the upper model
-# boundary.
-
-
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = outer:gplates
-  set Tangential velocity boundary indicators = inner
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 273
-  end
-end
-
-# The initial temperature is an adiabatic profile, which is
-# taken from the adiabatic conditions model. In this case, this is
-# is the ascii data model that loads a file containing profiles
-# corresponding to the Birch-Murnaghan equation of state.
-# In addition to the adiabatic profile, there are thermal boundary
-# layers at the surface and the core-mantle boundary.
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Mesh refinement
-  set Refinement fraction                = 0.4
-  set Coarsening fraction                = 0.05
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 2
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 5
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/tests/burstedde.cc.bak b/tests/burstedde.cc.bak
deleted file mode 100644
index f43d3026353..00000000000
--- a/tests/burstedde.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/burstedde/burstedde.cc"
diff --git a/tests/burstedde.prm.bak b/tests/burstedde.prm.bak
deleted file mode 100644
index ab2535036b3..00000000000
--- a/tests/burstedde.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# The 3D polynomial Stokes (burstedde) benchmark, for which an
-# analytical solution is available.
-#
-# See the manual for more information.
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-set Additional shared libraries            = ./libburstedde.so
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-# The setup is a 3d unit cube.
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-    set Z extent  = 1
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:BursteddeBoundary, 1: BursteddeBoundary, 2: BursteddeBoundary, 3: BursteddeBoundary, 4: BursteddeBoundary, 5: BursteddeBoundary
-end
-
-subsection Material model
-  set Model name = BursteddeMaterial
-end
-
-subsection Gravity model
-  set Model name = BursteddeGravity
-end
-
-subsection Burstedde benchmark
-  #Viscosity parameter is beta
-  set Viscosity parameter             = 20
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, BursteddePostprocessor
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/burstedde_stokes_rhs.cc.bak b/tests/burstedde_stokes_rhs.cc.bak
deleted file mode 100644
index 43fcbf64f93..00000000000
--- a/tests/burstedde_stokes_rhs.cc.bak
+++ /dev/null
@@ -1,472 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  /**
-   * This is the "Burstedde" benchmark defined in the following paper:
-   * @code
-   *  @Article{busa13,
-   *    author =       {Burstedde, Carsten and Stadler, Georg and Alisic, Laura and Wilcox, Lucas C and Tan, Eh and Gurnis, Michael and Ghattas, Omar},
-   *    title =        {Large-scale adaptive mantle convection simulation},
-   *    journal =      {Geophysical Journal International},
-   *    year =         2013,
-   *    volume =       192,
-   *    number =       {3},
-   *    publisher =    {Oxford University Press},
-   *    pages =        {889--906}}
-   * @endcode
-   *
-   */
-  namespace BursteddeBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-      Tensor<1,3>
-      burstedde_velocity (const Point<3> &pos,
-                          const double eta)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const double z = pos[2];
-
-        // create a Point<3> (because it has a constructor that takes
-        // three doubles) and return it (it automatically converts to
-        // the necessary Tensor<1,3>).
-        return Point<3> (x+x*x+x*y+x*x*x*y,
-                         y+x*y+y*y+x*x*y*y,
-                         -2.*z-3.*x*z-3.*y*z-5.*x*x*y*z);
-      }
-
-      double
-      burstedde_pressure (const Point<3> &pos,
-                          const double eta)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const double z = pos[2];
-
-        const double min_eta = 1.0;
-        const double max_eta = eta;
-        const double A(min_eta*(max_eta-min_eta)/(max_eta+min_eta));
-
-        return x*y*z+x*x*x*y*y*y*z-5./32.;
-      }
-
-
-      /**
-       * The exact solution for the Burstedde benchmark.
-       */
-      template <int dim>
-      class FunctionBurstedde : public Function<dim>
-      {
-        public:
-          FunctionBurstedde (const double beta)
-            :
-            Function<dim>(dim+2),
-            beta_(beta)
-          {}
-
-          virtual void vector_value (const Point<dim>   &pos,
-                                     Vector<double>   &values) const
-          {
-            Assert (dim == 3, ExcNotImplemented());
-            Assert (values.size() >= 4, ExcInternalError());
-
-            const Point<3> p (pos[0], pos[1], pos[2]);
-
-            const Tensor<1,3> v = AnalyticSolutions::burstedde_velocity (p, beta_);
-            values[0] = v[0];
-            values[1] = v[1];
-            values[2] = v[2];
-
-            values[3] = AnalyticSolutions::burstedde_pressure (p, beta_);
-          }
-
-        private:
-          const double beta_;
-      };
-    }
-
-
-
-    template <int dim>
-    class BursteddeBoundary : public BoundaryVelocity::Interface<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        BursteddeBoundary();
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        virtual
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position) const;
-
-      private:
-        const double beta;
-    };
-
-    template <int dim>
-    BursteddeBoundary<dim>::BursteddeBoundary ()
-      :
-      beta (0)
-    {}
-
-
-
-    template <>
-    Tensor<1,2>
-    BursteddeBoundary<2>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<2> &p) const
-    {
-      Assert (false, ExcNotImplemented());
-      return Tensor<1,2>();
-    }
-
-
-
-    template <>
-    Tensor<1,3>
-    BursteddeBoundary<3>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<3> &p) const
-    {
-      return AnalyticSolutions::burstedde_velocity (p, beta);
-    }
-
-
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class BursteddeMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const
-        {
-
-          MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
-          *force = out.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> &p = in.position[i];
-
-              const double x=p[0];
-              const double y=p[1];
-              const double z=p[2];
-              const double mu=exp(1. - beta * (x*(1.-x)+y*(1.-y) + z*(1.-z)));
-
-              out.viscosities[i] = mu;
-              out.thermal_conductivities[i] = 0.0;
-              out.densities[i] = 1.0;
-
-              out.thermal_expansion_coefficients[i] = 0.0;
-              out.compressibilities[i] = 0.0;
-
-              out.specific_heat[i] = 0.0;
-
-              // Pressure derivative of entropy at the given positions.
-              out.entropy_derivative_pressure[i] = 0.0;
-              // Temperature derivative of entropy at the given positions.
-              out.entropy_derivative_temperature[i] = 0.0;
-              // Change in composition due to chemical reactions at the
-              // given positions. The term reaction_terms[i][c] is the
-              // change in compositional field c at point i.
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                out.reaction_terms[i][c] = 0.0;
-
-              if (force)
-                {
-                  const double dmudx=-beta*(1.-2.*x)*mu;
-                  const double dmudy=-beta*(1.-2.*y)*mu;
-                  const double dmudz=-beta*(1.-2.*z)*mu;
-
-
-
-                  force->rhs_u[i][0] = ((y*z+3.*std::pow(x,2)*std::pow(y,3)*z)- mu*(2.+6.*x*y))
-                                       -dmudx*(2.+4.*x+2.*y+6.*std::pow(x,2)*y)
-                                       -dmudy*(x+std::pow(x,3)+y+2.*x*std::pow(y,2))
-                                       -dmudz*(-3.*z-10.*x*y*z);
-
-                  force->rhs_u[i][1] = ((x*z+3.*std::pow(x,3)*std::pow(y,2)*z)- mu*(2.+2.*std::pow(x,2)+2.*std::pow(y,2)))
-                                       -dmudx*(x+std::pow(x,3)+y+2.*x*std::pow(y,2))
-                                       -dmudy*(2.+2.*x+4.*y+4.*std::pow(x,2)*y)
-                                       -dmudz*(-3.*z-5.*std::pow(x,2)*z);
-
-                  force->rhs_u[i][2] = ((x*y+std::pow(x,3)*std::pow(y,3)) - mu*(-10.*y*z))
-                                       -dmudx*(-3.*z-10.*x*y*z)
-                                       -dmudy*(-3.*z-5.*std::pow(x,2)*z)
-                                       -dmudz*(-4.-6.*x-6.*y-10.*std::pow(x,2)*y);
-                }
-
-            }
-
-        }
-
-
-
-
-
-
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        virtual bool is_compressible () const;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-
-        /**
-         * Returns the viscosity value in the inclusion
-         */
-        double get_beta() const;
-
-        /**
-         * viscosity value in the inclusion
-         */
-        double beta;
-    };
-
-
-
-    template <int dim>
-    bool
-    BursteddeMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    BursteddeMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // create a global section in the parameter file for parameters
-      // that describe this benchmark. note that we declare them here
-      // in the material model, but other kinds of plugins (e.g., the gravity
-      // model below) may also read these parameters even though they do not
-      // declare them
-      prm.enter_subsection("Burstedde benchmark");
-      {
-        prm.declare_entry("Viscosity parameter", "20",
-                          Patterns::Double (0),
-                          "Viscosity in the Burstedde benchmark.");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    BursteddeMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Burstedde benchmark");
-      {
-        beta = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-
-    template <int dim>
-    double
-    BursteddeMaterial<dim>::get_beta() const
-    {
-      return beta;
-    }
-
-
-
-
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the paper Duretz et al. reference above.
-      */
-    template <int dim>
-    class BursteddePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        virtual
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics);
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    BursteddePostprocessor<dim>::execute (TableHandler &statistics)
-    {
-      std::unique_ptr<Function<dim>> ref_func;
-      {
-        const BursteddeMaterial<dim> *
-        material_model
-          = dynamic_cast<const BursteddeMaterial<dim> *>(&this->get_material_model());
-
-        ref_func = std::make_unique<AnalyticSolutions::FunctionBurstedde<dim>>(material_model->get_beta());
-      }
-
-      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                          dim+2);
-      ComponentSelectFunction<dim> comp_p(dim, dim+2);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_u,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_p,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_p);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_ul2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_pl2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-      std::ostringstream os;
-      os << std::scientific <<  u_l1
-         << ", " << p_l1
-         << ", " << u_l2
-         << ", " << p_l2;
-
-      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
-    }
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BursteddeBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(BursteddeMaterial,
-                                   "BursteddeMaterial",
-                                   "A material model that corresponds to the `Burstedde' benchmark. "
-                                   "See the manual for more information.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(BursteddeBoundary,
-                                            "BursteddeBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "`Burstedde' benchmark. See the manual for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(BursteddePostprocessor,
-                                  "BursteddePostprocessor",
-                                  "A postprocessor that compares the solution of the `Burstedde' benchmark "
-                                  "with the one computed by ASPECT "
-                                  "and reports the error. See the manual for more information.")
-  }
-}
diff --git a/tests/burstedde_stokes_rhs.prm.bak b/tests/burstedde_stokes_rhs.prm.bak
deleted file mode 100644
index 2ee28267d1e..00000000000
--- a/tests/burstedde_stokes_rhs.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# like burstedde, but using a Stokes RHS instead of BursteddeGravity
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-set Additional shared libraries            = ./libburstedde.so
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-# The setup is a 3d unit cube.
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-    set Z extent  = 1
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:BursteddeBoundary, 1: BursteddeBoundary, 2: BursteddeBoundary, 3: BursteddeBoundary, 4: BursteddeBoundary, 5: BursteddeBoundary
-end
-
-subsection Formulation
-  set Enable additional Stokes RHS            = true
-end
-
-subsection Material model
-  set Model name = BursteddeMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Burstedde benchmark
-  #Viscosity parameter is beta
-  set Viscosity parameter             = 20
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, BursteddePostprocessor
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/cell_reference.cc.bak b/tests/cell_reference.cc.bak
deleted file mode 100644
index cafb6a6f936..00000000000
--- a/tests/cell_reference.cc.bak
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/material_model/simpler.h>
-
-using namespace dealii;
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    class CellMaterial :
-      public aspect::MaterialModel::Simpler<dim>, aspect::SimulatorAccess<dim>
-    {
-      public:
-        void
-        evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                 MaterialModel::MaterialModelOutputs<dim> &out) const
-        {
-          Simpler<dim>::evaluate(in,out);
-
-          if (in.current_cell.state() == IteratorState::valid)
-            {
-              std::cout << "Level: " << in.current_cell->level() << " Index: " << in.current_cell->index() << std::endl;
-            }
-        }
-    };
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(CellMaterial,
-                                   "cell",
-                                   "")
-  }
-}
diff --git a/tests/cell_reference.prm.bak b/tests/cell_reference.prm.bak
deleted file mode 100644
index 9a531fe3e64..00000000000
--- a/tests/cell_reference.prm.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-# This is a copy of simpler_box.prm test,
-# with a slightly modified material model that outputs the
-# cell level and index to check that the cell reference is working
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = cell
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/cells_in_circumference.prm.bak b/tests/cells_in_circumference.prm.bak
deleted file mode 100644
index 8746bc59842..00000000000
--- a/tests/cells_in_circumference.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# Use a mesh with a different number of cells in the circumferential direction.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 5000000
-    set Outer radius = 6371000
-    set Opening angle = 360
-    set Cells along circumference = 20
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Additional refinement times              = 0,0
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/check_compositional_field_functions.cc.bak b/tests/check_compositional_field_functions.cc.bak
deleted file mode 100644
index 1f66d188d94..00000000000
--- a/tests/check_compositional_field_functions.cc.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/parameters.h>
-#include <aspect/material_model/utilities.h>
-
-template <int dim>
-void f(const aspect::SimulatorAccess<dim> &simulator_access,
-       aspect::Assemblers::Manager<dim> &)
-{
-  // This function tests whether the compositional field types are correctly
-  // processed.
-
-  using namespace aspect::MaterialModel;
-
-  aspect::ParameterHandler prm;
-
-  // Fields 0 and 4 are chemical compositions
-  // These are called Field 1 and Field 5
-  const std::vector<unsigned int> indices = simulator_access.introspection().get_indices_for_fields_of_type(aspect::Parameters<dim>::CompositionalFieldDescription::chemical_composition);
-  const std::vector<std::string> names = simulator_access.introspection().get_names_for_fields_of_type(aspect::Parameters<dim>::CompositionalFieldDescription::chemical_composition);
-
-  const std::vector<double> field_values { 0.1, 0.3, 0.3, 0.3, 0.2, 0.3, 0.3};
-  const std::vector<double> compositional_field_fractions = MaterialUtilities::compute_only_composition_fractions(field_values, indices);
-
-  std::cout << "Chemical composition field #0 (the background field) has value " << compositional_field_fractions[0] << "." << std::endl;
-
-  for (unsigned int i=0; i<3; ++i)
-    std::cout << "Chemical composition field #" << i+1 << " is called " << names[i] << ", is in position "  << indices[i] << ", and has value " << compositional_field_fractions[i+1] << "." << std::endl;
-
-  exit(0);
-
-}
-
-template <>
-void f(const aspect::SimulatorAccess<2> &,
-       aspect::Assemblers::Manager<2> &)
-{
-  AssertThrow(false,dealii::ExcInternalError());
-}
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  using namespace dealii;
-  std::cout << "* Connecting signals" << std::endl;
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2));
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/check_compositional_field_functions.prm.bak b/tests/check_compositional_field_functions.prm.bak
deleted file mode 100644
index afe59fe951c..00000000000
--- a/tests/check_compositional_field_functions.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# This test checks whether the compositional field functions are implemented correctly.
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/tests/composite_viscous_outputs.prm
-
-set Additional shared libraries = tests/libcheck_compositional_field_functions.so
-
-subsection Compositional fields
-  set Number of fields = 7
-  set Names of fields =  Field_1, Field_2, Field_3, Field_4, Field_5, Field_6, Field_7
-  set Types of fields =  chemical composition, stress, grain size, porosity, chemical composition, generic, unspecified
-end
diff --git a/tests/check_compositional_field_names.cc.bak b/tests/check_compositional_field_names.cc.bak
deleted file mode 100644
index 4b126e9d0d9..00000000000
--- a/tests/check_compositional_field_names.cc.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/parameters.h>
-
-template <int dim>
-void f(const aspect::SimulatorAccess<dim> &simulator_access,
-       aspect::Assemblers::Manager<dim> &)
-{
-  // This function tests whether the compositional field types are correctly
-  // processed.
-
-  using namespace aspect::MaterialModel;
-
-  aspect::ParameterHandler prm;
-
-  const std::vector<std::string> c_names = simulator_access.introspection().get_composition_names();
-  const std::vector<typename aspect::Parameters<dim>::CompositionalFieldDescription> descriptions = simulator_access.introspection().get_composition_descriptions();
-
-  for (unsigned int i=0; i<simulator_access.introspection().n_compositional_fields; ++i)
-    {
-      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::chemical_composition)
-        std::cout << c_names[i] << " is of type chemical composition" << std::endl;
-      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::grain_size)
-        std::cout << c_names[i] << " is of type grain size" << std::endl;
-      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::porosity)
-        std::cout << c_names[i] << " is of type porosity" << std::endl;
-      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::generic)
-        std::cout << c_names[i] << " is of type generic" << std::endl;
-      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::stress)
-        std::cout << c_names[i] << " is of type stress" << std::endl;
-      if (descriptions[i].type == aspect::Parameters<dim>::CompositionalFieldDescription::unspecified)
-        std::cout << c_names[i] << " is of type unspecified" << std::endl;
-    }
-
-  exit(0);
-
-}
-
-template <>
-void f(const aspect::SimulatorAccess<2> &,
-       aspect::Assemblers::Manager<2> &)
-{
-  AssertThrow(false,dealii::ExcInternalError());
-}
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  using namespace dealii;
-  std::cout << "* Connecting signals" << std::endl;
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2));
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/check_compositional_field_names.prm.bak b/tests/check_compositional_field_names.prm.bak
deleted file mode 100644
index 0fbe38e00bd..00000000000
--- a/tests/check_compositional_field_names.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-# This test checks whether the compositional field names are
-# processed correctly.
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/tests/composite_viscous_outputs.prm
-
-set Additional shared libraries = tests/libcheck_compositional_field_names.so
-
-subsection Compositional fields
-  set Number of fields = 7
-  set Names of fields =  Field_1, Field_2, Field_3, Field_4, Field_5, Field_6, Field_7
-  set Types of fields =  chemical composition, stress, grain size, porosity, chemical composition, generic, unspecified
-end
diff --git a/tests/checkpoint_01.cc.bak b/tests/checkpoint_01.cc.bak
deleted file mode 100644
index 020cad8f414..00000000000
--- a/tests/checkpoint_01.cc.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Launch ASPECT
- * twice to test checkpoint/resume and then terminate the outer ASPECT run.
- */
-int f()
-{
-  std::cout << "* starting from beginning:" << std::endl;
-
-  // call ASPECT with "--" and pipe an existing input file into it.
-  int ret;
-  std::string command;
-
-  command = ("cd output-checkpoint_01 ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_01.prm "
-             " ; "
-             " echo 'set Output directory = output1.tmp' "
-             " ; "
-             " rm -rf output1.tmp ; mkdir output1.tmp "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  command = ("cd output-checkpoint_01 ; "
-             " rm -rf output2.tmp ; mkdir output2.tmp ; "
-             " cp output1.tmp/restart* output2.tmp/");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now resuming:" << std::endl;
-  command = ("cd output-checkpoint_01 ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_01.prm "
-             " ; "
-             " echo 'set Output directory = output2.tmp' "
-             " ; "
-             " echo 'set Resume computation = true' "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  std::cout << "* now comparing:" << std::endl;
-
-  ret = system ("cd output-checkpoint_01 ; "
-                "cp output1.tmp/depth_average.gnuplot depth_average.gnuplot1;"
-                "cp output2.tmp/depth_average.gnuplot depth_average.gnuplot2;"
-                "cp output1.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot1;"
-                "cp output2.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot2;"
-                "cp output1.tmp/log.txt log.txt1;"
-                "cp output2.tmp/log.txt log.txt2;"
-                "cp output1.tmp/statistics statistics1;"
-                "cp output2.tmp/statistics statistics2;"
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // terminate current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/checkpoint_01.prm.bak b/tests/checkpoint_01.prm.bak
deleted file mode 100644
index 512d44620af..00000000000
--- a/tests/checkpoint_01.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# test checkpoint/resume.
-
-# This test is controlled via the plugin in checkpoint_01.cc. The plugin will
-# first execute ASPECT with this .prm and write the output into
-# output1.tmp/. This will generate a snapshot that is then resumed from. The
-# output for this second run will be written into output2.tmp/. Finally,
-# output files will be copied into the main output folder for comparison.
-
-# based on box_end_time_1e7_terminate.prm
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Checkpointing
-  set Steps between checkpoint = 4
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average, visualization, composition statistics, temperature statistics, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = false
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/checkpoint_01_check_parameters.cc.bak b/tests/checkpoint_01_check_parameters.cc.bak
deleted file mode 100644
index 7ee437f4cb0..00000000000
--- a/tests/checkpoint_01_check_parameters.cc.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Launch ASPECT
- * twice to test checkpoint/resume and then terminate the outer ASPECT run.
- */
-int f()
-{
-  std::cout << "* starting from beginning:" << std::endl;
-
-  // call ASPECT with "--" and pipe an existing input file into it.
-  int ret;
-  std::string command;
-
-  command = ("cd output-checkpoint_01_check_parameters ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_01_check_parameters.prm "
-             " ; "
-             " echo 'set Output directory = output1.tmp' "
-             " ; "
-             " rm -rf output1.tmp ; mkdir output1.tmp "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  command = ("cd output-checkpoint_01_check_parameters ; "
-             " rm -rf output2.tmp ; mkdir output2.tmp ; "
-             " cp output1.tmp/restart* output2.tmp/");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now resuming:" << std::endl;
-  command = ("cd output-checkpoint_01_check_parameters ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_01_check_parameters.prm "
-             " ; "
-             " echo 'set Output directory = output2.tmp' "
-             " ; "
-             " echo 'set Resume computation = true' "
-             " ; "
-             //
-             // now also prescribe an incompatible number of compositional fields
-             //
-             " echo 'subsection Compositional fields' "
-             " ; "
-             " echo '  set Number of fields = 3' "
-             " ; "
-             " echo 'end' "
-             " ; "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-
-  // now run ASPECT on this (invalid) input file and output
-  // the expected error code
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now comparing:" << std::endl;
-
-  command = ("cd output-checkpoint_01_check_parameters ; "
-             "cp output1.tmp/log.txt log.txt1;"
-             "cp output1.tmp/statistics statistics1;");
-  ret = system (command.c_str());
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // terminate current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/checkpoint_01_check_parameters.prm.bak b/tests/checkpoint_01_check_parameters.prm.bak
deleted file mode 100644
index 58d08e2eb80..00000000000
--- a/tests/checkpoint_01_check_parameters.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# like the checkpoint_01 test, but try to restart with an incompatible
-# number of compositional fields
-#
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Checkpointing
-  set Steps between checkpoint = 4
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average, visualization, composition statistics, temperature statistics, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = false
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
diff --git a/tests/checkpoint_02.cc.bak b/tests/checkpoint_02.cc.bak
deleted file mode 100644
index 755887dbcb6..00000000000
--- a/tests/checkpoint_02.cc.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-
-/*
- * Launch the following function when this plugin is created. Launch ASPECT
- * twice to test checkpoint/resume and then terminate the outer ASPECT run.
- */
-int f()
-{
-  std::cout << "* starting from beginning:" << std::endl;
-
-  // call ASPECT with "--" and pipe an existing input file into it.
-  int ret;
-
-  ret = system ("cd output-checkpoint_02 ; "
-                "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_02.prm "
-                " ; "
-                " echo 'set Output directory = output1.tmp' "
-                " ; "
-                " rm -rf output1.tmp ; mkdir output1.tmp "
-                ") "
-                "| ../../aspect -- >/dev/null ");
-
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  ret = system ("cd output-checkpoint_02 ; "
-                " rm -rf output2.tmp ; cp -r output1.tmp output2.tmp ;"
-                " rm -f output1.tmp/log.txt; "
-                " cp output1.tmp/restart.mesh.old output1.tmp/restart.mesh;"
-                " cp output1.tmp/restart.mesh.info.old output1.tmp/restart.mesh.info;"
-                " cp output1.tmp/restart.resume.z.old output1.tmp/restart.resume.z;");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now resuming:" << std::endl;
-  ret = system ("cd output-checkpoint_02 ; "
-                "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_02.prm "
-                " ; "
-                " echo 'set Output directory = output1.tmp' "
-                " ; "
-                " echo 'set Resume computation = true' "
-                ") "
-                "| ../../aspect -- >/dev/null");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  std::cout << "* now comparing:" << std::endl;
-
-  ret = system ("cd output-checkpoint_02 ; "
-                "cp output1.tmp/depth_average.gnuplot depth_average.gnuplot1;"
-                "cp output2.tmp/depth_average.gnuplot depth_average.gnuplot2;"
-                "cp output1.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot1;"
-                "cp output2.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot2;"
-                "cp output1.tmp/log.txt log.txt1;"
-                "cp output2.tmp/log.txt log.txt2;"
-                "cp output1.tmp/statistics statistics1;"
-                "cp output2.tmp/statistics statistics2;"
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  ret = system ("cd output-checkpoint_02 ; "
-                "diff -c output?.tmp/restart.resume.z;"
-                "diff -c output?.tmp/restart.mesh;"
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // terminate current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/checkpoint_02.prm.bak b/tests/checkpoint_02.prm.bak
deleted file mode 100644
index a45dcd124c7..00000000000
--- a/tests/checkpoint_02.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# test checkpoint/resume.
-
-# Like checkpoint_01, but we resume from the first of two snapshots. That way
-# we can actually compare if the checkpoint data of the second checkpoint is
-# identical.
-
-# Note: this requires a patch to Trilinos' ML (at least version 12.2.1 and
-# older) because the preconditioner is not deterministic.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.4e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Checkpointing
-  set Steps between checkpoint = 5
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average, visualization, composition statistics, temperature statistics, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = false
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/checkpoint_02_direct.cc.bak b/tests/checkpoint_02_direct.cc.bak
deleted file mode 100644
index 6c1439f300d..00000000000
--- a/tests/checkpoint_02_direct.cc.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-
-/*
- * Launch the following function when this plugin is created. Launch ASPECT
- * twice to test checkpoint/resume and then terminate the outer ASPECT run.
- */
-int f()
-{
-  std::cout << "* starting from beginning:" << std::endl;
-
-  // call ASPECT with "--" and pipe an existing input file into it.
-  int ret;
-
-  ret = system ("cd output-checkpoint_02_direct ; "
-                "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_02_direct.prm "
-                " ; "
-                " echo 'set Output directory = output1.tmp' "
-                " ; "
-                " rm -rf output1.tmp ; mkdir output1.tmp "
-                ") "
-                "| ../../aspect -- >/dev/null ");
-
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  ret = system ("cd output-checkpoint_02_direct ; "
-                " rm -rf output2.tmp ; cp -r output1.tmp output2.tmp ;"
-                " rm -f output1.tmp/log.txt; "
-                " cp output1.tmp/restart.mesh.old output1.tmp/restart.mesh;"
-                " cp output1.tmp/restart.mesh.info.old output1.tmp/restart.mesh.info;"
-                " cp output1.tmp/restart.resume.z.old output1.tmp/restart.resume.z;");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now resuming:" << std::endl;
-  ret = system ("cd output-checkpoint_02_direct ; "
-                "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_02_direct.prm "
-                " ; "
-                " echo 'set Output directory = output1.tmp' "
-                " ; "
-                " echo 'set Resume computation = true' "
-                ") "
-                "| ../../aspect -- >/dev/null");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  std::cout << "* now comparing:" << std::endl;
-
-  ret = system ("cd output-checkpoint_02_direct ; "
-                "cp output1.tmp/depth_average.gnuplot depth_average.gnuplot1;"
-                "cp output2.tmp/depth_average.gnuplot depth_average.gnuplot2;"
-                "cp output1.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot1;"
-                "cp output2.tmp/solution/solution-00009.0000.gnuplot solution-00009.0000.gnuplot2;"
-                "cp output1.tmp/log.txt log.txt1;"
-                "cp output2.tmp/log.txt log.txt2;"
-                "cp output1.tmp/statistics statistics1;"
-                "cp output2.tmp/statistics statistics2;"
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  ret = system ("cd output-checkpoint_02_direct ; "
-                "diff -c output?.tmp/restart.resume.z;"
-                "diff -c output?.tmp/restart.mesh;"
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // terminate current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/checkpoint_02_direct.prm.bak b/tests/checkpoint_02_direct.prm.bak
deleted file mode 100644
index 95b54e0ef4e..00000000000
--- a/tests/checkpoint_02_direct.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# test checkpoint/resume.
-
-# Like checkpoint-02, but using a direct solver.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.4e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Checkpointing
-  set Steps between checkpoint = 5
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average, visualization, composition statistics, temperature statistics, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = false
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/checkpoint_03_particles.cc.bak b/tests/checkpoint_03_particles.cc.bak
deleted file mode 100644
index 754142c6d3e..00000000000
--- a/tests/checkpoint_03_particles.cc.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Launch ASPECT
- * twice to test checkpoint/resume and then terminate the outer ASPECT run.
- */
-int f()
-{
-  std::cout << "* starting from beginning:" << std::endl;
-
-  // call ASPECT with "--" and pipe an existing input file into it.
-  int ret;
-  std::string command;
-
-  command = ("cd output-checkpoint_03_particles ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_03_particles.prm "
-             " ; "
-             " echo 'set Output directory = output1.tmp' "
-             " ; "
-             " rm -rf output1.tmp ; mkdir output1.tmp "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  command = ("cd output-checkpoint_03_particles ; "
-             " rm -rf output2.tmp ; mkdir output2.tmp ; "
-             " cp output1.tmp/restart* output2.tmp/");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now resuming:" << std::endl;
-  command = ("cd output-checkpoint_03_particles ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_03_particles.prm "
-             " ; "
-             " echo 'set Output directory = output2.tmp' "
-             " ; "
-             " echo 'set Resume computation = true' "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  std::cout << "* now comparing:" << std::endl;
-
-  ret = system ("cd output-checkpoint_03_particles ; "
-                "cp output1.tmp/particles/particles-00009.0000.gnuplot particles-00009.0000.gnuplot1;"
-                "cp output2.tmp/particles/particles-00009.0000.gnuplot particles-00009.0000.gnuplot2;"
-                "cp output1.tmp/log.txt log.txt1;"
-                "cp output2.tmp/log.txt log.txt2;"
-                "cp output1.tmp/statistics statistics1;"
-                "cp output2.tmp/statistics statistics2;"
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // terminate current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/checkpoint_03_particles.prm.bak b/tests/checkpoint_03_particles.prm.bak
deleted file mode 100644
index 483a6f84e35..00000000000
--- a/tests/checkpoint_03_particles.prm.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-# test checkpoint/resume.
-
-# This test is controlled via the plugin in checkpoint_03.cc. The plugin will
-# first execute ASPECT with this .prm and write the output into
-# output1.tmp/. This will generate a snapshot that is then resumed from. The
-# output for this second run will be written into output2.tmp/. Finally,
-# output files will be copied into the main output folder for comparison.
-
-# based on checkpoint_01.prm, but extended by particle serialization
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Checkpointing
-  set Steps between checkpoint = 4
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = false
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial position, position, velocity
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1000
-    end
-  end
-end
diff --git a/tests/checkpoint_04_particles_no_output.cc.bak b/tests/checkpoint_04_particles_no_output.cc.bak
deleted file mode 100644
index b8b4db22980..00000000000
--- a/tests/checkpoint_04_particles_no_output.cc.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Launch ASPECT
- * twice to test checkpoint/resume and then terminate the outer ASPECT run.
- */
-int f()
-{
-  std::cout << "* starting from beginning:" << std::endl;
-
-  // call ASPECT with "--" and pipe an existing input file into it.
-  int ret;
-  std::string command;
-
-  command = ("cd output-checkpoint_04_particles_no_output ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_04_particles_no_output.prm "
-             " ; "
-             " echo 'set Output directory = output1.tmp' "
-             " ; "
-             " rm -rf output1.tmp ; mkdir output1.tmp "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  command = ("cd output-checkpoint_04_particles_no_output ; "
-             " rm -rf output2.tmp ; mkdir output2.tmp ; "
-             " cp output1.tmp/restart* output2.tmp/");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now resuming:" << std::endl;
-  command = ("cd output-checkpoint_04_particles_no_output ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_04_particles_no_output.prm "
-             " ; "
-             " echo 'set Output directory = output2.tmp' "
-             " ; "
-             " echo 'set Resume computation = true' "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  std::cout << "* now comparing:" << std::endl;
-
-  ret = system ("cd output-checkpoint_04_particles_no_output ; "
-                "cp output1.tmp/log.txt log.txt1;"
-                "cp output2.tmp/log.txt log.txt2;"
-                "cp output1.tmp/statistics statistics1;"
-                "cp output2.tmp/statistics statistics2;"
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // terminate current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/checkpoint_04_particles_no_output.prm.bak b/tests/checkpoint_04_particles_no_output.prm.bak
deleted file mode 100644
index 1994ec4bb68..00000000000
--- a/tests/checkpoint_04_particles_no_output.prm.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-# test checkpoint/resume.
-
-# This test is controlled via the plugin in checkpoint_03.cc. The plugin will
-# first execute ASPECT with this .prm and write the output into
-# output1.tmp/. This will generate a snapshot that is then resumed from. The
-# output for this second run will be written into output2.tmp/. Finally,
-# output files will be copied into the main output folder for comparison.
-
-# based on checkpoint_01.prm, but extended by particle serialization
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Checkpointing
-  set Steps between checkpoint = 4
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = false
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial position, position, velocity
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1000
-    end
-  end
-end
diff --git a/tests/checkpoint_05_mpi_create.prm.bak b/tests/checkpoint_05_mpi_create.prm.bak
deleted file mode 100644
index df3ba5115c1..00000000000
--- a/tests/checkpoint_05_mpi_create.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-# Like checkpoint_01, but in parallel.
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/checkpoint_01.prm
diff --git a/tests/checkpoint_05_mpi_resume.cc.bak b/tests/checkpoint_05_mpi_resume.cc.bak
deleted file mode 100644
index f9a0881b0f8..00000000000
--- a/tests/checkpoint_05_mpi_resume.cc.bak
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Copy checkpoint
- * files into the correct place to resume model.
- */
-int f()
-{
-  if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) != 0)
-    return 42;
-
-  std::cout << "* Copying checkpoint files." << std::endl;
-
-  std::string command;
-
-  command = ("mkdir -p output-checkpoint_05_mpi_resume; "
-             "cp -r output-checkpoint_05_mpi_create/restart* output-checkpoint_05_mpi_resume/");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  const int ret = system (command.c_str());
-  if (ret!=0)
-    {
-      std::cout << "system() returned error " << ret << std::endl;
-      exit(1);
-    }
-
-  std::cout << "* Finished copying files. Now resuming model." << std::endl;
-
-  return 42;
-}
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/checkpoint_05_mpi_resume.prm.bak b/tests/checkpoint_05_mpi_resume.prm.bak
deleted file mode 100644
index d66f1288f6f..00000000000
--- a/tests/checkpoint_05_mpi_resume.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-# Like checkpoint_01, but in parallel. This test resumes from the checkpoint
-# written by checkpoint_05_mpi_write.  In order for this to work, this test
-# loads a shared library that copies the necessary checkpoint files into the
-# output directory of this test before starting the run.
-#
-# MPI: 2
-# DEPENDS-ON: checkpoint_05_mpi_create
-
-set Dimension = 2
-set Resume computation = true
-
-include $ASPECT_SOURCE_DIR/tests/checkpoint_01.prm
diff --git a/tests/checkpoint_06_spherical_shell.cc.bak b/tests/checkpoint_06_spherical_shell.cc.bak
deleted file mode 100644
index 71991ccfb6e..00000000000
--- a/tests/checkpoint_06_spherical_shell.cc.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Launch ASPECT
- * twice to test checkpoint/resume and then terminate the outer ASPECT run.
- */
-int f()
-{
-  std::cout << "* starting from beginning:" << std::endl;
-
-  // call ASPECT with "--" and pipe an existing input file into it.
-  int ret;
-  std::string command;
-
-  command = ("cd output-checkpoint_06_spherical_shell ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_06_spherical_shell.prm "
-             " ; "
-             " echo 'set Output directory = output1.tmp' "
-             " ; "
-             " rm -rf output1.tmp ; mkdir output1.tmp "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  command = ("cd output-checkpoint_06_spherical_shell ; "
-             " rm -rf output2.tmp ; mkdir output2.tmp ; "
-             " cp output1.tmp/restart* output2.tmp/");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now resuming:" << std::endl;
-  command = ("cd output-checkpoint_06_spherical_shell ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/checkpoint_06_spherical_shell.prm "
-             " ; "
-             " echo 'set Output directory = output2.tmp' "
-             " ; "
-             " echo 'set Resume computation = true' "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  std::cout << "* now comparing:" << std::endl;
-
-  ret = system ("cd output-checkpoint_06_spherical_shell ; "
-                "cp output1.tmp/solution/solution-00005.0000.gnuplot solution-00005.0000.gnuplot1;"
-                "cp output2.tmp/solution/solution-00005.0000.gnuplot solution-00005.0000.gnuplot2;"
-                "cp output1.tmp/log.txt log.txt1;"
-                "cp output2.tmp/log.txt log.txt2;"
-                "cp output1.tmp/statistics statistics1;"
-                "cp output2.tmp/statistics statistics2;"
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // terminate current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/checkpoint_06_spherical_shell.prm.bak b/tests/checkpoint_06_spherical_shell.prm.bak
deleted file mode 100644
index 458aa3bebb1..00000000000
--- a/tests/checkpoint_06_spherical_shell.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# test checkpoint/resume.
-
-# This test is controlled via the plugin in checkpoint_06_spherical_shell.cc. The plugin will
-# first execute ASPECT with this .prm and write the output into
-# output1.tmp/. This will generate a snapshot that is then resumed from. The
-# output for this second run will be written into output2.tmp/. Finally,
-# output files will be copied into the main output folder for comparison.
-
-# based on checkpoint_01, but for the spherical shell geometry, and therefore
-# a different mapping.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 3e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Checkpointing
-  set Steps between checkpoint = 4
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e20
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = surface
-  set Zero velocity boundary indicators       = bottom
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, temperature statistics, velocity statistics
-
-  subsection Visualization
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = false
-end
diff --git a/tests/checkpoint_07_enable_free_surface_create.prm.bak b/tests/checkpoint_07_enable_free_surface_create.prm.bak
deleted file mode 100644
index 9588a7d1288..00000000000
--- a/tests/checkpoint_07_enable_free_surface_create.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# Test to start a model without free surface but with a zero mesh deformation
-# enabled and write a checkpoint (this test).
-# Another test (checkpoint_07_enable_free_surface_resume) will then test to
-# resume from this checkpoint and enable a free surface.
-
-# based on checkpoint_06_free_surface
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 3e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Pressure normalization                 = surface
-
-subsection Checkpointing
-  set Steps between checkpoint = 4
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = none
-
-  subsection Simple model
-    set Viscosity = 1e20
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: boundary function
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top
-  set Zero velocity boundary indicators       = bottom
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, temperature statistics, velocity statistics
-
-  subsection Visualization
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type =  block AMG
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = false
-end
diff --git a/tests/checkpoint_07_enable_free_surface_resume.cc.bak b/tests/checkpoint_07_enable_free_surface_resume.cc.bak
deleted file mode 100644
index 0a67adf5e32..00000000000
--- a/tests/checkpoint_07_enable_free_surface_resume.cc.bak
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Copy checkpoint
- * files into the correct place to resume model.
- */
-int f()
-{
-  if (dealii::Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) != 0)
-    return 42;
-
-  std::cout << "* Copying checkpoint files." << std::endl;
-
-  std::string command;
-
-  command = ("mkdir -p output-checkpoint_07_enable_free_surface_resume; "
-             "cp -r output-checkpoint_07_enable_free_surface_create/restart* output-checkpoint_07_enable_free_surface_resume/");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  const int ret = system (command.c_str());
-  if (ret!=0)
-    {
-      std::cout << "system() returned error " << ret << std::endl;
-      exit(1);
-    }
-
-  std::cout << "* Finished copying files. Now resuming model." << std::endl;
-
-  return 42;
-}
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/checkpoint_07_enable_free_surface_resume.prm.bak b/tests/checkpoint_07_enable_free_surface_resume.prm.bak
deleted file mode 100644
index 442dbe7d106..00000000000
--- a/tests/checkpoint_07_enable_free_surface_resume.prm.bak
+++ /dev/null
@@ -1,31 +0,0 @@
-# Test to start a model without free surface but with a zero mesh deformation
-# enabled and write a checkpoint (this test).
-# Another test (checkpoint_07_enable_free_surface_resume) will then test to
-# resume from this checkpoint and enable a free surface.
-
-# based on checkpoint_06_free_surface
-
-# DEPENDS-ON: checkpoint_07_enable_free_surface_create
-
-include $ASPECT_SOURCE_DIR/tests/checkpoint_07_enable_free_surface_create.prm
-
-set Dimension = 2
-set Resume computation = true
-set Pressure normalization = no
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators =
-end
-
-# Enabling the free surface during the model run can throw off
-# the solver. Loosen the tolerance of the A block preconditioner
-# to allow for solver convergence.
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver A block tolerance = 1e-1
-  end
-end
diff --git a/tests/chunk_ascii_initial_temperature.prm.bak b/tests/chunk_ascii_initial_temperature.prm.bak
deleted file mode 100644
index b3b6212acf0..00000000000
--- a/tests/chunk_ascii_initial_temperature.prm.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-# A simple test that checks the temperature initialization
-# via ascii file in a 2D chunk geometry.
-# Sets a harmonic perturbation to the temperature field,
-# and lower and upper temperature boundary conditions.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Longitude repetitions = 1
-    set Chunk inner radius = 3481000
-    set Chunk outer radius = 6336000
-    set Radius repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = shell_2d.txt
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 0
-    set Outer temperature = 0
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer
-  set Zero velocity boundary indicators       = inner
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-end
diff --git a/tests/chunk_conditions.prm.bak b/tests/chunk_conditions.prm.bak
deleted file mode 100644
index 118a4dd36b8..00000000000
--- a/tests/chunk_conditions.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# A simple test that checks the temperature initialization
-# in a 2D chunk geometry. Sets a harmonic perturbation to
-# the temperature field, and lower and upper temperature
-# boundary conditions.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 60
-    set Chunk maximum longitude = 120
-    set Longitude repetitions = 1
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 1800
-    set Outer temperature = 273
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer
-  set Zero velocity boundary indicators       = inner
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-end
diff --git a/tests/chunk_cross_hemisphere.prm.bak b/tests/chunk_cross_hemisphere.prm.bak
deleted file mode 100644
index 903fb07eac8..00000000000
--- a/tests/chunk_cross_hemisphere.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# An input script to test the chunk geometry model
-# where the domain crosses both hemispheres.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = -10
-    set Chunk maximum longitude = 220
-    set Longitude repetitions = 2
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer, east, west
-  set Zero velocity boundary indicators       = inner
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics
-end
diff --git a/tests/chunk_first_time_step_2d.prm.bak b/tests/chunk_first_time_step_2d.prm.bak
deleted file mode 100644
index 9c34b84f55f..00000000000
--- a/tests/chunk_first_time_step_2d.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# An input script to test the chunk geometry model
-# Designed to check the mesh set-up in 2D
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 30
-    set Longitude repetitions = 1
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer
-  set Zero velocity boundary indicators       = inner
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics
-end
diff --git a/tests/chunk_first_time_step_3d.prm.bak b/tests/chunk_first_time_step_3d.prm.bak
deleted file mode 100644
index a512ae929d6..00000000000
--- a/tests/chunk_first_time_step_3d.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# An input script to test the chunk geometry model
-# Designed to check the mesh set-up in 3D
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = -20
-    set Chunk maximum longitude = 20
-    set Longitude repetitions = 1
-    set Chunk minimum latitude = -10
-    set Chunk maximum latitude = 10
-    set Latitude repetitions = 1
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer
-  set Zero velocity boundary indicators       = inner, west, east
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics
-end
diff --git a/tests/chunk_initial_topography_ascii_data.prm.bak b/tests/chunk_initial_topography_ascii_data.prm.bak
deleted file mode 100644
index 0401f46466b..00000000000
--- a/tests/chunk_initial_topography_ascii_data.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# An input script to test the chunk geometry model
-# with additional initial topography.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Longitude repetitions = 1
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-      set Data file name       = shell_2d_outer.0.txt
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer, east, west
-  set Zero velocity boundary indicators       = inner
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, topography
-end
diff --git a/tests/chunk_initial_topography_ascii_data_3d.prm.bak b/tests/chunk_initial_topography_ascii_data_3d.prm.bak
deleted file mode 100644
index 95d540c3b4c..00000000000
--- a/tests/chunk_initial_topography_ascii_data_3d.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# An input script to test the chunk geometry model
-# with additional initial topography.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = -20
-    set Chunk maximum longitude = 20
-    set Longitude repetitions = 1
-    set Chunk minimum latitude = -20
-    set Chunk maximum latitude = 20
-    set Latitude repetitions = 1
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-      set Data file name       = shell_3d_outer.0.txt
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer, east, west, north, south
-  set Zero velocity boundary indicators       = inner
-end
-
-# The ascii data file prescribes a topography between -2000 m and
-# +9000 m. The topography postprocessor output should match with this.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, topography
-end
diff --git a/tests/chunk_initial_topography_ascii_data_3d_colatitude.prm.bak b/tests/chunk_initial_topography_ascii_data_3d_colatitude.prm.bak
deleted file mode 100644
index 7f074c69fb7..00000000000
--- a/tests/chunk_initial_topography_ascii_data_3d_colatitude.prm.bak
+++ /dev/null
@@ -1,19 +0,0 @@
-# An input script to test the chunk geometry model
-# with additional initial topography with a gradient
-# in the latitudinal direction.
-include $ASPECT_SOURCE_DIR/tests/chunk_initial_topography_ascii_data_3d.prm
-
-set Dimension                       = 3
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-      set Data file name       = shell_3d_outer_2.0.txt
-    end
-  end
-end
diff --git a/tests/chunk_lithostatic_pressure_2d.prm.bak b/tests/chunk_lithostatic_pressure_2d.prm.bak
deleted file mode 100644
index b2714dd2e9d..00000000000
--- a/tests/chunk_lithostatic_pressure_2d.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-# In this test we prescribe a lithostatic pressure
-# for the traction on the eastern boundary of the
-# chunk geometry. This boundary condition is known
-# as "open". However, there are no lateral variations
-# in density, so with increasing resolution,
-# velocity should go to zero.
-
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600
-set Surface pressure                       = 0
-set Pressure normalization                 = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-# Because the eastern boundary is open and material might
-# move through it,
-# we set fixed temperature and composition boundary conditions.
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = inner, outer, east
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = inner, outer, east
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3471000
-    set Chunk outer radius = 6371000
-    set Chunk minimum longitude = 10
-    set Chunk maximum longitude = 50
-    set Chunk minimum latitude = 0
-    set Chunk maximum latitude = 40
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.600e3
-  end
-end
-
-# We prescribe one compositional field
-# to represent the lithosphere
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities                  = 3300,3250
-    set Reference temperature      = 293
-    set Specific heats             = 1250
-    set Thermal conductivities     = 4.7
-    set Thermal expansivities      = 2e-5
-    set Viscosities                = 1e21,1e24
-    set Viscosity averaging scheme = harmonic
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system = spherical
-    set Function expression = if (y > 45.0*pi/180.0, 4, 3)
-  end
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = east: initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Representative point =  6371000, 50, 40
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, outer, west, north, south
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = lith_depth=8e4, model_height=6e5
-    set Function expression = if(z>=(model_height-lith_depth),-1,0);0
-  end
-end
-
-# The lithosphere is represented by a lower density,
-# higher viscosity compositional field.
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y,z
-    set Function constants = lith_depth=100e3, model_height=6e5
-    set Function expression = if(sqrt(x*x+y*y+z*z)<(6.371e6-lith_depth),0,1)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, visualization
-
-  subsection Visualization
-    set Point-wise stress and strain = true
-    set Interpolate output = false
-    set Output format = gnuplot
-    set List of output variables = stress, strain rate, nonadiabatic pressure
-  end
-end
diff --git a/tests/chunk_lithostatic_pressure_2d_initial_topography.prm.bak b/tests/chunk_lithostatic_pressure_2d_initial_topography.prm.bak
deleted file mode 100644
index 8f7243b24fb..00000000000
--- a/tests/chunk_lithostatic_pressure_2d_initial_topography.prm.bak
+++ /dev/null
@@ -1,46 +0,0 @@
-# In this variation on chunk_lithostatic_pressure_2d.prm
-# we test whether the point_is_in_domain function
-# handles the initial topography correctly. We therefore
-# add an initial topography and pick a representative point
-# for the initial lithostatic pressure that lies above
-# the unperturbed surface but below the surface plus
-# initial topography.
-
-include $ASPECT_SOURCE_DIR/tests/chunk_lithostatic_pressure_2d.prm
-
-set Dimension = 2
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3471000
-    set Chunk outer radius = 6371000
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 50
-  end
-
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-      set Data file name       = shell_2d_outer.0.txt
-    end
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, outer, west
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = east: initial lithostatic pressure
-
-  # Set a radius between 6371 and 6461 km (surface radius
-  # without and with 90 km initial topography at 0 degrees longitude.
-  subsection Initial lithostatic pressure
-    set Representative point =  6394000, 0.1
-  end
-end
diff --git a/tests/chunk_tangential_velocity.prm.bak b/tests/chunk_tangential_velocity.prm.bak
deleted file mode 100644
index 49b03af1694..00000000000
--- a/tests/chunk_tangential_velocity.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# This test makes sure the issue discussed in
-# https://github.com/geodynamics/aspect/issues/3359
-# has been fixed (accurate tangential velocity
-# boundary conditions for models with chunk
-# geometry and a free surface boundary).
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 273
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Pressure normalization                 = no
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 8.e18
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Chunk inner radius = 5620.e3
-    set Chunk outer radius = 6370.e3
-    set Longitude repetitions = 13
-    set Radius repetitions = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.8
-  end
-end
-
-subsection Mesh deformation
-  set Additional tangential mesh velocity boundary indicators = east,west
-  set Mesh deformation boundary indicators = outer:free surface
-
-  subsection Free surface
-    set Surface velocity projection      = normal
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, west, east
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = outer: function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r,theta,t
-    set Function expression = 0;0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Outer temperature = 273
-    set Inner temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = minimum refinement function
-end
-
-subsection Postprocess
-  set List of postprocessors = topography, velocity statistics, heat flux statistics
-end
diff --git a/tests/chunk_topography_postprocessor.prm.bak b/tests/chunk_topography_postprocessor.prm.bak
deleted file mode 100644
index 1c2e3d6187a..00000000000
--- a/tests/chunk_topography_postprocessor.prm.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-# This test computes min/max topography
-# for a chunk with a free surface.
-
-set Dimension = 2
-set CFL number                             = 0.1
-set End time                               = 1e9
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = inner:0,outer:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-    set Longitude repetitions = 2
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-3000.e3)^2 + (y-3000.e3)^2 ) < 500.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner, east, west
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = outer: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/command_postprocessor.prm.bak b/tests/command_postprocessor.prm.bak
deleted file mode 100644
index ddafc95f81a..00000000000
--- a/tests/command_postprocessor.prm.bak
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test that ASPECT executes a shell command using the
-# command postprocessor.
-
-set Dimension = 2
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = box
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = command
-
-  subsection Command
-    set Command = /bin/bash -c "echo 'Hello, world'"
-    set Run on all processes = false
-    set Terminate on failure = false
-  end
-end
diff --git a/tests/compaction_length_refinement.prm.bak b/tests/compaction_length_refinement.prm.bak
deleted file mode 100644
index 6ec413f239a..00000000000
--- a/tests/compaction_length_refinement.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# Test the compaction length refinement criterion.
-# The compaction length is 1 at the lower left boundary,
-# and two magnitudes smaller at the top right boundary,
-# and we specify two cells per compaction length.
-# Hence, the finest cells should be on refinement level 8,
-# and in the top right corner.
-# The permeability changes along the x axis, the viscosity
-# along the y axis.
-
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 20
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 1 + 4.605170186 * y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5 - 0.4286 * x; 0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Thermal conductivity              = 0
-    set Reference solid density           = 1
-    set Reference melt density            = 1
-    set Thermal expansion coefficient     = 0
-    set Reference permeability            = 32 #permeability of 1 for phi=0.5
-    set Reference shear viscosity         = 0.5
-    set Reference bulk viscosity          = 0.375
-    set Exponential melt weakening factor = 0
-    set Thermal viscosity exponent        = 1
-    set Thermal bulk viscosity exponent   = 1
-    set Reference temperature             = 1
-    set Solid compressibility             = 0
-    set Melt compressibility              = 0
-    set Reference melt viscosity          = 1
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.5
-  set Refinement fraction                      = 0.5
-  set Initial adaptive refinement              = 5
-  set Initial global refinement                = 5
-  set Strategy                                 = compaction length
-  set Time steps between mesh refinement       = 0
-
-  subsection Compaction length
-    set Mesh cells per compaction length       = 2
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
diff --git a/tests/compaction_length_visualization.prm.bak b/tests/compaction_length_visualization.prm.bak
deleted file mode 100644
index 9129c4af5d3..00000000000
--- a/tests/compaction_length_visualization.prm.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-# Tests the compaction length visualization plugin.
-# Based on compaction_length_refinement.prm
-
-
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 20
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 1 + 4.605170186 * y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5 - 0.4286 * x; 0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Thermal conductivity              = 0
-    set Reference solid density           = 1
-    set Reference melt density            = 1
-    set Thermal expansion coefficient     = 0
-    set Reference permeability            = 32 #permeability of 1 for phi=0.5
-    set Reference shear viscosity         = 0.5
-    set Reference bulk viscosity          = 0.375
-    set Exponential melt weakening factor = 0
-    set Thermal viscosity exponent        = 1
-    set Thermal bulk viscosity exponent   = 1
-    set Reference temperature             = 1
-    set Solid compressibility             = 0
-    set Melt compressibility              = 0
-    set Reference melt viscosity          = 1
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.5
-  set Refinement fraction                      = 0.5
-  set Initial adaptive refinement              = 5
-  set Initial global refinement                = 5
-  set Strategy                                 = compaction length
-  set Time steps between mesh refinement       = 0
-
-  subsection Compaction length
-    set Mesh cells per compaction length       = 2
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity, compaction length, is melt cell
-    end
-  end
-end
diff --git a/tests/composite_viscous_outputs.cc.bak b/tests/composite_viscous_outputs.cc.bak
deleted file mode 100644
index d06d7d4917c..00000000000
--- a/tests/composite_viscous_outputs.cc.bak
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/material_model/rheology/composite_visco_plastic.h>
-
-template <int dim>
-void f(const aspect::SimulatorAccess<dim> &simulator_access,
-       aspect::Assemblers::Manager<dim> &)
-{
-  // This function tests whether the composite creep rheology is producing
-  // the correct composite viscosity and partial strain rates corresponding to
-  // the different creep mechanisms incorporated into the rheology.
-  // It is assumed that each individual creep mechanism has already been tested.
-
-  using namespace aspect::MaterialModel;
-
-  // First, we set up a few objects which are used by the rheology model.
-  aspect::ParameterHandler prm;
-  const std::vector<std::string> list_of_composition_names = simulator_access.introspection().get_composition_names();
-  auto n_phases = std::make_unique<std::vector<unsigned int>>(1); // 1 phase per composition
-  const unsigned int composition = 0;
-  const std::vector<double> volume_fractions = {1.};
-  const std::vector<double> phase_function_values = std::vector<double>();
-  const std::vector<unsigned int> n_phase_transitions_per_composition = std::vector<unsigned int>(1);
-
-  // Next, we initialise instances of the composite rheology and
-  // individual creep mechanisms.
-  std::unique_ptr<Rheology::CompositeViscoPlastic<dim>> composite_creep;
-  composite_creep = std::make_unique<Rheology::CompositeViscoPlastic<dim>>();
-  composite_creep->initialize_simulator (simulator_access.get_simulator());
-  composite_creep->declare_parameters(prm);
-  prm.set("Use plastic damper", "true");
-  prm.set("Plastic damper viscosity", "1.e17");
-  prm.set("Maximum yield stress", "5e8");
-  composite_creep->parse_parameters(prm, n_phases);
-
-  std::unique_ptr<Rheology::DiffusionCreep<dim>> diffusion_creep;
-  diffusion_creep = std::make_unique<Rheology::DiffusionCreep<dim>>();
-  diffusion_creep->initialize_simulator (simulator_access.get_simulator());
-  diffusion_creep->declare_parameters(prm);
-  diffusion_creep->parse_parameters(prm, n_phases);
-
-  std::unique_ptr<Rheology::DislocationCreep<dim>> dislocation_creep;
-  dislocation_creep = std::make_unique<Rheology::DislocationCreep<dim>>();
-  dislocation_creep->initialize_simulator (simulator_access.get_simulator());
-  dislocation_creep->declare_parameters(prm);
-  dislocation_creep->parse_parameters(prm, n_phases);
-
-  std::unique_ptr<Rheology::PeierlsCreep<dim>> peierls_creep;
-  peierls_creep = std::make_unique<Rheology::PeierlsCreep<dim>>();
-  peierls_creep->initialize_simulator (simulator_access.get_simulator());
-  peierls_creep->declare_parameters(prm);
-  peierls_creep->parse_parameters(prm, n_phases);
-
-  std::unique_ptr<Rheology::DruckerPrager<dim>> drucker_prager;
-  drucker_prager = std::make_unique<Rheology::DruckerPrager<dim>>();
-  drucker_prager->initialize_simulator (simulator_access.get_simulator());
-  drucker_prager->declare_parameters(prm);
-  prm.set("Use plastic damper", "true");
-  prm.set("Plastic damper viscosity", "1.e17");
-  prm.set("Maximum yield stress", "5e8");
-  drucker_prager->parse_parameters(prm, n_phases);
-  Rheology::DruckerPragerParameters p = drucker_prager->compute_drucker_prager_parameters(composition, phase_function_values, n_phase_transitions_per_composition);
-
-  // The creep components are arranged in series with each other.
-  // This package of components is then arranged in parallel with
-  // a strain rate limiter with a constant viscosity lim_visc.
-  // The whole system is then arranged in series with a viscosity limiter with
-  // viscosity max_visc.
-  // lim_visc is equal to (min_visc*max_visc)/(max_visc - min_visc)
-  double min_visc = prm.get_double("Minimum viscosity");
-  double max_visc = prm.get_double("Maximum viscosity");
-  double lim_visc = (min_visc*max_visc)/(max_visc - min_visc);
-
-  // Assign values to the variables which will be passed to compute_viscosity
-  // The test involves pure shear calculations at 1 GPa and variable temperature
-  double temperature;
-  const double pressure = 1.e9;
-  SymmetricTensor<2,dim> strain_rate;
-  strain_rate[0][0] = -1e-11;
-  strain_rate[0][1] = 0.;
-  strain_rate[1][1] = 1e-11;
-  strain_rate[2][0] = 0.;
-  strain_rate[2][1] = 0.;
-  strain_rate[2][2] = 0.;
-
-  std::cout << "temperature (K)   eta (Pas)   creep stress (Pa)   edot_ii (/s)   edot_ii fractions (diff, disl, prls, drpr, max)" << std::endl;
-
-  // Loop through strain rates, tracking whether there is a discrepancy in
-  // the decomposed strain rates.
-  bool error = false;
-  double viscosity;
-  double total_strain_rate;
-  double creep_strain_rate;
-  double creep_stress;
-  double diff_stress;
-  double disl_stress;
-  double prls_stress;
-  double drpr_stress;
-  std::vector<double> partial_strain_rates(5, 0.);
-
-  for (unsigned int i=0; i <= 10; i++)
-    {
-      temperature = 1000. + i*100.;
-
-      // Compute the viscosity
-      viscosity = composite_creep->compute_composition_viscosity(pressure, temperature, composition, strain_rate, partial_strain_rates);
-      total_strain_rate = std::accumulate(partial_strain_rates.begin(), partial_strain_rates.end(), 0.);
-
-      // The creep strain rate is calculated by subtracting the strain rate
-      // of the max viscosity dashpot from the total strain rate
-      // The creep stress is then calculated by subtracting the stress running
-      // through the strain rate limiter from the total stress
-      creep_strain_rate = total_strain_rate - partial_strain_rates[4];
-      creep_stress = 2.*(viscosity*total_strain_rate - lim_visc*creep_strain_rate);
-
-      // Print the output
-      std::cout << temperature << ' ' << viscosity << ' ' << creep_stress << ' ' << total_strain_rate;
-      for (unsigned int i=0; i < partial_strain_rates.size(); ++i)
-        {
-          std::cout << ' ' << partial_strain_rates[i]/total_strain_rate;
-        }
-      std::cout << std::endl;
-
-      // The following lines test that each individual creep mechanism
-      // experiences the same creep stress
-
-      // Each creep mechanism should experience the same stress
-      diff_stress = 2.*partial_strain_rates[0]*diffusion_creep->compute_viscosity(pressure, temperature, composition);
-      disl_stress = 2.*partial_strain_rates[1]*dislocation_creep->compute_viscosity(partial_strain_rates[1], pressure, temperature, composition);
-      prls_stress = 2.*partial_strain_rates[2]*peierls_creep->compute_viscosity(partial_strain_rates[2], pressure, temperature, composition);
-      if (partial_strain_rates[3] > 0.)
-        {
-          drpr_stress = 2.*partial_strain_rates[3]*drucker_prager->compute_viscosity(p.cohesion,
-                                                                                     p.angle_internal_friction,
-                                                                                     pressure,
-                                                                                     partial_strain_rates[3],
-                                                                                     p.max_yield_stress,
-                                                                                     std::numeric_limits<double>::infinity());
-        }
-      else
-        {
-          drpr_stress = creep_stress;
-        }
-
-      if ((std::fabs((diff_stress - creep_stress)/creep_stress) > 1e-6)
-          || (std::fabs((disl_stress - creep_stress)/creep_stress) > 1e-6)
-          || (std::fabs((prls_stress - creep_stress)/creep_stress) > 1e-6)
-          || (std::fabs((drpr_stress - creep_stress)/creep_stress) > 1e-6))
-        {
-          error = true;
-          std::cout << "   creep stress: " << creep_stress;
-          std::cout << " diffusion stress: " << diff_stress;
-          std::cout << " dislocation stress: " << disl_stress;
-          std::cout << " peierls stress: " << prls_stress;
-          std::cout << " drucker prager stress: " << drpr_stress << std::endl;
-        }
-    }
-
-  if (error)
-    {
-      std::cout << "   Error: The individual creep stresses differ by more than the required tolerance." << std::endl;
-      std::cout << "Some parts of the test were not successful." << std::endl;
-    }
-  else
-    {
-      std::cout << "OK" << std::endl;
-    }
-
-}
-
-template <>
-void f(const aspect::SimulatorAccess<2> &,
-       aspect::Assemblers::Manager<2> &)
-{
-  AssertThrow(false,dealii::ExcInternalError());
-}
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  using namespace dealii;
-  std::cout << "* Connecting signals" << std::endl;
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2));
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/composite_viscous_outputs.prm.bak b/tests/composite_viscous_outputs.prm.bak
deleted file mode 100644
index 2b8963c6d83..00000000000
--- a/tests/composite_viscous_outputs.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# This test checks whether the composite viscous rheology
-# plugin produces the correct composite viscosity and
-# decomposed strain rates.
-
-set Additional shared libraries = tests/libcomposite_viscous_outputs.so
-set Dimension                              = 3
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Angles of internal friction = 30.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
diff --git a/tests/compositing_02.prm.bak b/tests/compositing_02.prm.bak
deleted file mode 100644
index 72b2e636831..00000000000
--- a/tests/compositing_02.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-# Test compositing material model with Steinberger
-#
-# copy of steinberger_seismic_velocities.prm
-#
-# This was broken because a call to initialize() to the models was missing in
-# the compositing model/
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = compositing
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names              = pyr-ringwood88.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-  end
-
-  subsection Compositing
-    set Viscosity = simple
-    set Density = Steinberger
-    set Thermal expansion coefficient = Steinberger
-    set Specific heat = Steinberger
-    set Thermal conductivity = Steinberger
-    set Compressibility = Steinberger
-    set Entropy derivative pressure = Steinberger
-    set Entropy derivative temperature = Steinberger
-    set Reaction terms = Steinberger
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = named additional outputs, Vs anomaly, Vp anomaly
-    set Time between graphical output = 0
-
-    subsection Vp anomaly
-      set Number of depth slices = 96
-    end
-
-    subsection Vs anomaly
-      set Number of depth slices = 96
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/compositing_named_outputs.prm.bak b/tests/compositing_named_outputs.prm.bak
deleted file mode 100644
index 3e212dce3cf..00000000000
--- a/tests/compositing_named_outputs.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# Compositing material model with named outputs
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = compositing
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-
-  subsection Compositing
-    set Viscosity = simple
-    set Density = visco plastic
-    set Thermal expansion coefficient = simple
-    set Specific heat = simple
-    set Thermal conductivity = simple
-    set Compressibility = simple
-    set Entropy derivative pressure = simple
-    set Entropy derivative temperature = simple
-    set Reaction terms = simple
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density, named additional outputs
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/composition_active.prm.bak b/tests/composition_active.prm.bak
deleted file mode 100644
index caed2044777..00000000000
--- a/tests/composition_active.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-#########################################################
-# This is a variation of the platelike_boundary.prm file.
-# All settings are exactly the same with the exception
-# of the ones that pertain to compositional fields.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 4
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/tests/composition_active_nans.prm.bak b/tests/composition_active_nans.prm.bak
deleted file mode 100644
index 8bc5ff24ceb..00000000000
--- a/tests/composition_active_nans.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# When using the 'artificial viscosity' viz postprocessor in parallel,
-# we used to put NaNs into the output vector (for ghost and artificial
-# cells) that then triggered floating point exceptions. Check that
-# this no longer happens. For this, all we need to do is get past the
-# first time we create graphical output.
-
-# MPI: 2
-
-include $ASPECT_SOURCE_DIR/tests/composition_active.prm
-
-set End time                               = 0.1
-
-subsection Postprocess
-  subsection Visualization
-    set List of output variables = density, artificial viscosity, artificial viscosity composition
-
-    subsection Artificial viscosity composition
-      set Name of compositional field = C_1
-    end
-  end
-end
diff --git a/tests/composition_active_with_melt.cc.bak b/tests/composition_active_with_melt.cc.bak
deleted file mode 100644
index 9e99dfd3ab8..00000000000
--- a/tests/composition_active_with_melt.cc.bak
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/melt.h>
-#include <deal.II/base/parameter_handler.h>
-
-/**
- * This material model extends the simple material model
- * to include melt transport.
- */
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim>
-  class SimpleWithMelt:
-    public MaterialModel::MeltInterface<dim>
-  {
-    public:
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        return 1.0;
-      }
-
-
-      /**
-       * Declare the parameters this class takes through input files.
-       */
-      static
-      void
-      declare_parameters (ParameterHandler &prm);
-
-      /**
-       * Read the parameters this class declares from the parameter file.
-       */
-      virtual
-      void
-      parse_parameters (ParameterHandler &prm);
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            out.viscosities[i] = 1.0;
-            out.thermal_expansion_coefficients[i] = 0.01;
-            out.specific_heat[i] = 1250.0;
-            out.thermal_conductivities[i] = 1e-6;
-            out.compressibilities[i] = 0.0;
-            out.densities[i] = 1.0 * (1 - out.thermal_expansion_coefficients[i] * in.temperature[i])
-                               + compositional_delta_rho*std::max(in.composition[i][0],0.0);
-
-            // Pressure derivative of entropy at the given positions.
-            out.entropy_derivative_pressure[i] = 0.0;
-            // Temperature derivative of entropy at the given positions.
-            out.entropy_derivative_temperature[i] = 0.0;
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                melt_out->compaction_viscosities[i] = 1.0;
-                melt_out->fluid_viscosities[i] = 1.0;
-                melt_out->permeabilities[i] = 0.0; //1e-30*porosity * porosity;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-                melt_out->fluid_densities[i] = 1.0;
-              }
-          }
-      }
-
-    private:
-      double compositional_delta_rho;
-
-  };
-
-  template <int dim>
-  void
-  SimpleWithMelt<dim>::declare_parameters (ParameterHandler &prm)
-  {
-    prm.enter_subsection("Material model");
-    {
-      prm.enter_subsection("Simple with melt");
-      {
-        prm.declare_entry ("Density differential for compositional field 1", "100.0",
-                           Patterns::Double(),
-                           "If compositional fields are used, then one would frequently want "
-                           "to make the density depend on these fields. In this simple material "
-                           "model, we make the following assumptions: if no compositional fields "
-                           "are used in the current simulation, then the density is simply the usual "
-                           "one with its linear dependence on the temperature. If there are compositional "
-                           "fields, then the density only depends on the first one in such a way that "
-                           "the density has an additional term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
-                           "This parameter describes the value of $\\Delta \\rho$. "
-                           "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection();
-  }
-
-
-
-  template <int dim>
-  void
-  SimpleWithMelt<dim>::parse_parameters (ParameterHandler &prm)
-  {
-    prm.enter_subsection("Material model");
-    {
-      prm.enter_subsection("Simple with melt");
-      {
-        compositional_delta_rho    = prm.get_double ("Density differential for compositional field 1");
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection();
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_MATERIAL_MODEL(SimpleWithMelt,
-                                 "simple with melt",
-                                 "A simple material model that is like the "
-                                 "'simple' model, but with melt migration.")
-}
diff --git a/tests/composition_active_with_melt.prm.bak b/tests/composition_active_with_melt.prm.bak
deleted file mode 100644
index 641bcbcb0b5..00000000000
--- a/tests/composition_active_with_melt.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-#########################################################
-# This is a variation of the platelike-boundary.prm file.
-# It is identical to the composition-active test, except
-# for the second compositional field, which is called
-# porosity and set to zero, and Include melt transport is
-# set to true. Result can be compared to the test
-# composition-active-without-melt.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-  set Use discontinuous compaction pressure   = false
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple with melt
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, composition statistics
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = C_1, porosity
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ;  0.0
-  end
-end
diff --git a/tests/composition_active_without_melt.cc.bak b/tests/composition_active_without_melt.cc.bak
deleted file mode 100644
index 7fdcf9950f6..00000000000
--- a/tests/composition_active_without_melt.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "composition_active_with_melt.cc"
diff --git a/tests/composition_active_without_melt.prm.bak b/tests/composition_active_without_melt.prm.bak
deleted file mode 100644
index 66b93bad723..00000000000
--- a/tests/composition_active_without_melt.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-#########################################################
-# This is a variation of the platelike-boundary.prm file.
-# It is identical to the composition-active test, except
-# for the second compositional field, which is called
-# porosity and set to zero. This is for comparison to
-# models with melt migration.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple with melt
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, composition statistics
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = C_1, porosity
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ;  0.0
-  end
-end
diff --git a/tests/composition_cg_dg_fem.prm.bak b/tests/composition_cg_dg_fem.prm.bak
deleted file mode 100644
index 4959bbadef3..00000000000
--- a/tests/composition_cg_dg_fem.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-#
-#
-# copied from discontinuous_composition_1.prm
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 2
-end
-
-subsection Discretization
-  set Use discontinuous temperature discretization = false
-  set Use discontinuous composition discretization = true,false
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, composition statistics
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/tests/composition_names.prm.bak b/tests/composition_names.prm.bak
deleted file mode 100644
index 5245dffc549..00000000000
--- a/tests/composition_names.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-# test composition names
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = peridotite, eclogite
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/composition_names_duplicates.prm.bak b/tests/composition_names_duplicates.prm.bak
deleted file mode 100644
index 1058f9c3eb7..00000000000
--- a/tests/composition_names_duplicates.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# A test to ensure the naming of compositional fields works as expected.
-
-# EXPECT FAILURE
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Dimension                              = 2
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = peridotite, density
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,3
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Maximal temperature = 3773
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = material properties
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/composition_passive_discontinuous_constant.prm.bak b/tests/composition_passive_discontinuous_constant.prm.bak
deleted file mode 100644
index cf39800564f..00000000000
--- a/tests/composition_passive_discontinuous_constant.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# This is a variation of the composition_passive_passive.prm
-# test that uses a DGQ0 (cell-wise constant) composition element.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Discretization
-  set Composition polynomial degree = 0
-  set Use discontinuous composition discretization = true
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average only viscosity
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.1
-    set Output format                 = gnuplot
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields with same initial condition
-# and only the first one will be advected along.
-subsection Compositional fields
-  set Number of fields = 1
-  set Compositional field methods = field
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0)
-  end
-end
diff --git a/tests/composition_passive_particles.prm.bak b/tests/composition_passive_particles.prm.bak
deleted file mode 100644
index 6c54199b045..00000000000
--- a/tests/composition_passive_particles.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-#########################################################
-# This is a variation of the composition_passive.prm
-# parameter file, with the exception that we also
-# advect along a set of particles and that we do not longer
-# compute temperature statistics and composition statistics
-# as part of postprocessing
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format = vtu
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
-
-subsection Particles
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/composition_passive_quarter_shell_cartesian.prm.bak b/tests/composition_passive_quarter_shell_cartesian.prm.bak
deleted file mode 100644
index 11e38f25dce..00000000000
--- a/tests/composition_passive_quarter_shell_cartesian.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-#########################################################
-# This is a variation of the platelike-boundary.prm file.
-# All settings are exactly the same with the exception
-# of the ones that pertain to compositional fields.
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-set Output directory                       = output_composition-passive_quarter-shell-cartesian
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = .45
-    set Outer radius  = 1
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, inner, outer
-  set Prescribed velocity boundary indicators =   #outer: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system   = spherical
-    set Variable names      = r, phi
-    set Function expression = (1-r)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Coordinate system   = cartesian
-    set Function expression = if ((x > 0.6 && x < 0.8 && y > 0.1 && y < 0.5), 1, 0) ; if ((x > 0.5 && x < 0.6 && y > 0.1 && y < 0.5), 1, 0)
-  end
-end
diff --git a/tests/composition_passive_quarter_shell_depth.prm.bak b/tests/composition_passive_quarter_shell_depth.prm.bak
deleted file mode 100644
index 1d19d63ef70..00000000000
--- a/tests/composition_passive_quarter_shell_depth.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-#########################################################
-# This is a variation of the platelike-boundary.prm file.
-# All settings are exactly the same with the exception
-# of the ones that pertain to compositional fields.
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-set Output directory                       = output_composition-passive_quarter-shell-depth
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = .45
-    set Outer radius  = 1
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, inner, outer
-  set Prescribed velocity boundary indicators =   #outer: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system   = spherical
-    set Variable names      = r, phi
-    set Function expression = (1-r)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = d,na
-    set Coordinate system   = depth
-    set Function expression = if (d > 0.1 && d < 0.2 , 1, 0) ; if (d < 0.4 && d > 0.3, 1, 0)
-  end
-end
diff --git a/tests/composition_passive_quarter_shell_spherical.prm.bak b/tests/composition_passive_quarter_shell_spherical.prm.bak
deleted file mode 100644
index cfadb1c1b53..00000000000
--- a/tests/composition_passive_quarter_shell_spherical.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-#########################################################
-# This is a variation of the platelike-boundary.prm file.
-# All settings are exactly the same with the exception
-# of the ones that pertain to compositional fields.
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20
-set Use years in output instead of seconds = false
-set Output directory                       = output_composition-passive_quarter-shell-spherical
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = .45
-    set Outer radius  = 1
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, inner, outer
-  set Prescribed velocity boundary indicators =   #outer: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system   = spherical
-    set Variable names      = r, phi
-    set Function expression = (1-r)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = r,phi
-    set Coordinate system   = spherical
-    set Function expression = if((r > 0.5 && r < 0.6), 1, 0) ; if((r > 0.8 && r < 0.95), 1, 0)
-  end
-end
diff --git a/tests/composition_passive_static.prm.bak b/tests/composition_passive_static.prm.bak
deleted file mode 100644
index b9c92cbfdff..00000000000
--- a/tests/composition_passive_static.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-#########################################################
-# This is a variation of the composition_passive.prm
-# parameter file with a field of type "static". Check
-# that we don't advect the solution.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.1
-    set Output format                 = gnuplot
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields with same initial condition
-# and only the first one will be advected along.
-subsection Compositional fields
-  set Number of fields = 2
-  set Compositional field methods = field,static
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y<0.2, 1, 0)
-  end
-end
diff --git a/tests/composition_reaction.prm.bak b/tests/composition_reaction.prm.bak
deleted file mode 100644
index 0178cc598bd..00000000000
--- a/tests/composition_reaction.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-#########################################################
-# This is a variation of the composition_active.prm
-# parameter file, with the exception that we use the
-# material model composition reaction that accounts for
-# reactions between the two compositional fields.
-
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.3
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-# Let us here choose again a box domain of size 2x1
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-# We then set the temperature to one at the bottom and zero
-# at the top:
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0
-  end
-end
-
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-    set Density differential for compositional field 1 = -5
-    set Density differential for compositional field 2 = 5
-    set Reaction depth                = 0.2
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
diff --git a/tests/composition_reaction_iterated_IMPES.cc.bak b/tests/composition_reaction_iterated_IMPES.cc.bak
deleted file mode 100644
index 43866fd7ba5..00000000000
--- a/tests/composition_reaction_iterated_IMPES.cc.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/composition_reaction.h>
-#include <aspect/geometry_model/interface.h>
-
-/**
- * This material model assumes three compositional fields
- * where the reaction rate of the first and the third one
- * depend on the second one. Thus, an iterated scheme is
- * required to compute the correct solution.
- */
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class IteratedReaction : public MaterialModel::CompositionReaction<dim>
-    {
-      public:
-        virtual void evaluate(const MaterialModelInputs<dim> &in,
-                              MaterialModelOutputs<dim> &out) const
-        {
-          this->CompositionReaction<dim>::evaluate(in, out);
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const double depth = this->get_geometry_model().depth(in.position[i]);
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                {
-                  Assert(in.composition[i].size() > 1,
-                         ExcMessage ("Material model iterated reaction can only be used with "
-                                     "at least two compositial fields."));
-
-                  double delta_C = 0.0;
-                  switch (c)
-                    {
-                      case 0:
-                        delta_C = in.composition[i][1];
-                        break;
-                      case 1:
-                        delta_C = 1.0;
-                        break;
-                      case 2:
-                        delta_C = in.composition[i][1];
-                        break;
-                    }
-                  out.reaction_terms[i][c] = delta_C;
-                }
-            }
-
-        }
-
-    };
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(IteratedReaction,
-                                   "iterated reaction",
-                                   "A simple material model that is like the "
-                                   "'composition reaction' model, but requires an "
-                                   "iterated IMPES scheme to converge to the correct "
-                                   "solution.")
-  }
-}
diff --git a/tests/composition_reaction_iterated_IMPES.prm.bak b/tests/composition_reaction_iterated_IMPES.prm.bak
deleted file mode 100644
index 33f017d866b..00000000000
--- a/tests/composition_reaction_iterated_IMPES.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-#########################################################
-# This is a variation of the composition_reaction test,
-# with the exception that we use a reaction term that
-# requires the iterated Advection and Stokes solver scheme to reach the
-# correct reaction rate, which is one for the second
-# field and the value of the second field for the first
-# and the third field. Without iterating, the fields will
-# use the value from the previous time step. In addition,
-# this test checks if the results are the same for the
-# first and third field, independent of the order of
-# solving, and thus if our solver scheme is consistent.
-
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.01
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-
-############### Parameters describing the model
-# Let us here choose again a box domain of size 2x1
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-# We then set the temperature to one at the bottom and zero
-# at the top:
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.0;0.0;0.0
-  end
-end
-
-subsection Material model
-  set Model name = iterated reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-    set Density differential for compositional field 1 = -5
-    set Density differential for compositional field 2 = 5
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization
-end
diff --git a/tests/composition_stabilization.prm.bak b/tests/composition_stabilization.prm.bak
deleted file mode 100644
index 721f44f0c1e..00000000000
--- a/tests/composition_stabilization.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-#########################################################
-# This is a test for the stabilization of the advection
-# equation for compositional fields. The flow is
-# symmetric around the origin, and two fields that
-# each feature a circle of compositional distinct
-# material are advected with the flow. Rotating field C_2
-# by 180 degrees should yield the same result as C_1.
-# It is a variation of the platelike_boundary.prm file.
-# All settings are exactly the same with the exception
-# of the ones that pertain to compositional fields.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 4
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Prescribed velocity boundary indicators = top: function, bottom: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(z>0.5,sin(pi*x),-sin(pi*x)); 0
-  end
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(sqrt((x-0.25)*(x-0.25)+(y-0.5)*(y-0.5))<0.2, 1, 0); if(sqrt((x-0.75)*(x-0.75)+(y-0.5)*(y-0.5))<0.2, 1000, 10)
-  end
-end
diff --git a/tests/compositional_boundary_values.prm.bak b/tests/compositional_boundary_values.prm.bak
deleted file mode 100644
index 895b7b0b48e..00000000000
--- a/tests/compositional_boundary_values.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# A testcase that evaluates inflow boundary conditions for compositional
-# fields. It solves the equations on a box with Dirichlet boundary conditions
-# equal to (z,0), which then is also the velocity everywhere.
-#
-# We prescribe boundary values for the compositional fields at the left
-# and see how it is transported towards the right.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = 0
-  set List of model names = box
-
-  subsection Box
-    set Left composition = 10, 10
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0 ; 1
-  end
-end
diff --git a/tests/compositional_boundary_values_02.prm.bak b/tests/compositional_boundary_values_02.prm.bak
deleted file mode 100644
index 2c057bd1dd1..00000000000
--- a/tests/compositional_boundary_values_02.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# Like the 'compositional_boundary_values' test, but here we also prescribe
-# boundary values at the neutral bottom boundary where flow is
-# tangential. Because boundary values are prescribed strongly, this leads to a
-# boundary layer one cell wide.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = 0, 2
-  set List of model names = box
-
-  subsection Box
-    set Left composition = 10, 10
-    set Right composition = 20, 20
-    set Bottom composition = 30, 30
-    set Top composition = 40, 40
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0 ; 1
-  end
-end
diff --git a/tests/compositional_boundary_values_03.prm.bak b/tests/compositional_boundary_values_03.prm.bak
deleted file mode 100644
index d097d2b3fa3..00000000000
--- a/tests/compositional_boundary_values_03.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# Like the 'compositional_boundary_values_02' test, but use different
-# values for the boundary conditions of different compositional fields.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = 0, 2
-  set List of model names = box
-
-  subsection Box
-    set Left composition = 10, -10
-    set Right composition = 20, -20
-    set Bottom composition = 30, -30
-    set Top composition = 40, -40
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0 ; 1
-  end
-end
diff --git a/tests/compositional_heating.prm.bak b/tests/compositional_heating.prm.bak
deleted file mode 100644
index 80feddba197..00000000000
--- a/tests/compositional_heating.prm.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1e9
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = compositional_heating
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1543
-    set Top temperature    =  273
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-# Initial temperature field
-# Typical continental geotherm based equations 4-6 from Chapman 1986 (Geol. Soc. Lon.):
-#   T(z) = Tt + (qt/k)*z - (A*z**2)/(2*k)    (eq 4)
-#   Tb = Tt + (qt/k)*dz - (A*dz**2)/(2*k)    (eq 5)
-#   qb = qt - A*dz                           (eq 6)
-#     T: Temperature, Ts: Layer surface temperature, Tb: layer basal temperature,
-#     qs: Layer surface heat flux, qb: Layer basal heat flux, A = heat production,
-#     dz: Layer thickness, k: thermal conductivity
-# The initial constraints are:
-#   Crust surface temperature (Tsc) = 273 K
-#   Crust surface heat flow   (qsc) = 0.07 W/m^2
-#   Crust heat production      (Ac) = 1.5e-6 W/m^3
-#   Crust thickness           (dzu) = 30.3 m
-#   Mantle heat production     (Am) = 0. W/m^3
-#   Mantle thickness          (dzm) = 70.e3
-#   Thermal conductivity        (K) = 2.5 W/(m K)
-# These constraints allow us to calculate the following values:
-#   qbc = qsc - A*dzc = 0.07 - 1.5e-6*30.e3 = 0.025
-#   Tbc = Tsc + (qsc/k)*dzc - (A*dzc**2)/(2*k) =
-#         273. + (0.07/2.5)*30.e3 - (1.5e-6 * 30.e3**2)/(2.*2.5) = 843
-#   qsm = qbc = 0.025
-#   Tsm = Tbc = 843
-#   qbm = qsm - A*dzm = 0.025 - 0.*70.e3 = 0.025
-#   Tbm = Tsm + (qts/k)*dzs - (A*dzm**2)/(2*k) =
-#         843. + (0.025/2.5)*30.e3 - (0. * 70.e3**2)/(2.*2.5) = 1543
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=100e3,tsc=273,tsm=843,qsc=0.07,qsm=0.025,k=2.5,A=1.5e-6
-    set Function expression = if( (h-y)<=30.e3, \
-                                  tsc + (qsc/k)*(h-y) - (A*(h-y)*(h-y))/(2.0*k), \
-                                  tsm + (qsm/k)*(h-y-30.e3))
-  end
-end
-
-# Internal heating (user specifies heat flux in W/m^3)
-# Values below are for the background (mantle) and crust.
-# If one wishes to track a property through compositional fields that should
-# not be used to determine the heat flux (e.g. finite strain), set the
-# "Use compositional field for heat flux averaging" value for that field to 0.
-# See Initial temperature model section for relationship between heat flux, production
-# and initial temperature profile representative of a continental geotherm.
-subsection Heating model
-  set List of model names = compositional heating
-
-  subsection Compositional heating
-    set Use compositional field for heat production averaging = 1, 1
-    set Compositional heating values = 0., 1.5e-6
-  end
-end
-
-# Compositional fields used to track upper and lower crust
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = upper
-end
-
-# Initial composition model
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y>=70.e3, 1, 0);
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material (mantle) and crust)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Reference values and viscosity averaging
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-16
-    set Minimum viscosity = 1e18
-    set Maximum viscosity = 1e28
-    set Viscosity averaging scheme = harmonic
-
-    # Thermodynamic properties
-    # Thermal diffusivity = thermal_conductivity/(density*heat_capacity)
-    set Thermal diffusivities = 1.010101e-6, 1.190476e-6
-    set Heat capacities = 750.
-    set Densities = 3300., 2800.
-    set Thermal expansivities = 0.
-
-    # Uniform viscosity
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Postprocessor
-subsection Postprocess
-  set List of postprocessors = heat flux statistics, temperature statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 200
-  end
-end
diff --git a/tests/compositional_heating_exclude_background.prm.bak b/tests/compositional_heating_exclude_background.prm.bak
deleted file mode 100644
index 08ca20911b2..00000000000
--- a/tests/compositional_heating_exclude_background.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-# A test to check that we can correctly exclude the background
-# field from the average heating calculation.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1e9
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = compositional_heating
-set Timing output frequency                = 1
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1543
-    set Top temperature    =  273
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=100e3,tsc=273,tsm=843,qsc=0.07,qsm=0.025,k=2.5,A=1.5e-6
-    set Function expression = if( (h-y)<=30.e3, \
-                                  tsc + (qsc/k)*(h-y) - (A*(h-y)*(h-y))/(2.0*k), \
-                                  tsm + (qsm/k)*(h-y-30.e3))
-  end
-end
-
-subsection Heating model
-  set List of model names = compositional heating
-
-  subsection Compositional heating
-    set Use compositional field for heat production averaging = 0, 1
-    set Compositional heating values = 1.5e-6, 1.5e-6
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = upper
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.5;
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-16
-    set Minimum viscosity = 1e18
-    set Maximum viscosity = 1e28
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 1.010101e-6, 1.190476e-6
-    set Heat capacities = 750.
-    set Densities = 3300., 3300.
-    set Thermal expansivities = 0.
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = heat flux statistics, temperature statistics, heating statistics
-end
diff --git a/tests/compositional_vectors.prm.bak b/tests/compositional_vectors.prm.bak
deleted file mode 100644
index 178adc69bbe..00000000000
--- a/tests/compositional_vectors.prm.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-set Dimension                              = 2
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = box
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = compositional vector
-    set Output format = gnuplot
-
-    subsection Compositional fields as vectors
-      set Names of vectors = vector_field1, vector_field2
-      set Names of fields = vec1x, vec1y; vec2x, vec2y
-    end
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields = unrelated1, vec1x, vec1y, unrelated2, vec2x, vec2y
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1;1;.5;1;-1;-.5
-  end
-end
diff --git a/tests/compositional_vectors_3d.prm.bak b/tests/compositional_vectors_3d.prm.bak
deleted file mode 100644
index 181aa62b254..00000000000
--- a/tests/compositional_vectors_3d.prm.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-set Dimension                              = 3
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = box
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = compositional vector
-    set Output format = gnuplot
-
-    subsection Compositional fields as vectors
-      set Names of vectors = vector_field
-      set Names of fields = vec_x, vec_y, vec_z
-    end
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 5
-  set Names of fields = unrelated1, vec_x, vec_y, vec_z, unrelated2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1;1;.5;1;0
-  end
-end
diff --git a/tests/compressibility.cc.bak b/tests/compressibility.cc.bak
deleted file mode 100644
index 0f6cc9653d3..00000000000
--- a/tests/compressibility.cc.bak
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class Compressibility : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-          * Return true if the compressibility() function returns something that
-          * is not zero.
-          */
-        bool
-        is_compressible () const override;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    Compressibility<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      Simple<dim>::evaluate(in, out);
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double pressure = in.pressure[i];
-          out.densities[i] = 1.0 + pressure;
-          out.compressibilities[i] = 1.0 / (1. + pressure);
-        }
-    }
-
-    template <int dim>
-    bool
-    Compressibility<dim>::
-    is_compressible () const
-    {
-      return true;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Compressibility,
-                                   "compressibility",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but has a non-zero compressibility.")
-  }
-}
-
-
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    class Compressibility : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics) override;
-    };
-  }
-}
-
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    Compressibility<dim>::execute (TableHandler &)
-    {
-      // create a quadrature formula based on the temperature element alone.
-      // be defensive about determining that what we think is the temperature
-      // element is indeed the temperature element
-      Assert (this->get_fe().n_base_elements() == 3+(this->n_compositional_fields()>0 ? 1 : 0),
-              ExcNotImplemented());
-      const QGauss<dim-1> quadrature_formula (this->get_fe().base_element(2).degree+1);
-
-      FEFaceValues<dim> fe_face_values (this->get_mapping(),
-                                        this->get_fe(),
-                                        quadrature_formula,
-                                        update_gradients         | update_values |
-                                        update_quadrature_points | update_JxW_values);
-
-      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-      std::vector<Tensor<1,dim>> velocity_values(quadrature_formula.size());
-
-      typename DoFHandler<dim>::active_cell_iterator
-      cell = this->get_dof_handler().begin_active(),
-      endc = this->get_dof_handler().end();
-
-      MaterialModel::MaterialModelInputs<dim> in(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-      MaterialModel::MaterialModelOutputs<dim> out(fe_face_values.n_quadrature_points, this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::density;
-
-      // compute the integral of the viscosity. since we're on a unit box,
-      // this also is the average value
-      double bottom_flux_integral = 0;
-      double top_flux_integral = 0;
-      for (; cell!=endc; ++cell)
-        if (cell->is_locally_owned())
-          for (unsigned int f=0; f<2*dim; ++f)
-            if (cell->at_boundary(f)
-                &&
-                ((cell->face(f)->boundary_id() == 2)
-                 ||
-                 (cell->face(f)->boundary_id() == 3)))
-              {
-                fe_face_values.reinit (cell,f);
-                fe_face_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
-                    in.temperature);
-                fe_face_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
-                                                                                               in.pressure);
-                fe_face_values[this->introspection().extractors.velocities].get_function_symmetric_gradients (this->get_solution(),
-                    in.strain_rate);
-                for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                  fe_face_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
-                      composition_values[c]);
-                fe_face_values[this->introspection().extractors.velocities].get_function_values (this->get_solution(),
-                    velocity_values);
-
-                in.position = fe_face_values.get_quadrature_points();
-                for (unsigned int i=0; i<fe_face_values.n_quadrature_points; ++i)
-                  {
-                    for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                      in.composition[i][c] = composition_values[c][i];
-                  }
-
-                this->get_material_model().evaluate(in, out);
-
-                if (cell->face(f)->boundary_id() == 2)
-                  for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                    bottom_flux_integral += out.densities[q] * velocity_values[q][1] * fe_face_values.JxW(q);
-                if (cell->face(f)->boundary_id() == 3)
-                  for (unsigned int q=0; q<fe_face_values.n_quadrature_points; ++q)
-                    top_flux_integral += out.densities[q] * velocity_values[q][1] * fe_face_values.JxW(q);
-              }
-
-      std::ostringstream screen_text1;
-      std::ostringstream screen_text2;
-      screen_text1.precision(4);
-      screen_text2.precision(4);
-      screen_text1 << Utilities::MPI::sum(bottom_flux_integral, this->get_mpi_communicator());
-      screen_text2 << Utilities::MPI::sum(top_flux_integral, this->get_mpi_communicator());
-
-      return std::pair<std::string, std::string> ("Top/bottom flux:",
-                                                  screen_text2.str() + "/" + screen_text1.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(Compressibility,
-                                  "compressibility",
-                                  "A postprocessor that computes some statistics about "
-                                  "the mass fluxes.")
-  }
-}
diff --git a/tests/compressibility.prm.bak b/tests/compressibility.prm.bak
deleted file mode 100644
index 7f89e9c6cc1..00000000000
--- a/tests/compressibility.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# A testcase that demonstrates compressibility. It solves the
-# equations on a box with Dirichlet boundary conditions equal to
-# (0,1) at the bottom boundary, a tangential velocity at the sides
-# and a free boundary at the top.
-#
-# We then choose a density rho=1+p and a compressibility that leads
-# to an exponential density profile rho=e^z, i.e.
-# compressibility=1/rho drho/dp=1/(1+p). The mass flux (product of density
-# and velocity) into the box and out of the box should be the same.
-#
-# We can only tell that the correct mass flux is computed in a
-# postprocessor, which we implement in the .cc file.
-#
-#
-# The correct solution has an exponentially increasing pressure and
-# density (top to bottom) where p(z)=e^(1-z)-1  (depth=1-z) and
-# rho(z)=e^(1-z). To conserve mass, this then requires a velocity
-# in z-direction equal to
-#    v(z) = e^(-(1-z))
-# However, this is the product of the equation
-#    div(rho u) = 0
-# which we instead solve in each iteration as
-#    div u = -1/rho drho/dp u^* . g
-# where u^* is a linearization point. In the first iteration, we start
-# with u^*=0, so we solve
-#    div u = 0
-# and the velocity field is of course completely wrong (it does not
-# accelerate towards the top as expected but is in fact constant).
-#
-# This testcase therefore verifies that we compute this wrong solution
-# in the first iteration. We use the no Advection, iterated Stokes/max_nonlinear_iterations=1
-# option for the solver scheme.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = compressibility
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = compressibility, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/compressibility_iterated_stokes.cc.bak b/tests/compressibility_iterated_stokes.cc.bak
deleted file mode 100644
index 9c34031b4ed..00000000000
--- a/tests/compressibility_iterated_stokes.cc.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// use the same postprocessing facilities as for the 'compressibility'
-// testcase
-#include "compressibility.cc"
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class CompressibilityIteratedStokes : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-        /**
-          * Return true if the compressibility() function returns something that
-          * is not zero.
-          */
-        bool
-        is_compressible () const override;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    CompressibilityIteratedStokes<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      Simple<dim>::evaluate(in, out);
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          out.densities[i] = 10.0/11.0*exp(in.pressure[i]/100.0);
-          out.compressibilities[i] = 0.01;
-        }
-    }
-
-    template <int dim>
-    bool
-    CompressibilityIteratedStokes<dim>::
-    is_compressible () const
-    {
-      return true;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(CompressibilityIteratedStokes,
-                                   "compressibility iterated stokes",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but has a non-zero compressibility.")
-  }
-}
diff --git a/tests/compressibility_iterated_stokes.prm.bak b/tests/compressibility_iterated_stokes.prm.bak
deleted file mode 100644
index 3c692bcdec7..00000000000
--- a/tests/compressibility_iterated_stokes.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# A variation on the 'compressibility' testcase. here, we compute not
-# only the first iteration of a nonlinear fixed point scheme, but in
-# fact the first several. This should iterate out the
-# continuity equation,
-#    div u = -1/rho drho/dp u^ . g
-# and so should lead to an upward expansion of the flux.
-#
-# with the original testcase, the iteration does not converge. rather,
-# we need a much smaller compressibility to make things converge. we
-# choose a velocity profile
-#   u_z = 1+z/100
-# with corresponding density profile
-#   rho = 1/(1+z/100)
-# so that the continuity equation is satisfied. From the density one
-# can compute a pressure profile (here, the pressure equals the hydrostatic
-# pressure because all second derivatives of the velocity vanish). This gives
-# p(z), which we can invert for z=z(p) and enter into the density equation
-# to get
-#   rho = 10.0/11.0*exp(pressure/100.0)
-# which corresponds to compressibility=0.01. This is implemented in
-# the .cc file corresponding to this testcase.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 5
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = compressibility iterated stokes
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = compressibility, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, volumetric strain rate
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/compressibility_iterated_stokes_direct_solver.cc.bak b/tests/compressibility_iterated_stokes_direct_solver.cc.bak
deleted file mode 100644
index a1d5f2ddde2..00000000000
--- a/tests/compressibility_iterated_stokes_direct_solver.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "compressibility_iterated_stokes.cc"
diff --git a/tests/compressibility_iterated_stokes_direct_solver.prm.bak b/tests/compressibility_iterated_stokes_direct_solver.prm.bak
deleted file mode 100644
index b3370598c77..00000000000
--- a/tests/compressibility_iterated_stokes_direct_solver.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# Copy of compressibility_iterated_stokes but using a direct solver. This is
-# to check that solve_stokes() returns the correct nonlinear residual.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 5
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = compressibility iterated stokes
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = compressibility
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/compressibility_lateral_pipe.cc.bak b/tests/compressibility_lateral_pipe.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_lateral_pipe.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe.prm.bak b/tests/compressibility_lateral_pipe.prm.bak
deleted file mode 100644
index 70c96f03b91..00000000000
--- a/tests/compressibility_lateral_pipe.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm
-
-set End time = 2e7
diff --git a/tests/compressibility_lateral_pipe_advect.cc.bak b/tests/compressibility_lateral_pipe_advect.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_lateral_pipe_advect.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_advect.prm.bak b/tests/compressibility_lateral_pipe_advect.prm.bak
deleted file mode 100644
index 1acea3e0dc9..00000000000
--- a/tests/compressibility_lateral_pipe_advect.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm
-
-set End time = 2e6
diff --git a/tests/compressibility_lateral_pipe_advect_projected_density.cc.bak b/tests/compressibility_lateral_pipe_advect_projected_density.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_lateral_pipe_advect_projected_density.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_advect_projected_density.prm.bak b/tests/compressibility_lateral_pipe_advect_projected_density.prm.bak
deleted file mode 100644
index b7c398e1891..00000000000
--- a/tests/compressibility_lateral_pipe_advect_projected_density.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_advect/lateral_pipe.prm
-
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_advect/projected_density.prm
-
-set End time = 2e6
diff --git a/tests/compressibility_lateral_pipe_increase_pressure.cc.bak b/tests/compressibility_lateral_pipe_increase_pressure.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_lateral_pipe_increase_pressure.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_increase_pressure.prm.bak b/tests/compressibility_lateral_pipe_increase_pressure.prm.bak
deleted file mode 100644
index a74f0d19c52..00000000000
--- a/tests/compressibility_lateral_pipe_increase_pressure.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm
-
-set End time = 1e12
diff --git a/tests/compressibility_lateral_pipe_increase_pressure_projected_density.cc.bak b/tests/compressibility_lateral_pipe_increase_pressure_projected_density.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_lateral_pipe_increase_pressure_projected_density.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_increase_pressure_projected_density.prm.bak b/tests/compressibility_lateral_pipe_increase_pressure_projected_density.prm.bak
deleted file mode 100644
index 59c76e2dd43..00000000000
--- a/tests/compressibility_lateral_pipe_increase_pressure_projected_density.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/lateral_pipe.prm
-
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_increase_pressure/projected_density.prm
-
-set End time = 1e12
diff --git a/tests/compressibility_lateral_pipe_projected_density.cc.bak b/tests/compressibility_lateral_pipe_projected_density.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_lateral_pipe_projected_density.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_projected_density.prm.bak b/tests/compressibility_lateral_pipe_projected_density.prm.bak
deleted file mode 100644
index c8efc495810..00000000000
--- a/tests/compressibility_lateral_pipe_projected_density.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe/lateral_pipe.prm
-
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe/projected_density.prm
-
-set End time = 2e7
diff --git a/tests/compressibility_lateral_pipe_transient.cc.bak b/tests/compressibility_lateral_pipe_transient.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_lateral_pipe_transient.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_transient.prm.bak b/tests/compressibility_lateral_pipe_transient.prm.bak
deleted file mode 100644
index 47594f2f50a..00000000000
--- a/tests/compressibility_lateral_pipe_transient.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm
-
-set End time = 1e13
diff --git a/tests/compressibility_lateral_pipe_transient_projected_density.cc.bak b/tests/compressibility_lateral_pipe_transient_projected_density.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_lateral_pipe_transient_projected_density.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_lateral_pipe_transient_projected_density.prm.bak b/tests/compressibility_lateral_pipe_transient_projected_density.prm.bak
deleted file mode 100644
index 50d8198c15f..00000000000
--- a/tests/compressibility_lateral_pipe_transient_projected_density.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_transient/lateral_pipe.prm
-
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/lateral_pipe_transient/projected_density.prm
-
-set End time = 1e13
diff --git a/tests/compressibility_vertical_pipe.cc.bak b/tests/compressibility_vertical_pipe.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_vertical_pipe.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_vertical_pipe.prm.bak b/tests/compressibility_vertical_pipe.prm.bak
deleted file mode 100644
index 4be871494cb..00000000000
--- a/tests/compressibility_vertical_pipe.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm
-
-set End time = 1e6
diff --git a/tests/compressibility_vertical_pipe_projected_density.cc.bak b/tests/compressibility_vertical_pipe_projected_density.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/compressibility_vertical_pipe_projected_density.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/compressibility_vertical_pipe_projected_density.prm.bak b/tests/compressibility_vertical_pipe_projected_density.prm.bak
deleted file mode 100644
index c84510a654b..00000000000
--- a/tests/compressibility_vertical_pipe_projected_density.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm
-
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe/projected_density.prm
-
-set End time = 1e6
diff --git a/tests/compressibility_volumetric_strain_rate.cc.bak b/tests/compressibility_volumetric_strain_rate.cc.bak
deleted file mode 100644
index a1d5f2ddde2..00000000000
--- a/tests/compressibility_volumetric_strain_rate.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "compressibility_iterated_stokes.cc"
diff --git a/tests/compressibility_volumetric_strain_rate.prm.bak b/tests/compressibility_volumetric_strain_rate.prm.bak
deleted file mode 100644
index f9a83c46a72..00000000000
--- a/tests/compressibility_volumetric_strain_rate.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# A variation on the 'compressibility_iterated_stokes' testcase.
-# We use it to test the volumetric strain rate visualization postprocessor.
-#
-# As the testcase has the analytical solution
-#   u_z = 1+z/10
-# with corresponding density profile
-#   rho = 1/(1+z/10),
-# the volumetric strain rate should be 0.1 throughout the whole domain.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 5
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = compressibility iterated stokes
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = compressibility, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Point-wise stress and strain = true
-    set List of output variables      = density, volumetric strain rate
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/compressible_forsterite_box.prm.bak b/tests/compressible_forsterite_box.prm.bak
deleted file mode 100644
index 1e1004c6f07..00000000000
--- a/tests/compressible_forsterite_box.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# This test ensures that the multicomponent compressible
-# material model works with compositional fields
-# enabled
-
-set Dimension                              = 2
-set End time                               = 0
-
-subsection Compositional fields
-  set Number of fields          = 1
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent                = 400e3
-    set X repetitions           = 1
-    set Y extent                = 400e3
-    set Y repetitions           = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 1000 + y/400
-  end
-end
-
-# The following properties are for forsterite.
-# They are approximate values based on the dataset of Holland and Powell (2011).
-# Note that the heat capacity is the specific isochoric heat capacity (Cv [J/kg]).
-
-subsection Material model
-  set Model name         = multicomponent compressible
-
-  subsection Multicomponent compressible
-    set Reference temperatures = 298.15
-    set Reference densities = 3222.5
-    set Reference isothermal compressibilities = 7.8e-12
-    set Isothermal bulk modulus pressure derivatives = 3.84
-    set Reference thermal expansivities = 2.85e-5
-    set Isochoric specific heats = 1230.
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = material properties
-    set Time between graphical output = 0
-    set Number of grouped files       = 0
-
-    subsection Material properties
-      set List of material properties = density, thermal expansivity, compressibility, specific heat
-    end
-  end
-end
diff --git a/tests/compression_heating.cc.bak b/tests/compression_heating.cc.bak
deleted file mode 100644
index 4eb0171708b..00000000000
--- a/tests/compression_heating.cc.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/melt_global.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class Compression : public MaterialModel::MeltGlobal<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-    };
-
-
-    template <int dim>
-    void
-    Compression<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      MeltGlobal<dim>::evaluate(in, out);
-      const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          out.reaction_terms[i][porosity_idx] = 0.2;
-        }
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Compression,
-                                   "melt global compression",
-                                   "A simple material model that is like the "
-                                   "'melt simple' model, but has a constant reaction term.")
-  }
-}
diff --git a/tests/compression_heating.prm.bak b/tests/compression_heating.prm.bak
deleted file mode 100644
index 0ebf5cd02d1..00000000000
--- a/tests/compression_heating.prm.bak
+++ /dev/null
@@ -1,141 +0,0 @@
-# This test is used to check if the shear heating
-# of melt, in particular the compression heating heating, is
-# calculated correctly.
-# There is no driving force in form of gravity in this model,
-# but material is melting homogeneously with a constant rate,
-# and the top boundary of the model is open, allowing material
-# to flow out (material expands upon melting).
-# There is no shear in the solid itself or shear between melt
-# and solid, but the velocity divergence is nonzero (it is 0.1),
-# so there is compression heating \xi (\nabla \cdot u_s).
-#
-# With the material properties in this benchmark, shear
-# heating of melt should have a value of 1.0 (for the
-# Total shear heating with melt rate).
-#
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 0.3
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 1600
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5; 0.0
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2
-
-  subsection Function
-    set Function expression = 0;0
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Heating model
-  set List of model names = shear heating, shear heating with melt
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = melt global compression
-
-  subsection Melt global
-    set Reference solid density    = 2
-    set Reference melt density     = 1
-    set Reference specific heat    = 1
-    set Reference temperature      = 1600
-    set Thermal conductivity       = 0.0
-    set Surface solidus            = 10000.0
-    set Include melting and freezing = false
-    set Reference permeability       = 1e-5
-    set Reference shear viscosity    = 1
-    set Reference bulk viscosity     = 100
-    set Reference melt viscosity     = 1
-    set Thermal viscosity exponent   = 0
-    set Exponential melt weakening factor = 0
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heating statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature, heating
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
diff --git a/tests/compute-no-normal-flux-constraints.prm.bak b/tests/compute-no-normal-flux-constraints.prm.bak
deleted file mode 100644
index 7c63396787a..00000000000
--- a/tests/compute-no-normal-flux-constraints.prm.bak
+++ /dev/null
@@ -1,146 +0,0 @@
-set Dimension = 2
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 10e2
-set Output directory = output-no-flux-constraints
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 273
-set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
-set Nonlinear solver tolerance             = 1e-4
-set Max nonlinear iterations               = 10
-set CFL number                             = 0.3
-set Timing output frequency                = 1
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-end
-
-# here are John's settings
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-
-  subsection Newton solver parameters
-    set Max Newton line search iterations        = 5
-    set Max pre-Newton nonlinear iterations      = 20
-    set Maximum linear Stokes solver tolerance   = 1e-1
-    set Nonlinear Newton solver switch tolerance = 1e-5
-    set SPD safety factor                        = 0.9
-    set Stabilization preconditioner             = SPD
-    set Stabilization velocity block             = SPD
-    set Use Newton failsafe                      = false
-    set Use Newton residual scaling method       = false
-    set Use Eisenstat Walker method for Picard iterations = true
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3.481e6
-    set Chunk outer radius = 6.371e6
-    set Chunk maximum longitude = 61.0
-    set Chunk minimum longitude = 0.0
-    set Longitude repetitions = 2
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = west, east, bottom, top
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1673
-    set Outer temperature = 273
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature  = 273
-
-    #    set Reference viscosity    = 1.e22
-
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0
-    set Heat capacities       = 750.
-    set Densities             = 3150
-    set Thermal expansivities = 0
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep          =  1e-21
-    set Stress exponents for dislocation creep    =   4
-    set Activation energies for dislocation creep =   0
-    set Activation volumes for dislocation creep  =   0
-
-    # cohesion set really high to generate very large plastic
-    # viscosities which will not be taken into account
-    # by the material model.
-    set Angles of internal friction = 0
-    set Cohesions                   = 1e15
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, depth average
-
-  subsection Depth average
-    set Number of zones = 50
-    set Output format = txt
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set List of output variables = density, viscosity, error indicator
-    set Output format = vtu
-    set Time between graphical output = 0.1e6
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set End step = 20
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 100
-end
diff --git a/tests/conservative_with_mpi.cc.bak b/tests/conservative_with_mpi.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/conservative_with_mpi.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/conservative_with_mpi.prm.bak b/tests/conservative_with_mpi.prm.bak
deleted file mode 100644
index add8f5f5e4e..00000000000
--- a/tests/conservative_with_mpi.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# when using the conservative element in a parallel program, we used to get an
-# assertion in normalize_pressure because we tried to modify an element of a
-# vector with ghost elements. there was also a second thinko in the same
-# function. verify that this doesn't happen any more.
-
-# MPI: 2
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = true
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/consistent_boundary_flux_adjacent_dirichlet.prm.bak b/tests/consistent_boundary_flux_adjacent_dirichlet.prm.bak
deleted file mode 100644
index 727e25d3667..00000000000
--- a/tests/consistent_boundary_flux_adjacent_dirichlet.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# This test is based on boundary_heat_flux and checks that the consistent
-# boundary flux method in the heatflux statistics postprocessor computes
-# the correct boundary fluxes for models with Dirichlet temperature
-# boundary conditions on two adjacent faces of the same cell that belong
-# to different boundaries.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 2.5e11
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 90  # -183°C adiabat
-set Use conduction timestep                = true
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 20000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
-
-  subsection Function
-    set Function expression = 0;0
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta = 0.0
-    set cR = 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left,top
-  set List of model names = initial temperature
-end
-
-subsection Boundary heat flux model
-  set Fixed heat flux boundary indicators = bottom
-  set Model name = function
-
-  subsection Function
-    set Function expression = -0.04
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density        = 950
-    set Reference specific heat  = 1000
-    set Reference temperature    = 273
-    set Thermal conductivity     = 2.38
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =  heat flux map
-  end
-end
diff --git a/tests/consistent_boundary_flux_neumann.prm.bak b/tests/consistent_boundary_flux_neumann.prm.bak
deleted file mode 100644
index 2d39ae7b4c6..00000000000
--- a/tests/consistent_boundary_flux_neumann.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# This test is based on boundary_heat_flux and checks that the consistent
-# boundary flux method in the heatflux statistics postprocessor computes
-# the correct boundary fluxes for models with adjacent Dirichlet and
-# Neumann temperature boundary conditions.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 2.5e16
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 90  # -183°C adiabat
-set Use conduction timestep                = true
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 20000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
-
-  subsection Function
-    set Function expression = 0;0
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta = 0.0
-    set cR = 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left
-  set List of model names = initial temperature
-end
-
-subsection Boundary heat flux model
-  set Fixed heat flux boundary indicators = bottom
-  set Model name = function
-
-  subsection Function
-    set Function expression = -0.04
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density        = 950
-    set Reference specific heat  = 1000
-    set Reference temperature    = 273
-    set Thermal conductivity     = 2.38
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heat flux statistics
-end
diff --git a/tests/consistent_boundary_flux_open_boundary.prm.bak b/tests/consistent_boundary_flux_open_boundary.prm.bak
deleted file mode 100644
index 389ffb9fa28..00000000000
--- a/tests/consistent_boundary_flux_open_boundary.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# This test is based on boundary_heat_flux and checks that the consistent
-# boundary flux method in the heat flux statistics postprocessor computes
-# the correct boundary fluxes for models with Dirichlet temperature
-# boundary conditions on two adjacent faces of the same cell that belong
-# to different boundaries.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 1e13
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 90  # -183°C adiabat
-set Use conduction timestep                = true
-set Output directory = output-no-expansion
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 20000
-    set Y extent = 20000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function,1:function, 2:function,3:function
-
-  subsection Function
-    set Function constants = yr_in_s=31557600
-    set Function expression = 1/yr_in_s;0
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta = 0.0
-    set cR = 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, left
-  set List of model names = initial temperature
-end
-
-subsection Boundary heat flux model
-  set Fixed heat flux boundary indicators = bottom
-  set Model name = function
-
-  subsection Function
-    set Function expression = -0.04
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density        = 950
-    set Reference specific heat  = 1000
-    set Reference temperature    = 273
-    set Thermal conductivity     = 2.38
-    set Thermal expansion coefficient      = 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heat flux statistics
-end
diff --git a/tests/constant_composition_convergence.prm.bak b/tests/constant_composition_convergence.prm.bak
deleted file mode 100644
index 18b01262cec..00000000000
--- a/tests/constant_composition_convergence.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# This test checks that the advection solver converges
-# in the first timestep even when solving for a constant
-# compositional field.
-
-set Dimension                              = 2
-set End time                               = 2e8
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 400000
-    set Y extent = 400000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2 ,3
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 1600 + 100*sin(x*pi/200000.0)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                = 3000
-    set Thermal conductivity             = 0
-    set Thermal expansion coefficient    = 4e-5
-    set Viscosity                        = 1e23
-    set Reference temperature            = 1600
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/constant_temperature_boundary_conditions.prm.bak b/tests/constant_temperature_boundary_conditions.prm.bak
deleted file mode 100644
index 9e4673ee765..00000000000
--- a/tests/constant_temperature_boundary_conditions.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 0 : 0.0, 1 : 1.0, 2:2.0, 3:3.0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/continental_extension.prm.bak b/tests/continental_extension.prm.bak
deleted file mode 100644
index 81a0c2241f4..00000000000
--- a/tests/continental_extension.prm.bak
+++ /dev/null
@@ -1,51 +0,0 @@
-####
-# This test is based on the Continental Extension Cookbook
-# There, the initial temperature is computed through a
-# somewhat cumbersome function specified in the input file.
-# With the continental geotherm plugin, one only has to
-# specify the boundary temperature constraints and layer
-# thicknesses of the upper crust, lower crust and mantle
-# lithosphere. Other parameters such as layer densities
-# are read from other sections in the input file, ensuring
-# consistency between the parameters set for the initial
-# temperature and those in the material model and compositional
-# heating plugins. Significantly, the continental geotherm
-# initial temperature plugin enforces that specific names are
-# used for crustal and mantle layers, which are specified
-# below in the Compositional fields subsection.
-
-include $ASPECT_SOURCE_DIR/cookbooks/continental_extension/continental_extension.prm
-
-set Timing output frequency                = 100
-set End time                               = 1e4
-set Max nonlinear iterations               = 1
-
-# Perform only one global refinement and no adaptive refinements
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Time steps between mesh refinement = 0
-end
-
-# Update the names of the compositional fields associated with the upper crust, lower crust,
-# and lithospheric mantle to be consistent with the naming scheme enforced by the continental
-# geothermal initial temperature plugin.
-subsection Compositional fields
-  set Names of fields = noninitial_plastic_strain, plastic_strain, upper_crust, lower_crust, lithospheric_mantle
-end
-
-# Initial temperature field
-subsection Initial temperature model
-  set Model name = continental geotherm
-
-  subsection Continental geotherm
-    set Lithosphere-Asthenosphere boundary isotherm = 1613.
-    set Surface temperature = 273.
-    set Layer thicknesses = 20000., 20000., 60000.
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
diff --git a/tests/convection_box_particles.prm.bak b/tests/convection_box_particles.prm.bak
deleted file mode 100644
index 38a5d238970..00000000000
--- a/tests/convection_box_particles.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-include $ASPECT_SOURCE_DIR/cookbooks/convection-box-particles/convection-box-particles.prm
-
-set Dimension = 2
-set End time = 0
diff --git a/tests/convection_box_phase_function.prm.bak b/tests/convection_box_phase_function.prm.bak
deleted file mode 100644
index 37a099a5d7b..00000000000
--- a/tests/convection_box_phase_function.prm.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-# This is a setup for convection in a 2D box with a phase transition
-# in the center, similar to the setup of Christensen & Yuen 1985.
-# The test case is for the steady state heat flux plugin: the model
-# run should terminate once the heat flux does not change by more
-# than plus/minus 5% in a time frame of 2 Myr.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 2e8
-
-# This controls the solver accuracy
-set Nonlinear solver tolerance             = 1e-5
-set Maximum time step                      = 1e5
-set Adiabatic surface temperature          = 500
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-# This model assumes the Boussinesq approximation, so it is
-# incompressible and has a constant reference density.
-subsection Formulation
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1350000
-    set Y extent = 1350000
-  end
-end
-
-# For the Boussinesq approximation, all heating terms are switched off.
-subsection Heating model
-  set List of model names =
-end
-
-# Set the reference profile.
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants = density=1000
-    set Function expression = 500; density*10*depth; density
-    set Variable names = depth
-  end
-end
-
-# This temperature initial condition resembles the one in Christensen & Yuen, 1985.
-# It has conductive boundary layers at the top and bottom, and sinusoidal
-# temperature perturbations.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants = delta=0.1, A=10, h=1350000, pi=3.1416
-    set Variable names = x,z
-    set Function expression = 500 + 500*(erfc(z/(h*delta)) - erfc((1-z/h)/delta)) + A*cos(pi*x/h)*sin(pi*z/h) + A*cos(2*pi*x/h)*sin(pi*z/h) + A*cos(pi*x/h)*sin(2*pi*z/h) + A*cos(2*pi*x/h)*sin(2*pi*z/h)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom, left, right
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# This material model uses phase functions.
-# The model in Christensen & Yuen is nondimensional. To make this
-# easy, we here set all material
-# properties to multiples of 10, and then control the three important
-# model parameters by setting:
-#
-# k = 2.460375e7 / Ra,                                      to control the Rayleigh number,
-# deltarho = 2 alpha rho DeltaT = 200 kg/m3,                to achieve Rb = 2Ra, as in Christensen & Yuen,
-# gamma = P * Ra/Rb * rho g h / DeltaT = P/2 * 1.35e7 Pa/K, to set the phase buoyancy parameter.
-#
-subsection Material model
-  set Model name = latent heat
-  set Material averaging = harmonic average only viscosity
-
-  subsection Latent heat
-    set Reference density = 1000
-    set Reference temperature = 500
-    set Viscosity = 1e20
-    set Thermal viscosity exponent = 0.0
-    set Thermal conductivity = 246.03750
-    set Reference specific heat = 1000
-    set Thermal expansion coefficient = 1e-4
-    set Compressibility = 0
-    set Phase transition depths = 675000
-    set Phase transition widths = 54000
-    set Define transition by depth instead of pressure = true
-    set Phase transition temperatures = 500
-    set Phase transition Clapeyron slopes = -4050000
-    set Phase transition density jumps = 200
-    set Corresponding phase for density jump = 0
-    set Viscosity prefactors = 1,1
-    set Minimum viscosity = 1e20
-    set Maximum viscosity = 1e20
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = heat flux statistics
-end
-
-subsection Termination criteria
-  set Termination criteria = end time, steady state heat flux
-
-  subsection Steady state heat flux
-    set Maximum relative deviation = 0.05
-    set Time in steady state = 2e6
-    set Boundary indicators = top
-  end
-end
diff --git a/tests/cookbook_mantle_convection_annulus.prm.bak b/tests/cookbook_mantle_convection_annulus.prm.bak
deleted file mode 100644
index b23e7ed85da..00000000000
--- a/tests/cookbook_mantle_convection_annulus.prm.bak
+++ /dev/null
@@ -1,36 +0,0 @@
-# input file for model R of van der wiel et al, 2024.
-
-include $ASPECT_SOURCE_DIR/cookbooks/mantle_convection_with_continents_in_annulus/modelR.prm
-
-set World builder file                     = $ASPECT_SOURCE_DIR/cookbooks/mantle_convection_with_continents_in_annulus/world.wb
-set Output directory                       = cookbook_mantle_convection_annulus
-set End time                               = 0
-
-subsection Mesh refinement
-  set Initial global refinement       = 1
-  set Initial adaptive refinement     = 0
-  set Strategy                        = minimum refinement function, viscosity, velocity
-
-  subsection Minimum refinement function
-    set Coordinate system = spherical
-    set Function expression = if(r>6000e3, 6, if(r>5000e3,5,3))
-    set Variable names = r,phi,t
-  end
-end
-
-subsection Postprocess
-end
-
-subsection Particles
-  subsection Generator
-    subsection Uniform radial
-      set Minimum radius = 3580000
-      set Maximum radius = 6270000
-      set Radial layers  = 50
-    end
-
-    subsection Probability density function
-      set Number of particles           = 123
-    end
-  end
-end
diff --git a/tests/cookbook_simpler_with_crust.cc.bak b/tests/cookbook_simpler_with_crust.cc.bak
deleted file mode 100644
index da3179eff95..00000000000
--- a/tests/cookbook_simpler_with_crust.cc.bak
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// copied from ../cookbooks/free-surface-with-crust/plugin/simpler-with-crust.cc
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-#include <cmath>
-
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model similar to the "simpler" material model, but where the
-     * viscosity has two different values dependent on whether we are above or
-     * below a line at a certain z-value, i.e., with a
-     * crust.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class SimplerWithCrust : public Interface<dim>
-    {
-      public:
-
-        virtual bool is_compressible () const;
-
-        virtual void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                              typename Interface<dim>::MaterialModelOutputs &out) const;
-
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-        /**
-         * @}
-         */
-
-      private:
-        double reference_rho;
-        double reference_T;
-        double eta_L;
-        double eta_U;
-        double jump_height;
-        double thermal_alpha;
-        double reference_specific_heat;
-        double k_value;
-    };
-
-
-    template <int dim>
-    bool
-    SimplerWithCrust<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-
-    template <int dim>
-    void
-    SimplerWithCrust<dim>::
-    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out ) const
-    {
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          const double z = in.position[i][1];
-          if (z>jump_height)
-            out.viscosities[i] = eta_U;
-          else
-            out.viscosities[i] = eta_L;
-
-          out.densities[i] = reference_rho * (1.0 - thermal_alpha * (in.temperature[i] - reference_T));
-          out.thermal_expansion_coefficients[i] = thermal_alpha;
-          out.specific_heat[i] = reference_specific_heat;
-          out.thermal_conductivities[i] = k_value;
-          out.compressibilities[i] = 0.0;
-        }
-    }
-
-
-    template <int dim>
-    void
-    SimplerWithCrust<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simpler with crust model");
-        {
-          prm.declare_entry ("Reference density", "3300",
-                             Patterns::Double (0),
-                             "Reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference temperature", "293",
-                             Patterns::Double (0),
-                             "The reference temperature $T_0$. The reference temperature is used "
-                             "in the density formula. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Lower viscosity", "5e24",
-                             Patterns::Double (0),
-                             "The value of the viscosity $\\eta$L. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Upper viscosity", "5e24",
-                             Patterns::Double (0),
-                             "The value of the viscosity in the top section $\\eta$U. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Jump height", "100000",
-                             Patterns::Double (0),
-                             "The height at which the viscosity changes. Units: \\si{\\meter}.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250",
-                             Patterns::Double (0),
-                             "The value of the specific heat $cp$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                             Patterns::Double (0),
-                             "The value of the thermal expansion coefficient $\\beta$. "
-                             "Units: \\si{\\per\\kelvin}.");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    SimplerWithCrust<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simpler with crust model");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          reference_T                = prm.get_double ("Reference temperature");
-          eta_L                      = prm.get_double ("Lower viscosity");
-          eta_U                      = prm.get_double ("Upper viscosity");
-          jump_height                = prm.get_double ("Jump height");
-          k_value                    = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.density = NonlinearDependence::none;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SimplerWithCrust,
-                                   "simpler with crust",
-                                   "A material model that is like the ``simpler'' model but "
-                                   "has a jump in the viscosity.")
-  }
-}
diff --git a/tests/coordinate_transformation.cc.bak b/tests/coordinate_transformation.cc.bak
deleted file mode 100644
index f3cd7d46339..00000000000
--- a/tests/coordinate_transformation.cc.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// include utility functions
-#include <aspect/utilities.h>
-
-#include <iostream>
-
-using namespace dealii;
-using namespace aspect::Utilities;
-// Check various conversions between cartesian and spherical coordinates
-
-template <typename T, unsigned int dim>
-void check_point(T point1, T point2)
-{
-  std::cout << std::endl << "Point 1: ";
-  for (unsigned int i = 0; i < dim; ++i)
-    std::cout << point1[i] << ' ';
-
-  std::cout << std::endl << "Point 2: ";
-  for (unsigned int i = 0; i < dim; ++i)
-    std::cout << point2[i] << ' ';
-
-  std::cout << std::endl;
-}
-
-int f()
-{
-  const dealii::Point<2> origin2(0,0);
-  const dealii::Point<3> origin3(0,0,0);
-
-  const std::array<double,2> sorigin2 = {{0,0}};
-  const std::array<double,3> sorigin3 = {{0,0,0}};
-
-  const dealii::Point<2> one2(1,1);
-  const dealii::Point<3> one3(1,1,1);
-
-  const std::array<double,2> sone2 = {{sqrt(2),numbers::PI/4}};
-  const std::array<double,3> sone3 = {{sqrt(3),numbers::PI/4,std::acos(1/sqrt(3))}};
-
-  const dealii::Point<3> x(1,0,0);
-  const dealii::Point<3> y(0,1,0);
-  const dealii::Point<3> z(0,0,1);
-
-  const std::array<double,3> sx = {{1,0,numbers::PI/2}};
-  const std::array<double,3> sy = {{1,numbers::PI/2,numbers::PI/2}};
-  const std::array<double,3> sz = {{1,0,0}};
-
-  check_point<const std::array<double,2>,2>(Coordinates::cartesian_to_spherical_coordinates(origin2),sorigin2);
-  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(origin3),sorigin3);
-  check_point<const Point<2>,2>(origin2, Coordinates::spherical_to_cartesian_coordinates<2>(sorigin2));
-  check_point<const Point<3>,3>(origin3, Coordinates::spherical_to_cartesian_coordinates<3>(sorigin3));
-
-  check_point<const std::array<double,2>,2>(Coordinates::cartesian_to_spherical_coordinates(one2),sone2);
-  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(one3),sone3);
-  check_point<const Point<2>,2>(one2, Coordinates::spherical_to_cartesian_coordinates<2>(sone2));
-  check_point<const Point<3>,3>(one3, Coordinates::spherical_to_cartesian_coordinates<3>(sone3));
-
-  check_point<const Point<3>,3>(x, Coordinates::spherical_to_cartesian_coordinates<3>(sx));
-  check_point<const Point<3>,3>(y, Coordinates::spherical_to_cartesian_coordinates<3>(sy));
-  check_point<const Point<3>,3>(z, Coordinates::spherical_to_cartesian_coordinates<3>(sz));
-
-  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(x),sx);
-  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(y),sy);
-  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(z),sz);
-
-  const dealii::Point<3> dateline(0,-1,0);
-  const std::array<double,3> sdateline = {{1,3*numbers::PI/2,numbers::PI/2}};
-
-  check_point<const Point<3>,3>(dateline, Coordinates::spherical_to_cartesian_coordinates<3>(sdateline));
-  check_point<const std::array<double,3>,3>(Coordinates::cartesian_to_spherical_coordinates(dateline),sdateline);
-
-
-  return 42;
-}
-
-int i = f();
diff --git a/tests/coordinate_transformation.prm.bak b/tests/coordinate_transformation.prm.bak
deleted file mode 100644
index 319e7d0b857..00000000000
--- a/tests/coordinate_transformation.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# a test that simply verifies that the plugin described in
-# coordinate_transformation.cc is indeed run
-
-
-
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/coupled_two_phase_tian_parameterization_kinematic_slab.prm.bak b/tests/coupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
deleted file mode 100644
index 1dbaee3a852..00000000000
--- a/tests/coupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-# This test is for the fully coupled Simplified Subduction Model with Parameterized
-# Solid-Fluid Reactions cookbook. It also doubles as a test for the min/max
-# compaction viscosity.
-
-include $ASPECT_SOURCE_DIR/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm
-
-set Adiabatic surface temperature              = 1600
-set Nonlinear solver scheme                    = single Advection, single Stokes
-set End time                                   = 2000
-
-subsection Mesh refinement
-  set Initial global refinement = 1
-
-  subsection Minimum refinement function
-    set Function expression = 1
-  end
-end
-
-# Slightly change composition model to ensure that there is bound_fluid
-# and porosity at the end of the test.
-subsection Boundary composition model
-  set Fixed composition boundary indicators         = left
-  set List of model names                           = function
-
-  subsection Function
-    set Function constants  = initial_porosity=0, initial_bound_sed=0.03, initial_bound_MORB=0.02, initial_bound_gabbro=0.01, \
-                              sediment_min=0, sediment_max=5e3, MORB_min=5e3, MORB_max=12e3, gabbro_min=12e3, gabbro_max=20e3, \
-                              onset_time=0, slab_thickness=20e3
-    set Function expression = initial_porosity; \
-                              if( t<=onset_time, 0, \
-                              if( (y<=slab_thickness - sediment_min) & (y>slab_thickness - sediment_max), initial_bound_sed, \
-                              if( (y<=slab_thickness - MORB_min) & (y>slab_thickness - MORB_max), initial_bound_MORB, \
-                              if( (y<=slab_thickness - gabbro_min) & (y>slab_thickness - gabbro_max), initial_bound_gabbro, 0.0)))); \
-                              if(y>slab_thickness, 1, 0); \
-                              if(y<=8e3, 1, 0); \
-                              if(y>8e3 & y<=15e3, 1, 0); \
-                              if(y>15e3 & y<=slab_thickness, 1, 0)
-  end
-end
-
-subsection Material model
-  subsection Reactive Fluid Transport Model
-    set Minimum compaction viscosity = 1e18
-    set Maximum compaction viscosity = 1e21
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors          = composition statistics, visualization
-
-  subsection Visualization
-    set Output format                 = gnuplot
-    set Time between graphical output = 2000
-
-    subsection Melt material properties
-      set List of properties          = compaction viscosity
-    end
-  end
-end
diff --git a/tests/cpo_simple_shearbox.prm.bak b/tests/cpo_simple_shearbox.prm.bak
deleted file mode 100644
index a7d6fcd02ff..00000000000
--- a/tests/cpo_simple_shearbox.prm.bak
+++ /dev/null
@@ -1,154 +0,0 @@
-set Timing output frequency  = 1000000
-set Dimension                = 3
-set Pressure normalization   = surface
-set Surface pressure         = 0
-set Nonlinear solver scheme  = single Advection, no Stokes
-set End time                 = 2e6
-set Use years in output instead of seconds = false
-set Maximum time step = 1e3
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = water
-  set Compositional field methods = static
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-    set Box origin X coordinate = -0.500
-    set Box origin Y coordinate = -0.500
-    set Box origin Z coordinate = -0.500
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1200 ## Annotation: Temperature function
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top, left, right, front, back
-
-  subsection Box
-    set Bottom temperature = 1200
-    set Left temperature   = 1200
-    set Right temperature  = 1200
-    set Top temperature    = 1200
-    set Front temperature  = 1200
-    set Back temperature   = 1200
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,z,t
-    set Function expression = z*1e-5;0;0 ## Annotation set velocity condition
-  end
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Minimum viscosity = 1e15
-    set Densities = 3300
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 10000
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles, crystal preferred orientation
-
-  subsection Visualization
-    set Time between graphical output = 1e6
-    set List of output variables = viscosity, strain rate, stress, density
-  end
-
-  subsection Crystal Preferred Orientation
-    set Time between data output = 1e6
-    set Write in background thread = true
-    set Compress cpo data files = false
-    set Write out raw cpo data = mineral 0: volume fraction, mineral 0: Euler angles, mineral 1: volume fraction, mineral 1: Euler angles
-    set Write out draw volume weighted cpo data = mineral 0: volume fraction, mineral 0: Euler angles, mineral 1: volume fraction, mineral 1: Euler angles
-  end
-
-  subsection Particles
-    set Time between data output = 1e6
-    set Data output format       = gnuplot
-    set Exclude output properties = a_cosine_matrix, volume fraction
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
-
-subsection Particles
-  set List of particle properties = integrated strain invariant, crystal preferred orientation, cpo bingham average, cpo elastic tensor, elastic tensor decomposition
-  set Particle generator name = ascii file
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = $ASPECT_SOURCE_DIR/data/particle/property/
-      set Data file name = particle_one.dat
-    end
-  end
-
-  subsection Crystal Preferred Orientation
-    set Random number seed = 301
-    set Number of grains per particle = 5
-    set Property advection method = Backward Euler ## Annotation Property advection method
-    set Property advection tolerance = 1e-15
-    set CPO derivatives algorithm = D-Rex 2004
-
-    subsection Initial grains
-      set Minerals = Olivine: A-fabric , Enstatite
-      set Volume fractions minerals = 1.0,0.0
-    end
-
-    subsection D-Rex 2004
-      set Mobility = 125
-      set Stress exponents = 3.5
-      set Exponents p = 1.5
-      set Nucleation efficiency = 5
-      set Threshold GBS = 0.3
-    end
-  end
-
-  subsection CPO Bingham Average
-    set Random number seed = 200
-  end
-end
diff --git a/tests/crameri_benchmark_1_gmg.cc.bak b/tests/crameri_benchmark_1_gmg.cc.bak
deleted file mode 100644
index 6ca69dfb7eb..00000000000
--- a/tests/crameri_benchmark_1_gmg.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/crameri_et_al/case_1/crameri_benchmark_1.cc"
diff --git a/tests/crameri_benchmark_1_gmg.prm.bak b/tests/crameri_benchmark_1_gmg.prm.bak
deleted file mode 100644
index 8dcc9a0b9a5..00000000000
--- a/tests/crameri_benchmark_1_gmg.prm.bak
+++ /dev/null
@@ -1,52 +0,0 @@
-# test gmg + free surface
-
-include $ASPECT_SOURCE_DIR/benchmarks/crameri_et_al/case_1/crameri_benchmark_1.prm
-
-set Dimension = 2
-set End time = 90
-set Output directory = output-crameri-gmg
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Material model
-  set Material averaging =  harmonic average
-end
-
-subsection Postprocess
-  subsection Visualization
-    set Output mesh velocity = true
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = rebound box
-
-  subsection Rebound Box
-    set Order = 1
-    set Amplitude = 7.e3
-  end
-
-  subsection Box
-    set X extent = 28.e5
-    set Y extent = 7.e5
-    set X repetitions = 60
-    set Y repetitions = 15
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-end
diff --git a/tests/crustal_model_3D.prm.bak b/tests/crustal_model_3D.prm.bak
deleted file mode 100644
index 254913117f2..00000000000
--- a/tests/crustal_model_3D.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-############### Global parameters
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set CFL number                             = .5
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-9
-set Max nonlinear iterations               = 2
-set Pressure normalization                 = no
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 128e3
-    set Y extent  =  96e3
-    set Z extent  =  16e3
-    set X repetitions  = 8
-    set Y repetitions  = 3
-  end
-end
-
-# We prescribe a diverging velocity field on the left, right and bottom boundary
-# such that two crustal faults form with an offset between them.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = front, back
-  set Prescribed velocity boundary indicators = left: function, right:function, bottom:function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = cm=0.01, year=1
-    set Function expression = if (x<56e3 && y<=48e3 | x<72e3 && y>48e3, -1*cm/year, 1*cm/year) ; 0 ; 0
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = top: free surface
-
-  # Advecting the free surface vertically rather than
-  # in the surface normal direction can result in a
-  # more stable mesh when the deformation is large
-  subsection Free surface
-    set Surface velocity projection = vertical
-  end
-end
-
-subsection Material model
-  set Model name = drucker prager
-
-  subsection Drucker Prager
-    set Reference density = 2800
-
-    subsection Viscosity
-      set Minimum viscosity = 1e19
-      set Maximum viscosity = 1e25
-      set Reference strain rate = 1e-20
-      set Angle of internal friction = 30
-      set Cohesion = 20e6
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Refinement fraction                = 0.9
-  set Strategy                           = strain rate
-  set Coarsening fraction                = 0.05
-  set Minimum refinement level           = 1
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography, pressure statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density, viscosity, strain rate, error indicator
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-9
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/custom_spherical_shell_2d_list.prm.bak b/tests/custom_spherical_shell_2d_list.prm.bak
deleted file mode 100644
index 243a9faba50..00000000000
--- a/tests/custom_spherical_shell_2d_list.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# Use a comma-separated list of radius values to extrude a custom mesh
-# as an extension of the default spherical shell geometry (2d case)
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 2000.0
-    set Outer temperature = 1000.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 5711000
-    set Outer radius = 6371000
-    set Opening angle = 360
-    set Custom mesh subdivision = list of radial values
-    set List of radial values = 5961000, 6151000  # depth values 220 km and 410 km
-    set Initial lateral refinement = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1500.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Output format       = gnuplot
-    set Interpolate output = false
-  end
-end
diff --git a/tests/custom_spherical_shell_2d_slices.prm.bak b/tests/custom_spherical_shell_2d_slices.prm.bak
deleted file mode 100644
index 2830b0c6c92..00000000000
--- a/tests/custom_spherical_shell_2d_slices.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# This is a simple 2d setup for testing a custom spherical shell
-# using the number of slices subdivision scheme.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 2000.0
-    set Outer temperature = 1000.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Custom mesh subdivision = number of slices
-    set Number of slices = 2
-    set Inner radius = 5711000
-    set Outer radius = 6371000
-    set Initial lateral refinement = 1
-    set Opening angle = 360
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1500.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format      = gnuplot
-  end
-end
diff --git a/tests/custom_spherical_shell_3d_list.prm.bak b/tests/custom_spherical_shell_3d_list.prm.bak
deleted file mode 100644
index 3c8a95c9c3f..00000000000
--- a/tests/custom_spherical_shell_3d_list.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# Use a comma-separated list of radius values to extrude a custom mesh
-# as an extension of the default spherical shell geometry (3d case)
-
-set Dimension                              = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 2000.0
-    set Outer temperature = 1000.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 5711000
-    set Outer radius = 6371000
-    set Opening angle = 360
-    set Custom mesh subdivision = list of radial values
-    set List of radial values = 5961000, 6151000  # depth values 220 km and 410 km
-    set Initial lateral refinement = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1500.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Output format      = gnuplot
-    set Interpolate output = false
-  end
-end
diff --git a/tests/custom_spherical_shell_3d_slices.prm.bak b/tests/custom_spherical_shell_3d_slices.prm.bak
deleted file mode 100644
index 47df314ab6d..00000000000
--- a/tests/custom_spherical_shell_3d_slices.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# This is a simple 3d setup for testing a custom spherical shell
-# using the number of slices subdivision scheme.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 2000.0
-    set Outer temperature = 1000.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Custom mesh subdivision = number of slices
-    set Number of slices = 2
-    set Inner radius = 5711000
-    set Outer radius = 6371000
-    set Initial lateral refinement = 1
-    set Opening angle = 360
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1500.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format      = gnuplot
-  end
-end
diff --git a/tests/damped_viscoelastic_bending_beam.prm.bak b/tests/damped_viscoelastic_bending_beam.prm.bak
deleted file mode 100644
index 51ff4a8c6cc..00000000000
--- a/tests/damped_viscoelastic_bending_beam.prm.bak
+++ /dev/null
@@ -1,49 +0,0 @@
-# This test checks whether the viscoelastic bending beam benchmark
-# run successfully in combination with a viscous damper for the
-# elastic viscosity.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-set End time  = 1e3
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 10
-  end
-end
-
-# Material model, adding viscous dampers to each material.
-# The material response is only significantly affected if
-# the damper viscosity is similar to or greater than
-# the product of the elastic timestep and the shear modulus.
-# A damper value of 0 Pas corresponds to purely elastic deformation.
-
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities            =  2800,  2800,  2800,  2800,  3300
-    set Viscosities          = 1.e18, 1.e18, 1.e18, 1.e18, 1.e24
-    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
-    set Fixed elastic time step     = 1e3
-    set Elastic damper viscosity    = 1e14
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = maximum composition
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/darcy_velocity.cc.bak b/tests/darcy_velocity.cc.bak
deleted file mode 100644
index 41a9c23ffdf..00000000000
--- a/tests/darcy_velocity.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "rising_melt_blob.cc"
diff --git a/tests/darcy_velocity.prm.bak b/tests/darcy_velocity.prm.bak
deleted file mode 100644
index 0036483f25a..00000000000
--- a/tests/darcy_velocity.prm.bak
+++ /dev/null
@@ -1,145 +0,0 @@
-#########################################################
-# This is a test for the new advection method that advects a
-# compositional field with the fluid velocity prescribed by
-# Darcy's Law. Darcy's law is approximated here with:
-# u_f = u_s - K_D / phi * (rho_s * g - rho_f * g)
-# u_f = fluid velocity
-# u_s = solid velocity
-# K_D = Darcy Coefficient
-# phi = porosity
-# rho_f = fluid density
-# rhos_s = solid density
-# g = gravity
-# The second term on the rhs of Darcy's Law only contributes
-# to the component of the  fluid velocity parallel to the gravity
-# vector, which is proportional to the buoyancy of the fluid phase.
-
-# The initial porosity is uniform everywhere, and in the
-# center of the model is a blob of 'fluid' and 'solid'.
-# The solid has a prescribed x velocity, and so the fluid
-# blob should be advected horizontally with the solid velocity and
-# vertically as it rises up due to its buoyancy.
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 500
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 5
-set CFL number                             = 0.5
-set Output directory                       = darcy_velocity
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Maximum time step                      = 500
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 200000
-    set Y extent = 100000
-    set X repetitions = 2
-  end
-end
-
-# This model is only designed to predict fluid velocities arising from initial prescribed values in porosity.
-# As such, no variations in temperature are needed and both the boundary and initial temperatures are held constant.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 293
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top, bottom, left, right
-
-  subsection Box
-    set Bottom temperature = 293
-    set Top temperature    = 293
-    set Left temperature   = 293
-    set Right temperature  = 293
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x:function, right x:function
-  set Tangential velocity boundary indicators = top, bottom
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x,y,t
-    set Function expression = 1;0
-  end
-end
-
-############### Compositional fields
-# We want to use three compositional fields, the porosity and
-# and two additional fields. The solid field will be advected with
-# the solid speed prescribed above, and the fluid field will be advected
-# as the sum of the solid velocity and the vertical buoyancy the fluid has.
-# The porosity field is uniform to allow for a uniform fluid velocity. The
-# fluid field is a circle of radius 12.5km at the center of the model domain.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, fluid
-  set Compositional field methods = darcy field, darcy field
-  set Types of fields = porosity, generic
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=12500, A_f=0.2, A_s = 1.0
-    set Function expression = A_f; if((x - x0)*(x - x0) + (y - y0)*(y - y0) <= c*c, A_s, 0)
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators = bottom, top, left, right
-  set Allow fixed composition on outflow boundaries = true
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# The 'melting rate' material model from rising_melt_blob.cc is being
-# used since it provides terms for the fluid phase in this test. Melt
-# is not actually turned on, but the structure of the material model is
-# being used to fill fluid related parameters.
-subsection Material model
-  set Model name = melting rate
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, maximum depth of field
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/darcy_velocity_vertical.cc.bak b/tests/darcy_velocity_vertical.cc.bak
deleted file mode 100644
index 41a9c23ffdf..00000000000
--- a/tests/darcy_velocity_vertical.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "rising_melt_blob.cc"
diff --git a/tests/darcy_velocity_vertical.prm.bak b/tests/darcy_velocity_vertical.prm.bak
deleted file mode 100644
index fb89d6ee3bc..00000000000
--- a/tests/darcy_velocity_vertical.prm.bak
+++ /dev/null
@@ -1,37 +0,0 @@
-#########################################################
-# This is a test for the new advection method that advects a
-# compositional field with the fluid velocity prescribed by
-# Darcy's Law. Darcy's law is approximated here with:
-# u_f = u_s - K_D / phi * (rho_s * g - rho_f * g)
-# u_f = fluid velocity
-# u_s = solid velocity
-# K_D = Darcy Coefficient
-# phi = porosity
-# rho_f = fluid density
-# rhos_s = solid density
-# g = gravity
-# The second term on the rhs of Darcy's Law only contributes
-# to the component of the  fluid velocity parallel to the gravity
-# vector, which is proportional to the buoyancy of the fluid phase.
-
-# The initial porosity is uniform everywhere, and in the
-# center of the model is a blob of 'fluid' and 'solid'.
-# The solid has a prescribed y velocity that is exactly the opposite
-# of the Darcy velocity, and so the fluid blob should not move.
-
-############### Global parameters
-
-include $ASPECT_SOURCE_DIR/tests/darcy_velocity.prm
-
-set End time                               = 200
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top y:function, bottom y:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x,y,t
-    set Function expression = 0;-6.31152
-  end
-end
diff --git a/tests/dash_dash.cc.bak b/tests/dash_dash.cc.bak
deleted file mode 100644
index f3ae96f5b56..00000000000
--- a/tests/dash_dash.cc.bak
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-
-// create a function that is run upon loading the plugin.  as discussed in the
-// corresponding .prm file, this function simply calls ASPECT again, and then
-// terminates the original instance of ASPECT
-int f()
-{
-  // call ASPECT with "--" and pipe an existing input file into it.
-  //
-  // notes:
-  // - the box_origin.prm file contains no explicit output directory
-  //   (nor would that be helpful here), so we also pipe the name
-  //   for a temporary output directory into ASPECT
-  // - if this directory does not exist, this would trigger
-  //   ASPECT's 'directory appears not to exist' warning.
-  //   consequently, remove the directory if it existed before
-  //   and re-create it as an empty directory
-  system ("cd output-dash_dash ; "
-          "(cat " ASPECT_SOURCE_DIR "/tests/box_origin.prm "
-          " ; "
-          " echo 'set Output directory = output.tmp' "
-          " ; "
-          " rm -rf output.tmp ; mkdir output.tmp "
-          ") "
-          "| ../../aspect -- ");
-  exit (0);
-}
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/dash_dash.prm.bak b/tests/dash_dash.prm.bak
deleted file mode 100644
index 6926345742a..00000000000
--- a/tests/dash_dash.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-# Test that we indeed read from stdin when the input file is given as "--"
-
-# This .prm file is really a sham. Its only purpose is to set up a test that
-# automatically loads a shared library that only starts aspect (again!) with
-# "--" as argument, and when that has finished running terminates the original
-# copy of aspect. In other words, the original aspect is only used to load a
-# shared library, nothing else, and so the contents of the current .prm file do
-# not matter.
diff --git a/tests/dc_Picard_compressible.prm.bak b/tests/dc_Picard_compressible.prm.bak
deleted file mode 100644
index d7cbe095d27..00000000000
--- a/tests/dc_Picard_compressible.prm.bak
+++ /dev/null
@@ -1,263 +0,0 @@
-#### This is a compressible whole Earth model solved by the
-#### single Advection, iterated dc Stokes. This represent a coarse
-#### version of a production type setup.
-#### Global parameters
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-set Nonlinear solver scheme                = single Advection, iterated defect correction Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 150
-set Max nonlinear iterations in pre-refinement = 0
-set Pressure normalization                 = surface
-set Maximum time step                      = 1e6
-
-#set Number of cheap Stokes solver steps    = 200  # aspect 2.2
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 0.5
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set GMRES solver restart length = 250
-    set Linear solver tolerance             = 1e-2
-    set Maximum number of expensive Stokes solver steps = 1000
-    set Number of cheap Stokes solver steps    = 200
-  end
-end
-
-#### Model Geometry
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3485e3
-    set Outer radius  = 6371e3 #5961e3
-    set Opening angle = 360
-  end
-end
-
-#### Mesh refinement
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Variable names      = depth,t
-    set Coordinate system = depth
-    set Function expression = if(depth<=200e3, 5,if(depth<=620e3, 5,if(depth<=680e3,5,if(depth>=2586e3,5,5))))
-
-    #if(depth<560e3,0,if(depth>760e3,0,6))
-    #        if(depth<560e3,5,if(depth>760e3,5,6))
-  end
-end
-
-##### Set temperature Model
-subsection Boundary temperature model
-  #set Allow fixed temperature on outflow boundaries = true  # default
-  set Fixed temperature boundary indicators         = bottom, top
-
-  #  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 273 #273 for surface ############
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators       = inner, outer
-
-  # set Zero velocity boundary indicators             = outer
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-# Number and names of compositional fields
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = plastic_strain #add strain field
-end
-
-#### Temperature model
-subsection Initial temperature model
-  #set Model name = adiabatic
-  set List of model names =  adiabatic, function
-  set List of model operators = add
-
-  #  set Model name = adiabatic
-  subsection Adiabatic
-    set Age bottom boundary layer = 100.e6
-    set Age top boundary layer = 100.e6
-    set Radius = 0
-    set Amplitude = 0
-    set Position = center
-    set Subadiabaticity = 0
-
-    #    subsection Function
-    #      set Variable names      = x,y
-    #      set Function constants  = R=6371.e3
-    #      set Function expression = #                                if(sqrt(x*x+y*y)<=R-660.e3, 1, 0); #                                if(sqrt(x*x+y*y)>R-660.e3, 1, 0)
-    #   end
-  end
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names      = x,y,z
-    set Function constants  = R=6371.e3
-    set Function expression = \
-                               if(sqrt(x*x+y*y)<=R<100e3, rand_seed(1) * 100 -50 , 0)
-  end
-end
-
-subsection Adiabatic conditions model # need to initialize for initial adiabatic temp.
-  #send
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_isentrope.txt
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating, radioactive decay
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-
-  subsection Radioactive decay
-    set Crust defined by composition = false
-    set Crust depth = 10e3
-    set Half decay times = 4.468e9, 0.704e9, 14e9, 1.248e9
-    set Heating rates = 9.4946e-5, 5.68e-4, 2.6368e-5, 2.8761e-5
-    set Initial concentrations crust = 0.0, 0.0, 0.0, 0.0
-    set Initial concentrations mantle = 0.0082, 0.000059, 0.024, 0.013
-    set Number of elements = 4
-  end
-
-  #set List of model names = compositional heating
-end
-
-############################ MATERIAL MODEL ######################################################################
-
-subsection Material model
-  set Model name = compositing #visco plastic #melt simple
-  set Material averaging = harmonic average
-
-  ############################ MATERIAL MODEL ######################################################################
-  subsection Compositing
-    set Viscosity = visco plastic
-    set Density = ascii reference profile
-    set Thermal expansion coefficient = ascii reference profile
-    set Specific heat = ascii reference profile
-    set Thermal conductivity = visco plastic
-    set Compressibility = ascii reference profile
-    set Entropy derivative pressure = ascii reference profile
-    set Entropy derivative temperature = ascii reference profile
-    set Reaction terms = visco plastic
-  end
-
-  subsection Ascii reference profile
-    set Thermal conductivity =  3.0
-
-    subsection Ascii data model
-      set Data file name = example_isentrope.txt
-      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    end
-  end
-
-  subsection Visco Plastic
-    set Define transition by depth instead of pressure  = true
-    set Phase transition Clapeyron slopes = background: 3.0e6|-2.5e6|9.e6
-    set Phase transition depths           = background: 410e3|660e3|2740e3
-    set Phase transition widths           = background: 12e3|23e3|11e3
-    set Phase transition temperatures     = background: 1770|1852|2591
-
-    # Reference temperature and viscosity
-    set Reference temperature = 293
-
-    # The minimum strain-rate helps limit large viscosities values that arise
-    # as the strain-rate approaches zero.
-    # The reference strain-rate is used on the first non-linear iteration
-    # of the first time step when the velocity has not been determined yet.
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-
-    # Limit the viscosity with minimum and maximum values
-    set Minimum viscosity = 1e20
-    set Maximum viscosity = 1e26
-
-    # Harmonic viscosity averaging
-    set Viscosity averaging scheme = harmonic
-
-    # Choose to have the viscosity (pre-yield) follow a dislocation
-    # diffusion or composite flow law.  Here, dislocation is selected
-    # so no need to specify diffusion creep parameters below, which are
-    # only used if "diffusion" or "composite" option is selected.
-    set Viscous flow law = diffusion
-
-    #  from cizkov
-    #     order:                           background    ,        mantle_low        ,        mantle_up
-    #    set Thermal diffusivities =   8.384146341463415e-07,     8.384146341463415e-07   , 7.309941520467837e-07
-
-    set Thermal diffusivities = 1.e-6
-    set Thermal expansivities = background: 3.e-5|2.e-5|2.e-5|2.e-5, plastic_strain: 3.e-5
-    set Heat capacities       =        1250     # specific heat
-    set Densities             = background: 3416|3800|4750|4750, plastic_strain: 3416
-
-    #    set Thermal expansivities =      3.0e-5  ,              3.0e-5,                     2.7e-5
-    #     Dislocation creep                                                 #(1/2)^3.5 * 1e-17
-    set Prefactors for dislocation creep          = background: 1e-22|1e-22|1e-30|1e-30, plastic_strain:1e-22
-    set Stress exponents for dislocation creep    = 3.5
-    set Activation energies for dislocation creep = background: 4.8e5|4.8e5|4.8e5|4.8e5, plastic_strain:4.8e5
-    set Activation volumes for dislocation creep  = background: 11.e-6|11.e-6|11.e-6|11.e-6, plastic_strain: 11.e-6
-
-    #     Diffusion creep
-    set Prefactors for diffusion creep            = background: 1.e-9|1.e-9|1.0e-16|1.0e-16, plastic_strain: 1.e-9
-    set Stress exponents for diffusion creep      = 1.0                                                  #### doesnt exist anymore??? ####
-    set Activation energies for diffusion creep   = background: 3.35e5|3.35e5|2.e5|2.e5, plastic_strain: 3.35e5
-    set Activation volumes for diffusion creep    = background: 4.8e-6|4.8e-6|1.1e-6|1.1e-6, plastic_strain: 4.8e-6
-    set Grain size                                = 1 #1e-3
-    set Grain size exponents for diffusion creep  = 0   #default
-
-    ###    # Plasticity parameters
-    set Angles of internal friction = background: 0|0|0|0, plastic_strain:0            # Angle Mohr
-    set Cohesions                   = background: 40e6|1e20|1e20|1e20, plastic_strain:40e6
-    set Strain weakening mechanism = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals = 1.e30
-    set Cohesion strain weakening factors = 1
-    set Friction strain weakening factors = 1
-    set End plasticity strain weakening intervals = 2.e30
-  end
-end
-
-#######################
-# Gravity model
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
-
-#######################
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, \
-                               composition statistics, depth average, heat flux statistics
-
-  subsection Depth average
-    set Number of zones = 3
-    set Output format = txt
-    set Time between graphical output = 1e7
-    set Depth boundaries of zones = 0, 10000,150000,2900000
-  end
-end
diff --git a/tests/density_boundary.prm.bak b/tests/density_boundary.prm.bak
deleted file mode 100644
index 9f17af0f0e9..00000000000
--- a/tests/density_boundary.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# This is a relatively realistic compressible model setup.
-# There is no simple analytical solution to it, it is rather
-# intended to serve as a comparison for more complicated
-# material models, which should be able to reproduce it.
-# The material model used here is already tested by
-# simple_compressibility_iterated_stokes.
-# Currently there is the steinberger_compressible test
-# reproducing this test.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-    set Reference compressibility = 2.5e-12
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, boundary densities
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/depth_average_01.prm.bak b/tests/depth_average_01.prm.bak
deleted file mode 100644
index 3ad349605ae..00000000000
--- a/tests/depth_average_01.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# Test the 'depth average' postprocessor on a coarse mesh version of
-# convection_box.prm. This test makes no sense since we average over 10 depth
-# intervals but we only compute on a 4x4 mesh -- This is sufficient to produce
-# reasonable data, but not enough for actual resolution.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Time between graphical output = 0.1
-    set Number of zones = 10
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-15
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-15
-  end
-end
diff --git a/tests/depth_average_02.prm.bak b/tests/depth_average_02.prm.bak
deleted file mode 100644
index 8c5bb292eab..00000000000
--- a/tests/depth_average_02.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# Like the _01 test, but adjust the number of intervals we compute on
-# in such a way that it makes sense for the 4x4 mesh we have here
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Time between graphical output = 0.1
-    set Number of zones = 4
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-15
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-15
-  end
-end
diff --git a/tests/depth_average_03.prm.bak b/tests/depth_average_03.prm.bak
deleted file mode 100644
index b6f6ef0667a..00000000000
--- a/tests/depth_average_03.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# Like the _02 test, but create output in years. At one point I
-# believed that this was previously ignored (despite assurances in the
-# manual) but it turned out to work nevertheless. Anyway, it's good to
-# have a test.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 10 # but note the very low viscosity
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1e+9
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    # output every 5 years (noting that 'Use years in
-    # output instead of seconds' is set). For the current
-    # model, this means twice
-    set Time between graphical output = 5
-    set Number of zones = 4
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-15
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-15
-  end
-end
diff --git a/tests/depth_average_04.prm.bak b/tests/depth_average_04.prm.bak
deleted file mode 100644
index be78266ebea..00000000000
--- a/tests/depth_average_04.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# Like _03, but output stuff in a different format than gnuplot
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 10 # but note the very low viscosity
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1e+9
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    # output every 5 years (noting that 'Use years in
-    # output instead of seconds' is set). For the current
-    # model, this means twice
-    set Time between graphical output = 5
-    set Number of zones = 4
-    set Output format = vtk
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-15
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-15
-  end
-end
diff --git a/tests/depth_average_05.prm.bak b/tests/depth_average_05.prm.bak
deleted file mode 100644
index 5d457e2820f..00000000000
--- a/tests/depth_average_05.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# Test outputting a subset of the available laterally-averaged
-# quantities in the DepthAverage postprocessor.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Time between graphical output = 0.1
-    set Number of zones = 10
-
-    # Test outputting a subset of the depth-averaged quantities
-    set List of output variables = velocity magnitude, temperature
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-15
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-15
-  end
-end
diff --git a/tests/depth_average_06.prm.bak b/tests/depth_average_06.prm.bak
deleted file mode 100644
index bc2b38c6e6b..00000000000
--- a/tests/depth_average_06.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-# Test the 'depth average' postprocessor, specifically the
-# vertical mass flux value. In this model the mass flux
-# is upwards and varies linearly from 0.5 to 1.0 across
-# the model.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = y
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   =
-  set List of model names =
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Prescribed velocity boundary indicators = top: function, bottom: function
-
-  subsection Function
-    set Function expression = 0.0; 1.0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0.5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Time between graphical output = 0.1
-    set Number of zones = 10
-    set Output format = txt
-  end
-end
diff --git a/tests/depth_average_rounding_bug.prm.bak b/tests/depth_average_rounding_bug.prm.bak
deleted file mode 100644
index ab2c117db35..00000000000
--- a/tests/depth_average_rounding_bug.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# Test to verify the following rounding bug in depth-averaging is fixed:
-#
-# An error occurred in line <107> of file <source/simulator/lateral_averaging.cc> in function
-# The violated condition was:
-#     idx<num_slices
-
-set Dimension                              = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 30
-    set Chunk maximum longitude = 67
-    set Longitude repetitions = 1
-    set Chunk minimum latitude = 0
-    set Chunk maximum latitude = 41
-    set Latitude repetitions = 1
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer
-  set Zero velocity boundary indicators       = inner, west, east
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 1e3
-    set Output format                 = gnuplot
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 50
-end
diff --git a/tests/depth_average_txt_output.prm.bak b/tests/depth_average_txt_output.prm.bak
deleted file mode 100644
index 00cabdc42bf..00000000000
--- a/tests/depth_average_txt_output.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# Test outputting laterally-averaged quantities from the
-# DepthAverage postprocessor in a plain ascii text table format.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Time between graphical output = 0.1
-    set Number of zones = 10
-    set List of output variables = velocity magnitude, temperature
-    set Output format = txt
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-15
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-15
-  end
-end
diff --git a/tests/depth_average_underres.prm.bak b/tests/depth_average_underres.prm.bak
deleted file mode 100644
index d1c61b2cd41..00000000000
--- a/tests/depth_average_underres.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# Duplicate of depth_average_01, with coarser mesh
-
-# Test the 'depth average' postprocessor on a coarse mesh version of
-# convection_box.prm. This test makes no sense since we average over 21 depth
-# intervals but we only compute on a 2x2 mesh -- one of the depth intervals
-# will receive no quadrature points
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Time between graphical output = 0.1
-    set Number of zones = 21
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-15
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-15
-  end
-end
diff --git a/tests/depth_dependent_3d_shell_list_simple.prm.bak b/tests/depth_dependent_3d_shell_list_simple.prm.bak
deleted file mode 100644
index c57582c0d7a..00000000000
--- a/tests/depth_dependent_3d_shell_list_simple.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# Test depth-dependent material model for a 3d spherical
-# shell geometry calculation using base model ''simple''
-# and depth dependence taken from list
-# A simple setup for convection in a 3d shell. See the
-# manual for more information.
-
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1.0e5
-set Output directory                       = output-depth-dependent-3d-shell-list-simple
-
-subsection Material model
-  set Model name = depth dependent
-
-  subsection Depth dependent model
-    set Base model = simple
-    set Depth dependence method = List
-    set Depth list = 6.7e5, 3.481e6
-    set Viscosity list = 1.0e21, 3.0e22
-    set Reference viscosity = 1e22
-  end
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1973
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1473
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 1.0e6
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 50
-end
diff --git a/tests/depth_dependent_additional_outputs.prm.bak b/tests/depth_dependent_additional_outputs.prm.bak
deleted file mode 100644
index 5659a4b6534..00000000000
--- a/tests/depth_dependent_additional_outputs.prm.bak
+++ /dev/null
@@ -1,34 +0,0 @@
-# Like grain_size_growth.prm, but check that additional
-# material model outputs can be postprocessed correctly
-# in the depth-dependent material model.
-
-############### Global parameters
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
-
-set End time = 0
-
-subsection Material model
-  set Model name = depth dependent
-
-  subsection Depth dependent model
-    set Base model = grain size
-    set Reference viscosity = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = named additional outputs
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/depth_dependent_box_file_simple.prm.bak b/tests/depth_dependent_box_file_simple.prm.bak
deleted file mode 100644
index a8be50f11da..00000000000
--- a/tests/depth_dependent_box_file_simple.prm.bak
+++ /dev/null
@@ -1,159 +0,0 @@
-# Test depth-dependent material model in 2d box using a file
-# to specify depth-dependence. This test uses the default viscosity
-# structure, defined in the documentation.
-
-# A description of convection in a 2d box. See the manual for more information.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 1.0e8
-set Output directory                       = output-depth-dependent-box-file-simple
-
-# Then there are variables that describe the tolerance of
-# the linear solver as well as how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.0e6
-    set Y extent = 3.0e6
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
-    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above. (As will be seen
-# in the next section, the actual temperature prescribed here
-# at the left and right does not matter.)
-# We then also have to prescribe several other parts of the model such as
-# which boundaries actually carry a prescribed boundary temperature, whereas
-# all other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 2773
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 273.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = depth dependent
-
-  subsection Depth dependent model
-    set Base model = simple
-    set Depth dependence method = File
-    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/depth-dependent/
-    set Viscosity depth file = visc_depth.txt
-    set Reference viscosity = 1e25
-  end
-
-  subsection Simple model
-    set Reference density             = 3300.0
-    set Reference specific heat       = 1250.0
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e25
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/depth_dependent_box_function_simple.prm.bak b/tests/depth_dependent_box_function_simple.prm.bak
deleted file mode 100644
index c170cf1a926..00000000000
--- a/tests/depth_dependent_box_function_simple.prm.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-# Test depth-dependent material model using simple material model as
-# base model with depth-dependence specified by user-provided function
-
-# A description of convection in a 2d box. See the manual for more information.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 1.0e8
-set Output directory                       = output-depth-dependent-box-function-simple
-
-# Then there are variables that describe the tolerance of
-# the linear solver as well as how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.0e6
-    set Y extent = 3.0e6
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
-    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above. (As will be seen
-# in the next section, the actual temperature prescribed here
-# at the left and right does not matter.)
-# We then also have to prescribe several other parts of the model such as
-# which boundaries actually carry a prescribed boundary temperature, whereas
-# all other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 2773
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 273.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = depth dependent
-
-  subsection Depth dependent model
-    set Base model = simple
-    set Depth dependence method = Function
-    set Reference viscosity = 1e25
-
-    subsection Viscosity depth function
-      set Variable names = d
-      set Function expression = if(d>6.70e5,3.0e22,1.0e21);
-    end
-  end
-
-  subsection Simple model
-    set Reference density             = 3300.0
-    set Reference specific heat       = 1250.0
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e25
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics,  depth average
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/depth_dependent_box_function_time_dependent.prm.bak b/tests/depth_dependent_box_function_time_dependent.prm.bak
deleted file mode 100644
index 984d2c0a8f9..00000000000
--- a/tests/depth_dependent_box_function_time_dependent.prm.bak
+++ /dev/null
@@ -1,164 +0,0 @@
-# Test depth-dependent material model using simple material model as
-# base model with depth-dependence specified by user-provided function.
-# This is an extended copy from depth_dependent_box_function that
-# uses a time dependent function to prescribe depth dependent viscosity.
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 1.0e8
-set Output directory                       = output-depth-dependent-box-function-time-dependent
-
-# Then there are variables that describe the tolerance of
-# the linear solver as well as how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.0e6
-    set Y extent = 3.0e6
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
-    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above. (As will be seen
-# in the next section, the actual temperature prescribed here
-# at the left and right does not matter.)
-# We then also have to prescribe several other parts of the model such as
-# which boundaries actually carry a prescribed boundary temperature, whereas
-# all other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 2773
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 273.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = depth dependent
-
-  subsection Depth dependent model
-    set Base model = simple
-    set Depth dependence method = Function
-    set Reference viscosity = 1e25
-
-    subsection Viscosity depth function
-      set Variable names = d,t
-      set Function expression = if(d>6.70e5,3.0e22*(1.0+t/1e8),1.0e21*(1.0+t/1e8));
-    end
-  end
-
-  subsection Simple model
-    set Reference density             = 3300.0
-    set Reference specific heat       = 1250.0
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e25
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics,  depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/depth_dependent_box_none_simple.prm.bak b/tests/depth_dependent_box_none_simple.prm.bak
deleted file mode 100644
index 171f1720630..00000000000
--- a/tests/depth_dependent_box_none_simple.prm.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-# Test depth-dependent material model in 2d box using simple material model as
-# base model with no depth-dependence
-
-# A description of convection in a 2d box. See the manual for more information.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 1.0e8
-
-#set Output directory                       = output
-
-# Then there are variables that describe the tolerance of
-# the linear solver as well as how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.0e6
-    set Y extent = 3.0e6
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
-    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above. (As will be seen
-# in the next section, the actual temperature prescribed here
-# at the left and right does not matter.)
-# We then also have to prescribe several other parts of the model such as
-# which boundaries actually carry a prescribed boundary temperature, whereas
-# all other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 2773
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 273.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = depth dependent
-
-  subsection Depth dependent model
-    set Base model = simple
-    set Depth dependence method = None
-    set Reference viscosity = 1e25
-  end
-
-  subsection Simple model
-    set Reference density             = 3300.0
-    set Reference specific heat       = 1250.0
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e25
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/depth_dependent_initialize_base_model.prm.bak b/tests/depth_dependent_initialize_base_model.prm.bak
deleted file mode 100644
index 84a05525bde..00000000000
--- a/tests/depth_dependent_initialize_base_model.prm.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-# A test that makes sure that the depth dependent material model
-# correctly initializes its base model (if the base model needs
-# initialization).
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-
-subsection Material model
-  set Model name = depth dependent
-  set Material averaging = harmonic average
-
-  subsection Depth dependent model
-    set Base model = ascii reference profile
-    set Depth dependence method = None
-    set Reference viscosity = 1e21
-  end
-
-  subsection Ascii reference profile
-    set Thermal viscosity exponent = 0
-    set Viscosity prefactors = 1.0, 1.0, 1.0, 1.0
-
-    subsection Ascii data model
-      set Data file name = example_isentrope.txt
-      set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    end
-  end
-end
-
-# The geometry is a spherical shell with the inner and
-# outer radius of the Earth's mantle.
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Adiabatic conditions model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_isentrope.txt
-  end
-end
-
-# The gravity model reads an ascii data file that contains a gravity
-# profile consistent with the material properties computed using the
-# Birch-Murnaghan equation of state. It automatically uses the same file
-# specified in the adiabatic conditions model.
-subsection Gravity model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/adiabatic-conditions/ascii-data/
-    set Data file name = example_isentrope.txt
-  end
-end
-
-# The model uses the anelastic liquid approximation.
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
-
-# The present-day plate velocities are imposed on the upper model
-# boundary.
-
-
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = outer:gplates
-  set Tangential velocity boundary indicators = inner
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 273
-  end
-end
-
-# The initial temperature is an adiabatic profile, which is
-# taken from the adiabatic conditions model. In this case, this is
-# is the ascii data model that loads a file containing profiles
-# corresponding to the Birch-Murnaghan equation of state.
-# In addition to the adiabatic profile, there are thermal boundary
-# layers at the surface and the core-mantle boundary.
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Mesh refinement
-  set Refinement fraction                = 0.4
-  set Coarsening fraction                = 0.05
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 2
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 5
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/tests/depth_postprocessor_box.prm.bak b/tests/depth_postprocessor_box.prm.bak
deleted file mode 100644
index b8ad2c0b598..00000000000
--- a/tests/depth_postprocessor_box.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = depth
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/depth_postprocessor_chunk.prm.bak b/tests/depth_postprocessor_chunk.prm.bak
deleted file mode 100644
index ec7cdd6eaa9..00000000000
--- a/tests/depth_postprocessor_chunk.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 0.75
-    set Chunk maximum longitude = 10
-    set Chunk maximum latitude = 10
-    set Radius repetitions = 2
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy = temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = depth
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/depth_postprocessor_ellipsoidal_chunk.prm.bak b/tests/depth_postprocessor_ellipsoidal_chunk.prm.bak
deleted file mode 100644
index 6a581bdad65..00000000000
--- a/tests/depth_postprocessor_ellipsoidal_chunk.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = east, west
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = west: 0, east: 1
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Geometry model
-  set Model name = ellipsoidal chunk
-
-  subsection Ellipsoidal chunk
-    set NE corner = 5:30
-    set NW corner = 0:0
-    set SE corner = 10:-10
-    set Depth = 3000000
-    set Eccentricity = 0.5
-    set East-West subdivisions = 2
-    set North-South subdivisions = 2
-    set Depth subdivisions = 2
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Strategy = temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = depth
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/depth_postprocessor_sphere.prm.bak b/tests/depth_postprocessor_sphere.prm.bak
deleted file mode 100644
index 06072219de9..00000000000
--- a/tests/depth_postprocessor_sphere.prm.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 0
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = surface: 0.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial linear
-
-  subsection Radial linear
-    set Magnitude at bottom = 0.0
-  end
-end
-
-subsection Geometry model
-  set Model name = sphere
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1000
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e20
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy = temperature
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = depth
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/depth_postprocessor_spherical_shell.prm.bak b/tests/depth_postprocessor_spherical_shell.prm.bak
deleted file mode 100644
index 32bbc7697ad..00000000000
--- a/tests/depth_postprocessor_spherical_shell.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1000
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e20
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Strategy = temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = depth
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/depth_postprocessor_two_merged_boxes.prm.bak b/tests/depth_postprocessor_two_merged_boxes.prm.bak
deleted file mode 100644
index 49a196df9bf..00000000000
--- a/tests/depth_postprocessor_two_merged_boxes.prm.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box with lithosphere boundary indicators
-
-  subsection Box with lithosphere boundary indicators
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = depth
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/derivative_of_weighted_p_norm_average.cc.bak b/tests/derivative_of_weighted_p_norm_average.cc.bak
deleted file mode 100644
index f020c66dc46..00000000000
--- a/tests/derivative_of_weighted_p_norm_average.cc.bak
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/utilities.h>
-
-int f()
-{
-  using namespace aspect;
-
-  std::vector<double> weights = {1,2};
-  std::vector<double> values = {3,4};
-  std::vector<double> derivatives = {5,6};
-  std::vector<double> p_norms = {-1000,-2.5,-2,-1,0,1,2,2.5,3,4,1000};
-
-  for (unsigned int i = 0; i < p_norms.size(); i++)
-    {
-      std::cout << "p = " << p_norms[i] << ", average = " << aspect::Utilities::derivative_of_weighted_p_norm_average<double>(0,weights,values,derivatives,p_norms[i]) << std::endl;
-    }
-
-  exit(0);
-  return 42;
-}
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/derivative_of_weighted_p_norm_average.prm.bak b/tests/derivative_of_weighted_p_norm_average.prm.bak
deleted file mode 100644
index bcddea0d59b..00000000000
--- a/tests/derivative_of_weighted_p_norm_average.prm.bak
+++ /dev/null
@@ -1 +0,0 @@
-set Additional shared libraries = tests/libderivative_of_weighted_p_norm_average.so
diff --git a/tests/diffusion.prm.bak b/tests/diffusion.prm.bak
deleted file mode 100644
index a83283bd668..00000000000
--- a/tests/diffusion.prm.bak
+++ /dev/null
@@ -1,304 +0,0 @@
-# A test by Juliane Dannberg
-#
-# This test verifies whether physical diffusion works as expected.
-# It sets up a half-space heated from above and cooled from below
-# for which we know that (if infinite) the temperature should behave
-# as a time dependent function like
-#   T(z,t) = (T_halfspace - T_0) * erf(z / (2*sqrt(kappa * t))) + T_0
-# where
-#   T_0 = surface temperature (here =1)
-#   T_halfspace = temperature at infinity (here =0)
-#   kappa = thermal diffusivity (= k / (rho * c_p))
-#   z = distance to surface
-#   t = time
-#
-# The results produced by this test have been verified to be correct.
-
-##################################################################
-
-
-
-# Listing of Parameters
-# ---------------------
-
-# At the top, state that the program should be run for a two-dimensional
-# simulation
-set Dimension = 2
-
-# In computations, the time step $k$ is chosen according to $k = c \min_K
-# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
-# and the denominator is the maximal magnitude of the velocity on cell $K$
-# times the polynomial degree $p_T$ of the temperature discretization. The
-# dimensionless constant $c$ is called the CFL number in this program. For
-# time discretizations that have explicit components, $c$ must be less than a
-# constant that depends on the details of the time discretization and that is
-# no larger than one. On the other hand, for implicit discretizations such as
-# the one chosen here, one can choose the time step as large as one wants (in
-# particular, one can choose $c>1$) though a CFL number significantly larger
-# than one will yield rather diffusive solutions. Units: None.
-set CFL number                             = 0.01
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 4e7
-
-# The name of the directory into which all output files should be placed. This
-# may be an absolute or a relative path.
-
-# A flag indicating whether the computation should be resumed from a
-# previously saved state (if true) or start from scratch (if false).
-set Resume computation                     = false
-
-# The start time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set Start time                             = 0
-
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Adiabatic surface temperature          = 0
-
-# The mathematical equations that describe thermal convection only determine
-# the pressure up to an arbitrary constant. On the other hand, for comparison
-# and for looking up material parameters it is important that the pressure be
-# normalized somehow. We do this by enforcing a particular average pressure
-# value at the surface of the domain, where the geometry model determines
-# where the surface is. This parameter describes what this average surface
-# pressure value is supposed to be. By default, it is set to zero, but one may
-# want to choose a different value for example for simulating only the volume
-# of the mantle below the lithosphere, in which case the surface pressure
-# should be the lithostatic pressure at the bottom of the lithosphere.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Surface pressure                       = 0
-
-# When computing results for mantle convection simulations, it is often
-# difficult to judge the order of magnitude of results when they are stated in
-# MKS units involving seconds. Rather, some kinds of results such as
-# velocities are often stated in terms of meters per year (or, sometimes,
-# centimeters per year). On the other hand, for non-dimensional computations,
-# one wants results in their natural unit system as used inside the code. If
-# this flag is set to 'true' conversion to years happens; if it is 'false', no
-# such conversion happens.
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set List of model names = box
-
-  # A comma separated list of integers denoting those boundaries on which the
-  # temperature is fixed and described by the boundary temperature object
-  # selected in its own section of this input file. All boundary indicators
-  # used by the geometry but not explicitly listed here will end up with
-  # no-flux (insulating) boundary conditions.
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Bottom temperature = 0
-    set Top temperature    = 1
-  end
-end
-
-subsection Discretization
-  # The polynomial degree to use for the velocity variables in the Stokes
-  # system. Units: None.
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-
-  # Whether to use a Stokes discretization that is locally conservative at the
-  # expense of a larger number of degrees of freedom (true), or to go with a
-  # cheaper discretization that does not locally conserve mass, although it is
-  # globally conservative (false).
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    # Extent of the box in x-direction. Units: \\si{\\meter}.
-    set X extent = 1
-
-    # Extent of the box in y-direction. Units: \\si{\\meter}.
-    set Y extent = 1
-
-    # Extent of the box in z-direction. This value is ignored if the
-    # simulation is in 2d Units: \\si{\\meter}.
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
-    set Reference density             = 1
-
-    # The value of the specific heat $cp$. Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.
-    set Reference specific heat       = 1250
-
-    # The reference temperature $T_0$. Units: \\si{\\kelvin}.
-    set Reference temperature         = 0
-
-    # The value of the thermal conductivity $k$. Units: \\si{\\watt\\per\\meter\\per\\kelvin}.
-    set Thermal conductivity          = 1e-6
-
-    # The value of the thermal expansion coefficient $\beta$. Units: \\si{\\per\\kelvin}.
-    set Thermal expansion coefficient = 2e-5
-
-    # The value of the constant viscosity. Units: \\si{\\pascal\\second}.
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  # A list of times so that if the end time of a time step is beyond this
-  # time, an additional round of mesh refinement is triggered. This is mostly
-  # useful to make sure we can get through the initial transient phase of a
-  # simulation on a relatively coarse mesh, and then refine again when we are
-  # in a time range that we are interested in and where we would like to use a
-  # finer mesh. Units: each element of the list has units years if the 'Use
-  # years in output instead of seconds' parameter is set; seconds otherwise.
-  set Additional refinement times        =
-
-  # The number of adaptive refinement steps performed after initial global
-  # refinement but while still within the first time step.
-  set Initial adaptive refinement        = 0
-
-  # The number of global refinement steps performed on the initial coarse
-  # mesh, before the problem is first solved there.
-  set Initial global refinement          = 5
-
-  # The fraction of cells with the largest error that should be flagged for
-  # refinement.
-  set Refinement fraction                = 0.3
-
-  # The fraction of cells with the smallest error that should be flagged for
-  # coarsening.
-  set Coarsening fraction                = 0.05
-
-  # The method used to determine which cells to refine and which to coarsen.
-  set Strategy                           = thermal energy density
-
-  # The number of time steps after which the mesh is to be adapted again based
-  # on computed error indicators.
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  # A comma separated list of integers denoting those boundaries on which the
-  # velocity is tangential and unrestrained, i.e., where no external forces
-  # act to prescribe a particular tangential velocity (although there is a
-  # force that requires the flow to be tangential).
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Checkpointing
-  # The wall time between performing checkpoints. If 0, will use the
-  # checkpoint step frequency instead.
-  set Time between checkpoint                = 0
-
-  # The number of timesteps between performing checkpoints. If 0 and time
-  # between checkpoint is not specified, checkpointing will not be performed.
-  set Steps between checkpoint               = 50
-end
-
-subsection Postprocess
-  # A comma separated list of postprocessor objects that should be run at the
-  # end of each time step. Some of these postprocessors will declare their own
-  # parameters which may, for example, include that they will actually do
-  # something only every so many time steps or years. Alternatively, the text
-  # 'all' indicates that all available postprocessors should be run after each
-  # time step.
-  #
-  # The following postprocessors are available:
-  #
-  # `depth average': A postprocessor that computes depth averaged quantities
-  # and writes them out.
-  #
-  # `heat flux statistics': A postprocessor that computes some statistics
-  # about the heat flux across boundaries.
-  #
-  # `heat flux statistics for the table model': A postprocessor that computes
-  # some statistics about the heat flux across boundaries.
-  #
-  # `velocity statistics for the table model': A postprocessor that computes
-  # some statistics about the velocity field.
-  #
-  # `temperature statistics': A postprocessor that computes some statistics
-  # about the temperature field.
-  #
-  # `velocity statistics': A postprocessor that computes some statistics about
-  # the velocity field.
-  #
-  # `visualization': A postprocessor that takes the solution and writes it
-  # into files that can be read by a graphical visualization program.
-  # Additional run time parameters are read from the parameter subsection
-  # 'Visualization'.
-  set List of postprocessors = temperature statistics, heat flux statistics, depth average
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 1
-    set Number of zones = 10
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-    set List of output variables      = density,viscosity
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/diffusion_dislocation.prm.bak b/tests/diffusion_dislocation.prm.bak
deleted file mode 100644
index 026576959c8..00000000000
--- a/tests/diffusion_dislocation.prm.bak
+++ /dev/null
@@ -1,122 +0,0 @@
-# This somewhat specific test checks the diffusion dislocation
-# rheology model (with Hirth and Kohlstedt (2004) parameters
-# for dry olivine).
-# It sets up a 2D Cartesian box with two different materials
-# inside. Both materials are olivine, but the second has an
-# adjusted density. The starting temperature is a typical
-# geotherm. The top and bottom boundaries are held at fixed
-# temperature, and all boundaries have tangential velocity
-# boundary conditions.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent    = 3000e3
-    set Y extent    = 750e3
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields  = depleted_lithosphere
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = if(y>=650e3,1,0)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=750e3, w=3000e3
-    set Function expression = \
-      if( y < 100e3, \
-        (100e3-y)/100e3*100+1635, \
-        if(y>650e3, \
-          (h-y)/(100e3)*1342+293, \
-          1635))
-  end
-end
-
-subsection Material model
-  set Model name = diffusion dislocation
-
-  subsection Diffusion dislocation
-    set Reference temperature = 293
-    set Minimum strain rate = 5e-19
-    set Minimum viscosity = 1e1
-    set Maximum viscosity = 1e28
-    set Effective viscosity coefficient = 1.0
-    set Thermal diffusivity = 0.8e-6
-    set Heat capacity = 1.25e3
-    set Densities = 3330, 3300
-    set Thermal expansivities = 2e-5
-    set Viscosity averaging scheme = harmonic
-    set Grain size = 1e-3
-    set Prefactors for diffusion creep = 1.5e-15
-    set Stress exponents for diffusion creep = 1
-    set Grain size exponents for diffusion creep = 3
-    set Activation energies for diffusion creep = 3.75e5
-    set Activation volumes for diffusion creep = 6e-6
-    set Prefactors for dislocation creep = 1.1e-16
-    set Stress exponents for dislocation creep = 3.5
-    set Activation energies for dislocation creep = 5.3e5
-    set Activation volumes for dislocation creep = 1.4e-5
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                 = 3
-  set Initial adaptive refinement               = 0
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 0
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/diffusion_dislocation_fixed_strain_rate.prm.bak b/tests/diffusion_dislocation_fixed_strain_rate.prm.bak
deleted file mode 100644
index b4bb8eefd8a..00000000000
--- a/tests/diffusion_dislocation_fixed_strain_rate.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# This model has a box geometry where simple shear is induced by constant velocity
-# along the bottom and top boundaries. Diffusion dislocation creep laws corresponding
-# to the model of Hirth and Kohlstedt for dry olivine are used, and the viscosity is
-# calculated at the first time step for a constant temperature of 1600 K.
-# The analytical solution for the viscosity with the given parameters is 5.81735e17 Pas.
-# Note that the strain rate output by aspect is the *norm*, but the model itself uses
-# the square root of the second invariant. For reference, edot_norm = sqrt(2*edot_ii).
-# The depth average output contains viscosity output, and so provides the required test.
-
-
-set Dimension = 2
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic  = true
-    set X extent    = 500e3
-    set Y extent    = 500e3
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = if(y<250e3,1,-1); 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600
-  end
-end
-
-subsection Material model
-  set Model name = diffusion dislocation
-
-  subsection Diffusion dislocation
-    set Reference temperature = 293
-    set Minimum strain rate = 5e-19
-    set Minimum viscosity = 1e1
-    set Maximum viscosity = 1e28
-    set Effective viscosity coefficient = 1.0
-    set Thermal diffusivity = 0.8e-6
-    set Heat capacity = 1.25e3
-    set Densities = 3300
-    set Thermal expansivities = 2e-5
-    set Viscosity averaging scheme = harmonic
-    set Grain size = 1e-3
-    set Prefactors for diffusion creep = 1.5e-15
-    set Stress exponents for diffusion creep = 1
-    set Grain size exponents for diffusion creep = 3
-    set Activation energies for diffusion creep = 3.75e5
-    set Activation volumes for diffusion creep = 6e-6
-    set Prefactors for dislocation creep = 1.1e-16
-    set Stress exponents for dislocation creep = 3.5
-    set Activation energies for dislocation creep = 5.3e5
-    set Activation volumes for dislocation creep = 1.4e-5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                 = 5
-  set Initial adaptive refinement               = 0
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, depth average
-end
diff --git a/tests/diffusion_dislocation_fixed_strain_rate2.prm.bak b/tests/diffusion_dislocation_fixed_strain_rate2.prm.bak
deleted file mode 100644
index 452b3237d84..00000000000
--- a/tests/diffusion_dislocation_fixed_strain_rate2.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# This is a modification of the diffusion_dislocation_fixed_strain_rate
-# test, where only the temperature and the strain rate are different.
-# It tests if the diffusion dislocation model also works correctly if
-# material model inputs are slightly outside the range of what is usually
-# encountered in the mantle.
-
-set Dimension = 2
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic  = true
-    set X extent    = 500e3
-    set Y extent    = 500e3
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = if(y<250e3,1,-1); 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 160
-  end
-end
-
-subsection Material model
-  set Model name = diffusion dislocation
-
-  subsection Diffusion dislocation
-    set Reference temperature = 293
-    set Minimum strain rate = 5e-19
-    set Minimum viscosity = 1e1
-    set Maximum viscosity = 1e28
-    set Effective viscosity coefficient = 1.0
-    set Thermal diffusivity = 0.8e-6
-    set Heat capacity = 1.25e3
-    set Densities = 3300
-    set Thermal expansivities = 2e-5
-    set Viscosity averaging scheme = harmonic
-    set Grain size = 1e-3
-    set Prefactors for diffusion creep = 1.5e-15
-    set Stress exponents for diffusion creep = 1
-    set Grain size exponents for diffusion creep = 3
-    set Activation energies for diffusion creep = 3.75e5
-    set Activation volumes for diffusion creep = 6e-6
-    set Prefactors for dislocation creep = 1.1e-16
-    set Stress exponents for dislocation creep = 3.5
-    set Activation energies for dislocation creep = 5.3e4
-    set Activation volumes for dislocation creep = 1.4e-5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                 = 5
-  set Initial adaptive refinement               = 0
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, depth average
-end
diff --git a/tests/diffusion_dislocation_reference_density_profile.prm.bak b/tests/diffusion_dislocation_reference_density_profile.prm.bak
deleted file mode 100644
index 3a246ceda49..00000000000
--- a/tests/diffusion_dislocation_reference_density_profile.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# Identical to the test diffusion_dislocation, except the
-# reference density profile formulation is used for the
-# temperature equation.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = diffusion_dislocation_reference_density_profile
-
-# Use 'reference density profile' formulation for the temperature equation
-subsection Formulation
-  set Formulation          = custom
-  set Mass conservation    = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent    = 3000e3
-    set Y extent    = 750e3
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields  = depleted_lithosphere
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = if(y>=650e3,1,0)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=750e3, w=3000e3
-    set Function expression = \
-      if( y < 100e3, \
-        (100e3-y)/100e3*100+1635, \
-        if(y>650e3, \
-          (h-y)/(100e3)*1342+293, \
-          1635))
-  end
-end
-
-subsection Material model
-  set Model name = diffusion dislocation
-
-  subsection Diffusion dislocation
-    set Reference temperature = 293
-    set Minimum strain rate = 5e-19
-    set Minimum viscosity = 1e1
-    set Maximum viscosity = 1e28
-    set Effective viscosity coefficient = 1.0
-    set Thermal diffusivity = 0.8e-6
-    set Heat capacity = 1.25e3
-    set Densities = 3330, 3300
-    set Thermal expansivities = 2e-5
-    set Viscosity averaging scheme = harmonic
-    set Grain size = 1e-3
-    set Prefactors for diffusion creep = 1.5e-15
-    set Stress exponents for diffusion creep = 1
-    set Grain size exponents for diffusion creep = 3
-    set Activation energies for diffusion creep = 3.75e5
-    set Activation volumes for diffusion creep = 6e-6
-    set Prefactors for dislocation creep = 1.1e-16
-    set Stress exponents for dislocation creep = 3.5
-    set Activation energies for dislocation creep = 5.3e5
-    set Activation volumes for dislocation creep = 1.4e-5
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                 = 3
-  set Initial adaptive refinement               = 0
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 0
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/diffusion_velocity.prm.bak b/tests/diffusion_velocity.prm.bak
deleted file mode 100644
index 9cb86c2f963..00000000000
--- a/tests/diffusion_velocity.prm.bak
+++ /dev/null
@@ -1,303 +0,0 @@
-# A test by Juliane Dannberg
-#
-# This test verifies whether physical diffusion works as expected.
-# It sets up a half-space heated from above and cooled from below
-# for which we know that (if infinite) the temperature should behave
-# as a time dependent function like
-#   T(z,t) = (T_halfspace - T_0) * erf(z / (2*sqrt(kappa * t))) + T_0
-# where
-#   T_0 = surface temperature (here =1)
-#   T_halfspace = temperature at infinity (here =0)
-#   kappa = thermal diffusivity (= k / (rho * c_p))
-#   z = distance to surface
-#   t = time
-#
-# The results produced by this test have been verified to be correct.
-
-##################################################################
-
-
-
-# Listing of Parameters
-# ---------------------
-
-# At the top, state that the program should be run for a two-dimensional
-# simulation
-set Dimension = 2
-
-# In computations, the time step $k$ is chosen according to $k = c \min_K
-# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
-# and the denominator is the maximal magnitude of the velocity on cell $K$
-# times the polynomial degree $p_T$ of the temperature discretization. The
-# dimensionless constant $c$ is called the CFL number in this program. For
-# time discretizations that have explicit components, $c$ must be less than a
-# constant that depends on the details of the time discretization and that is
-# no larger than one. On the other hand, for implicit discretizations such as
-# the one chosen here, one can choose the time step as large as one wants (in
-# particular, one can choose $c>1$) though a CFL number significantly larger
-# than one will yield rather diffusive solutions. Units: None.
-set CFL number                             = 0.01
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 2e7
-
-# The name of the directory into which all output files should be placed. This
-# may be an absolute or a relative path.
-
-# A flag indicating whether the computation should be resumed from a
-# previously saved state (if true) or start from scratch (if false).
-set Resume computation                     = false
-
-# The start time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set Start time                             = 0
-
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Adiabatic surface temperature          = 0
-
-# The mathematical equations that describe thermal convection only determine
-# the pressure up to an arbitrary constant. On the other hand, for comparison
-# and for looking up material parameters it is important that the pressure be
-# normalized somehow. We do this by enforcing a particular average pressure
-# value at the surface of the domain, where the geometry model determines
-# where the surface is. This parameter describes what this average surface
-# pressure value is supposed to be. By default, it is set to zero, but one may
-# want to choose a different value for example for simulating only the volume
-# of the mantle below the lithosphere, in which case the surface pressure
-# should be the lithostatic pressure at the bottom of the lithosphere.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Surface pressure                       = 0
-
-# When computing results for mantle convection simulations, it is often
-# difficult to judge the order of magnitude of results when they are stated in
-# MKS units involving seconds. Rather, some kinds of results such as
-# velocities are often stated in terms of meters per year (or, sometimes,
-# centimeters per year). On the other hand, for non-dimensional computations,
-# one wants results in their natural unit system as used inside the code. If
-# this flag is set to 'true' conversion to years happens; if it is 'false', no
-# such conversion happens.
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set List of model names = box
-
-  # A comma separated list of integers denoting those boundaries on which the
-  # temperature is fixed and described by the boundary temperature object
-  # selected in its own section of this input file. All boundary indicators
-  # used by the geometry but not explicitly listed here will end up with
-  # no-flux (insulating) boundary conditions.
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Bottom temperature = 0
-    set Top temperature    = 1
-  end
-end
-
-subsection Discretization
-  # The polynomial degree to use for the velocity variables in the Stokes
-  # system. Units: None.
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-
-  # Whether to use a Stokes discretization that is locally conservative at the
-  # expense of a larger number of degrees of freedom (true), or to go with a
-  # cheaper discretization that does not locally conserve mass, although it is
-  # globally conservative (false).
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    # Extent of the box in x-direction. Units: \\si{\\meter}.
-    set X extent = 1
-
-    # Extent of the box in y-direction. Units: \\si{\\meter}.
-    set Y extent = 1
-
-    # Extent of the box in z-direction. This value is ignored if the
-    # simulation is in 2d Units: \\si{\\meter}.
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
-    set Reference density             = 1
-
-    # The value of the specific heat $cp$. Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.
-    set Reference specific heat       = 1250
-
-    # The reference temperature $T_0$. Units: \\si{\\kelvin}.
-    set Reference temperature         = 0
-
-    # The value of the thermal conductivity $k$. Units: \\si{\\watt\\per\\meter\\per\\kelvin}.
-    set Thermal conductivity          = 1e-6
-
-    # The value of the thermal expansion coefficient $\beta$. Units: \\si{\\per\\kelvin}.
-    set Thermal expansion coefficient = 2e-5
-
-    # The value of the constant viscosity. Units: \\si{\\pascal\\second}.
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  # A list of times so that if the end time of a time step is beyond this
-  # time, an additional round of mesh refinement is triggered. This is mostly
-  # useful to make sure we can get through the initial transient phase of a
-  # simulation on a relatively coarse mesh, and then refine again when we are
-  # in a time range that we are interested in and where we would like to use a
-  # finer mesh. Units: each element of the list has units years if the 'Use
-  # years in output instead of seconds' parameter is set; seconds otherwise.
-  set Additional refinement times        =
-
-  # The number of adaptive refinement steps performed after initial global
-  # refinement but while still within the first time step.
-  set Initial adaptive refinement        = 0
-
-  # The number of global refinement steps performed on the initial coarse
-  # mesh, before the problem is first solved there.
-  set Initial global refinement          = 5
-
-  # The fraction of cells with the largest error that should be flagged for
-  # refinement.
-  set Refinement fraction                = 0.3
-
-  # The fraction of cells with the smallest error that should be flagged for
-  # coarsening.
-  set Coarsening fraction                = 0.05
-
-  # The method used to determine which cells to refine and which to coarsen.
-  set Strategy                           = thermal energy density
-
-  # The number of time steps after which the mesh is to be adapted again based
-  # on computed error indicators.
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  # A comma separated list of integers denoting those boundaries on which the
-  # velocity is tangential and unrestrained, i.e., where no external forces
-  # act to prescribe a particular tangential velocity (although there is a
-  # force that requires the flow to be tangential).
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Checkpointing
-  # The wall time between performing checkpoints. If 0, will use the
-  # checkpoint step frequency instead.
-  set Time between checkpoint                = 0
-
-  # The number of timesteps between performing checkpoints. If 0 and time
-  # between checkpoint is not specified, checkpointing will not be performed.
-  set Steps between checkpoint               = 50
-end
-
-subsection Postprocess
-  # A comma separated list of postprocessor objects that should be run at the
-  # end of each time step. Some of these postprocessors will declare their own
-  # parameters which may, for example, include that they will actually do
-  # something only every so many time steps or years. Alternatively, the text
-  # 'all' indicates that all available postprocessors should be run after each
-  # time step.
-  #
-  # The following postprocessors are available:
-  #
-  # `depth average': A postprocessor that computes depth averaged quantities
-  # and writes them out.
-  #
-  # `heat flux statistics': A postprocessor that computes some statistics
-  # about the heat flux across boundaries.
-  #
-  # `heat flux statistics for the table model': A postprocessor that computes
-  # some statistics about the heat flux across boundaries.
-  #
-  # `velocity statistics for the table model': A postprocessor that computes
-  # some statistics about the velocity field.
-  #
-  # `temperature statistics': A postprocessor that computes some statistics
-  # about the temperature field.
-  #
-  # `velocity statistics': A postprocessor that computes some statistics about
-  # the velocity field.
-  #
-  # `visualization': A postprocessor that takes the solution and writes it
-  # into files that can be read by a graphical visualization program.
-  # Additional run time parameters are read from the parameter subsection
-  # 'Visualization'.
-  set List of postprocessors = temperature statistics, heat flux statistics, velocity statistics, basic statistics
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 1
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-    set List of output variables      = density,viscosity
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/direct_solver_1.prm.bak b/tests/direct_solver_1.prm.bak
deleted file mode 100644
index 44ff9d82aff..00000000000
--- a/tests/direct_solver_1.prm.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-############### Global parameters
-# We use a 2d setup. Since it takes some time for
-# the model to reach a steady state we set the
-# end time to approximately 15 billion years.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 6e15
-set Use years in output instead of seconds = false
-set Output directory                       = output
-set Pressure normalization                 = surface
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = 3
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;-2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    # The change of density across the phase transition. Together with the
-    # Clapeyron slope, this is what determines the entropy change.
-    set Phase transition density jumps                 = 115.6
-    set Corresponding phase for density jump           = 0
-
-    # If the temperature is equal to the phase transition temperature, the
-    # phase transition will occur at the phase transition depth. However,
-    # if the temperature deviates from this value, the Clapeyron slope
-    # determines how much the pressure (and depth) of the phase boundary
-    # changes. Here, the phase transition will be in the middle of the box
-    # for T=T1.
-    set Phase transition depths                        = 500000
-    set Phase transition temperatures                  = 1000
-    set Phase transition Clapeyron slopes              = 1e7
-
-    # We set the width of the phase transition to 5 km. You may want to
-    # change this parameter to see how latent heating depends on the width
-    # of the phase transition.
-    set Phase transition widths                        = 5000
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 2.38
-
-    # We set the thermal expansion and the compressibility to zero, so that
-    # all temperature (and density) changes are caused by advection, diffusion
-    # and latent heating.
-    set Thermal expansion coefficient                  = 0.0
-    set Compressibility                                = 0.0
-
-    # Viscosity is constant.
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 8.44e21
-    set Viscosity prefactors                           = 1.0, 1.0
-    set Composition viscosity prefactor                = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 0
-    set List of output variables      = density
-  end
-end
-
-subsection Heating model
-  set List of model names =  latent heat
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/direct_solver_2.prm.bak b/tests/direct_solver_2.prm.bak
deleted file mode 100644
index f93040c970b..00000000000
--- a/tests/direct_solver_2.prm.bak
+++ /dev/null
@@ -1,150 +0,0 @@
-# test that the direct solver works in parallel
-# MPI: 3
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 6e15
-set Use years in output instead of seconds = false
-set Output directory                       = output
-set Pressure normalization                 = surface
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = 3
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;-2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    # The change of density across the phase transition. Together with the
-    # Clapeyron slope, this is what determines the entropy change.
-    set Phase transition density jumps                 = 115.6
-    set Corresponding phase for density jump           = 0
-
-    # If the temperature is equal to the phase transition temperature, the
-    # phase transition will occur at the phase transition depth. However,
-    # if the temperature deviates from this value, the Clapeyron slope
-    # determines how much the pressure (and depth) of the phase boundary
-    # changes. Here, the phase transition will be in the middle of the box
-    # for T=T1.
-    set Phase transition depths                        = 500000
-    set Phase transition temperatures                  = 1000
-    set Phase transition Clapeyron slopes              = 1e7
-
-    # We set the width of the phase transition to 5 km. You may want to
-    # change this parameter to see how latent heating depends on the width
-    # of the phase transition.
-    set Phase transition widths                        = 5000
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 2.38
-
-    # We set the thermal expansion and the compressibility to zero, so that
-    # all temperature (and density) changes are caused by advection, diffusion
-    # and latent heating.
-    set Thermal expansion coefficient                  = 0.0
-    set Compressibility                                = 0.0
-
-    # Viscosity is constant.
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 8.44e21
-    set Viscosity prefactors                           = 1.0, 1.0
-    set Composition viscosity prefactor                = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-
-    # We are only interested in the last timestep (when the system hast reached
-    # a steady state). For following the development of the system or checking
-    # if the solution already reached steady state, this parameter can be set
-    # to a smaller value.
-    set Time between graphical output = 0
-    set List of output variables      = density
-  end
-end
-
-subsection Heating model
-  set List of model names =  latent heat
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/discontinuous_composition_1.prm.bak b/tests/discontinuous_composition_1.prm.bak
deleted file mode 100644
index c74771ce989..00000000000
--- a/tests/discontinuous_composition_1.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# A test to check discontinuous composition discretization.
-# Based on composition-passive.prm
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 2
-end
-
-subsection Discretization
-  set Use discontinuous temperature discretization = false
-  set Use discontinuous composition discretization = true
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, composition statistics
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter.prm.bak b/tests/discontinuous_composition_bound_preserving_limiter.prm.bak
deleted file mode 100644
index 916efe1e4a8..00000000000
--- a/tests/discontinuous_composition_bound_preserving_limiter.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# this test is specifically designed for the bound-preserving limiter
-# A description of the falling box benchmark see the reference:
-# Gerya, T. V., Yuen, D. A., 2003a. Characteristics-based marker-in-cell method
-# with conservative finite-differences schemes for modeling geological flows with
-# strongly variable transport properties
-# This test uses two falling boxes in order to use two different compositional fields
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1e6
-set Use years in output instead of seconds = true
-set CFL number                             = .5
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500e3
-    set Y extent  = 500e3
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# Thermal expansion coeff = 0 --> no temperature dependence
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3200
-    set Viscosity                     = 1e21
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = 100  # 3300 kg/m^3
-    set Composition viscosity prefactor = 1  # ONLY PARAMETER THAT CHANGES IN THESE TESTS
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(((x>187.5e3)&&(x<375e3)&&(z>312.5e3)&&(z<375e3)), 1, 0);if((x>125e3)&&(x<312.5e3)&&((z>312.5e3)&&(z<437.5e3)), 2, 0);
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 1
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
-    set Global composition maximum = 1.0, 2.0
-    set Global composition minimum = 0.0, 0.0
-  end
-end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter_3d.prm.bak b/tests/discontinuous_composition_bound_preserving_limiter_3d.prm.bak
deleted file mode 100644
index c381f0011ad..00000000000
--- a/tests/discontinuous_composition_bound_preserving_limiter_3d.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# this test is specifically designed for the bound-preserving limiter
-# A description of the falling box benchmark see the reference:
-# Gerya, T. V., Yuen, D. A., 2003a. Characteristics-based marker-in-cell method
-# with conservative finite-differences schemes for modeling geological flows with
-# strongly variable transport properties
-# This test uses two falling boxes in order to use two different compositional fields
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 5e5
-set Use years in output instead of seconds = true
-set CFL number                             = .5
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500e3
-    set Y extent  = 500e3
-    set Z extent  = 500e3
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, front, back, bottom, top
-end
-
-# Thermal expansion coeff = 0 --> no temperature dependence
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3200
-    set Viscosity                     = 1e21
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = 100  # 3300 kg/m^3
-    set Composition viscosity prefactor = 1  # ONLY PARAMETER THAT CHANGES IN THESE TESTS
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = if(((x>125e3)&&(x<375e3)&&(y>125e3)&&(y<375e3)&&(z>125e3)&&(z<375e3)), 1, 0)
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 2
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true # apply the limiter to the DG solutions
-    set Global composition maximum = 1.0
-    set Global composition minimum = 0.0
-  end
-end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm.bak b/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm.bak
deleted file mode 100644
index 5377bc15ed8..00000000000
--- a/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# This test uses the bound-preserving limiter, but only for
-# one of the two existing fields. Because both fields are
-# set up identically, any difference in the output of the
-# two fields stems from the limiter algorithm.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 25000
-set Use years in output instead of seconds = true
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500e3
-    set Y extent  = 500e3
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3200
-    set Viscosity                     = 1e21
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = 100
-    set Composition viscosity prefactor = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x<251e3 ? 0 : 1; x<251e3 ? 0 : 1;
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 0
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    # apply the limiter to the DG solution of field 1, but not field 2
-    set Use limiter for discontinuous composition solution = true, false
-    set Global composition maximum = 1.0, 1.0
-    set Global composition minimum = 0.0, 0.0
-  end
-end
diff --git a/tests/discontinuous_composition_serial_periodic_amr.prm.bak b/tests/discontinuous_composition_serial_periodic_amr.prm.bak
deleted file mode 100644
index c52a3983fb3..00000000000
--- a/tests/discontinuous_composition_serial_periodic_amr.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# Test serial AMR with discontinuous composition elements
-# (in particular flux terms at periodic boundary faces where
-# neighbors are of different level).
-# This test in parallel currently fails (crashes), but we can
-# not test that, because expected test failures are only supported
-# in serial tests.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 4
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory = periodic_test
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Mesh refinement
-  set Minimum refinement level           = 2
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 1
-  set Strategy = composition gradient
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Y periodic = true
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
-    set Function expression = xv;yv
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function expression = if (y<0.65, if(y>0.35, 1.0, 0.0), 0.0)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.0
-  end
-end
diff --git a/tests/discontinuous_temperature.prm.bak b/tests/discontinuous_temperature.prm.bak
deleted file mode 100644
index c6abb8b6c91..00000000000
--- a/tests/discontinuous_temperature.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# A test to check discontinuous temperature discretization.
-# Based on composition-passive.prm
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 2
-end
-
-subsection Discretization
-  set Use discontinuous temperature discretization = true
-  set Use discontinuous composition discretization = false
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, composition statistics
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/tests/discontinuous_temperature_blankenbach.cc.bak b/tests/discontinuous_temperature_blankenbach.cc.bak
deleted file mode 100644
index b18d72104d5..00000000000
--- a/tests/discontinuous_temperature_blankenbach.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/blankenbach/plugin/code.cc"
diff --git a/tests/discontinuous_temperature_blankenbach.prm.bak b/tests/discontinuous_temperature_blankenbach.prm.bak
deleted file mode 100644
index dd6316264d5..00000000000
--- a/tests/discontinuous_temperature_blankenbach.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-# This is case 1c from the Blankenbach Benchmark (Blankenbach 1989), but
-# computed with discontinuous temperature elements. There used to be a bug
-# in the computation of the face terms when combining DG elements with
-# Boussinesq approximation temperature equations. This test crashed due to
-# oscillations before the fix, but now gives accurate results.
-
-set End time                               = 0.002 # 1.0 for full benchmark
-set Use years in output instead of seconds = false
-set CFL number = 5.0
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0; 0; 1
-    set Variable names      = depth
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = ascii data
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/benchmarks/blankenbach/
-    set Data file name = initial_temperature_case1c.txt
-  end
-end
-
-subsection Material model
-  set Model name = nondimensional
-
-  subsection Nondimensional model
-    set Di                      = 0.0
-    set Ra                      = 1e6
-
-    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
-    set Reference density       = 1
-
-    # The value of the specific heat $cp$. Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.
-    set Reference specific heat = 1
-
-    # Whether to use the TALA instead of the ALA approximation.
-    set Use TALA                = false
-    set Viscosity temperature prefactor = 0.0
-    set Viscosity depth prefactor = 0.0
-    set gamma                   = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement= 3
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 1.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Formulation
-  set Formulation          = custom # with this selection equivalent to BA
-  set Mass conservation    = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, heating statistics
-end
-
-subsection Termination criteria
-  set Termination criteria      = steady state velocity
-
-  subsection Steady state velocity
-    set Maximum relative deviation = 1e-5
-    set Time in steady state       = 0.1
-  end
-end
-
-subsection Discretization
-  set Use discontinuous temperature discretization = true
-end
diff --git a/tests/discontinuous_temperature_spherical_shell_3d.prm.bak b/tests/discontinuous_temperature_spherical_shell_3d.prm.bak
deleted file mode 100644
index 1e71a837f16..00000000000
--- a/tests/discontinuous_temperature_spherical_shell_3d.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# This is to ensure that face->measure() is not being
-# called in the dG method - that breaks in 3d, in the
-# case of non-planar faces.
-
-# Define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 3
-
-# Specify the time you want to let the model run for in
-# years and the output directory. Here we only calculate
-# the instantaneous solution.
-set End time                               = 0
-
-# Here we specify the geometry of the domain, which is
-# a spherical shell with inner radius of 3481km and
-# outer radius of 6371km
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6371000
-  end
-end
-
-# This section specifies the temperature at the boundary of
-# the domain. Here we set the temperature to be constant.
-# Alternatively it could be set to the initial condition.
-# We assume fixed temperatures and free slip at the inner and outer boundary
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 1600
-    set Outer temperature = 1600
-  end
-end
-
-# This section describes the gravity field, which is pointing
-# towards the Earth's center with the same magnitude of 10 m/s^2
-# everywhere
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-# This section prescribes the initial condition in the temperature
-# field, which is chosen as a scaled version of the S20RTS shear
-# wave velocity model (Ritsema et al., 2000). S20RTS is defined
-# by spherical harmonics up to degree 20 that are radially interpolated
-# with a cubic spline.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-# The material model is based on the simple material model, which assumes
-# a constant density, and other parameters as stated below.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                 = 3300
-    set Viscosity                         = 1e21
-    set Thermal expansion coefficient     = 3e-5
-    set Reference temperature             = 1600
-    set Thermal conductivity              = 4.125
-    set Reference specific heat           = 1250
-  end
-end
-
-# For this calculation we only do 2 global refinement steps. This resolution
-# is too low to fully resolve the mantle flow, however it does capture
-# the main features.
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-end
-
-subsection Discretization
-  set Use discontinuous temperature discretization = true
-end
diff --git a/tests/doneahuerta_3.cc.bak b/tests/doneahuerta_3.cc.bak
deleted file mode 100644
index e1dbd9428a3..00000000000
--- a/tests/doneahuerta_3.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/doneahuerta/doneahuerta.cc"
diff --git a/tests/doneahuerta_3.prm.bak b/tests/doneahuerta_3.prm.bak
deleted file mode 100644
index 3dc8099cdfc..00000000000
--- a/tests/doneahuerta_3.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-############### Global parameters
-# This is the manufactured solution of Donea & Huerta,
-# Finite element methods for flow problems,
-# Wiley, 2003. page 306
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0  : DoneaHuertaBoundary, \
-                                                1  : DoneaHuertaBoundary, \
-                                                2  : DoneaHuertaBoundary, \
-                                                3  : DoneaHuertaBoundary
-end
-
-subsection Material model
-  set Model name = DoneaHuertaMaterial
-end
-
-subsection Gravity model
-  set Model name = DoneaHuertaGravity
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, DoneaHuertaPostprocessor
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density, viscosity, strain rate, gravity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/drucker_prager_compression.prm.bak b/tests/drucker_prager_compression.prm.bak
deleted file mode 100644
index 6bde6270eb8..00000000000
--- a/tests/drucker_prager_compression.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-############### Global parameters
-# This model is based on the paper
-# Kaus, B. (2010), Tectonophysics 484, 36-47.
-# We iterate out the Stokes equation.
-# We use only the expensive Stokes solver.
-# 1 Timestep experiment.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver tolerance             = 1e-5
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 10 # to localize deformation, more iterations are needed
-
-############### Parameters describing the model
-# We consider a 2D box of 40x10 km of which the elements are of unit aspect ratio.
-# Temperature plays no role in this model.
-# We prescribe a horizontal velocity (compression) on the vertical
-# boundaries, but leave the vertical component free.
-# To the bottom boundary we prescribe the same horizontal velocity,
-# the vertical velocity component is set to zero. The top boundary is open.
-# We use a Drucker Prager failure criterion.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 40000
-    set Y extent  = 10000
-    set X repetitions = 4
-  end
-end
-
-############### We prescribe a velocity of W/2 * background strain rate invariant
-# where W is the width of the domain and the background strain rate 1e-15 1/s.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0 x:function,1 x:function, 2: function
-
-  subsection Function
-    set Function expression     =  if(x>=2e4,-2.e-11,2.e-11);0
-  end
-end
-
-subsection Material model
-  set Model name = drucker prager
-
-  subsection Drucker Prager
-    set Thermal conductivity          = 0.0
-    set Reference density             = 2700.0
-    set Reference temperature         = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Reference specific heat       = 1
-
-    subsection Viscosity
-      set Minimum viscosity           = 1e19
-      set Maximum viscosity           = 1e26
-      set Cohesion                    = 4e7
-      set Angle of internal friction  = 15
-      set Reference strain rate       = 1e-15
-    end
-  end
-end
-
-############## rho * g = 27000
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# We set the temperature to zero, as it is not important.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 1
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-# We select to compute some statistics about the
-# velocity field and the mass flux through the boundaries.
-# We prescribe an inflow of 2e-11 m/s on both vertical boundaries
-# which should be the value of the maximum velocity. The VRMS will
-# be a little lower, because the inflow will be balanced by an outflow
-# through the top boundary over a greater boundary length.
-# For the given density and inflow velocity, a boundary
-# mass flux of v * L * rho = 2e-11 * 10000 * 2700 = 5.4e-4 kg/s
-# is expected for each vertical boundary,
-# compensated by a influx of 1.08e-3 kg/s through the top.
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/drucker_prager_derivatives_2d.cc.bak b/tests/drucker_prager_derivatives_2d.cc.bak
deleted file mode 100644
index d6d713fb9fb..00000000000
--- a/tests/drucker_prager_derivatives_2d.cc.bak
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/drucker_prager.h>
-#include <aspect/simulator_access.h>
-#include <aspect/newton.h>
-#include <aspect/utilities.h>
-#include <aspect/parameters.h>
-
-#include <deal.II/base/exceptions.h>
-#include <memory>
-#include <functional>
-
-#include <iostream>
-
-template <int dim>
-void f(const aspect::SimulatorAccess<dim> &simulator_access,
-       aspect::Assemblers::Manager<dim> &)
-{
-
-  std::cout << std::endl << "Testing DruckerPrager derivatives against finite difference derivatives " << std::endl;
-
-  using namespace aspect::MaterialModel;
-
-  // first set all material model values
-  MaterialModelInputs<dim> in_base(5,3);
-  in_base.composition[0][0] = 0;
-  in_base.composition[0][1] = 0;
-  in_base.composition[0][2] = 0;
-  in_base.composition[1][0] = 0.75;
-  in_base.composition[1][1] = 0.15;
-  in_base.composition[1][2] = 0.10;
-  in_base.composition[2][0] = 0;
-  in_base.composition[2][1] = 0.2;
-  in_base.composition[2][2] = 0.4;
-  in_base.composition[3][0] = 0;
-  in_base.composition[3][1] = 0.2;
-  in_base.composition[3][2] = 0.4;
-  in_base.composition[4][0] = 1;
-  in_base.composition[4][1] = 0;
-  in_base.composition[4][2] = 0;
-
-  in_base.temperature[0] = 293;
-  in_base.temperature[1] = 1600;
-  in_base.temperature[2] = 2000;
-  in_base.temperature[3] = 2100;
-  in_base.temperature[4] = 2200;
-
-  in_base.pressure[0] = 1e9;
-  in_base.pressure[1] = 5e9;
-  in_base.pressure[2] = 2e10;
-  in_base.pressure[3] = 2e11;
-  in_base.pressure[4] = 2e12;
-
-  /**
-   * We can't take to small strain-rates, because then the difference in the
-   * visocisty will be too small for the double accuracy which stores
-   * the visocity solutions and the finite difference solution.
-   */
-  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
-  in_base.strain_rate[0][0][0] = 1e-12;
-  in_base.strain_rate[0][0][1] = 1e-12;
-  in_base.strain_rate[0][1][1] = 1e-11;
-
-  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[1][0][0] = -1.71266e-13;
-  in_base.strain_rate[1][0][1] = -5.82647e-12;
-  in_base.strain_rate[1][1][1] = 4.21668e-14;
-
-  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[2][1][1] = 1e-13;
-  in_base.strain_rate[2][0][1] = 1e-11;
-  in_base.strain_rate[2][0][0] = -1e-12;
-
-  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[3][1][1] = 4.9e-21;
-  in_base.strain_rate[3][0][1] = 4.9e-21;
-  in_base.strain_rate[3][0][0] = 4.9e-21;
-
-  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[4][1][1] = 1e-11;
-  in_base.strain_rate[4][0][1] = 1e-11;
-  in_base.strain_rate[4][0][0] = 1e-11;
-
-  // initialize some variables we will need later.
-  const double finite_difference_accuracy = 1e-7;
-  const double finite_difference_factor = 1+finite_difference_accuracy;
-
-  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
-
-  MaterialModelOutputs<dim> out_base(5,3);
-  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
-  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
-
-  // initialize the material we want to test.
-  aspect::ParameterHandler prm;
-
-  const aspect::MaterialModel::DruckerPrager<dim> const_material_model = dynamic_cast<const aspect::MaterialModel::DruckerPrager<dim> &>(simulator_access.get_material_model());
-  aspect::MaterialModel::DruckerPrager<dim> material_model = const_cast<aspect::MaterialModel::DruckerPrager<dim> &>(const_material_model);
-
-  material_model.declare_parameters(prm);
-
-  prm.enter_subsection("Material model");
-  {
-    prm.enter_subsection ("Drucker Prager");
-    {
-      prm.enter_subsection ("Viscosity");
-      {
-        prm.set ("Reference strain rate", "1e-20");
-        prm.set ("Angle of internal friction", "30");
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection();
-  }
-  prm.leave_subsection();
-
-  const_cast<aspect::MaterialModel::Interface<dim> &>(simulator_access.get_material_model()).parse_parameters(prm);
-
-  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
-
-  simulator_access.get_material_model().evaluate(in_base, out_base);
-
-  // set up additional output for the derivatives
-  MaterialModelDerivatives<dim> *derivatives;
-  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
-  double temp;
-
-  // have a bool so we know whether the test has succeed or not.
-  bool Error = false;
-
-  // test the pressure derivative.
-  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
-  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
-
-  simulator_access.get_material_model().evaluate(in_dviscositydpressure, out_dviscositydpressure);
-
-  for (unsigned int i = 0; i < 5; i++)
-    {
-      // prevent division by zero. If it is zero, the test has passed, because or
-      // the finite difference and the analytical result match perfectly, or (more
-      // likely) the material model in independent of this variable.
-      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
-      if (in_base.pressure[i] != 0)
-        {
-          temp /= (in_base.pressure[i] * finite_difference_accuracy);
-        }
-      std::cout << "pressure: point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i]  << std::endl;
-      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
-        {
-          std::cout << "   Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
-          Error = true;
-        }
-
-    }
-
-  // test the strain-rate derivative.
-  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
-    {
-      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
-                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
-                                                    * finite_difference_accuracy
-                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
-        }
-
-
-      simulator_access.get_material_model().evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          // prevent division by zero. If it is zero, the test has passed, because or
-          // the finite difference and the analytical result match perfectly, or (more
-          // likely) the material model in independent of this variable.
-          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
-          if (temp != 0)
-            {
-              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
-            }
-          std::cout << "strain-rate: point = " << i << ", component = " << component << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
-          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
-            {
-              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
-              Error = true;
-            }
-
-        }
-
-    }
-
-  if (Error)
-    {
-      std::cout << "Some parts of the test were not successful." << std::endl;
-    }
-  else
-    {
-      std::cout << "OK" << std::endl;
-    }
-
-}
-
-template <>
-void f(const aspect::SimulatorAccess<3> &,
-       aspect::Assemblers::Manager<3> &)
-{
-  AssertThrow(false,dealii::ExcInternalError());
-}
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  using namespace dealii;
-  std::cout << "* Connecting signals" << std::endl;
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2));
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/drucker_prager_derivatives_2d.prm.bak b/tests/drucker_prager_derivatives_2d.prm.bak
deleted file mode 100644
index eecb827ba81..00000000000
--- a/tests/drucker_prager_derivatives_2d.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# This test checks whether the derivatives of the drucker prager
-# material model are the same as the finite difference derivatives
-# created by the drucker prager material model. Significantly, the
-# temperature, composition, pressure and strain rate values
-# evaluated by the material are all specified within
-# drucker_prager_derivatives_2d.cc and the model parameters defined
-# below are not used in the test.
-set Additional shared libraries = tests/libdrucker_prager_derivatives_2d.so
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 0
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = drucker prager
-
-  subsection Drucker Prager
-    subsection Viscosity
-      set Reference strain rate = 1e-20
-      set Angle of internal friction = 30.
-    end
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/drucker_prager_derivatives_3d.cc.bak b/tests/drucker_prager_derivatives_3d.cc.bak
deleted file mode 100644
index 33aabf18543..00000000000
--- a/tests/drucker_prager_derivatives_3d.cc.bak
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/drucker_prager.h>
-#include <aspect/simulator_access.h>
-#include <aspect/newton.h>
-#include <aspect/utilities.h>
-#include <aspect/parameters.h>
-
-#include <deal.II/base/exceptions.h>
-#include <memory>
-#include <functional>
-
-#include <iostream>
-
-template <int dim>
-void f(const aspect::SimulatorAccess<dim> &simulator_access,
-       aspect::Assemblers::Manager<dim> &)
-{
-
-  std::cout << std::endl << "Testing DruckerPrager derivatives against finite difference derivatives " << std::endl;
-
-  using namespace aspect::MaterialModel;
-
-  // first set all material model values
-  MaterialModelInputs<dim> in_base(5,3);
-  in_base.composition[0][0] = 0;
-  in_base.composition[0][1] = 0;
-  in_base.composition[0][2] = 0;
-  in_base.composition[1][0] = 0.75;
-  in_base.composition[1][1] = 0.15;
-  in_base.composition[1][2] = 0.10;
-  in_base.composition[2][0] = 0;
-  in_base.composition[2][1] = 0.2;
-  in_base.composition[2][2] = 0.4;
-  in_base.composition[3][0] = 0;
-  in_base.composition[3][1] = 0.2;
-  in_base.composition[3][2] = 0.4;
-  in_base.composition[4][0] = 1;
-  in_base.composition[4][1] = 0;
-  in_base.composition[4][2] = 0;
-
-  in_base.temperature[0] = 293;
-  in_base.temperature[1] = 1600;
-  in_base.temperature[2] = 2000;
-  in_base.temperature[3] = 2100;
-  in_base.temperature[4] = 2200;
-
-  in_base.pressure[0] = 1e9;
-  in_base.pressure[1] = 5e9;
-  in_base.pressure[2] = 2e10;
-  in_base.pressure[3] = 2e11;
-  in_base.pressure[4] = 2e12;
-
-  /**
-   * We can't take to small strain-rates, because then the difference in the
-   * visocisty will be too small for the double accuracy which stores
-   * the visocity solutions and the finite difference solution.
-   */
-  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
-  in_base.strain_rate[0][0][0] = 1e-12;
-  in_base.strain_rate[0][0][1] = 1e-12;
-  in_base.strain_rate[0][1][1] = 1e-11;
-  in_base.strain_rate[0][2][0] = 1e-12;
-  in_base.strain_rate[0][2][1] = 1e-12;
-  in_base.strain_rate[0][2][2] = 1e-11;
-
-  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[1][0][0] = -1.71266e-13;
-  in_base.strain_rate[1][0][1] = -5.82647e-12;
-  in_base.strain_rate[1][1][1] = 4.21668e-14;
-  in_base.strain_rate[1][2][0] = -5.42647e-12;
-  in_base.strain_rate[1][2][1] = -5.22647e-12;
-  in_base.strain_rate[1][2][2] = 4.21668e-14;
-
-  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[2][1][1] = 1e-13;
-  in_base.strain_rate[2][0][1] = 1e-11;
-  in_base.strain_rate[2][0][0] = -1e-12;
-  in_base.strain_rate[2][2][0] = 1e-11;
-  in_base.strain_rate[2][2][1] = 1e-11;
-  in_base.strain_rate[2][2][2] = -1e-12;
-
-  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[3][1][1] = 4.9e-21;
-  in_base.strain_rate[3][0][1] = 4.9e-21;
-  in_base.strain_rate[3][0][0] = 4.9e-21;
-  in_base.strain_rate[3][2][0] = 4.9e-21;
-  in_base.strain_rate[3][2][1] = 4.9e-21;
-  in_base.strain_rate[3][2][2] = 4.9e-21;
-
-  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[4][1][1] = 1e-11;
-  in_base.strain_rate[4][0][1] = 1e-11;
-  in_base.strain_rate[4][0][0] = 1e-11;
-  in_base.strain_rate[4][2][0] = 1e-11;
-  in_base.strain_rate[4][2][1] = 1e-11;
-  in_base.strain_rate[4][2][2] = 1e-11;
-
-  // initialize some variables we will need later.
-  const double finite_difference_accuracy = 1e-7;
-  const double finite_difference_factor = 1+finite_difference_accuracy;
-
-  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
-
-  MaterialModelOutputs<dim> out_base(5,3);
-  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
-  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
-
-  // initialize the material we want to test.
-  aspect::ParameterHandler prm;
-
-  const aspect::MaterialModel::DruckerPrager<dim> const_material_model = dynamic_cast<const aspect::MaterialModel::DruckerPrager<dim> &>(simulator_access.get_material_model());
-  aspect::MaterialModel::DruckerPrager<dim> material_model = const_cast<aspect::MaterialModel::DruckerPrager<dim> &>(const_material_model);
-
-  material_model.declare_parameters(prm);
-
-  prm.enter_subsection("Material model");
-  {
-    prm.enter_subsection ("Drucker Prager");
-    {
-      prm.enter_subsection ("Viscosity");
-      {
-        prm.set ("Reference strain rate", "1e-20");
-        prm.set ("Angle of internal friction", "30");
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection();
-  }
-  prm.leave_subsection();
-
-  const_cast<aspect::MaterialModel::Interface<dim> &>(simulator_access.get_material_model()).parse_parameters(prm);
-
-  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
-
-  simulator_access.get_material_model().evaluate(in_base, out_base);
-
-  // set up additional output for the derivatives
-  MaterialModelDerivatives<dim> *derivatives;
-  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
-  double temp;
-
-  // have a bool so we know whether the test has succeed or not.
-  bool Error = false;
-
-  // test the pressure derivative.
-  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
-  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
-
-  simulator_access.get_material_model().evaluate(in_dviscositydpressure, out_dviscositydpressure);
-
-  for (unsigned int i = 0; i < 5; i++)
-    {
-      // prevent division by zero. If it is zero, the test has passed, because or
-      // the finite difference and the analytical result match perfectly, or (more
-      // likely) the material model in independent of this variable.
-      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
-      if (in_base.pressure[i] != 0)
-        {
-          temp /= (in_base.pressure[i] * finite_difference_accuracy);
-        }
-      std::cout << "pressure: point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i]  << std::endl;
-      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
-        {
-          std::cout << "   Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
-          Error = true;
-        }
-
-    }
-
-  // test the strain-rate derivative.
-  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
-    {
-      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
-                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
-                                                    * finite_difference_accuracy
-                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
-        }
-
-
-      simulator_access.get_material_model().evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          // prevent division by zero. If it is zero, the test has passed, because or
-          // the finite difference and the analytical result match perfectly, or (more
-          // likely) the material model in independent of this variable.
-          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
-          if (temp != 0)
-            {
-              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
-            }
-          std::cout << "strain-rate: point = " << i << ", component = " << component << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
-          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
-            {
-              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
-              Error = true;
-            }
-
-        }
-
-    }
-
-  if (Error)
-    {
-      std::cout << "Some parts of the test were not successful." << std::endl;
-    }
-  else
-    {
-      std::cout << "OK" << std::endl;
-    }
-
-}
-
-template <>
-void f(const aspect::SimulatorAccess<2> &,
-       aspect::Assemblers::Manager<2> &)
-{
-  AssertThrow(false,dealii::ExcInternalError());
-}
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  using namespace dealii;
-  std::cout << "* Connecting signals" << std::endl;
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2));
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/drucker_prager_derivatives_3d.prm.bak b/tests/drucker_prager_derivatives_3d.prm.bak
deleted file mode 100644
index 65fa5b2d2d2..00000000000
--- a/tests/drucker_prager_derivatives_3d.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# This test checks whether the derivatives of the drucker prager
-# material model are the same as the finite difference derivatives
-# created by the drucker prager material model. Significantly, the
-# temperature, composition, pressure and strain rate values
-# evaluated by the material are all specified within
-# drucker_prager_derivatives_3d.cc and the model parameters defined
-# below are not used in the test.
-set Additional shared libraries = tests/libdrucker_prager_derivatives_3d.so
-set Dimension                              = 3
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year); 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 0
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = drucker prager
-
-  subsection Drucker Prager
-    subsection Viscosity
-      set Reference strain rate = 1e-20
-      set Angle of internal friction = 30.
-    end
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/drucker_prager_extension.prm.bak b/tests/drucker_prager_extension.prm.bak
deleted file mode 100644
index 3731bbbfcf0..00000000000
--- a/tests/drucker_prager_extension.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-############### Global parameters
-# This model is based on the paper
-# Kaus, B. (2010), Tectonophysics 484, 36-47.
-# We iterate out the Stokes equation.
-# We use only the expensive Stokes solver.
-# 1 Timestep experiment.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver tolerance             = 1e-5
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 10 # to localize deformation, more iterations are needed
-
-############### Parameters describing the model
-# We consider a 2D box of 40x10 km of which the elements are of unit aspect ratio.
-# Temperature plays no role in this model.
-# We prescribe a horizontal velocity (extension) on the vertical
-# boundaries, but leave the vertical component free.
-# To the bottom boundary we prescribe the same horizontal velocity,
-# the vertical velocity component is set to zero. The top boundary is open.
-# We use a Drucker Prager failure criterion.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 40000
-    set Y extent  = 10000
-    set X repetitions = 4
-  end
-end
-
-############### We prescribe a velocity of W/2 * background strain rate invariant
-# where W is the width of the domain and the background strain rate 1e-15 1/s.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0 x:function,1 x:function, 2: function
-
-  subsection Function
-    set Function expression     =  if(x>=2e4,2.e-11,-2.e-11);0
-  end
-end
-
-subsection Material model
-  set Model name = drucker prager
-
-  subsection Drucker Prager
-    set Thermal conductivity          = 0.0
-    set Reference density             = 2700.0
-    set Reference temperature         = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Reference specific heat       = 1
-
-    subsection Viscosity
-      set Minimum viscosity           = 1e19
-      set Maximum viscosity           = 1e26
-      set Cohesion                    = 4e7
-      set Angle of internal friction  = 15
-      set Reference strain rate       = 1e-15
-    end
-  end
-end
-
-############## rho * g = 27000
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# We set the temperature to zero, as it is not important.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 1
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-# We select to compute some statistics about the
-# velocity field and the mass flux through the boundaries.
-# As we prescribe an outflow of 2e-11 m/s on both vertical boundaries
-# the VRMS should be on that order. The max velocity will be a little
-# higher, because the outflow will be balanced by an inflow
-# through the top boundary over a smaller boundary length.
-# For the given density and outflow velocity, a boundary
-# mass flux of v * L * rho = 2e-11  * 10000 * 2700 = 5.4e-4 kg/s
-# is expected for each vertical boundary,
-# compensated by a influx of 1.08e-3 kg/s through the top.
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/dynamic_core.prm.bak b/tests/dynamic_core.prm.bak
deleted file mode 100644
index 8cf0b7a94d4..00000000000
--- a/tests/dynamic_core.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# A simple setup for Earth convection model in a 2d shell
-# with the core mantle boundary (CMB) temperature dynamically evolves through time.
-# The 'dynamic core' boundary temperature plugin and 'core statistics' postprocessor
-# are used to solving and tracing the core evolution.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Output directory                       = output
-
-#set Resume computation                     = true
-
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = dynamic core
-
-  subsection Dynamic core
-    set Inner temperature                 = 4100
-    set Outer temperature                 = 300
-    set Core density                      = 12.5e3
-    set Gravity acceleration              = 9.81    # For the core
-    set CMB pressure                      = 0.14e12
-    set Initial light composition         = 0.042   # wt% for light elements
-    set Max iteration                     = 30
-    set Core heat capacity                = 840
-    set K0                                = 4.111e11
-    set Alpha                             = 1.35e-5 # Thermal expansivity for the core
-    set Core conductivity                 = 50
-
-    subsection Geotherm parameters
-      set Tm0= 1695
-      set Tm1= 10.9e-12
-      set Tm2= -8.0e-24
-      set Theta= 0.11
-      set Composition dependency= false
-    end
-
-    subsection Radioactive heat source
-      #                                            100ppm K in core
-      set Number of radioactive heating elements = 1
-      set Heating rates                          = 2.92e-5
-      set Half life times                        = 1.25       #Unit: Gyr
-      set Initial concentrations                 = 0.1442962
-    end
-  end
-end
-
-subsection Heating model
-  set List of model names =  adiabatic heating
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 0 #4
-  set Time steps between mesh refinement = 0 #15
-end
-
-subsection Postprocess
-  set List of postprocessors = core statistics
-
-  subsection Dynamic core statistics
-    set Excess entropy only = true
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = user request
-end
diff --git a/tests/dynamic_friction.prm.bak b/tests/dynamic_friction.prm.bak
deleted file mode 100644
index b2f24056a7c..00000000000
--- a/tests/dynamic_friction.prm.bak
+++ /dev/null
@@ -1,141 +0,0 @@
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 1
-set CFL number                             = 0.5
-set Output directory                       = dynamic_friction
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions  = 4
-    set X extent  = 80e3
-    set Y extent  = 20e3
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = top: free surface
-
-  # Advecting the free surface vertically rather than
-  # in the surface normal direction can result in a
-  # more stable mesh when the deformation is large
-  subsection Free surface
-    set Surface velocity projection = vertical
-  end
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Densities                  = 2800
-    set Thermal expansivities      = 4e-5
-    set Viscosity averaging scheme = harmonic
-    set Minimum viscosity          = 1e19
-    set Maximum viscosity          = 1e25
-    set Reference strain rate      = 1e-15
-    set Minimum strain rate        = 1.e-50
-    set Reference temperature      = 293
-
-    # Dislocation creep parameters for
-    set Prefactors for dislocation creep          =      5e-21, 5e-26
-    set Stress exponents for dislocation creep    =      1.0
-    set Activation energies for dislocation creep =      0.0
-    set Activation volumes for dislocation creep  =      0.0
-
-    # Plasticity parameters
-    set Friction mechanism                  = dynamic friction
-    set Dynamic characteristic strain rate  = 1e-15
-    set Angles of internal friction         = 29.0171320271063, 26.565051177078
-    set Dynamic angles of internal friction = 30.9637565320735, 26.565051177078
-    set Cohesions                           = 20e6
-    set Maximum yield stress                = 1e50
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( x > 40.e3 & x < 41.e3 & y < 0.4e3, 0, 1)
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left: function, right:function
-  set Tangential velocity boundary indicators = bottom
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = cm=0.01, year=1
-    set Function expression =  if (x==0 , 1*cm/year, if (x==80.e3, -1*cm/year, 0)) ; 0
-  end
-end
-
-############### Parameters describing the temperature field
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.95
-  set Strategy                           = strain rate
-  set Coarsening fraction                = 0.05
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-9
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/dynamic_topography.prm.bak b/tests/dynamic_topography.prm.bak
deleted file mode 100644
index 17b761b0e60..00000000000
--- a/tests/dynamic_topography.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# A test that verifies that the dynamic topography is calculated correctly
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature  = 1600
-    set Left temperature    = 1600
-    set Right temperature   = 1600
-    set Top temperature     = 1600
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1800000
-    set Y extent = 700000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names     = x,y
-    set Function expression = if(sqrt((x-900000)*(x-900000) + (y-300000)*(y-300000))<50000,1700,1600)
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y < 600000, 0.0, 1.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1600
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 3e-4
-    set Viscosity                     = 1e21
-    set Composition viscosity prefactor = 100
-    set Thermal viscosity exponent    = 36.84136
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,3
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = dynamic topography, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-    set List of output variables = dynamic topography
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/dynamic_topography2.prm.bak b/tests/dynamic_topography2.prm.bak
deleted file mode 100644
index 1bbd1a9e4b9..00000000000
--- a/tests/dynamic_topography2.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# A test that verifies that the dynamic topography is calculated correctly
-# when the cell sizes vary on the surface
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature  = 1600
-    set Left temperature    = 1600
-    set Right temperature   = 1600
-    set Top temperature     = 1600
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1800000
-    set Y extent = 700000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names     = x,y
-    set Function expression = if(sqrt((x-900000)*(x-900000) + (y-650000)*(y-650000))<50000,1700,1600)
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y < 600000, 0.0, 1.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1600
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 3e-4
-    set Viscosity                     = 1e21
-    set Composition viscosity prefactor = 100
-    set Thermal viscosity exponent    = 36.84136
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.5
-  set Coarsening fraction                = 0.00
-  set Strategy                           = thermal energy density
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,3
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = dynamic topography, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-    set List of output variables = dynamic topography
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/dynamic_topography3.prm.bak b/tests/dynamic_topography3.prm.bak
deleted file mode 100644
index 17bc82f5427..00000000000
--- a/tests/dynamic_topography3.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-# A test that verifies that the dynamic topography is calculated correctly
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 1600
-    set Outer temperature = 1600
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3480000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Vertical wave number = 2
-    set Lateral wave number one = 3
-    set Lateral wave number two = 2
-    set Magnitude = 100
-    set Reference temperature = 1600
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1600
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Strategy                           = temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner,outer
-end
-
-subsection Postprocess
-  set List of postprocessors = dynamic topography, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-    set List of output variables = dynamic topography
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/dynamic_topography_back.prm.bak b/tests/dynamic_topography_back.prm.bak
deleted file mode 100644
index 49ad21f1bc9..00000000000
--- a/tests/dynamic_topography_back.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# A test that verifies that the dynamic topography is calculated correctly
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature  = 1600
-    set Left temperature    = 1600
-    set Right temperature   = 1600
-    set Top temperature     = 1600
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = -10
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1800000
-    set Y extent = 700000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names     = x,y
-    set Function expression = if(sqrt((x-900000)*(x-900000) + (y-300000)*(y-300000))<50000,1700,1600)
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y < 600000, 0.0, 1.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1600
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 3e-4
-    set Viscosity                     = 1e21
-    set Composition viscosity prefactor = 100
-    set Thermal viscosity exponent    = 36.84136
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,3
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = dynamic topography, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-    set List of output variables = dynamic topography
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/dynamic_topography_vs_surface_dynamic_topography.prm.bak b/tests/dynamic_topography_vs_surface_dynamic_topography.prm.bak
deleted file mode 100644
index 975e90f33dc..00000000000
--- a/tests/dynamic_topography_vs_surface_dynamic_topography.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-# Like the dynamic_topography test, but not only output the dynamic
-# topography using the 'dynamic topography' viz postprocessor, but
-# also using 'surface dynamic topography'.
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature  = 1600
-    set Left temperature    = 1600
-    set Right temperature   = 1600
-    set Top temperature     = 1600
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1800000
-    set Y extent = 700000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names     = x,y
-    set Function expression = if(sqrt((x-900000)*(x-900000) + (y-300000)*(y-300000))<50000,1700,1600)
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y < 600000, 0.0, 1.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1600
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 3e-4
-    set Viscosity                     = 1e21
-    set Composition viscosity prefactor = 100
-    set Thermal viscosity exponent    = 36.84136
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,3
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = dynamic topography, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-    set List of output variables = dynamic topography, surface dynamic topography
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/edit_parameters.cc.bak b/tests/edit_parameters.cc.bak
deleted file mode 100644
index 695cb1501ab..00000000000
--- a/tests/edit_parameters.cc.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <deal.II/base/parameter_handler.h>
-#include <aspect/global.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/boundary_temperature/interface.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  // Global variables (to be set by parameters)
-  unsigned int switch_step;
-  bool switched;
-
-  /**
-   * Declare additional parameters.
-   */
-  void declare_parameters(const unsigned int,
-                          ParameterHandler &prm)
-  {
-    prm.declare_entry("Switch step", "0",
-                      Patterns::Integer(0),
-                      "Switch CFL at the timestep given.");
-  }
-
-  template <int dim>
-  void parse_parameters(const Parameters<dim>,
-                        ParameterHandler &prm)
-  {
-    switch_step = prm.get_integer("Switch step");
-    switched = false;
-  }
-
-  template <int dim>
-  void on_start_timestep (const SimulatorAccess<dim> &simulator_access)
-  {
-    simulator_access.get_pcout() << "Signal start_timestep triggered!" << std::endl;
-    if (simulator_access.get_timestep_number() != numbers::invalid_unsigned_int
-        &&
-        simulator_access.get_timestep_number() >= switch_step
-        &&
-        !switched )
-      {
-        simulator_access.get_pcout() << "Reducing CFL number!" << std::endl;
-        const_cast<Parameters<dim>&>(simulator_access.get_parameters()).CFL_number *= 0.5;
-
-        switched = true;
-      }
-  }
-
-
-  template <int dim>
-  void on_edit_parameters (const SimulatorAccess<dim> &simulator_access,
-                           Parameters<dim> &/*parameters*/)
-  {
-    simulator_access.get_pcout()<<"Signal edit_parameters triggered!"<<std::endl;
-  }
-
-  // Connect declare_parameters and parse_parameters to appropriate signals.
-  void parameter_connector ()
-  {
-    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
-    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
-
-    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
-    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
-  }
-
-  template <int dim>
-  void signal_connector (SimulatorSignals<dim> &signals)
-  {
-    signals.edit_parameters_pre_setup_dofs.connect (&on_edit_parameters<dim>);
-    signals.start_timestep.connect(&on_start_timestep<dim>);
-  }
-
-  // Tell ASPECT to send signals to the connector functions
-  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
-  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
-}
diff --git a/tests/edit_parameters.prm.bak b/tests/edit_parameters.prm.bak
deleted file mode 100644
index 168d625fc7f..00000000000
--- a/tests/edit_parameters.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test runtime editing of parameters, in particular reducing
-# the CFL number by a factor of 2 after 5 timesteps.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.e9
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Switch step = 5
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 0:0,1:0,2:10,3:0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step                  = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, velocity statistics
-end
diff --git a/tests/elastic_stabilization_time_scale_factor.prm.bak b/tests/elastic_stabilization_time_scale_factor.prm.bak
deleted file mode 100644
index 5c7ff722022..00000000000
--- a/tests/elastic_stabilization_time_scale_factor.prm.bak
+++ /dev/null
@@ -1,38 +0,0 @@
-# This test checks whether the stabilization time scale factor works correctly
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm
-
-set End time                               = 5
-set Output directory                       = elastic_stabilization_time_scale_factor
-
-# Implement the new time scale factor
-subsection Material model
-  subsection Viscoelastic
-    set Stabilization time scale factor = 2
-  end
-end
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 7
-  end
-end
-
-# No global refinement
-subsection Mesh refinement
-  set Initial global refinement          = 0
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, material statistics, velocity statistics, topography
-
-  subsection Topography
-    set Output to file           = false
-    set Time between text output = 0
-  end
-end
diff --git a/tests/ellipsoidal_chunk_coordinate_parallel.prm.bak b/tests/ellipsoidal_chunk_coordinate_parallel.prm.bak
deleted file mode 100644
index e5d078d6cf3..00000000000
--- a/tests/ellipsoidal_chunk_coordinate_parallel.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# A simple setup for convection in a 3d ellipsoidal chunk. See the
-# manual for more information.
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# the shape of the grid, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-############### Parameters describing the model
-# We create a coordinate-parallel ellipsoidal chunk with
-# a large eccentricity (0.5).
-# The coordinate-parallel implementation takes two opposite
-# corners of the chunk as input.
-
-subsection Geometry model
-  set Model name = ellipsoidal chunk
-
-  subsection Ellipsoidal chunk
-    set NE corner = 7.5:30
-    set SW corner = -7.5:-10
-    set Depth = 3000000
-    set Eccentricity = 0.5
-    set East-West subdivisions = 1
-    set North-South subdivisions = 2
-    set Depth subdivisions = 3
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer,north,south,east,west
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer,north,south,east,west
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = west: 0, east: 1, south: 2, north: 3, inner: 4, outer:5
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.473e3
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-############### Parameters describing the discretization
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-############### Parameters describing what to do with the solution
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables          = density
-    set Output format                     = gnuplot
-  end
-end
diff --git a/tests/ellipsoidal_chunk_geometry.cc.bak b/tests/ellipsoidal_chunk_geometry.cc.bak
deleted file mode 100644
index fa6838e8c1e..00000000000
--- a/tests/ellipsoidal_chunk_geometry.cc.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-
-#include <deal.II/base/exceptions.h>
-
-#include <iostream>
-
-using namespace aspect;
-using namespace dealii;
-
-bool test_point(const GeometryModel::internal::EllipsoidalChunkGeometry<3> ellipsoidal_manifold,
-                const Point<3> &test_point)
-{
-  const Point<3> converted_point = ellipsoidal_manifold.pull_back(test_point);
-  const Point<3> twice_converted_point = ellipsoidal_manifold.push_forward(converted_point);
-
-  const Tensor<1,3> difference = twice_converted_point - test_point;
-  const double error = difference.norm() / test_point.norm();
-
-  std::cout << "Point: " << test_point
-            << " becomes: " << converted_point
-            << ". Back transformed: " << twice_converted_point
-            << ". Error: " << error << std::endl;
-
-  return true;
-}
-
-/*
- * Launch the following function when this plugin is created.
- */
-int f()
-{
-
-  const unsigned int dim=3;
-
-  std::vector<Point<2>> corners(2,Point<2>(-15.0,-15.0));
-  corners[1] *= -1.0;
-
-  std::vector<Point<3>> test_points;
-  test_points.push_back(Point<3> (6371000.0,0,0));
-  test_points.push_back(Point<3> (6171000.0,0,0));
-  test_points.push_back(Point<3> (3000000.0,3000000.0,0));
-  test_points.push_back(Point<3> (3000000.0,3000000.0,3000000.0));
-  test_points.push_back(Point<3> (3000000.0,-3000000.0,-3000000.0));
-  test_points.push_back(Point<3> (25000.0,25000.0,3481000.0));
-  test_points.push_back(Point<3> (25000.0,25000.0,1000000.0));
-  test_points.push_back(Point<3> (25000.0,25000.0,500000.0));
-  test_points.push_back(Point<3> (25000.0,25000.0,50000.0));
-
-
-  InitialTopographyModel::ZeroTopography<dim> topography;
-  {
-    std::cout << "Simple sphere test" << std::endl;
-    GeometryModel::internal::EllipsoidalChunkGeometry<dim> ellipsoidal_manifold(topography,
-                                                                                6371000.0,
-                                                                                0.0,
-                                                                                6371000.0,
-                                                                                2890000.0,
-                                                                                corners);
-
-    for (unsigned int i=0; i<test_points.size(); ++i)
-      test_point(ellipsoidal_manifold,test_points[i]);
-  }
-
-  const double semi_major_axis_a = 6378137.0;
-  const double eccentricity = 8.1819190842622e-2;
-  const double semi_minor = std::sqrt((1 - pow(eccentricity,2)) * pow(semi_major_axis_a,2));
-  {
-    std::cout << "WGS84 test" << std::endl;
-
-    GeometryModel::internal::EllipsoidalChunkGeometry<dim> ellipsoidal_manifold(topography,
-                                                                                semi_major_axis_a,
-                                                                                eccentricity,
-                                                                                semi_minor,
-                                                                                2890000.0,
-                                                                                corners);
-
-    for (unsigned int i=0; i<test_points.size(); ++i)
-      test_point(ellipsoidal_manifold,test_points[i]);
-  }
-
-  {
-    std::cout << "Test for points outside of the provided depth range" << std::endl;
-    GeometryModel::internal::EllipsoidalChunkGeometry<dim> ellipsoidal_manifold(topography,
-                                                                                semi_major_axis_a,
-                                                                                eccentricity,
-                                                                                semi_minor,
-                                                                                500000.0,
-                                                                                corners);
-
-    for (unsigned int i=0; i<test_points.size(); ++i)
-      test_point(ellipsoidal_manifold,test_points[i]);
-  }
-
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/ellipsoidal_chunk_geometry.prm.bak b/tests/ellipsoidal_chunk_geometry.prm.bak
deleted file mode 100644
index 2ecefd5d850..00000000000
--- a/tests/ellipsoidal_chunk_geometry.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-# This test checks the accuracy of the coordinate transformation
-# for the ellipsoidal chunk geometry model. Because the used
-# manifold includes an approximation for the conversion between
-# spherical and ellipsoidal coordinates the conversion is inaccurate
-# very close to the center of the domain. This test documents this
-# inaccuracy and shows that it is negligible for points at the
-# core-mantle boundary (5e-11 relative to center distance) and even for points
-# at the inner-core-boundary (1e-7).
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = ellipsoidal chunk
-
-  subsection Ellipsoidal chunk
-    set NE corner = 7.5:30
-    set SW corner = -7.5:-10
-    set Depth = 3000000
-    set Eccentricity = 0.5
-    set East-West subdivisions = 1
-    set North-South subdivisions = 2
-    set Depth subdivisions = 3
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer,north,south,east,west
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer,north,south,east,west
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = west: 0, east: 1, south: 2, north: 3, inner: 4, outer:5
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.473e3
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables          = density
-    set Output format                     = gnuplot
-  end
-end
diff --git a/tests/ellipsoidal_chunk_noncoordinate_parallel.prm.bak b/tests/ellipsoidal_chunk_noncoordinate_parallel.prm.bak
deleted file mode 100644
index c3323c27cc8..00000000000
--- a/tests/ellipsoidal_chunk_noncoordinate_parallel.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# A simple setup for convection in a 3d ellipsoidal chunk. See the
-# manual for more information.
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# the shape of the grid, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-############### Parameters describing the model
-# We create a non-coordinate-parallel ellipsoidal chunk with
-# a large eccentricity (0.5).
-# The non-coordinate-parallel implementation takes three
-# corners of the chunk as input.
-
-subsection Geometry model
-  set Model name = ellipsoidal chunk
-
-  subsection Ellipsoidal chunk
-    set NE corner = 5:30
-    set NW corner = 0:0
-    set SW corner = 10:-10
-    set Depth = 3000000
-    set Eccentricity = 0.5
-    set East-West subdivisions = 1
-    set North-South subdivisions = 2
-    set Depth subdivisions = 3
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer,north,south,east,west
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer, east, west, north, south
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = west: 0, east: 1, south: 2, north: 3, inner: 4, outer:5
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.473e3
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-############### Parameters describing the discretization
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-############### Parameters describing what to do with the solution
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, velocity statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables          = density
-    set Output format                     = gnuplot
-  end
-end
diff --git a/tests/ellipsoidal_chunk_topography.prm.bak b/tests/ellipsoidal_chunk_topography.prm.bak
deleted file mode 100644
index 9735d656e86..00000000000
--- a/tests/ellipsoidal_chunk_topography.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# A simple setup for convection in a 3d ellipsoidal chunk with topography.
-# manual for more information.
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# the shape of the grid, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-
-############### Parameters describing the model
-# We create a coordinate parallel ellipsoidal chunk with
-# a large eccentricity (0.5).
-
-subsection Geometry model
-  set Model name = ellipsoidal chunk
-
-  subsection Ellipsoidal chunk
-    set NE corner = 7.5:30
-    set SW corner = -7.5:-10
-    set Depth = 3000000
-    set Eccentricity = 0.5
-    set East-West subdivisions = 1
-    set North-South subdivisions = 2
-    set Depth subdivisions = 3
-  end
-
-  subsection Initial topography model
-    set Model name = prm polygon
-
-    subsection Prm polygon
-      set Topography parameters = 200000  > 8,31;0,31;0,10;8,10 & \
-                                   -200000 > -8,-11;0,-11;0,10;-8,10
-    end
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer,north,south,east,west
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer,north,south,east,west
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = west: 0, east: 1, south: 2, north: 3, inner: 4, outer:5
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.473e3
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-############### Parameters describing the discretization
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-############### Parameters describing what to do with the solution
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables          = density
-    set Output format                     = gnuplot
-  end
-end
diff --git a/tests/entropy_adiabat.cc.bak b/tests/entropy_adiabat.cc.bak
deleted file mode 100644
index 7ad48d87aef..00000000000
--- a/tests/entropy_adiabat.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_adiabat.prm.bak b/tests/entropy_adiabat.prm.bak
deleted file mode 100644
index 59ea4c95b51..00000000000
--- a/tests/entropy_adiabat.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# Adiabatic downwelling that starts on one adiabat, with inflow on another adiabat
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/entropy_adiabat.prm
-
-set End time = 1e7
-
-subsection Geometry model
-  subsection Box
-    set Y repetitions = 10
-  end
-end
diff --git a/tests/entropy_conduction.cc.bak b/tests/entropy_conduction.cc.bak
deleted file mode 100644
index 7ad48d87aef..00000000000
--- a/tests/entropy_conduction.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_conduction.prm.bak b/tests/entropy_conduction.prm.bak
deleted file mode 100644
index 4b777c318a5..00000000000
--- a/tests/entropy_conduction.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-# Conductive cooling starting form an adiabat.
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/entropy_conduction.prm
-
-set End time = 1e7
diff --git a/tests/entropy_half_space.cc.bak b/tests/entropy_half_space.cc.bak
deleted file mode 100644
index 7ad48d87aef..00000000000
--- a/tests/entropy_half_space.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_half_space.prm.bak b/tests/entropy_half_space.prm.bak
deleted file mode 100644
index d6788546676..00000000000
--- a/tests/entropy_half_space.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# Conductive cooling of a half-space using the entropy method.
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/entropy_half_space.prm
-
-set End time = 1e7
-
-subsection Geometry model
-  subsection Box
-    set Y repetitions = 10
-  end
-end
diff --git a/tests/entropy_initial_lookup.cc.bak b/tests/entropy_initial_lookup.cc.bak
deleted file mode 100644
index 7ad48d87aef..00000000000
--- a/tests/entropy_initial_lookup.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_initial_lookup.prm.bak b/tests/entropy_initial_lookup.prm.bak
deleted file mode 100644
index 34f1f0b032d..00000000000
--- a/tests/entropy_initial_lookup.prm.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-# Entropy field initiated with a constant temperature and a table lookup of
-# (P, T) -> S.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600.0
-
-subsection Formulation
-  set Mass conservation = projected density field
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 13000
-    set Y extent = 1300000
-    set Y repetitions = 100
-  end
-end
-
-subsection Initial temperature model
-  # A constant initial temperature is assigned
-  # There is a decreasing in the entropy with increasing pressure.
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600.0
-  end
-end
-
-subsection Adiabatic conditions model
-  # The 'ascii data' option does not need the additional
-  # plugin, but is limited to the available adiabat data files.
-  # 'compute entropy profile' computes arbitrary adiabats
-  # internally, based on the data table.
-
-  set Model name = compute entropy profile
-
-  subsection Compute entropy profile
-    set Surface entropy = 2534  # equivalent to T=1600 K
-  end
-
-  subsection Ascii data model
-    set Data directory  = $ASPECT_SOURCE_DIR/data/material-model/
-    set Data file name  = entropy-table/opxtable/1600K_adiabat.txt
-  end
-end
-
-# We prescribe temperatures according to the data table.
-# This output is computed in the material model.
-subsection Temperature field
-  set Temperature method = prescribed field with diffusion
-end
-
-# We solve the entropy equation for the compositional field with name
-# 'entropy'. Temperature and density are then computed based on entropy and
-# pressure.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = entropy, density_field
-  set Types of fields = entropy, density
-  set Compositional field methods = field, prescribed field
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top
-  set List of model names = initial temperature
-end
-
-# Prescribing downward flow through a vertical pipe with
-# tangential side boundaries.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Function expression = 0; -0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We look up the values of entropies from another look-up table.
-# This table looks up the value of entropy from a pair of temperature and pressure.
-subsection Initial composition model
-  set List of model names = entropy table lookup
-
-  subsection Entropy table lookup
-    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/
-    set Material file name = material_table_temperature_pressure.txt
-  end
-end
-
-# We use a data table for orthopyroxene computed using the thermodynamic
-# modeling software Perple_X.
-subsection Material model
-  set Model name = entropy model
-
-  subsection Entropy model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/
-    set Material file name               = material_table_entropy_pressure.txt
-    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
-    set Thermal conductivity formulation = constant
-    set Thermal conductivity             = 0.1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e6
-    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
-    set Output format = gnuplot
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
-    end
-  end
-end
diff --git a/tests/entropy_initial_lookup_wb.cc.bak b/tests/entropy_initial_lookup_wb.cc.bak
deleted file mode 100644
index 7ad48d87aef..00000000000
--- a/tests/entropy_initial_lookup_wb.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_initial_lookup_wb.prm.bak b/tests/entropy_initial_lookup_wb.prm.bak
deleted file mode 100644
index 65333180d21..00000000000
--- a/tests/entropy_initial_lookup_wb.prm.bak
+++ /dev/null
@@ -1,141 +0,0 @@
-# Entropy field initiated with a temperature field of a subduction slab
-# using the World Builder and a table lookup of (P, T) -> S.
-
-set Dimension = 2
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 0
-set Output directory = output_3
-set Timing output frequency = 10
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 1573.0
-set Resume computation = false
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set World builder file = $ASPECT_SOURCE_DIR/tests/entropy_initial_lookup_wb.wb
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-  set Use discontinuous composition discretization = false
-end
-
-subsection Formulation
-  set Mass conservation = projected density field
-end
-
-# Geometry:
-#   The mesh is a 2-D chunk that spans 171.5 degree in longitude
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3.481e6
-    set Chunk outer radius = 6.371e6
-    set Chunk maximum longitude = 1.7150e+02
-    set Chunk minimum longitude = 0.0
-    set Longitude repetitions = 6
-  end
-end
-
-# Mesh refinement:
-#   We combine the strategies of the isosurfaces with the viscosity.
-#   In this way, we can refine the level of the refinement in the
-#   slab core controlled by the colder temperature in the slab.
-subsection Mesh refinement
-  set Initial global refinement = 3
-  set Initial adaptive refinement = 3
-  set Minimum refinement level = 3
-  set Strategy = isosurfaces, minimum refinement function, viscosity
-  set Time steps between mesh refinement = 10
-  set Refinement fraction = 0.2
-  set Coarsening fraction = 0.2
-  set Run postprocessors on initial refinement = true
-  set Skip solvers on initial refinement = true
-
-  subsection Isosurfaces
-    set Isosurfaces = max, max, Temperature: 270.0 | 1173.0
-  end
-
-  subsection Minimum refinement function
-    set Coordinate system = spherical
-    set Variable names = r,phi,t
-    set Function constants = Ro=6.3710e+06, UM=670e3, DD=100e3
-    set Function expression = ((Ro-r<UM)? \
-                                   ((Ro-r<DD)? 5: 3): 0.0)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-# Initial temperature:
-# A slab structure is configured by the WorldBuilder
-subsection Initial temperature model
-  set List of model names = world builder
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 273
-  end
-end
-
-# We solve the entropy equation for the compositional field with name
-# 'entropy'. Temperature and density are then computed based on entropy and
-# pressure.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = entropy, density_field
-  set Types of fields = entropy, density
-  set Compositional field methods = field, prescribed field
-end
-
-# We look up the values of entropies from another look-up table.
-# This table looks up the value of entropy from a pair of temperature and pressure.
-subsection Initial composition model
-  set List of model names = entropy table lookup
-
-  subsection Entropy table lookup
-    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/
-    set Material file name = material_table_temperature_pressure.txt
-  end
-end
-
-# We use a data table for pyrolite computed using the thermodynamic
-# modeling software Perple_X.
-subsection Material model
-  set Model name = entropy model
-
-  subsection Entropy model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/pyrtable/
-    set Material file name               = material_table_entropy_pressure.txt
-    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
-    set Thermal conductivity formulation = constant
-    set Thermal conductivity             = 0.1
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e6
-    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
-    set Output format = gnuplot
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
-    end
-  end
-end
diff --git a/tests/entropy_plasticity.cc.bak b/tests/entropy_plasticity.cc.bak
deleted file mode 100644
index 7ad48d87aef..00000000000
--- a/tests/entropy_plasticity.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_plasticity.prm.bak b/tests/entropy_plasticity.prm.bak
deleted file mode 100644
index f699984b4bb..00000000000
--- a/tests/entropy_plasticity.prm.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-# A 2-D annulus model for convection under early-Earth conditions, with plasticity,
-# reference viscosity profile, and p-T dependent conductivity
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 4e5
-set Output directory                       = output-entropy-plasticity
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-subsection Formulation
-  set Mass conservation = projected density field
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set List of compositional fields with disabled boundary entropy viscosity = entropy
-  end
-end
-
-# This material model reads in the Hefesto table
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-  set Model name = entropy model
-
-  subsection Entropy model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
-    set Material file name               = material_table.txt
-    set Lateral viscosity file name      = constant_lateral_vis_prefactor_50000.txt
-    set Thermal conductivity formulation = p-T-dependent
-    set Maximum viscosity                = 1e30
-    set Minimum viscosity                = 1e12
-    set Maximum lateral viscosity variation          = 2000
-    set Cohesion                         = 8e7
-    set Angle of internal friction       = 0.572957795130823 # = 0.01 radians
-  end
-
-  subsection Depth dependent viscosity
-    set Data directory                   = $ASPECT_SOURCE_DIR/benchmarks/entropy_adiabat/data/
-    set Data file name                   = constant_viscosity.txt
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-  end
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-# Set the reference profiles, using a constant entropy
-subsection Adiabatic conditions model
-  set Model name = compute entropy profile
-
-  subsection Compute entropy profile
-    # This is specific entropy, equivalent to T=1600K according to the used table
-    set Surface entropy = 2535
-  end
-end
-
-subsection Initial temperature model
-  set Model name = prescribed temperature
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names =  initial temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-# The temperature field is computed from the entropy
-subsection Temperature field
-  set Temperature method = prescribed field with diffusion
-end
-
-# Density is computed from entropy
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = entropy, density_field
-  set Compositional field methods = field, prescribed field
-end
-
-# Set the initial temperature profile
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r,phi
-    set Function expression = 2535.08 + 10 * sin(2*phi)*sin(pi*(r-6371000)/2890000) - 1878.618 * erfc((6371000-r)/(2*sqrt(1.152e-6*5e7*31557600))) + \
-    486.368 * max(erfc((r-3481000)/(2*sqrt(1.152e-6*5e8*31557600))), exp(-((phi - 3/4*pi)^2)/(2*(1/35*pi)^2) - ((r-3481000)^2)/(2*400000^2))  );0
-
-    #set Function expression = 2687.748 + 10 * sin(2*phi)*sin(pi*(r-6371000)/2890000) - 2031.286 * erfc((6371000-r)/(2*sqrt(1.152e-6*5e7*31557600))) + 333.7 * erfc((r-3481000)/(2*sqrt(1.152e-6*5e8*31557600)));0
-  end
-end
-
-# Set the boundary entropy to values corresponding to
-# realistic temperature.
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = top, bottom
-  set List of model names = spherical constant
-  set Allow fixed composition on outflow boundaries = true
-
-  subsection Spherical constant
-    # Corresponding to T=300 K for p=0 GPa according to used table
-    set Outer composition = 600
-
-    # Corresponding to T=3400 K for p=140 GPa according to used table
-    set Inner composition = 2950
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Minimum refinement level                 = 2
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = composition threshold
-
-  subsection Composition threshold
-    set Compositional field thresholds = 2700, 1e6
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint = 600
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
-end
diff --git a/tests/entropy_read_multi_table.cc.bak b/tests/entropy_read_multi_table.cc.bak
deleted file mode 100644
index 7ad48d87aef..00000000000
--- a/tests/entropy_read_multi_table.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/entropy_adiabat/plugins/entropy_advection.cc"
diff --git a/tests/entropy_read_multi_table.prm.bak b/tests/entropy_read_multi_table.prm.bak
deleted file mode 100644
index c3b6c90b7f7..00000000000
--- a/tests/entropy_read_multi_table.prm.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-# A box model with two compositions. It reads in two look-up tables
-# and computes the initial property based on the chemical compositions.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Maximum time step                      = 1e6
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 50
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1560.29
-
-subsection Formulation
-  set Mass conservation = projected density field
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 13000
-    set Y extent = 13000
-    set Y repetitions = 1
-  end
-end
-
-subsection Adiabatic conditions model
-  # 'compute entropy profile' computes arbitrary adiabats
-  # internally, based on the data table.
-  set Model name = compute entropy profile
-
-  subsection Compute entropy profile
-    # Entropy equivalent to T=1560.29 K according to the used table
-    set Surface entropy = 2500
-  end
-end
-
-# We prescribe temperatures according to the data table.
-# This output is computed in the material model.
-subsection Temperature field
-  set Temperature method = prescribed field with diffusion
-end
-
-# We solve the entropy equation for the compositional field with type
-# 'entropy'. Temperature and density are then computed based on entropy and
-# pressure.
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = percent_bas, entropy_bas, entropy_haz, density_field
-  set Types of fields = chemical composition, entropy, entropy, density
-  set Compositional field methods = field, field, field, prescribed field
-end
-
-# Prescribing closed boundaries.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, left, right, bottom
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-# We start at the same entropy as the one used for the
-# adiabatic profile. The last compositional field gives
-# the analytical solution for the temperature at the
-# end of the model run based on the half-space cooling
-# model.
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    # Entropy equivalent to T=1560.29 K according to table
-    set Function expression = 0.2; 2500; 2500; 0.0
-  end
-end
-
-# We use a data table for orthopyroxene computed using the thermodynamic
-# modeling software HeFESTo.
-# We use a very large viscosity to make sure the material does not move.
-subsection Material model
-  set Model name = entropy model
-
-  subsection Entropy model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/entropy-table/opxtable/
-    set Material file name               = material_table.txt, multi_composition_test.txt
-    set Maximum viscosity                = 1e30
-    set Minimum viscosity                = 1e30
-    set Lateral viscosity file name      = constant_lateral_vis_prefactor.txt
-    set Thermal conductivity formulation = constant
-    set Thermal conductivity             = 4.7
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 1e8
-    set List of output variables      = material properties, adiabat, nonadiabatic pressure, nonadiabatic temperature
-    set Output format = gnuplot
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity, compressibility
-    end
-  end
-end
diff --git a/tests/entropy_viscosity_statistics.prm.bak b/tests/entropy_viscosity_statistics.prm.bak
deleted file mode 100644
index 1af94eee676..00000000000
--- a/tests/entropy_viscosity_statistics.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-# This is a copy of the artificial_viscosity test that
-# additionally checks the entropy viscosity statistics postprocessor.
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/artificial_viscosity.prm
-
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, entropy viscosity statistics
-end
diff --git a/tests/exponential_decay.cc.bak b/tests/exponential_decay.cc.bak
deleted file mode 100644
index 5a10eab7c89..00000000000
--- a/tests/exponential_decay.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/operator_splitting/exponential_decay/exponential_decay.cc"
diff --git a/tests/exponential_decay.prm.bak b/tests/exponential_decay.prm.bak
deleted file mode 100644
index f1d306673e9..00000000000
--- a/tests/exponential_decay.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-#########################################################
-# This is a benchmark case that tests the operator split
-# solver scheme, which can use a different time step to
-# compute reactions between compositional fields than
-# the time step used for advection.
-# In this test case, there is no advection, and we start
-# from a composition (and temperature) that is 1 everywhere
-# in the domain and then decays over time, following the
-# equations for exponential decay.
-
-# We use a plugin that implements the reactions for exponential
-# decay.
-set Additional shared libraries = ./libexponential_decay.so
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 100
-set Use years in output instead of seconds = false
-
-# We use a new solver scheme that enables the operator split.
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Use operator splitting                 = true
-set Maximum time step                      = 10
-
-# As we split the time-stepping of advection and reactions,
-# there are now two different time steps in the model:
-# We control the advection time step using the 'Maximum time step'
-# parameter (as this benchmark has no driving force, and hence very
-# low velocities, we can not use the CFL number), and the reaction
-# time step is controlled internally through the ODE solver scheme.
-# Instead of changing the step for the ODE solver, we can make the
-# solution more accurate by modifying the Reaction solver relative
-# tolerance.
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction solver relative tolerance = 1e-6
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-# Both initial temperature and composition are set to 1,
-# and will decay starting from this value.
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1.0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1.0
-  end
-end
-
-# We choose material and heating models that let temperature
-# and composition decay over time, and that is implemented in
-# a plugin.
-subsection Heating model
-  set List of model names = exponential decay heating
-
-  subsection Exponential decay heating
-    set Half life = 10
-  end
-end
-
-subsection Material model
-  set Model name = exponential decay
-
-  subsection Exponential decay
-    set Half life = 10
-  end
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1e5
-    set Density differential for compositional field 1 = 0
-  end
-end
-
-# As composition and temperature do not depend on x or y,
-# we can use a coarse resolution.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-# We output some statistics about the composition, and make
-# use of a postprocessor that computes errors compared to the
-# analytical solution for exponential decay.
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization, ExponentialDecayPostprocessor
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/fail.prm.bak b/tests/fail.prm.bak
deleted file mode 100644
index ed59e1c4984..00000000000
--- a/tests/fail.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-# test that we can have tests where we expect failure triggered by the following line:
-#
-# EXPECT FAILURE
-
-set Dimension = 5
diff --git a/tests/find_boundary_composition_model.cc.bak b/tests/find_boundary_composition_model.cc.bak
deleted file mode 100644
index d427e640cc4..00000000000
--- a/tests/find_boundary_composition_model.cc.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/box.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/boundary_composition/initial_composition.h>
-#include <aspect/boundary_composition/box.h>
-#include <aspect/simulator.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    template <int dim>
-    class Box2 : public Box<dim>
-    {
-      public:
-        virtual void update();
-    };
-    template <int dim>
-    void Box2<dim>::update()
-    {
-      if (this->get_boundary_composition_manager().template has_matching_boundary_composition_model<BoundaryComposition::Box<dim>>())
-        std::cout << "Box is found!" << std::endl;
-      else
-        std::cout << "Box is not found!" << std::endl;
-
-      if (this->get_boundary_composition_manager().template has_matching_boundary_composition_model<BoundaryComposition::InitialComposition<dim>>())
-        std::cout << "InitialComposition is found!" << std::endl;
-      else
-        std::cout << "InitialComposition is not found!" << std::endl;
-
-      try
-        {
-          this->get_boundary_composition_manager().template get_matching_boundary_composition_model<BoundaryComposition::Box<dim>>();
-          std::cout << "Box is found!" << std::endl;
-        }
-      catch (...)
-        {
-          std::cout << "Box is not found!" << std::endl;
-        }
-
-      try
-        {
-          this->get_boundary_composition_manager().template get_matching_boundary_composition_model<BoundaryComposition::InitialComposition<dim>>();
-          std::cout << "InitialComposition is found!" << std::endl;
-        }
-      catch (...)
-        {
-          std::cout << "InitialComposition is not found!" << std::endl;
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
-                                               "box2",
-                                               "A model in which the temperature is chosen constant on "
-                                               "all the sides of a box. For test")
-  }
-}
diff --git a/tests/find_boundary_composition_model.prm.bak b/tests/find_boundary_composition_model.prm.bak
deleted file mode 100644
index 2869b261323..00000000000
--- a/tests/find_boundary_composition_model.prm.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-# Based on find_post_process.prm.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = 0,1,2,3
-  set List of model names                   = initial composition
-end
-
-subsection Boundary temperature model
-  set List of model names = box2
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields  = field_a, field_b
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.5, 1, 0) ; if(y<0.5, 0, 1)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
diff --git a/tests/find_boundary_composition_model_fail_1.cc.bak b/tests/find_boundary_composition_model_fail_1.cc.bak
deleted file mode 100644
index 9e21214fe56..00000000000
--- a/tests/find_boundary_composition_model_fail_1.cc.bak
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/box.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/boundary_composition/initial_composition.h>
-#include <aspect/boundary_composition/box.h>
-#include <aspect/simulator.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    template <int dim>
-    class Box2 : public Box<dim>
-    {
-      public:
-        virtual void update();
-    };
-    template <int dim>
-    void Box2<dim>::update()
-    {
-      this->get_boundary_composition_manager().template get_matching_boundary_composition_model<BoundaryComposition::Box<dim>>();
-      std::cout << "Box is found!" << std::endl;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
-                                               "box2",
-                                               "A model in which the temperature is chosen constant on "
-                                               "all the sides of a box. For test")
-  }
-}
diff --git a/tests/find_boundary_composition_model_fail_1.prm.bak b/tests/find_boundary_composition_model_fail_1.prm.bak
deleted file mode 100644
index 45afeed8f65..00000000000
--- a/tests/find_boundary_composition_model_fail_1.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# This test will request a non-activated boundary composition model and
-# will not catch the resulting exception to check if the
-# exception output works correctly.
-# Based on find_post_process_fail_1.prm.
-
-# EXPECT FAILURE
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = 0,1,2,3
-  set List of model names                   = initial composition
-end
-
-subsection Boundary temperature model
-  set List of model names = box2
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields  = field_a, field_b
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.5, 1, 0) ; if(y<0.5, 0, 1)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
diff --git a/tests/find_mesh_refinement.cc.bak b/tests/find_mesh_refinement.cc.bak
deleted file mode 100644
index 7718c91d498..00000000000
--- a/tests/find_mesh_refinement.cc.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/box.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/mesh_refinement/density.h>
-#include <aspect/mesh_refinement/boundary.h>
-#include <aspect/simulator.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    template <int dim>
-    class Box2 : public Box<dim>
-    {
-      public:
-        virtual void update();
-    };
-    template <int dim>
-    void Box2<dim>::update()
-    {
-      if (this->get_mesh_refinement_manager().template has_matching_mesh_refinement_strategy<MeshRefinement::Density<dim>>())
-        std::cout << "Density is found!" << std::endl;
-      else
-        std::cout << "Density is not found!" << std::endl;
-
-      if (this->get_mesh_refinement_manager().template has_matching_mesh_refinement_strategy<MeshRefinement::Boundary<dim>>())
-        std::cout << "Boundary is found!" << std::endl;
-      else
-        std::cout << "Boundary is not found!" << std::endl;
-
-      try
-        {
-          this->get_mesh_refinement_manager().template get_matching_mesh_refinement_strategy<MeshRefinement::Density<dim>>();
-          std::cout << "Density is found!" << std::endl;
-        }
-      catch (...)
-        {
-          std::cout << "Density is not found!" << std::endl;
-        }
-
-      try
-        {
-          this->get_mesh_refinement_manager().template get_matching_mesh_refinement_strategy<MeshRefinement::Boundary<dim>>();
-          std::cout << "Boundary is found!" << std::endl;
-        }
-      catch (...)
-        {
-          std::cout << "Boundary is not found!" << std::endl;
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
-                                               "box2",
-                                               "A model in which the temperature is chosen constant on "
-                                               "all the sides of a box. For test")
-  }
-}
diff --git a/tests/find_mesh_refinement.prm.bak b/tests/find_mesh_refinement.prm.bak
deleted file mode 100644
index b1e278b2dc7..00000000000
--- a/tests/find_mesh_refinement.prm.bak
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test for looking for mesh refinement strategy plugins
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box2
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Strategy = density
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =  heat flux statistics
-end
diff --git a/tests/find_mesh_refinement_fail_1.cc.bak b/tests/find_mesh_refinement_fail_1.cc.bak
deleted file mode 100644
index 92594ca2155..00000000000
--- a/tests/find_mesh_refinement_fail_1.cc.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/box.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/mesh_refinement/boundary.h>
-#include <aspect/simulator.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    template <int dim>
-    class Box2 : public Box<dim>
-    {
-      public:
-        virtual void update();
-    };
-    template <int dim>
-    void Box2<dim>::update()
-    {
-      this->get_mesh_refinement_manager().template get_matching_mesh_refinement_strategy<MeshRefinement::Boundary<dim>>();
-      std::cout << "Boundary is found!" << std::endl;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
-                                               "box2",
-                                               "A model in which the temperature is chosen constant on "
-                                               "all the sides of a box. For test")
-  }
-}
diff --git a/tests/find_mesh_refinement_fail_1.prm.bak b/tests/find_mesh_refinement_fail_1.prm.bak
deleted file mode 100644
index 922a46b0730..00000000000
--- a/tests/find_mesh_refinement_fail_1.prm.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-# This test will request a non-activated mesh refinement strategy and
-# will not catch the resulting exception to check if the
-# exception output works correctly.
-
-# EXPECT FAILURE
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box2
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Strategy = density
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =  heat flux statistics
-end
diff --git a/tests/find_postprocess.cc.bak b/tests/find_postprocess.cc.bak
deleted file mode 100644
index 9c81576c187..00000000000
--- a/tests/find_postprocess.cc.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/box.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/postprocess/heat_flux_statistics.h>
-#include <aspect/postprocess/pressure_statistics.h>
-#include <aspect/simulator.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    template <int dim>
-    class Box2 : public Box<dim>
-    {
-      public:
-        virtual void update();
-    };
-    template <int dim>
-    void Box2<dim>::update()
-    {
-      if (this->get_postprocess_manager().template has_matching_postprocessor<Postprocess::PressureStatistics<dim>>())
-        std::cout << "PressureStatistics is found!" << std::endl;
-      else
-        std::cout << "PressureStatistics is not found!" << std::endl;
-
-      if (this->get_postprocess_manager().template has_matching_postprocessor<Postprocess::HeatFluxStatistics<dim>>())
-        std::cout << "HeatFluxStatistics is found!" << std::endl;
-      else
-        std::cout << "HeatFluxStatistics is not found!" << std::endl;
-
-      try
-        {
-          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::PressureStatistics<dim>>();
-          std::cout << "PressureStatistics is found!" << std::endl;
-        }
-      catch (...)
-        {
-          std::cout << "PressureStatistics is not found!" << std::endl;
-        }
-
-      try
-        {
-          this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::HeatFluxStatistics<dim>>();
-          std::cout << "HeatFluxStatistics is found!" << std::endl;
-        }
-      catch (...)
-        {
-          std::cout << "HeatFluxStatistics is not found!" << std::endl;
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
-                                               "box2",
-                                               "A model in which the temperature is chosen constant on "
-                                               "all the sides of a box. For test")
-  }
-}
diff --git a/tests/find_postprocess.prm.bak b/tests/find_postprocess.prm.bak
deleted file mode 100644
index 5e3e4f3f0d7..00000000000
--- a/tests/find_postprocess.prm.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box2
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =  heat flux statistics
-end
diff --git a/tests/find_postprocess_fail_1.cc.bak b/tests/find_postprocess_fail_1.cc.bak
deleted file mode 100644
index f0ed09ec46c..00000000000
--- a/tests/find_postprocess_fail_1.cc.bak
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/boundary_temperature/box.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/postprocess/heat_flux_statistics.h>
-#include <aspect/postprocess/pressure_statistics.h>
-#include <aspect/simulator.h>
-
-#include <utility>
-#include <limits>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    template <int dim>
-    class Box2 : public Box<dim>
-    {
-      public:
-        virtual void update();
-    };
-    template <int dim>
-    void Box2<dim>::update()
-    {
-      this->get_postprocess_manager().template get_matching_postprocessor<Postprocess::PressureStatistics<dim>>();
-      std::cout << "PressureStatistics is found!" << std::endl;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Box2,
-                                               "box2",
-                                               "A model in which the temperature is chosen constant on "
-                                               "all the sides of a box. For test")
-  }
-}
diff --git a/tests/find_postprocess_fail_1.prm.bak b/tests/find_postprocess_fail_1.prm.bak
deleted file mode 100644
index 4e80d4ab0fc..00000000000
--- a/tests/find_postprocess_fail_1.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-# This test will request a non-activated postprocessor and
-# will not catch the resulting exception to check if the
-# exception output works correctly.
-
-# EXPECT FAILURE
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box2
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =  heat flux statistics
-end
diff --git a/tests/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg.prm.bak b/tests/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg.prm.bak
deleted file mode 100644
index 908f301611a..00000000000
--- a/tests/free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg.prm.bak
+++ /dev/null
@@ -1,33 +0,0 @@
-# Same as free_surface_VE_cylinder_2D_loading.prm, but uses
-# a fixed elastic timestep in combination with stress averaging
-# to smooth out the elastic response to instantaneous stress changes
-# and use the GMG solver.
-# MPI: 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm
-
-
-#  Global parameters
-set Dimension                              = 2
-set Output directory                       = output_free_surface_VE_cylinder_2D_loading_fixed_elastic_dt_gmg
-set End time = 30
-
-# Material model
-
-subsection Material model
-  set Model name = viscoelastic
-  set Material averaging = harmonic average only viscosity
-
-  subsection Viscoelastic
-    set Use fixed elastic time step = true
-    set Fixed elastic time step     = 1e2
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 1000
-  end
-end
diff --git a/tests/free_surface_adaptive_blob.prm.bak b/tests/free_surface_adaptive_blob.prm.bak
deleted file mode 100644
index b858f092f3c..00000000000
--- a/tests/free_surface_adaptive_blob.prm.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-# like free_surface_blob.prm with adaptive refinement and in parallel
-# MPI: 3
-
-set Dimension = 2
-set CFL number                             = 0.5
-set End time                               = 1e9
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, basic statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/free_surface_blob.prm.bak b/tests/free_surface_blob.prm.bak
deleted file mode 100644
index a8933a148e3..00000000000
--- a/tests/free_surface_blob.prm.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-#Test for free surface topography due to a rising blob
-
-set Dimension = 2
-set CFL number                             = 0.5
-set End time                               = 1e9
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, basic statistics,
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/free_surface_blob_gmg.prm.bak b/tests/free_surface_blob_gmg.prm.bak
deleted file mode 100644
index e90258a7983..00000000000
--- a/tests/free_surface_blob_gmg.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# test gmg + free surface
-include $ASPECT_SOURCE_DIR/tests/free_surface_blob.prm
-
-set Dimension = 2
-set Output directory                       = output_free_surface_blob_gmg
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/tests/free_surface_blob_melt.cc.bak b/tests/free_surface_blob_melt.cc.bak
deleted file mode 100644
index 17f4b7f2170..00000000000
--- a/tests/free_surface_blob_melt.cc.bak
+++ /dev/null
@@ -1,326 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/global.h>
-#include <aspect/melt.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class MeltFreeSurface : public MaterialModel::MeltFractionModel<dim>, public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-        virtual void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                                     std::vector<double> &melt_fractions) const;
-        virtual bool is_compressible () const;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Reference quantities
-         * @{
-         */
-        virtual double reference_darcy_coefficient () const;
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-        /**
-         * @}
-         */
-
-      private:
-        double reference_rho;
-        double reference_T;
-        double eta;
-        double composition_viscosity_prefactor;
-        double thermal_viscosity_exponent;
-        double maximum_thermal_prefactor;
-        double minimum_thermal_prefactor;
-        double thermal_alpha;
-        double reference_specific_heat;
-
-        /**
-         * The thermal conductivity.
-         */
-        double k_value;
-
-        double compositional_delta_rho;
-    };
-
-
-    template <int dim>
-    void
-    MeltFreeSurface<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double delta_temp = in.temperature[i]-reference_T;
-          const double temperature_dependence = (reference_T > 0
-                                                 ?
-                                                 std::max(std::min(std::exp(-thermal_viscosity_exponent*delta_temp/reference_T),
-                                                                   maximum_thermal_prefactor),
-                                                          minimum_thermal_prefactor)
-                                                 :
-                                                 1.0);
-
-          out.viscosities[i] = ((composition_viscosity_prefactor != 1.0) && (in.composition[i].size()>0))
-                               ?
-                               // Geometric interpolation
-                               pow(10.0, ((1-in.composition[i][0]) * log10(eta*temperature_dependence)
-                                          + in.composition[i][0] * log10(eta*composition_viscosity_prefactor*temperature_dependence)))
-                               :
-                               temperature_dependence * eta;
-
-          const double c = (in.composition[i].size()>0)
-                           ?
-                           std::max(0.0, in.composition[i][0])
-                           :
-                           0.0;
-
-          out.densities[i] = reference_rho * (1 - thermal_alpha * (in.temperature[i] - reference_T))
-                             + compositional_delta_rho * c;
-
-          out.thermal_expansion_coefficients[i] = thermal_alpha;
-          out.specific_heat[i] = reference_specific_heat;
-          out.thermal_conductivities[i] = k_value;
-          out.compressibilities[i] = 0.0;
-          // Pressure derivative of entropy at the given positions.
-          out.entropy_derivative_pressure[i] = 0.0;
-          // Temperature derivative of entropy at the given positions.
-          out.entropy_derivative_temperature[i] = 0.0;
-          // Change in composition due to chemical reactions at the
-          // given positions. The term reaction_terms[i][c] is the
-          // change in compositional field c at point i.
-          for (unsigned int c=0; c<in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-
-      // fill melt outputs if they exist
-      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
-
-      if (melt_out != nullptr)
-        {
-          const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const double porosity = std::max(in.composition[i][porosity_idx],0.0);
-              melt_out->fluid_densities[i] = 300.;
-              melt_out->permeabilities[i] = 1e-8 * std::pow(porosity, 3);
-              melt_out->compaction_viscosities[i] = eta;
-              melt_out->fluid_viscosities[i] = 10.;
-              melt_out->fluid_density_gradients[i] = 0.0;
-            }
-        }
-    }
-
-    template <int dim>
-    void
-    MeltFreeSurface<dim>::
-    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                    std::vector<double> &melt_fractions) const
-    {
-      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
-        melt_fractions[q] = 0.0;
-      return;
-    }
-
-    template <int dim>
-    double
-    MeltFreeSurface<dim>::
-    reference_darcy_coefficient () const
-    {
-      return 1e-14;
-    }
-
-    template <int dim>
-    bool
-    MeltFreeSurface<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-
-
-    template <int dim>
-    void
-    MeltFreeSurface<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simple model");
-        {
-          prm.declare_entry ("Reference density", "3300",
-                             Patterns::Double (0),
-                             "Reference density $\\rho_0$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}.");
-          prm.declare_entry ("Reference temperature", "293",
-                             Patterns::Double (0),
-                             "The reference temperature $T_0$. The reference temperature is used "
-                             "in both the density and viscosity formulas. Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Viscosity", "5e24",
-                             Patterns::Double (0),
-                             "The value of the constant viscosity $\\eta_0$. This viscosity may be "
-                             "modified by both temperature and compositional dependencies. "
-                             "Units: \\si{\\pascal\\second}.");
-          prm.declare_entry ("Composition viscosity prefactor", "1.0",
-                             Patterns::Double (0),
-                             "A linear dependency of viscosity on the first compositional field. "
-                             "Dimensionless prefactor. With a value of 1.0 (the default) the "
-                             "viscosity does not depend on the composition. See the general documentation "
-                             "of this model for a formula that states the dependence of the "
-                             "viscosity on this factor, which is called $\\xi$ there.");
-          prm.declare_entry ("Thermal viscosity exponent", "0.0",
-                             Patterns::Double (0),
-                             "The temperature dependence of viscosity. Dimensionless exponent. "
-                             "See the general documentation "
-                             "of this model for a formula that states the dependence of the "
-                             "viscosity on this factor, which is called $\\beta$ there.");
-          prm.declare_entry("Maximum thermal prefactor","1.0e2",
-                            Patterns::Double (0),
-                            "The maximum value of the viscosity prefactor associated with temperature "
-                            "dependence.");
-          prm.declare_entry("Minimum thermal prefactor","1.0e-2",
-                            Patterns::Double (0),
-                            "The minimum value of the viscosity prefactor associated with temperature "
-                            "dependence.");
-          prm.declare_entry ("Thermal conductivity", "4.7",
-                             Patterns::Double (0),
-                             "The value of the thermal conductivity $k$. "
-                             "Units: \\si{\\watt\\per\\meter\\per\\kelvin}.");
-          prm.declare_entry ("Reference specific heat", "1250",
-                             Patterns::Double (0),
-                             "The value of the specific heat $C_p$. "
-                             "Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.");
-          prm.declare_entry ("Thermal expansion coefficient", "2e-5",
-                             Patterns::Double (0),
-                             "The value of the thermal expansion coefficient $\\alpha$. "
-                             "Units: \\si{\\per\\kelvin}.");
-          prm.declare_entry ("Density differential for compositional field 1", "0",
-                             Patterns::Double(),
-                             "If compositional fields are used, then one would frequently want "
-                             "to make the density depend on these fields. In this simple material "
-                             "model, we make the following assumptions: if no compositional fields "
-                             "are used in the current simulation, then the density is simply the usual "
-                             "one with its linear dependence on the temperature. If there are compositional "
-                             "fields, then the density only depends on the first one in such a way that "
-                             "the density has an additional term of the kind $+\\Delta \\rho \\; c_1(\\mathbf x)$. "
-                             "This parameter describes the value of $\\Delta \\rho$. "
-                             "Units: \\si{\\kilogram\\per\\meter\\cubed}/unit change in composition.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    MeltFreeSurface<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Simple model");
-        {
-          reference_rho              = prm.get_double ("Reference density");
-          reference_T                = prm.get_double ("Reference temperature");
-          eta                        = prm.get_double ("Viscosity");
-          composition_viscosity_prefactor = prm.get_double ("Composition viscosity prefactor");
-          thermal_viscosity_exponent = prm.get_double ("Thermal viscosity exponent");
-          maximum_thermal_prefactor       = prm.get_double ("Maximum thermal prefactor");
-          minimum_thermal_prefactor       = prm.get_double ("Minimum thermal prefactor");
-          if ( maximum_thermal_prefactor == 0.0 ) maximum_thermal_prefactor = std::numeric_limits<double>::max();
-          if ( minimum_thermal_prefactor == 0.0 ) minimum_thermal_prefactor = std::numeric_limits<double>::min();
-
-          k_value                    = prm.get_double ("Thermal conductivity");
-          reference_specific_heat    = prm.get_double ("Reference specific heat");
-          thermal_alpha              = prm.get_double ("Thermal expansion coefficient");
-          compositional_delta_rho    = prm.get_double ("Density differential for compositional field 1");
-
-          if (thermal_viscosity_exponent!=0.0 && reference_T == 0.0)
-            AssertThrow(false, ExcMessage("Error: Material model simple with Thermal viscosity exponent can not have reference_T=0."));
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::none;
-      this->model_dependence.viscosity = NonlinearDependence::none;
-      this->model_dependence.density = NonlinearDependence::none;
-
-      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-
-      if (thermal_viscosity_exponent != 0)
-        this->model_dependence.viscosity |= NonlinearDependence::temperature;
-      if (composition_viscosity_prefactor != 1.0)
-        this->model_dependence.viscosity |= NonlinearDependence::compositional_fields;
-
-      if (thermal_alpha != 0)
-        this->model_dependence.density |=NonlinearDependence::temperature;
-      if (compositional_delta_rho != 0)
-        this->model_dependence.density |=NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(MeltFreeSurface,
-                                   "melt free surface",
-                                   "A simple material model that is like the "
-                                   "'simple' model, but has melt outputs.")
-  }
-}
diff --git a/tests/free_surface_blob_melt.prm.bak b/tests/free_surface_blob_melt.prm.bak
deleted file mode 100644
index ca63d832517..00000000000
--- a/tests/free_surface_blob_melt.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-# Test for free surface topography due to a rising blob
-# with melt transport = on, but zero porosity.
-# This test is the same as free_surface_blob (except for
-# the melt transport) and tests that results are approximately
-# the same.
-
-set Dimension = 2
-set CFL number                             = 0.5
-set End time                               = 1e9
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = melt free surface
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, basic statistics,
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/free_surface_blob_nonzero_melt.cc.bak b/tests/free_surface_blob_nonzero_melt.cc.bak
deleted file mode 100644
index e127b3eaeac..00000000000
--- a/tests/free_surface_blob_nonzero_melt.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "free_surface_blob_melt.cc"
diff --git a/tests/free_surface_blob_nonzero_melt.prm.bak b/tests/free_surface_blob_nonzero_melt.prm.bak
deleted file mode 100644
index e7e9b841a68..00000000000
--- a/tests/free_surface_blob_nonzero_melt.prm.bak
+++ /dev/null
@@ -1,153 +0,0 @@
-# Test for free surface topography due to a rising blob
-# with melt transport = on and nonzero porosity.
-# The test is the same as free_surface_blob_melt, except that melt
-# has a nonzero initial condition.
-# We test if the boundary conditions for melt are set correctly
-# (no melt flowing in/out at the free surface) by checking if the
-# mass of the porosity field is conserved.
-
-set Dimension = 2
-set CFL number                             = 0.5
-set End time                               = 1e4
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-set Maximum time step                      = 1e4
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = melt free surface
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = minimum refinement function
-  set Time steps between mesh refinement = 0
-
-  subsection Minimum refinement function
-    set Variable names      = depth, phi
-    set Function expression = if(depth<10000,5,3)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.02 * (sin (3.141*x/5.e5) * sin (2*3.141*y/5.e5)) * (sin (3.141*x/5.e5) * sin (2*3.141*y/5.e5))
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, visualization, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables =  melt material properties
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/free_surface_iterated_IMPES.prm.bak b/tests/free_surface_iterated_IMPES.prm.bak
deleted file mode 100644
index 8bb9e64ff1e..00000000000
--- a/tests/free_surface_iterated_IMPES.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-# This is a copy of the free_surface_iterated_stokes test,
-# the only difference being that it uses the iterated Advection and Stokes solver.
-
-set Dimension = 2
-set CFL number                             = 0.1
-set End time                               = 1e9
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/free_surface_iterated_stokes.prm.bak b/tests/free_surface_iterated_stokes.prm.bak
deleted file mode 100644
index 7efea011e3f..00000000000
--- a/tests/free_surface_iterated_stokes.prm.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-#Test for running a free surface with the iterated stokes solver
-
-set Dimension = 2
-set CFL number                             = 0.1
-set End time                               = 1e9
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/free_surface_iterated_stokes_gmg.prm.bak b/tests/free_surface_iterated_stokes_gmg.prm.bak
deleted file mode 100644
index b8dd281ac99..00000000000
--- a/tests/free_surface_iterated_stokes_gmg.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# test gmg + free surface
-include $ASPECT_SOURCE_DIR/tests/free_surface_iterated_stokes.prm
-
-set Dimension = 2
-set Output directory                       = output_free_surface_iterated_stokes_gmg
-
-subsection Mesh refinement
-  set Initial global refinement          = 3                      # default: 2
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type =  block GMG
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/tests/free_surface_relaxation.cc.bak b/tests/free_surface_relaxation.cc.bak
deleted file mode 100644
index 5bca2e1708f..00000000000
--- a/tests/free_surface_relaxation.cc.bak
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-#include <aspect/geometry_model/box.h>
-#include <deal.II/grid/grid_generator.h>
-#include <deal.II/grid/tria_iterator.h>
-#include <deal.II/grid/tria_accessor.h>
-#include <deal.II/grid/tria.h>
-#include <cmath>
-#include <vector>
-
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    /**
-     * A class deriving from Box<dim>, which changes the upper boundary
-       with a sinusoidal perturbation of a given order and amplitude
-     */
-    template <int dim>
-    class ReboundBox : public Box<dim>
-    {
-      public:
-        /**
-         * Generate a coarse mesh for the geometry described by this class.
-         * Makes perturbs the top boundary of the box with a function
-         * of the form z' = amplitude * cos(order * x )
-         */
-        virtual
-        void create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter
-         * file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-
-        /**
-         * Give the depth of a point.
-         */
-        virtual
-        double depth( const Point<dim> &position) const;
-
-        /**
-         * Give the maximal depth of a point.
-         */
-        virtual
-        double maximal_depth() const;
-
-      private:
-
-        unsigned int order;  // Order of the perturbation
-        double amplitude;  // amplitude of the perturbation
-
-    };
-
-    template <int dim>
-    void
-    ReboundBox<dim>::
-    create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
-    {
-
-      // Call the normal Box mesh generator
-      Box<dim>::create_coarse_mesh( coarse_grid );
-
-      // move the vertices
-      std::vector<bool> vertex_touched (coarse_grid.n_vertices(), false);
-
-      typename parallel::distributed::Triangulation<dim>::active_cell_iterator cell;
-      for (cell = coarse_grid.begin_active();  cell != coarse_grid.end();  ++cell)
-        for (unsigned int v = 0; v < cell->n_vertices();  ++v)
-          if (vertex_touched[cell->vertex_index(v)] == false)
-            {
-              Point<dim> &vertex = cell->vertex(v);
-              vertex[dim-1] = vertex[dim-1] + std::cos(order*2.0*M_PI*vertex[0]/(this->get_extents()[0]))*
-                              amplitude*vertex[dim-1]/(this->get_extents()[dim-1]);
-              vertex_touched[cell->vertex_index(v)] = true;
-            }
-
-    }
-
-    template <int dim>
-    double
-    ReboundBox<dim>::maximal_depth() const
-    {
-      return Box<dim>::maximal_depth()+amplitude;
-    }
-
-    template <int dim>
-    double
-    ReboundBox<dim>::depth(const Point<dim> &position) const
-    {
-      double d = maximal_depth()-position(dim-1);
-      return d;
-    }
-
-    template <int dim>
-    void
-    ReboundBox<dim>::
-    declare_parameters (ParameterHandler &prm)
-    {
-      Box<dim>::declare_parameters(prm);
-
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Rebound Box");
-        {
-          prm.declare_entry ("Order", "1",
-                             Patterns::Double (0),
-                             "Order of the perturbation");
-          prm.declare_entry ("Amplitude", "0.1",
-                             Patterns::Double (0),
-                             "Scaled amplitude of the perturbation");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    ReboundBox<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      Box<dim>::parse_parameters(prm);
-
-      prm.enter_subsection("Geometry model");
-      {
-        prm.enter_subsection("Rebound Box");
-        {
-          order = prm.get_double ("Order");
-          amplitude = prm.get_double ("Amplitude");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace GeometryModel
-  {
-    ASPECT_REGISTER_GEOMETRY_MODEL(ReboundBox,
-                                   "rebound box",
-                                   "Geometry model for benchmarking relaxation of topography.")
-  }
-}
diff --git a/tests/free_surface_relaxation.prm.bak b/tests/free_surface_relaxation.prm.bak
deleted file mode 100644
index 102ff80b7aa..00000000000
--- a/tests/free_surface_relaxation.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-# Test for relaxing topography of the free surface after an
-# initial sinusoidal perturbation
-
-set Dimension = 2
-set CFL number                             = 0.01
-set End time                               = 1e5
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = rebound box
-
-  subsection Rebound Box
-    set Order = 3
-    set Amplitude = 1.5e4
-  end
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 50
-    set Y repetitions = 20
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  0.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-    set Density differential for compositional field 1 = 0.0
-    set Composition viscosity prefactor = 100.
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.00
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, basic statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/free_surface_tangential_mesh_velocity.prm.bak b/tests/free_surface_tangential_mesh_velocity.prm.bak
deleted file mode 100644
index 2f26fb4b882..00000000000
--- a/tests/free_surface_tangential_mesh_velocity.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-set Dimension                              = 2
-set End time                               = 1e6
-set Use years in output instead of seconds = true
-set Output directory                       = output
-set Adiabatic surface temperature          = 1613
-set CFL number                             = 1.0
-set Pressure normalization                 = no
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2e5
-    set X repetitions = 2
-    set Y extent = 1e5
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = function
-
-  # box prescribes a constant temp, function is for a function
-  subsection Function
-    set Function expression = if(y<5e4,1613,273)
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom
-  set Prescribed velocity boundary indicators = left x: function, right x: function
-
-  subsection Function
-    set Function expression = if(x>0, 1e-2 , -1e-2); 0
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = top: free surface
-  set Additional tangential mesh velocity boundary indicators = left,right
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.8
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density     = 3300
-    set Thermal conductivity  = 3.3
-    set Thermal expansion coefficient  = 3e-5
-    set Reference specific heat        = 1200
-    set Viscosity             = 1e21
-    set Reference temperature = 1600
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Strategy                           = strain rate, topography
-end
-
-# After 1 My, the model domain volume should have shrunk from 2e10 m2
-# to 1.8 m2 because of the prescribed outflow in combination
-# with a free surface.
-subsection Postprocess
-  set List of postprocessors = topography, domain volume statistics
-end
diff --git a/tests/free_surface_tangential_mesh_velocity_2.prm.bak b/tests/free_surface_tangential_mesh_velocity_2.prm.bak
deleted file mode 100644
index b8a59f51870..00000000000
--- a/tests/free_surface_tangential_mesh_velocity_2.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# A copy of free_surface_tangential_mesh_velocity that has tangential
-# mesh velocity constraints on the same boundary as prescribed constraints
-# (in this case a free surface).
-
-set Dimension                              = 2
-set End time                               = 1e6
-set Use years in output instead of seconds = true
-set Output directory                       = output
-set Adiabatic surface temperature          = 1613
-set CFL number                             = 1.0
-set Pressure normalization                 = no
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2e5
-    set X repetitions = 2
-    set Y extent = 1e5
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = top: free surface
-  set Additional tangential mesh velocity boundary indicators = left,right, top
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = function
-
-  subsection Function
-    set Function expression = if(y<5e4,1613,273)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-
-  subsection Function
-    set Function expression = if(x>0, 1e-2 , -1e-2); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.8
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density     = 3300
-    set Thermal conductivity  = 3.3
-    set Thermal expansion coefficient  = 3e-5
-    set Reference specific heat        = 1200
-    set Viscosity             = 1e21
-    set Reference temperature = 1600
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Strategy                           = strain rate, topography
-end
-
-subsection Postprocess
-  set List of postprocessors = topography
-end
diff --git a/tests/free_surface_timestep_repeat.prm.bak b/tests/free_surface_timestep_repeat.prm.bak
deleted file mode 100644
index c5a69ff7dfe..00000000000
--- a/tests/free_surface_timestep_repeat.prm.bak
+++ /dev/null
@@ -1,176 +0,0 @@
-# This test is based on
-# /benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm
-# and checks that we can repeat time steps with mesh deformation enabled.
-
-#  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 2
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set CFL number                             = 0.001
-set Maximum time step                      = 1
-set Output directory                       = output_free_surface_VE_cylinder_2D_loading-repeat
-set Timing output frequency                = 10
-set Pressure normalization                 = no
-
-subsection Time stepping
-  set List of model names = convection time step, repeat on cutback
-  set Minimum time step size = 0.5
-
-  subsection Repeat on cutback
-    set Relative repeat threshold = 0.99
-  end
-end
-
-# Model geometry (500x500 km, 50 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 500e3
-    set Y extent      = 500e3
-  end
-end
-
-# Mesh refinement specifications
-# Mesh refinement does not seem to affect
-# deformation of free surface (at least in 2-D).
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Time steps between mesh refinement = 1
-  set Strategy         = strain rate
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Mesh deformation
-  set Additional tangential mesh velocity boundary indicators = left,right
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Surface velocity projection      = normal
-  end
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-end
-
-# Prescribe a fixed vertical traction on the top boundary
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = top y: function
-
-  subsection Function
-    set Variable names = x,y,t
-
-    #set Function expression = 0; 1.e9 + -20.e3*x
-    set Function constants  = r0=100.e3, H0=1.e3, t1=1.e3, rhoi=900, g=9.8, t0=1.e3
-
-    # r0 is load radius, H0 is load height, t1 is time load is fully removed,
-    # rhoi is density of ice/load
-    # option to linearly thin load beginning at time t0.
-    set Function expression = 0; if (x<r0 ,if(t<t0,-g*H0*rhoi,if(t<t1,-g*H0*rhoi*(1-(t-t0)/t1),0)), 0)
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0;
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = true
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# Temperature initial conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 3300
-    set Viscosities                 = 3.e20
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 3
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.8
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, temperature statistics, topography, velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate
-    set Time between graphical output = 2
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-
-  subsection Topography
-    set Output to file = true
-    set Time between text output = 2
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/tests/function_mesh_deformation_tangential_mesh_velocity.prm.bak b/tests/function_mesh_deformation_tangential_mesh_velocity.prm.bak
deleted file mode 100644
index 151ba67ed17..00000000000
--- a/tests/function_mesh_deformation_tangential_mesh_velocity.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# This test prescribes a surface motion going from
-# 1000 m per million year on the left to -1000 m
-# on the right, thus keeping the overall domain area
-# fixed.
-set Dimension                              = 2
-set End time                               = 5e5
-set Maximum time step                      = 1e4
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1613
-set CFL number                             = 1.0
-set Pressure normalization                 = surface
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2e5
-    set X repetitions = 2
-    set Y extent = 1e5
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = function
-
-  subsection Function
-    set Function expression = if(y<5e4,1613,273)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-  set Zero velocity boundary indicators       = left, right
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = top: boundary function
-
-  # The left and right boundary are allowed to move,
-  # even though the Stokes velocity is zero along these boundaries.
-  set Additional tangential mesh velocity boundary indicators = left,right
-
-  # Prescribe a boundary velocity in m/s equal to max 1000 m/My
-  subsection Boundary function
-    set Variable names      = x,y,t
-    set Function expression = 0;  -3.168808781e-16*(x-1e5)
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.8
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density     = 3300
-    set Thermal conductivity  = 3.3
-    set Thermal expansion coefficient  = 3e-5
-    set Reference specific heat        = 1200
-    set Viscosity             = 1e21
-    set Reference temperature = 1600
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Strategy                           = strain rate, topography
-end
-
-subsection Postprocess
-  # After 1 My, min/max topography should be -1000/1000 m.
-  set List of postprocessors = topography
-end
diff --git a/tests/gaussian_initial_temperature.prm.bak b/tests/gaussian_initial_temperature.prm.bak
deleted file mode 100644
index 13a0d7dab7a..00000000000
--- a/tests/gaussian_initial_temperature.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# Test the spherical gaussian perturbation initial temperature model
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-
-  #  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 360
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Additional refinement times              =
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Initial temperature model
-  set Model name = spherical gaussian perturbation
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/geoid.prm.bak b/tests/geoid.prm.bak
deleted file mode 100644
index 06cb3e1f802..00000000000
--- a/tests/geoid.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# A simple pure math setup to compute geoid in single degree 2 order 0 perturbation density field.
-# The perturbation is added to a constant density, i.e., degree 0 order 0 component.
-# The analytic solution of the density integral contribution of this case should be -0.53059320038
-# for (2,0) component and 14.1570019498 for degree 0 order 0, and the sum up of the spherical harmonics
-# of dynamic topography should be the same as the grid output in dynamic topography postprocessor.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-set Adiabatic surface temperature          = 0.0
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 0.1
-    set Viscosity                     = 1.0
-    set Thermal conductivity          = 1.0
-    set Reference temperature         = 0.0
-    set Reference density             = 1.0
-    set Reference specific heat       = 1.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 200000
-    set Outer radius  = 400000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner,outer
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = angular momentum
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Function constants = pi=3.1415926536
-    set Variable names = r,phi,theta,t
-    set Function expression = (5/2)*sqrt(5/pi)*(3*(cos(theta))^2-1)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.8
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 0
-  set Strategy                           = density
-end
-
-subsection Postprocess
-  set List of postprocessors = basic statistics, geoid, dynamic topography
-
-  subsection Dynamic topography
-    set Density above = 0.
-    set Density below = 2.0
-  end
-
-  subsection Geoid
-    set Maximum degree = 10
-    set Minimum degree = 0
-    set Output data in geographical coordinates = true
-    set Density above = 0
-    set Density below = 2.0
-    set Also output the spherical harmonic coefficients of geoid anomaly = true
-    set Also output the spherical harmonic coefficients of surface dynamic topography contribution = true
-    set Also output the spherical harmonic coefficients of CMB dynamic topography contribution = true
-    set Also output the spherical harmonic coefficients of density anomaly contribution = true
-    set Include surface topography contribution = true
-    set Include CMB topography contribution = true
-    set Also output the gravity anomaly  = true
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/geoid_freesurface.prm.bak b/tests/geoid_freesurface.prm.bak
deleted file mode 100644
index 4b5452ae735..00000000000
--- a/tests/geoid_freesurface.prm.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-# A simple setup to compute geoid in single degree 2 order 0 perturbation density field.
-# The perturbation is added to a constant density, i.e., degree 0 order 0 component.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 1
-set Adiabatic surface temperature          = 0.0
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Pressure normalization                 = no
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 0.1
-    set Viscosity                     = 1.0
-    set Thermal conductivity          = 1.0
-    set Reference temperature         = 0.0
-    set Reference density             = 1.0
-    set Reference specific heat       = 1.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 200000
-    set Outer radius = 400000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner
-end
-
-subsection Nullspace removal
-  set Remove nullspace = angular momentum
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Function constants = pi=3.1415926536
-    set Variable names = r,phi,theta,t
-    set Function expression = (5/2)*sqrt(5/pi)*(3*(cos(theta))^2-1)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.8
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-  set Strategy                           = density
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = outer: free surface
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = basic statistics, geoid, dynamic topography, topography
-
-  subsection Topography
-    set Output to file = true
-  end
-
-  subsection Dynamic topography
-    set Density above = 0.
-    set Density below = 2.0
-  end
-
-  subsection Geoid
-    set Include surface topography contribution = true
-    set Include CMB topography contribution = true
-    set Maximum degree = 10
-    set Minimum degree = 0
-    set Output data in geographical coordinates = true
-    set Density above = 0
-    set Density below = 2.0
-    set Output geoid anomaly coefficients = true
-    set Output surface topography contribution coefficients = true
-    set Output CMB topography contribution coefficients = true
-    set Output density anomaly contribution coefficients = true
-    set Output gravity anomaly = true
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 1
-end
diff --git a/tests/geoid_no_topo.prm.bak b/tests/geoid_no_topo.prm.bak
deleted file mode 100644
index 3eb6a7daca7..00000000000
--- a/tests/geoid_no_topo.prm.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-# A simple pure math setup to compute geoid in single degree 2 order 0 perturbation density field.
-# The perturbation is added to a constant density, i.e., degree 0 order 0 component.
-# The analytic solution of the density integral contribution of this case should be -0.53059320038
-# for (2,0) component and 14.1570019498 for degree 0 order 0.
-# The contribution from dynamic topography is not included.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-set Adiabatic surface temperature          = 0.0
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 0.1
-    set Reference temperature         = 0.0
-    set Reference density             = 1.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 200000
-    set Outer radius  = 400000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner,outer
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = angular momentum
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Function constants = pi=3.1415926536
-    set Variable names = r,phi,theta,t
-    set Function expression = (5/2)*sqrt(5/pi)*(3*(cos(theta))^2-1)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.8
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 0
-  set Strategy                           = density
-end
-
-subsection Postprocess
-  set List of postprocessors = geoid
-
-  subsection Geoid
-    set Maximum degree = 10
-    set Minimum degree = 0
-    set Output data in geographical coordinates = true
-    set Also output the spherical harmonic coefficients of geoid anomaly = true
-    set Also output the spherical harmonic coefficients of density anomaly contribution = true
-    set Include surface topography contribution = false
-    set Include CMB topography contribution = false
-    set Also output the gravity anomaly  = true
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/geoid_visualization.prm.bak b/tests/geoid_visualization.prm.bak
deleted file mode 100644
index 25bea323052..00000000000
--- a/tests/geoid_visualization.prm.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-# A test for the geoid visualization postprocessor.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-set Adiabatic surface temperature          = 0.0
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 1.0e-1
-    set Viscosity                     = 1.0
-    set Thermal conductivity          = 1.0
-    set Reference temperature         = 0.0
-    set Reference density             = 1.0
-    set Reference specific heat       = 1.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 200000
-    set Outer radius  = 400000
-    set Cells along circumference = 12
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner,outer
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = angular momentum
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Function constants = pi=3.1415926536
-    set Variable names = r,phi,theta,t
-    set Function expression = (5/2)*sqrt(5/pi)*(3*(cos(theta))^2-1)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.8
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = geoid
-    set Output format = gnuplot
-  end
-
-  subsection Geoid
-    set Maximum degree = 10
-    set Minimum degree = 0
-    set Output data in geographical coordinates = true
-    set Density above = 0
-    set Density below = 2.0
-    set Also output the spherical harmonic coefficients of geoid anomaly = false
-    set Also output the spherical harmonic coefficients of surface dynamic topography contribution = false
-    set Also output the spherical harmonic coefficients of CMB dynamic topography contribution = false
-    set Also output the spherical harmonic coefficients of density anomaly contribution = false
-    set Include surface topography contribution = true
-    set Include CMB topography contribution = true
-  end
-
-  subsection Dynamic topography
-    set Density above = 0.
-    set Density below = 2.0
-    set Output surface = false
-    set Output bottom = false
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/geometric_average_crash.prm.bak b/tests/geometric_average_crash.prm.bak
deleted file mode 100644
index f61cdf27366..00000000000
--- a/tests/geometric_average_crash.prm.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-# document crash/FPE that happens when doing geometric averaging
-# with viscosities in 3d (due to an overflow)
-
-set Dimension                               = 3
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius      = 1
-    set Chunk outer radius      = 2
-    set Chunk minimum latitude  = 37
-    set Chunk maximum latitude  = 49
-    set Chunk minimum longitude = -132
-    set Chunk maximum longitude = -116
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names    = initial temperature
-  set Fixed temperature boundary indicators     = inner, outer
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators   = outer
-  set Zero velocity boundary indicators         = inner
-end
-
-subsection Material model
-  set Material averaging    = geometric average
-  set Model name            = simple
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 1e6
-    set Age top boundary layer = 5e6
-    set Amplitude = 100
-    set Position = center
-    set Radius = 100e3
-    set Subadiabaticity = 0
-  end
-end
-
-subsection Gravity model
-  set Model name    = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement             = 3
-  set Initial adaptive refinement           = 0
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 0
-end
diff --git a/tests/geometric_average_only_viscosity.prm.bak b/tests/geometric_average_only_viscosity.prm.bak
deleted file mode 100644
index 86c74bbf8ec..00000000000
--- a/tests/geometric_average_only_viscosity.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# This is a setup to test geometric averaging of the viscosity
-# and that it works with the GMG.
-# The viscosity in the model decreases exponentially from left to
-# right from 1e14 Pa s to 1e10 Pa s. The model has two cells, so
-# using the geometric average only for the viscosity should lead
-# to a viscosity of 1e11 in the cells on the left and 1e13 in the
-# cells on the right.
-
-set Dimension                              = 2
-set End time                               = 0
-set Adiabatic surface temperature          = 100
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100
-    set Y extent = 100
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = 200 - x
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom, left, right
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = geometric average only viscosity
-
-  subsection Simple model
-    set Viscosity = 1e14
-    set Thermal viscosity exponent = 9.210340372 #ln(10000)
-    set Reference temperature = 100
-    set Minimum thermal prefactor = 1e-6
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables      = material properties
-    set Interpolate output            = false
-  end
-end
diff --git a/tests/global_latent_heat.prm.bak b/tests/global_latent_heat.prm.bak
deleted file mode 100644
index d2c348ce691..00000000000
--- a/tests/global_latent_heat.prm.bak
+++ /dev/null
@@ -1,159 +0,0 @@
-# This is a test for the latent heat of melt heating model
-# and its interaction with other heating plugins.
-# A constant heating rate is described using the function
-# heating model, and this heating should lead to melting
-# of approximately 0.01/s (so that the maximum porosity at
-# the end of the model run (t=1s) should be approximately
-# 1%. In practice, this value is slightly lower because
-# some heat is also used to increase the temperature of
-# the material.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 1
-set Maximum time step                      = 0.01
-set Output directory                       = output_latent_heat
-set Nonlinear solver scheme                = single Advection, no Stokes
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1000
-set Use operator splitting = true
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Function expression = 0;0
-  end
-
-  subsection Pressure function
-    set Function expression = 0
-  end
-
-  subsection Fluid pressure function
-    set Function expression = 0
-  end
-
-  subsection Compaction pressure function
-    set Function expression = 0
-  end
-
-  subsection Fluid velocity function
-    set Function expression = 0;0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields  = porosity, peridotite
-end
-
-subsection Melt settings
-  set Include melt transport               = true
-  set Melt scaling factor threshold        = 1e-8
-  set Use discontinuous compaction pressure = false
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = amplitude=500, width=50000, b=100000
-    set Function expression = 1000
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 0; 0
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       =
-  set Prescribed velocity boundary indicators =
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-  set List of model names = initial composition
-end
-
-subsection Heating model
-  set List of model names = latent heat melt, function
-
-  subsection Latent heat melt
-    set Melting entropy change = -1000
-  end
-
-  subsection Function
-    set Function expression = 1e4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Thermal conductivity          = 0
-    set Reference shear viscosity     = 5e22
-    set Thermal viscosity exponent    = 0
-    set Exponential melt weakening factor    = 0
-    set Include melting and freezing  = true
-    set Melting time scale for operator splitting = 0.0005
-    set Thermal expansion coefficient = 0
-    set Reference specific heat       = 100
-    set Reference temperature         = 1000
-    set Reference solid density       = 1000
-    set Reference melt density        = 1000
-    set Depletion solidus change      = 0
-    set Pressure solidus change       = 0
-    set Surface solidus               = 1000
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Minimum refinement level                 = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, composition statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set List of output variables = material properties, nonadiabatic temperature, melt fraction
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity,reaction terms
-    end
-  end
-end
diff --git a/tests/global_melt.prm.bak b/tests/global_melt.prm.bak
deleted file mode 100644
index c6fc81f113e..00000000000
--- a/tests/global_melt.prm.bak
+++ /dev/null
@@ -1,216 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Test for melt migration in a global-scale model
-
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 1.0
-set Maximum time step                      = 1e6
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = with_melt
-set Max nonlinear iterations               = 4
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 5e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.2
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3700
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = #2,3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-
-  subsection Function
-    set Function constants  = b=100000, c=20000
-    set Variable names      = x,y
-    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 8700000
-    set Y extent = 2900000
-
-    #    set X periodic = true
-    set X repetitions = 3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 5e8
-    set Age top boundary layer    = 3e8
-    set Amplitude                 = 50
-    set Position                  = center
-    set Radius                    = 350000
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-
-  subsection Harmonic perturbation
-    set Magnitude = 50
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,a = 0.0, b = 2500000, c = 100000, d=1450000
-    set Function expression = a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c)); a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Reference melt density            = 3000
-    set Thermal expansion coefficient     = 2e-5
-    set Reference permeability            = 1e-8
-    set Reference shear viscosity         = 5e21
-    set Reference bulk viscosity          = 1e19
-    set Exponential melt weakening factor = 10
-    set Thermal viscosity exponent        = 7
-    set Thermal bulk viscosity exponent   = 7
-    set Reference temperature             = 1600
-    set Solid compressibility             = 4.2e-12
-    set Melt compressibility              = 1.25e-11
-    set Reference melt viscosity          = 10
-    set Depletion density change          = -200.0 # -100.0 # 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 3
-  set Strategy                                 = composition threshold, minimum refinement function #, nonadiabatic temperature
-  set Time steps between mesh refinement       = 0
-
-  subsection Minimum refinement function
-    set Coordinate system   = depth
-    set Function expression = if (depth>1500000,5,4)
-    set Variable names      = depth,phi
-  end
-
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-4,1.0
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating #, latent heat melt, shear heating
-end
-
-subsection Nullspace removal
-  #  set Remove nullspace                        = net x translation
-
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Interpolate output            = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-
-  subsection Depth average
-    set Number of zones = 12
-    set Time between graphical output = 6e5
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint = 1700
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-14
-  set Temperature solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/global_melt_parallel.prm.bak b/tests/global_melt_parallel.prm.bak
deleted file mode 100644
index 05319e19fd4..00000000000
--- a/tests/global_melt_parallel.prm.bak
+++ /dev/null
@@ -1,214 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Test for melt migration in a global-scale model
-
-# MPI: 2
-
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 1.0
-set Maximum time step                      = 1e6
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = with_melt
-set Max nonlinear iterations               = 4
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 5e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.2
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3700
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = #2,3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-
-  subsection Function
-    set Function constants  = b=100000, c=20000
-    set Variable names      = x,y
-    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 8700000
-    set Y extent = 2900000
-
-    #    set X periodic = true
-    set X repetitions = 3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 5e8
-    set Age top boundary layer    = 3e8
-    set Amplitude                 = 50
-    set Position                  = center
-    set Radius                    = 350000
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-
-  subsection Harmonic perturbation
-    set Magnitude = 50
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,a = 0.0, b = 2500000, c = 100000, d=1450000
-    set Function expression = a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c)); a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Reference melt density            = 3000
-    set Thermal expansion coefficient     = 2e-5
-    set Reference permeability            = 1e-8
-    set Reference shear viscosity         = 5e21
-    set Reference bulk viscosity          = 1e19
-    set Exponential melt weakening factor = 10
-    set Thermal viscosity exponent        = 7
-    set Thermal bulk viscosity exponent   = 7
-    set Reference temperature             = 1600
-    set Solid compressibility             = 4.2e-12
-    set Melt compressibility              = 1.25e-11
-    set Reference melt viscosity          = 10
-    set Depletion density change          = -200.0 # -100.0 # 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 3
-  set Strategy                                 = composition threshold, minimum refinement function #, nonadiabatic temperature
-  set Time steps between mesh refinement       = 0
-
-  subsection Minimum refinement function
-    set Coordinate system   = depth
-    set Function expression = if (depth>1500000,5,4)
-    set Variable names      = depth,phi
-  end
-
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-4,1.0
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating #, latent heat melt, shear heating
-end
-
-subsection Nullspace removal
-  #  set Remove nullspace                        = net x translation
-
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Interpolate output            = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-
-  subsection Depth average
-    set Number of zones = 12
-    set Time between graphical output = 6e5
-  end
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-14
-  set Temperature solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/global_refine_amr.cc.bak b/tests/global_refine_amr.cc.bak
deleted file mode 100644
index a98892ff04a..00000000000
--- a/tests/global_refine_amr.cc.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/simulator_access.h>
-#include <math.h>
-
-
-using namespace dealii;
-
-
-namespace aspect
-{
-  template <int dim>
-  class AMRLeft : public MeshRefinement::Interface<dim>,
-    public SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * After cells have been marked for coarsening/refinement, apply
-       * additional criteria independent of the error estimate.
-       *
-       */
-      virtual
-      void
-      tag_additional_cells () const;
-
-      /**
-       * Declare the parameters this class takes through input files.
-       */
-      static
-      void
-      declare_parameters (ParameterHandler &prm);
-
-      /**
-       * Read the parameters this class declares from the parameter
-       * file.
-       */
-      virtual
-      void
-      parse_parameters (ParameterHandler &prm);
-
-    private:
-  };
-
-
-  template <int dim>
-  void
-  AMRLeft<dim>::tag_additional_cells () const
-  {
-    std::cout << "plugin is called!" << std::endl;
-
-    for (typename Triangulation<dim>::active_cell_iterator
-         cell = this->get_triangulation().begin_active();
-         cell != this->get_triangulation().end(); ++cell)
-      {
-        if (cell->is_locally_owned() && cell->center(true)[0]<0.5)
-          cell->clear_refine_flag ();
-      }
-  }
-
-  template <int dim>
-  void
-  AMRLeft<dim>::
-  declare_parameters (ParameterHandler &prm)
-  {
-  }
-
-  template <int dim>
-  void
-  AMRLeft<dim>::parse_parameters (ParameterHandler &prm)
-  {
-  }
-
-}
-
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(AMRLeft,
-                                            "AMRLeft",
-                                            "TODO")
-}
diff --git a/tests/global_refine_amr.prm.bak b/tests/global_refine_amr.prm.bak
deleted file mode 100644
index 6101973eb68..00000000000
--- a/tests/global_refine_amr.prm.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-  set Strategy = AMRLeft
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/global_refine_bug.prm.bak b/tests/global_refine_bug.prm.bak
deleted file mode 100644
index 95e52be5227..00000000000
--- a/tests/global_refine_bug.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# Simple setup showing a bug with global refinement
-#
-# When running a model with many MPI ranks and very few cells on each
-# rank, mesh smoothing would stop us from refining all cells correctly.
-# Here, we would have 1,444 DoFs with < 8 ranks and 1,418 with 8 ranks.
-#
-# MPI: 8
-
-set Dimension                              = 2
-set End time                               = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 5
-    set Y repetitions = 5
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-  end
-end
diff --git a/tests/gmg_mesh_deform.prm.bak b/tests/gmg_mesh_deform.prm.bak
deleted file mode 100644
index 5dadb762b3f..00000000000
--- a/tests/gmg_mesh_deform.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# Test GMG with initial mesh deformation
-#
-# This test is a copy of
-
-include $ASPECT_SOURCE_DIR/tests/box_initial_mesh_deformation_ascii_data.prm
-
-set Dimension = 3
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/tests/gmg_mesh_deform_adaptive.prm.bak b/tests/gmg_mesh_deform_adaptive.prm.bak
deleted file mode 100644
index 92cf731c7b1..00000000000
--- a/tests/gmg_mesh_deform_adaptive.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# Test GMG with mesh deformation with adaptive mesh refinement
-#
-# This test is based on
-include $ASPECT_SOURCE_DIR/tests/function_mesh_deformation_tangential_mesh_velocity.prm
-
-set Dimension = 2
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
-
-subsection Mesh refinement
-  set Time steps between mesh refinement = 5
-end
diff --git a/tests/gmg_mesh_deform_adaptive_bug.prm.bak b/tests/gmg_mesh_deform_adaptive_bug.prm.bak
deleted file mode 100644
index 61bf6e56e08..00000000000
--- a/tests/gmg_mesh_deform_adaptive_bug.prm.bak
+++ /dev/null
@@ -1,25 +0,0 @@
-# Test GMG with mesh deformation with adaptive mesh refinement
-# MPI: 4
-#
-# This test fails with dealii::MGLevelGlobalTransfer Dimension 2 not equal to 0.
-
-
-# This test is based on
-include $ASPECT_SOURCE_DIR/tests/function_mesh_deformation_tangential_mesh_velocity.prm
-
-set Dimension = 2
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
-
-subsection Mesh refinement
-  set Time steps between mesh refinement = 5
-end
diff --git a/tests/gmg_mesh_deform_adaptive_bug2.prm.bak b/tests/gmg_mesh_deform_adaptive_bug2.prm.bak
deleted file mode 100644
index e4d449d3c57..00000000000
--- a/tests/gmg_mesh_deform_adaptive_bug2.prm.bak
+++ /dev/null
@@ -1,139 +0,0 @@
-# This test is a simplified 2d crustal extension problem with
-# a free surface an adaptive refinement. It would trigger a bug
-# with negative cell diagonals in the GMG preconditioner.
-
-set Dimension                                       = 2
-set Start time                                      = 0
-set End time                                        = 600000
-set Use years in output instead of seconds          = true
-set Nonlinear solver scheme                         = single Advection, iterated Stokes
-
-# This model is very sensitive to the nonlinear solver tolerance,
-# results still change slightly down to a tolerance of 1e-8, but
-# require much more resources than reasonable for a cookbook.
-set Nonlinear solver tolerance                      = 2e-6
-set Max nonlinear iterations                        = 100
-set CFL number                                      = 0.5
-set Output directory                                = output-crustal_model_2D
-set Timing output frequency                         = 1
-set Pressure normalization                          = no
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions  = 5
-    set X extent  = 80e3
-    set Y extent  = 16e3
-  end
-end
-
-# Advecting the free surface vertically rather than
-# in the surface normal direction can result in a
-# more stable mesh when the deformation is large
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-
-  subsection Free surface
-    set Surface velocity projection = vertical
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Densities = 2800
-    set Minimum viscosity = 1e22
-    set Maximum viscosity = 1e22
-    set Reference strain rate = 1e-20
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5e-22
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Angles of internal friction = 0.
-    set Cohesions                   = 20.e6
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left: function, right:function, bottom:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = cm=0.01, year=1
-    set Function expression =  if (x<40e3 , 1*cm/year, -1*cm/year) ; 0
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.95
-  set Strategy                           = strain rate
-  set Coarsening fraction                = 0.05
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics, material statistics, topography
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, error indicator, heating, partition
-    set Time between graphical output = 0
-    set Output mesh velocity = true
-  end
-
-  subsection Topography
-    set Output to file = false
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1e-6
-    set Number of cheap Stokes solver steps = 2000
-  end
-end
diff --git a/tests/gmg_mesh_deform_function.prm.bak b/tests/gmg_mesh_deform_function.prm.bak
deleted file mode 100644
index b1f4c4523ac..00000000000
--- a/tests/gmg_mesh_deform_function.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test GMG with mesh deformation prescribed by a changing function
-#
-# This test is a copy of
-include $ASPECT_SOURCE_DIR/tests/function_mesh_deformation_tangential_mesh_velocity.prm
-
-set Dimension = 2
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/tests/gmg_mesh_deform_ghost_entries.prm.bak b/tests/gmg_mesh_deform_ghost_entries.prm.bak
deleted file mode 100644
index d7af0deb1f2..00000000000
--- a/tests/gmg_mesh_deform_ghost_entries.prm.bak
+++ /dev/null
@@ -1,38 +0,0 @@
-# Based on viscoelastic free surface benchmark (with free surface
-# disabled) to show a bug, where we did not include the correct ghost
-# entries for the MappingQEulerian
-# MPI: 3
-
-include $ASPECT_SOURCE_DIR/benchmarks/free_surface_tractions/viscoelastic/free_surface_VE_cylinder_2D_loading.prm
-
-set Dimension                              = 2
-set End time = 10
-
-subsection Material model
-  set Model name = viscoelastic
-  set Material averaging = harmonic average only viscosity
-
-  subsection Viscoelastic
-    set Use fixed elastic time step = true
-    set Fixed elastic time step     = 1e2
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Mesh deformation
-  set Additional tangential mesh velocity boundary indicators = left,right
-  set Mesh deformation boundary indicators = top: boundary function
-
-  subsection Boundary function
-    set Variable names      = x,y,t
-    set Function expression = 0;  -3.168808781e-16*(x-1e5)
-  end
-end
diff --git a/tests/gmg_mesh_deform_prescribed.cc.bak b/tests/gmg_mesh_deform_prescribed.cc.bak
deleted file mode 100644
index a05d9059016..00000000000
--- a/tests/gmg_mesh_deform_prescribed.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "box_initial_mesh_deformation.cc"
diff --git a/tests/gmg_mesh_deform_prescribed.prm.bak b/tests/gmg_mesh_deform_prescribed.prm.bak
deleted file mode 100644
index 6b5f9a1c93f..00000000000
--- a/tests/gmg_mesh_deform_prescribed.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test GMG with mesh deformation prescribed by a prescribed function
-#
-# This test is a copy of
-include $ASPECT_SOURCE_DIR/tests/box_initial_mesh_deformation.prm
-
-set Dimension = 2
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/tests/gmg_mesh_deform_topo.prm.bak b/tests/gmg_mesh_deform_topo.prm.bak
deleted file mode 100644
index 2948e31282d..00000000000
--- a/tests/gmg_mesh_deform_topo.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# A modified 2d convection box with a prescribed, moving surface. The
-# oscillating sin wavee on the surface pushes the rising plume up and
-# down. This test was used to verify that matrix-based and matrix-free
-# give the same solution in a moving domain with mesh deformation.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.0024
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-  set Zero velocity boundary indicators       = left, right
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = top: boundary function
-
-  # The left and right boundary are allowed to move,
-  # even though the Stokes velocity is zero along these boundaries.
-  set Additional tangential mesh velocity boundary indicators = left,right
-
-  subsection Boundary function
-    set Variable names      = x,y,t
-    set Function expression = 0;  if (x<0.5, 1e+2*sin(x*2*3.14159)*cos(t/0.001), 0)
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e5   # = Ra
-  end
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization, topography
-
-  subsection Visualization
-    set Time between graphical output = 0.0001
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance                         = 1e-7
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 200
-  end
-end
diff --git a/tests/gmg_no_normal_flux_only.prm.bak b/tests/gmg_no_normal_flux_only.prm.bak
deleted file mode 100644
index fd862c3bd09..00000000000
--- a/tests/gmg_no_normal_flux_only.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# 3d shell with GMG, tangential velocity boundary only
-# based on shell_3d_gmg.prm
-# MPI: 2
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0.0
-set Output directory                       = output-shell_simple_3d
-set Nonlinear solver scheme                = no Advection, single Stokes
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average only viscosity
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1973
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.473e3
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 1
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1.5e6
-    set Output format                 = vtu
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 50
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1e-4
-  end
-end
diff --git a/tests/gmg_test_project_q1.prm.bak b/tests/gmg_test_project_q1.prm.bak
deleted file mode 100644
index 462c8aba92c..00000000000
--- a/tests/gmg_test_project_q1.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# test gmg + project to Q1 only viscosity
-set Dimension                              = 2
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-set Output directory                       = test
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 360
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3700
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Function
-    set Coordinate system   = spherical
-    set Variable names      = r, phi
-    set Function constants  = r0 = 3481000, r1 = 6371000
-    set Function expression = 30 * sin((r-r0)/(r1-r0)*pi)*sin(16*phi) + 20 * sin(2*(r-r0)/(r1-r0)*pi)*sin(12*phi)
-  end
-
-  subsection Adiabatic
-    set Age top boundary layer = 7e7
-    set Age bottom boundary layer = 1e8
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-  set Material averaging = project to Q1 only viscosity
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names              = pyr-ringwood88.txt
-    set Radial viscosity file name       = radial-visc-simple.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Use lateral average temperature for viscosity  = false
-    set Maximum viscosity                = 1.5e23
-    set Minimum viscosity                = 5e19
-    set Maximum lateral viscosity variation = 1e4
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set GMRES solver restart length = 200
-    set Number of cheap Stokes solver steps = 500
-  end
-
-  subsection Matrix Free
-    set Output details = true
-  end
-end
diff --git a/tests/gmg_velocity_boundary_2d_box_no_flux.prm.bak b/tests/gmg_velocity_boundary_2d_box_no_flux.prm.bak
deleted file mode 100644
index 00c197b51e0..00000000000
--- a/tests/gmg_velocity_boundary_2d_box_no_flux.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-set Dimension = 2
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 0
-set Output directory = output
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 273
-set Nonlinear solver scheme = single Advection, single Stokes
-set CFL number = 0.3
-set Timing output frequency = 1
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 6.7830e+06
-    set Y extent = 2.8900e6
-    set X repetitions = 2
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 1
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1, 3
-  set Zero velocity boundary indicators = 0, 2
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = bottom: 1673, top: 273
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0
-    set Heat capacities = 750.
-    set Densities = 3150
-    set Thermal expansivities = 0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = 1e-21
-    set Activation energies for diffusion creep = 0
-    set Activation volumes for diffusion creep = 0
-    set Grain size exponents for diffusion creep = 0
-    set Angles of internal friction = 0
-    set Cohesions = 1e15
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/gmg_velocity_boundary_2d_box_no_normal_flux.prm.bak b/tests/gmg_velocity_boundary_2d_box_no_normal_flux.prm.bak
deleted file mode 100644
index 67f988d104e..00000000000
--- a/tests/gmg_velocity_boundary_2d_box_no_normal_flux.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-set Dimension = 2
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 0
-set Output directory = output
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 273
-set Nonlinear solver scheme = single Advection, single Stokes
-set CFL number = 0.3
-set Timing output frequency = 1
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 6.7830e+06
-    set Y extent = 2.8900e6
-    set X repetitions = 2
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 1
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = bottom: 1673, top: 273
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0
-    set Heat capacities = 750.
-    set Densities = 3150
-    set Thermal expansivities = 0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = 1e-21
-    set Activation energies for diffusion creep = 0
-    set Activation volumes for diffusion creep = 0
-    set Grain size exponents for diffusion creep = 0
-    set Angles of internal friction = 0
-    set Cohesions = 1e15
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/gmg_velocity_boundary_2d_chunk_no_flux.prm.bak b/tests/gmg_velocity_boundary_2d_chunk_no_flux.prm.bak
deleted file mode 100644
index 9bbb4c8e048..00000000000
--- a/tests/gmg_velocity_boundary_2d_chunk_no_flux.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-set Dimension = 2
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 0
-set Output directory = output
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 273
-set Nonlinear solver scheme = single Advection, single Stokes
-set CFL number = 0.3
-set Timing output frequency = 1
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3.481e6
-    set Chunk outer radius = 6.371e6
-    set Chunk maximum longitude = 61.0
-    set Chunk minimum longitude = 0.0
-    set Longitude repetitions = 2
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 1
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1, 3
-  set Zero velocity boundary indicators = 0, 2
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1673
-    set Outer temperature = 273
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0
-    set Heat capacities = 750.
-    set Densities = 3150
-    set Thermal expansivities = 0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = 1e-21
-    set Activation energies for diffusion creep = 0
-    set Activation volumes for diffusion creep = 0
-    set Grain size exponents for diffusion creep = 0
-    set Angles of internal friction = 0
-    set Cohesions = 1e15
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/gmg_velocity_boundary_2d_chunk_no_normal_flux.prm.bak b/tests/gmg_velocity_boundary_2d_chunk_no_normal_flux.prm.bak
deleted file mode 100644
index edcee92ae6a..00000000000
--- a/tests/gmg_velocity_boundary_2d_chunk_no_normal_flux.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-set Dimension = 2
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 0
-set Output directory = output
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 273
-set Nonlinear solver scheme = single Advection, single Stokes
-set CFL number = 0.3
-set Timing output frequency = 1
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3.481e6
-    set Chunk outer radius = 6.371e6
-    set Chunk maximum longitude = 61.0
-    set Chunk minimum longitude = 0.0
-    set Longitude repetitions = 2
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 1
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1673
-    set Outer temperature = 273
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0
-    set Heat capacities = 750.
-    set Densities = 3150
-    set Thermal expansivities = 0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = 1e-21
-    set Activation energies for diffusion creep = 0
-    set Activation volumes for diffusion creep = 0
-    set Grain size exponents for diffusion creep = 0
-    set Angles of internal friction = 0
-    set Cohesions = 1e15
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/gmg_velocity_boundary_3d_box_no_flux.prm.bak b/tests/gmg_velocity_boundary_3d_box_no_flux.prm.bak
deleted file mode 100644
index 98af1d7b8f2..00000000000
--- a/tests/gmg_velocity_boundary_3d_box_no_flux.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-set Dimension = 3
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 0
-set Output directory = output
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 273
-set Nonlinear solver scheme = single Advection, single Stokes
-set CFL number = 0.3
-set Timing output frequency = 1
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 6.7830e+06
-    set Y extent = 2.8900e6
-    set Z extent = 1.5000e6
-    set X repetitions = 4
-    set Y repetitions = 2
-    set Z repetitions = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 1
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 4, 5
-  set Zero velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = bottom: 1673, top: 273
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0
-    set Heat capacities = 750.
-    set Densities = 3150
-    set Thermal expansivities = 0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = 1e-21
-    set Activation energies for diffusion creep = 0
-    set Activation volumes for diffusion creep = 0
-    set Grain size exponents for diffusion creep = 0
-    set Angles of internal friction = 0
-    set Cohesions = 1e15
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/gmg_velocity_boundary_3d_box_no_normal_flux.prm.bak b/tests/gmg_velocity_boundary_3d_box_no_normal_flux.prm.bak
deleted file mode 100644
index 7de9f17a45f..00000000000
--- a/tests/gmg_velocity_boundary_3d_box_no_normal_flux.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-set Dimension = 3
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 0
-set Output directory = output
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 273
-set Nonlinear solver scheme = single Advection, single Stokes
-set CFL number = 0.3
-set Timing output frequency = 1
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 6.7830e+06
-    set Y extent = 2.8900e6
-    set Z extent = 1.5000e6
-    set X repetitions = 4
-    set Y repetitions = 2
-    set Z repetitions = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 1
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3, 4, 5
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = constant
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = bottom: 1673, top: 273
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0
-    set Heat capacities = 750.
-    set Densities = 3150
-    set Thermal expansivities = 0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = 1e-21
-    set Activation energies for diffusion creep = 0
-    set Activation volumes for diffusion creep = 0
-    set Grain size exponents for diffusion creep = 0
-    set Angles of internal friction = 0
-    set Cohesions = 1e15
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/gmg_velocity_boundary_3d_chunk_no_flux.prm.bak b/tests/gmg_velocity_boundary_3d_chunk_no_flux.prm.bak
deleted file mode 100644
index 74459ad909a..00000000000
--- a/tests/gmg_velocity_boundary_3d_chunk_no_flux.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-set Dimension = 3
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 0
-set Output directory = output
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 273
-set Nonlinear solver scheme = single Advection, single Stokes
-set CFL number = 0.3
-set Timing output frequency = 1
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3.481e6
-    set Chunk outer radius = 6.371e6
-    set Chunk maximum longitude = 61.0
-    set Chunk minimum longitude = 0.0
-    set Chunk maximum latitude = 61.0
-    set Chunk minimum latitude = 0.0
-    set Longitude repetitions = 2
-    set Latitude repetitions = 2
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 1
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 4, 5
-  set Zero velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1673
-    set Outer temperature = 273
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0
-    set Heat capacities = 750.
-    set Densities = 3150
-    set Thermal expansivities = 0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = 1e-21
-    set Activation energies for diffusion creep = 0
-    set Activation volumes for diffusion creep = 0
-    set Grain size exponents for diffusion creep = 0
-    set Angles of internal friction = 0
-    set Cohesions = 1e15
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/gmg_velocity_boundary_3d_chunk_no_normal_flux.prm.bak b/tests/gmg_velocity_boundary_3d_chunk_no_normal_flux.prm.bak
deleted file mode 100644
index 8cd2a715f2d..00000000000
--- a/tests/gmg_velocity_boundary_3d_chunk_no_normal_flux.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-set Dimension = 3
-set Use years in output instead of seconds = true
-set Start time = 0
-set End time = 0
-set Output directory = output
-set Pressure normalization = surface
-set Surface pressure = 0
-set Adiabatic surface temperature = 273
-set Nonlinear solver scheme = single Advection, single Stokes
-set CFL number = 0.3
-set Timing output frequency = 1
-
-subsection Discretization
-  set Composition polynomial degree = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree = 2
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3.481e6
-    set Chunk outer radius = 6.371e6
-    set Chunk maximum longitude = 61.0
-    set Chunk minimum longitude = 0.0
-    set Chunk maximum latitude = 61.0
-    set Chunk minimum latitude = 0.0
-    set Longitude repetitions = 2
-    set Latitude repetitions = 2
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-  set Initial global refinement = 1
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3, 4, 5
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1673
-    set Outer temperature = 273
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-15
-    set Minimum viscosity = 1e21
-    set Maximum viscosity = 1e25
-    set Viscosity averaging scheme = harmonic
-    set Thermal diffusivities = 0
-    set Heat capacities = 750.
-    set Densities = 3150
-    set Thermal expansivities = 0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = 1e-21
-    set Activation energies for diffusion creep = 0
-    set Activation volumes for diffusion creep = 0
-    set Grain size exponents for diffusion creep = 0
-    set Angles of internal friction = 0
-    set Cohesions = 1e15
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/gmg_velocity_boundary_component.prm.bak b/tests/gmg_velocity_boundary_component.prm.bak
deleted file mode 100644
index 7d42918f5c4..00000000000
--- a/tests/gmg_velocity_boundary_component.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-# Test that GMG can deal with velocity boundary conditions of the form [xyz]:
-#
-# Test is identical to:
-include $ASPECT_SOURCE_DIR/tests/ascii_data_boundary_velocity_2d_box_list.prm
-
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: ascii data,right: ascii data, left x: function, right: function
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/tests/gplates_1_3.prm.bak b/tests/gplates_1_3.prm.bak
deleted file mode 100644
index 09fcd75ee16..00000000000
--- a/tests/gplates_1_3.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-# A simple setup for for using the GPlates interface in a 2d shell.
-# This test uses the grid produced by GPlates 1.3
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output
-set Adiabatic surface temperature          = 1600
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e22
-    set Thermal viscosity exponent    = 5.0
-    set Reference temperature         = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 1:gplates
-  set Tangential velocity boundary indicators = 0
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-    set Lithosphere thickness = 660000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/gplates_1_4.prm.bak b/tests/gplates_1_4.prm.bak
deleted file mode 100644
index 0158a7e15f9..00000000000
--- a/tests/gplates_1_4.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# A simple setup for for using the GPlates interface in a 2d shell.
-# This test uses the grid produced by GPlates 1.4.
-# The result is identical to the GPlates 1.3 test, which ensures
-# that the correction for the mesh changes between these versions
-# does work properly.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output
-set Adiabatic surface temperature          = 1600
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e22
-    set Thermal viscosity exponent    = 5.0
-    set Reference temperature         = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 1:gplates
-  set Tangential velocity boundary indicators = 0
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day_1.4.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-    set Lithosphere thickness = 660000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/gplates_3d.prm.bak b/tests/gplates_3d.prm.bak
deleted file mode 100644
index db1f8299282..00000000000
--- a/tests/gplates_3d.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# A simple setup for for using the GPlates interface in a 3d shell.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output
-set Adiabatic surface temperature          = 1600
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e22
-    set Thermal viscosity exponent    = 5.0
-    set Reference temperature         = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 1:gplates
-  set Tangential velocity boundary indicators = 0
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day_1.4.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-    set Lithosphere thickness = 660000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, velocity boundary statistics
-end
diff --git a/tests/gplates_rotation.prm.bak b/tests/gplates_rotation.prm.bak
deleted file mode 100644
index 98c8d6af4f2..00000000000
--- a/tests/gplates_rotation.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# A simple setup for for using the GPlates interface in a 2d shell.
-# This tests the rotation functionality of a 2D model.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output
-set Adiabatic surface temperature          = 1600
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e22
-    set Thermal viscosity exponent    = 5.0
-    set Reference temperature         = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 1:gplates
-  set Tangential velocity boundary indicators = 0
-
-  subsection GPlates model
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Point one = 1.0,1.87
-    set Point two = 2.0,5.24
-    set Lithosphere thickness = 660000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/gplates_scale_factor.prm.bak b/tests/gplates_scale_factor.prm.bak
deleted file mode 100644
index e9fbeca50af..00000000000
--- a/tests/gplates_scale_factor.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# A simple setup for for using the GPlates interface in a 2d shell.
-# This test is a copy of the gplates_1_4 test but uses a different
-# scaling factor to make sure that velocities are scaled correctly.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output
-set Adiabatic surface temperature          = 1600
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e22
-    set Thermal viscosity exponent    = 5.0
-    set Reference temperature         = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 1:gplates
-  set Tangential velocity boundary indicators = 0
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day_1.4.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-    set Lithosphere thickness = 660000
-    set Scale factor = 2
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/grain_lag_angle.prm.bak b/tests/grain_lag_angle.prm.bak
deleted file mode 100644
index 777c3ce69aa..00000000000
--- a/tests/grain_lag_angle.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# 2D model for half of a mid-ocean ridge
-# for testing the grain lag angle postprocessor
-# based on the mid-ocean ridge cookbook, with a few simplifications
-
-set Dimension = 2
-set End time = 5e5
-set Adiabatic surface temperature = 1570
-
-# geometry
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 105000
-    set Y extent  = 70000
-    set X repetitions  = 3
-    set Y repetitions  = 2
-  end
-end
-
-# gravity
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# boundary velocity
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function
-  set Tangential velocity boundary indicators = left
-
-  subsection Function
-    set Function constants  = u0=0.05, x0=10000, xc=52500
-    set Variable names  = x,z
-    set Function expression  = if(x<x0,(1-(x/x0-1)*(x/x0-1))*u0,u0); 0
-  end
-end
-
-# boundary traction
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Representative point  = 105000, 7000
-  end
-end
-
-# initial temperature
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer  = 1e8
-    set Age bottom boundary layer  = 1e5
-    set Amplitude      = 0
-  end
-end
-
-# boundary temperature
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 293
-    set Bottom temperature = 1570
-  end
-end
-
-# material
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 4.7
-    set Reference density = 3400
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity = 5e21
-    set Thermal viscosity exponent = 7
-    set Reference temperature = 1570
-  end
-end
-
-# mesh refinement
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# postprocessing
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables = grain lag angle
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/grain_size_additional_outputs.prm.bak b/tests/grain_size_additional_outputs.prm.bak
deleted file mode 100644
index 9dfa3a89581..00000000000
--- a/tests/grain_size_additional_outputs.prm.bak
+++ /dev/null
@@ -1,24 +0,0 @@
-# Like grain_size_growth.prm, but check that additional
-# material model outputs can be postprocessed correctly.
-
-############### Global parameters
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
-
-set End time = 0
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = named additional outputs
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/grain_size_averaging.prm.bak b/tests/grain_size_averaging.prm.bak
deleted file mode 100644
index 81ccaeb3b1c..00000000000
--- a/tests/grain_size_averaging.prm.bak
+++ /dev/null
@@ -1,16 +0,0 @@
-# A test for the grain size material model with the GMG
-# solver. We want to make sure no floating point exceptions
-# are thrown when material properties are averaged.
-
-include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
-
-
-subsection Material model
-  set Material averaging = geometric average only viscosity
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/tests/grain_size_crossed_transition.prm.bak b/tests/grain_size_crossed_transition.prm.bak
deleted file mode 100644
index 432e73f0346..00000000000
--- a/tests/grain_size_crossed_transition.prm.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-# A test for the grain size material model to see if the grain
-# size is reset correctly after crossing a phase transition.
-# The model contains a phase transition in the middle at 50 km depth
-# where the grain size is reset to 1 mm (from the initial value of
-# 2 mm). The vertical component of the velocity prescribed at the top
-# and bottom boundary is a sine wave, so that in the left half of
-# the model, grain size is reset above the transition, and in the
-# right half it is reset below the phase transition.
-
-set Dimension                              = 2
-set End time                               = 10000
-set Use years in output instead of seconds = true
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 300000
-    set Y extent = 100000
-    set X periodic = true
-    set X repetitions = 3
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top,bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 1600
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function, bottom:function
-
-  subsection Function
-    set Function expression = 0.1; sin(x/300000*2*pi)
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 0
-
-    subsection Function
-      set Function expression       = 0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  =
-    set Function expression = 2e-3
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-  set Compositional field methods = particles
-  set Types of fields = grain size
-  set Mapped particle properties = grain_size:grain_size
-end
-
-subsection Material model
-  set Model name = grain size
-  set Material averaging = none
-
-  subsection Grain size model
-    set Reference density                    = 3400
-    set Thermal conductivity                 = 0
-    set Thermal expansion coefficient        = 0
-    set Reference compressibility            = 0
-    set Viscosity                            = 1e19
-    set Minimum viscosity                    = 1e16
-    set Reference temperature                = 1600
-    set Grain growth activation energy       = 4e5, 4e5
-    set Grain growth activation volume       = 0, 0
-    set Grain growth rate constant           = 0, 0
-    set Grain growth exponent                = 3, 3
-    set Average specific grain boundary energy = 1, 1
-    set Work fraction for boundary area change = 0.1, 0.1
-    set Geometric constant                   = 3, 3
-    set Grain size evolution formulation     = paleowattmeter
-    set Reciprocal required strain           = 10
-    set Phase transition depths              = 50000
-    set Phase transition Clapeyron slopes    = 1e6
-    set Phase transition temperatures        = 1600
-    set Phase transition widths              = 0
-    set Recrystallized grain size            = 1e-3
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 3.0e-016, 3.0e-016 # s^-1 Pa^-1 m^p
-    set Diffusion creep exponent             = 1, 1 # 1 for diffusion creep
-    set Diffusion creep grain size exponent  = 3, 3
-    set Diffusion activation energy          = 3.75e5, 3.75e5 #J/mol
-    set Diffusion activation volume          = 0, 0 # m^3/mol (from Karato 2010)
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # No dislocation creep
-    set Dislocation creep prefactor          = 1e-200, 1e-200 # s^-1 Pa^-n
-    set Dislocation creep exponent           = 1, 1
-    set Dislocation activation energy        = 0, 0 # J/mol
-    set Dislocation activation volume        = 0, 0 # m^3/mol
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Variable names = depth, nothing
-    set Function expression = if(depth>40000 && depth <60000, 4, 2)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, particles
-
-  subsection Visualization
-    set List of output variables  = material properties
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Time between data output = 0
-  end
-end
-
-subsection Particles
-  set List of particle properties = grain size
-  set Particle generator name = probability density function
-
-  subsection Generator
-    subsection Probability density function
-      set Function expression = sin(y/100000*pi)
-      set Number of particles = 10000
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type =  block AMG
-  end
-end
diff --git a/tests/grain_size_friction_heating.prm.bak b/tests/grain_size_friction_heating.prm.bak
deleted file mode 100644
index f33a22c9e31..00000000000
--- a/tests/grain_size_friction_heating.prm.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-# A test for the grain size material model similar to
-# grain_size_strain.prm. The only difference is the activation of shear
-# heating. In the grain size model, a fraction of the energy dissipated by
-# dislocation creep increases the surface area of grains.
-
-set Dimension                              = 2
-set End time                               = 10000
-set Use years in output instead of seconds = true
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-    set X periodic    = true
-  end
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top,bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 1400
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function,bottom:function
-
-  subsection Function
-    set Function expression = 1.0*(y/100000);0
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 0
-
-    subsection Function
-      set Function expression       = 0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  =
-    set Function expression = if(z<50000,1e-3,1.0000001e-3)
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-end
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                = 3400
-    set Thermal conductivity             = 0
-    set Thermal expansion coefficient    = 0
-    set Reference compressibility        = 0
-    set Viscosity                        = 1e18
-    set Minimum viscosity                = 1e16
-    set Reference temperature            = 1600
-    set Recrystallized grain size        =
-    set Grain growth activation energy       = 4e5
-    set Grain growth activation volume       = 0.0
-    set Grain growth rate constant           = 1.92E-010
-    set Grain growth exponent                = 3
-    set Average specific grain boundary energy = 1.0
-    set Work fraction for boundary area change = 0.1
-    set Geometric constant                   = 3
-    set Grain size evolution formulation     = paleowattmeter
-    set Reciprocal required strain                  = 10
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 3.0e-015 # s^-1 Pa^-1 m^p
-    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 3.75e5 #J/mol
-    set Diffusion activation volume          = 6e-6 # m^3/mol (from Karato 2010)
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # Kawazoe et al. (2009)
-    # Dislocation creep
-    set Dislocation creep prefactor          = 1.244507e-15 # s^-1 Pa^-n
-    set Dislocation creep exponent           = 3.5
-    set Dislocation activation energy        = 530000 # J/mol
-    set Dislocation activation volume        = 1.40E-005 # m^3/mol
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, heating statistics
-end
diff --git a/tests/grain_size_growth.prm.bak b/tests/grain_size_growth.prm.bak
deleted file mode 100644
index fc49ee5b3ff..00000000000
--- a/tests/grain_size_growth.prm.bak
+++ /dev/null
@@ -1,159 +0,0 @@
-# This is a very simple test case that checks
-# that the implementation of the grain growth
-# laws are correct. All parameters, including
-# temperature and pressure, are set to constant
-# values and no dynamic recrystallization is
-# included (the reciprocal required strain is
-# set to zero). Material flows in from the left
-# and flows out at the right boundary with a constant
-# velocity. The grain size
-# should then only depend on the x coordinate
-# following the relation
-#
-# d(x) = (d_0^p + A * x)^(1/p)
-#
-# with
-# d_0 = 8e-5 m              (initial grain size)
-# p   = 10                  (grain size exponent)
-# A   = 2.0294e-46 m^(p-1)  (grain growth rate constant * exp(-E/(RT)) / velocity)
-#
-# leading to a grain size of d=8.8957E-5 m at the
-# right boundary of the model if the end time is extended
-# to at least 1 Myr (the time it takes material to reach
-# the right model boundary).
-
-############### Global parameters
-
-set Dimension                              = 2
-set End time                               = 50000
-set Use years in output instead of seconds = true
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top,bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 1400
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = left
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom,top
-  set Prescribed velocity boundary indicators = left:function,right:function
-
-  subsection Function
-    set Function expression = 0.1;0
-  end
-end
-
-# Warning: Merge the parameter in the following subsection with any
-# other parameter of the same name, otherwise your model results might change
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 0
-
-    subsection Function
-      set Function expression       = 0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  =
-    set Function expression = if(z<50000,8e-5,8.00001e-5)
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-end
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                = 3400
-    set Thermal conductivity             = 0
-    set Thermal expansion coefficient    = 0
-    set Reference compressibility        = 0
-    set Viscosity                        = 1e18
-    set Reference temperature            = 1600
-    set Recrystallized grain size        =
-    set Grain growth activation energy       = 3e5
-    set Grain growth activation volume       = 0.0
-    set Grain growth rate constant           = 4E-045
-    set Grain growth exponent                = 10
-    set Grain size evolution formulation     = paleowattmeter
-    set Reciprocal required strain           = 0
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 1.5e-024 # s^-1 Pa^-1 m^p
-    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 3e5 #J/mol
-    set Diffusion activation volume          = 2e-6 # m^3/mol (from Karato 2010)
-
-    # Kawazoe et al. (2009)
-    # Dislocation creep
-    set Dislocation creep prefactor          = 1.1E-016 # s^-1 Pa^-n
-    set Dislocation creep exponent           = 3.5
-    set Dislocation activation energy        = 530000 # J/mol
-    set Dislocation activation volume        = 1.40E-005 # m^3/mol
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, ODE statistics
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-7
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/grain_size_growth_one_cell.prm.bak b/tests/grain_size_growth_one_cell.prm.bak
deleted file mode 100644
index 831d1421eb9..00000000000
--- a/tests/grain_size_growth_one_cell.prm.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-# This is a very simple test case that checks
-# that the implementation of the grain growth
-# laws are correct. All parameters, including
-# temperature and pressure, are set to constant
-# values and no dynamic recrystallization is
-# included (the reciprocal required strain is
-# set to zero). The grain size should only
-# depend on time following the relation
-#
-# d(x) = (d_0^p + A * t)^(1/p)
-#
-# with
-# d_0 = 8e-5 m              (initial grain size)
-# p   = 10                  (grain size exponent)
-# A   = 2.0294e-45 m^(p-1)  (grain growth rate constant * exp(-E/(RT)))
-#
-# leading to a grain size of d=8.8957E-5 m at the
-# right boundary of the model at the end time of
-# 1 Myr.
-
-# This test is similar to grain size growth, but
-# computes the grain growth in just one mesh cell
-# rather than advecting the growing grains from
-# left to right.
-
-############### Global parameters
-
-set Dimension                              = 2
-set End time                               = 1e6
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top,bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 1400
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   =
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 0
-
-    subsection Function
-      set Function expression       = 0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  =
-    set Function expression = 8e-5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-end
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                = 3400
-    set Thermal conductivity             = 0
-    set Thermal expansion coefficient    = 0
-    set Reference compressibility        = 0
-    set Viscosity                        = 1e18
-    set Reference temperature            = 1600
-    set Recrystallized grain size        =
-    set Grain growth activation energy       = 3e5
-    set Grain growth activation volume       = 0.0
-    set Grain growth rate constant           = 4E-045
-    set Grain growth exponent                = 10
-    set Grain size evolution formulation     = paleowattmeter
-    set Reciprocal required strain           = 0
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 1.5e-024 # s^-1 Pa^-1 m^p
-    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 3e5 #J/mol
-    set Diffusion activation volume          = 2e-6 # m^3/mol (from Karato 2010)
-
-    # Kawazoe et al. (2009)
-    # Dislocation creep
-    set Dislocation creep prefactor          = 1.1E-016 # s^-1 Pa^-n
-    set Dislocation creep exponent           = 3.5
-    set Dislocation activation energy        = 530000 # J/mol
-    set Dislocation activation volume        = 1.40E-005 # m^3/mol
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, ODE statistics
-end
diff --git a/tests/grain_size_growth_one_cell_particles.prm.bak b/tests/grain_size_growth_one_cell_particles.prm.bak
deleted file mode 100644
index f0a496715ce..00000000000
--- a/tests/grain_size_growth_one_cell_particles.prm.bak
+++ /dev/null
@@ -1,43 +0,0 @@
-# Like grain size growth one cell, but with particles.
-
-include $ASPECT_SOURCE_DIR/tests/grain_size_growth_one_cell.prm
-
-
-############### Global parameters
-
-set Dimension                              = 2
-set End time                               = 1e6
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-  set Compositional field methods = particles
-  set Mapped particle properties = grain_size:grain_size
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, velocity statistics, particles, ODE statistics
-
-  subsection Particles
-    set Time between data output = 1e6
-  end
-end
-
-# We use particles to advect the grain size.
-subsection Particles
-  set Interpolation scheme = cell average
-  set List of particle properties = grain size
-  set Load balancing strategy = none
-  set Integration scheme = rk2
-  set Update ghost particles = true
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 50000
-    end
-  end
-end
diff --git a/tests/grain_size_growth_particles.prm.bak b/tests/grain_size_growth_particles.prm.bak
deleted file mode 100644
index 5a43e8a6d79..00000000000
--- a/tests/grain_size_growth_particles.prm.bak
+++ /dev/null
@@ -1,49 +0,0 @@
-# This is a very simple test case that checks
-# that the implementation of the grain growth
-# laws are correct. All parameters, including
-# temperature and pressure, are set to constant
-# values and no dynamic recrystallization is
-# included (the reciprocal required strain is
-# set to zero). Material flows in from the left
-# and flows out at the right boundary with a constant
-# velocity. The grain size
-# should then only depend on the x coordinate
-# following the relation
-#
-# d(x) = (d_0 + A * x)^(1/p)
-#
-# with
-# d_0 = 8e-5 m         (initial grain size)
-# p   = 10             (grain size exponent)
-# A   = 2.0294e-46 1/m
-#
-# leading to a grain size of d=8.8957E-5 m at the
-# right boundary of the model.
-
-############### Global parameters
-
-set Dimension                              = 2
-set End time                               = 50000
-
-include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
-
-
-subsection Postprocess
-  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = gnuplot
-  end
-end
-
-subsection Particles
-  set List of particle properties = grain size
-  set Integration scheme = rk2
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/grain_size_growth_pinned.prm.bak b/tests/grain_size_growth_pinned.prm.bak
deleted file mode 100644
index 67fc6740293..00000000000
--- a/tests/grain_size_growth_pinned.prm.bak
+++ /dev/null
@@ -1,34 +0,0 @@
-# This is a very simple test case that checks
-# that the implementation of the grain growth
-# laws with the pinned grain damage formulation
-# (Mulyukova and Bercovici (2018) are correct.
-# All parameters, including temperature and pressure
-# are set to constant values.
-# Material flows in from the left
-# and flows out at the right boundary with a constant
-# velocity. The grain size
-# should then only depend on the x coordinate
-# following the relation
-#
-# d(x) = (d_0^p + A * x)^(1/p)
-#
-# with
-# d_0 = 8e-5 m                 (initial grain size)
-# p   = 10                     (grain size exponent)
-# A   = 1.334585e-44 1/m^(p-1) (grain growth rate constant * exp(-E/(RT)) / velocity)
-#
-# which means we expect a grain size of 1.296828e-4 m at x = 1e5 m.
-#
-# If this test runs for 2e6 it produces a grain size of
-# 1.29087e-04 m at x = 1e5 m, which is close enough.
-
-include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
-
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Grain size evolution formulation  = pinned grain damage
-  end
-end
diff --git a/tests/grain_size_latent_heat.cc.bak b/tests/grain_size_latent_heat.cc.bak
deleted file mode 100644
index 8f972b15a8b..00000000000
--- a/tests/grain_size_latent_heat.cc.bak
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
-  Copyright (C) 2014 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/grain_size.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/gravity_model/interface.h>
-
-#include <deal.II/base/parameter_handler.h>
-
-#include <iostream>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * A material model that consists of globally constant values for all
-     * material parameters except that the density decays linearly with the
-     * temperature and the viscosity, which depends on the temperature,
-     * pressure, strain rate and grain size.
-     *
-     * The grain size evolves in time, dependent on strain rate, temperature,
-     * creep regime, and phase transitions.
-     *
-     * The model is considered compressible.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class GrainSizeLatentHeat : public MaterialModel::GrainSize<dim>
-    {
-      public:
-        virtual bool is_compressible () const override
-        {
-          return false;
-        }
-
-        virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                              typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const override
-        {
-          double dHdT = 0.0;
-          double dHdp = 0.0;
-
-          if (in.current_cell.state() == IteratorState::valid)
-            {
-              const QTrapezoid<dim> quadrature_formula;
-              const unsigned int n_q_points = quadrature_formula.size();
-
-              FEValues<dim> fe_values (this->get_mapping(),
-                                       this->get_fe(),
-                                       quadrature_formula,
-                                       update_values);
-
-              std::vector<double> temperatures(n_q_points), pressures(n_q_points);
-              std::vector<std::vector<double>> compositions (quadrature_formula.size(),std::vector<double> (this->n_compositional_fields()));
-              std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-
-              fe_values.reinit (in.current_cell);
-
-              // get the various components of the solution, then
-              // evaluate the material properties there
-              fe_values[this->introspection().extractors.temperature]
-              .get_function_values (this->get_solution(), temperatures);
-              fe_values[this->introspection().extractors.pressure]
-              .get_function_values (this->get_solution(), pressures);
-
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                fe_values[this->introspection().extractors.compositional_fields[c]]
-                .get_function_values(this->get_solution(),
-                                     composition_values[c]);
-              for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
-                {
-                  for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                    compositions[q][c] = composition_values[c][q];
-                }
-
-              unsigned int T_points(0),p_points(0);
-
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  const double own_enthalpy = this->material_lookup[0]->enthalpy(temperatures[q],pressures[q]);
-                  for (unsigned int p=0; p<n_q_points; ++p)
-                    {
-                      double enthalpy_p,enthalpy_T;
-                      if (std::fabs(temperatures[q] - temperatures[p]) > 1e-12 * temperatures[q])
-                        {
-                          enthalpy_p = this->material_lookup[0]->enthalpy(temperatures[p],pressures[q]);
-                          const double point_contribution = (own_enthalpy-enthalpy_p)/(temperatures[q]-temperatures[p]);
-                          dHdT += point_contribution;
-                          T_points++;
-                        }
-                      if (std::fabs(pressures[q] - pressures[p]) > 1)
-                        {
-                          enthalpy_T = this->material_lookup[0]->enthalpy(temperatures[q],pressures[p]);
-                          dHdp += (own_enthalpy-enthalpy_T)/(pressures[q]-pressures[p]);
-                          p_points++;
-                        }
-                    }
-                }
-
-              if ((T_points > 0)
-                  && (p_points > 0))
-                {
-                  dHdT /= T_points;
-                  dHdp /= p_points;
-                }
-            }
-
-          std::vector<double> adiabatic_pressures (in.n_evaluation_points());
-          std::vector<unsigned int> phase_indices (in.n_evaluation_points());
-
-          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-            {
-              std::vector<double> composition (in.composition[i]);
-              for (unsigned int c=0; c<composition.size(); ++c)
-                composition[c] = std::max(this->min_grain_size,composition[c]);
-
-              const double gravity_norm = this->get_gravity_model().gravity_vector(in.position[i]).norm();
-
-              out.densities[i] = this->density(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
-
-              // We do not fill the phase function index, because that will be done internally in the get_phase_index() function
-              adiabatic_pressures[i] = this->get_adiabatic_conditions().is_initialized()
-                                       ?
-                                       this->get_adiabatic_conditions().pressure(in.position[i])
-                                       :
-                                       in.pressure[i];
-              const double depth = this->get_geometry_model().depth(in.position[i]);
-              const double rho_g = out.densities[i] * gravity_norm;
-              MaterialUtilities::PhaseFunctionInputs<dim> phase_inputs(in.temperature[i], adiabatic_pressures[i], depth, rho_g, numbers::invalid_unsigned_int);
-              phase_indices[i] = this->get_phase_index(phase_inputs);
-
-              if (in.requests_property(MaterialProperties::viscosity))
-                {
-                  double effective_viscosity;
-                  double disl_viscosity = std::numeric_limits<double>::max();
-                  Assert(std::isfinite(in.strain_rate[i].norm()),
-                         ExcMessage("Invalid strain_rate in the MaterialModelInputs. This is likely because it was "
-                                    "not filled by the caller."));
-                  const SymmetricTensor<2,dim> shear_strain_rate = in.strain_rate[i] - 1./dim * trace(in.strain_rate[i]) * unit_symmetric_tensor<dim>();
-                  const double second_strain_rate_invariant = std::sqrt(std::max(-second_invariant(shear_strain_rate), 0.));
-
-                  const double adiabatic_temperature = this->get_adiabatic_conditions().is_initialized()
-                                                       ?
-                                                       this->get_adiabatic_conditions().temperature(in.position[i])
-                                                       :
-                                                       in.temperature[i];
-
-                  const unsigned int grain_size_index = this->introspection().compositional_index_for_name("grain_size");
-
-                  const double diff_viscosity = this->diffusion_viscosity(in.temperature[i],
-                                                                          adiabatic_temperature,
-                                                                          adiabatic_pressures[i],
-                                                                          composition[grain_size_index],
-                                                                          second_strain_rate_invariant,
-                                                                          phase_indices[i]);
-
-                  if (std::abs(second_strain_rate_invariant) > 1e-30)
-                    {
-                      disl_viscosity = this->dislocation_viscosity(in.temperature[i], adiabatic_temperature, adiabatic_pressures[i], in.strain_rate[i], phase_indices[i], diff_viscosity);
-                      effective_viscosity = disl_viscosity * diff_viscosity / (disl_viscosity + diff_viscosity);
-                    }
-                  else
-                    effective_viscosity = diff_viscosity;
-
-                  out.viscosities[i] = std::min(std::max(this->min_eta,effective_viscosity),this->max_eta);
-                }
-
-              if (this->get_adiabatic_conditions().is_initialized())
-                {
-                  if ((in.current_cell.state() == IteratorState::valid)
-                      && (std::fabs(dHdp) > std::numeric_limits<double>::epsilon())
-                      && (std::fabs(dHdT) > std::numeric_limits<double>::epsilon()))
-                    {
-                      out.thermal_expansion_coefficients[i] = (1 - 3515.6 * dHdp) / in.temperature[i];
-                      out.specific_heat[i] = dHdT;
-                    }
-                  else
-                    {
-                      out.thermal_expansion_coefficients[i] = this->thermal_expansion_coefficient(in.temperature[i], in.pressure[i], in.composition[i], in.position[i]);
-                      out.specific_heat[i] = this->specific_heat(in.temperature[i], in.pressure[i], composition, in.position[i]);
-                    }
-                }
-              else
-                {
-                  out.thermal_expansion_coefficients[i] = (1 - 3515.6 * this->material_lookup[0]->dHdp(in.temperature[i],in.pressure[i])) / in.temperature[i];
-                  out.specific_heat[i] = this->material_lookup[0]->dHdT(in.temperature[i],in.pressure[i]);
-                }
-
-              out.thermal_conductivities[i] = this->k_value;
-              out.compressibilities[i] = this->compressibility(in.temperature[i], in.pressure[i], composition, in.position[i]);
-            }
-          if (in.requests_property(MaterialProperties::reaction_terms))
-            out.reaction_terms = this->grain_size_change(in, adiabatic_pressures, phase_indices);
-        }
-    };
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(GrainSizeLatentHeat,
-                                   "grain size latent heat",
-                                   "A material model that behaves in the same way as "
-                                   "the grain size model, but is modified to "
-                                   "resemble the latent heat benchmark. Due to the "
-                                   "nature of the benchmark the model needs to be "
-                                   "incompressible despite a material table and "
-                                   "use a constant density for the calculation of "
-                                   "the latent heat.")
-  }
-}
diff --git a/tests/grain_size_latent_heat.prm.bak b/tests/grain_size_latent_heat.prm.bak
deleted file mode 100644
index 947168e0ad7..00000000000
--- a/tests/grain_size_latent_heat.prm.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-# This is a model setup to test latent heat generation.
-# It is identical to the latent_heat_enthalpy test, but utilizes
-# the grain size material model to ensure a correct
-# implementation of the functionality. For details on the
-# test see the latent_heat_enthalpy test case.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 1e15
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature          = 1000
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 50000
-    set Y extent = 1000000
-    set Y repetitions = 20
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  =
-    set Function expression = 8e-5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-end
-
-# Warning: Merge the parameter in the following subsection with any
-# other parameter of the same name, otherwise your model results might change
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Function expression = 0;-2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0 + (y-1000000)/1000000
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = grain size latent heat
-
-  subsection Grain size model
-    set Reference density                = 3400
-    set Thermal conductivity             = 2.38
-    set Thermal expansion coefficient    = 0
-    set Minimum thermal expansivity      = 0
-    set Reference compressibility        = 0
-    set Viscosity                        = 8.44e21
-    set Minimum viscosity                = 8.44e21
-    set Maximum viscosity                = 8.44e21
-    set Reference temperature            = 1000
-    set Grain growth rate constant       = 0
-    set Recrystallized grain size        =
-    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/latent-heat-enthalpy-test/
-    set Material file names = testdata.txt
-    set Material file format = perplex
-    set Use table properties = true
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, composition statistics
-end
diff --git a/tests/grain_size_phase_function.prm.bak b/tests/grain_size_phase_function.prm.bak
deleted file mode 100644
index f3c5c4ff500..00000000000
--- a/tests/grain_size_phase_function.prm.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-# A test for the grain size material model to see if the
-# phase transitions work correctly. The test has three phase
-# transitions with different Clapeyron slopes that affect
-# the viscosity and the grain size growth.
-
-set Dimension                              = 2
-set End time                               = 10000
-set Use years in output instead of seconds = true
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top,bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 1600
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1400 + 0.004 * x
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  =
-    set Function expression = 1e-3
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-  set Compositional field methods = particles
-  set Types of fields = grain size
-  set Mapped particle properties = grain_size:grain_size
-end
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                    = 1000
-    set Thermal conductivity                 = 0
-    set Thermal expansion coefficient        = 0
-    set Reference compressibility            = 0
-    set Viscosity                            = 1e19
-    set Minimum viscosity                    = 1e16
-    set Reference temperature                = 1600
-    set Grain growth activation energy       = 0, 0, 0, 0
-    set Grain growth activation volume       = 0, 0, 0, 0
-    set Grain growth rate constant           = 0, 1e-20, 0, 5e-21
-    set Grain growth exponent                = 3, 3, 3, 3
-    set Average specific grain boundary energy = 1, 1, 1, 1
-    set Work fraction for boundary area change = 0.1, 0.1, 0.1, 0.1
-    set Geometric constant                   = 3, 3, 3, 3
-    set Grain size evolution formulation     = paleowattmeter
-    set Reciprocal required strain           = 10
-    set Phase transition depths              = background:20000|50000|65000
-    set Phase transition Clapeyron slopes    = background:1e6|-5e5|2.5e5
-    set Phase transition temperatures        = background:1600|1600|1600
-    set Phase transition widths              = background:0|0|0
-    set Recrystallized grain size            = 1e-3, 1e-3, 1e-3
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 3.0e-016, 3.0e-015, 3.0e-017, 3.0e-016
-    set Diffusion creep exponent             = 1, 1, 1, 1
-    set Diffusion creep grain size exponent  = 3, 3, 3, 3
-    set Diffusion activation energy          = 3.75e5, 3.75e5, 3.75e5, 3.75e5
-    set Diffusion activation volume          = 0, 0, 0, 0
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # No dislocation creep
-    set Dislocation creep prefactor          = 1e-200, 1e-200, 1e-200, 1e-200
-    set Dislocation creep exponent           = 1, 1, 1, 1
-    set Dislocation activation energy        = 0, 0, 0, 0
-    set Dislocation activation volume        = 0, 0, 0, 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, particles, material statistics, ODE statistics
-
-  subsection Visualization
-    set List of output variables  = material properties
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Time between data output = 0
-  end
-end
-
-subsection Particles
-  set List of particle properties = grain size
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10000
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set GMRES solver restart length = 200
-  end
-end
diff --git a/tests/grain_size_plunge.prm.bak b/tests/grain_size_plunge.prm.bak
deleted file mode 100644
index fc16242f83d..00000000000
--- a/tests/grain_size_plunge.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-# A test for the grain size material model using the pinned state damage formulation.
-# This test is like grain_size_strain_pinned_state, but uses the parameters
-# from Mulyukova and Bercovici (2018) at constant
-# temperature and stress in their figure 4 to reproduce a grain size plunge.
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/grain_size_pinned_state/grain_size_plunge.prm
-
-set End time                               = 1e2
diff --git a/tests/grain_size_ridge.prm.bak b/tests/grain_size_ridge.prm.bak
deleted file mode 100644
index 6ce36974883..00000000000
--- a/tests/grain_size_ridge.prm.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-# This is a test for the grain_size_ridge cookbook.
-# We loosen the solver tolerance to make it run faster.
-
-include $ASPECT_SOURCE_DIR/cookbooks/grain_size_ridge/grain_size_ridge.prm
-
-set End time                    = 500
-set Nonlinear solver tolerance  = 1e-4
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 5e-5
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 4
-  set Initial adaptive refinement = 0
-  set Minimum refinement level = 4
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics, mass flux statistics, particles, ODE statistics
-end
diff --git a/tests/grain_size_ridge_traction.prm.bak b/tests/grain_size_ridge_traction.prm.bak
deleted file mode 100644
index e8be1f3aa27..00000000000
--- a/tests/grain_size_ridge_traction.prm.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-# This is a test for the grain size evolutionn in a realistic
-# model setup, in this case, the grain_size_ridge cookbook.
-# However, we prescribe the traction rather than the velocity
-# at the boundaries. This way, we can make sure our boundary
-# conditions do not introduce any artificially high grain size
-# reduction.
-
-include $ASPECT_SOURCE_DIR/cookbooks/grain_size_ridge/grain_size_ridge.prm
-
-set End time                    = 100
-set Maximum time step           = 50
-
-# Refine the mesh within the lithosphere.
-subsection Mesh refinement
-  set Initial global refinement = 5
-  set Initial adaptive refinement = 0
-  set Minimum refinement level = 5
-  set Time steps between mesh refinement = 0
-end
-
-# Make the model domain smaller so we can resolve the
-# lithosphere well even in a small test case.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 410000
-    set Y extent  = 200000
-    set X repetitions = 2
-    set Y repetitions = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, top
-  set Prescribed velocity boundary indicators = bottom x: function, right y:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0; 0
-  end
-end
-
-# Prescribe traction instead of velocity to avoid sigularity
-# in the top left corner.
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right x:initial lithostatic pressure, bottom y:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Representative point         = 60000, 0
-    set Number of integration points = 10000
-  end
-end
-
-# Larger conductivity to make up for the smaller model domain.
-# Fast grain size change.
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-
-  subsection Grain size model
-    set Thermal conductivity  = 20
-    set Maximum viscosity     = 1e23
-    set Work fraction for boundary area change = 0.5
-  end
-end
-
-# Leave a gap of low viscosity in the corner to make the problem
-# more well-posed.
-subsection Initial temperature model
-  set List of model names = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer   = 0.0
-    set Top boundary layer age model = function
-
-    subsection Age function
-      set Function expression = max((x-10000) / 0.05, 0)
-    end
-  end
-end
-
-# Make the initial grain size constant everywhere.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 5e-3
-    set Variable names      = x,y
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, velocity statistics, mass flux statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = gnuplot
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell = 5
-  set Maximum particles per cell = 80
-  set Particle generator name = probability density function
-
-  subsection Generator
-    subsection Probability density function
-      set Function expression = 20000*20000+y*y
-      set Number of particles = 20000
-    end
-  end
-end
diff --git a/tests/grain_size_strain.prm.bak b/tests/grain_size_strain.prm.bak
deleted file mode 100644
index 81a61961b4a..00000000000
--- a/tests/grain_size_strain.prm.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-# A test for the grain size material model. The test imposes simple shear
-# across a 100 km square domain with a rheology derived from experiments on
-# olivine. The model domain is isobaric and initially isothermal.
-# Over time the model maintains nearly constant temperatures, pressures and
-# strain rates. The grain size in the test approaches the equilibrium
-# grain size for t -> infinity. At 4 Myr the grain size is
-# 9.35850647e-04 m, which is close to the equilibrium value.
-
-set Dimension                              = 2
-set End time                               = 5000
-set Use years in output instead of seconds = true
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-    set X periodic    = true
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top,bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 1400
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function,bottom:function
-
-  subsection Function
-    set Function expression = 1.0*(y/100000);0
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 0
-
-    subsection Function
-      set Function expression       = 0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  =
-    set Function expression = if(z<50000,1e-3,1.0000001e-3)
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-end
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                = 3400
-    set Thermal conductivity             = 0
-    set Thermal expansion coefficient    = 0
-    set Reference compressibility        = 0
-    set Viscosity                        = 1e18
-    set Minimum viscosity                = 1e16
-    set Reference temperature            = 1600
-    set Recrystallized grain size        =
-    set Grain growth activation energy       = 4e5
-    set Grain growth activation volume       = 0.0
-    set Grain growth rate constant           = 1.92E-010
-    set Grain growth exponent                = 3
-    set Average specific grain boundary energy = 1.0
-    set Work fraction for boundary area change = 0.1
-    set Geometric constant                   = 3
-    set Grain size evolution formulation     = paleowattmeter
-    set Reciprocal required strain                  = 10
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 3.0e-015 # s^-1 Pa^-1 m^p
-    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 3.75e5 #J/mol
-    set Diffusion activation volume          = 6e-6 # m^3/mol (from Karato 2010)
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # Kawazoe et al. (2009)
-    # Dislocation creep
-    set Dislocation creep prefactor          = 1.244507e-15 # s^-1 Pa^-n
-    set Dislocation creep exponent           = 3.5
-    set Dislocation activation energy        = 530000 # J/mol
-    set Dislocation activation volume        = 1.40E-005 # m^3/mol
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, ODE statistics
-end
diff --git a/tests/grain_size_strain_pinned.prm.bak b/tests/grain_size_strain_pinned.prm.bak
deleted file mode 100644
index 759f7419be8..00000000000
--- a/tests/grain_size_strain_pinned.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# A test for the grain size material model. The test imposes simple shear
-# across a 100 km square domain.
-# Over time the model maintains nearly constant temperatures, pressures and
-# strain rates.
-# The model change in grain size can be compared to the analytical
-# equations derived in Mulyukova & Bercovici 2018, which is done
-# in a python notebook stored in
-# $ASPECT_SOURCE_DIR/benchmarks/grain_size_pinned_state/dynamic_grain_size_pinned_state.ipynb
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/grain_size_strain.prm
-
-set End time = 1
-set Maximum time step = 1
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                = 3400
-    set Thermal conductivity             = 0
-    set Thermal expansion coefficient    = 0
-    set Reference compressibility        = 0
-    set Viscosity                        = 1e18
-    set Minimum viscosity                = 1e16
-    set Reference temperature            = 1600
-    set Recrystallized grain size        =
-    set Grain growth activation energy       = 4e5
-    set Grain growth activation volume       = 0.0
-    set Grain growth rate constant           = 1.92E-010
-    set Grain growth exponent                = 3
-    set Average specific grain boundary energy = 1.0
-    set Geometric constant                   = 3
-    set Grain size evolution formulation     = pinned grain damage
-    set Reciprocal required strain                  = 10
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 3.0e-015 # s^-1 Pa^-1 m^p
-    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 3.75e5 #J/mol
-    set Diffusion activation volume          = 6e-6 # m^3/mol (from Karato 2010)
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # Kawazoe et al. (2009)
-    # Dislocation creep
-    set Dislocation creep prefactor          = 1.244507e-15 # s^-1 Pa^-n
-    set Dislocation creep exponent           = 3.5
-    set Dislocation activation energy        = 530000 # J/mol
-    set Dislocation activation volume        = 1.40E-005 # m^3/mol
-
-    subsection Grain damage partitioning
-      set Minimum grain size reduction work fraction  = 1e-1
-    end
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, velocity statistics, material statistics, visualization, ODE statistics
-
-  subsection Visualization
-    set Time between graphical output = 1
-    set List of output variables = material properties, named additional outputs, heating, strain rate, stress second invariant, stress
-    set Output format = gnuplot
-
-    subsection Material properties
-      set List of material properties = viscosity, density, reaction terms
-    end
-  end
-end
diff --git a/tests/grain_size_strain_pinned_state.prm.bak b/tests/grain_size_strain_pinned_state.prm.bak
deleted file mode 100644
index d43bf269650..00000000000
--- a/tests/grain_size_strain_pinned_state.prm.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-# A test for the grain size material model using the pinned state damage formulation.
-# Over time the model maintains nearly constant temperatures, pressures and
-# strain rates. The grain size in the test approaches the equilibrium
-# grain size for t -> infinity. At 400 Myr the equilibrium grain size should
-# be 0.015124 m.
-
-include $ASPECT_SOURCE_DIR/tests/grain_size_strain.prm
-
-set Output directory                       = output_grain_size_strain_pinned_state
-set End time = 1e6
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                = 3400
-    set Thermal conductivity             = 0
-    set Thermal expansion coefficient    = 0
-    set Reference compressibility        = 0
-    set Viscosity                        = 1e18
-    set Minimum viscosity                = 1e16
-    set Reference temperature            = 1600
-    set Recrystallized grain size        =
-    set Grain growth activation energy       = 39072
-    set Grain growth activation volume       = 0.0
-    set Grain growth rate constant           = 1.6E-022
-    set Grain growth exponent                = 4
-    set Average specific grain boundary energy = 1.0
-    set Geometric constant                   = 3
-    set Grain size evolution formulation     = pinned grain damage
-
-    # Mulyukova and Bercovici (2018)
-    # Diffusion creep
-    set Diffusion creep prefactor            = 1e-200 # s^-1 Pa^-1 m^p
-    set Diffusion creep exponent             = 1.0 # 1 for diffusion creep
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 3e5 #J/mol
-    set Diffusion activation volume          = 0 # m^3/mol
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # Kawazoe et al. (2009)
-    # Dislocation creep
-    set Dislocation creep prefactor          = 1e-13 # s^-1 Pa^-n
-    set Dislocation creep exponent           = 3
-    set Dislocation activation energy        = 390720 # J/mol
-    set Dislocation activation volume        = 0 # m^3/mol
-
-    subsection Grain damage partitioning
-      set Minimum grain size reduction work fraction = 1e-6
-    end
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
diff --git a/tests/grain_size_yield.prm.bak b/tests/grain_size_yield.prm.bak
deleted file mode 100644
index 4a8e5c04db4..00000000000
--- a/tests/grain_size_yield.prm.bak
+++ /dev/null
@@ -1,55 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield.prm
-
-
-# Global parameters
-set Dimension                              = 2
-set Adiabatic surface temperature          = 273
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                    = 3300
-    set Thermal conductivity                 = 3.3
-    set Thermal expansion coefficient        = 0.000035
-    set Reference compressibility            = 0
-    set Minimum viscosity                    = 1e17
-    set Maximum viscosity                    = 1e28
-    set Reference temperature                = 293
-    set Grain growth rate constant           = 0
-    set Work fraction for boundary area change = 0
-
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 1e-30
-    set Diffusion creep exponent             = 1
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 0
-    set Diffusion activation volume          = 0
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # No dislocation creep
-    set Dislocation creep prefactor          = 5.e-23
-    set Dislocation creep exponent           = 1
-    set Dislocation activation energy        = 0
-    set Dislocation activation volume        = 0
-    set Use Drucker-Prager rheology          = true
-    set Cohesions                            = 1e6
-    set Angles of internal friction          = 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-  set Types of fields = grain size
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
diff --git a/tests/graphical_output.cc.bak b/tests/graphical_output.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/graphical_output.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/graphical_output.prm.bak b/tests/graphical_output.prm.bak
deleted file mode 100644
index e869c091bdd..00000000000
--- a/tests/graphical_output.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor, visualization
-
-  subsection Depth average
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = viscosity, nonadiabatic pressure
-  end
-end
diff --git a/tests/graphical_output_02.prm.bak b/tests/graphical_output_02.prm.bak
deleted file mode 100644
index d06b46e0868..00000000000
--- a/tests/graphical_output_02.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields          = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/graphical_output_hdf5.cc.bak b/tests/graphical_output_hdf5.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/graphical_output_hdf5.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/graphical_output_hdf5.prm.bak b/tests/graphical_output_hdf5.prm.bak
deleted file mode 100644
index 13f86c36a3c..00000000000
--- a/tests/graphical_output_hdf5.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-# A copy of the graphical_output test designed to test the
-# hdf5 visualization output format.
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor, visualization
-
-  subsection Depth average
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = hdf5
-    set Time between graphical output = 0
-    set List of output variables = viscosity, nonadiabatic pressure
-  end
-end
diff --git a/tests/gravity_function.prm.bak b/tests/gravity_function.prm.bak
deleted file mode 100644
index 796969a54ec..00000000000
--- a/tests/gravity_function.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# Copy of the simpler box test with a function
-# object describing the gravity
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;x
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = density, viscosity, gravity
-  end
-end
diff --git a/tests/gravity_function_time.prm.bak b/tests/gravity_function_time.prm.bak
deleted file mode 100644
index 2e55282dace..00000000000
--- a/tests/gravity_function_time.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# Copy of the simpler box test with a function
-# object describing the gravity
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;if(t>0,x,0)
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = density, gravity
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/gravity_model_cartesian.prm.bak b/tests/gravity_model_cartesian.prm.bak
deleted file mode 100644
index f68e7ed13a7..00000000000
--- a/tests/gravity_model_cartesian.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# This is a test based on benchmarks/onset-of-convection/convection-box-base.prm.
-# It makes sure that the gravity plugin 'function' works correctly
-# for a Cartesian coordinate system.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use conduction timestep                = true
-
-subsection Termination criteria
-  set Termination criteria                 = end step
-  set End step                             = 0
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Outer radius = 6371000
-    set Inner radius = 3481000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r,phi
-    set Function expression = 2500 + 10*sin(10*phi)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-#subsection Gravity model
-#  set Model name = radial constant
-#
-#  subsection Radial constant
-#    set Magnitude = 10.0
-#  end
-#end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x,y
-    set Function expression = x;y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 4000
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity                     = 1e23
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set Time steps between graphical output = 5
-    set List of output variables = gravity
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/gravity_model_depth.prm.bak b/tests/gravity_model_depth.prm.bak
deleted file mode 100644
index 92c43750fa7..00000000000
--- a/tests/gravity_model_depth.prm.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-#This is a test based on benchmarks/onset-of-convection/convection-box-base.prm. It makes sure that the gravity plugin 'function' works correctly for a  Cartesian coordinate system.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Output directory                       = output-gravity_model_depth
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use conduction timestep                = true
-
-subsection Termination criteria
-  set Termination criteria                 = end step
-  set End step                             = 0
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Outer radius = 6371000
-    set Inner radius = 3481000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r,phi
-    set Function expression = 2500 + 10*sin(10*phi)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = depth
-    set Variable names = z,x
-    set Function expression = z;0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 4000
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity                     = 1e23
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set Time steps between graphical output = 5
-    set List of output variables = gravity
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/gravity_model_spherical.prm.bak b/tests/gravity_model_spherical.prm.bak
deleted file mode 100644
index fb684336f2d..00000000000
--- a/tests/gravity_model_spherical.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# This is a test based on benchmarks/onset-of-convection/convection-box-base.prm.
-# It makes sure that the gravity plugin 'function' works correctly for a
-# Cartesian coordinate system.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use conduction timestep                = true
-
-subsection Termination criteria
-  set Termination criteria                 = end step
-  set End step                             = 0
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Outer radius = 6371000
-    set Inner radius = 3481000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r,phi
-    set Function expression = 2500 + 10*sin(10*phi)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3500
-    set Outer temperature = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-#subsection Gravity model
-#  set Model name = radial constant
-#
-#  subsection Radial constant
-#    set Magnitude = 10.0
-#  end
-#end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r,phi
-    set Function expression = r;phi
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 4000
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity                     = 1e23
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set Time steps between graphical output = 5
-    set List of output variables = gravity
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/gravity_point_values_list.prm.bak b/tests/gravity_point_values_list.prm.bak
deleted file mode 100644
index e9c3941449c..00000000000
--- a/tests/gravity_point_values_list.prm.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-# A simple setup for testing the gravity postprocessor using the
-# sample scheme 'list'.
-# See the corresponding section in the manual for more information.
-
-# General parameters
-set Dimension                              = 3
-set End time                               = 0
-set Output directory                       = output-gravity_point_values_list
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1
-    set Outer radius  = 2
-    set Cells along circumference = 12
-  end
-end
-
-# Model boundary velocity
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = top, bottom
-end
-
-# Material model
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                 = 1e6
-  end
-end
-
-# Model initial temperature
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Model gravity
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude  = 10
-  end
-end
-
-# Mesh refinement
-subsection Mesh refinement
-  set Initial global refinement          = 0
-end
-
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = gravity calculation
-
-  subsection Gravity calculation
-    set Sampling scheme           = list of points
-    set List of radius            = 4
-    set List of longitude         = 100
-    set List of latitude          = 35
-  end
-end
diff --git a/tests/gravity_point_values_map.prm.bak b/tests/gravity_point_values_map.prm.bak
deleted file mode 100644
index f124e0de566..00000000000
--- a/tests/gravity_point_values_map.prm.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-# A simple setup for testing the gravity postprocessor using the
-# sample scheme 'map'.
-# See the corresponding section in the manual for more information.
-
-# General parameters
-set Dimension                              = 3
-set End time                               = 0
-set Output directory                       = output-gravity_point_values_map
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1
-    set Outer radius  = 2
-    set Cells along circumference = 12
-  end
-end
-
-# Model boundary velocity
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = top, bottom
-end
-
-# Material model
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                 = 1e6
-  end
-end
-
-# Model initial temperature
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Model gravity
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude  = 10
-  end
-end
-
-# Mesh refinement
-subsection Mesh refinement
-  set Initial global refinement          = 0
-end
-
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = gravity calculation
-
-  subsection Gravity calculation
-    set Sampling scheme               = map
-    set Minimum radius                = 4
-    set Number points longitude       = 5
-    set Number points latitude        = 5
-  end
-end
diff --git a/tests/gravity_point_values_spiral.prm.bak b/tests/gravity_point_values_spiral.prm.bak
deleted file mode 100644
index 52730c459db..00000000000
--- a/tests/gravity_point_values_spiral.prm.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-# A simple setup for testing the gravity postprocessor using the
-# sample scheme 'fibonacci spiral'.
-# See the corresponding section in the manual for more information.
-
-# General parameters
-set Dimension                              = 3
-set End time                               = 0
-set Output directory                       = output-gravity_point_values_spiral
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1
-    set Outer radius  = 2
-    set Cells along circumference = 12
-  end
-end
-
-# Model boundary velocity
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = top, bottom
-end
-
-# Material model
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                 = 1e6
-  end
-end
-
-# Model initial temperature
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Model gravity
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude  = 10
-  end
-end
-
-# Mesh refinement
-subsection Mesh refinement
-  set Initial global refinement          = 0
-end
-
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = gravity calculation
-
-  subsection Gravity calculation
-    set Sampling scheme                      = fibonacci spiral
-    set Number points fibonacci spiral       = 10
-    set Minimum radius                       = 4
-  end
-end
diff --git a/tests/gravity_point_values_spiral_parallel.prm.bak b/tests/gravity_point_values_spiral_parallel.prm.bak
deleted file mode 100644
index f8f7f1a2ccc..00000000000
--- a/tests/gravity_point_values_spiral_parallel.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-# This is a copy of the gravity_point_values_spiral test,
-# but the real purpose of the test is to check that running
-# the postprocessor in parallel works.
-
-# MPI: 3
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/tests/gravity_point_values_spiral.prm
diff --git a/tests/gravity_prem.prm.bak b/tests/gravity_prem.prm.bak
deleted file mode 100644
index 60961ef1251..00000000000
--- a/tests/gravity_prem.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# Copy of the simpler box test with a gravity
-# profile that follows PREM.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = ascii data
-
-  subsection Ascii data model
-    #    set Data directory = $ASPECT_SOURCE_DIR/data/gravity-model/
-    #    set Data file name = prem.txt
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 637100
-    set Y extent = 6371000
-    set Y repetitions = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1600
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 5e24
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = gravity
-  end
-end
diff --git a/tests/gravity_quadrature_degree_increase.prm.bak b/tests/gravity_quadrature_degree_increase.prm.bak
deleted file mode 100644
index d4544e3a5ba..00000000000
--- a/tests/gravity_quadrature_degree_increase.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-# A simple setup for testing the gravity postprocessor using the
-# sample scheme 'list'.
-# See the corresponding section in the manual for more information.
-
-# General parameters
-set Dimension                              = 3
-set End time                               = 0
-set Output directory                       = output-gravity_quadrature_degree_increase.prm
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# Model geometry
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1
-    set Outer radius  = 2
-    set Cells along circumference = 12
-  end
-end
-
-# Model boundary velocity
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = top, bottom
-end
-
-# Material model
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                 = 1e6
-  end
-end
-
-# Model initial temperature
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Model gravity
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude  = 10
-  end
-end
-
-# Mesh refinement
-subsection Mesh refinement
-  set Initial global refinement          = 0
-end
-
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = gravity calculation
-
-  subsection Gravity calculation
-    set Sampling scheme           = list of points
-    set List of radius            = 4
-    set List of longitude         = 100
-    set List of latitude          = 35
-    set Quadrature degree increase = -1
-  end
-end
diff --git a/tests/gs_drucker_prager.prm.bak b/tests/gs_drucker_prager.prm.bak
deleted file mode 100644
index 311c133c4d1..00000000000
--- a/tests/gs_drucker_prager.prm.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-# In this test, a velocity field is prescribed that represents
-# simple shear with respect to the model's y-axis. This setup generates
-# output that describes the material model's response to a range
-# of stress conditions.
-
-# The yield strength is
-# cohesion * cos(phi) + pressure * sin(phi) = 50 MPa + 0.5 * pressure
-# = 50 MPa + 0.5 * 1e6 * x
-
-# The (non-yield) stress in the model is
-# 2 * strain_rate * viscosity = 1e6 * y
-
-# This means the transition from yielding to non-yielding (expressed by
-# the plastic_yielding variable in the graphical output) should start
-# at x=0, y=50 and end at x=200, y=150.
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 293
-set Use years in output instead of seconds = false
-
-# Because this model aims to capture rheological behavior under a range
-# of deformation regimes, we prescribe a flow field in the section called
-# `Prescribed Stokes Solution` below.
-set Nonlinear solver scheme                = single Advection, no Stokes
-set End time                               = 0
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  # Strain rate = 1/2 du_x/dy = 1/2 * 1e6/1e22
-  subsection Velocity function
-    set Function expression = 1e6/(2*1e22)*y^2; 0
-  end
-
-  subsection Pressure function
-    set Function expression = 1e6*x
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent      = 200
-    set Y extent      = 150
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-  set Types of fields = grain size
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600
-  end
-end
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                    = 2700
-    set Thermal conductivity                 = 0
-    set Thermal expansion coefficient        = 0
-    set Reference compressibility            = 0
-    set Minimum viscosity                    = 10
-    set Maximum viscosity                    = 1e30
-    set Reference temperature                = 1600
-    set Grain growth rate constant           = 0
-    set Work fraction for boundary area change = 0
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 1e-22
-    set Diffusion creep exponent             = 1
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 0
-    set Diffusion activation volume          = 0
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # No dislocation creep
-    set Dislocation creep prefactor          = 1e-30
-    set Dislocation creep exponent           = 1
-    set Dislocation activation energy        = 0
-    set Dislocation activation volume        = 0
-    set Use Drucker-Prager rheology          = true
-    set Cohesions                            = 5.77350269e7
-    set Angles of internal friction          = 30
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, material statistics
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables  = material properties, named additional outputs, strain rate, shear stress
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/gs_drucker_prager_extension.prm.bak b/tests/gs_drucker_prager_extension.prm.bak
deleted file mode 100644
index 5908d26fe51..00000000000
--- a/tests/gs_drucker_prager_extension.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# This test is similar to drucker_prager_extension, but uses
-# grain size material model. Because the implementation of
-# the min and max viscosity cutoff is different, the solution
-# is slightly different as well.
-
-include $ASPECT_SOURCE_DIR/tests/drucker_prager_extension.prm
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set Nonlinear solver tolerance             = 1e-7
-set Adiabatic surface temperature          = 1600
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-  set Compositional field methods = particles
-  set Types of fields = grain size
-  set Mapped particle properties = grain_size:grain_size
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600
-  end
-end
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                    = 2700
-    set Thermal conductivity                 = 0
-    set Thermal expansion coefficient        = 0
-    set Reference compressibility            = 0
-    set Minimum viscosity                    = 1e19
-    set Maximum viscosity                    = 1e26
-    set Reference temperature                = 1600
-    set Grain growth rate constant           = 0
-    set Work fraction for boundary area change = 0
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 1e-30
-    set Diffusion creep exponent             = 1
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 0
-    set Diffusion activation volume          = 0
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # No dislocation creep
-    set Dislocation creep prefactor          = 1e-30
-    set Dislocation creep exponent           = 1
-    set Dislocation activation energy        = 0
-    set Dislocation activation volume        = 0
-    set Use Drucker-Prager rheology          = true
-    set Cohesions                            = 4e7
-    set Angles of internal friction          = 15
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles, material statistics
-
-  subsection Visualization
-    set List of output variables  = material properties, named additional outputs, strain rate
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Time between data output = 0
-  end
-end
-
-subsection Particles
-  set List of particle properties = grain size
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10000
-    end
-  end
-end
diff --git a/tests/gs_drucker_prager_extension_adiabatic.prm.bak b/tests/gs_drucker_prager_extension_adiabatic.prm.bak
deleted file mode 100644
index 5ab9011c1ca..00000000000
--- a/tests/gs_drucker_prager_extension_adiabatic.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# This test is like gs_drucker_prager_extension, but uses
-# the adiabatic pressure for yielding.
-
-include $ASPECT_SOURCE_DIR/tests/drucker_prager_extension.prm
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set Nonlinear solver tolerance             = 1e-7
-set Adiabatic surface temperature          = 1600
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-  set Compositional field methods = particles
-  set Types of fields = grain size
-  set Mapped particle properties = grain_size:grain_size
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600
-  end
-end
-
-subsection Material model
-  set Model name = grain size
-
-  subsection Grain size model
-    set Reference density                    = 2700
-    set Thermal conductivity                 = 0
-    set Thermal expansion coefficient        = 0
-    set Reference compressibility            = 0
-    set Minimum viscosity                    = 1e19
-    set Maximum viscosity                    = 1e26
-    set Reference temperature                = 1600
-    set Grain growth rate constant           = 0
-    set Work fraction for boundary area change = 0
-
-    # Faul and Jackson 2007
-    # Diffusion creep
-    # new scaled prefactors to match vertical viscosity profile
-    set Diffusion creep prefactor            = 1e-30
-    set Diffusion creep exponent             = 1
-    set Diffusion creep grain size exponent  = 3
-    set Diffusion activation energy          = 0
-    set Diffusion activation volume          = 0
-    set Dislocation viscosity iteration threshold = 1e-3
-
-    # No dislocation creep
-    set Dislocation creep prefactor          = 1e-30
-    set Dislocation creep exponent           = 1
-    set Dislocation activation energy        = 0
-    set Dislocation activation volume        = 0
-    set Use Drucker-Prager rheology          = true
-    set Cohesions                            = 4e7
-    set Angles of internal friction          = 15
-    set Use adiabatic pressure for yield stress = true
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles, material statistics
-
-  subsection Visualization
-    set List of output variables  = material properties, named additional outputs, strain rate
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Time between data output = 0
-  end
-end
-
-subsection Particles
-  set List of particle properties = grain size
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10000
-    end
-  end
-end
diff --git a/tests/heat_advection_by_melt.cc.bak b/tests/heat_advection_by_melt.cc.bak
deleted file mode 100644
index 3e092d644a0..00000000000
--- a/tests/heat_advection_by_melt.cc.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/material_model/melt_global.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-
-namespace aspect
-{
-
-  template <int dim>
-  class PressureBdry:
-    public BoundaryFluidPressure::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id /*boundary_indicator*/,
-        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &fluid_pressure_gradient_outputs
-      ) const
-      {
-        const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-        Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for shear heating with melt."));
-
-        for (unsigned int q=0; q<fluid_pressure_gradient_outputs.size(); ++q)
-          {
-            const double density = material_model_outputs.densities[q];
-            const double melt_density = melt_outputs->fluid_densities[q];
-            const double porosity = material_model_inputs.composition[q][this->introspection().compositional_index_for_name("porosity")];
-
-            const double bulk_density = (porosity * melt_density + (1.0 - porosity) * density);
-            fluid_pressure_gradient_outputs[q] = this->get_gravity_model().gravity_vector(material_model_inputs.position[q]) * bulk_density * normal_vectors[q];
-          }
-      }
-
-  };
-
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class Advection : public MaterialModel::MeltGlobal<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-    };
-
-
-    template <int dim>
-    void
-    Advection<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      MeltGlobal<dim>::evaluate(in, out);
-
-      // fill melt outputs if they exist
-      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          out.densities[i] = 2.0;
-        }
-
-      if (melt_out != nullptr)
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              melt_out->fluid_densities[i] = 1.0;
-              melt_out->permeabilities[i] = 1.0;
-            }
-        }
-
-
-
-    }
-
-  }
-
-}
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(Advection,
-                                   "melt global advection",
-                                   "A simple material model that is like the "
-                                   "'melt simple' model, but has a constant reaction term.")
-  }
-}
diff --git a/tests/heat_advection_by_melt.prm.bak b/tests/heat_advection_by_melt.prm.bak
deleted file mode 100644
index e2ad0d10ee3..00000000000
--- a/tests/heat_advection_by_melt.prm.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-# This test is used to check if the shear heating
-# of melt, in particular advective transport of heat due
-# to melt migration, is calculated correctly.
-# There is no in- or outflux of solid material, but melt
-# is allowed to flow in freely, so that it moves upwards
-# with a constant velocity determined by its buoyancy.
-# Hence there is no shear of the solid material, but there
-# is dissipation due to the segregation of melt
-# \eta_f porosity^2 / permeability * (u_f - u_s)^2,
-# and heat is advected by melt migration:
-# porosity \rho_f C_p (u_f \cdot \nabla T).
-#
-# With the material properties in this benchmark, both heating
-# rates should be the same (0.1), and the temperature should stay
-# in equilibrium.
-#
-set Dimension                              = 2
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 0.03125
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 1 + y
-    set Variable names        = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.1; 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-
-  subsection Function
-    set Function expression = 0;0
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-  set Heat advection by melt = true
-end
-
-subsection Heating model
-  set List of model names = shear heating, shear heating with melt
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.1111111111111
-  end
-end
-
-subsection Material model
-  set Model name = melt global advection
-
-  subsection Melt global
-    set Reference solid density    = 2
-    set Reference melt density     = 1
-    set Reference specific heat    = 1
-    set Reference temperature      = 1600
-    set Thermal conductivity       = 0.0
-    set Surface solidus            = 10000.0
-    set Include melting and freezing = false
-    set Reference permeability       = 1
-    set Reference shear viscosity    = 1
-    set Reference bulk viscosity     = 1
-    set Reference melt viscosity     = 10
-    set Thermal viscosity exponent   = 0
-    set Exponential melt weakening factor = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heating statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature, heating
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
diff --git a/tests/heat_advection_by_melt_operator_splitting.cc.bak b/tests/heat_advection_by_melt_operator_splitting.cc.bak
deleted file mode 100644
index 3cb698c7e1d..00000000000
--- a/tests/heat_advection_by_melt_operator_splitting.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "heat_advection_by_melt.cc"
diff --git a/tests/heat_advection_by_melt_operator_splitting.prm.bak b/tests/heat_advection_by_melt_operator_splitting.prm.bak
deleted file mode 100644
index 4cc0b1f8b79..00000000000
--- a/tests/heat_advection_by_melt_operator_splitting.prm.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-# This test is a copy of the heat_advection_by_melt test,
-# even with the same results, the only difference is that
-# operator splitting is enabled.
-# It tests if melt heating models work also with operator
-# splitting.
-#
-set Dimension                              = 2
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Use operator splitting                 = true
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 0.1
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 1 + y
-    set Variable names        = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.1; 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-
-  subsection Function
-    set Function expression = 0;0
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-  set Heat advection by melt = true
-end
-
-subsection Heating model
-  set List of model names = shear heating, shear heating with melt
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.1111111111111
-  end
-end
-
-subsection Material model
-  set Model name = melt global advection
-
-  subsection Melt global
-    set Reference solid density    = 2
-    set Reference melt density     = 1
-    set Reference specific heat    = 1
-    set Reference temperature      = 1600
-    set Thermal conductivity       = 0.0
-    set Surface solidus            = 10000.0
-    set Include melting and freezing = false
-    set Reference permeability       = 1
-    set Reference shear viscosity    = 1
-    set Reference bulk viscosity     = 1
-    set Reference melt viscosity     = 10
-    set Thermal viscosity exponent   = 0
-    set Exponential melt weakening factor = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heating statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature, heating
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
diff --git a/tests/heat_flow.prm.bak b/tests/heat_flow.prm.bak
deleted file mode 100644
index 85be7273ae2..00000000000
--- a/tests/heat_flow.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-include $ASPECT_SOURCE_DIR/cookbooks/heat_flow/heat-flow.prm
-
-set Dimension = 2
-set End time = 0
diff --git a/tests/heat_flow_plume.prm.bak b/tests/heat_flow_plume.prm.bak
deleted file mode 100644
index 3bcc168bd61..00000000000
--- a/tests/heat_flow_plume.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-include $ASPECT_SOURCE_DIR/cookbooks/heat_flow/heat-flow-plume.prm
-
-set Dimension = 2
-set End time = 0
diff --git a/tests/heat_flux_densities.prm.bak b/tests/heat_flux_densities.prm.bak
deleted file mode 100644
index 01f7650f661..00000000000
--- a/tests/heat_flux_densities.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# Compute heat flux densities, this is blankenbach case 2b
-
-set End time                               = 0.004
-set Use years in output instead of seconds = false
-set CFL number = 5.0
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0; 0; 1
-    set Variable names      = depth
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2.5
-    set Y extent = 1
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1, ratio=2.5
-    set Function expression = 1* ((1.0-z/L) + p*cos(k*pi*x/L/ratio)*sin(pi*z/L))
-  end
-end
-
-subsection Material model
-  set Model name = nondimensional
-
-  subsection Nondimensional model
-    set Di                      = 0.0
-    set Ra                      = 1e4
-
-    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
-    set Reference density       = 1
-
-    # The value of the specific heat $cp$. Units: \\si{\\joule\\per\\kelvin\\per\\kilogram}.
-    set Reference specific heat = 1
-
-    # Whether to use the TALA instead of the ALA approximation.
-    set Use TALA                = false
-    set Viscosity temperature prefactor = 9.70406052783923433184
-    set Viscosity depth prefactor       = 4.1588830833596718565
-    set gamma                   = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 1.0
-  set Additional refinement times              = 0.1, 0.2, 0.3
-end
-
-subsection Heating model
-  set List of model names = #  adiabatic heating, shear heating#, constant heating
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Formulation
-  set Formulation          = custom # with this selection equivalent to BA
-  set Mass conservation    = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, heat flux densities, heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.002
-    set List of output variables      = material properties, adiabat, thermal conductivity, heating, artificial viscosity
-  end
-end
diff --git a/tests/heat_flux_map.prm.bak b/tests/heat_flux_map.prm.bak
deleted file mode 100644
index af5412b1a86..00000000000
--- a/tests/heat_flux_map.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.01
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = heat flux map, heat flux statistics
-end
diff --git a/tests/heat_flux_map_vis.prm.bak b/tests/heat_flux_map_vis.prm.bak
deleted file mode 100644
index 53e39af5c80..00000000000
--- a/tests/heat_flux_map_vis.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.01
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = heat flux map
-    set Time between graphical output = 0.01
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/heat_flux_map_vis_point_wise.prm.bak b/tests/heat_flux_map_vis_point_wise.prm.bak
deleted file mode 100644
index 6fd247ea814..00000000000
--- a/tests/heat_flux_map_vis_point_wise.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-# This is a copy of the heat_flux_map_vis test that
-# uses the point-wise output of the heat_flux_map visualization postprocessor.
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/heat_flux_map_vis.prm
-
-
-subsection Postprocess
-  subsection Visualization
-    set Interpolate output = true
-
-    # We only have dirichlet boundaries with tangential velocities, so we can
-    # increase the output resolution as described in the documentation of the 'heat
-    # flux map' postprocessor.
-    subsection Heat flux map
-      set Output point wise heat flux = true
-    end
-  end
-end
diff --git a/tests/heating_function.prm.bak b/tests/heating_function.prm.bak
deleted file mode 100644
index a1307c698d5..00000000000
--- a/tests/heating_function.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# A test for the function heating plugin.
-# The heating function is given in cartesian coordinates.
-
-set Dimension                              = 2
-set End time                               = 0.0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 0.55
-    set Outer radius  = 1.0
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Heating model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = thermal energy density
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = heating statistics, visualization
-
-  subsection Visualization
-    set List of output variables = heating
-    set Output format = gnuplot
-    set Time between graphical output = 0.0
-  end
-end
diff --git a/tests/heating_function_depth.prm.bak b/tests/heating_function_depth.prm.bak
deleted file mode 100644
index cca71d2c751..00000000000
--- a/tests/heating_function_depth.prm.bak
+++ /dev/null
@@ -1,16 +0,0 @@
-# A test for the function heating plugin.
-# The heating function is given in terms of depth.
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/heating_function.prm
-
-
-subsection Heating model
-  set List of model names = function
-
-  subsection Function
-    set Coordinate system = depth
-    set Function expression = x
-  end
-end
diff --git a/tests/heating_function_spherical.prm.bak b/tests/heating_function_spherical.prm.bak
deleted file mode 100644
index 2376dfe12b7..00000000000
--- a/tests/heating_function_spherical.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# A test for the function heating plugin.
-# The heating function is given in spherical coordinates.
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/heating_function.prm
-
-
-subsection Heating model
-  set List of model names = function
-
-  subsection Function
-    set Coordinate system = spherical
-    set Variable names = r,phi
-    set Function expression = phi
-  end
-end
diff --git a/tests/hexagonal_initial_temperature.prm.bak b/tests/hexagonal_initial_temperature.prm.bak
deleted file mode 100644
index 74f9fa5a6cd..00000000000
--- a/tests/hexagonal_initial_temperature.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# Test the spherical hexagonal perturbation initial temperature model
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 360
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Additional refinement times              =
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/hill_diffusion.prm.bak b/tests/hill_diffusion.prm.bak
deleted file mode 100644
index 314114a2766..00000000000
--- a/tests/hill_diffusion.prm.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.001
-set Maximum time step                      = 0.0005
-set Nonlinear solver scheme = no Advection, no Stokes
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# 1x1 box with an initial hill topography
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function constants = A=0.075, L=1.
-      set Function expression = \
-                                A * sin(x*pi)
-    end
-  end
-end
-
-# Temperature effects are ignored
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = initial temperature
-end
-
-# Free slip on all boundaries
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The mesh will be deformed according to the displacement
-# of the surface nodes due to diffusion of the topography.
-# The mesh is allowed to move vertical along the left and
-# right boundary.
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: diffusion
-  set Additional tangential mesh velocity boundary indicators = left, right
-
-  subsection Diffusion
-    # The diffusivity
-    set Hillslope transport coefficient = 0.25
-  end
-end
-
-# Vertical gravity
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-# One material with unity properties
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 6
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set Output mesh velocity = true
-    set Interpolate output = false
-    set Output format = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                         = 1e-7
-  end
-end
diff --git a/tests/hill_diffusion_3D.prm.bak b/tests/hill_diffusion_3D.prm.bak
deleted file mode 100644
index dea23489938..00000000000
--- a/tests/hill_diffusion_3D.prm.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set End time                               = 0.001
-set Maximum time step                      = 0.0005
-set Nonlinear solver scheme = no Advection, no Stokes
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# 1x1 box with an initial hill topography
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function constants = A=0.075, L=1.
-      set Function expression = \
-                                A * sin(x*pi)
-    end
-  end
-end
-
-# Temperature effects are ignored
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = initial temperature
-end
-
-# Free slip on all boundaries
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top, front, back
-end
-
-# The mesh will be deformed according to the displacement
-# of the surface nodes due to diffusion of the topography.
-# The mesh is allowed to move vertical along the left and
-# right boundary.
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: diffusion
-  set Additional tangential mesh velocity boundary indicators = left, right, front, back
-
-  subsection Diffusion
-    # The diffusivity
-    set Hillslope transport coefficient = 0.25
-  end
-end
-
-# Vertical gravity
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-# One material with unity properties
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set Output mesh velocity = true
-    set Interpolate output = false
-    set Output format = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                         = 1e-7
-  end
-end
diff --git a/tests/hk04_olivine_composite_hydration_prefactor.prm.bak b/tests/hk04_olivine_composite_hydration_prefactor.prm.bak
deleted file mode 100644
index e5c60de5094..00000000000
--- a/tests/hk04_olivine_composite_hydration_prefactor.prm.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-# A test case that checks the water fugacity viscous prefactor
-# multiplication scheme in combination with the visco plastic material model.
-# Following the flow law for wet olivine composite (diffusion and dislocation)
-# creep from Hirth & Kohlstaedt 2004 (10.1029/138GM06), the exact
-# viscosity is calculated in python through:
-# import numpy as np
-# R = 8.3144621
-# P = 1e9 Pa
-# T = 1173 K
-# edot_ii = 1e-17
-# n_disl = 3.5
-# E_disl = 520e3 J/mol
-# V_disl = 22e-6 m^3/mol
-# r_disl = 1.2
-# A_disl = 1600 / 1e6 / 1e6**n / 1e6**r 1/Pa^(4.7)/s
-#
-# n_diff = 1
-# E_diff = 375e3 J/mol
-# V_diff = 10e-6 m^3/mol
-# r_diff = 0.7
-# d = 1e-3 m
-# m = 3
-# A_diff = 2.5e7 / 1e6**n_diff / 1e6**m / 1e6**r_diff
-
-# A_H2O = 2.6e-5 1/Pa
-# activation_energy_H2O = 40e3 J/mol/K
-# activation_volume_H2O = 10e-6 m^3/mol
-#
-# M_H2O = 0.01801528 kg/mol
-# M_olivine = 0.1470027 kg/mol
-#
-# weight_fraction_h2o = 0.01
-# weight_fraction_olivine = 1 - weight_fraction_h2o
-# COH = (wt_fraction_h2o/M_H2O) / (weight_fraction_olivine/M_olivine) * 1e6
-#
-# fH2O = COH / A_H2O * np.exp((activation_energy_H2O + P*activation_volume_H2O)/(R * T))
-#
-# viscosity_disl = 0.5 * A_disl**(-1/n_disl) * edot_ii^((1-n_disl)/n_disl) * np.exp((E_disl + P*V_disl) / (n_disl*R*T)) * fH2O**(-r_disl/n_disl)
-# viscosity_diff = 0.5 * A_diff**(-1/n_diff) * d**m * np.exp((E_diff + P*V_diff) / (n_diff*R*T)) * fH2O**(-r_diff/n_diff)
-#
-# viscosity_comp = (viscosity_disl * viscosity_diff) / (viscosity_disl + viscosity_diff) = 2.62814004323392e20 Pa s
-# The viscosity should be equal to 2.6281e20 Pa s, and the material model should return this viscosity.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 1.e9
-
-subsection Compositional fields
-  set Names of fields  = bound_fluid
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.01
-  end
-end
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# No boundary-driven deformation, but the strain-rate used by the material
-# model is set in the material model section through the parameters
-# "Reference strain rate" and "Minimum strain rate".
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-# Initial temperature conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1173
-  end
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Dislocation creep parameters
-    # The water fugacity exponent is 1.2, but we need to divide by
-    # the stress exponent, so we input r/n=0.34285714285714286.
-    set Reference strain rate                          = 1e-17
-    set Minimum strain rate                            = 1e-17
-    set Viscous flow law                               = composite
-    set Prefactors for dislocation creep               = 1.0095317511683098e-25
-    set Stress exponents for dislocation creep         = 3.5
-    set Activation energies for dislocation creep      = 520e3
-    set Activation volumes for dislocation creep       = 22e-6
-    set Water fugacity exponents for dislocation creep = 0.34285714285714286
-    set Prefactors for diffusion creep                 = 1.5773933612004842e-21
-    set Stress exponents for diffusion creep           = 1.0
-    set Activation energies for diffusion creep        = 375e3
-    set Activation volumes for diffusion creep         = 10e-6
-    set Grain size                                     = 1e-3
-    set Water fugacity exponents for diffusion creep   = 0.7
-    set Viscosity prefactor scheme                     = HK04 olivine hydration
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = material statistics, visualization
-
-  subsection Visualization
-    set Interpolate output       = false
-    set List of output variables = material properties
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/hk04_olivine_composite_hydration_prefactor_cutoff.prm.bak b/tests/hk04_olivine_composite_hydration_prefactor_cutoff.prm.bak
deleted file mode 100644
index fac8db4be49..00000000000
--- a/tests/hk04_olivine_composite_hydration_prefactor_cutoff.prm.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-# A test case that checks the water fugacity viscous prefactor
-# multiplication scheme in combination with the visco plastic material model.
-# This test is almost identical to hk04_olivine_composite_hydration_prefactor.prm,
-# with the only difference being that the bound_fluid is 0. This test checks that
-# the HK04 olivine hydration viscosity prefactor scheme will not divide by 0, but
-# will instead use the user input value set using 'Minimum mass fraction bound
-# water content for fugacity'. The default value is 6.15e-6 (i.e. 6.15 ppm wt. H2O),
-# and so following the same calculation outlined in
-# hk04_olivine_composite_hydration_prefactor.prm, where T = 1173 K, P = 1 GPa, and
-# edot_ii = 1e-17 1/s, the material model should return 3.1724782150033374e22 Pa s
-# for the viscosity.
-
-include $ASPECT_SOURCE_DIR/tests/hk04_olivine_composite_hydration_prefactor.prm
-
-
-# Set the bound water everywhere in the model to be 0.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0
-  end
-end
diff --git a/tests/hk04_olivine_diffusion_hydration_prefactor.prm.bak b/tests/hk04_olivine_diffusion_hydration_prefactor.prm.bak
deleted file mode 100644
index 5acaeb092e6..00000000000
--- a/tests/hk04_olivine_diffusion_hydration_prefactor.prm.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-# A test case that checks the water fugacity viscous prefactor
-# multiplication scheme in combination with the visco plastic material model.
-# Following the flow law for wet olivine diffusion creep from
-# Hirth & Kohlstaedt 2004 (10.1029/138GM06), the exact
-# viscosity is calculated in python through:
-# import numpy as np
-# m = 3
-# d = 1e-3 m
-# E = 375e3 J/mol
-# V = 15e-6 m^3/mol
-# R = 8.3144621
-# P = 10e9 Pa
-# r = 0.7
-# T = 1673 K
-# A_diff = 2.5e7 / 1e6 / 1e6**m / 1e6**r 1/Pa^2/m^3/s
-#
-# A_H2O = 26 / 1e6**r 1/Pa
-# activation_energy_H2O = 40e3 J/mol
-# activation_volume_H2O = 10e-6 m^3/mol
-#
-# M_H2O = 18.01528
-# M_olivine = 147.0027
-#
-# weight_fraction_h2o = 0.01
-# weight_fraction_olivine = 1 - weight_fraction_h2o
-# COH = (wt_fraction_h2o/M_H2O) / (weight_fraction_olivine/M_olivine) * 1e6
-#
-# fH2O = COH / A_H2O * np.exp((activation_energy_H2O + P*activation_volume_H2O)/(R * T))
-# viscosity_analytic = 0.5 * A_diff**(-1) * d**(m) * np.exp((E + P*V) / R / T) * fH2O**(-r)
-#
-# In the background composition, r=0.7 and the viscosity should be equal to 2.766e19.
-#
-# In the solid_2 composition, r=0.0 and the viscosity should be equal to 4.924e23.
-# Combined, this should result in an average model viscosity of 2.462e23.
-# The material model should return this viscosity.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 10.e9
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = solid_2, bound_fluid
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if(y<=50e3, 1.0, 0.0); 0.01
-  end
-end
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# No boundary-driven deformation, but the strain-rate used by the material
-# model is set in the material model section through the parameters
-# "Reference strain rate" and "Minimum strain rate".
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-# Initial temperature conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1673
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Diffusion creep parameters
-    # In the background, the water fugacity exponent = 0.7, and this requires
-    # a different prefactor due to the dependence of A_diff on the fugacity exponent r.
-    set Viscous flow law                             = diffusion
-    set Prefactors for diffusion creep               = 1.57739e-21, 2.5e-17, 2.5e-17
-    set Stress exponents for diffusion creep         = 1.0
-    set Activation energies for diffusion creep      = 375e3
-    set Activation volumes for diffusion creep       = 15e-6
-    set Grain size                                   = 1e-3
-    set Water fugacity exponents for diffusion creep = 0.7, 0.0, 0.0
-    set Viscosity prefactor scheme                   = HK04 olivine hydration
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = material statistics, visualization
-
-  subsection Visualization
-    set Interpolate output       = false
-    set List of output variables = material properties
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/hk04_olivine_dislocation_hydration_prefactor.prm.bak b/tests/hk04_olivine_dislocation_hydration_prefactor.prm.bak
deleted file mode 100644
index 5d172398e94..00000000000
--- a/tests/hk04_olivine_dislocation_hydration_prefactor.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# A test case that checks the water fugacity viscous prefactor
-# multiplication scheme in combination with the visco plastic material model.
-# Following the flow law for wet olivine dislocation creep from
-# Hirth & Kohlstaedt 2004 (10.1029/138GM06), the exact
-# viscosity is calculated in python through:
-# import numpy as np
-# n = 3.5
-# E = 520e3 J/mol
-# V = 22e-6 m^3/mol
-# R = 8.3144621
-# P = 1e9 Pa
-# r = 1.2
-# edot_ii = 1e-13
-# T = 1173 K
-# A_disl = 1600 / 1e6 / 1e6**n / 1e6**r 1/Pa^(4.7)/s
-#
-# A_H2O = 2.6e-5 1/Pa
-# activation_energy_H2O = 40e3 J/mol/K
-# activation_volume_H2O = 10e-6 m^3/mol
-#
-# M_H2O = 0.01801528 kg/mol
-# M_olivine = 0.1470027 kg/mol
-#
-# weight_fraction_h2o = 0.01
-# weight_fraction_olivine = 1 - weight_fraction_h2o
-# COH = (wt_fraction_h2o/M_H2O) / (weight_fraction_olivine/M_olivine) * 1e6
-#
-# fH2O = COH / A_H2O * np.exp((activation_energy_H2O + P*activation_volume_H2O)/(R * T))
-# viscosity_analytic = 0.5 * A_disl**(-1/n) * edot_ii^((1-n)/n) * np.exp((E + P*V) / (n*R*T)) * fH2O**(-r/n)
-# The viscosity should be equal to 1.00291e19, and the material model should return this viscosity.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 1.e9
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = bound_fluid
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.01
-  end
-end
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# No boundary-driven deformation, but the strain-rate used by the material
-# model is set in the material model section through the parameters
-# "Reference strain rate" and "Minimum strain rate".
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-# Initial temperature conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1173
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Dislocation creep parameters
-    # The water fugacity exponent reported by Hirth & Kohlstaedt for dislocation
-    # creep is 1.2, but ASPECT requires that the water fugacity exponent is r/n,
-    # where n is the stress exponent and thus we input 1.2/3.5 = 0.34285714285714286
-    set Reference strain rate                          = 1e-13
-    set Minimum strain rate                            = 1e-13
-    set Viscous flow law                               = dislocation
-    set Prefactors for dislocation creep               = 1.0095317511683098e-25
-    set Stress exponents for dislocation creep         = 3.5
-    set Activation energies for dislocation creep      = 520e3
-    set Activation volumes for dislocation creep       = 22e-6
-    set Water fugacity exponents for dislocation creep = 0.34285714285714286
-    set Viscosity prefactor scheme                     = HK04 olivine hydration
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = material statistics, visualization
-
-  subsection Visualization
-    set Interpolate output       = false
-    set List of output variables = material properties
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/hollow_sphere.cc.bak b/tests/hollow_sphere.cc.bak
deleted file mode 100644
index abbd72c795b..00000000000
--- a/tests/hollow_sphere.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/hollow_sphere/hollow_sphere.cc"
diff --git a/tests/hollow_sphere.prm.bak b/tests/hollow_sphere.prm.bak
deleted file mode 100644
index b4bbc3647bb..00000000000
--- a/tests/hollow_sphere.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# The 3D HollowSphere benchmark, for which an
-# analytical solution is available (Thieulot, in prep).
-
-
-############### Global parameters
-
-set Additional shared libraries            = ./libhollow_sphere.so
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Output directory                       = output
-set Pressure normalization                 = surface
-
-############### Parameters describing the model
-# The setup is a 3D shell
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 0.5
-    set Outer radius = 1.0
-    set Cells along circumference = 12
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = inner : HollowSphereBoundary, \
-                                                outer : HollowSphereBoundary
-end
-
-subsection Material model
-  set Model name = HollowSphereMaterial
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 1.0
-  end
-end
-
-subsection HollowSphere benchmark
-  #Viscosity parameter is m
-  set Viscosity parameter             = -1
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, HollowSpherePostprocessor
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density, viscosity, strain rate
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/hollow_sphere_gmg.cc.bak b/tests/hollow_sphere_gmg.cc.bak
deleted file mode 100644
index abbd72c795b..00000000000
--- a/tests/hollow_sphere_gmg.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/hollow_sphere/hollow_sphere.cc"
diff --git a/tests/hollow_sphere_gmg.prm.bak b/tests/hollow_sphere_gmg.prm.bak
deleted file mode 100644
index 160aadc597d..00000000000
--- a/tests/hollow_sphere_gmg.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# The 3D HollowSphere benchmark solved with the block
-# GMG preconditioner and harmonic averaging
-
-
-############### Global parameters
-
-set Additional shared libraries            = ./libhollow_sphere.so
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Output directory                       = output
-set Pressure normalization                 = surface
-
-############### Parameters describing the model
-# The setup is a 3D shell
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 0.5
-    set Outer radius = 1.0
-    set Cells along circumference = 12
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = inner : HollowSphereBoundary, \
-                                                outer : HollowSphereBoundary
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 1.0
-  end
-end
-
-subsection HollowSphere benchmark
-  #Viscosity parameter is m
-  set Viscosity parameter             = -1
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, HollowSpherePostprocessor
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density, viscosity, strain rate
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  set Model name = HollowSphereMaterial
-  set Material averaging = harmonic average
-end
diff --git a/tests/hollow_sphere_gmg_project_q1.cc.bak b/tests/hollow_sphere_gmg_project_q1.cc.bak
deleted file mode 100644
index abbd72c795b..00000000000
--- a/tests/hollow_sphere_gmg_project_q1.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/hollow_sphere/hollow_sphere.cc"
diff --git a/tests/hollow_sphere_gmg_project_q1.prm.bak b/tests/hollow_sphere_gmg_project_q1.prm.bak
deleted file mode 100644
index 353b64698a8..00000000000
--- a/tests/hollow_sphere_gmg_project_q1.prm.bak
+++ /dev/null
@@ -1,29 +0,0 @@
-# The 3D HollowSphere benchmark solved with the block
-# GMG preconditioner and project to Q1 only viscosity
-# averaging
-
-include $ASPECT_SOURCE_DIR/benchmarks/hollow_sphere/hollow_sphere.prm
-
-set Dimension = 3
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 100
-  end
-end
-
-subsection Material model
-  set Model name = HollowSphereMaterial
-  set Material averaging = project to Q1 only viscosity
-end
-
-subsection Postprocess
-  set List of postprocessors = HollowSpherePostprocessor
-end
diff --git a/tests/hollow_sphere_gmg_q3.cc.bak b/tests/hollow_sphere_gmg_q3.cc.bak
deleted file mode 100644
index abbd72c795b..00000000000
--- a/tests/hollow_sphere_gmg_q3.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/hollow_sphere/hollow_sphere.cc"
diff --git a/tests/hollow_sphere_gmg_q3.prm.bak b/tests/hollow_sphere_gmg_q3.prm.bak
deleted file mode 100644
index e7f12bdbb80..00000000000
--- a/tests/hollow_sphere_gmg_q3.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-# Like hollow_sphere_gmg.prm but with Q3 elements
-
-
-############### Global parameters
-
-set Additional shared libraries            = ./libhollow_sphere.so
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Output directory                       = output
-set Pressure normalization                 = surface
-
-############### Parameters describing the model
-# The setup is a 3D shell
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 0.5
-    set Outer radius = 1.0
-    set Cells along circumference = 12
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = inner : HollowSphereBoundary, \
-                                                outer : HollowSphereBoundary
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 1.0
-  end
-end
-
-subsection HollowSphere benchmark
-  #Viscosity parameter is m
-  set Viscosity parameter             = -1
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Refinement fraction                = 0.1
-  set Strategy                           = velocity
-  set Run postprocessors on initial refinement            = true
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, HollowSpherePostprocessor
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density, viscosity, strain rate
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  set Model name = HollowSphereMaterial
-  set Material averaging = harmonic average
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree            = 3
-end
diff --git a/tests/hydrostatic_compression.cc.bak b/tests/hydrostatic_compression.cc.bak
deleted file mode 100644
index e558a39bdac..00000000000
--- a/tests/hydrostatic_compression.cc.bak
+++ /dev/null
@@ -1,313 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/simulator.h>
-#include <aspect/simulator/assemblers/interface.h>
-#include <aspect/gravity_model/interface.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  template <int dim>
-  class TestMaterial:
-    public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual bool is_compressible () const
-      {
-        return true;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        const double alpha = -0.2;     // T0 = 100
-
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            const double x = in.position[i](0);
-            const double z = in.position[i](1);
-            const double p = in.pressure[i];
-            const double T = in.temperature[i];
-            out.viscosities[i] = 1.0;
-            out.densities[i] = exp(alpha*T)*p;
-            out.thermal_expansion_coefficients[i] = -alpha;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 1.0/p;
-          }
-      }
-  };
-
-
-  template <int dim>
-  class Gravity : public aspect::GravityModel::Interface<dim>
-  {
-    public:
-      virtual Tensor<1,dim> gravity_vector (const Point<dim> &pos) const
-      {
-        const double x=pos[0];
-        const double z=pos[1];
-        const double pi = numbers::PI;
-
-        const double T0 = 100.0;
-        const double alpha = -0.2;
-
-        Tensor<1,dim> gravity;
-        gravity[0] = -(0.1e1 + 0.2e1 * alpha * (double) pi * cos((double) (2 * pi * x)) * cos((double) (pi * z))) / exp(alpha * (T0 + sin((double) (2 * pi * x)) * cos((double) (pi * z))));
-        gravity[1] = -(0.1e1 - alpha * sin((double) (2 * pi * x)) * (double) pi * sin((double) (pi * z))) / exp(alpha * (T0 + sin((double) (2 * pi * x)) * cos((double) (pi * z))));
-
-
-        return gravity;
-      }
-  };
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(dim+2) {}
-      virtual void vector_value (const Point<dim>   &p,
-                                 Vector<double>   &values) const
-      {
-        double x = p(0);
-        double z = p(1);
-        const double pi = numbers::PI;
-        const double u1 = 1.0;
-        const double w1 = 0.5;
-
-        values[0] = -2.0*u1*pi*sin((double) (2*pi*x)) + u1*cos((double) (2*pi*x)) - w1*(pi*pi+1.0)*cos((double) (pi*z));
-        values[1] = -w1*pi*sin(pi*z)+w1*cos(pi*z)-u1*(4*pi*pi+1)*cos(2*pi*x);
-        values[2] = 0.5-z;
-      }
-  };
-
-  /**
-    * A postprocessor that evaluates the accuracy of the solution
-    * by using the L2 norm.
-    */
-  template <int dim>
-  class ConvergencePostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Generate graphical output from the current solution.
-       */
-      virtual
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics);
-
-  };
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  ConvergencePostprocessor<dim>::execute (TableHandler &statistics)
-  {
-    RefFunction<dim> ref_func;
-    const QGauss<dim> quadrature_formula (this->get_fe().base_element(this->introspection().base_elements.velocities).degree+2);
-
-    const unsigned int n_total_comp = this->introspection().n_components;
-
-    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-
-    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                        n_total_comp);
-    ComponentSelectFunction<dim> comp_p(dim, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p);
-
-    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
-    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
-
-    std::ostringstream os;
-    os << std::scientific
-       << "ndofs= " << this->get_solution().size()
-       << " u_L2= " << u_l2
-       << " p_L2= " << p_l2
-       ;
-
-    return std::make_pair("Errors", os.str());
-  }
-
-  template <int dim>
-  class ForceAssembler :
-    public aspect::Assemblers::Interface<dim>, public SimulatorAccess<dim>
-  {
-
-    public:
-
-      virtual
-      void
-      execute (internal::Assembly::Scratch::ScratchBase<dim>   &scratch_base,
-               internal::Assembly::CopyData::CopyDataBase<dim> &data_base) const
-      {
-        internal::Assembly::Scratch::StokesSystem<dim> &scratch = dynamic_cast<internal::Assembly::Scratch::StokesSystem<dim>&> (scratch_base);
-        internal::Assembly::CopyData::StokesSystem<dim> &data = dynamic_cast<internal::Assembly::CopyData::StokesSystem<dim>&> (data_base);
-
-        const Introspection<dim> &introspection = this->introspection();
-        const FiniteElement<dim> &fe = this->get_fe();
-        const unsigned int stokes_dofs_per_cell = data.local_dof_indices.size();
-        const unsigned int n_q_points    = scratch.finite_element_values.n_quadrature_points;
-        const double pressure_scaling = this->get_pressure_scaling();
-
-        for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-          {
-            const unsigned int component_index_i = fe.system_to_component_index(i).first;
-
-            if (component_index_i == introspection.component_indices.pressure
-                ||
-                (
-                  component_index_i >= introspection.component_indices.velocities[0]
-                  &&
-                  component_index_i <= introspection.component_indices.velocities[dim-1]
-                ))
-              {
-                data.local_dof_indices[i_stokes] = scratch.local_dof_indices[i];
-                ++i_stokes;
-              }
-            ++i;
-          }
-
-        for (unsigned int q=0; q<n_q_points; ++q)
-          {
-            const double x = scratch.finite_element_values.quadrature_point(q)[0];
-            const double z = scratch.finite_element_values.quadrature_point(q)[1];
-
-            const double pi = numbers::PI;
-            const double u1 = 1.0;
-            const double w1 = 0.5;
-            const double alpha = -0.2;
-
-            Tensor<1,dim> force_u;
-            const double force_p = 0.0;
-
-            force_u[0]= -0.32e2 / 0.3e1 * u1 * pow(pi, 0.3e1) * sin(0.2e1 * pi * x)
-                        + 0.16e2 / 0.3e1 * u1 * pi * pi * cos(0.2e1 * pi * x)
-                        - w1 * (pi * pi + 0.1e1) * pi * pi * cos(pi * z)
-                        + (0.5e0 - z) * (0.1e1 + 0.2e1 * alpha * pi * cos(0.2e1 * pi * x) * cos(pi * z));
-
-            force_u[1]= -0.4e1 / 0.3e1 * w1 * pow(pi, 0.3e1) * sin(pi * z)
-                        + 0.4e1 / 0.3e1 * w1 * pi * pi * cos(pi * z)
-                        - 0.4e1 * u1 * (0.4e1 * pi * pi + 0.1e1) * pi * pi * cos(0.2e1 * pi * x)
-                        - 0.1e1 + (0.5e0 - z) * (0.1e1 - alpha * sin(0.2e1 * pi * x) * pi * sin(pi * z));
-
-
-            for (unsigned int i=0, i_stokes=0; i_stokes<stokes_dofs_per_cell; /*increment at end of loop*/)
-              {
-                const unsigned int component_index_i = fe.system_to_component_index(i).first;
-
-                if (component_index_i == introspection.component_indices.pressure
-                    ||
-                    (
-                      component_index_i >= introspection.component_indices.velocities[0]
-                      &&
-                      component_index_i <= introspection.component_indices.velocities[dim-1]
-                    ))
-                  {
-                    scratch.phi_u[i_stokes]   = scratch.finite_element_values[introspection.extractors.velocities].value (i,q);
-                    scratch.phi_p[i_stokes]   = scratch.finite_element_values[introspection.extractors.pressure].value (i, q);
-
-                    ++i_stokes;
-                  }
-                ++i;
-              }
-
-            const double JxW = scratch.finite_element_values.JxW(q);
-
-            for (unsigned int i=0; i<stokes_dofs_per_cell; ++i)
-              {
-                data.local_rhs(i) += (
-                                       (force_u * scratch.phi_u[i]
-                                        + pressure_scaling * force_p * scratch.phi_p[i])
-                                     )
-                                     * JxW;
-              }
-          }
-      }
-
-  };
-
-
-  template <int dim>
-  void add_force_assembler(const SimulatorAccess<dim> &simulator_access,
-                           Assemblers::Manager<dim> &assemblers)
-  {
-
-    Assemblers::Interface<dim> *assembler = new ForceAssembler<dim>();
-    assemblers.stokes_system.push_back(std::unique_ptr<Assemblers::Interface<dim>>(assembler));
-  }
-}
-
-
-
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  signals.set_assemblers.connect (&aspect::add_force_assembler<dim>);
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
-
-
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_GRAVITY_MODEL(Gravity,
-                                "MyGravity",
-                                "")
-
-  ASPECT_REGISTER_MATERIAL_MODEL(TestMaterial,
-                                 "test material",
-                                 "")
-
-  ASPECT_REGISTER_POSTPROCESSOR(ConvergencePostprocessor,
-                                "error calculation",
-                                "")
-}
diff --git a/tests/hydrostatic_compression.prm.bak b/tests/hydrostatic_compression.prm.bak
deleted file mode 100644
index d502cb1c7aa..00000000000
--- a/tests/hydrostatic_compression.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-# A testcase with manufactured solution that demonstrates that the mass
-# formulation "hydrostatic pressure" is correct and converges. The example is
-# constructed to have
-#
-# -\nabla \cdot \mathbf{u} = \left( \kappa \rho \textbf{g} - \alpha \nabla T \right) \cdot \textbf{u}
-#
-# using a specific gravity and a force vector is used to enforce the correct u
-# and p (by canceling out the gravity term). This means the test will only
-# work for this mass formulation.
-
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 50
-set Nonlinear solver tolerance             = 1e-10
-set Adiabatic surface temperature          = 100.0
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0.01
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Refinement fraction                      = 0.0
-  set Coarsening fraction                      = 0.0
-  set Time steps between mesh refinement       = 0
-  set Initial adaptive refinement              = 0
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation    = hydrostatic compression
-  set Temperature equation = real density
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,1,2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 101.0
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 99.0
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 0.99
-
-    #    set Box origin X coordinate = -1
-    set Box origin Y coordinate = -0.5
-  end
-end
-
-subsection Gravity model
-  set Model name = MyGravity
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-
-  subsection Function
-    set Function constants = u1=1,w1=0.5
-    set Function expression = -2*u1*pi*sin(2*pi*x)+u1*cos(2*pi*x)-w1*(pi*pi+1)*cos(pi*z);-w1*pi*sin(pi*z)+w1*cos(pi*z)-u1*(4*pi*pi+1)*cos(2*pi*x)
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 100.0 + sin(2*pi*x) * cos(pi*z)
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = test material
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, pressure statistics, velocity boundary statistics, error calculation
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = material properties, gravity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/inclusion_2.cc.bak b/tests/inclusion_2.cc.bak
deleted file mode 100644
index 02f52b98641..00000000000
--- a/tests/inclusion_2.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/inclusion/inclusion.cc"
diff --git a/tests/inclusion_2.prm.bak b/tests/inclusion_2.prm.bak
deleted file mode 100644
index 25b17b1fcf3..00000000000
--- a/tests/inclusion_2.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 1
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = InclusionMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = thermal energy density
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, InclusionPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/inclusion_4.cc.bak b/tests/inclusion_4.cc.bak
deleted file mode 100644
index 02f52b98641..00000000000
--- a/tests/inclusion_4.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/inclusion/inclusion.cc"
diff --git a/tests/inclusion_4.prm.bak b/tests/inclusion_4.prm.bak
deleted file mode 100644
index 524af027cc1..00000000000
--- a/tests/inclusion_4.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 1
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = InclusionMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = thermal energy density
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, InclusionPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/inclusion_adaptive.cc.bak b/tests/inclusion_adaptive.cc.bak
deleted file mode 100644
index 02f52b98641..00000000000
--- a/tests/inclusion_adaptive.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/inclusion/inclusion.cc"
diff --git a/tests/inclusion_adaptive.prm.bak b/tests/inclusion_adaptive.prm.bak
deleted file mode 100644
index 0f1ae0ff10e..00000000000
--- a/tests/inclusion_adaptive.prm.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 1
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = InclusionMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 5
-  set Initial global refinement          = 3
-  set Run postprocessors on initial refinement = true
-  set Refinement fraction                = 0.5#33333
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, InclusionPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/infill_density_flexure.cc.bak b/tests/infill_density_flexure.cc.bak
deleted file mode 100644
index 31e53d711fa..00000000000
--- a/tests/infill_density_flexure.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/infill_density/infill_ascii_data.cc"
diff --git a/tests/infill_density_flexure.prm.bak b/tests/infill_density_flexure.prm.bak
deleted file mode 100644
index c315615328a..00000000000
--- a/tests/infill_density_flexure.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-# Infill density benchmark test
-
-include $ASPECT_SOURCE_DIR/benchmarks/infill_density/infill_ascii.prm
-
-set End time = 0
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 2
-end
diff --git a/tests/initial_composition_list.prm.bak b/tests/initial_composition_list.prm.bak
deleted file mode 100644
index 67c24fb5d05..00000000000
--- a/tests/initial_composition_list.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-##### simple test for ascii data initial composition
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set List of model names = ascii data, function
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-0.5,0.1)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
-end
diff --git a/tests/initial_composition_list_using_maximum.prm.bak b/tests/initial_composition_list_using_maximum.prm.bak
deleted file mode 100644
index fbf3479dfd8..00000000000
--- a/tests/initial_composition_list_using_maximum.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-##### simple test for ascii data initial composition
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set List of model names = ascii data, function
-  set List of model operators = add, maximum
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,0.5,0.1)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
-end
diff --git a/tests/initial_composition_list_using_minimum.prm.bak b/tests/initial_composition_list_using_minimum.prm.bak
deleted file mode 100644
index 53cad23e421..00000000000
--- a/tests/initial_composition_list_using_minimum.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-##### simple test for ascii data initial composition
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set List of model names = ascii data, function
-  set List of model operators = add, minimum
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,0.5,0.1)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
-end
diff --git a/tests/initial_composition_list_using_subtract.prm.bak b/tests/initial_composition_list_using_subtract.prm.bak
deleted file mode 100644
index 49b6b71f971..00000000000
--- a/tests/initial_composition_list_using_subtract.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-##### simple test for ascii data initial composition
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set List of model names = ascii data, function
-  set List of model operators = add, subtract
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,0.5,-0.1)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, composition statistics
-end
diff --git a/tests/initial_condition_S20RTS.prm.bak b/tests/initial_condition_S20RTS.prm.bak
deleted file mode 100644
index b4eec6b42a5..00000000000
--- a/tests/initial_condition_S20RTS.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0
-  set Tangential velocity boundary indicators = 1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1600
-    set Outer temperature = 1600
-  end
-end
-
-subsection Initial temperature model
-  set Model name = S40RTS perturbation
-
-  subsection S40RTS perturbation
-    set Initial condition file name           = S20RTS.sph
-    set Vs to density scaling                 = 0.3
-    set Thermal expansion coefficient in initial temperature scaling = 4e-5
-    set Reference temperature                 = 1600
-    set Remove degree 0 from perturbation     = true
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/initial_condition_S20RTS_2D.prm.bak b/tests/initial_condition_S20RTS_2D.prm.bak
deleted file mode 100644
index eab87fddfd9..00000000000
--- a/tests/initial_condition_S20RTS_2D.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-# This is a variation of the initial_condition_S20RTS.prm test
-# that tests the same plugin for 2D models.
-
-include $ASPECT_SOURCE_DIR/tests/initial_condition_S20RTS.prm
-
-set Dimension = 2
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-end
diff --git a/tests/initial_condition_S20RTS_dgp.prm.bak b/tests/initial_condition_S20RTS_dgp.prm.bak
deleted file mode 100644
index 3136af608d8..00000000000
--- a/tests/initial_condition_S20RTS_dgp.prm.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree            = 1
-  set Use locally conservative discretization      = true
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0
-  set Tangential velocity boundary indicators = 1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1600
-    set Outer temperature = 1600
-  end
-end
-
-subsection Initial temperature model
-  set Model name = S40RTS perturbation
-
-  subsection S40RTS perturbation
-    set Initial condition file name           = S20RTS.sph
-    set Vs to density scaling                 = 0.3
-    set Thermal expansion coefficient in initial temperature scaling = 4e-5
-    set Reference temperature                 = 1600
-    set Remove degree 0 from perturbation     = true
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/initial_condition_S40RTS.prm.bak b/tests/initial_condition_S40RTS.prm.bak
deleted file mode 100644
index 11434a11692..00000000000
--- a/tests/initial_condition_S40RTS.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer,west,south,east
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner,outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1600
-    set Outer temperature = 1600
-  end
-end
-
-subsection Initial temperature model
-  set Model name = S40RTS perturbation
-
-  subsection S40RTS perturbation
-    set Initial condition file name           = S40RTS.sph
-    set Vs to density scaling                 = 0.3
-    set Thermal expansion coefficient in initial temperature scaling = 4e-5
-    set Reference temperature                 = 1600
-    set Remove degree 0 from perturbation     = true
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/initial_condition_SAVANI.prm.bak b/tests/initial_condition_SAVANI.prm.bak
deleted file mode 100644
index c191ebe67ad..00000000000
--- a/tests/initial_condition_SAVANI.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-    set Reference temperature         = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer, west, south, east
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1600
-    set Outer temperature = 1600
-  end
-end
-
-subsection Initial temperature model
-  set Model name = SAVANI perturbation
-
-  subsection SAVANI perturbation
-    set Initial condition file name           = savani.dlnvs.60.m.ab
-    set Vs to density scaling                 = 0.3
-    set Thermal expansion coefficient in initial temperature scaling = 4e-5
-    set Reference temperature                 = 1600
-    set Remove degree 0 from perturbation     = true
-    set Specify a lower maximum degree        = true
-    set Maximum degree                        = 40
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/initial_condition_lithosphere_mask.prm.bak b/tests/initial_condition_lithosphere_mask.prm.bak
deleted file mode 100644
index 293e8b9f42e..00000000000
--- a/tests/initial_condition_lithosphere_mask.prm.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Initial temperature model
-  set List of model names = function, lithosphere mask
-  set List of model operators = add, replace if valid
-
-  subsection Function
-    set Coordinate system = depth
-    set Function constants = temp=2500
-    set Function expression = temp
-  end
-
-  subsection Lithosphere Mask
-    set Depth specification method = File
-    set Lithosphere temperature = 1600
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/initial_condition_patch_on_S40RTS.prm.bak b/tests/initial_condition_patch_on_S40RTS.prm.bak
deleted file mode 100644
index 44f254f0ecb..00000000000
--- a/tests/initial_condition_patch_on_S40RTS.prm.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Initial temperature model
-  set Model name = patch on S40RTS
-
-  subsection Patch on S40RTS
-    set Maximum grid depth = 700000
-  end
-
-  subsection S40RTS perturbation
-    set Initial condition file name           = S20RTS.sph
-    set Vs to density scaling method          = file
-    set Thermal expansion coefficient in initial temperature scaling = 4e-5
-    set Reference temperature                 = 1600
-    set Remove degree 0 from perturbation     = true
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/initial_condition_vs_to_density.prm.bak b/tests/initial_condition_vs_to_density.prm.bak
deleted file mode 100644
index fc125ace1a1..00000000000
--- a/tests/initial_condition_vs_to_density.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# This tests whether ASPECT reads in the
-# vs to density scaling form a file correctly
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0
-  set Tangential velocity boundary indicators = 1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1600
-    set Outer temperature = 1600
-  end
-end
-
-subsection Initial temperature model
-  set Model name = S40RTS perturbation
-
-  subsection S40RTS perturbation
-    set Initial condition file name           = S20RTS.sph
-    set Vs to density scaling                 = 0.3
-    set Thermal expansion coefficient in initial temperature scaling = 4e-5
-    set Reference temperature                 = 1600
-    set Remove degree 0 from perturbation     = true
-    set Vs to density scaling method          = file
-
-    subsection Ascii data vs to density model
-      set Data file name                      = vs_to_density_Steinberger.txt
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/initial_condition_vs_to_density_SAVANI.prm.bak b/tests/initial_condition_vs_to_density_SAVANI.prm.bak
deleted file mode 100644
index 59086888f53..00000000000
--- a/tests/initial_condition_vs_to_density_SAVANI.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# This tests whether ASPECT reads in the
-# vs to density scaling form a file correctly
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0
-  set Tangential velocity boundary indicators = 1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1600
-    set Outer temperature = 1600
-  end
-end
-
-subsection Initial temperature model
-  set Model name = SAVANI perturbation
-
-  subsection SAVANI perturbation
-    set Initial condition file name           = savani.dlnvs.60.m.ab
-    set Vs to density scaling                 = 0.3
-    set Thermal expansion coefficient in initial temperature scaling = 4e-5
-    set Reference temperature                 = 1600
-    set Remove degree 0 from perturbation     = true
-    set Vs to density scaling method          = file
-
-    subsection Ascii data vs to density model
-      set Data file name                      = vs_to_density_Steinberger.txt
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/initial_global_refinement.prm.bak b/tests/initial_global_refinement.prm.bak
deleted file mode 100644
index ddd12757b9c..00000000000
--- a/tests/initial_global_refinement.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# This model tests if the maximum refinement function is
-# applied correctly in time step zero during global refinement.
-# The mesh should have the highest refinement level of 4 in the
-# upper quarter of the domain, the lowest refinement level of
-# 0 in the bottom quarter, and an intermediate level of 2 in
-# between.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = refine
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-    set X repetitions = 5
-    set Y repetitions = 5
-    set Z repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 4
-  set Initial adaptive refinement = 0
-  set Time steps between mesh refinement = 0
-  set Strategy = minimum refinement function, maximum refinement function
-  set Minimum refinement level = 0
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function expression = if( y>=0.751 , 4, if (y>=0.251, 2, 0))
-  end
-
-  subsection Maximum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function expression = if( y>=0.751, 4, if (y>=0.251, 2, 0))
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set List of output variables = partition
-  end
-end
diff --git a/tests/initial_porosity.prm.bak b/tests/initial_porosity.prm.bak
deleted file mode 100644
index 7e5bc0abd6e..00000000000
--- a/tests/initial_porosity.prm.bak
+++ /dev/null
@@ -1,216 +0,0 @@
-# A test that computes an initial porosity field based on the
-# equilibrium melt fraction for the given temperature field.
-
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 1.0
-set Maximum time step                      = 1e6
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = with_melt
-set Max nonlinear iterations               = 20
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Composition reference profile = function
-    set Function expression = 0.0;0.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.2
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3700
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = #2,3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-
-  subsection Function
-    set Function constants  = b=100000, c=20000
-    set Variable names      = x,y
-    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 8700000
-    set Y extent = 2900000
-
-    #    set X periodic = true
-    set X repetitions = 3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 5e8
-    set Age top boundary layer    = 3e8
-    set Amplitude                 = 0
-    set Position                  = center
-    set Radius                    = 350000
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-
-  subsection Function
-    set Function expression = if (x*x+y*y < 2700000*2700000,500,0)
-  end
-end
-
-subsection Initial composition model
-  set Model name = porosity
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Reference melt density            = 3000
-    set Thermal expansion coefficient     = 2e-5
-    set Reference permeability            = 1e-8
-    set Reference shear viscosity         = 5e21
-    set Reference bulk viscosity          = 1e19
-    set Exponential melt weakening factor = 10
-    set Thermal viscosity exponent        = 7
-    set Thermal bulk viscosity exponent   = 7
-    set Reference temperature             = 1600
-    set Solid compressibility             = 4.2e-12
-    set Melt compressibility              = 1.25e-11
-    set Reference melt viscosity          = 10
-    set Depletion density change          = -200.0 # -100.0 # 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 3
-  set Strategy                                 = composition threshold, minimum refinement function #, nonadiabatic temperature
-  set Time steps between mesh refinement       = 0
-
-  subsection Minimum refinement function
-    set Coordinate system   = depth
-    set Function expression = if (depth>1500000,5,4)
-    set Variable names      = depth,phi
-  end
-
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-4,1.0
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating #, latent heat melt, shear heating
-end
-
-subsection Nullspace removal
-  #  set Remove nullspace                        = net x translation
-
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Interpolate output            = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-
-  subsection Depth average
-    set Number of zones = 12
-    set Time between graphical output = 6e5
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint = 1700
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-14
-  set Temperature solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/initial_temperature_list.prm.bak b/tests/initial_temperature_list.prm.bak
deleted file mode 100644
index ee12f428b0d..00000000000
--- a/tests/initial_temperature_list.prm.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-##### simple test for using multiple initial temperature plugins
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = ascii data, function
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,-50,10)
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/initial_temperature_list_using_maximum.prm.bak b/tests/initial_temperature_list_using_maximum.prm.bak
deleted file mode 100644
index d27d06fe9fa..00000000000
--- a/tests/initial_temperature_list_using_maximum.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-##### simple test for using multiple initial temperature plugins
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = ascii data, function
-  set List of model operators = add, maximum
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,10,50)
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/initial_temperature_list_using_minimum.prm.bak b/tests/initial_temperature_list_using_minimum.prm.bak
deleted file mode 100644
index 432135d0982..00000000000
--- a/tests/initial_temperature_list_using_minimum.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-##### simple test for using multiple initial temperature plugins
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = ascii data, function
-  set List of model operators = add, minimum
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,10,50)
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/initial_temperature_list_using_subtract.prm.bak b/tests/initial_temperature_list_using_subtract.prm.bak
deleted file mode 100644
index 04e5a0754df..00000000000
--- a/tests/initial_temperature_list_using_subtract.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-##### simple test for using multiple initial temperature plugins
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = ascii data, function
-  set List of model operators = add, subtract
-
-  subsection Ascii data model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-data/test/
-    set Data file name       = box_2d.txt
-  end
-
-  subsection Function
-    set Function expression = if ((x-330000)*(x-330000)+(y-330000)*(y-330000) < 100000*100000,50,-10)
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/initial_temperature_profile.prm.bak b/tests/initial_temperature_profile.prm.bak
deleted file mode 100644
index b5dd0a90c34..00000000000
--- a/tests/initial_temperature_profile.prm.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer,west,south,east
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner,outer
-  set List of model names = initial temperature
-end
-
-subsection Initial temperature model
-  set List of model names = ascii profile, harmonic perturbation
-  set List of model operators = add
-
-  subsection Ascii profile
-    set Data directory = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-profile/tests/
-    set Data file name = simple_test.txt
-  end
-
-  subsection Harmonic perturbation
-    set Magnitude = 2.0
-    set Reference temperature = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/inner_core.cc.bak b/tests/inner_core.cc.bak
deleted file mode 100644
index ab683f33e71..00000000000
--- a/tests/inner_core.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../cookbooks/inner_core_convection/inner_core_assembly.cc"
diff --git a/tests/inner_core.prm.bak b/tests/inner_core.prm.bak
deleted file mode 100644
index 578c894fa9c..00000000000
--- a/tests/inner_core.prm.bak
+++ /dev/null
@@ -1,142 +0,0 @@
-# A simple setup for convection the inner core. See the
-# manual, Section Cookbooks/Geophysical setups/Inner core convection
-# for more information. Changing the Rayleigh number Ra
-# and the resistance to phase change P will change the mode
-# of inner core convection between translation, plume convection
-# or no convection.
-#
-# Setup and equations are given in: Deguen, Alboussiere,
-# and Cardin (2013), Thermal convection in Earth’s inner core
-# with phase change at its boundary. GJI, 194, 1310-133.
-
-# MPI: 2
-
-set Additional shared libraries            = ./libinner_core_convection.so
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set End time                               = 50
-set Output directory                       = output
-
-# The equations are non-dimensionalized, and all of the
-# material properties are constant and set to one, except
-# for the density, which scales with temperature.
-subsection Material model
-  set Model name = inner core material
-
-  subsection Simple model
-    set Reference density             = 0
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-
-  # The 'inner core material' model also contains a function that
-  # represents the resistance to melting/freezing at the inner core
-  # boundary.
-  # This phase boundary model combines a prescribed a normal
-  # velocity and normal stress. The relation between the two scales
-  # with the phase change number P, which is given in the 'Function
-  # expression'.
-  # For P-->infinity, the boundary is a free slip boundary, and for
-  # P-->0, the boundary is an open boundary (with zero normal stress).
-
-  # For time dependence, the variable names have to have dim+1 entries,
-  # and the last variable will be the time
-  subsection Inner core
-    subsection Phase change resistance function
-      set Variable names      = x,y,z
-      set Function expression = 1e-2     # <-- P
-    end
-  end
-end
-
-# The inner core is a sphere, and the non-dimensional radius
-# is 1.
-subsection Geometry model
-  set Model name = sphere
-
-  subsection Sphere
-    set Radius  = 1
-  end
-end
-
-# We use a new boundary condition at the surface, which takes
-# into account the effect of melting/freezing of material at
-# the boundary of inner and outer core, and which is implemented
-# in the shared library.
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = surface: zero traction
-end
-
-# The (potential) temperature is set to zero at the outer boundary.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = surface
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 0.8
-    set Outer temperature = 0
-  end
-end
-
-# We use a constant radiogenic heating rate.
-subsection Heating model
-  set List of model names = constant core heating
-
-  subsection Constant core heating
-    set Radiogenic heating rate = 6
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-# The gravity has its maximum value at the boundary of inner and
-# outer core, and decreases approximately linearly to zero towards
-# the center of the core.
-# The Rayleigh number used in the model is given by the magnitude
-# of the gravity at the inner core/outer core boundary.
-subsection Gravity model
-  set Model name = radial linear
-
-  subsection Radial linear
-    set Magnitude at bottom = 0.0
-    set Magnitude at surface = 2     # <-- Ra
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 0
-  set Strategy                           = minimum refinement function
-  set Time steps between mesh refinement = 0
-
-  subsection Minimum refinement function
-    set Variable names = depth, phi, theta
-    set Function expression = if(depth>0.1,if(depth>0.3,5,6),7)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Number of grouped files       = 0
-    set List of output variables      = strain rate, gravity, density, specific heat, heating
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net translation
-end
diff --git a/tests/internal_heating_statistics.prm.bak b/tests/internal_heating_statistics.prm.bak
deleted file mode 100644
index 9f467d21e3a..00000000000
--- a/tests/internal_heating_statistics.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-############### Global parameters
-# This is a test for the radiogenic heating and the internal
-# heating statistics postprocessor. Since density and radiogenic
-# heating are constant there is an analytical solution, which
-# is reproduced in this testcase.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 1000
-set Use years in output instead of seconds = false
-set Output directory = radiogenic_heating
-
-subsection Heating model
-  set List of model names = constant heating
-
-  subsection Constant heating
-    set Radiogenic heating rate = 1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = 3
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;-1
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 0.0
-    set Thermal expansion coefficient                  = 0.0
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = heating
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/interpolor_particles_harmonic_average.prm.bak b/tests/interpolor_particles_harmonic_average.prm.bak
deleted file mode 100644
index a2edd2fa67d..00000000000
--- a/tests/interpolor_particles_harmonic_average.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# Test whether the interpolator reads the input correctly.
-include $ASPECT_SOURCE_DIR/tests/time_stepping_repeat_particles.prm
-
-set End time                               = 0.0
-
-subsection Particles
-  set Interpolation scheme = harmonic average
-  set List of particle properties = initial position
-end
-
-subsection Compositional fields
-  set Number of fields = 0
-  set Names of fields =
-  set Compositional field methods =
-  set Mapped particle properties  =
-end
-
-
-subsection Initial composition model
-  set Model name = unspecified
-end
diff --git a/tests/interpolor_particles_nearest_neighbor.prm.bak b/tests/interpolor_particles_nearest_neighbor.prm.bak
deleted file mode 100644
index 3938cab7dd8..00000000000
--- a/tests/interpolor_particles_nearest_neighbor.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-# Test whether the interpolator reads the input correctly.
-include $ASPECT_SOURCE_DIR/tests/time_stepping_repeat_particles.prm
-
-set End time                               = 0.0
-
-subsection Particles
-  set Interpolation scheme = nearest neighbor
-end
diff --git a/tests/interpolor_particles_quadratic_least_squares.prm.bak b/tests/interpolor_particles_quadratic_least_squares.prm.bak
deleted file mode 100644
index 96d437503aa..00000000000
--- a/tests/interpolor_particles_quadratic_least_squares.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-# Test whether the interpolator reads the input correctly.
-include $ASPECT_SOURCE_DIR/tests/time_stepping_repeat_particles.prm
-
-set End time                               = 0.0
-
-subsection Particles
-  set Interpolation scheme = quadratic least squares
-end
diff --git a/tests/isosurfaces_simple_box_2D.prm.bak b/tests/isosurfaces_simple_box_2D.prm.bak
deleted file mode 100644
index 1164df69fe1..00000000000
--- a/tests/isosurfaces_simple_box_2D.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# This input file tests the isosurface mesh refinement plugin
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set X repetitions = 1
-    set Y repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x, y
-    set Function expression = if(x < 500000,if(y< 330000,100+x/1000,100+x/250),0)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x, y
-    set Function expression = if(x < 500000,if(y < 330000,1,0),0);if(x < 500000,0,1);if(x < 500000,if(y < 330000,0,1),0)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 3
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 2
-  set Strategy = isosurfaces
-
-  subsection Isosurfaces
-    # Although the isosurface entry specifies min/max level 4, refinement level will
-    # not be more than 2 because initial global + initial adaptive = 2
-    set Isosurfaces = 4,    4,    Temperature: 0 | 600,   C_2 : 0.0 | 0.5 ;\
-                      0,    0,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/isosurfaces_simple_box_2D_custom_fieldnames.prm.bak b/tests/isosurfaces_simple_box_2D_custom_fieldnames.prm.bak
deleted file mode 100644
index 971ab778bed..00000000000
--- a/tests/isosurfaces_simple_box_2D_custom_fieldnames.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# This input file tests the isosurface mesh refinement plugin
-include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
-
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = field1, FieldB, fIEld_C
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 2
-  set Strategy = isosurfaces
-
-  subsection Isosurfaces
-    # Although the isosurface entry specifies min/max level 4, refinement level will
-    # not be more than 2 because initial global + initial adaptive = 2
-    set Isosurfaces = 4,    4,    Temperature: 0 | 600,   FieldB : 0.0 | 0.5 ;\
-                   0,    0,    Temperature: 1600 | 3000,   FieldB : 0.0 | 0.5
-  end
-end
diff --git a/tests/isosurfaces_simple_box_2D_custom_fieldnames_fail.prm.bak b/tests/isosurfaces_simple_box_2D_custom_fieldnames_fail.prm.bak
deleted file mode 100644
index 12234b85b88..00000000000
--- a/tests/isosurfaces_simple_box_2D_custom_fieldnames_fail.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# This input file tests the isosurface mesh refinement plugin
-include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
-
-
-# EXPECT FAILURE
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = field1, FieldB, fIEld_C
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 2
-  set Strategy = isosurfaces
-
-  subsection Isosurfaces
-    set Isosurfaces = 4,    4,    Temperature: 0 | 600,   C_2 : 0.0 | 0.5 ;\
-                      0,    0,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
-  end
-end
diff --git a/tests/isosurfaces_simple_box_2D_min_max_1.prm.bak b/tests/isosurfaces_simple_box_2D_min_max_1.prm.bak
deleted file mode 100644
index f049331fa69..00000000000
--- a/tests/isosurfaces_simple_box_2D_min_max_1.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-# This input file tests the isosurface mesh refinement plugin
-include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
-
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 2
-  set Strategy = isosurfaces
-
-  subsection Isosurfaces
-    set Isosurfaces = max,    max,    Temperature: 0 | 600,   C_2 : 0.0 | 0.5 ;\
-                      min,    min,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
-  end
-end
diff --git a/tests/isosurfaces_simple_box_2D_min_max_2.prm.bak b/tests/isosurfaces_simple_box_2D_min_max_2.prm.bak
deleted file mode 100644
index 38e3d5b1138..00000000000
--- a/tests/isosurfaces_simple_box_2D_min_max_2.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-# This input file tests the isosurface mesh refinement plugin
-include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
-
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 2
-  set Strategy = isosurfaces, temperature
-
-  subsection Isosurfaces
-    set Isosurfaces = max-2,  max - 1,    Temperature: 0 | 600 ;\
-                      min + 1,min+2,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
-  end
-end
diff --git a/tests/isosurfaces_simple_box_3D.prm.bak b/tests/isosurfaces_simple_box_3D.prm.bak
deleted file mode 100644
index a9d746267a2..00000000000
--- a/tests/isosurfaces_simple_box_3D.prm.bak
+++ /dev/null
@@ -1,56 +0,0 @@
-# This input file tests the isosurface mesh refinement plugin
-include $ASPECT_SOURCE_DIR/tests/isosurfaces_simple_box_2D.prm
-
-set Dimension = 3
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-    set Z extent = 660000
-    set X repetitions = 1
-    set Y repetitions = 1
-    set Z repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x, y, z
-    set Function expression = if(z < 500000,if(x < 330000 && y < 330000,100+z/1000,100+z/250),0)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x, y, z
-    set Function expression = if(z < 500000,if(x < 330000 && y < 330000,1,0),0);if(z < 500000,if(x < 330000 && y < 330000,0,0),1);if(z < 500000,if(x < 330000 && y < 330000,0,1),0)
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 2
-  set Strategy = isosurfaces
-
-  subsection Isosurfaces
-    # Although the isosurface entry specifies min/max level 4, refinement level will
-    # not be more than 2 because initial global + initial adaptive = 2
-    set Isosurfaces = 3,    3,    Temperature: 0 | 600,   C_2 : 0.0 | 0.5 ;\
-                      0,    0,    Temperature: 1600 | 3000,   C_2 : 0.0 | 0.5
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 5
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0,1,2,3,4,5
-end
diff --git a/tests/isosurfaces_slab_2D.prm.bak b/tests/isosurfaces_slab_2D.prm.bak
deleted file mode 100644
index cb1088f6339..00000000000
--- a/tests/isosurfaces_slab_2D.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# This input file tests the box geometry in
-# combination with the isosurfaces plugin to refine a 2D slab
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1673.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-# We take a box geometry and increase the repetitions
-# of the coarse mesh
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10
-    set Y extent = 10
-    set X repetitions = 10
-    set Y repetitions = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 2
-  set Strategy = isosurfaces
-
-  subsection Isosurfaces
-    set Isosurfaces = 2,    2,    C_1 : 0.5 | 1.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1673.0
-    set Top temperature    = 273.0
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0,1,2,3
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y
-    set Function constants = Xtr=5.0, Dsl=1.0, Ymax=10.0, D0=0.3, Xmax=10.0
-    set Function expression = (x > Xtr + D0) ? ((y + Dsl > Ymax + D0)? 273.0 : 1673.0):\
-                              (((y > x + Xmax - Xtr - Dsl) && (y < x + Xmax - Xtr))? 273.0 : 1673.0)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x, y
-    set Function constants = Xtr=5.0, Dsl=1.0, Ymax=10.0, D0=0.3, Xmax=10.0
-    set Function expression = (x > Xtr + D0) ? ((y + Dsl > Ymax + D0)? 1.0 : 0.0):\
-                              (((y > x + Xmax - Xtr - Dsl) && (y < x + Xmax - Xtr))? 1.0 : 0.0)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics
-
-  subsection Visualization
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/isosurfaces_slab_3D.prm.bak b/tests/isosurfaces_slab_3D.prm.bak
deleted file mode 100644
index 0ef5b57fff9..00000000000
--- a/tests/isosurfaces_slab_3D.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# This input file tests the box geometry in
-# combination with the isosurfaces plugin to refine a 3D slab
-include $ASPECT_SOURCE_DIR/tests/isosurfaces_slab_2D.prm
-
-set Dimension = 3
-
-# We take a box geometry and increase the repetitions
-# of the coarse mesh
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 5
-    set Y extent = 1
-    set Z extent = 5
-    set X repetitions = 5
-    set Y repetitions = 1
-    set Z repetitions = 5
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 2
-  set Strategy = isosurfaces
-
-  subsection Isosurfaces
-    set Isosurfaces = 2,    2,    C_1 : 0.5 | 1.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1673.0
-    set Top temperature    = 273.0
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1, 2, 3, 4, 5
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y, z
-    set Function constants = Xtr=3.0, Dsl=1.0, Zmax=5.0, D0=0.3, Xmax=5.0
-    set Function expression = (x > Xtr + D0) ? ((z + Dsl > Zmax + D0)? 273.0 : 1673.0):\
-                              (((z > x + Xmax - Xtr - Dsl) && (z < x + Xmax - Xtr))? 273.0 : 1673.0)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x, y, z
-    set Function constants = Xtr=3.0, Dsl=1.0, Zmax=5.0, D0=0.3, Xmax=5.0
-    set Function expression = (x > Xtr + D0) ? ((z + Dsl > Zmax + D0)? 1.0 : 0.0):\
-                              (((z > x + Xmax - Xtr - Dsl) && (z < x + Xmax - Xtr))? 1.0 : 0.0)
-  end
-end
diff --git a/tests/iterated_advection_and_defect_correction_Stokes.prm.bak b/tests/iterated_advection_and_defect_correction_Stokes.prm.bak
deleted file mode 100644
index f7def287742..00000000000
--- a/tests/iterated_advection_and_defect_correction_Stokes.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-#########################################################
-# This is a model setup to test the iterated Advection and Stokes solver.
-# Both the calculation of the residuum and the convergence
-# with prescribed boundary conditions are tested.
-
-set Adiabatic surface temperature          = 0
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and defect correction Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-
-  subsection Stabilization parameters
-    set beta  = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 150000
-    set Y extent  = 65000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 0
-    set Thermal expansion coefficient = 1
-    set Thermal viscosity exponent = 0.0
-    set Reference specific heat = 1.0
-    set Reference density = 1.0
-    set Reference temperature = 0
-    set Viscosity = 1e16
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-2
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/iterated_advection_and_stokes.prm.bak b/tests/iterated_advection_and_stokes.prm.bak
deleted file mode 100644
index d5913c7a8b5..00000000000
--- a/tests/iterated_advection_and_stokes.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-#########################################################
-# This is a model setup to test the iterated Advection and Stokes solver.
-# Both the calculation of the residuum and the convergence
-# with prescribed boundary conditions are tested.
-
-set Adiabatic surface temperature          = 0
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-
-  subsection Stabilization parameters
-    set beta  = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 150000
-    set Y extent  = 65000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 0
-    set Thermal expansion coefficient = 1
-    set Thermal viscosity exponent = 0.0
-    set Reference specific heat = 1.0
-    set Reference density = 1.0
-    set Reference temperature = 0
-    set Viscosity = 1e16
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/iterated_advection_and_stokes_DG.prm.bak b/tests/iterated_advection_and_stokes_DG.prm.bak
deleted file mode 100644
index 656f6126b6b..00000000000
--- a/tests/iterated_advection_and_stokes_DG.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-#########################################################
-# This is a model setup to test the iterated Advection and Stokes solver
-# in combination with discontinuous discretization (DG) of the composition.
-
-set Adiabatic surface temperature          = 0
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = false
-    set beta  = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, test
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 150000
-    set Y extent  = 65000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c)); if(x<75e3,1,0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 0
-    set Thermal expansion coefficient = 1
-    set Thermal viscosity exponent = 0.0
-    set Reference specific heat = 1.0
-    set Reference density = 1.0
-    set Reference temperature = 0
-    set Viscosity = 1e16
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/iterated_advection_and_stokes_DG_limiter.prm.bak b/tests/iterated_advection_and_stokes_DG_limiter.prm.bak
deleted file mode 100644
index f07acf0e2d0..00000000000
--- a/tests/iterated_advection_and_stokes_DG_limiter.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-#########################################################
-# This is a model setup to test the iterated Advection and Stokes solver
-# in combination with discontinuous discretization (DG) of the composition.
-# The DG method also applies global limits to each field on a cell-by-cell
-# basis.
-
-set Adiabatic surface temperature          = 0
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-
-    # porosity will not exceed 0.21 during set model time.
-    # test will have to stay between 0 and 1.
-    set Global composition maximum =  1.0, 1.0
-    set Global composition minimum =  0.0, 0.0
-    set beta  = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, test
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 150000
-    set Y extent  = 65000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c)); if(x<75e3,1,0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 0
-    set Thermal expansion coefficient = 1
-    set Thermal viscosity exponent = 0.0
-    set Reference specific heat = 1.0
-    set Reference density = 1.0
-    set Reference temperature = 0
-    set Viscosity = 1e16
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/iterated_advection_and_stokes_direct_solver.prm.bak b/tests/iterated_advection_and_stokes_direct_solver.prm.bak
deleted file mode 100644
index 6105c34713e..00000000000
--- a/tests/iterated_advection_and_stokes_direct_solver.prm.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-#########################################################
-# This is a model setup to test the iterated Advection and Stokes
-# nonlinear solver scheme when using the direct solver.
-# Both the calculation of the residuum and the convergence
-# with prescribed boundary conditions are tested, as well
-# as agreement with the respective test for the iterative
-# solver (iterated_advection_and_stokes).
-
-set Adiabatic surface temperature          = 0
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-
-  subsection Stabilization parameters
-    set beta  = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 150000
-    set Y extent  = 65000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 0
-    set Thermal expansion coefficient = 1
-    set Thermal viscosity exponent = 0.0
-    set Reference specific heat = 1.0
-    set Reference density = 1.0
-    set Reference temperature = 0
-    set Viscosity = 1e16
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/iterated_advection_and_stokes_residual.prm.bak b/tests/iterated_advection_and_stokes_residual.prm.bak
deleted file mode 100644
index 1f8f5b5adce..00000000000
--- a/tests/iterated_advection_and_stokes_residual.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-#########################################################
-# This is a model setup to test the residual of the
-# iterated Advection and Stokes solver. Although the initial composition
-# residual is 0, the overall residual is finite.
-
-set Adiabatic surface temperature          = 0
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-
-  subsection Stabilization parameters
-    set beta  = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 150000
-    set Y extent  = 65000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = 0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 0
-    set Thermal expansion coefficient = 1
-    set Thermal viscosity exponent = 0.0
-    set Reference specific heat = 1.0
-    set Reference density = 1.0
-    set Reference temperature = 0
-    set Viscosity = 1e16
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/kaus_rayleigh_taylor_instability.prm.bak b/tests/kaus_rayleigh_taylor_instability.prm.bak
deleted file mode 100644
index ddd546f432c..00000000000
--- a/tests/kaus_rayleigh_taylor_instability.prm.bak
+++ /dev/null
@@ -1,41 +0,0 @@
-# Test based on the 2D Rayleigh Taylor benchmark described
-# in Kaus et al. (2010, 10.1016/j.pepi.2010.04.007).
-# The benchmark considers a denser, more viscous layer
-# overlying lighter, less viscous mantle. The interface
-# between the layers is perturbed, leading to drips along
-# the vertical domain boundaries. A free surface allows
-# for the development of surface topography.
-include $ASPECT_SOURCE_DIR/benchmarks/rayleigh_taylor_instability_free_surface/kaus_rayleigh_taylor_instability.prm
-
-
-############### Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 2500
-
-############### Mesh refinement
-# The Kaus paper considers a resolution of 50x50 elements.
-# We use 64x64 in the benchmark, but reduce it to 8x8 for this test.
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-# We monitor the topography over time.
-subsection Postprocess
-  set List of postprocessors = visualization, topography, composition statistics, maximum depth of field, velocity statistics
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set List of output variables      = viscosity, density
-    set Output mesh velocity          = true
-    set Output format = gnuplot
-  end
-
-  subsection Topography
-    set Output to file           = true
-    set Time between text output = 0
-  end
-end
diff --git a/tests/kinematically_driven_subduction_2d_case1.prm.bak b/tests/kinematically_driven_subduction_2d_case1.prm.bak
deleted file mode 100644
index 650c7bad14d..00000000000
--- a/tests/kinematically_driven_subduction_2d_case1.prm.bak
+++ /dev/null
@@ -1,177 +0,0 @@
-# This test is the same setup as the
-# cookbook kinematically_driven_subduction_2d
-# but with lower resolution. It models oceanic
-# subduction in a 2d box of 3000 x 670 km.
-# The subducting plate is driven by inflow boundary
-# conditions on the top part of the right boundary,
-# while a balancing outflow is prescribed underneath.
-# Only density and viscosity differ per composition.
-
-# 2D
-set Dimension                              = 2
-
-# Run for 0.1 My
-set Start time                             = 0
-set End time                               = 1.e5
-set CFL number                             = 0.5
-set Use years in output instead of seconds = true
-
-# Linear solver
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = output-Case1
-set Adiabatic surface temperature          = 0
-
-# We fix composition on the right boundary,
-# because we have inflow there.
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = right
-  set List of model names = initial composition
-end
-
-# We fix temperature on the top and bottom,
-# as well as on the right boundary because
-# we have inflow through the latter.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 0
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom, top
-  set Prescribed velocity boundary indicators = right x:function
-
-  subsection Function
-    set Function constants  = cm=100.0 #*3600.0*24.0*365.25
-    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
-                                 if(z>560000.0, -5.0/cm, \
-                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
-                              0
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature         = 0.0
-    set Viscosity averaging scheme    = maximum composition
-
-    # OP, ML SP, crust SP
-    set Viscosities                   = 1.e20, 1.e23, 1.e23, 1.e20
-    set Densities                     = 3200.0, 3250.0, 3250.0, 3250.0
-    set Thermal conductivities        = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = OP, ML_SP, crust_SP
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = Ax=1475600.0, Az=670000.0, \
-                              Bx=1500000.0, Bz=670000.0, \
-                              Cx=1358500.0, Cz=588000.0, \
-                              Dx=1382900.0, Dz=588000.0, \
-                              Ex=1530000.0, Ez=560000.0, \
-                              Fz=663000.0, Gz=662000.0, \
-                              Hz=631000.0, Iz=630000.0
-    set Function expression = \
-                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
-                              if((x>=Ex&z>=Ez&z<Gz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
-                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)|z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0)
-    set Variable names      = x,z
-  end
-end
-
-subsection Discretization
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent   = 3000e3
-    set Y extent   = 670e3
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We ignore any temperature effects
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0
-    set Variable names      = x,y,t
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 1
-  set Initial global refinement                = 4
-  set Minimum refinement level                 = 4
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = plus
-  set Coarsening fraction                      = 0.01
-  set Refinement fraction                      = 0.95
-  set Run postprocessors on initial refinement = false
-  set Skip solvers on initial refinement       = true
-  set Skip setup initial conditions on initial refinement = true
-  set Strategy                                 = minimum refinement function, viscosity
-  set Time steps between mesh refinement       = 16
-
-  subsection Minimum refinement function
-    set Coordinate system = depth
-    set Variable names = x,z,t
-    set Function constants = vel=150e3, L=100e3, crust=10e3
-    set Function expression = if(x<crust,8,if(x<L,7,if(x<vel,6,4)))
-  end
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, strain rate, error indicator
-    set Time between graphical output = 5e5
-  end
-
-  subsection Composition velocity statistics
-    set Names of selected compositional fields = ML_SP, crust_SP
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = end time
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-  end
-end
diff --git a/tests/kinematically_driven_subduction_2d_case2a.cc.bak b/tests/kinematically_driven_subduction_2d_case2a.cc.bak
deleted file mode 100644
index 9caed44a250..00000000000
--- a/tests/kinematically_driven_subduction_2d_case2a.cc.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "../cookbooks/kinematically_driven_subduction_2d/trench_location.cc"
-#include "../cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc"
-#include "../cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc"
-#include "../cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc"
diff --git a/tests/kinematically_driven_subduction_2d_case2a.prm.bak b/tests/kinematically_driven_subduction_2d_case2a.prm.bak
deleted file mode 100644
index bf65782432d..00000000000
--- a/tests/kinematically_driven_subduction_2d_case2a.prm.bak
+++ /dev/null
@@ -1,176 +0,0 @@
-# Test based on the cookbook kinematically_driven_subduction_2d_case2a,
-# with lower resolution and only a few timesteps.
-
-set End time                               = 1.e5
-
-# Copy of the cookbooks instead of includes because we
-# cannot include a prm that includes another prm as
-# $ASPECT_SOURCE_DIR is not expanded the second time.
-set Start time                             = 0
-set CFL number                             = 0.5
-set Use years in output instead of seconds = true
-
-# Linear solver
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature          = 0
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 1
-  set Initial global refinement                = 4
-  set Minimum refinement level                 = 4
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = plus
-  set Coarsening fraction                      = 0.01
-  set Refinement fraction                      = 0.95
-  set Run postprocessors on initial refinement = false
-  set Skip solvers on initial refinement       = true
-  set Skip setup initial conditions on initial refinement = true
-  set Strategy                                 = minimum refinement function, viscosity
-  set Time steps between mesh refinement       = 16
-
-  subsection Minimum refinement function
-    set Coordinate system = depth
-    set Variable names = x,z,t
-    set Function constants = vel=150e3, L=100e3, crust=10e3
-    set Function expression = if(x<crust,8,if(x<L,7,if(x<vel,6,4)))
-  end
-end
-
-# We fix composition on the right boundary,
-# because we have inflow there.
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = right
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom, top
-  set Prescribed velocity boundary indicators = right x:function
-
-  subsection Function
-    set Function constants  = cm=100.0 #*3600.0*24.0*365.25
-    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
-                                 if(z>560000.0, -5.0/cm, \
-                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
-                              0
-    set Variable names      = x,z
-  end
-end
-
-subsection Discretization
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent   = 3000e3
-    set Y extent   = 670e3
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end time
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, right
-  set List of model names = initial temperature
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-    set Reference temperature         = 473.15
-    set Densities                     = 3200.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0,3250.0
-    set Thermal expansivities         = 0
-    set Thermal conductivities        = 183.33,2.5,2.5,2.5,2.5,2.5,2.5,2.5
-    set Heat capacities               = 1250.0,750.0,750.0,750.0,750.0,1250.0,1250.0,750.0
-    set Viscosity averaging scheme    = maximum composition
-    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
-  end
-end
-
-# The overriding plate (OP) and subducting plate (SP)
-# are each divided into three different layers:
-# a layer of Bulk Oceanic Composition (BOC),
-# a layer of Serpentinized HarzBurgite (SHB),
-# and a "thermal layer".
-subsection Compositional fields
-  set Number of fields = 7
-  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = Ax=1475600.0, Az=670000.0, \
-                              Bx=1500000.0, Bz=670000.0, \
-                              Cx=1358500.0, Cz=588000.0, \
-                              Dx=1382900.0, Dz=588000.0, \
-                              Ex=1530000.0, Ez=560000.0, \
-                              Fz=663000.0, Gz=662000.0, \
-                              Hz=631000.0, Iz=630000.0
-    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
-                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
-                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
-                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
-                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
-                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
-                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
-    set Variable names      = x,z
-  end
-end
-
-# The initial temperature is prescribed through a plugin
-# and uses the plate cooling model for the temperature in both
-# plates (the plates have different ages) and an adiabatic
-# gradient of 0.25 degrees per km in the sublithospheric
-# mantle.
-subsection Initial temperature model
-  set List of model names = subduction plate cooling
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
-
-  subsection Composition velocity statistics
-    # Sum the velocities of the fields that make up the subducting plate.
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-
-  subsection Trench location
-    set Name of trench compositional field = BOC_OP
-  end
-
-  subsection Isotherm depth
-    set Isotherm value = 1073.15
-  end
-
-  subsection Composition RMS temperature statistics
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-end
diff --git a/tests/kinematically_driven_subduction_2d_case2b.cc.bak b/tests/kinematically_driven_subduction_2d_case2b.cc.bak
deleted file mode 100644
index 9caed44a250..00000000000
--- a/tests/kinematically_driven_subduction_2d_case2b.cc.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "../cookbooks/kinematically_driven_subduction_2d/trench_location.cc"
-#include "../cookbooks/kinematically_driven_subduction_2d/subduction_plate_cooling.cc"
-#include "../cookbooks/kinematically_driven_subduction_2d/isotherm_depth.cc"
-#include "../cookbooks/kinematically_driven_subduction_2d/composition_trms_statistics.cc"
diff --git a/tests/kinematically_driven_subduction_2d_case2b.prm.bak b/tests/kinematically_driven_subduction_2d_case2b.prm.bak
deleted file mode 100644
index 17af696dd8c..00000000000
--- a/tests/kinematically_driven_subduction_2d_case2b.prm.bak
+++ /dev/null
@@ -1,195 +0,0 @@
-# Test based on the cookbook kinematically_driven_subduction_2d_case2b,
-# with lower resolution and only a few timesteps.
-
-# 2D
-set Dimension                              = 2
-set End time                               = 1.e5
-
-# Copy of the cookbooks instead of includes because we
-# cannot include a prm that includes another prm as
-# $ASPECT_SOURCE_DIR is not expanded the second time.
-set Start time                             = 0
-set CFL number                             = 0.5
-set Use years in output instead of seconds = true
-
-# Linear solver
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature          = 0
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 1
-  set Initial global refinement                = 4
-  set Minimum refinement level                 = 4
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = plus
-  set Coarsening fraction                      = 0.01
-  set Refinement fraction                      = 0.95
-  set Run postprocessors on initial refinement = false
-  set Skip solvers on initial refinement       = true
-  set Skip setup initial conditions on initial refinement = true
-  set Strategy                                 = minimum refinement function, viscosity
-  set Time steps between mesh refinement       = 16
-
-  subsection Minimum refinement function
-    set Coordinate system = depth
-    set Variable names = x,z,t
-    set Function constants = vel=150e3, L=100e3, crust=10e3
-    set Function expression = if(x<crust,8,if(x<L,7,if(x<vel,6,4)))
-  end
-end
-
-# We fix composition on the right boundary,
-# because we have inflow there.
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = right
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom, top
-  set Prescribed velocity boundary indicators = right x:function
-
-  subsection Function
-    set Function constants  = cm=100.0 #*3600.0*24.0*365.25
-    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
-                                 if(z>560000.0, -5.0/cm, \
-                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
-                              0
-    set Variable names      = x,z
-  end
-end
-
-subsection Discretization
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent   = 3000e3
-    set Y extent   = 670e3
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end time
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, right
-  set List of model names = initial temperature
-end
-
-# The overriding plate (OP) and subducting plate (SP)
-# are each divided into three different layers:
-# a layer of Bulk Oceanic Composition (BOC),
-# a layer of Serpentinized HarzBurgite (SHB),
-# and a "thermal layer".
-subsection Compositional fields
-  set Number of fields = 7
-  set Names of fields  = BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = Ax=1475600.0, Az=670000.0, \
-                              Bx=1500000.0, Bz=670000.0, \
-                              Cx=1358500.0, Cz=588000.0, \
-                              Dx=1382900.0, Dz=588000.0, \
-                              Ex=1530000.0, Ez=560000.0, \
-                              Fz=663000.0, Gz=662000.0, \
-                              Hz=631000.0, Iz=630000.0
-    set Function expression = if(z>=Fz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
-                              if(z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0); \
-                              if(z>=Hz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Fz,1,0); \
-                              if(z>=Iz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz,1,0); \
-                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)&z<Hz,1,0); \
-                              if((x>=Ex&z>=Ez&z<Iz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Iz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
-                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1.5,0)
-    set Variable names      = x,z
-  end
-end
-
-# The initial temperature is prescribed through a plugin
-# and uses the plate cooling model for the temperature in both
-# plates (the plates have different ages) and an adiabatic
-# gradient of 0.25 degrees per km in the sublithospheric
-# mantle.
-subsection Initial temperature model
-  set List of model names = subduction plate cooling
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, heating statistics, maximum depth of field, composition velocity statistics, viscous dissipation statistics, temperature statistics, trench location, isotherm depth, composition RMS temperature statistics
-
-  subsection Composition velocity statistics
-    # Sum the velocities of the fields that make up the subducting plate.
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-
-  subsection Trench location
-    set Name of trench compositional field = BOC_OP
-  end
-
-  subsection Isotherm depth
-    set Isotherm value = 1073.15
-  end
-
-  subsection Composition RMS temperature statistics
-    set Names of selected compositional fields = BOC_SP, SHB_SP, thermal_SP
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    # The benchmark uses two different reference temperatures for the compositions:
-    # 1573.15 K for the asthenosphere, thermal_OP and thermal_SP, and 473.15 K for
-    # the rest of the compositions.
-    # As ASPECT only allows for one reference temperature, we have instead adapted
-    # the reference density for the mantle compositions. To do this, we took the initial
-    # temperature and the midpoint depth of the layers and equated the density equation
-    # using the benchmark reference density rho_0_1 (3200 kg/m3) and temperature T_0_1 (1573.15 K), and
-    # the density equation using the 473.15 K reference temperature to obtain the new reference density rho_0_2.
-    # For the left thermal layer, the initial temperature at the midpoint is 1355 K, so
-    # new reference density can be derived as follows:
-    # rho_0_1 * (1 - alpha * (T - T_0_1)) = rho_0_2 * (1 - alpha * (T - T_0_2)),
-    # 3200 * (1 - 2.5e-5 * (1355 - 1573.15)) = rho_0_2 * (1 - 2.5e-5 * (1355 - 473.15))
-    # rho_0_2 = 3290.66.
-    set Reference temperature         = 473.15
-
-    # BOC_OP, BOC_SP, SHB_OP, SHB_SP, thermal_OP, thermal_SP, WZ
-    set Densities                     = 3290.66,3000.0,3000.0,3250.0,3250.0,3290.66,3290.66,3200.0
-
-    # Compared to Case 2a, thermal expansivity is no longer zero and therefore temperature
-    # feeds into the density and therefore the Stokes equations
-    set Thermal expansivities         = 2.5e-5
-    set Thermal conductivities        = 183.33,2.5,2.5,2.5,2.5,2.5,2.5,2.5
-    set Heat capacities               = 1250.0,750.0,750.0,750.0,750.0,1250.0,1250.0,750.0
-    set Viscosity averaging scheme    = maximum composition
-    set Viscosities                   = 1.e20, 1.e23, 1.e20, 1.e23, 1.e23, 1.e23, 1.e23, 1.e20
-  end
-end
diff --git a/tests/king_ala.cc.bak b/tests/king_ala.cc.bak
deleted file mode 100644
index 1d456034870..00000000000
--- a/tests/king_ala.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/king2dcompressible/plugin/code.cc"
-#include "../benchmarks/blankenbach/plugin/heat_flux_statistics_gradient.cc"
diff --git a/tests/king_ala.prm.bak b/tests/king_ala.prm.bak
deleted file mode 100644
index e68485600c9..00000000000
--- a/tests/king_ala.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-# King2010 ALA benchmark as described in benchmarks/kingd2dcompressible
-
-include $ASPECT_SOURCE_DIR/benchmarks/king2dcompressible/ala.prm
-
-set Dimension                              = 2
-set CFL number = 10.0
-set End time                               = 0.5
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average, heating statistics
-end
diff --git a/tests/king_ala_nondim.prm.bak b/tests/king_ala_nondim.prm.bak
deleted file mode 100644
index 706dbb3ba12..00000000000
--- a/tests/king_ala_nondim.prm.bak
+++ /dev/null
@@ -1,163 +0,0 @@
-# King2010 ALA benchmark
-# like king_ala.prm but using the nondimensional material model
-
-set Dimension                              = 2
-set CFL number                             = 10.0
-set Adiabatic surface temperature          = 0.091
-set Use years in output instead of seconds = false
-set End time                               = 0.15
-
-subsection Discretization
-  subsection Stabilization parameters
-    set alpha                                              = 2
-    set beta                                               = 0.005
-    set cR                                                 = 0.033
-  end
-end
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=0.25, gamma=1.0
-    set Function expression = 0.091*exp(depth*Di); gamma/Di*(exp(depth*Di/gamma)-1); exp(depth*Di/gamma)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression =  1* ((1.0-z/L) + p*cos(k*pi*x/L/1.0)*sin(pi*z/L)) +0.091
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above. (As will be seen
-# in the next section, the actual temperature prescribed here
-# at the left and right does not matter.)
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top, bottom
-
-  subsection Box
-    set Top temperature    = 0.091
-    set Bottom temperature = 1.091
-    set Left temperature   = 0
-    set Right temperature  = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    # A flag indicating whether the adiabatic heating should be simplified
-    # from $\alpha T (\mathbf u \cdot \nabla p)$
-    # to $ \alpha \rho T (\mathbf u \cdot \mathbf g) $. alpha=thermal exp
-
-    # have \alpha rho T w
-    # need: \alpha \rho T w Di
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Material model
-  set Model name = nondimensional
-
-  subsection Nondimensional model
-    set Di                      = 0.25
-    set Ra                      = 1e4
-    set Reference density       = 1
-    set Reference specific heat = 1
-    set Use TALA                = false
-    set gamma                   = 1.0
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 1.0
-  set Additional refinement times              = 0.35
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average, heating statistics
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/latent_heat.prm.bak b/tests/latent_heat.prm.bak
deleted file mode 100644
index 47e2abb7c88..00000000000
--- a/tests/latent_heat.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-#########################################################
-# This is a model setup to test the latent heat generation.
-# Material flows in from the top and crosses a phase
-# transition, where energy is released and the temperature
-# increases.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 1e15
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = 3
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;-2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    # The change of density across the phase transition. Together with the
-    # Clapeyron slope, this is what determines the entropy change.
-    set Phase transition density jumps                 = 115.6
-    set Corresponding phase for density jump           = 0
-
-    # If the temperature is equal to the phase transition temperature, the
-    # phase transition will occur at the phase transition depth. However,
-    # if the temperature deviates from this value, the Clapeyron slope
-    # determines how much the pressure (and depth) of the phase boundary
-    # changes. Here, the phase transition will be in the middle of the box
-    # for T=T1.
-    set Phase transition depths                        = 500000
-    set Phase transition temperatures                  = 1000
-    set Phase transition Clapeyron slopes              = 1e7
-
-    # We set the width of the phase transition to 5 km. You may want to
-    # change this parameter to see how latent heating depends on the width
-    # of the phase transition.
-    set Phase transition widths                        = 20000
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 2.38
-
-    # We set the thermal expansion and the compressibility to zero, so that
-    # all temperature (and density) changes are caused by advection, diffusion
-    # and latent heating.
-    set Thermal expansion coefficient                  = 0.0
-    set Compressibility                                = 0.0
-
-    # Viscosity is constant.
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 8.44e21
-    set Viscosity prefactors                           = 1.0, 1.0
-    set Composition viscosity prefactor                = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
-
-subsection Heating model
-  set List of model names =  latent heat
-end
diff --git a/tests/latent_heat_composition.prm.bak b/tests/latent_heat_composition.prm.bak
deleted file mode 100644
index ef3020c3831..00000000000
--- a/tests/latent_heat_composition.prm.bak
+++ /dev/null
@@ -1,164 +0,0 @@
-#########################################################
-# This is a model setup to test the latent heat generation
-# with a single compositional field. The compositional field
-# is vertically stratified across the midpoint.
-# Material flows in from the top and crosses phases
-# transitions. In one of these transitions energy is released
-# and the temperature increases.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 1e15
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. Likewise, composition is only fixed along the upper boundary
-  # where there is inflow. To guarantee a steady downward flow, we fix the
-  # velocity at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = 3
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# Boundary composition derived from initial conditions
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = 3
-  set List of model names = initial composition
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;-2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y>=500000, 1, 0);
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    # The change of density across the phase transitions. Together with the
-    # Clapeyron slope, this is what determines the entropy change. Phase 0
-    # and 1 are reflective of the compositional field values, which are used
-    # to scale density jumps across each the phase transitions. Specifically,
-    # at each point "i" in the model the density jumps are scaled by
-    # (1-composition[i]) (phase 0) or composition[i] (phase 1).
-    set Phase transition density jumps                 = 115.6,115.6
-    set Corresponding phase for density jump           = 0,1
-
-    # No chemical (i.e. not phase transition-related) density change
-    # associated with compositional field
-    set Density differential for compositional field 1 = 0
-
-    # If the temperature is equal to the phase transition temperature, the
-    # phase transition will occur at the phase transition depth. However,
-    # if the temperature deviates from this value, the Clapeyron slope
-    # determines how much the pressure (and depth) of the phase boundary
-    # changes. Here, the phase transitions will be at 1/4 or 1/2 of the
-    # model depth and temperature T=T1. Given that the composition is 0
-    # above 50 km depth and the Clapeyron slope is 0, the first phase
-    # transition should not have any effect.
-    set Phase transition depths                        = 250000, 50000
-    set Phase transition temperatures                  = 1000, 1000
-    set Phase transition Clapeyron slopes              = 0, 1e7
-
-    # We set the width of the phase transition to 20 km. You may want to
-    # change this parameter to see how latent heating depends on the width
-    # of the phase transition.
-    set Phase transition widths                        = 20000, 20000
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 2.38
-
-    # We set the thermal expansion and the compressibility to zero, so that
-    # all temperature (and density) changes are caused by advection, diffusion
-    # and latent heating.
-    set Thermal expansion coefficient                  = 0.0
-    set Compressibility                                = 0.0
-
-    # Viscosity is constant.
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 8.44e21
-    set Viscosity prefactors                           = 1.0, 1.0, 1.0
-    set Composition viscosity prefactor                = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
-
-subsection Heating model
-  set List of model names =  latent heat
-end
diff --git a/tests/latent_heat_enthalpy.cc.bak b/tests/latent_heat_enthalpy.cc.bak
deleted file mode 100644
index fcf5b908d62..00000000000
--- a/tests/latent_heat_enthalpy.cc.bak
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
-  Copyright (C) 2015 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/material_model/interface.h>
-#include <aspect/adiabatic_conditions/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <iostream>
-#include <deal.II/base/quadrature_lib.h>
-#include <memory>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class LatentHeatEnthalpy : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        void
-        initialize()
-        {
-          const std::string datadirectory = Utilities::expand_ASPECT_SOURCE_DIR("$ASPECT_SOURCE_DIR/data/material-model/latent-heat-enthalpy-test/");
-          const std::string material_file_names  = "testdata.txt";
-
-          material_lookup = std::make_unique<MaterialModel::MaterialUtilities::Lookup::PerplexReader>(datadirectory+material_file_names,
-                            true,
-                            this->get_mpi_communicator());
-        }
-
-        bool
-        is_compressible () const
-        {
-          return false;
-        }
-
-        void
-        evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
-        {
-          const double reference_rho              = 3400;
-          const double density_jump               = 115.6;
-          const double reference_T                = 1000;
-          const double eta                        = 8.44e21;
-          const double k_value                    = 2.38;
-          const double reference_specific_heat    = 1000;
-          const double thermal_alpha              = 0;
-
-          double dHdT = 0.0;
-          double dHdp = 0.0;
-
-          if (in.current_cell.state() == IteratorState::valid)
-            {
-              const QTrapezoid<dim> quadrature_formula;
-              const unsigned int n_q_points = quadrature_formula.size();
-
-              FEValues<dim> fe_values (this->get_mapping(),
-                                       this->get_fe(),
-                                       quadrature_formula,
-                                       update_values);
-
-              std::vector<double> temperatures(n_q_points), pressures(n_q_points);
-              std::vector<std::vector<double>> compositions (quadrature_formula.size(),std::vector<double> (this->n_compositional_fields()));
-              std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-
-              fe_values.reinit (in.current_cell);
-
-              // get the various components of the solution, then
-              // evaluate the material properties there
-              fe_values[this->introspection().extractors.temperature]
-              .get_function_values (this->get_solution(), temperatures);
-              fe_values[this->introspection().extractors.pressure]
-              .get_function_values (this->get_solution(), pressures);
-
-              for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                fe_values[this->introspection().extractors.compositional_fields[c]]
-                .get_function_values(this->get_solution(),
-                                     composition_values[c]);
-              for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
-                {
-                  for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                    compositions[q][c] = composition_values[c][q];
-                }
-
-              unsigned int T_points(0),p_points(0);
-
-              for (unsigned int q=0; q<n_q_points; ++q)
-                {
-                  const double own_enthalpy = material_lookup->enthalpy(temperatures[q],pressures[q]);
-                  for (unsigned int p=0; p<n_q_points; ++p)
-                    {
-                      double enthalpy_p,enthalpy_T;
-                      if (std::fabs(temperatures[q] - temperatures[p]) > 100 * std::fabs(temperatures[q]) * std::numeric_limits<double>::epsilon())
-                        {
-                          enthalpy_p = material_lookup->enthalpy(temperatures[p],pressures[q]);
-                          const double point_contribution = (own_enthalpy-enthalpy_p)/(temperatures[q]-temperatures[p]);
-                          dHdT += point_contribution;
-                          T_points++;
-                        }
-                      if (std::fabs(pressures[q] - pressures[p]) > 100 * std::fabs(pressures[q]) * std::numeric_limits<double>::epsilon())
-                        {
-                          enthalpy_T = material_lookup->enthalpy(temperatures[q],pressures[p]);
-                          dHdp += (own_enthalpy-enthalpy_T)/(pressures[q]-pressures[p]);
-                          p_points++;
-                        }
-                    }
-                }
-
-              if ((T_points > 0)
-                  && (p_points > 0))
-                {
-                  dHdT /= T_points;
-                  dHdp /= p_points;
-                }
-            }
-
-          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-            {
-              if (in.requests_property(MaterialProperties::viscosity))
-                out.viscosities[i] = eta;
-
-              out.densities[i] = material_lookup->density(in.temperature[i],in.pressure[i]);
-
-              if (this->get_adiabatic_conditions().is_initialized())
-                {
-                  if ((in.current_cell.state() == IteratorState::valid)
-                      && (std::fabs(dHdp) > 100 * std::numeric_limits<double>::epsilon())
-                      && (std::fabs(dHdT) > 100 * std::numeric_limits<double>::epsilon()))
-                    {
-                      out.thermal_expansion_coefficients[i] = (1 - (reference_rho + density_jump) * dHdp) / in.temperature[i];
-                      out.specific_heat[i] = dHdT;
-                    }
-                  else
-                    {
-                      out.thermal_expansion_coefficients[i] = material_lookup->thermal_expansivity(in.temperature[i],in.pressure[i]);
-                      out.specific_heat[i] = material_lookup->specific_heat(in.temperature[i],in.pressure[i]);
-                    }
-                }
-              else
-                {
-                  out.thermal_expansion_coefficients[i] = (1 - (reference_rho + density_jump) * material_lookup->dHdp(in.temperature[i],in.pressure[i])) / in.temperature[i];
-                  out.specific_heat[i] = material_lookup->dHdT(in.temperature[i],in.pressure[i]);
-                }
-
-              out.thermal_conductivities[i] = k_value;
-            }
-        }
-
-      private:
-        std::unique_ptr<MaterialModel::MaterialUtilities::Lookup::MaterialLookup> material_lookup;
-    };
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(LatentHeatEnthalpy,
-                                   "latent heat enthalpy",
-                                   "A test model that implements a latent "
-                                   "heat formulation based on a lookup table "
-                                   "that is evaluated at the edges of the cell "
-                                   "rather than at the quadrature points.")
-  }
-}
diff --git a/tests/latent_heat_enthalpy.prm.bak b/tests/latent_heat_enthalpy.prm.bak
deleted file mode 100644
index 8989962f2ed..00000000000
--- a/tests/latent_heat_enthalpy.prm.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-#########################################################
-# This is a model setup to test the latent heat generation,
-# similar to the test latent_heat.
-# Material flows in from the top and crosses a phase
-# transition, where energy is released and the temperature
-# increases. The energy release in this model is calculated
-# from a lookup table for enthalpy values and the enthalpy
-# is evaluated at the edges of each cell instead of the
-# quadrature point to catch even very sharp transitions.
-# The steady-state result is around 10 % off the original
-# test, because the data table was created as small as
-# possible.
-# A similar testcase is also described in the latent heat
-# cookbook, and the predicted temperature solution at the
-# bottom of the model is the same (T2 = 1107.39 K).
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 2.5e14
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature          = 1000.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10000
-    set Y extent = 1000000
-    set Y repetitions = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Warning: Merge the parameter in the following subsection with any
-# other parameter of the same name, otherwise your model results might change
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = 3
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;-2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    # In contrast to the other latent heat test we need a small temperature
-    # perturbation to be able to compute derivatives from the material table.
-    # This is because we compute derivatives from the differences between cell
-    # vertices, and if they have identical pressure-temperature conditions, we
-    # can not compute a reasonable derivative
-    set Function expression = 1000.0 + (y-1000000)/1000000
-    set Variable names      = x,y
-  end
-end
-
-# All of the material properties are taken from the table or hard coded
-# in the material model.
-subsection Material model
-  set Model name = latent heat enthalpy
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
diff --git a/tests/latent_heat_melt.prm.bak b/tests/latent_heat_melt.prm.bak
deleted file mode 100644
index 78d88818449..00000000000
--- a/tests/latent_heat_melt.prm.bak
+++ /dev/null
@@ -1,145 +0,0 @@
-#########################################################
-# This is a model setup to test the latent heat generation.
-# Melt flows in from the bottom and crosses a phase
-# transition, where it freezes and energy is released and
-# the temperature increases.
-# The crucial property of the test is the equilibrium
-# temperature at the top of the domain.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 4e16
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Max nonlinear iterations               = 20
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, field2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(z<500000.0,1,0);if(z>500000.,0,1)
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Heating model
-  set List of model names = latent heat melt
-
-  subsection Latent heat melt
-    set Melting entropy change = -300.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-    set Bottom temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Viscosity                     = 8.44e21
-    set Density differential for compositional field 1 = 0
-    set Density differential for compositional field 2 = 0
-    set Reaction depth                = 500000
-    set Reference specific heat       = 1000.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics #, visualization
-
-  subsection Visualization
-    set Interpolate output            = false
-    set List of output variables      = material properties, nonadiabatic temperature
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 2500
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms, specific heat
-    end
-  end
-end
diff --git a/tests/latent_heat_melt_operator_split.prm.bak b/tests/latent_heat_melt_operator_split.prm.bak
deleted file mode 100644
index 6720afee75b..00000000000
--- a/tests/latent_heat_melt_operator_split.prm.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-# This is a model setup to test the latent heat generation.
-# Melt flows in from the bottom and crosses a phase
-# transition, where it freezes and energy is released and
-# the temperature increases.
-# The crucial property of the test is the equilibrium
-# temperature at the top of the domain. This test is the
-# same as the "latent heat melt" test, except that is uses
-# the operator split solver scheme.
-
-# The temperature should be
-# Tbottom + T * DS / C_p * DC
-# with
-# Tbottom = 1000 K (temperature at the bottom)
-# DS      = 300 K/kg (Melting entropy change)
-# C_p     = 1000 J/(kg K)
-# DC      = 1 (change in porosity)
-
-# Since the temperature T changes during the reaction,
-# but the change in porosity occurs instantaneously,
-# this is not a well-defined ODE and we do not use
-# our ODE solver to solve it. Even with the fixed step
-# operator splitting scheme, the solution depends on
-# the number of steps taken. Taking into account this
-# change in temperature, the temperature at the top
-# should be somewhere between 1300 and 1390 K. The more
-# steps we take, the closer it is to the upper value.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 4e16
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Use operator splitting                 = true
-
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction solver type               = fixed step
-    set Reaction time step                 = 4e16
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 20000
-    set Y extent = 1000000
-    set Y repetitions = 50
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, field2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(z<500000.0,1,0);if(z>500000.,0,1)
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Heating model
-  set List of model names = latent heat melt
-
-  subsection Latent heat melt
-    set Melting entropy change = -300.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-    set Bottom temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Viscosity                     = 8.44e21
-    set Density differential for compositional field 1 = 0
-    set Density differential for compositional field 2 = 0
-    set Reaction depth                = 500000
-    set Reference specific heat       = 1000.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-
-  subsection Visualization
-    set Interpolate output            = false
-    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 1e15
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms, specific heat
-    end
-  end
-end
diff --git a/tests/latent_heat_melt_statistics.prm.bak b/tests/latent_heat_melt_statistics.prm.bak
deleted file mode 100644
index 6aa71c38e50..00000000000
--- a/tests/latent_heat_melt_statistics.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-# This test checks if the postprocessor 'melt statistics' works as
-# intended. The statistics output is computed using
-# the melt fraction of peridotite in the melting model of
-# Katz et. al, 2003 (Geochem., Geophys., Geosyst. )
-# with the temperature ranging from 1000°C to 1900°C on the x axis
-# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
-
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9
-    set Y extent = 8
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1100+273.15+x*100
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
-  end
-end
-
-subsection Material model
-  set Model name = latent heat melt
-
-  subsection Latent heat melt
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-    set Mass fraction cpx             = 0.17
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 6
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = melt statistics
-end
diff --git a/tests/latent_heat_melt_transport.prm.bak b/tests/latent_heat_melt_transport.prm.bak
deleted file mode 100644
index ced00b8efe6..00000000000
--- a/tests/latent_heat_melt_transport.prm.bak
+++ /dev/null
@@ -1,162 +0,0 @@
-#########################################################
-# This is a model setup to test the latent heat generation.
-# Melt flows in from the bottom and crosses a phase
-# transition, where it freezes and energy is released and
-# the temperature increases.
-# The crucial property of the test is the equilibrium
-# temperature at the top of the domain. This test is the
-# same as the "latent heat melt" test, except that is uses
-# the operator split solver scheme, and that active melt
-# transport is enabled.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 4e16
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Use operator splitting                     = true
-
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction time step                     = 4e14
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(z<500000.0,1,0);if(z>500000.,0,1)
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Heating model
-  set List of model names = latent heat melt
-
-  subsection Latent heat melt
-    set Melting entropy change = -300.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-    set Bottom temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Reference solid density       = 3300
-    set Reference melt density        = 3299.9
-    set Thermal conductivity          = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Reference shear viscosity     = 8.44e21
-    set Reference specific heat       = 1000.0
-    set Depletion solidus change      = 0.0
-    set Surface solidus               = 2500
-    set Pressure solidus change       = -1e-7
-    set Exponential melt weakening factor = 0.0
-    set Melting time scale for operator splitting = 2.400384061e15
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, visualization
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set Time between graphical output = 2500
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms, specific heat
-    end
-  end
-end
diff --git a/tests/latent_heat_pressure.prm.bak b/tests/latent_heat_pressure.prm.bak
deleted file mode 100644
index 6464db86718..00000000000
--- a/tests/latent_heat_pressure.prm.bak
+++ /dev/null
@@ -1,126 +0,0 @@
-# This is a copy of the latent_heat test that defines the
-# phase transition in terms of pressure instead of depth.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 1e15
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = 3
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;-2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    # The change of density across the phase transition. Together with the
-    # Clapeyron slope, this is what determines the entropy change.
-    set Phase transition density jumps                 = 115.6
-    set Corresponding phase for density jump           = 0
-
-    # If the temperature is equal to the phase transition temperature, the
-    # phase transition will occur at the phase transition depth. However,
-    # if the temperature deviates from this value, the Clapeyron slope
-    # determines how much the pressure (and depth) of the phase boundary
-    # changes. Here, the phase transition will be in the middle of the box
-    # for T=T1.
-    set Phase transition pressures                     = 1.7e10
-    set Phase transition pressure widths               = 6.8e8
-    set Define transition by depth instead of pressure = false
-    set Phase transition temperatures                  = 1000
-    set Phase transition Clapeyron slopes              = 1e7
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 2.38
-
-    # We set the thermal expansion and the compressibility to zero, so that
-    # all temperature (and density) changes are caused by advection, diffusion
-    # and latent heating.
-    set Thermal expansion coefficient                  = 0.0
-    set Compressibility                                = 0.0
-
-    # Viscosity is constant.
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 8.44e21
-    set Viscosity prefactors                           = 1.0, 1.0
-    set Composition viscosity prefactor                = 1.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
-
-subsection Heating model
-  set List of model names =  latent heat
-end
diff --git a/tests/latent_heat_viscosity.prm.bak b/tests/latent_heat_viscosity.prm.bak
deleted file mode 100644
index 2253cc4b4ad..00000000000
--- a/tests/latent_heat_viscosity.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-# A simple setup for for using the GPlates interface in a 2d shell
-# with the latent heat material model. It tests the feature of the
-# latent heat material model to use a layered viscosity profile.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 3e8
-set Output directory                       = output_energy_density
-set Adiabatic surface temperature          = 1600
-set Resume computation                     = false
-
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    set Viscosity                     = 1e21
-    set Thermal viscosity exponent    = 15.0
-    set Reference temperature         = 1600
-
-    # 'background' or 'all' are identical identifiers, because there is just
-    # background material
-    set Phase transition depths           = all:410000|660000
-    set Phase transition widths           = background:20000|20000
-    set Phase transition temperatures     = all:1600|1600
-    set Phase transition Clapeyron slopes = all:3e6|-2e6
-    set Phase transition density jumps    = 100, 200
-    set Corresponding phase for density jump = 0, 0
-    set Viscosity prefactors          = 1, 10, 100
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = outer:gplates
-  set Tangential velocity boundary indicators = inner
-
-  subsection GPlates model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-velocity/gplates/
-    set Velocity file name = current_day.gpml
-    set Data file time step = 1e6
-    set Point one = 1.5708,4.87
-    set Point two = 1.5708,5.24
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 5e7
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Refinement fraction                = 0.8
-  set Coarsening fraction                = 0.05
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 5
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-    set List of output variables      = material properties
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint  = 1800
-end
-
-subsection Termination criteria
-  set End step = 1
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-end
diff --git a/tests/latent_heat_viscosity_adiabatic.prm.bak b/tests/latent_heat_viscosity_adiabatic.prm.bak
deleted file mode 100644
index 7d99b8b9df5..00000000000
--- a/tests/latent_heat_viscosity_adiabatic.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# A modification of the latent heat viscosity test, but with adiabatic heating.
-# It tests that the viscosity of the different layers is constant.
-# The gnuplot output illustrates the viscosity increase at 410 and 660 km depth.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    set Viscosity                     = 1e21
-    set Thermal viscosity exponent    = 15.0
-    set Reference temperature         = 1600
-
-    # 'background' or 'all' are identical identifiers, because there is just
-    # background material
-    set Phase transition depths           = all:410000|660000
-    set Phase transition widths           = background:20000|20000
-    set Phase transition temperatures     = all:1600|1600
-    set Phase transition Clapeyron slopes = all:3e6|-2e6
-    set Phase transition density jumps    = 100, 200
-    set Corresponding phase for density jump = 0, 0
-    set Viscosity prefactors          = 1, 10, 100
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, outer, left, right
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer = 0
-    set Age bottom boundary layer = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-    set List of output variables      = material properties
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-    set Number of zones = 25
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint  = 1800
-end
diff --git a/tests/lithosphere_boundary_indicator.prm.bak b/tests/lithosphere_boundary_indicator.prm.bak
deleted file mode 100644
index 0345ba01730..00000000000
--- a/tests/lithosphere_boundary_indicator.prm.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-# With this geometry model we add 2 additional boundary
-# indicators to the lithospheric part of the left and right
-# boundary.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-# We use a boundary temperature model
-# with additional boundary indicators
-# as prescribed by the geometry model
-# In 2D the additional boundary indicators have value 4 (left lithosphere)
-# and 5 (right lithosphere). Because we want flow through these boundaries
-# we set fixed temperature and composition boundary conditions.
-# For now we set the lower part of the vertical boundaries to
-# zero velocity, while prescribing a velocity function on boundary
-# 4 and 5. Note that this particular example can be accomplished
-# without additional boundary indicators and just prescribing a
-# velocity function on the whole vertical boundaries.
-# Along the top and the lithospheric part of the vertical boundaries
-# we prescribe a plate velocity of 1 cm/year.
-
-subsection Boundary temperature model
-  set List of model names = box with lithosphere boundary indicators
-  set Fixed temperature boundary indicators   = 0, 1, 4, 5
-
-  subsection Box with lithosphere boundary indicators
-    set Left temperature = 0
-  end
-end
-
-# We use the initial composition
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0, 1, 4, 5
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = box with lithosphere boundary indicators
-
-  subsection Box with lithosphere boundary indicators
-    set X extent = 1000000
-    set Y extent = 600000
-    set Lithospheric thickness = 80000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-# We prescribe one compositional field
-# to represent the lithosphere
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities                  = 3300,3250
-    set Reference temperature      = 293
-    set Specific heats             = 1250
-    set Thermal conductivities     = 0.
-    set Thermal expansivities      = 0.
-    set Viscosities                = 1e20,1e21
-    set Viscosity averaging scheme = harmonic
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function, 4: function, 5: function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = lith_depth=8e4, model_height=6e5
-    set Function expression = if(z>(model_height-lith_depth),0.01,0);0
-  end
-end
-
-# The lithosphere is represented by a lower density,
-# higher viscosity compositional field.
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z
-    set Function constants = lith_depth=8e4, model_height=6e5
-    set Function expression = if((model_height-z)<lith_depth,1,0)
-  end
-end
-
-# We look at the velocity and pressure statistics. Max velocity will be
-# the prescribed velocity of 1 cm/year. The boundary indicator
-# visualization shows us the indicators we set at the boundaries.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format            = gnuplot
-    set List of output variables = boundary indicators
-  end
-end
diff --git a/tests/lithosphere_boundary_indicator_3d.prm.bak b/tests/lithosphere_boundary_indicator_3d.prm.bak
deleted file mode 100644
index 89a2e7aec72..00000000000
--- a/tests/lithosphere_boundary_indicator_3d.prm.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-# With this geometry model we add 4 additional boundary
-# indicators to the lithospheric part of the left, right,
-# front and back boundaries (i.e. all vertical boundaries).
-
-set Dimension                              = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-# We use a boundary temperature model
-# with additional boundary indicators
-# as prescribed by the geometry model
-# In 3D the additional boundary indicators have value 6 (left lithosphere),
-# 7 (right lithosphere), 8 (front lithosphere) and 9 (back lithosphere).
-# Because we want flow through these boundaries
-# we set fixed temperature and composition boundary conditions.
-# For now we set the lower part of the vertical boundaries to
-# zero velocity, while prescribing a velocity function on boundary
-# 6, 7, 8 and 9. Note that this particular example can be accomplished
-# without additional boundary indicators and just prescribing a
-# velocity function on the whole vertical boundaries.
-# Along the top boundary and the lithospheric part of the vertical
-# boundaries, we prescribe a plate velocity of 1 cm/year.
-
-subsection Boundary temperature model
-  set List of model names = box with lithosphere boundary indicators
-  set Fixed temperature boundary indicators   = 0, 1, 6, 7, 8, 9
-
-  subsection Box with lithosphere boundary indicators
-    set Left temperature = 0
-  end
-end
-
-# We use the initial composition
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0, 1, 6, 7, 8, 9
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = box with lithosphere boundary indicators
-
-  subsection Box with lithosphere boundary indicators
-    set X extent = 1000000
-    set Y extent = 600000
-    set Z extent = 600000
-    set Lithospheric thickness = 80000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-# We prescribe one compositional field
-# to represent the lithosphere
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities                  = 3300,3250
-    set Reference temperature      = 293
-    set Specific heats             = 1250
-    set Thermal conductivities     = 0.
-    set Thermal expansivities      = 0.
-    set Viscosities                = 1e20,1e21
-    set Viscosity averaging scheme = harmonic
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1, 4
-  set Tangential velocity boundary indicators = 2, 3
-  set Prescribed velocity boundary indicators = 5: function, 6: function, 7: function, 8:function, 9:function
-
-  subsection Function
-    set Variable names = x,y,z
-    set Function constants = lith_depth=8e4, model_height=6e5
-    set Function expression = if(z>(model_height-lith_depth),0.01,0);0;0
-  end
-end
-
-# The lithosphere is represented by a lower density,
-# higher viscosity compositional field.
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y,z
-    set Function constants = lith_depth=8e4, model_height=6e5
-    set Function expression = if((model_height-z)<lith_depth,1,0)
-  end
-end
-
-# We look at the velocity and pressure statistics. Max velocity will be
-# the prescribed velocity of 1 cm/year. The boundary indicator
-# visualization shows us the indicators we set at the boundaries.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format            = gnuplot
-    set List of output variables = boundary indicators
-  end
-end
diff --git a/tests/lithosphere_boundary_indicator_3d_one_grid.prm.bak b/tests/lithosphere_boundary_indicator_3d_one_grid.prm.bak
deleted file mode 100644
index 94882566152..00000000000
--- a/tests/lithosphere_boundary_indicator_3d_one_grid.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# exactly the same as lithosphere_boundary_indicator_3d.prm but made with one grid
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/tests/lithosphere_boundary_indicator_3d.prm
-
-
-subsection Geometry model
-  subsection Box with lithosphere boundary indicators
-    set Use merged grids = false
-    set Z repetitions = 2
-  end
-end
diff --git a/tests/lithosphere_boundary_indicator_3d_periodic.prm.bak b/tests/lithosphere_boundary_indicator_3d_periodic.prm.bak
deleted file mode 100644
index 863549dc665..00000000000
--- a/tests/lithosphere_boundary_indicator_3d_periodic.prm.bak
+++ /dev/null
@@ -1,152 +0,0 @@
-# With this geometry model we add 4 additional boundary
-# indicators to the lithospheric part of the left, right,
-# front and back boundaries (i.e. all vertical boundaries).
-# This prm tests the periodic boundary condition for
-# the front and back additional boundaries.
-
-set Dimension                              = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-# We use a boundary temperature model
-# with additional boundary indicators
-# as prescribed by the geometry model.
-# Inflow occurs along the left top
-# boundary, so we prescribe temperature
-# there.
-# In 3D the additional boundary indicators have value 6 (left lithosphere),
-# 7 (right lithosphere), 8 (front lithosphere) and 9 (back lithosphere).
-# We prescribe a velocity field oblique to all vertical boundaries
-# (so in the X- and Y-direction) to the left and right lithosphere
-# and the top boundary.
-# Boundaries with inflow that are not periodic get a prescribed
-# temperature and composition.
-# The mantle velocity is restricted to tangential only.
-subsection Boundary temperature model
-  set List of model names = box with lithosphere boundary indicators
-  set Fixed temperature boundary indicators   = 6
-
-  subsection Box with lithosphere boundary indicators
-    set Left temperature lithosphere = 0
-    set Front temperature lithosphere = 0
-  end
-end
-
-# We use the initial composition as boundary
-# condition.
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 6
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-# We create a rectangular domain with additional
-# boundary indicators for the lithospheric part
-# of the vertical boundaries.
-# We use the repetitions to get the same resolution
-# in the lithosphere and mantle.
-# The lithospheric boundaries normal to the
-# Y-direction are periodic.
-subsection Geometry model
-  set Model name = box with lithosphere boundary indicators
-
-  subsection Box with lithosphere boundary indicators
-    set X extent = 600000
-    set Y extent = 1200000
-    set Z extent = 600000
-    set Lithospheric thickness = 100000
-    set X repetitions = 6
-    set Y repetitions = 12
-    set Z repetitions = 5
-    set Y periodic lithosphere = true
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-# We prescribe one compositional field
-# to represent the lithosphere as a
-# less dense, more viscous material.
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities                  = 3300,3250
-    set Reference temperature      = 293
-    set Specific heats             = 1250
-    set Thermal conductivities     = 0.
-    set Thermal expansivities      = 0.
-    set Viscosities                = 1e20,1e21
-    set Viscosity averaging scheme = harmonic
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3, 4
-  set Prescribed velocity boundary indicators = 5: function, 6:function, 7:function
-
-  # On the lithospheric part of the boundary,
-  # prescribe a velocity in the X- and Y-direction [m/yr].
-  subsection Function
-    set Variable names = x,y,z
-    set Function constants = lith_depth=100e3, model_height=600e3
-    set Function expression = if(z>(model_height-lith_depth),0.005,0); \
-                              if(z>(model_height-lith_depth),0.005,0); \
-                              0
-  end
-end
-
-# The lithosphere is represented by a lower density,
-# higher viscosity compositional field.
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-# The lithosphere is 100 km thick.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y,z
-    set Function constants = lith_depth=100e3, model_height=600e3
-    set Function expression = if((model_height-z)<lith_depth,1,0)
-  end
-end
-
-# We look at the velocity statistics. Max velocity will be
-# the prescribed velocity of 0.71 cm/year. The boundary indicator
-# visualization shows us the indicators we set at the boundaries.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format            = gnuplot
-    set List of output variables = boundary indicators
-  end
-end
diff --git a/tests/lithosphere_boundary_indicator_one_grid.prm.bak b/tests/lithosphere_boundary_indicator_one_grid.prm.bak
deleted file mode 100644
index 8bec08e2ea2..00000000000
--- a/tests/lithosphere_boundary_indicator_one_grid.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# exactly the same as lithosphere_boundary_indicator.prm but made with one grid
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/lithosphere_boundary_indicator.prm
-
-
-subsection Geometry model
-  subsection Box with lithosphere boundary indicators
-    set Use merged grids = false
-    set Y repetitions = 2
-  end
-end
diff --git a/tests/lithosphere_boundary_indicator_origin.prm.bak b/tests/lithosphere_boundary_indicator_origin.prm.bak
deleted file mode 100644
index 51ae8f6df9e..00000000000
--- a/tests/lithosphere_boundary_indicator_origin.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-# With this geometry model we add 2 additional boundary
-# indicators to the lithospheric part of the left and right
-# boundary.
-# This test is for a nonzero box Y origin.
-
-include $ASPECT_SOURCE_DIR/tests/lithosphere_boundary_indicator.prm
-
-
-subsection Geometry model
-  set Model name = box with lithosphere boundary indicators
-
-  subsection Box with lithosphere boundary indicators
-    set Box origin Y coordinate = 300000
-  end
-end
diff --git a/tests/logo.prm.bak b/tests/logo.prm.bak
deleted file mode 100644
index da18e118eca..00000000000
--- a/tests/logo.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-# A test for the model that produces the ASPECT logo.
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/doc/logo/logo.prm
-
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 1
-end
diff --git a/tests/magnetic_stripes.cc.bak b/tests/magnetic_stripes.cc.bak
deleted file mode 100644
index 7f2aa2f7ae6..00000000000
--- a/tests/magnetic_stripes.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../cookbooks/magnetic_stripes/magnetic_stripes.cc"
diff --git a/tests/magnetic_stripes.prm.bak b/tests/magnetic_stripes.prm.bak
deleted file mode 100644
index 0c769b454f5..00000000000
--- a/tests/magnetic_stripes.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-include $ASPECT_SOURCE_DIR/cookbooks/magnetic_stripes/magnetic_stripes.prm
-
-set Dimension = 2
-set End time = 0
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 0
-end
diff --git a/tests/mass_flux_statistics.prm.bak b/tests/mass_flux_statistics.prm.bak
deleted file mode 100644
index 0d62c7ea7bb..00000000000
--- a/tests/mass_flux_statistics.prm.bak
+++ /dev/null
@@ -1,44 +0,0 @@
-# Test to check the status of the mass flux statistics postprocessor.
-# Simple model with prescribed flux through the boundaries.
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set End time                               = 0
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-end
-
-subsection Material model
-  set Model name = simpler
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left:function,right:function,top:function,bottom:function
-
-  subsection Function
-    set Function expression = 1;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics
-end
diff --git a/tests/mass_reaction_term.prm.bak b/tests/mass_reaction_term.prm.bak
deleted file mode 100644
index d8e75194e40..00000000000
--- a/tests/mass_reaction_term.prm.bak
+++ /dev/null
@@ -1,173 +0,0 @@
-#########################################################
-# This is a model setup to test the term on the right-hand
-# side of the mass conservation in models with melt
-# transport that describes the change in volume associated
-# with melting and freezing reactions.
-# Melt flows in from the bottom and crosses a phase
-# transition, where it freezes and changes the velocity.
-# The crucial property of the test is the maximum velocity
-# (at the bottom of the domain), which should be close to
-# 2.4e-11 m/s.
-#
-# This is because upon melting, the density changes from
-# 3000 kg/m3 to 2500 kg/m3, so the velocity increases from
-# 2e-11 m/s to
-#
-# 2e-11 m/s * 3000/2500 = 2.4e-11 m/s.
-#
-# This test is similar to the
-# "latent heat melt transport" test, except that it has a
-# zero permeability and latent heat, and slightly different
-# material properties and geometry.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 2.6e16
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Use operator splitting                 = true
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 25000
-    set Y extent = 1000000
-    set Y repetitions = 40
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(z<500000.0,1,0);if(z>500000.,0,1)
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Heating model
-  set List of model names = latent heat melt
-
-  subsection Latent heat melt
-    set Melting entropy change = 0.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-    set Bottom temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;2.e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Reference solid density       = 3000
-    set Reference melt density        = 2500
-    set Thermal conductivity          = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Reference shear viscosity     = 8.44e28
-    set Reference specific heat       = 1000.0
-    set Depletion solidus change      = 0.0
-    set Surface solidus               = 2500
-    set Pressure solidus change       = -1e-7
-    set Exponential melt weakening factor = 0.0
-    set Melting time scale for operator splitting = 2.400384061e15
-    set Reference permeability        = 1e-25
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, named additional outputs, melt material properties
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set Time between graphical output = 2500
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms, specific heat
-    end
-
-    subsection Melt material properties
-      set List of properties = is melt cell
-    end
-  end
-end
diff --git a/tests/material_model_dependencies.cc.bak b/tests/material_model_dependencies.cc.bak
deleted file mode 100644
index 964c157b518..00000000000
--- a/tests/material_model_dependencies.cc.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// A postprocessor that simply outputs which of the output variables
-// of the material model depends on the input variables
-
-#include <aspect/postprocess/interface.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    class MaterialModelDependencies : public Interface<dim>,
-      public SimulatorAccess<dim>
-    {
-      public:
-        virtual
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics)
-        {
-          using namespace MaterialModel;
-          using namespace NonlinearDependence;
-
-          const aspect::MaterialModel::Interface<dim> &model
-            = this->get_material_model();
-          std::cout << "viscosity depends on"
-                    << ((model.get_model_dependence().viscosity & MaterialModel::NonlinearDependence::pressure)
-                        ?
-                        " pressure" : "")
-                    << ((model.get_model_dependence().viscosity & MaterialModel::NonlinearDependence::temperature)
-                        ?
-                        " temperature" : "")
-                    << ((model.get_model_dependence().viscosity & MaterialModel::NonlinearDependence::strain_rate)
-                        ?
-                        " strainrate" : "")
-                    << ((model.get_model_dependence().viscosity & MaterialModel::NonlinearDependence::compositional_fields)
-                        ?
-                        " composition" : "")
-                    << std::endl;
-          std::cout << "density depends on"
-                    << ((model.get_model_dependence().density & MaterialModel::NonlinearDependence::pressure)
-                        ?
-                        " pressure" : "")
-                    << ((model.get_model_dependence().density & MaterialModel::NonlinearDependence::temperature)
-                        ?
-                        " temperature" : "")
-                    << ((model.get_model_dependence().density & MaterialModel::NonlinearDependence::strain_rate)
-                        ?
-                        " strainrate" : "")
-                    << ((model.get_model_dependence().density & MaterialModel::NonlinearDependence::compositional_fields)
-                        ?
-                        " composition" : "")
-                    << std::endl;
-          std::cout << "compressibility depends on"
-                    << ((model.get_model_dependence().compressibility & MaterialModel::NonlinearDependence::pressure)
-                        ?
-                        " pressure" : "")
-                    << ((model.get_model_dependence().compressibility & MaterialModel::NonlinearDependence::temperature)
-                        ?
-                        " temperature" : "")
-                    << ((model.get_model_dependence().compressibility & MaterialModel::NonlinearDependence::strain_rate)
-                        ?
-                        " strainrate" : "")
-                    << ((model.get_model_dependence().compressibility & MaterialModel::NonlinearDependence::compositional_fields)
-                        ?
-                        " composition" : "")
-                    << std::endl;
-          std::cout << "specific_heat depends on"
-                    << ((model.get_model_dependence().specific_heat & MaterialModel::NonlinearDependence::pressure)
-                        ?
-                        " pressure" : "")
-                    << ((model.get_model_dependence().specific_heat & MaterialModel::NonlinearDependence::temperature)
-                        ?
-                        " temperature" : "")
-                    << ((model.get_model_dependence().specific_heat & MaterialModel::NonlinearDependence::strain_rate)
-                        ?
-                        " strainrate" : "")
-                    << ((model.get_model_dependence().specific_heat & MaterialModel::NonlinearDependence::compositional_fields)
-                        ?
-                        " composition" : "")
-                    << std::endl;
-          std::cout << "thermal_conductivity depends on"
-                    << ((model.get_model_dependence().thermal_conductivity & MaterialModel::NonlinearDependence::pressure)
-                        ?
-                        " pressure" : "")
-                    << ((model.get_model_dependence().thermal_conductivity & MaterialModel::NonlinearDependence::temperature)
-                        ?
-                        " temperature" : "")
-                    << ((model.get_model_dependence().thermal_conductivity & MaterialModel::NonlinearDependence::strain_rate)
-                        ?
-                        " strainrate" : "")
-                    << ((model.get_model_dependence().thermal_conductivity & MaterialModel::NonlinearDependence::compositional_fields)
-                        ?
-                        " composition" : "")
-                    << std::endl;
-          std::cout << "model is "
-                    << (model.is_compressible() ? "compressible" : "incompressible")
-                    << std::endl;
-          return std::pair<std::string,std::string>();
-        }
-    };
-  }
-}
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(MaterialModelDependencies,
-                                  "material model dependencies",
-                                  ".")
-  }
-}
diff --git a/tests/material_model_dependencies_burstedde.cc.bak b/tests/material_model_dependencies_burstedde.cc.bak
deleted file mode 100644
index 0ff8f448846..00000000000
--- a/tests/material_model_dependencies_burstedde.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
-#include "burstedde.cc"
diff --git a/tests/material_model_dependencies_burstedde.prm.bak b/tests/material_model_dependencies_burstedde.prm.bak
deleted file mode 100644
index 2d755cdd7db..00000000000
--- a/tests/material_model_dependencies_burstedde.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-#############################
-# Otherwise use the setup of burstedde
-
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-
-subsection Material model
-  set Model name = BursteddeMaterial
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-############### Parameters describing the model
-# The setup is a 3d unit cube.
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-    set Z extent  = 1
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:BursteddeBoundary, 1: BursteddeBoundary, 2: BursteddeBoundary, 3: BursteddeBoundary, 4: BursteddeBoundary, 5: BursteddeBoundary
-end
-
-subsection Gravity model
-  set Model name = BursteddeGravity
-end
-
-subsection Burstedde benchmark
-  #Viscosity parameter is beta
-  set Viscosity parameter             = 20
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/material_model_dependencies_composition_reaction.cc.bak b/tests/material_model_dependencies_composition_reaction.cc.bak
deleted file mode 100644
index d46e5b4ae6a..00000000000
--- a/tests/material_model_dependencies_composition_reaction.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_composition_reaction.prm.bak b/tests/material_model_dependencies_composition_reaction.prm.bak
deleted file mode 100644
index 87b199c2e50..00000000000
--- a/tests/material_model_dependencies_composition_reaction.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = composition reaction
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_cookbooks_freesurface_with_crust.cc.bak b/tests/material_model_dependencies_cookbooks_freesurface_with_crust.cc.bak
deleted file mode 100644
index eb67e33f19f..00000000000
--- a/tests/material_model_dependencies_cookbooks_freesurface_with_crust.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
-#include "cookbook_simpler_with_crust.cc"
diff --git a/tests/material_model_dependencies_cookbooks_freesurface_with_crust.prm.bak b/tests/material_model_dependencies_cookbooks_freesurface_with_crust.prm.bak
deleted file mode 100644
index 95a3a537270..00000000000
--- a/tests/material_model_dependencies_cookbooks_freesurface_with_crust.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = simpler with crust
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_diffusion_dislocation.cc.bak b/tests/material_model_dependencies_diffusion_dislocation.cc.bak
deleted file mode 100644
index d46e5b4ae6a..00000000000
--- a/tests/material_model_dependencies_diffusion_dislocation.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_diffusion_dislocation.prm.bak b/tests/material_model_dependencies_diffusion_dislocation.prm.bak
deleted file mode 100644
index 167ab526e75..00000000000
--- a/tests/material_model_dependencies_diffusion_dislocation.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-#############################
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 293
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-# This parameter file implements an initial temperature of 293 K + x,
-# where x is the fraction of the box width, in a 2D box of size 1x1.
-
-subsection Material model
-  set Model name = diffusion dislocation
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 293 + x
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_inclusion_2.cc.bak b/tests/material_model_dependencies_inclusion_2.cc.bak
deleted file mode 100644
index 8f9cb601c42..00000000000
--- a/tests/material_model_dependencies_inclusion_2.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
-#include "../benchmarks/inclusion/inclusion.cc"
diff --git a/tests/material_model_dependencies_inclusion_2.prm.bak b/tests/material_model_dependencies_inclusion_2.prm.bak
deleted file mode 100644
index 05684012fd3..00000000000
--- a/tests/material_model_dependencies_inclusion_2.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = InclusionMaterial
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_latent_heat.cc.bak b/tests/material_model_dependencies_latent_heat.cc.bak
deleted file mode 100644
index d46e5b4ae6a..00000000000
--- a/tests/material_model_dependencies_latent_heat.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_latent_heat.prm.bak b/tests/material_model_dependencies_latent_heat.prm.bak
deleted file mode 100644
index 9a109540bf3..00000000000
--- a/tests/material_model_dependencies_latent_heat.prm.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = latent heat
-
-  subsection Latent heat
-    # The change of density across the phase transition. Together with the
-    # Clapeyron slope, this is what determines the entropy change.
-    set Phase transition density jumps                 = 115.6
-    set Corresponding phase for density jump           = 0
-
-    # If the temperature is equal to the phase transition temperature, the
-    # phase transition will occur at the phase transition depth. However,
-    # if the temperature deviates from this value, the Clapeyron slope
-    # determines how much the pressure (and depth) of the phase boundary
-    # changes. Here, the phase transition will be in the middle of the box
-    # for T=T1.
-    set Phase transition depths                        = 500000
-    set Phase transition temperatures                  = 1000
-    set Phase transition Clapeyron slopes              = 1e7
-
-    # We set the width of the phase transition to 5 km. You may want to
-    # change this parameter to see how latent heating depends on the width
-    # of the phase transition.
-    set Phase transition widths                        = 5000
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 2.38
-
-    # We set the thermal expansion and the compressibility to zero, so that
-    # all temperature (and density) changes are caused by advection, diffusion
-    # and latent heating.
-    set Thermal expansion coefficient                  = 0.0
-    set Compressibility                                = 0.0
-
-    # Viscosity is constant.
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 8.44e21
-    set Viscosity prefactors                           = 1.0, 1.0
-    set Composition viscosity prefactor                = 1.0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_latent_heat_melt.cc.bak b/tests/material_model_dependencies_latent_heat_melt.cc.bak
deleted file mode 100644
index d46e5b4ae6a..00000000000
--- a/tests/material_model_dependencies_latent_heat_melt.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_latent_heat_melt.prm.bak b/tests/material_model_dependencies_latent_heat_melt.prm.bak
deleted file mode 100644
index 9be8b097444..00000000000
--- a/tests/material_model_dependencies_latent_heat_melt.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = latent heat melt
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_morency_doin.cc.bak b/tests/material_model_dependencies_morency_doin.cc.bak
deleted file mode 100644
index ed70eab2cff..00000000000
--- a/tests/material_model_dependencies_morency_doin.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
-#include "../cookbooks/morency_doin_2004/morency_doin.h"
-#include "../cookbooks/morency_doin_2004/morency_doin.cc"
diff --git a/tests/material_model_dependencies_morency_doin.prm.bak b/tests/material_model_dependencies_morency_doin.prm.bak
deleted file mode 100644
index d63aef97e65..00000000000
--- a/tests/material_model_dependencies_morency_doin.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = Morency and Doin
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_multicomponent.cc.bak b/tests/material_model_dependencies_multicomponent.cc.bak
deleted file mode 100644
index d46e5b4ae6a..00000000000
--- a/tests/material_model_dependencies_multicomponent.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_multicomponent.prm.bak b/tests/material_model_dependencies_multicomponent.prm.bak
deleted file mode 100644
index 62c8f1eadeb..00000000000
--- a/tests/material_model_dependencies_multicomponent.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = multicomponent
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_shear_thinning.cc.bak b/tests/material_model_dependencies_shear_thinning.cc.bak
deleted file mode 100644
index 2185180aca7..00000000000
--- a/tests/material_model_dependencies_shear_thinning.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
-#include "shear_thinning.cc"
diff --git a/tests/material_model_dependencies_shear_thinning.prm.bak b/tests/material_model_dependencies_shear_thinning.prm.bak
deleted file mode 100644
index 4504e5cccac..00000000000
--- a/tests/material_model_dependencies_shear_thinning.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = shear thinning
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_simple.cc.bak b/tests/material_model_dependencies_simple.cc.bak
deleted file mode 100644
index d46e5b4ae6a..00000000000
--- a/tests/material_model_dependencies_simple.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_simple.prm.bak b/tests/material_model_dependencies_simple.prm.bak
deleted file mode 100644
index 435f180cf11..00000000000
--- a/tests/material_model_dependencies_simple.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_simple_compressible.cc.bak b/tests/material_model_dependencies_simple_compressible.cc.bak
deleted file mode 100644
index d46e5b4ae6a..00000000000
--- a/tests/material_model_dependencies_simple_compressible.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_simple_compressible.prm.bak b/tests/material_model_dependencies_simple_compressible.prm.bak
deleted file mode 100644
index 4ce17012d8b..00000000000
--- a/tests/material_model_dependencies_simple_compressible.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = simple compressible
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_simpler.cc.bak b/tests/material_model_dependencies_simpler.cc.bak
deleted file mode 100644
index d46e5b4ae6a..00000000000
--- a/tests/material_model_dependencies_simpler.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_simpler.prm.bak b/tests/material_model_dependencies_simpler.prm.bak
deleted file mode 100644
index 4de064b0472..00000000000
--- a/tests/material_model_dependencies_simpler.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = simpler
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_solcx.cc.bak b/tests/material_model_dependencies_solcx.cc.bak
deleted file mode 100644
index feab596941d..00000000000
--- a/tests/material_model_dependencies_solcx.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/material_model_dependencies_solcx.prm.bak b/tests/material_model_dependencies_solcx.prm.bak
deleted file mode 100644
index 38790f176ce..00000000000
--- a/tests/material_model_dependencies_solcx.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_solkz.cc.bak b/tests/material_model_dependencies_solkz.cc.bak
deleted file mode 100644
index 2bd3f8ef1f0..00000000000
--- a/tests/material_model_dependencies_solkz.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/material_model_dependencies_solkz.prm.bak b/tests/material_model_dependencies_solkz.prm.bak
deleted file mode 100644
index 008105c3983..00000000000
--- a/tests/material_model_dependencies_solkz.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_steinberger.cc.bak b/tests/material_model_dependencies_steinberger.cc.bak
deleted file mode 100644
index d46e5b4ae6a..00000000000
--- a/tests/material_model_dependencies_steinberger.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
diff --git a/tests/material_model_dependencies_steinberger.prm.bak b/tests/material_model_dependencies_steinberger.prm.bak
deleted file mode 100644
index dc1126d1a9b..00000000000
--- a/tests/material_model_dependencies_steinberger.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-#############################
-# Otherwise use a mixture of the setup of SolCX and steinberger-viscosity
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = testdata.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_model_dependencies_tangurnis.cc.bak b/tests/material_model_dependencies_tangurnis.cc.bak
deleted file mode 100644
index 0b2bc1198d0..00000000000
--- a/tests/material_model_dependencies_tangurnis.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "material_model_dependencies.cc"
-#include "tangurnis.cc"
diff --git a/tests/material_model_dependencies_tangurnis.prm.bak b/tests/material_model_dependencies_tangurnis.prm.bak
deleted file mode 100644
index b405aff9383..00000000000
--- a/tests/material_model_dependencies_tangurnis.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-#############################
-# Otherwise use the setup of SolCX
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# Evaluate the nonlinear dependencies of the material model used here
-
-subsection Material model
-  set Model name = Tan Gurnis
-
-  subsection Tan Gurnis model
-    set Di                            = 0.5
-    set gamma                         = 1
-    set a                             = 0
-    set wavenumber                    = 1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = material model dependencies
-end
-
-subsection Formulation
-  set Formulation = anelastic liquid approximation
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Heating model
-  set List of model names = shear heating, adiabatic heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
diff --git a/tests/material_statistics.prm.bak b/tests/material_statistics.prm.bak
deleted file mode 100644
index 171fbca9ab1..00000000000
--- a/tests/material_statistics.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# This is a benchmark to check that the 'Material statistics'
-# postprocessor works correctly. It creates a model with lateral
-# flow. The density in the model is constant and the volume is known,
-# so it is easy to compute the expected output. Over time material
-# with a different density flows in until it fills the whole domain.
-
-set Dimension = 2
-set End time                               = 1e8
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Y extent = 100000
-    set X extent = 100000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = left
-  set List of model names = function
-
-  subsection Function
-    set Function expression = (t<1e7) ? 1600 + (t / 1e7) * 1000 : 2600
-  end
-end
-
-# To guarantee a steady rightward flow, we fix the velocity
-# at the left and right, and set it to free slip on the top and bottom.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left:function, right:function
-  set Tangential velocity boundary indicators = bottom,top
-
-  subsection Function
-    set Function expression = 1e-2;0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3300
-    set Reference temperature = 1600
-    set Thermal expansion coefficient = 1e-4
-    set Thermal conductivity = 0.0
-    set Viscosity = 1e21
-
-    # This was computed to correspond to a viscosity decrease of one order
-    # of magnitude over a temperature increase of 1000 K for a reference
-    # viscosity of 1e21 Pas and a reference temperature of 1600 K.
-    set Thermal viscosity exponent = 3.684136149
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = material statistics
-end
diff --git a/tests/matrix_nonzeros_1.prm.bak b/tests/matrix_nonzeros_1.prm.bak
deleted file mode 100644
index 3241fd0830a..00000000000
--- a/tests/matrix_nonzeros_1.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# Tests whether the 'matrix statistics' postprocessor outputs correctly on a
-# minimal problem with conforming Stokes and composition, and dG temperature FE
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.3
-    set Y extent = 2.2
-    set Z extent = 1.1
-    set Box origin X coordinate = -1.9
-    set Box origin Y coordinate = 2.5
-    set Box origin Z coordinate = 3.1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Discretization
-  set Use discontinuous temperature discretization = true
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = matrix statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/matrix_nonzeros_2.prm.bak b/tests/matrix_nonzeros_2.prm.bak
deleted file mode 100644
index 8011414d377..00000000000
--- a/tests/matrix_nonzeros_2.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# Do matrix_nonzeros output for varying advection methods to ensure correct behavior
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.3
-    set Y extent = 2.2
-    set Z extent = 1.1
-    set Box origin X coordinate = -1.9
-    set Box origin Y coordinate = 2.5
-    set Box origin Z coordinate = 3.1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = adv_field, adv_particle
-  set Compositional field methods = field, particles
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0; 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = matrix statistics, particles
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-  set Interpolation scheme = cell average
-  set Update ghost particles = true
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 100
-    end
-  end
-end
diff --git a/tests/matrix_nonzeros_3.prm.bak b/tests/matrix_nonzeros_3.prm.bak
deleted file mode 100644
index 92a56f04d8e..00000000000
--- a/tests/matrix_nonzeros_3.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-# Do matrix_nonzeros output for varying advection methods assuming
-# discontinuous composition to ensure correct behavior
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.3
-    set Y extent = 2.2
-    set Z extent = 1.1
-    set Box origin X coordinate = -1.9
-    set Box origin Y coordinate = 2.5
-    set Box origin Z coordinate = 3.1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = adv_field, adv_particle
-  set Compositional field methods = field, particles
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0; 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Discretization
-  set Use discontinuous temperature discretization = false
-  set Use discontinuous composition discretization = true
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = matrix statistics, particles
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-  set Interpolation scheme = cell average
-  set Update ghost particles = true
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 100
-    end
-  end
-end
diff --git a/tests/matrix_nonzeros_4.prm.bak b/tests/matrix_nonzeros_4.prm.bak
deleted file mode 100644
index 9f528be131b..00000000000
--- a/tests/matrix_nonzeros_4.prm.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-# Based on composition_reaction.prm with two compositional
-# fields to test re-use of the compositional matrix
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.3
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-# Let us here choose again a box domain of size 2x1
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-# We then set the temperature to one at the bottom and zero
-# at the top:
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0
-  end
-end
-
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-    set Density differential for compositional field 1 = -5
-    set Density differential for compositional field 2 = 5
-    set Reaction depth                = 0.2
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, memory statistics, matrix statistics
-
-  subsection Memory statistics
-    set Output peak virtual memory (VmPeak) = false
-  end
-end
diff --git a/tests/matrix_nonzeros_5.prm.bak b/tests/matrix_nonzeros_5.prm.bak
deleted file mode 100644
index b9d8d33eb9e..00000000000
--- a/tests/matrix_nonzeros_5.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# like matrix_nonzeros_4 but with different compositional field methods
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.3
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-# Let us here choose again a box domain of size 2x1
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-# We then set the temperature to one at the bottom and zero
-# at the top:
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Compositional field methods = static, field, field
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0;1
-  end
-end
-
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-    set Density differential for compositional field 1 = -5
-    set Density differential for compositional field 2 = 5
-    set Reaction depth                = 0.2
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, memory statistics, matrix statistics
-
-  subsection Memory statistics
-    set Output peak virtual memory (VmPeak) = false
-  end
-end
diff --git a/tests/matrix_nonzeros_6.prm.bak b/tests/matrix_nonzeros_6.prm.bak
deleted file mode 100644
index 4b41fdd9712..00000000000
--- a/tests/matrix_nonzeros_6.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-# like matrix_nonzeros_5 but with different solver schemes
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.3
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, single Stokes
-
-############### Parameters describing the model
-# Let us here choose again a box domain of size 2x1
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-# We then set the temperature to one at the bottom and zero
-# at the top:
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Compositional field methods = static, field, field
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0;1
-  end
-end
-
-subsection Material model
-  set Model name = composition reaction
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-    set Density differential for compositional field 1 = -5
-    set Density differential for compositional field 2 = 5
-    set Reaction depth                = 0.2
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, memory statistics, matrix statistics
-
-  subsection Memory statistics
-    set Output peak virtual memory (VmPeak) = false
-  end
-end
diff --git a/tests/matrix_nonzeros_7.prm.bak b/tests/matrix_nonzeros_7.prm.bak
deleted file mode 100644
index 4eff50e42a9..00000000000
--- a/tests/matrix_nonzeros_7.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-# like matrix_nonzeros_4 but with matrix free multigrid
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.3
-set Use years in output instead of seconds = false
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-############### Parameters describing the model
-# Let us here choose again a box domain of size 2x1
-# where we fix the temperature at the bottom and top,
-# allow free slip along the bottom, left and right,
-# and prescribe the velocity along the top using the
-# `function' description.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-# We then set the temperature to one at the bottom and zero
-# at the top:
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Compositional field methods = static, field, field
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient. The default
-# strength for gravity is one. The material model is the
-# same as before.
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = if(z<0.5+0.4*sin((x-0.5)*pi),1,0);0;1
-  end
-end
-
-subsection Material model
-  set Model name = composition reaction
-  set Material averaging = harmonic average
-
-  subsection Composition reaction model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-    set Density differential for compositional field 1 = -5
-    set Density differential for compositional field 2 = 5
-    set Reaction depth                = 0.2
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, memory statistics, matrix statistics
-
-  subsection Memory statistics
-    set Output peak virtual memory (VmPeak) = false
-  end
-end
diff --git a/tests/max_timesteps_btwn_output.prm.bak b/tests/max_timesteps_btwn_output.prm.bak
deleted file mode 100644
index c0da88af5db..00000000000
--- a/tests/max_timesteps_btwn_output.prm.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-# This is a test to check if output files are correctly written if the maximum number of steps
-# between outputs is smaller than the required one (while the dt between output files is large)
-# Based on the cookbook for convection in a 2d box.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 300.
-set Output directory                       = output
-
-# Then there are variables that describe the tolerance of
-# the linear solver as well as how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above. (As will be seen
-# in the next section, the actual temperature prescribed here
-# at the left and right does not matter.)
-# We then also have to prescribe several other parts of the model such as
-# which boundaries actually carry a prescribed boundary temperature, whereas
-# all other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.e5  # = Ra
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.1
-    set Time steps between graphical output = 5
-    set Number of grouped files = 1
-  end
-end
-
-subsection Termination criteria
-  set End step                  = 10
-  set Termination criteria      = end step
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/maximum_horizontal_compressive_stress_case_one.prm.bak b/tests/maximum_horizontal_compressive_stress_case_one.prm.bak
deleted file mode 100644
index e859badaf7f..00000000000
--- a/tests/maximum_horizontal_compressive_stress_case_one.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-############### Global parameters
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set CFL number                             = .5
-set Output directory                       = output-shear_box_3D
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Pressure normalization                 = no
-set Timing output frequency                = 1
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  =  1
-    set Z extent  =  1
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density = 0
-    set Viscosity = 0.5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators =
-  set Prescribed velocity boundary indicators = front z:function, back z:function, left z:function, right z:function, top:function, bottom:function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = cm=0.01, year=1
-    set Function expression =  (0.5-z)*2 ; 0.5-z ; z
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.9
-  set Strategy                           = strain rate
-  set Coarsening fraction                = 0.05
-  set Minimum refinement level           = 2
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography, pressure statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, maximum horizontal compressive stress
-    set Time between graphical output = 0
-    set Interpolate output = true
-    set Output format = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-9
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/maximum_horizontal_compressive_stress_case_two.prm.bak b/tests/maximum_horizontal_compressive_stress_case_two.prm.bak
deleted file mode 100644
index 21e9854f1a2..00000000000
--- a/tests/maximum_horizontal_compressive_stress_case_two.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-############### Global parameters
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set CFL number                             = .5
-set Output directory                       = output-punch_box_3D
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Pressure normalization                 = no
-set Timing output frequency                = 1
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  =  1
-    set Z extent  =  1
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-# The velocity along the top boundary models a spreading
-# center that is moving left and right:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left,right
-  set Prescribed velocity boundary indicators = front x:function, back x:function, top z:function, bottom z:function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = cm=0.01, year=1
-    set Function expression =  if(y > 0.5,-1,1) ; 0 ; if(z<0.5,-1,1)
-  end
-end
-
-subsection Boundary traction model
-  #set Prescribed traction boundary indicators = front:initial lithostatic pressure, back:initial lithostatic pressure,left:initial lithostatic pressure, right:initial lithostatic pressure
-  subsection Initial lithostatic pressure
-    set Representative point = 0,0,0
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.9
-  set Strategy                           = strain rate
-  set Coarsening fraction                = 0.05
-  set Minimum refinement level           = 2
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography, pressure statistics
-
-  subsection Visualization
-    set List of output variables = density, viscosity, maximum horizontal compressive stress
-    set Time between graphical output = 0
-    set Interpolate output = true
-    set Output format = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-9
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/maximum_refinement_function.prm.bak b/tests/maximum_refinement_function.prm.bak
deleted file mode 100644
index 0fbe53705d1..00000000000
--- a/tests/maximum_refinement_function.prm.bak
+++ /dev/null
@@ -1,154 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-
-# MPI: 2
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.33
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Additional refinement times              =
-  set Coarsening fraction                      = 0.2
-  set Refinement fraction                      = 0.5
-  set Initial adaptive refinement              = 5
-  set Initial global refinement                = 3
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = max
-  set Run postprocessors on initial refinement = true
-  set Strategy                                 = thermal energy density, maximum refinement function
-  set Time steps between mesh refinement       = 1
-
-  subsection Maximum refinement function
-    set Function constants  =
-
-    # This is in fact the default value
-    set Coordinate system = depth
-
-    # The following lines are equal to set the line:
-    # set Function expression = 4 + 2*sin(x*pi/250000)
-    # which implies:
-    # set Variable names = x,y
-    # because that is the default value for Variable names.
-    # To illustrate the possibility to rename function variables
-    # in your favourite naming scheme we use the following:
-    set Variable names = depth,not_used1
-    set Function expression = 6 + 2*sin(depth*2*pi/250000)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/maximum_refinement_function_cartesian.prm.bak b/tests/maximum_refinement_function_cartesian.prm.bak
deleted file mode 100644
index 49f90a417b2..00000000000
--- a/tests/maximum_refinement_function_cartesian.prm.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-
-# MPI: 2
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.33
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Additional refinement times              =
-  set Coarsening fraction                      = 0.2
-  set Refinement fraction                      = 0.5
-  set Initial adaptive refinement              = 5
-  set Initial global refinement                = 3
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = max
-  set Run postprocessors on initial refinement = true
-  set Strategy                                 = thermal energy density, maximum refinement function
-  set Time steps between mesh refinement       = 1
-
-  subsection Maximum refinement function
-    set Coordinate system      = cartesian
-    set Function constants     =
-    set Function expression    = 6 + 2*sin(x*2*pi/250000)*sin(y*2*pi/250000)
-    set Variable names         = x,y
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/maximum_refinement_function_spherical.prm.bak b/tests/maximum_refinement_function_spherical.prm.bak
deleted file mode 100644
index 8cacf09f1e8..00000000000
--- a/tests/maximum_refinement_function_spherical.prm.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-# Copy of the minimum_refinement_function_cartesian test, adjusted to
-# spherical geometry and refinement coordinates. The minimum refinement
-# formula in this test uses spherical coordinates and refines exactly
-# those regions of the model that are assigned the highest temperatures
-# by the initial condition 'harmonic perturbation'.
-
-# MPI: 2
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.33
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 250000
-    set Outer radius  = 500000
-    set Opening angle = 90
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Additional refinement times              =
-  set Coarsening fraction                      = 0.2
-  set Refinement fraction                      = 0.5
-  set Initial adaptive refinement              = 4
-  set Initial global refinement                = 3
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = max
-  set Run postprocessors on initial refinement = true
-  set Strategy                                 = thermal energy density, maximum refinement function
-  set Time steps between mesh refinement       = 1
-
-  subsection Maximum refinement function
-    set Coordinate system      = spherical
-    set Function constants     =
-    set Function expression    = 5 + 2*sin((r+250000)*2*pi/250000)*sin(12*phi)
-    set Variable names         = r,phi
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/maxtimestep.prm.bak b/tests/maxtimestep.prm.bak
deleted file mode 100644
index 4678231d214..00000000000
--- a/tests/maxtimestep.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-# a test that verifies that setting an end time earlier than when
-# we achieve steady state still terminates the program at the right
-# time
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Maximum time step                      = 42
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-  set End step                  = 5
-end
diff --git a/tests/melt_and_traction.prm.bak b/tests/melt_and_traction.prm.bak
deleted file mode 100644
index 888f6cb53af..00000000000
--- a/tests/melt_and_traction.prm.bak
+++ /dev/null
@@ -1,276 +0,0 @@
-# This is a test to see if traction boundary conditions work in models
-# with melt migration.
-# At the right and bottom boundary, the lithostatic pressure is applied,
-# so both the solid and the melt velocity should be approximately zero.
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 1600
-set Maximum time step                      = 1e6
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 20
-set Nonlinear solver tolerance             = 1e-7
-
-# In addition, melting and freezing normally happens on a much faster
-# time scale than the flow of melt, so we want to decouple the advection
-# of melt (and temperature) and the melting process itself. To do that,
-# we use the operator splitting scheme, and define that for every
-# advection time step, we want to do at least 50 reaction time step,
-# and in addition, we limit the maximum reaction time step size to
-# 500,000 years.
-set Use operator splitting                     = true
-
-# The end time of the simulation. We only do one time step.
-set End time                               = 1e5
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 100
-  end
-end
-
-# We apply the lithostatic pressure at the bottom and the right side.
-
-##################### Boundary conditions ########################
-
-# As boundary conditions for the temperature, we just use the
-# initial conditions again. This temperature is applied as a prescribed
-# temperature at the top and bottom boundary, as specified above.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3700
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function
-  set Tangential velocity boundary indicators = left
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0; 0
-  end
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = right:initial lithostatic pressure, bottom y:initial lithostatic pressure
-
-  subsection Initial lithostatic pressure
-    set Number of integration points = 10000
-    set Representative point         = 300000,300000
-  end
-end
-
-subsection Melt settings
-  # In addition, we now also specify in the model settings that we want to
-  # run a model with melt transport.
-  set Include melt transport                  = true
-end
-
-##################### Settings for melt transport ########################
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.5
-    set cR    = 1
-  end
-end
-
-##################### Initial temperature model ########################
-
-# We choose an adiabatic temperature profile as initial condition.
-subsection Initial temperature model
-  set List of model names = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 0
-    set Age top boundary layer    = 5e7
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-end
-
-# Now that our model uses compositional fields, we also need initial
-# conditions for the composition.
-# We use the function plugin to set both fields to zero at the beginning
-# of the model run.
-subsection Initial composition model
-  set List of model names = function, porosity
-
-  subsection Function
-    set Function expression = 0; 0
-    set Variable names      = x,y
-  end
-end
-
-# We again choose the initial composition as boundary condition
-# for all compositional fields.
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Models with melt transport also need an additional boundary condition.
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-##################### Model geometry ########################
-
-# The model geometry is a square with a dimension of 300 km.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 300000
-    set Y extent = 300000
-  end
-end
-
-################ Gravity and material properties ##################
-
-# The model has a constant gravity.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We use the melt global material model, which is one of the
-# material models that works with melt transport, as it also
-# specifies the material properties needed for melt migration,
-# such as the permeability, the melt density and the melt
-# viscosity.
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    # First we describe the parameters for the solid, in the same way
-    # we did in the model without melt transport
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Thermal expansion coefficient     = 2e-5
-    set Reference shear viscosity         = 5e21
-    set Thermal viscosity exponent        = 7
-    set Reference temperature             = 1600
-
-    # The melt usually has a different (lower) density than the solid.
-    set Reference melt density            = 3400
-
-    # The permeability describes how well the pores of a porous material
-    # are connected (and hence how fast melt can flow through the rock).
-    # It is computed as the product of the reference value given here
-    # and the porosity cubed. This means that the lower the porosity is
-    # the more difficult it is for the melt to flow.
-    set Reference permeability            = 1e-8
-
-    # The bulk viscosity describes the resistance of the rock to dilation
-    # and compaction. Melt can only flow into a region that had no melt
-    # before if the matrix of the solid rock expands, so this parameter
-    # also limits how fast melt can flow upwards.
-    # The bulk viscosity is computed as the reference value given here times
-    # a term that scales with one over the porosity. This means that for zero
-    # porosity, the rock can not dilate/compact any more, which is the same
-    # behavior that we have for solid mantle convection.
-    set Reference bulk viscosity          = 1e19
-
-    # In dependence of how much melt is present, we also weaken the shear
-    # viscosity: The more melt is present, the weaker the rock gets.
-    # This scaling is exponential, following the relation
-    # viscosity ~ exp(-alpha * phi),
-    # where alpha is the parameter given here, and phi is the porosity.
-    set Exponential melt weakening factor = 10
-
-    # In the same way the shear viscosity is reduced with increasing temperature,
-    # we also prescribe the temperature-dependence of the bulk viscosity.
-    set Thermal bulk viscosity exponent   = 7
-
-    # Finally, we prescribe the viscosity of the melt, which is used in Darcy's
-    # law. The lower this viscosity, the faster melt can flow.
-    set Reference melt viscosity          = 1
-
-    # change the density contrast of depleted material (in kg/m^3)
-    set Depletion density change          = -200.0
-
-    # How much melt has been generated and subsequently extracted from a particular
-    # volume of rock (how 'depleted' that volume of rock is) usually changes the
-    # solidus. The more the material has been molten already, the less melt will be
-    # generated afterwards for the same pressure and temperature conditions. We
-    # model this using a simplified, linear relationship, saying that to melt 100%
-    # of the rock the temperature has to be 200 K higher than to melt it initially.
-    set Depletion solidus change          = 200
-    set Melting time scale for operator splitting = 1e100
-    set Include melting and freezing      = false
-  end
-end
-
-##################### Mesh refinement #########################
-
-# For the model with melt migration, we use adaptive refinement.
-# We make use of two different refinement criteria: we set a minimum of 4 global
-# refinements everywhere in the model (which is the same resolution as for the
-# model without melt), and we refine in regions where melt is present, to be
-# precise, everywhere where the porosity is bigger than 1e-4.
-# We adapt the mesh every 5 time steps.
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Time steps between mesh refinement       = 0
-end
-
-# As the model is compressible and has an adiabatic temperature profile, we include
-# adiabatic heating in the list of heating models.
-# To make this model as simple as possible, we do not include shear heating (although
-# usually, adiabatic heating and shear heating should always be used together).
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-##################### Postprocessing ########################
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics, temperature statistics, mass flux statistics
-  set Run postprocessors on nonlinear iterations = true
-
-  # For the model with melt migration, also add a visualization
-  # postprocessor that computes the material properties relevant
-  # to migration (permeability, viscosity of the melt, etc.).
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, strain rate, melt material properties, nonadiabatic pressure
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Interpolate output            = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
diff --git a/tests/melt_boukare_EOS.prm.bak b/tests/melt_boukare_EOS.prm.bak
deleted file mode 100644
index a66742a46dd..00000000000
--- a/tests/melt_boukare_EOS.prm.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-# Test for the equation of state in the boukare material model.
-# The test has only 4 cells and a constant temperature and pressure.
-# It checks if the material properties are computed correctly for
-# the iron-bearing endmember of the melt composition.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Maximum time step                      = 1e7
-set Output directory                       = test
-set Nonlinear solver scheme                = first timestep only, single Stokes
-set Max nonlinear iterations               = 5
-set Pressure normalization                 = surface
-set Surface pressure                       = 110.e9
-set Adiabatic surface temperature          = 4000
-set Use conduction timestep                = true
-set Use operator splitting = true
-
-subsection Melt settings
-  set Include melt transport = true
-end
-
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction solver type                   = fixed step
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = molar_Fe_in_solid, molar_Fe_in_melt, porosity
-end
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500000
-    set Y extent = 500000
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 4000
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0; 1; 0.9999999 #fe_mantle_endmember
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, top, bottom
-  set Prescribed velocity boundary indicators =
-  set Tangential velocity boundary indicators =
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Maximal temperature = 3000
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-  set Fixed composition boundary indicators   = top
-  set Model name = initial composition
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = melt boukare
-
-  subsection Melt boukare
-    set Thermal conductivity          = 8.5
-    set Reference shear viscosity     = 5e22
-    set Thermal viscosity exponent    = 0
-    set Include melting and freezing  = false
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set List of output variables = material properties, melt material properties
-    set Output format = gnuplot
-    set Interpolate output = false
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,compressibility
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density
-    end
-  end
-end
diff --git a/tests/melt_boukare_averaging.prm.bak b/tests/melt_boukare_averaging.prm.bak
deleted file mode 100644
index 6f88da030c5..00000000000
--- a/tests/melt_boukare_averaging.prm.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-# Test for the equation of state in the boukare material model
-# The test has only 4 cells and a constant temperature and pressure.
-# It checks if the material properties are computed correctly for
-# a mixture of melt and solid with (20% porosity).
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Maximum time step                      = 1e7
-set Output directory                       = test
-set Nonlinear solver scheme                = first timestep only, single Stokes
-set Max nonlinear iterations               = 5
-set Pressure normalization                 = surface
-set Surface pressure                       = 100.e9
-set Adiabatic surface temperature          = 2000
-set Use conduction timestep                = true
-set Use operator splitting                 = true
-
-subsection Melt settings
-  set Include melt transport                 = true
-end
-
-subsection Solver parameters
-  subsection Operator splitting parameters
-    set Reaction solver type                   = fixed step
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = molar_Fe_in_solid, molar_Fe_in_melt, porosity
-end
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500000
-    set Y extent = 500000
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 2000
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.41; 0.43; 0.2
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, top, bottom
-  set Prescribed velocity boundary indicators =
-  set Tangential velocity boundary indicators =
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Maximal temperature = 2000
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-  set Fixed composition boundary indicators   = top
-  set Model name = initial composition
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = melt boukare
-
-  subsection Melt boukare
-    set Thermal conductivity          = 8.5
-    set Reference shear viscosity     = 5e22
-    set Thermal viscosity exponent    = 0
-    set Include melting and freezing  = false
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set List of output variables = material properties, melt material properties
-    set Output format = gnuplot
-    set Interpolate output = false
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,compressibility
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, fluid density gradient
-    end
-  end
-end
diff --git a/tests/melt_boundary_heat_flux.cc.bak b/tests/melt_boundary_heat_flux.cc.bak
deleted file mode 100644
index 41a9c23ffdf..00000000000
--- a/tests/melt_boundary_heat_flux.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "rising_melt_blob.cc"
diff --git a/tests/melt_boundary_heat_flux.prm.bak b/tests/melt_boundary_heat_flux.prm.bak
deleted file mode 100644
index af1abb1c260..00000000000
--- a/tests/melt_boundary_heat_flux.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-#########################################################
-# This is a test to see if the heat flux boundary
-# conditions work together with melt migration.
-
-############### Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 5000
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 50
-set CFL number                             = 0.2
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-############### Parameters describing the model
-# Let us here choose again a box domain
-# where we fix the temperature at the bottom and top,
-# allow free slip along the boundaries
-# and include melt migration.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 200000
-    set Y extent = 100000
-    set X repetitions = 2
-  end
-end
-
-subsection Boundary heat flux model
-  set Fixed heat flux boundary indicators   = 2, 3
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = if(z<50000, -1,1)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Melt settings
-  set Include melt transport = true
-end
-
-############### Compositional fields
-# We want to use two compositional fields, the porosity and
-# an additional field, to check if the melting rate functionality
-# has the same effect as the reaction term for the other
-# compositional fields. As the porosity field is advected by
-# a different mechanism, slight differences between the fields
-# are expected.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 1e6
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
-    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
-  end
-end
-
-subsection Material model
-  set Model name = melting rate
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/melt_compressible_advection.cc.bak b/tests/melt_compressible_advection.cc.bak
deleted file mode 100644
index d6c956a432f..00000000000
--- a/tests/melt_compressible_advection.cc.bak
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-namespace aspect
-{
-
-  /**
-    * A material model with constant material properties except for the
-    * compaction viscosity, and non-zero melt and solid compressibilities.
-    */
-  template <int dim>
-  class CompressibleMeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual bool is_compressible () const
-      {
-        return true;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        return 1.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            out.viscosities[i] = 0.75;
-            out.thermal_expansion_coefficients[i] = 0.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 0.0;
-            out.compressibilities[i] = 1.0;
-            out.densities[i] = 1.0;
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                melt_out->compaction_viscosities[i] = 0.5 * (in.position[i][1]+0.1)*(in.position[i][1]+0.1);
-                melt_out->fluid_viscosities[i] = 1.0;
-                melt_out->permeabilities[i] = 1.0;
-                melt_out->fluid_density_gradients[i] = this->get_gravity_model().gravity_vector(in.position[i]);
-                melt_out->fluid_densities[i] = 1.0;
-              }
-          }
-      }
-  };
-
-
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(2*dim+5) {}
-      virtual void vector_value (const Point<dim>   &p,
-                                 Vector<double>   &values) const
-      {
-        double x = p(0);
-        double y = p(1);
-        double porosity = -0.1 * std::exp(-(y+0.1))/(y+0.1) + 1.0;
-
-        values[0]=0;       // x vel
-        values[1]=0;    // y vel
-        values[2]=0;  // p_f
-        values[3]=0;  // p_c
-        values[4]=0;       // x melt vel
-        values[5]=0;    // y melt vel
-        values[6]=0;  // p_s
-        values[7]=0; // T
-        values[8]=porosity; // porosity
-      }
-  };
-
-
-  /**
-    * A postprocessor that evaluates the accuracy of the solution
-    * by using the L2 norm.
-    */
-  template <int dim>
-  class CompressibleMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Generate graphical output from the current solution.
-       */
-      virtual
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics);
-  };
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  CompressibleMeltPostprocessor<dim>::execute (TableHandler &statistics)
-  {
-    RefFunction<dim> ref_func;
-    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
-
-    const unsigned int n_total_comp = this->introspection().n_components;
-    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
-    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_porosity,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_porosity);
-
-    const double poro_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
-
-    std::ostringstream os;
-    os << std::scientific << poro_l2;
-    return std::make_pair("Error porosity_L2:", os.str());
-  }
-
-  template <int dim>
-  class PressureBdry:
-
-    public BoundaryFluidPressure::Interface<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id boundary_indicator,
-        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &output
-      ) const
-      {
-        for (unsigned int q=0; q<output.size(); ++q)
-          {
-            const double y = material_model_inputs.position[q][1];
-            Tensor<1,dim> direction;
-            direction[dim-1] = 1.0;
-            output[q] = (1.1 + y)*direction * normal_vectors[q];
-          }
-      }
-
-
-
-  };
-
-}
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(CompressibleMeltMaterial,
-                                 "compressible melt material",
-                                 "")
-
-
-  ASPECT_REGISTER_POSTPROCESSOR(CompressibleMeltPostprocessor,
-                                "compressible melt error",
-                                "A postprocessor that compares the numerical solution to the analytical "
-                                "solution derived for compressible melt transport in a 2D box as described "
-                                "in the manuscript and reports the error.")
-
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-
-}
diff --git a/tests/melt_compressible_advection.prm.bak b/tests/melt_compressible_advection.prm.bak
deleted file mode 100644
index 09031629585..00000000000
--- a/tests/melt_compressible_advection.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-# A test for the correct advection of the porosity
-# field in compressible cases.
-# With a prescribed velocity of u = (0,z) and
-# density, gravity and compressibilities set to 1,
-# phi = A * exp(-z) / z + 1. The z coordinate is
-# shifted z --> z+0.1 to avoid dividing by 0.
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 5e-5
-set Max nonlinear iterations               = 15
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0.025
-set Pressure normalization                 = surface
-set Surface pressure                       = 2.0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta = 0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = true
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-  end
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;1.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = 0.0;y+0.1
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = -0.1/(exp(y+0.1) * (y+0.1)) + 1.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = compressible melt material
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, compressible melt error
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/melt_force_vector.cc.bak b/tests/melt_force_vector.cc.bak
deleted file mode 100644
index 0d6b9d320d4..00000000000
--- a/tests/melt_force_vector.cc.bak
+++ /dev/null
@@ -1,338 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/melt.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-
-  template <int dim>
-  class TestMeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-
-      virtual double reference_darcy_coefficient () const
-      {
-        return 1.0;
-      }
-
-
-      virtual bool
-      viscosity_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
-      {
-        if ((dependence & MaterialModel::NonlinearDependence::compositional_fields) != MaterialModel::NonlinearDependence::none)
-          return true;
-        return false;
-      }
-
-      virtual bool
-      density_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
-      {
-        return false;
-      }
-
-
-      virtual bool
-      compressibility_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
-      {
-        return false;
-      }
-
-
-      virtual bool
-      specific_heat_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
-      {
-        return false;
-      }
-
-
-      virtual bool
-      thermal_conductivity_depends_on (const MaterialModel::NonlinearDependence::Dependence dependence) const
-      {
-        return false;
-      }
-
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_density () const
-      {
-        return 1.0;
-      }
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-        MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
-        *force = out.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
-
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            const double x = in.position[i](0);
-            const double z = in.position[i](1);
-            out.viscosities[i] = 1.0;
-            out.thermal_expansion_coefficients[i] = 0.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            out.densities[i] = 1.0;
-
-            out.reaction_terms[i][porosity_idx] = 0;
-//**********
-// copy and paste here
-            if (force)
-              {
-                force->rhs_u[i][0] = cos(z) - cos(x + z) + cos(x * z) * z;
-                force->rhs_u[i][1] = sin(x) - cos(x + z) + cos(x * z) * x;
-                force->rhs_p[i] = 0.4e1 * sin(x + z) - sin(x * z) * z * z - sin(x * z) * x * x;
-                force->rhs_melt_pc[i] = -0.10e2 * sin(x + z) / (0.1e1 + exp(-0.20e2 * x * x - 0.20e2 * z * z + 0.1e1));
-              }
-//***********
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-            {
-              double porosity = in.composition[i][porosity_idx];
-              // porosity = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1));
-              const double x = in.position[i](0);
-              const double z = in.position[i](1);
-              melt_out->compaction_viscosities[i] = 0.1e0 + 0.1e0 * exp(-0.20e2 * x * x - 0.20e2 * z * z + 0.1e1); // xi
-              melt_out->fluid_viscosities[i] = 1.0;
-              melt_out->permeabilities[i] = 1.0; // K_D
-              melt_out->fluid_density_gradients[i] = 0.0;
-              melt_out->fluid_densities[i] = 0.5;
-            }
-
-      }
-
-  };
-
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(2*dim+3+2) {}
-      virtual void vector_value (const Point<dim>   &p,
-                                 Vector<double>   &values) const
-      {
-        double x = p(0);
-        double z = p(1);
-//**********
-// copy and paste here (add "out.")
-        const double phi = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1));
-
-        values[0] = cos(z);                                                 //ux
-        values[1] = sin(x);                                                 //uz
-        values[2] = -0.2e1 * sin(x + z) + sin(x * z);                       //p_f
-        values[3] = sin(x + z);                                             //p_c
-        values[4] = values[0] - 1.0/phi * (-2.0 * cos(x+z) + cos(x*z)*z);   //u_f_x
-        values[5] = values[1] - 1.0/phi * (-2.0 * cos(x+z) + cos(x*z)*x);   //u_f_z
-        values[6] = values[2] + values[3] / (1.0 - phi);                    //p_s = p_f + p_c / (1-phi)
-        values[7] = 0;
-        values[8] = phi;                                                    //porosity
-//**********
-      }
-  };
-
-
-
-  /**
-    * A postprocessor that evaluates the accuracy of the solution
-    * by using the L2 norm.
-    */
-  template <int dim>
-  class ConvergenceMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Generate graphical output from the current solution.
-       */
-      virtual
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics);
-
-  };
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  ConvergenceMeltPostprocessor<dim>::execute (TableHandler &statistics)
-  {
-    RefFunction<dim> ref_func;
-    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
-
-    const unsigned int n_total_comp = this->introspection().n_components;
-
-    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
-
-    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                        n_total_comp);
-    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
-    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+
-                                                                                dim),
-                                          n_total_comp);
-    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_f);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_c,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_c);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_porosity,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_porosity);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u_f);
-
-    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
-    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
-    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
-    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
-    const double phi_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
-    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
-
-
-    std::ostringstream os;
-    os << std::scientific
-       << " h = " << this->get_triangulation().begin_active()->diameter()
-       << " ndofs= " << this->get_solution().size()
-       << " u_L2= " << u_l2
-       << " p_L2= "  << p_l2
-       << " p_f_L2= " << p_f_l2
-       << " p_c_L2= " << p_c_l2
-       << " phi_L2= " << phi_l2
-       << " u_f_L2= " << u_f_l2
-       ;
-
-    return std::make_pair("Errors", os.str());
-  }
-
-
-  template <int dim>
-  class PressureBdry:
-    public BoundaryFluidPressure::Interface<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const dealii::types::boundary_id,
-        const typename MaterialModel::Interface<dim>::MaterialModelInputs &material_model_inputs,
-        const typename MaterialModel::Interface<dim>::MaterialModelOutputs &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &output
-      ) const
-      {
-        for (unsigned int q=0; q<output.size(); ++q)
-          {
-            const double x = material_model_inputs.position[q][0];
-            const double z = material_model_inputs.position[q][1];
-            Tensor<1,dim> gradient;
-//**********
-// copy and paste here (add "out.")
-            gradient[0] = -0.2e1 * cos(x + z) + cos(x * z) * z;
-            gradient[1] = -0.2e1 * cos(x + z) + cos(x * z) * x;
-//**********
-            output[q] = gradient * normal_vectors[q];
-          }
-      }
-
-
-
-  };
-
-}
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_MATERIAL_MODEL(TestMeltMaterial,
-                                 "test melt material",
-                                 "")
-
-  ASPECT_REGISTER_POSTPROCESSOR(ConvergenceMeltPostprocessor,
-                                "melt error calculation",
-                                "A postprocessor that compares the numerical solution to the analytical solution")
-
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-
-}
diff --git a/tests/melt_force_vector.prm.bak b/tests/melt_force_vector.prm.bak
deleted file mode 100644
index ad69f066589..00000000000
--- a/tests/melt_force_vector.prm.bak
+++ /dev/null
@@ -1,160 +0,0 @@
-# A simple reference solution with RHS force vector with incompressible
-# melt transport
-
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Max nonlinear iterations               = 50
-set Nonlinear solver tolerance             = 1e-10 #1e-10
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = volume
-set Surface pressure                       = 0#0.2746026940#3.992884522
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Refinement fraction                      = 1.0
-  set Coarsening fraction                      = 0.0
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 0
-  set Initial adaptive refinement              = 1
-  set Run postprocessors on initial refinement = true
-  set Normalize individual refinement criteria = false#true
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2
-    set Y extent  = 2
-    set Box origin X coordinate = -1
-    set Box origin Y coordinate = -1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = cos(z);sin(x)
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants = pi=3.14159265359
-
-    #    set Function expression = if(abs(x)==1 || abs(z)==1, 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * ((x + 0.20e1 * z)^ 0.2e1)), 0)
-    #    set Function expression = 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * ((x + 0.20e1 * z)^ 0.2e1))
-    set Function expression = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * ((x + 0.2e1 * z)^ 0.2e1))
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = test melt material
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Formulation
-  set Enable additional Stokes RHS            = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, pressure statistics, velocity boundary statistics, melt error calculation
-
-  subsection Visualization
-    set List of output variables      = #melt density, permeability, melt viscosity, compaction viscosity, gravity, material properties, nonadiabatic pressure
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-    set Interpolate output = true
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-
-    #    set List of output variables      = gravity, material properties, nonadiabatic pressure
-
-    subsection Material properties
-      set List of material properties   = density, viscosity, thermal expansivity, reaction terms
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Use direct solver for Stokes system = true
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/melt_fraction_postprocessor.prm.bak b/tests/melt_fraction_postprocessor.prm.bak
deleted file mode 100644
index 4a4f16604bb..00000000000
--- a/tests/melt_fraction_postprocessor.prm.bak
+++ /dev/null
@@ -1,126 +0,0 @@
-# This test checks if the postprocessor 'melt fraction' works as
-# intended. The visualization output is then a p-T-diagram of
-# the melt fraction (which, in this case, is a simple linear relation)
-# with the temperature ranging from 1000°C to 1900°C on the x axis
-# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
-
-# The data can be plotted in gnuplot using:
-# set view map
-# splot "file1" using 5:6:7 with points pointtype 5 pointsize 1 palette,
-#       "file2" using 5:6:7 with points pointtype 5 pointsize 1 palette
-
-# MPI: 2
-
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9
-    set Y extent = 8
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1100+273.15+x*100
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Reference solid density       = 1
-    set Reference melt density        = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1600
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0
-    set Reference shear viscosity     = 1
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 6
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format = gnuplot
-    set Time between graphical output = 0.01
-    set List of output variables = melt fraction
-
-    subsection Melt fraction
-      set Mass fraction cpx = 0.17
-    end
-  end
-end
diff --git a/tests/melt_introspection.cc.bak b/tests/melt_introspection.cc.bak
deleted file mode 100644
index 1b1ae2fd77e..00000000000
--- a/tests/melt_introspection.cc.bak
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-#include <aspect/melt.h>
-#include <aspect/simulator/assemblers/interface.h>
-
-#include <deal.II/fe/fe_dgq.h>
-#include <iostream>
-
-using namespace dealii;
-
-namespace aspect
-{
-
-  template <int dim>
-  void my_signal(std::vector<VariableDeclaration<dim>> &variables)
-  {
-    std::cout << "* signals.edit_finite_element_variables:" << std::endl;
-
-    VariableDeclaration<dim> dummy("dummy",
-                                   std::make_shared<FE_DGQ<dim>>(4),
-                                   1,
-                                   1);
-    variables.insert(variables.begin()+6, dummy);
-
-    for (unsigned int i=0; i<variables.size(); ++i)
-      {
-        std::cout << " name=" << variables[i].name
-                  << " fe=" << variables[i].fe->get_name()
-                  << " multiplicity=" << variables[i].multiplicity
-                  << " n_blocks=" << variables[i].n_blocks
-                  << " n_components=" << variables[i].n_components()
-                  << std::endl;
-      }
-
-    std::cout << std::endl;
-  }
-
-
-  template <int dim>
-  class MeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        const double porosity = 0.01;
-        const double permeability = 1.0 * std::pow(porosity, 3) * std::pow(1.0-porosity, 2);
-        return permeability / 0.1;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            out.viscosities[i] = 1.0;
-            out.densities[i] = 1.0 + (in.composition[i][0]);
-            out.thermal_expansion_coefficients[i] = 1.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                const double porosity = in.composition[i][porosity_idx];
-
-                melt_out->compaction_viscosities[i] = 100.0;
-                melt_out->fluid_viscosities[i]=0.1;
-                melt_out->permeabilities[i]=1.0 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-                melt_out->fluid_densities[i]=.1;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-              }
-          }
-      }
-
-  };
-
-
-}
-
-
-
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  std::cout << "* Connecting signals" << std::endl;
-  signals.edit_finite_element_variables.connect(&aspect::my_signal<dim>);
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
-
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
-                                 "MeltMaterial",
-                                 "")
-}
diff --git a/tests/melt_introspection.prm.bak b/tests/melt_introspection.prm.bak
deleted file mode 100644
index f95c0d0fcd2..00000000000
--- a/tests/melt_introspection.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# A test that adds an assembler that tests if we can create additional
-# material model outputs
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, B
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;0
-    set Variable names      = x,y
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = MeltMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set List of output variables      = viscosity
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/melt_material_1.cc.bak b/tests/melt_material_1.cc.bak
deleted file mode 100644
index 52fa3c03ce4..00000000000
--- a/tests/melt_material_1.cc.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-namespace aspect
-{
-  template <int dim>
-  class MeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        const double porosity = 0.01;
-        const double permeability = 1.0 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-        return permeability / 0.1;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            out.viscosities[i] = 1.0;
-            out.densities[i] = 1.0 + (in.composition[i][0]);
-            out.thermal_expansion_coefficients[i] = 1.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                const double porosity = in.composition[i][porosity_idx];
-
-                melt_out->compaction_viscosities[i] = 100.0;
-                melt_out->fluid_viscosities[i]=0.1;
-                melt_out->permeabilities[i]=1.0 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-                melt_out->fluid_densities[i]=.1;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-              }
-          }
-      }
-
-  };
-
-
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
-                                 "MeltMaterial",
-                                 "")
-}
diff --git a/tests/melt_material_1.prm.bak b/tests/melt_material_1.prm.bak
deleted file mode 100644
index c0efd99e39c..00000000000
--- a/tests/melt_material_1.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# tests the new melt material interface
-
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 4e-09
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = peridotite, porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 1e-4
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if(y>250000*(1+0.5*sin(x*pi/250000)),0.3,0);if(x<200000,0.3,0.0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = MeltMaterial
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/melt_material_2.cc.bak b/tests/melt_material_2.cc.bak
deleted file mode 100644
index eb30240277f..00000000000
--- a/tests/melt_material_2.cc.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-namespace aspect
-{
-  template <int dim>
-  class MeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        const double permeability = 1.0 + std::pow(0.5, 2.0);
-        return permeability / 2.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            out.viscosities[i] = 3.0/4.0;
-            out.densities[i] = 3.0;
-            out.thermal_expansion_coefficients[i] = 1.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                melt_out->compaction_viscosities[i] = 1.0;
-                melt_out->fluid_viscosities[i]= 2.0;
-                melt_out->permeabilities[i]= 1.0 + std::pow(in.position[i][1],2);
-                melt_out->fluid_densities[i]= 1.0;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-              }
-          }
-      }
-
-  };
-
-  template <int dim>
-  class PressureBdry:
-
-    public BoundaryFluidPressure::Interface<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id boundary_indicator,
-        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &output
-      ) const
-      {
-        for (unsigned int q=0; q<output.size(); ++q)
-          {
-            Tensor<1,dim> gradient;
-            gradient[0] = 0.0;
-            gradient[1] = 0.0;
-            output[q] = gradient * normal_vectors[q];
-          }
-      }
-  };
-
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
-                                 "MeltMaterial2",
-                                 "")
-
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-}
diff --git a/tests/melt_material_2.prm.bak b/tests/melt_material_2.prm.bak
deleted file mode 100644
index 85dce399eb7..00000000000
--- a/tests/melt_material_2.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-# A testcase that demonstrates melt transport with a compactible matrix,
-# but incompressible matrix and fluid. It solves the equation on a box
-# with zero velocity boundary conditions at the bottom boundary,
-# tangential velocities at the sides and an open boundary at the top.
-#
-# We then choose a Darcy coefficient (= permeability divided by fluid
-# viscosity) of 0.5+y^2/2 and otherwise constant material parameters
-# so that the gradient of the fluid pressure vanishes. The velocity
-# should then be y^2/2, the compaction pressure -y and the fluid
-# pressure should be constant.
-#
-# We compute these material properties in a new material model, which
-# is implemented in the .cc file.
-#
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-# prescribe the fluid pressure as in the analytical solution
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = 0;0.5*y*y
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = MeltMaterial2
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/melt_material_3.cc.bak b/tests/melt_material_3.cc.bak
deleted file mode 100644
index 8ca211248f5..00000000000
--- a/tests/melt_material_3.cc.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-namespace aspect
-{
-  template <int dim>
-  class MeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        const double permeability = 1.0 + std::pow(0.5, 2.0);
-        return permeability / 2.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            out.viscosities[i] = 3.0/4.0;
-            out.densities[i] = 4.0;
-            out.thermal_expansion_coefficients[i] = 1.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                melt_out->compaction_viscosities[i] = 1.0;
-                melt_out->fluid_viscosities[i]= 2.0;
-                melt_out->permeabilities[i]= 1.0 + std::pow(in.position[i][1],2);
-                melt_out->fluid_densities[i]= 2.0;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-              }
-          }
-      }
-
-  };
-
-  template <int dim>
-  class PressureBdry:
-
-    public BoundaryFluidPressure::Interface<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id boundary_indicator,
-        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &output
-      ) const
-      {
-        for (unsigned int q=0; q<output.size(); ++q)
-          {
-            Tensor<1,dim> gradient;
-            gradient[0] = 0.0;
-            gradient[1] = -1.0;
-            output[q] = gradient * normal_vectors[q];
-          }
-      }
-  };
-
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
-                                 "MeltMaterial3",
-                                 "")
-
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-}
diff --git a/tests/melt_material_3.prm.bak b/tests/melt_material_3.prm.bak
deleted file mode 100644
index 8f23f9dbb7d..00000000000
--- a/tests/melt_material_3.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-# A testcase that demonstrates melt transport with a compactible matrix,
-# but incompressible matrix and fluid. It solves the equation on a box
-# with zero velocity boundary conditions at the bottom boundary,
-# tangential velocities at the sides and an open boundary at the top.
-#
-# We the choose a Darcy coefficient (= permeability divided by fluid
-# viscosity) of (1+y^2)/2 and otherwise constant material parameters
-# so that the gradient of the fluid pressure is -1. The velocity
-# should then be y^2/2, the compaction pressure -y and the fluid
-# pressure should be linear.
-#
-# We compute these material properties in a new material model, which
-# is implemented in the .cc file.
-#
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-# prescribe the fluid pressure as in the analytical solution
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = 0;0.5*y*y
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = MeltMaterial3
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/melt_material_4.cc.bak b/tests/melt_material_4.cc.bak
deleted file mode 100644
index aee80fefcce..00000000000
--- a/tests/melt_material_4.cc.bak
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-using namespace dealii;
-
-
-namespace aspect
-{
-  template <int dim>
-  class MeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        const double porosity = 0.01;
-        const double permeability = 1.0 + 0.001 / (1.0 - porosity);
-        return permeability / 2.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            const double y = in.position[i][dim-1] + 0.1;
-            out.viscosities[i] = 3.0/4.0;
-            out.densities[i] = 2 + std::pow(y,2)/0.001;
-            out.thermal_expansion_coefficients[i] = 1.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                double porosity = in.composition[i][porosity_idx];
-                melt_out->compaction_viscosities[i] = 1.0;
-                melt_out->fluid_viscosities[i]= 2.0;
-                melt_out->permeabilities[i]= 1.0 + 0.001 / (1.0 - porosity);
-                melt_out->fluid_densities[i]= 2.0;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-              }
-          }
-      }
-
-  };
-
-
-
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(9) {}
-      virtual void vector_value (const Point<dim>   &p,
-                                 Vector<double>   &values) const
-      {
-        double x = p(0);
-        double y = p(1);
-
-        const double porosity = 1.0 - 0.001/std::pow(y+0.1,2.0);
-        const double p_f = 1.0 - (y+0.1);
-        const double p_s = 0.0;
-
-        values[0]=0;  // x vel
-        values[1]=0.5 * std::pow(y+0.1, 2.0);  // y vel
-        values[2]=p_f;  // p_f
-        values[3]=(1.0-porosity)*(p_s-p_f); // p_c
-        values[4]=-1; // u_f_x
-        values[5]=-1; // u_f_y
-        values[6]=p_s;  // p_s
-        values[7]=0; // T
-        values[8]=porosity; // porosity
-      }
-  };
-
-
-
-  template <int dim>
-  class MMPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics);
-  };
-
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  MMPostprocessor<dim>::execute (TableHandler &statistics)
-  {
-    RefFunction<dim> ref_func;
-    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
-
-    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-
-    const unsigned int n_total_comp = this->introspection().n_components;
-    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                        n_total_comp);
-    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
-    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+dim),
-                                          n_total_comp);
-    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_f);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_porosity,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_porosity);
-
-    const double u_l2 = std::sqrt(Utilities::MPI::sum(cellwise_errors_u.norm_sqr(),this->get_mpi_communicator()));
-    const double p_l2 = std::sqrt(Utilities::MPI::sum(cellwise_errors_p.norm_sqr(),this->get_mpi_communicator()));
-    const double poro_l2 = std::sqrt(Utilities::MPI::sum(cellwise_errors_porosity.norm_sqr(),this->get_mpi_communicator()));
-
-    std::ostringstream os;
-    os << std::scientific << u_l2
-       << ", " << p_l2
-       << ", " << poro_l2;
-
-    return std::make_pair("Errors u_L2, p_f_L2, porosity_L2:", os.str());
-
-  }
-
-  template <int dim>
-  class PressureBdry:
-
-    public BoundaryFluidPressure::Interface<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id boundary_indicator,
-        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &output
-      ) const
-      {
-        for (unsigned int q=0; q<output.size(); ++q)
-          {
-            Tensor<1,dim> gradient;
-            gradient[0] = 0.0;
-            gradient[1] = -1.0;
-            output[q] = gradient * normal_vectors[q];
-          }
-      }
-  };
-
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(MeltMaterial,
-                                 "MeltMaterial4",
-                                 "")
-
-  ASPECT_REGISTER_POSTPROCESSOR(MMPostprocessor,
-                                "MMPostprocessor",
-                                "")
-
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-
-}
diff --git a/tests/melt_material_4.prm.bak b/tests/melt_material_4.prm.bak
deleted file mode 100644
index ad8339a6168..00000000000
--- a/tests/melt_material_4.prm.bak
+++ /dev/null
@@ -1,143 +0,0 @@
-# A testcase that demonstrates melt transport with a compactible matrix,
-# but incompressible matrix and fluid. It solves the equation on a box
-# with zero velocity boundary conditions at the bottom boundary,
-# tangential velocities at the sides and an open boundary at the top.
-# In addition, the advection of the porosity field is tested.
-#
-# This also checks the correct size of the time step, which depends
-# both on the melt and the solid velocity.
-#
-# We the choose a porosity phi = 1 - 0.001/y^2, a Darcy coefficient
-# (= permeability divided by fluid viscosity) of k_0 + 0.001/ (1 - phi),
-# a solid density of 2 + y^2/0.001  and otherwise constant material
-# parameters so that the gradient of the fluid pressure is -1.
-# The velocity should then be y^2/2, the compaction pressure -y and
-# the fluid pressure should be linear.
-# Note that we shift y --> y + 0.1, because we would have a negative
-# porosity otherwise.
-#
-# We compute these material properties in a new material model, which
-# is implemented in the .cc file.
-#
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-# prescribe the fluid pressure as in the analytical solution
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 0.9
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = 0;0.5*(y+0.1)*(y+0.1)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0 - 0.001/((y+0.1)*(y+0.1))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = MeltMaterial4
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, MMPostprocessor
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-18
-  set Temperature solver tolerance = 1e-18
-
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/melt_postprocessor_peridotite.prm.bak b/tests/melt_postprocessor_peridotite.prm.bak
deleted file mode 100644
index 17cc6d2b59f..00000000000
--- a/tests/melt_postprocessor_peridotite.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-# This test checks if the postprocessor 'melt fraction' works as
-# intended. The visualization output is then a p-T-diagram of
-# the melt fraction of peridotite using the melting model of
-# Katz et. al, 2003 (Geochem., Geophys., Geosyst. )
-# with the temperature ranging from 1000°C to 1900°C on the x axis
-# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
-
-# MPI: 2
-
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9
-    set Y extent = 8
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1100+273.15+x*100
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 6
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format = gnuplot
-    set Time between graphical output = 0.01
-    set List of output variables = melt fraction
-
-    subsection Melt fraction
-      set Mass fraction cpx = 0.17
-    end
-  end
-end
diff --git a/tests/melt_postprocessor_pyroxenite.prm.bak b/tests/melt_postprocessor_pyroxenite.prm.bak
deleted file mode 100644
index 27da3361083..00000000000
--- a/tests/melt_postprocessor_pyroxenite.prm.bak
+++ /dev/null
@@ -1,140 +0,0 @@
-# This test checks if the postprocessor 'melt fraction' works as
-# intended. The visualization output is then a p-T-diagram of
-# the melt fraction of pyroxenite using the melting model of
-# Sobolev et. al, 2010 (Nature)
-# with the temperature ranging from 1000°C to 1900°C on the x axis
-# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
-
-# The data can be plotted in gnuplot using:
-# set view map
-# splot "file1" using 5:6:8 with points pointtype 5 pointsize 1 palette,
-#       "file2" using 5:6:8 with points pointtype 5 pointsize 1 palette
-
-# MPI: 2
-
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9
-    set Y extent = 8
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = pyroxenite
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1100+273.15+x*100
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = box
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format = gnuplot
-    set Time between graphical output = 0.01
-    set List of output variables = melt fraction
-  end
-end
diff --git a/tests/melt_property_visualization.cc.bak b/tests/melt_property_visualization.cc.bak
deleted file mode 100644
index 42941744080..00000000000
--- a/tests/melt_property_visualization.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "melt_transport_compressible.cc"
diff --git a/tests/melt_property_visualization.prm.bak b/tests/melt_property_visualization.prm.bak
deleted file mode 100644
index 59a91210194..00000000000
--- a/tests/melt_property_visualization.prm.bak
+++ /dev/null
@@ -1,139 +0,0 @@
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 1
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-# test if the melt material properties visulaization output works
-# (for both scalar and tensor output variables)
-#
-subsection Discretization
-  # The polynomial degree to use for the composition variable(s). Units:
-  # None.
-  set Composition polynomial degree           = 2
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;-exp(y)
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = 0.1*exp(y);-0.3/4.0*exp(y)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0 - 0.3 * exp(y)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = compressible melt material
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = melt material properties
-    set Output format                 = gnuplot
-
-    subsection Melt material properties
-      set List of properties = permeability, fluid density gradient
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/melt_restart.cc.bak b/tests/melt_restart.cc.bak
deleted file mode 100644
index e1bf07b7fef..00000000000
--- a/tests/melt_restart.cc.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Launch ASPECT
- * twice to test checkpoint/resume and then terminate the outer ASPECT run.
- */
-int f()
-{
-  std::cout << "* starting from beginning:" << std::endl;
-
-  // call ASPECT with "--" and pipe an existing input file into it.
-  int ret;
-  std::string command;
-
-  command = ("cd output-melt_restart ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/melt_restart.prm "
-             " ; "
-             " echo 'set Output directory = output1.tmp' "
-             " ; "
-             " rm -rf output1.tmp ; mkdir output1.tmp "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  command = ("cd output-melt_restart ; "
-             " rm -rf output2.tmp ; mkdir output2.tmp ; "
-             " cp output1.tmp/restart* output2.tmp/");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now resuming:" << std::endl;
-  command = ("cd output-melt_restart ; "
-             "(cat " ASPECT_SOURCE_DIR "/tests/melt_restart.prm "
-             " ; "
-             " echo 'set Output directory = output2.tmp' "
-             " ; "
-             " echo 'set Resume computation = true' "
-             ") "
-             "| ../../aspect -- > /dev/null");
-  std::cout << "Executing the following command:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  std::cout << "* now comparing:" << std::endl;
-
-  ret = system ("cd output-melt_restart ; "
-                "cp output1.tmp/log.txt log.txt1;"
-                "cp output2.tmp/log.txt log.txt2;"
-                "cp output1.tmp/statistics statistics1;"
-                "cp output2.tmp/statistics statistics2;"
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // terminate current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/melt_restart.prm.bak b/tests/melt_restart.prm.bak
deleted file mode 100644
index 5ad3e65dd3c..00000000000
--- a/tests/melt_restart.prm.bak
+++ /dev/null
@@ -1,223 +0,0 @@
-# test checkpoint/resume.
-
-# This test is controlled via the plugin in melt_restart.cc. The plugin will
-# first execute ASPECT with this .prm and write the output into
-# output1.tmp/. This will generate a snapshot that is then resumed from. The
-# output for this second run will be written into output2.tmp/. Finally,
-# output files will be copied into the main output folder for comparison.
-
-# based on global_melt.prm
-
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 1.0
-set Maximum time step                      = 1e6
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = melt_restart
-set Max nonlinear iterations               = 20
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e3
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.2
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3700
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = #2,3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-
-  subsection Function
-    set Function constants  = b=100000, c=20000
-    set Variable names      = x,y
-    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 8700000
-    set Y extent = 2900000
-
-    #    set X periodic = true
-    set X repetitions = 3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 5e8
-    set Age top boundary layer    = 3e8
-    set Amplitude                 = 50
-    set Position                  = center
-    set Radius                    = 350000
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-
-  subsection Harmonic perturbation
-    set Magnitude = 50
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,a = 0.0, b = 2500000, c = 100000, d=1450000
-    set Function expression = a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c)); a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Thermal conductivity              = 4.7
-    set Reference solid density           = 3400
-    set Reference melt density            = 3000
-    set Thermal expansion coefficient     = 2e-5
-    set Reference permeability            = 1e-8
-    set Reference shear viscosity         = 5e21
-    set Reference bulk viscosity          = 1e19
-    set Exponential melt weakening factor = 10
-    set Thermal viscosity exponent        = 7
-    set Thermal bulk viscosity exponent   = 7
-    set Reference temperature             = 1600
-    set Solid compressibility             = 4.2e-12
-    set Melt compressibility              = 1.25e-11
-    set Reference melt viscosity          = 10
-    set Depletion density change          = -200.0 # -100.0 # 0.0
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 3
-  set Strategy                                 = composition threshold, minimum refinement function #, nonadiabatic temperature
-  set Time steps between mesh refinement       = 0
-
-  subsection Minimum refinement function
-    set Coordinate system   = depth
-    set Function expression = if (depth>1500000,5,4)
-    set Variable names      = depth,phi
-  end
-
-  subsection Composition threshold
-    set Compositional field thresholds = 1e-4,1.0
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating #, latent heat melt, shear heating
-end
-
-subsection Nullspace removal
-  #  set Remove nullspace                        = net x translation
-
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Interpolate output            = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-
-  subsection Depth average
-    set Number of zones = 12
-    set Time between graphical output = 6e5
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint = 0
-  set Steps between checkpoint = 1
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-14
-  set Temperature solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/melt_statistics.prm.bak b/tests/melt_statistics.prm.bak
deleted file mode 100644
index 5015b89b015..00000000000
--- a/tests/melt_statistics.prm.bak
+++ /dev/null
@@ -1,141 +0,0 @@
-# This test checks if the postprocessor 'melt statistics' works as
-# intended. The statistics output is computed using
-# the melt fraction of peridotite in the melting model of
-# Katz et. al, 2003 (Geochem., Geophys., Geosyst. )
-# with the temperature ranging from 1000°C to 1900°C on the x axis
-# and the pressure ranging from 0 GPa to 8 GPa on the y axis.
-
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9
-    set Y extent = 8
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 1100+273.15+x*100
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e9   # to have a pressure range up to 8 GPa
-  end
-end
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Reference solid density       = 1
-    set Reference melt density        = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0
-    set Reference shear viscosity     = 1
-    set Reference bulk viscosity      = 1
-    set Mass fraction cpx             = 0.17
-    set Exponential melt weakening factor = 0.0
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 6
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = melt statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files = 1
-    set Time between graphical output = 0.01
-    set List of output variables = melt fraction
-
-    subsection Melt fraction
-      set Mass fraction cpx = 0.17
-    end
-  end
-end
diff --git a/tests/melt_track.cc.bak b/tests/melt_track.cc.bak
deleted file mode 100644
index 069053c7cd3..00000000000
--- a/tests/melt_track.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solitary_wave/solitary_wave.cc"
diff --git a/tests/melt_track.prm.bak b/tests/melt_track.prm.bak
deleted file mode 100644
index 2bb381b7fee..00000000000
--- a/tests/melt_track.prm.bak
+++ /dev/null
@@ -1,189 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Uses the solitary wave benchmark to demonstrate the particle property melt particle,
-# which records the presence of melt over the melt transport threshold
-
-set Additional shared libraries            = ./libsolitary_wave.so
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = output_melt_track
-set Max nonlinear iterations               = 10
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.001
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-# we apply the phase speed of the wave here, so that it always stays in the same place in our model
-# the phase speed is c = 5.25e-11 m/s, but we have to convert it to m/years using the same conversion
-# that is used internally in ASPECT: year_in_seconds = 60*60*24*365.2425
-
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    #    set Function expression = 0;-8.2836999e-5
-    set Function expression = 0;-1.65673998e-4
-
-    #    set Function expression = 0;-3.31347996e-4
-    #    set Function expression = 0;-6.62695992e-4
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 10
-    set Y extent  = 400
-    set Y repetitions = 40
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Initial composition model
-  set Model name = Solitary wave initial condition
-
-  subsection Solitary wave initial condition
-    set Offset = 200
-    set Read solution from file = false
-    set Amplitude = 0.01
-    set Background porosity = 0.001
-  end
-end
-
-subsection Material model
-  set Model name = Solitary Wave
-
-  subsection Solitary wave
-    set Reference permeability = 5e-9
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 2
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = particles,visualization,composition statistics,velocity statistics,solitary wave statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 5e5
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-
-  subsection Particles
-    set Time between data output      = 0
-    set Data output format = gnuplot
-  end
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-14
-  set Temperature solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-10
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Particles
-  set Particle generator name       = ascii file
-  set List of particle properties   = melt particle
-
-  subsection Generator
-    subsection Ascii file
-      set Data file name            = melt_track.txt
-    end
-  end
-end
diff --git a/tests/melt_transport.prm.bak b/tests/melt_transport.prm.bak
deleted file mode 100644
index 1f4fbed6a21..00000000000
--- a/tests/melt_transport.prm.bak
+++ /dev/null
@@ -1,151 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# This test checks if including melt transport in a simulation,
-# but setting the porosity to 0, gives the same results as running
-# the simulation without melt transport.
-#
-# Results are the same up to the first three digits of time step size
-# and min/max/mass of compositional fields.
-#
-# Differences can be checked by setting 'Include melt transport'
-# to false.
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 1.5e7
-set Pressure normalization                 = surface
-set Surface pressure                       = 5e9
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-set Use operator splitting                     = true
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = peridotite, porosity
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = 1600 + 100 * exp(-(x-l)*(x-l)/(0.04*l*l)-(y-l)*(y-l)/(0.04*l*l))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if(y>250000*(1+0.5*sin(x*pi/250000)),0.3,0);0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Reference shear viscosity = 1e21
-    set Reference solid density = 3300
-    set Reference melt density = 3200
-    set Melting time scale for operator splitting = 1e100
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/melt_transport_adaptive.cc.bak b/tests/melt_transport_adaptive.cc.bak
deleted file mode 100644
index f1ecf2bf351..00000000000
--- a/tests/melt_transport_adaptive.cc.bak
+++ /dev/null
@@ -1,518 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/mesh_refinement/interface.h>
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-#include <deal.II/fe/fe_values.h>
-#include <deal.II/numerics/derivative_approximation.h>
-
-
-namespace aspect
-{
-  template <int dim>
-  class MeltVelocityRefinement : public MeshRefinement::Interface<dim>,
-    public SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Execute this mesh refinement criterion.
-       *
-       * @param[out] error_indicators A vector that for every active cell of
-       * the current mesh (which may be a partition of a distributed mesh)
-       * provides an error indicator. This vector will already have the
-       * correct size when the function is called.
-       */
-      virtual
-      void
-      execute (Vector<float> &indicators) const
-      {
-        indicators = 0;
-
-        KellyErrorEstimator<dim>::estimate (this->get_mapping(),
-                                            this->get_dof_handler(),
-                                            QGauss<dim-1>(this->introspection().polynomial_degree.velocities +1),
-                                            std::map<types::boundary_id,const Function<dim>*>(),
-                                            this->get_solution(),
-                                            indicators,
-                                            this->introspection().variable("fluid velocity").component_mask,
-                                            0,
-                                            0,
-                                            this->get_triangulation().locally_owned_subdomain());
-      }
-
-  };
-
-  template <int dim>
-  class PCRefinement : public MeshRefinement::Interface<dim>,
-    public SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Execute this mesh refinement criterion.
-       *
-       * @param[out] error_indicators A vector that for every active cell of
-       * the current mesh (which may be a partition of a distributed mesh)
-       * provides an error indicator. This vector will already have the
-       * correct size when the function is called.
-       */
-      virtual
-      void
-      execute (Vector<float> &indicators) const
-      {
-        indicators = 0;
-
-        // create a vector in which we set the compaction pressure block
-        // (that contains the scaled compaction pressure p_c_bar) to
-        // be a finite element interpolation of the (real) compaction pressure.
-        // we do so by setting up a quadrature formula and looping over these
-        // points, rescaling the compaction pressure, and writing
-        // the result into the output vector. As the scaling factor between
-        // the pressures is cell-wise constant (and the error indicator is
-        // a cellwise quantity too), we use a quadrature formula with only
-        // one point.
-        LinearAlgebra::BlockVector vec_distributed (this->introspection().index_sets.system_partitioning,
-                                                    this->get_mpi_communicator());
-
-        const unsigned int pc_component_index = this->introspection().variable("compaction pressure").first_component_index;
-        const unsigned int pc_base_index = this->introspection().variable("compaction pressure").base_index;
-
-        // Use a quadrature formula with only one point, as the scaling factor we need is cell-wise constant
-        const QMidpoint<dim> quadrature;
-
-        std::vector<types::global_dof_index> local_dof_indices (this->get_fe().dofs_per_cell);
-        FEValues<dim> fe_values (this->get_mapping(),
-                                 this->get_fe(),
-                                 quadrature,
-                                 update_quadrature_points | update_values | update_gradients);
-
-        MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
-        MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
-        MeltHandler<dim>::create_material_model_outputs(out);
-
-        typename DoFHandler<dim>::active_cell_iterator
-        cell = this->get_dof_handler().begin_active(),
-        endc = this->get_dof_handler().end();
-        for (; cell!=endc; ++cell)
-          if (cell->is_locally_owned())
-            {
-              fe_values.reinit(cell);
-              // Set use_strain_rates to false since we don't need viscosity
-              in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-              this->get_material_model().evaluate(in, out);
-
-              MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-              AssertThrow(melt_out != nullptr,
-                          ExcMessage("Need MeltOutputs from the material model for computing the melt properties."));
-
-              const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
-
-              cell->get_dof_indices (local_dof_indices);
-
-              // for each compaction pressure dof, write into the output
-              // vector the scaled compaction pressure. note that quadrature points and
-              // dofs are enumerated in the same order
-              for (unsigned int i=0; i<this->get_fe().base_element(pc_base_index).dofs_per_cell; ++i)
-                {
-                  const unsigned int system_local_dof
-                    = this->get_fe().component_to_system_index(pc_component_index,
-                                                               /*dof index within component=*/i);
-
-                  vec_distributed(local_dof_indices[system_local_dof])
-                    = p_c_scale * this->get_solution()[local_dof_indices[system_local_dof]];
-                }
-            }
-
-        vec_distributed.compress(VectorOperation::insert);
-
-        // now create a vector with the requisite ghost elements
-        // and use it for estimating the gradients
-        LinearAlgebra::BlockVector vec (this->introspection().index_sets.system_partitioning,
-                                        this->introspection().index_sets.system_relevant_partitioning,
-                                        this->get_mpi_communicator());
-        vec = vec_distributed;
-
-        DerivativeApproximation::approximate_gradient  (this->get_mapping(),
-                                                        this->get_dof_handler(),
-                                                        vec,
-                                                        indicators,
-                                                        pc_component_index);
-
-        // Scale gradient in each cell with the correct power of h. Otherwise,
-        // error indicators do not reduce when refined if there is a density
-        // jump. We need at least order 1 for the error not to grow when
-        // refining, so anything >1 should work. (note that the gradient
-        // itself scales like 1/h, so multiplying it with any factor h^s, s>1
-        // will yield convergence of the error indicators to zero as h->0)
-        const double power = 1.0 + dim/2.0;
-        {
-          unsigned int i=0;
-          for (cell = this->get_dof_handler().begin_active(); cell!=endc; ++cell, ++i)
-            if (cell->is_locally_owned())
-              indicators(i) *= std::pow(cell->diameter(), power);
-        }
-
-      }
-
-  };
-
-
-
-
-
-  template <int dim>
-  class TestMeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public SimulatorAccess<dim>
-  {
-    public:
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        const double porosity = 0.01;
-        const double permeability = porosity;
-        return permeability / 1.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            const double x = in.position[i](0);
-            const double z = in.position[i](1);
-            out.viscosities[i] = 1.0;
-            out.thermal_expansion_coefficients[i] = 0.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            out.densities[i] = 1.0;
-            // This is the RHS we need to use for the manufactured solution.
-            // We calculated it by subtracting the first term of the RHS (\Nabla (K_D \rho_f g)) from the LHS
-            // we computed using our analytical solution.
-            double reactionterm;
-            reactionterm = (0.8544665250e4 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) - 0.4950000000e1 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) + 0.3245696667e4 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) - 0.4687000001e3 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) + 0.160e3 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) * x * x + 0.3992000000e3 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * z + 0.1600000000e1 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * x - 0.1399880000e4 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * x + 0.8826800400e5 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * x + 0.1765360080e6 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * z - 0.7840998000e5 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * x * x + 0.4943188800e6 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * z * z - 0.1925014410e6 * exp(-0.400e2 * pow(x + 0.2e1 * z, 0.2e1)) * z + 0.3698838000e5 * exp(-0.600e2 * pow(x + 0.2e1 * z, 0.2e1)) * x + 0.7397676000e5 * exp(-0.600e2 * pow(x + 0.2e1 * z, 0.2e1)) * z - 0.16e2 * exp(-0.1200e3 * pow(x + 0.2e1 * z, 0.2e1)) * x - 0.32e2 * exp(-0.1200e3 * pow(x + 0.2e1 * z, 0.2e1)) * z - 0.6688400000e4 * exp(-0.800e2 * pow(x + 0.2e1 * z, 0.2e1)) * x - 0.1337680000e5 * exp(-0.800e2 * pow(x + 0.2e1 * z, 0.2e1)) * z + 0.556e3 * exp(-0.1000e3 * pow(x + 0.2e1 * z, 0.2e1)) * x + 0.1112e4 * exp(-0.1000e3 * pow(x + 0.2e1 * z, 0.2e1)) * z - 0.9625072050e5 * exp(-0.400e2 * pow(x + 0.2e1 * z, 0.2e1)) * x + 0.8e1 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) * x - 0.5763380040e5 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * z + 0.1971823986e7 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * z * z - 0.1950349995e5 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * x + 0.7723580040e6 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * x * x - 0.552024e6 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * z * z - 0.138006e6 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * x * x + 0.39792e5 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * z * z + 0.9860004000e4 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * x + 0.3318598800e5 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * z + 0.8e1 * exp(-0.100e3 * x * x - 0.400e3 * x * z - 0.400e3 * z * z + z) * x + 0.16e2 * exp(-0.100e3 * x * x - 0.400e3 * x * z - 0.400e3 * z * z + z) * z + 0.1599287976e7 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) * x * z - 0.3447976000e5 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * z + 0.1068266666e4 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * x - 0.320e3 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) * z * z + 0.4008e4 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * x * x + 0.1930895010e5 * z * z * exp(-0.20e2 * x * x - 0.20e2 * z * z + z + 0.1e1) + 0.1930895010e5 * x * x * exp(-0.20e2 * x * x - 0.20e2 * z * z + z + 0.1e1) - 0.9654475050e3 * z * exp(-0.20e2 * x * x - 0.20e2 * z * z + z + 0.1e1) + 0.9751995000e4 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * x * x + 0.3900798000e5 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * z * z + 0.3881097000e6 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * x * x + 0.1552438800e7 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * z * z + 0.1552438800e7 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) * x * z + 0.3900798000e5 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * x * z - 0.9097753500e4 * exp(-0.40e2 * x * x - 0.160e3 * x * z - 0.160e3 * z * z + z) - 0.640e3 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) * x * z + 0.4200000000e1 * exp(-0.120e3 * x * x - 0.400e3 * x * z - 0.420e3 * z * z + z + 0.1e1) - 0.9533794112e3 * exp(-0.20e2 * x * x - 0.20e2 * z * z + z + 0.1e1) - 0.1036095000e4 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) + 0.2253333334e2 * exp(-0.100e3 * x * x - 0.400e3 * x * z - 0.400e3 * z * z + z) + 0.1123231354e5 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) - 0.1863776536e5 * exp(-0.40e2 * x * x - 0.80e2 * x * z - 0.100e3 * z * z + z + 0.1e1) - 0.3960040000e5 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * x * x - 0.3696256000e6 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * z * z + 0.7636384800e6 * exp(-0.60e2 * x * x - 0.160e3 * x * z - 0.180e3 * z * z + z + 0.1e1) * x * z - 0.4400336000e6 * x * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * z + 0.47840e5 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * x * z + 0.47840e5 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * z * z + 0.11960e5 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * x * x - 0.6320160000e4 * exp(-0.80e2 * x * x - 0.240e3 * x * z - 0.260e3 * z * z + z + 0.1e1) * z + 0.9509415350e5 * exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1)) * x + 0.1901883070e6 * exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1)) * z - 0.1191523129e5 * exp(z) - 0.552024e6 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * x * z + 0.47712e5 * exp(-0.100e3 * x * x - 0.320e3 * x * z - 0.340e3 * z * z + z + 0.1e1) * x * z - 0.1723988000e5 * exp(-0.60e2 * x * x - 0.240e3 * x * z - 0.240e3 * z * z + z) * x - 0.1488766999e6 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * x - 0.2977534000e6 * exp(-0.20e2 * x * x - 0.80e2 * x * z - 0.80e2 * z * z + z) * z + 0.2136533332e4 * exp(-0.80e2 * x * x - 0.320e3 * x * z - 0.320e3 * z * z + z) * z) * pow(-0.4950000000e1 + exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1)), -0.3e1) * pow(-0.9950000000e1 + exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1)), -0.2e1);
-
-            out.reaction_terms[i][porosity_idx] = reactionterm;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                double porosity = in.composition[i][porosity_idx];
-
-                const double x = in.position[i](0);
-                const double z = in.position[i](1);
-                // porosity = 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * pow(x + 0.20e1 * z, 0.2e1));
-                // porosity = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.2e1 * z, 0.2e1));
-                melt_out->compaction_viscosities[i] = 0.1e0 + 0.1e0 * exp(-0.20e2 * x * x - 0.20e2 * z * z + 0.1e1);
-                melt_out->fluid_viscosities[i] = 1.0;
-                melt_out->permeabilities[i] = porosity;// K_D
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-                melt_out->fluid_densities[i] = 0.5;
-              }
-          }
-      }
-
-  };
-
-
-  template <int dim>
-  class Gravity : public aspect::GravityModel::Interface<dim>
-  {
-    public:
-      virtual Tensor<1,dim> gravity_vector (const Point<dim> &pos) const
-      {
-        const double x=pos[0];
-        const double z=pos[1];
-        Tensor<1,dim> gravity;
-        gravity[0] = (0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.400e2 * x - 0.8000e2 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) + 0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z)) / (0.9950000000e0 - 0.1000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)));
-        gravity[1] = (-0.1333333333e1 * exp(z) + 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.8000e2 * x - 0.160000e3 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) - 0.1e1 + 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z)) / (0.9950000000e0 - 0.1000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)));
-
-
-        return gravity;
-      }
-
-
-  };
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(2*dim+3+2) {}
-      virtual void vector_value (const Point<dim>   &p,
-                                 Vector<double>   &values) const
-      {
-        double x = p(0);
-        double z = p(1);
-
-        values[0] = x;
-        values[1] = -z + exp(z);
-        values[2] = -(0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.1e1 - z;
-        values[3] = -(0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z);
-        values[4] = x - 0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.400e2 * x - 0.8000e2 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) + 0.5e0 * (0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.400e2 * x - 0.8000e2 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) + 0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z)) / (0.9950000000e0 - 0.1000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)));
-        values[5] = -z + exp(z) - 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.8000e2 * x - 0.160000e3 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) + 0.1e1 + 0.5e0 * (-0.1333333333e1 * exp(z) + 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.8000e2 * x - 0.160000e3 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) - 0.1e1 + 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z)) / (0.9950000000e0 - 0.1000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)));
-        values[6] = 0.1e1 - z;
-        values[7] = 0;
-        values[8] = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1));
-
-        // We have to scale the compaction pressure solution to p_c_bar using sqrt(K_D / ref_K_D).
-        // K_D is equal to the porosity (as defined in the material model).
-        const double K_D = values[8];
-        const double ref_K_D = 0.01;
-        const double p_c_scale = std::sqrt(K_D / ref_K_D);
-
-        if (p_c_scale > 0)
-          values[3] /= p_c_scale;
-      }
-  };
-
-
-
-  /**
-    * A postprocessor that evaluates the accuracy of the solution
-    * by using the L2 norm.
-    */
-  template <int dim>
-  class ConvergenceMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Generate graphical output from the current solution.
-       */
-      virtual
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics);
-
-  };
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  ConvergenceMeltPostprocessor<dim>::execute (TableHandler &statistics)
-  {
-    RefFunction<dim> ref_func;
-    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
-
-    const unsigned int n_total_comp = this->introspection().n_components;
-
-    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_c_bar (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
-
-    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                        n_total_comp);
-    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
-    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+
-                                                                                dim),
-                                          n_total_comp);
-    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_f);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_c_bar,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_c);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_porosity,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_porosity);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u_f);
-
-
-    // Loop over all cells to compute the error for p_c from p_c_bar
-    const QGauss<dim> quadrature(this->get_parameters().stokes_velocity_degree+1);
-    FEValues<dim> fe_values (this->get_mapping(),
-                             this->get_fe(),
-                             quadrature,
-                             update_quadrature_points | update_values | update_gradients | update_JxW_values);
-
-    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
-    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
-
-    MeltHandler<dim>::create_material_model_outputs(out);
-
-    typename DoFHandler<dim>::active_cell_iterator
-    cell = this->get_dof_handler().begin_active(),
-    endc = this->get_dof_handler().end();
-    for (; cell!=endc; ++cell)
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-          this->get_material_model().evaluate(in, out);
-
-          const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
-
-          const unsigned int i = cell->active_cell_index();
-          cellwise_errors_p_c[i] = cellwise_errors_p_c_bar[i] * p_c_scale;
-        }
-
-    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
-    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
-    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
-    const double p_c_bar_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c_bar, VectorTools::L2_norm);
-    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
-    const double phi_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
-    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
-
-    std::ostringstream os;
-    os << std::scientific
-       << "ndofs= " << this->get_solution().size()
-       << " u_L2= " << u_l2
-       << " p_L2= "  << p_l2
-       << " p_f_L2= " << p_f_l2
-       << " p_c_bar_L2= " << p_c_bar_l2
-       << " p_c_L2= " << p_c_l2
-       << " phi_L2= " << phi_l2
-       << " u_f_L2= " << u_f_l2
-       ;
-
-    return std::make_pair("Errors", os.str());
-  }
-
-
-  template <int dim>
-  class PressureBdry:
-
-    public BoundaryFluidPressure::Interface<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id boundary_indicator,
-        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &output
-      ) const
-      {
-        for (unsigned int q=0; q<output.size(); ++q)
-          {
-            const double x = material_model_inputs.position[q][0];
-            const double z = material_model_inputs.position[q][1];
-            Tensor<1,dim> gradient;
-            gradient[0] = 0.4000000000e1 * x * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.400e2 * x - 0.8000e2 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1));
-            gradient[1] = 0.4000000000e1 * z * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) - (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) / (-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1))) + 0.2000000000e0 * (0.1e0 + 0.1e0 * exp(0.1e1 - 0.2000000000e2 * x * x - 0.2000000000e2 * z * z)) * exp(z) * pow(-0.9900000000e0 + 0.2000000000e0 * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (-0.8000e2 * x - 0.160000e3 * z) * exp(-0.200e2 * pow(x + 0.20e1 * z, 0.2e1)) - 0.1e1;
-            output[q] = gradient * normal_vectors[q];
-          }
-      }
-
-
-
-  };
-
-}
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_GRAVITY_MODEL(Gravity,
-                                "MyGravity",
-                                "")
-
-  ASPECT_REGISTER_MATERIAL_MODEL(TestMeltMaterial,
-                                 "test melt material",
-                                 "")
-  ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(MeltVelocityRefinement,
-                                            "melt velocity",
-                                            "")
-  ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(PCRefinement,
-                                            "pc",
-                                            "")
-
-  ASPECT_REGISTER_POSTPROCESSOR(ConvergenceMeltPostprocessor,
-                                "melt error calculation",
-                                "A postprocessor that compares the numerical solution to the analytical "
-                                "solution derived for incompressible melt transport in a 2D box as described "
-                                "in the manuscript and reports the error.")
-
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-
-}
diff --git a/tests/melt_transport_adaptive.prm.bak b/tests/melt_transport_adaptive.prm.bak
deleted file mode 100644
index 5318778af89..00000000000
--- a/tests/melt_transport_adaptive.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-# A testcase that demonstrates melt transport with a compactible matrix,
-# and compressible matrix and fluid. Boundary conditions for the
-# velocity and fluid pressure as well as porosity initial conditions
-# are applied as described by the derived analytical solution,
-# which can be found in the manuscript on compressible melt transport
-# in ASPECT.
-# We compute these material properties in a new material model, which
-# is implemented in the .cc file, together with a postprocessor to calculate
-# the error and a new pressure boundary condition.
-#
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 50
-set Nonlinear solver tolerance             = 1e-10
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0.2746026940#3.992884522
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Refinement fraction                      = 0.3333
-  set Coarsening fraction                      = 0.0
-  set Strategy                                 = composition, pc
-
-  #melt velocity, composition#composition, velocity# gradient#,velocity#viscosity#composition
-
-  set Time steps between mesh refinement       = 0
-  set Initial adaptive refinement              = 2
-  set Run postprocessors on initial refinement = true
-  set Normalize individual refinement criteria = true
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2
-    set Y extent  = 2
-    set Box origin X coordinate = -1
-    set Box origin Y coordinate = -1
-  end
-end
-
-subsection Gravity model
-  set Model name = MyGravity
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = x;-z+exp(z)
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants = pi=3.14159265359
-
-    #    set Function expression = if(abs(x)==1 || abs(z)==1, 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * ((x + 0.20e1 * z)^ 0.2e1)), 0)
-    #    set Function expression = 0.1000000000e-1 + 0.1000000000e0 * exp(-0.40e1 * ((x + 0.20e1 * z)^ 0.2e1))
-    set Function expression = 0.1000000000e-1 + 0.2000000000e0 * exp(-0.200e2 * ((x + 0.2e1 * z)^ 0.2e1))
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = test melt material
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, melt error calculation
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/melt_transport_compressible.cc.bak b/tests/melt_transport_compressible.cc.bak
deleted file mode 100644
index 14ecd79b67c..00000000000
--- a/tests/melt_transport_compressible.cc.bak
+++ /dev/null
@@ -1,370 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-namespace aspect
-{
-  template <int dim>
-  class CompressibleMeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual bool is_compressible () const
-      {
-        return true;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        const double permeability = K_D_0 + 2.0 * B / E - rho_s_0 * B * D / E * (1.0/rho_s_0 - 1.0/rho_f_0) * std::exp(0.5);
-        return permeability / 1.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            out.viscosities[i] = 0.5 * std::exp(2.0 * in.position[i][0]);
-            out.thermal_expansion_coefficients[i] = 0.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 1.0 / (rho_s_0 * C);
-            out.densities[i] = rho_s_0 * std::exp(-in.position[i][1]);
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = - rho_s_0 * B * D * std::exp(in.position[i][1]);
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                melt_out->compaction_viscosities[i] = xi_1 * std::exp(-in.position[i][1]) + 2.0/3.0 * std::exp(2.0 * in.position[i][0]) + xi_0;
-                melt_out->fluid_viscosities[i] = 1.0;
-                melt_out->permeabilities[i] = K_D_0 + 2.0 * B / E - rho_s_0 * B * D / E * (1.0/rho_s_0 - 1.0/rho_f_0) * std::exp(in.position[i][1]);
-                const double fluid_compressibility = 1.0 / (rho_f_0 * C);
-                melt_out->fluid_densities[i] = rho_f_0 * std::exp(-in.position[i][1]);
-                melt_out->fluid_density_gradients[i] = melt_out->fluid_densities[i] * melt_out->fluid_densities[i]
-                                                       * fluid_compressibility
-                                                       * this->get_gravity_model().gravity_vector(in.position[i]);
-              }
-          }
-      }
-
-      virtual void initialize ()
-      {
-        rho_s_0 = 1.2;
-        rho_f_0 = 1.0;
-        xi_0 = 1.0;
-        xi_1 = 1.0;
-
-        // A, B and C are constants from the velocity boundary conditions and gravity model
-        // they have to be consistent!
-        A = 0.1;
-        B = -3.0/4.0 * A;
-        C = 1.0;
-        D = 0.3;
-        E = - 3.0/4.0 * xi_0 * A + C * D *(rho_f_0 - rho_s_0);
-
-        K_D_0 = 2.2;
-      }
-
-
-    private:
-      double rho_s_0;
-      double rho_f_0;
-      double xi_0;
-      double xi_1;
-      double K_D_0;
-      double A;
-      double B;
-      double C;
-      double D;
-      double E;
-
-
-  };
-
-
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(2*dim+5) {}
-      virtual void vector_value (const Point<dim>   &p,
-                                 Vector<double>   &values) const
-      {
-        const double x = p(0);
-        const double y = p(1);
-        const double porosity = 1.0 - 0.3 * std::exp(y);
-        const double K_D = 2.2 + 2.0 * 0.075/0.135 + (1.0 - 5.0/6.0) * 0.075 * 0.3 * 1.2 / 0.135 * std::exp(y);
-        const double ref_K_D = 2.2 + 2.0 * 0.075/0.135 + (1.0 - 5.0/6.0) * 0.075 * 0.3 * 1.2 / 0.135 * std::exp(0.5);
-
-        values[0]=0.1 * std::exp(y);       // x vel
-        values[1]=-0.075 * std::exp(y);    // y vel
-        values[2]=-0.135*(std::exp(y) - std::exp(1)) + 1.0 - y;  // p_f
-        values[3]=0.75 * (std::exp(-y) + 2.0/3.0 * std::exp(2.0*x) + 1.0) * 0.1 * std::exp(y);  // p_c_bar
-        values[4]=0.1 * std::exp(y);       // x melt vel
-        values[5]=-0.075 * std::exp(y) + 0.135 * std::exp(y) * K_D / porosity;    // y melt vel
-
-        values[6]=values[2] + values[3] / (1.0 - porosity);  // p_s
-        values[7]=0; // T
-        values[8]=porosity; // porosity
-
-        // We have to scale the compaction pressure solution to p_c_bar using sqrt(K_D / ref_K_D).
-        // K_D is equal to the porosity (as defined in the material model).
-        const double p_c_scale = std::sqrt(K_D / ref_K_D);
-        if (p_c_scale > 0)
-          values[3] /= p_c_scale;
-      }
-  };
-
-  /**
-    * A postprocessor that evaluates the accuracy of the solution
-    * by using the L2 norm.
-    */
-  template <int dim>
-  class CompressibleMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Generate graphical output from the current solution.
-       */
-      virtual
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics);
-
-
-    private:
-      double rho_s_0;
-      double rho_f_0;
-      double xi_0;
-      double xi_1;
-      double K_D_0;
-      double A;
-      double B;
-      double C;
-      double D;
-      double E;
-  };
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  CompressibleMeltPostprocessor<dim>::execute (TableHandler &)
-  {
-    RefFunction<dim> ref_func;
-    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
-
-    const unsigned int n_total_comp = this->introspection().n_components;
-
-    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_c_bar (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
-
-    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                        n_total_comp);
-    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
-    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+dim),
-                                          n_total_comp);
-    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_f);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_c_bar,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_c);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_porosity,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_porosity);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u_f);
-
-
-    // Loop over all cells to compute the error for p_c from p_c_bar
-    const QGauss<dim> quadrature(this->get_parameters().stokes_velocity_degree+1);
-    FEValues<dim> fe_values (this->get_mapping(),
-                             this->get_fe(),
-                             quadrature,
-                             update_quadrature_points | update_values | update_gradients | update_JxW_values);
-
-    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
-    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
-
-    MeltHandler<dim>::create_material_model_outputs(out);
-
-    typename DoFHandler<dim>::active_cell_iterator
-    cell = this->get_dof_handler().begin_active(),
-    endc = this->get_dof_handler().end();
-    for (; cell!=endc; ++cell)
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-          this->get_material_model().evaluate(in, out);
-
-          const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
-
-          const unsigned int i = cell->active_cell_index();
-          cellwise_errors_p_c[i] = cellwise_errors_p_c_bar[i] * p_c_scale;
-        }
-
-    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
-    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
-    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
-    const double p_c_bar_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c_bar, VectorTools::L2_norm);
-    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
-    const double phi_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
-    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
-
-    std::ostringstream os;
-    os << std::scientific << std::sqrt(Utilities::MPI::sum(cellwise_errors_u.norm_sqr(),MPI_COMM_WORLD))
-       << ", " << u_l2
-       << ", " << p_l2
-       << ", " << p_f_l2
-       << ", " << p_c_bar_l2
-       << ", " << p_c_l2
-       << ", " << phi_l2
-       << ", " << u_f_l2;
-
-    return std::make_pair("Errors u_L2, p_L2, p_f_L2, p_c_bar_L2, p_c_L2, porosity_L2, u_f_L2:", os.str());
-  }
-
-
-  template <int dim>
-  class PressureBdry:
-
-    public BoundaryFluidPressure::Interface<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id,
-        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const MaterialModel::MaterialModelOutputs<dim> &,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &output
-      ) const
-      {
-        for (unsigned int q=0; q<output.size(); ++q)
-          {
-            const double rho_s_0 = 1.2;
-            const double rho_f_0 = 1.0;
-            const double xi_0 = 1.0;
-            const double A = 0.1;
-            const double C = 1.0;
-            const double D = 0.3;
-            const double E = - 3.0/4.0 * xi_0 * A + C * D *(rho_f_0 - rho_s_0);
-            const double y = material_model_inputs.position[q][1];
-            Tensor<1,dim> gravity;
-            gravity[dim-1] = 1.0;
-            output[q] = (E * std::exp(y) - rho_f_0 * C) * gravity * normal_vectors[q];
-          }
-      }
-
-
-
-  };
-
-}
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(CompressibleMeltMaterial,
-                                 "compressible melt material",
-                                 "")
-
-
-  ASPECT_REGISTER_POSTPROCESSOR(CompressibleMeltPostprocessor,
-                                "compressible melt error",
-                                "A postprocessor that compares the numerical solution to the analytical "
-                                "solution derived for compressible melt transport in a 2D box as described "
-                                "in the manuscript and reports the error.")
-
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-
-}
diff --git a/tests/melt_transport_compressible.prm.bak b/tests/melt_transport_compressible.prm.bak
deleted file mode 100644
index 039f2472f53..00000000000
--- a/tests/melt_transport_compressible.prm.bak
+++ /dev/null
@@ -1,142 +0,0 @@
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 50
-
-# This model is very sensitive to nonlinear solver tolerance and sometimes does
-# not quite reach 1e-5, increase to 2e-5 to avoid non-convergence
-set Nonlinear solver tolerance             = 2e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-# A testcase that demonstrates melt transport with a compactible matrix,
-# and compressible matrix and fluid. Boundary conditions for the
-# velocity and fluid pressure as well as porosity initial conditions
-# are applied as described by the derived analytical solution,
-# which can be found in the manuscript on compressible melt transport
-# in ASPECT.
-# We compute these material properties in a new material model, which
-# is implemented in the .cc file, together with a postprocessor to calculate
-# the error and a new pressure boundary condition.
-#
-subsection Discretization
-  # The polynomial degree to use for the composition variable(s). Units:
-  # None.
-  set Composition polynomial degree           = 2
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;-exp(y)
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = 0.1*exp(y);-0.3/4.0*exp(y)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0 - 0.3 * exp(y)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = compressible melt material
-end
-
-subsection Melt settings
-  set Use discontinuous compaction pressure = false
-  set Average melt velocity                 = false
-  set Include melt transport                  = true
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 6
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, compressible melt error
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/melt_transport_compressible_iterative.cc.bak b/tests/melt_transport_compressible_iterative.cc.bak
deleted file mode 100644
index 42941744080..00000000000
--- a/tests/melt_transport_compressible_iterative.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "melt_transport_compressible.cc"
diff --git a/tests/melt_transport_compressible_iterative.prm.bak b/tests/melt_transport_compressible_iterative.prm.bak
deleted file mode 100644
index 7e95b7e74d5..00000000000
--- a/tests/melt_transport_compressible_iterative.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 5
-set Nonlinear solver tolerance             = 1e-6
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-# Identical to melt_transport_compressible.prm except using an iterative
-# solver. Note that because of the low resolution the linear and nonlinear
-# solver tolerance for this test is increased. Higher resolutions converge
-# correctly.
-
-subsection Discretization
-  # The polynomial degree to use for the composition variable(s). Units:
-  # None.
-  set Composition polynomial degree           = 2
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;-exp(y)
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = 0.1*exp(y);-0.3/4.0*exp(y)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0 - 0.3 * exp(y)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = compressible melt material
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 1.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-  set Run postprocessors on initial refinement = true
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, compressible melt error
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-5
-    set Use direct solver for Stokes system = false
-    set GMRES solver restart length = 200
-  end
-end
diff --git a/tests/melt_transport_convergence_simple.cc.bak b/tests/melt_transport_convergence_simple.cc.bak
deleted file mode 100644
index a96af49bcd7..00000000000
--- a/tests/melt_transport_convergence_simple.cc.bak
+++ /dev/null
@@ -1,326 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-const double c = 1.0;
-
-
-namespace aspect
-{
-  template <int dim>
-  class TestMeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        const double porosity = 0.01;
-        const double permeability = porosity * porosity;
-        return permeability / 1.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            const double porosity = in.composition[i][porosity_idx];
-            const double x = in.position[i](0);
-            const double z = in.position[i](1);
-            out.viscosities[i] = std::exp(c * porosity);
-            out.thermal_expansion_coefficients[i] = 0.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            out.densities[i] = 1.0;
-            // This is the RHS we need to use for the manufactured solution.
-            // We calculated it by subtracting the first term of the RHS (\Nabla (K_D \rho_f g)) from the LHS
-            // we computed using our analytical solution.
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                double porosity = in.composition[i][porosity_idx];
-                melt_out->compaction_viscosities[i] = std::exp(c * porosity);
-                melt_out->fluid_viscosities[i] = 1.0;
-                melt_out->permeabilities[i] = porosity * porosity;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-                melt_out->fluid_densities[i] = 1.0;
-              }
-          }
-      }
-  };
-
-
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(2*dim+5) {}
-      virtual void vector_value (const Point<dim>   &p,
-                                 Vector<double>   &values) const
-      {
-        double x = p(0);
-        double z = p(1);
-        const double porosity = 0.15 + 1.0/20.0 * (numbers::PI/2.0 + std::atan(x + 2*z));
-
-        values[0]= 1.0;       // x vel
-        values[1]= 1.0;    // z vel
-        values[2]= std::exp(z/10.0);  // p_f
-        values[3]= 0;  // p_c
-        values[4]= 1.0;       // x melt vel
-        values[5]= 1.0;    // y melt vel
-        values[6]= std::exp(z/10.0);  // p_s
-        values[7]= 0; // T
-        values[8]= porosity;
-
-        // We have to scale the compaction pressure solution to p_c_bar using sqrt(K_D / ref_K_D).
-        // K_D is equal to the porosity (as defined in the material model).
-        const double K_D = values[8] * values[8];
-        const double ref_K_D = 0.01 * 0.01;
-        const double p_c_scale = std::sqrt(K_D / ref_K_D);
-
-        if (p_c_scale > 0)
-          values[3] /= p_c_scale;
-      }
-  };
-
-  /**
-    * A postprocessor that evaluates the accuracy of the solution
-    * by using the L2 norm.
-    */
-  template <int dim>
-  class ConvergenceMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Generate graphical output from the current solution.
-       */
-      virtual
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics);
-
-  };
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  ConvergenceMeltPostprocessor<dim>::execute (TableHandler &statistics)
-  {
-    RefFunction<dim> ref_func;
-    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
-
-    const unsigned int n_total_comp = this->introspection().n_components;
-
-    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_c_bar (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
-
-    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                        n_total_comp);
-    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
-    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+dim),
-                                          n_total_comp);
-    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_f);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_c_bar,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_c);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_porosity,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_porosity);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u_f);
-
-
-    // Loop over all cells to compute the error for p_c from p_c_bar
-    const QGauss<dim> quadrature(this->get_parameters().stokes_velocity_degree+1);
-    FEValues<dim> fe_values (this->get_mapping(),
-                             this->get_fe(),
-                             quadrature,
-                             update_quadrature_points | update_values | update_gradients | update_JxW_values);
-
-    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
-    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
-
-    MeltHandler<dim>::create_material_model_outputs(out);
-
-    typename DoFHandler<dim>::active_cell_iterator
-    cell = this->get_dof_handler().begin_active(),
-    endc = this->get_dof_handler().end();
-    for (; cell!=endc; ++cell)
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-          this->get_material_model().evaluate(in, out);
-
-          const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
-
-          const unsigned int i = cell->active_cell_index();
-          cellwise_errors_p_c[i] = cellwise_errors_p_c_bar[i] * p_c_scale;
-        }
-
-    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
-    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
-    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
-    const double p_c_bar_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c_bar, VectorTools::L2_norm);
-    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
-    const double poro_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
-    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
-
-    std::ostringstream os;
-    os << std::scientific << u_l2
-       << ", " << p_l2
-       << ", " << p_f_l2
-       << ", " << p_c_bar_l2
-       << ", " << p_c_l2
-       << ", " << poro_l2
-       << ", " << u_f_l2;
-
-    return std::make_pair("Errors u_L2, p_L2, p_f_L2, p_c_bar_L2, p_c_L2, porosity_L2, u_f_L2:", os.str());
-  }
-
-
-  template <int dim>
-  class PressureBdry:
-
-    public BoundaryFluidPressure::Interface<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id boundary_indicator,
-        const typename MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const typename MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &output
-      ) const
-      {
-        for (unsigned int q=0; q<output.size(); ++q)
-          {
-            const double z = material_model_inputs.position[q][1];
-            Tensor<1,dim> gravity;
-            gravity[0] = 0.0;
-            gravity[dim-1] = 1.0;
-            output[q] = 0.1 * std::exp(z/10.0) * gravity * normal_vectors[q];
-          }
-      }
-
-
-
-  };
-
-}
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(TestMeltMaterial,
-                                 "test melt material",
-                                 "")
-
-
-  ASPECT_REGISTER_POSTPROCESSOR(ConvergenceMeltPostprocessor,
-                                "melt error calculation",
-                                "A postprocessor that compares the numerical solution to the analytical "
-                                "solution derived for incompressible melt transport in a 2D box as described "
-                                "in the manuscript and reports the error.")
-
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-
-}
diff --git a/tests/melt_transport_convergence_simple.prm.bak b/tests/melt_transport_convergence_simple.prm.bak
deleted file mode 100644
index f4e2a3b7a20..00000000000
--- a/tests/melt_transport_convergence_simple.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-# A testcase that demonstrates melt transport with a compactible matrix,
-# and compressible matrix and fluid. Boundary conditions for the
-# velocity and fluid pressure as well as porosity initial conditions
-# are applied as described by the derived analytical solution,
-# which can be found in the manuscript on compressible melt transport
-# in ASPECT.
-# We compute these material properties in a new material model, which
-# is implemented in the .cc file, together with a postprocessor to calculate
-# the error and a new pressure boundary condition.
-#
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-6
-set Max nonlinear iterations               = 5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 2.718281828
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 20
-    set Y extent  = 20
-    set Box origin X coordinate = -10
-    set Box origin Y coordinate = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Function constants = c=1,pi=3.14159265359
-    set Function expression = 0.0;\
-                              0.1 * exp(z/10.0);
-    set Variable names      = x,z
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = 1.0;1.0
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants = pi=3.14159265359
-    set Function expression = 0.15+1.0/20.0*(pi/2+atan(x+2*z))
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = test melt material
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, melt error calculation
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-10
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/melt_transport_convergence_test.cc.bak b/tests/melt_transport_convergence_test.cc.bak
deleted file mode 100644
index c87649be7a1..00000000000
--- a/tests/melt_transport_convergence_test.cc.bak
+++ /dev/null
@@ -1,330 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-#include <aspect/simulator.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-namespace aspect
-{
-  template <int dim>
-  class TestMeltMaterial:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        const double porosity = 0.01;
-        const double permeability = porosity * porosity;
-        return permeability / 1.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-        double c = 1.0;
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            const double porosity = in.composition[i][porosity_idx];
-            const double x = in.position[i](0);
-            const double z = in.position[i](1);
-            out.viscosities[i] = exp(c*porosity);
-            out.thermal_expansion_coefficients[i] = 0.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            out.densities[i] = 1.0;
-            // This is the RHS we need to use for the manufactured solution.
-            // We calculated it by subtracting the first term of the RHS (\Nabla (K_D \rho_f g)) from the LHS
-            // we computed using our analytical solution.
-            out.reaction_terms[i][porosity_idx] =
-              0.1000000000e1 + 0.1000000000e0 * (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1))) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) - 0.1000000000e1 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.10e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.20e0 * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.25e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.50e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) - 0.50e-2 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.3e1) * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) - 0.10e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.20e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * pow(x + 0.20e1 * z, 0.3e1)) + 0.1000000000e0 * (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z)) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) - 0.1000000000e1 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.4000e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.400e0 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.25e-2 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.50e-2 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) - 0.50e-2 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.3e1) * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) - 0.4000e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.400e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * pow(x + 0.20e1 * z, 0.3e1) + 0.2500000000e-2 * exp(0.5000000000e-1 * z)) - 0.5000000000e-1 * (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.1166666666e0 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.100e1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1))) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e0 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.2333333332e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.4666666664e0 * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.5833333330e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.20000e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) - 0.2000e0 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) * pow(x + 0.20e1 * z, 0.3e1) - 0.2500e-2 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * (0.2e1 * x + 0.40e1 * z) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) - 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.10e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.20e0 * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.25e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.50e-2 * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) - 0.50e-2 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.3e1) * pow(0.2e1 * x + 0.40e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) - 0.10e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.20e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * pow(x + 0.20e1 * z, 0.3e1)) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.1250000000e-1 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.1166666666e0 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.100e1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1))) * pow(0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) - 0.5000000000e-1 * (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.1666666667e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z)) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e0 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.1333333334e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.1333333334e0 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.8333333335e-3 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.20000e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) - 0.40000e0 * (0.2e1 * x + 0.40e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) * pow(x + 0.20e1 * z, 0.3e1) - 0.2500e-2 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * (0.2e1 * x + 0.40e1 * z) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) - 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.4000e0 / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.400e0 * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(x + 0.20e1 * z, 0.3e1) - 0.25e-2 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.50e-2 * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) - 0.50e-2 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.3e1) * pow(0.40e1 * x + 0.800e1 * z, 0.2e1) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) - 0.4000e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.400e0 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) * pow(0.1e1 + pow(x + 0.20e1 * z, 0.4e1), -0.2e1) * pow(x + 0.20e1 * z, 0.3e1) + 0.2500000000e-2 * exp(0.5000000000e-1 * z)) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.1250000000e-1 * pow(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), 0.2e1) * (0.1666666667e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z)) * pow(0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1));
-
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            double c = 1.0;
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                double porosity = in.composition[i][porosity_idx];
-                melt_out->compaction_viscosities[i] = exp(c*porosity);
-                melt_out->fluid_viscosities[i] = 1.0;
-                melt_out->permeabilities[i] = porosity * porosity;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-                melt_out->fluid_densities[i] = 0.5;
-              }
-          }
-      }
-
-  };
-
-
-
-
-  template <int dim>
-  class RefFunction : public Function<dim>
-  {
-    public:
-      RefFunction () : Function<dim>(2*dim+5) {}
-      virtual void vector_value (const Point<dim>   &p,
-                                 Vector<double>   &values) const
-      {
-        double x = p(0);
-        double z = p(1);
-
-        values[0] = x + sin(z);
-        values[1] = x;
-        values[2] = -exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + exp(0.5000000000e-1 * z);
-        values[3] = -exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)));
-        values[4] = x + sin(z) - (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) - 0.5e0 * (0.1166666666e0 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.100e1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * sin(z) + 0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1))) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))));
-        values[5] = x - (0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z) - 0.5e0 * (0.1666666667e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) + 0.500e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * (cos(z) + 0.1e1) + 0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z)) / (0.95e0 + 0.25e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))));
-        values[6] = exp(0.5000000000e-1 * z);
-        values[7] = 0;
-        values[8] = 0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1));
-
-        // We have to scale the compaction pressure solution to p_c_bar using sqrt(K_D / ref_K_D).
-        // K_D is equal to the porosity (as defined in the material model).
-        const double K_D = values[8] * values[8];
-        const double ref_K_D = 0.01 * 0.01;
-        const double p_c_scale = std::sqrt(K_D / ref_K_D);
-
-        if (p_c_scale > 0)
-          values[3] /= p_c_scale;
-      }
-  };
-
-
-
-  /**
-    * A postprocessor that evaluates the accuracy of the solution
-    * by using the L2 norm.
-    */
-  template <int dim>
-  class ConvergenceMeltPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      /**
-       * Generate graphical output from the current solution.
-       */
-      virtual
-      std::pair<std::string,std::string>
-      execute (TableHandler &statistics);
-
-  };
-
-  template <int dim>
-  std::pair<std::string,std::string>
-  ConvergenceMeltPostprocessor<dim>::execute (TableHandler &statistics)
-  {
-    RefFunction<dim> ref_func;
-    const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
-    const unsigned int n_total_comp = this->introspection().n_components;
-
-    Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_c (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p_c_bar (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_u_f (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-    Vector<float> cellwise_errors_porosity (this->get_triangulation().n_active_cells());
-
-    ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                        n_total_comp);
-    ComponentSelectFunction<dim> comp_p_f(dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_p_c(dim+1, n_total_comp);
-    ComponentSelectFunction<dim> comp_u_f(std::pair<unsigned int, unsigned int>(dim+2,dim+2+
-                                                                                dim),
-                                          n_total_comp);
-    ComponentSelectFunction<dim> comp_p(dim+2+dim, n_total_comp);
-    ComponentSelectFunction<dim> comp_porosity(dim+2+dim+2, n_total_comp);
-
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_f);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_p_c_bar,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_p_c);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_porosity,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_porosity);
-    VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                       this->get_solution(),
-                                       ref_func,
-                                       cellwise_errors_u_f,
-                                       quadrature_formula,
-                                       VectorTools::L2_norm,
-                                       &comp_u_f);
-
-
-    // Loop over all cells to compute the error for p_c from p_c_bar
-    const QGauss<dim> quadrature(this->get_parameters().stokes_velocity_degree+1);
-    FEValues<dim> fe_values (this->get_mapping(),
-                             this->get_fe(),
-                             quadrature,
-                             update_quadrature_points | update_values | update_gradients | update_JxW_values);
-
-    MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), this->n_compositional_fields());
-    MaterialModel::MaterialModelOutputs<dim> out(quadrature.size(), this->n_compositional_fields());
-
-    MeltHandler<dim>::create_material_model_outputs(out);
-
-    typename DoFHandler<dim>::active_cell_iterator
-    cell = this->get_dof_handler().begin_active(),
-    endc = this->get_dof_handler().end();
-    for (; cell!=endc; ++cell)
-      if (cell->is_locally_owned())
-        {
-          fe_values.reinit (cell);
-          in.reinit(fe_values, cell, this->introspection(), this->get_solution());
-
-          this->get_material_model().evaluate(in, out);
-
-          const double p_c_scale = dynamic_cast<const MaterialModel::MeltInterface<dim>*>(&this->get_material_model())->p_c_scale(in, out, this->get_melt_handler(), true);
-
-          const unsigned int i = cell->active_cell_index();
-          cellwise_errors_p_c[i] = cellwise_errors_p_c_bar[i] * p_c_scale;
-        }
-
-    const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L2_norm);
-    const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L2_norm);
-    const double p_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_f, VectorTools::L2_norm);
-    const double p_c_bar_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c_bar, VectorTools::L2_norm);
-    const double p_c_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p_c, VectorTools::L2_norm);
-    const double poro_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_porosity, VectorTools::L2_norm);
-    const double u_f_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u_f, VectorTools::L2_norm);
-
-    std::ostringstream os;
-    os << std::scientific << u_l2
-       << ", " << p_l2
-       << ", " << p_f_l2
-       << ", " << p_c_bar_l2
-       << ", " << p_c_l2
-       << ", " << poro_l2
-       << ", " << u_f_l2;
-
-    return std::make_pair("Errors u_L2, p_L2, p_f_L2, p_c_bar_L2, p_c_L2, porosity_L2, u_f_L2:", os.str());
-  }
-
-
-  template <int dim>
-  class PressureBdry:
-
-    public BoundaryFluidPressure::Interface<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id boundary_indicator,
-        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &output
-      ) const
-      {
-        for (unsigned int q=0; q<output.size(); ++q)
-          {
-            const double x = material_model_inputs.position[q][0];
-            const double z = material_model_inputs.position[q][1];
-            Tensor<1,dim> gradient;
-            gradient[0] = 0.5e-1 * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.2e1 * x + 0.40e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1));
-            gradient[1] = 0.5e-1 * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) / (-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) - 0.5e-1 * exp(0.1e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1))) * pow(-0.9e0 - 0.5e-1 * atan(pow(x + 0.20e1 * z, 0.2e1)), -0.2e1) * (0.40e1 * x + 0.800e1 * z) / (0.1e1 + pow(x + 0.20e1 * z, 0.4e1)) + 0.5000000000e-1 * exp(0.5000000000e-1 * z);
-            output[q] = gradient * normal_vectors[q];
-          }
-      }
-
-
-
-  };
-
-}
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(TestMeltMaterial,
-                                 "test melt material",
-                                 "")
-
-
-  ASPECT_REGISTER_POSTPROCESSOR(ConvergenceMeltPostprocessor,
-                                "melt error calculation",
-                                "A postprocessor that compares the numerical solution to the analytical "
-                                "solution derived for incompressible melt transport in a 2D box as described "
-                                "in the manuscript and reports the error.")
-
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-
-}
diff --git a/tests/melt_transport_convergence_test.prm.bak b/tests/melt_transport_convergence_test.prm.bak
deleted file mode 100644
index 3a65be2ef38..00000000000
--- a/tests/melt_transport_convergence_test.prm.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-# A testcase that demonstrates melt transport with a compactible matrix,
-# and incompressible matrix and fluid. Boundary conditions for the
-# velocity and fluid pressure as well as porosity initial conditions
-# are applied as described by the derived analytical solution,
-# which can be found in the manuscript on compressible melt transport
-# in ASPECT.
-# We compute these material properties in a new material model, which
-# is implemented in the .cc file, together with a postprocessor to calculate
-# the error and a new pressure boundary condition.
-# An important feature of this setup is the high porosity vein that
-# runs through the model and we use it to demonstrate the effectiveness
-# of adaptive mesh refinement.
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 2.693171882
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = false
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 20
-    set Y extent  = 20
-    set Box origin X coordinate = -10
-    set Box origin Y coordinate = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = function
-
-  subsection Function
-    set Function constants = c=1,pi=3.14159265359
-    set Function expression = (.1166666666*(2*x+4.0*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))+.500e-1*(4.0*x+8.00*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))*(cos(z)+1)+1.00*exp(.1-.5e-1*atan((x+2.0*z)^2))*sin(z)+.5e-1*(2*x+4.0*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))/(-.9-.5e-1*atan((x+2.0*z)^2))-.5e-1*exp(.1-.5e-1*atan((x+2.0*z)^2))/(-.9-.5e-1*atan((x+2.0*z)^2))^2*(2*x+4.0*z)/(1+(x+2.0*z)^4))/(.95+.25e-1*atan((x+2.0*z)^2));\
-                              (.1666666667e-1*(4.0*x+8.00*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))+.500e-1*(2*x+4.0*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))*(cos(z)+1)+.5e-1*(4.0*x+8.00*z)/(1+(x+2.0*z)^4)*exp(.1-.5e-1*atan((x+2.0*z)^2))/(-.9-.5e-1*atan((x+2.0*z)^2))-.5e-1*exp(.1-.5e-1*atan((x+2.0*z)^2))/(-.9-.5e-1*atan((x+2.0*z)^2))^2*(4.0*x+8.00*z)/(1+(x+2.0*z)^4)+.5000000000e-1*exp(.5000000000e-1*z))/(.95+.25e-1*atan((x+2.0*z)^2))
-    set Variable names      = x,z
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function, 2:function, 3:function
-  set Zero velocity boundary indicators       =
-
-  subsection Function
-    set Function expression = x+sin(z);x
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants = pi=3.14159265359
-    set Function expression = 0.1-0.05*atan((x+2.0*z)*(x+2.0*z))
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = test melt material
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.95
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, velocity boundary statistics, melt error calculation
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/melt_velocity_boundary_conditions.cc.bak b/tests/melt_velocity_boundary_conditions.cc.bak
deleted file mode 100644
index e127b3eaeac..00000000000
--- a/tests/melt_velocity_boundary_conditions.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "free_surface_blob_melt.cc"
diff --git a/tests/melt_velocity_boundary_conditions.prm.bak b/tests/melt_velocity_boundary_conditions.prm.bak
deleted file mode 100644
index e841e5d409f..00000000000
--- a/tests/melt_velocity_boundary_conditions.prm.bak
+++ /dev/null
@@ -1,154 +0,0 @@
-# Test for the boundary conditions for the melt velocity
-# (which can not be set explicitly, but are implied by the boundary
-# conditions for the fluid pressure gradient) with melt transport = on
-# and a constant nonzero porosity at the top boundary.
-# The boundary conditions are set in a way that no melt should flow in
-# or out.
-#
-# The test is similar to free_surface_blob_melt, except that melt
-# has a nonzero initial condition, and there is no free surface.
-# We test if the boundary conditions for melt are set correctly
-# (no melt flowing in/out at the top surface) by checking if the
-# velocity field at the upper boundary is small (it should converge to
-# zero with increasing resolution close to the upper surface).
-
-set Dimension = 2
-set CFL number                             = 0.5
-set End time                               = 0
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = surface
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-set Maximum time step                      = 1e4
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = melt free surface
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,3
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.02 * y/2.e5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, visualization, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables =  melt material properties, material properties
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/melt_visco_plastic.cc.bak b/tests/melt_visco_plastic.cc.bak
deleted file mode 100644
index aaa6ba28bdc..00000000000
--- a/tests/melt_visco_plastic.cc.bak
+++ /dev/null
@@ -1,1038 +0,0 @@
-/*
-  Copyright (C) 2015 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _aspect_material_model_melt_visco_plastic_h
-#define _aspect_material_model_melt_visco_plastic_h
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator.h>
-#include <aspect/simulator_access.h>
-#include <aspect/postprocess/melt_statistics.h>
-#include <aspect/melt.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/numerics/fe_field_function.h>
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/base/parsed_function.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * Additional output fields for the plastic parameters weakened (or hardened)
-     * by strain to be added to the MaterialModel::MaterialModelOutputs structure
-     * and filled in the MaterialModel::Interface::evaluate() function.
-     */
-    template <int dim>
-    class PlasticAdditionalOutputs2 : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        PlasticAdditionalOutputs2(const unsigned int n_points);
-
-        virtual std::vector<double> get_nth_output(const unsigned int idx) const;
-
-        /**
-         * Cohesions at the evaluation points passed to
-         * the instance of MaterialModel::Interface::evaluate() that fills
-         * the current object.
-         */
-        std::vector<double> cohesions;
-
-        /**
-         * Internal angles of friction at the evaluation points passed to
-         * the instance of MaterialModel::Interface::evaluate() that fills
-         * the current object.
-         */
-        std::vector<double> friction_angles;
-
-        /**
-         * The area where the viscous stress exceeds the plastic yield strength,
-         * and viscosity is rescaled back to the yield envelope.
-         */
-        std::vector<double> yielding;
-    };
-
-    /**
-     * A material model that implements a simple formulation of the
-     * material parameters required for the modeling of melt transport,
-     * including a source term for the porosity according to the melting
-     * model for dry peridotite of Katz, 2003. This also includes a
-     * computation of the latent heat of melting (if the latent heat
-     * heating model is active).
-     *
-     * Most of the material properties are constant, except for the shear,
-     * compaction and melt viscosities and the permeability, which depend on
-     * the porosity; and the solid and melt densities, which depend on
-     * temperature and pressure.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class MeltViscoPlastic : public MaterialModel::MeltFractionModel<dim>,
-      public MaterialModel::MeltInterface<dim>,
-      public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-
-        /**
-         * Return whether the model is compressible or not.
-         * In this case, Keller et al, 2003 assume the fluid and
-         * solid phases are each incompressible: "compressibility
-         * in the model is accounted for by changes in melt fraction."
-         * Thus, this function will always return false.
-         */
-        bool is_compressible () const override;
-
-        /**
-         * @name Reference quantities
-         * @{
-         */
-        double reference_darcy_coefficient () const override;
-
-        void evaluate(const typename Interface<dim>::MaterialModelInputs &in,
-                      typename Interface<dim>::MaterialModelOutputs &out) const override;
-
-        virtual void melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                                     std::vector<double> &melt_fractions) const;
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Functions used in dealing with run-time parameters
-         * @{
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-        /**
-         * @}
-         */
-
-        virtual
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const override;
-
-      private:
-
-        double ref_temperature;
-
-        std::vector<double> densities;
-        std::vector<double> thermal_expansivities;
-        std::vector<double> specific_heats;
-        std::vector<double> thermal_conductivities;
-
-        double min_strain_rate;
-        double ref_strain_rate;
-        double min_viscosity;
-        double max_viscosity;
-
-        double ref_viscosity;
-
-        /**
-         * Enumeration for selecting which viscosity averaging scheme to use.
-         */
-        MaterialUtilities::CompositionalAveragingOperation viscosity_averaging;
-
-        std::vector<double> linear_viscosities;
-
-        std::vector<double> angles_internal_friction;
-        std::vector<double> cohesions;
-
-        double maximum_yield_stress;
-
-        std::vector<double> strength_reductions;
-
-        double melt_density_change;
-        double xi_0;
-        double eta_f;
-        double reference_permeability;
-        double alpha_phi;
-        double freezing_rate;
-        double melting_time_scale;
-
-        /**
-         * Parameters for anhydrous melting of peridotite after Katz, 2003
-         */
-
-        // for the solidus temperature
-        double A1;   // °C
-        double A2; // °C/Pa
-        double A3; // °C/(Pa^2)
-
-        // for the lherzolite liquidus temperature
-        double B1;   // °C
-        double B2;   // °C/Pa
-        double B3; // °C/(Pa^2)
-
-        // for the liquidus temperature
-        double C1;   // °C
-        double C2;  // °C/Pa
-        double C3; // °C/(Pa^2)
-
-        // for the reaction coefficient of pyroxene
-        double r1;     // cpx/melt
-        double r2;     // cpx/melt/GPa
-        double M_cpx;  // mass fraction of pyroxene
-
-        // melt fraction exponent
-        double beta;
-
-        /**
-         * Percentage of material that is molten for a given temperature and
-         * pressure (assuming equilibrium conditions). Melting model after Katz,
-         * 2003, for dry peridotite.
-         */
-        virtual
-        double
-        melt_fraction (const double temperature,
-                       const double pressure) const;
-
-        /**
-         * A function that fills the plastic additional output in the
-         * MaterialModelOutputs object that is handed over, if it exists.
-         * Does nothing otherwise.
-         */
-        void fill_plastic_outputs (const unsigned int point_index,
-                                   const std::vector<double> &volume_fractions,
-                                   const bool plastic_yielding,
-                                   const MaterialModel::MaterialModelInputs<dim> &in,
-                                   MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-        /**
-         * Whether to use a function defined as an input parameter for the melting rate
-         */
-        bool use_melting_rate_function;
-
-        /**
-         * A function object representing the melting rate.
-         */
-        Functions::ParsedFunction<dim> function;
-
-    };
-
-  }
-}
-
-#endif
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    using namespace dealii;
-
-    namespace
-    {
-      std::vector<std::string> make_plastic_additional_outputs_names()
-      {
-        std::vector<std::string> names;
-        names.emplace_back("current_cohesions");
-        names.emplace_back("current_friction_angles");
-        names.emplace_back("plastic_yielding");
-        return names;
-      }
-    }
-
-    template <int dim>
-    PlasticAdditionalOutputs2<dim>::PlasticAdditionalOutputs2 (const unsigned int n_points)
-      :
-      NamedAdditionalMaterialOutputs<dim>(make_plastic_additional_outputs_names()),
-      cohesions(n_points, numbers::signaling_nan<double>()),
-      friction_angles(n_points, numbers::signaling_nan<double>()),
-      yielding(n_points, numbers::signaling_nan<double>())
-    {}
-
-    template <int dim>
-    std::vector<double>
-    PlasticAdditionalOutputs2<dim>::get_nth_output(const unsigned int idx) const
-    {
-      AssertIndexRange (idx, 3);
-      switch (idx)
-        {
-          case 0:
-            return cohesions;
-
-          case 1:
-            return friction_angles;
-
-          case 2:
-            return yielding;
-
-          default:
-            AssertThrow(false, ExcInternalError());
-        }
-      // We will never get here, so just return something
-      return cohesions;
-    }
-
-    template <int dim>
-    double
-    MeltViscoPlastic<dim>::
-    reference_darcy_coefficient () const
-    {
-      // 0.01 = 1% melt
-      return reference_permeability * std::pow(0.01,3.0) / eta_f;
-    }
-
-    template <int dim>
-    bool
-    MeltViscoPlastic<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    double
-    MeltViscoPlastic<dim>::
-    melt_fraction (const double temperature,
-                   const double pressure) const
-    {
-      // anhydrous melting of peridotite after Katz, 2003
-      const double T_solidus  = A1 + 273.15
-                                + A2 * pressure
-                                + A3 * pressure * pressure;
-      const double T_lherz_liquidus = B1 + 273.15
-                                      + B2 * pressure
-                                      + B3 * pressure * pressure;
-      const double T_liquidus = C1 + 273.15
-                                + C2 * pressure
-                                + C3 * pressure * pressure;
-
-      // melt fraction for peridotite with clinopyroxene
-      double peridotite_melt_fraction;
-      if (temperature < T_solidus || pressure > 1.3e10)
-        peridotite_melt_fraction = 0.0;
-      else if (temperature > T_lherz_liquidus)
-        peridotite_melt_fraction = 1.0;
-      else
-        peridotite_melt_fraction = std::pow((temperature - T_solidus) / (T_lherz_liquidus - T_solidus),beta);
-
-      // melt fraction after melting of all clinopyroxene
-      const double R_cpx = r1 + r2 * std::max(0.0, pressure);
-      const double F_max = M_cpx / R_cpx;
-
-      if (peridotite_melt_fraction > F_max && temperature < T_liquidus)
-        {
-          const double T_max = std::pow(F_max,1/beta) * (T_lherz_liquidus - T_solidus) + T_solidus;
-          peridotite_melt_fraction = F_max + (1 - F_max) * pow((temperature - T_max) / (T_liquidus - T_max),beta);
-        }
-      return peridotite_melt_fraction;
-    }
-
-    template <int dim>
-    void
-    MeltViscoPlastic<dim>::
-    melt_fractions (const MaterialModel::MaterialModelInputs<dim> &in,
-                    std::vector<double> &melt_fractions) const
-    {
-      for (unsigned int q=0; q<in.n_evaluation_points(); ++q)
-        melt_fractions[q] = melt_fraction(in.temperature[q],
-                                          std::max(0.0, in.pressure[q]));
-      return;
-    }
-
-    template <int dim>
-    void
-    MeltViscoPlastic<dim>::
-    evaluate(const typename Interface<dim>::MaterialModelInputs &in, typename Interface<dim>::MaterialModelOutputs &out) const
-    {
-      // 1) Initial viscosities and other material properties
-      for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-        {
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
-          out.viscosities[i] = MaterialUtilities::average_value(volume_fractions, linear_viscosities, viscosity_averaging);
-
-          out.densities[i] = MaterialUtilities::average_value(volume_fractions, densities, MaterialUtilities::CompositionalAveragingOperation::arithmetic);
-          out.thermal_expansion_coefficients[i] = MaterialUtilities::average_value(volume_fractions, thermal_expansivities, MaterialUtilities::CompositionalAveragingOperation::arithmetic);
-          out.thermal_conductivities[i] = MaterialUtilities::average_value(volume_fractions, thermal_conductivities, MaterialUtilities::CompositionalAveragingOperation::arithmetic);
-          out.specific_heat[i] = MaterialUtilities::average_value(volume_fractions, specific_heats, MaterialUtilities::CompositionalAveragingOperation::arithmetic);
-
-          // TODO: compute the actual number
-          out.entropy_derivative_pressure[i]    = 0.0;
-          out.entropy_derivative_temperature[i] = 0.0;
-        }
-
-      // Store the intrinsic viscosities for computing the compaction viscosities later on
-      // (Keller et al. eq. 51).
-      const std::vector<double> intrinsic_viscosities = out.viscosities;
-
-      // 2) Retrieve fluid pressure and volumetric strain rate
-      std::vector<double> fluid_pressures(in.n_evaluation_points());
-      std::vector<double> volumetric_strain_rates(in.n_evaluation_points());
-      std::vector<double> volumetric_yield_strength(in.n_evaluation_points());
-
-      ReactionRateOutputs<dim> *reaction_rate_out = out.template get_additional_output<ReactionRateOutputs<dim>>();
-
-      if (this->include_melt_transport() )
-        {
-          if (in.current_cell.state() == IteratorState::valid)
-            {
-              std::vector<Point<dim>> quadrature_positions(in.n_evaluation_points());
-
-              for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-                quadrature_positions[i] = this->get_mapping().transform_real_to_unit_cell(in.current_cell, in.position[i]);
-
-              // FEValues requires a quadrature and we provide the default quadrature
-              // as we only need to evaluate the solution and gradients.
-              FEValues<dim> fe_values (this->get_mapping(),
-                                       this->get_fe(),
-                                       Quadrature<dim>(quadrature_positions),
-                                       update_values | update_gradients);
-
-              fe_values.reinit (in.current_cell);
-
-              // get fluid pressure from the current solution
-              const FEValuesExtractors::Scalar extractor_pressure = this->introspection().variable("fluid pressure").extractor_scalar();
-              fe_values[extractor_pressure].get_function_values (this->get_solution(),
-                                                                 fluid_pressures);
-
-              // get volumetric strain rate
-              // see Keller et al. eq. 11.
-              fe_values[this->introspection().extractors.velocities].get_function_divergences (this->get_solution(),
-                  volumetric_strain_rates);
-            }
-
-          const double time_scale = this->convert_output_to_years() ? year_in_seconds : 1.0;
-
-          // 3) Get porosity, melt density and update melt reaction terms
-          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-            {
-              // get peridotite and porosity field indices
-              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-              const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
-
-              const double old_porosity = in.composition[i][porosity_idx];
-              const double maximum_melt_fraction = in.composition[i][peridotite_idx];
-
-              // calculate the melting rate as difference between the equilibrium melt fraction
-              // and the solution of the previous time step
-              double porosity_change = 0.0;
-
-              // batch melting
-              porosity_change = melt_fraction(in.temperature[i], this->get_adiabatic_conditions().pressure(in.position[i]))
-                                - std::max(maximum_melt_fraction, 0.0);
-              porosity_change = std::max(porosity_change, 0.0);
-
-              // do not allow negative porosity
-              porosity_change = std::max(porosity_change, -old_porosity);
-
-              // because depletion is a volume-based, and not a mass-based property that is advected,
-              // additional scaling factors on the right hand side apply
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                {
-                  if (use_melting_rate_function == false)
-                    {
-                      // fill reaction rate outputs
-                      if (reaction_rate_out != nullptr)
-                        {
-                          if (c == peridotite_idx && this->get_timestep_number() > 0)
-                            reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale
-                                                                      * (1 - maximum_melt_fraction) / (1 - old_porosity);
-                          else if (c == porosity_idx && this->get_timestep_number() > 0)
-                            reaction_rate_out->reaction_rates[i][c] = porosity_change / melting_time_scale;
-                          else
-                            reaction_rate_out->reaction_rates[i][c] = 0.0;
-                        }
-
-                      out.reaction_terms[i][c] = 0.0;
-                    }
-                  else
-                    {
-                      // Set reaction rates to 0
-                      if (reaction_rate_out != nullptr)
-                        reaction_rate_out->reaction_rates[i][c] = 0.;
-                      //
-                      if (c == porosity_idx)
-                        out.reaction_terms[i][c] = function.value(in.position[i]) / time_scale * out.densities[i];
-                      else if (c == peridotite_idx)
-                        out.reaction_terms[i][c] = 0.0;
-                    }
-                }
-
-              // 4) Reduce shear viscosity due to melt presence
-              const double porosity = std::min(1.0, std::max(in.composition[i][porosity_idx],0.0));
-              out.viscosities[i] *= exp(- alpha_phi * porosity);
-            }
-        }
-
-      if (in.requests_property(MaterialProperties::viscosity) )
-        {
-          // 5) Compute plastic weakening of the viscosity
-          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-            {
-              // Compute volume fractions
-              const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
-
-              // 4) Compute plastic weakening of visco(elastic) viscosity
-              double porosity = 0.0;
-
-              if (this->include_melt_transport() )
-                porosity = std::min(1.0, std::max(in.composition[i][this->introspection().compositional_index_for_name("porosity")],0.0));
-
-              // calculate deviatoric strain rate (Keller et al. eq. 13)
-              const double edot_ii = ( (this->get_timestep_number() == 0 && in.strain_rate[i].norm() <= std::numeric_limits<double>::min())
-                                       ?
-                                       ref_strain_rate
-                                       :
-                                       std::max(std::sqrt(std::fabs(second_invariant(deviator(in.strain_rate[i])))),
-                                                min_strain_rate) );
-
-              // compute viscous stress
-              const double viscous_stress = 2. * out.viscosities[i] * edot_ii * (1.0 - porosity);
-
-              // In case porosity lies above the melt transport threshold
-              // P_effective = P_bulk - P_f = (1-porosity) * P_s + porosity * P_f - P_f = (1-porosity) * (P_s - P_f)
-              // otherwise,
-              // P_effective = P_bulk, which equals P_solid (which is given by in.pressure[i])
-              const double effective_pressure = ((this->include_melt_transport() && this->get_melt_handler().is_melt_cell(in.current_cell))
-                                                 ?
-                                                 (1. - porosity) * (in.pressure[i] - fluid_pressures[i])
-                                                 :
-                                                 in.pressure[i]);
-
-              double yield_strength = 0.0;
-              double tensile_strength = 0.0;
-
-              for (unsigned int c=0; c< volume_fractions.size(); ++c)
-                {
-                  const double tensile_strength_c = cohesions[c]/strength_reductions[c];
-
-                  // Convert friction angle from degrees to radians
-                  double phi = angles_internal_friction[c] * constants::degree_to_radians;
-                  const double transition_pressure = (cohesions[c] * std::cos(phi) - tensile_strength_c) / (1.0 -  sin(phi));
-
-                  double yield_strength_c = 0.0;
-                  // In case we're not using the Keller et al. formulation,
-                  // or the effective pressure is bigger than the transition pressure, use
-                  // the normal yield strength formulation
-                  if (effective_pressure > transition_pressure || !this->include_melt_transport())
-                    yield_strength_c = ( (dim==3)
-                                         ?
-                                         ( 6.0 * cohesions[c] * std::cos(phi) + 2.0 * effective_pressure * std::sin(phi) )
-                                         / ( std::sqrt(3.0) * (3.0 + std::sin(phi) ) )
-                                         :
-                                         cohesions[c] * std::cos(phi) + effective_pressure * std::sin(phi) );
-                  else
-                    // Note typo in Keller et al. paper eq. (37) (minus sign)
-                    yield_strength_c = tensile_strength_c + effective_pressure;
-
-                  // TODO add different averagings?
-                  yield_strength += volume_fractions[c]*yield_strength_c;
-                  tensile_strength += volume_fractions[c]*tensile_strength_c;
-                }
-
-              bool plastic_yielding = false;
-
-              // If the viscous stress is greater than the yield strength, rescale the viscosity back to yield surface
-              // and reaction term for plastic finite strain
-              if (viscous_stress >= yield_strength)
-                {
-                  plastic_yielding = true;
-                  out.viscosities[i] = yield_strength / (2.0 * edot_ii);
-                }
-
-              // Calculate average internal friction angle and cohesion values
-              const double cohesion = MaterialUtilities::average_value(volume_fractions, cohesions, viscosity_averaging);
-              const double angle_internal_friction = MaterialUtilities::average_value(volume_fractions, angles_internal_friction, viscosity_averaging);
-
-              PlasticAdditionalOutputs2<dim> *plastic_out = out.template get_additional_output<PlasticAdditionalOutputs2<dim>>();
-              if (plastic_out != nullptr)
-                {
-                  plastic_out->cohesions[i] = cohesion;
-                  plastic_out->friction_angles[i] = angle_internal_friction;
-                  plastic_out->yielding[i] = plastic_yielding ? 1 : 0;
-                }
-
-              // Limit the viscosity with specified minimum and maximum bounds
-              out.viscosities[i] = std::min(std::max(out.viscosities[i], min_viscosity), max_viscosity);
-
-              // Compute the volumetric yield strength (Keller et al. eq (38))
-              volumetric_yield_strength[i] = viscous_stress - tensile_strength;
-            }
-        }
-
-      // fill melt outputs if they exist
-      MeltOutputs<dim> *melt_out = out.template get_additional_output<MeltOutputs<dim>>();
-
-      if (melt_out != nullptr)
-        {
-          for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-            {
-              const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-              double porosity = std::min(1.0, std::max(in.composition[i][porosity_idx],0.0));
-              melt_out->fluid_viscosities[i] = eta_f;
-              melt_out->permeabilities[i] = reference_permeability * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-
-              melt_out->fluid_densities[i] = out.densities[i] + melt_density_change;
-              melt_out->fluid_density_gradients[i] = 0.0;
-
-              const double compaction_pressure = (1.0 - porosity) * (in.pressure[i] - fluid_pressures[i]);
-
-              const double phi_0 = 0.05;
-              porosity = std::max(std::min(porosity,0.995),1.e-8);
-              // compaction viscosities (Keller et al. eq (51)
-              melt_out->compaction_viscosities[i] = intrinsic_viscosities[i] * phi_0 / porosity;
-
-              // visco(elastic) compaction viscosity
-              // Keller et al. eq (36)
-              // TODO include elastic part
-              melt_out->compaction_viscosities[i] *= (1. - porosity);
-
-              // TODO compaction stress evolution parameter
-              // Keller et al. eq. (41) and (44)
-
-              // effective compaction viscosity (Keller et al. eq (43) )
-              // NB: I've added a minus sign as according to eq 43
-              if (in.strain_rate.size() && compaction_pressure < volumetric_yield_strength[i])
-                {
-                  // the volumetric strain rate might be negative, but will always have the same sign as the volumetric yield strength
-                  if (volumetric_strain_rates[i] >= 0)
-                    volumetric_strain_rates[i] = std::max(volumetric_strain_rates[i], min_strain_rate);
-                  else
-                    volumetric_strain_rates[i] = std::min(volumetric_strain_rates[i], -min_strain_rate);
-                  melt_out->compaction_viscosities[i] = - volumetric_yield_strength[i] / volumetric_strain_rates[i];
-                }
-
-              // Limit the viscosity with specified minimum and maximum bounds
-              melt_out->compaction_viscosities[i] = std::min(std::max(melt_out->compaction_viscosities[i], min_viscosity), max_viscosity);
-            }
-        }
-
-
-    }
-
-
-    template <int dim>
-    void
-    MeltViscoPlastic<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Melt visco plastic");
-        {
-
-          prm.declare_entry ("Reference temperature", "293", Patterns::Double(0),
-                             "For calculating density by thermal expansivity. Units: $K$");
-          prm.declare_entry ("Densities", "3300.",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of densities for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "If only one value is given, then all use the same value.  Units: $kg / m^3$");
-          prm.declare_entry ("Thermal expansivities", "4.e-5",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of thermal expansivities for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "If only one value is given, then all use the same value. Units: $1/K$");
-          prm.declare_entry ("Specific heats", "1250.",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of specific heats $C_p$ for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "If only one value is given, then all use the same value. Units: $J /kg /K$");
-          prm.declare_entry ("Thermal conductivities", "4.7",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of thermal conductivities for background mantle and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "If only one value is given, then all use the same value. Units: $W/m/K$ ");
-
-          prm.declare_entry ("Minimum strain rate", "1.0e-20", Patterns::Double(0),
-                             "Stabilizes strain dependent viscosity. Units: $1 / s$");
-          prm.declare_entry ("Reference strain rate","1.0e-15",Patterns::Double(0),
-                             "Reference strain rate for first time step. Units: $1 / s$");
-          prm.declare_entry ("Minimum viscosity", "1e17", Patterns::Double(0),
-                             "Lower cutoff for effective viscosity. Units: $Pa \\, s$");
-          prm.declare_entry ("Maximum viscosity", "1e28", Patterns::Double(0),
-                             "Upper cutoff for effective viscosity. Units: $Pa \\, s$");
-
-          prm.declare_entry ("Reference viscosity", "1e22", Patterns::Double(0),
-                             "Reference viscosity for nondimensionalization. "
-                             "To understand how pressure scaling works, take a look at "
-                             "\\cite{KHB12}. In particular, the value of this parameter "
-                             "would not affect the solution computed by \\aspect{} if "
-                             "we could do arithmetic exactly; however, computers do "
-                             "arithmetic in finite precision, and consequently we need to "
-                             "scale quantities in ways so that their magnitudes are "
-                             "roughly the same. As explained in \\cite{KHB12}, we scale "
-                             "the pressure during some computations (never visible by "
-                             "users) by a factor that involves a reference viscosity. This "
-                             "parameter describes this reference viscosity."
-                             "\n\n"
-                             "For problems with a constant viscosity, you will generally want "
-                             "to choose the reference viscosity equal to the actual viscosity. "
-                             "For problems with a variable viscosity, the reference viscosity "
-                             "should be a value that adequately represents the order of "
-                             "magnitude of the viscosities that appear, such as an average "
-                             "value or the value one would use to compute a Rayleigh number."
-                             "\n\n"
-                             "Units: $Pa \\, s$");
-
-          prm.declare_entry ("Viscosity averaging scheme", "harmonic",
-                             Patterns::Selection("arithmetic|harmonic|geometric|maximum composition "),
-                             "When more than one compositional field is present at a point "
-                             "with different viscosities, we need to come up with an average "
-                             "viscosity at that point.  Select a weighted harmonic, arithmetic, "
-                             "geometric, or maximum composition.");
-
-          prm.declare_entry ("Linear viscosities", "1.e22",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of linear viscosities for background material and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "The values can be used instead of the viscosities derived from the "
-                             "base material model. Units: Pa s.");
-
-          prm.declare_entry ("Angles of internal friction", "0",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of angles of internal friction, $\\phi$, for background material and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "For a value of zero, in 2D the von Mises criterion is retrieved. "
-                             "Angles higher than 30 degrees are harder to solve numerically. Units: degrees.");
-          prm.declare_entry ("Cohesions", "1e20",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of cohesions, $C$, for background material and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "The extremely large default cohesion value (1e20 Pa) prevents the viscous stress from "
-                             "exceeding the yield stress. Units: $Pa$.");
-
-          prm.declare_entry ("Maximum yield stress", "1e12", Patterns::Double(0),
-                             "Limits the maximum value of the yield stress determined by the "
-                             "drucker-prager plasticity parameters. Default value is chosen so this "
-                             "is not automatically used. Values of 100e6--1000e6 $Pa$ have been used "
-                             "in previous models. Units: $Pa$");
-
-          prm.declare_entry ("Host rock strength reductions", "4",
-                             Patterns::List(Patterns::Double(0)),
-                             "List of reduction factors of strength of the host rock under tensile stress, $R$, "
-                             "for background material and compositional fields, "
-                             "for a total of N+1 values, where N is the number of compositional fields. "
-                             "Units: none.");
-
-          prm.declare_entry ("Melt density change", "-500",
-                             Patterns::Double (),
-                             "Difference between solid density $\\rho_{s}$ and melt/fluid$\\rho_{f}$. "
-                             "Units: $kg/m^3$.");
-          prm.declare_entry ("Reference bulk viscosity", "1e22",
-                             Patterns::Double (0),
-                             "The value of the constant bulk viscosity $\\xi_0$ of the solid matrix. "
-                             "This viscosity may be modified by both temperature and porosity "
-                             "dependencies. Units: $Pa s$.");
-          prm.declare_entry ("Reference melt viscosity", "10",
-                             Patterns::Double (0),
-                             "The value of the constant melt viscosity $\\eta_f$. Units: $Pa s$.");
-          prm.declare_entry ("Exponential melt weakening factor", "27",
-                             Patterns::Double (0),
-                             "The porosity dependence of the viscosity. Units: dimensionless.");
-          prm.declare_entry ("Reference permeability", "1e-8",
-                             Patterns::Double(),
-                             "Reference permeability of the solid host rock."
-                             "Units: $m^2$.");
-          prm.declare_entry ("Melting time scale for operator splitting", "1e3",
-                             Patterns::Double (0),
-                             "Because the operator splitting scheme is used, the porosity field can not "
-                             "be set to a new equilibrium melt fraction instantly, but the model has to "
-                             "provide a melting time scale instead. This time scale defines how fast melting "
-                             "happens, or more specifically, the parameter defines the time after which "
-                             "the deviation of the porosity from the equilibrium melt fraction will be "
-                             "reduced to a fraction of $1/e$. So if the melting time scale is small compared "
-                             "to the time step size, the reaction will be so fast that the porosity is very "
-                             "close to the equilibrium melt fraction after reactions are computed. Conversely, "
-                             "if the melting time scale is large compared to the time step size, almost no "
-                             "melting and freezing will occur."
-                             "\n\n"
-                             "Also note that the melting time scale has to be larger than or equal to the reaction "
-                             "time step used in the operator splitting scheme, otherwise reactions can not be "
-                             "computed. "
-                             "Units: yr or s, depending on the ``Use years in output instead of seconds'' parameter.");
-
-          prm.declare_entry ("A1", "1085.7",
-                             Patterns::Double (),
-                             "Constant parameter in the quadratic "
-                             "function that approximates the solidus "
-                             "of peridotite. "
-                             "Units: ${}^\\circ C$.");
-          prm.declare_entry ("A2", "1.329e-7",
-                             Patterns::Double (),
-                             "Prefactor of the linear pressure term "
-                             "in the quadratic function that approximates "
-                             "the solidus of peridotite. "
-                             "Units: ${}^\\circ C/Pa$.");
-          prm.declare_entry ("A3", "-5.1e-18",
-                             Patterns::Double (),
-                             "Prefactor of the quadratic pressure term "
-                             "in the quadratic function that approximates "
-                             "the solidus of peridotite. "
-                             "Units: ${}^\\circ C/(Pa^2)$.");
-          prm.declare_entry ("B1", "1475.0",
-                             Patterns::Double (),
-                             "Constant parameter in the quadratic "
-                             "function that approximates the lherzolite "
-                             "liquidus used for calculating the fraction "
-                             "of peridotite-derived melt. "
-                             "Units: ${}^\\circ C$.");
-          prm.declare_entry ("B2", "8.0e-8",
-                             Patterns::Double (),
-                             "Prefactor of the linear pressure term "
-                             "in the quadratic function that approximates "
-                             "the  lherzolite liquidus used for "
-                             "calculating the fraction of peridotite-"
-                             "derived melt. "
-                             "Units: ${}^\\circ C/Pa$.");
-          prm.declare_entry ("B3", "-3.2e-18",
-                             Patterns::Double (),
-                             "Prefactor of the quadratic pressure term "
-                             "in the quadratic function that approximates "
-                             "the  lherzolite liquidus used for "
-                             "calculating the fraction of peridotite-"
-                             "derived melt. "
-                             "Units: ${}^\\circ C/(Pa^2)$.");
-          prm.declare_entry ("C1", "1780.0",
-                             Patterns::Double (),
-                             "Constant parameter in the quadratic "
-                             "function that approximates the liquidus "
-                             "of peridotite. "
-                             "Units: ${}^\\circ C$.");
-          prm.declare_entry ("C2", "4.50e-8",
-                             Patterns::Double (),
-                             "Prefactor of the linear pressure term "
-                             "in the quadratic function that approximates "
-                             "the liquidus of peridotite. "
-                             "Units: ${}^\\circ C/Pa$.");
-          prm.declare_entry ("C3", "-2.0e-18",
-                             Patterns::Double (),
-                             "Prefactor of the quadratic pressure term "
-                             "in the quadratic function that approximates "
-                             "the liquidus of peridotite. "
-                             "Units: ${}^\\circ C/(Pa^2)$.");
-          prm.declare_entry ("r1", "0.5",
-                             Patterns::Double (),
-                             "Constant in the linear function that "
-                             "approximates the clinopyroxene reaction "
-                             "coefficient. "
-                             "Units: non-dimensional.");
-          prm.declare_entry ("r2", "8e-11",
-                             Patterns::Double (),
-                             "Prefactor of the linear pressure term "
-                             "in the linear function that approximates "
-                             "the clinopyroxene reaction coefficient. "
-                             "Units: $1/Pa$.");
-          prm.declare_entry ("beta", "1.5",
-                             Patterns::Double (),
-                             "Exponent of the melting temperature in "
-                             "the melt fraction calculation. "
-                             "Units: non-dimensional.");
-          prm.declare_entry ("Mass fraction cpx", "0.15",
-                             Patterns::Double (),
-                             "Mass fraction of clinopyroxene in the "
-                             "peridotite to be molten. "
-                             "Units: non-dimensional.");
-
-          prm.declare_entry ("Use melting rate function", "false",
-                             Patterns::Bool (),
-                             "Prescribe the melting rate through a function defined as an input parameter. "
-                             "Units: None");
-
-          prm.enter_subsection("Melting rate function");
-          {
-            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-          }
-          prm.leave_subsection();
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    MeltViscoPlastic<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      //increment by one for background:
-      const unsigned int n_fields = this->n_compositional_fields() + 1;
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Melt visco plastic");
-        {
-
-          ref_temperature = prm.get_double ("Reference temperature");
-          densities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Densities"))),
-                                                              n_fields,
-                                                              "Densities");
-          thermal_expansivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal expansivities"))),
-                                                                          n_fields,
-                                                                          "Thermal expansivities");
-          specific_heats = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Specific heats"))),
-                                                                   n_fields,
-                                                                   "Specific heats");
-          thermal_conductivities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Thermal conductivities"))),
-                                                                           n_fields,
-                                                                           "Thermal conductivities");
-
-          min_strain_rate = prm.get_double("Minimum strain rate");
-          ref_strain_rate = prm.get_double("Reference strain rate");
-          min_viscosity = prm.get_double ("Minimum viscosity");
-          max_viscosity = prm.get_double ("Maximum viscosity");
-
-          ref_viscosity = prm.get_double ("Reference viscosity");
-
-          viscosity_averaging = MaterialUtilities::parse_compositional_averaging_operation ("Viscosity averaging scheme",
-                                prm);
-
-          linear_viscosities = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Linear viscosities"))),
-                                                                       n_fields,
-                                                                       "Linear viscosities");
-
-          angles_internal_friction = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Angles of internal friction"))),
-                                                                             n_fields,
-                                                                             "Angles of internal friction");
-          cohesions = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Cohesions"))),
-                                                              n_fields,
-                                                              "Cohesions");
-
-          maximum_yield_stress = prm.get_double("Maximum yield stress");
-
-          strength_reductions = Utilities::possibly_extend_from_1_to_N (Utilities::string_to_double(Utilities::split_string_list(prm.get("Host rock strength reductions"))),
-                                                                        n_fields,
-                                                                        "Host rock strength reductions");
-
-          melt_density_change        = prm.get_double ("Melt density change");
-          xi_0                       = prm.get_double ("Reference bulk viscosity");
-          eta_f                      = prm.get_double ("Reference melt viscosity");
-          reference_permeability     = prm.get_double ("Reference permeability");
-          alpha_phi                  = prm.get_double ("Exponential melt weakening factor");
-          melting_time_scale         = prm.get_double ("Melting time scale for operator splitting");
-
-          A1              = prm.get_double ("A1");
-          A2              = prm.get_double ("A2");
-          A3              = prm.get_double ("A3");
-          B1              = prm.get_double ("B1");
-          B2              = prm.get_double ("B2");
-          B3              = prm.get_double ("B3");
-          C1              = prm.get_double ("C1");
-          C2              = prm.get_double ("C2");
-          C3              = prm.get_double ("C3");
-          r1              = prm.get_double ("r1");
-          r2              = prm.get_double ("r2");
-          beta            = prm.get_double ("beta");
-          M_cpx           = prm.get_double ("Mass fraction cpx");
-
-          use_melting_rate_function  = prm.get_bool ("Use melting rate function");
-
-          if (use_melting_rate_function)
-            {
-              prm.enter_subsection("Melting rate function");
-              try
-                {
-                  function.parse_parameters (prm);
-                }
-              catch (...)
-                {
-                  std::cerr << "ERROR: FunctionParser failed to parse\n"
-                            << "\t'Material model.Melting rate function.Function'\n"
-                            << "with expression\n"
-                            << "\t'" << prm.get("Function expression") << "'"
-                            << "More information about the cause of the parse error \n"
-                            << "is shown below.\n";
-                  throw;
-                }
-              prm.leave_subsection();
-            }
-
-          AssertThrow(this->introspection().compositional_name_exists("peridotite"),
-                      ExcMessage("Material model Melt visco plastic only works if there is a "
-                                 "compositional field called peridotite."));
-
-          if (this->convert_output_to_years() == true)
-            melting_time_scale *= year_in_seconds;
-
-          AssertThrow(melting_time_scale >= this->get_parameters().reaction_time_step,
-                      ExcMessage("The reaction time step " + Utilities::to_string(this->get_parameters().reaction_time_step)
-                                 + " in the operator splitting scheme is too large to compute melting rates! "
-                                 "You have to choose it in such a way that it is smaller than the 'Melting time scale for "
-                                 "operator splitting' chosen in the material model, which is currently "
-                                 + Utilities::to_string(melting_time_scale) + "."));
-          AssertThrow(melting_time_scale > 0,
-                      ExcMessage("The Melting time scale for operator splitting must be larger than 0!"));
-
-          if (this->include_melt_transport())
-            {
-              AssertThrow(this->introspection().compositional_name_exists("porosity"),
-                          ExcMessage("Material model Melt visco plastic with melt transport only "
-                                     "works if there is a compositional field called porosity."));
-            }
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-    }
-
-    template <int dim>
-    void
-    MeltViscoPlastic<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<PlasticAdditionalOutputs2<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PlasticAdditionalOutputs2<dim>> (n_points));
-        }
-    }
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(MeltViscoPlastic,
-                                   "EXPERIMENTAL melt visco plastic",
-                                   "WARNING: This material model has not been thoroughly tested, "
-                                   "and it is not advised that it be used for any serious models "
-                                   "at this point.\n\n"
-                                   "This material model implements a simple formulation of the "
-                                   "material parameters required for the modeling of melt transport, "
-                                   "including a source term for the porosity according to the melting "
-                                   "model for dry peridotite of \\cite{KSL2003}. All other material "
-                                   "properties are taken from the visco-plastic model.")
-  }
-}
diff --git a/tests/melt_visco_plastic_mohr_circle_compaction.cc.bak b/tests/melt_visco_plastic_mohr_circle_compaction.cc.bak
deleted file mode 100644
index cacf2ceb305..00000000000
--- a/tests/melt_visco_plastic_mohr_circle_compaction.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "melt_visco_plastic.cc"
diff --git a/tests/melt_visco_plastic_mohr_circle_compaction.prm.bak b/tests/melt_visco_plastic_mohr_circle_compaction.prm.bak
deleted file mode 100644
index d8ed2f4bc8d..00000000000
--- a/tests/melt_visco_plastic_mohr_circle_compaction.prm.bak
+++ /dev/null
@@ -1,163 +0,0 @@
-# 2d model demonstrating implementation of the constitutive law
-# described by Keller et. al., 2013, including viscoplastic yielding
-# and melt migration.
-#
-# In this test, a velocity field is prescribed that represents
-# simple shear under uniaxial extension. This setup generates
-# output that describes the material model's response to a range
-# of stress conditions, both in resulting effective viscosity, and in
-# velocity of pore fluid flow.
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 293
-set Use years in output instead of seconds = false
-
-# Because this model aims to capture rheological behavior under a range
-# of deformation regimes, we prescribe a flow field in the section called
-# `Prescribed Stokes Solution` below.
-set Nonlinear solver scheme                = single Advection, no Stokes
-set End time                               = 0
-
-##################### Melting and freezing ########################
-
-set Use operator splitting                     = false
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Function expression = 1e6/(2*0.99*1e22)*y^2 + x/(5e22*.99)*(5e7-5e5*x); 0
-  end
-
-  subsection Fluid velocity function
-    set Function expression = 1e6/(2*0.99*1e22)*y^2; 0
-  end
-
-  subsection Pressure function
-    set Function expression = 0
-  end
-
-  subsection Fluid pressure function
-    set Function expression = (1e6*x-5e7)/(-.99)
-  end
-
-  subsection Compaction pressure function
-    set Function expression = max(1e6*x-5e7, 1e6*y-1e7)
-  end
-end
-
-
-subsection Material model
-  set Model name = EXPERIMENTAL melt visco plastic
-
-  subsection Melt visco plastic
-    set Exponential melt weakening factor = 0
-    set Cohesions                         = 4e7
-    set Angles of internal friction       = 30
-    set Minimum strain rate               = 1e-30
-    set Reference strain rate             = 1e-30
-    set Minimum viscosity                 = 10
-    set Maximum viscosity                 = 1e30
-  end
-end
-
-##################### Model geometry ########################
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent      = 250
-    set Y extent      = 160
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-##################### Temperature ########################
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 293
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators =
-end
-
-subsection Heating model
-  set List of model names =
-end
-
-subsection Melt settings
-  set Include melt transport = true
-  set Heat advection by melt = true
-  set Use discontinuous compaction pressure = false
-end
-
-##################### Composition ########################
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.01; 0.01
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   =
-  set List of model names = initial composition
-end
-
-##################### Mesh refinement #########################
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Time steps between mesh refinement       = 0
-end
-
-##################### Postprocessing ########################
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics
-
-  # We mainly want to look at material properties of the solid and the melt.
-  subsection Visualization
-    set List of output variables      = material properties, melt material properties, melt fraction, named additional outputs, stress, strain rate tensor
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-
-    # To see in which cells melt transport is modelled, it can be useful to look
-    # at the property 'is melt cell', so we include it in the output. In addition,
-    # we always visualize the compaction pressure 'p_c' if this postprocessor is
-    # used.
-    subsection Melt material properties
-      set List of properties = compaction viscosity, permeability, fluid density, is melt cell
-    end
-  end
-end
diff --git a/tests/melt_visco_plastic_mohr_circle_shear.cc.bak b/tests/melt_visco_plastic_mohr_circle_shear.cc.bak
deleted file mode 100644
index cacf2ceb305..00000000000
--- a/tests/melt_visco_plastic_mohr_circle_shear.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "melt_visco_plastic.cc"
diff --git a/tests/melt_visco_plastic_mohr_circle_shear.prm.bak b/tests/melt_visco_plastic_mohr_circle_shear.prm.bak
deleted file mode 100644
index 6a9a756ae1f..00000000000
--- a/tests/melt_visco_plastic_mohr_circle_shear.prm.bak
+++ /dev/null
@@ -1,162 +0,0 @@
-# 2d model demonstrating implementation of the constitutive law
-# described by Keller et. al., 2013, including viscoplastic yielding
-# and melt migration.
-#
-# In this test, a velocity field is prescribed that represents
-# simple shear with respect to the model's y-axis. This setup generates
-# output that describes the material model's response to a range
-# of stress conditions.
-
-set Dimension                              = 2
-set Adiabatic surface temperature          = 293
-set Use years in output instead of seconds = false
-
-# Because this model aims to capture rheological behavior under a range
-# of deformation regimes, we prescribe a flow field in the section called
-# `Prescribed Stokes Solution` below.
-set Nonlinear solver scheme                = single Advection, no Stokes
-set End time                               = 0
-
-##################### Melting and freezing ########################
-
-set Use operator splitting                     = false
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Function expression = 1e6/(2*0.99*1e22)*y^2; 0
-  end
-
-  subsection Fluid velocity function
-    set Function expression = 1e6/(2*0.99*1e22)*y^2; 0
-  end
-
-  subsection Pressure function
-    set Function expression = 0
-  end
-
-  subsection Fluid pressure function
-    set Function expression = (1e6*x-5e7)/(-.99)
-  end
-
-  subsection Compaction pressure function
-    set Function expression = 1e6*x-5e7
-  end
-end
-
-
-subsection Material model
-  set Model name = EXPERIMENTAL melt visco plastic
-
-  subsection Melt visco plastic
-    set Exponential melt weakening factor = 0
-    set Cohesions                         = 4e7
-    set Angles of internal friction       = 30
-    set Minimum strain rate               = 1e-30
-    set Reference strain rate             = 1e-30
-    set Minimum viscosity                 = 10
-    set Maximum viscosity                 = 1e30
-  end
-end
-
-##################### Model geometry ########################
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent      = 250
-    set Y extent      = 160
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-##################### Temperature ########################
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 293
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators =
-end
-
-subsection Heating model
-  set List of model names =
-end
-
-subsection Melt settings
-  set Include melt transport = true
-  set Heat advection by melt = true
-  set Use discontinuous compaction pressure = false
-end
-
-##################### Composition ########################
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.01; 0.01
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   =
-  set List of model names = initial composition
-end
-
-##################### Mesh refinement #########################
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Time steps between mesh refinement       = 0
-end
-
-##################### Postprocessing ########################
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics, velocity statistics
-
-  # We mainly want to look at material properties of the solid and the melt.
-  subsection Visualization
-    set List of output variables      = material properties, melt material properties, melt fraction, named additional outputs, stress, strain rate tensor
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-
-    # To see in which cells melt transport is modelled, it can be useful to look
-    # at the property 'is melt cell', so we include it in the output. In addition,
-    # we always visualize the compaction pressure 'p_c' if this postprocessor is
-    # used.
-    subsection Melt material properties
-      set List of properties = compaction viscosity, permeability, fluid density, is melt cell
-    end
-  end
-end
diff --git a/tests/melting_rate.cc.bak b/tests/melting_rate.cc.bak
deleted file mode 100644
index 8133a73311f..00000000000
--- a/tests/melting_rate.cc.bak
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/melt.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-using namespace dealii;
-
-
-namespace aspect
-{
-  template <int dim>
-  class MeltingRate:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        return 1e-8 * std::pow(0.01, 3.0) / 10.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-            const unsigned int peridotite_idx = this->introspection().compositional_index_for_name("peridotite");
-
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              {
-                const double x = in.position[i][0] - 100000.0;
-                const double y = in.position[i][1] - 50000.0;
-                const double c0 = 10000.0;
-                const double deltaT = this->get_timestep();
-                if (c == peridotite_idx &&
-                    // check whether we are past the initialization
-                    // phase before the first time step
-                    this->get_timestep_number()!=numbers::invalid_unsigned_int &&
-                    deltaT>0.0)
-                  out.reaction_terms[i][c] = 0.0001 * std::exp(-(x*x+y*y)/(2*c0*c0));
-                else if (c == porosity_idx &&
-                         // check whether we are past the
-                         // initialization phase before the first time
-                         // step
-                         this->get_timestep_number()!=numbers::invalid_unsigned_int &&
-                         deltaT>0.0)
-                  out.reaction_terms[i][c] = 0.0001 * std::exp(-(x*x+y*y)/(2*c0*c0)) * 3000.0 / deltaT;
-                else
-                  out.reaction_terms[i][c] = 0.0;
-              }
-
-            out.viscosities[i] = 5e20;
-            out.densities[i] = 3000.0 * (1 - 2e-5 * (in.temperature[i] - 293.0));
-            out.thermal_expansion_coefficients[i] = 2e-5;
-            out.specific_heat[i] = 1250.0;
-            out.thermal_conductivities[i] = 4.7;
-            out.compressibilities[i] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                const double porosity = in.composition[i][porosity_idx];
-
-                melt_out->compaction_viscosities[i] = 5e20;
-                melt_out->fluid_viscosities[i]= 10.0;
-                melt_out->permeabilities[i]= 1e-8 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-                melt_out->fluid_densities[i]= 2500.0;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-              }
-          }
-      }
-
-  };
-
-
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(MeltingRate,
-                                 "melting rate",
-                                 "")
-}
diff --git a/tests/melting_rate.prm.bak b/tests/melting_rate.prm.bak
deleted file mode 100644
index 1139fff7a9f..00000000000
--- a/tests/melting_rate.prm.bak
+++ /dev/null
@@ -1,138 +0,0 @@
-#########################################################
-# This is a test for the melting rate functionality
-# It uses a new material model similar to the melt
-# simple model, but with a different melting rate.
-
-# The melting rate has the form of a Gaussian function
-# and every timestep a fixed amount of material is melting.
-
-# The amplitude of the Gaussian is 0.0001, so both the
-# porosity and the peridotite field should increase by
-# this amount (visible in the maximum value).
-
-# Note that the maximum porosity can deviate slightly,
-# as additional melt is created bx compaction.
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 200
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 3
-set CFL number                             = 0.01
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-############### Parameters describing the model
-# Let us here choose again a box domain
-# where we fix the temperature at the bottom and top,
-# allow free slip along the boundaries
-# and include melt migration.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 200000
-    set Y extent = 100000
-    set X repetitions = 2
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1600
-    set Top temperature    = 293
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Melt settings
-  set Include melt transport = true
-end
-
-############### Compositional fields
-# We want to use two compositional fields, the porosity and
-# an additional field, to check if the melting rate functionality
-# has the same effect as the reaction term for the other
-# compositional fields. As the porosity field is advected by
-# a different mechanism, slight differences between the fields
-# are expected.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 1e6
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
-    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
-  end
-end
-
-subsection Material model
-  set Model name = melting rate
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/melting_rate_operator_splitting.prm.bak b/tests/melting_rate_operator_splitting.prm.bak
deleted file mode 100644
index f6e752e52eb..00000000000
--- a/tests/melting_rate_operator_splitting.prm.bak
+++ /dev/null
@@ -1,154 +0,0 @@
-#########################################################
-# This is a test for the melting rate functionality,
-# and it is similar to the melting_rate, but uses
-# operator splitting and latent heat of melting.
-
-# We set the temperature in such a way that the initial
-# equilibrium melt fraction would be 0.2, but due to
-# latent heat effects, the temperature gets reduced and
-# the final melt fraction should be 0.1.
-# Likewise, the temperature should be reduced from 1000.2
-# to 1000.1.
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 2e5
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1000.2
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 100
-set CFL number                             = 1.0
-set Maximum time step                      = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use operator splitting                     = true
-
-############### Parameters describing the model
-# Let us here choose again a box domain
-# where we fix the temperature at the bottom and top,
-# allow free slip along the boundaries
-# and include melt migration.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Melt settings
-  set Include melt transport = true
-end
-
-############### Compositional fields
-# We want to use two compositional fields, the porosity and
-# an additional field, to check if the melting rate functionality
-# has the same effect as the reaction term for the other
-# compositional fields. As the porosity field is advected by
-# a different mechanism, slight differences between the fields
-# are expected.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-# We don't need gravity.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 1000.2
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
-    set Function expression = 0.0; 0.0
-  end
-end
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Reference solid density       = 1000
-    set Reference melt density        = 1000
-    set Thermal conductivity          = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Reference shear viscosity     = 1e21
-    set Reference specific heat       = 1000.0
-    set Depletion solidus change      = 0.0
-    set Exponential melt weakening factor = 0.0
-    set Melt extraction depth         = 0.0
-    set Melting time scale for operator splitting = 1.111111111e3
-    set Freezing rate                 = 9e-4
-
-    # simplify the melting model so that porosity depends on temperature linearly
-    set A1 = 726.85   # this is in °C --> 1000 K
-    set A2 = 0
-    set A3 = 0
-    set B1 = 727.85   # this is in °C --> 1001 K
-    set B2 = 0
-    set B3 = 0
-    set C1 = 727.85   # this is in °C --> 1001 K
-    set C2 = 0
-    set C3 = 0
-    set Peridotite melting entropy change = -1.0
-    set Mass fraction cpx = 1.0
-    set r1 = 1.0
-    set r2 = 0.0
-    set beta = 1
-  end
-end
-
-subsection Heating model
-  set List of model names = latent heat melt
-
-  subsection Latent heat melt
-    set Melting entropy change = -1.0
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties, melt fraction
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
-    end
-  end
-end
diff --git a/tests/melting_rate_operator_splitting2.prm.bak b/tests/melting_rate_operator_splitting2.prm.bak
deleted file mode 100644
index 9136beb2df1..00000000000
--- a/tests/melting_rate_operator_splitting2.prm.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-#########################################################
-# This is a test for the melting rate functionality,
-# and it is the same as the melting_rate_operator_splitting
-# test case, except that is uses the melt global instead
-# of the melt simple material model. This also means that
-# we have to change the absolute temperature values, as
-# this material model has a fixed temperature difference
-# of 500 K between solidus and liquidus.
-
-# We set the temperature in such a way that the initial
-# equilibrium melt fraction would be 2e-3, but due to
-# latent heat effects, the temperature gets reduced and
-# the final melt fraction should be 1e-3.
-# Likewise, the temperature should be reduced from 1001
-# to 1000.5.
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 2e5
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1001
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 100
-set CFL number                             = 1.0
-set Maximum time step                      = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use operator splitting                     = true
-
-############### Parameters describing the model
-# Let us here choose again a box domain
-# where we fix the temperature at the bottom and top,
-# allow free slip along the boundaries
-# and include melt migration.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Melt settings
-  set Include melt transport = true
-end
-
-############### Compositional fields
-# We want to use two compositional fields, the porosity and
-# an additional field, to check if the melting rate functionality
-# has the same effect as the reaction term for the other
-# compositional fields. As the porosity field is advected by
-# a different mechanism, slight differences between the fields
-# are expected.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-# We don't need gravity.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 1001
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
-    set Function expression = 0.0; 0.0
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Reference solid density       = 1000
-    set Reference melt density        = 1000
-    set Thermal conductivity          = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Reference shear viscosity     = 1e21
-    set Reference specific heat       = 1000.0
-    set Exponential melt weakening factor = 0.0
-    set Melting time scale for operator splitting = 1.111111111e3
-
-    # simplify the melting model so that porosity depends on temperature linearly
-    set Surface solidus               = 1000
-    set Pressure solidus change       = 0.0
-    set Depletion solidus change      = 0.0
-  end
-end
-
-subsection Heating model
-  set List of model names = latent heat melt
-
-  subsection Latent heat melt
-    set Melting entropy change = -500.0
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties, melt fraction
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
-    end
-  end
-end
diff --git a/tests/melting_rate_test.prm.bak b/tests/melting_rate_test.prm.bak
deleted file mode 100644
index 6676a4bfd78..00000000000
--- a/tests/melting_rate_test.prm.bak
+++ /dev/null
@@ -1,156 +0,0 @@
-# Fractionation example.
-# This test is similar to the boukare_melting_diagram,
-# but evolves over time. Consequently, the melt and solid
-# composition in the two-phase region should reflect the
-# melting diagram at the end of the model run.
-
-# To plot the output:
-# gnuplot
-# set view map
-# splot "solution-00000.0000.gnuplot" using 1:2:11 palette
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 2e6
-set Nonlinear solver scheme                = first timestep only, single Stokes
-set Max nonlinear iterations               = 3
-set Pressure normalization                 = surface
-set Surface pressure                       = 120.e9
-set Adiabatic surface temperature          = 5000
-set Use operator splitting = true
-set Maximum time step                      = 1e6
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = porosity, molar_Fe_in_solid, molar_Fe_in_melt
-end
-
-subsection Melt settings
-  set Include melt transport               = true
-  set Melt scaling factor threshold        = 1e6
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-
-  subsection Operator splitting parameters
-    set Reaction time step                     = 1e5
-    set Reaction solver type                   = fixed step
-  end
-end
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = amplitude=500, width=50000, b=100000
-    set Function expression = 3400 + 1600 * y
-  end
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 0; x; x
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       =
-  set Prescribed velocity boundary indicators =
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Heating model
-  set List of model names =
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = melt boukare
-
-  subsection Melt boukare
-    set Thermal conductivity          = 8.5
-    set Reference shear viscosity     = 5e22
-    set Thermal viscosity exponent    = 10
-    set Exponential melt weakening factor    = 0
-    set Include melting and freezing  = true
-    set Melting time scale for operator splitting = 1e5
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = composition threshold
-  set Minimum refinement level                 = 0
-
-  subsection Composition threshold
-    set Compositional field thresholds = 0.1,1,1
-  end
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set Output format = gnuplot
-    set List of output variables = material properties, nonadiabatic temperature, melt fraction
-
-    subsection Material properties
-      set List of material properties = density,thermal expansivity,specific heat,viscosity,compressibility
-    end
-  end
-end
diff --git a/tests/memory_statistics_1.prm.bak b/tests/memory_statistics_1.prm.bak
deleted file mode 100644
index 5326b25d703..00000000000
--- a/tests/memory_statistics_1.prm.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-# Tests whether the 'memory statistics' postprocessor outputs correctly on a
-# minimal problem
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.3
-    set Y extent = 2.2
-    set Z extent = 1.1
-    set Box origin X coordinate = -1.9
-    set Box origin Y coordinate = 2.5
-    set Box origin Z coordinate = 3.1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = memory statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/merged_chunks_2D.prm.bak b/tests/merged_chunks_2D.prm.bak
deleted file mode 100644
index 13b41080b21..00000000000
--- a/tests/merged_chunks_2D.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-# With this geometry model we add 4 additional boundary
-# indicators to the lithospheric part of the radial
-# boundaries of a chunk.
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-# In 2D the radial boundary indicators are
-# upper|lower east|west.
-# Because we want flow through the upper part of the boundaries
-# we set fixed temperature and composition boundary conditions.
-# For now we set the lower part of the radial boundaries to
-# zero velocity, while prescribing a velocity function on the
-# upper boundaries. Note that this particular example can be accomplished
-# without additional boundary indicators and just prescribing a
-# velocity function on the whole radial boundaries.
-# Along the top and the lithospheric part of the vertical boundaries
-# we prescribe a plate velocity of 1 cm/year.
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = uppereast, upperwest, bottom, top
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = uppereast, upperwest
-end
-
-subsection Geometry model
-  set Model name = chunk with lithosphere boundary indicators
-
-  # We start the outer chunk at a depth of
-  # 150 km
-  subsection Chunk with lithosphere boundary indicators
-    set Chunk inner radius = 3471000
-    set Chunk outer radius = 6371000
-    set Chunk middle boundary radius = 6221000
-    set Inner chunk radius repetitions = 8
-    set Outer chunk radius repetitions = 1
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 40
-    set Longitude repetitions = 8
-    set Chunk minimum latitude = 0
-    set Chunk maximum latitude = 40
-    set Latitude repetitions = 8
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-# We prescribe one compositional field
-# to represent the lithosphere
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities                  = 3300,3250
-    set Reference temperature      = 293
-    set Specific heats             = 1250
-    set Thermal conductivities     = 0.
-    set Thermal expansivities      = 0.
-    set Viscosities                = 1e20,1e22
-    set Viscosity averaging scheme = harmonic
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = uppereast:function, upperwest:function, top:function
-  set Tangential velocity boundary indicators = bottom
-  set Zero velocity boundary indicators       = lowereast, lowerwest
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = vel_mag=0.01
-    set Function expression = -y/sqrt(y*y+x*x)*vel_mag; x/sqrt(y*y+x*x)*vel_mag
-  end
-end
-
-# The lithosphere is represented by a lower density,
-# higher viscosity compositional field.
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = lith_depth=125e3, model_radius=6371e3
-    set Function expression = if(sqrt(x*x+y*y)<(model_radius-lith_depth),0,1)
-  end
-end
-
-# We look at the velocity statistics; max velocity will be
-# the prescribed velocity of 1 cm/year. The boundary indicator
-# visualization shows us the indicators we set at the boundaries.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = boundary indicators
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/merged_chunks_2D_one_grid.prm.bak b/tests/merged_chunks_2D_one_grid.prm.bak
deleted file mode 100644
index 92f6a66d36e..00000000000
--- a/tests/merged_chunks_2D_one_grid.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# exactly the same as merged_chunks_2D.prm but made with one grid
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/merged_chunks_2D.prm
-
-
-subsection Geometry model
-  subsection Chunk with lithosphere boundary indicators
-    set Use merged grids = false
-    set Inner chunk radius repetitions = 9
-  end
-end
diff --git a/tests/merged_chunks_3D.prm.bak b/tests/merged_chunks_3D.prm.bak
deleted file mode 100644
index 939200acc4a..00000000000
--- a/tests/merged_chunks_3D.prm.bak
+++ /dev/null
@@ -1,140 +0,0 @@
-# With this geometry model we add 4 additional boundary
-# indicators to the radial boundaries of a chunk.
-
-set Dimension                              = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600
-set Surface pressure                       = 0
-set Pressure normalization                 = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-# In 3D the radial boundary indicators are
-# upper|lower east|west|south|north.
-# Because we want flow through the upper part of the boundaries
-# we set fixed temperature and composition boundary conditions.
-# For now we set the lower part of the radial boundaries to
-# zero velocity, while prescribing a velocity function on the
-# upper boundaries. Note that this particular example can be accomplished
-# without additional boundary indicators and just prescribing a
-# velocity function on the whole radial boundaries.
-# Along the top and the lithospheric part of the vertical boundaries
-# we prescribe a plate velocity of 1 cm/year.
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = uppereast, upperwest, uppernorth, uppersouth, bottom, top
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = uppereast, upperwest, uppernorth, uppersouth, top
-end
-
-subsection Geometry model
-  set Model name = chunk with lithosphere boundary indicators
-
-  # We start the outer chunk at a depth of
-  # 150 km
-  subsection Chunk with lithosphere boundary indicators
-    set Chunk inner radius = 5771000
-    set Chunk outer radius = 6371000
-    set Chunk middle boundary radius = 6221000
-    set Inner chunk radius repetitions = 3
-    set Outer chunk radius repetitions = 1
-    set Chunk minimum longitude = -20
-    set Chunk maximum longitude = 20
-    set Longitude repetitions = 8
-    set Chunk minimum latitude = -20
-    set Chunk maximum latitude = 20
-    set Latitude repetitions = 8
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600
-  end
-end
-
-# We prescribe one compositional field
-# to represent the lithosphere
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities                  = 3300,3250
-    set Reference temperature      = 293
-    set Specific heats             = 1250
-    set Thermal conductivities     = 0.
-    set Thermal expansivities      = 0.
-    set Viscosities                = 1e20,1e21
-    set Viscosity averaging scheme = harmonic
-  end
-end
-
-# NB To see the additional boundary indicators,
-# add one level of adaptive refinement
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = uppernorth:function, uppersouth:function, uppereast:function, \
-                                                upperwest:function, outer:function
-  set Tangential velocity boundary indicators = bottom
-  set Zero velocity boundary indicators       = lowereast, lowerwest, lowernorth, lowersouth
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = vel_mag=0.01
-    set Function expression = -y/sqrt(z*z+y*y+x*x)*vel_mag; x/sqrt(z*z+y*y+x*x)*vel_mag; 0
-  end
-end
-
-# The lithosphere is represented by a lower density,
-# higher viscosity compositional field.
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = lith_depth=125e3, model_radius=6371e3
-    set Function expression = if(sqrt(x*x+y*y+z*z)<(model_radius-lith_depth),0,1)
-  end
-end
-
-# We look at the velocity statistics; max velocity will be
-# the prescribed velocity of 1 cm/year. The boundary indicator
-# visualization shows us the indicators we set at the boundaries.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = boundary indicators
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/merged_chunks_3D_one_grid.prm.bak b/tests/merged_chunks_3D_one_grid.prm.bak
deleted file mode 100644
index ffe825d540e..00000000000
--- a/tests/merged_chunks_3D_one_grid.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# exactly the same as merged_chunks_3D.prm but made with one grid
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/tests/merged_chunks_3D.prm
-
-
-subsection Geometry model
-  subsection Chunk with lithosphere boundary indicators
-    set Use merged grids = false
-    set Inner chunk radius repetitions = 4
-  end
-end
diff --git a/tests/mesh_deformation_gmg_2d_spherical_shell.prm.bak b/tests/mesh_deformation_gmg_2d_spherical_shell.prm.bak
deleted file mode 100644
index e6b32e89711..00000000000
--- a/tests/mesh_deformation_gmg_2d_spherical_shell.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# This input file tests gmg solver with
-# mesh deformation in a spherical shell geometry
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 1
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                         = 1e-1
-    set Stokes solver type                              = block GMG
-    set Number of cheap Stokes solver steps             = 5000
-    set GMRES solver restart length                     = 1000
-    set Maximum number of expensive Stokes solver steps = 0
-    set Use full A block as preconditioner              = true
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/mesh-deformation/ascii-data/
-    set Data file name = spherical_shell_2d.txt
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 3700
-    set Outer temperature = 273
-  end
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average only viscosity
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators       = bottom, top
-end
-
-# The minimum and maximum topography in the ascii file is 3km and 400 km, respectively.
-# The topography statistics should be within these bounds.
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, topography
-
-  subsection Topography
-    set Output to file = true
-    set Time between text output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = surface elevation
-    set Output format      = gnuplot
-  end
-end
diff --git a/tests/mesh_deformation_particles.cc.bak b/tests/mesh_deformation_particles.cc.bak
deleted file mode 100644
index 9e7806dd0cd..00000000000
--- a/tests/mesh_deformation_particles.cc.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_signals.h>
-#include <aspect/simulator_access.h>
-#include <aspect/particle/world.h>
-#include <deal.II/particles/particle_handler.h>
-
-#include <iostream>
-
-using namespace aspect;
-
-
-template <int dim>
-void post_mesh_deformation (const SimulatorAccess<dim> &simulator_access)
-{
-  // Get the reference location of the one particle,
-  // and check that it has the correct value.
-  const Point<dim> predicted_particle_reference_location =
-    simulator_access.get_particle_world(0).get_particle_handler().begin()->get_reference_location();
-  // At timestep 0, the mesh is not deformed
-  // other than through the initial topography/
-  // initial mesh deformation plugins, which
-  // are not active in this test.
-  // At timestep 1, the surface of the mesh is
-  // upwardly displaced by dt*v_surf = 0.5*1.0 = 0.5.
-  // The new surface lies therefore at 1.5.
-  // Because the particle does not move (Stokes velocity
-  // is set to zero), the vertical coordinate of the particle
-  // reference location within the one cell of the mesh
-  // should be updated from 0.5/1.0 to 0.5/1.5 = 1/3.
-  Point<dim> correct_particle_reference_location;
-  correct_particle_reference_location[0] = 0.5;
-  if (simulator_access.get_timestep_number() == 0)
-    correct_particle_reference_location[dim-1] = 0.5;
-  else if (simulator_access.get_timestep_number() == 1)
-    correct_particle_reference_location[dim-1] = 1./3.;
-  else
-    Assert(false, ExcNotImplemented());
-
-  AssertThrow(predicted_particle_reference_location == correct_particle_reference_location,
-              ExcMessage("The particle reference location is not correct."));
-}
-
-
-template <int dim>
-void signal_connector (SimulatorSignals<dim> &signals)
-{
-  signals.post_mesh_deformation.connect (&post_mesh_deformation<dim>);
-}
-
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/mesh_deformation_particles.prm.bak b/tests/mesh_deformation_particles.prm.bak
deleted file mode 100644
index f25a8106bcd..00000000000
--- a/tests/mesh_deformation_particles.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# Benchmark for free surface with particles
-
-set Dimension = 2
-set End time                               = 0.5
-set Start time                             = 0
-set Nonlinear solver scheme                = single Advection, no Stokes
-set CFL number                             = 1.0
-set Maximum first time step                = 0.5
-set Pressure normalization                 = no
-set Use years in output instead of seconds = false
-set Output directory                       = mesh_def_particles
-
-subsection Prescribed Stokes solution
-  set Model name = function
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set X repetitions = 1
-    set Y repetitions = 1
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: boundary function
-  set Additional tangential mesh velocity boundary indicators = left, right
-
-  subsection Boundary function
-    set Function expression = 0;if(y<1,0,1)
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set List of output variables      =
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell = 1
-  set Maximum particles per cell = 1
-  set List of particle properties = initial position, position, reference position
-  set Particle generator name = uniform box
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.5
-      set Maximum x = 1
-      set Minimum y = 0.5
-      set Maximum y = 1
-      set Number of particles = 1
-    end
-  end
-end
diff --git a/tests/mesh_velocity_output.prm.bak b/tests/mesh_velocity_output.prm.bak
deleted file mode 100644
index 3385beb467e..00000000000
--- a/tests/mesh_velocity_output.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-# Test for outputting ALE mesh velocity with a free surface
-
-set Dimension = 2
-set CFL number                             = 0.5
-set End time                               = 1e9
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, basic statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output mesh velocity = true
-    set Output format = gnuplot
-    set Time between graphical output = 0.
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/mid_ocean_ridge.prm.bak b/tests/mid_ocean_ridge.prm.bak
deleted file mode 100644
index f43ca715461..00000000000
--- a/tests/mid_ocean_ridge.prm.bak
+++ /dev/null
@@ -1,26 +0,0 @@
-# Copy of the mid-ocean ridge cookbook, with temperature dependent
-# compaction viscosity.
-
-include $ASPECT_SOURCE_DIR/cookbooks/mid_ocean_ridge/mid_ocean_ridge.prm
-
-set End time = 1e4
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Thermal bulk viscosity exponent = 7
-  end
-end
-
-subsection Postprocess
-  subsection Visualization
-    set Interpolate output = false
-    set Output format      = gnuplot
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 3
-end
diff --git a/tests/minimum_refinement_function.prm.bak b/tests/minimum_refinement_function.prm.bak
deleted file mode 100644
index 3703f21fc5a..00000000000
--- a/tests/minimum_refinement_function.prm.bak
+++ /dev/null
@@ -1,154 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-
-# MPI: 2
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.33
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Additional refinement times              =
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 3
-  set Initial global refinement                = 3
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = max
-  set Run postprocessors on initial refinement = true
-  set Strategy                                 = temperature, minimum refinement function
-  set Time steps between mesh refinement       = 1
-
-  subsection Minimum refinement function
-    set Function constants  =
-
-    # This is in fact the default value
-    set Coordinate system   = depth
-
-    # The following lines are equal to set the line:
-    # set Function expression = 4 + 2*sin(x*pi/250000)
-    # which implies:
-    # set Variable names    = x,y
-    # because that is the default value for Variable names.
-    # To illustrate the possibility to rename function variables
-    # in your favourite naming scheme we use the following:
-    set Variable names      = depth,not_used1
-    set Function expression = 4 + 2*sin(depth*pi/250000)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/minimum_refinement_function_cartesian.prm.bak b/tests/minimum_refinement_function_cartesian.prm.bak
deleted file mode 100644
index 7490b1bda0b..00000000000
--- a/tests/minimum_refinement_function_cartesian.prm.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-
-# MPI: 2
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.33
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Additional refinement times              =
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 3
-  set Initial global refinement                = 3
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = max
-  set Run postprocessors on initial refinement = true
-  set Strategy                                 = temperature, minimum refinement function
-  set Time steps between mesh refinement       = 1
-
-  subsection Minimum refinement function
-    set Coordinate system      = cartesian
-    set Function constants     =
-    set Function expression    = 4 + 2*sin(x*pi/250000)*sin(y*pi/250000)
-    set Variable names         = x,y
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/minimum_refinement_function_spherical.prm.bak b/tests/minimum_refinement_function_spherical.prm.bak
deleted file mode 100644
index cff1ad1da42..00000000000
--- a/tests/minimum_refinement_function_spherical.prm.bak
+++ /dev/null
@@ -1,136 +0,0 @@
-# Copy of the minimum_refinement_function_cartesian test, adjusted to
-# spherical geometry and refinement coordinates. The minimum refinement
-# formula in this test uses spherical coordinates and refines exactly
-# those regions of the model that are assigned the highest temperatures
-# by the initial condition 'harmonic perturbation'.
-
-# MPI: 2
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.33
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 250000
-    set Outer radius  = 500000
-    set Opening angle = 90
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Additional refinement times              =
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 3
-  set Initial global refinement                = 2
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = max
-  set Run postprocessors on initial refinement = true
-  set Strategy                                 = minimum refinement function
-  set Time steps between mesh refinement       = 1
-
-  subsection Minimum refinement function
-    set Coordinate system      = spherical
-    set Function constants     =
-    set Function expression    = 2 + 3*sin((r+250000)*pi/250000)*sin(6*phi)
-    set Variable names         = r,phi
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/minimum_refinement_function_time_dependent.prm.bak b/tests/minimum_refinement_function_time_dependent.prm.bak
deleted file mode 100644
index 00172c2131d..00000000000
--- a/tests/minimum_refinement_function_time_dependent.prm.bak
+++ /dev/null
@@ -1,154 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-
-# MPI: 2
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 5e9
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.078 and 0.117 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.33
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Additional refinement times              =
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 3
-  set Initial global refinement                = 3
-  set Normalize individual refinement criteria = true
-  set Refinement criteria merge operation      = max
-  set Run postprocessors on initial refinement = true
-  set Strategy                                 = temperature, minimum refinement function
-  set Time steps between mesh refinement       = 1
-
-  subsection Minimum refinement function
-    set Function constants  =
-
-    # This is in fact the default value
-    set Coordinate system   = depth
-
-    # The following lines are equal to set the line:
-    # set Function expression = 4 + 2*sin(x*pi/250000-t/6e8)
-    # which implies:
-    # set Variable names    = x,y
-    # because that is the default value for Variable names.
-    # To illustrate the possibility to rename function variables
-    # in your favourite naming scheme we use the following:
-    set Variable names      = depth,not_used1,t
-    set Function expression = 4 + 2*sin(depth*pi/250000-t/6e8)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors = basic statistics
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      =
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/modified_tait_forsterite_box.prm.bak b/tests/modified_tait_forsterite_box.prm.bak
deleted file mode 100644
index 62aa4ac9ccf..00000000000
--- a/tests/modified_tait_forsterite_box.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# This test ensures that the Modified Tait
-# material model works with compositional fields
-# enabled
-
-set Dimension                              = 2
-set End time                               = 0
-set Adiabatic surface temperature          = 1000
-
-subsection Compositional fields
-  set Number of fields          = 1
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent                = 400e3
-    set X repetitions           = 1
-    set Y extent                = 400e3
-    set Y repetitions           = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 1000 + y/400
-  end
-end
-
-# The following properties are for forsterite.
-# They are taken from Holland and Powell (2011).
-# Note that the heat capacity function had to be converted
-# from a molar basis to mass basis
-# (Cp(specific) = Cp(molar)/molar_mass)
-# The Einstein temperature is calculated empirically from the
-# expression in Holland and Powell
-# (Einstein temperature  = 10636 / (S/n + 6.44)), where
-# S is the standard state molar entropy and n is the number of atoms
-# per formula unit.
-
-subsection Material model
-  set Model name         = modified tait
-
-  subsection Modified Tait model
-    set Reference pressure = 1e5
-    set Reference temperature = 298.15
-    set Reference density = 3222.5
-    set Reference isothermal bulk modulus = 128.5e9
-    set Reference bulk modulus derivative = 3.84
-    set Reference thermal expansivity = 2.85e-5
-    set Einstein temperature = 531.117
-
-    subsection Reference heat capacity function
-      set Variable names = T
-      set Function expression = (233.3 + 0.001494*T - 603800.0/T/T - 1869.7/sqrt(T))/0.1406931
-    end
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = material properties
-    set Time between graphical output = 0
-    set Number of grouped files       = 0
-
-    subsection Material properties
-      set List of material properties = density, thermal expansivity, specific heat
-    end
-  end
-end
diff --git a/tests/morency_doin.cc.bak b/tests/morency_doin.cc.bak
deleted file mode 100644
index f97acda03ad..00000000000
--- a/tests/morency_doin.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../cookbooks/morency_doin_2004/morency_doin.h"
-#include "../cookbooks/morency_doin_2004/morency_doin.cc"
diff --git a/tests/morency_doin.prm.bak b/tests/morency_doin.prm.bak
deleted file mode 100644
index 1d19ee59b5b..00000000000
--- a/tests/morency_doin.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-set Dimension = 2
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent    = 3000e3
-    set Y extent    = 750e3
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields  = upper_crust, lower_crust
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = if(y>=725e3,1,0);if((y<725e3&y>700e3),1,0)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=750e3, w=3000e3
-    set Function expression = \
-      if( y < 100e3, \
-        (100e3-y)/100e3*100+1635, \
-        if(y>650e3, \
-          (h-y)/(100e3)*1342+293, \
-          1635))
-  end
-end
-
-subsection Material model
-  set Model name = Morency and Doin
-
-  subsection Morency and Doin
-    set Densities = 3300,2700,2700
-    set Activation energies = 500,320,320
-    set Coefficient of yield stress increase with depth = 0.25
-    set Thermal expansivities = 2e-5
-    set Stress exponents for viscous rheology = 3
-    set Stress exponents for plastic rheology = 30
-    set Thermal diffusivity = 0.8e-6
-    set Heat capacity = 1.25e3
-    set Activation volume = 6.4e-6
-    set Reference strain rate = 6.4e-16
-    set Preexponential constant for viscous rheology law = 7e11 ## Value used in paper is 1.24e14
-    set Cohesive strength of rocks at the surface = 117
-    set Reference temperature = 293
-    set Minimum strain rate = 5e-19                             ## Value used in paper is 1.4e-20
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                 = 5
-  set Initial adaptive refinement               = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = depth average
-
-  subsection Depth average
-    set Number of zones = 32
-    set Output format = gnuplot
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 0
-end
diff --git a/tests/multicomponent_arithmetic.prm.bak b/tests/multicomponent_arithmetic.prm.bak
deleted file mode 100644
index e99f3107107..00000000000
--- a/tests/multicomponent_arithmetic.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# Test the multicomponent material model using arithmetic
-# averaging for viscosity. Three blobs with different
-# densities and different viscosities move around...
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 2e7
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0.0
-    set Bottom temperature = 0.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 28.e5
-    set Y extent = 7.e5
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-5.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1, 0)
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature = 0.0
-    set Densities = 3300, 3200, 3600,3400
-    set Specific heats = 1250
-    set Thermal conductivities = 4.7
-    set Thermal expansivities = 4e-5
-    set Viscosities = 1.e21, 1.e20, 1.e23, 1.e22
-    set Viscosity averaging scheme = arithmetic
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = composition
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( sqrt((x-12.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1,0); if( sqrt((x-17.e5)^2 + (y-3.e5)^2) < 5.e4, 1, 0)
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step                  = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity,density
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/multicomponent_compressible_averaging.prm.bak b/tests/multicomponent_compressible_averaging.prm.bak
deleted file mode 100644
index f71093e38ba..00000000000
--- a/tests/multicomponent_compressible_averaging.prm.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-# This test checks that the correct averaging is done by the
-# multicomponent compressible material model. In this test,
-# two materials are chosen, with constant mass fractions of 0.5.
-# At the reference temperature (273 K) and at 0 GPa pressure,
-# materials 1 and 2 have densities of 2000 kg/m^3 and 3000 kg/m^3,
-# which equates to volume fractions of 0.6 and 0.4.
-#
-# The outputs for the properties at 0 GPa and 273 K are then:
-# Density: 2400 kg/m^3 (volume averaged, 0.6*2000 + 0.4*3000)
-# Thermal_expansivity: 2.4e-5 (volume averaged, 0.6*2e-5 + 0.4*3e-5)
-# Isochoric specific_heat: 1500 (mass averaged, 0.5*1000 + 0.5*2000)
-# Viscosity: 2.4e20 (arithmetically volume averaged, 0.6*2.e20 + 0.4*3.e20)
-# Thermal conductivity: 2.4 (volume averaged, 0.6*2 + 0.4*3)
-# Isobaric specific heat: 1527.3 (mass averaged, 0.5*1027.3 + 0.5*2027.3)
-# (because isobaric specific heat Cp = Cv + T*alpha^2/(rho*beta_T))
-#
-# At other pressure-temperature conditions, the volume
-# fractions change despite the mass fractions remaining constant.
-
-set CFL number                             = 1.0
-set End time                               = 0.
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name         = multicomponent compressible
-
-  subsection Multicomponent compressible
-    set Reference temperatures = 273.
-    set Reference densities = 2000., 3000.
-    set Reference isothermal compressibilities = 2e-12, 3e-12
-    set Isothermal bulk modulus pressure derivatives = 4, 4
-    set Reference thermal expansivities = 2.e-5, 3.e-5
-    set Isochoric specific heats = 1000., 2000.
-    set Thermal conductivities = 2., 3.
-    set Viscosities = 2.e20, 3.e20
-    set Viscosity averaging scheme = arithmetic
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, basic statistics, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = material properties, thermal conductivity
-    set Time between graphical output = 0
-
-    subsection Vp anomaly
-      set Number of depth slices = 12
-    end
-
-    subsection Vs anomaly
-      set Number of depth slices = 12
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/multicomponent_geometric.prm.bak b/tests/multicomponent_geometric.prm.bak
deleted file mode 100644
index 2d5e80b85bc..00000000000
--- a/tests/multicomponent_geometric.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# Test the multicomponent material model using geometric
-# averaging for viscosity. Three blobs with different
-# densities and different viscosities move around...
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 2e7
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0.0
-    set Bottom temperature = 0.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 28.e5
-    set Y extent = 7.e5
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-5.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1, 0)
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature = 0.0
-    set Densities = 3300, 3200, 3600,3400
-    set Specific heats = 1250
-    set Thermal conductivities = 4.7
-    set Thermal expansivities = 4e-5
-    set Viscosities = 1.e21, 1.e20, 1.e23, 1.e22
-    set Viscosity averaging scheme = geometric
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = composition
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( sqrt((x-12.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1,0); if( sqrt((x-17.e5)^2 + (y-3.e5)^2) < 5.e4, 1, 0)
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step                  = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity,density
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/multicomponent_harmonic.prm.bak b/tests/multicomponent_harmonic.prm.bak
deleted file mode 100644
index 50b8e9e15f2..00000000000
--- a/tests/multicomponent_harmonic.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# Test the multicomponent material model using harmonic
-# averaging for viscosity. Three blobs with different
-# densities and different viscosities move around...
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 2e7
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0.0
-    set Bottom temperature = 0.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 28.e5
-    set Y extent = 7.e5
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-5.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1, 0)
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature = 0.0
-    set Densities = 3300, 3200, 3600,3400
-    set Specific heats = 1250
-    set Thermal conductivities = 4.7
-    set Thermal expansivities = 4e-5
-    set Viscosities = 1.e21, 1.e20, 1.e23, 1.e22
-    set Viscosity averaging scheme = harmonic
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = composition
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( sqrt((x-12.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1,0); if( sqrt((x-17.e5)^2 + (y-3.e5)^2) < 5.e4, 1, 0)
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step                  = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity,density
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/multicomponent_max_composition.prm.bak b/tests/multicomponent_max_composition.prm.bak
deleted file mode 100644
index f7e6b3df599..00000000000
--- a/tests/multicomponent_max_composition.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# Test the multicomponent material model using maximum composition
-# averaging for viscosity. Three blobs with different
-# densities and different viscosities move around...
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 2e7
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0.0
-    set Bottom temperature = 0.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 28.e5
-    set Y extent = 7.e5
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-5.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1, 0)
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature = 0.0
-    set Densities = 3300, 3200, 3600,3400
-    set Specific heats = 1250
-    set Thermal conductivities = 4.7
-    set Thermal expansivities = 4e-5
-    set Viscosities = 1.e21, 1.e20, 1.e23, 1.e22
-    set Viscosity averaging scheme = maximum composition
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = composition
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-3.e5)^2) < 5.e4 , 1,0); if( sqrt((x-12.e5)^2 + (y-3.e5)^2 ) < 5.e4, 1,0); if( sqrt((x-17.e5)^2 + (y-3.e5)^2) < 5.e4, 1, 0)
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step                  = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity,density
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/multicomponent_steinberger.prm.bak b/tests/multicomponent_steinberger.prm.bak
deleted file mode 100644
index dff155ef20a..00000000000
--- a/tests/multicomponent_steinberger.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-# Test the multicomponent steinberger material model. Three blobs with different viscosities move around.
-# The reference viscosity of background is from the radial viscosity profile of Steinberger & Calderwood 2006.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 60000
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 1600
-set Surface pressure                       = 0
-set Pressure normalization = surface
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators = top, bottom, left, right
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom, left, right
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2.e6
-    set Y extent = 2.e6
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 1600
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( sqrt( (x-5.e5 )^2 + (y-5.e5)^2) < 2.e5 , 1,0); if( sqrt((x-10.e5)^2 + (y-15.e5)^2 ) < 2.e5, 1,0); if( sqrt((x-15.e5)^2 + (y-10.e5)^2) < 2.e5, 1, 0)
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Use lateral average temperature for viscosity = false
-    set Data directory                                = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Radial viscosity file name                    = radial-visc.txt
-    set Lateral viscosity file name                   = temp-viscosity-prefactor.txt
-    set Composition viscosity prefactors              = 1, 5, 0.1, 10
-    set Material file names                           = pyr-ringwood88.txt, pyr-ringwood88.txt, pyr-ringwood88.txt, pyr-ringwood88.txt
-    set Minimum viscosity                             = 1e19
-    set Maximum viscosity                             = 1e24
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = composition, viscosity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step                  = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity,density
-    set Output format                 = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/multiple_named_additional_outputs.cc.bak b/tests/multiple_named_additional_outputs.cc.bak
deleted file mode 100644
index 8f019a5f76c..00000000000
--- a/tests/multiple_named_additional_outputs.cc.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class PrescribedFieldMaterial : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-        virtual
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    PrescribedFieldMaterial<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      Simple<dim>::evaluate(in, out);
-
-      // set up variable to interpolate prescribed field outputs onto compositional fields
-      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
-
-      if (prescribed_field_out != nullptr)
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          {
-            const double y = in.position[i](1);
-            prescribed_field_out->prescribed_field_outputs[i][1] = std::exp(-y*y/2.0);
-          }
-
-      SeismicAdditionalOutputs<dim> *seismic_out = out.template get_additional_output<SeismicAdditionalOutputs<dim>>();
-
-      if (seismic_out != nullptr)
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          {
-            const double y = in.position[i](1);
-            seismic_out->vp[i] = std::exp(-y*y/3.0);
-            seismic_out->vs[i] = -std::exp(-y*y/3.0);
-          }
-    }
-
-
-    template <int dim>
-    void
-    PrescribedFieldMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points,this->n_compositional_fields()));
-        }
-
-      if (out.template get_additional_output<SeismicAdditionalOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::SeismicAdditionalOutputs<dim>> (n_points));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedFieldMaterial,
-                                   "prescribed field material",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but creates prescribed field outputs.")
-  }
-}
diff --git a/tests/multiple_named_additional_outputs.prm.bak b/tests/multiple_named_additional_outputs.prm.bak
deleted file mode 100644
index 809d89ee914..00000000000
--- a/tests/multiple_named_additional_outputs.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# A testcase that demonstrates the named additional outputs postprocessor for multiple
-# named outputs. The test is based on prescribed_field_with_diffusion only
-# with more than one additional output.
-
-set Dimension = 2
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-
-subsection Solver parameters
-  subsection Diffusion solver parameters
-    set Diffusion length scale = 0.23241476
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 0.1
-    set Y extent = 10
-    set Y repetitions = 100
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields  = normal_field, diffused_field
-  set Compositional field methods = field, prescribed field with diffusion
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.1
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0; 0.0
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = top
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 0; 0
-  end
-end
-
-subsection Material model
-  set Model name = prescribed field material
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = named additional outputs
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/muparser-temperature-example.prm.bak b/tests/muparser-temperature-example.prm.bak
deleted file mode 100644
index 5f785a7a607..00000000000
--- a/tests/muparser-temperature-example.prm.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-# Basic parameter file for using a function expression to define the
-# initial temperature structure using (? : ) syntax for if-else conditions.
-# 2D, Dimensional, Boussinesq, Simple Material Model
-
-# Dimension, end-time (years) and output directory
-# Only does zeroth time-step to show that initial condition works
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output-muparser-temperature-example
-
-# Parameters Related to the Solver and Pressure Normalization
-
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Even when using the Boussinesq approximation you need to set this parameter
-# because this will be the temperature used to calculate the reference density
-# used in the advection equation (even if a separate reference temperature is
-# specified by the material model)
-
-set Adiabatic surface temperature          = 273 # K
-
-# If you have a large model or a model with large viscosity variation and you
-# want to run the 0th timestep more quickly in order to just check in the initial
-# condition (IC), you can set these solver tolerance values to larger numbers, but
-# this means the solution will not be converged.
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance            = 1e-6 # can set to 1e-3 for checking IC
-  end
-end
-
-# The following is equivalent to the Boussinesq approximation
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation = incompressible
-  set Temperature equation = reference density profile
-end
-
-# Want a 2D box 5000 km wide by 1000 km deep (5e6 x 1e6 meters).
-# The variable repetitions divides the whole domain into 5 boxes (1000 x 1000 km)
-# as the 0th level mesh refinement: this is needed so elements are squares
-# and not elongated rectangles.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 5e6
-    set Y extent = 1e6
-    set X repetitions = 5
-    set Y repetitions = 1
-  end
-end
-
-# Refine the upper 150 km of the mesh so lithosphere structure is resolved.
-# Function expression asks if the depth is less than the lithosphere depth and
-# then refinement level = 5, else  refinement level = 0
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Minimum refinement level           = 1
-  set Initial adaptive refinement        = 2
-  set Time steps between mesh refinement = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function constants  = ymax=1e6,lith=1.5e5
-    set Function expression = ((ymax-y<=lith) ? 5 : 0)
-  end
-end
-
-# Half-space cooling model increasing with age from x>0 to xtr
-# For x>xtr, half-space cooling model with a fixed age.
-# Note, we use 1-erfc instead of erf because the muparser in dealii
-# only knows about erfc. Also, we need to use ymax-y since y=0 at the
-# bottom of the box
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = ymax=1.0e6, xtrm=2.200e6, vsub=7.927e-10, \
-                               ageop=9.46e14, Tm=1673, Ts=273, kappa=1e-6
-    set Function expression = (((x>0.0) && (x<=xtrm)) ? \
-                                 (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*(x/vsub)))))) : \
-                                 (x>xtrm) ? \
-                                  (Ts + (Tm-Ts)*(1-erfc((ymax-y)/(2*sqrt(kappa*ageop))))) :\
-                                  (Tm) )
-  end
-end
-
-# Set boundary types and values for temperature
-# Default is zero-flux (keep for sidewalls), so only need set top and bottom to fixed temperature
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1673
-    set Top temperature    = 273
-  end
-end
-
-# Free-slip on all sides (tangential velocity V-perp=0, dV/dn=0)
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300  # kg/m^3
-    set Reference specific heat       = 1250  # J/kg/K
-    set Reference temperature         = 273   # K
-    set Thermal conductivity          = 4.125 # W/m/K
-    set Thermal expansion coefficient = 2e-5  # 1/K
-    set Viscosity                     = 1e21  # Pa s
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics
-
-  subsection Visualization
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-end
diff --git a/tests/n_expensive_stokes_solver_steps.prm.bak b/tests/n_expensive_stokes_solver_steps.prm.bak
deleted file mode 100644
index f4173d0b6fe..00000000000
--- a/tests/n_expensive_stokes_solver_steps.prm.bak
+++ /dev/null
@@ -1,160 +0,0 @@
-# Test depth-dependent material model in 2d box using simple material model as
-# base model with no depth-dependence
-
-# EXPECT FAILURE
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = true
-set End time                               = 1.0e8
-
-#set Output directory                       = output
-
-# Then there are variables that describe the tolerance of
-# the linear solver as well as how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-
-
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.0e6
-    set Y extent = 3.0e6
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=10.0, L=3.0e6, pi=3.1415926536, k=1
-    set Function expression = 2773.0 - z/L*(2500.0) + p*cos(k*pi*x/L)*sin(k*pi*z/L/2.0)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above. (As will be seen
-# in the next section, the actual temperature prescribed here
-# at the left and right does not matter.)
-# We then also have to prescribe several other parts of the model such as
-# which boundaries actually carry a prescribed boundary temperature, whereas
-# all other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 2773
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 273.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 2e-5   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = depth dependent
-
-  subsection Depth dependent model
-    set Base model = simple
-    set Depth dependence method = None
-    set Reference viscosity = 1e25
-  end
-
-  subsection Simple model
-    set Reference density             = 3300.0
-    set Reference specific heat       = 1250.0
-    set Reference temperature         = 0
-    set Thermal conductivity          = 4.0
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e25
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, depth average
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set Number of cheap Stokes solver steps = 0
-    set Maximum number of expensive Stokes solver steps = 5
-  end
-end
diff --git a/tests/natural_coordinates_conversion.cc.bak b/tests/natural_coordinates_conversion.cc.bak
deleted file mode 100644
index adc504dbe67..00000000000
--- a/tests/natural_coordinates_conversion.cc.bak
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/geometry_model/box.h>
-#include <aspect/geometry_model/chunk.h>
-#include <aspect/geometry_model/ellipsoidal_chunk.h>
-#include <aspect/geometry_model/two_merged_boxes.h>
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-#include <aspect/geometry_model/initial_topography_model/zero_topography.h>
-#include <aspect/simulator_access.h>
-#include <limits>
-
-int f()
-{
-  using namespace aspect;
-  // test whether the functions return the inverse of each other.
-
-  // test point
-  Point<2> point_2d(25000,50000);
-  Point<3> point_3d(25000,25000,50000);
-
-  std::array<double,2> inter_point_2d;
-  std::array<double,3> inter_point_3d;
-  Point<2> new_point_2d = Point<2>();
-  Point<3> new_point_3d= Point<3>();
-  // get the supported geometries
-  std::cout << std::endl << "2D:" << std::endl;
-  // Box 2D
-  {
-    GeometryModel::Box<2> box;
-    ParameterHandler prm_box;
-    box.declare_parameters(prm_box);
-    prm_box.enter_subsection("Geometry model");
-    prm_box.enter_subsection("Box");
-    prm_box.set("X extent", "100e3");
-    prm_box.set("Y extent", "100e3");
-    prm_box.leave_subsection();
-    prm_box.leave_subsection();
-    box.parse_parameters(prm_box);
-
-    inter_point_2d = box.cartesian_to_natural_coordinates(point_2d);
-    new_point_2d = box.natural_to_cartesian_coordinates(inter_point_2d);
-
-    if (std::fabs(new_point_2d(0) - point_2d(0)) < 1e-8 &&
-        std::fabs(new_point_2d(1) - point_2d(1)) < 1e-8)
-      std::cout << "Box 2D ok:                   point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
-    else
-      std::cout << "Box 2D failed:               point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
-  }
-
-  // Two merged boxes 2d
-  {
-    GeometryModel::TwoMergedBoxes<2> two_merged_boxes;
-    ParameterHandler prm_two_merged_boxes;
-    two_merged_boxes.declare_parameters(prm_two_merged_boxes);
-    prm_two_merged_boxes.enter_subsection("Geometry model");
-    prm_two_merged_boxes.enter_subsection("Box with lithosphere boundary indicators");
-    prm_two_merged_boxes.set("X extent", "100e3");
-    prm_two_merged_boxes.set("Y extent", "100e3");
-    prm_two_merged_boxes.leave_subsection();
-    prm_two_merged_boxes.leave_subsection();
-    two_merged_boxes.parse_parameters(prm_two_merged_boxes);
-    inter_point_2d = two_merged_boxes.cartesian_to_natural_coordinates(point_2d);
-    new_point_2d = two_merged_boxes.natural_to_cartesian_coordinates(inter_point_2d);
-
-    if (std::fabs(new_point_2d(0) - point_2d(0)) < 1e-8 &&
-        std::fabs(new_point_2d(1) - point_2d(1)) < 1e-8)
-      std::cout << "Two merged boxes 2d ok:      point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
-    else
-      std::cout << "Two merged boxes 2d failed:  point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
-  }
-
-  // Chunk 2d
-  {
-    GeometryModel::Chunk<2> chunk;
-    ParameterHandler prm_chunk;
-    chunk.declare_parameters(prm_chunk);
-    prm_chunk.enter_subsection("Geometry model");
-    prm_chunk.enter_subsection("Chunk");
-    prm_chunk.set("Chunk inner radius", "6128137.0");
-    prm_chunk.set("Chunk outer radius", "6378137.0");
-    prm_chunk.leave_subsection();
-    prm_chunk.leave_subsection();
-    chunk.parse_parameters(prm_chunk);
-
-    inter_point_2d = chunk.cartesian_to_natural_coordinates(point_2d);
-    new_point_2d = chunk.natural_to_cartesian_coordinates(inter_point_2d);
-
-    if (std::fabs(new_point_2d(0) - point_2d(0)) < 1e-8 &&
-        std::fabs(new_point_2d(1) - point_2d(1)) < 1e-8)
-      std::cout << "Chunk 2D ok:                 point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
-    else
-      std::cout << "Chunk 2D failed:             point = " << point_2d << ", inter point = " << inter_point_2d[0] << ", " << inter_point_2d[1] << ", new_point = " << new_point_2d << std::endl;
-
-  }
-  std::cout << std::endl << "3D:" << std::endl;
-  // Box 3D
-  {
-    GeometryModel::Box<3> box;
-    //box.initialize(topo);
-    ParameterHandler prm_box;
-    box.declare_parameters(prm_box);
-    prm_box.enter_subsection("Geometry model");
-    prm_box.enter_subsection("Box");
-    prm_box.set("X extent", "100e3");
-    prm_box.set("Y extent", "100e3");
-    prm_box.set("Z extent", "200e3");
-    prm_box.leave_subsection();
-    prm_box.leave_subsection();
-    box.parse_parameters(prm_box);
-
-    inter_point_3d = box.cartesian_to_natural_coordinates(point_3d);
-    new_point_3d = box.natural_to_cartesian_coordinates(inter_point_3d);
-
-    if (std::fabs(new_point_3d(0) - point_3d(0)) < 1e-8 &&
-        std::fabs(new_point_3d(1) - point_3d(1)) < 1e-8 &&
-        std::fabs(new_point_3d(2) - point_3d(2)) < 1e-8)
-      std::cout << "Box 3D ok:                   point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
-    else
-      std::cout << "Box 3D failed:               point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
-  }
-
-  // Two merged boxes 3d
-  {
-    GeometryModel::TwoMergedBoxes<3> two_merged_boxes;
-    ParameterHandler prm_two_merged_boxes;
-    two_merged_boxes.declare_parameters(prm_two_merged_boxes);
-    prm_two_merged_boxes.enter_subsection("Geometry model");
-    prm_two_merged_boxes.enter_subsection("Box with lithosphere boundary indicators");
-    prm_two_merged_boxes.set("X extent", "100e3");
-    prm_two_merged_boxes.set("Y extent", "100e3");
-    prm_two_merged_boxes.set("Z extent", "200e3");
-    prm_two_merged_boxes.leave_subsection();
-    prm_two_merged_boxes.leave_subsection();
-    two_merged_boxes.parse_parameters(prm_two_merged_boxes);
-    inter_point_3d = two_merged_boxes.cartesian_to_natural_coordinates(point_3d);
-    new_point_3d = two_merged_boxes.natural_to_cartesian_coordinates(inter_point_3d);
-
-    if (std::fabs(new_point_3d(0) - point_3d(0)) < 1e-8 &&
-        std::fabs(new_point_3d(1) - point_3d(1)) < 1e-8 &&
-        std::fabs(new_point_3d(2) - point_3d(2)) < 1e-8)
-      std::cout << "Two merged boxes 3d ok:      point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
-    else
-      std::cout << "Two merged boxes 3d failed:  point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
-  }
-
-  // Chunk 3d
-  {
-    GeometryModel::Chunk<3> chunk;
-    ParameterHandler prm_chunk;
-    chunk.declare_parameters(prm_chunk);
-    prm_chunk.enter_subsection("Geometry model");
-    prm_chunk.enter_subsection("Chunk");
-    prm_chunk.set("Chunk inner radius", "6128137.0");
-    prm_chunk.set("Chunk outer radius", "6378137.0");
-    prm_chunk.leave_subsection();
-    prm_chunk.leave_subsection();
-    chunk.parse_parameters(prm_chunk);
-
-    inter_point_3d = chunk.cartesian_to_natural_coordinates(point_3d);
-    new_point_3d = chunk.natural_to_cartesian_coordinates(inter_point_3d);
-
-    if (std::fabs(new_point_3d(0) - point_3d(0)) < 1e-8 &&
-        std::fabs(new_point_3d(1) - point_3d(1)) < 1e-8 &&
-        std::fabs(new_point_3d(2) - point_3d(2)) < 1e-8)
-      std::cout << "Chunk 3D ok:                 point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", new_point = " << new_point_3d << std::endl;
-    else
-      std::cout << "Chunk 3D failed:             point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", new_point = " << new_point_3d << std::endl;
-  }
-
-  // Ellipsoidal chunk 3d
-  {
-    GeometryModel::EllipsoidalChunk<3> ellipsoidal_chunk;
-    ParameterHandler prm_ellispoidal_chunk;
-    ellipsoidal_chunk.declare_parameters(prm_ellispoidal_chunk);
-    prm_ellispoidal_chunk.enter_subsection("Geometry model");
-    prm_ellispoidal_chunk.enter_subsection("Ellipsoidal chunk");
-    prm_ellispoidal_chunk.set("NE corner", "10:10");
-    prm_ellispoidal_chunk.set("SW corner", "0:0");
-    prm_ellispoidal_chunk.leave_subsection();
-    prm_ellispoidal_chunk.leave_subsection();
-    ellipsoidal_chunk.parse_parameters(prm_ellispoidal_chunk);
-    inter_point_3d = ellipsoidal_chunk.cartesian_to_natural_coordinates(point_3d);
-    new_point_3d = ellipsoidal_chunk.natural_to_cartesian_coordinates(inter_point_3d);
-
-    if (std::fabs(new_point_3d(0) - point_3d(0)) < 1e-8 &&
-        std::fabs(new_point_3d(1) - point_3d(1)) < 1e-8 &&
-        std::fabs(new_point_3d(2) - point_3d(2)) < 1e-8)
-      std::cout << "Ellipsoidal 3d chunk ok:     point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
-    else
-      std::cout << "Ellipsoidal 3d chunk failed: point = " << point_3d << ", inter point = " << inter_point_3d[0] << ", " << inter_point_3d[1] << ", " << inter_point_3d[2]<< ", new_point = " << new_point_3d << std::endl;
-  }
-
-
-  exit(0);
-  return 42;
-}
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/natural_coordinates_conversion.prm.bak b/tests/natural_coordinates_conversion.prm.bak
deleted file mode 100644
index e7f90049811..00000000000
--- a/tests/natural_coordinates_conversion.prm.bak
+++ /dev/null
@@ -1 +0,0 @@
-set Additional shared libraries = tests/libnatural_coordinates_conversion.so
diff --git a/tests/netcdf_boundary_velocity_2d_box.prm.bak b/tests/netcdf_boundary_velocity_2d_box.prm.bak
deleted file mode 100644
index 65f0788c9a5..00000000000
--- a/tests/netcdf_boundary_velocity_2d_box.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# Test netcdf data loaded into StructuredData and used as a boundary velocity
-#
-# test copied from ascii_data_boundary_velocity_2d_box.prm and modified
-# box_2d_left.0.nc is converted from data/boundary-velocity/ascii-data/test/box_2d_left.0.txt
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0.01
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3300000
-    set Y extent = 660000
-    set X repetitions = 5
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Amplitude = 300
-    set Radius    = 250000
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top,bottom
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left: ascii data, right: ascii data
-  set Zero velocity boundary indicators = top,bottom
-
-  subsection Ascii data model
-    set Data file name       = box_2d_left.0.nc
-    set Data directory = $ASPECT_SOURCE_DIR/data/test/netcdf/
-    set Scale factor = 0.01
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/newton_postprocess_nonlinear.prm.bak b/tests/newton_postprocess_nonlinear.prm.bak
deleted file mode 100644
index b563800640c..00000000000
--- a/tests/newton_postprocess_nonlinear.prm.bak
+++ /dev/null
@@ -1,175 +0,0 @@
-# This test makes sure that postprocessing nonlinear iterations works
-# with the Newton solver scheme.
-
-#  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
-set Nonlinear solver tolerance             = 1e-4
-set Max nonlinear iterations               = 5
-set CFL number                             = 0.5
-set Maximum time step                      = 5
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-
-# Solver parameters
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block AMG
-    set Linear solver tolerance = 1e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-
-  subsection Newton solver parameters
-    set Max Newton line search iterations        = 5
-    set Max pre-Newton nonlinear iterations      = 200
-    set Maximum linear Stokes solver tolerance   = 1e-1
-    set Nonlinear Newton solver switch tolerance = 1e-4
-    set SPD safety factor                        = 0.9
-    set Stabilization preconditioner             = SPD
-    set Stabilization velocity block             = SPD
-    set Use Newton failsafe                      = false
-    set Use Newton residual scaling method       = false
-    set Use Eisenstat Walker method for Picard iterations = true
-  end
-end
-
-# Model geometry (100x100 km, initial 50 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 2
-    set Y repetitions = 2
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Globally refine to 3.125 km grid spacing
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Velocity boundary conditions (5e-9 m/s on each boundary)
-# The imposed velocity produces a background strain-rate
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = left x: function, right x:function, top y: function, bottom y: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = vel=0.15778463
-    set Function expression = if (x<50e3 , vel, -vel); if (y<50e3, -vel, vel);
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, block,                air,                  inclusion
-  set Types of fields  = stress,       stress,       stress,       chemical composition, chemical composition, chemical composition
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; \
-                              if ( ( x<43.75e3 && y>25.e3 && y<75.e3) || (x>56.25e3 && y>25.e3 && y<75.e3) || (y>56.25e3 && y<75.e3 && x>=43.75e3 && x<=56.25e3) || (y<43.75e3 && y>25.e3 && x>=43.75e3 && x<=56.25e3), 1, 0); \
-                              if (y<=25.e3 || y>=75.e3, 1, 0); \
-                              if (y<=56.25e3 && y>=43.75e3 && x>=43.75e3 && x<=56.25e3, 1, 0);
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Fixed composition boundary indicators  =
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# Temperature initial conditions (isothermal)
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.
-  end
-end
-
-# Material model
-subsection Material model
-  set Material averaging = none
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Densities                   = 2700
-    set Reference strain rate       = 1.e-13
-    set Maximum viscosity           = 1.e23
-    set Minimum viscosity           = 1.e17
-    set Prefactors for dislocation creep          = 5e-24, 1e-50, 1e-50, 1e-50, 5e-24, 5.e-18, 5e-18
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 1e50
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 5e3
-    set Viscosity averaging scheme  = harmonic
-    set Angles of internal friction = 37., 0., 0., 0., 37., 0., 0.
-    set Cohesions                   = 100.e6, 1.e50, 1.e50, 1.e50, 100.e6, 10.e6, 10.e6
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, velocity statistics, visualization
-  set Run postprocessors on nonlinear iterations = true
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate, named additional outputs
-    set Time between graphical output = 0e3
-    set Interpolate output = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-end
-
-# Termination criteria
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/tests/no_Advection_iterated_defect_correction_Stokes.prm.bak b/tests/no_Advection_iterated_defect_correction_Stokes.prm.bak
deleted file mode 100644
index fa9414f79ba..00000000000
--- a/tests/no_Advection_iterated_defect_correction_Stokes.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-#########################################################
-# This is a model setup to test the iterated Advection and Stokes solver.
-# Both the calculation of the residuum and the convergence
-# with prescribed boundary conditions are tested.
-
-set Adiabatic surface temperature          = 0
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = no Advection, iterated defect correction Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-
-  subsection Stabilization parameters
-    set beta  = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 150000
-    set Y extent  = 65000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 0
-    set Thermal expansion coefficient = 1
-    set Thermal viscosity exponent = 0.0
-    set Reference specific heat = 1.0
-    set Reference density = 1.0
-    set Reference temperature = 0
-    set Viscosity = 1e16
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-2
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/no_adiabatic_heating.cc.bak b/tests/no_adiabatic_heating.cc.bak
deleted file mode 100644
index 439e10250a9..00000000000
--- a/tests/no_adiabatic_heating.cc.bak
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// use the same postprocessing facilities as for the
-// 'compressibility_iterated_stokes' testcase
-#include "compressibility_iterated_stokes.cc"
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class NoAdiabaticHeating : public CompressibilityIteratedStokes<dim>
-    {
-      public:
-        virtual double thermal_expansion_coefficient (const double,
-                                                      const double,
-                                                      const std::vector<double> &,
-                                                      const Point<dim> &) const
-        {
-          return 0;
-        }
-    };
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(NoAdiabaticHeating,
-                                   "no adiabatic heating",
-                                   "As described in the .prm file.")
-  }
-}
diff --git a/tests/no_adiabatic_heating.prm.bak b/tests/no_adiabatic_heating.prm.bak
deleted file mode 100644
index 79d44e0bf0b..00000000000
--- a/tests/no_adiabatic_heating.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# This is a follow-on on the 'compressibility_iterated_stokes' testcase
-# where we choose
-#   u_z = 1+z/100
-# If we switch off adiabatic heating and shear heating, then there
-# should be no effect on the temperature field from the velocity, and
-# no effect from the temperature onto the velocity either. Verify that
-# this is so
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 5
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = no adiabatic heating
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/tests/no_adiabatic_heating_02.cc.bak b/tests/no_adiabatic_heating_02.cc.bak
deleted file mode 100644
index 1b5ed90f274..00000000000
--- a/tests/no_adiabatic_heating_02.cc.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// use the same postprocessing facilities as for the
-// 'compressibility_iterated_stokes' testcase
-#include "compressibility_iterated_stokes.cc"
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class NoAdiabaticHeating : public CompressibilityIteratedStokes<dim>
-    {
-      public:
-        virtual double thermal_expansion_coefficient (const double,
-                                                      const double,
-                                                      const std::vector<double> &,
-                                                      const Point<dim> &) const
-        {
-          return 0;
-        }
-
-        virtual double viscosity (const double,
-                                  const double,
-                                  const std::vector<double> &,
-                                  const Point<dim> &) const
-        {
-          return 0;
-        }
-    };
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(NoAdiabaticHeating,
-                                   "no adiabatic heating",
-                                   "As described in the .prm file.")
-  }
-}
diff --git a/tests/no_adiabatic_heating_02.prm.bak b/tests/no_adiabatic_heating_02.prm.bak
deleted file mode 100644
index 19640fb0d82..00000000000
--- a/tests/no_adiabatic_heating_02.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# Like 'no_adiabatic_heating' but here we actually switch on friction
-# heating. We also set the viscosity to zero, so there should still
-# be no change in temperature
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 5
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = no adiabatic heating
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, velocity statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.1
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/tests/no_adiabatic_heating_03.cc.bak b/tests/no_adiabatic_heating_03.cc.bak
deleted file mode 100644
index 439e10250a9..00000000000
--- a/tests/no_adiabatic_heating_03.cc.bak
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// use the same postprocessing facilities as for the
-// 'compressibility_iterated_stokes' testcase
-#include "compressibility_iterated_stokes.cc"
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class NoAdiabaticHeating : public CompressibilityIteratedStokes<dim>
-    {
-      public:
-        virtual double thermal_expansion_coefficient (const double,
-                                                      const double,
-                                                      const std::vector<double> &,
-                                                      const Point<dim> &) const
-        {
-          return 0;
-        }
-    };
-
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(NoAdiabaticHeating,
-                                   "no adiabatic heating",
-                                   "As described in the .prm file.")
-  }
-}
diff --git a/tests/no_adiabatic_heating_03.prm.bak b/tests/no_adiabatic_heating_03.prm.bak
deleted file mode 100644
index 8a85abf90d1..00000000000
--- a/tests/no_adiabatic_heating_03.prm.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-# Like 'no_adiabatic_heating_02' but here we actually switch on shear
-# heating and set the viscosity to a non-zero. In this testcase, we have
-#   u_z(z) = 1+z/10
-# so in 2d, we have
-#   eps(u) - 1/3 (div u) I = [[-1/30,0], [0,2/30]]
-# so the shear heating term is
-#   2*eta*5/9*(1/10)^2
-# From the velocity, we get
-#   z = t+t^2/20
-# Consequently, if we set the thermal diffusivity to zero and c_P=1, then from
-#   rho(t) DT/Dt = 2*eta*5/9*(1/10)^2
-# we get
-#   T(t)  = \int_0^t 2*eta*5/9*(1/10)^2 / rho(t) dt
-# Now,
-#   rho(t) = rho(z(t)) = rho(t+t^2/20) = 1/(1+u_z(z(t))
-#          = 1/(1+(t+t^2/20)/10)
-# so
-#   T(t)  = eta/90 * (t + t^2/20 + t^3/600)
-# We can reformulate this in terms of z as
-#   T(z)  = eta/1350 * [(z+20)*sqrt(25+5z) - 100]
-# Thus, the maximal temperature at the outlet should be
-#   T(1)  = 0.011*eta
-# To make all of this work, of course, we need that the density does
-# not depend on the temperature
-#
-# In this testcase, we choose eta=10, so this should lead to
-#   T(1)  = 0.1112
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = .1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 5
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2
-
-  subsection Box
-    set Bottom temperature = 0
-  end
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = no adiabatic heating
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, velocity statistics, basic statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.1
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/tests/no_cheap_gmg.cc.bak b/tests/no_cheap_gmg.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/no_cheap_gmg.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/no_cheap_gmg.prm.bak b/tests/no_cheap_gmg.prm.bak
deleted file mode 100644
index 1c6367eee09..00000000000
--- a/tests/no_cheap_gmg.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# Like sol_cx_4_gmg but without cheap iterations.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-  set Material averaging = harmonic average
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/no_conduction_timestep.prm.bak b/tests/no_conduction_timestep.prm.bak
deleted file mode 100644
index 2b9b9bf70e5..00000000000
--- a/tests/no_conduction_timestep.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# This test checks that we do not divide by zero when computing
-# the conduction timestep in a model, where the thermal conductivity is
-# set to zero. We simply use the convection timestep in this case
-# (or fall back to the original default, when the velocity is zero as well).
-# Otherwise this test is identical to constant_composition_convergence.prm
-
-set Dimension                              = 2
-set End time                               = 2e8
-set Use years in output instead of seconds = true
-set Use conduction timestep                = true
-set Adiabatic surface temperature          = 1600
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 400000
-    set Y extent = 400000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2 ,3
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 1600 + 100*sin(x*pi/200000.0)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                = 3000
-    set Thermal conductivity             = 0
-    set Thermal expansion coefficient    = 4e-5
-    set Viscosity                        = 1e23
-    set Reference temperature            = 1600
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics
-end
diff --git a/tests/no_dirichlet_on_outflow.prm.bak b/tests/no_dirichlet_on_outflow.prm.bak
deleted file mode 100644
index 330aa2e63dd..00000000000
--- a/tests/no_dirichlet_on_outflow.prm.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-# This test checks if fixed temperature boundary conditions are only
-# prescribed on outflow boundaries (if this option is activated in
-# the input file), and in particular if this also works for time-
-# dependent in- and outflow.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above, whereas all other
-# parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry
-# boundaries).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set Allow fixed temperature on outflow boundaries = false
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-end
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all four sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top:function
-
-  subsection Function
-    set Variable names      = x,y,t
-    set Function expression = 0;(x-0.5)*sin(t*30)
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e4   # = Ra
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy = temperature
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/tests/no_dirichlet_on_outflow_C.prm.bak b/tests/no_dirichlet_on_outflow_C.prm.bak
deleted file mode 100644
index 9b95f9948b2..00000000000
--- a/tests/no_dirichlet_on_outflow_C.prm.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-# This test checks if fixed composition boundary conditions are only
-# prescribed on outflow boundaries (if this option is activated in
-# the input file), and in particular if this also works for time-
-# dependent in- and outflow, and in a case where we prescribe the
-# temperature for both inflow and outflow.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 1.7
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set Allow fixed temperature on outflow boundaries = true
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = bottom, top
-  set Allow fixed composition on outflow boundaries = false
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Prescribed velocity boundary indicators = top:function, bottom:function
-
-  subsection Function
-    set Variable names      = x,y,t
-    set Function expression = 0;(x-0.5)*sin(t*3)
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e4   # = Ra
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 5
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy = temperature
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/tests/no_dirichlet_on_outflow_adaptive.prm.bak b/tests/no_dirichlet_on_outflow_adaptive.prm.bak
deleted file mode 100644
index 62aa05c961c..00000000000
--- a/tests/no_dirichlet_on_outflow_adaptive.prm.bak
+++ /dev/null
@@ -1,172 +0,0 @@
-# This test is a copy of the no_dirichlet_outflow_boundary test,
-# with the only difference that it runs in parallel and adaptive
-# mesh.
-# This test checks if fixed temperature boundary conditions are only
-# prescribed on outflow boundaries (if this option is activated in
-# the input file), and in particular if this also works for time-
-# dependent in- and outflow.
-
-# MPI: 2
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.1
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above, whereas all other
-# parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry
-# boundaries).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set Allow fixed temperature on outflow boundaries = false
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-end
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all four sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top:function
-
-  subsection Function
-    set Variable names      = x,y,t
-    set Function expression = 0;(x-0.5)*sin(t*30)
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e4   # = Ra
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 1
-  set Time steps between mesh refinement       = 0
-  set Strategy = temperature
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/tests/no_dirichlet_on_outflow_melt.cc.bak b/tests/no_dirichlet_on_outflow_melt.cc.bak
deleted file mode 100644
index 41a9c23ffdf..00000000000
--- a/tests/no_dirichlet_on_outflow_melt.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "rising_melt_blob.cc"
diff --git a/tests/no_dirichlet_on_outflow_melt.prm.bak b/tests/no_dirichlet_on_outflow_melt.prm.bak
deleted file mode 100644
index ecef9e27d6a..00000000000
--- a/tests/no_dirichlet_on_outflow_melt.prm.bak
+++ /dev/null
@@ -1,144 +0,0 @@
-# This test checks if fixed composition boundary conditions are only
-# prescribed on outflow boundaries (if this option is activated in
-# the input file), and in particular if this also works in a model
-# with melt transport.
-
-
-set Dimension                              = 2
-set End time                               = 500
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 50
-
-#set CFL number                             = 0.1
-
-subsection Melt settings
-  set Include melt transport = true
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=100000, pi=3.1415926536, k=1
-    set Function expression = 1600
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Material model
-  set Model name = melting rate
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=50000,y0=50000,c=10000
-    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set Allow fixed temperature on outflow boundaries = false
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1600
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = bottom, top
-  set Allow fixed composition on outflow boundaries = false
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Prescribed velocity boundary indicators = top:function, bottom:function
-
-  subsection Function
-    set Variable names      = x,y,t
-    set Function expression = 0;(x/10000-0.5)*sin(t/30)
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e4   # = Ra
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy = temperature
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/tests/no_dirichlet_on_outflow_only_new_constraints.prm.bak b/tests/no_dirichlet_on_outflow_only_new_constraints.prm.bak
deleted file mode 100644
index 838fdf42f08..00000000000
--- a/tests/no_dirichlet_on_outflow_only_new_constraints.prm.bak
+++ /dev/null
@@ -1,168 +0,0 @@
-# This test checks if fixed temperature boundary conditions are only
-# prescribed on outflow boundaries (if this option is activated in
-# the input file), and in particular if this also works for time-
-# dependent in- and outflow where only new constraints are added.
-
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-# Then follows a section that describes the boundary conditions
-# for the temperature. The model we choose is called 'box' and
-# allows to set a constant temperature on each of the four sides
-# of the box geometry. In our case, we choose something that is
-# heated from below and cooled from above, whereas all other
-# parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry
-# boundaries).
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top
-  set Allow fixed temperature on outflow boundaries = false
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = false
-end
-
-# The next parameters then describe on which parts of the
-# boundary we prescribe a zero or nonzero velocity and
-# on which parts the flow is allowed to be tangential.
-# Here, all four sides of the box allow tangential
-# unrestricted flow but with a zero normal component:
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Prescribed velocity boundary indicators = top:function
-
-  subsection Function
-    set Variable names      = x,y,t
-    set Function expression = 0;if(x>2*t,1,-1)
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e4   # = Ra
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy = temperature
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/tests/no_dirichlet_on_outflow_refine.prm.bak b/tests/no_dirichlet_on_outflow_refine.prm.bak
deleted file mode 100644
index 74cf957cc47..00000000000
--- a/tests/no_dirichlet_on_outflow_refine.prm.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-# This test makes sure that the "Allow fixed temperature on outflow
-# boundaries = false" option also works in time steps where the mesh
-# is refined. Flow is prescribed to be vertically upwards and the
-# boundary temperature in the left half of the model is slightly
-# hotter than the initial condition. The mesh is refined in every
-# second step.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 2e6
-set Output directory                       = test
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose 5a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 800e3
-    set Y extent = 800e3
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 1500 + 250 * 0.5 * (1-tanh((x-450000)/40000))
-  end
-end
-
-# This is 10 K hotter than the initial condition within the plume
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set Allow fixed temperature on outflow boundaries = false
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 1500 + 260 * 0.5 * (1-tanh((x-450000)/40000))
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Prescribed velocity boundary indicators = top: function, bottom: function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 0; 0.1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Material model
-  set Model name = latent heat
-  set Material averaging = project to Q1 only viscosity
-
-  subsection Latent heat
-    set Minimum viscosity             = 1e17
-    set Viscosity                     = 7e21
-    set Reference density             = 3291.5
-    set Thermal conductivity          = 4
-    set Thermal expansion coefficient = 2.6e-5
-    set Reference specific heat       = 1000
-    set Reference temperature         = 1600
-    set Compressibility               = 0
-    set Thermal viscosity exponent    = 50.0
-    set Phase transition density jumps                 = 110
-    set Corresponding phase for density jump           = 0
-    set Phase transition depths                        = 300000
-    set Phase transition widths                        = 0
-    set Phase transition temperatures                  = 1600
-    set Phase transition Clapeyron slopes              = 0
-    set Viscosity prefactors                           = 1,1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on.
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Strategy                                 = minimum refinement function
-  set Time steps between mesh refinement       = 2
-
-  subsection Minimum refinement function
-    set Coordinate system = cartesian
-    set Function expression = 4
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set Output format                 = vtu
-    set List of output variables      = material properties
-  end
-end
diff --git a/tests/no_flow.prm.bak b/tests/no_flow.prm.bak
deleted file mode 100644
index bfdd9a468de..00000000000
--- a/tests/no_flow.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# A test that deals with the problem that if there is no flow then the
-# convection time step is infinite. in that case, we need to limit the
-# time step size to something related to the conduction time step
-#
-# We make sure that there is no flow in this particular situation by using
-# zero boundary conditions and a zero thermal expansion coefficient so
-# that the right hand side of the velocity is constant.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set Use conduction timestep       = true
-set End time                               = 1
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 0
-    set Reference specific heat = 1
-    set Thermal conductivity = 1
-    set Reference density = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/non_conservative_with_mpi.cc.bak b/tests/non_conservative_with_mpi.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/non_conservative_with_mpi.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/non_conservative_with_mpi.prm.bak b/tests/non_conservative_with_mpi.prm.bak
deleted file mode 100644
index c38ef837296..00000000000
--- a/tests/non_conservative_with_mpi.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-# this is a variant of the conservative_with_mpi test that verifies that the
-# same as discussed there also works for the non-conservative element
-
-# MPI: 2
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm.bak
deleted file mode 100644
index 3071bfcd224..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set Maximum time step                      = 1
-set End time                               = 4
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = iterated Advection and Newton Stokes
-set Max nonlinear iterations = 45
-set Nonlinear solver tolerance = 5e-10
-set Additional shared libraries = ../benchmarks/nonlinear_channel_flow/libsimple_nonlinear.so
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 3
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 5
-    set Maximum linear Stokes solver tolerance = 1e-1
-  end
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Stokes solver type =  block AMG
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10e3
-    set Y extent = 8e3
-    set Y repetitions = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple nonlinear
-  set Material averaging = none
-
-  subsection Simple nonlinear
-    set Minimum viscosity = 1e19
-    set Maximum viscosity = 1e24
-    set Stress exponent = 3
-    set Viscosity averaging p = 10000
-    set Viscosity prefactor = 1e-37
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 2 y: function, 3 y: function # pressure bc: Prescribe a horizontal traction on the vertical boundaries
-
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 0;if(z>0,0,1e9)
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1
-  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
-
-  subsection Function
-    set Function constants = n = 3
-    set Variable names = x,z
-
-    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
-    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
-
-  subsection Depth average
-    set List of output variables = viscosity
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties,strain rate, spd factor
-    set Output format = gnuplot
-    set Time between graphical output = 2
-  end
-end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.prm.bak
deleted file mode 100644
index 6c5d1c62389..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_GMG.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test Newton GMG solver based on
-# benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
-
-include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
-
-set Additional shared libraries = $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/libsimple_nonlinear.so
-set Max nonlinear iterations = 10
-
-subsection Material model
-  set Material averaging = harmonic average
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.prm.bak
deleted file mode 100644
index fd00966896d..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_deviator.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set Maximum time step                      = 1
-set End time                               = 4
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = iterated Advection and Newton Stokes
-set Max nonlinear iterations = 45
-set Nonlinear solver tolerance = 5e-10
-set Additional shared libraries = ../benchmarks/nonlinear_channel_flow/libsimple_nonlinear.so
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 3
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 5
-    set Maximum linear Stokes solver tolerance = 1e-1
-  end
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Stokes solver type =  block AMG
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10e3
-    set Y extent = 8e3
-    set Y repetitions = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple nonlinear
-  set Material averaging = none
-
-  subsection Simple nonlinear
-    set Minimum viscosity = 1e19
-    set Maximum viscosity = 1e24
-    set Stress exponent = 3
-    set Viscosity averaging p = 10000
-    set Viscosity prefactor = 1e-37
-    set Use deviator of strain-rate = false
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 2 y: function, 3 y: function # pressure bc: Prescribe a horizontal traction on the vertical boundaries
-
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 0;if(z>0,0,1e9)
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1
-  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
-
-  subsection Function
-    set Function constants = n = 3
-    set Variable names = x,z
-
-    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
-    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
-
-  subsection Depth average
-    set List of output variables = viscosity
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties,strain rate, spd factor
-    set Output format = gnuplot
-    set Time between graphical output = 2
-  end
-end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.prm.bak
deleted file mode 100644
index 604797f5fde..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_no_line_search.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm
-
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max Newton line search iterations = 0
-  end
-end
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.cc.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.prm.bak b/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.prm.bak
deleted file mode 100644
index d5c54cc776c..00000000000
--- a/tests/nonlinear_channel_flow_tractions_Newton_Stokes_particles.prm.bak
+++ /dev/null
@@ -1,38 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark, but adds passive particles.
-
-include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_tractions_Newton_Stokes.prm
-
-set Dimension = 2
-set Additional shared libraries = ./libsimple_nonlinear.so
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization, particles
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties,strain rate, spd factor
-    set Output format = gnuplot
-    set Time between graphical output = 2
-  end
-
-  subsection Particles
-    set Time between data output = 1
-    set Data output format = gnuplot
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial position, position
-  set Interpolation scheme = nearest neighbor
-  set Particle generator name = random uniform
-  set Minimum particles per cell = 2
-  set Maximum particles per cell = 2
-  set Load balancing strategy = remove and add particles
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 512
-    end
-  end
-end
diff --git a/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.cc.bak b/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.cc.bak
deleted file mode 100644
index b0c1b8e736e..00000000000
--- a/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.cc.bak
+++ /dev/null
@@ -1 +0,0 @@
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.prm.bak b/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.prm.bak
deleted file mode 100644
index 3911c7d64fc..00000000000
--- a/tests/nonlinear_channel_flow_tractions_dc_picard_Stokes_GMG.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-#Test GMG  iterated defect correction Stokes solver based on
-# benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
-
-include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/input_t.prm
-
-set Nonlinear solver scheme = single Advection, iterated defect correction Stokes
-set Max nonlinear iterations = 10
-
-subsection Material model
-  set Material averaging = harmonic average
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/tests/nonlinear_channel_flow_tractions_iterated_IMPES.cc.bak b/tests/nonlinear_channel_flow_tractions_iterated_IMPES.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_tractions_iterated_IMPES.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_tractions_iterated_IMPES.prm.bak b/tests/nonlinear_channel_flow_tractions_iterated_IMPES.prm.bak
deleted file mode 100644
index 11466407119..00000000000
--- a/tests/nonlinear_channel_flow_tractions_iterated_IMPES.prm.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set Maximum time step                      = 1
-set End time                               = 2
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = iterated Advection and Stokes
-set Max nonlinear iterations = 100
-set Nonlinear solver tolerance = 1e-10
-set Additional shared libraries = ../benchmarks/nonlinear_channel_flow/libsimple_nonlinear.so
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 3
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 5
-    set Maximum linear Stokes solver tolerance = 1e-1
-  end
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-10
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10e3
-    set Y extent = 8e3
-    set Y repetitions = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple nonlinear
-
-  subsection Simple nonlinear
-    set Minimum viscosity = 1e19
-    set Maximum viscosity = 1e24
-    set Stress exponent = 3
-    set Viscosity averaging p = 10000
-    set Viscosity prefactor = 1e-37
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 2 y: function, 3 y: function # pressure bc: Prescribe a horizontal traction on the vertical boundaries
-
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 0;if(z>0,0,1e9)
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1
-  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
-
-  subsection Function
-    set Function constants = n = 3
-    set Variable names = x,z
-
-    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
-    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
-
-  subsection Depth average
-    set List of output variables = viscosity
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties,strain rate
-    set Output format = gnuplot
-    set Time between graphical output = 2
-  end
-end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm.bak
deleted file mode 100644
index 1f2cea719ab..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set Maximum time step                      = 1
-set End time                               = 4
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = iterated Advection and Newton Stokes
-set Max nonlinear iterations = 30
-set Nonlinear solver tolerance = 5e-12
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 3
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 5
-    set Maximum linear Stokes solver tolerance = 1e-1
-  end
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Stokes solver type =  block AMG
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10e3
-    set Y extent = 8e3
-    set Y repetitions = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple nonlinear
-  set Material averaging = none
-
-  subsection Simple nonlinear
-    # Instead of the default of 1.96e-40, set the minimum
-    # strain rate to something closer to, but below,
-    # the actual minimum strain rate.
-    set Minimum strain rate = 1e-16
-    set Minimum viscosity = 1e19
-    set Maximum viscosity = 1e24
-    set Stress exponent = 3
-    set Viscosity averaging p = 10000
-    set Viscosity prefactor = 1e-37
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1
-
-  #  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
-  set Prescribed velocity boundary indicators = 2: function, 3: function # velocity bc
-
-  subsection Function
-    set Function constants = n = 3
-    set Variable names = x,z
-
-    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
-    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
-  end
-end
-
-subsection Boundary traction model
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 0;if(z>0,0,1e9)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
-
-  subsection Depth average
-    set List of output variables = viscosity
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties,strain rate, spd factor
-    set Output format = gnuplot
-    set Time between graphical output = 2
-  end
-end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.prm.bak
deleted file mode 100644
index e82fa5e93a8..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_GMG.prm.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
-
-set Nonlinear solver tolerance = 1e-11
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 31 #one more than max iterations
-    set Nonlinear Newton solver switch tolerance =  0
-  end
-
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1e-6
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
-end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.prm.bak
deleted file mode 100644
index b4dd337ec56..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
-
-set End time                               = 2
-set Max nonlinear iterations = 100
-set Nonlinear solver tolerance = 1.5e-9
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 100
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 0
-    set Maximum linear Stokes solver tolerance = 1e-1
-    set Use Eisenstat Walker method for Picard iterations = false
-  end
-end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.prm.bak
deleted file mode 100644
index 522f99740cf..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_derivative_EW.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
-
-set End time                               = 2
-set Max nonlinear iterations = 100
-set Nonlinear solver tolerance = 1e-9
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 100
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 0
-    set Maximum linear Stokes solver tolerance = 1e-1
-    set Use Eisenstat Walker method for Picard iterations = true
-  end
-end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.prm.bak
deleted file mode 100644
index 34791b88253..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_deviator.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
-
-set Nonlinear solver tolerance = 5e-12
-
-subsection Material model
-  set Model name = simple nonlinear
-
-  subsection Simple nonlinear
-    set Use deviator of strain-rate = false
-  end
-end
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.cc.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.prm.bak b/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.prm.bak
deleted file mode 100644
index c4e4c683525..00000000000
--- a/tests/nonlinear_channel_flow_velocities_Newton_Stokes_no_line_search.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
-
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max Newton line search iterations = 0
-  end
-end
diff --git a/tests/nonlinear_channel_flow_velocities_iterated_IMPES.cc.bak b/tests/nonlinear_channel_flow_velocities_iterated_IMPES.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_velocities_iterated_IMPES.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_iterated_IMPES.prm.bak b/tests/nonlinear_channel_flow_velocities_iterated_IMPES.prm.bak
deleted file mode 100644
index bc3c9910638..00000000000
--- a/tests/nonlinear_channel_flow_velocities_iterated_IMPES.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set Maximum time step                      = 1
-set End time                               = 2
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = iterated Advection and Stokes
-set Max nonlinear iterations = 100
-set Nonlinear solver tolerance = 1e-10
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 3
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 5
-    set Maximum linear Stokes solver tolerance = 1e-1
-  end
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10e3
-    set Y extent = 8e3
-    set Y repetitions = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple nonlinear
-
-  subsection Simple nonlinear
-    set Minimum viscosity = 1e19
-    set Maximum viscosity = 1e24
-    set Stress exponent = 3
-    set Viscosity averaging p = 10000
-    set Viscosity prefactor = 1e-37
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1
-
-  #  set Prescribed velocity boundary indicators = 2 x: function, 3 x: function # pressure bc: Prescribe a zero vertical velocity component on the vertical boundaries
-  set Prescribed velocity boundary indicators = 2: function, 3: function # velocity bc
-
-  subsection Function
-    set Function constants = n = 3
-    set Variable names = x,z
-
-    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
-    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-((x-(5e3))^(n+1)));
-  end
-end
-
-subsection Boundary traction model
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 0;if(z>0,0,1e9)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization #, depth average
-
-  subsection Depth average
-    set List of output variables = viscosity
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties,strain rate
-    set Output format = gnuplot
-    set Time between graphical output = 2
-  end
-end
diff --git a/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.cc.bak b/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.cc.bak
deleted file mode 100644
index 63ec7ca86d1..00000000000
--- a/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
diff --git a/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.prm.bak b/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.prm.bak
deleted file mode 100644
index fb7654faf27..00000000000
--- a/tests/nonlinear_channel_flow_velocities_single_advection_Newton_Stokes.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the solver scheme
-# 'single Advection, iterated Newton Stokes'
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/nonlinear_channel_flow_velocities_Newton_Stokes.prm
-
-set Nonlinear solver scheme = single Advection, iterated Newton Stokes
diff --git a/tests/nonlinear_convergence_for_small_composition.cc.bak b/tests/nonlinear_convergence_for_small_composition.cc.bak
deleted file mode 100644
index 05ef86afa08..00000000000
--- a/tests/nonlinear_convergence_for_small_composition.cc.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  template <int dim>
-  class TestMaterial:
-    public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            out.viscosities[i] = 1e19;
-            out.thermal_expansion_coefficients[i] = 1e-5;
-            out.specific_heat[i] = 1000.0;
-            out.thermal_conductivities[i] = 1.0;
-            out.compressibilities[i] = 0.0;
-            out.densities[i] = 30000.0*(1.0-1.e-5*in.temperature[i]);
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              {
-                if (in.requests_property(MaterialModel::MaterialProperties::reaction_terms))
-                  out.reaction_terms[i][c] = trace(in.strain_rate[i]) * this->get_timestep();
-                else
-                  out.reaction_terms[i][c] = 0.0;
-              }
-            out.entropy_derivative_pressure[i]    = 0.0;
-            out.entropy_derivative_temperature[i] = 0.0;
-
-          }
-      }
-  };
-}
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(TestMaterial,
-                                 "test material",
-                                 "")
-
-}
diff --git a/tests/nonlinear_convergence_for_small_composition.prm.bak b/tests/nonlinear_convergence_for_small_composition.prm.bak
deleted file mode 100644
index 3603032eb6d..00000000000
--- a/tests/nonlinear_convergence_for_small_composition.prm.bak
+++ /dev/null
@@ -1,162 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# This test demonstrates that the nonlinear solver can not converge
-# if the reaction term depends on the Stokes solution (in this case
-# the velocity divergence) and the right-hand side of the compositional
-# field advection equation is zero or very small otherwise, as long as
-# the Stokes solution still changes (the number of linear Stokes solver
-# iterations is not equal to zero).
-# As soon as the Stokes system is not solved any more, the nonlinear
-# residual drops to a very small number.
-
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 1.0
-set Maximum time step                      = 1e6
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 20
-set Nonlinear solver tolerance             = 5e-9
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Start time                             = 0
-set End time                               = 1e4
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.2
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 3700
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-
-  subsection Function
-    set Function constants  = b=100000, c=20000
-    set Variable names      = x,y
-    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2900000
-    set Y extent = 2900000
-    set X repetitions = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age bottom boundary layer = 5e8
-    set Age top boundary layer    = 3e8
-    set Amplitude                 = 50
-    set Position                  = center
-    set Radius                    = 500000
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-
-  subsection Harmonic perturbation
-    set Magnitude = 50
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,a = 0.0, b = 2500000, c = 100000, d=1450000
-    set Function expression = a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c)); a * exp(-((y-b)*(y-b)+(0.2*(x-d))*(0.2*(x-d)))/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = test material
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.8
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-
-  subsection Visualization
-    set List of output variables      = material properties
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-  end
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-14
-  set Temperature solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/nonlinear_solver_history.cc.bak b/tests/nonlinear_solver_history.cc.bak
deleted file mode 100644
index cdc772dd69d..00000000000
--- a/tests/nonlinear_solver_history.cc.bak
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_signals.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-
-namespace aspect
-{
-  template <int dim>
-  void post_nonlinear_solver (const SolverControl &nonlinear_solver_control)
-  {
-    const bool success = nonlinear_solver_control.last_check() == SolverControl::success;
-    std::cout << "\nnumber of nonlinear iterations: " << nonlinear_solver_control.last_step() << ". State: " << success << ".\n";
-  }
-
-
-  template <int dim>
-  void signal_connector (SimulatorSignals<dim> &signals)
-  {
-    std::cout << "Connecting signals" << std::endl;
-    signals.post_nonlinear_solver.connect (&post_nonlinear_solver<dim>);
-  }
-
-
-  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                    signal_connector<3>)
-}
diff --git a/tests/nonlinear_solver_history.prm.bak b/tests/nonlinear_solver_history.prm.bak
deleted file mode 100644
index 044b0c79458..00000000000
--- a/tests/nonlinear_solver_history.prm.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0.1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, Stokes residual
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/normalize_initial_composition.prm.bak b/tests/normalize_initial_composition.prm.bak
deleted file mode 100644
index 35e375fe773..00000000000
--- a/tests/normalize_initial_composition.prm.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-# This test ensures that the Simpler material model works
-# with compositional fields enabled
-
-set Dimension                              = 2
-set End time                               = 0
-
-subsection Compositional fields
-  set Number of fields          = 2
-  set List of normalized fields   =  0,1
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 1;1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent                = 1
-    set X repetitions           = 2
-    set Y extent                = 1
-    set Y repetitions           = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Material model
-  set Model name         = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
diff --git a/tests/normalize_pressure_volume.prm.bak b/tests/normalize_pressure_volume.prm.bak
deleted file mode 100644
index 26b67b24b54..00000000000
--- a/tests/normalize_pressure_volume.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-# test that pressure "volume" normalization works correctly.
-# note that the solution is kind of non-sensical..
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Pressure normalization                 = volume
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 2
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 3: function
-  set Zero velocity boundary indicators       = 0, 1
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = 0;x*(1-x)*z
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, visualization
-end
diff --git a/tests/nsinker.cc.bak b/tests/nsinker.cc.bak
deleted file mode 100644
index 3414e98ba87..00000000000
--- a/tests/nsinker.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/nsinker/nsinker.cc"
diff --git a/tests/nsinker.prm.bak b/tests/nsinker.prm.bak
deleted file mode 100644
index 33822b2a947..00000000000
--- a/tests/nsinker.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/benchmarks/nsinker/nsinker.prm
-
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 1
-end
diff --git a/tests/nsinker_2d.cc.bak b/tests/nsinker_2d.cc.bak
deleted file mode 100644
index 3414e98ba87..00000000000
--- a/tests/nsinker_2d.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/nsinker/nsinker.cc"
diff --git a/tests/nsinker_2d.prm.bak b/tests/nsinker_2d.prm.bak
deleted file mode 100644
index a0b79e17f9e..00000000000
--- a/tests/nsinker_2d.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-include $ASPECT_SOURCE_DIR/benchmarks/nsinker/nsinker_2d.prm
-
-set Dimension = 2
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 1
-end
diff --git a/tests/nsinker_bfbt.cc.bak b/tests/nsinker_bfbt.cc.bak
deleted file mode 100644
index 3414e98ba87..00000000000
--- a/tests/nsinker_bfbt.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/nsinker/nsinker.cc"
diff --git a/tests/nsinker_bfbt.prm.bak b/tests/nsinker_bfbt.prm.bak
deleted file mode 100644
index 33822b2a947..00000000000
--- a/tests/nsinker_bfbt.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/benchmarks/nsinker/nsinker.prm
-
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 1
-end
diff --git a/tests/nsinker_gmg_idr.cc.bak b/tests/nsinker_gmg_idr.cc.bak
deleted file mode 100644
index 3414e98ba87..00000000000
--- a/tests/nsinker_gmg_idr.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/nsinker/nsinker.cc"
diff --git a/tests/nsinker_gmg_idr.prm.bak b/tests/nsinker_gmg_idr.prm.bak
deleted file mode 100644
index 5f90a8060ae..00000000000
--- a/tests/nsinker_gmg_idr.prm.bak
+++ /dev/null
@@ -1,24 +0,0 @@
-# Nsinker benchmark using geometric multigrid preconditioner
-# with an IDR(2) solver
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/benchmarks/nsinker/nsinker_gmg.prm
-
-
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Krylov method for cheap solver steps = IDR(s)
-    set IDR(s) parameter = 2
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
diff --git a/tests/octagonal_initial_temperature.prm.bak b/tests/octagonal_initial_temperature.prm.bak
deleted file mode 100644
index 75f770da3db..00000000000
--- a/tests/octagonal_initial_temperature.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# Test the spherical "hexagonal" perturbation initial temperature model with
-# an eight-fold symmetry
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = .5
-    set Outer radius = 1
-    set Opening angle = 360
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-
-  subsection Spherical hexagonal perturbation
-    set Angular mode = 8
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Additional refinement times              =
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/octagonal_initial_temperature_ellipsoidal_chunk.prm.bak b/tests/octagonal_initial_temperature_ellipsoidal_chunk.prm.bak
deleted file mode 100644
index c15a220c014..00000000000
--- a/tests/octagonal_initial_temperature_ellipsoidal_chunk.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# Test the spherical "hexagonal" perturbation initial temperature model with
-# an eight-fold symmetry
-
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 2
-    set Outer temperature = 0
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = ellipsoidal chunk
-
-  subsection Ellipsoidal chunk
-    set NE corner = 5:30
-    set NW corner = 0:0
-    set SW corner = 10:-10
-    set Depth = 3000000
-    set Eccentricity = 0.
-    set East-West subdivisions = 1
-    set North-South subdivisions = 1
-    set Depth subdivisions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-
-  subsection Spherical hexagonal perturbation
-    set Angular mode = 8
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner
-  set Zero velocity boundary indicators       = outer
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/octagonal_initial_temperature_rotated.prm.bak b/tests/octagonal_initial_temperature_rotated.prm.bak
deleted file mode 100644
index 98b3678ed5a..00000000000
--- a/tests/octagonal_initial_temperature_rotated.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# Test the spherical "hexagonal" perturbation initial temperature model with
-# an eight-fold symmetry including a rotation angle
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1
-    set Outer temperature = 0
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = .5
-    set Outer radius = 1
-    set Opening angle = 360
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-
-  subsection Spherical hexagonal perturbation
-    set Angular mode = 8
-    set Rotation offset = -22.5
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Additional refinement times              =
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/onset_of_convection.prm.bak b/tests/onset_of_convection.prm.bak
deleted file mode 100644
index 6ebdfb44c3a..00000000000
--- a/tests/onset_of_convection.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-include $ASPECT_SOURCE_DIR/cookbooks/onset_of_convection/onset_of_convection.prm
-
-set Dimension = 2
-set End time = 0
diff --git a/tests/original_prm.prm.bak b/tests/original_prm.prm.bak
deleted file mode 100644
index a0fbb6f71be..00000000000
--- a/tests/original_prm.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-# test that output/original.prm is written correctly
-
-# based on no_flow.prm:
-include $ASPECT_SOURCE_DIR/tests/no_flow.prm
-
-
-# Note: the line above also checks that ASPECT_SOURCE_DIR is not being replaced
-
-# The reference output will contain an additional line with the output
-# directory below this line:
diff --git a/tests/original_prm/original.prm.bak b/tests/original_prm/original.prm.bak
deleted file mode 100644
index 701798a8f69..00000000000
--- a/tests/original_prm/original.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-# test that output/original.prm is written correctly
-
-# based on no_flow.prm:
-include $ASPECT_SOURCE_DIR/tests/no_flow.prm
-
-
-# Note: the line above also checks that ASPECT_SOURCE_DIR is not being replaced
-
-# The reference output will contain an additional line with the output
-# directory below this line:
-
-set Output directory = output-original_prm
-
diff --git a/tests/output_averaging_arithmetic.cc.bak b/tests/output_averaging_arithmetic.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/output_averaging_arithmetic.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/output_averaging_arithmetic.prm.bak b/tests/output_averaging_arithmetic.prm.bak
deleted file mode 100644
index e77b9085c63..00000000000
--- a/tests/output_averaging_arithmetic.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# Test that when we do material model averaging, that the material
-# model parameters such as the viscosity are also averaged when output
-# in graphical format. We want to do this because we want to visualize
-# what these parameters really are to the computational model, not
-# what they are in a pointwise sense before the computational model
-# gets to see them.
-#
-# This test uses the SolKz model, which has a viscosity that grows
-# exponentially in z-direction. The various output_averaging_*prm
-# files then simply apply different cellwise averaging options to
-# this viscosity.
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-  set Material averaging = arithmetic average
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format                 = gnuplot
-    set List of output variables      = viscosity
-    set Interpolate output            = false
-  end
-end
diff --git a/tests/output_averaging_harmonic.cc.bak b/tests/output_averaging_harmonic.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/output_averaging_harmonic.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/output_averaging_harmonic.prm.bak b/tests/output_averaging_harmonic.prm.bak
deleted file mode 100644
index 2112ba4d0e8..00000000000
--- a/tests/output_averaging_harmonic.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# Test that when we do material model averaging, that the material
-# model parameters such as the viscosity are also averaged when output
-# in graphical format. We want to do this because we want to visualize
-# what these parameters really are to the computational model, not
-# what they are in a pointwise sense before the computational model
-# gets to see them.
-#
-# This test uses the SolKz model, which has a viscosity that grows
-# exponentially in z-direction. The various output_averaging_*prm
-# files then simply apply different cellwise averaging options to
-# this viscosity.
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-  set Material averaging = harmonic average
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format                 = gnuplot
-    set List of output variables      = viscosity
-    set Interpolate output            = false
-  end
-end
diff --git a/tests/own_gravity.cc.bak b/tests/own_gravity.cc.bak
deleted file mode 100644
index af3950f828b..00000000000
--- a/tests/own_gravity.cc.bak
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-
-using namespace dealii;
-
-
-template <int dim>
-class MyGravity :
-  public aspect::GravityModel::Interface<dim>
-{
-  public:
-    virtual Tensor<1,dim> gravity_vector (const Point<dim> &position) const
-    {
-      Tensor<1,dim> ret;
-      ret[0] = position[1];
-      ret[1] = 42.0;
-      return ret;
-    }
-};
-
-
-// explicit instantiation
-ASPECT_REGISTER_GRAVITY_MODEL(MyGravity, "my gravity", "no description")
diff --git a/tests/own_gravity.prm.bak b/tests/own_gravity.prm.bak
deleted file mode 100644
index d0f833d0425..00000000000
--- a/tests/own_gravity.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# implement own gravity model, also test gravity visualization
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 2
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = my gravity
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Depth average
-    set Time between graphical output = 0
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-    set List of output variables = gravity
-  end
-end
diff --git a/tests/parallel_output_group_0.prm.bak b/tests/parallel_output_group_0.prm.bak
deleted file mode 100644
index c6037a74dcc..00000000000
--- a/tests/parallel_output_group_0.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# Test grouping of files in vtu output
-
-# MPI: 3
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1
-set Output directory                       = output
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer, left, right
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/tests/parallel_output_group_1.prm.bak b/tests/parallel_output_group_1.prm.bak
deleted file mode 100644
index 01fe1ac72ad..00000000000
--- a/tests/parallel_output_group_1.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# Test grouping of files in vtu output
-
-# MPI: 3
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1
-set Output directory                       = output
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer, left, right
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Number of grouped files       = 1
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/tests/parallel_output_group_2.prm.bak b/tests/parallel_output_group_2.prm.bak
deleted file mode 100644
index 59476211264..00000000000
--- a/tests/parallel_output_group_2.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# Test grouping of files in vtu output
-
-# MPI: 3
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1
-set Output directory                       = output
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer, left, right
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Number of grouped files       = 2
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/tests/parallel_refine_crash.prm.bak b/tests/parallel_refine_crash.prm.bak
deleted file mode 100644
index afb45a0e4ec..00000000000
--- a/tests/parallel_refine_crash.prm.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-# MPI: 4
-
-# Test case that showed two problems:
-#
-# 1. Parallel mesh smoothing would interfere with minimum refinement function
-# leading to missing refinement when run with few cells per processor.
-# 2. This leads to a crash with periodic constraints because of a hanging node.
-#
-# File shows the problem with 7 or more MPI ranks.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 1000
-set Maximum time step                      = 20000
-set Output directory                       = test_periodic
-set Pressure normalization                 = no #surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100e3
-    set Y extent = 150e3
-    set Z extent = 200e3
-    set X repetitions = 2
-    set Y repetitions = 3
-    set Z repetitions = 4
-    set Y periodic        = true
-  end
-end
-
-# We do not consider temperature in this setup
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = initial temperature
-end
-
-# X boundaries are periodic, and the rest are tangential.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0   # = Ra
-  end
-end
-
-# Dimensionless
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-# We also have to specify that we want to use the Boussinesq
-# approximation (assuming the density in the temperature
-# equation to be constant, and incompressibility).
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-# We set our global refinement at the resolution level we want at the surface. As of now,
-# FastScape initial resolution is determined based off this.
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 2
-  set Time steps between mesh refinement       = 0
-  set Refinement fraction = 0.5
-  set Strategy                                 =  minimum refinement function, maximum refinement function
-  set Run postprocessors on initial refinement            = true
-
-  subsection Maximum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y,z
-    set Function expression = if( z>=150.e3 , if( z>=160.e3, if( z>=170.e3, 4 , 3 ) , 2 ) , 1 )
-  end
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y,z
-    set Function expression = if( z>=150.e3 , if( z>=160.e3, if( z>=170.e3, 4 , 3 ) , 2 ) , 1 )
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set List of output variables      = strain rate, error indicator, partition
-    set Interpolate output = true
-  end
-end
diff --git a/tests/particle_count_statistics.cc.bak b/tests/particle_count_statistics.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/particle_count_statistics.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/particle_count_statistics.prm.bak b/tests/particle_count_statistics.prm.bak
deleted file mode 100644
index b4270531b50..00000000000
--- a/tests/particle_count_statistics.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# This test is based on sol_cx_particles and tests
-# the particle count statistics postprocessor that outputs
-# the minimum, average and maximum number of particles per cell
-# in the domain.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e2
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = particles, particle count statistics
-
-  subsection Depth average
-    set Time between graphical output = 100
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 100
-  end
-
-  subsection Particles
-    set Time between data output = 1
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1000
-    end
-  end
-end
diff --git a/tests/particle_exclude_all_properties.prm.bak b/tests/particle_exclude_all_properties.prm.bak
deleted file mode 100644
index bf9b2feb9e8..00000000000
--- a/tests/particle_exclude_all_properties.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-#########################################################
-# This is a variation of the composition-passive.prm
-# parameter file, with the exception that we also
-# advect along a set of particles and that we do not longer
-# compute temperature statistics and composition statistics
-# as part of postprocessing
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0 #0.1
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-passive-particles-explicit2-output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format       = gnuplot
-    set Exclude output properties = initial C_9,all
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 10
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 100
-    end
-  end
-end
diff --git a/tests/particle_exclude_one_property.prm.bak b/tests/particle_exclude_one_property.prm.bak
deleted file mode 100644
index ce3ab8714ea..00000000000
--- a/tests/particle_exclude_one_property.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-#########################################################
-# This is a variation of the composition-passive.prm
-# parameter file, with the exception that we also
-# advect along a set of particles and that we do not longer
-# compute temperature statistics and composition statistics
-# as part of postprocessing
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0 #0.1
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-passive-particles-explicit2-output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format       = gnuplot
-    set Exclude output properties = initial C_9
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 10
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 100
-    end
-  end
-end
diff --git a/tests/particle_exclude_one_property_vtu.prm.bak b/tests/particle_exclude_one_property_vtu.prm.bak
deleted file mode 100644
index 89189f41500..00000000000
--- a/tests/particle_exclude_one_property_vtu.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-#########################################################
-# This is a variation of the composition-passive.prm
-# parameter file, with the exception that we also
-# advect along a set of particles and that we do not longer
-# compute temperature statistics and composition statistics
-# as part of postprocessing
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0 #0.1
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-passive-particles-explicit2-output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format       = vtu
-    set Exclude output properties = initial C_9
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 10
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 100
-    end
-  end
-end
diff --git a/tests/particle_exclude_three_properties_vtu.prm.bak b/tests/particle_exclude_three_properties_vtu.prm.bak
deleted file mode 100644
index c144738f218..00000000000
--- a/tests/particle_exclude_three_properties_vtu.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-#########################################################
-# This is a variation of the composition-passive.prm
-# parameter file, with the exception that we also
-# advect along a set of particles and that we do not longer
-# compute temperature statistics and composition statistics
-# as part of postprocessing
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0 #0.1
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-passive-particles-explicit2-output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format       = vtu
-    set Exclude output properties = initial C_2, initial C_4, initial C_9
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 10
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 100
-    end
-  end
-end
diff --git a/tests/particle_exclude_two_properties_vtu.prm.bak b/tests/particle_exclude_two_properties_vtu.prm.bak
deleted file mode 100644
index 38373ef7bc2..00000000000
--- a/tests/particle_exclude_two_properties_vtu.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-#########################################################
-# This is a variation of the composition-passive.prm
-# parameter file, with the exception that we also
-# advect along a set of particles and that we do not longer
-# compute temperature statistics and composition statistics
-# as part of postprocessing
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0 #0.1
-set Use years in output instead of seconds = false
-set Output directory                       = output-composition-passive-particles-explicit2-output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format       = vtu
-    set Exclude output properties = initial C_2, initial C_9
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 10
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial position, initial composition, velocity # lpo, integrated strain invariant #function, initial composition, initial position, pT path
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 100
-    end
-  end
-end
diff --git a/tests/particle_fast_evaluate_many_compositions.prm.bak b/tests/particle_fast_evaluate_many_compositions.prm.bak
deleted file mode 100644
index 3134e3b543e..00000000000
--- a/tests/particle_fast_evaluate_many_compositions.prm.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-# A test based on Issue 4356: https://github.com/geodynamics/aspect/issues/4356
-# It tests that in models with multiple compositions the compositions
-# are correctly evaluated at the particle locations, even when using the
-# deal.II class FEPointEvaluation.
-
-set Adiabatic surface temperature          = 1623
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Dimension                              = 2
-set End time                               = 0
-set Pressure normalization                 = no
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 21
-  set Compositional field methods = static
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Initial temperature
-    set Maximal temperature = 3773
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = bottom, top
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-
-  subsection Function
-    set Function expression = 0;-1.65673998e-4
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 10
-    set Y extent  = 400
-    set Y repetitions = 40
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 2;4;6;8;10;12;14;16;18;20;22;24;26;28;30;32;34;36;38;40;42
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 2
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-end
-
-subsection Postprocess
-  set List of postprocessors = particles,visualization,composition statistics,velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Time between graphical output = 5e5
-  end
-
-  subsection Particles
-    set Time between data output      = 0
-    set Data output format            = gnuplot
-  end
-end
-
-subsection Particles
-  set List of particle properties   = composition
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles           = 10
-    end
-  end
-end
diff --git a/tests/particle_fast_evaluate_multiple_compositions.prm.bak b/tests/particle_fast_evaluate_multiple_compositions.prm.bak
deleted file mode 100644
index 6e445da7ecd..00000000000
--- a/tests/particle_fast_evaluate_multiple_compositions.prm.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-# A test based on Issue 4356: https://github.com/geodynamics/aspect/issues/4356
-# It tests that in models with multiple compositions the compositions
-# are correctly evaluated at the particle locations, even when using the
-# deal.II class FEPointEvaluation.
-
-set Adiabatic surface temperature          = 1623
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Dimension                              = 2
-set End time                               = 0
-set Pressure normalization                 = no
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = porosity,peridotite, 3
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Initial temperature
-    set Maximal temperature = 3773
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = bottom, top
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-
-  subsection Function
-    set Function expression = 0;-1.65673998e-4
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 10
-    set Y extent  = 400
-    set Y repetitions = 40
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 2;5;8
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 2
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-end
-
-subsection Postprocess
-  set List of postprocessors = particles,visualization,composition statistics,velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Time between graphical output = 5e5
-  end
-
-  subsection Particles
-    set Time between data output      = 0
-    set Data output format            = gnuplot
-  end
-end
-
-subsection Particles
-  set List of particle properties   = composition
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles           = 10
-    end
-  end
-end
diff --git a/tests/particle_free_surface.prm.bak b/tests/particle_free_surface.prm.bak
deleted file mode 100644
index 589a9343780..00000000000
--- a/tests/particle_free_surface.prm.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-# A test that checks particles combined with a free surface.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-set Pressure normalization                 = no
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = uniform box
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.3
-      set Maximum x = 0.5
-      set Minimum y = 0.1
-      set Maximum y = 0.3
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_generator_ascii.prm.bak b/tests/particle_generator_ascii.prm.bak
deleted file mode 100644
index 8ffb1d07070..00000000000
--- a/tests/particle_generator_ascii.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and therefore
-# tests the behavior of the particles.
-
-# MPI: 4
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Particle generator name = ascii file
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-  end
-end
diff --git a/tests/particle_generator_box.prm.bak b/tests/particle_generator_box.prm.bak
deleted file mode 100644
index 98dd82b843c..00000000000
--- a/tests/particle_generator_box.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and therefore
-# tests the behavior of the particles.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = uniform box
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.3
-      set Maximum x = 0.5
-      set Minimum y = 0.1
-      set Maximum y = 0.3
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_generator_box_3d.prm.bak b/tests/particle_generator_box_3d.prm.bak
deleted file mode 100644
index 5f301bfde21..00000000000
--- a/tests/particle_generator_box_3d.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# This is a modification of the van-keken-particle tests.
-# It tests the uniform box particle generator in 3d,
-# and the ascii particle output.
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 10
-set Use years in output instead of seconds = false
-set CFL number                             = 1.0
-set Timing output frequency                = 100
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set Z extent  = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, front, back
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Particle generator name = uniform box
-  set Integration scheme = euler
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.3
-      set Maximum x = 0.55
-      set Minimum y = 0.2
-      set Maximum y = 0.3
-      set Minimum z = 0.1
-      set Maximum z = 0.4
-      set Number of particles = 30
-    end
-  end
-end
diff --git a/tests/particle_generator_quadrature_points.prm.bak b/tests/particle_generator_quadrature_points.prm.bak
deleted file mode 100644
index d1b4a957c16..00000000000
--- a/tests/particle_generator_quadrature_points.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and therefore
-# tests the behavior of the particles.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0
-  set Refinement fraction                = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = quadrature points
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-  end
-end
diff --git a/tests/particle_generator_radial.prm.bak b/tests/particle_generator_radial.prm.bak
deleted file mode 100644
index c5089440b1e..00000000000
--- a/tests/particle_generator_radial.prm.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and therefore
-# tests the behavior of the particles.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Particle generator name = uniform radial
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Uniform radial
-      set Minimum radius = 0.05
-      set Maximum radius = 0.15
-      set Minimum longitude = 0.0
-      set Maximum longitude = 270.0
-      set Center x = 0.4
-      set Center y = 0.2
-      set Radial layers = 2
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_generator_random_uniform.prm.bak b/tests/particle_generator_random_uniform.prm.bak
deleted file mode 100644
index 7ad7b6f0f44..00000000000
--- a/tests/particle_generator_random_uniform.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This test is a copy of particle_generator_reference_cell and tests
-# the same model for the random uniform particle generator.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0
-  set Refinement fraction                = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Random cell selection = true
-      set Number of particles = 256
-    end
-  end
-end
diff --git a/tests/particle_generator_random_uniform_3mpi_1particle.prm.bak b/tests/particle_generator_random_uniform_3mpi_1particle.prm.bak
deleted file mode 100644
index 86364a4af97..00000000000
--- a/tests/particle_generator_random_uniform_3mpi_1particle.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This test is a copy of particle_generator_reference_cell and tests
-# the same model for the random uniform particle generator.
-
-# MPI: 3
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0
-  set Refinement fraction                = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Random cell selection = true
-      set Number of particles = 1
-    end
-  end
-end
diff --git a/tests/particle_generator_random_uniform_3mpi_2particle.prm.bak b/tests/particle_generator_random_uniform_3mpi_2particle.prm.bak
deleted file mode 100644
index b8be7bde0ea..00000000000
--- a/tests/particle_generator_random_uniform_3mpi_2particle.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This test is a copy of particle_generator_reference_cell and tests
-# the same model for the random uniform particle generator.
-
-# MPI: 3
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0
-  set Refinement fraction                = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Random cell selection = true
-      set Number of particles = 2
-    end
-  end
-end
diff --git a/tests/particle_generator_random_uniform_3mpi_3particle.prm.bak b/tests/particle_generator_random_uniform_3mpi_3particle.prm.bak
deleted file mode 100644
index 79281a87281..00000000000
--- a/tests/particle_generator_random_uniform_3mpi_3particle.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This test is a copy of particle_generator_reference_cell and tests
-# the same model for the random uniform particle generator.
-
-# MPI: 3
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0
-  set Refinement fraction                = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Random cell selection = true
-      set Number of particles = 3
-    end
-  end
-end
diff --git a/tests/particle_generator_random_uniform_3mpi_4particle.prm.bak b/tests/particle_generator_random_uniform_3mpi_4particle.prm.bak
deleted file mode 100644
index 5895a8b5cd2..00000000000
--- a/tests/particle_generator_random_uniform_3mpi_4particle.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This test is a copy of particle_generator_reference_cell and tests
-# the same model for the random uniform particle generator.
-
-# MPI: 3
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0
-  set Refinement fraction                = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Random cell selection = true
-      set Number of particles = 4
-    end
-  end
-end
diff --git a/tests/particle_generator_random_uniform_deterministic_cell.prm.bak b/tests/particle_generator_random_uniform_deterministic_cell.prm.bak
deleted file mode 100644
index 9d7b0a27b85..00000000000
--- a/tests/particle_generator_random_uniform_deterministic_cell.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# This test is a copy of particle_generator_random_uniform and tests
-# the same model, but with the number of particles per cell chosen
-# deterministically according to their particle density.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0
-  set Refinement fraction                = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Random cell selection = false
-      set Number of particles = 256
-    end
-  end
-end
diff --git a/tests/particle_generator_random_uniform_empty_rank.prm.bak b/tests/particle_generator_random_uniform_empty_rank.prm.bak
deleted file mode 100644
index 24f5c9372c3..00000000000
--- a/tests/particle_generator_random_uniform_empty_rank.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This test tests the random uniform particle generator if one
-# MPI rank has no cells.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0
-  set Refinement fraction                = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Random cell selection = false
-      set Number of particles = 1
-    end
-  end
-end
diff --git a/tests/particle_generator_reference_cell.prm.bak b/tests/particle_generator_reference_cell.prm.bak
deleted file mode 100644
index 20846eedcab..00000000000
--- a/tests/particle_generator_reference_cell.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and therefore
-# tests the behavior of the particles.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0
-  set Refinement fraction                = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = reference cell
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 4
-    end
-  end
-end
diff --git a/tests/particle_handler_copy.cc.bak b/tests/particle_handler_copy.cc.bak
deleted file mode 100644
index 86abc4a9c1b..00000000000
--- a/tests/particle_handler_copy.cc.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-  Copyright (C) 2020 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_signals.h>
-#include <aspect/particle/world.h>
-
-#include <deal.II/particles/particle_handler.h>
-
-#include <iostream>
-
-using namespace aspect;
-
-template <int dim>
-void duplicate_particle_handler(const SimulatorAccess<dim> &simulator_access,
-                                const bool,
-                                const unsigned int,
-                                const SolverControl &)
-{
-  const auto &particle_world = simulator_access.get_particle_world(0);
-  dealii::Particles::ParticleHandler<dim> particle_handler;
-  std::cout << "duplicating particle handler" << std::endl;
-
-  particle_world.copy_particle_handler(particle_world.get_particle_handler(),
-                                       particle_handler);
-
-  auto copied_particle = particle_handler.begin();
-  for (const auto &particle: particle_world.get_particle_handler())
-    {
-      std::cout << "Original position: " << particle.get_location()
-                << ". Copied position: " << copied_particle->get_location() << std::endl;
-      std::cout << "Original properties: " << particle.get_properties()[0]
-                << ". Copied properties: " << copied_particle->get_properties()[0] << std::endl;
-      ++copied_particle;
-    }
-
-  particle_handler.begin()->get_properties()[0] = 3.14;
-
-  std::cout << "resetting changed particle handler" << std::endl;
-
-  auto &non_const_particle_handler = const_cast<dealii::Particles::ParticleHandler<dim> &>(particle_world.get_particle_handler());
-
-  particle_world.copy_particle_handler(particle_handler,
-                                       non_const_particle_handler);
-
-  copied_particle = particle_handler.begin();
-  for (const auto &particle: particle_world.get_particle_handler())
-    {
-      std::cout << "Original position: " << particle.get_location()
-                << ". Copied position: " << copied_particle->get_location() << std::endl;
-      std::cout << "Original properties: " << particle.get_properties()[0]
-                << ". Copied properties: " << copied_particle->get_properties()[0] << std::endl;
-      ++copied_particle;
-    }
-}
-
-
-template <int dim>
-void signal_connector (SimulatorSignals<dim> &signals)
-{
-  std::cout << "Connecting signals" << std::endl;
-  signals.post_advection_solver.connect (&duplicate_particle_handler<dim>);
-}
-
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/particle_handler_copy.prm.bak b/tests/particle_handler_copy.prm.bak
deleted file mode 100644
index 9f4a41f4754..00000000000
--- a/tests/particle_handler_copy.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# A test for the Particle::World::copy_particle_handler
-# function that copies the particle handler (and all contained
-# particles), modifies one of them, and then resets the
-# the particles every time the composition system is solved.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom, top
-  set Tangential velocity boundary indicators = left, right
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity
-  set Particle generator name = uniform box
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.3
-      set Maximum x = 0.5
-      set Minimum y = 0.1
-      set Maximum y = 0.3
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_initial_adaptive_output.prm.bak b/tests/particle_initial_adaptive_output.prm.bak
deleted file mode 100644
index befcbec15a6..00000000000
--- a/tests/particle_initial_adaptive_output.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# This tests the behavior of the particles postprocessor, when the
-# 'Run postprocessors on initial refinement option is set. We do not
-# want to advect the particles in this case, because we are solving the
-# first timestep multiple times.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Run postprocessors on initial refinement = true
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Particle generator name = uniform box
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.3
-      set Maximum x = 0.5
-      set Minimum y = 0.1
-      set Maximum y = 0.3
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_initial_adaptive_refinement.prm.bak b/tests/particle_initial_adaptive_refinement.prm.bak
deleted file mode 100644
index db6638ffa46..00000000000
--- a/tests/particle_initial_adaptive_refinement.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and therefore
-# tests the behavior of the particles.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set Particle generator name = uniform box
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.3
-      set Maximum x = 0.5
-      set Minimum y = 0.1
-      set Maximum y = 0.3
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_integrator_euler.prm.bak b/tests/particle_integrator_euler.prm.bak
deleted file mode 100644
index c22c0388f19..00000000000
--- a/tests/particle_integrator_euler.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and therefore
-# tests the behavior of the particles.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Integration scheme = euler
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_integrator_rk2_first_order_time.prm.bak b/tests/particle_integrator_rk2_first_order_time.prm.bak
deleted file mode 100644
index abadc067245..00000000000
--- a/tests/particle_integrator_rk2_first_order_time.prm.bak
+++ /dev/null
@@ -1,26 +0,0 @@
-# This test is like particle_integrator_euler.prm, but
-# tests the behavior of the particles when integrated using the RK2
-# integrator, and only using one velocity field.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-include $ASPECT_SOURCE_DIR/tests/particle_integrator_euler.prm
-
-
-subsection Postprocess
-  subsection Particles
-    set Data output format = gnuplot
-  end
-end
-
-subsection Particles
-  set Integration scheme = rk2
-
-  subsection Integrator
-    subsection RK2
-      set Higher order accurate in time = false
-    end
-  end
-end
diff --git a/tests/particle_integrator_rk4.prm.bak b/tests/particle_integrator_rk4.prm.bak
deleted file mode 100644
index ae322391790..00000000000
--- a/tests/particle_integrator_rk4.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and therefore
-# tests the behavior of the particles.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Integration scheme = rk4
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_interpolator_bilinear_3d.prm.bak b/tests/particle_interpolator_bilinear_3d.prm.bak
deleted file mode 100644
index 304532508db..00000000000
--- a/tests/particle_interpolator_bilinear_3d.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# This is a variation of the particle_interpolator_cell_average_2
-# test that includes a time varying solution with active particles.
-# In particular this test was introduced to check for the accuracy
-# of the bilinear_least_squares interpolator in 3D
-
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = .1
-set Use years in output instead of seconds = false
-set Output directory = output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top, front, back
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 1
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Data output format       = none
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Compositional field methods = particles
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = if(y<0.2*x, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-  set Interpolation scheme = bilinear least squares
-  set Update ghost particles   = true
-  set Particle generator name = reference cell
-
-  subsection Interpolator
-    subsection Bilinear least squares
-      set Use linear least squares limiter = true
-    end
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 2
-    end
-  end
-end
diff --git a/tests/particle_interpolator_bilinear_3d_add_particles.prm.bak b/tests/particle_interpolator_bilinear_3d_add_particles.prm.bak
deleted file mode 100644
index 1c299b419a3..00000000000
--- a/tests/particle_interpolator_bilinear_3d_add_particles.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-# This is a variation of the particle_interpolator_bilinear_3d test that tests
-# that the bilinear least squares interpolator can fall back on a nearest
-# neighbor interpolator if there are too few particles in a cell.
-
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = .1
-set Use years in output instead of seconds = false
-set Output directory = output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top, front, back
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 1
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Data output format       = vtu #none
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Compositional field methods = particles
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = if(y<0.2*x, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-  set Interpolation scheme = bilinear least squares
-  set Update ghost particles   = true
-  set Load balancing strategy = add particles, repartition
-  set Minimum particles per cell = 4
-  set Particle generator name = reference cell
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 1
-    end
-  end
-end
diff --git a/tests/particle_interpolator_bilinear_add_particles.cc.bak b/tests/particle_interpolator_bilinear_add_particles.cc.bak
deleted file mode 100644
index 003736a2955..00000000000
--- a/tests/particle_interpolator_bilinear_add_particles.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_bilinear_add_particles.prm.bak b/tests/particle_interpolator_bilinear_add_particles.prm.bak
deleted file mode 100644
index f127cb44a1a..00000000000
--- a/tests/particle_interpolator_bilinear_add_particles.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# A test based on the SolKz benchmark that ensures that additional particles
-# are added to the model during the computation with multiple properties on
-# the particles.
-
-set Additional shared libraries            = ./libsolkz_compositional_fields.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolKzCompositionalMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = density_comp, viscosity_comp
-  set Compositional field methods = particles, particles
-  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, SolKzPostprocessor
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = bilinear least squares
-  set Minimum particles per cell = 50
-  set Maximum particles per cell = 16384
-  set Load balancing strategy = remove and add particles
-  set Update ghost particles = true
-  set Particle generator name = reference cell
-
-  subsection Function
-    set Number of components = 2
-    set Variable names      = x, z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression =  -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 7
-    end
-  end
-
-  subsection Interpolator
-    subsection Bilinear least squares
-      set Use linear least squares limiter = true, true
-      set Use boundary extrapolation = true, true
-    end
-  end
-end
diff --git a/tests/particle_interpolator_bilinear_least_squares_solkz.cc.bak b/tests/particle_interpolator_bilinear_least_squares_solkz.cc.bak
deleted file mode 100644
index 003736a2955..00000000000
--- a/tests/particle_interpolator_bilinear_least_squares_solkz.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_bilinear_least_squares_solkz.prm.bak b/tests/particle_interpolator_bilinear_least_squares_solkz.prm.bak
deleted file mode 100644
index 691106d556b..00000000000
--- a/tests/particle_interpolator_bilinear_least_squares_solkz.prm.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-# A test based on the SolKz benchmark that performs bilinear
-# least squares interpolation from particle properties to
-# compositional fields that are flagged as 'particle' advected fields.
-
-set Additional shared libraries            = ./libparticle_interpolator_bilinear_least_squares_solkz.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolKzCompositionalMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = density_comp, viscosity_comp
-  set Compositional field methods = particles, particles
-  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, SolKzPostprocessor, composition statistics
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = bilinear least squares
-  set Maximum particles per cell = 16384
-  set Update ghost particles = true
-  set Particle generator name = reference cell
-
-  subsection Function
-    set Number of components = 2
-    set Variable names      = x, z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression =  -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 4
-    end
-  end
-
-  subsection Interpolator
-    subsection Bilinear least squares
-      set Use linear least squares limiter = true
-    end
-  end
-end
diff --git a/tests/particle_interpolator_bilinear_limiter.prm.bak b/tests/particle_interpolator_bilinear_limiter.prm.bak
deleted file mode 100644
index 5f2e9f7acdc..00000000000
--- a/tests/particle_interpolator_bilinear_limiter.prm.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-#########################################################
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Output directory                       = output
-set CFL number                             = 0.25
-set Maximum time step                      = 0.25
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom,top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities = 1, 2, 0
-    set Viscosities = 1, 1000, 0.001
-    set Viscosity averaging scheme = geometric
-    set Thermal expansivities = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, composition statistics, pressure statistics, material statistics, global statistics, particles
-
-  subsection Visualization
-    set Output format = none
-  end
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-# Here, we track compositional fields via active particle particles.
-# The initial composition assigned to the particles is 'mapped'
-# to the particles at each time step.  This property is accessed in
-# the material model through a compositional field (standard method)
-# whose values are interpolated from the particles.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = sphere, air
-  set Compositional field methods = particles, particles
-  set Mapped particle properties = sphere:initial sphere, air: initial air
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = r=0.123456789, xc=0.5, yc=0.6
-    set Function expression = if(sqrt((x-xc)*(x-xc)+(y-yc)*(y-yc)) < r, 1, 0) ; if (y>0.75,1,0)
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity, initial composition, initial position #, integrated strain
-  set Interpolation scheme = bilinear least squares
-  set Update ghost particles = true
-  set Particle generator name = reference cell
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 3
-    end
-  end
-
-  subsection Interpolator
-    subsection Bilinear least squares
-      set Use linear least squares limiter = true
-    end
-  end
-end
diff --git a/tests/particle_interpolator_cell_average.prm.bak b/tests/particle_interpolator_cell_average.prm.bak
deleted file mode 100644
index 113b72e48c7..00000000000
--- a/tests/particle_interpolator_cell_average.prm.bak
+++ /dev/null
@@ -1,125 +0,0 @@
-# A test that performs interpolation from particle properties to
-# compositional fields that are flagged as 'particle' advected
-# fields.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = advection_field, advection_particle, advection_particle2
-  set Compositional field methods = field, particles, particles
-  set Mapped particle properties = advection_particle2:velocity [1], advection_particle:function
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02));0.0;0.0
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 70
-  end
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity, function, initial composition
-  set Interpolation scheme = cell average
-  set Update ghost particles = true
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Variable names      = x,z
-      set Function expression = x*x*z
-      set Number of particles = 100000
-    end
-  end
-end
diff --git a/tests/particle_interpolator_cell_average_2.prm.bak b/tests/particle_interpolator_cell_average_2.prm.bak
deleted file mode 100644
index 20edea67973..00000000000
--- a/tests/particle_interpolator_cell_average_2.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-#########################################################
-# This is a variation of the composition-passive.prm
-# parameter file, with the exception that we also
-# advect along a set of particles that
-#
-# See the manual for more information about this setup.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.03
-set Use years in output instead of seconds = false
-set Output directory                       = output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics
-
-  subsection Particles
-    set Time between data output = 0.03
-    set Data output format       = none
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-  set Compositional field methods = particles
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-  set Update ghost particles   = true
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 20000
-    end
-  end
-end
diff --git a/tests/particle_interpolator_empty_cells.prm.bak b/tests/particle_interpolator_empty_cells.prm.bak
deleted file mode 100644
index 01749438db6..00000000000
--- a/tests/particle_interpolator_empty_cells.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# A test that makes sure the 'cell average' particle interpolator
-# does not crash when single cells do not contain particles.
-
-set Dimension                               = 2
-set End time                                = 7e9
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent    = 1000000.0
-    set Y extent    =  450000.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators     = top, bottom
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators         = left, right, bottom, top
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields  = c1
-  set Compositional field methods = particles
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = arithmetic average
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z,t
-    set Function expression = if(((450000-z)<=55e3),1,0)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z,t
-    set Function expression = min(1350/(85e3+15e3*sin(x/100e3))*(450000-z)+293,1350+293)
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                 = 5
-  set Initial adaptive refinement               = 3
-  set Run postprocessors on initial refinement  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = particles, particle count statistics
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 3
-end
-
-subsection Particles
-  set List of particle properties = initial composition, initial position
-  set Interpolation scheme = cell average
-  set Update ghost particles = true
-  set Particle generator name = random uniform
-  set Minimum particles per cell = 2
-  set Maximum particles per cell = 100
-  set Load balancing strategy = remove and add particles
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 2500
-    end
-  end
-end
diff --git a/tests/particle_interpolator_from_ghost_cells.prm.bak b/tests/particle_interpolator_from_ghost_cells.prm.bak
deleted file mode 100644
index ac709190437..00000000000
--- a/tests/particle_interpolator_from_ghost_cells.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# A test that makes sure the 'cell average' particle interpolator
-# also uses data from ghost particles to compute the averaged
-# properties in a cell without particles.
-
-# MPI: 2
-
-set Dimension                               = 2
-set End time                                = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent    = 1000000.0
-    set Y extent    =  450000.0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators     = top, bottom
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators         = left, right, bottom, top
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Compositional field methods = particles
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = arithmetic average
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z,t
-    set Function expression = if(((450000-z)<=225000),1,0)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z,t
-    set Function expression = 1613
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                 = 4
-  set Initial adaptive refinement               = 0
-  set Time steps between mesh refinement         = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = particles, particle count statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-    set List of output variables = particle count, partition
-  end
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-  set Particle generator name = random uniform
-  set Minimum particles per cell = 2
-  set Maximum particles per cell = 100
-  set Load balancing strategy = none
-  set Update ghost particles = true
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 400
-    end
-  end
-end
diff --git a/tests/particle_interpolator_harmonic_average_solkz.cc.bak b/tests/particle_interpolator_harmonic_average_solkz.cc.bak
deleted file mode 100644
index 003736a2955..00000000000
--- a/tests/particle_interpolator_harmonic_average_solkz.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_harmonic_average_solkz.prm.bak b/tests/particle_interpolator_harmonic_average_solkz.prm.bak
deleted file mode 100644
index 42e61829847..00000000000
--- a/tests/particle_interpolator_harmonic_average_solkz.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-# A test based on the SolKz benchmark that performs a cellwise
-# average using harmonic averaging from particle properties to
-# compositional fields that are flagged as 'particle' advected fields.
-
-# Note that since the test performs harmonic averaging, the density
-# values being averaged all have to be positive, which required a
-# modification of the original density from the benchmark. Therefore,
-# the error in pressure is large (since the pressure no longer
-# corresponds to the analytical solution).
-
-set Additional shared libraries            = ./libparticle_interpolator_harmonic_average_solkz.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolKzCompositionalMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = density_comp, viscosity_comp
-  set Compositional field methods = particles, particles
-  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
-end
-
-# The initial condition is adapted from the original solkz benchmark by adding a constant
-# value of 1 to keep all properties positive (which is necessary for harmonic averaging)
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression = 1 - sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, SolKzPostprocessor
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = harmonic average
-  set Maximum particles per cell = 4096
-  set Update ghost particles = true
-  set Particle generator name = reference cell
-
-  # The initial condition is adapted from the original solkz benchmark by adding a constant
-  # value of 1 to keep all properties positive (which is necessary for harmonic averaging)
-  subsection Function
-    set Number of components = 2
-    set Variable names      = x, z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression = 1 - sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 4
-    end
-  end
-end
diff --git a/tests/particle_interpolator_nearest_neighbor.prm.bak b/tests/particle_interpolator_nearest_neighbor.prm.bak
deleted file mode 100644
index bc0116c4279..00000000000
--- a/tests/particle_interpolator_nearest_neighbor.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-# A test that performs interpolation from particle properties to
-# compositional fields that are flagged as 'particle' advected
-# fields.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 30
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = advection_field, advection_particle, advection_particle2
-  set Compositional field methods = field, particles, particles
-  set Mapped particle properties = advection_particle:initial advection_particle, advection_particle2:initial advection_particle2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = if(z>(0.4+0.02*cos(pi*x/0.9142)),1,0);0.0;0.0
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Minimum refinement level           = 4
-  set Time steps between mesh refinement = 1
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.5
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1
-  end
-
-  subsection Particles
-    set Time between data output = 1
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-  set Interpolation scheme = nearest neighbor
-  set Update ghost particles = true
-  set Maximum particles per cell = 10
-  set Minimum particles per cell = 10
-  set Particle generator name = uniform box
-  set Load balancing strategy = add particles
-
-  subsection Generator
-    subsection Probability density function
-      set Variable names      = x,z
-      set Function expression = 1 #x*x*z
-    end
-
-    subsection Uniform box
-      set Number of particles = 1000
-    end
-  end
-end
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.cc.bak b/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.cc.bak
deleted file mode 100644
index 003736a2955..00000000000
--- a/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm.bak b/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm.bak
deleted file mode 100644
index a9d6687352b..00000000000
--- a/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-# A test based on the particle version of the SolKz benchmark that (1) tests to
-# ensure that additional particles are added to the model during the computation
-# with multiple properties on the particles and (2) tests to ensure that the
-# particle methodology when used with the Quadratic Least Squares Particle
-# Interpolation algorithm correctly computes the particle version of the Solkz
-# benchmark.
-
-set Additional shared libraries            = ./libparticle_interpolator_quadratic_add_particles.so
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = SolKzCompositionalMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-############### Parameters describing the temperature field
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-############### Parameters describing the discretization
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Use locally conservative discretization = false
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = density_comp, viscosity_comp
-  set Compositional field methods = particles, particles
-  set Mapped particle properties = density_comp:function[0], viscosity_comp:function[1]
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression = -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, SolKzPostprocessor
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = quadratic least squares
-  set Minimum particles per cell = 10
-  set Maximum particles per cell = 16384
-  set Load balancing strategy = remove and add particles
-  set Update ghost particles = false
-  set Particle generator name = reference cell
-
-  subsection Function
-    set Number of components = 2
-    set Variable names      = x, z
-    set Function constants  = pi=3.1415926, eta_b=1e6
-    set Function expression =  -1 * sin(2*z) * cos(3*pi*x); exp(log(eta_b)*z)
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 3
-    end
-  end
-
-  subsection Interpolator
-    subsection Quadratic least squares
-      set Use quadratic least squares limiter = false
-    end
-  end
-end
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_limiter.cc.bak b/tests/particle_interpolator_quadratic_least_squares_2d_limiter.cc.bak
deleted file mode 100644
index 003736a2955..00000000000
--- a/tests/particle_interpolator_quadratic_least_squares_2d_limiter.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/compositional_fields/solkz_compositional_fields.cc"
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_limiter.prm.bak b/tests/particle_interpolator_quadratic_least_squares_2d_limiter.prm.bak
deleted file mode 100644
index bba2dbce22c..00000000000
--- a/tests/particle_interpolator_quadratic_least_squares_2d_limiter.prm.bak
+++ /dev/null
@@ -1,28 +0,0 @@
-# A test based on the 2d version of the SolKz benchmark that (1) tests to
-# ensure that the particle methodology when used with the Quadratic Least
-# Squares Particle Interpolation algorithm correctly computes the particle
-# version of the Solkz benchmark and (2) tests that the Quadratic Least
-# Squares limiter is properly limiting, without disproportionately
-# affecting the accuracy of the interpolation algorithm.
-
-include $ASPECT_SOURCE_DIR/tests/particle_interpolator_quadratic_least_squares_2d_add_particles.prm
-
-set Additional shared libraries            = ./libparticle_interpolator_quadratic_least_squares_2d_limiter.so
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-end
-
-subsection Particles
-  set Update ghost particles = true
-  set Load balancing strategy = none
-  set Minimum particles per cell = 7
-
-  subsection Interpolator
-    subsection Quadratic least squares
-      set Use quadratic least squares limiter = true
-      set Use boundary extrapolation = true
-    end
-  end
-end
diff --git a/tests/particle_interpolator_quadratic_least_squares_2d_periodic.prm.bak b/tests/particle_interpolator_quadratic_least_squares_2d_periodic.prm.bak
deleted file mode 100644
index e04238d9dd2..00000000000
--- a/tests/particle_interpolator_quadratic_least_squares_2d_periodic.prm.bak
+++ /dev/null
@@ -1,41 +0,0 @@
-# A test for quadratic least squares interpolation with periodic boundaries
-
-# MPI: 2
-
-include $ASPECT_SOURCE_DIR/tests/particle_periodic_boundaries.prm
-
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Compositional fields
-  set Compositional field methods = particles
-  set Mapped particle properties = C_1:initial C_1
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles, composition statistics
-end
-
-subsection Particles
-  set Interpolation scheme = quadratic least squares
-  set Update ghost particles = true
-
-  subsection Interpolator
-    subsection Quadratic least squares
-      set Use quadratic least squares limiter = true
-    end
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10000
-    end
-  end
-end
diff --git a/tests/particle_interpolator_quadratic_least_squares_3d.prm.bak b/tests/particle_interpolator_quadratic_least_squares_3d.prm.bak
deleted file mode 100644
index 15ad8f14364..00000000000
--- a/tests/particle_interpolator_quadratic_least_squares_3d.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-# This is a variation of the particle_interpolator_bilinear_3d
-# test that includes a time varying solution with active particles.
-# In particular this test was introduced to check for the accuracy
-# of the quadratic_least_squares interpolator in 3D
-
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = .1
-set Use years in output instead of seconds = false
-set Output directory = temp_output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top, front, back
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 1
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Data output format       = none
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Compositional field methods = particles
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = if(y<0.2*x, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-  set Interpolation scheme = quadratic least squares
-  set Update ghost particles   = true
-  set Particle generator name = reference cell
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 3
-    end
-  end
-
-  subsection Interpolator
-    subsection Quadratic least squares
-      set Use quadratic least squares limiter = true
-      set Use boundary extrapolation = false
-    end
-  end
-end
diff --git a/tests/particle_interpolator_time_dependence.prm.bak b/tests/particle_interpolator_time_dependence.prm.bak
deleted file mode 100644
index d95e697b862..00000000000
--- a/tests/particle_interpolator_time_dependence.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This is a variation of the particle_interpolator_cell_average_2
-# test that includes a time varying solution with active particles.
-# In particular this test was introduced to check for the accuracy
-# of the interpolation in time-varying flow.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.015 # 1 for complete run
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = particles, velocity statistics, composition statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties
-    set Time between graphical output = 0
-  end
-
-  subsection Particles
-    set Time between data output = 0.03
-    set Data output format       = none
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Compositional field methods = particles
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2*x, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-  set Update ghost particles   = true
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 20000
-    end
-  end
-end
diff --git a/tests/particle_linear_accelerated_flow_rk2.prm.bak b/tests/particle_linear_accelerated_flow_rk2.prm.bak
deleted file mode 100644
index 120b1798cd4..00000000000
--- a/tests/particle_linear_accelerated_flow_rk2.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# This test prescribes a velocity field in x direction of the form:
-# vx = 0.1 + t, where t is time. Therefore the position of
-# the single particle in this test follows:
-# x(t) = 0.5*t^2 + 0.1 * t, which results to:
-# x(1) = 0.6, for a particle starting at x(0)=0
-# Because the position is a polynomial of second order, and we use
-# a second-order time-accurate integrator (rk2), the particle arrives
-# at the exact end position.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function expression = 0.1+t;0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 0
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, particles
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables      = partition
-  end
-
-  subsection Particles
-    set Time between data output = 1
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Particle generator name = uniform box
-  set Integration scheme = rk2
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.0
-      set Maximum x = 0.1
-      set Minimum y = 0.5
-      set Maximum y = 0.55
-      set Number of particles = 1
-    end
-  end
-end
diff --git a/tests/particle_load_balancing_none.prm.bak b/tests/particle_load_balancing_none.prm.bak
deleted file mode 100644
index 42bd0ffcf35..00000000000
--- a/tests/particle_load_balancing_none.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-# A test for the particle load balancing strategy 'none'.
-# No load balancing is performed and the resulting imbalance is
-# recorded by the 'load balance statistics' postprocessor.
-
-# MPI: 4
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 4
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 1
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-  set Run postprocessors on initial refinement = true
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, particle count statistics, load balance statistics
-
-  subsection Particles
-    set Time between data output = 100
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set Load balancing strategy = none
-  set Integration scheme = euler
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1000
-    end
-  end
-end
diff --git a/tests/particle_load_balancing_refinement.prm.bak b/tests/particle_load_balancing_refinement.prm.bak
deleted file mode 100644
index 5ada582d81d..00000000000
--- a/tests/particle_load_balancing_refinement.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-# A test for the 'particle distribution' refinement plugin.
-# The cell are refined based on the numbers of particles they
-# contain.
-
-set Dimension                              = 2
-set End time                               = 100
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = particle density
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 1
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 100
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Load balancing strategy = none
-  set Integration scheme = euler
-  set Particle generator name = probability density function
-
-  subsection Generator
-    subsection Probability density function
-      set Variable names      = x,z
-      set Function expression = x*x*z
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_load_balancing_refinement_02.prm.bak b/tests/particle_load_balancing_refinement_02.prm.bak
deleted file mode 100644
index 19679d80e72..00000000000
--- a/tests/particle_load_balancing_refinement_02.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-# A test for the 'particle distribution' refinement plugin.
-# The cell are refined based on the numbers of particles they
-# contain.
-
-set Dimension                              = 2
-set End time                               = 500
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = particle density
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 1
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 100
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Load balancing strategy = none
-  set Integration scheme = euler
-  set Particle generator name = probability density function
-
-  subsection Generator
-    subsection Probability density function
-      set Variable names      = x,z
-      set Function expression = x*x*z
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_load_balancing_removal.prm.bak b/tests/particle_load_balancing_removal.prm.bak
deleted file mode 100644
index 0878376e9a9..00000000000
--- a/tests/particle_load_balancing_removal.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-# A test for the particle load balancing strategy 'remove particles'.
-# As soon as too many particles live in a cell, a fraction of them
-# is discarded.
-
-set Dimension                              = 2
-set End time                               = 100
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 1
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 100
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Load balancing strategy = remove particles
-  set Maximum particles per cell = 10
-  set Integration scheme = euler
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 100
-    end
-  end
-end
diff --git a/tests/particle_load_balancing_removal_addition.prm.bak b/tests/particle_load_balancing_removal_addition.prm.bak
deleted file mode 100644
index 3ce8355a91a..00000000000
--- a/tests/particle_load_balancing_removal_addition.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-# A test for the particle load balancing strategy 'remove and add particles'.
-# As soon as too many particles live in a cell, a fraction of them
-# is discarded. If too few particles live in this cell a number of particles
-# is generated at random positions in this cell to reach a user-set minimum
-# number.
-
-set Dimension                              = 2
-set End time                               = 100
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 1
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 100
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Load balancing strategy = remove and add particles
-  set Maximum particles per cell = 10
-  set Minimum particles per cell = 5
-  set Integration scheme = euler
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 100
-    end
-  end
-end
diff --git a/tests/particle_load_balancing_removal_addition_properties.prm.bak b/tests/particle_load_balancing_removal_addition_properties.prm.bak
deleted file mode 100644
index 84caf69fc9b..00000000000
--- a/tests/particle_load_balancing_removal_addition_properties.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# A test for the particle load balancing strategy 'remove and add particles'.
-# This test is a copy of particle_load_balancing_removal_addition, except
-# that it additionally tests the generation and interpolation of
-# the properties of the newly generated particles.
-
-set Dimension                              = 2
-set End time                               = 500
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 1
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 500
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Load balancing strategy = remove and add particles
-  set List of particle properties = initial position, position
-  set Maximum particles per cell = 10
-  set Minimum particles per cell = 5
-  set Integration scheme = euler
-  set Update ghost particles = true
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 100
-    end
-  end
-end
diff --git a/tests/particle_load_balancing_repartition.prm.bak b/tests/particle_load_balancing_repartition.prm.bak
deleted file mode 100644
index 60b97add43d..00000000000
--- a/tests/particle_load_balancing_repartition.prm.bak
+++ /dev/null
@@ -1,19 +0,0 @@
-# A test for the particle load balancing strategy 'repartition'.
-#
-# The load is distributed according to a balanced weight defined
-# as: n_locally_owned_cells + particle_weight/1000 * n_locally_owned_particles.
-# This test uses the default particle weight.
-
-# MPI: 4
-
-include $ASPECT_SOURCE_DIR/tests/particle_load_balancing_none.prm
-
-set Dimension                              = 2
-
-subsection Postprocess
-end
-
-subsection Particles
-  set Load balancing strategy = repartition
-  set Particle weight = 10
-end
diff --git a/tests/particle_load_balancing_repartition_1000.prm.bak b/tests/particle_load_balancing_repartition_1000.prm.bak
deleted file mode 100644
index cceec166e6b..00000000000
--- a/tests/particle_load_balancing_repartition_1000.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-# A test for the particle load balancing strategy 'repartition'.
-#
-# The load is distributed according to a balanced weight defined
-# as: n_locally_owned_cells + particle_weight/1000 * n_locally_owned_particles.
-# This test uses a large particle weight to ensure a good particle distribution
-# at the cost of an imbalance in the cell distribution.
-
-# MPI: 4
-
-include $ASPECT_SOURCE_DIR/tests/particle_load_balancing_none.prm
-
-set Dimension                              = 2
-
-subsection Postprocess
-end
-
-subsection Particles
-  set Load balancing strategy = repartition
-  set Particle weight = 1000
-end
diff --git a/tests/particle_melt_advection.cc.bak b/tests/particle_melt_advection.cc.bak
deleted file mode 100644
index 41a9c23ffdf..00000000000
--- a/tests/particle_melt_advection.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "rising_melt_blob.cc"
diff --git a/tests/particle_melt_advection.prm.bak b/tests/particle_melt_advection.prm.bak
deleted file mode 100644
index 258ed8a649b..00000000000
--- a/tests/particle_melt_advection.prm.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-# This is a test for the melt particle functionality.
-# It is the same setup as in the rising_melt_blob test,
-# with added passive particles that move with the melt
-# velocity. The test checks if the particles are moving
-# correctly, and if they are correctly labelled with the
-# property 'melt presence' if the porosity is above a
-# threshold at their location.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 3000 # 20000
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 50
-set CFL number                             = 0.2
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.2
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Bottom temperature = 1600
-    set Top temperature    = 293
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = #2,3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-
-  subsection Function
-    set Function constants  = b=100000, c=20000
-    set Variable names      = x,y
-    set Function expression = 0.0; -0.024995 + 0.1 * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 200000
-    set Y extent = 100000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 1e6
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
-    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
-  end
-end
-
-subsection Material model
-  set Model name = melting rate
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating #, latent heat melt, shear heating
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, temperature statistics, depth average, particles
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Interpolate output            = true
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-
-  subsection Depth average
-    set Number of zones = 12
-    set Time between graphical output = 6e5
-  end
-
-  subsection Particles
-    set Time between data output      = 0
-    set Data output format            = ascii
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint = 1700
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
-
-subsection Particles
-  set Particle generator name       = reference cell
-  set List of particle properties   = melt particle
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 1
-    end
-  end
-end
diff --git a/tests/particle_output_gnuplot.prm.bak b/tests/particle_output_gnuplot.prm.bak
deleted file mode 100644
index a01d1e7b972..00000000000
--- a/tests/particle_output_gnuplot.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# A simple test that checks the gnuplot output option for particles in parallel
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = gnuplot
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_output_hdf5.prm.bak b/tests/particle_output_hdf5.prm.bak
deleted file mode 100644
index 373198fd6c0..00000000000
--- a/tests/particle_output_hdf5.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# A simple test that checks the hdf5 output option for particles in parallel
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = hdf5
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_output_multiple_formats.prm.bak b/tests/particle_output_multiple_formats.prm.bak
deleted file mode 100644
index 2a48a19db93..00000000000
--- a/tests/particle_output_multiple_formats.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-# A simple test that checks the possibility to write particle output in
-# multiple formats
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = gnuplot, vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_output_none.prm.bak b/tests/particle_output_none.prm.bak
deleted file mode 100644
index 847d7f8d6c7..00000000000
--- a/tests/particle_output_none.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This is a modification of the van-keken-particle tests.
-# It tests that the 'no output' particle output option works, i.e.
-# that no particle output is written, but the particles are generated and
-# advected. Since we can not test for not existing files the only test is
-# that no particle output file is mentioned in the screen output.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 10
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 30
-    end
-  end
-end
diff --git a/tests/particle_output_vtu.prm.bak b/tests/particle_output_vtu.prm.bak
deleted file mode 100644
index 9304b79c6ca..00000000000
--- a/tests/particle_output_vtu.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# A simple test that checks the compressed vtu output option for particles in parallel
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_output_vtu_group.prm.bak b/tests/particle_output_vtu_group.prm.bak
deleted file mode 100644
index da030887079..00000000000
--- a/tests/particle_output_vtu_group.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# A simple test that checks the vtu output option for particles in parallel
-# In particular in this test we test the ability to group output into a single
-# file using MPI I/O.
-#
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-    set Number of grouped files = 1
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_output_vtu_temp.prm.bak b/tests/particle_output_vtu_temp.prm.bak
deleted file mode 100644
index 11df7012a84..00000000000
--- a/tests/particle_output_vtu_temp.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# A simple test that checks the vtu output option for particles in parallel
-# In particular we here write to a temporary location first.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-    set Temporary output location = /tmp
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_periodic_boundaries.prm.bak b/tests/particle_periodic_boundaries.prm.bak
deleted file mode 100644
index 26f0cdc0ac1..00000000000
--- a/tests/particle_periodic_boundaries.prm.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file and makes the
-# x boundary periodic to test the particle handling at these boundaries
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set X extent   = 0.9142
-    set Y extent   = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net x translation
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_periodic_boundaries_dc.prm.bak b/tests/particle_periodic_boundaries_dc.prm.bak
deleted file mode 100644
index 2d3b4db6be2..00000000000
--- a/tests/particle_periodic_boundaries_dc.prm.bak
+++ /dev/null
@@ -1,35 +0,0 @@
-# A test for periodic boundary conditions with particles
-
-# MPI: 2
-
-include $ASPECT_SOURCE_DIR/tests/particle_periodic_boundaries.prm
-
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Compositional fields
-  set Compositional field methods = particles
-  set Mapped particle properties = C_1:initial C_1
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Strategy                           = composition
-  set Initial global refinement          = 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles, composition statistics
-end
-
-subsection Particles
-  set Interpolation scheme = bilinear least squares
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10000
-    end
-  end
-end
diff --git a/tests/particle_periodic_boundaries_rk4.prm.bak b/tests/particle_periodic_boundaries_rk4.prm.bak
deleted file mode 100644
index 6e5c2de2ea2..00000000000
--- a/tests/particle_periodic_boundaries_rk4.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-# A description of the van Keken et al. benchmark.
-# This test adds particles to the cookbook parameter file and makes the
-# x boundary periodic to test the particle handling at these boundaries,
-# in particular for the RK4 velocity integration scheme.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 200
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set X extent   = 0.9142
-    set Y extent   = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net x translation
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 200
-    set Data output format = gnuplot
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_periodic_quarter_shell.prm.bak b/tests/particle_periodic_quarter_shell.prm.bak
deleted file mode 100644
index e4822ac7e94..00000000000
--- a/tests/particle_periodic_quarter_shell.prm.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-# This test adapts tests/particle_periodic_boundaries.prm to test the particle
-# handling at periodic boundaries in the polar direction for a quarter
-# spherical shell geometry.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 5
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3.481
-    set Outer radius = 6.336
-    set Phi periodic = true
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net x translation
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = r, phi
-    set Function constants  = pi=3.1415926
-    set Coordinate system = spherical
-    set Function expression = if( r < 4.195 + (0.3*sin(3*phi)) + (0.3*cos(3*phi)), 1, 0)
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles, visualization
-
-  subsection Particles
-    set Time between data output = 5
-    set Data output format = gnuplot
-  end
-end
-
-subsection Particles
-  set Integration scheme = euler
-  set Particle generator name = probability density function
-  set List of particle properties = function, initial composition, initial position
-
-  subsection Generator
-    subsection Probability density function
-      set Function expression = (y < 0.1) ? 1.0 : ((x < 0.1) ? 1.0 : 0.0)
-      set Number of particles = 50
-    end
-  end
-end
diff --git a/tests/particle_periodic_quarter_shell_2.prm.bak b/tests/particle_periodic_quarter_shell_2.prm.bak
deleted file mode 100644
index dc9385257ad..00000000000
--- a/tests/particle_periodic_quarter_shell_2.prm.bak
+++ /dev/null
@@ -1,122 +0,0 @@
-# This test adapts tests/particle_periodic_quarter_shell.prm to test the particle
-# handling at periodic boundaries in the polar direction for a quarter
-# spherical shell geometry.
-# The velocity and the initial particle locations are prescribed so that we know
-# where particles should end up. The time step size is precribed in such a way
-# that particles at the outer boundary should move exactly half of a cell in
-# angular direction in each time step, and particles at the inner boundary move
-# exactly a quarter of a cell in angular direction in each time step.
-# (There are 96 cells in longitudinal direction.)
-
-set Dimension                              = 2
-set End time                               = 0.032725
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, no Stokes
-set Maximum time step                      = 0.00818125
-
-# We prescibe rotating flow with an angular velocity increase with radius
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Function expression = -y * sqrt(x*x+y*y); x * sqrt(x*x+y*y)
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 0.5
-    set Outer radius = 1
-    set Phi periodic = true
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1000
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = r, phi
-    set Function constants  = pi=3.1415926
-    set Coordinate system = spherical
-    set Function expression = if( r < 4.195 + (0.3*sin(3*phi)) + (0.3*cos(3*phi)), 1, 0)
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particle count statistics, particles, visualization
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = gnuplot
-  end
-end
-
-subsection Particles
-  set Particle generator name = uniform radial
-  set List of particle properties = function, position, reference position, initial position
-  set Integration scheme = rk2
-
-  subsection Generator
-    subsection Uniform radial
-      set Maximum latitude = 180
-      set Maximum longitude = 89.999
-      set Maximum radius = 0.9999
-      set Minimum latitude = 0.
-      set Minimum longitude = 89
-      set Minimum radius = 0.5001
-      set Radial layers = 10
-      set Number of particles = 50
-    end
-  end
-end
diff --git a/tests/particle_property_composition.cc.bak b/tests/particle_property_composition.cc.bak
deleted file mode 100644
index 069053c7cd3..00000000000
--- a/tests/particle_property_composition.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solitary_wave/solitary_wave.cc"
diff --git a/tests/particle_property_composition.prm.bak b/tests/particle_property_composition.prm.bak
deleted file mode 100644
index db45740c57d..00000000000
--- a/tests/particle_property_composition.prm.bak
+++ /dev/null
@@ -1,188 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Uses the solitary wave benchmark to demonstrate the particle property melt particle,
-# which records the presence of melt over the melt transport threshold
-
-set Additional shared libraries            = ./libsolitary_wave.so
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = particle_property_composition
-set Max nonlinear iterations               = 10
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.001
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity,peridotite
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-# we apply the phase speed of the wave here, so that it always stays in the same place in our model
-# the phase speed is c = 5.25e-11 m/s, but we have to convert it to m/years using the same conversion
-# that is used internally in ASPECT: year_in_seconds = 60*60*24*365.2425
-
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    #    set Function expression = 0;-8.2836999e-5
-    set Function expression = 0;-1.65673998e-4
-
-    #    set Function expression = 0;-3.31347996e-4
-    #    set Function expression = 0;-6.62695992e-4
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 10
-    set Y extent  = 400
-    set Y repetitions = 40
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Initial composition model
-  set Model name = Solitary wave initial condition
-
-  subsection Solitary wave initial condition
-    set Offset = 200
-    set Read solution from file = false
-    set Amplitude = 0.01
-    set Background porosity = 0.001
-  end
-end
-
-subsection Material model
-  set Model name = Solitary Wave
-
-  subsection Solitary wave
-    set Reference permeability = 5e-9
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 2
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = particles,visualization,composition statistics,velocity statistics,solitary wave statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = gnuplot
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 5e5
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-
-  subsection Particles
-    set Time between data output      = 0
-  end
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-14
-  set Temperature solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-10
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Particles
-  set Particle generator name       = ascii file
-  set List of particle properties   = composition
-
-  subsection Generator
-    subsection Ascii file
-      set Data file name            = particle_property_composition.txt
-    end
-  end
-end
diff --git a/tests/particle_property_function.prm.bak b/tests/particle_property_function.prm.bak
deleted file mode 100644
index eca0a29a958..00000000000
--- a/tests/particle_property_function.prm.bak
+++ /dev/null
@@ -1,113 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and specifically tests
-# the probability density function generator.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity,function, initial composition, initial position
-  set Particle generator name = probability density function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Variable names      = x,z
-      set Function expression = x*x*z
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_property_initial_composition.prm.bak b/tests/particle_property_initial_composition.prm.bak
deleted file mode 100644
index 29c45a5e97e..00000000000
--- a/tests/particle_property_initial_composition.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and specifically tests
-# the particle property initial composition and its naming scheme
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields  = anomaly
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial composition
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_property_initial_composition_boundary.prm.bak b/tests/particle_property_initial_composition_boundary.prm.bak
deleted file mode 100644
index 6426861d1b3..00000000000
--- a/tests/particle_property_initial_composition_boundary.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-# This is an extension of the particle_property_initial_composition test that
-# sets a boundary condition for the composition. Additional particles with the
-# initial composition property that are generated at this boundary are now
-# initialized with this boundary value, instead of the interpolated value of
-# other particles in that cell.
-
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom, top
-  set Tangential velocity boundary indicators = left, right
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields  = anomaly
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = left, bottom
-  set List of model names = box
-
-  subsection Box
-    set Left composition = -1.0
-    set Bottom composition = 3.0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = gnuplot
-  end
-end
-
-subsection Particles
-  set Particle generator name = reference cell
-  set List of particle properties = initial composition
-  set Load balancing strategy = add particles
-  set Minimum particles per cell = 40
-
-  subsection Generator
-  end
-end
diff --git a/tests/particle_property_integrated_strain_invariant.prm.bak b/tests/particle_property_integrated_strain_invariant.prm.bak
deleted file mode 100644
index 3afb9c1e3b5..00000000000
--- a/tests/particle_property_integrated_strain_invariant.prm.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 10
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = particle_property_integrated_strain_invariant
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 1
-    set Data output format = ascii
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain invariant
-  set Particle generator name = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 100
-    end
-  end
-end
diff --git a/tests/particle_property_integrated_strain_pure_shear.prm.bak b/tests/particle_property_integrated_strain_pure_shear.prm.bak
deleted file mode 100644
index 0785b14ce83..00000000000
--- a/tests/particle_property_integrated_strain_pure_shear.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# This model tests the particle property integrated strain in a pure shear deformation.
-# Particles at the bottom left experience only deformation and no rotation (perfect pure
-# shear), while particles at the upper right corner only experience solid body rotation
-# and no deformation.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left,bottom
-  set Prescribed velocity boundary indicators = top:function, right:function
-
-  subsection Function
-    set Function expression = 1-y; x-1
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 1.0
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain
-  set Particle generator name = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_property_integrated_strain_simple_shear.prm.bak b/tests/particle_property_integrated_strain_simple_shear.prm.bak
deleted file mode 100644
index a478e50f2db..00000000000
--- a/tests/particle_property_integrated_strain_simple_shear.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# This model tests the particle property integrated strain in a simple shear deformation.
-# All particles in the domain experience the same velocity gradients that lead to a combined
-# rotation and deformation.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 1
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set X periodic = true
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-
-  subsection Function
-    set Function expression = if (y < 0.5, -1, 1); 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles
-
-  subsection Particles
-    set Time between data output = 1
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain
-  set Particle generator name = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_property_multiple_functions.prm.bak b/tests/particle_property_multiple_functions.prm.bak
deleted file mode 100644
index 96ec0638246..00000000000
--- a/tests/particle_property_multiple_functions.prm.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file with two particle properties
-# defined by two different functions. One is a discontinuous function and the other
-# is a smooth function.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity, function, initial composition, initial position
-  set Particle generator name = probability density function
-
-  subsection Function
-    set Number of components = 2
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 ); 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Variable names      = x,z
-      set Function expression = x*x*z
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_property_multiple_functions_with_interpolation.prm.bak b/tests/particle_property_multiple_functions_with_interpolation.prm.bak
deleted file mode 100644
index 7ca7edd0853..00000000000
--- a/tests/particle_property_multiple_functions_with_interpolation.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds active particles to the cookbook parameter file,
-# and interpolates two particle properties defined by two functions
-# onto two compositional fields.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = advection_field, advection_particle, advection_particle2
-  set Compositional field methods = field, particles, particles
-  set Mapped particle properties = advection_particle:function [0], advection_particle2:function [1]
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02));0.0;0.0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = velocity, function, initial composition
-  set Update ghost particles = true
-  set Particle generator name = random uniform
-
-  subsection Function
-    set Number of components = 2
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 ); 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Variable names      = x,z
-      set Function expression = x*x*z
-      set Number of particles = 1024
-    end
-  end
-end
diff --git a/tests/particle_property_post_initialize_function.cc.bak b/tests/particle_property_post_initialize_function.cc.bak
deleted file mode 100644
index d5c7d46c01e..00000000000
--- a/tests/particle_property_post_initialize_function.cc.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/simulator_access.h>
-#include <aspect/particle/property/interface.h>
-
-#include <iostream>
-
-unsigned int counter_without = 0, counter_with = 0;
-bool quiet = true;
-
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      template <int dim>
-      class PostInitializeParticleProperty : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-      {
-        public:
-
-          virtual
-          void
-          initialize ()
-          {
-            std::cout << "initialize" << std::endl;
-            const Particle::Property::Manager<dim> &manager = this->get_particle_world(this->get_particle_world_index()).get_property_manager();
-            post_initialized_info = manager.get_data_info().get_field_index_by_name("initial position");
-            std::cout << "initial position: post_initialized_info = " << post_initialized_info << std::endl;
-
-            post_initialized_info = manager.get_data_info().get_field_index_by_name("initial C_1");
-            std::cout << "initial composition C_1: post_initialized_info = " << post_initialized_info << std::endl;
-
-            post_initialized_info = manager.get_data_info().get_field_index_by_name("velocity");
-            std::cout << "velocity: post_initialized_info = " << post_initialized_info << std::endl;
-            exit(0);
-          }
-
-          virtual
-          std::vector<std::pair<std::string, unsigned int>>
-          get_property_information() const
-          {
-            return std::vector<std::pair<std::string, unsigned int>>();
-          }
-
-        private:
-          unsigned int post_initialized_info;
-
-      };
-    }
-  }
-}
-
-
-namespace aspect
-{
-  namespace Particle
-  {
-    namespace Property
-    {
-      ASPECT_REGISTER_PARTICLE_PROPERTY(PostInitializeParticleProperty,
-                                        "PostInitializeParticleProperty",
-                                        "")
-    }
-  }
-}
diff --git a/tests/particle_property_post_initialize_function.prm.bak b/tests/particle_property_post_initialize_function.prm.bak
deleted file mode 100644
index 041646d981c..00000000000
--- a/tests/particle_property_post_initialize_function.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-#########################################################
-# This is a variation of the particle_exclude_three_properties_vtu.prm
-# parameter file.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-
-  subsection Particles
-    set Time between data output = 0.1
-    set Data output format       = vtu
-    set Exclude output properties = initial C_2, initial C_9
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 10
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.1; 0.2; 0.3 ; 0.4; 0.5;0.6;0.7;0.8;0.9;0.95
-  end
-end
-
-subsection Particles
-  set List of particle properties = initial position, initial composition, PostInitializeParticleProperty, velocity
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles        = 100
-    end
-  end
-end
diff --git a/tests/particle_timing_information.prm.bak b/tests/particle_timing_information.prm.bak
deleted file mode 100644
index 63decad61d4..00000000000
--- a/tests/particle_timing_information.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This tests the behavior of the particles postprocessor, when the
-# 'Run postprocessors on initial refinement option is set. We do not
-# want to advect the particles in this case, because we are solving the
-# first timestep multiple times.
-
-# MPI: 2
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Run postprocessors on initial refinement = true
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = ascii
-  end
-end
-
-subsection Particles
-  set Particle generator name = uniform box
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.3
-      set Maximum x = 0.5
-      set Minimum y = 0.1
-      set Maximum y = 0.3
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/particle_visualization_particle_count.prm.bak b/tests/particle_visualization_particle_count.prm.bak
deleted file mode 100644
index de616e01b41..00000000000
--- a/tests/particle_visualization_particle_count.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# This is a copy of the particle_property_function test, but instead of the
-# function property it tests the 'particle count' visualization plugin that
-# outputs the number of particles per cell.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 70
-    set Output format = gnuplot
-    set List of output variables = particle count
-  end
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set Particle generator name = probability density function
-
-  subsection Generator
-    subsection Probability density function
-      set Variable names      = x,z
-      set Function expression = x*x*z
-      set Number of particles = 30
-    end
-  end
-end
diff --git a/tests/particles_with_AMR_on.prm.bak b/tests/particles_with_AMR_on.prm.bak
deleted file mode 100644
index d2dc06ca5ee..00000000000
--- a/tests/particles_with_AMR_on.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# A description of the falling box benchmark see the reference:
-# Gerya, T. V., Yuen, D. A., 2003a. Characteristics-based marker-in-cell method
-# with conservative finite-differences schemes for modeling geological flows with
-# strongly variable transport properties
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 5e5
-set Use years in output instead of seconds = true
-set CFL number                             = 1
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500e3
-    set Y extent  = 500e3
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# Thermal expansion coeff = 0 --> no temperature dependence
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3200
-    set Viscosity                     = 1e21
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = 100  # 3300 kg/m^3
-    set Composition viscosity prefactor = 1  # ONLY PARAMETER THAT CHANGES IN THESE TESTS
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = composition
-  set Compositional field methods = particles
-  set Mapped particle properties = composition:function
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(((x>187.5e3)&&(x<312.5e3)&&(z>312.5e3)&&(z<437.5e3)), 1, 0)
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Strategy                           = composition approximate gradient
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 1
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-  set Normalize individual refinement criteria = true
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Discretization
-  set Use discontinuous composition discretization = true
-end
-
-subsection Postprocess
-  set List of postprocessors = particles, velocity statistics, composition statistics
-
-  subsection Particles
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set Load balancing strategy = remove and add particles
-  set Minimum particles per cell = 9
-  set Maximum particles per cell = 36
-  set List of particle properties = function
-  set Integration scheme = rk2
-  set Interpolation scheme = cell average
-  set Update ghost particles = true
-  set Particle generator name = reference cell
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(((x>187.5e3)&&(x<312.5e3)&&(z>312.5e3)&&(z<437.5e3)), 1, 0)
-  end
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 8
-    end
-  end
-end
diff --git a/tests/passive_comp.prm.bak b/tests/passive_comp.prm.bak
deleted file mode 100644
index 7b813db72d0..00000000000
--- a/tests/passive_comp.prm.bak
+++ /dev/null
@@ -1,280 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# In computations, the time step $k$ is chosen according to $k = c \min_K
-# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
-# and the denominator is the maximal magnitude of the velocity on cell $K$
-# times the polynomial degree $p_T$ of the temperature discretization. The
-# dimensionless constant $c$ is called the CFL number in this program. For
-# time discretizations that have explicit components, $c$ must be less than a
-# constant that depends on the details of the time discretization and that is
-# no larger than one. On the other hand, for implicit discretizations such as
-# the one chosen here, one can choose the time step as large as one wants (in
-# particular, one can choose $c>1$) though a CFL number significantly larger
-# than one will yield rather diffusive solutions. Units: None.
-set CFL number                             = 1.0
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 8e12
-
-# The name of the directory into which all output files should be placed. This
-# may be an absolute or a relative path.
-
-# A flag indicating whether the computation should be resumed from a
-# previously saved state (if true) or start from scratch (if false).
-set Resume computation                     = false
-
-# The start time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set Start time                             = 0
-
-# When computing results for mantle convection simulations, it is often
-# difficult to judge the order of magnitude of results when they are stated in
-# MKS units involving seconds. Rather, some kinds of results such as
-# velocities are often stated in terms of meters per year (or, sometimes,
-# centimeters per year). On the other hand, for non-dimensional computations,
-# one wants results in their natural unit system as used inside the code. If
-# this flag is set to 'true' conversion to years happens; if it is 'false', no
-# such conversion happens.
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-
-  # A comma separated list of integers denoting those boundaries on which the
-  # temperature is fixed and described by the boundary temperature object
-  # selected in its own section of this input file. All boundary indicators
-  # used by the geometry but not explicitly listed here will end up with
-  # no-flux (insulating) boundary conditions.
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    # Temperature at the inner boundary (core mantle boundary). Units: K.
-    set Inner temperature = 0
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: K.
-    set Outer temperature = 0
-  end
-end
-
-subsection Discretization
-  # The polynomial degree to use for the velocity variables in the Stokes
-  # system. Units: None.
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-
-  # The polynomial degree to use for the composition variable(s). Units: None.
-  set Composition polynomial degree           = 2
-
-  # Whether to use a Stokes discretization that is locally conservative at the
-  # expense of a larger number of degrees of freedom (true), or to go with a
-  # cheaper discretization that does not locally conserve mass, although it is
-  # globally conservative (false).
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.11
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set List of normalized fields =
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    # Inner radius of the spherical shell. Units: \\si{\\meter}.
-    set Inner radius  = 3481000
-
-    # Opening angle in degrees of the section of the shell that we want to
-    # build. Units: degrees.
-    set Opening angle = 360
-
-    # Outer radius of the spherical shell. Units: \\si{\\meter}.
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-
-  subsection Radial constant
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-
-  subsection Spherical gaussian perturbation
-    # The amplitude of the perturbation.
-    set Amplitude             = 0.00
-
-    # The angle where the center of the perturbation is placed.
-    set Angle                 = 0e0
-
-    # The non-dimensional radial distance where the center of the perturbation
-    # is placed.
-    set Non-dimensional depth = 0.7
-
-    # The standard deviation of the Gaussian perturbation.
-    set Sigma                 = 0.2
-
-    # The sign of the perturbation.
-    set Sign                  = 1
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = if(x > 0,0,1)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    # Reference density $\rho_0$. Units: \\si{\\kilogram\\per\\meter\\cubed}.
-    set Reference density             = 3300
-
-    # The reference temperature $T_0$. Units: \\si{\\kelvin}.
-    set Reference temperature         = 293
-
-    # The value of the thermal conductivity $k$. Units: \\si{\\watt\\per\\meter\\per\\kelvin}.
-    set Thermal conductivity          = 4.7#1e-6
-
-    # The value of the thermal expansion coefficient $\beta$. Units: \\si{\\per\\kelvin}.
-    set Thermal expansion coefficient = 4e-5
-
-    # The value of the constant viscosity. Units: \\si{\\pascal\\second}.
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  # A list of times so that if the end time of a time step is beyond this
-  # time, an additional round of mesh refinement is triggered. This is mostly
-  # useful to make sure we can get through the initial transient phase of a
-  # simulation on a relatively coarse mesh, and then refine again when we are
-  # in a time range that we are interested in and where we would like to use a
-  # finer mesh. Units: each element of the list has units years if the 'Use
-  # years in output instead of seconds' parameter is set; seconds otherwise.
-  set Additional refinement times        =
-
-  # The number of adaptive refinement steps performed after initial global
-  # refinement but while still within the first time step.
-  set Initial adaptive refinement        = 0
-
-  # The number of global refinement steps performed on the initial coarse
-  # mesh, before the problem is first solved there.
-  set Initial global refinement          = 3
-
-  # The fraction of cells with the largest error that should be flagged for
-  # refinement.
-  set Refinement fraction                = 0.0
-
-  # The fraction of cells with the smallest error that should be flagged for
-  # coarsening.
-  set Coarsening fraction                = 0.00
-
-  # The method used to determine which cells to refine and which to coarsen.
-  set Strategy                           = temperature
-
-  # The number of time steps after which the mesh is to be adapted again based
-  # on computed error indicators.
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1:function
-
-  subsection Function
-    # The name of the variables as they will be used in the function,
-    # separated by ','.
-    set Variable names      = x,y
-
-    # Any constant used inside the function which is not a variable name.
-    set Function constants  = pi=3.1415926
-
-    # Vector valued expression for the velocity; separate components by ';'
-    set Function expression = if(x>0,-1.e-14*sqrt(x*x+y*y)*sin(atan(y/x)),1.e-14*sqrt(x*x+y*y)*sin(atan(y/x))); if(x>0,1.e-14*sqrt(x*x+y*y)*cos(atan(y/x)),-1.e-14*sqrt(x*x+y*y)*cos(atan(y/x)))
-  end
-end
-
-subsection Postprocess
-  # A comma separated list of postprocessor objects that should be run at the
-  # end of each time step. Some of these postprocessors will declare their own
-  # parameters which may, for example, include that they will actually do
-  # something only every so many time steps or years. Alternatively, the text
-  # 'all' indicates that all available postprocessors should be run after each
-  # time step.
-  #
-  # The following postprocessors are available:
-  #
-  # `visualization':
-  # A postprocessor that takes the solution and writes it into files that can
-  # be read by a graphical visualization program. Additional run time
-  # parameters are read from the parameter subsection
-  # 'Visualization'.
-  #
-  # `velocity statistics': A postprocessor that computes
-  # some statistics about the velocity field.
-  #
-  # `temperature statistics': A
-  # postprocessor that computes some statistics about the temperature
-  # field.
-  #
-  # `velocity statistics for the table model': A postprocessor that
-  # computes some statistics about the velocity field.
-  #
-  # `heat flux statistics
-  # for the table model': A postprocessor that computes some statistics about
-  # the heat flux across boundaries.
-  #
-  # `heat flux statistics': A postprocessor
-  # that computes some statistics about the heat flux across boundaries.
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 1e6
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/tests/periodic_box.prm.bak b/tests/periodic_box.prm.bak
deleted file mode 100644
index 833c83059b1..00000000000
--- a/tests/periodic_box.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-#Test for running a box in 2D with periodic boundary conditions
-#in the x condition.  Also tests the removal of net translations
-#in the periodic direction
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e6
-set Output directory                       = output
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set X extent = 1.e6
-    set Y extent = 5.e5
-    set Z extent = 5.e5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e20
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 10
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 2,3
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net x translation
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-  end
-end
diff --git a/tests/periodic_box2.prm.bak b/tests/periodic_box2.prm.bak
deleted file mode 100644
index 71f719b3098..00000000000
--- a/tests/periodic_box2.prm.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-# like periodic_box.prm, except we are now periodic in x and y and running in
-# parallel
-#
-# MPI: 2
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e6
-set Output directory                       = output
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set Y periodic = true
-    set X extent = 1.e6
-    set Y extent = 5.e5
-    set Z extent = 5.e5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e20
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 10
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net translation
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-  end
-end
diff --git a/tests/periodic_box_freesurface.prm.bak b/tests/periodic_box_freesurface.prm.bak
deleted file mode 100644
index fce3480d6cb..00000000000
--- a/tests/periodic_box_freesurface.prm.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-#Test for running a box in 2D with periodic boundary conditions
-#in the x condition and a free surface on the top.
-#  Also tests the removal of net translations in the periodic direction
-
-set Dimension = 2
-set CFL number                             = 0.4
-set End time                               = 1e6
-set Output directory                       = output
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set X extent = 1.e6
-    set Y extent = 5.e5
-    set Z extent = 5.e5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e20
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 6
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 10
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators        = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 1.0
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net x translation
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 4
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  topography,
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-  end
-end
diff --git a/tests/periodic_box_gmg.prm.bak b/tests/periodic_box_gmg.prm.bak
deleted file mode 100644
index 1cc7f1860ed..00000000000
--- a/tests/periodic_box_gmg.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# Test that periodic boundary conditions work with GMG. This test will
-# currently crash if run with a larger end time as we will run into a
-# situation with adaptive refinement across the periodic border, which
-# is not supported.
-
-# MPI: 2
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 20000
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = no
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 0.0
-    set Bottom temperature = 1000.0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set X extent = 1.e6
-    set Y extent = 5.e5
-    set Z extent = 5.e5
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net x translation
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1e-8
-    set Number of cheap Stokes solver steps = 100
-  end
-
-  subsection Matrix Free
-    set Output details = true
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e20
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 5                       # default: 2
-  set Minimum refinement level                            = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.03
-  set Strategy                           = thermal energy density#, equal periodic refinement
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables =
-    set Number of grouped files       = 1
-    set Output format                 = vtu
-    set Time between graphical output = 0#1.e3
-  end
-end
diff --git a/tests/periodic_box_mpi4.prm.bak b/tests/periodic_box_mpi4.prm.bak
deleted file mode 100644
index 9fa52a3281e..00000000000
--- a/tests/periodic_box_mpi4.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# like periodic_box2.prm. This test shows bugs inside
-# SimulatorAccess<dim>::get_fe() and handling of nullspace constraints that
-# happen if one MPI process does not own any DoFs. We force this here be using
-# a coarse mesh and 4 tasks.
-
-# MPI: 4
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e6
-set Output directory                       = output
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set Y periodic = true
-    set X extent = 1.e6
-    set Y extent = 5.e5
-    set Z extent = 5.e5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e20
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = net translation
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, visualization
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-  end
-end
diff --git a/tests/periodic_compressible.prm.bak b/tests/periodic_compressible.prm.bak
deleted file mode 100644
index f5752e3fe04..00000000000
--- a/tests/periodic_compressible.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# This is a test case for periodic boundary conditions in a model
-# with a compressible material model.
-
-set Dimension                              = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-set Output directory                       = periodic
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 3
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent   = 2900000
-    set Y extent   = 2900000
-    set X periodic = true
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 3773
-    set Top temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set List of model names = adiabatic, function
-
-  subsection Function
-    set Coordinate system   = cartesian
-    set Variable names      = x, y
-    set Function constants  = d = 2900000
-    set Function expression = 50 * sin(2*x/d*pi)*sin(2*y/d*pi)
-  end
-
-  subsection Adiabatic
-    set Age top boundary layer = 1e8
-    set Age bottom boundary layer = 1e8
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top
-  set Zero velocity boundary indicators = bottom
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics,temperature statistics,heat flux statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set List of output variables      = viscosity, density, thermal expansivity, specific heat, nonadiabatic temperature #, named additional outputs
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/tests/periodic_linear_momentum.prm.bak b/tests/periodic_linear_momentum.prm.bak
deleted file mode 100644
index a658346c553..00000000000
--- a/tests/periodic_linear_momentum.prm.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-# Test linear x momentum for periodic box.
-# This is based off of periodic_box.prm
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e6
-set Output directory                       = output
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set X extent = 1.e6
-    set Y extent = 5.e5
-    set Z extent = 5.e5
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if((sqrt((x-1.e5)^2+(y-4.0e5)^2)<5.0e4) | (sqrt((x-3.e5)^2+(y-2.e5)^2)<1.0e5) , 800.0, 0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e20
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 10
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 2,3
-end
-
-subsection Nullspace removal
-  set Remove nullspace                        = linear x momentum
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-  end
-end
diff --git a/tests/periodic_quarter_shell.prm.bak b/tests/periodic_quarter_shell.prm.bak
deleted file mode 100644
index 7d9e88e7e70..00000000000
--- a/tests/periodic_quarter_shell.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# testing for periodic conditions in phi direction
-# for 2D quarter spherical shell geometry
-# based on boundary_velocity_function_spherical.prm
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-    set Phi periodic = true
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 3
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner
-  set Prescribed velocity boundary indicators = outer: function
-
-  subsection Function
-    set Coordinate system   = spherical
-    set Variable names      = r, phi
-    set Function expression = 0.0;0.1
-    set Use spherical unit vectors = true
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 5
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/plugin.cc.bak b/tests/plugin.cc.bak
deleted file mode 100644
index 28ad2b0dff3..00000000000
--- a/tests/plugin.cc.bak
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// make sure we can include deal.II and aspect files
-#include <aspect/simulator.h>
-#include <aspect/utilities.h>
-#include <deal.II/grid/tria.h>
-
-#include <iostream>
-#include <typeinfo>
-
-// create a function that is run upon loading the plugin
-// and that produces some output
-int f()
-{
-  std::cout << aspect::Utilities::expand_ASPECT_SOURCE_DIR("srcdir='$ASPECT_SOURCE_DIR'") << std::endl;
-
-  std::cout << typeid(dealii::Triangulation<2>).name() << ' '
-            << typeid(aspect::Simulator<2>).name() << std::endl;
-  return 42;
-}
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/plugin.prm.bak b/tests/plugin.prm.bak
deleted file mode 100644
index 4c4846cfe0d..00000000000
--- a/tests/plugin.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# a test that simply verifies that the plugin described in
-# plugin.cc is indeed run
-
-
-
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/plugin_dependency.cc.bak b/tests/plugin_dependency.cc.bak
deleted file mode 100644
index 0220c9f8685..00000000000
--- a/tests/plugin_dependency.cc.bak
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// create a postprocessor that does exactly the same as
-// SolCxPostprocessor, but also requires something else
-
-#include "../benchmarks/solcx/solcx.cc"
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    class NewPostprocessor : public aspect::InclusionBenchmark::SolCxPostprocessor<dim>
-    {
-      public:
-        virtual
-        std::list<std::string>
-        required_other_postprocessors () const
-        {
-          // select a postprocessor that is not selected in the .prm file
-          std::list<std::string> deps;
-          deps.push_back ("velocity statistics");
-          return deps;
-        }
-    };
-  }
-}
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(NewPostprocessor,
-                                  "new postprocessor",
-                                  ".")
-  }
-}
diff --git a/tests/plugin_dependency.prm.bak b/tests/plugin_dependency.prm.bak
deleted file mode 100644
index 951f6a70549..00000000000
--- a/tests/plugin_dependency.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-# Test that the way we provide postprocessors to state that they
-# depend on other postprocessors works
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  # choose a postprocessor that will in turn require another one
-  # to run as well (here, velocity statistics)
-  set List of postprocessors = new postprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/plugin_dependency_redundant.cc.bak b/tests/plugin_dependency_redundant.cc.bak
deleted file mode 100644
index 2e05a4d2efa..00000000000
--- a/tests/plugin_dependency_redundant.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Exactly like plugin_dependency.cc
-
-#include "plugin_dependency.cc"
diff --git a/tests/plugin_dependency_redundant.prm.bak b/tests/plugin_dependency_redundant.prm.bak
deleted file mode 100644
index ff11c3cbd8c..00000000000
--- a/tests/plugin_dependency_redundant.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# like plugin_dependency, but also list the required plugin in the
-# .prm file. this is then redundant, and this test ensures that we
-# don't load the plugin twice
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  # choose a postprocessor that will in turn require another one
-  # to run as well (here, velocity statistics). check that
-  # redundancy is no problem
-  set List of postprocessors = new postprocessor, velocity statistics
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/plugin_dependency_redundant_02.cc.bak b/tests/plugin_dependency_redundant_02.cc.bak
deleted file mode 100644
index 2e05a4d2efa..00000000000
--- a/tests/plugin_dependency_redundant_02.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Exactly like plugin_dependency.cc
-
-#include "plugin_dependency.cc"
diff --git a/tests/plugin_dependency_redundant_02.prm.bak b/tests/plugin_dependency_redundant_02.prm.bak
deleted file mode 100644
index 35d30bb9ee3..00000000000
--- a/tests/plugin_dependency_redundant_02.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-# like plugin_dependency_redundant, but list plugins in reverse order. this
-# should still no lead to any redundancy
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  # choose a postprocessor that will in turn require another one
-  # to run as well (here, velocity statistics). check that
-  # redundancy is no problem
-  set List of postprocessors = velocity statistics, new postprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/point_value_01.prm.bak b/tests/point_value_01.prm.bak
deleted file mode 100644
index 315b5ed6ed3..00000000000
--- a/tests/point_value_01.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# A variation of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for evaluating the solution at chosen points
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.1
-set Use years in output instead of seconds = false
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0.0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, point values
-
-  subsection Point values
-    set Evaluation points = 0.25, 0.5  ; \
-                            0.5 , 0.25 ; \
-                            0.75, 0.75
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/point_value_02.prm.bak b/tests/point_value_02.prm.bak
deleted file mode 100644
index 24de8b255f5..00000000000
--- a/tests/point_value_02.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# A variation of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for evaluating the solution at chosen points
-#
-# This variation tests that we correctly convert output to years as well.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.001
-set Use years in output instead of seconds = true
-set Pressure normalization                 = volume
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 5
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0.0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, point values
-
-  subsection Point values
-    set Evaluation points = 0.25, 0.5  ; \
-                            0.5 , 0.25 ; \
-                            0.75, 0.75
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity, artificial viscosity composition
-
-    subsection Artificial viscosity composition
-      set Name of compositional field = C_1
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/point_value_02_mpi.prm.bak b/tests/point_value_02_mpi.prm.bak
deleted file mode 100644
index f81605536f0..00000000000
--- a/tests/point_value_02_mpi.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# A variation of the cookbook/sinker-with-averaging/sinker-with-averaging.prm
-# file for evaluating the solution at chosen points
-
-# This variant of the _02 test checks that everything still runs for
-# parallel computations.
-
-# MPI: 3
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.001
-set Use years in output instead of seconds = true
-set Pressure normalization                 = volume
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0000
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = left, right, bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Reference density             = 1
-    set Viscosity                     = 1
-    set Thermal expansion coefficient = 0.0
-    set Composition viscosity prefactor = 1e6
-    set Density differential for compositional field 1 = 10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if( (sqrt((x-0.5)^2+(y-0.5)^2)>0.22) , 0 , 1 )
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization, point values
-
-  subsection Point values
-    set Evaluation points = 0.25, 0.5  ; \
-                            0.5 , 0.25 ; \
-                            0.75, 0.75
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set List of output variables = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/point_value_03.prm.bak b/tests/point_value_03.prm.bak
deleted file mode 100644
index e98372d8ba6..00000000000
--- a/tests/point_value_03.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-# A variation of cell_in_circumference to test that the point values
-# postprocessor also works with non-rectangular meshes
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 5000000
-    set Outer radius = 6371000
-    set Opening angle = 360
-
-    # use a number of cells the is guaranteed to not create any
-    # symmetries
-    set Cells along circumference = 11
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Additional refinement times              = 0,0
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, point values
-
-  # Choose points that are for sure in the domain but not
-  # at symmetry points
-  subsection Point values
-    set Evaluation points = 6000000, 1000  ; \
-                            1000, 6000000  ; \
-                            4014515, 4234567
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/point_value_natural_coordinates.prm.bak b/tests/point_value_natural_coordinates.prm.bak
deleted file mode 100644
index 284770c03b5..00000000000
--- a/tests/point_value_natural_coordinates.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# A test for the point values postprocessor
-# using natural coordinates
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3481000
-    set Chunk outer radius = 6371000
-    set Chunk minimum longitude = 0
-    set Chunk maximum longitude = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = point values
-
-  subsection Point values
-    # Get values at 0, 10 and 20 degrees longitude and 71 km depth
-    set Evaluation points = 6300e3, 0  ; \
-                            6300e3, 0.1745 ; \
-                            6300e3, 0.3491
-    set Use natural coordinates = true
-  end
-end
diff --git a/tests/point_value_natural_coordinates_shell.prm.bak b/tests/point_value_natural_coordinates_shell.prm.bak
deleted file mode 100644
index 1fa8d3688d9..00000000000
--- a/tests/point_value_natural_coordinates_shell.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# A test for the point values postprocessor
-# using natural coordinates
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if((sqrt((x-3483208.)^2+(y-3483208.)^2)<5e5) , 1800.0, 1613.0)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = point values
-
-  subsection Point values
-    # Get values at 45 degrees longitude and 1 and 1445 km depth.
-    # The former should give a temperature of 1613 K and the latter
-    # of 1800 K.
-    set Evaluation points = 6370e3, 0.7854; \
-                            4926e3, 0.7854
-    set Use natural coordinates = true
-  end
-end
diff --git a/tests/point_value_specific_output_times.prm.bak b/tests/point_value_specific_output_times.prm.bak
deleted file mode 100644
index 0bcc0cd7242..00000000000
--- a/tests/point_value_specific_output_times.prm.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-# A variation of cell_in_circumference to test that the point values
-# postprocessor also works when requesting output at specific time intervals only.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 3e16
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 5000000
-    set Outer radius = 6371000
-    set Opening angle = 360
-
-    # use a number of cells the is guaranteed to not create any
-    # symmetries
-    set Cells along circumference = 11
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Additional refinement times              = 0,0
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, point values
-
-  # Choose points that are for sure in the domain but not
-  # at symmetry points
-  subsection Point values
-    set Time between point values output = 2e16
-    set Evaluation points = 6000000, 1000  ; \
-                            1000, 6000000  ; \
-                            4014515, 4234567
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/poiseuille_2d.prm.bak b/tests/poiseuille_2d.prm.bak
deleted file mode 100644
index b04faa39c19..00000000000
--- a/tests/poiseuille_2d.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# A simple Poiseuille flow example in which we prescribe the velocity to
-# be (z*(z-1),0)^T and see what pressure we get. We switch off gravity
-# so the pressure is purely the dynamic pressure. It is only determined
-# up to a constant, and with a viscosity of eta=1, should be between
-# +2 at the left inlet and -2 at the right outlet.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function
-  set Zero velocity boundary indicators       = 2, 3
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z*(1-z);0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
-end
diff --git a/tests/poiseuille_2d_horizontal_pressure_bc.prm.bak b/tests/poiseuille_2d_horizontal_pressure_bc.prm.bak
deleted file mode 100644
index f1061d1bc45..00000000000
--- a/tests/poiseuille_2d_horizontal_pressure_bc.prm.bak
+++ /dev/null
@@ -1,102 +0,0 @@
-# Like the poiseuille_2d.prm test, but instead of prescribing the
-# velocity at the left and right ends, prescribe the horizontal
-# component of the traction. At the same time, set the vertical
-# component of the velocity to zero. This should yield the same answer.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary traction model
-  # Prescribe a horizontal traction on the vertical boundaries
-  set Prescribed traction boundary indicators = 0 x: function, 1 x: function
-
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 2;0
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 2, 3
-
-  # Prescribe a zero vertical velocity component on the vertical boundaries
-  set Prescribed velocity boundary indicators = 0 y: function, 1 y: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = 0;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
-end
diff --git a/tests/poiseuille_2d_pressure_bc.prm.bak b/tests/poiseuille_2d_pressure_bc.prm.bak
deleted file mode 100644
index 1fc3a5e84c2..00000000000
--- a/tests/poiseuille_2d_pressure_bc.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# Like the poiseuille_2d.prm test, but instead of prescribing the
-# velocity at the left and right ends, prescribe the pressure. This
-# should yield the same answer, of course.
-# In this case however, there will be pressure singularities
-# in the corners of the domain.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 0 : function, 1 : function
-
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 2;0
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
-end
diff --git a/tests/poiseuille_2d_pressure_bc_gmg.prm.bak b/tests/poiseuille_2d_pressure_bc_gmg.prm.bak
deleted file mode 100644
index 7b919c72e10..00000000000
--- a/tests/poiseuille_2d_pressure_bc_gmg.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-# Like the poiseuille_2d_pressure_bc.prm test, but using GMG instead.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Solver parameters
-  subsection Matrix Free
-    set Output details = true
-  end
-
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps             = 200
-    set Maximum number of expensive Stokes solver steps = 0
-    set Linear solver tolerance                         = 1e-6
-    set GMRES solver restart length                     = 100
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 0 : function, 1 : function
-
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 2;0
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
-end
diff --git a/tests/poiseuille_3d_x_horizontal_pressure_bc.prm.bak b/tests/poiseuille_3d_x_horizontal_pressure_bc.prm.bak
deleted file mode 100644
index 1df32b084f5..00000000000
--- a/tests/poiseuille_3d_x_horizontal_pressure_bc.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# Like the poiseuille_2d_horizontal_pressure_bc.prm test,
-# but in 3d.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Box
-    set Left temperature = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary traction model
-  # Prescribe a horizontal traction on the vertical boundaries
-  set Prescribed traction boundary indicators = 0 x: function, 1 x: function
-
-  subsection Function
-    set Variable names = x,y,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0;0). On the right (1;0;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0;0) = - (2) (-1;0;0) = (2;0;0).
-    # Right boundary: tau = - pressure(right) (1;0;0) = - (-2) (1;0;0) = (2;0;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 2;0;0
-  end
-end
-
-subsection Boundary velocity model
-  # Prescribe zero y and z velocity components on the vertical boundaries
-  set Prescribed velocity boundary indicators = 0 yz: function, 1 yz: function
-  set Zero velocity boundary indicators       = 2, 3, 4, 5
-
-  subsection Function
-    set Variable names = x,y,z
-    set Function expression = 0;0;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics
-end
diff --git a/tests/postprocess_initial.prm.bak b/tests/postprocess_initial.prm.bak
deleted file mode 100644
index 102096617ad..00000000000
--- a/tests/postprocess_initial.prm.bak
+++ /dev/null
@@ -1,105 +0,0 @@
-#########################################################
-# this tests that "Run postprocessors on initial refinement = true"
-# is working correctly (in particular that it increases the id
-# of the output files)
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1e-15
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0.01
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 3
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-  set Run postprocessors on initial refinement = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/tests/postprocess_iterations_Stokes_only.cc.bak b/tests/postprocess_iterations_Stokes_only.cc.bak
deleted file mode 100644
index 9130c172908..00000000000
--- a/tests/postprocess_iterations_Stokes_only.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "compressibility_iterated_stokes_direct_solver.cc"
diff --git a/tests/postprocess_iterations_Stokes_only.prm.bak b/tests/postprocess_iterations_Stokes_only.prm.bak
deleted file mode 100644
index a92bb623bb5..00000000000
--- a/tests/postprocess_iterations_Stokes_only.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-#########################################################
-# This is a model setup to test the postprocessing of
-# nonlinear iterations for the no Advection, iterated Stokes solver.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 5
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = compressibility iterated stokes
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set Run postprocessors on nonlinear iterations = true
-  set List of postprocessors = visualization, dynamic topography, heat flux map, compressibility
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/postprocess_iterations_iterated_Stokes.cc.bak b/tests/postprocess_iterations_iterated_Stokes.cc.bak
deleted file mode 100644
index 1f606d76070..00000000000
--- a/tests/postprocess_iterations_iterated_Stokes.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "no_adiabatic_heating_03.cc"
diff --git a/tests/postprocess_iterations_iterated_Stokes.prm.bak b/tests/postprocess_iterations_iterated_Stokes.prm.bak
deleted file mode 100644
index 00eda6f3a7d..00000000000
--- a/tests/postprocess_iterations_iterated_Stokes.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-#########################################################
-# This is a model setup to test the postprocessing of
-# nonlinear iterations for the iterated Stokes solver.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = .1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 5
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2
-
-  subsection Box
-    set Bottom temperature = 0
-  end
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = no adiabatic heating
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set Run postprocessors on nonlinear iterations = true
-  set List of postprocessors = visualization, dynamic topography, heat flux map, temperature statistics, velocity statistics, basic statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/tests/postprocess_iterations_iterated_advection_and_stokes.prm.bak b/tests/postprocess_iterations_iterated_advection_and_stokes.prm.bak
deleted file mode 100644
index 0eb8d91e950..00000000000
--- a/tests/postprocess_iterations_iterated_advection_and_stokes.prm.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-#########################################################
-# This is a model setup to test the postprocessing of
-# nonlinear iterations for the iterated Advection and Stokes solver.
-
-
-set Adiabatic surface temperature          = 0
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-
-  subsection Stabilization parameters
-    set beta  = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 150000
-    set Y extent  = 65000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 0
-    set Thermal expansion coefficient = 1
-    set Thermal viscosity exponent = 0.0
-    set Reference specific heat = 1.0
-    set Reference density = 1.0
-    set Reference temperature = 0
-    set Viscosity = 1e16
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set Run postprocessors on nonlinear iterations = true
-  set List of postprocessors = visualization, dynamic topography, heat flux map
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/pre_data_out_build_patches.cc.bak b/tests/pre_data_out_build_patches.cc.bak
deleted file mode 100644
index 69dd5dd1148..00000000000
--- a/tests/pre_data_out_build_patches.cc.bak
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_signals.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-
-namespace aspect
-{
-  template <int dim>
-  void pre_data_out_build_patches (DataOut<dim> &)
-  {
-    std::cout << "\npre_data_out_build_patches:\n";
-  }
-
-
-  template <int dim>
-  void signal_connector (SimulatorSignals<dim> &signals)
-  {
-    std::cout << "Connecting signals" << std::endl;
-    signals.pre_data_out_build_patches.connect (&pre_data_out_build_patches<dim>);
-  }
-
-
-  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                    signal_connector<3>)
-}
diff --git a/tests/pre_data_out_build_patches.prm.bak b/tests/pre_data_out_build_patches.prm.bak
deleted file mode 100644
index 63eab17f78a..00000000000
--- a/tests/pre_data_out_build_patches.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# A copy of stokes_solver.prm
-# to test the pre_data_out_build_patches signal
-# in visualization.cc.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0.1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set List of output variables      = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/prescribed_dilation.cc.bak b/tests/prescribed_dilation.cc.bak
deleted file mode 100644
index 1cd8e57417b..00000000000
--- a/tests/prescribed_dilation.cc.bak
+++ /dev/null
@@ -1,413 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  namespace Benchmark
-  {
-    using namespace dealii;
-
-    /**
-     * u = cos(y), sin(x)+xy
-     * p = 2/3 eta x
-     * grad p = 2/3 eta
-     * R = div u = x
-     * => grad p and compressibility term cancel
-     */
-
-    namespace AnalyticSolutions
-    {
-      Tensor<1,2>
-      velocity (const Point<2> &pos,
-                const double /*eta*/)
-      {
-
-        const double x = pos[0];
-        const double y = pos[1];
-
-        return Point<2> (cos(y), sin(x)+x*y);
-      }
-
-      double
-      pressure (const Point<2> &pos,
-                const double eta)
-      {
-        const double x = pos[0];
-        //        const double y = pos[1];
-
-        return 2./3.*eta*(x-1.0);
-      }
-
-
-      /**
-       * The exact solution for the benchmark.
-       */
-      template <int dim>
-      class Exact : public Function<dim>
-      {
-        public:
-          Exact (const double eta)
-            :
-            Function<dim>(dim+2),
-            eta(eta)
-          {}
-
-          virtual void vector_value (const Point<dim>   &pos,
-                                     Vector<double>   &values) const
-          {
-            Assert (dim == 2, ExcNotImplemented());
-            Assert (values.size() >= 3, ExcInternalError());
-
-            const Point<2> p (pos[0], pos[1]);
-
-            const Tensor<1,2> v = AnalyticSolutions::velocity (p, eta);
-            values[0] = v[0];
-            values[1] = v[1];
-
-            values[2] = AnalyticSolutions::pressure (p, eta);
-          }
-
-        private:
-          const double eta;
-      };
-    }
-
-
-
-    template <int dim>
-    class MyBoundary : public BoundaryVelocity::Interface<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        MyBoundary();
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        virtual
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_indicator,
-                           const Point<dim> &position) const;
-
-      private:
-        const double eta;
-    };
-
-    template <int dim>
-    MyBoundary<dim>::MyBoundary ()
-      :
-      eta (0)
-    {}
-
-
-
-    template <>
-    Tensor<1,2>
-    MyBoundary<2>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<2> &p) const
-    {
-      return AnalyticSolutions::velocity (p, eta);
-    }
-
-
-
-    template <>
-    Tensor<1,3>
-    MyBoundary<3>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<3> &p) const
-    {
-      Assert (false, ExcNotImplemented());
-      return Tensor<1,3>();
-    }
-
-
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class MyMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const
-        {
-          MaterialModel::PrescribedPlasticDilation<dim>
-          *prescribed_dilation = out.template get_additional_output<MaterialModel::PrescribedPlasticDilation<dim>>();
-
-          MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>
-          *force = out.template get_additional_output<MaterialModel::AdditionalMaterialOutputsStokesRHS<dim>>();
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> &p = in.position[i];
-
-              const double x=p[0];
-              const double y=p[1];
-
-              out.viscosities[i] = eta;
-              out.thermal_conductivities[i] = 0.0;
-              out.densities[i] = 1.0;
-
-              out.thermal_expansion_coefficients[i] = 0.0;
-              out.compressibilities[i] = 0.0;
-
-              out.specific_heat[i] = 0.0;
-
-              // Pressure derivative of entropy at the given positions.
-              out.entropy_derivative_pressure[i] = 0.0;
-              // Temperature derivative of entropy at the given positions.
-              out.entropy_derivative_temperature[i] = 0.0;
-              // Change in composition due to chemical reactions at the
-              // given positions. The term reaction_terms[i][c] is the
-              // change in compositional field c at point i.
-              for (unsigned int c=0; c<in.composition[i].size(); ++c)
-                out.reaction_terms[i][c] = 0.0;
-
-              if (force)
-                {
-                  force->rhs_u[i][0] = -eta*(1-cos(y));
-                  force->rhs_u[i][1] = -eta*(-sin(x));
-                  force->rhs_p[i] = 0.;
-                }
-              if (prescribed_dilation)
-                {
-                  prescribed_dilation->dilation[i] = x;
-                }
-
-            }
-
-        }
-
-        virtual bool is_compressible () const;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-
-        double get_eta () const;
-
-        /**
-         * viscosity value in the inclusion
-         */
-        double eta;
-    };
-
-
-
-    template <int dim>
-    double
-    MyMaterial<dim>::
-    get_eta () const
-    {
-      return eta;
-    }
-
-    template <int dim>
-    bool
-    MyMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    MyMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      // create a global section in the parameter file for parameters
-      // that describe this benchmark. note that we declare them here
-      // in the material model, but other kinds of plugins (e.g., the gravity
-      // model below) may also read these parameters even though they do not
-      // declare them
-      prm.enter_subsection("My benchmark");
-
-      {
-        prm.declare_entry("Viscosity parameter", "10",
-                          Patterns::Double (0),
-                          "Viscosity the benchmark.");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    MyMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("My benchmark");
-      {
-        eta = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-
-
-
-
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the paper Duretz et al. reference above.
-      */
-    template <int dim>
-    class MyPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        virtual
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics);
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    MyPostprocessor<dim>::execute (TableHandler &statistics)
-    {
-      std::unique_ptr<Function<dim>> ref_func;
-      {
-        const MyMaterial<dim> *
-        material_model
-          = dynamic_cast<const MyMaterial<dim> *>(&this->get_material_model());
-
-        ref_func = std::make_unique<AnalyticSolutions::Exact<dim>>(material_model->get_eta());
-      }
-
-      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                          dim+2);
-      ComponentSelectFunction<dim> comp_p(dim, dim+2);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_u,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_p,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_p);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_ul2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_pl2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-      std::ostringstream os;
-      os << std::scientific << u_l2 << ", " << p_l2;
-
-      return std::make_pair("Errors u_L2, p_L2:", os.str());
-    }
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Benchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(MyMaterial,
-                                   "MyMaterial",
-                                   "A material model that corresponds to the `My' benchmark. "
-                                   "See the manual for more information.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(MyBoundary,
-                                            "MyBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "`My' benchmark. See the manual for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(MyPostprocessor,
-                                  "MyPostprocessor",
-                                  "A postprocessor that compares the solution of the `My' benchmark "
-                                  "with the one computed by ASPECT "
-                                  "and reports the error. See the manual for more information.")
-  }
-}
diff --git a/tests/prescribed_dilation.prm.bak b/tests/prescribed_dilation.prm.bak
deleted file mode 100644
index 86af3ebbb17..00000000000
--- a/tests/prescribed_dilation.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# Manufactured solution to test PrescribedDilation
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-subsection Formulation
-  set Enable prescribed dilation          = true
-  set Enable additional Stokes RHS            = true
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2
-    set Y extent  = 2
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:MyBoundary, 1:MyBoundary, 2:MyBoundary, 3:MyBoundary
-end
-
-subsection Material model
-  set Model name = MyMaterial
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 1.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Run postprocessors on initial refinement = true
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, MyPostprocessor, visualization
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/prescribed_dilation_gmg.cc.bak b/tests/prescribed_dilation_gmg.cc.bak
deleted file mode 100644
index 0c5505e0b32..00000000000
--- a/tests/prescribed_dilation_gmg.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "prescribed_dilation.cc"
diff --git a/tests/prescribed_dilation_gmg.prm.bak b/tests/prescribed_dilation_gmg.prm.bak
deleted file mode 100644
index 75f4507e657..00000000000
--- a/tests/prescribed_dilation_gmg.prm.bak
+++ /dev/null
@@ -1,19 +0,0 @@
-# like prescribed_dilation.prm but using GMG
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/prescribed_dilation.prm
-
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 200
-
-    #set Maximum number of expensive Stokes solver steps = 40
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/tests/prescribed_dilation_newton.cc.bak b/tests/prescribed_dilation_newton.cc.bak
deleted file mode 100644
index 0c5505e0b32..00000000000
--- a/tests/prescribed_dilation_newton.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "prescribed_dilation.cc"
diff --git a/tests/prescribed_dilation_newton.prm.bak b/tests/prescribed_dilation_newton.prm.bak
deleted file mode 100644
index 43536b2edd1..00000000000
--- a/tests/prescribed_dilation_newton.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# like prescribed_dilation.prm but using Newton solver
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/prescribed_dilation.prm
-
-set Nonlinear solver scheme = iterated Advection and Newton Stokes
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    #    set Stokes solver type = block GMG
-    #    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  #  set Material averaging = harmonic average
-end
diff --git a/tests/prescribed_dilation_newton_singleadvection.cc.bak b/tests/prescribed_dilation_newton_singleadvection.cc.bak
deleted file mode 100644
index 0c5505e0b32..00000000000
--- a/tests/prescribed_dilation_newton_singleadvection.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "prescribed_dilation.cc"
diff --git a/tests/prescribed_dilation_newton_singleadvection.prm.bak b/tests/prescribed_dilation_newton_singleadvection.prm.bak
deleted file mode 100644
index 251b62c988b..00000000000
--- a/tests/prescribed_dilation_newton_singleadvection.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# like prescribed_dilation.prm but using Newton solver
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/prescribed_dilation.prm
-
-set Nonlinear solver scheme = single Advection, iterated Newton Stokes
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    #    set Stokes solver type = block GMG
-    #    set Number of cheap Stokes solver steps = 200
-  end
-end
-
-subsection Material model
-  #  set Material averaging = harmonic average
-end
diff --git a/tests/prescribed_field.cc.bak b/tests/prescribed_field.cc.bak
deleted file mode 100644
index a722b8b0f79..00000000000
--- a/tests/prescribed_field.cc.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class PrescribedFieldMaterial : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-        virtual
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    PrescribedFieldMaterial<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      Simple<dim>::evaluate(in, out);
-
-      // set up variable to interpolate prescribed field outputs onto compositional fields
-      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
-
-      if (prescribed_field_out != nullptr)
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          prescribed_field_out->prescribed_field_outputs[i][1] = out.densities[i];
-    }
-
-
-    template <int dim>
-    void
-    PrescribedFieldMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points, this->n_compositional_fields()));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedFieldMaterial,
-                                   "prescribed field material",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but creates prescribed field outputs.")
-  }
-}
diff --git a/tests/prescribed_field.prm.bak b/tests/prescribed_field.prm.bak
deleted file mode 100644
index 244bfd50701..00000000000
--- a/tests/prescribed_field.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# A testcase that demonstrates that interpolating material model
-# outputs into compositional fields works.
-#
-# The density is chosen as rho = 1 + 0.1*sin(2*pi*x)*sin(2*pi*y)
-# and is copied into the compositional field 'prescribed field',
-# so the minimum and maximum composition should be 0.9 at 1.1,
-# respectively.
-# The test also contains another compositional field that does
-# not use this method, so it should remain zero everywhere
-# (which is what the initial condition is).
-
-set Dimension = 2
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields  = normal_field, prescribed_field
-  set Compositional field methods = field, prescribed field
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.1 * sin(2*3.1416*x) * sin(2*3.1416*y)
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0; 0.0
-  end
-end
-
-subsection Material model
-  set Model name = prescribed field material
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/prescribed_field_temperature.cc.bak b/tests/prescribed_field_temperature.cc.bak
deleted file mode 100644
index cc5d415d51d..00000000000
--- a/tests/prescribed_field_temperature.cc.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class PrescribedFieldMaterial : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-        virtual
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    PrescribedFieldMaterial<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      Simple<dim>::evaluate(in, out);
-
-      // set up variable to interpolate prescribed field outputs onto temperature field
-      PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>();
-
-      if (prescribed_temperature_out != nullptr)
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          prescribed_temperature_out->prescribed_temperature_outputs[i] = in.pressure[i];
-    }
-
-
-    template <int dim>
-    void
-    PrescribedFieldMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>> (n_points));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedFieldMaterial,
-                                   "prescribed field material",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but creates prescribed field outputs "
-                                   "for the temperature.")
-  }
-}
diff --git a/tests/prescribed_field_temperature.prm.bak b/tests/prescribed_field_temperature.prm.bak
deleted file mode 100644
index 295da0b20e9..00000000000
--- a/tests/prescribed_field_temperature.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-# A testcase that demonstrates that interpolating material model
-# outputs into the temperature field works.
-#
-# The material model prescribes the temperature to be exactly the
-# pressure of the model
-# and is copied into the temperature field,
-# so the minimum and maximum temperature should be 0.0 and 1.0,
-# respectively.
-
-set Dimension = 2
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-
-subsection Temperature field
-  set Temperature method                     = prescribed field
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5
-  end
-end
-
-subsection Material model
-  set Model name = prescribed field material
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/prescribed_field_temperature_max_isotherm.prm.bak b/tests/prescribed_field_temperature_max_isotherm.prm.bak
deleted file mode 100644
index 2df6f62e5b7..00000000000
--- a/tests/prescribed_field_temperature_max_isotherm.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-set Additional shared libraries = ./libprescribed_temperature_in_field.so
-
-include $ASPECT_SOURCE_DIR/tests/prescribed_temperature_in_field.prm
-
-
-## The temperature will be fixed in the 'Fixed'
-## compositional field. The maximum fixed temperature
-## will also allow temperature to be constrained
-## outside of the fixed compositional model, as long
-## as the temperature is below 500 K.
-subsection Prescribed internal temperature model
-  set Maximum fixed temperature isosurface = 500
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if(x>=0.4, if(y<=0.5, 600, 400), 1000)
-  end
-end
diff --git a/tests/prescribed_field_with_diffusion.cc.bak b/tests/prescribed_field_with_diffusion.cc.bak
deleted file mode 100644
index e318fd79b7c..00000000000
--- a/tests/prescribed_field_with_diffusion.cc.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class PrescribedFieldMaterial : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-        virtual
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    PrescribedFieldMaterial<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      Simple<dim>::evaluate(in, out);
-
-      // set up variable to interpolate prescribed field outputs onto compositional fields
-      PrescribedFieldOutputs<dim> *prescribed_field_out = out.template get_additional_output<PrescribedFieldOutputs<dim>>();
-
-      if (prescribed_field_out != nullptr)
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          {
-            const double y = in.position[i](1);
-            prescribed_field_out->prescribed_field_outputs[i][1] = std::exp(-y*y/2.0);
-          }
-    }
-
-
-    template <int dim>
-    void
-    PrescribedFieldMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<PrescribedFieldOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedFieldOutputs<dim>> (n_points, this->n_compositional_fields()));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedFieldMaterial,
-                                   "prescribed field material",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but creates prescribed field outputs.")
-  }
-}
diff --git a/tests/prescribed_field_with_diffusion.prm.bak b/tests/prescribed_field_with_diffusion.prm.bak
deleted file mode 100644
index fac752e786f..00000000000
--- a/tests/prescribed_field_with_diffusion.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# A testcase that demonstrates that interpolating material model
-# outputs into compositional fields and diffusing them works.
-#
-# The property copied into the compositional field 'prescribed field',
-# is a Gaussian with an amplitude of 1, namely exp(-0.5*x*x).
-# We choose the diffusion length scale in a way that its amplitude
-# should be reduced to 0.95 when the diffusion equation is solved.
-#
-# The test also contains another compositional field that does
-# not use this method, so it should remain zero everywhere
-# (which is what the initial condition is).
-
-set Dimension = 2
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-
-subsection Solver parameters
-  subsection Diffusion solver parameters
-    set Diffusion length scale = 0.23241476
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 0.1
-    set Y extent = 10
-    set Y repetitions = 100
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields  = normal_field, diffused_field
-  set Compositional field methods = field, prescribed field with diffusion
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.1
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0; 0.0
-  end
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators = top
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 0; 0
-  end
-end
-
-subsection Material model
-  set Model name = prescribed field material
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = named additional outputs
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/prescribed_stokes_solution.prm.bak b/tests/prescribed_stokes_solution.prm.bak
deleted file mode 100644
index 305c6e7a82b..00000000000
--- a/tests/prescribed_stokes_solution.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# test PrescribedStokesSolution
-# This test is based on depth_average_01, and is similar to cookbooks/convection_box.prm
-# Here we prescribe a circular Stokes flow
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/prescribed_stokes_solution_DG_periodic.prm.bak b/tests/prescribed_stokes_solution_DG_periodic.prm.bak
deleted file mode 100644
index 31cf14989f2..00000000000
--- a/tests/prescribed_stokes_solution_DG_periodic.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# test DG advection solver on a PrescribedStokesSolution (u,v) = (0,1 )
-# with periodic boundary conditions on both x and y axes
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 1
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Function expression = 0;1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X periodic = true
-    set Y periodic = true
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926536
-    set Function expression = cos(2*pi*x)*sin(2*pi*y)
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 2
-  set Use discontinuous temperature discretization = true
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/prescribed_stokes_solution_melt.prm.bak b/tests/prescribed_stokes_solution_melt.prm.bak
deleted file mode 100644
index 31df81fce04..00000000000
--- a/tests/prescribed_stokes_solution_melt.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# This test is a copy of the prescribed_stokes_solution test,
-# except that is uses melt transport.
-# The original test is based on depth_average_01, and is similar
-# to cookbooks/convection_box.prm.
-# We prescribe a circular Stokes flow.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use operator splitting                 = true
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Melt settings
-  set Use discontinuous compaction pressure = false
-  set Include melt transport                  = true
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Reference solid density       = 1
-    set Reference melt density        = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Reference shear viscosity     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/prescribed_temperature.cc.bak b/tests/prescribed_temperature.cc.bak
deleted file mode 100644
index 410067357c5..00000000000
--- a/tests/prescribed_temperature.cc.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class PrescribedTemperatureMaterial : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-        virtual
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    PrescribedTemperatureMaterial<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      Simple<dim>::evaluate(in, out);
-
-      // set up variable to interpolate prescribed field outputs onto compositional fields
-      PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>();
-
-      if (prescribed_temperature_out != nullptr)
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          {
-            const double y = in.position[i](1);
-            prescribed_temperature_out->prescribed_temperature_outputs[i] = y>0.5 ? 5.605170186 : 1.0;
-          }
-    }
-
-
-    template <int dim>
-    void
-    PrescribedTemperatureMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>> (n_points));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedTemperatureMaterial,
-                                   "prescribed temperature material",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but creates prescribed temperature outputs.")
-  }
-}
diff --git a/tests/prescribed_temperature.prm.bak b/tests/prescribed_temperature.prm.bak
deleted file mode 100644
index 59778fd43b1..00000000000
--- a/tests/prescribed_temperature.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# A testcase that demonstrates that interpolating material model
-# outputs into the temperature field works, and that this
-# temperature is actually being used to compute the material
-# properties.
-#
-# The property copied into the temperature field has a large
-# value in the upper half of the box and a low value in the lower
-# half of the box. If viscosities are being computed correctly,
-# then the strain rate should be much larger in the top half.
-
-set Dimension = 2
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set X periodic = true
-  end
-end
-
-subsection Temperature field
-  set Temperature method = prescribed field
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Material model
-  set Model name = prescribed temperature material
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-    set Thermal viscosity exponent    = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = top:function, bottom:function
-
-  subsection Function
-    set Function expression = y; 0.0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = named additional outputs, strain rate, material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/prescribed_temperature_in_field.cc.bak b/tests/prescribed_temperature_in_field.cc.bak
deleted file mode 100644
index 643a8743841..00000000000
--- a/tests/prescribed_temperature_in_field.cc.bak
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/parsed_function.h>
-#include <deal.II/fe/fe_values.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/initial_temperature/interface.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  // Declare and parse additional parameters
-  bool prescribe_internal_temperature;
-  std::vector <std::string> fixed_compositional_fields;
-  double max_isotherm;
-
-
-  void declare_parameters(const unsigned int /*dim*/,
-                          ParameterHandler &prm)
-  {
-    prm.enter_subsection ("Prescribed internal temperature model");
-    {
-      prm.declare_entry ("Prescribe internal temperature", "false",
-                         Patterns::Bool (),
-                         "Whether or not to use any prescribed internal temperatures. "
-                         "Locations in which to prescribe temperature are defined "
-                         "based on the values of the compositional fields specified by "
-                         "the parameter ``Names of compositional fields with fixed temperature'' "
-                         "and the temperature is fixed to its initial state. Indicators are evaluated "
-                         "separately at each support point."
-                        );
-      prm.declare_entry ("Maximum fixed temperature isosurface", "0",
-                         Patterns::Double (),
-                         "The maximum temperature that will remain fixed. Temperatures above this "
-                         "value will be treated normally."
-                        );
-      prm.declare_entry ("Names of compositional fields with fixed temperature", "",
-                         Patterns::List(Patterns::Anything ()),
-                         "The names of compositional fields that determine the location where the "
-                         "temperature is fixed to the values it was initialized with. The temperature "
-                         "will be fixed if any of the fields listed here is above 0.5."
-                        );
-    }
-    prm.leave_subsection ();
-  }
-
-
-
-  template <int dim>
-  void parse_parameters(const Parameters<dim> &,
-                        ParameterHandler &prm)
-  {
-    prm.enter_subsection ("Prescribed internal temperature model");
-    {
-      prescribe_internal_temperature = prm.get_bool ("Prescribe internal temperature");
-      fixed_compositional_fields = Utilities::split_string_list (prm.get("Names of compositional fields with fixed temperature"));
-      max_isotherm = prm.get_double ("Maximum fixed temperature isosurface");
-    }
-    prm.leave_subsection ();
-  }
-
-  /**
-   * This function is called by a signal which is triggered after the other constraints
-   * have been calculated. This enables the definition of additional constraints in the mass
-   * matrix on any arbitrary degree of freedom in the model space.
-   */
-  template <int dim>
-  void constrain_internal_temperature (const SimulatorAccess<dim> &simulator_access,
-                                       AffineConstraints<double> &current_constraints)
-  {
-    // Save access to the initial temperature manager the first time
-    // we get here so that we can access it past the first time step
-    // as well.
-    static std::shared_ptr<const aspect::InitialTemperature::Manager<dim>> initial_temperature_manager;
-    if (initial_temperature_manager == nullptr)
-      initial_temperature_manager = simulator_access.get_initial_temperature_manager_pointer();
-
-    if (prescribe_internal_temperature)
-      {
-        const std::vector<Point<dim>> points = aspect::Utilities::get_unit_support_points(simulator_access);
-        const Quadrature<dim> quadrature (points);
-        FEValues<dim> fe_values (simulator_access.get_fe(), quadrature, update_quadrature_points | update_values | update_gradients);
-        typename DoFHandler<dim>::active_cell_iterator cell;
-        MaterialModel::MaterialModelInputs<dim> in(quadrature.size(), simulator_access.introspection().n_compositional_fields);
-
-        // Loop over all cells
-        for (cell = simulator_access.get_dof_handler().begin_active();
-             cell != simulator_access.get_dof_handler().end();
-             ++cell)
-
-          if (! cell->is_artificial())
-            {
-              fe_values.reinit (cell);
-              in.reinit(fe_values, cell, simulator_access.introspection(), simulator_access.get_solution());
-
-              std::vector<types::global_dof_index> local_dof_indices(simulator_access.get_fe().dofs_per_cell);
-              cell->get_dof_indices (local_dof_indices);
-              for (unsigned int q=0; q<quadrature.size(); q++)
-                {
-
-                  // If it's okay to constrain this DOF
-                  if (current_constraints.can_store_line(local_dof_indices[q]) &&
-                      !current_constraints.is_constrained(local_dof_indices[q]))
-                    {
-
-                      bool constrain_temperature = false;
-                      for (unsigned int c=0; c < fixed_compositional_fields.size(); ++c)
-                        {
-
-                          const unsigned int composition_idx = simulator_access.introspection().compositional_index_for_name(fixed_compositional_fields[c]);
-                          if (in.composition[q][composition_idx] >= 0.5 || in.temperature[q] <= max_isotherm)
-                            {
-                              constrain_temperature = true;
-                            }
-                        }
-
-                      if (constrain_temperature)
-                        {
-                          // Get the temperature component index
-                          const unsigned int c_idx = simulator_access.get_fe().system_to_component_index(q).first;
-
-                          // If we're on one of the temperature DOFs
-                          if (c_idx == simulator_access.introspection().component_indices.temperature)
-                            {
-
-                              // Set the temperature to be equal to the initial temperature
-                              in.temperature[q] = initial_temperature_manager->initial_temperature(in.position[q]);
-                              // Update the constraints
-                              current_constraints.add_line (local_dof_indices[q]);
-                              current_constraints.set_inhomogeneity (local_dof_indices[q], in.temperature[q]);
-                            }
-
-
-                        }
-                    }
-                }
-            }
-      }
-  }
-
-  // Connect declare_parameters and parse_parameters to appropriate signals.
-  void parameter_connector ()
-  {
-    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
-    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
-
-    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
-    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
-  }
-
-  // Connect constraints function to correct signal.
-  template <int dim>
-  void signal_connector (SimulatorSignals<dim> &signals)
-  {
-    signals.post_constraints_creation.connect (&constrain_internal_temperature<dim>);
-  }
-
-  // Tell ASPECT to send signals to the connector functions
-  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
-  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
-}
diff --git a/tests/prescribed_temperature_in_field.prm.bak b/tests/prescribed_temperature_in_field.prm.bak
deleted file mode 100644
index 9f5a54d3154..00000000000
--- a/tests/prescribed_temperature_in_field.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# Load the signal library.
-set Additional shared libraries = ./libprescribed_temperature_in_field.so
-set Dimension   = 2
-set End time    = 10000
-
-subsection Geometry model
-  set Model name = box
-end
-
-## The temperature will be fixed in the 'Fixed'
-## compositional field
-subsection Prescribed internal temperature model
-  set Prescribe internal temperature = true
-  set Names of compositional fields with fixed temperature = Fixed
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = Fixed, Not_fixed
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x,y
-    set Function expression = if(x<=0.5, 1, 0); if(x>=0.5, 1, 0)
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if(x<=0.4, 1000, 100)
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top, bottom, right, left
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 4
-  set Initial adaptive refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/prescribed_temperature_with_diffusion.cc.bak b/tests/prescribed_temperature_with_diffusion.cc.bak
deleted file mode 100644
index b6f22c64398..00000000000
--- a/tests/prescribed_temperature_with_diffusion.cc.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class PrescribedTemperatureMaterial : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-        virtual
-        void
-        create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    PrescribedTemperatureMaterial<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      Simple<dim>::evaluate(in, out);
-
-      // set up variable to interpolate prescribed field outputs onto compositional fields
-      PrescribedTemperatureOutputs<dim> *prescribed_temperature_out = out.template get_additional_output<PrescribedTemperatureOutputs<dim>>();
-
-      if (prescribed_temperature_out != nullptr)
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          {
-            const double y = in.position[i](1);
-            prescribed_temperature_out->prescribed_temperature_outputs[i] = std::exp(-y*y/2.0);
-          }
-    }
-
-
-    template <int dim>
-    void
-    PrescribedTemperatureMaterial<dim>::create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      if (out.template get_additional_output<PrescribedTemperatureOutputs<dim>>() == nullptr)
-        {
-          const unsigned int n_points = out.n_evaluation_points();
-          out.additional_outputs.push_back(
-            std::make_unique<MaterialModel::PrescribedTemperatureOutputs<dim>> (n_points));
-        }
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(PrescribedTemperatureMaterial,
-                                   "prescribed temperature material",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but creates prescribed temperature outputs.")
-  }
-}
diff --git a/tests/prescribed_temperature_with_diffusion.prm.bak b/tests/prescribed_temperature_with_diffusion.prm.bak
deleted file mode 100644
index 5bd3bf5c48d..00000000000
--- a/tests/prescribed_temperature_with_diffusion.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# A testcase that demonstrates that interpolating material model
-# outputs into the temperature field and diffusing it works.
-#
-# The property copied into the temperature field
-# is a Gaussian with an amplitude of 1, namely exp(-0.5*x*x).
-# We choose the diffusion length scale in a way that its amplitude
-# should be reduced to 0.95 when the diffusion equation is solved.
-
-set Dimension = 2
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-
-subsection Solver parameters
-  subsection Diffusion solver parameters
-    set Diffusion length scale = 0.23241476
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 0.1
-    set Y extent = 10
-    set Y repetitions = 100
-  end
-end
-
-subsection Temperature field
-  set Temperature method = prescribed field with diffusion
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = prescribed temperature material
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = named additional outputs
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/prescribed_velocity.cc.bak b/tests/prescribed_velocity.cc.bak
deleted file mode 100644
index 910cee787e0..00000000000
--- a/tests/prescribed_velocity.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../cookbooks/prescribed_velocity/prescribed_velocity.cc"
diff --git a/tests/prescribed_velocity.prm.bak b/tests/prescribed_velocity.prm.bak
deleted file mode 100644
index 6ee60456eb1..00000000000
--- a/tests/prescribed_velocity.prm.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-## First we set up a unit length box model with uniform everything.
-set Dimension                              = 2
-set End time                               = 0
-
-## Turn prescribed velocities on
-set Prescribe internal velocities = true
-
-subsection Geometry model
-  set Model name = box
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 3
-  set Initial adaptive refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics
-end
-
-subsection Prescribed velocities
-  subsection Indicator function
-    set Variable names = x,y,t
-
-    # Return where to prescribe u_x; u_y; u_z (last one only used if dimension = 3)
-    # 1 if velocity should be prescribed, 0 otherwise
-    set Function expression = if(((x>.1)&(x<.9))&(abs(x-(1-y))<.05),1,0); \
-                                if(((x>.1)&(x<.9))&(abs(x-(1-y))<.05),1,0)
-  end
-
-  subsection Velocity function
-    set Variable names = x,y,t
-
-    # Return u_x; u_y; u_z (u_z only used if in 3d)
-    set Function expression = (exp(-1*abs(x-(1-y))/.05)); \
-                                -(exp(-1*abs(x-(1-y))/.05))
-  end
-end
diff --git a/tests/prescribed_velocity_boundary.cc.bak b/tests/prescribed_velocity_boundary.cc.bak
deleted file mode 100644
index f8e9d98ec96..00000000000
--- a/tests/prescribed_velocity_boundary.cc.bak
+++ /dev/null
@@ -1,446 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-      // based on http://geodynamics.org/hg/cs/AMR/Discontinuous_Stokes with permission
-      void _Inclusion(double pos[2], double r_inclusion, double eta, double *vx, double *vy, double *p)
-      {
-        const double min_eta = 1.0;
-        const double max_eta = eta;
-        const double epsilon = 1; // strain rate
-        const double A(min_eta*(max_eta-min_eta)/(max_eta+min_eta));
-        std::complex<double> phi, psi, dphi;
-        const double offset[2]= {1.0, 1.0};
-        double r2_inclusion = r_inclusion * r_inclusion;
-
-        double x = pos[0]-offset[0];
-        double y = pos[1]-offset[1];
-        double r2 = x*x+y*y;
-
-        std::complex<double> z(x,y);
-        if (r2<r2_inclusion)
-          {
-            // inside the inclusion
-            phi=0;
-            dphi=0;
-            psi=-4*epsilon*(max_eta*min_eta/(min_eta+max_eta))*z;
-          }
-        else
-          {
-            // outside the inclusion
-            phi=-2*epsilon*A*r2_inclusion/z;
-            dphi=-phi/z;
-            psi=-2*epsilon*(min_eta*z+A*r2_inclusion*r2_inclusion/(z*z*z));
-          }
-        double visc = (r2<r2_inclusion)? max_eta : 1.0;
-        std::complex<double> v = (phi - z*conj(dphi) - conj(psi))/(2.0*visc);
-        *vx=v.real();
-        *vy=v.imag();
-        *p=-2*epsilon*dphi.real();
-      }
-
-
-
-
-
-      /**
-       * The exact solution for the Inclusion benchmark.
-       */
-      template <int dim>
-      class FunctionInclusion : public Function<dim>
-      {
-        public:
-          FunctionInclusion (double eta_B) : Function<dim>(dim+2), eta_B_(eta_B) {}
-          virtual void vector_value (const Point<dim>   &p,
-                                     Vector<double>   &values) const
-          {
-            double pos[2]= {p(0),p(1)};
-            AnalyticSolutions::_Inclusion
-            (pos,0.2,eta_B_, &values[0], &values[1], &values[2]);
-          }
-
-        private:
-          double eta_B_;
-      };
-    }
-
-
-
-    template <int dim>
-    class InclusionBoundary : public BoundaryVelocity::Interface<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        InclusionBoundary(): eta_B (1e3)
-        {}
-
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        virtual
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id boundary_id,
-                           const Point<dim> &position) const;
-
-        virtual void initialize ()
-        { }
-
-
-      private:
-
-        double eta_B;
-    };
-
-
-    template <int dim>
-    Tensor<1,dim>
-    InclusionBoundary<dim>::
-    boundary_velocity (const types::boundary_id boundary_id,
-                       const Point<dim> &p) const
-    {
-      Assert (dim == 2, ExcNotImplemented());
-
-      std::cout << "Boundary_velocity called with boundary_id ="
-                << static_cast<int>(boundary_id) << std::endl;
-
-      return Tensor<1,dim>();
-      double pos[2]= {p(0),p(1)};
-
-      Tensor<1,dim> velocity;
-      double pressure;
-      AnalyticSolutions::_Inclusion
-      (pos,0.2,eta_B, &velocity[0], &velocity[1], &pressure);
-
-      return velocity;
-    }
-
-
-
-
-    /**
-     * A material model that describes the "Pure shear/Inclusion" benchmark
-     * of the paper cited in the documentation of the DuretzEtAl namespace.
-     *
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     *
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class InclusionMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const Point<dim> &pos = in.position[i];
-              const double r2 = ( pos[0] - 1.0 ) * ( pos[0] - 1.0 ) + ( pos[1] - 1.0 ) * ( pos[1] - 1.0 );
-              out.viscosities[i] = ( r2 < 0.2 * 0.2 ) ? eta_B : 1.0;
-              out.densities[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.compressibilities[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-              out.specific_heat[i] = 0;
-            }
-        }
-
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        virtual bool is_compressible () const;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-
-
-
-        /**
-         * Returns the viscosity value in the inclusion
-         */
-        double get_eta_B() const;
-
-      private:
-        /**
-         * viscosity value in the inclusion
-         */
-        double eta_B;
-    };
-
-    template <int dim>
-    bool
-    InclusionMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    InclusionMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Inclusion");
-        {
-          prm.declare_entry ("Viscosity jump", "1e3",
-                             Patterns::Double (0),
-                             "Viscosity in the Inclusion.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    InclusionMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection("Inclusion");
-        {
-          eta_B = prm.get_double ("Viscosity jump");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-    template <int dim>
-    double
-    InclusionMaterial<dim>::get_eta_B() const
-    {
-      return eta_B;
-    }
-
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution of the
-      * aspect::MaterialModel::DuretzEtAl::Inclusion material models.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the following paper:
-      * @code
-      *  @Article{DMGT11,
-      *    author =       {T. Duretz and D. A. May and T. V. Gerya and P. J. Tackley},
-      *    title =        {Discretization errors and free surface stabilization in the
-      *                  finite difference and marker-in-cell method for applied
-      *                  geodynamics: {A} numerical study},
-      *    journal =      {Geochemistry Geophysics Geosystems},
-      *    year =         2011,
-      *    volume =       12,
-      *    pages =        {Q07004/1--26}}
-      * @endcode
-      *
-      * @note While this paper summarizes the benchmarks used here, some of the
-      * benchmarks actually originate in earlier papers. For the original
-      * references, see the bibliography of the paper above.
-      * @ingroup Postprocessing
-      */
-    template <int dim>
-    class InclusionPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        virtual
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics);
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    InclusionPostprocessor<dim>::execute (TableHandler &statistics)
-    {
-      std::unique_ptr<Function<dim>> ref_func;
-      if (dynamic_cast<const InclusionMaterial<dim> *>(&this->get_material_model()) != nullptr)
-        {
-          const InclusionMaterial<dim> *
-          material_model
-            = dynamic_cast<const InclusionMaterial<dim> *>(&this->get_material_model());
-
-          ref_func = std::make_unique<AnalyticSolutions::FunctionInclusion<dim>>(material_model->get_eta_B());
-        }
-      else
-        {
-          AssertThrow(false,
-                      ExcMessage("Postprocessor DuretzEtAl only works with the material model SolCx, SolKz, and Inclusion."));
-        }
-
-      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +2);
-
-      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                          dim+2);
-      ComponentSelectFunction<dim> comp_p(dim, dim+2);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_u,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_p,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_p);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_ul2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_pl2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-      std::ostringstream os;
-      os << std::scientific << u_l1
-         << ", " << p_l1
-         << ", " << u_l2
-         << ", " << p_l2;
-
-      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
-    }
-
-
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InclusionBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(InclusionMaterial,
-                                   "InclusionMaterial",
-                                   "A material model that corresponds to the 'Inclusion' benchmark "
-                                   "defined in Duretz et al., G-Cubed, 2011.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(InclusionBoundary,
-                                            "InclusionBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "``inclusion'' benchmark. See the manual and the Kronbichler, Heister "
-                                            "and Bangerth paper on ASPECT for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(InclusionPostprocessor,
-                                  "InclusionPostprocessor",
-                                  "A postprocessor that compares the solution of the benchmarks from "
-                                  "the Duretz et al., G-Cubed, 2011, paper with the one computed by ASPECT "
-                                  "and reports the error. Specifically, it can compute the errors for "
-                                  "the SolCx, SolKz and inclusion benchmarks. The postprocessor inquires "
-                                  "which material model is currently being used and adjusts "
-                                  "which exact solution to use accordingly.")
-  }
-}
diff --git a/tests/prescribed_velocity_boundary.prm.bak b/tests/prescribed_velocity_boundary.prm.bak
deleted file mode 100644
index c7d3b9a94d2..00000000000
--- a/tests/prescribed_velocity_boundary.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# copied from inclusion_2 to test VelocityBoundaryConditions::initialize(indicator)
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 1
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = InclusionMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Strategy                           = thermal energy density
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, InclusionPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/prescribed_velocity_dgp.cc.bak b/tests/prescribed_velocity_dgp.cc.bak
deleted file mode 100644
index 30afa2c63f3..00000000000
--- a/tests/prescribed_velocity_dgp.cc.bak
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/parsed_function.h>
-#include <deal.II/fe/fe_values.h>
-#include <aspect/global.h>
-#include <aspect/utilities.h>
-#include <aspect/simulator_signals.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  // Global variables (to be set by parameters)
-  bool prescribe_internal_velocities;
-
-  // Because we do not initially know what dimension we're in, we need
-  // function parser objects for both 2d and 3d.
-  Functions::ParsedFunction<2> prescribed_velocity_indicator_function_2d (2);
-  Functions::ParsedFunction<3> prescribed_velocity_indicator_function_3d (3);
-  Functions::ParsedFunction<2> prescribed_velocity_function_2d (2);
-  Functions::ParsedFunction<3> prescribed_velocity_function_3d (3);
-
-
-
-  /**
-   * Declare additional parameters.
-   */
-  void declare_parameters(const unsigned int dim,
-                          ParameterHandler &prm)
-  {
-    prm.declare_entry ("Prescribe internal velocities", "false",
-                       Patterns::Bool (),
-                       "Whether or not to use any prescribed internal velocities. "
-                       "Locations in which to prescribe velocities are defined "
-                       "in section ``Prescribed velocities/Indicator function'' "
-                       "and the velocities are defined in section ``Prescribed "
-                       "velocities/Velocity function''. Indicators are evaluated "
-                       "at the center of each cell, and all DOFs associated with "
-                       "the specified velocity component at the indicated cells "
-                       "are constrained."
-                      );
-
-    prm.enter_subsection ("Prescribed velocities");
-    {
-      prm.enter_subsection ("Indicator function");
-      {
-        if (dim == 2)
-          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
-        else
-          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
-      }
-      prm.leave_subsection ();
-
-      prm.enter_subsection ("Velocity function");
-      {
-        if (dim == 2)
-          Functions::ParsedFunction<2>::declare_parameters (prm, 2);
-        else
-          Functions::ParsedFunction<3>::declare_parameters (prm, 3);
-      }
-      prm.leave_subsection ();
-    }
-    prm.leave_subsection ();
-  }
-
-
-
-  template <int dim>
-  void parse_parameters(const Parameters<dim> &,
-                        ParameterHandler &prm)
-  {
-    prescribe_internal_velocities = prm.get_bool ("Prescribe internal velocities");
-    prm.enter_subsection ("Prescribed velocities");
-    {
-      prm.enter_subsection("Indicator function");
-      {
-        try
-          {
-            if (dim == 2)
-              prescribed_velocity_indicator_function_2d.parse_parameters (prm);
-            else
-              prescribed_velocity_indicator_function_3d.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Prescribed velocities.Indicator function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'";
-            throw;
-          }
-      }
-      prm.leave_subsection();
-
-      prm.enter_subsection("Velocity function");
-      {
-        try
-          {
-            if (dim == 2)
-              prescribed_velocity_function_2d.parse_parameters (prm);
-            else
-              prescribed_velocity_function_3d.parse_parameters (prm);
-          }
-        catch (...)
-          {
-            std::cerr << "ERROR: FunctionParser failed to parse\n"
-                      << "\t'Prescribed velocities.Velocity function'\n"
-                      << "with expression\n"
-                      << "\t'" << prm.get("Function expression") << "'";
-            throw;
-          }
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection ();
-  }
-
-
-
-  /**
-   * This function is called by a signal which is triggered after the other constraints
-   * have been calculated. This enables us to define additional constraints in the mass
-   * matrix on any arbitrary degree of freedom in the model space.
-   */
-  template <int dim>
-  void constrain_internal_velocities (const SimulatorAccess<dim> &simulator_access,
-                                      AffineConstraints<double> &current_constraints)
-  {
-    if (prescribe_internal_velocities)
-      {
-        const std::vector<Point<dim>> points = aspect::Utilities::get_unit_support_points(simulator_access);
-        const Quadrature<dim> quadrature (points);
-        FEValues<dim> fe_values (simulator_access.get_fe(), quadrature, update_quadrature_points);
-        typename DoFHandler<dim>::active_cell_iterator cell;
-
-        // Loop over all cells
-        for (cell = simulator_access.get_dof_handler().begin_active();
-             cell != simulator_access.get_dof_handler().end();
-             ++cell)
-          if (! cell->is_artificial())
-            {
-              fe_values.reinit (cell);
-              std::vector<types::global_dof_index> local_dof_indices(simulator_access.get_fe().dofs_per_cell);
-              cell->get_dof_indices (local_dof_indices);
-
-              for (unsigned int q=0; q<quadrature.size(); q++)
-                // If it's okay to constrain this DOF
-                if (current_constraints.can_store_line(local_dof_indices[q]) &&
-                    !current_constraints.is_constrained(local_dof_indices[q]))
-                  {
-                    // Get the velocity component index
-                    const unsigned int c_idx =
-                      simulator_access.get_fe().system_to_component_index(q).first;
-
-                    // If we're on one of the velocity DOFs
-                    if ((c_idx >=
-                         simulator_access.introspection().component_indices.velocities[0])
-                        &&
-                        (c_idx <=
-                         simulator_access.introspection().component_indices.velocities[dim-1]))
-                      {
-                        // Which velocity component is this DOF associated with?
-                        const unsigned int component_direction
-                          = (c_idx
-                             - simulator_access.introspection().component_indices.velocities[0]);
-
-                        // we get time passed as seconds (always) but may want
-                        // to reinterpret it in years
-                        double time = simulator_access.get_time();
-                        if (simulator_access.convert_output_to_years())
-                          time /= year_in_seconds;
-
-                        prescribed_velocity_indicator_function_2d.set_time (time);
-                        prescribed_velocity_indicator_function_3d.set_time (time);
-                        prescribed_velocity_function_2d.set_time (time);
-                        prescribed_velocity_function_3d.set_time (time);
-
-                        const Point<dim> p = fe_values.quadrature_point(q);
-
-                        // Because we defined and parsed our parameter
-                        // file differently for 2d and 3d we need to
-                        // be sure to query the correct object for
-                        // function values. The function parser
-                        // objects expect points of a certain
-                        // dimension, but Point p will be compiled for
-                        // both 2d and 3d, so we need some careful
-                        // casts to make this compile. Casting Point
-                        // objects between 2d and 3d is somewhat
-                        // meaningless but the offending casts will
-                        // never actually be executed because they are
-                        // protected by the if/else statements.
-                        double indicator, u_i;
-                        if (dim == 2)
-                          {
-                            indicator = prescribed_velocity_indicator_function_2d.value
-                                        (reinterpret_cast<const Point<2>&>(p),
-                                         component_direction);
-                            u_i       = prescribed_velocity_function_2d.value
-                                        (reinterpret_cast<const Point<2>&>(p),
-                                         component_direction);
-                          }
-                        else
-                          {
-                            indicator = prescribed_velocity_indicator_function_3d.value
-                                        (reinterpret_cast<const Point<3>&>(p),
-                                         component_direction);
-                            u_i       = prescribed_velocity_function_3d.value
-                                        (reinterpret_cast<const Point<3>&>(p),
-                                         component_direction);
-                          }
-
-                        if (indicator > 0.5)
-                          {
-                            // Add a constraint of the form dof[q] = u_i
-                            // to the list of constraints.
-                            current_constraints.add_line (local_dof_indices[q]);
-                            current_constraints.set_inhomogeneity (local_dof_indices[q], u_i);
-                          }
-                      }
-                  }
-            }
-      }
-  }
-
-  // Connect declare_parameters and parse_parameters to appropriate signals.
-  void parameter_connector ()
-  {
-    SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
-    SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
-
-    SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
-    SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
-  }
-
-  // Connect constraints function to correct signal.
-  template <int dim>
-  void signal_connector (SimulatorSignals<dim> &signals)
-  {
-    signals.post_constraints_creation.connect (&constrain_internal_velocities<dim>);
-  }
-
-  // Tell ASPECT to send signals to the connector functions
-  ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
-  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
-}
diff --git a/tests/prescribed_velocity_dgp.prm.bak b/tests/prescribed_velocity_dgp.prm.bak
deleted file mode 100644
index 85385afdda4..00000000000
--- a/tests/prescribed_velocity_dgp.prm.bak
+++ /dev/null
@@ -1,62 +0,0 @@
-## First we set up a unit length box model with uniform everything.
-set Dimension                              = 2
-set End time                               = 0
-
-## Turn prescribed velocities on
-set Prescribe internal velocities = true
-
-subsection Discretization
-  set Use locally conservative discretization = true
-end
-
-subsection Geometry model
-  set Model name = box
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 3
-  set Initial adaptive refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics
-end
-
-subsection Prescribed velocities
-  subsection Indicator function
-    set Variable names = x,y,t
-
-    # Return where to prescribe u_x; u_y; u_z (last one only used if dimension = 3)
-    # 1 if velocity should be prescribed, 0 otherwise
-    set Function expression = if(((x>.1)&(x<.9))&(abs(x-(1-y))<.05),1,0); \
-                                if(((x>.1)&(x<.9))&(abs(x-(1-y))<.05),1,0)
-  end
-
-  subsection Velocity function
-    set Variable names = x,y,t
-
-    # Return u_x; u_y; u_z (u_z only used if in 3d)
-    set Function expression = (exp(-1*abs(x-(1-y))/.05)); \
-                                -(exp(-1*abs(x-(1-y))/.05))
-  end
-end
diff --git a/tests/prescribed_viscosity_additional_outputs.prm.bak b/tests/prescribed_viscosity_additional_outputs.prm.bak
deleted file mode 100644
index a3c82cca0dd..00000000000
--- a/tests/prescribed_viscosity_additional_outputs.prm.bak
+++ /dev/null
@@ -1,41 +0,0 @@
-# Like grain_size_growth.prm, but check that additional
-# material model outputs can be postprocessed correctly
-# in the prescribed viscosity material model.
-
-############### Global parameters
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/grain_size_growth.prm
-
-set End time = 0
-
-subsection Material model
-  set Model name = prescribed viscosity
-
-  subsection Prescribed viscosity
-    set Base model = grain size
-
-    subsection Indicator function
-      # Return where to prescribe the viscosity
-      set Function expression = if(x>50000, 1, 0)
-    end
-
-    subsection Viscosity function
-      set Function expression = 1e22
-    end
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics,temperature statistics, velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables = viscosity, named additional outputs
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/prescribed_viscosity_happy.prm.bak b/tests/prescribed_viscosity_happy.prm.bak
deleted file mode 100644
index d88a4fb44f8..00000000000
--- a/tests/prescribed_viscosity_happy.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-set Dimension   = 2
-set CFL number  = 0.5
-set End time    = 0
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1e3
-    set Y extent = 1e3
-    set X repetitions = 1
-    set Y repetitions = 1
-  end
-end
-
-subsection Mesh refinement
-  set Time steps between mesh refinement = 5
-  set Initial global refinement = 5
-  set Initial adaptive refinement = 4
-  set Strategy = viscosity
-  set Skip solvers on initial refinement = true
-end
-
-subsection Material model
-  set Model name = prescribed viscosity
-  set Material averaging = geometric average only viscosity
-
-  subsection Prescribed viscosity
-    set Base model = simple
-
-    subsection Indicator function
-      set Variable names = x,y,t
-
-      # Return where to prescribe u_x; u_y; u_z
-      # (last one only used if dimension = 3)
-      # 1 if velocity should be prescribed, 0 otherwise
-      set Function expression = if(y>425,if(x<500, \
-      if(sqrt((x-250)*(x-250)+(y-750)*(y-750))<100,1,0), \
-      if(sqrt((x-750)*(x-750)+(y-750)*(y-750))<100,1,0)), \
-      if(sqrt((x-500)*(x-500)+(y-500)*(y-500))>200 & sqrt((x-500)*(x-500)+(y-500)*(y-500))<300,1,0))
-    end
-
-    subsection Viscosity function
-      set Variable names = x,y,t
-
-      # Return u_x; u_y; u_z (u_z only used if in 3d)
-      set Function expression = if(y>425,if(x<500, \
-      if(sqrt((x-250)*(x-250)+(y-750)*(y-750))<100,if(y<775,if(sqrt((x-250)*(x-250)+(y-750)*(y-750))>25,7.5e25,1e25),1e26),0), \
-      if(sqrt((x-750)*(x-750)+(y-750)*(y-750))<100,if(y<775,if(sqrt((x-750)*(x-750)+(y-750)*(y-750))>25,7.5e25,1e25),1e26),0)), \
-      if(sqrt((x-500)*(x-500)+(y-500)*(y-500))>200 & sqrt((x-500)*(x-500)+(y-500)*(y-500))<300,1e24*sqrt((x-500)*(x-500)+(y-500)*(y-500))/3,0))
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables = material properties
-    set Output format                 = gnuplot
-    set Number of grouped files       = 0
-  end
-end
diff --git a/tests/pressure_boundary.prm.bak b/tests/pressure_boundary.prm.bak
deleted file mode 100644
index 0f92413fee8..00000000000
--- a/tests/pressure_boundary.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# like refine_vel.prm, but run the "spherical velocity statistics"
-# postprocessor
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e300
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Pressure normalization = volume
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Additional refinement times              = 0,0
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, boundary pressures
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/pressure_compatibility.prm.bak b/tests/pressure_compatibility.prm.bak
deleted file mode 100644
index 035384a4bff..00000000000
--- a/tests/pressure_compatibility.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# A test, whether we apply the right pressure compatibility
-# correction in the case of prescribed boundary conditions.
-# This test is essentially similar to the platelike-boundary
-# cookbook but uses a strongly compressible material model.
-# Previously we did not correct the pressure RHS in this setup,
-# which prevented it from converging.
-
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.1
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Reference compressibility     = 7e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heat flux statistics, velocity statistics
-end
diff --git a/tests/pressure_compatibility_2.prm.bak b/tests/pressure_compatibility_2.prm.bak
deleted file mode 100644
index b8e200639c4..00000000000
--- a/tests/pressure_compatibility_2.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# This is a compressible test case that shall
-# test the behavior of the pressure compatibility
-# mechanism in case of prescribed normal velocities
-# integrated over the boundaries. It is converging
-# in this setup, but if the solver tolerance is
-# decreased or the prescribed normal velocity is
-# increased it fails to converge, which is exactly
-# the behavior we intend.
-
-set CFL number                             = 1
-set End time                               = 400
-set Adiabatic surface temperature          = 0.5
-set Use years in output instead of seconds = false
-set Pressure normalization                 = no
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 2
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 0.01
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density = 1
-    set Reference specific heat = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity = 1
-    set Thermal conductivity = 1e-7
-    set Reference compressibility = 1e-6
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,3
-  set Prescribed velocity boundary indicators = 2:function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1e-9
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, temperature statistics
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/pressure_compatibility_3.prm.bak b/tests/pressure_compatibility_3.prm.bak
deleted file mode 100644
index b37e5210a48..00000000000
--- a/tests/pressure_compatibility_3.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# This is a compressible test case that tests
-# the behavior of the pressure compatibility
-# mechanism in case of prescribed normal velocities
-# whose integral over the boundaries is non-zero.
-# This checks that the linear solver converges, even
-# with low solver tolerance and a significant in- or
-# outflow.
-
-set CFL number                             = 1
-set End time                               = 50
-set Adiabatic surface temperature          = 0.5
-set Use years in output instead of seconds = false
-set Pressure normalization                 = no
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 2
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 0.01
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density = 1
-    set Reference specific heat = 1
-    set Thermal expansion coefficient = 1
-    set Viscosity = 1
-    set Thermal conductivity = 1e-7
-    set Reference compressibility = 1e-6
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,3
-  set Prescribed velocity boundary indicators = 2:function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;0.01
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, temperature statistics, mass flux statistics
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/pressure_compatibility_4.prm.bak b/tests/pressure_compatibility_4.prm.bak
deleted file mode 100644
index c453722fd3b..00000000000
--- a/tests/pressure_compatibility_4.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# This is a compressible test case that tests
-# the behavior of the pressure compatibility
-# mechanism in case of prescribed normal velocities
-# whose integral over the boundaries is zero when
-# using the exact values, but non-zero when using the
-# interpolated values (i.e. constant at the top, and
-# sin(x) at the bottom). This checks that the linear
-# solver converges, even with a very low solver tolerance.
-
-set CFL number                             = 1
-set End time                               = 5e-5
-set Adiabatic surface temperature          = 0.5
-set Use years in output instead of seconds = false
-set Pressure normalization                 = no
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 2
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 0.01
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density = 1
-    set Reference specific heat = 1
-    set Thermal expansion coefficient = 0
-    set Viscosity = 1
-    set Thermal conductivity = 1e-7
-    set Reference compressibility = 1e-6
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;if(y<0.5,1e3*(1-cos(1.0)),1e3*sin(x))
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, temperature statistics, mass flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-15
-  end
-end
diff --git a/tests/pressure_compatibility_dg.prm.bak b/tests/pressure_compatibility_dg.prm.bak
deleted file mode 100644
index faab4b7cd27..00000000000
--- a/tests/pressure_compatibility_dg.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-# like pressure_compatibility.prm but with DG pressure
-# MPI: 2
-
-include $ASPECT_SOURCE_DIR/tests/pressure_compatibility.prm
-
-
-subsection Discretization
-  set Use locally conservative discretization = true
-end
diff --git a/tests/pressure_compatibility_dg_direct.prm.bak b/tests/pressure_compatibility_dg_direct.prm.bak
deleted file mode 100644
index e3e760b55ca..00000000000
--- a/tests/pressure_compatibility_dg_direct.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-# like pressure_compatibility.prm but with DG pressure and a direct solver
-# MPI: 2
-
-include $ASPECT_SOURCE_DIR/tests/pressure_compatibility.prm
-
-
-subsection Discretization
-  set Use locally conservative discretization = true
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/pressure_compatibility_direct.prm.bak b/tests/pressure_compatibility_direct.prm.bak
deleted file mode 100644
index ae9795796d7..00000000000
--- a/tests/pressure_compatibility_direct.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-# like pressure_compatibility.prm but with a direct solver
-# MPI: 2
-
-include $ASPECT_SOURCE_DIR/tests/pressure_compatibility.prm
-
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
diff --git a/tests/pressure_constraint.cc.bak b/tests/pressure_constraint.cc.bak
deleted file mode 100644
index 2b1f1a84868..00000000000
--- a/tests/pressure_constraint.cc.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <deal.II/base/parameter_handler.h>
-#include <deal.II/base/parsed_function.h>
-#include <deal.II/fe/fe_values.h>
-#include <aspect/global.h>
-#include <aspect/simulator_signals.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  template <int dim>
-  void modify_constraints (const SimulatorAccess<dim> &simulator_access,
-                           AffineConstraints<double> &current_constraints)
-  {
-    // Hack: the first pressure dof is only this easy to compute if we don't
-    // use a direct solver or reorganize the blocks of the linear system in
-    // some other way. Good enough for this test though!
-    const types::global_dof_index first_pressure_dof =
-      simulator_access.introspection().system_dofs_per_block[0];
-
-    const double value = 100;
-
-    current_constraints.add_line(first_pressure_dof);
-    current_constraints.set_inhomogeneity (first_pressure_dof, value);
-
-    std::cout << "adding constraint idx= " << first_pressure_dof
-              << " to value= " << value
-              << std::endl;
-  }
-
-  // Connect constraints function to correct signal.
-  template <int dim>
-  void signal_connector (SimulatorSignals<dim> &signals)
-  {
-    signals.post_constraints_creation.connect (&modify_constraints<dim>);
-  }
-
-  // Tell ASPECT to send signals to the connector functions
-  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>, signal_connector<3>)
-}
diff --git a/tests/pressure_constraint.prm.bak b/tests/pressure_constraint.prm.bak
deleted file mode 100644
index 55d04041fa8..00000000000
--- a/tests/pressure_constraint.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-# based on poiseuille_2d.prm but add a pressure constraint to one
-# pressure DoF
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0.1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Pressure normalization = no
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 0
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function
-  set Zero velocity boundary indicators       = 2, 3
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z*(1-z);0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, matrix statistics
-end
diff --git a/tests/pressure_scaling_signal.cc.bak b/tests/pressure_scaling_signal.cc.bak
deleted file mode 100644
index 0a0c76af191..00000000000
--- a/tests/pressure_scaling_signal.cc.bak
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/inclusion/inclusion.cc"
-
-#include <aspect/simulator_signals.h>
-
-
-double my_signal(const double pressure_scaling, const double reference_viscosity, const double length_scale)
-{
-  std::cout << "pressure_scaling = " << pressure_scaling
-            << " reference_viscosity = " << reference_viscosity
-            << " length_scale = " << length_scale << std::endl;
-  // Now change it to something different:
-  return 42.0;
-}
-
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  std::cout << "* Connecting signals" << std::endl;
-  signals.modify_pressure_scaling.connect(&my_signal);
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/pressure_scaling_signal.prm.bak b/tests/pressure_scaling_signal.prm.bak
deleted file mode 100644
index a7704a9ad35..00000000000
--- a/tests/pressure_scaling_signal.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# copy of inclusion_4.prm to test the signal modify_pressure_scaling.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = volume
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 1
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = InclusionMaterial
-
-  subsection Inclusion
-    set Viscosity jump = 1e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = thermal energy density
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: InclusionBoundary, 1: InclusionBoundary, 2: InclusionBoundary, 3: InclusionBoundary
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, InclusionPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/principal_deviatoric_stress.cc.bak b/tests/principal_deviatoric_stress.cc.bak
deleted file mode 100644
index c45fb20207c..00000000000
--- a/tests/principal_deviatoric_stress.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "simple_shear.cc"
diff --git a/tests/principal_deviatoric_stress.prm.bak b/tests/principal_deviatoric_stress.prm.bak
deleted file mode 100644
index d0b0fd38671..00000000000
--- a/tests/principal_deviatoric_stress.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-# This is a copy of simple_shear.prm that tests the 'principal stress'
-# postprocessor when computing principal stresses for the deviatoric stress
-# only. Due to the nature of the benchmark the principal deviatoric stress
-# should be 200/-200 Pa respectively (see simple_shear.prm) for a description
-# of the benchmark.
-
-set Dimension                              = 2
-set End time                               = 0.025
-set Use years in output instead of seconds = false
-set Output directory = simple_shear
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set X periodic = true
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-
-  subsection Function
-    set Function expression = if (y < 0.5, -1, 1); 0
-  end
-end
-
-subsection Material model
-  set Model name = finite strain
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0;0.0;0.0;1.0
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, composition statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = strain rate, stress, principal stress
-    set Output format = gnuplot
-    set Time between graphical output = 0.05
-
-    subsection Principal stress
-      set Use deviatoric stress = true
-    end
-  end
-
-  subsection Particles
-    set Time between data output = 0.05
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain
-  set Particle generator name = ascii file
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/finite_strain/
-      set Data file name = simple_shear_particle.dat
-    end
-  end
-end
diff --git a/tests/prm_distance_polygon.cc.bak b/tests/prm_distance_polygon.cc.bak
deleted file mode 100644
index 50d48fda0f8..00000000000
--- a/tests/prm_distance_polygon.cc.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-#include <iostream>
-
-int f()
-{
-  using namespace aspect::Utilities;
-
-  const int dim=3;
-
-  // A square polygon
-  std::vector<Point<2>> polygon(4);
-  polygon[0] = Point<2>(0.0,0.0);
-  polygon[1] = Point<2>(1.0,0.0);
-  polygon[2] = Point<2>(1.0,1.0);
-  polygon[3] = Point<2>(0.0,1.0);
-
-  // A concave polygon
-  std::vector<Point<2>> concave_polygon(5);
-  concave_polygon[0] = Point<2>(0.0,0.0);
-  concave_polygon[1] = Point<2>(1.0,0.0);
-  concave_polygon[2] = Point<2>(1.0,1.0);
-  concave_polygon[3] = Point<2>(0.5,0.5);
-  concave_polygon[4] = Point<2>(0.0,1.0);
-
-  // A selfcrossing polygon
-  std::vector<Point<2>> crossing_polygon(4);
-  crossing_polygon[0] = Point<2>(0.0,0.0);
-  crossing_polygon[1] = Point<2>(1.0,0.0);
-  crossing_polygon[2] = Point<2>(1.0,-1.0);
-  crossing_polygon[3] = Point<2>(0.0,1.0);
-
-
-  // Some points inside and outside the polygon
-  Point<2> points[] = {Point<2>(0.5,-1), Point<2>(0.5,0.5), Point<2>(0.001,0.2), Point<2>(2.0,2.0), Point<2>(0.25,0.70)};
-
-  std::cout << "Testing distance to polygon function with the following parameters: (polygon 1) "
-            << polygon[0] << ", " << polygon[1] << ", " << polygon[2] << ", " << polygon[3] << ", "
-            << "(polygon 2) " << concave_polygon[0] << ", " << concave_polygon[1] << ", " << concave_polygon[2] << ", " << concave_polygon[3] << ", " << concave_polygon[4] << ", "
-            << "(polygon 3) " << crossing_polygon[0] << ", " << crossing_polygon[1] << ", " << crossing_polygon[2] << ", " << crossing_polygon[3]
-            << ", (points) "
-            << points[0] << ", " << points[1] << ", " << points[2] << ", " << points[3] << ", " << points[4] << std::endl;
-
-  for (unsigned int i = 0; i < 5; i++)
-    {
-      std::cout << "Minimal distance of point " << points[i] << " to polygon 1 = " << signed_distance_to_polygon<dim>(polygon,points[i]) << std::endl;
-      std::cout << "Minimal distance of point " << points[i] << " to polygon 2 = " << signed_distance_to_polygon<dim>(concave_polygon,points[i]) << std::endl;
-      std::cout << "Minimal distance of point " << points[i] << " to polygon 3 = " << signed_distance_to_polygon<dim>(crossing_polygon,points[i]) << std::endl;
-    }
-
-  exit(0);
-  return 42;
-}
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/prm_distance_polygon.prm.bak b/tests/prm_distance_polygon.prm.bak
deleted file mode 100644
index 583a5b0da38..00000000000
--- a/tests/prm_distance_polygon.prm.bak
+++ /dev/null
@@ -1 +0,0 @@
-set Additional shared libraries = tests/libprm_distance_polygon.so
diff --git a/tests/prm_polygon_in_out.cc.bak b/tests/prm_polygon_in_out.cc.bak
deleted file mode 100644
index c9a9b1d222e..00000000000
--- a/tests/prm_polygon_in_out.cc.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/geometry_model/initial_topography_model/interface.h>
-#include <aspect/geometry_model/initial_topography_model/prm_polygon.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-
-int f()
-{
-  using namespace aspect;
-  const int dim=3;
-  std::string parameters_clockwise = "100 > 0,0;0,5;5,5;5,0 & -100 > 10,10;10,15;15,15";
-  std::string parameters_anticlockwise = "100 > 0,0;5,0;5,5;0,5 & -100 > 10,10;15,15;10,15";
-  InitialTopographyModel::PrmPolygon<dim> topo_clockwise;
-  InitialTopographyModel::PrmPolygon<dim> topo_anticlockwise;
-
-  ParameterHandler prm_clockwise;
-  topo_clockwise.declare_parameters(prm_clockwise);
-  prm_clockwise.enter_subsection("Geometry model");
-  prm_clockwise.enter_subsection ("Initial topography model");
-  prm_clockwise.enter_subsection ("Prm polygon");
-  prm_clockwise.set ("Topography parameters", parameters_clockwise);
-  prm_clockwise.leave_subsection();
-  prm_clockwise.leave_subsection();
-  prm_clockwise.leave_subsection();
-
-  ParameterHandler prm_anticlockwise;
-  topo_anticlockwise.declare_parameters(prm_anticlockwise);
-  prm_anticlockwise.enter_subsection("Geometry model");
-  prm_anticlockwise.enter_subsection ("Initial topography model");
-  prm_anticlockwise.enter_subsection ("Prm polygon");
-  prm_anticlockwise.set ("Topography parameters", parameters_anticlockwise);
-  prm_anticlockwise.leave_subsection();
-  prm_anticlockwise.leave_subsection();
-  prm_anticlockwise.leave_subsection();
-
-  topo_clockwise.parse_parameters(prm_clockwise);
-  topo_anticlockwise.parse_parameters(prm_anticlockwise);
-
-  Point<2> points[] = {Point<2>(-1,-1),Point<2>(0,0),Point<2>(0.001,0),Point<2>(0,0.001),Point<2>(0.001,0.001),
-                       Point<2>(0,-0.001),Point<2>(-0.001,-0.001),Point<2>(-0.01,2.5),Point<2>(0,2.5),Point<2>(0.01,2.5),
-                       Point<2>(0,4.99),Point<2>(0,5),Point<2>(0.01,5),Point<2>(2.5,5),Point<2>(2.5,-0.01),
-                       Point<2>(2.5,0),Point<2>(2.5,0.01),Point<2>(4.99,0),Point<2>(5,0),Point<2>(5,0.01),
-                       Point<2>(5,2.5),Point<2>(4.99,5),Point<2>(5,4.99),Point<2>(5,5),Point<2>(5,5.01),
-                       Point<2>(1,1),Point<2>(12.5,12),Point<2>(11.5,12),Point<2>(15,10),Point<2>(14,10),
-                       Point<2>(15,11),Point<2>(5,6),Point<2>(6,5),Point<2>(0,-1),Point<2>(-1,0),
-                       Point<2>(-1,5),Point<2>(0,6),Point<2>(5,-1),Point<2>(6,0),Point<2>(6,-1),
-                       Point<2>(16,16),Point<2>(12.5,15),Point<2>(10,12.5),Point<2>(10,15),Point<2>(10,10)
-                      };
-
-  std::cout << "Testing prm polygon plugin with the following parameters: (clockwise) " << parameters_clockwise << ", (anticlockwise) " << parameters_anticlockwise << std::endl;
-  for (unsigned int i = 0; i < 45; i++)
-    {
-      std::cout << "Clockwise topo at     (" << points[i] << ") = " << topo_clockwise.value(points[i]) << std::endl;
-      std::cout << "Anticlockwise Topo at (" << points[i] << ") = " << topo_anticlockwise.value(points[i]) << std::endl;
-    }
-
-  exit(0);
-  return 42;
-}
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/prm_polygon_in_out.prm.bak b/tests/prm_polygon_in_out.prm.bak
deleted file mode 100644
index 2f9359eb8db..00000000000
--- a/tests/prm_polygon_in_out.prm.bak
+++ /dev/null
@@ -1 +0,0 @@
-set Additional shared libraries = tests/libprm_polygon_in_out.so
diff --git a/tests/prmbackslash.prm.bak b/tests/prmbackslash.prm.bak
deleted file mode 100644
index 63063c53811..00000000000
--- a/tests/prmbackslash.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# a test that tests #
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = \
-1e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Maximum time step                      = 42
-
-# \ test
-# bla
-
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-# The parameters below this comment were created by the update script
-# as replacement for the old 'Model settings' subsection. They can be
-# safely merged with any existing subsections with the same name.
-
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-  set End step                  = 5
-end
diff --git a/tests/prmbackslash_2.cc.bak b/tests/prmbackslash_2.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/prmbackslash_2.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/prmbackslash_2.prm.bak b/tests/prmbackslash_2.prm.bak
deleted file mode 100644
index 7a211a97e07..00000000000
--- a/tests/prmbackslash_2.prm.bak
+++ /dev/null
@@ -1,156 +0,0 @@
-# Based on the sol_c\
-x_2.prm test input, split\
- every input file after 20
-# characters with a \
-backslash. In some cases,\
- split it more than once.
-# The output should \
-still be the same.
-
-
-set Dimension = 2
-
-set CFL number      \
-                       = \
-1.0
-set End time        \
-                       = \
-0
-
-
-set Resume computati\
-on                     = \
-false
-set Start time      \
-                       = \
-0
-set Adiabatic surfac\
-e temperature          = \
-0
-set Surface pressure\
-                       = \
-0
-set Use years in out\
-put instead of seconds = \
-false
-set Nonlinear solver \
- scheme                = \
-no Advection, iterated Stokes
-
-subsection Boundary \
-temperature model
-  set Model name = b\
-ox
-end
-
-
-subsection Discretiz\
-ation
-  set Stokes velocit\
-y polynomial degree      \
- = 2
-  set Temperature po\
-lynomial degree          \
- = 2
-  set Use locally co\
-nservative discretization\
- = false
-  subsection Stabili\
-zation parameters
-    set alpha = 2
-    set beta  = 0.07\
-8
-    set cR    = 0.5 \
-
-  end
-end
-
-
-subsection Geometry \
-model
-  set Model name = b\
-ox
-
-  subsection Box
-    set X extent = 1\
-
-    set Y extent = 1\
-
-    set Z extent = 1\
-
-  end
-end
-
-
-subsection Gravity m\
-odel
-  set Model name = v\
-ertical
-end
-
-
-subsection Initial t\
-emperature model
-  set Model name = p\
-erturbed box
-end
-
-
-subsection Material \
-model
-  set Model name = S\
-olCxMaterial
-end
-
-
-subsection Mesh refi\
-nement
-  set Initial adapti\
-ve refinement        = 0 \
-
-  set Initial global \
- refinement          = 2 \
-
-
-  set Strategy      \
-                     = de\
-nsity, temperature
-end
-
-
-subsection Boundary temp\
-erature model
-  set Fixed temperat\
-ure boundary indicators  \
- = 0, 1
-end
-subsection Boundary velo\
-city model
-  set Tangential vel\
-ocity boundary indicators\
- = 0,1,2,3
-end
-
-
-subsection Postproce\
-ss
-  set List of postpr\
-ocessors = SolCxPostprocessor
-  subsection Depth a\
-verage
-    set Time between \
- graphical output = 1e8
-  end
-
-  subsection Visuali\
-zation
-    set Number of gr\
-ouped files       = 0
-    set Output forma\
-t                 = gnupl\
-ot
-    set Time between \
- graphical output = 0   #\
- default: 1e8
-  end
-end
diff --git a/tests/projected_density_vertical_pipe.cc.bak b/tests/projected_density_vertical_pipe.cc.bak
deleted file mode 100644
index 6856cf8980d..00000000000
--- a/tests/projected_density_vertical_pipe.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/compressibility_formulations/plugins/compressibility_formulations.cc"
diff --git a/tests/projected_density_vertical_pipe.prm.bak b/tests/projected_density_vertical_pipe.prm.bak
deleted file mode 100644
index 608164a1ba8..00000000000
--- a/tests/projected_density_vertical_pipe.prm.bak
+++ /dev/null
@@ -1,31 +0,0 @@
-# This is a test for the benchmark described in
-# $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe
-
-include $ASPECT_SOURCE_DIR/benchmarks/compressibility_formulations/vertical_pipe/vertical_pipe.prm
-
-
-# It makes sure that boundary conditions are not applied to the projected density field
-
-# Fewer time steps, higher solver tolerance
-set End time                    = 2.2e6
-set Nonlinear solver tolerance  = 1e-5
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = true
-  set Fixed composition boundary indicators = top, bottom
-  set Model name = box
-
-  # The test is to make sure these values are ignored
-  subsection Box
-    set Bottom composition = 2000
-    set Top composition = 3000
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, mass flux statistics, material statistics, composition statistics
-end
-
-subsection Discretization
-  set Use discontinuous composition discretization = false
-end
diff --git a/tests/pure_shear.cc.bak b/tests/pure_shear.cc.bak
deleted file mode 100644
index c45fb20207c..00000000000
--- a/tests/pure_shear.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "simple_shear.cc"
diff --git a/tests/pure_shear.prm.bak b/tests/pure_shear.prm.bak
deleted file mode 100644
index 80d8517d4e6..00000000000
--- a/tests/pure_shear.prm.bak
+++ /dev/null
@@ -1,145 +0,0 @@
-# This parameter file reproduces an analytical benchmark for the evolution
-# of finite strain in a model of pure shear as described (for a specific
-# application) in McKenzie & Jackson (1983): "The relationship between
-# strain rates, crustal thickening, paleomagnetism, finite strain and
-# fault movements within a deforming zone." They show that the analytical
-# solution for the deformation gradient tensor F in pure shear deformation is:
-#
-# F_xx = e^(u_x,x * t)
-# F_xy = 0
-# F_yx = 0
-# F_yy = e^(-u_x,x * t),
-#
-# where u is the velocity, t is time, and a comma represents a derivative
-# in that particular direction. u_x,x in this example is equivalent to
-# -u_y,y so that also: F_yy = e^(u_y,y * t) which is intuitive.
-# For this benchmark it is important to recognize that the deformation in
-# this model is actually only "pure" pure shear at the origin, since the
-# deformation field around is a mixture of pure shear and a rotational
-# component. Also the value of u_x,x at the origin is not prescribed
-# directly, but is a model output, because we only know velocity profiles
-# for the top and right boundaries. Using the computed velocity field we
-# can calculate u_x,x approximately at the origin to be 1.253, and therefore
-# expect:
-# F_xx (t=1.0) = 3.501
-# F_yy (t=1.0) = 0.2856
-# This parameter file tracks the finite strain in two ways, once by using
-# compositional fields as illustrated in the finite strain cookbook, and
-# once by using a particle particle that sits and remains at the origin.
-# The results should of course be the same.
-#
-# Numerical results for particle tracking show excellent agreement:
-# F_xx (t=1.0) = 3.50088
-# F_yy (t=1.0) = 0.285643
-#
-# Numerical results for compositional fields also show good results.
-# F_xx (t=1.0) = 3.49776
-# F_yy (t=1.0) = 0.286723
-# The compositional field results are slightly less accurate, probably due to
-# numerical diffusion, but were found to converge against the analytical
-# values with increasing resolution.
-
-set Dimension                              = 2
-set End time                               = 0.025
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom
-  set Prescribed velocity boundary indicators = top:function, right:function
-
-  subsection Function
-    set Function expression = 1-y; x-1
-  end
-end
-
-subsection Material model
-  set Model name = finite strain
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0;0.0;0.0;1.0
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, visualization, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = strain rate, shear stress, principal stress
-    set Output format = gnuplot
-    set Time between graphical output = 0.05
-  end
-
-  subsection Particles
-    set Time between data output = 0.05
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain
-  set Particle generator name = ascii file
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/finite_strain/
-      set Data file name = pure_shear_particle.dat
-    end
-  end
-end
diff --git a/tests/q1_q1.cc.bak b/tests/q1_q1.cc.bak
deleted file mode 100644
index 7a614ac255c..00000000000
--- a/tests/q1_q1.cc.bak
+++ /dev/null
@@ -1,474 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Check the Donea-Huerta benchmark using the Q1 x Q1 element
-
-#include <aspect/simulator.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/utilities.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-namespace aspect
-{
-  namespace DoneaHuertaBenchmark
-  {
-    using namespace dealii;
-
-    namespace AnalyticSolutions
-    {
-
-      Tensor<1,2>
-      DoneaHuerta_velocity (const Point<2> &pos,
-                            const double /*beta*/)
-      {
-        const double x = pos[0];
-        const double y = pos[1];
-        const double v_x =  x*x*(1.-x)*(1.-x)*(2.*y-6.*y*y+4.*y*y*y) ;
-        const double v_y = -y*y*(1.-y)*(1.-y)*(2.*x-6.*x*x+4.*x*x*x) ;
-        return Point<2> (v_x,v_y);
-      }
-
-      double
-      DoneaHuerta_pressure (const Point<2> &pos,
-                            const double /*beta*/)
-      {
-        const double x = pos[0];
-        return x*(1.-x)-1./6.;
-      }
-
-
-      template <int dim>
-      class FunctionDoneaHuerta : public Function<dim>
-      {
-        public:
-          FunctionDoneaHuerta (const double beta)
-            :
-            Function<dim>(dim+2),
-            beta_(beta)
-          {}
-
-          virtual void vector_value (const Point<dim>   &pos,
-                                     Vector<double>   &values) const
-          {
-            Assert (dim == 2, ExcNotImplemented());
-            Assert (values.size() >= 4, ExcInternalError());
-
-            const Point<2> p (pos[0], pos[1]);
-
-            const Tensor<1,2> v = AnalyticSolutions::DoneaHuerta_velocity (p, beta_);
-            values[0] = v[0];
-            values[1] = v[1];
-            values[2] = AnalyticSolutions::DoneaHuerta_pressure (p, beta_);
-          }
-
-        private:
-          const double beta_;
-      };
-    }
-
-
-
-    template <int dim>
-    class DoneaHuertaBoundary : public BoundaryVelocity::Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        DoneaHuertaBoundary();
-
-        /**
-         * Return the boundary velocity as a function of position.
-         */
-        virtual
-        Tensor<1,dim>
-        boundary_velocity (const types::boundary_id ,
-                           const Point<dim> &position) const;
-
-      private:
-        const double beta;
-    };
-
-
-    /**
-     * @note This benchmark only talks about the flow field, not about a
-     * temperature field. All quantities related to the temperature are
-     * therefore set to zero in the implementation of this class.
-     _r*
-     * @ingroup MaterialModels
-     */
-    template <int dim>
-    class DoneaHuertaMaterial : public MaterialModel::Interface<dim>
-    {
-      public:
-        /**
-         * @name Physical parameters used in the basic equations
-         * @{
-         */
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const
-        {
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              out.viscosities[i] = 1.;
-              out.densities[i] = 1;
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 0;
-              out.thermal_expansion_coefficients[i] = 0;
-              out.thermal_conductivities[i] = 0.0;
-            }
-        }
-        /**
-         * @}
-         */
-
-        /**
-         * @name Qualitative properties one can ask a material model
-         * @{
-         */
-
-        /**
-         * Return whether the model is compressible or not.
-         * Incompressibility does not necessarily imply that the density is
-         * constant; rather, it may still depend on temperature or pressure.
-         * In the current context, compressibility means whether we should
-         * solve the continuity equation as $\nabla \cdot (\rho \mathbf u)=0$
-         * (compressible Stokes) or as $\nabla \cdot \mathbf{u}=0$
-         * (incompressible Stokes).
-         */
-        virtual bool is_compressible () const;
-        /**
-         * @}
-         */
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-
-
-
-        /**
-         * Returns the viscosity value in the inclusion
-         */
-        double get_beta() const;
-
-        /**
-         * viscosity value in the inclusion
-         */
-        double beta;
-    };
-
-
-    template <int dim>
-    bool
-    DoneaHuertaMaterial<dim>::
-    is_compressible () const
-    {
-      return false;
-    }
-
-    template <int dim>
-    void
-    DoneaHuertaMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      //create a global section in the parameter file for parameters
-      //that describe this benchmark. note that we declare them here
-      //in the material model, but other kinds of plugins (e.g., the gravity
-      //model below) may also read these parameters even though they do not
-      //declare them
-      prm.enter_subsection("DoneaHuerta benchmark");
-      {
-        prm.declare_entry("Viscosity parameter", "1",
-                          Patterns::Double (),
-                          "Viscosity parameter beta in the DoneaHuerta benchmark.");
-      }
-      prm.leave_subsection();
-    }
-
-
-    template <int dim>
-    void
-    DoneaHuertaMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("DoneaHuerta benchmark");
-      {
-        beta = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-    }
-
-
-    template <int dim>
-    double
-    DoneaHuertaMaterial<dim>::get_beta() const
-    {
-      return beta;
-    }
-
-    template <int dim>
-    DoneaHuertaBoundary<dim>::DoneaHuertaBoundary ()
-      :
-      beta (0)
-    {}
-
-
-
-    template <>
-    Tensor<1,2>
-    DoneaHuertaBoundary<2>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<2> &p) const
-    {
-      const DoneaHuertaMaterial<2> *
-      material_model
-        = dynamic_cast<const DoneaHuertaMaterial<2> *>(&this->get_material_model());
-      return AnalyticSolutions::DoneaHuerta_velocity (p, material_model->get_beta());
-    }
-
-
-
-    template <>
-    Tensor<1,3>
-    DoneaHuertaBoundary<3>::
-    boundary_velocity (const types::boundary_id ,
-                       const Point<3> &) const
-    {
-      Assert (false, ExcNotImplemented());
-      return Tensor<1,3>();
-    }
-
-
-
-
-    /**
-     *gravity model for the DoneaHuerta benchmark
-    */
-
-    template <int dim>
-    class DoneaHuertaGravity : public aspect::GravityModel::Interface<dim>
-    {
-      public:
-        virtual Tensor<1,dim> gravity_vector (const Point<dim> &pos) const;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-        */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-
-        double beta;
-    };
-
-
-    template <int dim>
-    Tensor<1,dim>
-    DoneaHuertaGravity<dim>::
-    gravity_vector(const Point<dim> &pos) const
-    {
-      const double x=pos[0];
-      const double y=pos[1];
-      Tensor<1,dim> g;
-      g[0]= ( (12.-24.*y)*x*x*x*x + (-24.+48.*y)*x*x*x + (-48.*y+72.*y*y-48.*y*y*y+12.)*x*x
-              + (-2.+24.*y-72.*y*y+48.*y*y*y)*x + 1.-4.*y+12.*y*y-8.*y*y*y );
-
-      g[1]= ( (8.-48.*y+48.*y*y)*x*x*x + (-12.+72.*y-72*y*y)*x*x
-              +  (4.-24.*y+48.*y*y-48.*y*y*y+24.*y*y*y*y)*x - 12.*y*y + 24.*y*y*y -12.*y*y*y*y);
-      return g;
-    }
-
-    template <int dim>
-    void
-    DoneaHuertaGravity<dim>::declare_parameters (ParameterHandler &/*prm*/)
-    {
-      //nothing to declare here. This plugin will however, read parameters
-      //declared by the material model in the "Burstedde benchmark" section
-    }
-
-    template <int dim>
-    void
-    DoneaHuertaGravity<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("DoneaHuerta benchmark");
-      {
-        beta = prm.get_double ("Viscosity parameter");
-      }
-      prm.leave_subsection();
-    }
-
-
-
-
-
-    /**
-      * A postprocessor that evaluates the accuracy of the solution.
-      *
-      * The implementation of error evaluators that correspond to the
-      * benchmarks defined in the paper Duretz et al. reference above.
-      */
-    template <int dim>
-    class DoneaHuertaPostprocessor : public Postprocess::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Generate graphical output from the current solution.
-         */
-        virtual
-        std::pair<std::string,std::string>
-        execute (TableHandler &statistics);
-
-      private:
-        /**
-         * Calculate the L2 dynamic topography error.
-         */
-        //double
-        //compute_dynamic_topography_error() const;
-    };
-
-    template <int dim>
-    std::pair<std::string,std::string>
-    DoneaHuertaPostprocessor<dim>::execute (TableHandler &)
-    {
-      std::unique_ptr<Function<dim>> ref_func;
-      {
-        const DoneaHuertaMaterial<dim> *
-        material_model
-          = dynamic_cast<const DoneaHuertaMaterial<dim> *>(&this->get_material_model());
-
-        ref_func.reset (new AnalyticSolutions::FunctionDoneaHuerta<dim>(material_model->get_beta()));
-      }
-
-      const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities+2);
-
-      Vector<float> cellwise_errors_u (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_p (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_ul2 (this->get_triangulation().n_active_cells());
-      Vector<float> cellwise_errors_pl2 (this->get_triangulation().n_active_cells());
-
-      ComponentSelectFunction<dim> comp_u(std::pair<unsigned int, unsigned int>(0,dim),
-                                          dim+2);
-      ComponentSelectFunction<dim> comp_p(dim, dim+2);
-
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_u,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_p,
-                                         quadrature_formula,
-                                         VectorTools::L1_norm,
-                                         &comp_p);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_ul2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_u);
-      VectorTools::integrate_difference (this->get_mapping(),this->get_dof_handler(),
-                                         this->get_solution(),
-                                         *ref_func,
-                                         cellwise_errors_pl2,
-                                         quadrature_formula,
-                                         VectorTools::L2_norm,
-                                         &comp_p);
-
-      const double u_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_u, VectorTools::L1_norm);
-      const double p_l1 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_p, VectorTools::L1_norm);
-      const double u_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_ul2, VectorTools::L2_norm);
-      const double p_l2 = VectorTools::compute_global_error(this->get_triangulation(), cellwise_errors_pl2, VectorTools::L2_norm);
-
-      std::ostringstream os;
-
-      os << std::scientific <<  u_l1
-         << ", " << p_l1
-         << ", " << u_l2
-         << ", " << p_l2;
-
-      return std::make_pair("Errors u_L1, p_L1, u_L2, p_L2:", os.str());
-    }
-  }
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace DoneaHuertaBenchmark
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(DoneaHuertaMaterial,
-                                   "DoneaHuertaMaterial",
-                                   "A material model that corresponds to the `DoneaHuerta' benchmark. "
-                                   "See the manual for more information.")
-
-    ASPECT_REGISTER_BOUNDARY_VELOCITY_MODEL(DoneaHuertaBoundary,
-                                            "DoneaHuertaBoundary",
-                                            "Implementation of the velocity boundary conditions for the "
-                                            "`DoneaHuerta' benchmark. See the manual for more information about this "
-                                            "benchmark.")
-
-    ASPECT_REGISTER_POSTPROCESSOR(DoneaHuertaPostprocessor,
-                                  "DoneaHuertaPostprocessor",
-                                  "A postprocessor that compares the solution of the `DoneaHuerta' benchmark "
-                                  "with the one computed by ASPECT "
-                                  "and reports the error. See the manual for more information.")
-
-    ASPECT_REGISTER_GRAVITY_MODEL(DoneaHuertaGravity,
-                                  "DoneaHuertaGravity",
-                                  "A gravity model in corresponding to the `DoneaHuerta' benchmark. "
-                                  "See the manual for more information.")
-  }
-}
diff --git a/tests/q1_q1.prm.bak b/tests/q1_q1.prm.bak
deleted file mode 100644
index ecd37b4bcf9..00000000000
--- a/tests/q1_q1.prm.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-# Check the Donea-Huerta benchmark using the Q1 x Q1 element
-
-
-############### Global parameters
-# We use a 2d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0  : DoneaHuertaBoundary, \
-                                                1  : DoneaHuertaBoundary, \
-                                                2  : DoneaHuertaBoundary, \
-                                                3  : DoneaHuertaBoundary
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 1
-  set Use equal order interpolation for Stokes = true
-end
-
-subsection Material model
-  set Model name = DoneaHuertaMaterial
-end
-
-subsection Gravity model
-  set Model name = DoneaHuertaGravity
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, DoneaHuertaPostprocessor
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, gravity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-
-    #    set Use direct solver for Stokes system             = true
-  end
-end
diff --git a/tests/q1_q1_6.cc.bak b/tests/q1_q1_6.cc.bak
deleted file mode 100644
index 2c4484f5fb0..00000000000
--- a/tests/q1_q1_6.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "q1_q1.cc"
diff --git a/tests/q1_q1_6.prm.bak b/tests/q1_q1_6.prm.bak
deleted file mode 100644
index 5ae04385321..00000000000
--- a/tests/q1_q1_6.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-############### Global parameters
-# We use a 2d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory                       = output
-set Pressure normalization                 = volume
-
-############### Parameters describing the model
-# Because the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-#Boundary conditions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0  : DoneaHuertaBoundary, \
-                                                1  : DoneaHuertaBoundary, \
-                                                2  : DoneaHuertaBoundary, \
-                                                3  : DoneaHuertaBoundary
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 1
-  set Use equal order interpolation for Stokes = true
-end
-
-subsection Material model
-  set Model name = DoneaHuertaMaterial
-end
-
-subsection Gravity model
-  set Model name = DoneaHuertaGravity
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 6
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, DoneaHuertaPostprocessor
-
-  subsection Visualization
-    set List of output variables = density, viscosity, strain rate, gravity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-    set Number of cheap Stokes solver steps = 0
-
-    #    set Use direct solver for Stokes system             = true
-  end
-end
diff --git a/tests/quarter_shell_variable_coordinate_systems_cartesian.prm.bak b/tests/quarter_shell_variable_coordinate_systems_cartesian.prm.bak
deleted file mode 100644
index 7ed50df7d0f..00000000000
--- a/tests/quarter_shell_variable_coordinate_systems_cartesian.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# A simple setup for convection in a quarter of a 2d shell with
-# user input allowing for different coordinate systems
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output_quarter_shell_variable_coordinate_systems_cartesian
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = .45
-    set Outer radius  = 1
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4370
-    set Outer temperature = 273
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Coordinate system = cartesian
-    set Function expression = if ((x > 0.6 && x < 0.8 && y > 0.1 && y < 0.5), 8000, 0)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/tests/quarter_shell_variable_coordinate_systems_depth.prm.bak b/tests/quarter_shell_variable_coordinate_systems_depth.prm.bak
deleted file mode 100644
index 56f0167b66b..00000000000
--- a/tests/quarter_shell_variable_coordinate_systems_depth.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# A simple setup for convection in a quarter of a 2d shell with
-# user input allowing for different coordinate systems
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output_quarter_shell_variable_coordinate_systems_depth
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = .45
-    set Outer radius  = 1
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4370
-    set Outer temperature = 273
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = d, na
-    set Coordinate system = depth
-    set Function expression = if ((d < 0.65), 8000, 0)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/tests/quarter_shell_variable_coordinate_systems_spherical.prm.bak b/tests/quarter_shell_variable_coordinate_systems_spherical.prm.bak
deleted file mode 100644
index b1f122e474d..00000000000
--- a/tests/quarter_shell_variable_coordinate_systems_spherical.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# A simple setup for convection in a quarter of a 2d shell with
-# user input allowing for different coordinate systems
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output_quarter_shell_variable_coordinate_systems_spherical
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = .45
-    set Outer radius  = 1
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4370
-    set Outer temperature = 273
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = r,phi
-    set Coordinate system = spherical
-    set Function expression = if ((r <0.8 && r >0.5 && phi <  3.14159265/2 && phi > 3.14159265/4), 8000, 0)
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/tests/quick_mpi.cc.bak b/tests/quick_mpi.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/quick_mpi.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/quick_mpi.prm.bak b/tests/quick_mpi.prm.bak
deleted file mode 100644
index 5b0270d17a3..00000000000
--- a/tests/quick_mpi.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# derived from non_conservative_with_mpi used for the quick tests (ASPECT_RUN_ALL_TESTS=OFF)
-
-# we do not include statistics with the hope that this makes the test work on
-# a wide range of machines
-
-# Enable if: QUICK_TEST
-# MPI: 2
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/radioactive_decay.prm.bak b/tests/radioactive_decay.prm.bak
deleted file mode 100644
index c2623965c39..00000000000
--- a/tests/radioactive_decay.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# A simple setup for convection in a quarter of a 2d shell. See the
-# manual for more information.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1e6
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = R=6.336e6 ,Rc=300e3
-    set Variable names      = x,y
-    set Function expression = if(R-sqrt(x*x+y*y)<Rc,1,0)
-  end
-end
-
-subsection Heating model
-  set List of model names = radioactive decay
-
-  subsection Radioactive decay
-    set Number of elements    = 2
-    set Heating rates                 = 1e-5,  2e-5
-    set Half decay times              = 5e6,   2.5e6
-    set Initial concentrations mantle = 0.0,   0.1
-    set Initial concentrations crust  = 0.1,   0.0
-    set Crust defined by composition  = true
-    set Crust composition number      = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0
-  set Tangential velocity boundary indicators = 1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = heating statistics
-end
diff --git a/tests/radiogenic_heating.prm.bak b/tests/radiogenic_heating.prm.bak
deleted file mode 100644
index 761ddc384e7..00000000000
--- a/tests/radiogenic_heating.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-############### Global parameters
-# This is a test for the radiogenic heating.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 1000
-set Use years in output instead of seconds = false
-set Output directory = radiogenic_heating
-
-subsection Heating model
-  set List of model names = constant heating
-
-  subsection Constant heating
-    set Radiogenic heating rate = 1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000000
-    set Y extent = 1000000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = 3
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0, 1
-
-  subsection Function
-    set Function expression = 0;-1
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density                              = 3400
-    set Reference specific heat                        = 1000
-    set Reference temperature                          = 1000
-    set Thermal conductivity                           = 0.0
-    set Thermal expansion coefficient                  = 0.0
-    set Thermal viscosity exponent                     = 0.0
-    set Viscosity                                      = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
diff --git a/tests/random_perturbation_box.prm.bak b/tests/random_perturbation_box.prm.bak
deleted file mode 100644
index 6921b91881c..00000000000
--- a/tests/random_perturbation_box.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-# This is a test for the random Gaussian perturbation initial
-# temperature model. 10 perturbations are placed within the
-# box.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 20000
-    set Y extent = 15000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-# The perturbation will be added to the temperature given
-# by the function plugin.
-subsection Initial temperature model
-  set List of model names = function, random Gaussian perturbation
-
-  subsection Function
-    set Function expression = 500
-  end
-
-  subsection Random Gaussian perturbation
-    set Number of perturbations = 10
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1
-    set Thermal expansion coefficient                  = 1e-4
-    set Viscosity                                      = 1e20
-    set Reference density                              = 3300
-    set Reference temperature                          = 500
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/tests/random_perturbation_chunk.prm.bak b/tests/random_perturbation_chunk.prm.bak
deleted file mode 100644
index 4bbce2b2d2b..00000000000
--- a/tests/random_perturbation_chunk.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-# This is a test for the random Gaussian perturbation initial
-# temperature model. 10 perturbations are placed within the
-# chunk.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk inner radius = 3481000
-    set Chunk outer radius = 6371000
-    set Chunk maximum longitude = 45
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-# The perturbation will be added to the temperature given
-# by the function plugin.
-subsection Initial temperature model
-  set List of model names = function, random Gaussian perturbation
-
-  subsection Function
-    set Function expression = 500
-  end
-
-  subsection Random Gaussian perturbation
-    set Number of perturbations = 10
-    set Width = 200000
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1
-    set Thermal expansion coefficient                  = 1e-4
-    set Viscosity                                      = 1e20
-    set Reference density                              = 3300
-    set Reference temperature                          = 500
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/tests/random_perturbation_merged_boxes.prm.bak b/tests/random_perturbation_merged_boxes.prm.bak
deleted file mode 100644
index 477038e777c..00000000000
--- a/tests/random_perturbation_merged_boxes.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-# This is a test for the random Gaussian perturbation initial
-# temperature model. 10 perturbations are placed within the
-# two merged boxes.
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Geometry model
-  set Model name = box with lithosphere boundary indicators
-
-  subsection Box with lithosphere boundary indicators
-    set X extent = 20000
-    set Y extent = 15000
-    set Z extent = 15000
-    set Box origin X coordinate = 10000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-# The perturbation will be added to the temperature given
-# by the function plugin.
-subsection Initial temperature model
-  set List of model names = function, random Gaussian perturbation
-
-  subsection Function
-    set Function expression = 500
-  end
-
-  subsection Random Gaussian perturbation
-    set Number of perturbations = 10
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1
-    set Thermal expansion coefficient                  = 1e-4
-    set Viscosity                                      = 1e20
-    set Reference density                              = 3300
-    set Reference temperature                          = 500
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/tests/random_perturbation_sphere.prm.bak b/tests/random_perturbation_sphere.prm.bak
deleted file mode 100644
index 0bb1fff06df..00000000000
--- a/tests/random_perturbation_sphere.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# This is a test for the random Gaussian perturbation initial
-# temperature model. 10 perturbations are placed within the
-# sphere.
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Geometry model
-  set Model name = sphere
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-# The perturbation will be added to the temperature given
-# by the function plugin.
-subsection Initial temperature model
-  set List of model names = function, random Gaussian perturbation
-
-  subsection Function
-    set Function expression = 500
-  end
-
-  subsection Random Gaussian perturbation
-    set Number of perturbations = 10
-    set Width = 500000
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1
-    set Thermal expansion coefficient                  = 1e-4
-    set Viscosity                                      = 1e20
-    set Reference density                              = 3300
-    set Reference temperature                          = 500
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/tests/random_perturbation_spherical_shell.prm.bak b/tests/random_perturbation_spherical_shell.prm.bak
deleted file mode 100644
index 3313b06449a..00000000000
--- a/tests/random_perturbation_spherical_shell.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# This is a test for the random Gaussian perturbation initial
-# temperature model. 10 perturbations are placed within the
-# spherical shell.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = spherical shell
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-# The perturbation will be added to the temperature given
-# by the function plugin.
-subsection Initial temperature model
-  set List of model names = function, random Gaussian perturbation
-
-  subsection Function
-    set Function expression = 500
-  end
-
-  subsection Random Gaussian perturbation
-    set Number of perturbations = 10
-    set Width = 500000
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1
-    set Thermal expansion coefficient                  = 1e-4
-    set Viscosity                                      = 1e20
-    set Reference density                              = 3300
-    set Reference temperature                          = 500
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0.1
-  end
-end
diff --git a/tests/reactive_fluid_transport_no_reaction.prm.bak b/tests/reactive_fluid_transport_no_reaction.prm.bak
deleted file mode 100644
index 0d56ea7c6a9..00000000000
--- a/tests/reactive_fluid_transport_no_reaction.prm.bak
+++ /dev/null
@@ -1,25 +0,0 @@
-# This model tests the reactive fluid transport material
-# 'no reaction' scenario to ensure that there is no reaction
-# between the fluid and solid phases. The values of
-# porosity (0) and the bound fluid (0.01) are initially
-# spatially uniform. The absence of reactions between
-# the two phases and near zero velocities (free-slip on
-# all sides) produces no change in their values through time.
-
-# As this test is very similar to the reactive_fluid_transport_zero_solubility
-# test, we include the latter parameter file and only change relevant parameters.
-include $ASPECT_SOURCE_DIR/tests/reactive_fluid_transport_zero_solubility.prm
-
-set Output directory                       = reactive_fluid_transport_no_reaction
-
-# As there are no reactions between the fluid and solid,
-# there is no need to use operator splitting.
-set Use operator splitting                     = false
-
-# Use the no reaction scheme in the reactive fluid
-# transport model.
-subsection Material model
-  subsection Reactive Fluid Transport Model
-    set Fluid-solid reaction scheme = no reaction
-  end
-end
diff --git a/tests/reactive_fluid_transport_zero_solubility.prm.bak b/tests/reactive_fluid_transport_zero_solubility.prm.bak
deleted file mode 100644
index dbcae34b6a2..00000000000
--- a/tests/reactive_fluid_transport_zero_solubility.prm.bak
+++ /dev/null
@@ -1,138 +0,0 @@
-# This model tests the reactive material model "zero solubility"
-# reaction scenario, where all of the bound fluid in a solid
-# with zero solubility should go into the free fluid phase
-# (tracked by porosity field). The model begins with no free fluid
-# (zero porosity) and 1% bound fluid (0.01). For a fluid reaction
-# time scale of 1e3 years and a time step size of 10e3 years,
-# the reaction should be complete at the end of the first time step
-# giving a porosity of 0.01 and a bound fluid value of 0.
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = reactive_fluid_transport_zero_solubility
-set Max nonlinear iterations               = 1
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-set End time                               = 10e3
-
-# Because the model includes reactions that might be on a faster time scale
-# than the time step of the model (release of bound fluid into free fluid),
-# we use the operator splitting scheme.
-set Use operator splitting                     = true
-
-# Melt transport is turned on to ensure it works
-# with this reaction scheme. If set to false,
-# a separate velocity and pressure would not be
-# calculated for the fluid phase, and the porosity
-# field would be advected with the solid velocity
-# unless a separate advection scheme is specified.
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-# There are two compositional fields, one that tracks the amount of free fluid
-# (the porosity) and one that tracks the amount of bound fluid (bound_fluid).
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, bound_fluid
-end
-
-# Initially, there is no free water (the porosity is zero) and the water content
-# of the material is 1%.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0; 0.01
-  end
-end
-
-# The composition is not fixed on any boundary
-subsection Boundary composition model
-  set Fixed composition boundary indicators =
-  set List of model names = initial composition
-end
-
-# Free slip on all sides
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-# The model is 2x2 km
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2e3
-    set Y extent  = 2e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# The temperature is not important for this model, so we simply
-# set it to 1600 K everywhere (including the boundary).
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1600
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Maximal temperature = 1600
-    set Minimal temperature = 1600
-  end
-end
-
-# The reactive fluid transport model is composited
-# on top of the visco plastic material model.
-subsection Material model
-  set Model name = reactive fluid transport
-
-  subsection Reactive Fluid Transport Model
-    set Base model = visco plastic
-    set Reference fluid density = 2995
-    set Shear to bulk viscosity ratio = 0.1
-    set Reference fluid viscosity = 10
-    set Reference permeability = 2.5e-6
-    set Exponential fluid weakening factor = 0
-    set Fluid reaction time scale for operator splitting = 1e3
-    set Fluid-solid reaction scheme = zero solubility
-  end
-
-  subsection Visco Plastic
-    set Reference temperature                   = 1600
-    set Prefactors for diffusion creep          = 5e-21
-    set Viscous flow law = diffusion
-    set Densities                   = 3000
-    set Viscosity averaging scheme  = harmonic
-    set Minimum viscosity           = 1e19
-    set Maximum viscosity           = 1e19
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 0
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, melt statistics, velocity statistics
-end
diff --git a/tests/refine_vel.prm.bak b/tests/refine_vel.prm.bak
deleted file mode 100644
index 315f32bfd2e..00000000000
--- a/tests/refine_vel.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e300
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-  set End step                  = 3
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Additional refinement times              = 0,0
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/refinement_artificial_viscosity_1.prm.bak b/tests/refinement_artificial_viscosity_1.prm.bak
deleted file mode 100644
index 5f4b3aece5a..00000000000
--- a/tests/refinement_artificial_viscosity_1.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# Test MeshRefinement::ArtificialViscosity
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0.08
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = Alice, Bob
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,1,2,3
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if(x+y<0.4,1.0,0.1);if((1-x)^2+y^2<0.25,0.0,100.0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy = artificial viscosity
-  set Additional refinement times              = 0.06
-
-  subsection Artificial viscosity
-    set Temperature scaling factor = 1.0
-    set Compositional field scaling factors =
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,temperature statistics,composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = artificial viscosity#, artificial viscosity composition
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/refinement_artificial_viscosity_2.prm.bak b/tests/refinement_artificial_viscosity_2.prm.bak
deleted file mode 100644
index 4116b08fc27..00000000000
--- a/tests/refinement_artificial_viscosity_2.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-# Test MeshRefinement::ArtificialViscosity
-
-include $ASPECT_SOURCE_DIR/tests/refinement_artificial_viscosity_1.prm
-
-
-subsection Mesh refinement
-  subsection Artificial viscosity
-    set Temperature scaling factor = 0.0
-    set Compositional field scaling factors = 1.0, 0.0
-  end
-end
diff --git a/tests/refinement_artificial_viscosity_3.prm.bak b/tests/refinement_artificial_viscosity_3.prm.bak
deleted file mode 100644
index 188da3cc623..00000000000
--- a/tests/refinement_artificial_viscosity_3.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-# Test MeshRefinement::ArtificialViscosity
-
-include $ASPECT_SOURCE_DIR/tests/refinement_artificial_viscosity_1.prm
-
-
-subsection Mesh refinement
-  subsection Artificial viscosity
-    set Temperature scaling factor = 0.0
-    set Compositional field scaling factors = 0.0, 1.0
-  end
-end
diff --git a/tests/refinement_boundary.prm.bak b/tests/refinement_boundary.prm.bak
deleted file mode 100644
index 4da199e7cf6..00000000000
--- a/tests/refinement_boundary.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# Test that we indeed refine the boundaries when using the
-# 'boundary' mesh refinement criterion
-#
-# As far as output is concerned, all we care about is the number
-# of cells, which is always printed by default.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 3
-  set Initial global refinement          = 2
-  set Strategy                           = boundary
-
-  subsection Boundary
-    set Boundary refinement indicators = top, bottom, left, right
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
diff --git a/tests/refinement_composition_gradient.prm.bak b/tests/refinement_composition_gradient.prm.bak
deleted file mode 100644
index 25ddfdfb106..00000000000
--- a/tests/refinement_composition_gradient.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# Test MeshRefinement::CompositionGradient
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Dimension                              = 2
-set End time                               = 0.08
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = Alice, Bob
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,1,2,3
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(sqrt((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5))<0.25,0.5,0.1)
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if(x+y<0.4,1.0,0.1);1.0+exp(-(x-0.5)^2/0.05-(y-0.4)^2/0.05)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.4
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy = composition gradient
-  set Additional refinement times              = 0.02,0.04,0.06
-
-  subsection Composition gradient
-    set Compositional field scaling factors = 0.0, 1.0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,temperature statistics,composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = artificial viscosity
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/refinement_composition_threshold.prm.bak b/tests/refinement_composition_threshold.prm.bak
deleted file mode 100644
index 2e6dedbcaf4..00000000000
--- a/tests/refinement_composition_threshold.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# Test MeshRefinement::CompositionThreshold
-
-include $ASPECT_SOURCE_DIR/tests/refinement_composition_gradient.prm
-
-set End time                               = 0.07
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.4
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy = composition threshold
-  set Additional refinement times              = 0.04,0.06
-
-  subsection Composition threshold
-    set Compositional field thresholds = 0.5, 1.5
-  end
-end
diff --git a/tests/refinement_nonadiabatic_temperature.prm.bak b/tests/refinement_nonadiabatic_temperature.prm.bak
deleted file mode 100644
index 871025c9cc5..00000000000
--- a/tests/refinement_nonadiabatic_temperature.prm.bak
+++ /dev/null
@@ -1,27 +0,0 @@
-# A setup that tests if the nonadiabatic temperature threshold mesh
-# refinement plugin works correctly and that its interaction with the
-# minimum and maximum refinement level plugins makes sense.
-
-include $ASPECT_SOURCE_DIR/cookbooks/convection-box/convection-box.prm
-
-set End time                               = 0.02
-set Adiabatic surface temperature          = 0.5
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 2
-  set Time steps between mesh refinement       = 1
-  set Strategy = nonadiabatic temperature threshold, minimum refinement function, maximum refinement function
-
-  subsection Minimum refinement function
-    set Function expression = if(x > 0.5, 3, 4)
-  end
-
-  subsection Maximum refinement function
-    set Function expression = if(x > 0.5, 4, 5)
-  end
-
-  subsection Nonadiabatic temperature threshold
-    set Threshold = 0.25
-  end
-end
diff --git a/tests/refinement_strainrate.prm.bak b/tests/refinement_strainrate.prm.bak
deleted file mode 100644
index efab27c5a44..00000000000
--- a/tests/refinement_strainrate.prm.bak
+++ /dev/null
@@ -1,121 +0,0 @@
-# check strain rate based refinement
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-# The setup is a 3d box with edge length 2890000 in which
-# all 6 sides have free slip boundary conditions. Because
-# the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2890000
-    set Y extent  = 2890000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Viscosity                     = 1e22
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# This, however, is the more important part: We need to describe
-# the compositional field and its influence on the density
-# function. The following blocks say that we want to
-# advect a single compositional field and that we give it an
-# initial value that is zero outside a sphere of radius
-# r=200000m and centered at the point (p,p,p) with
-# p=1445000 (which is half the diameter of the box) and one inside.
-# The last block re-opens the material model and sets the
-# density differential per unit change in compositional field to
-# 100.
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = r=250000,p=1445000
-    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)) > r, 0, 1)
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.2
-  set Coarsening fraction                = 0.
-  set Strategy                           = strain rate
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density, viscosity, strain rate
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/refinement_switch.prm.bak b/tests/refinement_switch.prm.bak
deleted file mode 100644
index 628a342240e..00000000000
--- a/tests/refinement_switch.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.5
-set Output directory                       = refinement_switch
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 2
-  set Time steps between mesh refinement       = 1000
-  set Refinement fraction = 0.25
-  set Coarsening fraction = 0
-  set Adapt by fraction of cells = true
-  set Strategy = temperature
-  set Run postprocessors on initial refinement = true
-end
-
-subsection Compositional fields
-  set List of normalized fields = 0
-  set Names of fields           = heat
-  set Number of fields          = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if (y > 0.5, 1, 0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables      = error indicator
-  end
-end
-
-subsection Termination criteria
-  set End step                  = 1
-  set Termination criteria      = end step
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/refinement_topography.cc.bak b/tests/refinement_topography.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/refinement_topography.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/refinement_topography.prm.bak b/tests/refinement_topography.prm.bak
deleted file mode 100644
index 048fc546127..00000000000
--- a/tests/refinement_topography.prm.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-# Test that we indeed refine towards the surface when using the
-# 'topography' mesh refinement criterion
-#
-# As far as output is concerned, all we care about is the number
-# of cells, which is always printed by default.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 2
-  set Strategy                           = topography
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
diff --git a/tests/remove_angular_momentum.prm.bak b/tests/remove_angular_momentum.prm.bak
deleted file mode 100644
index 403902ded41..00000000000
--- a/tests/remove_angular_momentum.prm.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-# Test for removing the angular momentum in 2D spherical
-# shells.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 5.e6 #by this time net rotation will start to be evident
-set Output directory                       = output
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e20
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 100
-    set Outer temperature = 0
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace = angular momentum
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, rotation statistics
-end
diff --git a/tests/remove_angular_momentum_3d.prm.bak b/tests/remove_angular_momentum_3d.prm.bak
deleted file mode 100644
index 7494245f661..00000000000
--- a/tests/remove_angular_momentum_3d.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# This test is based on rotation_statistics_3D_asymmetric, with the modification
-# that we solve for the velocity solution and remove the angular momentum.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set End time                               = 1
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Nullspace removal
-  set Remove nullspace = angular momentum
-end
-
-subsection Geometry model
-  set Model name = sphere
-
-  subsection Sphere
-    set Radius = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if (x>0, if (y>0, 1.0, 2.0), if (y<0, 1.0, 2.0))
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 2
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0.5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, rotation statistics
-
-  subsection Rotation statistics
-    set Output full moment of inertia tensor = true
-  end
-end
diff --git a/tests/remove_net_rotation.prm.bak b/tests/remove_net_rotation.prm.bak
deleted file mode 100644
index 344b39430eb..00000000000
--- a/tests/remove_net_rotation.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# Test for removing the net rotation in 2D spherical
-# shells.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 5.e6 #by this time net rotation will start to be evident
-set Output directory                       = output
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e20
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 100
-    set Outer temperature = 0
-  end
-end
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, rotation statistics
-
-  subsection Rotation statistics
-    set Use constant density of one = true
-  end
-end
diff --git a/tests/remove_net_rotation_3d.prm.bak b/tests/remove_net_rotation_3d.prm.bak
deleted file mode 100644
index b70a64ec4d7..00000000000
--- a/tests/remove_net_rotation_3d.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# This test is based on rotation_statistics_3D_asymmetric, with the modification
-# that we solve for the velocity solution and remove the net rotation.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set End time                               = 1
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Nullspace removal
-  set Remove nullspace = net rotation
-end
-
-subsection Geometry model
-  set Model name = sphere
-
-  subsection Sphere
-    set Radius = 1
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if (x>0, if (y>0, 1.0, 2.0), if (y<0, 1.0, 2.0))
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 2
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0.5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, rotation statistics
-
-  subsection Rotation statistics
-    set Use constant density of one = true
-    set Output full moment of inertia tensor = true
-  end
-end
diff --git a/tests/remove_net_surface_rotation.prm.bak b/tests/remove_net_surface_rotation.prm.bak
deleted file mode 100644
index d5ab550d1b9..00000000000
--- a/tests/remove_net_surface_rotation.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-# Test for removing the net surface rotation in 2D spherical
-# shells. Setup is identical to the 'remove_net_rotation' test,
-# except we remove net surface rotation instead of volume rotation.
-# The 'rotation statistics' postprocessor will show negligible
-# surface angular velocity, and higher overall angular velocity
-# than for 'remove_net_rotation'.
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/remove_net_rotation.prm
-
-
-subsection Nullspace removal
-  set Remove nullspace = net surface rotation
-end
diff --git a/tests/replace_lithosphere_viscosity_file.prm.bak b/tests/replace_lithosphere_viscosity_file.prm.bak
deleted file mode 100644
index cf7aaba0864..00000000000
--- a/tests/replace_lithosphere_viscosity_file.prm.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-# Test replace lithosphere viscosity material model
-# using base model ''simple'' and lithosphere-asthenosphere
-# boundary taken from file
-
-
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 1e05
-
-subsection Material model
-  set Model name = replace lithosphere viscosity
-
-  subsection Replace lithosphere viscosity
-    set Base model = simple
-    set Lithosphere viscosity = 1e25
-    set Depth specification method = File
-  end
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = depth
-    set Function constants = temp=2500
-    set Function expression = temp
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics
-end
diff --git a/tests/resume_free_surface.cc.bak b/tests/resume_free_surface.cc.bak
deleted file mode 100644
index 4ae77524790..00000000000
--- a/tests/resume_free_surface.cc.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-
-/*
- * Launch the following function when this plugin is created. Launch ASPECT
- * twice to test checkpoint/resume and then abort the outer ASPECT run.
- */
-int f()
-{
-  std::cout << "* starting from beginning:" << std::endl;
-
-  // call ASPECT with "--" and pipe an existing input file into it.
-  int ret;
-
-  ret = system ("cd output-resume_free_surface ; "
-                "(cat " ASPECT_SOURCE_DIR "/tests/resume_free_surface.prm "
-                " ; "
-                " echo 'set Output directory = output1.tmp' "
-                " ; "
-                " rm -rf output1.tmp ; mkdir output1.tmp "
-                ") "
-                "| ../../aspect -- >/dev/null ");
-
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  ret = system ("cd output-resume_free_surface ; "
-                " rm -rf output2.tmp ; cp -r output1.tmp output2.tmp ;"
-                " rm -f output1.tmp/log.txt; "
-                " cp output1.tmp/restart.mesh.old output1.tmp/restart.mesh;"
-                " cp output1.tmp/restart.mesh.info.old output1.tmp/restart.mesh.info;"
-                " cp output1.tmp/restart.resume.z.old output1.tmp/restart.resume.z;");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-
-  std::cout << "* now resuming:" << std::endl;
-  ret = system ("cd output-resume_free_surface ; "
-                "(cat " ASPECT_SOURCE_DIR "/tests/resume_free_surface.prm "
-                " ; "
-                " echo 'set Output directory = output1.tmp' "
-                " ; "
-                " echo 'set Resume computation = true' "
-                ") "
-                "| ../../aspect -- >/dev/null");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  std::cout << "* now comparing:" << std::endl;
-
-  ret = system ("cd output-resume_free_surface ; "
-                " cp output1.tmp/solution/solution-00004.0000.gnuplot solution/solution-00004.0000.gnuplot1 ;"
-                " cp output2.tmp/solution/solution-00004.0000.gnuplot solution/solution-00004.0000.gnuplot2 ;"
-                " cp output1.tmp/log.txt log.txt1 ;"
-                " cp output2.tmp/log.txt log.txt2 ;"
-                " cp output1.tmp/statistics statistics1 ;"
-                " cp output2.tmp/statistics statistics2");
-
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  ret = system ("cd output-resume_free_surface ; "
-                "diff -c output?.tmp/restart.resume.z ; "
-                "diff -c output?.tmp/restart.mesh ; "
-                "");
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // abort current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/resume_free_surface.prm.bak b/tests/resume_free_surface.prm.bak
deleted file mode 100644
index 35699f9222e..00000000000
--- a/tests/resume_free_surface.prm.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-#Test for resuming simulations with a free surface
-set Dimension = 2
-set CFL number                             = 0.5
-set End time                               = 1e9
-
-#set Output directory                       = output
-#set Resume computation                     = true
-set Start time                             = 0
-set Pressure normalization                 = no
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:200,3:200
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 2
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function expression = (500e3-x)/500e3*100
-      set Maximum topography value = 100
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-160.e3)^2 ) < 25.e3, 0.0, 200.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e19
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 1.0
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 4
-  set Checkpoint on termination = false
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, basic statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format = gnuplot
-    set Time between graphical output = 0.
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-  end
-end
diff --git a/tests/rheology_scaled_profile.cc.bak b/tests/rheology_scaled_profile.cc.bak
deleted file mode 100644
index 3795ec41aad..00000000000
--- a/tests/rheology_scaled_profile.cc.bak
+++ /dev/null
@@ -1,296 +0,0 @@
-/*
-  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-
-#include <aspect/geometry_model/interface.h>
-#include <aspect/material_model/rheology/ascii_depth_profile.h>
-#include <aspect/lateral_averaging.h>
-
-namespace aspect
-{
-  using namespace dealii;
-
-  namespace MaterialModel
-  {
-    /**
-     * Additional output fields for the viscosity prior to scaling to be added to
-     * the MaterialModel::MaterialModelOutputs structure and filled in the
-     * MaterialModel::Interface::evaluate() function.
-     */
-    template <int dim>
-    class UnscaledViscosityAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
-    {
-      public:
-        UnscaledViscosityAdditionalOutputs(const unsigned int n_points)
-          : NamedAdditionalMaterialOutputs<dim>(std::vector<std::string>(1, "unscaled_viscosity"),
-                                                n_points)
-        {}
-    };
-  }
-
-  namespace internal
-  {
-    template <int dim>
-    class FunctorDepthAverageUnscaledViscosity: public internal::FunctorBase<dim>
-    {
-      public:
-        FunctorDepthAverageUnscaledViscosity()
-        {}
-
-        bool need_material_properties() const override
-        {
-          return true;
-        }
-
-        void
-        create_additional_material_model_outputs (const unsigned int n_points,
-                                                  MaterialModel::MaterialModelOutputs<dim> &outputs) const override
-        {
-          if (outputs.template get_additional_output<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>() == nullptr)
-            {
-              outputs.additional_outputs.push_back(
-                std::make_unique<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>> (n_points));
-            }
-        }
-
-        void operator()(const MaterialModel::MaterialModelInputs<dim> &,
-                        const MaterialModel::MaterialModelOutputs<dim> &out,
-                        const FEValues<dim> &,
-                        const LinearAlgebra::BlockVector &,
-                        std::vector<double> &output) override
-        {
-          const MaterialModel::UnscaledViscosityAdditionalOutputs<dim> *unscaled_viscosity_outputs
-            = out.template get_additional_output<const MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>();
-
-          Assert(unscaled_viscosity_outputs != nullptr,ExcInternalError());
-
-          for (unsigned int q=0; q<output.size(); ++q)
-            output[q] = unscaled_viscosity_outputs->output_values[0][q];
-        }
-    };
-  }
-
-  namespace MaterialModel
-  {
-    /**
-     * A material model that tests the variable depth averaging routines. The material properties are
-     * constant, except that the viscosity is set to a reference viscosity profile by first computing
-     * an unscaled (constant) viscosity profile, which is then scaled by the quotient between reference
-     * profile and unscaled viscosity.
-     */
-    template <int dim>
-    class ScaledViscosityProfileMaterial : public MaterialModel::Interface<dim>, public aspect::SimulatorAccess<dim>
-    {
-      public:
-        void initialize() override
-        {
-          reference_viscosity_coordinates = reference_viscosity_profile->get_interpolation_point_coordinates();
-        }
-
-        void update() override
-        {
-          std::vector<std::unique_ptr<internal::FunctorBase<dim>>> lateral_averaging_properties;
-          lateral_averaging_properties.push_back(std::make_unique<internal::FunctorDepthAverageUnscaledViscosity<dim>>());
-
-          std::vector<std::vector<double>> averages =
-            this->get_lateral_averaging().compute_lateral_averages(reference_viscosity_coordinates,
-                                                                   lateral_averaging_properties);
-
-          laterally_averaged_viscosity_profile.swap(averages[0]);
-
-          for (unsigned int i = 0; i < laterally_averaged_viscosity_profile.size(); ++i)
-            AssertThrow(numbers::is_finite(laterally_averaged_viscosity_profile[i]),
-                        ExcMessage("In computing depth averages, there is at"
-                                   " least one depth band that does not have"
-                                   " any quadrature points in it."
-                                   " Consider reducing number of depth layers"
-                                   " for averaging."));
-        }
-
-
-
-        double
-        compute_viscosity_scaling (const double depth) const
-        {
-          // Make maximal depth slightly larger to ensure depth < maximal_depth
-          const double maximal_depth = this->get_geometry_model().maximal_depth() *
-                                       (1.0+std::numeric_limits<double>::epsilon());
-          Assert(depth < maximal_depth, ExcInternalError());
-
-          unsigned int depth_index;
-          if (depth < reference_viscosity_coordinates.front())
-            {
-              depth_index = 0;
-            }
-          else if (depth > reference_viscosity_coordinates.back())
-            {
-              depth_index = reference_viscosity_coordinates.size() - 1;
-            }
-          else
-            {
-              depth_index = std::distance(reference_viscosity_coordinates.begin(),
-                                          std::lower_bound(reference_viscosity_coordinates.begin(),
-                                                           reference_viscosity_coordinates.end(),
-                                                           depth));
-            }
-          // depth_index calculated above is the first layer boundary larger than depth,
-          // the correct layer index is then one less than this (except for depth == depth_bounds[0],
-          // in which case the depth_bounds index is also the layer_index, namely 0).
-          // For depths > depth_bounds[n-1], where, n is the size of the depth_bounds, we need to use
-          // the depth_bound one less than this, i.e. depth_bounds[n-2] to compute the averages of the
-          // last layer.
-          if (depth_index > 0)
-            depth_index -= 1;
-
-          // When evaluating reference viscosity, evaluate at the next lower depth that is stored
-          // in the reference profile instead of the actual depth. This makes the profile piecewise
-          // constant. This will be specific to the viscosity profile used (and ignore the entry with
-          // the largest depth in the profile).
-          const double reference_viscosity = reference_viscosity_profile->compute_viscosity(reference_viscosity_coordinates.at(depth_index));
-
-          const double average_viscosity = laterally_averaged_viscosity_profile[depth_index];
-
-          return reference_viscosity / average_viscosity;
-        }
-
-
-
-        void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                      MaterialModel::MaterialModelOutputs<dim> &out) const override
-        {
-          UnscaledViscosityAdditionalOutputs<dim> *unscaled_viscosity_out =
-            out.template get_additional_output<MaterialModel::UnscaledViscosityAdditionalOutputs<dim>>();
-
-          for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-            {
-              const double depth = this->get_geometry_model().depth(in.position[i]);
-              const std::array<double, dim> spherical_coordinates =
-                Utilities::Coordinates::cartesian_to_spherical_coordinates(in.position[i]);
-
-              out.densities[i] = 3300.0;
-              out.viscosities[i] = (1 - 2. * spherical_coordinates[1]/numbers::PI) * 1e20 +
-                                   2. * spherical_coordinates[1]/numbers::PI * 1e21;
-
-              // store unscaled viscosity to compute averaged profile use for compute scaling factor
-              if (unscaled_viscosity_out != nullptr)
-                {
-                  unscaled_viscosity_out->output_values[0][i] = out.viscosities[i];
-                }
-
-              if (this->simulator_is_past_initialization() == true && this->get_timestep_number() > 0)
-                out.viscosities[i] *= compute_viscosity_scaling(depth);
-
-              out.compressibilities[i] = 0;
-              out.specific_heat[i] = 1200;
-              out.thermal_expansion_coefficients[i] = 3e-5;
-              out.thermal_conductivities[i] = 4.7;
-            }
-        }
-
-        bool is_compressible() const override
-        {
-          return false;
-        }
-
-        void
-        create_additional_named_outputs (MaterialModelOutputs<dim> &outputs) const override
-        {
-          if (outputs.template get_additional_output<UnscaledViscosityAdditionalOutputs<dim>>() == nullptr)
-            {
-              const unsigned int n_points = outputs.n_evaluation_points();
-              outputs.additional_outputs.push_back(
-                std::make_unique<UnscaledViscosityAdditionalOutputs<dim>> (n_points));
-            }
-        }
-
-        static
-        void
-        declare_parameters(ParameterHandler &prm)
-        {
-          prm.enter_subsection("Material model");
-          {
-            // Depth-dependent parameters from the rheology plugin
-            Rheology::AsciiDepthProfile<dim>::declare_parameters(prm, "Depth dependent model");
-          }
-          prm.leave_subsection();
-        }
-
-        void
-        parse_parameters(ParameterHandler &prm) override
-        {
-          prm.enter_subsection("Material model");
-          {
-            reference_viscosity_profile = std::make_unique<Rheology::AsciiDepthProfile<dim>>();
-            reference_viscosity_profile->initialize_simulator (this->get_simulator());
-            reference_viscosity_profile->parse_parameters(prm, "Depth dependent model");
-            reference_viscosity_profile->initialize();
-          }
-          prm.leave_subsection();
-
-          this->model_dependence.viscosity = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.density = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.compressibility = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.specific_heat = MaterialModel::NonlinearDependence::none;
-          this->model_dependence.thermal_conductivity = MaterialModel::NonlinearDependence::none;
-        }
-
-      private:
-        /**
-         * A reference depth-profile for viscosity. Can be used for simply
-         * depth-dependent rheologies, or to compare (and potentially scale)
-         * the grain-size dependent viscosity to a reference profile.
-         */
-        std::unique_ptr<Rheology::AsciiDepthProfile<dim>> reference_viscosity_profile;
-
-        /**
-         * Reference viscosity profile coordinates.
-         */
-        std::vector<double> reference_viscosity_coordinates;
-
-        /**
-         * A depth-profile of the laterally averaged viscosity in each layer
-         * in the current model. Can be used to compare (and potentially scale)
-         * the computed viscosity to the reference profile.
-         */
-        std::vector<double> laterally_averaged_viscosity_profile;
-    };
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ScaledViscosityProfileMaterial,
-                                   "scaled viscosity profile",
-                                   "A material model that scales a constant viscosity to a given "
-                                   "reference profile.")
-
-#define INSTANTIATE(dim) \
-  template class UnscaledViscosityAdditionalOutputs<dim>;
-
-    ASPECT_INSTANTIATE(INSTANTIATE)
-
-  }
-}
diff --git a/tests/rheology_scaled_profile.prm.bak b/tests/rheology_scaled_profile.prm.bak
deleted file mode 100644
index 98d00e935e1..00000000000
--- a/tests/rheology_scaled_profile.prm.bak
+++ /dev/null
@@ -1,82 +0,0 @@
-# 2d quarter shell using a scaled viscosity profile
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1.0e5
-
-subsection Material model
-  set Model name = scaled viscosity profile
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = top, left, right
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average, material statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 0
-    set Number of grouped files       = 0
-    set List of output variables      = material properties, named additional outputs
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 3
-    set Depth boundaries of zones = 0, 1e6, 2e6, 3e6
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/tests/rigid_shear_instantaneous.cc.bak b/tests/rigid_shear_instantaneous.cc.bak
deleted file mode 100644
index 6b7d8b8ffaa..00000000000
--- a/tests/rigid_shear_instantaneous.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/rigid_shear/plugin/rigid_shear.cc"
diff --git a/tests/rigid_shear_instantaneous.prm.bak b/tests/rigid_shear_instantaneous.prm.bak
deleted file mode 100644
index 06780bfd48c..00000000000
--- a/tests/rigid_shear_instantaneous.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-# A description of the rigid shear benchmark for which a known solution
-# is available. See the benchmark folder for more information.
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/rigid_shear/instantaneous/rigid_shear.prm
diff --git a/tests/rigid_shear_steady_state.cc.bak b/tests/rigid_shear_steady_state.cc.bak
deleted file mode 100644
index 6b7d8b8ffaa..00000000000
--- a/tests/rigid_shear_steady_state.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/rigid_shear/plugin/rigid_shear.cc"
diff --git a/tests/rigid_shear_steady_state.prm.bak b/tests/rigid_shear_steady_state.prm.bak
deleted file mode 100644
index f3d21ce9b92..00000000000
--- a/tests/rigid_shear_steady_state.prm.bak
+++ /dev/null
@@ -1,5 +0,0 @@
-# A description of the rigid shear benchmark for which a known solution
-# is available. See the benchmark folder for more information.
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/rigid_shear/steady-state/rigid_shear.prm
diff --git a/tests/rigid_shear_transient.cc.bak b/tests/rigid_shear_transient.cc.bak
deleted file mode 100644
index 6b7d8b8ffaa..00000000000
--- a/tests/rigid_shear_transient.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/rigid_shear/plugin/rigid_shear.cc"
diff --git a/tests/rigid_shear_transient.prm.bak b/tests/rigid_shear_transient.prm.bak
deleted file mode 100644
index 7e79d574cc1..00000000000
--- a/tests/rigid_shear_transient.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-# A description of the rigid shear benchmark for which a known solution
-# is available. See the benchmark folder for more information.
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/rigid_shear/transient/rigid_shear.prm
-
-set End time = 0.1
diff --git a/tests/rising_melt_blob.cc.bak b/tests/rising_melt_blob.cc.bak
deleted file mode 100644
index d1ff721b04f..00000000000
--- a/tests/rising_melt_blob.cc.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/melt.h>
-#include <aspect/boundary_velocity/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-
-#include <deal.II/dofs/dof_tools.h>
-#include <deal.II/numerics/data_out.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/base/function_lib.h>
-#include <deal.II/numerics/error_estimator.h>
-#include <deal.II/numerics/vector_tools.h>
-
-using namespace dealii;
-
-
-namespace aspect
-{
-  template <int dim>
-  class MeltingRate:
-    public MaterialModel::MeltInterface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual double reference_darcy_coefficient () const
-      {
-        return 1e-8 * std::pow(0.01, 3.0) / 10.0;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              out.reaction_terms[i][c] = 0.0;
-
-            out.viscosities[i] = 5e20;
-            out.densities[i] = 3000.0 * (1 - 2e-5 * (in.temperature[i] - 293.0));
-            out.thermal_expansion_coefficients[i] = 2e-5;
-            out.specific_heat[i] = 1250.0;
-            out.thermal_conductivities[i] = 4.7;
-            out.compressibilities[i] = 0.0;
-          }
-
-        // fill melt outputs if they exist
-        aspect::MaterialModel::MeltOutputs<dim> *melt_out = out.template get_additional_output<aspect::MaterialModel::MeltOutputs<dim>>();
-
-        if (melt_out != nullptr)
-          {
-            const unsigned int porosity_idx = this->introspection().compositional_index_for_name("porosity");
-            for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-              {
-                const double porosity = in.composition[i][porosity_idx];
-
-                melt_out->compaction_viscosities[i] = 5e20 * 0.05/std::max(porosity,0.00025);
-                melt_out->fluid_viscosities[i]= 10.0;
-                melt_out->permeabilities[i]= 1e-8 * std::pow(porosity,3) * std::pow(1.0-porosity,2);
-                melt_out->fluid_densities[i]= 2500.0;
-                melt_out->fluid_density_gradients[i] = Tensor<1,dim>();
-              }
-          }
-      }
-
-  };
-
-
-}
-
-
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(MeltingRate,
-                                 "melting rate",
-                                 "")
-}
diff --git a/tests/rising_melt_blob.prm.bak b/tests/rising_melt_blob.prm.bak
deleted file mode 100644
index 9d35d29cc69..00000000000
--- a/tests/rising_melt_blob.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-#########################################################
-# This is a test for the new melt solver. It checks if
-# melt transport works correctly in a model that has both
-# regions with and without melt (so only some of the cells
-# are "melt cells").
-
-# The initial porosity is zero everywhere, except for a
-# Gaussian in the center of the model (the "melt blob").
-# As there is no melting or freezing, the blob should
-# just rise, conserving the total porosity.
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 20000
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 50
-set CFL number                             = 0.2
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-############### Parameters describing the model
-# Let us here choose again a box domain
-# where we fix the temperature at the bottom and top,
-# allow free slip along the boundaries
-# and include melt migration.
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 200000
-    set Y extent = 100000
-    set X repetitions = 2
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1600
-    set Top temperature    = 293
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Melt settings
-  set Include melt transport = true
-end
-
-############### Compositional fields
-# We want to use two compositional fields, the porosity and
-# an additional field, to check if the melting rate functionality
-# has the same effect as the reaction term for the other
-# compositional fields. As the porosity field is advected by
-# a different mechanism, slight differences between the fields
-# are expected.
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-# We then choose a vertical gravity model and describe the
-# initial temperature with a vertical gradient.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 1e6
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=100000,y0=50000,c=10000
-    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
-  end
-end
-
-subsection Material model
-  set Model name = melting rate
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
-    end
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/rising_melt_blob_freezing.prm.bak b/tests/rising_melt_blob_freezing.prm.bak
deleted file mode 100644
index e24eff65436..00000000000
--- a/tests/rising_melt_blob_freezing.prm.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-#########################################################
-# This is a test for the melting rate functionality,
-# in particular the freezing of melt.
-# It uses the melt simple model.
-
-# The initial porosity has the form of a Gaussian function
-# there is a fixed (constant) freezing rate.
-
-# The amplitude of the Gaussian is 0.2, and the melting time
-# scale is chosen in such a way that the fraction of melt
-# should be cut in half every year (visible in the maximum
-# value of the porosity field).
-
-############### Global parameters
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 2
-set Use years in output instead of seconds = true
-set Adiabatic surface temperature          = 1600
-
-# Do not solve for Stokes to speed up test
-# (see rising_melt_blob for the same test that solves Stokes)
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-# number of nonlinear iterations reduced from 50 to 10 to speed up test.
-set Max nonlinear iterations               = 10
-set Maximum time step                      = 1
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use operator splitting                     = true
-
-subsection Prescribed Stokes solution
-  set Model name = function
-end
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Melt extraction depth = 0.0
-    set Freezing rate         = 1.0
-    set Melting time scale for operator splitting = 1.442695041
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
-
-############### Parameters describing the model
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100000
-    set Y extent = 100000
-  end
-end
-
-subsection Melt settings
-  set Include melt transport = true
-
-  # Set to false in order to prescribe Stokes solution
-  set Use discontinuous compaction pressure = false
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 293
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = pi=3.1415926,x0=50000,y0=50000,c=10000
-    set Function expression = 0.2 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c)); 0.0 * exp(-((x-x0)*(x-x0)+(y-y0)*(y-y0))/(2*c*c))
-  end
-end
-
-# The final part of this input file describes how many times the
-# mesh is refined and what to do with the solution once computed
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
-    end
-  end
-end
diff --git a/tests/rotation_statistics.prm.bak b/tests/rotation_statistics.prm.bak
deleted file mode 100644
index 4d388250206..00000000000
--- a/tests/rotation_statistics.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# This test is based on prescribed_stokes_solution, with the modification
-# that we create a rotating sphere. The velocity is prescribed with a angular velocity
-# of 1, and this is mostly a test that the 'rotation statistics' postprocessor
-# correctly computes this angular velocity w, and the corresponding angular
-# momentum L = I * w. Since the moment of inertia I of a 2D sphere rotating around z is
-#
-# I = 1/2 M R^2 = 1/2 rho V R^2 = 1/2 rho * PI R^2 R^2
-#
-# with rho=1 and R=1: I = 1/2 * PI = 1.570796
-#
-# and with the angular velocity w=1 the angular momentum we expect
-# L = I = 1.570796. The test output is slightly off, but converges with
-# increasing resolution towards this value.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 1
-end
-
-subsection Geometry model
-  set Model name = sphere
-
-  subsection Sphere
-    set Radius = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, rotation statistics
-end
diff --git a/tests/rotation_statistics_3d.prm.bak b/tests/rotation_statistics_3d.prm.bak
deleted file mode 100644
index ee1bce63953..00000000000
--- a/tests/rotation_statistics_3d.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# This test is based on prescribed_stokes_solution, with the modification
-# that we create a rotating sphere. The velocity is prescribed with a angular velocity
-# of 1, and this is mostly a test that the 'rotation statistics' postprocessor
-# correctly computes this angular velocity w, and the corresponding angular
-# momentum L = I * w. Since the moment of inertia I of a 3D sphere is
-#
-# I = 2/5 M R^2 = 2/5 rho V R^2 = 2/5 rho * 4/3 PI R^3 R^2
-#
-# with rho=1 and R=1: I = 2/5 * 4/3 * PI = 1.675516
-#
-# and with the angular velocity w=1 the angular momentum we expect
-# L = I = 1.675516. The test output is slightly off, but converges with
-# increasing resolution towards this value.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 1
-end
-
-subsection Geometry model
-  set Model name = sphere
-
-  subsection Sphere
-    set Radius = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, rotation statistics
-end
diff --git a/tests/rotation_statistics_3d_asymmetric.prm.bak b/tests/rotation_statistics_3d_asymmetric.prm.bak
deleted file mode 100644
index 9cdcb3fdfc5..00000000000
--- a/tests/rotation_statistics_3d_asymmetric.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# This test is based on rotation_statistics_3D, with the modification
-# that we create a rotating sphere with an asymmetric density distribution.
-# More precisely the density is 2 if (x>0 && y>0) or (x<0 && y<0), and 1 otherwise.
-# This allows us to compute the xy entry of the moment of inertia tensor I as
-# a sum of a full sphere with density 1 (for which I_xy == 0) and two
-# anomalies in the first and third quadrant of the x-y plane with delta_rho=1:
-#
-# I_xy = -1 * \int_V delta_rho * x * y dV
-#      = -1 * \int_V (r*cos(phi)*sin(theta) * r*sin(phi)*sin(theta)) dV
-#      = -2 * \int_(phi=0)^(pi/2) \int_(theta=0)^(pi) \int_(r=0)^(R)
-#        r^2 sin(phi) cos(phi) sin^2(theta) * r^2 sin(theta) dr dtheta dphi
-#      = -4/15 R^5 = -0.266666
-#
-# This is mostly a test that the 'rotation statistics' postprocessor
-# correctly computes this moment of inertia tensor (including the correct
-# sign).
-
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Geometry model
-  set Model name = sphere
-
-  subsection Sphere
-    set Radius = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if (x>0, if (y>0, 1.0, 2.0), if (y<0, 1.0, 2.0))
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Vertical
-    set Magnitude = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 2
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 0.5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, rotation statistics
-
-  subsection Rotation statistics
-    set Output full moment of inertia tensor = true
-  end
-end
diff --git a/tests/rotation_statistics_3d_surface.prm.bak b/tests/rotation_statistics_3d_surface.prm.bak
deleted file mode 100644
index 9463c5fc6dc..00000000000
--- a/tests/rotation_statistics_3d_surface.prm.bak
+++ /dev/null
@@ -1,20 +0,0 @@
-# This test is based on 'rotation_statistics_3d', with the modification
-# that the sphere rotates with a radially varying angular velocity of
-# w=r instead of w=1. Since our sphere has a radius of 1 this means the
-# volume net rotation is different from 'rotation_statistics_3d', but
-# the surface net rotation should still be 1, which the postprocessor
-# 'rotation statistics' reports correctly.
-
-set Dimension                              = 3
-
-include $ASPECT_SOURCE_DIR/tests/rotation_statistics_3d.prm
-
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,z,t
-    set Function expression = -y*sqrt(x*x+y*y+z*z); x*sqrt(x*x+y*y+z*z); 0
-  end
-end
diff --git a/tests/sea_level_postprocessor.prm.bak b/tests/sea_level_postprocessor.prm.bak
deleted file mode 100644
index b07ad6a1198..00000000000
--- a/tests/sea_level_postprocessor.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# A simple setup to test the sea level postprocessor.
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set Start time                             = 0
-set End time                               = 0
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Timing output frequency                = 1
-set Pressure normalization                 = no
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3480.e3
-    set Outer radius = 6371.e3
-    set Opening angle = 360
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 0
-  set Initial adaptive refinement        = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = outer: free surface
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner
-end
-
-subsection Nullspace removal
-  set Remove nullspace = angular momentum
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = inner, outer
-  set List of model names = initial temperature
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-subsection Material model
-  set Model name = simpler
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = basic statistics, temperature statistics, velocity statistics, topography, geoid, sea level
-
-  subsection Topography
-    set Output to file = true
-  end
-
-  subsection Geoid
-    set Include surface topography contribution = true
-    set Include CMB topography contribution = false
-    set Output data in geographical coordinates = true
-    set Maximum degree = 3
-  end
-
-  subsection Sea level
-    set Output to file = true
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end time
-end
diff --git a/tests/segregation_heating.cc.bak b/tests/segregation_heating.cc.bak
deleted file mode 100644
index 6628a39f34f..00000000000
--- a/tests/segregation_heating.cc.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/boundary_fluid_pressure/interface.h>
-#include <aspect/gravity_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/global.h>
-#include <aspect/melt.h>
-
-namespace aspect
-{
-
-  template <int dim>
-  class PressureBdry:
-    public BoundaryFluidPressure::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual
-      void fluid_pressure_gradient (
-        const types::boundary_id /*boundary_indicator*/,
-        const MaterialModel::MaterialModelInputs<dim> &material_model_inputs,
-        const MaterialModel::MaterialModelOutputs<dim> &material_model_outputs,
-        const std::vector<Tensor<1,dim>> &normal_vectors,
-        std::vector<double> &fluid_pressure_gradient_outputs
-      ) const
-      {
-        const MaterialModel::MeltOutputs<dim> *melt_outputs = material_model_outputs.template get_additional_output<MaterialModel::MeltOutputs<dim>>();
-        Assert(melt_outputs != nullptr, ExcMessage("Need MeltOutputs from the material model for shear heating with melt."));
-
-        for (unsigned int q=0; q<fluid_pressure_gradient_outputs.size(); ++q)
-          {
-            const double density = material_model_outputs.densities[q];
-            const double melt_density = melt_outputs->fluid_densities[q];
-            const double porosity = material_model_inputs.composition[q][this->introspection().compositional_index_for_name("porosity")];
-
-            const double bulk_density = (porosity * melt_density + (1.0 - porosity) * density);
-            fluid_pressure_gradient_outputs[q] = this->get_gravity_model().gravity_vector(material_model_inputs.position[q]) * bulk_density * normal_vectors[q];
-          }
-      }
-
-  };
-
-}
-
-// explicit instantiations
-namespace aspect
-{
-  ASPECT_REGISTER_BOUNDARY_FLUID_PRESSURE_MODEL(PressureBdry,
-                                                "PressureBdry",
-                                                "A fluid pressure boundary condition that prescribes the "
-                                                "gradient of the fluid pressure at the boundaries as "
-                                                "calculated in the analytical solution. ")
-
-}
diff --git a/tests/segregation_heating.prm.bak b/tests/segregation_heating.prm.bak
deleted file mode 100644
index c6cc3aa80bd..00000000000
--- a/tests/segregation_heating.prm.bak
+++ /dev/null
@@ -1,142 +0,0 @@
-# This test is used to check if the shear heating
-# of melt, in particular the segregation heating, is
-# calculated correctly.
-# There is no in- or outflux of solid material, but melt
-# is allowed to flow in freely, so that it moves upwards
-# with a constant velocity determined by its buoyancy.
-# Hence there is no shear of the solid material, but there
-# is dissipation due to the segregation of melt:
-# \eta_f porosity^2 / permeability * (u_f - u_s)^2.
-#
-# With the material properties in this benchmark, shear
-# heating of melt should have a value of 0.78125 (for the
-# Total shear heating with melt rate).
-#
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 0.1
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression       = 1600
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5; 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-
-  subsection Function
-    set Function expression = 0;0
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-  set Heat advection by melt = true
-end
-
-subsection Heating model
-  set List of model names = shear heating, shear heating with melt
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = PressureBdry
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Reference solid density    = 2
-    set Reference melt density     = 1
-    set Reference specific heat    = 1
-    set Reference temperature      = 1600
-    set Thermal conductivity       = 0.0
-    set Surface solidus            = 10000.0
-    set Include melting and freezing = false
-    set Reference permeability       = 1
-    set Reference shear viscosity    = 1
-    set Reference bulk viscosity     = 1
-    set Reference melt viscosity     = 1
-    set Thermal viscosity exponent   = 0
-    set Exponential melt weakening factor = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heating statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature, heating
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
diff --git a/tests/shear_bands.cc.bak b/tests/shear_bands.cc.bak
deleted file mode 100644
index 63d03d90ae7..00000000000
--- a/tests/shear_bands.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/shear_bands/shear_bands.cc"
diff --git a/tests/shear_bands.prm.bak b/tests/shear_bands.prm.bak
deleted file mode 100644
index 69518b45218..00000000000
--- a/tests/shear_bands.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# This is a test for the magmatic shear bands test case,
-# which also checks the strain rate parameter in the entropy
-# viscosity stabilization.
-
-set Additional shared libraries            = ./libshear_bands.so
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 4
-set Nonlinear solver tolerance             = 1e-5
-set Dimension                              = 2
-set End time                               = 3e-8
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.078
-    set gamma = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# we apply simple shear here, so that the top and bottom boundaries
-# move with the same speed u0, but in opposite directions
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-
-  subsection Function
-    set Function constants = u0=5e2,ymid=0.0005
-    set Function expression = u0*(y/ymid-1.0);0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.004
-    set Y extent  = 0.001
-    set X periodic = true
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=64000
-    set Function expression = 0.0
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = shear bands initial condition
-end
-
-subsection Material model
-  set Model name = shear bands material
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, strain rate, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-24
-  set Temperature solver tolerance = 1e-20
-
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/shear_heating.prm.bak b/tests/shear_heating.prm.bak
deleted file mode 100644
index f2a820b47d9..00000000000
--- a/tests/shear_heating.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# A test case for shear heating. The viscosity is constant and a
-# constant shear strain rate is applied by prescribing the velocities
-# at the upper and lower boundaries of the box domain; the sides are
-# periodic. This yields a constant strain rate [[0,1/2],[1/2,0]]
-# with norm |dot eps|=1/sqrt(2), so that together with the viscosity
-# of 1, the shear heating 2 * eta * pow(|dot eps|,2) = 1.
-#
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set X periodic = true
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = heating, viscosity, strain rate
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/shear_heating_compressible.prm.bak b/tests/shear_heating_compressible.prm.bak
deleted file mode 100644
index 1f5a4f217f8..00000000000
--- a/tests/shear_heating_compressible.prm.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-# This is a test for the correct behavior of
-# the shear heating in the compressible case.
-# The velocity is prescribed using the prescribed
-# Stokes solution plugin so that the strain rate is
-# [0 0.5 0.5 2./3.], which means that we can calculate
-# the solution for the shear heating (2 eta eps:eps),
-# which should be 2.111111.
-
-set CFL number                             = 1
-set End time                               = 0
-set Adiabatic surface temperature          = 0.5
-set Surface pressure                       = 0.0
-set Use years in output instead of seconds = false
-set Pressure normalization                 = surface
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y
-    set Function expression = 0.0;x+y
-  end
-
-  subsection Pressure function
-    set Variable names = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 0.01
-    set Reference temperature = 0.5
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density = 1
-    set Reference specific heat = 1
-    set Thermal expansion coefficient = 0.1
-    set Viscosity = 1
-    set Thermal conductivity = 1e-7
-    set Reference compressibility = 1e-6
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Boundary velocity model
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;0.01
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics,  heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = heating, viscosity, strain rate
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/shear_heating_compressible_melt.prm.bak b/tests/shear_heating_compressible_melt.prm.bak
deleted file mode 100644
index ee6c2ca8036..00000000000
--- a/tests/shear_heating_compressible_melt.prm.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-# This is a copy of the shear_heating_compressible
-# test, except that it uses melt transport.
-
-# The test is for the correct behavior of
-# the shear heating in the compressible case.
-# The velocity is prescribed using the prescribed
-# Stokes solution plugin so that the strain rate is
-# [0 0.5 0.5 2./3.], which means that we can calculate
-# the solution for the shear heating (2 eta eps:eps),
-# which should be 2.111111.
-
-set CFL number                             = 1
-set End time                               = 0
-set Adiabatic surface temperature          = 0.5
-set Surface pressure                       = 0.0
-set Use years in output instead of seconds = false
-set Pressure normalization                 = surface
-set Nonlinear solver scheme                = single Advection, no Stokes
-set Use operator splitting                 = true
-
-subsection Melt settings
-  set Use discontinuous compaction pressure = false
-  set Include melt transport                  = true
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y
-    set Function expression = 0.0;x+y
-  end
-
-  subsection Fluid velocity function
-    set Variable names = x,y
-    set Function expression = 0.0;x+y
-  end
-
-  subsection Pressure function
-    set Variable names = x,y
-    set Function expression = 0.0
-  end
-
-  subsection Fluid pressure function
-    set Variable names = x,y
-    set Function expression = 0.0
-  end
-
-  subsection Compaction pressure function
-    set Variable names = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 0.01
-    set Reference temperature = 0.5
-  end
-end
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Reference solid density = 1
-    set Reference melt density        = 1
-    set Reference specific heat = 1
-    set Reference temperature = 0.5
-    set Thermal expansion coefficient = 0.1
-    set Reference shear viscosity = 1
-    set Reference bulk viscosity = 1e5
-    set Thermal conductivity = 1e-7
-    set Solid compressibility = 1e-6
-    set Use full compressibility = true
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Boundary velocity model
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;0.01
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics,  heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = heating, viscosity, strain rate, density
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/shear_heating_limited.prm.bak b/tests/shear_heating_limited.prm.bak
deleted file mode 100644
index 5b4723fcce2..00000000000
--- a/tests/shear_heating_limited.prm.bak
+++ /dev/null
@@ -1,30 +0,0 @@
-# A test case for shear heating. The viscosity is constant and a
-# constant shear strain rate is applied by prescribing the velocities
-# at the upper and lower boundaries of the box domain; the sides are
-# periodic. This yields a constant strain rate [[0,1/2],[1/2,0]]
-# with norm |dot eps|=1/sqrt(2), so that together with the viscosity
-# of 1, the shear heating 2 * eta * pow(|dot eps|,2) = 1.
-# We then limit the stress that is being used in the shear heating
-# computation to 0.5 Pa (half of the stress in the model), so the
-# resulting shear heating is 0.5 W/kg.
-
-include $ASPECT_SOURCE_DIR/tests/shear_heating.prm
-
-
-subsection Heating model
-  set List of model names = shear heating
-
-  subsection Shear heating
-    set Limit stress contribution to shear heating = true
-    set Cohesion for maximum shear stress = 0.5
-    set Friction angle for maximum shear stress = 0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = heating statistics, visualization
-
-  subsection Visualization
-    set List of output variables = heating, viscosity, strain rate, stress second invariant
-  end
-end
diff --git a/tests/shear_heating_with_melt.prm.bak b/tests/shear_heating_with_melt.prm.bak
deleted file mode 100644
index 73a574f4f64..00000000000
--- a/tests/shear_heating_with_melt.prm.bak
+++ /dev/null
@@ -1,210 +0,0 @@
-# This is a test for the heating model plugins related to
-# melt migration, in particular shear heating with melt.
-# In this 1D model, material is upwelling with a high temperature
-# from the bottom boundary and melting adiabatically. This
-# leads to dissipation heating due to the relative movement of
-# melt and solid. As these terms scale with 1/porosity, this
-# can lead to instabilities. However, this can be avoided by
-# choosing a resolution that is high enough and choosing the
-# Darcy coefficient variation threshold to be not too small
-# (here, the default value is sufficient).
-
-# The test is based on the model of 1D upwelling melting in a
-# plume with melt-related heating in the Supplementary material
-# of Dannberg & Heister, 2016.
-# To better compare the results with Dannberg & Heister, 2016,
-# the bottom boundary temperature can be changed to 2000 K
-# (this is just not feasible in the test, as it would take too
-# many time time steps until the onset of melting).
-
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-set Dimension                              = 2
-set End time                               = 1e4
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-set Use operator splitting                 = true
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-  set Composition polynomial degree     = 1
-
-  subsection Stabilization parameters
-    set beta  = 0.1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = 2
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 1850
-  end
-
-  subsection Function
-    set Function expression = if(y<150000,2200,293)
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    set Function constants  = u0=1.5
-    set Variable names      = x,z
-    set Function expression = 0;u0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 7200
-    set Y extent  = 300000
-    set Y repetitions = 40
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 5e9
-    set Age bottom boundary layer   = 0.0
-    set Amplitude                   = 0
-    set Radius                      = 0
-
-    subsection Function
-      set Function expression       = 0;0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,a = 1e-6, b = 300000, c = 20000, d=0.0
-    set Function expression = 0;0 #d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c)); d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = melt simple
-
-  subsection Melt simple
-    set Reference solid density = 3400
-    set Reference melt density = 2776
-    set Thermal expansion coefficient = 3.5e-5
-    set Reference permeability = 5e-9
-    set Reference shear viscosity = 5e18
-    set Reference bulk viscosity = 5e19
-    set Exponential melt weakening factor = 10
-    set Thermal viscosity exponent = 5
-    set Thermal bulk viscosity exponent = 5
-    set Reference temperature = 1600
-    set Solid compressibility = 3.2e-12
-    set Melt compressibility = 3.8462e-11
-    set Melt bulk modulus derivative = 1.6
-    set Use full compressibility = false
-    set Thermal conductivity = 4.7
-    set Melt extraction depth = 0.0
-    set Freezing rate = 0
-    set Mass fraction cpx = 0.1
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.00
-  set Refinement fraction                      = 0.999
-  set Initial adaptive refinement              = 1
-  set Initial global refinement                = 0
-  set Strategy                                 = minimum refinement function, composition threshold
-  set Time steps between mesh refinement       = 0
-
-  subsection Composition threshold
-    set Compositional field thresholds = 5e-6,1.0
-  end
-
-  subsection Composition
-    set Compositional field scaling factors = 1,0
-  end
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Function expression = if(y>220000,0,0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-  set Heat advection by melt                  = true
-end
-
-subsection Heating model
-  set List of model names                     = adiabatic heating, latent heat melt, shear heating, adiabatic heating of melt, shear heating with melt
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics,velocity statistics, mass flux statistics, heating statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set List of output variables      = material properties, melt material properties, nonadiabatic temperature, nonadiabatic pressure, melt fraction, heating
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set Time between graphical output = 2500
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
diff --git a/tests/shear_thinning.cc.bak b/tests/shear_thinning.cc.bak
deleted file mode 100644
index 47997051b48..00000000000
--- a/tests/shear_thinning.cc.bak
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class ShearThinning : public MaterialModel::Simple<dim>
-    {
-      public:
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-        void
-        parse_parameters (ParameterHandler &prm);
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    ShearThinning<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      Simple<dim>::evaluate(in, out);
-      if (in.requests_property(MaterialProperties::viscosity))
-        for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-          out.viscosities[i] = 1./(1+in.strain_rate[i].norm());
-    }
-
-    template <int dim>
-    void
-    ShearThinning<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      Simple<dim>::parse_parameters(prm);
-
-      // Declare dependencies on solution variables that are different from simple
-      this->model_dependence.viscosity = MaterialModel::NonlinearDependence::strain_rate;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(ShearThinning,
-                                   "shear thinning",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but has a viscosity equal to 1/|strain rate|.")
-  }
-}
-
-
-
-#include <aspect/postprocess/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    class ShearThinning : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        virtual
-        std::pair<std::string,std::string>
-        execute (TableHandler &);
-    };
-  }
-}
-
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    template <int dim>
-    std::pair<std::string,std::string>
-    ShearThinning<dim>::execute (TableHandler &)
-    {
-      // create a quadrature formula based on the temperature element alone.
-      // be defensive about determining that what we think is the temperature
-      // element is indeed the temperature element
-      Assert (this->get_fe().n_base_elements() == 3+(this->n_compositional_fields()>0 ? 1 : 0),
-              ExcNotImplemented());
-      const QGauss<dim> quadrature_formula (this->get_fe().base_element(2).degree+1);
-
-      FEValues<dim> fe_values (this->get_mapping(),
-                               this->get_fe(),
-                               quadrature_formula,
-                               update_gradients         | update_values |
-                               update_quadrature_points | update_JxW_values);
-
-      std::vector<std::vector<double>> composition_values (this->n_compositional_fields(),std::vector<double> (quadrature_formula.size()));
-
-      typename DoFHandler<dim>::active_cell_iterator
-      cell = this->get_dof_handler().begin_active(),
-      endc = this->get_dof_handler().end();
-
-      typename MaterialModel::MaterialModelInputs<dim> in(fe_values.n_quadrature_points, this->n_compositional_fields());
-      typename MaterialModel::MaterialModelOutputs<dim> out(fe_values.n_quadrature_points, this->n_compositional_fields());
-      in.requested_properties = MaterialModel::MaterialProperties::viscosity;
-
-      // compute the integral of the viscosity. since we're on a unit box,
-      // this also is the average value
-      double viscosity_integral = 0;
-      for (; cell!=endc; ++cell)
-        if (cell->is_locally_owned())
-          {
-            fe_values.reinit (cell);
-            fe_values[this->introspection().extractors.temperature].get_function_values (this->get_solution(),
-                                                                                         in.temperature);
-            fe_values[this->introspection().extractors.pressure].get_function_values (this->get_solution(),
-                                                                                      in.pressure);
-            fe_values[this->introspection().extractors.velocities].get_function_symmetric_gradients (this->get_solution(),
-                in.strain_rate);
-            for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-              fe_values[this->introspection().extractors.compositional_fields[c]].get_function_values(this->get_solution(),
-                  composition_values[c]);
-
-            in.position = fe_values.get_quadrature_points();
-            for (unsigned int i=0; i<fe_values.n_quadrature_points; ++i)
-              {
-                for (unsigned int c=0; c<this->n_compositional_fields(); ++c)
-                  in.composition[i][c] = composition_values[c][i];
-              }
-
-            this->get_material_model().evaluate(in, out);
-
-
-            for (unsigned int q=0; q<fe_values.n_quadrature_points; ++q)
-              viscosity_integral += out.viscosities[q] * fe_values.JxW(q);
-          }
-
-      std::ostringstream screen_text;
-      screen_text.precision(4);
-      screen_text << Utilities::MPI::sum(viscosity_integral, this->get_mpi_communicator());
-
-      return std::pair<std::string, std::string> ("Average viscosity:",
-                                                  screen_text.str());
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(ShearThinning,
-                                  "shear thinning",
-                                  "A postprocessor that computes some statistics about "
-                                  "the viscosity.")
-  }
-}
diff --git a/tests/shear_thinning.prm.bak b/tests/shear_thinning.prm.bak
deleted file mode 100644
index b97a2990bb4..00000000000
--- a/tests/shear_thinning.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# A testcase that demonstrates shear thinning. It solves the
-# equations on a box with Dirichlet boundary conditions equal to
-# (z,0), which then is also the velocity everywhere. This yields
-# a constant strain rate [[0,1/2],[1/2,0]] with norm |dot eps|=1/sqrt(2).
-#
-# We then have a viscosity that depends on
-# the strain rate as eta=1/(1+|dot eps|). Because the strain rate
-# is constant, so is the viscosity.
-#
-# In this version of the testcase, we only run a single Advection and a single Stokes step,
-# so the viscosity we use for the first velocity step is eta=1.
-# We can only tell that the correct viscosity is computed in a
-# postprocessor, which we implement in the .cc file. The correct
-# value that needs to be computed is viscosity=1/(1+|dot eps|),
-# i.e., viscosity=0.585786
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = shear thinning
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = shear thinning
-end
diff --git a/tests/shearbox_particle_strain_rate.prm.bak b/tests/shearbox_particle_strain_rate.prm.bak
deleted file mode 100644
index 725fb4c788a..00000000000
--- a/tests/shearbox_particle_strain_rate.prm.bak
+++ /dev/null
@@ -1,186 +0,0 @@
-# A description of convection in a 3d box. See the manual for more information.
-set CFL number = 0.1
-set Timing output frequency = 5000
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 3
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is. We
-# also designate an output directory.
-set Use years in output instead of seconds = false
-set End time                               = 0.001 #100. #00.0 #0.0125 #5.0
-set Nonlinear solver scheme = single Advection, no Stokes
-set Output directory  = test_shearbox3d
-
-# Then there are variables that describe how the pressure should
-# be normalized. Here, we choose a zero average pressure
-# at the surface of the domain (for the current geometry, the
-# surface is defined as the top boundary).
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-    set Box origin X coordinate = -0.5
-    set Box origin Y coordinate = -0.5
-    set Box origin Z coordinate = -0.5
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1 ## Annotation: Temperature function
-  end
-end
-
-# Then follows a section that describes the boundary conditions for the
-# temperature. The model we choose is called 'box' and allows to set a constant
-# temperature on each of the four sides of the box geometry. In our case, we
-# choose something that is heated from below and cooled from above.
-# All other parts of the boundary are insulated (i.e., no heat flux through
-# these boundaries; this is also often used to specify symmetry boundaries).
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top, left, right, front, back
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 1
-    set Right temperature  = 1
-    set Top temperature    = 1
-    set Front temperature  = 1
-    set Back temperature   = 1
-  end
-end
-
-subsection Boundary velocity model
-  subsection Function
-    set Variable names = x,y,z,t
-    set Function expression = z;0;0; ## Annotation: set velocity condition
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,z,t
-    set Function expression = z;0;0; ## Annotation: set velocity condition
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple # default:
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-
-  #  set Time steps between mesh refinement       = 5
-  #  set Strategy = strain rate
-
-  #  set Additional refinement times              = 0.003
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, visualization, particles
-
-  subsection Visualization
-    set Time between graphical output = 0.001 #0.024999
-    set List of output variables = strain rate tensor
-  end
-
-  subsection Particles
-    set Time between data output = 0.001 #0.02499999999999
-    set Data output format       = vtu, ascii
-  end
-end
-
-subsection Checkpointing
-  # The number of timesteps between performing checkpoints. If 0 and time
-  # between checkpoint is not specified, checkpointing will not be performed.
-  # Units: None.
-  #set Steps between checkpoint = 50
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
-
-subsection Particles
-  set List of particle properties =  integrated strain invariant, strain rate
-  set Particle generator name = ascii file
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = $ASPECT_SOURCE_DIR/data/particle/generator/ascii/
-      set Data file name = shearbox_particle_strain_rate.dat
-    end
-  end
-end
diff --git a/tests/shell_2d_gmg.prm.bak b/tests/shell_2d_gmg.prm.bak
deleted file mode 100644
index d29de762b21..00000000000
--- a/tests/shell_2d_gmg.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# 2d shell with no flux top boundary to test GMG
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1.0e5
-set Output directory                       = output-shell_2d_gmg
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average only viscosity
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 2
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e5
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/tests/shell_3d_gmg.prm.bak b/tests/shell_3d_gmg.prm.bak
deleted file mode 100644
index cb123cdc243..00000000000
--- a/tests/shell_3d_gmg.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# 3d shell with GMG
-# MPI: 4
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0.0
-set Output directory                       = output-shell_simple_3d
-set Nonlinear solver scheme                = no Advection, single Stokes
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average only viscosity
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = bottom
-  set Tangential velocity boundary indicators = top
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 1973
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.473e3
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 1
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 1
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1.5e6
-    set Output format                 = vtu
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 50
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1e-4
-  end
-end
diff --git a/tests/shell_boundary_composition_spherical_constant.prm.bak b/tests/shell_boundary_composition_spherical_constant.prm.bak
deleted file mode 100644
index 811b6c62f44..00000000000
--- a/tests/shell_boundary_composition_spherical_constant.prm.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-# 2d shell with 'spherical constant' boundary composition
-# for multiple compositions.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output-shell_boundary_composition_spherical_constant
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average only viscosity
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Boundary composition model
-  set List of model names = spherical constant
-  set Fixed composition boundary indicators = top, bottom
-
-  subsection Spherical constant
-    set Inner composition = 1,2
-    set Outer composition = 2,3
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 2; 2
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-end
diff --git a/tests/shell_quarter_BC.prm.bak b/tests/shell_quarter_BC.prm.bak
deleted file mode 100644
index 241cc75947f..00000000000
--- a/tests/shell_quarter_BC.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# This is a copy of shell_quarter_gmg.prm.
-# It tests if boundary conditions are applied correctly at
-# tangential boundaries (in this case, top) when they are not
-# fixed on outflow parts of the boundary.
-
-include $ASPECT_SOURCE_DIR/tests/shell_quarter_gmg.prm
-
-set End time                               = 3e6
-
-subsection Boundary temperature model
-  set Allow fixed temperature on outflow boundaries = false
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       =
-  set Tangential velocity boundary indicators = top, left, right, bottom
-end
diff --git a/tests/shell_quarter_gmg.prm.bak b/tests/shell_quarter_gmg.prm.bak
deleted file mode 100644
index 95ea7bb5243..00000000000
--- a/tests/shell_quarter_gmg.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# 2d quarter shell with no flux top boundary to test GMG
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1.0e5
-set Output directory                       = output-shell_2d_gmg
-
-subsection Material model
-  set Model name = simple
-  set Material averaging = harmonic average
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = top, left, right
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 2
-  set Initial adaptive refinement        = 2
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                 = vtu
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e5
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/tests/shell_surface_base_variables.prm.bak b/tests/shell_surface_base_variables.prm.bak
deleted file mode 100644
index d47555aad0f..00000000000
--- a/tests/shell_surface_base_variables.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# A quarter-shell spherical 2d model to test
-# the output of the base variables velocity, pressure
-# temperature etc on the mesh boundary.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e300
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false  # default: true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-# The parameters below this comment were created by the update script
-# as replacement for the old 'Model settings' subsection. They can be
-# safely merged with any existing subsections with the same name.
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Termination criteria
-  set Termination criteria      = end step
-  set End step                  = 1
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613 # default: 293
-    set Thermal conductivity          = 1e-6 # default: 4.7
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22    # default: 5e24
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Additional refinement times        = 0,0
-  set Strategy = velocity
-  set Time steps between mesh refinement = 2
-  set Refinement fraction                = 0.8
-  set Coarsening fraction                = 0.0
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 2413.0, 1613)
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, spherical velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-    set Output base variables on mesh surface = true
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/shell_with_variable_coordinate_systems.prm.bak b/tests/shell_with_variable_coordinate_systems.prm.bak
deleted file mode 100644
index 5cbd7313921..00000000000
--- a/tests/shell_with_variable_coordinate_systems.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# A simple setup for convection in a quarter of a 2d shell with
-# user input allowing for different coordinate systems
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Output directory                       = output
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = .45
-    set Outer radius  = 1
-    set Opening angle = 360
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Prescribed velocity boundary indicators = outer:function
-
-  subsection Function
-    set Variable names = r,phi
-    set Coordinate system = spherical
-    set Function expression = if (phi < 3.14159265, 1e-8*cos(phi), -1e-8*cos(phi)) ; 5e-8*cos(phi)
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner, outer
-  set List of model names = function
-
-  subsection Spherical constant
-    set Inner temperature = 4370
-    set Outer temperature = 273
-  end
-
-  subsection Function
-    set Variable names = r,phi
-    set Coordinate system = spherical
-    set Function expression = if ((r >0.9 && phi <  3.14159265), 0, 386)
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 5
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 1e6
-    set Number of grouped files       = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-  end
-end
diff --git a/tests/signal_fem.cc.bak b/tests/signal_fem.cc.bak
deleted file mode 100644
index 43a2872fb9e..00000000000
--- a/tests/signal_fem.cc.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-#include <aspect/simulator/assemblers/interface.h>
-
-#include <deal.II/fe/fe_dgq.h>
-#include <iostream>
-
-using namespace dealii;
-
-namespace aspect
-{
-
-  template <int dim>
-  void my_signal(std::vector<VariableDeclaration<dim>> &variables)
-  {
-    std::cout << "* signals.edit_finite_element_variables:" << std::endl;
-
-    VariableDeclaration<dim> dummy("dummy",
-                                   std::make_shared<FE_DGQ<dim>>(4),
-                                   2,
-                                   1);
-    variables.insert(variables.begin()+3, dummy);
-
-    for (unsigned int i=0; i<variables.size(); ++i)
-      {
-        std::cout << " name=" << variables[i].name
-                  << " fe=" << variables[i].fe->get_name()
-                  << " multiplicity=" << variables[i].multiplicity
-                  << " n_blocks=" << variables[i].n_blocks
-                  << " n_components=" << variables[i].n_components()
-                  << std::endl;
-      }
-
-    std::cout << std::endl;
-  }
-}
-
-
-
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  std::cout << "* Connecting signals" << std::endl;
-  signals.edit_finite_element_variables.connect(&aspect::my_signal<dim>);
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/signal_fem.prm.bak b/tests/signal_fem.prm.bak
deleted file mode 100644
index b0cc97254a5..00000000000
--- a/tests/signal_fem.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# A test that adds an assembler that tests if we can create additional
-# material model outputs
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = A, B
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;0
-    set Variable names      = x,y
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set List of output variables      = viscosity
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/signals.cc.bak b/tests/signals.cc.bak
deleted file mode 100644
index d9542efa2eb..00000000000
--- a/tests/signals.cc.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// make sure we can include deal.II and aspect files
-#include <aspect/simulator_signals.h>
-
-#include <iostream>
-
-using namespace aspect;
-
-
-// create a function that is run upon loading the plugin
-// when declaring parameters, and that produces some output
-void declare_parameters(const unsigned int dim,
-                        ParameterHandler &prm)
-{
-  std::cout << "declaring parameters" << std::endl;
-  prm.declare_entry("abc", "42", Patterns::Integer(21,43));
-}
-
-
-// same for parsing parameters
-template <int dim>
-void parse_parameters(const Parameters<dim> &parameters,
-                      ParameterHandler &prm)
-{
-  std::cout << "parsing parameters: abc="
-            << prm.get("abc") << std::endl;
-  Assert (prm.get_integer ("abc") == 21, ExcInternalError());
-}
-
-
-void parameter_connector ()
-{
-  SimulatorSignals<2>::declare_additional_parameters.connect (&declare_parameters);
-  SimulatorSignals<3>::declare_additional_parameters.connect (&declare_parameters);
-
-  SimulatorSignals<2>::parse_additional_parameters.connect (&parse_parameters<2>);
-  SimulatorSignals<3>::parse_additional_parameters.connect (&parse_parameters<3>);
-}
-
-
-ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(parameter_connector)
diff --git a/tests/signals.prm.bak b/tests/signals.prm.bak
deleted file mode 100644
index c8d149ed66b..00000000000
--- a/tests/signals.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# a test that simply verifies that the plugin described in
-# signals.cc is indeed run and that it can declare and
-# parse parameters
-
-
-# a parameter declared from a slot connected to a signal
-set abc = 21
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/signals_connect.cc.bak b/tests/signals_connect.cc.bak
deleted file mode 100644
index d30a2127fa5..00000000000
--- a/tests/signals_connect.cc.bak
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_signals.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-
-using namespace aspect;
-
-
-template <int dim>
-void post_constraints_creation (const SimulatorAccess<dim> &,
-                                AffineConstraints<double> &)
-{
-  std::cout << std::endl
-            << "*** constraints signal called ***"
-            << std::endl
-            << std::endl;
-}
-
-
-template <int dim>
-void signal_connector (SimulatorSignals<dim> &signals)
-{
-  std::cout << "Connecting signals" << std::endl;
-  signals.post_constraints_creation.connect (&post_constraints_creation<dim>);
-}
-
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/signals_connect.prm.bak b/tests/signals_connect.prm.bak
deleted file mode 100644
index 2a0c7c469f0..00000000000
--- a/tests/signals_connect.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-# a test that simply verifies that the plugin described in
-# signals_connect.cc is indeed run and that it can declare and
-# parse parameters
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/signals_post_constraints.cc.bak b/tests/signals_post_constraints.cc.bak
deleted file mode 100644
index f7dea1de7aa..00000000000
--- a/tests/signals_post_constraints.cc.bak
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_signals.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-
-using namespace aspect;
-
-
-template <int dim>
-void post_constraints_creation (const SimulatorAccess<dim> &simulator_access,
-                                AffineConstraints<double> &current_constraints)
-{
-  simulator_access.get_statistics_object()
-  .add_value ("number of constraints",
-              current_constraints.n_constraints());
-}
-
-
-template <int dim>
-void signal_connector (SimulatorSignals<dim> &signals)
-{
-  signals.post_constraints_creation.connect (&post_constraints_creation<dim>);
-}
-
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/signals_post_constraints.prm.bak b/tests/signals_post_constraints.prm.bak
deleted file mode 100644
index 1255e5d6f4f..00000000000
--- a/tests/signals_post_constraints.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-# output some status information for every time step from the
-# post-constraints signal
-#
-# otherwise identical to blankenbach.prm
-
-set End time                               = 0.002 # 1.0 for full benchmark
-set Use years in output instead of seconds = false
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e3
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = z1=0.102367, z2=0.897633, pi=3.14159265359
-    set Function expression = if(z<z1,0.5+0.5*(z1-z)/z1,if(z>z2,0.5*(1-z)/(1-z2),0.5)) + 0.1 * cos(x*pi) * sin(z*pi)
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-3
-    set Viscosity                     = 1e-4
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/simple_composite.prm.bak b/tests/simple_composite.prm.bak
deleted file mode 100644
index a3b65c4ffc9..00000000000
--- a/tests/simple_composite.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# Duplicate of simple incompressible test using a compositing model to
-# select all material properties from the simple incompressible model.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = compositing
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-
-  subsection Compositing
-    set Viscosity = simple
-    set Density = simple
-    set Thermal expansion coefficient = simple
-    set Specific heat = simple
-    set Thermal conductivity = simple
-    set Compressibility = simple
-    set Entropy derivative pressure = simple
-    set Entropy derivative temperature = simple
-    set Reaction terms = simple
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/simple_compressibility_iterated_stokes.cc.bak b/tests/simple_compressibility_iterated_stokes.cc.bak
deleted file mode 100644
index aff05b345ec..00000000000
--- a/tests/simple_compressibility_iterated_stokes.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "compressibility.cc"
diff --git a/tests/simple_compressibility_iterated_stokes.prm.bak b/tests/simple_compressibility_iterated_stokes.prm.bak
deleted file mode 100644
index 88d8fa0f358..00000000000
--- a/tests/simple_compressibility_iterated_stokes.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# A variation on the 'compressibility_iterated_stokes' testcase.
-# The only variation is the used material model. This test adapts the
-# 'simple compressible' material model plugin to do the same job as the
-# shared library material model from compressibility_iterated_stokes.cc
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Max nonlinear iterations               = 5
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density             = 0.909090909090
-    set Reference compressibility     = 0.01
-    set Reference specific heat       = 1250
-    set Thermal conductivity          = 1e-6
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1
-  set Prescribed velocity boundary indicators = 2: function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = compressibility
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/simple_compressibility_iterated_stokes_gmg.cc.bak b/tests/simple_compressibility_iterated_stokes_gmg.cc.bak
deleted file mode 100644
index aff05b345ec..00000000000
--- a/tests/simple_compressibility_iterated_stokes_gmg.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "compressibility.cc"
diff --git a/tests/simple_compressibility_iterated_stokes_gmg.prm.bak b/tests/simple_compressibility_iterated_stokes_gmg.prm.bak
deleted file mode 100644
index e4c6cc1614d..00000000000
--- a/tests/simple_compressibility_iterated_stokes_gmg.prm.bak
+++ /dev/null
@@ -1,19 +0,0 @@
-# like simple_compressibility_iterated_stokes.prm but using GMG
-
-include $ASPECT_SOURCE_DIR/tests/simple_compressibility_iterated_stokes.prm
-
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
diff --git a/tests/simple_compressible.prm.bak b/tests/simple_compressible.prm.bak
deleted file mode 100644
index 44d94da9cd2..00000000000
--- a/tests/simple_compressible.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# This is a relatively realistic compressible model setup.
-# There is no simple analytical solution to it, it is rather
-# intended to serve as a comparison for more complicated
-# material models, which should be able to reproduce it.
-# The material model used here is already tested by
-# simple_compressibility_iterated_stokes.
-# Currently there is the steinberger_compressible test
-# reproducing this test.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-    set Reference compressibility = 2.5e-12
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/simple_incompressible.prm.bak b/tests/simple_incompressible.prm.bak
deleted file mode 100644
index 05fd020e33e..00000000000
--- a/tests/simple_incompressible.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# This is a relatively realistic incompressible model setup.
-# There is no simple analytical solution to it, it is rather
-# intended to serve as a comparison for more complicated
-# material models, which should be able to reproduce it.
-# Currently there is the steinberger_incompressible test
-# reproducing this test.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/simple_nonlinear.cc.bak b/tests/simple_nonlinear.cc.bak
deleted file mode 100644
index db839536247..00000000000
--- a/tests/simple_nonlinear.cc.bak
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/newton.h>
-
-#include <iostream>
-
-#include <aspect/utilities.h>
-
-#include "../benchmarks/newton_solver_benchmark_set/nonlinear_channel_flow/simple_nonlinear.cc"
-
-template <int dim>
-int f(double parameter)
-{
-
-  std::cout << std::endl << "Test for p = " << parameter << " with dimension " << dim << std::endl;
-
-  using namespace aspect::MaterialModel;
-
-  // first set all material model values
-  MaterialModelInputs<dim> in_base(5,3);
-  in_base.composition[0][0] = 0;
-  in_base.composition[0][1] = 0;
-  in_base.composition[0][2] = 0;
-  in_base.composition[1][0] = 0.75;
-  in_base.composition[1][1] = 0.15;
-  in_base.composition[1][2] = 0.10;
-  in_base.composition[2][0] = 0;
-  in_base.composition[2][1] = 0.2;
-  in_base.composition[2][2] = 0.4;
-  in_base.composition[3][0] = 0;
-  in_base.composition[3][1] = 0.2;
-  in_base.composition[3][2] = 0.4;
-  in_base.composition[4][0] = 1;
-  in_base.composition[4][1] = 0;
-  in_base.composition[4][2] = 0;
-
-  in_base.temperature[0] = 293;
-  in_base.temperature[1] = 1600;
-  in_base.temperature[2] = 2000;
-  in_base.temperature[3] = 2100;
-  in_base.temperature[4] = 2200;
-
-  in_base.pressure[0] = 1e9;
-  in_base.pressure[1] = 5e9;
-  in_base.pressure[2] = 2e10;
-  in_base.pressure[3] = 2e11;
-  in_base.pressure[4] = 2e12;
-
-  /**
-   * We can't take to small strain-rates, because then the difference in the
-   * viscosity will be too small for the double accuracy which stores
-   * the viscosity solutions and the finite difference solution.
-   */
-  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
-  in_base.strain_rate[0][0][0] = 1e-12;
-  in_base.strain_rate[0][0][1] = 1e-12;
-  in_base.strain_rate[0][1][1] = 1e-11;
-  if (dim == 3)
-    {
-      in_base.strain_rate[0][2][0] = 1e-12;
-      in_base.strain_rate[0][2][1] = 1e-12;
-      in_base.strain_rate[0][2][2] = 1e-11;
-    }
-
-  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[1][0][0] = -1.71266e-13;
-  in_base.strain_rate[1][0][1] = -5.82647e-12;
-  in_base.strain_rate[1][1][1] = 4.21668e-14;
-  if (dim == 3)
-    {
-      in_base.strain_rate[1][2][0] = -5.42647e-12;
-      in_base.strain_rate[1][2][1] = -5.22647e-12;
-      in_base.strain_rate[1][2][2] = 4.21668e-14;
-    }
-  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[2][1][1] = 1e-13;
-  in_base.strain_rate[2][0][1] = 1e-11;
-  in_base.strain_rate[2][0][0] = -1e-12;
-  if (dim == 3)
-    {
-      in_base.strain_rate[2][2][0] = 1e-11;
-      in_base.strain_rate[2][2][1] = 1e-11;
-      in_base.strain_rate[2][2][2] = -1e-12;
-    }
-  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[3][1][1] = 4.9e-21;
-  in_base.strain_rate[3][0][1] = 4.9e-21;
-  in_base.strain_rate[3][0][0] = 4.9e-21;
-  if (dim == 3)
-    {
-      in_base.strain_rate[3][2][0] = 4.9e-21;
-      in_base.strain_rate[3][2][1] = 4.9e-21;
-      in_base.strain_rate[3][2][2] = 4.9e-21;
-    }
-  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[4][1][1] = 1e-11;
-  in_base.strain_rate[4][0][1] = 1e-11;
-  in_base.strain_rate[4][0][0] = 1e-11;
-  if (dim == 3)
-    {
-      in_base.strain_rate[4][2][0] = 1e-11;
-      in_base.strain_rate[4][2][1] = 1e-11;
-      in_base.strain_rate[4][2][2] = 1e-11;
-    }
-
-  // initialize some variables we will need later.
-  double finite_difference_accuracy = 1e-7;
-  double finite_difference_factor = 1+finite_difference_accuracy;
-
-
-  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
-
-  MaterialModelOutputs<dim> out_base(5,3);
-  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
-
-  if (out_base.template get_additional_output<MaterialModelDerivatives<dim>>() != nullptr)
-    throw "error";
-
-  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
-
-  // initialize the material we want to test.
-  SimpleNonlinear<dim> mat;
-  ParameterHandler prm;
-  mat.declare_parameters(prm);
-
-  prm.enter_subsection("Compositional fields");
-  {
-    prm.set("Number of fields","3");
-  }
-  prm.leave_subsection();
-  prm.enter_subsection("Material model");
-  {
-    prm.enter_subsection ("Simple nonlinear");
-    {
-      prm.set ("Viscosity prefactor", "1e-37,1e-36,1e-35,5e-36");
-      prm.set ("Viscosity averaging p", std::to_string(parameter));
-      prm.set ("Minimum strain rate", 1.4e-20);
-    }
-    prm.leave_subsection();
-  }
-  prm.leave_subsection();
-
-  mat.parse_parameters(prm);
-
-  mat.evaluate(in_base, out_base);
-
-  // set up additional output for the derivatives
-  MaterialModelDerivatives<dim> *derivatives;
-  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
-  double temp;
-
-  // have a bool so we know whether the test has succeed or not.
-  bool Error = false;
-
-  // this material is not pressure dependent, so we do not test it.
-
-  // test the strain-rate derivative.
-  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
-    {
-      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
-                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
-                                                    * finite_difference_accuracy
-                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
-        }
-
-
-      mat.evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          // prevent division by zero. If it is zero, the test has passed, because or
-          // the finite difference and the analytical result match perfectly, or (more
-          // likely) the material model in independent of this variable.
-          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
-          if (temp != 0)
-            {
-              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
-            }
-          std::cout << "strain-rate: component = " << component << ", point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
-          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
-            {
-              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
-              Error = true;
-            }
-
-        }
-
-    }
-
-  if (Error)
-    {
-      std::cout << "Some parts of the test were not successful." << std::endl;
-    }
-  else
-    {
-      std::cout << "OK" << std::endl;
-    }
-
-  return 42;
-}
-
-int exit_function()
-{
-  exit(0);
-  return 42;
-}
-// run this function by initializing a global variable by it
-// test 2D
-int ii2 = f<2>(-1000); // Testing min function
-int iz2 = f<2>(-2); // Testing generalized p norm mean with negative p
-int ij2 = f<2>(-1.5); // Testing generalized p norm mean with negative, non int p
-int ik2 = f<2>(-1); // Testing harmonic mean
-int ji2 = f<2>(0); // Testing geometric mean
-int jj2 = f<2>(1); // Testing arithmetic mean
-int jk2 = f<2>(2); // Testing generalized p norm mean with positive p
-int kj2 = f<2>(1000); // Testing max function
-// test 3D
-int ii3 = f<3>(-1000); // Testing min function
-int iz3 = f<3>(-2); // Testing generalized p norm mean with negative p
-int ij3 = f<3>(-1.5); // Testing generalized p norm mean with negative, non int p
-int ik3 = f<3>(-1); // Testing harmonic mean
-int ji3 = f<3>(0); // Testing geometric mean
-int jj3 = f<3>(1); // Testing arithmetic mean
-int jk3 = f<3>(2); // Testing generalized p norm mean with positive p
-int kj3 = f<3>(1000); // Testing max function
-// exit
-int kl2 = exit_function();
diff --git a/tests/simple_nonlinear.prm.bak b/tests/simple_nonlinear.prm.bak
deleted file mode 100644
index df918fdb908..00000000000
--- a/tests/simple_nonlinear.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-# This test checks whether the derivatives of the simple nonlinear
-# material model are the same as the finite difference derivatives
-# created by the simple nonlinear material model.
-set Additional shared libraries = tests/libsimple_nonlinear.so
diff --git a/tests/simple_shear.cc.bak b/tests/simple_shear.cc.bak
deleted file mode 100644
index 8cb157267d4..00000000000
--- a/tests/simple_shear.cc.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class FiniteStrain : public MaterialModel::Simple<dim>
-    {
-      public:
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-        virtual void parse_parameters(ParameterHandler &prm);
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    FiniteStrain<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // First, we use the material descriptions of the 'simple' material model to fill all of the material
-      // model outputs. Below, we will then overwrite selected properties (the reaction terms), which are
-      // needed to track the finite strain.
-      Simple<dim>::evaluate(in, out);
-
-      // We need the velocity gradient for the finite strain (they are not included in material model inputs),
-      // so we get them from the finite element.
-      if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0)
-        {
-          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +1);
-          FEValues<dim> fe_values (this->get_mapping(),
-                                   this->get_fe(),
-                                   quadrature_formula,
-                                   update_gradients);
-
-          std::vector<Tensor<2,dim>> velocity_gradients (quadrature_formula.size(), Tensor<2,dim>());
-
-          fe_values.reinit (in.current_cell);
-          fe_values[this->introspection().extractors.velocities].get_function_gradients (this->get_solution(),
-                                                                                         velocity_gradients);
-
-          // Assign the strain components to the compositional fields reaction terms.
-          // If there are too many fields, we simply fill only the first fields with the
-          // existing strain rate tensor components.
-          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
-            {
-              // Convert the compositional fields into the tensor quantity they represent.
-              const Tensor<2,dim> strain(make_array_view(&in.composition[q][0],
-                                                         &in.composition[q][0] + Tensor<2,dim>::n_independent_components));
-
-              // Compute the strain accumulated in this timestep.
-              const Tensor<2,dim> strain_increment = this->get_timestep() * (velocity_gradients[q] * strain);
-
-              // Output the strain increment component-wise to its respective compositional field's reaction terms.
-              strain_increment.unroll(&out.reaction_terms[q][0],
-                                      &out.reaction_terms[q][0] + Tensor<2,dim>::n_independent_components);
-            }
-        }
-    }
-
-
-    template <int dim>
-    void
-    FiniteStrain<dim>::
-    parse_parameters (ParameterHandler &prm)
-    {
-      Simple<dim>::parse_parameters (prm);
-
-      AssertThrow(this->n_compositional_fields() >= (Tensor<2,dim>::n_independent_components),
-                  ExcMessage("There must be at least as many compositional fields as independent components in the full "
-                             "strain rate tensor."));
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(FiniteStrain,
-                                   "finite strain",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but tracks the finite strain as compositional "
-                                   "fields. The model assumes that the first 4 (in 2D) "
-                                   " or 9 (in 3D) compositional fields contain the finite "
-                                   "strain components. ")
-  }
-}
diff --git a/tests/simple_shear.prm.bak b/tests/simple_shear.prm.bak
deleted file mode 100644
index 0d2d8a40cf9..00000000000
--- a/tests/simple_shear.prm.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-# This parameter file reproduces an analytical benchmark for the evolution
-# of finite strain in a model of simple shear as described (for a specific
-# application) in McKenzie & Jackson (1983): "The relationship between
-# strain rates, crustal thickening, paleomagnetism, finite strain and
-# fault movements within a deforming zone." They show that the analytical
-# solution for the deformation gradient tensor F in simple shear deformation is:
-#
-# F_xx = 1.0
-# F_xy = u_x,y * t
-# F_yx = 0
-# F_yy = 1.0,
-#
-# where u is the velocity, t is time, and a comma represents a derivative
-# in that particular direction.
-# Because u_x,y = 2.0 / 1.0 is constant in the whole domain (and over time) we expect
-# a constant F at any given time, and in particular:
-# F_xy (t=1.0) = 2.0
-#
-# This parameter file tracks the finite strain in two ways, once by using
-# compositional fields as illustrated in the finite strain cookbook, and
-# once by using a particle particle that sits and remains in the center of the domain.
-# The results should of course be the same.
-#
-# Numerical results for particle tracking and compositional fields
-# show equally excellent agreement:
-# F_xy (t=1.0) = 2.0
-
-set Dimension                              = 2
-set End time                               = 0.025
-set Use years in output instead of seconds = false
-set Output directory = simple_shear
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set X periodic = true
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-
-  subsection Function
-    set Function expression = if (y < 0.5, -1, 1); 0
-  end
-end
-
-subsection Material model
-  set Model name = finite strain
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0;0.0;0.0;1.0
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, composition statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = strain rate, stress, principal stress
-    set Output format = gnuplot
-    set Time between graphical output = 0.05
-  end
-
-  subsection Particles
-    set Time between data output = 0.05
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain
-  set Particle generator name = ascii file
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/finite_strain/
-      set Data file name = simple_shear_particle.dat
-    end
-  end
-end
diff --git a/tests/simple_shear_output_the_mobility.cc.bak b/tests/simple_shear_output_the_mobility.cc.bak
deleted file mode 100644
index 8cb157267d4..00000000000
--- a/tests/simple_shear_output_the_mobility.cc.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class FiniteStrain : public MaterialModel::Simple<dim>
-    {
-      public:
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-        virtual void parse_parameters(ParameterHandler &prm);
-    };
-
-  }
-}
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-
-    template <int dim>
-    void
-    FiniteStrain<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      // First, we use the material descriptions of the 'simple' material model to fill all of the material
-      // model outputs. Below, we will then overwrite selected properties (the reaction terms), which are
-      // needed to track the finite strain.
-      Simple<dim>::evaluate(in, out);
-
-      // We need the velocity gradient for the finite strain (they are not included in material model inputs),
-      // so we get them from the finite element.
-      if (in.current_cell.state() == IteratorState::valid && this->get_timestep_number() > 0)
-        {
-          const QGauss<dim> quadrature_formula (this->introspection().polynomial_degree.velocities +1);
-          FEValues<dim> fe_values (this->get_mapping(),
-                                   this->get_fe(),
-                                   quadrature_formula,
-                                   update_gradients);
-
-          std::vector<Tensor<2,dim>> velocity_gradients (quadrature_formula.size(), Tensor<2,dim>());
-
-          fe_values.reinit (in.current_cell);
-          fe_values[this->introspection().extractors.velocities].get_function_gradients (this->get_solution(),
-                                                                                         velocity_gradients);
-
-          // Assign the strain components to the compositional fields reaction terms.
-          // If there are too many fields, we simply fill only the first fields with the
-          // existing strain rate tensor components.
-          for (unsigned int q=0; q < in.n_evaluation_points(); ++q)
-            {
-              // Convert the compositional fields into the tensor quantity they represent.
-              const Tensor<2,dim> strain(make_array_view(&in.composition[q][0],
-                                                         &in.composition[q][0] + Tensor<2,dim>::n_independent_components));
-
-              // Compute the strain accumulated in this timestep.
-              const Tensor<2,dim> strain_increment = this->get_timestep() * (velocity_gradients[q] * strain);
-
-              // Output the strain increment component-wise to its respective compositional field's reaction terms.
-              strain_increment.unroll(&out.reaction_terms[q][0],
-                                      &out.reaction_terms[q][0] + Tensor<2,dim>::n_independent_components);
-            }
-        }
-    }
-
-
-    template <int dim>
-    void
-    FiniteStrain<dim>::
-    parse_parameters (ParameterHandler &prm)
-    {
-      Simple<dim>::parse_parameters (prm);
-
-      AssertThrow(this->n_compositional_fields() >= (Tensor<2,dim>::n_independent_components),
-                  ExcMessage("There must be at least as many compositional fields as independent components in the full "
-                             "strain rate tensor."));
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(FiniteStrain,
-                                   "finite strain",
-                                   "A simple material model that is like the "
-                                   "'Simple' model, but tracks the finite strain as compositional "
-                                   "fields. The model assumes that the first 4 (in 2D) "
-                                   " or 9 (in 3D) compositional fields contain the finite "
-                                   "strain components. ")
-  }
-}
diff --git a/tests/simple_shear_output_the_mobility.prm.bak b/tests/simple_shear_output_the_mobility.prm.bak
deleted file mode 100644
index 5c31e38bc0a..00000000000
--- a/tests/simple_shear_output_the_mobility.prm.bak
+++ /dev/null
@@ -1,139 +0,0 @@
-# This parameter file is a copy of simple_shear.prm but with the added postprocessor
-# "mobility statistics" following Lourenco et al., 2020.
-# Mobility = surface rms velocity / whole domain rms velocity.
-# This result of ~1.73205 in this test is very close to the analytical
-# solution of sqrt(3).
-#
-# This parameter file reproduces an analytical benchmark for the evolution
-# of finite strain in a model of simple shear as described (for a specific
-# application) in McKenzie & Jackson (1983): "The relationship between
-# strain rates, crustal thickening, paleomagnetism, finite strain and
-# fault movements within a deforming zone." They show that the analytical
-# solution for the deformation gradient tensor F in simple shear deformation is:
-#
-# F_xx = 1.0
-# F_xy = u_x,y * t
-# F_yx = 0
-# F_yy = 1.0,
-#
-# where u is the velocity, t is time, and a comma represents a derivative
-# in that particular direction.
-# Because u_x,y = 2.0 / 1.0 is constant in the whole domain (and over time) we expect
-# a constant F at any given time, and in particular:
-# F_xy (t=1.0) = 2.0
-#
-# This parameter file tracks the finite strain in two ways, once by using
-# compositional fields as illustrated in the finite strain cookbook, and
-# once by using a particle that sits and remains in the center of the domain.
-# The results should be the same.
-#
-# Numerical results for particle tracking and compositional fields
-# show equally excellent agreement.
-
-set Dimension                              = 2
-set End time                               = 0.025
-set Use years in output instead of seconds = false
-set Output directory = simple_shear_output_the_mobility
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set X periodic = true
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function, top:function
-
-  subsection Function
-    set Function expression = if (y < 0.5, -1, 1); 0
-  end
-end
-
-subsection Material model
-  set Model name = finite strain
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0;0.0;0.0;1.0
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = particles, composition statistics, visualization, mobility statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = strain rate, stress, principal stress
-    set Output format = gnuplot
-    set Time between graphical output = 0.05
-  end
-
-  subsection Particles
-    set Time between data output = 0.05
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain
-  set Particle generator name = ascii file
-
-  subsection Generator
-    subsection Ascii file
-      set Data directory = $ASPECT_SOURCE_DIR/benchmarks/finite_strain/
-      set Data file name = simple_shear_particle.dat
-    end
-  end
-end
diff --git a/tests/simpler_box.prm.bak b/tests/simpler_box.prm.bak
deleted file mode 100644
index b6f00e8dc5a..00000000000
--- a/tests/simpler_box.prm.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/simpler_composition.prm.bak b/tests/simpler_composition.prm.bak
deleted file mode 100644
index ae05f34ed4f..00000000000
--- a/tests/simpler_composition.prm.bak
+++ /dev/null
@@ -1,61 +0,0 @@
-# This test ensures that the Simpler material model works
-# with compositional fields enabled
-
-set Dimension                              = 2
-set End time                               = 0
-
-subsection Compositional fields
-  set Number of fields          = 1
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent                = 1024e3
-    set X repetitions           = 2
-    set Y extent                = 1024e3
-    set Y repetitions           = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 500
-  end
-end
-
-subsection Material model
-  set Model name         = simpler
-
-  subsection Simpler model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, top, bottom
-end
diff --git a/tests/single_Advection_iterated_defect_correction_Stokes.prm.bak b/tests/single_Advection_iterated_defect_correction_Stokes.prm.bak
deleted file mode 100644
index 3358f9ece04..00000000000
--- a/tests/single_Advection_iterated_defect_correction_Stokes.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-#########################################################
-# This is a model setup to test the iterated Advection and Stokes solver.
-# Both the calculation of the residuum and the convergence
-# with prescribed boundary conditions are tested.
-
-set Adiabatic surface temperature          = 0
-set CFL number                             = 0.5
-set Nonlinear solver scheme                = single Advection, iterated defect correction Stokes
-set Max nonlinear iterations               = 10
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  set Stokes velocity polynomial degree = 2
-
-  subsection Stabilization parameters
-    set beta  = 0.5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Box
-    set Top temperature = 0
-    set Bottom temperature = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 150000
-    set Y extent  = 65000
-    set X repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,x0=150000,a = 0.2, b = 75000, c = 10000, d=0.0
-    set Function expression = d + a * exp(-((x-b)*(x-b)+y*y)/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity = 0
-    set Thermal expansion coefficient = 1
-    set Thermal viscosity exponent = 0.0
-    set Reference specific heat = 1.0
-    set Reference density = 1.0
-    set Reference temperature = 0
-    set Viscosity = 1e16
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-2
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/sinking_block.cc.bak b/tests/sinking_block.cc.bak
deleted file mode 100644
index d5f03fd9261..00000000000
--- a/tests/sinking_block.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/sinking_block/sinking_block.cc"
diff --git a/tests/sinking_block.prm.bak b/tests/sinking_block.prm.bak
deleted file mode 100644
index 46e689f4ced..00000000000
--- a/tests/sinking_block.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-# This is a test for the sinking block benchmark.
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/sinking_block/sinking_block.prm
-
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-end
diff --git a/tests/skip_initial_conditions_setup_on_initial_refinement.prm.bak b/tests/skip_initial_conditions_setup_on_initial_refinement.prm.bak
deleted file mode 100644
index 97c8b432af3..00000000000
--- a/tests/skip_initial_conditions_setup_on_initial_refinement.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-##### simple test for skipping initial conditions setup
-##### on initial refinement.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1
-set Output directory                       = output-test
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 2
-  set Time steps between mesh refinement       = 0
-  set Skip solvers on initial refinement       = true
-  set Skip setup initial conditions on initial refinement = true
-  set Strategy                                 = minimum refinement function
-
-  subsection Minimum refinement function
-    set Variable names        = x, y
-    set Function expression   = if(x>330000, 3 ,1)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = heat flux statistics
-end
diff --git a/tests/skip_refinement.prm.bak b/tests/skip_refinement.prm.bak
deleted file mode 100644
index 193151e2736..00000000000
--- a/tests/skip_refinement.prm.bak
+++ /dev/null
@@ -1,165 +0,0 @@
-# A simulation with adaptive refinement only based on minimum
-# refinement function. As a consequence, refinement will not change
-# the mesh after the minimum refinement is reached. Confirm that
-# ASPECT detects this and skips the mesh refinement routines.
-
-#  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 100
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set CFL number                             = 0.5
-set Maximum time step                      = 50
-set Pressure normalization                 = no
-
-# Solver parameters
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 2000
-    set Linear solver tolerance = 1e-7
-    set GMRES solver restart length = 50
-  end
-end
-
-# Model geometry
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 2
-    set Y repetitions = 4
-    set X extent      = 1500e3
-    set Y extent      = 2891e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 3
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 1
-  set Strategy                           = minimum refinement function
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function expression = y>=2791.e3 ? 4 : 1
-  end
-end
-
-# Element types
-subsection Discretization
-  set Composition polynomial degree     = 2
-  set Stokes velocity polynomial degree = 2
-  set Temperature polynomial degree     = 1
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = top: free surface
-  set Additional tangential mesh velocity boundary indicators = left,right
-
-  subsection Free surface
-    set Surface velocity projection = normal
-  end
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-end
-
-# Prescribe a fixed vertical traction on the top boundary
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = top y: function
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants  = r0=100.e3, H0=1.e3, t1=90.e3, t2=100.e3, rhoi=931, g=9.815
-    set Function expression = 0; (x^2+y^2)<r0^2 ? t<t1 ? abs(cos(t/100.*pi))==1.0 ? -g*H0*rhoi*t/t1 : -g*H0*rhoi*(t+50.)/t1 : t<t2 ? abs(cos(t/100.*pi))==1.0 ? -g*H0*rhoi*(1-(t-t1)/(t2-t1)) : -g*H0*rhoi*(1-(t+50.-t1)/(t2-t1)) : 0 : 0;
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 7
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, LM, TZ, UM, Lith
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; if(y<=2221e3,1,0); if(y<=2471e3 && y>2221e3,1,0); if(y<=2821e3 && y>2471e3,1,0); if(y>2821e3,1,0);
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = true
-  set List of model names = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# Temperature initial conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-  set Material averaging = harmonic average only viscosity
-
-  subsection Viscoelastic
-    set Densities                   = 4978, 4978, 4978, 4978, 4978, 3871, 3438, 3037
-    set Viscosities                 = 2.e21, 2.e21, 2.e21, 2.e21, 2.e21, 1.e21, 1.e21, 1.e40
-    set Elastic shear moduli        = 2.28340e11, 2.28340e11, 2.28340e11, 2.28340e11, 2.28340e11, 1.05490e11, 0.70363e11, 0.50605e11
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 2.5
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.815
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = visualization, basic statistics, composition statistics, temperature statistics, topography, velocity statistics
-
-  subsection Visualization
-    set List of output variables = material properties, nonadiabatic pressure, strain rate
-    set Time between graphical output = 10000
-    set Interpolate output = false
-    set Number of grouped files = 1
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-end
diff --git a/tests/skip_solvers_on_initial_refinement.prm.bak b/tests/skip_solvers_on_initial_refinement.prm.bak
deleted file mode 100644
index d2251e6693b..00000000000
--- a/tests/skip_solvers_on_initial_refinement.prm.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-##### simple test for skipping solvers on initial refinement
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1
-set Output directory                       = output-test
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 660000
-    set Y extent = 660000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function,left:function,right:function,top:function
-
-  subsection Function
-    set Function expression = 1;0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 2
-  set Time steps between mesh refinement       = 0
-  set Skip solvers on initial refinement       = true
-  set Skip setup initial conditions on initial refinement = false
-  set Strategy                                 = minimum refinement function
-
-  subsection Minimum refinement function
-    set Variable names        = x, y
-    set Function expression   = if(x>330000, 3 ,1)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = heat flux statistics
-end
diff --git a/tests/slab2_initial_composition_3d_shell.prm.bak b/tests/slab2_initial_composition_3d_shell.prm.bak
deleted file mode 100644
index 2de5db0b27f..00000000000
--- a/tests/slab2_initial_composition_3d_shell.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-##### simple test for slab2 model as initial composition
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 30
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = bottom, top, west, east, south
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, west, east, south
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields  = slabs
-  set Compositional field methods = static
-end
-
-subsection Initial composition model
-  set Model name = slab model
-
-  # The following lines point to the location of the slab2 model
-  # data file, generated using the jupyter notebook in the
-  # /data/initial-composition/slab-model/ folder.
-  subsection Slab model
-    set Data directory       = $ASPECT_SOURCE_DIR/data/initial-composition/slab-model/
-    set Data file name       = shell_3d.txt
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, composition statistics, visualization
-end
diff --git a/tests/slab_tip_depth.prm.bak b/tests/slab_tip_depth.prm.bak
deleted file mode 100644
index 0e1532e6b75..00000000000
--- a/tests/slab_tip_depth.prm.bak
+++ /dev/null
@@ -1,157 +0,0 @@
-# This test considers the first timestep of a
-# 2d subduction setup with prescribed in- and outflow.
-# The postprocessor maximum depth of field
-# returns the depth of the deepest point of each field.
-# With increasing resolution, it should return the following
-# maximum depths of the composition fields:
-# 82, 110 and 82 km, resp.
-# The postprocessors viscous dissipation statistics and
-# viscous dissipation per compositional field return
-# the viscous dissipation over the whole domain and
-# per area of each field, resp. With enough resolution,
-# the dissipation over the whole domain should be
-# approx. 8.5 kW/m and that over the subducting plate approx. 4 kW/m.
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set CFL number                             = 0.5
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Adiabatic surface temperature          = 0
-
-# We fix composition on the right boundary,
-# because we have inflow there.
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = right
-  set List of model names = initial composition
-end
-
-# We fix temperature on the top and bottom,
-# as well as on the right boundary because
-# we have inflow through the latter.
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 0
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-# prescribe horizontal in- and outflow through the right boundary
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom, top
-  set Prescribed velocity boundary indicators = right x:function
-
-  subsection Function
-    set Function constants  = cm=100.0
-    set Function expression = if(z<540000.0, (600.0/550.0)/cm, \
-                                 if(z>560000.0, -5.0/cm, \
-                                    ((((-600.0/550.0)-5.0)/-20.0)*((z/1000.0)-560.0)+5.0)*(-1.0/cm))); \
-                              0
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Reference temperature         = 0.0
-    set Viscosity averaging scheme    = maximum composition
-
-    # background, OP, ML SP, crust SP
-    set Viscosities                   = 1.e20, 1.e23, 1.e23, 1.e20
-    set Densities                     = 3200.0, 3250.0, 3250.0, 3250.0
-    set Thermal conductivities        = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = OP, ML_SP, crust_SP
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  = Ax=1475600.0, Az=670000.0, \
-                              Bx=1500000.0, Bz=670000.0, \
-                              Cx=1358500.0, Cz=588000.0, \
-                              Dx=1382900.0, Dz=588000.0, \
-                              Ex=1530000.0, Ez=560000.0, \
-                              Fz=663000.0, Gz=662000.0, \
-                              Hz=631000.0, Iz=630000.0
-    set Function expression = \
-                              if(z>=Cz&z>=((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz),1,0); \
-                              if((x>=Ex&z>=Ez&z<Gz)|(x<Ex&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<Gz&z>=((Ez-Dz)/(Ex-Dx)*(x-Dx)+Dz)),1,0); \
-                              if(z>=Cz&z>((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz)&z<((Az-Cz)/(Ax-Cx)*(x-Cx)+Cz)|z>=Gz&z<=((Bz-Dz)/(Bx-Dx)*(x-Dx)+Dz),1,0)
-    set Variable names      = x,z
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent   = 3000e3
-    set Y extent   = 670e3
-    set X repetitions = 4
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# We ignore any temperature effects
-subsection Initial temperature model
-  set List of model names = function
-
-  subsection Function
-    set Function constants  =
-    set Function expression = 0
-    set Variable names      = x,y,t
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 2
-  set Initial global refinement                = 4
-  set Minimum refinement level                 = 4
-  set Coarsening fraction                      = 0.01
-  set Refinement fraction                      = 0.95
-  set Skip solvers on initial refinement       = true
-  set Strategy                                 = minimum refinement function
-  set Time steps between mesh refinement       = 16
-
-  subsection Minimum refinement function
-    set Coordinate system = depth
-    set Variable names = x,z,t
-    set Function constants = vel_trans=150e3
-    set Function expression = if(x<vel_trans,6,4)
-  end
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, maximum depth of field, viscous dissipation statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-6
-    set Number of cheap Stokes solver steps = 200
-  end
-end
diff --git a/tests/slope_refinement.prm.bak b/tests/slope_refinement.prm.bak
deleted file mode 100644
index f39e9d10960..00000000000
--- a/tests/slope_refinement.prm.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-#Test for slope-based refinement
-
-set Dimension = 2
-set CFL number                             = 0.1
-set End time                               = 1e9
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature,slope
-  set Time steps between mesh refinement = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/smoothing.prm.bak b/tests/smoothing.prm.bak
deleted file mode 100644
index 6930c3b3e10..00000000000
--- a/tests/smoothing.prm.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-# Smoothing
-# Here we prescribe a circular Stokes flow and test if EV with smoothing works while it rotates
-
-# set CFL number = 0.1
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = .5
-set Output directory                       = output
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 2
-
-  subsection Stabilization parameters
-    set Use artificial viscosity smoothing = true
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-    set Box origin X coordinate = -1
-    set Box origin Y coordinate = -1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression =  if((sqrt((x-0)^2+(y-0.5)^2)<0.3)&(abs(x)>=0.05|y>=0.7),1,if(sqrt((x-0)^2+(y+0.5)^2)<0.3,1-sqrt((x-0)^2+(y+0.5)^2)/0.3,if(sqrt((x+0.5)^2+(y+0)^2)<0.3,1.0/4.0*(1+cos(pi*min(sqrt((x+0.5)^2+(y+0)^2)/0.3,1))),0)))
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top, bottom, left, right
-
-  subsection Box
-    set Bottom temperature = 0
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0  # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-5
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = .1
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/smoothing_composition_passive.prm.bak b/tests/smoothing_composition_passive.prm.bak
deleted file mode 100644
index 60b1dee1a4c..00000000000
--- a/tests/smoothing_composition_passive.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-#########################################################
-# SMOOTHING - COMPOSITIONAL PASSIVE
-# This is a test based off of that composition-passive.prm file.
-# All settings are exactly the same with the exception
-# that we are using entropy viscosity with smoothing,
-# and that things were made slightly simpler to make
-# the test run faster.
-#
-# See the manual for more information about this setup.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-set Output directory                       = output
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set Use artificial viscosity smoothing = true
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/tests/sol_cx_2.cc.bak b/tests/sol_cx_2.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_2.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2.prm.bak b/tests/sol_cx_2.prm.bak
deleted file mode 100644
index 1446019093c..00000000000
--- a/tests/sol_cx_2.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-set Additional shared libraries            = ./libsolcx.so
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_2_conservative.cc.bak b/tests/sol_cx_2_conservative.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_2_conservative.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_conservative.prm.bak b/tests/sol_cx_2_conservative.prm.bak
deleted file mode 100644
index 63673305a3c..00000000000
--- a/tests/sol_cx_2_conservative.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = true
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_2_equal_order.cc.bak b/tests/sol_cx_2_equal_order.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_2_equal_order.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_equal_order.prm.bak b/tests/sol_cx_2_equal_order.prm.bak
deleted file mode 100644
index 37e77dc4c0a..00000000000
--- a/tests/sol_cx_2_equal_order.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# Check the SolCx benchmark, but using the Q1 x Q1 element
-
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 1
-  set Temperature polynomial degree           = 1
-  set Use equal order interpolation for Stokes = true
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_2_gmg.cc.bak b/tests/sol_cx_2_gmg.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_2_gmg.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_gmg.prm.bak b/tests/sol_cx_2_gmg.prm.bak
deleted file mode 100644
index 730301c673b..00000000000
--- a/tests/sol_cx_2_gmg.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# The Solcx benchmark solved with the block
-# GMG preconditioner and harmonic averaging
-# for 2 global refinements
-
-
-set Additional shared libraries            = ./libsolcx.so
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-  set Material averaging = harmonic average only viscosity
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_2_normalized_pressure.cc.bak b/tests/sol_cx_2_normalized_pressure.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_2_normalized_pressure.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_normalized_pressure.prm.bak b/tests/sol_cx_2_normalized_pressure.prm.bak
deleted file mode 100644
index eb2e6792fde..00000000000
--- a/tests/sol_cx_2_normalized_pressure.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = volume
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_2_q3.cc.bak b/tests/sol_cx_2_q3.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_2_q3.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_2_q3.prm.bak b/tests/sol_cx_2_q3.prm.bak
deleted file mode 100644
index 3e821efd853..00000000000
--- a/tests/sol_cx_2_q3.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 3
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_4.cc.bak b/tests/sol_cx_4.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_4.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4.prm.bak b/tests/sol_cx_4.prm.bak
deleted file mode 100644
index 3142b8d808f..00000000000
--- a/tests/sol_cx_4.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_4_conservative.cc.bak b/tests/sol_cx_4_conservative.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_4_conservative.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_conservative.prm.bak b/tests/sol_cx_4_conservative.prm.bak
deleted file mode 100644
index a2be5091bd6..00000000000
--- a/tests/sol_cx_4_conservative.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = true
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_4_equal_order.cc.bak b/tests/sol_cx_4_equal_order.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_4_equal_order.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_equal_order.prm.bak b/tests/sol_cx_4_equal_order.prm.bak
deleted file mode 100644
index 664f5e00814..00000000000
--- a/tests/sol_cx_4_equal_order.prm.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-# Check the SolCx benchmark, but using the Q1 x Q1 element
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 1
-  set Temperature polynomial degree           = 1
-  set Use equal order interpolation for Stokes = true
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor, visualization
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_4_gmg.cc.bak b/tests/sol_cx_4_gmg.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_4_gmg.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_gmg.prm.bak b/tests/sol_cx_4_gmg.prm.bak
deleted file mode 100644
index 96800a5d76c..00000000000
--- a/tests/sol_cx_4_gmg.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# The Solcx benchmark solved with the block
-# GMG preconditioner and harmonic averaging
-# for 4 global refinements
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-  set Material averaging = harmonic average only viscosity
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_4_normalized_pressure.cc.bak b/tests/sol_cx_4_normalized_pressure.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_4_normalized_pressure.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_normalized_pressure.prm.bak b/tests/sol_cx_4_normalized_pressure.prm.bak
deleted file mode 100644
index c07efe8c9ed..00000000000
--- a/tests/sol_cx_4_normalized_pressure.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization = volume
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_4_normalized_pressure_large_static_pressure.cc.bak b/tests/sol_cx_4_normalized_pressure_large_static_pressure.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_4_normalized_pressure_large_static_pressure.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_normalized_pressure_large_static_pressure.prm.bak b/tests/sol_cx_4_normalized_pressure_large_static_pressure.prm.bak
deleted file mode 100644
index ff66ace7930..00000000000
--- a/tests/sol_cx_4_normalized_pressure_large_static_pressure.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = volume
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# a case where we have a large static pressure, 1e6 times larger than the
-# dynamic pressure, by making the material very heavy. verify that we still
-# get the correct solution.
-#
-# note that to get the same number of iterations as for the
-# sol_cx_4_normalized_pressure testcase, we have to set the linear solver
-# tolerance to something smaller, because the right hand side vector is
-# much larger when using a large background density. then, however, using
-# the exact same number of iterations, we get the exact same error, as
-# claimed in the appendix of the first ASPECT paper
-
-
-subsection Material model
-  set Model name = SolCxMaterial
-
-  subsection SolCx
-    set Background density = 1e6
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 0.6e-9
-  end
-end
diff --git a/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.cc.bak b/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.prm.bak b/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.prm.bak
deleted file mode 100644
index bb4e0638565..00000000000
--- a/tests/sol_cx_4_normalized_pressure_low_solver_tolerance.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# a case where we set the linear solver tolerance to a more loose value
-# than the default to see that it affects the overall accuracy. it turns
-# out that we can reduce the tolerance from 1e-7 to 1e-3 without changing
-# the accuracy in the solution very much. with 1e-2 the iteration error
-# now becomes so that it affects the overall error (which is iteration
-# plus discretization)
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = volume
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 1
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-2
-  end
-end
diff --git a/tests/sol_cx_mpi_2.cc.bak b/tests/sol_cx_mpi_2.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_mpi_2.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_mpi_2.prm.bak b/tests/sol_cx_mpi_2.prm.bak
deleted file mode 100644
index 132bf623ad6..00000000000
--- a/tests/sol_cx_mpi_2.prm.bak
+++ /dev/null
@@ -1,78 +0,0 @@
-# Like sol_cx_2.prm, but with 2 processors
-
-# MPI: 2
-
-set Additional shared libraries            = ./libsolcx.so
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_newton_crash.cc.bak b/tests/sol_cx_newton_crash.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/sol_cx_newton_crash.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/sol_cx_newton_crash.prm.bak b/tests/sol_cx_newton_crash.prm.bak
deleted file mode 100644
index 631b5d98956..00000000000
--- a/tests/sol_cx_newton_crash.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# A linear problem (copied from sol_cx_4) that crashes when "iterated Newton Stokes" is
-# used an the linear tolerance is reduced.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, iterated Newton Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance                         = 1e-9
-  end
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-  set Material averaging = harmonic average only viscosity
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_cx_particles.cc.bak b/tests/sol_cx_particles.cc.bak
deleted file mode 100644
index 5d18c190496..00000000000
--- a/tests/sol_cx_particles.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/compositional_fields/solcx_compositional_fields.cc"
diff --git a/tests/sol_cx_particles.prm.bak b/tests/sol_cx_particles.prm.bak
deleted file mode 100644
index 60758de0b1c..00000000000
--- a/tests/sol_cx_particles.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/solcx/compositional_fields/solcx_particles.prm
-
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 1
-end
diff --git a/tests/sol_kz_2.cc.bak b/tests/sol_kz_2.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/sol_kz_2.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2.prm.bak b/tests/sol_kz_2.prm.bak
deleted file mode 100644
index 95f4a9122cd..00000000000
--- a/tests/sol_kz_2.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolKzPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_kz_2_cheaper_first_phase_solver.cc.bak b/tests/sol_kz_2_cheaper_first_phase_solver.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/sol_kz_2_cheaper_first_phase_solver.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_cheaper_first_phase_solver.prm.bak b/tests/sol_kz_2_cheaper_first_phase_solver.prm.bak
deleted file mode 100644
index 23dc0d1701d..00000000000
--- a/tests/sol_kz_2_cheaper_first_phase_solver.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolKzPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 20
-  end
-end
diff --git a/tests/sol_kz_2_conservative.cc.bak b/tests/sol_kz_2_conservative.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/sol_kz_2_conservative.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_conservative.prm.bak b/tests/sol_kz_2_conservative.prm.bak
deleted file mode 100644
index 823da8106b2..00000000000
--- a/tests/sol_kz_2_conservative.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolKzPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_kz_2_no_first_phase_solver.cc.bak b/tests/sol_kz_2_no_first_phase_solver.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/sol_kz_2_no_first_phase_solver.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_no_first_phase_solver.prm.bak b/tests/sol_kz_2_no_first_phase_solver.prm.bak
deleted file mode 100644
index 1e31796636d..00000000000
--- a/tests/sol_kz_2_no_first_phase_solver.prm.bak
+++ /dev/null
@@ -1,79 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolKzPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/sol_kz_2_project_q1_only_visc.cc.bak b/tests/sol_kz_2_project_q1_only_visc.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/sol_kz_2_project_q1_only_visc.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_project_q1_only_visc.prm.bak b/tests/sol_kz_2_project_q1_only_visc.prm.bak
deleted file mode 100644
index 06803a88518..00000000000
--- a/tests/sol_kz_2_project_q1_only_visc.prm.bak
+++ /dev/null
@@ -1,14 +0,0 @@
-# Solkz benchmark using project to Q1 only viscosity material modeling averaging
-
-include $ASPECT_SOURCE_DIR/benchmarks/solkz/solkz.prm
-
-
-subsection Material model
-  set Model name = SolKzMaterial
-  set Material averaging = project to Q1 only viscosity
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
diff --git a/tests/sol_kz_2_q3.cc.bak b/tests/sol_kz_2_q3.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/sol_kz_2_q3.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_2_q3.prm.bak b/tests/sol_kz_2_q3.prm.bak
deleted file mode 100644
index 785fef07fbe..00000000000
--- a/tests/sol_kz_2_q3.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 3
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolKzPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_kz_4.cc.bak b/tests/sol_kz_4.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/sol_kz_4.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_4.prm.bak b/tests/sol_kz_4.prm.bak
deleted file mode 100644
index b092a55d92b..00000000000
--- a/tests/sol_kz_4.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolKzPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/sol_kz_4_conservative.cc.bak b/tests/sol_kz_4_conservative.cc.bak
deleted file mode 100644
index d6275281d3e..00000000000
--- a/tests/sol_kz_4_conservative.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solkz/solkz.cc"
diff --git a/tests/sol_kz_4_conservative.prm.bak b/tests/sol_kz_4_conservative.prm.bak
deleted file mode 100644
index 9a63dc35f49..00000000000
--- a/tests/sol_kz_4_conservative.prm.bak
+++ /dev/null
@@ -1,73 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolKzMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolKzPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/solidus_initial_conditions.cc.bak b/tests/solidus_initial_conditions.cc.bak
deleted file mode 100644
index e45783c44fa..00000000000
--- a/tests/solidus_initial_conditions.cc.bak
+++ /dev/null
@@ -1,447 +0,0 @@
-/*
-  Copyright (C) 2011 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/initial_temperature/interface.h>
-#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-#include <aspect/geometry_model/spherical_shell.h>
-#include <aspect/boundary_temperature/interface.h>
-
-#include <cmath>
-
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    /**
-     * Data class to handle the melting curve.
-     */
-    class MeltingCurve
-    {
-      public:
-
-        /**
-         * Read the data file into the class.
-         */
-        void read(const std::string &filename,
-                  const MPI_Comm comm);
-
-        /**
-         * Get the melting temperature.
-         */
-        double T(const double p, const double radius) const;
-
-        /**
-         * Is the melting curve dependent on radius. The melting curve can be
-         * dependent on radius or pressure.
-         */
-        bool is_radius;
-
-        /**
-         * Number of data points in the melting curve data.
-         */
-        unsigned int n_points;
-      private:
-        /**
-         * Data array for temperature.
-         */
-        std::vector<double> T_array;
-
-        /**
-         * Data array for pressure/radius.
-         */
-        std::vector<double> P_or_R_array;
-
-        /**
-         * Name of the data file.
-         */
-        std::string data_filename;
-    };
-
-
-    /**
-     * A class that implements temperature initial conditions based on solidus
-     * provided by a data file.
-     *
-     * @ingroup InitialTemperatures
-     */
-    template <int dim>
-    class Solidus : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * Constructor.
-         */
-        Solidus ();
-
-        /**
-         * Return the initial temperature as a function of position.
-         */
-        double initial_temperature (const Point<dim> &position) const override;
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        void
-        parse_parameters (ParameterHandler &prm) override;
-
-      private:
-        /**
-         * Returns spherical coordinates of a cartesian position.
-         */
-        const Tensor<1,dim>
-        spherical_surface_coordinates(const Tensor<1,dim> &position) const;
-
-        /**
-         * Lithosphere thickness.
-         */
-        double       litho_thick;
-
-        /**
-         * Magnitude of temperature perturbation.
-         */
-        double       magnitude_T;
-
-        /**
-         * Magnitude of lithosphere thickness perturbation.
-         */
-        double       magnitude_lith;
-
-        /**
-         * Temperature difference from solidus, so the initial condition can
-         * be super-solidus or sub-solidus.
-         */
-        double       deltaT;
-
-        /**
-         * The lateral wave number  of the harmonic perturbation in the first
-         * dimension. This is the only lateral wave number in 2D and equals
-         * the degree of the spherical harmonics in a 3D spherical shell.
-         */
-        int          lateral_wave_number_1;
-
-        /**
-         * The lateral wave number of the harmonic perturbation in the second
-         * dimension. This is not used in 2D and equals the order of the
-         * spherical harmonics in a 3D spherical shell.
-         */
-        int          lateral_wave_number_2;
-
-        /**
-         * The data file name for solidus data.
-         */
-        std::string  solidus_filename;
-
-        /**
-         * Data class for melting curve
-         */
-        MeltingCurve solidus_curve;
-    };
-
-    void MeltingCurve::read(const std::string &filename,
-                            const MPI_Comm comm)
-    {
-      data_filename=filename;
-      // Read data from disk and distribute among processes
-      std::istringstream in(Utilities::read_and_distribute_file_content(filename, comm));
-
-      std::string dummy;
-
-      std::string T_Unit,P_Unit;
-      n_points=0;
-      getline (in, dummy);
-      in>>T_Unit>>P_Unit;
-      getline (in, dummy);
-      while (!in.eof())
-        {
-          double T,p;
-          in>>T>>p;
-          if (!in.fail())
-            {
-              // Unit switching
-              if (T_Unit=="C")
-                {
-                  T+=273.15;                      // Degree C to K
-                }
-              else if (T_Unit!="K")
-                {
-                  AssertThrow(false,ExcMessage ("Unit of the first column of melting curve data "
-                                                "has to be one of the following: C/K."));
-                }
-
-              is_radius=false;                    // Second column is pressure
-              if (P_Unit=="kbar")
-                p*=1.e8;                        // kbar to Pa
-              else if (P_Unit=="GPa")
-                p*=1.e9;                        // GPa to Pa
-              else
-                {
-                  is_radius=true;                 // Second column is radius instead of pressure
-                  if (P_Unit=="km")
-                    p*=1.e3;                    // km to meters
-                  else if (P_Unit!="m")
-                    AssertThrow(false,ExcMessage ("Unit of the second column of melting curve data "
-                                                  "has to be one of the following: Pa/GPa/km/m."));
-                }
-              T_array.push_back(T);
-              P_or_R_array.push_back(p);
-              n_points++;
-            }
-          getline (in, dummy);
-        }
-    }
-
-
-
-    double MeltingCurve::T(const double p, const double radius) const
-    {
-      double T_value,P_or_R_value=is_radius?radius:p;
-      if (T_array.size()==0)return (0);
-      for (unsigned i=1; i<n_points; i++)
-        {
-          if (     (i==n_points-1) ||
-                   (is_radius && P_or_R_value>P_or_R_array[i]) ||
-                   (!is_radius && P_or_R_value<P_or_R_array[i]) )
-            {
-              T_value=T_array[i-1]+(T_array[i]-T_array[i-1])/(P_or_R_array[i]-P_or_R_array[i-1])*(P_or_R_value-P_or_R_array[i-1]);
-              return (T_value);
-            }
-        }
-      AssertThrow(false,ExcMessage(std::string("Something wrong with the melting curve data ")+ data_filename ));
-      return (-1);
-    }
-
-
-
-    template <int dim>
-    Solidus<dim>::Solidus ():
-      solidus_curve()
-    {}
-
-    template <int dim>
-    double
-    Solidus<dim>::
-    initial_temperature (const Point<dim> &position) const
-    {
-      double T_min,T_litho;
-      double T_solidus,T_perturbation;
-      double litho_thick_theta;
-      double lateral_perturbation;
-      double Depth=this->get_geometry_model().depth(position);
-
-      AssertThrow(solidus_curve.n_points!=0,ExcMessage("Error reading solidus file."));
-      AssertThrow(solidus_curve.is_radius==true,ExcMessage("The solidus curve has to be radius dependent."));
-      const GeometryModel::SphericalShell<dim> *spherical_geometry_model=
-        dynamic_cast<const GeometryModel::SphericalShell<dim> *>(&this->get_geometry_model());
-
-      AssertThrow(spherical_geometry_model!=0,
-                  ExcMessage("This initial condition can only be used with spherical shell geometry model."));
-
-      AssertThrow(this->has_boundary_temperature(),
-                  ExcMessage("This initial condition can only be used with a prescribed boundary temperature."));
-
-      T_min=(this->get_boundary_temperature_manager()).minimal_temperature();
-
-      // In case of spherical shell calculate spherical coordinates
-      const Tensor<1,dim> scoord = spherical_surface_coordinates(position);
-      if (dim==2)
-        {
-          // Use a sine as lateral perturbation that is scaled to the opening angle of the geometry.
-          // This way the perturbation is always 0 at the model boundaries.
-          const double opening_angle = spherical_geometry_model->opening_angle() * constants::degree_to_radians;
-          lateral_perturbation = std::sin(lateral_wave_number_1*scoord[1]*numbers::PI/opening_angle);
-        }
-      else if (dim==3)
-        {
-          // Spherical harmonics are only defined for order <= degree
-          // and degree >= 0. Verify that it is indeed.
-          Assert ( std::abs(lateral_wave_number_2) <= lateral_wave_number_1,
-                   ExcMessage ("Spherical harmonics can only be computed for "
-                               "order <= degree."));
-          Assert ( lateral_wave_number_1 >= 0,
-                   ExcMessage ("Spherical harmonics can only be computed for "
-                               "degree >= 0."));
-          // use a spherical harmonic function as lateral perturbation
-          std::pair<double,double> sph_harm_vals = Utilities::real_spherical_harmonic( lateral_wave_number_1, lateral_wave_number_2, scoord[2], scoord[1] );
-          lateral_perturbation = sph_harm_vals.first;
-        }
-      litho_thick_theta=litho_thick-magnitude_lith*lateral_perturbation;
-      T_litho=solidus_curve.T(0,spherical_geometry_model->outer_radius()-litho_thick_theta)+deltaT;
-
-      if (litho_thick_theta>0 && Depth<litho_thick_theta)
-        T_solidus=T_min+(T_litho-T_min)*(Depth/litho_thick_theta);
-      else
-        T_solidus=solidus_curve.T(0,sqrt(position.square()))+deltaT;
-
-      T_perturbation=Depth/( this->get_geometry_model().maximal_depth() )*magnitude_T*lateral_perturbation;
-      return T_solidus+T_perturbation;
-    }
-
-
-
-    template <int dim>
-    const Tensor<1,dim>
-    Solidus<dim>::
-    spherical_surface_coordinates(const Tensor<1,dim> &position) const
-    {
-      Tensor<1,dim> scoord;
-
-      scoord[0] = std::sqrt(position.norm_square());                // R
-      scoord[1] = std::atan2(position[1],position[0]);              // Phi
-      if (scoord[1] < 0.0) scoord[1] = 2*numbers::PI + scoord[1];   // correct phi to [0,2*pi]
-      if (dim==3)
-        scoord[2] = std::acos(position[2]/std::sqrt(position.norm_square())); // Theta
-
-      return scoord;
-    }
-
-
-
-    template <int dim>
-    void
-    Solidus<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Solidus");
-        {
-          prm.declare_entry ("Supersolidus","0e0",
-                             Patterns::Double (),
-                             "The difference from solidus, use this number to generate initial conditions "
-                             "that close to solidus instead of exactly at solidus. Use small negative number"
-                             " in this parameter to prevent large melting generation at the beginning. "
-                             "  Units: \\si{\\kelvin} ");
-          prm.declare_entry ("Lithosphere thickness","0",
-                             Patterns::Double (0),
-                             "The thickness of lithosphere thickness. Units: \\si{\\meter}");
-          prm.enter_subsection("Perturbation");
-          {
-            prm.declare_entry ("Temperature amplitude", "0e0",
-                               Patterns::Double (0),
-                               "The amplitude of the initial spherical temperature perturbation in (K)");
-            prm.declare_entry ("Lithosphere thickness amplitude", "0e0",
-                               Patterns::Double (),
-                               "The amplitude of the initial lithosphere thickness perturbation in (m)");
-            prm.declare_entry ("Lateral wave number one","3",
-                               Patterns::Integer(),
-                               "Doubled first lateral wave number of the harmonic perturbation. "
-                               "Equals the spherical harmonic degree in 3D spherical shells. "
-                               "In all other cases one equals half of a sine period over "
-                               "the model domain. This allows for single up-/downswings. "
-                               "Negative numbers reverse the sign of the perturbation but are "
-                               "not allowed for the spherical harmonic case.");
-            prm.declare_entry ("Lateral wave number two", "2",
-                               Patterns::Integer (),
-                               "Doubled second lateral wave number of the harmonic perturbation. "
-                               "Equals the spherical harmonic order in 3D spherical shells. "
-                               "In all other cases one equals half of a sine period over "
-                               "the model domain. This allows for single up-/downswings. "
-                               "Negative numbers reverse the sign of the perturbation.");
-          }
-          prm.leave_subsection();
-          prm.enter_subsection ("Data");
-          {
-            prm.declare_entry ("Solidus filename", "",
-                               Patterns::Anything(),
-                               "The solidus data filename. It is a function of radius or pressure "
-                               "in the following format: \n"
-                               "Line 1:  Header \n"
-                               "Line 2:  Unit of temperature (C/K)        "
-                               "Unit of pressure (GPa/kbar) or radius (km/m) \n"
-                               "Line 3~: Column of solidus temperature    Column of radius/pressure \n"
-                               "See data/initial-temperature/solidus.Mars as an example."
-                               "\n\n"
-                               "In order to facilitate placing input files in locations relative "
-                               "to the ASPECT source directory, the file name may also include the special "
-                               "text '$ASPECT_SOURCE_DIR' which will be interpreted as the path "
-                               "in which the ASPECT source files were located when ASPECT was "
-                               "compiled. This interpretation allows, for example, to reference "
-                               "files located in the `data/' subdirectory of ASPECT.");
-          }
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    Solidus<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection ("Initial temperature model");
-      {
-        prm.enter_subsection("Solidus");
-        {
-          deltaT=prm.get_double("Supersolidus");
-          litho_thick=prm.get_double("Lithosphere thickness");
-          prm.enter_subsection("Perturbation");
-          {
-            magnitude_T    = prm.get_double("Temperature amplitude");
-            magnitude_lith = prm.get_double("Lithosphere thickness amplitude");
-            lateral_wave_number_1 = prm.get_integer ("Lateral wave number one");
-            lateral_wave_number_2 = prm.get_integer ("Lateral wave number two");
-          }
-          prm.leave_subsection();
-          prm.enter_subsection("Data");
-          solidus_filename = Utilities::expand_ASPECT_SOURCE_DIR(prm.get ("Solidus filename"));
-          solidus_curve.read(solidus_filename,this->get_mpi_communicator());
-          prm.leave_subsection();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-  }
-
-
-}
-
-
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace InitialTemperature
-  {
-    ASPECT_REGISTER_INITIAL_TEMPERATURE_MODEL(Solidus,
-                                              "solidus",
-                                              "This is a temperature initial condition that "
-                                              "starts the model close to solidus, it also contains "
-                                              "a user defined lithosphere thickness and with perturbations "
-                                              " in both lithosphere thickness and temperature based on "
-                                              "spherical harmonic functions. It was used as the initial condition "
-                                              "of early Mars after the freezing of the magma ocean, "
-                                              "using the solidus from Parmentier et al., "
-                                              "Melt-solid segregation, Fractional magma ocean solidification, and implications for "
-                                              "long term planetary evolution. Luna and Planetary Science, 2007.")
-  }
-}
diff --git a/tests/solidus_initial_conditions.prm.bak b/tests/solidus_initial_conditions.prm.bak
deleted file mode 100644
index 1198dbadfd6..00000000000
--- a/tests/solidus_initial_conditions.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# A simple setup for initial condition close to solidus of Mars in a 2d shell with perturbations. See the
-# manual for more information.
-
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1.5e-9
-set Adiabatic surface temperature          = 1200
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 1700000
-    set Outer radius  = 3385000
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0
-  set Tangential velocity boundary indicators = 1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2200
-    set Outer temperature = 250
-  end
-end
-
-subsection Initial temperature model
-  set Model name              = solidus
-
-  subsection Solidus
-    set Supersolidus          = -50
-    set Lithosphere thickness = 500e3
-
-    subsection Perturbation
-      set Temperature amplitude           = 100
-      set Lithosphere thickness amplitude = 250e3
-      set Lateral wave number one         = 12
-      set Lateral wave number two         = 6
-    end
-
-    subsection Data
-      set Solidus filename = $ASPECT_SOURCE_DIR/data/initial-temperature/solidus.Mars
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 1e6
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
diff --git a/tests/solitary_wave.cc.bak b/tests/solitary_wave.cc.bak
deleted file mode 100644
index 069053c7cd3..00000000000
--- a/tests/solitary_wave.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solitary_wave/solitary_wave.cc"
diff --git a/tests/solitary_wave.prm.bak b/tests/solitary_wave.prm.bak
deleted file mode 100644
index 5e0fb993e6a..00000000000
--- a/tests/solitary_wave.prm.bak
+++ /dev/null
@@ -1,159 +0,0 @@
-# Listing of Parameters
-# ---------------------
-# Set up the solitary wave benchmark
-# (Barcilon & Richter, 1986; Simpson & Spiegelman, 2011;
-# Keller et al., 2013; Schmeling, 2000)
-
-set Adiabatic surface temperature          = 1623
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-set Nonlinear solver tolerance             = 1e-5
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 1 times its wavelength during the model time.
-set End time                               = 2e3
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta  = 0.001
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Initial temperature
-    # Temperature at the inner boundary (core mantle boundary). Units: \\si{\\kelvin}.
-    set Maximal temperature = 3773
-
-    # Temperature at the outer boundary (lithosphere water/air). Units: \\si{\\kelvin}.
-    set Minimal temperature = 273
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2,3
-end
-
-# we apply the phase speed of the wave here, so that it always stays in the same place in our model
-# the phase speed is c = 5.25e-11 m/s, but we have to convert it to m/years using the same conversion
-# that is used internally in ASPECT: year_in_seconds = 60*60*24*365.2425
-
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function, 3:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    #    set Function expression = 0;-8.2836999e-5
-    set Function expression = 0;-1.65673998e-4
-
-    #    set Function expression = 0;-3.31347996e-4
-    #    set Function expression = 0;-6.62695992e-4
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 10
-    set Y extent  = 400
-    set Y repetitions = 40
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Initial composition model
-  set Model name = Solitary wave initial condition
-
-  subsection Solitary wave initial condition
-    set Offset = 200
-    set Read solution from file = false
-    set Amplitude = 0.01
-    set Background porosity = 0.001
-  end
-end
-
-subsection Material model
-  set Model name = Solitary Wave
-
-  subsection Solitary wave
-    set Reference permeability = 5e-9
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.0
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 2
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics,solitary wave statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = vtu
-    set Time between graphical output = 5e5
-
-    subsection Melt material properties
-      set List of properties = fluid density, permeability, fluid viscosity, compaction viscosity
-    end
-  end
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-14
-  set Temperature solver tolerance = 1e-14
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-10
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/solubility.cc.bak b/tests/solubility.cc.bak
deleted file mode 100644
index c6871a82a73..00000000000
--- a/tests/solubility.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solubility/plugin/solubility.cc"
diff --git a/tests/solubility.prm.bak b/tests/solubility.prm.bak
deleted file mode 100644
index 8faad431cd7..00000000000
--- a/tests/solubility.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-# 1D solubility test
-
-include $ASPECT_SOURCE_DIR/benchmarks/solubility/solubility.prm
-
-set End time = 15000
-
-subsection Geometry model
-  subsection Box
-    set Y repetitions = 100
-  end
-end
diff --git a/tests/solve_no_advection_no_stokes.prm.bak b/tests/solve_no_advection_no_stokes.prm.bak
deleted file mode 100644
index a927cd68012..00000000000
--- a/tests/solve_no_advection_no_stokes.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-set Dimension                              = 3
-set Use years in output instead of seconds = false
-set Start time                             = 0
-set End time                               = 0
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Output directory                       = output-solve_no_advection_no_stokes
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = outer,west,south,east
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = inner,outer
-  set List of model names = initial temperature
-end
-
-subsection Initial temperature model
-  set List of model names = ascii profile, harmonic perturbation
-  set List of model operators = add
-
-  subsection Ascii profile
-    set Data directory = $ASPECT_SOURCE_DIR/data/initial-temperature/ascii-profile/tests/
-    set Data file name = simple_test.txt
-  end
-
-  subsection Harmonic perturbation
-    set Magnitude = 2.0
-    set Reference temperature = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 0
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 15
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/solver_history.cc.bak b/tests/solver_history.cc.bak
deleted file mode 100644
index 3d2ff3b3010..00000000000
--- a/tests/solver_history.cc.bak
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator_signals.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-
-namespace aspect
-{
-  template <int dim>
-  void post_stokes_solver (const SimulatorAccess<dim> &,
-                           const unsigned int /*number_S_iterations*/,
-                           const unsigned int /*number_A_iterations*/,
-                           const SolverControl &/*solver_control_cheap*/,
-                           const SolverControl &/*solver_control_expensive*/)
-  {
-    std::cout << "\npost_stokes_solver:\n";
-  }
-
-
-  template <int dim>
-  void signal_connector (SimulatorSignals<dim> &signals)
-  {
-    std::cout << "Connecting signals" << std::endl;
-    signals.post_stokes_solver.connect (&post_stokes_solver<dim>);
-  }
-
-
-  ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                    signal_connector<3>)
-}
diff --git a/tests/solver_history.prm.bak b/tests/solver_history.prm.bak
deleted file mode 100644
index b137a2a3cc7..00000000000
--- a/tests/solver_history.prm.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0.1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, Stokes residual
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 30
-  end
-end
diff --git a/tests/solver_scheme_no_advection_single_stokes.cc.bak b/tests/solver_scheme_no_advection_single_stokes.cc.bak
deleted file mode 100644
index 033218a35c0..00000000000
--- a/tests/solver_scheme_no_advection_single_stokes.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/solcx/solcx.cc"
diff --git a/tests/solver_scheme_no_advection_single_stokes.prm.bak b/tests/solver_scheme_no_advection_single_stokes.prm.bak
deleted file mode 100644
index 39c34cb24d2..00000000000
--- a/tests/solver_scheme_no_advection_single_stokes.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# solcx test, based on no_cheap_gmg.prm to show "no Advection, single Stokes"
-# scheme works
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-  set Material averaging = harmonic average
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = SolCxPostprocessor
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/spectral_comparison.prm.bak b/tests/spectral_comparison.prm.bak
deleted file mode 100644
index ef947a04fcb..00000000000
--- a/tests/spectral_comparison.prm.bak
+++ /dev/null
@@ -1,16 +0,0 @@
-# A test for the geoid, gravity and dynamic topography postprocessor
-
-set Dimension                              = 3
-
-include $ASPECT_SOURCE_DIR/benchmarks/geoid-spectral-comparison/spectral-comparison.prm
-
-
-subsection Mesh refinement
-  set Initial global refinement = 0
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps             = 200
-  end
-end
diff --git a/tests/spherical_constant_boundary_3d_sphere.prm.bak b/tests/spherical_constant_boundary_3d_sphere.prm.bak
deleted file mode 100644
index 3b332afb107..00000000000
--- a/tests/spherical_constant_boundary_3d_sphere.prm.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-# This test ensures that the spherical constant
-# boundary composition sets the composition
-# at the surface of a sphere
-
-set Dimension                              = 2
-set End time                               = 0
-
-subsection Compositional fields
-  set Number of fields          = 1
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = spherical constant
-  set Fixed composition boundary indicators   = 0
-
-  subsection Spherical constant
-    set Outer composition = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = sphere
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 500
-  end
-end
-
-subsection Material model
-  set Model name         = simpler
-
-  subsection Simpler model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = depth
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/spherical_nsinker.cc.bak b/tests/spherical_nsinker.cc.bak
deleted file mode 100644
index 19f0a384ea2..00000000000
--- a/tests/spherical_nsinker.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/nsinker_spherical_shell/nsinker.cc"
diff --git a/tests/spherical_nsinker.prm.bak b/tests/spherical_nsinker.prm.bak
deleted file mode 100644
index 22621d3e4f5..00000000000
--- a/tests/spherical_nsinker.prm.bak
+++ /dev/null
@@ -1,16 +0,0 @@
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/benchmarks/nsinker_spherical_shell/gmg.prm
-
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-end
-
-subsection Postprocess
-  subsection Memory statistics
-    # disable as it is not deterministic:
-    set Output peak virtual memory (VmPeak) = false
-  end
-end
diff --git a/tests/spherical_shell_initial_topography_ascii_data_3d.prm.bak b/tests/spherical_shell_initial_topography_ascii_data_3d.prm.bak
deleted file mode 100644
index 898ba1a57ee..00000000000
--- a/tests/spherical_shell_initial_topography_ascii_data_3d.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# An input script to test the chunk geometry model
-# with additional initial topography.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = -20
-    set Chunk maximum longitude = 20
-    set Longitude repetitions = 1
-    set Chunk minimum latitude = -20
-    set Chunk maximum latitude = 20
-    set Latitude repetitions = 1
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-      set Data file name       = shell_3d_outer.0.txt
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer, east, west, north, south
-  set Zero velocity boundary indicators       = inner
-end
-
-# The ascii data file prescribes a topography between -2000 m and
-# +9000 m. The topography postprocessor output should match with this.
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables = surface elevation
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/spherical_shell_initial_topography_function_3d.prm.bak b/tests/spherical_shell_initial_topography_function_3d.prm.bak
deleted file mode 100644
index 8f6e7ff86f8..00000000000
--- a/tests/spherical_shell_initial_topography_function_3d.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# An input script to test the spherical geometry model with additional
-# initial topography described as a function. We don't actually solve
-# for anything, but produce output that should show the topography.
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-
-  # Have a 2 km high mountain belt around the equator that decreases
-  # linearly over a (z-)distance of 2000km
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function constants = z0=2000000, H=2000
-      set Function expression = if(abs(z)<z0, H*(z0-abs(z))/z0, 0)
-      set Maximum topography value = 2000
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables = surface elevation
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/spherical_velocity_statistics.prm.bak b/tests/spherical_velocity_statistics.prm.bak
deleted file mode 100644
index 85e7b318afe..00000000000
--- a/tests/spherical_velocity_statistics.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# like refine_vel.prm, but run the "spherical velocity statistics"
-# postprocessor
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e300
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-  set End step                  = 1
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Additional refinement times              = 0,0
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, spherical velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/spiegelman_fail_test.cc.bak b/tests/spiegelman_fail_test.cc.bak
deleted file mode 100644
index 60ed8005162..00000000000
--- a/tests/spiegelman_fail_test.cc.bak
+++ /dev/null
@@ -1,678 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/simulator_access.h>
-#include <aspect/newton.h>
-#include <aspect/parameters.h>
-
-#include <iostream>
-
-#include <aspect/utilities.h>
-
-#include <aspect/material_model/interface.h>
-
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    using namespace dealii;
-
-    /**
-     * The same material model as Drucker Prager, but this one supports multiple
-     * compositions in a way to reproduce the Spiegelman 2016 paper.
-     *
-     * The model is considered incompressible, following the definition
-     * described in Interface::is_compressible.
-     *
-     * The viscosity is computed according to the Drucker Prager frictional
-     * plasticity criterion based on a user-defined internal angle of friction $\phi$
-     * and cohesion $C$. In 3D:
-     * $\sigma_y = \frac{6 C \cos(\phi)}{\sqrt(3) (3+\sin(\phi))} +
-     * \frac{6 P \sin(\phi)}{\sqrt(3) (3+\sin(\phi))}$,
-     * where $P$ is the pressure.
-     * See for example Zienkiewicz, O. C., Humpheson, C. and Lewis, R. W. (1975),
-     * G&eacute;otechnique 25, No. 4, 671-689.
-     * With this formulation we circumscribe instead of inscribe the Mohr Coulomb
-     * yield surface.
-     * In 2D the Drucker Prager yield surface is the same
-     * as the Mohr Coulomb surface:
-     * $\sigma_y = P \sin(\phi) + C \cos(\phi)$.
-     * Note that in 2D for $\phi=0$, these criteria
-     * revert to the von Mises criterion (no pressure dependence).
-     * See for example Thieulot, C. (2011), PEPI 188, 47-68.
-     *
-     * Note that we enforce the pressure to be positive in the computation of
-     * the yield strength by replacing it with
-     * a zero value whenever it is negative to prevent negative
-     * yield strengths and viscosities.
-     * We then use the computed yield strength to scale back the viscosity on
-     * to the yield surface using the Viscosity Rescaling Method described in
-     * Kachanov, L. M. (2004), Fundamentals of the Theory of Plasticity,
-     * Dover Publications, Inc.
-     *
-     * To avoid numerically unfavourably large (or even negative) viscosity ranges,
-     * we regularize the viscosity by $\eta_{\text{eff}} = \eta_{\text{ref}} * \eta
-     * / (\eta_{\text{ref}} + \eta)$. Furthermore,
-     * we cut off the viscosity with a user-defined minimum and maximum viscosity:
-     * $\eta_eff = \frac{1}{\frac{1}{\eta_min + \eta}+
-     * \frac{1}{\eta_max}}$.
-     *
-     * Note that this model uses the formulation that assumes an incompressible
-     * medium despite the fact that the density follows the law
-     * $\rho(T)=\rho_0(1-\beta(T-T_{\text{ref}}))$.
-     *
-     *
-     * @ingroup MaterialModels
-     */
-
-    template <int dim>
-    class SpiegelmanMaterial : public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        double compute_second_invariant(const SymmetricTensor<2,dim> strain_rate, const double min_strain_rate) const;
-
-        double compute_viscosity(const double edot_ii,const double pressure,const int comp, const double constant_viscosity,const bool compute_full_viscosity, const double min_visc, const double max_visc) const;
-
-        virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                              MaterialModel::MaterialModelOutputs<dim> &out) const;
-
-        /**
-         * Return whether the model is compressible or not.  Incompressibility
-         * does not necessarily imply that the density is constant; rather, it
-         * may still depend on temperature or pressure. In the current
-         * context, compressibility means whether we should solve the continuity
-         * equation as $\nabla \cdot (\rho \mathbf u)=0$ (compressible Stokes)
-         * or as $\nabla \cdot \mathbf{u}=0$ (incompressible Stokes).
-         *
-         * This material model is incompressible.
-         */
-        virtual bool is_compressible () const;
-
-        virtual double reference_density () const;
-
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-
-      private:
-
-        double reference_T;
-
-
-        /**
-         * Whether or not to use the deviator of the strain-rate in the
-         * viscosity calculation.
-         */
-        bool use_deviator_of_strain_rate;
-
-        /**
-         * Defining a minimum strain rate stabilizes the viscosity calculation,
-         * which involves a division by the strain rate. Units: $\\si{\\per\\second}$.
-         */
-        std::vector<double> min_strain_rate;
-        std::vector<double> min_visc;
-        std::vector<double> max_visc;
-        std::vector<double> veff_coefficient;
-        double ref_visc;
-        double reference_compressibility;
-        std::vector<double> ref_visc_list;
-
-        std::vector<double> thermal_diffusivity;
-        std::vector<double> heat_capacity;
-
-
-        std::vector<double> densities;
-        std::vector<double> thermal_expansivities;
-
-        std::vector<double> cohesion;
-        std::vector<double> phi;
-
-        /**
-         * The friction angles phi for each of the compositional fields. Since we use their
-         * sines and cosines a lot, we only compute these values (for each of the phis) once
-         * and cache them.
-         */
-        std::vector<double> sin_phi;
-        std::vector<double> cos_phi;
-
-        std::vector<double> constant_viscosity;
-
-        unsigned int n_fields;
-
-        /**
-         * This parameter is used in the averaging of the  of the different compositions.
-         * It is implemented as a generalized mean, where p < -1000 is the minimum, p ==-1
-         * is the harmonic average, p == 0 is the geometric average, p == 1 is the arithmetic
-         * average and p > 1000 is the maximum.
-         */
-        double viscosity_averaging_p;
-
-        /**
-         * This value determines whether to use the analytical or the
-         * finite difference derivative for the Newton solver. Although
-         * the analytical derivative should be much faster to compute, the
-         * finite difference derivative can be useful when changing the
-         * rheology.
-         */
-        bool use_analytical_derivative;
-    };
-
-  }
-
-
-  namespace
-  {
-    std::vector<double>
-    get_vector_double (const std::string &parameter, const unsigned int n_fields, ParameterHandler &prm)
-    {
-      std::vector<double> parameter_list;
-      parameter_list = Utilities::string_to_double(Utilities::split_string_list(prm.get (parameter)));
-      if (parameter_list.size() == 1)
-        parameter_list.resize(n_fields, parameter_list[0]);
-
-      AssertThrow(parameter_list.size() == n_fields,
-                  ExcMessage("Length of " + parameter + " list (size "+ std::to_string(parameter_list.size()) +") must be either one,"
-                             " or n_compositional_fields+1 (= " + std::to_string(n_fields) + ")."));
-
-      return parameter_list;
-    }
-  }
-
-  namespace MaterialModel
-  {
-    template <int dim>
-    double
-    SpiegelmanMaterial<dim>::
-    compute_second_invariant(const SymmetricTensor<2,dim> strain_rate, const double min_strain_rate) const
-    {
-      const double edot_ii_strict = std::sqrt(strain_rate*strain_rate);
-      const double edot_ii = std::max(edot_ii_strict, min_strain_rate);
-      return edot_ii;
-    }
-
-    template <int dim>
-    double
-    SpiegelmanMaterial<dim>::
-    compute_viscosity(const double edot_ii,
-                      const double pressure,
-                      const int comp,
-                      const double constant_viscosity,
-                      const bool compute_full_viscosity,
-                      const double min_visc,
-                      const double max_visc) const
-    {
-      double viscosity;
-
-      if (constant_viscosity == 0)
-        {
-          const double strength = ( (dim==3)
-                                    ?
-                                    ( 6.0 * cohesion[comp] * cos_phi[comp] + 6.0 * std::max(pressure,0.0) * sin_phi[comp] )
-                                    / ( std::sqrt(3) * ( 3.0 + sin_phi[comp] ) )
-                                    :
-                                    cohesion[comp] * cos_phi[comp] + std::max(pressure,0.0) * sin_phi[comp] );
-
-          // Rescale the viscosity back onto the yield surface
-          if (strength != 0 && edot_ii != 0)
-            viscosity = strength / ( 2.0 * std::sqrt(0.5) * edot_ii );
-          else
-            viscosity = ref_visc;
-
-          if (compute_full_viscosity == true)
-            viscosity = ref_visc * viscosity / (ref_visc + viscosity);
-        }
-      else
-        {
-          viscosity = constant_viscosity;
-        }
-
-      if (compute_full_viscosity == true)
-        return std::max(std::min(viscosity, max_visc), min_visc);
-      else
-        return viscosity;
-    }
-
-    template <int dim>
-    void
-    SpiegelmanMaterial<dim>::
-    evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-             MaterialModel::MaterialModelOutputs<dim> &out) const
-    {
-      //set up additional output for the derivatives
-      MaterialModelDerivatives<dim> *derivatives;
-      derivatives = out.template get_additional_output<MaterialModelDerivatives<dim>>();
-
-      for (unsigned int i=0; i < in.n_evaluation_points(); ++i)
-        {
-          const double temperature = in.temperature[i];
-          const double pressure = in.pressure[i];
-
-          // Averaging composition-field dependent properties
-          // Compositions
-          //This assert may be help when designing tests for this material model
-          AssertThrow(in.composition[i].size()+1 == n_fields,
-                      ExcMessage("Number of compositional fields + 1 not equal to number of fields given in input file."));
-
-          const std::vector<double> volume_fractions = MaterialUtilities::compute_composition_fractions(in.composition[i]);
-          double density = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            {
-              const double temperature_factor = (1 - thermal_expansivities[c] * (temperature - reference_T));
-              density += volume_fractions[c] * densities[c] * std::exp(reference_compressibility * pressure) * temperature_factor;
-            }
-
-          // thermal expansivities
-          double thermal_expansivity = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            thermal_expansivity += volume_fractions[c] * thermal_expansivities[c];
-
-          // Specific heat at the given positions.
-          double specific_heat = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            specific_heat += volume_fractions[c] * heat_capacity[c];
-
-          // Thermal conductivity at the given positions.
-          double thermal_conductivities = 0.0;
-          for (unsigned int c=0; c < volume_fractions.size(); ++c)
-            thermal_conductivities += volume_fractions[c] * thermal_diffusivity[c] * heat_capacity[c] * densities[c];
-
-          // calculate effective viscosity
-          if (in.requests_property(MaterialProperties::viscosity))
-            {
-              // This function calculates viscosities assuming that all the compositional fields
-              // experience the same strain rate (isostrain). Since there is only one process in
-              // this material model (a general powerlaw) we do not need to worry about how to
-              // distribute the strain-rate and stress over the processes.
-              std::vector<double> composition_viscosities(volume_fractions.size());
-              std::vector<SymmetricTensor<2,dim>> composition_viscosities_derivatives(volume_fractions.size());
-              std::vector<double> composition_dviscosities_dpressure(volume_fractions.size());
-
-              const SymmetricTensor<2,dim> edot = use_deviator_of_strain_rate ? deviator(in.strain_rate[i]) : in.strain_rate[i];
-
-              for (unsigned int c=0; c < volume_fractions.size(); ++c)
-                {
-                  // If strain rate is zero (like during the first time step) set it to some very small number
-                  // to prevent a division-by-zero, and a floating point exception.
-                  // Otherwise, calculate the square-root of the norm of the second invariant of the deviatoric-
-                  // strain rate (often simplified as epsilondot_ii)
-
-                  const double edot_ii = compute_second_invariant(edot, min_strain_rate[c]);
-
-                  // Find effective viscosities for each of the individual phases
-                  // Viscosities should have same number of entries as compositional fields
-
-                  // Regularized Drucker Prager viscosity (see Spiegelman et al, 2016)
-                  composition_viscosities[c] = compute_viscosity(edot_ii,pressure,c,constant_viscosity[c],true,min_visc[c],max_visc[c]);
-
-                  Assert(dealii::numbers::is_finite(composition_viscosities[c]),ExcMessage ("Error: Viscosity is not finite."));
-
-                  if (derivatives != nullptr)
-                    {
-                      if (use_analytical_derivative)
-                        {
-                          //analytic
-                          if (constant_viscosity[c] == 0  && composition_viscosities[c] <= max_visc[c] && composition_viscosities[c] >= min_visc[c])
-                            {
-                              // we only want the pure durcker prager here, so the regularization should be off and the min and max values should not be used.
-                              // Therefore we set the compute_full_viscosity flag to false. The min and max viscosity values  won't be used with this flag,
-                              // so we enter dummy values.
-                              const double drucker_prager_viscosity = compute_viscosity(edot_ii,pressure,c,constant_viscosity[c],false,std::numeric_limits<double>::min(),std::numeric_limits<double>::max());
-                              const double regularization_adjustment = (ref_visc * ref_visc)
-                                                                       / (ref_visc * ref_visc + 2.0 * ref_visc * drucker_prager_viscosity
-                                                                          + drucker_prager_viscosity * drucker_prager_viscosity);
-
-                              composition_viscosities_derivatives[c] = -regularization_adjustment *
-                                                                       (drucker_prager_viscosity / (edot_ii * edot_ii)) * edot;
-
-                              if (use_deviator_of_strain_rate == true)
-                                composition_viscosities_derivatives[c] = composition_viscosities_derivatives[c] * deviator_tensor<dim>();
-
-                              composition_dviscosities_dpressure[c] = regularization_adjustment *
-                                                                      ((dim == 3)
-                                                                       ?
-                                                                       6 * sin_phi[c] / (std::sqrt(3) * (3.0 + sin_phi[c]) * 2.0 * std::sqrt(0.5) * edot_ii)
-                                                                       :
-                                                                       sin_phi[c] / (2.0 * std::sqrt(0.5) * edot_ii));
-                            }
-                          else
-                            {
-                              composition_viscosities_derivatives[c] = 0;
-                              composition_dviscosities_dpressure[c] = 0;
-                            }
-                        }
-                      else
-                        {
-                          // finite difference
-                          const double finite_difference_accuracy = 1e-7;
-                          // For each independent component, compute the derivative.
-                          for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
-                            {
-                              // compute which of the independent index of the strain-rate tensor we are now looking at.
-                              const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
-
-                              // add a small difference to one independent component of the strain-rate tensor
-                              const SymmetricTensor<2,dim> strain_rate_difference_plus = edot + std::max(edot_ii, min_strain_rate[c]) * finite_difference_accuracy
-                                                                                         * Utilities::nth_basis_for_symmetric_tensors<dim>(component);
-                              const double second_invariant_strain_rate_difference_plus = compute_second_invariant(strain_rate_difference_plus, min_strain_rate[c]);
-                              const double eta_component_plus = compute_viscosity(second_invariant_strain_rate_difference_plus,pressure,c,constant_viscosity[c],true,min_visc[c],max_visc[c]);
-
-                              // compute the difference between the viscosity with and without the strain-rate difference.
-                              double viscosity_derivative = eta_component_plus - composition_viscosities[c];
-                              if (viscosity_derivative != 0)
-                                {
-                                  // when the difference is non-zero, divide by the difference.
-                                  viscosity_derivative /= std::max(edot_ii, min_strain_rate[c]) * finite_difference_accuracy;
-                                }
-
-                              composition_viscosities_derivatives[c][strain_rate_indices] = viscosity_derivative;
-                            }
-
-                          /**
-                           * Now compute the finite difference derivative of the viscoisty to the pressure
-                           */
-                          double pressure_difference = in.pressure[i] + (std::fabs(in.pressure[i]) * finite_difference_accuracy);
-
-                          double pressure_difference_eta = compute_viscosity(edot_ii, pressure_difference,c,constant_viscosity[c],true,min_visc[c],max_visc[c]);
-                          double deriv_pressure = pressure_difference_eta - composition_viscosities[c];
-
-
-                          if (pressure_difference_eta != 0)
-                            {
-                              if (in.pressure[i] != 0)
-                                {
-                                  deriv_pressure /= std::fabs(in.pressure[i]) * finite_difference_accuracy;
-                                }
-                              else
-                                {
-                                  deriv_pressure = 0;
-                                }
-                            }
-
-                          composition_dviscosities_dpressure[c] = deriv_pressure;
-                        }
-                    }
-                }
-              out.viscosities[i] = Utilities::weighted_p_norm_average(volume_fractions, composition_viscosities, viscosity_averaging_p);
-              Assert(dealii::numbers::is_finite(out.viscosities[i]),ExcMessage ("Error: Averaged viscosity is not finite."));
-
-              if (derivatives != nullptr)
-                {
-                  derivatives->viscosity_derivative_wrt_strain_rate[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_viscosities_derivatives, viscosity_averaging_p);
-                  derivatives->viscosity_derivative_wrt_pressure[i] = Utilities::derivative_of_weighted_p_norm_average(out.viscosities[i],volume_fractions, composition_viscosities, composition_dviscosities_dpressure, viscosity_averaging_p);
-
-                  Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_pressure[i]),
-                         ExcMessage ("Error: Averaged dviscosities_dpressure is not finite."));
-
-                  for (int x = 0; x < dim; ++x)
-                    for (int y = 0; y < dim; ++y)
-                      Assert(dealii::numbers::is_finite(derivatives->viscosity_derivative_wrt_strain_rate[i][x][y]),
-                             ExcMessage ("Error: Averaged dviscosities_dstrain_rate is not finite."));
-                }
-            }
-          out.densities[i] = density;
-          out.thermal_expansion_coefficients[i] = thermal_expansivity;
-          // Specific heat at the given positions.
-          out.specific_heat[i] = specific_heat;
-          // Thermal conductivity at the given positions.
-          out.thermal_conductivities[i] = thermal_conductivities;
-          // Compressibility at the given positions.
-          // The compressibility is given as
-          // $\frac 1\rho \frac{\partial\rho}{\partial p}$.
-          out.compressibilities[i] = reference_compressibility;
-          // Pressure derivative of entropy at the given positions.
-          out.entropy_derivative_pressure[i] = 0.0;
-          // Temperature derivative of entropy at the given positions.
-          out.entropy_derivative_temperature[i] = 0.0;
-          // Change in composition due to chemical reactions at the
-          // given positions. The term reaction_terms[i][c] is the
-          // change in compositional field c at point i.
-          for (unsigned int c=0; c < in.composition[i].size(); ++c)
-            out.reaction_terms[i][c] = 0.0;
-        }
-    }
-
-    template <int dim>
-    double
-    SpiegelmanMaterial<dim>::
-    reference_density () const
-    {
-      return densities[0];
-    }
-
-    template <int dim>
-    bool
-    SpiegelmanMaterial<dim>::
-    is_compressible () const
-    {
-      return (reference_compressibility != 0);
-    }
-
-    template <int dim>
-    void
-    SpiegelmanMaterial<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Compositional fields");
-      {
-        prm.declare_entry ("Number of fields", "0",
-                           Patterns::Integer (0),
-                           "The number of fields that will be advected along with the flow field, excluding "
-                           "velocity, pressure and temperature.");
-
-        // temperature and density parameters
-        prm.declare_entry ("List of conductivities", "2.25",
-                           Patterns::List (Patterns::Double(0)),
-                           "A list of thermal conductivities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("List of capacities", "1250",
-                           Patterns::List (Patterns::Double(0)),
-                           "A list of heat capacities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("Thermal expansivities", "3.5e-5",
-                           Patterns::List(Patterns::Double(0)),
-                           "List of thermal expansivities for background mantle and compositional fields, "
-                           "for a total of N+1 values, where N is the number of compositional fields. "
-                           "If only one value is given, then all use the same value.  Units: \\si{\\per\\kelvin}");
-        prm.declare_entry ("List of reference densities", "2700",
-                           Patterns::List (Patterns::Double(0)),
-                           "A list of reference densities equal to the number of "
-                           "compositional fields.");
-
-        // visocosity parameters
-        prm.declare_entry ("List of cohesions", "1e20",
-                           Patterns::List (Patterns::Double(0)),
-                           "A list of initial viscosities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("List of angles of internal friction", "30",
-                           Patterns::List (Patterns::Double(0)),
-                           "A list of initial viscosities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("List of initial viscosities", "1e21",
-                           Patterns::List (Patterns::Double(0)),
-                           "A list of initial viscosities equal to the number of "
-                           "compositional fields.");
-        prm.declare_entry ("List of constant viscosities", "0",
-                           Patterns::List (Patterns::Double(0)),
-                           "A list of viscous viscosities equal to the number of "
-                           "compositional fields. When it is zero, the Drucker Prager "
-                           "rheology is used, when it is nonzero, it sets the viscosity "
-                           "with the set value.");
-
-      }
-      prm.leave_subsection();
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Spiegelman 2016");
-        {
-          // Reference and minimum/maximum values
-          prm.declare_entry ("Reference temperature", "293", Patterns::Double(0),
-                             "For calculating density by thermal expansivity. Units: \\si{\\kelvin}");
-          prm.declare_entry ("Minimum strain rate", "1.96e-40", Patterns::List(Patterns::Double(0)),
-                             "Stabilizes strain dependent viscosity. Units: \\si{\\per\\second}");
-          prm.declare_entry ("Minimum viscosity", "1e10", Patterns::List(Patterns::Double(0)),
-                             "Lower cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Maximum viscosity", "1e28", Patterns::List(Patterns::Double(0)),
-                             "Upper cutoff for effective viscosity. Units: \\si{\\pascal\\second}");
-          prm.declare_entry ("Effective viscosity coefficient", "1.0", Patterns::List(Patterns::Double(0)),
-                             "Scaling coefficient for effective viscosity.");
-          prm.declare_entry ("Reference viscosity", "1e22", Patterns::List(Patterns::Double(0)),
-                             "Reference viscosity for nondimensionalization. Units $Pa s$");
-          prm.declare_entry ("Reference compressibility", "4e-12", Patterns::Double (0),
-                             "The value of the reference compressibility. Units: \\si{\\per\\pascal}.");
-
-          // averaging parameters
-          prm.declare_entry ("Viscosity averaging p", "-1",
-                             Patterns::Double(),
-                             "This is the p value in the generalized weighed average eqation: "
-                             " mean = \\frac{1}{k}(\\sum_{i=1}^k \\big(c_i \\eta_{\\text{eff}_i}^p)\\big)^{\\frac{1}{p}}. "
-                             " Units: \\si{\\pascal\\second}");
-
-          // finite difference versus analytical
-          prm.declare_entry ("Use analytical derivative", "true",
-                             Patterns::Bool(),
-                             "This value determines whether to use the analytical or the finite difference derivative "
-                             "for the Newton solver. Although the analytical derivative should be much faster to compute, "
-                             "the finite difference derivative can be useful when changing the rheology.");
-
-          prm.declare_entry ("Use deviator of strain-rate", "true",
-                             Patterns::Bool(),
-                             "Whether or not to use the deviator of the strain-rate in the viscosity calculation.");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-
-
-    template <int dim>
-    void
-    SpiegelmanMaterial<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      using namespace Utilities;
-      // can't use this->n_compositional_fields(), because some
-      // tests never initiate the simulator, but uses the material
-      // model directly.
-      prm.enter_subsection ("Compositional fields");
-      {
-        n_fields = prm.get_integer ("Number of fields")+1;
-
-        // temperature and density parameters
-        thermal_diffusivity = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of conductivities"))),
-                                                          n_fields,
-                                                          "List of conductivities");
-        heat_capacity = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of capacities"))),
-                                                    n_fields,
-                                                    "List of capacities");
-        densities = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of reference densities"))),
-                                                n_fields,
-                                                "List of refdens");
-        thermal_expansivities = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("Thermal expansivities"))),
-                                                            n_fields,
-                                                            "Thermal expansivities");
-
-        // Rheological parameters
-        cohesion = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of cohesions"))),
-                                               n_fields,
-                                               "List of cohesions");
-        phi = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of angles of internal friction"))),
-                                          n_fields,
-                                          "List of angles of internal friction");
-
-
-        // Todo: make use of the initial viscosity
-        ref_visc_list = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of initial viscosities"))),
-                                                    n_fields,
-                                                    "List of initial viscosities");
-
-        sin_phi.resize(n_fields);
-        cos_phi.resize(n_fields);
-        for (unsigned int c = 0; c < n_fields; ++c)
-          {
-            sin_phi[c] = std::sin(phi[c] * constants::degree_to_radians);
-            cos_phi[c] = std::cos(phi[c] * constants::degree_to_radians);
-          }
-
-        constant_viscosity = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("List of constant viscosities"))),
-                                                         n_fields,
-                                                         "List of constant viscosities");
-      }
-      prm.leave_subsection();
-
-      prm.enter_subsection("Material model");
-      {
-        prm.enter_subsection ("Spiegelman 2016");
-        {
-
-          // Reference and minimum/maximum values
-          reference_T = prm.get_double("Reference temperature");
-          ref_visc = prm.get_double ("Reference viscosity");
-          min_strain_rate = possibly_extend_from_1_to_N(string_to_double(split_string_list(prm.get("Minimum strain rate"))),
-                                                        n_fields,
-                                                        "Minimum strain rate");
-          min_visc = get_vector_double ("Minimum viscosity",n_fields,prm);
-          max_visc = get_vector_double ("Maximum viscosity",n_fields,prm);
-          veff_coefficient = get_vector_double ("Effective viscosity coefficient",n_fields,prm);
-          reference_compressibility  = prm.get_double ("Reference compressibility");
-          use_deviator_of_strain_rate = prm.get_bool ("Use deviator of strain-rate");
-
-
-          // averaging parameters
-          viscosity_averaging_p = prm.get_double("Viscosity averaging p");
-
-          use_analytical_derivative = prm.get_bool("Use analytical derivative");
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-
-
-      // Declare dependencies on solution variables
-      this->model_dependence.viscosity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::strain_rate | NonlinearDependence::compositional_fields;
-      this->model_dependence.density = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-      this->model_dependence.compressibility = NonlinearDependence::none;
-      this->model_dependence.specific_heat = NonlinearDependence::none;
-      this->model_dependence.thermal_conductivity = NonlinearDependence::temperature | NonlinearDependence::pressure | NonlinearDependence::compositional_fields;
-    }
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace MaterialModel
-  {
-    ASPECT_REGISTER_MATERIAL_MODEL(SpiegelmanMaterial,
-                                   "spiegelman 2016",
-                                   "An implementation of the spiegelman 2016 benchmark paper in gcubed "
-                                   "(doi:10.1002/ 2015GC006228). It implements a regularized Drucker Prager "
-                                   "material (when the parameter constant viscosity is 0) and a linear material "
-                                   "(when the parameter constant viscosity is not 0), which are both needed to "
-                                   "implement the Spiegelman benchmark. The derivatives for the Newton solver "
-                                   "have been implemented for this material model.")
-  }
-}
diff --git a/tests/spiegelman_fail_test.prm.bak b/tests/spiegelman_fail_test.prm.bak
deleted file mode 100644
index d3ec4a45b69..00000000000
--- a/tests/spiegelman_fail_test.prm.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-# This is the most difficult case of the Spiegelman benchmark. The
-# goal of this test is to show that the linear Newton solver fails
-# when the matrix becomes non Symmetric Positive Definite, and
-# is safed by forcing the matrix to be SPD. In the next timestep
-# the stabilization is reset to the user defined values.
-
-set Additional shared libraries = ../tests/libspiegelman_fail_test.so
-set Output directory = output/
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = iterated Advection and Newton Stokes
-set Max nonlinear iterations = 4
-set Nonlinear solver tolerance = 1e-14
-set Pressure normalization = no
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-    set Linear solver tolerance = 9e-1
-    set Stokes solver type = block AMG
-  end
-
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 2
-    set SPD safety factor = 9e-1
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 0
-    set Maximum linear Stokes solver tolerance = 9e-1
-    set Use Newton residual scaling method = false
-    set Use Newton failsafe = true
-    set Stabilization preconditioner = none
-    set Stabilization velocity block = none
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,z
-    set Function constants = H = 30e3
-    set Function expression = if(z < 0.25 * H,1, \
-if(z < (0.25+(1/12)-0.02)*H & x > (2-(1/12))*H & x < (2+(1/12))*H,1, \
-if(z < (0.25+(1/12))*H & (x > (2-(1/12)+0.02)*H & x < (2+(1/12)-0.02)*H | (x-(2-(1/12)+0.02)*H)^2 + (z-(0.25+(1/12)-0.02)*H)^2 < (0.02*H)^2 | (x-(2+(1/12)-0.02)*H)^2 + (z-(0.25+(1/12)-0.02)*H)^2 < (0.02*H)^2),1, \
-if(z < (0.25+0.02)*H && x > (2-(1/12)-0.02)*H && x < (2+(1/12)+0.02)*H && ((x-(2-(1/12)-0.02)*H)^2 + (z-(0.25+0.02)*H)^2 > (0.02*H)^2 && (x-(2+(1/12)+0.02)*H)^2 + (z-(0.25+0.02)*H)^2 > (0.02*H)^2),1,0))))
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 120e3
-    set Y extent = 30e3
-    set X repetitions = 4
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set List of conductivities                         = 2.25,   2.25
-  set List of capacities                             = 1250,   1250
-  set List of reference densities                    = 2700.0, 2700.0
-  set List of cohesions                              = 1e8,    0
-  set List of angles of internal friction            = 30,     0
-  set List of initial viscosities                    = 1e20,   1e21
-  set List of constant viscosities                   = 0,      1e21
-end
-
-subsection Material model
-  set Model name = spiegelman 2016
-  set Material averaging = none
-
-  subsection Spiegelman 2016
-    set Maximum viscosity = 1e24
-    set Minimum viscosity = 1e21
-    set Use deviator of strain-rate = false
-    set Viscosity averaging p = -1
-    set Use analytical derivative     = false
-    set Reference viscosity = 5e24
-    set Reference compressibility = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Strategy =  strain rate
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 2
-  set Prescribed velocity boundary indicators = 0 x:function,1 x:function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = if(x<60e3,3.96109558e-10,-3.96109558e-10);0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, pressure statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties,strain rate, spd factor
-    set Interpolate output = false
-  end
-end
diff --git a/tests/spiegelman_material.cc.bak b/tests/spiegelman_material.cc.bak
deleted file mode 100644
index 5650b030bd8..00000000000
--- a/tests/spiegelman_material.cc.bak
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../tests/spiegelman_fail_test.cc"
-
-int f(double parameter)
-{
-
-  std::cout << std::endl << "Test for p = " << parameter << std::endl;
-
-  const int dim=2;
-  using namespace aspect::MaterialModel;
-  MaterialModelInputs<dim> in_base(5,3);
-  in_base.composition[0][0] = 0;
-  in_base.composition[0][1] = 0;
-  in_base.composition[0][2] = 0;
-  in_base.composition[1][0] = 0.75;
-  in_base.composition[1][1] = 0.15;
-  in_base.composition[1][2] = 0.10;
-  in_base.composition[2][0] = 0;
-  in_base.composition[2][1] = 0.2;
-  in_base.composition[2][2] = 0.4;
-  in_base.composition[3][0] = 0;
-  in_base.composition[3][1] = 0.2;
-  in_base.composition[3][2] = 0.4;
-  in_base.composition[4][0] = 1;
-  in_base.composition[4][1] = 0;
-  in_base.composition[4][2] = 0;
-
-  in_base.pressure[0] = 1e9;
-  in_base.pressure[1] = 5e9;
-  in_base.pressure[2] = 2e10;
-  in_base.pressure[3] = 2e11;
-  in_base.pressure[4] = 2e12;
-
-  /**
-   * We can't take to small strain-rates, because then the difference in the
-   * viscosity will be too small for the double accuracy which stores
-   * the viscosity solutions and the finite difference solution.
-   */
-  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
-  in_base.strain_rate[0][0][0] = 1e-12;
-  in_base.strain_rate[0][0][1] = 1e-12;
-  in_base.strain_rate[0][1][1] = 1e-11;
-  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[1][0][0] = -1.71266e-13;
-  in_base.strain_rate[1][0][1] = -5.82647e-12;
-  in_base.strain_rate[1][1][1] = 4.21668e-14;
-  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[2][1][1] = 1e-13;
-  in_base.strain_rate[2][0][1] = 1e-11;
-  in_base.strain_rate[2][0][0] = -1e-12;
-  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[3][1][1] = 1e-22;
-  in_base.strain_rate[3][0][1] = 1e-22;
-  in_base.strain_rate[3][0][0] = -1e-22;
-  /**
-   * We can get it working with these values:
-   *
-   * in_base.strain_rate[3][1][1] = 9e-16;
-   * in_base.strain_rate[3][0][1] = 9e-16;
-   * in_base.strain_rate[3][0][0] = -9e-16;
-   *
-   * With very low strain-rates the differences between the finite difference and
-   * analytical solution grow. We  interpent this as that the finite difference
-   * method we use becomes unaccurate for very low strain-rates.
-   */
-  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[4][1][1] = 1e-11;
-  in_base.strain_rate[4][0][1] = 1e-11;
-  in_base.strain_rate[4][0][0] = 1e-11;
-
-  in_base.temperature[0] = 293;
-  in_base.temperature[1] = 1600;
-  in_base.temperature[2] = 2000;
-  in_base.temperature[3] = 2100;
-  in_base.temperature[4] = 2200;
-
-  SymmetricTensor<2,dim> zerozero = SymmetricTensor<2,dim>();
-  SymmetricTensor<2,dim> onezero = SymmetricTensor<2,dim>();
-  SymmetricTensor<2,dim> oneone = SymmetricTensor<2,dim>();
-
-  zerozero[0][0] = 1;
-  onezero[1][0]  = 0.5; // because symmetry doubles this entry
-  oneone[1][1]   = 1;
-
-  double finite_difference_accuracy = 1e-7;
-  double finite_difference_factor = 1+finite_difference_accuracy;
-
-  bool Error = false;
-
-  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
-  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
-
-  MaterialModelInputs<dim> in_dviscositydstrainrate_zerozero(in_base);
-  MaterialModelInputs<dim> in_dviscositydstrainrate_onezero(in_base);
-  MaterialModelInputs<dim> in_dviscositydstrainrate_oneone(in_base);
-
-  in_dviscositydstrainrate_zerozero.strain_rate[0] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[0][0][0]) * finite_difference_accuracy * zerozero;
-  in_dviscositydstrainrate_zerozero.strain_rate[1] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[1][0][0]) * finite_difference_accuracy * zerozero;
-  in_dviscositydstrainrate_zerozero.strain_rate[2] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[2][0][0]) * finite_difference_accuracy * zerozero;
-  in_dviscositydstrainrate_zerozero.strain_rate[3] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[3][0][0]) * finite_difference_accuracy * zerozero;
-  in_dviscositydstrainrate_zerozero.strain_rate[4] += std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[4][0][0]) * finite_difference_accuracy * zerozero;
-  in_dviscositydstrainrate_onezero.strain_rate[0]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[0][1][0]) * finite_difference_accuracy * onezero;
-  in_dviscositydstrainrate_onezero.strain_rate[1]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[1][1][0]) * finite_difference_accuracy * onezero;
-  in_dviscositydstrainrate_onezero.strain_rate[2]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[2][1][0]) * finite_difference_accuracy * onezero;
-  in_dviscositydstrainrate_onezero.strain_rate[3]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[3][1][0]) * finite_difference_accuracy * onezero;
-  in_dviscositydstrainrate_onezero.strain_rate[4]  += std::fabs(in_dviscositydstrainrate_onezero.strain_rate[4][1][0]) * finite_difference_accuracy * onezero;
-  in_dviscositydstrainrate_oneone.strain_rate[0]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[0][1][1]) * finite_difference_accuracy * oneone;
-  in_dviscositydstrainrate_oneone.strain_rate[1]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[1][1][1]) * finite_difference_accuracy * oneone;
-  in_dviscositydstrainrate_oneone.strain_rate[2]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[2][1][1]) * finite_difference_accuracy * oneone;
-  in_dviscositydstrainrate_oneone.strain_rate[3]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[3][1][1]) * finite_difference_accuracy * oneone;
-  in_dviscositydstrainrate_oneone.strain_rate[4]   += std::fabs(in_dviscositydstrainrate_oneone.strain_rate[4][1][1]) * finite_difference_accuracy * oneone;
-
-  MaterialModelInputs<dim> in_dviscositydtemperature(in_base);
-  in_dviscositydtemperature.temperature[0] *= 1.0000000001;
-  in_dviscositydtemperature.temperature[1] *= 1.0000000001;
-  in_dviscositydtemperature.temperature[2] *= 1.0000000001;
-  in_dviscositydtemperature.temperature[3] *= 1.0000000001;
-  in_dviscositydtemperature.temperature[4] *= 1.0000000001;
-
-
-  MaterialModelOutputs<dim> out_base(5,3);
-
-  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
-  MaterialModelOutputs<dim> out_dviscositydstrainrate_zerozero(5,3);
-  MaterialModelOutputs<dim> out_dviscositydstrainrate_onezero(5,3);
-  MaterialModelOutputs<dim> out_dviscositydstrainrate_oneone(5,3);
-  MaterialModelOutputs<dim> out_dviscositydtemperature(5,3);
-
-  if (out_base.get_additional_output<MaterialModelDerivatives<dim>>() != nullptr)
-    throw "error";
-
-  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
-
-  SpiegelmanMaterial<dim> mat;
-  ParameterHandler prm;
-  mat.declare_parameters(prm);
-
-  prm.enter_subsection("Compositional fields");
-  {
-    prm.set("Number of fields","3");
-    prm.set("List of conductivities","2.25");
-    prm.set("List of capacities","1250");
-    prm.set("List of reference densities","2700.0");
-    prm.set("List of cohesions","1e8,0,1e8,1e8");
-    prm.set("List of angles of internal friction","30.0");
-    prm.set("List of initial viscosities","1e20");
-    prm.set("List of constant viscosities","0,1e21,0,0");
-  }
-  prm.leave_subsection();
-  prm.enter_subsection("Material model");
-  {
-    prm.enter_subsection ("Spiegelman 2016");
-    {
-      prm.set("Use deviator of strain-rate", "false");
-      prm.set("Use analytical derivative", "true");
-      prm.set ("Viscosity averaging p", std::to_string(parameter));
-    }
-    prm.leave_subsection();
-  }
-  prm.leave_subsection();
-
-  mat.parse_parameters(prm);
-
-  mat.evaluate(in_base, out_base);
-  mat.evaluate(in_dviscositydpressure, out_dviscositydpressure);
-  mat.evaluate(in_dviscositydstrainrate_zerozero, out_dviscositydstrainrate_zerozero);
-  mat.evaluate(in_dviscositydstrainrate_onezero, out_dviscositydstrainrate_onezero);
-  mat.evaluate(in_dviscositydstrainrate_oneone, out_dviscositydstrainrate_oneone);
-  mat.evaluate(in_dviscositydtemperature, out_dviscositydtemperature);
-
-  //set up additional output for the derivatives
-  MaterialModelDerivatives<dim> *derivatives;
-  derivatives = out_base.get_additional_output<MaterialModelDerivatives<dim>>();
-
-  double temp;
-  for (unsigned int i = 0; i < 5; i++)
-    {
-      // prevent division by zero. If it is zero, the test has passed, because or
-      // the finite difference and the analytical result match perfectly, or (more
-      // likely) the material model in independent of this variable.
-      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
-      if (in_base.pressure[i] != 0)
-        {
-          temp /= (in_base.pressure[i] * finite_difference_accuracy);
-        }
-
-      std::cout << "pressure on quadrature point " << i << ": Finite difference = " << temp << ". Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i] << std::endl;
-      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * 0.5 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
-        {
-          std::cout << "Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
-          Error = true;
-        }
-
-    }
-
-  for (unsigned int i = 0; i < 5; i++)
-    {
-      // prevent division by zero. If it is zero, the test has passed, because or
-      // the finite difference and the analytical result match perfectly, or (more
-      // likely) the material model in independent of this variable.
-      temp = out_dviscositydstrainrate_zerozero.viscosities[i] - out_base.viscosities[i];
-      if (temp != 0)
-        {
-          temp /= std::fabs(in_dviscositydstrainrate_zerozero.strain_rate[i][0][0]) * finite_difference_accuracy;
-        }
-      std::cout << "zerozero on quadrature point " << i << ": Finite difference = " << temp << ". Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][0][0] << std::endl;
-      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][0][0]) > 1e-3 * 0.5 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][0][0])))
-        {
-          std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
-          Error = true;
-        }
-
-
-
-    }
-
-  for (unsigned int i = 0; i < 5; i++)
-    {
-      // prevent division by zero. If it is zero, the test has passed, because or
-      // the finite difference and the analytical result match perfectly, or (more
-      // likely) the material model in independent of this variable.
-      temp = out_dviscositydstrainrate_onezero.viscosities[i] - out_base.viscosities[i];
-      if (temp != 0)
-        {
-          temp /= std::fabs(in_dviscositydstrainrate_onezero.strain_rate[i][1][0]) * finite_difference_accuracy;
-        }
-      std::cout << "onezero on quadrature point " << i << ": Finite difference = " << temp << ". Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][1][0]   << std::endl;
-      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][1][0]) > 1e-3 * 0.5 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][1][0])) )
-        {
-          std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
-          Error = true;
-        }
-    }
-
-  for (unsigned int i = 0; i < 5; i++)
-    {
-      // prevent division by zero. If it is zero, the test has passed, because or
-      // the finite difference and the analytical result match perfectly, or (more
-      // likely) the material model in independent of this variable.
-      temp = out_dviscositydstrainrate_oneone.viscosities[i] - out_base.viscosities[i];
-      if (temp != 0)
-        {
-          temp /= std::fabs(in_dviscositydstrainrate_oneone.strain_rate[i][1][1]) * finite_difference_accuracy;
-        }
-      std::cout << "oneone on quadrature point " << i << ": Finite difference = " << temp << ". Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][1][1]  << std::endl;
-      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][1][1]) > 1e-3 * 0.5 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][1][1])) )
-        {
-          std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
-          Error = true;
-        }
-
-    }
-
-  if (Error)
-    {
-      std::cout << "Some parts of the test were not successful." << std::endl;
-    }
-  else
-    {
-      std::cout << "OK" << std::endl;
-    }
-
-  return 42;
-}
-
-int exit_function()
-{
-  exit(0);
-  return 42;
-}
-// run this function by initializing a global variable by it
-int ii = f(-1000); // Testing min function
-int iz = f(-2); // Testing generalized p norm mean with negative p
-int ij = f(-1.5); // Testing generalized p norm mean with negative, non int p
-int ik = f(-1); // Testing harmonic mean
-int ji = f(0); // Testing geometric mean
-int jj = f(1); // Testing arithmetic mean
-int jk = f(2); // Testing generalized p norm mean with positive p
-int kj = f(1000); // Testing max function
-int kl = exit_function();
diff --git a/tests/spiegelman_material.prm.bak b/tests/spiegelman_material.prm.bak
deleted file mode 100644
index 36979856777..00000000000
--- a/tests/spiegelman_material.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-# This test checks whether the derivatives of the simple nonlinear
-# material model are the same as the finite difference derivatives
-# created by the simple nonlinear material model.
-set Additional shared libraries = tests/libspiegelman_material.so
diff --git a/tests/splines.cc.bak b/tests/splines.cc.bak
deleted file mode 100644
index 0e2011aedbd..00000000000
--- a/tests/splines.cc.bak
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * This tests the Utilities::tk::spline class for the linear case,
- * the spline case and the monotone spline case.
- */
-#include <aspect/utilities.h>
-#include <iostream>
-
-int f()
-{
-  using namespace aspect::Utilities;
-  tk::spline linear,spline,monotone_spline;
-
-  std::vector<double> x_list(5,0.0);
-  std::vector<double> y_list(5,0.0);
-
-  x_list = {1,2,3,4,5};
-  y_list = {0,5,15,2,6};
-
-  linear.set_points(x_list,y_list,false,false);
-  spline.set_points(x_list,y_list,true,false);
-  monotone_spline.set_points(x_list,y_list,true,true);
-
-  std::cout << "Linear interpolates: "
-            << "0 = " << linear(0) << ", 0.25 = " << linear(0.25) << ", 0.5 = " << linear(0.5) << ", 0.75 = " << linear(0.75)
-            << ", 1 = " << linear(1) << ", 1.25 = " << linear(1.25) << ", 1.5 = " << linear(1.5) << ", 1.75 = " << linear(1.75)
-            << ", 2 = " << linear(2) << ", 2.25 = " << linear(2.25) << ", 2.5 = " << linear(2.5) << ", 2.75 = " << linear(2.75) << std::endl
-            << "                     3 = " << linear(3) << ", 3.25 = " << linear(3.25) << ", 3.5 = " << linear(3.5) << ", 3.75 = " << linear(3.75)
-            << ", 4 = " << linear(4) << ", 4.25 = " << linear(4.25) << ", 4.5 = " << linear(4.5) << ", 4,75 = " << linear(4.75)
-            << ", 5 = " << linear(5) << ", 5.25 = " << linear(5.25) << ", 5.5 = " << linear(5.5) << ", 5.75 = " << linear(5.75)
-            << ", 6 = " << linear(6) << std::endl;
-
-  std::cout << "Spline interpolates: "
-            << "0 = " << spline(0) << ", 0.25 = " << spline(0.25) << ", 0.5 = " << spline(0.5) << ", 0.75 = " << spline(0.75)
-            << ", 1 = " << spline(1) << ", 1.25 = " << spline(1.25) << ", 1.5 = " << spline(1.5) << ", 1.75 = " << spline(1.75)
-            << ", 2 = " << spline(2) << ", 2.25 = " << spline(2.25) << ", 2.5 = " << spline(2.5) << ", 2.75 = " << spline(2.75) << std::endl
-            << "                     3 = " << spline(3) << ", 3.25 = " << spline(3.25) << ", 3.5 = " << spline(3.5) << ", 3.75 = " << spline(3.75)
-            << ", 4 = " << spline(4) << ", 4.25 = " << spline(4.25) << ", 4.5 = " << spline(4.5) << ", 4,75 = " << spline(4.75)
-            << ", 5 = " << spline(5) << ", 5.25 = " << spline(5.25) << ", 5.5 = " << spline(5.5) << ", 5.75 = " << spline(5.75)
-            << ", 6 = " << spline(6) << std::endl;
-
-  std::cout << "Monotone spline interpolates: "
-            << "0 = " << monotone_spline(0) << ", 0.25 = " << monotone_spline(0.25) << ", 0.5 = " << monotone_spline(0.5) << ", 0.75 = " << monotone_spline(0.75)
-            << ", 1 = " << monotone_spline(1) << ", 1.25 = " << monotone_spline(1.25) << ", 1.5 = " << monotone_spline(1.5) << ", 1.75 = " << monotone_spline(1.75)
-            << ", 2 = " << monotone_spline(2) << ", 2.25 = " << monotone_spline(2.25) << ", 2.5 = " << monotone_spline(2.5) << ", 2.75 = " << monotone_spline(2.75) << std::endl
-            << "                              3 = " << monotone_spline(3) << ", 3.25 = " << monotone_spline(3.25) << ", 3.5 = " << monotone_spline(3.5) << ", 3.75 = " << monotone_spline(3.75)
-            << ", 4 = " << monotone_spline(4) << ", 4.25 = " << monotone_spline(4.25) << ", 4.5 = " << monotone_spline(4.5) << ", 4,75 = " << monotone_spline(4.75)
-            << ", 5 = " << monotone_spline(5) << ", 5.25 = " << monotone_spline(5.25) << ", 5.5 = " << monotone_spline(5.5) << ", 5.75 = " << monotone_spline(5.75)
-            << ", 6 = " << monotone_spline(6) << std::endl;
-
-  exit(0);
-  return 42;
-}
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/splines.prm.bak b/tests/splines.prm.bak
deleted file mode 100644
index 1afb61af5bd..00000000000
--- a/tests/splines.prm.bak
+++ /dev/null
@@ -1 +0,0 @@
-set Additional shared libraries = tests/libsplines.so
diff --git a/tests/static_temperature.prm.bak b/tests/static_temperature.prm.bak
deleted file mode 100644
index 3b0a5c0f967..00000000000
--- a/tests/static_temperature.prm.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-# Test for static temperature field option. When the temperature field is static
-# the temperature field does not change with time, but other field like the
-# composition or elastic stress can be advected and changed in time.
-
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set Start time                 = 0.0
-set End time                               = 20e3
-set Output directory                       = static_temperature
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500e3
-    set Y extent = 500e3
-  end
-end
-
-# spherical temperature anomaly (so get appreciable velocity in first time step)
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = r=50e3, p=250e3, Tref=1400
-    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)) < r, 0, Tref)
-  end
-end
-
-subsection Temperature field
-  set Temperature method = static
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1400
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 1400
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81   #
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1400
-    set Thermal conductivity          = 3.3
-    set Thermal expansion coefficient = 3.0e-5
-    set Viscosity                     = 1e20
-  end
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 2
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set List of output variables      = density, viscosity, strain rate
-    set Output format                 = gnuplot
-    set Time between graphical output = 20e3
-    set Number of grouped files       = 0
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-end
diff --git a/tests/statistics_output.prm.bak b/tests/statistics_output.prm.bak
deleted file mode 100644
index ae7c0a2dcfd..00000000000
--- a/tests/statistics_output.prm.bak
+++ /dev/null
@@ -1,142 +0,0 @@
-# This test is a copy of adiabatic_heating_with_melt
-# except that a line for each nonlinear iteration is
-# written into the statistics file, which is the feature
-# that is tested.
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-# We only want to test if one line is written per iteration
-set Max nonlinear iterations               = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 6.6e12
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
-
-subsection Discretization
-  set Stokes velocity polynomial degree    = 2
-  set Composition polynomial degree        = 1
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9177
-    set Y extent = 183540      # maximum pressure 6 GPa
-    set Y repetitions = 20
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    subsection Function
-      set Function expression       = 1.0;0.0
-    end
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.1; 0.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 3:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    set Function expression = 0;1e-10
-  end
-end
-
-subsection Melt settings
-  set Include melt transport                  = true
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, adiabatic heating of melt
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = fluid density
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = melt global
-
-  subsection Melt global
-    set Reference solid density  = 3300
-    set Reference melt density   = 3000
-    set Reference specific heat  = 1000
-    set Reference temperature    = 1600
-    set Thermal conductivity     = 0.0
-    set Surface solidus          = 10000.0
-    set Include melting and freezing = false
-    set Reference permeability   = 1.2345679e-10
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, heating statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = viscosity, density, nonadiabatic temperature
-  end
-
-  subsection Global statistics
-    set Write statistics for each nonlinear iteration = true
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-12
-  end
-end
diff --git a/tests/steinberger_averaging.prm.bak b/tests/steinberger_averaging.prm.bak
deleted file mode 100644
index 51bc2a687da..00000000000
--- a/tests/steinberger_averaging.prm.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-# This is a copy of Steinberger compressible test,
-# but it uses two tiny property tables with constant properties to
-# test the averaging schemes for the material properties.
-# The constant mass fraction of material_2 is 0.5, which for densities of
-# 2000 kg/m^3 and 3000 kg/m^3 equates to a volume fraction of 0.4.
-#
-# The correct outputs for the properties are then:
-# volume fraction of phase A: 0.5 (volume averaged, 0.6*0.5 + 0.4*0.5)
-# volume fraction of phase B: 0.3 (volume averaged, 0.6*0.5 + 0.4*0.0)
-# volume fraction of phase C: 0.2 (volume averaged, 0.6*0.0 + 0.4*0.5)
-# Seismic Vs: 5.942027625961722 (VRH average of 6 and 6)
-# Seismic Vp: 7.922703501282297 (VRH average of 8 and 8)
-# Density: 2400 kg/m^3 (volume averaged, 0.6*2000 + 0.4*3000)
-# Thermal_expansivity: 2.4e-5 (volume averaged, 0.6*2e-5 + 0.4*3e-5)
-# Specific_heat: 1500 (mass averaged, 0.5*1000 + 0.5*2000)
-
-set CFL number                             = 1.0
-set End time                               = 0.
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = constant_material_1_tiny.txt, constant_material_2_tiny.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = named additional outputs, material properties
-    set Time between graphical output = 0
-
-    subsection Vp anomaly
-      set Number of depth slices = 96
-    end
-
-    subsection Vs anomaly
-      set Number of depth slices = 96
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_background.prm.bak b/tests/steinberger_background.prm.bak
deleted file mode 100644
index 395a34c3693..00000000000
--- a/tests/steinberger_background.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-# This is a copy of the steinberger compressible test.
-# It is intended to test the ability of the steinberger
-# material model to use the first data file as a background
-# composition, and all other compositional fields as
-# anomalies modifying this composition.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = testdata.txt,testdata-modified-alpha.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity             = 1.5
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density, thermal conductivity, thermal expansivity
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_compressible.prm.bak b/tests/steinberger_compressible.prm.bak
deleted file mode 100644
index 89c6c3e678b..00000000000
--- a/tests/steinberger_compressible.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# This is a copy of the simple compressible test.
-# However it uses the Steinberger material model, which
-# reads in lookup tables. The testdata used in this test
-# was prepared with the same equations as in the simple
-# compressible material model. The output between the two is
-# very similar, although not completely equal due to roundoff
-# errors.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = testdata.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_compressible_gmg.prm.bak b/tests/steinberger_compressible_gmg.prm.bak
deleted file mode 100644
index d301f93bc17..00000000000
--- a/tests/steinberger_compressible_gmg.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# Like steinberger_compressible but with GMG and harmonic averaging for viscosity
-
-include $ASPECT_SOURCE_DIR/tests/steinberger_compressible.prm
-
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/steinberger_conductivity.prm.bak b/tests/steinberger_conductivity.prm.bak
deleted file mode 100644
index 0af7bee1948..00000000000
--- a/tests/steinberger_conductivity.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# This is a test for the pressure- and temperature-dependent
-# thermal conductivity. It uses a linearly increasing temperature
-# in x-direction and a linearly increasing pressure in y
-# direction. The results can be compared with Stackhouse et al.,
-# 2015 (https://doi.org/10.1016/j.epsl.2015.06.050).
-
-set CFL number                             = 1.0
-set End time                               = 0
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 7.5e7
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 300 + 3700 * x
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = constant_material_1_tiny.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity formulation = p-T-dependent
-    set Thermal conductivity transition depths =
-    set Reference thermal conductivities = 4.9
-    set Pressure dependencies of thermal conductivity = 1.05e-10
-    set Reference temperatures for thermal conductivity = 1200
-    set Thermal conductivity exponents   = 1
-    set Saturation prefactors            = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   =
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output            = true
-    set Output format                 = gnuplot
-    set List of output variables      = thermal conductivity
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/steinberger_conductivity_tosi.prm.bak b/tests/steinberger_conductivity_tosi.prm.bak
deleted file mode 100644
index 7409e797042..00000000000
--- a/tests/steinberger_conductivity_tosi.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# This is a test for the pressure- and temperature-dependent
-# thermal conductivity. It uses a linearly increasing temperature
-# in x-direction and a linearly increasing pressure in y
-# direction. It has 4 conductivity layers, corresponding to
-# forsterite, wadsleyite, ringwoodite and bridgmanite +
-# ferropericlase. The results can be compared with Tosi et al.,
-# 2013 (https://doi.org/10.1016/j.pepi.2013.02.004), Figure 2.
-
-set CFL number                             = 1.0
-set End time                               = 0
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1
-    set Y extent  = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1.5e7
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1e-10 + 4000 * x
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = constant_material_1_tiny.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity formulation = p-T-dependent
-    set Thermal conductivity transition depths = 0.41, 0.52, 0.66
-    set Reference thermal conductivities = 2.47, 3.81, 3.52, 3.48
-    set Pressure dependencies of thermal conductivity = 3.3e-10, 3.4e-10, 3.6e-10, 1.2e-10
-    set Reference temperatures for thermal conductivity = 300
-    set Thermal conductivity exponents   = 0.48, 0.56, 0.61, 0.31
-    set Saturation prefactors            = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   =
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, depth average
-
-  subsection Visualization
-    set Interpolate output            = true
-    set Output format                 = gnuplot
-    set List of output variables      = thermal conductivity
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/steinberger_continuous_viscosity.prm.bak b/tests/steinberger_continuous_viscosity.prm.bak
deleted file mode 100644
index 1b624339323..00000000000
--- a/tests/steinberger_continuous_viscosity.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# This test is like the steinberger cookbook, but with the continuous version
-# of the viscosity profile.
-
-include $ASPECT_SOURCE_DIR/cookbooks/steinberger/steinberger.prm
-
-set End time                             = 2e6
-set Nonlinear solver scheme              = single Advection, single Stokes
-
-subsection Material model
-  subsection Steinberger model
-    set Radial viscosity file name       = radial-visc-continuous.txt
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
diff --git a/tests/steinberger_cookbook.prm.bak b/tests/steinberger_cookbook.prm.bak
deleted file mode 100644
index 41341225d1e..00000000000
--- a/tests/steinberger_cookbook.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-# Copy of the steinberger cookbook, with a shorter end time,
-# lower resolution and without nonlinear iterations.
-
-include $ASPECT_SOURCE_DIR/cookbooks/steinberger/steinberger.prm
-
-set End time                             = 2e6
-set Nonlinear solver scheme              = single Advection, single Stokes
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
diff --git a/tests/steinberger_latent_heat.prm.bak b/tests/steinberger_latent_heat.prm.bak
deleted file mode 100644
index e088b86af9c..00000000000
--- a/tests/steinberger_latent_heat.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# This is a copy of the steinberger compressible test. However, it activates
-# latent heat by computing the thermal expansivity and specific heat as
-# derivatives of the enthalpy, which leads to temperature jumps across phase
-# transitions.
-
-set CFL number                             = 1.0
-set End time                               = 0
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = ../pyr-ringwood88.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = true
-    set Use lateral average temperature for viscosity = false
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-# Warning: Merge the parameter in the following subsection with any
-# other parameter of the same name, otherwise your model results might change
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = material properties
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/steinberger_latent_heat_2.prm.bak b/tests/steinberger_latent_heat_2.prm.bak
deleted file mode 100644
index b7de027b6dc..00000000000
--- a/tests/steinberger_latent_heat_2.prm.bak
+++ /dev/null
@@ -1,125 +0,0 @@
-#########################################################
-# This is a model setup to test the latent heat generation.
-# It is identical to the latent_heat_enthalpy test, but utilizes
-# the steinberger material model to ensure a correct
-# implementation of the functionality. For details on the
-# test see the latent_heat_enthalpy testcase.
-
-set Dimension = 2
-set Start time                             = 0
-set End time                               = 1e15
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature          = 1000
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 50000
-    set Y extent = 1000000
-    set Y repetitions = 20
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  =
-    set Function expression = 8e-5
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields   = grain_size
-end
-
-# Warning: Merge the parameter in the following subsection with any
-# other parameter of the same name, otherwise your model results might change
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-############### Boundary conditions
-# We set the top temperature to T1=1000K.
-subsection Boundary temperature model
-  # We only fix the temperature at the upper boundary, the other boundaries
-  # are isolating. To guarantee a steady downward flow, we fix the velocity
-  # at the top and bottom, and set it to free slip on the sides.
-  set Fixed temperature boundary indicators   = top
-  set List of model names = box
-
-  subsection Box
-    set Top temperature = 1000
-  end
-end
-
-# We prescribe a constant downward flow.
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Function expression = 0;-2.1422e-11
-    set Variable names      = x,y
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000.0 + (y-1000000)/1000000
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Thermal conductivity             = 2.38
-    set Minimum viscosity                = 8.44e21
-    set Maximum viscosity                = 8.44e21
-    set Data directory = $ASPECT_SOURCE_DIR/data/material-model/latent-heat-enthalpy-test/
-    set Material file names = testdata.txt
-    set Radial viscosity file name = ../steinberger/test-steinberger-compressible/test-radial-visc.txt
-    set Lateral viscosity file name = ../steinberger/test-steinberger-compressible/test-viscosity-prefactor.txt
-    set Latent heat = true
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics, composition statistics
-end
diff --git a/tests/steinberger_lateral_fail.prm.bak b/tests/steinberger_lateral_fail.prm.bak
deleted file mode 100644
index 2d23dff80e9..00000000000
--- a/tests/steinberger_lateral_fail.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# EXPECT FAILURE
-
-# This is a copy of the simple compressible test.
-# However it uses the Steinberger material model, which
-# reads in lookup tables. The testdata used in this test
-# was prepared with the same equations as in the simple
-# compressible material model. However, the lookup table is much too large for
-# lateral averaging for the implementation currently, so an error should be
-# produced under the current conditions.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = testdata.txt
-
-    # Use overresolved viscosity prefactor file
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Use lateral average temperature for viscosity = true
-    set Number lateral average bands = 100
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_phase_fractions.prm.bak b/tests/steinberger_phase_fractions.prm.bak
deleted file mode 100644
index 9cca57ff5d8..00000000000
--- a/tests/steinberger_phase_fractions.prm.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-# This is a copy of Steinberger compressible test,
-# but it uses a pyrolite material property table instead
-# of the test data, so that reasonable seismic velocities are
-# computed. The property table also contains volume fractions of the
-# stable phases in the rock, which can be output using
-# the "named additional outputs" in the list of named outputs for
-# the Visualization postprocessor.
-# The material property table was created from raw PerpleX-vertex output
-# using the python script
-# contrib/python/create_aspect_readable_perplex_table_with_phase_volumes.py
-
-# The PerpleX calculations were run with the
-# Stixrude and Lithgow-Bertelloni
-# (2011; https://doi.org/10.1111/j.1365-246X.2010.04890.x) dataset.
-
-# The pyrolite composition is a six-component version of the composition in
-# McDonough and Sun (1995; https://doi.org/10.1016/0009-2541(94)00140-4):
-# 0.36 wt% Na2O, 37.8 wt% MgO, 4.45 wt% Al2O3, 45.0 wt% SiO2, 3.55 wt% CaO, 8.05 wt% FeO
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names              = pyr_MS95_with_volume_fractions_lo_res.dat
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = named additional outputs, Vs anomaly, Vp anomaly
-    set Time between graphical output = 0
-
-    subsection Vp anomaly
-      set Number of depth slices = 96
-    end
-
-    subsection Vs anomaly
-      set Number of depth slices = 96
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_phase_fractions_background.prm.bak b/tests/steinberger_phase_fractions_background.prm.bak
deleted file mode 100644
index de21ee96f0c..00000000000
--- a/tests/steinberger_phase_fractions_background.prm.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-# This is a copy of Steinberger compressible test,
-# but it uses pyrolite and MORB-composition material property tables instead
-# of the test data, so that reasonable seismic velocities are
-# computed. The property tables also contain volume fractions of the
-# stable phases in the rock, which can be output using
-# the "named additional outputs" in the list of named outputs for
-# the Visualization postprocessor.
-# The material property tables were created from raw PerpleX-vertex output
-# using the python script
-# contrib/python/create_aspect_readable_perplex_table_with_phase_volumes.py
-
-# The PerpleX calculations were run with the
-# Stixrude and Lithgow-Bertelloni
-# (2011; https://doi.org/10.1111/j.1365-246X.2010.04890.x) dataset.
-
-# The pyrolite composition is a six-component version of the composition in
-# McDonough and Sun (1995; https://doi.org/10.1016/0009-2541(94)00140-4):
-# 0.36 wt% Na2O, 37.8 wt% MgO, 4.45 wt% Al2O3, 45.0 wt% SiO2, 3.55 wt% CaO, 8.05 wt% FeO
-
-# The MORB composition is a six-component version of the composition in
-# Gale et al (2013; https://doi.org/10.1029/2012GC004334)
-# 2.790 wt% Na2O, 7.580 wt% MgO, 14.70 wt% Al2O3, 50.47 wt% SiO2, 11.39 wt% CaO, 10.43 wt% FeO
-
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names              = pyr_MS95_with_volume_fractions_lo_res.dat, morb_G13_with_volume_fractions_lo_res.dat
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = named additional outputs, Vs anomaly, Vp anomaly
-    set Time between graphical output = 0
-
-    subsection Vp anomaly
-      set Number of depth slices = 96
-    end
-
-    subsection Vs anomaly
-      set Number of depth slices = 96
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_phases.prm.bak b/tests/steinberger_phases.prm.bak
deleted file mode 100644
index 02bfaaed9a1..00000000000
--- a/tests/steinberger_phases.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# This is a copy of the steinberger compressible test.
-# It is intended to test the ability of the steinberger
-# material model to use the first data file as a background
-# composition, and ignore other compositional fields if
-# only a single material file is provided.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = constant_material_small.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity             = 1.5
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = material properties, named additional outputs
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_phases_2_lookups.prm.bak b/tests/steinberger_phases_2_lookups.prm.bak
deleted file mode 100644
index 89de4df7f0e..00000000000
--- a/tests/steinberger_phases_2_lookups.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# This is a copy of the steinberger phases test,
-# but it uses to lookups instead of one to see if
-# phases indices are read in correctly.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if (x-y>1,1,0)
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = constant_material_small.txt, constant_material_2_small.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity             = 1.5
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = material properties, named additional outputs
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_phases_hefesto.prm.bak b/tests/steinberger_phases_hefesto.prm.bak
deleted file mode 100644
index d2e49c92018..00000000000
--- a/tests/steinberger_phases_hefesto.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-# This is a copy of the steinberger phases test.
-# The only difference is that is uses the hefeasto instead
-# of the perplex data format. It should produce exactly the
-# same results.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = constant_material_small_hefesto.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity             = 1.5
-    set Material file format             = hefesto
-    set Derivatives file names           = constant_material_small_hefesto_derivatives.txt
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = material properties, named additional outputs
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility, specific heat
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_projected_density.prm.bak b/tests/steinberger_projected_density.prm.bak
deleted file mode 100644
index 3bfaafa5896..00000000000
--- a/tests/steinberger_projected_density.prm.bak
+++ /dev/null
@@ -1,114 +0,0 @@
-# This is a copy of the steinberger compressible test.
-# It is intended to test the ability of the steinberger
-# material model to be used with the projected density
-# approximation, which requires using compositional
-# fields that do not correspond to a look-up table.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields            = 3
-  set Names of fields             = composition, density_field, another_field
-  set Types of fields             = chemical composition, density, generic
-  set Compositional field methods = field, prescribed field, field
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (sqrt(x*x+y*y)-3481000)/(6371000-3481000); 3300; x/6371000
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = testdata.txt,testdata-modified-alpha.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity             = 1.5
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density, thermal conductivity, thermal expansivity
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
diff --git a/tests/steinberger_projected_density_dcPicard.prm.bak b/tests/steinberger_projected_density_dcPicard.prm.bak
deleted file mode 100644
index d082ef3016a..00000000000
--- a/tests/steinberger_projected_density_dcPicard.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# This is a copy of the steinberger compressible test,
-# where the default nonlinear solver scheme has been replaced
-# by the `iterated Advection and defect correction Stokes`
-# nonlinear solver scheme.
-# It is intended to test the ability of the steinberger
-# material model to be used with the projected density
-# approximation, which requires using compositional
-# fields that do not correspond to a look-up table.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Advection and defect correction Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields            = 3
-  set Names of fields             = composition, density_field, another_field
-  set Types of fields             = chemical composition, density, generic
-  set Compositional field methods = field, prescribed field, field
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (sqrt(x*x+y*y)-3481000)/(6371000-3481000); 3300; x/6371000
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = testdata.txt,testdata-modified-alpha.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity             = 1.5
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density, thermal conductivity, thermal expansivity
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Formulation
-  set Mass conservation = projected density field
-  set Temperature equation = real density
-end
diff --git a/tests/steinberger_seismic_velocities.prm.bak b/tests/steinberger_seismic_velocities.prm.bak
deleted file mode 100644
index 4ec078721f3..00000000000
--- a/tests/steinberger_seismic_velocities.prm.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-# This is a copy of Steinberger compressible test,
-# but it uses the pyrolite material property table instead
-# of the test data, so that reasonable seismic velocities are
-# computed.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names              = pyr-ringwood88.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-    set List of output variables      = named additional outputs, Vs anomaly, Vp anomaly
-    set Time between graphical output = 0
-
-    subsection Vp anomaly
-      set Number of depth slices = 96
-    end
-
-    subsection Vs anomaly
-      set Number of depth slices = 96
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_several_fields.prm.bak b/tests/steinberger_several_fields.prm.bak
deleted file mode 100644
index d549b38ea19..00000000000
--- a/tests/steinberger_several_fields.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# This is a copy of the steinberger single field test.
-# It is intended to test the ability of the steinberger
-# material model to use the first data file as a background
-# composition, and ignore several other compositional
-# fields if only a single material file is provided.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000); 2e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000); 3e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = testdata.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity             = 1.5
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = material properties
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_single_field.prm.bak b/tests/steinberger_single_field.prm.bak
deleted file mode 100644
index 713e5a079f0..00000000000
--- a/tests/steinberger_single_field.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# This is a copy of the steinberger compressible test.
-# It is intended to test the ability of the steinberger
-# material model to use the first data file as a background
-# composition, and ignore other compositional fields if
-# only a single material file is provided.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1e7 * (sqrt(x*x+y*y)-3481000)/(6371000-3481000)
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/test-steinberger-compressible/
-    set Material file names              = testdata.txt
-    set Lateral viscosity file name      = test-viscosity-prefactor.txt
-    set Radial viscosity file name       = test-radial-visc.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Thermal conductivity             = 1.5
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = material properties
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties   = density, thermal conductivity, thermal expansivity, compressibility
-    end
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
diff --git a/tests/steinberger_viscosity.prm.bak b/tests/steinberger_viscosity.prm.bak
deleted file mode 100644
index 5afe11f033a..00000000000
--- a/tests/steinberger_viscosity.prm.bak
+++ /dev/null
@@ -1,91 +0,0 @@
-# This is a copy of the steinberger_compressible test.
-# However, it uses the actual Steinberger viscosity model,
-# instead of the constant viscosity test data.
-
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names              = test-steinberger-compressible/testdata.txt
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-    set Number lateral average bands     = 40
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set List of output variables      = viscosity
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/steinberger_viscosity_adiabatic.prm.bak b/tests/steinberger_viscosity_adiabatic.prm.bak
deleted file mode 100644
index 7705b90be10..00000000000
--- a/tests/steinberger_viscosity_adiabatic.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# This is a copy of the steinberger_compressible test.
-# However, it uses the actual Steinberger viscosity model,
-# instead of the constant viscosity test data.
-# Additionally, it calculates the temperature deviation
-# for the viscosity model against the adiabatic
-# temperature profile instead of the lateral average.
-
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = Steinberger
-
-  subsection Steinberger model
-    set Data directory                   = $ASPECT_SOURCE_DIR/data/material-model/steinberger/
-    set Material file names              = test-steinberger-compressible/testdata.txt
-    set Use lateral average temperature for viscosity = false
-    set Bilinear interpolation           = true
-    set Latent heat                      = false
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set GMRES solver restart length = 200
-    set Use full A block as preconditioner = true
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics, temperature statistics, heat flux statistics, depth average
-
-  subsection Visualization
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set List of output variables      = viscosity
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
diff --git a/tests/stokes.prm.bak b/tests/stokes.prm.bak
deleted file mode 100644
index 5774224c597..00000000000
--- a/tests/stokes.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# this is a version of the stokes' law input file
-# but with less mesh refinement
-
-
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-# The setup is a 3d box with edge length 2890000 in which
-# all 6 sides have free slip boundary conditions. Because
-# the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2890000
-    set Y extent  = 2890000
-    set Z extent  = 2890000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3,4,5
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Viscosity                     = 1e22
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# This, however, is the more important part: We need to describe
-# the compositional field and its influence on the density
-# function. The following blocks say that we want to
-# advect a single compositional field and that we give it an
-# initial value that is zero outside a sphere of radius
-# r=200000m and centered at the point (p,p,p) with
-# p=1445000 (which is half the diameter of the box) and one inside.
-# The last block re-opens the material model and sets the
-# density differential per unit change in compositional field to
-# 100.
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = r=200000,p=1445000
-    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density, viscosity
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/stokes_residual.prm.bak b/tests/stokes_residual.prm.bak
deleted file mode 100644
index 08a8a88a9ac..00000000000
--- a/tests/stokes_residual.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# similar to solver_history.prm, but check the stokes residual postprocessor
-# instead of using the signal directly.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0.1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics, Stokes residual
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/stokes_residual_cheap.prm.bak b/tests/stokes_residual_cheap.prm.bak
deleted file mode 100644
index 53f3b322020..00000000000
--- a/tests/stokes_residual_cheap.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-# similar to solver_history.prm, but check the stokes residual postprocessor
-# instead of using the signal directly.
-
-include $ASPECT_SOURCE_DIR/tests/stokes_residual.prm
-
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/stokes_solver_fail.prm.bak b/tests/stokes_solver_fail.prm.bak
deleted file mode 100644
index ad8853c1ca5..00000000000
--- a/tests/stokes_solver_fail.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# This is a copy of simple_incompressible.prm that decreases Stokes solver
-# tolerance to provoke a crash and check the error message and solver history
-# output.
-
-# EXPECT FAILURE
-
-include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
-
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 10
-    set Maximum number of expensive Stokes solver steps = 0
-    set Linear solver tolerance = 1e-35
-    set Stokes solver type = block AMG
-   end
-end
diff --git a/tests/stokes_solver_fail_A.prm.bak b/tests/stokes_solver_fail_A.prm.bak
deleted file mode 100644
index 412803ef8b7..00000000000
--- a/tests/stokes_solver_fail_A.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-# This is a copy of simple_incompressible.prm that decreases Stokes solver
-# tolerance to provoke a crash and check the error message and solver history
-# output.
-
-# EXPECT FAILURE
-
-include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
-
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-    set Linear solver A block tolerance = 0
-  end
-end
diff --git a/tests/stokes_solver_fail_S.prm.bak b/tests/stokes_solver_fail_S.prm.bak
deleted file mode 100644
index 91690f406ee..00000000000
--- a/tests/stokes_solver_fail_S.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-# This is a copy of simple_incompressible.prm that decreases Stokes solver
-# tolerance to provoke a crash and check the error message and solver history
-# output.
-
-# EXPECT FAILURE
-
-include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
-
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-    set Linear solver S block tolerance = 0
-  end
-end
diff --git a/tests/stokes_solver_fail_cheap.prm.bak b/tests/stokes_solver_fail_cheap.prm.bak
deleted file mode 100644
index 0a81f485e7a..00000000000
--- a/tests/stokes_solver_fail_cheap.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# This is a copy of simple_incompressible.prm that decreases Stokes solver
-# tolerance to provoke a crash and check the error message and solver history
-# output. This test in particular checks that the correct error message is shown
-# if there are only cheap Stokes solver iterations.
-
-# EXPECT FAILURE
-
-include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
-
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-35
-    set Number of cheap Stokes solver steps = 10
-    set Maximum number of expensive Stokes solver steps = 0
-  end
-end
diff --git a/tests/stokes_solver_fail_gmg.prm.bak b/tests/stokes_solver_fail_gmg.prm.bak
deleted file mode 100644
index 11412d9632d..00000000000
--- a/tests/stokes_solver_fail_gmg.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# This is a copy of simple_incompressible.prm that decreases Stokes solver
-# tolerance to provoke a crash and check the error message and solver history
-# output.
-
-# EXPECT FAILURE
-
-include $ASPECT_SOURCE_DIR/tests/simple_incompressible.prm
-
-
-subsection Material model
-  set Material averaging = project to Q1 only viscosity
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-    set Linear solver tolerance = 1e-35
-    set Number of cheap Stokes solver steps = 10
-    set Maximum number of expensive Stokes solver steps = 10
-  end
-end
diff --git a/tests/stress_vs_surface_stress.cc.bak b/tests/stress_vs_surface_stress.cc.bak
deleted file mode 100644
index c45fb20207c..00000000000
--- a/tests/stress_vs_surface_stress.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "simple_shear.cc"
diff --git a/tests/stress_vs_surface_stress.prm.bak b/tests/stress_vs_surface_stress.prm.bak
deleted file mode 100644
index 1c552b2e83b..00000000000
--- a/tests/stress_vs_surface_stress.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# This is a variation of the pure_shear.prm file, and is used to test
-# the 'stress' visualization postprocessor as well as the 'surface
-# stress' visualization postprocessor that only outputs stuff on the
-# boundary.
-
-set Dimension                              = 2
-set End time                               = 0.025
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom
-  set Prescribed velocity boundary indicators = top:function, right:function
-
-  subsection Function
-    set Function expression = 1-y; x-1
-  end
-end
-
-subsection Material model
-  set Model name = finite strain
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = strain_xx, strain_xy, strain_yx, strain_yy
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0;0.0;0.0;1.0
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set Interpolate output = false
-    set List of output variables = stress, surface stress
-    set Time between graphical output = 0.05
-  end
-end
diff --git a/tests/stress_vs_surface_stress_point_values.cc.bak b/tests/stress_vs_surface_stress_point_values.cc.bak
deleted file mode 100644
index c45fb20207c..00000000000
--- a/tests/stress_vs_surface_stress_point_values.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "simple_shear.cc"
diff --git a/tests/stress_vs_surface_stress_point_values.prm.bak b/tests/stress_vs_surface_stress_point_values.prm.bak
deleted file mode 100644
index 41288b89db2..00000000000
--- a/tests/stress_vs_surface_stress_point_values.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# This is a variation of the pure_shear.prm file, and is used to test
-# the 'stress' visualization postprocessor as well as the 'surface
-# stress' visualization postprocessor that only outputs stuff on the
-# boundary. The two ought to agree on their results at the boundary.
-
-set Dimension                              = 2
-
-include $ASPECT_SOURCE_DIR/tests/stress_vs_surface_stress.prm
-
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Point-wise stress and strain = true
-  end
-end
diff --git a/tests/subduction_initiation_compositional_fields.prm.bak b/tests/subduction_initiation_compositional_fields.prm.bak
deleted file mode 100644
index 28b2d4298f6..00000000000
--- a/tests/subduction_initiation_compositional_fields.prm.bak
+++ /dev/null
@@ -1,51 +0,0 @@
-# Parameter file for replicating Matsumoto & Tomoda 1983
-# see cookbooks/subduction_initiation for more details
-
-include $ASPECT_SOURCE_DIR/cookbooks/subduction_initiation/subduction_initiation.prm.base
-
-set Dimension                              = 2
-set End time                               = 0
-
-subsection Mesh refinement
-  set Initial adaptive refinement   = 0
-  set Initial global refinement     = 3
-end
-
-#materials are:
-# asthenosphere left,
-# asthenosphere right,
-# lithosphere left,
-# lithosphere right,
-# water.
-
-subsection Material model
-  set Model name = multicomponent
-
-  subsection Multicomponent
-    set Densities = 3200, 3200, 3300, 3300, 1030
-    set Viscosities = 1e21, 1e21, 1e22, 1e22, 1e18
-    set Viscosity averaging scheme = harmonic
-    set Thermal expansivities = 0
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 4
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = L0=300e3, H=180e3
-    set Function expression = if((x>=L0 && y<H-18e3),1,0) ;\
-                              if((x<=L0 && y>H-60e3 && y<=H-10e3),1,0) ;\
-                              if((x>=L0 && y>=H-18e3 && y<=H-8e3),1,0) ;\
-                              if((x<=L0 && y>H-10e3) || (x>=L0 && y>H-8e3),1,0)
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics, pressure statistics, material statistics, global statistics
-end
diff --git a/tests/supg-compositional-passive.prm.bak b/tests/supg-compositional-passive.prm.bak
deleted file mode 100644
index 5e6b8c5127a..00000000000
--- a/tests/supg-compositional-passive.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-#########################################################
-# SUPG - COMPOSITIONAL PASSIVE
-# This is a test based off of the composition-passive.prm file.
-# All settings are exactly the same with the exception
-# that we are using SUPG instead of entropy viscosity,
-# and that things were made slightly simpler to make
-# the test run faster.
-#
-# See the manual for more information about this setup.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = false
-set Output directory                       = output
-
-subsection Discretization
-  subsection Stabilization parameters
-    set Stabilization method = SUPG
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, temperature statistics, composition statistics
-
-  subsection Visualization
-    set Time between graphical output = 0.1
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields that will be
-# advected along. Their initial conditions are given by
-# a function that is one for the lowermost 0.2 height
-# units of the domain and zero otherwise in the first case,
-# and one in the top most 0.2 height units in the latter.
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y>0.8, 1, 0)
-  end
-end
diff --git a/tests/supg.prm.bak b/tests/supg.prm.bak
deleted file mode 100644
index d0d0ce3fe1e..00000000000
--- a/tests/supg.prm.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-# SUPG
-# Here we prescribe a circular Stokes flow and test if SUPG works while it rotates
-
-# set CFL number = 0.1
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = .5
-set Output directory                       = output
-set Nonlinear solver scheme                = single Advection, no Stokes
-
-subsection Prescribed Stokes solution
-  set Model name = circle
-end
-
-subsection Discretization
-  set Temperature polynomial degree = 2
-
-  subsection Stabilization parameters
-    set Stabilization method = SUPG
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 2
-    set Box origin X coordinate = -1
-    set Box origin Y coordinate = -1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression =  if((sqrt((x-0)^2+(y-0.5)^2)<0.3)&(abs(x)>=0.05|y>=0.7),1,if(sqrt((x-0)^2+(y+0.5)^2)<0.3,1-sqrt((x-0)^2+(y+0.5)^2)/0.3,if(sqrt((x+0.5)^2+(y+0)^2)<0.3,1.0/4.0*(1+cos(pi*min(sqrt((x+0.5)^2+(y+0)^2)/0.3,1))),0)))
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top, bottom, left, right
-
-  subsection Box
-    set Bottom temperature = 0
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0  # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-5
-    set Thermal expansion coefficient = 0
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = .1
-    set List of output variables = artificial viscosity
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/surface_elevation_box_ascii_data.prm.bak b/tests/surface_elevation_box_ascii_data.prm.bak
deleted file mode 100644
index 5b05fb2996b..00000000000
--- a/tests/surface_elevation_box_ascii_data.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test the 'surface elevation' visualization postprocessor using a
-# model that imposes an initial topography.
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/tests/box_initial_topography_ascii_data.prm
-
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = surface elevation
-  end
-end
diff --git a/tests/surface_elevation_box_ascii_data_moved_origin.prm.bak b/tests/surface_elevation_box_ascii_data_moved_origin.prm.bak
deleted file mode 100644
index 2d7bb232045..00000000000
--- a/tests/surface_elevation_box_ascii_data_moved_origin.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test the 'surface elevation' visualization postprocessor using a
-# model that imposes an initial topography.
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/tests/box_initial_topography_ascii_data_moved_origin.prm
-
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = surface elevation
-  end
-end
diff --git a/tests/surface_elevation_box_function.prm.bak b/tests/surface_elevation_box_function.prm.bak
deleted file mode 100644
index e86ffcaa379..00000000000
--- a/tests/surface_elevation_box_function.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test the 'surface elevation' visualization postprocessor using a
-# model that imposes an initial topography.
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/box_initial_topography_function.prm
-
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = surface elevation
-  end
-end
diff --git a/tests/surface_elevation_box_prm_polygon.prm.bak b/tests/surface_elevation_box_prm_polygon.prm.bak
deleted file mode 100644
index 48345b0f6f8..00000000000
--- a/tests/surface_elevation_box_prm_polygon.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test the 'surface elevation' visualization postprocessor using a
-# model that imposes an initial topography.
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/tests/box_initial_topography_prm_polygon.prm
-
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = surface elevation
-  end
-end
diff --git a/tests/surface_elevation_chunk_ascii_data.prm.bak b/tests/surface_elevation_chunk_ascii_data.prm.bak
deleted file mode 100644
index c1e5a5e0e03..00000000000
--- a/tests/surface_elevation_chunk_ascii_data.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test the 'surface elevation' visualization postprocessor using a
-# model that imposes an initial topography.
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/chunk_initial_topography_ascii_data.prm
-
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = surface elevation
-  end
-end
diff --git a/tests/surface_elevation_chunk_ascii_data_3d.prm.bak b/tests/surface_elevation_chunk_ascii_data_3d.prm.bak
deleted file mode 100644
index f35229adb01..00000000000
--- a/tests/surface_elevation_chunk_ascii_data_3d.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test the 'surface elevation' visualization postprocessor using a
-# model that imposes an initial topography.
-
-set Dimension = 3
-
-include $ASPECT_SOURCE_DIR/tests/chunk_initial_topography_ascii_data_3d.prm
-
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = surface elevation
-  end
-end
diff --git a/tests/surface_elevation_chunk_ascii_data_3d_colatitude.prm.bak b/tests/surface_elevation_chunk_ascii_data_3d_colatitude.prm.bak
deleted file mode 100644
index 43bc34d8ef2..00000000000
--- a/tests/surface_elevation_chunk_ascii_data_3d_colatitude.prm.bak
+++ /dev/null
@@ -1,32 +0,0 @@
-# Test the 'surface elevation' visualization postprocessor using a
-# model that imposes an initial topography.
-
-set Dimension = 3
-
-## From here on, this is a copy of the chunk_initial_topography_ascii_data_3d_colatitude.prm
-## file because apparently we cannot recursively include .prm files.
-include $ASPECT_SOURCE_DIR/tests/chunk_initial_topography_ascii_data_3d.prm
-
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/test/
-      set Data file name       = shell_3d_outer_2.0.txt
-    end
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = surface elevation
-  end
-end
diff --git a/tests/surface_elevation_chunk_ascii_data_global_3d.prm.bak b/tests/surface_elevation_chunk_ascii_data_global_3d.prm.bak
deleted file mode 100644
index 0cde540b5fd..00000000000
--- a/tests/surface_elevation_chunk_ascii_data_global_3d.prm.bak
+++ /dev/null
@@ -1,112 +0,0 @@
-# Test the 'surface elevation' visualization postprocessor using a
-# model that imposes an initial topography that is read from a data file
-# that describes global topography at 1-degree resolution.
-
-
-##############################################3
-# Start with a copy of chunk_initial_topography_ascii_data_3d.prm,
-# but with a different data file (a global topography description
-# with 1 degree accuracy
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-
-###################################
-# This is the part that is different: Specifically, do not actually
-# solve anything, and output the elevation so that we can inspect it.
-# Also use a higher mesh resolution
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    #    set Chunk minimum longitude = -10
-    #    set Chunk maximum longitude = 90
-    #    set Chunk minimum latitude = -45
-    #    set Chunk maximum latitude = 45
-
-    set Chunk minimum longitude = -45
-    set Chunk maximum longitude = 45
-    set Chunk minimum latitude = -45
-    set Chunk maximum latitude = 45
-    set Longitude repetitions = 1
-    set Latitude repetitions = 1
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/
-      set Data file name       = global_1deg.txt.gz
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 3
-  set Initial global refinement          = 2
-  set Skip solvers on initial refinement = false
-  set Strategy                           = topography
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = outer, east, west, north, south
-  set Zero velocity boundary indicators       = inner
-end
-
-# The ascii data file prescribes a topography between -2000 m and
-# +9000 m. The topography postprocessor output should match with this.
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = surface elevation
-  end
-end
diff --git a/tests/surface_elevation_spherical_shell_ascii_data_global_3d.prm.bak b/tests/surface_elevation_spherical_shell_ascii_data_global_3d.prm.bak
deleted file mode 100644
index 653dd878e4c..00000000000
--- a/tests/surface_elevation_spherical_shell_ascii_data_global_3d.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# Test the 'surface elevation' visualization postprocessor using a
-# model that imposes an initial topography that is read from a data file
-# that describes global topography at 1-degree resolution.
-
-
-##############################################3
-# Start with a copy of chunk_initial_topography_ascii_data_3d.prm,
-# but with a different data file (a global topography description
-# with 1 degree accuracy
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-
-###################################
-# This is the part that is different: Specifically, do not actually
-# solve anything, and output the elevation so that we can inspect it.
-# Also use a higher mesh resolution
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Initial topography model
-    set Model name = ascii data
-
-    subsection Ascii data model
-      set Data directory       = $ASPECT_SOURCE_DIR/data/geometry-model/initial-topography-model/ascii-data/
-      set Data file name       = global_1deg.txt.gz
-    end
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = function
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Function
-    set Function expression = 1613.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Skip solvers on initial refinement = false
-  set Strategy                           = topography
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators =
-  set Zero velocity boundary indicators       = inner
-end
-
-# The ascii data file prescribes a topography between -2000 m and
-# +9000 m. The topography postprocessor output should match with this.
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = surface elevation
-  end
-end
diff --git a/tests/surface_stress_strainrate_3d.cc.bak b/tests/surface_stress_strainrate_3d.cc.bak
deleted file mode 100644
index 45d7c30f6ef..00000000000
--- a/tests/surface_stress_strainrate_3d.cc.bak
+++ /dev/null
@@ -1 +0,0 @@
-#include "simple_shear.cc"
diff --git a/tests/surface_stress_strainrate_3d.prm.bak b/tests/surface_stress_strainrate_3d.prm.bak
deleted file mode 100644
index a78383d0c43..00000000000
--- a/tests/surface_stress_strainrate_3d.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# This is a variation of the pure_shear.prm file, and is used to test
-# in 3D the 'stress' and 'strain rate tensor' visualization postprocessors
-# as well as the 'surface stress' and 'surface strain rate tensor'
-# visualization postprocessors that only output stuff on the
-# boundary. They ought to agree on their results at the boundary.
-set Dimension                              = 3
-set End time                               = 0.025
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 1.0
-    set Y extent  = 1.0
-    set Z extent  = 1.0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, bottom, front, back
-  set Prescribed velocity boundary indicators = top:function, right:function
-
-  subsection Function
-    set Function expression = 1-z; 0; x-1
-  end
-end
-
-subsection Material model
-  set Model name = finite strain
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 9
-  set Names of fields = strain_xx, strain_xy, strain_xz, strain_yx, strain_yy, strain_yz, strain_zx, strain_zy, strain_zz
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 1.0
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = top
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = strain rate
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set Interpolate output = false
-    set List of output variables = stress, surface stress, strain rate tensor, surface strain rate tensor
-    set Time between graphical output = 0.025
-    set Point-wise stress and strain = true
-  end
-end
diff --git a/tests/symbolic_boundary_names_box.prm.bak b/tests/symbolic_boundary_names_box.prm.bak
deleted file mode 100644
index 24523600a45..00000000000
--- a/tests/symbolic_boundary_names_box.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# like simpler_box.prm, but use symbolic names for all boundary
-# components
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = left, right
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = right
-  set Zero velocity boundary indicators       = left, bottom, top
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/symbolic_boundary_names_box_constant_bc.prm.bak b/tests/symbolic_boundary_names_box_constant_bc.prm.bak
deleted file mode 100644
index 7d3df1f9397..00000000000
--- a/tests/symbolic_boundary_names_box_constant_bc.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-# like symbolic_boundary_names_box but use the 'constant' boundary
-# temperature model and use symbolic names there.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = left, right, bottom, top
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 0: 42, right: 84, bottom: 126, 3: 168
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = right
-  set Zero velocity boundary indicators       = left, bottom, top
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/symbolic_boundary_names_spherical_shell_2d_180_degrees.prm.bak b/tests/symbolic_boundary_names_spherical_shell_2d_180_degrees.prm.bak
deleted file mode 100644
index 74be6d2b0cc..00000000000
--- a/tests/symbolic_boundary_names_spherical_shell_2d_180_degrees.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-# like simpler_box.prm, but use symbolic names for all boundary
-# components
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 180
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, left
-  set Zero velocity boundary indicators       = outer, right
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/symbolic_boundary_names_spherical_shell_2d_90_degrees.prm.bak b/tests/symbolic_boundary_names_spherical_shell_2d_90_degrees.prm.bak
deleted file mode 100644
index 7ec1b30e48d..00000000000
--- a/tests/symbolic_boundary_names_spherical_shell_2d_90_degrees.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-# like simpler_box.prm, but use symbolic names for all boundary
-# components
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, left
-  set Zero velocity boundary indicators       = outer, right
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/symbolic_boundary_names_spherical_shell_2d_full.prm.bak b/tests/symbolic_boundary_names_spherical_shell_2d_full.prm.bak
deleted file mode 100644
index 4d9dbd07b62..00000000000
--- a/tests/symbolic_boundary_names_spherical_shell_2d_full.prm.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-# like simpler_box.prm, but use symbolic names for all boundary
-# components
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner
-  set Zero velocity boundary indicators       = outer
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/symbolic_boundary_names_spherical_shell_3d_90_degrees.prm.bak b/tests/symbolic_boundary_names_spherical_shell_3d_90_degrees.prm.bak
deleted file mode 100644
index d218a6e3e11..00000000000
--- a/tests/symbolic_boundary_names_spherical_shell_3d_90_degrees.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-# like simpler_box.prm, but use symbolic names for all boundary
-# components
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner, east
-  set Zero velocity boundary indicators       = outer, west, south
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/symbolic_boundary_names_spherical_shell_3d_full.prm.bak b/tests/symbolic_boundary_names_spherical_shell_3d_full.prm.bak
deleted file mode 100644
index 0077e3c6847..00000000000
--- a/tests/symbolic_boundary_names_spherical_shell_3d_full.prm.bak
+++ /dev/null
@@ -1,60 +0,0 @@
-# like simpler_box.prm, but use symbolic names for all boundary
-# components
-
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-end
-
-subsection Gravity model
-  set Model name = radial constant
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Material model
-  set Model name = simpler
-
-  subsection Simpler model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner
-  set Zero velocity boundary indicators       = outer
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity
-  end
-end
diff --git a/tests/tangurnis.cc.bak b/tests/tangurnis.cc.bak
deleted file mode 100644
index e603297ca45..00000000000
--- a/tests/tangurnis.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/tangurnis/code/tangurnis.cc"
diff --git a/tests/tangurnis_ba.cc.bak b/tests/tangurnis_ba.cc.bak
deleted file mode 100644
index 7966a8ab1f8..00000000000
--- a/tests/tangurnis_ba.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "tangurnis.cc"
diff --git a/tests/tangurnis_ba.prm.bak b/tests/tangurnis_ba.prm.bak
deleted file mode 100644
index 2f85430f32b..00000000000
--- a/tests/tangurnis_ba.prm.bak
+++ /dev/null
@@ -1,248 +0,0 @@
-# TanGurnis BA benchmark
-
-set Additional shared libraries            = ./code/libtangurnis.so
-
-# At the top, state that the program should be run for a two-dimensional
-# simulation
-set Dimension = 2
-
-# In computations, the time step $k$ is chosen according to $k = c \min_K
-# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
-# and the denominator is the maximal magnitude of the velocity on cell $K$
-# times the polynomial degree $p_T$ of the temperature discretization. The
-# dimensionless constant $c$ is called the CFL number in this program. For
-# time discretizations that have explicit components, $c$ must be less than a
-# constant that depends on the details of the time discretization and that is
-# no larger than one. On the other hand, for implicit discretizations such as
-# the one chosen here, one can choose the time step as large as one wants (in
-# particular, one can choose $c>1$) though a CFL number significantly larger
-# than one will yield rather diffusive solutions. Units: None.
-set CFL number                             = 1.0
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0.0001
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# The name of the directory into which all output files should be placed. This
-# may be an absolute or a relative path.
-set Output directory                       = output
-
-# A flag indicating whether the computation should be resumed from a
-# previously saved state (if true) or start from scratch (if false).
-set Resume computation                     = false
-
-# The start time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set Start time                             = 0
-
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Adiabatic surface temperature          = 0
-
-# The mathematical equations that describe thermal convection only determine
-# the pressure up to an arbitrary constant. On the other hand, for comparison
-# and for looking up material parameters it is important that the pressure be
-# normalized somehow. We do this by enforcing a particular average pressure
-# value at the surface of the domain, where the geometry model determines
-# where the surface is. This parameter describes what this average surface
-# pressure value is supposed to be. By default, it is set to zero, but one may
-# want to choose a different value for example for simulating only the volume
-# of the mantle below the lithosphere, in which case the surface pressure
-# should be the lithostatic pressure at the bottom of the lithosphere.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Surface pressure                       = 0
-
-# When computing results for mantle convection simulations, it is often
-# difficult to judge the order of magnitude of results when they are stated in
-# MKS units involving seconds. Rather, some kinds of results such as
-# velocities are often stated in terms of meters per year (or, sometimes,
-# centimeters per year). On the other hand, for non-dimensional computations,
-# one wants results in their natural unit system as used inside the code. If
-# this flag is set to 'true' conversion to years happens; if it is 'false', no
-# such conversion happens.
-set Use years in output instead of seconds = false
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=0.0, gamma=1.0
-    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-subsection Formulation
-  set Formulation = Boussinesq approximation
-
-  #set Mass conservation        = incompressible
-  #set Temperature equation     = reference density profile
-end
-
-subsection Boundary temperature model
-  set List of model names = Tan Gurnis
-
-  # A comma separated list of integers denoting those boundaries on which the
-  # temperature is fixed and described by the boundary temperature object
-  # selected in its own section of this input file. All boundary indicators
-  # used by the geometry but not explicitly listed here will end up with
-  # no-flux (insulating) boundary conditions.
-  set Fixed temperature boundary indicators   = left, right, bottom, top
-end
-
-subsection Discretization
-  # The polynomial degree to use for the velocity variables in the Stokes
-  # system. Units: None.
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-
-  # Whether to use a Stokes discretization that is locally conservative at the
-  # expense of a larger number of degrees of freedom (true), or to go with a
-  # cheaper discretization that does not locally conserve mass, although it is
-  # globally conservative (false).
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    # Extent of the box in x-direction. Units: \\si{\\meter}.
-    set X extent = 1
-
-    # Extent of the box in y-direction. Units: \\si{\\meter}.
-    set Y extent = 1
-
-    # Extent of the box in z-direction. This value is ignored if the
-    # simulation is in 2d Units: \\si{\\meter}.
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*y)*cos(pi*1*x)
-  end
-end
-
-subsection Material model
-  set Model name = Tan Gurnis
-
-  subsection Tan Gurnis model
-    set Di                            = 0
-    set gamma                         = 1 # infinity really, but does not matter
-    set a                             = 0
-    set wavenumber                    = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-
-  # The method used to determine which cells to refine and which to coarsen.
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 100
-end
-
-subsection Boundary velocity model
-  # A comma separated list of integers denoting those boundaries on which the
-  # velocity is tangential and unrestrained, i.e., where no external forces
-  # act to prescribe a particular tangential velocity (although there is a
-  # force that requires the flow to be tangential).
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  # A comma separated list of postprocessor objects that should be run at the
-  # end of each time step. Some of these postprocessors will declare their own
-  # parameters which may, for example, include that they will actually do
-  # something only every so many time steps or years. Alternatively, the text
-  # 'all' indicates that all available postprocessors should be run after each
-  # time step.
-  #
-  # The following postprocessors are available:
-  #
-  # `depth average': A postprocessor that computes depth averaged quantities
-  # and writes them out.
-  #
-  # `heat flux statistics': A postprocessor that computes some statistics
-  # about the heat flux across boundaries.
-  #
-  # `heat flux statistics for the table model': A postprocessor that computes
-  # some statistics about the heat flux across boundaries.
-  #
-  # `velocity statistics for the table model': A postprocessor that computes
-  # some statistics about the velocity field.
-  #
-  # `temperature statistics': A postprocessor that computes some statistics
-  # about the temperature field.
-  #
-  # `velocity statistics': A postprocessor that computes some statistics about
-  # the velocity field.
-  #
-  # `visualization': A postprocessor that takes the solution and writes it
-  # into files that can be read by a graphical visualization program.
-  # Additional run time parameters are read from the parameter subsection
-  # 'Visualization'.
-  set List of postprocessors = Tan Gurnis error, visualization
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/tangurnis_ba_custom.cc.bak b/tests/tangurnis_ba_custom.cc.bak
deleted file mode 100644
index 7966a8ab1f8..00000000000
--- a/tests/tangurnis_ba_custom.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "tangurnis.cc"
diff --git a/tests/tangurnis_ba_custom.prm.bak b/tests/tangurnis_ba_custom.prm.bak
deleted file mode 100644
index 0e466aaaed5..00000000000
--- a/tests/tangurnis_ba_custom.prm.bak
+++ /dev/null
@@ -1,247 +0,0 @@
-# identical to tangurnis_ba.prm, but using a custom "formulation" instead of BA
-
-set Additional shared libraries            = ./code/libtangurnis.so
-
-# At the top, state that the program should be run for a two-dimensional
-# simulation
-set Dimension = 2
-
-# In computations, the time step $k$ is chosen according to $k = c \min_K
-# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
-# and the denominator is the maximal magnitude of the velocity on cell $K$
-# times the polynomial degree $p_T$ of the temperature discretization. The
-# dimensionless constant $c$ is called the CFL number in this program. For
-# time discretizations that have explicit components, $c$ must be less than a
-# constant that depends on the details of the time discretization and that is
-# no larger than one. On the other hand, for implicit discretizations such as
-# the one chosen here, one can choose the time step as large as one wants (in
-# particular, one can choose $c>1$) though a CFL number significantly larger
-# than one will yield rather diffusive solutions. Units: None.
-set CFL number                             = 1.0
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0.0001
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# The name of the directory into which all output files should be placed. This
-# may be an absolute or a relative path.
-set Output directory                       = output
-
-# A flag indicating whether the computation should be resumed from a
-# previously saved state (if true) or start from scratch (if false).
-set Resume computation                     = false
-
-# The start time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set Start time                             = 0
-
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Adiabatic surface temperature          = 0
-
-# The mathematical equations that describe thermal convection only determine
-# the pressure up to an arbitrary constant. On the other hand, for comparison
-# and for looking up material parameters it is important that the pressure be
-# normalized somehow. We do this by enforcing a particular average pressure
-# value at the surface of the domain, where the geometry model determines
-# where the surface is. This parameter describes what this average surface
-# pressure value is supposed to be. By default, it is set to zero, but one may
-# want to choose a different value for example for simulating only the volume
-# of the mantle below the lithosphere, in which case the surface pressure
-# should be the lithostatic pressure at the bottom of the lithosphere.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Surface pressure                       = 0
-
-# When computing results for mantle convection simulations, it is often
-# difficult to judge the order of magnitude of results when they are stated in
-# MKS units involving seconds. Rather, some kinds of results such as
-# velocities are often stated in terms of meters per year (or, sometimes,
-# centimeters per year). On the other hand, for non-dimensional computations,
-# one wants results in their natural unit system as used inside the code. If
-# this flag is set to 'true' conversion to years happens; if it is 'false', no
-# such conversion happens.
-set Use years in output instead of seconds = false
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=0.0, gamma=1.0
-    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation        = incompressible
-  set Temperature equation     = reference density profile
-end
-
-subsection Boundary temperature model
-  set List of model names = Tan Gurnis
-
-  # A comma separated list of integers denoting those boundaries on which the
-  # temperature is fixed and described by the boundary temperature object
-  # selected in its own section of this input file. All boundary indicators
-  # used by the geometry but not explicitly listed here will end up with
-  # no-flux (insulating) boundary conditions.
-  set Fixed temperature boundary indicators   = left, right, bottom, top
-end
-
-subsection Discretization
-  # The polynomial degree to use for the velocity variables in the Stokes
-  # system. Units: None.
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-
-  # Whether to use a Stokes discretization that is locally conservative at the
-  # expense of a larger number of degrees of freedom (true), or to go with a
-  # cheaper discretization that does not locally conserve mass, although it is
-  # globally conservative (false).
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    # Extent of the box in x-direction. Units: \\si{\\meter}.
-    set X extent = 1
-
-    # Extent of the box in y-direction. Units: \\si{\\meter}.
-    set Y extent = 1
-
-    # Extent of the box in z-direction. This value is ignored if the
-    # simulation is in 2d Units: \\si{\\meter}.
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*y)*cos(pi*1*x)
-  end
-end
-
-subsection Material model
-  set Model name = Tan Gurnis
-
-  subsection Tan Gurnis model
-    set Di                            = 0
-    set gamma                         = 1 # infinity really, but does not matter
-    set a                             = 0
-    set wavenumber                    = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-
-  # The method used to determine which cells to refine and which to coarsen.
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 100
-end
-
-subsection Boundary velocity model
-  # A comma separated list of integers denoting those boundaries on which the
-  # velocity is tangential and unrestrained, i.e., where no external forces
-  # act to prescribe a particular tangential velocity (although there is a
-  # force that requires the flow to be tangential).
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  # A comma separated list of postprocessor objects that should be run at the
-  # end of each time step. Some of these postprocessors will declare their own
-  # parameters which may, for example, include that they will actually do
-  # something only every so many time steps or years. Alternatively, the text
-  # 'all' indicates that all available postprocessors should be run after each
-  # time step.
-  #
-  # The following postprocessors are available:
-  #
-  # `depth average': A postprocessor that computes depth averaged quantities
-  # and writes them out.
-  #
-  # `heat flux statistics': A postprocessor that computes some statistics
-  # about the heat flux across boundaries.
-  #
-  # `heat flux statistics for the table model': A postprocessor that computes
-  # some statistics about the heat flux across boundaries.
-  #
-  # `velocity statistics for the table model': A postprocessor that computes
-  # some statistics about the velocity field.
-  #
-  # `temperature statistics': A postprocessor that computes some statistics
-  # about the temperature field.
-  #
-  # `velocity statistics': A postprocessor that computes some statistics about
-  # the velocity field.
-  #
-  # `visualization': A postprocessor that takes the solution and writes it
-  # into files that can be read by a graphical visualization program.
-  # Additional run time parameters are read from the parameter subsection
-  # 'Visualization'.
-  set List of postprocessors = Tan Gurnis error, visualization
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/tangurnis_tala.cc.bak b/tests/tangurnis_tala.cc.bak
deleted file mode 100644
index 7966a8ab1f8..00000000000
--- a/tests/tangurnis_tala.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "tangurnis.cc"
diff --git a/tests/tangurnis_tala.prm.bak b/tests/tangurnis_tala.prm.bak
deleted file mode 100644
index 7e2a84cd8dd..00000000000
--- a/tests/tangurnis_tala.prm.bak
+++ /dev/null
@@ -1,262 +0,0 @@
-# TanGurnis benchmark TALA
-
-set Additional shared libraries            = ./code/libtangurnis.so
-
-# At the top, state that the program should be run for a two-dimensional
-# simulation
-set Dimension = 2
-
-# In computations, the time step $k$ is chosen according to $k = c \min_K
-# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
-# and the denominator is the maximal magnitude of the velocity on cell $K$
-# times the polynomial degree $p_T$ of the temperature discretization. The
-# dimensionless constant $c$ is called the CFL number in this program. For
-# time discretizations that have explicit components, $c$ must be less than a
-# constant that depends on the details of the time discretization and that is
-# no larger than one. On the other hand, for implicit discretizations such as
-# the one chosen here, one can choose the time step as large as one wants (in
-# particular, one can choose $c>1$) though a CFL number significantly larger
-# than one will yield rather diffusive solutions. Units: None.
-set CFL number                             = 1.0
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0.0001
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# The name of the directory into which all output files should be placed. This
-# may be an absolute or a relative path.
-set Output directory                       = output_tala
-
-# A flag indicating whether the computation should be resumed from a
-# previously saved state (if true) or start from scratch (if false).
-set Resume computation                     = false
-
-# The start time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set Start time                             = 0
-
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Adiabatic surface temperature          = 0
-
-# The mathematical equations that describe thermal convection only determine
-# the pressure up to an arbitrary constant. On the other hand, for comparison
-# and for looking up material parameters it is important that the pressure be
-# normalized somehow. We do this by enforcing a particular average pressure
-# value at the surface of the domain, where the geometry model determines
-# where the surface is. This parameter describes what this average surface
-# pressure value is supposed to be. By default, it is set to zero, but one may
-# want to choose a different value for example for simulating only the volume
-# of the mantle below the lithosphere, in which case the surface pressure
-# should be the lithostatic pressure at the bottom of the lithosphere.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Surface pressure                       = 0
-
-# When computing results for mantle convection simulations, it is often
-# difficult to judge the order of magnitude of results when they are stated in
-# MKS units involving seconds. Rather, some kinds of results such as
-# velocities are often stated in terms of meters per year (or, sometimes,
-# centimeters per year). On the other hand, for non-dimensional computations,
-# one wants results in their natural unit system as used inside the code. If
-# this flag is set to 'true' conversion to years happens; if it is 'false', no
-# such conversion happens.
-set Use years in output instead of seconds = false
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=0.5, gamma=1.0
-    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation        = reference density profile
-  set Temperature equation     = reference density profile
-end
-
-subsection Boundary temperature model
-  set List of model names = Tan Gurnis
-
-  # A comma separated list of integers denoting those boundaries on which the
-  # temperature is fixed and described by the boundary temperature object
-  # selected in its own section of this input file. All boundary indicators
-  # used by the geometry but not explicitly listed here will end up with
-  # no-flux (insulating) boundary conditions.
-  set Fixed temperature boundary indicators   = left, right, bottom, top
-end
-
-subsection Discretization
-  # The polynomial degree to use for the velocity variables in the Stokes
-  # system. Units: None.
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-
-  # Whether to use a Stokes discretization that is locally conservative at the
-  # expense of a larger number of degrees of freedom (true), or to go with a
-  # cheaper discretization that does not locally conserve mass, although it is
-  # globally conservative (false).
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    # Extent of the box in x-direction. Units: \\si{\\meter}.
-    set X extent = 1
-
-    # Extent of the box in y-direction. Units: \\si{\\meter}.
-    set Y extent = 1
-
-    # Extent of the box in z-direction. This value is ignored if the
-    # simulation is in 2d Units: \\si{\\meter}.
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*y)*cos(pi*1*x)
-  end
-end
-
-subsection Material model
-  set Model name = Tan Gurnis
-
-  subsection Tan Gurnis model
-    set Di                            = 0.5
-    set gamma                         = 1
-    set a                             = 0
-    set wavenumber                    = 1
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-
-  # The method used to determine which cells to refine and which to coarsen.
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 100
-end
-
-subsection Boundary velocity model
-  # A comma separated list of integers denoting those boundaries on which the
-  # velocity is tangential and unrestrained, i.e., where no external forces
-  # act to prescribe a particular tangential velocity (although there is a
-  # force that requires the flow to be tangential).
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  # A comma separated list of postprocessor objects that should be run at the
-  # end of each time step. Some of these postprocessors will declare their own
-  # parameters which may, for example, include that they will actually do
-  # something only every so many time steps or years. Alternatively, the text
-  # 'all' indicates that all available postprocessors should be run after each
-  # time step.
-  #
-  # The following postprocessors are available:
-  #
-  # `depth average': A postprocessor that computes depth averaged quantities
-  # and writes them out.
-  #
-  # `heat flux statistics': A postprocessor that computes some statistics
-  # about the heat flux across boundaries.
-  #
-  # `heat flux statistics for the table model': A postprocessor that computes
-  # some statistics about the heat flux across boundaries.
-  #
-  # `velocity statistics for the table model': A postprocessor that computes
-  # some statistics about the velocity field.
-  #
-  # `temperature statistics': A postprocessor that computes some statistics
-  # about the temperature field.
-  #
-  # `velocity statistics': A postprocessor that computes some statistics about
-  # the velocity field.
-  #
-  # `visualization': A postprocessor that takes the solution and writes it
-  # into files that can be read by a graphical visualization program.
-  # Additional run time parameters are read from the parameter subsection
-  # 'Visualization'.
-  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, adiabat
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/tangurnis_tala_c.cc.bak b/tests/tangurnis_tala_c.cc.bak
deleted file mode 100644
index 7966a8ab1f8..00000000000
--- a/tests/tangurnis_tala_c.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "tangurnis.cc"
diff --git a/tests/tangurnis_tala_c.prm.bak b/tests/tangurnis_tala_c.prm.bak
deleted file mode 100644
index 0614afabf96..00000000000
--- a/tests/tangurnis_tala_c.prm.bak
+++ /dev/null
@@ -1,262 +0,0 @@
-# TanGurnis benchmark TALA benchmark with a=2
-
-set Additional shared libraries            = ./code/libtangurnis.so
-
-# At the top, state that the program should be run for a two-dimensional
-# simulation
-set Dimension = 2
-
-# In computations, the time step $k$ is chosen according to $k = c \min_K
-# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
-# and the denominator is the maximal magnitude of the velocity on cell $K$
-# times the polynomial degree $p_T$ of the temperature discretization. The
-# dimensionless constant $c$ is called the CFL number in this program. For
-# time discretizations that have explicit components, $c$ must be less than a
-# constant that depends on the details of the time discretization and that is
-# no larger than one. On the other hand, for implicit discretizations such as
-# the one chosen here, one can choose the time step as large as one wants (in
-# particular, one can choose $c>1$) though a CFL number significantly larger
-# than one will yield rather diffusive solutions. Units: None.
-set CFL number                             = 1.0
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0.0001
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# The name of the directory into which all output files should be placed. This
-# may be an absolute or a relative path.
-set Output directory                       = output
-
-# A flag indicating whether the computation should be resumed from a
-# previously saved state (if true) or start from scratch (if false).
-set Resume computation                     = false
-
-# The start time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set Start time                             = 0
-
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Adiabatic surface temperature          = 0
-
-# The mathematical equations that describe thermal convection only determine
-# the pressure up to an arbitrary constant. On the other hand, for comparison
-# and for looking up material parameters it is important that the pressure be
-# normalized somehow. We do this by enforcing a particular average pressure
-# value at the surface of the domain, where the geometry model determines
-# where the surface is. This parameter describes what this average surface
-# pressure value is supposed to be. By default, it is set to zero, but one may
-# want to choose a different value for example for simulating only the volume
-# of the mantle below the lithosphere, in which case the surface pressure
-# should be the lithostatic pressure at the bottom of the lithosphere.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Surface pressure                       = 0
-
-# When computing results for mantle convection simulations, it is often
-# difficult to judge the order of magnitude of results when they are stated in
-# MKS units involving seconds. Rather, some kinds of results such as
-# velocities are often stated in terms of meters per year (or, sometimes,
-# centimeters per year). On the other hand, for non-dimensional computations,
-# one wants results in their natural unit system as used inside the code. If
-# this flag is set to 'true' conversion to years happens; if it is 'false', no
-# such conversion happens.
-set Use years in output instead of seconds = false
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=0.5, gamma=1.0
-    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation        = reference density profile
-  set Temperature equation     = reference density profile
-end
-
-subsection Boundary temperature model
-  set List of model names = Tan Gurnis
-
-  # A comma separated list of integers denoting those boundaries on which the
-  # temperature is fixed and described by the boundary temperature object
-  # selected in its own section of this input file. All boundary indicators
-  # used by the geometry but not explicitly listed here will end up with
-  # no-flux (insulating) boundary conditions.
-  set Fixed temperature boundary indicators   = left, right, bottom, top
-end
-
-subsection Discretization
-  # The polynomial degree to use for the velocity variables in the Stokes
-  # system. Units: None.
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-
-  # Whether to use a Stokes discretization that is locally conservative at the
-  # expense of a larger number of degrees of freedom (true), or to go with a
-  # cheaper discretization that does not locally conserve mass, although it is
-  # globally conservative (false).
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    # Extent of the box in x-direction. Units: \\si{\\meter}.
-    set X extent = 1
-
-    # Extent of the box in y-direction. Units: \\si{\\meter}.
-    set Y extent = 1
-
-    # Extent of the box in z-direction. This value is ignored if the
-    # simulation is in 2d Units: \\si{\\meter}.
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*y)*cos(pi*1*x)
-  end
-end
-
-subsection Material model
-  set Model name = Tan Gurnis
-
-  subsection Tan Gurnis model
-    set Di                            = 0.5
-    set gamma                         = 1
-    set a                             = 2
-    set wavenumber                    = 1
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-
-  # The method used to determine which cells to refine and which to coarsen.
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 100
-end
-
-subsection Boundary velocity model
-  # A comma separated list of integers denoting those boundaries on which the
-  # velocity is tangential and unrestrained, i.e., where no external forces
-  # act to prescribe a particular tangential velocity (although there is a
-  # force that requires the flow to be tangential).
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  # A comma separated list of postprocessor objects that should be run at the
-  # end of each time step. Some of these postprocessors will declare their own
-  # parameters which may, for example, include that they will actually do
-  # something only every so many time steps or years. Alternatively, the text
-  # 'all' indicates that all available postprocessors should be run after each
-  # time step.
-  #
-  # The following postprocessors are available:
-  #
-  # `depth average': A postprocessor that computes depth averaged quantities
-  # and writes them out.
-  #
-  # `heat flux statistics': A postprocessor that computes some statistics
-  # about the heat flux across boundaries.
-  #
-  # `heat flux statistics for the table model': A postprocessor that computes
-  # some statistics about the heat flux across boundaries.
-  #
-  # `velocity statistics for the table model': A postprocessor that computes
-  # some statistics about the velocity field.
-  #
-  # `temperature statistics': A postprocessor that computes some statistics
-  # about the temperature field.
-  #
-  # `velocity statistics': A postprocessor that computes some statistics about
-  # the velocity field.
-  #
-  # `visualization': A postprocessor that takes the solution and writes it
-  # into files that can be read by a graphical visualization program.
-  # Additional run time parameters are read from the parameter subsection
-  # 'Visualization'.
-  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, adiabat
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-  end
-end
diff --git a/tests/tangurnis_tala_gmg.cc.bak b/tests/tangurnis_tala_gmg.cc.bak
deleted file mode 100644
index 7966a8ab1f8..00000000000
--- a/tests/tangurnis_tala_gmg.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "tangurnis.cc"
diff --git a/tests/tangurnis_tala_gmg.prm.bak b/tests/tangurnis_tala_gmg.prm.bak
deleted file mode 100644
index e53df20f5ea..00000000000
--- a/tests/tangurnis_tala_gmg.prm.bak
+++ /dev/null
@@ -1,19 +0,0 @@
-# TanGurnis benchmark TALA using geometric multigrid preconditioner
-
-include $ASPECT_SOURCE_DIR/benchmarks/tangurnis/tala/tan.prm
-
-
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
diff --git a/tests/tangurnis_tala_implicit.cc.bak b/tests/tangurnis_tala_implicit.cc.bak
deleted file mode 100644
index 7966a8ab1f8..00000000000
--- a/tests/tangurnis_tala_implicit.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "tangurnis.cc"
diff --git a/tests/tangurnis_tala_implicit.prm.bak b/tests/tangurnis_tala_implicit.prm.bak
deleted file mode 100644
index 8e7086c7949..00000000000
--- a/tests/tangurnis_tala_implicit.prm.bak
+++ /dev/null
@@ -1,265 +0,0 @@
-# TanGurnis benchmark TALA, like tangurnis_tala.prm but using the implicit
-# mass formulation leading to a single newton step
-
-set Additional shared libraries            = ./code/libtangurnis.so
-
-# At the top, state that the program should be run for a two-dimensional
-# simulation
-set Dimension = 2
-
-# In computations, the time step $k$ is chosen according to $k = c \min_K
-# \frac{h_K}{\|u\|_{\infty,K} p_T}$ where $h_K$ is the diameter of cell $K$,
-# and the denominator is the maximal magnitude of the velocity on cell $K$
-# times the polynomial degree $p_T$ of the temperature discretization. The
-# dimensionless constant $c$ is called the CFL number in this program. For
-# time discretizations that have explicit components, $c$ must be less than a
-# constant that depends on the details of the time discretization and that is
-# no larger than one. On the other hand, for implicit discretizations such as
-# the one chosen here, one can choose the time step as large as one wants (in
-# particular, one can choose $c>1$) though a CFL number significantly larger
-# than one will yield rather diffusive solutions. Units: None.
-set CFL number                             = 1.0
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 0.0001
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-# The name of the directory into which all output files should be placed. This
-# may be an absolute or a relative path.
-set Output directory                       = output_tala
-
-# A flag indicating whether the computation should be resumed from a
-# previously saved state (if true) or start from scratch (if false).
-set Resume computation                     = false
-
-# The start time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set Start time                             = 0
-
-# In order to make the problem in the first time step easier to solve, we need
-# a reasonable guess for the temperature and pressure. To obtain it, we use an
-# adiabatic pressure and temperature field. This parameter describes what the
-# `adiabatic' temperature would be at the surface of the domain (i.e. at depth
-# zero). Note that this value need not coincide with the boundary condition
-# posed at this point. Rather, the boundary condition may differ significantly
-# from the adiabatic value, and then typically induce a thermal boundary
-# layer.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Adiabatic surface temperature          = 0
-
-# The mathematical equations that describe thermal convection only determine
-# the pressure up to an arbitrary constant. On the other hand, for comparison
-# and for looking up material parameters it is important that the pressure be
-# normalized somehow. We do this by enforcing a particular average pressure
-# value at the surface of the domain, where the geometry model determines
-# where the surface is. This parameter describes what this average surface
-# pressure value is supposed to be. By default, it is set to zero, but one may
-# want to choose a different value for example for simulating only the volume
-# of the mantle below the lithosphere, in which case the surface pressure
-# should be the lithostatic pressure at the bottom of the lithosphere.
-# For more information, see the section in the manual that discusses the
-# general mathematical model.
-set Surface pressure                       = 0
-
-# When computing results for mantle convection simulations, it is often
-# difficult to judge the order of magnitude of results when they are stated in
-# MKS units involving seconds. Rather, some kinds of results such as
-# velocities are often stated in terms of meters per year (or, sometimes,
-# centimeters per year). On the other hand, for non-dimensional computations,
-# one wants results in their natural unit system as used inside the code. If
-# this flag is set to 'true' conversion to years happens; if it is 'false', no
-# such conversion happens.
-set Use years in output instead of seconds = false
-
-subsection Adiabatic conditions model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = Di=0.5, gamma=1.0
-    set Function expression = 0;0;exp(Di/gamma*depth)  # T,p,rho
-    set Variable names      = depth
-  end
-end
-
-subsection Formulation
-  set Formulation = custom
-  set Mass conservation        = implicit reference density profile
-  set Temperature equation     = reference density profile
-end
-
-subsection Boundary temperature model
-  set List of model names = Tan Gurnis
-
-  # A comma separated list of integers denoting those boundaries on which the
-  # temperature is fixed and described by the boundary temperature object
-  # selected in its own section of this input file. All boundary indicators
-  # used by the geometry but not explicitly listed here will end up with
-  # no-flux (insulating) boundary conditions.
-  set Fixed temperature boundary indicators   = left, right, bottom, top
-end
-
-subsection Discretization
-  # The polynomial degree to use for the velocity variables in the Stokes
-  # system. Units: None.
-  set Stokes velocity polynomial degree       = 2
-
-  # The polynomial degree to use for the temperature variable. Units: None.
-  set Temperature polynomial degree           = 2
-
-  # Whether to use a Stokes discretization that is locally conservative at the
-  # expense of a larger number of degrees of freedom (true), or to go with a
-  # cheaper discretization that does not locally conserve mass, although it is
-  # globally conservative (false).
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    # The exponent $\alpha$ in the entropy viscosity stabilization. Units:
-    # None.
-    set alpha = 2
-
-    # The $\beta$ factor in the artificial viscosity stabilization. An
-    # appropriate value for 2d is 0.052 and 0.078 for 3d. Units: None.
-    set beta  = 0.078
-
-    # The $c_R$ factor in the entropy viscosity stabilization. Units: None.
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    # Extent of the box in x-direction. Units: \\si{\\meter}.
-    set X extent = 1
-
-    # Extent of the box in y-direction. Units: \\si{\\meter}.
-    set Y extent = 1
-
-    # Extent of the box in z-direction. This value is ignored if the
-    # simulation is in 2d Units: \\si{\\meter}.
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = sin(pi*y)*cos(pi*1*x)
-  end
-end
-
-subsection Material model
-  set Model name = Tan Gurnis
-  set Material averaging = none
-
-  subsection Tan Gurnis model
-    set Di                            = 0.5
-    set gamma                         = 1
-    set a                             = 0
-    set wavenumber                    = 1
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-
-  # The method used to determine which cells to refine and which to coarsen.
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 100
-end
-
-subsection Boundary velocity model
-  # A comma separated list of integers denoting those boundaries on which the
-  # velocity is tangential and unrestrained, i.e., where no external forces
-  # act to prescribe a particular tangential velocity (although there is a
-  # force that requires the flow to be tangential).
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Postprocess
-  # A comma separated list of postprocessor objects that should be run at the
-  # end of each time step. Some of these postprocessors will declare their own
-  # parameters which may, for example, include that they will actually do
-  # something only every so many time steps or years. Alternatively, the text
-  # 'all' indicates that all available postprocessors should be run after each
-  # time step.
-  #
-  # The following postprocessors are available:
-  #
-  # `depth average': A postprocessor that computes depth averaged quantities
-  # and writes them out.
-  #
-  # `heat flux statistics': A postprocessor that computes some statistics
-  # about the heat flux across boundaries.
-  #
-  # `heat flux statistics for the table model': A postprocessor that computes
-  # some statistics about the heat flux across boundaries.
-  #
-  # `velocity statistics for the table model': A postprocessor that computes
-  # some statistics about the velocity field.
-  #
-  # `temperature statistics': A postprocessor that computes some statistics
-  # about the temperature field.
-  #
-  # `velocity statistics': A postprocessor that computes some statistics about
-  # the velocity field.
-  #
-  # `visualization': A postprocessor that takes the solution and writes it
-  # into files that can be read by a graphical visualization program.
-  # Additional run time parameters are read from the parameter subsection
-  # 'Visualization'.
-  set List of postprocessors = Tan Gurnis error, visualization, heating statistics
-
-  subsection Depth average
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, adiabat
-
-    # VTU file output supports grouping files from several CPUs into one file
-    # using MPI I/O when writing on a parallel filesystem. Select 0 for no
-    # grouping. This will disable parallel file output and instead write one
-    # file per processor in a background thread. A value of 1 will generate
-    # one big file containing the whole solution.
-    set Number of grouped files       = 0
-
-    # The file format to be used for graphical output.
-    set Output format                 = vtu
-
-    # The time interval between each generation of graphical output files. A
-    # value of zero indicates that output should be generated in each time
-    # step. Units: years if the 'Use years in output instead of seconds'
-    # parameter is set; seconds otherwise.
-    set Time between graphical output = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = false
-    set Stokes solver type = block AMG
-  end
-end
diff --git a/tests/temperature_dependent_stokes_matrix.prm.bak b/tests/temperature_dependent_stokes_matrix.prm.bak
deleted file mode 100644
index a88d77568ed..00000000000
--- a/tests/temperature_dependent_stokes_matrix.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# We used to have the problem that if the viscosity
-# depended on the temperature, we would still not want
-# to re-compute the Stokes matrix. This was a clear bug.
-# This test verifies that this is now fixed by creating
-# a temperature-dependent viscosity and using it to run
-# a model that has several time steps. The velocities we
-# get need to be the ones that come from the re-computed
-# Stokes matrix, and they have different RMS values.
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e6
-set Start time                             = 0
-set Adiabatic surface temperature          = 1.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-
-    # This is the point of this test:
-    set Thermal viscosity exponent = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity
-  end
-end
diff --git a/tests/terminate_user_request.cc.bak b/tests/terminate_user_request.cc.bak
deleted file mode 100644
index 7186bafb99f..00000000000
--- a/tests/terminate_user_request.cc.bak
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <stdlib.h>
-
-// Create a function that is run upon loading the plugin. We delete the
-// restart.mesh file that is used as a trigger for terminating
-// ASPECT. Otherwise we might have a left over file that triggers termination
-// immediately.
-int f()
-{
-  system ("rm -f output-terminate_user_request/restart.mesh");
-  return 42;
-}
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/terminate_user_request.prm.bak b/tests/terminate_user_request.prm.bak
deleted file mode 100644
index a761cbf58ca..00000000000
--- a/tests/terminate_user_request.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# a test that verifies that we indeed terminate when a particular file was
-# found in the output directory. the file name we choose is that of a
-# checkpointing file that we write at the end of time step 5, so that we
-# terminate after time step 6
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e7
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = user request
-
-  subsection User request
-    set File name = restart.mesh
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 5
-end
diff --git a/tests/thermal_alpha_s40rts.prm.bak b/tests/thermal_alpha_s40rts.prm.bak
deleted file mode 100644
index 7568693c500..00000000000
--- a/tests/thermal_alpha_s40rts.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# Test for S40RTS initial condition using thermal expansion from the material model
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1600
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity                     = 1e22
-    set Thermal viscosity exponent    = 5.0
-    set Reference temperature         = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = 0,1
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 2600
-    set Outer temperature = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = S40RTS perturbation
-
-  subsection S40RTS perturbation
-    set Use thermal expansion coefficient from material model = true
-    set Thermal expansion coefficient in initial temperature scaling = 1 # large value since this shouldn't be used
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics
-end
diff --git a/tests/tian_MORB.prm.bak b/tests/tian_MORB.prm.bak
deleted file mode 100644
index 4b0706a9f3e..00000000000
--- a/tests/tian_MORB.prm.bak
+++ /dev/null
@@ -1,27 +0,0 @@
-# This model generates a representation of a phase diagram for the equilibrium
-# wt% water that can be stored in a MORB as shown in Figure 5 of Tian et. al., 2019.
-# This model reproduces that phase diagram (very low res by default), with an important
-# caveat being that the pressure axis is inverted relative to the ASPECT output.
-# A surface pressure of 600 MPa is imposed to reproduce the pressure axis,
-# and a lateral temperature gradient is imposed to reproduce the temperature axis.
-include $ASPECT_SOURCE_DIR/tests/tian_peridotite.prm
-
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = initial_porosity; \
-                              initial_bound_water; \
-                              0; \
-                              0; \
-                              1; \
-                              0
-  end
-end
-
-subsection Material model
-  subsection Reactive Fluid Transport Model
-    set Maximum weight percent water in MORB                    = 5.3
-  end
-end
diff --git a/tests/tian_gabbro.prm.bak b/tests/tian_gabbro.prm.bak
deleted file mode 100644
index b96ed026bf8..00000000000
--- a/tests/tian_gabbro.prm.bak
+++ /dev/null
@@ -1,27 +0,0 @@
-# This model generates a representation of a phase diagram for the equilibrium
-# wt% water that can be stored in a gabbro as shown in Figure 2 of Tian et. al., 2019.
-# This model reproduces that phase diagram (very low res by default), with an important
-# caveat being that the pressure axis is inverted relative to the ASPECT output.
-# A surface pressure of 600 MPa is imposed to reproduce the pressure axis,
-# and a lateral temperature gradient is imposed to reproduce the temperature axis.
-include $ASPECT_SOURCE_DIR/tests/tian_peridotite.prm
-
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = initial_porosity; \
-                              initial_bound_water; \
-                              0; \
-                              1; \
-                              0; \
-                              0
-  end
-end
-
-subsection Material model
-  subsection Reactive Fluid Transport Model
-    set Maximum weight percent water in gabbro                    = 5.1
-  end
-end
diff --git a/tests/tian_peridotite.prm.bak b/tests/tian_peridotite.prm.bak
deleted file mode 100644
index df0f6571a49..00000000000
--- a/tests/tian_peridotite.prm.bak
+++ /dev/null
@@ -1,122 +0,0 @@
-# This model generates a representation of a phase diagram for the equilibrium
-# wt% water that can be stored in an upper mantle peridotite (PUM) as shown in
-# Figure 11 of  Tian et. al., 2019. This model reproduces that phase diagram
-# (very low res by default), with an important caveat being that the pressure axis
-# is inverted relative to the ASPECT output. A surface pressure of 600 MPa is imposed
-# to reproduce the pressure axis,and a lateral temperature gradient is imposed to
-# reproduce the temperature axis.
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 10
-set Nonlinear solver tolerance             = 1e-5
-set Surface pressure                       = 0.6e9
-set Dimension                              = 2
-set End time                               = 1e3
-set Maximum time step                      = 1e3
-set Use operator splitting                 = true
-
-# The Tian approximation implementation requires that all 4 rock compositions exist
-# as compositional fields, though they do not have to all be non zero.
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields = porosity, bound_fluid, peridotite, gabbro, MORB, sediment
-end
-
-# Specify that the entire domain is peridotite, with an initial bound water content
-# of 11% everywhere, the bound_water will evolve to the parametrized phase diagram
-# for peridotite.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = initial_porosity=0.0, initial_bound_water=0.11
-    set Function expression = initial_porosity; \
-                              initial_bound_water; \
-                              1; \
-                              0; \
-                              0; \
-                              0
-  end
-end
-
-# Zero velocity boundaries
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = left, right, top, bottom
-end
-
-# Make the model 200km x 200km so that the Pressure extends to 6 GPa,
-# as in phase diagrams from Tian et al., 2019
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 200e3
-    set Y extent  = 200e3
-    set Y repetitions = 1
-    set X repetitions = 1
-  end
-end
-
-# 10 m/s^2 vertical gravity
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Lateral temperature gradient from 300 - 1000 C, as in
-# phase diagrams from Tian et al., 2019
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system   = cartesian
-    set Variable names      = x,y
-    set Function constants  = Tmin=573, Tmax=1273
-    set Function expression = Tmin + (Tmax - Tmin) * x/200e3
-  end
-end
-
-# Keep the temperature fixed
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom, right, left
-  set List of model names = initial temperature
-
-  subsection Initial temperature
-    set Maximal temperature = 573
-    set Minimal temperature = 1273
-  end
-end
-
-# Material model, using the simpler base model and selecting the tian approximation
-# as the fluid solid reaction scheme for the reactive fluid transport model.
-subsection Material model
-  set Model name = reactive fluid transport
-
-  subsection Reactive Fluid Transport Model
-    set Base model                                       = simpler
-    set Reference fluid density                          = 3000
-    set Fluid reaction time scale for operator splitting = 1e2
-    set Fluid-solid reaction scheme                      = tian approximation
-    set Maximum weight percent water in peridotite       = 11
-  end
-
-  subsection Simpler model
-    set Reference density             = 3000.0
-    set Thermal expansion coefficient = 1e-5
-  end
-end
-
-subsection Melt settings
-  set Include melt transport = true
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 2
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
diff --git a/tests/tian_sediment.prm.bak b/tests/tian_sediment.prm.bak
deleted file mode 100644
index 9e2f6973ba7..00000000000
--- a/tests/tian_sediment.prm.bak
+++ /dev/null
@@ -1,27 +0,0 @@
-# This model generates a representation of a phase diagram for the equilibrium
-# wt% water that can be stored in a sediment as shown in Figure 8 of Tian et. al., 2019.
-# This model reproduces that phase diagram (very low res by default), with an important
-# caveat being that the pressure axis is inverted relative to the ASPECT output.
-# A surface pressure of 600 MPa is imposed to reproduce the pressure axis,
-# and a lateral temperature gradient is imposed to reproduce the temperature axis.
-include $ASPECT_SOURCE_DIR/tests/tian_peridotite.prm
-
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = initial_porosity; \
-                              initial_bound_water; \
-                              0; \
-                              0; \
-                              0; \
-                              1
-  end
-end
-
-subsection Material model
-  subsection Reactive Fluid Transport Model
-    set Maximum weight percent water in sediment                 = 3.2
-  end
-end
diff --git a/tests/time_dependent_annulus.cc.bak b/tests/time_dependent_annulus.cc.bak
deleted file mode 100644
index d763f64cea7..00000000000
--- a/tests/time_dependent_annulus.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/time_dependent_annulus/plugin/time_dependent_annulus.cc"
diff --git a/tests/time_dependent_annulus.prm.bak b/tests/time_dependent_annulus.prm.bak
deleted file mode 100644
index 34f4829f94d..00000000000
--- a/tests/time_dependent_annulus.prm.bak
+++ /dev/null
@@ -1,10 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/benchmarks/time_dependent_annulus/time_dependent_annulus.prm
-
-set End time = 0.003
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 1
-end
diff --git a/tests/time_dependent_temperature_bc.cc.bak b/tests/time_dependent_temperature_bc.cc.bak
deleted file mode 100644
index 0d4ed45e8ac..00000000000
--- a/tests/time_dependent_temperature_bc.cc.bak
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
-  Copyright (C) 2011 - 2020 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef __aspect__boundary_temperature_time_dep_box_h
-#define __aspect__boundary_temperature_time_dep_box_h
-
-#include <aspect/boundary_temperature/interface.h>
-#include <aspect/simulator_access.h>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    /**
-     * A class that implements a temperature boundary condition for a time_dep_box
-     * geometry.
-     *
-     * @ingroup BoundaryTemperatures
-     */
-    template <int dim>
-    class Time_Dep_Box : public Interface<dim>, public SimulatorAccess<dim>
-    {
-      public:
-        /**
-         * This plugin prescribes time dependent temperatures for all boundaries.
-         *
-         * @copydoc aspect::BoundaryTemperature::Interface::boundary_temperature()
-         */
-        virtual
-        double boundary_temperature (const types::boundary_id boundary_indicator,
-                                     const Point<dim> &position) const;
-
-        /**
-         * Return the minimal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        virtual
-        double minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const;
-
-        /**
-         * Return the maximal the temperature on that part of the boundary on
-         * which Dirichlet conditions are posed.
-         *
-         * This value is used in computing dimensionless numbers such as the
-         * Nusselt number indicating heat flux.
-         */
-        virtual
-        double maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const;
-
-        /**
-         * Declare the parameters this class takes through input files. This
-         * class declares the inner and outer boundary temperatures.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-
-      private:
-        double temperature_[2*dim];
-    };
-  }
-}
-
-
-#endif
-
-#include <utility>
-#include <limits>
-#include <aspect/geometry_model/box.h>
-
-
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-// ------------------------------ Time_Dep_Box -------------------
-
-    template <int dim>
-    double
-    Time_Dep_Box<dim>::
-    boundary_temperature (const types::boundary_id boundary_indicator,
-                          const Point<dim> &position) const
-    {
-      // verify that the geometry is a time_dep_box since only
-      // for this geometry do we know for sure what boundary indicators it
-      // uses and what they mean
-      Assert (dynamic_cast<const GeometryModel::Box<dim>*>(&this->get_geometry_model())
-              != 0,
-              ExcMessage ("This boundary model is only implemented if the geometry is "
-                          "a time_dep_box."));
-
-      Assert (boundary_indicator<2*dim, ExcMessage ("Unknown boundary indicator."));
-      return temperature_[boundary_indicator] * this->get_time();
-    }
-
-
-    template <int dim>
-    double
-    Time_Dep_Box<dim>::
-    minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
-    {
-      if (fixed_boundary_ids.empty())
-        return *std::min_element(temperature_, temperature_+2*dim);
-      else
-        {
-          double min = maximal_temperature(fixed_boundary_ids);
-          for (typename std::set<types::boundary_id>::const_iterator
-               p = fixed_boundary_ids.begin();
-               p != fixed_boundary_ids.end(); ++p)
-            if (p != fixed_boundary_ids.end())
-              min = std::min(min,temperature_[*p]);
-          return min;
-        }
-    }
-
-
-
-    template <int dim>
-    double
-    Time_Dep_Box<dim>::
-    maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const
-    {
-      if (fixed_boundary_ids.empty())
-        return *std::max_element(temperature_, temperature_+2*dim);
-      else
-        {
-          double max = -std::numeric_limits<double>::max();
-          for (typename std::set<types::boundary_id>::const_iterator
-               p = fixed_boundary_ids.begin();
-               p != fixed_boundary_ids.end(); ++p)
-            if (p != fixed_boundary_ids.end())
-              max = std::max(max,temperature_[*p]);
-          return max;
-        }
-    }
-
-    template <int dim>
-    void
-    Time_Dep_Box<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Time_Dep_Box");
-        {
-          prm.declare_entry ("Left temperature", "1",
-                             Patterns::Double (),
-                             "Temperature at the left boundary (at minimal x-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Right temperature", "0",
-                             Patterns::Double (),
-                             "Temperature at the right boundary (at maximal x-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Bottom temperature", "0",
-                             Patterns::Double (),
-                             "Temperature at the bottom boundary (at minimal z-value). Units: \\si{\\kelvin}.");
-          prm.declare_entry ("Top temperature", "0",
-                             Patterns::Double (),
-                             "Temperature at the top boundary (at maximal x-value). Units: \\si{\\kelvin}.");
-          if (dim==3)
-            {
-              prm.declare_entry ("Front temperature", "0",
-                                 Patterns::Double (),
-                                 "Temperature at the front boundary (at minimal y-value). Units: \\si{\\kelvin}.");
-              prm.declare_entry ("Back temperature", "0",
-                                 Patterns::Double (),
-                                 "Temperature at the back boundary (at maximal y-value). Units: \\si{\\kelvin}.");
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-    template <int dim>
-    void
-    Time_Dep_Box<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Boundary temperature model");
-      {
-        prm.enter_subsection("Time_Dep_Box");
-        {
-          switch (dim)
-            {
-              case 2:
-                temperature_[0] = prm.get_double ("Left temperature");
-                temperature_[1] = prm.get_double ("Right temperature");
-                temperature_[2] = prm.get_double ("Bottom temperature");
-                temperature_[3] = prm.get_double ("Top temperature");
-                break;
-
-              case 3:
-                temperature_[0] = prm.get_double ("Left temperature");
-                temperature_[1] = prm.get_double ("Right temperature");
-                temperature_[2] = prm.get_double ("Front temperature");
-                temperature_[3] = prm.get_double ("Back temperature");
-                temperature_[4] = prm.get_double ("Bottom temperature");
-                temperature_[5] = prm.get_double ("Top temperature");
-                break;
-
-              default:
-                Assert (false, ExcNotImplemented());
-            }
-        }
-        prm.leave_subsection ();
-      }
-      prm.leave_subsection ();
-    }
-
-
-  }
-}
-
-// explicit instantiations
-namespace aspect
-{
-  namespace BoundaryTemperature
-  {
-    ASPECT_REGISTER_BOUNDARY_TEMPERATURE_MODEL(Time_Dep_Box,
-                                               "time_dep_box",
-                                               "A model in which the temperature is chosen constant on "
-                                               "all the sides of a time_dep_box.")
-  }
-}
diff --git a/tests/time_dependent_temperature_bc.prm.bak b/tests/time_dependent_temperature_bc.prm.bak
deleted file mode 100644
index 2e4c3431d68..00000000000
--- a/tests/time_dependent_temperature_bc.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# originally taken from diffusion.prm, but intended to test that we can deal
-# with time dependent temperature boundary conditions
-#
-# this is just a preliminary test. we used to crash because we forgot to set
-# the time before we evaluate the temperature boundary conditions for the
-# first time, and plugins providing such boundary conditions consequently
-# had no way to tell the time when evaluated when computing the initial
-# solution
-
-
-set Dimension = 2
-set CFL number                             = 0.01
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = time_dep_box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Time_Dep_Box
-    set Bottom temperature = 0
-    set Top temperature    = 1 # the model interprets this as T(t)=1*t
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Checkpointing
-  set Time between checkpoint                = 0
-  set Steps between checkpoint               = 50
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
diff --git a/tests/time_dependent_temperature_bc_2.cc.bak b/tests/time_dependent_temperature_bc_2.cc.bak
deleted file mode 100644
index ca9a0f67c4c..00000000000
--- a/tests/time_dependent_temperature_bc_2.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "time_dependent_temperature_bc.cc"
diff --git a/tests/time_dependent_temperature_bc_2.prm.bak b/tests/time_dependent_temperature_bc_2.prm.bak
deleted file mode 100644
index c81d3513e3f..00000000000
--- a/tests/time_dependent_temperature_bc_2.prm.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-# originally taken from diffusion.prm, but intended to test that we can deal
-# with time dependent temperature boundary conditions
-#
-# we use a time dependent boundary condition at the top boundary and verify
-# that the temperature at the indeed changes with time as expected
-
-
-set Dimension = 2
-set CFL number                             = 1
-set End time                               = 1
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = time_dep_box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Time_Dep_Box
-    set Bottom temperature = 0
-    set Top temperature    = 1 # the model interprets this as T(t)=1*t
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Checkpointing
-  set Time between checkpoint                = 0
-  set Steps between checkpoint               = 50
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
diff --git a/tests/time_stepping_fail.prm.bak b/tests/time_stepping_fail.prm.bak
deleted file mode 100644
index c1f746bc4d7..00000000000
--- a/tests/time_stepping_fail.prm.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-# test "Time stepping::Function" plugin with a negative time step, based on box_end_time_1e7_terminate.prm
-
-# EXPECT FAILURE
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.5e4
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Time stepping
-  set List of model names = function
-
-  subsection Function
-    set Function expression = if (time<5e2,1e2,-1)
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
diff --git a/tests/time_stepping_function.prm.bak b/tests/time_stepping_function.prm.bak
deleted file mode 100644
index 395168a90c3..00000000000
--- a/tests/time_stepping_function.prm.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-# test "Time stepping::Function" plugin, based on box_end_time_1e7_terminate.prm
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.5e4
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Time stepping
-  set List of model names = function
-
-  subsection Function
-    set Function expression = if (time<5e3,2e2+1e2*cos(2*3.141*time/5e3),3e2+time/1e3)
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
diff --git a/tests/time_stepping_min.prm.bak b/tests/time_stepping_min.prm.bak
deleted file mode 100644
index 8f270500b39..00000000000
--- a/tests/time_stepping_min.prm.bak
+++ /dev/null
@@ -1,66 +0,0 @@
-# test "Time stepping::Function" plugin combined with a minimum step size
-#
-# based on time_stepping_function.prm
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1.5e4
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Time stepping
-  set Minimum time step size = 101
-  set List of model names = function
-
-  subsection Function
-    set Function expression = if (time<5e3,2e2+1e2*cos(2*3.141*time/5e3),3e2+time/1e3)
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
diff --git a/tests/time_stepping_repeat.prm.bak b/tests/time_stepping_repeat.prm.bak
deleted file mode 100644
index bdf8860cc0a..00000000000
--- a/tests/time_stepping_repeat.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# Test TimeStepping plugin "repeat on cutback" by having a change in
-# prescribed surface velocity
-
-set Dimension                              = 2
-set End time                               = 0.755
-set Use years in output instead of seconds = false
-set Maximum relative increase in time step     = 2
-
-subsection Time stepping
-  set List of model names = convection time step, repeat on cutback
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(t<0.75, if(x<0.5,-1,1), 100); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(z<0.2, 1, 0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-7
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1e-5
-
-    #    set Output format                 = gnuplot
-  end
-end
-
-# This is the new part: We declare that there will
-# be two compositional fields with same initial condition
-# and only the first one will be advected along.
-subsection Compositional fields
-  set Number of fields = 0
-
-  #  set Compositional field methods = field,static
-end
-
-subsection Initial composition model
-  #  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y<0.2, 1, 0)
-  end
-end
diff --git a/tests/time_stepping_repeat_particles.prm.bak b/tests/time_stepping_repeat_particles.prm.bak
deleted file mode 100644
index 28934691f49..00000000000
--- a/tests/time_stepping_repeat_particles.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-# Test TimeStepping plugin "repeat on cutback" by having a change in
-# prescribed surface velocity in combination with the advection
-# of particles. There are two compositional fields, one based on
-# the field method and one on the particle method. The initial condition
-# for the fields is the same (idenical to the temperature field).
-# For sufficient mesh and particle resolution,
-# the end result for the two fields should be practically the same.
-
-set Dimension                              = 2
-set End time                               = 0.755
-set Use years in output instead of seconds = false
-set Maximum relative increase in time step     = 2
-
-subsection Time stepping
-  set List of model names = convection time step, repeat on cutback
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-    set X repetitions = 2
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(t<0.75, if(x<0.5,-1,1), 100); 0
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if(z<0.2, 1, 0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity          = 1e-7
-    set Thermal expansion coefficient = 1e-4
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, particles
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1e-1
-    set Output format = gnuplot
-  end
-
-  subsection Particles
-    set Time between data output = 1e-1
-    set Data output format          = gnuplot
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = field, particles
-  set Compositional field methods = field,particles
-  set Mapped particle properties  = particles:initial particles
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(y<0.2, 1, 0) ; if(y<0.2, 1, 0)
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell  = 0
-  set Maximum particles per cell  = 100
-  set Load balancing strategy     = remove and add particles
-  set List of particle properties = initial composition, composition
-  set Update ghost particles      = true
-  set Allow cells without particles = true
-  set Particle generator name = uniform box
-
-  subsection Generator
-    subsection Uniform box
-      set Minimum x = 0.
-      set Maximum x = 2.
-      set Minimum y = 0.
-      set Maximum y = 0.3
-      set Number of particles = 64
-    end
-  end
-end
diff --git a/tests/time_stepping_repeat_particles_iterated_advection.prm.bak b/tests/time_stepping_repeat_particles_iterated_advection.prm.bak
deleted file mode 100644
index 64125a220a5..00000000000
--- a/tests/time_stepping_repeat_particles_iterated_advection.prm.bak
+++ /dev/null
@@ -1,30 +0,0 @@
-# Test TimeStepping plugin "repeat on cutback" by having a change in
-# prescribed surface velocity in combination with the advection
-# of particles. There are two compositional fields, one based on
-# the field method and one on the particle method. The initial condition
-# for the fields is the same (identical to the temperature field).
-# For sufficient mesh and particle resolution,
-# the end result for the two fields should be practically the same.
-# Same as time_stepping_repeat_particles.prm except for the prescribed
-# boundary velocity and the iterative Advection scheme.
-# For this scheme, the particle positions and properties
-# have to be restored before each second or later nonlinear iteration
-# within a timestep. The sudden change in surface velocity is
-# less extreme so that the second temperature nonlinear iteration after
-# the change still converges.
-
-include $ASPECT_SOURCE_DIR/tests/time_stepping_repeat_particles.prm
-
-set Dimension                  = 2
-set Nonlinear solver scheme    = iterated Advection and Stokes
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, left, right
-  set Prescribed velocity boundary indicators = top: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(t<0.75, if(x<0.5,-1,1), if(x<0.5,-15,15)); 0
-  end
-end
diff --git a/tests/tomography_based_plate_motions_cookbook.cc.bak b/tests/tomography_based_plate_motions_cookbook.cc.bak
deleted file mode 100644
index 5c70f768d86..00000000000
--- a/tests/tomography_based_plate_motions_cookbook.cc.bak
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-  Copyright (C) 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../cookbooks/tomography_based_plate_motions/plugins/tomography_based_plate_motions.cc"
-#include "../cookbooks/tomography_based_plate_motions/plugins/reference_profile.cc"
diff --git a/tests/tomography_based_plate_motions_cookbook.prm.bak b/tests/tomography_based_plate_motions_cookbook.prm.bak
deleted file mode 100644
index 25677171d64..00000000000
--- a/tests/tomography_based_plate_motions_cookbook.prm.bak
+++ /dev/null
@@ -1,39 +0,0 @@
-# This is a test for the cookbook described in
-# $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/models
-
-include $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/2D_slice_with_faults_and_cratons.prm
-
-set Additional shared libraries            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/plugins/libtomography_based_plate_motions.release.so
-set World builder file                     = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/world_builder_smac_cratons_faults_2D.json
-set Output directory                       = output
-set Max nonlinear iterations               = 1
-
-subsection Mesh refinement
-  set Initial adaptive refinement = 1
-  set Initial global refinement = 1
-  set Skip solvers on initial refinement = true
-end
-
-subsection Material model
-  set Model name                    = tomography based plate motions
-
-  subsection Tomography based plate motions model
-    subsection Density velocity scaling
-      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
-      set Data file name                            = rho_vs_scaling.txt
-    end
-
-    subsection Temperature velocity scaling
-      set Data directory                            = $ASPECT_SOURCE_DIR/cookbooks/tomography_based_plate_motions/input_data/
-      set Data file name                            = dT_vs_scaling.txt
-    end
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors         = boundary velocity residual statistics, velocity boundary statistics, visualization, heat flux statistics, depth average
-
-  subsection Visualization
-    set Output format                = gnuplot
-  end
-end
diff --git a/tests/topo_box.prm.bak b/tests/topo_box.prm.bak
deleted file mode 100644
index 5533d14d98e..00000000000
--- a/tests/topo_box.prm.bak
+++ /dev/null
@@ -1,119 +0,0 @@
-#Test topography postprocessor with box geometry
-set Output directory                       = topo_box
-set CFL number                             = 0.5
-set Dimension                              = 2
-set End time                               = 1e+7
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Nonlinear solver tolerance             = 1e-6
-set Pressure normalization                 = no
-set Resume computation                     = false
-set Start time                             = 0
-set Timing output frequency                = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators = top
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom
-  set Prescribed velocity boundary indicators = left: function, right:function
-
-  subsection Function
-    set Function constants  = cm=0.01, year=3.155e7, pi=3.141593, angle=60, total_depth=512e3, crustal_depth=30e3, lithospheric_depth=120e3
-    set Function expression = if (x<50e3, if (z > total_depth-lithospheric_depth, 1*cm, -(lithospheric_depth/(total_depth-lithospheric_depth))*cm), if (z > total_depth-lithospheric_depth, -1*cm, (lithospheric_depth/(total_depth-lithospheric_depth))*cm)); 0
-    set Variable names      = x,z
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators     = top: free surface
-  set Additional tangential mesh velocity boundary indicators = right, left
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-    set Surface velocity projection = vertical
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Box origin X coordinate = 0
-    set Box origin Y coordinate = 0
-    set Box origin Z coordinate = 0
-    set X extent                = 1024e3
-    set X periodic              = false
-    set X repetitions           = 2
-    set Y extent                = 512e3
-    set Y periodic              = false
-    set Y repetitions           = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = reference_t=293, crustal_t = 420, lith_t = 1350, mantle_t = 1470, total_depth=512e3, crustal_depth=30e3, lithospheric_depth=120e3,
-    set Function expression = if (z>total_depth-crustal_depth,reference_t+(total_depth-z)*(crustal_t/crustal_depth), if (z>total_depth-lithospheric_depth,reference_t+crustal_t+(total_depth-crustal_depth-z)*(lith_t-crustal_t)/(lithospheric_depth-crustal_depth), reference_t+lith_t+(total_depth-lithospheric_depth-z)*(mantle_t-lith_t)/(total_depth-lithospheric_depth)))
-    set Variable names      = x,z
-  end
-end
-
-subsection Material model
-  set Model name         = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Minimum refinement level                 = 4
-end
-
-subsection Boundary composition model
-  set Fixed composition boundary indicators   = left, right
-  set List of model names = initial composition
-end
-
-subsection Postprocess
-  set List of postprocessors = topography
-
-  subsection Topography
-    set Time between text output       = 0
-    set Output to file = true
-  end
-end
-
-subsection Termination criteria
-  set End step                  = 1
-  set Termination criteria      = end step
-
-  subsection Steady state velocity
-    set Maximum relative deviation = 0.05
-    set Time in steady state       = 1e6
-  end
-
-  subsection User request
-    set File name = terminate-aspect
-  end
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-10
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-8
-  end
-end
diff --git a/tests/topo_chunk.prm.bak b/tests/topo_chunk.prm.bak
deleted file mode 100644
index 7d1d64d95c5..00000000000
--- a/tests/topo_chunk.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-#Test topography postprocessor with chunk geometry
-set Dimension = 2
-set CFL number                             = 1.0
-set Adiabatic surface temperature          = 1600.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Output directory              = topo_chunk
-set Pressure normalization = no
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = chunk
-
-  subsection Chunk
-    set Chunk minimum longitude = 60
-    set Chunk maximum longitude = 120
-    set Longitude repetitions = 1
-    set Chunk inner radius = 3000000
-    set Chunk outer radius = 6000000
-    set Radius repetitions = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 1800
-    set Outer temperature = 273
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = outer: free surface
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-end
-
-subsection Postprocess
-  set List of postprocessors = topography
-
-  subsection Topography
-    set Time between text output       = 0
-    set Output to file = true
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step                               = 1
-end
diff --git a/tests/topo_shell.prm.bak b/tests/topo_shell.prm.bak
deleted file mode 100644
index a02260cccb3..00000000000
--- a/tests/topo_shell.prm.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-#Test topography postprocessor with spherical shell geometry
-set Dimension                              = 2
-set Use years in output instead of seconds = true
-set End time                               = 1.5e9
-set Output directory                       = topo_shell
-set Pressure normalization                 = no
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Outer radius  = 6336000
-    set Opening angle = 90
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = inner
-  set Tangential velocity boundary indicators = left, right
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = top, bottom
-  set List of model names = spherical constant
-
-  subsection Spherical constant
-    set Inner temperature = 4273
-    set Outer temperature = 973
-  end
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators     = top: free surface
-end
-
-subsection Heating model
-  set List of model names =  shear heating
-end
-
-subsection Initial temperature model
-  set Model name = spherical hexagonal perturbation
-end
-
-subsection Gravity model
-  set Model name = ascii data
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = topography
-
-  subsection Topography
-    set Time between text output       = 0
-    set Output to file = true
-  end
-end
-
-subsection Termination criteria
-  set End step                  = 1
-  set Termination criteria      = end step
-end
diff --git a/tests/tosi_benchmark.cc.bak b/tests/tosi_benchmark.cc.bak
deleted file mode 100644
index 8e2b0e4e121..00000000000
--- a/tests/tosi_benchmark.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark.prm.bak b/tests/tosi_benchmark.prm.bak
deleted file mode 100644
index 1de3651779a..00000000000
--- a/tests/tosi_benchmark.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-# This is a test for the benchmark described in
-# $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015
-
-include $ASPECT_SOURCE_DIR/benchmarks/tosi_et_al_2015_gcubed/Tosi_base.prm
-
-set Additional shared libraries            = ./libtosi_benchmark.so
-set End time                               = 0.005
-set Max nonlinear iterations               = 15
diff --git a/tests/tosi_benchmark_gmg_dc_picard_solver.cc.bak b/tests/tosi_benchmark_gmg_dc_picard_solver.cc.bak
deleted file mode 100644
index 7dfc1e32ff1..00000000000
--- a/tests/tosi_benchmark_gmg_dc_picard_solver.cc.bak
+++ /dev/null
@@ -1 +0,0 @@
-#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark_gmg_dc_picard_solver.prm.bak b/tests/tosi_benchmark_gmg_dc_picard_solver.prm.bak
deleted file mode 100644
index d4e0b9aae33..00000000000
--- a/tests/tosi_benchmark_gmg_dc_picard_solver.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test GMG  iterated defect correction Stokes solver based on
-# benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
-
-include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
-
-set Nonlinear solver scheme = single Advection, iterated defect correction Stokes
-set End time                               = 0.0022
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/tests/tosi_benchmark_gmg_newton_solver.cc.bak b/tests/tosi_benchmark_gmg_newton_solver.cc.bak
deleted file mode 100644
index 8e2b0e4e121..00000000000
--- a/tests/tosi_benchmark_gmg_newton_solver.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark_gmg_newton_solver.prm.bak b/tests/tosi_benchmark_gmg_newton_solver.prm.bak
deleted file mode 100644
index 1034fe649d0..00000000000
--- a/tests/tosi_benchmark_gmg_newton_solver.prm.bak
+++ /dev/null
@@ -1,18 +0,0 @@
-# Test Newton GMG solver based on
-# benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input_gmg.prm
-
-set Additional shared libraries            = $ASPECT_SOURCE_DIR/benchmarks/tosi_et_al_2015_gcubed/libtosi_benchmark.so
-
-include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
-
-set End time                               = 0.0022
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average
-end
diff --git a/tests/tosi_benchmark_newton_solver.cc.bak b/tests/tosi_benchmark_newton_solver.cc.bak
deleted file mode 100644
index 8e2b0e4e121..00000000000
--- a/tests/tosi_benchmark_newton_solver.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark_newton_solver.prm.bak b/tests/tosi_benchmark_newton_solver.prm.bak
deleted file mode 100644
index 4e6f87f530f..00000000000
--- a/tests/tosi_benchmark_newton_solver.prm.bak
+++ /dev/null
@@ -1,8 +0,0 @@
-# This is a test for the benchmark described in
-# $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015
-
-include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
-
-set Additional shared libraries            = ./libnewton_solver_tosi.so
-set End time                               = 0.0021
-set Max nonlinear iterations               = 15
diff --git a/tests/tosi_benchmark_newton_solver_full_A.cc.bak b/tests/tosi_benchmark_newton_solver_full_A.cc.bak
deleted file mode 100644
index 8e2b0e4e121..00000000000
--- a/tests/tosi_benchmark_newton_solver_full_A.cc.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "../benchmarks/tosi_et_al_2015_gcubed/tosi.cc"
diff --git a/tests/tosi_benchmark_newton_solver_full_A.prm.bak b/tests/tosi_benchmark_newton_solver_full_A.prm.bak
deleted file mode 100644
index 3422d700046..00000000000
--- a/tests/tosi_benchmark_newton_solver_full_A.prm.bak
+++ /dev/null
@@ -1,15 +0,0 @@
-# This is a test for the Tosi benchmark using the Newton solver and the full A block
-# as preconditioner. Prior to this test there was a bug assigning the correct assemblers
-# for this case.
-
-include $ASPECT_SOURCE_DIR/benchmarks/newton_solver_benchmark_set/tosi_et_al_2015/input.prm
-
-set Additional shared libraries            = ./libnewton_solver_tosi.so
-set End time                               = 0.0021
-set Max nonlinear iterations               = 15
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use full A block as preconditioner = true
-  end
-end
diff --git a/tests/traction_ascii_data.prm.bak b/tests/traction_ascii_data.prm.bak
deleted file mode 100644
index 946e2f042c6..00000000000
--- a/tests/traction_ascii_data.prm.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-# This is a test model for the ascii data traction plugin.
-# It reads traction boundary conditions from a file
-# located in the data/traction-boundary-conditions/ascii-data/test/
-# directory and applies them at the left side of a 2d box
-# model.
-
-
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 3
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 0 #1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 3
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 3000000
-    set Y extent  = 660000
-    set X repetitions = 9
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 1e8
-    set Age bottom boundary layer   = 0.0
-    set Amplitude                   = 250
-    set Radius                      = 400000
-  end
-end
-
-subsection Material model
-  set Model name = diffusion dislocation
-  set Material averaging = none
-
-  subsection Diffusion dislocation
-    set Densities                                 = 3330
-    set Maximum viscosity                         = 1e26
-    set Minimum viscosity                         = 1e17
-    set Heat capacity                             = 1200
-    set Thermal expansivities                     = 3.3e-5
-    set Activation energies for diffusion creep   = 375000
-    set Activation volumes for diffusion creep    = 6e-6
-    set Grain size exponents for diffusion creep  = 4
-    set Prefactors for diffusion creep            = 1.5e-16
-    set Activation energies for dislocation creep = 480000
-    set Prefactors for dislocation creep          = 2e-15
-    set Activation volumes for dislocation creep  = 8e-6
-    set Maximum strain rate ratio iterations      = 10000
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 0:ascii data
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-traction/ascii-data/test/
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set Time between graphical output = 50
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint = 1700
-end
-
-subsection Heating model
-  set List of model names =  latent heat
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block AMG
-  end
-end
diff --git a/tests/traction_multiple_model.prm.bak b/tests/traction_multiple_model.prm.bak
deleted file mode 100644
index dffe3da3ef9..00000000000
--- a/tests/traction_multiple_model.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-# This is a test model for the allowing multiple traction models for a single boundary.
-# It reads traction boundary conditions from a file
-# located in the data/traction-boundary-conditions/ascii-data/test/
-# directory and combine it with a traction function and applies them at
-# the left side of a 2d box model.
-
-
-set Adiabatic surface temperature          = 1600
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Max nonlinear iterations               = 3
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 0 #1e5
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 3
-
-  subsection Initial temperature
-    set Minimal temperature = 293
-    set Maximal temperature = 1600
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 3000000
-    set Y extent  = 660000
-    set X repetitions = 9
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 1e8
-    set Age bottom boundary layer   = 0.0
-    set Amplitude                   = 250
-    set Radius                      = 400000
-  end
-end
-
-subsection Material model
-  set Model name = diffusion dislocation
-  set Material averaging =  harmonic average only viscosity
-
-  subsection Diffusion dislocation
-    set Densities                                 = 3330
-    set Maximum viscosity                         = 1e26
-    set Minimum viscosity                         = 1e17
-    set Heat capacity                             = 1200
-    set Thermal expansivities                     = 3.3e-5
-    set Activation energies for diffusion creep   = 375000
-    set Activation volumes for diffusion creep    = 6e-6
-    set Grain size exponents for diffusion creep  = 4
-    set Prefactors for diffusion creep            = 1.5e-16
-    set Activation energies for dislocation creep = 480000
-    set Prefactors for dislocation creep          = 2e-15
-    set Activation volumes for dislocation creep  = 8e-6
-    set Maximum strain rate ratio iterations      = 10000
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 4
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary traction model
-  set Prescribed traction boundary indicators = 0:ascii data, 0:function
-
-  subsection Function
-    set Variable names      = x,y
-
-    # The following line is the stress applied to the side boundaries (in Pa)
-    set Function constants  = stress=2000e6
-    set Function expression = if (y>600e3 ,-stress,0); 0
-  end
-
-  subsection Ascii data model
-    set Data directory = $ASPECT_SOURCE_DIR/data/boundary-traction/ascii-data/test/
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set Time between graphical output = 50
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-  end
-end
-
-subsection Checkpointing
-  set Time between checkpoint = 1700
-end
-
-subsection Heating model
-  set List of model names =  latent heat
-end
diff --git a/tests/transform_fault_behn_2007.prm.bak b/tests/transform_fault_behn_2007.prm.bak
deleted file mode 100644
index d294510054a..00000000000
--- a/tests/transform_fault_behn_2007.prm.bak
+++ /dev/null
@@ -1,11 +0,0 @@
-include $ASPECT_SOURCE_DIR/cookbooks/transform_fault_behn_2007/transform_fault_behn_2007.prm
-
-set World builder file = $ASPECT_SOURCE_DIR/contrib/world_builder/cookbooks/3d_cartesian_transform_fault/3d_cartesian_transform_fault.wb
-set Dimension = 3
-set End time = 0
-
-subsection Mesh refinement
-  set Initial global refinement = 2
-  set Initial adaptive refinement = 0
-  set Minimum refinement level = 2
-end
diff --git a/tests/two_merged_boxes_free_surface.prm.bak b/tests/two_merged_boxes_free_surface.prm.bak
deleted file mode 100644
index a9a2b35c0e2..00000000000
--- a/tests/two_merged_boxes_free_surface.prm.bak
+++ /dev/null
@@ -1,72 +0,0 @@
-set Dimension = 3
-set CFL number                             = 1.0
-set End time                               = 1
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-set Pressure normalization                 = no
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box with lithosphere boundary indicators
-
-  subsection Box with lithosphere boundary indicators
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1000
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3,6,7,8,9
-  set Zero velocity boundary indicators       = 4
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 5: free surface
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set List of output variables = depth
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/uncoupled_two_phase_tian_parameterization_kinematic_slab.prm.bak b/tests/uncoupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
deleted file mode 100644
index 11bc6fe9b90..00000000000
--- a/tests/uncoupled_two_phase_tian_parameterization_kinematic_slab.prm.bak
+++ /dev/null
@@ -1,50 +0,0 @@
-# This test is for the uncoupled Simplified Subduction Model with Parameterized
-# Solid-Fluid Reactions cookbook.
-
-include $ASPECT_SOURCE_DIR/cookbooks/tian_parameterization_kinematic_slab/coupled-two-phase-tian-parameterization-kinematic-slab.prm
-
-set Adiabatic surface temperature              = 1600
-set Nonlinear solver scheme                    = single Advection, single Stokes
-set End time                                   = 2000
-
-subsection Mesh refinement
-  set Initial global refinement = 1
-
-  subsection Minimum refinement function
-    set Function expression = 1
-  end
-end
-
-subsection Compositional fields
-  set Compositional field methods = darcy field, field, field, field, field, field
-end
-
-# Slightly change composition model to ensure that there is bound_fluid
-# and porosity at the end of the test.
-subsection Boundary composition model
-  set Fixed composition boundary indicators         = left
-  set List of model names                           = function
-
-  subsection Function
-    set Function constants  = initial_porosity=0, initial_bound_sed=0.03, initial_bound_MORB=0.02, initial_bound_gabbro=0.01, \
-                              sediment_min=0, sediment_max=5e3, MORB_min=5e3, MORB_max=12e3, gabbro_min=12e3, gabbro_max=20e3, \
-                              onset_time=0, slab_thickness=20e3
-    set Function expression = initial_porosity; \
-                              if( t<=onset_time, 0, \
-                              if( (y<=slab_thickness - sediment_min) & (y>slab_thickness - sediment_max), initial_bound_sed, \
-                              if( (y<=slab_thickness - MORB_min) & (y>slab_thickness - MORB_max), initial_bound_MORB, \
-                              if( (y<=slab_thickness - gabbro_min) & (y>slab_thickness - gabbro_max), initial_bound_gabbro, 0.0)))); \
-                              if(y>slab_thickness, 1, 0); \
-                              if(y<=8e3, 1, 0); \
-                              if(y>8e3 & y<=15e3, 1, 0); \
-                              if(y>15e3 & y<=slab_thickness, 1, 0)
-  end
-end
-
-subsection Melt settings
-  set Include melt transport = false
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
diff --git a/tests/update_script.cc.bak b/tests/update_script.cc.bak
deleted file mode 100644
index 24f1c669c67..00000000000
--- a/tests/update_script.cc.bak
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Use the update
- * script to update this parameter file. Unfortunately at this point the file
- * has already been loaded, so the current ASPECT instance would get the old
- * file. Thus we start a new ASPECT instance that will load the new file.
- * To avoid an endless recursion we remove the shared library from the new
- * input file (otherwise the new instance would call this library again, and so
- * on). After finishing the new instance we exit to not continue the old one.
- */
-int f()
-{
-  int ret;
-  std::string command;
-
-  command = ("cp update_script.x.prm output-update_script/updated.prm &&"
-             "sed -i.bak 's:set Additional shared libraries = ./libupdate_script.so::' output-update_script/updated.prm &&"
-             "bash " ASPECT_SOURCE_DIR "/contrib/utilities/update_prm_files.sh output-update_script/updated.prm &&"
-             "rm output-update_script/updated.prm.bak");
-
-  std::cout << "Executing the update script:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  command = ("../aspect output-update_script/updated.prm");
-  std::cout << "Running ASPECT with updated parameter file:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // abort current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/update_script_2.cc.bak b/tests/update_script_2.cc.bak
deleted file mode 100644
index 63ae1fcdcff..00000000000
--- a/tests/update_script_2.cc.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <iostream>
-
-/*
- * Launch the following function when this plugin is created. Use the update
- * script to update this parameter file. Unfortunately at this point the file
- * has already been loaded, so the current ASPECT instance would get the old
- * file. Thus we start a new ASPECT instance that will load the new file.
- * To avoid an endless recursion we remove the shared library from the new
- * input file (otherwise the new instance would call this library again, and so
- * on). After finishing the new instance we exit to not continue the old one.
- *
- * This test in particular calls the update script multiple times on the same
- * file, and ensures that only the first time changes happen. Every subsequent
- * application should not change the file any more.
- */
-int f()
-{
-  int ret;
-  std::string command;
-
-  command = ("cp update_script_2.x.prm output-update_script_2/updated2.prm;"
-             "sed -i.bak 's:set Additional shared libraries = ./libupdate_script_2.so::' output-update_script_2/updated2.prm;"
-             "bash " ASPECT_SOURCE_DIR "/contrib/utilities/update_prm_files.sh output-update_script_2/updated2.prm;"
-             "bash " ASPECT_SOURCE_DIR "/contrib/utilities/update_prm_files.sh output-update_script_2/updated2.prm;"
-             "rm output-update_script_2/updated2.prm.bak");
-
-  std::cout << "Executing the update script:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  command = ("../aspect output-update_script_2/updated2.prm");
-  std::cout << "Running ASPECT with updated parameter file:\n"
-            << command
-            << std::endl;
-  ret = system (command.c_str());
-  if (ret!=0)
-    std::cout << "system() returned error " << ret << std::endl;
-
-  // abort current process:
-  exit (0);
-  return 42;
-}
-
-
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/update_script_2/updated2.prm.bak b/tests/update_script_2/updated2.prm.bak
deleted file mode 100644
index cf003367e9b..00000000000
--- a/tests/update_script_2/updated2.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-# This test is a modified copy of update_script.prm.
-# It differs from update_script.prm by applying the update script twice,
-# and checking that it does not add additional lines after the
-# first run.
-
-# The content of this prm file is only executable by ASPECT <=1.5, but the
-# corresponding shared library in update_script.cc will first execute the
-# update script on this .prm file before running ASPECT with the updated
-# version of the file. The success of this test means the script did its job
-# and ASPECT 2.0 is able to read the twice updated file and the twice updated
-# file does not differ from the once updated file.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-set Output directory = output-update_script_2
-
-subsection Adiabatic conditions model
-  set Model name = compute profile
-
-  subsection Compute profile
-    set Use surface condition function = true
-
-    subsection Surface condition function
-      set Function expression = 1e-2*t; 1613.0+1e-13*t
-    end
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Boundary composition model
-  set List of model names = function
-end
-
-subsection Initial composition model
-  set Model name = function
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial linear
-
-  subsection Radial linear
-    set Magnitude at bottom = 10.7
-    set Magnitude at surface = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-    set Reference compressibility = 2.5e-12
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics, basic statistics, temperature statistics,heat flux statistics, depth average, dynamic topography, particles, heating statistics
-
-  subsection Dynamic topography
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = vtu
-    set List of output variables      = density, heating
-    set Time between graphical output = 0
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 10
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating
-end
-
-subsection Particles
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 50
-    end
-  end
-end
diff --git a/tests/upwelling_melting_peridotite.prm.bak b/tests/upwelling_melting_peridotite.prm.bak
deleted file mode 100644
index cf1d2b9f663..00000000000
--- a/tests/upwelling_melting_peridotite.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-# This test is used to check if the latent heat of
-# melting of peridotite is calculated correctly.
-# The material is upwelling with a constant velocity
-# (without separation of melt and solid) and without
-# conduction of heat, so that the steady state of the
-# model is an adiabatic temperature profile. An approximated
-# analytical solution for this profile to compare the solution
-# to is described in Katz et al., 2003 (A new parameterization
-# of hydrous mantle melting).
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 2.5e13
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9177
-    set Y extent = 183540      # maximum pressure 6 GPa
-    set Y repetitions = 20
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    set Function expression = 0;1e-10
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = latent heat melt
-
-  subsection Latent heat melt
-    set Reference density        = 3300
-    set Mass fraction cpx        = 0.10
-    set Reference specific heat  = 1000
-    set Relative density of melt = 0.878787879  # melt density of 2900 kg/m^3
-    set Reference temperature    = 1623.15      # 1350°C adiabat
-    set Peridotite melting entropy change = -300
-    set Thermal conductivity     = 0.0
-    set Compressibility          = 0.0
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = melt fraction, viscosity, density, nonadiabatic temperature
-
-    subsection Melt fraction
-      set Mass fraction cpx = 0.10
-    end
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, latent heat
-end
diff --git a/tests/upwelling_melting_peridotite_compressible.prm.bak b/tests/upwelling_melting_peridotite_compressible.prm.bak
deleted file mode 100644
index affddc66fcf..00000000000
--- a/tests/upwelling_melting_peridotite_compressible.prm.bak
+++ /dev/null
@@ -1,128 +0,0 @@
-# This test is used to check if the compressible variation
-# of the upwelling_melting_peridotite test is calculated correctly.
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 2.5e13
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1723.15   # 1450°C adiabat
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9177
-    set Y extent = 183540      # maximum pressure 6 GPa
-    set Y repetitions = 20
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    set Function expression = 0;1e-10
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = latent heat melt
-
-  subsection Latent heat melt
-    set Reference density        = 3300
-    set Mass fraction cpx        = 0.10
-    set Reference specific heat  = 1000
-    set Relative density of melt = 0.878787879  # melt density of 2900 kg/m^3
-    set Reference temperature    = 1623.15      # 1350°C adiabat
-    set Peridotite melting entropy change = -300
-    set Thermal conductivity     = 0.0
-    set Compressibility          = 4e-12
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.01
-    set List of output variables = melt fraction, viscosity, density, nonadiabatic temperature
-
-    subsection Melt fraction
-      set Mass fraction cpx = 0.10
-    end
-  end
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, latent heat
-end
diff --git a/tests/upwelling_melting_pyroxenite.prm.bak b/tests/upwelling_melting_pyroxenite.prm.bak
deleted file mode 100644
index c898f927597..00000000000
--- a/tests/upwelling_melting_pyroxenite.prm.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-# This test is used to check if the latent heat of
-# melting of pyroxenite is calculated correctly.
-# The material is upwelling with a constant velocity
-# (without separation of melt and solid) and without
-# conduction of heat, so that the steady state of the
-# model is an adiabatic temperature profile. An approximated
-# analytical solution for this profile to compare the solution
-# to can be calculated analogue to the description in Katz
-# et al., 2003 (A new parameterization of hydrous mantle melting)
-# by numerically integrating equation (23) of that paper and
-# using the corresponding parameters of the pyroxenite melting
-# parameterization from Sobolev et al., 2011 (Linking mantle plumes,
-# large igneous provinces and environmental catastrophes).
-
-# At the top, we define the number of space dimensions we would like to
-# work in:
-set Dimension                              = 2
-
-# There are several global variables that have to do with what
-# time system we want to work in and what the end time is.
-set Use years in output instead of seconds = false
-set End time                               = 2.5e13
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1623.15   # 1350°C adiabat
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Discretization
-  subsection Stabilization parameters
-    set beta = 0.13
-  end
-end
-
-# Then come a number of sections that deal with the setup
-# of the problem to solve. The first one deals with the
-# geometry of the domain within which we want to solve.
-# The sections that follow all have the same basic setup
-# where we select the name of a particular model (here,
-# the box geometry) and then, in a further subsection,
-# set the parameters that are specific to this particular
-# model.
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 9177
-    set Y extent = 183540      # maximum pressure 6 GPa
-    set Y repetitions = 20
-  end
-end
-
-# The next section deals with the initial conditions for the
-# temperature (there are no initial conditions for the
-# velocity variable since the velocity is assumed to always
-# be in a static equilibrium with the temperature field).
-# There are a number of models with the 'function' model
-# a generic one that allows us to enter the actual initial
-# conditions in the form of a formula that can contain
-# constants. We choose a linear temperature profile that
-# matches the boundary conditions defined below plus
-# a small perturbation:
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1746.794 - z/183540.0 * 300
-    set Variable names      = x,z
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1.0
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2
-
-  subsection Box
-    set Bottom temperature = 1746.794  # 1350°C adiabat
-  end
-end
-
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 2
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 2:function
-  set Tangential velocity boundary indicators = 0,1
-
-  subsection Function
-    set Function expression = 0;1e-10
-  end
-end
-
-# The following two sections describe first the
-# direction (vertical) and magnitude of gravity and the
-# material model (i.e., density, viscosity, etc). We have
-# discussed the settings used here in the introduction to
-# this cookbook in the manual already.
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = latent heat melt
-
-  subsection Latent heat melt
-    set Reference density        = 3300
-    set Mass fraction cpx        = 0.10
-    set Reference specific heat  = 1000
-    set Relative density of melt = 0.878787879  # melt density of 2900 kg/m^3
-    set Reference temperature    = 1623.15      # 1350°C adiabat
-    set Pyroxenite melting entropy change = -300
-    set Thermal conductivity     = 0.0
-    set Compressibility          = 0.0
-  end
-end
-
-# The settings above all pertain to the description of the
-# continuous partial differential equations we want to solve.
-# The following section deals with the discretization of
-# this problem, namely the kind of mesh we want to compute
-# on. We here use a globally refined mesh without
-# adaptive mesh refinement.
-subsection Mesh refinement
-  set Initial global refinement                = 3
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# The final part is to specify what ASPECT should do with the
-# solution once computed at the end of every time step. The
-# process of evaluating the solution is called `postprocessing'
-# and we choose to compute velocity and temperature statistics,
-# statistics about the heat flux through the boundaries of the
-# domain, and to generate graphical output files for later
-# visualization. These output files are created every time
-# a time step crosses time points separated by 0.01. Given
-# our start time (zero) and final time (0.5) this means that
-# we will obtain 50 output files.
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, latent heat
-end
diff --git a/tests/use_full_A_block_preconditioner.prm.bak b/tests/use_full_A_block_preconditioner.prm.bak
deleted file mode 100644
index 9e81c204546..00000000000
--- a/tests/use_full_A_block_preconditioner.prm.bak
+++ /dev/null
@@ -1,88 +0,0 @@
-# This is a relatively realistic compressible model setup.
-# There is no simple analytical solution to it, it is rather
-# intended to serve as a comparison for more complicated
-# models. This variation is particularly made to test using
-# the full A block as preconditioner for the Stokes system
-# instead of the simplified approximation described in the
-# first ASPECT paper.
-
-set CFL number                             = 1.0
-set End time                               = 1e5
-set Adiabatic surface temperature          = 1600.0
-set Use years in output instead of seconds = true
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use full A block as preconditioner = true
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0,1
-
-  subsection Spherical constant
-    set Inner temperature = 4250
-    set Outer temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius  = 3481000
-    set Opening angle = 90
-    set Outer radius  = 6371000
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 200.0
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density = 3340
-    set Reference specific heat = 1200
-    set Thermal expansion coefficient = 3e-5
-    set Viscosity = 1e21
-    set Reference compressibility = 2.5e-12
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.0
-  set Coarsening fraction                = 0.0
-  set Strategy                           = velocity
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,2,3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
-
-subsection Heating model
-  set List of model names = adiabatic heating, shear heating
-end
diff --git a/tests/van_keken_smooth_particle.prm.bak b/tests/van_keken_smooth_particle.prm.bak
deleted file mode 100644
index 54a54304bbb..00000000000
--- a/tests/van_keken_smooth_particle.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# A description of the van Keken et al. benchmark using smooth initial
-# conditions instead of the discontinuous ones in
-# van-keken-discontinuous.prm. See the manual for more information.
-# This test adds particles to the cookbook parameter file, and therefore
-# tests the behavior of the particles.
-
-set Dimension                              = 2
-set End time                               = 70
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 0.9142
-    set Y extent  = 1.0000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right
-  set Zero velocity boundary indicators       = bottom, top
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1010
-    set Viscosity                     = 1e2
-    set Thermal expansion coefficient = 0
-    set Density differential for compositional field 1 = -10
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-############### Parameters describing the temperature field
-# Note: The temperature plays no role in this model
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# Note: The compositional field is what drives the flow
-# in this example
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = pi=3.1415926
-    set Function expression = 0.5*(1+tanh((0.2+0.02*cos(pi*x/0.9142)-z)/0.02))
-  end
-end
-
-############### Parameters describing the discretization
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Strategy                           = composition
-  set Initial global refinement          = 4
-  set Time steps between mesh refinement = 0
-  set Coarsening fraction                = 0.05
-  set Refinement fraction                = 0.3
-end
-
-############### Parameters describing what to do with the solution
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, composition statistics,particles
-
-  subsection Particles
-    set Time between data output = 70
-    set Data output format = vtu
-  end
-end
-
-subsection Particles
-  set List of particle properties = function, initial composition, initial position
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = if( (z>0.2+0.02*cos(pi*x/0.9142)) , 0 , 1 )
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 10
-    end
-  end
-end
diff --git a/tests/vankeken_subduction.cc.bak b/tests/vankeken_subduction.cc.bak
deleted file mode 100644
index 89ad2bb0304..00000000000
--- a/tests/vankeken_subduction.cc.bak
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "../cookbooks/prescribed_velocity/prescribed_velocity.cc"
-#include "../cookbooks/vankeken_subduction/plugin/van_Keken_mesh.cc"
diff --git a/tests/vankeken_subduction.prm.bak b/tests/vankeken_subduction.prm.bak
deleted file mode 100644
index b68d80fbffd..00000000000
--- a/tests/vankeken_subduction.prm.bak
+++ /dev/null
@@ -1,13 +0,0 @@
-include $ASPECT_SOURCE_DIR/cookbooks/vankeken_subduction/vankeken_corner_flow.prm
-
-set End time = 0
-
-subsection Mesh refinement
-  set Initial global refinement = 0
-  set Initial adaptive refinement = 0
-end
-
-# Postprocessing
-subsection Postprocess
-  set List of postprocessors = velocity statistics
-end
diff --git a/tests/var_declaration_expansion.cc.bak b/tests/var_declaration_expansion.cc.bak
deleted file mode 100644
index 12776345f3c..00000000000
--- a/tests/var_declaration_expansion.cc.bak
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/utilities.h>
-
-#include <iostream>
-
-void print_string_vector(std::vector<std::string> data)
-{
-  for (std::vector<std::string>::iterator it = data.begin(); it != data.end(); ++it)
-    std::cout << "\t" << *it << std::endl;
-}
-
-int f()
-{
-  using namespace aspect::Utilities;
-
-  std::vector<std::string> base_declarations;
-  base_declarations.push_back("vector(  vec  )");
-  base_declarations.push_back("tensor(  ten )");
-
-  std::vector<std::string> var_decl_2 = expand_dimensional_variable_names<2> (base_declarations);
-  std::vector<std::string> var_decl_3 = expand_dimensional_variable_names<3> (base_declarations);
-
-  std::cout << "Dimension 2:" << std::endl;
-  print_string_vector(var_decl_2);
-
-  std::cout << "Dimension 3:" << std::endl;
-  print_string_vector(var_decl_3);
-
-  exit(0);
-
-  // dummy return for compilation warnings
-
-  return 0;
-}
-
-int ignored_variable = f();
diff --git a/tests/var_declaration_expansion.prm.bak b/tests/var_declaration_expansion.prm.bak
deleted file mode 100644
index bfa37b00c09..00000000000
--- a/tests/var_declaration_expansion.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# A test that simply verifies that the additional material
-# model outputs can be accessed.
-
-
-
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/velocity_boundary_statistics.prm.bak b/tests/velocity_boundary_statistics.prm.bak
deleted file mode 100644
index 116d7d2dc25..00000000000
--- a/tests/velocity_boundary_statistics.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e13
-set Start time                             = 0
-set Adiabatic surface temperature          = 1613.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = 0, 1
-
-  subsection Spherical constant
-    set Inner temperature = 1613.0
-    set Outer temperature = 1613.0
-  end
-end
-
-subsection Termination criteria
-  set Checkpoint on termination = true
-  set Termination criteria      = end step
-  set End step                  = 10
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 9.81
-  end
-end
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6371000
-    set Opening angle = 90
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = if((sqrt((x-3e6)^2+(y-2e6)^2)<1e6) , 800.0, 0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1613
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1e22
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 4
-  set Additional refinement times              = 0,0
-  set Strategy = velocity
-  set Time steps between mesh refinement       = 2
-  set Refinement fraction                      = 0.1
-  set Coarsening fraction                      = 0.0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 2, 3
-  set Zero velocity boundary indicators       = 1
-end
-
-subsection Heating model
-  set List of model names = shear heating
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics,  temperature statistics, heat flux statistics, velocity boundary statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/velocity_divergence.cc.bak b/tests/velocity_divergence.cc.bak
deleted file mode 100644
index fe5b66368ef..00000000000
--- a/tests/velocity_divergence.cc.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-
-namespace aspect
-{
-  template <int dim>
-  class TestMaterial:
-    public MaterialModel::Interface<dim>, public ::aspect::SimulatorAccess<dim>
-  {
-    public:
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-
-      virtual void evaluate(const typename MaterialModel::Interface<dim>::MaterialModelInputs &in,
-                            typename MaterialModel::Interface<dim>::MaterialModelOutputs &out) const
-      {
-        for (unsigned int i=0; i<in.n_evaluation_points(); ++i)
-          {
-            out.viscosities[i] = 1e19;
-            out.thermal_expansion_coefficients[i] = 0.0;
-            out.specific_heat[i] = 1.0;
-            out.thermal_conductivities[i] = 1e-4;
-            out.compressibilities[i] = 0.0;
-            out.densities[i] = 3000;
-            for (unsigned int c=0; c<in.composition[i].size(); ++c)
-              {
-                if (in.requests_property(MaterialModel::MaterialProperties::reaction_terms))
-                  out.reaction_terms[i][c] = trace(in.strain_rate[i]) * this->get_timestep();
-                else
-                  out.reaction_terms[i][c] = 0.0;
-              }
-
-          }
-      }
-  };
-}
-
-// explicit instantiations
-namespace aspect
-{
-
-  ASPECT_REGISTER_MATERIAL_MODEL(TestMaterial,
-                                 "test material",
-                                 "")
-
-}
diff --git a/tests/velocity_divergence.prm.bak b/tests/velocity_divergence.prm.bak
deleted file mode 100644
index 0c667e22076..00000000000
--- a/tests/velocity_divergence.prm.bak
+++ /dev/null
@@ -1,161 +0,0 @@
-# This is a test investigating if the divergence
-# of the velocity is really zero, as it should be
-# in cases where no melt is present. The material model
-# implements a reaction term for the porosity
-# compositional field that equals the velocity divergence
-# in the way it would be used in models with melt transport,
-# but in this model melt migration is not used.
-#
-# The divergence is zero if the velocity is prescribed at
-# all of the boundaries, but not with a mix of free slip and
-# prescribed velocity boundary conditions.
-# ---------------------
-set Adiabatic surface temperature          = 1580
-set CFL number                             = 1.0
-set Nonlinear solver scheme                = iterated Advection and Stokes
-set Output directory                       = test
-set Max nonlinear iterations               = 6
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-# This end time is chosen in such a way that the solitary wave travels
-# approximately 5 times its wavelength during the model time.
-set End time                               = 250.0
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = porosity
-end
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,1,2,3
-
-  subsection Box
-    set Top temperature = 293
-    set Bottom temperature = 1580
-  end
-end
-
-subsection Boundary composition model
-  set Allow fixed composition on outflow boundaries = true
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = 0,1,2,3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0:function, 1:function #,2:function, 3:function
-  set Tangential velocity boundary indicators = 2,3
-
-  subsection Function
-    set Function constants  = z0=35000, u0=1.00, x0=10000, z1=35000
-    set Variable names      = x,z
-    set Function expression = u0*z/z0;0.0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 70000
-    set Y extent  = 35000
-    set X repetitions = 2
-
-    #    set X periodic = true
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = adiabatic
-
-  subsection Adiabatic
-    set Age top boundary layer      = 1e7
-    set Age bottom boundary layer   = 0.0
-    set Amplitude                   = 0
-    set Radius                      = 30000
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = pi=3.1415926,a = 1e-5, b = 35000, c = 2000, d=17500
-    set Function expression = a * exp(-((x-b)*(x-b)+(y-d)*(y-d))/(2*c*c))
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = test material
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.005
-  set Refinement fraction                      = 0.0
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 6
-  set Strategy                                 = minimum refinement function, composition
-  set Time steps between mesh refinement       = 0
-
-  subsection Minimum refinement function
-    set Coordinate system   = cartesian
-    set Function expression = if(y>35000,if(x<60000,7,if(x<15000,5,5)),5)
-    set Variable names      = x,y
-  end
-end
-
-subsection Boundary fluid pressure model
-  set Plugin name = density
-
-  subsection Density
-    set Density formulation = solid density
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,composition statistics,velocity statistics, mass flux statistics
-
-  subsection Visualization
-    set List of output variables      = material properties, nonadiabatic temperature, melt fraction, strain rate
-    set Number of grouped files       = 0
-    set Interpolate output            = false
-    set Output format                 = vtu
-    set Time between graphical output = 0
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-  end
-end
-
-subsection Checkpointing
-  set Steps between checkpoint = 10
-end
-
-subsection Solver parameters
-  set Composition solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-    set Use direct solver for Stokes system = false
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/velocity_in_years.prm.bak b/tests/velocity_in_years.prm.bak
deleted file mode 100644
index 06492761127..00000000000
--- a/tests/velocity_in_years.prm.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-#########################################################
-# A variation of composition-active (but only because that
-# one has prescribed, variable boundary conditions).
-#
-# We used to have a bug in that when "Use years in output instead of seconds"
-# was set to "true", we would still interpret velocities given in the input
-# file as in m/s. Presumably, people mean to use m/year in that case. See the
-# email thread with Cedric Thieulot, subject "velocity RMS" in December 2012.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-# Prescribe velocities in the range [-1,1]. Given that above
-# we say that we want years instead of seconds, this is supposed
-# to mean "1 m/year", not "1 m/second".
-#
-# 1m/year is approximately equal to 3.17e-8 m/s.
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2
-  set Prescribed velocity boundary indicators = 3: function
-
-  subsection Function
-    set Variable names      = x,z,t
-    set Function constants  = pi=3.1415926
-    set Function expression = if(x>1+sin(0.5*pi*t), 1, -1); 0
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 0
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/vep_chemical_compositions.prm.bak b/tests/vep_chemical_compositions.prm.bak
deleted file mode 100644
index 2a5451f89ee..00000000000
--- a/tests/vep_chemical_compositions.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# This tests checks that we do not have to specify material properties
-# for compositional fields that do not represent chemical compositions.
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm
-
-
-# Global parameters
-set Dimension                              = 2
-set End time                               = 1000
-set Max nonlinear iterations               = 2
-set Output directory                       = vep_chemical_compositions
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 6
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, plastic_strain, viscous_strain, test
-  set Types of fields  = stress, stress, stress, strain, strain, chemical composition
-end
-
-# We prescribe some initial strain at the center of the domain
-# plastic_strain, viscous_strain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0; 0; 0; \
-                              if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0); \
-                              if(x>=35e3&x<=65e3&y>=35.e3&y<=65.e3,0.8,0); 1
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  # We test whether we can specify
-  # 1. the same value for all fields
-  # 2. a value for each field (old behaviour, preserved for backwards compatibility)
-  # 3. only values for chemical composition fields
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5e-23, 5e-23, 5e-23, 5e-23, 5e-23, 5e-23, 5e-23
-    set Stress exponents for dislocation creep = 1, 0, 0, 0, 0, 0, 1
-    set Activation energies for dislocation creep = 0, 0
-    set Activation volumes for dislocation creep = 0
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0,10,10,10,5,5,0
-    set Cohesions = 1.e6,0,0,0,0,0,1e6
-    set Strain weakening mechanism = plastic weakening with plastic strain and viscous weakening with viscous strain
-    set Start prefactor strain weakening intervals = 0,0
-    set End prefactor strain weakening intervals = 1,1,1,1,1,1,1
-    set Prefactor strain weakening factors = 0.5,0.5
-    set Start plasticity strain weakening intervals = 0.,0
-    set End plasticity strain weakening intervals = 1,1,1,1,1,1,1
-    set Cohesion strain weakening factors = 0.5,0.5
-    set Friction strain weakening factors = 0.5
-    set Elastic shear moduli        = 1e10,1e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Time between graphical output = 1000
-  end
-end
diff --git a/tests/vis_velocity_in_years.prm.bak b/tests/vis_velocity_in_years.prm.bak
deleted file mode 100644
index 51694c3b056..00000000000
--- a/tests/vis_velocity_in_years.prm.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1.0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1.2
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, basic statistics,  temperature statistics, heat flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/visco_elastic_top_beam.prm.bak b/tests/visco_elastic_top_beam.prm.bak
deleted file mode 100644
index e27fc9f5fe3..00000000000
--- a/tests/visco_elastic_top_beam.prm.bak
+++ /dev/null
@@ -1,154 +0,0 @@
-# Like the viscous_top_beam.prm test, but including elasticity.
-
-
-# Global parameters
-set Dimension                              = 2
-set End time                               = 2e3
-set Use years in output instead of seconds = true
-set Output directory = output_ve
-set CFL number                             = 0.5
-set Maximum time step                      = 1e3
-
-# Solver settings
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 2000
-  end
-end
-
-# Model geometry (7.5x5 km, 0.1 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 10
-    set X extent      = 7.5e3
-    set Y extent      = 5e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Element types
-subsection Discretization
-  set Temperature polynomial degree           = 1
-  set Use locally conservative discretization = false
-  set Use discontinuous temperature discretization = false
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-    set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0
-    set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0
-  end
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = top
-  set Tangential velocity boundary indicators = bottom, left, right
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, beam
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; if (x>=3.5e3 && x<=4.0e3 && y>=3.0e3, 1, 0)
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Fixed composition boundary indicators  = bottom, top, right, left
-  set List of model names                   = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 293
-    set Left temperature   = 293
-    set Right temperature  = 293
-    set Top temperature    = 293
-  end
-end
-
-# Temperature initial conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Densities            =  2800,  2800,  2800,  2800,  6000
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5.e-19, 5.e-19, 5.e-19, 5.e-19, 5.e-25
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
-    set Fixed elastic time step     = 2e3
-    set Use fixed elastic time step = true
-    set Viscosity averaging scheme  = maximum composition
-    set Cohesions = 1.e50
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate, stress second invariant, principal stress
-    set Output format = gnuplot
-    set Time steps between graphical output = 1
-    set Interpolate output = true
-
-    subsection Principal stress
-      set Use deviatoric stress = true
-    end
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-end
diff --git a/tests/visco_plastic.prm.bak b/tests/visco_plastic.prm.bak
deleted file mode 100644
index 70e7a3c88a6..00000000000
--- a/tests/visco_plastic.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_additional_plastic_outputs.prm.bak b/tests/visco_plastic_additional_plastic_outputs.prm.bak
deleted file mode 100644
index 3344c0c6f2e..00000000000
--- a/tests/visco_plastic_additional_plastic_outputs.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_additional_plastic_outputs
-set Timing output frequency                = 1
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = plastic_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 20.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/visco_plastic_adiabat_temperature.prm.bak b/tests/visco_plastic_adiabat_temperature.prm.bak
deleted file mode 100644
index e7793e437b0..00000000000
--- a/tests/visco_plastic_adiabat_temperature.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# A test for adding an adiabatic temperature gradient to the temperature
-# in the flow laws for the visco_plastic material model.
-# This is useful for incompressible models that do not include an adiabatic
-# temperature gradient.
-# This test modifies the visco_plastic_diffusion_dislocation_composite test
-# by adding a temperature gradient to the otherwise uniform temperature (1573).
-# The gradient is added in terms of pressure rather than depth.
-# Using a pressure gradient of 32436 Pa/m, then a value of
-# 0.3 K/km = 0.0003 K/m = 9.24e-09 K/Pa gives an earth-like adiabat.
-# At the surface P = 3e9 Pa (as defined in original test) so Tv = T + Tad ~ 1600
-# strain-rate = 4.48e-16 (from applied pure shear) and eta-comp ~ 3.43e18 Pa s.
-# At the bottom of the box (100 km, P = 3e9 + 3300*100e3*10 = 6.3e9 Pa, with g = 10 m/s^2)
-# In the test, there is some dynamic pressure, so the pressure at the bottom is 6.15e9 Pa
-# For this pressure, eta-comp ~ 20.016e18 Pa s
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_adiabat_temperature
-set Surface pressure                       = 3.e9
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1573
-    set Left temperature   = 1573
-    set Right temperature  = 1573
-    set Top temperature    = 1573
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = mm=0.001, year=1
-    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1573
-  end
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = composite
-    set Grain size = 1.e-3
-    set Grain size exponents for diffusion creep = 3.
-    set Prefactors for diffusion creep = 2.37e-15
-    set Activation energies for diffusion creep = 375.e3
-    set Activation volumes for diffusion creep = 10.e-6
-    set Prefactors for dislocation creep = 6.52e-16
-    set Stress exponents for dislocation creep = 3.5
-    set Activation energies for dislocation creep = 530.e3
-    set Activation volumes for dislocation creep = 18.e-6
-    set Adiabat temperature gradient for viscosity = 9.24e-09
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_adiabatic_heating_density.prm.bak b/tests/visco_plastic_adiabatic_heating_density.prm.bak
deleted file mode 100644
index 1551c607bbc..00000000000
--- a/tests/visco_plastic_adiabatic_heating_density.prm.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-# A test with the visco_plastic material model to ensure
-# that the multicomponent_incompressible EOS module
-# uses the adiabatic temperature to compute density when
-# adiabatic heating is turned on. The formula specified
-# in this test follows the Extended Boussinesq approximation.
-# The initial temperature throughout the model is equal to
-# the adiabatic temperature profile. As a result, the
-# the absolute density should be constant throughout the
-# model and equal to the background values specified in
-# material model (3300 kg m^-3):
-#   density = background_density * ( 1 - thermal_expansivity * (temperature - reference_temperature)),
-# where the reference_temperature is the depth-dependent
-# adiabatic temperature. If adiabatic heating was not
-# used in the model, then the reference temperature
-# would be the constant value specified in the material
-# model (273 K), which would produce different density values.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1573
-
-# In combination with simplified adiabatic and shear heating,
-# the parameters give the Extended Boussinesq approximation.
-subsection Formulation
-  set Formulation          = custom
-  set Mass conservation    = incompressible
-  set Temperature equation = reference density profile
-end
-
-subsection Heating model
-  set List of model names = shear heating, adiabatic heating
-
-  subsection Adiabatic heating
-    set Use simplified adiabatic heating = true
-  end
-end
-
-# Model geometry (100x100 km, 100 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# No mesh refinement
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# All boundaries have a fixed temperature
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators  = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-# The initial temperature profile is equal to the adiabatic temperature profile.
-subsection Initial temperature model
-  set Model name = adiabatic
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Since adiabatic heating is used, the reference temperature
-    # specified below will be ignored and the density formulation
-    # will use the adiabatic temperature.
-    set Reference temperature = 273
-    set Thermal expansivities = 1e-5
-    set Densities             = 3300
-
-    # Constant viscosity
-    set Viscous flow law                         = diffusion
-    set Grain size exponents for diffusion creep = 0.
-    set Prefactors for diffusion creep           = 5.e-22
-    set Activation energies for diffusion creep  = 0.
-    set Activation volumes for diffusion creep   = 0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = material statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = adiabat, density
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/visco_plastic_adiabatic_pressure_in_viscous_creep.prm.bak b/tests/visco_plastic_adiabatic_pressure_in_viscous_creep.prm.bak
deleted file mode 100644
index 57282f24785..00000000000
--- a/tests/visco_plastic_adiabatic_pressure_in_viscous_creep.prm.bak
+++ /dev/null
@@ -1,149 +0,0 @@
-# A test for using the adiabatic pressure in creep (diffusion,
-# dislocation, peierls) viscosity calculation for the visco_plastic
-# material model. For example, the adiabatic pressure is 3.3e9 Pa
-# (= rho * g * depth = 3300 * 10 * 100e3) at the bottom. So, the
-# predicted diffusion viscosisty ‘eta_diff’ can be calculated by the
-# following equation:
-#
-#   eta_diff = 0.5 * A^(-1/n) * d^(m/n) * exp((E + P_ad*V)/(nRT))
-#            = 7.47e18 Pa*s
-#
-#  A    = 2.37e-15   # diffusion creep prefactor m^3/Pa*s
-#  d    = 1.e-3      # grain size [m]
-#  n    = 1          # stress exponent for diffusion
-#  m    = 3.         # grain size exponents for diffusion
-#  R    = 8.314      # gas constant [J/mol*K]
-#  T    = 1573       # temperature [K]
-#  E    = 375.e3     # activation energy for diffusion [J/mol]
-#  V    = 10.e-6     # activation volume for diffusion [m^3/mol]
-#  P_ad = 3.3e9      # adiabatic pressure at the bottom (Pa)
-
-# Similarly, the predicted dislocation viscosity 'eta_disl' and peierls
-# viscosity 'eta_peir' can be obtained by the corresponding equations.
-# The following 'subsection Visco Plastic' provides the relevant parameter
-# values. eta_disl = 1.14e21 Pa*s. eta_peir = 7.46e22 Pa*s. The predicted
-# composite (average) viscosity is 7.42e18 Pa*s.
-# The material model returns the harmonic average of the three creep
-# viscosities at the bottom.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_adiabatic_pressure_in_viscous_creep
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1573
-    set Left temperature   = 1573
-    set Right temperature  = 1573
-    set Top temperature    = 1573
-  end
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = mm=0.001, year=1
-    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1573
-  end
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = composite
-
-    # diffusion creep parameters
-    set Grain size = 1.e-3
-    set Grain size exponents for diffusion creep = 3.
-    set Prefactors for diffusion creep = 2.37e-15
-    set Activation energies for diffusion creep = 375.e3
-    set Activation volumes for diffusion creep = 10.e-6
-
-    # dislocation creep parameters
-    set Prefactors for dislocation creep = 6.52e-16
-    set Stress exponents for dislocation creep = 3.5
-    set Activation energies for dislocation creep = 530.e3
-    set Activation volumes for dislocation creep = 18.e-6
-
-    # peierls creep parameters
-    set Include Peierls creep                     = true
-    set Peierls creep flow law                    = exact
-    set Prefactors for Peierls creep              = 1.4e-19
-    set Activation energies for Peierls creep     = 320.e3
-    set Activation volumes for Peierls creep      = 1.4e-5
-    set Peierls stresses                          = 5.e9
-    set Stress exponents for Peierls creep        = 2.0
-    set Peierls fitting parameters                = 0.17
-    set Peierls glide parameters p                = 0.5
-    set Peierls glide parameters q                = 1.0
-    set Peierls strain rate residual tolerance    = 1e-6
-    set Maximum Peierls strain rate iterations    = 40
-    set Cutoff stresses for Peierls creep         = 0.0
-    set Use adiabatic pressure in creep viscosity = true
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_complex.prm.bak b/tests/visco_plastic_complex.prm.bak
deleted file mode 100644
index 9ef7aced3bc..00000000000
--- a/tests/visco_plastic_complex.prm.bak
+++ /dev/null
@@ -1,174 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_complex
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1573
-    set Top temperature    =  273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Initial temperature field
-# Typical continental geotherm based equations 4-6 from Chapman 1986 (Geol. Soc. Lon.)
-# The initial constraints are:
-#   surface temperature (ts) = 273 K; basal temperature (tb) = 1573 K; Moho
-#   temperature (tm) = 873 K; crust heat production (A) = 9.e-7 W/m^3; crust
-#   thermal conductivity (kc) = 2.5 (W/(m K));
-# To satisfy these constraints, the following values are required:
-#   surface heat flow (qs) = 0.0635 W/m^2; basal heat flow = 0.365 W/m^2;
-#   mantle thermal conductivity (km) = 3.65 (W/(m K));
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=100e3,ts=273,tm=873.,qs=0.0635,qb=0.0365,kc=2.5,km=3.65,A=9.e-7
-    set Function expression = if( (h-y)<=30.e3, \
-                                  ts + (qs/kc)*(h-y) - (A*(h-y)*(h-y))/(2.0*kc), \
-                                  tm + (qb/km)*(h-y-30.e3))
-  end
-end
-
-# Internal heating (only internal heating for crust)
-# Assuming a very large decay time, the heat production (W/m^3) is effectively:
-#   radioactive_heating_rate (W/kg) * density (kg/m^3)
-# For a reference crustal density of 2800 kg/m^3 and 9.e-7 W/m^3 heating production,
-# the heating rate (assuming a single element) is 9.e-7/2800. = 3.214287e-10
-subsection Heating model
-  set List of model names = radioactive decay
-
-  subsection Radioactive decay
-    set Number of elements            = 1
-    set Heating rates                 = 3.2142857e-10
-    set Half decay times              = 1.e20
-    set Initial concentrations mantle = 0.0
-    set Initial concentrations crust  = 1.0
-    set Crust defined by composition  = true
-    set Crust composition number      = 1
-  end
-end
-
-# Compositional fields used to track finite strain
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = plastic_strain, crust
-end
-
-# Initial composition model
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0; if(y>=70.e3, 1, 0);
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material, strain fields and crust)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Reference values and viscosity averaging
-    set Minimum strain rate = 1.e-20
-    set Reference strain rate = 1.e-16
-    set Minimum viscosity = 1e18
-    set Maximum viscosity = 1e28
-    set Viscosity averaging scheme = harmonic
-
-    # Thermodynamic properties
-    set Thermal diffusivities = 1.474747e-6,1.474747e-6,1.190476e-6
-    set Heat capacities = 750.
-    set Densities = 3300,3300,2800
-    set Thermal expansivities = 0.
-
-    # Viscous flow laws
-    # Background: Dry olive (Hirth & Kohlstedt 2004), Crust: Wet quartzite (Rutter & Brodie 2004)
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 6.52e-16,6.52e-16,8.57e-28
-    set Stress exponents for dislocation creep = 3.5,3.5,4.0
-    set Activation energies for dislocation creep = 530.e3,530.e3,223.e3
-    set Activation volumes for dislocation creep = 18.e-6,18.e-6,0.
-
-    # Yielding mechanism and values
-    set Yield mechanism = limiter
-    set Stress limiter exponents = 10, 10, 10
-    set Angles of internal friction = 0.,0.,0.
-    set Cohesions = 1.e6,1.e6,1.e6
-
-    # Strain weakening
-    set Strain weakening mechanism = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_composite.prm.bak b/tests/visco_plastic_composite.prm.bak
deleted file mode 100644
index f7b853d6197..00000000000
--- a/tests/visco_plastic_composite.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# Test for the visco_plastic composite viscosity option.
-# The user-defined diffusion and dislocation viscosity are
-# 1e22 Pa s and the composite viscosity should be 5e21 Pa s.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = mm=0.001, year=1
-    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = composite
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Prefactors for diffusion creep = 5.e-23
-    set Grain size exponents for diffusion creep = 0.
-    set Activation energies for diffusion creep = 0.
-    set Activation volumes for diffusion creep = 0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_constant_viscosity_prefactor.prm.bak b/tests/visco_plastic_constant_viscosity_prefactor.prm.bak
deleted file mode 100644
index ccb4c3f7163..00000000000
--- a/tests/visco_plastic_constant_viscosity_prefactor.prm.bak
+++ /dev/null
@@ -1,104 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_constant_viscosity_prefactor
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, bottom, left, right
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = weak_layer
-end
-
-# The compositional field is only present in the lower half of the model
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if (y<=50e3,1,0)
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    # Background and compositional field both have initial viscosity of 1e23 Pa s
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-24
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-
-    # The compositional field viscosity is reduced by a factor of 10 before yielding
-    set Constant viscosity prefactors = 1., 0.1
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = material properties
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/visco_plastic_derivatives_2d.cc.bak b/tests/visco_plastic_derivatives_2d.cc.bak
deleted file mode 100644
index 795ab6f89af..00000000000
--- a/tests/visco_plastic_derivatives_2d.cc.bak
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/simulator_access.h>
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/visco_plastic.h>
-#include <aspect/simulator_access.h>
-#include <aspect/newton.h>
-#include <aspect/parameters.h>
-
-#include <deal.II/grid/tria.h>
-#include <deal.II/base/exceptions.h>
-#include <memory>
-#include <functional>
-
-#include <iostream>
-
-template <int dim>
-void f(const aspect::SimulatorAccess<dim> &simulator_access,
-       aspect::Assemblers::Manager<dim> &,
-       std::string averaging_parameter)
-{
-
-  std::cout << std::endl << "Testing ViscoPlastic derivatives against analytical derivatives for averaging parameter " << averaging_parameter << std::endl;
-
-  using namespace aspect::MaterialModel;
-
-  // first set all material model values
-  MaterialModelInputs<dim> in_base(5,3);
-  in_base.composition[0][0] = 0;
-  in_base.composition[0][1] = 0;
-  in_base.composition[0][2] = 0;
-  in_base.composition[1][0] = 0.75;
-  in_base.composition[1][1] = 0.15;
-  in_base.composition[1][2] = 0.10;
-  in_base.composition[2][0] = 0;
-  in_base.composition[2][1] = 0.2;
-  in_base.composition[2][2] = 0.4;
-  in_base.composition[3][0] = 0;
-  in_base.composition[3][1] = 0.2;
-  in_base.composition[3][2] = 0.4;
-  in_base.composition[4][0] = 1;
-  in_base.composition[4][1] = 0;
-  in_base.composition[4][2] = 0;
-
-  in_base.temperature[0] = 293;
-  in_base.temperature[1] = 1600;
-  in_base.temperature[2] = 2000;
-  in_base.temperature[3] = 2100;
-  in_base.temperature[4] = 600;
-
-  in_base.pressure[0] = 1e9;
-  in_base.pressure[1] = 5e9;
-  in_base.pressure[2] = 2e10;
-  in_base.pressure[3] = 2e11;
-  in_base.pressure[4] = 5e8;
-
-  in_base.position[0] = Point<dim>();
-  in_base.position[1] = Point<dim>();
-  in_base.position[2] = Point<dim>();
-  in_base.position[3] = Point<dim>();
-  in_base.position[4] = Point<dim>();
-
-  /**
-   * We can't take too small strain-rates, because then the difference in the
-   * viscosity will be too small for the double accuracy which stores
-   * the viscosity solutions and the finite difference solution.
-   */
-  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
-  in_base.strain_rate[0][0][0] = 1e-12;
-  in_base.strain_rate[0][0][1] = 1e-12;
-  in_base.strain_rate[0][1][1] = 1e-11;
-
-  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[1][0][0] = -1.71266e-13;
-  in_base.strain_rate[1][0][1] = -5.82647e-12;
-  in_base.strain_rate[1][1][1] = 4.21668e-14;
-
-  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[2][1][1] = 1e-13;
-  in_base.strain_rate[2][0][1] = 1e-11;
-  in_base.strain_rate[2][0][0] = -1e-12;
-
-  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[3][1][1] = 4.9e-21;
-  in_base.strain_rate[3][0][1] = 4.9e-21;
-  in_base.strain_rate[3][0][0] = 4.9e-21;
-
-  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[4][1][1] = 1e-11;
-  in_base.strain_rate[4][0][1] = 1e-11;
-  in_base.strain_rate[4][0][0] = -1e-11;
-
-
-  // initialize some variables we will need later.
-  double finite_difference_accuracy = 1e-7;
-  double finite_difference_factor = 1+finite_difference_accuracy;
-
-
-  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
-
-  MaterialModelOutputs<dim> out_base(5,3);
-  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
-  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
-
-  // initialize the material we want to test.
-  aspect::ParameterHandler prm;
-
-  const aspect::MaterialModel::ViscoPlastic<dim> &const_material_model = dynamic_cast<const aspect::MaterialModel::ViscoPlastic<dim> &>(simulator_access.get_material_model());
-  aspect::MaterialModel::ViscoPlastic<dim> &material_model = const_cast<aspect::MaterialModel::ViscoPlastic<dim> &>(const_material_model);
-
-  material_model.declare_parameters(prm);
-
-  prm.enter_subsection("Material model");
-  {
-    prm.enter_subsection ("Visco Plastic");
-    {
-      prm.set ("Viscosity averaging scheme", averaging_parameter);
-      prm.set ("Angles of internal friction", "30");
-    }
-    prm.leave_subsection();
-  }
-  prm.leave_subsection();
-
-  const_cast<aspect::MaterialModel::Interface<dim> &>(simulator_access.get_material_model()).parse_parameters(prm);
-
-  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
-
-  simulator_access.get_material_model().evaluate(in_base, out_base);
-
-  // set up additional output for the derivatives
-  MaterialModelDerivatives<dim> *derivatives;
-  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
-  double temp;
-
-  // have a bool so we know whether the test has succeed or not.
-  bool Error = false;
-
-  // test the pressure derivative.
-  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
-  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
-
-  simulator_access.get_material_model().evaluate(in_dviscositydpressure, out_dviscositydpressure);
-
-  for (unsigned int i = 0; i < 5; i++)
-    {
-      // prevent division by zero. If it is zero, the test has passed, because or
-      // the finite difference and the analytical result match perfectly, or (more
-      // likely) the material model in independent of this variable.
-      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
-      if (in_base.pressure[i] != 0)
-        {
-          temp /= (in_base.pressure[i] * finite_difference_accuracy);
-        }
-      std::cout << "pressure: point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i]  << std::endl;
-      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
-        {
-          std::cout << "   Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
-          Error = true;
-        }
-
-    }
-
-  // test the strain-rate derivative.
-  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
-    {
-      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          // components that are not on the diagonal are multiplied by 0.5, because the symmetric tensor
-          // is modified by 0.5 in both symmetric directions (xy/yx) simultaneously and we compute the combined
-          // derivative
-          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
-                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
-                                                    * (component > dim-1 ? 0.5 : 1 )
-                                                    * finite_difference_accuracy
-                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
-        }
-
-
-      simulator_access.get_material_model().evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          // prevent division by zero. If it is zero, the test has passed, because or
-          // the finite difference and the analytical result match perfectly, or (more
-          // likely) the material model in independent of this variable.
-          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
-          if (temp != 0)
-            {
-              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
-            }
-          std::cout << "strain-rate: point = " << i << ", component = " << component << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
-          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
-            {
-              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
-              Error = true;
-            }
-
-        }
-
-    }
-
-  if (Error)
-    {
-      std::cout << "Some parts of the test were not successful." << std::endl;
-    }
-  else
-    {
-      std::cout << "OK" << std::endl;
-    }
-
-}
-
-template <>
-void f(const aspect::SimulatorAccess<3> &,
-       aspect::Assemblers::Manager<3> &,
-       std::string )
-{
-  AssertThrow(false,dealii::ExcInternalError());
-}
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  using namespace dealii;
-  std::cout << "* Connecting signals" << std::endl;
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2,
-                                            "harmonic"));
-
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2,
-                                            "geometric"));
-
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2,
-                                            "arithmetic"));
-
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2,
-                                            "maximum composition"));
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/visco_plastic_derivatives_2d.prm.bak b/tests/visco_plastic_derivatives_2d.prm.bak
deleted file mode 100644
index 841bc22c95a..00000000000
--- a/tests/visco_plastic_derivatives_2d.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# This test checks whether the derivatives of the drucker prager
-# material model are the same as the finite difference derivatives
-# created by the drucker prager material model.
-set Additional shared libraries = tests/libvisco_plastic_derivatives.so
-set Dimension                              = 2
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Adiabatic surface temperature          = 273
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);0;0
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Angles of internal friction = 30.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_derivatives_3d.cc.bak b/tests/visco_plastic_derivatives_3d.cc.bak
deleted file mode 100644
index f7432393b1b..00000000000
--- a/tests/visco_plastic_derivatives_3d.cc.bak
+++ /dev/null
@@ -1,289 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/simulator.h>
-#include <aspect/simulator_access.h>
-
-#include <aspect/material_model/interface.h>
-#include <aspect/material_model/visco_plastic.h>
-#include <aspect/simulator_access.h>
-#include <aspect/newton.h>
-#include <aspect/parameters.h>
-
-#include <deal.II/grid/tria.h>
-#include <deal.II/base/exceptions.h>
-#include <memory>
-#include <functional>
-
-#include <iostream>
-
-template <int dim>
-void f(const aspect::SimulatorAccess<dim> &simulator_access,
-       aspect::Assemblers::Manager<dim> &,
-       std::string averaging_parameter)
-{
-
-  std::cout << std::endl << "Testing ViscoPlastic derivatives against analytical derivatives for averaging parameter " << averaging_parameter << std::endl;
-
-  using namespace aspect::MaterialModel;
-
-  // first set all material model values
-  MaterialModelInputs<dim> in_base(5,3);
-  in_base.composition[0][0] = 0;
-  in_base.composition[0][1] = 0;
-  in_base.composition[0][2] = 0;
-  in_base.composition[1][0] = 0.75;
-  in_base.composition[1][1] = 0.15;
-  in_base.composition[1][2] = 0.10;
-  in_base.composition[2][0] = 0;
-  in_base.composition[2][1] = 0.2;
-  in_base.composition[2][2] = 0.4;
-  in_base.composition[3][0] = 0;
-  in_base.composition[3][1] = 0.2;
-  in_base.composition[3][2] = 0.4;
-  in_base.composition[4][0] = 1;
-  in_base.composition[4][1] = 0;
-  in_base.composition[4][2] = 0;
-
-  in_base.temperature[0] = 293;
-  in_base.temperature[1] = 1600;
-  in_base.temperature[2] = 2000;
-  in_base.temperature[3] = 2100;
-  in_base.temperature[4] = 600;
-
-  in_base.pressure[0] = 1e9;
-  in_base.pressure[1] = 5e9;
-  in_base.pressure[2] = 2e10;
-  in_base.pressure[3] = 2e11;
-  in_base.pressure[4] = 5e8;
-
-  in_base.position[0] = Point<dim>();
-  in_base.position[1] = Point<dim>();
-  in_base.position[2] = Point<dim>();
-  in_base.position[3] = Point<dim>();
-  in_base.position[4] = Point<dim>();
-
-  /**
-   * We can't take too small strain-rates, because then the difference in the
-   * viscosity will be too small for the double accuracy which stores
-   * the viscosity solutions and the finite difference solution.
-   */
-  in_base.strain_rate[0] = SymmetricTensor<2,dim>();
-  in_base.strain_rate[0][0][0] = 1e-12;
-  in_base.strain_rate[0][0][1] = 1e-12;
-  in_base.strain_rate[0][1][1] = 1e-11;
-  in_base.strain_rate[0][2][0] = 1e-12;
-  in_base.strain_rate[0][2][1] = 1e-12;
-  in_base.strain_rate[0][2][2] = 1e-11;
-
-  in_base.strain_rate[1] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[1][0][0] = -1.71266e-13;
-  in_base.strain_rate[1][0][1] = -5.82647e-12;
-  in_base.strain_rate[1][1][1] = 4.21668e-14;
-  in_base.strain_rate[1][2][0] = -5.42647e-12;
-  in_base.strain_rate[1][2][1] = -5.22647e-12;
-  in_base.strain_rate[1][2][2] = 4.21668e-14;
-
-  in_base.strain_rate[2] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[2][1][1] = 1e-13;
-  in_base.strain_rate[2][0][1] = 1e-11;
-  in_base.strain_rate[2][0][0] = -1e-12;
-  in_base.strain_rate[2][2][0] = 1e-11;
-  in_base.strain_rate[2][2][1] = 1e-11;
-  in_base.strain_rate[2][2][2] = -1e-12;
-
-  in_base.strain_rate[3] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[3][1][1] = 4.9e-21;
-  in_base.strain_rate[3][0][1] = 4.9e-21;
-  in_base.strain_rate[3][0][0] = 4.9e-21;
-  in_base.strain_rate[3][2][0] = 4.9e-21;
-  in_base.strain_rate[3][2][1] = 4.9e-21;
-  in_base.strain_rate[3][2][2] = 4.9e-21;
-
-  in_base.strain_rate[4] = SymmetricTensor<2,dim>(in_base.strain_rate[0]);
-  in_base.strain_rate[4][1][1] = 1e-11;
-  in_base.strain_rate[4][0][1] = 1e-11;
-  in_base.strain_rate[4][0][0] = -5e-12;
-  in_base.strain_rate[4][2][0] = 1e-11;
-  in_base.strain_rate[4][2][1] = 1e-11;
-  in_base.strain_rate[4][2][2] = -5e-12;
-
-
-  // initialize some variables we will need later.
-  double finite_difference_accuracy = 1e-7;
-  double finite_difference_factor = 1+finite_difference_accuracy;
-
-
-  MaterialModelInputs<dim> in_dviscositydstrainrate(in_base);
-
-  MaterialModelOutputs<dim> out_base(5,3);
-  MaterialModelOutputs<dim> out_dviscositydpressure(5,3);
-  MaterialModelOutputs<dim> out_dviscositydstrainrate(5,3);
-
-  // initialize the material we want to test.
-  aspect::ParameterHandler prm;
-
-  const aspect::MaterialModel::ViscoPlastic<dim> &const_material_model = dynamic_cast<const aspect::MaterialModel::ViscoPlastic<dim> &>(simulator_access.get_material_model());
-  aspect::MaterialModel::ViscoPlastic<dim> &material_model = const_cast<aspect::MaterialModel::ViscoPlastic<dim> &>(const_material_model);
-
-  material_model.declare_parameters(prm);
-
-  prm.enter_subsection("Material model");
-  {
-    prm.enter_subsection ("Visco Plastic");
-    {
-      prm.set ("Viscosity averaging scheme", averaging_parameter);
-      prm.set ("Angles of internal friction", "30");
-    }
-    prm.leave_subsection();
-  }
-  prm.leave_subsection();
-
-  const_cast<aspect::MaterialModel::Interface<dim> &>(simulator_access.get_material_model()).parse_parameters(prm);
-
-  out_base.additional_outputs.push_back(std::make_unique<MaterialModelDerivatives<dim>> (5));
-
-  simulator_access.get_material_model().evaluate(in_base, out_base);
-
-  // set up additional output for the derivatives
-  MaterialModelDerivatives<dim> *derivatives;
-  derivatives = out_base.template get_additional_output<MaterialModelDerivatives<dim>>();
-  double temp;
-
-  // have a bool so we know whether the test has succeed or not.
-  bool Error = false;
-
-  // test the pressure derivative.
-  MaterialModelInputs<dim> in_dviscositydpressure(in_base);
-  in_dviscositydpressure.pressure[0] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[1] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[2] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[3] *= finite_difference_factor;
-  in_dviscositydpressure.pressure[4] *= finite_difference_factor;
-
-  simulator_access.get_material_model().evaluate(in_dviscositydpressure, out_dviscositydpressure);
-
-  for (unsigned int i = 0; i < 5; i++)
-    {
-      // prevent division by zero. If it is zero, the test has passed, because or
-      // the finite difference and the analytical result match perfectly, or (more
-      // likely) the material model in independent of this variable.
-      temp = (out_dviscositydpressure.viscosities[i] - out_base.viscosities[i]);
-      if (in_base.pressure[i] != 0)
-        {
-          temp /= (in_base.pressure[i] * finite_difference_accuracy);
-        }
-      std::cout << "pressure: point = " << i << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_pressure[i]  << std::endl;
-      if (std::fabs(temp - derivatives->viscosity_derivative_wrt_pressure[i]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_pressure[i])))
-        {
-          std::cout << "   Error: The derivative of the viscosity to the pressure is too different from the analytical value." << std::endl;
-          Error = true;
-        }
-
-    }
-
-  // test the strain-rate derivative.
-  for (unsigned int component = 0; component < SymmetricTensor<2,dim>::n_independent_components; ++component)
-    {
-      const TableIndices<2> strain_rate_indices = SymmetricTensor<2,dim>::unrolled_to_component_indices (component);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          // components that are not on the diagonal are multiplied by 0.5, because the symmetric tensor
-          // is modified by 0.5 in both symmetric directions (xy/yx) simultaneously and we compute the combined
-          // derivative
-          in_dviscositydstrainrate.strain_rate[i] = in_base.strain_rate[i]
-                                                    + std::fabs(in_base.strain_rate[i][strain_rate_indices])
-                                                    * (component > dim-1 ? 0.5 : 1 )
-                                                    * finite_difference_accuracy
-                                                    * aspect::Utilities::nth_basis_for_symmetric_tensors<dim>(component);
-        }
-
-
-      simulator_access.get_material_model().evaluate(in_dviscositydstrainrate, out_dviscositydstrainrate);
-
-      for (unsigned int i = 0; i < 5; i++)
-        {
-          // prevent division by zero. If it is zero, the test has passed, because or
-          // the finite difference and the analytical result match perfectly, or (more
-          // likely) the material model in independent of this variable.
-          temp = out_dviscositydstrainrate.viscosities[i] - out_base.viscosities[i];
-          if (temp != 0)
-            {
-              temp /= std::fabs(in_dviscositydstrainrate.strain_rate[i][strain_rate_indices]) * finite_difference_accuracy;
-            }
-          std::cout << "strain-rate: point = " << i << ", component = " << component << ", Finite difference = " << temp << ", Analytical derivative = " << derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]  << std::endl;
-          if (std::fabs(temp - derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices]) > 1e-3 * (std::fabs(temp) + std::fabs(derivatives->viscosity_derivative_wrt_strain_rate[i][strain_rate_indices])))
-            {
-              std::cout << "   Error: The derivative of the viscosity to the strain rate is too different from the analytical value." << std::endl;
-              Error = true;
-            }
-
-        }
-
-    }
-
-  if (Error)
-    {
-      std::cout << "Some parts of the test were not successful." << std::endl;
-    }
-  else
-    {
-      std::cout << "OK" << std::endl;
-    }
-
-}
-
-template <>
-void f(const aspect::SimulatorAccess<2> &,
-       aspect::Assemblers::Manager<2> &,
-       std::string )
-{
-  AssertThrow(false,dealii::ExcInternalError());
-}
-
-template <int dim>
-void signal_connector (aspect::SimulatorSignals<dim> &signals)
-{
-  using namespace dealii;
-  std::cout << "* Connecting signals" << std::endl;
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2,
-                                            "harmonic"));
-
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2,
-                                            "geometric"));
-
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2,
-                                            "arithmetic"));
-
-  signals.set_assemblers.connect (std::bind(&f<dim>,
-                                            std::placeholders::_1,
-                                            std::placeholders::_2,
-                                            "maximum composition"));
-}
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
diff --git a/tests/visco_plastic_derivatives_3d.prm.bak b/tests/visco_plastic_derivatives_3d.prm.bak
deleted file mode 100644
index 68114301dc3..00000000000
--- a/tests/visco_plastic_derivatives_3d.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# This test checks whether the derivatives of the drucker prager
-# material model are the same as the finite difference derivatives
-# created by the drucker prager material model.
-set Additional shared libraries = tests/libvisco_plastic_derivatives.so
-set Dimension                              = 3
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Adiabatic surface temperature          = 273
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 3
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);0;0
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Angles of internal friction = 30.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_diffusion.prm.bak b/tests/visco_plastic_diffusion.prm.bak
deleted file mode 100644
index 5199e9f5960..00000000000
--- a/tests/visco_plastic_diffusion.prm.bak
+++ /dev/null
@@ -1,110 +0,0 @@
-# A test for diffusion creep in the visco_plastic material model.
-# The diffusion creep viscosity is defined as:
-#   0.5 * A^(-1/n) * d^(m/n) * exp((E + P*V)/(nRT)), with
-#   A = 2.37e-15, n = 1, d = 1e-3, m = 3, E = 375.e3,
-#   V = 10e-6, P = 3e9, T = 1573 and R = 8.3144598.
-# Using these values, the computed viscosity should be
-#   ~ 5.9266e18 Pa s.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 3.e9
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1573
-    set Left temperature   = 1573
-    set Right temperature  = 1573
-    set Top temperature    = 1573
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = mm=0.001, year=1
-    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1573
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = diffusion
-    set Grain size = 1.e-3
-    set Grain size exponents for diffusion creep = 3.
-    set Prefactors for diffusion creep = 2.37e-15
-    set Activation energies for diffusion creep = 375.e3
-    set Activation volumes for diffusion creep = 10.e-6
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_diffusion_dislocation_composite.prm.bak b/tests/visco_plastic_diffusion_dislocation_composite.prm.bak
deleted file mode 100644
index 6d698882f81..00000000000
--- a/tests/visco_plastic_diffusion_dislocation_composite.prm.bak
+++ /dev/null
@@ -1,116 +0,0 @@
-# A test for composite creep in the visco_plastic material model.
-# The composite creep viscosity (vis_composite) is defined as:
-#   (vis_diffusion * vis_dislocation)/(vis_diffusion + vis_dislocation)
-# The diffusion and dislocation creep viscosity values are, respectively,
-# ~ 5.9266e18 Pa s and ~ 4.4592e20 Pa s. For more information on how these
-# values are calculated, see tests visco_plastic_diffusion and
-# visco_plastic_dislocation.
-# Using these values, the composite viscosity should be:
-#   ~ 5.8488e18 Pa s.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 3.e9
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1573
-    set Left temperature   = 1573
-    set Right temperature  = 1573
-    set Top temperature    = 1573
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = mm=0.001, year=1
-    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1573
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = composite
-    set Grain size = 1.e-3
-    set Grain size exponents for diffusion creep = 3.
-    set Prefactors for diffusion creep = 2.37e-15
-    set Activation energies for diffusion creep = 375.e3
-    set Activation volumes for diffusion creep = 10.e-6
-    set Prefactors for dislocation creep = 6.52e-16
-    set Stress exponents for dislocation creep = 3.5
-    set Activation energies for dislocation creep = 530.e3
-    set Activation volumes for dislocation creep = 18.e-6
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_dislocation.prm.bak b/tests/visco_plastic_dislocation.prm.bak
deleted file mode 100644
index 15fc1186c55..00000000000
--- a/tests/visco_plastic_dislocation.prm.bak
+++ /dev/null
@@ -1,109 +0,0 @@
-# A test for dislocation creep in the visco_plastic material model.
-# The dislocation creep viscosity is defined as:
-#   0.5 * A^(-1/n) * edot_ii^((1-n)/n) * exp((E + P*V)/(nRT)), with
-#   A = 6.52e-16, n = 3.5, edot_ii = 3.16887e-16, E = 530.e3,
-#   V = 18e-6, P = 3e9, T = 1573 and R = 8.3144598.
-# Using these values, the computed viscosity should be
-#   ~ 4.4592e20 Pa s.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 3.e9
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1573
-    set Left temperature   = 1573
-    set Right temperature  = 1573
-    set Top temperature    = 1573
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = mm=0.001, year=1
-    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1573
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 6.52e-16
-    set Stress exponents for dislocation creep = 3.5
-    set Activation energies for dislocation creep = 530.e3
-    set Activation volumes for dislocation creep = 18.e-6
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_frank_kamenetskii.prm.bak b/tests/visco_plastic_frank_kamenetskii.prm.bak
deleted file mode 100644
index f005ed25519..00000000000
--- a/tests/visco_plastic_frank_kamenetskii.prm.bak
+++ /dev/null
@@ -1,107 +0,0 @@
-# A test for Frank Kamenetskii rheology in the visco_plastic material model.
-# Frank-Kamenetskii viscosity approximation:
-# viscosity = A * exp(E * 0.5 * (1.0-(T/ref_T)))
-# A: 1.e21, E: 15., ref_T: 1573
-# Using these values, the computed viscosity should be
-#   ~ 1e21 Pa s.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1573.
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1573
-    set Left temperature   = 1573
-    set Right temperature  = 1573
-    set Top temperature    = 1573
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = mm=0.001, year=1
-    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1573
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = frank kamenetskii
-    set Viscosity ratios for Frank Kamenetskii = 15.
-    set Prefactors for Frank Kamenetskii = 1.e21
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_frank_kamenetskii_pressure.prm.bak b/tests/visco_plastic_frank_kamenetskii_pressure.prm.bak
deleted file mode 100644
index 1e60e8f1902..00000000000
--- a/tests/visco_plastic_frank_kamenetskii_pressure.prm.bak
+++ /dev/null
@@ -1,108 +0,0 @@
-# A test for Frank Kamenetskii rheology in the visco_plastic material model.
-# Frank-Kamenetskii viscosity approximation:
-# viscosity = A * exp(E * 0.5 * (1.0-(T/ref_T)) + F * (P-ref_P)/(ref_rho*g*h))
-# A: 1.e21, E: 15., ref_T: 1573, F: 2., ref_P = 0
-# Using these values, the computed viscosity at the model surface (P = ref_P = 0) should be
-#   ~ 1e21 Pa s.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 0
-set Adiabatic surface temperature          = 1573.
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1573
-    set Left temperature   = 1573
-    set Right temperature  = 1573
-    set Top temperature    = 1573
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = mm=0.001, year=1
-    set Function expression = if (x<50e3 , -0.5*mm/year, 0.5*mm/year); if (y<50e3 , 0.5*mm/year, -0.5*mm/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1573
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = frank kamenetskii
-    set Viscosity ratios for Frank Kamenetskii = 15.
-    set Prefactors for Frank Kamenetskii = 1.e21
-    set Pressure prefactors for Frank Kamenetskii = 2.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_friction_function.prm.bak b/tests/visco_plastic_friction_function.prm.bak
deleted file mode 100644
index 4473ce482ea..00000000000
--- a/tests/visco_plastic_friction_function.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-# A quadratic box where the friction angle is
-# given as a function dependent of space and time.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 3
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_friction_function
-set Timing output frequency                = 1
-set Maximum time step                      = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name      = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0; 0;
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate                     = 1.e-16
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5.e-23
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Yield mechanism                           = drucker
-    set Angles of internal friction               = 0.
-    set Cohesions                                 = 1.e6
-
-    # these are the lines you need to use the friction function
-    set Friction mechanism                        = function
-
-    subsection Friction function
-      set Coordinate system                       = cartesian
-      set Variable names                          = x,y,t
-      set Function expression                     = if(x>0 ,if(t <2 ,0, 30), 15)
-    end
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name  = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_gerya_2019_vp.prm.bak b/tests/visco_plastic_gerya_2019_vp.prm.bak
deleted file mode 100644
index e78b2a592c5..00000000000
--- a/tests/visco_plastic_gerya_2019_vp.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# This parameter file modifies the benchmark gerya_2019_vp.prm
-# to use a coarser resolution
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm
-
-
-#  Global parameters
-set Dimension                              = 2
-set Max nonlinear iterations               = 2
-set Output directory                       = visco_plastic_gerya_2019_vp
-
-# Reduce the number of global refinements from 5 to 3
-subsection Mesh refinement
-  set Initial global refinement          = 3
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, material statistics, velocity statistics
-  set Run postprocessors on nonlinear iterations = false
-end
diff --git a/tests/visco_plastic_newton_nonlinear_channelflow.prm.bak b/tests/visco_plastic_newton_nonlinear_channelflow.prm.bak
deleted file mode 100644
index 2edc307f674..00000000000
--- a/tests/visco_plastic_newton_nonlinear_channelflow.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# Like the poiseuille_2d.prm test and based on the nonlinear channel
-# flow benchmark. This is used to test the velocity boundary conditions
-# of the Newton Stokes solver.
-
-set Output directory = vp_input_v_2_new
-set Dimension = 2
-set CFL number                             = 1.0
-set Maximum time step                      = 1
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 1
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme = iterated Advection and Newton Stokes
-set Max nonlinear iterations = 150
-set Nonlinear solver tolerance = 5e-12
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-5
-    set Stokes solver type = block AMG
-  end
-
-  subsection Newton solver parameters
-    set Max pre-Newton nonlinear iterations = 10
-    set Nonlinear Newton solver switch tolerance = 1e-20
-    set Max Newton line search iterations = 0
-    set Maximum linear Stokes solver tolerance = 1e-2
-    set Use Newton residual scaling method = false
-    set Use Newton failsafe = false
-    set Stabilization preconditioner = SPD
-    set Stabilization velocity block = SPD
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Left temperature = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 10e3
-    set Y extent = 8e3
-    set Y repetitions = 1
-  end
-end
-
-subsection Material model
-  set Model name = visco plastic
-  set Material averaging = none
-
-  subsection Visco Plastic
-    set Viscous flow law = dislocation
-    set Minimum viscosity = 1e19
-    set Maximum viscosity = 1e24
-    set Prefactors for diffusion creep = 1
-    set Prefactors for dislocation creep = 1e-37
-    set Grain size exponents for diffusion creep = 0
-    set Activation energies for diffusion creep = 0
-    set Activation energies for dislocation creep = 0
-    set Activation volumes for diffusion creep = 0
-    set Activation volumes for dislocation creep = 0
-    set Stress exponents for dislocation creep = 3
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = 0, 1
-  set Prescribed velocity boundary indicators = 2: function, 3: function # velocity bc
-
-  subsection Function
-    set Function constants = n = 3
-    set Variable names = x,z
-
-    # For velocity boundary conditions both are used, for pressure boundary conditions only the first (x) component
-    set Function expression = 0;(1e-37/(n+1))*((1e9/8e3)^n)*(((5e3)^(n+1))-(abs(x-(5e3))^(n+1)));
-  end
-end
-
-subsection Boundary traction model
-  subsection Function
-    set Variable names = x,z
-
-    # We want to prescribe a pressure of 2 at the left boundary
-    # and -2 at the right boundary.
-    # The traction in this case is defined as:
-    # tau =  - pressure * normal_vector.
-    # On the left boundary, the outward pointing normal vector is
-    # (-1;0). On the right (1;0).
-    # Therefore:
-    # Left boundary:  tau = - pressure(left) (-1;0) = - (2) (-1;0) = (2;0).
-    # Right boundary: tau = - pressure(right) (1;0) = - (-2) (1;0) = (2;0).
-    # Conveniently, the traction is the same on both boundaries.
-    set Function expression = 0;if(z>0,0,1e9)
-  end
-end
diff --git a/tests/visco_plastic_peierls_cutoff_test.prm.bak b/tests/visco_plastic_peierls_cutoff_test.prm.bak
deleted file mode 100644
index 215594cc155..00000000000
--- a/tests/visco_plastic_peierls_cutoff_test.prm.bak
+++ /dev/null
@@ -1,100 +0,0 @@
-# A test for the exact Peierls creep flow law
-# with the visco_plastic material model.
-# Following the general Peierls creep flow law of Idrissi
-# et al. 2016 and assuming a stress of 100 Pa. Idrissi
-# has stress exponent = 0 so that strain rate does not
-# go to 0 as stress goes to 0. To allow for convergence
-# approximate strain rate below a cutoff stress of 1000 Pa
-# as a quadratic function of stress.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 3.e2
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# No boundary-driven deformation, but the strain-rate used by the material
-# model is set in the material model section through the parameters
-# "Reference strain rate" and "Minimum strain rate".
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1073
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate                     = 9.576747017313619e-11
-    set Minimum strain rate                       = 9.576747017313619e-11
-
-    # dislocation creep parameters
-    # These values produce such a sufficiently high viscosity that the
-    # composite viscosity between the diffusion and dislocation creep
-    # is effectively equal to the Peierls creep viscosity.
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep          = 1.e-50
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0
-    set Activation volumes for dislocation creep  = 0
-
-    # Peierls creep parameters
-    set Include Peierls creep                     = true
-    set Peierls creep flow law                    = exact
-    set Prefactors for Peierls creep              = 1e6
-    set Activation energies for Peierls creep     = 566.e3
-    set Activation volumes for Peierls creep      = 0.
-    set Peierls stresses                          = 3.8e9
-    set Stress exponents for Peierls creep        = 0.0
-    set Peierls fitting parameters                = 0.15
-    set Peierls glide parameters p                = 0.5
-    set Peierls glide parameters q                = 2.0
-    set Peierls strain rate residual tolerance    = 1e-12
-    set Maximum Peierls strain rate iterations    = 40
-    set Cutoff stresses for Peierls creep         = 1000
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = material statistics
-end
diff --git a/tests/visco_plastic_peierls_idrissi_exact.prm.bak b/tests/visco_plastic_peierls_idrissi_exact.prm.bak
deleted file mode 100644
index 400d651f3b8..00000000000
--- a/tests/visco_plastic_peierls_idrissi_exact.prm.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-# A test for the exact Peierls creep flow law
-# with the visco_plastic material model.
-# Following the general Peierls creep flow law of Idrissi
-# et al. 2016 and assuming a stress of 1.092890e8 Pa (strain rate is 1e-13 s^(-1)), the
-# exact viscosity is calculated in python through:
-#  import numpy as np
-#  A    = 1e6     # Peierls creep prefactor 1/s 1/Pa^2
-#  R    = 8.314   # gas constant [J/mol*K]
-#  T    = 1073    # temperature [K]
-#  sig  = 1.092890e8 # stress [Pa]
-#  sigp = 3.8e9   # Peierls creep stress [Pa]
-#  E    = 566e3   # Peierls creep activation energy [J/mol]
-#  V    = 0       # Peierls creep activation volume
-#  P    = 0       # Pressure (Pa)
-#  n    = 0       # Peierls creep stress exponent
-#  p    = 0.5     # First slide parameter
-#  q    = 2       # Second glide parameter
-#
-#  Strain rate invariant:
-#    edot_ii = A*np.power(sig,n)*np.exp(-(E/(R*T))*np.power( (1-np.power((sig/sigp),p) ),q) )
-#            = 1.000000e-13
-#
-#  Viscosity:
-#    visc = 0.5*sig/edot_ii = 5.464448e20
-#
-# The material model should return this viscosity.
-# The strain rate invariant (edot_ii) above is manually set in the material
-# model subsection.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 3.e9
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# No boundary-driven deformation, but the strain-rate used by the material
-# model is set in the material model section through the parameters
-# "Reference strain rate" and "Minimum strain rate".
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-# Initial temperature conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1073
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate                     = 1e-13
-    set Minimum strain rate                       = 1e-13
-
-    # dislocation creep parameters
-    # These values produce such a sufficiently high viscosity that the
-    # composite viscosity between the diffusion and dislocation creep
-    # is effectively equal to the Peierls creep viscosity.
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep          = 1.e-50
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0
-    set Activation volumes for dislocation creep  = 0
-
-    # Peierls creep parameters
-    set Include Peierls creep                     = true
-    set Peierls creep flow law                    = exact
-    set Prefactors for Peierls creep              = 1e6
-    set Activation energies for Peierls creep     = 566.e3
-    set Activation volumes for Peierls creep      = 0.
-    set Peierls stresses                          = 3.8e9
-    set Stress exponents for Peierls creep        = 0.0
-    set Peierls fitting parameters                = 0.15
-    set Peierls glide parameters p                = 0.5
-    set Peierls glide parameters q                = 2.0
-    set Peierls strain rate residual tolerance    = 1e-6
-    set Maximum Peierls strain rate iterations    = 40
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = material statistics
-end
diff --git a/tests/visco_plastic_peierls_mei_exact.prm.bak b/tests/visco_plastic_peierls_mei_exact.prm.bak
deleted file mode 100644
index f4ef1471c41..00000000000
--- a/tests/visco_plastic_peierls_mei_exact.prm.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-# A test for the exact Peierls creep flow law
-# with the visco_plastic material model.
-# Following the general Peierls creep flow law of Mei
-# et al. 2010 and assuming a stress of 900e6 Pa, the
-# exact viscosity is calculated in python through:
-#  import numpy as np
-#  A    = 1.4e-7/np.power(1e6,2) # Peierls creep prefactor 1/s 1/Pa^2
-#  R    = 8.314   # gas constant [J/mol*K]
-#  T    = 1073    # temperature [K]
-#  sig  = 1000e6  # stress [Pa]
-#  sigp = 5.9e9   # Peierls creep stress [Pa]
-#  E    = 320e3   # Peierls creep activation energy [J/mol]
-#  V    = 0       # Peierls creep activation volume
-#  P    = 0       # Pressure (Pa)
-#  n    = 2       # Peierls creep stress exponent
-#  p    = 0.5     # First slide parameter
-#  q    = 1       # Second glide parameter
-#
-#  Strain rate invariant:
-#    edot_ii = A*np.power(sig,n)*np.exp(-(E/(R*T))*np.power( (1-np.power((sig/sigp),p) ),q) )
-#            = 9.576747017313619e-11
-#
-#  Viscosity:
-#    visc = 0.5*sig/edot_ii = 5.22097951523685e+18
-#
-# The material model should return this viscosity.
-# The strain rate invariant (edot_ii) above is manually set in the material
-# model subsection.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 3.e9
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# No boundary-driven deformation, but the strain-rate used by the material
-# model is set in the material model section through the parameters
-# "Reference strain rate" and "Minimum strain rate".
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-# Initial temperature conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1073
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate                     = 9.576747017313619e-11
-    set Minimum strain rate                       = 9.576747017313619e-11
-
-    # dislocation creep parameters
-    # These values produce such a sufficiently high viscosity that the
-    # composite viscosity between the diffusion and dislocation creep
-    # is effectively equal to the Peierls creep viscosity.
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep          = 1.e-50
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0
-    set Activation volumes for dislocation creep  = 0
-
-    # Peierls creep parameters
-    set Include Peierls creep                     = true
-    set Peierls creep flow law                    = exact
-    set Prefactors for Peierls creep              = 1.4e-19
-    set Activation energies for Peierls creep     = 320.e3
-    set Activation volumes for Peierls creep      = 0.
-    set Peierls stresses                          = 5.9e9
-    set Stress exponents for Peierls creep        = 2.0
-    set Peierls fitting parameters                = 0.15
-    set Peierls glide parameters p                = 0.5
-    set Peierls glide parameters q                = 1.0
-    set Peierls strain rate residual tolerance    = 1e-12
-    set Maximum Peierls strain rate iterations    = 40
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = material statistics
-end
diff --git a/tests/visco_plastic_peierls_mei_viscosity_approx.prm.bak b/tests/visco_plastic_peierls_mei_viscosity_approx.prm.bak
deleted file mode 100644
index 40ba99bfaf3..00000000000
--- a/tests/visco_plastic_peierls_mei_viscosity_approx.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-# A test for the peierls creep viscosity approximation
-# with the visco_plastic material model.
-# Following the general Peierls creep flow law of Mei
-# et al. 2010 and assuming a stress of 900e6 Pa, the
-# exact viscosity is calculated in python through:
-#  import numpy as np
-#  A    = 1.4e-7/np.power(1e6,2) # Peierls creep prefactor 1/s 1/Pa^2
-#  R    = 8.314   # gas constant [J/mol*K]
-#  T    = 1073    # temperature [K]
-#  sig  = 1000e6  # stress [Pa]
-#  sigp = 5.9e9   # Peierls creep stress [Pa]
-#  E    = 320e3   # Peierls creep activation energy [J/mol]
-#  V    = 0       # Peierls creep activation volume
-#  P    = 0       # Pressure (Pa)
-#  n    = 2       # Peierls creep stress exponent
-#  p    = 0.5     # First slide parameter
-#  q    = 1       # Second glide parameter
-#
-#  Strain rate invariant:
-#    edot_ii = A*np.power(sig,n)*np.exp(-(E/(R*T))*np.power( (1-np.power((sig/sigp),p) ),q) )
-#            = 9.576747017313619e-11
-#
-#  Viscosity:
-#    visc = 0.5*sig/edot_ii = 5.22097951523685e+18
-#
-#  Fitting parameters for approximated viscosity:
-#    gamma = 0.15 # fitting parameter
-#
-#  Recalculate strain rate
-#    edot_ii = A*np.power(sig,n)*np.exp(-(E/(R*T))*np.power((1 - np.power(gamma,p)),q))*np.power(sig/(gamma*sigp),s)
-#            = 9.326722654162315e-11
-#
-#  Exponential term in Peierls creep viscosity approximation
-#    s =  p*q*np.power(g,p)*np.power((1-np.power(g,p)),q-1)*(E/(R*T))
-#
-#  # Approximated viscosity
-#    visca = 0.5*gamma*sigp/np.power(A*np.power(gamma*sigp,n),1/(s+n))*np.power(edot_ii,(1/(s+n))-1)*np.exp((E/(R*T))*np.power((1 - np.power(gamma,p)),q)/(s+n))
-#          = 5.360939941500902e+18
-#
-# The material model should return the above value of the approximated viscosity.
-# The strain rate invariant (edot_ii) above is manually set in the material
-# model subsection.
-
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_peierls_mei_exact.prm
-
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate                     = 9.326722654162315e-11
-    set Minimum strain rate                       = 9.326722654162315e-11
-
-    # dislocation creep parameters
-    # These values produce such a sufficiently high viscosity that the
-    # composite viscosity between the diffusion and dislocation creep
-    # is effectively equal to the Peierls creep viscosity.
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep          = 1.e-50
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0
-    set Activation volumes for dislocation creep  = 0
-
-    # Peierls creep parameters
-    set Include Peierls creep                     = true
-    set Peierls creep flow law                    = viscosity approximation
-    set Prefactors for Peierls creep              = 1.4e-19
-    set Activation energies for Peierls creep     = 320.e3
-    set Activation volumes for Peierls creep      = 0.
-    set Peierls stresses                          = 5.9e9
-    set Stress exponents for Peierls creep        = 2.0
-    set Peierls fitting parameters                = 0.15
-    set Peierls glide parameters p                = 0.5
-    set Peierls glide parameters q                = 1.0
-  end
-end
diff --git a/tests/visco_plastic_peierls_strict_cutoff_test.prm.bak b/tests/visco_plastic_peierls_strict_cutoff_test.prm.bak
deleted file mode 100644
index 146b02a23ce..00000000000
--- a/tests/visco_plastic_peierls_strict_cutoff_test.prm.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-# A test for the exact Peierls creep flow law
-# with the visco_plastic material model.
-# Following the general Peierls creep flow law of Idrissi
-# et al. 2016 and assuming a strain rate of 1e-15 s^-1. The stress
-# from the Peierls rheology is limited by the cutoff stress
-# of 1000 Pa, so a viscosity of 5e17 Pa*s is computed instead
-# from:
-#     1000 / 1e-15 / 2.0 = 5e17
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Surface pressure                       = 3.e2
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# No boundary-driven deformation, but the strain-rate used by the material
-# model is set in the material model section through the parameters
-# "Reference strain rate" and "Minimum strain rate".
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1673
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate                     = 1e-15
-    set Minimum strain rate                       = 1e-15
-
-    # dislocation creep parameters
-    # These values produce such a sufficiently high viscosity that the
-    # composite viscosity between the diffusion and dislocation creep
-    # is effectively equal to the Peierls creep viscosity.
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep          = 1.e-50
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0
-    set Activation volumes for dislocation creep  = 0
-
-    # Peierls creep parameters
-    set Include Peierls creep                     = true
-    set Peierls creep flow law                    = exact
-    set Prefactors for Peierls creep              = 1e6
-    set Activation energies for Peierls creep     = 566.e3
-    set Activation volumes for Peierls creep      = 0.
-    set Peierls stresses                          = 3.8e9
-    set Stress exponents for Peierls creep        = 0.0
-    set Peierls fitting parameters                = 0.15
-    set Peierls glide parameters p                = 0.5
-    set Peierls glide parameters q                = 2.0
-    set Peierls strain rate residual tolerance    = 1e-22
-    set Maximum Peierls strain rate iterations    = 40
-    set Cutoff stresses for Peierls creep         = 1000
-    set Apply strict stress cutoff for Peierls creep = true
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = material statistics
-end
diff --git a/tests/visco_plastic_phases.prm.bak b/tests/visco_plastic_phases.prm.bak
deleted file mode 100644
index 82b24b5dfe4..00000000000
--- a/tests/visco_plastic_phases.prm.bak
+++ /dev/null
@@ -1,106 +0,0 @@
-# Copy of visco_plastic.prm, but include a phase transition for the EoS
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Phase transition depths = 50e3
-    set Phase transition widths = 1e3
-    set Phase transition temperatures = 273
-    set Phase transition Clapeyron slopes = 0
-    set Densities = background:3300|3400
-    set Thermal expansivities = background:3.5e-5|2e-5
-    set Heat capacities = background:1200|1000
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = material properties
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_phases_compositions.prm.bak b/tests/visco_plastic_phases_compositions.prm.bak
deleted file mode 100644
index 2ad5384b058..00000000000
--- a/tests/visco_plastic_phases_compositions.prm.bak
+++ /dev/null
@@ -1,123 +0,0 @@
-# Copy of visco_plastic_phases.prm, but include multiple
-# compositions and have different numbers of phase transitions
-# for different compositions (including 0).
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-
-  # background is assumed to be lithosphere
-  set Names of fields  = upper_crust, lower_crust
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = (y > 80000) ? 1.0 : 0.0; \
-                              (y > 50000) ? ((y <= 80000) ? 1.0 : 0.0) : 0.0
-  end
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Phase transition depths = upper_crust: 10e3, background: 70e3|90e3
-    set Phase transition widths = upper_crust: 1e3,background: 1e3|1e3
-    set Phase transition temperatures = upper_crust: 1000, background: 1000|1000
-    set Phase transition Clapeyron slopes = upper_crust: 0, background: 0|0
-    set Densities = upper_crust: 2700|2750, lower_crust: 2850, background:3300|3400|3500
-    set Thermal expansivities = upper_crust: 1e-5|1.5e-5, lower_crust: 7e-5, background:3.5e-5|2e-5|1e-5
-    set Heat capacities = upper_crust: 900|800, lower_crust: 600, background:1200|1000|700
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = material properties
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_phases_peierls_mei_exact.prm.bak b/tests/visco_plastic_phases_peierls_mei_exact.prm.bak
deleted file mode 100644
index 3804c4fab33..00000000000
--- a/tests/visco_plastic_phases_peierls_mei_exact.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# This test is a copy of visco_plastic_peierls_mei_viscosity_exact.prm
-# but one in which phase transitions take place within the domain.
-# The viscosities, densities, thermal expansivities and heat capacities
-# change within the domain.
-
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_peierls_mei_exact.prm
-
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = right
-  set Compositional field methods = field
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set List of model operators = add
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y
-    set Function constants = XMAX=100e3
-    set Function expression = (x>XMAX/2.0) ? 1.0 : 0.0
-  end
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Phase transition depths = background:50e3|75e3, right:50e3|75e3
-    set Phase transition widths = background:1e3|1e3, right:1e3|1e3
-    set Phase transition temperatures = background:273|273, right:273|273
-    set Phase transition Clapeyron slopes = background:0|0, right:0|0
-    set Densities = background:3300|3400|3500, right:3600|3700|3800
-    set Thermal expansivities = background:3.5e-5|2e-5|1.5e-5, right:3.5e-5|2e-5|1.5e-5
-    set Heat capacities = background:1200|1000|900, right:1200|1000|900
-    set Reference strain rate                     = 9.326722654162315e-11
-    set Minimum strain rate                       = 9.326722654162315e-11
-
-    # dislocation creep parameters
-    # These values produce such a sufficiently high viscosity that the
-    # composite viscosity between the diffusion and dislocation creep
-    # is effectively equal to the Peierls creep viscosity.
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep          = background:1e-50|1e-50|1e-50, right:1e-50|1e-50|1e-50
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0
-    set Activation volumes for dislocation creep  = 0
-
-    # Peierls creep parameters
-    set Include Peierls creep                     = true
-    set Peierls creep flow law                    = exact
-    set Prefactors for Peierls creep              = background:2.8e-19|1.4e-19|0.7e-19, right:2.8e-18|1.4e-18|0.7e-18
-    set Activation energies for Peierls creep     = 320.e3
-    set Activation volumes for Peierls creep      = 0.
-    set Peierls stresses                          = 5.9e9
-    set Stress exponents for Peierls creep        = 2.0
-    set Peierls fitting parameters                = 0.15
-    set Peierls glide parameters p                = 0.5
-    set Peierls glide parameters q                = 1.0
-    set Peierls strain rate residual tolerance    = 1e-12
-    set Maximum Peierls strain rate iterations    = 40
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set List of output variables = material properties
-    set Time between graphical output = 0
-    set Number of grouped files       = 0
-
-    subsection Material properties
-      set List of material properties = density, thermal expansivity, specific heat, viscosity
-    end
-  end
-end
diff --git a/tests/visco_plastic_phases_plasticity.prm.bak b/tests/visco_plastic_phases_plasticity.prm.bak
deleted file mode 100644
index 7caa29ebabc..00000000000
--- a/tests/visco_plastic_phases_plasticity.prm.bak
+++ /dev/null
@@ -1,111 +0,0 @@
-# Copy of visco_plastic_phases.prm, but tests different plasticity parameters for different phases.
-# Above the 50km depth phase transition we set 10MPa and 20 degrees for the cohesion and internal friction angle.
-# Below the 50km depth phase transition plastic yielding is switched off by setting a high cohesion of 1e20, and friction changes to 0.
-# This is visible in the visualization output.
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_phases_plasticity
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Phase transition depths = 50e3
-    set Phase transition widths = 1e3
-    set Phase transition temperatures = 273
-    set Phase transition Clapeyron slopes = 0
-    set Densities = background:3300|3400
-    set Thermal expansivities = background:3.5e-5|2e-5
-    set Heat capacities = background:1200|1000
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Angles of internal friction = background: 20 | 0
-    set Cohesions                   = background: 1e7 | 1e20
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = material properties, named additional outputs
-    set Output format = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_phases_temperature_limit_basalt.prm.bak b/tests/visco_plastic_phases_temperature_limit_basalt.prm.bak
deleted file mode 100644
index 1029c6da674..00000000000
--- a/tests/visco_plastic_phases_temperature_limit_basalt.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-# This test uses a similar setup as visco_plastic.prm and includes the phase transitions
-# for basalt. Here I am showing the variations of material properties using the "specific heat"
-# field.
-# specifically, the usage of the "Phase transition temperature lower limits" and
-# the "Phase transition temperature upper limits" are demonstrated in this test case.
-# For other compositions, see also:
-# pyrolite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite.prm
-# pyrolite, complicated: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite_complicated.prm
-# harzburgite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_harzburgite.prm
-# basalt: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_basalt.prm
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Max nonlinear iterations               = 1
-set Timing output frequency                = 1
-
-# model geometry
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 800e3
-    set Y extent      = 800e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = left, right
-  set List of model names = box
-
-  subsection Box
-    set Left temperature   = 273
-    set Right temperature  = 2000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y
-    set Function constants = XMAX=800e3, Tl=273.0, Tr=2000.0
-    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
-  end
-end
-
-# value for material model
-# The phase transitions are separated into subgroups. subgroups are separated by blanks.
-# Moreover, subsgroups are connected but don't intersect each other
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Maximum viscosity = 1e24
-    set Phase transition depths = background:150e3|80e3|80e3| 665e3|720e3
-    set Phase transition widths = background:5e3|5e3|5e3| 5e3|5e3
-    set Phase transition temperatures = background:587.0|773.15|1173.0|  1662.0|1662.0
-    set Phase transition temperature lower limits = background:-1e31|769.0|773.15|  -1e31|-1e31
-    set Phase transition temperature upper limits = background:769.0|773.15|1e31|  1e31|1e31
-    set Phase transition Clapeyron slopes = background:-0.0|5e8|0.0|  4e6|1.3e6
-    set Thermal diffusivities = 1.0e-6
-    set Heat capacities = background:3000.0|3540.0|3540.0|3540.0| 3613.0|3871.7
-    set Densities = 3300.0
-    set Thermal expansivities = 0.0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = background:5e-20|5e-22|5e-22|5e-22| 5e-22|5e-22
-    set Grain size exponents for diffusion creep = 0.0
-    set Activation energies for diffusion creep = 0.0
-    set Activation volumes for diffusion creep = 0.0
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = material properties
-    set Output format = gnuplot
-    set Time between graphical output = 0.1e6
-  end
-end
diff --git a/tests/visco_plastic_phases_temperature_limit_harzburgite.prm.bak b/tests/visco_plastic_phases_temperature_limit_harzburgite.prm.bak
deleted file mode 100644
index 5587302a38b..00000000000
--- a/tests/visco_plastic_phases_temperature_limit_harzburgite.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-# This test uses a similar setup as visco_plastic.prm and includes the phase transitions
-# for harzburgite. Here I am showing the variations of material properties using the "specific heat"
-# field.
-# specifically, the usage of the "Phase transition temperature lower limits" and
-# the "Phase transition temperature upper limits" are demonstrated in this test case.
-# For other compositions, see also:
-# pyrolite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite.prm
-# pyrolite, complicated: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite_complicated.prm
-# harzburgite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_harzburgite.prm
-# basalt: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_basalt.prm
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Max nonlinear iterations               = 1
-set Timing output frequency                = 1
-
-# model geometry
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 800e3
-    set Y extent      = 800e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = left, right
-  set List of model names = box
-
-  subsection Box
-    set Left temperature   = 273
-    set Right temperature  = 2000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y
-    set Function constants = XMAX=800e3, Tl=273.0, Tr=2000.0
-    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
-  end
-end
-
-# value for material model
-# The phase transitions are separated into subgroups. subgroups are separated by blanks.
-# Moreover, subsgroups are connected but don't intersect each other
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Maximum viscosity = 1e24
-    set Phase transition depths = background:410e3|520e3|560e3| 670e3|670e3|670e3| 670e3|670e3
-    set Phase transition widths = background:5e3|5e3|5e3| 5e3|5e3|5e3| 5e3|5e3
-    set Phase transition temperatures = background:1662.0|1662.0|1662.0| 1662.0|1662.0|1662.0| 1662.0|1662.0
-    set Phase transition temperature lower limits = background:-1e31|-1e31|-1e31| -1e31|-1e31|-1e31| 1662.0|1662.0
-    set Phase transition temperature upper limits = background:1e31|1e31|1e31| 1662.0|1662.0|1662.0| 1e31|1e31
-    set Phase transition Clapeyron slopes = background:4e6|4.1e6|4e6| 4e6|-2e6|-3.1e6| -2e6|1.3e6
-    set Thermal diffusivities = 1.0e-6
-    set Heat capacities = background: 3235.0|3372.3|3441.7|3441.7| 3478.7|3716.1|3759.4| 3679.1|3759.4
-    set Densities = 3300.0
-    set Thermal expansivities = 0.0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = background:5e-22|5e-22|5e-22|5e-22| 5e-24|5e-24|5e-24| 5e-24|5e-24
-    set Grain size exponents for diffusion creep = 0.0
-    set Activation energies for diffusion creep = 0.0
-    set Activation volumes for diffusion creep = 0.0
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = material properties
-    set Output format = gnuplot
-    set Time between graphical output = 0.1e6
-  end
-end
diff --git a/tests/visco_plastic_phases_temperature_limit_pyrolite.prm.bak b/tests/visco_plastic_phases_temperature_limit_pyrolite.prm.bak
deleted file mode 100644
index 1339d8609b0..00000000000
--- a/tests/visco_plastic_phases_temperature_limit_pyrolite.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-# This test uses a similar setup as visco_plastic.prm and includes the phase transitions
-# for pyrolite. Here I am showing the variations of material properties using the "specific heat"
-# field.
-# specifically, the usage of the "Phase transition temperature lower limits" and
-# the "Phase transition temperature upper limits" are demonstrated in this test case.
-# For other compositions, see also:
-# pyrolite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite.prm
-# pyrolite, complicated: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite_complicated.prm
-# harzburgite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_harzburgite.prm
-# basalt: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_basalt.prm
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Max nonlinear iterations               = 1
-set Timing output frequency                = 1
-
-# model geometry
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 800e3
-    set Y extent      = 800e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = left, right
-  set List of model names = box
-
-  subsection Box
-    set Left temperature   = 273
-    set Right temperature  = 2000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y
-    set Function constants = XMAX=800e3, Tl=273.0, Tr=2000.0
-    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
-  end
-end
-
-# value for material model
-# The phase transitions are separated into subgroups. subgroups are separated by blanks.
-# Moreover, subsgroups are connected but don't intersect each other
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Maximum viscosity = 1e24
-    set Phase transition depths = background:410e3|520e3|560e3| 670e3|670e3|670e3| 670e3|670e3
-    set Phase transition widths = background:5e3|5e3|5e3| 5e3|5e3|5e3| 5e3|5e3
-    set Phase transition temperatures = background:1662.0|1662.0|1662.0| 1662.0|1662.0|1662.0| 1662.0|1662.0
-    set Phase transition temperature lower limits = background:-1e31|-1e31|-1e31| -1e31|-1e31|-1e31| 1662.0|1662.0
-    set Phase transition temperature upper limits = background:1e31|1e31|1e31| 1662.0|1662.0|1662.0| 1e31|1e31
-    set Phase transition Clapeyron slopes = background:4e6|4.1e6|4e6| 4e6|-2e6|-3.1e6| -2e6|1.3e6
-    set Thermal diffusivities = 1.0e-6
-    set Heat capacities = background: 3300.0|3394.4|3442.1|3453.2| 3527.1|3691.45|3774.7| 3616.45|3772.0
-    set Densities = 3300.0
-    set Thermal expansivities = 0.0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = background:5e-22|5e-22|5e-22|5e-22| 5e-24|5e-24|5e-24| 5e-24|5e-24
-    set Grain size exponents for diffusion creep = 0.0
-    set Activation energies for diffusion creep = 0.0
-    set Activation volumes for diffusion creep = 0.0
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = material properties
-    set Output format = gnuplot
-    set Time between graphical output = 0.1e6
-  end
-end
diff --git a/tests/visco_plastic_phases_temperature_limit_pyrolite_complicated.prm.bak b/tests/visco_plastic_phases_temperature_limit_pyrolite_complicated.prm.bak
deleted file mode 100644
index dcedabeb78c..00000000000
--- a/tests/visco_plastic_phases_temperature_limit_pyrolite_complicated.prm.bak
+++ /dev/null
@@ -1,117 +0,0 @@
-# This test uses a similar setup as visco_plastic.prm and includes the phase transitions
-# of a complicated set. This is not a realistic case but is only a test for the implementation.
-# Here I am showing the variations of material properties using the "specific heat" field.
-# specifically, the usage of the "Phase transition temperature lower limits" and
-# the "Phase transition temperature upper limits" are demonstrated in this test case.
-# For other compositions, see also:
-# pyrolite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite.prm
-# pyrolite, complicated: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_pyrolite_complicated.prm
-# harzburgite: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_harzburgite.prm
-# basalt: $ASPECT_SOURCE_DIR/tests/visco_plastic_phases_basalt.prm
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Max nonlinear iterations               = 1
-set Timing output frequency                = 1
-
-# model geometry
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 800e3
-    set Y extent      = 800e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = left, right
-  set List of model names = box
-
-  subsection Box
-    set Left temperature   = 273
-    set Right temperature  = 2000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y
-    set Function constants = XMAX=800e3, Tl=273.0, Tr=2000.0
-    set Function expression = Tl * (x - XMAX)/(-XMAX) + Tr * x / XMAX
-  end
-end
-
-# value for material model
-# The phase transitions are separated into subgroups. subgroups are separated by blanks.
-# Moreover, subsgroups are connected but don't intersect each other
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference temperature = 273
-    set Maximum viscosity = 1e24
-    set Phase transition depths = background:670e3|670e3| 670e3|670e3|670e3| 670e3|670e3
-    set Phase transition widths = background:5e3|5e3| 5e3|5e3|5e3| 5e3|5e3
-    set Phase transition temperatures = background:1662.0|962.0| 962.0|1662.0|1662.0| 1662.0|1662.0
-    set Phase transition temperature lower limits = background:-1e31|-1e31| 1425.0|1425.0|-1e31| 1662.0|1662.0
-    set Phase transition temperature upper limits = background:1425.0|1425.0| 1e31|1662.0|1662.0| 1e31|1e31
-    set Phase transition Clapeyron slopes = background:4e6|-2e6| -2e6|4e6|-3.1e6| -3.1e6|4e6
-    set Thermal diffusivities = 1.0e-6
-    set Heat capacities = background:1000|2000|4000| 3000|4000|4500| 3500|4500
-    set Densities = 3300.0
-    set Thermal expansivities = 0.0
-    set Viscous flow law = diffusion
-    set Prefactors for diffusion creep = 5e-22
-    set Grain size exponents for diffusion creep = 0.0
-    set Activation energies for diffusion creep = 0.0
-    set Activation volumes for diffusion creep = 0.0
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = material properties
-    set Output format = gnuplot
-    set Time between graphical output = 0.1e6
-  end
-end
diff --git a/tests/visco_plastic_phases_viscosity.prm.bak b/tests/visco_plastic_phases_viscosity.prm.bak
deleted file mode 100644
index 3bec9e86dc5..00000000000
--- a/tests/visco_plastic_phases_viscosity.prm.bak
+++ /dev/null
@@ -1,129 +0,0 @@
-# Copy of visco_plastic.prm, but include a phase transition for the EoS
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = right
-  set Compositional field methods = field
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set List of model operators = add
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y
-    set Function constants = XMAX=100e3
-    set Function expression = (x>XMAX/2.0) ? 1.0 : 0.0
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Phase transition depths = background:50e3|75e3, right:50e3|75e3
-    set Phase transition widths = background:1e3|1e3, right:1e3|1e3
-    set Phase transition temperatures = background:273|273, right:273|273
-    set Phase transition Clapeyron slopes = background:0|0, right:0|0
-    set Densities = background:3300|3400|3500, right:3600|3700|3800
-    set Thermal expansivities = background:3.5e-5|2e-5|1.5e-5, right:3.5e-5|2e-5|1.5e-5
-    set Heat capacities = background:1200|1000|900, right:1200|1000|900
-    set Minimum viscosity = 1.e10
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for diffusion creep = background:5.e-20|5.e-19|5.e-18, right:5.e-17|5.e-16|5.e-15
-    set Grain size exponents for diffusion creep = background:3.|3.|3., right:3.|3.|3.
-    set Activation energies for diffusion creep = background:0.|0.|0., right:0.|0.|0.
-    set Activation volumes for diffusion creep = background:0.|0.|0., right:0.|0.|0.
-    set Prefactors for dislocation creep = background:5.e-23|5.e-21|5.e-19, right:5.e-18|5.e-17|5.e-16
-    set Stress exponents for dislocation creep = background:1.0|1.0|1.0, right:1.0|1.0|1.0
-    set Activation energies for dislocation creep = background:0.|0.|0., right:0.|0.|0.
-    set Activation volumes for dislocation creep = background:0.|0.|0., right:0.|0.|0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = material properties
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_phases_viscosity_max_min.prm.bak b/tests/visco_plastic_phases_viscosity_max_min.prm.bak
deleted file mode 100644
index 91daf7c66d8..00000000000
--- a/tests/visco_plastic_phases_viscosity_max_min.prm.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-# Copy of visco_plastic.prm, but include a phase transition for the EoS
-# as well as different values of minimum and a maximum viscosity on different phases.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = right
-  set Compositional field methods = field
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set List of model operators = add
-
-  subsection Function
-    set Coordinate system = cartesian
-    set Variable names = x, y
-    set Function constants = XMAX=100e3
-    set Function expression = (x>XMAX/2.0) ? 1.0 : 0.0
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Phase transition depths = background:50e3|75e3, right:50e3|75e3
-    set Phase transition widths = background:1e3|1e3, right:1e3|1e3
-    set Phase transition temperatures = background:273|273, right:273|273
-    set Phase transition Clapeyron slopes = background:0|0, right:0|0
-    set Densities = background:3300|3400|3500, right:3600|3700|3800
-    set Thermal expansivities = background:3.5e-5|2e-5|1.5e-5, right:3.5e-5|2e-5|1.5e-5
-    set Heat capacities = background:1200|1000|900, right:1200|1000|900
-
-    # Set Maximum and Minimum viscosities on phases
-    set Maximum viscosity = background: 1.e21 | 1.e19 | 1.e21, right: 1.e20
-    set Minimum viscosity = background: 1.e17 | 1.e17 | 1.e19, right: 1.e16
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for diffusion creep = background:5.e-20|5.e-19|5.e-18, right:5.e-17|5.e-16|5.e-15
-    set Grain size exponents for diffusion creep = background:3.|3.|3., right:3.|3.|3.
-    set Activation energies for diffusion creep = background:0.|0.|0., right:0.|0.|0.
-    set Activation volumes for diffusion creep = background:0.|0.|0., right:0.|0.|0.
-    set Prefactors for dislocation creep = background:5.e-23|5.e-21|5.e-19, right:5.e-18|5.e-17|5.e-16
-    set Stress exponents for dislocation creep = background:1.0|1.0|1.0, right:1.0|1.0|1.0
-    set Activation energies for dislocation creep = background:0.|0.|0., right:0.|0.|0.
-    set Activation volumes for dislocation creep = background:0.|0.|0., right:0.|0.|0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, material statistics
-
-  subsection Visualization
-    set List of output variables = material properties
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_reference_density_profile.prm.bak b/tests/visco_plastic_reference_density_profile.prm.bak
deleted file mode 100644
index f5faa67f2a0..00000000000
--- a/tests/visco_plastic_reference_density_profile.prm.bak
+++ /dev/null
@@ -1,103 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_reference_density_profile
-set Timing output frequency                = 1
-
-# Formulation
-subsection Formulation
-  set Formulation          = custom
-  set Mass conservation    = incompressible
-  set Temperature equation = reference density profile
-end
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_thermal_conductivity.prm.bak b/tests/visco_plastic_thermal_conductivity.prm.bak
deleted file mode 100644
index 95efb16e900..00000000000
--- a/tests/visco_plastic_thermal_conductivity.prm.bak
+++ /dev/null
@@ -1,21 +0,0 @@
-# A test to check whether using user-specified thermal conductivity
-# values gives identical results to specifying the equivalent
-# thermal diffusivity values. The test visco_plastic_diffusion
-# uses the default values for density (3000 kg/m^3), thermal
-# diffusivity (0.8e-6 m^2/s) and heat capacity (1250 1/K).
-# The thermal conductivity is thus 3000*1250*0.8e-6 = 3.0 (W/(m K)).
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_diffusion.prm
-
-
-# Global parameters
-set Dimension                              = 2
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Define thermal conductivities = true
-    set Thermal conductivities = 3.0
-  end
-end
diff --git a/tests/visco_plastic_total_strain_healing_temperature_dependent.prm.bak b/tests/visco_plastic_total_strain_healing_temperature_dependent.prm.bak
deleted file mode 100644
index c75d64b62fe..00000000000
--- a/tests/visco_plastic_total_strain_healing_temperature_dependent.prm.bak
+++ /dev/null
@@ -1,166 +0,0 @@
-# This test checks whether the temperature strain healing mechanism,
-# located in source/material_model/rheology/strain_dependent.cc,
-# works as intended when the total strain (invariant) is tracked.
-#
-# In the setup below, an initial amount of strain (0.2) is applied
-# uniformly throughout the domain via the initial composition subsection.
-# The model contains a uniform initial temperature (273 K) and no-slip BC
-# to produce no movement throughout the model domain. This ensures that
-# no additional strain accumulates and the value of the compositional
-# tracking the total strain invariant will strictly dependent on the
-# temperature-dependent strain healing parameters.
-#
-# The temperature-dependent strain healing is formulated as:
-#   healed_strain = strain_healing_temperature_dependent_recovery_rate *
-#                   exp( -strain_healing_temperature_dependent_prefactor *
-#                        0.5 * ( 1.0 - temperature/reference_temperature ) ) *
-#                   time
-#
-# Above, the parameters strain_healing_temperature_dependent_recovery_rate
-# and strain_healing_temperature_dependent_prefactor are user-defined
-# values set to, respectively, 1.e-15 and 15. The parameter reference_temperature
-# is equal to the user-specified adiabatic surface temperature, which is
-# set to 273 K. The variable time simply refers to how long the model
-# has run.
-#
-# The model runs for 10 millions years with 2 million year time steps.
-# For example, the analytical prediction for the value of the compositional
-# field total_strain at 10 Myr is:
-#   0.2 - (1e-15 * exp(-15. * 0.5 * (1.0 - 273/293))*10.e6*31556952.0) ~= 0.01087
-# Note that 31556952.0 represents the conversion from years to seconds.
-#
-# Comparing the analytical and numerical solution (values from log.txt)
-# at each time step demonstrates the strain healing implementation
-# is working as expected.
-# Time      Analytical Solution   Calculated Solution
-# 0  Myr    0.200000              0.2000
-# 2  Myr    0.162174              0.1622
-# 4  Myr    0.124348              0.1243
-# 6  Myr    0.086522              0.08652
-# 8  Myr    0.048691              0.0487
-# 10 Myr    0.010870              0.01087
-#
-# The calculated value can be observed directly in the file screen-output, as the
-# composition statistics postprocessor is used. For future debugging purposes,
-# the time step is limited to 2e6 years and both statistics and solution files
-# are output as well.
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 10e6
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Maximum time step                      = 2e6
-set Output directory                       = visco_plastic_total_strain_healing_temperature_dependent
-set Timing output frequency                = 1
-set Adiabatic surface temperature = 293
-
-# Model geometry (100x100 km, 25 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 5
-    set Y repetitions = 5
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = initial temperature
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = bottom, top, left, right
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = total_strain
-end
-
-# Prescribe initial values for total_strain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.2
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-20
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5.e-23
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 30.
-    set Cohesions                   = 1.e9
-    set Strain weakening mechanism = total strain
-    set Start prefactor strain weakening intervals  = 0.0
-    set End prefactor strain weakening intervals    = 0.2
-    set Prefactor strain weakening factors          = 0.5
-    set Start plasticity strain weakening intervals = 0.0
-    set End plasticity strain weakening intervals   = 0.2
-    set Cohesion strain weakening factors           = 0.5
-    set Friction strain weakening factors           = 0.5
-    set Strain healing mechanism  = temperature dependent
-    set Strain healing temperature dependent recovery rate = 1.e-15
-    set Strain healing temperature dependent prefactor     = 15.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = composition statistics, material statistics, temperature statistics, velocity statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-    set Time between graphical output = 2e6
-  end
-end
diff --git a/tests/visco_plastic_track_noninitial_plastic_strain.prm.bak b/tests/visco_plastic_track_noninitial_plastic_strain.prm.bak
deleted file mode 100644
index e89241c9331..00000000000
--- a/tests/visco_plastic_track_noninitial_plastic_strain.prm.bak
+++ /dev/null
@@ -1,133 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1e3
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_track_noninitial_plastic_strain
-set Timing output frequency                = 1
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = plastic_strain, noninitial_plastic_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=40e3 & x<=60e3 & y>=40.3e3& y<=60.e3, 0.2, 0); 0.0;
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-    set Time between graphical output       = 1e3
-  end
-end
diff --git a/tests/visco_plastic_vep_bending_beam.prm.bak b/tests/visco_plastic_vep_bending_beam.prm.bak
deleted file mode 100644
index 28d8e3927b2..00000000000
--- a/tests/visco_plastic_vep_bending_beam.prm.bak
+++ /dev/null
@@ -1,49 +0,0 @@
-# This test checks whether the viscoelastic bending beam benchmark
-# works with the visco_plastic material model. In particular,
-# this benchmark is a good test to ensure that a model with
-# compositional fields that affect material properties works.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-set End time  = 1e3
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 10
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Densities =  2800,  2800,  2800,  2800,  3300
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5.e-19, 5.e-19, 5.e-19, 5.e-19, 5.e-25
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
-    set Fixed elastic time step     = 1e3
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = maximum composition
-    set Cohesions = 1.e50
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/visco_plastic_vep_brick_extension.prm.bak b/tests/visco_plastic_vep_brick_extension.prm.bak
deleted file mode 100644
index dfe551c4d14..00000000000
--- a/tests/visco_plastic_vep_brick_extension.prm.bak
+++ /dev/null
@@ -1,63 +0,0 @@
-# This test checks the viscoelastic_plastic brick extension benchmark,
-# but reduces the resolution and viscosity seed for the purpose of runtime
-# length. The model runs for five time steps, which reveal that in the first
-# three time steps the second nonlinear iteration requires zero linear Stokes
-# solves. This likely reflects that elastic stresses buildup prior to yielding
-# and the solution does not change significantly during this time.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/kaus_2010/kaus_2010_extension.prm
-
-set Dimension                              = 2
-set End time                               = 5e3
-set Nonlinear solver tolerance             = 1e-7
-set Max nonlinear iterations               = 4
-set Output directory                       = visco_plastic_vep_brick_extension
-
-subsection Solver parameters
-  subsection Newton solver parameters
-    set Nonlinear Newton solver switch tolerance = 1e-2
-    set Max Newton line search iterations        = 2
-  end
-end
-
-# Model geometry (40x10 km, 2 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 5
-  end
-end
-
-# Change seed size from 800x400 to 4000x2000 meters
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; 0; \
-                              if (y<=2.0e3 && x>=18.0e3 && x<=22.0e3, 1, 0);
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, particles
-
-  subsection Particles
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell  = 2
-  set Maximum particles per cell  = 8
-
-  subsection Generator
-    subsection Reference cell
-      set Number of particles per cell per direction = 2
-    end
-  end
-end
diff --git a/tests/visco_plastic_vep_plate_flexure.prm.bak b/tests/visco_plastic_vep_plate_flexure.prm.bak
deleted file mode 100644
index eff50b0744c..00000000000
--- a/tests/visco_plastic_vep_plate_flexure.prm.bak
+++ /dev/null
@@ -1,51 +0,0 @@
-# This test checks whether the viscoelastic finite-length elastic plate
-# flexure benchmark runs successfully with the Visco Plastic material model.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm
-
-set End time                               = 5
-set Output directory                       = visco_plastic_vep_plate_flexure
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 7
-  end
-end
-
-# No global refinement
-subsection Mesh refinement
-  set Initial global refinement          = 0
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5.e-18, 5.e-18, 5.e-18, 5.e-18, 5.e-36, 5.e-36
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0
-    set Elastic shear moduli        = 1.e50, 1.e50, 1.e50, 1.e50, 3.e10, 3.e10
-    set Fixed elastic time step     = 5
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = maximum composition
-    set Cohesions                   = 1.e50
-    set Densities                   = 2700,  2700,  2700,  2700,  2700,  1890
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, material statistics, velocity statistics, topography
-
-  subsection Topography
-    set Output to file           = false
-    set Time between text output = 0
-  end
-end
diff --git a/tests/visco_plastic_vep_simple_shear.prm.bak b/tests/visco_plastic_vep_simple_shear.prm.bak
deleted file mode 100644
index 00184996a46..00000000000
--- a/tests/visco_plastic_vep_simple_shear.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-# This test checks the viscoelastic_plastic simple shear benchmark,
-# but reduces the end time for the purpose of runtime.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_simple_shear/viscoelastic_plastic_simple_shear.prm
-
-set Dimension                              = 2
-set End time                               = 0.05
diff --git a/tests/visco_plastic_vep_stress_build-up.prm.bak b/tests/visco_plastic_vep_stress_build-up.prm.bak
deleted file mode 100644
index 0091623ef14..00000000000
--- a/tests/visco_plastic_vep_stress_build-up.prm.bak
+++ /dev/null
@@ -1,58 +0,0 @@
-# This test checks viscoelastic stress buildup with a
-# constant strain rate and an elastic time step equal
-# to the numerical time step. The fixed elastic time
-# step used during the first time step is equal to the
-# numerical time step. Viscoelastic stresses (sigma_xx,
-# sigma_yy, sigma_xy) are tracked with compositional
-# fields. The parameter file is derived from the 2D
-# viscoelastic_stress_build-up benchmark with modifications
-# to the resolution, end time, material properties and
-# postprocessors.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-
-#  Global parameters
-set End time                               = 1e3
-
-# Model geometry (100x100 km, 5 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5e-22
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-    set Viscosity averaging scheme  = harmonic
-    set Densities                   = 2800.
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/visco_plastic_vep_stress_build-up_fixed_elastic_time_step.prm.bak b/tests/visco_plastic_vep_stress_build-up_fixed_elastic_time_step.prm.bak
deleted file mode 100644
index 397d0d20cc5..00000000000
--- a/tests/visco_plastic_vep_stress_build-up_fixed_elastic_time_step.prm.bak
+++ /dev/null
@@ -1,57 +0,0 @@
-# This test checks viscoelastic stress buildup with a
-# constant strain rate and an elastic time step equal
-# to a user-specified constant elastic time step. This
-# fixed elastic time step is double the numerical time step.
-# Viscoelastic stresses (sigma_xx, sigma_yy, sigma_xy)
-# are tracked with compositional fields. The parameter
-# file is derived from the 2D viscoelastic_stress_build-up
-# benchmark with modifications to the resolution, end time,
-# material properties and postprocessors.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-
-#  Global parameters
-set End time                               = 1e3
-
-# Model geometry (100x100 km, 5 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5e-22
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = true
-    set Fixed elastic time step     = 2e3
-    set Viscosity averaging scheme  = harmonic
-    set Densities                   = 2800.
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/visco_plastic_vep_stress_build-up_stress_averaging.prm.bak b/tests/visco_plastic_vep_stress_build-up_stress_averaging.prm.bak
deleted file mode 100644
index 46bb3f501c3..00000000000
--- a/tests/visco_plastic_vep_stress_build-up_stress_averaging.prm.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-# This test checks viscoelastic stress buildup with a
-# constant strain rate and an elastic time step equal
-# to a user-specified constant elastic time step. This
-# fixed elastic time step is double the numerical time step.
-# Stress averaging is used to account for the difference
-# between the numerical and elastic time step. Viscoelastic
-# stresses (sigma_xx, sigma_yy, sigma_xy) are tracked
-# with compositional fields. The parameter file is derived
-# from the 2D viscoelastic_stress_build-up benchmark with
-# modifications to the resolution, end time, material
-# properties and postprocessors.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-
-#  Global parameters
-set End time                               = 1e3
-
-# Model geometry (100x100 km, 5 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5e-22
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = true
-    set Fixed elastic time step     = 2e3
-    set Viscosity averaging scheme  = harmonic
-    set Densities                   = 2800.
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/visco_plastic_vep_stress_build-up_yield.prm.bak b/tests/visco_plastic_vep_stress_build-up_yield.prm.bak
deleted file mode 100644
index 69185522072..00000000000
--- a/tests/visco_plastic_vep_stress_build-up_yield.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# This test checks viscoelastic stress buildup with a
-# constant strain rate, an elastic time step equal
-# to the numerical time step and a yield stress of 10 MPa.
-# The fixed elastic time step used during the first time
-# step is equal to the numerical time step. Viscoelastic
-# stresses (sigma_xx, sigma_yy, sigma_xy) are tracked with
-# compositional fields. The yield stress of 10 MPa should
-# prevent elastic stresses from accumulating above this
-# value. The parameter file is derived from the 2D
-# viscoelastic_stress_build-up benchmark with modifications
-# to the resolution, end time, material properties and
-# postprocessors. Notably, other tests derived from the same
-# benchmark have a cohesion of 1e6 Pa, run for 1 time step
-# (End time = 1e3), and only do 1 nonlinear iteration. Here,
-# we have adjusted the parameters slightly to illustrate that
-# in some cases the solution may not change at all between nonlinear
-# iterations and as a result no Stokes linear iterations are
-# performed.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 2
-
-#  Global parameters
-set End time                               = 2e3
-
-# Model geometry (100x100 km, 5 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5e-22
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-    set Viscosity averaging scheme  = harmonic
-    set Angles of internal friction = 0.
-    set Cohesions                   = 1.e6
-    set Densities                   = 2800
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/visco_plastic_vep_stress_build-up_yield_particles.prm.bak b/tests/visco_plastic_vep_stress_build-up_yield_particles.prm.bak
deleted file mode 100644
index 7e23790d243..00000000000
--- a/tests/visco_plastic_vep_stress_build-up_yield_particles.prm.bak
+++ /dev/null
@@ -1,92 +0,0 @@
-# This test checks viscoelastic stress buildup with a
-# constant strain rate, an elastic time step equal
-# to the numerical time step and a yield stress of 10 MPa.
-# The fixed elastic time step used during the first time
-# step is equal to the numerical time step. Viscoelastic
-# stresses (sigma_xx, sigma_yy, sigma_xy) are tracked with
-# active particles. The yield stress of 10 MPa should
-# prevent elastic stresses from accumulating above this
-# value. The parameter file is derived from the 2D
-# viscoelastic_stress_build-up benchmark with modifications
-# to the resolution, end time, material properties and
-# postprocessors. Notably, other tests derived from the same
-# benchmark have a cohesion of 1e6 Pa, run for 1 time step
-# (End time = 1e3), and only do 1 nonlinear iteration. Here,
-# we have adjusted the parameters slightly to illustrate that
-# in some cases the solution may not change at all between nonlinear
-# iterations and as a result no Stokes linear iterations are
-# performed.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Nonlinear solver tolerance             = 1e-5
-set Max nonlinear iterations               = 2
-set Output directory                       = visco_plastic_vep_stress_build-up_yield_particles
-
-#  Global parameters
-set End time                               = 2e3
-
-# Model geometry (100x100 km, 5 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Track compositional fields with active particles
-subsection Compositional fields
-  set Compositional field methods = particles, particles, particles
-  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5e-22
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-    set Viscosity averaging scheme  = harmonic
-    set Angles of internal friction = 0.
-    set Cohesions                   = 1.e6
-    set Densities                   = 2800
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output    = 1e9
-    set Data output format          = vtu
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell  = 25
-  set Maximum particles per cell  = 35
-  set Load balancing strategy     = remove and add particles
-  set List of particle properties = initial composition, elastic stress
-  set Interpolation scheme        = bilinear least squares
-  set Update ghost particles      = true
-  set Particle generator name     = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 12e3
-    end
-  end
-end
diff --git a/tests/visco_plastic_viscous_strain_weakening.prm.bak b/tests/visco_plastic_viscous_strain_weakening.prm.bak
deleted file mode 100644
index d3b52dffd09..00000000000
--- a/tests/visco_plastic_viscous_strain_weakening.prm.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 10
-set Output directory                       = visco_plastic_viscous_strain_weakening
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = viscous_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=40e3&x<=60e3&y>=40e3&y<=50.e3,0.2,0);
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 6.e6
-    set Strain weakening mechanism = viscous weakening with viscous strain only
-    set Start prefactor strain weakening intervals = 0.
-    set End prefactor strain weakening intervals = 1.0
-    set Prefactor strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/visco_plastic_yield.prm.bak b/tests/visco_plastic_yield.prm.bak
deleted file mode 100644
index d602efb79b0..00000000000
--- a/tests/visco_plastic_yield.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, material statistics
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_yield_max.prm.bak b/tests/visco_plastic_yield_max.prm.bak
deleted file mode 100644
index cd187a5e5b1..00000000000
--- a/tests/visco_plastic_yield_max.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# This test checks that the maximum yield stress is causing the
-# effective viscosity to change by the correct amount. The velocity
-# boundary conditions create a constant applied strain rate 3.1709e-16 1/s
-# (0.0005 m/y / 50e3 m / sec2yr). The drucker prager parameters create
-# a constant yield stress of 1e6 Pa, which would give a viscosity of
-# 1e6/2/3.17e-16 = 1.57e21 Pa s (this is the visco_plastic_yield test).
-# So, here we set maximum yield strength = 0.5e6 Pa, and so the effective
-# viscosity becomes 0.5e6/2/3.17e-16 = 7.88e20. The gnuplot output includes
-# the strain rate value and the viscosity.
-#
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = max_yield
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Maximum yield stress = 5.0e5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics, mass flux statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = strain rate, viscosity
-    set Output format                 = gnuplot
-    set Time between graphical output = 0.25e6
-    set Number of grouped files       = 0
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_yield_noninitial-plastic-strain_particles.prm.bak b/tests/visco_plastic_yield_noninitial-plastic-strain_particles.prm.bak
deleted file mode 100644
index b4d660ab000..00000000000
--- a/tests/visco_plastic_yield_noninitial-plastic-strain_particles.prm.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-# A test to check whether noninitial plastic strain is correctly tracked
-# on particles, which are also used to track plastic and viscous strain.
-# The boundary conditions (see tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm)
-# produce an incremental strain of 1e-5 per time step and material that is always yielding.
-# The initial strain values are as follows - plastic strain: 1e-5, noninitial plastic strain: 0,
-# viscous strain: 0. As a result, the viscous strain should always have a value of 0 throughout
-# the model run. Respectively, after 3 time steps the plastic and noninitial plastic values
-# should be 4e-5 and 3e-5.
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm
-
-set End time           = 3000
-set Maximum time step  = 1000
-set Output directory   = visco_plastic_yield_noninitial-plastic-strain_particles
-
-# Particles mapped to the Compositional fields used to track plastic, noninitial plastic, and viscous strain.
-subsection Compositional fields
-  set Number of fields            = 3
-  set Names of fields             = plastic_strain, noninitial_plastic_strain, viscous_strain
-  set Compositional field methods = particles, particles, particles
-  set Mapped particle properties  = plastic_strain:plastic_strain, noninitial_plastic_strain:noninitial_plastic_strain, viscous_strain:viscous_strain
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 1.e-5; 0; 0;
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = composition statistics, mass flux statistics, particles, particle count statistics, velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables       = named additional outputs, strain rate, viscosity
-    set Time between graphical output  = 0
-    set Output format                  = gnuplot
-  end
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = viscoplastic strain invariants
-  set Particle generator name = random uniform
-  set Interpolation scheme = nearest neighbor
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1e5
-    end
-  end
-end
diff --git a/tests/visco_plastic_yield_plastic_damper.prm.bak b/tests/visco_plastic_yield_plastic_damper.prm.bak
deleted file mode 100644
index fed5bf581c0..00000000000
--- a/tests/visco_plastic_yield_plastic_damper.prm.bak
+++ /dev/null
@@ -1,26 +0,0 @@
-# This test modifies the benchmark gerya_2019_vp.prm
-# to include a viscous damper in the plastic viscosity calculation.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plastic_shear_bands/gerya_2019/gerya_2019_vp.prm
-
-set Max nonlinear iterations = 1
-set Output directory = visco_plastic_yield_plastic_damper
-
-subsection Mesh refinement
-  set Initial global refinement = 2
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Allow negative pressures in plasticity = true
-    set Use plastic damper = true
-    set Plastic damper viscosity = 1e19
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, material statistics, velocity statistics
-  set Run postprocessors on nonlinear iterations = false
-end
diff --git a/tests/visco_plastic_yield_plastic_strain_weakening.prm.bak b/tests/visco_plastic_yield_plastic_strain_weakening.prm.bak
deleted file mode 100644
index 1fe8c29a51f..00000000000
--- a/tests/visco_plastic_yield_plastic_strain_weakening.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield_plastic_strain_weakening
-set Timing output frequency                = 1
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = plastic_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = plastic weakening with plastic strain only
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/visco_plastic_yield_plastic_strain_weakening_particles.prm.bak b/tests/visco_plastic_yield_plastic_strain_weakening_particles.prm.bak
deleted file mode 100644
index a2479627110..00000000000
--- a/tests/visco_plastic_yield_plastic_strain_weakening_particles.prm.bak
+++ /dev/null
@@ -1,31 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_strain_weakening.prm
-
-
-# Particles mapped to the Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Compositional field methods = particles
-  set Mapped particle properties =  plastic_strain:plastic_strain
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles
-
-  subsection Particles
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = viscoplastic strain invariants
-  set Particle generator name = random uniform
-  set Maximum particles per cell = 500
-  set Interpolation scheme = nearest neighbor
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1e5
-    end
-  end
-end
diff --git a/tests/visco_plastic_yield_plastic_viscous_strain_healing.prm.bak b/tests/visco_plastic_yield_plastic_viscous_strain_healing.prm.bak
deleted file mode 100644
index a7bd23fad4d..00000000000
--- a/tests/visco_plastic_yield_plastic_viscous_strain_healing.prm.bak
+++ /dev/null
@@ -1,148 +0,0 @@
-# This test runs on 1 mpi process for 8 timesteps
-# healed_strain = strain_healing_temperature_dependent_recovery_rate *
-# exp(-strain_healing_temperature_dependent_prefactor * 0.5 * (1.0 - temperature/reference_temperature)) * this_timestep
-# The returned strain values due to strain healing should be:
-# plastic_strain: max, 4.435e-04; min, -3.198e-05
-# viscous_strain: max, 3.187e-01: min, -2.083e-01
-# Analytical value of total healed strain = 4.999e-08
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 5e7
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield_plastic_viscous_strain_healing
-set Timing output frequency                = 1
-set Adiabatic surface temperature = 273.
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = plastic_strain, viscous_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0); if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.4,0)
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = plastic weakening with plastic strain and viscous weakening with viscous strain
-    set Start prefactor strain weakening intervals = 0.
-    set End prefactor strain weakening intervals = 1.0
-    set Prefactor strain weakening factors = 0.5
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-    set Strain healing mechanism = temperature dependent
-    set Strain healing temperature dependent recovery rate = 1.e-15
-    set Strain healing temperature dependent prefactor = 15.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-    set Time between graphical output = 5e7
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm.bak b/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm.bak
deleted file mode 100644
index 113cc289512..00000000000
--- a/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield_plastic_viscous_strain_weakening
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = plastic_strain, viscous_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0); if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.4,0)
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = plastic weakening with plastic strain and viscous weakening with viscous strain
-    set Start prefactor strain weakening intervals = 0.
-    set End prefactor strain weakening intervals = 1.0
-    set Prefactor strain weakening factors = 0.5
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_yield_plastic_viscous_strain_weakening_particles.prm.bak b/tests/visco_plastic_yield_plastic_viscous_strain_weakening_particles.prm.bak
deleted file mode 100644
index b837029ab9f..00000000000
--- a/tests/visco_plastic_yield_plastic_viscous_strain_weakening_particles.prm.bak
+++ /dev/null
@@ -1,31 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm
-
-
-# Particles mapped to the Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Compositional field methods = particles, particles
-  set Mapped particle properties =  plastic_strain:plastic_strain, viscous_strain:viscous_strain
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = viscoplastic strain invariants
-  set Particle generator name = random uniform
-  set Interpolation scheme = nearest neighbor
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1e5
-    end
-  end
-end
diff --git a/tests/visco_plastic_yield_strain_weakening.prm.bak b/tests/visco_plastic_yield_strain_weakening.prm.bak
deleted file mode 100644
index fa50b6a4c3b..00000000000
--- a/tests/visco_plastic_yield_strain_weakening.prm.bak
+++ /dev/null
@@ -1,132 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield_strain_weakening
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = total_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = plastic weakening with total strain only
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_yield_strain_weakening_compositions.prm.bak b/tests/visco_plastic_yield_strain_weakening_compositions.prm.bak
deleted file mode 100644
index 5b434128f7a..00000000000
--- a/tests/visco_plastic_yield_strain_weakening_compositions.prm.bak
+++ /dev/null
@@ -1,127 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield_strain_weakening_composition
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = total_strain, weak_layer
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);if (y>50e3,1,0)
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Densities = 3300,10000,2700
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-24
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6,1e1,1e7
-    set Strain weakening mechanism = plastic weakening with total strain only
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = strain rate, named additional outputs, material properties
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/visco_plastic_yield_strain_weakening_defect_corr_stokes.prm.bak b/tests/visco_plastic_yield_strain_weakening_defect_corr_stokes.prm.bak
deleted file mode 100644
index 9de62a1e28e..00000000000
--- a/tests/visco_plastic_yield_strain_weakening_defect_corr_stokes.prm.bak
+++ /dev/null
@@ -1,4 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_strain_weakening.prm
-
-set Nonlinear solver scheme                = single Advection, iterated defect correction Stokes
-set Output directory                       = visco_plastic_yield_strain_weakening_defect_corr_stokes
diff --git a/tests/visco_plastic_yield_strain_weakening_full_strain_tensor.prm.bak b/tests/visco_plastic_yield_strain_weakening_full_strain_tensor.prm.bak
deleted file mode 100644
index b86a2f1fcfd..00000000000
--- a/tests/visco_plastic_yield_strain_weakening_full_strain_tensor.prm.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1e2
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield_strain_weakening_full_strain_tensor
-set Timing output frequency                = 1
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields = s11, s12, s21, s22
-end
-
-# The compositional fields have an initial value 0 or 0.5
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.5; 0; 0; 0.5;
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material and strain fields)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = finite strain tensor
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Start prefactor strain weakening intervals = 0.
-    set End prefactor strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-    set Prefactor strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_yield_strain_weakening_full_strain_tensor_3d.prm.bak b/tests/visco_plastic_yield_strain_weakening_full_strain_tensor_3d.prm.bak
deleted file mode 100644
index ff6984c1de7..00000000000
--- a/tests/visco_plastic_yield_strain_weakening_full_strain_tensor_3d.prm.bak
+++ /dev/null
@@ -1,130 +0,0 @@
-# Global parameters
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 1e2
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield_strain_weakening_full_strain_tensor_3d
-set Timing output frequency                = 1
-
-# Model geometry (100x10x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 1
-    set Z repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 10e3
-    set Z extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right, front, back
-  set List of model names = initial temperature
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = front, back
-  set Prescribed velocity boundary indicators = bottom z: function, top z: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); 0; if (z<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain
-subsection Compositional fields
-  set Number of fields = 9
-  set Names of fields = s11, s12, s13, s21, s22, s23, s31, s32, s33
-end
-
-# The compositional fields have an initial value 0 or 0.5
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function expression = 0.5; 0; 0; 0; 0.5; 0; 0; 0; 0.5
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material and strain fields)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = finite strain tensor
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Start prefactor strain weakening intervals = 0.
-    set End prefactor strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-    set Prefactor strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_yield_strain_weakening_iterated_advection.prm.bak b/tests/visco_plastic_yield_strain_weakening_iterated_advection.prm.bak
deleted file mode 100644
index 520bacbe8da..00000000000
--- a/tests/visco_plastic_yield_strain_weakening_iterated_advection.prm.bak
+++ /dev/null
@@ -1,44 +0,0 @@
-# A test to check whether the calculated finite strain invariant
-# (total strain in this case) does not unrealistically accumulate during
-# nonlinear iterations when an iterative Advection scheme is used. We
-# check this by running the postprocessors on every nonlinear iteration.
-# The test output from the composition statistics postprocessor,
-# which prints out min/max/mass of each compositional field, confirms
-# that the total strain does not incorrectly accumulate during successive
-# nonlinear iterations.
-# The test has been slightly modified from the test linked below.
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_strain_weakening.prm
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 2e5
-set Maximum time step                      = 1e5
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = iterated Advection and Stokes
-
-# Set a very strict nonlinear tolerance such that we perform more than
-# one nonlinear iteration after the first time step.
-set Nonlinear solver tolerance             = 1e-14
-
-# Cap the number of nonlinear iterations at 5, as we
-# only need to a few iterations to see how the strain
-# field evolves within each timestep.
-set Max nonlinear iterations               = 5
-set Output directory                       = visco_plastic_yield_strain_weakening_iterated_advection
-
-# Start with no initial (total) strain such that the
-# accumulated strain should be uniform throughout
-# the domain over the course of this model run.
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, velocity statistics
-  set Run postprocessors on nonlinear iterations = true
-end
diff --git a/tests/visco_plastic_yield_strain_weakening_no-advect_no_stokes.prm.bak b/tests/visco_plastic_yield_strain_weakening_no-advect_no_stokes.prm.bak
deleted file mode 100644
index 817de85ec23..00000000000
--- a/tests/visco_plastic_yield_strain_weakening_no-advect_no_stokes.prm.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-# A test checking that the 'no Advection, no Stokes' nonlinear solver
-# scheme can be used in combination with the strain weakening rheology module
-
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_strain_weakening.prm
-
-set Nonlinear solver scheme                = no Advection, no Stokes
-set Output directory                       = visco_plastic_yield_strain_weakening_no-advect_no_stokes
diff --git a/tests/visco_plastic_yield_strain_weakening_particles.prm.bak b/tests/visco_plastic_yield_strain_weakening_particles.prm.bak
deleted file mode 100644
index f711b92cede..00000000000
--- a/tests/visco_plastic_yield_strain_weakening_particles.prm.bak
+++ /dev/null
@@ -1,31 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_strain_weakening.prm
-
-
-# Particles mapped to the Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Compositional field methods = particles
-  set Mapped particle properties =  total_strain:total_strain
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = viscoplastic strain invariants
-  set Particle generator name = random uniform
-  set Interpolation scheme = nearest neighbor
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1e5
-    end
-  end
-end
diff --git a/tests/visco_plastic_yield_temperature_activated_viscous_strain_weakening.prm.bak b/tests/visco_plastic_yield_temperature_activated_viscous_strain_weakening.prm.bak
deleted file mode 100644
index 8b3b6344cf6..00000000000
--- a/tests/visco_plastic_yield_temperature_activated_viscous_strain_weakening.prm.bak
+++ /dev/null
@@ -1,46 +0,0 @@
-#this tests the temperature dependence of the viscous strain weakening factor
-
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_viscous_strain_weakening.prm
-
-set Output directory = visco_plastic_yield_temperature_activated_viscous_strain_weakening
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=25.e3&x<=75.e3&y>=25.e3&y<=75.e3,0.5,0);
-  end
-end
-
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Use temperature activated strain softening  = true
-    set Lower temperature for onset of strain weakening = 800
-    set Lower temperature for maximum strain weakening  = 900
-    set Upper temperature for maximum strain weakening  = 1000
-    set Upper temperature for onset of strain weakening = 1100
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function constants = h=100e3,ts1=800,ts2=1200
-    set Function expression =  ts1 + ((ts2-ts1))*(h-y)/h;
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1200
-    set Top temperature    =  800
-  end
-end
diff --git a/tests/visco_plastic_yield_total_strain_healing.prm.bak b/tests/visco_plastic_yield_total_strain_healing.prm.bak
deleted file mode 100644
index c057fadf507..00000000000
--- a/tests/visco_plastic_yield_total_strain_healing.prm.bak
+++ /dev/null
@@ -1,147 +0,0 @@
-# This test runs on 1 mpi process and computes 8 timesteps
-# healed_strain = strain_healing_temperature_dependent_recovery_rate *
-# exp(-strain_healing_temperature_dependent_prefactor * 0.5 * (1.0 - temperature/reference_temperature)) * this_timestep
-# The returned strain value due to strain healing in the last timestep should be:
-# total_strain: max, 4.435e-04; min, -3.198e-05
-# Analytical value of total healed strain = 4.999e-08
-
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 5e7
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield_total_strain_healing
-set Timing output frequency                = 1
-set Adiabatic surface temperature = 273.
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = total_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = total strain
-    set Start prefactor strain weakening intervals = 0.
-    set End prefactor strain weakening intervals = 1.0
-    set Prefactor strain weakening factors = 0.5
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-    set Strain healing mechanism = temperature dependent
-    set Strain healing temperature dependent recovery rate = 1.e-15
-    set Strain healing temperature dependent prefactor = 15.
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-    set Time between graphical output = 5e7
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/visco_plastic_yield_viscous_strain_weakening.prm.bak b/tests/visco_plastic_yield_viscous_strain_weakening.prm.bak
deleted file mode 100644
index 399d6b9313e..00000000000
--- a/tests/visco_plastic_yield_viscous_strain_weakening.prm.bak
+++ /dev/null
@@ -1,131 +0,0 @@
-# Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = true
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Max nonlinear iterations               = 1
-set Output directory                       = visco_plastic_yield_viscous_strain_weakening
-set Timing output frequency                = 1
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 0
-  end
-end
-
-# Model geometry (100x100 km, 10 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 10
-    set Y repetitions = 10
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Boundary classifications (fixed T boundaries, prescribed velocity)
-
-# Temperature boundary and initial conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 273
-    set Left temperature   = 273
-    set Right temperature  = 273
-    set Top temperature    = 273
-  end
-end
-
-# Velocity on boundaries characterized by functions
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom y: function, top y: function, left x: function, right x: function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = m=0.0005, year=1
-    set Function expression = if (x<50e3 , -1*m/year, 1*m/year); if (y<50e3 , 1*m/year, -1*m/year);
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 273
-  end
-end
-
-# Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = viscous_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0);
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = viscous weakening with viscous strain only
-    set Start prefactor strain weakening intervals = 0.
-    set End prefactor strain weakening intervals = 1.0
-    set Prefactor strain weakening factors = 0.5
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Output format            = gnuplot
-  end
-end
diff --git a/tests/visco_plastic_yield_viscous_strain_weakening_particles.prm.bak b/tests/visco_plastic_yield_viscous_strain_weakening_particles.prm.bak
deleted file mode 100644
index ceef25a2d34..00000000000
--- a/tests/visco_plastic_yield_viscous_strain_weakening_particles.prm.bak
+++ /dev/null
@@ -1,31 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_viscous_strain_weakening.prm
-
-
-# Particles mapped to the Compositional fields used to track finite strain invariant
-subsection Compositional fields
-  set Compositional field methods = particles
-  set Mapped particle properties =  viscous_strain:viscous_strain
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization, particles
-
-  subsection Particles
-    set Time between data output = 0
-    set Data output format = none
-  end
-end
-
-subsection Particles
-  set List of particle properties = viscoplastic strain invariants
-  set Particle generator name = random uniform
-  set Interpolation scheme = nearest neighbor
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 1e5
-    end
-  end
-end
diff --git a/tests/viscoelastic_bending_beam.prm.bak b/tests/viscoelastic_bending_beam.prm.bak
deleted file mode 100644
index ce81b7b0196..00000000000
--- a/tests/viscoelastic_bending_beam.prm.bak
+++ /dev/null
@@ -1,51 +0,0 @@
-# This test checks whether the viscoelastic bending beam benchmark
-# run successfully. In particular, this benchmark is a good test to
-# ensure that a model with compositional fields that affect material
-# properties works.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-set End time  = 1e3
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 10
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, beam
-  set Types of fields  = stress, stress, stress, chemical composition
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities            =  2800,  3300
-    set Viscosities          = 1.e18, 1.e24
-    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
-    set Fixed elastic time step     = 1e3
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = maximum composition
-  end
-end
diff --git a/tests/viscoelastic_bending_beam_averaging.prm.bak b/tests/viscoelastic_bending_beam_averaging.prm.bak
deleted file mode 100644
index 4e6683fa2fc..00000000000
--- a/tests/viscoelastic_bending_beam_averaging.prm.bak
+++ /dev/null
@@ -1,38 +0,0 @@
-# This test checks whether the viscoelastic bending beam benchmark
-# runs successfully. In particular, this benchmark is a good test to
-# ensure that a model with compositional fields that affect material
-# properties works, and that material averaging works in combination
-# with elasticity.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-set End time  = 1e3
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 10
-  end
-end
-
-# Use material averaging. The only options that can be used
-# with elasticity, aside from 'none', are 'harmonic average
-# only viscosity' and 'project to Q1 only viscosity'.
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/viscoelastic_bending_beam_gmg.prm.bak b/tests/viscoelastic_bending_beam_gmg.prm.bak
deleted file mode 100644
index 802565674c3..00000000000
--- a/tests/viscoelastic_bending_beam_gmg.prm.bak
+++ /dev/null
@@ -1,47 +0,0 @@
-# This test checks whether the viscoelastic bending beam benchmark
-# runs successfully. In particular, this benchmark is a good test to
-# ensure that a model with compositional fields that affect material
-# properties works. This test is identical to the test
-# tests/viscoelastic_bending_beam.prm, except that the GMG Stokes solver
-# and material averaging (required for GMG) is used here. Significantly,
-# the use of material averaging will produce deviations between the
-# results of the two tests, as the calculated and stresses are
-# influenced by averaging across the material interfaces.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-set End time          = 1e3
-set Output directory  = viscoelastic_bending_beam_gmg
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 10
-  end
-end
-
-# Use material averaging (required for GMG Stokes solver)
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/viscoelastic_bending_beam_particles.prm.bak b/tests/viscoelastic_bending_beam_particles.prm.bak
deleted file mode 100644
index 5a96946d2f5..00000000000
--- a/tests/viscoelastic_bending_beam_particles.prm.bak
+++ /dev/null
@@ -1,53 +0,0 @@
-# This test checks whether the viscoelastic bending beam benchmark
-# run successfully. In particular, this benchmark is a good test to
-# ensure that a model using active particles to track both viscoelastic
-# stresses and lithologies, which affect material properties, works.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-set End time         = 2e3
-set Output directory = viscoelastic_bending_beam_particles
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 10
-  end
-end
-
-# Compositional field names and methods
-subsection Compositional fields
-  set Number of fields = 4
-  set Compositional field methods =           particles,           particles,           particles,         particles
-  set Names of fields             =           ve_stress_xx,        ve_stress_yy,        ve_stress_xy,      beam
-  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy, beam:initial beam
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output    = 1e9
-    set Data output format          = vtu
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell  = 25
-  set Maximum particles per cell  = 35
-  set Load balancing strategy     = remove and add particles
-  set List of particle properties = initial composition, elastic stress
-  set Interpolation scheme        = bilinear least squares
-  set Update ghost particles      = true
-  set Particle generator name     = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 4.5e3
-    end
-  end
-end
diff --git a/tests/viscoelastic_bending_beam_principal_stress.prm.bak b/tests/viscoelastic_bending_beam_principal_stress.prm.bak
deleted file mode 100644
index bebc628441c..00000000000
--- a/tests/viscoelastic_bending_beam_principal_stress.prm.bak
+++ /dev/null
@@ -1,34 +0,0 @@
-# This test checks whether the viscoelastic bending beam benchmark
-# runs successfully. This test extends viscoelastic_bending_beam by
-# also outputting the principal stresses including the elastic stresses.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_bending_beam/viscoelastic_bending_beam.prm
-
-set End time  = 1e3
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 10
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average, visualization
-
-  subsection Visualization
-    set List of output variables = principal stress
-    set Output format = gnuplot
-  end
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/viscoelastic_fixed_elastic_time_step.prm.bak b/tests/viscoelastic_fixed_elastic_time_step.prm.bak
deleted file mode 100644
index 03c9a68deae..00000000000
--- a/tests/viscoelastic_fixed_elastic_time_step.prm.bak
+++ /dev/null
@@ -1,54 +0,0 @@
-# This test checks viscoelastic stress buildup with a
-# constant strain rate and an elastic time step equal
-# to a user-specified constant elastic time step. This
-# fixed elastic time step is double the numerical time step.
-# Viscoelastic stresses (sigma_xx, sigma_yy, sigma_xy)
-# are tracked with compositional fields. The parameter
-# file is derived from the 2D viscoelastic_stress_build-up
-# benchmark with modifications to the resolution, end time,
-# material properties and postprocessors.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-
-#  Global parameters
-set End time                               = 1e3
-set Output directory                       = viscoelastic_fixed_elastic_time_step
-
-# Model geometry (100x100 km, 5 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 2800
-    set Viscosities                 = 1.e21
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = true
-    set Fixed elastic time step     = 2e3
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/viscoelastic_numerical_elastic_time_step.prm.bak b/tests/viscoelastic_numerical_elastic_time_step.prm.bak
deleted file mode 100644
index 85b94327777..00000000000
--- a/tests/viscoelastic_numerical_elastic_time_step.prm.bak
+++ /dev/null
@@ -1,55 +0,0 @@
-# This test checks viscoelastic stress buildup with a
-# constant strain rate and an elastic time step equal
-# to the numerical time step. The fixed elastic time
-# step used during the first time step is equal to the
-# numerical time step. Viscoelastic stresses (sigma_xx,
-# sigma_yy, sigma_xy) are tracked with compositional
-# fields. The parameter file is derived from the 2D
-# viscoelastic_stress_build-up benchmark with modifications
-# to the resolution, end time, material properties and
-# postprocessors.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-
-#  Global parameters
-set End time                               = 1e3
-set Output directory                       = viscoelastic_numerical_elastic_time_step
-
-# Model geometry (100x100 km, 5 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 2800
-    set Viscosities                 = 1.e21
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/viscoelastic_numerical_elastic_time_step_particles.prm.bak b/tests/viscoelastic_numerical_elastic_time_step_particles.prm.bak
deleted file mode 100644
index 468cb571164..00000000000
--- a/tests/viscoelastic_numerical_elastic_time_step_particles.prm.bak
+++ /dev/null
@@ -1,75 +0,0 @@
-# This test checks viscoelastic stress buildup with a
-# constant strain rate and an elastic time step equal
-# to the numerical time step. The fixed elastic time
-# step used during the first time step is equal to the
-# numerical time step. Viscoelastic stresses (sigma_xx,
-# sigma_yy, sigma_xy) are tracked with active particles.
-# The parameter file is derived from the 2D
-# viscoelastic_stress_build-up benchmark with modifications
-# to the compositional field method, resolution, end time, material properties and
-# postprocessors.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-
-#  Global parameters
-set End time                               = 2e3
-set Output directory                       = viscoelastic_numerical_elastic_time_step_particles
-
-# Model geometry (100x100 km, 5 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Track compositional fields with active particles
-subsection Compositional fields
-  set Compositional field methods = particles, particles, particles
-  set Mapped particle properties  = ve_stress_xx:ve_stress_xx, ve_stress_yy:ve_stress_yy, ve_stress_xy:ve_stress_xy
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 2800
-    set Viscosities                 = 1.e21
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, composition statistics, particles
-
-  subsection Particles
-    set Time between data output    = 1e9
-    set Data output format          = vtu
-  end
-end
-
-subsection Particles
-  set Minimum particles per cell  = 25
-  set Maximum particles per cell  = 35
-  set Load balancing strategy     = remove and add particles
-  set List of particle properties = initial composition, elastic stress
-  set Interpolation scheme        = bilinear least squares
-  set Update ghost particles      = true
-  set Particle generator name     = random uniform
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 12e3
-    end
-  end
-end
diff --git a/tests/viscoelastic_plate_flexure.prm.bak b/tests/viscoelastic_plate_flexure.prm.bak
deleted file mode 100644
index 9ec4375b878..00000000000
--- a/tests/viscoelastic_plate_flexure.prm.bak
+++ /dev/null
@@ -1,32 +0,0 @@
-# This test checks whether the viscoelastic finite-length elastic plate
-# flexure benchmark runs successfully.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_plate_flexure/viscoelastic_plate_flexure.prm
-
-set End time                               = 5
-set Output directory                       = viscoelastic_plate_flexure
-
-# Significantly reduce resolution
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 7
-  end
-end
-
-# No global refinement
-subsection Mesh refinement
-  set Initial global refinement          = 0
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = basic statistics, material statistics, velocity statistics, topography
-
-  subsection Topography
-    set Output to file           = false
-    set Time between text output = 0
-  end
-end
diff --git a/tests/viscoelastic_sheared_torsion.prm.bak b/tests/viscoelastic_sheared_torsion.prm.bak
deleted file mode 100644
index f6e5cadcf5c..00000000000
--- a/tests/viscoelastic_sheared_torsion.prm.bak
+++ /dev/null
@@ -1,9 +0,0 @@
-# This is a test for the viscoelastic sheared torsion benchmark defined
-# in benchmarks/viscoelastic_sheared_torsion.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_sheared_torsion/viscoelastic_sheared_torsion.prm
-
-
-# Global parameters
-set Dimension                                  = 3
-set End time                                   = 0.02
diff --git a/tests/viscoelastic_stress_averaging.prm.bak b/tests/viscoelastic_stress_averaging.prm.bak
deleted file mode 100644
index 8a8f1005e7f..00000000000
--- a/tests/viscoelastic_stress_averaging.prm.bak
+++ /dev/null
@@ -1,56 +0,0 @@
-# This test checks viscoelastic stress buildup with a
-# constant strain rate and an elastic time step equal
-# to a user-specified constant elastic time step. This
-# fixed elastic time step is double the numerical time step.
-# Stress averaging is used to account for the difference
-# between the numerical and elastic time step. Viscoelastic
-# stresses (sigma_xx, sigma_yy, sigma_xy) are tracked
-# with compositional fields. The parameter file is derived
-# from the 2D viscoelastic_stress_build-up benchmark with
-# modifications to the resolution, end time, material
-# properties and postprocessors.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-
-#  Global parameters
-set End time                               = 1e3
-set Output directory                       = viscoelastic_stress_averaging
-
-# Model geometry (100x100 km, 5 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 20
-    set Y repetitions = 20
-    set X extent      = 100e3
-    set Y extent      = 100e3
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 2800
-    set Viscosities                 = 1.e21
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = true
-    set Fixed elastic time step     = 2e3
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, depth average
-
-  subsection Depth average
-    set Time between graphical output = 0
-    set Number of zones = 5
-    set List of output variables = composition
-    set Output format = txt
-  end
-end
diff --git a/tests/viscoelastic_stress_build-up.prm.bak b/tests/viscoelastic_stress_build-up.prm.bak
deleted file mode 100644
index 07b892908cd..00000000000
--- a/tests/viscoelastic_stress_build-up.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# This test is a prestressed and smaller version of the
-# viscoelastic_stress_build-up benchmark.
-# The benchmark has a 2D analytical solution for the build-up
-# of stress in an initially unstressed viscoelastic medium subject to a
-# constant strain-rate. This benchmark is described in "Robust
-# characteristics method for modelling multiphase visco-elasto-plastic
-# thermo-mechanical problems" by Gerya and Yuen, 2007, Phys. Earth. Planet.
-# Inter., v. 163, p. 83-105. Full details of the benchmark are located in
-# section 3.1 and figure 3 of this manuscript.
-#
-# The analytical solution for viscoelastic stress build-up in
-# an incompressible medium with a constant strain-rate is:
-#   sigma_ij = 2 * edot_ii * eta * (1 - e^(-mu*t/eta)),
-# where sigma_ij is the elastic deviatoric stress tensor, edot_ij is
-# the deviatoric strain-rate, eta is the background viscosity, mu is the
-# shear modulus and t is time.
-#
-# Following the conditions described in section 3.1 and figure 3 from
-# Gerya and Yuen (2007), a 100x100 km body is subject to a constant
-# strain-rate of 1.e-14 s^-1 in both the horizontal and vertical directions.
-# Constant deformation is driven by inflow and outflow, respectively,
-# on the right and bottom walls. The top and left walls are free-slip.
-# The material has a viscosity of 1e22 Pa s and a shear modulus of 1e10 Pa.
-# With these values, the analytical solution predicts a horizontal
-# or vertical viscoelastic stress magnitude of ~ 200 MPa after 250 Kyr
-# of deformation. Significantly, the effective "viscoelastic" viscosity
-# is enforced to be constant through time by using a constant time step.
-# This is achieved by setting a maximum time step (1000 years) much lower
-# than the time step size given by the CFL number of 0.5.
-#
-# This result can be observed by viewing the compositional field values
-# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
-# of the viscoselastic stress tensor. Significantly, the composition is not
-# fixed on any boundary in order to prevent the formation of boundary artifacts
-# in the compositional fields tracking viscoelastic stresses.
-#
-# For the current test, we prescribe initial values to the compositional fields
-# that track the viscoelastic stresses that are equal to the
-# analytical solution for the viscoelastic stress after 250 Kyr.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-
-#  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1000
-set Use years in output instead of seconds = true
-set Output directory                       = output
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, left
-  set Prescribed velocity boundary indicators = bottom y:function, right x:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = Lx = 100000, yinsec = 31557600, eps_ii = 1e-14
-    set Function expression = if (x>50e3, Lx*eps_ii*yinsec, 0.); if (y<50e3, Lx*eps_ii*yinsec, 0.);
-  end
-end
-
-# Spatial domain of different compositional fields:
-# ve_stress_xx, ve_stress_yy, ve_stress_xy
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = eta = 1e22, mu = 1e10, eps = 1e-14, t = 250000, yinsec = 31557600
-    set Function expression = 2.*eta*eps*(1.-exp(-mu*t*yinsec/eta)); \
-                              -2.*eta*eps*(1.-exp(-mu*t*yinsec/eta)); \
-                              0
-  end
-end
-
-subsection Postprocess
-  subsection Visualization
-    set Time between graphical output = 1e3
-    set List of output variables = stress, shear stress, stress second invariant
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/viscoelastic_stress_build-up_gmg.prm.bak b/tests/viscoelastic_stress_build-up_gmg.prm.bak
deleted file mode 100644
index 9c1f3235417..00000000000
--- a/tests/viscoelastic_stress_build-up_gmg.prm.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-# This test is a prestressed and smaller version of the
-# viscoelastic_stress_build-up benchmark. The only differences
-# between this test case and tests/viscoelastic_stress_build-up.prm
-# are the use of the GMG solver and material averaging (required for
-# GMG) in this test.  Otherwise, all of the parameters are identical
-# between the two tests.
-#
-# The benchmark has a 2D analytical solution for the build-up
-# of stress in an initially unstressed viscoelastic medium subject to a
-# constant strain-rate. This benchmark is described in "Robust
-# characteristics method for modelling multiphase visco-elasto-plastic
-# thermo-mechanical problems" by Gerya and Yuen, 2007, Phys. Earth. Planet.
-# Inter., v. 163, p. 83-105. Full details of the benchmark are located in
-# section 3.1 and figure 3 of this manuscript.
-#
-# The analytical solution for viscoelastic stress build-up in
-# an incompressible medium with a constant strain-rate is:
-#   simga_ij = 2 * edot_ii * eta * (1 - e^(-mu*t/eta)),
-# where sigma_ij is the elastic deviatoric stress tensor, edot_ij is
-# the deviatoric strain-rate, eta is the background viscosity, mu is the
-# shear modulus and t is time.
-#
-# Following the conditions described in section 3.1 and figure 3 from
-# Gerya and Yuen (2007), a 100x100 km body is subject to a constant
-# strain-rate of 1.e-14 s^-1 in both the horizontal and vertical directions.
-# Constant deformation is driven by inflow and outflow, respectively,
-# on the right and bottom walls. The top and left walls are free-slip.
-# The material has a viscosity of 1e22 Pa s and a shear modulus of 1e10 Pa.
-# With these values, the analytical solution predicts a horizontal
-# or vertical viscoelastic stress magnitude of ~ 200 MPa after 250 Kyr
-# of deformation. Significantly, the effective "viscoelastic" viscosity
-# is enforced to be constant through time by using a constant time step.
-# This is achieved by setting a maximum time step (1000 years) much lower
-# than the time step size given by the CFL number of 0.5.
-#
-# This result can be observed by viewing the compositional field values
-# representing the horizontal (ve_stress_xx) or vertical (ve_stress_yy) components
-# of the viscoselastic stress tensor. Significantly, the composition is not
-# fixed on any boundary in order to prevent the formation of boundary artifacts
-# in the compositional fields tracking viscoelastic stresses.
-#
-# For the current test, we prescribe initial values to the compositional fields
-# that track the viscoelastic stresses that are equal to the eventual
-# analytical solution for the viscoelastic stress.
-
-include $ASPECT_SOURCE_DIR/benchmarks/viscoelastic_stress_build-up/viscoelastic_stress_build-up.prm
-
-
-#  Global parameters
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 1000
-set Use years in output instead of seconds = true
-set Output directory                       = viscoelastic_stress_build-up_gmg
-
-# Use GMG Stokes solver
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Stokes solver type = block GMG
-  end
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = top, left
-  set Prescribed velocity boundary indicators = bottom y:function, right x:function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = Lx = 100000, yinsec = 31557600, eps_ii = 1e-14
-    set Function expression = if (x>50e3, Lx*eps_ii*yinsec, 0.); if (y<50e3, Lx*eps_ii*yinsec, 0.);
-  end
-end
-
-# Spatial domain of different compositional fields:
-# ve_stress_xx, ve_stress_yy, ve_stress_xy
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  = eta = 1e22, mu = 1e10, eps = 1e-14, t = 250000, yinsec = 31557600
-    set Function expression = 2.*eta*eps*(1.-exp(-mu*t*yinsec/eta)); \
-                              -2.*eta*eps*(1.-exp(-mu*t*yinsec/eta)); \
-                              0
-  end
-end
-
-subsection Material model
-  set Material averaging = harmonic average only viscosity
-end
-
-subsection Postprocess
-  subsection Visualization
-    set Time between graphical output = 1e3
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/viscoelastoplastic_yield_plastic_viscous_strain_weakening.prm.bak b/tests/viscoelastoplastic_yield_plastic_viscous_strain_weakening.prm.bak
deleted file mode 100644
index 4b36b78d9a2..00000000000
--- a/tests/viscoelastoplastic_yield_plastic_viscous_strain_weakening.prm.bak
+++ /dev/null
@@ -1,77 +0,0 @@
-include $ASPECT_SOURCE_DIR/tests/visco_plastic_yield_plastic_viscous_strain_weakening.prm
-
-
-# Global parameters
-set Dimension                              = 2
-set End time                               = 1000
-set Max nonlinear iterations               = 2
-set Output directory                       = viscoelastoplastic_yield_plastic_viscous_strain_weakening
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 5
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, plastic_strain, viscous_strain
-end
-
-# We prescribe some initial strain at the center of the domain
-# plastic_strain, viscous_strain
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0; 0; 0; \
-                              if(x>=45e3&x<=55e3&y>=45.3e3&y<=55.e3,0.2,0); \
-                              if(x>=35e3&x<=65e3&y>=35.e3&y<=65.e3,0.8,0)
-  end
-end
-
-# Boundary composition specification
-subsection Boundary composition model
-  set List of model names = initial composition
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = true
-end
-
-# Material model (values for background material)
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Reference strain rate = 1.e-16
-    set Viscous flow law = dislocation
-    set Prefactors for dislocation creep = 5.e-23
-    set Stress exponents for dislocation creep = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep = 0.
-    set Yield mechanism = drucker
-    set Angles of internal friction = 0.
-    set Cohesions = 1.e6
-    set Strain weakening mechanism = plastic weakening with plastic strain and viscous weakening with viscous strain
-    set Start prefactor strain weakening intervals = 0.
-    set End prefactor strain weakening intervals = 1.0
-    set Prefactor strain weakening factors = 0.5
-    set Start plasticity strain weakening intervals = 0.
-    set End plasticity strain weakening intervals = 1.0
-    set Cohesion strain weakening factors = 0.5
-    set Friction strain weakening factors = 0.5
-    set Elastic shear moduli        = 1.e10
-    set Use fixed elastic time step = false
-    set Fixed elastic time step     = 1e3
-  end
-end
-
-# Post processing
-# named additional outputs includes the weakened cohesions and friction angles
-subsection Postprocess
-  set List of postprocessors = velocity statistics, mass flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = viscosity, strain rate, named additional outputs
-    set Time between graphical output = 1000
-  end
-end
diff --git a/tests/viscoplastic_melt_blob_freezing.prm.bak b/tests/viscoplastic_melt_blob_freezing.prm.bak
deleted file mode 100644
index a054fd7e2cb..00000000000
--- a/tests/viscoplastic_melt_blob_freezing.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-#########################################################
-# This is a test for the melting rate functionality,
-# in particular the freezing of melt.
-# It uses the reactive fluid transport material model composited
-# on top of the visco plastic material model.
-
-# The initial porosity has the form of a Gaussian function
-# there is a fixed (constant) freezing rate.
-
-# The amplitude of the Gaussian is 0.2, and the melting time
-# scale is chosen in such a way that the fraction of melt
-# should be cut in half every year (visible in the maximum
-# value of the porosity field).
-
-# This is like the rising_melt_blob_freezing test, except
-# that it uses the reactive fluid transport material model
-# composited with a visco plastic solid material model.
-# Outputs of this test and rising_melt_blob freezing should
-# be identical except for the the solid viscosity. This is because
-# the melt_simple material model uses a simple temperature scaled
-# solid viscosity, and the reactive_fluid_transport model used here
-# composites with a the visco plastic material model, with a different
-# viscosity calculation than the solid in melt_simple.
-
-############### Global parameters
-include $ASPECT_SOURCE_DIR/tests/rising_melt_blob_freezing.prm
-
-set Output directory = viscoplastic_melt_blob_freezing
-
-#The reactive fluid transport material model is composited on top
-# of the visco plastic material model. This example uses the default
-# settings of the visco plastic material model for the solid deformation,
-# which are not important for this test case.
-subsection Material model
-  set Model name =  reactive fluid transport
-  set Material averaging =  harmonic average
-
-  subsection Reactive Fluid Transport Model
-    set Base model = visco plastic
-    set Fluid-solid reaction scheme = katz2003
-
-    subsection Katz 2003 model
-      set Melt extraction depth = 0.0
-      set Freezing rate         = 1.0
-      set Melting time scale for operator splitting = 1.442695041
-    end
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables      = density, viscosity, thermal expansivity, melt material properties
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-
-    subsection Melt material properties
-      set List of properties = permeability, fluid density, compaction viscosity, fluid viscosity
-    end
-  end
-end
diff --git a/tests/viscoplastic_melt_fraction.prm.bak b/tests/viscoplastic_melt_fraction.prm.bak
deleted file mode 100644
index 07e90549a13..00000000000
--- a/tests/viscoplastic_melt_fraction.prm.bak
+++ /dev/null
@@ -1,118 +0,0 @@
-# This test checks whether the katz2003 mantle melting model in the
-# reactive transport material model produces the correct melt fraction output.
-#
-# Temperature will be held constant throughout model at 1573 K so at 1 GPa
-# melt fraction should be 15% from Katz et. al. 2003 Fig. 4
-
-set Adiabatic surface temperature          = 1573
-
-# The number of space dimensions you want to run this program in.
-set Dimension                              = 2
-
-# The end time of the simulation. Units: years if the 'Use years in output
-# instead of seconds' parameter is set; seconds otherwise.
-set End time                               = 1000
-set Pressure normalization                 = surface
-set Use years in output instead of seconds = true
-set Output directory                       = output-vp-melt-fraction
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = top, bottom
-
-  subsection Initial temperature
-    set Maximal temperature = 1573
-    set Minimal temperature = 1573
-  end
-end
-
-# The composition is not fixed on any boundary
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators =
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 100e3
-    set Y extent  = 100e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    # Magnitude of the gravity vector in $m/s^2$. The direction is always
-    # radially outward from the center of the earth.
-    set Magnitude = 10
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = porosity, peridotite
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 1573
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0;0
-  end
-end
-
-#The reactive fluid transport material model is composited on top
-# of the visco plastic material model. This example uses the default
-# settings of the visco plastic material model for the solid deformation,
-# which are not important for this test case.
-subsection Material model
-  set Model name =  reactive fluid transport
-  set Material averaging =  harmonic average
-
-  subsection Reactive Fluid Transport Model
-    set Base model = visco plastic
-    set Fluid-solid reaction scheme = katz2003
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 5
-  set Strategy                                 = composition
-  set Time steps between mesh refinement       = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = bottom, top, left, right
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Use direct solver for Stokes system = true
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization, melt statistics, pressure statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set List of output variables      = melt fraction, named additional outputs
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/viscosity_refinement.prm.bak b/tests/viscosity_refinement.prm.bak
deleted file mode 100644
index fff433301f9..00000000000
--- a/tests/viscosity_refinement.prm.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-# Test the viscosity refinement criterion
-set Adiabatic surface temperature          = 1623
-set Dimension                              = 2
-set End time                               = 0
-
-subsection Boundary temperature model
-  set List of model names = initial temperature
-  set Fixed temperature boundary indicators   = 0,3
-
-  subsection Initial temperature
-    set Maximal temperature = 3773
-    set Minimal temperature = 273
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 500000
-    set Y extent  = 500000
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function constants  = l=250000
-    set Function expression = if(x < l, 1873, 1623)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal viscosity exponent = 5.0
-    set Reference temperature = 1750
-  end
-end
-
-subsection Mesh refinement
-  set Coarsening fraction                      = 0.05
-  set Refinement fraction                      = 0.3
-  set Initial adaptive refinement              = 3
-  set Initial global refinement                = 2
-  set Strategy                                 = viscosity
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-  set Zero velocity boundary indicators       =
-end
-
-subsection Postprocess
-  set List of postprocessors =
-end
diff --git a/tests/viscous_dissipation_statistics.prm.bak b/tests/viscous_dissipation_statistics.prm.bak
deleted file mode 100644
index 8bb473c2542..00000000000
--- a/tests/viscous_dissipation_statistics.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# this is a version of the stokes' law input file
-# but with less mesh refinement
-
-
-
-############### Global parameters
-# We use a 3d setup. Since we are only interested
-# in a steady state solution, we set the end time
-# equal to the start time to force a single time
-# step before the program terminates.
-
-set Dimension                              = 3
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-############### Parameters describing the model
-# The setup is a 3d box with edge length 2890000 in which
-# all 6 sides have free slip boundary conditions. Because
-# the temperature plays no role in this model we need not
-# bother to describe temperature boundary conditions or
-# the material parameters that pertain to the temperature.
-
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent  = 2890000
-    set Y extent  = 2890000
-    set Z extent  = 2890000
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3,4,5
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Viscosity                     = 1e22
-    set Density differential for compositional field 1 = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 9.81
-  end
-end
-
-############### Parameters describing the temperature field
-# As above, there is no need to set anything for the
-# temperature boundary conditions.
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0
-  end
-end
-
-############### Parameters describing the compositional field
-# This, however, is the more important part: We need to describe
-# the compositional field and its influence on the density
-# function. The following blocks say that we want to
-# advect a single compositional field and that we give it an
-# initial value that is zero outside a sphere of radius
-# r=200000m and centered at the point (p,p,p) with
-# p=1445000 (which is half the diameter of the box) and one inside.
-# The last block re-opens the material model and sets the
-# density differential per unit change in compositional field to
-# 100.
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y,z
-    set Function constants  = r=200000,p=1445000
-    set Function expression = if(sqrt((x-p)*(x-p)+(y-p)*(y-p)+(z-p)*(z-p)) > r, 0, 1)
-  end
-end
-
-############### Parameters describing the discretization
-# The following parameters describe how often we want to refine
-# the mesh globally and adaptively, what fraction of cells should
-# be refined in each adaptive refinement step, and what refinement
-# indicator to use when refining the mesh adaptively.
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 2
-  set Initial global refinement          = 2
-  set Refinement fraction                = 0.2
-  set Strategy                           = velocity
-end
-
-############### Parameters describing what to do with the solution
-# The final section allows us to choose which postprocessors to
-# run at the end of each time step. We select to generate graphical
-# output that will consist of the primary variables (velocity, pressure,
-# temperature and the compositional fields) as well as the density and
-# viscosity. We also select to compute some statistics about the
-# velocity field.
-
-subsection Postprocess
-  set List of postprocessors = visualization, velocity statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = density, viscosity
-    set Output format                 = gnuplot
-  end
-end
diff --git a/tests/viscous_top_beam.prm.bak b/tests/viscous_top_beam.prm.bak
deleted file mode 100644
index 63b291dda6f..00000000000
--- a/tests/viscous_top_beam.prm.bak
+++ /dev/null
@@ -1,163 +0,0 @@
-# This parameter file reproduces a 2D benchmark for viscoelastic deformation
-# published in "Numerical modelling of magma dynamics coupled to tectonic
-# deformation of lithosphere and crust" by Keller, May and Kaus, 2013,
-# Geophys. J. Int., v. 195,  p. 1406-1422. The model setup and results are
-# described in detail in section B.2.3 and figure B5.
-#
-# The test uses a vertical beam instead of the one in the original
-# benchmark to check the directions of computed stress in the
-# postprocessors.
-#
-# In addition, elasticity is switched off.
-
-# Global parameters
-set Dimension                              = 2
-set End time                               = 2e3
-set Use years in output instead of seconds = true
-set CFL number                             = 0.5
-set Maximum time step                      = 1e3
-
-# Solver settings
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Number of cheap Stokes solver steps = 2000
-  end
-end
-
-# Model geometry (7.5x5 km, 0.1 km spacing)
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X repetitions = 15
-    set Y repetitions = 10
-    set X extent      = 7.5e3
-    set Y extent      = 5e3
-  end
-end
-
-# Mesh refinement specifications
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-# Element types
-subsection Discretization
-  set Temperature polynomial degree           = 1
-  set Use locally conservative discretization = false
-  set Use discontinuous temperature discretization = false
-  set Use discontinuous composition discretization = true
-
-  subsection Stabilization parameters
-    set Use limiter for discontinuous composition solution = true
-    set Global composition maximum =  1.e11,  1.e11,  1.e11, 1.0
-    set Global composition minimum = -1.e11, -1.e11, -1.e11, 0.0
-  end
-end
-
-# Formulation classification
-subsection Formulation
-  set Enable elasticity = false
-end
-
-# Velocity boundary conditions
-subsection Boundary velocity model
-  set Zero velocity boundary indicators       = top
-  set Tangential velocity boundary indicators = bottom, left, right
-end
-
-# Number and name of compositional fields
-subsection Compositional fields
-  set Number of fields = 4
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy, beam
-  set Types of fields = generic, generic, generic, chemical composition
-end
-
-# Spatial domain of different compositional fields
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function constants  =
-    set Function expression = 0; 0; 0; if (x>=3.5e3 && x<=4.0e3 && y>=3.0e3, 1, 0)
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set Fixed composition boundary indicators  = bottom, top, right, left
-  set List of model names                   = initial composition
-end
-
-# Temperature boundary conditions
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators = bottom, top, left, right
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 293
-    set Left temperature   = 293
-    set Right temperature  = 293
-    set Top temperature    = 293
-  end
-end
-
-# Temperature initial conditions
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 293
-  end
-end
-
-# Material model
-subsection Material model
-  set Model name = visco plastic
-
-  subsection Visco Plastic
-    set Densities            =  2800,  2800,  2800,  2800,  6000
-    set Viscous flow law                          = dislocation
-    set Prefactors for dislocation creep          = 5.e-19, 5.e-19, 5.e-19, 5.e-19, 5.e-25
-    set Stress exponents for dislocation creep    = 1.0
-    set Activation energies for dislocation creep = 0.
-    set Activation volumes for dislocation creep  = 0.
-    set Elastic shear moduli = 1.e11, 1.e11, 1.e11, 1.e11, 1.e10
-    set Fixed elastic time step     = 2e3
-    set Use fixed elastic time step = true
-    set Viscosity averaging scheme  = maximum composition
-    set Cohesions = 1.e50
-  end
-end
-
-# Gravity model
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.
-  end
-end
-
-# Post processing
-subsection Postprocess
-  set List of postprocessors = velocity statistics, basic statistics, temperature statistics, visualization
-
-  subsection Visualization
-    set List of output variables = material properties, strain rate, stress second invariant, principal stress
-    set Output format = gnuplot
-    set Time steps between graphical output = 1
-    set Interpolate output = true
-
-    subsection Principal stress
-      set Use deviatoric stress = true
-    end
-
-    subsection Material properties
-      set List of material properties = density, viscosity
-    end
-  end
-end
diff --git a/tests/visualization_averaged_strain_rate.prm.bak b/tests/visualization_averaged_strain_rate.prm.bak
deleted file mode 100644
index 3373e94fdc1..00000000000
--- a/tests/visualization_averaged_strain_rate.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# A testcase for the "Point-wise stress and strain" setting for the "strain
-# rate" visualization postprocessor. It solves the equations on a box with
-# Dirichlet boundary conditions equal to (z*z,0), which then is also the
-# velocity everywhere. This yields a linear strain rate.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z*z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Point-wise stress and strain = false
-    set Output format = gnuplot
-    set List of output variables = strain rate
-  end
-end
diff --git a/tests/visualization_averaged_strain_rate2.prm.bak b/tests/visualization_averaged_strain_rate2.prm.bak
deleted file mode 100644
index d9d292ede95..00000000000
--- a/tests/visualization_averaged_strain_rate2.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-# Like visualization_averaged_strain_rate.prm but without averaging turned on.
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/visualization_averaged_strain_rate.prm
-
-
-subsection Postprocess
-  subsection Visualization
-    set Point-wise stress and strain = true
-  end
-end
diff --git a/tests/visualization_conductivity_diffusivity.prm.bak b/tests/visualization_conductivity_diffusivity.prm.bak
deleted file mode 100644
index 985766ad368..00000000000
--- a/tests/visualization_conductivity_diffusivity.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-#########################################################
-# This tests that the thermal conductivity and diffusivity
-# visualization postprocessors are working correctly.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 3e-5
-    set Reference specific heat                        = 1
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-# For a temperature between zero and one,
-# density will vary between (1 - 3e-5) and 1.
-# The thermal conductivity is set to 1e-6 everywhere
-# and the thermal diffusivity (k/(rho c_p))
-# will thus vary from 1e-6 to 1.00003e-6
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format = gnuplot
-    set List of output variables = density, thermal conductivity, thermal diffusivity, specific heat
-  end
-end
diff --git a/tests/visualization_higher_order_output.prm.bak b/tests/visualization_higher_order_output.prm.bak
deleted file mode 100644
index 3c2075d9a14..00000000000
--- a/tests/visualization_higher_order_output.prm.bak
+++ /dev/null
@@ -1,17 +0,0 @@
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/cookbooks/van-keken/van-keken-smooth.prm
-
-set End time = 0.0
-
-subsection Mesh refinement
-  set Initial adaptive refinement              = 0
-  set Initial global refinement                = 3
-end
-
-subsection Postprocess
-  subsection Visualization
-    set Interpolate output = true
-    set Write higher order output = true
-  end
-end
diff --git a/tests/visualization_shear_stress.prm.bak b/tests/visualization_shear_stress.prm.bak
deleted file mode 100644
index 8fb8c817718..00000000000
--- a/tests/visualization_shear_stress.prm.bak
+++ /dev/null
@@ -1,87 +0,0 @@
-# A testcase for the "shear stress" visualization postprocessor. It solves the
-# equations on a box with Dirichlet boundary conditions equal to
-# (z,0), which then is also the velocity everywhere. This yields
-# a constant strain rate [[0,1/2],[1/2,0]]
-#
-# the shear stress is then simply this tensor times -2*eta and we set
-# eta=42 below.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 42
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Point-wise stress and strain = false
-    set Output format = gnuplot
-    set List of output variables = shear stress
-  end
-end
diff --git a/tests/visualization_shear_stress_pointwise.prm.bak b/tests/visualization_shear_stress_pointwise.prm.bak
deleted file mode 100644
index de0fe74a4b0..00000000000
--- a/tests/visualization_shear_stress_pointwise.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-# Like visualization_shear_stress.prm but with point-wise output
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/visualization_shear_stress.prm
-
-
-subsection Postprocess
-  subsection Visualization
-    set Point-wise stress and strain = true
-  end
-end
diff --git a/tests/visualization_shear_stress_viscoelastic.prm.bak b/tests/visualization_shear_stress_viscoelastic.prm.bak
deleted file mode 100644
index 0e5a0b948c8..00000000000
--- a/tests/visualization_shear_stress_viscoelastic.prm.bak
+++ /dev/null
@@ -1,49 +0,0 @@
-# A testcase for the "shear stress" visualization postprocessor
-# when elasticity is enabled. The rheology is viscoelastic,
-# but otherwise the test is identical to visualization_shear_stress.prm.
-# In the first timestep, the elastic initial conditions
-# impose zero differential stress. A very high shear modulus relative
-# to the viscosity ensures that the differential stress quickly approaches
-# the value from the original viscous test.
-#
-# The test solves the equations on a box with Dirichlet boundary
-# conditions equal to (z,0), which then is also the velocity everywhere.
-# This yields a constant strain rate [[0,1/2],[1/2,0]].
-#
-# the stress is then simply this tensor times -2*eta plus the pressure and we set
-# eta=42 below. compared to the visualization_shear_stress test, the test
-# also includes a nonzero gravity so that we get a nonconstant pressure
-#
-# the second invariant of the deviatoric stress will be 42.
-
-include $ASPECT_SOURCE_DIR/tests/visualization_shear_stress.prm
-
-set End time                               = 1
-
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 1
-    set Viscosities                 = 42
-    set Elastic shear moduli        = 1e16
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
-end
-
-subsection Postprocess
-  subsection Visualization
-    set Time between graphical output = 1
-    set Interpolate output = true
-  end
-end
diff --git a/tests/visualization_strain_rate.prm.bak b/tests/visualization_strain_rate.prm.bak
deleted file mode 100644
index db121ab3211..00000000000
--- a/tests/visualization_strain_rate.prm.bak
+++ /dev/null
@@ -1,84 +0,0 @@
-# A testcase for the "strain rate" visualization postprocessor. It solves the
-# equations on a box with Dirichlet boundary conditions equal to
-# (z,0), which then is also the velocity everywhere. This yields
-# a constant strain rate [[0,1/2],[1/2,0]] with norm |dot eps|=1/sqrt(2).
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Point-wise stress and strain = false
-    set Output format = gnuplot
-    set List of output variables = strain rate
-  end
-end
diff --git a/tests/visualization_strain_rate_pointwise.prm.bak b/tests/visualization_strain_rate_pointwise.prm.bak
deleted file mode 100644
index 4e85497f782..00000000000
--- a/tests/visualization_strain_rate_pointwise.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-# Like visualization_strain_rate.prm but with point-wise output
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/visualization_strain_rate.prm
-
-
-subsection Postprocess
-  subsection Visualization
-    set Point-wise stress and strain = true
-  end
-end
diff --git a/tests/visualization_strain_rate_tensor.prm.bak b/tests/visualization_strain_rate_tensor.prm.bak
deleted file mode 100644
index f65ccca708b..00000000000
--- a/tests/visualization_strain_rate_tensor.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# A testcase for the "strain rate tensor" visualization postprocessor. It solves the
-# equations on a box with Dirichlet boundary conditions equal to
-# (z,0), which then is also the velocity everywhere. This yields
-# a constant strain rate [[0,1/2],[1/2,0]].
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Point-wise stress and strain = true
-    set Output format = gnuplot
-    set List of output variables = strain rate tensor
-  end
-end
diff --git a/tests/visualization_strain_rate_tensor_pointwise.prm.bak b/tests/visualization_strain_rate_tensor_pointwise.prm.bak
deleted file mode 100644
index 4a15cce0c76..00000000000
--- a/tests/visualization_strain_rate_tensor_pointwise.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-# Like visualization_strain_rate_tensor.prm but with point-wise output
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/visualization_strain_rate_tensor.prm
-
-
-subsection Postprocess
-  subsection Visualization
-    set Point-wise stress and strain = true
-  end
-end
diff --git a/tests/visualization_stress.prm.bak b/tests/visualization_stress.prm.bak
deleted file mode 100644
index 57963d287e3..00000000000
--- a/tests/visualization_stress.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# A testcase for the "stress" visualization postprocessor. It solves the
-# equations on a box with Dirichlet boundary conditions equal to
-# (z,0), which then is also the velocity everywhere. This yields
-# a constant strain rate [[0,1/2],[1/2,0]]
-#
-# the stress is then simply this tensor times -2*eta plus the pressure and we set
-# eta=42 below. compared to the visualization_shear_stress test, the test
-# also includes a nonzero gravity so that we get a nonconstant pressure
-#
-# the second invariant of the deviatoric stress will be 42.
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# choose a gravity to ensure that there is a pressure
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 42
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Point-wise stress and strain = false
-    set Output format = gnuplot
-    set List of output variables = stress, stress second invariant
-  end
-end
diff --git a/tests/visualization_stress_pointwise.prm.bak b/tests/visualization_stress_pointwise.prm.bak
deleted file mode 100644
index 7e292b75ce7..00000000000
--- a/tests/visualization_stress_pointwise.prm.bak
+++ /dev/null
@@ -1,12 +0,0 @@
-# Like visualization_stress.prm but with point-wise output
-
-set Dimension = 2
-
-include $ASPECT_SOURCE_DIR/tests/visualization_stress.prm
-
-
-subsection Postprocess
-  subsection Visualization
-    set Point-wise stress and strain = true
-  end
-end
diff --git a/tests/visualization_stress_viscoelastic.prm.bak b/tests/visualization_stress_viscoelastic.prm.bak
deleted file mode 100644
index b402535e662..00000000000
--- a/tests/visualization_stress_viscoelastic.prm.bak
+++ /dev/null
@@ -1,49 +0,0 @@
-# A testcase for the "stress" visualization postprocessor
-# when elasticity is enabled. The rheology is viscoelastic,
-# but otherwise the test is identical to visualization_stress.prm.
-# In the first timestep, the elastic initial conditions
-# impose zero differential stress. A very high shear modulus relative
-# to the viscosity ensures that the differential stress quickly approaches
-# the value from the original viscous test.
-#
-# The test solves the equations on a box with Dirichlet boundary
-# conditions equal to (z,0), which then is also the velocity everywhere.
-# This yields a constant strain rate [[0,1/2],[1/2,0]].
-#
-# the stress is then simply this tensor times -2*eta plus the pressure and we set
-# eta=42 below. compared to the visualization_shear_stress test, the test
-# also includes a nonzero gravity so that we get a nonconstant pressure
-#
-# the second invariant of the deviatoric stress will be 42.
-
-include $ASPECT_SOURCE_DIR/tests/visualization_stress.prm
-
-set End time                               = 1
-
-subsection Formulation
-  set Enable elasticity = true
-end
-
-subsection Material model
-  set Model name = viscoelastic
-
-  subsection Viscoelastic
-    set Densities                   = 1
-    set Viscosities                 = 42
-    set Elastic shear moduli        = 1e16
-    set Use fixed elastic time step = false
-    set Viscosity averaging scheme  = harmonic
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields  = ve_stress_xx, ve_stress_yy, ve_stress_xy
-end
-
-subsection Postprocess
-  subsection Visualization
-    set Time between graphical output = 1
-    set Interpolate output = true
-  end
-end
diff --git a/tests/visualization_temperature_anomaly.prm.bak b/tests/visualization_temperature_anomaly.prm.bak
deleted file mode 100644
index 60a5b9731ab..00000000000
--- a/tests/visualization_temperature_anomaly.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-#########################################################
-# This tests that the temperature anomaly
-# visualization postprocessor is working correctly.
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 2
-    set Y extent = 1
-  end
-end
-
-subsection Boundary temperature model
-  set Fixed temperature boundary indicators   = 2, 3
-  set List of model names = box
-
-  subsection Box
-    set Bottom temperature = 1
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0, 1, 2, 3
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function expression = (1-z)
-  end
-end
-
-# Compared to the passive material model, we here make
-# the density composition dependent by letting it depend
-# linearly on the value of the first compositional field.
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Thermal conductivity                           = 1e-6
-    set Thermal expansion coefficient                  = 3e-5
-    set Reference specific heat                        = 1
-    set Viscosity                                      = 1
-    set Reference density                              = 1
-    set Reference temperature                          = 0
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-# For a temperature between zero and one,
-# density will vary between (1 - 3e-5) and 1.
-# The thermal conductivity is set to 1e-6 everywhere
-# and the thermal diffusivity (k/(rho c_p))
-# will thus vary from 1e-6 to 1.00003e-6
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format = gnuplot
-    set List of output variables = temperature anomaly
-
-    subsection Temperature anomaly
-      set Number of depth slices = 6
-      set Use maximal temperature for bottom = false
-    end
-  end
-end
diff --git a/tests/visualization_unique_list.prm.bak b/tests/visualization_unique_list.prm.bak
deleted file mode 100644
index 1fdb22897c0..00000000000
--- a/tests/visualization_unique_list.prm.bak
+++ /dev/null
@@ -1,83 +0,0 @@
-# A testcase to make sure the has_unique_entries function
-# successfully reports wrong input files.
-
-# EXPECT FAILURE
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1, 2, 3
-end
-
-# no gravity. the pressure will equal just the dynamic component
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 0
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-# temperature field doesn't matter. set it to zero
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Function expression = x
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = 0: function, 1: function, 2: function, 3: function
-
-  subsection Function
-    set Variable names = x,z
-    set Function expression = z;0
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set Output format = gnuplot
-    set List of output variables = strain rate, strain rate
-  end
-end
diff --git a/tests/visualization_vertical_heat_flux.prm.bak b/tests/visualization_vertical_heat_flux.prm.bak
deleted file mode 100644
index d035ec9757e..00000000000
--- a/tests/visualization_vertical_heat_flux.prm.bak
+++ /dev/null
@@ -1,90 +0,0 @@
-# Test for vertical heat flux visualization postprocessor
-
-set Dimension                              = 2
-set Use years in output instead of seconds = false
-set End time                               = 0.0
-set Output directory                       = output
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,z
-    set Function constants  = p=0.01, L=1, pi=3.1415926536, k=1
-    set Function expression = (1.0-z) - p*cos(k*pi*x/L)*sin(pi*z)
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = bottom, top
-
-  subsection Box
-    set Bottom temperature = 1
-    set Left temperature   = 0
-    set Right temperature  = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = left, right, bottom, top
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 1e14   # = Ra / Thermal expansion coefficient
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1
-    set Thermal expansion coefficient = 1e-10
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 4
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-end
-
-# add vertical heat flux to visualization postprocessor
-subsection Postprocess
-  set List of postprocessors = velocity statistics, temperature statistics, heat flux statistics, visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = vertical heat flux
-    set Time between graphical output = 0.00
-    set Output format = gnuplot
-  end
-end
-
-subsection Solver parameters
-  set Temperature solver tolerance = 1e-10
-
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1e-7
-  end
-end
diff --git a/tests/viz_mesh_deform_vector.prm.bak b/tests/viz_mesh_deform_vector.prm.bak
deleted file mode 100644
index cf12c76932a..00000000000
--- a/tests/viz_mesh_deform_vector.prm.bak
+++ /dev/null
@@ -1,124 +0,0 @@
-# Test undeformed mesh output and mesh deformation displacement
-#
-# copied from free_surface_blob.prm
-
-set Dimension = 2
-set CFL number                             = 0.5
-set End time                               = 1e8
-set Output directory                       = output
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Pressure normalization                 = no
-set Timing output frequency                = 5
-set Use years in output instead of seconds = true
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = 2,3
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = 2:0,3:0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500.e3
-    set Y extent = 200.e3
-    set X repetitions = 5
-    set Y repetitions = 2
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10.0
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression =  if( sqrt( (x-250.e3)^2 + (y-100.e3)^2 ) < 25.e3, 200.0, 0.0)
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 3300
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0.0
-    set Thermal conductivity          = 4.7
-    set Thermal expansion coefficient = 4e-5
-    set Viscosity                     = 1.e21
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.00
-  set Strategy                           = temperature
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1
-  set Zero velocity boundary indicators       = 2
-end
-
-subsection Mesh deformation
-  set Mesh deformation boundary indicators = 3: free surface
-
-  subsection Free surface
-    set Free surface stabilization theta = 0.5
-  end
-end
-
-subsection Termination criteria
-  set Termination criteria = end step
-  set End step = 10
-end
-
-subsection Postprocess
-  set List of postprocessors = topography,velocity statistics, basic statistics, visualization
-
-  subsection Visualization
-    set Time between graphical output = 0
-    set Output undeformed mesh = true
-    set Output mesh velocity = true
-    set Output mesh displacement      = true
-    set Output format                 = gnuplot
-  end
-end
-
-subsection Solver parameters
-  subsection Stokes solver parameters
-    set Linear solver tolerance = 1.e-7
-    set Number of cheap Stokes solver steps = 0
-  end
-end
diff --git a/tests/viz_plugin_dependency.cc.bak b/tests/viz_plugin_dependency.cc.bak
deleted file mode 100644
index 1975629b0b8..00000000000
--- a/tests/viz_plugin_dependency.cc.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// create a visualization postprocessor that requires something else
-//
-// this works just like the plugin_dependency* tests, just that it's a
-// viz postprocessor, not a regular postprocessor that has
-// dependencies
-
-#include "../benchmarks/solcx/solcx.cc"
-#include <aspect/postprocess/visualization.h>
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      template <int dim>
-      class MyPostprocessor
-        : public DataPostprocessorScalar<dim>,
-          public SimulatorAccess<dim>,
-          public Interface<dim>
-      {
-        public:
-          MyPostprocessor ()
-            :
-            DataPostprocessorScalar<dim> ("my_postprocessor",
-                                          update_default)
-          {}
-
-          virtual
-          void
-          evaluate_vector_field (const DataPostprocessorInputs::Vector<dim> &input_data,
-                                 std::vector<Vector<double>>               &computed_quantities) const
-          {
-            Assert (computed_quantities[0].size() == 1, ExcInternalError());
-
-            for (unsigned int q=0; q<computed_quantities.size(); ++q)
-              {
-                // not important what we do here :-)
-                computed_quantities[q](0) = 0;
-              }
-          }
-
-          virtual
-          std::list<std::string>
-          required_other_postprocessors () const
-          {
-            // select a postprocessor that is not selected in the .prm file
-            std::list<std::string> deps;
-            deps.push_back ("velocity statistics");
-            return deps;
-          }
-      };
-    }
-  }
-}
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    namespace VisualizationPostprocessors
-    {
-      ASPECT_REGISTER_VISUALIZATION_POSTPROCESSOR(MyPostprocessor,
-                                                  "my postprocessor",
-                                                  ".")
-    }
-  }
-}
diff --git a/tests/viz_plugin_dependency.prm.bak b/tests/viz_plugin_dependency.prm.bak
deleted file mode 100644
index 4da6310c80e..00000000000
--- a/tests/viz_plugin_dependency.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-# Test that the way we provide postprocessors to state that they
-# depend on other postprocessors works
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = no Advection, iterated Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = SolCxMaterial
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-
-    # choose a postprocessor that will in turn require another one
-    # to run as well (here, velocity statistics)
-    set List of output variables = my postprocessor
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/viz_spherical_velocity_components.prm.bak b/tests/viz_spherical_velocity_components.prm.bak
deleted file mode 100644
index e8632525cea..00000000000
--- a/tests/viz_spherical_velocity_components.prm.bak
+++ /dev/null
@@ -1,80 +0,0 @@
-##### test visualization postprocessor "spherical velocity components"
-
-set Dimension                              = 3
-set Use years in output instead of seconds = true
-set End time                               = 0
-set Adiabatic surface temperature          = 1613.0
-
-subsection Geometry model
-  set Model name = spherical shell
-
-  subsection Spherical shell
-    set Inner radius = 3481000
-    set Outer radius = 6336000
-  end
-end
-
-subsection Initial temperature model
-  set Model name = harmonic perturbation
-
-  subsection Harmonic perturbation
-    set Magnitude = 3
-    set Reference temperature = 1613
-  end
-end
-
-subsection Boundary temperature model
-  set List of model names = spherical constant
-  set Fixed temperature boundary indicators   = inner, outer
-
-  subsection Spherical constant
-    set Inner temperature = 3000
-    set Outer temperature = 273
-  end
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = inner
-  set Prescribed velocity boundary indicators = outer: function
-
-  subsection Function
-    set Coordinate system   = spherical
-    set Variable names      = r, phi, theta
-    set Function expression = sin(4*phi);sin(2*phi);cos(theta)
-    set Use spherical unit vectors = true
-  end
-end
-
-subsection Gravity model
-  set Model name = radial constant
-
-  subsection Radial constant
-    set Magnitude = 10
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Viscosity = 1e21
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement                = 1
-  set Initial adaptive refinement              = 0
-  set Time steps between mesh refinement       = 0
-  set Strategy                                 = temperature
-end
-
-subsection Postprocess
-  set List of postprocessors = velocity statistics, visualization
-
-  subsection Visualization
-    set List of output variables      = spherical velocity components
-    set Interpolate output = false
-    set Time between graphical output = 0
-    set Output format = gnuplot
-  end
-end
diff --git a/tests/vof_circle_1.cc.bak b/tests/vof_circle_1.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_circle_1.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_circle_1.prm.bak b/tests/vof_circle_1.prm.bak
deleted file mode 100644
index 565f8d667b8..00000000000
--- a/tests/vof_circle_1.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# Test advecting a circle under a constant velocity field
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.25
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Box origin X coordinate = -2.0
-    set Box origin Y coordinate = -2.0
-    set X extent = 4
-    set Y extent = 4
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-    set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, volume of fluid mms
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 0.25
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-      set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
-    end
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 2.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_circle_amr.cc.bak b/tests/vof_circle_amr.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_circle_amr.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_circle_amr.prm.bak b/tests/vof_circle_amr.prm.bak
deleted file mode 100644
index 6160cf141ed..00000000000
--- a/tests/vof_circle_amr.prm.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-# Test advecting a circle under a constant velocity field
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.25
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Minimum refinement level           = 2
-  set Initial global refinement          = 3
-  set Initial adaptive refinement        = 2
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-  set Strategy                                 = volume of fluid interface
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Box origin X coordinate = -2.0
-    set Box origin Y coordinate = -2.0
-    set X extent = 4
-    set Y extent = 4
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-    set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, volume of fluid mms
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 0.25
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-      set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
-    end
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 2.0
-    set List of output variables = volume of fluid values, error indicator
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_circle_mpi.cc.bak b/tests/vof_circle_mpi.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_circle_mpi.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_circle_mpi.prm.bak b/tests/vof_circle_mpi.prm.bak
deleted file mode 100644
index 4797696b132..00000000000
--- a/tests/vof_circle_mpi.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# MPI: 4
-
-# Set velocity field test parameter file
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.25
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Initial global refinement          = 4
-  set Initial adaptive refinement        = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Box origin X coordinate = -2.0
-    set Box origin Y coordinate = -2.0
-    set X extent = 4
-    set Y extent = 4
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-    set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, volume of fluid mms
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 0.25
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-      set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
-    end
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 2.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_circle_mpi_amr.cc.bak b/tests/vof_circle_mpi_amr.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_circle_mpi_amr.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_circle_mpi_amr.prm.bak b/tests/vof_circle_mpi_amr.prm.bak
deleted file mode 100644
index 39928ff92d1..00000000000
--- a/tests/vof_circle_mpi_amr.prm.bak
+++ /dev/null
@@ -1,99 +0,0 @@
-# MPI: 4
-
-# Set velocity field test parameter file
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.04
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Minimum refinement level           = 1
-  set Initial global refinement          = 1
-  set Initial adaptive refinement        = 2
-  set Time steps between mesh refinement = 1
-  set Run postprocessors on initial refinement = true
-  set Strategy                                 = volume of fluid interface
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set Box origin X coordinate = -2.0
-    set Box origin Y coordinate = -2.0
-    set X extent = 4
-    set Y extent = 4
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-    set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, volume of fluid mms
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 0.25
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = x0=-1.0, y0=-1.0, xv=1.0, yv=1.0
-      set Function expression = 0.5-sqrt((x-x0-xv*t)^2+(y-y0-yv*t)^2)
-    end
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 2.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_composition_init.prm.bak b/tests/vof_composition_init.prm.bak
deleted file mode 100644
index 531f9132266..00000000000
--- a/tests/vof_composition_init.prm.bak
+++ /dev/null
@@ -1,81 +0,0 @@
-# Test for linear interface under constant velocity
-# Error should be at machine precision
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 3
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Time steps between mesh refinement = 0
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100
-    set Y extent = 100
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:composition
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function expression = 50-y
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, composition statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_err_calc.h.bak b/tests/vof_err_calc.h.bak
deleted file mode 100644
index d51500e7d95..00000000000
--- a/tests/vof_err_calc.h.bak
+++ /dev/null
@@ -1,342 +0,0 @@
-/*
-  Copyright (C) 2011 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file doc/COPYING.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#include <aspect/global.h>
-#include <aspect/simulator_access.h>
-#include <aspect/postprocess/interface.h>
-#include <aspect/volume_of_fluid/utilities.h>
-#include <aspect/volume_of_fluid/handler.h>
-
-// Deal II includes
-#include <deal.II/base/parsed_function.h>
-#include <deal.II/base/quadrature_lib.h>
-#include <deal.II/fe/fe_values.h>
-
-
-namespace aspect
-{
-  namespace Postprocess
-  {
-    using namespace dealii;
-
-    template <int dim>
-    class VolumeOfFluidSpecifiedSolutionDiff : public Interface<dim>, public ::aspect::SimulatorAccess<dim>
-    {
-      public:
-        VolumeOfFluidSpecifiedSolutionDiff();
-
-        double get_next_t (const double curr_time, const double interval);
-
-        /**
-         * Evaluate the solution for some velocity statistics.
-         */
-        virtual
-        std::pair<std::string,std::string>
-        execute (TableHandler &);
-
-        /**
-         * Declare the parameters this class takes through input files.
-         */
-        static
-        void
-        declare_parameters (ParameterHandler &prm);
-
-        /**
-         * Read the parameters this class declares from the parameter file.
-         */
-        virtual
-        void
-        parse_parameters (ParameterHandler &prm);
-
-      private:
-        // Error calculation functions
-        static std::vector<std::string> error_names ();
-        static std::vector<std::string> error_abrev ();
-        std::vector<double> calc_error_level_set (const Function<dim> &func,
-                                                  const unsigned int n_samp,
-                                                  const unsigned int f_ind);
-
-        // Required variables
-        bool initialized;
-        double error_eval_interval;
-        double next_evaluation_time;
-        unsigned int n_error_samples;
-
-        /**
-         * Level set function for true solution
-         */
-        std::unique_ptr<Functions::ParsedFunction<dim>> trueSolLS;
-    };
-
-    template <int dim>
-    VolumeOfFluidSpecifiedSolutionDiff<dim>::VolumeOfFluidSpecifiedSolutionDiff ()
-      : initialized(false),
-        error_eval_interval (std::numeric_limits<double>::quiet_NaN ()),
-        next_evaluation_time (std::numeric_limits<double>::quiet_NaN ()),
-        n_error_samples (1)
-    {
-    }
-
-    template <int dim>
-    double VolumeOfFluidSpecifiedSolutionDiff<dim>::get_next_t (const double curr_time,
-                                                                const double interval)
-    {
-      const int i = (int) (curr_time / interval);
-      return (i + 1) * interval;
-    }
-
-    template <int dim>
-    std::pair<std::string, std::string>
-    VolumeOfFluidSpecifiedSolutionDiff<dim>::execute (TableHandler &)
-    {
-      std::string result_string = "";
-      std::string label_string = "";
-      if (!initialized)
-        {
-          initialized = true;
-          next_evaluation_time = this->get_time ();
-        }
-
-      if (this->get_time () >= next_evaluation_time)
-        {
-          std::vector<std::string> err_abrev = error_abrev ();
-          double curr_time = this->get_time();
-          if (this->convert_output_to_years())
-            curr_time /= year_in_seconds;
-          trueSolLS->set_time(curr_time);
-
-          std::ostringstream label_stream;
-          std::ostringstream err_str;
-          label_stream << "VoF Calculation(";
-
-          unsigned int n_err = err_abrev.size();
-          std::vector<std::string>::iterator it = err_abrev.begin();
-          for (; it!=err_abrev.end(); )
-            {
-              label_stream << *it;
-              if (++it!=err_abrev.end())
-                label_stream << '/';
-            }
-          label_stream << "):";
-          label_string = label_stream.str();
-
-          unsigned int n_volume_of_fluid_fields = this->get_volume_of_fluid_handler().get_n_fields();
-          std::vector<double> local_err_vals (n_volume_of_fluid_fields*n_err);
-          for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
-            {
-              std::vector<double> l_err_vals_f = calc_error_level_set (*trueSolLS, n_error_samples, f);
-              for (unsigned int i=0; i<n_err; ++i)
-                local_err_vals[f*n_err+i] = l_err_vals_f[i];
-            }
-
-          std::vector<double> global_err_vals(n_volume_of_fluid_fields*n_err);
-          Utilities::MPI::sum (local_err_vals, this->get_mpi_communicator(), global_err_vals);
-
-          for (unsigned int f=0; f<n_volume_of_fluid_fields; ++f)
-            {
-              for (unsigned int i=0; i<n_err; ++i)
-                {
-                  err_str << std::scientific << std::setprecision (8)
-                          << global_err_vals[f*n_err+i];
-                  if (i+1<n_err)
-                    err_str << " / ";
-                }
-              if (f+1<n_volume_of_fluid_fields)
-                err_str << " // ";
-            }
-          result_string = err_str.str ();
-          next_evaluation_time = get_next_t (this->get_time (), error_eval_interval);
-        }
-      return std::make_pair (label_string, result_string);
-    }
-
-    template <int dim>
-    void
-    VolumeOfFluidSpecifiedSolutionDiff<dim>::declare_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("VoF MMS");
-        {
-          prm.declare_entry ("Time between error estimates", "1e8",
-                             Patterns::Double (0.),
-                             "Time interval between error estimates.");
-
-          prm.declare_entry ("Number error samples", "3",
-                             Patterns::Integer (1),
-                             "Number of iterations for the midpoint quadrature used to accumulate the error estimate");
-
-          prm.enter_subsection ("True LS");
-          {
-            Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
-          }
-          prm.leave_subsection ();
-
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    void
-    VolumeOfFluidSpecifiedSolutionDiff<dim>::parse_parameters (ParameterHandler &prm)
-    {
-      prm.enter_subsection("Postprocess");
-      {
-        prm.enter_subsection("VoF MMS");
-        {
-          n_error_samples = prm.get_integer ("Number error samples");
-
-          error_eval_interval = prm.get_double ("Time between error estimates");
-          if (this->convert_output_to_years())
-            error_eval_interval *= year_in_seconds;
-          prm.enter_subsection ("True LS");
-          {
-            trueSolLS.reset(new Functions::ParsedFunction<dim>(this->get_volume_of_fluid_handler().get_n_fields()));
-            trueSolLS->parse_parameters (prm);
-          }
-          prm.leave_subsection ();
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection();
-    }
-
-    template <int dim>
-    std::vector<std::string> VolumeOfFluidSpecifiedSolutionDiff<dim>::error_abrev ()
-    {
-      std::vector<std::string> names (1, "IEstL1");
-      names.push_back ("FEstL1");
-      return names;
-    }
-
-    template <int dim>
-    std::vector<double> VolumeOfFluidSpecifiedSolutionDiff<dim>::calc_error_level_set (const Function<dim> &func,
-        const unsigned int n_samp,
-        const unsigned int f_ind)
-    {
-      const LinearAlgebra::BlockVector &solution = this->get_solution();
-
-      double I_err_est = 0.0;
-      double F_err_est = 0.0;
-      const double h = 1.0 / n_samp;
-
-      const DoFHandler<dim> &dof_handler = this->get_dof_handler();
-      const FiniteElement<dim> &finite_element = this->get_fe();
-      const unsigned int dofs_per_cell = finite_element.dofs_per_cell;
-      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
-
-      const QIterated<dim> quadrature (QMidpoint<1>(), n_samp);
-      FEValues<dim> fe_err (this->get_mapping(), finite_element, quadrature,
-                            update_JxW_values |
-                            update_quadrature_points);
-
-      const unsigned int volume_of_fluid_index = this->get_volume_of_fluid_handler().field_struct_for_field_index(f_ind)
-                                                 .volume_fraction.first_component_index;
-      const unsigned int volume_of_fluidN_c_index = this->get_volume_of_fluid_handler().field_struct_for_field_index(f_ind)
-                                                    .reconstruction.first_component_index;
-
-      // Compare computed solution to reinit using provided function
-      for (auto cell : dof_handler.active_cell_iterators ())
-        {
-          if (!cell->is_locally_owned ())
-            continue;
-
-          // Obtain data for this cell
-          cell->get_dof_indices (local_dof_indices);
-          Tensor<1, dim, double> normal;
-          for (unsigned int i=0; i<dim; ++i)
-            normal[i] = solution(local_dof_indices[finite_element.component_to_system_index(volume_of_fluidN_c_index+i, 0)]);
-          const double d_compute = solution(local_dof_indices[finite_element.component_to_system_index(volume_of_fluidN_c_index+dim, 0)]);
-          const double cell_volume_of_fluid = solution(local_dof_indices[finite_element.component_to_system_index(volume_of_fluid_index, 0)]);
-
-          // Calculate approximation for volume
-          fe_err.reinit (cell);
-
-          const double cell_vol = cell->measure ();
-          const double cell_diam = cell->diameter();
-          const double d_true = func.value(cell->barycenter(), f_ind);
-          double nnorm1 = 0;
-          for (unsigned int i = 0; i < dim; ++i)
-            {
-              nnorm1 += abs (normal[i]);
-            }
-
-          if (abs (d_compute) >= 0.5 * nnorm1 &&
-              abs (d_true) >= 0.5 * cell_diam &&
-              d_compute * d_true >= 0.0)
-            {
-              continue;
-            }
-
-          double val = 0.0;
-          double volume_of_fluid_reinit = 0.0;
-          for (unsigned int i = 0; i < fe_err.n_quadrature_points; ++i)
-            {
-              double d_t = 0.0;
-              Tensor<1, dim, double> grad_t;
-              Point<dim> xU = quadrature.point (i);
-              for (unsigned int di = 0; di < dim; ++di)
-                {
-                  Point<dim> xH = xU;
-                  Point<dim> xL = xU;
-                  xH[di] += 0.5 * h;
-                  xL[di] -= 0.5 * h;
-                  const double dH = func.value(cell->intermediate_point(xH), f_ind);
-                  const double dL = func.value(cell->intermediate_point(xL), f_ind);
-                  grad_t[di] = (dL - dH);
-                  d_t += (0.5 / dim) * (dH + dL);
-                }
-              const double solution_fluid_fraction_at_point = VolumeOfFluid::Utilities::compute_fluid_fraction (grad_t, d_t);
-              volume_of_fluid_reinit += solution_fluid_fraction_at_point*(fe_err.JxW (i) / cell_vol);
-              for (unsigned int di = 0; di < dim; ++di)
-                {
-                  xU[di] -= 0.5;
-                }
-              const double dot = normal * xU;
-              const double computed_fluid_fraction_at_point = VolumeOfFluid::Utilities::compute_fluid_fraction (h * normal,
-                                                              (d_compute - dot));
-              const double diff = abs (solution_fluid_fraction_at_point - computed_fluid_fraction_at_point);
-              val += diff * fe_err.JxW (i);
-            }
-          I_err_est += val;
-          F_err_est += abs (cell_volume_of_fluid - volume_of_fluid_reinit) * cell_vol;
-        }
-
-      std::vector<double> errors(1, I_err_est);
-      errors.push_back (F_err_est);
-      return errors;
-    }
-  }
-}
-
-
-// explicit instantiations
-namespace aspect
-{
-  namespace Postprocess
-  {
-    ASPECT_REGISTER_POSTPROCESSOR(VolumeOfFluidSpecifiedSolutionDiff,
-                                  "volume of fluid mms",
-                                  "A postprocessor that approximates the interface error.")
-  }
-}
diff --git a/tests/vof_linear.cc.bak b/tests/vof_linear.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_linear.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_linear.prm.bak b/tests/vof_linear.prm.bak
deleted file mode 100644
index 6f4e558e4cf..00000000000
--- a/tests/vof_linear.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# Test for linear interface under constant velocity
-# Error should be at machine precision
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.25
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, volume of fluid mms
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 0.25
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-      set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
-    end
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_linear_2f.cc.bak b/tests/vof_linear_2f.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_linear_2f.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_linear_2f.prm.bak b/tests/vof_linear_2f.prm.bak
deleted file mode 100644
index 3ded209c99d..00000000000
--- a/tests/vof_linear_2f.prm.bak
+++ /dev/null
@@ -1,93 +0,0 @@
-# Test for linear interface under constant velocity
-# Error should be at machine precision
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.5
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-  set Names of fields = F_1, F_2
-  set Compositional field methods = volume of fluid, volume of fluid
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set, F_2:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0_0=1.0, y0_0=0.0, x0_1=0.75, y0_1=0.0, xv=-0.25, yv=-0.25
-    set Function expression = cos(init*pi)*(x-x0_0-xv*t)+sin(init*pi)*(y-y0_0-yv*t);cos(init*pi)*(x-x0_1-xv*t)+sin(init*pi)*(y-y0_1-yv*t)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, volume of fluid statistics, volume of fluid mms
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 0.25
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = init=1.25, x0_0=1.0, y0_0=0.0, x0_1=0.75, y0_1=0.0, xv=-0.25, yv=-0.25
-      set Function expression = cos(init*pi)*(x-x0_0-xv*t)+sin(init*pi)*(y-y0_0-yv*t);cos(init*pi)*(x-x0_1-xv*t)+sin(init*pi)*(y-y0_1-yv*t)
-    end
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_linear_amr.cc.bak b/tests/vof_linear_amr.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_linear_amr.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_linear_amr.prm.bak b/tests/vof_linear_amr.prm.bak
deleted file mode 100644
index 0a94eeba27f..00000000000
--- a/tests/vof_linear_amr.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# Test for linear interface under constant velocity
-# Error should be at machine precision
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.25
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Minimum refinement level           = 2
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 1
-  set Strategy                           = volume of fluid interface
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, volume of fluid mms, visualization
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 0.25
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-      set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
-    end
-  end
-
-  subsection Visualization
-    set Time between graphical output = 0.2
-    set Interpolate output = false
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_linear_amr_mpi.cc.bak b/tests/vof_linear_amr_mpi.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_linear_amr_mpi.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_linear_amr_mpi.prm.bak b/tests/vof_linear_amr_mpi.prm.bak
deleted file mode 100644
index 5ed24ddb505..00000000000
--- a/tests/vof_linear_amr_mpi.prm.bak
+++ /dev/null
@@ -1,97 +0,0 @@
-# MPI: 4
-
-# Test for linear interface under constant velocity
-# Error should be at machine precision
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.04
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Minimum refinement level           = 2
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 1
-  set Strategy                           = volume of fluid interface
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, volume of fluid mms
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 0.25
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-      set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
-    end
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_linear_inflow.prm.bak b/tests/vof_linear_inflow.prm.bak
deleted file mode 100644
index abfcea3eb64..00000000000
--- a/tests/vof_linear_inflow.prm.bak
+++ /dev/null
@@ -1,86 +0,0 @@
-# Debugging inflow boundary condition
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.03125
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = if(y<=0.5,1,0)
-  end
-end
-
-# Composition boundary conditions
-subsection Boundary composition model
-  set List of model names = initial composition
-  set Fixed composition boundary indicators   = bottom, top, left, right
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = 0;1
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_linear_periodic.cc.bak b/tests/vof_linear_periodic.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_linear_periodic.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_linear_periodic.prm.bak b/tests/vof_linear_periodic.prm.bak
deleted file mode 100644
index 5110f35c30e..00000000000
--- a/tests/vof_linear_periodic.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# Test for linear interface under constant velocity
-# Error should be at machine precision
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 4
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 0
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Y periodic = true
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
-    set Function expression = cos(init*pi)*(x-x0)+sin(init*pi)*(y-y0)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, volume of fluid mms
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 4.0
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
-      set Function expression = cos(init*pi)*(x-x0)+sin(init*pi)*(y-y0)
-    end
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_linear_periodic_amr.cc.bak b/tests/vof_linear_periodic_amr.cc.bak
deleted file mode 100644
index 279f80158ec..00000000000
--- a/tests/vof_linear_periodic_amr.cc.bak
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-// Use vof error estimator
-
-#include "vof_err_calc.h"
diff --git a/tests/vof_linear_periodic_amr.prm.bak b/tests/vof_linear_periodic_amr.prm.bak
deleted file mode 100644
index 4befddeb052..00000000000
--- a/tests/vof_linear_periodic_amr.prm.bak
+++ /dev/null
@@ -1,96 +0,0 @@
-# Test for linear interface under constant velocity
-# Error should be at machine precision
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0.1
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Minimum refinement level           = 2
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 3
-  set Time steps between mesh refinement = 1
-  set Strategy                           = volume of fluid interface
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Y periodic = true
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
-    set Function expression = cos(init*pi)*(x-x0)+sin(init*pi)*(y-y0)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics, volume of fluid mms
-
-  subsection VoF MMS
-    set Number error samples = 16
-    set Time between error estimates = 4.0
-
-    subsection True LS
-      set Variable names = x,y,t
-      set Function constants = init=1.4, x0=1.0, y0=0.3, xv=0.0, yv=-0.25
-      set Function expression = cos(init*pi)*(x-x0)+sin(init*pi)*(y-y0)
-    end
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 0.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/vof_mpi_amr_no_dof.prm.bak b/tests/vof_mpi_amr_no_dof.prm.bak
deleted file mode 100644
index b2f03d72562..00000000000
--- a/tests/vof_mpi_amr_no_dof.prm.bak
+++ /dev/null
@@ -1,85 +0,0 @@
-# MPI: 4
-
-# Test for linear interface under constant velocity
-# Error should be at machine precision
-
-set Dimension                              = 2
-set Start time                             = 0
-set End time                               = 0
-set Use years in output instead of seconds = false
-set CFL number                             = 0.5
-set Output directory                       = output
-set Nonlinear solver scheme                   = single Advection, no Stokes
-
-subsection Volume of Fluid
-  set Number initialization samples = 16
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-  set Names of fields = F_1
-  set Compositional field methods = volume of fluid
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 1
-  set Initial global refinement          = 1
-  set Time steps between mesh refinement = 0
-  set Strategy                           = volume of fluid interface
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-  end
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-end
-
-subsection Initial composition model
-  set List of model names = function
-  set Volume of fluid initialization type = F_1:level set
-
-  subsection Function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = cos(init*pi)*(x-x0-xv*t)+sin(init*pi)*(y-y0-yv*t)
-  end
-end
-
-subsection Prescribed Stokes solution
-  set Model name = function
-
-  subsection Velocity function
-    set Variable names = x,y,t
-    set Function constants = init=1.25, x0=1.0, y0=0.0, xv=-0.25, yv=-0.25
-    set Function expression = xv;yv
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = volume of fluid statistics
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1.0
-    set List of output variables = volume of fluid values
-
-    subsection Volume of Fluid
-      set Output interface reconstruction contour = true
-    end
-  end
-end
diff --git a/tests/walltime.prm.bak b/tests/walltime.prm.bak
deleted file mode 100644
index aa0a32698c3..00000000000
--- a/tests/walltime.prm.bak
+++ /dev/null
@@ -1,64 +0,0 @@
-# Tests whether the 'wall time' termination criteria work OK on a
-# minimal problem
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 1e9
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 3.3
-    set Y extent = 2.2
-    set Z extent = 1.1
-    set Box origin X coordinate = -1.9
-    set Box origin Y coordinate = 2.5
-    set Box origin Z coordinate = 3.1
-  end
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 1
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 1
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 1
-  set Zero velocity boundary indicators       = 0, 2, 3
-end
-
-subsection Termination criteria
-  set Termination criteria      = wall time
-  set Wall time                 = 0
-end
diff --git a/tests/weighted_p_norm_average.cc.bak b/tests/weighted_p_norm_average.cc.bak
deleted file mode 100644
index 17f8803c8d0..00000000000
--- a/tests/weighted_p_norm_average.cc.bak
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-//#include <aspect/simulator.h>
-//#include <aspect/geometry_model/initial_topography_model/interface.h>
-//#include <aspect/geometry_model/initial_topography_model/prm_polygon.h>
-//#include <aspect/simulator_access.h>
-#include <aspect/utilities.h>
-
-//#include <iostream>
-//
-int f()
-{
-  using namespace aspect;
-
-  std::vector<double> weights = {1,1,2,2,3,3};
-  std::vector<double> values = {6,5,4,3,2,1};
-  std::vector<double> p_norms = {-1000,-2.5,-2,-1,0,1,2,2.5,3,4,1000};
-
-  for (unsigned int i = 0; i < p_norms.size(); i++)
-    {
-      std::cout << "p = " << p_norms[i] << ", average = " << aspect::Utilities::weighted_p_norm_average(weights,values,p_norms[i]) << std::endl;
-    }
-
-  exit(0);
-  return 42;
-}
-// run this function by initializing a global variable by it
-int i = f();
diff --git a/tests/world_builder_select_composition.prm.bak b/tests/world_builder_select_composition.prm.bak
deleted file mode 100644
index 0e98ebd4582..00000000000
--- a/tests/world_builder_select_composition.prm.bak
+++ /dev/null
@@ -1,69 +0,0 @@
-# Enable if: ASPECT_WITH_WORLD_BUILDER
-# This test is a copy of world_builder_simple.prm and checks that we can select
-# a subset of compositions for which to evaluate the world builder.
-
-set World builder file                     = $ASPECT_SOURCE_DIR/tests/world_builder_select_composition.wb
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature = 1613
-set End time = 0
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Function expression = if(x > 1500000,1.0,0.0);0.0;0.0
-    set Composition reference profile = function
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = 1
-  set Tangential velocity boundary indicators = 0, 2, 3
-end
-
-subsection Compositional fields
-  set Number of fields = 3
-  set Names of fields = Crust, Lithosphere, Continent
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1500e3
-    set Y extent = 200e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = world builder
-end
-
-subsection Initial composition model
-  set List of model names = world builder
-
-  subsection World builder
-    set List of relevant compositions = Crust
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference temperature = 1613
-    set Viscosity = 1e21
-    set Thermal conductivity = 1e-06
-    set Density differential for compositional field 1 = 500
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 5
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics
-end
diff --git a/tests/world_builder_select_grains.prm.bak b/tests/world_builder_select_grains.prm.bak
deleted file mode 100644
index c8e434dd8cd..00000000000
--- a/tests/world_builder_select_grains.prm.bak
+++ /dev/null
@@ -1,95 +0,0 @@
-# Enable if: ASPECT_WITH_WORLD_BUILDER
-# This test is a copy of world_builder_simple.prm and checks that we can select
-# a subset of grains for which to evaluate the world builder.
-
-include $ASPECT_SOURCE_DIR/tests/world_builder_select_composition.prm
-
-set World builder file                     = $ASPECT_SOURCE_DIR/tests/world_builder_select_grains.wb
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature = 1613
-set End time = 0
-set Dimension = 3
-set Nonlinear solver scheme = no Advection, no Stokes
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1000e3
-    set Y extent = 200e3
-    set Z extent = 200e3
-    set Box origin Z coordinate = -200e3
-    set Box origin Y coordinate = -100e3
-    set Box origin X coordinate = -50e3
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference temperature = 1613
-    set Viscosity = 1e21
-    set Thermal conductivity = 1e-06
-    set Density differential for compositional field 1 = 500
-  end
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 5
-end
-
-subsection Postprocess
-  set List of postprocessors = composition statistics, visualization, particles, crystal preferred orientation
-
-  subsection Crystal Preferred Orientation
-    set Time between data output = 1e6
-    set Write in background thread = true
-    set Compress cpo data files = false
-    set Write out raw cpo data = mineral 0: volume fraction, mineral 0: rotation matrix, mineral 1: volume fraction, mineral 1: rotation matrix
-    set Write out draw volume weighted cpo data = mineral 0: volume fraction, mineral 0: rotation matrix, mineral 1: volume fraction, mineral 1: rotation matrix
-  end
-
-  subsection Particles
-    set Time between data output = 1e6
-    set Data output format       = gnuplot
-    set Exclude output properties = a_cosine_matrix, volume fraction
-  end
-end
-
-subsection Particles
-  set List of particle properties = integrated strain invariant, crystal preferred orientation, cpo bingham average, cpo elastic tensor, elastic tensor decomposition
-  set Particle generator name = random uniform
-
-  subsection Crystal Preferred Orientation
-    set Random number seed = 301
-    set Number of grains per particle = 5
-    set Property advection method = Backward Euler
-    set Property advection tolerance = 1e-15
-    set CPO derivatives algorithm = D-Rex 2004
-
-    subsection Initial grains
-      set Model name = World Builder
-      set Minerals = Olivine: A-fabric , Enstatite
-      set Volume fractions minerals = 1.0,0.0
-    end
-
-    subsection D-Rex 2004
-      set Mobility = 125
-      set Stress exponents = 3.5
-      set Exponents p = 1.5
-      set Nucleation efficiency = 5
-      set Threshold GBS = 0.3
-    end
-  end
-
-  subsection CPO Bingham Average
-    set Random number seed = 200
-  end
-
-  subsection Generator
-    subsection Probability density function
-      set Number of particles = 50
-    end
-  end
-end
diff --git a/tests/world_builder_simple.prm.bak b/tests/world_builder_simple.prm.bak
deleted file mode 100644
index 8f7e93e98fb..00000000000
--- a/tests/world_builder_simple.prm.bak
+++ /dev/null
@@ -1,70 +0,0 @@
-# Enable if: ASPECT_WITH_WORLD_BUILDER
-# This test uses the Geodynamic World Builder to create
-# initial temperatures and compositions
-
-set World builder file                     = $ASPECT_SOURCE_DIR/tests/world_builder_simple.wb
-set Use years in output instead of seconds = false
-set Adiabatic surface temperature = 1613
-set End time = 0
-
-subsection Adiabatic conditions model
-  subsection Compute profile
-    set Function expression = if(x > 1500000,1.0,0.0)
-    set Composition reference profile = function
-  end
-end
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = 1
-  set Tangential velocity boundary indicators = 0, 2, 3
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 5
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Output format = gnuplot
-    set Interpolate output = false
-    set List of output variables = adiabat
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 1
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference temperature = 1613
-    set Viscosity = 1e21
-    set Thermal conductivity = 1e-06
-    set Density differential for compositional field 1 = 500
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1500e3
-    set Y extent = 200e3
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = world builder
-end
-
-subsection Initial composition model
-  set List of model names = world builder
-end
diff --git a/tests/world_builder_simple_2d_cartesian_sticky_air.prm.bak b/tests/world_builder_simple_2d_cartesian_sticky_air.prm.bak
deleted file mode 100644
index f781e5b4f35..00000000000
--- a/tests/world_builder_simple_2d_cartesian_sticky_air.prm.bak
+++ /dev/null
@@ -1,71 +0,0 @@
-# Enable if: ASPECT_WITH_WORLD_BUILDER
-set Nonlinear solver scheme = no Advection, no Stokes
-set World builder file                     = $ASPECT_SOURCE_DIR/tests/world_builder_simple_2d_cartesian_sticky_air.wb
-set Use years in output instead of seconds = false
-set Output directory = wbdir3
-set Adiabatic surface temperature = 1613
-set End time = 0
-
-subsection Boundary velocity model
-  set Zero velocity boundary indicators = 1
-  set Tangential velocity boundary indicators = 0, 2, 3
-end
-
-subsection Mesh refinement
-  set Initial global refinement = 4
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization
-
-  subsection Visualization
-    set Interpolate output = false
-    set List of output variables = adiabat
-    set Output format = gnuplot
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 7
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference temperature = 1613
-    set Viscosity = 1e21
-    set Thermal conductivity = 1e-06
-    set Density differential for compositional field 1 = 500
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 500e3
-    set Y extent = 800e3
-  end
-
-  subsection Initial topography model
-    set Model name = function
-
-    subsection Function
-      set Function expression = 100e3
-      set Maximum topography value = 100e3
-    end
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = world builder
-end
-
-subsection Initial composition model
-  set List of model names = world builder
-end
diff --git a/tests/write_plugin_graph.cc.bak b/tests/write_plugin_graph.cc.bak
deleted file mode 100644
index ca9e8a86bfc..00000000000
--- a/tests/write_plugin_graph.cc.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include <aspect/material_model/interface.h>
-#include <aspect/simulator.h>
-#include <aspect/simulator_signals.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-
-using namespace aspect;
-
-
-template <int dim>
-void post_constraints_creation (const SimulatorAccess<dim> &sim,
-                                AffineConstraints<double> &)
-{
-  static bool first = true;
-  if (first)
-    {
-      std::stringstream ss;
-      sim.get_simulator().write_plugin_graph(ss);
-      std::string content = ss.str();
-
-      const char *checks[] =
-      {
-        "digraph Plugins",
-        "label=\"TestMaterial\"",
-        "N6aspect12TestMaterialILi2EEE -> N6aspect13MaterialModel9InterfaceILi2EEE",
-        "label=\"simpler\"",
-        "Simulator -> SimulatorAccess",
-        "N6aspect19BoundaryComposition9AsciiDataILi2EEE [label=\"ascii data\""
-      };
-
-      for (unsigned int i = 0; i < sizeof(checks)/sizeof(checks[0]); ++i)
-        {
-          bool found = content.find(checks[i])!=std::string::npos;
-
-          if (found)
-            std::cout << "found " << checks[i] << std::endl;
-          Assert(found, ExcInternalError());
-        }
-
-    }
-  first = false;
-}
-
-
-template <int dim>
-void signal_connector (SimulatorSignals<dim> &signals)
-{
-  signals.post_constraints_creation.connect (&post_constraints_creation<dim>);
-}
-
-
-ASPECT_REGISTER_SIGNALS_CONNECTOR(signal_connector<2>,
-                                  signal_connector<3>)
-
-
-// make a dummy material model and instantiate and register it
-namespace aspect
-{
-  template <int dim>
-  class TestMaterial : public MaterialModel::Interface<dim>
-  {
-    public:
-      virtual void evaluate(const MaterialModel::MaterialModelInputs<dim> &in,
-                            MaterialModel::MaterialModelOutputs<dim> &out) const
-      {}
-
-      virtual bool is_compressible () const
-      {
-        return false;
-      }
-  };
-
-
-  ASPECT_REGISTER_MATERIAL_MODEL(TestMaterial,
-                                 "TestMaterial",
-                                 "A material model.")
-}
diff --git a/tests/write_plugin_graph.prm.bak b/tests/write_plugin_graph.prm.bak
deleted file mode 100644
index ef203ef9686..00000000000
--- a/tests/write_plugin_graph.prm.bak
+++ /dev/null
@@ -1,76 +0,0 @@
-# a test that write the plugin graph
-
-
-set Dimension = 2
-set CFL number                             = 1.0
-set End time                               = 0
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 0, 1
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = perturbed box
-end
-
-subsection Material model
-  set Model name = simple
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 2
-  set Strategy                           = density, temperature
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Postprocess
-  set List of postprocessors =
-
-  subsection Depth average
-    set Time between graphical output = 1e8
-  end
-
-  subsection Visualization
-    set Interpolate output = false
-    set Number of grouped files       = 0
-    set Output format                 = gnuplot
-    set Time between graphical output = 0
-  end
-end
diff --git a/tests/zero_RHS.prm.bak b/tests/zero_RHS.prm.bak
deleted file mode 100644
index 735e10ead1b..00000000000
--- a/tests/zero_RHS.prm.bak
+++ /dev/null
@@ -1,120 +0,0 @@
-# This is a test for models where the right-hand side of
-# the temperature or composition system is zero (i.e., the field
-# is zero, and there are no boundary conditions/additional RHS
-# terms).
-# In this case, the solver scheme should skip solving this
-# field.
-
-set Dimension = 2
-set End time                               = 2e5
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-# Here we specify that the model has fixed temperature
-# boundary conditions, as well as free slip boundary
-# conditions for the sides and bottom.
-
-subsection Boundary temperature model
-  set List of model names = constant
-  set Fixed temperature boundary indicators   = left, right, bottom, top
-
-  subsection Constant
-    set Boundary indicator to temperature mappings = left:0, right:0, bottom:0, top:0
-  end
-end
-
-subsection Discretization
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100.e2
-    set Y extent = 1000.e2
-    set X repetitions = 10
-    set Y repetitions = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0; if(y>500e2,1,0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density             = 3300
-    set Reference specific heat       = 0.0
-    set Thermal conductivity          = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Viscosity                     = 1.e20
-    set Reference compressibility     = 1e-11
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.0;-0.01
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics,
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1
-    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-  end
-end
diff --git a/tests/zero_matrix.prm.bak b/tests/zero_matrix.prm.bak
deleted file mode 100644
index ca072372776..00000000000
--- a/tests/zero_matrix.prm.bak
+++ /dev/null
@@ -1,115 +0,0 @@
-# This is a test for models where matrix of
-# the temperature or composition system is zero (i.e., the field
-# is zero, but there are non-zero RHS terms).
-# In this case, the solver should throw an exception.
-#
-# EXPECT FAILURE
-
-set Dimension = 2
-set End time                               = 2e5
-set Nonlinear solver scheme                = single Advection, iterated Stokes
-set Pressure normalization                 = surface
-set Surface pressure                       = 0
-set Use years in output instead of seconds = true
-
-subsection Heating model
-  set List of model names = constant heating
-
-  subsection Constant heating
-    set Radiogenic heating rate = 1
-  end
-end
-
-subsection Compositional fields
-  set Number of fields = 2
-end
-
-subsection Discretization
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 100.e2
-    set Y extent = 1000.e2
-    set X repetitions = 10
-    set Y repetitions = 100
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-
-  subsection Vertical
-    set Magnitude = 10
-  end
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Initial composition model
-  set Model name = function
-
-  subsection Function
-    set Function expression = 0.0; if(y>500e2,1,0)
-    set Variable names      = x,y
-  end
-end
-
-subsection Material model
-  set Model name = simple compressible
-
-  subsection Simple compressible model
-    set Reference density             = 3300
-    set Reference specific heat       = 0.0
-    set Thermal conductivity          = 0.0
-    set Thermal expansion coefficient = 0.0
-    set Viscosity                     = 1.e20
-    set Reference compressibility     = 1e-11
-  end
-end
-
-subsection Mesh refinement
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 0
-  set Time steps between mesh refinement = 0
-end
-
-subsection Boundary velocity model
-  set Prescribed velocity boundary indicators = bottom:function
-  set Tangential velocity boundary indicators = left, right
-
-  subsection Function
-    set Variable names      = x,y
-    set Function expression = 0.0;-0.01
-  end
-end
-
-subsection Postprocess
-  set List of postprocessors = visualization,velocity statistics,
-
-  subsection Visualization
-    set Interpolate output = false
-    set Time between graphical output = 1
-    set List of output variables      = material properties, nonadiabatic temperature, nonadiabatic pressure, strain rate
-
-    subsection Material properties
-      set List of material properties = density, viscosity, thermal expansivity, reaction terms
-    end
-  end
-end
diff --git a/tests/zero_temperature.prm.bak b/tests/zero_temperature.prm.bak
deleted file mode 100644
index 075891af908..00000000000
--- a/tests/zero_temperature.prm.bak
+++ /dev/null
@@ -1,94 +0,0 @@
-# derived from diffusion.prm. we have no velocity here, and the temperature
-# boundary values are all zero as well, so there is nothing really to do.
-# check that this works.
-
-set Dimension = 2
-set CFL number                             = 1
-set End time                               = 1
-set Resume computation                     = false
-set Start time                             = 0
-set Adiabatic surface temperature          = 0
-set Surface pressure                       = 0
-set Use years in output instead of seconds = false
-set Nonlinear solver scheme                = single Advection, single Stokes
-
-subsection Boundary temperature model
-  set List of model names = box
-  set Fixed temperature boundary indicators   = 2, 3
-
-  subsection Box
-    set Bottom temperature = 0
-    set Top temperature    = 0
-  end
-end
-
-subsection Discretization
-  set Stokes velocity polynomial degree       = 2
-  set Temperature polynomial degree           = 2
-  set Use locally conservative discretization = false
-
-  subsection Stabilization parameters
-    set alpha = 2
-    set beta  = 0.078
-    set cR    = 0.5
-  end
-end
-
-subsection Geometry model
-  set Model name = box
-
-  subsection Box
-    set X extent = 1
-    set Y extent = 1
-    set Z extent = 1
-  end
-end
-
-subsection Gravity model
-  set Model name = vertical
-end
-
-subsection Initial temperature model
-  set Model name = function
-
-  subsection Function
-    set Variable names = x,y
-    set Function expression = 0.0
-  end
-end
-
-subsection Material model
-  set Model name = simple
-
-  subsection Simple model
-    set Reference density             = 1
-    set Reference specific heat       = 1250
-    set Reference temperature         = 0
-    set Thermal conductivity          = 1e-6
-    set Thermal expansion coefficient = 2e-5
-    set Viscosity                     = 1
-  end
-end
-
-subsection Mesh refinement
-  set Additional refinement times        =
-  set Initial adaptive refinement        = 0
-  set Initial global refinement          = 5
-  set Refinement fraction                = 0.3
-  set Coarsening fraction                = 0.05
-  set Strategy                           = thermal energy density
-  set Time steps between mesh refinement = 5
-end
-
-subsection Boundary velocity model
-  set Tangential velocity boundary indicators = 0,1,2,3
-end
-
-subsection Checkpointing
-  set Time between checkpoint                = 0
-  set Steps between checkpoint               = 50
-end
-
-subsection Postprocess
-  set List of postprocessors = temperature statistics
-end
diff --git a/unit_tests/additional_outputs.cc.bak b/unit_tests/additional_outputs.cc.bak
deleted file mode 100644
index 8eb691ccb58..00000000000
--- a/unit_tests/additional_outputs.cc.bak
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-#include <aspect/utilities.h>
-
-// A test that simply verifies that the additional material
-// model outputs can be accessed.
-
-#include <aspect/simulator.h>
-#include <deal.II/grid/tria.h>
-#include <aspect/material_model/simple.h>
-#include <aspect/simulator_access.h>
-
-#include <iostream>
-
-namespace
-{
-  using namespace dealii;
-  using namespace aspect;
-
-  template <int dim>
-  class AdditionalOutputs1 : public MaterialModel::AdditionalMaterialOutputs<dim>
-  {
-    public:
-      AdditionalOutputs1 (const unsigned int n_points,
-                          const unsigned int /*n_comp*/)
-      {
-        additional_material_output1.resize(n_points);
-      }
-
-      std::vector<double> additional_material_output1;
-  };
-
-
-  template <int dim>
-  class Material1 : public MaterialModel::Simple<dim>
-  {
-    public:
-
-      void evaluate(const MaterialModel::MaterialModelInputs<dim> &/*in*/,
-                    MaterialModel::MaterialModelOutputs<dim> &out) const override
-      {
-        AdditionalOutputs1<dim> *additional;
-
-        additional = out.template get_additional_output<AdditionalOutputs1<dim>>();
-        additional->additional_material_output1[0] = 42.0;
-      }
-  };
-}
-
-
-TEST_CASE("AdditionalOutputs works")
-{
-  const int dim=2;
-
-  using namespace aspect::MaterialModel;
-  MaterialModelInputs<dim> in(1,1);
-  MaterialModelOutputs<dim> out(1,1);
-  in.requested_properties = MaterialProperties::additional_outputs;
-
-
-  REQUIRE(out.get_additional_output<AdditionalOutputs1<dim>>() == nullptr);
-
-  out.additional_outputs.push_back(std::make_unique<AdditionalOutputs1<dim>> (1, 1));
-
-  REQUIRE(out.get_additional_output<AdditionalOutputs1<dim>>() != nullptr);
-
-  Material1<dim> mat;
-  mat.evaluate(in, out);
-
-  REQUIRE(out.get_additional_output<AdditionalOutputs1<dim>>()->additional_material_output1[0] == 42.0);
-
-  // test const version of get_additional_output:
-  {
-    const MaterialModelOutputs<dim> &const_out = out;
-    REQUIRE(const_out.get_additional_output<AdditionalOutputs1<dim>>() != nullptr);
-    const AdditionalOutputs1<dim> *a = const_out.get_additional_output<AdditionalOutputs1<dim>>();
-    REQUIRE(a != nullptr);
-  }
-}
diff --git a/unit_tests/common.h.bak b/unit_tests/common.h.bak
deleted file mode 100644
index ebeb0b22555..00000000000
--- a/unit_tests/common.h.bak
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-  Copyright (C) 2018 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _aspect_unit_tests_common_h
-#define _aspect_unit_tests_common_h
-
-#include <catch.hpp>
-
-#include <deal.II/base/table.h>
-
-
-using Catch::Matchers::Contains;
-using Catch::Matchers::StartsWith;
-
-/**
- * Compare the given two std::vector<double> entries with an epsilon (using Catch::Approx)
- */
-inline void compare_vectors_approx(
-  const std::vector<double> &computed,
-  const std::vector<double> &expected)
-{
-  REQUIRE(computed.size() == expected.size());
-  for (unsigned int i=0; i<computed.size(); ++i)
-    {
-      INFO("array index i=" << i << ": ");
-      REQUIRE(computed[i] == Approx(expected[i]));
-    }
-}
-
-/**
- * Compare the given two table entries with an epsilon (using Catch::Approx)
- */
-inline void compare_tables_approx(
-  const dealii::Table<2,double> &computed,
-  const dealii::Table<2,double> &expected)
-{
-  REQUIRE(computed.size() == expected.size());
-
-  for (unsigned int i=0; i<computed.n_rows(); ++i)
-    {
-      for (unsigned int j=0; j<computed.n_cols(); ++j)
-        {
-          INFO("array index i,j=" << i << ',' << j << ": ");
-          REQUIRE(computed[i][j] == Approx(expected[i][j]));
-        }
-    }
-}
-
-#endif
diff --git a/unit_tests/crystal_preferred_orientation.cc.bak b/unit_tests/crystal_preferred_orientation.cc.bak
deleted file mode 100644
index d379e32bb63..00000000000
--- a/unit_tests/crystal_preferred_orientation.cc.bak
+++ /dev/null
@@ -1,2309 +0,0 @@
-/*
-  Copyright (C) 2022 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-#include <aspect/particle/property/elastic_tensor_decomposition.h>
-#include <aspect/particle/property/crystal_preferred_orientation.h>
-#include <aspect/particle/property/cpo_elastic_tensor.h>
-#include <deal.II/base/parameter_handler.h>
-#include <aspect/utilities.h>
-
-
-/**
- * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
- */
-inline void compare_3d_arrays_approx(
-  const std::array<double,3> &computed,
-  const std::array<double,3> &expected)
-{
-  CHECK(computed.size() == expected.size());
-  for (unsigned int i=0; i< computed.size(); ++i)
-    {
-      INFO("vector index i=" << i << ": ");
-      CHECK(computed[i] == Approx(expected[i]));
-    }
-}
-
-
-/**
- * Compare the given two std::array<double,3> entries with an epsilon (using Catch::Approx)
- */
-inline void compare_3d_arrays_approx(
-  const std::vector<double> &computed,
-  const std::vector<double> &expected)
-{
-  CHECK(computed.size() == expected.size());
-  for (unsigned int i=0; i< computed.size(); ++i)
-    {
-      INFO("vector index i=" << i << ": ");
-      CHECK(computed[i] == Approx(expected[i]));
-    }
-}
-
-
-/**
- * Compare two rotation matrices
- */
-inline void compare_rotation_matrices_approx(
-  const std::array<std::array<double,3>,3> &computed,
-  const std::array<std::array<double,3>,3> &expected)
-{
-  // sign of eigenvector is not important
-  INFO("rotation matrices are not the same: \n" <<
-       "expected = " << expected[0][0] << " " << expected[0][1] << " " << expected[0][2] << "\n" <<
-       "           " << expected[1][0] << " " << expected[1][1] << " " << expected[1][2] << "\n" <<
-       "           " << expected[2][0] << " " << expected[2][1] << " " << expected[2][2] << "\n" <<
-       "computed = " << computed[0][0] << " " << computed[0][1] << " " << computed[0][2] << "\n" <<
-       "           " << computed[1][0] << " " << computed[1][1] << " " << computed[1][2] << "\n" <<
-       "           " << computed[2][0] << " " << computed[2][1] << " " << computed[2][2] << "\n" );
-  CHECK((
-          (computed[0][0] == Approx(expected[0][0]) && computed[0][1] == Approx(expected[0][1]) && computed[0][2] == Approx(expected[0][2]) &&
-           computed[1][0] == Approx(expected[1][0]) && computed[1][1] == Approx(expected[1][1]) && computed[1][2] == Approx(expected[1][2]) &&
-           computed[2][0] == Approx(expected[2][0]) && computed[2][1] == Approx(expected[2][1]) && computed[2][2] == Approx(expected[2][2]))
-          ||
-          (computed[0][0] == Approx(-expected[0][0]) && computed[0][1] == Approx(-expected[0][1]) && computed[0][2] == Approx(-expected[0][2]) &&
-           computed[1][0] == Approx(-expected[1][0]) && computed[1][1] == Approx(-expected[1][1]) && computed[1][2] == Approx(-expected[1][2]) &&
-           computed[2][0] == Approx(-expected[2][0]) && computed[2][1] == Approx(-expected[2][1]) && computed[2][2] == Approx(-expected[2][2]))));
-}
-
-/**
- * Compare two rotation matrices
- */
-inline void compare_rotation_matrices_approx(
-  const dealii::Tensor<2,3> &computed,
-  const dealii::Tensor<2,3> &expected)
-{
-  // sign of eigenvector is not important
-  INFO("rotation matrices are not the same: \n" <<
-       "expected = " << expected[0][0] << " " << expected[0][1] << " " << expected[0][2] << "\n" <<
-       "           " << expected[1][0] << " " << expected[1][1] << " " << expected[1][2] << "\n" <<
-       "           " << expected[2][0] << " " << expected[2][1] << " " << expected[2][2] << "\n" <<
-       "computed = " << computed[0][0] << " " << computed[0][1] << " " << computed[0][2] << "\n" <<
-       "           " << computed[1][0] << " " << computed[1][1] << " " << computed[1][2] << "\n" <<
-       "           " << computed[2][0] << " " << computed[2][1] << " " << computed[2][2] << "\n" );
-  const double tol = 1e-14;
-  CHECK((
-          ((computed[0][0] == Approx(expected[0][0]) || std::fabs(computed[0][0]) < tol)
-           && (computed[0][1] == Approx(expected[0][1]) || std::fabs(computed[0][1]) < tol)
-           && (computed[0][2] == Approx(expected[0][2]) || std::fabs(computed[0][2]) < tol)
-           && (computed[1][0] == Approx(expected[1][0]) || std::fabs(computed[1][0]) < tol)
-           && (computed[1][1] == Approx(expected[1][1]) || std::fabs(computed[1][1]) < tol)
-           && (computed[1][2] == Approx(expected[1][2]) || std::fabs(computed[1][2]) < tol)
-           && (computed[2][0] == Approx(expected[2][0]) || std::fabs(computed[2][0]) < tol)
-           && (computed[2][1] == Approx(expected[2][1]) || std::fabs(computed[2][1]) < tol)
-           && (computed[2][2] == Approx(expected[2][2]) || std::fabs(computed[2][2]) < tol))
-          ||
-          ((computed[0][0] == Approx(-expected[0][0]) || std::fabs(computed[0][0]) < tol)
-           && (computed[0][1] == Approx(-expected[0][1]) || std::fabs(computed[0][1]) < tol)
-           && (computed[0][2] == Approx(-expected[0][2]) || std::fabs(computed[0][2]) < tol)
-           && (computed[1][0] == Approx(-expected[1][0]) || std::fabs(computed[1][0]) < tol)
-           && (computed[1][1] == Approx(-expected[1][1]) || std::fabs(computed[1][1]) < tol)
-           && (computed[1][2] == Approx(-expected[1][2]) || std::fabs(computed[1][2]) < tol)
-           && (computed[2][0] == Approx(-expected[2][0]) || std::fabs(computed[2][0]) < tol)
-           && (computed[2][1] == Approx(-expected[2][1]) || std::fabs(computed[2][1]) < tol)
-           && (computed[2][2] == Approx(-expected[2][2]) || std::fabs(computed[2][2]) < tol))));
-}
-
-TEST_CASE("CPO core: Store and Load")
-{
-  // test store and load functions
-  // the first and last element should not be changed, because we start at
-  // data position = 1.
-  aspect::Particle::Property::CrystalPreferredOrientation<3> cpo;
-  aspect::ParameterHandler prm;
-  prm.enter_subsection("Particles");
-  {
-    cpo.declare_parameters(prm);
-    prm.enter_subsection("Crystal Preferred Orientation");
-    {
-      prm.set("Random number seed","1");
-      prm.set("Number of grains per particle","3");
-      prm.set("CPO derivatives algorithm","Spin tensor");
-      prm.set("Property advection method","Backward Euler");
-
-      prm.enter_subsection("Initial grains");
-      {
-        prm.set("Model name","Uniform grains and random uniform rotations");
-        // Let the minerals just passively rotate with the rotation of
-        // the particle caused by the flow.
-        prm.set("Minerals","Passive,Passive");
-        prm.set("Volume fractions minerals","0.7,0.3");
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection ();
-  }
-  prm.leave_subsection ();
-
-  prm.enter_subsection("Particles");
-  {
-    cpo.parse_parameters(prm);
-  }
-  prm.leave_subsection ();
-
-  cpo.initialize();
-
-  unsigned int cpo_data_position = 1;
-  std::vector<double> data_array(70,-1.);
-  dealii::ArrayView<double> data(&data_array[0],70);
-
-  cpo.set_volume_fraction_mineral(cpo_data_position,data,0,0.7);
-  cpo.set_volume_fraction_mineral(cpo_data_position,data,1,0.3);
-
-  using namespace dealii;
-  Tensor<2,3> rotation_matrix;
-  rotation_matrix[TableIndices<2>(0,0)] = 0;
-  rotation_matrix[TableIndices<2>(0,1)] = 1./1000.;
-  rotation_matrix[TableIndices<2>(0,2)] = 2./1000.;
-  rotation_matrix[TableIndices<2>(1,0)] = 3./1000.;
-  rotation_matrix[TableIndices<2>(1,1)] = 4./1000.;
-  rotation_matrix[TableIndices<2>(1,2)] = 5./1000.;
-  rotation_matrix[TableIndices<2>(2,0)] = 6./1000.;
-  rotation_matrix[TableIndices<2>(2,1)] = 7./1000.;
-  rotation_matrix[TableIndices<2>(2,2)] = 8./1000.;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data,0,0,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 9./1000.;
-  rotation_matrix[TableIndices<2>(0,1)] = 10./1000.;
-  rotation_matrix[TableIndices<2>(0,2)] = 11./1000.;
-  rotation_matrix[TableIndices<2>(1,0)] = 12./1000.;
-  rotation_matrix[TableIndices<2>(1,1)] = 13./1000.;
-  rotation_matrix[TableIndices<2>(1,2)] = 14./1000.;
-  rotation_matrix[TableIndices<2>(2,0)] = 15./1000.;
-  rotation_matrix[TableIndices<2>(2,1)] = 16./1000.;
-  rotation_matrix[TableIndices<2>(2,2)] = 17./1000.;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data,0,1,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 18./1000.;
-  rotation_matrix[TableIndices<2>(0,1)] = 19./1000.;
-  rotation_matrix[TableIndices<2>(0,2)] = 20./1000.;
-  rotation_matrix[TableIndices<2>(1,0)] = 21./1000.;
-  rotation_matrix[TableIndices<2>(1,1)] = 22./1000.;
-  rotation_matrix[TableIndices<2>(1,2)] = 23./1000.;
-  rotation_matrix[TableIndices<2>(2,0)] = 24./1000.;
-  rotation_matrix[TableIndices<2>(2,1)] = 25./1000.;
-  rotation_matrix[TableIndices<2>(2,2)] = 26./1000.;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data,0,2,rotation_matrix);
-
-  cpo.set_volume_fractions_grains(cpo_data_position,data,0,0,0.1);
-  cpo.set_volume_fractions_grains(cpo_data_position,data,0,1,0.2);
-  cpo.set_volume_fractions_grains(cpo_data_position,data,0,2,0.3);
-
-
-  rotation_matrix[TableIndices<2>(0,0)] = 27./1000.;
-  rotation_matrix[TableIndices<2>(0,1)] = 28./1000.;
-  rotation_matrix[TableIndices<2>(0,2)] = 29./1000.;
-  rotation_matrix[TableIndices<2>(1,0)] = 30./1000.;
-  rotation_matrix[TableIndices<2>(1,1)] = 31./1000.;
-  rotation_matrix[TableIndices<2>(1,2)] = 32./1000.;
-  rotation_matrix[TableIndices<2>(2,0)] = 33./1000.;
-  rotation_matrix[TableIndices<2>(2,1)] = 34./1000.;
-  rotation_matrix[TableIndices<2>(2,2)] = 35./1000.;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data,1,0,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 36./1000.;
-  rotation_matrix[TableIndices<2>(0,1)] = 37./1000.;
-  rotation_matrix[TableIndices<2>(0,2)] = 38./1000.;
-  rotation_matrix[TableIndices<2>(1,0)] = 39./1000.;
-  rotation_matrix[TableIndices<2>(1,1)] = 40./1000.;
-  rotation_matrix[TableIndices<2>(1,2)] = 41./1000.;
-  rotation_matrix[TableIndices<2>(2,0)] = 42./1000.;
-  rotation_matrix[TableIndices<2>(2,1)] = 43./1000.;
-  rotation_matrix[TableIndices<2>(2,2)] = 44./1000.;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data,1,1,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 45./1000.;
-  rotation_matrix[TableIndices<2>(0,1)] = 46./1000.;
-  rotation_matrix[TableIndices<2>(0,2)] = 47./1000.;
-  rotation_matrix[TableIndices<2>(1,0)] = 48./1000.;
-  rotation_matrix[TableIndices<2>(1,1)] = 49./1000.;
-  rotation_matrix[TableIndices<2>(1,2)] = 50./1000.;
-  rotation_matrix[TableIndices<2>(2,0)] = 51./1000.;
-  rotation_matrix[TableIndices<2>(2,1)] = 52./1000.;
-  rotation_matrix[TableIndices<2>(2,2)] = 53./1000.;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data,1,2,rotation_matrix);
-
-  cpo.set_volume_fractions_grains(cpo_data_position,data,1,0,0.4);
-  cpo.set_volume_fractions_grains(cpo_data_position,data,1,1,0.5);
-  cpo.set_volume_fractions_grains(cpo_data_position,data,1,2,0.6);
-
-  data[0] = 20847932.2;
-  data[65] = 6541684.3;
-
-  cpo.set_deformation_type(cpo_data_position,data,0,aspect::Particle::Property::DeformationType::passive);
-  cpo.set_deformation_type(cpo_data_position,data,1,aspect::Particle::Property::DeformationType::passive);
-
-
-  CHECK(data[0] == Approx(20847932.2)); // before data position
-  // mineral 1
-  CHECK(data[1] ==  Approx(0.0)); // deformation type
-  CHECK(data[2] ==  Approx(0.7)); //Mineral volume fraction
-  CHECK(data[3] ==  Approx(0.1)); // grain 0 volume fraction
-  double counter_rotation = 0.;
-  for (size_t iii = 4; iii < 13; iii++)
-    {
-      CHECK(data[iii] == Approx(counter_rotation));
-      counter_rotation += 1./1000.;
-    }
-  CHECK(data[13] ==  Approx(0.2)); // grain 1 volume fraction
-  for (size_t iii = 14; iii < 23; iii++)
-    {
-      CHECK(data[iii] == Approx(counter_rotation));
-      counter_rotation += 1./1000.;
-    }
-  CHECK(data[23] ==  Approx(0.3)); // grain 2 volume fraction
-  for (size_t iii = 24; iii < 33; iii++)
-    {
-      CHECK(data[iii] == Approx(counter_rotation));
-      counter_rotation += 1./1000.;
-    }
-  // mineral 2
-  CHECK(data[33] ==  Approx(0.0)); // deformation type
-  CHECK(data[34] ==  Approx(0.3)); //Mineral volume fraction
-  CHECK(data[35] ==  Approx(0.4)); // grain 0 volume fraction
-  for (size_t iii = 36; iii < 45; iii++)
-    {
-      CHECK(data[iii] == Approx(counter_rotation));
-      counter_rotation += 1./1000.;
-    }
-  CHECK(data[45] ==  Approx(0.5)); // grain 1 volume fraction
-  for (size_t iii = 46; iii < 55; iii++)
-    {
-      CHECK(data[iii] == Approx(counter_rotation));
-      counter_rotation += 1./1000.;
-    }
-  CHECK(data[55] ==  Approx(0.6)); // grain 2 volume fraction
-  for (size_t iii = 56; iii < 65; iii++)
-    {
-      CHECK(data[iii] == Approx(counter_rotation));
-      counter_rotation += 1./1000.;
-    }
-  CHECK(data[65] == Approx(6541684.3)); // after data position
-  CHECK(data[66] == Approx(-1.0)); // after data position
-
-}
-
-TEST_CASE("CPO core: Spin tensor")
-{
-  using namespace dealii;
-  using namespace aspect;
-
-  {
-    // test initialization in 3d.
-
-    aspect::Particle::Property::CrystalPreferredOrientation<3> cpo_3d;
-    aspect::ParameterHandler prm;
-    prm.enter_subsection("Particles");
-    {
-      cpo_3d.declare_parameters(prm);
-      prm.enter_subsection("Crystal Preferred Orientation");
-      {
-        prm.set("Random number seed","1");
-        prm.set("Number of grains per particle","5");
-        prm.set("CPO derivatives algorithm","Spin tensor");
-        prm.set("Property advection method","Forward Euler");
-        prm.enter_subsection("Initial grains");
-        {
-          prm.set("Model name","Uniform grains and random uniform rotations");
-          // Let the minerals just passively rotate with the rotation of
-          // the particle caused by the flow.
-          prm.set("Minerals","Passive,Passive");
-          prm.set("Volume fractions minerals","0.5,0.5");
-        }
-        prm.leave_subsection();
-      }
-      prm.leave_subsection ();
-    }
-    prm.leave_subsection ();
-
-
-    prm.enter_subsection("Particles");
-    {
-      cpo_3d.parse_parameters(prm);
-    }
-    prm.leave_subsection ();
-
-    cpo_3d.initialize();
-
-    Point<3> dummy_point;
-    std::vector<double> data;
-    cpo_3d.initialize_one_particle_property(dummy_point, data);
-    // The CPO particles are initialized. With the same seed, the outcome should
-    // always be the same, so test that for seed = 1. Furthermore, in the data
-    // I can only really test that the first entry is the water content (0) and
-    // that every first entry of each particle is 1/n_grains = 1/10 = 0.1.
-    CHECK(data[0] == Approx(-1.0));//isnan(data[0])); // default fabric type which is only computed on a update
-    CHECK(data[1] == Approx(0.5)); // default volume fraction olivine
-    CHECK(data[2] == Approx(0.2));
-    CHECK(data[3] == Approx(0.8794381492));
-    CHECK(data[4] == Approx(-0.4757482965));
-    CHECK(data[5] == Approx(-0.015877661));
-    CHECK(data[6] == Approx(-0.197154988));
-    CHECK(data[7] == Approx(-0.394402755));
-    CHECK(data[8] == Approx(0.8975390674));
-    CHECK(data[9] == Approx(-0.4332648756));
-    CHECK(data[10] == Approx(-0.7861997362));
-    CHECK(data[11] == Approx(-0.4406489786));
-    CHECK(data[12] == Approx(0.2));
-    CHECK(data[13] == Approx(-0.911475687));
-    CHECK(data[14] == Approx(0.4113536692));
-    CHECK(data[15] == Approx(0.0004804047));
-    CHECK(data[16] == Approx(-0.3056521145));
-    CHECK(data[17] == Approx(-0.6780433033));
-    CHECK(data[18] == Approx(0.6684564786));
-    CHECK(data[19] == Approx(0.2752977604));
-    CHECK(data[20] == Approx(0.6091349914));
-    CHECK(data[21] == Approx(0.7437511045));
-    CHECK(data[22] == Approx(0.2));
-    CHECK(data[32] == Approx(0.2));
-    CHECK(data[42] == Approx(0.2));
-    CHECK(data[52] == Approx(-1.0));// default fabric type which is only computed on a update
-    CHECK(data[53] == Approx(0.5)); // default volume fraction olivine
-    CHECK(data[54] == Approx(0.2));
-    CHECK(data[64] == Approx(0.2));
-    CHECK(data[74] == Approx(0.2));
-    CHECK(data[84] == Approx(0.2));
-    CHECK(data[94] == Approx(0.2));
-    CHECK(data[103] == Approx(-0.0688278144));
-
-    std::vector<double> volume_fractions(5,0.2);
-    std::vector<dealii::Tensor<2,3>> rotation_matrices_minerals(5);
-    rotation_matrices_minerals[0][0][0] = 0.5;
-    rotation_matrices_minerals[0][0][1] = 0.5;
-    rotation_matrices_minerals[0][0][2] = 0.5;
-    rotation_matrices_minerals[0][1][0] = 0.5;
-    rotation_matrices_minerals[0][1][1] = 0.5;
-    rotation_matrices_minerals[0][1][2] = 0.5;
-    rotation_matrices_minerals[0][2][0] = 0.5;
-    rotation_matrices_minerals[0][2][1] = 0.5;
-    rotation_matrices_minerals[0][2][2] = 0.5;
-
-    rotation_matrices_minerals[1][0][0] = 0.1;
-    rotation_matrices_minerals[1][0][1] = 0.2;
-    rotation_matrices_minerals[1][0][2] = 0.3;
-    rotation_matrices_minerals[1][1][0] = 0.4;
-    rotation_matrices_minerals[1][1][1] = 0.5;
-    rotation_matrices_minerals[1][1][2] = 0.6;
-    rotation_matrices_minerals[1][2][0] = 0.7;
-    rotation_matrices_minerals[1][2][1] = 0.8;
-    rotation_matrices_minerals[1][2][2] = 0.9;
-
-    rotation_matrices_minerals[2][0][0] = 0.1;
-    rotation_matrices_minerals[2][0][1] = 0.2;
-    rotation_matrices_minerals[2][0][2] = 0.3;
-    rotation_matrices_minerals[2][1][0] = 0.4;
-    rotation_matrices_minerals[2][1][1] = 0.5;
-    rotation_matrices_minerals[2][1][2] = 0.6;
-    rotation_matrices_minerals[2][2][0] = 0.7;
-    rotation_matrices_minerals[2][2][1] = 0.8;
-    rotation_matrices_minerals[2][2][2] = 0.9;
-
-    rotation_matrices_minerals[3][0][0] = 0.1;
-    rotation_matrices_minerals[3][0][1] = 0.2;
-    rotation_matrices_minerals[3][0][2] = 0.3;
-    rotation_matrices_minerals[3][1][0] = 0.4;
-    rotation_matrices_minerals[3][1][1] = 0.5;
-    rotation_matrices_minerals[3][1][2] = 0.6;
-    rotation_matrices_minerals[3][2][0] = 0.7;
-    rotation_matrices_minerals[3][2][1] = 0.8;
-    rotation_matrices_minerals[3][2][2] = 0.9;
-
-    rotation_matrices_minerals[4][0][0] = 0.1;
-    rotation_matrices_minerals[4][0][1] = 0.2;
-    rotation_matrices_minerals[4][0][2] = 0.3;
-    rotation_matrices_minerals[4][1][0] = 0.4;
-    rotation_matrices_minerals[4][1][1] = 0.5;
-    rotation_matrices_minerals[4][1][2] = 0.6;
-    rotation_matrices_minerals[4][2][0] = 0.7;
-    rotation_matrices_minerals[4][2][1] = 0.8;
-    rotation_matrices_minerals[4][2][2] = 0.9;
-
-    SymmetricTensor<2,3> strain_rate_nondimensional;
-    strain_rate_nondimensional[0][1] = 0.5959;
-
-    SymmetricTensor<2,3> compressible_strain_rate;
-
-    Tensor<2,3> velocity_gradient_tensor_nondimensional;
-    velocity_gradient_tensor_nondimensional[0][1] = 2.0* 0.5959;
-    velocity_gradient_tensor_nondimensional[1][0] = 2.0* 0.5959;
-
-    const Point<3> position;
-    const double temperature = 0;
-    const double pressure = 0;
-    const Tensor<1,3> velocity;
-    const std::vector<double> compositions;
-    const SymmetricTensor<2,3> strain_rate;
-    const double water_content = 0;
-
-    std::pair<std::vector<double>, std::vector<Tensor<2,3>>> derivatives;
-    derivatives = cpo_3d.compute_derivatives(0,
-                                             data,
-                                             0,
-                                             strain_rate_nondimensional,
-                                             velocity_gradient_tensor_nondimensional,
-                                             position,
-                                             temperature,
-                                             pressure,
-                                             velocity,
-                                             compositions,
-                                             strain_rate,
-                                             compressible_strain_rate,
-                                             water_content);
-
-    // The correct analytical solution to check against
-    // Note that this still has to be multiplied with with volume fraction
-    // of each grain to get the same solution as D-Rex would get.
-    double solution[5] = {0.0, 0.0, 0.0, 0.0 ,0.0};
-    for (unsigned int iii = 0; iii < derivatives.first.size(); ++iii)
-      CHECK(derivatives.first[iii] == Approx(solution[iii]));
-
-    Tensor<2,3> deriv_direction_solution_2_to_5;
-    deriv_direction_solution_2_to_5[0][0] = 0;
-    deriv_direction_solution_2_to_5[0][1] = 0.0;
-    deriv_direction_solution_2_to_5[0][2] = 0.0;
-    deriv_direction_solution_2_to_5[1][0] = 0.0;
-    deriv_direction_solution_2_to_5[1][1] = 0.0;
-    deriv_direction_solution_2_to_5[1][2] = 0.0;
-    deriv_direction_solution_2_to_5[2][0] = 0.0;
-    deriv_direction_solution_2_to_5[2][1] = 0.0;
-    deriv_direction_solution_2_to_5[2][2] = 0.0;
-    Tensor<2,3> deriv_direction_solution[5] = {Tensor<2,3>(),deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5};
-    for (size_t index = 0; index < 5; index++)
-      {
-        for (size_t iii = 0; iii < 3; iii++)
-          {
-            for (size_t jjj = 0; jjj < 3; jjj++)
-              {
-                CHECK(deriv_direction_solution[index][iii][jjj] == Approx(derivatives.second[index][iii][jjj]));
-              }
-          }
-      }
-    // now check if the value is the same as the D-Rex output when contracted with the direction matrix
-    Tensor<2,3> deriv_direction_full_solution_2_to_5;
-    deriv_direction_full_solution_2_to_5[0][0] = 0.0 ;
-    deriv_direction_full_solution_2_to_5[0][1] = 0.0;
-    deriv_direction_full_solution_2_to_5[0][2] = 0.0;
-    deriv_direction_full_solution_2_to_5[1][0] = 0.0;
-    deriv_direction_full_solution_2_to_5[1][1] = 0.0;
-    deriv_direction_full_solution_2_to_5[1][2] = 0.0;
-    deriv_direction_full_solution_2_to_5[2][0] = 0.0;
-    deriv_direction_full_solution_2_to_5[2][1] = 0.0;
-    deriv_direction_full_solution_2_to_5[2][2] = 0.0;
-    Tensor<2,3> deriv_direction_full_solution[5] = {Tensor<2,3>(),deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5};
-    for (size_t index = 0; index < 5; index++)
-      {
-        auto full_solution = rotation_matrices_minerals[index] * deriv_direction_solution[index];
-        for (size_t iii = 0; iii < 3; iii++)
-          {
-            for (size_t jjj = 0; jjj < 3; jjj++)
-              {
-                CHECK(full_solution[iii][jjj] == Approx(deriv_direction_full_solution[index][iii][jjj]));
-              }
-          }
-      }
-  }
-}
-
-
-TEST_CASE("Fabric determination function")
-{
-  using namespace aspect;
-  using namespace Particle::Property;
-  CrystalPreferredOrientation<3> cpo;
-  double MPa = 1e6;
-
-  CHECK(cpo.determine_deformation_type_karato_2008(379.*MPa, 0.) == DeformationType::olivine_a_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(381.*MPa, 0.) == DeformationType::olivine_d_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(0.*MPa, 100.) == DeformationType::olivine_a_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 50.) == DeformationType::olivine_a_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 50.) == DeformationType::olivine_a_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(379.*MPa, 50.) == DeformationType::olivine_d_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 49.) == DeformationType::olivine_d_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 75.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 100.) == DeformationType::olivine_a_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 100.) == DeformationType::olivine_a_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(379.*MPa, 100.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 100.) == DeformationType::olivine_b_fabric);
-
-  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 200.) == DeformationType::olivine_a_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 200.) == DeformationType::olivine_a_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 200.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 200.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 200.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 200.) == DeformationType::olivine_b_fabric);
-
-  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 300.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 300.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 300.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 300.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 300.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 300.) == DeformationType::olivine_b_fabric);
-
-  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 380.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 380.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 380.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 380.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 380.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 380.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 380.) == DeformationType::olivine_b_fabric);
-
-  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 400.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 400.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 400.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 400.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 400.) == DeformationType::olivine_c_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 400.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 400.) == DeformationType::olivine_b_fabric);
-
-  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 600.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 600.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 600.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 600.) == DeformationType::olivine_c_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 600.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 600.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 600.) == DeformationType::olivine_b_fabric);
-
-  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 800.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 800.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 800.) == DeformationType::olivine_c_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 800.) == DeformationType::olivine_c_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 800.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 800.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 800.) == DeformationType::olivine_b_fabric);
-
-  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 1000.) == DeformationType::olivine_e_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 1000.) == DeformationType::olivine_c_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 1000.) == DeformationType::olivine_c_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 1000.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 1000.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 1000.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 1000.) == DeformationType::olivine_b_fabric);
-
-  CHECK(cpo.determine_deformation_type_karato_2008(20.*MPa, 1200.) == DeformationType::olivine_c_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(100.*MPa, 1200.) == DeformationType::olivine_c_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(200.*MPa, 1200.) == DeformationType::olivine_c_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(340.*MPa, 1200.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(360.*MPa, 1200.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(380.*MPa, 1200.) == DeformationType::olivine_b_fabric);
-  CHECK(cpo.determine_deformation_type_karato_2008(480.*MPa, 1200.) == DeformationType::olivine_b_fabric);
-}
-
-
-TEST_CASE("CPO")
-{
-  using namespace dealii;
-  using namespace aspect;
-
-  {
-    // test initialization 3d.
-    const int dim3=3;
-
-    Particle::Property::CrystalPreferredOrientation<dim3> lpo_3d;
-    ParameterHandler prm;
-
-    prm.enter_subsection("Particles");
-    {
-      lpo_3d.declare_parameters(prm);
-      prm.enter_subsection("Crystal Preferred Orientation");
-      {
-        prm.set("Random number seed","1");
-        prm.set("Number of grains per particle","5");
-      }
-      prm.leave_subsection ();
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection("Particles");
-    {
-      lpo_3d.parse_parameters(prm);
-    }
-    prm.leave_subsection();
-
-    lpo_3d.initialize();
-
-
-    Point<dim3> dummy_point;
-    std::vector<double> data;
-    lpo_3d.initialize_one_particle_property(dummy_point, data);
-
-    // The LPO particles are initialized. With the same seed, the outcome should
-    // always be the same, so test that for seed = 1. Forthermore, in the data
-    // I can only really test that the first entry is the water content (0) and
-    // that every first entry of each particle is 1/n_grains = 1/10 = 0.1.
-    CHECK(data[0] == Approx(-1.0));//isnan(data[0])); // default fabric type which is only computed on a update
-    CHECK(data[1] == Approx(0.5)); // default volume fraction olivine
-    CHECK(data[2] == Approx(0.2));
-    CHECK(data[3] == Approx(0.8794381492));
-    CHECK(data[4] == Approx(-0.4757482965));
-    CHECK(data[5] == Approx(-0.015877661));
-    CHECK(data[6] == Approx(-0.197154988));
-    CHECK(data[7] == Approx(-0.394402755));
-    CHECK(data[8] == Approx(0.8975390674));
-    CHECK(data[9] == Approx(-0.4332648756));
-    CHECK(data[10] == Approx(-0.7861997362));
-    CHECK(data[11] == Approx(-0.4406489786));
-    CHECK(data[12] == Approx(0.2));
-    CHECK(data[13] == Approx(-0.911475687));
-    CHECK(data[14] == Approx(0.4113536692));
-    CHECK(data[15] == Approx(0.0004804047));
-    CHECK(data[16] == Approx(-0.3056521145));
-    CHECK(data[17] == Approx(-0.6780433033));
-    CHECK(data[18] == Approx(0.6684564786));
-    CHECK(data[19] == Approx(0.2752977604));
-    CHECK(data[20] == Approx(0.6091349914));
-    CHECK(data[21] == Approx(0.7437511045));
-    CHECK(data[22] == Approx(0.2));
-    CHECK(data[32] == Approx(0.2));
-    CHECK(data[42] == Approx(0.2));
-    CHECK(data[52] == Approx(-1.0));// default fabric type which is only computed on a update
-    CHECK(data[53] == Approx(0.5)); // default volume fraction olivine
-    CHECK(data[54] == Approx(0.2));
-    CHECK(data[64] == Approx(0.2));
-    CHECK(data[74] == Approx(0.2));
-    CHECK(data[84] == Approx(0.2));
-    CHECK(data[94] == Approx(0.2));
-    CHECK(data[103] == Approx(-0.0688278144));
-
-    std::vector<double> volume_fractions(5,0.2);
-    std::vector<dealii::Tensor<2,3>> a_cosine_matrices(5);
-    a_cosine_matrices[0][0][0] = 0.5;
-    a_cosine_matrices[0][0][1] = 0.5;
-    a_cosine_matrices[0][0][2] = 0.5;
-    a_cosine_matrices[0][1][0] = 0.5;
-    a_cosine_matrices[0][1][1] = 0.5;
-    a_cosine_matrices[0][1][2] = 0.5;
-    a_cosine_matrices[0][2][0] = 0.5;
-    a_cosine_matrices[0][2][1] = 0.5;
-    a_cosine_matrices[0][2][2] = 0.5;
-
-    a_cosine_matrices[1][0][0] = 0.1;
-    a_cosine_matrices[1][0][1] = 0.2;
-    a_cosine_matrices[1][0][2] = 0.3;
-    a_cosine_matrices[1][1][0] = 0.4;
-    a_cosine_matrices[1][1][1] = 0.5;
-    a_cosine_matrices[1][1][2] = 0.6;
-    a_cosine_matrices[1][2][0] = 0.7;
-    a_cosine_matrices[1][2][1] = 0.8;
-    a_cosine_matrices[1][2][2] = 0.9;
-
-    a_cosine_matrices[2][0][0] = 0.1;
-    a_cosine_matrices[2][0][1] = 0.2;
-    a_cosine_matrices[2][0][2] = 0.3;
-    a_cosine_matrices[2][1][0] = 0.4;
-    a_cosine_matrices[2][1][1] = 0.5;
-    a_cosine_matrices[2][1][2] = 0.6;
-    a_cosine_matrices[2][2][0] = 0.7;
-    a_cosine_matrices[2][2][1] = 0.8;
-    a_cosine_matrices[2][2][2] = 0.9;
-
-    a_cosine_matrices[3][0][0] = 0.1;
-    a_cosine_matrices[3][0][1] = 0.2;
-    a_cosine_matrices[3][0][2] = 0.3;
-    a_cosine_matrices[3][1][0] = 0.4;
-    a_cosine_matrices[3][1][1] = 0.5;
-    a_cosine_matrices[3][1][2] = 0.6;
-    a_cosine_matrices[3][2][0] = 0.7;
-    a_cosine_matrices[3][2][1] = 0.8;
-    a_cosine_matrices[3][2][2] = 0.9;
-
-    a_cosine_matrices[4][0][0] = 0.1;
-    a_cosine_matrices[4][0][1] = 0.2;
-    a_cosine_matrices[4][0][2] = 0.3;
-    a_cosine_matrices[4][1][0] = 0.4;
-    a_cosine_matrices[4][1][1] = 0.5;
-    a_cosine_matrices[4][1][2] = 0.6;
-    a_cosine_matrices[4][2][0] = 0.7;
-    a_cosine_matrices[4][2][1] = 0.8;
-    a_cosine_matrices[4][2][2] = 0.9;
-
-    lpo_3d.set_volume_fractions_grains(0,data,0,0,0.2);
-    lpo_3d.set_volume_fractions_grains(0,data,0,1,0.2);
-    lpo_3d.set_volume_fractions_grains(0,data,0,2,0.2);
-    lpo_3d.set_volume_fractions_grains(0,data,0,3,0.2);
-    lpo_3d.set_volume_fractions_grains(0,data,0,4,0.2);
-
-    lpo_3d.set_rotation_matrix_grains(0,data,0,0,a_cosine_matrices[0]);
-    lpo_3d.set_rotation_matrix_grains(0,data,0,1,a_cosine_matrices[1]);
-    lpo_3d.set_rotation_matrix_grains(0,data,0,2,a_cosine_matrices[2]);
-    lpo_3d.set_rotation_matrix_grains(0,data,0,3,a_cosine_matrices[3]);
-    lpo_3d.set_rotation_matrix_grains(0,data,0,4,a_cosine_matrices[4]);
-
-    SymmetricTensor<2,3> strain_rate_nondimensional;
-    strain_rate_nondimensional[0][1] = 0.5959;
-
-    Tensor<2,3> velocity_gradient_tensor_nondimensional;
-    velocity_gradient_tensor_nondimensional[0][1] = 2.0* 0.5959;
-    velocity_gradient_tensor_nondimensional[1][0] = 2.0* 0.5959;
-
-    std::array<double,4> ref_resolved_shear_stress;
-    ref_resolved_shear_stress[0] = 1;
-    ref_resolved_shear_stress[1] = 2;
-    ref_resolved_shear_stress[2] = 3;
-    ref_resolved_shear_stress[3] = 1e60; // can't really use nummerical limits max or infinite, because need to be able to square it without becoming infinite. This is the value fortran D-Rex uses.
-
-
-    std::pair<std::vector<double>, std::vector<Tensor<2,3>>> derivatives;
-    derivatives = lpo_3d.compute_derivatives_drex_2004(0,
-                                                       data,
-                                                       0,
-                                                       strain_rate_nondimensional,
-                                                       velocity_gradient_tensor_nondimensional,
-                                                       ref_resolved_shear_stress,
-                                                       true);
-
-
-    // The correct analytical solution to check against
-    double solution[5] = {3.150563756, -0.787640939, -0.787640939, -0.787640939 ,-0.787640939};
-    for (unsigned int i = 0; i < derivatives.first.size(); ++i)
-      CHECK(derivatives.first[i] == Approx(solution[i]));
-
-
-    Tensor<2,3> deriv_direction_solution_2_to_5;
-    deriv_direction_solution_2_to_5[0][0] = 0;
-    deriv_direction_solution_2_to_5[0][1] = 0.00501912;
-    deriv_direction_solution_2_to_5[0][2] = 0.0100382;
-    deriv_direction_solution_2_to_5[1][0] = -0.00501912;
-    deriv_direction_solution_2_to_5[1][1] = 0;
-    deriv_direction_solution_2_to_5[1][2] = 0.00501912;
-    deriv_direction_solution_2_to_5[2][0] = -0.0100382;
-    deriv_direction_solution_2_to_5[2][1] = -0.00501912;
-    deriv_direction_solution_2_to_5[2][2] = 0;
-
-    Tensor<2,3> deriv_direction_solution[5] = {Tensor<2,3>(),deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5};
-    for (size_t index = 0; index < 5; index++)
-      {
-        for (size_t iii = 0; iii < 3; iii++)
-          {
-            for (size_t jjj = 0; jjj < 3; jjj++)
-              {
-                CHECK(deriv_direction_solution[index][iii][jjj] == Approx(derivatives.second[index][iii][jjj]));
-              }
-          }
-      }
-    // now check if the value is the same as the D-Rex output when contracted with the direction matrix
-    Tensor<2,3> deriv_direction_full_solution_2_to_5;
-    deriv_direction_full_solution_2_to_5[0][0] = -0.004015284 ;
-    deriv_direction_full_solution_2_to_5[0][1] = -0.0010038242;
-    deriv_direction_full_solution_2_to_5[0][2] = 0.0020076485;
-    deriv_direction_full_solution_2_to_5[1][0] = -0.00853248;
-    deriv_direction_full_solution_2_to_5[1][1] = -0.0010038242;
-    deriv_direction_full_solution_2_to_5[1][2] = 0.0065248576;
-    deriv_direction_full_solution_2_to_5[2][0] = -0.0130497151;
-    deriv_direction_full_solution_2_to_5[2][1] = -0.0010038242;
-    deriv_direction_full_solution_2_to_5[2][2] = 0.0110420667;
-    Tensor<2,3> deriv_direction_full_solution[5] = {Tensor<2,3>(),deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5};
-    for (size_t index = 0; index < 5; index++)
-      {
-        auto full_solution = a_cosine_matrices[index] * deriv_direction_solution[index];
-        for (size_t iii = 0; iii < 3; iii++)
-          {
-            for (size_t jjj = 0; jjj < 3; jjj++)
-              {
-                CHECK(full_solution[iii][jjj] == Approx(deriv_direction_full_solution[index][iii][jjj]));
-              }
-          }
-      }
-  }
-
-  {
-    // thirdly test 3d lpo with different strain-rate and velocity gradient tensors.
-    // The solution of this test has not been analytically confirmed.
-    const int dim3=3;
-
-    Particle::Property::CrystalPreferredOrientation<dim3> lpo_3d;
-    ParameterHandler prm;
-
-    prm.enter_subsection("Particles");
-    {
-      lpo_3d.declare_parameters(prm);
-      prm.enter_subsection("Crystal Preferred Orientation");
-      {
-        prm.set("Random number seed","1");
-        prm.set("Number of grains per particle","5");
-      }
-      prm.leave_subsection ();
-    }
-    prm.leave_subsection ();
-
-    prm.enter_subsection("Particles");
-    {
-      lpo_3d.parse_parameters(prm);
-    }
-    prm.leave_subsection ();
-
-    lpo_3d.initialize();
-
-
-    Point<dim3> dummy_point;
-    std::vector<double> data;
-    lpo_3d.initialize_one_particle_property(dummy_point, data);
-
-    // The LPO particles are initialized. With the same seed, the outcome should
-    // always be the same, so test that for seed = 1. Forthermore, in the data
-    // I can only really test that the first entry is the water content (0) and
-    // that every first entry of each particle is 1/n_grains = 1/10 = 0.1.
-    CHECK(data[0] == Approx(-1.0));//isnan(data[0])); // default fabric type which is only computed on a update
-    CHECK(data[1] == Approx(0.5)); // default volume fraction olivine
-    CHECK(data[2] == Approx(0.2));
-    CHECK(data[3] == Approx(0.8794381492));
-    CHECK(data[4] == Approx(-0.4757482965));
-    CHECK(data[5] == Approx(-0.015877661));
-    CHECK(data[6] == Approx(-0.197154988));
-    CHECK(data[7] == Approx(-0.394402755));
-    CHECK(data[8] == Approx(0.8975390674));
-    CHECK(data[9] == Approx(-0.4332648756));
-    CHECK(data[10] == Approx(-0.7861997362));
-    CHECK(data[11] == Approx(-0.4406489786));
-    CHECK(data[12] == Approx(0.2));
-    CHECK(data[13] == Approx(-0.911475687));
-    CHECK(data[14] == Approx(0.4113536692));
-    CHECK(data[15] == Approx(0.0004804047));
-    CHECK(data[16] == Approx(-0.3056521145));
-    CHECK(data[17] == Approx(-0.6780433033));
-    CHECK(data[18] == Approx(0.6684564786));
-    CHECK(data[19] == Approx(0.2752977604));
-    CHECK(data[20] == Approx(0.6091349914));
-    CHECK(data[21] == Approx(0.7437511045));
-    CHECK(data[22] == Approx(0.2));
-    CHECK(data[32] == Approx(0.2));
-    CHECK(data[42] == Approx(0.2));
-    CHECK(data[52] == Approx(-1.0));// default fabric type which is only computed on a update
-    CHECK(data[53] == Approx(0.5)); // default volume fraction olivine
-    CHECK(data[54] == Approx(0.2));
-    CHECK(data[64] == Approx(0.2));
-    CHECK(data[74] == Approx(0.2));
-    CHECK(data[84] == Approx(0.2));
-    CHECK(data[94] == Approx(0.2));
-    CHECK(data[103] == Approx(-0.0688278144));
-
-    std::vector<double> volume_fractions(5,0.2);
-    std::vector<dealii::Tensor<2,3>> a_cosine_matrices(5);
-    a_cosine_matrices[0][0][0] = 0.5;
-    a_cosine_matrices[0][0][1] = 0.5;
-    a_cosine_matrices[0][0][2] = 0.5;
-    a_cosine_matrices[0][1][0] = 0.5;
-    a_cosine_matrices[0][1][1] = 0.5;
-    a_cosine_matrices[0][1][2] = 0.5;
-    a_cosine_matrices[0][2][0] = 0.5;
-    a_cosine_matrices[0][2][1] = 0.5;
-    a_cosine_matrices[0][2][2] = 0.5;
-
-    a_cosine_matrices[1][0][0] = 0.1;
-    a_cosine_matrices[1][0][1] = 0.2;
-    a_cosine_matrices[1][0][2] = 0.3;
-    a_cosine_matrices[1][1][0] = 0.4;
-    a_cosine_matrices[1][1][1] = 0.5;
-    a_cosine_matrices[1][1][2] = 0.6;
-    a_cosine_matrices[1][2][0] = 0.7;
-    a_cosine_matrices[1][2][1] = 0.8;
-    a_cosine_matrices[1][2][2] = 0.9;
-
-    a_cosine_matrices[2][0][0] = 0.1;
-    a_cosine_matrices[2][0][1] = 0.2;
-    a_cosine_matrices[2][0][2] = 0.3;
-    a_cosine_matrices[2][1][0] = 0.4;
-    a_cosine_matrices[2][1][1] = 0.5;
-    a_cosine_matrices[2][1][2] = 0.6;
-    a_cosine_matrices[2][2][0] = 0.7;
-    a_cosine_matrices[2][2][1] = 0.8;
-    a_cosine_matrices[2][2][2] = 0.9;
-
-    a_cosine_matrices[3][0][0] = 0.1;
-    a_cosine_matrices[3][0][1] = 0.2;
-    a_cosine_matrices[3][0][2] = 0.3;
-    a_cosine_matrices[3][1][0] = 0.4;
-    a_cosine_matrices[3][1][1] = 0.5;
-    a_cosine_matrices[3][1][2] = 0.6;
-    a_cosine_matrices[3][2][0] = 0.7;
-    a_cosine_matrices[3][2][1] = 0.8;
-    a_cosine_matrices[3][2][2] = 0.9;
-
-    a_cosine_matrices[4][0][0] = 0.1;
-    a_cosine_matrices[4][0][1] = 0.2;
-    a_cosine_matrices[4][0][2] = 0.3;
-    a_cosine_matrices[4][1][0] = 0.4;
-    a_cosine_matrices[4][1][1] = 0.5;
-    a_cosine_matrices[4][1][2] = 0.6;
-    a_cosine_matrices[4][2][0] = 0.7;
-    a_cosine_matrices[4][2][1] = 0.8;
-    a_cosine_matrices[4][2][2] = 0.9;
-
-
-    lpo_3d.set_volume_fractions_grains(0,data,0,0,0.2);
-    lpo_3d.set_volume_fractions_grains(0,data,0,1,0.2);
-    lpo_3d.set_volume_fractions_grains(0,data,0,2,0.2);
-    lpo_3d.set_volume_fractions_grains(0,data,0,3,0.2);
-    lpo_3d.set_volume_fractions_grains(0,data,0,4,0.2);
-
-    lpo_3d.set_rotation_matrix_grains(0,data,0,0,a_cosine_matrices[0]);
-    lpo_3d.set_rotation_matrix_grains(0,data,0,1,a_cosine_matrices[1]);
-    lpo_3d.set_rotation_matrix_grains(0,data,0,2,a_cosine_matrices[2]);
-    lpo_3d.set_rotation_matrix_grains(0,data,0,3,a_cosine_matrices[3]);
-    lpo_3d.set_rotation_matrix_grains(0,data,0,4,a_cosine_matrices[4]);
-
-    SymmetricTensor<2,dim3> strain_rate_nondimensional; // e
-    strain_rate_nondimensional[0][0] = 7.5;
-    strain_rate_nondimensional[0][1] = 8;
-    strain_rate_nondimensional[0][2] = 8.5;
-    //strain_rate_nondimensional[1][0] = 8; // symmetry
-    strain_rate_nondimensional[1][1] = 9.5;
-    strain_rate_nondimensional[1][2] = 10;
-    //strain_rate_nondimensional[2][0] = 8.5;// symmetry
-    //strain_rate_nondimensional[2][1] = 10; // symmetry
-    strain_rate_nondimensional[2][2] = 11.5;
-
-    Tensor<2,dim3> velocity_gradient_tensor_nondimensional; // l
-    velocity_gradient_tensor_nondimensional[0][0] = 2;
-    velocity_gradient_tensor_nondimensional[0][1] = 2.5;
-    velocity_gradient_tensor_nondimensional[0][2] = 3;
-    velocity_gradient_tensor_nondimensional[1][0] = 3.5;
-    velocity_gradient_tensor_nondimensional[1][1] = 4;
-    velocity_gradient_tensor_nondimensional[1][2] = 4.5;
-    velocity_gradient_tensor_nondimensional[2][0] = 5;
-    velocity_gradient_tensor_nondimensional[2][1] = 5.5;
-    velocity_gradient_tensor_nondimensional[2][2] = 6;
-
-
-    std::array<double,4> ref_resolved_shear_stress;
-    ref_resolved_shear_stress[0] = 1;
-    ref_resolved_shear_stress[1] = 2;
-    ref_resolved_shear_stress[2] = 3;
-    ref_resolved_shear_stress[3] = 1e60; // can't really use nummerical limits max or infinite, because need to be able to square it without becoming infinite. This is the value fortran D-Rex uses.
-
-
-    std::pair<std::vector<double>, std::vector<Tensor<2,3>>> derivatives;
-    derivatives = lpo_3d.compute_derivatives_drex_2004(0,
-                                                       data,
-                                                       0,
-                                                       strain_rate_nondimensional,
-                                                       velocity_gradient_tensor_nondimensional,
-                                                       ref_resolved_shear_stress,
-                                                       true);
-
-    // The correct analytical solution to check against
-    double solution[5] = {2.5350823696, -0.6337705924, -0.6337705924, -0.6337705924 ,-0.6337705924};
-    for (unsigned int i = 0; i < derivatives.first.size(); ++i)
-      CHECK(derivatives.first[i] == Approx(solution[i]));
-
-
-    Tensor<2,3> deriv_direction_solution_1;
-    deriv_direction_solution_1[0][0] = 0;
-    deriv_direction_solution_1[0][1] = 0.5;
-    deriv_direction_solution_1[0][2] = 1.0;
-    deriv_direction_solution_1[1][0] = -0.5;
-    deriv_direction_solution_1[1][1] = 0;
-    deriv_direction_solution_1[1][2] = 0.5;
-    deriv_direction_solution_1[2][0] = -1.0;
-    deriv_direction_solution_1[2][1] = -0.5;
-    deriv_direction_solution_1[2][2] = 0;
-    Tensor<2,3> deriv_direction_solution_2_to_5;
-    deriv_direction_solution_2_to_5[0][0] = 0;
-    deriv_direction_solution_2_to_5[0][1] = 0.5304624591;
-    deriv_direction_solution_2_to_5[0][2] = 1.0609249182;
-    deriv_direction_solution_2_to_5[1][0] = -0.5304624591;
-    deriv_direction_solution_2_to_5[1][1] = 0;
-    deriv_direction_solution_2_to_5[1][2] = 0.5304624591;
-    deriv_direction_solution_2_to_5[2][0] = -1.0609249182;
-    deriv_direction_solution_2_to_5[2][1] = -0.5304624591 ;
-    deriv_direction_solution_2_to_5[2][2] = 0;
-
-    Tensor<2,3> deriv_direction_solution[5] = {deriv_direction_solution_1,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5,deriv_direction_solution_2_to_5};
-    for (size_t index = 0; index < 5; index++)
-      {
-        for (size_t iii = 0; iii < 3; iii++)
-          {
-            for (size_t jjj = 0; jjj < 3; jjj++)
-              {
-                CHECK(deriv_direction_solution[index][iii][jjj] == Approx(derivatives.second[index][iii][jjj]));
-              }
-          }
-      }
-    // now check if the value is the same as the D-Rex output when contracted with the direction matrix
-    Tensor<2,3> deriv_direction_full_solution_1;
-    deriv_direction_full_solution_1[0][0] = -0.75;
-    deriv_direction_full_solution_1[0][1] = 0.0;
-    deriv_direction_full_solution_1[0][2] = 0.75;
-    deriv_direction_full_solution_1[1][0] = -0.75;
-    deriv_direction_full_solution_1[1][1] = 0;
-    deriv_direction_full_solution_1[1][2] = 0.75;
-    deriv_direction_full_solution_1[2][0] = -0.75;
-    deriv_direction_full_solution_1[2][1] = 0.0;
-    deriv_direction_full_solution_1[2][2] = 0.75;
-    Tensor<2,3> deriv_direction_full_solution_2_to_5;
-    deriv_direction_full_solution_2_to_5[0][0] = -0.4243699673 ;
-    deriv_direction_full_solution_2_to_5[0][1] = -0.1060924918;
-    deriv_direction_full_solution_2_to_5[0][2] = 0.2121849836;
-    deriv_direction_full_solution_2_to_5[1][0] = -0.9017861805;
-    deriv_direction_full_solution_2_to_5[1][1] = -0.1060924918;
-    deriv_direction_full_solution_2_to_5[1][2] = 0.6896011968;
-    deriv_direction_full_solution_2_to_5[2][0] = -1.3792023937;
-    deriv_direction_full_solution_2_to_5[2][1] = -0.1060924918;
-    deriv_direction_full_solution_2_to_5[2][2] = 1.16701741;
-    Tensor<2,3> deriv_direction_full_solution[5] = {deriv_direction_full_solution_1,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5,deriv_direction_full_solution_2_to_5};
-    for (size_t index = 0; index < 5; index++)
-      {
-        auto full_solution = a_cosine_matrices[index] * deriv_direction_solution[index];
-        for (size_t iii = 0; iii < 3; iii++)
-          {
-            for (size_t jjj = 0; jjj < 3; jjj++)
-              {
-                CHECK(full_solution[iii][jjj] == Approx(deriv_direction_full_solution[index][iii][jjj]));
-              }
-          }
-      }
-  }
-}
-
-
-
-TEST_CASE("CPO elastic tensor")
-{
-  std::vector<double> volume_fraction_mineral = {0.7,0.3};
-  std::vector<std::vector<double>> volume_fractions_grains(2,std::vector<double>(8));
-  std::vector<std::vector<dealii::Tensor<2,3>>> a_cosine_matrices_grains(2,std::vector<dealii::Tensor<2,3>>(8));
-
-  dealii::Tensor<2,6> reference_elastic_tensor;
-  dealii::Tensor<2,6> computed_elastic_tensor;
-
-  unsigned int cpo_data_position = 0;
-  std::vector<double> data_array(200,-1.);
-  dealii::ArrayView<double> data_cpo(&data_array[0],200);
-
-
-  // test the averaging function
-  aspect::Particle::Property::CrystalPreferredOrientation<3> cpo;
-  aspect::Particle::Property::CpoElasticTensor<3> cpo_elastic_tensor;
-  aspect::ParameterHandler prm;
-  prm.enter_subsection("Particles");
-  {
-    cpo.declare_parameters(prm);
-    cpo_elastic_tensor.declare_parameters(prm);
-    prm.enter_subsection("Crystal Preferred Orientation");
-    {
-      prm.set("Random number seed","1");
-      prm.set("Number of grains per particle","8");
-      prm.set("CPO derivatives algorithm","Spin tensor");
-      prm.set("Property advection method","Backward Euler");
-      prm.enter_subsection("Initial grains");
-      {
-        prm.set("Model name","Uniform grains and random uniform rotations");
-        // Let the minerals just passively rotate with the rotation of
-        // the particle caused by the flow.
-        prm.set("Minerals","Passive,Passive");
-        prm.set("Volume fractions minerals","0.7,0.3");
-      }
-      prm.leave_subsection();
-    }
-    prm.leave_subsection ();
-  }
-  prm.leave_subsection ();
-
-  prm.enter_subsection("Particles");
-  {
-    cpo.parse_parameters(prm);
-    cpo_elastic_tensor.parse_parameters(prm);
-  }
-  prm.leave_subsection();
-
-  cpo.initialize();
-
-
-  // All these numbers are directly from the Fortran D-Rex
-  // Had to fix the random seed to get consistent results.
-  // Fixed the random set to an array filled with zeros.
-  using namespace dealii;
-  Tensor<2,3> rotation_matrix;
-  rotation_matrix[TableIndices<2>(0,0)] = -0.87492387659370430;
-  rotation_matrix[TableIndices<2>(0,1)] = -0.47600252255715020;
-  rotation_matrix[TableIndices<2>(0,2)] = -0.10151800968122601;
-  rotation_matrix[TableIndices<2>(1,0)] = 0.13036031917262200;
-  rotation_matrix[TableIndices<2>(1,1)] = -2.6406769698713056E-002;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.99232315682823224;
-  rotation_matrix[TableIndices<2>(2,0)] = 0.46957683898444408;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.87974004016081919;
-  rotation_matrix[TableIndices<2>(2,2)] = 8.6098835151007691E-002;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,0,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = -0.98046837857873570;
-  rotation_matrix[TableIndices<2>(0,1)] = 0.19463893778994429;
-  rotation_matrix[TableIndices<2>(0,2)] = -2.8239743415760400E-002;
-  rotation_matrix[TableIndices<2>(1,0)] = 6.8942963409018593E-002;
-  rotation_matrix[TableIndices<2>(1,1)] = 0.20565757913350766;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.97619251975954824;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.18419735979776022;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.95907282258851756;
-  rotation_matrix[TableIndices<2>(2,2)] = -0.21505972600848655;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,1,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = -0.60475851993637786;
-  rotation_matrix[TableIndices<2>(0,1)] = 0.70843624030907060;
-  rotation_matrix[TableIndices<2>(0,2)] = -0.36543256811748415;
-  rotation_matrix[TableIndices<2>(1,0)] = 0.14301138974031016;
-  rotation_matrix[TableIndices<2>(1,1)] = -0.35406726088673490;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.92567249145068109;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.78533679283378455;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.61106385979914768;
-  rotation_matrix[TableIndices<2>(2,2)] = 0.11279851062549377;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,2,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 0.86791495614143876;
-  rotation_matrix[TableIndices<2>(0,1)] = 0.11797028562530290;
-  rotation_matrix[TableIndices<2>(0,2)] = -0.48441508819120616;
-  rotation_matrix[TableIndices<2>(1,0)] = 0.29623368357270952;
-  rotation_matrix[TableIndices<2>(1,1)] = 0.66075310029034506;
-  rotation_matrix[TableIndices<2>(1,2)] = 0.69114249890201696;
-  rotation_matrix[TableIndices<2>(2,0)] = 0.40054408016972737;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.74231595966649988;
-  rotation_matrix[TableIndices<2>(2,2)] = 0.53869116329275069;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,3,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 6.2142369991145308E-002;
-  rotation_matrix[TableIndices<2>(0,1)] = 0.99798524450925208;
-  rotation_matrix[TableIndices<2>(0,2)] = 1.4733749724082583E-002;
-  rotation_matrix[TableIndices<2>(1,0)] = 0.16313304505497195;
-  rotation_matrix[TableIndices<2>(1,1)] = 3.9946223138032123E-003;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.99141604427573704;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.98947772660983668;
-  rotation_matrix[TableIndices<2>(2,1)] = 6.3633828841832010E-002;
-  rotation_matrix[TableIndices<2>(2,2)] = -0.16253511002663851;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,4,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 0.95811162445076037;
-  rotation_matrix[TableIndices<2>(0,1)] = -0.24047036409864109;
-  rotation_matrix[TableIndices<2>(0,2)] = -0.18394917461469307;
-  rotation_matrix[TableIndices<2>(1,0)] = -0.26945849516984494;
-  rotation_matrix[TableIndices<2>(1,1)] = -0.95216866624585605;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.14816174866727450;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.13948857525086517;
-  rotation_matrix[TableIndices<2>(2,1)] = 0.18918653693665904;
-  rotation_matrix[TableIndices<2>(2,2)] = -0.97685775746677384;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,5,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 0.54599545795872684;
-  rotation_matrix[TableIndices<2>(0,1)] = -0.79260950430410815;
-  rotation_matrix[TableIndices<2>(0,2)] = -0.27534584625644454;
-  rotation_matrix[TableIndices<2>(1,0)] = -0.83567561116582212;
-  rotation_matrix[TableIndices<2>(1,1)] = -0.55085590166106368;
-  rotation_matrix[TableIndices<2>(1,2)] = -6.8746495709015629E-002;
-  rotation_matrix[TableIndices<2>(2,0)] = -9.6081601263635075E-002;
-  rotation_matrix[TableIndices<2>(2,1)] = 0.26479508638287669;
-  rotation_matrix[TableIndices<2>(2,2)] = -0.96221681521835400;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,6,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 0.14540407652501869;
-  rotation_matrix[TableIndices<2>(0,1)] = -0.61649901222701298;
-  rotation_matrix[TableIndices<2>(0,2)] = -0.77881206212059828;
-  rotation_matrix[TableIndices<2>(1,0)] = -0.59216315099851768;
-  rotation_matrix[TableIndices<2>(1,1)] = -0.68282211925029168;
-  rotation_matrix[TableIndices<2>(1,2)] = 0.43341920614609419;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.79819736735552915;
-  rotation_matrix[TableIndices<2>(2,1)] = 0.39350172081601731;
-  rotation_matrix[TableIndices<2>(2,2)] = -0.46322016633770996;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,0,7,rotation_matrix);
-
-
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,0,2.5128593570287589E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,1,0.83128842847575013);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,2,2.4387041141724769E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,3,2.4763275182773107E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,4,2.4801714431754770E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,5,2.3943562805875843E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,6,2.1493810045792379E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,0,7,2.4193574346041427E-002);
-
-  rotation_matrix[TableIndices<2>(0,0)] = -0.66168933252008499;
-  rotation_matrix[TableIndices<2>(0,1)] = -0.27722421136423192;
-  rotation_matrix[TableIndices<2>(0,2)] = 0.70016104334335305;
-  rotation_matrix[TableIndices<2>(1,0)] = -0.45052346117292291;
-  rotation_matrix[TableIndices<2>(1,1)] = -0.59946225647123619;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.66370395454608444;
-  rotation_matrix[TableIndices<2>(2,0)] = 0.60350910238307343;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.75116099269655345;
-  rotation_matrix[TableIndices<2>(2,2)] = 0.27207473610935284;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,0,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 0.70309122563849258;
-  rotation_matrix[TableIndices<2>(0,1)] = -0.23393734574397834;
-  rotation_matrix[TableIndices<2>(0,2)] = -0.67775637808568567;
-  rotation_matrix[TableIndices<2>(1,0)] = 0.68298185906364617;
-  rotation_matrix[TableIndices<2>(1,1)] = -6.6406501211459870E-002;
-  rotation_matrix[TableIndices<2>(1,2)] = 0.73168002139436472;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.21654097292603913;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.97001835897279087;
-  rotation_matrix[TableIndices<2>(2,2)] = 0.11341644508992850;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,1,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = -0.37892641930874921;
-  rotation_matrix[TableIndices<2>(0,1)] = 0.92610670487847191;
-  rotation_matrix[TableIndices<2>(0,2)] = 3.9338024409460159E-002;
-  rotation_matrix[TableIndices<2>(1,0)] = -0.10014673867324062;
-  rotation_matrix[TableIndices<2>(1,1)] = 2.1922389732184896E-004;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.99514251026853373;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.92466780075091537;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.37833500123197994;
-  rotation_matrix[TableIndices<2>(2,2)] = 9.2539397053637271E-002;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,2,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 0.73973803569795438;
-  rotation_matrix[TableIndices<2>(0,1)] = -0.58084801380447959;
-  rotation_matrix[TableIndices<2>(0,2)] = -0.35134329241205425;
-  rotation_matrix[TableIndices<2>(1,0)] = 0.30883050284698427;
-  rotation_matrix[TableIndices<2>(1,1)] = -0.17349072757172229;
-  rotation_matrix[TableIndices<2>(1,2)] = 0.94047567596335968;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.60686583881969203;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.79564553570809793;
-  rotation_matrix[TableIndices<2>(2,2)] = 5.0387432541084881E-002;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,3,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = 4.2730545437086563E-002;
-  rotation_matrix[TableIndices<2>(0,1)] = 0.99790446393350407;
-  rotation_matrix[TableIndices<2>(0,2)] = 4.9677348699965519E-002;
-  rotation_matrix[TableIndices<2>(1,0)] = 0.24607319829629554;
-  rotation_matrix[TableIndices<2>(1,1)] = 3.7594987859276820E-002;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.97243353311600111;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.97326576151708344;
-  rotation_matrix[TableIndices<2>(2,1)] = 5.2990062123162360E-002;
-  rotation_matrix[TableIndices<2>(2,2)] = -0.24420040893728351;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,4,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = -0.92112012021624434;
-  rotation_matrix[TableIndices<2>(0,1)] = 0.17590913101287936;
-  rotation_matrix[TableIndices<2>(0,2)] = 0.34726602737040008;
-  rotation_matrix[TableIndices<2>(1,0)] = -0.27292179963530816;
-  rotation_matrix[TableIndices<2>(1,1)] = -0.92793421776529450;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.25387354780599874;
-  rotation_matrix[TableIndices<2>(2,0)] = 0.27758135269283285;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.32862450412044819;
-  rotation_matrix[TableIndices<2>(2,2)] = 0.90274831467569783;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,5,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = -4.6028553384029648E-002;
-  rotation_matrix[TableIndices<2>(0,1)] = -0.82828827663204008;
-  rotation_matrix[TableIndices<2>(0,2)] = -0.56150509327989218;
-  rotation_matrix[TableIndices<2>(1,0)] = -0.62780239844730912;
-  rotation_matrix[TableIndices<2>(1,1)] = -0.41264414122407550;
-  rotation_matrix[TableIndices<2>(1,2)] = 0.66416683570654200;
-  rotation_matrix[TableIndices<2>(2,0)] = -0.78150657001547463;
-  rotation_matrix[TableIndices<2>(2,1)] = 0.37975977805647526;
-  rotation_matrix[TableIndices<2>(2,2)] = -0.50060220610535922;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,6,rotation_matrix);
-
-  rotation_matrix[TableIndices<2>(0,0)] = -0.69974343277254114;
-  rotation_matrix[TableIndices<2>(0,1)] = -0.60514581197791628;
-  rotation_matrix[TableIndices<2>(0,2)] = 0.38074455421574593;
-  rotation_matrix[TableIndices<2>(1,0)] = 0.27181144918830025;
-  rotation_matrix[TableIndices<2>(1,1)] = -0.71756260285634454;
-  rotation_matrix[TableIndices<2>(1,2)] = -0.64160793166977359;
-  rotation_matrix[TableIndices<2>(2,0)] = 0.66130789657394939;
-  rotation_matrix[TableIndices<2>(2,1)] = -0.34496383827187421;
-  rotation_matrix[TableIndices<2>(2,2)] = 0.66656470768691123;
-  cpo.set_rotation_matrix_grains(cpo_data_position,data_cpo,1,7,rotation_matrix);
-
-
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,0,2.4802805652404735E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,1,2.4917064186342413E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,2,2.4790722064907112E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,3,2.4932751194567736E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,4,2.4896744967217745E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,5,0.79902139535472505);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,6,2.4861121542485400E-002);
-  cpo.set_volume_fractions_grains(cpo_data_position,data_cpo,1,7,5.1777395037349808E-002);
-
-  reference_elastic_tensor[0][0] = 282.99195951271281;
-  reference_elastic_tensor[0][1] = 74.161110997372660;
-  reference_elastic_tensor[0][2] = 69.528000044099443;
-  reference_elastic_tensor[0][3] = 0.85449958913948032;
-  reference_elastic_tensor[0][4] = 0.15156631865980030;
-  reference_elastic_tensor[0][5] = -10.295196344728696;
-  reference_elastic_tensor[1][0] = 74.161110997372674;
-  reference_elastic_tensor[1][1] = 223.44404040361212;
-  reference_elastic_tensor[1][2] = 70.938305212304968;
-  reference_elastic_tensor[1][3] = 1.4935368335052783;
-  reference_elastic_tensor[1][4] = -1.5555954844298270;
-  reference_elastic_tensor[1][5] = -3.5461136157235025;
-  reference_elastic_tensor[2][0] = 69.528000044099443;
-  reference_elastic_tensor[2][1] = 70.938305212304940;
-  reference_elastic_tensor[2][2] = 208.89404139751849;
-  reference_elastic_tensor[2][3] = 0.48656291118743428;
-  reference_elastic_tensor[2][4] = 0.49424401802786699;
-  reference_elastic_tensor[2][5] = -0.15651560991351129;
-  reference_elastic_tensor[3][0] = 0.85449958913948365;
-  reference_elastic_tensor[3][1] = 1.4935368335052732;
-  reference_elastic_tensor[3][2] = 0.48656291118742612;
-  reference_elastic_tensor[3][3] = 71.502776245041289;
-  reference_elastic_tensor[3][4] = -2.3939425644793477;
-  reference_elastic_tensor[3][5] = 0.62714033620769472;
-  reference_elastic_tensor[4][0] = 0.15156631865980935;
-  reference_elastic_tensor[4][1] = -1.5555954844298292;
-  reference_elastic_tensor[4][2] = 0.49424401802786488;
-  reference_elastic_tensor[4][3] = -2.3939425644793459;
-  reference_elastic_tensor[4][4] = 78.565442407530099;
-  reference_elastic_tensor[4][5] = -0.69890743507815323;
-  reference_elastic_tensor[5][0] = -10.295196344728710;
-  reference_elastic_tensor[5][1] = -3.5461136157235131;
-  reference_elastic_tensor[5][2] = -0.15651560991350758;
-  reference_elastic_tensor[5][3] = 0.62714033620769460;
-  reference_elastic_tensor[5][4] = -0.69890743507815523;
-  reference_elastic_tensor[5][5] = 80.599981331604567;
-
-
-  cpo.set_volume_fraction_mineral(cpo_data_position,data_cpo,0,0.7);
-  cpo.set_volume_fraction_mineral(cpo_data_position,data_cpo,1,0.3);
-
-  cpo.set_deformation_type(cpo_data_position,data_cpo,0,aspect::Particle::Property::DeformationType::olivine_a_fabric);
-  cpo.set_deformation_type(cpo_data_position,data_cpo,1,aspect::Particle::Property::DeformationType::enstatite);
-
-  computed_elastic_tensor = cpo_elastic_tensor.voigt_average_elastic_tensor(cpo,
-                                                                            cpo_data_position,
-                                                                            data_cpo);
-
-
-  for (size_t i = 0; i < 6; i++)
-    {
-      for (size_t j = 0; j < 6; j++)
-        {
-          CHECK(computed_elastic_tensor[i][j] == Approx(reference_elastic_tensor[i][j]));
-        }
-    }
-
-  // test store and load functions
-  // the first and last element should not be changed
-  // by these functions.
-  std::vector<double> array_ref = {0.0,
-                                   1.,2.,3.,4.,5,6,
-                                   7.,8.,9.,10,11,12,
-                                   13,14,15,16,17,18,
-                                   19,20,21,22,23,24,
-                                   25,26,27,28,29,30,
-                                   31,32,33,34,35,36,
-                                   37
-                                  };
-
-  std::vector<double> array = {0.0,
-                               1.,2.,3.,4.,5.,6.,
-                               7.,8.,9.,10,11,12,
-                               13,14,15,16,17,18,
-                               19,20,21,22,23,24,
-                               25,26,27,28,29,30,
-                               31,32,33,34,35,36,
-                               37
-                              };
-
-  // There used to be 36 unique entries, but now because we are using the
-  // symmetric tensor, there are only 21 unique entries.
-  std::vector<double> array_plus_100 = {0.0,
-                                        101.,102.,103.,104.,105.,106.,
-                                        107.,108.,109.,110.,111.,112.,
-                                        113.,114.,115.,116.,117.,118.,
-                                        119.,120.,121.,22.,23.,24.,
-                                        25.,26.,27.,28.,29.,30.,
-                                        31.,32.,33.,34.,35.,36.,
-                                        37.
-                                       };
-
-  cpo_data_position = 1;
-  dealii::ArrayView<double> data(&array[0],38);
-  dealii::SymmetricTensor<2,6> tensor = cpo_elastic_tensor.get_elastic_tensor(cpo_data_position,data);
-
-  for (unsigned int i = 0; i < dealii::SymmetricTensor<2,6>::n_independent_components ; ++i)
-    {
-      CHECK(data[cpo_data_position + i] == tensor[dealii::SymmetricTensor<2,6>::unrolled_to_component_indices(i)]);
-    }
-
-  cpo_elastic_tensor.set_elastic_tensor(cpo_data_position,data,tensor);
-
-  for (unsigned int i = 0; i < array.size() ; ++i)
-    CHECK(data[i] == array_ref[i]);
-
-  for (unsigned int i = 0; i < dealii::SymmetricTensor<2,6>::n_independent_components ; ++i)
-    {
-      tensor[dealii::SymmetricTensor<2,6>::unrolled_to_component_indices(i)] += 100;
-    }
-
-  cpo_elastic_tensor.set_elastic_tensor(cpo_data_position,data,tensor);
-
-  for (unsigned int i = 0; i < array.size() ; ++i)
-    CHECK(data[i] == array_plus_100[i]);
-
-  tensor = cpo_elastic_tensor.get_elastic_tensor(cpo_data_position,data);
-
-  for (unsigned int i = 0; i < dealii::SymmetricTensor<2,6>::n_independent_components ; ++i)
-    {
-      CHECK(data[cpo_data_position + i] == tensor[dealii::SymmetricTensor<2,6>::unrolled_to_component_indices(i)]);
-    }
-
-  for (unsigned int i = 0; i < dealii::SymmetricTensor<2,6>::n_independent_components ; ++i)
-    {
-      CHECK(array_plus_100[cpo_data_position + i] == tensor[dealii::SymmetricTensor<2,6>::unrolled_to_component_indices(i)]);
-    }
-}
-
-
-
-
-TEST_CASE("LPO elastic tensor decomposition")
-{
-  using namespace dealii;
-  using namespace aspect::Particle::Property;
-  using namespace aspect::Particle::Property::Utilities;
-  {
-    auto elastic_composition_class = ElasticTensorDecomposition<3>();
-
-    // the matrix from Browaeys and Chevrot, 2004, Geophys. J. Int. (doi: 10.1111/j.1365-246X.2004.02415.x)
-    // Note that the computed norms are not in the papers, but are an extra check.
-    SymmetricTensor<2,6> full_elastic_matrix;
-    full_elastic_matrix[0][0] = 192;
-    full_elastic_matrix[0][1] = 66;
-    full_elastic_matrix[0][2] = 60;
-    full_elastic_matrix[1][1] = 160;
-    full_elastic_matrix[1][2] = 56;
-    full_elastic_matrix[2][2] = 272;
-    full_elastic_matrix[3][3] = 60;
-    full_elastic_matrix[4][4] = 62;
-    full_elastic_matrix[5][5] = 49;
-
-    SymmetricTensor<2,6> reference_isotropic_matrix;
-    reference_isotropic_matrix[0][0] = 194.7;
-    reference_isotropic_matrix[0][1] = 67.3;
-    reference_isotropic_matrix[0][2] = 67.3;
-    reference_isotropic_matrix[1][1] = 194.7;
-    reference_isotropic_matrix[1][2] = 67.3;
-    reference_isotropic_matrix[2][2] = 194.7;
-    reference_isotropic_matrix[3][3] = 63.7;
-    reference_isotropic_matrix[4][4] = 63.7;
-    reference_isotropic_matrix[5][5] = 63.7;
-
-    SymmetricTensor<2,6> reference_hex_matrix;
-    reference_hex_matrix[0][0] = -21.7;
-    reference_hex_matrix[1][1] = -21.7;
-    reference_hex_matrix[2][2] = 77.3;
-    reference_hex_matrix[1][2] = -9.3;
-    reference_hex_matrix[0][2] = -9.3;
-    reference_hex_matrix[0][1] = 1.7;
-    reference_hex_matrix[3][3] = -2.7;
-    reference_hex_matrix[4][4] = -2.7;
-    reference_hex_matrix[5][5] = -11.7;
-
-    SymmetricTensor<2,6> reference_T_matrix;
-    reference_T_matrix[0][0] = 3;
-    reference_T_matrix[1][1] = 3;
-    reference_T_matrix[0][1] = -3;
-    reference_T_matrix[5][5] = -3;
-
-    SymmetricTensor<2,6> reference_O_matrix;
-    reference_O_matrix[0][0] = 16;
-    reference_O_matrix[1][1] = -16;
-    reference_O_matrix[1][2] = -2;
-    reference_O_matrix[0][2] = 2;
-    reference_O_matrix[3][3] = -1;
-    reference_O_matrix[4][4] = 1;
-
-    const Tensor<1,21> full_elastic_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(full_elastic_matrix);
-    const Tensor<1,21> reference_isotropic_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_isotropic_matrix);
-    const Tensor<1,21> reference_hex_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_hex_matrix);
-    const Tensor<1,21> reference_T_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_T_matrix);
-    const Tensor<1,21> reference_O_vector = aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_O_matrix);
-
-    // this matrix is already in the SCCSS, so no rotation needed, only the  projection.
-    CHECK(full_elastic_vector.norm_square() == Approx(198012.0));
-    const Tensor<1,21> mono_and_higher_vector = aspect::Particle::Property::Utilities::projection_matrix_triclinic_to_monoclinic * full_elastic_vector;
-    const Tensor<1,21> tric_vector = full_elastic_vector-mono_and_higher_vector;
-    for (size_t iii = 0; iii < 21; iii++)
-      {
-        CHECK(std::abs(tric_vector[iii]) < 1e-15);
-      }
-    CHECK(tric_vector.norm_square() == Approx(0.0));
-
-    dealii::Tensor<1,9>  mono_and_higher_vector_croped;
-    mono_and_higher_vector_croped[0] = mono_and_higher_vector[0];
-    mono_and_higher_vector_croped[1] = mono_and_higher_vector[1];
-    mono_and_higher_vector_croped[2] = mono_and_higher_vector[2];
-    mono_and_higher_vector_croped[3] = mono_and_higher_vector[3];
-    mono_and_higher_vector_croped[4] = mono_and_higher_vector[4];
-    mono_and_higher_vector_croped[5] = mono_and_higher_vector[5];
-    mono_and_higher_vector_croped[6] = mono_and_higher_vector[6];
-    mono_and_higher_vector_croped[7] = mono_and_higher_vector[7];
-    mono_and_higher_vector_croped[8] = mono_and_higher_vector[8];
-    const Tensor<1,9> ortho_and_higher_vector = aspect::Particle::Property::Utilities::projection_matrix_monoclinic_to_orthorhombic*mono_and_higher_vector_croped;
-    const Tensor<1,9> mono_vector = mono_and_higher_vector_croped-ortho_and_higher_vector;
-    for (size_t iii = 0; iii < 9; iii++)
-      {
-        CHECK(std::abs(mono_vector[iii]) < 1e-15);
-      }
-    CHECK(mono_vector.norm_square() == Approx(0.0));
-
-    const Tensor<1,9> tetra_and_higher_vector = aspect::Particle::Property::Utilities::projection_matrix_orthorhombic_to_tetragonal*ortho_and_higher_vector;
-    const Tensor<1,9> ortho_vector = ortho_and_higher_vector-tetra_and_higher_vector;
-    for (size_t iii = 0; iii < 9; iii++)
-      {
-        CHECK(ortho_vector[iii] == Approx(reference_O_vector[iii]));
-      }
-    CHECK(ortho_vector.norm_square() == Approx(536.0));
-
-    const Tensor<1,9> hexa_and_higher_vector = aspect::Particle::Property::Utilities::projection_matrix_tetragonal_to_hexagonal*tetra_and_higher_vector;
-    const Tensor<1,9> tetra_vector = tetra_and_higher_vector-hexa_and_higher_vector;
-    for (size_t iii = 0; iii < 9; iii++)
-      {
-        CHECK(tetra_vector[iii] == Approx(reference_T_vector[iii]));
-      }
-    CHECK(tetra_vector.norm_square() == Approx(72.0));
-
-    const Tensor<1,9> iso_vector = aspect::Particle::Property::Utilities::projection_matrix_hexagonal_to_isotropic*hexa_and_higher_vector;
-    for (size_t iii = 0; iii < 9; iii++)
-      {
-        // something weird is going on with the approx, somehow without a very large
-        // epsilon it thinks for example that "194.6666666667 == Approx( 194.7 )" is false.
-        CHECK(iso_vector[iii] == Approx(reference_isotropic_vector[iii]).epsilon(1e-3));
-      }
-    CHECK(iso_vector.norm_square() == Approx(189529.3333333334));
-
-    const Tensor<1,9> hexa_vector = hexa_and_higher_vector-iso_vector;
-    for (size_t iii = 0; iii < 9; iii++)
-      {
-        // same as above.
-        CHECK(hexa_vector[iii] == Approx(reference_hex_vector[iii]).epsilon(2.5e-2));
-      }
-    CHECK(hexa_vector.norm_square() == Approx(7874.6666666667));
-
-  }
-
-  {
-    // now compute the distribution in a elastic tensor which is not in SCCS.
-    // We will use the result (with the results of the steps in between) from
-    // Cowin and Mehrabadi, 1985, Mech. appl. Math.
-    SymmetricTensor<2,6> full_elastic_matrix;
-    full_elastic_matrix[0][0] = 1769.50;
-    full_elastic_matrix[0][1] = 873.50;
-    full_elastic_matrix[0][2] = 838.22;
-    full_elastic_matrix[0][3] = -17.68;
-    full_elastic_matrix[0][4] = -110.32;
-    full_elastic_matrix[0][5] = 144.92;
-    full_elastic_matrix[1][0] = 873.50;
-    full_elastic_matrix[1][1] = 1846.64;
-    full_elastic_matrix[1][2] = 836.66;
-    full_elastic_matrix[1][3] = -37.60;
-    full_elastic_matrix[1][4] = -32.32;
-    full_elastic_matrix[1][5] = 153.80;
-    full_elastic_matrix[2][0] = 838.22;
-    full_elastic_matrix[2][1] = 836.66;
-    full_elastic_matrix[2][2] = 1603.28;
-    full_elastic_matrix[2][3] = -29.68;
-    full_elastic_matrix[2][4] = -93.52;
-    full_elastic_matrix[2][5] = 22.40;
-    full_elastic_matrix[3][0] = -17.68;
-    full_elastic_matrix[3][1] = -37.60;
-    full_elastic_matrix[3][2] = -29.68;
-    full_elastic_matrix[3][3] = 438.77;
-    full_elastic_matrix[3][4] = 57.68;
-    full_elastic_matrix[3][5] = -50.50;
-    full_elastic_matrix[4][0] = -110.32;
-    full_elastic_matrix[4][1] = -32.32;
-    full_elastic_matrix[4][2] = -93.52;
-    full_elastic_matrix[4][3] = 57.68;
-    full_elastic_matrix[4][4] = 439.79;
-    full_elastic_matrix[4][5] = -34.78;
-    full_elastic_matrix[5][0] = 144.92;
-    full_elastic_matrix[5][1] = 153.80;
-    full_elastic_matrix[5][2] = 22.40;
-    full_elastic_matrix[5][3] = -50.50;
-    full_elastic_matrix[5][4] = -34.78;
-    full_elastic_matrix[5][5] = 501.80;
-    full_elastic_matrix /= 81.;
-
-    SymmetricTensor<2,3> reference_dilatation_matrix;
-    reference_dilatation_matrix[0][0] = 386.80;
-    reference_dilatation_matrix[0][1] = 35.68;
-    reference_dilatation_matrix[0][2] = -26.24;
-    //reference_dilatation_matrix[1][0] = ;
-    reference_dilatation_matrix[1][1] = 395.20;
-    reference_dilatation_matrix[1][2] = -9.44;
-    //reference_dilatation_matrix[2][0] = ;
-    //reference_dilatation_matrix[2][1] = ;
-    reference_dilatation_matrix[2][2] = 364.24;
-    reference_dilatation_matrix /= 9.;
-
-    SymmetricTensor<2,3> reference_voigt_matrix;
-    reference_voigt_matrix[0][0] = 33.47;
-    reference_voigt_matrix[0][1] = 4.4;
-    reference_voigt_matrix[0][2] = -3.14;
-    //reference_voigt_matrix[1][0] = ;
-    reference_voigt_matrix[1][1] = 34.41;
-    reference_voigt_matrix[1][2] = -1.26;
-    //reference_voigt_matrix[2][0] = ;
-    //reference_voigt_matrix[2][1] = ;
-    reference_voigt_matrix[2][2] = 30.64;
-
-    // Q in equation 2.17, but reordered from
-    // largest to smallest eigenvalue.
-    Tensor<2,3> reference_SCCS;
-    reference_SCCS[2][0] = 2./3.;
-    reference_SCCS[2][1] = -1./3.;
-    reference_SCCS[2][2] = 2./3.;
-    reference_SCCS[1][0] = 1./3.;
-    reference_SCCS[1][1] = -2./3.;
-    reference_SCCS[1][2] = -2./3.;
-    reference_SCCS[0][0] = 2./3.;
-    reference_SCCS[0][1] = 2./3.;
-    reference_SCCS[0][2] = -1./3.;
-
-    SymmetricTensor<2,6> reference_rotated_elastic_matrix;
-    reference_rotated_elastic_matrix[0][0] = 18;
-    reference_rotated_elastic_matrix[0][1] = 9.98;
-    reference_rotated_elastic_matrix[0][2] = 10.1;
-    //reference_rotated_elastic_matrix[1][0] = ;
-    reference_rotated_elastic_matrix[1][1] = 20.2;
-    reference_rotated_elastic_matrix[1][2] = 10.07;
-    //reference_rotated_elastic_matrix[2][0] = ;
-    //reference_rotated_elastic_matrix[2][1] = ;
-    reference_rotated_elastic_matrix[2][2] = 27.6;
-    reference_rotated_elastic_matrix[3][3] = 6.23;
-    reference_rotated_elastic_matrix[4][4] = 5.61;
-    reference_rotated_elastic_matrix[5][5] = 4.52;
-
-    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        for (size_t jjj = 0; jjj < 3; jjj++)
-          {
-            CHECK(reference_dilatation_matrix[iii][jjj] == Approx(dilatation_stiffness_tensor_full[iii][jjj]));
-          }
-      }
-
-    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        for (size_t jjj = 0; jjj < 3; jjj++)
-          {
-            CHECK(reference_voigt_matrix[iii][jjj] == Approx(voigt_stiffness_tensor_full[iii][jjj]));
-          }
-      }
-    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-    // chose the permutation which fits the solution given in the paper.
-    // This is not a even permutation.
-    std::array<unsigned int, 3> permutation = {{2,1,0}};
-    Tensor<2,3> permutated_SCCS;
-    for (size_t j = 0; j < 3; j++)
-      {
-        permutated_SCCS[j] = unpermutated_SCCS[permutation[j]];
-      }
-    SymmetricTensor<2,6> rotated_elastic_matrix = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(permutated_SCCS,full_elastic_matrix);
-
-    for (size_t iii = 0; iii < 6; iii++)
-      {
-        for (size_t jjj = 0; jjj < 6; jjj++)
-          {
-            CHECK(reference_rotated_elastic_matrix[iii][jjj] == Approx(rotated_elastic_matrix[iii][jjj]).margin(1e-4).epsilon(7.5e-2));
-          }
-      }
-  }
-  {
-    // This is testing some other elastic matrices of which the properties can
-    // be resonaly predicted (for example, mostly hexagonal) and some coverage
-    // testing: Case 1.
-
-    SymmetricTensor<2,6> full_elastic_matrix;
-    full_elastic_matrix[0][0] = 192;
-    full_elastic_matrix[0][1] = 66;
-    full_elastic_matrix[0][2] = 56;
-    full_elastic_matrix[1][1] = 192;
-    full_elastic_matrix[1][2] = 56;
-    full_elastic_matrix[2][2] = 272;
-    full_elastic_matrix[3][3] = 60;
-    full_elastic_matrix[4][4] = 60;
-    full_elastic_matrix[5][5] = 0.5*(full_elastic_matrix[0][0] + full_elastic_matrix[0][1]);
-
-    std::array<std::array<double,3>,7 > reference_norms;
-    reference_norms[0] = {{0,0,0}}; // no triclinic
-    reference_norms[1] = {{0,0,0}}; // no monoclinic
-    reference_norms[2] = {{12822.0,0,12822.0}}; // orthorhomic dependent on direction (remember, this is basically just one grain)
-    reference_norms[3] = {{1568.0,8712.0,1568.0}}; // tetragonal could be present
-    reference_norms[4] = {{2759.3333333333,8437.3333333333,2759.3333333333}}; // hexagonal is expected
-    reference_norms[5] = {{247182.6666666667,247182.6666666667,247182.6666666667}}; // isotropic should be the same for every permutation
-    reference_norms[6] = {{264332.0,264332.0,264332.0}}; // total should be the same for every direction
-
-    // It is already in a SCCS frame, so they should be
-    // unit vectors. The order is irrelevant.
-    Tensor<2,3> reference_unpermutated_SCCS;
-    reference_unpermutated_SCCS[0][0] = 0;
-    reference_unpermutated_SCCS[0][1] = 0;
-    reference_unpermutated_SCCS[0][2] = 1;
-    reference_unpermutated_SCCS[1][0] = 1;
-    reference_unpermutated_SCCS[1][1] = 0;
-    reference_unpermutated_SCCS[1][2] = 0;
-    reference_unpermutated_SCCS[2][0] = 0;
-    reference_unpermutated_SCCS[2][1] = 1;
-    reference_unpermutated_SCCS[2][2] = 0;
-
-    // Permutation 2 has the highest norm, so reference_unpermutated_SCCS
-    // is permutated by {1,2,0};
-    Tensor<2,3> reference_hexa_permutated_SCCS;
-    reference_hexa_permutated_SCCS[0][0] = 1;
-    reference_hexa_permutated_SCCS[0][1] = 0;
-    reference_hexa_permutated_SCCS[0][2] = 0;
-    reference_hexa_permutated_SCCS[1][0] = 0;
-    reference_hexa_permutated_SCCS[1][1] = 1;
-    reference_hexa_permutated_SCCS[1][2] = 0;
-    reference_hexa_permutated_SCCS[2][0] = 0;
-    reference_hexa_permutated_SCCS[2][1] = 0;
-    reference_hexa_permutated_SCCS[2][2] = 1;
-
-    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
-    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
-    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
-    std::array<double,3> totals = {{0,0,0}};
-    for (size_t iii = 0; iii < 7; iii++)
-      {
-        // also check that the total is equal to the full norm.
-
-        for (size_t jjj = 0; jjj < 3; jjj++)
-          {
-            INFO("i:j = " << iii << ":" << jjj );
-            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
-            if (iii < 6)
-              {
-                totals[jjj] += norms[iii][jjj];
-              }
-          }
-      }
-    for (size_t jjj = 0; jjj < 3; jjj++)
-      {
-        INFO("j = " << jjj );
-        CHECK(totals[jjj] == Approx(norms[6][jjj]));
-      }
-
-    // also check that all the isotropic and totals are the same
-    for (size_t iii = 1; iii < 3; iii++)
-      {
-        CHECK(norms[5][0] == Approx(norms[5][iii]));
-        CHECK(norms[6][0] == Approx(norms[6][iii]));
-      }
-
-    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
-    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
-    Tensor<2,3> hexa_permutated_SCCS;
-    for (size_t index = 0; index < 3; index++)
-      {
-        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
-      }
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-  }
-  {
-    // This is testing some other elastic matrices of which the properties can
-    // be resonaly predicted (for example, mostly hexagonal) and some coverage
-    // testing: Case 2: a more complicated matrix.
-
-    SymmetricTensor<2,6> full_elastic_matrix;
-    full_elastic_matrix[0][0] = 225;
-    full_elastic_matrix[0][1] = 54;
-    full_elastic_matrix[0][2] = 72;
-    full_elastic_matrix[1][1] = 214;
-    full_elastic_matrix[1][2] = 53;
-    full_elastic_matrix[2][2] = 178;
-    full_elastic_matrix[3][3] = 78;
-    full_elastic_matrix[4][4] = 82;
-    full_elastic_matrix[5][5] = 76;
-
-    std::array<std::array<double,3>,7 > reference_norms;
-    reference_norms[0] = {{0,0,0}}; // no triclinic
-    reference_norms[1] = {{0,0,0}}; // no monoclinic
-    reference_norms[2] = {{453.5,1044.0,1113.5}}; // orthorhomic dependent on direction
-    reference_norms[3] = {{91.125,84.5,595.125}}; // tetragonal could be present
-    reference_norms[4] = {{1350.175,766.3,186.175}}; // hexagonal is expected
-    reference_norms[5] = {{222364.2,222364.2,222364.2}}; // isotropic should be the same for every permutation
-    reference_norms[6] = {{224259.0,224259.0,224259.0}}; // total should be the same for every direction
-
-    // It is already in a SCCS frame, so they should be
-    // unit vectors. The order is irrelevant.
-    Tensor<2,3> reference_unpermutated_SCCS;
-    reference_unpermutated_SCCS[0][0] = 1;
-    reference_unpermutated_SCCS[0][1] = 0;
-    reference_unpermutated_SCCS[0][2] = 0;
-    reference_unpermutated_SCCS[1][0] = 0;
-    reference_unpermutated_SCCS[1][1] = 1;
-    reference_unpermutated_SCCS[1][2] = 0;
-    reference_unpermutated_SCCS[2][0] = 0;
-    reference_unpermutated_SCCS[2][1] = 0;
-    reference_unpermutated_SCCS[2][2] = 1;
-
-    // Permutation 1 has the highest norm, so reference_unpermutated_SCCS
-    // is permutated by {0,1,2};
-    Tensor<2,3> reference_hexa_permutated_SCCS;
-    reference_hexa_permutated_SCCS[0][0] = 1;
-    reference_hexa_permutated_SCCS[0][1] = 0;
-    reference_hexa_permutated_SCCS[0][2] = 0;
-    reference_hexa_permutated_SCCS[1][0] = 0;
-    reference_hexa_permutated_SCCS[1][1] = 1;
-    reference_hexa_permutated_SCCS[1][2] = 0;
-    reference_hexa_permutated_SCCS[2][0] = 0;
-    reference_hexa_permutated_SCCS[2][1] = 0;
-    reference_hexa_permutated_SCCS[2][2] = 1;
-
-    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
-    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
-    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
-    std::array<double,3> totals = {{0,0,0}};
-    for (size_t iii = 0; iii < 7; iii++)
-      {
-        // also check that the total is equal to the full norm.
-
-        for (size_t jjj = 0; jjj < 3; jjj++)
-          {
-            INFO("i:j = " << iii << ":" << jjj );
-            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
-            if (iii < 6)
-              {
-                totals[jjj] += norms[iii][jjj];
-              }
-          }
-      }
-    for (size_t jjj = 0; jjj < 3; jjj++)
-      {
-        INFO("j = " << jjj );
-        CHECK(totals[jjj] == Approx(norms[6][jjj]));
-      }
-
-    // also check that all the isotropic and totals are the same
-    for (size_t iii = 1; iii < 3; iii++)
-      {
-        CHECK(norms[5][0] == Approx(norms[5][iii]));
-        CHECK(norms[6][0] == Approx(norms[6][iii]));
-      }
-
-    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
-    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
-    Tensor<2,3> hexa_permutated_SCCS;
-    for (size_t index = 0; index < 3; index++)
-      {
-        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
-      }
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-  }
-
-  {
-    // This is testing some other elastic matrices of which the properties can
-    // be resonaly predicted (for example, mostly hexagonal) and some coverage
-    // testing: Case 3: olivine from experiments as used in D-Rex.
-
-    SymmetricTensor<2,6> full_elastic_matrix;
-    full_elastic_matrix[0][0] = 320.71;
-    full_elastic_matrix[0][1] = 69.84;
-    full_elastic_matrix[0][2] = 71.22;
-    full_elastic_matrix[1][1] = 197.25;
-    full_elastic_matrix[1][2] = 74.8;
-    full_elastic_matrix[2][2] = 234.32;
-    full_elastic_matrix[3][3] = 63.77;
-    full_elastic_matrix[4][4] = 77.67;
-    full_elastic_matrix[5][5] = 78.36;
-
-    std::array<std::array<double,3>,7 > reference_norms;
-    reference_norms[0] = {{0,0,0}}; // no triclinic
-    reference_norms[1] = {{0,0,0}}; // no monoclinic
-    reference_norms[2] = {{4181.95385,689.94905,8020.4222}}; // orthorhomic dependent on direction
-    reference_norms[3] = {{1298.2060125,90.3840125,525.5282}}; // tetragonal could be present
-    reference_norms[4] = {{4364.6051908333,9064.4319908333,1298.8146533333}}; // hexagonal is expected
-    reference_norms[5] = {{282871.5975466666,282871.5975466666,282871.5975466666}}; // isotropic should be the same for every permutation
-    reference_norms[6] = {{292716.3626,292716.3626,292716.3626}}; // total should be the same for every direction
-
-    // It is already in a SCCS frame, so they should be
-    // unit vectors. The order is irrelevant.
-    Tensor<2,3> reference_unpermutated_SCCS;
-    reference_unpermutated_SCCS[0][0] = 1;
-    reference_unpermutated_SCCS[0][1] = 0;
-    reference_unpermutated_SCCS[0][2] = 0;
-    reference_unpermutated_SCCS[1][0] = 0;
-    reference_unpermutated_SCCS[1][1] = 0;
-    reference_unpermutated_SCCS[1][2] = 1;
-    reference_unpermutated_SCCS[2][0] = 0;
-    reference_unpermutated_SCCS[2][1] = 1;
-    reference_unpermutated_SCCS[2][2] = 0;
-
-    // Permutation 2 has the highest norm, so reference_unpermutated_SCCS
-    // is permutated by {1,2,0};
-    Tensor<2,3> reference_hexa_permutated_SCCS;
-    reference_hexa_permutated_SCCS[0][0] = 0;
-    reference_hexa_permutated_SCCS[0][1] = 0;
-    reference_hexa_permutated_SCCS[0][2] = 1;
-    reference_hexa_permutated_SCCS[1][0] = 0;
-    reference_hexa_permutated_SCCS[1][1] = 1;
-    reference_hexa_permutated_SCCS[1][2] = 0;
-    reference_hexa_permutated_SCCS[2][0] = 1;
-    reference_hexa_permutated_SCCS[2][1] = 0;
-    reference_hexa_permutated_SCCS[2][2] = 0;
-
-    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
-    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
-    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
-    std::array<double,3> totals = {{0,0,0}};
-    for (size_t iii = 0; iii < 7; iii++)
-      {
-        // also check that the total is equal to the full norm.
-
-        for (size_t jjj = 0; jjj < 3; jjj++)
-          {
-            INFO("i:j = " << iii << ":" << jjj );
-            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
-            if (iii < 6)
-              {
-                totals[jjj] += norms[iii][jjj];
-              }
-          }
-      }
-    for (size_t jjj = 0; jjj < 3; jjj++)
-      {
-        INFO("j = " << jjj );
-        CHECK(totals[jjj] == Approx(norms[6][jjj]));
-      }
-
-    // also check that all the isotropic and totals are the same
-    for (size_t iii = 1; iii < 3; iii++)
-      {
-        CHECK(norms[5][0] == Approx(norms[5][iii]));
-        CHECK(norms[6][0] == Approx(norms[6][iii]));
-      }
-
-    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
-    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
-    Tensor<2,3> hexa_permutated_SCCS;
-    for (size_t index = 0; index < 3; index++)
-      {
-        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
-      }
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-  }
-
-  {
-    // This is testing some other elastic matrices of which the properties can
-    // be resonaly predicted (for example, mostly hexagonal) and some coverage
-    // testing: Case 4: enstatite from experiments as used in D-Rex.
-
-    SymmetricTensor<2,6> full_elastic_matrix;
-    full_elastic_matrix[0][0] = 236.9;
-    full_elastic_matrix[0][1] = 79.6;
-    full_elastic_matrix[0][2] = 63.2;
-    full_elastic_matrix[1][1] = 180.5;
-    full_elastic_matrix[1][2] = 56.8;
-    full_elastic_matrix[2][2] = 230.4;
-    full_elastic_matrix[3][3] = 84.3;
-    full_elastic_matrix[4][4] = 79.4;
-    full_elastic_matrix[5][5] = 80.1;
-
-    std::array<std::array<double,3>,7 > reference_norms;
-    reference_norms[0] = {{0,0,0}}; // no triclinic
-    reference_norms[1] = {{0,0,0}}; // no monoclinic
-    reference_norms[2] = {{576.245,1514.945,1679.46}}; // orthorhomic dependent on direction
-    reference_norms[3] = {{67.86125,199.00125,483.605}}; // tetragonal could be present
-    reference_norms[4] = {{2076.64175,1006.80175,557.683}}; // hexagonal is expected
-    reference_norms[5] = {{245485.992,245485.992,245485.992}}; // isotropic should be the same for every permutation
-    reference_norms[6] = {{248206.74,248206.74,248206.74}}; // total should be the same for every direction
-
-    // It is already in a SCCS frame, so they should be
-    // unit vectors. The order is irrelevant.
-    Tensor<2,3> reference_unpermutated_SCCS;
-    reference_unpermutated_SCCS[0][0] = 1;
-    reference_unpermutated_SCCS[0][1] = 0;
-    reference_unpermutated_SCCS[0][2] = 0;
-    reference_unpermutated_SCCS[1][0] = 0;
-    reference_unpermutated_SCCS[1][1] = 0;
-    reference_unpermutated_SCCS[1][2] = 1;
-    reference_unpermutated_SCCS[2][0] = 0;
-    reference_unpermutated_SCCS[2][1] = 1;
-    reference_unpermutated_SCCS[2][2] = 0;
-
-    // Permutation 1 has the highest norm, so reference_unpermutated_SCCS
-    // is permutated by {0,1,2};
-    Tensor<2,3> reference_hexa_permutated_SCCS;
-    reference_hexa_permutated_SCCS[0][0] = 1;
-    reference_hexa_permutated_SCCS[0][1] = 0;
-    reference_hexa_permutated_SCCS[0][2] = 0;
-    reference_hexa_permutated_SCCS[1][0] = 0;
-    reference_hexa_permutated_SCCS[1][1] = 0;
-    reference_hexa_permutated_SCCS[1][2] = 1;
-    reference_hexa_permutated_SCCS[2][0] = 0;
-    reference_hexa_permutated_SCCS[2][1] = 1;
-    reference_hexa_permutated_SCCS[2][2] = 0;
-
-    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
-    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
-    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
-    std::array<double,3> totals = {{0,0,0}};
-    for (size_t iii = 0; iii < 7; iii++)
-      {
-        // also check that the total is equal to the full norm.
-
-        for (size_t jjj = 0; jjj < 3; jjj++)
-          {
-            INFO("i:j = " << iii << ":" << jjj );
-            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
-            if (iii < 6)
-              {
-                totals[jjj] += norms[iii][jjj];
-              }
-          }
-      }
-    for (size_t jjj = 0; jjj < 3; jjj++)
-      {
-        INFO("j = " << jjj );
-        CHECK(totals[jjj] == Approx(norms[6][jjj]));
-      }
-
-    // also check that all the isotropic and totals are the same
-    for (size_t iii = 1; iii < 3; iii++)
-      {
-        CHECK(norms[5][0] == Approx(norms[5][iii]));
-        CHECK(norms[6][0] == Approx(norms[6][iii]));
-      }
-
-
-    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
-    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
-    Tensor<2,3> hexa_permutated_SCCS;
-    for (size_t index = 0; index < 3; index++)
-      {
-        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
-      }
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-  }
-
-  {
-    // This is testing some other elastic matrices of which the properties can
-    // be resonaly predicted (for example, mostly hexagonal) and some coverage
-    // testing: Case 4: from http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php (Be).
-    // This one should have at least in one direction almost all the the anistropy be
-    // hexagonal anisotropy.
-
-    SymmetricTensor<2,6> full_elastic_matrix;
-    full_elastic_matrix[0][0] = 192.3;
-    full_elastic_matrix[0][1] = 26.7;
-    full_elastic_matrix[0][2] = 14;
-    full_elastic_matrix[1][1] = full_elastic_matrix[0][0];
-    full_elastic_matrix[1][2] = full_elastic_matrix[0][2];
-    full_elastic_matrix[2][2] = 336.4;
-    full_elastic_matrix[3][3] = 162.5;
-    full_elastic_matrix[4][4] = full_elastic_matrix[3][3];
-    full_elastic_matrix[5][5] = 0.5*(full_elastic_matrix[0][0] + full_elastic_matrix[0][1]);
-
-    std::array<std::array<double,3>,7 > reference_norms;
-    reference_norms[0] = {{0,0,0}}; // no triclinic
-    reference_norms[1] = {{0,0,0}}; // no monoclinic
-    reference_norms[2] = {{16161.695,0.0,16161.695}}; // orthorhomic dependent on direction
-    reference_norms[3] = {{2786.31125,1425.78,2786.31125}}; // tetragonal could be present
-    reference_norms[4] = {{8079.22575,25601.452,8079.22575}}; // hexagonal is expected
-    reference_norms[5] = {{421517.088,421517.088,421517.088}}; // isotropic should be the same for every permutation
-    reference_norms[6] = {{448544.32,448544.32,448544.32}}; // total should be the same for every direction
-
-    // It is already in a SCCS frame, so they should be
-    // unit vectors. The order is irrelevant.
-    Tensor<2,3> reference_unpermutated_SCCS;
-    reference_unpermutated_SCCS[0][0] = 0;
-    reference_unpermutated_SCCS[0][1] = 0;
-    reference_unpermutated_SCCS[0][2] = 1;
-    reference_unpermutated_SCCS[1][0] = 1;
-    reference_unpermutated_SCCS[1][1] = 0;
-    reference_unpermutated_SCCS[1][2] = 0;
-    reference_unpermutated_SCCS[2][0] = 0;
-    reference_unpermutated_SCCS[2][1] = 1;
-    reference_unpermutated_SCCS[2][2] = 0;
-
-    // Permutation 2 has the highest norm, so reference_unpermutated_SCCS
-    // is permutated by {1,2,0};
-    Tensor<2,3> reference_hexa_permutated_SCCS;
-    reference_hexa_permutated_SCCS[0][0] = 1;
-    reference_hexa_permutated_SCCS[0][1] = 0;
-    reference_hexa_permutated_SCCS[0][2] = 0;
-    reference_hexa_permutated_SCCS[1][0] = 0;
-    reference_hexa_permutated_SCCS[1][1] = 1;
-    reference_hexa_permutated_SCCS[1][2] = 0;
-    reference_hexa_permutated_SCCS[2][0] = 0;
-    reference_hexa_permutated_SCCS[2][1] = 0;
-    reference_hexa_permutated_SCCS[2][2] = 1;
-
-    const SymmetricTensor<2,3> dilatation_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_dilatation_stiffness_tensor(full_elastic_matrix);
-    const SymmetricTensor<2,3> voigt_stiffness_tensor_full = aspect::Particle::Property::Utilities::compute_voigt_stiffness_tensor(full_elastic_matrix);
-    Tensor<2,3> unpermutated_SCCS = aspect::Particle::Property::Utilities::compute_unpermutated_SCCS(dilatation_stiffness_tensor_full, voigt_stiffness_tensor_full);
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("unpermutated_SCCS[" << iii << "] = " << unpermutated_SCCS[iii][0] << ":" << unpermutated_SCCS[iii][1] << ":" << unpermutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_unpermutated_SCCS[iii][0] == Approx(unpermutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][1] == Approx(unpermutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_unpermutated_SCCS[iii][2] == Approx(unpermutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_unpermutated_SCCS[iii][0] == Approx(-unpermutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][1] == Approx(-unpermutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_unpermutated_SCCS[iii][2] == Approx(-unpermutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-    std::array<std::array<double,3>,7 > norms = aspect::Particle::Property::Utilities::compute_elastic_tensor_SCCS_decompositions(unpermutated_SCCS, full_elastic_matrix);
-    std::array<double,3> totals = {{0,0,0}};
-    for (size_t iii = 0; iii < 7; iii++)
-      {
-        // also check that the total is equal to the full norm.
-
-        for (size_t jjj = 0; jjj < 3; jjj++)
-          {
-            INFO("i:j = " << iii << ":" << jjj );
-            CHECK(reference_norms[iii][jjj] == Approx(norms[iii][jjj]));
-            if (iii < 6)
-              {
-                totals[jjj] += norms[iii][jjj];
-              }
-          }
-      }
-    for (size_t jjj = 0; jjj < 3; jjj++)
-      {
-        INFO("j = " << jjj );
-        CHECK(totals[jjj] == Approx(norms[6][jjj]));
-      }
-
-    // also check that all the isotropic and totals are the same
-    for (size_t iii = 1; iii < 3; iii++)
-      {
-        CHECK(norms[5][0] == Approx(norms[5][iii]));
-        CHECK(norms[6][0] == Approx(norms[6][iii]));
-      }
-
-
-    const size_t max_hexagonal_element_index = std::max_element(norms[4].begin(),norms[4].end())-norms[4].begin();
-    std::array<unsigned int, 3> permutation = aspect::Particle::Property::Utilities::indexed_even_permutation(max_hexagonal_element_index);
-    Tensor<2,3> hexa_permutated_SCCS;
-    for (size_t index = 0; index < 3; index++)
-      {
-        hexa_permutated_SCCS[index] = unpermutated_SCCS[permutation[index]];
-      }
-    for (size_t iii = 0; iii < 3; iii++)
-      {
-        const double epsilon = 1e-3;
-        INFO("hexa_permutated_SCCS[" << iii << "] = " << hexa_permutated_SCCS[iii][0] << ":" << hexa_permutated_SCCS[iii][1] << ":" << hexa_permutated_SCCS[iii][2]);
-        // The direction of the eigenvectors is not important, but they do need to be consistent
-        CHECK((reference_hexa_permutated_SCCS[iii][0] == Approx(hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][1] == Approx(hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-               && reference_hexa_permutated_SCCS[iii][2] == Approx(hexa_permutated_SCCS[iii][2]).epsilon(epsilon)
-               || (reference_hexa_permutated_SCCS[iii][0] == Approx(-hexa_permutated_SCCS[iii][0]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][1] == Approx(-hexa_permutated_SCCS[iii][1]).epsilon(epsilon)
-                   && reference_hexa_permutated_SCCS[iii][2] == Approx(-hexa_permutated_SCCS[iii][2]).epsilon(epsilon))));
-      }
-  }
-}
diff --git a/unit_tests/first.cc.bak b/unit_tests/first.cc.bak
deleted file mode 100644
index c38c7b9c367..00000000000
--- a/unit_tests/first.cc.bak
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-#include <aspect/utilities.h>
-#include <aspect/citation_info.h>
-#include <deal.II/base/function_parser.h>
-
-TEST_CASE("floating point check example")
-{
-  // this would fail because of floating point arithmetic, but using Approx(f) will work:
-  //  REQUIRE(0.1*3.0 == 0.3);
-  REQUIRE(0.1*3.0 == Approx(0.3));
-}
-
-TEST_CASE("floating point std::vector checks")
-{
-  // here is how you can compare two std::vector<double>:
-  std::vector<double> computed = {0.1*3.0, 1.0};
-  std::vector<double> expected = {0.3, 1.0};
-
-  compare_vectors_approx(computed, expected);
-}
-
-TEST_CASE("Utilities::read_and_distribute_file_content")
-{
-  const std::string file_name = aspect::Utilities::expand_ASPECT_SOURCE_DIR("$ASPECT_SOURCE_DIR/VERSION");
-  const std::string content =
-    aspect::Utilities::read_and_distribute_file_content(file_name,
-                                                        MPI_COMM_WORLD);
-  REQUIRE(content.size()>0);
-
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::read_and_distribute_file_content("does-not-exist.cc",
-                                                        MPI_COMM_WORLD),
-    Contains("Could not open"));
-}
-
-TEST_CASE("function parser if() and division by zero")
-{
-  std::string variables = "x";
-  std::map<std::string,double> constants;
-
-  dealii::FunctionParser<1> fp(1);
-  fp.initialize(variables,
-                "if(x>0,1/x,-1)",
-                constants);
-  REQUIRE(fp.value(dealii::Point<1>(4.0)) == 0.25);
-  REQUIRE(fp.value(dealii::Point<1>(-5.0)) == -1.0);
-  // This will sadly trigger a floating point exception:
-  //REQUIRE(fp.value(dealii::Point<1>(0.0)) == -1.0);
-
-  fp.initialize(variables,
-                "(x>0) ? (1/x) : (-1)",
-                constants);
-  REQUIRE(fp.value(dealii::Point<1>(4.0)) == 0.25);
-  REQUIRE(fp.value(dealii::Point<1>(-5.0)) == -1.0);
-  REQUIRE(fp.value(dealii::Point<1>(0.0)) == -1.0);
-}
-
-TEST_CASE("citation test")
-{
-  using namespace aspect;
-  REQUIRE_THAT(CitationInfo::get_url_part(), StartsWith("citing.html?ver="));
-  CitationInfo::add("bla");
-  REQUIRE_THAT(CitationInfo::get_url_part(), StartsWith("citing.html?ver="));
-  REQUIRE_THAT(CitationInfo::get_url_part(), Contains("bla=1"));
-  REQUIRE_THAT(CitationInfo::get_url_part(), !Contains("blub"));
-  CitationInfo::add("blub");
-  REQUIRE_THAT(CitationInfo::get_url_part(), Contains("bla=1"));
-  REQUIRE_THAT(CitationInfo::get_url_part(), Contains("blub=1"));
-}
diff --git a/unit_tests/introspection.cc.bak b/unit_tests/introspection.cc.bak
deleted file mode 100644
index a74ea3834fc..00000000000
--- a/unit_tests/introspection.cc.bak
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-  Copyright (C) 2024 - 2024 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-
-#include <aspect/parameters.h>
-#include <aspect/simulator.h>
-#include <aspect/introspection.h>
-
-TEST_CASE("Introspection::basic")
-{
-  using namespace aspect;
-  dealii::ParameterHandler prm;
-  Simulator<2>::declare_parameters(prm);
-
-
-  prm.set("Output directory", "");
-
-  prm.enter_subsection("Compositional fields");
-  prm.set("Number of fields", "3");
-  prm.set("Names of fields", "a,b,c");
-  prm.leave_subsection();
-
-  Parameters<2> parameters(prm, MPI_COMM_WORLD);
-
-  const std::vector<VariableDeclaration<2>> variables = construct_default_variables (parameters);
-  Introspection<2> introspection (variables, parameters);
-
-  dealii::FESystem<2> fe(introspection.get_fes(), introspection.get_multiplicities());
-  CHECK(fe.get_name() == "FESystem<2>[FE_Q<2>(2)^2-FE_Q<2>(1)-FE_Q<2>(2)-FE_Q<2>(2)^3]");
-
-  CHECK(introspection.n_components == 7);
-  CHECK(introspection.n_compositional_fields == 3);
-  CHECK(introspection.n_blocks == 6);
-
-  CHECK(introspection.component_indices.velocities[0] == 0);
-  CHECK(introspection.component_indices.velocities[1] == 1);
-  CHECK(introspection.component_indices.pressure == 2);
-  CHECK(introspection.component_indices.temperature == 3);
-  CHECK(introspection.component_indices.compositional_fields[0] == 4);
-
-  CHECK(introspection.block_indices.velocities == 0);
-  CHECK(introspection.block_indices.pressure == 1);
-  CHECK(introspection.block_indices.temperature == 2);
-  CHECK(introspection.block_indices.compositional_fields.size() == 3);
-  CHECK(introspection.block_indices.compositional_fields[0] == 3);
-  CHECK(introspection.block_indices.compositional_fields[1] == 4);
-  CHECK(introspection.block_indices.compositional_fields[2] == 5);
-
-  // sparsity pattern block index:
-  CHECK(introspection.block_indices.compositional_field_sparsity_pattern.size() == 3);
-  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[0] == 3);
-  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[1] == 3);
-  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[2] == 3);
-
-  CHECK(introspection.base_elements.velocities == 0);
-  CHECK(introspection.base_elements.pressure == 1);
-  CHECK(introspection.base_elements.temperature == 2);
-  // All compositional fields have the same FE:
-  CHECK(introspection.base_elements.compositional_fields == std::vector<unsigned int>({3,3,3}));
-  CHECK(introspection.get_composition_base_element_indices() == std::vector<unsigned int>({3}));
-  CHECK(introspection.get_compositional_field_indices_with_base_element(3) == std::vector<unsigned int>({0,1,2}));
-}
-
-TEST_CASE("Introspection::different-composition-types")
-{
-  using namespace aspect;
-  dealii::ParameterHandler prm;
-  Simulator<2>::declare_parameters(prm);
-
-
-  prm.set("Output directory", "");
-
-  prm.enter_subsection("Compositional fields");
-  prm.set("Number of fields", "3");
-  prm.set("Names of fields", "a,b,c");
-  prm.leave_subsection();
-  prm.enter_subsection("Discretization");
-  prm.set("Use discontinuous temperature discretization", "false");
-  prm.set("Use discontinuous composition discretization", "true,false,false");
-  prm.leave_subsection();
-
-  Parameters<2> parameters(prm, MPI_COMM_WORLD);
-
-  const std::vector<VariableDeclaration<2>> variables = construct_default_variables (parameters);
-  Introspection<2> introspection (variables, parameters);
-
-  dealii::FESystem<2> fe(introspection.get_fes(), introspection.get_multiplicities());
-  CHECK(fe.get_name() == "FESystem<2>[FE_Q<2>(2)^2-FE_Q<2>(1)-FE_Q<2>(2)-FE_DGQ<2>(2)-FE_Q<2>(2)^2]");
-
-  CHECK(introspection.n_components == 7);
-  CHECK(introspection.n_compositional_fields == 3);
-  CHECK(introspection.n_blocks == 6);
-
-  CHECK(introspection.component_indices.velocities[0] == 0);
-  CHECK(introspection.component_indices.velocities[1] == 1);
-  CHECK(introspection.component_indices.pressure == 2);
-  CHECK(introspection.component_indices.temperature == 3);
-  CHECK(introspection.component_indices.compositional_fields[0] == 4);
-
-  CHECK(introspection.block_indices.velocities == 0);
-  CHECK(introspection.block_indices.pressure == 1);
-  CHECK(introspection.block_indices.temperature == 2);
-  CHECK(introspection.block_indices.compositional_fields[0] == 3);
-  CHECK(introspection.block_indices.compositional_fields[1] == 4);
-  CHECK(introspection.block_indices.compositional_fields[2] == 5);
-
-  // sparsity pattern block index:
-  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[0] == 3);
-  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[1] == 4);
-  CHECK(introspection.block_indices.compositional_field_sparsity_pattern[2] == 4);
-
-  // base elements:
-  CHECK(introspection.base_elements.compositional_fields == std::vector<unsigned int>({3,4,4}));
-  CHECK(introspection.get_composition_base_element_indices() == std::vector<unsigned int>({3,4}));
-  CHECK(introspection.get_compositional_field_indices_with_base_element(3) == std::vector<unsigned int>({0}));
-  CHECK(introspection.get_compositional_field_indices_with_base_element(4) == std::vector<unsigned int>({1,2}));
-}
diff --git a/unit_tests/mesh_refinement.cc.bak b/unit_tests/mesh_refinement.cc.bak
deleted file mode 100644
index efb33ec0053..00000000000
--- a/unit_tests/mesh_refinement.cc.bak
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-  Copyright (C) 2020 - 2021 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-#include <aspect/mesh_refinement/isosurfaces.h>
-
-namespace aspect
-{
-  namespace MeshRefinement
-  {
-    namespace internal
-    {
-      // Forward declaration
-      unsigned int min_max_string_to_int(const std::string &string_value, const unsigned int minimum_refinement_level, const unsigned int  maximum_refinement_level);
-    }
-  }
-}
-
-TEST_CASE("Isosurfaces min_max_string_to_int function")
-{
-
-  using namespace aspect::MeshRefinement::internal;
-  CHECK(min_max_string_to_int("min",1,5) == 1);
-  CHECK(min_max_string_to_int("min+1",1,5) == 2);
-  CHECK(min_max_string_to_int("min+2",1,5) == 3);
-  CHECK(min_max_string_to_int("min+3",1,5) == 4);
-  CHECK(min_max_string_to_int("min+4",1,5) == 5);
-  CHECK(min_max_string_to_int("max",1,5) == 5);
-  CHECK(min_max_string_to_int("max-1",1,5) == 4);
-  CHECK(min_max_string_to_int("max-2",1,5) == 3);
-  CHECK(min_max_string_to_int("max-3",1,5) == 2);
-  CHECK(min_max_string_to_int("max-4",1,5) == 1);
-  CHECK(min_max_string_to_int("2",1,5) == 2);
-
-  CHECK(min_max_string_to_int("6",1,5) == 5);
-  CHECK(min_max_string_to_int("0",1,5) == 1);
-  CHECK(min_max_string_to_int("min+5",1,5) == 5);
-  CHECK(min_max_string_to_int("max-5",1,5) == 1);
-
-  CHECK_THROWS_WITH(min_max_string_to_int("min-1",1,5),Contains("A value of min-1 was provided, but you can't provide a smaller value"));
-  CHECK_THROWS_WITH(min_max_string_to_int("max+1",1,5),Contains("A value of max+1 was provided, but you can't provide a larger value"));
-}
diff --git a/unit_tests/netcdf.cc.bak b/unit_tests/netcdf.cc.bak
deleted file mode 100644
index 31de709c15a..00000000000
--- a/unit_tests/netcdf.cc.bak
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
-  Copyright (C) 2021 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-#include <aspect/utilities.h>
-
-#ifdef ASPECT_WITH_NETCDF
-
-TEST_CASE("Utilities::load_netcdf-1d")
-{
-  using namespace dealii;
-
-  aspect::Utilities::StructuredDataLookup<1> lookup(1.0 /*scaling*/);
-  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/PREM_1s_depth.nc");
-
-  REQUIRE(lookup.get_column_names().size()==9);
-  REQUIRE(lookup.get_column_names()[0] == "radius");
-  REQUIRE(lookup.get_column_names()[2] == "vpv");
-
-  REQUIRE(lookup.get_data(Point<1>(1.0), 0) == Approx(6370.0)); // radius at depth = 1.0
-  REQUIRE(lookup.get_data(Point<1>(1.0), 2) == Approx(1.45)); // vpv at depth = 1.0
-}
-
-TEST_CASE("Utilities::load_netcdf-1d-column-names")
-{
-  using namespace dealii;
-
-  aspect::Utilities::StructuredDataLookup<1> lookup(1.0 /*scaling*/);
-  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/PREM_1s_depth.nc",
-                     std::vector<std::string> {"vpv","radius"});
-
-  REQUIRE(lookup.get_column_names().size()==2);
-  REQUIRE(lookup.get_column_names()[0] == "vpv");
-  REQUIRE(lookup.get_column_names()[1] == "radius");
-
-  REQUIRE(lookup.get_data(Point<1>(1.0), 0) == Approx(1.45)); // vpv at depth = 1.0
-  REQUIRE(lookup.get_data(Point<1>(1.0), 1) == Approx(6370.0)); // radius at depth = 1.0
-}
-
-TEST_CASE("Utilities::load_netcdf-3d")
-{
-  using namespace dealii;
-
-  aspect::Utilities::StructuredDataLookup<3> lookup(1.0 /*scaling*/);
-  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/test-3d-cartesian.nc");
-
-  REQUIRE(lookup.get_column_names().size()==2);
-  REQUIRE(lookup.get_column_names()[0] == "index");
-  REQUIRE(lookup.get_column_names()[1] == "depth");
-
-  REQUIRE(lookup.get_data(Point<3>(0., 500., 0.), 0) == Approx(0.));
-  REQUIRE(lookup.get_data(Point<3>(1000., 500., 0.), 0) == Approx(1.));
-}
-
-TEST_CASE("Utilities::load_netcdf-3d-spherical")
-{
-  using namespace dealii;
-
-  aspect::Utilities::StructuredDataLookup<3> lookup(1.0 /*scaling*/);
-  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/test-3d-spherical.nc");
-
-  REQUIRE(lookup.get_column_names().size()==1);
-  REQUIRE(lookup.get_column_names()[0] == "vs_anomaly");
-
-  REQUIRE(lookup.get_data(Point<3>(5297311.3326, 2.0944, 2.793), 0) == Approx(6423.5));
-  REQUIRE(lookup.get_data(Point<3>(6252530.6549, 4.1888, 3.142), 0) == Approx(4574.6));
-}
-
-TEST_CASE("Utilities::load_netcdf-3d-column-names")
-{
-  using namespace dealii;
-
-  aspect::Utilities::StructuredDataLookup<3> lookup(1.0 /*scaling*/);
-  lookup.load_netcdf(ASPECT_SOURCE_DIR "/data/test/netcdf/test-3d-cartesian.nc",
-                     std::vector<std::string> {"index"});
-
-  REQUIRE(lookup.get_column_names().size()==1);
-  REQUIRE(lookup.get_column_names()[0] == "index");
-
-  REQUIRE(lookup.get_data(Point<3>(0., 500., 0.), 0) == Approx(0.));
-  REQUIRE(lookup.get_data(Point<3>(1000., 500., 0.), 0) == Approx(1.));
-}
-
-#endif
diff --git a/unit_tests/parse_map_to_double_array.cc.bak b/unit_tests/parse_map_to_double_array.cc.bak
deleted file mode 100644
index 92669f9a9ba..00000000000
--- a/unit_tests/parse_map_to_double_array.cc.bak
+++ /dev/null
@@ -1,460 +0,0 @@
-/*
-  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-#include <aspect/utilities.h>
-#include <deal.II/base/exceptions.h>
-
-
-TEST_CASE("Utilities::parse_map_to_double_array")
-{
-  // Parse multicomponent properties
-  INFO("check 1: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, C4:400, C5:500, background:0",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"),
-  {0.0,100.0,200.0,300.0,400.0,500.0});
-
-  INFO("check 2: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("all:100",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"),
-  {100.0,100.0,100.0,100.0,100.0,100.0});
-
-  INFO("check 3: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("background:0, C1:100, C2:200, C3:300, C4:400, C5:500",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"),
-  {0.0,100.0,200.0,300.0,400.0,500.0});
-
-  INFO("check 4: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("background:0, C2:200, C1:100, C4:400, C5:500, C3:300",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"),
-  {0.0,100.0,200.0,300.0,400.0,500.0});
-
-  INFO("check 5: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, background:0, C3:300, C4:400, C5:500",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"),
-  {0.0,100.0,200.0,300.0,400.0,500.0});
-
-  INFO("check 6: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("100, 200, 300, 400, 500",
-  {"C1","C2","C3","C4","C5"},
-  false,
-  "TestField"),
-  {100.0,200.0,300.0,400.0,500.0});
-
-  INFO("check 7: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, C4:400, C5:500",
-  {"C1","C2","C3","C4","C5"},
-  false,
-  "TestField"),
-  {100.0,200.0,300.0,400.0,500.0});
-
-  INFO("check 8: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("background:0, C2:200, C1:100, C4:400, C5:500, C3:300",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"),
-  {0.0,100.0,200.0,300.0,400.0,500.0});
-
-  {
-    INFO("check 9: ");
-    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|100, C3:300, C4:400, C5:500, background:0",
-    {"C1","C2","C3","C4","C5"},
-    true,
-    "TestField",
-    true,
-    n_values_per_key),
-    {0.0,100.0,200.0,100.0,300.0,400.0,500.0});
-
-    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,1,2,1,1,1}));
-  }
-
-  {
-    INFO("check 10: ");
-    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|, C3:300, C4:400, C5:500",
-    {"C1","C2","C3","C4","C5"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    {100.0,200.0,300.0,400.0,500.0});
-
-    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,1,1,1,1}));
-  }
-
-  {
-    INFO("check 11: ");
-    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C4:400, C5:500",
-    {"C1","C2","C3","C4","C5"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    {100.0,200.0,300.0,300.0,400.0,500.0});
-
-    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,2,1,1,1}));
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C4:400, C5:500",
-    {"C1","C2","C3","C4","C5"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    {100.0,200.0,300.0,300.0,400.0,500.0});
-  }
-
-  {
-    INFO("check 12: ");
-    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("all:300|400",
-    {"C1","C2"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    {300.0,400.0,300.0,400.0});
-
-    REQUIRE(*n_values_per_key == std::vector<unsigned int> ({2,2}));
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("all:100|200",
-    {"C1","C2"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    {100.0,200.0,100.0,200.0});
-  }
-
-  INFO("check 13: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("background:0, C1:100, C4:400, C5:500, C3:300",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField",
-  false,
-  nullptr,
-  true),
-  {0.0,100.0,300.0,400.0,500.0});
-
-  INFO("check 14: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C4:400, C5:500, C3:300",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField",
-  false,
-  nullptr,
-  true),
-  {100.0,300.0,400.0,500.0});
-
-  INFO("check 16: ");
-  compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField",
-  false,
-  nullptr,
-  true),
-  std::vector<double>());
-
-  {
-    INFO("check 17: ");
-    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C5:500",
-    {"C1","C2","C3","C4","C5"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key,
-    true),
-    {100.0,200.0,300.0,300.0,500.0});
-
-    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,2,1,0,1}));
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C5:500",
-    {"C1","C2","C3","C4","C5"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key,
-    true),
-    {100.0,200.0,300.0,300.0,500.0});
-  }
-
-  {
-    INFO("check 18: ");
-    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>(std::vector<unsigned int>({2,2}));
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:300|400, C2:200",
-    {"C1","C2"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    {300.0,400.0,200.0,200.0});
-
-    INFO("check 19: ");
-
-    // still using the compare_vectors_approx defined before
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("200",
-    {"C1","C2"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    {200.0,200.0,200.0,200.0});
-  }
-
-  {
-    // Check that we can provide additional allowed keys that are ignored when parsing
-    INFO("check 20: ");
-    aspect::Utilities::MapParsing::Options options({"C1","C2","C3","C5"},"TestField");
-    options.list_of_allowed_keys = {"C1","C2","C3","C4","C5","C6","C7"};
-
-    std::string input_string = "C1:100, C2:200, C3:300, C5:500";
-
-    compare_vectors_approx(aspect::Utilities::MapParsing::parse_map_to_double_array (input_string, options),
-    {100.0,200.0,300.0,500.0});
-  }
-  INFO("check complete");
-
-}
-
-using Catch::Matchers::Contains;
-
-TEST_CASE("Utilities::parse_map_to_double_array FAIL ON PURPOSE")
-{
-  // Purposefully fail Parse multicomponent properties
-  INFO("check fail 1: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_map_to_double_array ("C1:100, C1:200, C3:300, C4:400, C5:500",
-  {"C1","C2","C3","C4","C5"},
-  false,
-  "TestField"), Contains("is listed multiple times"));
-
-
-  INFO("check fail 2: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, C4:400, C5:500",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"), Contains("The keyword <background> in TestField is not listed"));
-
-
-  INFO("check fail 3: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_map_to_double_array ("C1:100, C1:200, C3:300, C4;400, C5:500, bg:3",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"), Contains("does not have the expected format"));
-
-
-  INFO("check fail 4: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, C4:400, C24:500, bg:3",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"), Contains("does not match any entries"));
-
-  INFO("check fail 5: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200, C3:300, all:400, C5:500, bg:3",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"), Contains("The keyword `all' in the property TestField is only allowed if"));
-
-  INFO("check fail 6: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_map_to_double_array ("C1:100",
-  {"C1","C2","C3","C4","C5"},
-  true,
-  "TestField"), Contains("The keyword <background> in TestField is not listed"));
-
-  // Subentries not allowed
-  INFO("check fail 7: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:100|200, C3:300, C4:400, C5:500",
-  {"C1","C2","C3","C4","C5"},
-  false,
-  "TestField"), Contains("The keyword <C2> in TestField has multiple values"));
-
-  // Wrong subentry format
-  INFO("check fail 8: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:|200, C3:300, C4:400, C5:500",
-  {"C1","C2","C3","C4","C5"},
-  false,
-  "TestField",
-  true), Contains("does not have the expected format"));
-
-  // No subentries
-  INFO("check fail 9: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_map_to_double_array ("C1:100, C2:|, C3:300, C4:400, C5:500",
-  {"C1","C2","C3","C4","C5"},
-  false,
-  "TestField",
-  true), Contains("does not have the expected format"));
-
-  // Wrong input structure
-  {
-    INFO("check fail 10: ");
-    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("C1:100, C2:200|300, C3:300, C4:400, C5:500",
-    {"C1","C2","C3","C4","C5"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    {100.0,200.0,300.0,300.0,400.0,500.0});
-
-    REQUIRE(*n_values_per_key == std::vector<unsigned int>({1,2,1,1,1}));
-
-    REQUIRE_THROWS_WITH(aspect::Utilities::parse_map_to_double_array ("C1:100|200, C2:300, C3:300, C4:400, C5:500",
-    {"C1","C2","C3","C4","C5"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    Contains("The key <C1> in <TestField> does not have the expected number"));
-  }
-
-  {
-    INFO("check fail 11: ");
-    auto n_values_per_key = std::make_unique<std::vector<unsigned int>>();
-
-    compare_vectors_approx(aspect::Utilities::parse_map_to_double_array ("all:300|400",
-    {"C1","C2"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    {300.0,400.0,300.0,400.0});
-
-    REQUIRE(*n_values_per_key == std::vector<unsigned int>({2,2}));
-
-    REQUIRE_THROWS_WITH(aspect::Utilities::parse_map_to_double_array ("all:100|200|300",
-    {"C1","C2"},
-    false,
-    "TestField",
-    true,
-    n_values_per_key),
-    Contains("The key <C1> in <TestField> does not have the expected number"));
-  }
-}
-
-
-TEST_CASE("Utilities::parse_input_table")
-{
-  // Parse multicomponent properties
-  INFO("check 1: ");
-
-  dealii::Table<2,double> expected_result(3,3);
-
-  expected_result[0][0] = 100.0;
-  expected_result[0][1] = 10.0;
-  expected_result[0][2] = 30.0;
-  expected_result[1][0] = 25.0;
-  expected_result[1][1] = 5.0;
-  expected_result[1][2] = 1500.0;
-  expected_result[2][0] = 0.001;
-  expected_result[2][1] = 0.1;
-  expected_result[2][2] = 3.5;
-
-
-  compare_tables_approx(aspect::Utilities::parse_input_table<double> ("100,10,30; 25.0,5.0 ,1.5e3; 0.001,10e-2,3.5",
-                                                                      3, 3, "TestField"),
-                        expected_result);
-
-  expected_result[0][0] = 100.0;
-  expected_result[0][1] = 10.0;
-  expected_result[0][2] = 30.0;
-  expected_result[1][0] = 100.0;
-  expected_result[1][1] = 10.0;
-  expected_result[1][2] = 30.0;
-  expected_result[2][0] = 100.0;
-  expected_result[2][1] = 10.0;
-  expected_result[2][2] = 30.0;
-
-
-  compare_tables_approx(aspect::Utilities::parse_input_table<double> ("100,10,30",
-                                                                      3, 3, "TestField"),
-                        expected_result);
-
-  expected_result[0][0] = 100.0;
-  expected_result[0][1] = 100.0;
-  expected_result[0][2] = 100.0;
-  expected_result[1][0] = 10.0;
-  expected_result[1][1] = 10.0;
-  expected_result[1][2] = 10.0;
-  expected_result[2][0] = 30.0;
-  expected_result[2][1] = 30.0;
-  expected_result[2][2] = 30.0;
-
-
-  compare_tables_approx(aspect::Utilities::parse_input_table<double> ("100;10;30",
-                                                                      3, 3, "TestField"),
-                        expected_result);
-
-  INFO("check complete");
-
-}
-
-using Catch::Matchers::Contains;
-
-TEST_CASE("Utilities::parse_input_table FAIL ON PURPOSE")
-{
-  // Purposefully fail Parse multicomponent properties
-  INFO("check fail 1: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_input_table<double> ("100,10,30; 25.0,5.0 ,1.5e3",
-                                                  3,3,
-                                                  "TestField"), Contains("Length of TestField"));
-
-  // Purposefully fail Parse multicomponent properties
-  INFO("check fail 2: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_input_table<double> ("100,10; 25.0,5.0; 5.0,2.5",
-                                                  3,3,
-                                                  "TestField"), Contains("Length of TestField"));
-
-  // Purposefully fail Parse multicomponent properties
-  INFO("check fail 3: ");
-  REQUIRE_THROWS_WITH(
-    aspect::Utilities::parse_input_table<double> ("100,10; a,5.0; 5.0,2.5",
-                                                  3,2,
-                                                  "TestField"), Contains("bad lexical cast"));
-}
diff --git a/unit_tests/particles.cc.bak b/unit_tests/particles.cc.bak
deleted file mode 100644
index 8cff8cea568..00000000000
--- a/unit_tests/particles.cc.bak
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-  Copyright (C) 2020 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-#include <aspect/particle/property/interface.h>
-#include <aspect/particle/world.h>
-#include <deal.II/base/parameter_handler.h>
-
-TEST_CASE("Particle Manager plugin names")
-{
-  dealii::ParameterHandler prm;
-  aspect::Particle::Property::Manager<2> manager;
-  // The property manager needs to know about the integrator, which is declared in World
-  aspect::Particle::World<2>::declare_parameters(prm);
-
-  prm.enter_subsection("Particles");
-  manager.declare_parameters(prm);
-  prm.set("List of particle properties","composition, position");
-  manager.parse_parameters(prm);
-  prm.leave_subsection();
-
-  // existing and listed pluring
-  REQUIRE(manager.plugin_name_exists("composition") == true);
-  REQUIRE(manager.plugin_name_exists("position") == true);
-
-  // existing but not listed plugin
-  REQUIRE(manager.plugin_name_exists("pT path") == false);
-
-  // non-existed plugin
-  REQUIRE(manager.plugin_name_exists("non-existent plugin name") == false);
-
-  // check that one is before the other
-  REQUIRE(manager.check_plugin_order("composition", "position") == true);
-  REQUIRE(manager.check_plugin_order("position", "composition") == false);
-
-  // Check the plugin indices
-  REQUIRE(manager.get_plugin_index_by_name("composition") == 0);
-  REQUIRE(manager.get_plugin_index_by_name("position") == 1);
-}
diff --git a/unit_tests/termination_criteria.cc.bak b/unit_tests/termination_criteria.cc.bak
deleted file mode 100644
index a98c9483c08..00000000000
--- a/unit_tests/termination_criteria.cc.bak
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-  Copyright (C) 2019 - 2022 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-#include <aspect/termination_criteria/steady_temperature.h>
-
-
-/**
- * A function that trims the handed over list and removes all entries from the front that are
- * further back in time measured from the last entry than given by the first argument.
- * Additionally it makes sure to always keep two entries in the list, if the list had
- * two or more entries. Otherwise the function does not change the list.
- */
-void trim_time_temperature_list (const double necessary_time_in_steady_state,
-                                 std::list<std::pair<double, double>> &time_temperature_list)
-{
-  // Remove old times until we're at the correct time period
-  // but ensure at least two entries remain in the list (one old, one current timestep)
-  auto it = time_temperature_list.begin();
-  while (time_temperature_list.back().first - (*it).first > necessary_time_in_steady_state &&
-         std::distance(it,time_temperature_list.end()) > 2)
-    ++it;
-
-  time_temperature_list.erase(time_temperature_list.begin(), it);
-}
-
-
-TEST_CASE("trim time_temperature_list test for steady state termination criteria")
-{
-  std::list<std::pair<double,double>> time_temperature;
-  time_temperature.emplace_back(0.0,1.0);
-  time_temperature.emplace_back(1.0,2.0);
-  time_temperature.emplace_back(1.4,3.0);
-
-  trim_time_temperature_list(1.5,time_temperature);
-
-  REQUIRE(time_temperature.front().second == 1.0);
-  REQUIRE(time_temperature.back().second == 3.0);
-
-  // Remove first entry because it is more than 1.0 away from last entry
-  trim_time_temperature_list(1.0,time_temperature);
-
-  REQUIRE(time_temperature.front().second == 2.0);
-  REQUIRE(time_temperature.back().second == 3.0);
-
-  // Try to remove first entry, should not change list, since it should keep at least 2 entries
-  trim_time_temperature_list(0.3,time_temperature);
-
-  REQUIRE(time_temperature.front().second == 2.0);
-  REQUIRE(time_temperature.back().second == 3.0);
-}
diff --git a/unit_tests/utilities.cc.bak b/unit_tests/utilities.cc.bak
deleted file mode 100644
index 830dbc9eae1..00000000000
--- a/unit_tests/utilities.cc.bak
+++ /dev/null
@@ -1,628 +0,0 @@
-/*
-  Copyright (C) 2018 - 2023 by the authors of the ASPECT code.
-
-  This file is part of ASPECT.
-
-  ASPECT is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
-
-  ASPECT is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with ASPECT; see the file LICENSE.  If not see
-  <http://www.gnu.org/licenses/>.
-*/
-
-#include "common.h"
-#include <aspect/utilities.h>
-
-TEST_CASE("Utilities::weighted_p_norm_average")
-{
-  std::vector<double> weights = {1,1,2,2,3,3};
-  std::vector<double> values = {6,5,4,3,2,1};
-  std::vector<double> p_norms = {-1000,-2.5,-2,-1,0,1,2,2.5,3,4,1000};
-  std::vector<double> expected = {1., 1.59237, 1.6974 , 1.98895, 2.38899, 2.83333, 3.24037, 3.41824, 3.57872, 3.85347, 6. };
-
-  for (unsigned int i = 0; i < p_norms.size(); i++)
-    {
-      INFO("check i=" << i << ": ");
-      REQUIRE(aspect::Utilities::weighted_p_norm_average(weights,values,p_norms[i]) == Approx(expected[i]));
-    }
-
-}
-
-TEST_CASE("Utilities::AsciiDataLookup")
-{
-  using namespace dealii;
-
-  //TODO: add support for setting data directly instead of relying on a file to load:
-  aspect::Utilities::StructuredDataLookup<1> lookup(2 /*n_components*/, 1.0 /*scaling*/);
-  const std::string data_filename = aspect::Utilities::expand_ASPECT_SOURCE_DIR("$ASPECT_SOURCE_DIR/data/boundary-velocity/ascii-data/test/box_2d_left.0.txt");
-  lookup.load_file(data_filename, MPI_COMM_WORLD);
-
-  INFO(lookup.get_data(Point<1>(330000./2.0),0));
-  INFO(lookup.get_data(Point<1>(330000./2.0),1));
-  INFO(lookup.get_gradients(Point<1>(330000./2.0),0));
-  INFO(lookup.get_gradients(Point<1>(330000./2.0),1));
-
-  REQUIRE(lookup.get_data(Point<1>(330000./2.0),0) == Approx(0.5));
-  REQUIRE(lookup.get_data(Point<1>(330000./2.0),1) == Approx(0.0));
-  REQUIRE(lookup.get_gradients(Point<1>(330000./2.0),0)[0] == Approx(-1.0/330000.));
-  REQUIRE(lookup.get_gradients(Point<1>(330000./2.0),1)[0] == Approx(0.0));
-}
-
-
-TEST_CASE("Utilities::AsciiDataLookup manual dim=1")
-{
-  using namespace dealii;
-
-  aspect::Utilities::StructuredDataLookup<1> lookup(2 /*n_components*/, 1.0 /*scaling*/);
-
-  std::vector<std::string> column_names = {"a", "b"};
-  Table<1,double> table(2);
-  std::vector<Table<1,double>> raw_data(2, table);
-
-  std::vector<std::vector<double>> coordinate_values(1, std::vector<double>({1.0, 2.0}));
-  // c1:
-  raw_data[0](0) = 0.0;
-  raw_data[0](1) = 1.0;
-  // c2:
-  raw_data[1](0) = 5.0;
-  raw_data[1](1) = 3.0;
-
-  lookup.reinit(column_names, std::move(coordinate_values), std::move(raw_data),
-                MPI_COMM_SELF, numbers::invalid_unsigned_int);
-
-  INFO(lookup.get_data(Point<1>(1.5), 0));
-  INFO(lookup.get_data(Point<1>(1.5), 1));
-
-  REQUIRE(lookup.get_data(Point<1>(1.5),0) == Approx(0.5));
-  REQUIRE(lookup.get_data(Point<1>(1.5),1) == Approx(4.0));
-
-  REQUIRE(lookup.get_gradients(Point<1>(1.5),0)[0] == Approx(1.0));
-  REQUIRE(lookup.get_gradients(Point<1>(1.5),1)[0] == Approx(-2.0));
-}
-
-TEST_CASE("Utilities::AsciiDataLookup manual dim=2")
-{
-  using namespace dealii;
-
-  aspect::Utilities::StructuredDataLookup<2> lookup(1 /*n_components*/, 1.0 /*scaling*/);
-
-  std::vector<std::string> column_names = {"topography"};
-  std::vector<Table<2,double>> raw_data(1, Table<2,double>(3,3));
-  std::vector<std::vector<double>> coordinate_values(2, std::vector<double>(3, 0.));
-
-  // x:
-  coordinate_values[0] = {0., 1., 3.};
-  // y:
-  coordinate_values[1] = {5., 6., 7.};
-  // c1:
-  raw_data[0](0,0) = 1.0;
-  raw_data[0](1,0) = 2.0;
-  raw_data[0](2,0) = 3.0;
-  raw_data[0](0,1) = 4.0;
-  raw_data[0](1,1) = 5.0;
-  raw_data[0](2,1) = 6.0;
-  raw_data[0](0,2) = 0.0;
-  raw_data[0](1,2) = 0.0;
-  raw_data[0](2,2) = 0.0;
-
-  lookup.reinit(column_names, std::move(coordinate_values), std::move(raw_data),
-                MPI_COMM_SELF, numbers::invalid_unsigned_int);
-
-  REQUIRE(lookup.get_data(Point<2>(1.0,6.0),0) == Approx(5.0));
-  REQUIRE(lookup.get_data(Point<2>(2.0,6.0),0) == Approx(5.5));
-}
-
-TEST_CASE("Utilities::AsciiDataLookup manual dim=2 equid")
-{
-  using namespace dealii;
-
-  aspect::Utilities::StructuredDataLookup<2> lookup(1 /*n_components*/, 1.0 /*scaling*/);
-
-  std::vector<std::string> column_names = {"topography"};
-  std::vector<Table<2,double>> raw_data(1, Table<2,double>(3,3));
-  std::vector<std::vector<double>> coordinate_values(2, std::vector<double>(3, 0.));
-
-  // x:
-  coordinate_values[0] = {0., 1., 2.};
-  // y:
-  coordinate_values[1] = {5., 6., 7.};
-  // c1:
-  raw_data[0](0,0) = 1.0;
-  raw_data[0](1,0) = 2.0;
-  raw_data[0](2,0) = 3.0;
-  raw_data[0](0,1) = 4.0;
-  raw_data[0](1,1) = 5.0;
-  raw_data[0](2,1) = 6.0;
-  raw_data[0](0,2) = 0.0;
-  raw_data[0](1,2) = 0.0;
-  raw_data[0](2,2) = 0.0;
-
-  lookup.reinit(column_names, std::move(coordinate_values), std::move(raw_data),
-                MPI_COMM_SELF, numbers::invalid_unsigned_int);
-
-  REQUIRE(lookup.get_data(Point<2>(1.0,6.0),0) == Approx(5.0));
-  REQUIRE(lookup.get_data(Point<2>(1.5,6.0),0) == Approx(5.5));
-}
-
-TEST_CASE("Random draw volume weighted average rotation matrix")
-{
-  std::vector<double> unsorted_volume_fractions = {2.,5.,1.,3.,6.,4.};
-  std::vector<double> sorted_volume_fractions_ref = {1.,2.,3.,4.,5.,6.};
-  const std::vector<std::size_t> permutation = aspect::Utilities::compute_sorting_permutation<double>(unsorted_volume_fractions);
-  const std::vector<double> sorted_volume_fractions = aspect::Utilities::apply_permutation<double>(unsorted_volume_fractions,permutation);
-
-  for (unsigned int i = 0; i < sorted_volume_fractions.size(); i++)
-    {
-      REQUIRE(sorted_volume_fractions[i] == Approx(sorted_volume_fractions_ref[i]));
-    }
-
-  const std::vector<dealii::Tensor<2,3>> unsorted_rotation_matrices =
-  {
-    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
-    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
-    dealii::Tensor<2,3>({{1.,1.,1.},{1.,1.,1.},{1.,1.,1.}}),
-    dealii::Tensor<2,3>({{3.,3.,3.},{3.,3.,3.},{3.,3.,3.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}})
-  };
-
-  const std::vector<dealii::Tensor<2,3>> sorted_rotation_matrices_ref =
-  {
-    dealii::Tensor<2,3>({{1.,1.,1.},{1.,1.,1.},{1.,1.,1.}}),
-    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
-    dealii::Tensor<2,3>({{3.,3.,3.},{3.,3.,3.},{3.,3.,3.}}),
-    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}}),
-    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}})
-  };
-  const std::vector<dealii::Tensor<2,3>> sorted_rotation_matrices = aspect::Utilities::apply_permutation<dealii::Tensor<2,3>>(unsorted_rotation_matrices,permutation);
-  for (unsigned int i = 0; i < sorted_rotation_matrices.size(); i++)
-    {
-      REQUIRE(sorted_rotation_matrices[i][0][0] == Approx(sorted_rotation_matrices_ref[i][0][0]));
-    }
-
-  std::mt19937 random_number_generator;
-  random_number_generator.seed(5);
-  const std::vector<dealii::Tensor<2,3>> result = aspect::Utilities::rotation_matrices_random_draw_volume_weighting(unsorted_volume_fractions,
-                                                   unsorted_rotation_matrices,
-                                                   25,
-                                                   random_number_generator);
-
-  const std::vector<dealii::Tensor<2,3>> result_ref =
-  {
-    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
-    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}}),
-    dealii::Tensor<2,3>({{4.,4.,4.},{4.,4.,4.},{4.,4.,4.}}),
-    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{3.,3.,3.},{3.,3.,3.},{3.,3.,3.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
-    dealii::Tensor<2,3>({{3.,3.,3.},{3.,3.,3.},{3.,3.,3.}}),
-    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
-    dealii::Tensor<2,3>({{5.,5.,5.},{5.,5.,5.},{5.,5.,5.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{1.,1.,1.},{1.,1.,1.},{1.,1.,1.}}),
-    dealii::Tensor<2,3>({{2.,2.,2.},{2.,2.,2.},{2.,2.,2.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-    dealii::Tensor<2,3>({{6.,6.,6.},{6.,6.,6.},{6.,6.,6.}}),
-  };
-  for (unsigned int i = 0; i < result.size(); i++)
-    {
-      REQUIRE(result[i][0][0] == Approx(result_ref[i][0][0]));
-    }
-}
-
-TEST_CASE("wrap angle")
-{
-  REQUIRE(aspect::Utilities::wrap_angle(-720.) == 0.);
-  REQUIRE(aspect::Utilities::wrap_angle(-540.) == 180.);
-  REQUIRE(aspect::Utilities::wrap_angle(-361.) == 359.);
-  REQUIRE(aspect::Utilities::wrap_angle(-360.) == 0.);
-  REQUIRE(aspect::Utilities::wrap_angle(-359.) == 1.);
-  REQUIRE(aspect::Utilities::wrap_angle(-270.) == 90.);
-  REQUIRE(aspect::Utilities::wrap_angle(-180.) == 180.);
-  REQUIRE(aspect::Utilities::wrap_angle(-90.) == 270.);
-  REQUIRE(aspect::Utilities::wrap_angle(0.) == 0.);
-  REQUIRE(aspect::Utilities::wrap_angle(90.) == 90.);
-  REQUIRE(aspect::Utilities::wrap_angle(180.) == 180.);
-  REQUIRE(aspect::Utilities::wrap_angle(270.) == 270.);
-  REQUIRE(aspect::Utilities::wrap_angle(359.) == 359.);
-  REQUIRE(aspect::Utilities::wrap_angle(360.) == 0.);
-  REQUIRE(aspect::Utilities::wrap_angle(361.) == 1.);
-  REQUIRE(aspect::Utilities::wrap_angle(540.) == 180.);
-  REQUIRE(aspect::Utilities::wrap_angle(720.) == 0.);
-}
-
-TEST_CASE("CPO elastic tensor transform functions")
-{
-  dealii::SymmetricTensor<2,6> reference_elastic_tensor({1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21});
-
-// first test whether the functions are invertable
-  {
-    dealii::SymmetricTensor<2,6> result_up_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor));
-
-    for (size_t i = 0; i < 6; i++)
-      {
-        for (size_t j = 0; j < 6; j++)
-          {
-            REQUIRE(reference_elastic_tensor[i][j] == Approx(result_up_down[i][j]));
-          }
-      }
-  }
-  {
-    dealii::SymmetricTensor<2,6> result_down_up = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(aspect::Utilities::Tensors::to_voigt_stiffness_vector(reference_elastic_tensor));
-
-    for (size_t i = 0; i < 6; i++)
-      {
-        for (size_t j = 0; j < 6; j++)
-          {
-            REQUIRE(reference_elastic_tensor[i][j] == Approx(result_down_up[i][j]));
-          }
-      }
-  }
-  {
-    dealii::SymmetricTensor<2,6> result_up_2down_up = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(aspect::Utilities::Tensors::to_voigt_stiffness_vector(aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
-
-    for (size_t i = 0; i < 6; i++)
-      {
-        for (size_t j = 0; j < 6; j++)
-          {
-            REQUIRE(reference_elastic_tensor[i][j] == Approx(result_up_2down_up[i][j]));
-          }
-      }
-  }
-
-  // test rotations
-  // rotation matrix
-  dealii::Tensor<2,3> rotation_tensor;
-
-  {
-
-    // fill the rotation matrix with a rotations in all directions
-    {
-      double radians = 0;
-      double alpha = radians;
-      double beta = radians;
-      double gamma = radians;
-      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
-      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
-      rotation_tensor[0][2] = -std::sin(beta);
-      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
-      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
-      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
-      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
-      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
-      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
-    }
-
-    {
-      dealii::SymmetricTensor<4,3> result_full_stiffness_tensor = aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor);
-      dealii::SymmetricTensor<4,3> result_full_stiffness_tensor_rotate_zero = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,result_full_stiffness_tensor);
-
-      // first check that one the tensors didn't change with zero rotation
-      for (size_t i = 0; i < 3; i++)
-        {
-          for (size_t j = 0; j < 3; j++)
-            {
-              for (size_t k = 0; k < 3; k++)
-                {
-                  for (size_t l = 0; l < 3; l++)
-                    {
-                      REQUIRE(result_full_stiffness_tensor[i][j][k][l] == Approx(result_full_stiffness_tensor_rotate_zero[i][j][k][l]));
-                    }
-                }
-            }
-        }
-    }
-
-    {
-      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
-                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
-                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
-      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor,reference_elastic_tensor);
-
-      // first check that one the tensors didn't change with zero rotation
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_up_1_rotate_down[i][j] == Approx(reference_elastic_tensor[i][j]));
-              REQUIRE(result_1_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
-            }
-        }
-
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
-            }
-        }
-    }
-
-    // fill the rotation matrix with a rotations in all directions
-    {
-      double radians = (dealii::numbers::PI/180.0)*(360/5); //0.35*dealii::numbers::PI; //(dealii::numbers::PI/180.0)*36;
-      double alpha = radians;
-      double beta = radians;
-      double gamma = radians;
-      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
-      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
-      rotation_tensor[0][2] = -std::sin(beta);
-      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
-      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
-      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
-      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
-      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
-      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
-    }
-
-    {
-      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
-                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
-                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
-      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor,reference_elastic_tensor);
-
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
-            }
-        }
-
-      dealii::SymmetricTensor<4,3> result_up_10_rotate = aspect::Utilities::Tensors::to_full_stiffness_tensor(result_up_1_rotate_down);
-
-      dealii::SymmetricTensor<2,6> result_5_rotate = result_1_rotate;
-
-      for (size_t i = 0; i < 4; i++)
-        {
-          result_up_10_rotate = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,result_up_10_rotate);
-          result_5_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, result_5_rotate);
-        }
-
-      dealii::SymmetricTensor<2,6> result_up_10_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(result_up_10_rotate);
-
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_5_rotate[i][j] == Approx(result_up_10_rotate_down[i][j]));
-              // This test doesn't work when rotating in all rotations at the same time.
-              //REQUIRE(result_1_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
-            }
-        }
-    }
-  }
-  {
-    // fill the rotation matrix with a rotations in the alpha direction
-    {
-      double radians = (dealii::numbers::PI/180.0)*(360/5); //0.35*dealii::numbers::PI; //(dealii::numbers::PI/180.0)*36;
-      double alpha = radians;
-      double beta = 0;
-      double gamma = 0;
-      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
-      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
-      rotation_tensor[0][2] = -std::sin(beta);
-      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
-      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
-      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
-      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
-      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
-      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
-    }
-
-    {
-      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
-                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
-                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
-      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor,reference_elastic_tensor);
-
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
-            }
-        }
-
-      dealii::SymmetricTensor<4,3> result_up_10_rotate = aspect::Utilities::Tensors::to_full_stiffness_tensor(result_up_1_rotate_down);
-
-      dealii::SymmetricTensor<2,6> result_5_rotate = result_1_rotate;
-
-      for (size_t i = 0; i < 4; i++)
-        {
-          result_up_10_rotate = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor, result_up_10_rotate);
-          result_5_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, result_5_rotate);
-        }
-
-      dealii::SymmetricTensor<2,6> result_up_10_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(result_up_10_rotate);
-
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_5_rotate[i][j] == Approx(result_up_10_rotate_down[i][j]));
-              REQUIRE(result_5_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
-            }
-        }
-    }
-  }
-  {
-    // fill the rotation matrix with a rotations in the beta direction
-    {
-      double radians = (dealii::numbers::PI/180.0)*(360/5); //0.35*dealii::numbers::PI; //(dealii::numbers::PI/180.0)*36;
-      double alpha = 0;
-      double beta = radians;
-      double gamma = 0;
-      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
-      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
-      rotation_tensor[0][2] = -std::sin(beta);
-      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
-      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
-      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
-      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
-      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
-      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
-    }
-
-    {
-      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
-                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
-                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
-      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, reference_elastic_tensor);
-
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
-            }
-        }
-
-      dealii::SymmetricTensor<4,3> result_up_10_rotate = aspect::Utilities::Tensors::to_full_stiffness_tensor(result_up_1_rotate_down);
-
-      dealii::SymmetricTensor<2,6> result_5_rotate = result_1_rotate;
-
-      for (size_t i = 0; i < 4; i++)
-        {
-          result_up_10_rotate = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor, result_up_10_rotate);
-          result_5_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, result_5_rotate);
-        }
-
-      dealii::SymmetricTensor<2,6> result_up_10_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(result_up_10_rotate);
-
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_5_rotate[i][j] == Approx(result_up_10_rotate_down[i][j]));
-              REQUIRE(result_5_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
-            }
-        }
-    }
-  }
-
-  {
-    // fill the rotation matrix with a rotations in the gamma direction
-    {
-      double radians = (dealii::numbers::PI/180.0)*(360/5); //0.35*dealii::numbers::PI; //(dealii::numbers::PI/180.0)*36;
-      double alpha = 0;
-      double beta = 0;
-      double gamma = radians;
-      rotation_tensor[0][0] = std::cos(alpha) * std::cos(beta);
-      rotation_tensor[0][1] = std::sin(alpha) * std::cos(beta);
-      rotation_tensor[0][2] = -std::sin(beta);
-      rotation_tensor[1][0] = std::cos(alpha) * std::sin(beta) * std::sin(gamma) - std::sin(alpha)*cos(gamma);
-      rotation_tensor[1][1] = std::sin(alpha) * std::sin(beta) * std::sin(gamma) + std::cos(alpha)*cos(gamma);
-      rotation_tensor[1][2] = std::cos(beta) * std::sin(gamma);
-      rotation_tensor[2][0] = std::cos(alpha) * std::sin(beta) * std::cos(gamma) + std::sin(alpha)*sin(gamma);
-      rotation_tensor[2][1] = std::sin(alpha) * std::sin(beta) * std::cos(gamma) - std::cos(alpha)*sin(gamma);
-      rotation_tensor[2][2] = std::cos(beta) * std::cos(gamma);
-    }
-
-    {
-      dealii::SymmetricTensor<2,6> result_up_1_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(
-                                                               aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor,
-                                                                   aspect::Utilities::Tensors::to_full_stiffness_tensor(reference_elastic_tensor)));
-      dealii::SymmetricTensor<2,6> result_1_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, reference_elastic_tensor);
-
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_1_rotate[i][j] == Approx(result_up_1_rotate_down[i][j]));
-            }
-        }
-
-      dealii::SymmetricTensor<4,3> result_up_10_rotate = aspect::Utilities::Tensors::to_full_stiffness_tensor(result_up_1_rotate_down);
-
-      dealii::SymmetricTensor<2,6> result_5_rotate = result_1_rotate;
-
-      for (size_t i = 0; i < 4; i++)
-        {
-          result_up_10_rotate = aspect::Utilities::Tensors::rotate_full_stiffness_tensor(rotation_tensor, result_up_10_rotate);
-          result_5_rotate = aspect::Utilities::Tensors::rotate_voigt_stiffness_matrix(rotation_tensor, result_5_rotate);
-        }
-
-      dealii::SymmetricTensor<2,6> result_up_10_rotate_down = aspect::Utilities::Tensors::to_voigt_stiffness_matrix(result_up_10_rotate);
-
-      for (size_t i = 0; i < 6; i++)
-        {
-          for (size_t j = 0; j < 6; j++)
-            {
-              REQUIRE(result_5_rotate[i][j] == Approx(result_up_10_rotate_down[i][j]));
-              REQUIRE(result_5_rotate[i][j] == Approx(reference_elastic_tensor[i][j]));
-            }
-        }
-    }
-  }
-
-  /**
-   * test Levi-Cevita tensor function
-   */
-  {
-
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][0][0] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][0][1] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][0][2] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][1][0] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][1][1] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][1][2] == Approx(1.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][2][0] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][2][1] == Approx(-1.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[0][2][2] == Approx(0.0));
-
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][0][0] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][0][1] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][0][2] == Approx(-1.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][1][0] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][1][1] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][1][2] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][2][0] == Approx(1.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][2][1] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[1][2][2] == Approx(0.0));
-
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][0][0] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][0][1] == Approx(1.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][0][2] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][1][0] == Approx(-1.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][1][1] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][1][2] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][2][0] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][2][1] == Approx(0.0));
-    REQUIRE(aspect::Utilities::Tensors::levi_civita<3>()[2][2][2] == Approx(0.0));
-  }
-}
-
-TEST_CASE("Utilities::string_to_unsigned_int")
-{
-  CHECK(aspect::Utilities::string_to_unsigned_int("1234") == 1234);
-
-  CHECK(aspect::Utilities::string_to_unsigned_int(std::vector<std::string>({"234","0","1"}))
-        == std::vector<unsigned int>({234,0,1}));
-
-  CHECK(aspect::Utilities::string_to_unsigned_int(std::vector<std::string>({"42"}))
-        == std::vector<unsigned int>({42}));
-
-  CHECK(aspect::Utilities::string_to_unsigned_int(std::vector<std::string>({}))
-        == std::vector<unsigned int>());
-}

From fa78f1e66120f2d841d474778173ef57c60b7ac7 Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Sat, 27 Jul 2024 16:30:58 +0800
Subject: [PATCH 21/22] fix bug: missing case: comments behind parameter value

---
 .../prm_files/reformat_limiter_settings.py    | 40 +++++++++++++++----
 1 file changed, 32 insertions(+), 8 deletions(-)

diff --git a/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py b/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py
index f9a401d4281..92f11886d15 100644
--- a/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py
+++ b/contrib/utilities/update_scripts/prm_files/reformat_limiter_settings.py
@@ -33,7 +33,7 @@ def reformat_limiter_settings(parameters):
     new_entries = ["Limiter for discontinuous temperature solution",
                    "Limiter for discontinuous composition solution"]
 
-    # go to the subsection
+    # Go to the subsection
     if "Discretization" in parameters:
         if "Stabilization parameters" in parameters["Discretization"]["value"]:
             subsection = parameters["Discretization"]["value"]["Stabilization parameters"]["value"]
@@ -41,16 +41,40 @@ def reformat_limiter_settings(parameters):
             for i in range(0,2):
                 if old_entries[i] in subsection:
 
+                    # Get the parameter value. Notice that the value may be followed by some
+                    # extra comments, in which case we need to split them.
+                    comments = subsection[old_entries[i]]["comment"]
+                    values_and_extra_comments = subsection[old_entries[i]]["value"].split('#', 1)
+                    values = values_and_extra_comments[0].rstrip()
+                    extra_comments = '' if len(values_and_extra_comments) == 1 else " #" + values_and_extra_comments[1]
+
                     # Delete the old entry
-                    use_limiter = subsection[old_entries[i]]["value"]
                     del subsection[old_entries[i]]
 
-                    # If limiter is used, then set the value of the new entry to "bound preserving"
-                    if use_limiter == "true":
-                        subsection[new_entries[i]] = {"comment"         : "", 
-                                                      "value"           : "bound preserving",  
-                                                      "type"            : "parameter", 
-                                                      "alignment spaces": 1}
+                    new_values = ''
+                    if i == 0:
+                        # For temperature field, the parameter value is a boolean
+                        new_values = "bound preserving" if values == "true" else "none"
+
+                    else:
+                        # For compositional fields, the parameter value may be a boolean or 
+                        # a list of booleans.
+                        split_values = values.split(',')
+                        for i in range(0, len(split_values)):
+                            if split_values[i] == "true":
+                                new_values += "bound preserving"
+                            else:
+                                new_values += "none"
+
+                            if i < len(split_values)-1:
+                                new_values += ", "
+                        
+                    # append the new values with the extra comments
+                    new_values += extra_comments
+                    subsection[new_entries[i]] = {"comment"         : comments,
+                                                  "value"           : new_values,
+                                                  "type"            : "parameter",
+                                                  "alignment spaces": 1}
 
     return parameters
 

From 3c8173e532501368f94463603816b3e42040265d Mon Sep 17 00:00:00 2001
From: Yimin Jin <jinym@cea-igp.ac.cn>
Date: Sat, 27 Jul 2024 16:32:10 +0800
Subject: [PATCH 22/22] correct the parameter entries related with DG limiter

---
 .../solcx/compositional_fields/solcx_compositional_fields.prm  | 1 +
 benchmarks/solcx/compositional_fields/solcx_particles.prm      | 1 +
 tests/discontinuous_composition_bound_preserving_limiter.prm   | 1 +
 .../discontinuous_composition_bound_preserving_limiter_3d.prm  | 1 +
 ...us_composition_bound_preserving_limiter_selected_fields.prm | 3 +++
 tests/iterated_advection_and_stokes_DG.prm                     | 1 +
 6 files changed, 8 insertions(+)

diff --git a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm
index 959a224769a..19f189b6c0a 100644
--- a/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm
+++ b/benchmarks/solcx/compositional_fields/solcx_compositional_fields.prm
@@ -72,6 +72,7 @@ subsection Discretization
   subsection Stabilization parameters
     set Global composition maximum = 1, 1e6
     set Global composition minimum = -1, 1
+    set Limiter for discontinuous temperature solution = bound preserving # apply the limiter to the DG solutions
   end
 end
 
diff --git a/benchmarks/solcx/compositional_fields/solcx_particles.prm b/benchmarks/solcx/compositional_fields/solcx_particles.prm
index d12d68df74c..e742152af5c 100644
--- a/benchmarks/solcx/compositional_fields/solcx_particles.prm
+++ b/benchmarks/solcx/compositional_fields/solcx_particles.prm
@@ -55,6 +55,7 @@ subsection Discretization
   set Use discontinuous composition discretization = true
 
   subsection Stabilization parameters
+    set Limiter for discontinuous temperature solution = none # apply the limiter to the DG solutions
   end
 end
 
diff --git a/tests/discontinuous_composition_bound_preserving_limiter.prm b/tests/discontinuous_composition_bound_preserving_limiter.prm
index 22c01ef8073..b6c742644b7 100644
--- a/tests/discontinuous_composition_bound_preserving_limiter.prm
+++ b/tests/discontinuous_composition_bound_preserving_limiter.prm
@@ -95,5 +95,6 @@ subsection Discretization
   subsection Stabilization parameters
     set Global composition maximum = 1.0, 2.0
     set Global composition minimum = 0.0, 0.0
+    set Limiter for discontinuous temperature solution = bound preserving # apply the limiter to the DG solutions
   end
 end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter_3d.prm b/tests/discontinuous_composition_bound_preserving_limiter_3d.prm
index b46a3cc6d74..ec38cd80076 100644
--- a/tests/discontinuous_composition_bound_preserving_limiter_3d.prm
+++ b/tests/discontinuous_composition_bound_preserving_limiter_3d.prm
@@ -96,5 +96,6 @@ subsection Discretization
   subsection Stabilization parameters
     set Global composition maximum = 1.0
     set Global composition minimum = 0.0
+    set Limiter for discontinuous temperature solution = bound preserving # apply the limiter to the DG solutions
   end
 end
diff --git a/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm b/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm
index 9c09a91d4d6..46f333e7aff 100644
--- a/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm
+++ b/tests/discontinuous_composition_bound_preserving_limiter_selected_fields.prm
@@ -82,5 +82,8 @@ subsection Discretization
   subsection Stabilization parameters
     set Global composition maximum = 1.0, 1.0
     set Global composition minimum = 0.0, 0.0
+
+    # apply the limiter to the DG solution of field 1, but not field 2
+    set Limiter for discontinuous composition solution = bound preserving, none
   end
 end
diff --git a/tests/iterated_advection_and_stokes_DG.prm b/tests/iterated_advection_and_stokes_DG.prm
index 42e04d3c81a..beca90c7156 100644
--- a/tests/iterated_advection_and_stokes_DG.prm
+++ b/tests/iterated_advection_and_stokes_DG.prm
@@ -27,6 +27,7 @@ subsection Discretization
 
   subsection Stabilization parameters
     set beta  = 0.5
+    set Limiter for discontinuous temperature solution = none
   end
 end